diff --git a/CMakeLists.txt b/CMakeLists.txt index 718115043b..b3f2149f24 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -596,25 +596,38 @@ endif() if(CAPSTONE_RISCV_SUPPORT) add_definitions(-DCAPSTONE_HAS_RISCV) set(SOURCES_RISCV + arch/RISCV/RISCVBaseInfo.c arch/RISCV/RISCVDisassembler.c + arch/RISCV/RISCVDisassemblerExtension.c arch/RISCV/RISCVInstPrinter.c arch/RISCV/RISCVMapping.c arch/RISCV/RISCVModule.c ) set(HEADERS_RISCV arch/RISCV/RISCVBaseInfo.h - arch/RISCV/RISCVDisassembler.h + arch/RISCV/RISCVDisassemblerExtension.h arch/RISCV/RISCVInstPrinter.h arch/RISCV/RISCVMapping.h arch/RISCV/RISCVModule.h + arch/RISCV/RISCVLinkage.h arch/RISCV/RISCVGenAsmWriter.inc + arch/RISCV/RISCVGenCSAliasMnemMap.inc + arch/RISCV/RISCVGenCSFeatureName.inc + arch/RISCV/RISCVGenCSMappingInsn.inc + arch/RISCV/RISCVGenCSMappingInsnName.inc + arch/RISCV/RISCVGenCSMappingInsnOp.inc + arch/RISCV/RISCVGenCSOpGroup.inc + arch/RISCV/RISCVGenCSSystemOperandsEnum.inc arch/RISCV/RISCVGenDisassemblerTables.inc - arch/RISCV/RISCVGenInsnNameMaps.inc arch/RISCV/RISCVGenInstrInfo.inc arch/RISCV/RISCVGenRegisterInfo.inc arch/RISCV/RISCVGenSubtargetInfo.inc - arch/RISCV/RISCVMappingInsn.inc - arch/RISCV/RISCVMappingInsnOp.inc + arch/RISCV/RISCVGenSystemOperands.inc + arch/RISCV/RISCVGenCompressedInstructionsInfo.inc + arch/RISCV/RISCVGenCSAliasEnum.inc + arch/RISCV/RISCVGenCSFeatureEnum.inc + arch/RISCV/RISCVGenCSInsnEnum.inc + arch/RISCV/RISCVGenCSRegEnum.inc ) endif() diff --git a/MCInstPrinter.c b/MCInstPrinter.c index 20613283f5..75c6e4fca3 100644 --- a/MCInstPrinter.c +++ b/MCInstPrinter.c @@ -11,6 +11,7 @@ extern bool Mips_getFeatureBits(unsigned int mode, unsigned int feature); extern bool AArch64_getFeatureBits(unsigned int mode, unsigned int feature); extern bool TriCore_getFeatureBits(unsigned int mode, unsigned int feature); extern bool Sparc_getFeatureBits(unsigned int mode, unsigned int feature); +extern bool RISCV_getFeatureBits(unsigned int mode, unsigned int feature); static bool testFeatureBits(const MCInst *MI, uint32_t Value) { @@ -42,8 +43,13 @@ static bool testFeatureBits(const MCInst *MI, uint32_t Value) #ifdef CAPSTONE_HAS_SPARC case CS_ARCH_SPARC: return Sparc_getFeatureBits(MI->csh->mode, Value); +#endif +#ifdef CAPSTONE_HAS_RISCV + case CS_ARCH_RISCV: + return RISCV_getFeatureBits(MI->csh->mode, Value); #endif } + } static bool matchAliasCondition(MCInst *MI, const MCRegisterInfo *MRI, diff --git a/Mapping.h b/Mapping.h index fe17062e2d..5f4096d701 100644 --- a/Mapping.h +++ b/Mapping.h @@ -48,7 +48,7 @@ unsigned short insn_find(const insn_map *m, unsigned int max, unsigned int id, unsigned int find_cs_id(unsigned MC_Opcode, const insn_map *imap, unsigned imap_size); -#define MAX_NO_DATA_TYPES 16 +#define MAX_NO_DATA_TYPES 32 ///< A LLVM<->CS Mapping entry of an MCOperand. typedef struct { diff --git a/MathExtras.h b/MathExtras.h index 65f4121222..6373db8576 100644 --- a/MathExtras.h +++ b/MathExtras.h @@ -62,6 +62,15 @@ static inline bool isIntN(unsigned N, int64_t x) (-(INT64_C(1) << (N - 1)) <= x && x < (INT64_C(1) << (N - 1))); } +/// isShiftedIntN - Checks if a signed integer is an N bit number shifted left by S. +static inline bool isShiftedIntN(unsigned N, unsigned S, int64_t x) { + return isIntN(N + S, x) && (x % (UINT64_C(1) << S) == 0); +} + +static inline bool isShiftedUIntN(unsigned N, unsigned S, uint64_t x) { + return isUIntN(N + S, x) && (x % (UINT64_C(1) << S) == 0); +} + /// isMask_32 - This function returns true if the argument is a sequence of ones /// starting at the least significant bit with the remainder zero (32 bit /// version). Ex. isMask_32(0x0000FFFFU) == true. diff --git a/SStream.c b/SStream.c index 07824f28ab..c2f6b94632 100644 --- a/SStream.c +++ b/SStream.c @@ -506,6 +506,13 @@ void printFloat(SStream *ss, float val) SStream_concat(ss, "%e", val); } +void printfFloat(SStream *ss, const char* fmt, float val) +{ + assert(ss); + SSTREAM_RETURN_IF_CLOSED(ss); + SStream_concat(ss, fmt, val); +} + void printFloatBang(SStream *ss, float val) { assert(ss); diff --git a/SStream.h b/SStream.h index 77e3065d4a..5d948df044 100644 --- a/SStream.h +++ b/SStream.h @@ -94,6 +94,8 @@ void printInt32BangDec(SStream *O, int32_t val); void printFloat(SStream *O, float val); +void printfFloat(SStream *ss, const char* fmt, float val); + void printFloatBang(SStream *O, float val); void printExpr(SStream *O, uint64_t val); diff --git a/arch/RISCV/RISCVBaseInfo.c b/arch/RISCV/RISCVBaseInfo.c new file mode 100644 index 0000000000..e113427d74 --- /dev/null +++ b/arch/RISCV/RISCVBaseInfo.c @@ -0,0 +1,143 @@ +/* Capstone Disassembly Engine, http://www.capstone-engine.org */ +/* By Nguyen Anh Quynh , 2013-2022, */ +/* Rot127 2022-2023 */ +/* Automatically translated source file from LLVM. */ + +/* LLVM-commit: */ +/* LLVM-tag: */ + +/* Only small edits allowed. */ +/* For multiple similar edits, please create a Patch for the translator. */ + +/* Capstone's C++ file translator: */ +/* https://github.com/capstone-engine/capstone/tree/next/suite/auto-sync */ + +//===-- RISCVBaseInfo.cpp - Top level definitions for RISC-V MC -----------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +// +// This file contains small standalone enum definitions for the RISC-V target +// useful for the compiler back-end and the MC libraries. +// +//===----------------------------------------------------------------------===// + +#include +#include +#include +#include + +#include "RISCVBaseInfo.h" + +#define CONCAT(a, b) CONCAT_(a, b) +#define CONCAT_(a, b) a##_##b + +typedef struct { + unsigned value; + bool isFractional; +} VLMULDecodeResult; +VLMULDecodeResult decodeVLMUL(RISCVII_VLMUL VLMUL) +{ + switch (VLMUL) { + default: + CS_ASSERT(0 && "Unexpected LMUL value!"); + case RISCVII_LMUL_1: + case RISCVII_LMUL_2: + case RISCVII_LMUL_4: + case RISCVII_LMUL_8: { + VLMULDecodeResult result = { + .value = 1 << (unsigned)(VLMUL), + .isFractional = false + }; + return result; + } + case RISCVII_LMUL_F2: + case RISCVII_LMUL_F4: + case RISCVII_LMUL_F8: { + VLMULDecodeResult result = { + .value = 1 << (8 - (unsigned)(VLMUL)), + .isFractional = true + }; + return result; + } + } +} + +void printVType(unsigned VType, SStream *OS) +{ + unsigned Sew = RISCVVType_getSEW(VType); + SStream_concat(OS, "%s", "e"); + printUInt64(OS, Sew); + + unsigned LMul; + bool Fractional; + VLMULDecodeResult result = decodeVLMUL(RISCVVType_getVLMUL(VType)); + LMul = result.value; + Fractional = result.isFractional; + + if (Fractional) + SStream_concat0(OS, ", mf"); + else + SStream_concat0(OS, ", m"); + printUInt64(OS, LMul); + + if (RISCVVType_isTailAgnostic(VType)) + SStream_concat0(OS, ", ta"); + else + SStream_concat0(OS, ", tu"); + + if (RISCVVType_isMaskAgnostic(VType)) + SStream_concat0(OS, ", ma"); + else + SStream_concat0(OS, ", mu"); +} + +typedef struct { + uint8_t first; + uint8_t second; +} LoadFP32ImmArrElement; + +// Lookup table for fli.s for entries 2-31. +static const LoadFP32ImmArrElement LoadFP32ImmArr[] = { + { 0b01101111, 0b00 }, { 0b01110000, 0b00 }, { 0b01110111, 0b00 }, + { 0b01111000, 0b00 }, { 0b01111011, 0b00 }, { 0b01111100, 0b00 }, + { 0b01111101, 0b00 }, { 0b01111101, 0b01 }, { 0b01111101, 0b10 }, + { 0b01111101, 0b11 }, { 0b01111110, 0b00 }, { 0b01111110, 0b01 }, + { 0b01111110, 0b10 }, { 0b01111110, 0b11 }, { 0b01111111, 0b00 }, + { 0b01111111, 0b01 }, { 0b01111111, 0b10 }, { 0b01111111, 0b11 }, + { 0b10000000, 0b00 }, { 0b10000000, 0b01 }, { 0b10000000, 0b10 }, + { 0b10000001, 0b00 }, { 0b10000010, 0b00 }, { 0b10000011, 0b00 }, + { 0b10000110, 0b00 }, { 0b10000111, 0b00 }, { 0b10001110, 0b00 }, + { 0b10001111, 0b00 }, { 0b11111111, 0b00 }, { 0b11111111, 0b10 }, +}; + +float getFPImm(unsigned Imm) +{ + CS_ASSERT(Imm != 1 && Imm != 30 && Imm != 31 && + "Unsupported immediate"); + + // Entry 0 is -1.0, the only negative value. Entry 16 is 1.0. + uint32_t Sign = 0; + if (Imm == 0) { + Sign = 0b1; + Imm = 16; + } + + uint32_t Exp = LoadFP32ImmArr[Imm - 2].first; + uint32_t Mantissa = LoadFP32ImmArr[Imm - 2].second; + + uint32_t I = Sign << 31 | Exp << 23 | Mantissa << 21; + float result; + memcpy(&result, &I, sizeof(float)); + return result; +} + +void RISCVZC_printSpimm(int64_t Spimm, SStream *OS) +{ + printInt32(OS, Spimm); +} + +// namespace llvm diff --git a/arch/RISCV/RISCVBaseInfo.h b/arch/RISCV/RISCVBaseInfo.h index 704a39c563..d113665a2d 100644 --- a/arch/RISCV/RISCVBaseInfo.h +++ b/arch/RISCV/RISCVBaseInfo.h @@ -1,64 +1,126 @@ -//===-- RISCVBaseInfo.h - Top level definitions for RISCV MC ----*- C++ -*-===// -// -// The LLVM Compiler Infrastructure +/* Capstone Disassembly Engine, http://www.capstone-engine.org */ +/* By Nguyen Anh Quynh , 2013-2022, */ +/* Rot127 2022-2023 */ +/* Automatically translated source file from LLVM. */ + +/* LLVM-commit: */ +/* LLVM-tag: */ + +/* Only small edits allowed. */ +/* For multiple similar edits, please create a Patch for the translator. */ + +/* Capstone's C++ file translator: */ +/* https://github.com/capstone-engine/capstone/tree/next/suite/auto-sync */ + +//===-- RISCVBaseInfo.h - Top level definitions for RISC-V MC ---*- C++ -*-===// // -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // -// This file contains small standalone enum definitions for the RISCV target +// This file contains small standalone enum definitions for the RISC-V target // useful for the compiler back-end and the MC libraries. // //===----------------------------------------------------------------------===// -#ifndef CS_RISCVBASEINFO_H -#define CS_RISCVBASEINFO_H -#include "../../cs_priv.h" +#ifndef LLVM_LIB_TARGET_RISCV_MCTARGETDESC_RISCVBASEINFO_H +#define LLVM_LIB_TARGET_RISCV_MCTARGETDESC_RISCVBASEINFO_H -//#include "RISCVMCTargetDesc.h" +#include +#include +#include +#include + +#include "../../utils.h" + +#define CONCAT(a, b) CONCAT_(a, b) +#define CONCAT_(a, b) a##_##b // RISCVII - This namespace holds all of the target specific flags that // instruction info tracks. All definitions must match RISCVInstrFormats.td. -enum { - IRISCVII_InstFormatPseudo = 0, - IRISCVII_InstFormatR = 1, - IRISCVII_InstFormatR4 = 2, - IRISCVII_InstFormatI = 3, - IRISCVII_InstFormatS = 4, - IRISCVII_InstFormatB = 5, - IRISCVII_InstFormatU = 6, - IRISCVII_InstFormatJ = 7, - IRISCVII_InstFormatCR = 8, - IRISCVII_InstFormatCI = 9, - IRISCVII_InstFormatCSS = 10, - IRISCVII_InstFormatCIW = 11, - IRISCVII_InstFormatCL = 12, - IRISCVII_InstFormatCS = 13, - IRISCVII_InstFormatCA = 14, - IRISCVII_InstFormatCB = 15, - IRISCVII_InstFormatCJ = 16, - IRISCVII_InstFormatOther = 17, - - IRISCVII_InstFormatMask = 31 -}; +// CS namespace begin: RISCVII +// RISC-V Specific Machine Operand Flags enum { - RISCVII_MO_None, - RISCVII_MO_LO, - RISCVII_MO_HI, - RISCVII_MO_PCREL_HI, + RISCVII_MO_None = 0, + RISCVII_MO_CALL = 1, + RISCVII_MO_LO = 3, + RISCVII_MO_HI = 4, + RISCVII_MO_PCREL_LO = 5, + RISCVII_MO_PCREL_HI = 6, + RISCVII_MO_GOT_HI = 7, + RISCVII_MO_TPREL_LO = 8, + RISCVII_MO_TPREL_HI = 9, + RISCVII_MO_TPREL_ADD = 10, + RISCVII_MO_TLS_GOT_HI = 11, + RISCVII_MO_TLS_GD_HI = 12, + RISCVII_MO_TLSDESC_HI = 13, + RISCVII_MO_TLSDESC_LOAD_LO = 14, + RISCVII_MO_TLSDESC_ADD_LO = 15, + RISCVII_MO_TLSDESC_CALL = 16, + + // Used to differentiate between target-specific "direct" flags and "bitmask" + // flags. A machine operand can only have one "direct" flag, but can have + // multiple "bitmask" flags. + RISCVII_MO_DIRECT_FLAG_MASK = 31 }; +typedef enum OperandType { + RISCVOp_OPERAND_FIRST_RISCV_IMM = MCOI_OPERAND_FIRST_TARGET, + RISCVOp_OPERAND_UIMM1 = RISCVOp_OPERAND_FIRST_RISCV_IMM, + RISCVOp_OPERAND_UIMM2, + RISCVOp_OPERAND_UIMM2_LSB0, + RISCVOp_OPERAND_UIMM3, + RISCVOp_OPERAND_UIMM4, + RISCVOp_OPERAND_UIMM5, + RISCVOp_OPERAND_UIMM6, + RISCVOp_OPERAND_UIMM7, + RISCVOp_OPERAND_UIMM7_LSB00, + RISCVOp_OPERAND_UIMM8_LSB00, + RISCVOp_OPERAND_UIMM8, + RISCVOp_OPERAND_UIMM8_LSB000, + RISCVOp_OPERAND_UIMM8_GE32, + RISCVOp_OPERAND_UIMM9_LSB000, + RISCVOp_OPERAND_UIMM10_LSB00_NONZERO, + RISCVOp_OPERAND_UIMM12, + RISCVOp_OPERAND_ZERO, + RISCVOp_OPERAND_SIMM5, + RISCVOp_OPERAND_SIMM5_PLUS1, + RISCVOp_OPERAND_SIMM6, + RISCVOp_OPERAND_SIMM6_NONZERO, + RISCVOp_OPERAND_SIMM10_LSB0000_NONZERO, + RISCVOp_OPERAND_SIMM12, + RISCVOp_OPERAND_SIMM12_LSB00000, + RISCVOp_OPERAND_UIMM20, + RISCVOp_OPERAND_UIMMLOG2XLEN, + RISCVOp_OPERAND_UIMMLOG2XLEN_NONZERO, + RISCVOp_OPERAND_CLUI_IMM, + RISCVOp_OPERAND_VTYPEI10, + RISCVOp_OPERAND_VTYPEI11, + RISCVOp_OPERAND_RVKRNUM, + RISCVOp_OPERAND_RVKRNUM_0_7, + RISCVOp_OPERAND_RVKRNUM_1_10, + RISCVOp_OPERAND_RVKRNUM_2_14, + OPERAND_LAST_RISCV_IMM = RISCVOp_OPERAND_RVKRNUM_2_14, + // Operand is either a register or uimm5, this is used by V extension pseudo + // instructions to represent a value that be passed as AVL to either vsetvli + // or vsetivli. + RISCVOp_OPERAND_AVL, +} RISCVOp_OperandType; + // Describes the predecessor/successor bits used in the FENCE instruction. -enum FenceField { + +typedef enum FenceField { RISCVFenceField_I = 8, RISCVFenceField_O = 4, RISCVFenceField_R = 2, RISCVFenceField_W = 1 -}; +} RISCVFenceField_FenceField; // Describes the supported floating point rounding mode encodings. -enum RoundingMode { + +typedef enum RoundingMode { RISCVFPRndMode_RNE = 0, RISCVFPRndMode_RTZ = 1, RISCVFPRndMode_RDN = 2, @@ -66,9 +128,25 @@ enum RoundingMode { RISCVFPRndMode_RMM = 4, RISCVFPRndMode_DYN = 7, RISCVFPRndMode_Invalid -}; +} RISCVFPRndMode_RoundingMode; -inline static const char *roundingModeToString(enum RoundingMode RndMode) +inline static bool RISCVFPRndMode_isValidRoundingMode(unsigned Mode) +{ + switch (Mode) { + default: + return false; + case RISCVFPRndMode_RNE: + case RISCVFPRndMode_RTZ: + case RISCVFPRndMode_RDN: + case RISCVFPRndMode_RUP: + case RISCVFPRndMode_RMM: + case RISCVFPRndMode_DYN: + return true; + } +} + +inline static const char* +RISCVFPRndMode_roundingModeToString(unsigned RndMode) { switch (RndMode) { default: @@ -88,19 +166,136 @@ inline static const char *roundingModeToString(enum RoundingMode RndMode) } } -inline static bool RISCVFPRndMode_isValidRoundingMode(unsigned Mode) +inline static bool RISCVVType_isTailAgnostic(unsigned VType) { - switch (Mode) { - default: - return false; - case RISCVFPRndMode_RNE: - case RISCVFPRndMode_RTZ: - case RISCVFPRndMode_RDN: - case RISCVFPRndMode_RUP: - case RISCVFPRndMode_RMM: - case RISCVFPRndMode_DYN: - return true; + return VType & 0x40; +} + +inline static bool RISCVVType_isMaskAgnostic(unsigned VType) +{ + return VType & 0x80; +} + + +typedef enum RLISTENCODE { + RISCVZC_RLISTENCODE_RA = 4, + RISCVZC_RLISTENCODE_RA_S0, + RISCVZC_RLISTENCODE_RA_S0_S1, + RISCVZC_RLISTENCODE_RA_S0_S2, + RISCVZC_RLISTENCODE_RA_S0_S3, + RISCVZC_RLISTENCODE_RA_S0_S4, + RISCVZC_RLISTENCODE_RA_S0_S5, + RISCVZC_RLISTENCODE_RA_S0_S6, + RISCVZC_RLISTENCODE_RA_S0_S7, + RISCVZC_RLISTENCODE_RA_S0_S8, + RISCVZC_RLISTENCODE_RA_S0_S9, + // note - to include s10, s11 must also be included + RISCVZC_RLISTENCODE_RA_S0_S11, + RISCVZC_RLISTENCODE_INVALID_RLIST, +} RISCVZC_RLISTENCODE; + + +inline static unsigned RISCVZC_getStackAdjBase(unsigned RlistVal, bool IsRV64, + bool IsEABI) +{ + CS_ASSERT(RlistVal != RISCVZC_RLISTENCODE_INVALID_RLIST && + "{ra, s0-s10} is not supported, s11 must be included."); + if (IsEABI) + return 16; + if (!IsRV64) { + switch (RlistVal) { + case RISCVZC_RLISTENCODE_RA: + case RISCVZC_RLISTENCODE_RA_S0: + case RISCVZC_RLISTENCODE_RA_S0_S1: + case RISCVZC_RLISTENCODE_RA_S0_S2: + return 16; + case RISCVZC_RLISTENCODE_RA_S0_S3: + case RISCVZC_RLISTENCODE_RA_S0_S4: + case RISCVZC_RLISTENCODE_RA_S0_S5: + case RISCVZC_RLISTENCODE_RA_S0_S6: + return 32; + case RISCVZC_RLISTENCODE_RA_S0_S7: + case RISCVZC_RLISTENCODE_RA_S0_S8: + case RISCVZC_RLISTENCODE_RA_S0_S9: + return 48; + case RISCVZC_RLISTENCODE_RA_S0_S11: + return 64; + } + } else { + switch (RlistVal) { + case RISCVZC_RLISTENCODE_RA: + case RISCVZC_RLISTENCODE_RA_S0: + return 16; + case RISCVZC_RLISTENCODE_RA_S0_S1: + case RISCVZC_RLISTENCODE_RA_S0_S2: + return 32; + case RISCVZC_RLISTENCODE_RA_S0_S3: + case RISCVZC_RLISTENCODE_RA_S0_S4: + return 48; + case RISCVZC_RLISTENCODE_RA_S0_S5: + case RISCVZC_RLISTENCODE_RA_S0_S6: + return 64; + case RISCVZC_RLISTENCODE_RA_S0_S7: + case RISCVZC_RLISTENCODE_RA_S0_S8: + return 80; + case RISCVZC_RLISTENCODE_RA_S0_S9: + return 96; + case RISCVZC_RLISTENCODE_RA_S0_S11: + return 112; + } } + CS_ASSERT(0 && "Unexpected RlistVal"); + return 0; // unreachable +} + +typedef enum VLMUL { + RISCVII_LMUL_1 = 0, + RISCVII_LMUL_2, + RISCVII_LMUL_4, + RISCVII_LMUL_8, + RISCVII_LMUL_RESERVED, + RISCVII_LMUL_F8, + RISCVII_LMUL_F4, + RISCVII_LMUL_F2 +} RISCVII_VLMUL; + +inline static RISCVII_VLMUL RISCVVType_getVLMUL(unsigned VType) +{ + unsigned VLMUL = VType & 0x7; + return (RISCVII_VLMUL)(VLMUL); +} + +inline static unsigned RISCVVType_decodeVSEW(unsigned VSEW) +{ + CS_ASSERT(VSEW < 8 && "Unexpected VSEW value"); + return 1 << (VSEW + 3); } +inline static unsigned RISCVVType_getSEW(unsigned VType) +{ + unsigned VSEW = (VType >> 3) & 0x7; + return RISCVVType_decodeVSEW(VSEW); +} + +typedef struct { + unsigned raw_val; +} RegVal; + +typedef struct SysReg { + const char *Name; + RegVal val1; + const char *AltName; + RegVal val2; + const char *DeprecatedName; + unsigned Encoding; + unsigned DummyFeatureArray[1]; + bool isRV32Only; +} RISCV_SysReg; + +void printVType(unsigned VType, SStream *OS); + +float getFPImm(unsigned Imm); + +void RISCVZC_printSpimm(int64_t Spimm, SStream *OS); + #endif diff --git a/arch/RISCV/RISCVDisassembler.c b/arch/RISCV/RISCVDisassembler.c index 9e9ba9a620..6b4f17218c 100644 --- a/arch/RISCV/RISCVDisassembler.c +++ b/arch/RISCV/RISCVDisassembler.c @@ -1,450 +1,740 @@ -//===-- RISCVDisassembler.cpp - Disassembler for RISCV --------------------===// +/* Capstone Disassembly Engine, http://www.capstone-engine.org */ +/* By Nguyen Anh Quynh , 2013-2022, */ +/* Rot127 2022-2023 */ +/* Automatically translated source file from LLVM. */ + +/* LLVM-commit: */ +/* LLVM-tag: */ + +/* Only small edits allowed. */ +/* For multiple similar edits, please create a Patch for the translator. */ + +/* Capstone's C++ file translator: */ +/* https://github.com/capstone-engine/capstone/tree/next/suite/auto-sync */ + +//===-- RISCVDisassembler.cpp - Disassembler for RISC-V -------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // -// The LLVM Compiler Infrastructure +//===----------------------------------------------------------------------===// // -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. +// This file implements the RISCVDisassembler class. // //===----------------------------------------------------------------------===// -/* Capstone Disassembly Engine */ -/* RISC-V Backend By Rodrigo Cortes Porto & - Shawn Chang , HardenedLinux@2018 */ - -#ifdef CAPSTONE_HAS_RISCV - -#include // DEBUG -#include +#include #include - -#include "../../cs_priv.h" -#include "../../utils.h" +#include +#include #include "../../MCInst.h" -#include "../../MCInstrDesc.h" -#include "../../MCFixedLenDisassembler.h" -#include "../../MCRegisterInfo.h" -#include "../../MCDisassembler.h" #include "../../MathExtras.h" -#include "../../Mapping.h" +#include "../../MCInstPrinter.h" +#include "../../MCDisassembler.h" +#include "../../MCFixedLenDisassembler.h" +#include "../../cs_priv.h" +#include "../../utils.h" +#include "RISCVDisassemblerExtension.h" #include "RISCVBaseInfo.h" -#include "RISCVDisassembler.h" -/* Need the feature infos define in - RISCVGenSubtargetInfo.inc. */ #define GET_SUBTARGETINFO_ENUM #include "RISCVGenSubtargetInfo.inc" -/* When we specify the RISCV64 mode, It means It is RV64IMAFD. - Similar, RISCV32 means RV32IMAFD. -*/ -static uint64_t getFeatureBits(int mode) -{ - uint64_t ret = RISCV_FeatureStdExtM | RISCV_FeatureStdExtA | - RISCV_FeatureStdExtF | RISCV_FeatureStdExtD; - - if (mode & CS_MODE_RISCV64) - ret |= RISCV_Feature64Bit; - if (mode & CS_MODE_RISCVC) - ret |= RISCV_FeatureStdExtC; - - return ret; -} - #define GET_REGINFO_ENUM -#define GET_REGINFO_MC_DESC #include "RISCVGenRegisterInfo.inc" + #define GET_INSTRINFO_ENUM +#define GET_INSTRINFO_MC_DESC #include "RISCVGenInstrInfo.inc" -static const unsigned GPRDecoderTable[] = { - RISCV_X0, RISCV_X1, RISCV_X2, RISCV_X3, RISCV_X4, RISCV_X5, - RISCV_X6, RISCV_X7, RISCV_X8, RISCV_X9, RISCV_X10, RISCV_X11, - RISCV_X12, RISCV_X13, RISCV_X14, RISCV_X15, RISCV_X16, RISCV_X17, - RISCV_X18, RISCV_X19, RISCV_X20, RISCV_X21, RISCV_X22, RISCV_X23, - RISCV_X24, RISCV_X25, RISCV_X26, RISCV_X27, RISCV_X28, RISCV_X29, - RISCV_X30, RISCV_X31 -}; -static DecodeStatus DecodeGPRRegisterClass(MCInst *Inst, uint64_t RegNo, +#define CONCAT(a, b) CONCAT_(a, b) +#define CONCAT_(a, b) a##_##b + +#define DEBUG_TYPE "riscv-disassembler" + +DecodeStatus RISCV_getInstruction(MCInst *Instr, uint16_t *Size, const uint8_t *Bytes, + size_t BytesLen, uint64_t Address, + SStream *CStream); +void addSPOperands(MCInst *MI); +; +// end anonymous namespace + +static DecodeStatus DecodeGPRRegisterClass(MCInst *Inst, uint32_t RegNo, uint64_t Address, const void *Decoder) { - unsigned Reg = 0; + bool IsRVE = RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureRVE); - if (RegNo >= ARR_SIZE(GPRDecoderTable)) + if (RegNo >= 32 || (IsRVE && RegNo >= 16)) return MCDisassembler_Fail; - // We must define our own mapping from RegNo to register identifier. - // Accessing index RegNo in the register class will work in the case that - // registers were added in ascending order, but not in general. - Reg = GPRDecoderTable[RegNo]; - //Inst.addOperand(MCOperand::createReg(Reg)); - MCOperand_CreateReg0(Inst, Reg); + MCRegister Reg = RISCV_X0 + RegNo; + MCOperand_CreateReg0(Inst, (Reg)); return MCDisassembler_Success; } -static const unsigned FPR32DecoderTable[] = { - RISCV_F0_32, RISCV_F1_32, RISCV_F2_32, RISCV_F3_32, RISCV_F4_32, - RISCV_F5_32, RISCV_F6_32, RISCV_F7_32, RISCV_F8_32, RISCV_F9_32, - RISCV_F10_32, RISCV_F11_32, RISCV_F12_32, RISCV_F13_32, RISCV_F14_32, - RISCV_F15_32, RISCV_F16_32, RISCV_F17_32, RISCV_F18_32, RISCV_F19_32, - RISCV_F20_32, RISCV_F21_32, RISCV_F22_32, RISCV_F23_32, RISCV_F24_32, - RISCV_F25_32, RISCV_F26_32, RISCV_F27_32, RISCV_F28_32, RISCV_F29_32, - RISCV_F30_32, RISCV_F31_32 -}; +static DecodeStatus DecodeGPRX1X5RegisterClass(MCInst *Inst, uint32_t RegNo, + uint64_t Address, + const void *Decoder) +{ + MCRegister Reg = RISCV_X0 + RegNo; + if (Reg != RISCV_X1 && Reg != RISCV_X5) + return MCDisassembler_Fail; -static DecodeStatus DecodeFPR32RegisterClass(MCInst *Inst, uint64_t RegNo, + MCOperand_CreateReg0(Inst, (Reg)); + return MCDisassembler_Success; +} + +static DecodeStatus DecodeFPR16RegisterClass(MCInst *Inst, uint32_t RegNo, uint64_t Address, const void *Decoder) { - unsigned Reg = 0; + if (RegNo >= 32) + return MCDisassembler_Fail; + + MCRegister Reg = RISCV_F0_H + RegNo; + MCOperand_CreateReg0(Inst, (Reg)); + return MCDisassembler_Success; +} - if (RegNo >= ARR_SIZE(FPR32DecoderTable)) +static DecodeStatus DecodeFPR32RegisterClass(MCInst *Inst, uint32_t RegNo, + uint64_t Address, + const void *Decoder) +{ + if (RegNo >= 32) return MCDisassembler_Fail; - // We must define our own mapping from RegNo to register identifier. - // Accessing index RegNo in the register class will work in the case that - // registers were added in ascending order, but not in general. - Reg = FPR32DecoderTable[RegNo]; - MCOperand_CreateReg0(Inst, Reg); + MCRegister Reg = RISCV_F0_F + RegNo; + MCOperand_CreateReg0(Inst, (Reg)); return MCDisassembler_Success; } -static DecodeStatus DecodeFPR32CRegisterClass(MCInst *Inst, uint64_t RegNo, +static DecodeStatus DecodeFPR32CRegisterClass(MCInst *Inst, uint32_t RegNo, uint64_t Address, const void *Decoder) { - unsigned Reg = 0; - - if (RegNo > 8) + if (RegNo >= 8) { return MCDisassembler_Fail; - Reg = FPR32DecoderTable[RegNo + 8]; - MCOperand_CreateReg0(Inst, Reg); + } + MCRegister Reg = RISCV_F8_F + RegNo; + MCOperand_CreateReg0(Inst, (Reg)); return MCDisassembler_Success; } -static const unsigned FPR64DecoderTable[] = { - RISCV_F0_64, RISCV_F1_64, RISCV_F2_64, RISCV_F3_64, RISCV_F4_64, - RISCV_F5_64, RISCV_F6_64, RISCV_F7_64, RISCV_F8_64, RISCV_F9_64, - RISCV_F10_64, RISCV_F11_64, RISCV_F12_64, RISCV_F13_64, RISCV_F14_64, - RISCV_F15_64, RISCV_F16_64, RISCV_F17_64, RISCV_F18_64, RISCV_F19_64, - RISCV_F20_64, RISCV_F21_64, RISCV_F22_64, RISCV_F23_64, RISCV_F24_64, - RISCV_F25_64, RISCV_F26_64, RISCV_F27_64, RISCV_F28_64, RISCV_F29_64, - RISCV_F30_64, RISCV_F31_64 -}; - -static DecodeStatus DecodeFPR64RegisterClass(MCInst *Inst, uint64_t RegNo, +static DecodeStatus DecodeFPR64RegisterClass(MCInst *Inst, uint32_t RegNo, uint64_t Address, const void *Decoder) { - unsigned Reg = 0; - - if (RegNo >= ARR_SIZE(FPR64DecoderTable)) + if (RegNo >= 32) return MCDisassembler_Fail; - // We must define our own mapping from RegNo to register identifier. - // Accessing index RegNo in the register class will work in the case that - // registers were added in ascending order, but not in general. - Reg = FPR64DecoderTable[RegNo]; - MCOperand_CreateReg0(Inst, Reg); + MCRegister Reg = RISCV_F0_D + RegNo; + MCOperand_CreateReg0(Inst, (Reg)); return MCDisassembler_Success; } -static DecodeStatus DecodeFPR64CRegisterClass(MCInst *Inst, uint64_t RegNo, +static DecodeStatus DecodeFPR64CRegisterClass(MCInst *Inst, uint32_t RegNo, uint64_t Address, const void *Decoder) { - unsigned Reg = 0; - - if (RegNo > 8) + if (RegNo >= 8) { return MCDisassembler_Fail; - Reg = FPR64DecoderTable[RegNo + 8]; - MCOperand_CreateReg0(Inst, Reg); + } + MCRegister Reg = RISCV_F8_D + RegNo; + MCOperand_CreateReg0(Inst, (Reg)); return MCDisassembler_Success; } -static DecodeStatus DecodeGPRNoX0RegisterClass(MCInst *Inst, uint64_t RegNo, +static DecodeStatus DecodeGPRNoX0RegisterClass(MCInst *Inst, uint32_t RegNo, uint64_t Address, const void *Decoder) { - if (RegNo == 0) + if (RegNo == 0) { return MCDisassembler_Fail; + } + return DecodeGPRRegisterClass(Inst, RegNo, Address, Decoder); } static DecodeStatus DecodeGPRNoX0X2RegisterClass(MCInst *Inst, uint64_t RegNo, - uint64_t Address, + uint32_t Address, const void *Decoder) { - if (RegNo == 2) + if (RegNo == 2) { return MCDisassembler_Fail; + } + return DecodeGPRNoX0RegisterClass(Inst, RegNo, Address, Decoder); } -static DecodeStatus DecodeGPRCRegisterClass(MCInst *Inst, uint64_t RegNo, +static DecodeStatus DecodeGPRCRegisterClass(MCInst *Inst, uint32_t RegNo, uint64_t Address, const void *Decoder) { - unsigned Reg = 0; + if (RegNo >= 8) + return MCDisassembler_Fail; - if (RegNo > 8) + MCRegister Reg = RISCV_X8 + RegNo; + MCOperand_CreateReg0(Inst, (Reg)); + return MCDisassembler_Success; +} + +static DecodeStatus DecodeGPRPairRegisterClass(MCInst *Inst, uint32_t RegNo, + uint64_t Address, + const void *Decoder) +{ + if (RegNo >= 32 || RegNo & 1) return MCDisassembler_Fail; - Reg = GPRDecoderTable[RegNo + 8]; - MCOperand_CreateReg0(Inst, Reg); + MCRegister Reg = RISCV_X0 + RegNo; + MCOperand_CreateReg0(Inst, (Reg)); return MCDisassembler_Success; } -// Add implied SP operand for instructions *SP compressed instructions. The SP -// operand isn't explicitly encoded in the instruction. -static void addImplySP(MCInst *Inst, int64_t Address, const void *Decoder) +static DecodeStatus DecodeSR07RegisterClass(MCInst *Inst, uint64_t RegNo, + uint64_t Address, + const void *Decoder) { - if (MCInst_getOpcode(Inst) == RISCV_C_LWSP || - MCInst_getOpcode(Inst) == RISCV_C_SWSP || - MCInst_getOpcode(Inst) == RISCV_C_LDSP || - MCInst_getOpcode(Inst) == RISCV_C_SDSP || - MCInst_getOpcode(Inst) == RISCV_C_FLWSP || - MCInst_getOpcode(Inst) == RISCV_C_FSWSP || - MCInst_getOpcode(Inst) == RISCV_C_FLDSP || - MCInst_getOpcode(Inst) == RISCV_C_FSDSP || - MCInst_getOpcode(Inst) == RISCV_C_ADDI4SPN) { - DecodeGPRRegisterClass(Inst, 2, Address, Decoder); - } + if (RegNo >= 8) + return MCDisassembler_Fail; - if (MCInst_getOpcode(Inst) == RISCV_C_ADDI16SP) { - DecodeGPRRegisterClass(Inst, 2, Address, Decoder); - DecodeGPRRegisterClass(Inst, 2, Address, Decoder); - } + MCRegister Reg = (RegNo < 2) ? (RegNo + RISCV_X8) : + (RegNo - 2 + RISCV_X18); + MCOperand_CreateReg0(Inst, (Reg)); + return MCDisassembler_Success; } -static DecodeStatus decodeUImmOperand(MCInst *Inst, uint64_t Imm, - int64_t Address, const void *Decoder, - unsigned N) +static DecodeStatus DecodeVRRegisterClass(MCInst *Inst, uint32_t RegNo, + uint64_t Address, const void *Decoder) { - //CS_ASSERT(isUInt(Imm) && "Invalid immediate"); - addImplySP(Inst, Address, Decoder); - //Inst.addOperand(MCOperand::createImm(Imm)); - MCOperand_CreateImm0(Inst, Imm); + if (RegNo >= 32) + return MCDisassembler_Fail; + + MCRegister Reg = RISCV_V0 + RegNo; + MCOperand_CreateReg0(Inst, (Reg)); return MCDisassembler_Success; } -static DecodeStatus decodeUImmNonZeroOperand(MCInst *Inst, uint64_t Imm, - int64_t Address, - const void *Decoder, unsigned N) +static DecodeStatus DecodeVRM2RegisterClass(MCInst *Inst, uint32_t RegNo, + uint64_t Address, + const void *Decoder) { - if (Imm == 0) + if (RegNo >= 32 || RegNo % 2) return MCDisassembler_Fail; - return decodeUImmOperand(Inst, Imm, Address, Decoder, N); + + MCRegister Reg = MCRegisterInfo_getMatchingSuperReg(Inst->MRI, + RISCV_V0 + RegNo, RISCV_sub_vrm1_0, + MCRegisterInfo_getRegClass(Inst->MRI, RISCV_VRM2RegClassID)); + + MCOperand_CreateReg0(Inst, (Reg)); + return MCDisassembler_Success; } -static DecodeStatus decodeSImmOperand(MCInst *Inst, uint64_t Imm, - int64_t Address, const void *Decoder, - unsigned N) +static DecodeStatus DecodeVRM4RegisterClass(MCInst *Inst, uint32_t RegNo, + uint64_t Address, + const void *Decoder) { - //CS_ASSERT(isUInt(Imm) && "Invalid immediate"); - addImplySP(Inst, Address, Decoder); - // Sign-extend the number in the bottom N bits of Imm - //Inst.addOperand(MCOperand::createImm(SignExtend64(Imm))); - MCOperand_CreateImm0(Inst, SignExtend64(Imm, N)); + if (RegNo >= 32 || RegNo % 4) + return MCDisassembler_Fail; + + MCRegister Reg = MCRegisterInfo_getMatchingSuperReg(Inst->MRI, + RISCV_V0 + RegNo, RISCV_sub_vrm1_0, + MCRegisterInfo_getRegClass(Inst->MRI, RISCV_VRM4RegClassID)); + + MCOperand_CreateReg0(Inst, (Reg)); return MCDisassembler_Success; } -static DecodeStatus decodeSImmNonZeroOperand(MCInst *Inst, uint64_t Imm, - int64_t Address, - const void *Decoder, unsigned N) +static DecodeStatus DecodeVRM8RegisterClass(MCInst *Inst, uint32_t RegNo, + uint64_t Address, + const void *Decoder) { - if (Imm == 0) + if (RegNo >= 32 || RegNo % 8) return MCDisassembler_Fail; - return decodeSImmOperand(Inst, Imm, Address, Decoder, N); + + MCRegister Reg = MCRegisterInfo_getMatchingSuperReg(Inst->MRI, + RISCV_V0 + RegNo, RISCV_sub_vrm1_0, + MCRegisterInfo_getRegClass(Inst->MRI, RISCV_VRM8RegClassID)); + + MCOperand_CreateReg0(Inst, (Reg)); + return MCDisassembler_Success; } -static DecodeStatus decodeSImmOperandAndLsl1(MCInst *Inst, uint64_t Imm, - int64_t Address, - const void *Decoder, unsigned N) +static DecodeStatus decodeVMaskReg(MCInst *Inst, uint64_t RegNo, + uint64_t Address, const void *Decoder) { - //CS_ASSERT(isUInt(Imm) && "Invalid immediate"); - // Sign-extend the number in the bottom N bits of Imm after accounting for - // the fact that the N bit immediate is stored in N-1 bits (the LSB is - // always zero) - //Inst.addOperand(MCOperand::createImm(SignExtend64(Imm << 1))); - MCOperand_CreateImm0(Inst, SignExtend64(Imm << 1, N)); + if (RegNo > 2) { + return MCDisassembler_Fail; + } + MCRegister Reg = (RegNo == 0) ? RISCV_V0 : RISCV_NoRegister; + + MCOperand_CreateReg0(Inst, (Reg)); return MCDisassembler_Success; } -static DecodeStatus decodeCLUIImmOperand(MCInst *Inst, uint64_t Imm, +#define DEFINE_decodeUImmOperand(N) \ + static DecodeStatus CONCAT(decodeUImmOperand, \ + N)(MCInst * Inst, uint32_t Imm, \ + int64_t Address, const void *Decoder) \ + { \ + CS_ASSERT(isUIntN(N, Imm) && "Invalid immediate"); \ + MCOperand_CreateImm0(Inst, (Imm)); \ + return MCDisassembler_Success; \ + } +DEFINE_decodeUImmOperand(6); +DEFINE_decodeUImmOperand(2); +DEFINE_decodeUImmOperand(8); +DEFINE_decodeUImmOperand(9); +DEFINE_decodeUImmOperand(7); +DEFINE_decodeUImmOperand(4); +DEFINE_decodeUImmOperand(20); +DEFINE_decodeUImmOperand(5); +DEFINE_decodeUImmOperand(11); +DEFINE_decodeUImmOperand(10); +DEFINE_decodeUImmOperand(12); +DEFINE_decodeUImmOperand(3); +DEFINE_decodeUImmOperand(1); + +#define DEFINE_decodeUImmNonZeroOperand(N) \ + static DecodeStatus CONCAT(decodeUImmNonZeroOperand, \ + N)(MCInst * Inst, uint32_t Imm, \ + int64_t Address, const void *Decoder) \ + { \ + if (Imm == 0) \ + return MCDisassembler_Fail; \ + return CONCAT(decodeUImmOperand, N)(Inst, Imm, Address, \ + Decoder); \ + } +DEFINE_decodeUImmNonZeroOperand(10); + +#define DEFINE_decodeSImmOperand(N) \ + static DecodeStatus CONCAT(decodeSImmOperand, \ + N)(MCInst * Inst, uint32_t Imm, \ + int64_t Address, const void *Decoder) \ + { \ + CS_ASSERT(isUIntN(N, Imm) && "Invalid immediate"); \ +\ + MCOperand_CreateImm0(Inst, (SignExtend64((Imm), N))); \ + return MCDisassembler_Success; \ + } +DEFINE_decodeSImmOperand(6); +DEFINE_decodeSImmOperand(12); +DEFINE_decodeSImmOperand(5); +DEFINE_decodeSImmOperand(10); + +#define DEFINE_decodeSImmNonZeroOperand(N) \ + static DecodeStatus CONCAT(decodeSImmNonZeroOperand, \ + N)(MCInst * Inst, uint32_t Imm, \ + int64_t Address, const void *Decoder) \ + { \ + if (Imm == 0) \ + return MCDisassembler_Fail; \ + return CONCAT(decodeSImmOperand, N)(Inst, Imm, Address, \ + Decoder); \ + } +DEFINE_decodeSImmNonZeroOperand(6); +DEFINE_decodeSImmNonZeroOperand(10); + +#define DEFINE_decodeSImmOperandAndLsl1(N) \ + static DecodeStatus CONCAT(decodeSImmOperandAndLsl1, \ + N)(MCInst * Inst, uint32_t Imm, \ + int64_t Address, const void *Decoder) \ + { \ + CS_ASSERT(isUIntN(N, Imm) && "Invalid immediate"); \ +\ + MCOperand_CreateImm0(Inst, (SignExtend64((Imm << 1), N))); \ + return MCDisassembler_Success; \ + } +DEFINE_decodeSImmOperandAndLsl1(12); +DEFINE_decodeSImmOperandAndLsl1(9); +DEFINE_decodeSImmOperandAndLsl1(13); +DEFINE_decodeSImmOperandAndLsl1(21); + +static DecodeStatus decodeCLUIImmOperand(MCInst *Inst, uint32_t Imm, int64_t Address, const void *Decoder) { - //CS_ASSERT(isUInt<6>(Imm) && "Invalid immediate"); + CS_ASSERT(isUIntN(6, Imm) && "Invalid immediate"); if (Imm > 31) { - Imm = (SignExtend64(Imm, 6) & 0xfffff); + Imm = (SignExtend64((Imm), 6) & 0xfffff); } - //Inst.addOperand(MCOperand::createImm(Imm)); - MCOperand_CreateImm0(Inst, Imm); + MCOperand_CreateImm0(Inst, (Imm)); return MCDisassembler_Success; } -static DecodeStatus decodeFRMArg(MCInst *Inst, uint64_t Imm, int64_t Address, +static DecodeStatus decodeFRMArg(MCInst *Inst, uint32_t Imm, int64_t Address, const void *Decoder) { - //CS_ASSERT(isUInt<3>(Imm) && "Invalid immediate"); + CS_ASSERT(isUIntN(3, Imm) && "Invalid immediate"); if (!RISCVFPRndMode_isValidRoundingMode(Imm)) return MCDisassembler_Fail; - //Inst.addOperand(MCOperand::createImm(Imm)); - MCOperand_CreateImm0(Inst, Imm); + MCOperand_CreateImm0(Inst, (Imm)); return MCDisassembler_Success; } +static DecodeStatus decodeRVCInstrRdRs1ImmZero(MCInst *Inst, uint32_t Insn, + uint64_t Address, + const void *Decoder); + +static DecodeStatus decodeRVCInstrRdSImm(MCInst *Inst, uint32_t Insn, + uint64_t Address, const void *Decoder); + +static DecodeStatus decodeRVCInstrRdRs1UImm(MCInst *Inst, uint32_t Insn, + uint64_t Address, + const void *Decoder); + +static DecodeStatus decodeRVCInstrRdRs2(MCInst *Inst, uint32_t Insn, + uint64_t Address, const void *Decoder); + +static DecodeStatus decodeRVCInstrRdRs1Rs2(MCInst *Inst, uint32_t Insn, + uint64_t Address, + const void *Decoder); + +static DecodeStatus decodeXTHeadMemPair(MCInst *Inst, uint32_t Insn, + uint64_t Address, const void *Decoder); + +static DecodeStatus decodeZcmpRlist(MCInst *Inst, unsigned Imm, + uint64_t Address, const void *Decoder); + +static DecodeStatus decodeRegReg(MCInst *Inst, uint32_t Insn, uint64_t Address, + const void *Decoder); + +static DecodeStatus decodeZcmpSpimm(MCInst *Inst, unsigned Imm, + uint64_t Address, const void *Decoder); + +static DecodeStatus decodeCSSPushPopchk(MCInst *Inst, uint32_t Insn, + uint64_t Address, const void *Decoder); + +static DecodeStatus decodeUImmLog2XLenOperand(MCInst *Inst, uint32_t Imm, + int64_t Address, + const void *Decoder) + { + CS_ASSERT(isUIntN(6, Imm) && "Invalid immediate"); + + if (!RISCV_getFeatureBits(Inst->csh->mode, RISCV_Feature64Bit) && + !isUIntN(5, Imm)) + return MCDisassembler_Fail; + + MCOperand_CreateImm0(Inst, (Imm)); + return MCDisassembler_Success; + } + +static DecodeStatus decodeUImmLog2XLenNonZeroOperand(MCInst *Inst, uint32_t Imm, + int64_t Address, + const void *Decoder) + { + if (Imm == 0) + return MCDisassembler_Fail; + return decodeUImmLog2XLenOperand(Inst, Imm, Address, Decoder); + } + #include "RISCVGenDisassemblerTables.inc" -static void init_MI_insn_detail(MCInst *MI) +static DecodeStatus decodeRVCInstrRdRs1ImmZero(MCInst *Inst, uint32_t Insn, + uint64_t Address, + const void *Decoder) { - if (MI->flat_insn->detail) { - memset(MI->flat_insn->detail, 0, sizeof(cs_detail)); - } + uint32_t Rd = fieldFromInstruction_4(Insn, 7, 5); + DecodeStatus Result = + DecodeGPRNoX0RegisterClass(Inst, Rd, Address, Decoder); + (void)Result; + CS_ASSERT(Result == MCDisassembler_Success && "Invalid register"); + MCInst_addOperand2(Inst, (MCInst_getOperand(Inst, (0)))); + MCOperand_CreateImm0(Inst, (0)); + return MCDisassembler_Success; +} - return; +static DecodeStatus decodeCSSPushPopchk(MCInst *Inst, uint32_t Insn, + uint64_t Address, const void *Decoder) +{ + uint32_t Rs1 = fieldFromInstruction_4(Insn, 7, 5); + DecodeStatus Result = + DecodeGPRX1X5RegisterClass(Inst, Rs1, Address, Decoder); + (void)Result; + CS_ASSERT(Result == MCDisassembler_Success && "Invalid register"); + return MCDisassembler_Success; } -// mark the load/store instructions through the opcode. -static void markLSInsn(MCInst *MI, uint32_t in) +static DecodeStatus decodeRVCInstrRdSImm(MCInst *Inst, uint32_t Insn, + uint64_t Address, const void *Decoder) { - /* - I ld 0000011 = 0x03 - st 0100011 = 0x23 - F/D ld 0000111 = 0x07 - st 0100111 = 0x27 - st 0101111 = 0x2f - */ -#define MASK_LS_INSN 0x0000007f - uint32_t opcode = in & MASK_LS_INSN; - if (0 == (opcode ^ 0x03) || 0 == (opcode ^ 0x07) || - 0 == (opcode ^ 0x23) || 0 == (opcode ^ 0x27) || - 0 == (opcode ^ 0x2f)) - MI->flat_insn->detail->riscv.need_effective_addr = true; -#undef MASK_LS_INSN - return; -} - -static void markCLSInsn(MCInst *MI, uint32_t in) + MCOperand_CreateReg0(Inst, (RISCV_X0)); + uint32_t SImm6 = fieldFromInstruction_4(Insn, 12, 1) << 5 | + fieldFromInstruction_4(Insn, 2, 5); + DecodeStatus Result = + CONCAT(decodeSImmOperand, 6)(Inst, SImm6, Address, Decoder); + (void)Result; + CS_ASSERT(Result == MCDisassembler_Success && "Invalid immediate"); + return MCDisassembler_Success; +} + +static DecodeStatus decodeRVCInstrRdRs1UImm(MCInst *Inst, uint32_t Insn, + uint64_t Address, + const void *Decoder) { - // Unfortunately there is no obvious pattern in terms of RISC-V C instructions - // Thus, we compare the instruction IDs to see if it is a load/store instruction - unsigned id = MCInst_getOpcode(MI); - if (id == RISCV_C_FLD || id == RISCV_C_LW || id == RISCV_C_FLW || - id == RISCV_C_LD || id == RISCV_C_FSD || id == RISCV_C_SW || - id == RISCV_C_FSW || id == RISCV_C_SD || id == RISCV_C_FLDSP || - id == RISCV_C_LWSP || id == RISCV_C_FLWSP || id == RISCV_C_LDSP || - id == RISCV_C_FSDSP || id == RISCV_C_SWSP || id == RISCV_C_FSWSP || - id == RISCV_C_SDSP) { - RISCV_get_detail(MI)->need_effective_addr = true; - } - return; + MCOperand_CreateReg0(Inst, (RISCV_X0)); + MCInst_addOperand2(Inst, (MCInst_getOperand(Inst, (0)))); + uint32_t UImm6 = fieldFromInstruction_4(Insn, 12, 1) << 5 | + fieldFromInstruction_4(Insn, 2, 5); + DecodeStatus Result = + CONCAT(decodeUImmOperand, 6)(Inst, UImm6, Address, Decoder); + (void)Result; + CS_ASSERT(Result == MCDisassembler_Success && "Invalid immediate"); + return MCDisassembler_Success; } -static DecodeStatus -RISCVDisassembler_getInstruction(int mode, MCInst *MI, const uint8_t *code, - size_t code_len, uint16_t *Size, - uint64_t Address, MCRegisterInfo *MRI) +static DecodeStatus decodeRVCInstrRdRs2(MCInst *Inst, uint32_t Insn, + uint64_t Address, const void *Decoder) +{ + uint32_t Rd = fieldFromInstruction_4(Insn, 7, 5); + uint32_t Rs2 = fieldFromInstruction_4(Insn, 2, 5); + DecodeGPRRegisterClass(Inst, Rd, Address, Decoder); + DecodeGPRRegisterClass(Inst, Rs2, Address, Decoder); + return MCDisassembler_Success; +} + +static DecodeStatus decodeRVCInstrRdRs1Rs2(MCInst *Inst, uint32_t Insn, + uint64_t Address, + const void *Decoder) +{ + uint32_t Rd = fieldFromInstruction_4(Insn, 7, 5); + uint32_t Rs2 = fieldFromInstruction_4(Insn, 2, 5); + DecodeGPRRegisterClass(Inst, Rd, Address, Decoder); + MCInst_addOperand2(Inst, (MCInst_getOperand(Inst, (0)))); + DecodeGPRRegisterClass(Inst, Rs2, Address, Decoder); + return MCDisassembler_Success; +} + +static DecodeStatus decodeXTHeadMemPair(MCInst *Inst, uint32_t Insn, + uint64_t Address, const void *Decoder) +{ + uint32_t Rd1 = fieldFromInstruction_4(Insn, 7, 5); + uint32_t Rs1 = fieldFromInstruction_4(Insn, 15, 5); + uint32_t Rd2 = fieldFromInstruction_4(Insn, 20, 5); + uint32_t UImm2 = fieldFromInstruction_4(Insn, 25, 2); + DecodeGPRRegisterClass(Inst, Rd1, Address, Decoder); + DecodeGPRRegisterClass(Inst, Rd2, Address, Decoder); + DecodeGPRRegisterClass(Inst, Rs1, Address, Decoder); + DecodeStatus Result = + CONCAT(decodeUImmOperand, 2)(Inst, UImm2, Address, Decoder); + (void)Result; + CS_ASSERT(Result == MCDisassembler_Success && "Invalid immediate"); + + // Disassemble the final operand which is implicit. + unsigned Opcode = MCInst_getOpcode(Inst); + bool IsWordOp = (Opcode == RISCV_TH_LWD || Opcode == RISCV_TH_LWUD || + Opcode == RISCV_TH_SWD); + if (IsWordOp) + MCOperand_CreateImm0(Inst, (3)); + else + MCOperand_CreateImm0(Inst, (4)); + + return MCDisassembler_Success; +} + +static DecodeStatus decodeZcmpRlist(MCInst *Inst, unsigned Imm, + uint64_t Address, const void *Decoder) +{ + if (Imm <= 3) + return MCDisassembler_Fail; + MCOperand_CreateImm0(Inst, (Imm)); + return MCDisassembler_Success; +} + +static DecodeStatus decodeRegReg(MCInst *Inst, uint32_t Insn, uint64_t Address, + const void *Decoder) +{ + uint32_t Rs1 = fieldFromInstruction_4(Insn, 0, 5); + uint32_t Rs2 = fieldFromInstruction_4(Insn, 5, 5); + DecodeGPRRegisterClass(Inst, Rs1, Address, Decoder); + DecodeGPRRegisterClass(Inst, Rs2, Address, Decoder); + return MCDisassembler_Success; +} + +static DecodeStatus decodeZcmpSpimm(MCInst *Inst, unsigned Imm, + uint64_t Address, const void *Decoder) +{ + MCOperand_CreateImm0(Inst, (Imm)); + return MCDisassembler_Success; +} + +// Add implied SP operand for C.*SP compressed instructions. The SP operand +// isn't explicitly encoded in the instruction. +void addSPOperands(MCInst *MI) +{ + const MCInstrDesc *MCID = + MCInstrDesc_get(MCInst_getOpcode(MI), RISCVDescs.Insts, ARR_SIZE(RISCVDescs.Insts)); + MCOperand SPReg; + SPReg.MachineOperandType = kRegister; + SPReg.Kind = kRegister; + SPReg.RegVal = RISCV_X2; + for (unsigned i = 0; i < MCID->NumOperands; i++) + if (MCID->OpInfo[i].RegClass == RISCV_SPRegClassID) + MCInst_insert0(MI, i, &SPReg); +} + +DecodeStatus RISCV_getInstruction(MCInst *MI, uint16_t *Size, const uint8_t *Bytes, + size_t BytesLen, uint64_t Address, SStream *CS) { // TODO: This will need modification when supporting instruction set // extensions with instructions > 32-bits (up to 176 bits wide). - uint32_t Inst = 0; + uint32_t Insn; DecodeStatus Result; +#define TRY_TO_DECODE_WITH_ADDITIONAL_OPERATION(width, FEATURE_CHECKS, DECODER_TABLE, \ + DESC, ADDITIONAL_OPERATION) \ + do { \ + if (FEATURE_CHECKS) { \ + Result = decodeInstruction_##width(DECODER_TABLE, MI, Insn, \ + Address, NULL); \ + if (Result != MCDisassembler_Fail) { \ + ADDITIONAL_OPERATION; \ + return Result; \ + } \ + } \ + } while (false) +#define TRY_TO_DECODE_AND_ADD_SP(width, FEATURE_CHECKS, DECODER_TABLE, DESC) \ + TRY_TO_DECODE_WITH_ADDITIONAL_OPERATION(width, FEATURE_CHECKS, DECODER_TABLE, \ + DESC, addSPOperands(MI)) +#define TRY_TO_DECODE(width, FEATURE_CHECKS, DECODER_TABLE, DESC) \ + TRY_TO_DECODE_WITH_ADDITIONAL_OPERATION(width, FEATURE_CHECKS, DECODER_TABLE, \ + DESC, (void)NULL) +#define TRY_TO_DECODE_FEATURE(width, FEATURE, DECODER_TABLE, DESC) \ + TRY_TO_DECODE(width, RISCV_getFeatureBits(MI->csh->mode, FEATURE), DECODER_TABLE, DESC) + // It's a 32 bit instruction if bit 0 and 1 are 1. - if ((code[0] & 0x3) == 0x3) { - if (code_len < 4) { + if ((Bytes[0] & 0x3) == 0x3) { + if (BytesLen < 4) { *Size = 0; return MCDisassembler_Fail; } - *Size = 4; - // Get the four bytes of the instruction. - //Encoded as little endian 32 bits. - Inst = code[0] | (code[1] << 8) | (code[2] << 16) | - ((uint32_t)code[3] << 24); - init_MI_insn_detail(MI); - // Now we need mark what instruction need fix effective address output. - if (MI->csh->detail_opt) - markLSInsn(MI, Inst); - Result = decodeInstruction(DecoderTable32, MI, Inst, Address, - MRI, mode); - } else { - if (code_len < 2) { - *Size = 0; - return MCDisassembler_Fail; - } - // If not b4bit. - if (!(getFeatureBits(mode) & ((uint64_t)RISCV_Feature64Bit))) { - // Trying RISCV32Only_16 table (16-bit Instruction) - Inst = code[0] | (code[1] << 8); - init_MI_insn_detail(MI); - Result = decodeInstruction(DecoderTableRISCV32Only_16, - MI, Inst, Address, MRI, - mode); - if (Result != MCDisassembler_Fail) { - *Size = 2; - return Result; - } - } + Insn = readBytes32(MI, Bytes); + + TRY_TO_DECODE(4, RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZdinx) && + !RISCV_getFeatureBits(MI->csh->mode, RISCV_Feature64Bit), + DecoderTableRV32Zdinx32, + "RV32Zdinx table (Double in Integer and rv32)"); + TRY_TO_DECODE(4, RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZacas) && + !RISCV_getFeatureBits(MI->csh->mode, RISCV_Feature64Bit), + DecoderTableRV32Zacas32, + "RV32Zacas table (Compare-And-Swap and rv32)"); + TRY_TO_DECODE_FEATURE(4, RISCV_FeatureStdExtZfinx, + DecoderTableRVZfinx32, + "RVZfinx table (Float in Integer)"); + TRY_TO_DECODE_FEATURE(4, RISCV_FeatureVendorXVentanaCondOps, + DecoderTableXVentana32, + "Ventana custom opcode table"); + TRY_TO_DECODE_FEATURE(4, RISCV_FeatureVendorXTHeadBa, + DecoderTableXTHeadBa32, + "XTHeadBa custom opcode table"); + TRY_TO_DECODE_FEATURE(4, RISCV_FeatureVendorXTHeadBb, + DecoderTableXTHeadBb32, + "XTHeadBb custom opcode table"); + TRY_TO_DECODE_FEATURE(4, RISCV_FeatureVendorXTHeadBs, + DecoderTableXTHeadBs32, + "XTHeadBs custom opcode table"); + TRY_TO_DECODE_FEATURE(4, RISCV_FeatureVendorXTHeadCondMov, + DecoderTableXTHeadCondMov32, + "XTHeadCondMov custom opcode table"); + TRY_TO_DECODE_FEATURE(4, RISCV_FeatureVendorXTHeadCmo, + DecoderTableXTHeadCmo32, + "XTHeadCmo custom opcode table"); + TRY_TO_DECODE_FEATURE(4, RISCV_FeatureVendorXTHeadFMemIdx, + DecoderTableXTHeadFMemIdx32, + "XTHeadFMemIdx custom opcode table"); + TRY_TO_DECODE_FEATURE(4, RISCV_FeatureVendorXTHeadMac, + DecoderTableXTHeadMac32, + "XTHeadMac custom opcode table"); + TRY_TO_DECODE_FEATURE(4, RISCV_FeatureVendorXTHeadMemIdx, + DecoderTableXTHeadMemIdx32, + "XTHeadMemIdx custom opcode table"); + TRY_TO_DECODE_FEATURE(4, RISCV_FeatureVendorXTHeadMemPair, + DecoderTableXTHeadMemPair32, + "XTHeadMemPair custom opcode table"); + TRY_TO_DECODE_FEATURE(4, RISCV_FeatureVendorXTHeadSync, + DecoderTableXTHeadSync32, + "XTHeadSync custom opcode table"); + TRY_TO_DECODE_FEATURE(4, RISCV_FeatureVendorXTHeadVdot, + DecoderTableXTHeadVdot32, + "XTHeadVdot custom opcode table"); + TRY_TO_DECODE_FEATURE(4, RISCV_FeatureVendorXSfvcp, + DecoderTableXSfvcp32, + "SiFive VCIX custom opcode table"); + TRY_TO_DECODE_FEATURE(4, + RISCV_FeatureVendorXSfvqmaccdod, + DecoderTableXSfvqmaccdod32, + "SiFive Matrix Multiplication (2x8 and 8x2) Instruction opcode table"); + TRY_TO_DECODE_FEATURE(4, + RISCV_FeatureVendorXSfvqmaccqoq, + DecoderTableXSfvqmaccqoq32, + "SiFive Matrix Multiplication (4x8 and 8x4) Instruction opcode table"); + TRY_TO_DECODE_FEATURE(4, + RISCV_FeatureVendorXSfvfwmaccqqq, + DecoderTableXSfvfwmaccqqq32, + "SiFive Matrix Multiplication Instruction opcode table"); + TRY_TO_DECODE_FEATURE(4, + RISCV_FeatureVendorXSfvfnrclipxfqf, + DecoderTableXSfvfnrclipxfqf32, + "SiFive FP32-to-int8 Ranged Clip Instructions opcode table"); + TRY_TO_DECODE_FEATURE(4, + RISCV_FeatureVendorXCVbitmanip, + DecoderTableXCVbitmanip32, + "CORE-V Bit Manipulation custom opcode table"); + TRY_TO_DECODE_FEATURE(4, RISCV_FeatureVendorXCVelw, + DecoderTableXCVelw32, + "CORE-V Event load custom opcode table"); + TRY_TO_DECODE_FEATURE(4, RISCV_FeatureVendorXCVmac, + DecoderTableXCVmac32, + "CORE-V MAC custom opcode table"); + TRY_TO_DECODE_FEATURE(4, RISCV_FeatureVendorXCVmem, + DecoderTableXCVmem32, + "CORE-V MEM custom opcode table"); + TRY_TO_DECODE_FEATURE(4, RISCV_FeatureVendorXCValu, + DecoderTableXCValu32, + "CORE-V ALU custom opcode table"); + TRY_TO_DECODE_FEATURE(4, + RISCV_FeatureVendorXCVsimd, DecoderTableXCVsimd32, + "CORE-V SIMD extensions custom opcode table"); + TRY_TO_DECODE_FEATURE(4, + RISCV_FeatureVendorXCVbi, DecoderTableXCVbi32, + "CORE-V Immediate Branching custom opcode table"); + TRY_TO_DECODE(4, true, DecoderTable32, "RISCV32 table"); - // Trying RISCV_C table (16-bit Instruction) - Inst = code[0] | (code[1] << 8); - init_MI_insn_detail(MI); - // Calling the auto-generated decoder function. - Result = decodeInstruction(DecoderTable16, MI, Inst, Address, - MRI, mode); - // Now we need mark what instruction need fix effective address output. - // Note that we mark it AFTER the instruction is decoded - // This is because there is no obvious pattern in terms of RISC-V C instructions - // So we compare the instruction IDs one by one - if (detail_is_set(MI)) - markCLSInsn(MI, Inst); - *Size = 2; + return MCDisassembler_Fail; } - return Result; + if (BytesLen < 2) { + *Size = 0; + return MCDisassembler_Fail; + } + *Size = 2; + + Insn = readBytes16(MI, Bytes); + TRY_TO_DECODE_AND_ADD_SP(2, !RISCV_getFeatureBits(MI->csh->mode, RISCV_Feature64Bit), + DecoderTableRISCV32Only_16, + "RISCV32Only_16 table (16-bit Instruction)"); + TRY_TO_DECODE_FEATURE(2, RISCV_FeatureStdExtZicfiss, DecoderTableZicfiss16, + "RVZicfiss table (Shadow Stack)"); + TRY_TO_DECODE_FEATURE(2, RISCV_FeatureStdExtZcmt, DecoderTableRVZcmt16, + "Zcmt table (16-bit Table Jump Instructions)"); + TRY_TO_DECODE_FEATURE(2, + RISCV_FeatureStdExtZcmp, DecoderTableRVZcmp16, + "Zcmp table (16-bit Push/Pop & Double Move Instructions)"); + TRY_TO_DECODE_AND_ADD_SP(2, true, DecoderTable16, + "RISCV_C table (16-bit Instruction)"); + + return MCDisassembler_Fail; } -bool RISCV_getInstruction(csh ud, const uint8_t *code, size_t code_len, - MCInst *instr, uint16_t *size, uint64_t address, - void *info) -{ - cs_struct *handle = (cs_struct *)(uintptr_t)ud; +bool RISCV_LLVM_getInstruction(csh handle, const uint8_t *Bytes, + size_t ByteLen, MCInst *MI, uint16_t *Size, + uint64_t Address, void *Info) { - DecodeStatus Result = RISCVDisassembler_getInstruction( - handle->mode, instr, code, code_len, size, address, - (MCRegisterInfo *)info); - if (Result == MCDisassembler_SoftFail) { - MCInst_setSoftFail(instr); - } - return Result != MCDisassembler_Fail; + MI->MRI = (MCRegisterInfo *) Info; + return RISCV_getInstruction(MI, Size, Bytes, ByteLen, Address, NULL) != MCDisassembler_Fail; } - -void RISCV_init(MCRegisterInfo *MRI) -{ - /* - InitMCRegisterInfo(RISCVRegDesc, 97, RA, PC, - RISCVMCRegisterClasses, 11, - RISCVRegUnitRoots, - 64, - RISCVRegDiffLists, - RISCVLaneMaskLists, - RISCVRegStrings, - RISCVRegClassStrings, - RISCVSubRegIdxLists, - 2, - RISCVSubRegIdxRanges, - RISCVRegEncodingTable); - */ - - MCRegisterInfo_InitMCRegisterInfo(MRI, RISCVRegDesc, 97, 0, 0, - RISCVMCRegisterClasses, 11, 0, 0, - RISCVRegDiffLists, 0, - RISCVSubRegIdxLists, 2, 0); -} - -#endif diff --git a/arch/RISCV/RISCVDisassemblerExtension.c b/arch/RISCV/RISCVDisassemblerExtension.c new file mode 100644 index 0000000000..5d8b90b5a0 --- /dev/null +++ b/arch/RISCV/RISCVDisassemblerExtension.c @@ -0,0 +1,89 @@ +#include "RISCVDisassemblerExtension.h" + +#define GET_SUBTARGETINFO_ENUM +#include "RISCVGenSubtargetInfo.inc" + +bool RISCV_getFeatureBits(unsigned int mode, unsigned int feature) { + if (feature == RISCV_FeatureNoRVCHints) { + return false; + } + + switch (feature) { + case RISCV_Feature32Bit: + return mode & CS_MODE_RISCV32; + + case RISCV_Feature64Bit: + return mode & CS_MODE_RISCV64; + + case RISCV_FEATURE_HASSTDEXTF: + case RISCV_FEATURE_HASSTDEXTD: + return mode & CS_MODE_RISCV_FD; + + case RISCV_FeatureStdExtV: + return mode & CS_MODE_RISCV_V; + + case RISCV_FeatureStdExtZfinx: + case RISCV_FeatureStdExtZdinx: + case RISCV_FeatureStdExtZhinx: + case RISCV_FeatureStdExtZhinxmin: + return mode & CS_MODE_RISCV_ZFINX; + + case RISCV_FeatureStdExtC: + return mode & CS_MODE_RISCV_C; + + case RISCV_FeatureStdExtZcmp: + case RISCV_FeatureStdExtZcmt: + case RISCV_FeatureStdExtZce: + return mode & CS_MODE_RISCV_ZCMP_ZCMT_ZCE; + + case RISCV_FeatureStdExtZicfiss: + return mode & CS_MODE_RISCV_ZICFISS; + + case RISCV_FeatureRVE: + return mode & CS_MODE_RISCV_E; + + case RISCV_FeatureStdExtA: + return mode & CS_MODE_RISCV_A; + + case RISCV_FeatureVendorXCVelw: + return mode & CS_MODE_RISCV_COREV; + + case RISCV_FeatureVendorXSfvcp: + case RISCV_FeatureVendorXSfvfnrclipxfqf: + case RISCV_FeatureVendorXSfvfwmaccqqq: + case RISCV_FeatureVendorXSfvqmaccdod: + case RISCV_FeatureVendorXSfvqmaccqoq: + return mode & CS_MODE_RISCV_SIFIVE; + + case RISCV_FeatureVendorXTHeadBa: + case RISCV_FeatureVendorXTHeadBb: + case RISCV_FeatureVendorXTHeadBs: + case RISCV_FeatureVendorXTHeadCmo: + case RISCV_FeatureVendorXTHeadCondMov: + case RISCV_FeatureVendorXTHeadFMemIdx: + case RISCV_FeatureVendorXTHeadMac: + case RISCV_FeatureVendorXTHeadMemIdx: + case RISCV_FeatureVendorXTHeadMemPair: + case RISCV_FeatureVendorXTHeadSync: + case RISCV_FeatureVendorXTHeadVdot: + return mode & CS_MODE_RISCV_THEAD; + + case RISCV_FeatureStdExtZba: + return mode & CS_MODE_RISCV_ZBA; + case RISCV_FeatureStdExtZbb: + return mode & CS_MODE_RISCV_ZBB; + case RISCV_FeatureStdExtZbc: + return mode & CS_MODE_RISCV_ZBC; + case RISCV_FeatureStdExtZbkb: + return mode & CS_MODE_RISCV_ZBKB; + case RISCV_FeatureStdExtZbkc: + return mode & CS_MODE_RISCV_ZBKC; + case RISCV_FeatureStdExtZbkx: + return mode & CS_MODE_RISCV_ZBKX; + case RISCV_FeatureStdExtZbs: + return mode & CS_MODE_RISCV_ZBS; + default: + // support everything by default + return true; + } +} \ No newline at end of file diff --git a/arch/RISCV/RISCVDisassemblerExtension.h b/arch/RISCV/RISCVDisassemblerExtension.h new file mode 100644 index 0000000000..8c7a8ae432 --- /dev/null +++ b/arch/RISCV/RISCVDisassemblerExtension.h @@ -0,0 +1,8 @@ +#ifndef CS_RISCV_DISASSEMBLER_EXTENSION_H +#define CS_RISCV_DISASSEMBLER_EXTENSION_H + +#include "../../cs_priv.h" + +bool RISCV_getFeatureBits(unsigned int mode, unsigned int feature); + +#endif // CS_RISCV_DISASSEMBLER_EXTENSION_H diff --git a/arch/RISCV/RISCVGenAsmWriter.inc b/arch/RISCV/RISCVGenAsmWriter.inc index c8a6aac644..ac356336a0 100644 --- a/arch/RISCV/RISCVGenAsmWriter.inc +++ b/arch/RISCV/RISCVGenAsmWriter.inc @@ -1,286 +1,1673 @@ -/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\ -|* *| -|* Assembly Writer Source Fragment *| -|* *| -|* Automatically generated file, do not edit! *| -|* *| -\*===----------------------------------------------------------------------===*/ +/* Capstone Disassembly Engine, https://www.capstone-engine.org */ +/* By Nguyen Anh Quynh , 2013-2022, */ +/* Rot127 2022-2024 */ +/* Automatically generated file by Capstone's LLVM TableGen Disassembler Backend. */ -/* Capstone Disassembly Engine */ -/* By Nguyen Anh Quynh , 2013-2015 */ +/* LLVM-commit: */ +/* LLVM-tag: */ -#include // debug -#include -#include +/* Do not edit. */ +/* Capstone's LLVM TableGen Backends: */ +/* https://github.com/capstone-engine/llvm-capstone */ -/// printInstruction - This method is automatically generated by tablegen +#include +#include "../../cs_priv.h" +#include "../../MathExtras.h" + +/// getMnemonic - This method is automatically generated by tablegen /// from the instruction set description. -static void printInstruction(MCInst *MI, SStream *O, MCRegisterInfo *MRI) -{ +static MnemonicBitsInfo getMnemonic(MCInst *MI, SStream *O) { #ifndef CAPSTONE_DIET static const char AsmStrs[] = { - /* 0 */ 'l', 'l', 'a', 9, 0, - /* 5 */ 's', 'f', 'e', 'n', 'c', 'e', '.', 'v', 'm', 'a', 9, 0, - /* 17 */ 's', 'r', 'a', 9, 0, - /* 22 */ 'l', 'b', 9, 0, - /* 26 */ 's', 'b', 9, 0, - /* 30 */ 'c', '.', 's', 'u', 'b', 9, 0, - /* 37 */ 'a', 'u', 'i', 'p', 'c', 9, 0, - /* 44 */ 'c', 's', 'r', 'r', 'c', 9, 0, - /* 51 */ 'f', 's', 'u', 'b', '.', 'd', 9, 0, - /* 59 */ 'f', 'm', 's', 'u', 'b', '.', 'd', 9, 0, - /* 68 */ 'f', 'n', 'm', 's', 'u', 'b', '.', 'd', 9, 0, - /* 78 */ 's', 'c', '.', 'd', 9, 0, - /* 84 */ 'f', 'a', 'd', 'd', '.', 'd', 9, 0, - /* 92 */ 'f', 'm', 'a', 'd', 'd', '.', 'd', 9, 0, - /* 101 */ 'f', 'n', 'm', 'a', 'd', 'd', '.', 'd', 9, 0, - /* 111 */ 'a', 'm', 'o', 'a', 'd', 'd', '.', 'd', 9, 0, - /* 121 */ 'a', 'm', 'o', 'a', 'n', 'd', '.', 'd', 9, 0, - /* 131 */ 'f', 'l', 'e', '.', 'd', 9, 0, - /* 138 */ 'f', 's', 'g', 'n', 'j', '.', 'd', 9, 0, - /* 147 */ 'f', 'c', 'v', 't', '.', 'l', '.', 'd', 9, 0, - /* 157 */ 'f', 'm', 'u', 'l', '.', 'd', 9, 0, - /* 165 */ 'f', 'm', 'i', 'n', '.', 'd', 9, 0, - /* 173 */ 'a', 'm', 'o', 'm', 'i', 'n', '.', 'd', 9, 0, - /* 183 */ 'f', 's', 'g', 'n', 'j', 'n', '.', 'd', 9, 0, - /* 193 */ 'a', 'm', 'o', 's', 'w', 'a', 'p', '.', 'd', 9, 0, - /* 204 */ 'f', 'e', 'q', '.', 'd', 9, 0, - /* 211 */ 'l', 'r', '.', 'd', 9, 0, - /* 217 */ 'a', 'm', 'o', 'o', 'r', '.', 'd', 9, 0, - /* 226 */ 'a', 'm', 'o', 'x', 'o', 'r', '.', 'd', 9, 0, - /* 236 */ 'f', 'c', 'v', 't', '.', 's', '.', 'd', 9, 0, - /* 246 */ 'f', 'c', 'l', 'a', 's', 's', '.', 'd', 9, 0, - /* 256 */ 'f', 'l', 't', '.', 'd', 9, 0, - /* 263 */ 'f', 's', 'q', 'r', 't', '.', 'd', 9, 0, - /* 272 */ 'f', 'c', 'v', 't', '.', 'l', 'u', '.', 'd', 9, 0, - /* 283 */ 'a', 'm', 'o', 'm', 'i', 'n', 'u', '.', 'd', 9, 0, - /* 294 */ 'f', 'c', 'v', 't', '.', 'w', 'u', '.', 'd', 9, 0, - /* 305 */ 'a', 'm', 'o', 'm', 'a', 'x', 'u', '.', 'd', 9, 0, - /* 316 */ 'f', 'd', 'i', 'v', '.', 'd', 9, 0, - /* 324 */ 'f', 'c', 'v', 't', '.', 'w', '.', 'd', 9, 0, - /* 334 */ 'f', 'm', 'v', '.', 'x', '.', 'd', 9, 0, - /* 343 */ 'f', 'm', 'a', 'x', '.', 'd', 9, 0, - /* 351 */ 'a', 'm', 'o', 'm', 'a', 'x', '.', 'd', 9, 0, - /* 361 */ 'f', 's', 'g', 'n', 'j', 'x', '.', 'd', 9, 0, - /* 371 */ 'c', '.', 'a', 'd', 'd', 9, 0, - /* 378 */ 'c', '.', 'l', 'd', 9, 0, - /* 384 */ 'c', '.', 'f', 'l', 'd', 9, 0, - /* 391 */ 'c', '.', 'a', 'n', 'd', 9, 0, - /* 398 */ 'c', '.', 's', 'd', 9, 0, - /* 404 */ 'c', '.', 'f', 's', 'd', 9, 0, - /* 411 */ 'f', 'e', 'n', 'c', 'e', 9, 0, - /* 418 */ 'b', 'g', 'e', 9, 0, - /* 423 */ 'b', 'n', 'e', 9, 0, - /* 428 */ 'm', 'u', 'l', 'h', 9, 0, - /* 434 */ 's', 'h', 9, 0, - /* 438 */ 'f', 'e', 'n', 'c', 'e', '.', 'i', 9, 0, - /* 447 */ 'c', '.', 's', 'r', 'a', 'i', 9, 0, - /* 455 */ 'c', 's', 'r', 'r', 'c', 'i', 9, 0, - /* 463 */ 'c', '.', 'a', 'd', 'd', 'i', 9, 0, - /* 471 */ 'c', '.', 'a', 'n', 'd', 'i', 9, 0, - /* 479 */ 'w', 'f', 'i', 9, 0, - /* 484 */ 'c', '.', 'l', 'i', 9, 0, - /* 490 */ 'c', '.', 's', 'l', 'l', 'i', 9, 0, - /* 498 */ 'c', '.', 's', 'r', 'l', 'i', 9, 0, - /* 506 */ 'x', 'o', 'r', 'i', 9, 0, - /* 512 */ 'c', 's', 'r', 'r', 's', 'i', 9, 0, - /* 520 */ 's', 'l', 't', 'i', 9, 0, - /* 526 */ 'c', '.', 'l', 'u', 'i', 9, 0, - /* 533 */ 'c', 's', 'r', 'r', 'w', 'i', 9, 0, - /* 541 */ 'c', '.', 'j', 9, 0, - /* 546 */ 'c', '.', 'e', 'b', 'r', 'e', 'a', 'k', 9, 0, - /* 556 */ 'f', 'c', 'v', 't', '.', 'd', '.', 'l', 9, 0, - /* 566 */ 'f', 'c', 'v', 't', '.', 's', '.', 'l', 9, 0, - /* 576 */ 'c', '.', 'j', 'a', 'l', 9, 0, - /* 583 */ 't', 'a', 'i', 'l', 9, 0, - /* 589 */ 'e', 'c', 'a', 'l', 'l', 9, 0, - /* 596 */ 's', 'l', 'l', 9, 0, - /* 601 */ 's', 'c', '.', 'd', '.', 'r', 'l', 9, 0, - /* 610 */ 'a', 'm', 'o', 'a', 'd', 'd', '.', 'd', '.', 'r', 'l', 9, 0, - /* 623 */ 'a', 'm', 'o', 'a', 'n', 'd', '.', 'd', '.', 'r', 'l', 9, 0, - /* 636 */ 'a', 'm', 'o', 'm', 'i', 'n', '.', 'd', '.', 'r', 'l', 9, 0, - /* 649 */ 'a', 'm', 'o', 's', 'w', 'a', 'p', '.', 'd', '.', 'r', 'l', 9, 0, - /* 663 */ 'l', 'r', '.', 'd', '.', 'r', 'l', 9, 0, - /* 672 */ 'a', 'm', 'o', 'o', 'r', '.', 'd', '.', 'r', 'l', 9, 0, - /* 684 */ 'a', 'm', 'o', 'x', 'o', 'r', '.', 'd', '.', 'r', 'l', 9, 0, - /* 697 */ 'a', 'm', 'o', 'm', 'i', 'n', 'u', '.', 'd', '.', 'r', 'l', 9, 0, - /* 711 */ 'a', 'm', 'o', 'm', 'a', 'x', 'u', '.', 'd', '.', 'r', 'l', 9, 0, - /* 725 */ 'a', 'm', 'o', 'm', 'a', 'x', '.', 'd', '.', 'r', 'l', 9, 0, - /* 738 */ 's', 'c', '.', 'w', '.', 'r', 'l', 9, 0, - /* 747 */ 'a', 'm', 'o', 'a', 'd', 'd', '.', 'w', '.', 'r', 'l', 9, 0, - /* 760 */ 'a', 'm', 'o', 'a', 'n', 'd', '.', 'w', '.', 'r', 'l', 9, 0, - /* 773 */ 'a', 'm', 'o', 'm', 'i', 'n', '.', 'w', '.', 'r', 'l', 9, 0, - /* 786 */ 'a', 'm', 'o', 's', 'w', 'a', 'p', '.', 'w', '.', 'r', 'l', 9, 0, - /* 800 */ 'l', 'r', '.', 'w', '.', 'r', 'l', 9, 0, - /* 809 */ 'a', 'm', 'o', 'o', 'r', '.', 'w', '.', 'r', 'l', 9, 0, - /* 821 */ 'a', 'm', 'o', 'x', 'o', 'r', '.', 'w', '.', 'r', 'l', 9, 0, - /* 834 */ 'a', 'm', 'o', 'm', 'i', 'n', 'u', '.', 'w', '.', 'r', 'l', 9, 0, - /* 848 */ 'a', 'm', 'o', 'm', 'a', 'x', 'u', '.', 'w', '.', 'r', 'l', 9, 0, - /* 862 */ 'a', 'm', 'o', 'm', 'a', 'x', '.', 'w', '.', 'r', 'l', 9, 0, - /* 875 */ 's', 'c', '.', 'd', '.', 'a', 'q', 'r', 'l', 9, 0, - /* 886 */ 'a', 'm', 'o', 'a', 'd', 'd', '.', 'd', '.', 'a', 'q', 'r', 'l', 9, 0, - /* 901 */ 'a', 'm', 'o', 'a', 'n', 'd', '.', 'd', '.', 'a', 'q', 'r', 'l', 9, 0, - /* 916 */ 'a', 'm', 'o', 'm', 'i', 'n', '.', 'd', '.', 'a', 'q', 'r', 'l', 9, 0, - /* 931 */ 'a', 'm', 'o', 's', 'w', 'a', 'p', '.', 'd', '.', 'a', 'q', 'r', 'l', 9, 0, - /* 947 */ 'l', 'r', '.', 'd', '.', 'a', 'q', 'r', 'l', 9, 0, - /* 958 */ 'a', 'm', 'o', 'o', 'r', '.', 'd', '.', 'a', 'q', 'r', 'l', 9, 0, - /* 972 */ 'a', 'm', 'o', 'x', 'o', 'r', '.', 'd', '.', 'a', 'q', 'r', 'l', 9, 0, - /* 987 */ 'a', 'm', 'o', 'm', 'i', 'n', 'u', '.', 'd', '.', 'a', 'q', 'r', 'l', 9, 0, - /* 1003 */ 'a', 'm', 'o', 'm', 'a', 'x', 'u', '.', 'd', '.', 'a', 'q', 'r', 'l', 9, 0, - /* 1019 */ 'a', 'm', 'o', 'm', 'a', 'x', '.', 'd', '.', 'a', 'q', 'r', 'l', 9, 0, - /* 1034 */ 's', 'c', '.', 'w', '.', 'a', 'q', 'r', 'l', 9, 0, - /* 1045 */ 'a', 'm', 'o', 'a', 'd', 'd', '.', 'w', '.', 'a', 'q', 'r', 'l', 9, 0, - /* 1060 */ 'a', 'm', 'o', 'a', 'n', 'd', '.', 'w', '.', 'a', 'q', 'r', 'l', 9, 0, - /* 1075 */ 'a', 'm', 'o', 'm', 'i', 'n', '.', 'w', '.', 'a', 'q', 'r', 'l', 9, 0, - /* 1090 */ 'a', 'm', 'o', 's', 'w', 'a', 'p', '.', 'w', '.', 'a', 'q', 'r', 'l', 9, 0, - /* 1106 */ 'l', 'r', '.', 'w', '.', 'a', 'q', 'r', 'l', 9, 0, - /* 1117 */ 'a', 'm', 'o', 'o', 'r', '.', 'w', '.', 'a', 'q', 'r', 'l', 9, 0, - /* 1131 */ 'a', 'm', 'o', 'x', 'o', 'r', '.', 'w', '.', 'a', 'q', 'r', 'l', 9, 0, - /* 1146 */ 'a', 'm', 'o', 'm', 'i', 'n', 'u', '.', 'w', '.', 'a', 'q', 'r', 'l', 9, 0, - /* 1162 */ 'a', 'm', 'o', 'm', 'a', 'x', 'u', '.', 'w', '.', 'a', 'q', 'r', 'l', 9, 0, - /* 1178 */ 'a', 'm', 'o', 'm', 'a', 'x', '.', 'w', '.', 'a', 'q', 'r', 'l', 9, 0, - /* 1193 */ 's', 'r', 'l', 9, 0, - /* 1198 */ 'm', 'u', 'l', 9, 0, - /* 1203 */ 'r', 'e', 'm', 9, 0, - /* 1208 */ 'c', '.', 'a', 'd', 'd', 'i', '4', 's', 'p', 'n', 9, 0, - /* 1220 */ 'f', 'e', 'n', 'c', 'e', '.', 't', 's', 'o', 9, 0, - /* 1231 */ 'c', '.', 'u', 'n', 'i', 'm', 'p', 9, 0, - /* 1240 */ 'c', '.', 'n', 'o', 'p', 9, 0, - /* 1247 */ 'c', '.', 'a', 'd', 'd', 'i', '1', '6', 's', 'p', 9, 0, - /* 1259 */ 'c', '.', 'l', 'd', 's', 'p', 9, 0, - /* 1267 */ 'c', '.', 'f', 'l', 'd', 's', 'p', 9, 0, - /* 1276 */ 'c', '.', 's', 'd', 's', 'p', 9, 0, - /* 1284 */ 'c', '.', 'f', 's', 'd', 's', 'p', 9, 0, - /* 1293 */ 'c', '.', 'l', 'w', 's', 'p', 9, 0, - /* 1301 */ 'c', '.', 'f', 'l', 'w', 's', 'p', 9, 0, - /* 1310 */ 'c', '.', 's', 'w', 's', 'p', 9, 0, - /* 1318 */ 'c', '.', 'f', 's', 'w', 's', 'p', 9, 0, - /* 1327 */ 's', 'c', '.', 'd', '.', 'a', 'q', 9, 0, - /* 1336 */ 'a', 'm', 'o', 'a', 'd', 'd', '.', 'd', '.', 'a', 'q', 9, 0, - /* 1349 */ 'a', 'm', 'o', 'a', 'n', 'd', '.', 'd', '.', 'a', 'q', 9, 0, - /* 1362 */ 'a', 'm', 'o', 'm', 'i', 'n', '.', 'd', '.', 'a', 'q', 9, 0, - /* 1375 */ 'a', 'm', 'o', 's', 'w', 'a', 'p', '.', 'd', '.', 'a', 'q', 9, 0, - /* 1389 */ 'l', 'r', '.', 'd', '.', 'a', 'q', 9, 0, - /* 1398 */ 'a', 'm', 'o', 'o', 'r', '.', 'd', '.', 'a', 'q', 9, 0, - /* 1410 */ 'a', 'm', 'o', 'x', 'o', 'r', '.', 'd', '.', 'a', 'q', 9, 0, - /* 1423 */ 'a', 'm', 'o', 'm', 'i', 'n', 'u', '.', 'd', '.', 'a', 'q', 9, 0, - /* 1437 */ 'a', 'm', 'o', 'm', 'a', 'x', 'u', '.', 'd', '.', 'a', 'q', 9, 0, - /* 1451 */ 'a', 'm', 'o', 'm', 'a', 'x', '.', 'd', '.', 'a', 'q', 9, 0, - /* 1464 */ 's', 'c', '.', 'w', '.', 'a', 'q', 9, 0, - /* 1473 */ 'a', 'm', 'o', 'a', 'd', 'd', '.', 'w', '.', 'a', 'q', 9, 0, - /* 1486 */ 'a', 'm', 'o', 'a', 'n', 'd', '.', 'w', '.', 'a', 'q', 9, 0, - /* 1499 */ 'a', 'm', 'o', 'm', 'i', 'n', '.', 'w', '.', 'a', 'q', 9, 0, - /* 1512 */ 'a', 'm', 'o', 's', 'w', 'a', 'p', '.', 'w', '.', 'a', 'q', 9, 0, - /* 1526 */ 'l', 'r', '.', 'w', '.', 'a', 'q', 9, 0, - /* 1535 */ 'a', 'm', 'o', 'o', 'r', '.', 'w', '.', 'a', 'q', 9, 0, - /* 1547 */ 'a', 'm', 'o', 'x', 'o', 'r', '.', 'w', '.', 'a', 'q', 9, 0, - /* 1560 */ 'a', 'm', 'o', 'm', 'i', 'n', 'u', '.', 'w', '.', 'a', 'q', 9, 0, - /* 1574 */ 'a', 'm', 'o', 'm', 'a', 'x', 'u', '.', 'w', '.', 'a', 'q', 9, 0, - /* 1588 */ 'a', 'm', 'o', 'm', 'a', 'x', '.', 'w', '.', 'a', 'q', 9, 0, - /* 1601 */ 'b', 'e', 'q', 9, 0, - /* 1606 */ 'c', '.', 'j', 'r', 9, 0, - /* 1612 */ 'c', '.', 'j', 'a', 'l', 'r', 9, 0, - /* 1620 */ 'c', '.', 'o', 'r', 9, 0, - /* 1626 */ 'c', '.', 'x', 'o', 'r', 9, 0, - /* 1633 */ 'f', 's', 'u', 'b', '.', 's', 9, 0, - /* 1641 */ 'f', 'm', 's', 'u', 'b', '.', 's', 9, 0, - /* 1650 */ 'f', 'n', 'm', 's', 'u', 'b', '.', 's', 9, 0, - /* 1660 */ 'f', 'c', 'v', 't', '.', 'd', '.', 's', 9, 0, - /* 1670 */ 'f', 'a', 'd', 'd', '.', 's', 9, 0, - /* 1678 */ 'f', 'm', 'a', 'd', 'd', '.', 's', 9, 0, - /* 1687 */ 'f', 'n', 'm', 'a', 'd', 'd', '.', 's', 9, 0, - /* 1697 */ 'f', 'l', 'e', '.', 's', 9, 0, - /* 1704 */ 'f', 's', 'g', 'n', 'j', '.', 's', 9, 0, - /* 1713 */ 'f', 'c', 'v', 't', '.', 'l', '.', 's', 9, 0, - /* 1723 */ 'f', 'm', 'u', 'l', '.', 's', 9, 0, - /* 1731 */ 'f', 'm', 'i', 'n', '.', 's', 9, 0, - /* 1739 */ 'f', 's', 'g', 'n', 'j', 'n', '.', 's', 9, 0, - /* 1749 */ 'f', 'e', 'q', '.', 's', 9, 0, - /* 1756 */ 'f', 'c', 'l', 'a', 's', 's', '.', 's', 9, 0, - /* 1766 */ 'f', 'l', 't', '.', 's', 9, 0, - /* 1773 */ 'f', 's', 'q', 'r', 't', '.', 's', 9, 0, - /* 1782 */ 'f', 'c', 'v', 't', '.', 'l', 'u', '.', 's', 9, 0, - /* 1793 */ 'f', 'c', 'v', 't', '.', 'w', 'u', '.', 's', 9, 0, - /* 1804 */ 'f', 'd', 'i', 'v', '.', 's', 9, 0, - /* 1812 */ 'f', 'c', 'v', 't', '.', 'w', '.', 's', 9, 0, - /* 1822 */ 'f', 'm', 'a', 'x', '.', 's', 9, 0, - /* 1830 */ 'f', 's', 'g', 'n', 'j', 'x', '.', 's', 9, 0, - /* 1840 */ 'c', 's', 'r', 'r', 's', 9, 0, - /* 1847 */ 'm', 'r', 'e', 't', 9, 0, - /* 1853 */ 's', 'r', 'e', 't', 9, 0, - /* 1859 */ 'u', 'r', 'e', 't', 9, 0, - /* 1865 */ 'b', 'l', 't', 9, 0, - /* 1870 */ 's', 'l', 't', 9, 0, - /* 1875 */ 'l', 'b', 'u', 9, 0, - /* 1880 */ 'b', 'g', 'e', 'u', 9, 0, - /* 1886 */ 'm', 'u', 'l', 'h', 'u', 9, 0, - /* 1893 */ 's', 'l', 't', 'i', 'u', 9, 0, - /* 1900 */ 'f', 'c', 'v', 't', '.', 'd', '.', 'l', 'u', 9, 0, - /* 1911 */ 'f', 'c', 'v', 't', '.', 's', '.', 'l', 'u', 9, 0, - /* 1922 */ 'r', 'e', 'm', 'u', 9, 0, - /* 1928 */ 'm', 'u', 'l', 'h', 's', 'u', 9, 0, - /* 1936 */ 'b', 'l', 't', 'u', 9, 0, - /* 1942 */ 's', 'l', 't', 'u', 9, 0, - /* 1948 */ 'd', 'i', 'v', 'u', 9, 0, - /* 1954 */ 'f', 'c', 'v', 't', '.', 'd', '.', 'w', 'u', 9, 0, - /* 1965 */ 'f', 'c', 'v', 't', '.', 's', '.', 'w', 'u', 9, 0, - /* 1976 */ 'l', 'w', 'u', 9, 0, - /* 1981 */ 'd', 'i', 'v', 9, 0, - /* 1986 */ 'c', '.', 'm', 'v', 9, 0, - /* 1992 */ 's', 'c', '.', 'w', 9, 0, - /* 1998 */ 'f', 'c', 'v', 't', '.', 'd', '.', 'w', 9, 0, - /* 2008 */ 'a', 'm', 'o', 'a', 'd', 'd', '.', 'w', 9, 0, - /* 2018 */ 'a', 'm', 'o', 'a', 'n', 'd', '.', 'w', 9, 0, - /* 2028 */ 'a', 'm', 'o', 'm', 'i', 'n', '.', 'w', 9, 0, - /* 2038 */ 'a', 'm', 'o', 's', 'w', 'a', 'p', '.', 'w', 9, 0, - /* 2049 */ 'l', 'r', '.', 'w', 9, 0, - /* 2055 */ 'a', 'm', 'o', 'o', 'r', '.', 'w', 9, 0, - /* 2064 */ 'a', 'm', 'o', 'x', 'o', 'r', '.', 'w', 9, 0, - /* 2074 */ 'f', 'c', 'v', 't', '.', 's', '.', 'w', 9, 0, - /* 2084 */ 'a', 'm', 'o', 'm', 'i', 'n', 'u', '.', 'w', 9, 0, - /* 2095 */ 'a', 'm', 'o', 'm', 'a', 'x', 'u', '.', 'w', 9, 0, - /* 2106 */ 'f', 'm', 'v', '.', 'x', '.', 'w', 9, 0, - /* 2115 */ 'a', 'm', 'o', 'm', 'a', 'x', '.', 'w', 9, 0, - /* 2125 */ 's', 'r', 'a', 'w', 9, 0, - /* 2131 */ 'c', '.', 's', 'u', 'b', 'w', 9, 0, - /* 2139 */ 'c', '.', 'a', 'd', 'd', 'w', 9, 0, - /* 2147 */ 's', 'r', 'a', 'i', 'w', 9, 0, - /* 2154 */ 'c', '.', 'a', 'd', 'd', 'i', 'w', 9, 0, - /* 2163 */ 's', 'l', 'l', 'i', 'w', 9, 0, - /* 2170 */ 's', 'r', 'l', 'i', 'w', 9, 0, - /* 2177 */ 'c', '.', 'l', 'w', 9, 0, - /* 2183 */ 'c', '.', 'f', 'l', 'w', 9, 0, - /* 2190 */ 's', 'l', 'l', 'w', 9, 0, - /* 2196 */ 's', 'r', 'l', 'w', 9, 0, - /* 2202 */ 'm', 'u', 'l', 'w', 9, 0, - /* 2208 */ 'r', 'e', 'm', 'w', 9, 0, - /* 2214 */ 'c', 's', 'r', 'r', 'w', 9, 0, - /* 2221 */ 'c', '.', 's', 'w', 9, 0, - /* 2227 */ 'c', '.', 'f', 's', 'w', 9, 0, - /* 2234 */ 'r', 'e', 'm', 'u', 'w', 9, 0, - /* 2241 */ 'd', 'i', 'v', 'u', 'w', 9, 0, - /* 2248 */ 'd', 'i', 'v', 'w', 9, 0, - /* 2254 */ 'f', 'm', 'v', '.', 'd', '.', 'x', 9, 0, - /* 2263 */ 'f', 'm', 'v', '.', 'w', '.', 'x', 9, 0, - /* 2272 */ 'c', '.', 'b', 'n', 'e', 'z', 9, 0, - /* 2280 */ 'c', '.', 'b', 'e', 'q', 'z', 9, 0, - /* 2288 */ '#', 32, 'X', 'R', 'a', 'y', 32, 'F', 'u', 'n', 'c', 't', 'i', 'o', 'n', 32, 'P', 'a', 't', 'c', 'h', 'a', 'b', 'l', 'e', 32, 'R', 'E', 'T', '.', 0, - /* 2319 */ '#', 32, 'X', 'R', 'a', 'y', 32, 'T', 'y', 'p', 'e', 'd', 32, 'E', 'v', 'e', 'n', 't', 32, 'L', 'o', 'g', '.', 0, - /* 2343 */ '#', 32, 'X', 'R', 'a', 'y', 32, 'C', 'u', 's', 't', 'o', 'm', 32, 'E', 'v', 'e', 'n', 't', 32, 'L', 'o', 'g', '.', 0, - /* 2368 */ '#', 32, 'X', 'R', 'a', 'y', 32, 'F', 'u', 'n', 'c', 't', 'i', 'o', 'n', 32, 'E', 'n', 't', 'e', 'r', '.', 0, - /* 2391 */ '#', 32, 'X', 'R', 'a', 'y', 32, 'T', 'a', 'i', 'l', 32, 'C', 'a', 'l', 'l', 32, 'E', 'x', 'i', 't', '.', 0, - /* 2414 */ '#', 32, 'X', 'R', 'a', 'y', 32, 'F', 'u', 'n', 'c', 't', 'i', 'o', 'n', 32, 'E', 'x', 'i', 't', '.', 0, - /* 2436 */ 'L', 'I', 'F', 'E', 'T', 'I', 'M', 'E', '_', 'E', 'N', 'D', 0, - /* 2449 */ 'B', 'U', 'N', 'D', 'L', 'E', 0, - /* 2456 */ 'D', 'B', 'G', '_', 'V', 'A', 'L', 'U', 'E', 0, - /* 2466 */ 'D', 'B', 'G', '_', 'L', 'A', 'B', 'E', 'L', 0, - /* 2476 */ 'L', 'I', 'F', 'E', 'T', 'I', 'M', 'E', '_', 'S', 'T', 'A', 'R', 'T', 0, - /* 2491 */ '#', 32, 'F', 'E', 'n', 't', 'r', 'y', 32, 'c', 'a', 'l', 'l', 0, - }; -#endif + /* 0 */ "mop.r.0\t\0" + /* 9 */ "mop.rr.0\t\0" + /* 19 */ "mop.r.10\t\0" + /* 29 */ "mop.r.20\t\0" + /* 39 */ "mop.r.30\t\0" + /* 49 */ "th.ff0\t\0" + /* 57 */ "sha512sig0\t\0" + /* 69 */ "sha256sig0\t\0" + /* 81 */ "sha512sum0\t\0" + /* 93 */ "sha256sum0\t\0" + /* 105 */ "sm3p0\t\0" + /* 112 */ "mop.r.1\t\0" + /* 121 */ "mop.rr.1\t\0" + /* 131 */ "cm.mvsa01\t\0" + /* 142 */ "mop.r.11\t\0" + /* 152 */ "mop.r.21\t\0" + /* 162 */ "mop.r.31\t\0" + /* 172 */ "th.ff1\t\0" + /* 180 */ "cv.ff1\t\0" + /* 188 */ "sha512sig1\t\0" + /* 200 */ "sha256sig1\t\0" + /* 212 */ "th.dcache.cpal1\t\0" + /* 229 */ "th.dcache.cval1\t\0" + /* 246 */ "cv.fl1\t\0" + /* 254 */ "sha512sum1\t\0" + /* 266 */ "sha256sum1\t\0" + /* 278 */ "sm3p1\t\0" + /* 285 */ "mop.r.2\t\0" + /* 294 */ "mop.rr.2\t\0" + /* 304 */ "mop.r.12\t\0" + /* 314 */ "mop.r.22\t\0" + /* 324 */ "vsext.vf2\t\0" + /* 335 */ "vzext.vf2\t\0" + /* 346 */ "aes64ks2\t\0" + /* 356 */ "cv.sub.div2\t\0" + /* 369 */ "cv.add.div2\t\0" + /* 382 */ "cv.cplxmul.i.div2\t\0" + /* 401 */ "cv.subrotmj.div2\t\0" + /* 419 */ "cv.cplxmul.r.div2\t\0" + /* 438 */ "sf.vqmacc.2x8x2\t\0" + /* 455 */ "sf.vqmaccus.2x8x2\t\0" + /* 474 */ "sf.vqmaccu.2x8x2\t\0" + /* 492 */ "sf.vqmaccsu.2x8x2\t\0" + /* 511 */ "mop.r.3\t\0" + /* 520 */ "mop.rr.3\t\0" + /* 530 */ "mop.r.13\t\0" + /* 540 */ "mop.r.23\t\0" + /* 550 */ "mop.r.4\t\0" + /* 559 */ "mop.rr.4\t\0" + /* 569 */ "mop.r.14\t\0" + /* 579 */ "mop.r.24\t\0" + /* 589 */ "c.srai64\t\0" + /* 599 */ "c.slli64\t\0" + /* 609 */ "c.srli64\t\0" + /* 619 */ "vsext.vf4\t\0" + /* 630 */ "vzext.vf4\t\0" + /* 641 */ "xperm4\t\0" + /* 649 */ "cv.sub.div4\t\0" + /* 662 */ "cv.add.div4\t\0" + /* 675 */ "cv.cplxmul.i.div4\t\0" + /* 694 */ "cv.subrotmj.div4\t\0" + /* 712 */ "cv.cplxmul.r.div4\t\0" + /* 731 */ "sf.vfwmacc.4x4x4\t\0" + /* 749 */ "sf.vqmacc.4x8x4\t\0" + /* 766 */ "sf.vqmaccus.4x8x4\t\0" + /* 785 */ "sf.vqmaccu.4x8x4\t\0" + /* 803 */ "sf.vqmaccsu.4x8x4\t\0" + /* 822 */ "mop.r.5\t\0" + /* 831 */ "mop.rr.5\t\0" + /* 841 */ "mop.r.15\t\0" + /* 851 */ "mop.r.25\t\0" + /* 861 */ "mop.r.6\t\0" + /* 870 */ "mop.rr.6\t\0" + /* 880 */ "mop.r.16\t\0" + /* 890 */ "fcvt.s.bf16\t\0" + /* 903 */ "mop.r.26\t\0" + /* 913 */ "mop.r.7\t\0" + /* 922 */ "mop.rr.7\t\0" + /* 932 */ "mop.r.17\t\0" + /* 942 */ "mop.r.27\t\0" + /* 952 */ "mop.r.8\t\0" + /* 961 */ "mop.r.18\t\0" + /* 971 */ "mop.r.28\t\0" + /* 981 */ "vsext.vf8\t\0" + /* 992 */ "vzext.vf8\t\0" + /* 1003 */ "xperm8\t\0" + /* 1011 */ "brev8\t\0" + /* 1018 */ "cv.sub.div8\t\0" + /* 1031 */ "cv.add.div8\t\0" + /* 1044 */ "cv.cplxmul.i.div8\t\0" + /* 1063 */ "cv.subrotmj.div8\t\0" + /* 1081 */ "cv.cplxmul.r.div8\t\0" + /* 1100 */ "mop.r.9\t\0" + /* 1109 */ "mop.r.19\t\0" + /* 1119 */ "mop.r.29\t\0" + /* 1129 */ "lga\t\0" + /* 1134 */ "th.lbia\t\0" + /* 1143 */ "th.sbia\t\0" + /* 1152 */ "th.ldia\t\0" + /* 1161 */ "th.sdia\t\0" + /* 1170 */ "th.lhia\t\0" + /* 1179 */ "th.shia\t\0" + /* 1188 */ "th.lbuia\t\0" + /* 1198 */ "th.lhuia\t\0" + /* 1208 */ "th.lwuia\t\0" + /* 1218 */ "th.lwia\t\0" + /* 1227 */ "th.swia\t\0" + /* 1236 */ "lla\t\0" + /* 1241 */ "th.mula\t\0" + /* 1250 */ "sfence.vma\t\0" + /* 1262 */ "sinval.vma\t\0" + /* 1274 */ "hfence.gvma\t\0" + /* 1287 */ "hinval.gvma\t\0" + /* 1300 */ "hfence.vvma\t\0" + /* 1313 */ "hinval.vvma\t\0" + /* 1326 */ "th.dcache.cpa\t\0" + /* 1341 */ "th.dcache.ipa\t\0" + /* 1356 */ "th.icache.ipa\t\0" + /* 1371 */ "th.dcache.cipa\t\0" + /* 1387 */ "sra\t\0" + /* 1392 */ "th.dcache.cva\t\0" + /* 1407 */ "th.dcache.iva\t\0" + /* 1422 */ "th.icache.iva\t\0" + /* 1437 */ "th.dcache.civa\t\0" + /* 1453 */ "cv.shuffle2.b\t\0" + /* 1468 */ "cv.sra.b\t\0" + /* 1478 */ "cv.sub.b\t\0" + /* 1488 */ "orc.b\t\0" + /* 1495 */ "cv.sra.sc.b\t\0" + /* 1508 */ "cv.sub.sc.b\t\0" + /* 1521 */ "cv.add.sc.b\t\0" + /* 1534 */ "cv.and.sc.b\t\0" + /* 1547 */ "cv.cmpge.sc.b\t\0" + /* 1562 */ "cv.cmple.sc.b\t\0" + /* 1577 */ "cv.cmpne.sc.b\t\0" + /* 1592 */ "cv.avg.sc.b\t\0" + /* 1605 */ "cv.sll.sc.b\t\0" + /* 1618 */ "cv.srl.sc.b\t\0" + /* 1631 */ "cv.min.sc.b\t\0" + /* 1644 */ "cv.dotsp.sc.b\t\0" + /* 1659 */ "cv.sdotsp.sc.b\t\0" + /* 1675 */ "cv.dotusp.sc.b\t\0" + /* 1691 */ "cv.sdotusp.sc.b\t\0" + /* 1708 */ "cv.dotup.sc.b\t\0" + /* 1723 */ "cv.sdotup.sc.b\t\0" + /* 1739 */ "cv.cmpeq.sc.b\t\0" + /* 1754 */ "cv.or.sc.b\t\0" + /* 1766 */ "cv.xor.sc.b\t\0" + /* 1779 */ "cv.cmpgt.sc.b\t\0" + /* 1794 */ "cv.cmplt.sc.b\t\0" + /* 1809 */ "cv.cmpgeu.sc.b\t\0" + /* 1825 */ "cv.cmpleu.sc.b\t\0" + /* 1841 */ "cv.avgu.sc.b\t\0" + /* 1855 */ "cv.minu.sc.b\t\0" + /* 1869 */ "cv.cmpgtu.sc.b\t\0" + /* 1885 */ "cv.cmpltu.sc.b\t\0" + /* 1901 */ "cv.maxu.sc.b\t\0" + /* 1915 */ "cv.max.sc.b\t\0" + /* 1928 */ "cv.add.b\t\0" + /* 1938 */ "cv.and.b\t\0" + /* 1948 */ "cv.cmpge.b\t\0" + /* 1960 */ "cv.shuffle.b\t\0" + /* 1974 */ "cv.cmple.b\t\0" + /* 1986 */ "cv.cmpne.b\t\0" + /* 1998 */ "cv.avg.b\t\0" + /* 2008 */ "cv.shufflei0.sci.b\t\0" + /* 2028 */ "cv.shufflei1.sci.b\t\0" + /* 2048 */ "cv.shufflei2.sci.b\t\0" + /* 2068 */ "cv.shufflei3.sci.b\t\0" + /* 2088 */ "cv.sra.sci.b\t\0" + /* 2102 */ "cv.sub.sci.b\t\0" + /* 2116 */ "cv.add.sci.b\t\0" + /* 2130 */ "cv.and.sci.b\t\0" + /* 2144 */ "cv.cmpge.sci.b\t\0" + /* 2160 */ "cv.cmple.sci.b\t\0" + /* 2176 */ "cv.cmpne.sci.b\t\0" + /* 2192 */ "cv.avg.sci.b\t\0" + /* 2206 */ "cv.sll.sci.b\t\0" + /* 2220 */ "cv.srl.sci.b\t\0" + /* 2234 */ "cv.min.sci.b\t\0" + /* 2248 */ "cv.dotsp.sci.b\t\0" + /* 2264 */ "cv.sdotsp.sci.b\t\0" + /* 2281 */ "cv.dotusp.sci.b\t\0" + /* 2298 */ "cv.sdotusp.sci.b\t\0" + /* 2316 */ "cv.dotup.sci.b\t\0" + /* 2332 */ "cv.sdotup.sci.b\t\0" + /* 2349 */ "cv.cmpeq.sci.b\t\0" + /* 2365 */ "cv.or.sci.b\t\0" + /* 2378 */ "cv.xor.sci.b\t\0" + /* 2392 */ "cv.cmpgt.sci.b\t\0" + /* 2408 */ "cv.cmplt.sci.b\t\0" + /* 2424 */ "cv.cmpgeu.sci.b\t\0" + /* 2441 */ "cv.cmpleu.sci.b\t\0" + /* 2458 */ "cv.avgu.sci.b\t\0" + /* 2473 */ "cv.minu.sci.b\t\0" + /* 2488 */ "cv.cmpgtu.sci.b\t\0" + /* 2505 */ "cv.cmpltu.sci.b\t\0" + /* 2522 */ "cv.maxu.sci.b\t\0" + /* 2537 */ "cv.max.sci.b\t\0" + /* 2551 */ "cv.packhi.b\t\0" + /* 2564 */ "cv.sll.b\t\0" + /* 2574 */ "cv.srl.b\t\0" + /* 2584 */ "cv.min.b\t\0" + /* 2594 */ "cv.packlo.b\t\0" + /* 2607 */ "cv.dotsp.b\t\0" + /* 2619 */ "cv.sdotsp.b\t\0" + /* 2632 */ "cv.dotusp.b\t\0" + /* 2645 */ "cv.sdotusp.b\t\0" + /* 2659 */ "cv.dotup.b\t\0" + /* 2671 */ "cv.sdotup.b\t\0" + /* 2684 */ "cv.cmpeq.b\t\0" + /* 2696 */ "cv.or.b\t\0" + /* 2705 */ "cv.xor.b\t\0" + /* 2715 */ "cv.abs.b\t\0" + /* 2725 */ "cv.extract.b\t\0" + /* 2739 */ "cv.cmpgt.b\t\0" + /* 2751 */ "cv.cmplt.b\t\0" + /* 2763 */ "cv.insert.b\t\0" + /* 2776 */ "c.sext.b\t\0" + /* 2786 */ "c.zext.b\t\0" + /* 2796 */ "cv.cmpgeu.b\t\0" + /* 2809 */ "cv.cmpleu.b\t\0" + /* 2822 */ "cv.avgu.b\t\0" + /* 2833 */ "cv.minu.b\t\0" + /* 2844 */ "cv.extractu.b\t\0" + /* 2859 */ "cv.cmpgtu.b\t\0" + /* 2872 */ "cv.cmpltu.b\t\0" + /* 2885 */ "cv.maxu.b\t\0" + /* 2896 */ "hlv.b\t\0" + /* 2903 */ "hsv.b\t\0" + /* 2910 */ "cv.max.b\t\0" + /* 2920 */ "th.lbib\t\0" + /* 2929 */ "th.sbib\t\0" + /* 2938 */ "th.ldib\t\0" + /* 2947 */ "th.sdib\t\0" + /* 2956 */ "th.lhib\t\0" + /* 2965 */ "th.shib\t\0" + /* 2974 */ "th.lbuib\t\0" + /* 2984 */ "th.lhuib\t\0" + /* 2994 */ "th.lwuib\t\0" + /* 3004 */ "th.lwib\t\0" + /* 3013 */ "th.swib\t\0" + /* 3022 */ "cv.lb\t\0" + /* 3029 */ "cv.clb\t\0" + /* 3037 */ "th.lrb\t\0" + /* 3045 */ "th.srb\t\0" + /* 3053 */ "th.lurb\t\0" + /* 3062 */ "th.surb\t\0" + /* 3071 */ "c.sb\t\0" + /* 3077 */ "cv.sb\t\0" + /* 3084 */ "c.sub\t\0" + /* 3091 */ "cv.mac\t\0" + /* 3099 */ "vt.maskc\t\0" + /* 3109 */ "auipc\t\0" + /* 3116 */ "csrrc\t\0" + /* 3123 */ "la.tlsdesc\t\0" + /* 3135 */ "fsub.d\t\0" + /* 3143 */ "fmsub.d\t\0" + /* 3152 */ "fnmsub.d\t\0" + /* 3162 */ "sc.d\t\0" + /* 3168 */ "fadd.d\t\0" + /* 3176 */ "fmadd.d\t\0" + /* 3185 */ "fnmadd.d\t\0" + /* 3195 */ "amoadd.d\t\0" + /* 3205 */ "amoand.d\t\0" + /* 3215 */ "fround.d\t\0" + /* 3225 */ "fle.d\t\0" + /* 3232 */ "fcvt.h.d\t\0" + /* 3242 */ "fli.d\t\0" + /* 3249 */ "fsgnj.d\t\0" + /* 3258 */ "fcvt.l.d\t\0" + /* 3268 */ "fmul.d\t\0" + /* 3276 */ "fminm.d\t\0" + /* 3285 */ "fmaxm.d\t\0" + /* 3294 */ "fmin.d\t\0" + /* 3302 */ "amomin.d\t\0" + /* 3312 */ "fsgnjn.d\t\0" + /* 3322 */ "ssamoswap.d\t\0" + /* 3335 */ "feq.d\t\0" + /* 3342 */ "fleq.d\t\0" + /* 3350 */ "fltq.d\t\0" + /* 3358 */ "lr.d\t\0" + /* 3364 */ "amoor.d\t\0" + /* 3373 */ "amoxor.d\t\0" + /* 3383 */ "fcvt.s.d\t\0" + /* 3393 */ "amocas.d\t\0" + /* 3403 */ "fclass.d\t\0" + /* 3413 */ "flt.d\t\0" + /* 3420 */ "fsqrt.d\t\0" + /* 3429 */ "fcvt.lu.d\t\0" + /* 3440 */ "amominu.d\t\0" + /* 3451 */ "fcvt.wu.d\t\0" + /* 3462 */ "amomaxu.d\t\0" + /* 3473 */ "fdiv.d\t\0" + /* 3481 */ "hlv.d\t\0" + /* 3488 */ "hsv.d\t\0" + /* 3495 */ "fcvtmod.w.d\t\0" + /* 3508 */ "fcvt.w.d\t\0" + /* 3518 */ "fmvh.x.d\t\0" + /* 3528 */ "fmv.x.d\t\0" + /* 3537 */ "fmax.d\t\0" + /* 3545 */ "amomax.d\t\0" + /* 3555 */ "fsgnjx.d\t\0" + /* 3565 */ "froundnx.d\t\0" + /* 3577 */ "c.add\t\0" + /* 3584 */ "sh1add\t\0" + /* 3592 */ "sh2add\t\0" + /* 3600 */ "sh3add\t\0" + /* 3608 */ "th.ldd\t\0" + /* 3616 */ "th.sdd\t\0" + /* 3624 */ "sm4ed\t\0" + /* 3631 */ "la.tls.gd\t\0" + /* 3642 */ "c.ld\t\0" + /* 3648 */ "c.fld\t\0" + /* 3655 */ "c.and\t\0" + /* 3662 */ "th.lrd\t\0" + /* 3670 */ "th.flrd\t\0" + /* 3679 */ "th.srd\t\0" + /* 3687 */ "th.fsrd\t\0" + /* 3696 */ "th.lurd\t\0" + /* 3705 */ "th.flurd\t\0" + /* 3715 */ "th.surd\t\0" + /* 3724 */ "th.fsurd\t\0" + /* 3734 */ "c.sd\t\0" + /* 3740 */ "c.fsd\t\0" + /* 3747 */ "th.lwud\t\0" + /* 3756 */ "th.lwd\t\0" + /* 3764 */ "th.swd\t\0" + /* 3772 */ "fence\t\0" + /* 3779 */ "bge\t\0" + /* 3784 */ "la.tls.ie\t\0" + /* 3795 */ "bne\t\0" + /* 3800 */ "vfmv.s.f\t\0" + /* 3810 */ "vfmv.v.f\t\0" + /* 3820 */ "sf.vfnrclip.xu.f.qf\t\0" + /* 3841 */ "sf.vfnrclip.x.f.qf\t\0" + /* 3861 */ "vfwmaccbf16.vf\t\0" + /* 3877 */ "vfsub.vf\t\0" + /* 3887 */ "vfmsub.vf\t\0" + /* 3898 */ "vfnmsub.vf\t\0" + /* 3910 */ "vfrsub.vf\t\0" + /* 3921 */ "vfwsub.vf\t\0" + /* 3932 */ "vfmsac.vf\t\0" + /* 3943 */ "vfnmsac.vf\t\0" + /* 3955 */ "vfwnmsac.vf\t\0" + /* 3968 */ "vfwmsac.vf\t\0" + /* 3980 */ "vfmacc.vf\t\0" + /* 3991 */ "vfnmacc.vf\t\0" + /* 4003 */ "vfwnmacc.vf\t\0" + /* 4016 */ "vfwmacc.vf\t\0" + /* 4028 */ "vfadd.vf\t\0" + /* 4038 */ "vfmadd.vf\t\0" + /* 4049 */ "vfnmadd.vf\t\0" + /* 4061 */ "vfwadd.vf\t\0" + /* 4072 */ "vmfge.vf\t\0" + /* 4082 */ "vmfle.vf\t\0" + /* 4092 */ "vmfne.vf\t\0" + /* 4102 */ "vfsgnj.vf\t\0" + /* 4113 */ "vfmul.vf\t\0" + /* 4123 */ "vfwmul.vf\t\0" + /* 4134 */ "vfmin.vf\t\0" + /* 4144 */ "vfsgnjn.vf\t\0" + /* 4156 */ "vfslide1down.vf\t\0" + /* 4173 */ "vfslide1up.vf\t\0" + /* 4188 */ "vmfeq.vf\t\0" + /* 4198 */ "vmfgt.vf\t\0" + /* 4208 */ "vmflt.vf\t\0" + /* 4218 */ "vfdiv.vf\t\0" + /* 4228 */ "vfrdiv.vf\t\0" + /* 4239 */ "vfmax.vf\t\0" + /* 4249 */ "vfsgnjx.vf\t\0" + /* 4261 */ "vfwsub.wf\t\0" + /* 4272 */ "vfwadd.wf\t\0" + /* 4283 */ "cv.shuffle2.h\t\0" + /* 4298 */ "cv.sra.h\t\0" + /* 4308 */ "cv.sub.h\t\0" + /* 4318 */ "fsub.h\t\0" + /* 4326 */ "fmsub.h\t\0" + /* 4335 */ "fnmsub.h\t\0" + /* 4345 */ "cv.sra.sc.h\t\0" + /* 4358 */ "cv.sub.sc.h\t\0" + /* 4371 */ "cv.add.sc.h\t\0" + /* 4384 */ "cv.and.sc.h\t\0" + /* 4397 */ "cv.cmpge.sc.h\t\0" + /* 4412 */ "cv.cmple.sc.h\t\0" + /* 4427 */ "cv.cmpne.sc.h\t\0" + /* 4442 */ "cv.avg.sc.h\t\0" + /* 4455 */ "cv.sll.sc.h\t\0" + /* 4468 */ "cv.srl.sc.h\t\0" + /* 4481 */ "cv.min.sc.h\t\0" + /* 4494 */ "cv.dotsp.sc.h\t\0" + /* 4509 */ "cv.sdotsp.sc.h\t\0" + /* 4525 */ "cv.dotusp.sc.h\t\0" + /* 4541 */ "cv.sdotusp.sc.h\t\0" + /* 4558 */ "cv.dotup.sc.h\t\0" + /* 4573 */ "cv.sdotup.sc.h\t\0" + /* 4589 */ "cv.cmpeq.sc.h\t\0" + /* 4604 */ "cv.or.sc.h\t\0" + /* 4616 */ "cv.xor.sc.h\t\0" + /* 4629 */ "cv.cmpgt.sc.h\t\0" + /* 4644 */ "cv.cmplt.sc.h\t\0" + /* 4659 */ "cv.cmpgeu.sc.h\t\0" + /* 4675 */ "cv.cmpleu.sc.h\t\0" + /* 4691 */ "cv.avgu.sc.h\t\0" + /* 4705 */ "cv.minu.sc.h\t\0" + /* 4719 */ "cv.cmpgtu.sc.h\t\0" + /* 4735 */ "cv.cmpltu.sc.h\t\0" + /* 4751 */ "cv.maxu.sc.h\t\0" + /* 4765 */ "cv.max.sc.h\t\0" + /* 4778 */ "fcvt.d.h\t\0" + /* 4788 */ "cv.add.h\t\0" + /* 4798 */ "fadd.h\t\0" + /* 4806 */ "fmadd.h\t\0" + /* 4815 */ "fnmadd.h\t\0" + /* 4825 */ "cv.and.h\t\0" + /* 4835 */ "fround.h\t\0" + /* 4845 */ "cv.cmpge.h\t\0" + /* 4857 */ "cv.shuffle.h\t\0" + /* 4871 */ "cv.cmple.h\t\0" + /* 4883 */ "cv.cmpne.h\t\0" + /* 4895 */ "cv.avg.h\t\0" + /* 4905 */ "cv.sra.sci.h\t\0" + /* 4919 */ "cv.sub.sci.h\t\0" + /* 4933 */ "cv.add.sci.h\t\0" + /* 4947 */ "cv.and.sci.h\t\0" + /* 4961 */ "cv.cmpge.sci.h\t\0" + /* 4977 */ "cv.shuffle.sci.h\t\0" + /* 4995 */ "cv.cmple.sci.h\t\0" + /* 5011 */ "cv.cmpne.sci.h\t\0" + /* 5027 */ "cv.avg.sci.h\t\0" + /* 5041 */ "cv.sll.sci.h\t\0" + /* 5055 */ "cv.srl.sci.h\t\0" + /* 5069 */ "cv.min.sci.h\t\0" + /* 5083 */ "cv.dotsp.sci.h\t\0" + /* 5099 */ "cv.sdotsp.sci.h\t\0" + /* 5116 */ "cv.dotusp.sci.h\t\0" + /* 5133 */ "cv.sdotusp.sci.h\t\0" + /* 5151 */ "cv.dotup.sci.h\t\0" + /* 5167 */ "cv.sdotup.sci.h\t\0" + /* 5184 */ "cv.cmpeq.sci.h\t\0" + /* 5200 */ "cv.or.sci.h\t\0" + /* 5213 */ "cv.xor.sci.h\t\0" + /* 5227 */ "cv.cmpgt.sci.h\t\0" + /* 5243 */ "cv.cmplt.sci.h\t\0" + /* 5259 */ "cv.cmpgeu.sci.h\t\0" + /* 5276 */ "cv.cmpleu.sci.h\t\0" + /* 5293 */ "cv.avgu.sci.h\t\0" + /* 5308 */ "cv.minu.sci.h\t\0" + /* 5323 */ "cv.cmpgtu.sci.h\t\0" + /* 5340 */ "cv.cmpltu.sci.h\t\0" + /* 5357 */ "cv.maxu.sci.h\t\0" + /* 5372 */ "cv.max.sci.h\t\0" + /* 5386 */ "fli.h\t\0" + /* 5393 */ "fsgnj.h\t\0" + /* 5402 */ "cv.pack.h\t\0" + /* 5413 */ "fcvt.l.h\t\0" + /* 5423 */ "cv.sll.h\t\0" + /* 5433 */ "cv.srl.h\t\0" + /* 5443 */ "fmul.h\t\0" + /* 5451 */ "fminm.h\t\0" + /* 5460 */ "fmaxm.h\t\0" + /* 5469 */ "cv.min.h\t\0" + /* 5479 */ "fmin.h\t\0" + /* 5487 */ "fsgnjn.h\t\0" + /* 5497 */ "cv.dotsp.h\t\0" + /* 5509 */ "cv.sdotsp.h\t\0" + /* 5522 */ "cv.dotusp.h\t\0" + /* 5535 */ "cv.sdotusp.h\t\0" + /* 5549 */ "cv.dotup.h\t\0" + /* 5561 */ "cv.sdotup.h\t\0" + /* 5574 */ "feq.h\t\0" + /* 5581 */ "fleq.h\t\0" + /* 5589 */ "cv.cmpeq.h\t\0" + /* 5601 */ "fltq.h\t\0" + /* 5609 */ "cv.or.h\t\0" + /* 5618 */ "cv.xor.h\t\0" + /* 5628 */ "fcvt.s.h\t\0" + /* 5638 */ "cv.abs.h\t\0" + /* 5648 */ "fclass.h\t\0" + /* 5658 */ "cv.extract.h\t\0" + /* 5672 */ "cv.cmpgt.h\t\0" + /* 5684 */ "flt.h\t\0" + /* 5691 */ "cv.cmplt.h\t\0" + /* 5703 */ "cv.insert.h\t\0" + /* 5716 */ "fsqrt.h\t\0" + /* 5725 */ "c.sext.h\t\0" + /* 5735 */ "c.zext.h\t\0" + /* 5745 */ "cv.cmpgeu.h\t\0" + /* 5758 */ "cv.cmpleu.h\t\0" + /* 5771 */ "cv.avgu.h\t\0" + /* 5782 */ "fcvt.lu.h\t\0" + /* 5793 */ "cv.minu.h\t\0" + /* 5804 */ "cv.extractu.h\t\0" + /* 5819 */ "cv.cmpgtu.h\t\0" + /* 5832 */ "cv.cmpltu.h\t\0" + /* 5845 */ "fcvt.wu.h\t\0" + /* 5856 */ "cv.maxu.h\t\0" + /* 5867 */ "fdiv.h\t\0" + /* 5875 */ "hlv.h\t\0" + /* 5882 */ "hsv.h\t\0" + /* 5889 */ "fcvt.w.h\t\0" + /* 5899 */ "fmv.x.h\t\0" + /* 5908 */ "cv.max.h\t\0" + /* 5918 */ "fmax.h\t\0" + /* 5926 */ "fsgnjx.h\t\0" + /* 5936 */ "froundnx.h\t\0" + /* 5948 */ "sha512sig0h\t\0" + /* 5961 */ "sha512sig1h\t\0" + /* 5974 */ "th.mulah\t\0" + /* 5984 */ "packh\t\0" + /* 5991 */ "c.lh\t\0" + /* 5997 */ "cv.lh\t\0" + /* 6004 */ "flh\t\0" + /* 6009 */ "clmulh\t\0" + /* 6017 */ "th.lrh\t\0" + /* 6025 */ "th.srh\t\0" + /* 6033 */ "th.lurh\t\0" + /* 6042 */ "th.surh\t\0" + /* 6051 */ "c.sh\t\0" + /* 6057 */ "cv.sh\t\0" + /* 6064 */ "fsh\t\0" + /* 6069 */ "th.mulsh\t\0" + /* 6079 */ "cbo.flush\t\0" + /* 6090 */ "cm.push\t\0" + /* 6099 */ "c.sspush\t\0" + /* 6109 */ "sf.vc.i\t\0" + /* 6118 */ "prefetch.i\t\0" + /* 6130 */ "cv.cplxmul.i\t\0" + /* 6144 */ "sf.vc.v.i\t\0" + /* 6155 */ "vmv.v.i\t\0" + /* 6164 */ "aes64ks1i\t\0" + /* 6175 */ "c.srai\t\0" + /* 6183 */ "csrrci\t\0" + /* 6191 */ "c.addi\t\0" + /* 6199 */ "c.andi\t\0" + /* 6207 */ "c.li\t\0" + /* 6213 */ "c.slli\t\0" + /* 6221 */ "c.srli\t\0" + /* 6229 */ "vsetivli\t\0" + /* 6239 */ "vsetvli\t\0" + /* 6248 */ "aes32dsmi\t\0" + /* 6259 */ "aes32esmi\t\0" + /* 6270 */ "bclri\t\0" + /* 6277 */ "rori\t\0" + /* 6283 */ "xori\t\0" + /* 6289 */ "th.srri\t\0" + /* 6298 */ "aes32dsi\t\0" + /* 6308 */ "aes32esi\t\0" + /* 6318 */ "csrrsi\t\0" + /* 6326 */ "bseti\t\0" + /* 6333 */ "slti\t\0" + /* 6339 */ "bexti\t\0" + /* 6346 */ "c.lui\t\0" + /* 6353 */ "vaeskf1.vi\t\0" + /* 6365 */ "vaeskf2.vi\t\0" + /* 6377 */ "vssra.vi\t\0" + /* 6387 */ "vsra.vi\t\0" + /* 6396 */ "vrsub.vi\t\0" + /* 6406 */ "vsm3c.vi\t\0" + /* 6416 */ "vmadc.vi\t\0" + /* 6426 */ "vsadd.vi\t\0" + /* 6436 */ "vadd.vi\t\0" + /* 6445 */ "vand.vi\t\0" + /* 6454 */ "vmsge.vi\t\0" + /* 6464 */ "vmsle.vi\t\0" + /* 6474 */ "vmsne.vi\t\0" + /* 6484 */ "vsm4k.vi\t\0" + /* 6494 */ "vsll.vi\t\0" + /* 6503 */ "vwsll.vi\t\0" + /* 6513 */ "vssrl.vi\t\0" + /* 6523 */ "vsrl.vi\t\0" + /* 6532 */ "vslidedown.vi\t\0" + /* 6547 */ "vslideup.vi\t\0" + /* 6560 */ "vmseq.vi\t\0" + /* 6570 */ "vrgather.vi\t\0" + /* 6583 */ "vror.vi\t\0" + /* 6592 */ "vor.vi\t\0" + /* 6600 */ "vxor.vi\t\0" + /* 6609 */ "vmsgt.vi\t\0" + /* 6619 */ "vmslt.vi\t\0" + /* 6629 */ "vsaddu.vi\t\0" + /* 6640 */ "vmsgeu.vi\t\0" + /* 6651 */ "vmsleu.vi\t\0" + /* 6662 */ "vmsgtu.vi\t\0" + /* 6673 */ "vmsltu.vi\t\0" + /* 6684 */ "binvi\t\0" + /* 6691 */ "vnsra.wi\t\0" + /* 6701 */ "vnsrl.wi\t\0" + /* 6711 */ "vnclip.wi\t\0" + /* 6722 */ "vnclipu.wi\t\0" + /* 6734 */ "csrrwi\t\0" + /* 6742 */ "c.j\t\0" + /* 6747 */ "cv.subrotmj\t\0" + /* 6760 */ "cv.cplxconj\t\0" + /* 6773 */ "cv.pack\t\0" + /* 6782 */ "c.sspopchk\t\0" + /* 6794 */ "fcvt.d.l\t\0" + /* 6804 */ "fcvt.h.l\t\0" + /* 6814 */ "fcvt.s.l\t\0" + /* 6824 */ "sha512sig0l\t\0" + /* 6837 */ "sha512sig1l\t\0" + /* 6850 */ "c.jal\t\0" + /* 6857 */ "cbo.inval\t\0" + /* 6868 */ "tail\t\0" + /* 6874 */ "call\t\0" + /* 6880 */ "sll\t\0" + /* 6885 */ "rol\t\0" + /* 6890 */ "sc.d.rl\t\0" + /* 6899 */ "amoadd.d.rl\t\0" + /* 6912 */ "amoand.d.rl\t\0" + /* 6925 */ "amomin.d.rl\t\0" + /* 6938 */ "ssamoswap.d.rl\t\0" + /* 6954 */ "lr.d.rl\t\0" + /* 6963 */ "amoor.d.rl\t\0" + /* 6975 */ "amoxor.d.rl\t\0" + /* 6988 */ "amocas.d.rl\t\0" + /* 7001 */ "amominu.d.rl\t\0" + /* 7015 */ "amomaxu.d.rl\t\0" + /* 7029 */ "amomax.d.rl\t\0" + /* 7042 */ "amocas.q.rl\t\0" + /* 7055 */ "sc.w.rl\t\0" + /* 7064 */ "amoadd.w.rl\t\0" + /* 7077 */ "amoand.w.rl\t\0" + /* 7090 */ "amomin.w.rl\t\0" + /* 7103 */ "ssamoswap.w.rl\t\0" + /* 7119 */ "lr.w.rl\t\0" + /* 7128 */ "amoor.w.rl\t\0" + /* 7140 */ "amoxor.w.rl\t\0" + /* 7153 */ "amocas.w.rl\t\0" + /* 7166 */ "amominu.w.rl\t\0" + /* 7180 */ "amomaxu.w.rl\t\0" + /* 7194 */ "amomax.w.rl\t\0" + /* 7207 */ "sc.d.aqrl\t\0" + /* 7218 */ "amoadd.d.aqrl\t\0" + /* 7233 */ "amoand.d.aqrl\t\0" + /* 7248 */ "amomin.d.aqrl\t\0" + /* 7263 */ "ssamoswap.d.aqrl\t\0" + /* 7281 */ "lr.d.aqrl\t\0" + /* 7292 */ "amoor.d.aqrl\t\0" + /* 7306 */ "amoxor.d.aqrl\t\0" + /* 7321 */ "amocas.d.aqrl\t\0" + /* 7336 */ "amominu.d.aqrl\t\0" + /* 7352 */ "amomaxu.d.aqrl\t\0" + /* 7368 */ "amomax.d.aqrl\t\0" + /* 7383 */ "amocas.q.aqrl\t\0" + /* 7398 */ "sc.w.aqrl\t\0" + /* 7409 */ "amoadd.w.aqrl\t\0" + /* 7424 */ "amoand.w.aqrl\t\0" + /* 7439 */ "amomin.w.aqrl\t\0" + /* 7454 */ "ssamoswap.w.aqrl\t\0" + /* 7472 */ "lr.w.aqrl\t\0" + /* 7483 */ "amoor.w.aqrl\t\0" + /* 7497 */ "amoxor.w.aqrl\t\0" + /* 7512 */ "amocas.w.aqrl\t\0" + /* 7527 */ "amominu.w.aqrl\t\0" + /* 7543 */ "amomaxu.w.aqrl\t\0" + /* 7559 */ "amomax.w.aqrl\t\0" + /* 7574 */ "srl\t\0" + /* 7579 */ "th.addsl\t\0" + /* 7589 */ "c.mul\t\0" + /* 7596 */ "clmul\t\0" + /* 7603 */ "vsetvl\t\0" + /* 7611 */ "viota.m\t\0" + /* 7620 */ "vmsbf.m\t\0" + /* 7629 */ "vmsif.m\t\0" + /* 7638 */ "vmsof.m\t\0" + /* 7647 */ "vcpop.m\t\0" + /* 7656 */ "vfirst.m\t\0" + /* 7666 */ "rem\t\0" + /* 7671 */ "vfmerge.vfm\t\0" + /* 7684 */ "aes64im\t\0" + /* 7693 */ "vmadc.vim\t\0" + /* 7704 */ "vadc.vim\t\0" + /* 7714 */ "vmerge.vim\t\0" + /* 7726 */ "vmand.mm\t\0" + /* 7736 */ "vmnand.mm\t\0" + /* 7747 */ "vmandn.mm\t\0" + /* 7758 */ "vmorn.mm\t\0" + /* 7768 */ "vmor.mm\t\0" + /* 7777 */ "vmnor.mm\t\0" + /* 7787 */ "vmxnor.mm\t\0" + /* 7798 */ "vmxor.mm\t\0" + /* 7808 */ "cv.bneimm\t\0" + /* 7819 */ "cv.beqimm\t\0" + /* 7830 */ "aes64dsm\t\0" + /* 7840 */ "aes64esm\t\0" + /* 7850 */ "vcompress.vm\t\0" + /* 7864 */ "vmsbc.vvm\t\0" + /* 7875 */ "vsbc.vvm\t\0" + /* 7885 */ "vmadc.vvm\t\0" + /* 7896 */ "vadc.vvm\t\0" + /* 7906 */ "vmerge.vvm\t\0" + /* 7918 */ "vmsbc.vxm\t\0" + /* 7929 */ "vsbc.vxm\t\0" + /* 7939 */ "vmadc.vxm\t\0" + /* 7950 */ "vadc.vxm\t\0" + /* 7960 */ "vmerge.vxm\t\0" + /* 7972 */ "cbo.clean\t\0" + /* 7983 */ "cv.subn\t\0" + /* 7992 */ "vt.maskcn\t\0" + /* 8003 */ "cv.addn\t\0" + /* 8012 */ "andn\t\0" + /* 8018 */ "cv.min\t\0" + /* 8026 */ "c.addi4spn\t\0" + /* 8038 */ "cv.subrn\t\0" + /* 8048 */ "cv.addrn\t\0" + /* 8058 */ "orn\t\0" + /* 8063 */ "cv.macsrn\t\0" + /* 8074 */ "cv.machhsrn\t\0" + /* 8087 */ "cv.mulhhsrn\t\0" + /* 8100 */ "cv.mulsrn\t\0" + /* 8111 */ "cv.suburn\t\0" + /* 8122 */ "cv.macurn\t\0" + /* 8133 */ "cv.addurn\t\0" + /* 8144 */ "cv.machhurn\t\0" + /* 8157 */ "cv.mulhhurn\t\0" + /* 8170 */ "cv.mulurn\t\0" + /* 8181 */ "cv.macsn\t\0" + /* 8191 */ "cv.machhsn\t\0" + /* 8203 */ "cv.mulhhsn\t\0" + /* 8215 */ "cv.mulsn\t\0" + /* 8225 */ "cv.subun\t\0" + /* 8235 */ "cv.macun\t\0" + /* 8245 */ "cv.addun\t\0" + /* 8255 */ "cv.machhun\t\0" + /* 8267 */ "cv.mulhhun\t\0" + /* 8279 */ "cv.mulun\t\0" + /* 8289 */ "cbo.zero\t\0" + /* 8299 */ "ssrdp\t\0" + /* 8306 */ "cv.clip\t\0" + /* 8315 */ "unzip\t\0" + /* 8322 */ "jump\t\0" + /* 8328 */ "c.nop\t\0" + /* 8335 */ "cm.pop\t\0" + /* 8343 */ "cpop\t\0" + /* 8349 */ "c.addi16sp\t\0" + /* 8361 */ "c.ldsp\t\0" + /* 8369 */ "c.fldsp\t\0" + /* 8378 */ "c.sdsp\t\0" + /* 8386 */ "c.fsdsp\t\0" + /* 8395 */ "c.lwsp\t\0" + /* 8403 */ "c.flwsp\t\0" + /* 8412 */ "c.swsp\t\0" + /* 8420 */ "c.fswsp\t\0" + /* 8429 */ "amocas.q\t\0" + /* 8439 */ "sc.d.aq\t\0" + /* 8448 */ "amoadd.d.aq\t\0" + /* 8461 */ "amoand.d.aq\t\0" + /* 8474 */ "amomin.d.aq\t\0" + /* 8487 */ "ssamoswap.d.aq\t\0" + /* 8503 */ "lr.d.aq\t\0" + /* 8512 */ "amoor.d.aq\t\0" + /* 8524 */ "amoxor.d.aq\t\0" + /* 8537 */ "amocas.d.aq\t\0" + /* 8550 */ "amominu.d.aq\t\0" + /* 8564 */ "amomaxu.d.aq\t\0" + /* 8578 */ "amomax.d.aq\t\0" + /* 8591 */ "amocas.q.aq\t\0" + /* 8604 */ "sc.w.aq\t\0" + /* 8613 */ "amoadd.w.aq\t\0" + /* 8626 */ "amoand.w.aq\t\0" + /* 8639 */ "amomin.w.aq\t\0" + /* 8652 */ "ssamoswap.w.aq\t\0" + /* 8668 */ "lr.w.aq\t\0" + /* 8677 */ "amoor.w.aq\t\0" + /* 8689 */ "amoxor.w.aq\t\0" + /* 8702 */ "amocas.w.aq\t\0" + /* 8715 */ "amominu.w.aq\t\0" + /* 8729 */ "amomaxu.w.aq\t\0" + /* 8743 */ "amomax.w.aq\t\0" + /* 8756 */ "beq\t\0" + /* 8761 */ "prefetch.r\t\0" + /* 8773 */ "cv.cplxmul.r\t\0" + /* 8787 */ "sha512sum0r\t\0" + /* 8800 */ "sha512sum1r\t\0" + /* 8813 */ "c.jr\t\0" + /* 8819 */ "c.jalr\t\0" + /* 8827 */ "cv.bclr\t\0" + /* 8836 */ "clmulr\t\0" + /* 8844 */ "cv.subnr\t\0" + /* 8854 */ "cv.addnr\t\0" + /* 8864 */ "cv.subrnr\t\0" + /* 8875 */ "cv.addrnr\t\0" + /* 8886 */ "cv.suburnr\t\0" + /* 8898 */ "cv.addurnr\t\0" + /* 8910 */ "cv.subunr\t\0" + /* 8921 */ "cv.addunr\t\0" + /* 8932 */ "c.or\t\0" + /* 8938 */ "xnor\t\0" + /* 8944 */ "cv.ror\t\0" + /* 8952 */ "c.xor\t\0" + /* 8959 */ "cv.clipr\t\0" + /* 8969 */ "cv.bclrr\t\0" + /* 8979 */ "cv.extractr\t\0" + /* 8992 */ "cv.bsetr\t\0" + /* 9002 */ "cv.insertr\t\0" + /* 9014 */ "cv.clipur\t\0" + /* 9025 */ "cv.extractur\t\0" + /* 9039 */ "fcvt.bf16.s\t\0" + /* 9052 */ "fsub.s\t\0" + /* 9060 */ "fmsub.s\t\0" + /* 9069 */ "fnmsub.s\t\0" + /* 9079 */ "fcvt.d.s\t\0" + /* 9089 */ "fadd.s\t\0" + /* 9097 */ "fmadd.s\t\0" + /* 9106 */ "fnmadd.s\t\0" + /* 9116 */ "fround.s\t\0" + /* 9126 */ "fle.s\t\0" + /* 9133 */ "vfmv.f.s\t\0" + /* 9143 */ "fcvt.h.s\t\0" + /* 9153 */ "fli.s\t\0" + /* 9160 */ "fsgnj.s\t\0" + /* 9169 */ "fcvt.l.s\t\0" + /* 9179 */ "fmul.s\t\0" + /* 9187 */ "fminm.s\t\0" + /* 9196 */ "fmaxm.s\t\0" + /* 9205 */ "fmin.s\t\0" + /* 9213 */ "fsgnjn.s\t\0" + /* 9223 */ "feq.s\t\0" + /* 9230 */ "fleq.s\t\0" + /* 9238 */ "fltq.s\t\0" + /* 9246 */ "fclass.s\t\0" + /* 9256 */ "flt.s\t\0" + /* 9263 */ "fsqrt.s\t\0" + /* 9272 */ "fcvt.lu.s\t\0" + /* 9283 */ "fcvt.wu.s\t\0" + /* 9294 */ "fdiv.s\t\0" + /* 9302 */ "fcvt.w.s\t\0" + /* 9312 */ "vmv.x.s\t\0" + /* 9321 */ "fmax.s\t\0" + /* 9329 */ "fsgnjx.s\t\0" + /* 9339 */ "froundnx.s\t\0" + /* 9351 */ "cm.mva01s\t\0" + /* 9362 */ "th.sfence.vmas\t\0" + /* 9378 */ "cv.abs\t\0" + /* 9386 */ "cv.extbs\t\0" + /* 9396 */ "aes64ds\t\0" + /* 9405 */ "aes64es\t\0" + /* 9414 */ "cv.exths\t\0" + /* 9424 */ "sm4ks\t\0" + /* 9431 */ "th.muls\t\0" + /* 9440 */ "csrrs\t\0" + /* 9447 */ "vredand.vs\t\0" + /* 9459 */ "vaesdf.vs\t\0" + /* 9470 */ "vaesef.vs\t\0" + /* 9481 */ "vaesdm.vs\t\0" + /* 9492 */ "vaesem.vs\t\0" + /* 9503 */ "vredsum.vs\t\0" + /* 9515 */ "vwredsum.vs\t\0" + /* 9528 */ "vfredosum.vs\t\0" + /* 9542 */ "vfwredosum.vs\t\0" + /* 9557 */ "vfredusum.vs\t\0" + /* 9571 */ "vfwredusum.vs\t\0" + /* 9586 */ "vfredmin.vs\t\0" + /* 9599 */ "vredmin.vs\t\0" + /* 9611 */ "vsm4r.vs\t\0" + /* 9621 */ "vredor.vs\t\0" + /* 9632 */ "vredxor.vs\t\0" + /* 9644 */ "vwredsumu.vs\t\0" + /* 9658 */ "vredminu.vs\t\0" + /* 9671 */ "vredmaxu.vs\t\0" + /* 9684 */ "vfredmax.vs\t\0" + /* 9697 */ "vredmax.vs\t\0" + /* 9709 */ "vaesz.vs\t\0" + /* 9719 */ "cv.extract\t\0" + /* 9731 */ "cv.slet\t\0" + /* 9740 */ "cm.popret\t\0" + /* 9751 */ "cv.bset\t\0" + /* 9760 */ "cm.jt\t\0" + /* 9767 */ "cm.jalt\t\0" + /* 9776 */ "blt\t\0" + /* 9781 */ "slt\t\0" + /* 9786 */ "cv.cnt\t\0" + /* 9794 */ "c.not\t\0" + /* 9801 */ "cv.insert\t\0" + /* 9812 */ "th.tst\t\0" + /* 9820 */ "th.ext\t\0" + /* 9828 */ "bext\t\0" + /* 9834 */ "hlv.bu\t\0" + /* 9842 */ "c.lbu\t\0" + /* 9849 */ "cv.lbu\t\0" + /* 9857 */ "th.lrbu\t\0" + /* 9866 */ "th.lurbu\t\0" + /* 9876 */ "bgeu\t\0" + /* 9882 */ "hlv.hu\t\0" + /* 9890 */ "hlvx.hu\t\0" + /* 9899 */ "c.lhu\t\0" + /* 9906 */ "cv.lhu\t\0" + /* 9914 */ "mulhu\t\0" + /* 9921 */ "th.lrhu\t\0" + /* 9930 */ "th.lurhu\t\0" + /* 9940 */ "sltiu\t\0" + /* 9947 */ "fcvt.d.lu\t\0" + /* 9958 */ "fcvt.h.lu\t\0" + /* 9969 */ "fcvt.s.lu\t\0" + /* 9980 */ "remu\t\0" + /* 9986 */ "cv.minu\t\0" + /* 9995 */ "cv.clipu\t\0" + /* 10005 */ "mulhsu\t\0" + /* 10013 */ "cv.msu\t\0" + /* 10021 */ "cv.extractu\t\0" + /* 10034 */ "cv.sletu\t\0" + /* 10044 */ "bltu\t\0" + /* 10050 */ "sltu\t\0" + /* 10056 */ "th.extu\t\0" + /* 10065 */ "divu\t\0" + /* 10071 */ "fcvt.d.wu\t\0" + /* 10082 */ "fcvt.h.wu\t\0" + /* 10093 */ "fcvt.s.wu\t\0" + /* 10104 */ "hlv.wu\t\0" + /* 10112 */ "hlvx.wu\t\0" + /* 10121 */ "lwu\t\0" + /* 10126 */ "th.lrwu\t\0" + /* 10135 */ "th.lurwu\t\0" + /* 10145 */ "cv.maxu\t\0" + /* 10154 */ "vlseg2e32.v\t\0" + /* 10167 */ "vlsseg2e32.v\t\0" + /* 10181 */ "vssseg2e32.v\t\0" + /* 10195 */ "vsseg2e32.v\t\0" + /* 10208 */ "vlseg3e32.v\t\0" + /* 10221 */ "vlsseg3e32.v\t\0" + /* 10235 */ "vssseg3e32.v\t\0" + /* 10249 */ "vsseg3e32.v\t\0" + /* 10262 */ "vlseg4e32.v\t\0" + /* 10275 */ "vlsseg4e32.v\t\0" + /* 10289 */ "vssseg4e32.v\t\0" + /* 10303 */ "vsseg4e32.v\t\0" + /* 10316 */ "vlseg5e32.v\t\0" + /* 10329 */ "vlsseg5e32.v\t\0" + /* 10343 */ "vssseg5e32.v\t\0" + /* 10357 */ "vsseg5e32.v\t\0" + /* 10370 */ "vlseg6e32.v\t\0" + /* 10383 */ "vlsseg6e32.v\t\0" + /* 10397 */ "vssseg6e32.v\t\0" + /* 10411 */ "vsseg6e32.v\t\0" + /* 10424 */ "vlseg7e32.v\t\0" + /* 10437 */ "vlsseg7e32.v\t\0" + /* 10451 */ "vssseg7e32.v\t\0" + /* 10465 */ "vsseg7e32.v\t\0" + /* 10478 */ "vlseg8e32.v\t\0" + /* 10491 */ "vlsseg8e32.v\t\0" + /* 10505 */ "vssseg8e32.v\t\0" + /* 10519 */ "vsseg8e32.v\t\0" + /* 10532 */ "vle32.v\t\0" + /* 10541 */ "vl1re32.v\t\0" + /* 10552 */ "vl2re32.v\t\0" + /* 10563 */ "vl4re32.v\t\0" + /* 10574 */ "vl8re32.v\t\0" + /* 10585 */ "vlse32.v\t\0" + /* 10595 */ "vsse32.v\t\0" + /* 10605 */ "vse32.v\t\0" + /* 10614 */ "vloxseg2ei32.v\t\0" + /* 10630 */ "vsoxseg2ei32.v\t\0" + /* 10646 */ "vluxseg2ei32.v\t\0" + /* 10662 */ "vsuxseg2ei32.v\t\0" + /* 10678 */ "vloxseg3ei32.v\t\0" + /* 10694 */ "vsoxseg3ei32.v\t\0" + /* 10710 */ "vluxseg3ei32.v\t\0" + /* 10726 */ "vsuxseg3ei32.v\t\0" + /* 10742 */ "vloxseg4ei32.v\t\0" + /* 10758 */ "vsoxseg4ei32.v\t\0" + /* 10774 */ "vluxseg4ei32.v\t\0" + /* 10790 */ "vsuxseg4ei32.v\t\0" + /* 10806 */ "vloxseg5ei32.v\t\0" + /* 10822 */ "vsoxseg5ei32.v\t\0" + /* 10838 */ "vluxseg5ei32.v\t\0" + /* 10854 */ "vsuxseg5ei32.v\t\0" + /* 10870 */ "vloxseg6ei32.v\t\0" + /* 10886 */ "vsoxseg6ei32.v\t\0" + /* 10902 */ "vluxseg6ei32.v\t\0" + /* 10918 */ "vsuxseg6ei32.v\t\0" + /* 10934 */ "vloxseg7ei32.v\t\0" + /* 10950 */ "vsoxseg7ei32.v\t\0" + /* 10966 */ "vluxseg7ei32.v\t\0" + /* 10982 */ "vsuxseg7ei32.v\t\0" + /* 10998 */ "vloxseg8ei32.v\t\0" + /* 11014 */ "vsoxseg8ei32.v\t\0" + /* 11030 */ "vluxseg8ei32.v\t\0" + /* 11046 */ "vsuxseg8ei32.v\t\0" + /* 11062 */ "vloxei32.v\t\0" + /* 11074 */ "vsoxei32.v\t\0" + /* 11086 */ "vluxei32.v\t\0" + /* 11098 */ "vsuxei32.v\t\0" + /* 11110 */ "vlseg2e64.v\t\0" + /* 11123 */ "vlsseg2e64.v\t\0" + /* 11137 */ "vssseg2e64.v\t\0" + /* 11151 */ "vsseg2e64.v\t\0" + /* 11164 */ "vlseg3e64.v\t\0" + /* 11177 */ "vlsseg3e64.v\t\0" + /* 11191 */ "vssseg3e64.v\t\0" + /* 11205 */ "vsseg3e64.v\t\0" + /* 11218 */ "vlseg4e64.v\t\0" + /* 11231 */ "vlsseg4e64.v\t\0" + /* 11245 */ "vssseg4e64.v\t\0" + /* 11259 */ "vsseg4e64.v\t\0" + /* 11272 */ "vlseg5e64.v\t\0" + /* 11285 */ "vlsseg5e64.v\t\0" + /* 11299 */ "vssseg5e64.v\t\0" + /* 11313 */ "vsseg5e64.v\t\0" + /* 11326 */ "vlseg6e64.v\t\0" + /* 11339 */ "vlsseg6e64.v\t\0" + /* 11353 */ "vssseg6e64.v\t\0" + /* 11367 */ "vsseg6e64.v\t\0" + /* 11380 */ "vlseg7e64.v\t\0" + /* 11393 */ "vlsseg7e64.v\t\0" + /* 11407 */ "vssseg7e64.v\t\0" + /* 11421 */ "vsseg7e64.v\t\0" + /* 11434 */ "vlseg8e64.v\t\0" + /* 11447 */ "vlsseg8e64.v\t\0" + /* 11461 */ "vssseg8e64.v\t\0" + /* 11475 */ "vsseg8e64.v\t\0" + /* 11488 */ "vle64.v\t\0" + /* 11497 */ "vl1re64.v\t\0" + /* 11508 */ "vl2re64.v\t\0" + /* 11519 */ "vl4re64.v\t\0" + /* 11530 */ "vl8re64.v\t\0" + /* 11541 */ "vlse64.v\t\0" + /* 11551 */ "vsse64.v\t\0" + /* 11561 */ "vse64.v\t\0" + /* 11570 */ "vloxseg2ei64.v\t\0" + /* 11586 */ "vsoxseg2ei64.v\t\0" + /* 11602 */ "vluxseg2ei64.v\t\0" + /* 11618 */ "vsuxseg2ei64.v\t\0" + /* 11634 */ "vloxseg3ei64.v\t\0" + /* 11650 */ "vsoxseg3ei64.v\t\0" + /* 11666 */ "vluxseg3ei64.v\t\0" + /* 11682 */ "vsuxseg3ei64.v\t\0" + /* 11698 */ "vloxseg4ei64.v\t\0" + /* 11714 */ "vsoxseg4ei64.v\t\0" + /* 11730 */ "vluxseg4ei64.v\t\0" + /* 11746 */ "vsuxseg4ei64.v\t\0" + /* 11762 */ "vloxseg5ei64.v\t\0" + /* 11778 */ "vsoxseg5ei64.v\t\0" + /* 11794 */ "vluxseg5ei64.v\t\0" + /* 11810 */ "vsuxseg5ei64.v\t\0" + /* 11826 */ "vloxseg6ei64.v\t\0" + /* 11842 */ "vsoxseg6ei64.v\t\0" + /* 11858 */ "vluxseg6ei64.v\t\0" + /* 11874 */ "vsuxseg6ei64.v\t\0" + /* 11890 */ "vloxseg7ei64.v\t\0" + /* 11906 */ "vsoxseg7ei64.v\t\0" + /* 11922 */ "vluxseg7ei64.v\t\0" + /* 11938 */ "vsuxseg7ei64.v\t\0" + /* 11954 */ "vloxseg8ei64.v\t\0" + /* 11970 */ "vsoxseg8ei64.v\t\0" + /* 11986 */ "vluxseg8ei64.v\t\0" + /* 12002 */ "vsuxseg8ei64.v\t\0" + /* 12018 */ "vloxei64.v\t\0" + /* 12030 */ "vsoxei64.v\t\0" + /* 12042 */ "vluxei64.v\t\0" + /* 12054 */ "vsuxei64.v\t\0" + /* 12066 */ "vlseg2e16.v\t\0" + /* 12079 */ "vlsseg2e16.v\t\0" + /* 12093 */ "vssseg2e16.v\t\0" + /* 12107 */ "vsseg2e16.v\t\0" + /* 12120 */ "vlseg3e16.v\t\0" + /* 12133 */ "vlsseg3e16.v\t\0" + /* 12147 */ "vssseg3e16.v\t\0" + /* 12161 */ "vsseg3e16.v\t\0" + /* 12174 */ "vlseg4e16.v\t\0" + /* 12187 */ "vlsseg4e16.v\t\0" + /* 12201 */ "vssseg4e16.v\t\0" + /* 12215 */ "vsseg4e16.v\t\0" + /* 12228 */ "vlseg5e16.v\t\0" + /* 12241 */ "vlsseg5e16.v\t\0" + /* 12255 */ "vssseg5e16.v\t\0" + /* 12269 */ "vsseg5e16.v\t\0" + /* 12282 */ "vlseg6e16.v\t\0" + /* 12295 */ "vlsseg6e16.v\t\0" + /* 12309 */ "vssseg6e16.v\t\0" + /* 12323 */ "vsseg6e16.v\t\0" + /* 12336 */ "vlseg7e16.v\t\0" + /* 12349 */ "vlsseg7e16.v\t\0" + /* 12363 */ "vssseg7e16.v\t\0" + /* 12377 */ "vsseg7e16.v\t\0" + /* 12390 */ "vlseg8e16.v\t\0" + /* 12403 */ "vlsseg8e16.v\t\0" + /* 12417 */ "vssseg8e16.v\t\0" + /* 12431 */ "vsseg8e16.v\t\0" + /* 12444 */ "vle16.v\t\0" + /* 12453 */ "vl1re16.v\t\0" + /* 12464 */ "vl2re16.v\t\0" + /* 12475 */ "vl4re16.v\t\0" + /* 12486 */ "vl8re16.v\t\0" + /* 12497 */ "vlse16.v\t\0" + /* 12507 */ "vsse16.v\t\0" + /* 12517 */ "vse16.v\t\0" + /* 12526 */ "vloxseg2ei16.v\t\0" + /* 12542 */ "vsoxseg2ei16.v\t\0" + /* 12558 */ "vluxseg2ei16.v\t\0" + /* 12574 */ "vsuxseg2ei16.v\t\0" + /* 12590 */ "vloxseg3ei16.v\t\0" + /* 12606 */ "vsoxseg3ei16.v\t\0" + /* 12622 */ "vluxseg3ei16.v\t\0" + /* 12638 */ "vsuxseg3ei16.v\t\0" + /* 12654 */ "vloxseg4ei16.v\t\0" + /* 12670 */ "vsoxseg4ei16.v\t\0" + /* 12686 */ "vluxseg4ei16.v\t\0" + /* 12702 */ "vsuxseg4ei16.v\t\0" + /* 12718 */ "vloxseg5ei16.v\t\0" + /* 12734 */ "vsoxseg5ei16.v\t\0" + /* 12750 */ "vluxseg5ei16.v\t\0" + /* 12766 */ "vsuxseg5ei16.v\t\0" + /* 12782 */ "vloxseg6ei16.v\t\0" + /* 12798 */ "vsoxseg6ei16.v\t\0" + /* 12814 */ "vluxseg6ei16.v\t\0" + /* 12830 */ "vsuxseg6ei16.v\t\0" + /* 12846 */ "vloxseg7ei16.v\t\0" + /* 12862 */ "vsoxseg7ei16.v\t\0" + /* 12878 */ "vluxseg7ei16.v\t\0" + /* 12894 */ "vsuxseg7ei16.v\t\0" + /* 12910 */ "vloxseg8ei16.v\t\0" + /* 12926 */ "vsoxseg8ei16.v\t\0" + /* 12942 */ "vluxseg8ei16.v\t\0" + /* 12958 */ "vsuxseg8ei16.v\t\0" + /* 12974 */ "vloxei16.v\t\0" + /* 12986 */ "vsoxei16.v\t\0" + /* 12998 */ "vluxei16.v\t\0" + /* 13010 */ "vsuxei16.v\t\0" + /* 13022 */ "vfrec7.v\t\0" + /* 13032 */ "vfrsqrt7.v\t\0" + /* 13044 */ "vlseg2e8.v\t\0" + /* 13056 */ "vlsseg2e8.v\t\0" + /* 13069 */ "vssseg2e8.v\t\0" + /* 13082 */ "vsseg2e8.v\t\0" + /* 13094 */ "vlseg3e8.v\t\0" + /* 13106 */ "vlsseg3e8.v\t\0" + /* 13119 */ "vssseg3e8.v\t\0" + /* 13132 */ "vsseg3e8.v\t\0" + /* 13144 */ "vlseg4e8.v\t\0" + /* 13156 */ "vlsseg4e8.v\t\0" + /* 13169 */ "vssseg4e8.v\t\0" + /* 13182 */ "vsseg4e8.v\t\0" + /* 13194 */ "vlseg5e8.v\t\0" + /* 13206 */ "vlsseg5e8.v\t\0" + /* 13219 */ "vssseg5e8.v\t\0" + /* 13232 */ "vsseg5e8.v\t\0" + /* 13244 */ "vlseg6e8.v\t\0" + /* 13256 */ "vlsseg6e8.v\t\0" + /* 13269 */ "vssseg6e8.v\t\0" + /* 13282 */ "vsseg6e8.v\t\0" + /* 13294 */ "vlseg7e8.v\t\0" + /* 13306 */ "vlsseg7e8.v\t\0" + /* 13319 */ "vssseg7e8.v\t\0" + /* 13332 */ "vsseg7e8.v\t\0" + /* 13344 */ "vlseg8e8.v\t\0" + /* 13356 */ "vlsseg8e8.v\t\0" + /* 13369 */ "vssseg8e8.v\t\0" + /* 13382 */ "vsseg8e8.v\t\0" + /* 13394 */ "vle8.v\t\0" + /* 13402 */ "vl1re8.v\t\0" + /* 13412 */ "vl2re8.v\t\0" + /* 13422 */ "vl4re8.v\t\0" + /* 13432 */ "vl8re8.v\t\0" + /* 13442 */ "vlse8.v\t\0" + /* 13451 */ "vsse8.v\t\0" + /* 13460 */ "vse8.v\t\0" + /* 13468 */ "vloxseg2ei8.v\t\0" + /* 13483 */ "vsoxseg2ei8.v\t\0" + /* 13498 */ "vluxseg2ei8.v\t\0" + /* 13513 */ "vsuxseg2ei8.v\t\0" + /* 13528 */ "vloxseg3ei8.v\t\0" + /* 13543 */ "vsoxseg3ei8.v\t\0" + /* 13558 */ "vluxseg3ei8.v\t\0" + /* 13573 */ "vsuxseg3ei8.v\t\0" + /* 13588 */ "vloxseg4ei8.v\t\0" + /* 13603 */ "vsoxseg4ei8.v\t\0" + /* 13618 */ "vluxseg4ei8.v\t\0" + /* 13633 */ "vsuxseg4ei8.v\t\0" + /* 13648 */ "vloxseg5ei8.v\t\0" + /* 13663 */ "vsoxseg5ei8.v\t\0" + /* 13678 */ "vluxseg5ei8.v\t\0" + /* 13693 */ "vsuxseg5ei8.v\t\0" + /* 13708 */ "vloxseg6ei8.v\t\0" + /* 13723 */ "vsoxseg6ei8.v\t\0" + /* 13738 */ "vluxseg6ei8.v\t\0" + /* 13753 */ "vsuxseg6ei8.v\t\0" + /* 13768 */ "vloxseg7ei8.v\t\0" + /* 13783 */ "vsoxseg7ei8.v\t\0" + /* 13798 */ "vluxseg7ei8.v\t\0" + /* 13813 */ "vsuxseg7ei8.v\t\0" + /* 13828 */ "vloxseg8ei8.v\t\0" + /* 13843 */ "vsoxseg8ei8.v\t\0" + /* 13858 */ "vluxseg8ei8.v\t\0" + /* 13873 */ "vsuxseg8ei8.v\t\0" + /* 13888 */ "vloxei8.v\t\0" + /* 13899 */ "vsoxei8.v\t\0" + /* 13910 */ "vluxei8.v\t\0" + /* 13921 */ "vsuxei8.v\t\0" + /* 13932 */ "vbrev8.v\t\0" + /* 13942 */ "vrev8.v\t\0" + /* 13951 */ "vid.v\t\0" + /* 13958 */ "vfwcvtbf16.f.f.v\t\0" + /* 13976 */ "vfwcvt.f.f.v\t\0" + /* 13990 */ "vfcvt.xu.f.v\t\0" + /* 14004 */ "vfwcvt.xu.f.v\t\0" + /* 14019 */ "vfcvt.rtz.xu.f.v\t\0" + /* 14037 */ "vfwcvt.rtz.xu.f.v\t\0" + /* 14056 */ "vfcvt.x.f.v\t\0" + /* 14069 */ "vfwcvt.x.f.v\t\0" + /* 14083 */ "vfcvt.rtz.x.f.v\t\0" + /* 14100 */ "vfwcvt.rtz.x.f.v\t\0" + /* 14118 */ "vlseg2e32ff.v\t\0" + /* 14133 */ "vlseg3e32ff.v\t\0" + /* 14148 */ "vlseg4e32ff.v\t\0" + /* 14163 */ "vlseg5e32ff.v\t\0" + /* 14178 */ "vlseg6e32ff.v\t\0" + /* 14193 */ "vlseg7e32ff.v\t\0" + /* 14208 */ "vlseg8e32ff.v\t\0" + /* 14223 */ "vle32ff.v\t\0" + /* 14234 */ "vlseg2e64ff.v\t\0" + /* 14249 */ "vlseg3e64ff.v\t\0" + /* 14264 */ "vlseg4e64ff.v\t\0" + /* 14279 */ "vlseg5e64ff.v\t\0" + /* 14294 */ "vlseg6e64ff.v\t\0" + /* 14309 */ "vlseg7e64ff.v\t\0" + /* 14324 */ "vlseg8e64ff.v\t\0" + /* 14339 */ "vle64ff.v\t\0" + /* 14350 */ "vlseg2e16ff.v\t\0" + /* 14365 */ "vlseg3e16ff.v\t\0" + /* 14380 */ "vlseg4e16ff.v\t\0" + /* 14395 */ "vlseg5e16ff.v\t\0" + /* 14410 */ "vlseg6e16ff.v\t\0" + /* 14425 */ "vlseg7e16ff.v\t\0" + /* 14440 */ "vlseg8e16ff.v\t\0" + /* 14455 */ "vle16ff.v\t\0" + /* 14466 */ "vlseg2e8ff.v\t\0" + /* 14480 */ "vlseg3e8ff.v\t\0" + /* 14494 */ "vlseg4e8ff.v\t\0" + /* 14508 */ "vlseg5e8ff.v\t\0" + /* 14522 */ "vlseg6e8ff.v\t\0" + /* 14536 */ "vlseg7e8ff.v\t\0" + /* 14550 */ "vlseg8e8ff.v\t\0" + /* 14564 */ "vle8ff.v\t\0" + /* 14574 */ "vlm.v\t\0" + /* 14581 */ "vsm.v\t\0" + /* 14588 */ "vcpop.v\t\0" + /* 14597 */ "vs1r.v\t\0" + /* 14605 */ "vmv1r.v\t\0" + /* 14614 */ "vs2r.v\t\0" + /* 14622 */ "vmv2r.v\t\0" + /* 14631 */ "vs4r.v\t\0" + /* 14639 */ "vmv4r.v\t\0" + /* 14648 */ "vs8r.v\t\0" + /* 14656 */ "vmv8r.v\t\0" + /* 14665 */ "vfclass.v\t\0" + /* 14676 */ "vfsqrt.v\t\0" + /* 14686 */ "vfcvt.f.xu.v\t\0" + /* 14700 */ "vfwcvt.f.xu.v\t\0" + /* 14715 */ "vmv.v.v\t\0" + /* 14724 */ "vbrev.v\t\0" + /* 14733 */ "vfcvt.f.x.v\t\0" + /* 14746 */ "vfwcvt.f.x.v\t\0" + /* 14760 */ "vclz.v\t\0" + /* 14768 */ "vctz.v\t\0" + /* 14776 */ "th.rev\t\0" + /* 14784 */ "cv.bitrev\t\0" + /* 14795 */ "sf.vc.fv\t\0" + /* 14805 */ "sf.vc.v.fv\t\0" + /* 14817 */ "sf.vc.iv\t\0" + /* 14827 */ "sf.vc.v.iv\t\0" + /* 14839 */ "div\t\0" + /* 14844 */ "c.mv\t\0" + /* 14850 */ "binv\t\0" + /* 14856 */ "vfwmaccbf16.vv\t\0" + /* 14872 */ "vrgatherei16.vv\t\0" + /* 14889 */ "th.vmaqa.vv\t\0" + /* 14902 */ "vssra.vv\t\0" + /* 14912 */ "vsra.vv\t\0" + /* 14921 */ "vasub.vv\t\0" + /* 14931 */ "vfsub.vv\t\0" + /* 14941 */ "vfmsub.vv\t\0" + /* 14952 */ "vfnmsub.vv\t\0" + /* 14964 */ "vnmsub.vv\t\0" + /* 14975 */ "vssub.vv\t\0" + /* 14985 */ "vsub.vv\t\0" + /* 14994 */ "vfwsub.vv\t\0" + /* 15005 */ "vwsub.vv\t\0" + /* 15015 */ "vfmsac.vv\t\0" + /* 15026 */ "vfnmsac.vv\t\0" + /* 15038 */ "vnmsac.vv\t\0" + /* 15049 */ "vfwnmsac.vv\t\0" + /* 15062 */ "vfwmsac.vv\t\0" + /* 15074 */ "vmsbc.vv\t\0" + /* 15084 */ "vfmacc.vv\t\0" + /* 15095 */ "vfnmacc.vv\t\0" + /* 15107 */ "vfwnmacc.vv\t\0" + /* 15120 */ "vmacc.vv\t\0" + /* 15130 */ "vfwmacc.vv\t\0" + /* 15142 */ "vwmacc.vv\t\0" + /* 15153 */ "vmadc.vv\t\0" + /* 15163 */ "sf.vc.vv\t\0" + /* 15173 */ "vaadd.vv\t\0" + /* 15183 */ "vfadd.vv\t\0" + /* 15193 */ "vfmadd.vv\t\0" + /* 15204 */ "vfnmadd.vv\t\0" + /* 15216 */ "vmadd.vv\t\0" + /* 15226 */ "vsadd.vv\t\0" + /* 15236 */ "vadd.vv\t\0" + /* 15245 */ "vfwadd.vv\t\0" + /* 15256 */ "vwadd.vv\t\0" + /* 15266 */ "vand.vv\t\0" + /* 15275 */ "vmfle.vv\t\0" + /* 15285 */ "vmsle.vv\t\0" + /* 15295 */ "vsm3me.vv\t\0" + /* 15306 */ "vmfne.vv\t\0" + /* 15316 */ "vmsne.vv\t\0" + /* 15326 */ "vaesdf.vv\t\0" + /* 15337 */ "vaesef.vv\t\0" + /* 15348 */ "vsha2ch.vv\t\0" + /* 15360 */ "vclmulh.vv\t\0" + /* 15372 */ "vmulh.vv\t\0" + /* 15382 */ "vghsh.vv\t\0" + /* 15392 */ "vfsgnj.vv\t\0" + /* 15403 */ "vsha2cl.vv\t\0" + /* 15415 */ "vsll.vv\t\0" + /* 15424 */ "vwsll.vv\t\0" + /* 15434 */ "vrol.vv\t\0" + /* 15443 */ "vssrl.vv\t\0" + /* 15453 */ "vsrl.vv\t\0" + /* 15462 */ "vfmul.vv\t\0" + /* 15472 */ "vgmul.vv\t\0" + /* 15482 */ "vclmul.vv\t\0" + /* 15493 */ "vsmul.vv\t\0" + /* 15503 */ "vmul.vv\t\0" + /* 15512 */ "vfwmul.vv\t\0" + /* 15523 */ "vwmul.vv\t\0" + /* 15533 */ "vaesdm.vv\t\0" + /* 15544 */ "vrem.vv\t\0" + /* 15553 */ "vaesem.vv\t\0" + /* 15564 */ "vandn.vv\t\0" + /* 15574 */ "vfmin.vv\t\0" + /* 15584 */ "vmin.vv\t\0" + /* 15593 */ "vfsgnjn.vv\t\0" + /* 15605 */ "vmfeq.vv\t\0" + /* 15615 */ "vmseq.vv\t\0" + /* 15625 */ "vsm4r.vv\t\0" + /* 15635 */ "vrgather.vv\t\0" + /* 15648 */ "vror.vv\t\0" + /* 15657 */ "vor.vv\t\0" + /* 15665 */ "vxor.vv\t\0" + /* 15674 */ "vsha2ms.vv\t\0" + /* 15686 */ "vmflt.vv\t\0" + /* 15696 */ "vmslt.vv\t\0" + /* 15706 */ "th.vmaqau.vv\t\0" + /* 15720 */ "vasubu.vv\t\0" + /* 15731 */ "vssubu.vv\t\0" + /* 15742 */ "vwsubu.vv\t\0" + /* 15753 */ "vwmaccu.vv\t\0" + /* 15765 */ "vaaddu.vv\t\0" + /* 15776 */ "vsaddu.vv\t\0" + /* 15787 */ "vwaddu.vv\t\0" + /* 15798 */ "vmsleu.vv\t\0" + /* 15809 */ "vmulhu.vv\t\0" + /* 15820 */ "vwmulu.vv\t\0" + /* 15831 */ "vremu.vv\t\0" + /* 15841 */ "vminu.vv\t\0" + /* 15851 */ "th.vmaqasu.vv\t\0" + /* 15866 */ "vwmaccsu.vv\t\0" + /* 15879 */ "vmulhsu.vv\t\0" + /* 15891 */ "vwmulsu.vv\t\0" + /* 15903 */ "vmsltu.vv\t\0" + /* 15914 */ "vdivu.vv\t\0" + /* 15924 */ "vmaxu.vv\t\0" + /* 15934 */ "sf.vc.v.vv\t\0" + /* 15946 */ "vfdiv.vv\t\0" + /* 15956 */ "vdiv.vv\t\0" + /* 15965 */ "vfmax.vv\t\0" + /* 15975 */ "vmax.vv\t\0" + /* 15984 */ "vfsgnjx.vv\t\0" + /* 15996 */ "sf.vc.fvv\t\0" + /* 16007 */ "sf.vc.v.fvv\t\0" + /* 16020 */ "sf.vc.ivv\t\0" + /* 16031 */ "sf.vc.v.ivv\t\0" + /* 16044 */ "sf.vc.vvv\t\0" + /* 16055 */ "sf.vc.v.vvv\t\0" + /* 16068 */ "sf.vc.xvv\t\0" + /* 16079 */ "sf.vc.v.xvv\t\0" + /* 16092 */ "vnsra.wv\t\0" + /* 16102 */ "vfwsub.wv\t\0" + /* 16113 */ "vwsub.wv\t\0" + /* 16123 */ "vfwadd.wv\t\0" + /* 16134 */ "vwadd.wv\t\0" + /* 16144 */ "vnsrl.wv\t\0" + /* 16154 */ "vnclip.wv\t\0" + /* 16165 */ "vwsubu.wv\t\0" + /* 16176 */ "vwaddu.wv\t\0" + /* 16187 */ "vnclipu.wv\t\0" + /* 16199 */ "sf.vc.xv\t\0" + /* 16209 */ "sf.vc.v.xv\t\0" + /* 16221 */ "sc.w\t\0" + /* 16227 */ "fcvt.d.w\t\0" + /* 16237 */ "amoadd.w\t\0" + /* 16247 */ "amoand.w\t\0" + /* 16257 */ "vfncvtbf16.f.f.w\t\0" + /* 16275 */ "vfncvt.rod.f.f.w\t\0" + /* 16293 */ "vfncvt.f.f.w\t\0" + /* 16307 */ "vfncvt.xu.f.w\t\0" + /* 16322 */ "vfncvt.rtz.xu.f.w\t\0" + /* 16341 */ "vfncvt.x.f.w\t\0" + /* 16355 */ "vfncvt.rtz.x.f.w\t\0" + /* 16373 */ "fcvt.h.w\t\0" + /* 16383 */ "prefetch.w\t\0" + /* 16395 */ "amomin.w\t\0" + /* 16405 */ "ssamoswap.w\t\0" + /* 16418 */ "lr.w\t\0" + /* 16424 */ "amoor.w\t\0" + /* 16433 */ "amoxor.w\t\0" + /* 16443 */ "fcvt.s.w\t\0" + /* 16453 */ "amocas.w\t\0" + /* 16463 */ "c.zext.w\t\0" + /* 16473 */ "amominu.w\t\0" + /* 16484 */ "vfncvt.f.xu.w\t\0" + /* 16499 */ "amomaxu.w\t\0" + /* 16510 */ "hlv.w\t\0" + /* 16517 */ "hsv.w\t\0" + /* 16524 */ "vfncvt.f.x.w\t\0" + /* 16538 */ "fmv.x.w\t\0" + /* 16547 */ "amomax.w\t\0" + /* 16557 */ "th.mulaw\t\0" + /* 16567 */ "sraw\t\0" + /* 16573 */ "c.subw\t\0" + /* 16581 */ "c.addw\t\0" + /* 16589 */ "sraiw\t\0" + /* 16596 */ "c.addiw\t\0" + /* 16605 */ "slliw\t\0" + /* 16612 */ "srliw\t\0" + /* 16619 */ "roriw\t\0" + /* 16626 */ "th.srriw\t\0" + /* 16636 */ "packw\t\0" + /* 16643 */ "c.lw\t\0" + /* 16649 */ "cv.lw\t\0" + /* 16656 */ "cv.elw\t\0" + /* 16664 */ "c.flw\t\0" + /* 16671 */ "sllw\t\0" + /* 16677 */ "rolw\t\0" + /* 16683 */ "srlw\t\0" + /* 16689 */ "mulw\t\0" + /* 16695 */ "remw\t\0" + /* 16701 */ "cpopw\t\0" + /* 16708 */ "th.lrw\t\0" + /* 16716 */ "th.flrw\t\0" + /* 16725 */ "rorw\t\0" + /* 16731 */ "csrrw\t\0" + /* 16738 */ "th.srw\t\0" + /* 16746 */ "th.fsrw\t\0" + /* 16755 */ "th.lurw\t\0" + /* 16764 */ "th.flurw\t\0" + /* 16774 */ "th.surw\t\0" + /* 16783 */ "th.fsurw\t\0" + /* 16793 */ "c.sw\t\0" + /* 16799 */ "cv.sw\t\0" + /* 16806 */ "th.dcache.csw\t\0" + /* 16821 */ "c.fsw\t\0" + /* 16828 */ "th.dcache.isw\t\0" + /* 16843 */ "th.dcache.cisw\t\0" + /* 16859 */ "th.mulsw\t\0" + /* 16869 */ "sh1add.uw\t\0" + /* 16880 */ "sh2add.uw\t\0" + /* 16891 */ "sh3add.uw\t\0" + /* 16902 */ "slli.uw\t\0" + /* 16911 */ "remuw\t\0" + /* 16918 */ "divuw\t\0" + /* 16925 */ "th.revw\t\0" + /* 16934 */ "sf.vc.fvw\t\0" + /* 16945 */ "sf.vc.v.fvw\t\0" + /* 16958 */ "sf.vc.ivw\t\0" + /* 16969 */ "sf.vc.v.ivw\t\0" + /* 16982 */ "divw\t\0" + /* 16988 */ "sf.vc.vvw\t\0" + /* 16999 */ "sf.vc.v.vvw\t\0" + /* 17012 */ "sf.vc.xvw\t\0" + /* 17023 */ "sf.vc.v.xvw\t\0" + /* 17036 */ "clzw\t\0" + /* 17042 */ "ctzw\t\0" + /* 17048 */ "sf.vc.x\t\0" + /* 17057 */ "fmvp.d.x\t\0" + /* 17067 */ "fmv.d.x\t\0" + /* 17076 */ "fmv.h.x\t\0" + /* 17085 */ "vmv.s.x\t\0" + /* 17094 */ "sf.vc.v.x\t\0" + /* 17105 */ "vmv.v.x\t\0" + /* 17114 */ "fmv.w.x\t\0" + /* 17123 */ "cv.max\t\0" + /* 17131 */ "th.vmaqa.vx\t\0" + /* 17144 */ "vssra.vx\t\0" + /* 17154 */ "vsra.vx\t\0" + /* 17163 */ "vasub.vx\t\0" + /* 17173 */ "vnmsub.vx\t\0" + /* 17184 */ "vrsub.vx\t\0" + /* 17194 */ "vssub.vx\t\0" + /* 17204 */ "vsub.vx\t\0" + /* 17213 */ "vwsub.vx\t\0" + /* 17223 */ "vnmsac.vx\t\0" + /* 17234 */ "vmsbc.vx\t\0" + /* 17244 */ "vmacc.vx\t\0" + /* 17254 */ "vwmacc.vx\t\0" + /* 17265 */ "vmadc.vx\t\0" + /* 17275 */ "vaadd.vx\t\0" + /* 17285 */ "vmadd.vx\t\0" + /* 17295 */ "vsadd.vx\t\0" + /* 17305 */ "vadd.vx\t\0" + /* 17314 */ "vwadd.vx\t\0" + /* 17324 */ "vand.vx\t\0" + /* 17333 */ "vmsge.vx\t\0" + /* 17343 */ "vmsle.vx\t\0" + /* 17353 */ "vmsne.vx\t\0" + /* 17363 */ "vclmulh.vx\t\0" + /* 17375 */ "vmulh.vx\t\0" + /* 17385 */ "vsll.vx\t\0" + /* 17394 */ "vwsll.vx\t\0" + /* 17404 */ "vrol.vx\t\0" + /* 17413 */ "vssrl.vx\t\0" + /* 17423 */ "vsrl.vx\t\0" + /* 17432 */ "vclmul.vx\t\0" + /* 17443 */ "vsmul.vx\t\0" + /* 17453 */ "vmul.vx\t\0" + /* 17462 */ "vwmul.vx\t\0" + /* 17472 */ "vrem.vx\t\0" + /* 17481 */ "vandn.vx\t\0" + /* 17491 */ "vmin.vx\t\0" + /* 17500 */ "vslide1down.vx\t\0" + /* 17516 */ "vslidedown.vx\t\0" + /* 17531 */ "vslide1up.vx\t\0" + /* 17545 */ "vslideup.vx\t\0" + /* 17558 */ "vmseq.vx\t\0" + /* 17568 */ "vrgather.vx\t\0" + /* 17581 */ "vror.vx\t\0" + /* 17590 */ "vor.vx\t\0" + /* 17598 */ "vxor.vx\t\0" + /* 17607 */ "th.vmaqaus.vx\t\0" + /* 17622 */ "vwmaccus.vx\t\0" + /* 17635 */ "vmsgt.vx\t\0" + /* 17645 */ "vmslt.vx\t\0" + /* 17655 */ "th.vmaqau.vx\t\0" + /* 17669 */ "vasubu.vx\t\0" + /* 17680 */ "vssubu.vx\t\0" + /* 17691 */ "vwsubu.vx\t\0" + /* 17702 */ "vwmaccu.vx\t\0" + /* 17714 */ "vaaddu.vx\t\0" + /* 17725 */ "vsaddu.vx\t\0" + /* 17736 */ "vwaddu.vx\t\0" + /* 17747 */ "vmsgeu.vx\t\0" + /* 17758 */ "vmsleu.vx\t\0" + /* 17769 */ "vmulhu.vx\t\0" + /* 17780 */ "vwmulu.vx\t\0" + /* 17791 */ "vremu.vx\t\0" + /* 17801 */ "vminu.vx\t\0" + /* 17811 */ "th.vmaqasu.vx\t\0" + /* 17826 */ "vwmaccsu.vx\t\0" + /* 17839 */ "vmulhsu.vx\t\0" + /* 17851 */ "vwmulsu.vx\t\0" + /* 17863 */ "vmsgtu.vx\t\0" + /* 17874 */ "vmsltu.vx\t\0" + /* 17885 */ "vdivu.vx\t\0" + /* 17895 */ "vmaxu.vx\t\0" + /* 17905 */ "vdiv.vx\t\0" + /* 17914 */ "vmax.vx\t\0" + /* 17923 */ "vnsra.wx\t\0" + /* 17933 */ "vwsub.wx\t\0" + /* 17943 */ "vwadd.wx\t\0" + /* 17953 */ "vnsrl.wx\t\0" + /* 17963 */ "vnclip.wx\t\0" + /* 17974 */ "vwsubu.wx\t\0" + /* 17985 */ "vwaddu.wx\t\0" + /* 17996 */ "vnclipu.wx\t\0" + /* 18008 */ "th.tstnbz\t\0" + /* 18019 */ "cv.extbz\t\0" + /* 18029 */ "czero.nez\t\0" + /* 18040 */ "c.bnez\t\0" + /* 18048 */ "th.mvnez\t\0" + /* 18058 */ "cv.exthz\t\0" + /* 18068 */ "clz\t\0" + /* 18073 */ "czero.eqz\t\0" + /* 18084 */ "c.beqz\t\0" + /* 18092 */ "th.mveqz\t\0" + /* 18102 */ "ctz\t\0" + /* 18107 */ "cm.popretz\t\0" + /* 18119 */ ".insn r4 \0" + /* 18129 */ ".insn ca \0" + /* 18139 */ ".insn b \0" + /* 18148 */ ".insn cb \0" + /* 18158 */ ".insn i \0" + /* 18167 */ ".insn ci \0" + /* 18177 */ ".insn j \0" + /* 18186 */ ".insn cj \0" + /* 18196 */ ".insn cl \0" + /* 18206 */ ".insn r \0" + /* 18215 */ ".insn cr \0" + /* 18225 */ ".insn s \0" + /* 18234 */ ".insn cs \0" + /* 18244 */ ".insn css \0" + /* 18255 */ ".insn u \0" + /* 18264 */ ".insn ciw \0" + /* 18275 */ "# XRay Function Patchable RET.\0" + /* 18306 */ "# XRay Typed Event Log.\0" + /* 18330 */ "# XRay Custom Event Log.\0" + /* 18355 */ "# XRay Function Enter.\0" + /* 18378 */ "# XRay Tail Call Exit.\0" + /* 18401 */ "# XRay Function Exit.\0" + /* 18423 */ "cmop.1\0" + /* 18430 */ "cmop.11\0" + /* 18438 */ "cmop.3\0" + /* 18445 */ "cmop.13\0" + /* 18453 */ "cmop.5\0" + /* 18460 */ "cmop.15\0" + /* 18468 */ "cmop.7\0" + /* 18475 */ "cmop.9\0" + /* 18482 */ "LIFETIME_END\0" + /* 18495 */ "PSEUDO_PROBE\0" + /* 18508 */ "BUNDLE\0" + /* 18515 */ "DBG_VALUE\0" + /* 18525 */ "DBG_INSTR_REF\0" + /* 18539 */ "DBG_PHI\0" + /* 18547 */ "DBG_LABEL\0" + /* 18557 */ "LIFETIME_START\0" + /* 18572 */ "DBG_VALUE_LIST\0" + /* 18587 */ "th.sync\0" + /* 18595 */ "th.sync.i\0" + /* 18605 */ "fence.i\0" + /* 18613 */ "wfi\0" + /* 18617 */ "c.ebreak\0" + /* 18626 */ "sfence.w.inval\0" + /* 18641 */ "# FEntry call\0" + /* 18655 */ "th.l2cache.call\0" + /* 18671 */ "th.dcache.call\0" + /* 18686 */ "ecall\0" + /* 18692 */ "th.l2cache.iall\0" + /* 18708 */ "th.dcache.iall\0" + /* 18723 */ "th.icache.iall\0" + /* 18738 */ "th.l2cache.ciall\0" + /* 18755 */ "th.dcache.ciall\0" + /* 18771 */ "fence.tso\0" + /* 18781 */ "wrs.nto\0" + /* 18789 */ "wrs.sto\0" + /* 18797 */ "c.unimp\0" + /* 18805 */ "c.nop\0" + /* 18811 */ "sfence.inval.ir\0" + /* 18827 */ "th.sync.s\0" + /* 18837 */ "th.sync.is\0" + /* 18848 */ "th.icache.ialls\0" + /* 18864 */ "dret\0" + /* 18869 */ "mret\0" + /* 18874 */ "sret\0" +}; +#endif // CAPSTONE_DIET - static const uint16_t OpInfo0[] = { + static const uint32_t OpInfo0[] = { 0U, // PHI 0U, // INLINEASM 0U, // INLINEASM_BR @@ -294,28 +1681,40 @@ static void printInstruction(MCInst *MI, SStream *O, MCRegisterInfo *MRI) 0U, // IMPLICIT_DEF 0U, // SUBREG_TO_REG 0U, // COPY_TO_REGCLASS - 2457U, // DBG_VALUE - 2467U, // DBG_LABEL + 18516U, // DBG_VALUE + 18573U, // DBG_VALUE_LIST + 18526U, // DBG_INSTR_REF + 18540U, // DBG_PHI + 18548U, // DBG_LABEL 0U, // REG_SEQUENCE 0U, // COPY - 2450U, // BUNDLE - 2477U, // LIFETIME_START - 2437U, // LIFETIME_END + 18509U, // BUNDLE + 18558U, // LIFETIME_START + 18483U, // LIFETIME_END + 18496U, // PSEUDO_PROBE + 0U, // ARITH_FENCE 0U, // STACKMAP - 2492U, // FENTRY_CALL + 18642U, // FENTRY_CALL 0U, // PATCHPOINT 0U, // LOAD_STACK_GUARD + 0U, // PREALLOCATED_SETUP + 0U, // PREALLOCATED_ARG 0U, // STATEPOINT 0U, // LOCAL_ESCAPE 0U, // FAULTING_OP 0U, // PATCHABLE_OP - 2369U, // PATCHABLE_FUNCTION_ENTER - 2289U, // PATCHABLE_RET - 2415U, // PATCHABLE_FUNCTION_EXIT - 2392U, // PATCHABLE_TAIL_CALL - 2344U, // PATCHABLE_EVENT_CALL - 2320U, // PATCHABLE_TYPED_EVENT_CALL + 18356U, // PATCHABLE_FUNCTION_ENTER + 18276U, // PATCHABLE_RET + 18402U, // PATCHABLE_FUNCTION_EXIT + 18379U, // PATCHABLE_TAIL_CALL + 18331U, // PATCHABLE_EVENT_CALL + 18307U, // PATCHABLE_TYPED_EVENT_CALL 0U, // ICALL_BRANCH_FUNNEL + 0U, // MEMBARRIER + 0U, // JUMP_TABLE_DEBUG_INFO + 0U, // G_ASSERT_SEXT + 0U, // G_ASSERT_ZEXT + 0U, // G_ASSERT_ALIGN 0U, // G_ADD 0U, // G_SUB 0U, // G_MUL @@ -323,6 +1722,8 @@ static void printInstruction(MCInst *MI, SStream *O, MCRegisterInfo *MRI) 0U, // G_UDIV 0U, // G_SREM 0U, // G_UREM + 0U, // G_SDIVREM + 0U, // G_UDIVREM 0U, // G_AND 0U, // G_OR 0U, // G_XOR @@ -330,6 +1731,7 @@ static void printInstruction(MCInst *MI, SStream *O, MCRegisterInfo *MRI) 0U, // G_PHI 0U, // G_FRAME_INDEX 0U, // G_GLOBAL_VALUE + 0U, // G_CONSTANT_POOL 0U, // G_EXTRACT 0U, // G_UNMERGE_VALUES 0U, // G_INSERT @@ -340,12 +1742,22 @@ static void printInstruction(MCInst *MI, SStream *O, MCRegisterInfo *MRI) 0U, // G_PTRTOINT 0U, // G_INTTOPTR 0U, // G_BITCAST + 0U, // G_FREEZE + 0U, // G_CONSTANT_FOLD_BARRIER + 0U, // G_INTRINSIC_FPTRUNC_ROUND 0U, // G_INTRINSIC_TRUNC 0U, // G_INTRINSIC_ROUND + 0U, // G_INTRINSIC_LRINT + 0U, // G_INTRINSIC_ROUNDEVEN + 0U, // G_READCYCLECOUNTER 0U, // G_LOAD 0U, // G_SEXTLOAD 0U, // G_ZEXTLOAD + 0U, // G_INDEXED_LOAD + 0U, // G_INDEXED_SEXTLOAD + 0U, // G_INDEXED_ZEXTLOAD 0U, // G_STORE + 0U, // G_INDEXED_STORE 0U, // G_ATOMIC_CMPXCHG_WITH_SUCCESS 0U, // G_ATOMIC_CMPXCHG 0U, // G_ATOMICRMW_XCHG @@ -359,10 +1771,21 @@ static void printInstruction(MCInst *MI, SStream *O, MCRegisterInfo *MRI) 0U, // G_ATOMICRMW_MIN 0U, // G_ATOMICRMW_UMAX 0U, // G_ATOMICRMW_UMIN + 0U, // G_ATOMICRMW_FADD + 0U, // G_ATOMICRMW_FSUB + 0U, // G_ATOMICRMW_FMAX + 0U, // G_ATOMICRMW_FMIN + 0U, // G_ATOMICRMW_UINC_WRAP + 0U, // G_ATOMICRMW_UDEC_WRAP + 0U, // G_FENCE + 0U, // G_PREFETCH 0U, // G_BRCOND 0U, // G_BRINDIRECT + 0U, // G_INVOKE_REGION_START 0U, // G_INTRINSIC 0U, // G_INTRINSIC_W_SIDE_EFFECTS + 0U, // G_INTRINSIC_CONVERGENT + 0U, // G_INTRINSIC_CONVERGENT_W_SIDE_EFFECTS 0U, // G_ANYEXT 0U, // G_TRUNC 0U, // G_CONSTANT @@ -370,10 +1793,15 @@ static void printInstruction(MCInst *MI, SStream *O, MCRegisterInfo *MRI) 0U, // G_VASTART 0U, // G_VAARG 0U, // G_SEXT + 0U, // G_SEXT_INREG 0U, // G_ZEXT 0U, // G_SHL 0U, // G_LSHR 0U, // G_ASHR + 0U, // G_FSHL + 0U, // G_FSHR + 0U, // G_ROTR + 0U, // G_ROTL 0U, // G_ICMP 0U, // G_FCMP 0U, // G_SELECT @@ -389,18 +1817,37 @@ static void printInstruction(MCInst *MI, SStream *O, MCRegisterInfo *MRI) 0U, // G_SMULO 0U, // G_UMULH 0U, // G_SMULH + 0U, // G_UADDSAT + 0U, // G_SADDSAT + 0U, // G_USUBSAT + 0U, // G_SSUBSAT + 0U, // G_USHLSAT + 0U, // G_SSHLSAT + 0U, // G_SMULFIX + 0U, // G_UMULFIX + 0U, // G_SMULFIXSAT + 0U, // G_UMULFIXSAT + 0U, // G_SDIVFIX + 0U, // G_UDIVFIX + 0U, // G_SDIVFIXSAT + 0U, // G_UDIVFIXSAT 0U, // G_FADD 0U, // G_FSUB 0U, // G_FMUL 0U, // G_FMA + 0U, // G_FMAD 0U, // G_FDIV 0U, // G_FREM 0U, // G_FPOW + 0U, // G_FPOWI 0U, // G_FEXP 0U, // G_FEXP2 + 0U, // G_FEXP10 0U, // G_FLOG 0U, // G_FLOG2 0U, // G_FLOG10 + 0U, // G_FLDEXP + 0U, // G_FFREXP 0U, // G_FNEG 0U, // G_FPEXT 0U, // G_FPTRUNC @@ -409,10 +1856,32 @@ static void printInstruction(MCInst *MI, SStream *O, MCRegisterInfo *MRI) 0U, // G_SITOFP 0U, // G_UITOFP 0U, // G_FABS + 0U, // G_FCOPYSIGN + 0U, // G_IS_FPCLASS 0U, // G_FCANONICALIZE - 0U, // G_GEP - 0U, // G_PTR_MASK + 0U, // G_FMINNUM + 0U, // G_FMAXNUM + 0U, // G_FMINNUM_IEEE + 0U, // G_FMAXNUM_IEEE + 0U, // G_FMINIMUM + 0U, // G_FMAXIMUM + 0U, // G_GET_FPENV + 0U, // G_SET_FPENV + 0U, // G_RESET_FPENV + 0U, // G_GET_FPMODE + 0U, // G_SET_FPMODE + 0U, // G_RESET_FPMODE + 0U, // G_PTR_ADD + 0U, // G_PTRMASK + 0U, // G_SMIN + 0U, // G_SMAX + 0U, // G_UMIN + 0U, // G_UMAX + 0U, // G_ABS + 0U, // G_LROUND + 0U, // G_LLROUND 0U, // G_BR + 0U, // G_BRJT 0U, // G_INSERT_VECTOR_ELT 0U, // G_EXTRACT_VECTOR_ELT 0U, // G_SHUFFLE_VECTOR @@ -422,318 +1891,12876 @@ static void printInstruction(MCInst *MI, SStream *O, MCRegisterInfo *MRI) 0U, // G_CTLZ_ZERO_UNDEF 0U, // G_CTPOP 0U, // G_BSWAP + 0U, // G_BITREVERSE 0U, // G_FCEIL 0U, // G_FCOS 0U, // G_FSIN 0U, // G_FSQRT 0U, // G_FFLOOR + 0U, // G_FRINT + 0U, // G_FNEARBYINT 0U, // G_ADDRSPACE_CAST 0U, // G_BLOCK_ADDR - 4U, // ADJCALLSTACKDOWN - 4U, // ADJCALLSTACKUP - 4U, // BuildPairF64Pseudo - 4U, // PseudoAtomicLoadNand32 - 4U, // PseudoAtomicLoadNand64 - 4U, // PseudoBR - 4U, // PseudoBRIND - 4687U, // PseudoCALL - 4U, // PseudoCALLIndirect - 4U, // PseudoCmpXchg32 - 4U, // PseudoCmpXchg64 - 20482U, // PseudoLA - 20967U, // PseudoLI - 20481U, // PseudoLLA - 4U, // PseudoMaskedAtomicLoadAdd32 - 4U, // PseudoMaskedAtomicLoadMax32 - 4U, // PseudoMaskedAtomicLoadMin32 - 4U, // PseudoMaskedAtomicLoadNand32 - 4U, // PseudoMaskedAtomicLoadSub32 - 4U, // PseudoMaskedAtomicLoadUMax32 - 4U, // PseudoMaskedAtomicLoadUMin32 - 4U, // PseudoMaskedAtomicSwap32 - 4U, // PseudoMaskedCmpXchg32 - 4U, // PseudoRET - 4680U, // PseudoTAIL - 4U, // PseudoTAILIndirect - 4U, // Select_FPR32_Using_CC_GPR - 4U, // Select_FPR64_Using_CC_GPR - 4U, // Select_GPR_Using_CC_GPR - 4U, // SplitF64Pseudo - 20854U, // ADD - 20946U, // ADDI - 22637U, // ADDIW - 22622U, // ADDW - 20592U, // AMOADD_D - 21817U, // AMOADD_D_AQ - 21367U, // AMOADD_D_AQ_RL - 21091U, // AMOADD_D_RL - 22489U, // AMOADD_W - 21954U, // AMOADD_W_AQ - 21526U, // AMOADD_W_AQ_RL - 21228U, // AMOADD_W_RL - 20602U, // AMOAND_D - 21830U, // AMOAND_D_AQ - 21382U, // AMOAND_D_AQ_RL - 21104U, // AMOAND_D_RL - 22499U, // AMOAND_W - 21967U, // AMOAND_W_AQ - 21541U, // AMOAND_W_AQ_RL - 21241U, // AMOAND_W_RL - 20786U, // AMOMAXU_D - 21918U, // AMOMAXU_D_AQ - 21484U, // AMOMAXU_D_AQ_RL - 21192U, // AMOMAXU_D_RL - 22576U, // AMOMAXU_W - 22055U, // AMOMAXU_W_AQ - 21643U, // AMOMAXU_W_AQ_RL - 21329U, // AMOMAXU_W_RL - 20832U, // AMOMAX_D - 21932U, // AMOMAX_D_AQ - 21500U, // AMOMAX_D_AQ_RL - 21206U, // AMOMAX_D_RL - 22596U, // AMOMAX_W - 22069U, // AMOMAX_W_AQ - 21659U, // AMOMAX_W_AQ_RL - 21343U, // AMOMAX_W_RL - 20764U, // AMOMINU_D - 21904U, // AMOMINU_D_AQ - 21468U, // AMOMINU_D_AQ_RL - 21178U, // AMOMINU_D_RL - 22565U, // AMOMINU_W - 22041U, // AMOMINU_W_AQ - 21627U, // AMOMINU_W_AQ_RL - 21315U, // AMOMINU_W_RL - 20654U, // AMOMIN_D - 21843U, // AMOMIN_D_AQ - 21397U, // AMOMIN_D_AQ_RL - 21117U, // AMOMIN_D_RL - 22509U, // AMOMIN_W - 21980U, // AMOMIN_W_AQ - 21556U, // AMOMIN_W_AQ_RL - 21254U, // AMOMIN_W_RL - 20698U, // AMOOR_D - 21879U, // AMOOR_D_AQ - 21439U, // AMOOR_D_AQ_RL - 21153U, // AMOOR_D_RL - 22536U, // AMOOR_W - 22016U, // AMOOR_W_AQ - 21598U, // AMOOR_W_AQ_RL - 21290U, // AMOOR_W_RL - 20674U, // AMOSWAP_D - 21856U, // AMOSWAP_D_AQ - 21412U, // AMOSWAP_D_AQ_RL - 21130U, // AMOSWAP_D_RL - 22519U, // AMOSWAP_W - 21993U, // AMOSWAP_W_AQ - 21571U, // AMOSWAP_W_AQ_RL - 21267U, // AMOSWAP_W_RL - 20707U, // AMOXOR_D - 21891U, // AMOXOR_D_AQ - 21453U, // AMOXOR_D_AQ_RL - 21165U, // AMOXOR_D_RL - 22545U, // AMOXOR_W - 22028U, // AMOXOR_W_AQ - 21612U, // AMOXOR_W_AQ_RL - 21302U, // AMOXOR_W_RL - 20874U, // AND - 20954U, // ANDI - 20518U, // AUIPC - 22082U, // BEQ - 20899U, // BGE - 22361U, // BGEU - 22346U, // BLT - 22417U, // BLTU - 20904U, // BNE - 20525U, // CSRRC - 20936U, // CSRRCI - 22321U, // CSRRS - 20993U, // CSRRSI - 22695U, // CSRRW - 21014U, // CSRRWI - 8564U, // C_ADD - 8656U, // C_ADDI - 9440U, // C_ADDI16SP - 21689U, // C_ADDI4SPN - 10347U, // C_ADDIW - 10332U, // C_ADDW - 8584U, // C_AND - 8664U, // C_ANDI - 22761U, // C_BEQZ - 22753U, // C_BNEZ - 547U, // C_EBREAK - 20865U, // C_FLD - 21748U, // C_FLDSP - 22664U, // C_FLW - 21782U, // C_FLWSP - 20885U, // C_FSD - 21765U, // C_FSDSP - 22708U, // C_FSW - 21799U, // C_FSWSP - 4638U, // C_J - 4673U, // C_JAL - 5709U, // C_JALR - 5703U, // C_JR - 20859U, // C_LD - 21740U, // C_LDSP - 20965U, // C_LI - 21007U, // C_LUI - 22658U, // C_LW - 21774U, // C_LWSP - 22467U, // C_MV - 1241U, // C_NOP - 9813U, // C_OR - 20879U, // C_SD - 21757U, // C_SDSP - 8683U, // C_SLLI - 8640U, // C_SRAI - 8691U, // C_SRLI - 8223U, // C_SUB - 10324U, // C_SUBW - 22702U, // C_SW - 21791U, // C_SWSP - 1232U, // C_UNIMP - 9819U, // C_XOR - 22462U, // DIV - 22429U, // DIVU - 22722U, // DIVUW - 22729U, // DIVW - 549U, // EBREAK - 590U, // ECALL - 20565U, // FADD_D - 22151U, // FADD_S - 20727U, // FCLASS_D - 22237U, // FCLASS_S - 21037U, // FCVT_D_L - 22381U, // FCVT_D_LU - 22141U, // FCVT_D_S - 22479U, // FCVT_D_W - 22435U, // FCVT_D_WU - 20753U, // FCVT_LU_D - 22263U, // FCVT_LU_S - 20628U, // FCVT_L_D - 22194U, // FCVT_L_S - 20717U, // FCVT_S_D - 21047U, // FCVT_S_L - 22392U, // FCVT_S_LU - 22555U, // FCVT_S_W - 22446U, // FCVT_S_WU - 20775U, // FCVT_WU_D - 22274U, // FCVT_WU_S - 20805U, // FCVT_W_D - 22293U, // FCVT_W_S - 20797U, // FDIV_D - 22285U, // FDIV_S - 12700U, // FENCE - 439U, // FENCE_I - 1221U, // FENCE_TSO - 20685U, // FEQ_D - 22230U, // FEQ_S - 20867U, // FLD - 20612U, // FLE_D - 22178U, // FLE_S - 20737U, // FLT_D - 22247U, // FLT_S - 22666U, // FLW - 20573U, // FMADD_D - 22159U, // FMADD_S - 20824U, // FMAX_D - 22303U, // FMAX_S - 20646U, // FMIN_D - 22212U, // FMIN_S - 20540U, // FMSUB_D - 22122U, // FMSUB_S - 20638U, // FMUL_D - 22204U, // FMUL_S - 22735U, // FMV_D_X - 22744U, // FMV_W_X - 20815U, // FMV_X_D - 22587U, // FMV_X_W - 20582U, // FNMADD_D - 22168U, // FNMADD_S - 20549U, // FNMSUB_D - 22131U, // FNMSUB_S - 20887U, // FSD - 20664U, // FSGNJN_D - 22220U, // FSGNJN_S - 20842U, // FSGNJX_D - 22311U, // FSGNJX_S - 20619U, // FSGNJ_D - 22185U, // FSGNJ_S - 20744U, // FSQRT_D - 22254U, // FSQRT_S - 20532U, // FSUB_D - 22114U, // FSUB_S - 22710U, // FSW - 21059U, // JAL - 22095U, // JALR - 20503U, // LB - 22356U, // LBU - 20861U, // LD - 20911U, // LH - 22369U, // LHU - 37076U, // LR_D - 38254U, // LR_D_AQ - 37812U, // LR_D_AQ_RL - 37528U, // LR_D_RL - 38914U, // LR_W - 38391U, // LR_W_AQ - 37971U, // LR_W_AQ_RL - 37665U, // LR_W_RL - 21009U, // LUI - 22660U, // LW - 22457U, // LWU - 1848U, // MRET - 21679U, // MUL - 20909U, // MULH - 22409U, // MULHSU - 22367U, // MULHU - 22683U, // MULW - 22103U, // OR - 20988U, // ORI - 21684U, // REM - 22403U, // REMU - 22715U, // REMUW - 22689U, // REMW - 20507U, // SB - 20559U, // SC_D - 21808U, // SC_D_AQ - 21356U, // SC_D_AQ_RL - 21082U, // SC_D_RL - 22473U, // SC_W - 21945U, // SC_W_AQ - 21515U, // SC_W_AQ_RL - 21219U, // SC_W_RL - 20881U, // SD - 20486U, // SFENCE_VMA - 20915U, // SH - 21077U, // SLL - 20973U, // SLLI - 22644U, // SLLIW - 22671U, // SLLW - 22351U, // SLT - 21001U, // SLTI - 22374U, // SLTIU - 22423U, // SLTU - 20498U, // SRA - 20930U, // SRAI - 22628U, // SRAIW - 22606U, // SRAW - 1854U, // SRET - 21674U, // SRL - 20981U, // SRLI - 22651U, // SRLIW - 22677U, // SRLW - 20513U, // SUB - 22614U, // SUBW - 22704U, // SW - 1234U, // UNIMP - 1860U, // URET - 480U, // WFI - 22109U, // XOR - 20987U, // XORI + 0U, // G_JUMP_TABLE + 0U, // G_DYN_STACKALLOC + 0U, // G_STACKSAVE + 0U, // G_STACKRESTORE + 0U, // G_STRICT_FADD + 0U, // G_STRICT_FSUB + 0U, // G_STRICT_FMUL + 0U, // G_STRICT_FDIV + 0U, // G_STRICT_FREM + 0U, // G_STRICT_FMA + 0U, // G_STRICT_FSQRT + 0U, // G_STRICT_FLDEXP + 0U, // G_READ_REGISTER + 0U, // G_WRITE_REGISTER + 0U, // G_MEMCPY + 0U, // G_MEMCPY_INLINE + 0U, // G_MEMMOVE + 0U, // G_MEMSET + 0U, // G_BZERO + 0U, // G_VECREDUCE_SEQ_FADD + 0U, // G_VECREDUCE_SEQ_FMUL + 0U, // G_VECREDUCE_FADD + 0U, // G_VECREDUCE_FMUL + 0U, // G_VECREDUCE_FMAX + 0U, // G_VECREDUCE_FMIN + 0U, // G_VECREDUCE_FMAXIMUM + 0U, // G_VECREDUCE_FMINIMUM + 0U, // G_VECREDUCE_ADD + 0U, // G_VECREDUCE_MUL + 0U, // G_VECREDUCE_AND + 0U, // G_VECREDUCE_OR + 0U, // G_VECREDUCE_XOR + 0U, // G_VECREDUCE_SMAX + 0U, // G_VECREDUCE_SMIN + 0U, // G_VECREDUCE_UMAX + 0U, // G_VECREDUCE_UMIN + 0U, // G_SBFX + 0U, // G_UBFX + 0U, // ADJCALLSTACKDOWN + 0U, // ADJCALLSTACKUP + 0U, // BuildPairF64Pseudo + 0U, // BuildPairF64Pseudo_INX + 0U, // G_FCLASS + 0U, // HWASAN_CHECK_MEMACCESS_SHORTGRANULES + 0U, // KCFI_CHECK + 36348U, // PseudoAddTPRel + 0U, // PseudoAtomicLoadNand32 + 0U, // PseudoAtomicLoadNand64 + 0U, // PseudoBR + 0U, // PseudoBRIND + 301787U, // PseudoCALL + 0U, // PseudoCALLIndirect + 33594075U, // PseudoCALLReg + 0U, // PseudoCCADD + 0U, // PseudoCCADDI + 0U, // PseudoCCADDIW + 0U, // PseudoCCADDW + 0U, // PseudoCCAND + 0U, // PseudoCCANDI + 0U, // PseudoCCANDN + 0U, // PseudoCCMOVGPR + 0U, // PseudoCCMOVGPRNoX0 + 0U, // PseudoCCOR + 0U, // PseudoCCORI + 0U, // PseudoCCORN + 0U, // PseudoCCSLL + 0U, // PseudoCCSLLI + 0U, // PseudoCCSLLIW + 0U, // PseudoCCSLLW + 0U, // PseudoCCSRA + 0U, // PseudoCCSRAI + 0U, // PseudoCCSRAIW + 0U, // PseudoCCSRAW + 0U, // PseudoCCSRL + 0U, // PseudoCCSRLI + 0U, // PseudoCCSRLIW + 0U, // PseudoCCSRLW + 0U, // PseudoCCSUB + 0U, // PseudoCCSUBW + 0U, // PseudoCCXNOR + 0U, // PseudoCCXOR + 0U, // PseudoCCXORI + 0U, // PseudoCmpXchg32 + 0U, // PseudoCmpXchg64 + 2418085443U, // PseudoFLD + 2418087797U, // PseudoFLH + 2418098459U, // PseudoFLW + 0U, // PseudoFROUND_D + 0U, // PseudoFROUND_D_IN32X + 0U, // PseudoFROUND_D_INX + 0U, // PseudoFROUND_H + 0U, // PseudoFROUND_H_INX + 0U, // PseudoFROUND_S + 0U, // PseudoFROUND_S_INX + 2418085535U, // PseudoFSD + 2418087857U, // PseudoFSH + 2418098616U, // PseudoFSW + 37822595U, // PseudoJump + 33588438U, // PseudoLA + 33588438U, // PseudoLAImm + 33590324U, // PseudoLA_TLSDESC + 33590832U, // PseudoLA_TLS_GD + 33590985U, // PseudoLA_TLS_IE + 33590226U, // PseudoLB + 33597045U, // PseudoLBU + 33590845U, // PseudoLD + 33588330U, // PseudoLGA + 33593194U, // PseudoLH + 33597102U, // PseudoLHU + 33593410U, // PseudoLI + 33588437U, // PseudoLLA + 33588437U, // PseudoLLAImm + 33603846U, // PseudoLW + 33597322U, // PseudoLWU + 0U, // PseudoLongBEQ + 0U, // PseudoLongBGE + 0U, // PseudoLongBGEU + 0U, // PseudoLongBLT + 0U, // PseudoLongBLTU + 0U, // PseudoLongBNE + 0U, // PseudoMaskedAtomicLoadAdd32 + 0U, // PseudoMaskedAtomicLoadMax32 + 0U, // PseudoMaskedAtomicLoadMin32 + 0U, // PseudoMaskedAtomicLoadNand32 + 0U, // PseudoMaskedAtomicLoadSub32 + 0U, // PseudoMaskedAtomicLoadUMax32 + 0U, // PseudoMaskedAtomicLoadUMin32 + 0U, // PseudoMaskedAtomicSwap32 + 0U, // PseudoMaskedCmpXchg32 + 0U, // PseudoMovImm + 0U, // PseudoQuietFLE_D + 0U, // PseudoQuietFLE_D_IN32X + 0U, // PseudoQuietFLE_D_INX + 0U, // PseudoQuietFLE_H + 0U, // PseudoQuietFLE_H_INX + 0U, // PseudoQuietFLE_S + 0U, // PseudoQuietFLE_S_INX + 0U, // PseudoQuietFLT_D + 0U, // PseudoQuietFLT_D_IN32X + 0U, // PseudoQuietFLT_D_INX + 0U, // PseudoQuietFLT_H + 0U, // PseudoQuietFLT_H_INX + 0U, // PseudoQuietFLT_S + 0U, // PseudoQuietFLT_S_INX + 0U, // PseudoRET + 0U, // PseudoRV32ZdinxLD + 0U, // PseudoRV32ZdinxSD + 0U, // PseudoRVVInitUndefM1 + 0U, // PseudoRVVInitUndefM2 + 0U, // PseudoRVVInitUndefM4 + 0U, // PseudoRVVInitUndefM8 + 0U, // PseudoReadVL + 0U, // PseudoReadVLENB + 2418084866U, // PseudoSB + 2418085529U, // PseudoSD + 33589979U, // PseudoSEXT_B + 33592928U, // PseudoSEXT_H + 2418087846U, // PseudoSH + 2418098588U, // PseudoSW + 301781U, // PseudoTAIL + 0U, // PseudoTAILIndirect + 0U, // PseudoTHVdotVMAQASU_VV_M1 + 0U, // PseudoTHVdotVMAQASU_VV_M1_MASK + 0U, // PseudoTHVdotVMAQASU_VV_M2 + 0U, // PseudoTHVdotVMAQASU_VV_M2_MASK + 0U, // PseudoTHVdotVMAQASU_VV_M4 + 0U, // PseudoTHVdotVMAQASU_VV_M4_MASK + 0U, // PseudoTHVdotVMAQASU_VV_M8 + 0U, // PseudoTHVdotVMAQASU_VV_M8_MASK + 0U, // PseudoTHVdotVMAQASU_VV_MF2 + 0U, // PseudoTHVdotVMAQASU_VV_MF2_MASK + 0U, // PseudoTHVdotVMAQASU_VX_M1 + 0U, // PseudoTHVdotVMAQASU_VX_M1_MASK + 0U, // PseudoTHVdotVMAQASU_VX_M2 + 0U, // PseudoTHVdotVMAQASU_VX_M2_MASK + 0U, // PseudoTHVdotVMAQASU_VX_M4 + 0U, // PseudoTHVdotVMAQASU_VX_M4_MASK + 0U, // PseudoTHVdotVMAQASU_VX_M8 + 0U, // PseudoTHVdotVMAQASU_VX_M8_MASK + 0U, // PseudoTHVdotVMAQASU_VX_MF2 + 0U, // PseudoTHVdotVMAQASU_VX_MF2_MASK + 0U, // PseudoTHVdotVMAQAUS_VX_M1 + 0U, // PseudoTHVdotVMAQAUS_VX_M1_MASK + 0U, // PseudoTHVdotVMAQAUS_VX_M2 + 0U, // PseudoTHVdotVMAQAUS_VX_M2_MASK + 0U, // PseudoTHVdotVMAQAUS_VX_M4 + 0U, // PseudoTHVdotVMAQAUS_VX_M4_MASK + 0U, // PseudoTHVdotVMAQAUS_VX_M8 + 0U, // PseudoTHVdotVMAQAUS_VX_M8_MASK + 0U, // PseudoTHVdotVMAQAUS_VX_MF2 + 0U, // PseudoTHVdotVMAQAUS_VX_MF2_MASK + 0U, // PseudoTHVdotVMAQAU_VV_M1 + 0U, // PseudoTHVdotVMAQAU_VV_M1_MASK + 0U, // PseudoTHVdotVMAQAU_VV_M2 + 0U, // PseudoTHVdotVMAQAU_VV_M2_MASK + 0U, // PseudoTHVdotVMAQAU_VV_M4 + 0U, // PseudoTHVdotVMAQAU_VV_M4_MASK + 0U, // PseudoTHVdotVMAQAU_VV_M8 + 0U, // PseudoTHVdotVMAQAU_VV_M8_MASK + 0U, // PseudoTHVdotVMAQAU_VV_MF2 + 0U, // PseudoTHVdotVMAQAU_VV_MF2_MASK + 0U, // PseudoTHVdotVMAQAU_VX_M1 + 0U, // PseudoTHVdotVMAQAU_VX_M1_MASK + 0U, // PseudoTHVdotVMAQAU_VX_M2 + 0U, // PseudoTHVdotVMAQAU_VX_M2_MASK + 0U, // PseudoTHVdotVMAQAU_VX_M4 + 0U, // PseudoTHVdotVMAQAU_VX_M4_MASK + 0U, // PseudoTHVdotVMAQAU_VX_M8 + 0U, // PseudoTHVdotVMAQAU_VX_M8_MASK + 0U, // PseudoTHVdotVMAQAU_VX_MF2 + 0U, // PseudoTHVdotVMAQAU_VX_MF2_MASK + 0U, // PseudoTHVdotVMAQA_VV_M1 + 0U, // PseudoTHVdotVMAQA_VV_M1_MASK + 0U, // PseudoTHVdotVMAQA_VV_M2 + 0U, // PseudoTHVdotVMAQA_VV_M2_MASK + 0U, // PseudoTHVdotVMAQA_VV_M4 + 0U, // PseudoTHVdotVMAQA_VV_M4_MASK + 0U, // PseudoTHVdotVMAQA_VV_M8 + 0U, // PseudoTHVdotVMAQA_VV_M8_MASK + 0U, // PseudoTHVdotVMAQA_VV_MF2 + 0U, // PseudoTHVdotVMAQA_VV_MF2_MASK + 0U, // PseudoTHVdotVMAQA_VX_M1 + 0U, // PseudoTHVdotVMAQA_VX_M1_MASK + 0U, // PseudoTHVdotVMAQA_VX_M2 + 0U, // PseudoTHVdotVMAQA_VX_M2_MASK + 0U, // PseudoTHVdotVMAQA_VX_M4 + 0U, // PseudoTHVdotVMAQA_VX_M4_MASK + 0U, // PseudoTHVdotVMAQA_VX_M8 + 0U, // PseudoTHVdotVMAQA_VX_M8_MASK + 0U, // PseudoTHVdotVMAQA_VX_MF2 + 0U, // PseudoTHVdotVMAQA_VX_MF2_MASK + 606118518U, // PseudoTLSDESCCall + 0U, // PseudoVAADDU_VV_M1 + 0U, // PseudoVAADDU_VV_M1_MASK + 0U, // PseudoVAADDU_VV_M2 + 0U, // PseudoVAADDU_VV_M2_MASK + 0U, // PseudoVAADDU_VV_M4 + 0U, // PseudoVAADDU_VV_M4_MASK + 0U, // PseudoVAADDU_VV_M8 + 0U, // PseudoVAADDU_VV_M8_MASK + 0U, // PseudoVAADDU_VV_MF2 + 0U, // PseudoVAADDU_VV_MF2_MASK + 0U, // PseudoVAADDU_VV_MF4 + 0U, // PseudoVAADDU_VV_MF4_MASK + 0U, // PseudoVAADDU_VV_MF8 + 0U, // PseudoVAADDU_VV_MF8_MASK + 0U, // PseudoVAADDU_VX_M1 + 0U, // PseudoVAADDU_VX_M1_MASK + 0U, // PseudoVAADDU_VX_M2 + 0U, // PseudoVAADDU_VX_M2_MASK + 0U, // PseudoVAADDU_VX_M4 + 0U, // PseudoVAADDU_VX_M4_MASK + 0U, // PseudoVAADDU_VX_M8 + 0U, // PseudoVAADDU_VX_M8_MASK + 0U, // PseudoVAADDU_VX_MF2 + 0U, // PseudoVAADDU_VX_MF2_MASK + 0U, // PseudoVAADDU_VX_MF4 + 0U, // PseudoVAADDU_VX_MF4_MASK + 0U, // PseudoVAADDU_VX_MF8 + 0U, // PseudoVAADDU_VX_MF8_MASK + 0U, // PseudoVAADD_VV_M1 + 0U, // PseudoVAADD_VV_M1_MASK + 0U, // PseudoVAADD_VV_M2 + 0U, // PseudoVAADD_VV_M2_MASK + 0U, // PseudoVAADD_VV_M4 + 0U, // PseudoVAADD_VV_M4_MASK + 0U, // PseudoVAADD_VV_M8 + 0U, // PseudoVAADD_VV_M8_MASK + 0U, // PseudoVAADD_VV_MF2 + 0U, // PseudoVAADD_VV_MF2_MASK + 0U, // PseudoVAADD_VV_MF4 + 0U, // PseudoVAADD_VV_MF4_MASK + 0U, // PseudoVAADD_VV_MF8 + 0U, // PseudoVAADD_VV_MF8_MASK + 0U, // PseudoVAADD_VX_M1 + 0U, // PseudoVAADD_VX_M1_MASK + 0U, // PseudoVAADD_VX_M2 + 0U, // PseudoVAADD_VX_M2_MASK + 0U, // PseudoVAADD_VX_M4 + 0U, // PseudoVAADD_VX_M4_MASK + 0U, // PseudoVAADD_VX_M8 + 0U, // PseudoVAADD_VX_M8_MASK + 0U, // PseudoVAADD_VX_MF2 + 0U, // PseudoVAADD_VX_MF2_MASK + 0U, // PseudoVAADD_VX_MF4 + 0U, // PseudoVAADD_VX_MF4_MASK + 0U, // PseudoVAADD_VX_MF8 + 0U, // PseudoVAADD_VX_MF8_MASK + 0U, // PseudoVADC_VIM_M1 + 0U, // PseudoVADC_VIM_M2 + 0U, // PseudoVADC_VIM_M4 + 0U, // PseudoVADC_VIM_M8 + 0U, // PseudoVADC_VIM_MF2 + 0U, // PseudoVADC_VIM_MF4 + 0U, // PseudoVADC_VIM_MF8 + 0U, // PseudoVADC_VVM_M1 + 0U, // PseudoVADC_VVM_M2 + 0U, // PseudoVADC_VVM_M4 + 0U, // PseudoVADC_VVM_M8 + 0U, // PseudoVADC_VVM_MF2 + 0U, // PseudoVADC_VVM_MF4 + 0U, // PseudoVADC_VVM_MF8 + 0U, // PseudoVADC_VXM_M1 + 0U, // PseudoVADC_VXM_M2 + 0U, // PseudoVADC_VXM_M4 + 0U, // PseudoVADC_VXM_M8 + 0U, // PseudoVADC_VXM_MF2 + 0U, // PseudoVADC_VXM_MF4 + 0U, // PseudoVADC_VXM_MF8 + 0U, // PseudoVADD_VI_M1 + 0U, // PseudoVADD_VI_M1_MASK + 0U, // PseudoVADD_VI_M2 + 0U, // PseudoVADD_VI_M2_MASK + 0U, // PseudoVADD_VI_M4 + 0U, // PseudoVADD_VI_M4_MASK + 0U, // PseudoVADD_VI_M8 + 0U, // PseudoVADD_VI_M8_MASK + 0U, // PseudoVADD_VI_MF2 + 0U, // PseudoVADD_VI_MF2_MASK + 0U, // PseudoVADD_VI_MF4 + 0U, // PseudoVADD_VI_MF4_MASK + 0U, // PseudoVADD_VI_MF8 + 0U, // PseudoVADD_VI_MF8_MASK + 0U, // PseudoVADD_VV_M1 + 0U, // PseudoVADD_VV_M1_MASK + 0U, // PseudoVADD_VV_M2 + 0U, // PseudoVADD_VV_M2_MASK + 0U, // PseudoVADD_VV_M4 + 0U, // PseudoVADD_VV_M4_MASK + 0U, // PseudoVADD_VV_M8 + 0U, // PseudoVADD_VV_M8_MASK + 0U, // PseudoVADD_VV_MF2 + 0U, // PseudoVADD_VV_MF2_MASK + 0U, // PseudoVADD_VV_MF4 + 0U, // PseudoVADD_VV_MF4_MASK + 0U, // PseudoVADD_VV_MF8 + 0U, // PseudoVADD_VV_MF8_MASK + 0U, // PseudoVADD_VX_M1 + 0U, // PseudoVADD_VX_M1_MASK + 0U, // PseudoVADD_VX_M2 + 0U, // PseudoVADD_VX_M2_MASK + 0U, // PseudoVADD_VX_M4 + 0U, // PseudoVADD_VX_M4_MASK + 0U, // PseudoVADD_VX_M8 + 0U, // PseudoVADD_VX_M8_MASK + 0U, // PseudoVADD_VX_MF2 + 0U, // PseudoVADD_VX_MF2_MASK + 0U, // PseudoVADD_VX_MF4 + 0U, // PseudoVADD_VX_MF4_MASK + 0U, // PseudoVADD_VX_MF8 + 0U, // PseudoVADD_VX_MF8_MASK + 0U, // PseudoVAESDF_VS_M1_M1 + 0U, // PseudoVAESDF_VS_M1_MF2 + 0U, // PseudoVAESDF_VS_M1_MF4 + 0U, // PseudoVAESDF_VS_M1_MF8 + 0U, // PseudoVAESDF_VS_M2_M1 + 0U, // PseudoVAESDF_VS_M2_M2 + 0U, // PseudoVAESDF_VS_M2_MF2 + 0U, // PseudoVAESDF_VS_M2_MF4 + 0U, // PseudoVAESDF_VS_M2_MF8 + 0U, // PseudoVAESDF_VS_M4_M1 + 0U, // PseudoVAESDF_VS_M4_M2 + 0U, // PseudoVAESDF_VS_M4_M4 + 0U, // PseudoVAESDF_VS_M4_MF2 + 0U, // PseudoVAESDF_VS_M4_MF4 + 0U, // PseudoVAESDF_VS_M4_MF8 + 0U, // PseudoVAESDF_VS_M8_M1 + 0U, // PseudoVAESDF_VS_M8_M2 + 0U, // PseudoVAESDF_VS_M8_M4 + 0U, // PseudoVAESDF_VS_M8_MF2 + 0U, // PseudoVAESDF_VS_M8_MF4 + 0U, // PseudoVAESDF_VS_M8_MF8 + 0U, // PseudoVAESDF_VS_MF2_MF2 + 0U, // PseudoVAESDF_VS_MF2_MF4 + 0U, // PseudoVAESDF_VS_MF2_MF8 + 0U, // PseudoVAESDF_VV_M1 + 0U, // PseudoVAESDF_VV_M2 + 0U, // PseudoVAESDF_VV_M4 + 0U, // PseudoVAESDF_VV_M8 + 0U, // PseudoVAESDF_VV_MF2 + 0U, // PseudoVAESDM_VS_M1_M1 + 0U, // PseudoVAESDM_VS_M1_MF2 + 0U, // PseudoVAESDM_VS_M1_MF4 + 0U, // PseudoVAESDM_VS_M1_MF8 + 0U, // PseudoVAESDM_VS_M2_M1 + 0U, // PseudoVAESDM_VS_M2_M2 + 0U, // PseudoVAESDM_VS_M2_MF2 + 0U, // PseudoVAESDM_VS_M2_MF4 + 0U, // PseudoVAESDM_VS_M2_MF8 + 0U, // PseudoVAESDM_VS_M4_M1 + 0U, // PseudoVAESDM_VS_M4_M2 + 0U, // PseudoVAESDM_VS_M4_M4 + 0U, // PseudoVAESDM_VS_M4_MF2 + 0U, // PseudoVAESDM_VS_M4_MF4 + 0U, // PseudoVAESDM_VS_M4_MF8 + 0U, // PseudoVAESDM_VS_M8_M1 + 0U, // PseudoVAESDM_VS_M8_M2 + 0U, // PseudoVAESDM_VS_M8_M4 + 0U, // PseudoVAESDM_VS_M8_MF2 + 0U, // PseudoVAESDM_VS_M8_MF4 + 0U, // PseudoVAESDM_VS_M8_MF8 + 0U, // PseudoVAESDM_VS_MF2_MF2 + 0U, // PseudoVAESDM_VS_MF2_MF4 + 0U, // PseudoVAESDM_VS_MF2_MF8 + 0U, // PseudoVAESDM_VV_M1 + 0U, // PseudoVAESDM_VV_M2 + 0U, // PseudoVAESDM_VV_M4 + 0U, // PseudoVAESDM_VV_M8 + 0U, // PseudoVAESDM_VV_MF2 + 0U, // PseudoVAESEF_VS_M1_M1 + 0U, // PseudoVAESEF_VS_M1_MF2 + 0U, // PseudoVAESEF_VS_M1_MF4 + 0U, // PseudoVAESEF_VS_M1_MF8 + 0U, // PseudoVAESEF_VS_M2_M1 + 0U, // PseudoVAESEF_VS_M2_M2 + 0U, // PseudoVAESEF_VS_M2_MF2 + 0U, // PseudoVAESEF_VS_M2_MF4 + 0U, // PseudoVAESEF_VS_M2_MF8 + 0U, // PseudoVAESEF_VS_M4_M1 + 0U, // PseudoVAESEF_VS_M4_M2 + 0U, // PseudoVAESEF_VS_M4_M4 + 0U, // PseudoVAESEF_VS_M4_MF2 + 0U, // PseudoVAESEF_VS_M4_MF4 + 0U, // PseudoVAESEF_VS_M4_MF8 + 0U, // PseudoVAESEF_VS_M8_M1 + 0U, // PseudoVAESEF_VS_M8_M2 + 0U, // PseudoVAESEF_VS_M8_M4 + 0U, // PseudoVAESEF_VS_M8_MF2 + 0U, // PseudoVAESEF_VS_M8_MF4 + 0U, // PseudoVAESEF_VS_M8_MF8 + 0U, // PseudoVAESEF_VS_MF2_MF2 + 0U, // PseudoVAESEF_VS_MF2_MF4 + 0U, // PseudoVAESEF_VS_MF2_MF8 + 0U, // PseudoVAESEF_VV_M1 + 0U, // PseudoVAESEF_VV_M2 + 0U, // PseudoVAESEF_VV_M4 + 0U, // PseudoVAESEF_VV_M8 + 0U, // PseudoVAESEF_VV_MF2 + 0U, // PseudoVAESEM_VS_M1_M1 + 0U, // PseudoVAESEM_VS_M1_MF2 + 0U, // PseudoVAESEM_VS_M1_MF4 + 0U, // PseudoVAESEM_VS_M1_MF8 + 0U, // PseudoVAESEM_VS_M2_M1 + 0U, // PseudoVAESEM_VS_M2_M2 + 0U, // PseudoVAESEM_VS_M2_MF2 + 0U, // PseudoVAESEM_VS_M2_MF4 + 0U, // PseudoVAESEM_VS_M2_MF8 + 0U, // PseudoVAESEM_VS_M4_M1 + 0U, // PseudoVAESEM_VS_M4_M2 + 0U, // PseudoVAESEM_VS_M4_M4 + 0U, // PseudoVAESEM_VS_M4_MF2 + 0U, // PseudoVAESEM_VS_M4_MF4 + 0U, // PseudoVAESEM_VS_M4_MF8 + 0U, // PseudoVAESEM_VS_M8_M1 + 0U, // PseudoVAESEM_VS_M8_M2 + 0U, // PseudoVAESEM_VS_M8_M4 + 0U, // PseudoVAESEM_VS_M8_MF2 + 0U, // PseudoVAESEM_VS_M8_MF4 + 0U, // PseudoVAESEM_VS_M8_MF8 + 0U, // PseudoVAESEM_VS_MF2_MF2 + 0U, // PseudoVAESEM_VS_MF2_MF4 + 0U, // PseudoVAESEM_VS_MF2_MF8 + 0U, // PseudoVAESEM_VV_M1 + 0U, // PseudoVAESEM_VV_M2 + 0U, // PseudoVAESEM_VV_M4 + 0U, // PseudoVAESEM_VV_M8 + 0U, // PseudoVAESEM_VV_MF2 + 0U, // PseudoVAESKF1_VI_M1 + 0U, // PseudoVAESKF1_VI_M2 + 0U, // PseudoVAESKF1_VI_M4 + 0U, // PseudoVAESKF1_VI_M8 + 0U, // PseudoVAESKF1_VI_MF2 + 0U, // PseudoVAESKF2_VI_M1 + 0U, // PseudoVAESKF2_VI_M2 + 0U, // PseudoVAESKF2_VI_M4 + 0U, // PseudoVAESKF2_VI_M8 + 0U, // PseudoVAESKF2_VI_MF2 + 0U, // PseudoVAESZ_VS_M1_M1 + 0U, // PseudoVAESZ_VS_M1_MF2 + 0U, // PseudoVAESZ_VS_M1_MF4 + 0U, // PseudoVAESZ_VS_M1_MF8 + 0U, // PseudoVAESZ_VS_M2_M1 + 0U, // PseudoVAESZ_VS_M2_M2 + 0U, // PseudoVAESZ_VS_M2_MF2 + 0U, // PseudoVAESZ_VS_M2_MF4 + 0U, // PseudoVAESZ_VS_M2_MF8 + 0U, // PseudoVAESZ_VS_M4_M1 + 0U, // PseudoVAESZ_VS_M4_M2 + 0U, // PseudoVAESZ_VS_M4_M4 + 0U, // PseudoVAESZ_VS_M4_MF2 + 0U, // PseudoVAESZ_VS_M4_MF4 + 0U, // PseudoVAESZ_VS_M4_MF8 + 0U, // PseudoVAESZ_VS_M8_M1 + 0U, // PseudoVAESZ_VS_M8_M2 + 0U, // PseudoVAESZ_VS_M8_M4 + 0U, // PseudoVAESZ_VS_M8_MF2 + 0U, // PseudoVAESZ_VS_M8_MF4 + 0U, // PseudoVAESZ_VS_M8_MF8 + 0U, // PseudoVAESZ_VS_MF2_MF2 + 0U, // PseudoVAESZ_VS_MF2_MF4 + 0U, // PseudoVAESZ_VS_MF2_MF8 + 0U, // PseudoVANDN_VV_M1 + 0U, // PseudoVANDN_VV_M1_MASK + 0U, // PseudoVANDN_VV_M2 + 0U, // PseudoVANDN_VV_M2_MASK + 0U, // PseudoVANDN_VV_M4 + 0U, // PseudoVANDN_VV_M4_MASK + 0U, // PseudoVANDN_VV_M8 + 0U, // PseudoVANDN_VV_M8_MASK + 0U, // PseudoVANDN_VV_MF2 + 0U, // PseudoVANDN_VV_MF2_MASK + 0U, // PseudoVANDN_VV_MF4 + 0U, // PseudoVANDN_VV_MF4_MASK + 0U, // PseudoVANDN_VV_MF8 + 0U, // PseudoVANDN_VV_MF8_MASK + 0U, // PseudoVANDN_VX_M1 + 0U, // PseudoVANDN_VX_M1_MASK + 0U, // PseudoVANDN_VX_M2 + 0U, // PseudoVANDN_VX_M2_MASK + 0U, // PseudoVANDN_VX_M4 + 0U, // PseudoVANDN_VX_M4_MASK + 0U, // PseudoVANDN_VX_M8 + 0U, // PseudoVANDN_VX_M8_MASK + 0U, // PseudoVANDN_VX_MF2 + 0U, // PseudoVANDN_VX_MF2_MASK + 0U, // PseudoVANDN_VX_MF4 + 0U, // PseudoVANDN_VX_MF4_MASK + 0U, // PseudoVANDN_VX_MF8 + 0U, // PseudoVANDN_VX_MF8_MASK + 0U, // PseudoVAND_VI_M1 + 0U, // PseudoVAND_VI_M1_MASK + 0U, // PseudoVAND_VI_M2 + 0U, // PseudoVAND_VI_M2_MASK + 0U, // PseudoVAND_VI_M4 + 0U, // PseudoVAND_VI_M4_MASK + 0U, // PseudoVAND_VI_M8 + 0U, // PseudoVAND_VI_M8_MASK + 0U, // PseudoVAND_VI_MF2 + 0U, // PseudoVAND_VI_MF2_MASK + 0U, // PseudoVAND_VI_MF4 + 0U, // PseudoVAND_VI_MF4_MASK + 0U, // PseudoVAND_VI_MF8 + 0U, // PseudoVAND_VI_MF8_MASK + 0U, // PseudoVAND_VV_M1 + 0U, // PseudoVAND_VV_M1_MASK + 0U, // PseudoVAND_VV_M2 + 0U, // PseudoVAND_VV_M2_MASK + 0U, // PseudoVAND_VV_M4 + 0U, // PseudoVAND_VV_M4_MASK + 0U, // PseudoVAND_VV_M8 + 0U, // PseudoVAND_VV_M8_MASK + 0U, // PseudoVAND_VV_MF2 + 0U, // PseudoVAND_VV_MF2_MASK + 0U, // PseudoVAND_VV_MF4 + 0U, // PseudoVAND_VV_MF4_MASK + 0U, // PseudoVAND_VV_MF8 + 0U, // PseudoVAND_VV_MF8_MASK + 0U, // PseudoVAND_VX_M1 + 0U, // PseudoVAND_VX_M1_MASK + 0U, // PseudoVAND_VX_M2 + 0U, // PseudoVAND_VX_M2_MASK + 0U, // PseudoVAND_VX_M4 + 0U, // PseudoVAND_VX_M4_MASK + 0U, // PseudoVAND_VX_M8 + 0U, // PseudoVAND_VX_M8_MASK + 0U, // PseudoVAND_VX_MF2 + 0U, // PseudoVAND_VX_MF2_MASK + 0U, // PseudoVAND_VX_MF4 + 0U, // PseudoVAND_VX_MF4_MASK + 0U, // PseudoVAND_VX_MF8 + 0U, // PseudoVAND_VX_MF8_MASK + 0U, // PseudoVASUBU_VV_M1 + 0U, // PseudoVASUBU_VV_M1_MASK + 0U, // PseudoVASUBU_VV_M2 + 0U, // PseudoVASUBU_VV_M2_MASK + 0U, // PseudoVASUBU_VV_M4 + 0U, // PseudoVASUBU_VV_M4_MASK + 0U, // PseudoVASUBU_VV_M8 + 0U, // PseudoVASUBU_VV_M8_MASK + 0U, // PseudoVASUBU_VV_MF2 + 0U, // PseudoVASUBU_VV_MF2_MASK + 0U, // PseudoVASUBU_VV_MF4 + 0U, // PseudoVASUBU_VV_MF4_MASK + 0U, // PseudoVASUBU_VV_MF8 + 0U, // PseudoVASUBU_VV_MF8_MASK + 0U, // PseudoVASUBU_VX_M1 + 0U, // PseudoVASUBU_VX_M1_MASK + 0U, // PseudoVASUBU_VX_M2 + 0U, // PseudoVASUBU_VX_M2_MASK + 0U, // PseudoVASUBU_VX_M4 + 0U, // PseudoVASUBU_VX_M4_MASK + 0U, // PseudoVASUBU_VX_M8 + 0U, // PseudoVASUBU_VX_M8_MASK + 0U, // PseudoVASUBU_VX_MF2 + 0U, // PseudoVASUBU_VX_MF2_MASK + 0U, // PseudoVASUBU_VX_MF4 + 0U, // PseudoVASUBU_VX_MF4_MASK + 0U, // PseudoVASUBU_VX_MF8 + 0U, // PseudoVASUBU_VX_MF8_MASK + 0U, // PseudoVASUB_VV_M1 + 0U, // PseudoVASUB_VV_M1_MASK + 0U, // PseudoVASUB_VV_M2 + 0U, // PseudoVASUB_VV_M2_MASK + 0U, // PseudoVASUB_VV_M4 + 0U, // PseudoVASUB_VV_M4_MASK + 0U, // PseudoVASUB_VV_M8 + 0U, // PseudoVASUB_VV_M8_MASK + 0U, // PseudoVASUB_VV_MF2 + 0U, // PseudoVASUB_VV_MF2_MASK + 0U, // PseudoVASUB_VV_MF4 + 0U, // PseudoVASUB_VV_MF4_MASK + 0U, // PseudoVASUB_VV_MF8 + 0U, // PseudoVASUB_VV_MF8_MASK + 0U, // PseudoVASUB_VX_M1 + 0U, // PseudoVASUB_VX_M1_MASK + 0U, // PseudoVASUB_VX_M2 + 0U, // PseudoVASUB_VX_M2_MASK + 0U, // PseudoVASUB_VX_M4 + 0U, // PseudoVASUB_VX_M4_MASK + 0U, // PseudoVASUB_VX_M8 + 0U, // PseudoVASUB_VX_M8_MASK + 0U, // PseudoVASUB_VX_MF2 + 0U, // PseudoVASUB_VX_MF2_MASK + 0U, // PseudoVASUB_VX_MF4 + 0U, // PseudoVASUB_VX_MF4_MASK + 0U, // PseudoVASUB_VX_MF8 + 0U, // PseudoVASUB_VX_MF8_MASK + 0U, // PseudoVBREV8_V_M1 + 0U, // PseudoVBREV8_V_M1_MASK + 0U, // PseudoVBREV8_V_M2 + 0U, // PseudoVBREV8_V_M2_MASK + 0U, // PseudoVBREV8_V_M4 + 0U, // PseudoVBREV8_V_M4_MASK + 0U, // PseudoVBREV8_V_M8 + 0U, // PseudoVBREV8_V_M8_MASK + 0U, // PseudoVBREV8_V_MF2 + 0U, // PseudoVBREV8_V_MF2_MASK + 0U, // PseudoVBREV8_V_MF4 + 0U, // PseudoVBREV8_V_MF4_MASK + 0U, // PseudoVBREV8_V_MF8 + 0U, // PseudoVBREV8_V_MF8_MASK + 0U, // PseudoVBREV_V_M1 + 0U, // PseudoVBREV_V_M1_MASK + 0U, // PseudoVBREV_V_M2 + 0U, // PseudoVBREV_V_M2_MASK + 0U, // PseudoVBREV_V_M4 + 0U, // PseudoVBREV_V_M4_MASK + 0U, // PseudoVBREV_V_M8 + 0U, // PseudoVBREV_V_M8_MASK + 0U, // PseudoVBREV_V_MF2 + 0U, // PseudoVBREV_V_MF2_MASK + 0U, // PseudoVBREV_V_MF4 + 0U, // PseudoVBREV_V_MF4_MASK + 0U, // PseudoVBREV_V_MF8 + 0U, // PseudoVBREV_V_MF8_MASK + 0U, // PseudoVCLMULH_VV_M1 + 0U, // PseudoVCLMULH_VV_M1_MASK + 0U, // PseudoVCLMULH_VV_M2 + 0U, // PseudoVCLMULH_VV_M2_MASK + 0U, // PseudoVCLMULH_VV_M4 + 0U, // PseudoVCLMULH_VV_M4_MASK + 0U, // PseudoVCLMULH_VV_M8 + 0U, // PseudoVCLMULH_VV_M8_MASK + 0U, // PseudoVCLMULH_VV_MF2 + 0U, // PseudoVCLMULH_VV_MF2_MASK + 0U, // PseudoVCLMULH_VV_MF4 + 0U, // PseudoVCLMULH_VV_MF4_MASK + 0U, // PseudoVCLMULH_VV_MF8 + 0U, // PseudoVCLMULH_VV_MF8_MASK + 0U, // PseudoVCLMULH_VX_M1 + 0U, // PseudoVCLMULH_VX_M1_MASK + 0U, // PseudoVCLMULH_VX_M2 + 0U, // PseudoVCLMULH_VX_M2_MASK + 0U, // PseudoVCLMULH_VX_M4 + 0U, // PseudoVCLMULH_VX_M4_MASK + 0U, // PseudoVCLMULH_VX_M8 + 0U, // PseudoVCLMULH_VX_M8_MASK + 0U, // PseudoVCLMULH_VX_MF2 + 0U, // PseudoVCLMULH_VX_MF2_MASK + 0U, // PseudoVCLMULH_VX_MF4 + 0U, // PseudoVCLMULH_VX_MF4_MASK + 0U, // PseudoVCLMULH_VX_MF8 + 0U, // PseudoVCLMULH_VX_MF8_MASK + 0U, // PseudoVCLMUL_VV_M1 + 0U, // PseudoVCLMUL_VV_M1_MASK + 0U, // PseudoVCLMUL_VV_M2 + 0U, // PseudoVCLMUL_VV_M2_MASK + 0U, // PseudoVCLMUL_VV_M4 + 0U, // PseudoVCLMUL_VV_M4_MASK + 0U, // PseudoVCLMUL_VV_M8 + 0U, // PseudoVCLMUL_VV_M8_MASK + 0U, // PseudoVCLMUL_VV_MF2 + 0U, // PseudoVCLMUL_VV_MF2_MASK + 0U, // PseudoVCLMUL_VV_MF4 + 0U, // PseudoVCLMUL_VV_MF4_MASK + 0U, // PseudoVCLMUL_VV_MF8 + 0U, // PseudoVCLMUL_VV_MF8_MASK + 0U, // PseudoVCLMUL_VX_M1 + 0U, // PseudoVCLMUL_VX_M1_MASK + 0U, // PseudoVCLMUL_VX_M2 + 0U, // PseudoVCLMUL_VX_M2_MASK + 0U, // PseudoVCLMUL_VX_M4 + 0U, // PseudoVCLMUL_VX_M4_MASK + 0U, // PseudoVCLMUL_VX_M8 + 0U, // PseudoVCLMUL_VX_M8_MASK + 0U, // PseudoVCLMUL_VX_MF2 + 0U, // PseudoVCLMUL_VX_MF2_MASK + 0U, // PseudoVCLMUL_VX_MF4 + 0U, // PseudoVCLMUL_VX_MF4_MASK + 0U, // PseudoVCLMUL_VX_MF8 + 0U, // PseudoVCLMUL_VX_MF8_MASK + 0U, // PseudoVCLZ_V_M1 + 0U, // PseudoVCLZ_V_M1_MASK + 0U, // PseudoVCLZ_V_M2 + 0U, // PseudoVCLZ_V_M2_MASK + 0U, // PseudoVCLZ_V_M4 + 0U, // PseudoVCLZ_V_M4_MASK + 0U, // PseudoVCLZ_V_M8 + 0U, // PseudoVCLZ_V_M8_MASK + 0U, // PseudoVCLZ_V_MF2 + 0U, // PseudoVCLZ_V_MF2_MASK + 0U, // PseudoVCLZ_V_MF4 + 0U, // PseudoVCLZ_V_MF4_MASK + 0U, // PseudoVCLZ_V_MF8 + 0U, // PseudoVCLZ_V_MF8_MASK + 0U, // PseudoVCOMPRESS_VM_M1_E16 + 0U, // PseudoVCOMPRESS_VM_M1_E32 + 0U, // PseudoVCOMPRESS_VM_M1_E64 + 0U, // PseudoVCOMPRESS_VM_M1_E8 + 0U, // PseudoVCOMPRESS_VM_M2_E16 + 0U, // PseudoVCOMPRESS_VM_M2_E32 + 0U, // PseudoVCOMPRESS_VM_M2_E64 + 0U, // PseudoVCOMPRESS_VM_M2_E8 + 0U, // PseudoVCOMPRESS_VM_M4_E16 + 0U, // PseudoVCOMPRESS_VM_M4_E32 + 0U, // PseudoVCOMPRESS_VM_M4_E64 + 0U, // PseudoVCOMPRESS_VM_M4_E8 + 0U, // PseudoVCOMPRESS_VM_M8_E16 + 0U, // PseudoVCOMPRESS_VM_M8_E32 + 0U, // PseudoVCOMPRESS_VM_M8_E64 + 0U, // PseudoVCOMPRESS_VM_M8_E8 + 0U, // PseudoVCOMPRESS_VM_MF2_E16 + 0U, // PseudoVCOMPRESS_VM_MF2_E32 + 0U, // PseudoVCOMPRESS_VM_MF2_E8 + 0U, // PseudoVCOMPRESS_VM_MF4_E16 + 0U, // PseudoVCOMPRESS_VM_MF4_E8 + 0U, // PseudoVCOMPRESS_VM_MF8_E8 + 0U, // PseudoVCPOP_M_B1 + 0U, // PseudoVCPOP_M_B16 + 0U, // PseudoVCPOP_M_B16_MASK + 0U, // PseudoVCPOP_M_B1_MASK + 0U, // PseudoVCPOP_M_B2 + 0U, // PseudoVCPOP_M_B2_MASK + 0U, // PseudoVCPOP_M_B32 + 0U, // PseudoVCPOP_M_B32_MASK + 0U, // PseudoVCPOP_M_B4 + 0U, // PseudoVCPOP_M_B4_MASK + 0U, // PseudoVCPOP_M_B64 + 0U, // PseudoVCPOP_M_B64_MASK + 0U, // PseudoVCPOP_M_B8 + 0U, // PseudoVCPOP_M_B8_MASK + 0U, // PseudoVCPOP_V_M1 + 0U, // PseudoVCPOP_V_M1_MASK + 0U, // PseudoVCPOP_V_M2 + 0U, // PseudoVCPOP_V_M2_MASK + 0U, // PseudoVCPOP_V_M4 + 0U, // PseudoVCPOP_V_M4_MASK + 0U, // PseudoVCPOP_V_M8 + 0U, // PseudoVCPOP_V_M8_MASK + 0U, // PseudoVCPOP_V_MF2 + 0U, // PseudoVCPOP_V_MF2_MASK + 0U, // PseudoVCPOP_V_MF4 + 0U, // PseudoVCPOP_V_MF4_MASK + 0U, // PseudoVCPOP_V_MF8 + 0U, // PseudoVCPOP_V_MF8_MASK + 0U, // PseudoVCTZ_V_M1 + 0U, // PseudoVCTZ_V_M1_MASK + 0U, // PseudoVCTZ_V_M2 + 0U, // PseudoVCTZ_V_M2_MASK + 0U, // PseudoVCTZ_V_M4 + 0U, // PseudoVCTZ_V_M4_MASK + 0U, // PseudoVCTZ_V_M8 + 0U, // PseudoVCTZ_V_M8_MASK + 0U, // PseudoVCTZ_V_MF2 + 0U, // PseudoVCTZ_V_MF2_MASK + 0U, // PseudoVCTZ_V_MF4 + 0U, // PseudoVCTZ_V_MF4_MASK + 0U, // PseudoVCTZ_V_MF8 + 0U, // PseudoVCTZ_V_MF8_MASK + 0U, // PseudoVC_FPR16VV_SE_M1 + 0U, // PseudoVC_FPR16VV_SE_M2 + 0U, // PseudoVC_FPR16VV_SE_M4 + 0U, // PseudoVC_FPR16VV_SE_M8 + 0U, // PseudoVC_FPR16VV_SE_MF2 + 0U, // PseudoVC_FPR16VV_SE_MF4 + 0U, // PseudoVC_FPR16VW_SE_M1 + 0U, // PseudoVC_FPR16VW_SE_M2 + 0U, // PseudoVC_FPR16VW_SE_M4 + 0U, // PseudoVC_FPR16VW_SE_M8 + 0U, // PseudoVC_FPR16VW_SE_MF2 + 0U, // PseudoVC_FPR16VW_SE_MF4 + 0U, // PseudoVC_FPR16V_SE_M1 + 0U, // PseudoVC_FPR16V_SE_M2 + 0U, // PseudoVC_FPR16V_SE_M4 + 0U, // PseudoVC_FPR16V_SE_M8 + 0U, // PseudoVC_FPR16V_SE_MF2 + 0U, // PseudoVC_FPR16V_SE_MF4 + 0U, // PseudoVC_FPR32VV_SE_M1 + 0U, // PseudoVC_FPR32VV_SE_M2 + 0U, // PseudoVC_FPR32VV_SE_M4 + 0U, // PseudoVC_FPR32VV_SE_M8 + 0U, // PseudoVC_FPR32VV_SE_MF2 + 0U, // PseudoVC_FPR32VW_SE_M1 + 0U, // PseudoVC_FPR32VW_SE_M2 + 0U, // PseudoVC_FPR32VW_SE_M4 + 0U, // PseudoVC_FPR32VW_SE_M8 + 0U, // PseudoVC_FPR32VW_SE_MF2 + 0U, // PseudoVC_FPR32V_SE_M1 + 0U, // PseudoVC_FPR32V_SE_M2 + 0U, // PseudoVC_FPR32V_SE_M4 + 0U, // PseudoVC_FPR32V_SE_M8 + 0U, // PseudoVC_FPR32V_SE_MF2 + 0U, // PseudoVC_FPR64VV_SE_M1 + 0U, // PseudoVC_FPR64VV_SE_M2 + 0U, // PseudoVC_FPR64VV_SE_M4 + 0U, // PseudoVC_FPR64VV_SE_M8 + 0U, // PseudoVC_FPR64V_SE_M1 + 0U, // PseudoVC_FPR64V_SE_M2 + 0U, // PseudoVC_FPR64V_SE_M4 + 0U, // PseudoVC_FPR64V_SE_M8 + 0U, // PseudoVC_IVV_SE_M1 + 0U, // PseudoVC_IVV_SE_M2 + 0U, // PseudoVC_IVV_SE_M4 + 0U, // PseudoVC_IVV_SE_M8 + 0U, // PseudoVC_IVV_SE_MF2 + 0U, // PseudoVC_IVV_SE_MF4 + 0U, // PseudoVC_IVV_SE_MF8 + 0U, // PseudoVC_IVW_SE_M1 + 0U, // PseudoVC_IVW_SE_M2 + 0U, // PseudoVC_IVW_SE_M4 + 0U, // PseudoVC_IVW_SE_MF2 + 0U, // PseudoVC_IVW_SE_MF4 + 0U, // PseudoVC_IVW_SE_MF8 + 0U, // PseudoVC_IV_SE_M1 + 0U, // PseudoVC_IV_SE_M2 + 0U, // PseudoVC_IV_SE_M4 + 0U, // PseudoVC_IV_SE_M8 + 0U, // PseudoVC_IV_SE_MF2 + 0U, // PseudoVC_IV_SE_MF4 + 0U, // PseudoVC_IV_SE_MF8 + 0U, // PseudoVC_I_SE_M1 + 0U, // PseudoVC_I_SE_M2 + 0U, // PseudoVC_I_SE_M4 + 0U, // PseudoVC_I_SE_M8 + 0U, // PseudoVC_I_SE_MF2 + 0U, // PseudoVC_I_SE_MF4 + 0U, // PseudoVC_I_SE_MF8 + 0U, // PseudoVC_VVV_SE_M1 + 0U, // PseudoVC_VVV_SE_M2 + 0U, // PseudoVC_VVV_SE_M4 + 0U, // PseudoVC_VVV_SE_M8 + 0U, // PseudoVC_VVV_SE_MF2 + 0U, // PseudoVC_VVV_SE_MF4 + 0U, // PseudoVC_VVV_SE_MF8 + 0U, // PseudoVC_VVW_SE_M1 + 0U, // PseudoVC_VVW_SE_M2 + 0U, // PseudoVC_VVW_SE_M4 + 0U, // PseudoVC_VVW_SE_MF2 + 0U, // PseudoVC_VVW_SE_MF4 + 0U, // PseudoVC_VVW_SE_MF8 + 0U, // PseudoVC_VV_SE_M1 + 0U, // PseudoVC_VV_SE_M2 + 0U, // PseudoVC_VV_SE_M4 + 0U, // PseudoVC_VV_SE_M8 + 0U, // PseudoVC_VV_SE_MF2 + 0U, // PseudoVC_VV_SE_MF4 + 0U, // PseudoVC_VV_SE_MF8 + 0U, // PseudoVC_V_FPR16VV_M1 + 0U, // PseudoVC_V_FPR16VV_M2 + 0U, // PseudoVC_V_FPR16VV_M4 + 0U, // PseudoVC_V_FPR16VV_M8 + 0U, // PseudoVC_V_FPR16VV_MF2 + 0U, // PseudoVC_V_FPR16VV_MF4 + 0U, // PseudoVC_V_FPR16VV_SE_M1 + 0U, // PseudoVC_V_FPR16VV_SE_M2 + 0U, // PseudoVC_V_FPR16VV_SE_M4 + 0U, // PseudoVC_V_FPR16VV_SE_M8 + 0U, // PseudoVC_V_FPR16VV_SE_MF2 + 0U, // PseudoVC_V_FPR16VV_SE_MF4 + 0U, // PseudoVC_V_FPR16VW_M1 + 0U, // PseudoVC_V_FPR16VW_M2 + 0U, // PseudoVC_V_FPR16VW_M4 + 0U, // PseudoVC_V_FPR16VW_M8 + 0U, // PseudoVC_V_FPR16VW_MF2 + 0U, // PseudoVC_V_FPR16VW_MF4 + 0U, // PseudoVC_V_FPR16VW_SE_M1 + 0U, // PseudoVC_V_FPR16VW_SE_M2 + 0U, // PseudoVC_V_FPR16VW_SE_M4 + 0U, // PseudoVC_V_FPR16VW_SE_M8 + 0U, // PseudoVC_V_FPR16VW_SE_MF2 + 0U, // PseudoVC_V_FPR16VW_SE_MF4 + 0U, // PseudoVC_V_FPR16V_M1 + 0U, // PseudoVC_V_FPR16V_M2 + 0U, // PseudoVC_V_FPR16V_M4 + 0U, // PseudoVC_V_FPR16V_M8 + 0U, // PseudoVC_V_FPR16V_MF2 + 0U, // PseudoVC_V_FPR16V_MF4 + 0U, // PseudoVC_V_FPR16V_SE_M1 + 0U, // PseudoVC_V_FPR16V_SE_M2 + 0U, // PseudoVC_V_FPR16V_SE_M4 + 0U, // PseudoVC_V_FPR16V_SE_M8 + 0U, // PseudoVC_V_FPR16V_SE_MF2 + 0U, // PseudoVC_V_FPR16V_SE_MF4 + 0U, // PseudoVC_V_FPR32VV_M1 + 0U, // PseudoVC_V_FPR32VV_M2 + 0U, // PseudoVC_V_FPR32VV_M4 + 0U, // PseudoVC_V_FPR32VV_M8 + 0U, // PseudoVC_V_FPR32VV_MF2 + 0U, // PseudoVC_V_FPR32VV_SE_M1 + 0U, // PseudoVC_V_FPR32VV_SE_M2 + 0U, // PseudoVC_V_FPR32VV_SE_M4 + 0U, // PseudoVC_V_FPR32VV_SE_M8 + 0U, // PseudoVC_V_FPR32VV_SE_MF2 + 0U, // PseudoVC_V_FPR32VW_M1 + 0U, // PseudoVC_V_FPR32VW_M2 + 0U, // PseudoVC_V_FPR32VW_M4 + 0U, // PseudoVC_V_FPR32VW_M8 + 0U, // PseudoVC_V_FPR32VW_MF2 + 0U, // PseudoVC_V_FPR32VW_SE_M1 + 0U, // PseudoVC_V_FPR32VW_SE_M2 + 0U, // PseudoVC_V_FPR32VW_SE_M4 + 0U, // PseudoVC_V_FPR32VW_SE_M8 + 0U, // PseudoVC_V_FPR32VW_SE_MF2 + 0U, // PseudoVC_V_FPR32V_M1 + 0U, // PseudoVC_V_FPR32V_M2 + 0U, // PseudoVC_V_FPR32V_M4 + 0U, // PseudoVC_V_FPR32V_M8 + 0U, // PseudoVC_V_FPR32V_MF2 + 0U, // PseudoVC_V_FPR32V_SE_M1 + 0U, // PseudoVC_V_FPR32V_SE_M2 + 0U, // PseudoVC_V_FPR32V_SE_M4 + 0U, // PseudoVC_V_FPR32V_SE_M8 + 0U, // PseudoVC_V_FPR32V_SE_MF2 + 0U, // PseudoVC_V_FPR64VV_M1 + 0U, // PseudoVC_V_FPR64VV_M2 + 0U, // PseudoVC_V_FPR64VV_M4 + 0U, // PseudoVC_V_FPR64VV_M8 + 0U, // PseudoVC_V_FPR64VV_SE_M1 + 0U, // PseudoVC_V_FPR64VV_SE_M2 + 0U, // PseudoVC_V_FPR64VV_SE_M4 + 0U, // PseudoVC_V_FPR64VV_SE_M8 + 0U, // PseudoVC_V_FPR64V_M1 + 0U, // PseudoVC_V_FPR64V_M2 + 0U, // PseudoVC_V_FPR64V_M4 + 0U, // PseudoVC_V_FPR64V_M8 + 0U, // PseudoVC_V_FPR64V_SE_M1 + 0U, // PseudoVC_V_FPR64V_SE_M2 + 0U, // PseudoVC_V_FPR64V_SE_M4 + 0U, // PseudoVC_V_FPR64V_SE_M8 + 0U, // PseudoVC_V_IVV_M1 + 0U, // PseudoVC_V_IVV_M2 + 0U, // PseudoVC_V_IVV_M4 + 0U, // PseudoVC_V_IVV_M8 + 0U, // PseudoVC_V_IVV_MF2 + 0U, // PseudoVC_V_IVV_MF4 + 0U, // PseudoVC_V_IVV_MF8 + 0U, // PseudoVC_V_IVV_SE_M1 + 0U, // PseudoVC_V_IVV_SE_M2 + 0U, // PseudoVC_V_IVV_SE_M4 + 0U, // PseudoVC_V_IVV_SE_M8 + 0U, // PseudoVC_V_IVV_SE_MF2 + 0U, // PseudoVC_V_IVV_SE_MF4 + 0U, // PseudoVC_V_IVV_SE_MF8 + 0U, // PseudoVC_V_IVW_M1 + 0U, // PseudoVC_V_IVW_M2 + 0U, // PseudoVC_V_IVW_M4 + 0U, // PseudoVC_V_IVW_MF2 + 0U, // PseudoVC_V_IVW_MF4 + 0U, // PseudoVC_V_IVW_MF8 + 0U, // PseudoVC_V_IVW_SE_M1 + 0U, // PseudoVC_V_IVW_SE_M2 + 0U, // PseudoVC_V_IVW_SE_M4 + 0U, // PseudoVC_V_IVW_SE_MF2 + 0U, // PseudoVC_V_IVW_SE_MF4 + 0U, // PseudoVC_V_IVW_SE_MF8 + 0U, // PseudoVC_V_IV_M1 + 0U, // PseudoVC_V_IV_M2 + 0U, // PseudoVC_V_IV_M4 + 0U, // PseudoVC_V_IV_M8 + 0U, // PseudoVC_V_IV_MF2 + 0U, // PseudoVC_V_IV_MF4 + 0U, // PseudoVC_V_IV_MF8 + 0U, // PseudoVC_V_IV_SE_M1 + 0U, // PseudoVC_V_IV_SE_M2 + 0U, // PseudoVC_V_IV_SE_M4 + 0U, // PseudoVC_V_IV_SE_M8 + 0U, // PseudoVC_V_IV_SE_MF2 + 0U, // PseudoVC_V_IV_SE_MF4 + 0U, // PseudoVC_V_IV_SE_MF8 + 0U, // PseudoVC_V_I_M1 + 0U, // PseudoVC_V_I_M2 + 0U, // PseudoVC_V_I_M4 + 0U, // PseudoVC_V_I_M8 + 0U, // PseudoVC_V_I_MF2 + 0U, // PseudoVC_V_I_MF4 + 0U, // PseudoVC_V_I_MF8 + 0U, // PseudoVC_V_I_SE_M1 + 0U, // PseudoVC_V_I_SE_M2 + 0U, // PseudoVC_V_I_SE_M4 + 0U, // PseudoVC_V_I_SE_M8 + 0U, // PseudoVC_V_I_SE_MF2 + 0U, // PseudoVC_V_I_SE_MF4 + 0U, // PseudoVC_V_I_SE_MF8 + 0U, // PseudoVC_V_VVV_M1 + 0U, // PseudoVC_V_VVV_M2 + 0U, // PseudoVC_V_VVV_M4 + 0U, // PseudoVC_V_VVV_M8 + 0U, // PseudoVC_V_VVV_MF2 + 0U, // PseudoVC_V_VVV_MF4 + 0U, // PseudoVC_V_VVV_MF8 + 0U, // PseudoVC_V_VVV_SE_M1 + 0U, // PseudoVC_V_VVV_SE_M2 + 0U, // PseudoVC_V_VVV_SE_M4 + 0U, // PseudoVC_V_VVV_SE_M8 + 0U, // PseudoVC_V_VVV_SE_MF2 + 0U, // PseudoVC_V_VVV_SE_MF4 + 0U, // PseudoVC_V_VVV_SE_MF8 + 0U, // PseudoVC_V_VVW_M1 + 0U, // PseudoVC_V_VVW_M2 + 0U, // PseudoVC_V_VVW_M4 + 0U, // PseudoVC_V_VVW_MF2 + 0U, // PseudoVC_V_VVW_MF4 + 0U, // PseudoVC_V_VVW_MF8 + 0U, // PseudoVC_V_VVW_SE_M1 + 0U, // PseudoVC_V_VVW_SE_M2 + 0U, // PseudoVC_V_VVW_SE_M4 + 0U, // PseudoVC_V_VVW_SE_MF2 + 0U, // PseudoVC_V_VVW_SE_MF4 + 0U, // PseudoVC_V_VVW_SE_MF8 + 0U, // PseudoVC_V_VV_M1 + 0U, // PseudoVC_V_VV_M2 + 0U, // PseudoVC_V_VV_M4 + 0U, // PseudoVC_V_VV_M8 + 0U, // PseudoVC_V_VV_MF2 + 0U, // PseudoVC_V_VV_MF4 + 0U, // PseudoVC_V_VV_MF8 + 0U, // PseudoVC_V_VV_SE_M1 + 0U, // PseudoVC_V_VV_SE_M2 + 0U, // PseudoVC_V_VV_SE_M4 + 0U, // PseudoVC_V_VV_SE_M8 + 0U, // PseudoVC_V_VV_SE_MF2 + 0U, // PseudoVC_V_VV_SE_MF4 + 0U, // PseudoVC_V_VV_SE_MF8 + 0U, // PseudoVC_V_XVV_M1 + 0U, // PseudoVC_V_XVV_M2 + 0U, // PseudoVC_V_XVV_M4 + 0U, // PseudoVC_V_XVV_M8 + 0U, // PseudoVC_V_XVV_MF2 + 0U, // PseudoVC_V_XVV_MF4 + 0U, // PseudoVC_V_XVV_MF8 + 0U, // PseudoVC_V_XVV_SE_M1 + 0U, // PseudoVC_V_XVV_SE_M2 + 0U, // PseudoVC_V_XVV_SE_M4 + 0U, // PseudoVC_V_XVV_SE_M8 + 0U, // PseudoVC_V_XVV_SE_MF2 + 0U, // PseudoVC_V_XVV_SE_MF4 + 0U, // PseudoVC_V_XVV_SE_MF8 + 0U, // PseudoVC_V_XVW_M1 + 0U, // PseudoVC_V_XVW_M2 + 0U, // PseudoVC_V_XVW_M4 + 0U, // PseudoVC_V_XVW_MF2 + 0U, // PseudoVC_V_XVW_MF4 + 0U, // PseudoVC_V_XVW_MF8 + 0U, // PseudoVC_V_XVW_SE_M1 + 0U, // PseudoVC_V_XVW_SE_M2 + 0U, // PseudoVC_V_XVW_SE_M4 + 0U, // PseudoVC_V_XVW_SE_MF2 + 0U, // PseudoVC_V_XVW_SE_MF4 + 0U, // PseudoVC_V_XVW_SE_MF8 + 0U, // PseudoVC_V_XV_M1 + 0U, // PseudoVC_V_XV_M2 + 0U, // PseudoVC_V_XV_M4 + 0U, // PseudoVC_V_XV_M8 + 0U, // PseudoVC_V_XV_MF2 + 0U, // PseudoVC_V_XV_MF4 + 0U, // PseudoVC_V_XV_MF8 + 0U, // PseudoVC_V_XV_SE_M1 + 0U, // PseudoVC_V_XV_SE_M2 + 0U, // PseudoVC_V_XV_SE_M4 + 0U, // PseudoVC_V_XV_SE_M8 + 0U, // PseudoVC_V_XV_SE_MF2 + 0U, // PseudoVC_V_XV_SE_MF4 + 0U, // PseudoVC_V_XV_SE_MF8 + 0U, // PseudoVC_V_X_M1 + 0U, // PseudoVC_V_X_M2 + 0U, // PseudoVC_V_X_M4 + 0U, // PseudoVC_V_X_M8 + 0U, // PseudoVC_V_X_MF2 + 0U, // PseudoVC_V_X_MF4 + 0U, // PseudoVC_V_X_MF8 + 0U, // PseudoVC_V_X_SE_M1 + 0U, // PseudoVC_V_X_SE_M2 + 0U, // PseudoVC_V_X_SE_M4 + 0U, // PseudoVC_V_X_SE_M8 + 0U, // PseudoVC_V_X_SE_MF2 + 0U, // PseudoVC_V_X_SE_MF4 + 0U, // PseudoVC_V_X_SE_MF8 + 0U, // PseudoVC_XVV_SE_M1 + 0U, // PseudoVC_XVV_SE_M2 + 0U, // PseudoVC_XVV_SE_M4 + 0U, // PseudoVC_XVV_SE_M8 + 0U, // PseudoVC_XVV_SE_MF2 + 0U, // PseudoVC_XVV_SE_MF4 + 0U, // PseudoVC_XVV_SE_MF8 + 0U, // PseudoVC_XVW_SE_M1 + 0U, // PseudoVC_XVW_SE_M2 + 0U, // PseudoVC_XVW_SE_M4 + 0U, // PseudoVC_XVW_SE_MF2 + 0U, // PseudoVC_XVW_SE_MF4 + 0U, // PseudoVC_XVW_SE_MF8 + 0U, // PseudoVC_XV_SE_M1 + 0U, // PseudoVC_XV_SE_M2 + 0U, // PseudoVC_XV_SE_M4 + 0U, // PseudoVC_XV_SE_M8 + 0U, // PseudoVC_XV_SE_MF2 + 0U, // PseudoVC_XV_SE_MF4 + 0U, // PseudoVC_XV_SE_MF8 + 0U, // PseudoVC_X_SE_M1 + 0U, // PseudoVC_X_SE_M2 + 0U, // PseudoVC_X_SE_M4 + 0U, // PseudoVC_X_SE_M8 + 0U, // PseudoVC_X_SE_MF2 + 0U, // PseudoVC_X_SE_MF4 + 0U, // PseudoVC_X_SE_MF8 + 0U, // PseudoVDIVU_VV_M1_E16 + 0U, // PseudoVDIVU_VV_M1_E16_MASK + 0U, // PseudoVDIVU_VV_M1_E32 + 0U, // PseudoVDIVU_VV_M1_E32_MASK + 0U, // PseudoVDIVU_VV_M1_E64 + 0U, // PseudoVDIVU_VV_M1_E64_MASK + 0U, // PseudoVDIVU_VV_M1_E8 + 0U, // PseudoVDIVU_VV_M1_E8_MASK + 0U, // PseudoVDIVU_VV_M2_E16 + 0U, // PseudoVDIVU_VV_M2_E16_MASK + 0U, // PseudoVDIVU_VV_M2_E32 + 0U, // PseudoVDIVU_VV_M2_E32_MASK + 0U, // PseudoVDIVU_VV_M2_E64 + 0U, // PseudoVDIVU_VV_M2_E64_MASK + 0U, // PseudoVDIVU_VV_M2_E8 + 0U, // PseudoVDIVU_VV_M2_E8_MASK + 0U, // PseudoVDIVU_VV_M4_E16 + 0U, // PseudoVDIVU_VV_M4_E16_MASK + 0U, // PseudoVDIVU_VV_M4_E32 + 0U, // PseudoVDIVU_VV_M4_E32_MASK + 0U, // PseudoVDIVU_VV_M4_E64 + 0U, // PseudoVDIVU_VV_M4_E64_MASK + 0U, // PseudoVDIVU_VV_M4_E8 + 0U, // PseudoVDIVU_VV_M4_E8_MASK + 0U, // PseudoVDIVU_VV_M8_E16 + 0U, // PseudoVDIVU_VV_M8_E16_MASK + 0U, // PseudoVDIVU_VV_M8_E32 + 0U, // PseudoVDIVU_VV_M8_E32_MASK + 0U, // PseudoVDIVU_VV_M8_E64 + 0U, // PseudoVDIVU_VV_M8_E64_MASK + 0U, // PseudoVDIVU_VV_M8_E8 + 0U, // PseudoVDIVU_VV_M8_E8_MASK + 0U, // PseudoVDIVU_VV_MF2_E16 + 0U, // PseudoVDIVU_VV_MF2_E16_MASK + 0U, // PseudoVDIVU_VV_MF2_E32 + 0U, // PseudoVDIVU_VV_MF2_E32_MASK + 0U, // PseudoVDIVU_VV_MF2_E8 + 0U, // PseudoVDIVU_VV_MF2_E8_MASK + 0U, // PseudoVDIVU_VV_MF4_E16 + 0U, // PseudoVDIVU_VV_MF4_E16_MASK + 0U, // PseudoVDIVU_VV_MF4_E8 + 0U, // PseudoVDIVU_VV_MF4_E8_MASK + 0U, // PseudoVDIVU_VV_MF8_E8 + 0U, // PseudoVDIVU_VV_MF8_E8_MASK + 0U, // PseudoVDIVU_VX_M1_E16 + 0U, // PseudoVDIVU_VX_M1_E16_MASK + 0U, // PseudoVDIVU_VX_M1_E32 + 0U, // PseudoVDIVU_VX_M1_E32_MASK + 0U, // PseudoVDIVU_VX_M1_E64 + 0U, // PseudoVDIVU_VX_M1_E64_MASK + 0U, // PseudoVDIVU_VX_M1_E8 + 0U, // PseudoVDIVU_VX_M1_E8_MASK + 0U, // PseudoVDIVU_VX_M2_E16 + 0U, // PseudoVDIVU_VX_M2_E16_MASK + 0U, // PseudoVDIVU_VX_M2_E32 + 0U, // PseudoVDIVU_VX_M2_E32_MASK + 0U, // PseudoVDIVU_VX_M2_E64 + 0U, // PseudoVDIVU_VX_M2_E64_MASK + 0U, // PseudoVDIVU_VX_M2_E8 + 0U, // PseudoVDIVU_VX_M2_E8_MASK + 0U, // PseudoVDIVU_VX_M4_E16 + 0U, // PseudoVDIVU_VX_M4_E16_MASK + 0U, // PseudoVDIVU_VX_M4_E32 + 0U, // PseudoVDIVU_VX_M4_E32_MASK + 0U, // PseudoVDIVU_VX_M4_E64 + 0U, // PseudoVDIVU_VX_M4_E64_MASK + 0U, // PseudoVDIVU_VX_M4_E8 + 0U, // PseudoVDIVU_VX_M4_E8_MASK + 0U, // PseudoVDIVU_VX_M8_E16 + 0U, // PseudoVDIVU_VX_M8_E16_MASK + 0U, // PseudoVDIVU_VX_M8_E32 + 0U, // PseudoVDIVU_VX_M8_E32_MASK + 0U, // PseudoVDIVU_VX_M8_E64 + 0U, // PseudoVDIVU_VX_M8_E64_MASK + 0U, // PseudoVDIVU_VX_M8_E8 + 0U, // PseudoVDIVU_VX_M8_E8_MASK + 0U, // PseudoVDIVU_VX_MF2_E16 + 0U, // PseudoVDIVU_VX_MF2_E16_MASK + 0U, // PseudoVDIVU_VX_MF2_E32 + 0U, // PseudoVDIVU_VX_MF2_E32_MASK + 0U, // PseudoVDIVU_VX_MF2_E8 + 0U, // PseudoVDIVU_VX_MF2_E8_MASK + 0U, // PseudoVDIVU_VX_MF4_E16 + 0U, // PseudoVDIVU_VX_MF4_E16_MASK + 0U, // PseudoVDIVU_VX_MF4_E8 + 0U, // PseudoVDIVU_VX_MF4_E8_MASK + 0U, // PseudoVDIVU_VX_MF8_E8 + 0U, // PseudoVDIVU_VX_MF8_E8_MASK + 0U, // PseudoVDIV_VV_M1_E16 + 0U, // PseudoVDIV_VV_M1_E16_MASK + 0U, // PseudoVDIV_VV_M1_E32 + 0U, // PseudoVDIV_VV_M1_E32_MASK + 0U, // PseudoVDIV_VV_M1_E64 + 0U, // PseudoVDIV_VV_M1_E64_MASK + 0U, // PseudoVDIV_VV_M1_E8 + 0U, // PseudoVDIV_VV_M1_E8_MASK + 0U, // PseudoVDIV_VV_M2_E16 + 0U, // PseudoVDIV_VV_M2_E16_MASK + 0U, // PseudoVDIV_VV_M2_E32 + 0U, // PseudoVDIV_VV_M2_E32_MASK + 0U, // PseudoVDIV_VV_M2_E64 + 0U, // PseudoVDIV_VV_M2_E64_MASK + 0U, // PseudoVDIV_VV_M2_E8 + 0U, // PseudoVDIV_VV_M2_E8_MASK + 0U, // PseudoVDIV_VV_M4_E16 + 0U, // PseudoVDIV_VV_M4_E16_MASK + 0U, // PseudoVDIV_VV_M4_E32 + 0U, // PseudoVDIV_VV_M4_E32_MASK + 0U, // PseudoVDIV_VV_M4_E64 + 0U, // PseudoVDIV_VV_M4_E64_MASK + 0U, // PseudoVDIV_VV_M4_E8 + 0U, // PseudoVDIV_VV_M4_E8_MASK + 0U, // PseudoVDIV_VV_M8_E16 + 0U, // PseudoVDIV_VV_M8_E16_MASK + 0U, // PseudoVDIV_VV_M8_E32 + 0U, // PseudoVDIV_VV_M8_E32_MASK + 0U, // PseudoVDIV_VV_M8_E64 + 0U, // PseudoVDIV_VV_M8_E64_MASK + 0U, // PseudoVDIV_VV_M8_E8 + 0U, // PseudoVDIV_VV_M8_E8_MASK + 0U, // PseudoVDIV_VV_MF2_E16 + 0U, // PseudoVDIV_VV_MF2_E16_MASK + 0U, // PseudoVDIV_VV_MF2_E32 + 0U, // PseudoVDIV_VV_MF2_E32_MASK + 0U, // PseudoVDIV_VV_MF2_E8 + 0U, // PseudoVDIV_VV_MF2_E8_MASK + 0U, // PseudoVDIV_VV_MF4_E16 + 0U, // PseudoVDIV_VV_MF4_E16_MASK + 0U, // PseudoVDIV_VV_MF4_E8 + 0U, // PseudoVDIV_VV_MF4_E8_MASK + 0U, // PseudoVDIV_VV_MF8_E8 + 0U, // PseudoVDIV_VV_MF8_E8_MASK + 0U, // PseudoVDIV_VX_M1_E16 + 0U, // PseudoVDIV_VX_M1_E16_MASK + 0U, // PseudoVDIV_VX_M1_E32 + 0U, // PseudoVDIV_VX_M1_E32_MASK + 0U, // PseudoVDIV_VX_M1_E64 + 0U, // PseudoVDIV_VX_M1_E64_MASK + 0U, // PseudoVDIV_VX_M1_E8 + 0U, // PseudoVDIV_VX_M1_E8_MASK + 0U, // PseudoVDIV_VX_M2_E16 + 0U, // PseudoVDIV_VX_M2_E16_MASK + 0U, // PseudoVDIV_VX_M2_E32 + 0U, // PseudoVDIV_VX_M2_E32_MASK + 0U, // PseudoVDIV_VX_M2_E64 + 0U, // PseudoVDIV_VX_M2_E64_MASK + 0U, // PseudoVDIV_VX_M2_E8 + 0U, // PseudoVDIV_VX_M2_E8_MASK + 0U, // PseudoVDIV_VX_M4_E16 + 0U, // PseudoVDIV_VX_M4_E16_MASK + 0U, // PseudoVDIV_VX_M4_E32 + 0U, // PseudoVDIV_VX_M4_E32_MASK + 0U, // PseudoVDIV_VX_M4_E64 + 0U, // PseudoVDIV_VX_M4_E64_MASK + 0U, // PseudoVDIV_VX_M4_E8 + 0U, // PseudoVDIV_VX_M4_E8_MASK + 0U, // PseudoVDIV_VX_M8_E16 + 0U, // PseudoVDIV_VX_M8_E16_MASK + 0U, // PseudoVDIV_VX_M8_E32 + 0U, // PseudoVDIV_VX_M8_E32_MASK + 0U, // PseudoVDIV_VX_M8_E64 + 0U, // PseudoVDIV_VX_M8_E64_MASK + 0U, // PseudoVDIV_VX_M8_E8 + 0U, // PseudoVDIV_VX_M8_E8_MASK + 0U, // PseudoVDIV_VX_MF2_E16 + 0U, // PseudoVDIV_VX_MF2_E16_MASK + 0U, // PseudoVDIV_VX_MF2_E32 + 0U, // PseudoVDIV_VX_MF2_E32_MASK + 0U, // PseudoVDIV_VX_MF2_E8 + 0U, // PseudoVDIV_VX_MF2_E8_MASK + 0U, // PseudoVDIV_VX_MF4_E16 + 0U, // PseudoVDIV_VX_MF4_E16_MASK + 0U, // PseudoVDIV_VX_MF4_E8 + 0U, // PseudoVDIV_VX_MF4_E8_MASK + 0U, // PseudoVDIV_VX_MF8_E8 + 0U, // PseudoVDIV_VX_MF8_E8_MASK + 0U, // PseudoVFADD_VFPR16_M1 + 0U, // PseudoVFADD_VFPR16_M1_MASK + 0U, // PseudoVFADD_VFPR16_M2 + 0U, // PseudoVFADD_VFPR16_M2_MASK + 0U, // PseudoVFADD_VFPR16_M4 + 0U, // PseudoVFADD_VFPR16_M4_MASK + 0U, // PseudoVFADD_VFPR16_M8 + 0U, // PseudoVFADD_VFPR16_M8_MASK + 0U, // PseudoVFADD_VFPR16_MF2 + 0U, // PseudoVFADD_VFPR16_MF2_MASK + 0U, // PseudoVFADD_VFPR16_MF4 + 0U, // PseudoVFADD_VFPR16_MF4_MASK + 0U, // PseudoVFADD_VFPR32_M1 + 0U, // PseudoVFADD_VFPR32_M1_MASK + 0U, // PseudoVFADD_VFPR32_M2 + 0U, // PseudoVFADD_VFPR32_M2_MASK + 0U, // PseudoVFADD_VFPR32_M4 + 0U, // PseudoVFADD_VFPR32_M4_MASK + 0U, // PseudoVFADD_VFPR32_M8 + 0U, // PseudoVFADD_VFPR32_M8_MASK + 0U, // PseudoVFADD_VFPR32_MF2 + 0U, // PseudoVFADD_VFPR32_MF2_MASK + 0U, // PseudoVFADD_VFPR64_M1 + 0U, // PseudoVFADD_VFPR64_M1_MASK + 0U, // PseudoVFADD_VFPR64_M2 + 0U, // PseudoVFADD_VFPR64_M2_MASK + 0U, // PseudoVFADD_VFPR64_M4 + 0U, // PseudoVFADD_VFPR64_M4_MASK + 0U, // PseudoVFADD_VFPR64_M8 + 0U, // PseudoVFADD_VFPR64_M8_MASK + 0U, // PseudoVFADD_VV_M1 + 0U, // PseudoVFADD_VV_M1_MASK + 0U, // PseudoVFADD_VV_M2 + 0U, // PseudoVFADD_VV_M2_MASK + 0U, // PseudoVFADD_VV_M4 + 0U, // PseudoVFADD_VV_M4_MASK + 0U, // PseudoVFADD_VV_M8 + 0U, // PseudoVFADD_VV_M8_MASK + 0U, // PseudoVFADD_VV_MF2 + 0U, // PseudoVFADD_VV_MF2_MASK + 0U, // PseudoVFADD_VV_MF4 + 0U, // PseudoVFADD_VV_MF4_MASK + 0U, // PseudoVFCLASS_V_M1 + 0U, // PseudoVFCLASS_V_M1_MASK + 0U, // PseudoVFCLASS_V_M2 + 0U, // PseudoVFCLASS_V_M2_MASK + 0U, // PseudoVFCLASS_V_M4 + 0U, // PseudoVFCLASS_V_M4_MASK + 0U, // PseudoVFCLASS_V_M8 + 0U, // PseudoVFCLASS_V_M8_MASK + 0U, // PseudoVFCLASS_V_MF2 + 0U, // PseudoVFCLASS_V_MF2_MASK + 0U, // PseudoVFCLASS_V_MF4 + 0U, // PseudoVFCLASS_V_MF4_MASK + 0U, // PseudoVFCVT_F_XU_V_M1 + 0U, // PseudoVFCVT_F_XU_V_M1_MASK + 0U, // PseudoVFCVT_F_XU_V_M2 + 0U, // PseudoVFCVT_F_XU_V_M2_MASK + 0U, // PseudoVFCVT_F_XU_V_M4 + 0U, // PseudoVFCVT_F_XU_V_M4_MASK + 0U, // PseudoVFCVT_F_XU_V_M8 + 0U, // PseudoVFCVT_F_XU_V_M8_MASK + 0U, // PseudoVFCVT_F_XU_V_MF2 + 0U, // PseudoVFCVT_F_XU_V_MF2_MASK + 0U, // PseudoVFCVT_F_XU_V_MF4 + 0U, // PseudoVFCVT_F_XU_V_MF4_MASK + 0U, // PseudoVFCVT_F_X_V_M1 + 0U, // PseudoVFCVT_F_X_V_M1_MASK + 0U, // PseudoVFCVT_F_X_V_M2 + 0U, // PseudoVFCVT_F_X_V_M2_MASK + 0U, // PseudoVFCVT_F_X_V_M4 + 0U, // PseudoVFCVT_F_X_V_M4_MASK + 0U, // PseudoVFCVT_F_X_V_M8 + 0U, // PseudoVFCVT_F_X_V_M8_MASK + 0U, // PseudoVFCVT_F_X_V_MF2 + 0U, // PseudoVFCVT_F_X_V_MF2_MASK + 0U, // PseudoVFCVT_F_X_V_MF4 + 0U, // PseudoVFCVT_F_X_V_MF4_MASK + 0U, // PseudoVFCVT_RM_F_XU_V_M1 + 0U, // PseudoVFCVT_RM_F_XU_V_M1_MASK + 0U, // PseudoVFCVT_RM_F_XU_V_M2 + 0U, // PseudoVFCVT_RM_F_XU_V_M2_MASK + 0U, // PseudoVFCVT_RM_F_XU_V_M4 + 0U, // PseudoVFCVT_RM_F_XU_V_M4_MASK + 0U, // PseudoVFCVT_RM_F_XU_V_M8 + 0U, // PseudoVFCVT_RM_F_XU_V_M8_MASK + 0U, // PseudoVFCVT_RM_F_XU_V_MF2 + 0U, // PseudoVFCVT_RM_F_XU_V_MF2_MASK + 0U, // PseudoVFCVT_RM_F_XU_V_MF4 + 0U, // PseudoVFCVT_RM_F_XU_V_MF4_MASK + 0U, // PseudoVFCVT_RM_F_X_V_M1 + 0U, // PseudoVFCVT_RM_F_X_V_M1_MASK + 0U, // PseudoVFCVT_RM_F_X_V_M2 + 0U, // PseudoVFCVT_RM_F_X_V_M2_MASK + 0U, // PseudoVFCVT_RM_F_X_V_M4 + 0U, // PseudoVFCVT_RM_F_X_V_M4_MASK + 0U, // PseudoVFCVT_RM_F_X_V_M8 + 0U, // PseudoVFCVT_RM_F_X_V_M8_MASK + 0U, // PseudoVFCVT_RM_F_X_V_MF2 + 0U, // PseudoVFCVT_RM_F_X_V_MF2_MASK + 0U, // PseudoVFCVT_RM_F_X_V_MF4 + 0U, // PseudoVFCVT_RM_F_X_V_MF4_MASK + 0U, // PseudoVFCVT_RM_XU_F_V_M1 + 0U, // PseudoVFCVT_RM_XU_F_V_M1_MASK + 0U, // PseudoVFCVT_RM_XU_F_V_M2 + 0U, // PseudoVFCVT_RM_XU_F_V_M2_MASK + 0U, // PseudoVFCVT_RM_XU_F_V_M4 + 0U, // PseudoVFCVT_RM_XU_F_V_M4_MASK + 0U, // PseudoVFCVT_RM_XU_F_V_M8 + 0U, // PseudoVFCVT_RM_XU_F_V_M8_MASK + 0U, // PseudoVFCVT_RM_XU_F_V_MF2 + 0U, // PseudoVFCVT_RM_XU_F_V_MF2_MASK + 0U, // PseudoVFCVT_RM_XU_F_V_MF4 + 0U, // PseudoVFCVT_RM_XU_F_V_MF4_MASK + 0U, // PseudoVFCVT_RM_X_F_V_M1 + 0U, // PseudoVFCVT_RM_X_F_V_M1_MASK + 0U, // PseudoVFCVT_RM_X_F_V_M2 + 0U, // PseudoVFCVT_RM_X_F_V_M2_MASK + 0U, // PseudoVFCVT_RM_X_F_V_M4 + 0U, // PseudoVFCVT_RM_X_F_V_M4_MASK + 0U, // PseudoVFCVT_RM_X_F_V_M8 + 0U, // PseudoVFCVT_RM_X_F_V_M8_MASK + 0U, // PseudoVFCVT_RM_X_F_V_MF2 + 0U, // PseudoVFCVT_RM_X_F_V_MF2_MASK + 0U, // PseudoVFCVT_RM_X_F_V_MF4 + 0U, // PseudoVFCVT_RM_X_F_V_MF4_MASK + 0U, // PseudoVFCVT_RTZ_XU_F_V_M1 + 0U, // PseudoVFCVT_RTZ_XU_F_V_M1_MASK + 0U, // PseudoVFCVT_RTZ_XU_F_V_M2 + 0U, // PseudoVFCVT_RTZ_XU_F_V_M2_MASK + 0U, // PseudoVFCVT_RTZ_XU_F_V_M4 + 0U, // PseudoVFCVT_RTZ_XU_F_V_M4_MASK + 0U, // PseudoVFCVT_RTZ_XU_F_V_M8 + 0U, // PseudoVFCVT_RTZ_XU_F_V_M8_MASK + 0U, // PseudoVFCVT_RTZ_XU_F_V_MF2 + 0U, // PseudoVFCVT_RTZ_XU_F_V_MF2_MASK + 0U, // PseudoVFCVT_RTZ_XU_F_V_MF4 + 0U, // PseudoVFCVT_RTZ_XU_F_V_MF4_MASK + 0U, // PseudoVFCVT_RTZ_X_F_V_M1 + 0U, // PseudoVFCVT_RTZ_X_F_V_M1_MASK + 0U, // PseudoVFCVT_RTZ_X_F_V_M2 + 0U, // PseudoVFCVT_RTZ_X_F_V_M2_MASK + 0U, // PseudoVFCVT_RTZ_X_F_V_M4 + 0U, // PseudoVFCVT_RTZ_X_F_V_M4_MASK + 0U, // PseudoVFCVT_RTZ_X_F_V_M8 + 0U, // PseudoVFCVT_RTZ_X_F_V_M8_MASK + 0U, // PseudoVFCVT_RTZ_X_F_V_MF2 + 0U, // PseudoVFCVT_RTZ_X_F_V_MF2_MASK + 0U, // PseudoVFCVT_RTZ_X_F_V_MF4 + 0U, // PseudoVFCVT_RTZ_X_F_V_MF4_MASK + 0U, // PseudoVFCVT_XU_F_V_M1 + 0U, // PseudoVFCVT_XU_F_V_M1_MASK + 0U, // PseudoVFCVT_XU_F_V_M2 + 0U, // PseudoVFCVT_XU_F_V_M2_MASK + 0U, // PseudoVFCVT_XU_F_V_M4 + 0U, // PseudoVFCVT_XU_F_V_M4_MASK + 0U, // PseudoVFCVT_XU_F_V_M8 + 0U, // PseudoVFCVT_XU_F_V_M8_MASK + 0U, // PseudoVFCVT_XU_F_V_MF2 + 0U, // PseudoVFCVT_XU_F_V_MF2_MASK + 0U, // PseudoVFCVT_XU_F_V_MF4 + 0U, // PseudoVFCVT_XU_F_V_MF4_MASK + 0U, // PseudoVFCVT_X_F_V_M1 + 0U, // PseudoVFCVT_X_F_V_M1_MASK + 0U, // PseudoVFCVT_X_F_V_M2 + 0U, // PseudoVFCVT_X_F_V_M2_MASK + 0U, // PseudoVFCVT_X_F_V_M4 + 0U, // PseudoVFCVT_X_F_V_M4_MASK + 0U, // PseudoVFCVT_X_F_V_M8 + 0U, // PseudoVFCVT_X_F_V_M8_MASK + 0U, // PseudoVFCVT_X_F_V_MF2 + 0U, // PseudoVFCVT_X_F_V_MF2_MASK + 0U, // PseudoVFCVT_X_F_V_MF4 + 0U, // PseudoVFCVT_X_F_V_MF4_MASK + 0U, // PseudoVFDIV_VFPR16_M1_E16 + 0U, // PseudoVFDIV_VFPR16_M1_E16_MASK + 0U, // PseudoVFDIV_VFPR16_M2_E16 + 0U, // PseudoVFDIV_VFPR16_M2_E16_MASK + 0U, // PseudoVFDIV_VFPR16_M4_E16 + 0U, // PseudoVFDIV_VFPR16_M4_E16_MASK + 0U, // PseudoVFDIV_VFPR16_M8_E16 + 0U, // PseudoVFDIV_VFPR16_M8_E16_MASK + 0U, // PseudoVFDIV_VFPR16_MF2_E16 + 0U, // PseudoVFDIV_VFPR16_MF2_E16_MASK + 0U, // PseudoVFDIV_VFPR16_MF4_E16 + 0U, // PseudoVFDIV_VFPR16_MF4_E16_MASK + 0U, // PseudoVFDIV_VFPR32_M1_E32 + 0U, // PseudoVFDIV_VFPR32_M1_E32_MASK + 0U, // PseudoVFDIV_VFPR32_M2_E32 + 0U, // PseudoVFDIV_VFPR32_M2_E32_MASK + 0U, // PseudoVFDIV_VFPR32_M4_E32 + 0U, // PseudoVFDIV_VFPR32_M4_E32_MASK + 0U, // PseudoVFDIV_VFPR32_M8_E32 + 0U, // PseudoVFDIV_VFPR32_M8_E32_MASK + 0U, // PseudoVFDIV_VFPR32_MF2_E32 + 0U, // PseudoVFDIV_VFPR32_MF2_E32_MASK + 0U, // PseudoVFDIV_VFPR64_M1_E64 + 0U, // PseudoVFDIV_VFPR64_M1_E64_MASK + 0U, // PseudoVFDIV_VFPR64_M2_E64 + 0U, // PseudoVFDIV_VFPR64_M2_E64_MASK + 0U, // PseudoVFDIV_VFPR64_M4_E64 + 0U, // PseudoVFDIV_VFPR64_M4_E64_MASK + 0U, // PseudoVFDIV_VFPR64_M8_E64 + 0U, // PseudoVFDIV_VFPR64_M8_E64_MASK + 0U, // PseudoVFDIV_VV_M1_E16 + 0U, // PseudoVFDIV_VV_M1_E16_MASK + 0U, // PseudoVFDIV_VV_M1_E32 + 0U, // PseudoVFDIV_VV_M1_E32_MASK + 0U, // PseudoVFDIV_VV_M1_E64 + 0U, // PseudoVFDIV_VV_M1_E64_MASK + 0U, // PseudoVFDIV_VV_M2_E16 + 0U, // PseudoVFDIV_VV_M2_E16_MASK + 0U, // PseudoVFDIV_VV_M2_E32 + 0U, // PseudoVFDIV_VV_M2_E32_MASK + 0U, // PseudoVFDIV_VV_M2_E64 + 0U, // PseudoVFDIV_VV_M2_E64_MASK + 0U, // PseudoVFDIV_VV_M4_E16 + 0U, // PseudoVFDIV_VV_M4_E16_MASK + 0U, // PseudoVFDIV_VV_M4_E32 + 0U, // PseudoVFDIV_VV_M4_E32_MASK + 0U, // PseudoVFDIV_VV_M4_E64 + 0U, // PseudoVFDIV_VV_M4_E64_MASK + 0U, // PseudoVFDIV_VV_M8_E16 + 0U, // PseudoVFDIV_VV_M8_E16_MASK + 0U, // PseudoVFDIV_VV_M8_E32 + 0U, // PseudoVFDIV_VV_M8_E32_MASK + 0U, // PseudoVFDIV_VV_M8_E64 + 0U, // PseudoVFDIV_VV_M8_E64_MASK + 0U, // PseudoVFDIV_VV_MF2_E16 + 0U, // PseudoVFDIV_VV_MF2_E16_MASK + 0U, // PseudoVFDIV_VV_MF2_E32 + 0U, // PseudoVFDIV_VV_MF2_E32_MASK + 0U, // PseudoVFDIV_VV_MF4_E16 + 0U, // PseudoVFDIV_VV_MF4_E16_MASK + 0U, // PseudoVFIRST_M_B1 + 0U, // PseudoVFIRST_M_B16 + 0U, // PseudoVFIRST_M_B16_MASK + 0U, // PseudoVFIRST_M_B1_MASK + 0U, // PseudoVFIRST_M_B2 + 0U, // PseudoVFIRST_M_B2_MASK + 0U, // PseudoVFIRST_M_B32 + 0U, // PseudoVFIRST_M_B32_MASK + 0U, // PseudoVFIRST_M_B4 + 0U, // PseudoVFIRST_M_B4_MASK + 0U, // PseudoVFIRST_M_B64 + 0U, // PseudoVFIRST_M_B64_MASK + 0U, // PseudoVFIRST_M_B8 + 0U, // PseudoVFIRST_M_B8_MASK + 0U, // PseudoVFMACC_VFPR16_M1 + 0U, // PseudoVFMACC_VFPR16_M1_MASK + 0U, // PseudoVFMACC_VFPR16_M2 + 0U, // PseudoVFMACC_VFPR16_M2_MASK + 0U, // PseudoVFMACC_VFPR16_M4 + 0U, // PseudoVFMACC_VFPR16_M4_MASK + 0U, // PseudoVFMACC_VFPR16_M8 + 0U, // PseudoVFMACC_VFPR16_M8_MASK + 0U, // PseudoVFMACC_VFPR16_MF2 + 0U, // PseudoVFMACC_VFPR16_MF2_MASK + 0U, // PseudoVFMACC_VFPR16_MF4 + 0U, // PseudoVFMACC_VFPR16_MF4_MASK + 0U, // PseudoVFMACC_VFPR32_M1 + 0U, // PseudoVFMACC_VFPR32_M1_MASK + 0U, // PseudoVFMACC_VFPR32_M2 + 0U, // PseudoVFMACC_VFPR32_M2_MASK + 0U, // PseudoVFMACC_VFPR32_M4 + 0U, // PseudoVFMACC_VFPR32_M4_MASK + 0U, // PseudoVFMACC_VFPR32_M8 + 0U, // PseudoVFMACC_VFPR32_M8_MASK + 0U, // PseudoVFMACC_VFPR32_MF2 + 0U, // PseudoVFMACC_VFPR32_MF2_MASK + 0U, // PseudoVFMACC_VFPR64_M1 + 0U, // PseudoVFMACC_VFPR64_M1_MASK + 0U, // PseudoVFMACC_VFPR64_M2 + 0U, // PseudoVFMACC_VFPR64_M2_MASK + 0U, // PseudoVFMACC_VFPR64_M4 + 0U, // PseudoVFMACC_VFPR64_M4_MASK + 0U, // PseudoVFMACC_VFPR64_M8 + 0U, // PseudoVFMACC_VFPR64_M8_MASK + 0U, // PseudoVFMACC_VV_M1 + 0U, // PseudoVFMACC_VV_M1_MASK + 0U, // PseudoVFMACC_VV_M2 + 0U, // PseudoVFMACC_VV_M2_MASK + 0U, // PseudoVFMACC_VV_M4 + 0U, // PseudoVFMACC_VV_M4_MASK + 0U, // PseudoVFMACC_VV_M8 + 0U, // PseudoVFMACC_VV_M8_MASK + 0U, // PseudoVFMACC_VV_MF2 + 0U, // PseudoVFMACC_VV_MF2_MASK + 0U, // PseudoVFMACC_VV_MF4 + 0U, // PseudoVFMACC_VV_MF4_MASK + 0U, // PseudoVFMADD_VFPR16_M1 + 0U, // PseudoVFMADD_VFPR16_M1_MASK + 0U, // PseudoVFMADD_VFPR16_M2 + 0U, // PseudoVFMADD_VFPR16_M2_MASK + 0U, // PseudoVFMADD_VFPR16_M4 + 0U, // PseudoVFMADD_VFPR16_M4_MASK + 0U, // PseudoVFMADD_VFPR16_M8 + 0U, // PseudoVFMADD_VFPR16_M8_MASK + 0U, // PseudoVFMADD_VFPR16_MF2 + 0U, // PseudoVFMADD_VFPR16_MF2_MASK + 0U, // PseudoVFMADD_VFPR16_MF4 + 0U, // PseudoVFMADD_VFPR16_MF4_MASK + 0U, // PseudoVFMADD_VFPR32_M1 + 0U, // PseudoVFMADD_VFPR32_M1_MASK + 0U, // PseudoVFMADD_VFPR32_M2 + 0U, // PseudoVFMADD_VFPR32_M2_MASK + 0U, // PseudoVFMADD_VFPR32_M4 + 0U, // PseudoVFMADD_VFPR32_M4_MASK + 0U, // PseudoVFMADD_VFPR32_M8 + 0U, // PseudoVFMADD_VFPR32_M8_MASK + 0U, // PseudoVFMADD_VFPR32_MF2 + 0U, // PseudoVFMADD_VFPR32_MF2_MASK + 0U, // PseudoVFMADD_VFPR64_M1 + 0U, // PseudoVFMADD_VFPR64_M1_MASK + 0U, // PseudoVFMADD_VFPR64_M2 + 0U, // PseudoVFMADD_VFPR64_M2_MASK + 0U, // PseudoVFMADD_VFPR64_M4 + 0U, // PseudoVFMADD_VFPR64_M4_MASK + 0U, // PseudoVFMADD_VFPR64_M8 + 0U, // PseudoVFMADD_VFPR64_M8_MASK + 0U, // PseudoVFMADD_VV_M1 + 0U, // PseudoVFMADD_VV_M1_MASK + 0U, // PseudoVFMADD_VV_M2 + 0U, // PseudoVFMADD_VV_M2_MASK + 0U, // PseudoVFMADD_VV_M4 + 0U, // PseudoVFMADD_VV_M4_MASK + 0U, // PseudoVFMADD_VV_M8 + 0U, // PseudoVFMADD_VV_M8_MASK + 0U, // PseudoVFMADD_VV_MF2 + 0U, // PseudoVFMADD_VV_MF2_MASK + 0U, // PseudoVFMADD_VV_MF4 + 0U, // PseudoVFMADD_VV_MF4_MASK + 0U, // PseudoVFMAX_VFPR16_M1 + 0U, // PseudoVFMAX_VFPR16_M1_MASK + 0U, // PseudoVFMAX_VFPR16_M2 + 0U, // PseudoVFMAX_VFPR16_M2_MASK + 0U, // PseudoVFMAX_VFPR16_M4 + 0U, // PseudoVFMAX_VFPR16_M4_MASK + 0U, // PseudoVFMAX_VFPR16_M8 + 0U, // PseudoVFMAX_VFPR16_M8_MASK + 0U, // PseudoVFMAX_VFPR16_MF2 + 0U, // PseudoVFMAX_VFPR16_MF2_MASK + 0U, // PseudoVFMAX_VFPR16_MF4 + 0U, // PseudoVFMAX_VFPR16_MF4_MASK + 0U, // PseudoVFMAX_VFPR32_M1 + 0U, // PseudoVFMAX_VFPR32_M1_MASK + 0U, // PseudoVFMAX_VFPR32_M2 + 0U, // PseudoVFMAX_VFPR32_M2_MASK + 0U, // PseudoVFMAX_VFPR32_M4 + 0U, // PseudoVFMAX_VFPR32_M4_MASK + 0U, // PseudoVFMAX_VFPR32_M8 + 0U, // PseudoVFMAX_VFPR32_M8_MASK + 0U, // PseudoVFMAX_VFPR32_MF2 + 0U, // PseudoVFMAX_VFPR32_MF2_MASK + 0U, // PseudoVFMAX_VFPR64_M1 + 0U, // PseudoVFMAX_VFPR64_M1_MASK + 0U, // PseudoVFMAX_VFPR64_M2 + 0U, // PseudoVFMAX_VFPR64_M2_MASK + 0U, // PseudoVFMAX_VFPR64_M4 + 0U, // PseudoVFMAX_VFPR64_M4_MASK + 0U, // PseudoVFMAX_VFPR64_M8 + 0U, // PseudoVFMAX_VFPR64_M8_MASK + 0U, // PseudoVFMAX_VV_M1 + 0U, // PseudoVFMAX_VV_M1_MASK + 0U, // PseudoVFMAX_VV_M2 + 0U, // PseudoVFMAX_VV_M2_MASK + 0U, // PseudoVFMAX_VV_M4 + 0U, // PseudoVFMAX_VV_M4_MASK + 0U, // PseudoVFMAX_VV_M8 + 0U, // PseudoVFMAX_VV_M8_MASK + 0U, // PseudoVFMAX_VV_MF2 + 0U, // PseudoVFMAX_VV_MF2_MASK + 0U, // PseudoVFMAX_VV_MF4 + 0U, // PseudoVFMAX_VV_MF4_MASK + 0U, // PseudoVFMERGE_VFPR16M_M1 + 0U, // PseudoVFMERGE_VFPR16M_M2 + 0U, // PseudoVFMERGE_VFPR16M_M4 + 0U, // PseudoVFMERGE_VFPR16M_M8 + 0U, // PseudoVFMERGE_VFPR16M_MF2 + 0U, // PseudoVFMERGE_VFPR16M_MF4 + 0U, // PseudoVFMERGE_VFPR32M_M1 + 0U, // PseudoVFMERGE_VFPR32M_M2 + 0U, // PseudoVFMERGE_VFPR32M_M4 + 0U, // PseudoVFMERGE_VFPR32M_M8 + 0U, // PseudoVFMERGE_VFPR32M_MF2 + 0U, // PseudoVFMERGE_VFPR64M_M1 + 0U, // PseudoVFMERGE_VFPR64M_M2 + 0U, // PseudoVFMERGE_VFPR64M_M4 + 0U, // PseudoVFMERGE_VFPR64M_M8 + 0U, // PseudoVFMIN_VFPR16_M1 + 0U, // PseudoVFMIN_VFPR16_M1_MASK + 0U, // PseudoVFMIN_VFPR16_M2 + 0U, // PseudoVFMIN_VFPR16_M2_MASK + 0U, // PseudoVFMIN_VFPR16_M4 + 0U, // PseudoVFMIN_VFPR16_M4_MASK + 0U, // PseudoVFMIN_VFPR16_M8 + 0U, // PseudoVFMIN_VFPR16_M8_MASK + 0U, // PseudoVFMIN_VFPR16_MF2 + 0U, // PseudoVFMIN_VFPR16_MF2_MASK + 0U, // PseudoVFMIN_VFPR16_MF4 + 0U, // PseudoVFMIN_VFPR16_MF4_MASK + 0U, // PseudoVFMIN_VFPR32_M1 + 0U, // PseudoVFMIN_VFPR32_M1_MASK + 0U, // PseudoVFMIN_VFPR32_M2 + 0U, // PseudoVFMIN_VFPR32_M2_MASK + 0U, // PseudoVFMIN_VFPR32_M4 + 0U, // PseudoVFMIN_VFPR32_M4_MASK + 0U, // PseudoVFMIN_VFPR32_M8 + 0U, // PseudoVFMIN_VFPR32_M8_MASK + 0U, // PseudoVFMIN_VFPR32_MF2 + 0U, // PseudoVFMIN_VFPR32_MF2_MASK + 0U, // PseudoVFMIN_VFPR64_M1 + 0U, // PseudoVFMIN_VFPR64_M1_MASK + 0U, // PseudoVFMIN_VFPR64_M2 + 0U, // PseudoVFMIN_VFPR64_M2_MASK + 0U, // PseudoVFMIN_VFPR64_M4 + 0U, // PseudoVFMIN_VFPR64_M4_MASK + 0U, // PseudoVFMIN_VFPR64_M8 + 0U, // PseudoVFMIN_VFPR64_M8_MASK + 0U, // PseudoVFMIN_VV_M1 + 0U, // PseudoVFMIN_VV_M1_MASK + 0U, // PseudoVFMIN_VV_M2 + 0U, // PseudoVFMIN_VV_M2_MASK + 0U, // PseudoVFMIN_VV_M4 + 0U, // PseudoVFMIN_VV_M4_MASK + 0U, // PseudoVFMIN_VV_M8 + 0U, // PseudoVFMIN_VV_M8_MASK + 0U, // PseudoVFMIN_VV_MF2 + 0U, // PseudoVFMIN_VV_MF2_MASK + 0U, // PseudoVFMIN_VV_MF4 + 0U, // PseudoVFMIN_VV_MF4_MASK + 0U, // PseudoVFMSAC_VFPR16_M1 + 0U, // PseudoVFMSAC_VFPR16_M1_MASK + 0U, // PseudoVFMSAC_VFPR16_M2 + 0U, // PseudoVFMSAC_VFPR16_M2_MASK + 0U, // PseudoVFMSAC_VFPR16_M4 + 0U, // PseudoVFMSAC_VFPR16_M4_MASK + 0U, // PseudoVFMSAC_VFPR16_M8 + 0U, // PseudoVFMSAC_VFPR16_M8_MASK + 0U, // PseudoVFMSAC_VFPR16_MF2 + 0U, // PseudoVFMSAC_VFPR16_MF2_MASK + 0U, // PseudoVFMSAC_VFPR16_MF4 + 0U, // PseudoVFMSAC_VFPR16_MF4_MASK + 0U, // PseudoVFMSAC_VFPR32_M1 + 0U, // PseudoVFMSAC_VFPR32_M1_MASK + 0U, // PseudoVFMSAC_VFPR32_M2 + 0U, // PseudoVFMSAC_VFPR32_M2_MASK + 0U, // PseudoVFMSAC_VFPR32_M4 + 0U, // PseudoVFMSAC_VFPR32_M4_MASK + 0U, // PseudoVFMSAC_VFPR32_M8 + 0U, // PseudoVFMSAC_VFPR32_M8_MASK + 0U, // PseudoVFMSAC_VFPR32_MF2 + 0U, // PseudoVFMSAC_VFPR32_MF2_MASK + 0U, // PseudoVFMSAC_VFPR64_M1 + 0U, // PseudoVFMSAC_VFPR64_M1_MASK + 0U, // PseudoVFMSAC_VFPR64_M2 + 0U, // PseudoVFMSAC_VFPR64_M2_MASK + 0U, // PseudoVFMSAC_VFPR64_M4 + 0U, // PseudoVFMSAC_VFPR64_M4_MASK + 0U, // PseudoVFMSAC_VFPR64_M8 + 0U, // PseudoVFMSAC_VFPR64_M8_MASK + 0U, // PseudoVFMSAC_VV_M1 + 0U, // PseudoVFMSAC_VV_M1_MASK + 0U, // PseudoVFMSAC_VV_M2 + 0U, // PseudoVFMSAC_VV_M2_MASK + 0U, // PseudoVFMSAC_VV_M4 + 0U, // PseudoVFMSAC_VV_M4_MASK + 0U, // PseudoVFMSAC_VV_M8 + 0U, // PseudoVFMSAC_VV_M8_MASK + 0U, // PseudoVFMSAC_VV_MF2 + 0U, // PseudoVFMSAC_VV_MF2_MASK + 0U, // PseudoVFMSAC_VV_MF4 + 0U, // PseudoVFMSAC_VV_MF4_MASK + 0U, // PseudoVFMSUB_VFPR16_M1 + 0U, // PseudoVFMSUB_VFPR16_M1_MASK + 0U, // PseudoVFMSUB_VFPR16_M2 + 0U, // PseudoVFMSUB_VFPR16_M2_MASK + 0U, // PseudoVFMSUB_VFPR16_M4 + 0U, // PseudoVFMSUB_VFPR16_M4_MASK + 0U, // PseudoVFMSUB_VFPR16_M8 + 0U, // PseudoVFMSUB_VFPR16_M8_MASK + 0U, // PseudoVFMSUB_VFPR16_MF2 + 0U, // PseudoVFMSUB_VFPR16_MF2_MASK + 0U, // PseudoVFMSUB_VFPR16_MF4 + 0U, // PseudoVFMSUB_VFPR16_MF4_MASK + 0U, // PseudoVFMSUB_VFPR32_M1 + 0U, // PseudoVFMSUB_VFPR32_M1_MASK + 0U, // PseudoVFMSUB_VFPR32_M2 + 0U, // PseudoVFMSUB_VFPR32_M2_MASK + 0U, // PseudoVFMSUB_VFPR32_M4 + 0U, // PseudoVFMSUB_VFPR32_M4_MASK + 0U, // PseudoVFMSUB_VFPR32_M8 + 0U, // PseudoVFMSUB_VFPR32_M8_MASK + 0U, // PseudoVFMSUB_VFPR32_MF2 + 0U, // PseudoVFMSUB_VFPR32_MF2_MASK + 0U, // PseudoVFMSUB_VFPR64_M1 + 0U, // PseudoVFMSUB_VFPR64_M1_MASK + 0U, // PseudoVFMSUB_VFPR64_M2 + 0U, // PseudoVFMSUB_VFPR64_M2_MASK + 0U, // PseudoVFMSUB_VFPR64_M4 + 0U, // PseudoVFMSUB_VFPR64_M4_MASK + 0U, // PseudoVFMSUB_VFPR64_M8 + 0U, // PseudoVFMSUB_VFPR64_M8_MASK + 0U, // PseudoVFMSUB_VV_M1 + 0U, // PseudoVFMSUB_VV_M1_MASK + 0U, // PseudoVFMSUB_VV_M2 + 0U, // PseudoVFMSUB_VV_M2_MASK + 0U, // PseudoVFMSUB_VV_M4 + 0U, // PseudoVFMSUB_VV_M4_MASK + 0U, // PseudoVFMSUB_VV_M8 + 0U, // PseudoVFMSUB_VV_M8_MASK + 0U, // PseudoVFMSUB_VV_MF2 + 0U, // PseudoVFMSUB_VV_MF2_MASK + 0U, // PseudoVFMSUB_VV_MF4 + 0U, // PseudoVFMSUB_VV_MF4_MASK + 0U, // PseudoVFMUL_VFPR16_M1 + 0U, // PseudoVFMUL_VFPR16_M1_MASK + 0U, // PseudoVFMUL_VFPR16_M2 + 0U, // PseudoVFMUL_VFPR16_M2_MASK + 0U, // PseudoVFMUL_VFPR16_M4 + 0U, // PseudoVFMUL_VFPR16_M4_MASK + 0U, // PseudoVFMUL_VFPR16_M8 + 0U, // PseudoVFMUL_VFPR16_M8_MASK + 0U, // PseudoVFMUL_VFPR16_MF2 + 0U, // PseudoVFMUL_VFPR16_MF2_MASK + 0U, // PseudoVFMUL_VFPR16_MF4 + 0U, // PseudoVFMUL_VFPR16_MF4_MASK + 0U, // PseudoVFMUL_VFPR32_M1 + 0U, // PseudoVFMUL_VFPR32_M1_MASK + 0U, // PseudoVFMUL_VFPR32_M2 + 0U, // PseudoVFMUL_VFPR32_M2_MASK + 0U, // PseudoVFMUL_VFPR32_M4 + 0U, // PseudoVFMUL_VFPR32_M4_MASK + 0U, // PseudoVFMUL_VFPR32_M8 + 0U, // PseudoVFMUL_VFPR32_M8_MASK + 0U, // PseudoVFMUL_VFPR32_MF2 + 0U, // PseudoVFMUL_VFPR32_MF2_MASK + 0U, // PseudoVFMUL_VFPR64_M1 + 0U, // PseudoVFMUL_VFPR64_M1_MASK + 0U, // PseudoVFMUL_VFPR64_M2 + 0U, // PseudoVFMUL_VFPR64_M2_MASK + 0U, // PseudoVFMUL_VFPR64_M4 + 0U, // PseudoVFMUL_VFPR64_M4_MASK + 0U, // PseudoVFMUL_VFPR64_M8 + 0U, // PseudoVFMUL_VFPR64_M8_MASK + 0U, // PseudoVFMUL_VV_M1 + 0U, // PseudoVFMUL_VV_M1_MASK + 0U, // PseudoVFMUL_VV_M2 + 0U, // PseudoVFMUL_VV_M2_MASK + 0U, // PseudoVFMUL_VV_M4 + 0U, // PseudoVFMUL_VV_M4_MASK + 0U, // PseudoVFMUL_VV_M8 + 0U, // PseudoVFMUL_VV_M8_MASK + 0U, // PseudoVFMUL_VV_MF2 + 0U, // PseudoVFMUL_VV_MF2_MASK + 0U, // PseudoVFMUL_VV_MF4 + 0U, // PseudoVFMUL_VV_MF4_MASK + 0U, // PseudoVFMV_FPR16_S_M1 + 0U, // PseudoVFMV_FPR16_S_M2 + 0U, // PseudoVFMV_FPR16_S_M4 + 0U, // PseudoVFMV_FPR16_S_M8 + 0U, // PseudoVFMV_FPR16_S_MF2 + 0U, // PseudoVFMV_FPR16_S_MF4 + 0U, // PseudoVFMV_FPR32_S_M1 + 0U, // PseudoVFMV_FPR32_S_M2 + 0U, // PseudoVFMV_FPR32_S_M4 + 0U, // PseudoVFMV_FPR32_S_M8 + 0U, // PseudoVFMV_FPR32_S_MF2 + 0U, // PseudoVFMV_FPR64_S_M1 + 0U, // PseudoVFMV_FPR64_S_M2 + 0U, // PseudoVFMV_FPR64_S_M4 + 0U, // PseudoVFMV_FPR64_S_M8 + 0U, // PseudoVFMV_S_FPR16_M1 + 0U, // PseudoVFMV_S_FPR16_M2 + 0U, // PseudoVFMV_S_FPR16_M4 + 0U, // PseudoVFMV_S_FPR16_M8 + 0U, // PseudoVFMV_S_FPR16_MF2 + 0U, // PseudoVFMV_S_FPR16_MF4 + 0U, // PseudoVFMV_S_FPR32_M1 + 0U, // PseudoVFMV_S_FPR32_M2 + 0U, // PseudoVFMV_S_FPR32_M4 + 0U, // PseudoVFMV_S_FPR32_M8 + 0U, // PseudoVFMV_S_FPR32_MF2 + 0U, // PseudoVFMV_S_FPR64_M1 + 0U, // PseudoVFMV_S_FPR64_M2 + 0U, // PseudoVFMV_S_FPR64_M4 + 0U, // PseudoVFMV_S_FPR64_M8 + 0U, // PseudoVFMV_V_FPR16_M1 + 0U, // PseudoVFMV_V_FPR16_M2 + 0U, // PseudoVFMV_V_FPR16_M4 + 0U, // PseudoVFMV_V_FPR16_M8 + 0U, // PseudoVFMV_V_FPR16_MF2 + 0U, // PseudoVFMV_V_FPR16_MF4 + 0U, // PseudoVFMV_V_FPR32_M1 + 0U, // PseudoVFMV_V_FPR32_M2 + 0U, // PseudoVFMV_V_FPR32_M4 + 0U, // PseudoVFMV_V_FPR32_M8 + 0U, // PseudoVFMV_V_FPR32_MF2 + 0U, // PseudoVFMV_V_FPR64_M1 + 0U, // PseudoVFMV_V_FPR64_M2 + 0U, // PseudoVFMV_V_FPR64_M4 + 0U, // PseudoVFMV_V_FPR64_M8 + 0U, // PseudoVFNCVTBF16_F_F_W_M1 + 0U, // PseudoVFNCVTBF16_F_F_W_M1_MASK + 0U, // PseudoVFNCVTBF16_F_F_W_M2 + 0U, // PseudoVFNCVTBF16_F_F_W_M2_MASK + 0U, // PseudoVFNCVTBF16_F_F_W_M4 + 0U, // PseudoVFNCVTBF16_F_F_W_M4_MASK + 0U, // PseudoVFNCVTBF16_F_F_W_MF2 + 0U, // PseudoVFNCVTBF16_F_F_W_MF2_MASK + 0U, // PseudoVFNCVTBF16_F_F_W_MF4 + 0U, // PseudoVFNCVTBF16_F_F_W_MF4_MASK + 0U, // PseudoVFNCVT_F_F_W_M1 + 0U, // PseudoVFNCVT_F_F_W_M1_MASK + 0U, // PseudoVFNCVT_F_F_W_M2 + 0U, // PseudoVFNCVT_F_F_W_M2_MASK + 0U, // PseudoVFNCVT_F_F_W_M4 + 0U, // PseudoVFNCVT_F_F_W_M4_MASK + 0U, // PseudoVFNCVT_F_F_W_MF2 + 0U, // PseudoVFNCVT_F_F_W_MF2_MASK + 0U, // PseudoVFNCVT_F_F_W_MF4 + 0U, // PseudoVFNCVT_F_F_W_MF4_MASK + 0U, // PseudoVFNCVT_F_XU_W_M1 + 0U, // PseudoVFNCVT_F_XU_W_M1_MASK + 0U, // PseudoVFNCVT_F_XU_W_M2 + 0U, // PseudoVFNCVT_F_XU_W_M2_MASK + 0U, // PseudoVFNCVT_F_XU_W_M4 + 0U, // PseudoVFNCVT_F_XU_W_M4_MASK + 0U, // PseudoVFNCVT_F_XU_W_MF2 + 0U, // PseudoVFNCVT_F_XU_W_MF2_MASK + 0U, // PseudoVFNCVT_F_XU_W_MF4 + 0U, // PseudoVFNCVT_F_XU_W_MF4_MASK + 0U, // PseudoVFNCVT_F_X_W_M1 + 0U, // PseudoVFNCVT_F_X_W_M1_MASK + 0U, // PseudoVFNCVT_F_X_W_M2 + 0U, // PseudoVFNCVT_F_X_W_M2_MASK + 0U, // PseudoVFNCVT_F_X_W_M4 + 0U, // PseudoVFNCVT_F_X_W_M4_MASK + 0U, // PseudoVFNCVT_F_X_W_MF2 + 0U, // PseudoVFNCVT_F_X_W_MF2_MASK + 0U, // PseudoVFNCVT_F_X_W_MF4 + 0U, // PseudoVFNCVT_F_X_W_MF4_MASK + 0U, // PseudoVFNCVT_RM_F_XU_W_M1 + 0U, // PseudoVFNCVT_RM_F_XU_W_M1_MASK + 0U, // PseudoVFNCVT_RM_F_XU_W_M2 + 0U, // PseudoVFNCVT_RM_F_XU_W_M2_MASK + 0U, // PseudoVFNCVT_RM_F_XU_W_M4 + 0U, // PseudoVFNCVT_RM_F_XU_W_M4_MASK + 0U, // PseudoVFNCVT_RM_F_XU_W_MF2 + 0U, // PseudoVFNCVT_RM_F_XU_W_MF2_MASK + 0U, // PseudoVFNCVT_RM_F_XU_W_MF4 + 0U, // PseudoVFNCVT_RM_F_XU_W_MF4_MASK + 0U, // PseudoVFNCVT_RM_F_X_W_M1 + 0U, // PseudoVFNCVT_RM_F_X_W_M1_MASK + 0U, // PseudoVFNCVT_RM_F_X_W_M2 + 0U, // PseudoVFNCVT_RM_F_X_W_M2_MASK + 0U, // PseudoVFNCVT_RM_F_X_W_M4 + 0U, // PseudoVFNCVT_RM_F_X_W_M4_MASK + 0U, // PseudoVFNCVT_RM_F_X_W_MF2 + 0U, // PseudoVFNCVT_RM_F_X_W_MF2_MASK + 0U, // PseudoVFNCVT_RM_F_X_W_MF4 + 0U, // PseudoVFNCVT_RM_F_X_W_MF4_MASK + 0U, // PseudoVFNCVT_RM_XU_F_W_M1 + 0U, // PseudoVFNCVT_RM_XU_F_W_M1_MASK + 0U, // PseudoVFNCVT_RM_XU_F_W_M2 + 0U, // PseudoVFNCVT_RM_XU_F_W_M2_MASK + 0U, // PseudoVFNCVT_RM_XU_F_W_M4 + 0U, // PseudoVFNCVT_RM_XU_F_W_M4_MASK + 0U, // PseudoVFNCVT_RM_XU_F_W_MF2 + 0U, // PseudoVFNCVT_RM_XU_F_W_MF2_MASK + 0U, // PseudoVFNCVT_RM_XU_F_W_MF4 + 0U, // PseudoVFNCVT_RM_XU_F_W_MF4_MASK + 0U, // PseudoVFNCVT_RM_XU_F_W_MF8 + 0U, // PseudoVFNCVT_RM_XU_F_W_MF8_MASK + 0U, // PseudoVFNCVT_RM_X_F_W_M1 + 0U, // PseudoVFNCVT_RM_X_F_W_M1_MASK + 0U, // PseudoVFNCVT_RM_X_F_W_M2 + 0U, // PseudoVFNCVT_RM_X_F_W_M2_MASK + 0U, // PseudoVFNCVT_RM_X_F_W_M4 + 0U, // PseudoVFNCVT_RM_X_F_W_M4_MASK + 0U, // PseudoVFNCVT_RM_X_F_W_MF2 + 0U, // PseudoVFNCVT_RM_X_F_W_MF2_MASK + 0U, // PseudoVFNCVT_RM_X_F_W_MF4 + 0U, // PseudoVFNCVT_RM_X_F_W_MF4_MASK + 0U, // PseudoVFNCVT_RM_X_F_W_MF8 + 0U, // PseudoVFNCVT_RM_X_F_W_MF8_MASK + 0U, // PseudoVFNCVT_ROD_F_F_W_M1 + 0U, // PseudoVFNCVT_ROD_F_F_W_M1_MASK + 0U, // PseudoVFNCVT_ROD_F_F_W_M2 + 0U, // PseudoVFNCVT_ROD_F_F_W_M2_MASK + 0U, // PseudoVFNCVT_ROD_F_F_W_M4 + 0U, // PseudoVFNCVT_ROD_F_F_W_M4_MASK + 0U, // PseudoVFNCVT_ROD_F_F_W_MF2 + 0U, // PseudoVFNCVT_ROD_F_F_W_MF2_MASK + 0U, // PseudoVFNCVT_ROD_F_F_W_MF4 + 0U, // PseudoVFNCVT_ROD_F_F_W_MF4_MASK + 0U, // PseudoVFNCVT_RTZ_XU_F_W_M1 + 0U, // PseudoVFNCVT_RTZ_XU_F_W_M1_MASK + 0U, // PseudoVFNCVT_RTZ_XU_F_W_M2 + 0U, // PseudoVFNCVT_RTZ_XU_F_W_M2_MASK + 0U, // PseudoVFNCVT_RTZ_XU_F_W_M4 + 0U, // PseudoVFNCVT_RTZ_XU_F_W_M4_MASK + 0U, // PseudoVFNCVT_RTZ_XU_F_W_MF2 + 0U, // PseudoVFNCVT_RTZ_XU_F_W_MF2_MASK + 0U, // PseudoVFNCVT_RTZ_XU_F_W_MF4 + 0U, // PseudoVFNCVT_RTZ_XU_F_W_MF4_MASK + 0U, // PseudoVFNCVT_RTZ_XU_F_W_MF8 + 0U, // PseudoVFNCVT_RTZ_XU_F_W_MF8_MASK + 0U, // PseudoVFNCVT_RTZ_X_F_W_M1 + 0U, // PseudoVFNCVT_RTZ_X_F_W_M1_MASK + 0U, // PseudoVFNCVT_RTZ_X_F_W_M2 + 0U, // PseudoVFNCVT_RTZ_X_F_W_M2_MASK + 0U, // PseudoVFNCVT_RTZ_X_F_W_M4 + 0U, // PseudoVFNCVT_RTZ_X_F_W_M4_MASK + 0U, // PseudoVFNCVT_RTZ_X_F_W_MF2 + 0U, // PseudoVFNCVT_RTZ_X_F_W_MF2_MASK + 0U, // PseudoVFNCVT_RTZ_X_F_W_MF4 + 0U, // PseudoVFNCVT_RTZ_X_F_W_MF4_MASK + 0U, // PseudoVFNCVT_RTZ_X_F_W_MF8 + 0U, // PseudoVFNCVT_RTZ_X_F_W_MF8_MASK + 0U, // PseudoVFNCVT_XU_F_W_M1 + 0U, // PseudoVFNCVT_XU_F_W_M1_MASK + 0U, // PseudoVFNCVT_XU_F_W_M2 + 0U, // PseudoVFNCVT_XU_F_W_M2_MASK + 0U, // PseudoVFNCVT_XU_F_W_M4 + 0U, // PseudoVFNCVT_XU_F_W_M4_MASK + 0U, // PseudoVFNCVT_XU_F_W_MF2 + 0U, // PseudoVFNCVT_XU_F_W_MF2_MASK + 0U, // PseudoVFNCVT_XU_F_W_MF4 + 0U, // PseudoVFNCVT_XU_F_W_MF4_MASK + 0U, // PseudoVFNCVT_XU_F_W_MF8 + 0U, // PseudoVFNCVT_XU_F_W_MF8_MASK + 0U, // PseudoVFNCVT_X_F_W_M1 + 0U, // PseudoVFNCVT_X_F_W_M1_MASK + 0U, // PseudoVFNCVT_X_F_W_M2 + 0U, // PseudoVFNCVT_X_F_W_M2_MASK + 0U, // PseudoVFNCVT_X_F_W_M4 + 0U, // PseudoVFNCVT_X_F_W_M4_MASK + 0U, // PseudoVFNCVT_X_F_W_MF2 + 0U, // PseudoVFNCVT_X_F_W_MF2_MASK + 0U, // PseudoVFNCVT_X_F_W_MF4 + 0U, // PseudoVFNCVT_X_F_W_MF4_MASK + 0U, // PseudoVFNCVT_X_F_W_MF8 + 0U, // PseudoVFNCVT_X_F_W_MF8_MASK + 0U, // PseudoVFNMACC_VFPR16_M1 + 0U, // PseudoVFNMACC_VFPR16_M1_MASK + 0U, // PseudoVFNMACC_VFPR16_M2 + 0U, // PseudoVFNMACC_VFPR16_M2_MASK + 0U, // PseudoVFNMACC_VFPR16_M4 + 0U, // PseudoVFNMACC_VFPR16_M4_MASK + 0U, // PseudoVFNMACC_VFPR16_M8 + 0U, // PseudoVFNMACC_VFPR16_M8_MASK + 0U, // PseudoVFNMACC_VFPR16_MF2 + 0U, // PseudoVFNMACC_VFPR16_MF2_MASK + 0U, // PseudoVFNMACC_VFPR16_MF4 + 0U, // PseudoVFNMACC_VFPR16_MF4_MASK + 0U, // PseudoVFNMACC_VFPR32_M1 + 0U, // PseudoVFNMACC_VFPR32_M1_MASK + 0U, // PseudoVFNMACC_VFPR32_M2 + 0U, // PseudoVFNMACC_VFPR32_M2_MASK + 0U, // PseudoVFNMACC_VFPR32_M4 + 0U, // PseudoVFNMACC_VFPR32_M4_MASK + 0U, // PseudoVFNMACC_VFPR32_M8 + 0U, // PseudoVFNMACC_VFPR32_M8_MASK + 0U, // PseudoVFNMACC_VFPR32_MF2 + 0U, // PseudoVFNMACC_VFPR32_MF2_MASK + 0U, // PseudoVFNMACC_VFPR64_M1 + 0U, // PseudoVFNMACC_VFPR64_M1_MASK + 0U, // PseudoVFNMACC_VFPR64_M2 + 0U, // PseudoVFNMACC_VFPR64_M2_MASK + 0U, // PseudoVFNMACC_VFPR64_M4 + 0U, // PseudoVFNMACC_VFPR64_M4_MASK + 0U, // PseudoVFNMACC_VFPR64_M8 + 0U, // PseudoVFNMACC_VFPR64_M8_MASK + 0U, // PseudoVFNMACC_VV_M1 + 0U, // PseudoVFNMACC_VV_M1_MASK + 0U, // PseudoVFNMACC_VV_M2 + 0U, // PseudoVFNMACC_VV_M2_MASK + 0U, // PseudoVFNMACC_VV_M4 + 0U, // PseudoVFNMACC_VV_M4_MASK + 0U, // PseudoVFNMACC_VV_M8 + 0U, // PseudoVFNMACC_VV_M8_MASK + 0U, // PseudoVFNMACC_VV_MF2 + 0U, // PseudoVFNMACC_VV_MF2_MASK + 0U, // PseudoVFNMACC_VV_MF4 + 0U, // PseudoVFNMACC_VV_MF4_MASK + 0U, // PseudoVFNMADD_VFPR16_M1 + 0U, // PseudoVFNMADD_VFPR16_M1_MASK + 0U, // PseudoVFNMADD_VFPR16_M2 + 0U, // PseudoVFNMADD_VFPR16_M2_MASK + 0U, // PseudoVFNMADD_VFPR16_M4 + 0U, // PseudoVFNMADD_VFPR16_M4_MASK + 0U, // PseudoVFNMADD_VFPR16_M8 + 0U, // PseudoVFNMADD_VFPR16_M8_MASK + 0U, // PseudoVFNMADD_VFPR16_MF2 + 0U, // PseudoVFNMADD_VFPR16_MF2_MASK + 0U, // PseudoVFNMADD_VFPR16_MF4 + 0U, // PseudoVFNMADD_VFPR16_MF4_MASK + 0U, // PseudoVFNMADD_VFPR32_M1 + 0U, // PseudoVFNMADD_VFPR32_M1_MASK + 0U, // PseudoVFNMADD_VFPR32_M2 + 0U, // PseudoVFNMADD_VFPR32_M2_MASK + 0U, // PseudoVFNMADD_VFPR32_M4 + 0U, // PseudoVFNMADD_VFPR32_M4_MASK + 0U, // PseudoVFNMADD_VFPR32_M8 + 0U, // PseudoVFNMADD_VFPR32_M8_MASK + 0U, // PseudoVFNMADD_VFPR32_MF2 + 0U, // PseudoVFNMADD_VFPR32_MF2_MASK + 0U, // PseudoVFNMADD_VFPR64_M1 + 0U, // PseudoVFNMADD_VFPR64_M1_MASK + 0U, // PseudoVFNMADD_VFPR64_M2 + 0U, // PseudoVFNMADD_VFPR64_M2_MASK + 0U, // PseudoVFNMADD_VFPR64_M4 + 0U, // PseudoVFNMADD_VFPR64_M4_MASK + 0U, // PseudoVFNMADD_VFPR64_M8 + 0U, // PseudoVFNMADD_VFPR64_M8_MASK + 0U, // PseudoVFNMADD_VV_M1 + 0U, // PseudoVFNMADD_VV_M1_MASK + 0U, // PseudoVFNMADD_VV_M2 + 0U, // PseudoVFNMADD_VV_M2_MASK + 0U, // PseudoVFNMADD_VV_M4 + 0U, // PseudoVFNMADD_VV_M4_MASK + 0U, // PseudoVFNMADD_VV_M8 + 0U, // PseudoVFNMADD_VV_M8_MASK + 0U, // PseudoVFNMADD_VV_MF2 + 0U, // PseudoVFNMADD_VV_MF2_MASK + 0U, // PseudoVFNMADD_VV_MF4 + 0U, // PseudoVFNMADD_VV_MF4_MASK + 0U, // PseudoVFNMSAC_VFPR16_M1 + 0U, // PseudoVFNMSAC_VFPR16_M1_MASK + 0U, // PseudoVFNMSAC_VFPR16_M2 + 0U, // PseudoVFNMSAC_VFPR16_M2_MASK + 0U, // PseudoVFNMSAC_VFPR16_M4 + 0U, // PseudoVFNMSAC_VFPR16_M4_MASK + 0U, // PseudoVFNMSAC_VFPR16_M8 + 0U, // PseudoVFNMSAC_VFPR16_M8_MASK + 0U, // PseudoVFNMSAC_VFPR16_MF2 + 0U, // PseudoVFNMSAC_VFPR16_MF2_MASK + 0U, // PseudoVFNMSAC_VFPR16_MF4 + 0U, // PseudoVFNMSAC_VFPR16_MF4_MASK + 0U, // PseudoVFNMSAC_VFPR32_M1 + 0U, // PseudoVFNMSAC_VFPR32_M1_MASK + 0U, // PseudoVFNMSAC_VFPR32_M2 + 0U, // PseudoVFNMSAC_VFPR32_M2_MASK + 0U, // PseudoVFNMSAC_VFPR32_M4 + 0U, // PseudoVFNMSAC_VFPR32_M4_MASK + 0U, // PseudoVFNMSAC_VFPR32_M8 + 0U, // PseudoVFNMSAC_VFPR32_M8_MASK + 0U, // PseudoVFNMSAC_VFPR32_MF2 + 0U, // PseudoVFNMSAC_VFPR32_MF2_MASK + 0U, // PseudoVFNMSAC_VFPR64_M1 + 0U, // PseudoVFNMSAC_VFPR64_M1_MASK + 0U, // PseudoVFNMSAC_VFPR64_M2 + 0U, // PseudoVFNMSAC_VFPR64_M2_MASK + 0U, // PseudoVFNMSAC_VFPR64_M4 + 0U, // PseudoVFNMSAC_VFPR64_M4_MASK + 0U, // PseudoVFNMSAC_VFPR64_M8 + 0U, // PseudoVFNMSAC_VFPR64_M8_MASK + 0U, // PseudoVFNMSAC_VV_M1 + 0U, // PseudoVFNMSAC_VV_M1_MASK + 0U, // PseudoVFNMSAC_VV_M2 + 0U, // PseudoVFNMSAC_VV_M2_MASK + 0U, // PseudoVFNMSAC_VV_M4 + 0U, // PseudoVFNMSAC_VV_M4_MASK + 0U, // PseudoVFNMSAC_VV_M8 + 0U, // PseudoVFNMSAC_VV_M8_MASK + 0U, // PseudoVFNMSAC_VV_MF2 + 0U, // PseudoVFNMSAC_VV_MF2_MASK + 0U, // PseudoVFNMSAC_VV_MF4 + 0U, // PseudoVFNMSAC_VV_MF4_MASK + 0U, // PseudoVFNMSUB_VFPR16_M1 + 0U, // PseudoVFNMSUB_VFPR16_M1_MASK + 0U, // PseudoVFNMSUB_VFPR16_M2 + 0U, // PseudoVFNMSUB_VFPR16_M2_MASK + 0U, // PseudoVFNMSUB_VFPR16_M4 + 0U, // PseudoVFNMSUB_VFPR16_M4_MASK + 0U, // PseudoVFNMSUB_VFPR16_M8 + 0U, // PseudoVFNMSUB_VFPR16_M8_MASK + 0U, // PseudoVFNMSUB_VFPR16_MF2 + 0U, // PseudoVFNMSUB_VFPR16_MF2_MASK + 0U, // PseudoVFNMSUB_VFPR16_MF4 + 0U, // PseudoVFNMSUB_VFPR16_MF4_MASK + 0U, // PseudoVFNMSUB_VFPR32_M1 + 0U, // PseudoVFNMSUB_VFPR32_M1_MASK + 0U, // PseudoVFNMSUB_VFPR32_M2 + 0U, // PseudoVFNMSUB_VFPR32_M2_MASK + 0U, // PseudoVFNMSUB_VFPR32_M4 + 0U, // PseudoVFNMSUB_VFPR32_M4_MASK + 0U, // PseudoVFNMSUB_VFPR32_M8 + 0U, // PseudoVFNMSUB_VFPR32_M8_MASK + 0U, // PseudoVFNMSUB_VFPR32_MF2 + 0U, // PseudoVFNMSUB_VFPR32_MF2_MASK + 0U, // PseudoVFNMSUB_VFPR64_M1 + 0U, // PseudoVFNMSUB_VFPR64_M1_MASK + 0U, // PseudoVFNMSUB_VFPR64_M2 + 0U, // PseudoVFNMSUB_VFPR64_M2_MASK + 0U, // PseudoVFNMSUB_VFPR64_M4 + 0U, // PseudoVFNMSUB_VFPR64_M4_MASK + 0U, // PseudoVFNMSUB_VFPR64_M8 + 0U, // PseudoVFNMSUB_VFPR64_M8_MASK + 0U, // PseudoVFNMSUB_VV_M1 + 0U, // PseudoVFNMSUB_VV_M1_MASK + 0U, // PseudoVFNMSUB_VV_M2 + 0U, // PseudoVFNMSUB_VV_M2_MASK + 0U, // PseudoVFNMSUB_VV_M4 + 0U, // PseudoVFNMSUB_VV_M4_MASK + 0U, // PseudoVFNMSUB_VV_M8 + 0U, // PseudoVFNMSUB_VV_M8_MASK + 0U, // PseudoVFNMSUB_VV_MF2 + 0U, // PseudoVFNMSUB_VV_MF2_MASK + 0U, // PseudoVFNMSUB_VV_MF4 + 0U, // PseudoVFNMSUB_VV_MF4_MASK + 0U, // PseudoVFNRCLIP_XU_F_QF_M1 + 0U, // PseudoVFNRCLIP_XU_F_QF_M1_MASK + 0U, // PseudoVFNRCLIP_XU_F_QF_M2 + 0U, // PseudoVFNRCLIP_XU_F_QF_M2_MASK + 0U, // PseudoVFNRCLIP_XU_F_QF_MF2 + 0U, // PseudoVFNRCLIP_XU_F_QF_MF2_MASK + 0U, // PseudoVFNRCLIP_XU_F_QF_MF4 + 0U, // PseudoVFNRCLIP_XU_F_QF_MF4_MASK + 0U, // PseudoVFNRCLIP_XU_F_QF_MF8 + 0U, // PseudoVFNRCLIP_XU_F_QF_MF8_MASK + 0U, // PseudoVFNRCLIP_X_F_QF_M1 + 0U, // PseudoVFNRCLIP_X_F_QF_M1_MASK + 0U, // PseudoVFNRCLIP_X_F_QF_M2 + 0U, // PseudoVFNRCLIP_X_F_QF_M2_MASK + 0U, // PseudoVFNRCLIP_X_F_QF_MF2 + 0U, // PseudoVFNRCLIP_X_F_QF_MF2_MASK + 0U, // PseudoVFNRCLIP_X_F_QF_MF4 + 0U, // PseudoVFNRCLIP_X_F_QF_MF4_MASK + 0U, // PseudoVFNRCLIP_X_F_QF_MF8 + 0U, // PseudoVFNRCLIP_X_F_QF_MF8_MASK + 0U, // PseudoVFRDIV_VFPR16_M1_E16 + 0U, // PseudoVFRDIV_VFPR16_M1_E16_MASK + 0U, // PseudoVFRDIV_VFPR16_M2_E16 + 0U, // PseudoVFRDIV_VFPR16_M2_E16_MASK + 0U, // PseudoVFRDIV_VFPR16_M4_E16 + 0U, // PseudoVFRDIV_VFPR16_M4_E16_MASK + 0U, // PseudoVFRDIV_VFPR16_M8_E16 + 0U, // PseudoVFRDIV_VFPR16_M8_E16_MASK + 0U, // PseudoVFRDIV_VFPR16_MF2_E16 + 0U, // PseudoVFRDIV_VFPR16_MF2_E16_MASK + 0U, // PseudoVFRDIV_VFPR16_MF4_E16 + 0U, // PseudoVFRDIV_VFPR16_MF4_E16_MASK + 0U, // PseudoVFRDIV_VFPR32_M1_E32 + 0U, // PseudoVFRDIV_VFPR32_M1_E32_MASK + 0U, // PseudoVFRDIV_VFPR32_M2_E32 + 0U, // PseudoVFRDIV_VFPR32_M2_E32_MASK + 0U, // PseudoVFRDIV_VFPR32_M4_E32 + 0U, // PseudoVFRDIV_VFPR32_M4_E32_MASK + 0U, // PseudoVFRDIV_VFPR32_M8_E32 + 0U, // PseudoVFRDIV_VFPR32_M8_E32_MASK + 0U, // PseudoVFRDIV_VFPR32_MF2_E32 + 0U, // PseudoVFRDIV_VFPR32_MF2_E32_MASK + 0U, // PseudoVFRDIV_VFPR64_M1_E64 + 0U, // PseudoVFRDIV_VFPR64_M1_E64_MASK + 0U, // PseudoVFRDIV_VFPR64_M2_E64 + 0U, // PseudoVFRDIV_VFPR64_M2_E64_MASK + 0U, // PseudoVFRDIV_VFPR64_M4_E64 + 0U, // PseudoVFRDIV_VFPR64_M4_E64_MASK + 0U, // PseudoVFRDIV_VFPR64_M8_E64 + 0U, // PseudoVFRDIV_VFPR64_M8_E64_MASK + 0U, // PseudoVFREC7_V_M1 + 0U, // PseudoVFREC7_V_M1_MASK + 0U, // PseudoVFREC7_V_M2 + 0U, // PseudoVFREC7_V_M2_MASK + 0U, // PseudoVFREC7_V_M4 + 0U, // PseudoVFREC7_V_M4_MASK + 0U, // PseudoVFREC7_V_M8 + 0U, // PseudoVFREC7_V_M8_MASK + 0U, // PseudoVFREC7_V_MF2 + 0U, // PseudoVFREC7_V_MF2_MASK + 0U, // PseudoVFREC7_V_MF4 + 0U, // PseudoVFREC7_V_MF4_MASK + 0U, // PseudoVFREDMAX_VS_M1_E16 + 0U, // PseudoVFREDMAX_VS_M1_E16_MASK + 0U, // PseudoVFREDMAX_VS_M1_E32 + 0U, // PseudoVFREDMAX_VS_M1_E32_MASK + 0U, // PseudoVFREDMAX_VS_M1_E64 + 0U, // PseudoVFREDMAX_VS_M1_E64_MASK + 0U, // PseudoVFREDMAX_VS_M2_E16 + 0U, // PseudoVFREDMAX_VS_M2_E16_MASK + 0U, // PseudoVFREDMAX_VS_M2_E32 + 0U, // PseudoVFREDMAX_VS_M2_E32_MASK + 0U, // PseudoVFREDMAX_VS_M2_E64 + 0U, // PseudoVFREDMAX_VS_M2_E64_MASK + 0U, // PseudoVFREDMAX_VS_M4_E16 + 0U, // PseudoVFREDMAX_VS_M4_E16_MASK + 0U, // PseudoVFREDMAX_VS_M4_E32 + 0U, // PseudoVFREDMAX_VS_M4_E32_MASK + 0U, // PseudoVFREDMAX_VS_M4_E64 + 0U, // PseudoVFREDMAX_VS_M4_E64_MASK + 0U, // PseudoVFREDMAX_VS_M8_E16 + 0U, // PseudoVFREDMAX_VS_M8_E16_MASK + 0U, // PseudoVFREDMAX_VS_M8_E32 + 0U, // PseudoVFREDMAX_VS_M8_E32_MASK + 0U, // PseudoVFREDMAX_VS_M8_E64 + 0U, // PseudoVFREDMAX_VS_M8_E64_MASK + 0U, // PseudoVFREDMAX_VS_MF2_E16 + 0U, // PseudoVFREDMAX_VS_MF2_E16_MASK + 0U, // PseudoVFREDMAX_VS_MF2_E32 + 0U, // PseudoVFREDMAX_VS_MF2_E32_MASK + 0U, // PseudoVFREDMAX_VS_MF4_E16 + 0U, // PseudoVFREDMAX_VS_MF4_E16_MASK + 0U, // PseudoVFREDMIN_VS_M1_E16 + 0U, // PseudoVFREDMIN_VS_M1_E16_MASK + 0U, // PseudoVFREDMIN_VS_M1_E32 + 0U, // PseudoVFREDMIN_VS_M1_E32_MASK + 0U, // PseudoVFREDMIN_VS_M1_E64 + 0U, // PseudoVFREDMIN_VS_M1_E64_MASK + 0U, // PseudoVFREDMIN_VS_M2_E16 + 0U, // PseudoVFREDMIN_VS_M2_E16_MASK + 0U, // PseudoVFREDMIN_VS_M2_E32 + 0U, // PseudoVFREDMIN_VS_M2_E32_MASK + 0U, // PseudoVFREDMIN_VS_M2_E64 + 0U, // PseudoVFREDMIN_VS_M2_E64_MASK + 0U, // PseudoVFREDMIN_VS_M4_E16 + 0U, // PseudoVFREDMIN_VS_M4_E16_MASK + 0U, // PseudoVFREDMIN_VS_M4_E32 + 0U, // PseudoVFREDMIN_VS_M4_E32_MASK + 0U, // PseudoVFREDMIN_VS_M4_E64 + 0U, // PseudoVFREDMIN_VS_M4_E64_MASK + 0U, // PseudoVFREDMIN_VS_M8_E16 + 0U, // PseudoVFREDMIN_VS_M8_E16_MASK + 0U, // PseudoVFREDMIN_VS_M8_E32 + 0U, // PseudoVFREDMIN_VS_M8_E32_MASK + 0U, // PseudoVFREDMIN_VS_M8_E64 + 0U, // PseudoVFREDMIN_VS_M8_E64_MASK + 0U, // PseudoVFREDMIN_VS_MF2_E16 + 0U, // PseudoVFREDMIN_VS_MF2_E16_MASK + 0U, // PseudoVFREDMIN_VS_MF2_E32 + 0U, // PseudoVFREDMIN_VS_MF2_E32_MASK + 0U, // PseudoVFREDMIN_VS_MF4_E16 + 0U, // PseudoVFREDMIN_VS_MF4_E16_MASK + 0U, // PseudoVFREDOSUM_VS_M1_E16 + 0U, // PseudoVFREDOSUM_VS_M1_E16_MASK + 0U, // PseudoVFREDOSUM_VS_M1_E32 + 0U, // PseudoVFREDOSUM_VS_M1_E32_MASK + 0U, // PseudoVFREDOSUM_VS_M1_E64 + 0U, // PseudoVFREDOSUM_VS_M1_E64_MASK + 0U, // PseudoVFREDOSUM_VS_M2_E16 + 0U, // PseudoVFREDOSUM_VS_M2_E16_MASK + 0U, // PseudoVFREDOSUM_VS_M2_E32 + 0U, // PseudoVFREDOSUM_VS_M2_E32_MASK + 0U, // PseudoVFREDOSUM_VS_M2_E64 + 0U, // PseudoVFREDOSUM_VS_M2_E64_MASK + 0U, // PseudoVFREDOSUM_VS_M4_E16 + 0U, // PseudoVFREDOSUM_VS_M4_E16_MASK + 0U, // PseudoVFREDOSUM_VS_M4_E32 + 0U, // PseudoVFREDOSUM_VS_M4_E32_MASK + 0U, // PseudoVFREDOSUM_VS_M4_E64 + 0U, // PseudoVFREDOSUM_VS_M4_E64_MASK + 0U, // PseudoVFREDOSUM_VS_M8_E16 + 0U, // PseudoVFREDOSUM_VS_M8_E16_MASK + 0U, // PseudoVFREDOSUM_VS_M8_E32 + 0U, // PseudoVFREDOSUM_VS_M8_E32_MASK + 0U, // PseudoVFREDOSUM_VS_M8_E64 + 0U, // PseudoVFREDOSUM_VS_M8_E64_MASK + 0U, // PseudoVFREDOSUM_VS_MF2_E16 + 0U, // PseudoVFREDOSUM_VS_MF2_E16_MASK + 0U, // PseudoVFREDOSUM_VS_MF2_E32 + 0U, // PseudoVFREDOSUM_VS_MF2_E32_MASK + 0U, // PseudoVFREDOSUM_VS_MF4_E16 + 0U, // PseudoVFREDOSUM_VS_MF4_E16_MASK + 0U, // PseudoVFREDUSUM_VS_M1_E16 + 0U, // PseudoVFREDUSUM_VS_M1_E16_MASK + 0U, // PseudoVFREDUSUM_VS_M1_E32 + 0U, // PseudoVFREDUSUM_VS_M1_E32_MASK + 0U, // PseudoVFREDUSUM_VS_M1_E64 + 0U, // PseudoVFREDUSUM_VS_M1_E64_MASK + 0U, // PseudoVFREDUSUM_VS_M2_E16 + 0U, // PseudoVFREDUSUM_VS_M2_E16_MASK + 0U, // PseudoVFREDUSUM_VS_M2_E32 + 0U, // PseudoVFREDUSUM_VS_M2_E32_MASK + 0U, // PseudoVFREDUSUM_VS_M2_E64 + 0U, // PseudoVFREDUSUM_VS_M2_E64_MASK + 0U, // PseudoVFREDUSUM_VS_M4_E16 + 0U, // PseudoVFREDUSUM_VS_M4_E16_MASK + 0U, // PseudoVFREDUSUM_VS_M4_E32 + 0U, // PseudoVFREDUSUM_VS_M4_E32_MASK + 0U, // PseudoVFREDUSUM_VS_M4_E64 + 0U, // PseudoVFREDUSUM_VS_M4_E64_MASK + 0U, // PseudoVFREDUSUM_VS_M8_E16 + 0U, // PseudoVFREDUSUM_VS_M8_E16_MASK + 0U, // PseudoVFREDUSUM_VS_M8_E32 + 0U, // PseudoVFREDUSUM_VS_M8_E32_MASK + 0U, // PseudoVFREDUSUM_VS_M8_E64 + 0U, // PseudoVFREDUSUM_VS_M8_E64_MASK + 0U, // PseudoVFREDUSUM_VS_MF2_E16 + 0U, // PseudoVFREDUSUM_VS_MF2_E16_MASK + 0U, // PseudoVFREDUSUM_VS_MF2_E32 + 0U, // PseudoVFREDUSUM_VS_MF2_E32_MASK + 0U, // PseudoVFREDUSUM_VS_MF4_E16 + 0U, // PseudoVFREDUSUM_VS_MF4_E16_MASK + 0U, // PseudoVFROUND_NOEXCEPT_V_M1_MASK + 0U, // PseudoVFROUND_NOEXCEPT_V_M2_MASK + 0U, // PseudoVFROUND_NOEXCEPT_V_M4_MASK + 0U, // PseudoVFROUND_NOEXCEPT_V_M8_MASK + 0U, // PseudoVFROUND_NOEXCEPT_V_MF2_MASK + 0U, // PseudoVFROUND_NOEXCEPT_V_MF4_MASK + 0U, // PseudoVFRSQRT7_V_M1 + 0U, // PseudoVFRSQRT7_V_M1_MASK + 0U, // PseudoVFRSQRT7_V_M2 + 0U, // PseudoVFRSQRT7_V_M2_MASK + 0U, // PseudoVFRSQRT7_V_M4 + 0U, // PseudoVFRSQRT7_V_M4_MASK + 0U, // PseudoVFRSQRT7_V_M8 + 0U, // PseudoVFRSQRT7_V_M8_MASK + 0U, // PseudoVFRSQRT7_V_MF2 + 0U, // PseudoVFRSQRT7_V_MF2_MASK + 0U, // PseudoVFRSQRT7_V_MF4 + 0U, // PseudoVFRSQRT7_V_MF4_MASK + 0U, // PseudoVFRSUB_VFPR16_M1 + 0U, // PseudoVFRSUB_VFPR16_M1_MASK + 0U, // PseudoVFRSUB_VFPR16_M2 + 0U, // PseudoVFRSUB_VFPR16_M2_MASK + 0U, // PseudoVFRSUB_VFPR16_M4 + 0U, // PseudoVFRSUB_VFPR16_M4_MASK + 0U, // PseudoVFRSUB_VFPR16_M8 + 0U, // PseudoVFRSUB_VFPR16_M8_MASK + 0U, // PseudoVFRSUB_VFPR16_MF2 + 0U, // PseudoVFRSUB_VFPR16_MF2_MASK + 0U, // PseudoVFRSUB_VFPR16_MF4 + 0U, // PseudoVFRSUB_VFPR16_MF4_MASK + 0U, // PseudoVFRSUB_VFPR32_M1 + 0U, // PseudoVFRSUB_VFPR32_M1_MASK + 0U, // PseudoVFRSUB_VFPR32_M2 + 0U, // PseudoVFRSUB_VFPR32_M2_MASK + 0U, // PseudoVFRSUB_VFPR32_M4 + 0U, // PseudoVFRSUB_VFPR32_M4_MASK + 0U, // PseudoVFRSUB_VFPR32_M8 + 0U, // PseudoVFRSUB_VFPR32_M8_MASK + 0U, // PseudoVFRSUB_VFPR32_MF2 + 0U, // PseudoVFRSUB_VFPR32_MF2_MASK + 0U, // PseudoVFRSUB_VFPR64_M1 + 0U, // PseudoVFRSUB_VFPR64_M1_MASK + 0U, // PseudoVFRSUB_VFPR64_M2 + 0U, // PseudoVFRSUB_VFPR64_M2_MASK + 0U, // PseudoVFRSUB_VFPR64_M4 + 0U, // PseudoVFRSUB_VFPR64_M4_MASK + 0U, // PseudoVFRSUB_VFPR64_M8 + 0U, // PseudoVFRSUB_VFPR64_M8_MASK + 0U, // PseudoVFSGNJN_VFPR16_M1 + 0U, // PseudoVFSGNJN_VFPR16_M1_MASK + 0U, // PseudoVFSGNJN_VFPR16_M2 + 0U, // PseudoVFSGNJN_VFPR16_M2_MASK + 0U, // PseudoVFSGNJN_VFPR16_M4 + 0U, // PseudoVFSGNJN_VFPR16_M4_MASK + 0U, // PseudoVFSGNJN_VFPR16_M8 + 0U, // PseudoVFSGNJN_VFPR16_M8_MASK + 0U, // PseudoVFSGNJN_VFPR16_MF2 + 0U, // PseudoVFSGNJN_VFPR16_MF2_MASK + 0U, // PseudoVFSGNJN_VFPR16_MF4 + 0U, // PseudoVFSGNJN_VFPR16_MF4_MASK + 0U, // PseudoVFSGNJN_VFPR32_M1 + 0U, // PseudoVFSGNJN_VFPR32_M1_MASK + 0U, // PseudoVFSGNJN_VFPR32_M2 + 0U, // PseudoVFSGNJN_VFPR32_M2_MASK + 0U, // PseudoVFSGNJN_VFPR32_M4 + 0U, // PseudoVFSGNJN_VFPR32_M4_MASK + 0U, // PseudoVFSGNJN_VFPR32_M8 + 0U, // PseudoVFSGNJN_VFPR32_M8_MASK + 0U, // PseudoVFSGNJN_VFPR32_MF2 + 0U, // PseudoVFSGNJN_VFPR32_MF2_MASK + 0U, // PseudoVFSGNJN_VFPR64_M1 + 0U, // PseudoVFSGNJN_VFPR64_M1_MASK + 0U, // PseudoVFSGNJN_VFPR64_M2 + 0U, // PseudoVFSGNJN_VFPR64_M2_MASK + 0U, // PseudoVFSGNJN_VFPR64_M4 + 0U, // PseudoVFSGNJN_VFPR64_M4_MASK + 0U, // PseudoVFSGNJN_VFPR64_M8 + 0U, // PseudoVFSGNJN_VFPR64_M8_MASK + 0U, // PseudoVFSGNJN_VV_M1 + 0U, // PseudoVFSGNJN_VV_M1_MASK + 0U, // PseudoVFSGNJN_VV_M2 + 0U, // PseudoVFSGNJN_VV_M2_MASK + 0U, // PseudoVFSGNJN_VV_M4 + 0U, // PseudoVFSGNJN_VV_M4_MASK + 0U, // PseudoVFSGNJN_VV_M8 + 0U, // PseudoVFSGNJN_VV_M8_MASK + 0U, // PseudoVFSGNJN_VV_MF2 + 0U, // PseudoVFSGNJN_VV_MF2_MASK + 0U, // PseudoVFSGNJN_VV_MF4 + 0U, // PseudoVFSGNJN_VV_MF4_MASK + 0U, // PseudoVFSGNJX_VFPR16_M1 + 0U, // PseudoVFSGNJX_VFPR16_M1_MASK + 0U, // PseudoVFSGNJX_VFPR16_M2 + 0U, // PseudoVFSGNJX_VFPR16_M2_MASK + 0U, // PseudoVFSGNJX_VFPR16_M4 + 0U, // PseudoVFSGNJX_VFPR16_M4_MASK + 0U, // PseudoVFSGNJX_VFPR16_M8 + 0U, // PseudoVFSGNJX_VFPR16_M8_MASK + 0U, // PseudoVFSGNJX_VFPR16_MF2 + 0U, // PseudoVFSGNJX_VFPR16_MF2_MASK + 0U, // PseudoVFSGNJX_VFPR16_MF4 + 0U, // PseudoVFSGNJX_VFPR16_MF4_MASK + 0U, // PseudoVFSGNJX_VFPR32_M1 + 0U, // PseudoVFSGNJX_VFPR32_M1_MASK + 0U, // PseudoVFSGNJX_VFPR32_M2 + 0U, // PseudoVFSGNJX_VFPR32_M2_MASK + 0U, // PseudoVFSGNJX_VFPR32_M4 + 0U, // PseudoVFSGNJX_VFPR32_M4_MASK + 0U, // PseudoVFSGNJX_VFPR32_M8 + 0U, // PseudoVFSGNJX_VFPR32_M8_MASK + 0U, // PseudoVFSGNJX_VFPR32_MF2 + 0U, // PseudoVFSGNJX_VFPR32_MF2_MASK + 0U, // PseudoVFSGNJX_VFPR64_M1 + 0U, // PseudoVFSGNJX_VFPR64_M1_MASK + 0U, // PseudoVFSGNJX_VFPR64_M2 + 0U, // PseudoVFSGNJX_VFPR64_M2_MASK + 0U, // PseudoVFSGNJX_VFPR64_M4 + 0U, // PseudoVFSGNJX_VFPR64_M4_MASK + 0U, // PseudoVFSGNJX_VFPR64_M8 + 0U, // PseudoVFSGNJX_VFPR64_M8_MASK + 0U, // PseudoVFSGNJX_VV_M1 + 0U, // PseudoVFSGNJX_VV_M1_MASK + 0U, // PseudoVFSGNJX_VV_M2 + 0U, // PseudoVFSGNJX_VV_M2_MASK + 0U, // PseudoVFSGNJX_VV_M4 + 0U, // PseudoVFSGNJX_VV_M4_MASK + 0U, // PseudoVFSGNJX_VV_M8 + 0U, // PseudoVFSGNJX_VV_M8_MASK + 0U, // PseudoVFSGNJX_VV_MF2 + 0U, // PseudoVFSGNJX_VV_MF2_MASK + 0U, // PseudoVFSGNJX_VV_MF4 + 0U, // PseudoVFSGNJX_VV_MF4_MASK + 0U, // PseudoVFSGNJ_VFPR16_M1 + 0U, // PseudoVFSGNJ_VFPR16_M1_MASK + 0U, // PseudoVFSGNJ_VFPR16_M2 + 0U, // PseudoVFSGNJ_VFPR16_M2_MASK + 0U, // PseudoVFSGNJ_VFPR16_M4 + 0U, // PseudoVFSGNJ_VFPR16_M4_MASK + 0U, // PseudoVFSGNJ_VFPR16_M8 + 0U, // PseudoVFSGNJ_VFPR16_M8_MASK + 0U, // PseudoVFSGNJ_VFPR16_MF2 + 0U, // PseudoVFSGNJ_VFPR16_MF2_MASK + 0U, // PseudoVFSGNJ_VFPR16_MF4 + 0U, // PseudoVFSGNJ_VFPR16_MF4_MASK + 0U, // PseudoVFSGNJ_VFPR32_M1 + 0U, // PseudoVFSGNJ_VFPR32_M1_MASK + 0U, // PseudoVFSGNJ_VFPR32_M2 + 0U, // PseudoVFSGNJ_VFPR32_M2_MASK + 0U, // PseudoVFSGNJ_VFPR32_M4 + 0U, // PseudoVFSGNJ_VFPR32_M4_MASK + 0U, // PseudoVFSGNJ_VFPR32_M8 + 0U, // PseudoVFSGNJ_VFPR32_M8_MASK + 0U, // PseudoVFSGNJ_VFPR32_MF2 + 0U, // PseudoVFSGNJ_VFPR32_MF2_MASK + 0U, // PseudoVFSGNJ_VFPR64_M1 + 0U, // PseudoVFSGNJ_VFPR64_M1_MASK + 0U, // PseudoVFSGNJ_VFPR64_M2 + 0U, // PseudoVFSGNJ_VFPR64_M2_MASK + 0U, // PseudoVFSGNJ_VFPR64_M4 + 0U, // PseudoVFSGNJ_VFPR64_M4_MASK + 0U, // PseudoVFSGNJ_VFPR64_M8 + 0U, // PseudoVFSGNJ_VFPR64_M8_MASK + 0U, // PseudoVFSGNJ_VV_M1 + 0U, // PseudoVFSGNJ_VV_M1_MASK + 0U, // PseudoVFSGNJ_VV_M2 + 0U, // PseudoVFSGNJ_VV_M2_MASK + 0U, // PseudoVFSGNJ_VV_M4 + 0U, // PseudoVFSGNJ_VV_M4_MASK + 0U, // PseudoVFSGNJ_VV_M8 + 0U, // PseudoVFSGNJ_VV_M8_MASK + 0U, // PseudoVFSGNJ_VV_MF2 + 0U, // PseudoVFSGNJ_VV_MF2_MASK + 0U, // PseudoVFSGNJ_VV_MF4 + 0U, // PseudoVFSGNJ_VV_MF4_MASK + 0U, // PseudoVFSLIDE1DOWN_VFPR16_M1 + 0U, // PseudoVFSLIDE1DOWN_VFPR16_M1_MASK + 0U, // PseudoVFSLIDE1DOWN_VFPR16_M2 + 0U, // PseudoVFSLIDE1DOWN_VFPR16_M2_MASK + 0U, // PseudoVFSLIDE1DOWN_VFPR16_M4 + 0U, // PseudoVFSLIDE1DOWN_VFPR16_M4_MASK + 0U, // PseudoVFSLIDE1DOWN_VFPR16_M8 + 0U, // PseudoVFSLIDE1DOWN_VFPR16_M8_MASK + 0U, // PseudoVFSLIDE1DOWN_VFPR16_MF2 + 0U, // PseudoVFSLIDE1DOWN_VFPR16_MF2_MASK + 0U, // PseudoVFSLIDE1DOWN_VFPR16_MF4 + 0U, // PseudoVFSLIDE1DOWN_VFPR16_MF4_MASK + 0U, // PseudoVFSLIDE1DOWN_VFPR32_M1 + 0U, // PseudoVFSLIDE1DOWN_VFPR32_M1_MASK + 0U, // PseudoVFSLIDE1DOWN_VFPR32_M2 + 0U, // PseudoVFSLIDE1DOWN_VFPR32_M2_MASK + 0U, // PseudoVFSLIDE1DOWN_VFPR32_M4 + 0U, // PseudoVFSLIDE1DOWN_VFPR32_M4_MASK + 0U, // PseudoVFSLIDE1DOWN_VFPR32_M8 + 0U, // PseudoVFSLIDE1DOWN_VFPR32_M8_MASK + 0U, // PseudoVFSLIDE1DOWN_VFPR32_MF2 + 0U, // PseudoVFSLIDE1DOWN_VFPR32_MF2_MASK + 0U, // PseudoVFSLIDE1DOWN_VFPR64_M1 + 0U, // PseudoVFSLIDE1DOWN_VFPR64_M1_MASK + 0U, // PseudoVFSLIDE1DOWN_VFPR64_M2 + 0U, // PseudoVFSLIDE1DOWN_VFPR64_M2_MASK + 0U, // PseudoVFSLIDE1DOWN_VFPR64_M4 + 0U, // PseudoVFSLIDE1DOWN_VFPR64_M4_MASK + 0U, // PseudoVFSLIDE1DOWN_VFPR64_M8 + 0U, // PseudoVFSLIDE1DOWN_VFPR64_M8_MASK + 0U, // PseudoVFSLIDE1UP_VFPR16_M1 + 0U, // PseudoVFSLIDE1UP_VFPR16_M1_MASK + 0U, // PseudoVFSLIDE1UP_VFPR16_M2 + 0U, // PseudoVFSLIDE1UP_VFPR16_M2_MASK + 0U, // PseudoVFSLIDE1UP_VFPR16_M4 + 0U, // PseudoVFSLIDE1UP_VFPR16_M4_MASK + 0U, // PseudoVFSLIDE1UP_VFPR16_M8 + 0U, // PseudoVFSLIDE1UP_VFPR16_M8_MASK + 0U, // PseudoVFSLIDE1UP_VFPR16_MF2 + 0U, // PseudoVFSLIDE1UP_VFPR16_MF2_MASK + 0U, // PseudoVFSLIDE1UP_VFPR16_MF4 + 0U, // PseudoVFSLIDE1UP_VFPR16_MF4_MASK + 0U, // PseudoVFSLIDE1UP_VFPR32_M1 + 0U, // PseudoVFSLIDE1UP_VFPR32_M1_MASK + 0U, // PseudoVFSLIDE1UP_VFPR32_M2 + 0U, // PseudoVFSLIDE1UP_VFPR32_M2_MASK + 0U, // PseudoVFSLIDE1UP_VFPR32_M4 + 0U, // PseudoVFSLIDE1UP_VFPR32_M4_MASK + 0U, // PseudoVFSLIDE1UP_VFPR32_M8 + 0U, // PseudoVFSLIDE1UP_VFPR32_M8_MASK + 0U, // PseudoVFSLIDE1UP_VFPR32_MF2 + 0U, // PseudoVFSLIDE1UP_VFPR32_MF2_MASK + 0U, // PseudoVFSLIDE1UP_VFPR64_M1 + 0U, // PseudoVFSLIDE1UP_VFPR64_M1_MASK + 0U, // PseudoVFSLIDE1UP_VFPR64_M2 + 0U, // PseudoVFSLIDE1UP_VFPR64_M2_MASK + 0U, // PseudoVFSLIDE1UP_VFPR64_M4 + 0U, // PseudoVFSLIDE1UP_VFPR64_M4_MASK + 0U, // PseudoVFSLIDE1UP_VFPR64_M8 + 0U, // PseudoVFSLIDE1UP_VFPR64_M8_MASK + 0U, // PseudoVFSQRT_V_M1_E16 + 0U, // PseudoVFSQRT_V_M1_E16_MASK + 0U, // PseudoVFSQRT_V_M1_E32 + 0U, // PseudoVFSQRT_V_M1_E32_MASK + 0U, // PseudoVFSQRT_V_M1_E64 + 0U, // PseudoVFSQRT_V_M1_E64_MASK + 0U, // PseudoVFSQRT_V_M2_E16 + 0U, // PseudoVFSQRT_V_M2_E16_MASK + 0U, // PseudoVFSQRT_V_M2_E32 + 0U, // PseudoVFSQRT_V_M2_E32_MASK + 0U, // PseudoVFSQRT_V_M2_E64 + 0U, // PseudoVFSQRT_V_M2_E64_MASK + 0U, // PseudoVFSQRT_V_M4_E16 + 0U, // PseudoVFSQRT_V_M4_E16_MASK + 0U, // PseudoVFSQRT_V_M4_E32 + 0U, // PseudoVFSQRT_V_M4_E32_MASK + 0U, // PseudoVFSQRT_V_M4_E64 + 0U, // PseudoVFSQRT_V_M4_E64_MASK + 0U, // PseudoVFSQRT_V_M8_E16 + 0U, // PseudoVFSQRT_V_M8_E16_MASK + 0U, // PseudoVFSQRT_V_M8_E32 + 0U, // PseudoVFSQRT_V_M8_E32_MASK + 0U, // PseudoVFSQRT_V_M8_E64 + 0U, // PseudoVFSQRT_V_M8_E64_MASK + 0U, // PseudoVFSQRT_V_MF2_E16 + 0U, // PseudoVFSQRT_V_MF2_E16_MASK + 0U, // PseudoVFSQRT_V_MF2_E32 + 0U, // PseudoVFSQRT_V_MF2_E32_MASK + 0U, // PseudoVFSQRT_V_MF4_E16 + 0U, // PseudoVFSQRT_V_MF4_E16_MASK + 0U, // PseudoVFSUB_VFPR16_M1 + 0U, // PseudoVFSUB_VFPR16_M1_MASK + 0U, // PseudoVFSUB_VFPR16_M2 + 0U, // PseudoVFSUB_VFPR16_M2_MASK + 0U, // PseudoVFSUB_VFPR16_M4 + 0U, // PseudoVFSUB_VFPR16_M4_MASK + 0U, // PseudoVFSUB_VFPR16_M8 + 0U, // PseudoVFSUB_VFPR16_M8_MASK + 0U, // PseudoVFSUB_VFPR16_MF2 + 0U, // PseudoVFSUB_VFPR16_MF2_MASK + 0U, // PseudoVFSUB_VFPR16_MF4 + 0U, // PseudoVFSUB_VFPR16_MF4_MASK + 0U, // PseudoVFSUB_VFPR32_M1 + 0U, // PseudoVFSUB_VFPR32_M1_MASK + 0U, // PseudoVFSUB_VFPR32_M2 + 0U, // PseudoVFSUB_VFPR32_M2_MASK + 0U, // PseudoVFSUB_VFPR32_M4 + 0U, // PseudoVFSUB_VFPR32_M4_MASK + 0U, // PseudoVFSUB_VFPR32_M8 + 0U, // PseudoVFSUB_VFPR32_M8_MASK + 0U, // PseudoVFSUB_VFPR32_MF2 + 0U, // PseudoVFSUB_VFPR32_MF2_MASK + 0U, // PseudoVFSUB_VFPR64_M1 + 0U, // PseudoVFSUB_VFPR64_M1_MASK + 0U, // PseudoVFSUB_VFPR64_M2 + 0U, // PseudoVFSUB_VFPR64_M2_MASK + 0U, // PseudoVFSUB_VFPR64_M4 + 0U, // PseudoVFSUB_VFPR64_M4_MASK + 0U, // PseudoVFSUB_VFPR64_M8 + 0U, // PseudoVFSUB_VFPR64_M8_MASK + 0U, // PseudoVFSUB_VV_M1 + 0U, // PseudoVFSUB_VV_M1_MASK + 0U, // PseudoVFSUB_VV_M2 + 0U, // PseudoVFSUB_VV_M2_MASK + 0U, // PseudoVFSUB_VV_M4 + 0U, // PseudoVFSUB_VV_M4_MASK + 0U, // PseudoVFSUB_VV_M8 + 0U, // PseudoVFSUB_VV_M8_MASK + 0U, // PseudoVFSUB_VV_MF2 + 0U, // PseudoVFSUB_VV_MF2_MASK + 0U, // PseudoVFSUB_VV_MF4 + 0U, // PseudoVFSUB_VV_MF4_MASK + 0U, // PseudoVFWADD_VFPR16_M1 + 0U, // PseudoVFWADD_VFPR16_M1_MASK + 0U, // PseudoVFWADD_VFPR16_M2 + 0U, // PseudoVFWADD_VFPR16_M2_MASK + 0U, // PseudoVFWADD_VFPR16_M4 + 0U, // PseudoVFWADD_VFPR16_M4_MASK + 0U, // PseudoVFWADD_VFPR16_MF2 + 0U, // PseudoVFWADD_VFPR16_MF2_MASK + 0U, // PseudoVFWADD_VFPR16_MF4 + 0U, // PseudoVFWADD_VFPR16_MF4_MASK + 0U, // PseudoVFWADD_VFPR32_M1 + 0U, // PseudoVFWADD_VFPR32_M1_MASK + 0U, // PseudoVFWADD_VFPR32_M2 + 0U, // PseudoVFWADD_VFPR32_M2_MASK + 0U, // PseudoVFWADD_VFPR32_M4 + 0U, // PseudoVFWADD_VFPR32_M4_MASK + 0U, // PseudoVFWADD_VFPR32_MF2 + 0U, // PseudoVFWADD_VFPR32_MF2_MASK + 0U, // PseudoVFWADD_VV_M1 + 0U, // PseudoVFWADD_VV_M1_MASK + 0U, // PseudoVFWADD_VV_M2 + 0U, // PseudoVFWADD_VV_M2_MASK + 0U, // PseudoVFWADD_VV_M4 + 0U, // PseudoVFWADD_VV_M4_MASK + 0U, // PseudoVFWADD_VV_MF2 + 0U, // PseudoVFWADD_VV_MF2_MASK + 0U, // PseudoVFWADD_VV_MF4 + 0U, // PseudoVFWADD_VV_MF4_MASK + 0U, // PseudoVFWADD_WFPR16_M1 + 0U, // PseudoVFWADD_WFPR16_M1_MASK + 0U, // PseudoVFWADD_WFPR16_M2 + 0U, // PseudoVFWADD_WFPR16_M2_MASK + 0U, // PseudoVFWADD_WFPR16_M4 + 0U, // PseudoVFWADD_WFPR16_M4_MASK + 0U, // PseudoVFWADD_WFPR16_MF2 + 0U, // PseudoVFWADD_WFPR16_MF2_MASK + 0U, // PseudoVFWADD_WFPR16_MF4 + 0U, // PseudoVFWADD_WFPR16_MF4_MASK + 0U, // PseudoVFWADD_WFPR32_M1 + 0U, // PseudoVFWADD_WFPR32_M1_MASK + 0U, // PseudoVFWADD_WFPR32_M2 + 0U, // PseudoVFWADD_WFPR32_M2_MASK + 0U, // PseudoVFWADD_WFPR32_M4 + 0U, // PseudoVFWADD_WFPR32_M4_MASK + 0U, // PseudoVFWADD_WFPR32_MF2 + 0U, // PseudoVFWADD_WFPR32_MF2_MASK + 0U, // PseudoVFWADD_WV_M1 + 0U, // PseudoVFWADD_WV_M1_MASK + 0U, // PseudoVFWADD_WV_M1_MASK_TIED + 0U, // PseudoVFWADD_WV_M1_TIED + 0U, // PseudoVFWADD_WV_M2 + 0U, // PseudoVFWADD_WV_M2_MASK + 0U, // PseudoVFWADD_WV_M2_MASK_TIED + 0U, // PseudoVFWADD_WV_M2_TIED + 0U, // PseudoVFWADD_WV_M4 + 0U, // PseudoVFWADD_WV_M4_MASK + 0U, // PseudoVFWADD_WV_M4_MASK_TIED + 0U, // PseudoVFWADD_WV_M4_TIED + 0U, // PseudoVFWADD_WV_MF2 + 0U, // PseudoVFWADD_WV_MF2_MASK + 0U, // PseudoVFWADD_WV_MF2_MASK_TIED + 0U, // PseudoVFWADD_WV_MF2_TIED + 0U, // PseudoVFWADD_WV_MF4 + 0U, // PseudoVFWADD_WV_MF4_MASK + 0U, // PseudoVFWADD_WV_MF4_MASK_TIED + 0U, // PseudoVFWADD_WV_MF4_TIED + 0U, // PseudoVFWCVTBF16_F_F_V_M1 + 0U, // PseudoVFWCVTBF16_F_F_V_M1_MASK + 0U, // PseudoVFWCVTBF16_F_F_V_M2 + 0U, // PseudoVFWCVTBF16_F_F_V_M2_MASK + 0U, // PseudoVFWCVTBF16_F_F_V_M4 + 0U, // PseudoVFWCVTBF16_F_F_V_M4_MASK + 0U, // PseudoVFWCVTBF16_F_F_V_MF2 + 0U, // PseudoVFWCVTBF16_F_F_V_MF2_MASK + 0U, // PseudoVFWCVTBF16_F_F_V_MF4 + 0U, // PseudoVFWCVTBF16_F_F_V_MF4_MASK + 0U, // PseudoVFWCVT_F_F_V_M1 + 0U, // PseudoVFWCVT_F_F_V_M1_MASK + 0U, // PseudoVFWCVT_F_F_V_M2 + 0U, // PseudoVFWCVT_F_F_V_M2_MASK + 0U, // PseudoVFWCVT_F_F_V_M4 + 0U, // PseudoVFWCVT_F_F_V_M4_MASK + 0U, // PseudoVFWCVT_F_F_V_MF2 + 0U, // PseudoVFWCVT_F_F_V_MF2_MASK + 0U, // PseudoVFWCVT_F_F_V_MF4 + 0U, // PseudoVFWCVT_F_F_V_MF4_MASK + 0U, // PseudoVFWCVT_F_XU_V_M1 + 0U, // PseudoVFWCVT_F_XU_V_M1_MASK + 0U, // PseudoVFWCVT_F_XU_V_M2 + 0U, // PseudoVFWCVT_F_XU_V_M2_MASK + 0U, // PseudoVFWCVT_F_XU_V_M4 + 0U, // PseudoVFWCVT_F_XU_V_M4_MASK + 0U, // PseudoVFWCVT_F_XU_V_MF2 + 0U, // PseudoVFWCVT_F_XU_V_MF2_MASK + 0U, // PseudoVFWCVT_F_XU_V_MF4 + 0U, // PseudoVFWCVT_F_XU_V_MF4_MASK + 0U, // PseudoVFWCVT_F_XU_V_MF8 + 0U, // PseudoVFWCVT_F_XU_V_MF8_MASK + 0U, // PseudoVFWCVT_F_X_V_M1 + 0U, // PseudoVFWCVT_F_X_V_M1_MASK + 0U, // PseudoVFWCVT_F_X_V_M2 + 0U, // PseudoVFWCVT_F_X_V_M2_MASK + 0U, // PseudoVFWCVT_F_X_V_M4 + 0U, // PseudoVFWCVT_F_X_V_M4_MASK + 0U, // PseudoVFWCVT_F_X_V_MF2 + 0U, // PseudoVFWCVT_F_X_V_MF2_MASK + 0U, // PseudoVFWCVT_F_X_V_MF4 + 0U, // PseudoVFWCVT_F_X_V_MF4_MASK + 0U, // PseudoVFWCVT_F_X_V_MF8 + 0U, // PseudoVFWCVT_F_X_V_MF8_MASK + 0U, // PseudoVFWCVT_RM_XU_F_V_M1 + 0U, // PseudoVFWCVT_RM_XU_F_V_M1_MASK + 0U, // PseudoVFWCVT_RM_XU_F_V_M2 + 0U, // PseudoVFWCVT_RM_XU_F_V_M2_MASK + 0U, // PseudoVFWCVT_RM_XU_F_V_M4 + 0U, // PseudoVFWCVT_RM_XU_F_V_M4_MASK + 0U, // PseudoVFWCVT_RM_XU_F_V_MF2 + 0U, // PseudoVFWCVT_RM_XU_F_V_MF2_MASK + 0U, // PseudoVFWCVT_RM_XU_F_V_MF4 + 0U, // PseudoVFWCVT_RM_XU_F_V_MF4_MASK + 0U, // PseudoVFWCVT_RM_X_F_V_M1 + 0U, // PseudoVFWCVT_RM_X_F_V_M1_MASK + 0U, // PseudoVFWCVT_RM_X_F_V_M2 + 0U, // PseudoVFWCVT_RM_X_F_V_M2_MASK + 0U, // PseudoVFWCVT_RM_X_F_V_M4 + 0U, // PseudoVFWCVT_RM_X_F_V_M4_MASK + 0U, // PseudoVFWCVT_RM_X_F_V_MF2 + 0U, // PseudoVFWCVT_RM_X_F_V_MF2_MASK + 0U, // PseudoVFWCVT_RM_X_F_V_MF4 + 0U, // PseudoVFWCVT_RM_X_F_V_MF4_MASK + 0U, // PseudoVFWCVT_RTZ_XU_F_V_M1 + 0U, // PseudoVFWCVT_RTZ_XU_F_V_M1_MASK + 0U, // PseudoVFWCVT_RTZ_XU_F_V_M2 + 0U, // PseudoVFWCVT_RTZ_XU_F_V_M2_MASK + 0U, // PseudoVFWCVT_RTZ_XU_F_V_M4 + 0U, // PseudoVFWCVT_RTZ_XU_F_V_M4_MASK + 0U, // PseudoVFWCVT_RTZ_XU_F_V_MF2 + 0U, // PseudoVFWCVT_RTZ_XU_F_V_MF2_MASK + 0U, // PseudoVFWCVT_RTZ_XU_F_V_MF4 + 0U, // PseudoVFWCVT_RTZ_XU_F_V_MF4_MASK + 0U, // PseudoVFWCVT_RTZ_X_F_V_M1 + 0U, // PseudoVFWCVT_RTZ_X_F_V_M1_MASK + 0U, // PseudoVFWCVT_RTZ_X_F_V_M2 + 0U, // PseudoVFWCVT_RTZ_X_F_V_M2_MASK + 0U, // PseudoVFWCVT_RTZ_X_F_V_M4 + 0U, // PseudoVFWCVT_RTZ_X_F_V_M4_MASK + 0U, // PseudoVFWCVT_RTZ_X_F_V_MF2 + 0U, // PseudoVFWCVT_RTZ_X_F_V_MF2_MASK + 0U, // PseudoVFWCVT_RTZ_X_F_V_MF4 + 0U, // PseudoVFWCVT_RTZ_X_F_V_MF4_MASK + 0U, // PseudoVFWCVT_XU_F_V_M1 + 0U, // PseudoVFWCVT_XU_F_V_M1_MASK + 0U, // PseudoVFWCVT_XU_F_V_M2 + 0U, // PseudoVFWCVT_XU_F_V_M2_MASK + 0U, // PseudoVFWCVT_XU_F_V_M4 + 0U, // PseudoVFWCVT_XU_F_V_M4_MASK + 0U, // PseudoVFWCVT_XU_F_V_MF2 + 0U, // PseudoVFWCVT_XU_F_V_MF2_MASK + 0U, // PseudoVFWCVT_XU_F_V_MF4 + 0U, // PseudoVFWCVT_XU_F_V_MF4_MASK + 0U, // PseudoVFWCVT_X_F_V_M1 + 0U, // PseudoVFWCVT_X_F_V_M1_MASK + 0U, // PseudoVFWCVT_X_F_V_M2 + 0U, // PseudoVFWCVT_X_F_V_M2_MASK + 0U, // PseudoVFWCVT_X_F_V_M4 + 0U, // PseudoVFWCVT_X_F_V_M4_MASK + 0U, // PseudoVFWCVT_X_F_V_MF2 + 0U, // PseudoVFWCVT_X_F_V_MF2_MASK + 0U, // PseudoVFWCVT_X_F_V_MF4 + 0U, // PseudoVFWCVT_X_F_V_MF4_MASK + 0U, // PseudoVFWMACCBF16_VFPR16_M1 + 0U, // PseudoVFWMACCBF16_VFPR16_M1_MASK + 0U, // PseudoVFWMACCBF16_VFPR16_M2 + 0U, // PseudoVFWMACCBF16_VFPR16_M2_MASK + 0U, // PseudoVFWMACCBF16_VFPR16_M4 + 0U, // PseudoVFWMACCBF16_VFPR16_M4_MASK + 0U, // PseudoVFWMACCBF16_VFPR16_MF2 + 0U, // PseudoVFWMACCBF16_VFPR16_MF2_MASK + 0U, // PseudoVFWMACCBF16_VFPR16_MF4 + 0U, // PseudoVFWMACCBF16_VFPR16_MF4_MASK + 0U, // PseudoVFWMACCBF16_VV_M1 + 0U, // PseudoVFWMACCBF16_VV_M1_MASK + 0U, // PseudoVFWMACCBF16_VV_M2 + 0U, // PseudoVFWMACCBF16_VV_M2_MASK + 0U, // PseudoVFWMACCBF16_VV_M4 + 0U, // PseudoVFWMACCBF16_VV_M4_MASK + 0U, // PseudoVFWMACCBF16_VV_MF2 + 0U, // PseudoVFWMACCBF16_VV_MF2_MASK + 0U, // PseudoVFWMACCBF16_VV_MF4 + 0U, // PseudoVFWMACCBF16_VV_MF4_MASK + 0U, // PseudoVFWMACC_4x4x4_M1 + 0U, // PseudoVFWMACC_4x4x4_M2 + 0U, // PseudoVFWMACC_4x4x4_M4 + 0U, // PseudoVFWMACC_4x4x4_M8 + 0U, // PseudoVFWMACC_4x4x4_MF2 + 0U, // PseudoVFWMACC_4x4x4_MF4 + 0U, // PseudoVFWMACC_VFPR16_M1 + 0U, // PseudoVFWMACC_VFPR16_M1_MASK + 0U, // PseudoVFWMACC_VFPR16_M2 + 0U, // PseudoVFWMACC_VFPR16_M2_MASK + 0U, // PseudoVFWMACC_VFPR16_M4 + 0U, // PseudoVFWMACC_VFPR16_M4_MASK + 0U, // PseudoVFWMACC_VFPR16_MF2 + 0U, // PseudoVFWMACC_VFPR16_MF2_MASK + 0U, // PseudoVFWMACC_VFPR16_MF4 + 0U, // PseudoVFWMACC_VFPR16_MF4_MASK + 0U, // PseudoVFWMACC_VFPR32_M1 + 0U, // PseudoVFWMACC_VFPR32_M1_MASK + 0U, // PseudoVFWMACC_VFPR32_M2 + 0U, // PseudoVFWMACC_VFPR32_M2_MASK + 0U, // PseudoVFWMACC_VFPR32_M4 + 0U, // PseudoVFWMACC_VFPR32_M4_MASK + 0U, // PseudoVFWMACC_VFPR32_MF2 + 0U, // PseudoVFWMACC_VFPR32_MF2_MASK + 0U, // PseudoVFWMACC_VV_M1 + 0U, // PseudoVFWMACC_VV_M1_MASK + 0U, // PseudoVFWMACC_VV_M2 + 0U, // PseudoVFWMACC_VV_M2_MASK + 0U, // PseudoVFWMACC_VV_M4 + 0U, // PseudoVFWMACC_VV_M4_MASK + 0U, // PseudoVFWMACC_VV_MF2 + 0U, // PseudoVFWMACC_VV_MF2_MASK + 0U, // PseudoVFWMACC_VV_MF4 + 0U, // PseudoVFWMACC_VV_MF4_MASK + 0U, // PseudoVFWMSAC_VFPR16_M1 + 0U, // PseudoVFWMSAC_VFPR16_M1_MASK + 0U, // PseudoVFWMSAC_VFPR16_M2 + 0U, // PseudoVFWMSAC_VFPR16_M2_MASK + 0U, // PseudoVFWMSAC_VFPR16_M4 + 0U, // PseudoVFWMSAC_VFPR16_M4_MASK + 0U, // PseudoVFWMSAC_VFPR16_MF2 + 0U, // PseudoVFWMSAC_VFPR16_MF2_MASK + 0U, // PseudoVFWMSAC_VFPR16_MF4 + 0U, // PseudoVFWMSAC_VFPR16_MF4_MASK + 0U, // PseudoVFWMSAC_VFPR32_M1 + 0U, // PseudoVFWMSAC_VFPR32_M1_MASK + 0U, // PseudoVFWMSAC_VFPR32_M2 + 0U, // PseudoVFWMSAC_VFPR32_M2_MASK + 0U, // PseudoVFWMSAC_VFPR32_M4 + 0U, // PseudoVFWMSAC_VFPR32_M4_MASK + 0U, // PseudoVFWMSAC_VFPR32_MF2 + 0U, // PseudoVFWMSAC_VFPR32_MF2_MASK + 0U, // PseudoVFWMSAC_VV_M1 + 0U, // PseudoVFWMSAC_VV_M1_MASK + 0U, // PseudoVFWMSAC_VV_M2 + 0U, // PseudoVFWMSAC_VV_M2_MASK + 0U, // PseudoVFWMSAC_VV_M4 + 0U, // PseudoVFWMSAC_VV_M4_MASK + 0U, // PseudoVFWMSAC_VV_MF2 + 0U, // PseudoVFWMSAC_VV_MF2_MASK + 0U, // PseudoVFWMSAC_VV_MF4 + 0U, // PseudoVFWMSAC_VV_MF4_MASK + 0U, // PseudoVFWMUL_VFPR16_M1 + 0U, // PseudoVFWMUL_VFPR16_M1_MASK + 0U, // PseudoVFWMUL_VFPR16_M2 + 0U, // PseudoVFWMUL_VFPR16_M2_MASK + 0U, // PseudoVFWMUL_VFPR16_M4 + 0U, // PseudoVFWMUL_VFPR16_M4_MASK + 0U, // PseudoVFWMUL_VFPR16_MF2 + 0U, // PseudoVFWMUL_VFPR16_MF2_MASK + 0U, // PseudoVFWMUL_VFPR16_MF4 + 0U, // PseudoVFWMUL_VFPR16_MF4_MASK + 0U, // PseudoVFWMUL_VFPR32_M1 + 0U, // PseudoVFWMUL_VFPR32_M1_MASK + 0U, // PseudoVFWMUL_VFPR32_M2 + 0U, // PseudoVFWMUL_VFPR32_M2_MASK + 0U, // PseudoVFWMUL_VFPR32_M4 + 0U, // PseudoVFWMUL_VFPR32_M4_MASK + 0U, // PseudoVFWMUL_VFPR32_MF2 + 0U, // PseudoVFWMUL_VFPR32_MF2_MASK + 0U, // PseudoVFWMUL_VV_M1 + 0U, // PseudoVFWMUL_VV_M1_MASK + 0U, // PseudoVFWMUL_VV_M2 + 0U, // PseudoVFWMUL_VV_M2_MASK + 0U, // PseudoVFWMUL_VV_M4 + 0U, // PseudoVFWMUL_VV_M4_MASK + 0U, // PseudoVFWMUL_VV_MF2 + 0U, // PseudoVFWMUL_VV_MF2_MASK + 0U, // PseudoVFWMUL_VV_MF4 + 0U, // PseudoVFWMUL_VV_MF4_MASK + 0U, // PseudoVFWNMACC_VFPR16_M1 + 0U, // PseudoVFWNMACC_VFPR16_M1_MASK + 0U, // PseudoVFWNMACC_VFPR16_M2 + 0U, // PseudoVFWNMACC_VFPR16_M2_MASK + 0U, // PseudoVFWNMACC_VFPR16_M4 + 0U, // PseudoVFWNMACC_VFPR16_M4_MASK + 0U, // PseudoVFWNMACC_VFPR16_MF2 + 0U, // PseudoVFWNMACC_VFPR16_MF2_MASK + 0U, // PseudoVFWNMACC_VFPR16_MF4 + 0U, // PseudoVFWNMACC_VFPR16_MF4_MASK + 0U, // PseudoVFWNMACC_VFPR32_M1 + 0U, // PseudoVFWNMACC_VFPR32_M1_MASK + 0U, // PseudoVFWNMACC_VFPR32_M2 + 0U, // PseudoVFWNMACC_VFPR32_M2_MASK + 0U, // PseudoVFWNMACC_VFPR32_M4 + 0U, // PseudoVFWNMACC_VFPR32_M4_MASK + 0U, // PseudoVFWNMACC_VFPR32_MF2 + 0U, // PseudoVFWNMACC_VFPR32_MF2_MASK + 0U, // PseudoVFWNMACC_VV_M1 + 0U, // PseudoVFWNMACC_VV_M1_MASK + 0U, // PseudoVFWNMACC_VV_M2 + 0U, // PseudoVFWNMACC_VV_M2_MASK + 0U, // PseudoVFWNMACC_VV_M4 + 0U, // PseudoVFWNMACC_VV_M4_MASK + 0U, // PseudoVFWNMACC_VV_MF2 + 0U, // PseudoVFWNMACC_VV_MF2_MASK + 0U, // PseudoVFWNMACC_VV_MF4 + 0U, // PseudoVFWNMACC_VV_MF4_MASK + 0U, // PseudoVFWNMSAC_VFPR16_M1 + 0U, // PseudoVFWNMSAC_VFPR16_M1_MASK + 0U, // PseudoVFWNMSAC_VFPR16_M2 + 0U, // PseudoVFWNMSAC_VFPR16_M2_MASK + 0U, // PseudoVFWNMSAC_VFPR16_M4 + 0U, // PseudoVFWNMSAC_VFPR16_M4_MASK + 0U, // PseudoVFWNMSAC_VFPR16_MF2 + 0U, // PseudoVFWNMSAC_VFPR16_MF2_MASK + 0U, // PseudoVFWNMSAC_VFPR16_MF4 + 0U, // PseudoVFWNMSAC_VFPR16_MF4_MASK + 0U, // PseudoVFWNMSAC_VFPR32_M1 + 0U, // PseudoVFWNMSAC_VFPR32_M1_MASK + 0U, // PseudoVFWNMSAC_VFPR32_M2 + 0U, // PseudoVFWNMSAC_VFPR32_M2_MASK + 0U, // PseudoVFWNMSAC_VFPR32_M4 + 0U, // PseudoVFWNMSAC_VFPR32_M4_MASK + 0U, // PseudoVFWNMSAC_VFPR32_MF2 + 0U, // PseudoVFWNMSAC_VFPR32_MF2_MASK + 0U, // PseudoVFWNMSAC_VV_M1 + 0U, // PseudoVFWNMSAC_VV_M1_MASK + 0U, // PseudoVFWNMSAC_VV_M2 + 0U, // PseudoVFWNMSAC_VV_M2_MASK + 0U, // PseudoVFWNMSAC_VV_M4 + 0U, // PseudoVFWNMSAC_VV_M4_MASK + 0U, // PseudoVFWNMSAC_VV_MF2 + 0U, // PseudoVFWNMSAC_VV_MF2_MASK + 0U, // PseudoVFWNMSAC_VV_MF4 + 0U, // PseudoVFWNMSAC_VV_MF4_MASK + 0U, // PseudoVFWREDOSUM_VS_M1_E16 + 0U, // PseudoVFWREDOSUM_VS_M1_E16_MASK + 0U, // PseudoVFWREDOSUM_VS_M1_E32 + 0U, // PseudoVFWREDOSUM_VS_M1_E32_MASK + 0U, // PseudoVFWREDOSUM_VS_M2_E16 + 0U, // PseudoVFWREDOSUM_VS_M2_E16_MASK + 0U, // PseudoVFWREDOSUM_VS_M2_E32 + 0U, // PseudoVFWREDOSUM_VS_M2_E32_MASK + 0U, // PseudoVFWREDOSUM_VS_M4_E16 + 0U, // PseudoVFWREDOSUM_VS_M4_E16_MASK + 0U, // PseudoVFWREDOSUM_VS_M4_E32 + 0U, // PseudoVFWREDOSUM_VS_M4_E32_MASK + 0U, // PseudoVFWREDOSUM_VS_M8_E16 + 0U, // PseudoVFWREDOSUM_VS_M8_E16_MASK + 0U, // PseudoVFWREDOSUM_VS_M8_E32 + 0U, // PseudoVFWREDOSUM_VS_M8_E32_MASK + 0U, // PseudoVFWREDOSUM_VS_MF2_E16 + 0U, // PseudoVFWREDOSUM_VS_MF2_E16_MASK + 0U, // PseudoVFWREDOSUM_VS_MF2_E32 + 0U, // PseudoVFWREDOSUM_VS_MF2_E32_MASK + 0U, // PseudoVFWREDOSUM_VS_MF4_E16 + 0U, // PseudoVFWREDOSUM_VS_MF4_E16_MASK + 0U, // PseudoVFWREDUSUM_VS_M1_E16 + 0U, // PseudoVFWREDUSUM_VS_M1_E16_MASK + 0U, // PseudoVFWREDUSUM_VS_M1_E32 + 0U, // PseudoVFWREDUSUM_VS_M1_E32_MASK + 0U, // PseudoVFWREDUSUM_VS_M2_E16 + 0U, // PseudoVFWREDUSUM_VS_M2_E16_MASK + 0U, // PseudoVFWREDUSUM_VS_M2_E32 + 0U, // PseudoVFWREDUSUM_VS_M2_E32_MASK + 0U, // PseudoVFWREDUSUM_VS_M4_E16 + 0U, // PseudoVFWREDUSUM_VS_M4_E16_MASK + 0U, // PseudoVFWREDUSUM_VS_M4_E32 + 0U, // PseudoVFWREDUSUM_VS_M4_E32_MASK + 0U, // PseudoVFWREDUSUM_VS_M8_E16 + 0U, // PseudoVFWREDUSUM_VS_M8_E16_MASK + 0U, // PseudoVFWREDUSUM_VS_M8_E32 + 0U, // PseudoVFWREDUSUM_VS_M8_E32_MASK + 0U, // PseudoVFWREDUSUM_VS_MF2_E16 + 0U, // PseudoVFWREDUSUM_VS_MF2_E16_MASK + 0U, // PseudoVFWREDUSUM_VS_MF2_E32 + 0U, // PseudoVFWREDUSUM_VS_MF2_E32_MASK + 0U, // PseudoVFWREDUSUM_VS_MF4_E16 + 0U, // PseudoVFWREDUSUM_VS_MF4_E16_MASK + 0U, // PseudoVFWSUB_VFPR16_M1 + 0U, // PseudoVFWSUB_VFPR16_M1_MASK + 0U, // PseudoVFWSUB_VFPR16_M2 + 0U, // PseudoVFWSUB_VFPR16_M2_MASK + 0U, // PseudoVFWSUB_VFPR16_M4 + 0U, // PseudoVFWSUB_VFPR16_M4_MASK + 0U, // PseudoVFWSUB_VFPR16_MF2 + 0U, // PseudoVFWSUB_VFPR16_MF2_MASK + 0U, // PseudoVFWSUB_VFPR16_MF4 + 0U, // PseudoVFWSUB_VFPR16_MF4_MASK + 0U, // PseudoVFWSUB_VFPR32_M1 + 0U, // PseudoVFWSUB_VFPR32_M1_MASK + 0U, // PseudoVFWSUB_VFPR32_M2 + 0U, // PseudoVFWSUB_VFPR32_M2_MASK + 0U, // PseudoVFWSUB_VFPR32_M4 + 0U, // PseudoVFWSUB_VFPR32_M4_MASK + 0U, // PseudoVFWSUB_VFPR32_MF2 + 0U, // PseudoVFWSUB_VFPR32_MF2_MASK + 0U, // PseudoVFWSUB_VV_M1 + 0U, // PseudoVFWSUB_VV_M1_MASK + 0U, // PseudoVFWSUB_VV_M2 + 0U, // PseudoVFWSUB_VV_M2_MASK + 0U, // PseudoVFWSUB_VV_M4 + 0U, // PseudoVFWSUB_VV_M4_MASK + 0U, // PseudoVFWSUB_VV_MF2 + 0U, // PseudoVFWSUB_VV_MF2_MASK + 0U, // PseudoVFWSUB_VV_MF4 + 0U, // PseudoVFWSUB_VV_MF4_MASK + 0U, // PseudoVFWSUB_WFPR16_M1 + 0U, // PseudoVFWSUB_WFPR16_M1_MASK + 0U, // PseudoVFWSUB_WFPR16_M2 + 0U, // PseudoVFWSUB_WFPR16_M2_MASK + 0U, // PseudoVFWSUB_WFPR16_M4 + 0U, // PseudoVFWSUB_WFPR16_M4_MASK + 0U, // PseudoVFWSUB_WFPR16_MF2 + 0U, // PseudoVFWSUB_WFPR16_MF2_MASK + 0U, // PseudoVFWSUB_WFPR16_MF4 + 0U, // PseudoVFWSUB_WFPR16_MF4_MASK + 0U, // PseudoVFWSUB_WFPR32_M1 + 0U, // PseudoVFWSUB_WFPR32_M1_MASK + 0U, // PseudoVFWSUB_WFPR32_M2 + 0U, // PseudoVFWSUB_WFPR32_M2_MASK + 0U, // PseudoVFWSUB_WFPR32_M4 + 0U, // PseudoVFWSUB_WFPR32_M4_MASK + 0U, // PseudoVFWSUB_WFPR32_MF2 + 0U, // PseudoVFWSUB_WFPR32_MF2_MASK + 0U, // PseudoVFWSUB_WV_M1 + 0U, // PseudoVFWSUB_WV_M1_MASK + 0U, // PseudoVFWSUB_WV_M1_MASK_TIED + 0U, // PseudoVFWSUB_WV_M1_TIED + 0U, // PseudoVFWSUB_WV_M2 + 0U, // PseudoVFWSUB_WV_M2_MASK + 0U, // PseudoVFWSUB_WV_M2_MASK_TIED + 0U, // PseudoVFWSUB_WV_M2_TIED + 0U, // PseudoVFWSUB_WV_M4 + 0U, // PseudoVFWSUB_WV_M4_MASK + 0U, // PseudoVFWSUB_WV_M4_MASK_TIED + 0U, // PseudoVFWSUB_WV_M4_TIED + 0U, // PseudoVFWSUB_WV_MF2 + 0U, // PseudoVFWSUB_WV_MF2_MASK + 0U, // PseudoVFWSUB_WV_MF2_MASK_TIED + 0U, // PseudoVFWSUB_WV_MF2_TIED + 0U, // PseudoVFWSUB_WV_MF4 + 0U, // PseudoVFWSUB_WV_MF4_MASK + 0U, // PseudoVFWSUB_WV_MF4_MASK_TIED + 0U, // PseudoVFWSUB_WV_MF4_TIED + 0U, // PseudoVGHSH_VV_M1 + 0U, // PseudoVGHSH_VV_M2 + 0U, // PseudoVGHSH_VV_M4 + 0U, // PseudoVGHSH_VV_M8 + 0U, // PseudoVGHSH_VV_MF2 + 0U, // PseudoVGMUL_VV_M1 + 0U, // PseudoVGMUL_VV_M2 + 0U, // PseudoVGMUL_VV_M4 + 0U, // PseudoVGMUL_VV_M8 + 0U, // PseudoVGMUL_VV_MF2 + 0U, // PseudoVID_V_M1 + 0U, // PseudoVID_V_M1_MASK + 0U, // PseudoVID_V_M2 + 0U, // PseudoVID_V_M2_MASK + 0U, // PseudoVID_V_M4 + 0U, // PseudoVID_V_M4_MASK + 0U, // PseudoVID_V_M8 + 0U, // PseudoVID_V_M8_MASK + 0U, // PseudoVID_V_MF2 + 0U, // PseudoVID_V_MF2_MASK + 0U, // PseudoVID_V_MF4 + 0U, // PseudoVID_V_MF4_MASK + 0U, // PseudoVID_V_MF8 + 0U, // PseudoVID_V_MF8_MASK + 0U, // PseudoVIOTA_M_M1 + 0U, // PseudoVIOTA_M_M1_MASK + 0U, // PseudoVIOTA_M_M2 + 0U, // PseudoVIOTA_M_M2_MASK + 0U, // PseudoVIOTA_M_M4 + 0U, // PseudoVIOTA_M_M4_MASK + 0U, // PseudoVIOTA_M_M8 + 0U, // PseudoVIOTA_M_M8_MASK + 0U, // PseudoVIOTA_M_MF2 + 0U, // PseudoVIOTA_M_MF2_MASK + 0U, // PseudoVIOTA_M_MF4 + 0U, // PseudoVIOTA_M_MF4_MASK + 0U, // PseudoVIOTA_M_MF8 + 0U, // PseudoVIOTA_M_MF8_MASK + 0U, // PseudoVLE16FF_V_M1 + 0U, // PseudoVLE16FF_V_M1_MASK + 0U, // PseudoVLE16FF_V_M2 + 0U, // PseudoVLE16FF_V_M2_MASK + 0U, // PseudoVLE16FF_V_M4 + 0U, // PseudoVLE16FF_V_M4_MASK + 0U, // PseudoVLE16FF_V_M8 + 0U, // PseudoVLE16FF_V_M8_MASK + 0U, // PseudoVLE16FF_V_MF2 + 0U, // PseudoVLE16FF_V_MF2_MASK + 0U, // PseudoVLE16FF_V_MF4 + 0U, // PseudoVLE16FF_V_MF4_MASK + 0U, // PseudoVLE16_V_M1 + 0U, // PseudoVLE16_V_M1_MASK + 0U, // PseudoVLE16_V_M2 + 0U, // PseudoVLE16_V_M2_MASK + 0U, // PseudoVLE16_V_M4 + 0U, // PseudoVLE16_V_M4_MASK + 0U, // PseudoVLE16_V_M8 + 0U, // PseudoVLE16_V_M8_MASK + 0U, // PseudoVLE16_V_MF2 + 0U, // PseudoVLE16_V_MF2_MASK + 0U, // PseudoVLE16_V_MF4 + 0U, // PseudoVLE16_V_MF4_MASK + 0U, // PseudoVLE32FF_V_M1 + 0U, // PseudoVLE32FF_V_M1_MASK + 0U, // PseudoVLE32FF_V_M2 + 0U, // PseudoVLE32FF_V_M2_MASK + 0U, // PseudoVLE32FF_V_M4 + 0U, // PseudoVLE32FF_V_M4_MASK + 0U, // PseudoVLE32FF_V_M8 + 0U, // PseudoVLE32FF_V_M8_MASK + 0U, // PseudoVLE32FF_V_MF2 + 0U, // PseudoVLE32FF_V_MF2_MASK + 0U, // PseudoVLE32_V_M1 + 0U, // PseudoVLE32_V_M1_MASK + 0U, // PseudoVLE32_V_M2 + 0U, // PseudoVLE32_V_M2_MASK + 0U, // PseudoVLE32_V_M4 + 0U, // PseudoVLE32_V_M4_MASK + 0U, // PseudoVLE32_V_M8 + 0U, // PseudoVLE32_V_M8_MASK + 0U, // PseudoVLE32_V_MF2 + 0U, // PseudoVLE32_V_MF2_MASK + 0U, // PseudoVLE64FF_V_M1 + 0U, // PseudoVLE64FF_V_M1_MASK + 0U, // PseudoVLE64FF_V_M2 + 0U, // PseudoVLE64FF_V_M2_MASK + 0U, // PseudoVLE64FF_V_M4 + 0U, // PseudoVLE64FF_V_M4_MASK + 0U, // PseudoVLE64FF_V_M8 + 0U, // PseudoVLE64FF_V_M8_MASK + 0U, // PseudoVLE64_V_M1 + 0U, // PseudoVLE64_V_M1_MASK + 0U, // PseudoVLE64_V_M2 + 0U, // PseudoVLE64_V_M2_MASK + 0U, // PseudoVLE64_V_M4 + 0U, // PseudoVLE64_V_M4_MASK + 0U, // PseudoVLE64_V_M8 + 0U, // PseudoVLE64_V_M8_MASK + 0U, // PseudoVLE8FF_V_M1 + 0U, // PseudoVLE8FF_V_M1_MASK + 0U, // PseudoVLE8FF_V_M2 + 0U, // PseudoVLE8FF_V_M2_MASK + 0U, // PseudoVLE8FF_V_M4 + 0U, // PseudoVLE8FF_V_M4_MASK + 0U, // PseudoVLE8FF_V_M8 + 0U, // PseudoVLE8FF_V_M8_MASK + 0U, // PseudoVLE8FF_V_MF2 + 0U, // PseudoVLE8FF_V_MF2_MASK + 0U, // PseudoVLE8FF_V_MF4 + 0U, // PseudoVLE8FF_V_MF4_MASK + 0U, // PseudoVLE8FF_V_MF8 + 0U, // PseudoVLE8FF_V_MF8_MASK + 0U, // PseudoVLE8_V_M1 + 0U, // PseudoVLE8_V_M1_MASK + 0U, // PseudoVLE8_V_M2 + 0U, // PseudoVLE8_V_M2_MASK + 0U, // PseudoVLE8_V_M4 + 0U, // PseudoVLE8_V_M4_MASK + 0U, // PseudoVLE8_V_M8 + 0U, // PseudoVLE8_V_M8_MASK + 0U, // PseudoVLE8_V_MF2 + 0U, // PseudoVLE8_V_MF2_MASK + 0U, // PseudoVLE8_V_MF4 + 0U, // PseudoVLE8_V_MF4_MASK + 0U, // PseudoVLE8_V_MF8 + 0U, // PseudoVLE8_V_MF8_MASK + 0U, // PseudoVLM_V_B1 + 0U, // PseudoVLM_V_B16 + 0U, // PseudoVLM_V_B2 + 0U, // PseudoVLM_V_B32 + 0U, // PseudoVLM_V_B4 + 0U, // PseudoVLM_V_B64 + 0U, // PseudoVLM_V_B8 + 0U, // PseudoVLOXEI16_V_M1_M1 + 0U, // PseudoVLOXEI16_V_M1_M1_MASK + 0U, // PseudoVLOXEI16_V_M1_M2 + 0U, // PseudoVLOXEI16_V_M1_M2_MASK + 0U, // PseudoVLOXEI16_V_M1_M4 + 0U, // PseudoVLOXEI16_V_M1_M4_MASK + 0U, // PseudoVLOXEI16_V_M1_MF2 + 0U, // PseudoVLOXEI16_V_M1_MF2_MASK + 0U, // PseudoVLOXEI16_V_M2_M1 + 0U, // PseudoVLOXEI16_V_M2_M1_MASK + 0U, // PseudoVLOXEI16_V_M2_M2 + 0U, // PseudoVLOXEI16_V_M2_M2_MASK + 0U, // PseudoVLOXEI16_V_M2_M4 + 0U, // PseudoVLOXEI16_V_M2_M4_MASK + 0U, // PseudoVLOXEI16_V_M2_M8 + 0U, // PseudoVLOXEI16_V_M2_M8_MASK + 0U, // PseudoVLOXEI16_V_M4_M2 + 0U, // PseudoVLOXEI16_V_M4_M2_MASK + 0U, // PseudoVLOXEI16_V_M4_M4 + 0U, // PseudoVLOXEI16_V_M4_M4_MASK + 0U, // PseudoVLOXEI16_V_M4_M8 + 0U, // PseudoVLOXEI16_V_M4_M8_MASK + 0U, // PseudoVLOXEI16_V_M8_M4 + 0U, // PseudoVLOXEI16_V_M8_M4_MASK + 0U, // PseudoVLOXEI16_V_M8_M8 + 0U, // PseudoVLOXEI16_V_M8_M8_MASK + 0U, // PseudoVLOXEI16_V_MF2_M1 + 0U, // PseudoVLOXEI16_V_MF2_M1_MASK + 0U, // PseudoVLOXEI16_V_MF2_M2 + 0U, // PseudoVLOXEI16_V_MF2_M2_MASK + 0U, // PseudoVLOXEI16_V_MF2_MF2 + 0U, // PseudoVLOXEI16_V_MF2_MF2_MASK + 0U, // PseudoVLOXEI16_V_MF2_MF4 + 0U, // PseudoVLOXEI16_V_MF2_MF4_MASK + 0U, // PseudoVLOXEI16_V_MF4_M1 + 0U, // PseudoVLOXEI16_V_MF4_M1_MASK + 0U, // PseudoVLOXEI16_V_MF4_MF2 + 0U, // PseudoVLOXEI16_V_MF4_MF2_MASK + 0U, // PseudoVLOXEI16_V_MF4_MF4 + 0U, // PseudoVLOXEI16_V_MF4_MF4_MASK + 0U, // PseudoVLOXEI16_V_MF4_MF8 + 0U, // PseudoVLOXEI16_V_MF4_MF8_MASK + 0U, // PseudoVLOXEI32_V_M1_M1 + 0U, // PseudoVLOXEI32_V_M1_M1_MASK + 0U, // PseudoVLOXEI32_V_M1_M2 + 0U, // PseudoVLOXEI32_V_M1_M2_MASK + 0U, // PseudoVLOXEI32_V_M1_MF2 + 0U, // PseudoVLOXEI32_V_M1_MF2_MASK + 0U, // PseudoVLOXEI32_V_M1_MF4 + 0U, // PseudoVLOXEI32_V_M1_MF4_MASK + 0U, // PseudoVLOXEI32_V_M2_M1 + 0U, // PseudoVLOXEI32_V_M2_M1_MASK + 0U, // PseudoVLOXEI32_V_M2_M2 + 0U, // PseudoVLOXEI32_V_M2_M2_MASK + 0U, // PseudoVLOXEI32_V_M2_M4 + 0U, // PseudoVLOXEI32_V_M2_M4_MASK + 0U, // PseudoVLOXEI32_V_M2_MF2 + 0U, // PseudoVLOXEI32_V_M2_MF2_MASK + 0U, // PseudoVLOXEI32_V_M4_M1 + 0U, // PseudoVLOXEI32_V_M4_M1_MASK + 0U, // PseudoVLOXEI32_V_M4_M2 + 0U, // PseudoVLOXEI32_V_M4_M2_MASK + 0U, // PseudoVLOXEI32_V_M4_M4 + 0U, // PseudoVLOXEI32_V_M4_M4_MASK + 0U, // PseudoVLOXEI32_V_M4_M8 + 0U, // PseudoVLOXEI32_V_M4_M8_MASK + 0U, // PseudoVLOXEI32_V_M8_M2 + 0U, // PseudoVLOXEI32_V_M8_M2_MASK + 0U, // PseudoVLOXEI32_V_M8_M4 + 0U, // PseudoVLOXEI32_V_M8_M4_MASK + 0U, // PseudoVLOXEI32_V_M8_M8 + 0U, // PseudoVLOXEI32_V_M8_M8_MASK + 0U, // PseudoVLOXEI32_V_MF2_M1 + 0U, // PseudoVLOXEI32_V_MF2_M1_MASK + 0U, // PseudoVLOXEI32_V_MF2_MF2 + 0U, // PseudoVLOXEI32_V_MF2_MF2_MASK + 0U, // PseudoVLOXEI32_V_MF2_MF4 + 0U, // PseudoVLOXEI32_V_MF2_MF4_MASK + 0U, // PseudoVLOXEI32_V_MF2_MF8 + 0U, // PseudoVLOXEI32_V_MF2_MF8_MASK + 0U, // PseudoVLOXEI64_V_M1_M1 + 0U, // PseudoVLOXEI64_V_M1_M1_MASK + 0U, // PseudoVLOXEI64_V_M1_MF2 + 0U, // PseudoVLOXEI64_V_M1_MF2_MASK + 0U, // PseudoVLOXEI64_V_M1_MF4 + 0U, // PseudoVLOXEI64_V_M1_MF4_MASK + 0U, // PseudoVLOXEI64_V_M1_MF8 + 0U, // PseudoVLOXEI64_V_M1_MF8_MASK + 0U, // PseudoVLOXEI64_V_M2_M1 + 0U, // PseudoVLOXEI64_V_M2_M1_MASK + 0U, // PseudoVLOXEI64_V_M2_M2 + 0U, // PseudoVLOXEI64_V_M2_M2_MASK + 0U, // PseudoVLOXEI64_V_M2_MF2 + 0U, // PseudoVLOXEI64_V_M2_MF2_MASK + 0U, // PseudoVLOXEI64_V_M2_MF4 + 0U, // PseudoVLOXEI64_V_M2_MF4_MASK + 0U, // PseudoVLOXEI64_V_M4_M1 + 0U, // PseudoVLOXEI64_V_M4_M1_MASK + 0U, // PseudoVLOXEI64_V_M4_M2 + 0U, // PseudoVLOXEI64_V_M4_M2_MASK + 0U, // PseudoVLOXEI64_V_M4_M4 + 0U, // PseudoVLOXEI64_V_M4_M4_MASK + 0U, // PseudoVLOXEI64_V_M4_MF2 + 0U, // PseudoVLOXEI64_V_M4_MF2_MASK + 0U, // PseudoVLOXEI64_V_M8_M1 + 0U, // PseudoVLOXEI64_V_M8_M1_MASK + 0U, // PseudoVLOXEI64_V_M8_M2 + 0U, // PseudoVLOXEI64_V_M8_M2_MASK + 0U, // PseudoVLOXEI64_V_M8_M4 + 0U, // PseudoVLOXEI64_V_M8_M4_MASK + 0U, // PseudoVLOXEI64_V_M8_M8 + 0U, // PseudoVLOXEI64_V_M8_M8_MASK + 0U, // PseudoVLOXEI8_V_M1_M1 + 0U, // PseudoVLOXEI8_V_M1_M1_MASK + 0U, // PseudoVLOXEI8_V_M1_M2 + 0U, // PseudoVLOXEI8_V_M1_M2_MASK + 0U, // PseudoVLOXEI8_V_M1_M4 + 0U, // PseudoVLOXEI8_V_M1_M4_MASK + 0U, // PseudoVLOXEI8_V_M1_M8 + 0U, // PseudoVLOXEI8_V_M1_M8_MASK + 0U, // PseudoVLOXEI8_V_M2_M2 + 0U, // PseudoVLOXEI8_V_M2_M2_MASK + 0U, // PseudoVLOXEI8_V_M2_M4 + 0U, // PseudoVLOXEI8_V_M2_M4_MASK + 0U, // PseudoVLOXEI8_V_M2_M8 + 0U, // PseudoVLOXEI8_V_M2_M8_MASK + 0U, // PseudoVLOXEI8_V_M4_M4 + 0U, // PseudoVLOXEI8_V_M4_M4_MASK + 0U, // PseudoVLOXEI8_V_M4_M8 + 0U, // PseudoVLOXEI8_V_M4_M8_MASK + 0U, // PseudoVLOXEI8_V_M8_M8 + 0U, // PseudoVLOXEI8_V_M8_M8_MASK + 0U, // PseudoVLOXEI8_V_MF2_M1 + 0U, // PseudoVLOXEI8_V_MF2_M1_MASK + 0U, // PseudoVLOXEI8_V_MF2_M2 + 0U, // PseudoVLOXEI8_V_MF2_M2_MASK + 0U, // PseudoVLOXEI8_V_MF2_M4 + 0U, // PseudoVLOXEI8_V_MF2_M4_MASK + 0U, // PseudoVLOXEI8_V_MF2_MF2 + 0U, // PseudoVLOXEI8_V_MF2_MF2_MASK + 0U, // PseudoVLOXEI8_V_MF4_M1 + 0U, // PseudoVLOXEI8_V_MF4_M1_MASK + 0U, // PseudoVLOXEI8_V_MF4_M2 + 0U, // PseudoVLOXEI8_V_MF4_M2_MASK + 0U, // PseudoVLOXEI8_V_MF4_MF2 + 0U, // PseudoVLOXEI8_V_MF4_MF2_MASK + 0U, // PseudoVLOXEI8_V_MF4_MF4 + 0U, // PseudoVLOXEI8_V_MF4_MF4_MASK + 0U, // PseudoVLOXEI8_V_MF8_M1 + 0U, // PseudoVLOXEI8_V_MF8_M1_MASK + 0U, // PseudoVLOXEI8_V_MF8_MF2 + 0U, // PseudoVLOXEI8_V_MF8_MF2_MASK + 0U, // PseudoVLOXEI8_V_MF8_MF4 + 0U, // PseudoVLOXEI8_V_MF8_MF4_MASK + 0U, // PseudoVLOXEI8_V_MF8_MF8 + 0U, // PseudoVLOXEI8_V_MF8_MF8_MASK + 0U, // PseudoVLOXSEG2EI16_V_M1_M1 + 0U, // PseudoVLOXSEG2EI16_V_M1_M1_MASK + 0U, // PseudoVLOXSEG2EI16_V_M1_M2 + 0U, // PseudoVLOXSEG2EI16_V_M1_M2_MASK + 0U, // PseudoVLOXSEG2EI16_V_M1_M4 + 0U, // PseudoVLOXSEG2EI16_V_M1_M4_MASK + 0U, // PseudoVLOXSEG2EI16_V_M1_MF2 + 0U, // PseudoVLOXSEG2EI16_V_M1_MF2_MASK + 0U, // PseudoVLOXSEG2EI16_V_M2_M1 + 0U, // PseudoVLOXSEG2EI16_V_M2_M1_MASK + 0U, // PseudoVLOXSEG2EI16_V_M2_M2 + 0U, // PseudoVLOXSEG2EI16_V_M2_M2_MASK + 0U, // PseudoVLOXSEG2EI16_V_M2_M4 + 0U, // PseudoVLOXSEG2EI16_V_M2_M4_MASK + 0U, // PseudoVLOXSEG2EI16_V_M4_M2 + 0U, // PseudoVLOXSEG2EI16_V_M4_M2_MASK + 0U, // PseudoVLOXSEG2EI16_V_M4_M4 + 0U, // PseudoVLOXSEG2EI16_V_M4_M4_MASK + 0U, // PseudoVLOXSEG2EI16_V_M8_M4 + 0U, // PseudoVLOXSEG2EI16_V_M8_M4_MASK + 0U, // PseudoVLOXSEG2EI16_V_MF2_M1 + 0U, // PseudoVLOXSEG2EI16_V_MF2_M1_MASK + 0U, // PseudoVLOXSEG2EI16_V_MF2_M2 + 0U, // PseudoVLOXSEG2EI16_V_MF2_M2_MASK + 0U, // PseudoVLOXSEG2EI16_V_MF2_MF2 + 0U, // PseudoVLOXSEG2EI16_V_MF2_MF2_MASK + 0U, // PseudoVLOXSEG2EI16_V_MF2_MF4 + 0U, // PseudoVLOXSEG2EI16_V_MF2_MF4_MASK + 0U, // PseudoVLOXSEG2EI16_V_MF4_M1 + 0U, // PseudoVLOXSEG2EI16_V_MF4_M1_MASK + 0U, // PseudoVLOXSEG2EI16_V_MF4_MF2 + 0U, // PseudoVLOXSEG2EI16_V_MF4_MF2_MASK + 0U, // PseudoVLOXSEG2EI16_V_MF4_MF4 + 0U, // PseudoVLOXSEG2EI16_V_MF4_MF4_MASK + 0U, // PseudoVLOXSEG2EI16_V_MF4_MF8 + 0U, // PseudoVLOXSEG2EI16_V_MF4_MF8_MASK + 0U, // PseudoVLOXSEG2EI32_V_M1_M1 + 0U, // PseudoVLOXSEG2EI32_V_M1_M1_MASK + 0U, // PseudoVLOXSEG2EI32_V_M1_M2 + 0U, // PseudoVLOXSEG2EI32_V_M1_M2_MASK + 0U, // PseudoVLOXSEG2EI32_V_M1_MF2 + 0U, // PseudoVLOXSEG2EI32_V_M1_MF2_MASK + 0U, // PseudoVLOXSEG2EI32_V_M1_MF4 + 0U, // PseudoVLOXSEG2EI32_V_M1_MF4_MASK + 0U, // PseudoVLOXSEG2EI32_V_M2_M1 + 0U, // PseudoVLOXSEG2EI32_V_M2_M1_MASK + 0U, // PseudoVLOXSEG2EI32_V_M2_M2 + 0U, // PseudoVLOXSEG2EI32_V_M2_M2_MASK + 0U, // PseudoVLOXSEG2EI32_V_M2_M4 + 0U, // PseudoVLOXSEG2EI32_V_M2_M4_MASK + 0U, // PseudoVLOXSEG2EI32_V_M2_MF2 + 0U, // PseudoVLOXSEG2EI32_V_M2_MF2_MASK + 0U, // PseudoVLOXSEG2EI32_V_M4_M1 + 0U, // PseudoVLOXSEG2EI32_V_M4_M1_MASK + 0U, // PseudoVLOXSEG2EI32_V_M4_M2 + 0U, // PseudoVLOXSEG2EI32_V_M4_M2_MASK + 0U, // PseudoVLOXSEG2EI32_V_M4_M4 + 0U, // PseudoVLOXSEG2EI32_V_M4_M4_MASK + 0U, // PseudoVLOXSEG2EI32_V_M8_M2 + 0U, // PseudoVLOXSEG2EI32_V_M8_M2_MASK + 0U, // PseudoVLOXSEG2EI32_V_M8_M4 + 0U, // PseudoVLOXSEG2EI32_V_M8_M4_MASK + 0U, // PseudoVLOXSEG2EI32_V_MF2_M1 + 0U, // PseudoVLOXSEG2EI32_V_MF2_M1_MASK + 0U, // PseudoVLOXSEG2EI32_V_MF2_MF2 + 0U, // PseudoVLOXSEG2EI32_V_MF2_MF2_MASK + 0U, // PseudoVLOXSEG2EI32_V_MF2_MF4 + 0U, // PseudoVLOXSEG2EI32_V_MF2_MF4_MASK + 0U, // PseudoVLOXSEG2EI32_V_MF2_MF8 + 0U, // PseudoVLOXSEG2EI32_V_MF2_MF8_MASK + 0U, // PseudoVLOXSEG2EI64_V_M1_M1 + 0U, // PseudoVLOXSEG2EI64_V_M1_M1_MASK + 0U, // PseudoVLOXSEG2EI64_V_M1_MF2 + 0U, // PseudoVLOXSEG2EI64_V_M1_MF2_MASK + 0U, // PseudoVLOXSEG2EI64_V_M1_MF4 + 0U, // PseudoVLOXSEG2EI64_V_M1_MF4_MASK + 0U, // PseudoVLOXSEG2EI64_V_M1_MF8 + 0U, // PseudoVLOXSEG2EI64_V_M1_MF8_MASK + 0U, // PseudoVLOXSEG2EI64_V_M2_M1 + 0U, // PseudoVLOXSEG2EI64_V_M2_M1_MASK + 0U, // PseudoVLOXSEG2EI64_V_M2_M2 + 0U, // PseudoVLOXSEG2EI64_V_M2_M2_MASK + 0U, // PseudoVLOXSEG2EI64_V_M2_MF2 + 0U, // PseudoVLOXSEG2EI64_V_M2_MF2_MASK + 0U, // PseudoVLOXSEG2EI64_V_M2_MF4 + 0U, // PseudoVLOXSEG2EI64_V_M2_MF4_MASK + 0U, // PseudoVLOXSEG2EI64_V_M4_M1 + 0U, // PseudoVLOXSEG2EI64_V_M4_M1_MASK + 0U, // PseudoVLOXSEG2EI64_V_M4_M2 + 0U, // PseudoVLOXSEG2EI64_V_M4_M2_MASK + 0U, // PseudoVLOXSEG2EI64_V_M4_M4 + 0U, // PseudoVLOXSEG2EI64_V_M4_M4_MASK + 0U, // PseudoVLOXSEG2EI64_V_M4_MF2 + 0U, // PseudoVLOXSEG2EI64_V_M4_MF2_MASK + 0U, // PseudoVLOXSEG2EI64_V_M8_M1 + 0U, // PseudoVLOXSEG2EI64_V_M8_M1_MASK + 0U, // PseudoVLOXSEG2EI64_V_M8_M2 + 0U, // PseudoVLOXSEG2EI64_V_M8_M2_MASK + 0U, // PseudoVLOXSEG2EI64_V_M8_M4 + 0U, // PseudoVLOXSEG2EI64_V_M8_M4_MASK + 0U, // PseudoVLOXSEG2EI8_V_M1_M1 + 0U, // PseudoVLOXSEG2EI8_V_M1_M1_MASK + 0U, // PseudoVLOXSEG2EI8_V_M1_M2 + 0U, // PseudoVLOXSEG2EI8_V_M1_M2_MASK + 0U, // PseudoVLOXSEG2EI8_V_M1_M4 + 0U, // PseudoVLOXSEG2EI8_V_M1_M4_MASK + 0U, // PseudoVLOXSEG2EI8_V_M2_M2 + 0U, // PseudoVLOXSEG2EI8_V_M2_M2_MASK + 0U, // PseudoVLOXSEG2EI8_V_M2_M4 + 0U, // PseudoVLOXSEG2EI8_V_M2_M4_MASK + 0U, // PseudoVLOXSEG2EI8_V_M4_M4 + 0U, // PseudoVLOXSEG2EI8_V_M4_M4_MASK + 0U, // PseudoVLOXSEG2EI8_V_MF2_M1 + 0U, // PseudoVLOXSEG2EI8_V_MF2_M1_MASK + 0U, // PseudoVLOXSEG2EI8_V_MF2_M2 + 0U, // PseudoVLOXSEG2EI8_V_MF2_M2_MASK + 0U, // PseudoVLOXSEG2EI8_V_MF2_M4 + 0U, // PseudoVLOXSEG2EI8_V_MF2_M4_MASK + 0U, // PseudoVLOXSEG2EI8_V_MF2_MF2 + 0U, // PseudoVLOXSEG2EI8_V_MF2_MF2_MASK + 0U, // PseudoVLOXSEG2EI8_V_MF4_M1 + 0U, // PseudoVLOXSEG2EI8_V_MF4_M1_MASK + 0U, // PseudoVLOXSEG2EI8_V_MF4_M2 + 0U, // PseudoVLOXSEG2EI8_V_MF4_M2_MASK + 0U, // PseudoVLOXSEG2EI8_V_MF4_MF2 + 0U, // PseudoVLOXSEG2EI8_V_MF4_MF2_MASK + 0U, // PseudoVLOXSEG2EI8_V_MF4_MF4 + 0U, // PseudoVLOXSEG2EI8_V_MF4_MF4_MASK + 0U, // PseudoVLOXSEG2EI8_V_MF8_M1 + 0U, // PseudoVLOXSEG2EI8_V_MF8_M1_MASK + 0U, // PseudoVLOXSEG2EI8_V_MF8_MF2 + 0U, // PseudoVLOXSEG2EI8_V_MF8_MF2_MASK + 0U, // PseudoVLOXSEG2EI8_V_MF8_MF4 + 0U, // PseudoVLOXSEG2EI8_V_MF8_MF4_MASK + 0U, // PseudoVLOXSEG2EI8_V_MF8_MF8 + 0U, // PseudoVLOXSEG2EI8_V_MF8_MF8_MASK + 0U, // PseudoVLOXSEG3EI16_V_M1_M1 + 0U, // PseudoVLOXSEG3EI16_V_M1_M1_MASK + 0U, // PseudoVLOXSEG3EI16_V_M1_M2 + 0U, // PseudoVLOXSEG3EI16_V_M1_M2_MASK + 0U, // PseudoVLOXSEG3EI16_V_M1_MF2 + 0U, // PseudoVLOXSEG3EI16_V_M1_MF2_MASK + 0U, // PseudoVLOXSEG3EI16_V_M2_M1 + 0U, // PseudoVLOXSEG3EI16_V_M2_M1_MASK + 0U, // PseudoVLOXSEG3EI16_V_M2_M2 + 0U, // PseudoVLOXSEG3EI16_V_M2_M2_MASK + 0U, // PseudoVLOXSEG3EI16_V_M4_M2 + 0U, // PseudoVLOXSEG3EI16_V_M4_M2_MASK + 0U, // PseudoVLOXSEG3EI16_V_MF2_M1 + 0U, // PseudoVLOXSEG3EI16_V_MF2_M1_MASK + 0U, // PseudoVLOXSEG3EI16_V_MF2_M2 + 0U, // PseudoVLOXSEG3EI16_V_MF2_M2_MASK + 0U, // PseudoVLOXSEG3EI16_V_MF2_MF2 + 0U, // PseudoVLOXSEG3EI16_V_MF2_MF2_MASK + 0U, // PseudoVLOXSEG3EI16_V_MF2_MF4 + 0U, // PseudoVLOXSEG3EI16_V_MF2_MF4_MASK + 0U, // PseudoVLOXSEG3EI16_V_MF4_M1 + 0U, // PseudoVLOXSEG3EI16_V_MF4_M1_MASK + 0U, // PseudoVLOXSEG3EI16_V_MF4_MF2 + 0U, // PseudoVLOXSEG3EI16_V_MF4_MF2_MASK + 0U, // PseudoVLOXSEG3EI16_V_MF4_MF4 + 0U, // PseudoVLOXSEG3EI16_V_MF4_MF4_MASK + 0U, // PseudoVLOXSEG3EI16_V_MF4_MF8 + 0U, // PseudoVLOXSEG3EI16_V_MF4_MF8_MASK + 0U, // PseudoVLOXSEG3EI32_V_M1_M1 + 0U, // PseudoVLOXSEG3EI32_V_M1_M1_MASK + 0U, // PseudoVLOXSEG3EI32_V_M1_M2 + 0U, // PseudoVLOXSEG3EI32_V_M1_M2_MASK + 0U, // PseudoVLOXSEG3EI32_V_M1_MF2 + 0U, // PseudoVLOXSEG3EI32_V_M1_MF2_MASK + 0U, // PseudoVLOXSEG3EI32_V_M1_MF4 + 0U, // PseudoVLOXSEG3EI32_V_M1_MF4_MASK + 0U, // PseudoVLOXSEG3EI32_V_M2_M1 + 0U, // PseudoVLOXSEG3EI32_V_M2_M1_MASK + 0U, // PseudoVLOXSEG3EI32_V_M2_M2 + 0U, // PseudoVLOXSEG3EI32_V_M2_M2_MASK + 0U, // PseudoVLOXSEG3EI32_V_M2_MF2 + 0U, // PseudoVLOXSEG3EI32_V_M2_MF2_MASK + 0U, // PseudoVLOXSEG3EI32_V_M4_M1 + 0U, // PseudoVLOXSEG3EI32_V_M4_M1_MASK + 0U, // PseudoVLOXSEG3EI32_V_M4_M2 + 0U, // PseudoVLOXSEG3EI32_V_M4_M2_MASK + 0U, // PseudoVLOXSEG3EI32_V_M8_M2 + 0U, // PseudoVLOXSEG3EI32_V_M8_M2_MASK + 0U, // PseudoVLOXSEG3EI32_V_MF2_M1 + 0U, // PseudoVLOXSEG3EI32_V_MF2_M1_MASK + 0U, // PseudoVLOXSEG3EI32_V_MF2_MF2 + 0U, // PseudoVLOXSEG3EI32_V_MF2_MF2_MASK + 0U, // PseudoVLOXSEG3EI32_V_MF2_MF4 + 0U, // PseudoVLOXSEG3EI32_V_MF2_MF4_MASK + 0U, // PseudoVLOXSEG3EI32_V_MF2_MF8 + 0U, // PseudoVLOXSEG3EI32_V_MF2_MF8_MASK + 0U, // PseudoVLOXSEG3EI64_V_M1_M1 + 0U, // PseudoVLOXSEG3EI64_V_M1_M1_MASK + 0U, // PseudoVLOXSEG3EI64_V_M1_MF2 + 0U, // PseudoVLOXSEG3EI64_V_M1_MF2_MASK + 0U, // PseudoVLOXSEG3EI64_V_M1_MF4 + 0U, // PseudoVLOXSEG3EI64_V_M1_MF4_MASK + 0U, // PseudoVLOXSEG3EI64_V_M1_MF8 + 0U, // PseudoVLOXSEG3EI64_V_M1_MF8_MASK + 0U, // PseudoVLOXSEG3EI64_V_M2_M1 + 0U, // PseudoVLOXSEG3EI64_V_M2_M1_MASK + 0U, // PseudoVLOXSEG3EI64_V_M2_M2 + 0U, // PseudoVLOXSEG3EI64_V_M2_M2_MASK + 0U, // PseudoVLOXSEG3EI64_V_M2_MF2 + 0U, // PseudoVLOXSEG3EI64_V_M2_MF2_MASK + 0U, // PseudoVLOXSEG3EI64_V_M2_MF4 + 0U, // PseudoVLOXSEG3EI64_V_M2_MF4_MASK + 0U, // PseudoVLOXSEG3EI64_V_M4_M1 + 0U, // PseudoVLOXSEG3EI64_V_M4_M1_MASK + 0U, // PseudoVLOXSEG3EI64_V_M4_M2 + 0U, // PseudoVLOXSEG3EI64_V_M4_M2_MASK + 0U, // PseudoVLOXSEG3EI64_V_M4_MF2 + 0U, // PseudoVLOXSEG3EI64_V_M4_MF2_MASK + 0U, // PseudoVLOXSEG3EI64_V_M8_M1 + 0U, // PseudoVLOXSEG3EI64_V_M8_M1_MASK + 0U, // PseudoVLOXSEG3EI64_V_M8_M2 + 0U, // PseudoVLOXSEG3EI64_V_M8_M2_MASK + 0U, // PseudoVLOXSEG3EI8_V_M1_M1 + 0U, // PseudoVLOXSEG3EI8_V_M1_M1_MASK + 0U, // PseudoVLOXSEG3EI8_V_M1_M2 + 0U, // PseudoVLOXSEG3EI8_V_M1_M2_MASK + 0U, // PseudoVLOXSEG3EI8_V_M2_M2 + 0U, // PseudoVLOXSEG3EI8_V_M2_M2_MASK + 0U, // PseudoVLOXSEG3EI8_V_MF2_M1 + 0U, // PseudoVLOXSEG3EI8_V_MF2_M1_MASK + 0U, // PseudoVLOXSEG3EI8_V_MF2_M2 + 0U, // PseudoVLOXSEG3EI8_V_MF2_M2_MASK + 0U, // PseudoVLOXSEG3EI8_V_MF2_MF2 + 0U, // PseudoVLOXSEG3EI8_V_MF2_MF2_MASK + 0U, // PseudoVLOXSEG3EI8_V_MF4_M1 + 0U, // PseudoVLOXSEG3EI8_V_MF4_M1_MASK + 0U, // PseudoVLOXSEG3EI8_V_MF4_M2 + 0U, // PseudoVLOXSEG3EI8_V_MF4_M2_MASK + 0U, // PseudoVLOXSEG3EI8_V_MF4_MF2 + 0U, // PseudoVLOXSEG3EI8_V_MF4_MF2_MASK + 0U, // PseudoVLOXSEG3EI8_V_MF4_MF4 + 0U, // PseudoVLOXSEG3EI8_V_MF4_MF4_MASK + 0U, // PseudoVLOXSEG3EI8_V_MF8_M1 + 0U, // PseudoVLOXSEG3EI8_V_MF8_M1_MASK + 0U, // PseudoVLOXSEG3EI8_V_MF8_MF2 + 0U, // PseudoVLOXSEG3EI8_V_MF8_MF2_MASK + 0U, // PseudoVLOXSEG3EI8_V_MF8_MF4 + 0U, // PseudoVLOXSEG3EI8_V_MF8_MF4_MASK + 0U, // PseudoVLOXSEG3EI8_V_MF8_MF8 + 0U, // PseudoVLOXSEG3EI8_V_MF8_MF8_MASK + 0U, // PseudoVLOXSEG4EI16_V_M1_M1 + 0U, // PseudoVLOXSEG4EI16_V_M1_M1_MASK + 0U, // PseudoVLOXSEG4EI16_V_M1_M2 + 0U, // PseudoVLOXSEG4EI16_V_M1_M2_MASK + 0U, // PseudoVLOXSEG4EI16_V_M1_MF2 + 0U, // PseudoVLOXSEG4EI16_V_M1_MF2_MASK + 0U, // PseudoVLOXSEG4EI16_V_M2_M1 + 0U, // PseudoVLOXSEG4EI16_V_M2_M1_MASK + 0U, // PseudoVLOXSEG4EI16_V_M2_M2 + 0U, // PseudoVLOXSEG4EI16_V_M2_M2_MASK + 0U, // PseudoVLOXSEG4EI16_V_M4_M2 + 0U, // PseudoVLOXSEG4EI16_V_M4_M2_MASK + 0U, // PseudoVLOXSEG4EI16_V_MF2_M1 + 0U, // PseudoVLOXSEG4EI16_V_MF2_M1_MASK + 0U, // PseudoVLOXSEG4EI16_V_MF2_M2 + 0U, // PseudoVLOXSEG4EI16_V_MF2_M2_MASK + 0U, // PseudoVLOXSEG4EI16_V_MF2_MF2 + 0U, // PseudoVLOXSEG4EI16_V_MF2_MF2_MASK + 0U, // PseudoVLOXSEG4EI16_V_MF2_MF4 + 0U, // PseudoVLOXSEG4EI16_V_MF2_MF4_MASK + 0U, // PseudoVLOXSEG4EI16_V_MF4_M1 + 0U, // PseudoVLOXSEG4EI16_V_MF4_M1_MASK + 0U, // PseudoVLOXSEG4EI16_V_MF4_MF2 + 0U, // PseudoVLOXSEG4EI16_V_MF4_MF2_MASK + 0U, // PseudoVLOXSEG4EI16_V_MF4_MF4 + 0U, // PseudoVLOXSEG4EI16_V_MF4_MF4_MASK + 0U, // PseudoVLOXSEG4EI16_V_MF4_MF8 + 0U, // PseudoVLOXSEG4EI16_V_MF4_MF8_MASK + 0U, // PseudoVLOXSEG4EI32_V_M1_M1 + 0U, // PseudoVLOXSEG4EI32_V_M1_M1_MASK + 0U, // PseudoVLOXSEG4EI32_V_M1_M2 + 0U, // PseudoVLOXSEG4EI32_V_M1_M2_MASK + 0U, // PseudoVLOXSEG4EI32_V_M1_MF2 + 0U, // PseudoVLOXSEG4EI32_V_M1_MF2_MASK + 0U, // PseudoVLOXSEG4EI32_V_M1_MF4 + 0U, // PseudoVLOXSEG4EI32_V_M1_MF4_MASK + 0U, // PseudoVLOXSEG4EI32_V_M2_M1 + 0U, // PseudoVLOXSEG4EI32_V_M2_M1_MASK + 0U, // PseudoVLOXSEG4EI32_V_M2_M2 + 0U, // PseudoVLOXSEG4EI32_V_M2_M2_MASK + 0U, // PseudoVLOXSEG4EI32_V_M2_MF2 + 0U, // PseudoVLOXSEG4EI32_V_M2_MF2_MASK + 0U, // PseudoVLOXSEG4EI32_V_M4_M1 + 0U, // PseudoVLOXSEG4EI32_V_M4_M1_MASK + 0U, // PseudoVLOXSEG4EI32_V_M4_M2 + 0U, // PseudoVLOXSEG4EI32_V_M4_M2_MASK + 0U, // PseudoVLOXSEG4EI32_V_M8_M2 + 0U, // PseudoVLOXSEG4EI32_V_M8_M2_MASK + 0U, // PseudoVLOXSEG4EI32_V_MF2_M1 + 0U, // PseudoVLOXSEG4EI32_V_MF2_M1_MASK + 0U, // PseudoVLOXSEG4EI32_V_MF2_MF2 + 0U, // PseudoVLOXSEG4EI32_V_MF2_MF2_MASK + 0U, // PseudoVLOXSEG4EI32_V_MF2_MF4 + 0U, // PseudoVLOXSEG4EI32_V_MF2_MF4_MASK + 0U, // PseudoVLOXSEG4EI32_V_MF2_MF8 + 0U, // PseudoVLOXSEG4EI32_V_MF2_MF8_MASK + 0U, // PseudoVLOXSEG4EI64_V_M1_M1 + 0U, // PseudoVLOXSEG4EI64_V_M1_M1_MASK + 0U, // PseudoVLOXSEG4EI64_V_M1_MF2 + 0U, // PseudoVLOXSEG4EI64_V_M1_MF2_MASK + 0U, // PseudoVLOXSEG4EI64_V_M1_MF4 + 0U, // PseudoVLOXSEG4EI64_V_M1_MF4_MASK + 0U, // PseudoVLOXSEG4EI64_V_M1_MF8 + 0U, // PseudoVLOXSEG4EI64_V_M1_MF8_MASK + 0U, // PseudoVLOXSEG4EI64_V_M2_M1 + 0U, // PseudoVLOXSEG4EI64_V_M2_M1_MASK + 0U, // PseudoVLOXSEG4EI64_V_M2_M2 + 0U, // PseudoVLOXSEG4EI64_V_M2_M2_MASK + 0U, // PseudoVLOXSEG4EI64_V_M2_MF2 + 0U, // PseudoVLOXSEG4EI64_V_M2_MF2_MASK + 0U, // PseudoVLOXSEG4EI64_V_M2_MF4 + 0U, // PseudoVLOXSEG4EI64_V_M2_MF4_MASK + 0U, // PseudoVLOXSEG4EI64_V_M4_M1 + 0U, // PseudoVLOXSEG4EI64_V_M4_M1_MASK + 0U, // PseudoVLOXSEG4EI64_V_M4_M2 + 0U, // PseudoVLOXSEG4EI64_V_M4_M2_MASK + 0U, // PseudoVLOXSEG4EI64_V_M4_MF2 + 0U, // PseudoVLOXSEG4EI64_V_M4_MF2_MASK + 0U, // PseudoVLOXSEG4EI64_V_M8_M1 + 0U, // PseudoVLOXSEG4EI64_V_M8_M1_MASK + 0U, // PseudoVLOXSEG4EI64_V_M8_M2 + 0U, // PseudoVLOXSEG4EI64_V_M8_M2_MASK + 0U, // PseudoVLOXSEG4EI8_V_M1_M1 + 0U, // PseudoVLOXSEG4EI8_V_M1_M1_MASK + 0U, // PseudoVLOXSEG4EI8_V_M1_M2 + 0U, // PseudoVLOXSEG4EI8_V_M1_M2_MASK + 0U, // PseudoVLOXSEG4EI8_V_M2_M2 + 0U, // PseudoVLOXSEG4EI8_V_M2_M2_MASK + 0U, // PseudoVLOXSEG4EI8_V_MF2_M1 + 0U, // PseudoVLOXSEG4EI8_V_MF2_M1_MASK + 0U, // PseudoVLOXSEG4EI8_V_MF2_M2 + 0U, // PseudoVLOXSEG4EI8_V_MF2_M2_MASK + 0U, // PseudoVLOXSEG4EI8_V_MF2_MF2 + 0U, // PseudoVLOXSEG4EI8_V_MF2_MF2_MASK + 0U, // PseudoVLOXSEG4EI8_V_MF4_M1 + 0U, // PseudoVLOXSEG4EI8_V_MF4_M1_MASK + 0U, // PseudoVLOXSEG4EI8_V_MF4_M2 + 0U, // PseudoVLOXSEG4EI8_V_MF4_M2_MASK + 0U, // PseudoVLOXSEG4EI8_V_MF4_MF2 + 0U, // PseudoVLOXSEG4EI8_V_MF4_MF2_MASK + 0U, // PseudoVLOXSEG4EI8_V_MF4_MF4 + 0U, // PseudoVLOXSEG4EI8_V_MF4_MF4_MASK + 0U, // PseudoVLOXSEG4EI8_V_MF8_M1 + 0U, // PseudoVLOXSEG4EI8_V_MF8_M1_MASK + 0U, // PseudoVLOXSEG4EI8_V_MF8_MF2 + 0U, // PseudoVLOXSEG4EI8_V_MF8_MF2_MASK + 0U, // PseudoVLOXSEG4EI8_V_MF8_MF4 + 0U, // PseudoVLOXSEG4EI8_V_MF8_MF4_MASK + 0U, // PseudoVLOXSEG4EI8_V_MF8_MF8 + 0U, // PseudoVLOXSEG4EI8_V_MF8_MF8_MASK + 0U, // PseudoVLOXSEG5EI16_V_M1_M1 + 0U, // PseudoVLOXSEG5EI16_V_M1_M1_MASK + 0U, // PseudoVLOXSEG5EI16_V_M1_MF2 + 0U, // PseudoVLOXSEG5EI16_V_M1_MF2_MASK + 0U, // PseudoVLOXSEG5EI16_V_M2_M1 + 0U, // PseudoVLOXSEG5EI16_V_M2_M1_MASK + 0U, // PseudoVLOXSEG5EI16_V_MF2_M1 + 0U, // PseudoVLOXSEG5EI16_V_MF2_M1_MASK + 0U, // PseudoVLOXSEG5EI16_V_MF2_MF2 + 0U, // PseudoVLOXSEG5EI16_V_MF2_MF2_MASK + 0U, // PseudoVLOXSEG5EI16_V_MF2_MF4 + 0U, // PseudoVLOXSEG5EI16_V_MF2_MF4_MASK + 0U, // PseudoVLOXSEG5EI16_V_MF4_M1 + 0U, // PseudoVLOXSEG5EI16_V_MF4_M1_MASK + 0U, // PseudoVLOXSEG5EI16_V_MF4_MF2 + 0U, // PseudoVLOXSEG5EI16_V_MF4_MF2_MASK + 0U, // PseudoVLOXSEG5EI16_V_MF4_MF4 + 0U, // PseudoVLOXSEG5EI16_V_MF4_MF4_MASK + 0U, // PseudoVLOXSEG5EI16_V_MF4_MF8 + 0U, // PseudoVLOXSEG5EI16_V_MF4_MF8_MASK + 0U, // PseudoVLOXSEG5EI32_V_M1_M1 + 0U, // PseudoVLOXSEG5EI32_V_M1_M1_MASK + 0U, // PseudoVLOXSEG5EI32_V_M1_MF2 + 0U, // PseudoVLOXSEG5EI32_V_M1_MF2_MASK + 0U, // PseudoVLOXSEG5EI32_V_M1_MF4 + 0U, // PseudoVLOXSEG5EI32_V_M1_MF4_MASK + 0U, // PseudoVLOXSEG5EI32_V_M2_M1 + 0U, // PseudoVLOXSEG5EI32_V_M2_M1_MASK + 0U, // PseudoVLOXSEG5EI32_V_M2_MF2 + 0U, // PseudoVLOXSEG5EI32_V_M2_MF2_MASK + 0U, // PseudoVLOXSEG5EI32_V_M4_M1 + 0U, // PseudoVLOXSEG5EI32_V_M4_M1_MASK + 0U, // PseudoVLOXSEG5EI32_V_MF2_M1 + 0U, // PseudoVLOXSEG5EI32_V_MF2_M1_MASK + 0U, // PseudoVLOXSEG5EI32_V_MF2_MF2 + 0U, // PseudoVLOXSEG5EI32_V_MF2_MF2_MASK + 0U, // PseudoVLOXSEG5EI32_V_MF2_MF4 + 0U, // PseudoVLOXSEG5EI32_V_MF2_MF4_MASK + 0U, // PseudoVLOXSEG5EI32_V_MF2_MF8 + 0U, // PseudoVLOXSEG5EI32_V_MF2_MF8_MASK + 0U, // PseudoVLOXSEG5EI64_V_M1_M1 + 0U, // PseudoVLOXSEG5EI64_V_M1_M1_MASK + 0U, // PseudoVLOXSEG5EI64_V_M1_MF2 + 0U, // PseudoVLOXSEG5EI64_V_M1_MF2_MASK + 0U, // PseudoVLOXSEG5EI64_V_M1_MF4 + 0U, // PseudoVLOXSEG5EI64_V_M1_MF4_MASK + 0U, // PseudoVLOXSEG5EI64_V_M1_MF8 + 0U, // PseudoVLOXSEG5EI64_V_M1_MF8_MASK + 0U, // PseudoVLOXSEG5EI64_V_M2_M1 + 0U, // PseudoVLOXSEG5EI64_V_M2_M1_MASK + 0U, // PseudoVLOXSEG5EI64_V_M2_MF2 + 0U, // PseudoVLOXSEG5EI64_V_M2_MF2_MASK + 0U, // PseudoVLOXSEG5EI64_V_M2_MF4 + 0U, // PseudoVLOXSEG5EI64_V_M2_MF4_MASK + 0U, // PseudoVLOXSEG5EI64_V_M4_M1 + 0U, // PseudoVLOXSEG5EI64_V_M4_M1_MASK + 0U, // PseudoVLOXSEG5EI64_V_M4_MF2 + 0U, // PseudoVLOXSEG5EI64_V_M4_MF2_MASK + 0U, // PseudoVLOXSEG5EI64_V_M8_M1 + 0U, // PseudoVLOXSEG5EI64_V_M8_M1_MASK + 0U, // PseudoVLOXSEG5EI8_V_M1_M1 + 0U, // PseudoVLOXSEG5EI8_V_M1_M1_MASK + 0U, // PseudoVLOXSEG5EI8_V_MF2_M1 + 0U, // PseudoVLOXSEG5EI8_V_MF2_M1_MASK + 0U, // PseudoVLOXSEG5EI8_V_MF2_MF2 + 0U, // PseudoVLOXSEG5EI8_V_MF2_MF2_MASK + 0U, // PseudoVLOXSEG5EI8_V_MF4_M1 + 0U, // PseudoVLOXSEG5EI8_V_MF4_M1_MASK + 0U, // PseudoVLOXSEG5EI8_V_MF4_MF2 + 0U, // PseudoVLOXSEG5EI8_V_MF4_MF2_MASK + 0U, // PseudoVLOXSEG5EI8_V_MF4_MF4 + 0U, // PseudoVLOXSEG5EI8_V_MF4_MF4_MASK + 0U, // PseudoVLOXSEG5EI8_V_MF8_M1 + 0U, // PseudoVLOXSEG5EI8_V_MF8_M1_MASK + 0U, // PseudoVLOXSEG5EI8_V_MF8_MF2 + 0U, // PseudoVLOXSEG5EI8_V_MF8_MF2_MASK + 0U, // PseudoVLOXSEG5EI8_V_MF8_MF4 + 0U, // PseudoVLOXSEG5EI8_V_MF8_MF4_MASK + 0U, // PseudoVLOXSEG5EI8_V_MF8_MF8 + 0U, // PseudoVLOXSEG5EI8_V_MF8_MF8_MASK + 0U, // PseudoVLOXSEG6EI16_V_M1_M1 + 0U, // PseudoVLOXSEG6EI16_V_M1_M1_MASK + 0U, // PseudoVLOXSEG6EI16_V_M1_MF2 + 0U, // PseudoVLOXSEG6EI16_V_M1_MF2_MASK + 0U, // PseudoVLOXSEG6EI16_V_M2_M1 + 0U, // PseudoVLOXSEG6EI16_V_M2_M1_MASK + 0U, // PseudoVLOXSEG6EI16_V_MF2_M1 + 0U, // PseudoVLOXSEG6EI16_V_MF2_M1_MASK + 0U, // PseudoVLOXSEG6EI16_V_MF2_MF2 + 0U, // PseudoVLOXSEG6EI16_V_MF2_MF2_MASK + 0U, // PseudoVLOXSEG6EI16_V_MF2_MF4 + 0U, // PseudoVLOXSEG6EI16_V_MF2_MF4_MASK + 0U, // PseudoVLOXSEG6EI16_V_MF4_M1 + 0U, // PseudoVLOXSEG6EI16_V_MF4_M1_MASK + 0U, // PseudoVLOXSEG6EI16_V_MF4_MF2 + 0U, // PseudoVLOXSEG6EI16_V_MF4_MF2_MASK + 0U, // PseudoVLOXSEG6EI16_V_MF4_MF4 + 0U, // PseudoVLOXSEG6EI16_V_MF4_MF4_MASK + 0U, // PseudoVLOXSEG6EI16_V_MF4_MF8 + 0U, // PseudoVLOXSEG6EI16_V_MF4_MF8_MASK + 0U, // PseudoVLOXSEG6EI32_V_M1_M1 + 0U, // PseudoVLOXSEG6EI32_V_M1_M1_MASK + 0U, // PseudoVLOXSEG6EI32_V_M1_MF2 + 0U, // PseudoVLOXSEG6EI32_V_M1_MF2_MASK + 0U, // PseudoVLOXSEG6EI32_V_M1_MF4 + 0U, // PseudoVLOXSEG6EI32_V_M1_MF4_MASK + 0U, // PseudoVLOXSEG6EI32_V_M2_M1 + 0U, // PseudoVLOXSEG6EI32_V_M2_M1_MASK + 0U, // PseudoVLOXSEG6EI32_V_M2_MF2 + 0U, // PseudoVLOXSEG6EI32_V_M2_MF2_MASK + 0U, // PseudoVLOXSEG6EI32_V_M4_M1 + 0U, // PseudoVLOXSEG6EI32_V_M4_M1_MASK + 0U, // PseudoVLOXSEG6EI32_V_MF2_M1 + 0U, // PseudoVLOXSEG6EI32_V_MF2_M1_MASK + 0U, // PseudoVLOXSEG6EI32_V_MF2_MF2 + 0U, // PseudoVLOXSEG6EI32_V_MF2_MF2_MASK + 0U, // PseudoVLOXSEG6EI32_V_MF2_MF4 + 0U, // PseudoVLOXSEG6EI32_V_MF2_MF4_MASK + 0U, // PseudoVLOXSEG6EI32_V_MF2_MF8 + 0U, // PseudoVLOXSEG6EI32_V_MF2_MF8_MASK + 0U, // PseudoVLOXSEG6EI64_V_M1_M1 + 0U, // PseudoVLOXSEG6EI64_V_M1_M1_MASK + 0U, // PseudoVLOXSEG6EI64_V_M1_MF2 + 0U, // PseudoVLOXSEG6EI64_V_M1_MF2_MASK + 0U, // PseudoVLOXSEG6EI64_V_M1_MF4 + 0U, // PseudoVLOXSEG6EI64_V_M1_MF4_MASK + 0U, // PseudoVLOXSEG6EI64_V_M1_MF8 + 0U, // PseudoVLOXSEG6EI64_V_M1_MF8_MASK + 0U, // PseudoVLOXSEG6EI64_V_M2_M1 + 0U, // PseudoVLOXSEG6EI64_V_M2_M1_MASK + 0U, // PseudoVLOXSEG6EI64_V_M2_MF2 + 0U, // PseudoVLOXSEG6EI64_V_M2_MF2_MASK + 0U, // PseudoVLOXSEG6EI64_V_M2_MF4 + 0U, // PseudoVLOXSEG6EI64_V_M2_MF4_MASK + 0U, // PseudoVLOXSEG6EI64_V_M4_M1 + 0U, // PseudoVLOXSEG6EI64_V_M4_M1_MASK + 0U, // PseudoVLOXSEG6EI64_V_M4_MF2 + 0U, // PseudoVLOXSEG6EI64_V_M4_MF2_MASK + 0U, // PseudoVLOXSEG6EI64_V_M8_M1 + 0U, // PseudoVLOXSEG6EI64_V_M8_M1_MASK + 0U, // PseudoVLOXSEG6EI8_V_M1_M1 + 0U, // PseudoVLOXSEG6EI8_V_M1_M1_MASK + 0U, // PseudoVLOXSEG6EI8_V_MF2_M1 + 0U, // PseudoVLOXSEG6EI8_V_MF2_M1_MASK + 0U, // PseudoVLOXSEG6EI8_V_MF2_MF2 + 0U, // PseudoVLOXSEG6EI8_V_MF2_MF2_MASK + 0U, // PseudoVLOXSEG6EI8_V_MF4_M1 + 0U, // PseudoVLOXSEG6EI8_V_MF4_M1_MASK + 0U, // PseudoVLOXSEG6EI8_V_MF4_MF2 + 0U, // PseudoVLOXSEG6EI8_V_MF4_MF2_MASK + 0U, // PseudoVLOXSEG6EI8_V_MF4_MF4 + 0U, // PseudoVLOXSEG6EI8_V_MF4_MF4_MASK + 0U, // PseudoVLOXSEG6EI8_V_MF8_M1 + 0U, // PseudoVLOXSEG6EI8_V_MF8_M1_MASK + 0U, // PseudoVLOXSEG6EI8_V_MF8_MF2 + 0U, // PseudoVLOXSEG6EI8_V_MF8_MF2_MASK + 0U, // PseudoVLOXSEG6EI8_V_MF8_MF4 + 0U, // PseudoVLOXSEG6EI8_V_MF8_MF4_MASK + 0U, // PseudoVLOXSEG6EI8_V_MF8_MF8 + 0U, // PseudoVLOXSEG6EI8_V_MF8_MF8_MASK + 0U, // PseudoVLOXSEG7EI16_V_M1_M1 + 0U, // PseudoVLOXSEG7EI16_V_M1_M1_MASK + 0U, // PseudoVLOXSEG7EI16_V_M1_MF2 + 0U, // PseudoVLOXSEG7EI16_V_M1_MF2_MASK + 0U, // PseudoVLOXSEG7EI16_V_M2_M1 + 0U, // PseudoVLOXSEG7EI16_V_M2_M1_MASK + 0U, // PseudoVLOXSEG7EI16_V_MF2_M1 + 0U, // PseudoVLOXSEG7EI16_V_MF2_M1_MASK + 0U, // PseudoVLOXSEG7EI16_V_MF2_MF2 + 0U, // PseudoVLOXSEG7EI16_V_MF2_MF2_MASK + 0U, // PseudoVLOXSEG7EI16_V_MF2_MF4 + 0U, // PseudoVLOXSEG7EI16_V_MF2_MF4_MASK + 0U, // PseudoVLOXSEG7EI16_V_MF4_M1 + 0U, // PseudoVLOXSEG7EI16_V_MF4_M1_MASK + 0U, // PseudoVLOXSEG7EI16_V_MF4_MF2 + 0U, // PseudoVLOXSEG7EI16_V_MF4_MF2_MASK + 0U, // PseudoVLOXSEG7EI16_V_MF4_MF4 + 0U, // PseudoVLOXSEG7EI16_V_MF4_MF4_MASK + 0U, // PseudoVLOXSEG7EI16_V_MF4_MF8 + 0U, // PseudoVLOXSEG7EI16_V_MF4_MF8_MASK + 0U, // PseudoVLOXSEG7EI32_V_M1_M1 + 0U, // PseudoVLOXSEG7EI32_V_M1_M1_MASK + 0U, // PseudoVLOXSEG7EI32_V_M1_MF2 + 0U, // PseudoVLOXSEG7EI32_V_M1_MF2_MASK + 0U, // PseudoVLOXSEG7EI32_V_M1_MF4 + 0U, // PseudoVLOXSEG7EI32_V_M1_MF4_MASK + 0U, // PseudoVLOXSEG7EI32_V_M2_M1 + 0U, // PseudoVLOXSEG7EI32_V_M2_M1_MASK + 0U, // PseudoVLOXSEG7EI32_V_M2_MF2 + 0U, // PseudoVLOXSEG7EI32_V_M2_MF2_MASK + 0U, // PseudoVLOXSEG7EI32_V_M4_M1 + 0U, // PseudoVLOXSEG7EI32_V_M4_M1_MASK + 0U, // PseudoVLOXSEG7EI32_V_MF2_M1 + 0U, // PseudoVLOXSEG7EI32_V_MF2_M1_MASK + 0U, // PseudoVLOXSEG7EI32_V_MF2_MF2 + 0U, // PseudoVLOXSEG7EI32_V_MF2_MF2_MASK + 0U, // PseudoVLOXSEG7EI32_V_MF2_MF4 + 0U, // PseudoVLOXSEG7EI32_V_MF2_MF4_MASK + 0U, // PseudoVLOXSEG7EI32_V_MF2_MF8 + 0U, // PseudoVLOXSEG7EI32_V_MF2_MF8_MASK + 0U, // PseudoVLOXSEG7EI64_V_M1_M1 + 0U, // PseudoVLOXSEG7EI64_V_M1_M1_MASK + 0U, // PseudoVLOXSEG7EI64_V_M1_MF2 + 0U, // PseudoVLOXSEG7EI64_V_M1_MF2_MASK + 0U, // PseudoVLOXSEG7EI64_V_M1_MF4 + 0U, // PseudoVLOXSEG7EI64_V_M1_MF4_MASK + 0U, // PseudoVLOXSEG7EI64_V_M1_MF8 + 0U, // PseudoVLOXSEG7EI64_V_M1_MF8_MASK + 0U, // PseudoVLOXSEG7EI64_V_M2_M1 + 0U, // PseudoVLOXSEG7EI64_V_M2_M1_MASK + 0U, // PseudoVLOXSEG7EI64_V_M2_MF2 + 0U, // PseudoVLOXSEG7EI64_V_M2_MF2_MASK + 0U, // PseudoVLOXSEG7EI64_V_M2_MF4 + 0U, // PseudoVLOXSEG7EI64_V_M2_MF4_MASK + 0U, // PseudoVLOXSEG7EI64_V_M4_M1 + 0U, // PseudoVLOXSEG7EI64_V_M4_M1_MASK + 0U, // PseudoVLOXSEG7EI64_V_M4_MF2 + 0U, // PseudoVLOXSEG7EI64_V_M4_MF2_MASK + 0U, // PseudoVLOXSEG7EI64_V_M8_M1 + 0U, // PseudoVLOXSEG7EI64_V_M8_M1_MASK + 0U, // PseudoVLOXSEG7EI8_V_M1_M1 + 0U, // PseudoVLOXSEG7EI8_V_M1_M1_MASK + 0U, // PseudoVLOXSEG7EI8_V_MF2_M1 + 0U, // PseudoVLOXSEG7EI8_V_MF2_M1_MASK + 0U, // PseudoVLOXSEG7EI8_V_MF2_MF2 + 0U, // PseudoVLOXSEG7EI8_V_MF2_MF2_MASK + 0U, // PseudoVLOXSEG7EI8_V_MF4_M1 + 0U, // PseudoVLOXSEG7EI8_V_MF4_M1_MASK + 0U, // PseudoVLOXSEG7EI8_V_MF4_MF2 + 0U, // PseudoVLOXSEG7EI8_V_MF4_MF2_MASK + 0U, // PseudoVLOXSEG7EI8_V_MF4_MF4 + 0U, // PseudoVLOXSEG7EI8_V_MF4_MF4_MASK + 0U, // PseudoVLOXSEG7EI8_V_MF8_M1 + 0U, // PseudoVLOXSEG7EI8_V_MF8_M1_MASK + 0U, // PseudoVLOXSEG7EI8_V_MF8_MF2 + 0U, // PseudoVLOXSEG7EI8_V_MF8_MF2_MASK + 0U, // PseudoVLOXSEG7EI8_V_MF8_MF4 + 0U, // PseudoVLOXSEG7EI8_V_MF8_MF4_MASK + 0U, // PseudoVLOXSEG7EI8_V_MF8_MF8 + 0U, // PseudoVLOXSEG7EI8_V_MF8_MF8_MASK + 0U, // PseudoVLOXSEG8EI16_V_M1_M1 + 0U, // PseudoVLOXSEG8EI16_V_M1_M1_MASK + 0U, // PseudoVLOXSEG8EI16_V_M1_MF2 + 0U, // PseudoVLOXSEG8EI16_V_M1_MF2_MASK + 0U, // PseudoVLOXSEG8EI16_V_M2_M1 + 0U, // PseudoVLOXSEG8EI16_V_M2_M1_MASK + 0U, // PseudoVLOXSEG8EI16_V_MF2_M1 + 0U, // PseudoVLOXSEG8EI16_V_MF2_M1_MASK + 0U, // PseudoVLOXSEG8EI16_V_MF2_MF2 + 0U, // PseudoVLOXSEG8EI16_V_MF2_MF2_MASK + 0U, // PseudoVLOXSEG8EI16_V_MF2_MF4 + 0U, // PseudoVLOXSEG8EI16_V_MF2_MF4_MASK + 0U, // PseudoVLOXSEG8EI16_V_MF4_M1 + 0U, // PseudoVLOXSEG8EI16_V_MF4_M1_MASK + 0U, // PseudoVLOXSEG8EI16_V_MF4_MF2 + 0U, // PseudoVLOXSEG8EI16_V_MF4_MF2_MASK + 0U, // PseudoVLOXSEG8EI16_V_MF4_MF4 + 0U, // PseudoVLOXSEG8EI16_V_MF4_MF4_MASK + 0U, // PseudoVLOXSEG8EI16_V_MF4_MF8 + 0U, // PseudoVLOXSEG8EI16_V_MF4_MF8_MASK + 0U, // PseudoVLOXSEG8EI32_V_M1_M1 + 0U, // PseudoVLOXSEG8EI32_V_M1_M1_MASK + 0U, // PseudoVLOXSEG8EI32_V_M1_MF2 + 0U, // PseudoVLOXSEG8EI32_V_M1_MF2_MASK + 0U, // PseudoVLOXSEG8EI32_V_M1_MF4 + 0U, // PseudoVLOXSEG8EI32_V_M1_MF4_MASK + 0U, // PseudoVLOXSEG8EI32_V_M2_M1 + 0U, // PseudoVLOXSEG8EI32_V_M2_M1_MASK + 0U, // PseudoVLOXSEG8EI32_V_M2_MF2 + 0U, // PseudoVLOXSEG8EI32_V_M2_MF2_MASK + 0U, // PseudoVLOXSEG8EI32_V_M4_M1 + 0U, // PseudoVLOXSEG8EI32_V_M4_M1_MASK + 0U, // PseudoVLOXSEG8EI32_V_MF2_M1 + 0U, // PseudoVLOXSEG8EI32_V_MF2_M1_MASK + 0U, // PseudoVLOXSEG8EI32_V_MF2_MF2 + 0U, // PseudoVLOXSEG8EI32_V_MF2_MF2_MASK + 0U, // PseudoVLOXSEG8EI32_V_MF2_MF4 + 0U, // PseudoVLOXSEG8EI32_V_MF2_MF4_MASK + 0U, // PseudoVLOXSEG8EI32_V_MF2_MF8 + 0U, // PseudoVLOXSEG8EI32_V_MF2_MF8_MASK + 0U, // PseudoVLOXSEG8EI64_V_M1_M1 + 0U, // PseudoVLOXSEG8EI64_V_M1_M1_MASK + 0U, // PseudoVLOXSEG8EI64_V_M1_MF2 + 0U, // PseudoVLOXSEG8EI64_V_M1_MF2_MASK + 0U, // PseudoVLOXSEG8EI64_V_M1_MF4 + 0U, // PseudoVLOXSEG8EI64_V_M1_MF4_MASK + 0U, // PseudoVLOXSEG8EI64_V_M1_MF8 + 0U, // PseudoVLOXSEG8EI64_V_M1_MF8_MASK + 0U, // PseudoVLOXSEG8EI64_V_M2_M1 + 0U, // PseudoVLOXSEG8EI64_V_M2_M1_MASK + 0U, // PseudoVLOXSEG8EI64_V_M2_MF2 + 0U, // PseudoVLOXSEG8EI64_V_M2_MF2_MASK + 0U, // PseudoVLOXSEG8EI64_V_M2_MF4 + 0U, // PseudoVLOXSEG8EI64_V_M2_MF4_MASK + 0U, // PseudoVLOXSEG8EI64_V_M4_M1 + 0U, // PseudoVLOXSEG8EI64_V_M4_M1_MASK + 0U, // PseudoVLOXSEG8EI64_V_M4_MF2 + 0U, // PseudoVLOXSEG8EI64_V_M4_MF2_MASK + 0U, // PseudoVLOXSEG8EI64_V_M8_M1 + 0U, // PseudoVLOXSEG8EI64_V_M8_M1_MASK + 0U, // PseudoVLOXSEG8EI8_V_M1_M1 + 0U, // PseudoVLOXSEG8EI8_V_M1_M1_MASK + 0U, // PseudoVLOXSEG8EI8_V_MF2_M1 + 0U, // PseudoVLOXSEG8EI8_V_MF2_M1_MASK + 0U, // PseudoVLOXSEG8EI8_V_MF2_MF2 + 0U, // PseudoVLOXSEG8EI8_V_MF2_MF2_MASK + 0U, // PseudoVLOXSEG8EI8_V_MF4_M1 + 0U, // PseudoVLOXSEG8EI8_V_MF4_M1_MASK + 0U, // PseudoVLOXSEG8EI8_V_MF4_MF2 + 0U, // PseudoVLOXSEG8EI8_V_MF4_MF2_MASK + 0U, // PseudoVLOXSEG8EI8_V_MF4_MF4 + 0U, // PseudoVLOXSEG8EI8_V_MF4_MF4_MASK + 0U, // PseudoVLOXSEG8EI8_V_MF8_M1 + 0U, // PseudoVLOXSEG8EI8_V_MF8_M1_MASK + 0U, // PseudoVLOXSEG8EI8_V_MF8_MF2 + 0U, // PseudoVLOXSEG8EI8_V_MF8_MF2_MASK + 0U, // PseudoVLOXSEG8EI8_V_MF8_MF4 + 0U, // PseudoVLOXSEG8EI8_V_MF8_MF4_MASK + 0U, // PseudoVLOXSEG8EI8_V_MF8_MF8 + 0U, // PseudoVLOXSEG8EI8_V_MF8_MF8_MASK + 0U, // PseudoVLSE16_V_M1 + 0U, // PseudoVLSE16_V_M1_MASK + 0U, // PseudoVLSE16_V_M2 + 0U, // PseudoVLSE16_V_M2_MASK + 0U, // PseudoVLSE16_V_M4 + 0U, // PseudoVLSE16_V_M4_MASK + 0U, // PseudoVLSE16_V_M8 + 0U, // PseudoVLSE16_V_M8_MASK + 0U, // PseudoVLSE16_V_MF2 + 0U, // PseudoVLSE16_V_MF2_MASK + 0U, // PseudoVLSE16_V_MF4 + 0U, // PseudoVLSE16_V_MF4_MASK + 0U, // PseudoVLSE32_V_M1 + 0U, // PseudoVLSE32_V_M1_MASK + 0U, // PseudoVLSE32_V_M2 + 0U, // PseudoVLSE32_V_M2_MASK + 0U, // PseudoVLSE32_V_M4 + 0U, // PseudoVLSE32_V_M4_MASK + 0U, // PseudoVLSE32_V_M8 + 0U, // PseudoVLSE32_V_M8_MASK + 0U, // PseudoVLSE32_V_MF2 + 0U, // PseudoVLSE32_V_MF2_MASK + 0U, // PseudoVLSE64_V_M1 + 0U, // PseudoVLSE64_V_M1_MASK + 0U, // PseudoVLSE64_V_M2 + 0U, // PseudoVLSE64_V_M2_MASK + 0U, // PseudoVLSE64_V_M4 + 0U, // PseudoVLSE64_V_M4_MASK + 0U, // PseudoVLSE64_V_M8 + 0U, // PseudoVLSE64_V_M8_MASK + 0U, // PseudoVLSE8_V_M1 + 0U, // PseudoVLSE8_V_M1_MASK + 0U, // PseudoVLSE8_V_M2 + 0U, // PseudoVLSE8_V_M2_MASK + 0U, // PseudoVLSE8_V_M4 + 0U, // PseudoVLSE8_V_M4_MASK + 0U, // PseudoVLSE8_V_M8 + 0U, // PseudoVLSE8_V_M8_MASK + 0U, // PseudoVLSE8_V_MF2 + 0U, // PseudoVLSE8_V_MF2_MASK + 0U, // PseudoVLSE8_V_MF4 + 0U, // PseudoVLSE8_V_MF4_MASK + 0U, // PseudoVLSE8_V_MF8 + 0U, // PseudoVLSE8_V_MF8_MASK + 0U, // PseudoVLSEG2E16FF_V_M1 + 0U, // PseudoVLSEG2E16FF_V_M1_MASK + 0U, // PseudoVLSEG2E16FF_V_M2 + 0U, // PseudoVLSEG2E16FF_V_M2_MASK + 0U, // PseudoVLSEG2E16FF_V_M4 + 0U, // PseudoVLSEG2E16FF_V_M4_MASK + 0U, // PseudoVLSEG2E16FF_V_MF2 + 0U, // PseudoVLSEG2E16FF_V_MF2_MASK + 0U, // PseudoVLSEG2E16FF_V_MF4 + 0U, // PseudoVLSEG2E16FF_V_MF4_MASK + 0U, // PseudoVLSEG2E16_V_M1 + 0U, // PseudoVLSEG2E16_V_M1_MASK + 0U, // PseudoVLSEG2E16_V_M2 + 0U, // PseudoVLSEG2E16_V_M2_MASK + 0U, // PseudoVLSEG2E16_V_M4 + 0U, // PseudoVLSEG2E16_V_M4_MASK + 0U, // PseudoVLSEG2E16_V_MF2 + 0U, // PseudoVLSEG2E16_V_MF2_MASK + 0U, // PseudoVLSEG2E16_V_MF4 + 0U, // PseudoVLSEG2E16_V_MF4_MASK + 0U, // PseudoVLSEG2E32FF_V_M1 + 0U, // PseudoVLSEG2E32FF_V_M1_MASK + 0U, // PseudoVLSEG2E32FF_V_M2 + 0U, // PseudoVLSEG2E32FF_V_M2_MASK + 0U, // PseudoVLSEG2E32FF_V_M4 + 0U, // PseudoVLSEG2E32FF_V_M4_MASK + 0U, // PseudoVLSEG2E32FF_V_MF2 + 0U, // PseudoVLSEG2E32FF_V_MF2_MASK + 0U, // PseudoVLSEG2E32_V_M1 + 0U, // PseudoVLSEG2E32_V_M1_MASK + 0U, // PseudoVLSEG2E32_V_M2 + 0U, // PseudoVLSEG2E32_V_M2_MASK + 0U, // PseudoVLSEG2E32_V_M4 + 0U, // PseudoVLSEG2E32_V_M4_MASK + 0U, // PseudoVLSEG2E32_V_MF2 + 0U, // PseudoVLSEG2E32_V_MF2_MASK + 0U, // PseudoVLSEG2E64FF_V_M1 + 0U, // PseudoVLSEG2E64FF_V_M1_MASK + 0U, // PseudoVLSEG2E64FF_V_M2 + 0U, // PseudoVLSEG2E64FF_V_M2_MASK + 0U, // PseudoVLSEG2E64FF_V_M4 + 0U, // PseudoVLSEG2E64FF_V_M4_MASK + 0U, // PseudoVLSEG2E64_V_M1 + 0U, // PseudoVLSEG2E64_V_M1_MASK + 0U, // PseudoVLSEG2E64_V_M2 + 0U, // PseudoVLSEG2E64_V_M2_MASK + 0U, // PseudoVLSEG2E64_V_M4 + 0U, // PseudoVLSEG2E64_V_M4_MASK + 0U, // PseudoVLSEG2E8FF_V_M1 + 0U, // PseudoVLSEG2E8FF_V_M1_MASK + 0U, // PseudoVLSEG2E8FF_V_M2 + 0U, // PseudoVLSEG2E8FF_V_M2_MASK + 0U, // PseudoVLSEG2E8FF_V_M4 + 0U, // PseudoVLSEG2E8FF_V_M4_MASK + 0U, // PseudoVLSEG2E8FF_V_MF2 + 0U, // PseudoVLSEG2E8FF_V_MF2_MASK + 0U, // PseudoVLSEG2E8FF_V_MF4 + 0U, // PseudoVLSEG2E8FF_V_MF4_MASK + 0U, // PseudoVLSEG2E8FF_V_MF8 + 0U, // PseudoVLSEG2E8FF_V_MF8_MASK + 0U, // PseudoVLSEG2E8_V_M1 + 0U, // PseudoVLSEG2E8_V_M1_MASK + 0U, // PseudoVLSEG2E8_V_M2 + 0U, // PseudoVLSEG2E8_V_M2_MASK + 0U, // PseudoVLSEG2E8_V_M4 + 0U, // PseudoVLSEG2E8_V_M4_MASK + 0U, // PseudoVLSEG2E8_V_MF2 + 0U, // PseudoVLSEG2E8_V_MF2_MASK + 0U, // PseudoVLSEG2E8_V_MF4 + 0U, // PseudoVLSEG2E8_V_MF4_MASK + 0U, // PseudoVLSEG2E8_V_MF8 + 0U, // PseudoVLSEG2E8_V_MF8_MASK + 0U, // PseudoVLSEG3E16FF_V_M1 + 0U, // PseudoVLSEG3E16FF_V_M1_MASK + 0U, // PseudoVLSEG3E16FF_V_M2 + 0U, // PseudoVLSEG3E16FF_V_M2_MASK + 0U, // PseudoVLSEG3E16FF_V_MF2 + 0U, // PseudoVLSEG3E16FF_V_MF2_MASK + 0U, // PseudoVLSEG3E16FF_V_MF4 + 0U, // PseudoVLSEG3E16FF_V_MF4_MASK + 0U, // PseudoVLSEG3E16_V_M1 + 0U, // PseudoVLSEG3E16_V_M1_MASK + 0U, // PseudoVLSEG3E16_V_M2 + 0U, // PseudoVLSEG3E16_V_M2_MASK + 0U, // PseudoVLSEG3E16_V_MF2 + 0U, // PseudoVLSEG3E16_V_MF2_MASK + 0U, // PseudoVLSEG3E16_V_MF4 + 0U, // PseudoVLSEG3E16_V_MF4_MASK + 0U, // PseudoVLSEG3E32FF_V_M1 + 0U, // PseudoVLSEG3E32FF_V_M1_MASK + 0U, // PseudoVLSEG3E32FF_V_M2 + 0U, // PseudoVLSEG3E32FF_V_M2_MASK + 0U, // PseudoVLSEG3E32FF_V_MF2 + 0U, // PseudoVLSEG3E32FF_V_MF2_MASK + 0U, // PseudoVLSEG3E32_V_M1 + 0U, // PseudoVLSEG3E32_V_M1_MASK + 0U, // PseudoVLSEG3E32_V_M2 + 0U, // PseudoVLSEG3E32_V_M2_MASK + 0U, // PseudoVLSEG3E32_V_MF2 + 0U, // PseudoVLSEG3E32_V_MF2_MASK + 0U, // PseudoVLSEG3E64FF_V_M1 + 0U, // PseudoVLSEG3E64FF_V_M1_MASK + 0U, // PseudoVLSEG3E64FF_V_M2 + 0U, // PseudoVLSEG3E64FF_V_M2_MASK + 0U, // PseudoVLSEG3E64_V_M1 + 0U, // PseudoVLSEG3E64_V_M1_MASK + 0U, // PseudoVLSEG3E64_V_M2 + 0U, // PseudoVLSEG3E64_V_M2_MASK + 0U, // PseudoVLSEG3E8FF_V_M1 + 0U, // PseudoVLSEG3E8FF_V_M1_MASK + 0U, // PseudoVLSEG3E8FF_V_M2 + 0U, // PseudoVLSEG3E8FF_V_M2_MASK + 0U, // PseudoVLSEG3E8FF_V_MF2 + 0U, // PseudoVLSEG3E8FF_V_MF2_MASK + 0U, // PseudoVLSEG3E8FF_V_MF4 + 0U, // PseudoVLSEG3E8FF_V_MF4_MASK + 0U, // PseudoVLSEG3E8FF_V_MF8 + 0U, // PseudoVLSEG3E8FF_V_MF8_MASK + 0U, // PseudoVLSEG3E8_V_M1 + 0U, // PseudoVLSEG3E8_V_M1_MASK + 0U, // PseudoVLSEG3E8_V_M2 + 0U, // PseudoVLSEG3E8_V_M2_MASK + 0U, // PseudoVLSEG3E8_V_MF2 + 0U, // PseudoVLSEG3E8_V_MF2_MASK + 0U, // PseudoVLSEG3E8_V_MF4 + 0U, // PseudoVLSEG3E8_V_MF4_MASK + 0U, // PseudoVLSEG3E8_V_MF8 + 0U, // PseudoVLSEG3E8_V_MF8_MASK + 0U, // PseudoVLSEG4E16FF_V_M1 + 0U, // PseudoVLSEG4E16FF_V_M1_MASK + 0U, // PseudoVLSEG4E16FF_V_M2 + 0U, // PseudoVLSEG4E16FF_V_M2_MASK + 0U, // PseudoVLSEG4E16FF_V_MF2 + 0U, // PseudoVLSEG4E16FF_V_MF2_MASK + 0U, // PseudoVLSEG4E16FF_V_MF4 + 0U, // PseudoVLSEG4E16FF_V_MF4_MASK + 0U, // PseudoVLSEG4E16_V_M1 + 0U, // PseudoVLSEG4E16_V_M1_MASK + 0U, // PseudoVLSEG4E16_V_M2 + 0U, // PseudoVLSEG4E16_V_M2_MASK + 0U, // PseudoVLSEG4E16_V_MF2 + 0U, // PseudoVLSEG4E16_V_MF2_MASK + 0U, // PseudoVLSEG4E16_V_MF4 + 0U, // PseudoVLSEG4E16_V_MF4_MASK + 0U, // PseudoVLSEG4E32FF_V_M1 + 0U, // PseudoVLSEG4E32FF_V_M1_MASK + 0U, // PseudoVLSEG4E32FF_V_M2 + 0U, // PseudoVLSEG4E32FF_V_M2_MASK + 0U, // PseudoVLSEG4E32FF_V_MF2 + 0U, // PseudoVLSEG4E32FF_V_MF2_MASK + 0U, // PseudoVLSEG4E32_V_M1 + 0U, // PseudoVLSEG4E32_V_M1_MASK + 0U, // PseudoVLSEG4E32_V_M2 + 0U, // PseudoVLSEG4E32_V_M2_MASK + 0U, // PseudoVLSEG4E32_V_MF2 + 0U, // PseudoVLSEG4E32_V_MF2_MASK + 0U, // PseudoVLSEG4E64FF_V_M1 + 0U, // PseudoVLSEG4E64FF_V_M1_MASK + 0U, // PseudoVLSEG4E64FF_V_M2 + 0U, // PseudoVLSEG4E64FF_V_M2_MASK + 0U, // PseudoVLSEG4E64_V_M1 + 0U, // PseudoVLSEG4E64_V_M1_MASK + 0U, // PseudoVLSEG4E64_V_M2 + 0U, // PseudoVLSEG4E64_V_M2_MASK + 0U, // PseudoVLSEG4E8FF_V_M1 + 0U, // PseudoVLSEG4E8FF_V_M1_MASK + 0U, // PseudoVLSEG4E8FF_V_M2 + 0U, // PseudoVLSEG4E8FF_V_M2_MASK + 0U, // PseudoVLSEG4E8FF_V_MF2 + 0U, // PseudoVLSEG4E8FF_V_MF2_MASK + 0U, // PseudoVLSEG4E8FF_V_MF4 + 0U, // PseudoVLSEG4E8FF_V_MF4_MASK + 0U, // PseudoVLSEG4E8FF_V_MF8 + 0U, // PseudoVLSEG4E8FF_V_MF8_MASK + 0U, // PseudoVLSEG4E8_V_M1 + 0U, // PseudoVLSEG4E8_V_M1_MASK + 0U, // PseudoVLSEG4E8_V_M2 + 0U, // PseudoVLSEG4E8_V_M2_MASK + 0U, // PseudoVLSEG4E8_V_MF2 + 0U, // PseudoVLSEG4E8_V_MF2_MASK + 0U, // PseudoVLSEG4E8_V_MF4 + 0U, // PseudoVLSEG4E8_V_MF4_MASK + 0U, // PseudoVLSEG4E8_V_MF8 + 0U, // PseudoVLSEG4E8_V_MF8_MASK + 0U, // PseudoVLSEG5E16FF_V_M1 + 0U, // PseudoVLSEG5E16FF_V_M1_MASK + 0U, // PseudoVLSEG5E16FF_V_MF2 + 0U, // PseudoVLSEG5E16FF_V_MF2_MASK + 0U, // PseudoVLSEG5E16FF_V_MF4 + 0U, // PseudoVLSEG5E16FF_V_MF4_MASK + 0U, // PseudoVLSEG5E16_V_M1 + 0U, // PseudoVLSEG5E16_V_M1_MASK + 0U, // PseudoVLSEG5E16_V_MF2 + 0U, // PseudoVLSEG5E16_V_MF2_MASK + 0U, // PseudoVLSEG5E16_V_MF4 + 0U, // PseudoVLSEG5E16_V_MF4_MASK + 0U, // PseudoVLSEG5E32FF_V_M1 + 0U, // PseudoVLSEG5E32FF_V_M1_MASK + 0U, // PseudoVLSEG5E32FF_V_MF2 + 0U, // PseudoVLSEG5E32FF_V_MF2_MASK + 0U, // PseudoVLSEG5E32_V_M1 + 0U, // PseudoVLSEG5E32_V_M1_MASK + 0U, // PseudoVLSEG5E32_V_MF2 + 0U, // PseudoVLSEG5E32_V_MF2_MASK + 0U, // PseudoVLSEG5E64FF_V_M1 + 0U, // PseudoVLSEG5E64FF_V_M1_MASK + 0U, // PseudoVLSEG5E64_V_M1 + 0U, // PseudoVLSEG5E64_V_M1_MASK + 0U, // PseudoVLSEG5E8FF_V_M1 + 0U, // PseudoVLSEG5E8FF_V_M1_MASK + 0U, // PseudoVLSEG5E8FF_V_MF2 + 0U, // PseudoVLSEG5E8FF_V_MF2_MASK + 0U, // PseudoVLSEG5E8FF_V_MF4 + 0U, // PseudoVLSEG5E8FF_V_MF4_MASK + 0U, // PseudoVLSEG5E8FF_V_MF8 + 0U, // PseudoVLSEG5E8FF_V_MF8_MASK + 0U, // PseudoVLSEG5E8_V_M1 + 0U, // PseudoVLSEG5E8_V_M1_MASK + 0U, // PseudoVLSEG5E8_V_MF2 + 0U, // PseudoVLSEG5E8_V_MF2_MASK + 0U, // PseudoVLSEG5E8_V_MF4 + 0U, // PseudoVLSEG5E8_V_MF4_MASK + 0U, // PseudoVLSEG5E8_V_MF8 + 0U, // PseudoVLSEG5E8_V_MF8_MASK + 0U, // PseudoVLSEG6E16FF_V_M1 + 0U, // PseudoVLSEG6E16FF_V_M1_MASK + 0U, // PseudoVLSEG6E16FF_V_MF2 + 0U, // PseudoVLSEG6E16FF_V_MF2_MASK + 0U, // PseudoVLSEG6E16FF_V_MF4 + 0U, // PseudoVLSEG6E16FF_V_MF4_MASK + 0U, // PseudoVLSEG6E16_V_M1 + 0U, // PseudoVLSEG6E16_V_M1_MASK + 0U, // PseudoVLSEG6E16_V_MF2 + 0U, // PseudoVLSEG6E16_V_MF2_MASK + 0U, // PseudoVLSEG6E16_V_MF4 + 0U, // PseudoVLSEG6E16_V_MF4_MASK + 0U, // PseudoVLSEG6E32FF_V_M1 + 0U, // PseudoVLSEG6E32FF_V_M1_MASK + 0U, // PseudoVLSEG6E32FF_V_MF2 + 0U, // PseudoVLSEG6E32FF_V_MF2_MASK + 0U, // PseudoVLSEG6E32_V_M1 + 0U, // PseudoVLSEG6E32_V_M1_MASK + 0U, // PseudoVLSEG6E32_V_MF2 + 0U, // PseudoVLSEG6E32_V_MF2_MASK + 0U, // PseudoVLSEG6E64FF_V_M1 + 0U, // PseudoVLSEG6E64FF_V_M1_MASK + 0U, // PseudoVLSEG6E64_V_M1 + 0U, // PseudoVLSEG6E64_V_M1_MASK + 0U, // PseudoVLSEG6E8FF_V_M1 + 0U, // PseudoVLSEG6E8FF_V_M1_MASK + 0U, // PseudoVLSEG6E8FF_V_MF2 + 0U, // PseudoVLSEG6E8FF_V_MF2_MASK + 0U, // PseudoVLSEG6E8FF_V_MF4 + 0U, // PseudoVLSEG6E8FF_V_MF4_MASK + 0U, // PseudoVLSEG6E8FF_V_MF8 + 0U, // PseudoVLSEG6E8FF_V_MF8_MASK + 0U, // PseudoVLSEG6E8_V_M1 + 0U, // PseudoVLSEG6E8_V_M1_MASK + 0U, // PseudoVLSEG6E8_V_MF2 + 0U, // PseudoVLSEG6E8_V_MF2_MASK + 0U, // PseudoVLSEG6E8_V_MF4 + 0U, // PseudoVLSEG6E8_V_MF4_MASK + 0U, // PseudoVLSEG6E8_V_MF8 + 0U, // PseudoVLSEG6E8_V_MF8_MASK + 0U, // PseudoVLSEG7E16FF_V_M1 + 0U, // PseudoVLSEG7E16FF_V_M1_MASK + 0U, // PseudoVLSEG7E16FF_V_MF2 + 0U, // PseudoVLSEG7E16FF_V_MF2_MASK + 0U, // PseudoVLSEG7E16FF_V_MF4 + 0U, // PseudoVLSEG7E16FF_V_MF4_MASK + 0U, // PseudoVLSEG7E16_V_M1 + 0U, // PseudoVLSEG7E16_V_M1_MASK + 0U, // PseudoVLSEG7E16_V_MF2 + 0U, // PseudoVLSEG7E16_V_MF2_MASK + 0U, // PseudoVLSEG7E16_V_MF4 + 0U, // PseudoVLSEG7E16_V_MF4_MASK + 0U, // PseudoVLSEG7E32FF_V_M1 + 0U, // PseudoVLSEG7E32FF_V_M1_MASK + 0U, // PseudoVLSEG7E32FF_V_MF2 + 0U, // PseudoVLSEG7E32FF_V_MF2_MASK + 0U, // PseudoVLSEG7E32_V_M1 + 0U, // PseudoVLSEG7E32_V_M1_MASK + 0U, // PseudoVLSEG7E32_V_MF2 + 0U, // PseudoVLSEG7E32_V_MF2_MASK + 0U, // PseudoVLSEG7E64FF_V_M1 + 0U, // PseudoVLSEG7E64FF_V_M1_MASK + 0U, // PseudoVLSEG7E64_V_M1 + 0U, // PseudoVLSEG7E64_V_M1_MASK + 0U, // PseudoVLSEG7E8FF_V_M1 + 0U, // PseudoVLSEG7E8FF_V_M1_MASK + 0U, // PseudoVLSEG7E8FF_V_MF2 + 0U, // PseudoVLSEG7E8FF_V_MF2_MASK + 0U, // PseudoVLSEG7E8FF_V_MF4 + 0U, // PseudoVLSEG7E8FF_V_MF4_MASK + 0U, // PseudoVLSEG7E8FF_V_MF8 + 0U, // PseudoVLSEG7E8FF_V_MF8_MASK + 0U, // PseudoVLSEG7E8_V_M1 + 0U, // PseudoVLSEG7E8_V_M1_MASK + 0U, // PseudoVLSEG7E8_V_MF2 + 0U, // PseudoVLSEG7E8_V_MF2_MASK + 0U, // PseudoVLSEG7E8_V_MF4 + 0U, // PseudoVLSEG7E8_V_MF4_MASK + 0U, // PseudoVLSEG7E8_V_MF8 + 0U, // PseudoVLSEG7E8_V_MF8_MASK + 0U, // PseudoVLSEG8E16FF_V_M1 + 0U, // PseudoVLSEG8E16FF_V_M1_MASK + 0U, // PseudoVLSEG8E16FF_V_MF2 + 0U, // PseudoVLSEG8E16FF_V_MF2_MASK + 0U, // PseudoVLSEG8E16FF_V_MF4 + 0U, // PseudoVLSEG8E16FF_V_MF4_MASK + 0U, // PseudoVLSEG8E16_V_M1 + 0U, // PseudoVLSEG8E16_V_M1_MASK + 0U, // PseudoVLSEG8E16_V_MF2 + 0U, // PseudoVLSEG8E16_V_MF2_MASK + 0U, // PseudoVLSEG8E16_V_MF4 + 0U, // PseudoVLSEG8E16_V_MF4_MASK + 0U, // PseudoVLSEG8E32FF_V_M1 + 0U, // PseudoVLSEG8E32FF_V_M1_MASK + 0U, // PseudoVLSEG8E32FF_V_MF2 + 0U, // PseudoVLSEG8E32FF_V_MF2_MASK + 0U, // PseudoVLSEG8E32_V_M1 + 0U, // PseudoVLSEG8E32_V_M1_MASK + 0U, // PseudoVLSEG8E32_V_MF2 + 0U, // PseudoVLSEG8E32_V_MF2_MASK + 0U, // PseudoVLSEG8E64FF_V_M1 + 0U, // PseudoVLSEG8E64FF_V_M1_MASK + 0U, // PseudoVLSEG8E64_V_M1 + 0U, // PseudoVLSEG8E64_V_M1_MASK + 0U, // PseudoVLSEG8E8FF_V_M1 + 0U, // PseudoVLSEG8E8FF_V_M1_MASK + 0U, // PseudoVLSEG8E8FF_V_MF2 + 0U, // PseudoVLSEG8E8FF_V_MF2_MASK + 0U, // PseudoVLSEG8E8FF_V_MF4 + 0U, // PseudoVLSEG8E8FF_V_MF4_MASK + 0U, // PseudoVLSEG8E8FF_V_MF8 + 0U, // PseudoVLSEG8E8FF_V_MF8_MASK + 0U, // PseudoVLSEG8E8_V_M1 + 0U, // PseudoVLSEG8E8_V_M1_MASK + 0U, // PseudoVLSEG8E8_V_MF2 + 0U, // PseudoVLSEG8E8_V_MF2_MASK + 0U, // PseudoVLSEG8E8_V_MF4 + 0U, // PseudoVLSEG8E8_V_MF4_MASK + 0U, // PseudoVLSEG8E8_V_MF8 + 0U, // PseudoVLSEG8E8_V_MF8_MASK + 0U, // PseudoVLSSEG2E16_V_M1 + 0U, // PseudoVLSSEG2E16_V_M1_MASK + 0U, // PseudoVLSSEG2E16_V_M2 + 0U, // PseudoVLSSEG2E16_V_M2_MASK + 0U, // PseudoVLSSEG2E16_V_M4 + 0U, // PseudoVLSSEG2E16_V_M4_MASK + 0U, // PseudoVLSSEG2E16_V_MF2 + 0U, // PseudoVLSSEG2E16_V_MF2_MASK + 0U, // PseudoVLSSEG2E16_V_MF4 + 0U, // PseudoVLSSEG2E16_V_MF4_MASK + 0U, // PseudoVLSSEG2E32_V_M1 + 0U, // PseudoVLSSEG2E32_V_M1_MASK + 0U, // PseudoVLSSEG2E32_V_M2 + 0U, // PseudoVLSSEG2E32_V_M2_MASK + 0U, // PseudoVLSSEG2E32_V_M4 + 0U, // PseudoVLSSEG2E32_V_M4_MASK + 0U, // PseudoVLSSEG2E32_V_MF2 + 0U, // PseudoVLSSEG2E32_V_MF2_MASK + 0U, // PseudoVLSSEG2E64_V_M1 + 0U, // PseudoVLSSEG2E64_V_M1_MASK + 0U, // PseudoVLSSEG2E64_V_M2 + 0U, // PseudoVLSSEG2E64_V_M2_MASK + 0U, // PseudoVLSSEG2E64_V_M4 + 0U, // PseudoVLSSEG2E64_V_M4_MASK + 0U, // PseudoVLSSEG2E8_V_M1 + 0U, // PseudoVLSSEG2E8_V_M1_MASK + 0U, // PseudoVLSSEG2E8_V_M2 + 0U, // PseudoVLSSEG2E8_V_M2_MASK + 0U, // PseudoVLSSEG2E8_V_M4 + 0U, // PseudoVLSSEG2E8_V_M4_MASK + 0U, // PseudoVLSSEG2E8_V_MF2 + 0U, // PseudoVLSSEG2E8_V_MF2_MASK + 0U, // PseudoVLSSEG2E8_V_MF4 + 0U, // PseudoVLSSEG2E8_V_MF4_MASK + 0U, // PseudoVLSSEG2E8_V_MF8 + 0U, // PseudoVLSSEG2E8_V_MF8_MASK + 0U, // PseudoVLSSEG3E16_V_M1 + 0U, // PseudoVLSSEG3E16_V_M1_MASK + 0U, // PseudoVLSSEG3E16_V_M2 + 0U, // PseudoVLSSEG3E16_V_M2_MASK + 0U, // PseudoVLSSEG3E16_V_MF2 + 0U, // PseudoVLSSEG3E16_V_MF2_MASK + 0U, // PseudoVLSSEG3E16_V_MF4 + 0U, // PseudoVLSSEG3E16_V_MF4_MASK + 0U, // PseudoVLSSEG3E32_V_M1 + 0U, // PseudoVLSSEG3E32_V_M1_MASK + 0U, // PseudoVLSSEG3E32_V_M2 + 0U, // PseudoVLSSEG3E32_V_M2_MASK + 0U, // PseudoVLSSEG3E32_V_MF2 + 0U, // PseudoVLSSEG3E32_V_MF2_MASK + 0U, // PseudoVLSSEG3E64_V_M1 + 0U, // PseudoVLSSEG3E64_V_M1_MASK + 0U, // PseudoVLSSEG3E64_V_M2 + 0U, // PseudoVLSSEG3E64_V_M2_MASK + 0U, // PseudoVLSSEG3E8_V_M1 + 0U, // PseudoVLSSEG3E8_V_M1_MASK + 0U, // PseudoVLSSEG3E8_V_M2 + 0U, // PseudoVLSSEG3E8_V_M2_MASK + 0U, // PseudoVLSSEG3E8_V_MF2 + 0U, // PseudoVLSSEG3E8_V_MF2_MASK + 0U, // PseudoVLSSEG3E8_V_MF4 + 0U, // PseudoVLSSEG3E8_V_MF4_MASK + 0U, // PseudoVLSSEG3E8_V_MF8 + 0U, // PseudoVLSSEG3E8_V_MF8_MASK + 0U, // PseudoVLSSEG4E16_V_M1 + 0U, // PseudoVLSSEG4E16_V_M1_MASK + 0U, // PseudoVLSSEG4E16_V_M2 + 0U, // PseudoVLSSEG4E16_V_M2_MASK + 0U, // PseudoVLSSEG4E16_V_MF2 + 0U, // PseudoVLSSEG4E16_V_MF2_MASK + 0U, // PseudoVLSSEG4E16_V_MF4 + 0U, // PseudoVLSSEG4E16_V_MF4_MASK + 0U, // PseudoVLSSEG4E32_V_M1 + 0U, // PseudoVLSSEG4E32_V_M1_MASK + 0U, // PseudoVLSSEG4E32_V_M2 + 0U, // PseudoVLSSEG4E32_V_M2_MASK + 0U, // PseudoVLSSEG4E32_V_MF2 + 0U, // PseudoVLSSEG4E32_V_MF2_MASK + 0U, // PseudoVLSSEG4E64_V_M1 + 0U, // PseudoVLSSEG4E64_V_M1_MASK + 0U, // PseudoVLSSEG4E64_V_M2 + 0U, // PseudoVLSSEG4E64_V_M2_MASK + 0U, // PseudoVLSSEG4E8_V_M1 + 0U, // PseudoVLSSEG4E8_V_M1_MASK + 0U, // PseudoVLSSEG4E8_V_M2 + 0U, // PseudoVLSSEG4E8_V_M2_MASK + 0U, // PseudoVLSSEG4E8_V_MF2 + 0U, // PseudoVLSSEG4E8_V_MF2_MASK + 0U, // PseudoVLSSEG4E8_V_MF4 + 0U, // PseudoVLSSEG4E8_V_MF4_MASK + 0U, // PseudoVLSSEG4E8_V_MF8 + 0U, // PseudoVLSSEG4E8_V_MF8_MASK + 0U, // PseudoVLSSEG5E16_V_M1 + 0U, // PseudoVLSSEG5E16_V_M1_MASK + 0U, // PseudoVLSSEG5E16_V_MF2 + 0U, // PseudoVLSSEG5E16_V_MF2_MASK + 0U, // PseudoVLSSEG5E16_V_MF4 + 0U, // PseudoVLSSEG5E16_V_MF4_MASK + 0U, // PseudoVLSSEG5E32_V_M1 + 0U, // PseudoVLSSEG5E32_V_M1_MASK + 0U, // PseudoVLSSEG5E32_V_MF2 + 0U, // PseudoVLSSEG5E32_V_MF2_MASK + 0U, // PseudoVLSSEG5E64_V_M1 + 0U, // PseudoVLSSEG5E64_V_M1_MASK + 0U, // PseudoVLSSEG5E8_V_M1 + 0U, // PseudoVLSSEG5E8_V_M1_MASK + 0U, // PseudoVLSSEG5E8_V_MF2 + 0U, // PseudoVLSSEG5E8_V_MF2_MASK + 0U, // PseudoVLSSEG5E8_V_MF4 + 0U, // PseudoVLSSEG5E8_V_MF4_MASK + 0U, // PseudoVLSSEG5E8_V_MF8 + 0U, // PseudoVLSSEG5E8_V_MF8_MASK + 0U, // PseudoVLSSEG6E16_V_M1 + 0U, // PseudoVLSSEG6E16_V_M1_MASK + 0U, // PseudoVLSSEG6E16_V_MF2 + 0U, // PseudoVLSSEG6E16_V_MF2_MASK + 0U, // PseudoVLSSEG6E16_V_MF4 + 0U, // PseudoVLSSEG6E16_V_MF4_MASK + 0U, // PseudoVLSSEG6E32_V_M1 + 0U, // PseudoVLSSEG6E32_V_M1_MASK + 0U, // PseudoVLSSEG6E32_V_MF2 + 0U, // PseudoVLSSEG6E32_V_MF2_MASK + 0U, // PseudoVLSSEG6E64_V_M1 + 0U, // PseudoVLSSEG6E64_V_M1_MASK + 0U, // PseudoVLSSEG6E8_V_M1 + 0U, // PseudoVLSSEG6E8_V_M1_MASK + 0U, // PseudoVLSSEG6E8_V_MF2 + 0U, // PseudoVLSSEG6E8_V_MF2_MASK + 0U, // PseudoVLSSEG6E8_V_MF4 + 0U, // PseudoVLSSEG6E8_V_MF4_MASK + 0U, // PseudoVLSSEG6E8_V_MF8 + 0U, // PseudoVLSSEG6E8_V_MF8_MASK + 0U, // PseudoVLSSEG7E16_V_M1 + 0U, // PseudoVLSSEG7E16_V_M1_MASK + 0U, // PseudoVLSSEG7E16_V_MF2 + 0U, // PseudoVLSSEG7E16_V_MF2_MASK + 0U, // PseudoVLSSEG7E16_V_MF4 + 0U, // PseudoVLSSEG7E16_V_MF4_MASK + 0U, // PseudoVLSSEG7E32_V_M1 + 0U, // PseudoVLSSEG7E32_V_M1_MASK + 0U, // PseudoVLSSEG7E32_V_MF2 + 0U, // PseudoVLSSEG7E32_V_MF2_MASK + 0U, // PseudoVLSSEG7E64_V_M1 + 0U, // PseudoVLSSEG7E64_V_M1_MASK + 0U, // PseudoVLSSEG7E8_V_M1 + 0U, // PseudoVLSSEG7E8_V_M1_MASK + 0U, // PseudoVLSSEG7E8_V_MF2 + 0U, // PseudoVLSSEG7E8_V_MF2_MASK + 0U, // PseudoVLSSEG7E8_V_MF4 + 0U, // PseudoVLSSEG7E8_V_MF4_MASK + 0U, // PseudoVLSSEG7E8_V_MF8 + 0U, // PseudoVLSSEG7E8_V_MF8_MASK + 0U, // PseudoVLSSEG8E16_V_M1 + 0U, // PseudoVLSSEG8E16_V_M1_MASK + 0U, // PseudoVLSSEG8E16_V_MF2 + 0U, // PseudoVLSSEG8E16_V_MF2_MASK + 0U, // PseudoVLSSEG8E16_V_MF4 + 0U, // PseudoVLSSEG8E16_V_MF4_MASK + 0U, // PseudoVLSSEG8E32_V_M1 + 0U, // PseudoVLSSEG8E32_V_M1_MASK + 0U, // PseudoVLSSEG8E32_V_MF2 + 0U, // PseudoVLSSEG8E32_V_MF2_MASK + 0U, // PseudoVLSSEG8E64_V_M1 + 0U, // PseudoVLSSEG8E64_V_M1_MASK + 0U, // PseudoVLSSEG8E8_V_M1 + 0U, // PseudoVLSSEG8E8_V_M1_MASK + 0U, // PseudoVLSSEG8E8_V_MF2 + 0U, // PseudoVLSSEG8E8_V_MF2_MASK + 0U, // PseudoVLSSEG8E8_V_MF4 + 0U, // PseudoVLSSEG8E8_V_MF4_MASK + 0U, // PseudoVLSSEG8E8_V_MF8 + 0U, // PseudoVLSSEG8E8_V_MF8_MASK + 0U, // PseudoVLUXEI16_V_M1_M1 + 0U, // PseudoVLUXEI16_V_M1_M1_MASK + 0U, // PseudoVLUXEI16_V_M1_M2 + 0U, // PseudoVLUXEI16_V_M1_M2_MASK + 0U, // PseudoVLUXEI16_V_M1_M4 + 0U, // PseudoVLUXEI16_V_M1_M4_MASK + 0U, // PseudoVLUXEI16_V_M1_MF2 + 0U, // PseudoVLUXEI16_V_M1_MF2_MASK + 0U, // PseudoVLUXEI16_V_M2_M1 + 0U, // PseudoVLUXEI16_V_M2_M1_MASK + 0U, // PseudoVLUXEI16_V_M2_M2 + 0U, // PseudoVLUXEI16_V_M2_M2_MASK + 0U, // PseudoVLUXEI16_V_M2_M4 + 0U, // PseudoVLUXEI16_V_M2_M4_MASK + 0U, // PseudoVLUXEI16_V_M2_M8 + 0U, // PseudoVLUXEI16_V_M2_M8_MASK + 0U, // PseudoVLUXEI16_V_M4_M2 + 0U, // PseudoVLUXEI16_V_M4_M2_MASK + 0U, // PseudoVLUXEI16_V_M4_M4 + 0U, // PseudoVLUXEI16_V_M4_M4_MASK + 0U, // PseudoVLUXEI16_V_M4_M8 + 0U, // PseudoVLUXEI16_V_M4_M8_MASK + 0U, // PseudoVLUXEI16_V_M8_M4 + 0U, // PseudoVLUXEI16_V_M8_M4_MASK + 0U, // PseudoVLUXEI16_V_M8_M8 + 0U, // PseudoVLUXEI16_V_M8_M8_MASK + 0U, // PseudoVLUXEI16_V_MF2_M1 + 0U, // PseudoVLUXEI16_V_MF2_M1_MASK + 0U, // PseudoVLUXEI16_V_MF2_M2 + 0U, // PseudoVLUXEI16_V_MF2_M2_MASK + 0U, // PseudoVLUXEI16_V_MF2_MF2 + 0U, // PseudoVLUXEI16_V_MF2_MF2_MASK + 0U, // PseudoVLUXEI16_V_MF2_MF4 + 0U, // PseudoVLUXEI16_V_MF2_MF4_MASK + 0U, // PseudoVLUXEI16_V_MF4_M1 + 0U, // PseudoVLUXEI16_V_MF4_M1_MASK + 0U, // PseudoVLUXEI16_V_MF4_MF2 + 0U, // PseudoVLUXEI16_V_MF4_MF2_MASK + 0U, // PseudoVLUXEI16_V_MF4_MF4 + 0U, // PseudoVLUXEI16_V_MF4_MF4_MASK + 0U, // PseudoVLUXEI16_V_MF4_MF8 + 0U, // PseudoVLUXEI16_V_MF4_MF8_MASK + 0U, // PseudoVLUXEI32_V_M1_M1 + 0U, // PseudoVLUXEI32_V_M1_M1_MASK + 0U, // PseudoVLUXEI32_V_M1_M2 + 0U, // PseudoVLUXEI32_V_M1_M2_MASK + 0U, // PseudoVLUXEI32_V_M1_MF2 + 0U, // PseudoVLUXEI32_V_M1_MF2_MASK + 0U, // PseudoVLUXEI32_V_M1_MF4 + 0U, // PseudoVLUXEI32_V_M1_MF4_MASK + 0U, // PseudoVLUXEI32_V_M2_M1 + 0U, // PseudoVLUXEI32_V_M2_M1_MASK + 0U, // PseudoVLUXEI32_V_M2_M2 + 0U, // PseudoVLUXEI32_V_M2_M2_MASK + 0U, // PseudoVLUXEI32_V_M2_M4 + 0U, // PseudoVLUXEI32_V_M2_M4_MASK + 0U, // PseudoVLUXEI32_V_M2_MF2 + 0U, // PseudoVLUXEI32_V_M2_MF2_MASK + 0U, // PseudoVLUXEI32_V_M4_M1 + 0U, // PseudoVLUXEI32_V_M4_M1_MASK + 0U, // PseudoVLUXEI32_V_M4_M2 + 0U, // PseudoVLUXEI32_V_M4_M2_MASK + 0U, // PseudoVLUXEI32_V_M4_M4 + 0U, // PseudoVLUXEI32_V_M4_M4_MASK + 0U, // PseudoVLUXEI32_V_M4_M8 + 0U, // PseudoVLUXEI32_V_M4_M8_MASK + 0U, // PseudoVLUXEI32_V_M8_M2 + 0U, // PseudoVLUXEI32_V_M8_M2_MASK + 0U, // PseudoVLUXEI32_V_M8_M4 + 0U, // PseudoVLUXEI32_V_M8_M4_MASK + 0U, // PseudoVLUXEI32_V_M8_M8 + 0U, // PseudoVLUXEI32_V_M8_M8_MASK + 0U, // PseudoVLUXEI32_V_MF2_M1 + 0U, // PseudoVLUXEI32_V_MF2_M1_MASK + 0U, // PseudoVLUXEI32_V_MF2_MF2 + 0U, // PseudoVLUXEI32_V_MF2_MF2_MASK + 0U, // PseudoVLUXEI32_V_MF2_MF4 + 0U, // PseudoVLUXEI32_V_MF2_MF4_MASK + 0U, // PseudoVLUXEI32_V_MF2_MF8 + 0U, // PseudoVLUXEI32_V_MF2_MF8_MASK + 0U, // PseudoVLUXEI64_V_M1_M1 + 0U, // PseudoVLUXEI64_V_M1_M1_MASK + 0U, // PseudoVLUXEI64_V_M1_MF2 + 0U, // PseudoVLUXEI64_V_M1_MF2_MASK + 0U, // PseudoVLUXEI64_V_M1_MF4 + 0U, // PseudoVLUXEI64_V_M1_MF4_MASK + 0U, // PseudoVLUXEI64_V_M1_MF8 + 0U, // PseudoVLUXEI64_V_M1_MF8_MASK + 0U, // PseudoVLUXEI64_V_M2_M1 + 0U, // PseudoVLUXEI64_V_M2_M1_MASK + 0U, // PseudoVLUXEI64_V_M2_M2 + 0U, // PseudoVLUXEI64_V_M2_M2_MASK + 0U, // PseudoVLUXEI64_V_M2_MF2 + 0U, // PseudoVLUXEI64_V_M2_MF2_MASK + 0U, // PseudoVLUXEI64_V_M2_MF4 + 0U, // PseudoVLUXEI64_V_M2_MF4_MASK + 0U, // PseudoVLUXEI64_V_M4_M1 + 0U, // PseudoVLUXEI64_V_M4_M1_MASK + 0U, // PseudoVLUXEI64_V_M4_M2 + 0U, // PseudoVLUXEI64_V_M4_M2_MASK + 0U, // PseudoVLUXEI64_V_M4_M4 + 0U, // PseudoVLUXEI64_V_M4_M4_MASK + 0U, // PseudoVLUXEI64_V_M4_MF2 + 0U, // PseudoVLUXEI64_V_M4_MF2_MASK + 0U, // PseudoVLUXEI64_V_M8_M1 + 0U, // PseudoVLUXEI64_V_M8_M1_MASK + 0U, // PseudoVLUXEI64_V_M8_M2 + 0U, // PseudoVLUXEI64_V_M8_M2_MASK + 0U, // PseudoVLUXEI64_V_M8_M4 + 0U, // PseudoVLUXEI64_V_M8_M4_MASK + 0U, // PseudoVLUXEI64_V_M8_M8 + 0U, // PseudoVLUXEI64_V_M8_M8_MASK + 0U, // PseudoVLUXEI8_V_M1_M1 + 0U, // PseudoVLUXEI8_V_M1_M1_MASK + 0U, // PseudoVLUXEI8_V_M1_M2 + 0U, // PseudoVLUXEI8_V_M1_M2_MASK + 0U, // PseudoVLUXEI8_V_M1_M4 + 0U, // PseudoVLUXEI8_V_M1_M4_MASK + 0U, // PseudoVLUXEI8_V_M1_M8 + 0U, // PseudoVLUXEI8_V_M1_M8_MASK + 0U, // PseudoVLUXEI8_V_M2_M2 + 0U, // PseudoVLUXEI8_V_M2_M2_MASK + 0U, // PseudoVLUXEI8_V_M2_M4 + 0U, // PseudoVLUXEI8_V_M2_M4_MASK + 0U, // PseudoVLUXEI8_V_M2_M8 + 0U, // PseudoVLUXEI8_V_M2_M8_MASK + 0U, // PseudoVLUXEI8_V_M4_M4 + 0U, // PseudoVLUXEI8_V_M4_M4_MASK + 0U, // PseudoVLUXEI8_V_M4_M8 + 0U, // PseudoVLUXEI8_V_M4_M8_MASK + 0U, // PseudoVLUXEI8_V_M8_M8 + 0U, // PseudoVLUXEI8_V_M8_M8_MASK + 0U, // PseudoVLUXEI8_V_MF2_M1 + 0U, // PseudoVLUXEI8_V_MF2_M1_MASK + 0U, // PseudoVLUXEI8_V_MF2_M2 + 0U, // PseudoVLUXEI8_V_MF2_M2_MASK + 0U, // PseudoVLUXEI8_V_MF2_M4 + 0U, // PseudoVLUXEI8_V_MF2_M4_MASK + 0U, // PseudoVLUXEI8_V_MF2_MF2 + 0U, // PseudoVLUXEI8_V_MF2_MF2_MASK + 0U, // PseudoVLUXEI8_V_MF4_M1 + 0U, // PseudoVLUXEI8_V_MF4_M1_MASK + 0U, // PseudoVLUXEI8_V_MF4_M2 + 0U, // PseudoVLUXEI8_V_MF4_M2_MASK + 0U, // PseudoVLUXEI8_V_MF4_MF2 + 0U, // PseudoVLUXEI8_V_MF4_MF2_MASK + 0U, // PseudoVLUXEI8_V_MF4_MF4 + 0U, // PseudoVLUXEI8_V_MF4_MF4_MASK + 0U, // PseudoVLUXEI8_V_MF8_M1 + 0U, // PseudoVLUXEI8_V_MF8_M1_MASK + 0U, // PseudoVLUXEI8_V_MF8_MF2 + 0U, // PseudoVLUXEI8_V_MF8_MF2_MASK + 0U, // PseudoVLUXEI8_V_MF8_MF4 + 0U, // PseudoVLUXEI8_V_MF8_MF4_MASK + 0U, // PseudoVLUXEI8_V_MF8_MF8 + 0U, // PseudoVLUXEI8_V_MF8_MF8_MASK + 0U, // PseudoVLUXSEG2EI16_V_M1_M1 + 0U, // PseudoVLUXSEG2EI16_V_M1_M1_MASK + 0U, // PseudoVLUXSEG2EI16_V_M1_M2 + 0U, // PseudoVLUXSEG2EI16_V_M1_M2_MASK + 0U, // PseudoVLUXSEG2EI16_V_M1_M4 + 0U, // PseudoVLUXSEG2EI16_V_M1_M4_MASK + 0U, // PseudoVLUXSEG2EI16_V_M1_MF2 + 0U, // PseudoVLUXSEG2EI16_V_M1_MF2_MASK + 0U, // PseudoVLUXSEG2EI16_V_M2_M1 + 0U, // PseudoVLUXSEG2EI16_V_M2_M1_MASK + 0U, // PseudoVLUXSEG2EI16_V_M2_M2 + 0U, // PseudoVLUXSEG2EI16_V_M2_M2_MASK + 0U, // PseudoVLUXSEG2EI16_V_M2_M4 + 0U, // PseudoVLUXSEG2EI16_V_M2_M4_MASK + 0U, // PseudoVLUXSEG2EI16_V_M4_M2 + 0U, // PseudoVLUXSEG2EI16_V_M4_M2_MASK + 0U, // PseudoVLUXSEG2EI16_V_M4_M4 + 0U, // PseudoVLUXSEG2EI16_V_M4_M4_MASK + 0U, // PseudoVLUXSEG2EI16_V_M8_M4 + 0U, // PseudoVLUXSEG2EI16_V_M8_M4_MASK + 0U, // PseudoVLUXSEG2EI16_V_MF2_M1 + 0U, // PseudoVLUXSEG2EI16_V_MF2_M1_MASK + 0U, // PseudoVLUXSEG2EI16_V_MF2_M2 + 0U, // PseudoVLUXSEG2EI16_V_MF2_M2_MASK + 0U, // PseudoVLUXSEG2EI16_V_MF2_MF2 + 0U, // PseudoVLUXSEG2EI16_V_MF2_MF2_MASK + 0U, // PseudoVLUXSEG2EI16_V_MF2_MF4 + 0U, // PseudoVLUXSEG2EI16_V_MF2_MF4_MASK + 0U, // PseudoVLUXSEG2EI16_V_MF4_M1 + 0U, // PseudoVLUXSEG2EI16_V_MF4_M1_MASK + 0U, // PseudoVLUXSEG2EI16_V_MF4_MF2 + 0U, // PseudoVLUXSEG2EI16_V_MF4_MF2_MASK + 0U, // PseudoVLUXSEG2EI16_V_MF4_MF4 + 0U, // PseudoVLUXSEG2EI16_V_MF4_MF4_MASK + 0U, // PseudoVLUXSEG2EI16_V_MF4_MF8 + 0U, // PseudoVLUXSEG2EI16_V_MF4_MF8_MASK + 0U, // PseudoVLUXSEG2EI32_V_M1_M1 + 0U, // PseudoVLUXSEG2EI32_V_M1_M1_MASK + 0U, // PseudoVLUXSEG2EI32_V_M1_M2 + 0U, // PseudoVLUXSEG2EI32_V_M1_M2_MASK + 0U, // PseudoVLUXSEG2EI32_V_M1_MF2 + 0U, // PseudoVLUXSEG2EI32_V_M1_MF2_MASK + 0U, // PseudoVLUXSEG2EI32_V_M1_MF4 + 0U, // PseudoVLUXSEG2EI32_V_M1_MF4_MASK + 0U, // PseudoVLUXSEG2EI32_V_M2_M1 + 0U, // PseudoVLUXSEG2EI32_V_M2_M1_MASK + 0U, // PseudoVLUXSEG2EI32_V_M2_M2 + 0U, // PseudoVLUXSEG2EI32_V_M2_M2_MASK + 0U, // PseudoVLUXSEG2EI32_V_M2_M4 + 0U, // PseudoVLUXSEG2EI32_V_M2_M4_MASK + 0U, // PseudoVLUXSEG2EI32_V_M2_MF2 + 0U, // PseudoVLUXSEG2EI32_V_M2_MF2_MASK + 0U, // PseudoVLUXSEG2EI32_V_M4_M1 + 0U, // PseudoVLUXSEG2EI32_V_M4_M1_MASK + 0U, // PseudoVLUXSEG2EI32_V_M4_M2 + 0U, // PseudoVLUXSEG2EI32_V_M4_M2_MASK + 0U, // PseudoVLUXSEG2EI32_V_M4_M4 + 0U, // PseudoVLUXSEG2EI32_V_M4_M4_MASK + 0U, // PseudoVLUXSEG2EI32_V_M8_M2 + 0U, // PseudoVLUXSEG2EI32_V_M8_M2_MASK + 0U, // PseudoVLUXSEG2EI32_V_M8_M4 + 0U, // PseudoVLUXSEG2EI32_V_M8_M4_MASK + 0U, // PseudoVLUXSEG2EI32_V_MF2_M1 + 0U, // PseudoVLUXSEG2EI32_V_MF2_M1_MASK + 0U, // PseudoVLUXSEG2EI32_V_MF2_MF2 + 0U, // PseudoVLUXSEG2EI32_V_MF2_MF2_MASK + 0U, // PseudoVLUXSEG2EI32_V_MF2_MF4 + 0U, // PseudoVLUXSEG2EI32_V_MF2_MF4_MASK + 0U, // PseudoVLUXSEG2EI32_V_MF2_MF8 + 0U, // PseudoVLUXSEG2EI32_V_MF2_MF8_MASK + 0U, // PseudoVLUXSEG2EI64_V_M1_M1 + 0U, // PseudoVLUXSEG2EI64_V_M1_M1_MASK + 0U, // PseudoVLUXSEG2EI64_V_M1_MF2 + 0U, // PseudoVLUXSEG2EI64_V_M1_MF2_MASK + 0U, // PseudoVLUXSEG2EI64_V_M1_MF4 + 0U, // PseudoVLUXSEG2EI64_V_M1_MF4_MASK + 0U, // PseudoVLUXSEG2EI64_V_M1_MF8 + 0U, // PseudoVLUXSEG2EI64_V_M1_MF8_MASK + 0U, // PseudoVLUXSEG2EI64_V_M2_M1 + 0U, // PseudoVLUXSEG2EI64_V_M2_M1_MASK + 0U, // PseudoVLUXSEG2EI64_V_M2_M2 + 0U, // PseudoVLUXSEG2EI64_V_M2_M2_MASK + 0U, // PseudoVLUXSEG2EI64_V_M2_MF2 + 0U, // PseudoVLUXSEG2EI64_V_M2_MF2_MASK + 0U, // PseudoVLUXSEG2EI64_V_M2_MF4 + 0U, // PseudoVLUXSEG2EI64_V_M2_MF4_MASK + 0U, // PseudoVLUXSEG2EI64_V_M4_M1 + 0U, // PseudoVLUXSEG2EI64_V_M4_M1_MASK + 0U, // PseudoVLUXSEG2EI64_V_M4_M2 + 0U, // PseudoVLUXSEG2EI64_V_M4_M2_MASK + 0U, // PseudoVLUXSEG2EI64_V_M4_M4 + 0U, // PseudoVLUXSEG2EI64_V_M4_M4_MASK + 0U, // PseudoVLUXSEG2EI64_V_M4_MF2 + 0U, // PseudoVLUXSEG2EI64_V_M4_MF2_MASK + 0U, // PseudoVLUXSEG2EI64_V_M8_M1 + 0U, // PseudoVLUXSEG2EI64_V_M8_M1_MASK + 0U, // PseudoVLUXSEG2EI64_V_M8_M2 + 0U, // PseudoVLUXSEG2EI64_V_M8_M2_MASK + 0U, // PseudoVLUXSEG2EI64_V_M8_M4 + 0U, // PseudoVLUXSEG2EI64_V_M8_M4_MASK + 0U, // PseudoVLUXSEG2EI8_V_M1_M1 + 0U, // PseudoVLUXSEG2EI8_V_M1_M1_MASK + 0U, // PseudoVLUXSEG2EI8_V_M1_M2 + 0U, // PseudoVLUXSEG2EI8_V_M1_M2_MASK + 0U, // PseudoVLUXSEG2EI8_V_M1_M4 + 0U, // PseudoVLUXSEG2EI8_V_M1_M4_MASK + 0U, // PseudoVLUXSEG2EI8_V_M2_M2 + 0U, // PseudoVLUXSEG2EI8_V_M2_M2_MASK + 0U, // PseudoVLUXSEG2EI8_V_M2_M4 + 0U, // PseudoVLUXSEG2EI8_V_M2_M4_MASK + 0U, // PseudoVLUXSEG2EI8_V_M4_M4 + 0U, // PseudoVLUXSEG2EI8_V_M4_M4_MASK + 0U, // PseudoVLUXSEG2EI8_V_MF2_M1 + 0U, // PseudoVLUXSEG2EI8_V_MF2_M1_MASK + 0U, // PseudoVLUXSEG2EI8_V_MF2_M2 + 0U, // PseudoVLUXSEG2EI8_V_MF2_M2_MASK + 0U, // PseudoVLUXSEG2EI8_V_MF2_M4 + 0U, // PseudoVLUXSEG2EI8_V_MF2_M4_MASK + 0U, // PseudoVLUXSEG2EI8_V_MF2_MF2 + 0U, // PseudoVLUXSEG2EI8_V_MF2_MF2_MASK + 0U, // PseudoVLUXSEG2EI8_V_MF4_M1 + 0U, // PseudoVLUXSEG2EI8_V_MF4_M1_MASK + 0U, // PseudoVLUXSEG2EI8_V_MF4_M2 + 0U, // PseudoVLUXSEG2EI8_V_MF4_M2_MASK + 0U, // PseudoVLUXSEG2EI8_V_MF4_MF2 + 0U, // PseudoVLUXSEG2EI8_V_MF4_MF2_MASK + 0U, // PseudoVLUXSEG2EI8_V_MF4_MF4 + 0U, // PseudoVLUXSEG2EI8_V_MF4_MF4_MASK + 0U, // PseudoVLUXSEG2EI8_V_MF8_M1 + 0U, // PseudoVLUXSEG2EI8_V_MF8_M1_MASK + 0U, // PseudoVLUXSEG2EI8_V_MF8_MF2 + 0U, // PseudoVLUXSEG2EI8_V_MF8_MF2_MASK + 0U, // PseudoVLUXSEG2EI8_V_MF8_MF4 + 0U, // PseudoVLUXSEG2EI8_V_MF8_MF4_MASK + 0U, // PseudoVLUXSEG2EI8_V_MF8_MF8 + 0U, // PseudoVLUXSEG2EI8_V_MF8_MF8_MASK + 0U, // PseudoVLUXSEG3EI16_V_M1_M1 + 0U, // PseudoVLUXSEG3EI16_V_M1_M1_MASK + 0U, // PseudoVLUXSEG3EI16_V_M1_M2 + 0U, // PseudoVLUXSEG3EI16_V_M1_M2_MASK + 0U, // PseudoVLUXSEG3EI16_V_M1_MF2 + 0U, // PseudoVLUXSEG3EI16_V_M1_MF2_MASK + 0U, // PseudoVLUXSEG3EI16_V_M2_M1 + 0U, // PseudoVLUXSEG3EI16_V_M2_M1_MASK + 0U, // PseudoVLUXSEG3EI16_V_M2_M2 + 0U, // PseudoVLUXSEG3EI16_V_M2_M2_MASK + 0U, // PseudoVLUXSEG3EI16_V_M4_M2 + 0U, // PseudoVLUXSEG3EI16_V_M4_M2_MASK + 0U, // PseudoVLUXSEG3EI16_V_MF2_M1 + 0U, // PseudoVLUXSEG3EI16_V_MF2_M1_MASK + 0U, // PseudoVLUXSEG3EI16_V_MF2_M2 + 0U, // PseudoVLUXSEG3EI16_V_MF2_M2_MASK + 0U, // PseudoVLUXSEG3EI16_V_MF2_MF2 + 0U, // PseudoVLUXSEG3EI16_V_MF2_MF2_MASK + 0U, // PseudoVLUXSEG3EI16_V_MF2_MF4 + 0U, // PseudoVLUXSEG3EI16_V_MF2_MF4_MASK + 0U, // PseudoVLUXSEG3EI16_V_MF4_M1 + 0U, // PseudoVLUXSEG3EI16_V_MF4_M1_MASK + 0U, // PseudoVLUXSEG3EI16_V_MF4_MF2 + 0U, // PseudoVLUXSEG3EI16_V_MF4_MF2_MASK + 0U, // PseudoVLUXSEG3EI16_V_MF4_MF4 + 0U, // PseudoVLUXSEG3EI16_V_MF4_MF4_MASK + 0U, // PseudoVLUXSEG3EI16_V_MF4_MF8 + 0U, // PseudoVLUXSEG3EI16_V_MF4_MF8_MASK + 0U, // PseudoVLUXSEG3EI32_V_M1_M1 + 0U, // PseudoVLUXSEG3EI32_V_M1_M1_MASK + 0U, // PseudoVLUXSEG3EI32_V_M1_M2 + 0U, // PseudoVLUXSEG3EI32_V_M1_M2_MASK + 0U, // PseudoVLUXSEG3EI32_V_M1_MF2 + 0U, // PseudoVLUXSEG3EI32_V_M1_MF2_MASK + 0U, // PseudoVLUXSEG3EI32_V_M1_MF4 + 0U, // PseudoVLUXSEG3EI32_V_M1_MF4_MASK + 0U, // PseudoVLUXSEG3EI32_V_M2_M1 + 0U, // PseudoVLUXSEG3EI32_V_M2_M1_MASK + 0U, // PseudoVLUXSEG3EI32_V_M2_M2 + 0U, // PseudoVLUXSEG3EI32_V_M2_M2_MASK + 0U, // PseudoVLUXSEG3EI32_V_M2_MF2 + 0U, // PseudoVLUXSEG3EI32_V_M2_MF2_MASK + 0U, // PseudoVLUXSEG3EI32_V_M4_M1 + 0U, // PseudoVLUXSEG3EI32_V_M4_M1_MASK + 0U, // PseudoVLUXSEG3EI32_V_M4_M2 + 0U, // PseudoVLUXSEG3EI32_V_M4_M2_MASK + 0U, // PseudoVLUXSEG3EI32_V_M8_M2 + 0U, // PseudoVLUXSEG3EI32_V_M8_M2_MASK + 0U, // PseudoVLUXSEG3EI32_V_MF2_M1 + 0U, // PseudoVLUXSEG3EI32_V_MF2_M1_MASK + 0U, // PseudoVLUXSEG3EI32_V_MF2_MF2 + 0U, // PseudoVLUXSEG3EI32_V_MF2_MF2_MASK + 0U, // PseudoVLUXSEG3EI32_V_MF2_MF4 + 0U, // PseudoVLUXSEG3EI32_V_MF2_MF4_MASK + 0U, // PseudoVLUXSEG3EI32_V_MF2_MF8 + 0U, // PseudoVLUXSEG3EI32_V_MF2_MF8_MASK + 0U, // PseudoVLUXSEG3EI64_V_M1_M1 + 0U, // PseudoVLUXSEG3EI64_V_M1_M1_MASK + 0U, // PseudoVLUXSEG3EI64_V_M1_MF2 + 0U, // PseudoVLUXSEG3EI64_V_M1_MF2_MASK + 0U, // PseudoVLUXSEG3EI64_V_M1_MF4 + 0U, // PseudoVLUXSEG3EI64_V_M1_MF4_MASK + 0U, // PseudoVLUXSEG3EI64_V_M1_MF8 + 0U, // PseudoVLUXSEG3EI64_V_M1_MF8_MASK + 0U, // PseudoVLUXSEG3EI64_V_M2_M1 + 0U, // PseudoVLUXSEG3EI64_V_M2_M1_MASK + 0U, // PseudoVLUXSEG3EI64_V_M2_M2 + 0U, // PseudoVLUXSEG3EI64_V_M2_M2_MASK + 0U, // PseudoVLUXSEG3EI64_V_M2_MF2 + 0U, // PseudoVLUXSEG3EI64_V_M2_MF2_MASK + 0U, // PseudoVLUXSEG3EI64_V_M2_MF4 + 0U, // PseudoVLUXSEG3EI64_V_M2_MF4_MASK + 0U, // PseudoVLUXSEG3EI64_V_M4_M1 + 0U, // PseudoVLUXSEG3EI64_V_M4_M1_MASK + 0U, // PseudoVLUXSEG3EI64_V_M4_M2 + 0U, // PseudoVLUXSEG3EI64_V_M4_M2_MASK + 0U, // PseudoVLUXSEG3EI64_V_M4_MF2 + 0U, // PseudoVLUXSEG3EI64_V_M4_MF2_MASK + 0U, // PseudoVLUXSEG3EI64_V_M8_M1 + 0U, // PseudoVLUXSEG3EI64_V_M8_M1_MASK + 0U, // PseudoVLUXSEG3EI64_V_M8_M2 + 0U, // PseudoVLUXSEG3EI64_V_M8_M2_MASK + 0U, // PseudoVLUXSEG3EI8_V_M1_M1 + 0U, // PseudoVLUXSEG3EI8_V_M1_M1_MASK + 0U, // PseudoVLUXSEG3EI8_V_M1_M2 + 0U, // PseudoVLUXSEG3EI8_V_M1_M2_MASK + 0U, // PseudoVLUXSEG3EI8_V_M2_M2 + 0U, // PseudoVLUXSEG3EI8_V_M2_M2_MASK + 0U, // PseudoVLUXSEG3EI8_V_MF2_M1 + 0U, // PseudoVLUXSEG3EI8_V_MF2_M1_MASK + 0U, // PseudoVLUXSEG3EI8_V_MF2_M2 + 0U, // PseudoVLUXSEG3EI8_V_MF2_M2_MASK + 0U, // PseudoVLUXSEG3EI8_V_MF2_MF2 + 0U, // PseudoVLUXSEG3EI8_V_MF2_MF2_MASK + 0U, // PseudoVLUXSEG3EI8_V_MF4_M1 + 0U, // PseudoVLUXSEG3EI8_V_MF4_M1_MASK + 0U, // PseudoVLUXSEG3EI8_V_MF4_M2 + 0U, // PseudoVLUXSEG3EI8_V_MF4_M2_MASK + 0U, // PseudoVLUXSEG3EI8_V_MF4_MF2 + 0U, // PseudoVLUXSEG3EI8_V_MF4_MF2_MASK + 0U, // PseudoVLUXSEG3EI8_V_MF4_MF4 + 0U, // PseudoVLUXSEG3EI8_V_MF4_MF4_MASK + 0U, // PseudoVLUXSEG3EI8_V_MF8_M1 + 0U, // PseudoVLUXSEG3EI8_V_MF8_M1_MASK + 0U, // PseudoVLUXSEG3EI8_V_MF8_MF2 + 0U, // PseudoVLUXSEG3EI8_V_MF8_MF2_MASK + 0U, // PseudoVLUXSEG3EI8_V_MF8_MF4 + 0U, // PseudoVLUXSEG3EI8_V_MF8_MF4_MASK + 0U, // PseudoVLUXSEG3EI8_V_MF8_MF8 + 0U, // PseudoVLUXSEG3EI8_V_MF8_MF8_MASK + 0U, // PseudoVLUXSEG4EI16_V_M1_M1 + 0U, // PseudoVLUXSEG4EI16_V_M1_M1_MASK + 0U, // PseudoVLUXSEG4EI16_V_M1_M2 + 0U, // PseudoVLUXSEG4EI16_V_M1_M2_MASK + 0U, // PseudoVLUXSEG4EI16_V_M1_MF2 + 0U, // PseudoVLUXSEG4EI16_V_M1_MF2_MASK + 0U, // PseudoVLUXSEG4EI16_V_M2_M1 + 0U, // PseudoVLUXSEG4EI16_V_M2_M1_MASK + 0U, // PseudoVLUXSEG4EI16_V_M2_M2 + 0U, // PseudoVLUXSEG4EI16_V_M2_M2_MASK + 0U, // PseudoVLUXSEG4EI16_V_M4_M2 + 0U, // PseudoVLUXSEG4EI16_V_M4_M2_MASK + 0U, // PseudoVLUXSEG4EI16_V_MF2_M1 + 0U, // PseudoVLUXSEG4EI16_V_MF2_M1_MASK + 0U, // PseudoVLUXSEG4EI16_V_MF2_M2 + 0U, // PseudoVLUXSEG4EI16_V_MF2_M2_MASK + 0U, // PseudoVLUXSEG4EI16_V_MF2_MF2 + 0U, // PseudoVLUXSEG4EI16_V_MF2_MF2_MASK + 0U, // PseudoVLUXSEG4EI16_V_MF2_MF4 + 0U, // PseudoVLUXSEG4EI16_V_MF2_MF4_MASK + 0U, // PseudoVLUXSEG4EI16_V_MF4_M1 + 0U, // PseudoVLUXSEG4EI16_V_MF4_M1_MASK + 0U, // PseudoVLUXSEG4EI16_V_MF4_MF2 + 0U, // PseudoVLUXSEG4EI16_V_MF4_MF2_MASK + 0U, // PseudoVLUXSEG4EI16_V_MF4_MF4 + 0U, // PseudoVLUXSEG4EI16_V_MF4_MF4_MASK + 0U, // PseudoVLUXSEG4EI16_V_MF4_MF8 + 0U, // PseudoVLUXSEG4EI16_V_MF4_MF8_MASK + 0U, // PseudoVLUXSEG4EI32_V_M1_M1 + 0U, // PseudoVLUXSEG4EI32_V_M1_M1_MASK + 0U, // PseudoVLUXSEG4EI32_V_M1_M2 + 0U, // PseudoVLUXSEG4EI32_V_M1_M2_MASK + 0U, // PseudoVLUXSEG4EI32_V_M1_MF2 + 0U, // PseudoVLUXSEG4EI32_V_M1_MF2_MASK + 0U, // PseudoVLUXSEG4EI32_V_M1_MF4 + 0U, // PseudoVLUXSEG4EI32_V_M1_MF4_MASK + 0U, // PseudoVLUXSEG4EI32_V_M2_M1 + 0U, // PseudoVLUXSEG4EI32_V_M2_M1_MASK + 0U, // PseudoVLUXSEG4EI32_V_M2_M2 + 0U, // PseudoVLUXSEG4EI32_V_M2_M2_MASK + 0U, // PseudoVLUXSEG4EI32_V_M2_MF2 + 0U, // PseudoVLUXSEG4EI32_V_M2_MF2_MASK + 0U, // PseudoVLUXSEG4EI32_V_M4_M1 + 0U, // PseudoVLUXSEG4EI32_V_M4_M1_MASK + 0U, // PseudoVLUXSEG4EI32_V_M4_M2 + 0U, // PseudoVLUXSEG4EI32_V_M4_M2_MASK + 0U, // PseudoVLUXSEG4EI32_V_M8_M2 + 0U, // PseudoVLUXSEG4EI32_V_M8_M2_MASK + 0U, // PseudoVLUXSEG4EI32_V_MF2_M1 + 0U, // PseudoVLUXSEG4EI32_V_MF2_M1_MASK + 0U, // PseudoVLUXSEG4EI32_V_MF2_MF2 + 0U, // PseudoVLUXSEG4EI32_V_MF2_MF2_MASK + 0U, // PseudoVLUXSEG4EI32_V_MF2_MF4 + 0U, // PseudoVLUXSEG4EI32_V_MF2_MF4_MASK + 0U, // PseudoVLUXSEG4EI32_V_MF2_MF8 + 0U, // PseudoVLUXSEG4EI32_V_MF2_MF8_MASK + 0U, // PseudoVLUXSEG4EI64_V_M1_M1 + 0U, // PseudoVLUXSEG4EI64_V_M1_M1_MASK + 0U, // PseudoVLUXSEG4EI64_V_M1_MF2 + 0U, // PseudoVLUXSEG4EI64_V_M1_MF2_MASK + 0U, // PseudoVLUXSEG4EI64_V_M1_MF4 + 0U, // PseudoVLUXSEG4EI64_V_M1_MF4_MASK + 0U, // PseudoVLUXSEG4EI64_V_M1_MF8 + 0U, // PseudoVLUXSEG4EI64_V_M1_MF8_MASK + 0U, // PseudoVLUXSEG4EI64_V_M2_M1 + 0U, // PseudoVLUXSEG4EI64_V_M2_M1_MASK + 0U, // PseudoVLUXSEG4EI64_V_M2_M2 + 0U, // PseudoVLUXSEG4EI64_V_M2_M2_MASK + 0U, // PseudoVLUXSEG4EI64_V_M2_MF2 + 0U, // PseudoVLUXSEG4EI64_V_M2_MF2_MASK + 0U, // PseudoVLUXSEG4EI64_V_M2_MF4 + 0U, // PseudoVLUXSEG4EI64_V_M2_MF4_MASK + 0U, // PseudoVLUXSEG4EI64_V_M4_M1 + 0U, // PseudoVLUXSEG4EI64_V_M4_M1_MASK + 0U, // PseudoVLUXSEG4EI64_V_M4_M2 + 0U, // PseudoVLUXSEG4EI64_V_M4_M2_MASK + 0U, // PseudoVLUXSEG4EI64_V_M4_MF2 + 0U, // PseudoVLUXSEG4EI64_V_M4_MF2_MASK + 0U, // PseudoVLUXSEG4EI64_V_M8_M1 + 0U, // PseudoVLUXSEG4EI64_V_M8_M1_MASK + 0U, // PseudoVLUXSEG4EI64_V_M8_M2 + 0U, // PseudoVLUXSEG4EI64_V_M8_M2_MASK + 0U, // PseudoVLUXSEG4EI8_V_M1_M1 + 0U, // PseudoVLUXSEG4EI8_V_M1_M1_MASK + 0U, // PseudoVLUXSEG4EI8_V_M1_M2 + 0U, // PseudoVLUXSEG4EI8_V_M1_M2_MASK + 0U, // PseudoVLUXSEG4EI8_V_M2_M2 + 0U, // PseudoVLUXSEG4EI8_V_M2_M2_MASK + 0U, // PseudoVLUXSEG4EI8_V_MF2_M1 + 0U, // PseudoVLUXSEG4EI8_V_MF2_M1_MASK + 0U, // PseudoVLUXSEG4EI8_V_MF2_M2 + 0U, // PseudoVLUXSEG4EI8_V_MF2_M2_MASK + 0U, // PseudoVLUXSEG4EI8_V_MF2_MF2 + 0U, // PseudoVLUXSEG4EI8_V_MF2_MF2_MASK + 0U, // PseudoVLUXSEG4EI8_V_MF4_M1 + 0U, // PseudoVLUXSEG4EI8_V_MF4_M1_MASK + 0U, // PseudoVLUXSEG4EI8_V_MF4_M2 + 0U, // PseudoVLUXSEG4EI8_V_MF4_M2_MASK + 0U, // PseudoVLUXSEG4EI8_V_MF4_MF2 + 0U, // PseudoVLUXSEG4EI8_V_MF4_MF2_MASK + 0U, // PseudoVLUXSEG4EI8_V_MF4_MF4 + 0U, // PseudoVLUXSEG4EI8_V_MF4_MF4_MASK + 0U, // PseudoVLUXSEG4EI8_V_MF8_M1 + 0U, // PseudoVLUXSEG4EI8_V_MF8_M1_MASK + 0U, // PseudoVLUXSEG4EI8_V_MF8_MF2 + 0U, // PseudoVLUXSEG4EI8_V_MF8_MF2_MASK + 0U, // PseudoVLUXSEG4EI8_V_MF8_MF4 + 0U, // PseudoVLUXSEG4EI8_V_MF8_MF4_MASK + 0U, // PseudoVLUXSEG4EI8_V_MF8_MF8 + 0U, // PseudoVLUXSEG4EI8_V_MF8_MF8_MASK + 0U, // PseudoVLUXSEG5EI16_V_M1_M1 + 0U, // PseudoVLUXSEG5EI16_V_M1_M1_MASK + 0U, // PseudoVLUXSEG5EI16_V_M1_MF2 + 0U, // PseudoVLUXSEG5EI16_V_M1_MF2_MASK + 0U, // PseudoVLUXSEG5EI16_V_M2_M1 + 0U, // PseudoVLUXSEG5EI16_V_M2_M1_MASK + 0U, // PseudoVLUXSEG5EI16_V_MF2_M1 + 0U, // PseudoVLUXSEG5EI16_V_MF2_M1_MASK + 0U, // PseudoVLUXSEG5EI16_V_MF2_MF2 + 0U, // PseudoVLUXSEG5EI16_V_MF2_MF2_MASK + 0U, // PseudoVLUXSEG5EI16_V_MF2_MF4 + 0U, // PseudoVLUXSEG5EI16_V_MF2_MF4_MASK + 0U, // PseudoVLUXSEG5EI16_V_MF4_M1 + 0U, // PseudoVLUXSEG5EI16_V_MF4_M1_MASK + 0U, // PseudoVLUXSEG5EI16_V_MF4_MF2 + 0U, // PseudoVLUXSEG5EI16_V_MF4_MF2_MASK + 0U, // PseudoVLUXSEG5EI16_V_MF4_MF4 + 0U, // PseudoVLUXSEG5EI16_V_MF4_MF4_MASK + 0U, // PseudoVLUXSEG5EI16_V_MF4_MF8 + 0U, // PseudoVLUXSEG5EI16_V_MF4_MF8_MASK + 0U, // PseudoVLUXSEG5EI32_V_M1_M1 + 0U, // PseudoVLUXSEG5EI32_V_M1_M1_MASK + 0U, // PseudoVLUXSEG5EI32_V_M1_MF2 + 0U, // PseudoVLUXSEG5EI32_V_M1_MF2_MASK + 0U, // PseudoVLUXSEG5EI32_V_M1_MF4 + 0U, // PseudoVLUXSEG5EI32_V_M1_MF4_MASK + 0U, // PseudoVLUXSEG5EI32_V_M2_M1 + 0U, // PseudoVLUXSEG5EI32_V_M2_M1_MASK + 0U, // PseudoVLUXSEG5EI32_V_M2_MF2 + 0U, // PseudoVLUXSEG5EI32_V_M2_MF2_MASK + 0U, // PseudoVLUXSEG5EI32_V_M4_M1 + 0U, // PseudoVLUXSEG5EI32_V_M4_M1_MASK + 0U, // PseudoVLUXSEG5EI32_V_MF2_M1 + 0U, // PseudoVLUXSEG5EI32_V_MF2_M1_MASK + 0U, // PseudoVLUXSEG5EI32_V_MF2_MF2 + 0U, // PseudoVLUXSEG5EI32_V_MF2_MF2_MASK + 0U, // PseudoVLUXSEG5EI32_V_MF2_MF4 + 0U, // PseudoVLUXSEG5EI32_V_MF2_MF4_MASK + 0U, // PseudoVLUXSEG5EI32_V_MF2_MF8 + 0U, // PseudoVLUXSEG5EI32_V_MF2_MF8_MASK + 0U, // PseudoVLUXSEG5EI64_V_M1_M1 + 0U, // PseudoVLUXSEG5EI64_V_M1_M1_MASK + 0U, // PseudoVLUXSEG5EI64_V_M1_MF2 + 0U, // PseudoVLUXSEG5EI64_V_M1_MF2_MASK + 0U, // PseudoVLUXSEG5EI64_V_M1_MF4 + 0U, // PseudoVLUXSEG5EI64_V_M1_MF4_MASK + 0U, // PseudoVLUXSEG5EI64_V_M1_MF8 + 0U, // PseudoVLUXSEG5EI64_V_M1_MF8_MASK + 0U, // PseudoVLUXSEG5EI64_V_M2_M1 + 0U, // PseudoVLUXSEG5EI64_V_M2_M1_MASK + 0U, // PseudoVLUXSEG5EI64_V_M2_MF2 + 0U, // PseudoVLUXSEG5EI64_V_M2_MF2_MASK + 0U, // PseudoVLUXSEG5EI64_V_M2_MF4 + 0U, // PseudoVLUXSEG5EI64_V_M2_MF4_MASK + 0U, // PseudoVLUXSEG5EI64_V_M4_M1 + 0U, // PseudoVLUXSEG5EI64_V_M4_M1_MASK + 0U, // PseudoVLUXSEG5EI64_V_M4_MF2 + 0U, // PseudoVLUXSEG5EI64_V_M4_MF2_MASK + 0U, // PseudoVLUXSEG5EI64_V_M8_M1 + 0U, // PseudoVLUXSEG5EI64_V_M8_M1_MASK + 0U, // PseudoVLUXSEG5EI8_V_M1_M1 + 0U, // PseudoVLUXSEG5EI8_V_M1_M1_MASK + 0U, // PseudoVLUXSEG5EI8_V_MF2_M1 + 0U, // PseudoVLUXSEG5EI8_V_MF2_M1_MASK + 0U, // PseudoVLUXSEG5EI8_V_MF2_MF2 + 0U, // PseudoVLUXSEG5EI8_V_MF2_MF2_MASK + 0U, // PseudoVLUXSEG5EI8_V_MF4_M1 + 0U, // PseudoVLUXSEG5EI8_V_MF4_M1_MASK + 0U, // PseudoVLUXSEG5EI8_V_MF4_MF2 + 0U, // PseudoVLUXSEG5EI8_V_MF4_MF2_MASK + 0U, // PseudoVLUXSEG5EI8_V_MF4_MF4 + 0U, // PseudoVLUXSEG5EI8_V_MF4_MF4_MASK + 0U, // PseudoVLUXSEG5EI8_V_MF8_M1 + 0U, // PseudoVLUXSEG5EI8_V_MF8_M1_MASK + 0U, // PseudoVLUXSEG5EI8_V_MF8_MF2 + 0U, // PseudoVLUXSEG5EI8_V_MF8_MF2_MASK + 0U, // PseudoVLUXSEG5EI8_V_MF8_MF4 + 0U, // PseudoVLUXSEG5EI8_V_MF8_MF4_MASK + 0U, // PseudoVLUXSEG5EI8_V_MF8_MF8 + 0U, // PseudoVLUXSEG5EI8_V_MF8_MF8_MASK + 0U, // PseudoVLUXSEG6EI16_V_M1_M1 + 0U, // PseudoVLUXSEG6EI16_V_M1_M1_MASK + 0U, // PseudoVLUXSEG6EI16_V_M1_MF2 + 0U, // PseudoVLUXSEG6EI16_V_M1_MF2_MASK + 0U, // PseudoVLUXSEG6EI16_V_M2_M1 + 0U, // PseudoVLUXSEG6EI16_V_M2_M1_MASK + 0U, // PseudoVLUXSEG6EI16_V_MF2_M1 + 0U, // PseudoVLUXSEG6EI16_V_MF2_M1_MASK + 0U, // PseudoVLUXSEG6EI16_V_MF2_MF2 + 0U, // PseudoVLUXSEG6EI16_V_MF2_MF2_MASK + 0U, // PseudoVLUXSEG6EI16_V_MF2_MF4 + 0U, // PseudoVLUXSEG6EI16_V_MF2_MF4_MASK + 0U, // PseudoVLUXSEG6EI16_V_MF4_M1 + 0U, // PseudoVLUXSEG6EI16_V_MF4_M1_MASK + 0U, // PseudoVLUXSEG6EI16_V_MF4_MF2 + 0U, // PseudoVLUXSEG6EI16_V_MF4_MF2_MASK + 0U, // PseudoVLUXSEG6EI16_V_MF4_MF4 + 0U, // PseudoVLUXSEG6EI16_V_MF4_MF4_MASK + 0U, // PseudoVLUXSEG6EI16_V_MF4_MF8 + 0U, // PseudoVLUXSEG6EI16_V_MF4_MF8_MASK + 0U, // PseudoVLUXSEG6EI32_V_M1_M1 + 0U, // PseudoVLUXSEG6EI32_V_M1_M1_MASK + 0U, // PseudoVLUXSEG6EI32_V_M1_MF2 + 0U, // PseudoVLUXSEG6EI32_V_M1_MF2_MASK + 0U, // PseudoVLUXSEG6EI32_V_M1_MF4 + 0U, // PseudoVLUXSEG6EI32_V_M1_MF4_MASK + 0U, // PseudoVLUXSEG6EI32_V_M2_M1 + 0U, // PseudoVLUXSEG6EI32_V_M2_M1_MASK + 0U, // PseudoVLUXSEG6EI32_V_M2_MF2 + 0U, // PseudoVLUXSEG6EI32_V_M2_MF2_MASK + 0U, // PseudoVLUXSEG6EI32_V_M4_M1 + 0U, // PseudoVLUXSEG6EI32_V_M4_M1_MASK + 0U, // PseudoVLUXSEG6EI32_V_MF2_M1 + 0U, // PseudoVLUXSEG6EI32_V_MF2_M1_MASK + 0U, // PseudoVLUXSEG6EI32_V_MF2_MF2 + 0U, // PseudoVLUXSEG6EI32_V_MF2_MF2_MASK + 0U, // PseudoVLUXSEG6EI32_V_MF2_MF4 + 0U, // PseudoVLUXSEG6EI32_V_MF2_MF4_MASK + 0U, // PseudoVLUXSEG6EI32_V_MF2_MF8 + 0U, // PseudoVLUXSEG6EI32_V_MF2_MF8_MASK + 0U, // PseudoVLUXSEG6EI64_V_M1_M1 + 0U, // PseudoVLUXSEG6EI64_V_M1_M1_MASK + 0U, // PseudoVLUXSEG6EI64_V_M1_MF2 + 0U, // PseudoVLUXSEG6EI64_V_M1_MF2_MASK + 0U, // PseudoVLUXSEG6EI64_V_M1_MF4 + 0U, // PseudoVLUXSEG6EI64_V_M1_MF4_MASK + 0U, // PseudoVLUXSEG6EI64_V_M1_MF8 + 0U, // PseudoVLUXSEG6EI64_V_M1_MF8_MASK + 0U, // PseudoVLUXSEG6EI64_V_M2_M1 + 0U, // PseudoVLUXSEG6EI64_V_M2_M1_MASK + 0U, // PseudoVLUXSEG6EI64_V_M2_MF2 + 0U, // PseudoVLUXSEG6EI64_V_M2_MF2_MASK + 0U, // PseudoVLUXSEG6EI64_V_M2_MF4 + 0U, // PseudoVLUXSEG6EI64_V_M2_MF4_MASK + 0U, // PseudoVLUXSEG6EI64_V_M4_M1 + 0U, // PseudoVLUXSEG6EI64_V_M4_M1_MASK + 0U, // PseudoVLUXSEG6EI64_V_M4_MF2 + 0U, // PseudoVLUXSEG6EI64_V_M4_MF2_MASK + 0U, // PseudoVLUXSEG6EI64_V_M8_M1 + 0U, // PseudoVLUXSEG6EI64_V_M8_M1_MASK + 0U, // PseudoVLUXSEG6EI8_V_M1_M1 + 0U, // PseudoVLUXSEG6EI8_V_M1_M1_MASK + 0U, // PseudoVLUXSEG6EI8_V_MF2_M1 + 0U, // PseudoVLUXSEG6EI8_V_MF2_M1_MASK + 0U, // PseudoVLUXSEG6EI8_V_MF2_MF2 + 0U, // PseudoVLUXSEG6EI8_V_MF2_MF2_MASK + 0U, // PseudoVLUXSEG6EI8_V_MF4_M1 + 0U, // PseudoVLUXSEG6EI8_V_MF4_M1_MASK + 0U, // PseudoVLUXSEG6EI8_V_MF4_MF2 + 0U, // PseudoVLUXSEG6EI8_V_MF4_MF2_MASK + 0U, // PseudoVLUXSEG6EI8_V_MF4_MF4 + 0U, // PseudoVLUXSEG6EI8_V_MF4_MF4_MASK + 0U, // PseudoVLUXSEG6EI8_V_MF8_M1 + 0U, // PseudoVLUXSEG6EI8_V_MF8_M1_MASK + 0U, // PseudoVLUXSEG6EI8_V_MF8_MF2 + 0U, // PseudoVLUXSEG6EI8_V_MF8_MF2_MASK + 0U, // PseudoVLUXSEG6EI8_V_MF8_MF4 + 0U, // PseudoVLUXSEG6EI8_V_MF8_MF4_MASK + 0U, // PseudoVLUXSEG6EI8_V_MF8_MF8 + 0U, // PseudoVLUXSEG6EI8_V_MF8_MF8_MASK + 0U, // PseudoVLUXSEG7EI16_V_M1_M1 + 0U, // PseudoVLUXSEG7EI16_V_M1_M1_MASK + 0U, // PseudoVLUXSEG7EI16_V_M1_MF2 + 0U, // PseudoVLUXSEG7EI16_V_M1_MF2_MASK + 0U, // PseudoVLUXSEG7EI16_V_M2_M1 + 0U, // PseudoVLUXSEG7EI16_V_M2_M1_MASK + 0U, // PseudoVLUXSEG7EI16_V_MF2_M1 + 0U, // PseudoVLUXSEG7EI16_V_MF2_M1_MASK + 0U, // PseudoVLUXSEG7EI16_V_MF2_MF2 + 0U, // PseudoVLUXSEG7EI16_V_MF2_MF2_MASK + 0U, // PseudoVLUXSEG7EI16_V_MF2_MF4 + 0U, // PseudoVLUXSEG7EI16_V_MF2_MF4_MASK + 0U, // PseudoVLUXSEG7EI16_V_MF4_M1 + 0U, // PseudoVLUXSEG7EI16_V_MF4_M1_MASK + 0U, // PseudoVLUXSEG7EI16_V_MF4_MF2 + 0U, // PseudoVLUXSEG7EI16_V_MF4_MF2_MASK + 0U, // PseudoVLUXSEG7EI16_V_MF4_MF4 + 0U, // PseudoVLUXSEG7EI16_V_MF4_MF4_MASK + 0U, // PseudoVLUXSEG7EI16_V_MF4_MF8 + 0U, // PseudoVLUXSEG7EI16_V_MF4_MF8_MASK + 0U, // PseudoVLUXSEG7EI32_V_M1_M1 + 0U, // PseudoVLUXSEG7EI32_V_M1_M1_MASK + 0U, // PseudoVLUXSEG7EI32_V_M1_MF2 + 0U, // PseudoVLUXSEG7EI32_V_M1_MF2_MASK + 0U, // PseudoVLUXSEG7EI32_V_M1_MF4 + 0U, // PseudoVLUXSEG7EI32_V_M1_MF4_MASK + 0U, // PseudoVLUXSEG7EI32_V_M2_M1 + 0U, // PseudoVLUXSEG7EI32_V_M2_M1_MASK + 0U, // PseudoVLUXSEG7EI32_V_M2_MF2 + 0U, // PseudoVLUXSEG7EI32_V_M2_MF2_MASK + 0U, // PseudoVLUXSEG7EI32_V_M4_M1 + 0U, // PseudoVLUXSEG7EI32_V_M4_M1_MASK + 0U, // PseudoVLUXSEG7EI32_V_MF2_M1 + 0U, // PseudoVLUXSEG7EI32_V_MF2_M1_MASK + 0U, // PseudoVLUXSEG7EI32_V_MF2_MF2 + 0U, // PseudoVLUXSEG7EI32_V_MF2_MF2_MASK + 0U, // PseudoVLUXSEG7EI32_V_MF2_MF4 + 0U, // PseudoVLUXSEG7EI32_V_MF2_MF4_MASK + 0U, // PseudoVLUXSEG7EI32_V_MF2_MF8 + 0U, // PseudoVLUXSEG7EI32_V_MF2_MF8_MASK + 0U, // PseudoVLUXSEG7EI64_V_M1_M1 + 0U, // PseudoVLUXSEG7EI64_V_M1_M1_MASK + 0U, // PseudoVLUXSEG7EI64_V_M1_MF2 + 0U, // PseudoVLUXSEG7EI64_V_M1_MF2_MASK + 0U, // PseudoVLUXSEG7EI64_V_M1_MF4 + 0U, // PseudoVLUXSEG7EI64_V_M1_MF4_MASK + 0U, // PseudoVLUXSEG7EI64_V_M1_MF8 + 0U, // PseudoVLUXSEG7EI64_V_M1_MF8_MASK + 0U, // PseudoVLUXSEG7EI64_V_M2_M1 + 0U, // PseudoVLUXSEG7EI64_V_M2_M1_MASK + 0U, // PseudoVLUXSEG7EI64_V_M2_MF2 + 0U, // PseudoVLUXSEG7EI64_V_M2_MF2_MASK + 0U, // PseudoVLUXSEG7EI64_V_M2_MF4 + 0U, // PseudoVLUXSEG7EI64_V_M2_MF4_MASK + 0U, // PseudoVLUXSEG7EI64_V_M4_M1 + 0U, // PseudoVLUXSEG7EI64_V_M4_M1_MASK + 0U, // PseudoVLUXSEG7EI64_V_M4_MF2 + 0U, // PseudoVLUXSEG7EI64_V_M4_MF2_MASK + 0U, // PseudoVLUXSEG7EI64_V_M8_M1 + 0U, // PseudoVLUXSEG7EI64_V_M8_M1_MASK + 0U, // PseudoVLUXSEG7EI8_V_M1_M1 + 0U, // PseudoVLUXSEG7EI8_V_M1_M1_MASK + 0U, // PseudoVLUXSEG7EI8_V_MF2_M1 + 0U, // PseudoVLUXSEG7EI8_V_MF2_M1_MASK + 0U, // PseudoVLUXSEG7EI8_V_MF2_MF2 + 0U, // PseudoVLUXSEG7EI8_V_MF2_MF2_MASK + 0U, // PseudoVLUXSEG7EI8_V_MF4_M1 + 0U, // PseudoVLUXSEG7EI8_V_MF4_M1_MASK + 0U, // PseudoVLUXSEG7EI8_V_MF4_MF2 + 0U, // PseudoVLUXSEG7EI8_V_MF4_MF2_MASK + 0U, // PseudoVLUXSEG7EI8_V_MF4_MF4 + 0U, // PseudoVLUXSEG7EI8_V_MF4_MF4_MASK + 0U, // PseudoVLUXSEG7EI8_V_MF8_M1 + 0U, // PseudoVLUXSEG7EI8_V_MF8_M1_MASK + 0U, // PseudoVLUXSEG7EI8_V_MF8_MF2 + 0U, // PseudoVLUXSEG7EI8_V_MF8_MF2_MASK + 0U, // PseudoVLUXSEG7EI8_V_MF8_MF4 + 0U, // PseudoVLUXSEG7EI8_V_MF8_MF4_MASK + 0U, // PseudoVLUXSEG7EI8_V_MF8_MF8 + 0U, // PseudoVLUXSEG7EI8_V_MF8_MF8_MASK + 0U, // PseudoVLUXSEG8EI16_V_M1_M1 + 0U, // PseudoVLUXSEG8EI16_V_M1_M1_MASK + 0U, // PseudoVLUXSEG8EI16_V_M1_MF2 + 0U, // PseudoVLUXSEG8EI16_V_M1_MF2_MASK + 0U, // PseudoVLUXSEG8EI16_V_M2_M1 + 0U, // PseudoVLUXSEG8EI16_V_M2_M1_MASK + 0U, // PseudoVLUXSEG8EI16_V_MF2_M1 + 0U, // PseudoVLUXSEG8EI16_V_MF2_M1_MASK + 0U, // PseudoVLUXSEG8EI16_V_MF2_MF2 + 0U, // PseudoVLUXSEG8EI16_V_MF2_MF2_MASK + 0U, // PseudoVLUXSEG8EI16_V_MF2_MF4 + 0U, // PseudoVLUXSEG8EI16_V_MF2_MF4_MASK + 0U, // PseudoVLUXSEG8EI16_V_MF4_M1 + 0U, // PseudoVLUXSEG8EI16_V_MF4_M1_MASK + 0U, // PseudoVLUXSEG8EI16_V_MF4_MF2 + 0U, // PseudoVLUXSEG8EI16_V_MF4_MF2_MASK + 0U, // PseudoVLUXSEG8EI16_V_MF4_MF4 + 0U, // PseudoVLUXSEG8EI16_V_MF4_MF4_MASK + 0U, // PseudoVLUXSEG8EI16_V_MF4_MF8 + 0U, // PseudoVLUXSEG8EI16_V_MF4_MF8_MASK + 0U, // PseudoVLUXSEG8EI32_V_M1_M1 + 0U, // PseudoVLUXSEG8EI32_V_M1_M1_MASK + 0U, // PseudoVLUXSEG8EI32_V_M1_MF2 + 0U, // PseudoVLUXSEG8EI32_V_M1_MF2_MASK + 0U, // PseudoVLUXSEG8EI32_V_M1_MF4 + 0U, // PseudoVLUXSEG8EI32_V_M1_MF4_MASK + 0U, // PseudoVLUXSEG8EI32_V_M2_M1 + 0U, // PseudoVLUXSEG8EI32_V_M2_M1_MASK + 0U, // PseudoVLUXSEG8EI32_V_M2_MF2 + 0U, // PseudoVLUXSEG8EI32_V_M2_MF2_MASK + 0U, // PseudoVLUXSEG8EI32_V_M4_M1 + 0U, // PseudoVLUXSEG8EI32_V_M4_M1_MASK + 0U, // PseudoVLUXSEG8EI32_V_MF2_M1 + 0U, // PseudoVLUXSEG8EI32_V_MF2_M1_MASK + 0U, // PseudoVLUXSEG8EI32_V_MF2_MF2 + 0U, // PseudoVLUXSEG8EI32_V_MF2_MF2_MASK + 0U, // PseudoVLUXSEG8EI32_V_MF2_MF4 + 0U, // PseudoVLUXSEG8EI32_V_MF2_MF4_MASK + 0U, // PseudoVLUXSEG8EI32_V_MF2_MF8 + 0U, // PseudoVLUXSEG8EI32_V_MF2_MF8_MASK + 0U, // PseudoVLUXSEG8EI64_V_M1_M1 + 0U, // PseudoVLUXSEG8EI64_V_M1_M1_MASK + 0U, // PseudoVLUXSEG8EI64_V_M1_MF2 + 0U, // PseudoVLUXSEG8EI64_V_M1_MF2_MASK + 0U, // PseudoVLUXSEG8EI64_V_M1_MF4 + 0U, // PseudoVLUXSEG8EI64_V_M1_MF4_MASK + 0U, // PseudoVLUXSEG8EI64_V_M1_MF8 + 0U, // PseudoVLUXSEG8EI64_V_M1_MF8_MASK + 0U, // PseudoVLUXSEG8EI64_V_M2_M1 + 0U, // PseudoVLUXSEG8EI64_V_M2_M1_MASK + 0U, // PseudoVLUXSEG8EI64_V_M2_MF2 + 0U, // PseudoVLUXSEG8EI64_V_M2_MF2_MASK + 0U, // PseudoVLUXSEG8EI64_V_M2_MF4 + 0U, // PseudoVLUXSEG8EI64_V_M2_MF4_MASK + 0U, // PseudoVLUXSEG8EI64_V_M4_M1 + 0U, // PseudoVLUXSEG8EI64_V_M4_M1_MASK + 0U, // PseudoVLUXSEG8EI64_V_M4_MF2 + 0U, // PseudoVLUXSEG8EI64_V_M4_MF2_MASK + 0U, // PseudoVLUXSEG8EI64_V_M8_M1 + 0U, // PseudoVLUXSEG8EI64_V_M8_M1_MASK + 0U, // PseudoVLUXSEG8EI8_V_M1_M1 + 0U, // PseudoVLUXSEG8EI8_V_M1_M1_MASK + 0U, // PseudoVLUXSEG8EI8_V_MF2_M1 + 0U, // PseudoVLUXSEG8EI8_V_MF2_M1_MASK + 0U, // PseudoVLUXSEG8EI8_V_MF2_MF2 + 0U, // PseudoVLUXSEG8EI8_V_MF2_MF2_MASK + 0U, // PseudoVLUXSEG8EI8_V_MF4_M1 + 0U, // PseudoVLUXSEG8EI8_V_MF4_M1_MASK + 0U, // PseudoVLUXSEG8EI8_V_MF4_MF2 + 0U, // PseudoVLUXSEG8EI8_V_MF4_MF2_MASK + 0U, // PseudoVLUXSEG8EI8_V_MF4_MF4 + 0U, // PseudoVLUXSEG8EI8_V_MF4_MF4_MASK + 0U, // PseudoVLUXSEG8EI8_V_MF8_M1 + 0U, // PseudoVLUXSEG8EI8_V_MF8_M1_MASK + 0U, // PseudoVLUXSEG8EI8_V_MF8_MF2 + 0U, // PseudoVLUXSEG8EI8_V_MF8_MF2_MASK + 0U, // PseudoVLUXSEG8EI8_V_MF8_MF4 + 0U, // PseudoVLUXSEG8EI8_V_MF8_MF4_MASK + 0U, // PseudoVLUXSEG8EI8_V_MF8_MF8 + 0U, // PseudoVLUXSEG8EI8_V_MF8_MF8_MASK + 0U, // PseudoVMACC_VV_M1 + 0U, // PseudoVMACC_VV_M1_MASK + 0U, // PseudoVMACC_VV_M2 + 0U, // PseudoVMACC_VV_M2_MASK + 0U, // PseudoVMACC_VV_M4 + 0U, // PseudoVMACC_VV_M4_MASK + 0U, // PseudoVMACC_VV_M8 + 0U, // PseudoVMACC_VV_M8_MASK + 0U, // PseudoVMACC_VV_MF2 + 0U, // PseudoVMACC_VV_MF2_MASK + 0U, // PseudoVMACC_VV_MF4 + 0U, // PseudoVMACC_VV_MF4_MASK + 0U, // PseudoVMACC_VV_MF8 + 0U, // PseudoVMACC_VV_MF8_MASK + 0U, // PseudoVMACC_VX_M1 + 0U, // PseudoVMACC_VX_M1_MASK + 0U, // PseudoVMACC_VX_M2 + 0U, // PseudoVMACC_VX_M2_MASK + 0U, // PseudoVMACC_VX_M4 + 0U, // PseudoVMACC_VX_M4_MASK + 0U, // PseudoVMACC_VX_M8 + 0U, // PseudoVMACC_VX_M8_MASK + 0U, // PseudoVMACC_VX_MF2 + 0U, // PseudoVMACC_VX_MF2_MASK + 0U, // PseudoVMACC_VX_MF4 + 0U, // PseudoVMACC_VX_MF4_MASK + 0U, // PseudoVMACC_VX_MF8 + 0U, // PseudoVMACC_VX_MF8_MASK + 0U, // PseudoVMADC_VIM_M1 + 0U, // PseudoVMADC_VIM_M2 + 0U, // PseudoVMADC_VIM_M4 + 0U, // PseudoVMADC_VIM_M8 + 0U, // PseudoVMADC_VIM_MF2 + 0U, // PseudoVMADC_VIM_MF4 + 0U, // PseudoVMADC_VIM_MF8 + 0U, // PseudoVMADC_VI_M1 + 0U, // PseudoVMADC_VI_M2 + 0U, // PseudoVMADC_VI_M4 + 0U, // PseudoVMADC_VI_M8 + 0U, // PseudoVMADC_VI_MF2 + 0U, // PseudoVMADC_VI_MF4 + 0U, // PseudoVMADC_VI_MF8 + 0U, // PseudoVMADC_VVM_M1 + 0U, // PseudoVMADC_VVM_M2 + 0U, // PseudoVMADC_VVM_M4 + 0U, // PseudoVMADC_VVM_M8 + 0U, // PseudoVMADC_VVM_MF2 + 0U, // PseudoVMADC_VVM_MF4 + 0U, // PseudoVMADC_VVM_MF8 + 0U, // PseudoVMADC_VV_M1 + 0U, // PseudoVMADC_VV_M2 + 0U, // PseudoVMADC_VV_M4 + 0U, // PseudoVMADC_VV_M8 + 0U, // PseudoVMADC_VV_MF2 + 0U, // PseudoVMADC_VV_MF4 + 0U, // PseudoVMADC_VV_MF8 + 0U, // PseudoVMADC_VXM_M1 + 0U, // PseudoVMADC_VXM_M2 + 0U, // PseudoVMADC_VXM_M4 + 0U, // PseudoVMADC_VXM_M8 + 0U, // PseudoVMADC_VXM_MF2 + 0U, // PseudoVMADC_VXM_MF4 + 0U, // PseudoVMADC_VXM_MF8 + 0U, // PseudoVMADC_VX_M1 + 0U, // PseudoVMADC_VX_M2 + 0U, // PseudoVMADC_VX_M4 + 0U, // PseudoVMADC_VX_M8 + 0U, // PseudoVMADC_VX_MF2 + 0U, // PseudoVMADC_VX_MF4 + 0U, // PseudoVMADC_VX_MF8 + 0U, // PseudoVMADD_VV_M1 + 0U, // PseudoVMADD_VV_M1_MASK + 0U, // PseudoVMADD_VV_M2 + 0U, // PseudoVMADD_VV_M2_MASK + 0U, // PseudoVMADD_VV_M4 + 0U, // PseudoVMADD_VV_M4_MASK + 0U, // PseudoVMADD_VV_M8 + 0U, // PseudoVMADD_VV_M8_MASK + 0U, // PseudoVMADD_VV_MF2 + 0U, // PseudoVMADD_VV_MF2_MASK + 0U, // PseudoVMADD_VV_MF4 + 0U, // PseudoVMADD_VV_MF4_MASK + 0U, // PseudoVMADD_VV_MF8 + 0U, // PseudoVMADD_VV_MF8_MASK + 0U, // PseudoVMADD_VX_M1 + 0U, // PseudoVMADD_VX_M1_MASK + 0U, // PseudoVMADD_VX_M2 + 0U, // PseudoVMADD_VX_M2_MASK + 0U, // PseudoVMADD_VX_M4 + 0U, // PseudoVMADD_VX_M4_MASK + 0U, // PseudoVMADD_VX_M8 + 0U, // PseudoVMADD_VX_M8_MASK + 0U, // PseudoVMADD_VX_MF2 + 0U, // PseudoVMADD_VX_MF2_MASK + 0U, // PseudoVMADD_VX_MF4 + 0U, // PseudoVMADD_VX_MF4_MASK + 0U, // PseudoVMADD_VX_MF8 + 0U, // PseudoVMADD_VX_MF8_MASK + 0U, // PseudoVMANDN_MM_M1 + 0U, // PseudoVMANDN_MM_M2 + 0U, // PseudoVMANDN_MM_M4 + 0U, // PseudoVMANDN_MM_M8 + 0U, // PseudoVMANDN_MM_MF2 + 0U, // PseudoVMANDN_MM_MF4 + 0U, // PseudoVMANDN_MM_MF8 + 0U, // PseudoVMAND_MM_M1 + 0U, // PseudoVMAND_MM_M2 + 0U, // PseudoVMAND_MM_M4 + 0U, // PseudoVMAND_MM_M8 + 0U, // PseudoVMAND_MM_MF2 + 0U, // PseudoVMAND_MM_MF4 + 0U, // PseudoVMAND_MM_MF8 + 0U, // PseudoVMAXU_VV_M1 + 0U, // PseudoVMAXU_VV_M1_MASK + 0U, // PseudoVMAXU_VV_M2 + 0U, // PseudoVMAXU_VV_M2_MASK + 0U, // PseudoVMAXU_VV_M4 + 0U, // PseudoVMAXU_VV_M4_MASK + 0U, // PseudoVMAXU_VV_M8 + 0U, // PseudoVMAXU_VV_M8_MASK + 0U, // PseudoVMAXU_VV_MF2 + 0U, // PseudoVMAXU_VV_MF2_MASK + 0U, // PseudoVMAXU_VV_MF4 + 0U, // PseudoVMAXU_VV_MF4_MASK + 0U, // PseudoVMAXU_VV_MF8 + 0U, // PseudoVMAXU_VV_MF8_MASK + 0U, // PseudoVMAXU_VX_M1 + 0U, // PseudoVMAXU_VX_M1_MASK + 0U, // PseudoVMAXU_VX_M2 + 0U, // PseudoVMAXU_VX_M2_MASK + 0U, // PseudoVMAXU_VX_M4 + 0U, // PseudoVMAXU_VX_M4_MASK + 0U, // PseudoVMAXU_VX_M8 + 0U, // PseudoVMAXU_VX_M8_MASK + 0U, // PseudoVMAXU_VX_MF2 + 0U, // PseudoVMAXU_VX_MF2_MASK + 0U, // PseudoVMAXU_VX_MF4 + 0U, // PseudoVMAXU_VX_MF4_MASK + 0U, // PseudoVMAXU_VX_MF8 + 0U, // PseudoVMAXU_VX_MF8_MASK + 0U, // PseudoVMAX_VV_M1 + 0U, // PseudoVMAX_VV_M1_MASK + 0U, // PseudoVMAX_VV_M2 + 0U, // PseudoVMAX_VV_M2_MASK + 0U, // PseudoVMAX_VV_M4 + 0U, // PseudoVMAX_VV_M4_MASK + 0U, // PseudoVMAX_VV_M8 + 0U, // PseudoVMAX_VV_M8_MASK + 0U, // PseudoVMAX_VV_MF2 + 0U, // PseudoVMAX_VV_MF2_MASK + 0U, // PseudoVMAX_VV_MF4 + 0U, // PseudoVMAX_VV_MF4_MASK + 0U, // PseudoVMAX_VV_MF8 + 0U, // PseudoVMAX_VV_MF8_MASK + 0U, // PseudoVMAX_VX_M1 + 0U, // PseudoVMAX_VX_M1_MASK + 0U, // PseudoVMAX_VX_M2 + 0U, // PseudoVMAX_VX_M2_MASK + 0U, // PseudoVMAX_VX_M4 + 0U, // PseudoVMAX_VX_M4_MASK + 0U, // PseudoVMAX_VX_M8 + 0U, // PseudoVMAX_VX_M8_MASK + 0U, // PseudoVMAX_VX_MF2 + 0U, // PseudoVMAX_VX_MF2_MASK + 0U, // PseudoVMAX_VX_MF4 + 0U, // PseudoVMAX_VX_MF4_MASK + 0U, // PseudoVMAX_VX_MF8 + 0U, // PseudoVMAX_VX_MF8_MASK + 0U, // PseudoVMCLR_M_B1 + 0U, // PseudoVMCLR_M_B16 + 0U, // PseudoVMCLR_M_B2 + 0U, // PseudoVMCLR_M_B32 + 0U, // PseudoVMCLR_M_B4 + 0U, // PseudoVMCLR_M_B64 + 0U, // PseudoVMCLR_M_B8 + 0U, // PseudoVMERGE_VIM_M1 + 0U, // PseudoVMERGE_VIM_M2 + 0U, // PseudoVMERGE_VIM_M4 + 0U, // PseudoVMERGE_VIM_M8 + 0U, // PseudoVMERGE_VIM_MF2 + 0U, // PseudoVMERGE_VIM_MF4 + 0U, // PseudoVMERGE_VIM_MF8 + 0U, // PseudoVMERGE_VVM_M1 + 0U, // PseudoVMERGE_VVM_M2 + 0U, // PseudoVMERGE_VVM_M4 + 0U, // PseudoVMERGE_VVM_M8 + 0U, // PseudoVMERGE_VVM_MF2 + 0U, // PseudoVMERGE_VVM_MF4 + 0U, // PseudoVMERGE_VVM_MF8 + 0U, // PseudoVMERGE_VXM_M1 + 0U, // PseudoVMERGE_VXM_M2 + 0U, // PseudoVMERGE_VXM_M4 + 0U, // PseudoVMERGE_VXM_M8 + 0U, // PseudoVMERGE_VXM_MF2 + 0U, // PseudoVMERGE_VXM_MF4 + 0U, // PseudoVMERGE_VXM_MF8 + 0U, // PseudoVMFEQ_VFPR16_M1 + 0U, // PseudoVMFEQ_VFPR16_M1_MASK + 0U, // PseudoVMFEQ_VFPR16_M2 + 0U, // PseudoVMFEQ_VFPR16_M2_MASK + 0U, // PseudoVMFEQ_VFPR16_M4 + 0U, // PseudoVMFEQ_VFPR16_M4_MASK + 0U, // PseudoVMFEQ_VFPR16_M8 + 0U, // PseudoVMFEQ_VFPR16_M8_MASK + 0U, // PseudoVMFEQ_VFPR16_MF2 + 0U, // PseudoVMFEQ_VFPR16_MF2_MASK + 0U, // PseudoVMFEQ_VFPR16_MF4 + 0U, // PseudoVMFEQ_VFPR16_MF4_MASK + 0U, // PseudoVMFEQ_VFPR32_M1 + 0U, // PseudoVMFEQ_VFPR32_M1_MASK + 0U, // PseudoVMFEQ_VFPR32_M2 + 0U, // PseudoVMFEQ_VFPR32_M2_MASK + 0U, // PseudoVMFEQ_VFPR32_M4 + 0U, // PseudoVMFEQ_VFPR32_M4_MASK + 0U, // PseudoVMFEQ_VFPR32_M8 + 0U, // PseudoVMFEQ_VFPR32_M8_MASK + 0U, // PseudoVMFEQ_VFPR32_MF2 + 0U, // PseudoVMFEQ_VFPR32_MF2_MASK + 0U, // PseudoVMFEQ_VFPR64_M1 + 0U, // PseudoVMFEQ_VFPR64_M1_MASK + 0U, // PseudoVMFEQ_VFPR64_M2 + 0U, // PseudoVMFEQ_VFPR64_M2_MASK + 0U, // PseudoVMFEQ_VFPR64_M4 + 0U, // PseudoVMFEQ_VFPR64_M4_MASK + 0U, // PseudoVMFEQ_VFPR64_M8 + 0U, // PseudoVMFEQ_VFPR64_M8_MASK + 0U, // PseudoVMFEQ_VV_M1 + 0U, // PseudoVMFEQ_VV_M1_MASK + 0U, // PseudoVMFEQ_VV_M2 + 0U, // PseudoVMFEQ_VV_M2_MASK + 0U, // PseudoVMFEQ_VV_M4 + 0U, // PseudoVMFEQ_VV_M4_MASK + 0U, // PseudoVMFEQ_VV_M8 + 0U, // PseudoVMFEQ_VV_M8_MASK + 0U, // PseudoVMFEQ_VV_MF2 + 0U, // PseudoVMFEQ_VV_MF2_MASK + 0U, // PseudoVMFEQ_VV_MF4 + 0U, // PseudoVMFEQ_VV_MF4_MASK + 0U, // PseudoVMFGE_VFPR16_M1 + 0U, // PseudoVMFGE_VFPR16_M1_MASK + 0U, // PseudoVMFGE_VFPR16_M2 + 0U, // PseudoVMFGE_VFPR16_M2_MASK + 0U, // PseudoVMFGE_VFPR16_M4 + 0U, // PseudoVMFGE_VFPR16_M4_MASK + 0U, // PseudoVMFGE_VFPR16_M8 + 0U, // PseudoVMFGE_VFPR16_M8_MASK + 0U, // PseudoVMFGE_VFPR16_MF2 + 0U, // PseudoVMFGE_VFPR16_MF2_MASK + 0U, // PseudoVMFGE_VFPR16_MF4 + 0U, // PseudoVMFGE_VFPR16_MF4_MASK + 0U, // PseudoVMFGE_VFPR32_M1 + 0U, // PseudoVMFGE_VFPR32_M1_MASK + 0U, // PseudoVMFGE_VFPR32_M2 + 0U, // PseudoVMFGE_VFPR32_M2_MASK + 0U, // PseudoVMFGE_VFPR32_M4 + 0U, // PseudoVMFGE_VFPR32_M4_MASK + 0U, // PseudoVMFGE_VFPR32_M8 + 0U, // PseudoVMFGE_VFPR32_M8_MASK + 0U, // PseudoVMFGE_VFPR32_MF2 + 0U, // PseudoVMFGE_VFPR32_MF2_MASK + 0U, // PseudoVMFGE_VFPR64_M1 + 0U, // PseudoVMFGE_VFPR64_M1_MASK + 0U, // PseudoVMFGE_VFPR64_M2 + 0U, // PseudoVMFGE_VFPR64_M2_MASK + 0U, // PseudoVMFGE_VFPR64_M4 + 0U, // PseudoVMFGE_VFPR64_M4_MASK + 0U, // PseudoVMFGE_VFPR64_M8 + 0U, // PseudoVMFGE_VFPR64_M8_MASK + 0U, // PseudoVMFGT_VFPR16_M1 + 0U, // PseudoVMFGT_VFPR16_M1_MASK + 0U, // PseudoVMFGT_VFPR16_M2 + 0U, // PseudoVMFGT_VFPR16_M2_MASK + 0U, // PseudoVMFGT_VFPR16_M4 + 0U, // PseudoVMFGT_VFPR16_M4_MASK + 0U, // PseudoVMFGT_VFPR16_M8 + 0U, // PseudoVMFGT_VFPR16_M8_MASK + 0U, // PseudoVMFGT_VFPR16_MF2 + 0U, // PseudoVMFGT_VFPR16_MF2_MASK + 0U, // PseudoVMFGT_VFPR16_MF4 + 0U, // PseudoVMFGT_VFPR16_MF4_MASK + 0U, // PseudoVMFGT_VFPR32_M1 + 0U, // PseudoVMFGT_VFPR32_M1_MASK + 0U, // PseudoVMFGT_VFPR32_M2 + 0U, // PseudoVMFGT_VFPR32_M2_MASK + 0U, // PseudoVMFGT_VFPR32_M4 + 0U, // PseudoVMFGT_VFPR32_M4_MASK + 0U, // PseudoVMFGT_VFPR32_M8 + 0U, // PseudoVMFGT_VFPR32_M8_MASK + 0U, // PseudoVMFGT_VFPR32_MF2 + 0U, // PseudoVMFGT_VFPR32_MF2_MASK + 0U, // PseudoVMFGT_VFPR64_M1 + 0U, // PseudoVMFGT_VFPR64_M1_MASK + 0U, // PseudoVMFGT_VFPR64_M2 + 0U, // PseudoVMFGT_VFPR64_M2_MASK + 0U, // PseudoVMFGT_VFPR64_M4 + 0U, // PseudoVMFGT_VFPR64_M4_MASK + 0U, // PseudoVMFGT_VFPR64_M8 + 0U, // PseudoVMFGT_VFPR64_M8_MASK + 0U, // PseudoVMFLE_VFPR16_M1 + 0U, // PseudoVMFLE_VFPR16_M1_MASK + 0U, // PseudoVMFLE_VFPR16_M2 + 0U, // PseudoVMFLE_VFPR16_M2_MASK + 0U, // PseudoVMFLE_VFPR16_M4 + 0U, // PseudoVMFLE_VFPR16_M4_MASK + 0U, // PseudoVMFLE_VFPR16_M8 + 0U, // PseudoVMFLE_VFPR16_M8_MASK + 0U, // PseudoVMFLE_VFPR16_MF2 + 0U, // PseudoVMFLE_VFPR16_MF2_MASK + 0U, // PseudoVMFLE_VFPR16_MF4 + 0U, // PseudoVMFLE_VFPR16_MF4_MASK + 0U, // PseudoVMFLE_VFPR32_M1 + 0U, // PseudoVMFLE_VFPR32_M1_MASK + 0U, // PseudoVMFLE_VFPR32_M2 + 0U, // PseudoVMFLE_VFPR32_M2_MASK + 0U, // PseudoVMFLE_VFPR32_M4 + 0U, // PseudoVMFLE_VFPR32_M4_MASK + 0U, // PseudoVMFLE_VFPR32_M8 + 0U, // PseudoVMFLE_VFPR32_M8_MASK + 0U, // PseudoVMFLE_VFPR32_MF2 + 0U, // PseudoVMFLE_VFPR32_MF2_MASK + 0U, // PseudoVMFLE_VFPR64_M1 + 0U, // PseudoVMFLE_VFPR64_M1_MASK + 0U, // PseudoVMFLE_VFPR64_M2 + 0U, // PseudoVMFLE_VFPR64_M2_MASK + 0U, // PseudoVMFLE_VFPR64_M4 + 0U, // PseudoVMFLE_VFPR64_M4_MASK + 0U, // PseudoVMFLE_VFPR64_M8 + 0U, // PseudoVMFLE_VFPR64_M8_MASK + 0U, // PseudoVMFLE_VV_M1 + 0U, // PseudoVMFLE_VV_M1_MASK + 0U, // PseudoVMFLE_VV_M2 + 0U, // PseudoVMFLE_VV_M2_MASK + 0U, // PseudoVMFLE_VV_M4 + 0U, // PseudoVMFLE_VV_M4_MASK + 0U, // PseudoVMFLE_VV_M8 + 0U, // PseudoVMFLE_VV_M8_MASK + 0U, // PseudoVMFLE_VV_MF2 + 0U, // PseudoVMFLE_VV_MF2_MASK + 0U, // PseudoVMFLE_VV_MF4 + 0U, // PseudoVMFLE_VV_MF4_MASK + 0U, // PseudoVMFLT_VFPR16_M1 + 0U, // PseudoVMFLT_VFPR16_M1_MASK + 0U, // PseudoVMFLT_VFPR16_M2 + 0U, // PseudoVMFLT_VFPR16_M2_MASK + 0U, // PseudoVMFLT_VFPR16_M4 + 0U, // PseudoVMFLT_VFPR16_M4_MASK + 0U, // PseudoVMFLT_VFPR16_M8 + 0U, // PseudoVMFLT_VFPR16_M8_MASK + 0U, // PseudoVMFLT_VFPR16_MF2 + 0U, // PseudoVMFLT_VFPR16_MF2_MASK + 0U, // PseudoVMFLT_VFPR16_MF4 + 0U, // PseudoVMFLT_VFPR16_MF4_MASK + 0U, // PseudoVMFLT_VFPR32_M1 + 0U, // PseudoVMFLT_VFPR32_M1_MASK + 0U, // PseudoVMFLT_VFPR32_M2 + 0U, // PseudoVMFLT_VFPR32_M2_MASK + 0U, // PseudoVMFLT_VFPR32_M4 + 0U, // PseudoVMFLT_VFPR32_M4_MASK + 0U, // PseudoVMFLT_VFPR32_M8 + 0U, // PseudoVMFLT_VFPR32_M8_MASK + 0U, // PseudoVMFLT_VFPR32_MF2 + 0U, // PseudoVMFLT_VFPR32_MF2_MASK + 0U, // PseudoVMFLT_VFPR64_M1 + 0U, // PseudoVMFLT_VFPR64_M1_MASK + 0U, // PseudoVMFLT_VFPR64_M2 + 0U, // PseudoVMFLT_VFPR64_M2_MASK + 0U, // PseudoVMFLT_VFPR64_M4 + 0U, // PseudoVMFLT_VFPR64_M4_MASK + 0U, // PseudoVMFLT_VFPR64_M8 + 0U, // PseudoVMFLT_VFPR64_M8_MASK + 0U, // PseudoVMFLT_VV_M1 + 0U, // PseudoVMFLT_VV_M1_MASK + 0U, // PseudoVMFLT_VV_M2 + 0U, // PseudoVMFLT_VV_M2_MASK + 0U, // PseudoVMFLT_VV_M4 + 0U, // PseudoVMFLT_VV_M4_MASK + 0U, // PseudoVMFLT_VV_M8 + 0U, // PseudoVMFLT_VV_M8_MASK + 0U, // PseudoVMFLT_VV_MF2 + 0U, // PseudoVMFLT_VV_MF2_MASK + 0U, // PseudoVMFLT_VV_MF4 + 0U, // PseudoVMFLT_VV_MF4_MASK + 0U, // PseudoVMFNE_VFPR16_M1 + 0U, // PseudoVMFNE_VFPR16_M1_MASK + 0U, // PseudoVMFNE_VFPR16_M2 + 0U, // PseudoVMFNE_VFPR16_M2_MASK + 0U, // PseudoVMFNE_VFPR16_M4 + 0U, // PseudoVMFNE_VFPR16_M4_MASK + 0U, // PseudoVMFNE_VFPR16_M8 + 0U, // PseudoVMFNE_VFPR16_M8_MASK + 0U, // PseudoVMFNE_VFPR16_MF2 + 0U, // PseudoVMFNE_VFPR16_MF2_MASK + 0U, // PseudoVMFNE_VFPR16_MF4 + 0U, // PseudoVMFNE_VFPR16_MF4_MASK + 0U, // PseudoVMFNE_VFPR32_M1 + 0U, // PseudoVMFNE_VFPR32_M1_MASK + 0U, // PseudoVMFNE_VFPR32_M2 + 0U, // PseudoVMFNE_VFPR32_M2_MASK + 0U, // PseudoVMFNE_VFPR32_M4 + 0U, // PseudoVMFNE_VFPR32_M4_MASK + 0U, // PseudoVMFNE_VFPR32_M8 + 0U, // PseudoVMFNE_VFPR32_M8_MASK + 0U, // PseudoVMFNE_VFPR32_MF2 + 0U, // PseudoVMFNE_VFPR32_MF2_MASK + 0U, // PseudoVMFNE_VFPR64_M1 + 0U, // PseudoVMFNE_VFPR64_M1_MASK + 0U, // PseudoVMFNE_VFPR64_M2 + 0U, // PseudoVMFNE_VFPR64_M2_MASK + 0U, // PseudoVMFNE_VFPR64_M4 + 0U, // PseudoVMFNE_VFPR64_M4_MASK + 0U, // PseudoVMFNE_VFPR64_M8 + 0U, // PseudoVMFNE_VFPR64_M8_MASK + 0U, // PseudoVMFNE_VV_M1 + 0U, // PseudoVMFNE_VV_M1_MASK + 0U, // PseudoVMFNE_VV_M2 + 0U, // PseudoVMFNE_VV_M2_MASK + 0U, // PseudoVMFNE_VV_M4 + 0U, // PseudoVMFNE_VV_M4_MASK + 0U, // PseudoVMFNE_VV_M8 + 0U, // PseudoVMFNE_VV_M8_MASK + 0U, // PseudoVMFNE_VV_MF2 + 0U, // PseudoVMFNE_VV_MF2_MASK + 0U, // PseudoVMFNE_VV_MF4 + 0U, // PseudoVMFNE_VV_MF4_MASK + 0U, // PseudoVMINU_VV_M1 + 0U, // PseudoVMINU_VV_M1_MASK + 0U, // PseudoVMINU_VV_M2 + 0U, // PseudoVMINU_VV_M2_MASK + 0U, // PseudoVMINU_VV_M4 + 0U, // PseudoVMINU_VV_M4_MASK + 0U, // PseudoVMINU_VV_M8 + 0U, // PseudoVMINU_VV_M8_MASK + 0U, // PseudoVMINU_VV_MF2 + 0U, // PseudoVMINU_VV_MF2_MASK + 0U, // PseudoVMINU_VV_MF4 + 0U, // PseudoVMINU_VV_MF4_MASK + 0U, // PseudoVMINU_VV_MF8 + 0U, // PseudoVMINU_VV_MF8_MASK + 0U, // PseudoVMINU_VX_M1 + 0U, // PseudoVMINU_VX_M1_MASK + 0U, // PseudoVMINU_VX_M2 + 0U, // PseudoVMINU_VX_M2_MASK + 0U, // PseudoVMINU_VX_M4 + 0U, // PseudoVMINU_VX_M4_MASK + 0U, // PseudoVMINU_VX_M8 + 0U, // PseudoVMINU_VX_M8_MASK + 0U, // PseudoVMINU_VX_MF2 + 0U, // PseudoVMINU_VX_MF2_MASK + 0U, // PseudoVMINU_VX_MF4 + 0U, // PseudoVMINU_VX_MF4_MASK + 0U, // PseudoVMINU_VX_MF8 + 0U, // PseudoVMINU_VX_MF8_MASK + 0U, // PseudoVMIN_VV_M1 + 0U, // PseudoVMIN_VV_M1_MASK + 0U, // PseudoVMIN_VV_M2 + 0U, // PseudoVMIN_VV_M2_MASK + 0U, // PseudoVMIN_VV_M4 + 0U, // PseudoVMIN_VV_M4_MASK + 0U, // PseudoVMIN_VV_M8 + 0U, // PseudoVMIN_VV_M8_MASK + 0U, // PseudoVMIN_VV_MF2 + 0U, // PseudoVMIN_VV_MF2_MASK + 0U, // PseudoVMIN_VV_MF4 + 0U, // PseudoVMIN_VV_MF4_MASK + 0U, // PseudoVMIN_VV_MF8 + 0U, // PseudoVMIN_VV_MF8_MASK + 0U, // PseudoVMIN_VX_M1 + 0U, // PseudoVMIN_VX_M1_MASK + 0U, // PseudoVMIN_VX_M2 + 0U, // PseudoVMIN_VX_M2_MASK + 0U, // PseudoVMIN_VX_M4 + 0U, // PseudoVMIN_VX_M4_MASK + 0U, // PseudoVMIN_VX_M8 + 0U, // PseudoVMIN_VX_M8_MASK + 0U, // PseudoVMIN_VX_MF2 + 0U, // PseudoVMIN_VX_MF2_MASK + 0U, // PseudoVMIN_VX_MF4 + 0U, // PseudoVMIN_VX_MF4_MASK + 0U, // PseudoVMIN_VX_MF8 + 0U, // PseudoVMIN_VX_MF8_MASK + 0U, // PseudoVMNAND_MM_M1 + 0U, // PseudoVMNAND_MM_M2 + 0U, // PseudoVMNAND_MM_M4 + 0U, // PseudoVMNAND_MM_M8 + 0U, // PseudoVMNAND_MM_MF2 + 0U, // PseudoVMNAND_MM_MF4 + 0U, // PseudoVMNAND_MM_MF8 + 0U, // PseudoVMNOR_MM_M1 + 0U, // PseudoVMNOR_MM_M2 + 0U, // PseudoVMNOR_MM_M4 + 0U, // PseudoVMNOR_MM_M8 + 0U, // PseudoVMNOR_MM_MF2 + 0U, // PseudoVMNOR_MM_MF4 + 0U, // PseudoVMNOR_MM_MF8 + 0U, // PseudoVMORN_MM_M1 + 0U, // PseudoVMORN_MM_M2 + 0U, // PseudoVMORN_MM_M4 + 0U, // PseudoVMORN_MM_M8 + 0U, // PseudoVMORN_MM_MF2 + 0U, // PseudoVMORN_MM_MF4 + 0U, // PseudoVMORN_MM_MF8 + 0U, // PseudoVMOR_MM_M1 + 0U, // PseudoVMOR_MM_M2 + 0U, // PseudoVMOR_MM_M4 + 0U, // PseudoVMOR_MM_M8 + 0U, // PseudoVMOR_MM_MF2 + 0U, // PseudoVMOR_MM_MF4 + 0U, // PseudoVMOR_MM_MF8 + 0U, // PseudoVMSBC_VVM_M1 + 0U, // PseudoVMSBC_VVM_M2 + 0U, // PseudoVMSBC_VVM_M4 + 0U, // PseudoVMSBC_VVM_M8 + 0U, // PseudoVMSBC_VVM_MF2 + 0U, // PseudoVMSBC_VVM_MF4 + 0U, // PseudoVMSBC_VVM_MF8 + 0U, // PseudoVMSBC_VV_M1 + 0U, // PseudoVMSBC_VV_M2 + 0U, // PseudoVMSBC_VV_M4 + 0U, // PseudoVMSBC_VV_M8 + 0U, // PseudoVMSBC_VV_MF2 + 0U, // PseudoVMSBC_VV_MF4 + 0U, // PseudoVMSBC_VV_MF8 + 0U, // PseudoVMSBC_VXM_M1 + 0U, // PseudoVMSBC_VXM_M2 + 0U, // PseudoVMSBC_VXM_M4 + 0U, // PseudoVMSBC_VXM_M8 + 0U, // PseudoVMSBC_VXM_MF2 + 0U, // PseudoVMSBC_VXM_MF4 + 0U, // PseudoVMSBC_VXM_MF8 + 0U, // PseudoVMSBC_VX_M1 + 0U, // PseudoVMSBC_VX_M2 + 0U, // PseudoVMSBC_VX_M4 + 0U, // PseudoVMSBC_VX_M8 + 0U, // PseudoVMSBC_VX_MF2 + 0U, // PseudoVMSBC_VX_MF4 + 0U, // PseudoVMSBC_VX_MF8 + 0U, // PseudoVMSBF_M_B1 + 0U, // PseudoVMSBF_M_B16 + 0U, // PseudoVMSBF_M_B16_MASK + 0U, // PseudoVMSBF_M_B1_MASK + 0U, // PseudoVMSBF_M_B2 + 0U, // PseudoVMSBF_M_B2_MASK + 0U, // PseudoVMSBF_M_B32 + 0U, // PseudoVMSBF_M_B32_MASK + 0U, // PseudoVMSBF_M_B4 + 0U, // PseudoVMSBF_M_B4_MASK + 0U, // PseudoVMSBF_M_B64 + 0U, // PseudoVMSBF_M_B64_MASK + 0U, // PseudoVMSBF_M_B8 + 0U, // PseudoVMSBF_M_B8_MASK + 0U, // PseudoVMSEQ_VI_M1 + 0U, // PseudoVMSEQ_VI_M1_MASK + 0U, // PseudoVMSEQ_VI_M2 + 0U, // PseudoVMSEQ_VI_M2_MASK + 0U, // PseudoVMSEQ_VI_M4 + 0U, // PseudoVMSEQ_VI_M4_MASK + 0U, // PseudoVMSEQ_VI_M8 + 0U, // PseudoVMSEQ_VI_M8_MASK + 0U, // PseudoVMSEQ_VI_MF2 + 0U, // PseudoVMSEQ_VI_MF2_MASK + 0U, // PseudoVMSEQ_VI_MF4 + 0U, // PseudoVMSEQ_VI_MF4_MASK + 0U, // PseudoVMSEQ_VI_MF8 + 0U, // PseudoVMSEQ_VI_MF8_MASK + 0U, // PseudoVMSEQ_VV_M1 + 0U, // PseudoVMSEQ_VV_M1_MASK + 0U, // PseudoVMSEQ_VV_M2 + 0U, // PseudoVMSEQ_VV_M2_MASK + 0U, // PseudoVMSEQ_VV_M4 + 0U, // PseudoVMSEQ_VV_M4_MASK + 0U, // PseudoVMSEQ_VV_M8 + 0U, // PseudoVMSEQ_VV_M8_MASK + 0U, // PseudoVMSEQ_VV_MF2 + 0U, // PseudoVMSEQ_VV_MF2_MASK + 0U, // PseudoVMSEQ_VV_MF4 + 0U, // PseudoVMSEQ_VV_MF4_MASK + 0U, // PseudoVMSEQ_VV_MF8 + 0U, // PseudoVMSEQ_VV_MF8_MASK + 0U, // PseudoVMSEQ_VX_M1 + 0U, // PseudoVMSEQ_VX_M1_MASK + 0U, // PseudoVMSEQ_VX_M2 + 0U, // PseudoVMSEQ_VX_M2_MASK + 0U, // PseudoVMSEQ_VX_M4 + 0U, // PseudoVMSEQ_VX_M4_MASK + 0U, // PseudoVMSEQ_VX_M8 + 0U, // PseudoVMSEQ_VX_M8_MASK + 0U, // PseudoVMSEQ_VX_MF2 + 0U, // PseudoVMSEQ_VX_MF2_MASK + 0U, // PseudoVMSEQ_VX_MF4 + 0U, // PseudoVMSEQ_VX_MF4_MASK + 0U, // PseudoVMSEQ_VX_MF8 + 0U, // PseudoVMSEQ_VX_MF8_MASK + 0U, // PseudoVMSET_M_B1 + 0U, // PseudoVMSET_M_B16 + 0U, // PseudoVMSET_M_B2 + 0U, // PseudoVMSET_M_B32 + 0U, // PseudoVMSET_M_B4 + 0U, // PseudoVMSET_M_B64 + 0U, // PseudoVMSET_M_B8 + 39409U, // PseudoVMSGEU_VI + 2147534164U, // PseudoVMSGEU_VX + 50516U, // PseudoVMSGEU_VX_M + 2954937684U, // PseudoVMSGEU_VX_M_T + 39223U, // PseudoVMSGE_VI + 2147533750U, // PseudoVMSGE_VX + 50102U, // PseudoVMSGE_VX_M + 2954937270U, // PseudoVMSGE_VX_M_T + 0U, // PseudoVMSGTU_VI_M1 + 0U, // PseudoVMSGTU_VI_M1_MASK + 0U, // PseudoVMSGTU_VI_M2 + 0U, // PseudoVMSGTU_VI_M2_MASK + 0U, // PseudoVMSGTU_VI_M4 + 0U, // PseudoVMSGTU_VI_M4_MASK + 0U, // PseudoVMSGTU_VI_M8 + 0U, // PseudoVMSGTU_VI_M8_MASK + 0U, // PseudoVMSGTU_VI_MF2 + 0U, // PseudoVMSGTU_VI_MF2_MASK + 0U, // PseudoVMSGTU_VI_MF4 + 0U, // PseudoVMSGTU_VI_MF4_MASK + 0U, // PseudoVMSGTU_VI_MF8 + 0U, // PseudoVMSGTU_VI_MF8_MASK + 0U, // PseudoVMSGTU_VX_M1 + 0U, // PseudoVMSGTU_VX_M1_MASK + 0U, // PseudoVMSGTU_VX_M2 + 0U, // PseudoVMSGTU_VX_M2_MASK + 0U, // PseudoVMSGTU_VX_M4 + 0U, // PseudoVMSGTU_VX_M4_MASK + 0U, // PseudoVMSGTU_VX_M8 + 0U, // PseudoVMSGTU_VX_M8_MASK + 0U, // PseudoVMSGTU_VX_MF2 + 0U, // PseudoVMSGTU_VX_MF2_MASK + 0U, // PseudoVMSGTU_VX_MF4 + 0U, // PseudoVMSGTU_VX_MF4_MASK + 0U, // PseudoVMSGTU_VX_MF8 + 0U, // PseudoVMSGTU_VX_MF8_MASK + 0U, // PseudoVMSGT_VI_M1 + 0U, // PseudoVMSGT_VI_M1_MASK + 0U, // PseudoVMSGT_VI_M2 + 0U, // PseudoVMSGT_VI_M2_MASK + 0U, // PseudoVMSGT_VI_M4 + 0U, // PseudoVMSGT_VI_M4_MASK + 0U, // PseudoVMSGT_VI_M8 + 0U, // PseudoVMSGT_VI_M8_MASK + 0U, // PseudoVMSGT_VI_MF2 + 0U, // PseudoVMSGT_VI_MF2_MASK + 0U, // PseudoVMSGT_VI_MF4 + 0U, // PseudoVMSGT_VI_MF4_MASK + 0U, // PseudoVMSGT_VI_MF8 + 0U, // PseudoVMSGT_VI_MF8_MASK + 0U, // PseudoVMSGT_VX_M1 + 0U, // PseudoVMSGT_VX_M1_MASK + 0U, // PseudoVMSGT_VX_M2 + 0U, // PseudoVMSGT_VX_M2_MASK + 0U, // PseudoVMSGT_VX_M4 + 0U, // PseudoVMSGT_VX_M4_MASK + 0U, // PseudoVMSGT_VX_M8 + 0U, // PseudoVMSGT_VX_M8_MASK + 0U, // PseudoVMSGT_VX_MF2 + 0U, // PseudoVMSGT_VX_MF2_MASK + 0U, // PseudoVMSGT_VX_MF4 + 0U, // PseudoVMSGT_VX_MF4_MASK + 0U, // PseudoVMSGT_VX_MF8 + 0U, // PseudoVMSGT_VX_MF8_MASK + 0U, // PseudoVMSIF_M_B1 + 0U, // PseudoVMSIF_M_B16 + 0U, // PseudoVMSIF_M_B16_MASK + 0U, // PseudoVMSIF_M_B1_MASK + 0U, // PseudoVMSIF_M_B2 + 0U, // PseudoVMSIF_M_B2_MASK + 0U, // PseudoVMSIF_M_B32 + 0U, // PseudoVMSIF_M_B32_MASK + 0U, // PseudoVMSIF_M_B4 + 0U, // PseudoVMSIF_M_B4_MASK + 0U, // PseudoVMSIF_M_B64 + 0U, // PseudoVMSIF_M_B64_MASK + 0U, // PseudoVMSIF_M_B8 + 0U, // PseudoVMSIF_M_B8_MASK + 0U, // PseudoVMSLEU_VI_M1 + 0U, // PseudoVMSLEU_VI_M1_MASK + 0U, // PseudoVMSLEU_VI_M2 + 0U, // PseudoVMSLEU_VI_M2_MASK + 0U, // PseudoVMSLEU_VI_M4 + 0U, // PseudoVMSLEU_VI_M4_MASK + 0U, // PseudoVMSLEU_VI_M8 + 0U, // PseudoVMSLEU_VI_M8_MASK + 0U, // PseudoVMSLEU_VI_MF2 + 0U, // PseudoVMSLEU_VI_MF2_MASK + 0U, // PseudoVMSLEU_VI_MF4 + 0U, // PseudoVMSLEU_VI_MF4_MASK + 0U, // PseudoVMSLEU_VI_MF8 + 0U, // PseudoVMSLEU_VI_MF8_MASK + 0U, // PseudoVMSLEU_VV_M1 + 0U, // PseudoVMSLEU_VV_M1_MASK + 0U, // PseudoVMSLEU_VV_M2 + 0U, // PseudoVMSLEU_VV_M2_MASK + 0U, // PseudoVMSLEU_VV_M4 + 0U, // PseudoVMSLEU_VV_M4_MASK + 0U, // PseudoVMSLEU_VV_M8 + 0U, // PseudoVMSLEU_VV_M8_MASK + 0U, // PseudoVMSLEU_VV_MF2 + 0U, // PseudoVMSLEU_VV_MF2_MASK + 0U, // PseudoVMSLEU_VV_MF4 + 0U, // PseudoVMSLEU_VV_MF4_MASK + 0U, // PseudoVMSLEU_VV_MF8 + 0U, // PseudoVMSLEU_VV_MF8_MASK + 0U, // PseudoVMSLEU_VX_M1 + 0U, // PseudoVMSLEU_VX_M1_MASK + 0U, // PseudoVMSLEU_VX_M2 + 0U, // PseudoVMSLEU_VX_M2_MASK + 0U, // PseudoVMSLEU_VX_M4 + 0U, // PseudoVMSLEU_VX_M4_MASK + 0U, // PseudoVMSLEU_VX_M8 + 0U, // PseudoVMSLEU_VX_M8_MASK + 0U, // PseudoVMSLEU_VX_MF2 + 0U, // PseudoVMSLEU_VX_MF2_MASK + 0U, // PseudoVMSLEU_VX_MF4 + 0U, // PseudoVMSLEU_VX_MF4_MASK + 0U, // PseudoVMSLEU_VX_MF8 + 0U, // PseudoVMSLEU_VX_MF8_MASK + 0U, // PseudoVMSLE_VI_M1 + 0U, // PseudoVMSLE_VI_M1_MASK + 0U, // PseudoVMSLE_VI_M2 + 0U, // PseudoVMSLE_VI_M2_MASK + 0U, // PseudoVMSLE_VI_M4 + 0U, // PseudoVMSLE_VI_M4_MASK + 0U, // PseudoVMSLE_VI_M8 + 0U, // PseudoVMSLE_VI_M8_MASK + 0U, // PseudoVMSLE_VI_MF2 + 0U, // PseudoVMSLE_VI_MF2_MASK + 0U, // PseudoVMSLE_VI_MF4 + 0U, // PseudoVMSLE_VI_MF4_MASK + 0U, // PseudoVMSLE_VI_MF8 + 0U, // PseudoVMSLE_VI_MF8_MASK + 0U, // PseudoVMSLE_VV_M1 + 0U, // PseudoVMSLE_VV_M1_MASK + 0U, // PseudoVMSLE_VV_M2 + 0U, // PseudoVMSLE_VV_M2_MASK + 0U, // PseudoVMSLE_VV_M4 + 0U, // PseudoVMSLE_VV_M4_MASK + 0U, // PseudoVMSLE_VV_M8 + 0U, // PseudoVMSLE_VV_M8_MASK + 0U, // PseudoVMSLE_VV_MF2 + 0U, // PseudoVMSLE_VV_MF2_MASK + 0U, // PseudoVMSLE_VV_MF4 + 0U, // PseudoVMSLE_VV_MF4_MASK + 0U, // PseudoVMSLE_VV_MF8 + 0U, // PseudoVMSLE_VV_MF8_MASK + 0U, // PseudoVMSLE_VX_M1 + 0U, // PseudoVMSLE_VX_M1_MASK + 0U, // PseudoVMSLE_VX_M2 + 0U, // PseudoVMSLE_VX_M2_MASK + 0U, // PseudoVMSLE_VX_M4 + 0U, // PseudoVMSLE_VX_M4_MASK + 0U, // PseudoVMSLE_VX_M8 + 0U, // PseudoVMSLE_VX_M8_MASK + 0U, // PseudoVMSLE_VX_MF2 + 0U, // PseudoVMSLE_VX_MF2_MASK + 0U, // PseudoVMSLE_VX_MF4 + 0U, // PseudoVMSLE_VX_MF4_MASK + 0U, // PseudoVMSLE_VX_MF8 + 0U, // PseudoVMSLE_VX_MF8_MASK + 39442U, // PseudoVMSLTU_VI + 0U, // PseudoVMSLTU_VV_M1 + 0U, // PseudoVMSLTU_VV_M1_MASK + 0U, // PseudoVMSLTU_VV_M2 + 0U, // PseudoVMSLTU_VV_M2_MASK + 0U, // PseudoVMSLTU_VV_M4 + 0U, // PseudoVMSLTU_VV_M4_MASK + 0U, // PseudoVMSLTU_VV_M8 + 0U, // PseudoVMSLTU_VV_M8_MASK + 0U, // PseudoVMSLTU_VV_MF2 + 0U, // PseudoVMSLTU_VV_MF2_MASK + 0U, // PseudoVMSLTU_VV_MF4 + 0U, // PseudoVMSLTU_VV_MF4_MASK + 0U, // PseudoVMSLTU_VV_MF8 + 0U, // PseudoVMSLTU_VV_MF8_MASK + 0U, // PseudoVMSLTU_VX_M1 + 0U, // PseudoVMSLTU_VX_M1_MASK + 0U, // PseudoVMSLTU_VX_M2 + 0U, // PseudoVMSLTU_VX_M2_MASK + 0U, // PseudoVMSLTU_VX_M4 + 0U, // PseudoVMSLTU_VX_M4_MASK + 0U, // PseudoVMSLTU_VX_M8 + 0U, // PseudoVMSLTU_VX_M8_MASK + 0U, // PseudoVMSLTU_VX_MF2 + 0U, // PseudoVMSLTU_VX_MF2_MASK + 0U, // PseudoVMSLTU_VX_MF4 + 0U, // PseudoVMSLTU_VX_MF4_MASK + 0U, // PseudoVMSLTU_VX_MF8 + 0U, // PseudoVMSLTU_VX_MF8_MASK + 39388U, // PseudoVMSLT_VI + 0U, // PseudoVMSLT_VV_M1 + 0U, // PseudoVMSLT_VV_M1_MASK + 0U, // PseudoVMSLT_VV_M2 + 0U, // PseudoVMSLT_VV_M2_MASK + 0U, // PseudoVMSLT_VV_M4 + 0U, // PseudoVMSLT_VV_M4_MASK + 0U, // PseudoVMSLT_VV_M8 + 0U, // PseudoVMSLT_VV_M8_MASK + 0U, // PseudoVMSLT_VV_MF2 + 0U, // PseudoVMSLT_VV_MF2_MASK + 0U, // PseudoVMSLT_VV_MF4 + 0U, // PseudoVMSLT_VV_MF4_MASK + 0U, // PseudoVMSLT_VV_MF8 + 0U, // PseudoVMSLT_VV_MF8_MASK + 0U, // PseudoVMSLT_VX_M1 + 0U, // PseudoVMSLT_VX_M1_MASK + 0U, // PseudoVMSLT_VX_M2 + 0U, // PseudoVMSLT_VX_M2_MASK + 0U, // PseudoVMSLT_VX_M4 + 0U, // PseudoVMSLT_VX_M4_MASK + 0U, // PseudoVMSLT_VX_M8 + 0U, // PseudoVMSLT_VX_M8_MASK + 0U, // PseudoVMSLT_VX_MF2 + 0U, // PseudoVMSLT_VX_MF2_MASK + 0U, // PseudoVMSLT_VX_MF4 + 0U, // PseudoVMSLT_VX_MF4_MASK + 0U, // PseudoVMSLT_VX_MF8 + 0U, // PseudoVMSLT_VX_MF8_MASK + 0U, // PseudoVMSNE_VI_M1 + 0U, // PseudoVMSNE_VI_M1_MASK + 0U, // PseudoVMSNE_VI_M2 + 0U, // PseudoVMSNE_VI_M2_MASK + 0U, // PseudoVMSNE_VI_M4 + 0U, // PseudoVMSNE_VI_M4_MASK + 0U, // PseudoVMSNE_VI_M8 + 0U, // PseudoVMSNE_VI_M8_MASK + 0U, // PseudoVMSNE_VI_MF2 + 0U, // PseudoVMSNE_VI_MF2_MASK + 0U, // PseudoVMSNE_VI_MF4 + 0U, // PseudoVMSNE_VI_MF4_MASK + 0U, // PseudoVMSNE_VI_MF8 + 0U, // PseudoVMSNE_VI_MF8_MASK + 0U, // PseudoVMSNE_VV_M1 + 0U, // PseudoVMSNE_VV_M1_MASK + 0U, // PseudoVMSNE_VV_M2 + 0U, // PseudoVMSNE_VV_M2_MASK + 0U, // PseudoVMSNE_VV_M4 + 0U, // PseudoVMSNE_VV_M4_MASK + 0U, // PseudoVMSNE_VV_M8 + 0U, // PseudoVMSNE_VV_M8_MASK + 0U, // PseudoVMSNE_VV_MF2 + 0U, // PseudoVMSNE_VV_MF2_MASK + 0U, // PseudoVMSNE_VV_MF4 + 0U, // PseudoVMSNE_VV_MF4_MASK + 0U, // PseudoVMSNE_VV_MF8 + 0U, // PseudoVMSNE_VV_MF8_MASK + 0U, // PseudoVMSNE_VX_M1 + 0U, // PseudoVMSNE_VX_M1_MASK + 0U, // PseudoVMSNE_VX_M2 + 0U, // PseudoVMSNE_VX_M2_MASK + 0U, // PseudoVMSNE_VX_M4 + 0U, // PseudoVMSNE_VX_M4_MASK + 0U, // PseudoVMSNE_VX_M8 + 0U, // PseudoVMSNE_VX_M8_MASK + 0U, // PseudoVMSNE_VX_MF2 + 0U, // PseudoVMSNE_VX_MF2_MASK + 0U, // PseudoVMSNE_VX_MF4 + 0U, // PseudoVMSNE_VX_MF4_MASK + 0U, // PseudoVMSNE_VX_MF8 + 0U, // PseudoVMSNE_VX_MF8_MASK + 0U, // PseudoVMSOF_M_B1 + 0U, // PseudoVMSOF_M_B16 + 0U, // PseudoVMSOF_M_B16_MASK + 0U, // PseudoVMSOF_M_B1_MASK + 0U, // PseudoVMSOF_M_B2 + 0U, // PseudoVMSOF_M_B2_MASK + 0U, // PseudoVMSOF_M_B32 + 0U, // PseudoVMSOF_M_B32_MASK + 0U, // PseudoVMSOF_M_B4 + 0U, // PseudoVMSOF_M_B4_MASK + 0U, // PseudoVMSOF_M_B64 + 0U, // PseudoVMSOF_M_B64_MASK + 0U, // PseudoVMSOF_M_B8 + 0U, // PseudoVMSOF_M_B8_MASK + 0U, // PseudoVMULHSU_VV_M1 + 0U, // PseudoVMULHSU_VV_M1_MASK + 0U, // PseudoVMULHSU_VV_M2 + 0U, // PseudoVMULHSU_VV_M2_MASK + 0U, // PseudoVMULHSU_VV_M4 + 0U, // PseudoVMULHSU_VV_M4_MASK + 0U, // PseudoVMULHSU_VV_M8 + 0U, // PseudoVMULHSU_VV_M8_MASK + 0U, // PseudoVMULHSU_VV_MF2 + 0U, // PseudoVMULHSU_VV_MF2_MASK + 0U, // PseudoVMULHSU_VV_MF4 + 0U, // PseudoVMULHSU_VV_MF4_MASK + 0U, // PseudoVMULHSU_VV_MF8 + 0U, // PseudoVMULHSU_VV_MF8_MASK + 0U, // PseudoVMULHSU_VX_M1 + 0U, // PseudoVMULHSU_VX_M1_MASK + 0U, // PseudoVMULHSU_VX_M2 + 0U, // PseudoVMULHSU_VX_M2_MASK + 0U, // PseudoVMULHSU_VX_M4 + 0U, // PseudoVMULHSU_VX_M4_MASK + 0U, // PseudoVMULHSU_VX_M8 + 0U, // PseudoVMULHSU_VX_M8_MASK + 0U, // PseudoVMULHSU_VX_MF2 + 0U, // PseudoVMULHSU_VX_MF2_MASK + 0U, // PseudoVMULHSU_VX_MF4 + 0U, // PseudoVMULHSU_VX_MF4_MASK + 0U, // PseudoVMULHSU_VX_MF8 + 0U, // PseudoVMULHSU_VX_MF8_MASK + 0U, // PseudoVMULHU_VV_M1 + 0U, // PseudoVMULHU_VV_M1_MASK + 0U, // PseudoVMULHU_VV_M2 + 0U, // PseudoVMULHU_VV_M2_MASK + 0U, // PseudoVMULHU_VV_M4 + 0U, // PseudoVMULHU_VV_M4_MASK + 0U, // PseudoVMULHU_VV_M8 + 0U, // PseudoVMULHU_VV_M8_MASK + 0U, // PseudoVMULHU_VV_MF2 + 0U, // PseudoVMULHU_VV_MF2_MASK + 0U, // PseudoVMULHU_VV_MF4 + 0U, // PseudoVMULHU_VV_MF4_MASK + 0U, // PseudoVMULHU_VV_MF8 + 0U, // PseudoVMULHU_VV_MF8_MASK + 0U, // PseudoVMULHU_VX_M1 + 0U, // PseudoVMULHU_VX_M1_MASK + 0U, // PseudoVMULHU_VX_M2 + 0U, // PseudoVMULHU_VX_M2_MASK + 0U, // PseudoVMULHU_VX_M4 + 0U, // PseudoVMULHU_VX_M4_MASK + 0U, // PseudoVMULHU_VX_M8 + 0U, // PseudoVMULHU_VX_M8_MASK + 0U, // PseudoVMULHU_VX_MF2 + 0U, // PseudoVMULHU_VX_MF2_MASK + 0U, // PseudoVMULHU_VX_MF4 + 0U, // PseudoVMULHU_VX_MF4_MASK + 0U, // PseudoVMULHU_VX_MF8 + 0U, // PseudoVMULHU_VX_MF8_MASK + 0U, // PseudoVMULH_VV_M1 + 0U, // PseudoVMULH_VV_M1_MASK + 0U, // PseudoVMULH_VV_M2 + 0U, // PseudoVMULH_VV_M2_MASK + 0U, // PseudoVMULH_VV_M4 + 0U, // PseudoVMULH_VV_M4_MASK + 0U, // PseudoVMULH_VV_M8 + 0U, // PseudoVMULH_VV_M8_MASK + 0U, // PseudoVMULH_VV_MF2 + 0U, // PseudoVMULH_VV_MF2_MASK + 0U, // PseudoVMULH_VV_MF4 + 0U, // PseudoVMULH_VV_MF4_MASK + 0U, // PseudoVMULH_VV_MF8 + 0U, // PseudoVMULH_VV_MF8_MASK + 0U, // PseudoVMULH_VX_M1 + 0U, // PseudoVMULH_VX_M1_MASK + 0U, // PseudoVMULH_VX_M2 + 0U, // PseudoVMULH_VX_M2_MASK + 0U, // PseudoVMULH_VX_M4 + 0U, // PseudoVMULH_VX_M4_MASK + 0U, // PseudoVMULH_VX_M8 + 0U, // PseudoVMULH_VX_M8_MASK + 0U, // PseudoVMULH_VX_MF2 + 0U, // PseudoVMULH_VX_MF2_MASK + 0U, // PseudoVMULH_VX_MF4 + 0U, // PseudoVMULH_VX_MF4_MASK + 0U, // PseudoVMULH_VX_MF8 + 0U, // PseudoVMULH_VX_MF8_MASK + 0U, // PseudoVMUL_VV_M1 + 0U, // PseudoVMUL_VV_M1_MASK + 0U, // PseudoVMUL_VV_M2 + 0U, // PseudoVMUL_VV_M2_MASK + 0U, // PseudoVMUL_VV_M4 + 0U, // PseudoVMUL_VV_M4_MASK + 0U, // PseudoVMUL_VV_M8 + 0U, // PseudoVMUL_VV_M8_MASK + 0U, // PseudoVMUL_VV_MF2 + 0U, // PseudoVMUL_VV_MF2_MASK + 0U, // PseudoVMUL_VV_MF4 + 0U, // PseudoVMUL_VV_MF4_MASK + 0U, // PseudoVMUL_VV_MF8 + 0U, // PseudoVMUL_VV_MF8_MASK + 0U, // PseudoVMUL_VX_M1 + 0U, // PseudoVMUL_VX_M1_MASK + 0U, // PseudoVMUL_VX_M2 + 0U, // PseudoVMUL_VX_M2_MASK + 0U, // PseudoVMUL_VX_M4 + 0U, // PseudoVMUL_VX_M4_MASK + 0U, // PseudoVMUL_VX_M8 + 0U, // PseudoVMUL_VX_M8_MASK + 0U, // PseudoVMUL_VX_MF2 + 0U, // PseudoVMUL_VX_MF2_MASK + 0U, // PseudoVMUL_VX_MF4 + 0U, // PseudoVMUL_VX_MF4_MASK + 0U, // PseudoVMUL_VX_MF8 + 0U, // PseudoVMUL_VX_MF8_MASK + 0U, // PseudoVMV_S_X + 0U, // PseudoVMV_V_I_M1 + 0U, // PseudoVMV_V_I_M2 + 0U, // PseudoVMV_V_I_M4 + 0U, // PseudoVMV_V_I_M8 + 0U, // PseudoVMV_V_I_MF2 + 0U, // PseudoVMV_V_I_MF4 + 0U, // PseudoVMV_V_I_MF8 + 0U, // PseudoVMV_V_V_M1 + 0U, // PseudoVMV_V_V_M2 + 0U, // PseudoVMV_V_V_M4 + 0U, // PseudoVMV_V_V_M8 + 0U, // PseudoVMV_V_V_MF2 + 0U, // PseudoVMV_V_V_MF4 + 0U, // PseudoVMV_V_V_MF8 + 0U, // PseudoVMV_V_X_M1 + 0U, // PseudoVMV_V_X_M2 + 0U, // PseudoVMV_V_X_M4 + 0U, // PseudoVMV_V_X_M8 + 0U, // PseudoVMV_V_X_MF2 + 0U, // PseudoVMV_V_X_MF4 + 0U, // PseudoVMV_V_X_MF8 + 0U, // PseudoVMV_X_S + 0U, // PseudoVMXNOR_MM_M1 + 0U, // PseudoVMXNOR_MM_M2 + 0U, // PseudoVMXNOR_MM_M4 + 0U, // PseudoVMXNOR_MM_M8 + 0U, // PseudoVMXNOR_MM_MF2 + 0U, // PseudoVMXNOR_MM_MF4 + 0U, // PseudoVMXNOR_MM_MF8 + 0U, // PseudoVMXOR_MM_M1 + 0U, // PseudoVMXOR_MM_M2 + 0U, // PseudoVMXOR_MM_M4 + 0U, // PseudoVMXOR_MM_M8 + 0U, // PseudoVMXOR_MM_MF2 + 0U, // PseudoVMXOR_MM_MF4 + 0U, // PseudoVMXOR_MM_MF8 + 0U, // PseudoVNCLIPU_WI_M1 + 0U, // PseudoVNCLIPU_WI_M1_MASK + 0U, // PseudoVNCLIPU_WI_M2 + 0U, // PseudoVNCLIPU_WI_M2_MASK + 0U, // PseudoVNCLIPU_WI_M4 + 0U, // PseudoVNCLIPU_WI_M4_MASK + 0U, // PseudoVNCLIPU_WI_MF2 + 0U, // PseudoVNCLIPU_WI_MF2_MASK + 0U, // PseudoVNCLIPU_WI_MF4 + 0U, // PseudoVNCLIPU_WI_MF4_MASK + 0U, // PseudoVNCLIPU_WI_MF8 + 0U, // PseudoVNCLIPU_WI_MF8_MASK + 0U, // PseudoVNCLIPU_WV_M1 + 0U, // PseudoVNCLIPU_WV_M1_MASK + 0U, // PseudoVNCLIPU_WV_M2 + 0U, // PseudoVNCLIPU_WV_M2_MASK + 0U, // PseudoVNCLIPU_WV_M4 + 0U, // PseudoVNCLIPU_WV_M4_MASK + 0U, // PseudoVNCLIPU_WV_MF2 + 0U, // PseudoVNCLIPU_WV_MF2_MASK + 0U, // PseudoVNCLIPU_WV_MF4 + 0U, // PseudoVNCLIPU_WV_MF4_MASK + 0U, // PseudoVNCLIPU_WV_MF8 + 0U, // PseudoVNCLIPU_WV_MF8_MASK + 0U, // PseudoVNCLIPU_WX_M1 + 0U, // PseudoVNCLIPU_WX_M1_MASK + 0U, // PseudoVNCLIPU_WX_M2 + 0U, // PseudoVNCLIPU_WX_M2_MASK + 0U, // PseudoVNCLIPU_WX_M4 + 0U, // PseudoVNCLIPU_WX_M4_MASK + 0U, // PseudoVNCLIPU_WX_MF2 + 0U, // PseudoVNCLIPU_WX_MF2_MASK + 0U, // PseudoVNCLIPU_WX_MF4 + 0U, // PseudoVNCLIPU_WX_MF4_MASK + 0U, // PseudoVNCLIPU_WX_MF8 + 0U, // PseudoVNCLIPU_WX_MF8_MASK + 0U, // PseudoVNCLIP_WI_M1 + 0U, // PseudoVNCLIP_WI_M1_MASK + 0U, // PseudoVNCLIP_WI_M2 + 0U, // PseudoVNCLIP_WI_M2_MASK + 0U, // PseudoVNCLIP_WI_M4 + 0U, // PseudoVNCLIP_WI_M4_MASK + 0U, // PseudoVNCLIP_WI_MF2 + 0U, // PseudoVNCLIP_WI_MF2_MASK + 0U, // PseudoVNCLIP_WI_MF4 + 0U, // PseudoVNCLIP_WI_MF4_MASK + 0U, // PseudoVNCLIP_WI_MF8 + 0U, // PseudoVNCLIP_WI_MF8_MASK + 0U, // PseudoVNCLIP_WV_M1 + 0U, // PseudoVNCLIP_WV_M1_MASK + 0U, // PseudoVNCLIP_WV_M2 + 0U, // PseudoVNCLIP_WV_M2_MASK + 0U, // PseudoVNCLIP_WV_M4 + 0U, // PseudoVNCLIP_WV_M4_MASK + 0U, // PseudoVNCLIP_WV_MF2 + 0U, // PseudoVNCLIP_WV_MF2_MASK + 0U, // PseudoVNCLIP_WV_MF4 + 0U, // PseudoVNCLIP_WV_MF4_MASK + 0U, // PseudoVNCLIP_WV_MF8 + 0U, // PseudoVNCLIP_WV_MF8_MASK + 0U, // PseudoVNCLIP_WX_M1 + 0U, // PseudoVNCLIP_WX_M1_MASK + 0U, // PseudoVNCLIP_WX_M2 + 0U, // PseudoVNCLIP_WX_M2_MASK + 0U, // PseudoVNCLIP_WX_M4 + 0U, // PseudoVNCLIP_WX_M4_MASK + 0U, // PseudoVNCLIP_WX_MF2 + 0U, // PseudoVNCLIP_WX_MF2_MASK + 0U, // PseudoVNCLIP_WX_MF4 + 0U, // PseudoVNCLIP_WX_MF4_MASK + 0U, // PseudoVNCLIP_WX_MF8 + 0U, // PseudoVNCLIP_WX_MF8_MASK + 0U, // PseudoVNMSAC_VV_M1 + 0U, // PseudoVNMSAC_VV_M1_MASK + 0U, // PseudoVNMSAC_VV_M2 + 0U, // PseudoVNMSAC_VV_M2_MASK + 0U, // PseudoVNMSAC_VV_M4 + 0U, // PseudoVNMSAC_VV_M4_MASK + 0U, // PseudoVNMSAC_VV_M8 + 0U, // PseudoVNMSAC_VV_M8_MASK + 0U, // PseudoVNMSAC_VV_MF2 + 0U, // PseudoVNMSAC_VV_MF2_MASK + 0U, // PseudoVNMSAC_VV_MF4 + 0U, // PseudoVNMSAC_VV_MF4_MASK + 0U, // PseudoVNMSAC_VV_MF8 + 0U, // PseudoVNMSAC_VV_MF8_MASK + 0U, // PseudoVNMSAC_VX_M1 + 0U, // PseudoVNMSAC_VX_M1_MASK + 0U, // PseudoVNMSAC_VX_M2 + 0U, // PseudoVNMSAC_VX_M2_MASK + 0U, // PseudoVNMSAC_VX_M4 + 0U, // PseudoVNMSAC_VX_M4_MASK + 0U, // PseudoVNMSAC_VX_M8 + 0U, // PseudoVNMSAC_VX_M8_MASK + 0U, // PseudoVNMSAC_VX_MF2 + 0U, // PseudoVNMSAC_VX_MF2_MASK + 0U, // PseudoVNMSAC_VX_MF4 + 0U, // PseudoVNMSAC_VX_MF4_MASK + 0U, // PseudoVNMSAC_VX_MF8 + 0U, // PseudoVNMSAC_VX_MF8_MASK + 0U, // PseudoVNMSUB_VV_M1 + 0U, // PseudoVNMSUB_VV_M1_MASK + 0U, // PseudoVNMSUB_VV_M2 + 0U, // PseudoVNMSUB_VV_M2_MASK + 0U, // PseudoVNMSUB_VV_M4 + 0U, // PseudoVNMSUB_VV_M4_MASK + 0U, // PseudoVNMSUB_VV_M8 + 0U, // PseudoVNMSUB_VV_M8_MASK + 0U, // PseudoVNMSUB_VV_MF2 + 0U, // PseudoVNMSUB_VV_MF2_MASK + 0U, // PseudoVNMSUB_VV_MF4 + 0U, // PseudoVNMSUB_VV_MF4_MASK + 0U, // PseudoVNMSUB_VV_MF8 + 0U, // PseudoVNMSUB_VV_MF8_MASK + 0U, // PseudoVNMSUB_VX_M1 + 0U, // PseudoVNMSUB_VX_M1_MASK + 0U, // PseudoVNMSUB_VX_M2 + 0U, // PseudoVNMSUB_VX_M2_MASK + 0U, // PseudoVNMSUB_VX_M4 + 0U, // PseudoVNMSUB_VX_M4_MASK + 0U, // PseudoVNMSUB_VX_M8 + 0U, // PseudoVNMSUB_VX_M8_MASK + 0U, // PseudoVNMSUB_VX_MF2 + 0U, // PseudoVNMSUB_VX_MF2_MASK + 0U, // PseudoVNMSUB_VX_MF4 + 0U, // PseudoVNMSUB_VX_MF4_MASK + 0U, // PseudoVNMSUB_VX_MF8 + 0U, // PseudoVNMSUB_VX_MF8_MASK + 0U, // PseudoVNSRA_WI_M1 + 0U, // PseudoVNSRA_WI_M1_MASK + 0U, // PseudoVNSRA_WI_M2 + 0U, // PseudoVNSRA_WI_M2_MASK + 0U, // PseudoVNSRA_WI_M4 + 0U, // PseudoVNSRA_WI_M4_MASK + 0U, // PseudoVNSRA_WI_MF2 + 0U, // PseudoVNSRA_WI_MF2_MASK + 0U, // PseudoVNSRA_WI_MF4 + 0U, // PseudoVNSRA_WI_MF4_MASK + 0U, // PseudoVNSRA_WI_MF8 + 0U, // PseudoVNSRA_WI_MF8_MASK + 0U, // PseudoVNSRA_WV_M1 + 0U, // PseudoVNSRA_WV_M1_MASK + 0U, // PseudoVNSRA_WV_M2 + 0U, // PseudoVNSRA_WV_M2_MASK + 0U, // PseudoVNSRA_WV_M4 + 0U, // PseudoVNSRA_WV_M4_MASK + 0U, // PseudoVNSRA_WV_MF2 + 0U, // PseudoVNSRA_WV_MF2_MASK + 0U, // PseudoVNSRA_WV_MF4 + 0U, // PseudoVNSRA_WV_MF4_MASK + 0U, // PseudoVNSRA_WV_MF8 + 0U, // PseudoVNSRA_WV_MF8_MASK + 0U, // PseudoVNSRA_WX_M1 + 0U, // PseudoVNSRA_WX_M1_MASK + 0U, // PseudoVNSRA_WX_M2 + 0U, // PseudoVNSRA_WX_M2_MASK + 0U, // PseudoVNSRA_WX_M4 + 0U, // PseudoVNSRA_WX_M4_MASK + 0U, // PseudoVNSRA_WX_MF2 + 0U, // PseudoVNSRA_WX_MF2_MASK + 0U, // PseudoVNSRA_WX_MF4 + 0U, // PseudoVNSRA_WX_MF4_MASK + 0U, // PseudoVNSRA_WX_MF8 + 0U, // PseudoVNSRA_WX_MF8_MASK + 0U, // PseudoVNSRL_WI_M1 + 0U, // PseudoVNSRL_WI_M1_MASK + 0U, // PseudoVNSRL_WI_M2 + 0U, // PseudoVNSRL_WI_M2_MASK + 0U, // PseudoVNSRL_WI_M4 + 0U, // PseudoVNSRL_WI_M4_MASK + 0U, // PseudoVNSRL_WI_MF2 + 0U, // PseudoVNSRL_WI_MF2_MASK + 0U, // PseudoVNSRL_WI_MF4 + 0U, // PseudoVNSRL_WI_MF4_MASK + 0U, // PseudoVNSRL_WI_MF8 + 0U, // PseudoVNSRL_WI_MF8_MASK + 0U, // PseudoVNSRL_WV_M1 + 0U, // PseudoVNSRL_WV_M1_MASK + 0U, // PseudoVNSRL_WV_M2 + 0U, // PseudoVNSRL_WV_M2_MASK + 0U, // PseudoVNSRL_WV_M4 + 0U, // PseudoVNSRL_WV_M4_MASK + 0U, // PseudoVNSRL_WV_MF2 + 0U, // PseudoVNSRL_WV_MF2_MASK + 0U, // PseudoVNSRL_WV_MF4 + 0U, // PseudoVNSRL_WV_MF4_MASK + 0U, // PseudoVNSRL_WV_MF8 + 0U, // PseudoVNSRL_WV_MF8_MASK + 0U, // PseudoVNSRL_WX_M1 + 0U, // PseudoVNSRL_WX_M1_MASK + 0U, // PseudoVNSRL_WX_M2 + 0U, // PseudoVNSRL_WX_M2_MASK + 0U, // PseudoVNSRL_WX_M4 + 0U, // PseudoVNSRL_WX_M4_MASK + 0U, // PseudoVNSRL_WX_MF2 + 0U, // PseudoVNSRL_WX_MF2_MASK + 0U, // PseudoVNSRL_WX_MF4 + 0U, // PseudoVNSRL_WX_MF4_MASK + 0U, // PseudoVNSRL_WX_MF8 + 0U, // PseudoVNSRL_WX_MF8_MASK + 0U, // PseudoVOR_VI_M1 + 0U, // PseudoVOR_VI_M1_MASK + 0U, // PseudoVOR_VI_M2 + 0U, // PseudoVOR_VI_M2_MASK + 0U, // PseudoVOR_VI_M4 + 0U, // PseudoVOR_VI_M4_MASK + 0U, // PseudoVOR_VI_M8 + 0U, // PseudoVOR_VI_M8_MASK + 0U, // PseudoVOR_VI_MF2 + 0U, // PseudoVOR_VI_MF2_MASK + 0U, // PseudoVOR_VI_MF4 + 0U, // PseudoVOR_VI_MF4_MASK + 0U, // PseudoVOR_VI_MF8 + 0U, // PseudoVOR_VI_MF8_MASK + 0U, // PseudoVOR_VV_M1 + 0U, // PseudoVOR_VV_M1_MASK + 0U, // PseudoVOR_VV_M2 + 0U, // PseudoVOR_VV_M2_MASK + 0U, // PseudoVOR_VV_M4 + 0U, // PseudoVOR_VV_M4_MASK + 0U, // PseudoVOR_VV_M8 + 0U, // PseudoVOR_VV_M8_MASK + 0U, // PseudoVOR_VV_MF2 + 0U, // PseudoVOR_VV_MF2_MASK + 0U, // PseudoVOR_VV_MF4 + 0U, // PseudoVOR_VV_MF4_MASK + 0U, // PseudoVOR_VV_MF8 + 0U, // PseudoVOR_VV_MF8_MASK + 0U, // PseudoVOR_VX_M1 + 0U, // PseudoVOR_VX_M1_MASK + 0U, // PseudoVOR_VX_M2 + 0U, // PseudoVOR_VX_M2_MASK + 0U, // PseudoVOR_VX_M4 + 0U, // PseudoVOR_VX_M4_MASK + 0U, // PseudoVOR_VX_M8 + 0U, // PseudoVOR_VX_M8_MASK + 0U, // PseudoVOR_VX_MF2 + 0U, // PseudoVOR_VX_MF2_MASK + 0U, // PseudoVOR_VX_MF4 + 0U, // PseudoVOR_VX_MF4_MASK + 0U, // PseudoVOR_VX_MF8 + 0U, // PseudoVOR_VX_MF8_MASK + 0U, // PseudoVQMACCSU_2x8x2_M1 + 0U, // PseudoVQMACCSU_2x8x2_M2 + 0U, // PseudoVQMACCSU_2x8x2_M4 + 0U, // PseudoVQMACCSU_2x8x2_M8 + 0U, // PseudoVQMACCSU_4x8x4_M1 + 0U, // PseudoVQMACCSU_4x8x4_M2 + 0U, // PseudoVQMACCSU_4x8x4_M4 + 0U, // PseudoVQMACCSU_4x8x4_MF2 + 0U, // PseudoVQMACCUS_2x8x2_M1 + 0U, // PseudoVQMACCUS_2x8x2_M2 + 0U, // PseudoVQMACCUS_2x8x2_M4 + 0U, // PseudoVQMACCUS_2x8x2_M8 + 0U, // PseudoVQMACCUS_4x8x4_M1 + 0U, // PseudoVQMACCUS_4x8x4_M2 + 0U, // PseudoVQMACCUS_4x8x4_M4 + 0U, // PseudoVQMACCUS_4x8x4_MF2 + 0U, // PseudoVQMACCU_2x8x2_M1 + 0U, // PseudoVQMACCU_2x8x2_M2 + 0U, // PseudoVQMACCU_2x8x2_M4 + 0U, // PseudoVQMACCU_2x8x2_M8 + 0U, // PseudoVQMACCU_4x8x4_M1 + 0U, // PseudoVQMACCU_4x8x4_M2 + 0U, // PseudoVQMACCU_4x8x4_M4 + 0U, // PseudoVQMACCU_4x8x4_MF2 + 0U, // PseudoVQMACC_2x8x2_M1 + 0U, // PseudoVQMACC_2x8x2_M2 + 0U, // PseudoVQMACC_2x8x2_M4 + 0U, // PseudoVQMACC_2x8x2_M8 + 0U, // PseudoVQMACC_4x8x4_M1 + 0U, // PseudoVQMACC_4x8x4_M2 + 0U, // PseudoVQMACC_4x8x4_M4 + 0U, // PseudoVQMACC_4x8x4_MF2 + 0U, // PseudoVREDAND_VS_M1_E16 + 0U, // PseudoVREDAND_VS_M1_E16_MASK + 0U, // PseudoVREDAND_VS_M1_E32 + 0U, // PseudoVREDAND_VS_M1_E32_MASK + 0U, // PseudoVREDAND_VS_M1_E64 + 0U, // PseudoVREDAND_VS_M1_E64_MASK + 0U, // PseudoVREDAND_VS_M1_E8 + 0U, // PseudoVREDAND_VS_M1_E8_MASK + 0U, // PseudoVREDAND_VS_M2_E16 + 0U, // PseudoVREDAND_VS_M2_E16_MASK + 0U, // PseudoVREDAND_VS_M2_E32 + 0U, // PseudoVREDAND_VS_M2_E32_MASK + 0U, // PseudoVREDAND_VS_M2_E64 + 0U, // PseudoVREDAND_VS_M2_E64_MASK + 0U, // PseudoVREDAND_VS_M2_E8 + 0U, // PseudoVREDAND_VS_M2_E8_MASK + 0U, // PseudoVREDAND_VS_M4_E16 + 0U, // PseudoVREDAND_VS_M4_E16_MASK + 0U, // PseudoVREDAND_VS_M4_E32 + 0U, // PseudoVREDAND_VS_M4_E32_MASK + 0U, // PseudoVREDAND_VS_M4_E64 + 0U, // PseudoVREDAND_VS_M4_E64_MASK + 0U, // PseudoVREDAND_VS_M4_E8 + 0U, // PseudoVREDAND_VS_M4_E8_MASK + 0U, // PseudoVREDAND_VS_M8_E16 + 0U, // PseudoVREDAND_VS_M8_E16_MASK + 0U, // PseudoVREDAND_VS_M8_E32 + 0U, // PseudoVREDAND_VS_M8_E32_MASK + 0U, // PseudoVREDAND_VS_M8_E64 + 0U, // PseudoVREDAND_VS_M8_E64_MASK + 0U, // PseudoVREDAND_VS_M8_E8 + 0U, // PseudoVREDAND_VS_M8_E8_MASK + 0U, // PseudoVREDAND_VS_MF2_E16 + 0U, // PseudoVREDAND_VS_MF2_E16_MASK + 0U, // PseudoVREDAND_VS_MF2_E32 + 0U, // PseudoVREDAND_VS_MF2_E32_MASK + 0U, // PseudoVREDAND_VS_MF2_E8 + 0U, // PseudoVREDAND_VS_MF2_E8_MASK + 0U, // PseudoVREDAND_VS_MF4_E16 + 0U, // PseudoVREDAND_VS_MF4_E16_MASK + 0U, // PseudoVREDAND_VS_MF4_E8 + 0U, // PseudoVREDAND_VS_MF4_E8_MASK + 0U, // PseudoVREDAND_VS_MF8_E8 + 0U, // PseudoVREDAND_VS_MF8_E8_MASK + 0U, // PseudoVREDMAXU_VS_M1_E16 + 0U, // PseudoVREDMAXU_VS_M1_E16_MASK + 0U, // PseudoVREDMAXU_VS_M1_E32 + 0U, // PseudoVREDMAXU_VS_M1_E32_MASK + 0U, // PseudoVREDMAXU_VS_M1_E64 + 0U, // PseudoVREDMAXU_VS_M1_E64_MASK + 0U, // PseudoVREDMAXU_VS_M1_E8 + 0U, // PseudoVREDMAXU_VS_M1_E8_MASK + 0U, // PseudoVREDMAXU_VS_M2_E16 + 0U, // PseudoVREDMAXU_VS_M2_E16_MASK + 0U, // PseudoVREDMAXU_VS_M2_E32 + 0U, // PseudoVREDMAXU_VS_M2_E32_MASK + 0U, // PseudoVREDMAXU_VS_M2_E64 + 0U, // PseudoVREDMAXU_VS_M2_E64_MASK + 0U, // PseudoVREDMAXU_VS_M2_E8 + 0U, // PseudoVREDMAXU_VS_M2_E8_MASK + 0U, // PseudoVREDMAXU_VS_M4_E16 + 0U, // PseudoVREDMAXU_VS_M4_E16_MASK + 0U, // PseudoVREDMAXU_VS_M4_E32 + 0U, // PseudoVREDMAXU_VS_M4_E32_MASK + 0U, // PseudoVREDMAXU_VS_M4_E64 + 0U, // PseudoVREDMAXU_VS_M4_E64_MASK + 0U, // PseudoVREDMAXU_VS_M4_E8 + 0U, // PseudoVREDMAXU_VS_M4_E8_MASK + 0U, // PseudoVREDMAXU_VS_M8_E16 + 0U, // PseudoVREDMAXU_VS_M8_E16_MASK + 0U, // PseudoVREDMAXU_VS_M8_E32 + 0U, // PseudoVREDMAXU_VS_M8_E32_MASK + 0U, // PseudoVREDMAXU_VS_M8_E64 + 0U, // PseudoVREDMAXU_VS_M8_E64_MASK + 0U, // PseudoVREDMAXU_VS_M8_E8 + 0U, // PseudoVREDMAXU_VS_M8_E8_MASK + 0U, // PseudoVREDMAXU_VS_MF2_E16 + 0U, // PseudoVREDMAXU_VS_MF2_E16_MASK + 0U, // PseudoVREDMAXU_VS_MF2_E32 + 0U, // PseudoVREDMAXU_VS_MF2_E32_MASK + 0U, // PseudoVREDMAXU_VS_MF2_E8 + 0U, // PseudoVREDMAXU_VS_MF2_E8_MASK + 0U, // PseudoVREDMAXU_VS_MF4_E16 + 0U, // PseudoVREDMAXU_VS_MF4_E16_MASK + 0U, // PseudoVREDMAXU_VS_MF4_E8 + 0U, // PseudoVREDMAXU_VS_MF4_E8_MASK + 0U, // PseudoVREDMAXU_VS_MF8_E8 + 0U, // PseudoVREDMAXU_VS_MF8_E8_MASK + 0U, // PseudoVREDMAX_VS_M1_E16 + 0U, // PseudoVREDMAX_VS_M1_E16_MASK + 0U, // PseudoVREDMAX_VS_M1_E32 + 0U, // PseudoVREDMAX_VS_M1_E32_MASK + 0U, // PseudoVREDMAX_VS_M1_E64 + 0U, // PseudoVREDMAX_VS_M1_E64_MASK + 0U, // PseudoVREDMAX_VS_M1_E8 + 0U, // PseudoVREDMAX_VS_M1_E8_MASK + 0U, // PseudoVREDMAX_VS_M2_E16 + 0U, // PseudoVREDMAX_VS_M2_E16_MASK + 0U, // PseudoVREDMAX_VS_M2_E32 + 0U, // PseudoVREDMAX_VS_M2_E32_MASK + 0U, // PseudoVREDMAX_VS_M2_E64 + 0U, // PseudoVREDMAX_VS_M2_E64_MASK + 0U, // PseudoVREDMAX_VS_M2_E8 + 0U, // PseudoVREDMAX_VS_M2_E8_MASK + 0U, // PseudoVREDMAX_VS_M4_E16 + 0U, // PseudoVREDMAX_VS_M4_E16_MASK + 0U, // PseudoVREDMAX_VS_M4_E32 + 0U, // PseudoVREDMAX_VS_M4_E32_MASK + 0U, // PseudoVREDMAX_VS_M4_E64 + 0U, // PseudoVREDMAX_VS_M4_E64_MASK + 0U, // PseudoVREDMAX_VS_M4_E8 + 0U, // PseudoVREDMAX_VS_M4_E8_MASK + 0U, // PseudoVREDMAX_VS_M8_E16 + 0U, // PseudoVREDMAX_VS_M8_E16_MASK + 0U, // PseudoVREDMAX_VS_M8_E32 + 0U, // PseudoVREDMAX_VS_M8_E32_MASK + 0U, // PseudoVREDMAX_VS_M8_E64 + 0U, // PseudoVREDMAX_VS_M8_E64_MASK + 0U, // PseudoVREDMAX_VS_M8_E8 + 0U, // PseudoVREDMAX_VS_M8_E8_MASK + 0U, // PseudoVREDMAX_VS_MF2_E16 + 0U, // PseudoVREDMAX_VS_MF2_E16_MASK + 0U, // PseudoVREDMAX_VS_MF2_E32 + 0U, // PseudoVREDMAX_VS_MF2_E32_MASK + 0U, // PseudoVREDMAX_VS_MF2_E8 + 0U, // PseudoVREDMAX_VS_MF2_E8_MASK + 0U, // PseudoVREDMAX_VS_MF4_E16 + 0U, // PseudoVREDMAX_VS_MF4_E16_MASK + 0U, // PseudoVREDMAX_VS_MF4_E8 + 0U, // PseudoVREDMAX_VS_MF4_E8_MASK + 0U, // PseudoVREDMAX_VS_MF8_E8 + 0U, // PseudoVREDMAX_VS_MF8_E8_MASK + 0U, // PseudoVREDMINU_VS_M1_E16 + 0U, // PseudoVREDMINU_VS_M1_E16_MASK + 0U, // PseudoVREDMINU_VS_M1_E32 + 0U, // PseudoVREDMINU_VS_M1_E32_MASK + 0U, // PseudoVREDMINU_VS_M1_E64 + 0U, // PseudoVREDMINU_VS_M1_E64_MASK + 0U, // PseudoVREDMINU_VS_M1_E8 + 0U, // PseudoVREDMINU_VS_M1_E8_MASK + 0U, // PseudoVREDMINU_VS_M2_E16 + 0U, // PseudoVREDMINU_VS_M2_E16_MASK + 0U, // PseudoVREDMINU_VS_M2_E32 + 0U, // PseudoVREDMINU_VS_M2_E32_MASK + 0U, // PseudoVREDMINU_VS_M2_E64 + 0U, // PseudoVREDMINU_VS_M2_E64_MASK + 0U, // PseudoVREDMINU_VS_M2_E8 + 0U, // PseudoVREDMINU_VS_M2_E8_MASK + 0U, // PseudoVREDMINU_VS_M4_E16 + 0U, // PseudoVREDMINU_VS_M4_E16_MASK + 0U, // PseudoVREDMINU_VS_M4_E32 + 0U, // PseudoVREDMINU_VS_M4_E32_MASK + 0U, // PseudoVREDMINU_VS_M4_E64 + 0U, // PseudoVREDMINU_VS_M4_E64_MASK + 0U, // PseudoVREDMINU_VS_M4_E8 + 0U, // PseudoVREDMINU_VS_M4_E8_MASK + 0U, // PseudoVREDMINU_VS_M8_E16 + 0U, // PseudoVREDMINU_VS_M8_E16_MASK + 0U, // PseudoVREDMINU_VS_M8_E32 + 0U, // PseudoVREDMINU_VS_M8_E32_MASK + 0U, // PseudoVREDMINU_VS_M8_E64 + 0U, // PseudoVREDMINU_VS_M8_E64_MASK + 0U, // PseudoVREDMINU_VS_M8_E8 + 0U, // PseudoVREDMINU_VS_M8_E8_MASK + 0U, // PseudoVREDMINU_VS_MF2_E16 + 0U, // PseudoVREDMINU_VS_MF2_E16_MASK + 0U, // PseudoVREDMINU_VS_MF2_E32 + 0U, // PseudoVREDMINU_VS_MF2_E32_MASK + 0U, // PseudoVREDMINU_VS_MF2_E8 + 0U, // PseudoVREDMINU_VS_MF2_E8_MASK + 0U, // PseudoVREDMINU_VS_MF4_E16 + 0U, // PseudoVREDMINU_VS_MF4_E16_MASK + 0U, // PseudoVREDMINU_VS_MF4_E8 + 0U, // PseudoVREDMINU_VS_MF4_E8_MASK + 0U, // PseudoVREDMINU_VS_MF8_E8 + 0U, // PseudoVREDMINU_VS_MF8_E8_MASK + 0U, // PseudoVREDMIN_VS_M1_E16 + 0U, // PseudoVREDMIN_VS_M1_E16_MASK + 0U, // PseudoVREDMIN_VS_M1_E32 + 0U, // PseudoVREDMIN_VS_M1_E32_MASK + 0U, // PseudoVREDMIN_VS_M1_E64 + 0U, // PseudoVREDMIN_VS_M1_E64_MASK + 0U, // PseudoVREDMIN_VS_M1_E8 + 0U, // PseudoVREDMIN_VS_M1_E8_MASK + 0U, // PseudoVREDMIN_VS_M2_E16 + 0U, // PseudoVREDMIN_VS_M2_E16_MASK + 0U, // PseudoVREDMIN_VS_M2_E32 + 0U, // PseudoVREDMIN_VS_M2_E32_MASK + 0U, // PseudoVREDMIN_VS_M2_E64 + 0U, // PseudoVREDMIN_VS_M2_E64_MASK + 0U, // PseudoVREDMIN_VS_M2_E8 + 0U, // PseudoVREDMIN_VS_M2_E8_MASK + 0U, // PseudoVREDMIN_VS_M4_E16 + 0U, // PseudoVREDMIN_VS_M4_E16_MASK + 0U, // PseudoVREDMIN_VS_M4_E32 + 0U, // PseudoVREDMIN_VS_M4_E32_MASK + 0U, // PseudoVREDMIN_VS_M4_E64 + 0U, // PseudoVREDMIN_VS_M4_E64_MASK + 0U, // PseudoVREDMIN_VS_M4_E8 + 0U, // PseudoVREDMIN_VS_M4_E8_MASK + 0U, // PseudoVREDMIN_VS_M8_E16 + 0U, // PseudoVREDMIN_VS_M8_E16_MASK + 0U, // PseudoVREDMIN_VS_M8_E32 + 0U, // PseudoVREDMIN_VS_M8_E32_MASK + 0U, // PseudoVREDMIN_VS_M8_E64 + 0U, // PseudoVREDMIN_VS_M8_E64_MASK + 0U, // PseudoVREDMIN_VS_M8_E8 + 0U, // PseudoVREDMIN_VS_M8_E8_MASK + 0U, // PseudoVREDMIN_VS_MF2_E16 + 0U, // PseudoVREDMIN_VS_MF2_E16_MASK + 0U, // PseudoVREDMIN_VS_MF2_E32 + 0U, // PseudoVREDMIN_VS_MF2_E32_MASK + 0U, // PseudoVREDMIN_VS_MF2_E8 + 0U, // PseudoVREDMIN_VS_MF2_E8_MASK + 0U, // PseudoVREDMIN_VS_MF4_E16 + 0U, // PseudoVREDMIN_VS_MF4_E16_MASK + 0U, // PseudoVREDMIN_VS_MF4_E8 + 0U, // PseudoVREDMIN_VS_MF4_E8_MASK + 0U, // PseudoVREDMIN_VS_MF8_E8 + 0U, // PseudoVREDMIN_VS_MF8_E8_MASK + 0U, // PseudoVREDOR_VS_M1_E16 + 0U, // PseudoVREDOR_VS_M1_E16_MASK + 0U, // PseudoVREDOR_VS_M1_E32 + 0U, // PseudoVREDOR_VS_M1_E32_MASK + 0U, // PseudoVREDOR_VS_M1_E64 + 0U, // PseudoVREDOR_VS_M1_E64_MASK + 0U, // PseudoVREDOR_VS_M1_E8 + 0U, // PseudoVREDOR_VS_M1_E8_MASK + 0U, // PseudoVREDOR_VS_M2_E16 + 0U, // PseudoVREDOR_VS_M2_E16_MASK + 0U, // PseudoVREDOR_VS_M2_E32 + 0U, // PseudoVREDOR_VS_M2_E32_MASK + 0U, // PseudoVREDOR_VS_M2_E64 + 0U, // PseudoVREDOR_VS_M2_E64_MASK + 0U, // PseudoVREDOR_VS_M2_E8 + 0U, // PseudoVREDOR_VS_M2_E8_MASK + 0U, // PseudoVREDOR_VS_M4_E16 + 0U, // PseudoVREDOR_VS_M4_E16_MASK + 0U, // PseudoVREDOR_VS_M4_E32 + 0U, // PseudoVREDOR_VS_M4_E32_MASK + 0U, // PseudoVREDOR_VS_M4_E64 + 0U, // PseudoVREDOR_VS_M4_E64_MASK + 0U, // PseudoVREDOR_VS_M4_E8 + 0U, // PseudoVREDOR_VS_M4_E8_MASK + 0U, // PseudoVREDOR_VS_M8_E16 + 0U, // PseudoVREDOR_VS_M8_E16_MASK + 0U, // PseudoVREDOR_VS_M8_E32 + 0U, // PseudoVREDOR_VS_M8_E32_MASK + 0U, // PseudoVREDOR_VS_M8_E64 + 0U, // PseudoVREDOR_VS_M8_E64_MASK + 0U, // PseudoVREDOR_VS_M8_E8 + 0U, // PseudoVREDOR_VS_M8_E8_MASK + 0U, // PseudoVREDOR_VS_MF2_E16 + 0U, // PseudoVREDOR_VS_MF2_E16_MASK + 0U, // PseudoVREDOR_VS_MF2_E32 + 0U, // PseudoVREDOR_VS_MF2_E32_MASK + 0U, // PseudoVREDOR_VS_MF2_E8 + 0U, // PseudoVREDOR_VS_MF2_E8_MASK + 0U, // PseudoVREDOR_VS_MF4_E16 + 0U, // PseudoVREDOR_VS_MF4_E16_MASK + 0U, // PseudoVREDOR_VS_MF4_E8 + 0U, // PseudoVREDOR_VS_MF4_E8_MASK + 0U, // PseudoVREDOR_VS_MF8_E8 + 0U, // PseudoVREDOR_VS_MF8_E8_MASK + 0U, // PseudoVREDSUM_VS_M1_E16 + 0U, // PseudoVREDSUM_VS_M1_E16_MASK + 0U, // PseudoVREDSUM_VS_M1_E32 + 0U, // PseudoVREDSUM_VS_M1_E32_MASK + 0U, // PseudoVREDSUM_VS_M1_E64 + 0U, // PseudoVREDSUM_VS_M1_E64_MASK + 0U, // PseudoVREDSUM_VS_M1_E8 + 0U, // PseudoVREDSUM_VS_M1_E8_MASK + 0U, // PseudoVREDSUM_VS_M2_E16 + 0U, // PseudoVREDSUM_VS_M2_E16_MASK + 0U, // PseudoVREDSUM_VS_M2_E32 + 0U, // PseudoVREDSUM_VS_M2_E32_MASK + 0U, // PseudoVREDSUM_VS_M2_E64 + 0U, // PseudoVREDSUM_VS_M2_E64_MASK + 0U, // PseudoVREDSUM_VS_M2_E8 + 0U, // PseudoVREDSUM_VS_M2_E8_MASK + 0U, // PseudoVREDSUM_VS_M4_E16 + 0U, // PseudoVREDSUM_VS_M4_E16_MASK + 0U, // PseudoVREDSUM_VS_M4_E32 + 0U, // PseudoVREDSUM_VS_M4_E32_MASK + 0U, // PseudoVREDSUM_VS_M4_E64 + 0U, // PseudoVREDSUM_VS_M4_E64_MASK + 0U, // PseudoVREDSUM_VS_M4_E8 + 0U, // PseudoVREDSUM_VS_M4_E8_MASK + 0U, // PseudoVREDSUM_VS_M8_E16 + 0U, // PseudoVREDSUM_VS_M8_E16_MASK + 0U, // PseudoVREDSUM_VS_M8_E32 + 0U, // PseudoVREDSUM_VS_M8_E32_MASK + 0U, // PseudoVREDSUM_VS_M8_E64 + 0U, // PseudoVREDSUM_VS_M8_E64_MASK + 0U, // PseudoVREDSUM_VS_M8_E8 + 0U, // PseudoVREDSUM_VS_M8_E8_MASK + 0U, // PseudoVREDSUM_VS_MF2_E16 + 0U, // PseudoVREDSUM_VS_MF2_E16_MASK + 0U, // PseudoVREDSUM_VS_MF2_E32 + 0U, // PseudoVREDSUM_VS_MF2_E32_MASK + 0U, // PseudoVREDSUM_VS_MF2_E8 + 0U, // PseudoVREDSUM_VS_MF2_E8_MASK + 0U, // PseudoVREDSUM_VS_MF4_E16 + 0U, // PseudoVREDSUM_VS_MF4_E16_MASK + 0U, // PseudoVREDSUM_VS_MF4_E8 + 0U, // PseudoVREDSUM_VS_MF4_E8_MASK + 0U, // PseudoVREDSUM_VS_MF8_E8 + 0U, // PseudoVREDSUM_VS_MF8_E8_MASK + 0U, // PseudoVREDXOR_VS_M1_E16 + 0U, // PseudoVREDXOR_VS_M1_E16_MASK + 0U, // PseudoVREDXOR_VS_M1_E32 + 0U, // PseudoVREDXOR_VS_M1_E32_MASK + 0U, // PseudoVREDXOR_VS_M1_E64 + 0U, // PseudoVREDXOR_VS_M1_E64_MASK + 0U, // PseudoVREDXOR_VS_M1_E8 + 0U, // PseudoVREDXOR_VS_M1_E8_MASK + 0U, // PseudoVREDXOR_VS_M2_E16 + 0U, // PseudoVREDXOR_VS_M2_E16_MASK + 0U, // PseudoVREDXOR_VS_M2_E32 + 0U, // PseudoVREDXOR_VS_M2_E32_MASK + 0U, // PseudoVREDXOR_VS_M2_E64 + 0U, // PseudoVREDXOR_VS_M2_E64_MASK + 0U, // PseudoVREDXOR_VS_M2_E8 + 0U, // PseudoVREDXOR_VS_M2_E8_MASK + 0U, // PseudoVREDXOR_VS_M4_E16 + 0U, // PseudoVREDXOR_VS_M4_E16_MASK + 0U, // PseudoVREDXOR_VS_M4_E32 + 0U, // PseudoVREDXOR_VS_M4_E32_MASK + 0U, // PseudoVREDXOR_VS_M4_E64 + 0U, // PseudoVREDXOR_VS_M4_E64_MASK + 0U, // PseudoVREDXOR_VS_M4_E8 + 0U, // PseudoVREDXOR_VS_M4_E8_MASK + 0U, // PseudoVREDXOR_VS_M8_E16 + 0U, // PseudoVREDXOR_VS_M8_E16_MASK + 0U, // PseudoVREDXOR_VS_M8_E32 + 0U, // PseudoVREDXOR_VS_M8_E32_MASK + 0U, // PseudoVREDXOR_VS_M8_E64 + 0U, // PseudoVREDXOR_VS_M8_E64_MASK + 0U, // PseudoVREDXOR_VS_M8_E8 + 0U, // PseudoVREDXOR_VS_M8_E8_MASK + 0U, // PseudoVREDXOR_VS_MF2_E16 + 0U, // PseudoVREDXOR_VS_MF2_E16_MASK + 0U, // PseudoVREDXOR_VS_MF2_E32 + 0U, // PseudoVREDXOR_VS_MF2_E32_MASK + 0U, // PseudoVREDXOR_VS_MF2_E8 + 0U, // PseudoVREDXOR_VS_MF2_E8_MASK + 0U, // PseudoVREDXOR_VS_MF4_E16 + 0U, // PseudoVREDXOR_VS_MF4_E16_MASK + 0U, // PseudoVREDXOR_VS_MF4_E8 + 0U, // PseudoVREDXOR_VS_MF4_E8_MASK + 0U, // PseudoVREDXOR_VS_MF8_E8 + 0U, // PseudoVREDXOR_VS_MF8_E8_MASK + 0U, // PseudoVRELOAD2_M1 + 0U, // PseudoVRELOAD2_M2 + 0U, // PseudoVRELOAD2_M4 + 0U, // PseudoVRELOAD2_MF2 + 0U, // PseudoVRELOAD2_MF4 + 0U, // PseudoVRELOAD2_MF8 + 0U, // PseudoVRELOAD3_M1 + 0U, // PseudoVRELOAD3_M2 + 0U, // PseudoVRELOAD3_MF2 + 0U, // PseudoVRELOAD3_MF4 + 0U, // PseudoVRELOAD3_MF8 + 0U, // PseudoVRELOAD4_M1 + 0U, // PseudoVRELOAD4_M2 + 0U, // PseudoVRELOAD4_MF2 + 0U, // PseudoVRELOAD4_MF4 + 0U, // PseudoVRELOAD4_MF8 + 0U, // PseudoVRELOAD5_M1 + 0U, // PseudoVRELOAD5_MF2 + 0U, // PseudoVRELOAD5_MF4 + 0U, // PseudoVRELOAD5_MF8 + 0U, // PseudoVRELOAD6_M1 + 0U, // PseudoVRELOAD6_MF2 + 0U, // PseudoVRELOAD6_MF4 + 0U, // PseudoVRELOAD6_MF8 + 0U, // PseudoVRELOAD7_M1 + 0U, // PseudoVRELOAD7_MF2 + 0U, // PseudoVRELOAD7_MF4 + 0U, // PseudoVRELOAD7_MF8 + 0U, // PseudoVRELOAD8_M1 + 0U, // PseudoVRELOAD8_MF2 + 0U, // PseudoVRELOAD8_MF4 + 0U, // PseudoVRELOAD8_MF8 + 0U, // PseudoVREMU_VV_M1_E16 + 0U, // PseudoVREMU_VV_M1_E16_MASK + 0U, // PseudoVREMU_VV_M1_E32 + 0U, // PseudoVREMU_VV_M1_E32_MASK + 0U, // PseudoVREMU_VV_M1_E64 + 0U, // PseudoVREMU_VV_M1_E64_MASK + 0U, // PseudoVREMU_VV_M1_E8 + 0U, // PseudoVREMU_VV_M1_E8_MASK + 0U, // PseudoVREMU_VV_M2_E16 + 0U, // PseudoVREMU_VV_M2_E16_MASK + 0U, // PseudoVREMU_VV_M2_E32 + 0U, // PseudoVREMU_VV_M2_E32_MASK + 0U, // PseudoVREMU_VV_M2_E64 + 0U, // PseudoVREMU_VV_M2_E64_MASK + 0U, // PseudoVREMU_VV_M2_E8 + 0U, // PseudoVREMU_VV_M2_E8_MASK + 0U, // PseudoVREMU_VV_M4_E16 + 0U, // PseudoVREMU_VV_M4_E16_MASK + 0U, // PseudoVREMU_VV_M4_E32 + 0U, // PseudoVREMU_VV_M4_E32_MASK + 0U, // PseudoVREMU_VV_M4_E64 + 0U, // PseudoVREMU_VV_M4_E64_MASK + 0U, // PseudoVREMU_VV_M4_E8 + 0U, // PseudoVREMU_VV_M4_E8_MASK + 0U, // PseudoVREMU_VV_M8_E16 + 0U, // PseudoVREMU_VV_M8_E16_MASK + 0U, // PseudoVREMU_VV_M8_E32 + 0U, // PseudoVREMU_VV_M8_E32_MASK + 0U, // PseudoVREMU_VV_M8_E64 + 0U, // PseudoVREMU_VV_M8_E64_MASK + 0U, // PseudoVREMU_VV_M8_E8 + 0U, // PseudoVREMU_VV_M8_E8_MASK + 0U, // PseudoVREMU_VV_MF2_E16 + 0U, // PseudoVREMU_VV_MF2_E16_MASK + 0U, // PseudoVREMU_VV_MF2_E32 + 0U, // PseudoVREMU_VV_MF2_E32_MASK + 0U, // PseudoVREMU_VV_MF2_E8 + 0U, // PseudoVREMU_VV_MF2_E8_MASK + 0U, // PseudoVREMU_VV_MF4_E16 + 0U, // PseudoVREMU_VV_MF4_E16_MASK + 0U, // PseudoVREMU_VV_MF4_E8 + 0U, // PseudoVREMU_VV_MF4_E8_MASK + 0U, // PseudoVREMU_VV_MF8_E8 + 0U, // PseudoVREMU_VV_MF8_E8_MASK + 0U, // PseudoVREMU_VX_M1_E16 + 0U, // PseudoVREMU_VX_M1_E16_MASK + 0U, // PseudoVREMU_VX_M1_E32 + 0U, // PseudoVREMU_VX_M1_E32_MASK + 0U, // PseudoVREMU_VX_M1_E64 + 0U, // PseudoVREMU_VX_M1_E64_MASK + 0U, // PseudoVREMU_VX_M1_E8 + 0U, // PseudoVREMU_VX_M1_E8_MASK + 0U, // PseudoVREMU_VX_M2_E16 + 0U, // PseudoVREMU_VX_M2_E16_MASK + 0U, // PseudoVREMU_VX_M2_E32 + 0U, // PseudoVREMU_VX_M2_E32_MASK + 0U, // PseudoVREMU_VX_M2_E64 + 0U, // PseudoVREMU_VX_M2_E64_MASK + 0U, // PseudoVREMU_VX_M2_E8 + 0U, // PseudoVREMU_VX_M2_E8_MASK + 0U, // PseudoVREMU_VX_M4_E16 + 0U, // PseudoVREMU_VX_M4_E16_MASK + 0U, // PseudoVREMU_VX_M4_E32 + 0U, // PseudoVREMU_VX_M4_E32_MASK + 0U, // PseudoVREMU_VX_M4_E64 + 0U, // PseudoVREMU_VX_M4_E64_MASK + 0U, // PseudoVREMU_VX_M4_E8 + 0U, // PseudoVREMU_VX_M4_E8_MASK + 0U, // PseudoVREMU_VX_M8_E16 + 0U, // PseudoVREMU_VX_M8_E16_MASK + 0U, // PseudoVREMU_VX_M8_E32 + 0U, // PseudoVREMU_VX_M8_E32_MASK + 0U, // PseudoVREMU_VX_M8_E64 + 0U, // PseudoVREMU_VX_M8_E64_MASK + 0U, // PseudoVREMU_VX_M8_E8 + 0U, // PseudoVREMU_VX_M8_E8_MASK + 0U, // PseudoVREMU_VX_MF2_E16 + 0U, // PseudoVREMU_VX_MF2_E16_MASK + 0U, // PseudoVREMU_VX_MF2_E32 + 0U, // PseudoVREMU_VX_MF2_E32_MASK + 0U, // PseudoVREMU_VX_MF2_E8 + 0U, // PseudoVREMU_VX_MF2_E8_MASK + 0U, // PseudoVREMU_VX_MF4_E16 + 0U, // PseudoVREMU_VX_MF4_E16_MASK + 0U, // PseudoVREMU_VX_MF4_E8 + 0U, // PseudoVREMU_VX_MF4_E8_MASK + 0U, // PseudoVREMU_VX_MF8_E8 + 0U, // PseudoVREMU_VX_MF8_E8_MASK + 0U, // PseudoVREM_VV_M1_E16 + 0U, // PseudoVREM_VV_M1_E16_MASK + 0U, // PseudoVREM_VV_M1_E32 + 0U, // PseudoVREM_VV_M1_E32_MASK + 0U, // PseudoVREM_VV_M1_E64 + 0U, // PseudoVREM_VV_M1_E64_MASK + 0U, // PseudoVREM_VV_M1_E8 + 0U, // PseudoVREM_VV_M1_E8_MASK + 0U, // PseudoVREM_VV_M2_E16 + 0U, // PseudoVREM_VV_M2_E16_MASK + 0U, // PseudoVREM_VV_M2_E32 + 0U, // PseudoVREM_VV_M2_E32_MASK + 0U, // PseudoVREM_VV_M2_E64 + 0U, // PseudoVREM_VV_M2_E64_MASK + 0U, // PseudoVREM_VV_M2_E8 + 0U, // PseudoVREM_VV_M2_E8_MASK + 0U, // PseudoVREM_VV_M4_E16 + 0U, // PseudoVREM_VV_M4_E16_MASK + 0U, // PseudoVREM_VV_M4_E32 + 0U, // PseudoVREM_VV_M4_E32_MASK + 0U, // PseudoVREM_VV_M4_E64 + 0U, // PseudoVREM_VV_M4_E64_MASK + 0U, // PseudoVREM_VV_M4_E8 + 0U, // PseudoVREM_VV_M4_E8_MASK + 0U, // PseudoVREM_VV_M8_E16 + 0U, // PseudoVREM_VV_M8_E16_MASK + 0U, // PseudoVREM_VV_M8_E32 + 0U, // PseudoVREM_VV_M8_E32_MASK + 0U, // PseudoVREM_VV_M8_E64 + 0U, // PseudoVREM_VV_M8_E64_MASK + 0U, // PseudoVREM_VV_M8_E8 + 0U, // PseudoVREM_VV_M8_E8_MASK + 0U, // PseudoVREM_VV_MF2_E16 + 0U, // PseudoVREM_VV_MF2_E16_MASK + 0U, // PseudoVREM_VV_MF2_E32 + 0U, // PseudoVREM_VV_MF2_E32_MASK + 0U, // PseudoVREM_VV_MF2_E8 + 0U, // PseudoVREM_VV_MF2_E8_MASK + 0U, // PseudoVREM_VV_MF4_E16 + 0U, // PseudoVREM_VV_MF4_E16_MASK + 0U, // PseudoVREM_VV_MF4_E8 + 0U, // PseudoVREM_VV_MF4_E8_MASK + 0U, // PseudoVREM_VV_MF8_E8 + 0U, // PseudoVREM_VV_MF8_E8_MASK + 0U, // PseudoVREM_VX_M1_E16 + 0U, // PseudoVREM_VX_M1_E16_MASK + 0U, // PseudoVREM_VX_M1_E32 + 0U, // PseudoVREM_VX_M1_E32_MASK + 0U, // PseudoVREM_VX_M1_E64 + 0U, // PseudoVREM_VX_M1_E64_MASK + 0U, // PseudoVREM_VX_M1_E8 + 0U, // PseudoVREM_VX_M1_E8_MASK + 0U, // PseudoVREM_VX_M2_E16 + 0U, // PseudoVREM_VX_M2_E16_MASK + 0U, // PseudoVREM_VX_M2_E32 + 0U, // PseudoVREM_VX_M2_E32_MASK + 0U, // PseudoVREM_VX_M2_E64 + 0U, // PseudoVREM_VX_M2_E64_MASK + 0U, // PseudoVREM_VX_M2_E8 + 0U, // PseudoVREM_VX_M2_E8_MASK + 0U, // PseudoVREM_VX_M4_E16 + 0U, // PseudoVREM_VX_M4_E16_MASK + 0U, // PseudoVREM_VX_M4_E32 + 0U, // PseudoVREM_VX_M4_E32_MASK + 0U, // PseudoVREM_VX_M4_E64 + 0U, // PseudoVREM_VX_M4_E64_MASK + 0U, // PseudoVREM_VX_M4_E8 + 0U, // PseudoVREM_VX_M4_E8_MASK + 0U, // PseudoVREM_VX_M8_E16 + 0U, // PseudoVREM_VX_M8_E16_MASK + 0U, // PseudoVREM_VX_M8_E32 + 0U, // PseudoVREM_VX_M8_E32_MASK + 0U, // PseudoVREM_VX_M8_E64 + 0U, // PseudoVREM_VX_M8_E64_MASK + 0U, // PseudoVREM_VX_M8_E8 + 0U, // PseudoVREM_VX_M8_E8_MASK + 0U, // PseudoVREM_VX_MF2_E16 + 0U, // PseudoVREM_VX_MF2_E16_MASK + 0U, // PseudoVREM_VX_MF2_E32 + 0U, // PseudoVREM_VX_MF2_E32_MASK + 0U, // PseudoVREM_VX_MF2_E8 + 0U, // PseudoVREM_VX_MF2_E8_MASK + 0U, // PseudoVREM_VX_MF4_E16 + 0U, // PseudoVREM_VX_MF4_E16_MASK + 0U, // PseudoVREM_VX_MF4_E8 + 0U, // PseudoVREM_VX_MF4_E8_MASK + 0U, // PseudoVREM_VX_MF8_E8 + 0U, // PseudoVREM_VX_MF8_E8_MASK + 0U, // PseudoVREV8_V_M1 + 0U, // PseudoVREV8_V_M1_MASK + 0U, // PseudoVREV8_V_M2 + 0U, // PseudoVREV8_V_M2_MASK + 0U, // PseudoVREV8_V_M4 + 0U, // PseudoVREV8_V_M4_MASK + 0U, // PseudoVREV8_V_M8 + 0U, // PseudoVREV8_V_M8_MASK + 0U, // PseudoVREV8_V_MF2 + 0U, // PseudoVREV8_V_MF2_MASK + 0U, // PseudoVREV8_V_MF4 + 0U, // PseudoVREV8_V_MF4_MASK + 0U, // PseudoVREV8_V_MF8 + 0U, // PseudoVREV8_V_MF8_MASK + 0U, // PseudoVRGATHEREI16_VV_M1_E16_M1 + 0U, // PseudoVRGATHEREI16_VV_M1_E16_M1_MASK + 0U, // PseudoVRGATHEREI16_VV_M1_E16_M2 + 0U, // PseudoVRGATHEREI16_VV_M1_E16_M2_MASK + 0U, // PseudoVRGATHEREI16_VV_M1_E16_MF2 + 0U, // PseudoVRGATHEREI16_VV_M1_E16_MF2_MASK + 0U, // PseudoVRGATHEREI16_VV_M1_E16_MF4 + 0U, // PseudoVRGATHEREI16_VV_M1_E16_MF4_MASK + 0U, // PseudoVRGATHEREI16_VV_M1_E32_M1 + 0U, // PseudoVRGATHEREI16_VV_M1_E32_M1_MASK + 0U, // PseudoVRGATHEREI16_VV_M1_E32_M2 + 0U, // PseudoVRGATHEREI16_VV_M1_E32_M2_MASK + 0U, // PseudoVRGATHEREI16_VV_M1_E32_MF2 + 0U, // PseudoVRGATHEREI16_VV_M1_E32_MF2_MASK + 0U, // PseudoVRGATHEREI16_VV_M1_E32_MF4 + 0U, // PseudoVRGATHEREI16_VV_M1_E32_MF4_MASK + 0U, // PseudoVRGATHEREI16_VV_M1_E64_M1 + 0U, // PseudoVRGATHEREI16_VV_M1_E64_M1_MASK + 0U, // PseudoVRGATHEREI16_VV_M1_E64_M2 + 0U, // PseudoVRGATHEREI16_VV_M1_E64_M2_MASK + 0U, // PseudoVRGATHEREI16_VV_M1_E64_MF2 + 0U, // PseudoVRGATHEREI16_VV_M1_E64_MF2_MASK + 0U, // PseudoVRGATHEREI16_VV_M1_E64_MF4 + 0U, // PseudoVRGATHEREI16_VV_M1_E64_MF4_MASK + 0U, // PseudoVRGATHEREI16_VV_M1_E8_M1 + 0U, // PseudoVRGATHEREI16_VV_M1_E8_M1_MASK + 0U, // PseudoVRGATHEREI16_VV_M1_E8_M2 + 0U, // PseudoVRGATHEREI16_VV_M1_E8_M2_MASK + 0U, // PseudoVRGATHEREI16_VV_M1_E8_MF2 + 0U, // PseudoVRGATHEREI16_VV_M1_E8_MF2_MASK + 0U, // PseudoVRGATHEREI16_VV_M1_E8_MF4 + 0U, // PseudoVRGATHEREI16_VV_M1_E8_MF4_MASK + 0U, // PseudoVRGATHEREI16_VV_M2_E16_M1 + 0U, // PseudoVRGATHEREI16_VV_M2_E16_M1_MASK + 0U, // PseudoVRGATHEREI16_VV_M2_E16_M2 + 0U, // PseudoVRGATHEREI16_VV_M2_E16_M2_MASK + 0U, // PseudoVRGATHEREI16_VV_M2_E16_M4 + 0U, // PseudoVRGATHEREI16_VV_M2_E16_M4_MASK + 0U, // PseudoVRGATHEREI16_VV_M2_E16_MF2 + 0U, // PseudoVRGATHEREI16_VV_M2_E16_MF2_MASK + 0U, // PseudoVRGATHEREI16_VV_M2_E32_M1 + 0U, // PseudoVRGATHEREI16_VV_M2_E32_M1_MASK + 0U, // PseudoVRGATHEREI16_VV_M2_E32_M2 + 0U, // PseudoVRGATHEREI16_VV_M2_E32_M2_MASK + 0U, // PseudoVRGATHEREI16_VV_M2_E32_M4 + 0U, // PseudoVRGATHEREI16_VV_M2_E32_M4_MASK + 0U, // PseudoVRGATHEREI16_VV_M2_E32_MF2 + 0U, // PseudoVRGATHEREI16_VV_M2_E32_MF2_MASK + 0U, // PseudoVRGATHEREI16_VV_M2_E64_M1 + 0U, // PseudoVRGATHEREI16_VV_M2_E64_M1_MASK + 0U, // PseudoVRGATHEREI16_VV_M2_E64_M2 + 0U, // PseudoVRGATHEREI16_VV_M2_E64_M2_MASK + 0U, // PseudoVRGATHEREI16_VV_M2_E64_M4 + 0U, // PseudoVRGATHEREI16_VV_M2_E64_M4_MASK + 0U, // PseudoVRGATHEREI16_VV_M2_E64_MF2 + 0U, // PseudoVRGATHEREI16_VV_M2_E64_MF2_MASK + 0U, // PseudoVRGATHEREI16_VV_M2_E8_M1 + 0U, // PseudoVRGATHEREI16_VV_M2_E8_M1_MASK + 0U, // PseudoVRGATHEREI16_VV_M2_E8_M2 + 0U, // PseudoVRGATHEREI16_VV_M2_E8_M2_MASK + 0U, // PseudoVRGATHEREI16_VV_M2_E8_M4 + 0U, // PseudoVRGATHEREI16_VV_M2_E8_M4_MASK + 0U, // PseudoVRGATHEREI16_VV_M2_E8_MF2 + 0U, // PseudoVRGATHEREI16_VV_M2_E8_MF2_MASK + 0U, // PseudoVRGATHEREI16_VV_M4_E16_M1 + 0U, // PseudoVRGATHEREI16_VV_M4_E16_M1_MASK + 0U, // PseudoVRGATHEREI16_VV_M4_E16_M2 + 0U, // PseudoVRGATHEREI16_VV_M4_E16_M2_MASK + 0U, // PseudoVRGATHEREI16_VV_M4_E16_M4 + 0U, // PseudoVRGATHEREI16_VV_M4_E16_M4_MASK + 0U, // PseudoVRGATHEREI16_VV_M4_E16_M8 + 0U, // PseudoVRGATHEREI16_VV_M4_E16_M8_MASK + 0U, // PseudoVRGATHEREI16_VV_M4_E32_M1 + 0U, // PseudoVRGATHEREI16_VV_M4_E32_M1_MASK + 0U, // PseudoVRGATHEREI16_VV_M4_E32_M2 + 0U, // PseudoVRGATHEREI16_VV_M4_E32_M2_MASK + 0U, // PseudoVRGATHEREI16_VV_M4_E32_M4 + 0U, // PseudoVRGATHEREI16_VV_M4_E32_M4_MASK + 0U, // PseudoVRGATHEREI16_VV_M4_E32_M8 + 0U, // PseudoVRGATHEREI16_VV_M4_E32_M8_MASK + 0U, // PseudoVRGATHEREI16_VV_M4_E64_M1 + 0U, // PseudoVRGATHEREI16_VV_M4_E64_M1_MASK + 0U, // PseudoVRGATHEREI16_VV_M4_E64_M2 + 0U, // PseudoVRGATHEREI16_VV_M4_E64_M2_MASK + 0U, // PseudoVRGATHEREI16_VV_M4_E64_M4 + 0U, // PseudoVRGATHEREI16_VV_M4_E64_M4_MASK + 0U, // PseudoVRGATHEREI16_VV_M4_E64_M8 + 0U, // PseudoVRGATHEREI16_VV_M4_E64_M8_MASK + 0U, // PseudoVRGATHEREI16_VV_M4_E8_M1 + 0U, // PseudoVRGATHEREI16_VV_M4_E8_M1_MASK + 0U, // PseudoVRGATHEREI16_VV_M4_E8_M2 + 0U, // PseudoVRGATHEREI16_VV_M4_E8_M2_MASK + 0U, // PseudoVRGATHEREI16_VV_M4_E8_M4 + 0U, // PseudoVRGATHEREI16_VV_M4_E8_M4_MASK + 0U, // PseudoVRGATHEREI16_VV_M4_E8_M8 + 0U, // PseudoVRGATHEREI16_VV_M4_E8_M8_MASK + 0U, // PseudoVRGATHEREI16_VV_M8_E16_M2 + 0U, // PseudoVRGATHEREI16_VV_M8_E16_M2_MASK + 0U, // PseudoVRGATHEREI16_VV_M8_E16_M4 + 0U, // PseudoVRGATHEREI16_VV_M8_E16_M4_MASK + 0U, // PseudoVRGATHEREI16_VV_M8_E16_M8 + 0U, // PseudoVRGATHEREI16_VV_M8_E16_M8_MASK + 0U, // PseudoVRGATHEREI16_VV_M8_E32_M2 + 0U, // PseudoVRGATHEREI16_VV_M8_E32_M2_MASK + 0U, // PseudoVRGATHEREI16_VV_M8_E32_M4 + 0U, // PseudoVRGATHEREI16_VV_M8_E32_M4_MASK + 0U, // PseudoVRGATHEREI16_VV_M8_E32_M8 + 0U, // PseudoVRGATHEREI16_VV_M8_E32_M8_MASK + 0U, // PseudoVRGATHEREI16_VV_M8_E64_M2 + 0U, // PseudoVRGATHEREI16_VV_M8_E64_M2_MASK + 0U, // PseudoVRGATHEREI16_VV_M8_E64_M4 + 0U, // PseudoVRGATHEREI16_VV_M8_E64_M4_MASK + 0U, // PseudoVRGATHEREI16_VV_M8_E64_M8 + 0U, // PseudoVRGATHEREI16_VV_M8_E64_M8_MASK + 0U, // PseudoVRGATHEREI16_VV_M8_E8_M2 + 0U, // PseudoVRGATHEREI16_VV_M8_E8_M2_MASK + 0U, // PseudoVRGATHEREI16_VV_M8_E8_M4 + 0U, // PseudoVRGATHEREI16_VV_M8_E8_M4_MASK + 0U, // PseudoVRGATHEREI16_VV_M8_E8_M8 + 0U, // PseudoVRGATHEREI16_VV_M8_E8_M8_MASK + 0U, // PseudoVRGATHEREI16_VV_MF2_E16_M1 + 0U, // PseudoVRGATHEREI16_VV_MF2_E16_M1_MASK + 0U, // PseudoVRGATHEREI16_VV_MF2_E16_MF2 + 0U, // PseudoVRGATHEREI16_VV_MF2_E16_MF2_MASK + 0U, // PseudoVRGATHEREI16_VV_MF2_E16_MF4 + 0U, // PseudoVRGATHEREI16_VV_MF2_E16_MF4_MASK + 0U, // PseudoVRGATHEREI16_VV_MF2_E16_MF8 + 0U, // PseudoVRGATHEREI16_VV_MF2_E16_MF8_MASK + 0U, // PseudoVRGATHEREI16_VV_MF2_E32_M1 + 0U, // PseudoVRGATHEREI16_VV_MF2_E32_M1_MASK + 0U, // PseudoVRGATHEREI16_VV_MF2_E32_MF2 + 0U, // PseudoVRGATHEREI16_VV_MF2_E32_MF2_MASK + 0U, // PseudoVRGATHEREI16_VV_MF2_E32_MF4 + 0U, // PseudoVRGATHEREI16_VV_MF2_E32_MF4_MASK + 0U, // PseudoVRGATHEREI16_VV_MF2_E32_MF8 + 0U, // PseudoVRGATHEREI16_VV_MF2_E32_MF8_MASK + 0U, // PseudoVRGATHEREI16_VV_MF2_E8_M1 + 0U, // PseudoVRGATHEREI16_VV_MF2_E8_M1_MASK + 0U, // PseudoVRGATHEREI16_VV_MF2_E8_MF2 + 0U, // PseudoVRGATHEREI16_VV_MF2_E8_MF2_MASK + 0U, // PseudoVRGATHEREI16_VV_MF2_E8_MF4 + 0U, // PseudoVRGATHEREI16_VV_MF2_E8_MF4_MASK + 0U, // PseudoVRGATHEREI16_VV_MF2_E8_MF8 + 0U, // PseudoVRGATHEREI16_VV_MF2_E8_MF8_MASK + 0U, // PseudoVRGATHEREI16_VV_MF4_E16_MF2 + 0U, // PseudoVRGATHEREI16_VV_MF4_E16_MF2_MASK + 0U, // PseudoVRGATHEREI16_VV_MF4_E16_MF4 + 0U, // PseudoVRGATHEREI16_VV_MF4_E16_MF4_MASK + 0U, // PseudoVRGATHEREI16_VV_MF4_E16_MF8 + 0U, // PseudoVRGATHEREI16_VV_MF4_E16_MF8_MASK + 0U, // PseudoVRGATHEREI16_VV_MF4_E8_MF2 + 0U, // PseudoVRGATHEREI16_VV_MF4_E8_MF2_MASK + 0U, // PseudoVRGATHEREI16_VV_MF4_E8_MF4 + 0U, // PseudoVRGATHEREI16_VV_MF4_E8_MF4_MASK + 0U, // PseudoVRGATHEREI16_VV_MF4_E8_MF8 + 0U, // PseudoVRGATHEREI16_VV_MF4_E8_MF8_MASK + 0U, // PseudoVRGATHEREI16_VV_MF8_E8_MF4 + 0U, // PseudoVRGATHEREI16_VV_MF8_E8_MF4_MASK + 0U, // PseudoVRGATHEREI16_VV_MF8_E8_MF8 + 0U, // PseudoVRGATHEREI16_VV_MF8_E8_MF8_MASK + 0U, // PseudoVRGATHER_VI_M1 + 0U, // PseudoVRGATHER_VI_M1_MASK + 0U, // PseudoVRGATHER_VI_M2 + 0U, // PseudoVRGATHER_VI_M2_MASK + 0U, // PseudoVRGATHER_VI_M4 + 0U, // PseudoVRGATHER_VI_M4_MASK + 0U, // PseudoVRGATHER_VI_M8 + 0U, // PseudoVRGATHER_VI_M8_MASK + 0U, // PseudoVRGATHER_VI_MF2 + 0U, // PseudoVRGATHER_VI_MF2_MASK + 0U, // PseudoVRGATHER_VI_MF4 + 0U, // PseudoVRGATHER_VI_MF4_MASK + 0U, // PseudoVRGATHER_VI_MF8 + 0U, // PseudoVRGATHER_VI_MF8_MASK + 0U, // PseudoVRGATHER_VV_M1_E16 + 0U, // PseudoVRGATHER_VV_M1_E16_MASK + 0U, // PseudoVRGATHER_VV_M1_E32 + 0U, // PseudoVRGATHER_VV_M1_E32_MASK + 0U, // PseudoVRGATHER_VV_M1_E64 + 0U, // PseudoVRGATHER_VV_M1_E64_MASK + 0U, // PseudoVRGATHER_VV_M1_E8 + 0U, // PseudoVRGATHER_VV_M1_E8_MASK + 0U, // PseudoVRGATHER_VV_M2_E16 + 0U, // PseudoVRGATHER_VV_M2_E16_MASK + 0U, // PseudoVRGATHER_VV_M2_E32 + 0U, // PseudoVRGATHER_VV_M2_E32_MASK + 0U, // PseudoVRGATHER_VV_M2_E64 + 0U, // PseudoVRGATHER_VV_M2_E64_MASK + 0U, // PseudoVRGATHER_VV_M2_E8 + 0U, // PseudoVRGATHER_VV_M2_E8_MASK + 0U, // PseudoVRGATHER_VV_M4_E16 + 0U, // PseudoVRGATHER_VV_M4_E16_MASK + 0U, // PseudoVRGATHER_VV_M4_E32 + 0U, // PseudoVRGATHER_VV_M4_E32_MASK + 0U, // PseudoVRGATHER_VV_M4_E64 + 0U, // PseudoVRGATHER_VV_M4_E64_MASK + 0U, // PseudoVRGATHER_VV_M4_E8 + 0U, // PseudoVRGATHER_VV_M4_E8_MASK + 0U, // PseudoVRGATHER_VV_M8_E16 + 0U, // PseudoVRGATHER_VV_M8_E16_MASK + 0U, // PseudoVRGATHER_VV_M8_E32 + 0U, // PseudoVRGATHER_VV_M8_E32_MASK + 0U, // PseudoVRGATHER_VV_M8_E64 + 0U, // PseudoVRGATHER_VV_M8_E64_MASK + 0U, // PseudoVRGATHER_VV_M8_E8 + 0U, // PseudoVRGATHER_VV_M8_E8_MASK + 0U, // PseudoVRGATHER_VV_MF2_E16 + 0U, // PseudoVRGATHER_VV_MF2_E16_MASK + 0U, // PseudoVRGATHER_VV_MF2_E32 + 0U, // PseudoVRGATHER_VV_MF2_E32_MASK + 0U, // PseudoVRGATHER_VV_MF2_E8 + 0U, // PseudoVRGATHER_VV_MF2_E8_MASK + 0U, // PseudoVRGATHER_VV_MF4_E16 + 0U, // PseudoVRGATHER_VV_MF4_E16_MASK + 0U, // PseudoVRGATHER_VV_MF4_E8 + 0U, // PseudoVRGATHER_VV_MF4_E8_MASK + 0U, // PseudoVRGATHER_VV_MF8_E8 + 0U, // PseudoVRGATHER_VV_MF8_E8_MASK + 0U, // PseudoVRGATHER_VX_M1 + 0U, // PseudoVRGATHER_VX_M1_MASK + 0U, // PseudoVRGATHER_VX_M2 + 0U, // PseudoVRGATHER_VX_M2_MASK + 0U, // PseudoVRGATHER_VX_M4 + 0U, // PseudoVRGATHER_VX_M4_MASK + 0U, // PseudoVRGATHER_VX_M8 + 0U, // PseudoVRGATHER_VX_M8_MASK + 0U, // PseudoVRGATHER_VX_MF2 + 0U, // PseudoVRGATHER_VX_MF2_MASK + 0U, // PseudoVRGATHER_VX_MF4 + 0U, // PseudoVRGATHER_VX_MF4_MASK + 0U, // PseudoVRGATHER_VX_MF8 + 0U, // PseudoVRGATHER_VX_MF8_MASK + 0U, // PseudoVROL_VV_M1 + 0U, // PseudoVROL_VV_M1_MASK + 0U, // PseudoVROL_VV_M2 + 0U, // PseudoVROL_VV_M2_MASK + 0U, // PseudoVROL_VV_M4 + 0U, // PseudoVROL_VV_M4_MASK + 0U, // PseudoVROL_VV_M8 + 0U, // PseudoVROL_VV_M8_MASK + 0U, // PseudoVROL_VV_MF2 + 0U, // PseudoVROL_VV_MF2_MASK + 0U, // PseudoVROL_VV_MF4 + 0U, // PseudoVROL_VV_MF4_MASK + 0U, // PseudoVROL_VV_MF8 + 0U, // PseudoVROL_VV_MF8_MASK + 0U, // PseudoVROL_VX_M1 + 0U, // PseudoVROL_VX_M1_MASK + 0U, // PseudoVROL_VX_M2 + 0U, // PseudoVROL_VX_M2_MASK + 0U, // PseudoVROL_VX_M4 + 0U, // PseudoVROL_VX_M4_MASK + 0U, // PseudoVROL_VX_M8 + 0U, // PseudoVROL_VX_M8_MASK + 0U, // PseudoVROL_VX_MF2 + 0U, // PseudoVROL_VX_MF2_MASK + 0U, // PseudoVROL_VX_MF4 + 0U, // PseudoVROL_VX_MF4_MASK + 0U, // PseudoVROL_VX_MF8 + 0U, // PseudoVROL_VX_MF8_MASK + 0U, // PseudoVROR_VI_M1 + 0U, // PseudoVROR_VI_M1_MASK + 0U, // PseudoVROR_VI_M2 + 0U, // PseudoVROR_VI_M2_MASK + 0U, // PseudoVROR_VI_M4 + 0U, // PseudoVROR_VI_M4_MASK + 0U, // PseudoVROR_VI_M8 + 0U, // PseudoVROR_VI_M8_MASK + 0U, // PseudoVROR_VI_MF2 + 0U, // PseudoVROR_VI_MF2_MASK + 0U, // PseudoVROR_VI_MF4 + 0U, // PseudoVROR_VI_MF4_MASK + 0U, // PseudoVROR_VI_MF8 + 0U, // PseudoVROR_VI_MF8_MASK + 0U, // PseudoVROR_VV_M1 + 0U, // PseudoVROR_VV_M1_MASK + 0U, // PseudoVROR_VV_M2 + 0U, // PseudoVROR_VV_M2_MASK + 0U, // PseudoVROR_VV_M4 + 0U, // PseudoVROR_VV_M4_MASK + 0U, // PseudoVROR_VV_M8 + 0U, // PseudoVROR_VV_M8_MASK + 0U, // PseudoVROR_VV_MF2 + 0U, // PseudoVROR_VV_MF2_MASK + 0U, // PseudoVROR_VV_MF4 + 0U, // PseudoVROR_VV_MF4_MASK + 0U, // PseudoVROR_VV_MF8 + 0U, // PseudoVROR_VV_MF8_MASK + 0U, // PseudoVROR_VX_M1 + 0U, // PseudoVROR_VX_M1_MASK + 0U, // PseudoVROR_VX_M2 + 0U, // PseudoVROR_VX_M2_MASK + 0U, // PseudoVROR_VX_M4 + 0U, // PseudoVROR_VX_M4_MASK + 0U, // PseudoVROR_VX_M8 + 0U, // PseudoVROR_VX_M8_MASK + 0U, // PseudoVROR_VX_MF2 + 0U, // PseudoVROR_VX_MF2_MASK + 0U, // PseudoVROR_VX_MF4 + 0U, // PseudoVROR_VX_MF4_MASK + 0U, // PseudoVROR_VX_MF8 + 0U, // PseudoVROR_VX_MF8_MASK + 0U, // PseudoVRSUB_VI_M1 + 0U, // PseudoVRSUB_VI_M1_MASK + 0U, // PseudoVRSUB_VI_M2 + 0U, // PseudoVRSUB_VI_M2_MASK + 0U, // PseudoVRSUB_VI_M4 + 0U, // PseudoVRSUB_VI_M4_MASK + 0U, // PseudoVRSUB_VI_M8 + 0U, // PseudoVRSUB_VI_M8_MASK + 0U, // PseudoVRSUB_VI_MF2 + 0U, // PseudoVRSUB_VI_MF2_MASK + 0U, // PseudoVRSUB_VI_MF4 + 0U, // PseudoVRSUB_VI_MF4_MASK + 0U, // PseudoVRSUB_VI_MF8 + 0U, // PseudoVRSUB_VI_MF8_MASK + 0U, // PseudoVRSUB_VX_M1 + 0U, // PseudoVRSUB_VX_M1_MASK + 0U, // PseudoVRSUB_VX_M2 + 0U, // PseudoVRSUB_VX_M2_MASK + 0U, // PseudoVRSUB_VX_M4 + 0U, // PseudoVRSUB_VX_M4_MASK + 0U, // PseudoVRSUB_VX_M8 + 0U, // PseudoVRSUB_VX_M8_MASK + 0U, // PseudoVRSUB_VX_MF2 + 0U, // PseudoVRSUB_VX_MF2_MASK + 0U, // PseudoVRSUB_VX_MF4 + 0U, // PseudoVRSUB_VX_MF4_MASK + 0U, // PseudoVRSUB_VX_MF8 + 0U, // PseudoVRSUB_VX_MF8_MASK + 0U, // PseudoVSADDU_VI_M1 + 0U, // PseudoVSADDU_VI_M1_MASK + 0U, // PseudoVSADDU_VI_M2 + 0U, // PseudoVSADDU_VI_M2_MASK + 0U, // PseudoVSADDU_VI_M4 + 0U, // PseudoVSADDU_VI_M4_MASK + 0U, // PseudoVSADDU_VI_M8 + 0U, // PseudoVSADDU_VI_M8_MASK + 0U, // PseudoVSADDU_VI_MF2 + 0U, // PseudoVSADDU_VI_MF2_MASK + 0U, // PseudoVSADDU_VI_MF4 + 0U, // PseudoVSADDU_VI_MF4_MASK + 0U, // PseudoVSADDU_VI_MF8 + 0U, // PseudoVSADDU_VI_MF8_MASK + 0U, // PseudoVSADDU_VV_M1 + 0U, // PseudoVSADDU_VV_M1_MASK + 0U, // PseudoVSADDU_VV_M2 + 0U, // PseudoVSADDU_VV_M2_MASK + 0U, // PseudoVSADDU_VV_M4 + 0U, // PseudoVSADDU_VV_M4_MASK + 0U, // PseudoVSADDU_VV_M8 + 0U, // PseudoVSADDU_VV_M8_MASK + 0U, // PseudoVSADDU_VV_MF2 + 0U, // PseudoVSADDU_VV_MF2_MASK + 0U, // PseudoVSADDU_VV_MF4 + 0U, // PseudoVSADDU_VV_MF4_MASK + 0U, // PseudoVSADDU_VV_MF8 + 0U, // PseudoVSADDU_VV_MF8_MASK + 0U, // PseudoVSADDU_VX_M1 + 0U, // PseudoVSADDU_VX_M1_MASK + 0U, // PseudoVSADDU_VX_M2 + 0U, // PseudoVSADDU_VX_M2_MASK + 0U, // PseudoVSADDU_VX_M4 + 0U, // PseudoVSADDU_VX_M4_MASK + 0U, // PseudoVSADDU_VX_M8 + 0U, // PseudoVSADDU_VX_M8_MASK + 0U, // PseudoVSADDU_VX_MF2 + 0U, // PseudoVSADDU_VX_MF2_MASK + 0U, // PseudoVSADDU_VX_MF4 + 0U, // PseudoVSADDU_VX_MF4_MASK + 0U, // PseudoVSADDU_VX_MF8 + 0U, // PseudoVSADDU_VX_MF8_MASK + 0U, // PseudoVSADD_VI_M1 + 0U, // PseudoVSADD_VI_M1_MASK + 0U, // PseudoVSADD_VI_M2 + 0U, // PseudoVSADD_VI_M2_MASK + 0U, // PseudoVSADD_VI_M4 + 0U, // PseudoVSADD_VI_M4_MASK + 0U, // PseudoVSADD_VI_M8 + 0U, // PseudoVSADD_VI_M8_MASK + 0U, // PseudoVSADD_VI_MF2 + 0U, // PseudoVSADD_VI_MF2_MASK + 0U, // PseudoVSADD_VI_MF4 + 0U, // PseudoVSADD_VI_MF4_MASK + 0U, // PseudoVSADD_VI_MF8 + 0U, // PseudoVSADD_VI_MF8_MASK + 0U, // PseudoVSADD_VV_M1 + 0U, // PseudoVSADD_VV_M1_MASK + 0U, // PseudoVSADD_VV_M2 + 0U, // PseudoVSADD_VV_M2_MASK + 0U, // PseudoVSADD_VV_M4 + 0U, // PseudoVSADD_VV_M4_MASK + 0U, // PseudoVSADD_VV_M8 + 0U, // PseudoVSADD_VV_M8_MASK + 0U, // PseudoVSADD_VV_MF2 + 0U, // PseudoVSADD_VV_MF2_MASK + 0U, // PseudoVSADD_VV_MF4 + 0U, // PseudoVSADD_VV_MF4_MASK + 0U, // PseudoVSADD_VV_MF8 + 0U, // PseudoVSADD_VV_MF8_MASK + 0U, // PseudoVSADD_VX_M1 + 0U, // PseudoVSADD_VX_M1_MASK + 0U, // PseudoVSADD_VX_M2 + 0U, // PseudoVSADD_VX_M2_MASK + 0U, // PseudoVSADD_VX_M4 + 0U, // PseudoVSADD_VX_M4_MASK + 0U, // PseudoVSADD_VX_M8 + 0U, // PseudoVSADD_VX_M8_MASK + 0U, // PseudoVSADD_VX_MF2 + 0U, // PseudoVSADD_VX_MF2_MASK + 0U, // PseudoVSADD_VX_MF4 + 0U, // PseudoVSADD_VX_MF4_MASK + 0U, // PseudoVSADD_VX_MF8 + 0U, // PseudoVSADD_VX_MF8_MASK + 0U, // PseudoVSBC_VVM_M1 + 0U, // PseudoVSBC_VVM_M2 + 0U, // PseudoVSBC_VVM_M4 + 0U, // PseudoVSBC_VVM_M8 + 0U, // PseudoVSBC_VVM_MF2 + 0U, // PseudoVSBC_VVM_MF4 + 0U, // PseudoVSBC_VVM_MF8 + 0U, // PseudoVSBC_VXM_M1 + 0U, // PseudoVSBC_VXM_M2 + 0U, // PseudoVSBC_VXM_M4 + 0U, // PseudoVSBC_VXM_M8 + 0U, // PseudoVSBC_VXM_MF2 + 0U, // PseudoVSBC_VXM_MF4 + 0U, // PseudoVSBC_VXM_MF8 + 0U, // PseudoVSE16_V_M1 + 0U, // PseudoVSE16_V_M1_MASK + 0U, // PseudoVSE16_V_M2 + 0U, // PseudoVSE16_V_M2_MASK + 0U, // PseudoVSE16_V_M4 + 0U, // PseudoVSE16_V_M4_MASK + 0U, // PseudoVSE16_V_M8 + 0U, // PseudoVSE16_V_M8_MASK + 0U, // PseudoVSE16_V_MF2 + 0U, // PseudoVSE16_V_MF2_MASK + 0U, // PseudoVSE16_V_MF4 + 0U, // PseudoVSE16_V_MF4_MASK + 0U, // PseudoVSE32_V_M1 + 0U, // PseudoVSE32_V_M1_MASK + 0U, // PseudoVSE32_V_M2 + 0U, // PseudoVSE32_V_M2_MASK + 0U, // PseudoVSE32_V_M4 + 0U, // PseudoVSE32_V_M4_MASK + 0U, // PseudoVSE32_V_M8 + 0U, // PseudoVSE32_V_M8_MASK + 0U, // PseudoVSE32_V_MF2 + 0U, // PseudoVSE32_V_MF2_MASK + 0U, // PseudoVSE64_V_M1 + 0U, // PseudoVSE64_V_M1_MASK + 0U, // PseudoVSE64_V_M2 + 0U, // PseudoVSE64_V_M2_MASK + 0U, // PseudoVSE64_V_M4 + 0U, // PseudoVSE64_V_M4_MASK + 0U, // PseudoVSE64_V_M8 + 0U, // PseudoVSE64_V_M8_MASK + 0U, // PseudoVSE8_V_M1 + 0U, // PseudoVSE8_V_M1_MASK + 0U, // PseudoVSE8_V_M2 + 0U, // PseudoVSE8_V_M2_MASK + 0U, // PseudoVSE8_V_M4 + 0U, // PseudoVSE8_V_M4_MASK + 0U, // PseudoVSE8_V_M8 + 0U, // PseudoVSE8_V_M8_MASK + 0U, // PseudoVSE8_V_MF2 + 0U, // PseudoVSE8_V_MF2_MASK + 0U, // PseudoVSE8_V_MF4 + 0U, // PseudoVSE8_V_MF4_MASK + 0U, // PseudoVSE8_V_MF8 + 0U, // PseudoVSE8_V_MF8_MASK + 0U, // PseudoVSETIVLI + 0U, // PseudoVSETVLI + 0U, // PseudoVSETVLIX0 + 0U, // PseudoVSEXT_VF2_M1 + 0U, // PseudoVSEXT_VF2_M1_MASK + 0U, // PseudoVSEXT_VF2_M2 + 0U, // PseudoVSEXT_VF2_M2_MASK + 0U, // PseudoVSEXT_VF2_M4 + 0U, // PseudoVSEXT_VF2_M4_MASK + 0U, // PseudoVSEXT_VF2_M8 + 0U, // PseudoVSEXT_VF2_M8_MASK + 0U, // PseudoVSEXT_VF2_MF2 + 0U, // PseudoVSEXT_VF2_MF2_MASK + 0U, // PseudoVSEXT_VF2_MF4 + 0U, // PseudoVSEXT_VF2_MF4_MASK + 0U, // PseudoVSEXT_VF4_M1 + 0U, // PseudoVSEXT_VF4_M1_MASK + 0U, // PseudoVSEXT_VF4_M2 + 0U, // PseudoVSEXT_VF4_M2_MASK + 0U, // PseudoVSEXT_VF4_M4 + 0U, // PseudoVSEXT_VF4_M4_MASK + 0U, // PseudoVSEXT_VF4_M8 + 0U, // PseudoVSEXT_VF4_M8_MASK + 0U, // PseudoVSEXT_VF4_MF2 + 0U, // PseudoVSEXT_VF4_MF2_MASK + 0U, // PseudoVSEXT_VF8_M1 + 0U, // PseudoVSEXT_VF8_M1_MASK + 0U, // PseudoVSEXT_VF8_M2 + 0U, // PseudoVSEXT_VF8_M2_MASK + 0U, // PseudoVSEXT_VF8_M4 + 0U, // PseudoVSEXT_VF8_M4_MASK + 0U, // PseudoVSEXT_VF8_M8 + 0U, // PseudoVSEXT_VF8_M8_MASK + 0U, // PseudoVSHA2CH_VV_M1 + 0U, // PseudoVSHA2CH_VV_M2 + 0U, // PseudoVSHA2CH_VV_M4 + 0U, // PseudoVSHA2CH_VV_M8 + 0U, // PseudoVSHA2CH_VV_MF2 + 0U, // PseudoVSHA2CL_VV_M1 + 0U, // PseudoVSHA2CL_VV_M2 + 0U, // PseudoVSHA2CL_VV_M4 + 0U, // PseudoVSHA2CL_VV_M8 + 0U, // PseudoVSHA2CL_VV_MF2 + 0U, // PseudoVSHA2MS_VV_M1 + 0U, // PseudoVSHA2MS_VV_M2 + 0U, // PseudoVSHA2MS_VV_M4 + 0U, // PseudoVSHA2MS_VV_M8 + 0U, // PseudoVSHA2MS_VV_MF2 + 0U, // PseudoVSLIDE1DOWN_VX_M1 + 0U, // PseudoVSLIDE1DOWN_VX_M1_MASK + 0U, // PseudoVSLIDE1DOWN_VX_M2 + 0U, // PseudoVSLIDE1DOWN_VX_M2_MASK + 0U, // PseudoVSLIDE1DOWN_VX_M4 + 0U, // PseudoVSLIDE1DOWN_VX_M4_MASK + 0U, // PseudoVSLIDE1DOWN_VX_M8 + 0U, // PseudoVSLIDE1DOWN_VX_M8_MASK + 0U, // PseudoVSLIDE1DOWN_VX_MF2 + 0U, // PseudoVSLIDE1DOWN_VX_MF2_MASK + 0U, // PseudoVSLIDE1DOWN_VX_MF4 + 0U, // PseudoVSLIDE1DOWN_VX_MF4_MASK + 0U, // PseudoVSLIDE1DOWN_VX_MF8 + 0U, // PseudoVSLIDE1DOWN_VX_MF8_MASK + 0U, // PseudoVSLIDE1UP_VX_M1 + 0U, // PseudoVSLIDE1UP_VX_M1_MASK + 0U, // PseudoVSLIDE1UP_VX_M2 + 0U, // PseudoVSLIDE1UP_VX_M2_MASK + 0U, // PseudoVSLIDE1UP_VX_M4 + 0U, // PseudoVSLIDE1UP_VX_M4_MASK + 0U, // PseudoVSLIDE1UP_VX_M8 + 0U, // PseudoVSLIDE1UP_VX_M8_MASK + 0U, // PseudoVSLIDE1UP_VX_MF2 + 0U, // PseudoVSLIDE1UP_VX_MF2_MASK + 0U, // PseudoVSLIDE1UP_VX_MF4 + 0U, // PseudoVSLIDE1UP_VX_MF4_MASK + 0U, // PseudoVSLIDE1UP_VX_MF8 + 0U, // PseudoVSLIDE1UP_VX_MF8_MASK + 0U, // PseudoVSLIDEDOWN_VI_M1 + 0U, // PseudoVSLIDEDOWN_VI_M1_MASK + 0U, // PseudoVSLIDEDOWN_VI_M2 + 0U, // PseudoVSLIDEDOWN_VI_M2_MASK + 0U, // PseudoVSLIDEDOWN_VI_M4 + 0U, // PseudoVSLIDEDOWN_VI_M4_MASK + 0U, // PseudoVSLIDEDOWN_VI_M8 + 0U, // PseudoVSLIDEDOWN_VI_M8_MASK + 0U, // PseudoVSLIDEDOWN_VI_MF2 + 0U, // PseudoVSLIDEDOWN_VI_MF2_MASK + 0U, // PseudoVSLIDEDOWN_VI_MF4 + 0U, // PseudoVSLIDEDOWN_VI_MF4_MASK + 0U, // PseudoVSLIDEDOWN_VI_MF8 + 0U, // PseudoVSLIDEDOWN_VI_MF8_MASK + 0U, // PseudoVSLIDEDOWN_VX_M1 + 0U, // PseudoVSLIDEDOWN_VX_M1_MASK + 0U, // PseudoVSLIDEDOWN_VX_M2 + 0U, // PseudoVSLIDEDOWN_VX_M2_MASK + 0U, // PseudoVSLIDEDOWN_VX_M4 + 0U, // PseudoVSLIDEDOWN_VX_M4_MASK + 0U, // PseudoVSLIDEDOWN_VX_M8 + 0U, // PseudoVSLIDEDOWN_VX_M8_MASK + 0U, // PseudoVSLIDEDOWN_VX_MF2 + 0U, // PseudoVSLIDEDOWN_VX_MF2_MASK + 0U, // PseudoVSLIDEDOWN_VX_MF4 + 0U, // PseudoVSLIDEDOWN_VX_MF4_MASK + 0U, // PseudoVSLIDEDOWN_VX_MF8 + 0U, // PseudoVSLIDEDOWN_VX_MF8_MASK + 0U, // PseudoVSLIDEUP_VI_M1 + 0U, // PseudoVSLIDEUP_VI_M1_MASK + 0U, // PseudoVSLIDEUP_VI_M2 + 0U, // PseudoVSLIDEUP_VI_M2_MASK + 0U, // PseudoVSLIDEUP_VI_M4 + 0U, // PseudoVSLIDEUP_VI_M4_MASK + 0U, // PseudoVSLIDEUP_VI_M8 + 0U, // PseudoVSLIDEUP_VI_M8_MASK + 0U, // PseudoVSLIDEUP_VI_MF2 + 0U, // PseudoVSLIDEUP_VI_MF2_MASK + 0U, // PseudoVSLIDEUP_VI_MF4 + 0U, // PseudoVSLIDEUP_VI_MF4_MASK + 0U, // PseudoVSLIDEUP_VI_MF8 + 0U, // PseudoVSLIDEUP_VI_MF8_MASK + 0U, // PseudoVSLIDEUP_VX_M1 + 0U, // PseudoVSLIDEUP_VX_M1_MASK + 0U, // PseudoVSLIDEUP_VX_M2 + 0U, // PseudoVSLIDEUP_VX_M2_MASK + 0U, // PseudoVSLIDEUP_VX_M4 + 0U, // PseudoVSLIDEUP_VX_M4_MASK + 0U, // PseudoVSLIDEUP_VX_M8 + 0U, // PseudoVSLIDEUP_VX_M8_MASK + 0U, // PseudoVSLIDEUP_VX_MF2 + 0U, // PseudoVSLIDEUP_VX_MF2_MASK + 0U, // PseudoVSLIDEUP_VX_MF4 + 0U, // PseudoVSLIDEUP_VX_MF4_MASK + 0U, // PseudoVSLIDEUP_VX_MF8 + 0U, // PseudoVSLIDEUP_VX_MF8_MASK + 0U, // PseudoVSLL_VI_M1 + 0U, // PseudoVSLL_VI_M1_MASK + 0U, // PseudoVSLL_VI_M2 + 0U, // PseudoVSLL_VI_M2_MASK + 0U, // PseudoVSLL_VI_M4 + 0U, // PseudoVSLL_VI_M4_MASK + 0U, // PseudoVSLL_VI_M8 + 0U, // PseudoVSLL_VI_M8_MASK + 0U, // PseudoVSLL_VI_MF2 + 0U, // PseudoVSLL_VI_MF2_MASK + 0U, // PseudoVSLL_VI_MF4 + 0U, // PseudoVSLL_VI_MF4_MASK + 0U, // PseudoVSLL_VI_MF8 + 0U, // PseudoVSLL_VI_MF8_MASK + 0U, // PseudoVSLL_VV_M1 + 0U, // PseudoVSLL_VV_M1_MASK + 0U, // PseudoVSLL_VV_M2 + 0U, // PseudoVSLL_VV_M2_MASK + 0U, // PseudoVSLL_VV_M4 + 0U, // PseudoVSLL_VV_M4_MASK + 0U, // PseudoVSLL_VV_M8 + 0U, // PseudoVSLL_VV_M8_MASK + 0U, // PseudoVSLL_VV_MF2 + 0U, // PseudoVSLL_VV_MF2_MASK + 0U, // PseudoVSLL_VV_MF4 + 0U, // PseudoVSLL_VV_MF4_MASK + 0U, // PseudoVSLL_VV_MF8 + 0U, // PseudoVSLL_VV_MF8_MASK + 0U, // PseudoVSLL_VX_M1 + 0U, // PseudoVSLL_VX_M1_MASK + 0U, // PseudoVSLL_VX_M2 + 0U, // PseudoVSLL_VX_M2_MASK + 0U, // PseudoVSLL_VX_M4 + 0U, // PseudoVSLL_VX_M4_MASK + 0U, // PseudoVSLL_VX_M8 + 0U, // PseudoVSLL_VX_M8_MASK + 0U, // PseudoVSLL_VX_MF2 + 0U, // PseudoVSLL_VX_MF2_MASK + 0U, // PseudoVSLL_VX_MF4 + 0U, // PseudoVSLL_VX_MF4_MASK + 0U, // PseudoVSLL_VX_MF8 + 0U, // PseudoVSLL_VX_MF8_MASK + 0U, // PseudoVSM3C_VI_M1 + 0U, // PseudoVSM3C_VI_M2 + 0U, // PseudoVSM3C_VI_M4 + 0U, // PseudoVSM3C_VI_M8 + 0U, // PseudoVSM3C_VI_MF2 + 0U, // PseudoVSM3ME_VV_M1 + 0U, // PseudoVSM3ME_VV_M2 + 0U, // PseudoVSM3ME_VV_M4 + 0U, // PseudoVSM3ME_VV_M8 + 0U, // PseudoVSM3ME_VV_MF2 + 0U, // PseudoVSM4K_VI_M1 + 0U, // PseudoVSM4K_VI_M2 + 0U, // PseudoVSM4K_VI_M4 + 0U, // PseudoVSM4K_VI_M8 + 0U, // PseudoVSM4K_VI_MF2 + 0U, // PseudoVSM4R_VS_M1_M1 + 0U, // PseudoVSM4R_VS_M1_MF2 + 0U, // PseudoVSM4R_VS_M1_MF4 + 0U, // PseudoVSM4R_VS_M1_MF8 + 0U, // PseudoVSM4R_VS_M2_M1 + 0U, // PseudoVSM4R_VS_M2_M2 + 0U, // PseudoVSM4R_VS_M2_MF2 + 0U, // PseudoVSM4R_VS_M2_MF4 + 0U, // PseudoVSM4R_VS_M2_MF8 + 0U, // PseudoVSM4R_VS_M4_M1 + 0U, // PseudoVSM4R_VS_M4_M2 + 0U, // PseudoVSM4R_VS_M4_M4 + 0U, // PseudoVSM4R_VS_M4_MF2 + 0U, // PseudoVSM4R_VS_M4_MF4 + 0U, // PseudoVSM4R_VS_M4_MF8 + 0U, // PseudoVSM4R_VS_M8_M1 + 0U, // PseudoVSM4R_VS_M8_M2 + 0U, // PseudoVSM4R_VS_M8_M4 + 0U, // PseudoVSM4R_VS_M8_MF2 + 0U, // PseudoVSM4R_VS_M8_MF4 + 0U, // PseudoVSM4R_VS_M8_MF8 + 0U, // PseudoVSM4R_VS_MF2_MF2 + 0U, // PseudoVSM4R_VS_MF2_MF4 + 0U, // PseudoVSM4R_VS_MF2_MF8 + 0U, // PseudoVSM4R_VV_M1 + 0U, // PseudoVSM4R_VV_M2 + 0U, // PseudoVSM4R_VV_M4 + 0U, // PseudoVSM4R_VV_M8 + 0U, // PseudoVSM4R_VV_MF2 + 0U, // PseudoVSMUL_VV_M1 + 0U, // PseudoVSMUL_VV_M1_MASK + 0U, // PseudoVSMUL_VV_M2 + 0U, // PseudoVSMUL_VV_M2_MASK + 0U, // PseudoVSMUL_VV_M4 + 0U, // PseudoVSMUL_VV_M4_MASK + 0U, // PseudoVSMUL_VV_M8 + 0U, // PseudoVSMUL_VV_M8_MASK + 0U, // PseudoVSMUL_VV_MF2 + 0U, // PseudoVSMUL_VV_MF2_MASK + 0U, // PseudoVSMUL_VV_MF4 + 0U, // PseudoVSMUL_VV_MF4_MASK + 0U, // PseudoVSMUL_VV_MF8 + 0U, // PseudoVSMUL_VV_MF8_MASK + 0U, // PseudoVSMUL_VX_M1 + 0U, // PseudoVSMUL_VX_M1_MASK + 0U, // PseudoVSMUL_VX_M2 + 0U, // PseudoVSMUL_VX_M2_MASK + 0U, // PseudoVSMUL_VX_M4 + 0U, // PseudoVSMUL_VX_M4_MASK + 0U, // PseudoVSMUL_VX_M8 + 0U, // PseudoVSMUL_VX_M8_MASK + 0U, // PseudoVSMUL_VX_MF2 + 0U, // PseudoVSMUL_VX_MF2_MASK + 0U, // PseudoVSMUL_VX_MF4 + 0U, // PseudoVSMUL_VX_MF4_MASK + 0U, // PseudoVSMUL_VX_MF8 + 0U, // PseudoVSMUL_VX_MF8_MASK + 0U, // PseudoVSM_V_B1 + 0U, // PseudoVSM_V_B16 + 0U, // PseudoVSM_V_B2 + 0U, // PseudoVSM_V_B32 + 0U, // PseudoVSM_V_B4 + 0U, // PseudoVSM_V_B64 + 0U, // PseudoVSM_V_B8 + 0U, // PseudoVSOXEI16_V_M1_M1 + 0U, // PseudoVSOXEI16_V_M1_M1_MASK + 0U, // PseudoVSOXEI16_V_M1_M2 + 0U, // PseudoVSOXEI16_V_M1_M2_MASK + 0U, // PseudoVSOXEI16_V_M1_M4 + 0U, // PseudoVSOXEI16_V_M1_M4_MASK + 0U, // PseudoVSOXEI16_V_M1_MF2 + 0U, // PseudoVSOXEI16_V_M1_MF2_MASK + 0U, // PseudoVSOXEI16_V_M2_M1 + 0U, // PseudoVSOXEI16_V_M2_M1_MASK + 0U, // PseudoVSOXEI16_V_M2_M2 + 0U, // PseudoVSOXEI16_V_M2_M2_MASK + 0U, // PseudoVSOXEI16_V_M2_M4 + 0U, // PseudoVSOXEI16_V_M2_M4_MASK + 0U, // PseudoVSOXEI16_V_M2_M8 + 0U, // PseudoVSOXEI16_V_M2_M8_MASK + 0U, // PseudoVSOXEI16_V_M4_M2 + 0U, // PseudoVSOXEI16_V_M4_M2_MASK + 0U, // PseudoVSOXEI16_V_M4_M4 + 0U, // PseudoVSOXEI16_V_M4_M4_MASK + 0U, // PseudoVSOXEI16_V_M4_M8 + 0U, // PseudoVSOXEI16_V_M4_M8_MASK + 0U, // PseudoVSOXEI16_V_M8_M4 + 0U, // PseudoVSOXEI16_V_M8_M4_MASK + 0U, // PseudoVSOXEI16_V_M8_M8 + 0U, // PseudoVSOXEI16_V_M8_M8_MASK + 0U, // PseudoVSOXEI16_V_MF2_M1 + 0U, // PseudoVSOXEI16_V_MF2_M1_MASK + 0U, // PseudoVSOXEI16_V_MF2_M2 + 0U, // PseudoVSOXEI16_V_MF2_M2_MASK + 0U, // PseudoVSOXEI16_V_MF2_MF2 + 0U, // PseudoVSOXEI16_V_MF2_MF2_MASK + 0U, // PseudoVSOXEI16_V_MF2_MF4 + 0U, // PseudoVSOXEI16_V_MF2_MF4_MASK + 0U, // PseudoVSOXEI16_V_MF4_M1 + 0U, // PseudoVSOXEI16_V_MF4_M1_MASK + 0U, // PseudoVSOXEI16_V_MF4_MF2 + 0U, // PseudoVSOXEI16_V_MF4_MF2_MASK + 0U, // PseudoVSOXEI16_V_MF4_MF4 + 0U, // PseudoVSOXEI16_V_MF4_MF4_MASK + 0U, // PseudoVSOXEI16_V_MF4_MF8 + 0U, // PseudoVSOXEI16_V_MF4_MF8_MASK + 0U, // PseudoVSOXEI32_V_M1_M1 + 0U, // PseudoVSOXEI32_V_M1_M1_MASK + 0U, // PseudoVSOXEI32_V_M1_M2 + 0U, // PseudoVSOXEI32_V_M1_M2_MASK + 0U, // PseudoVSOXEI32_V_M1_MF2 + 0U, // PseudoVSOXEI32_V_M1_MF2_MASK + 0U, // PseudoVSOXEI32_V_M1_MF4 + 0U, // PseudoVSOXEI32_V_M1_MF4_MASK + 0U, // PseudoVSOXEI32_V_M2_M1 + 0U, // PseudoVSOXEI32_V_M2_M1_MASK + 0U, // PseudoVSOXEI32_V_M2_M2 + 0U, // PseudoVSOXEI32_V_M2_M2_MASK + 0U, // PseudoVSOXEI32_V_M2_M4 + 0U, // PseudoVSOXEI32_V_M2_M4_MASK + 0U, // PseudoVSOXEI32_V_M2_MF2 + 0U, // PseudoVSOXEI32_V_M2_MF2_MASK + 0U, // PseudoVSOXEI32_V_M4_M1 + 0U, // PseudoVSOXEI32_V_M4_M1_MASK + 0U, // PseudoVSOXEI32_V_M4_M2 + 0U, // PseudoVSOXEI32_V_M4_M2_MASK + 0U, // PseudoVSOXEI32_V_M4_M4 + 0U, // PseudoVSOXEI32_V_M4_M4_MASK + 0U, // PseudoVSOXEI32_V_M4_M8 + 0U, // PseudoVSOXEI32_V_M4_M8_MASK + 0U, // PseudoVSOXEI32_V_M8_M2 + 0U, // PseudoVSOXEI32_V_M8_M2_MASK + 0U, // PseudoVSOXEI32_V_M8_M4 + 0U, // PseudoVSOXEI32_V_M8_M4_MASK + 0U, // PseudoVSOXEI32_V_M8_M8 + 0U, // PseudoVSOXEI32_V_M8_M8_MASK + 0U, // PseudoVSOXEI32_V_MF2_M1 + 0U, // PseudoVSOXEI32_V_MF2_M1_MASK + 0U, // PseudoVSOXEI32_V_MF2_MF2 + 0U, // PseudoVSOXEI32_V_MF2_MF2_MASK + 0U, // PseudoVSOXEI32_V_MF2_MF4 + 0U, // PseudoVSOXEI32_V_MF2_MF4_MASK + 0U, // PseudoVSOXEI32_V_MF2_MF8 + 0U, // PseudoVSOXEI32_V_MF2_MF8_MASK + 0U, // PseudoVSOXEI64_V_M1_M1 + 0U, // PseudoVSOXEI64_V_M1_M1_MASK + 0U, // PseudoVSOXEI64_V_M1_MF2 + 0U, // PseudoVSOXEI64_V_M1_MF2_MASK + 0U, // PseudoVSOXEI64_V_M1_MF4 + 0U, // PseudoVSOXEI64_V_M1_MF4_MASK + 0U, // PseudoVSOXEI64_V_M1_MF8 + 0U, // PseudoVSOXEI64_V_M1_MF8_MASK + 0U, // PseudoVSOXEI64_V_M2_M1 + 0U, // PseudoVSOXEI64_V_M2_M1_MASK + 0U, // PseudoVSOXEI64_V_M2_M2 + 0U, // PseudoVSOXEI64_V_M2_M2_MASK + 0U, // PseudoVSOXEI64_V_M2_MF2 + 0U, // PseudoVSOXEI64_V_M2_MF2_MASK + 0U, // PseudoVSOXEI64_V_M2_MF4 + 0U, // PseudoVSOXEI64_V_M2_MF4_MASK + 0U, // PseudoVSOXEI64_V_M4_M1 + 0U, // PseudoVSOXEI64_V_M4_M1_MASK + 0U, // PseudoVSOXEI64_V_M4_M2 + 0U, // PseudoVSOXEI64_V_M4_M2_MASK + 0U, // PseudoVSOXEI64_V_M4_M4 + 0U, // PseudoVSOXEI64_V_M4_M4_MASK + 0U, // PseudoVSOXEI64_V_M4_MF2 + 0U, // PseudoVSOXEI64_V_M4_MF2_MASK + 0U, // PseudoVSOXEI64_V_M8_M1 + 0U, // PseudoVSOXEI64_V_M8_M1_MASK + 0U, // PseudoVSOXEI64_V_M8_M2 + 0U, // PseudoVSOXEI64_V_M8_M2_MASK + 0U, // PseudoVSOXEI64_V_M8_M4 + 0U, // PseudoVSOXEI64_V_M8_M4_MASK + 0U, // PseudoVSOXEI64_V_M8_M8 + 0U, // PseudoVSOXEI64_V_M8_M8_MASK + 0U, // PseudoVSOXEI8_V_M1_M1 + 0U, // PseudoVSOXEI8_V_M1_M1_MASK + 0U, // PseudoVSOXEI8_V_M1_M2 + 0U, // PseudoVSOXEI8_V_M1_M2_MASK + 0U, // PseudoVSOXEI8_V_M1_M4 + 0U, // PseudoVSOXEI8_V_M1_M4_MASK + 0U, // PseudoVSOXEI8_V_M1_M8 + 0U, // PseudoVSOXEI8_V_M1_M8_MASK + 0U, // PseudoVSOXEI8_V_M2_M2 + 0U, // PseudoVSOXEI8_V_M2_M2_MASK + 0U, // PseudoVSOXEI8_V_M2_M4 + 0U, // PseudoVSOXEI8_V_M2_M4_MASK + 0U, // PseudoVSOXEI8_V_M2_M8 + 0U, // PseudoVSOXEI8_V_M2_M8_MASK + 0U, // PseudoVSOXEI8_V_M4_M4 + 0U, // PseudoVSOXEI8_V_M4_M4_MASK + 0U, // PseudoVSOXEI8_V_M4_M8 + 0U, // PseudoVSOXEI8_V_M4_M8_MASK + 0U, // PseudoVSOXEI8_V_M8_M8 + 0U, // PseudoVSOXEI8_V_M8_M8_MASK + 0U, // PseudoVSOXEI8_V_MF2_M1 + 0U, // PseudoVSOXEI8_V_MF2_M1_MASK + 0U, // PseudoVSOXEI8_V_MF2_M2 + 0U, // PseudoVSOXEI8_V_MF2_M2_MASK + 0U, // PseudoVSOXEI8_V_MF2_M4 + 0U, // PseudoVSOXEI8_V_MF2_M4_MASK + 0U, // PseudoVSOXEI8_V_MF2_MF2 + 0U, // PseudoVSOXEI8_V_MF2_MF2_MASK + 0U, // PseudoVSOXEI8_V_MF4_M1 + 0U, // PseudoVSOXEI8_V_MF4_M1_MASK + 0U, // PseudoVSOXEI8_V_MF4_M2 + 0U, // PseudoVSOXEI8_V_MF4_M2_MASK + 0U, // PseudoVSOXEI8_V_MF4_MF2 + 0U, // PseudoVSOXEI8_V_MF4_MF2_MASK + 0U, // PseudoVSOXEI8_V_MF4_MF4 + 0U, // PseudoVSOXEI8_V_MF4_MF4_MASK + 0U, // PseudoVSOXEI8_V_MF8_M1 + 0U, // PseudoVSOXEI8_V_MF8_M1_MASK + 0U, // PseudoVSOXEI8_V_MF8_MF2 + 0U, // PseudoVSOXEI8_V_MF8_MF2_MASK + 0U, // PseudoVSOXEI8_V_MF8_MF4 + 0U, // PseudoVSOXEI8_V_MF8_MF4_MASK + 0U, // PseudoVSOXEI8_V_MF8_MF8 + 0U, // PseudoVSOXEI8_V_MF8_MF8_MASK + 0U, // PseudoVSOXSEG2EI16_V_M1_M1 + 0U, // PseudoVSOXSEG2EI16_V_M1_M1_MASK + 0U, // PseudoVSOXSEG2EI16_V_M1_M2 + 0U, // PseudoVSOXSEG2EI16_V_M1_M2_MASK + 0U, // PseudoVSOXSEG2EI16_V_M1_M4 + 0U, // PseudoVSOXSEG2EI16_V_M1_M4_MASK + 0U, // PseudoVSOXSEG2EI16_V_M1_MF2 + 0U, // PseudoVSOXSEG2EI16_V_M1_MF2_MASK + 0U, // PseudoVSOXSEG2EI16_V_M2_M1 + 0U, // PseudoVSOXSEG2EI16_V_M2_M1_MASK + 0U, // PseudoVSOXSEG2EI16_V_M2_M2 + 0U, // PseudoVSOXSEG2EI16_V_M2_M2_MASK + 0U, // PseudoVSOXSEG2EI16_V_M2_M4 + 0U, // PseudoVSOXSEG2EI16_V_M2_M4_MASK + 0U, // PseudoVSOXSEG2EI16_V_M4_M2 + 0U, // PseudoVSOXSEG2EI16_V_M4_M2_MASK + 0U, // PseudoVSOXSEG2EI16_V_M4_M4 + 0U, // PseudoVSOXSEG2EI16_V_M4_M4_MASK + 0U, // PseudoVSOXSEG2EI16_V_M8_M4 + 0U, // PseudoVSOXSEG2EI16_V_M8_M4_MASK + 0U, // PseudoVSOXSEG2EI16_V_MF2_M1 + 0U, // PseudoVSOXSEG2EI16_V_MF2_M1_MASK + 0U, // PseudoVSOXSEG2EI16_V_MF2_M2 + 0U, // PseudoVSOXSEG2EI16_V_MF2_M2_MASK + 0U, // PseudoVSOXSEG2EI16_V_MF2_MF2 + 0U, // PseudoVSOXSEG2EI16_V_MF2_MF2_MASK + 0U, // PseudoVSOXSEG2EI16_V_MF2_MF4 + 0U, // PseudoVSOXSEG2EI16_V_MF2_MF4_MASK + 0U, // PseudoVSOXSEG2EI16_V_MF4_M1 + 0U, // PseudoVSOXSEG2EI16_V_MF4_M1_MASK + 0U, // PseudoVSOXSEG2EI16_V_MF4_MF2 + 0U, // PseudoVSOXSEG2EI16_V_MF4_MF2_MASK + 0U, // PseudoVSOXSEG2EI16_V_MF4_MF4 + 0U, // PseudoVSOXSEG2EI16_V_MF4_MF4_MASK + 0U, // PseudoVSOXSEG2EI16_V_MF4_MF8 + 0U, // PseudoVSOXSEG2EI16_V_MF4_MF8_MASK + 0U, // PseudoVSOXSEG2EI32_V_M1_M1 + 0U, // PseudoVSOXSEG2EI32_V_M1_M1_MASK + 0U, // PseudoVSOXSEG2EI32_V_M1_M2 + 0U, // PseudoVSOXSEG2EI32_V_M1_M2_MASK + 0U, // PseudoVSOXSEG2EI32_V_M1_MF2 + 0U, // PseudoVSOXSEG2EI32_V_M1_MF2_MASK + 0U, // PseudoVSOXSEG2EI32_V_M1_MF4 + 0U, // PseudoVSOXSEG2EI32_V_M1_MF4_MASK + 0U, // PseudoVSOXSEG2EI32_V_M2_M1 + 0U, // PseudoVSOXSEG2EI32_V_M2_M1_MASK + 0U, // PseudoVSOXSEG2EI32_V_M2_M2 + 0U, // PseudoVSOXSEG2EI32_V_M2_M2_MASK + 0U, // PseudoVSOXSEG2EI32_V_M2_M4 + 0U, // PseudoVSOXSEG2EI32_V_M2_M4_MASK + 0U, // PseudoVSOXSEG2EI32_V_M2_MF2 + 0U, // PseudoVSOXSEG2EI32_V_M2_MF2_MASK + 0U, // PseudoVSOXSEG2EI32_V_M4_M1 + 0U, // PseudoVSOXSEG2EI32_V_M4_M1_MASK + 0U, // PseudoVSOXSEG2EI32_V_M4_M2 + 0U, // PseudoVSOXSEG2EI32_V_M4_M2_MASK + 0U, // PseudoVSOXSEG2EI32_V_M4_M4 + 0U, // PseudoVSOXSEG2EI32_V_M4_M4_MASK + 0U, // PseudoVSOXSEG2EI32_V_M8_M2 + 0U, // PseudoVSOXSEG2EI32_V_M8_M2_MASK + 0U, // PseudoVSOXSEG2EI32_V_M8_M4 + 0U, // PseudoVSOXSEG2EI32_V_M8_M4_MASK + 0U, // PseudoVSOXSEG2EI32_V_MF2_M1 + 0U, // PseudoVSOXSEG2EI32_V_MF2_M1_MASK + 0U, // PseudoVSOXSEG2EI32_V_MF2_MF2 + 0U, // PseudoVSOXSEG2EI32_V_MF2_MF2_MASK + 0U, // PseudoVSOXSEG2EI32_V_MF2_MF4 + 0U, // PseudoVSOXSEG2EI32_V_MF2_MF4_MASK + 0U, // PseudoVSOXSEG2EI32_V_MF2_MF8 + 0U, // PseudoVSOXSEG2EI32_V_MF2_MF8_MASK + 0U, // PseudoVSOXSEG2EI64_V_M1_M1 + 0U, // PseudoVSOXSEG2EI64_V_M1_M1_MASK + 0U, // PseudoVSOXSEG2EI64_V_M1_MF2 + 0U, // PseudoVSOXSEG2EI64_V_M1_MF2_MASK + 0U, // PseudoVSOXSEG2EI64_V_M1_MF4 + 0U, // PseudoVSOXSEG2EI64_V_M1_MF4_MASK + 0U, // PseudoVSOXSEG2EI64_V_M1_MF8 + 0U, // PseudoVSOXSEG2EI64_V_M1_MF8_MASK + 0U, // PseudoVSOXSEG2EI64_V_M2_M1 + 0U, // PseudoVSOXSEG2EI64_V_M2_M1_MASK + 0U, // PseudoVSOXSEG2EI64_V_M2_M2 + 0U, // PseudoVSOXSEG2EI64_V_M2_M2_MASK + 0U, // PseudoVSOXSEG2EI64_V_M2_MF2 + 0U, // PseudoVSOXSEG2EI64_V_M2_MF2_MASK + 0U, // PseudoVSOXSEG2EI64_V_M2_MF4 + 0U, // PseudoVSOXSEG2EI64_V_M2_MF4_MASK + 0U, // PseudoVSOXSEG2EI64_V_M4_M1 + 0U, // PseudoVSOXSEG2EI64_V_M4_M1_MASK + 0U, // PseudoVSOXSEG2EI64_V_M4_M2 + 0U, // PseudoVSOXSEG2EI64_V_M4_M2_MASK + 0U, // PseudoVSOXSEG2EI64_V_M4_M4 + 0U, // PseudoVSOXSEG2EI64_V_M4_M4_MASK + 0U, // PseudoVSOXSEG2EI64_V_M4_MF2 + 0U, // PseudoVSOXSEG2EI64_V_M4_MF2_MASK + 0U, // PseudoVSOXSEG2EI64_V_M8_M1 + 0U, // PseudoVSOXSEG2EI64_V_M8_M1_MASK + 0U, // PseudoVSOXSEG2EI64_V_M8_M2 + 0U, // PseudoVSOXSEG2EI64_V_M8_M2_MASK + 0U, // PseudoVSOXSEG2EI64_V_M8_M4 + 0U, // PseudoVSOXSEG2EI64_V_M8_M4_MASK + 0U, // PseudoVSOXSEG2EI8_V_M1_M1 + 0U, // PseudoVSOXSEG2EI8_V_M1_M1_MASK + 0U, // PseudoVSOXSEG2EI8_V_M1_M2 + 0U, // PseudoVSOXSEG2EI8_V_M1_M2_MASK + 0U, // PseudoVSOXSEG2EI8_V_M1_M4 + 0U, // PseudoVSOXSEG2EI8_V_M1_M4_MASK + 0U, // PseudoVSOXSEG2EI8_V_M2_M2 + 0U, // PseudoVSOXSEG2EI8_V_M2_M2_MASK + 0U, // PseudoVSOXSEG2EI8_V_M2_M4 + 0U, // PseudoVSOXSEG2EI8_V_M2_M4_MASK + 0U, // PseudoVSOXSEG2EI8_V_M4_M4 + 0U, // PseudoVSOXSEG2EI8_V_M4_M4_MASK + 0U, // PseudoVSOXSEG2EI8_V_MF2_M1 + 0U, // PseudoVSOXSEG2EI8_V_MF2_M1_MASK + 0U, // PseudoVSOXSEG2EI8_V_MF2_M2 + 0U, // PseudoVSOXSEG2EI8_V_MF2_M2_MASK + 0U, // PseudoVSOXSEG2EI8_V_MF2_M4 + 0U, // PseudoVSOXSEG2EI8_V_MF2_M4_MASK + 0U, // PseudoVSOXSEG2EI8_V_MF2_MF2 + 0U, // PseudoVSOXSEG2EI8_V_MF2_MF2_MASK + 0U, // PseudoVSOXSEG2EI8_V_MF4_M1 + 0U, // PseudoVSOXSEG2EI8_V_MF4_M1_MASK + 0U, // PseudoVSOXSEG2EI8_V_MF4_M2 + 0U, // PseudoVSOXSEG2EI8_V_MF4_M2_MASK + 0U, // PseudoVSOXSEG2EI8_V_MF4_MF2 + 0U, // PseudoVSOXSEG2EI8_V_MF4_MF2_MASK + 0U, // PseudoVSOXSEG2EI8_V_MF4_MF4 + 0U, // PseudoVSOXSEG2EI8_V_MF4_MF4_MASK + 0U, // PseudoVSOXSEG2EI8_V_MF8_M1 + 0U, // PseudoVSOXSEG2EI8_V_MF8_M1_MASK + 0U, // PseudoVSOXSEG2EI8_V_MF8_MF2 + 0U, // PseudoVSOXSEG2EI8_V_MF8_MF2_MASK + 0U, // PseudoVSOXSEG2EI8_V_MF8_MF4 + 0U, // PseudoVSOXSEG2EI8_V_MF8_MF4_MASK + 0U, // PseudoVSOXSEG2EI8_V_MF8_MF8 + 0U, // PseudoVSOXSEG2EI8_V_MF8_MF8_MASK + 0U, // PseudoVSOXSEG3EI16_V_M1_M1 + 0U, // PseudoVSOXSEG3EI16_V_M1_M1_MASK + 0U, // PseudoVSOXSEG3EI16_V_M1_M2 + 0U, // PseudoVSOXSEG3EI16_V_M1_M2_MASK + 0U, // PseudoVSOXSEG3EI16_V_M1_MF2 + 0U, // PseudoVSOXSEG3EI16_V_M1_MF2_MASK + 0U, // PseudoVSOXSEG3EI16_V_M2_M1 + 0U, // PseudoVSOXSEG3EI16_V_M2_M1_MASK + 0U, // PseudoVSOXSEG3EI16_V_M2_M2 + 0U, // PseudoVSOXSEG3EI16_V_M2_M2_MASK + 0U, // PseudoVSOXSEG3EI16_V_M4_M2 + 0U, // PseudoVSOXSEG3EI16_V_M4_M2_MASK + 0U, // PseudoVSOXSEG3EI16_V_MF2_M1 + 0U, // PseudoVSOXSEG3EI16_V_MF2_M1_MASK + 0U, // PseudoVSOXSEG3EI16_V_MF2_M2 + 0U, // PseudoVSOXSEG3EI16_V_MF2_M2_MASK + 0U, // PseudoVSOXSEG3EI16_V_MF2_MF2 + 0U, // PseudoVSOXSEG3EI16_V_MF2_MF2_MASK + 0U, // PseudoVSOXSEG3EI16_V_MF2_MF4 + 0U, // PseudoVSOXSEG3EI16_V_MF2_MF4_MASK + 0U, // PseudoVSOXSEG3EI16_V_MF4_M1 + 0U, // PseudoVSOXSEG3EI16_V_MF4_M1_MASK + 0U, // PseudoVSOXSEG3EI16_V_MF4_MF2 + 0U, // PseudoVSOXSEG3EI16_V_MF4_MF2_MASK + 0U, // PseudoVSOXSEG3EI16_V_MF4_MF4 + 0U, // PseudoVSOXSEG3EI16_V_MF4_MF4_MASK + 0U, // PseudoVSOXSEG3EI16_V_MF4_MF8 + 0U, // PseudoVSOXSEG3EI16_V_MF4_MF8_MASK + 0U, // PseudoVSOXSEG3EI32_V_M1_M1 + 0U, // PseudoVSOXSEG3EI32_V_M1_M1_MASK + 0U, // PseudoVSOXSEG3EI32_V_M1_M2 + 0U, // PseudoVSOXSEG3EI32_V_M1_M2_MASK + 0U, // PseudoVSOXSEG3EI32_V_M1_MF2 + 0U, // PseudoVSOXSEG3EI32_V_M1_MF2_MASK + 0U, // PseudoVSOXSEG3EI32_V_M1_MF4 + 0U, // PseudoVSOXSEG3EI32_V_M1_MF4_MASK + 0U, // PseudoVSOXSEG3EI32_V_M2_M1 + 0U, // PseudoVSOXSEG3EI32_V_M2_M1_MASK + 0U, // PseudoVSOXSEG3EI32_V_M2_M2 + 0U, // PseudoVSOXSEG3EI32_V_M2_M2_MASK + 0U, // PseudoVSOXSEG3EI32_V_M2_MF2 + 0U, // PseudoVSOXSEG3EI32_V_M2_MF2_MASK + 0U, // PseudoVSOXSEG3EI32_V_M4_M1 + 0U, // PseudoVSOXSEG3EI32_V_M4_M1_MASK + 0U, // PseudoVSOXSEG3EI32_V_M4_M2 + 0U, // PseudoVSOXSEG3EI32_V_M4_M2_MASK + 0U, // PseudoVSOXSEG3EI32_V_M8_M2 + 0U, // PseudoVSOXSEG3EI32_V_M8_M2_MASK + 0U, // PseudoVSOXSEG3EI32_V_MF2_M1 + 0U, // PseudoVSOXSEG3EI32_V_MF2_M1_MASK + 0U, // PseudoVSOXSEG3EI32_V_MF2_MF2 + 0U, // PseudoVSOXSEG3EI32_V_MF2_MF2_MASK + 0U, // PseudoVSOXSEG3EI32_V_MF2_MF4 + 0U, // PseudoVSOXSEG3EI32_V_MF2_MF4_MASK + 0U, // PseudoVSOXSEG3EI32_V_MF2_MF8 + 0U, // PseudoVSOXSEG3EI32_V_MF2_MF8_MASK + 0U, // PseudoVSOXSEG3EI64_V_M1_M1 + 0U, // PseudoVSOXSEG3EI64_V_M1_M1_MASK + 0U, // PseudoVSOXSEG3EI64_V_M1_MF2 + 0U, // PseudoVSOXSEG3EI64_V_M1_MF2_MASK + 0U, // PseudoVSOXSEG3EI64_V_M1_MF4 + 0U, // PseudoVSOXSEG3EI64_V_M1_MF4_MASK + 0U, // PseudoVSOXSEG3EI64_V_M1_MF8 + 0U, // PseudoVSOXSEG3EI64_V_M1_MF8_MASK + 0U, // PseudoVSOXSEG3EI64_V_M2_M1 + 0U, // PseudoVSOXSEG3EI64_V_M2_M1_MASK + 0U, // PseudoVSOXSEG3EI64_V_M2_M2 + 0U, // PseudoVSOXSEG3EI64_V_M2_M2_MASK + 0U, // PseudoVSOXSEG3EI64_V_M2_MF2 + 0U, // PseudoVSOXSEG3EI64_V_M2_MF2_MASK + 0U, // PseudoVSOXSEG3EI64_V_M2_MF4 + 0U, // PseudoVSOXSEG3EI64_V_M2_MF4_MASK + 0U, // PseudoVSOXSEG3EI64_V_M4_M1 + 0U, // PseudoVSOXSEG3EI64_V_M4_M1_MASK + 0U, // PseudoVSOXSEG3EI64_V_M4_M2 + 0U, // PseudoVSOXSEG3EI64_V_M4_M2_MASK + 0U, // PseudoVSOXSEG3EI64_V_M4_MF2 + 0U, // PseudoVSOXSEG3EI64_V_M4_MF2_MASK + 0U, // PseudoVSOXSEG3EI64_V_M8_M1 + 0U, // PseudoVSOXSEG3EI64_V_M8_M1_MASK + 0U, // PseudoVSOXSEG3EI64_V_M8_M2 + 0U, // PseudoVSOXSEG3EI64_V_M8_M2_MASK + 0U, // PseudoVSOXSEG3EI8_V_M1_M1 + 0U, // PseudoVSOXSEG3EI8_V_M1_M1_MASK + 0U, // PseudoVSOXSEG3EI8_V_M1_M2 + 0U, // PseudoVSOXSEG3EI8_V_M1_M2_MASK + 0U, // PseudoVSOXSEG3EI8_V_M2_M2 + 0U, // PseudoVSOXSEG3EI8_V_M2_M2_MASK + 0U, // PseudoVSOXSEG3EI8_V_MF2_M1 + 0U, // PseudoVSOXSEG3EI8_V_MF2_M1_MASK + 0U, // PseudoVSOXSEG3EI8_V_MF2_M2 + 0U, // PseudoVSOXSEG3EI8_V_MF2_M2_MASK + 0U, // PseudoVSOXSEG3EI8_V_MF2_MF2 + 0U, // PseudoVSOXSEG3EI8_V_MF2_MF2_MASK + 0U, // PseudoVSOXSEG3EI8_V_MF4_M1 + 0U, // PseudoVSOXSEG3EI8_V_MF4_M1_MASK + 0U, // PseudoVSOXSEG3EI8_V_MF4_M2 + 0U, // PseudoVSOXSEG3EI8_V_MF4_M2_MASK + 0U, // PseudoVSOXSEG3EI8_V_MF4_MF2 + 0U, // PseudoVSOXSEG3EI8_V_MF4_MF2_MASK + 0U, // PseudoVSOXSEG3EI8_V_MF4_MF4 + 0U, // PseudoVSOXSEG3EI8_V_MF4_MF4_MASK + 0U, // PseudoVSOXSEG3EI8_V_MF8_M1 + 0U, // PseudoVSOXSEG3EI8_V_MF8_M1_MASK + 0U, // PseudoVSOXSEG3EI8_V_MF8_MF2 + 0U, // PseudoVSOXSEG3EI8_V_MF8_MF2_MASK + 0U, // PseudoVSOXSEG3EI8_V_MF8_MF4 + 0U, // PseudoVSOXSEG3EI8_V_MF8_MF4_MASK + 0U, // PseudoVSOXSEG3EI8_V_MF8_MF8 + 0U, // PseudoVSOXSEG3EI8_V_MF8_MF8_MASK + 0U, // PseudoVSOXSEG4EI16_V_M1_M1 + 0U, // PseudoVSOXSEG4EI16_V_M1_M1_MASK + 0U, // PseudoVSOXSEG4EI16_V_M1_M2 + 0U, // PseudoVSOXSEG4EI16_V_M1_M2_MASK + 0U, // PseudoVSOXSEG4EI16_V_M1_MF2 + 0U, // PseudoVSOXSEG4EI16_V_M1_MF2_MASK + 0U, // PseudoVSOXSEG4EI16_V_M2_M1 + 0U, // PseudoVSOXSEG4EI16_V_M2_M1_MASK + 0U, // PseudoVSOXSEG4EI16_V_M2_M2 + 0U, // PseudoVSOXSEG4EI16_V_M2_M2_MASK + 0U, // PseudoVSOXSEG4EI16_V_M4_M2 + 0U, // PseudoVSOXSEG4EI16_V_M4_M2_MASK + 0U, // PseudoVSOXSEG4EI16_V_MF2_M1 + 0U, // PseudoVSOXSEG4EI16_V_MF2_M1_MASK + 0U, // PseudoVSOXSEG4EI16_V_MF2_M2 + 0U, // PseudoVSOXSEG4EI16_V_MF2_M2_MASK + 0U, // PseudoVSOXSEG4EI16_V_MF2_MF2 + 0U, // PseudoVSOXSEG4EI16_V_MF2_MF2_MASK + 0U, // PseudoVSOXSEG4EI16_V_MF2_MF4 + 0U, // PseudoVSOXSEG4EI16_V_MF2_MF4_MASK + 0U, // PseudoVSOXSEG4EI16_V_MF4_M1 + 0U, // PseudoVSOXSEG4EI16_V_MF4_M1_MASK + 0U, // PseudoVSOXSEG4EI16_V_MF4_MF2 + 0U, // PseudoVSOXSEG4EI16_V_MF4_MF2_MASK + 0U, // PseudoVSOXSEG4EI16_V_MF4_MF4 + 0U, // PseudoVSOXSEG4EI16_V_MF4_MF4_MASK + 0U, // PseudoVSOXSEG4EI16_V_MF4_MF8 + 0U, // PseudoVSOXSEG4EI16_V_MF4_MF8_MASK + 0U, // PseudoVSOXSEG4EI32_V_M1_M1 + 0U, // PseudoVSOXSEG4EI32_V_M1_M1_MASK + 0U, // PseudoVSOXSEG4EI32_V_M1_M2 + 0U, // PseudoVSOXSEG4EI32_V_M1_M2_MASK + 0U, // PseudoVSOXSEG4EI32_V_M1_MF2 + 0U, // PseudoVSOXSEG4EI32_V_M1_MF2_MASK + 0U, // PseudoVSOXSEG4EI32_V_M1_MF4 + 0U, // PseudoVSOXSEG4EI32_V_M1_MF4_MASK + 0U, // PseudoVSOXSEG4EI32_V_M2_M1 + 0U, // PseudoVSOXSEG4EI32_V_M2_M1_MASK + 0U, // PseudoVSOXSEG4EI32_V_M2_M2 + 0U, // PseudoVSOXSEG4EI32_V_M2_M2_MASK + 0U, // PseudoVSOXSEG4EI32_V_M2_MF2 + 0U, // PseudoVSOXSEG4EI32_V_M2_MF2_MASK + 0U, // PseudoVSOXSEG4EI32_V_M4_M1 + 0U, // PseudoVSOXSEG4EI32_V_M4_M1_MASK + 0U, // PseudoVSOXSEG4EI32_V_M4_M2 + 0U, // PseudoVSOXSEG4EI32_V_M4_M2_MASK + 0U, // PseudoVSOXSEG4EI32_V_M8_M2 + 0U, // PseudoVSOXSEG4EI32_V_M8_M2_MASK + 0U, // PseudoVSOXSEG4EI32_V_MF2_M1 + 0U, // PseudoVSOXSEG4EI32_V_MF2_M1_MASK + 0U, // PseudoVSOXSEG4EI32_V_MF2_MF2 + 0U, // PseudoVSOXSEG4EI32_V_MF2_MF2_MASK + 0U, // PseudoVSOXSEG4EI32_V_MF2_MF4 + 0U, // PseudoVSOXSEG4EI32_V_MF2_MF4_MASK + 0U, // PseudoVSOXSEG4EI32_V_MF2_MF8 + 0U, // PseudoVSOXSEG4EI32_V_MF2_MF8_MASK + 0U, // PseudoVSOXSEG4EI64_V_M1_M1 + 0U, // PseudoVSOXSEG4EI64_V_M1_M1_MASK + 0U, // PseudoVSOXSEG4EI64_V_M1_MF2 + 0U, // PseudoVSOXSEG4EI64_V_M1_MF2_MASK + 0U, // PseudoVSOXSEG4EI64_V_M1_MF4 + 0U, // PseudoVSOXSEG4EI64_V_M1_MF4_MASK + 0U, // PseudoVSOXSEG4EI64_V_M1_MF8 + 0U, // PseudoVSOXSEG4EI64_V_M1_MF8_MASK + 0U, // PseudoVSOXSEG4EI64_V_M2_M1 + 0U, // PseudoVSOXSEG4EI64_V_M2_M1_MASK + 0U, // PseudoVSOXSEG4EI64_V_M2_M2 + 0U, // PseudoVSOXSEG4EI64_V_M2_M2_MASK + 0U, // PseudoVSOXSEG4EI64_V_M2_MF2 + 0U, // PseudoVSOXSEG4EI64_V_M2_MF2_MASK + 0U, // PseudoVSOXSEG4EI64_V_M2_MF4 + 0U, // PseudoVSOXSEG4EI64_V_M2_MF4_MASK + 0U, // PseudoVSOXSEG4EI64_V_M4_M1 + 0U, // PseudoVSOXSEG4EI64_V_M4_M1_MASK + 0U, // PseudoVSOXSEG4EI64_V_M4_M2 + 0U, // PseudoVSOXSEG4EI64_V_M4_M2_MASK + 0U, // PseudoVSOXSEG4EI64_V_M4_MF2 + 0U, // PseudoVSOXSEG4EI64_V_M4_MF2_MASK + 0U, // PseudoVSOXSEG4EI64_V_M8_M1 + 0U, // PseudoVSOXSEG4EI64_V_M8_M1_MASK + 0U, // PseudoVSOXSEG4EI64_V_M8_M2 + 0U, // PseudoVSOXSEG4EI64_V_M8_M2_MASK + 0U, // PseudoVSOXSEG4EI8_V_M1_M1 + 0U, // PseudoVSOXSEG4EI8_V_M1_M1_MASK + 0U, // PseudoVSOXSEG4EI8_V_M1_M2 + 0U, // PseudoVSOXSEG4EI8_V_M1_M2_MASK + 0U, // PseudoVSOXSEG4EI8_V_M2_M2 + 0U, // PseudoVSOXSEG4EI8_V_M2_M2_MASK + 0U, // PseudoVSOXSEG4EI8_V_MF2_M1 + 0U, // PseudoVSOXSEG4EI8_V_MF2_M1_MASK + 0U, // PseudoVSOXSEG4EI8_V_MF2_M2 + 0U, // PseudoVSOXSEG4EI8_V_MF2_M2_MASK + 0U, // PseudoVSOXSEG4EI8_V_MF2_MF2 + 0U, // PseudoVSOXSEG4EI8_V_MF2_MF2_MASK + 0U, // PseudoVSOXSEG4EI8_V_MF4_M1 + 0U, // PseudoVSOXSEG4EI8_V_MF4_M1_MASK + 0U, // PseudoVSOXSEG4EI8_V_MF4_M2 + 0U, // PseudoVSOXSEG4EI8_V_MF4_M2_MASK + 0U, // PseudoVSOXSEG4EI8_V_MF4_MF2 + 0U, // PseudoVSOXSEG4EI8_V_MF4_MF2_MASK + 0U, // PseudoVSOXSEG4EI8_V_MF4_MF4 + 0U, // PseudoVSOXSEG4EI8_V_MF4_MF4_MASK + 0U, // PseudoVSOXSEG4EI8_V_MF8_M1 + 0U, // PseudoVSOXSEG4EI8_V_MF8_M1_MASK + 0U, // PseudoVSOXSEG4EI8_V_MF8_MF2 + 0U, // PseudoVSOXSEG4EI8_V_MF8_MF2_MASK + 0U, // PseudoVSOXSEG4EI8_V_MF8_MF4 + 0U, // PseudoVSOXSEG4EI8_V_MF8_MF4_MASK + 0U, // PseudoVSOXSEG4EI8_V_MF8_MF8 + 0U, // PseudoVSOXSEG4EI8_V_MF8_MF8_MASK + 0U, // PseudoVSOXSEG5EI16_V_M1_M1 + 0U, // PseudoVSOXSEG5EI16_V_M1_M1_MASK + 0U, // PseudoVSOXSEG5EI16_V_M1_MF2 + 0U, // PseudoVSOXSEG5EI16_V_M1_MF2_MASK + 0U, // PseudoVSOXSEG5EI16_V_M2_M1 + 0U, // PseudoVSOXSEG5EI16_V_M2_M1_MASK + 0U, // PseudoVSOXSEG5EI16_V_MF2_M1 + 0U, // PseudoVSOXSEG5EI16_V_MF2_M1_MASK + 0U, // PseudoVSOXSEG5EI16_V_MF2_MF2 + 0U, // PseudoVSOXSEG5EI16_V_MF2_MF2_MASK + 0U, // PseudoVSOXSEG5EI16_V_MF2_MF4 + 0U, // PseudoVSOXSEG5EI16_V_MF2_MF4_MASK + 0U, // PseudoVSOXSEG5EI16_V_MF4_M1 + 0U, // PseudoVSOXSEG5EI16_V_MF4_M1_MASK + 0U, // PseudoVSOXSEG5EI16_V_MF4_MF2 + 0U, // PseudoVSOXSEG5EI16_V_MF4_MF2_MASK + 0U, // PseudoVSOXSEG5EI16_V_MF4_MF4 + 0U, // PseudoVSOXSEG5EI16_V_MF4_MF4_MASK + 0U, // PseudoVSOXSEG5EI16_V_MF4_MF8 + 0U, // PseudoVSOXSEG5EI16_V_MF4_MF8_MASK + 0U, // PseudoVSOXSEG5EI32_V_M1_M1 + 0U, // PseudoVSOXSEG5EI32_V_M1_M1_MASK + 0U, // PseudoVSOXSEG5EI32_V_M1_MF2 + 0U, // PseudoVSOXSEG5EI32_V_M1_MF2_MASK + 0U, // PseudoVSOXSEG5EI32_V_M1_MF4 + 0U, // PseudoVSOXSEG5EI32_V_M1_MF4_MASK + 0U, // PseudoVSOXSEG5EI32_V_M2_M1 + 0U, // PseudoVSOXSEG5EI32_V_M2_M1_MASK + 0U, // PseudoVSOXSEG5EI32_V_M2_MF2 + 0U, // PseudoVSOXSEG5EI32_V_M2_MF2_MASK + 0U, // PseudoVSOXSEG5EI32_V_M4_M1 + 0U, // PseudoVSOXSEG5EI32_V_M4_M1_MASK + 0U, // PseudoVSOXSEG5EI32_V_MF2_M1 + 0U, // PseudoVSOXSEG5EI32_V_MF2_M1_MASK + 0U, // PseudoVSOXSEG5EI32_V_MF2_MF2 + 0U, // PseudoVSOXSEG5EI32_V_MF2_MF2_MASK + 0U, // PseudoVSOXSEG5EI32_V_MF2_MF4 + 0U, // PseudoVSOXSEG5EI32_V_MF2_MF4_MASK + 0U, // PseudoVSOXSEG5EI32_V_MF2_MF8 + 0U, // PseudoVSOXSEG5EI32_V_MF2_MF8_MASK + 0U, // PseudoVSOXSEG5EI64_V_M1_M1 + 0U, // PseudoVSOXSEG5EI64_V_M1_M1_MASK + 0U, // PseudoVSOXSEG5EI64_V_M1_MF2 + 0U, // PseudoVSOXSEG5EI64_V_M1_MF2_MASK + 0U, // PseudoVSOXSEG5EI64_V_M1_MF4 + 0U, // PseudoVSOXSEG5EI64_V_M1_MF4_MASK + 0U, // PseudoVSOXSEG5EI64_V_M1_MF8 + 0U, // PseudoVSOXSEG5EI64_V_M1_MF8_MASK + 0U, // PseudoVSOXSEG5EI64_V_M2_M1 + 0U, // PseudoVSOXSEG5EI64_V_M2_M1_MASK + 0U, // PseudoVSOXSEG5EI64_V_M2_MF2 + 0U, // PseudoVSOXSEG5EI64_V_M2_MF2_MASK + 0U, // PseudoVSOXSEG5EI64_V_M2_MF4 + 0U, // PseudoVSOXSEG5EI64_V_M2_MF4_MASK + 0U, // PseudoVSOXSEG5EI64_V_M4_M1 + 0U, // PseudoVSOXSEG5EI64_V_M4_M1_MASK + 0U, // PseudoVSOXSEG5EI64_V_M4_MF2 + 0U, // PseudoVSOXSEG5EI64_V_M4_MF2_MASK + 0U, // PseudoVSOXSEG5EI64_V_M8_M1 + 0U, // PseudoVSOXSEG5EI64_V_M8_M1_MASK + 0U, // PseudoVSOXSEG5EI8_V_M1_M1 + 0U, // PseudoVSOXSEG5EI8_V_M1_M1_MASK + 0U, // PseudoVSOXSEG5EI8_V_MF2_M1 + 0U, // PseudoVSOXSEG5EI8_V_MF2_M1_MASK + 0U, // PseudoVSOXSEG5EI8_V_MF2_MF2 + 0U, // PseudoVSOXSEG5EI8_V_MF2_MF2_MASK + 0U, // PseudoVSOXSEG5EI8_V_MF4_M1 + 0U, // PseudoVSOXSEG5EI8_V_MF4_M1_MASK + 0U, // PseudoVSOXSEG5EI8_V_MF4_MF2 + 0U, // PseudoVSOXSEG5EI8_V_MF4_MF2_MASK + 0U, // PseudoVSOXSEG5EI8_V_MF4_MF4 + 0U, // PseudoVSOXSEG5EI8_V_MF4_MF4_MASK + 0U, // PseudoVSOXSEG5EI8_V_MF8_M1 + 0U, // PseudoVSOXSEG5EI8_V_MF8_M1_MASK + 0U, // PseudoVSOXSEG5EI8_V_MF8_MF2 + 0U, // PseudoVSOXSEG5EI8_V_MF8_MF2_MASK + 0U, // PseudoVSOXSEG5EI8_V_MF8_MF4 + 0U, // PseudoVSOXSEG5EI8_V_MF8_MF4_MASK + 0U, // PseudoVSOXSEG5EI8_V_MF8_MF8 + 0U, // PseudoVSOXSEG5EI8_V_MF8_MF8_MASK + 0U, // PseudoVSOXSEG6EI16_V_M1_M1 + 0U, // PseudoVSOXSEG6EI16_V_M1_M1_MASK + 0U, // PseudoVSOXSEG6EI16_V_M1_MF2 + 0U, // PseudoVSOXSEG6EI16_V_M1_MF2_MASK + 0U, // PseudoVSOXSEG6EI16_V_M2_M1 + 0U, // PseudoVSOXSEG6EI16_V_M2_M1_MASK + 0U, // PseudoVSOXSEG6EI16_V_MF2_M1 + 0U, // PseudoVSOXSEG6EI16_V_MF2_M1_MASK + 0U, // PseudoVSOXSEG6EI16_V_MF2_MF2 + 0U, // PseudoVSOXSEG6EI16_V_MF2_MF2_MASK + 0U, // PseudoVSOXSEG6EI16_V_MF2_MF4 + 0U, // PseudoVSOXSEG6EI16_V_MF2_MF4_MASK + 0U, // PseudoVSOXSEG6EI16_V_MF4_M1 + 0U, // PseudoVSOXSEG6EI16_V_MF4_M1_MASK + 0U, // PseudoVSOXSEG6EI16_V_MF4_MF2 + 0U, // PseudoVSOXSEG6EI16_V_MF4_MF2_MASK + 0U, // PseudoVSOXSEG6EI16_V_MF4_MF4 + 0U, // PseudoVSOXSEG6EI16_V_MF4_MF4_MASK + 0U, // PseudoVSOXSEG6EI16_V_MF4_MF8 + 0U, // PseudoVSOXSEG6EI16_V_MF4_MF8_MASK + 0U, // PseudoVSOXSEG6EI32_V_M1_M1 + 0U, // PseudoVSOXSEG6EI32_V_M1_M1_MASK + 0U, // PseudoVSOXSEG6EI32_V_M1_MF2 + 0U, // PseudoVSOXSEG6EI32_V_M1_MF2_MASK + 0U, // PseudoVSOXSEG6EI32_V_M1_MF4 + 0U, // PseudoVSOXSEG6EI32_V_M1_MF4_MASK + 0U, // PseudoVSOXSEG6EI32_V_M2_M1 + 0U, // PseudoVSOXSEG6EI32_V_M2_M1_MASK + 0U, // PseudoVSOXSEG6EI32_V_M2_MF2 + 0U, // PseudoVSOXSEG6EI32_V_M2_MF2_MASK + 0U, // PseudoVSOXSEG6EI32_V_M4_M1 + 0U, // PseudoVSOXSEG6EI32_V_M4_M1_MASK + 0U, // PseudoVSOXSEG6EI32_V_MF2_M1 + 0U, // PseudoVSOXSEG6EI32_V_MF2_M1_MASK + 0U, // PseudoVSOXSEG6EI32_V_MF2_MF2 + 0U, // PseudoVSOXSEG6EI32_V_MF2_MF2_MASK + 0U, // PseudoVSOXSEG6EI32_V_MF2_MF4 + 0U, // PseudoVSOXSEG6EI32_V_MF2_MF4_MASK + 0U, // PseudoVSOXSEG6EI32_V_MF2_MF8 + 0U, // PseudoVSOXSEG6EI32_V_MF2_MF8_MASK + 0U, // PseudoVSOXSEG6EI64_V_M1_M1 + 0U, // PseudoVSOXSEG6EI64_V_M1_M1_MASK + 0U, // PseudoVSOXSEG6EI64_V_M1_MF2 + 0U, // PseudoVSOXSEG6EI64_V_M1_MF2_MASK + 0U, // PseudoVSOXSEG6EI64_V_M1_MF4 + 0U, // PseudoVSOXSEG6EI64_V_M1_MF4_MASK + 0U, // PseudoVSOXSEG6EI64_V_M1_MF8 + 0U, // PseudoVSOXSEG6EI64_V_M1_MF8_MASK + 0U, // PseudoVSOXSEG6EI64_V_M2_M1 + 0U, // PseudoVSOXSEG6EI64_V_M2_M1_MASK + 0U, // PseudoVSOXSEG6EI64_V_M2_MF2 + 0U, // PseudoVSOXSEG6EI64_V_M2_MF2_MASK + 0U, // PseudoVSOXSEG6EI64_V_M2_MF4 + 0U, // PseudoVSOXSEG6EI64_V_M2_MF4_MASK + 0U, // PseudoVSOXSEG6EI64_V_M4_M1 + 0U, // PseudoVSOXSEG6EI64_V_M4_M1_MASK + 0U, // PseudoVSOXSEG6EI64_V_M4_MF2 + 0U, // PseudoVSOXSEG6EI64_V_M4_MF2_MASK + 0U, // PseudoVSOXSEG6EI64_V_M8_M1 + 0U, // PseudoVSOXSEG6EI64_V_M8_M1_MASK + 0U, // PseudoVSOXSEG6EI8_V_M1_M1 + 0U, // PseudoVSOXSEG6EI8_V_M1_M1_MASK + 0U, // PseudoVSOXSEG6EI8_V_MF2_M1 + 0U, // PseudoVSOXSEG6EI8_V_MF2_M1_MASK + 0U, // PseudoVSOXSEG6EI8_V_MF2_MF2 + 0U, // PseudoVSOXSEG6EI8_V_MF2_MF2_MASK + 0U, // PseudoVSOXSEG6EI8_V_MF4_M1 + 0U, // PseudoVSOXSEG6EI8_V_MF4_M1_MASK + 0U, // PseudoVSOXSEG6EI8_V_MF4_MF2 + 0U, // PseudoVSOXSEG6EI8_V_MF4_MF2_MASK + 0U, // PseudoVSOXSEG6EI8_V_MF4_MF4 + 0U, // PseudoVSOXSEG6EI8_V_MF4_MF4_MASK + 0U, // PseudoVSOXSEG6EI8_V_MF8_M1 + 0U, // PseudoVSOXSEG6EI8_V_MF8_M1_MASK + 0U, // PseudoVSOXSEG6EI8_V_MF8_MF2 + 0U, // PseudoVSOXSEG6EI8_V_MF8_MF2_MASK + 0U, // PseudoVSOXSEG6EI8_V_MF8_MF4 + 0U, // PseudoVSOXSEG6EI8_V_MF8_MF4_MASK + 0U, // PseudoVSOXSEG6EI8_V_MF8_MF8 + 0U, // PseudoVSOXSEG6EI8_V_MF8_MF8_MASK + 0U, // PseudoVSOXSEG7EI16_V_M1_M1 + 0U, // PseudoVSOXSEG7EI16_V_M1_M1_MASK + 0U, // PseudoVSOXSEG7EI16_V_M1_MF2 + 0U, // PseudoVSOXSEG7EI16_V_M1_MF2_MASK + 0U, // PseudoVSOXSEG7EI16_V_M2_M1 + 0U, // PseudoVSOXSEG7EI16_V_M2_M1_MASK + 0U, // PseudoVSOXSEG7EI16_V_MF2_M1 + 0U, // PseudoVSOXSEG7EI16_V_MF2_M1_MASK + 0U, // PseudoVSOXSEG7EI16_V_MF2_MF2 + 0U, // PseudoVSOXSEG7EI16_V_MF2_MF2_MASK + 0U, // PseudoVSOXSEG7EI16_V_MF2_MF4 + 0U, // PseudoVSOXSEG7EI16_V_MF2_MF4_MASK + 0U, // PseudoVSOXSEG7EI16_V_MF4_M1 + 0U, // PseudoVSOXSEG7EI16_V_MF4_M1_MASK + 0U, // PseudoVSOXSEG7EI16_V_MF4_MF2 + 0U, // PseudoVSOXSEG7EI16_V_MF4_MF2_MASK + 0U, // PseudoVSOXSEG7EI16_V_MF4_MF4 + 0U, // PseudoVSOXSEG7EI16_V_MF4_MF4_MASK + 0U, // PseudoVSOXSEG7EI16_V_MF4_MF8 + 0U, // PseudoVSOXSEG7EI16_V_MF4_MF8_MASK + 0U, // PseudoVSOXSEG7EI32_V_M1_M1 + 0U, // PseudoVSOXSEG7EI32_V_M1_M1_MASK + 0U, // PseudoVSOXSEG7EI32_V_M1_MF2 + 0U, // PseudoVSOXSEG7EI32_V_M1_MF2_MASK + 0U, // PseudoVSOXSEG7EI32_V_M1_MF4 + 0U, // PseudoVSOXSEG7EI32_V_M1_MF4_MASK + 0U, // PseudoVSOXSEG7EI32_V_M2_M1 + 0U, // PseudoVSOXSEG7EI32_V_M2_M1_MASK + 0U, // PseudoVSOXSEG7EI32_V_M2_MF2 + 0U, // PseudoVSOXSEG7EI32_V_M2_MF2_MASK + 0U, // PseudoVSOXSEG7EI32_V_M4_M1 + 0U, // PseudoVSOXSEG7EI32_V_M4_M1_MASK + 0U, // PseudoVSOXSEG7EI32_V_MF2_M1 + 0U, // PseudoVSOXSEG7EI32_V_MF2_M1_MASK + 0U, // PseudoVSOXSEG7EI32_V_MF2_MF2 + 0U, // PseudoVSOXSEG7EI32_V_MF2_MF2_MASK + 0U, // PseudoVSOXSEG7EI32_V_MF2_MF4 + 0U, // PseudoVSOXSEG7EI32_V_MF2_MF4_MASK + 0U, // PseudoVSOXSEG7EI32_V_MF2_MF8 + 0U, // PseudoVSOXSEG7EI32_V_MF2_MF8_MASK + 0U, // PseudoVSOXSEG7EI64_V_M1_M1 + 0U, // PseudoVSOXSEG7EI64_V_M1_M1_MASK + 0U, // PseudoVSOXSEG7EI64_V_M1_MF2 + 0U, // PseudoVSOXSEG7EI64_V_M1_MF2_MASK + 0U, // PseudoVSOXSEG7EI64_V_M1_MF4 + 0U, // PseudoVSOXSEG7EI64_V_M1_MF4_MASK + 0U, // PseudoVSOXSEG7EI64_V_M1_MF8 + 0U, // PseudoVSOXSEG7EI64_V_M1_MF8_MASK + 0U, // PseudoVSOXSEG7EI64_V_M2_M1 + 0U, // PseudoVSOXSEG7EI64_V_M2_M1_MASK + 0U, // PseudoVSOXSEG7EI64_V_M2_MF2 + 0U, // PseudoVSOXSEG7EI64_V_M2_MF2_MASK + 0U, // PseudoVSOXSEG7EI64_V_M2_MF4 + 0U, // PseudoVSOXSEG7EI64_V_M2_MF4_MASK + 0U, // PseudoVSOXSEG7EI64_V_M4_M1 + 0U, // PseudoVSOXSEG7EI64_V_M4_M1_MASK + 0U, // PseudoVSOXSEG7EI64_V_M4_MF2 + 0U, // PseudoVSOXSEG7EI64_V_M4_MF2_MASK + 0U, // PseudoVSOXSEG7EI64_V_M8_M1 + 0U, // PseudoVSOXSEG7EI64_V_M8_M1_MASK + 0U, // PseudoVSOXSEG7EI8_V_M1_M1 + 0U, // PseudoVSOXSEG7EI8_V_M1_M1_MASK + 0U, // PseudoVSOXSEG7EI8_V_MF2_M1 + 0U, // PseudoVSOXSEG7EI8_V_MF2_M1_MASK + 0U, // PseudoVSOXSEG7EI8_V_MF2_MF2 + 0U, // PseudoVSOXSEG7EI8_V_MF2_MF2_MASK + 0U, // PseudoVSOXSEG7EI8_V_MF4_M1 + 0U, // PseudoVSOXSEG7EI8_V_MF4_M1_MASK + 0U, // PseudoVSOXSEG7EI8_V_MF4_MF2 + 0U, // PseudoVSOXSEG7EI8_V_MF4_MF2_MASK + 0U, // PseudoVSOXSEG7EI8_V_MF4_MF4 + 0U, // PseudoVSOXSEG7EI8_V_MF4_MF4_MASK + 0U, // PseudoVSOXSEG7EI8_V_MF8_M1 + 0U, // PseudoVSOXSEG7EI8_V_MF8_M1_MASK + 0U, // PseudoVSOXSEG7EI8_V_MF8_MF2 + 0U, // PseudoVSOXSEG7EI8_V_MF8_MF2_MASK + 0U, // PseudoVSOXSEG7EI8_V_MF8_MF4 + 0U, // PseudoVSOXSEG7EI8_V_MF8_MF4_MASK + 0U, // PseudoVSOXSEG7EI8_V_MF8_MF8 + 0U, // PseudoVSOXSEG7EI8_V_MF8_MF8_MASK + 0U, // PseudoVSOXSEG8EI16_V_M1_M1 + 0U, // PseudoVSOXSEG8EI16_V_M1_M1_MASK + 0U, // PseudoVSOXSEG8EI16_V_M1_MF2 + 0U, // PseudoVSOXSEG8EI16_V_M1_MF2_MASK + 0U, // PseudoVSOXSEG8EI16_V_M2_M1 + 0U, // PseudoVSOXSEG8EI16_V_M2_M1_MASK + 0U, // PseudoVSOXSEG8EI16_V_MF2_M1 + 0U, // PseudoVSOXSEG8EI16_V_MF2_M1_MASK + 0U, // PseudoVSOXSEG8EI16_V_MF2_MF2 + 0U, // PseudoVSOXSEG8EI16_V_MF2_MF2_MASK + 0U, // PseudoVSOXSEG8EI16_V_MF2_MF4 + 0U, // PseudoVSOXSEG8EI16_V_MF2_MF4_MASK + 0U, // PseudoVSOXSEG8EI16_V_MF4_M1 + 0U, // PseudoVSOXSEG8EI16_V_MF4_M1_MASK + 0U, // PseudoVSOXSEG8EI16_V_MF4_MF2 + 0U, // PseudoVSOXSEG8EI16_V_MF4_MF2_MASK + 0U, // PseudoVSOXSEG8EI16_V_MF4_MF4 + 0U, // PseudoVSOXSEG8EI16_V_MF4_MF4_MASK + 0U, // PseudoVSOXSEG8EI16_V_MF4_MF8 + 0U, // PseudoVSOXSEG8EI16_V_MF4_MF8_MASK + 0U, // PseudoVSOXSEG8EI32_V_M1_M1 + 0U, // PseudoVSOXSEG8EI32_V_M1_M1_MASK + 0U, // PseudoVSOXSEG8EI32_V_M1_MF2 + 0U, // PseudoVSOXSEG8EI32_V_M1_MF2_MASK + 0U, // PseudoVSOXSEG8EI32_V_M1_MF4 + 0U, // PseudoVSOXSEG8EI32_V_M1_MF4_MASK + 0U, // PseudoVSOXSEG8EI32_V_M2_M1 + 0U, // PseudoVSOXSEG8EI32_V_M2_M1_MASK + 0U, // PseudoVSOXSEG8EI32_V_M2_MF2 + 0U, // PseudoVSOXSEG8EI32_V_M2_MF2_MASK + 0U, // PseudoVSOXSEG8EI32_V_M4_M1 + 0U, // PseudoVSOXSEG8EI32_V_M4_M1_MASK + 0U, // PseudoVSOXSEG8EI32_V_MF2_M1 + 0U, // PseudoVSOXSEG8EI32_V_MF2_M1_MASK + 0U, // PseudoVSOXSEG8EI32_V_MF2_MF2 + 0U, // PseudoVSOXSEG8EI32_V_MF2_MF2_MASK + 0U, // PseudoVSOXSEG8EI32_V_MF2_MF4 + 0U, // PseudoVSOXSEG8EI32_V_MF2_MF4_MASK + 0U, // PseudoVSOXSEG8EI32_V_MF2_MF8 + 0U, // PseudoVSOXSEG8EI32_V_MF2_MF8_MASK + 0U, // PseudoVSOXSEG8EI64_V_M1_M1 + 0U, // PseudoVSOXSEG8EI64_V_M1_M1_MASK + 0U, // PseudoVSOXSEG8EI64_V_M1_MF2 + 0U, // PseudoVSOXSEG8EI64_V_M1_MF2_MASK + 0U, // PseudoVSOXSEG8EI64_V_M1_MF4 + 0U, // PseudoVSOXSEG8EI64_V_M1_MF4_MASK + 0U, // PseudoVSOXSEG8EI64_V_M1_MF8 + 0U, // PseudoVSOXSEG8EI64_V_M1_MF8_MASK + 0U, // PseudoVSOXSEG8EI64_V_M2_M1 + 0U, // PseudoVSOXSEG8EI64_V_M2_M1_MASK + 0U, // PseudoVSOXSEG8EI64_V_M2_MF2 + 0U, // PseudoVSOXSEG8EI64_V_M2_MF2_MASK + 0U, // PseudoVSOXSEG8EI64_V_M2_MF4 + 0U, // PseudoVSOXSEG8EI64_V_M2_MF4_MASK + 0U, // PseudoVSOXSEG8EI64_V_M4_M1 + 0U, // PseudoVSOXSEG8EI64_V_M4_M1_MASK + 0U, // PseudoVSOXSEG8EI64_V_M4_MF2 + 0U, // PseudoVSOXSEG8EI64_V_M4_MF2_MASK + 0U, // PseudoVSOXSEG8EI64_V_M8_M1 + 0U, // PseudoVSOXSEG8EI64_V_M8_M1_MASK + 0U, // PseudoVSOXSEG8EI8_V_M1_M1 + 0U, // PseudoVSOXSEG8EI8_V_M1_M1_MASK + 0U, // PseudoVSOXSEG8EI8_V_MF2_M1 + 0U, // PseudoVSOXSEG8EI8_V_MF2_M1_MASK + 0U, // PseudoVSOXSEG8EI8_V_MF2_MF2 + 0U, // PseudoVSOXSEG8EI8_V_MF2_MF2_MASK + 0U, // PseudoVSOXSEG8EI8_V_MF4_M1 + 0U, // PseudoVSOXSEG8EI8_V_MF4_M1_MASK + 0U, // PseudoVSOXSEG8EI8_V_MF4_MF2 + 0U, // PseudoVSOXSEG8EI8_V_MF4_MF2_MASK + 0U, // PseudoVSOXSEG8EI8_V_MF4_MF4 + 0U, // PseudoVSOXSEG8EI8_V_MF4_MF4_MASK + 0U, // PseudoVSOXSEG8EI8_V_MF8_M1 + 0U, // PseudoVSOXSEG8EI8_V_MF8_M1_MASK + 0U, // PseudoVSOXSEG8EI8_V_MF8_MF2 + 0U, // PseudoVSOXSEG8EI8_V_MF8_MF2_MASK + 0U, // PseudoVSOXSEG8EI8_V_MF8_MF4 + 0U, // PseudoVSOXSEG8EI8_V_MF8_MF4_MASK + 0U, // PseudoVSOXSEG8EI8_V_MF8_MF8 + 0U, // PseudoVSOXSEG8EI8_V_MF8_MF8_MASK + 0U, // PseudoVSPILL2_M1 + 0U, // PseudoVSPILL2_M2 + 0U, // PseudoVSPILL2_M4 + 0U, // PseudoVSPILL2_MF2 + 0U, // PseudoVSPILL2_MF4 + 0U, // PseudoVSPILL2_MF8 + 0U, // PseudoVSPILL3_M1 + 0U, // PseudoVSPILL3_M2 + 0U, // PseudoVSPILL3_MF2 + 0U, // PseudoVSPILL3_MF4 + 0U, // PseudoVSPILL3_MF8 + 0U, // PseudoVSPILL4_M1 + 0U, // PseudoVSPILL4_M2 + 0U, // PseudoVSPILL4_MF2 + 0U, // PseudoVSPILL4_MF4 + 0U, // PseudoVSPILL4_MF8 + 0U, // PseudoVSPILL5_M1 + 0U, // PseudoVSPILL5_MF2 + 0U, // PseudoVSPILL5_MF4 + 0U, // PseudoVSPILL5_MF8 + 0U, // PseudoVSPILL6_M1 + 0U, // PseudoVSPILL6_MF2 + 0U, // PseudoVSPILL6_MF4 + 0U, // PseudoVSPILL6_MF8 + 0U, // PseudoVSPILL7_M1 + 0U, // PseudoVSPILL7_MF2 + 0U, // PseudoVSPILL7_MF4 + 0U, // PseudoVSPILL7_MF8 + 0U, // PseudoVSPILL8_M1 + 0U, // PseudoVSPILL8_MF2 + 0U, // PseudoVSPILL8_MF4 + 0U, // PseudoVSPILL8_MF8 + 0U, // PseudoVSRA_VI_M1 + 0U, // PseudoVSRA_VI_M1_MASK + 0U, // PseudoVSRA_VI_M2 + 0U, // PseudoVSRA_VI_M2_MASK + 0U, // PseudoVSRA_VI_M4 + 0U, // PseudoVSRA_VI_M4_MASK + 0U, // PseudoVSRA_VI_M8 + 0U, // PseudoVSRA_VI_M8_MASK + 0U, // PseudoVSRA_VI_MF2 + 0U, // PseudoVSRA_VI_MF2_MASK + 0U, // PseudoVSRA_VI_MF4 + 0U, // PseudoVSRA_VI_MF4_MASK + 0U, // PseudoVSRA_VI_MF8 + 0U, // PseudoVSRA_VI_MF8_MASK + 0U, // PseudoVSRA_VV_M1 + 0U, // PseudoVSRA_VV_M1_MASK + 0U, // PseudoVSRA_VV_M2 + 0U, // PseudoVSRA_VV_M2_MASK + 0U, // PseudoVSRA_VV_M4 + 0U, // PseudoVSRA_VV_M4_MASK + 0U, // PseudoVSRA_VV_M8 + 0U, // PseudoVSRA_VV_M8_MASK + 0U, // PseudoVSRA_VV_MF2 + 0U, // PseudoVSRA_VV_MF2_MASK + 0U, // PseudoVSRA_VV_MF4 + 0U, // PseudoVSRA_VV_MF4_MASK + 0U, // PseudoVSRA_VV_MF8 + 0U, // PseudoVSRA_VV_MF8_MASK + 0U, // PseudoVSRA_VX_M1 + 0U, // PseudoVSRA_VX_M1_MASK + 0U, // PseudoVSRA_VX_M2 + 0U, // PseudoVSRA_VX_M2_MASK + 0U, // PseudoVSRA_VX_M4 + 0U, // PseudoVSRA_VX_M4_MASK + 0U, // PseudoVSRA_VX_M8 + 0U, // PseudoVSRA_VX_M8_MASK + 0U, // PseudoVSRA_VX_MF2 + 0U, // PseudoVSRA_VX_MF2_MASK + 0U, // PseudoVSRA_VX_MF4 + 0U, // PseudoVSRA_VX_MF4_MASK + 0U, // PseudoVSRA_VX_MF8 + 0U, // PseudoVSRA_VX_MF8_MASK + 0U, // PseudoVSRL_VI_M1 + 0U, // PseudoVSRL_VI_M1_MASK + 0U, // PseudoVSRL_VI_M2 + 0U, // PseudoVSRL_VI_M2_MASK + 0U, // PseudoVSRL_VI_M4 + 0U, // PseudoVSRL_VI_M4_MASK + 0U, // PseudoVSRL_VI_M8 + 0U, // PseudoVSRL_VI_M8_MASK + 0U, // PseudoVSRL_VI_MF2 + 0U, // PseudoVSRL_VI_MF2_MASK + 0U, // PseudoVSRL_VI_MF4 + 0U, // PseudoVSRL_VI_MF4_MASK + 0U, // PseudoVSRL_VI_MF8 + 0U, // PseudoVSRL_VI_MF8_MASK + 0U, // PseudoVSRL_VV_M1 + 0U, // PseudoVSRL_VV_M1_MASK + 0U, // PseudoVSRL_VV_M2 + 0U, // PseudoVSRL_VV_M2_MASK + 0U, // PseudoVSRL_VV_M4 + 0U, // PseudoVSRL_VV_M4_MASK + 0U, // PseudoVSRL_VV_M8 + 0U, // PseudoVSRL_VV_M8_MASK + 0U, // PseudoVSRL_VV_MF2 + 0U, // PseudoVSRL_VV_MF2_MASK + 0U, // PseudoVSRL_VV_MF4 + 0U, // PseudoVSRL_VV_MF4_MASK + 0U, // PseudoVSRL_VV_MF8 + 0U, // PseudoVSRL_VV_MF8_MASK + 0U, // PseudoVSRL_VX_M1 + 0U, // PseudoVSRL_VX_M1_MASK + 0U, // PseudoVSRL_VX_M2 + 0U, // PseudoVSRL_VX_M2_MASK + 0U, // PseudoVSRL_VX_M4 + 0U, // PseudoVSRL_VX_M4_MASK + 0U, // PseudoVSRL_VX_M8 + 0U, // PseudoVSRL_VX_M8_MASK + 0U, // PseudoVSRL_VX_MF2 + 0U, // PseudoVSRL_VX_MF2_MASK + 0U, // PseudoVSRL_VX_MF4 + 0U, // PseudoVSRL_VX_MF4_MASK + 0U, // PseudoVSRL_VX_MF8 + 0U, // PseudoVSRL_VX_MF8_MASK + 0U, // PseudoVSSE16_V_M1 + 0U, // PseudoVSSE16_V_M1_MASK + 0U, // PseudoVSSE16_V_M2 + 0U, // PseudoVSSE16_V_M2_MASK + 0U, // PseudoVSSE16_V_M4 + 0U, // PseudoVSSE16_V_M4_MASK + 0U, // PseudoVSSE16_V_M8 + 0U, // PseudoVSSE16_V_M8_MASK + 0U, // PseudoVSSE16_V_MF2 + 0U, // PseudoVSSE16_V_MF2_MASK + 0U, // PseudoVSSE16_V_MF4 + 0U, // PseudoVSSE16_V_MF4_MASK + 0U, // PseudoVSSE32_V_M1 + 0U, // PseudoVSSE32_V_M1_MASK + 0U, // PseudoVSSE32_V_M2 + 0U, // PseudoVSSE32_V_M2_MASK + 0U, // PseudoVSSE32_V_M4 + 0U, // PseudoVSSE32_V_M4_MASK + 0U, // PseudoVSSE32_V_M8 + 0U, // PseudoVSSE32_V_M8_MASK + 0U, // PseudoVSSE32_V_MF2 + 0U, // PseudoVSSE32_V_MF2_MASK + 0U, // PseudoVSSE64_V_M1 + 0U, // PseudoVSSE64_V_M1_MASK + 0U, // PseudoVSSE64_V_M2 + 0U, // PseudoVSSE64_V_M2_MASK + 0U, // PseudoVSSE64_V_M4 + 0U, // PseudoVSSE64_V_M4_MASK + 0U, // PseudoVSSE64_V_M8 + 0U, // PseudoVSSE64_V_M8_MASK + 0U, // PseudoVSSE8_V_M1 + 0U, // PseudoVSSE8_V_M1_MASK + 0U, // PseudoVSSE8_V_M2 + 0U, // PseudoVSSE8_V_M2_MASK + 0U, // PseudoVSSE8_V_M4 + 0U, // PseudoVSSE8_V_M4_MASK + 0U, // PseudoVSSE8_V_M8 + 0U, // PseudoVSSE8_V_M8_MASK + 0U, // PseudoVSSE8_V_MF2 + 0U, // PseudoVSSE8_V_MF2_MASK + 0U, // PseudoVSSE8_V_MF4 + 0U, // PseudoVSSE8_V_MF4_MASK + 0U, // PseudoVSSE8_V_MF8 + 0U, // PseudoVSSE8_V_MF8_MASK + 0U, // PseudoVSSEG2E16_V_M1 + 0U, // PseudoVSSEG2E16_V_M1_MASK + 0U, // PseudoVSSEG2E16_V_M2 + 0U, // PseudoVSSEG2E16_V_M2_MASK + 0U, // PseudoVSSEG2E16_V_M4 + 0U, // PseudoVSSEG2E16_V_M4_MASK + 0U, // PseudoVSSEG2E16_V_MF2 + 0U, // PseudoVSSEG2E16_V_MF2_MASK + 0U, // PseudoVSSEG2E16_V_MF4 + 0U, // PseudoVSSEG2E16_V_MF4_MASK + 0U, // PseudoVSSEG2E32_V_M1 + 0U, // PseudoVSSEG2E32_V_M1_MASK + 0U, // PseudoVSSEG2E32_V_M2 + 0U, // PseudoVSSEG2E32_V_M2_MASK + 0U, // PseudoVSSEG2E32_V_M4 + 0U, // PseudoVSSEG2E32_V_M4_MASK + 0U, // PseudoVSSEG2E32_V_MF2 + 0U, // PseudoVSSEG2E32_V_MF2_MASK + 0U, // PseudoVSSEG2E64_V_M1 + 0U, // PseudoVSSEG2E64_V_M1_MASK + 0U, // PseudoVSSEG2E64_V_M2 + 0U, // PseudoVSSEG2E64_V_M2_MASK + 0U, // PseudoVSSEG2E64_V_M4 + 0U, // PseudoVSSEG2E64_V_M4_MASK + 0U, // PseudoVSSEG2E8_V_M1 + 0U, // PseudoVSSEG2E8_V_M1_MASK + 0U, // PseudoVSSEG2E8_V_M2 + 0U, // PseudoVSSEG2E8_V_M2_MASK + 0U, // PseudoVSSEG2E8_V_M4 + 0U, // PseudoVSSEG2E8_V_M4_MASK + 0U, // PseudoVSSEG2E8_V_MF2 + 0U, // PseudoVSSEG2E8_V_MF2_MASK + 0U, // PseudoVSSEG2E8_V_MF4 + 0U, // PseudoVSSEG2E8_V_MF4_MASK + 0U, // PseudoVSSEG2E8_V_MF8 + 0U, // PseudoVSSEG2E8_V_MF8_MASK + 0U, // PseudoVSSEG3E16_V_M1 + 0U, // PseudoVSSEG3E16_V_M1_MASK + 0U, // PseudoVSSEG3E16_V_M2 + 0U, // PseudoVSSEG3E16_V_M2_MASK + 0U, // PseudoVSSEG3E16_V_MF2 + 0U, // PseudoVSSEG3E16_V_MF2_MASK + 0U, // PseudoVSSEG3E16_V_MF4 + 0U, // PseudoVSSEG3E16_V_MF4_MASK + 0U, // PseudoVSSEG3E32_V_M1 + 0U, // PseudoVSSEG3E32_V_M1_MASK + 0U, // PseudoVSSEG3E32_V_M2 + 0U, // PseudoVSSEG3E32_V_M2_MASK + 0U, // PseudoVSSEG3E32_V_MF2 + 0U, // PseudoVSSEG3E32_V_MF2_MASK + 0U, // PseudoVSSEG3E64_V_M1 + 0U, // PseudoVSSEG3E64_V_M1_MASK + 0U, // PseudoVSSEG3E64_V_M2 + 0U, // PseudoVSSEG3E64_V_M2_MASK + 0U, // PseudoVSSEG3E8_V_M1 + 0U, // PseudoVSSEG3E8_V_M1_MASK + 0U, // PseudoVSSEG3E8_V_M2 + 0U, // PseudoVSSEG3E8_V_M2_MASK + 0U, // PseudoVSSEG3E8_V_MF2 + 0U, // PseudoVSSEG3E8_V_MF2_MASK + 0U, // PseudoVSSEG3E8_V_MF4 + 0U, // PseudoVSSEG3E8_V_MF4_MASK + 0U, // PseudoVSSEG3E8_V_MF8 + 0U, // PseudoVSSEG3E8_V_MF8_MASK + 0U, // PseudoVSSEG4E16_V_M1 + 0U, // PseudoVSSEG4E16_V_M1_MASK + 0U, // PseudoVSSEG4E16_V_M2 + 0U, // PseudoVSSEG4E16_V_M2_MASK + 0U, // PseudoVSSEG4E16_V_MF2 + 0U, // PseudoVSSEG4E16_V_MF2_MASK + 0U, // PseudoVSSEG4E16_V_MF4 + 0U, // PseudoVSSEG4E16_V_MF4_MASK + 0U, // PseudoVSSEG4E32_V_M1 + 0U, // PseudoVSSEG4E32_V_M1_MASK + 0U, // PseudoVSSEG4E32_V_M2 + 0U, // PseudoVSSEG4E32_V_M2_MASK + 0U, // PseudoVSSEG4E32_V_MF2 + 0U, // PseudoVSSEG4E32_V_MF2_MASK + 0U, // PseudoVSSEG4E64_V_M1 + 0U, // PseudoVSSEG4E64_V_M1_MASK + 0U, // PseudoVSSEG4E64_V_M2 + 0U, // PseudoVSSEG4E64_V_M2_MASK + 0U, // PseudoVSSEG4E8_V_M1 + 0U, // PseudoVSSEG4E8_V_M1_MASK + 0U, // PseudoVSSEG4E8_V_M2 + 0U, // PseudoVSSEG4E8_V_M2_MASK + 0U, // PseudoVSSEG4E8_V_MF2 + 0U, // PseudoVSSEG4E8_V_MF2_MASK + 0U, // PseudoVSSEG4E8_V_MF4 + 0U, // PseudoVSSEG4E8_V_MF4_MASK + 0U, // PseudoVSSEG4E8_V_MF8 + 0U, // PseudoVSSEG4E8_V_MF8_MASK + 0U, // PseudoVSSEG5E16_V_M1 + 0U, // PseudoVSSEG5E16_V_M1_MASK + 0U, // PseudoVSSEG5E16_V_MF2 + 0U, // PseudoVSSEG5E16_V_MF2_MASK + 0U, // PseudoVSSEG5E16_V_MF4 + 0U, // PseudoVSSEG5E16_V_MF4_MASK + 0U, // PseudoVSSEG5E32_V_M1 + 0U, // PseudoVSSEG5E32_V_M1_MASK + 0U, // PseudoVSSEG5E32_V_MF2 + 0U, // PseudoVSSEG5E32_V_MF2_MASK + 0U, // PseudoVSSEG5E64_V_M1 + 0U, // PseudoVSSEG5E64_V_M1_MASK + 0U, // PseudoVSSEG5E8_V_M1 + 0U, // PseudoVSSEG5E8_V_M1_MASK + 0U, // PseudoVSSEG5E8_V_MF2 + 0U, // PseudoVSSEG5E8_V_MF2_MASK + 0U, // PseudoVSSEG5E8_V_MF4 + 0U, // PseudoVSSEG5E8_V_MF4_MASK + 0U, // PseudoVSSEG5E8_V_MF8 + 0U, // PseudoVSSEG5E8_V_MF8_MASK + 0U, // PseudoVSSEG6E16_V_M1 + 0U, // PseudoVSSEG6E16_V_M1_MASK + 0U, // PseudoVSSEG6E16_V_MF2 + 0U, // PseudoVSSEG6E16_V_MF2_MASK + 0U, // PseudoVSSEG6E16_V_MF4 + 0U, // PseudoVSSEG6E16_V_MF4_MASK + 0U, // PseudoVSSEG6E32_V_M1 + 0U, // PseudoVSSEG6E32_V_M1_MASK + 0U, // PseudoVSSEG6E32_V_MF2 + 0U, // PseudoVSSEG6E32_V_MF2_MASK + 0U, // PseudoVSSEG6E64_V_M1 + 0U, // PseudoVSSEG6E64_V_M1_MASK + 0U, // PseudoVSSEG6E8_V_M1 + 0U, // PseudoVSSEG6E8_V_M1_MASK + 0U, // PseudoVSSEG6E8_V_MF2 + 0U, // PseudoVSSEG6E8_V_MF2_MASK + 0U, // PseudoVSSEG6E8_V_MF4 + 0U, // PseudoVSSEG6E8_V_MF4_MASK + 0U, // PseudoVSSEG6E8_V_MF8 + 0U, // PseudoVSSEG6E8_V_MF8_MASK + 0U, // PseudoVSSEG7E16_V_M1 + 0U, // PseudoVSSEG7E16_V_M1_MASK + 0U, // PseudoVSSEG7E16_V_MF2 + 0U, // PseudoVSSEG7E16_V_MF2_MASK + 0U, // PseudoVSSEG7E16_V_MF4 + 0U, // PseudoVSSEG7E16_V_MF4_MASK + 0U, // PseudoVSSEG7E32_V_M1 + 0U, // PseudoVSSEG7E32_V_M1_MASK + 0U, // PseudoVSSEG7E32_V_MF2 + 0U, // PseudoVSSEG7E32_V_MF2_MASK + 0U, // PseudoVSSEG7E64_V_M1 + 0U, // PseudoVSSEG7E64_V_M1_MASK + 0U, // PseudoVSSEG7E8_V_M1 + 0U, // PseudoVSSEG7E8_V_M1_MASK + 0U, // PseudoVSSEG7E8_V_MF2 + 0U, // PseudoVSSEG7E8_V_MF2_MASK + 0U, // PseudoVSSEG7E8_V_MF4 + 0U, // PseudoVSSEG7E8_V_MF4_MASK + 0U, // PseudoVSSEG7E8_V_MF8 + 0U, // PseudoVSSEG7E8_V_MF8_MASK + 0U, // PseudoVSSEG8E16_V_M1 + 0U, // PseudoVSSEG8E16_V_M1_MASK + 0U, // PseudoVSSEG8E16_V_MF2 + 0U, // PseudoVSSEG8E16_V_MF2_MASK + 0U, // PseudoVSSEG8E16_V_MF4 + 0U, // PseudoVSSEG8E16_V_MF4_MASK + 0U, // PseudoVSSEG8E32_V_M1 + 0U, // PseudoVSSEG8E32_V_M1_MASK + 0U, // PseudoVSSEG8E32_V_MF2 + 0U, // PseudoVSSEG8E32_V_MF2_MASK + 0U, // PseudoVSSEG8E64_V_M1 + 0U, // PseudoVSSEG8E64_V_M1_MASK + 0U, // PseudoVSSEG8E8_V_M1 + 0U, // PseudoVSSEG8E8_V_M1_MASK + 0U, // PseudoVSSEG8E8_V_MF2 + 0U, // PseudoVSSEG8E8_V_MF2_MASK + 0U, // PseudoVSSEG8E8_V_MF4 + 0U, // PseudoVSSEG8E8_V_MF4_MASK + 0U, // PseudoVSSEG8E8_V_MF8 + 0U, // PseudoVSSEG8E8_V_MF8_MASK + 0U, // PseudoVSSRA_VI_M1 + 0U, // PseudoVSSRA_VI_M1_MASK + 0U, // PseudoVSSRA_VI_M2 + 0U, // PseudoVSSRA_VI_M2_MASK + 0U, // PseudoVSSRA_VI_M4 + 0U, // PseudoVSSRA_VI_M4_MASK + 0U, // PseudoVSSRA_VI_M8 + 0U, // PseudoVSSRA_VI_M8_MASK + 0U, // PseudoVSSRA_VI_MF2 + 0U, // PseudoVSSRA_VI_MF2_MASK + 0U, // PseudoVSSRA_VI_MF4 + 0U, // PseudoVSSRA_VI_MF4_MASK + 0U, // PseudoVSSRA_VI_MF8 + 0U, // PseudoVSSRA_VI_MF8_MASK + 0U, // PseudoVSSRA_VV_M1 + 0U, // PseudoVSSRA_VV_M1_MASK + 0U, // PseudoVSSRA_VV_M2 + 0U, // PseudoVSSRA_VV_M2_MASK + 0U, // PseudoVSSRA_VV_M4 + 0U, // PseudoVSSRA_VV_M4_MASK + 0U, // PseudoVSSRA_VV_M8 + 0U, // PseudoVSSRA_VV_M8_MASK + 0U, // PseudoVSSRA_VV_MF2 + 0U, // PseudoVSSRA_VV_MF2_MASK + 0U, // PseudoVSSRA_VV_MF4 + 0U, // PseudoVSSRA_VV_MF4_MASK + 0U, // PseudoVSSRA_VV_MF8 + 0U, // PseudoVSSRA_VV_MF8_MASK + 0U, // PseudoVSSRA_VX_M1 + 0U, // PseudoVSSRA_VX_M1_MASK + 0U, // PseudoVSSRA_VX_M2 + 0U, // PseudoVSSRA_VX_M2_MASK + 0U, // PseudoVSSRA_VX_M4 + 0U, // PseudoVSSRA_VX_M4_MASK + 0U, // PseudoVSSRA_VX_M8 + 0U, // PseudoVSSRA_VX_M8_MASK + 0U, // PseudoVSSRA_VX_MF2 + 0U, // PseudoVSSRA_VX_MF2_MASK + 0U, // PseudoVSSRA_VX_MF4 + 0U, // PseudoVSSRA_VX_MF4_MASK + 0U, // PseudoVSSRA_VX_MF8 + 0U, // PseudoVSSRA_VX_MF8_MASK + 0U, // PseudoVSSRL_VI_M1 + 0U, // PseudoVSSRL_VI_M1_MASK + 0U, // PseudoVSSRL_VI_M2 + 0U, // PseudoVSSRL_VI_M2_MASK + 0U, // PseudoVSSRL_VI_M4 + 0U, // PseudoVSSRL_VI_M4_MASK + 0U, // PseudoVSSRL_VI_M8 + 0U, // PseudoVSSRL_VI_M8_MASK + 0U, // PseudoVSSRL_VI_MF2 + 0U, // PseudoVSSRL_VI_MF2_MASK + 0U, // PseudoVSSRL_VI_MF4 + 0U, // PseudoVSSRL_VI_MF4_MASK + 0U, // PseudoVSSRL_VI_MF8 + 0U, // PseudoVSSRL_VI_MF8_MASK + 0U, // PseudoVSSRL_VV_M1 + 0U, // PseudoVSSRL_VV_M1_MASK + 0U, // PseudoVSSRL_VV_M2 + 0U, // PseudoVSSRL_VV_M2_MASK + 0U, // PseudoVSSRL_VV_M4 + 0U, // PseudoVSSRL_VV_M4_MASK + 0U, // PseudoVSSRL_VV_M8 + 0U, // PseudoVSSRL_VV_M8_MASK + 0U, // PseudoVSSRL_VV_MF2 + 0U, // PseudoVSSRL_VV_MF2_MASK + 0U, // PseudoVSSRL_VV_MF4 + 0U, // PseudoVSSRL_VV_MF4_MASK + 0U, // PseudoVSSRL_VV_MF8 + 0U, // PseudoVSSRL_VV_MF8_MASK + 0U, // PseudoVSSRL_VX_M1 + 0U, // PseudoVSSRL_VX_M1_MASK + 0U, // PseudoVSSRL_VX_M2 + 0U, // PseudoVSSRL_VX_M2_MASK + 0U, // PseudoVSSRL_VX_M4 + 0U, // PseudoVSSRL_VX_M4_MASK + 0U, // PseudoVSSRL_VX_M8 + 0U, // PseudoVSSRL_VX_M8_MASK + 0U, // PseudoVSSRL_VX_MF2 + 0U, // PseudoVSSRL_VX_MF2_MASK + 0U, // PseudoVSSRL_VX_MF4 + 0U, // PseudoVSSRL_VX_MF4_MASK + 0U, // PseudoVSSRL_VX_MF8 + 0U, // PseudoVSSRL_VX_MF8_MASK + 0U, // PseudoVSSSEG2E16_V_M1 + 0U, // PseudoVSSSEG2E16_V_M1_MASK + 0U, // PseudoVSSSEG2E16_V_M2 + 0U, // PseudoVSSSEG2E16_V_M2_MASK + 0U, // PseudoVSSSEG2E16_V_M4 + 0U, // PseudoVSSSEG2E16_V_M4_MASK + 0U, // PseudoVSSSEG2E16_V_MF2 + 0U, // PseudoVSSSEG2E16_V_MF2_MASK + 0U, // PseudoVSSSEG2E16_V_MF4 + 0U, // PseudoVSSSEG2E16_V_MF4_MASK + 0U, // PseudoVSSSEG2E32_V_M1 + 0U, // PseudoVSSSEG2E32_V_M1_MASK + 0U, // PseudoVSSSEG2E32_V_M2 + 0U, // PseudoVSSSEG2E32_V_M2_MASK + 0U, // PseudoVSSSEG2E32_V_M4 + 0U, // PseudoVSSSEG2E32_V_M4_MASK + 0U, // PseudoVSSSEG2E32_V_MF2 + 0U, // PseudoVSSSEG2E32_V_MF2_MASK + 0U, // PseudoVSSSEG2E64_V_M1 + 0U, // PseudoVSSSEG2E64_V_M1_MASK + 0U, // PseudoVSSSEG2E64_V_M2 + 0U, // PseudoVSSSEG2E64_V_M2_MASK + 0U, // PseudoVSSSEG2E64_V_M4 + 0U, // PseudoVSSSEG2E64_V_M4_MASK + 0U, // PseudoVSSSEG2E8_V_M1 + 0U, // PseudoVSSSEG2E8_V_M1_MASK + 0U, // PseudoVSSSEG2E8_V_M2 + 0U, // PseudoVSSSEG2E8_V_M2_MASK + 0U, // PseudoVSSSEG2E8_V_M4 + 0U, // PseudoVSSSEG2E8_V_M4_MASK + 0U, // PseudoVSSSEG2E8_V_MF2 + 0U, // PseudoVSSSEG2E8_V_MF2_MASK + 0U, // PseudoVSSSEG2E8_V_MF4 + 0U, // PseudoVSSSEG2E8_V_MF4_MASK + 0U, // PseudoVSSSEG2E8_V_MF8 + 0U, // PseudoVSSSEG2E8_V_MF8_MASK + 0U, // PseudoVSSSEG3E16_V_M1 + 0U, // PseudoVSSSEG3E16_V_M1_MASK + 0U, // PseudoVSSSEG3E16_V_M2 + 0U, // PseudoVSSSEG3E16_V_M2_MASK + 0U, // PseudoVSSSEG3E16_V_MF2 + 0U, // PseudoVSSSEG3E16_V_MF2_MASK + 0U, // PseudoVSSSEG3E16_V_MF4 + 0U, // PseudoVSSSEG3E16_V_MF4_MASK + 0U, // PseudoVSSSEG3E32_V_M1 + 0U, // PseudoVSSSEG3E32_V_M1_MASK + 0U, // PseudoVSSSEG3E32_V_M2 + 0U, // PseudoVSSSEG3E32_V_M2_MASK + 0U, // PseudoVSSSEG3E32_V_MF2 + 0U, // PseudoVSSSEG3E32_V_MF2_MASK + 0U, // PseudoVSSSEG3E64_V_M1 + 0U, // PseudoVSSSEG3E64_V_M1_MASK + 0U, // PseudoVSSSEG3E64_V_M2 + 0U, // PseudoVSSSEG3E64_V_M2_MASK + 0U, // PseudoVSSSEG3E8_V_M1 + 0U, // PseudoVSSSEG3E8_V_M1_MASK + 0U, // PseudoVSSSEG3E8_V_M2 + 0U, // PseudoVSSSEG3E8_V_M2_MASK + 0U, // PseudoVSSSEG3E8_V_MF2 + 0U, // PseudoVSSSEG3E8_V_MF2_MASK + 0U, // PseudoVSSSEG3E8_V_MF4 + 0U, // PseudoVSSSEG3E8_V_MF4_MASK + 0U, // PseudoVSSSEG3E8_V_MF8 + 0U, // PseudoVSSSEG3E8_V_MF8_MASK + 0U, // PseudoVSSSEG4E16_V_M1 + 0U, // PseudoVSSSEG4E16_V_M1_MASK + 0U, // PseudoVSSSEG4E16_V_M2 + 0U, // PseudoVSSSEG4E16_V_M2_MASK + 0U, // PseudoVSSSEG4E16_V_MF2 + 0U, // PseudoVSSSEG4E16_V_MF2_MASK + 0U, // PseudoVSSSEG4E16_V_MF4 + 0U, // PseudoVSSSEG4E16_V_MF4_MASK + 0U, // PseudoVSSSEG4E32_V_M1 + 0U, // PseudoVSSSEG4E32_V_M1_MASK + 0U, // PseudoVSSSEG4E32_V_M2 + 0U, // PseudoVSSSEG4E32_V_M2_MASK + 0U, // PseudoVSSSEG4E32_V_MF2 + 0U, // PseudoVSSSEG4E32_V_MF2_MASK + 0U, // PseudoVSSSEG4E64_V_M1 + 0U, // PseudoVSSSEG4E64_V_M1_MASK + 0U, // PseudoVSSSEG4E64_V_M2 + 0U, // PseudoVSSSEG4E64_V_M2_MASK + 0U, // PseudoVSSSEG4E8_V_M1 + 0U, // PseudoVSSSEG4E8_V_M1_MASK + 0U, // PseudoVSSSEG4E8_V_M2 + 0U, // PseudoVSSSEG4E8_V_M2_MASK + 0U, // PseudoVSSSEG4E8_V_MF2 + 0U, // PseudoVSSSEG4E8_V_MF2_MASK + 0U, // PseudoVSSSEG4E8_V_MF4 + 0U, // PseudoVSSSEG4E8_V_MF4_MASK + 0U, // PseudoVSSSEG4E8_V_MF8 + 0U, // PseudoVSSSEG4E8_V_MF8_MASK + 0U, // PseudoVSSSEG5E16_V_M1 + 0U, // PseudoVSSSEG5E16_V_M1_MASK + 0U, // PseudoVSSSEG5E16_V_MF2 + 0U, // PseudoVSSSEG5E16_V_MF2_MASK + 0U, // PseudoVSSSEG5E16_V_MF4 + 0U, // PseudoVSSSEG5E16_V_MF4_MASK + 0U, // PseudoVSSSEG5E32_V_M1 + 0U, // PseudoVSSSEG5E32_V_M1_MASK + 0U, // PseudoVSSSEG5E32_V_MF2 + 0U, // PseudoVSSSEG5E32_V_MF2_MASK + 0U, // PseudoVSSSEG5E64_V_M1 + 0U, // PseudoVSSSEG5E64_V_M1_MASK + 0U, // PseudoVSSSEG5E8_V_M1 + 0U, // PseudoVSSSEG5E8_V_M1_MASK + 0U, // PseudoVSSSEG5E8_V_MF2 + 0U, // PseudoVSSSEG5E8_V_MF2_MASK + 0U, // PseudoVSSSEG5E8_V_MF4 + 0U, // PseudoVSSSEG5E8_V_MF4_MASK + 0U, // PseudoVSSSEG5E8_V_MF8 + 0U, // PseudoVSSSEG5E8_V_MF8_MASK + 0U, // PseudoVSSSEG6E16_V_M1 + 0U, // PseudoVSSSEG6E16_V_M1_MASK + 0U, // PseudoVSSSEG6E16_V_MF2 + 0U, // PseudoVSSSEG6E16_V_MF2_MASK + 0U, // PseudoVSSSEG6E16_V_MF4 + 0U, // PseudoVSSSEG6E16_V_MF4_MASK + 0U, // PseudoVSSSEG6E32_V_M1 + 0U, // PseudoVSSSEG6E32_V_M1_MASK + 0U, // PseudoVSSSEG6E32_V_MF2 + 0U, // PseudoVSSSEG6E32_V_MF2_MASK + 0U, // PseudoVSSSEG6E64_V_M1 + 0U, // PseudoVSSSEG6E64_V_M1_MASK + 0U, // PseudoVSSSEG6E8_V_M1 + 0U, // PseudoVSSSEG6E8_V_M1_MASK + 0U, // PseudoVSSSEG6E8_V_MF2 + 0U, // PseudoVSSSEG6E8_V_MF2_MASK + 0U, // PseudoVSSSEG6E8_V_MF4 + 0U, // PseudoVSSSEG6E8_V_MF4_MASK + 0U, // PseudoVSSSEG6E8_V_MF8 + 0U, // PseudoVSSSEG6E8_V_MF8_MASK + 0U, // PseudoVSSSEG7E16_V_M1 + 0U, // PseudoVSSSEG7E16_V_M1_MASK + 0U, // PseudoVSSSEG7E16_V_MF2 + 0U, // PseudoVSSSEG7E16_V_MF2_MASK + 0U, // PseudoVSSSEG7E16_V_MF4 + 0U, // PseudoVSSSEG7E16_V_MF4_MASK + 0U, // PseudoVSSSEG7E32_V_M1 + 0U, // PseudoVSSSEG7E32_V_M1_MASK + 0U, // PseudoVSSSEG7E32_V_MF2 + 0U, // PseudoVSSSEG7E32_V_MF2_MASK + 0U, // PseudoVSSSEG7E64_V_M1 + 0U, // PseudoVSSSEG7E64_V_M1_MASK + 0U, // PseudoVSSSEG7E8_V_M1 + 0U, // PseudoVSSSEG7E8_V_M1_MASK + 0U, // PseudoVSSSEG7E8_V_MF2 + 0U, // PseudoVSSSEG7E8_V_MF2_MASK + 0U, // PseudoVSSSEG7E8_V_MF4 + 0U, // PseudoVSSSEG7E8_V_MF4_MASK + 0U, // PseudoVSSSEG7E8_V_MF8 + 0U, // PseudoVSSSEG7E8_V_MF8_MASK + 0U, // PseudoVSSSEG8E16_V_M1 + 0U, // PseudoVSSSEG8E16_V_M1_MASK + 0U, // PseudoVSSSEG8E16_V_MF2 + 0U, // PseudoVSSSEG8E16_V_MF2_MASK + 0U, // PseudoVSSSEG8E16_V_MF4 + 0U, // PseudoVSSSEG8E16_V_MF4_MASK + 0U, // PseudoVSSSEG8E32_V_M1 + 0U, // PseudoVSSSEG8E32_V_M1_MASK + 0U, // PseudoVSSSEG8E32_V_MF2 + 0U, // PseudoVSSSEG8E32_V_MF2_MASK + 0U, // PseudoVSSSEG8E64_V_M1 + 0U, // PseudoVSSSEG8E64_V_M1_MASK + 0U, // PseudoVSSSEG8E8_V_M1 + 0U, // PseudoVSSSEG8E8_V_M1_MASK + 0U, // PseudoVSSSEG8E8_V_MF2 + 0U, // PseudoVSSSEG8E8_V_MF2_MASK + 0U, // PseudoVSSSEG8E8_V_MF4 + 0U, // PseudoVSSSEG8E8_V_MF4_MASK + 0U, // PseudoVSSSEG8E8_V_MF8 + 0U, // PseudoVSSSEG8E8_V_MF8_MASK + 0U, // PseudoVSSUBU_VV_M1 + 0U, // PseudoVSSUBU_VV_M1_MASK + 0U, // PseudoVSSUBU_VV_M2 + 0U, // PseudoVSSUBU_VV_M2_MASK + 0U, // PseudoVSSUBU_VV_M4 + 0U, // PseudoVSSUBU_VV_M4_MASK + 0U, // PseudoVSSUBU_VV_M8 + 0U, // PseudoVSSUBU_VV_M8_MASK + 0U, // PseudoVSSUBU_VV_MF2 + 0U, // PseudoVSSUBU_VV_MF2_MASK + 0U, // PseudoVSSUBU_VV_MF4 + 0U, // PseudoVSSUBU_VV_MF4_MASK + 0U, // PseudoVSSUBU_VV_MF8 + 0U, // PseudoVSSUBU_VV_MF8_MASK + 0U, // PseudoVSSUBU_VX_M1 + 0U, // PseudoVSSUBU_VX_M1_MASK + 0U, // PseudoVSSUBU_VX_M2 + 0U, // PseudoVSSUBU_VX_M2_MASK + 0U, // PseudoVSSUBU_VX_M4 + 0U, // PseudoVSSUBU_VX_M4_MASK + 0U, // PseudoVSSUBU_VX_M8 + 0U, // PseudoVSSUBU_VX_M8_MASK + 0U, // PseudoVSSUBU_VX_MF2 + 0U, // PseudoVSSUBU_VX_MF2_MASK + 0U, // PseudoVSSUBU_VX_MF4 + 0U, // PseudoVSSUBU_VX_MF4_MASK + 0U, // PseudoVSSUBU_VX_MF8 + 0U, // PseudoVSSUBU_VX_MF8_MASK + 0U, // PseudoVSSUB_VV_M1 + 0U, // PseudoVSSUB_VV_M1_MASK + 0U, // PseudoVSSUB_VV_M2 + 0U, // PseudoVSSUB_VV_M2_MASK + 0U, // PseudoVSSUB_VV_M4 + 0U, // PseudoVSSUB_VV_M4_MASK + 0U, // PseudoVSSUB_VV_M8 + 0U, // PseudoVSSUB_VV_M8_MASK + 0U, // PseudoVSSUB_VV_MF2 + 0U, // PseudoVSSUB_VV_MF2_MASK + 0U, // PseudoVSSUB_VV_MF4 + 0U, // PseudoVSSUB_VV_MF4_MASK + 0U, // PseudoVSSUB_VV_MF8 + 0U, // PseudoVSSUB_VV_MF8_MASK + 0U, // PseudoVSSUB_VX_M1 + 0U, // PseudoVSSUB_VX_M1_MASK + 0U, // PseudoVSSUB_VX_M2 + 0U, // PseudoVSSUB_VX_M2_MASK + 0U, // PseudoVSSUB_VX_M4 + 0U, // PseudoVSSUB_VX_M4_MASK + 0U, // PseudoVSSUB_VX_M8 + 0U, // PseudoVSSUB_VX_M8_MASK + 0U, // PseudoVSSUB_VX_MF2 + 0U, // PseudoVSSUB_VX_MF2_MASK + 0U, // PseudoVSSUB_VX_MF4 + 0U, // PseudoVSSUB_VX_MF4_MASK + 0U, // PseudoVSSUB_VX_MF8 + 0U, // PseudoVSSUB_VX_MF8_MASK + 0U, // PseudoVSUB_VV_M1 + 0U, // PseudoVSUB_VV_M1_MASK + 0U, // PseudoVSUB_VV_M2 + 0U, // PseudoVSUB_VV_M2_MASK + 0U, // PseudoVSUB_VV_M4 + 0U, // PseudoVSUB_VV_M4_MASK + 0U, // PseudoVSUB_VV_M8 + 0U, // PseudoVSUB_VV_M8_MASK + 0U, // PseudoVSUB_VV_MF2 + 0U, // PseudoVSUB_VV_MF2_MASK + 0U, // PseudoVSUB_VV_MF4 + 0U, // PseudoVSUB_VV_MF4_MASK + 0U, // PseudoVSUB_VV_MF8 + 0U, // PseudoVSUB_VV_MF8_MASK + 0U, // PseudoVSUB_VX_M1 + 0U, // PseudoVSUB_VX_M1_MASK + 0U, // PseudoVSUB_VX_M2 + 0U, // PseudoVSUB_VX_M2_MASK + 0U, // PseudoVSUB_VX_M4 + 0U, // PseudoVSUB_VX_M4_MASK + 0U, // PseudoVSUB_VX_M8 + 0U, // PseudoVSUB_VX_M8_MASK + 0U, // PseudoVSUB_VX_MF2 + 0U, // PseudoVSUB_VX_MF2_MASK + 0U, // PseudoVSUB_VX_MF4 + 0U, // PseudoVSUB_VX_MF4_MASK + 0U, // PseudoVSUB_VX_MF8 + 0U, // PseudoVSUB_VX_MF8_MASK + 0U, // PseudoVSUXEI16_V_M1_M1 + 0U, // PseudoVSUXEI16_V_M1_M1_MASK + 0U, // PseudoVSUXEI16_V_M1_M2 + 0U, // PseudoVSUXEI16_V_M1_M2_MASK + 0U, // PseudoVSUXEI16_V_M1_M4 + 0U, // PseudoVSUXEI16_V_M1_M4_MASK + 0U, // PseudoVSUXEI16_V_M1_MF2 + 0U, // PseudoVSUXEI16_V_M1_MF2_MASK + 0U, // PseudoVSUXEI16_V_M2_M1 + 0U, // PseudoVSUXEI16_V_M2_M1_MASK + 0U, // PseudoVSUXEI16_V_M2_M2 + 0U, // PseudoVSUXEI16_V_M2_M2_MASK + 0U, // PseudoVSUXEI16_V_M2_M4 + 0U, // PseudoVSUXEI16_V_M2_M4_MASK + 0U, // PseudoVSUXEI16_V_M2_M8 + 0U, // PseudoVSUXEI16_V_M2_M8_MASK + 0U, // PseudoVSUXEI16_V_M4_M2 + 0U, // PseudoVSUXEI16_V_M4_M2_MASK + 0U, // PseudoVSUXEI16_V_M4_M4 + 0U, // PseudoVSUXEI16_V_M4_M4_MASK + 0U, // PseudoVSUXEI16_V_M4_M8 + 0U, // PseudoVSUXEI16_V_M4_M8_MASK + 0U, // PseudoVSUXEI16_V_M8_M4 + 0U, // PseudoVSUXEI16_V_M8_M4_MASK + 0U, // PseudoVSUXEI16_V_M8_M8 + 0U, // PseudoVSUXEI16_V_M8_M8_MASK + 0U, // PseudoVSUXEI16_V_MF2_M1 + 0U, // PseudoVSUXEI16_V_MF2_M1_MASK + 0U, // PseudoVSUXEI16_V_MF2_M2 + 0U, // PseudoVSUXEI16_V_MF2_M2_MASK + 0U, // PseudoVSUXEI16_V_MF2_MF2 + 0U, // PseudoVSUXEI16_V_MF2_MF2_MASK + 0U, // PseudoVSUXEI16_V_MF2_MF4 + 0U, // PseudoVSUXEI16_V_MF2_MF4_MASK + 0U, // PseudoVSUXEI16_V_MF4_M1 + 0U, // PseudoVSUXEI16_V_MF4_M1_MASK + 0U, // PseudoVSUXEI16_V_MF4_MF2 + 0U, // PseudoVSUXEI16_V_MF4_MF2_MASK + 0U, // PseudoVSUXEI16_V_MF4_MF4 + 0U, // PseudoVSUXEI16_V_MF4_MF4_MASK + 0U, // PseudoVSUXEI16_V_MF4_MF8 + 0U, // PseudoVSUXEI16_V_MF4_MF8_MASK + 0U, // PseudoVSUXEI32_V_M1_M1 + 0U, // PseudoVSUXEI32_V_M1_M1_MASK + 0U, // PseudoVSUXEI32_V_M1_M2 + 0U, // PseudoVSUXEI32_V_M1_M2_MASK + 0U, // PseudoVSUXEI32_V_M1_MF2 + 0U, // PseudoVSUXEI32_V_M1_MF2_MASK + 0U, // PseudoVSUXEI32_V_M1_MF4 + 0U, // PseudoVSUXEI32_V_M1_MF4_MASK + 0U, // PseudoVSUXEI32_V_M2_M1 + 0U, // PseudoVSUXEI32_V_M2_M1_MASK + 0U, // PseudoVSUXEI32_V_M2_M2 + 0U, // PseudoVSUXEI32_V_M2_M2_MASK + 0U, // PseudoVSUXEI32_V_M2_M4 + 0U, // PseudoVSUXEI32_V_M2_M4_MASK + 0U, // PseudoVSUXEI32_V_M2_MF2 + 0U, // PseudoVSUXEI32_V_M2_MF2_MASK + 0U, // PseudoVSUXEI32_V_M4_M1 + 0U, // PseudoVSUXEI32_V_M4_M1_MASK + 0U, // PseudoVSUXEI32_V_M4_M2 + 0U, // PseudoVSUXEI32_V_M4_M2_MASK + 0U, // PseudoVSUXEI32_V_M4_M4 + 0U, // PseudoVSUXEI32_V_M4_M4_MASK + 0U, // PseudoVSUXEI32_V_M4_M8 + 0U, // PseudoVSUXEI32_V_M4_M8_MASK + 0U, // PseudoVSUXEI32_V_M8_M2 + 0U, // PseudoVSUXEI32_V_M8_M2_MASK + 0U, // PseudoVSUXEI32_V_M8_M4 + 0U, // PseudoVSUXEI32_V_M8_M4_MASK + 0U, // PseudoVSUXEI32_V_M8_M8 + 0U, // PseudoVSUXEI32_V_M8_M8_MASK + 0U, // PseudoVSUXEI32_V_MF2_M1 + 0U, // PseudoVSUXEI32_V_MF2_M1_MASK + 0U, // PseudoVSUXEI32_V_MF2_MF2 + 0U, // PseudoVSUXEI32_V_MF2_MF2_MASK + 0U, // PseudoVSUXEI32_V_MF2_MF4 + 0U, // PseudoVSUXEI32_V_MF2_MF4_MASK + 0U, // PseudoVSUXEI32_V_MF2_MF8 + 0U, // PseudoVSUXEI32_V_MF2_MF8_MASK + 0U, // PseudoVSUXEI64_V_M1_M1 + 0U, // PseudoVSUXEI64_V_M1_M1_MASK + 0U, // PseudoVSUXEI64_V_M1_MF2 + 0U, // PseudoVSUXEI64_V_M1_MF2_MASK + 0U, // PseudoVSUXEI64_V_M1_MF4 + 0U, // PseudoVSUXEI64_V_M1_MF4_MASK + 0U, // PseudoVSUXEI64_V_M1_MF8 + 0U, // PseudoVSUXEI64_V_M1_MF8_MASK + 0U, // PseudoVSUXEI64_V_M2_M1 + 0U, // PseudoVSUXEI64_V_M2_M1_MASK + 0U, // PseudoVSUXEI64_V_M2_M2 + 0U, // PseudoVSUXEI64_V_M2_M2_MASK + 0U, // PseudoVSUXEI64_V_M2_MF2 + 0U, // PseudoVSUXEI64_V_M2_MF2_MASK + 0U, // PseudoVSUXEI64_V_M2_MF4 + 0U, // PseudoVSUXEI64_V_M2_MF4_MASK + 0U, // PseudoVSUXEI64_V_M4_M1 + 0U, // PseudoVSUXEI64_V_M4_M1_MASK + 0U, // PseudoVSUXEI64_V_M4_M2 + 0U, // PseudoVSUXEI64_V_M4_M2_MASK + 0U, // PseudoVSUXEI64_V_M4_M4 + 0U, // PseudoVSUXEI64_V_M4_M4_MASK + 0U, // PseudoVSUXEI64_V_M4_MF2 + 0U, // PseudoVSUXEI64_V_M4_MF2_MASK + 0U, // PseudoVSUXEI64_V_M8_M1 + 0U, // PseudoVSUXEI64_V_M8_M1_MASK + 0U, // PseudoVSUXEI64_V_M8_M2 + 0U, // PseudoVSUXEI64_V_M8_M2_MASK + 0U, // PseudoVSUXEI64_V_M8_M4 + 0U, // PseudoVSUXEI64_V_M8_M4_MASK + 0U, // PseudoVSUXEI64_V_M8_M8 + 0U, // PseudoVSUXEI64_V_M8_M8_MASK + 0U, // PseudoVSUXEI8_V_M1_M1 + 0U, // PseudoVSUXEI8_V_M1_M1_MASK + 0U, // PseudoVSUXEI8_V_M1_M2 + 0U, // PseudoVSUXEI8_V_M1_M2_MASK + 0U, // PseudoVSUXEI8_V_M1_M4 + 0U, // PseudoVSUXEI8_V_M1_M4_MASK + 0U, // PseudoVSUXEI8_V_M1_M8 + 0U, // PseudoVSUXEI8_V_M1_M8_MASK + 0U, // PseudoVSUXEI8_V_M2_M2 + 0U, // PseudoVSUXEI8_V_M2_M2_MASK + 0U, // PseudoVSUXEI8_V_M2_M4 + 0U, // PseudoVSUXEI8_V_M2_M4_MASK + 0U, // PseudoVSUXEI8_V_M2_M8 + 0U, // PseudoVSUXEI8_V_M2_M8_MASK + 0U, // PseudoVSUXEI8_V_M4_M4 + 0U, // PseudoVSUXEI8_V_M4_M4_MASK + 0U, // PseudoVSUXEI8_V_M4_M8 + 0U, // PseudoVSUXEI8_V_M4_M8_MASK + 0U, // PseudoVSUXEI8_V_M8_M8 + 0U, // PseudoVSUXEI8_V_M8_M8_MASK + 0U, // PseudoVSUXEI8_V_MF2_M1 + 0U, // PseudoVSUXEI8_V_MF2_M1_MASK + 0U, // PseudoVSUXEI8_V_MF2_M2 + 0U, // PseudoVSUXEI8_V_MF2_M2_MASK + 0U, // PseudoVSUXEI8_V_MF2_M4 + 0U, // PseudoVSUXEI8_V_MF2_M4_MASK + 0U, // PseudoVSUXEI8_V_MF2_MF2 + 0U, // PseudoVSUXEI8_V_MF2_MF2_MASK + 0U, // PseudoVSUXEI8_V_MF4_M1 + 0U, // PseudoVSUXEI8_V_MF4_M1_MASK + 0U, // PseudoVSUXEI8_V_MF4_M2 + 0U, // PseudoVSUXEI8_V_MF4_M2_MASK + 0U, // PseudoVSUXEI8_V_MF4_MF2 + 0U, // PseudoVSUXEI8_V_MF4_MF2_MASK + 0U, // PseudoVSUXEI8_V_MF4_MF4 + 0U, // PseudoVSUXEI8_V_MF4_MF4_MASK + 0U, // PseudoVSUXEI8_V_MF8_M1 + 0U, // PseudoVSUXEI8_V_MF8_M1_MASK + 0U, // PseudoVSUXEI8_V_MF8_MF2 + 0U, // PseudoVSUXEI8_V_MF8_MF2_MASK + 0U, // PseudoVSUXEI8_V_MF8_MF4 + 0U, // PseudoVSUXEI8_V_MF8_MF4_MASK + 0U, // PseudoVSUXEI8_V_MF8_MF8 + 0U, // PseudoVSUXEI8_V_MF8_MF8_MASK + 0U, // PseudoVSUXSEG2EI16_V_M1_M1 + 0U, // PseudoVSUXSEG2EI16_V_M1_M1_MASK + 0U, // PseudoVSUXSEG2EI16_V_M1_M2 + 0U, // PseudoVSUXSEG2EI16_V_M1_M2_MASK + 0U, // PseudoVSUXSEG2EI16_V_M1_M4 + 0U, // PseudoVSUXSEG2EI16_V_M1_M4_MASK + 0U, // PseudoVSUXSEG2EI16_V_M1_MF2 + 0U, // PseudoVSUXSEG2EI16_V_M1_MF2_MASK + 0U, // PseudoVSUXSEG2EI16_V_M2_M1 + 0U, // PseudoVSUXSEG2EI16_V_M2_M1_MASK + 0U, // PseudoVSUXSEG2EI16_V_M2_M2 + 0U, // PseudoVSUXSEG2EI16_V_M2_M2_MASK + 0U, // PseudoVSUXSEG2EI16_V_M2_M4 + 0U, // PseudoVSUXSEG2EI16_V_M2_M4_MASK + 0U, // PseudoVSUXSEG2EI16_V_M4_M2 + 0U, // PseudoVSUXSEG2EI16_V_M4_M2_MASK + 0U, // PseudoVSUXSEG2EI16_V_M4_M4 + 0U, // PseudoVSUXSEG2EI16_V_M4_M4_MASK + 0U, // PseudoVSUXSEG2EI16_V_M8_M4 + 0U, // PseudoVSUXSEG2EI16_V_M8_M4_MASK + 0U, // PseudoVSUXSEG2EI16_V_MF2_M1 + 0U, // PseudoVSUXSEG2EI16_V_MF2_M1_MASK + 0U, // PseudoVSUXSEG2EI16_V_MF2_M2 + 0U, // PseudoVSUXSEG2EI16_V_MF2_M2_MASK + 0U, // PseudoVSUXSEG2EI16_V_MF2_MF2 + 0U, // PseudoVSUXSEG2EI16_V_MF2_MF2_MASK + 0U, // PseudoVSUXSEG2EI16_V_MF2_MF4 + 0U, // PseudoVSUXSEG2EI16_V_MF2_MF4_MASK + 0U, // PseudoVSUXSEG2EI16_V_MF4_M1 + 0U, // PseudoVSUXSEG2EI16_V_MF4_M1_MASK + 0U, // PseudoVSUXSEG2EI16_V_MF4_MF2 + 0U, // PseudoVSUXSEG2EI16_V_MF4_MF2_MASK + 0U, // PseudoVSUXSEG2EI16_V_MF4_MF4 + 0U, // PseudoVSUXSEG2EI16_V_MF4_MF4_MASK + 0U, // PseudoVSUXSEG2EI16_V_MF4_MF8 + 0U, // PseudoVSUXSEG2EI16_V_MF4_MF8_MASK + 0U, // PseudoVSUXSEG2EI32_V_M1_M1 + 0U, // PseudoVSUXSEG2EI32_V_M1_M1_MASK + 0U, // PseudoVSUXSEG2EI32_V_M1_M2 + 0U, // PseudoVSUXSEG2EI32_V_M1_M2_MASK + 0U, // PseudoVSUXSEG2EI32_V_M1_MF2 + 0U, // PseudoVSUXSEG2EI32_V_M1_MF2_MASK + 0U, // PseudoVSUXSEG2EI32_V_M1_MF4 + 0U, // PseudoVSUXSEG2EI32_V_M1_MF4_MASK + 0U, // PseudoVSUXSEG2EI32_V_M2_M1 + 0U, // PseudoVSUXSEG2EI32_V_M2_M1_MASK + 0U, // PseudoVSUXSEG2EI32_V_M2_M2 + 0U, // PseudoVSUXSEG2EI32_V_M2_M2_MASK + 0U, // PseudoVSUXSEG2EI32_V_M2_M4 + 0U, // PseudoVSUXSEG2EI32_V_M2_M4_MASK + 0U, // PseudoVSUXSEG2EI32_V_M2_MF2 + 0U, // PseudoVSUXSEG2EI32_V_M2_MF2_MASK + 0U, // PseudoVSUXSEG2EI32_V_M4_M1 + 0U, // PseudoVSUXSEG2EI32_V_M4_M1_MASK + 0U, // PseudoVSUXSEG2EI32_V_M4_M2 + 0U, // PseudoVSUXSEG2EI32_V_M4_M2_MASK + 0U, // PseudoVSUXSEG2EI32_V_M4_M4 + 0U, // PseudoVSUXSEG2EI32_V_M4_M4_MASK + 0U, // PseudoVSUXSEG2EI32_V_M8_M2 + 0U, // PseudoVSUXSEG2EI32_V_M8_M2_MASK + 0U, // PseudoVSUXSEG2EI32_V_M8_M4 + 0U, // PseudoVSUXSEG2EI32_V_M8_M4_MASK + 0U, // PseudoVSUXSEG2EI32_V_MF2_M1 + 0U, // PseudoVSUXSEG2EI32_V_MF2_M1_MASK + 0U, // PseudoVSUXSEG2EI32_V_MF2_MF2 + 0U, // PseudoVSUXSEG2EI32_V_MF2_MF2_MASK + 0U, // PseudoVSUXSEG2EI32_V_MF2_MF4 + 0U, // PseudoVSUXSEG2EI32_V_MF2_MF4_MASK + 0U, // PseudoVSUXSEG2EI32_V_MF2_MF8 + 0U, // PseudoVSUXSEG2EI32_V_MF2_MF8_MASK + 0U, // PseudoVSUXSEG2EI64_V_M1_M1 + 0U, // PseudoVSUXSEG2EI64_V_M1_M1_MASK + 0U, // PseudoVSUXSEG2EI64_V_M1_MF2 + 0U, // PseudoVSUXSEG2EI64_V_M1_MF2_MASK + 0U, // PseudoVSUXSEG2EI64_V_M1_MF4 + 0U, // PseudoVSUXSEG2EI64_V_M1_MF4_MASK + 0U, // PseudoVSUXSEG2EI64_V_M1_MF8 + 0U, // PseudoVSUXSEG2EI64_V_M1_MF8_MASK + 0U, // PseudoVSUXSEG2EI64_V_M2_M1 + 0U, // PseudoVSUXSEG2EI64_V_M2_M1_MASK + 0U, // PseudoVSUXSEG2EI64_V_M2_M2 + 0U, // PseudoVSUXSEG2EI64_V_M2_M2_MASK + 0U, // PseudoVSUXSEG2EI64_V_M2_MF2 + 0U, // PseudoVSUXSEG2EI64_V_M2_MF2_MASK + 0U, // PseudoVSUXSEG2EI64_V_M2_MF4 + 0U, // PseudoVSUXSEG2EI64_V_M2_MF4_MASK + 0U, // PseudoVSUXSEG2EI64_V_M4_M1 + 0U, // PseudoVSUXSEG2EI64_V_M4_M1_MASK + 0U, // PseudoVSUXSEG2EI64_V_M4_M2 + 0U, // PseudoVSUXSEG2EI64_V_M4_M2_MASK + 0U, // PseudoVSUXSEG2EI64_V_M4_M4 + 0U, // PseudoVSUXSEG2EI64_V_M4_M4_MASK + 0U, // PseudoVSUXSEG2EI64_V_M4_MF2 + 0U, // PseudoVSUXSEG2EI64_V_M4_MF2_MASK + 0U, // PseudoVSUXSEG2EI64_V_M8_M1 + 0U, // PseudoVSUXSEG2EI64_V_M8_M1_MASK + 0U, // PseudoVSUXSEG2EI64_V_M8_M2 + 0U, // PseudoVSUXSEG2EI64_V_M8_M2_MASK + 0U, // PseudoVSUXSEG2EI64_V_M8_M4 + 0U, // PseudoVSUXSEG2EI64_V_M8_M4_MASK + 0U, // PseudoVSUXSEG2EI8_V_M1_M1 + 0U, // PseudoVSUXSEG2EI8_V_M1_M1_MASK + 0U, // PseudoVSUXSEG2EI8_V_M1_M2 + 0U, // PseudoVSUXSEG2EI8_V_M1_M2_MASK + 0U, // PseudoVSUXSEG2EI8_V_M1_M4 + 0U, // PseudoVSUXSEG2EI8_V_M1_M4_MASK + 0U, // PseudoVSUXSEG2EI8_V_M2_M2 + 0U, // PseudoVSUXSEG2EI8_V_M2_M2_MASK + 0U, // PseudoVSUXSEG2EI8_V_M2_M4 + 0U, // PseudoVSUXSEG2EI8_V_M2_M4_MASK + 0U, // PseudoVSUXSEG2EI8_V_M4_M4 + 0U, // PseudoVSUXSEG2EI8_V_M4_M4_MASK + 0U, // PseudoVSUXSEG2EI8_V_MF2_M1 + 0U, // PseudoVSUXSEG2EI8_V_MF2_M1_MASK + 0U, // PseudoVSUXSEG2EI8_V_MF2_M2 + 0U, // PseudoVSUXSEG2EI8_V_MF2_M2_MASK + 0U, // PseudoVSUXSEG2EI8_V_MF2_M4 + 0U, // PseudoVSUXSEG2EI8_V_MF2_M4_MASK + 0U, // PseudoVSUXSEG2EI8_V_MF2_MF2 + 0U, // PseudoVSUXSEG2EI8_V_MF2_MF2_MASK + 0U, // PseudoVSUXSEG2EI8_V_MF4_M1 + 0U, // PseudoVSUXSEG2EI8_V_MF4_M1_MASK + 0U, // PseudoVSUXSEG2EI8_V_MF4_M2 + 0U, // PseudoVSUXSEG2EI8_V_MF4_M2_MASK + 0U, // PseudoVSUXSEG2EI8_V_MF4_MF2 + 0U, // PseudoVSUXSEG2EI8_V_MF4_MF2_MASK + 0U, // PseudoVSUXSEG2EI8_V_MF4_MF4 + 0U, // PseudoVSUXSEG2EI8_V_MF4_MF4_MASK + 0U, // PseudoVSUXSEG2EI8_V_MF8_M1 + 0U, // PseudoVSUXSEG2EI8_V_MF8_M1_MASK + 0U, // PseudoVSUXSEG2EI8_V_MF8_MF2 + 0U, // PseudoVSUXSEG2EI8_V_MF8_MF2_MASK + 0U, // PseudoVSUXSEG2EI8_V_MF8_MF4 + 0U, // PseudoVSUXSEG2EI8_V_MF8_MF4_MASK + 0U, // PseudoVSUXSEG2EI8_V_MF8_MF8 + 0U, // PseudoVSUXSEG2EI8_V_MF8_MF8_MASK + 0U, // PseudoVSUXSEG3EI16_V_M1_M1 + 0U, // PseudoVSUXSEG3EI16_V_M1_M1_MASK + 0U, // PseudoVSUXSEG3EI16_V_M1_M2 + 0U, // PseudoVSUXSEG3EI16_V_M1_M2_MASK + 0U, // PseudoVSUXSEG3EI16_V_M1_MF2 + 0U, // PseudoVSUXSEG3EI16_V_M1_MF2_MASK + 0U, // PseudoVSUXSEG3EI16_V_M2_M1 + 0U, // PseudoVSUXSEG3EI16_V_M2_M1_MASK + 0U, // PseudoVSUXSEG3EI16_V_M2_M2 + 0U, // PseudoVSUXSEG3EI16_V_M2_M2_MASK + 0U, // PseudoVSUXSEG3EI16_V_M4_M2 + 0U, // PseudoVSUXSEG3EI16_V_M4_M2_MASK + 0U, // PseudoVSUXSEG3EI16_V_MF2_M1 + 0U, // PseudoVSUXSEG3EI16_V_MF2_M1_MASK + 0U, // PseudoVSUXSEG3EI16_V_MF2_M2 + 0U, // PseudoVSUXSEG3EI16_V_MF2_M2_MASK + 0U, // PseudoVSUXSEG3EI16_V_MF2_MF2 + 0U, // PseudoVSUXSEG3EI16_V_MF2_MF2_MASK + 0U, // PseudoVSUXSEG3EI16_V_MF2_MF4 + 0U, // PseudoVSUXSEG3EI16_V_MF2_MF4_MASK + 0U, // PseudoVSUXSEG3EI16_V_MF4_M1 + 0U, // PseudoVSUXSEG3EI16_V_MF4_M1_MASK + 0U, // PseudoVSUXSEG3EI16_V_MF4_MF2 + 0U, // PseudoVSUXSEG3EI16_V_MF4_MF2_MASK + 0U, // PseudoVSUXSEG3EI16_V_MF4_MF4 + 0U, // PseudoVSUXSEG3EI16_V_MF4_MF4_MASK + 0U, // PseudoVSUXSEG3EI16_V_MF4_MF8 + 0U, // PseudoVSUXSEG3EI16_V_MF4_MF8_MASK + 0U, // PseudoVSUXSEG3EI32_V_M1_M1 + 0U, // PseudoVSUXSEG3EI32_V_M1_M1_MASK + 0U, // PseudoVSUXSEG3EI32_V_M1_M2 + 0U, // PseudoVSUXSEG3EI32_V_M1_M2_MASK + 0U, // PseudoVSUXSEG3EI32_V_M1_MF2 + 0U, // PseudoVSUXSEG3EI32_V_M1_MF2_MASK + 0U, // PseudoVSUXSEG3EI32_V_M1_MF4 + 0U, // PseudoVSUXSEG3EI32_V_M1_MF4_MASK + 0U, // PseudoVSUXSEG3EI32_V_M2_M1 + 0U, // PseudoVSUXSEG3EI32_V_M2_M1_MASK + 0U, // PseudoVSUXSEG3EI32_V_M2_M2 + 0U, // PseudoVSUXSEG3EI32_V_M2_M2_MASK + 0U, // PseudoVSUXSEG3EI32_V_M2_MF2 + 0U, // PseudoVSUXSEG3EI32_V_M2_MF2_MASK + 0U, // PseudoVSUXSEG3EI32_V_M4_M1 + 0U, // PseudoVSUXSEG3EI32_V_M4_M1_MASK + 0U, // PseudoVSUXSEG3EI32_V_M4_M2 + 0U, // PseudoVSUXSEG3EI32_V_M4_M2_MASK + 0U, // PseudoVSUXSEG3EI32_V_M8_M2 + 0U, // PseudoVSUXSEG3EI32_V_M8_M2_MASK + 0U, // PseudoVSUXSEG3EI32_V_MF2_M1 + 0U, // PseudoVSUXSEG3EI32_V_MF2_M1_MASK + 0U, // PseudoVSUXSEG3EI32_V_MF2_MF2 + 0U, // PseudoVSUXSEG3EI32_V_MF2_MF2_MASK + 0U, // PseudoVSUXSEG3EI32_V_MF2_MF4 + 0U, // PseudoVSUXSEG3EI32_V_MF2_MF4_MASK + 0U, // PseudoVSUXSEG3EI32_V_MF2_MF8 + 0U, // PseudoVSUXSEG3EI32_V_MF2_MF8_MASK + 0U, // PseudoVSUXSEG3EI64_V_M1_M1 + 0U, // PseudoVSUXSEG3EI64_V_M1_M1_MASK + 0U, // PseudoVSUXSEG3EI64_V_M1_MF2 + 0U, // PseudoVSUXSEG3EI64_V_M1_MF2_MASK + 0U, // PseudoVSUXSEG3EI64_V_M1_MF4 + 0U, // PseudoVSUXSEG3EI64_V_M1_MF4_MASK + 0U, // PseudoVSUXSEG3EI64_V_M1_MF8 + 0U, // PseudoVSUXSEG3EI64_V_M1_MF8_MASK + 0U, // PseudoVSUXSEG3EI64_V_M2_M1 + 0U, // PseudoVSUXSEG3EI64_V_M2_M1_MASK + 0U, // PseudoVSUXSEG3EI64_V_M2_M2 + 0U, // PseudoVSUXSEG3EI64_V_M2_M2_MASK + 0U, // PseudoVSUXSEG3EI64_V_M2_MF2 + 0U, // PseudoVSUXSEG3EI64_V_M2_MF2_MASK + 0U, // PseudoVSUXSEG3EI64_V_M2_MF4 + 0U, // PseudoVSUXSEG3EI64_V_M2_MF4_MASK + 0U, // PseudoVSUXSEG3EI64_V_M4_M1 + 0U, // PseudoVSUXSEG3EI64_V_M4_M1_MASK + 0U, // PseudoVSUXSEG3EI64_V_M4_M2 + 0U, // PseudoVSUXSEG3EI64_V_M4_M2_MASK + 0U, // PseudoVSUXSEG3EI64_V_M4_MF2 + 0U, // PseudoVSUXSEG3EI64_V_M4_MF2_MASK + 0U, // PseudoVSUXSEG3EI64_V_M8_M1 + 0U, // PseudoVSUXSEG3EI64_V_M8_M1_MASK + 0U, // PseudoVSUXSEG3EI64_V_M8_M2 + 0U, // PseudoVSUXSEG3EI64_V_M8_M2_MASK + 0U, // PseudoVSUXSEG3EI8_V_M1_M1 + 0U, // PseudoVSUXSEG3EI8_V_M1_M1_MASK + 0U, // PseudoVSUXSEG3EI8_V_M1_M2 + 0U, // PseudoVSUXSEG3EI8_V_M1_M2_MASK + 0U, // PseudoVSUXSEG3EI8_V_M2_M2 + 0U, // PseudoVSUXSEG3EI8_V_M2_M2_MASK + 0U, // PseudoVSUXSEG3EI8_V_MF2_M1 + 0U, // PseudoVSUXSEG3EI8_V_MF2_M1_MASK + 0U, // PseudoVSUXSEG3EI8_V_MF2_M2 + 0U, // PseudoVSUXSEG3EI8_V_MF2_M2_MASK + 0U, // PseudoVSUXSEG3EI8_V_MF2_MF2 + 0U, // PseudoVSUXSEG3EI8_V_MF2_MF2_MASK + 0U, // PseudoVSUXSEG3EI8_V_MF4_M1 + 0U, // PseudoVSUXSEG3EI8_V_MF4_M1_MASK + 0U, // PseudoVSUXSEG3EI8_V_MF4_M2 + 0U, // PseudoVSUXSEG3EI8_V_MF4_M2_MASK + 0U, // PseudoVSUXSEG3EI8_V_MF4_MF2 + 0U, // PseudoVSUXSEG3EI8_V_MF4_MF2_MASK + 0U, // PseudoVSUXSEG3EI8_V_MF4_MF4 + 0U, // PseudoVSUXSEG3EI8_V_MF4_MF4_MASK + 0U, // PseudoVSUXSEG3EI8_V_MF8_M1 + 0U, // PseudoVSUXSEG3EI8_V_MF8_M1_MASK + 0U, // PseudoVSUXSEG3EI8_V_MF8_MF2 + 0U, // PseudoVSUXSEG3EI8_V_MF8_MF2_MASK + 0U, // PseudoVSUXSEG3EI8_V_MF8_MF4 + 0U, // PseudoVSUXSEG3EI8_V_MF8_MF4_MASK + 0U, // PseudoVSUXSEG3EI8_V_MF8_MF8 + 0U, // PseudoVSUXSEG3EI8_V_MF8_MF8_MASK + 0U, // PseudoVSUXSEG4EI16_V_M1_M1 + 0U, // PseudoVSUXSEG4EI16_V_M1_M1_MASK + 0U, // PseudoVSUXSEG4EI16_V_M1_M2 + 0U, // PseudoVSUXSEG4EI16_V_M1_M2_MASK + 0U, // PseudoVSUXSEG4EI16_V_M1_MF2 + 0U, // PseudoVSUXSEG4EI16_V_M1_MF2_MASK + 0U, // PseudoVSUXSEG4EI16_V_M2_M1 + 0U, // PseudoVSUXSEG4EI16_V_M2_M1_MASK + 0U, // PseudoVSUXSEG4EI16_V_M2_M2 + 0U, // PseudoVSUXSEG4EI16_V_M2_M2_MASK + 0U, // PseudoVSUXSEG4EI16_V_M4_M2 + 0U, // PseudoVSUXSEG4EI16_V_M4_M2_MASK + 0U, // PseudoVSUXSEG4EI16_V_MF2_M1 + 0U, // PseudoVSUXSEG4EI16_V_MF2_M1_MASK + 0U, // PseudoVSUXSEG4EI16_V_MF2_M2 + 0U, // PseudoVSUXSEG4EI16_V_MF2_M2_MASK + 0U, // PseudoVSUXSEG4EI16_V_MF2_MF2 + 0U, // PseudoVSUXSEG4EI16_V_MF2_MF2_MASK + 0U, // PseudoVSUXSEG4EI16_V_MF2_MF4 + 0U, // PseudoVSUXSEG4EI16_V_MF2_MF4_MASK + 0U, // PseudoVSUXSEG4EI16_V_MF4_M1 + 0U, // PseudoVSUXSEG4EI16_V_MF4_M1_MASK + 0U, // PseudoVSUXSEG4EI16_V_MF4_MF2 + 0U, // PseudoVSUXSEG4EI16_V_MF4_MF2_MASK + 0U, // PseudoVSUXSEG4EI16_V_MF4_MF4 + 0U, // PseudoVSUXSEG4EI16_V_MF4_MF4_MASK + 0U, // PseudoVSUXSEG4EI16_V_MF4_MF8 + 0U, // PseudoVSUXSEG4EI16_V_MF4_MF8_MASK + 0U, // PseudoVSUXSEG4EI32_V_M1_M1 + 0U, // PseudoVSUXSEG4EI32_V_M1_M1_MASK + 0U, // PseudoVSUXSEG4EI32_V_M1_M2 + 0U, // PseudoVSUXSEG4EI32_V_M1_M2_MASK + 0U, // PseudoVSUXSEG4EI32_V_M1_MF2 + 0U, // PseudoVSUXSEG4EI32_V_M1_MF2_MASK + 0U, // PseudoVSUXSEG4EI32_V_M1_MF4 + 0U, // PseudoVSUXSEG4EI32_V_M1_MF4_MASK + 0U, // PseudoVSUXSEG4EI32_V_M2_M1 + 0U, // PseudoVSUXSEG4EI32_V_M2_M1_MASK + 0U, // PseudoVSUXSEG4EI32_V_M2_M2 + 0U, // PseudoVSUXSEG4EI32_V_M2_M2_MASK + 0U, // PseudoVSUXSEG4EI32_V_M2_MF2 + 0U, // PseudoVSUXSEG4EI32_V_M2_MF2_MASK + 0U, // PseudoVSUXSEG4EI32_V_M4_M1 + 0U, // PseudoVSUXSEG4EI32_V_M4_M1_MASK + 0U, // PseudoVSUXSEG4EI32_V_M4_M2 + 0U, // PseudoVSUXSEG4EI32_V_M4_M2_MASK + 0U, // PseudoVSUXSEG4EI32_V_M8_M2 + 0U, // PseudoVSUXSEG4EI32_V_M8_M2_MASK + 0U, // PseudoVSUXSEG4EI32_V_MF2_M1 + 0U, // PseudoVSUXSEG4EI32_V_MF2_M1_MASK + 0U, // PseudoVSUXSEG4EI32_V_MF2_MF2 + 0U, // PseudoVSUXSEG4EI32_V_MF2_MF2_MASK + 0U, // PseudoVSUXSEG4EI32_V_MF2_MF4 + 0U, // PseudoVSUXSEG4EI32_V_MF2_MF4_MASK + 0U, // PseudoVSUXSEG4EI32_V_MF2_MF8 + 0U, // PseudoVSUXSEG4EI32_V_MF2_MF8_MASK + 0U, // PseudoVSUXSEG4EI64_V_M1_M1 + 0U, // PseudoVSUXSEG4EI64_V_M1_M1_MASK + 0U, // PseudoVSUXSEG4EI64_V_M1_MF2 + 0U, // PseudoVSUXSEG4EI64_V_M1_MF2_MASK + 0U, // PseudoVSUXSEG4EI64_V_M1_MF4 + 0U, // PseudoVSUXSEG4EI64_V_M1_MF4_MASK + 0U, // PseudoVSUXSEG4EI64_V_M1_MF8 + 0U, // PseudoVSUXSEG4EI64_V_M1_MF8_MASK + 0U, // PseudoVSUXSEG4EI64_V_M2_M1 + 0U, // PseudoVSUXSEG4EI64_V_M2_M1_MASK + 0U, // PseudoVSUXSEG4EI64_V_M2_M2 + 0U, // PseudoVSUXSEG4EI64_V_M2_M2_MASK + 0U, // PseudoVSUXSEG4EI64_V_M2_MF2 + 0U, // PseudoVSUXSEG4EI64_V_M2_MF2_MASK + 0U, // PseudoVSUXSEG4EI64_V_M2_MF4 + 0U, // PseudoVSUXSEG4EI64_V_M2_MF4_MASK + 0U, // PseudoVSUXSEG4EI64_V_M4_M1 + 0U, // PseudoVSUXSEG4EI64_V_M4_M1_MASK + 0U, // PseudoVSUXSEG4EI64_V_M4_M2 + 0U, // PseudoVSUXSEG4EI64_V_M4_M2_MASK + 0U, // PseudoVSUXSEG4EI64_V_M4_MF2 + 0U, // PseudoVSUXSEG4EI64_V_M4_MF2_MASK + 0U, // PseudoVSUXSEG4EI64_V_M8_M1 + 0U, // PseudoVSUXSEG4EI64_V_M8_M1_MASK + 0U, // PseudoVSUXSEG4EI64_V_M8_M2 + 0U, // PseudoVSUXSEG4EI64_V_M8_M2_MASK + 0U, // PseudoVSUXSEG4EI8_V_M1_M1 + 0U, // PseudoVSUXSEG4EI8_V_M1_M1_MASK + 0U, // PseudoVSUXSEG4EI8_V_M1_M2 + 0U, // PseudoVSUXSEG4EI8_V_M1_M2_MASK + 0U, // PseudoVSUXSEG4EI8_V_M2_M2 + 0U, // PseudoVSUXSEG4EI8_V_M2_M2_MASK + 0U, // PseudoVSUXSEG4EI8_V_MF2_M1 + 0U, // PseudoVSUXSEG4EI8_V_MF2_M1_MASK + 0U, // PseudoVSUXSEG4EI8_V_MF2_M2 + 0U, // PseudoVSUXSEG4EI8_V_MF2_M2_MASK + 0U, // PseudoVSUXSEG4EI8_V_MF2_MF2 + 0U, // PseudoVSUXSEG4EI8_V_MF2_MF2_MASK + 0U, // PseudoVSUXSEG4EI8_V_MF4_M1 + 0U, // PseudoVSUXSEG4EI8_V_MF4_M1_MASK + 0U, // PseudoVSUXSEG4EI8_V_MF4_M2 + 0U, // PseudoVSUXSEG4EI8_V_MF4_M2_MASK + 0U, // PseudoVSUXSEG4EI8_V_MF4_MF2 + 0U, // PseudoVSUXSEG4EI8_V_MF4_MF2_MASK + 0U, // PseudoVSUXSEG4EI8_V_MF4_MF4 + 0U, // PseudoVSUXSEG4EI8_V_MF4_MF4_MASK + 0U, // PseudoVSUXSEG4EI8_V_MF8_M1 + 0U, // PseudoVSUXSEG4EI8_V_MF8_M1_MASK + 0U, // PseudoVSUXSEG4EI8_V_MF8_MF2 + 0U, // PseudoVSUXSEG4EI8_V_MF8_MF2_MASK + 0U, // PseudoVSUXSEG4EI8_V_MF8_MF4 + 0U, // PseudoVSUXSEG4EI8_V_MF8_MF4_MASK + 0U, // PseudoVSUXSEG4EI8_V_MF8_MF8 + 0U, // PseudoVSUXSEG4EI8_V_MF8_MF8_MASK + 0U, // PseudoVSUXSEG5EI16_V_M1_M1 + 0U, // PseudoVSUXSEG5EI16_V_M1_M1_MASK + 0U, // PseudoVSUXSEG5EI16_V_M1_MF2 + 0U, // PseudoVSUXSEG5EI16_V_M1_MF2_MASK + 0U, // PseudoVSUXSEG5EI16_V_M2_M1 + 0U, // PseudoVSUXSEG5EI16_V_M2_M1_MASK + 0U, // PseudoVSUXSEG5EI16_V_MF2_M1 + 0U, // PseudoVSUXSEG5EI16_V_MF2_M1_MASK + 0U, // PseudoVSUXSEG5EI16_V_MF2_MF2 + 0U, // PseudoVSUXSEG5EI16_V_MF2_MF2_MASK + 0U, // PseudoVSUXSEG5EI16_V_MF2_MF4 + 0U, // PseudoVSUXSEG5EI16_V_MF2_MF4_MASK + 0U, // PseudoVSUXSEG5EI16_V_MF4_M1 + 0U, // PseudoVSUXSEG5EI16_V_MF4_M1_MASK + 0U, // PseudoVSUXSEG5EI16_V_MF4_MF2 + 0U, // PseudoVSUXSEG5EI16_V_MF4_MF2_MASK + 0U, // PseudoVSUXSEG5EI16_V_MF4_MF4 + 0U, // PseudoVSUXSEG5EI16_V_MF4_MF4_MASK + 0U, // PseudoVSUXSEG5EI16_V_MF4_MF8 + 0U, // PseudoVSUXSEG5EI16_V_MF4_MF8_MASK + 0U, // PseudoVSUXSEG5EI32_V_M1_M1 + 0U, // PseudoVSUXSEG5EI32_V_M1_M1_MASK + 0U, // PseudoVSUXSEG5EI32_V_M1_MF2 + 0U, // PseudoVSUXSEG5EI32_V_M1_MF2_MASK + 0U, // PseudoVSUXSEG5EI32_V_M1_MF4 + 0U, // PseudoVSUXSEG5EI32_V_M1_MF4_MASK + 0U, // PseudoVSUXSEG5EI32_V_M2_M1 + 0U, // PseudoVSUXSEG5EI32_V_M2_M1_MASK + 0U, // PseudoVSUXSEG5EI32_V_M2_MF2 + 0U, // PseudoVSUXSEG5EI32_V_M2_MF2_MASK + 0U, // PseudoVSUXSEG5EI32_V_M4_M1 + 0U, // PseudoVSUXSEG5EI32_V_M4_M1_MASK + 0U, // PseudoVSUXSEG5EI32_V_MF2_M1 + 0U, // PseudoVSUXSEG5EI32_V_MF2_M1_MASK + 0U, // PseudoVSUXSEG5EI32_V_MF2_MF2 + 0U, // PseudoVSUXSEG5EI32_V_MF2_MF2_MASK + 0U, // PseudoVSUXSEG5EI32_V_MF2_MF4 + 0U, // PseudoVSUXSEG5EI32_V_MF2_MF4_MASK + 0U, // PseudoVSUXSEG5EI32_V_MF2_MF8 + 0U, // PseudoVSUXSEG5EI32_V_MF2_MF8_MASK + 0U, // PseudoVSUXSEG5EI64_V_M1_M1 + 0U, // PseudoVSUXSEG5EI64_V_M1_M1_MASK + 0U, // PseudoVSUXSEG5EI64_V_M1_MF2 + 0U, // PseudoVSUXSEG5EI64_V_M1_MF2_MASK + 0U, // PseudoVSUXSEG5EI64_V_M1_MF4 + 0U, // PseudoVSUXSEG5EI64_V_M1_MF4_MASK + 0U, // PseudoVSUXSEG5EI64_V_M1_MF8 + 0U, // PseudoVSUXSEG5EI64_V_M1_MF8_MASK + 0U, // PseudoVSUXSEG5EI64_V_M2_M1 + 0U, // PseudoVSUXSEG5EI64_V_M2_M1_MASK + 0U, // PseudoVSUXSEG5EI64_V_M2_MF2 + 0U, // PseudoVSUXSEG5EI64_V_M2_MF2_MASK + 0U, // PseudoVSUXSEG5EI64_V_M2_MF4 + 0U, // PseudoVSUXSEG5EI64_V_M2_MF4_MASK + 0U, // PseudoVSUXSEG5EI64_V_M4_M1 + 0U, // PseudoVSUXSEG5EI64_V_M4_M1_MASK + 0U, // PseudoVSUXSEG5EI64_V_M4_MF2 + 0U, // PseudoVSUXSEG5EI64_V_M4_MF2_MASK + 0U, // PseudoVSUXSEG5EI64_V_M8_M1 + 0U, // PseudoVSUXSEG5EI64_V_M8_M1_MASK + 0U, // PseudoVSUXSEG5EI8_V_M1_M1 + 0U, // PseudoVSUXSEG5EI8_V_M1_M1_MASK + 0U, // PseudoVSUXSEG5EI8_V_MF2_M1 + 0U, // PseudoVSUXSEG5EI8_V_MF2_M1_MASK + 0U, // PseudoVSUXSEG5EI8_V_MF2_MF2 + 0U, // PseudoVSUXSEG5EI8_V_MF2_MF2_MASK + 0U, // PseudoVSUXSEG5EI8_V_MF4_M1 + 0U, // PseudoVSUXSEG5EI8_V_MF4_M1_MASK + 0U, // PseudoVSUXSEG5EI8_V_MF4_MF2 + 0U, // PseudoVSUXSEG5EI8_V_MF4_MF2_MASK + 0U, // PseudoVSUXSEG5EI8_V_MF4_MF4 + 0U, // PseudoVSUXSEG5EI8_V_MF4_MF4_MASK + 0U, // PseudoVSUXSEG5EI8_V_MF8_M1 + 0U, // PseudoVSUXSEG5EI8_V_MF8_M1_MASK + 0U, // PseudoVSUXSEG5EI8_V_MF8_MF2 + 0U, // PseudoVSUXSEG5EI8_V_MF8_MF2_MASK + 0U, // PseudoVSUXSEG5EI8_V_MF8_MF4 + 0U, // PseudoVSUXSEG5EI8_V_MF8_MF4_MASK + 0U, // PseudoVSUXSEG5EI8_V_MF8_MF8 + 0U, // PseudoVSUXSEG5EI8_V_MF8_MF8_MASK + 0U, // PseudoVSUXSEG6EI16_V_M1_M1 + 0U, // PseudoVSUXSEG6EI16_V_M1_M1_MASK + 0U, // PseudoVSUXSEG6EI16_V_M1_MF2 + 0U, // PseudoVSUXSEG6EI16_V_M1_MF2_MASK + 0U, // PseudoVSUXSEG6EI16_V_M2_M1 + 0U, // PseudoVSUXSEG6EI16_V_M2_M1_MASK + 0U, // PseudoVSUXSEG6EI16_V_MF2_M1 + 0U, // PseudoVSUXSEG6EI16_V_MF2_M1_MASK + 0U, // PseudoVSUXSEG6EI16_V_MF2_MF2 + 0U, // PseudoVSUXSEG6EI16_V_MF2_MF2_MASK + 0U, // PseudoVSUXSEG6EI16_V_MF2_MF4 + 0U, // PseudoVSUXSEG6EI16_V_MF2_MF4_MASK + 0U, // PseudoVSUXSEG6EI16_V_MF4_M1 + 0U, // PseudoVSUXSEG6EI16_V_MF4_M1_MASK + 0U, // PseudoVSUXSEG6EI16_V_MF4_MF2 + 0U, // PseudoVSUXSEG6EI16_V_MF4_MF2_MASK + 0U, // PseudoVSUXSEG6EI16_V_MF4_MF4 + 0U, // PseudoVSUXSEG6EI16_V_MF4_MF4_MASK + 0U, // PseudoVSUXSEG6EI16_V_MF4_MF8 + 0U, // PseudoVSUXSEG6EI16_V_MF4_MF8_MASK + 0U, // PseudoVSUXSEG6EI32_V_M1_M1 + 0U, // PseudoVSUXSEG6EI32_V_M1_M1_MASK + 0U, // PseudoVSUXSEG6EI32_V_M1_MF2 + 0U, // PseudoVSUXSEG6EI32_V_M1_MF2_MASK + 0U, // PseudoVSUXSEG6EI32_V_M1_MF4 + 0U, // PseudoVSUXSEG6EI32_V_M1_MF4_MASK + 0U, // PseudoVSUXSEG6EI32_V_M2_M1 + 0U, // PseudoVSUXSEG6EI32_V_M2_M1_MASK + 0U, // PseudoVSUXSEG6EI32_V_M2_MF2 + 0U, // PseudoVSUXSEG6EI32_V_M2_MF2_MASK + 0U, // PseudoVSUXSEG6EI32_V_M4_M1 + 0U, // PseudoVSUXSEG6EI32_V_M4_M1_MASK + 0U, // PseudoVSUXSEG6EI32_V_MF2_M1 + 0U, // PseudoVSUXSEG6EI32_V_MF2_M1_MASK + 0U, // PseudoVSUXSEG6EI32_V_MF2_MF2 + 0U, // PseudoVSUXSEG6EI32_V_MF2_MF2_MASK + 0U, // PseudoVSUXSEG6EI32_V_MF2_MF4 + 0U, // PseudoVSUXSEG6EI32_V_MF2_MF4_MASK + 0U, // PseudoVSUXSEG6EI32_V_MF2_MF8 + 0U, // PseudoVSUXSEG6EI32_V_MF2_MF8_MASK + 0U, // PseudoVSUXSEG6EI64_V_M1_M1 + 0U, // PseudoVSUXSEG6EI64_V_M1_M1_MASK + 0U, // PseudoVSUXSEG6EI64_V_M1_MF2 + 0U, // PseudoVSUXSEG6EI64_V_M1_MF2_MASK + 0U, // PseudoVSUXSEG6EI64_V_M1_MF4 + 0U, // PseudoVSUXSEG6EI64_V_M1_MF4_MASK + 0U, // PseudoVSUXSEG6EI64_V_M1_MF8 + 0U, // PseudoVSUXSEG6EI64_V_M1_MF8_MASK + 0U, // PseudoVSUXSEG6EI64_V_M2_M1 + 0U, // PseudoVSUXSEG6EI64_V_M2_M1_MASK + 0U, // PseudoVSUXSEG6EI64_V_M2_MF2 + 0U, // PseudoVSUXSEG6EI64_V_M2_MF2_MASK + 0U, // PseudoVSUXSEG6EI64_V_M2_MF4 + 0U, // PseudoVSUXSEG6EI64_V_M2_MF4_MASK + 0U, // PseudoVSUXSEG6EI64_V_M4_M1 + 0U, // PseudoVSUXSEG6EI64_V_M4_M1_MASK + 0U, // PseudoVSUXSEG6EI64_V_M4_MF2 + 0U, // PseudoVSUXSEG6EI64_V_M4_MF2_MASK + 0U, // PseudoVSUXSEG6EI64_V_M8_M1 + 0U, // PseudoVSUXSEG6EI64_V_M8_M1_MASK + 0U, // PseudoVSUXSEG6EI8_V_M1_M1 + 0U, // PseudoVSUXSEG6EI8_V_M1_M1_MASK + 0U, // PseudoVSUXSEG6EI8_V_MF2_M1 + 0U, // PseudoVSUXSEG6EI8_V_MF2_M1_MASK + 0U, // PseudoVSUXSEG6EI8_V_MF2_MF2 + 0U, // PseudoVSUXSEG6EI8_V_MF2_MF2_MASK + 0U, // PseudoVSUXSEG6EI8_V_MF4_M1 + 0U, // PseudoVSUXSEG6EI8_V_MF4_M1_MASK + 0U, // PseudoVSUXSEG6EI8_V_MF4_MF2 + 0U, // PseudoVSUXSEG6EI8_V_MF4_MF2_MASK + 0U, // PseudoVSUXSEG6EI8_V_MF4_MF4 + 0U, // PseudoVSUXSEG6EI8_V_MF4_MF4_MASK + 0U, // PseudoVSUXSEG6EI8_V_MF8_M1 + 0U, // PseudoVSUXSEG6EI8_V_MF8_M1_MASK + 0U, // PseudoVSUXSEG6EI8_V_MF8_MF2 + 0U, // PseudoVSUXSEG6EI8_V_MF8_MF2_MASK + 0U, // PseudoVSUXSEG6EI8_V_MF8_MF4 + 0U, // PseudoVSUXSEG6EI8_V_MF8_MF4_MASK + 0U, // PseudoVSUXSEG6EI8_V_MF8_MF8 + 0U, // PseudoVSUXSEG6EI8_V_MF8_MF8_MASK + 0U, // PseudoVSUXSEG7EI16_V_M1_M1 + 0U, // PseudoVSUXSEG7EI16_V_M1_M1_MASK + 0U, // PseudoVSUXSEG7EI16_V_M1_MF2 + 0U, // PseudoVSUXSEG7EI16_V_M1_MF2_MASK + 0U, // PseudoVSUXSEG7EI16_V_M2_M1 + 0U, // PseudoVSUXSEG7EI16_V_M2_M1_MASK + 0U, // PseudoVSUXSEG7EI16_V_MF2_M1 + 0U, // PseudoVSUXSEG7EI16_V_MF2_M1_MASK + 0U, // PseudoVSUXSEG7EI16_V_MF2_MF2 + 0U, // PseudoVSUXSEG7EI16_V_MF2_MF2_MASK + 0U, // PseudoVSUXSEG7EI16_V_MF2_MF4 + 0U, // PseudoVSUXSEG7EI16_V_MF2_MF4_MASK + 0U, // PseudoVSUXSEG7EI16_V_MF4_M1 + 0U, // PseudoVSUXSEG7EI16_V_MF4_M1_MASK + 0U, // PseudoVSUXSEG7EI16_V_MF4_MF2 + 0U, // PseudoVSUXSEG7EI16_V_MF4_MF2_MASK + 0U, // PseudoVSUXSEG7EI16_V_MF4_MF4 + 0U, // PseudoVSUXSEG7EI16_V_MF4_MF4_MASK + 0U, // PseudoVSUXSEG7EI16_V_MF4_MF8 + 0U, // PseudoVSUXSEG7EI16_V_MF4_MF8_MASK + 0U, // PseudoVSUXSEG7EI32_V_M1_M1 + 0U, // PseudoVSUXSEG7EI32_V_M1_M1_MASK + 0U, // PseudoVSUXSEG7EI32_V_M1_MF2 + 0U, // PseudoVSUXSEG7EI32_V_M1_MF2_MASK + 0U, // PseudoVSUXSEG7EI32_V_M1_MF4 + 0U, // PseudoVSUXSEG7EI32_V_M1_MF4_MASK + 0U, // PseudoVSUXSEG7EI32_V_M2_M1 + 0U, // PseudoVSUXSEG7EI32_V_M2_M1_MASK + 0U, // PseudoVSUXSEG7EI32_V_M2_MF2 + 0U, // PseudoVSUXSEG7EI32_V_M2_MF2_MASK + 0U, // PseudoVSUXSEG7EI32_V_M4_M1 + 0U, // PseudoVSUXSEG7EI32_V_M4_M1_MASK + 0U, // PseudoVSUXSEG7EI32_V_MF2_M1 + 0U, // PseudoVSUXSEG7EI32_V_MF2_M1_MASK + 0U, // PseudoVSUXSEG7EI32_V_MF2_MF2 + 0U, // PseudoVSUXSEG7EI32_V_MF2_MF2_MASK + 0U, // PseudoVSUXSEG7EI32_V_MF2_MF4 + 0U, // PseudoVSUXSEG7EI32_V_MF2_MF4_MASK + 0U, // PseudoVSUXSEG7EI32_V_MF2_MF8 + 0U, // PseudoVSUXSEG7EI32_V_MF2_MF8_MASK + 0U, // PseudoVSUXSEG7EI64_V_M1_M1 + 0U, // PseudoVSUXSEG7EI64_V_M1_M1_MASK + 0U, // PseudoVSUXSEG7EI64_V_M1_MF2 + 0U, // PseudoVSUXSEG7EI64_V_M1_MF2_MASK + 0U, // PseudoVSUXSEG7EI64_V_M1_MF4 + 0U, // PseudoVSUXSEG7EI64_V_M1_MF4_MASK + 0U, // PseudoVSUXSEG7EI64_V_M1_MF8 + 0U, // PseudoVSUXSEG7EI64_V_M1_MF8_MASK + 0U, // PseudoVSUXSEG7EI64_V_M2_M1 + 0U, // PseudoVSUXSEG7EI64_V_M2_M1_MASK + 0U, // PseudoVSUXSEG7EI64_V_M2_MF2 + 0U, // PseudoVSUXSEG7EI64_V_M2_MF2_MASK + 0U, // PseudoVSUXSEG7EI64_V_M2_MF4 + 0U, // PseudoVSUXSEG7EI64_V_M2_MF4_MASK + 0U, // PseudoVSUXSEG7EI64_V_M4_M1 + 0U, // PseudoVSUXSEG7EI64_V_M4_M1_MASK + 0U, // PseudoVSUXSEG7EI64_V_M4_MF2 + 0U, // PseudoVSUXSEG7EI64_V_M4_MF2_MASK + 0U, // PseudoVSUXSEG7EI64_V_M8_M1 + 0U, // PseudoVSUXSEG7EI64_V_M8_M1_MASK + 0U, // PseudoVSUXSEG7EI8_V_M1_M1 + 0U, // PseudoVSUXSEG7EI8_V_M1_M1_MASK + 0U, // PseudoVSUXSEG7EI8_V_MF2_M1 + 0U, // PseudoVSUXSEG7EI8_V_MF2_M1_MASK + 0U, // PseudoVSUXSEG7EI8_V_MF2_MF2 + 0U, // PseudoVSUXSEG7EI8_V_MF2_MF2_MASK + 0U, // PseudoVSUXSEG7EI8_V_MF4_M1 + 0U, // PseudoVSUXSEG7EI8_V_MF4_M1_MASK + 0U, // PseudoVSUXSEG7EI8_V_MF4_MF2 + 0U, // PseudoVSUXSEG7EI8_V_MF4_MF2_MASK + 0U, // PseudoVSUXSEG7EI8_V_MF4_MF4 + 0U, // PseudoVSUXSEG7EI8_V_MF4_MF4_MASK + 0U, // PseudoVSUXSEG7EI8_V_MF8_M1 + 0U, // PseudoVSUXSEG7EI8_V_MF8_M1_MASK + 0U, // PseudoVSUXSEG7EI8_V_MF8_MF2 + 0U, // PseudoVSUXSEG7EI8_V_MF8_MF2_MASK + 0U, // PseudoVSUXSEG7EI8_V_MF8_MF4 + 0U, // PseudoVSUXSEG7EI8_V_MF8_MF4_MASK + 0U, // PseudoVSUXSEG7EI8_V_MF8_MF8 + 0U, // PseudoVSUXSEG7EI8_V_MF8_MF8_MASK + 0U, // PseudoVSUXSEG8EI16_V_M1_M1 + 0U, // PseudoVSUXSEG8EI16_V_M1_M1_MASK + 0U, // PseudoVSUXSEG8EI16_V_M1_MF2 + 0U, // PseudoVSUXSEG8EI16_V_M1_MF2_MASK + 0U, // PseudoVSUXSEG8EI16_V_M2_M1 + 0U, // PseudoVSUXSEG8EI16_V_M2_M1_MASK + 0U, // PseudoVSUXSEG8EI16_V_MF2_M1 + 0U, // PseudoVSUXSEG8EI16_V_MF2_M1_MASK + 0U, // PseudoVSUXSEG8EI16_V_MF2_MF2 + 0U, // PseudoVSUXSEG8EI16_V_MF2_MF2_MASK + 0U, // PseudoVSUXSEG8EI16_V_MF2_MF4 + 0U, // PseudoVSUXSEG8EI16_V_MF2_MF4_MASK + 0U, // PseudoVSUXSEG8EI16_V_MF4_M1 + 0U, // PseudoVSUXSEG8EI16_V_MF4_M1_MASK + 0U, // PseudoVSUXSEG8EI16_V_MF4_MF2 + 0U, // PseudoVSUXSEG8EI16_V_MF4_MF2_MASK + 0U, // PseudoVSUXSEG8EI16_V_MF4_MF4 + 0U, // PseudoVSUXSEG8EI16_V_MF4_MF4_MASK + 0U, // PseudoVSUXSEG8EI16_V_MF4_MF8 + 0U, // PseudoVSUXSEG8EI16_V_MF4_MF8_MASK + 0U, // PseudoVSUXSEG8EI32_V_M1_M1 + 0U, // PseudoVSUXSEG8EI32_V_M1_M1_MASK + 0U, // PseudoVSUXSEG8EI32_V_M1_MF2 + 0U, // PseudoVSUXSEG8EI32_V_M1_MF2_MASK + 0U, // PseudoVSUXSEG8EI32_V_M1_MF4 + 0U, // PseudoVSUXSEG8EI32_V_M1_MF4_MASK + 0U, // PseudoVSUXSEG8EI32_V_M2_M1 + 0U, // PseudoVSUXSEG8EI32_V_M2_M1_MASK + 0U, // PseudoVSUXSEG8EI32_V_M2_MF2 + 0U, // PseudoVSUXSEG8EI32_V_M2_MF2_MASK + 0U, // PseudoVSUXSEG8EI32_V_M4_M1 + 0U, // PseudoVSUXSEG8EI32_V_M4_M1_MASK + 0U, // PseudoVSUXSEG8EI32_V_MF2_M1 + 0U, // PseudoVSUXSEG8EI32_V_MF2_M1_MASK + 0U, // PseudoVSUXSEG8EI32_V_MF2_MF2 + 0U, // PseudoVSUXSEG8EI32_V_MF2_MF2_MASK + 0U, // PseudoVSUXSEG8EI32_V_MF2_MF4 + 0U, // PseudoVSUXSEG8EI32_V_MF2_MF4_MASK + 0U, // PseudoVSUXSEG8EI32_V_MF2_MF8 + 0U, // PseudoVSUXSEG8EI32_V_MF2_MF8_MASK + 0U, // PseudoVSUXSEG8EI64_V_M1_M1 + 0U, // PseudoVSUXSEG8EI64_V_M1_M1_MASK + 0U, // PseudoVSUXSEG8EI64_V_M1_MF2 + 0U, // PseudoVSUXSEG8EI64_V_M1_MF2_MASK + 0U, // PseudoVSUXSEG8EI64_V_M1_MF4 + 0U, // PseudoVSUXSEG8EI64_V_M1_MF4_MASK + 0U, // PseudoVSUXSEG8EI64_V_M1_MF8 + 0U, // PseudoVSUXSEG8EI64_V_M1_MF8_MASK + 0U, // PseudoVSUXSEG8EI64_V_M2_M1 + 0U, // PseudoVSUXSEG8EI64_V_M2_M1_MASK + 0U, // PseudoVSUXSEG8EI64_V_M2_MF2 + 0U, // PseudoVSUXSEG8EI64_V_M2_MF2_MASK + 0U, // PseudoVSUXSEG8EI64_V_M2_MF4 + 0U, // PseudoVSUXSEG8EI64_V_M2_MF4_MASK + 0U, // PseudoVSUXSEG8EI64_V_M4_M1 + 0U, // PseudoVSUXSEG8EI64_V_M4_M1_MASK + 0U, // PseudoVSUXSEG8EI64_V_M4_MF2 + 0U, // PseudoVSUXSEG8EI64_V_M4_MF2_MASK + 0U, // PseudoVSUXSEG8EI64_V_M8_M1 + 0U, // PseudoVSUXSEG8EI64_V_M8_M1_MASK + 0U, // PseudoVSUXSEG8EI8_V_M1_M1 + 0U, // PseudoVSUXSEG8EI8_V_M1_M1_MASK + 0U, // PseudoVSUXSEG8EI8_V_MF2_M1 + 0U, // PseudoVSUXSEG8EI8_V_MF2_M1_MASK + 0U, // PseudoVSUXSEG8EI8_V_MF2_MF2 + 0U, // PseudoVSUXSEG8EI8_V_MF2_MF2_MASK + 0U, // PseudoVSUXSEG8EI8_V_MF4_M1 + 0U, // PseudoVSUXSEG8EI8_V_MF4_M1_MASK + 0U, // PseudoVSUXSEG8EI8_V_MF4_MF2 + 0U, // PseudoVSUXSEG8EI8_V_MF4_MF2_MASK + 0U, // PseudoVSUXSEG8EI8_V_MF4_MF4 + 0U, // PseudoVSUXSEG8EI8_V_MF4_MF4_MASK + 0U, // PseudoVSUXSEG8EI8_V_MF8_M1 + 0U, // PseudoVSUXSEG8EI8_V_MF8_M1_MASK + 0U, // PseudoVSUXSEG8EI8_V_MF8_MF2 + 0U, // PseudoVSUXSEG8EI8_V_MF8_MF2_MASK + 0U, // PseudoVSUXSEG8EI8_V_MF8_MF4 + 0U, // PseudoVSUXSEG8EI8_V_MF8_MF4_MASK + 0U, // PseudoVSUXSEG8EI8_V_MF8_MF8 + 0U, // PseudoVSUXSEG8EI8_V_MF8_MF8_MASK + 0U, // PseudoVWADDU_VV_M1 + 0U, // PseudoVWADDU_VV_M1_MASK + 0U, // PseudoVWADDU_VV_M2 + 0U, // PseudoVWADDU_VV_M2_MASK + 0U, // PseudoVWADDU_VV_M4 + 0U, // PseudoVWADDU_VV_M4_MASK + 0U, // PseudoVWADDU_VV_MF2 + 0U, // PseudoVWADDU_VV_MF2_MASK + 0U, // PseudoVWADDU_VV_MF4 + 0U, // PseudoVWADDU_VV_MF4_MASK + 0U, // PseudoVWADDU_VV_MF8 + 0U, // PseudoVWADDU_VV_MF8_MASK + 0U, // PseudoVWADDU_VX_M1 + 0U, // PseudoVWADDU_VX_M1_MASK + 0U, // PseudoVWADDU_VX_M2 + 0U, // PseudoVWADDU_VX_M2_MASK + 0U, // PseudoVWADDU_VX_M4 + 0U, // PseudoVWADDU_VX_M4_MASK + 0U, // PseudoVWADDU_VX_MF2 + 0U, // PseudoVWADDU_VX_MF2_MASK + 0U, // PseudoVWADDU_VX_MF4 + 0U, // PseudoVWADDU_VX_MF4_MASK + 0U, // PseudoVWADDU_VX_MF8 + 0U, // PseudoVWADDU_VX_MF8_MASK + 0U, // PseudoVWADDU_WV_M1 + 0U, // PseudoVWADDU_WV_M1_MASK + 0U, // PseudoVWADDU_WV_M1_MASK_TIED + 0U, // PseudoVWADDU_WV_M1_TIED + 0U, // PseudoVWADDU_WV_M2 + 0U, // PseudoVWADDU_WV_M2_MASK + 0U, // PseudoVWADDU_WV_M2_MASK_TIED + 0U, // PseudoVWADDU_WV_M2_TIED + 0U, // PseudoVWADDU_WV_M4 + 0U, // PseudoVWADDU_WV_M4_MASK + 0U, // PseudoVWADDU_WV_M4_MASK_TIED + 0U, // PseudoVWADDU_WV_M4_TIED + 0U, // PseudoVWADDU_WV_MF2 + 0U, // PseudoVWADDU_WV_MF2_MASK + 0U, // PseudoVWADDU_WV_MF2_MASK_TIED + 0U, // PseudoVWADDU_WV_MF2_TIED + 0U, // PseudoVWADDU_WV_MF4 + 0U, // PseudoVWADDU_WV_MF4_MASK + 0U, // PseudoVWADDU_WV_MF4_MASK_TIED + 0U, // PseudoVWADDU_WV_MF4_TIED + 0U, // PseudoVWADDU_WV_MF8 + 0U, // PseudoVWADDU_WV_MF8_MASK + 0U, // PseudoVWADDU_WV_MF8_MASK_TIED + 0U, // PseudoVWADDU_WV_MF8_TIED + 0U, // PseudoVWADDU_WX_M1 + 0U, // PseudoVWADDU_WX_M1_MASK + 0U, // PseudoVWADDU_WX_M2 + 0U, // PseudoVWADDU_WX_M2_MASK + 0U, // PseudoVWADDU_WX_M4 + 0U, // PseudoVWADDU_WX_M4_MASK + 0U, // PseudoVWADDU_WX_MF2 + 0U, // PseudoVWADDU_WX_MF2_MASK + 0U, // PseudoVWADDU_WX_MF4 + 0U, // PseudoVWADDU_WX_MF4_MASK + 0U, // PseudoVWADDU_WX_MF8 + 0U, // PseudoVWADDU_WX_MF8_MASK + 0U, // PseudoVWADD_VV_M1 + 0U, // PseudoVWADD_VV_M1_MASK + 0U, // PseudoVWADD_VV_M2 + 0U, // PseudoVWADD_VV_M2_MASK + 0U, // PseudoVWADD_VV_M4 + 0U, // PseudoVWADD_VV_M4_MASK + 0U, // PseudoVWADD_VV_MF2 + 0U, // PseudoVWADD_VV_MF2_MASK + 0U, // PseudoVWADD_VV_MF4 + 0U, // PseudoVWADD_VV_MF4_MASK + 0U, // PseudoVWADD_VV_MF8 + 0U, // PseudoVWADD_VV_MF8_MASK + 0U, // PseudoVWADD_VX_M1 + 0U, // PseudoVWADD_VX_M1_MASK + 0U, // PseudoVWADD_VX_M2 + 0U, // PseudoVWADD_VX_M2_MASK + 0U, // PseudoVWADD_VX_M4 + 0U, // PseudoVWADD_VX_M4_MASK + 0U, // PseudoVWADD_VX_MF2 + 0U, // PseudoVWADD_VX_MF2_MASK + 0U, // PseudoVWADD_VX_MF4 + 0U, // PseudoVWADD_VX_MF4_MASK + 0U, // PseudoVWADD_VX_MF8 + 0U, // PseudoVWADD_VX_MF8_MASK + 0U, // PseudoVWADD_WV_M1 + 0U, // PseudoVWADD_WV_M1_MASK + 0U, // PseudoVWADD_WV_M1_MASK_TIED + 0U, // PseudoVWADD_WV_M1_TIED + 0U, // PseudoVWADD_WV_M2 + 0U, // PseudoVWADD_WV_M2_MASK + 0U, // PseudoVWADD_WV_M2_MASK_TIED + 0U, // PseudoVWADD_WV_M2_TIED + 0U, // PseudoVWADD_WV_M4 + 0U, // PseudoVWADD_WV_M4_MASK + 0U, // PseudoVWADD_WV_M4_MASK_TIED + 0U, // PseudoVWADD_WV_M4_TIED + 0U, // PseudoVWADD_WV_MF2 + 0U, // PseudoVWADD_WV_MF2_MASK + 0U, // PseudoVWADD_WV_MF2_MASK_TIED + 0U, // PseudoVWADD_WV_MF2_TIED + 0U, // PseudoVWADD_WV_MF4 + 0U, // PseudoVWADD_WV_MF4_MASK + 0U, // PseudoVWADD_WV_MF4_MASK_TIED + 0U, // PseudoVWADD_WV_MF4_TIED + 0U, // PseudoVWADD_WV_MF8 + 0U, // PseudoVWADD_WV_MF8_MASK + 0U, // PseudoVWADD_WV_MF8_MASK_TIED + 0U, // PseudoVWADD_WV_MF8_TIED + 0U, // PseudoVWADD_WX_M1 + 0U, // PseudoVWADD_WX_M1_MASK + 0U, // PseudoVWADD_WX_M2 + 0U, // PseudoVWADD_WX_M2_MASK + 0U, // PseudoVWADD_WX_M4 + 0U, // PseudoVWADD_WX_M4_MASK + 0U, // PseudoVWADD_WX_MF2 + 0U, // PseudoVWADD_WX_MF2_MASK + 0U, // PseudoVWADD_WX_MF4 + 0U, // PseudoVWADD_WX_MF4_MASK + 0U, // PseudoVWADD_WX_MF8 + 0U, // PseudoVWADD_WX_MF8_MASK + 0U, // PseudoVWMACCSU_VV_M1 + 0U, // PseudoVWMACCSU_VV_M1_MASK + 0U, // PseudoVWMACCSU_VV_M2 + 0U, // PseudoVWMACCSU_VV_M2_MASK + 0U, // PseudoVWMACCSU_VV_M4 + 0U, // PseudoVWMACCSU_VV_M4_MASK + 0U, // PseudoVWMACCSU_VV_MF2 + 0U, // PseudoVWMACCSU_VV_MF2_MASK + 0U, // PseudoVWMACCSU_VV_MF4 + 0U, // PseudoVWMACCSU_VV_MF4_MASK + 0U, // PseudoVWMACCSU_VV_MF8 + 0U, // PseudoVWMACCSU_VV_MF8_MASK + 0U, // PseudoVWMACCSU_VX_M1 + 0U, // PseudoVWMACCSU_VX_M1_MASK + 0U, // PseudoVWMACCSU_VX_M2 + 0U, // PseudoVWMACCSU_VX_M2_MASK + 0U, // PseudoVWMACCSU_VX_M4 + 0U, // PseudoVWMACCSU_VX_M4_MASK + 0U, // PseudoVWMACCSU_VX_MF2 + 0U, // PseudoVWMACCSU_VX_MF2_MASK + 0U, // PseudoVWMACCSU_VX_MF4 + 0U, // PseudoVWMACCSU_VX_MF4_MASK + 0U, // PseudoVWMACCSU_VX_MF8 + 0U, // PseudoVWMACCSU_VX_MF8_MASK + 0U, // PseudoVWMACCUS_VX_M1 + 0U, // PseudoVWMACCUS_VX_M1_MASK + 0U, // PseudoVWMACCUS_VX_M2 + 0U, // PseudoVWMACCUS_VX_M2_MASK + 0U, // PseudoVWMACCUS_VX_M4 + 0U, // PseudoVWMACCUS_VX_M4_MASK + 0U, // PseudoVWMACCUS_VX_MF2 + 0U, // PseudoVWMACCUS_VX_MF2_MASK + 0U, // PseudoVWMACCUS_VX_MF4 + 0U, // PseudoVWMACCUS_VX_MF4_MASK + 0U, // PseudoVWMACCUS_VX_MF8 + 0U, // PseudoVWMACCUS_VX_MF8_MASK + 0U, // PseudoVWMACCU_VV_M1 + 0U, // PseudoVWMACCU_VV_M1_MASK + 0U, // PseudoVWMACCU_VV_M2 + 0U, // PseudoVWMACCU_VV_M2_MASK + 0U, // PseudoVWMACCU_VV_M4 + 0U, // PseudoVWMACCU_VV_M4_MASK + 0U, // PseudoVWMACCU_VV_MF2 + 0U, // PseudoVWMACCU_VV_MF2_MASK + 0U, // PseudoVWMACCU_VV_MF4 + 0U, // PseudoVWMACCU_VV_MF4_MASK + 0U, // PseudoVWMACCU_VV_MF8 + 0U, // PseudoVWMACCU_VV_MF8_MASK + 0U, // PseudoVWMACCU_VX_M1 + 0U, // PseudoVWMACCU_VX_M1_MASK + 0U, // PseudoVWMACCU_VX_M2 + 0U, // PseudoVWMACCU_VX_M2_MASK + 0U, // PseudoVWMACCU_VX_M4 + 0U, // PseudoVWMACCU_VX_M4_MASK + 0U, // PseudoVWMACCU_VX_MF2 + 0U, // PseudoVWMACCU_VX_MF2_MASK + 0U, // PseudoVWMACCU_VX_MF4 + 0U, // PseudoVWMACCU_VX_MF4_MASK + 0U, // PseudoVWMACCU_VX_MF8 + 0U, // PseudoVWMACCU_VX_MF8_MASK + 0U, // PseudoVWMACC_VV_M1 + 0U, // PseudoVWMACC_VV_M1_MASK + 0U, // PseudoVWMACC_VV_M2 + 0U, // PseudoVWMACC_VV_M2_MASK + 0U, // PseudoVWMACC_VV_M4 + 0U, // PseudoVWMACC_VV_M4_MASK + 0U, // PseudoVWMACC_VV_MF2 + 0U, // PseudoVWMACC_VV_MF2_MASK + 0U, // PseudoVWMACC_VV_MF4 + 0U, // PseudoVWMACC_VV_MF4_MASK + 0U, // PseudoVWMACC_VV_MF8 + 0U, // PseudoVWMACC_VV_MF8_MASK + 0U, // PseudoVWMACC_VX_M1 + 0U, // PseudoVWMACC_VX_M1_MASK + 0U, // PseudoVWMACC_VX_M2 + 0U, // PseudoVWMACC_VX_M2_MASK + 0U, // PseudoVWMACC_VX_M4 + 0U, // PseudoVWMACC_VX_M4_MASK + 0U, // PseudoVWMACC_VX_MF2 + 0U, // PseudoVWMACC_VX_MF2_MASK + 0U, // PseudoVWMACC_VX_MF4 + 0U, // PseudoVWMACC_VX_MF4_MASK + 0U, // PseudoVWMACC_VX_MF8 + 0U, // PseudoVWMACC_VX_MF8_MASK + 0U, // PseudoVWMULSU_VV_M1 + 0U, // PseudoVWMULSU_VV_M1_MASK + 0U, // PseudoVWMULSU_VV_M2 + 0U, // PseudoVWMULSU_VV_M2_MASK + 0U, // PseudoVWMULSU_VV_M4 + 0U, // PseudoVWMULSU_VV_M4_MASK + 0U, // PseudoVWMULSU_VV_MF2 + 0U, // PseudoVWMULSU_VV_MF2_MASK + 0U, // PseudoVWMULSU_VV_MF4 + 0U, // PseudoVWMULSU_VV_MF4_MASK + 0U, // PseudoVWMULSU_VV_MF8 + 0U, // PseudoVWMULSU_VV_MF8_MASK + 0U, // PseudoVWMULSU_VX_M1 + 0U, // PseudoVWMULSU_VX_M1_MASK + 0U, // PseudoVWMULSU_VX_M2 + 0U, // PseudoVWMULSU_VX_M2_MASK + 0U, // PseudoVWMULSU_VX_M4 + 0U, // PseudoVWMULSU_VX_M4_MASK + 0U, // PseudoVWMULSU_VX_MF2 + 0U, // PseudoVWMULSU_VX_MF2_MASK + 0U, // PseudoVWMULSU_VX_MF4 + 0U, // PseudoVWMULSU_VX_MF4_MASK + 0U, // PseudoVWMULSU_VX_MF8 + 0U, // PseudoVWMULSU_VX_MF8_MASK + 0U, // PseudoVWMULU_VV_M1 + 0U, // PseudoVWMULU_VV_M1_MASK + 0U, // PseudoVWMULU_VV_M2 + 0U, // PseudoVWMULU_VV_M2_MASK + 0U, // PseudoVWMULU_VV_M4 + 0U, // PseudoVWMULU_VV_M4_MASK + 0U, // PseudoVWMULU_VV_MF2 + 0U, // PseudoVWMULU_VV_MF2_MASK + 0U, // PseudoVWMULU_VV_MF4 + 0U, // PseudoVWMULU_VV_MF4_MASK + 0U, // PseudoVWMULU_VV_MF8 + 0U, // PseudoVWMULU_VV_MF8_MASK + 0U, // PseudoVWMULU_VX_M1 + 0U, // PseudoVWMULU_VX_M1_MASK + 0U, // PseudoVWMULU_VX_M2 + 0U, // PseudoVWMULU_VX_M2_MASK + 0U, // PseudoVWMULU_VX_M4 + 0U, // PseudoVWMULU_VX_M4_MASK + 0U, // PseudoVWMULU_VX_MF2 + 0U, // PseudoVWMULU_VX_MF2_MASK + 0U, // PseudoVWMULU_VX_MF4 + 0U, // PseudoVWMULU_VX_MF4_MASK + 0U, // PseudoVWMULU_VX_MF8 + 0U, // PseudoVWMULU_VX_MF8_MASK + 0U, // PseudoVWMUL_VV_M1 + 0U, // PseudoVWMUL_VV_M1_MASK + 0U, // PseudoVWMUL_VV_M2 + 0U, // PseudoVWMUL_VV_M2_MASK + 0U, // PseudoVWMUL_VV_M4 + 0U, // PseudoVWMUL_VV_M4_MASK + 0U, // PseudoVWMUL_VV_MF2 + 0U, // PseudoVWMUL_VV_MF2_MASK + 0U, // PseudoVWMUL_VV_MF4 + 0U, // PseudoVWMUL_VV_MF4_MASK + 0U, // PseudoVWMUL_VV_MF8 + 0U, // PseudoVWMUL_VV_MF8_MASK + 0U, // PseudoVWMUL_VX_M1 + 0U, // PseudoVWMUL_VX_M1_MASK + 0U, // PseudoVWMUL_VX_M2 + 0U, // PseudoVWMUL_VX_M2_MASK + 0U, // PseudoVWMUL_VX_M4 + 0U, // PseudoVWMUL_VX_M4_MASK + 0U, // PseudoVWMUL_VX_MF2 + 0U, // PseudoVWMUL_VX_MF2_MASK + 0U, // PseudoVWMUL_VX_MF4 + 0U, // PseudoVWMUL_VX_MF4_MASK + 0U, // PseudoVWMUL_VX_MF8 + 0U, // PseudoVWMUL_VX_MF8_MASK + 0U, // PseudoVWREDSUMU_VS_M1_E16 + 0U, // PseudoVWREDSUMU_VS_M1_E16_MASK + 0U, // PseudoVWREDSUMU_VS_M1_E32 + 0U, // PseudoVWREDSUMU_VS_M1_E32_MASK + 0U, // PseudoVWREDSUMU_VS_M1_E8 + 0U, // PseudoVWREDSUMU_VS_M1_E8_MASK + 0U, // PseudoVWREDSUMU_VS_M2_E16 + 0U, // PseudoVWREDSUMU_VS_M2_E16_MASK + 0U, // PseudoVWREDSUMU_VS_M2_E32 + 0U, // PseudoVWREDSUMU_VS_M2_E32_MASK + 0U, // PseudoVWREDSUMU_VS_M2_E8 + 0U, // PseudoVWREDSUMU_VS_M2_E8_MASK + 0U, // PseudoVWREDSUMU_VS_M4_E16 + 0U, // PseudoVWREDSUMU_VS_M4_E16_MASK + 0U, // PseudoVWREDSUMU_VS_M4_E32 + 0U, // PseudoVWREDSUMU_VS_M4_E32_MASK + 0U, // PseudoVWREDSUMU_VS_M4_E8 + 0U, // PseudoVWREDSUMU_VS_M4_E8_MASK + 0U, // PseudoVWREDSUMU_VS_M8_E16 + 0U, // PseudoVWREDSUMU_VS_M8_E16_MASK + 0U, // PseudoVWREDSUMU_VS_M8_E32 + 0U, // PseudoVWREDSUMU_VS_M8_E32_MASK + 0U, // PseudoVWREDSUMU_VS_M8_E8 + 0U, // PseudoVWREDSUMU_VS_M8_E8_MASK + 0U, // PseudoVWREDSUMU_VS_MF2_E16 + 0U, // PseudoVWREDSUMU_VS_MF2_E16_MASK + 0U, // PseudoVWREDSUMU_VS_MF2_E32 + 0U, // PseudoVWREDSUMU_VS_MF2_E32_MASK + 0U, // PseudoVWREDSUMU_VS_MF2_E8 + 0U, // PseudoVWREDSUMU_VS_MF2_E8_MASK + 0U, // PseudoVWREDSUMU_VS_MF4_E16 + 0U, // PseudoVWREDSUMU_VS_MF4_E16_MASK + 0U, // PseudoVWREDSUMU_VS_MF4_E8 + 0U, // PseudoVWREDSUMU_VS_MF4_E8_MASK + 0U, // PseudoVWREDSUMU_VS_MF8_E8 + 0U, // PseudoVWREDSUMU_VS_MF8_E8_MASK + 0U, // PseudoVWREDSUM_VS_M1_E16 + 0U, // PseudoVWREDSUM_VS_M1_E16_MASK + 0U, // PseudoVWREDSUM_VS_M1_E32 + 0U, // PseudoVWREDSUM_VS_M1_E32_MASK + 0U, // PseudoVWREDSUM_VS_M1_E8 + 0U, // PseudoVWREDSUM_VS_M1_E8_MASK + 0U, // PseudoVWREDSUM_VS_M2_E16 + 0U, // PseudoVWREDSUM_VS_M2_E16_MASK + 0U, // PseudoVWREDSUM_VS_M2_E32 + 0U, // PseudoVWREDSUM_VS_M2_E32_MASK + 0U, // PseudoVWREDSUM_VS_M2_E8 + 0U, // PseudoVWREDSUM_VS_M2_E8_MASK + 0U, // PseudoVWREDSUM_VS_M4_E16 + 0U, // PseudoVWREDSUM_VS_M4_E16_MASK + 0U, // PseudoVWREDSUM_VS_M4_E32 + 0U, // PseudoVWREDSUM_VS_M4_E32_MASK + 0U, // PseudoVWREDSUM_VS_M4_E8 + 0U, // PseudoVWREDSUM_VS_M4_E8_MASK + 0U, // PseudoVWREDSUM_VS_M8_E16 + 0U, // PseudoVWREDSUM_VS_M8_E16_MASK + 0U, // PseudoVWREDSUM_VS_M8_E32 + 0U, // PseudoVWREDSUM_VS_M8_E32_MASK + 0U, // PseudoVWREDSUM_VS_M8_E8 + 0U, // PseudoVWREDSUM_VS_M8_E8_MASK + 0U, // PseudoVWREDSUM_VS_MF2_E16 + 0U, // PseudoVWREDSUM_VS_MF2_E16_MASK + 0U, // PseudoVWREDSUM_VS_MF2_E32 + 0U, // PseudoVWREDSUM_VS_MF2_E32_MASK + 0U, // PseudoVWREDSUM_VS_MF2_E8 + 0U, // PseudoVWREDSUM_VS_MF2_E8_MASK + 0U, // PseudoVWREDSUM_VS_MF4_E16 + 0U, // PseudoVWREDSUM_VS_MF4_E16_MASK + 0U, // PseudoVWREDSUM_VS_MF4_E8 + 0U, // PseudoVWREDSUM_VS_MF4_E8_MASK + 0U, // PseudoVWREDSUM_VS_MF8_E8 + 0U, // PseudoVWREDSUM_VS_MF8_E8_MASK + 0U, // PseudoVWSLL_VI_M1 + 0U, // PseudoVWSLL_VI_M1_MASK + 0U, // PseudoVWSLL_VI_M2 + 0U, // PseudoVWSLL_VI_M2_MASK + 0U, // PseudoVWSLL_VI_M4 + 0U, // PseudoVWSLL_VI_M4_MASK + 0U, // PseudoVWSLL_VI_MF2 + 0U, // PseudoVWSLL_VI_MF2_MASK + 0U, // PseudoVWSLL_VI_MF4 + 0U, // PseudoVWSLL_VI_MF4_MASK + 0U, // PseudoVWSLL_VI_MF8 + 0U, // PseudoVWSLL_VI_MF8_MASK + 0U, // PseudoVWSLL_VV_M1 + 0U, // PseudoVWSLL_VV_M1_MASK + 0U, // PseudoVWSLL_VV_M2 + 0U, // PseudoVWSLL_VV_M2_MASK + 0U, // PseudoVWSLL_VV_M4 + 0U, // PseudoVWSLL_VV_M4_MASK + 0U, // PseudoVWSLL_VV_MF2 + 0U, // PseudoVWSLL_VV_MF2_MASK + 0U, // PseudoVWSLL_VV_MF4 + 0U, // PseudoVWSLL_VV_MF4_MASK + 0U, // PseudoVWSLL_VV_MF8 + 0U, // PseudoVWSLL_VV_MF8_MASK + 0U, // PseudoVWSLL_VX_M1 + 0U, // PseudoVWSLL_VX_M1_MASK + 0U, // PseudoVWSLL_VX_M2 + 0U, // PseudoVWSLL_VX_M2_MASK + 0U, // PseudoVWSLL_VX_M4 + 0U, // PseudoVWSLL_VX_M4_MASK + 0U, // PseudoVWSLL_VX_MF2 + 0U, // PseudoVWSLL_VX_MF2_MASK + 0U, // PseudoVWSLL_VX_MF4 + 0U, // PseudoVWSLL_VX_MF4_MASK + 0U, // PseudoVWSLL_VX_MF8 + 0U, // PseudoVWSLL_VX_MF8_MASK + 0U, // PseudoVWSUBU_VV_M1 + 0U, // PseudoVWSUBU_VV_M1_MASK + 0U, // PseudoVWSUBU_VV_M2 + 0U, // PseudoVWSUBU_VV_M2_MASK + 0U, // PseudoVWSUBU_VV_M4 + 0U, // PseudoVWSUBU_VV_M4_MASK + 0U, // PseudoVWSUBU_VV_MF2 + 0U, // PseudoVWSUBU_VV_MF2_MASK + 0U, // PseudoVWSUBU_VV_MF4 + 0U, // PseudoVWSUBU_VV_MF4_MASK + 0U, // PseudoVWSUBU_VV_MF8 + 0U, // PseudoVWSUBU_VV_MF8_MASK + 0U, // PseudoVWSUBU_VX_M1 + 0U, // PseudoVWSUBU_VX_M1_MASK + 0U, // PseudoVWSUBU_VX_M2 + 0U, // PseudoVWSUBU_VX_M2_MASK + 0U, // PseudoVWSUBU_VX_M4 + 0U, // PseudoVWSUBU_VX_M4_MASK + 0U, // PseudoVWSUBU_VX_MF2 + 0U, // PseudoVWSUBU_VX_MF2_MASK + 0U, // PseudoVWSUBU_VX_MF4 + 0U, // PseudoVWSUBU_VX_MF4_MASK + 0U, // PseudoVWSUBU_VX_MF8 + 0U, // PseudoVWSUBU_VX_MF8_MASK + 0U, // PseudoVWSUBU_WV_M1 + 0U, // PseudoVWSUBU_WV_M1_MASK + 0U, // PseudoVWSUBU_WV_M1_MASK_TIED + 0U, // PseudoVWSUBU_WV_M1_TIED + 0U, // PseudoVWSUBU_WV_M2 + 0U, // PseudoVWSUBU_WV_M2_MASK + 0U, // PseudoVWSUBU_WV_M2_MASK_TIED + 0U, // PseudoVWSUBU_WV_M2_TIED + 0U, // PseudoVWSUBU_WV_M4 + 0U, // PseudoVWSUBU_WV_M4_MASK + 0U, // PseudoVWSUBU_WV_M4_MASK_TIED + 0U, // PseudoVWSUBU_WV_M4_TIED + 0U, // PseudoVWSUBU_WV_MF2 + 0U, // PseudoVWSUBU_WV_MF2_MASK + 0U, // PseudoVWSUBU_WV_MF2_MASK_TIED + 0U, // PseudoVWSUBU_WV_MF2_TIED + 0U, // PseudoVWSUBU_WV_MF4 + 0U, // PseudoVWSUBU_WV_MF4_MASK + 0U, // PseudoVWSUBU_WV_MF4_MASK_TIED + 0U, // PseudoVWSUBU_WV_MF4_TIED + 0U, // PseudoVWSUBU_WV_MF8 + 0U, // PseudoVWSUBU_WV_MF8_MASK + 0U, // PseudoVWSUBU_WV_MF8_MASK_TIED + 0U, // PseudoVWSUBU_WV_MF8_TIED + 0U, // PseudoVWSUBU_WX_M1 + 0U, // PseudoVWSUBU_WX_M1_MASK + 0U, // PseudoVWSUBU_WX_M2 + 0U, // PseudoVWSUBU_WX_M2_MASK + 0U, // PseudoVWSUBU_WX_M4 + 0U, // PseudoVWSUBU_WX_M4_MASK + 0U, // PseudoVWSUBU_WX_MF2 + 0U, // PseudoVWSUBU_WX_MF2_MASK + 0U, // PseudoVWSUBU_WX_MF4 + 0U, // PseudoVWSUBU_WX_MF4_MASK + 0U, // PseudoVWSUBU_WX_MF8 + 0U, // PseudoVWSUBU_WX_MF8_MASK + 0U, // PseudoVWSUB_VV_M1 + 0U, // PseudoVWSUB_VV_M1_MASK + 0U, // PseudoVWSUB_VV_M2 + 0U, // PseudoVWSUB_VV_M2_MASK + 0U, // PseudoVWSUB_VV_M4 + 0U, // PseudoVWSUB_VV_M4_MASK + 0U, // PseudoVWSUB_VV_MF2 + 0U, // PseudoVWSUB_VV_MF2_MASK + 0U, // PseudoVWSUB_VV_MF4 + 0U, // PseudoVWSUB_VV_MF4_MASK + 0U, // PseudoVWSUB_VV_MF8 + 0U, // PseudoVWSUB_VV_MF8_MASK + 0U, // PseudoVWSUB_VX_M1 + 0U, // PseudoVWSUB_VX_M1_MASK + 0U, // PseudoVWSUB_VX_M2 + 0U, // PseudoVWSUB_VX_M2_MASK + 0U, // PseudoVWSUB_VX_M4 + 0U, // PseudoVWSUB_VX_M4_MASK + 0U, // PseudoVWSUB_VX_MF2 + 0U, // PseudoVWSUB_VX_MF2_MASK + 0U, // PseudoVWSUB_VX_MF4 + 0U, // PseudoVWSUB_VX_MF4_MASK + 0U, // PseudoVWSUB_VX_MF8 + 0U, // PseudoVWSUB_VX_MF8_MASK + 0U, // PseudoVWSUB_WV_M1 + 0U, // PseudoVWSUB_WV_M1_MASK + 0U, // PseudoVWSUB_WV_M1_MASK_TIED + 0U, // PseudoVWSUB_WV_M1_TIED + 0U, // PseudoVWSUB_WV_M2 + 0U, // PseudoVWSUB_WV_M2_MASK + 0U, // PseudoVWSUB_WV_M2_MASK_TIED + 0U, // PseudoVWSUB_WV_M2_TIED + 0U, // PseudoVWSUB_WV_M4 + 0U, // PseudoVWSUB_WV_M4_MASK + 0U, // PseudoVWSUB_WV_M4_MASK_TIED + 0U, // PseudoVWSUB_WV_M4_TIED + 0U, // PseudoVWSUB_WV_MF2 + 0U, // PseudoVWSUB_WV_MF2_MASK + 0U, // PseudoVWSUB_WV_MF2_MASK_TIED + 0U, // PseudoVWSUB_WV_MF2_TIED + 0U, // PseudoVWSUB_WV_MF4 + 0U, // PseudoVWSUB_WV_MF4_MASK + 0U, // PseudoVWSUB_WV_MF4_MASK_TIED + 0U, // PseudoVWSUB_WV_MF4_TIED + 0U, // PseudoVWSUB_WV_MF8 + 0U, // PseudoVWSUB_WV_MF8_MASK + 0U, // PseudoVWSUB_WV_MF8_MASK_TIED + 0U, // PseudoVWSUB_WV_MF8_TIED + 0U, // PseudoVWSUB_WX_M1 + 0U, // PseudoVWSUB_WX_M1_MASK + 0U, // PseudoVWSUB_WX_M2 + 0U, // PseudoVWSUB_WX_M2_MASK + 0U, // PseudoVWSUB_WX_M4 + 0U, // PseudoVWSUB_WX_M4_MASK + 0U, // PseudoVWSUB_WX_MF2 + 0U, // PseudoVWSUB_WX_MF2_MASK + 0U, // PseudoVWSUB_WX_MF4 + 0U, // PseudoVWSUB_WX_MF4_MASK + 0U, // PseudoVWSUB_WX_MF8 + 0U, // PseudoVWSUB_WX_MF8_MASK + 0U, // PseudoVXOR_VI_M1 + 0U, // PseudoVXOR_VI_M1_MASK + 0U, // PseudoVXOR_VI_M2 + 0U, // PseudoVXOR_VI_M2_MASK + 0U, // PseudoVXOR_VI_M4 + 0U, // PseudoVXOR_VI_M4_MASK + 0U, // PseudoVXOR_VI_M8 + 0U, // PseudoVXOR_VI_M8_MASK + 0U, // PseudoVXOR_VI_MF2 + 0U, // PseudoVXOR_VI_MF2_MASK + 0U, // PseudoVXOR_VI_MF4 + 0U, // PseudoVXOR_VI_MF4_MASK + 0U, // PseudoVXOR_VI_MF8 + 0U, // PseudoVXOR_VI_MF8_MASK + 0U, // PseudoVXOR_VV_M1 + 0U, // PseudoVXOR_VV_M1_MASK + 0U, // PseudoVXOR_VV_M2 + 0U, // PseudoVXOR_VV_M2_MASK + 0U, // PseudoVXOR_VV_M4 + 0U, // PseudoVXOR_VV_M4_MASK + 0U, // PseudoVXOR_VV_M8 + 0U, // PseudoVXOR_VV_M8_MASK + 0U, // PseudoVXOR_VV_MF2 + 0U, // PseudoVXOR_VV_MF2_MASK + 0U, // PseudoVXOR_VV_MF4 + 0U, // PseudoVXOR_VV_MF4_MASK + 0U, // PseudoVXOR_VV_MF8 + 0U, // PseudoVXOR_VV_MF8_MASK + 0U, // PseudoVXOR_VX_M1 + 0U, // PseudoVXOR_VX_M1_MASK + 0U, // PseudoVXOR_VX_M2 + 0U, // PseudoVXOR_VX_M2_MASK + 0U, // PseudoVXOR_VX_M4 + 0U, // PseudoVXOR_VX_M4_MASK + 0U, // PseudoVXOR_VX_M8 + 0U, // PseudoVXOR_VX_M8_MASK + 0U, // PseudoVXOR_VX_MF2 + 0U, // PseudoVXOR_VX_MF2_MASK + 0U, // PseudoVXOR_VX_MF4 + 0U, // PseudoVXOR_VX_MF4_MASK + 0U, // PseudoVXOR_VX_MF8 + 0U, // PseudoVXOR_VX_MF8_MASK + 0U, // PseudoVZEXT_VF2_M1 + 0U, // PseudoVZEXT_VF2_M1_MASK + 0U, // PseudoVZEXT_VF2_M2 + 0U, // PseudoVZEXT_VF2_M2_MASK + 0U, // PseudoVZEXT_VF2_M4 + 0U, // PseudoVZEXT_VF2_M4_MASK + 0U, // PseudoVZEXT_VF2_M8 + 0U, // PseudoVZEXT_VF2_M8_MASK + 0U, // PseudoVZEXT_VF2_MF2 + 0U, // PseudoVZEXT_VF2_MF2_MASK + 0U, // PseudoVZEXT_VF2_MF4 + 0U, // PseudoVZEXT_VF2_MF4_MASK + 0U, // PseudoVZEXT_VF4_M1 + 0U, // PseudoVZEXT_VF4_M1_MASK + 0U, // PseudoVZEXT_VF4_M2 + 0U, // PseudoVZEXT_VF4_M2_MASK + 0U, // PseudoVZEXT_VF4_M4 + 0U, // PseudoVZEXT_VF4_M4_MASK + 0U, // PseudoVZEXT_VF4_M8 + 0U, // PseudoVZEXT_VF4_M8_MASK + 0U, // PseudoVZEXT_VF4_MF2 + 0U, // PseudoVZEXT_VF4_MF2_MASK + 0U, // PseudoVZEXT_VF8_M1 + 0U, // PseudoVZEXT_VF8_M1_MASK + 0U, // PseudoVZEXT_VF8_M2 + 0U, // PseudoVZEXT_VF8_M2_MASK + 0U, // PseudoVZEXT_VF8_M4 + 0U, // PseudoVZEXT_VF8_M4_MASK + 0U, // PseudoVZEXT_VF8_M8 + 0U, // PseudoVZEXT_VF8_M8_MASK + 33592938U, // PseudoZEXT_H + 33603666U, // PseudoZEXT_W + 0U, // ReadCycleWide + 0U, // ReadFFLAGS + 0U, // ReadFRM + 0U, // Select_FPR16INX_Using_CC_GPR + 0U, // Select_FPR16_Using_CC_GPR + 0U, // Select_FPR32INX_Using_CC_GPR + 0U, // Select_FPR32_Using_CC_GPR + 0U, // Select_FPR64IN32X_Using_CC_GPR + 0U, // Select_FPR64INX_Using_CC_GPR + 0U, // Select_FPR64_Using_CC_GPR + 0U, // Select_GPR_Using_CC_GPR + 0U, // SplitF64Pseudo + 0U, // SplitF64Pseudo_INX + 0U, // SwapFRMImm + 0U, // WriteFFLAGS + 0U, // WriteFRM + 0U, // WriteFRMImm + 0U, // WriteVXRMImm + 2147519996U, // ADD + 2147522610U, // ADDI + 2147533015U, // ADDIW + 2147533000U, // ADDW + 2147533289U, // ADD_UW + 39067U, // AES32DSI + 39017U, // AES32DSMI + 39077U, // AES32ESI + 39028U, // AES32ESMI + 2147525813U, // AES64DS + 2147524247U, // AES64DSM + 2147525822U, // AES64ES + 2147524257U, // AES64ESM + 33594885U, // AES64IM + 2147522581U, // AES64KS1I + 2147516763U, // AES64KS2 + 1075874940U, // AMOADD_D + 1075880193U, // AMOADD_D_AQ + 1075878963U, // AMOADD_D_AQ_RL + 1075878644U, // AMOADD_D_RL + 1075887982U, // AMOADD_W + 1075880358U, // AMOADD_W_AQ + 1075879154U, // AMOADD_W_AQ_RL + 1075878809U, // AMOADD_W_RL + 1075874950U, // AMOAND_D + 1075880206U, // AMOAND_D_AQ + 1075878978U, // AMOAND_D_AQ_RL + 1075878657U, // AMOAND_D_RL + 1075887992U, // AMOAND_W + 1075880371U, // AMOAND_W_AQ + 1075879169U, // AMOAND_W_AQ_RL + 1075878822U, // AMOAND_W_RL + 6360386U, // AMOCAS_D_RV32 + 6365530U, // AMOCAS_D_RV32_AQ + 6364314U, // AMOCAS_D_RV32_AQ_RL + 6363981U, // AMOCAS_D_RV32_RL + 6360386U, // AMOCAS_D_RV64 + 6365530U, // AMOCAS_D_RV64_AQ + 6364314U, // AMOCAS_D_RV64_AQ_RL + 6363981U, // AMOCAS_D_RV64_RL + 6365422U, // AMOCAS_Q + 6365584U, // AMOCAS_Q_AQ + 6364376U, // AMOCAS_Q_AQ_RL + 6364035U, // AMOCAS_Q_RL + 6373446U, // AMOCAS_W + 6365695U, // AMOCAS_W_AQ + 6364505U, // AMOCAS_W_AQ_RL + 6364146U, // AMOCAS_W_RL + 1075875207U, // AMOMAXU_D + 1075880309U, // AMOMAXU_D_AQ + 1075879097U, // AMOMAXU_D_AQ_RL + 1075878760U, // AMOMAXU_D_RL + 1075888244U, // AMOMAXU_W + 1075880474U, // AMOMAXU_W_AQ + 1075879288U, // AMOMAXU_W_AQ_RL + 1075878925U, // AMOMAXU_W_RL + 1075875290U, // AMOMAX_D + 1075880323U, // AMOMAX_D_AQ + 1075879113U, // AMOMAX_D_AQ_RL + 1075878774U, // AMOMAX_D_RL + 1075888292U, // AMOMAX_W + 1075880488U, // AMOMAX_W_AQ + 1075879304U, // AMOMAX_W_AQ_RL + 1075878939U, // AMOMAX_W_RL + 1075875185U, // AMOMINU_D + 1075880295U, // AMOMINU_D_AQ + 1075879081U, // AMOMINU_D_AQ_RL + 1075878746U, // AMOMINU_D_RL + 1075888218U, // AMOMINU_W + 1075880460U, // AMOMINU_W_AQ + 1075879272U, // AMOMINU_W_AQ_RL + 1075878911U, // AMOMINU_W_RL + 1075875047U, // AMOMIN_D + 1075880219U, // AMOMIN_D_AQ + 1075878993U, // AMOMIN_D_AQ_RL + 1075878670U, // AMOMIN_D_RL + 1075888140U, // AMOMIN_W + 1075880384U, // AMOMIN_W_AQ + 1075879184U, // AMOMIN_W_AQ_RL + 1075878835U, // AMOMIN_W_RL + 1075875109U, // AMOOR_D + 1075880257U, // AMOOR_D_AQ + 1075879037U, // AMOOR_D_AQ_RL + 1075878708U, // AMOOR_D_RL + 1075888169U, // AMOOR_W + 1075880422U, // AMOOR_W_AQ + 1075879228U, // AMOOR_W_AQ_RL + 1075878873U, // AMOOR_W_RL + 1075875069U, // AMOSWAP_D + 1075880234U, // AMOSWAP_D_AQ + 1075879010U, // AMOSWAP_D_AQ_RL + 1075878685U, // AMOSWAP_D_RL + 1075888152U, // AMOSWAP_W + 1075880399U, // AMOSWAP_W_AQ + 1075879201U, // AMOSWAP_W_AQ_RL + 1075878850U, // AMOSWAP_W_RL + 1075875118U, // AMOXOR_D + 1075880269U, // AMOXOR_D_AQ + 1075879051U, // AMOXOR_D_AQ_RL + 1075878720U, // AMOXOR_D_RL + 1075888178U, // AMOXOR_W + 1075880434U, // AMOXOR_W_AQ + 1075879242U, // AMOXOR_W_AQ_RL + 1075878885U, // AMOXOR_W_RL + 2147520074U, // AND + 2147522618U, // ANDI + 2147524429U, // ANDN + 33590310U, // AUIPC + 2147525247U, // BCLR + 2147522687U, // BCLRI + 1342218805U, // BEQ + 2147526245U, // BEXT + 2147522756U, // BEXTI + 1342213828U, // BGE + 1342219925U, // BGEU + 2147531267U, // BINV + 2147523101U, // BINVI + 1342219825U, // BLT + 1342220093U, // BLTU + 1342213844U, // BNE + 33588212U, // BREV8 + 2147526171U, // BSET + 2147522743U, // BSETI + 106277U, // CBO_CLEAN + 104384U, // CBO_FLUSH + 105162U, // CBO_INVAL + 106594U, // CBO_ZERO + 2147524013U, // CLMUL + 2147522426U, // CLMULH + 2147525253U, // CLMULR + 33605269U, // CLZ + 33604237U, // CLZW + 18424U, // CMOP1 + 18431U, // CMOP11 + 18446U, // CMOP13 + 18461U, // CMOP15 + 18439U, // CMOP3 + 18454U, // CMOP5 + 18469U, // CMOP7 + 18476U, // CMOP9 + 304680U, // CM_JALT + 304673U, // CM_JT + 33596552U, // CM_MVA01S + 33587332U, // CM_MVSA01 + 139408U, // CM_POP + 140813U, // CM_POPRET + 149180U, // CM_POPRETZ + 137163U, // CM_PUSH + 33595544U, // CPOP + 33603902U, // CPOPW + 8424493U, // CSRRC + 8427560U, // CSRRCI + 8430817U, // CSRRS + 8427695U, // CSRRSI + 8438108U, // CSRRW + 8428111U, // CSRRWI + 33605303U, // CTZ + 33604243U, // CTZW + 33596579U, // CV_ABS + 33589916U, // CV_ABS_B + 33592839U, // CV_ABS_H + 40772U, // CV_ADDN + 2954961559U, // CV_ADDNR + 40817U, // CV_ADDRN + 2954961580U, // CV_ADDRNR + 41014U, // CV_ADDUN + 2954961626U, // CV_ADDUNR + 40902U, // CV_ADDURN + 2954961603U, // CV_ADDURNR + 2147518345U, // CV_ADD_B + 2147516786U, // CV_ADD_DIV2 + 2147517079U, // CV_ADD_DIV4 + 2147517448U, // CV_ADD_DIV8 + 2147521205U, // CV_ADD_H + 2147518533U, // CV_ADD_SCI_B + 2147521350U, // CV_ADD_SCI_H + 2147517938U, // CV_ADD_SC_B + 2147520788U, // CV_ADD_SC_H + 2147518355U, // CV_AND_B + 2147521242U, // CV_AND_H + 2147518547U, // CV_AND_SCI_B + 2147521364U, // CV_AND_SCI_H + 2147517951U, // CV_AND_SC_B + 2147520801U, // CV_AND_SC_H + 2147519239U, // CV_AVGU_B + 2147522188U, // CV_AVGU_H + 2147518875U, // CV_AVGU_SCI_B + 2147521710U, // CV_AVGU_SCI_H + 2147518258U, // CV_AVGU_SC_B + 2147521108U, // CV_AVGU_SC_H + 2147518415U, // CV_AVG_B + 2147521312U, // CV_AVG_H + 2147518609U, // CV_AVG_SCI_B + 2147521444U, // CV_AVG_SCI_H + 2147518009U, // CV_AVG_SC_B + 2147520859U, // CV_AVG_SC_H + 41596U, // CV_BCLR + 2147525386U, // CV_BCLRR + 1342217868U, // CV_BEQIMM + 47553U, // CV_BITREV + 1342217857U, // CV_BNEIMM + 42520U, // CV_BSET + 2147525409U, // CV_BSETR + 33590230U, // CV_CLB + 2147524723U, // CV_CLIP + 2147525376U, // CV_CLIPR + 2147526412U, // CV_CLIPU + 2147525431U, // CV_CLIPUR + 2147519101U, // CV_CMPEQ_B + 2147522006U, // CV_CMPEQ_H + 2147518766U, // CV_CMPEQ_SCI_B + 2147521601U, // CV_CMPEQ_SCI_H + 2147518156U, // CV_CMPEQ_SC_B + 2147521006U, // CV_CMPEQ_SC_H + 2147519213U, // CV_CMPGEU_B + 2147522162U, // CV_CMPGEU_H + 2147518841U, // CV_CMPGEU_SCI_B + 2147521676U, // CV_CMPGEU_SCI_H + 2147518226U, // CV_CMPGEU_SC_B + 2147521076U, // CV_CMPGEU_SC_H + 2147518365U, // CV_CMPGE_B + 2147521262U, // CV_CMPGE_H + 2147518561U, // CV_CMPGE_SCI_B + 2147521378U, // CV_CMPGE_SCI_H + 2147517964U, // CV_CMPGE_SC_B + 2147520814U, // CV_CMPGE_SC_H + 2147519276U, // CV_CMPGTU_B + 2147522236U, // CV_CMPGTU_H + 2147518905U, // CV_CMPGTU_SCI_B + 2147521740U, // CV_CMPGTU_SCI_H + 2147518286U, // CV_CMPGTU_SC_B + 2147521136U, // CV_CMPGTU_SC_H + 2147519156U, // CV_CMPGT_B + 2147522089U, // CV_CMPGT_H + 2147518809U, // CV_CMPGT_SCI_B + 2147521644U, // CV_CMPGT_SCI_H + 2147518196U, // CV_CMPGT_SC_B + 2147521046U, // CV_CMPGT_SC_H + 2147519226U, // CV_CMPLEU_B + 2147522175U, // CV_CMPLEU_H + 2147518858U, // CV_CMPLEU_SCI_B + 2147521693U, // CV_CMPLEU_SCI_H + 2147518242U, // CV_CMPLEU_SC_B + 2147521092U, // CV_CMPLEU_SC_H + 2147518391U, // CV_CMPLE_B + 2147521288U, // CV_CMPLE_H + 2147518577U, // CV_CMPLE_SCI_B + 2147521412U, // CV_CMPLE_SCI_H + 2147517979U, // CV_CMPLE_SC_B + 2147520829U, // CV_CMPLE_SC_H + 2147519289U, // CV_CMPLTU_B + 2147522249U, // CV_CMPLTU_H + 2147518922U, // CV_CMPLTU_SCI_B + 2147521757U, // CV_CMPLTU_SCI_H + 2147518302U, // CV_CMPLTU_SC_B + 2147521152U, // CV_CMPLTU_SC_H + 2147519168U, // CV_CMPLT_B + 2147522108U, // CV_CMPLT_H + 2147518825U, // CV_CMPLT_SCI_B + 2147521660U, // CV_CMPLT_SCI_H + 2147518211U, // CV_CMPLT_SC_B + 2147521061U, // CV_CMPLT_SC_H + 2147518403U, // CV_CMPNE_B + 2147521300U, // CV_CMPNE_H + 2147518593U, // CV_CMPNE_SCI_B + 2147521428U, // CV_CMPNE_SCI_H + 2147517994U, // CV_CMPNE_SC_B + 2147520844U, // CV_CMPNE_SC_H + 33596987U, // CV_CNT + 33593961U, // CV_CPLXCONJ + 2954958835U, // CV_CPLXMUL_I + 2954953087U, // CV_CPLXMUL_I_DIV2 + 2954953380U, // CV_CPLXMUL_I_DIV4 + 2954953749U, // CV_CPLXMUL_I_DIV8 + 2954961478U, // CV_CPLXMUL_R + 2954953124U, // CV_CPLXMUL_R_DIV2 + 2954953417U, // CV_CPLXMUL_R_DIV4 + 2954953786U, // CV_CPLXMUL_R_DIV8 + 2147519024U, // CV_DOTSP_B + 2147521914U, // CV_DOTSP_H + 2147518665U, // CV_DOTSP_SCI_B + 2147521500U, // CV_DOTSP_SCI_H + 2147518061U, // CV_DOTSP_SC_B + 2147520911U, // CV_DOTSP_SC_H + 2147519076U, // CV_DOTUP_B + 2147521966U, // CV_DOTUP_H + 2147518733U, // CV_DOTUP_SCI_B + 2147521568U, // CV_DOTUP_SCI_H + 2147518125U, // CV_DOTUP_SC_B + 2147520975U, // CV_DOTUP_SC_H + 2147519049U, // CV_DOTUSP_B + 2147521939U, // CV_DOTUSP_H + 2147518698U, // CV_DOTUSP_SCI_B + 2147521533U, // CV_DOTUSP_SCI_H + 2147518092U, // CV_DOTUSP_SC_B + 2147520942U, // CV_DOTUSP_SC_H + 1679868177U, // CV_ELW + 33596587U, // CV_EXTBS + 33605220U, // CV_EXTBZ + 33596615U, // CV_EXTHS + 33605259U, // CV_EXTHZ + 42488U, // CV_EXTRACT + 2147525396U, // CV_EXTRACTR + 42790U, // CV_EXTRACTU + 2147525442U, // CV_EXTRACTUR + 2147519261U, // CV_EXTRACTU_B + 2147522221U, // CV_EXTRACTU_H + 2147519142U, // CV_EXTRACT_B + 2147522075U, // CV_EXTRACT_H + 33587381U, // CV_FF1 + 33587447U, // CV_FL1 + 807478858U, // CV_INSERT + 2954961707U, // CV_INSERTR + 2954955468U, // CV_INSERT_B + 2954958408U, // CV_INSERT_H + 11052666U, // CV_LBU_ri_inc + 12625530U, // CV_LBU_rr + 11052666U, // CV_LBU_rr_inc + 11045839U, // CV_LB_ri_inc + 12618703U, // CV_LB_rr + 11045839U, // CV_LB_rr_inc + 11052723U, // CV_LHU_ri_inc + 12625587U, // CV_LHU_rr + 11052723U, // CV_LHU_rr_inc + 11048814U, // CV_LH_ri_inc + 12621678U, // CV_LH_rr + 11048814U, // CV_LH_rr_inc + 11059466U, // CV_LW_ri_inc + 12632330U, // CV_LW_rr + 11059466U, // CV_LW_rr_inc + 2954955796U, // CV_MAC + 807477248U, // CV_MACHHSN + 807477131U, // CV_MACHHSRN + 807477312U, // CV_MACHHUN + 807477201U, // CV_MACHHURN + 807477238U, // CV_MACSN + 807477120U, // CV_MACSRN + 807477292U, // CV_MACUN + 807477179U, // CV_MACURN + 2147533540U, // CV_MAX + 2147526562U, // CV_MAXU + 2147519302U, // CV_MAXU_B + 2147522273U, // CV_MAXU_H + 2147518939U, // CV_MAXU_SCI_B + 2147521774U, // CV_MAXU_SCI_H + 2147518318U, // CV_MAXU_SC_B + 2147521168U, // CV_MAXU_SC_H + 2147519327U, // CV_MAX_B + 2147522325U, // CV_MAX_H + 2147518954U, // CV_MAX_SCI_B + 2147521789U, // CV_MAX_SCI_H + 2147518332U, // CV_MAX_SC_B + 2147521182U, // CV_MAX_SC_H + 2147524435U, // CV_MIN + 2147526403U, // CV_MINU + 2147519250U, // CV_MINU_B + 2147522210U, // CV_MINU_H + 2147518890U, // CV_MINU_SCI_B + 2147521725U, // CV_MINU_SCI_H + 2147518272U, // CV_MINU_SC_B + 2147521122U, // CV_MINU_SC_H + 2147519001U, // CV_MIN_B + 2147521886U, // CV_MIN_H + 2147518651U, // CV_MIN_SCI_B + 2147521486U, // CV_MIN_SCI_H + 2147518048U, // CV_MIN_SC_B + 2147520898U, // CV_MIN_SC_H + 2954962718U, // CV_MSU + 40972U, // CV_MULHHSN + 40856U, // CV_MULHHSRN + 41036U, // CV_MULHHUN + 40926U, // CV_MULHHURN + 40984U, // CV_MULSN + 40869U, // CV_MULSRN + 41048U, // CV_MULUN + 40939U, // CV_MULURN + 2147519113U, // CV_OR_B + 2147522026U, // CV_OR_H + 2147518782U, // CV_OR_SCI_B + 2147521617U, // CV_OR_SCI_H + 2147518171U, // CV_OR_SC_B + 2147521021U, // CV_OR_SC_H + 2147523190U, // CV_PACK + 2954955256U, // CV_PACKHI_B + 2954955299U, // CV_PACKLO_B + 2147521819U, // CV_PACK_H + 2147525361U, // CV_ROR + 11078662U, // CV_SB_ri_inc + 12618758U, // CV_SB_rr + 11078662U, // CV_SB_rr_inc + 2954955324U, // CV_SDOTSP_B + 2954958214U, // CV_SDOTSP_H + 2954954969U, // CV_SDOTSP_SCI_B + 2954957804U, // CV_SDOTSP_SCI_H + 2954954364U, // CV_SDOTSP_SC_B + 2954957214U, // CV_SDOTSP_SC_H + 2954955376U, // CV_SDOTUP_B + 2954958266U, // CV_SDOTUP_H + 2954955037U, // CV_SDOTUP_SCI_B + 2954957872U, // CV_SDOTUP_SCI_H + 2954954428U, // CV_SDOTUP_SC_B + 2954957278U, // CV_SDOTUP_SC_H + 2954955350U, // CV_SDOTUSP_B + 2954958240U, // CV_SDOTUSP_H + 2954955003U, // CV_SDOTUSP_SCI_B + 2954957838U, // CV_SDOTUSP_SCI_H + 2954954396U, // CV_SDOTUSP_SC_B + 2954957246U, // CV_SDOTUSP_SC_H + 2954954158U, // CV_SHUFFLE2_B + 2954956988U, // CV_SHUFFLE2_H + 2147518425U, // CV_SHUFFLEI0_SCI_B + 2147518445U, // CV_SHUFFLEI1_SCI_B + 2147518465U, // CV_SHUFFLEI2_SCI_B + 2147518485U, // CV_SHUFFLEI3_SCI_B + 2147518377U, // CV_SHUFFLE_B + 2147521274U, // CV_SHUFFLE_H + 2147521394U, // CV_SHUFFLE_SCI_H + 11081642U, // CV_SH_ri_inc + 12621738U, // CV_SH_rr + 11081642U, // CV_SH_rr_inc + 2147526148U, // CV_SLET + 2147526451U, // CV_SLETU + 2147518981U, // CV_SLL_B + 2147521840U, // CV_SLL_H + 2147518623U, // CV_SLL_SCI_B + 2147521458U, // CV_SLL_SCI_H + 2147518022U, // CV_SLL_SC_B + 2147520872U, // CV_SLL_SC_H + 2147517885U, // CV_SRA_B + 2147520715U, // CV_SRA_H + 2147518505U, // CV_SRA_SCI_B + 2147521322U, // CV_SRA_SCI_H + 2147517912U, // CV_SRA_SC_B + 2147520762U, // CV_SRA_SC_H + 2147518991U, // CV_SRL_B + 2147521850U, // CV_SRL_H + 2147518637U, // CV_SRL_SCI_B + 2147521472U, // CV_SRL_SCI_H + 2147518035U, // CV_SRL_SC_B + 2147520885U, // CV_SRL_SC_H + 40752U, // CV_SUBN + 2954961549U, // CV_SUBNR + 40807U, // CV_SUBRN + 2954961569U, // CV_SUBRNR + 2147523164U, // CV_SUBROTMJ + 2147516818U, // CV_SUBROTMJ_DIV2 + 2147517111U, // CV_SUBROTMJ_DIV4 + 2147517480U, // CV_SUBROTMJ_DIV8 + 40994U, // CV_SUBUN + 2954961615U, // CV_SUBUNR + 40880U, // CV_SUBURN + 2954961591U, // CV_SUBURNR + 2147517895U, // CV_SUB_B + 2147516773U, // CV_SUB_DIV2 + 2147517066U, // CV_SUB_DIV4 + 2147517435U, // CV_SUB_DIV8 + 2147520725U, // CV_SUB_H + 2147518519U, // CV_SUB_SCI_B + 2147521336U, // CV_SUB_SCI_H + 2147517925U, // CV_SUB_SC_B + 2147520775U, // CV_SUB_SC_H + 11092384U, // CV_SW_ri_inc + 12632480U, // CV_SW_rr + 11092384U, // CV_SW_rr_inc + 2147519122U, // CV_XOR_B + 2147522035U, // CV_XOR_H + 2147518795U, // CV_XOR_SCI_B + 2147521630U, // CV_XOR_SCI_H + 2147518183U, // CV_XOR_SC_B + 2147521033U, // CV_XOR_SC_H + 2147534490U, // CZERO_EQZ + 2147534446U, // CZERO_NEZ + 35720698U, // C_ADD + 35723312U, // C_ADDI + 35725470U, // C_ADDI16SP + 2147524443U, // C_ADDI4SPN + 35733717U, // C_ADDIW + 35723312U, // C_ADDI_HINT_IMM_ZERO + 35723312U, // C_ADDI_NOP + 35733702U, // C_ADDW + 35720698U, // C_ADD_HINT + 35720776U, // C_AND + 35723320U, // C_ANDI + 14730917U, // C_BEQZ + 14730873U, // C_BNEZ + 18618U, // C_EBREAK + 1679855169U, // C_FLD + 1679859890U, // C_FLDSP + 1679868185U, // C_FLW + 1679859924U, // C_FLWSP + 1679855261U, // C_FSD + 1679859907U, // C_FSDSP + 1679868342U, // C_FSW + 1679859941U, // C_FSWSP + 170583U, // C_J + 170691U, // C_JAL + 303732U, // C_JALR + 303726U, // C_JR + 1679861363U, // C_LBU + 1679855163U, // C_LD + 1679859882U, // C_LDSP + 1679857512U, // C_LH + 1679861420U, // C_LHU + 33593408U, // C_LI + 33593408U, // C_LI_HINT + 33593547U, // C_LUI + 33593547U, // C_LUI_HINT + 1679868164U, // C_LW + 1679859916U, // C_LWSP + 35724710U, // C_MUL + 33602045U, // C_MV + 33602045U, // C_MV_HINT + 18806U, // C_NOP + 303241U, // C_NOP_HINT + 337475U, // C_NOT + 35726053U, // C_OR + 1679854592U, // C_SB + 1679855255U, // C_SD + 1679859899U, // C_SDSP + 330457U, // C_SEXT_B + 333406U, // C_SEXT_H + 1679857572U, // C_SH + 35723334U, // C_SLLI + 328280U, // C_SLLI64_HINT + 35723334U, // C_SLLI_HINT + 35723296U, // C_SRAI + 328270U, // C_SRAI64_HINT + 35723342U, // C_SRLI + 328290U, // C_SRLI64_HINT + 301695U, // C_SSPOPCHK + 301012U, // C_SSPUSH + 35720205U, // C_SUB + 35733694U, // C_SUBW + 1679868314U, // C_SW + 1679859933U, // C_SWSP + 18798U, // C_UNIMP + 35726073U, // C_XOR + 330467U, // C_ZEXT_B + 333416U, // C_ZEXT_H + 344144U, // C_ZEXT_W + 2147531256U, // DIV + 2147526482U, // DIVU + 2147533335U, // DIVUW + 2147533399U, // DIVW + 18865U, // DRET + 18620U, // EBREAK + 18687U, // ECALL + 35937U, // FADD_D + 35937U, // FADD_D_IN32X + 35937U, // FADD_D_INX + 37567U, // FADD_H + 37567U, // FADD_H_INX + 41858U, // FADD_S + 41858U, // FADD_S_INX + 33590604U, // FCLASS_D + 33590604U, // FCLASS_D_IN32X + 33590604U, // FCLASS_D_INX + 33592849U, // FCLASS_H + 33592849U, // FCLASS_H_INX + 33596447U, // FCLASS_S + 33596447U, // FCLASS_S_INX + 100699560U, // FCVTMOD_W_D + 100705104U, // FCVT_BF16_S + 134255275U, // FCVT_D_H + 134255275U, // FCVT_D_H_IN32X + 134255275U, // FCVT_D_H_INX + 100702859U, // FCVT_D_L + 100706012U, // FCVT_D_LU + 100706012U, // FCVT_D_LU_INX + 100702859U, // FCVT_D_L_INX + 134259576U, // FCVT_D_S + 134259576U, // FCVT_D_S_IN32X + 134259576U, // FCVT_D_S_INX + 134266724U, // FCVT_D_W + 134260568U, // FCVT_D_WU + 134260568U, // FCVT_D_WU_IN32X + 134260568U, // FCVT_D_WU_INX + 134266724U, // FCVT_D_W_IN32X + 134266724U, // FCVT_D_W_INX + 100699297U, // FCVT_H_D + 100699297U, // FCVT_H_D_IN32X + 100699297U, // FCVT_H_D_INX + 100702869U, // FCVT_H_L + 100706023U, // FCVT_H_LU + 100706023U, // FCVT_H_LU_INX + 100702869U, // FCVT_H_L_INX + 100705208U, // FCVT_H_S + 100705208U, // FCVT_H_S_INX + 100712438U, // FCVT_H_W + 100706147U, // FCVT_H_WU + 100706147U, // FCVT_H_WU_INX + 100712438U, // FCVT_H_W_INX + 100699494U, // FCVT_LU_D + 100699494U, // FCVT_LU_D_INX + 100701847U, // FCVT_LU_H + 100701847U, // FCVT_LU_H_INX + 100705337U, // FCVT_LU_S + 100705337U, // FCVT_LU_S_INX + 100699323U, // FCVT_L_D + 100699323U, // FCVT_L_D_INX + 100701478U, // FCVT_L_H + 100701478U, // FCVT_L_H_INX + 100705234U, // FCVT_L_S + 100705234U, // FCVT_L_S_INX + 100696955U, // FCVT_S_BF16 + 100699448U, // FCVT_S_D + 100699448U, // FCVT_S_D_IN32X + 100699448U, // FCVT_S_D_INX + 134256125U, // FCVT_S_H + 134256125U, // FCVT_S_H_INX + 100702879U, // FCVT_S_L + 100706034U, // FCVT_S_LU + 100706034U, // FCVT_S_LU_INX + 100702879U, // FCVT_S_L_INX + 100712508U, // FCVT_S_W + 100706158U, // FCVT_S_WU + 100706158U, // FCVT_S_WU_INX + 100712508U, // FCVT_S_W_INX + 100699516U, // FCVT_WU_D + 100699516U, // FCVT_WU_D_IN32X + 100699516U, // FCVT_WU_D_INX + 100701910U, // FCVT_WU_H + 100701910U, // FCVT_WU_H_INX + 100705348U, // FCVT_WU_S + 100705348U, // FCVT_WU_S_INX + 100699573U, // FCVT_W_D + 100699573U, // FCVT_W_D_IN32X + 100699573U, // FCVT_W_D_INX + 100701954U, // FCVT_W_H + 100701954U, // FCVT_W_H_INX + 100705367U, // FCVT_W_S + 100705367U, // FCVT_W_S_INX + 36242U, // FDIV_D + 36242U, // FDIV_D_IN32X + 36242U, // FDIV_D_INX + 38636U, // FDIV_H + 38636U, // FDIV_H_INX + 42063U, // FDIV_S + 42063U, // FDIV_S_INX + 200381U, // FENCE + 18606U, // FENCE_I + 18772U, // FENCE_TSO + 2147519752U, // FEQ_D + 2147519752U, // FEQ_D_IN32X + 2147519752U, // FEQ_D_INX + 2147521991U, // FEQ_H + 2147521991U, // FEQ_H_INX + 2147525640U, // FEQ_S + 2147525640U, // FEQ_S_INX + 1679855171U, // FLD + 2147519759U, // FLEQ_D + 2147521998U, // FLEQ_H + 2147525647U, // FLEQ_S + 2147519642U, // FLE_D + 2147519642U, // FLE_D_IN32X + 2147519642U, // FLE_D_INX + 2147521281U, // FLE_H + 2147521281U, // FLE_H_INX + 2147525543U, // FLE_S + 2147525543U, // FLE_S_INX + 1679857525U, // FLH + 16813227U, // FLI_D + 16815371U, // FLI_H + 16819138U, // FLI_S + 2147519767U, // FLTQ_D + 2147522018U, // FLTQ_H + 2147525655U, // FLTQ_S + 2147519830U, // FLT_D + 2147519830U, // FLT_D_IN32X + 2147519830U, // FLT_D_INX + 2147522101U, // FLT_H + 2147522101U, // FLT_H_INX + 2147525673U, // FLT_S + 2147525673U, // FLT_S_INX + 1679868187U, // FLW + 35945U, // FMADD_D + 35945U, // FMADD_D_IN32X + 35945U, // FMADD_D_INX + 37575U, // FMADD_H + 37575U, // FMADD_H_INX + 41866U, // FMADD_S + 41866U, // FMADD_S_INX + 2147519702U, // FMAXM_D + 2147521877U, // FMAXM_H + 2147525613U, // FMAXM_S + 2147519954U, // FMAX_D + 2147519954U, // FMAX_D_IN32X + 2147519954U, // FMAX_D_INX + 2147522335U, // FMAX_H + 2147522335U, // FMAX_H_INX + 2147525738U, // FMAX_S + 2147525738U, // FMAX_S_INX + 2147519693U, // FMINM_D + 2147521868U, // FMINM_H + 2147525604U, // FMINM_S + 2147519711U, // FMIN_D + 2147519711U, // FMIN_D_IN32X + 2147519711U, // FMIN_D_INX + 2147521896U, // FMIN_H + 2147521896U, // FMIN_H_INX + 2147525622U, // FMIN_S + 2147525622U, // FMIN_S_INX + 35912U, // FMSUB_D + 35912U, // FMSUB_D_IN32X + 35912U, // FMSUB_D_INX + 37095U, // FMSUB_H + 37095U, // FMSUB_H_INX + 41829U, // FMSUB_S + 41829U, // FMSUB_S_INX + 36037U, // FMUL_D + 36037U, // FMUL_D_IN32X + 36037U, // FMUL_D_INX + 38212U, // FMUL_H + 38212U, // FMUL_H_INX + 41948U, // FMUL_S + 41948U, // FMUL_S_INX + 33590719U, // FMVH_X_D + 2147533474U, // FMVP_D_X + 33604268U, // FMV_D_X + 33604277U, // FMV_H_X + 33604315U, // FMV_W_X + 33590729U, // FMV_X_D + 33593100U, // FMV_X_H + 33603739U, // FMV_X_W + 33603739U, // FMV_X_W_FPR64 + 35954U, // FNMADD_D + 35954U, // FNMADD_D_IN32X + 35954U, // FNMADD_D_INX + 37584U, // FNMADD_H + 37584U, // FNMADD_H_INX + 41875U, // FNMADD_S + 41875U, // FNMADD_S_INX + 35921U, // FNMSUB_D + 35921U, // FNMSUB_D_IN32X + 35921U, // FNMSUB_D_INX + 37104U, // FNMSUB_H + 37104U, // FNMSUB_H_INX + 41838U, // FNMSUB_S + 41838U, // FNMSUB_S_INX + 100699630U, // FROUNDNX_D + 100702001U, // FROUNDNX_H + 100705404U, // FROUNDNX_S + 100699280U, // FROUND_D + 100700900U, // FROUND_H + 100705181U, // FROUND_S + 1679855263U, // FSD + 2147519729U, // FSGNJN_D + 2147519729U, // FSGNJN_D_IN32X + 2147519729U, // FSGNJN_D_INX + 2147521904U, // FSGNJN_H + 2147521904U, // FSGNJN_H_INX + 2147525630U, // FSGNJN_S + 2147525630U, // FSGNJN_S_INX + 2147519972U, // FSGNJX_D + 2147519972U, // FSGNJX_D_IN32X + 2147519972U, // FSGNJX_D_INX + 2147522343U, // FSGNJX_H + 2147522343U, // FSGNJX_H_INX + 2147525746U, // FSGNJX_S + 2147525746U, // FSGNJX_S_INX + 2147519666U, // FSGNJ_D + 2147519666U, // FSGNJ_D_IN32X + 2147519666U, // FSGNJ_D_INX + 2147521810U, // FSGNJ_H + 2147521810U, // FSGNJ_H_INX + 2147525577U, // FSGNJ_S + 2147525577U, // FSGNJ_S_INX + 1679857585U, // FSH + 100699485U, // FSQRT_D + 100699485U, // FSQRT_D_IN32X + 100699485U, // FSQRT_D_INX + 100701781U, // FSQRT_H + 100701781U, // FSQRT_H_INX + 100705328U, // FSQRT_S + 100705328U, // FSQRT_S_INX + 35904U, // FSUB_D + 35904U, // FSUB_D_IN32X + 35904U, // FSUB_D_INX + 37087U, // FSUB_H + 37087U, // FSUB_H_INX + 41821U, // FSUB_S + 41821U, // FSUB_S_INX + 1679868344U, // FSW + 33588475U, // HFENCE_GVMA + 33588501U, // HFENCE_VVMA + 33588488U, // HINVAL_GVMA + 33588514U, // HINVAL_VVMA + 52471459U, // HLVX_HU + 52471681U, // HLVX_WU + 52464465U, // HLV_B + 52471403U, // HLV_BU + 52465050U, // HLV_D + 52467444U, // HLV_H + 52471451U, // HLV_HU + 52478079U, // HLV_W + 52471673U, // HLV_WU + 52464472U, // HSV_B + 52465057U, // HSV_D + 52467451U, // HSV_H + 52478086U, // HSV_W + 50908U, // InsnB + 807487186U, // InsnCA + 50917U, // InsnCB + 270616312U, // InsnCI + 270616409U, // InsnCIW + 1342228235U, // InsnCJ + 270616341U, // InsnCL + 270616360U, // InsnCR + 51003U, // InsnCS + 51013U, // InsnCSS + 270616303U, // InsnI + 270616303U, // InsnI_Mem + 1346455298U, // InsnJ + 807487263U, // InsnR + 807487176U, // InsnR4 + 50994U, // InsnS + 2151761744U, // InsnU + 14719685U, // JAL + 1679860342U, // JALR + 1679854546U, // LB + 1679861365U, // LBU + 1679855165U, // LD + 1679857514U, // LH + 1679861422U, // LHU + 52464927U, // LR_D + 52470072U, // LR_D_AQ + 52468850U, // LR_D_AQ_RL + 52468523U, // LR_D_RL + 52477987U, // LR_W + 52470237U, // LR_W_AQ + 52469041U, // LR_W_AQ_RL + 52468688U, // LR_W_RL + 33593549U, // LUI + 1679868166U, // LW + 1679861642U, // LWU + 2147533543U, // MAX + 2147526565U, // MAXU + 2147524438U, // MIN + 2147526406U, // MINU + 33587201U, // MOPR0 + 33587313U, // MOPR1 + 33587220U, // MOPR10 + 33587343U, // MOPR11 + 33587505U, // MOPR12 + 33587731U, // MOPR13 + 33587770U, // MOPR14 + 33588042U, // MOPR15 + 33588081U, // MOPR16 + 33588133U, // MOPR17 + 33588162U, // MOPR18 + 33588310U, // MOPR19 + 33587486U, // MOPR2 + 33587230U, // MOPR20 + 33587353U, // MOPR21 + 33587515U, // MOPR22 + 33587741U, // MOPR23 + 33587780U, // MOPR24 + 33588052U, // MOPR25 + 33588104U, // MOPR26 + 33588143U, // MOPR27 + 33588172U, // MOPR28 + 33588320U, // MOPR29 + 33587712U, // MOPR3 + 33587240U, // MOPR30 + 33587363U, // MOPR31 + 33587751U, // MOPR4 + 33588023U, // MOPR5 + 33588062U, // MOPR6 + 33588114U, // MOPR7 + 33588153U, // MOPR8 + 33588301U, // MOPR9 + 2147516426U, // MOPRR0 + 2147516538U, // MOPRR1 + 2147516711U, // MOPRR2 + 2147516937U, // MOPRR3 + 2147516976U, // MOPRR4 + 2147517248U, // MOPRR5 + 2147517287U, // MOPRR6 + 2147517339U, // MOPRR7 + 18870U, // MRET + 2147524008U, // MUL + 2147522428U, // MULH + 2147526422U, // MULHSU + 2147526331U, // MULHU + 2147533106U, // MULW + 2147525351U, // OR + 33588689U, // ORC_B + 2147522695U, // ORI + 2147524475U, // ORN + 2147523193U, // PACK + 2147522401U, // PACKH + 2147533053U, // PACKW + 858087U, // PREFETCH_I + 860730U, // PREFETCH_R + 868352U, // PREFETCH_W + 2147524083U, // REM + 2147526397U, // REMU + 2147533328U, // REMUW + 2147533112U, // REMW + 33588213U, // REV8_RV32 + 33588213U, // REV8_RV64 + 2147523302U, // ROL + 2147533094U, // ROLW + 2147525364U, // ROR + 2147522694U, // RORI + 2147533036U, // RORIW + 2147533142U, // RORW + 1679854594U, // SB + 1075874907U, // SC_D + 1075880184U, // SC_D_AQ + 1075878952U, // SC_D_AQ_RL + 1075878635U, // SC_D_RL + 1075887966U, // SC_W + 1075880349U, // SC_W_AQ + 1075879143U, // SC_W_AQ_RL + 1075878800U, // SC_W_RL + 1679855257U, // SD + 33589979U, // SEXT_B + 33592928U, // SEXT_H + 18812U, // SFENCE_INVAL_IR + 33588451U, // SFENCE_VMA + 18627U, // SFENCE_W_INVAL + 1679857574U, // SH + 2147520001U, // SH1ADD + 2147533286U, // SH1ADD_UW + 2147520009U, // SH2ADD + 2147533297U, // SH2ADD_UW + 2147520017U, // SH3ADD + 2147533308U, // SH3ADD_UW + 33587270U, // SHA256SIG0 + 33587401U, // SHA256SIG1 + 33587294U, // SHA256SUM0 + 33587467U, // SHA256SUM1 + 33587258U, // SHA512SIG0 + 2147522365U, // SHA512SIG0H + 2147523241U, // SHA512SIG0L + 33587389U, // SHA512SIG1 + 2147522378U, // SHA512SIG1H + 2147523254U, // SHA512SIG1L + 33587282U, // SHA512SUM0 + 2147525204U, // SHA512SUM0R + 33587455U, // SHA512SUM1 + 2147525217U, // SHA512SUM1R + 33588463U, // SINVAL_VMA + 2147523297U, // SLL + 2147522632U, // SLLI + 2147533022U, // SLLIW + 2147533319U, // SLLI_UW + 2147533088U, // SLLW + 2147526198U, // SLT + 2147522750U, // SLTI + 2147526357U, // SLTIU + 2147526467U, // SLTU + 33587306U, // SM3P0 + 33587479U, // SM3P1 + 36393U, // SM4ED + 42193U, // SM4KS + 2147517804U, // SRA + 2147522594U, // SRAI + 2147533006U, // SRAIW + 2147532984U, // SRAW + 18875U, // SRET + 2147523991U, // SRL + 2147522640U, // SRLI + 2147533029U, // SRLIW + 2147533100U, // SRLW + 1075875067U, // SSAMOSWAP_D + 1075880232U, // SSAMOSWAP_D_AQ + 1075879008U, // SSAMOSWAP_D_AQ_RL + 1075878683U, // SSAMOSWAP_D_RL + 1075888150U, // SSAMOSWAP_W + 1075880397U, // SSAMOSWAP_W_AQ + 1075879199U, // SSAMOSWAP_W_AQ_RL + 1075878848U, // SSAMOSWAP_W_RL + 301697U, // SSPOPCHK + 301014U, // SSPUSH + 303212U, // SSRDP + 2147519503U, // SUB + 2147532992U, // SUBW + 1679868316U, // SW + 2954968556U, // THVdotVMAQASU_VV + 2954970516U, // THVdotVMAQASU_VX + 2954970312U, // THVdotVMAQAUS_VX + 2954968411U, // THVdotVMAQAU_VV + 2954970360U, // THVdotVMAQAU_VX + 2954967594U, // THVdotVMAQA_VV + 2954969836U, // THVdotVMAQA_VX + 40348U, // TH_ADDSL + 18672U, // TH_DCACHE_CALL + 18756U, // TH_DCACHE_CIALL + 296284U, // TH_DCACHE_CIPA + 311756U, // TH_DCACHE_CISW + 296350U, // TH_DCACHE_CIVA + 296239U, // TH_DCACHE_CPA + 295125U, // TH_DCACHE_CPAL1 + 311719U, // TH_DCACHE_CSW + 296305U, // TH_DCACHE_CVA + 295142U, // TH_DCACHE_CVAL1 + 18709U, // TH_DCACHE_IALL + 296254U, // TH_DCACHE_IPA + 311741U, // TH_DCACHE_ISW + 296320U, // TH_DCACHE_IVA + 42589U, // TH_EXT + 42825U, // TH_EXTU + 33587250U, // TH_FF0 + 33587373U, // TH_FF1 + 36439U, // TH_FLRD + 49485U, // TH_FLRW + 36474U, // TH_FLURD + 49533U, // TH_FLURW + 36456U, // TH_FSRD + 49515U, // TH_FSRW + 36493U, // TH_FSURD + 49552U, // TH_FSURW + 18724U, // TH_ICACHE_IALL + 18849U, // TH_ICACHE_IALLS + 296269U, // TH_ICACHE_IPA + 296335U, // TH_ICACHE_IVA + 18656U, // TH_L2CACHE_CALL + 18739U, // TH_L2CACHE_CIALL + 18693U, // TH_L2CACHE_IALL + 21529711U, // TH_LBIA + 21531497U, // TH_LBIB + 21529765U, // TH_LBUIA + 21531551U, // TH_LBUIB + 167808537U, // TH_LDD + 21529729U, // TH_LDIA + 21531515U, // TH_LDIB + 21529747U, // TH_LHIA + 21531533U, // TH_LHIB + 21529775U, // TH_LHUIA + 21531561U, // TH_LHUIB + 35806U, // TH_LRB + 42626U, // TH_LRBU + 36431U, // TH_LRD + 38786U, // TH_LRH + 42690U, // TH_LRHU + 49477U, // TH_LRW + 42895U, // TH_LRWU + 35822U, // TH_LURB + 42635U, // TH_LURBU + 36465U, // TH_LURD + 38802U, // TH_LURH + 42699U, // TH_LURHU + 49524U, // TH_LURW + 42904U, // TH_LURWU + 167808685U, // TH_LWD + 21529795U, // TH_LWIA + 21531581U, // TH_LWIB + 167808676U, // TH_LWUD + 21529785U, // TH_LWUIA + 21531571U, // TH_LWUIB + 2954953946U, // TH_MULA + 2954958679U, // TH_MULAH + 2954969262U, // TH_MULAW + 2954962136U, // TH_MULS + 2954958774U, // TH_MULSH + 2954969564U, // TH_MULSW + 2954970797U, // TH_MVEQZ + 2954970753U, // TH_MVNEZ + 33601977U, // TH_REV + 33604126U, // TH_REVW + 21562488U, // TH_SBIA + 21564274U, // TH_SBIB + 167808545U, // TH_SDD + 21562506U, // TH_SDIA + 21564292U, // TH_SDIB + 33596563U, // TH_SFENCE_VMAS + 21562524U, // TH_SHIA + 21564310U, // TH_SHIB + 35814U, // TH_SRB + 36448U, // TH_SRD + 38794U, // TH_SRH + 2147522706U, // TH_SRRI + 2147533043U, // TH_SRRIW + 49507U, // TH_SRW + 35831U, // TH_SURB + 36484U, // TH_SURD + 38811U, // TH_SURH + 49543U, // TH_SURW + 167808693U, // TH_SWD + 21562572U, // TH_SWIA + 21564358U, // TH_SWIB + 18588U, // TH_SYNC + 18596U, // TH_SYNC_I + 18838U, // TH_SYNC_IS + 18828U, // TH_SYNC_S + 2147526229U, // TH_TST + 33605209U, // TH_TSTNBZ + 18800U, // UNIMP + 33595516U, // UNZIP_RV32 + 48534U, // VAADDU_VV + 50483U, // VAADDU_VX + 47942U, // VAADD_VV + 50044U, // VAADD_VX + 2147524121U, // VADC_VIM + 2147524313U, // VADC_VVM + 2147524367U, // VADC_VXM + 39205U, // VADD_VI + 48005U, // VADD_VV + 50074U, // VADD_VX + 33596660U, // VAESDF_VS + 33602527U, // VAESDF_VV + 33596682U, // VAESDM_VS + 33602734U, // VAESDM_VV + 33596671U, // VAESEF_VS + 33602538U, // VAESEF_VV + 33596693U, // VAESEM_VS + 33602754U, // VAESEM_VV + 2147522770U, // VAESKF1_VI + 2147522782U, // VAESKF2_VI + 33596910U, // VAESZ_VS + 48333U, // VANDN_VV + 50250U, // VANDN_VX + 39214U, // VAND_VI + 48035U, // VAND_VV + 50093U, // VAND_VX + 48489U, // VASUBU_VV + 50438U, // VASUBU_VX + 47690U, // VASUB_VV + 49932U, // VASUB_VX + 201373293U, // VBREV8_V + 201374085U, // VBREV_V + 48129U, // VCLMULH_VV + 50132U, // VCLMULH_VX + 48251U, // VCLMUL_VV + 50201U, // VCLMUL_VX + 201374121U, // VCLZ_V + 2147524267U, // VCOMPRESS_VM + 201367008U, // VCPOP_M + 201373949U, // VCPOP_V + 201374129U, // VCTZ_V + 47564U, // VC_FV + 48765U, // VC_FVV + 49703U, // VC_FVW + 38878U, // VC_I + 47586U, // VC_IV + 48789U, // VC_IVV + 49727U, // VC_IVW + 47932U, // VC_VV + 48813U, // VC_VVV + 49757U, // VC_VVW + 4274646U, // VC_V_FV + 807485064U, // VC_V_FVV + 807486002U, // VC_V_FVW + 270604289U, // VC_V_I + 4274668U, // VC_V_IV + 807485088U, // VC_V_IVV + 807486026U, // VC_V_IVW + 4275775U, // VC_V_VV + 807485112U, // VC_V_VVV + 807486056U, // VC_V_VVW + 270615239U, // VC_V_X + 4276050U, // VC_V_XV + 807485136U, // VC_V_XVV + 807486080U, // VC_V_XVW + 49817U, // VC_X + 48968U, // VC_XV + 48837U, // VC_XVV + 49781U, // VC_XVW + 48683U, // VDIVU_VV + 50654U, // VDIVU_VX + 48725U, // VDIV_VV + 50674U, // VDIV_VX + 36797U, // VFADD_VF + 47952U, // VFADD_VV + 201374026U, // VFCLASS_V + 201374047U, // VFCVT_F_XU_V + 201374094U, // VFCVT_F_X_V + 201373380U, // VFCVT_RTZ_XU_F_V + 201373444U, // VFCVT_RTZ_X_F_V + 201373351U, // VFCVT_XU_F_V + 201373417U, // VFCVT_X_F_V + 36987U, // VFDIV_VF + 48715U, // VFDIV_VV + 201367017U, // VFIRST_M + 2954956685U, // VFMACC_VF + 2954967789U, // VFMACC_VV + 2954956743U, // VFMADD_VF + 2954967898U, // VFMADD_VV + 37008U, // VFMAX_VF + 48734U, // VFMAX_VV + 2147524088U, // VFMERGE_VFM + 36903U, // VFMIN_VF + 48343U, // VFMIN_VV + 2954956637U, // VFMSAC_VF + 2954967720U, // VFMSAC_VV + 2954956592U, // VFMSUB_VF + 2954967646U, // VFMSUB_VV + 36882U, // VFMUL_VF + 48231U, // VFMUL_VV + 33596334U, // VFMV_F_S + 35720921U, // VFMV_S_F + 33591011U, // VFMV_V_F + 201375618U, // VFNCVTBF16_F_F_W + 201375654U, // VFNCVT_F_F_W + 201375845U, // VFNCVT_F_XU_W + 201375885U, // VFNCVT_F_X_W + 201375636U, // VFNCVT_ROD_F_F_W + 201375683U, // VFNCVT_RTZ_XU_F_W + 201375716U, // VFNCVT_RTZ_X_F_W + 201375668U, // VFNCVT_XU_F_W + 201375702U, // VFNCVT_X_F_W + 2954956696U, // VFNMACC_VF + 2954967800U, // VFNMACC_VV + 2954956754U, // VFNMADD_VF + 2954967909U, // VFNMADD_VV + 2954956648U, // VFNMSAC_VF + 2954967731U, // VFNMSAC_VV + 2954956603U, // VFNMSUB_VF + 2954967657U, // VFNMSUB_VV + 36589U, // VFNRCLIP_XU_F_QF + 36610U, // VFNRCLIP_X_F_QF + 36997U, // VFRDIV_VF + 201372383U, // VFREC7_V + 42453U, // VFREDMAX_VS + 42355U, // VFREDMIN_VS + 42297U, // VFREDOSUM_VS + 42326U, // VFREDUSUM_VS + 201372393U, // VFRSQRT7_V + 36679U, // VFRSUB_VF + 36913U, // VFSGNJN_VF + 48362U, // VFSGNJN_VV + 37018U, // VFSGNJX_VF + 48753U, // VFSGNJX_VV + 36871U, // VFSGNJ_VF + 48161U, // VFSGNJ_VV + 36925U, // VFSLIDE1DOWN_VF + 36942U, // VFSLIDE1UP_VF + 201374037U, // VFSQRT_V + 36646U, // VFSUB_VF + 47700U, // VFSUB_VV + 36830U, // VFWADD_VF + 48014U, // VFWADD_VV + 37041U, // VFWADD_WF + 48892U, // VFWADD_WV + 201373319U, // VFWCVTBF16_F_F_V + 201373337U, // VFWCVT_F_F_V + 201374061U, // VFWCVT_F_XU_V + 201374107U, // VFWCVT_F_X_V + 201373398U, // VFWCVT_RTZ_XU_F_V + 201373461U, // VFWCVT_RTZ_X_F_V + 201373365U, // VFWCVT_XU_F_V + 201373430U, // VFWCVT_X_F_V + 2954956566U, // VFWMACCBF16_VF + 2954967561U, // VFWMACCBF16_VV + 2147517148U, // VFWMACC_4x4x4 + 2954956721U, // VFWMACC_VF + 2954967835U, // VFWMACC_VV + 2954956673U, // VFWMSAC_VF + 2954967767U, // VFWMSAC_VV + 36892U, // VFWMUL_VF + 48281U, // VFWMUL_VV + 2954956708U, // VFWNMACC_VF + 2954967812U, // VFWNMACC_VV + 2954956660U, // VFWNMSAC_VF + 2954967754U, // VFWNMSAC_VV + 42311U, // VFWREDOSUM_VS + 42340U, // VFWREDUSUM_VS + 36690U, // VFWSUB_VF + 47763U, // VFWSUB_VV + 37030U, // VFWSUB_WF + 48871U, // VFWSUB_WV + 2147531799U, // VGHSH_VV + 33602673U, // VGMUL_VV + 1095296U, // VID_V + 201366972U, // VIOTA_M + 52474022U, // VL1RE16_V + 52472110U, // VL1RE32_V + 52473066U, // VL1RE64_V + 52474971U, // VL1RE8_V + 52474033U, // VL2RE16_V + 52472121U, // VL2RE32_V + 52473077U, // VL2RE64_V + 52474981U, // VL2RE8_V + 52474044U, // VL4RE16_V + 52472132U, // VL4RE32_V + 52473088U, // VL4RE64_V + 52474991U, // VL4RE8_V + 52474055U, // VL8RE16_V + 52472143U, // VL8RE32_V + 52473099U, // VL8RE64_V + 52475001U, // VL8RE8_V + 220248184U, // VLE16FF_V + 220246173U, // VLE16_V + 220247952U, // VLE32FF_V + 220244261U, // VLE32_V + 220248068U, // VLE64FF_V + 220245217U, // VLE64_V + 220248293U, // VLE8FF_V + 220247123U, // VLE8_V + 52476143U, // VLM_V + 18920111U, // VLOXEI16_V + 18918199U, // VLOXEI32_V + 18919155U, // VLOXEI64_V + 18921025U, // VLOXEI8_V + 18919663U, // VLOXSEG2EI16_V + 18917751U, // VLOXSEG2EI32_V + 18918707U, // VLOXSEG2EI64_V + 18920605U, // VLOXSEG2EI8_V + 18919727U, // VLOXSEG3EI16_V + 18917815U, // VLOXSEG3EI32_V + 18918771U, // VLOXSEG3EI64_V + 18920665U, // VLOXSEG3EI8_V + 18919791U, // VLOXSEG4EI16_V + 18917879U, // VLOXSEG4EI32_V + 18918835U, // VLOXSEG4EI64_V + 18920725U, // VLOXSEG4EI8_V + 18919855U, // VLOXSEG5EI16_V + 18917943U, // VLOXSEG5EI32_V + 18918899U, // VLOXSEG5EI64_V + 18920785U, // VLOXSEG5EI8_V + 18919919U, // VLOXSEG6EI16_V + 18918007U, // VLOXSEG6EI32_V + 18918963U, // VLOXSEG6EI64_V + 18920845U, // VLOXSEG6EI8_V + 18919983U, // VLOXSEG7EI16_V + 18918071U, // VLOXSEG7EI32_V + 18919027U, // VLOXSEG7EI64_V + 18920905U, // VLOXSEG7EI8_V + 18920047U, // VLOXSEG8EI16_V + 18918135U, // VLOXSEG8EI32_V + 18919091U, // VLOXSEG8EI64_V + 18920965U, // VLOXSEG8EI8_V + 18919634U, // VLSE16_V + 18917722U, // VLSE32_V + 18918678U, // VLSE64_V + 18920579U, // VLSE8_V + 220248079U, // VLSEG2E16FF_V + 220245795U, // VLSEG2E16_V + 220247847U, // VLSEG2E32FF_V + 220243883U, // VLSEG2E32_V + 220247963U, // VLSEG2E64FF_V + 220244839U, // VLSEG2E64_V + 220248195U, // VLSEG2E8FF_V + 220246773U, // VLSEG2E8_V + 220248094U, // VLSEG3E16FF_V + 220245849U, // VLSEG3E16_V + 220247862U, // VLSEG3E32FF_V + 220243937U, // VLSEG3E32_V + 220247978U, // VLSEG3E64FF_V + 220244893U, // VLSEG3E64_V + 220248209U, // VLSEG3E8FF_V + 220246823U, // VLSEG3E8_V + 220248109U, // VLSEG4E16FF_V + 220245903U, // VLSEG4E16_V + 220247877U, // VLSEG4E32FF_V + 220243991U, // VLSEG4E32_V + 220247993U, // VLSEG4E64FF_V + 220244947U, // VLSEG4E64_V + 220248223U, // VLSEG4E8FF_V + 220246873U, // VLSEG4E8_V + 220248124U, // VLSEG5E16FF_V + 220245957U, // VLSEG5E16_V + 220247892U, // VLSEG5E32FF_V + 220244045U, // VLSEG5E32_V + 220248008U, // VLSEG5E64FF_V + 220245001U, // VLSEG5E64_V + 220248237U, // VLSEG5E8FF_V + 220246923U, // VLSEG5E8_V + 220248139U, // VLSEG6E16FF_V + 220246011U, // VLSEG6E16_V + 220247907U, // VLSEG6E32FF_V + 220244099U, // VLSEG6E32_V + 220248023U, // VLSEG6E64FF_V + 220245055U, // VLSEG6E64_V + 220248251U, // VLSEG6E8FF_V + 220246973U, // VLSEG6E8_V + 220248154U, // VLSEG7E16FF_V + 220246065U, // VLSEG7E16_V + 220247922U, // VLSEG7E32FF_V + 220244153U, // VLSEG7E32_V + 220248038U, // VLSEG7E64FF_V + 220245109U, // VLSEG7E64_V + 220248265U, // VLSEG7E8FF_V + 220247023U, // VLSEG7E8_V + 220248169U, // VLSEG8E16FF_V + 220246119U, // VLSEG8E16_V + 220247937U, // VLSEG8E32FF_V + 220244207U, // VLSEG8E32_V + 220248053U, // VLSEG8E64FF_V + 220245163U, // VLSEG8E64_V + 220248279U, // VLSEG8E8FF_V + 220247073U, // VLSEG8E8_V + 18919216U, // VLSSEG2E16_V + 18917304U, // VLSSEG2E32_V + 18918260U, // VLSSEG2E64_V + 18920193U, // VLSSEG2E8_V + 18919270U, // VLSSEG3E16_V + 18917358U, // VLSSEG3E32_V + 18918314U, // VLSSEG3E64_V + 18920243U, // VLSSEG3E8_V + 18919324U, // VLSSEG4E16_V + 18917412U, // VLSSEG4E32_V + 18918368U, // VLSSEG4E64_V + 18920293U, // VLSSEG4E8_V + 18919378U, // VLSSEG5E16_V + 18917466U, // VLSSEG5E32_V + 18918422U, // VLSSEG5E64_V + 18920343U, // VLSSEG5E8_V + 18919432U, // VLSSEG6E16_V + 18917520U, // VLSSEG6E32_V + 18918476U, // VLSSEG6E64_V + 18920393U, // VLSSEG6E8_V + 18919486U, // VLSSEG7E16_V + 18917574U, // VLSSEG7E32_V + 18918530U, // VLSSEG7E64_V + 18920443U, // VLSSEG7E8_V + 18919540U, // VLSSEG8E16_V + 18917628U, // VLSSEG8E32_V + 18918584U, // VLSSEG8E64_V + 18920493U, // VLSSEG8E8_V + 18920135U, // VLUXEI16_V + 18918223U, // VLUXEI32_V + 18919179U, // VLUXEI64_V + 18921047U, // VLUXEI8_V + 18919695U, // VLUXSEG2EI16_V + 18917783U, // VLUXSEG2EI32_V + 18918739U, // VLUXSEG2EI64_V + 18920635U, // VLUXSEG2EI8_V + 18919759U, // VLUXSEG3EI16_V + 18917847U, // VLUXSEG3EI32_V + 18918803U, // VLUXSEG3EI64_V + 18920695U, // VLUXSEG3EI8_V + 18919823U, // VLUXSEG4EI16_V + 18917911U, // VLUXSEG4EI32_V + 18918867U, // VLUXSEG4EI64_V + 18920755U, // VLUXSEG4EI8_V + 18919887U, // VLUXSEG5EI16_V + 18917975U, // VLUXSEG5EI32_V + 18918931U, // VLUXSEG5EI64_V + 18920815U, // VLUXSEG5EI8_V + 18919951U, // VLUXSEG6EI16_V + 18918039U, // VLUXSEG6EI32_V + 18918995U, // VLUXSEG6EI64_V + 18920875U, // VLUXSEG6EI8_V + 18920015U, // VLUXSEG7EI16_V + 18918103U, // VLUXSEG7EI32_V + 18919059U, // VLUXSEG7EI64_V + 18920935U, // VLUXSEG7EI8_V + 18920079U, // VLUXSEG8EI16_V + 18918167U, // VLUXSEG8EI32_V + 18919123U, // VLUXSEG8EI64_V + 18920995U, // VLUXSEG8EI8_V + 2954967825U, // VMACC_VV + 2954969949U, // VMACC_VX + 2147522833U, // VMADC_VI + 2147524110U, // VMADC_VIM + 2147531570U, // VMADC_VV + 2147524302U, // VMADC_VVM + 2147533682U, // VMADC_VX + 2147524356U, // VMADC_VXM + 2954967921U, // VMADD_VV + 2954969990U, // VMADD_VX + 2147524164U, // VMANDN_MM + 2147524143U, // VMAND_MM + 48693U, // VMAXU_VV + 50664U, // VMAXU_VX + 48744U, // VMAX_VV + 50683U, // VMAX_VX + 2147524131U, // VMERGE_VIM + 2147524323U, // VMERGE_VVM + 2147524377U, // VMERGE_VXM + 36957U, // VMFEQ_VF + 48374U, // VMFEQ_VV + 36841U, // VMFGE_VF + 36967U, // VMFGT_VF + 36851U, // VMFLE_VF + 48044U, // VMFLE_VV + 36977U, // VMFLT_VF + 48455U, // VMFLT_VV + 36861U, // VMFNE_VF + 48075U, // VMFNE_VV + 48610U, // VMINU_VV + 50570U, // VMINU_VX + 48353U, // VMIN_VV + 50260U, // VMIN_VX + 2147524153U, // VMNAND_MM + 2147524194U, // VMNOR_MM + 2147524175U, // VMORN_MM + 2147524185U, // VMOR_MM + 2147531491U, // VMSBC_VV + 2147524281U, // VMSBC_VVM + 2147533651U, // VMSBC_VX + 2147524335U, // VMSBC_VXM + 201366981U, // VMSBF_M + 39329U, // VMSEQ_VI + 48384U, // VMSEQ_VV + 50327U, // VMSEQ_VX + 39431U, // VMSGTU_VI + 50632U, // VMSGTU_VX + 39378U, // VMSGT_VI + 50404U, // VMSGT_VX + 201366990U, // VMSIF_M + 39420U, // VMSLEU_VI + 48567U, // VMSLEU_VV + 50527U, // VMSLEU_VX + 39233U, // VMSLE_VI + 48054U, // VMSLE_VV + 50112U, // VMSLE_VX + 48672U, // VMSLTU_VV + 50643U, // VMSLTU_VX + 48465U, // VMSLT_VV + 50414U, // VMSLT_VX + 39243U, // VMSNE_VI + 48085U, // VMSNE_VV + 50122U, // VMSNE_VX + 201366999U, // VMSOF_M + 48648U, // VMULHSU_VV + 50608U, // VMULHSU_VX + 48578U, // VMULHU_VV + 50538U, // VMULHU_VX + 48141U, // VMULH_VV + 50144U, // VMULH_VX + 48272U, // VMUL_VV + 50222U, // VMUL_VX + 33601806U, // VMV1R_V + 33601823U, // VMV2R_V + 33601840U, // VMV4R_V + 33601857U, // VMV8R_V + 35734206U, // VMV_S_X + 33593356U, // VMV_V_I + 33601916U, // VMV_V_V + 33604306U, // VMV_V_X + 33596513U, // VMV_X_S + 2147524204U, // VMXNOR_MM + 2147524215U, // VMXOR_MM + 39491U, // VNCLIPU_WI + 48956U, // VNCLIPU_WV + 50765U, // VNCLIPU_WX + 39480U, // VNCLIP_WI + 48923U, // VNCLIP_WV + 50732U, // VNCLIP_WX + 2954967743U, // VNMSAC_VV + 2954969928U, // VNMSAC_VX + 2954967669U, // VNMSUB_VV + 2954969878U, // VNMSUB_VX + 39460U, // VNSRA_WI + 48861U, // VNSRA_WV + 50692U, // VNSRA_WX + 39470U, // VNSRL_WI + 48913U, // VNSRL_WV + 50722U, // VNSRL_WX + 39361U, // VOR_VI + 48426U, // VOR_VV + 50359U, // VOR_VX + 2147516909U, // VQMACCSU_2x8x2 + 2147517220U, // VQMACCSU_4x8x4 + 2147516872U, // VQMACCUS_2x8x2 + 2147517183U, // VQMACCUS_4x8x4 + 2147516891U, // VQMACCU_2x8x2 + 2147517202U, // VQMACCU_4x8x4 + 2147516855U, // VQMACC_2x8x2 + 2147517166U, // VQMACC_4x8x4 + 42216U, // VREDAND_VS + 42440U, // VREDMAXU_VS + 42466U, // VREDMAX_VS + 42427U, // VREDMINU_VS + 42368U, // VREDMIN_VS + 42390U, // VREDOR_VS + 42272U, // VREDSUM_VS + 42401U, // VREDXOR_VS + 48600U, // VREMU_VV + 50560U, // VREMU_VX + 48313U, // VREM_VV + 50241U, // VREM_VX + 201373303U, // VREV8_V + 47641U, // VRGATHEREI16_VV + 39339U, // VRGATHER_VI + 48404U, // VRGATHER_VV + 50337U, // VRGATHER_VX + 48203U, // VROL_VV + 50173U, // VROL_VX + 39352U, // VROR_VI + 48417U, // VROR_VV + 50350U, // VROR_VX + 39165U, // VRSUB_VI + 49953U, // VRSUB_VX + 52476166U, // VS1R_V + 52476183U, // VS2R_V + 52476200U, // VS4R_V + 52476217U, // VS8R_V + 39398U, // VSADDU_VI + 48545U, // VSADDU_VV + 50494U, // VSADDU_VX + 39195U, // VSADD_VI + 47995U, // VSADD_VV + 50064U, // VSADD_VX + 2147524292U, // VSBC_VVM + 2147524346U, // VSBC_VXM + 220246246U, // VSE16_V + 220244334U, // VSE32_V + 220245290U, // VSE64_V + 220247189U, // VSE8_V + 1879087190U, // VSETIVLI + 2147524020U, // VSETVL + 1879087200U, // VSETVLI + 201359685U, // VSEXT_VF2 + 201359980U, // VSEXT_VF4 + 201360342U, // VSEXT_VF8 + 2147531765U, // VSHA2CH_VV + 2147531820U, // VSHA2CL_VV + 2147532091U, // VSHA2MS_VV + 50269U, // VSLIDE1DOWN_VX + 50300U, // VSLIDE1UP_VX + 39301U, // VSLIDEDOWN_VI + 50285U, // VSLIDEDOWN_VX + 39316U, // VSLIDEUP_VI + 50314U, // VSLIDEUP_VX + 39263U, // VSLL_VI + 48184U, // VSLL_VV + 50154U, // VSLL_VX + 2147522823U, // VSM3C_VI + 2147531712U, // VSM3ME_VV + 2147522901U, // VSM4K_VI + 33596812U, // VSM4R_VS + 33602826U, // VSM4R_VV + 48262U, // VSMUL_VV + 50212U, // VSMUL_VX + 52476150U, // VSM_V + 18920123U, // VSOXEI16_V + 18918211U, // VSOXEI32_V + 18919167U, // VSOXEI64_V + 18921036U, // VSOXEI8_V + 18919679U, // VSOXSEG2EI16_V + 18917767U, // VSOXSEG2EI32_V + 18918723U, // VSOXSEG2EI64_V + 18920620U, // VSOXSEG2EI8_V + 18919743U, // VSOXSEG3EI16_V + 18917831U, // VSOXSEG3EI32_V + 18918787U, // VSOXSEG3EI64_V + 18920680U, // VSOXSEG3EI8_V + 18919807U, // VSOXSEG4EI16_V + 18917895U, // VSOXSEG4EI32_V + 18918851U, // VSOXSEG4EI64_V + 18920740U, // VSOXSEG4EI8_V + 18919871U, // VSOXSEG5EI16_V + 18917959U, // VSOXSEG5EI32_V + 18918915U, // VSOXSEG5EI64_V + 18920800U, // VSOXSEG5EI8_V + 18919935U, // VSOXSEG6EI16_V + 18918023U, // VSOXSEG6EI32_V + 18918979U, // VSOXSEG6EI64_V + 18920860U, // VSOXSEG6EI8_V + 18919999U, // VSOXSEG7EI16_V + 18918087U, // VSOXSEG7EI32_V + 18919043U, // VSOXSEG7EI64_V + 18920920U, // VSOXSEG7EI8_V + 18920063U, // VSOXSEG8EI16_V + 18918151U, // VSOXSEG8EI32_V + 18919107U, // VSOXSEG8EI64_V + 18920980U, // VSOXSEG8EI8_V + 39156U, // VSRA_VI + 47681U, // VSRA_VV + 49923U, // VSRA_VX + 39292U, // VSRL_VI + 48222U, // VSRL_VV + 50192U, // VSRL_VX + 18919644U, // VSSE16_V + 18917732U, // VSSE32_V + 18918688U, // VSSE64_V + 18920588U, // VSSE8_V + 220245836U, // VSSEG2E16_V + 220243924U, // VSSEG2E32_V + 220244880U, // VSSEG2E64_V + 220246811U, // VSSEG2E8_V + 220245890U, // VSSEG3E16_V + 220243978U, // VSSEG3E32_V + 220244934U, // VSSEG3E64_V + 220246861U, // VSSEG3E8_V + 220245944U, // VSSEG4E16_V + 220244032U, // VSSEG4E32_V + 220244988U, // VSSEG4E64_V + 220246911U, // VSSEG4E8_V + 220245998U, // VSSEG5E16_V + 220244086U, // VSSEG5E32_V + 220245042U, // VSSEG5E64_V + 220246961U, // VSSEG5E8_V + 220246052U, // VSSEG6E16_V + 220244140U, // VSSEG6E32_V + 220245096U, // VSSEG6E64_V + 220247011U, // VSSEG6E8_V + 220246106U, // VSSEG7E16_V + 220244194U, // VSSEG7E32_V + 220245150U, // VSSEG7E64_V + 220247061U, // VSSEG7E8_V + 220246160U, // VSSEG8E16_V + 220244248U, // VSSEG8E32_V + 220245204U, // VSSEG8E64_V + 220247111U, // VSSEG8E8_V + 39146U, // VSSRA_VI + 47671U, // VSSRA_VV + 49913U, // VSSRA_VX + 39282U, // VSSRL_VI + 48212U, // VSSRL_VV + 50182U, // VSSRL_VX + 18919230U, // VSSSEG2E16_V + 18917318U, // VSSSEG2E32_V + 18918274U, // VSSSEG2E64_V + 18920206U, // VSSSEG2E8_V + 18919284U, // VSSSEG3E16_V + 18917372U, // VSSSEG3E32_V + 18918328U, // VSSSEG3E64_V + 18920256U, // VSSSEG3E8_V + 18919338U, // VSSSEG4E16_V + 18917426U, // VSSSEG4E32_V + 18918382U, // VSSSEG4E64_V + 18920306U, // VSSSEG4E8_V + 18919392U, // VSSSEG5E16_V + 18917480U, // VSSSEG5E32_V + 18918436U, // VSSSEG5E64_V + 18920356U, // VSSSEG5E8_V + 18919446U, // VSSSEG6E16_V + 18917534U, // VSSSEG6E32_V + 18918490U, // VSSSEG6E64_V + 18920406U, // VSSSEG6E8_V + 18919500U, // VSSSEG7E16_V + 18917588U, // VSSSEG7E32_V + 18918544U, // VSSSEG7E64_V + 18920456U, // VSSSEG7E8_V + 18919554U, // VSSSEG8E16_V + 18917642U, // VSSSEG8E32_V + 18918598U, // VSSSEG8E64_V + 18920506U, // VSSSEG8E8_V + 48500U, // VSSUBU_VV + 50449U, // VSSUBU_VX + 47744U, // VSSUB_VV + 49963U, // VSSUB_VX + 47754U, // VSUB_VV + 49973U, // VSUB_VX + 18920147U, // VSUXEI16_V + 18918235U, // VSUXEI32_V + 18919191U, // VSUXEI64_V + 18921058U, // VSUXEI8_V + 18919711U, // VSUXSEG2EI16_V + 18917799U, // VSUXSEG2EI32_V + 18918755U, // VSUXSEG2EI64_V + 18920650U, // VSUXSEG2EI8_V + 18919775U, // VSUXSEG3EI16_V + 18917863U, // VSUXSEG3EI32_V + 18918819U, // VSUXSEG3EI64_V + 18920710U, // VSUXSEG3EI8_V + 18919839U, // VSUXSEG4EI16_V + 18917927U, // VSUXSEG4EI32_V + 18918883U, // VSUXSEG4EI64_V + 18920770U, // VSUXSEG4EI8_V + 18919903U, // VSUXSEG5EI16_V + 18917991U, // VSUXSEG5EI32_V + 18918947U, // VSUXSEG5EI64_V + 18920830U, // VSUXSEG5EI8_V + 18919967U, // VSUXSEG6EI16_V + 18918055U, // VSUXSEG6EI32_V + 18919011U, // VSUXSEG6EI64_V + 18920890U, // VSUXSEG6EI8_V + 18920031U, // VSUXSEG7EI16_V + 18918119U, // VSUXSEG7EI32_V + 18919075U, // VSUXSEG7EI64_V + 18920950U, // VSUXSEG7EI8_V + 18920095U, // VSUXSEG8EI16_V + 18918183U, // VSUXSEG8EI32_V + 18919139U, // VSUXSEG8EI64_V + 18921010U, // VSUXSEG8EI8_V + 2147519516U, // VT_MASKC + 2147524409U, // VT_MASKCN + 48556U, // VWADDU_VV + 50505U, // VWADDU_VX + 48945U, // VWADDU_WV + 50754U, // VWADDU_WX + 48025U, // VWADD_VV + 50083U, // VWADD_VX + 48903U, // VWADD_WV + 50712U, // VWADD_WX + 2954968571U, // VWMACCSU_VV + 2954970531U, // VWMACCSU_VX + 2954970327U, // VWMACCUS_VX + 2954968458U, // VWMACCU_VV + 2954970407U, // VWMACCU_VX + 2954967847U, // VWMACC_VV + 2954969959U, // VWMACC_VX + 48660U, // VWMULSU_VV + 50620U, // VWMULSU_VX + 48589U, // VWMULU_VV + 50549U, // VWMULU_VX + 48292U, // VWMUL_VV + 50231U, // VWMUL_VX + 42413U, // VWREDSUMU_VS + 42284U, // VWREDSUM_VS + 39272U, // VWSLL_VI + 48193U, // VWSLL_VV + 50163U, // VWSLL_VX + 48511U, // VWSUBU_VV + 50460U, // VWSUBU_VX + 48934U, // VWSUBU_WV + 50743U, // VWSUBU_WX + 47774U, // VWSUB_VV + 49982U, // VWSUB_VX + 48882U, // VWSUB_WV + 50702U, // VWSUB_WX + 39369U, // VXOR_VI + 48434U, // VXOR_VV + 50367U, // VXOR_VX + 201359696U, // VZEXT_VF2 + 201359991U, // VZEXT_VF4 + 201360353U, // VZEXT_VF8 + 18614U, // WFI + 18782U, // WRS_NTO + 18790U, // WRS_STO + 2147525355U, // XNOR + 2147525371U, // XOR + 2147522700U, // XORI + 2147517058U, // XPERM4 + 2147517420U, // XPERM8 + 33592938U, // ZEXT_H_RV32 + 33592938U, // ZEXT_H_RV64 + 33595518U, // ZIP_RV32 }; - static const uint8_t OpInfo1[] = { + static const uint16_t OpInfo1[] = { 0U, // PHI 0U, // INLINEASM 0U, // INLINEASM_BR @@ -748,16 +14775,23 @@ static void printInstruction(MCInst *MI, SStream *O, MCRegisterInfo *MRI) 0U, // SUBREG_TO_REG 0U, // COPY_TO_REGCLASS 0U, // DBG_VALUE + 0U, // DBG_VALUE_LIST + 0U, // DBG_INSTR_REF + 0U, // DBG_PHI 0U, // DBG_LABEL 0U, // REG_SEQUENCE 0U, // COPY 0U, // BUNDLE 0U, // LIFETIME_START 0U, // LIFETIME_END + 0U, // PSEUDO_PROBE + 0U, // ARITH_FENCE 0U, // STACKMAP 0U, // FENTRY_CALL 0U, // PATCHPOINT 0U, // LOAD_STACK_GUARD + 0U, // PREALLOCATED_SETUP + 0U, // PREALLOCATED_ARG 0U, // STATEPOINT 0U, // LOCAL_ESCAPE 0U, // FAULTING_OP @@ -769,6 +14803,11 @@ static void printInstruction(MCInst *MI, SStream *O, MCRegisterInfo *MRI) 0U, // PATCHABLE_EVENT_CALL 0U, // PATCHABLE_TYPED_EVENT_CALL 0U, // ICALL_BRANCH_FUNNEL + 0U, // MEMBARRIER + 0U, // JUMP_TABLE_DEBUG_INFO + 0U, // G_ASSERT_SEXT + 0U, // G_ASSERT_ZEXT + 0U, // G_ASSERT_ALIGN 0U, // G_ADD 0U, // G_SUB 0U, // G_MUL @@ -776,6 +14815,8 @@ static void printInstruction(MCInst *MI, SStream *O, MCRegisterInfo *MRI) 0U, // G_UDIV 0U, // G_SREM 0U, // G_UREM + 0U, // G_SDIVREM + 0U, // G_UDIVREM 0U, // G_AND 0U, // G_OR 0U, // G_XOR @@ -783,6 +14824,7 @@ static void printInstruction(MCInst *MI, SStream *O, MCRegisterInfo *MRI) 0U, // G_PHI 0U, // G_FRAME_INDEX 0U, // G_GLOBAL_VALUE + 0U, // G_CONSTANT_POOL 0U, // G_EXTRACT 0U, // G_UNMERGE_VALUES 0U, // G_INSERT @@ -793,12 +14835,22 @@ static void printInstruction(MCInst *MI, SStream *O, MCRegisterInfo *MRI) 0U, // G_PTRTOINT 0U, // G_INTTOPTR 0U, // G_BITCAST + 0U, // G_FREEZE + 0U, // G_CONSTANT_FOLD_BARRIER + 0U, // G_INTRINSIC_FPTRUNC_ROUND 0U, // G_INTRINSIC_TRUNC 0U, // G_INTRINSIC_ROUND + 0U, // G_INTRINSIC_LRINT + 0U, // G_INTRINSIC_ROUNDEVEN + 0U, // G_READCYCLECOUNTER 0U, // G_LOAD 0U, // G_SEXTLOAD 0U, // G_ZEXTLOAD + 0U, // G_INDEXED_LOAD + 0U, // G_INDEXED_SEXTLOAD + 0U, // G_INDEXED_ZEXTLOAD 0U, // G_STORE + 0U, // G_INDEXED_STORE 0U, // G_ATOMIC_CMPXCHG_WITH_SUCCESS 0U, // G_ATOMIC_CMPXCHG 0U, // G_ATOMICRMW_XCHG @@ -812,10 +14864,21 @@ static void printInstruction(MCInst *MI, SStream *O, MCRegisterInfo *MRI) 0U, // G_ATOMICRMW_MIN 0U, // G_ATOMICRMW_UMAX 0U, // G_ATOMICRMW_UMIN + 0U, // G_ATOMICRMW_FADD + 0U, // G_ATOMICRMW_FSUB + 0U, // G_ATOMICRMW_FMAX + 0U, // G_ATOMICRMW_FMIN + 0U, // G_ATOMICRMW_UINC_WRAP + 0U, // G_ATOMICRMW_UDEC_WRAP + 0U, // G_FENCE + 0U, // G_PREFETCH 0U, // G_BRCOND 0U, // G_BRINDIRECT + 0U, // G_INVOKE_REGION_START 0U, // G_INTRINSIC 0U, // G_INTRINSIC_W_SIDE_EFFECTS + 0U, // G_INTRINSIC_CONVERGENT + 0U, // G_INTRINSIC_CONVERGENT_W_SIDE_EFFECTS 0U, // G_ANYEXT 0U, // G_TRUNC 0U, // G_CONSTANT @@ -823,10 +14886,15 @@ static void printInstruction(MCInst *MI, SStream *O, MCRegisterInfo *MRI) 0U, // G_VASTART 0U, // G_VAARG 0U, // G_SEXT + 0U, // G_SEXT_INREG 0U, // G_ZEXT 0U, // G_SHL 0U, // G_LSHR 0U, // G_ASHR + 0U, // G_FSHL + 0U, // G_FSHR + 0U, // G_ROTR + 0U, // G_ROTL 0U, // G_ICMP 0U, // G_FCMP 0U, // G_SELECT @@ -842,18 +14910,37 @@ static void printInstruction(MCInst *MI, SStream *O, MCRegisterInfo *MRI) 0U, // G_SMULO 0U, // G_UMULH 0U, // G_SMULH + 0U, // G_UADDSAT + 0U, // G_SADDSAT + 0U, // G_USUBSAT + 0U, // G_SSUBSAT + 0U, // G_USHLSAT + 0U, // G_SSHLSAT + 0U, // G_SMULFIX + 0U, // G_UMULFIX + 0U, // G_SMULFIXSAT + 0U, // G_UMULFIXSAT + 0U, // G_SDIVFIX + 0U, // G_UDIVFIX + 0U, // G_SDIVFIXSAT + 0U, // G_UDIVFIXSAT 0U, // G_FADD 0U, // G_FSUB 0U, // G_FMUL 0U, // G_FMA + 0U, // G_FMAD 0U, // G_FDIV 0U, // G_FREM 0U, // G_FPOW + 0U, // G_FPOWI 0U, // G_FEXP 0U, // G_FEXP2 + 0U, // G_FEXP10 0U, // G_FLOG 0U, // G_FLOG2 0U, // G_FLOG10 + 0U, // G_FLDEXP + 0U, // G_FFREXP 0U, // G_FNEG 0U, // G_FPEXT 0U, // G_FPTRUNC @@ -862,10 +14949,32 @@ static void printInstruction(MCInst *MI, SStream *O, MCRegisterInfo *MRI) 0U, // G_SITOFP 0U, // G_UITOFP 0U, // G_FABS + 0U, // G_FCOPYSIGN + 0U, // G_IS_FPCLASS 0U, // G_FCANONICALIZE - 0U, // G_GEP - 0U, // G_PTR_MASK + 0U, // G_FMINNUM + 0U, // G_FMAXNUM + 0U, // G_FMINNUM_IEEE + 0U, // G_FMAXNUM_IEEE + 0U, // G_FMINIMUM + 0U, // G_FMAXIMUM + 0U, // G_GET_FPENV + 0U, // G_SET_FPENV + 0U, // G_RESET_FPENV + 0U, // G_GET_FPMODE + 0U, // G_SET_FPMODE + 0U, // G_RESET_FPMODE + 0U, // G_PTR_ADD + 0U, // G_PTRMASK + 0U, // G_SMIN + 0U, // G_SMAX + 0U, // G_UMIN + 0U, // G_UMAX + 0U, // G_ABS + 0U, // G_LROUND + 0U, // G_LLROUND 0U, // G_BR + 0U, // G_BRJT 0U, // G_INSERT_VECTOR_ELT 0U, // G_EXTRACT_VECTOR_ELT 0U, // G_SHUFFLE_VECTOR @@ -875,27 +14984,136 @@ static void printInstruction(MCInst *MI, SStream *O, MCRegisterInfo *MRI) 0U, // G_CTLZ_ZERO_UNDEF 0U, // G_CTPOP 0U, // G_BSWAP + 0U, // G_BITREVERSE 0U, // G_FCEIL 0U, // G_FCOS 0U, // G_FSIN 0U, // G_FSQRT 0U, // G_FFLOOR + 0U, // G_FRINT + 0U, // G_FNEARBYINT 0U, // G_ADDRSPACE_CAST 0U, // G_BLOCK_ADDR + 0U, // G_JUMP_TABLE + 0U, // G_DYN_STACKALLOC + 0U, // G_STACKSAVE + 0U, // G_STACKRESTORE + 0U, // G_STRICT_FADD + 0U, // G_STRICT_FSUB + 0U, // G_STRICT_FMUL + 0U, // G_STRICT_FDIV + 0U, // G_STRICT_FREM + 0U, // G_STRICT_FMA + 0U, // G_STRICT_FSQRT + 0U, // G_STRICT_FLDEXP + 0U, // G_READ_REGISTER + 0U, // G_WRITE_REGISTER + 0U, // G_MEMCPY + 0U, // G_MEMCPY_INLINE + 0U, // G_MEMMOVE + 0U, // G_MEMSET + 0U, // G_BZERO + 0U, // G_VECREDUCE_SEQ_FADD + 0U, // G_VECREDUCE_SEQ_FMUL + 0U, // G_VECREDUCE_FADD + 0U, // G_VECREDUCE_FMUL + 0U, // G_VECREDUCE_FMAX + 0U, // G_VECREDUCE_FMIN + 0U, // G_VECREDUCE_FMAXIMUM + 0U, // G_VECREDUCE_FMINIMUM + 0U, // G_VECREDUCE_ADD + 0U, // G_VECREDUCE_MUL + 0U, // G_VECREDUCE_AND + 0U, // G_VECREDUCE_OR + 0U, // G_VECREDUCE_XOR + 0U, // G_VECREDUCE_SMAX + 0U, // G_VECREDUCE_SMIN + 0U, // G_VECREDUCE_UMAX + 0U, // G_VECREDUCE_UMIN + 0U, // G_SBFX + 0U, // G_UBFX 0U, // ADJCALLSTACKDOWN 0U, // ADJCALLSTACKUP 0U, // BuildPairF64Pseudo + 0U, // BuildPairF64Pseudo_INX + 0U, // G_FCLASS + 0U, // HWASAN_CHECK_MEMACCESS_SHORTGRANULES + 0U, // KCFI_CHECK + 0U, // PseudoAddTPRel 0U, // PseudoAtomicLoadNand32 0U, // PseudoAtomicLoadNand64 0U, // PseudoBR 0U, // PseudoBRIND 0U, // PseudoCALL 0U, // PseudoCALLIndirect + 0U, // PseudoCALLReg + 0U, // PseudoCCADD + 0U, // PseudoCCADDI + 0U, // PseudoCCADDIW + 0U, // PseudoCCADDW + 0U, // PseudoCCAND + 0U, // PseudoCCANDI + 0U, // PseudoCCANDN + 0U, // PseudoCCMOVGPR + 0U, // PseudoCCMOVGPRNoX0 + 0U, // PseudoCCOR + 0U, // PseudoCCORI + 0U, // PseudoCCORN + 0U, // PseudoCCSLL + 0U, // PseudoCCSLLI + 0U, // PseudoCCSLLIW + 0U, // PseudoCCSLLW + 0U, // PseudoCCSRA + 0U, // PseudoCCSRAI + 0U, // PseudoCCSRAIW + 0U, // PseudoCCSRAW + 0U, // PseudoCCSRL + 0U, // PseudoCCSRLI + 0U, // PseudoCCSRLIW + 0U, // PseudoCCSRLW + 0U, // PseudoCCSUB + 0U, // PseudoCCSUBW + 0U, // PseudoCCXNOR + 0U, // PseudoCCXOR + 0U, // PseudoCCXORI 0U, // PseudoCmpXchg32 0U, // PseudoCmpXchg64 + 0U, // PseudoFLD + 0U, // PseudoFLH + 0U, // PseudoFLW + 0U, // PseudoFROUND_D + 0U, // PseudoFROUND_D_IN32X + 0U, // PseudoFROUND_D_INX + 0U, // PseudoFROUND_H + 0U, // PseudoFROUND_H_INX + 0U, // PseudoFROUND_S + 0U, // PseudoFROUND_S_INX + 0U, // PseudoFSD + 0U, // PseudoFSH + 0U, // PseudoFSW + 0U, // PseudoJump 0U, // PseudoLA + 0U, // PseudoLAImm + 0U, // PseudoLA_TLSDESC + 0U, // PseudoLA_TLS_GD + 0U, // PseudoLA_TLS_IE + 0U, // PseudoLB + 0U, // PseudoLBU + 0U, // PseudoLD + 0U, // PseudoLGA + 0U, // PseudoLH + 0U, // PseudoLHU 0U, // PseudoLI 0U, // PseudoLLA + 0U, // PseudoLLAImm + 0U, // PseudoLW + 0U, // PseudoLWU + 0U, // PseudoLongBEQ + 0U, // PseudoLongBGE + 0U, // PseudoLongBGEU + 0U, // PseudoLongBLT + 0U, // PseudoLongBLTU + 0U, // PseudoLongBNE 0U, // PseudoMaskedAtomicLoadAdd32 0U, // PseudoMaskedAtomicLoadMax32 0U, // PseudoMaskedAtomicLoadMin32 @@ -905,225 +15123,11743 @@ static void printInstruction(MCInst *MI, SStream *O, MCRegisterInfo *MRI) 0U, // PseudoMaskedAtomicLoadUMin32 0U, // PseudoMaskedAtomicSwap32 0U, // PseudoMaskedCmpXchg32 + 0U, // PseudoMovImm + 0U, // PseudoQuietFLE_D + 0U, // PseudoQuietFLE_D_IN32X + 0U, // PseudoQuietFLE_D_INX + 0U, // PseudoQuietFLE_H + 0U, // PseudoQuietFLE_H_INX + 0U, // PseudoQuietFLE_S + 0U, // PseudoQuietFLE_S_INX + 0U, // PseudoQuietFLT_D + 0U, // PseudoQuietFLT_D_IN32X + 0U, // PseudoQuietFLT_D_INX + 0U, // PseudoQuietFLT_H + 0U, // PseudoQuietFLT_H_INX + 0U, // PseudoQuietFLT_S + 0U, // PseudoQuietFLT_S_INX 0U, // PseudoRET + 0U, // PseudoRV32ZdinxLD + 0U, // PseudoRV32ZdinxSD + 0U, // PseudoRVVInitUndefM1 + 0U, // PseudoRVVInitUndefM2 + 0U, // PseudoRVVInitUndefM4 + 0U, // PseudoRVVInitUndefM8 + 0U, // PseudoReadVL + 0U, // PseudoReadVLENB + 0U, // PseudoSB + 0U, // PseudoSD + 0U, // PseudoSEXT_B + 0U, // PseudoSEXT_H + 0U, // PseudoSH + 0U, // PseudoSW 0U, // PseudoTAIL 0U, // PseudoTAILIndirect + 0U, // PseudoTHVdotVMAQASU_VV_M1 + 0U, // PseudoTHVdotVMAQASU_VV_M1_MASK + 0U, // PseudoTHVdotVMAQASU_VV_M2 + 0U, // PseudoTHVdotVMAQASU_VV_M2_MASK + 0U, // PseudoTHVdotVMAQASU_VV_M4 + 0U, // PseudoTHVdotVMAQASU_VV_M4_MASK + 0U, // PseudoTHVdotVMAQASU_VV_M8 + 0U, // PseudoTHVdotVMAQASU_VV_M8_MASK + 0U, // PseudoTHVdotVMAQASU_VV_MF2 + 0U, // PseudoTHVdotVMAQASU_VV_MF2_MASK + 0U, // PseudoTHVdotVMAQASU_VX_M1 + 0U, // PseudoTHVdotVMAQASU_VX_M1_MASK + 0U, // PseudoTHVdotVMAQASU_VX_M2 + 0U, // PseudoTHVdotVMAQASU_VX_M2_MASK + 0U, // PseudoTHVdotVMAQASU_VX_M4 + 0U, // PseudoTHVdotVMAQASU_VX_M4_MASK + 0U, // PseudoTHVdotVMAQASU_VX_M8 + 0U, // PseudoTHVdotVMAQASU_VX_M8_MASK + 0U, // PseudoTHVdotVMAQASU_VX_MF2 + 0U, // PseudoTHVdotVMAQASU_VX_MF2_MASK + 0U, // PseudoTHVdotVMAQAUS_VX_M1 + 0U, // PseudoTHVdotVMAQAUS_VX_M1_MASK + 0U, // PseudoTHVdotVMAQAUS_VX_M2 + 0U, // PseudoTHVdotVMAQAUS_VX_M2_MASK + 0U, // PseudoTHVdotVMAQAUS_VX_M4 + 0U, // PseudoTHVdotVMAQAUS_VX_M4_MASK + 0U, // PseudoTHVdotVMAQAUS_VX_M8 + 0U, // PseudoTHVdotVMAQAUS_VX_M8_MASK + 0U, // PseudoTHVdotVMAQAUS_VX_MF2 + 0U, // PseudoTHVdotVMAQAUS_VX_MF2_MASK + 0U, // PseudoTHVdotVMAQAU_VV_M1 + 0U, // PseudoTHVdotVMAQAU_VV_M1_MASK + 0U, // PseudoTHVdotVMAQAU_VV_M2 + 0U, // PseudoTHVdotVMAQAU_VV_M2_MASK + 0U, // PseudoTHVdotVMAQAU_VV_M4 + 0U, // PseudoTHVdotVMAQAU_VV_M4_MASK + 0U, // PseudoTHVdotVMAQAU_VV_M8 + 0U, // PseudoTHVdotVMAQAU_VV_M8_MASK + 0U, // PseudoTHVdotVMAQAU_VV_MF2 + 0U, // PseudoTHVdotVMAQAU_VV_MF2_MASK + 0U, // PseudoTHVdotVMAQAU_VX_M1 + 0U, // PseudoTHVdotVMAQAU_VX_M1_MASK + 0U, // PseudoTHVdotVMAQAU_VX_M2 + 0U, // PseudoTHVdotVMAQAU_VX_M2_MASK + 0U, // PseudoTHVdotVMAQAU_VX_M4 + 0U, // PseudoTHVdotVMAQAU_VX_M4_MASK + 0U, // PseudoTHVdotVMAQAU_VX_M8 + 0U, // PseudoTHVdotVMAQAU_VX_M8_MASK + 0U, // PseudoTHVdotVMAQAU_VX_MF2 + 0U, // PseudoTHVdotVMAQAU_VX_MF2_MASK + 0U, // PseudoTHVdotVMAQA_VV_M1 + 0U, // PseudoTHVdotVMAQA_VV_M1_MASK + 0U, // PseudoTHVdotVMAQA_VV_M2 + 0U, // PseudoTHVdotVMAQA_VV_M2_MASK + 0U, // PseudoTHVdotVMAQA_VV_M4 + 0U, // PseudoTHVdotVMAQA_VV_M4_MASK + 0U, // PseudoTHVdotVMAQA_VV_M8 + 0U, // PseudoTHVdotVMAQA_VV_M8_MASK + 0U, // PseudoTHVdotVMAQA_VV_MF2 + 0U, // PseudoTHVdotVMAQA_VV_MF2_MASK + 0U, // PseudoTHVdotVMAQA_VX_M1 + 0U, // PseudoTHVdotVMAQA_VX_M1_MASK + 0U, // PseudoTHVdotVMAQA_VX_M2 + 0U, // PseudoTHVdotVMAQA_VX_M2_MASK + 0U, // PseudoTHVdotVMAQA_VX_M4 + 0U, // PseudoTHVdotVMAQA_VX_M4_MASK + 0U, // PseudoTHVdotVMAQA_VX_M8 + 0U, // PseudoTHVdotVMAQA_VX_M8_MASK + 0U, // PseudoTHVdotVMAQA_VX_MF2 + 0U, // PseudoTHVdotVMAQA_VX_MF2_MASK + 0U, // PseudoTLSDESCCall + 0U, // PseudoVAADDU_VV_M1 + 0U, // PseudoVAADDU_VV_M1_MASK + 0U, // PseudoVAADDU_VV_M2 + 0U, // PseudoVAADDU_VV_M2_MASK + 0U, // PseudoVAADDU_VV_M4 + 0U, // PseudoVAADDU_VV_M4_MASK + 0U, // PseudoVAADDU_VV_M8 + 0U, // PseudoVAADDU_VV_M8_MASK + 0U, // PseudoVAADDU_VV_MF2 + 0U, // PseudoVAADDU_VV_MF2_MASK + 0U, // PseudoVAADDU_VV_MF4 + 0U, // PseudoVAADDU_VV_MF4_MASK + 0U, // PseudoVAADDU_VV_MF8 + 0U, // PseudoVAADDU_VV_MF8_MASK + 0U, // PseudoVAADDU_VX_M1 + 0U, // PseudoVAADDU_VX_M1_MASK + 0U, // PseudoVAADDU_VX_M2 + 0U, // PseudoVAADDU_VX_M2_MASK + 0U, // PseudoVAADDU_VX_M4 + 0U, // PseudoVAADDU_VX_M4_MASK + 0U, // PseudoVAADDU_VX_M8 + 0U, // PseudoVAADDU_VX_M8_MASK + 0U, // PseudoVAADDU_VX_MF2 + 0U, // PseudoVAADDU_VX_MF2_MASK + 0U, // PseudoVAADDU_VX_MF4 + 0U, // PseudoVAADDU_VX_MF4_MASK + 0U, // PseudoVAADDU_VX_MF8 + 0U, // PseudoVAADDU_VX_MF8_MASK + 0U, // PseudoVAADD_VV_M1 + 0U, // PseudoVAADD_VV_M1_MASK + 0U, // PseudoVAADD_VV_M2 + 0U, // PseudoVAADD_VV_M2_MASK + 0U, // PseudoVAADD_VV_M4 + 0U, // PseudoVAADD_VV_M4_MASK + 0U, // PseudoVAADD_VV_M8 + 0U, // PseudoVAADD_VV_M8_MASK + 0U, // PseudoVAADD_VV_MF2 + 0U, // PseudoVAADD_VV_MF2_MASK + 0U, // PseudoVAADD_VV_MF4 + 0U, // PseudoVAADD_VV_MF4_MASK + 0U, // PseudoVAADD_VV_MF8 + 0U, // PseudoVAADD_VV_MF8_MASK + 0U, // PseudoVAADD_VX_M1 + 0U, // PseudoVAADD_VX_M1_MASK + 0U, // PseudoVAADD_VX_M2 + 0U, // PseudoVAADD_VX_M2_MASK + 0U, // PseudoVAADD_VX_M4 + 0U, // PseudoVAADD_VX_M4_MASK + 0U, // PseudoVAADD_VX_M8 + 0U, // PseudoVAADD_VX_M8_MASK + 0U, // PseudoVAADD_VX_MF2 + 0U, // PseudoVAADD_VX_MF2_MASK + 0U, // PseudoVAADD_VX_MF4 + 0U, // PseudoVAADD_VX_MF4_MASK + 0U, // PseudoVAADD_VX_MF8 + 0U, // PseudoVAADD_VX_MF8_MASK + 0U, // PseudoVADC_VIM_M1 + 0U, // PseudoVADC_VIM_M2 + 0U, // PseudoVADC_VIM_M4 + 0U, // PseudoVADC_VIM_M8 + 0U, // PseudoVADC_VIM_MF2 + 0U, // PseudoVADC_VIM_MF4 + 0U, // PseudoVADC_VIM_MF8 + 0U, // PseudoVADC_VVM_M1 + 0U, // PseudoVADC_VVM_M2 + 0U, // PseudoVADC_VVM_M4 + 0U, // PseudoVADC_VVM_M8 + 0U, // PseudoVADC_VVM_MF2 + 0U, // PseudoVADC_VVM_MF4 + 0U, // PseudoVADC_VVM_MF8 + 0U, // PseudoVADC_VXM_M1 + 0U, // PseudoVADC_VXM_M2 + 0U, // PseudoVADC_VXM_M4 + 0U, // PseudoVADC_VXM_M8 + 0U, // PseudoVADC_VXM_MF2 + 0U, // PseudoVADC_VXM_MF4 + 0U, // PseudoVADC_VXM_MF8 + 0U, // PseudoVADD_VI_M1 + 0U, // PseudoVADD_VI_M1_MASK + 0U, // PseudoVADD_VI_M2 + 0U, // PseudoVADD_VI_M2_MASK + 0U, // PseudoVADD_VI_M4 + 0U, // PseudoVADD_VI_M4_MASK + 0U, // PseudoVADD_VI_M8 + 0U, // PseudoVADD_VI_M8_MASK + 0U, // PseudoVADD_VI_MF2 + 0U, // PseudoVADD_VI_MF2_MASK + 0U, // PseudoVADD_VI_MF4 + 0U, // PseudoVADD_VI_MF4_MASK + 0U, // PseudoVADD_VI_MF8 + 0U, // PseudoVADD_VI_MF8_MASK + 0U, // PseudoVADD_VV_M1 + 0U, // PseudoVADD_VV_M1_MASK + 0U, // PseudoVADD_VV_M2 + 0U, // PseudoVADD_VV_M2_MASK + 0U, // PseudoVADD_VV_M4 + 0U, // PseudoVADD_VV_M4_MASK + 0U, // PseudoVADD_VV_M8 + 0U, // PseudoVADD_VV_M8_MASK + 0U, // PseudoVADD_VV_MF2 + 0U, // PseudoVADD_VV_MF2_MASK + 0U, // PseudoVADD_VV_MF4 + 0U, // PseudoVADD_VV_MF4_MASK + 0U, // PseudoVADD_VV_MF8 + 0U, // PseudoVADD_VV_MF8_MASK + 0U, // PseudoVADD_VX_M1 + 0U, // PseudoVADD_VX_M1_MASK + 0U, // PseudoVADD_VX_M2 + 0U, // PseudoVADD_VX_M2_MASK + 0U, // PseudoVADD_VX_M4 + 0U, // PseudoVADD_VX_M4_MASK + 0U, // PseudoVADD_VX_M8 + 0U, // PseudoVADD_VX_M8_MASK + 0U, // PseudoVADD_VX_MF2 + 0U, // PseudoVADD_VX_MF2_MASK + 0U, // PseudoVADD_VX_MF4 + 0U, // PseudoVADD_VX_MF4_MASK + 0U, // PseudoVADD_VX_MF8 + 0U, // PseudoVADD_VX_MF8_MASK + 0U, // PseudoVAESDF_VS_M1_M1 + 0U, // PseudoVAESDF_VS_M1_MF2 + 0U, // PseudoVAESDF_VS_M1_MF4 + 0U, // PseudoVAESDF_VS_M1_MF8 + 0U, // PseudoVAESDF_VS_M2_M1 + 0U, // PseudoVAESDF_VS_M2_M2 + 0U, // PseudoVAESDF_VS_M2_MF2 + 0U, // PseudoVAESDF_VS_M2_MF4 + 0U, // PseudoVAESDF_VS_M2_MF8 + 0U, // PseudoVAESDF_VS_M4_M1 + 0U, // PseudoVAESDF_VS_M4_M2 + 0U, // PseudoVAESDF_VS_M4_M4 + 0U, // PseudoVAESDF_VS_M4_MF2 + 0U, // PseudoVAESDF_VS_M4_MF4 + 0U, // PseudoVAESDF_VS_M4_MF8 + 0U, // PseudoVAESDF_VS_M8_M1 + 0U, // PseudoVAESDF_VS_M8_M2 + 0U, // PseudoVAESDF_VS_M8_M4 + 0U, // PseudoVAESDF_VS_M8_MF2 + 0U, // PseudoVAESDF_VS_M8_MF4 + 0U, // PseudoVAESDF_VS_M8_MF8 + 0U, // PseudoVAESDF_VS_MF2_MF2 + 0U, // PseudoVAESDF_VS_MF2_MF4 + 0U, // PseudoVAESDF_VS_MF2_MF8 + 0U, // PseudoVAESDF_VV_M1 + 0U, // PseudoVAESDF_VV_M2 + 0U, // PseudoVAESDF_VV_M4 + 0U, // PseudoVAESDF_VV_M8 + 0U, // PseudoVAESDF_VV_MF2 + 0U, // PseudoVAESDM_VS_M1_M1 + 0U, // PseudoVAESDM_VS_M1_MF2 + 0U, // PseudoVAESDM_VS_M1_MF4 + 0U, // PseudoVAESDM_VS_M1_MF8 + 0U, // PseudoVAESDM_VS_M2_M1 + 0U, // PseudoVAESDM_VS_M2_M2 + 0U, // PseudoVAESDM_VS_M2_MF2 + 0U, // PseudoVAESDM_VS_M2_MF4 + 0U, // PseudoVAESDM_VS_M2_MF8 + 0U, // PseudoVAESDM_VS_M4_M1 + 0U, // PseudoVAESDM_VS_M4_M2 + 0U, // PseudoVAESDM_VS_M4_M4 + 0U, // PseudoVAESDM_VS_M4_MF2 + 0U, // PseudoVAESDM_VS_M4_MF4 + 0U, // PseudoVAESDM_VS_M4_MF8 + 0U, // PseudoVAESDM_VS_M8_M1 + 0U, // PseudoVAESDM_VS_M8_M2 + 0U, // PseudoVAESDM_VS_M8_M4 + 0U, // PseudoVAESDM_VS_M8_MF2 + 0U, // PseudoVAESDM_VS_M8_MF4 + 0U, // PseudoVAESDM_VS_M8_MF8 + 0U, // PseudoVAESDM_VS_MF2_MF2 + 0U, // PseudoVAESDM_VS_MF2_MF4 + 0U, // PseudoVAESDM_VS_MF2_MF8 + 0U, // PseudoVAESDM_VV_M1 + 0U, // PseudoVAESDM_VV_M2 + 0U, // PseudoVAESDM_VV_M4 + 0U, // PseudoVAESDM_VV_M8 + 0U, // PseudoVAESDM_VV_MF2 + 0U, // PseudoVAESEF_VS_M1_M1 + 0U, // PseudoVAESEF_VS_M1_MF2 + 0U, // PseudoVAESEF_VS_M1_MF4 + 0U, // PseudoVAESEF_VS_M1_MF8 + 0U, // PseudoVAESEF_VS_M2_M1 + 0U, // PseudoVAESEF_VS_M2_M2 + 0U, // PseudoVAESEF_VS_M2_MF2 + 0U, // PseudoVAESEF_VS_M2_MF4 + 0U, // PseudoVAESEF_VS_M2_MF8 + 0U, // PseudoVAESEF_VS_M4_M1 + 0U, // PseudoVAESEF_VS_M4_M2 + 0U, // PseudoVAESEF_VS_M4_M4 + 0U, // PseudoVAESEF_VS_M4_MF2 + 0U, // PseudoVAESEF_VS_M4_MF4 + 0U, // PseudoVAESEF_VS_M4_MF8 + 0U, // PseudoVAESEF_VS_M8_M1 + 0U, // PseudoVAESEF_VS_M8_M2 + 0U, // PseudoVAESEF_VS_M8_M4 + 0U, // PseudoVAESEF_VS_M8_MF2 + 0U, // PseudoVAESEF_VS_M8_MF4 + 0U, // PseudoVAESEF_VS_M8_MF8 + 0U, // PseudoVAESEF_VS_MF2_MF2 + 0U, // PseudoVAESEF_VS_MF2_MF4 + 0U, // PseudoVAESEF_VS_MF2_MF8 + 0U, // PseudoVAESEF_VV_M1 + 0U, // PseudoVAESEF_VV_M2 + 0U, // PseudoVAESEF_VV_M4 + 0U, // PseudoVAESEF_VV_M8 + 0U, // PseudoVAESEF_VV_MF2 + 0U, // PseudoVAESEM_VS_M1_M1 + 0U, // PseudoVAESEM_VS_M1_MF2 + 0U, // PseudoVAESEM_VS_M1_MF4 + 0U, // PseudoVAESEM_VS_M1_MF8 + 0U, // PseudoVAESEM_VS_M2_M1 + 0U, // PseudoVAESEM_VS_M2_M2 + 0U, // PseudoVAESEM_VS_M2_MF2 + 0U, // PseudoVAESEM_VS_M2_MF4 + 0U, // PseudoVAESEM_VS_M2_MF8 + 0U, // PseudoVAESEM_VS_M4_M1 + 0U, // PseudoVAESEM_VS_M4_M2 + 0U, // PseudoVAESEM_VS_M4_M4 + 0U, // PseudoVAESEM_VS_M4_MF2 + 0U, // PseudoVAESEM_VS_M4_MF4 + 0U, // PseudoVAESEM_VS_M4_MF8 + 0U, // PseudoVAESEM_VS_M8_M1 + 0U, // PseudoVAESEM_VS_M8_M2 + 0U, // PseudoVAESEM_VS_M8_M4 + 0U, // PseudoVAESEM_VS_M8_MF2 + 0U, // PseudoVAESEM_VS_M8_MF4 + 0U, // PseudoVAESEM_VS_M8_MF8 + 0U, // PseudoVAESEM_VS_MF2_MF2 + 0U, // PseudoVAESEM_VS_MF2_MF4 + 0U, // PseudoVAESEM_VS_MF2_MF8 + 0U, // PseudoVAESEM_VV_M1 + 0U, // PseudoVAESEM_VV_M2 + 0U, // PseudoVAESEM_VV_M4 + 0U, // PseudoVAESEM_VV_M8 + 0U, // PseudoVAESEM_VV_MF2 + 0U, // PseudoVAESKF1_VI_M1 + 0U, // PseudoVAESKF1_VI_M2 + 0U, // PseudoVAESKF1_VI_M4 + 0U, // PseudoVAESKF1_VI_M8 + 0U, // PseudoVAESKF1_VI_MF2 + 0U, // PseudoVAESKF2_VI_M1 + 0U, // PseudoVAESKF2_VI_M2 + 0U, // PseudoVAESKF2_VI_M4 + 0U, // PseudoVAESKF2_VI_M8 + 0U, // PseudoVAESKF2_VI_MF2 + 0U, // PseudoVAESZ_VS_M1_M1 + 0U, // PseudoVAESZ_VS_M1_MF2 + 0U, // PseudoVAESZ_VS_M1_MF4 + 0U, // PseudoVAESZ_VS_M1_MF8 + 0U, // PseudoVAESZ_VS_M2_M1 + 0U, // PseudoVAESZ_VS_M2_M2 + 0U, // PseudoVAESZ_VS_M2_MF2 + 0U, // PseudoVAESZ_VS_M2_MF4 + 0U, // PseudoVAESZ_VS_M2_MF8 + 0U, // PseudoVAESZ_VS_M4_M1 + 0U, // PseudoVAESZ_VS_M4_M2 + 0U, // PseudoVAESZ_VS_M4_M4 + 0U, // PseudoVAESZ_VS_M4_MF2 + 0U, // PseudoVAESZ_VS_M4_MF4 + 0U, // PseudoVAESZ_VS_M4_MF8 + 0U, // PseudoVAESZ_VS_M8_M1 + 0U, // PseudoVAESZ_VS_M8_M2 + 0U, // PseudoVAESZ_VS_M8_M4 + 0U, // PseudoVAESZ_VS_M8_MF2 + 0U, // PseudoVAESZ_VS_M8_MF4 + 0U, // PseudoVAESZ_VS_M8_MF8 + 0U, // PseudoVAESZ_VS_MF2_MF2 + 0U, // PseudoVAESZ_VS_MF2_MF4 + 0U, // PseudoVAESZ_VS_MF2_MF8 + 0U, // PseudoVANDN_VV_M1 + 0U, // PseudoVANDN_VV_M1_MASK + 0U, // PseudoVANDN_VV_M2 + 0U, // PseudoVANDN_VV_M2_MASK + 0U, // PseudoVANDN_VV_M4 + 0U, // PseudoVANDN_VV_M4_MASK + 0U, // PseudoVANDN_VV_M8 + 0U, // PseudoVANDN_VV_M8_MASK + 0U, // PseudoVANDN_VV_MF2 + 0U, // PseudoVANDN_VV_MF2_MASK + 0U, // PseudoVANDN_VV_MF4 + 0U, // PseudoVANDN_VV_MF4_MASK + 0U, // PseudoVANDN_VV_MF8 + 0U, // PseudoVANDN_VV_MF8_MASK + 0U, // PseudoVANDN_VX_M1 + 0U, // PseudoVANDN_VX_M1_MASK + 0U, // PseudoVANDN_VX_M2 + 0U, // PseudoVANDN_VX_M2_MASK + 0U, // PseudoVANDN_VX_M4 + 0U, // PseudoVANDN_VX_M4_MASK + 0U, // PseudoVANDN_VX_M8 + 0U, // PseudoVANDN_VX_M8_MASK + 0U, // PseudoVANDN_VX_MF2 + 0U, // PseudoVANDN_VX_MF2_MASK + 0U, // PseudoVANDN_VX_MF4 + 0U, // PseudoVANDN_VX_MF4_MASK + 0U, // PseudoVANDN_VX_MF8 + 0U, // PseudoVANDN_VX_MF8_MASK + 0U, // PseudoVAND_VI_M1 + 0U, // PseudoVAND_VI_M1_MASK + 0U, // PseudoVAND_VI_M2 + 0U, // PseudoVAND_VI_M2_MASK + 0U, // PseudoVAND_VI_M4 + 0U, // PseudoVAND_VI_M4_MASK + 0U, // PseudoVAND_VI_M8 + 0U, // PseudoVAND_VI_M8_MASK + 0U, // PseudoVAND_VI_MF2 + 0U, // PseudoVAND_VI_MF2_MASK + 0U, // PseudoVAND_VI_MF4 + 0U, // PseudoVAND_VI_MF4_MASK + 0U, // PseudoVAND_VI_MF8 + 0U, // PseudoVAND_VI_MF8_MASK + 0U, // PseudoVAND_VV_M1 + 0U, // PseudoVAND_VV_M1_MASK + 0U, // PseudoVAND_VV_M2 + 0U, // PseudoVAND_VV_M2_MASK + 0U, // PseudoVAND_VV_M4 + 0U, // PseudoVAND_VV_M4_MASK + 0U, // PseudoVAND_VV_M8 + 0U, // PseudoVAND_VV_M8_MASK + 0U, // PseudoVAND_VV_MF2 + 0U, // PseudoVAND_VV_MF2_MASK + 0U, // PseudoVAND_VV_MF4 + 0U, // PseudoVAND_VV_MF4_MASK + 0U, // PseudoVAND_VV_MF8 + 0U, // PseudoVAND_VV_MF8_MASK + 0U, // PseudoVAND_VX_M1 + 0U, // PseudoVAND_VX_M1_MASK + 0U, // PseudoVAND_VX_M2 + 0U, // PseudoVAND_VX_M2_MASK + 0U, // PseudoVAND_VX_M4 + 0U, // PseudoVAND_VX_M4_MASK + 0U, // PseudoVAND_VX_M8 + 0U, // PseudoVAND_VX_M8_MASK + 0U, // PseudoVAND_VX_MF2 + 0U, // PseudoVAND_VX_MF2_MASK + 0U, // PseudoVAND_VX_MF4 + 0U, // PseudoVAND_VX_MF4_MASK + 0U, // PseudoVAND_VX_MF8 + 0U, // PseudoVAND_VX_MF8_MASK + 0U, // PseudoVASUBU_VV_M1 + 0U, // PseudoVASUBU_VV_M1_MASK + 0U, // PseudoVASUBU_VV_M2 + 0U, // PseudoVASUBU_VV_M2_MASK + 0U, // PseudoVASUBU_VV_M4 + 0U, // PseudoVASUBU_VV_M4_MASK + 0U, // PseudoVASUBU_VV_M8 + 0U, // PseudoVASUBU_VV_M8_MASK + 0U, // PseudoVASUBU_VV_MF2 + 0U, // PseudoVASUBU_VV_MF2_MASK + 0U, // PseudoVASUBU_VV_MF4 + 0U, // PseudoVASUBU_VV_MF4_MASK + 0U, // PseudoVASUBU_VV_MF8 + 0U, // PseudoVASUBU_VV_MF8_MASK + 0U, // PseudoVASUBU_VX_M1 + 0U, // PseudoVASUBU_VX_M1_MASK + 0U, // PseudoVASUBU_VX_M2 + 0U, // PseudoVASUBU_VX_M2_MASK + 0U, // PseudoVASUBU_VX_M4 + 0U, // PseudoVASUBU_VX_M4_MASK + 0U, // PseudoVASUBU_VX_M8 + 0U, // PseudoVASUBU_VX_M8_MASK + 0U, // PseudoVASUBU_VX_MF2 + 0U, // PseudoVASUBU_VX_MF2_MASK + 0U, // PseudoVASUBU_VX_MF4 + 0U, // PseudoVASUBU_VX_MF4_MASK + 0U, // PseudoVASUBU_VX_MF8 + 0U, // PseudoVASUBU_VX_MF8_MASK + 0U, // PseudoVASUB_VV_M1 + 0U, // PseudoVASUB_VV_M1_MASK + 0U, // PseudoVASUB_VV_M2 + 0U, // PseudoVASUB_VV_M2_MASK + 0U, // PseudoVASUB_VV_M4 + 0U, // PseudoVASUB_VV_M4_MASK + 0U, // PseudoVASUB_VV_M8 + 0U, // PseudoVASUB_VV_M8_MASK + 0U, // PseudoVASUB_VV_MF2 + 0U, // PseudoVASUB_VV_MF2_MASK + 0U, // PseudoVASUB_VV_MF4 + 0U, // PseudoVASUB_VV_MF4_MASK + 0U, // PseudoVASUB_VV_MF8 + 0U, // PseudoVASUB_VV_MF8_MASK + 0U, // PseudoVASUB_VX_M1 + 0U, // PseudoVASUB_VX_M1_MASK + 0U, // PseudoVASUB_VX_M2 + 0U, // PseudoVASUB_VX_M2_MASK + 0U, // PseudoVASUB_VX_M4 + 0U, // PseudoVASUB_VX_M4_MASK + 0U, // PseudoVASUB_VX_M8 + 0U, // PseudoVASUB_VX_M8_MASK + 0U, // PseudoVASUB_VX_MF2 + 0U, // PseudoVASUB_VX_MF2_MASK + 0U, // PseudoVASUB_VX_MF4 + 0U, // PseudoVASUB_VX_MF4_MASK + 0U, // PseudoVASUB_VX_MF8 + 0U, // PseudoVASUB_VX_MF8_MASK + 0U, // PseudoVBREV8_V_M1 + 0U, // PseudoVBREV8_V_M1_MASK + 0U, // PseudoVBREV8_V_M2 + 0U, // PseudoVBREV8_V_M2_MASK + 0U, // PseudoVBREV8_V_M4 + 0U, // PseudoVBREV8_V_M4_MASK + 0U, // PseudoVBREV8_V_M8 + 0U, // PseudoVBREV8_V_M8_MASK + 0U, // PseudoVBREV8_V_MF2 + 0U, // PseudoVBREV8_V_MF2_MASK + 0U, // PseudoVBREV8_V_MF4 + 0U, // PseudoVBREV8_V_MF4_MASK + 0U, // PseudoVBREV8_V_MF8 + 0U, // PseudoVBREV8_V_MF8_MASK + 0U, // PseudoVBREV_V_M1 + 0U, // PseudoVBREV_V_M1_MASK + 0U, // PseudoVBREV_V_M2 + 0U, // PseudoVBREV_V_M2_MASK + 0U, // PseudoVBREV_V_M4 + 0U, // PseudoVBREV_V_M4_MASK + 0U, // PseudoVBREV_V_M8 + 0U, // PseudoVBREV_V_M8_MASK + 0U, // PseudoVBREV_V_MF2 + 0U, // PseudoVBREV_V_MF2_MASK + 0U, // PseudoVBREV_V_MF4 + 0U, // PseudoVBREV_V_MF4_MASK + 0U, // PseudoVBREV_V_MF8 + 0U, // PseudoVBREV_V_MF8_MASK + 0U, // PseudoVCLMULH_VV_M1 + 0U, // PseudoVCLMULH_VV_M1_MASK + 0U, // PseudoVCLMULH_VV_M2 + 0U, // PseudoVCLMULH_VV_M2_MASK + 0U, // PseudoVCLMULH_VV_M4 + 0U, // PseudoVCLMULH_VV_M4_MASK + 0U, // PseudoVCLMULH_VV_M8 + 0U, // PseudoVCLMULH_VV_M8_MASK + 0U, // PseudoVCLMULH_VV_MF2 + 0U, // PseudoVCLMULH_VV_MF2_MASK + 0U, // PseudoVCLMULH_VV_MF4 + 0U, // PseudoVCLMULH_VV_MF4_MASK + 0U, // PseudoVCLMULH_VV_MF8 + 0U, // PseudoVCLMULH_VV_MF8_MASK + 0U, // PseudoVCLMULH_VX_M1 + 0U, // PseudoVCLMULH_VX_M1_MASK + 0U, // PseudoVCLMULH_VX_M2 + 0U, // PseudoVCLMULH_VX_M2_MASK + 0U, // PseudoVCLMULH_VX_M4 + 0U, // PseudoVCLMULH_VX_M4_MASK + 0U, // PseudoVCLMULH_VX_M8 + 0U, // PseudoVCLMULH_VX_M8_MASK + 0U, // PseudoVCLMULH_VX_MF2 + 0U, // PseudoVCLMULH_VX_MF2_MASK + 0U, // PseudoVCLMULH_VX_MF4 + 0U, // PseudoVCLMULH_VX_MF4_MASK + 0U, // PseudoVCLMULH_VX_MF8 + 0U, // PseudoVCLMULH_VX_MF8_MASK + 0U, // PseudoVCLMUL_VV_M1 + 0U, // PseudoVCLMUL_VV_M1_MASK + 0U, // PseudoVCLMUL_VV_M2 + 0U, // PseudoVCLMUL_VV_M2_MASK + 0U, // PseudoVCLMUL_VV_M4 + 0U, // PseudoVCLMUL_VV_M4_MASK + 0U, // PseudoVCLMUL_VV_M8 + 0U, // PseudoVCLMUL_VV_M8_MASK + 0U, // PseudoVCLMUL_VV_MF2 + 0U, // PseudoVCLMUL_VV_MF2_MASK + 0U, // PseudoVCLMUL_VV_MF4 + 0U, // PseudoVCLMUL_VV_MF4_MASK + 0U, // PseudoVCLMUL_VV_MF8 + 0U, // PseudoVCLMUL_VV_MF8_MASK + 0U, // PseudoVCLMUL_VX_M1 + 0U, // PseudoVCLMUL_VX_M1_MASK + 0U, // PseudoVCLMUL_VX_M2 + 0U, // PseudoVCLMUL_VX_M2_MASK + 0U, // PseudoVCLMUL_VX_M4 + 0U, // PseudoVCLMUL_VX_M4_MASK + 0U, // PseudoVCLMUL_VX_M8 + 0U, // PseudoVCLMUL_VX_M8_MASK + 0U, // PseudoVCLMUL_VX_MF2 + 0U, // PseudoVCLMUL_VX_MF2_MASK + 0U, // PseudoVCLMUL_VX_MF4 + 0U, // PseudoVCLMUL_VX_MF4_MASK + 0U, // PseudoVCLMUL_VX_MF8 + 0U, // PseudoVCLMUL_VX_MF8_MASK + 0U, // PseudoVCLZ_V_M1 + 0U, // PseudoVCLZ_V_M1_MASK + 0U, // PseudoVCLZ_V_M2 + 0U, // PseudoVCLZ_V_M2_MASK + 0U, // PseudoVCLZ_V_M4 + 0U, // PseudoVCLZ_V_M4_MASK + 0U, // PseudoVCLZ_V_M8 + 0U, // PseudoVCLZ_V_M8_MASK + 0U, // PseudoVCLZ_V_MF2 + 0U, // PseudoVCLZ_V_MF2_MASK + 0U, // PseudoVCLZ_V_MF4 + 0U, // PseudoVCLZ_V_MF4_MASK + 0U, // PseudoVCLZ_V_MF8 + 0U, // PseudoVCLZ_V_MF8_MASK + 0U, // PseudoVCOMPRESS_VM_M1_E16 + 0U, // PseudoVCOMPRESS_VM_M1_E32 + 0U, // PseudoVCOMPRESS_VM_M1_E64 + 0U, // PseudoVCOMPRESS_VM_M1_E8 + 0U, // PseudoVCOMPRESS_VM_M2_E16 + 0U, // PseudoVCOMPRESS_VM_M2_E32 + 0U, // PseudoVCOMPRESS_VM_M2_E64 + 0U, // PseudoVCOMPRESS_VM_M2_E8 + 0U, // PseudoVCOMPRESS_VM_M4_E16 + 0U, // PseudoVCOMPRESS_VM_M4_E32 + 0U, // PseudoVCOMPRESS_VM_M4_E64 + 0U, // PseudoVCOMPRESS_VM_M4_E8 + 0U, // PseudoVCOMPRESS_VM_M8_E16 + 0U, // PseudoVCOMPRESS_VM_M8_E32 + 0U, // PseudoVCOMPRESS_VM_M8_E64 + 0U, // PseudoVCOMPRESS_VM_M8_E8 + 0U, // PseudoVCOMPRESS_VM_MF2_E16 + 0U, // PseudoVCOMPRESS_VM_MF2_E32 + 0U, // PseudoVCOMPRESS_VM_MF2_E8 + 0U, // PseudoVCOMPRESS_VM_MF4_E16 + 0U, // PseudoVCOMPRESS_VM_MF4_E8 + 0U, // PseudoVCOMPRESS_VM_MF8_E8 + 0U, // PseudoVCPOP_M_B1 + 0U, // PseudoVCPOP_M_B16 + 0U, // PseudoVCPOP_M_B16_MASK + 0U, // PseudoVCPOP_M_B1_MASK + 0U, // PseudoVCPOP_M_B2 + 0U, // PseudoVCPOP_M_B2_MASK + 0U, // PseudoVCPOP_M_B32 + 0U, // PseudoVCPOP_M_B32_MASK + 0U, // PseudoVCPOP_M_B4 + 0U, // PseudoVCPOP_M_B4_MASK + 0U, // PseudoVCPOP_M_B64 + 0U, // PseudoVCPOP_M_B64_MASK + 0U, // PseudoVCPOP_M_B8 + 0U, // PseudoVCPOP_M_B8_MASK + 0U, // PseudoVCPOP_V_M1 + 0U, // PseudoVCPOP_V_M1_MASK + 0U, // PseudoVCPOP_V_M2 + 0U, // PseudoVCPOP_V_M2_MASK + 0U, // PseudoVCPOP_V_M4 + 0U, // PseudoVCPOP_V_M4_MASK + 0U, // PseudoVCPOP_V_M8 + 0U, // PseudoVCPOP_V_M8_MASK + 0U, // PseudoVCPOP_V_MF2 + 0U, // PseudoVCPOP_V_MF2_MASK + 0U, // PseudoVCPOP_V_MF4 + 0U, // PseudoVCPOP_V_MF4_MASK + 0U, // PseudoVCPOP_V_MF8 + 0U, // PseudoVCPOP_V_MF8_MASK + 0U, // PseudoVCTZ_V_M1 + 0U, // PseudoVCTZ_V_M1_MASK + 0U, // PseudoVCTZ_V_M2 + 0U, // PseudoVCTZ_V_M2_MASK + 0U, // PseudoVCTZ_V_M4 + 0U, // PseudoVCTZ_V_M4_MASK + 0U, // PseudoVCTZ_V_M8 + 0U, // PseudoVCTZ_V_M8_MASK + 0U, // PseudoVCTZ_V_MF2 + 0U, // PseudoVCTZ_V_MF2_MASK + 0U, // PseudoVCTZ_V_MF4 + 0U, // PseudoVCTZ_V_MF4_MASK + 0U, // PseudoVCTZ_V_MF8 + 0U, // PseudoVCTZ_V_MF8_MASK + 0U, // PseudoVC_FPR16VV_SE_M1 + 0U, // PseudoVC_FPR16VV_SE_M2 + 0U, // PseudoVC_FPR16VV_SE_M4 + 0U, // PseudoVC_FPR16VV_SE_M8 + 0U, // PseudoVC_FPR16VV_SE_MF2 + 0U, // PseudoVC_FPR16VV_SE_MF4 + 0U, // PseudoVC_FPR16VW_SE_M1 + 0U, // PseudoVC_FPR16VW_SE_M2 + 0U, // PseudoVC_FPR16VW_SE_M4 + 0U, // PseudoVC_FPR16VW_SE_M8 + 0U, // PseudoVC_FPR16VW_SE_MF2 + 0U, // PseudoVC_FPR16VW_SE_MF4 + 0U, // PseudoVC_FPR16V_SE_M1 + 0U, // PseudoVC_FPR16V_SE_M2 + 0U, // PseudoVC_FPR16V_SE_M4 + 0U, // PseudoVC_FPR16V_SE_M8 + 0U, // PseudoVC_FPR16V_SE_MF2 + 0U, // PseudoVC_FPR16V_SE_MF4 + 0U, // PseudoVC_FPR32VV_SE_M1 + 0U, // PseudoVC_FPR32VV_SE_M2 + 0U, // PseudoVC_FPR32VV_SE_M4 + 0U, // PseudoVC_FPR32VV_SE_M8 + 0U, // PseudoVC_FPR32VV_SE_MF2 + 0U, // PseudoVC_FPR32VW_SE_M1 + 0U, // PseudoVC_FPR32VW_SE_M2 + 0U, // PseudoVC_FPR32VW_SE_M4 + 0U, // PseudoVC_FPR32VW_SE_M8 + 0U, // PseudoVC_FPR32VW_SE_MF2 + 0U, // PseudoVC_FPR32V_SE_M1 + 0U, // PseudoVC_FPR32V_SE_M2 + 0U, // PseudoVC_FPR32V_SE_M4 + 0U, // PseudoVC_FPR32V_SE_M8 + 0U, // PseudoVC_FPR32V_SE_MF2 + 0U, // PseudoVC_FPR64VV_SE_M1 + 0U, // PseudoVC_FPR64VV_SE_M2 + 0U, // PseudoVC_FPR64VV_SE_M4 + 0U, // PseudoVC_FPR64VV_SE_M8 + 0U, // PseudoVC_FPR64V_SE_M1 + 0U, // PseudoVC_FPR64V_SE_M2 + 0U, // PseudoVC_FPR64V_SE_M4 + 0U, // PseudoVC_FPR64V_SE_M8 + 0U, // PseudoVC_IVV_SE_M1 + 0U, // PseudoVC_IVV_SE_M2 + 0U, // PseudoVC_IVV_SE_M4 + 0U, // PseudoVC_IVV_SE_M8 + 0U, // PseudoVC_IVV_SE_MF2 + 0U, // PseudoVC_IVV_SE_MF4 + 0U, // PseudoVC_IVV_SE_MF8 + 0U, // PseudoVC_IVW_SE_M1 + 0U, // PseudoVC_IVW_SE_M2 + 0U, // PseudoVC_IVW_SE_M4 + 0U, // PseudoVC_IVW_SE_MF2 + 0U, // PseudoVC_IVW_SE_MF4 + 0U, // PseudoVC_IVW_SE_MF8 + 0U, // PseudoVC_IV_SE_M1 + 0U, // PseudoVC_IV_SE_M2 + 0U, // PseudoVC_IV_SE_M4 + 0U, // PseudoVC_IV_SE_M8 + 0U, // PseudoVC_IV_SE_MF2 + 0U, // PseudoVC_IV_SE_MF4 + 0U, // PseudoVC_IV_SE_MF8 + 0U, // PseudoVC_I_SE_M1 + 0U, // PseudoVC_I_SE_M2 + 0U, // PseudoVC_I_SE_M4 + 0U, // PseudoVC_I_SE_M8 + 0U, // PseudoVC_I_SE_MF2 + 0U, // PseudoVC_I_SE_MF4 + 0U, // PseudoVC_I_SE_MF8 + 0U, // PseudoVC_VVV_SE_M1 + 0U, // PseudoVC_VVV_SE_M2 + 0U, // PseudoVC_VVV_SE_M4 + 0U, // PseudoVC_VVV_SE_M8 + 0U, // PseudoVC_VVV_SE_MF2 + 0U, // PseudoVC_VVV_SE_MF4 + 0U, // PseudoVC_VVV_SE_MF8 + 0U, // PseudoVC_VVW_SE_M1 + 0U, // PseudoVC_VVW_SE_M2 + 0U, // PseudoVC_VVW_SE_M4 + 0U, // PseudoVC_VVW_SE_MF2 + 0U, // PseudoVC_VVW_SE_MF4 + 0U, // PseudoVC_VVW_SE_MF8 + 0U, // PseudoVC_VV_SE_M1 + 0U, // PseudoVC_VV_SE_M2 + 0U, // PseudoVC_VV_SE_M4 + 0U, // PseudoVC_VV_SE_M8 + 0U, // PseudoVC_VV_SE_MF2 + 0U, // PseudoVC_VV_SE_MF4 + 0U, // PseudoVC_VV_SE_MF8 + 0U, // PseudoVC_V_FPR16VV_M1 + 0U, // PseudoVC_V_FPR16VV_M2 + 0U, // PseudoVC_V_FPR16VV_M4 + 0U, // PseudoVC_V_FPR16VV_M8 + 0U, // PseudoVC_V_FPR16VV_MF2 + 0U, // PseudoVC_V_FPR16VV_MF4 + 0U, // PseudoVC_V_FPR16VV_SE_M1 + 0U, // PseudoVC_V_FPR16VV_SE_M2 + 0U, // PseudoVC_V_FPR16VV_SE_M4 + 0U, // PseudoVC_V_FPR16VV_SE_M8 + 0U, // PseudoVC_V_FPR16VV_SE_MF2 + 0U, // PseudoVC_V_FPR16VV_SE_MF4 + 0U, // PseudoVC_V_FPR16VW_M1 + 0U, // PseudoVC_V_FPR16VW_M2 + 0U, // PseudoVC_V_FPR16VW_M4 + 0U, // PseudoVC_V_FPR16VW_M8 + 0U, // PseudoVC_V_FPR16VW_MF2 + 0U, // PseudoVC_V_FPR16VW_MF4 + 0U, // PseudoVC_V_FPR16VW_SE_M1 + 0U, // PseudoVC_V_FPR16VW_SE_M2 + 0U, // PseudoVC_V_FPR16VW_SE_M4 + 0U, // PseudoVC_V_FPR16VW_SE_M8 + 0U, // PseudoVC_V_FPR16VW_SE_MF2 + 0U, // PseudoVC_V_FPR16VW_SE_MF4 + 0U, // PseudoVC_V_FPR16V_M1 + 0U, // PseudoVC_V_FPR16V_M2 + 0U, // PseudoVC_V_FPR16V_M4 + 0U, // PseudoVC_V_FPR16V_M8 + 0U, // PseudoVC_V_FPR16V_MF2 + 0U, // PseudoVC_V_FPR16V_MF4 + 0U, // PseudoVC_V_FPR16V_SE_M1 + 0U, // PseudoVC_V_FPR16V_SE_M2 + 0U, // PseudoVC_V_FPR16V_SE_M4 + 0U, // PseudoVC_V_FPR16V_SE_M8 + 0U, // PseudoVC_V_FPR16V_SE_MF2 + 0U, // PseudoVC_V_FPR16V_SE_MF4 + 0U, // PseudoVC_V_FPR32VV_M1 + 0U, // PseudoVC_V_FPR32VV_M2 + 0U, // PseudoVC_V_FPR32VV_M4 + 0U, // PseudoVC_V_FPR32VV_M8 + 0U, // PseudoVC_V_FPR32VV_MF2 + 0U, // PseudoVC_V_FPR32VV_SE_M1 + 0U, // PseudoVC_V_FPR32VV_SE_M2 + 0U, // PseudoVC_V_FPR32VV_SE_M4 + 0U, // PseudoVC_V_FPR32VV_SE_M8 + 0U, // PseudoVC_V_FPR32VV_SE_MF2 + 0U, // PseudoVC_V_FPR32VW_M1 + 0U, // PseudoVC_V_FPR32VW_M2 + 0U, // PseudoVC_V_FPR32VW_M4 + 0U, // PseudoVC_V_FPR32VW_M8 + 0U, // PseudoVC_V_FPR32VW_MF2 + 0U, // PseudoVC_V_FPR32VW_SE_M1 + 0U, // PseudoVC_V_FPR32VW_SE_M2 + 0U, // PseudoVC_V_FPR32VW_SE_M4 + 0U, // PseudoVC_V_FPR32VW_SE_M8 + 0U, // PseudoVC_V_FPR32VW_SE_MF2 + 0U, // PseudoVC_V_FPR32V_M1 + 0U, // PseudoVC_V_FPR32V_M2 + 0U, // PseudoVC_V_FPR32V_M4 + 0U, // PseudoVC_V_FPR32V_M8 + 0U, // PseudoVC_V_FPR32V_MF2 + 0U, // PseudoVC_V_FPR32V_SE_M1 + 0U, // PseudoVC_V_FPR32V_SE_M2 + 0U, // PseudoVC_V_FPR32V_SE_M4 + 0U, // PseudoVC_V_FPR32V_SE_M8 + 0U, // PseudoVC_V_FPR32V_SE_MF2 + 0U, // PseudoVC_V_FPR64VV_M1 + 0U, // PseudoVC_V_FPR64VV_M2 + 0U, // PseudoVC_V_FPR64VV_M4 + 0U, // PseudoVC_V_FPR64VV_M8 + 0U, // PseudoVC_V_FPR64VV_SE_M1 + 0U, // PseudoVC_V_FPR64VV_SE_M2 + 0U, // PseudoVC_V_FPR64VV_SE_M4 + 0U, // PseudoVC_V_FPR64VV_SE_M8 + 0U, // PseudoVC_V_FPR64V_M1 + 0U, // PseudoVC_V_FPR64V_M2 + 0U, // PseudoVC_V_FPR64V_M4 + 0U, // PseudoVC_V_FPR64V_M8 + 0U, // PseudoVC_V_FPR64V_SE_M1 + 0U, // PseudoVC_V_FPR64V_SE_M2 + 0U, // PseudoVC_V_FPR64V_SE_M4 + 0U, // PseudoVC_V_FPR64V_SE_M8 + 0U, // PseudoVC_V_IVV_M1 + 0U, // PseudoVC_V_IVV_M2 + 0U, // PseudoVC_V_IVV_M4 + 0U, // PseudoVC_V_IVV_M8 + 0U, // PseudoVC_V_IVV_MF2 + 0U, // PseudoVC_V_IVV_MF4 + 0U, // PseudoVC_V_IVV_MF8 + 0U, // PseudoVC_V_IVV_SE_M1 + 0U, // PseudoVC_V_IVV_SE_M2 + 0U, // PseudoVC_V_IVV_SE_M4 + 0U, // PseudoVC_V_IVV_SE_M8 + 0U, // PseudoVC_V_IVV_SE_MF2 + 0U, // PseudoVC_V_IVV_SE_MF4 + 0U, // PseudoVC_V_IVV_SE_MF8 + 0U, // PseudoVC_V_IVW_M1 + 0U, // PseudoVC_V_IVW_M2 + 0U, // PseudoVC_V_IVW_M4 + 0U, // PseudoVC_V_IVW_MF2 + 0U, // PseudoVC_V_IVW_MF4 + 0U, // PseudoVC_V_IVW_MF8 + 0U, // PseudoVC_V_IVW_SE_M1 + 0U, // PseudoVC_V_IVW_SE_M2 + 0U, // PseudoVC_V_IVW_SE_M4 + 0U, // PseudoVC_V_IVW_SE_MF2 + 0U, // PseudoVC_V_IVW_SE_MF4 + 0U, // PseudoVC_V_IVW_SE_MF8 + 0U, // PseudoVC_V_IV_M1 + 0U, // PseudoVC_V_IV_M2 + 0U, // PseudoVC_V_IV_M4 + 0U, // PseudoVC_V_IV_M8 + 0U, // PseudoVC_V_IV_MF2 + 0U, // PseudoVC_V_IV_MF4 + 0U, // PseudoVC_V_IV_MF8 + 0U, // PseudoVC_V_IV_SE_M1 + 0U, // PseudoVC_V_IV_SE_M2 + 0U, // PseudoVC_V_IV_SE_M4 + 0U, // PseudoVC_V_IV_SE_M8 + 0U, // PseudoVC_V_IV_SE_MF2 + 0U, // PseudoVC_V_IV_SE_MF4 + 0U, // PseudoVC_V_IV_SE_MF8 + 0U, // PseudoVC_V_I_M1 + 0U, // PseudoVC_V_I_M2 + 0U, // PseudoVC_V_I_M4 + 0U, // PseudoVC_V_I_M8 + 0U, // PseudoVC_V_I_MF2 + 0U, // PseudoVC_V_I_MF4 + 0U, // PseudoVC_V_I_MF8 + 0U, // PseudoVC_V_I_SE_M1 + 0U, // PseudoVC_V_I_SE_M2 + 0U, // PseudoVC_V_I_SE_M4 + 0U, // PseudoVC_V_I_SE_M8 + 0U, // PseudoVC_V_I_SE_MF2 + 0U, // PseudoVC_V_I_SE_MF4 + 0U, // PseudoVC_V_I_SE_MF8 + 0U, // PseudoVC_V_VVV_M1 + 0U, // PseudoVC_V_VVV_M2 + 0U, // PseudoVC_V_VVV_M4 + 0U, // PseudoVC_V_VVV_M8 + 0U, // PseudoVC_V_VVV_MF2 + 0U, // PseudoVC_V_VVV_MF4 + 0U, // PseudoVC_V_VVV_MF8 + 0U, // PseudoVC_V_VVV_SE_M1 + 0U, // PseudoVC_V_VVV_SE_M2 + 0U, // PseudoVC_V_VVV_SE_M4 + 0U, // PseudoVC_V_VVV_SE_M8 + 0U, // PseudoVC_V_VVV_SE_MF2 + 0U, // PseudoVC_V_VVV_SE_MF4 + 0U, // PseudoVC_V_VVV_SE_MF8 + 0U, // PseudoVC_V_VVW_M1 + 0U, // PseudoVC_V_VVW_M2 + 0U, // PseudoVC_V_VVW_M4 + 0U, // PseudoVC_V_VVW_MF2 + 0U, // PseudoVC_V_VVW_MF4 + 0U, // PseudoVC_V_VVW_MF8 + 0U, // PseudoVC_V_VVW_SE_M1 + 0U, // PseudoVC_V_VVW_SE_M2 + 0U, // PseudoVC_V_VVW_SE_M4 + 0U, // PseudoVC_V_VVW_SE_MF2 + 0U, // PseudoVC_V_VVW_SE_MF4 + 0U, // PseudoVC_V_VVW_SE_MF8 + 0U, // PseudoVC_V_VV_M1 + 0U, // PseudoVC_V_VV_M2 + 0U, // PseudoVC_V_VV_M4 + 0U, // PseudoVC_V_VV_M8 + 0U, // PseudoVC_V_VV_MF2 + 0U, // PseudoVC_V_VV_MF4 + 0U, // PseudoVC_V_VV_MF8 + 0U, // PseudoVC_V_VV_SE_M1 + 0U, // PseudoVC_V_VV_SE_M2 + 0U, // PseudoVC_V_VV_SE_M4 + 0U, // PseudoVC_V_VV_SE_M8 + 0U, // PseudoVC_V_VV_SE_MF2 + 0U, // PseudoVC_V_VV_SE_MF4 + 0U, // PseudoVC_V_VV_SE_MF8 + 0U, // PseudoVC_V_XVV_M1 + 0U, // PseudoVC_V_XVV_M2 + 0U, // PseudoVC_V_XVV_M4 + 0U, // PseudoVC_V_XVV_M8 + 0U, // PseudoVC_V_XVV_MF2 + 0U, // PseudoVC_V_XVV_MF4 + 0U, // PseudoVC_V_XVV_MF8 + 0U, // PseudoVC_V_XVV_SE_M1 + 0U, // PseudoVC_V_XVV_SE_M2 + 0U, // PseudoVC_V_XVV_SE_M4 + 0U, // PseudoVC_V_XVV_SE_M8 + 0U, // PseudoVC_V_XVV_SE_MF2 + 0U, // PseudoVC_V_XVV_SE_MF4 + 0U, // PseudoVC_V_XVV_SE_MF8 + 0U, // PseudoVC_V_XVW_M1 + 0U, // PseudoVC_V_XVW_M2 + 0U, // PseudoVC_V_XVW_M4 + 0U, // PseudoVC_V_XVW_MF2 + 0U, // PseudoVC_V_XVW_MF4 + 0U, // PseudoVC_V_XVW_MF8 + 0U, // PseudoVC_V_XVW_SE_M1 + 0U, // PseudoVC_V_XVW_SE_M2 + 0U, // PseudoVC_V_XVW_SE_M4 + 0U, // PseudoVC_V_XVW_SE_MF2 + 0U, // PseudoVC_V_XVW_SE_MF4 + 0U, // PseudoVC_V_XVW_SE_MF8 + 0U, // PseudoVC_V_XV_M1 + 0U, // PseudoVC_V_XV_M2 + 0U, // PseudoVC_V_XV_M4 + 0U, // PseudoVC_V_XV_M8 + 0U, // PseudoVC_V_XV_MF2 + 0U, // PseudoVC_V_XV_MF4 + 0U, // PseudoVC_V_XV_MF8 + 0U, // PseudoVC_V_XV_SE_M1 + 0U, // PseudoVC_V_XV_SE_M2 + 0U, // PseudoVC_V_XV_SE_M4 + 0U, // PseudoVC_V_XV_SE_M8 + 0U, // PseudoVC_V_XV_SE_MF2 + 0U, // PseudoVC_V_XV_SE_MF4 + 0U, // PseudoVC_V_XV_SE_MF8 + 0U, // PseudoVC_V_X_M1 + 0U, // PseudoVC_V_X_M2 + 0U, // PseudoVC_V_X_M4 + 0U, // PseudoVC_V_X_M8 + 0U, // PseudoVC_V_X_MF2 + 0U, // PseudoVC_V_X_MF4 + 0U, // PseudoVC_V_X_MF8 + 0U, // PseudoVC_V_X_SE_M1 + 0U, // PseudoVC_V_X_SE_M2 + 0U, // PseudoVC_V_X_SE_M4 + 0U, // PseudoVC_V_X_SE_M8 + 0U, // PseudoVC_V_X_SE_MF2 + 0U, // PseudoVC_V_X_SE_MF4 + 0U, // PseudoVC_V_X_SE_MF8 + 0U, // PseudoVC_XVV_SE_M1 + 0U, // PseudoVC_XVV_SE_M2 + 0U, // PseudoVC_XVV_SE_M4 + 0U, // PseudoVC_XVV_SE_M8 + 0U, // PseudoVC_XVV_SE_MF2 + 0U, // PseudoVC_XVV_SE_MF4 + 0U, // PseudoVC_XVV_SE_MF8 + 0U, // PseudoVC_XVW_SE_M1 + 0U, // PseudoVC_XVW_SE_M2 + 0U, // PseudoVC_XVW_SE_M4 + 0U, // PseudoVC_XVW_SE_MF2 + 0U, // PseudoVC_XVW_SE_MF4 + 0U, // PseudoVC_XVW_SE_MF8 + 0U, // PseudoVC_XV_SE_M1 + 0U, // PseudoVC_XV_SE_M2 + 0U, // PseudoVC_XV_SE_M4 + 0U, // PseudoVC_XV_SE_M8 + 0U, // PseudoVC_XV_SE_MF2 + 0U, // PseudoVC_XV_SE_MF4 + 0U, // PseudoVC_XV_SE_MF8 + 0U, // PseudoVC_X_SE_M1 + 0U, // PseudoVC_X_SE_M2 + 0U, // PseudoVC_X_SE_M4 + 0U, // PseudoVC_X_SE_M8 + 0U, // PseudoVC_X_SE_MF2 + 0U, // PseudoVC_X_SE_MF4 + 0U, // PseudoVC_X_SE_MF8 + 0U, // PseudoVDIVU_VV_M1_E16 + 0U, // PseudoVDIVU_VV_M1_E16_MASK + 0U, // PseudoVDIVU_VV_M1_E32 + 0U, // PseudoVDIVU_VV_M1_E32_MASK + 0U, // PseudoVDIVU_VV_M1_E64 + 0U, // PseudoVDIVU_VV_M1_E64_MASK + 0U, // PseudoVDIVU_VV_M1_E8 + 0U, // PseudoVDIVU_VV_M1_E8_MASK + 0U, // PseudoVDIVU_VV_M2_E16 + 0U, // PseudoVDIVU_VV_M2_E16_MASK + 0U, // PseudoVDIVU_VV_M2_E32 + 0U, // PseudoVDIVU_VV_M2_E32_MASK + 0U, // PseudoVDIVU_VV_M2_E64 + 0U, // PseudoVDIVU_VV_M2_E64_MASK + 0U, // PseudoVDIVU_VV_M2_E8 + 0U, // PseudoVDIVU_VV_M2_E8_MASK + 0U, // PseudoVDIVU_VV_M4_E16 + 0U, // PseudoVDIVU_VV_M4_E16_MASK + 0U, // PseudoVDIVU_VV_M4_E32 + 0U, // PseudoVDIVU_VV_M4_E32_MASK + 0U, // PseudoVDIVU_VV_M4_E64 + 0U, // PseudoVDIVU_VV_M4_E64_MASK + 0U, // PseudoVDIVU_VV_M4_E8 + 0U, // PseudoVDIVU_VV_M4_E8_MASK + 0U, // PseudoVDIVU_VV_M8_E16 + 0U, // PseudoVDIVU_VV_M8_E16_MASK + 0U, // PseudoVDIVU_VV_M8_E32 + 0U, // PseudoVDIVU_VV_M8_E32_MASK + 0U, // PseudoVDIVU_VV_M8_E64 + 0U, // PseudoVDIVU_VV_M8_E64_MASK + 0U, // PseudoVDIVU_VV_M8_E8 + 0U, // PseudoVDIVU_VV_M8_E8_MASK + 0U, // PseudoVDIVU_VV_MF2_E16 + 0U, // PseudoVDIVU_VV_MF2_E16_MASK + 0U, // PseudoVDIVU_VV_MF2_E32 + 0U, // PseudoVDIVU_VV_MF2_E32_MASK + 0U, // PseudoVDIVU_VV_MF2_E8 + 0U, // PseudoVDIVU_VV_MF2_E8_MASK + 0U, // PseudoVDIVU_VV_MF4_E16 + 0U, // PseudoVDIVU_VV_MF4_E16_MASK + 0U, // PseudoVDIVU_VV_MF4_E8 + 0U, // PseudoVDIVU_VV_MF4_E8_MASK + 0U, // PseudoVDIVU_VV_MF8_E8 + 0U, // PseudoVDIVU_VV_MF8_E8_MASK + 0U, // PseudoVDIVU_VX_M1_E16 + 0U, // PseudoVDIVU_VX_M1_E16_MASK + 0U, // PseudoVDIVU_VX_M1_E32 + 0U, // PseudoVDIVU_VX_M1_E32_MASK + 0U, // PseudoVDIVU_VX_M1_E64 + 0U, // PseudoVDIVU_VX_M1_E64_MASK + 0U, // PseudoVDIVU_VX_M1_E8 + 0U, // PseudoVDIVU_VX_M1_E8_MASK + 0U, // PseudoVDIVU_VX_M2_E16 + 0U, // PseudoVDIVU_VX_M2_E16_MASK + 0U, // PseudoVDIVU_VX_M2_E32 + 0U, // PseudoVDIVU_VX_M2_E32_MASK + 0U, // PseudoVDIVU_VX_M2_E64 + 0U, // PseudoVDIVU_VX_M2_E64_MASK + 0U, // PseudoVDIVU_VX_M2_E8 + 0U, // PseudoVDIVU_VX_M2_E8_MASK + 0U, // PseudoVDIVU_VX_M4_E16 + 0U, // PseudoVDIVU_VX_M4_E16_MASK + 0U, // PseudoVDIVU_VX_M4_E32 + 0U, // PseudoVDIVU_VX_M4_E32_MASK + 0U, // PseudoVDIVU_VX_M4_E64 + 0U, // PseudoVDIVU_VX_M4_E64_MASK + 0U, // PseudoVDIVU_VX_M4_E8 + 0U, // PseudoVDIVU_VX_M4_E8_MASK + 0U, // PseudoVDIVU_VX_M8_E16 + 0U, // PseudoVDIVU_VX_M8_E16_MASK + 0U, // PseudoVDIVU_VX_M8_E32 + 0U, // PseudoVDIVU_VX_M8_E32_MASK + 0U, // PseudoVDIVU_VX_M8_E64 + 0U, // PseudoVDIVU_VX_M8_E64_MASK + 0U, // PseudoVDIVU_VX_M8_E8 + 0U, // PseudoVDIVU_VX_M8_E8_MASK + 0U, // PseudoVDIVU_VX_MF2_E16 + 0U, // PseudoVDIVU_VX_MF2_E16_MASK + 0U, // PseudoVDIVU_VX_MF2_E32 + 0U, // PseudoVDIVU_VX_MF2_E32_MASK + 0U, // PseudoVDIVU_VX_MF2_E8 + 0U, // PseudoVDIVU_VX_MF2_E8_MASK + 0U, // PseudoVDIVU_VX_MF4_E16 + 0U, // PseudoVDIVU_VX_MF4_E16_MASK + 0U, // PseudoVDIVU_VX_MF4_E8 + 0U, // PseudoVDIVU_VX_MF4_E8_MASK + 0U, // PseudoVDIVU_VX_MF8_E8 + 0U, // PseudoVDIVU_VX_MF8_E8_MASK + 0U, // PseudoVDIV_VV_M1_E16 + 0U, // PseudoVDIV_VV_M1_E16_MASK + 0U, // PseudoVDIV_VV_M1_E32 + 0U, // PseudoVDIV_VV_M1_E32_MASK + 0U, // PseudoVDIV_VV_M1_E64 + 0U, // PseudoVDIV_VV_M1_E64_MASK + 0U, // PseudoVDIV_VV_M1_E8 + 0U, // PseudoVDIV_VV_M1_E8_MASK + 0U, // PseudoVDIV_VV_M2_E16 + 0U, // PseudoVDIV_VV_M2_E16_MASK + 0U, // PseudoVDIV_VV_M2_E32 + 0U, // PseudoVDIV_VV_M2_E32_MASK + 0U, // PseudoVDIV_VV_M2_E64 + 0U, // PseudoVDIV_VV_M2_E64_MASK + 0U, // PseudoVDIV_VV_M2_E8 + 0U, // PseudoVDIV_VV_M2_E8_MASK + 0U, // PseudoVDIV_VV_M4_E16 + 0U, // PseudoVDIV_VV_M4_E16_MASK + 0U, // PseudoVDIV_VV_M4_E32 + 0U, // PseudoVDIV_VV_M4_E32_MASK + 0U, // PseudoVDIV_VV_M4_E64 + 0U, // PseudoVDIV_VV_M4_E64_MASK + 0U, // PseudoVDIV_VV_M4_E8 + 0U, // PseudoVDIV_VV_M4_E8_MASK + 0U, // PseudoVDIV_VV_M8_E16 + 0U, // PseudoVDIV_VV_M8_E16_MASK + 0U, // PseudoVDIV_VV_M8_E32 + 0U, // PseudoVDIV_VV_M8_E32_MASK + 0U, // PseudoVDIV_VV_M8_E64 + 0U, // PseudoVDIV_VV_M8_E64_MASK + 0U, // PseudoVDIV_VV_M8_E8 + 0U, // PseudoVDIV_VV_M8_E8_MASK + 0U, // PseudoVDIV_VV_MF2_E16 + 0U, // PseudoVDIV_VV_MF2_E16_MASK + 0U, // PseudoVDIV_VV_MF2_E32 + 0U, // PseudoVDIV_VV_MF2_E32_MASK + 0U, // PseudoVDIV_VV_MF2_E8 + 0U, // PseudoVDIV_VV_MF2_E8_MASK + 0U, // PseudoVDIV_VV_MF4_E16 + 0U, // PseudoVDIV_VV_MF4_E16_MASK + 0U, // PseudoVDIV_VV_MF4_E8 + 0U, // PseudoVDIV_VV_MF4_E8_MASK + 0U, // PseudoVDIV_VV_MF8_E8 + 0U, // PseudoVDIV_VV_MF8_E8_MASK + 0U, // PseudoVDIV_VX_M1_E16 + 0U, // PseudoVDIV_VX_M1_E16_MASK + 0U, // PseudoVDIV_VX_M1_E32 + 0U, // PseudoVDIV_VX_M1_E32_MASK + 0U, // PseudoVDIV_VX_M1_E64 + 0U, // PseudoVDIV_VX_M1_E64_MASK + 0U, // PseudoVDIV_VX_M1_E8 + 0U, // PseudoVDIV_VX_M1_E8_MASK + 0U, // PseudoVDIV_VX_M2_E16 + 0U, // PseudoVDIV_VX_M2_E16_MASK + 0U, // PseudoVDIV_VX_M2_E32 + 0U, // PseudoVDIV_VX_M2_E32_MASK + 0U, // PseudoVDIV_VX_M2_E64 + 0U, // PseudoVDIV_VX_M2_E64_MASK + 0U, // PseudoVDIV_VX_M2_E8 + 0U, // PseudoVDIV_VX_M2_E8_MASK + 0U, // PseudoVDIV_VX_M4_E16 + 0U, // PseudoVDIV_VX_M4_E16_MASK + 0U, // PseudoVDIV_VX_M4_E32 + 0U, // PseudoVDIV_VX_M4_E32_MASK + 0U, // PseudoVDIV_VX_M4_E64 + 0U, // PseudoVDIV_VX_M4_E64_MASK + 0U, // PseudoVDIV_VX_M4_E8 + 0U, // PseudoVDIV_VX_M4_E8_MASK + 0U, // PseudoVDIV_VX_M8_E16 + 0U, // PseudoVDIV_VX_M8_E16_MASK + 0U, // PseudoVDIV_VX_M8_E32 + 0U, // PseudoVDIV_VX_M8_E32_MASK + 0U, // PseudoVDIV_VX_M8_E64 + 0U, // PseudoVDIV_VX_M8_E64_MASK + 0U, // PseudoVDIV_VX_M8_E8 + 0U, // PseudoVDIV_VX_M8_E8_MASK + 0U, // PseudoVDIV_VX_MF2_E16 + 0U, // PseudoVDIV_VX_MF2_E16_MASK + 0U, // PseudoVDIV_VX_MF2_E32 + 0U, // PseudoVDIV_VX_MF2_E32_MASK + 0U, // PseudoVDIV_VX_MF2_E8 + 0U, // PseudoVDIV_VX_MF2_E8_MASK + 0U, // PseudoVDIV_VX_MF4_E16 + 0U, // PseudoVDIV_VX_MF4_E16_MASK + 0U, // PseudoVDIV_VX_MF4_E8 + 0U, // PseudoVDIV_VX_MF4_E8_MASK + 0U, // PseudoVDIV_VX_MF8_E8 + 0U, // PseudoVDIV_VX_MF8_E8_MASK + 0U, // PseudoVFADD_VFPR16_M1 + 0U, // PseudoVFADD_VFPR16_M1_MASK + 0U, // PseudoVFADD_VFPR16_M2 + 0U, // PseudoVFADD_VFPR16_M2_MASK + 0U, // PseudoVFADD_VFPR16_M4 + 0U, // PseudoVFADD_VFPR16_M4_MASK + 0U, // PseudoVFADD_VFPR16_M8 + 0U, // PseudoVFADD_VFPR16_M8_MASK + 0U, // PseudoVFADD_VFPR16_MF2 + 0U, // PseudoVFADD_VFPR16_MF2_MASK + 0U, // PseudoVFADD_VFPR16_MF4 + 0U, // PseudoVFADD_VFPR16_MF4_MASK + 0U, // PseudoVFADD_VFPR32_M1 + 0U, // PseudoVFADD_VFPR32_M1_MASK + 0U, // PseudoVFADD_VFPR32_M2 + 0U, // PseudoVFADD_VFPR32_M2_MASK + 0U, // PseudoVFADD_VFPR32_M4 + 0U, // PseudoVFADD_VFPR32_M4_MASK + 0U, // PseudoVFADD_VFPR32_M8 + 0U, // PseudoVFADD_VFPR32_M8_MASK + 0U, // PseudoVFADD_VFPR32_MF2 + 0U, // PseudoVFADD_VFPR32_MF2_MASK + 0U, // PseudoVFADD_VFPR64_M1 + 0U, // PseudoVFADD_VFPR64_M1_MASK + 0U, // PseudoVFADD_VFPR64_M2 + 0U, // PseudoVFADD_VFPR64_M2_MASK + 0U, // PseudoVFADD_VFPR64_M4 + 0U, // PseudoVFADD_VFPR64_M4_MASK + 0U, // PseudoVFADD_VFPR64_M8 + 0U, // PseudoVFADD_VFPR64_M8_MASK + 0U, // PseudoVFADD_VV_M1 + 0U, // PseudoVFADD_VV_M1_MASK + 0U, // PseudoVFADD_VV_M2 + 0U, // PseudoVFADD_VV_M2_MASK + 0U, // PseudoVFADD_VV_M4 + 0U, // PseudoVFADD_VV_M4_MASK + 0U, // PseudoVFADD_VV_M8 + 0U, // PseudoVFADD_VV_M8_MASK + 0U, // PseudoVFADD_VV_MF2 + 0U, // PseudoVFADD_VV_MF2_MASK + 0U, // PseudoVFADD_VV_MF4 + 0U, // PseudoVFADD_VV_MF4_MASK + 0U, // PseudoVFCLASS_V_M1 + 0U, // PseudoVFCLASS_V_M1_MASK + 0U, // PseudoVFCLASS_V_M2 + 0U, // PseudoVFCLASS_V_M2_MASK + 0U, // PseudoVFCLASS_V_M4 + 0U, // PseudoVFCLASS_V_M4_MASK + 0U, // PseudoVFCLASS_V_M8 + 0U, // PseudoVFCLASS_V_M8_MASK + 0U, // PseudoVFCLASS_V_MF2 + 0U, // PseudoVFCLASS_V_MF2_MASK + 0U, // PseudoVFCLASS_V_MF4 + 0U, // PseudoVFCLASS_V_MF4_MASK + 0U, // PseudoVFCVT_F_XU_V_M1 + 0U, // PseudoVFCVT_F_XU_V_M1_MASK + 0U, // PseudoVFCVT_F_XU_V_M2 + 0U, // PseudoVFCVT_F_XU_V_M2_MASK + 0U, // PseudoVFCVT_F_XU_V_M4 + 0U, // PseudoVFCVT_F_XU_V_M4_MASK + 0U, // PseudoVFCVT_F_XU_V_M8 + 0U, // PseudoVFCVT_F_XU_V_M8_MASK + 0U, // PseudoVFCVT_F_XU_V_MF2 + 0U, // PseudoVFCVT_F_XU_V_MF2_MASK + 0U, // PseudoVFCVT_F_XU_V_MF4 + 0U, // PseudoVFCVT_F_XU_V_MF4_MASK + 0U, // PseudoVFCVT_F_X_V_M1 + 0U, // PseudoVFCVT_F_X_V_M1_MASK + 0U, // PseudoVFCVT_F_X_V_M2 + 0U, // PseudoVFCVT_F_X_V_M2_MASK + 0U, // PseudoVFCVT_F_X_V_M4 + 0U, // PseudoVFCVT_F_X_V_M4_MASK + 0U, // PseudoVFCVT_F_X_V_M8 + 0U, // PseudoVFCVT_F_X_V_M8_MASK + 0U, // PseudoVFCVT_F_X_V_MF2 + 0U, // PseudoVFCVT_F_X_V_MF2_MASK + 0U, // PseudoVFCVT_F_X_V_MF4 + 0U, // PseudoVFCVT_F_X_V_MF4_MASK + 0U, // PseudoVFCVT_RM_F_XU_V_M1 + 0U, // PseudoVFCVT_RM_F_XU_V_M1_MASK + 0U, // PseudoVFCVT_RM_F_XU_V_M2 + 0U, // PseudoVFCVT_RM_F_XU_V_M2_MASK + 0U, // PseudoVFCVT_RM_F_XU_V_M4 + 0U, // PseudoVFCVT_RM_F_XU_V_M4_MASK + 0U, // PseudoVFCVT_RM_F_XU_V_M8 + 0U, // PseudoVFCVT_RM_F_XU_V_M8_MASK + 0U, // PseudoVFCVT_RM_F_XU_V_MF2 + 0U, // PseudoVFCVT_RM_F_XU_V_MF2_MASK + 0U, // PseudoVFCVT_RM_F_XU_V_MF4 + 0U, // PseudoVFCVT_RM_F_XU_V_MF4_MASK + 0U, // PseudoVFCVT_RM_F_X_V_M1 + 0U, // PseudoVFCVT_RM_F_X_V_M1_MASK + 0U, // PseudoVFCVT_RM_F_X_V_M2 + 0U, // PseudoVFCVT_RM_F_X_V_M2_MASK + 0U, // PseudoVFCVT_RM_F_X_V_M4 + 0U, // PseudoVFCVT_RM_F_X_V_M4_MASK + 0U, // PseudoVFCVT_RM_F_X_V_M8 + 0U, // PseudoVFCVT_RM_F_X_V_M8_MASK + 0U, // PseudoVFCVT_RM_F_X_V_MF2 + 0U, // PseudoVFCVT_RM_F_X_V_MF2_MASK + 0U, // PseudoVFCVT_RM_F_X_V_MF4 + 0U, // PseudoVFCVT_RM_F_X_V_MF4_MASK + 0U, // PseudoVFCVT_RM_XU_F_V_M1 + 0U, // PseudoVFCVT_RM_XU_F_V_M1_MASK + 0U, // PseudoVFCVT_RM_XU_F_V_M2 + 0U, // PseudoVFCVT_RM_XU_F_V_M2_MASK + 0U, // PseudoVFCVT_RM_XU_F_V_M4 + 0U, // PseudoVFCVT_RM_XU_F_V_M4_MASK + 0U, // PseudoVFCVT_RM_XU_F_V_M8 + 0U, // PseudoVFCVT_RM_XU_F_V_M8_MASK + 0U, // PseudoVFCVT_RM_XU_F_V_MF2 + 0U, // PseudoVFCVT_RM_XU_F_V_MF2_MASK + 0U, // PseudoVFCVT_RM_XU_F_V_MF4 + 0U, // PseudoVFCVT_RM_XU_F_V_MF4_MASK + 0U, // PseudoVFCVT_RM_X_F_V_M1 + 0U, // PseudoVFCVT_RM_X_F_V_M1_MASK + 0U, // PseudoVFCVT_RM_X_F_V_M2 + 0U, // PseudoVFCVT_RM_X_F_V_M2_MASK + 0U, // PseudoVFCVT_RM_X_F_V_M4 + 0U, // PseudoVFCVT_RM_X_F_V_M4_MASK + 0U, // PseudoVFCVT_RM_X_F_V_M8 + 0U, // PseudoVFCVT_RM_X_F_V_M8_MASK + 0U, // PseudoVFCVT_RM_X_F_V_MF2 + 0U, // PseudoVFCVT_RM_X_F_V_MF2_MASK + 0U, // PseudoVFCVT_RM_X_F_V_MF4 + 0U, // PseudoVFCVT_RM_X_F_V_MF4_MASK + 0U, // PseudoVFCVT_RTZ_XU_F_V_M1 + 0U, // PseudoVFCVT_RTZ_XU_F_V_M1_MASK + 0U, // PseudoVFCVT_RTZ_XU_F_V_M2 + 0U, // PseudoVFCVT_RTZ_XU_F_V_M2_MASK + 0U, // PseudoVFCVT_RTZ_XU_F_V_M4 + 0U, // PseudoVFCVT_RTZ_XU_F_V_M4_MASK + 0U, // PseudoVFCVT_RTZ_XU_F_V_M8 + 0U, // PseudoVFCVT_RTZ_XU_F_V_M8_MASK + 0U, // PseudoVFCVT_RTZ_XU_F_V_MF2 + 0U, // PseudoVFCVT_RTZ_XU_F_V_MF2_MASK + 0U, // PseudoVFCVT_RTZ_XU_F_V_MF4 + 0U, // PseudoVFCVT_RTZ_XU_F_V_MF4_MASK + 0U, // PseudoVFCVT_RTZ_X_F_V_M1 + 0U, // PseudoVFCVT_RTZ_X_F_V_M1_MASK + 0U, // PseudoVFCVT_RTZ_X_F_V_M2 + 0U, // PseudoVFCVT_RTZ_X_F_V_M2_MASK + 0U, // PseudoVFCVT_RTZ_X_F_V_M4 + 0U, // PseudoVFCVT_RTZ_X_F_V_M4_MASK + 0U, // PseudoVFCVT_RTZ_X_F_V_M8 + 0U, // PseudoVFCVT_RTZ_X_F_V_M8_MASK + 0U, // PseudoVFCVT_RTZ_X_F_V_MF2 + 0U, // PseudoVFCVT_RTZ_X_F_V_MF2_MASK + 0U, // PseudoVFCVT_RTZ_X_F_V_MF4 + 0U, // PseudoVFCVT_RTZ_X_F_V_MF4_MASK + 0U, // PseudoVFCVT_XU_F_V_M1 + 0U, // PseudoVFCVT_XU_F_V_M1_MASK + 0U, // PseudoVFCVT_XU_F_V_M2 + 0U, // PseudoVFCVT_XU_F_V_M2_MASK + 0U, // PseudoVFCVT_XU_F_V_M4 + 0U, // PseudoVFCVT_XU_F_V_M4_MASK + 0U, // PseudoVFCVT_XU_F_V_M8 + 0U, // PseudoVFCVT_XU_F_V_M8_MASK + 0U, // PseudoVFCVT_XU_F_V_MF2 + 0U, // PseudoVFCVT_XU_F_V_MF2_MASK + 0U, // PseudoVFCVT_XU_F_V_MF4 + 0U, // PseudoVFCVT_XU_F_V_MF4_MASK + 0U, // PseudoVFCVT_X_F_V_M1 + 0U, // PseudoVFCVT_X_F_V_M1_MASK + 0U, // PseudoVFCVT_X_F_V_M2 + 0U, // PseudoVFCVT_X_F_V_M2_MASK + 0U, // PseudoVFCVT_X_F_V_M4 + 0U, // PseudoVFCVT_X_F_V_M4_MASK + 0U, // PseudoVFCVT_X_F_V_M8 + 0U, // PseudoVFCVT_X_F_V_M8_MASK + 0U, // PseudoVFCVT_X_F_V_MF2 + 0U, // PseudoVFCVT_X_F_V_MF2_MASK + 0U, // PseudoVFCVT_X_F_V_MF4 + 0U, // PseudoVFCVT_X_F_V_MF4_MASK + 0U, // PseudoVFDIV_VFPR16_M1_E16 + 0U, // PseudoVFDIV_VFPR16_M1_E16_MASK + 0U, // PseudoVFDIV_VFPR16_M2_E16 + 0U, // PseudoVFDIV_VFPR16_M2_E16_MASK + 0U, // PseudoVFDIV_VFPR16_M4_E16 + 0U, // PseudoVFDIV_VFPR16_M4_E16_MASK + 0U, // PseudoVFDIV_VFPR16_M8_E16 + 0U, // PseudoVFDIV_VFPR16_M8_E16_MASK + 0U, // PseudoVFDIV_VFPR16_MF2_E16 + 0U, // PseudoVFDIV_VFPR16_MF2_E16_MASK + 0U, // PseudoVFDIV_VFPR16_MF4_E16 + 0U, // PseudoVFDIV_VFPR16_MF4_E16_MASK + 0U, // PseudoVFDIV_VFPR32_M1_E32 + 0U, // PseudoVFDIV_VFPR32_M1_E32_MASK + 0U, // PseudoVFDIV_VFPR32_M2_E32 + 0U, // PseudoVFDIV_VFPR32_M2_E32_MASK + 0U, // PseudoVFDIV_VFPR32_M4_E32 + 0U, // PseudoVFDIV_VFPR32_M4_E32_MASK + 0U, // PseudoVFDIV_VFPR32_M8_E32 + 0U, // PseudoVFDIV_VFPR32_M8_E32_MASK + 0U, // PseudoVFDIV_VFPR32_MF2_E32 + 0U, // PseudoVFDIV_VFPR32_MF2_E32_MASK + 0U, // PseudoVFDIV_VFPR64_M1_E64 + 0U, // PseudoVFDIV_VFPR64_M1_E64_MASK + 0U, // PseudoVFDIV_VFPR64_M2_E64 + 0U, // PseudoVFDIV_VFPR64_M2_E64_MASK + 0U, // PseudoVFDIV_VFPR64_M4_E64 + 0U, // PseudoVFDIV_VFPR64_M4_E64_MASK + 0U, // PseudoVFDIV_VFPR64_M8_E64 + 0U, // PseudoVFDIV_VFPR64_M8_E64_MASK + 0U, // PseudoVFDIV_VV_M1_E16 + 0U, // PseudoVFDIV_VV_M1_E16_MASK + 0U, // PseudoVFDIV_VV_M1_E32 + 0U, // PseudoVFDIV_VV_M1_E32_MASK + 0U, // PseudoVFDIV_VV_M1_E64 + 0U, // PseudoVFDIV_VV_M1_E64_MASK + 0U, // PseudoVFDIV_VV_M2_E16 + 0U, // PseudoVFDIV_VV_M2_E16_MASK + 0U, // PseudoVFDIV_VV_M2_E32 + 0U, // PseudoVFDIV_VV_M2_E32_MASK + 0U, // PseudoVFDIV_VV_M2_E64 + 0U, // PseudoVFDIV_VV_M2_E64_MASK + 0U, // PseudoVFDIV_VV_M4_E16 + 0U, // PseudoVFDIV_VV_M4_E16_MASK + 0U, // PseudoVFDIV_VV_M4_E32 + 0U, // PseudoVFDIV_VV_M4_E32_MASK + 0U, // PseudoVFDIV_VV_M4_E64 + 0U, // PseudoVFDIV_VV_M4_E64_MASK + 0U, // PseudoVFDIV_VV_M8_E16 + 0U, // PseudoVFDIV_VV_M8_E16_MASK + 0U, // PseudoVFDIV_VV_M8_E32 + 0U, // PseudoVFDIV_VV_M8_E32_MASK + 0U, // PseudoVFDIV_VV_M8_E64 + 0U, // PseudoVFDIV_VV_M8_E64_MASK + 0U, // PseudoVFDIV_VV_MF2_E16 + 0U, // PseudoVFDIV_VV_MF2_E16_MASK + 0U, // PseudoVFDIV_VV_MF2_E32 + 0U, // PseudoVFDIV_VV_MF2_E32_MASK + 0U, // PseudoVFDIV_VV_MF4_E16 + 0U, // PseudoVFDIV_VV_MF4_E16_MASK + 0U, // PseudoVFIRST_M_B1 + 0U, // PseudoVFIRST_M_B16 + 0U, // PseudoVFIRST_M_B16_MASK + 0U, // PseudoVFIRST_M_B1_MASK + 0U, // PseudoVFIRST_M_B2 + 0U, // PseudoVFIRST_M_B2_MASK + 0U, // PseudoVFIRST_M_B32 + 0U, // PseudoVFIRST_M_B32_MASK + 0U, // PseudoVFIRST_M_B4 + 0U, // PseudoVFIRST_M_B4_MASK + 0U, // PseudoVFIRST_M_B64 + 0U, // PseudoVFIRST_M_B64_MASK + 0U, // PseudoVFIRST_M_B8 + 0U, // PseudoVFIRST_M_B8_MASK + 0U, // PseudoVFMACC_VFPR16_M1 + 0U, // PseudoVFMACC_VFPR16_M1_MASK + 0U, // PseudoVFMACC_VFPR16_M2 + 0U, // PseudoVFMACC_VFPR16_M2_MASK + 0U, // PseudoVFMACC_VFPR16_M4 + 0U, // PseudoVFMACC_VFPR16_M4_MASK + 0U, // PseudoVFMACC_VFPR16_M8 + 0U, // PseudoVFMACC_VFPR16_M8_MASK + 0U, // PseudoVFMACC_VFPR16_MF2 + 0U, // PseudoVFMACC_VFPR16_MF2_MASK + 0U, // PseudoVFMACC_VFPR16_MF4 + 0U, // PseudoVFMACC_VFPR16_MF4_MASK + 0U, // PseudoVFMACC_VFPR32_M1 + 0U, // PseudoVFMACC_VFPR32_M1_MASK + 0U, // PseudoVFMACC_VFPR32_M2 + 0U, // PseudoVFMACC_VFPR32_M2_MASK + 0U, // PseudoVFMACC_VFPR32_M4 + 0U, // PseudoVFMACC_VFPR32_M4_MASK + 0U, // PseudoVFMACC_VFPR32_M8 + 0U, // PseudoVFMACC_VFPR32_M8_MASK + 0U, // PseudoVFMACC_VFPR32_MF2 + 0U, // PseudoVFMACC_VFPR32_MF2_MASK + 0U, // PseudoVFMACC_VFPR64_M1 + 0U, // PseudoVFMACC_VFPR64_M1_MASK + 0U, // PseudoVFMACC_VFPR64_M2 + 0U, // PseudoVFMACC_VFPR64_M2_MASK + 0U, // PseudoVFMACC_VFPR64_M4 + 0U, // PseudoVFMACC_VFPR64_M4_MASK + 0U, // PseudoVFMACC_VFPR64_M8 + 0U, // PseudoVFMACC_VFPR64_M8_MASK + 0U, // PseudoVFMACC_VV_M1 + 0U, // PseudoVFMACC_VV_M1_MASK + 0U, // PseudoVFMACC_VV_M2 + 0U, // PseudoVFMACC_VV_M2_MASK + 0U, // PseudoVFMACC_VV_M4 + 0U, // PseudoVFMACC_VV_M4_MASK + 0U, // PseudoVFMACC_VV_M8 + 0U, // PseudoVFMACC_VV_M8_MASK + 0U, // PseudoVFMACC_VV_MF2 + 0U, // PseudoVFMACC_VV_MF2_MASK + 0U, // PseudoVFMACC_VV_MF4 + 0U, // PseudoVFMACC_VV_MF4_MASK + 0U, // PseudoVFMADD_VFPR16_M1 + 0U, // PseudoVFMADD_VFPR16_M1_MASK + 0U, // PseudoVFMADD_VFPR16_M2 + 0U, // PseudoVFMADD_VFPR16_M2_MASK + 0U, // PseudoVFMADD_VFPR16_M4 + 0U, // PseudoVFMADD_VFPR16_M4_MASK + 0U, // PseudoVFMADD_VFPR16_M8 + 0U, // PseudoVFMADD_VFPR16_M8_MASK + 0U, // PseudoVFMADD_VFPR16_MF2 + 0U, // PseudoVFMADD_VFPR16_MF2_MASK + 0U, // PseudoVFMADD_VFPR16_MF4 + 0U, // PseudoVFMADD_VFPR16_MF4_MASK + 0U, // PseudoVFMADD_VFPR32_M1 + 0U, // PseudoVFMADD_VFPR32_M1_MASK + 0U, // PseudoVFMADD_VFPR32_M2 + 0U, // PseudoVFMADD_VFPR32_M2_MASK + 0U, // PseudoVFMADD_VFPR32_M4 + 0U, // PseudoVFMADD_VFPR32_M4_MASK + 0U, // PseudoVFMADD_VFPR32_M8 + 0U, // PseudoVFMADD_VFPR32_M8_MASK + 0U, // PseudoVFMADD_VFPR32_MF2 + 0U, // PseudoVFMADD_VFPR32_MF2_MASK + 0U, // PseudoVFMADD_VFPR64_M1 + 0U, // PseudoVFMADD_VFPR64_M1_MASK + 0U, // PseudoVFMADD_VFPR64_M2 + 0U, // PseudoVFMADD_VFPR64_M2_MASK + 0U, // PseudoVFMADD_VFPR64_M4 + 0U, // PseudoVFMADD_VFPR64_M4_MASK + 0U, // PseudoVFMADD_VFPR64_M8 + 0U, // PseudoVFMADD_VFPR64_M8_MASK + 0U, // PseudoVFMADD_VV_M1 + 0U, // PseudoVFMADD_VV_M1_MASK + 0U, // PseudoVFMADD_VV_M2 + 0U, // PseudoVFMADD_VV_M2_MASK + 0U, // PseudoVFMADD_VV_M4 + 0U, // PseudoVFMADD_VV_M4_MASK + 0U, // PseudoVFMADD_VV_M8 + 0U, // PseudoVFMADD_VV_M8_MASK + 0U, // PseudoVFMADD_VV_MF2 + 0U, // PseudoVFMADD_VV_MF2_MASK + 0U, // PseudoVFMADD_VV_MF4 + 0U, // PseudoVFMADD_VV_MF4_MASK + 0U, // PseudoVFMAX_VFPR16_M1 + 0U, // PseudoVFMAX_VFPR16_M1_MASK + 0U, // PseudoVFMAX_VFPR16_M2 + 0U, // PseudoVFMAX_VFPR16_M2_MASK + 0U, // PseudoVFMAX_VFPR16_M4 + 0U, // PseudoVFMAX_VFPR16_M4_MASK + 0U, // PseudoVFMAX_VFPR16_M8 + 0U, // PseudoVFMAX_VFPR16_M8_MASK + 0U, // PseudoVFMAX_VFPR16_MF2 + 0U, // PseudoVFMAX_VFPR16_MF2_MASK + 0U, // PseudoVFMAX_VFPR16_MF4 + 0U, // PseudoVFMAX_VFPR16_MF4_MASK + 0U, // PseudoVFMAX_VFPR32_M1 + 0U, // PseudoVFMAX_VFPR32_M1_MASK + 0U, // PseudoVFMAX_VFPR32_M2 + 0U, // PseudoVFMAX_VFPR32_M2_MASK + 0U, // PseudoVFMAX_VFPR32_M4 + 0U, // PseudoVFMAX_VFPR32_M4_MASK + 0U, // PseudoVFMAX_VFPR32_M8 + 0U, // PseudoVFMAX_VFPR32_M8_MASK + 0U, // PseudoVFMAX_VFPR32_MF2 + 0U, // PseudoVFMAX_VFPR32_MF2_MASK + 0U, // PseudoVFMAX_VFPR64_M1 + 0U, // PseudoVFMAX_VFPR64_M1_MASK + 0U, // PseudoVFMAX_VFPR64_M2 + 0U, // PseudoVFMAX_VFPR64_M2_MASK + 0U, // PseudoVFMAX_VFPR64_M4 + 0U, // PseudoVFMAX_VFPR64_M4_MASK + 0U, // PseudoVFMAX_VFPR64_M8 + 0U, // PseudoVFMAX_VFPR64_M8_MASK + 0U, // PseudoVFMAX_VV_M1 + 0U, // PseudoVFMAX_VV_M1_MASK + 0U, // PseudoVFMAX_VV_M2 + 0U, // PseudoVFMAX_VV_M2_MASK + 0U, // PseudoVFMAX_VV_M4 + 0U, // PseudoVFMAX_VV_M4_MASK + 0U, // PseudoVFMAX_VV_M8 + 0U, // PseudoVFMAX_VV_M8_MASK + 0U, // PseudoVFMAX_VV_MF2 + 0U, // PseudoVFMAX_VV_MF2_MASK + 0U, // PseudoVFMAX_VV_MF4 + 0U, // PseudoVFMAX_VV_MF4_MASK + 0U, // PseudoVFMERGE_VFPR16M_M1 + 0U, // PseudoVFMERGE_VFPR16M_M2 + 0U, // PseudoVFMERGE_VFPR16M_M4 + 0U, // PseudoVFMERGE_VFPR16M_M8 + 0U, // PseudoVFMERGE_VFPR16M_MF2 + 0U, // PseudoVFMERGE_VFPR16M_MF4 + 0U, // PseudoVFMERGE_VFPR32M_M1 + 0U, // PseudoVFMERGE_VFPR32M_M2 + 0U, // PseudoVFMERGE_VFPR32M_M4 + 0U, // PseudoVFMERGE_VFPR32M_M8 + 0U, // PseudoVFMERGE_VFPR32M_MF2 + 0U, // PseudoVFMERGE_VFPR64M_M1 + 0U, // PseudoVFMERGE_VFPR64M_M2 + 0U, // PseudoVFMERGE_VFPR64M_M4 + 0U, // PseudoVFMERGE_VFPR64M_M8 + 0U, // PseudoVFMIN_VFPR16_M1 + 0U, // PseudoVFMIN_VFPR16_M1_MASK + 0U, // PseudoVFMIN_VFPR16_M2 + 0U, // PseudoVFMIN_VFPR16_M2_MASK + 0U, // PseudoVFMIN_VFPR16_M4 + 0U, // PseudoVFMIN_VFPR16_M4_MASK + 0U, // PseudoVFMIN_VFPR16_M8 + 0U, // PseudoVFMIN_VFPR16_M8_MASK + 0U, // PseudoVFMIN_VFPR16_MF2 + 0U, // PseudoVFMIN_VFPR16_MF2_MASK + 0U, // PseudoVFMIN_VFPR16_MF4 + 0U, // PseudoVFMIN_VFPR16_MF4_MASK + 0U, // PseudoVFMIN_VFPR32_M1 + 0U, // PseudoVFMIN_VFPR32_M1_MASK + 0U, // PseudoVFMIN_VFPR32_M2 + 0U, // PseudoVFMIN_VFPR32_M2_MASK + 0U, // PseudoVFMIN_VFPR32_M4 + 0U, // PseudoVFMIN_VFPR32_M4_MASK + 0U, // PseudoVFMIN_VFPR32_M8 + 0U, // PseudoVFMIN_VFPR32_M8_MASK + 0U, // PseudoVFMIN_VFPR32_MF2 + 0U, // PseudoVFMIN_VFPR32_MF2_MASK + 0U, // PseudoVFMIN_VFPR64_M1 + 0U, // PseudoVFMIN_VFPR64_M1_MASK + 0U, // PseudoVFMIN_VFPR64_M2 + 0U, // PseudoVFMIN_VFPR64_M2_MASK + 0U, // PseudoVFMIN_VFPR64_M4 + 0U, // PseudoVFMIN_VFPR64_M4_MASK + 0U, // PseudoVFMIN_VFPR64_M8 + 0U, // PseudoVFMIN_VFPR64_M8_MASK + 0U, // PseudoVFMIN_VV_M1 + 0U, // PseudoVFMIN_VV_M1_MASK + 0U, // PseudoVFMIN_VV_M2 + 0U, // PseudoVFMIN_VV_M2_MASK + 0U, // PseudoVFMIN_VV_M4 + 0U, // PseudoVFMIN_VV_M4_MASK + 0U, // PseudoVFMIN_VV_M8 + 0U, // PseudoVFMIN_VV_M8_MASK + 0U, // PseudoVFMIN_VV_MF2 + 0U, // PseudoVFMIN_VV_MF2_MASK + 0U, // PseudoVFMIN_VV_MF4 + 0U, // PseudoVFMIN_VV_MF4_MASK + 0U, // PseudoVFMSAC_VFPR16_M1 + 0U, // PseudoVFMSAC_VFPR16_M1_MASK + 0U, // PseudoVFMSAC_VFPR16_M2 + 0U, // PseudoVFMSAC_VFPR16_M2_MASK + 0U, // PseudoVFMSAC_VFPR16_M4 + 0U, // PseudoVFMSAC_VFPR16_M4_MASK + 0U, // PseudoVFMSAC_VFPR16_M8 + 0U, // PseudoVFMSAC_VFPR16_M8_MASK + 0U, // PseudoVFMSAC_VFPR16_MF2 + 0U, // PseudoVFMSAC_VFPR16_MF2_MASK + 0U, // PseudoVFMSAC_VFPR16_MF4 + 0U, // PseudoVFMSAC_VFPR16_MF4_MASK + 0U, // PseudoVFMSAC_VFPR32_M1 + 0U, // PseudoVFMSAC_VFPR32_M1_MASK + 0U, // PseudoVFMSAC_VFPR32_M2 + 0U, // PseudoVFMSAC_VFPR32_M2_MASK + 0U, // PseudoVFMSAC_VFPR32_M4 + 0U, // PseudoVFMSAC_VFPR32_M4_MASK + 0U, // PseudoVFMSAC_VFPR32_M8 + 0U, // PseudoVFMSAC_VFPR32_M8_MASK + 0U, // PseudoVFMSAC_VFPR32_MF2 + 0U, // PseudoVFMSAC_VFPR32_MF2_MASK + 0U, // PseudoVFMSAC_VFPR64_M1 + 0U, // PseudoVFMSAC_VFPR64_M1_MASK + 0U, // PseudoVFMSAC_VFPR64_M2 + 0U, // PseudoVFMSAC_VFPR64_M2_MASK + 0U, // PseudoVFMSAC_VFPR64_M4 + 0U, // PseudoVFMSAC_VFPR64_M4_MASK + 0U, // PseudoVFMSAC_VFPR64_M8 + 0U, // PseudoVFMSAC_VFPR64_M8_MASK + 0U, // PseudoVFMSAC_VV_M1 + 0U, // PseudoVFMSAC_VV_M1_MASK + 0U, // PseudoVFMSAC_VV_M2 + 0U, // PseudoVFMSAC_VV_M2_MASK + 0U, // PseudoVFMSAC_VV_M4 + 0U, // PseudoVFMSAC_VV_M4_MASK + 0U, // PseudoVFMSAC_VV_M8 + 0U, // PseudoVFMSAC_VV_M8_MASK + 0U, // PseudoVFMSAC_VV_MF2 + 0U, // PseudoVFMSAC_VV_MF2_MASK + 0U, // PseudoVFMSAC_VV_MF4 + 0U, // PseudoVFMSAC_VV_MF4_MASK + 0U, // PseudoVFMSUB_VFPR16_M1 + 0U, // PseudoVFMSUB_VFPR16_M1_MASK + 0U, // PseudoVFMSUB_VFPR16_M2 + 0U, // PseudoVFMSUB_VFPR16_M2_MASK + 0U, // PseudoVFMSUB_VFPR16_M4 + 0U, // PseudoVFMSUB_VFPR16_M4_MASK + 0U, // PseudoVFMSUB_VFPR16_M8 + 0U, // PseudoVFMSUB_VFPR16_M8_MASK + 0U, // PseudoVFMSUB_VFPR16_MF2 + 0U, // PseudoVFMSUB_VFPR16_MF2_MASK + 0U, // PseudoVFMSUB_VFPR16_MF4 + 0U, // PseudoVFMSUB_VFPR16_MF4_MASK + 0U, // PseudoVFMSUB_VFPR32_M1 + 0U, // PseudoVFMSUB_VFPR32_M1_MASK + 0U, // PseudoVFMSUB_VFPR32_M2 + 0U, // PseudoVFMSUB_VFPR32_M2_MASK + 0U, // PseudoVFMSUB_VFPR32_M4 + 0U, // PseudoVFMSUB_VFPR32_M4_MASK + 0U, // PseudoVFMSUB_VFPR32_M8 + 0U, // PseudoVFMSUB_VFPR32_M8_MASK + 0U, // PseudoVFMSUB_VFPR32_MF2 + 0U, // PseudoVFMSUB_VFPR32_MF2_MASK + 0U, // PseudoVFMSUB_VFPR64_M1 + 0U, // PseudoVFMSUB_VFPR64_M1_MASK + 0U, // PseudoVFMSUB_VFPR64_M2 + 0U, // PseudoVFMSUB_VFPR64_M2_MASK + 0U, // PseudoVFMSUB_VFPR64_M4 + 0U, // PseudoVFMSUB_VFPR64_M4_MASK + 0U, // PseudoVFMSUB_VFPR64_M8 + 0U, // PseudoVFMSUB_VFPR64_M8_MASK + 0U, // PseudoVFMSUB_VV_M1 + 0U, // PseudoVFMSUB_VV_M1_MASK + 0U, // PseudoVFMSUB_VV_M2 + 0U, // PseudoVFMSUB_VV_M2_MASK + 0U, // PseudoVFMSUB_VV_M4 + 0U, // PseudoVFMSUB_VV_M4_MASK + 0U, // PseudoVFMSUB_VV_M8 + 0U, // PseudoVFMSUB_VV_M8_MASK + 0U, // PseudoVFMSUB_VV_MF2 + 0U, // PseudoVFMSUB_VV_MF2_MASK + 0U, // PseudoVFMSUB_VV_MF4 + 0U, // PseudoVFMSUB_VV_MF4_MASK + 0U, // PseudoVFMUL_VFPR16_M1 + 0U, // PseudoVFMUL_VFPR16_M1_MASK + 0U, // PseudoVFMUL_VFPR16_M2 + 0U, // PseudoVFMUL_VFPR16_M2_MASK + 0U, // PseudoVFMUL_VFPR16_M4 + 0U, // PseudoVFMUL_VFPR16_M4_MASK + 0U, // PseudoVFMUL_VFPR16_M8 + 0U, // PseudoVFMUL_VFPR16_M8_MASK + 0U, // PseudoVFMUL_VFPR16_MF2 + 0U, // PseudoVFMUL_VFPR16_MF2_MASK + 0U, // PseudoVFMUL_VFPR16_MF4 + 0U, // PseudoVFMUL_VFPR16_MF4_MASK + 0U, // PseudoVFMUL_VFPR32_M1 + 0U, // PseudoVFMUL_VFPR32_M1_MASK + 0U, // PseudoVFMUL_VFPR32_M2 + 0U, // PseudoVFMUL_VFPR32_M2_MASK + 0U, // PseudoVFMUL_VFPR32_M4 + 0U, // PseudoVFMUL_VFPR32_M4_MASK + 0U, // PseudoVFMUL_VFPR32_M8 + 0U, // PseudoVFMUL_VFPR32_M8_MASK + 0U, // PseudoVFMUL_VFPR32_MF2 + 0U, // PseudoVFMUL_VFPR32_MF2_MASK + 0U, // PseudoVFMUL_VFPR64_M1 + 0U, // PseudoVFMUL_VFPR64_M1_MASK + 0U, // PseudoVFMUL_VFPR64_M2 + 0U, // PseudoVFMUL_VFPR64_M2_MASK + 0U, // PseudoVFMUL_VFPR64_M4 + 0U, // PseudoVFMUL_VFPR64_M4_MASK + 0U, // PseudoVFMUL_VFPR64_M8 + 0U, // PseudoVFMUL_VFPR64_M8_MASK + 0U, // PseudoVFMUL_VV_M1 + 0U, // PseudoVFMUL_VV_M1_MASK + 0U, // PseudoVFMUL_VV_M2 + 0U, // PseudoVFMUL_VV_M2_MASK + 0U, // PseudoVFMUL_VV_M4 + 0U, // PseudoVFMUL_VV_M4_MASK + 0U, // PseudoVFMUL_VV_M8 + 0U, // PseudoVFMUL_VV_M8_MASK + 0U, // PseudoVFMUL_VV_MF2 + 0U, // PseudoVFMUL_VV_MF2_MASK + 0U, // PseudoVFMUL_VV_MF4 + 0U, // PseudoVFMUL_VV_MF4_MASK + 0U, // PseudoVFMV_FPR16_S_M1 + 0U, // PseudoVFMV_FPR16_S_M2 + 0U, // PseudoVFMV_FPR16_S_M4 + 0U, // PseudoVFMV_FPR16_S_M8 + 0U, // PseudoVFMV_FPR16_S_MF2 + 0U, // PseudoVFMV_FPR16_S_MF4 + 0U, // PseudoVFMV_FPR32_S_M1 + 0U, // PseudoVFMV_FPR32_S_M2 + 0U, // PseudoVFMV_FPR32_S_M4 + 0U, // PseudoVFMV_FPR32_S_M8 + 0U, // PseudoVFMV_FPR32_S_MF2 + 0U, // PseudoVFMV_FPR64_S_M1 + 0U, // PseudoVFMV_FPR64_S_M2 + 0U, // PseudoVFMV_FPR64_S_M4 + 0U, // PseudoVFMV_FPR64_S_M8 + 0U, // PseudoVFMV_S_FPR16_M1 + 0U, // PseudoVFMV_S_FPR16_M2 + 0U, // PseudoVFMV_S_FPR16_M4 + 0U, // PseudoVFMV_S_FPR16_M8 + 0U, // PseudoVFMV_S_FPR16_MF2 + 0U, // PseudoVFMV_S_FPR16_MF4 + 0U, // PseudoVFMV_S_FPR32_M1 + 0U, // PseudoVFMV_S_FPR32_M2 + 0U, // PseudoVFMV_S_FPR32_M4 + 0U, // PseudoVFMV_S_FPR32_M8 + 0U, // PseudoVFMV_S_FPR32_MF2 + 0U, // PseudoVFMV_S_FPR64_M1 + 0U, // PseudoVFMV_S_FPR64_M2 + 0U, // PseudoVFMV_S_FPR64_M4 + 0U, // PseudoVFMV_S_FPR64_M8 + 0U, // PseudoVFMV_V_FPR16_M1 + 0U, // PseudoVFMV_V_FPR16_M2 + 0U, // PseudoVFMV_V_FPR16_M4 + 0U, // PseudoVFMV_V_FPR16_M8 + 0U, // PseudoVFMV_V_FPR16_MF2 + 0U, // PseudoVFMV_V_FPR16_MF4 + 0U, // PseudoVFMV_V_FPR32_M1 + 0U, // PseudoVFMV_V_FPR32_M2 + 0U, // PseudoVFMV_V_FPR32_M4 + 0U, // PseudoVFMV_V_FPR32_M8 + 0U, // PseudoVFMV_V_FPR32_MF2 + 0U, // PseudoVFMV_V_FPR64_M1 + 0U, // PseudoVFMV_V_FPR64_M2 + 0U, // PseudoVFMV_V_FPR64_M4 + 0U, // PseudoVFMV_V_FPR64_M8 + 0U, // PseudoVFNCVTBF16_F_F_W_M1 + 0U, // PseudoVFNCVTBF16_F_F_W_M1_MASK + 0U, // PseudoVFNCVTBF16_F_F_W_M2 + 0U, // PseudoVFNCVTBF16_F_F_W_M2_MASK + 0U, // PseudoVFNCVTBF16_F_F_W_M4 + 0U, // PseudoVFNCVTBF16_F_F_W_M4_MASK + 0U, // PseudoVFNCVTBF16_F_F_W_MF2 + 0U, // PseudoVFNCVTBF16_F_F_W_MF2_MASK + 0U, // PseudoVFNCVTBF16_F_F_W_MF4 + 0U, // PseudoVFNCVTBF16_F_F_W_MF4_MASK + 0U, // PseudoVFNCVT_F_F_W_M1 + 0U, // PseudoVFNCVT_F_F_W_M1_MASK + 0U, // PseudoVFNCVT_F_F_W_M2 + 0U, // PseudoVFNCVT_F_F_W_M2_MASK + 0U, // PseudoVFNCVT_F_F_W_M4 + 0U, // PseudoVFNCVT_F_F_W_M4_MASK + 0U, // PseudoVFNCVT_F_F_W_MF2 + 0U, // PseudoVFNCVT_F_F_W_MF2_MASK + 0U, // PseudoVFNCVT_F_F_W_MF4 + 0U, // PseudoVFNCVT_F_F_W_MF4_MASK + 0U, // PseudoVFNCVT_F_XU_W_M1 + 0U, // PseudoVFNCVT_F_XU_W_M1_MASK + 0U, // PseudoVFNCVT_F_XU_W_M2 + 0U, // PseudoVFNCVT_F_XU_W_M2_MASK + 0U, // PseudoVFNCVT_F_XU_W_M4 + 0U, // PseudoVFNCVT_F_XU_W_M4_MASK + 0U, // PseudoVFNCVT_F_XU_W_MF2 + 0U, // PseudoVFNCVT_F_XU_W_MF2_MASK + 0U, // PseudoVFNCVT_F_XU_W_MF4 + 0U, // PseudoVFNCVT_F_XU_W_MF4_MASK + 0U, // PseudoVFNCVT_F_X_W_M1 + 0U, // PseudoVFNCVT_F_X_W_M1_MASK + 0U, // PseudoVFNCVT_F_X_W_M2 + 0U, // PseudoVFNCVT_F_X_W_M2_MASK + 0U, // PseudoVFNCVT_F_X_W_M4 + 0U, // PseudoVFNCVT_F_X_W_M4_MASK + 0U, // PseudoVFNCVT_F_X_W_MF2 + 0U, // PseudoVFNCVT_F_X_W_MF2_MASK + 0U, // PseudoVFNCVT_F_X_W_MF4 + 0U, // PseudoVFNCVT_F_X_W_MF4_MASK + 0U, // PseudoVFNCVT_RM_F_XU_W_M1 + 0U, // PseudoVFNCVT_RM_F_XU_W_M1_MASK + 0U, // PseudoVFNCVT_RM_F_XU_W_M2 + 0U, // PseudoVFNCVT_RM_F_XU_W_M2_MASK + 0U, // PseudoVFNCVT_RM_F_XU_W_M4 + 0U, // PseudoVFNCVT_RM_F_XU_W_M4_MASK + 0U, // PseudoVFNCVT_RM_F_XU_W_MF2 + 0U, // PseudoVFNCVT_RM_F_XU_W_MF2_MASK + 0U, // PseudoVFNCVT_RM_F_XU_W_MF4 + 0U, // PseudoVFNCVT_RM_F_XU_W_MF4_MASK + 0U, // PseudoVFNCVT_RM_F_X_W_M1 + 0U, // PseudoVFNCVT_RM_F_X_W_M1_MASK + 0U, // PseudoVFNCVT_RM_F_X_W_M2 + 0U, // PseudoVFNCVT_RM_F_X_W_M2_MASK + 0U, // PseudoVFNCVT_RM_F_X_W_M4 + 0U, // PseudoVFNCVT_RM_F_X_W_M4_MASK + 0U, // PseudoVFNCVT_RM_F_X_W_MF2 + 0U, // PseudoVFNCVT_RM_F_X_W_MF2_MASK + 0U, // PseudoVFNCVT_RM_F_X_W_MF4 + 0U, // PseudoVFNCVT_RM_F_X_W_MF4_MASK + 0U, // PseudoVFNCVT_RM_XU_F_W_M1 + 0U, // PseudoVFNCVT_RM_XU_F_W_M1_MASK + 0U, // PseudoVFNCVT_RM_XU_F_W_M2 + 0U, // PseudoVFNCVT_RM_XU_F_W_M2_MASK + 0U, // PseudoVFNCVT_RM_XU_F_W_M4 + 0U, // PseudoVFNCVT_RM_XU_F_W_M4_MASK + 0U, // PseudoVFNCVT_RM_XU_F_W_MF2 + 0U, // PseudoVFNCVT_RM_XU_F_W_MF2_MASK + 0U, // PseudoVFNCVT_RM_XU_F_W_MF4 + 0U, // PseudoVFNCVT_RM_XU_F_W_MF4_MASK + 0U, // PseudoVFNCVT_RM_XU_F_W_MF8 + 0U, // PseudoVFNCVT_RM_XU_F_W_MF8_MASK + 0U, // PseudoVFNCVT_RM_X_F_W_M1 + 0U, // PseudoVFNCVT_RM_X_F_W_M1_MASK + 0U, // PseudoVFNCVT_RM_X_F_W_M2 + 0U, // PseudoVFNCVT_RM_X_F_W_M2_MASK + 0U, // PseudoVFNCVT_RM_X_F_W_M4 + 0U, // PseudoVFNCVT_RM_X_F_W_M4_MASK + 0U, // PseudoVFNCVT_RM_X_F_W_MF2 + 0U, // PseudoVFNCVT_RM_X_F_W_MF2_MASK + 0U, // PseudoVFNCVT_RM_X_F_W_MF4 + 0U, // PseudoVFNCVT_RM_X_F_W_MF4_MASK + 0U, // PseudoVFNCVT_RM_X_F_W_MF8 + 0U, // PseudoVFNCVT_RM_X_F_W_MF8_MASK + 0U, // PseudoVFNCVT_ROD_F_F_W_M1 + 0U, // PseudoVFNCVT_ROD_F_F_W_M1_MASK + 0U, // PseudoVFNCVT_ROD_F_F_W_M2 + 0U, // PseudoVFNCVT_ROD_F_F_W_M2_MASK + 0U, // PseudoVFNCVT_ROD_F_F_W_M4 + 0U, // PseudoVFNCVT_ROD_F_F_W_M4_MASK + 0U, // PseudoVFNCVT_ROD_F_F_W_MF2 + 0U, // PseudoVFNCVT_ROD_F_F_W_MF2_MASK + 0U, // PseudoVFNCVT_ROD_F_F_W_MF4 + 0U, // PseudoVFNCVT_ROD_F_F_W_MF4_MASK + 0U, // PseudoVFNCVT_RTZ_XU_F_W_M1 + 0U, // PseudoVFNCVT_RTZ_XU_F_W_M1_MASK + 0U, // PseudoVFNCVT_RTZ_XU_F_W_M2 + 0U, // PseudoVFNCVT_RTZ_XU_F_W_M2_MASK + 0U, // PseudoVFNCVT_RTZ_XU_F_W_M4 + 0U, // PseudoVFNCVT_RTZ_XU_F_W_M4_MASK + 0U, // PseudoVFNCVT_RTZ_XU_F_W_MF2 + 0U, // PseudoVFNCVT_RTZ_XU_F_W_MF2_MASK + 0U, // PseudoVFNCVT_RTZ_XU_F_W_MF4 + 0U, // PseudoVFNCVT_RTZ_XU_F_W_MF4_MASK + 0U, // PseudoVFNCVT_RTZ_XU_F_W_MF8 + 0U, // PseudoVFNCVT_RTZ_XU_F_W_MF8_MASK + 0U, // PseudoVFNCVT_RTZ_X_F_W_M1 + 0U, // PseudoVFNCVT_RTZ_X_F_W_M1_MASK + 0U, // PseudoVFNCVT_RTZ_X_F_W_M2 + 0U, // PseudoVFNCVT_RTZ_X_F_W_M2_MASK + 0U, // PseudoVFNCVT_RTZ_X_F_W_M4 + 0U, // PseudoVFNCVT_RTZ_X_F_W_M4_MASK + 0U, // PseudoVFNCVT_RTZ_X_F_W_MF2 + 0U, // PseudoVFNCVT_RTZ_X_F_W_MF2_MASK + 0U, // PseudoVFNCVT_RTZ_X_F_W_MF4 + 0U, // PseudoVFNCVT_RTZ_X_F_W_MF4_MASK + 0U, // PseudoVFNCVT_RTZ_X_F_W_MF8 + 0U, // PseudoVFNCVT_RTZ_X_F_W_MF8_MASK + 0U, // PseudoVFNCVT_XU_F_W_M1 + 0U, // PseudoVFNCVT_XU_F_W_M1_MASK + 0U, // PseudoVFNCVT_XU_F_W_M2 + 0U, // PseudoVFNCVT_XU_F_W_M2_MASK + 0U, // PseudoVFNCVT_XU_F_W_M4 + 0U, // PseudoVFNCVT_XU_F_W_M4_MASK + 0U, // PseudoVFNCVT_XU_F_W_MF2 + 0U, // PseudoVFNCVT_XU_F_W_MF2_MASK + 0U, // PseudoVFNCVT_XU_F_W_MF4 + 0U, // PseudoVFNCVT_XU_F_W_MF4_MASK + 0U, // PseudoVFNCVT_XU_F_W_MF8 + 0U, // PseudoVFNCVT_XU_F_W_MF8_MASK + 0U, // PseudoVFNCVT_X_F_W_M1 + 0U, // PseudoVFNCVT_X_F_W_M1_MASK + 0U, // PseudoVFNCVT_X_F_W_M2 + 0U, // PseudoVFNCVT_X_F_W_M2_MASK + 0U, // PseudoVFNCVT_X_F_W_M4 + 0U, // PseudoVFNCVT_X_F_W_M4_MASK + 0U, // PseudoVFNCVT_X_F_W_MF2 + 0U, // PseudoVFNCVT_X_F_W_MF2_MASK + 0U, // PseudoVFNCVT_X_F_W_MF4 + 0U, // PseudoVFNCVT_X_F_W_MF4_MASK + 0U, // PseudoVFNCVT_X_F_W_MF8 + 0U, // PseudoVFNCVT_X_F_W_MF8_MASK + 0U, // PseudoVFNMACC_VFPR16_M1 + 0U, // PseudoVFNMACC_VFPR16_M1_MASK + 0U, // PseudoVFNMACC_VFPR16_M2 + 0U, // PseudoVFNMACC_VFPR16_M2_MASK + 0U, // PseudoVFNMACC_VFPR16_M4 + 0U, // PseudoVFNMACC_VFPR16_M4_MASK + 0U, // PseudoVFNMACC_VFPR16_M8 + 0U, // PseudoVFNMACC_VFPR16_M8_MASK + 0U, // PseudoVFNMACC_VFPR16_MF2 + 0U, // PseudoVFNMACC_VFPR16_MF2_MASK + 0U, // PseudoVFNMACC_VFPR16_MF4 + 0U, // PseudoVFNMACC_VFPR16_MF4_MASK + 0U, // PseudoVFNMACC_VFPR32_M1 + 0U, // PseudoVFNMACC_VFPR32_M1_MASK + 0U, // PseudoVFNMACC_VFPR32_M2 + 0U, // PseudoVFNMACC_VFPR32_M2_MASK + 0U, // PseudoVFNMACC_VFPR32_M4 + 0U, // PseudoVFNMACC_VFPR32_M4_MASK + 0U, // PseudoVFNMACC_VFPR32_M8 + 0U, // PseudoVFNMACC_VFPR32_M8_MASK + 0U, // PseudoVFNMACC_VFPR32_MF2 + 0U, // PseudoVFNMACC_VFPR32_MF2_MASK + 0U, // PseudoVFNMACC_VFPR64_M1 + 0U, // PseudoVFNMACC_VFPR64_M1_MASK + 0U, // PseudoVFNMACC_VFPR64_M2 + 0U, // PseudoVFNMACC_VFPR64_M2_MASK + 0U, // PseudoVFNMACC_VFPR64_M4 + 0U, // PseudoVFNMACC_VFPR64_M4_MASK + 0U, // PseudoVFNMACC_VFPR64_M8 + 0U, // PseudoVFNMACC_VFPR64_M8_MASK + 0U, // PseudoVFNMACC_VV_M1 + 0U, // PseudoVFNMACC_VV_M1_MASK + 0U, // PseudoVFNMACC_VV_M2 + 0U, // PseudoVFNMACC_VV_M2_MASK + 0U, // PseudoVFNMACC_VV_M4 + 0U, // PseudoVFNMACC_VV_M4_MASK + 0U, // PseudoVFNMACC_VV_M8 + 0U, // PseudoVFNMACC_VV_M8_MASK + 0U, // PseudoVFNMACC_VV_MF2 + 0U, // PseudoVFNMACC_VV_MF2_MASK + 0U, // PseudoVFNMACC_VV_MF4 + 0U, // PseudoVFNMACC_VV_MF4_MASK + 0U, // PseudoVFNMADD_VFPR16_M1 + 0U, // PseudoVFNMADD_VFPR16_M1_MASK + 0U, // PseudoVFNMADD_VFPR16_M2 + 0U, // PseudoVFNMADD_VFPR16_M2_MASK + 0U, // PseudoVFNMADD_VFPR16_M4 + 0U, // PseudoVFNMADD_VFPR16_M4_MASK + 0U, // PseudoVFNMADD_VFPR16_M8 + 0U, // PseudoVFNMADD_VFPR16_M8_MASK + 0U, // PseudoVFNMADD_VFPR16_MF2 + 0U, // PseudoVFNMADD_VFPR16_MF2_MASK + 0U, // PseudoVFNMADD_VFPR16_MF4 + 0U, // PseudoVFNMADD_VFPR16_MF4_MASK + 0U, // PseudoVFNMADD_VFPR32_M1 + 0U, // PseudoVFNMADD_VFPR32_M1_MASK + 0U, // PseudoVFNMADD_VFPR32_M2 + 0U, // PseudoVFNMADD_VFPR32_M2_MASK + 0U, // PseudoVFNMADD_VFPR32_M4 + 0U, // PseudoVFNMADD_VFPR32_M4_MASK + 0U, // PseudoVFNMADD_VFPR32_M8 + 0U, // PseudoVFNMADD_VFPR32_M8_MASK + 0U, // PseudoVFNMADD_VFPR32_MF2 + 0U, // PseudoVFNMADD_VFPR32_MF2_MASK + 0U, // PseudoVFNMADD_VFPR64_M1 + 0U, // PseudoVFNMADD_VFPR64_M1_MASK + 0U, // PseudoVFNMADD_VFPR64_M2 + 0U, // PseudoVFNMADD_VFPR64_M2_MASK + 0U, // PseudoVFNMADD_VFPR64_M4 + 0U, // PseudoVFNMADD_VFPR64_M4_MASK + 0U, // PseudoVFNMADD_VFPR64_M8 + 0U, // PseudoVFNMADD_VFPR64_M8_MASK + 0U, // PseudoVFNMADD_VV_M1 + 0U, // PseudoVFNMADD_VV_M1_MASK + 0U, // PseudoVFNMADD_VV_M2 + 0U, // PseudoVFNMADD_VV_M2_MASK + 0U, // PseudoVFNMADD_VV_M4 + 0U, // PseudoVFNMADD_VV_M4_MASK + 0U, // PseudoVFNMADD_VV_M8 + 0U, // PseudoVFNMADD_VV_M8_MASK + 0U, // PseudoVFNMADD_VV_MF2 + 0U, // PseudoVFNMADD_VV_MF2_MASK + 0U, // PseudoVFNMADD_VV_MF4 + 0U, // PseudoVFNMADD_VV_MF4_MASK + 0U, // PseudoVFNMSAC_VFPR16_M1 + 0U, // PseudoVFNMSAC_VFPR16_M1_MASK + 0U, // PseudoVFNMSAC_VFPR16_M2 + 0U, // PseudoVFNMSAC_VFPR16_M2_MASK + 0U, // PseudoVFNMSAC_VFPR16_M4 + 0U, // PseudoVFNMSAC_VFPR16_M4_MASK + 0U, // PseudoVFNMSAC_VFPR16_M8 + 0U, // PseudoVFNMSAC_VFPR16_M8_MASK + 0U, // PseudoVFNMSAC_VFPR16_MF2 + 0U, // PseudoVFNMSAC_VFPR16_MF2_MASK + 0U, // PseudoVFNMSAC_VFPR16_MF4 + 0U, // PseudoVFNMSAC_VFPR16_MF4_MASK + 0U, // PseudoVFNMSAC_VFPR32_M1 + 0U, // PseudoVFNMSAC_VFPR32_M1_MASK + 0U, // PseudoVFNMSAC_VFPR32_M2 + 0U, // PseudoVFNMSAC_VFPR32_M2_MASK + 0U, // PseudoVFNMSAC_VFPR32_M4 + 0U, // PseudoVFNMSAC_VFPR32_M4_MASK + 0U, // PseudoVFNMSAC_VFPR32_M8 + 0U, // PseudoVFNMSAC_VFPR32_M8_MASK + 0U, // PseudoVFNMSAC_VFPR32_MF2 + 0U, // PseudoVFNMSAC_VFPR32_MF2_MASK + 0U, // PseudoVFNMSAC_VFPR64_M1 + 0U, // PseudoVFNMSAC_VFPR64_M1_MASK + 0U, // PseudoVFNMSAC_VFPR64_M2 + 0U, // PseudoVFNMSAC_VFPR64_M2_MASK + 0U, // PseudoVFNMSAC_VFPR64_M4 + 0U, // PseudoVFNMSAC_VFPR64_M4_MASK + 0U, // PseudoVFNMSAC_VFPR64_M8 + 0U, // PseudoVFNMSAC_VFPR64_M8_MASK + 0U, // PseudoVFNMSAC_VV_M1 + 0U, // PseudoVFNMSAC_VV_M1_MASK + 0U, // PseudoVFNMSAC_VV_M2 + 0U, // PseudoVFNMSAC_VV_M2_MASK + 0U, // PseudoVFNMSAC_VV_M4 + 0U, // PseudoVFNMSAC_VV_M4_MASK + 0U, // PseudoVFNMSAC_VV_M8 + 0U, // PseudoVFNMSAC_VV_M8_MASK + 0U, // PseudoVFNMSAC_VV_MF2 + 0U, // PseudoVFNMSAC_VV_MF2_MASK + 0U, // PseudoVFNMSAC_VV_MF4 + 0U, // PseudoVFNMSAC_VV_MF4_MASK + 0U, // PseudoVFNMSUB_VFPR16_M1 + 0U, // PseudoVFNMSUB_VFPR16_M1_MASK + 0U, // PseudoVFNMSUB_VFPR16_M2 + 0U, // PseudoVFNMSUB_VFPR16_M2_MASK + 0U, // PseudoVFNMSUB_VFPR16_M4 + 0U, // PseudoVFNMSUB_VFPR16_M4_MASK + 0U, // PseudoVFNMSUB_VFPR16_M8 + 0U, // PseudoVFNMSUB_VFPR16_M8_MASK + 0U, // PseudoVFNMSUB_VFPR16_MF2 + 0U, // PseudoVFNMSUB_VFPR16_MF2_MASK + 0U, // PseudoVFNMSUB_VFPR16_MF4 + 0U, // PseudoVFNMSUB_VFPR16_MF4_MASK + 0U, // PseudoVFNMSUB_VFPR32_M1 + 0U, // PseudoVFNMSUB_VFPR32_M1_MASK + 0U, // PseudoVFNMSUB_VFPR32_M2 + 0U, // PseudoVFNMSUB_VFPR32_M2_MASK + 0U, // PseudoVFNMSUB_VFPR32_M4 + 0U, // PseudoVFNMSUB_VFPR32_M4_MASK + 0U, // PseudoVFNMSUB_VFPR32_M8 + 0U, // PseudoVFNMSUB_VFPR32_M8_MASK + 0U, // PseudoVFNMSUB_VFPR32_MF2 + 0U, // PseudoVFNMSUB_VFPR32_MF2_MASK + 0U, // PseudoVFNMSUB_VFPR64_M1 + 0U, // PseudoVFNMSUB_VFPR64_M1_MASK + 0U, // PseudoVFNMSUB_VFPR64_M2 + 0U, // PseudoVFNMSUB_VFPR64_M2_MASK + 0U, // PseudoVFNMSUB_VFPR64_M4 + 0U, // PseudoVFNMSUB_VFPR64_M4_MASK + 0U, // PseudoVFNMSUB_VFPR64_M8 + 0U, // PseudoVFNMSUB_VFPR64_M8_MASK + 0U, // PseudoVFNMSUB_VV_M1 + 0U, // PseudoVFNMSUB_VV_M1_MASK + 0U, // PseudoVFNMSUB_VV_M2 + 0U, // PseudoVFNMSUB_VV_M2_MASK + 0U, // PseudoVFNMSUB_VV_M4 + 0U, // PseudoVFNMSUB_VV_M4_MASK + 0U, // PseudoVFNMSUB_VV_M8 + 0U, // PseudoVFNMSUB_VV_M8_MASK + 0U, // PseudoVFNMSUB_VV_MF2 + 0U, // PseudoVFNMSUB_VV_MF2_MASK + 0U, // PseudoVFNMSUB_VV_MF4 + 0U, // PseudoVFNMSUB_VV_MF4_MASK + 0U, // PseudoVFNRCLIP_XU_F_QF_M1 + 0U, // PseudoVFNRCLIP_XU_F_QF_M1_MASK + 0U, // PseudoVFNRCLIP_XU_F_QF_M2 + 0U, // PseudoVFNRCLIP_XU_F_QF_M2_MASK + 0U, // PseudoVFNRCLIP_XU_F_QF_MF2 + 0U, // PseudoVFNRCLIP_XU_F_QF_MF2_MASK + 0U, // PseudoVFNRCLIP_XU_F_QF_MF4 + 0U, // PseudoVFNRCLIP_XU_F_QF_MF4_MASK + 0U, // PseudoVFNRCLIP_XU_F_QF_MF8 + 0U, // PseudoVFNRCLIP_XU_F_QF_MF8_MASK + 0U, // PseudoVFNRCLIP_X_F_QF_M1 + 0U, // PseudoVFNRCLIP_X_F_QF_M1_MASK + 0U, // PseudoVFNRCLIP_X_F_QF_M2 + 0U, // PseudoVFNRCLIP_X_F_QF_M2_MASK + 0U, // PseudoVFNRCLIP_X_F_QF_MF2 + 0U, // PseudoVFNRCLIP_X_F_QF_MF2_MASK + 0U, // PseudoVFNRCLIP_X_F_QF_MF4 + 0U, // PseudoVFNRCLIP_X_F_QF_MF4_MASK + 0U, // PseudoVFNRCLIP_X_F_QF_MF8 + 0U, // PseudoVFNRCLIP_X_F_QF_MF8_MASK + 0U, // PseudoVFRDIV_VFPR16_M1_E16 + 0U, // PseudoVFRDIV_VFPR16_M1_E16_MASK + 0U, // PseudoVFRDIV_VFPR16_M2_E16 + 0U, // PseudoVFRDIV_VFPR16_M2_E16_MASK + 0U, // PseudoVFRDIV_VFPR16_M4_E16 + 0U, // PseudoVFRDIV_VFPR16_M4_E16_MASK + 0U, // PseudoVFRDIV_VFPR16_M8_E16 + 0U, // PseudoVFRDIV_VFPR16_M8_E16_MASK + 0U, // PseudoVFRDIV_VFPR16_MF2_E16 + 0U, // PseudoVFRDIV_VFPR16_MF2_E16_MASK + 0U, // PseudoVFRDIV_VFPR16_MF4_E16 + 0U, // PseudoVFRDIV_VFPR16_MF4_E16_MASK + 0U, // PseudoVFRDIV_VFPR32_M1_E32 + 0U, // PseudoVFRDIV_VFPR32_M1_E32_MASK + 0U, // PseudoVFRDIV_VFPR32_M2_E32 + 0U, // PseudoVFRDIV_VFPR32_M2_E32_MASK + 0U, // PseudoVFRDIV_VFPR32_M4_E32 + 0U, // PseudoVFRDIV_VFPR32_M4_E32_MASK + 0U, // PseudoVFRDIV_VFPR32_M8_E32 + 0U, // PseudoVFRDIV_VFPR32_M8_E32_MASK + 0U, // PseudoVFRDIV_VFPR32_MF2_E32 + 0U, // PseudoVFRDIV_VFPR32_MF2_E32_MASK + 0U, // PseudoVFRDIV_VFPR64_M1_E64 + 0U, // PseudoVFRDIV_VFPR64_M1_E64_MASK + 0U, // PseudoVFRDIV_VFPR64_M2_E64 + 0U, // PseudoVFRDIV_VFPR64_M2_E64_MASK + 0U, // PseudoVFRDIV_VFPR64_M4_E64 + 0U, // PseudoVFRDIV_VFPR64_M4_E64_MASK + 0U, // PseudoVFRDIV_VFPR64_M8_E64 + 0U, // PseudoVFRDIV_VFPR64_M8_E64_MASK + 0U, // PseudoVFREC7_V_M1 + 0U, // PseudoVFREC7_V_M1_MASK + 0U, // PseudoVFREC7_V_M2 + 0U, // PseudoVFREC7_V_M2_MASK + 0U, // PseudoVFREC7_V_M4 + 0U, // PseudoVFREC7_V_M4_MASK + 0U, // PseudoVFREC7_V_M8 + 0U, // PseudoVFREC7_V_M8_MASK + 0U, // PseudoVFREC7_V_MF2 + 0U, // PseudoVFREC7_V_MF2_MASK + 0U, // PseudoVFREC7_V_MF4 + 0U, // PseudoVFREC7_V_MF4_MASK + 0U, // PseudoVFREDMAX_VS_M1_E16 + 0U, // PseudoVFREDMAX_VS_M1_E16_MASK + 0U, // PseudoVFREDMAX_VS_M1_E32 + 0U, // PseudoVFREDMAX_VS_M1_E32_MASK + 0U, // PseudoVFREDMAX_VS_M1_E64 + 0U, // PseudoVFREDMAX_VS_M1_E64_MASK + 0U, // PseudoVFREDMAX_VS_M2_E16 + 0U, // PseudoVFREDMAX_VS_M2_E16_MASK + 0U, // PseudoVFREDMAX_VS_M2_E32 + 0U, // PseudoVFREDMAX_VS_M2_E32_MASK + 0U, // PseudoVFREDMAX_VS_M2_E64 + 0U, // PseudoVFREDMAX_VS_M2_E64_MASK + 0U, // PseudoVFREDMAX_VS_M4_E16 + 0U, // PseudoVFREDMAX_VS_M4_E16_MASK + 0U, // PseudoVFREDMAX_VS_M4_E32 + 0U, // PseudoVFREDMAX_VS_M4_E32_MASK + 0U, // PseudoVFREDMAX_VS_M4_E64 + 0U, // PseudoVFREDMAX_VS_M4_E64_MASK + 0U, // PseudoVFREDMAX_VS_M8_E16 + 0U, // PseudoVFREDMAX_VS_M8_E16_MASK + 0U, // PseudoVFREDMAX_VS_M8_E32 + 0U, // PseudoVFREDMAX_VS_M8_E32_MASK + 0U, // PseudoVFREDMAX_VS_M8_E64 + 0U, // PseudoVFREDMAX_VS_M8_E64_MASK + 0U, // PseudoVFREDMAX_VS_MF2_E16 + 0U, // PseudoVFREDMAX_VS_MF2_E16_MASK + 0U, // PseudoVFREDMAX_VS_MF2_E32 + 0U, // PseudoVFREDMAX_VS_MF2_E32_MASK + 0U, // PseudoVFREDMAX_VS_MF4_E16 + 0U, // PseudoVFREDMAX_VS_MF4_E16_MASK + 0U, // PseudoVFREDMIN_VS_M1_E16 + 0U, // PseudoVFREDMIN_VS_M1_E16_MASK + 0U, // PseudoVFREDMIN_VS_M1_E32 + 0U, // PseudoVFREDMIN_VS_M1_E32_MASK + 0U, // PseudoVFREDMIN_VS_M1_E64 + 0U, // PseudoVFREDMIN_VS_M1_E64_MASK + 0U, // PseudoVFREDMIN_VS_M2_E16 + 0U, // PseudoVFREDMIN_VS_M2_E16_MASK + 0U, // PseudoVFREDMIN_VS_M2_E32 + 0U, // PseudoVFREDMIN_VS_M2_E32_MASK + 0U, // PseudoVFREDMIN_VS_M2_E64 + 0U, // PseudoVFREDMIN_VS_M2_E64_MASK + 0U, // PseudoVFREDMIN_VS_M4_E16 + 0U, // PseudoVFREDMIN_VS_M4_E16_MASK + 0U, // PseudoVFREDMIN_VS_M4_E32 + 0U, // PseudoVFREDMIN_VS_M4_E32_MASK + 0U, // PseudoVFREDMIN_VS_M4_E64 + 0U, // PseudoVFREDMIN_VS_M4_E64_MASK + 0U, // PseudoVFREDMIN_VS_M8_E16 + 0U, // PseudoVFREDMIN_VS_M8_E16_MASK + 0U, // PseudoVFREDMIN_VS_M8_E32 + 0U, // PseudoVFREDMIN_VS_M8_E32_MASK + 0U, // PseudoVFREDMIN_VS_M8_E64 + 0U, // PseudoVFREDMIN_VS_M8_E64_MASK + 0U, // PseudoVFREDMIN_VS_MF2_E16 + 0U, // PseudoVFREDMIN_VS_MF2_E16_MASK + 0U, // PseudoVFREDMIN_VS_MF2_E32 + 0U, // PseudoVFREDMIN_VS_MF2_E32_MASK + 0U, // PseudoVFREDMIN_VS_MF4_E16 + 0U, // PseudoVFREDMIN_VS_MF4_E16_MASK + 0U, // PseudoVFREDOSUM_VS_M1_E16 + 0U, // PseudoVFREDOSUM_VS_M1_E16_MASK + 0U, // PseudoVFREDOSUM_VS_M1_E32 + 0U, // PseudoVFREDOSUM_VS_M1_E32_MASK + 0U, // PseudoVFREDOSUM_VS_M1_E64 + 0U, // PseudoVFREDOSUM_VS_M1_E64_MASK + 0U, // PseudoVFREDOSUM_VS_M2_E16 + 0U, // PseudoVFREDOSUM_VS_M2_E16_MASK + 0U, // PseudoVFREDOSUM_VS_M2_E32 + 0U, // PseudoVFREDOSUM_VS_M2_E32_MASK + 0U, // PseudoVFREDOSUM_VS_M2_E64 + 0U, // PseudoVFREDOSUM_VS_M2_E64_MASK + 0U, // PseudoVFREDOSUM_VS_M4_E16 + 0U, // PseudoVFREDOSUM_VS_M4_E16_MASK + 0U, // PseudoVFREDOSUM_VS_M4_E32 + 0U, // PseudoVFREDOSUM_VS_M4_E32_MASK + 0U, // PseudoVFREDOSUM_VS_M4_E64 + 0U, // PseudoVFREDOSUM_VS_M4_E64_MASK + 0U, // PseudoVFREDOSUM_VS_M8_E16 + 0U, // PseudoVFREDOSUM_VS_M8_E16_MASK + 0U, // PseudoVFREDOSUM_VS_M8_E32 + 0U, // PseudoVFREDOSUM_VS_M8_E32_MASK + 0U, // PseudoVFREDOSUM_VS_M8_E64 + 0U, // PseudoVFREDOSUM_VS_M8_E64_MASK + 0U, // PseudoVFREDOSUM_VS_MF2_E16 + 0U, // PseudoVFREDOSUM_VS_MF2_E16_MASK + 0U, // PseudoVFREDOSUM_VS_MF2_E32 + 0U, // PseudoVFREDOSUM_VS_MF2_E32_MASK + 0U, // PseudoVFREDOSUM_VS_MF4_E16 + 0U, // PseudoVFREDOSUM_VS_MF4_E16_MASK + 0U, // PseudoVFREDUSUM_VS_M1_E16 + 0U, // PseudoVFREDUSUM_VS_M1_E16_MASK + 0U, // PseudoVFREDUSUM_VS_M1_E32 + 0U, // PseudoVFREDUSUM_VS_M1_E32_MASK + 0U, // PseudoVFREDUSUM_VS_M1_E64 + 0U, // PseudoVFREDUSUM_VS_M1_E64_MASK + 0U, // PseudoVFREDUSUM_VS_M2_E16 + 0U, // PseudoVFREDUSUM_VS_M2_E16_MASK + 0U, // PseudoVFREDUSUM_VS_M2_E32 + 0U, // PseudoVFREDUSUM_VS_M2_E32_MASK + 0U, // PseudoVFREDUSUM_VS_M2_E64 + 0U, // PseudoVFREDUSUM_VS_M2_E64_MASK + 0U, // PseudoVFREDUSUM_VS_M4_E16 + 0U, // PseudoVFREDUSUM_VS_M4_E16_MASK + 0U, // PseudoVFREDUSUM_VS_M4_E32 + 0U, // PseudoVFREDUSUM_VS_M4_E32_MASK + 0U, // PseudoVFREDUSUM_VS_M4_E64 + 0U, // PseudoVFREDUSUM_VS_M4_E64_MASK + 0U, // PseudoVFREDUSUM_VS_M8_E16 + 0U, // PseudoVFREDUSUM_VS_M8_E16_MASK + 0U, // PseudoVFREDUSUM_VS_M8_E32 + 0U, // PseudoVFREDUSUM_VS_M8_E32_MASK + 0U, // PseudoVFREDUSUM_VS_M8_E64 + 0U, // PseudoVFREDUSUM_VS_M8_E64_MASK + 0U, // PseudoVFREDUSUM_VS_MF2_E16 + 0U, // PseudoVFREDUSUM_VS_MF2_E16_MASK + 0U, // PseudoVFREDUSUM_VS_MF2_E32 + 0U, // PseudoVFREDUSUM_VS_MF2_E32_MASK + 0U, // PseudoVFREDUSUM_VS_MF4_E16 + 0U, // PseudoVFREDUSUM_VS_MF4_E16_MASK + 0U, // PseudoVFROUND_NOEXCEPT_V_M1_MASK + 0U, // PseudoVFROUND_NOEXCEPT_V_M2_MASK + 0U, // PseudoVFROUND_NOEXCEPT_V_M4_MASK + 0U, // PseudoVFROUND_NOEXCEPT_V_M8_MASK + 0U, // PseudoVFROUND_NOEXCEPT_V_MF2_MASK + 0U, // PseudoVFROUND_NOEXCEPT_V_MF4_MASK + 0U, // PseudoVFRSQRT7_V_M1 + 0U, // PseudoVFRSQRT7_V_M1_MASK + 0U, // PseudoVFRSQRT7_V_M2 + 0U, // PseudoVFRSQRT7_V_M2_MASK + 0U, // PseudoVFRSQRT7_V_M4 + 0U, // PseudoVFRSQRT7_V_M4_MASK + 0U, // PseudoVFRSQRT7_V_M8 + 0U, // PseudoVFRSQRT7_V_M8_MASK + 0U, // PseudoVFRSQRT7_V_MF2 + 0U, // PseudoVFRSQRT7_V_MF2_MASK + 0U, // PseudoVFRSQRT7_V_MF4 + 0U, // PseudoVFRSQRT7_V_MF4_MASK + 0U, // PseudoVFRSUB_VFPR16_M1 + 0U, // PseudoVFRSUB_VFPR16_M1_MASK + 0U, // PseudoVFRSUB_VFPR16_M2 + 0U, // PseudoVFRSUB_VFPR16_M2_MASK + 0U, // PseudoVFRSUB_VFPR16_M4 + 0U, // PseudoVFRSUB_VFPR16_M4_MASK + 0U, // PseudoVFRSUB_VFPR16_M8 + 0U, // PseudoVFRSUB_VFPR16_M8_MASK + 0U, // PseudoVFRSUB_VFPR16_MF2 + 0U, // PseudoVFRSUB_VFPR16_MF2_MASK + 0U, // PseudoVFRSUB_VFPR16_MF4 + 0U, // PseudoVFRSUB_VFPR16_MF4_MASK + 0U, // PseudoVFRSUB_VFPR32_M1 + 0U, // PseudoVFRSUB_VFPR32_M1_MASK + 0U, // PseudoVFRSUB_VFPR32_M2 + 0U, // PseudoVFRSUB_VFPR32_M2_MASK + 0U, // PseudoVFRSUB_VFPR32_M4 + 0U, // PseudoVFRSUB_VFPR32_M4_MASK + 0U, // PseudoVFRSUB_VFPR32_M8 + 0U, // PseudoVFRSUB_VFPR32_M8_MASK + 0U, // PseudoVFRSUB_VFPR32_MF2 + 0U, // PseudoVFRSUB_VFPR32_MF2_MASK + 0U, // PseudoVFRSUB_VFPR64_M1 + 0U, // PseudoVFRSUB_VFPR64_M1_MASK + 0U, // PseudoVFRSUB_VFPR64_M2 + 0U, // PseudoVFRSUB_VFPR64_M2_MASK + 0U, // PseudoVFRSUB_VFPR64_M4 + 0U, // PseudoVFRSUB_VFPR64_M4_MASK + 0U, // PseudoVFRSUB_VFPR64_M8 + 0U, // PseudoVFRSUB_VFPR64_M8_MASK + 0U, // PseudoVFSGNJN_VFPR16_M1 + 0U, // PseudoVFSGNJN_VFPR16_M1_MASK + 0U, // PseudoVFSGNJN_VFPR16_M2 + 0U, // PseudoVFSGNJN_VFPR16_M2_MASK + 0U, // PseudoVFSGNJN_VFPR16_M4 + 0U, // PseudoVFSGNJN_VFPR16_M4_MASK + 0U, // PseudoVFSGNJN_VFPR16_M8 + 0U, // PseudoVFSGNJN_VFPR16_M8_MASK + 0U, // PseudoVFSGNJN_VFPR16_MF2 + 0U, // PseudoVFSGNJN_VFPR16_MF2_MASK + 0U, // PseudoVFSGNJN_VFPR16_MF4 + 0U, // PseudoVFSGNJN_VFPR16_MF4_MASK + 0U, // PseudoVFSGNJN_VFPR32_M1 + 0U, // PseudoVFSGNJN_VFPR32_M1_MASK + 0U, // PseudoVFSGNJN_VFPR32_M2 + 0U, // PseudoVFSGNJN_VFPR32_M2_MASK + 0U, // PseudoVFSGNJN_VFPR32_M4 + 0U, // PseudoVFSGNJN_VFPR32_M4_MASK + 0U, // PseudoVFSGNJN_VFPR32_M8 + 0U, // PseudoVFSGNJN_VFPR32_M8_MASK + 0U, // PseudoVFSGNJN_VFPR32_MF2 + 0U, // PseudoVFSGNJN_VFPR32_MF2_MASK + 0U, // PseudoVFSGNJN_VFPR64_M1 + 0U, // PseudoVFSGNJN_VFPR64_M1_MASK + 0U, // PseudoVFSGNJN_VFPR64_M2 + 0U, // PseudoVFSGNJN_VFPR64_M2_MASK + 0U, // PseudoVFSGNJN_VFPR64_M4 + 0U, // PseudoVFSGNJN_VFPR64_M4_MASK + 0U, // PseudoVFSGNJN_VFPR64_M8 + 0U, // PseudoVFSGNJN_VFPR64_M8_MASK + 0U, // PseudoVFSGNJN_VV_M1 + 0U, // PseudoVFSGNJN_VV_M1_MASK + 0U, // PseudoVFSGNJN_VV_M2 + 0U, // PseudoVFSGNJN_VV_M2_MASK + 0U, // PseudoVFSGNJN_VV_M4 + 0U, // PseudoVFSGNJN_VV_M4_MASK + 0U, // PseudoVFSGNJN_VV_M8 + 0U, // PseudoVFSGNJN_VV_M8_MASK + 0U, // PseudoVFSGNJN_VV_MF2 + 0U, // PseudoVFSGNJN_VV_MF2_MASK + 0U, // PseudoVFSGNJN_VV_MF4 + 0U, // PseudoVFSGNJN_VV_MF4_MASK + 0U, // PseudoVFSGNJX_VFPR16_M1 + 0U, // PseudoVFSGNJX_VFPR16_M1_MASK + 0U, // PseudoVFSGNJX_VFPR16_M2 + 0U, // PseudoVFSGNJX_VFPR16_M2_MASK + 0U, // PseudoVFSGNJX_VFPR16_M4 + 0U, // PseudoVFSGNJX_VFPR16_M4_MASK + 0U, // PseudoVFSGNJX_VFPR16_M8 + 0U, // PseudoVFSGNJX_VFPR16_M8_MASK + 0U, // PseudoVFSGNJX_VFPR16_MF2 + 0U, // PseudoVFSGNJX_VFPR16_MF2_MASK + 0U, // PseudoVFSGNJX_VFPR16_MF4 + 0U, // PseudoVFSGNJX_VFPR16_MF4_MASK + 0U, // PseudoVFSGNJX_VFPR32_M1 + 0U, // PseudoVFSGNJX_VFPR32_M1_MASK + 0U, // PseudoVFSGNJX_VFPR32_M2 + 0U, // PseudoVFSGNJX_VFPR32_M2_MASK + 0U, // PseudoVFSGNJX_VFPR32_M4 + 0U, // PseudoVFSGNJX_VFPR32_M4_MASK + 0U, // PseudoVFSGNJX_VFPR32_M8 + 0U, // PseudoVFSGNJX_VFPR32_M8_MASK + 0U, // PseudoVFSGNJX_VFPR32_MF2 + 0U, // PseudoVFSGNJX_VFPR32_MF2_MASK + 0U, // PseudoVFSGNJX_VFPR64_M1 + 0U, // PseudoVFSGNJX_VFPR64_M1_MASK + 0U, // PseudoVFSGNJX_VFPR64_M2 + 0U, // PseudoVFSGNJX_VFPR64_M2_MASK + 0U, // PseudoVFSGNJX_VFPR64_M4 + 0U, // PseudoVFSGNJX_VFPR64_M4_MASK + 0U, // PseudoVFSGNJX_VFPR64_M8 + 0U, // PseudoVFSGNJX_VFPR64_M8_MASK + 0U, // PseudoVFSGNJX_VV_M1 + 0U, // PseudoVFSGNJX_VV_M1_MASK + 0U, // PseudoVFSGNJX_VV_M2 + 0U, // PseudoVFSGNJX_VV_M2_MASK + 0U, // PseudoVFSGNJX_VV_M4 + 0U, // PseudoVFSGNJX_VV_M4_MASK + 0U, // PseudoVFSGNJX_VV_M8 + 0U, // PseudoVFSGNJX_VV_M8_MASK + 0U, // PseudoVFSGNJX_VV_MF2 + 0U, // PseudoVFSGNJX_VV_MF2_MASK + 0U, // PseudoVFSGNJX_VV_MF4 + 0U, // PseudoVFSGNJX_VV_MF4_MASK + 0U, // PseudoVFSGNJ_VFPR16_M1 + 0U, // PseudoVFSGNJ_VFPR16_M1_MASK + 0U, // PseudoVFSGNJ_VFPR16_M2 + 0U, // PseudoVFSGNJ_VFPR16_M2_MASK + 0U, // PseudoVFSGNJ_VFPR16_M4 + 0U, // PseudoVFSGNJ_VFPR16_M4_MASK + 0U, // PseudoVFSGNJ_VFPR16_M8 + 0U, // PseudoVFSGNJ_VFPR16_M8_MASK + 0U, // PseudoVFSGNJ_VFPR16_MF2 + 0U, // PseudoVFSGNJ_VFPR16_MF2_MASK + 0U, // PseudoVFSGNJ_VFPR16_MF4 + 0U, // PseudoVFSGNJ_VFPR16_MF4_MASK + 0U, // PseudoVFSGNJ_VFPR32_M1 + 0U, // PseudoVFSGNJ_VFPR32_M1_MASK + 0U, // PseudoVFSGNJ_VFPR32_M2 + 0U, // PseudoVFSGNJ_VFPR32_M2_MASK + 0U, // PseudoVFSGNJ_VFPR32_M4 + 0U, // PseudoVFSGNJ_VFPR32_M4_MASK + 0U, // PseudoVFSGNJ_VFPR32_M8 + 0U, // PseudoVFSGNJ_VFPR32_M8_MASK + 0U, // PseudoVFSGNJ_VFPR32_MF2 + 0U, // PseudoVFSGNJ_VFPR32_MF2_MASK + 0U, // PseudoVFSGNJ_VFPR64_M1 + 0U, // PseudoVFSGNJ_VFPR64_M1_MASK + 0U, // PseudoVFSGNJ_VFPR64_M2 + 0U, // PseudoVFSGNJ_VFPR64_M2_MASK + 0U, // PseudoVFSGNJ_VFPR64_M4 + 0U, // PseudoVFSGNJ_VFPR64_M4_MASK + 0U, // PseudoVFSGNJ_VFPR64_M8 + 0U, // PseudoVFSGNJ_VFPR64_M8_MASK + 0U, // PseudoVFSGNJ_VV_M1 + 0U, // PseudoVFSGNJ_VV_M1_MASK + 0U, // PseudoVFSGNJ_VV_M2 + 0U, // PseudoVFSGNJ_VV_M2_MASK + 0U, // PseudoVFSGNJ_VV_M4 + 0U, // PseudoVFSGNJ_VV_M4_MASK + 0U, // PseudoVFSGNJ_VV_M8 + 0U, // PseudoVFSGNJ_VV_M8_MASK + 0U, // PseudoVFSGNJ_VV_MF2 + 0U, // PseudoVFSGNJ_VV_MF2_MASK + 0U, // PseudoVFSGNJ_VV_MF4 + 0U, // PseudoVFSGNJ_VV_MF4_MASK + 0U, // PseudoVFSLIDE1DOWN_VFPR16_M1 + 0U, // PseudoVFSLIDE1DOWN_VFPR16_M1_MASK + 0U, // PseudoVFSLIDE1DOWN_VFPR16_M2 + 0U, // PseudoVFSLIDE1DOWN_VFPR16_M2_MASK + 0U, // PseudoVFSLIDE1DOWN_VFPR16_M4 + 0U, // PseudoVFSLIDE1DOWN_VFPR16_M4_MASK + 0U, // PseudoVFSLIDE1DOWN_VFPR16_M8 + 0U, // PseudoVFSLIDE1DOWN_VFPR16_M8_MASK + 0U, // PseudoVFSLIDE1DOWN_VFPR16_MF2 + 0U, // PseudoVFSLIDE1DOWN_VFPR16_MF2_MASK + 0U, // PseudoVFSLIDE1DOWN_VFPR16_MF4 + 0U, // PseudoVFSLIDE1DOWN_VFPR16_MF4_MASK + 0U, // PseudoVFSLIDE1DOWN_VFPR32_M1 + 0U, // PseudoVFSLIDE1DOWN_VFPR32_M1_MASK + 0U, // PseudoVFSLIDE1DOWN_VFPR32_M2 + 0U, // PseudoVFSLIDE1DOWN_VFPR32_M2_MASK + 0U, // PseudoVFSLIDE1DOWN_VFPR32_M4 + 0U, // PseudoVFSLIDE1DOWN_VFPR32_M4_MASK + 0U, // PseudoVFSLIDE1DOWN_VFPR32_M8 + 0U, // PseudoVFSLIDE1DOWN_VFPR32_M8_MASK + 0U, // PseudoVFSLIDE1DOWN_VFPR32_MF2 + 0U, // PseudoVFSLIDE1DOWN_VFPR32_MF2_MASK + 0U, // PseudoVFSLIDE1DOWN_VFPR64_M1 + 0U, // PseudoVFSLIDE1DOWN_VFPR64_M1_MASK + 0U, // PseudoVFSLIDE1DOWN_VFPR64_M2 + 0U, // PseudoVFSLIDE1DOWN_VFPR64_M2_MASK + 0U, // PseudoVFSLIDE1DOWN_VFPR64_M4 + 0U, // PseudoVFSLIDE1DOWN_VFPR64_M4_MASK + 0U, // PseudoVFSLIDE1DOWN_VFPR64_M8 + 0U, // PseudoVFSLIDE1DOWN_VFPR64_M8_MASK + 0U, // PseudoVFSLIDE1UP_VFPR16_M1 + 0U, // PseudoVFSLIDE1UP_VFPR16_M1_MASK + 0U, // PseudoVFSLIDE1UP_VFPR16_M2 + 0U, // PseudoVFSLIDE1UP_VFPR16_M2_MASK + 0U, // PseudoVFSLIDE1UP_VFPR16_M4 + 0U, // PseudoVFSLIDE1UP_VFPR16_M4_MASK + 0U, // PseudoVFSLIDE1UP_VFPR16_M8 + 0U, // PseudoVFSLIDE1UP_VFPR16_M8_MASK + 0U, // PseudoVFSLIDE1UP_VFPR16_MF2 + 0U, // PseudoVFSLIDE1UP_VFPR16_MF2_MASK + 0U, // PseudoVFSLIDE1UP_VFPR16_MF4 + 0U, // PseudoVFSLIDE1UP_VFPR16_MF4_MASK + 0U, // PseudoVFSLIDE1UP_VFPR32_M1 + 0U, // PseudoVFSLIDE1UP_VFPR32_M1_MASK + 0U, // PseudoVFSLIDE1UP_VFPR32_M2 + 0U, // PseudoVFSLIDE1UP_VFPR32_M2_MASK + 0U, // PseudoVFSLIDE1UP_VFPR32_M4 + 0U, // PseudoVFSLIDE1UP_VFPR32_M4_MASK + 0U, // PseudoVFSLIDE1UP_VFPR32_M8 + 0U, // PseudoVFSLIDE1UP_VFPR32_M8_MASK + 0U, // PseudoVFSLIDE1UP_VFPR32_MF2 + 0U, // PseudoVFSLIDE1UP_VFPR32_MF2_MASK + 0U, // PseudoVFSLIDE1UP_VFPR64_M1 + 0U, // PseudoVFSLIDE1UP_VFPR64_M1_MASK + 0U, // PseudoVFSLIDE1UP_VFPR64_M2 + 0U, // PseudoVFSLIDE1UP_VFPR64_M2_MASK + 0U, // PseudoVFSLIDE1UP_VFPR64_M4 + 0U, // PseudoVFSLIDE1UP_VFPR64_M4_MASK + 0U, // PseudoVFSLIDE1UP_VFPR64_M8 + 0U, // PseudoVFSLIDE1UP_VFPR64_M8_MASK + 0U, // PseudoVFSQRT_V_M1_E16 + 0U, // PseudoVFSQRT_V_M1_E16_MASK + 0U, // PseudoVFSQRT_V_M1_E32 + 0U, // PseudoVFSQRT_V_M1_E32_MASK + 0U, // PseudoVFSQRT_V_M1_E64 + 0U, // PseudoVFSQRT_V_M1_E64_MASK + 0U, // PseudoVFSQRT_V_M2_E16 + 0U, // PseudoVFSQRT_V_M2_E16_MASK + 0U, // PseudoVFSQRT_V_M2_E32 + 0U, // PseudoVFSQRT_V_M2_E32_MASK + 0U, // PseudoVFSQRT_V_M2_E64 + 0U, // PseudoVFSQRT_V_M2_E64_MASK + 0U, // PseudoVFSQRT_V_M4_E16 + 0U, // PseudoVFSQRT_V_M4_E16_MASK + 0U, // PseudoVFSQRT_V_M4_E32 + 0U, // PseudoVFSQRT_V_M4_E32_MASK + 0U, // PseudoVFSQRT_V_M4_E64 + 0U, // PseudoVFSQRT_V_M4_E64_MASK + 0U, // PseudoVFSQRT_V_M8_E16 + 0U, // PseudoVFSQRT_V_M8_E16_MASK + 0U, // PseudoVFSQRT_V_M8_E32 + 0U, // PseudoVFSQRT_V_M8_E32_MASK + 0U, // PseudoVFSQRT_V_M8_E64 + 0U, // PseudoVFSQRT_V_M8_E64_MASK + 0U, // PseudoVFSQRT_V_MF2_E16 + 0U, // PseudoVFSQRT_V_MF2_E16_MASK + 0U, // PseudoVFSQRT_V_MF2_E32 + 0U, // PseudoVFSQRT_V_MF2_E32_MASK + 0U, // PseudoVFSQRT_V_MF4_E16 + 0U, // PseudoVFSQRT_V_MF4_E16_MASK + 0U, // PseudoVFSUB_VFPR16_M1 + 0U, // PseudoVFSUB_VFPR16_M1_MASK + 0U, // PseudoVFSUB_VFPR16_M2 + 0U, // PseudoVFSUB_VFPR16_M2_MASK + 0U, // PseudoVFSUB_VFPR16_M4 + 0U, // PseudoVFSUB_VFPR16_M4_MASK + 0U, // PseudoVFSUB_VFPR16_M8 + 0U, // PseudoVFSUB_VFPR16_M8_MASK + 0U, // PseudoVFSUB_VFPR16_MF2 + 0U, // PseudoVFSUB_VFPR16_MF2_MASK + 0U, // PseudoVFSUB_VFPR16_MF4 + 0U, // PseudoVFSUB_VFPR16_MF4_MASK + 0U, // PseudoVFSUB_VFPR32_M1 + 0U, // PseudoVFSUB_VFPR32_M1_MASK + 0U, // PseudoVFSUB_VFPR32_M2 + 0U, // PseudoVFSUB_VFPR32_M2_MASK + 0U, // PseudoVFSUB_VFPR32_M4 + 0U, // PseudoVFSUB_VFPR32_M4_MASK + 0U, // PseudoVFSUB_VFPR32_M8 + 0U, // PseudoVFSUB_VFPR32_M8_MASK + 0U, // PseudoVFSUB_VFPR32_MF2 + 0U, // PseudoVFSUB_VFPR32_MF2_MASK + 0U, // PseudoVFSUB_VFPR64_M1 + 0U, // PseudoVFSUB_VFPR64_M1_MASK + 0U, // PseudoVFSUB_VFPR64_M2 + 0U, // PseudoVFSUB_VFPR64_M2_MASK + 0U, // PseudoVFSUB_VFPR64_M4 + 0U, // PseudoVFSUB_VFPR64_M4_MASK + 0U, // PseudoVFSUB_VFPR64_M8 + 0U, // PseudoVFSUB_VFPR64_M8_MASK + 0U, // PseudoVFSUB_VV_M1 + 0U, // PseudoVFSUB_VV_M1_MASK + 0U, // PseudoVFSUB_VV_M2 + 0U, // PseudoVFSUB_VV_M2_MASK + 0U, // PseudoVFSUB_VV_M4 + 0U, // PseudoVFSUB_VV_M4_MASK + 0U, // PseudoVFSUB_VV_M8 + 0U, // PseudoVFSUB_VV_M8_MASK + 0U, // PseudoVFSUB_VV_MF2 + 0U, // PseudoVFSUB_VV_MF2_MASK + 0U, // PseudoVFSUB_VV_MF4 + 0U, // PseudoVFSUB_VV_MF4_MASK + 0U, // PseudoVFWADD_VFPR16_M1 + 0U, // PseudoVFWADD_VFPR16_M1_MASK + 0U, // PseudoVFWADD_VFPR16_M2 + 0U, // PseudoVFWADD_VFPR16_M2_MASK + 0U, // PseudoVFWADD_VFPR16_M4 + 0U, // PseudoVFWADD_VFPR16_M4_MASK + 0U, // PseudoVFWADD_VFPR16_MF2 + 0U, // PseudoVFWADD_VFPR16_MF2_MASK + 0U, // PseudoVFWADD_VFPR16_MF4 + 0U, // PseudoVFWADD_VFPR16_MF4_MASK + 0U, // PseudoVFWADD_VFPR32_M1 + 0U, // PseudoVFWADD_VFPR32_M1_MASK + 0U, // PseudoVFWADD_VFPR32_M2 + 0U, // PseudoVFWADD_VFPR32_M2_MASK + 0U, // PseudoVFWADD_VFPR32_M4 + 0U, // PseudoVFWADD_VFPR32_M4_MASK + 0U, // PseudoVFWADD_VFPR32_MF2 + 0U, // PseudoVFWADD_VFPR32_MF2_MASK + 0U, // PseudoVFWADD_VV_M1 + 0U, // PseudoVFWADD_VV_M1_MASK + 0U, // PseudoVFWADD_VV_M2 + 0U, // PseudoVFWADD_VV_M2_MASK + 0U, // PseudoVFWADD_VV_M4 + 0U, // PseudoVFWADD_VV_M4_MASK + 0U, // PseudoVFWADD_VV_MF2 + 0U, // PseudoVFWADD_VV_MF2_MASK + 0U, // PseudoVFWADD_VV_MF4 + 0U, // PseudoVFWADD_VV_MF4_MASK + 0U, // PseudoVFWADD_WFPR16_M1 + 0U, // PseudoVFWADD_WFPR16_M1_MASK + 0U, // PseudoVFWADD_WFPR16_M2 + 0U, // PseudoVFWADD_WFPR16_M2_MASK + 0U, // PseudoVFWADD_WFPR16_M4 + 0U, // PseudoVFWADD_WFPR16_M4_MASK + 0U, // PseudoVFWADD_WFPR16_MF2 + 0U, // PseudoVFWADD_WFPR16_MF2_MASK + 0U, // PseudoVFWADD_WFPR16_MF4 + 0U, // PseudoVFWADD_WFPR16_MF4_MASK + 0U, // PseudoVFWADD_WFPR32_M1 + 0U, // PseudoVFWADD_WFPR32_M1_MASK + 0U, // PseudoVFWADD_WFPR32_M2 + 0U, // PseudoVFWADD_WFPR32_M2_MASK + 0U, // PseudoVFWADD_WFPR32_M4 + 0U, // PseudoVFWADD_WFPR32_M4_MASK + 0U, // PseudoVFWADD_WFPR32_MF2 + 0U, // PseudoVFWADD_WFPR32_MF2_MASK + 0U, // PseudoVFWADD_WV_M1 + 0U, // PseudoVFWADD_WV_M1_MASK + 0U, // PseudoVFWADD_WV_M1_MASK_TIED + 0U, // PseudoVFWADD_WV_M1_TIED + 0U, // PseudoVFWADD_WV_M2 + 0U, // PseudoVFWADD_WV_M2_MASK + 0U, // PseudoVFWADD_WV_M2_MASK_TIED + 0U, // PseudoVFWADD_WV_M2_TIED + 0U, // PseudoVFWADD_WV_M4 + 0U, // PseudoVFWADD_WV_M4_MASK + 0U, // PseudoVFWADD_WV_M4_MASK_TIED + 0U, // PseudoVFWADD_WV_M4_TIED + 0U, // PseudoVFWADD_WV_MF2 + 0U, // PseudoVFWADD_WV_MF2_MASK + 0U, // PseudoVFWADD_WV_MF2_MASK_TIED + 0U, // PseudoVFWADD_WV_MF2_TIED + 0U, // PseudoVFWADD_WV_MF4 + 0U, // PseudoVFWADD_WV_MF4_MASK + 0U, // PseudoVFWADD_WV_MF4_MASK_TIED + 0U, // PseudoVFWADD_WV_MF4_TIED + 0U, // PseudoVFWCVTBF16_F_F_V_M1 + 0U, // PseudoVFWCVTBF16_F_F_V_M1_MASK + 0U, // PseudoVFWCVTBF16_F_F_V_M2 + 0U, // PseudoVFWCVTBF16_F_F_V_M2_MASK + 0U, // PseudoVFWCVTBF16_F_F_V_M4 + 0U, // PseudoVFWCVTBF16_F_F_V_M4_MASK + 0U, // PseudoVFWCVTBF16_F_F_V_MF2 + 0U, // PseudoVFWCVTBF16_F_F_V_MF2_MASK + 0U, // PseudoVFWCVTBF16_F_F_V_MF4 + 0U, // PseudoVFWCVTBF16_F_F_V_MF4_MASK + 0U, // PseudoVFWCVT_F_F_V_M1 + 0U, // PseudoVFWCVT_F_F_V_M1_MASK + 0U, // PseudoVFWCVT_F_F_V_M2 + 0U, // PseudoVFWCVT_F_F_V_M2_MASK + 0U, // PseudoVFWCVT_F_F_V_M4 + 0U, // PseudoVFWCVT_F_F_V_M4_MASK + 0U, // PseudoVFWCVT_F_F_V_MF2 + 0U, // PseudoVFWCVT_F_F_V_MF2_MASK + 0U, // PseudoVFWCVT_F_F_V_MF4 + 0U, // PseudoVFWCVT_F_F_V_MF4_MASK + 0U, // PseudoVFWCVT_F_XU_V_M1 + 0U, // PseudoVFWCVT_F_XU_V_M1_MASK + 0U, // PseudoVFWCVT_F_XU_V_M2 + 0U, // PseudoVFWCVT_F_XU_V_M2_MASK + 0U, // PseudoVFWCVT_F_XU_V_M4 + 0U, // PseudoVFWCVT_F_XU_V_M4_MASK + 0U, // PseudoVFWCVT_F_XU_V_MF2 + 0U, // PseudoVFWCVT_F_XU_V_MF2_MASK + 0U, // PseudoVFWCVT_F_XU_V_MF4 + 0U, // PseudoVFWCVT_F_XU_V_MF4_MASK + 0U, // PseudoVFWCVT_F_XU_V_MF8 + 0U, // PseudoVFWCVT_F_XU_V_MF8_MASK + 0U, // PseudoVFWCVT_F_X_V_M1 + 0U, // PseudoVFWCVT_F_X_V_M1_MASK + 0U, // PseudoVFWCVT_F_X_V_M2 + 0U, // PseudoVFWCVT_F_X_V_M2_MASK + 0U, // PseudoVFWCVT_F_X_V_M4 + 0U, // PseudoVFWCVT_F_X_V_M4_MASK + 0U, // PseudoVFWCVT_F_X_V_MF2 + 0U, // PseudoVFWCVT_F_X_V_MF2_MASK + 0U, // PseudoVFWCVT_F_X_V_MF4 + 0U, // PseudoVFWCVT_F_X_V_MF4_MASK + 0U, // PseudoVFWCVT_F_X_V_MF8 + 0U, // PseudoVFWCVT_F_X_V_MF8_MASK + 0U, // PseudoVFWCVT_RM_XU_F_V_M1 + 0U, // PseudoVFWCVT_RM_XU_F_V_M1_MASK + 0U, // PseudoVFWCVT_RM_XU_F_V_M2 + 0U, // PseudoVFWCVT_RM_XU_F_V_M2_MASK + 0U, // PseudoVFWCVT_RM_XU_F_V_M4 + 0U, // PseudoVFWCVT_RM_XU_F_V_M4_MASK + 0U, // PseudoVFWCVT_RM_XU_F_V_MF2 + 0U, // PseudoVFWCVT_RM_XU_F_V_MF2_MASK + 0U, // PseudoVFWCVT_RM_XU_F_V_MF4 + 0U, // PseudoVFWCVT_RM_XU_F_V_MF4_MASK + 0U, // PseudoVFWCVT_RM_X_F_V_M1 + 0U, // PseudoVFWCVT_RM_X_F_V_M1_MASK + 0U, // PseudoVFWCVT_RM_X_F_V_M2 + 0U, // PseudoVFWCVT_RM_X_F_V_M2_MASK + 0U, // PseudoVFWCVT_RM_X_F_V_M4 + 0U, // PseudoVFWCVT_RM_X_F_V_M4_MASK + 0U, // PseudoVFWCVT_RM_X_F_V_MF2 + 0U, // PseudoVFWCVT_RM_X_F_V_MF2_MASK + 0U, // PseudoVFWCVT_RM_X_F_V_MF4 + 0U, // PseudoVFWCVT_RM_X_F_V_MF4_MASK + 0U, // PseudoVFWCVT_RTZ_XU_F_V_M1 + 0U, // PseudoVFWCVT_RTZ_XU_F_V_M1_MASK + 0U, // PseudoVFWCVT_RTZ_XU_F_V_M2 + 0U, // PseudoVFWCVT_RTZ_XU_F_V_M2_MASK + 0U, // PseudoVFWCVT_RTZ_XU_F_V_M4 + 0U, // PseudoVFWCVT_RTZ_XU_F_V_M4_MASK + 0U, // PseudoVFWCVT_RTZ_XU_F_V_MF2 + 0U, // PseudoVFWCVT_RTZ_XU_F_V_MF2_MASK + 0U, // PseudoVFWCVT_RTZ_XU_F_V_MF4 + 0U, // PseudoVFWCVT_RTZ_XU_F_V_MF4_MASK + 0U, // PseudoVFWCVT_RTZ_X_F_V_M1 + 0U, // PseudoVFWCVT_RTZ_X_F_V_M1_MASK + 0U, // PseudoVFWCVT_RTZ_X_F_V_M2 + 0U, // PseudoVFWCVT_RTZ_X_F_V_M2_MASK + 0U, // PseudoVFWCVT_RTZ_X_F_V_M4 + 0U, // PseudoVFWCVT_RTZ_X_F_V_M4_MASK + 0U, // PseudoVFWCVT_RTZ_X_F_V_MF2 + 0U, // PseudoVFWCVT_RTZ_X_F_V_MF2_MASK + 0U, // PseudoVFWCVT_RTZ_X_F_V_MF4 + 0U, // PseudoVFWCVT_RTZ_X_F_V_MF4_MASK + 0U, // PseudoVFWCVT_XU_F_V_M1 + 0U, // PseudoVFWCVT_XU_F_V_M1_MASK + 0U, // PseudoVFWCVT_XU_F_V_M2 + 0U, // PseudoVFWCVT_XU_F_V_M2_MASK + 0U, // PseudoVFWCVT_XU_F_V_M4 + 0U, // PseudoVFWCVT_XU_F_V_M4_MASK + 0U, // PseudoVFWCVT_XU_F_V_MF2 + 0U, // PseudoVFWCVT_XU_F_V_MF2_MASK + 0U, // PseudoVFWCVT_XU_F_V_MF4 + 0U, // PseudoVFWCVT_XU_F_V_MF4_MASK + 0U, // PseudoVFWCVT_X_F_V_M1 + 0U, // PseudoVFWCVT_X_F_V_M1_MASK + 0U, // PseudoVFWCVT_X_F_V_M2 + 0U, // PseudoVFWCVT_X_F_V_M2_MASK + 0U, // PseudoVFWCVT_X_F_V_M4 + 0U, // PseudoVFWCVT_X_F_V_M4_MASK + 0U, // PseudoVFWCVT_X_F_V_MF2 + 0U, // PseudoVFWCVT_X_F_V_MF2_MASK + 0U, // PseudoVFWCVT_X_F_V_MF4 + 0U, // PseudoVFWCVT_X_F_V_MF4_MASK + 0U, // PseudoVFWMACCBF16_VFPR16_M1 + 0U, // PseudoVFWMACCBF16_VFPR16_M1_MASK + 0U, // PseudoVFWMACCBF16_VFPR16_M2 + 0U, // PseudoVFWMACCBF16_VFPR16_M2_MASK + 0U, // PseudoVFWMACCBF16_VFPR16_M4 + 0U, // PseudoVFWMACCBF16_VFPR16_M4_MASK + 0U, // PseudoVFWMACCBF16_VFPR16_MF2 + 0U, // PseudoVFWMACCBF16_VFPR16_MF2_MASK + 0U, // PseudoVFWMACCBF16_VFPR16_MF4 + 0U, // PseudoVFWMACCBF16_VFPR16_MF4_MASK + 0U, // PseudoVFWMACCBF16_VV_M1 + 0U, // PseudoVFWMACCBF16_VV_M1_MASK + 0U, // PseudoVFWMACCBF16_VV_M2 + 0U, // PseudoVFWMACCBF16_VV_M2_MASK + 0U, // PseudoVFWMACCBF16_VV_M4 + 0U, // PseudoVFWMACCBF16_VV_M4_MASK + 0U, // PseudoVFWMACCBF16_VV_MF2 + 0U, // PseudoVFWMACCBF16_VV_MF2_MASK + 0U, // PseudoVFWMACCBF16_VV_MF4 + 0U, // PseudoVFWMACCBF16_VV_MF4_MASK + 0U, // PseudoVFWMACC_4x4x4_M1 + 0U, // PseudoVFWMACC_4x4x4_M2 + 0U, // PseudoVFWMACC_4x4x4_M4 + 0U, // PseudoVFWMACC_4x4x4_M8 + 0U, // PseudoVFWMACC_4x4x4_MF2 + 0U, // PseudoVFWMACC_4x4x4_MF4 + 0U, // PseudoVFWMACC_VFPR16_M1 + 0U, // PseudoVFWMACC_VFPR16_M1_MASK + 0U, // PseudoVFWMACC_VFPR16_M2 + 0U, // PseudoVFWMACC_VFPR16_M2_MASK + 0U, // PseudoVFWMACC_VFPR16_M4 + 0U, // PseudoVFWMACC_VFPR16_M4_MASK + 0U, // PseudoVFWMACC_VFPR16_MF2 + 0U, // PseudoVFWMACC_VFPR16_MF2_MASK + 0U, // PseudoVFWMACC_VFPR16_MF4 + 0U, // PseudoVFWMACC_VFPR16_MF4_MASK + 0U, // PseudoVFWMACC_VFPR32_M1 + 0U, // PseudoVFWMACC_VFPR32_M1_MASK + 0U, // PseudoVFWMACC_VFPR32_M2 + 0U, // PseudoVFWMACC_VFPR32_M2_MASK + 0U, // PseudoVFWMACC_VFPR32_M4 + 0U, // PseudoVFWMACC_VFPR32_M4_MASK + 0U, // PseudoVFWMACC_VFPR32_MF2 + 0U, // PseudoVFWMACC_VFPR32_MF2_MASK + 0U, // PseudoVFWMACC_VV_M1 + 0U, // PseudoVFWMACC_VV_M1_MASK + 0U, // PseudoVFWMACC_VV_M2 + 0U, // PseudoVFWMACC_VV_M2_MASK + 0U, // PseudoVFWMACC_VV_M4 + 0U, // PseudoVFWMACC_VV_M4_MASK + 0U, // PseudoVFWMACC_VV_MF2 + 0U, // PseudoVFWMACC_VV_MF2_MASK + 0U, // PseudoVFWMACC_VV_MF4 + 0U, // PseudoVFWMACC_VV_MF4_MASK + 0U, // PseudoVFWMSAC_VFPR16_M1 + 0U, // PseudoVFWMSAC_VFPR16_M1_MASK + 0U, // PseudoVFWMSAC_VFPR16_M2 + 0U, // PseudoVFWMSAC_VFPR16_M2_MASK + 0U, // PseudoVFWMSAC_VFPR16_M4 + 0U, // PseudoVFWMSAC_VFPR16_M4_MASK + 0U, // PseudoVFWMSAC_VFPR16_MF2 + 0U, // PseudoVFWMSAC_VFPR16_MF2_MASK + 0U, // PseudoVFWMSAC_VFPR16_MF4 + 0U, // PseudoVFWMSAC_VFPR16_MF4_MASK + 0U, // PseudoVFWMSAC_VFPR32_M1 + 0U, // PseudoVFWMSAC_VFPR32_M1_MASK + 0U, // PseudoVFWMSAC_VFPR32_M2 + 0U, // PseudoVFWMSAC_VFPR32_M2_MASK + 0U, // PseudoVFWMSAC_VFPR32_M4 + 0U, // PseudoVFWMSAC_VFPR32_M4_MASK + 0U, // PseudoVFWMSAC_VFPR32_MF2 + 0U, // PseudoVFWMSAC_VFPR32_MF2_MASK + 0U, // PseudoVFWMSAC_VV_M1 + 0U, // PseudoVFWMSAC_VV_M1_MASK + 0U, // PseudoVFWMSAC_VV_M2 + 0U, // PseudoVFWMSAC_VV_M2_MASK + 0U, // PseudoVFWMSAC_VV_M4 + 0U, // PseudoVFWMSAC_VV_M4_MASK + 0U, // PseudoVFWMSAC_VV_MF2 + 0U, // PseudoVFWMSAC_VV_MF2_MASK + 0U, // PseudoVFWMSAC_VV_MF4 + 0U, // PseudoVFWMSAC_VV_MF4_MASK + 0U, // PseudoVFWMUL_VFPR16_M1 + 0U, // PseudoVFWMUL_VFPR16_M1_MASK + 0U, // PseudoVFWMUL_VFPR16_M2 + 0U, // PseudoVFWMUL_VFPR16_M2_MASK + 0U, // PseudoVFWMUL_VFPR16_M4 + 0U, // PseudoVFWMUL_VFPR16_M4_MASK + 0U, // PseudoVFWMUL_VFPR16_MF2 + 0U, // PseudoVFWMUL_VFPR16_MF2_MASK + 0U, // PseudoVFWMUL_VFPR16_MF4 + 0U, // PseudoVFWMUL_VFPR16_MF4_MASK + 0U, // PseudoVFWMUL_VFPR32_M1 + 0U, // PseudoVFWMUL_VFPR32_M1_MASK + 0U, // PseudoVFWMUL_VFPR32_M2 + 0U, // PseudoVFWMUL_VFPR32_M2_MASK + 0U, // PseudoVFWMUL_VFPR32_M4 + 0U, // PseudoVFWMUL_VFPR32_M4_MASK + 0U, // PseudoVFWMUL_VFPR32_MF2 + 0U, // PseudoVFWMUL_VFPR32_MF2_MASK + 0U, // PseudoVFWMUL_VV_M1 + 0U, // PseudoVFWMUL_VV_M1_MASK + 0U, // PseudoVFWMUL_VV_M2 + 0U, // PseudoVFWMUL_VV_M2_MASK + 0U, // PseudoVFWMUL_VV_M4 + 0U, // PseudoVFWMUL_VV_M4_MASK + 0U, // PseudoVFWMUL_VV_MF2 + 0U, // PseudoVFWMUL_VV_MF2_MASK + 0U, // PseudoVFWMUL_VV_MF4 + 0U, // PseudoVFWMUL_VV_MF4_MASK + 0U, // PseudoVFWNMACC_VFPR16_M1 + 0U, // PseudoVFWNMACC_VFPR16_M1_MASK + 0U, // PseudoVFWNMACC_VFPR16_M2 + 0U, // PseudoVFWNMACC_VFPR16_M2_MASK + 0U, // PseudoVFWNMACC_VFPR16_M4 + 0U, // PseudoVFWNMACC_VFPR16_M4_MASK + 0U, // PseudoVFWNMACC_VFPR16_MF2 + 0U, // PseudoVFWNMACC_VFPR16_MF2_MASK + 0U, // PseudoVFWNMACC_VFPR16_MF4 + 0U, // PseudoVFWNMACC_VFPR16_MF4_MASK + 0U, // PseudoVFWNMACC_VFPR32_M1 + 0U, // PseudoVFWNMACC_VFPR32_M1_MASK + 0U, // PseudoVFWNMACC_VFPR32_M2 + 0U, // PseudoVFWNMACC_VFPR32_M2_MASK + 0U, // PseudoVFWNMACC_VFPR32_M4 + 0U, // PseudoVFWNMACC_VFPR32_M4_MASK + 0U, // PseudoVFWNMACC_VFPR32_MF2 + 0U, // PseudoVFWNMACC_VFPR32_MF2_MASK + 0U, // PseudoVFWNMACC_VV_M1 + 0U, // PseudoVFWNMACC_VV_M1_MASK + 0U, // PseudoVFWNMACC_VV_M2 + 0U, // PseudoVFWNMACC_VV_M2_MASK + 0U, // PseudoVFWNMACC_VV_M4 + 0U, // PseudoVFWNMACC_VV_M4_MASK + 0U, // PseudoVFWNMACC_VV_MF2 + 0U, // PseudoVFWNMACC_VV_MF2_MASK + 0U, // PseudoVFWNMACC_VV_MF4 + 0U, // PseudoVFWNMACC_VV_MF4_MASK + 0U, // PseudoVFWNMSAC_VFPR16_M1 + 0U, // PseudoVFWNMSAC_VFPR16_M1_MASK + 0U, // PseudoVFWNMSAC_VFPR16_M2 + 0U, // PseudoVFWNMSAC_VFPR16_M2_MASK + 0U, // PseudoVFWNMSAC_VFPR16_M4 + 0U, // PseudoVFWNMSAC_VFPR16_M4_MASK + 0U, // PseudoVFWNMSAC_VFPR16_MF2 + 0U, // PseudoVFWNMSAC_VFPR16_MF2_MASK + 0U, // PseudoVFWNMSAC_VFPR16_MF4 + 0U, // PseudoVFWNMSAC_VFPR16_MF4_MASK + 0U, // PseudoVFWNMSAC_VFPR32_M1 + 0U, // PseudoVFWNMSAC_VFPR32_M1_MASK + 0U, // PseudoVFWNMSAC_VFPR32_M2 + 0U, // PseudoVFWNMSAC_VFPR32_M2_MASK + 0U, // PseudoVFWNMSAC_VFPR32_M4 + 0U, // PseudoVFWNMSAC_VFPR32_M4_MASK + 0U, // PseudoVFWNMSAC_VFPR32_MF2 + 0U, // PseudoVFWNMSAC_VFPR32_MF2_MASK + 0U, // PseudoVFWNMSAC_VV_M1 + 0U, // PseudoVFWNMSAC_VV_M1_MASK + 0U, // PseudoVFWNMSAC_VV_M2 + 0U, // PseudoVFWNMSAC_VV_M2_MASK + 0U, // PseudoVFWNMSAC_VV_M4 + 0U, // PseudoVFWNMSAC_VV_M4_MASK + 0U, // PseudoVFWNMSAC_VV_MF2 + 0U, // PseudoVFWNMSAC_VV_MF2_MASK + 0U, // PseudoVFWNMSAC_VV_MF4 + 0U, // PseudoVFWNMSAC_VV_MF4_MASK + 0U, // PseudoVFWREDOSUM_VS_M1_E16 + 0U, // PseudoVFWREDOSUM_VS_M1_E16_MASK + 0U, // PseudoVFWREDOSUM_VS_M1_E32 + 0U, // PseudoVFWREDOSUM_VS_M1_E32_MASK + 0U, // PseudoVFWREDOSUM_VS_M2_E16 + 0U, // PseudoVFWREDOSUM_VS_M2_E16_MASK + 0U, // PseudoVFWREDOSUM_VS_M2_E32 + 0U, // PseudoVFWREDOSUM_VS_M2_E32_MASK + 0U, // PseudoVFWREDOSUM_VS_M4_E16 + 0U, // PseudoVFWREDOSUM_VS_M4_E16_MASK + 0U, // PseudoVFWREDOSUM_VS_M4_E32 + 0U, // PseudoVFWREDOSUM_VS_M4_E32_MASK + 0U, // PseudoVFWREDOSUM_VS_M8_E16 + 0U, // PseudoVFWREDOSUM_VS_M8_E16_MASK + 0U, // PseudoVFWREDOSUM_VS_M8_E32 + 0U, // PseudoVFWREDOSUM_VS_M8_E32_MASK + 0U, // PseudoVFWREDOSUM_VS_MF2_E16 + 0U, // PseudoVFWREDOSUM_VS_MF2_E16_MASK + 0U, // PseudoVFWREDOSUM_VS_MF2_E32 + 0U, // PseudoVFWREDOSUM_VS_MF2_E32_MASK + 0U, // PseudoVFWREDOSUM_VS_MF4_E16 + 0U, // PseudoVFWREDOSUM_VS_MF4_E16_MASK + 0U, // PseudoVFWREDUSUM_VS_M1_E16 + 0U, // PseudoVFWREDUSUM_VS_M1_E16_MASK + 0U, // PseudoVFWREDUSUM_VS_M1_E32 + 0U, // PseudoVFWREDUSUM_VS_M1_E32_MASK + 0U, // PseudoVFWREDUSUM_VS_M2_E16 + 0U, // PseudoVFWREDUSUM_VS_M2_E16_MASK + 0U, // PseudoVFWREDUSUM_VS_M2_E32 + 0U, // PseudoVFWREDUSUM_VS_M2_E32_MASK + 0U, // PseudoVFWREDUSUM_VS_M4_E16 + 0U, // PseudoVFWREDUSUM_VS_M4_E16_MASK + 0U, // PseudoVFWREDUSUM_VS_M4_E32 + 0U, // PseudoVFWREDUSUM_VS_M4_E32_MASK + 0U, // PseudoVFWREDUSUM_VS_M8_E16 + 0U, // PseudoVFWREDUSUM_VS_M8_E16_MASK + 0U, // PseudoVFWREDUSUM_VS_M8_E32 + 0U, // PseudoVFWREDUSUM_VS_M8_E32_MASK + 0U, // PseudoVFWREDUSUM_VS_MF2_E16 + 0U, // PseudoVFWREDUSUM_VS_MF2_E16_MASK + 0U, // PseudoVFWREDUSUM_VS_MF2_E32 + 0U, // PseudoVFWREDUSUM_VS_MF2_E32_MASK + 0U, // PseudoVFWREDUSUM_VS_MF4_E16 + 0U, // PseudoVFWREDUSUM_VS_MF4_E16_MASK + 0U, // PseudoVFWSUB_VFPR16_M1 + 0U, // PseudoVFWSUB_VFPR16_M1_MASK + 0U, // PseudoVFWSUB_VFPR16_M2 + 0U, // PseudoVFWSUB_VFPR16_M2_MASK + 0U, // PseudoVFWSUB_VFPR16_M4 + 0U, // PseudoVFWSUB_VFPR16_M4_MASK + 0U, // PseudoVFWSUB_VFPR16_MF2 + 0U, // PseudoVFWSUB_VFPR16_MF2_MASK + 0U, // PseudoVFWSUB_VFPR16_MF4 + 0U, // PseudoVFWSUB_VFPR16_MF4_MASK + 0U, // PseudoVFWSUB_VFPR32_M1 + 0U, // PseudoVFWSUB_VFPR32_M1_MASK + 0U, // PseudoVFWSUB_VFPR32_M2 + 0U, // PseudoVFWSUB_VFPR32_M2_MASK + 0U, // PseudoVFWSUB_VFPR32_M4 + 0U, // PseudoVFWSUB_VFPR32_M4_MASK + 0U, // PseudoVFWSUB_VFPR32_MF2 + 0U, // PseudoVFWSUB_VFPR32_MF2_MASK + 0U, // PseudoVFWSUB_VV_M1 + 0U, // PseudoVFWSUB_VV_M1_MASK + 0U, // PseudoVFWSUB_VV_M2 + 0U, // PseudoVFWSUB_VV_M2_MASK + 0U, // PseudoVFWSUB_VV_M4 + 0U, // PseudoVFWSUB_VV_M4_MASK + 0U, // PseudoVFWSUB_VV_MF2 + 0U, // PseudoVFWSUB_VV_MF2_MASK + 0U, // PseudoVFWSUB_VV_MF4 + 0U, // PseudoVFWSUB_VV_MF4_MASK + 0U, // PseudoVFWSUB_WFPR16_M1 + 0U, // PseudoVFWSUB_WFPR16_M1_MASK + 0U, // PseudoVFWSUB_WFPR16_M2 + 0U, // PseudoVFWSUB_WFPR16_M2_MASK + 0U, // PseudoVFWSUB_WFPR16_M4 + 0U, // PseudoVFWSUB_WFPR16_M4_MASK + 0U, // PseudoVFWSUB_WFPR16_MF2 + 0U, // PseudoVFWSUB_WFPR16_MF2_MASK + 0U, // PseudoVFWSUB_WFPR16_MF4 + 0U, // PseudoVFWSUB_WFPR16_MF4_MASK + 0U, // PseudoVFWSUB_WFPR32_M1 + 0U, // PseudoVFWSUB_WFPR32_M1_MASK + 0U, // PseudoVFWSUB_WFPR32_M2 + 0U, // PseudoVFWSUB_WFPR32_M2_MASK + 0U, // PseudoVFWSUB_WFPR32_M4 + 0U, // PseudoVFWSUB_WFPR32_M4_MASK + 0U, // PseudoVFWSUB_WFPR32_MF2 + 0U, // PseudoVFWSUB_WFPR32_MF2_MASK + 0U, // PseudoVFWSUB_WV_M1 + 0U, // PseudoVFWSUB_WV_M1_MASK + 0U, // PseudoVFWSUB_WV_M1_MASK_TIED + 0U, // PseudoVFWSUB_WV_M1_TIED + 0U, // PseudoVFWSUB_WV_M2 + 0U, // PseudoVFWSUB_WV_M2_MASK + 0U, // PseudoVFWSUB_WV_M2_MASK_TIED + 0U, // PseudoVFWSUB_WV_M2_TIED + 0U, // PseudoVFWSUB_WV_M4 + 0U, // PseudoVFWSUB_WV_M4_MASK + 0U, // PseudoVFWSUB_WV_M4_MASK_TIED + 0U, // PseudoVFWSUB_WV_M4_TIED + 0U, // PseudoVFWSUB_WV_MF2 + 0U, // PseudoVFWSUB_WV_MF2_MASK + 0U, // PseudoVFWSUB_WV_MF2_MASK_TIED + 0U, // PseudoVFWSUB_WV_MF2_TIED + 0U, // PseudoVFWSUB_WV_MF4 + 0U, // PseudoVFWSUB_WV_MF4_MASK + 0U, // PseudoVFWSUB_WV_MF4_MASK_TIED + 0U, // PseudoVFWSUB_WV_MF4_TIED + 0U, // PseudoVGHSH_VV_M1 + 0U, // PseudoVGHSH_VV_M2 + 0U, // PseudoVGHSH_VV_M4 + 0U, // PseudoVGHSH_VV_M8 + 0U, // PseudoVGHSH_VV_MF2 + 0U, // PseudoVGMUL_VV_M1 + 0U, // PseudoVGMUL_VV_M2 + 0U, // PseudoVGMUL_VV_M4 + 0U, // PseudoVGMUL_VV_M8 + 0U, // PseudoVGMUL_VV_MF2 + 0U, // PseudoVID_V_M1 + 0U, // PseudoVID_V_M1_MASK + 0U, // PseudoVID_V_M2 + 0U, // PseudoVID_V_M2_MASK + 0U, // PseudoVID_V_M4 + 0U, // PseudoVID_V_M4_MASK + 0U, // PseudoVID_V_M8 + 0U, // PseudoVID_V_M8_MASK + 0U, // PseudoVID_V_MF2 + 0U, // PseudoVID_V_MF2_MASK + 0U, // PseudoVID_V_MF4 + 0U, // PseudoVID_V_MF4_MASK + 0U, // PseudoVID_V_MF8 + 0U, // PseudoVID_V_MF8_MASK + 0U, // PseudoVIOTA_M_M1 + 0U, // PseudoVIOTA_M_M1_MASK + 0U, // PseudoVIOTA_M_M2 + 0U, // PseudoVIOTA_M_M2_MASK + 0U, // PseudoVIOTA_M_M4 + 0U, // PseudoVIOTA_M_M4_MASK + 0U, // PseudoVIOTA_M_M8 + 0U, // PseudoVIOTA_M_M8_MASK + 0U, // PseudoVIOTA_M_MF2 + 0U, // PseudoVIOTA_M_MF2_MASK + 0U, // PseudoVIOTA_M_MF4 + 0U, // PseudoVIOTA_M_MF4_MASK + 0U, // PseudoVIOTA_M_MF8 + 0U, // PseudoVIOTA_M_MF8_MASK + 0U, // PseudoVLE16FF_V_M1 + 0U, // PseudoVLE16FF_V_M1_MASK + 0U, // PseudoVLE16FF_V_M2 + 0U, // PseudoVLE16FF_V_M2_MASK + 0U, // PseudoVLE16FF_V_M4 + 0U, // PseudoVLE16FF_V_M4_MASK + 0U, // PseudoVLE16FF_V_M8 + 0U, // PseudoVLE16FF_V_M8_MASK + 0U, // PseudoVLE16FF_V_MF2 + 0U, // PseudoVLE16FF_V_MF2_MASK + 0U, // PseudoVLE16FF_V_MF4 + 0U, // PseudoVLE16FF_V_MF4_MASK + 0U, // PseudoVLE16_V_M1 + 0U, // PseudoVLE16_V_M1_MASK + 0U, // PseudoVLE16_V_M2 + 0U, // PseudoVLE16_V_M2_MASK + 0U, // PseudoVLE16_V_M4 + 0U, // PseudoVLE16_V_M4_MASK + 0U, // PseudoVLE16_V_M8 + 0U, // PseudoVLE16_V_M8_MASK + 0U, // PseudoVLE16_V_MF2 + 0U, // PseudoVLE16_V_MF2_MASK + 0U, // PseudoVLE16_V_MF4 + 0U, // PseudoVLE16_V_MF4_MASK + 0U, // PseudoVLE32FF_V_M1 + 0U, // PseudoVLE32FF_V_M1_MASK + 0U, // PseudoVLE32FF_V_M2 + 0U, // PseudoVLE32FF_V_M2_MASK + 0U, // PseudoVLE32FF_V_M4 + 0U, // PseudoVLE32FF_V_M4_MASK + 0U, // PseudoVLE32FF_V_M8 + 0U, // PseudoVLE32FF_V_M8_MASK + 0U, // PseudoVLE32FF_V_MF2 + 0U, // PseudoVLE32FF_V_MF2_MASK + 0U, // PseudoVLE32_V_M1 + 0U, // PseudoVLE32_V_M1_MASK + 0U, // PseudoVLE32_V_M2 + 0U, // PseudoVLE32_V_M2_MASK + 0U, // PseudoVLE32_V_M4 + 0U, // PseudoVLE32_V_M4_MASK + 0U, // PseudoVLE32_V_M8 + 0U, // PseudoVLE32_V_M8_MASK + 0U, // PseudoVLE32_V_MF2 + 0U, // PseudoVLE32_V_MF2_MASK + 0U, // PseudoVLE64FF_V_M1 + 0U, // PseudoVLE64FF_V_M1_MASK + 0U, // PseudoVLE64FF_V_M2 + 0U, // PseudoVLE64FF_V_M2_MASK + 0U, // PseudoVLE64FF_V_M4 + 0U, // PseudoVLE64FF_V_M4_MASK + 0U, // PseudoVLE64FF_V_M8 + 0U, // PseudoVLE64FF_V_M8_MASK + 0U, // PseudoVLE64_V_M1 + 0U, // PseudoVLE64_V_M1_MASK + 0U, // PseudoVLE64_V_M2 + 0U, // PseudoVLE64_V_M2_MASK + 0U, // PseudoVLE64_V_M4 + 0U, // PseudoVLE64_V_M4_MASK + 0U, // PseudoVLE64_V_M8 + 0U, // PseudoVLE64_V_M8_MASK + 0U, // PseudoVLE8FF_V_M1 + 0U, // PseudoVLE8FF_V_M1_MASK + 0U, // PseudoVLE8FF_V_M2 + 0U, // PseudoVLE8FF_V_M2_MASK + 0U, // PseudoVLE8FF_V_M4 + 0U, // PseudoVLE8FF_V_M4_MASK + 0U, // PseudoVLE8FF_V_M8 + 0U, // PseudoVLE8FF_V_M8_MASK + 0U, // PseudoVLE8FF_V_MF2 + 0U, // PseudoVLE8FF_V_MF2_MASK + 0U, // PseudoVLE8FF_V_MF4 + 0U, // PseudoVLE8FF_V_MF4_MASK + 0U, // PseudoVLE8FF_V_MF8 + 0U, // PseudoVLE8FF_V_MF8_MASK + 0U, // PseudoVLE8_V_M1 + 0U, // PseudoVLE8_V_M1_MASK + 0U, // PseudoVLE8_V_M2 + 0U, // PseudoVLE8_V_M2_MASK + 0U, // PseudoVLE8_V_M4 + 0U, // PseudoVLE8_V_M4_MASK + 0U, // PseudoVLE8_V_M8 + 0U, // PseudoVLE8_V_M8_MASK + 0U, // PseudoVLE8_V_MF2 + 0U, // PseudoVLE8_V_MF2_MASK + 0U, // PseudoVLE8_V_MF4 + 0U, // PseudoVLE8_V_MF4_MASK + 0U, // PseudoVLE8_V_MF8 + 0U, // PseudoVLE8_V_MF8_MASK + 0U, // PseudoVLM_V_B1 + 0U, // PseudoVLM_V_B16 + 0U, // PseudoVLM_V_B2 + 0U, // PseudoVLM_V_B32 + 0U, // PseudoVLM_V_B4 + 0U, // PseudoVLM_V_B64 + 0U, // PseudoVLM_V_B8 + 0U, // PseudoVLOXEI16_V_M1_M1 + 0U, // PseudoVLOXEI16_V_M1_M1_MASK + 0U, // PseudoVLOXEI16_V_M1_M2 + 0U, // PseudoVLOXEI16_V_M1_M2_MASK + 0U, // PseudoVLOXEI16_V_M1_M4 + 0U, // PseudoVLOXEI16_V_M1_M4_MASK + 0U, // PseudoVLOXEI16_V_M1_MF2 + 0U, // PseudoVLOXEI16_V_M1_MF2_MASK + 0U, // PseudoVLOXEI16_V_M2_M1 + 0U, // PseudoVLOXEI16_V_M2_M1_MASK + 0U, // PseudoVLOXEI16_V_M2_M2 + 0U, // PseudoVLOXEI16_V_M2_M2_MASK + 0U, // PseudoVLOXEI16_V_M2_M4 + 0U, // PseudoVLOXEI16_V_M2_M4_MASK + 0U, // PseudoVLOXEI16_V_M2_M8 + 0U, // PseudoVLOXEI16_V_M2_M8_MASK + 0U, // PseudoVLOXEI16_V_M4_M2 + 0U, // PseudoVLOXEI16_V_M4_M2_MASK + 0U, // PseudoVLOXEI16_V_M4_M4 + 0U, // PseudoVLOXEI16_V_M4_M4_MASK + 0U, // PseudoVLOXEI16_V_M4_M8 + 0U, // PseudoVLOXEI16_V_M4_M8_MASK + 0U, // PseudoVLOXEI16_V_M8_M4 + 0U, // PseudoVLOXEI16_V_M8_M4_MASK + 0U, // PseudoVLOXEI16_V_M8_M8 + 0U, // PseudoVLOXEI16_V_M8_M8_MASK + 0U, // PseudoVLOXEI16_V_MF2_M1 + 0U, // PseudoVLOXEI16_V_MF2_M1_MASK + 0U, // PseudoVLOXEI16_V_MF2_M2 + 0U, // PseudoVLOXEI16_V_MF2_M2_MASK + 0U, // PseudoVLOXEI16_V_MF2_MF2 + 0U, // PseudoVLOXEI16_V_MF2_MF2_MASK + 0U, // PseudoVLOXEI16_V_MF2_MF4 + 0U, // PseudoVLOXEI16_V_MF2_MF4_MASK + 0U, // PseudoVLOXEI16_V_MF4_M1 + 0U, // PseudoVLOXEI16_V_MF4_M1_MASK + 0U, // PseudoVLOXEI16_V_MF4_MF2 + 0U, // PseudoVLOXEI16_V_MF4_MF2_MASK + 0U, // PseudoVLOXEI16_V_MF4_MF4 + 0U, // PseudoVLOXEI16_V_MF4_MF4_MASK + 0U, // PseudoVLOXEI16_V_MF4_MF8 + 0U, // PseudoVLOXEI16_V_MF4_MF8_MASK + 0U, // PseudoVLOXEI32_V_M1_M1 + 0U, // PseudoVLOXEI32_V_M1_M1_MASK + 0U, // PseudoVLOXEI32_V_M1_M2 + 0U, // PseudoVLOXEI32_V_M1_M2_MASK + 0U, // PseudoVLOXEI32_V_M1_MF2 + 0U, // PseudoVLOXEI32_V_M1_MF2_MASK + 0U, // PseudoVLOXEI32_V_M1_MF4 + 0U, // PseudoVLOXEI32_V_M1_MF4_MASK + 0U, // PseudoVLOXEI32_V_M2_M1 + 0U, // PseudoVLOXEI32_V_M2_M1_MASK + 0U, // PseudoVLOXEI32_V_M2_M2 + 0U, // PseudoVLOXEI32_V_M2_M2_MASK + 0U, // PseudoVLOXEI32_V_M2_M4 + 0U, // PseudoVLOXEI32_V_M2_M4_MASK + 0U, // PseudoVLOXEI32_V_M2_MF2 + 0U, // PseudoVLOXEI32_V_M2_MF2_MASK + 0U, // PseudoVLOXEI32_V_M4_M1 + 0U, // PseudoVLOXEI32_V_M4_M1_MASK + 0U, // PseudoVLOXEI32_V_M4_M2 + 0U, // PseudoVLOXEI32_V_M4_M2_MASK + 0U, // PseudoVLOXEI32_V_M4_M4 + 0U, // PseudoVLOXEI32_V_M4_M4_MASK + 0U, // PseudoVLOXEI32_V_M4_M8 + 0U, // PseudoVLOXEI32_V_M4_M8_MASK + 0U, // PseudoVLOXEI32_V_M8_M2 + 0U, // PseudoVLOXEI32_V_M8_M2_MASK + 0U, // PseudoVLOXEI32_V_M8_M4 + 0U, // PseudoVLOXEI32_V_M8_M4_MASK + 0U, // PseudoVLOXEI32_V_M8_M8 + 0U, // PseudoVLOXEI32_V_M8_M8_MASK + 0U, // PseudoVLOXEI32_V_MF2_M1 + 0U, // PseudoVLOXEI32_V_MF2_M1_MASK + 0U, // PseudoVLOXEI32_V_MF2_MF2 + 0U, // PseudoVLOXEI32_V_MF2_MF2_MASK + 0U, // PseudoVLOXEI32_V_MF2_MF4 + 0U, // PseudoVLOXEI32_V_MF2_MF4_MASK + 0U, // PseudoVLOXEI32_V_MF2_MF8 + 0U, // PseudoVLOXEI32_V_MF2_MF8_MASK + 0U, // PseudoVLOXEI64_V_M1_M1 + 0U, // PseudoVLOXEI64_V_M1_M1_MASK + 0U, // PseudoVLOXEI64_V_M1_MF2 + 0U, // PseudoVLOXEI64_V_M1_MF2_MASK + 0U, // PseudoVLOXEI64_V_M1_MF4 + 0U, // PseudoVLOXEI64_V_M1_MF4_MASK + 0U, // PseudoVLOXEI64_V_M1_MF8 + 0U, // PseudoVLOXEI64_V_M1_MF8_MASK + 0U, // PseudoVLOXEI64_V_M2_M1 + 0U, // PseudoVLOXEI64_V_M2_M1_MASK + 0U, // PseudoVLOXEI64_V_M2_M2 + 0U, // PseudoVLOXEI64_V_M2_M2_MASK + 0U, // PseudoVLOXEI64_V_M2_MF2 + 0U, // PseudoVLOXEI64_V_M2_MF2_MASK + 0U, // PseudoVLOXEI64_V_M2_MF4 + 0U, // PseudoVLOXEI64_V_M2_MF4_MASK + 0U, // PseudoVLOXEI64_V_M4_M1 + 0U, // PseudoVLOXEI64_V_M4_M1_MASK + 0U, // PseudoVLOXEI64_V_M4_M2 + 0U, // PseudoVLOXEI64_V_M4_M2_MASK + 0U, // PseudoVLOXEI64_V_M4_M4 + 0U, // PseudoVLOXEI64_V_M4_M4_MASK + 0U, // PseudoVLOXEI64_V_M4_MF2 + 0U, // PseudoVLOXEI64_V_M4_MF2_MASK + 0U, // PseudoVLOXEI64_V_M8_M1 + 0U, // PseudoVLOXEI64_V_M8_M1_MASK + 0U, // PseudoVLOXEI64_V_M8_M2 + 0U, // PseudoVLOXEI64_V_M8_M2_MASK + 0U, // PseudoVLOXEI64_V_M8_M4 + 0U, // PseudoVLOXEI64_V_M8_M4_MASK + 0U, // PseudoVLOXEI64_V_M8_M8 + 0U, // PseudoVLOXEI64_V_M8_M8_MASK + 0U, // PseudoVLOXEI8_V_M1_M1 + 0U, // PseudoVLOXEI8_V_M1_M1_MASK + 0U, // PseudoVLOXEI8_V_M1_M2 + 0U, // PseudoVLOXEI8_V_M1_M2_MASK + 0U, // PseudoVLOXEI8_V_M1_M4 + 0U, // PseudoVLOXEI8_V_M1_M4_MASK + 0U, // PseudoVLOXEI8_V_M1_M8 + 0U, // PseudoVLOXEI8_V_M1_M8_MASK + 0U, // PseudoVLOXEI8_V_M2_M2 + 0U, // PseudoVLOXEI8_V_M2_M2_MASK + 0U, // PseudoVLOXEI8_V_M2_M4 + 0U, // PseudoVLOXEI8_V_M2_M4_MASK + 0U, // PseudoVLOXEI8_V_M2_M8 + 0U, // PseudoVLOXEI8_V_M2_M8_MASK + 0U, // PseudoVLOXEI8_V_M4_M4 + 0U, // PseudoVLOXEI8_V_M4_M4_MASK + 0U, // PseudoVLOXEI8_V_M4_M8 + 0U, // PseudoVLOXEI8_V_M4_M8_MASK + 0U, // PseudoVLOXEI8_V_M8_M8 + 0U, // PseudoVLOXEI8_V_M8_M8_MASK + 0U, // PseudoVLOXEI8_V_MF2_M1 + 0U, // PseudoVLOXEI8_V_MF2_M1_MASK + 0U, // PseudoVLOXEI8_V_MF2_M2 + 0U, // PseudoVLOXEI8_V_MF2_M2_MASK + 0U, // PseudoVLOXEI8_V_MF2_M4 + 0U, // PseudoVLOXEI8_V_MF2_M4_MASK + 0U, // PseudoVLOXEI8_V_MF2_MF2 + 0U, // PseudoVLOXEI8_V_MF2_MF2_MASK + 0U, // PseudoVLOXEI8_V_MF4_M1 + 0U, // PseudoVLOXEI8_V_MF4_M1_MASK + 0U, // PseudoVLOXEI8_V_MF4_M2 + 0U, // PseudoVLOXEI8_V_MF4_M2_MASK + 0U, // PseudoVLOXEI8_V_MF4_MF2 + 0U, // PseudoVLOXEI8_V_MF4_MF2_MASK + 0U, // PseudoVLOXEI8_V_MF4_MF4 + 0U, // PseudoVLOXEI8_V_MF4_MF4_MASK + 0U, // PseudoVLOXEI8_V_MF8_M1 + 0U, // PseudoVLOXEI8_V_MF8_M1_MASK + 0U, // PseudoVLOXEI8_V_MF8_MF2 + 0U, // PseudoVLOXEI8_V_MF8_MF2_MASK + 0U, // PseudoVLOXEI8_V_MF8_MF4 + 0U, // PseudoVLOXEI8_V_MF8_MF4_MASK + 0U, // PseudoVLOXEI8_V_MF8_MF8 + 0U, // PseudoVLOXEI8_V_MF8_MF8_MASK + 0U, // PseudoVLOXSEG2EI16_V_M1_M1 + 0U, // PseudoVLOXSEG2EI16_V_M1_M1_MASK + 0U, // PseudoVLOXSEG2EI16_V_M1_M2 + 0U, // PseudoVLOXSEG2EI16_V_M1_M2_MASK + 0U, // PseudoVLOXSEG2EI16_V_M1_M4 + 0U, // PseudoVLOXSEG2EI16_V_M1_M4_MASK + 0U, // PseudoVLOXSEG2EI16_V_M1_MF2 + 0U, // PseudoVLOXSEG2EI16_V_M1_MF2_MASK + 0U, // PseudoVLOXSEG2EI16_V_M2_M1 + 0U, // PseudoVLOXSEG2EI16_V_M2_M1_MASK + 0U, // PseudoVLOXSEG2EI16_V_M2_M2 + 0U, // PseudoVLOXSEG2EI16_V_M2_M2_MASK + 0U, // PseudoVLOXSEG2EI16_V_M2_M4 + 0U, // PseudoVLOXSEG2EI16_V_M2_M4_MASK + 0U, // PseudoVLOXSEG2EI16_V_M4_M2 + 0U, // PseudoVLOXSEG2EI16_V_M4_M2_MASK + 0U, // PseudoVLOXSEG2EI16_V_M4_M4 + 0U, // PseudoVLOXSEG2EI16_V_M4_M4_MASK + 0U, // PseudoVLOXSEG2EI16_V_M8_M4 + 0U, // PseudoVLOXSEG2EI16_V_M8_M4_MASK + 0U, // PseudoVLOXSEG2EI16_V_MF2_M1 + 0U, // PseudoVLOXSEG2EI16_V_MF2_M1_MASK + 0U, // PseudoVLOXSEG2EI16_V_MF2_M2 + 0U, // PseudoVLOXSEG2EI16_V_MF2_M2_MASK + 0U, // PseudoVLOXSEG2EI16_V_MF2_MF2 + 0U, // PseudoVLOXSEG2EI16_V_MF2_MF2_MASK + 0U, // PseudoVLOXSEG2EI16_V_MF2_MF4 + 0U, // PseudoVLOXSEG2EI16_V_MF2_MF4_MASK + 0U, // PseudoVLOXSEG2EI16_V_MF4_M1 + 0U, // PseudoVLOXSEG2EI16_V_MF4_M1_MASK + 0U, // PseudoVLOXSEG2EI16_V_MF4_MF2 + 0U, // PseudoVLOXSEG2EI16_V_MF4_MF2_MASK + 0U, // PseudoVLOXSEG2EI16_V_MF4_MF4 + 0U, // PseudoVLOXSEG2EI16_V_MF4_MF4_MASK + 0U, // PseudoVLOXSEG2EI16_V_MF4_MF8 + 0U, // PseudoVLOXSEG2EI16_V_MF4_MF8_MASK + 0U, // PseudoVLOXSEG2EI32_V_M1_M1 + 0U, // PseudoVLOXSEG2EI32_V_M1_M1_MASK + 0U, // PseudoVLOXSEG2EI32_V_M1_M2 + 0U, // PseudoVLOXSEG2EI32_V_M1_M2_MASK + 0U, // PseudoVLOXSEG2EI32_V_M1_MF2 + 0U, // PseudoVLOXSEG2EI32_V_M1_MF2_MASK + 0U, // PseudoVLOXSEG2EI32_V_M1_MF4 + 0U, // PseudoVLOXSEG2EI32_V_M1_MF4_MASK + 0U, // PseudoVLOXSEG2EI32_V_M2_M1 + 0U, // PseudoVLOXSEG2EI32_V_M2_M1_MASK + 0U, // PseudoVLOXSEG2EI32_V_M2_M2 + 0U, // PseudoVLOXSEG2EI32_V_M2_M2_MASK + 0U, // PseudoVLOXSEG2EI32_V_M2_M4 + 0U, // PseudoVLOXSEG2EI32_V_M2_M4_MASK + 0U, // PseudoVLOXSEG2EI32_V_M2_MF2 + 0U, // PseudoVLOXSEG2EI32_V_M2_MF2_MASK + 0U, // PseudoVLOXSEG2EI32_V_M4_M1 + 0U, // PseudoVLOXSEG2EI32_V_M4_M1_MASK + 0U, // PseudoVLOXSEG2EI32_V_M4_M2 + 0U, // PseudoVLOXSEG2EI32_V_M4_M2_MASK + 0U, // PseudoVLOXSEG2EI32_V_M4_M4 + 0U, // PseudoVLOXSEG2EI32_V_M4_M4_MASK + 0U, // PseudoVLOXSEG2EI32_V_M8_M2 + 0U, // PseudoVLOXSEG2EI32_V_M8_M2_MASK + 0U, // PseudoVLOXSEG2EI32_V_M8_M4 + 0U, // PseudoVLOXSEG2EI32_V_M8_M4_MASK + 0U, // PseudoVLOXSEG2EI32_V_MF2_M1 + 0U, // PseudoVLOXSEG2EI32_V_MF2_M1_MASK + 0U, // PseudoVLOXSEG2EI32_V_MF2_MF2 + 0U, // PseudoVLOXSEG2EI32_V_MF2_MF2_MASK + 0U, // PseudoVLOXSEG2EI32_V_MF2_MF4 + 0U, // PseudoVLOXSEG2EI32_V_MF2_MF4_MASK + 0U, // PseudoVLOXSEG2EI32_V_MF2_MF8 + 0U, // PseudoVLOXSEG2EI32_V_MF2_MF8_MASK + 0U, // PseudoVLOXSEG2EI64_V_M1_M1 + 0U, // PseudoVLOXSEG2EI64_V_M1_M1_MASK + 0U, // PseudoVLOXSEG2EI64_V_M1_MF2 + 0U, // PseudoVLOXSEG2EI64_V_M1_MF2_MASK + 0U, // PseudoVLOXSEG2EI64_V_M1_MF4 + 0U, // PseudoVLOXSEG2EI64_V_M1_MF4_MASK + 0U, // PseudoVLOXSEG2EI64_V_M1_MF8 + 0U, // PseudoVLOXSEG2EI64_V_M1_MF8_MASK + 0U, // PseudoVLOXSEG2EI64_V_M2_M1 + 0U, // PseudoVLOXSEG2EI64_V_M2_M1_MASK + 0U, // PseudoVLOXSEG2EI64_V_M2_M2 + 0U, // PseudoVLOXSEG2EI64_V_M2_M2_MASK + 0U, // PseudoVLOXSEG2EI64_V_M2_MF2 + 0U, // PseudoVLOXSEG2EI64_V_M2_MF2_MASK + 0U, // PseudoVLOXSEG2EI64_V_M2_MF4 + 0U, // PseudoVLOXSEG2EI64_V_M2_MF4_MASK + 0U, // PseudoVLOXSEG2EI64_V_M4_M1 + 0U, // PseudoVLOXSEG2EI64_V_M4_M1_MASK + 0U, // PseudoVLOXSEG2EI64_V_M4_M2 + 0U, // PseudoVLOXSEG2EI64_V_M4_M2_MASK + 0U, // PseudoVLOXSEG2EI64_V_M4_M4 + 0U, // PseudoVLOXSEG2EI64_V_M4_M4_MASK + 0U, // PseudoVLOXSEG2EI64_V_M4_MF2 + 0U, // PseudoVLOXSEG2EI64_V_M4_MF2_MASK + 0U, // PseudoVLOXSEG2EI64_V_M8_M1 + 0U, // PseudoVLOXSEG2EI64_V_M8_M1_MASK + 0U, // PseudoVLOXSEG2EI64_V_M8_M2 + 0U, // PseudoVLOXSEG2EI64_V_M8_M2_MASK + 0U, // PseudoVLOXSEG2EI64_V_M8_M4 + 0U, // PseudoVLOXSEG2EI64_V_M8_M4_MASK + 0U, // PseudoVLOXSEG2EI8_V_M1_M1 + 0U, // PseudoVLOXSEG2EI8_V_M1_M1_MASK + 0U, // PseudoVLOXSEG2EI8_V_M1_M2 + 0U, // PseudoVLOXSEG2EI8_V_M1_M2_MASK + 0U, // PseudoVLOXSEG2EI8_V_M1_M4 + 0U, // PseudoVLOXSEG2EI8_V_M1_M4_MASK + 0U, // PseudoVLOXSEG2EI8_V_M2_M2 + 0U, // PseudoVLOXSEG2EI8_V_M2_M2_MASK + 0U, // PseudoVLOXSEG2EI8_V_M2_M4 + 0U, // PseudoVLOXSEG2EI8_V_M2_M4_MASK + 0U, // PseudoVLOXSEG2EI8_V_M4_M4 + 0U, // PseudoVLOXSEG2EI8_V_M4_M4_MASK + 0U, // PseudoVLOXSEG2EI8_V_MF2_M1 + 0U, // PseudoVLOXSEG2EI8_V_MF2_M1_MASK + 0U, // PseudoVLOXSEG2EI8_V_MF2_M2 + 0U, // PseudoVLOXSEG2EI8_V_MF2_M2_MASK + 0U, // PseudoVLOXSEG2EI8_V_MF2_M4 + 0U, // PseudoVLOXSEG2EI8_V_MF2_M4_MASK + 0U, // PseudoVLOXSEG2EI8_V_MF2_MF2 + 0U, // PseudoVLOXSEG2EI8_V_MF2_MF2_MASK + 0U, // PseudoVLOXSEG2EI8_V_MF4_M1 + 0U, // PseudoVLOXSEG2EI8_V_MF4_M1_MASK + 0U, // PseudoVLOXSEG2EI8_V_MF4_M2 + 0U, // PseudoVLOXSEG2EI8_V_MF4_M2_MASK + 0U, // PseudoVLOXSEG2EI8_V_MF4_MF2 + 0U, // PseudoVLOXSEG2EI8_V_MF4_MF2_MASK + 0U, // PseudoVLOXSEG2EI8_V_MF4_MF4 + 0U, // PseudoVLOXSEG2EI8_V_MF4_MF4_MASK + 0U, // PseudoVLOXSEG2EI8_V_MF8_M1 + 0U, // PseudoVLOXSEG2EI8_V_MF8_M1_MASK + 0U, // PseudoVLOXSEG2EI8_V_MF8_MF2 + 0U, // PseudoVLOXSEG2EI8_V_MF8_MF2_MASK + 0U, // PseudoVLOXSEG2EI8_V_MF8_MF4 + 0U, // PseudoVLOXSEG2EI8_V_MF8_MF4_MASK + 0U, // PseudoVLOXSEG2EI8_V_MF8_MF8 + 0U, // PseudoVLOXSEG2EI8_V_MF8_MF8_MASK + 0U, // PseudoVLOXSEG3EI16_V_M1_M1 + 0U, // PseudoVLOXSEG3EI16_V_M1_M1_MASK + 0U, // PseudoVLOXSEG3EI16_V_M1_M2 + 0U, // PseudoVLOXSEG3EI16_V_M1_M2_MASK + 0U, // PseudoVLOXSEG3EI16_V_M1_MF2 + 0U, // PseudoVLOXSEG3EI16_V_M1_MF2_MASK + 0U, // PseudoVLOXSEG3EI16_V_M2_M1 + 0U, // PseudoVLOXSEG3EI16_V_M2_M1_MASK + 0U, // PseudoVLOXSEG3EI16_V_M2_M2 + 0U, // PseudoVLOXSEG3EI16_V_M2_M2_MASK + 0U, // PseudoVLOXSEG3EI16_V_M4_M2 + 0U, // PseudoVLOXSEG3EI16_V_M4_M2_MASK + 0U, // PseudoVLOXSEG3EI16_V_MF2_M1 + 0U, // PseudoVLOXSEG3EI16_V_MF2_M1_MASK + 0U, // PseudoVLOXSEG3EI16_V_MF2_M2 + 0U, // PseudoVLOXSEG3EI16_V_MF2_M2_MASK + 0U, // PseudoVLOXSEG3EI16_V_MF2_MF2 + 0U, // PseudoVLOXSEG3EI16_V_MF2_MF2_MASK + 0U, // PseudoVLOXSEG3EI16_V_MF2_MF4 + 0U, // PseudoVLOXSEG3EI16_V_MF2_MF4_MASK + 0U, // PseudoVLOXSEG3EI16_V_MF4_M1 + 0U, // PseudoVLOXSEG3EI16_V_MF4_M1_MASK + 0U, // PseudoVLOXSEG3EI16_V_MF4_MF2 + 0U, // PseudoVLOXSEG3EI16_V_MF4_MF2_MASK + 0U, // PseudoVLOXSEG3EI16_V_MF4_MF4 + 0U, // PseudoVLOXSEG3EI16_V_MF4_MF4_MASK + 0U, // PseudoVLOXSEG3EI16_V_MF4_MF8 + 0U, // PseudoVLOXSEG3EI16_V_MF4_MF8_MASK + 0U, // PseudoVLOXSEG3EI32_V_M1_M1 + 0U, // PseudoVLOXSEG3EI32_V_M1_M1_MASK + 0U, // PseudoVLOXSEG3EI32_V_M1_M2 + 0U, // PseudoVLOXSEG3EI32_V_M1_M2_MASK + 0U, // PseudoVLOXSEG3EI32_V_M1_MF2 + 0U, // PseudoVLOXSEG3EI32_V_M1_MF2_MASK + 0U, // PseudoVLOXSEG3EI32_V_M1_MF4 + 0U, // PseudoVLOXSEG3EI32_V_M1_MF4_MASK + 0U, // PseudoVLOXSEG3EI32_V_M2_M1 + 0U, // PseudoVLOXSEG3EI32_V_M2_M1_MASK + 0U, // PseudoVLOXSEG3EI32_V_M2_M2 + 0U, // PseudoVLOXSEG3EI32_V_M2_M2_MASK + 0U, // PseudoVLOXSEG3EI32_V_M2_MF2 + 0U, // PseudoVLOXSEG3EI32_V_M2_MF2_MASK + 0U, // PseudoVLOXSEG3EI32_V_M4_M1 + 0U, // PseudoVLOXSEG3EI32_V_M4_M1_MASK + 0U, // PseudoVLOXSEG3EI32_V_M4_M2 + 0U, // PseudoVLOXSEG3EI32_V_M4_M2_MASK + 0U, // PseudoVLOXSEG3EI32_V_M8_M2 + 0U, // PseudoVLOXSEG3EI32_V_M8_M2_MASK + 0U, // PseudoVLOXSEG3EI32_V_MF2_M1 + 0U, // PseudoVLOXSEG3EI32_V_MF2_M1_MASK + 0U, // PseudoVLOXSEG3EI32_V_MF2_MF2 + 0U, // PseudoVLOXSEG3EI32_V_MF2_MF2_MASK + 0U, // PseudoVLOXSEG3EI32_V_MF2_MF4 + 0U, // PseudoVLOXSEG3EI32_V_MF2_MF4_MASK + 0U, // PseudoVLOXSEG3EI32_V_MF2_MF8 + 0U, // PseudoVLOXSEG3EI32_V_MF2_MF8_MASK + 0U, // PseudoVLOXSEG3EI64_V_M1_M1 + 0U, // PseudoVLOXSEG3EI64_V_M1_M1_MASK + 0U, // PseudoVLOXSEG3EI64_V_M1_MF2 + 0U, // PseudoVLOXSEG3EI64_V_M1_MF2_MASK + 0U, // PseudoVLOXSEG3EI64_V_M1_MF4 + 0U, // PseudoVLOXSEG3EI64_V_M1_MF4_MASK + 0U, // PseudoVLOXSEG3EI64_V_M1_MF8 + 0U, // PseudoVLOXSEG3EI64_V_M1_MF8_MASK + 0U, // PseudoVLOXSEG3EI64_V_M2_M1 + 0U, // PseudoVLOXSEG3EI64_V_M2_M1_MASK + 0U, // PseudoVLOXSEG3EI64_V_M2_M2 + 0U, // PseudoVLOXSEG3EI64_V_M2_M2_MASK + 0U, // PseudoVLOXSEG3EI64_V_M2_MF2 + 0U, // PseudoVLOXSEG3EI64_V_M2_MF2_MASK + 0U, // PseudoVLOXSEG3EI64_V_M2_MF4 + 0U, // PseudoVLOXSEG3EI64_V_M2_MF4_MASK + 0U, // PseudoVLOXSEG3EI64_V_M4_M1 + 0U, // PseudoVLOXSEG3EI64_V_M4_M1_MASK + 0U, // PseudoVLOXSEG3EI64_V_M4_M2 + 0U, // PseudoVLOXSEG3EI64_V_M4_M2_MASK + 0U, // PseudoVLOXSEG3EI64_V_M4_MF2 + 0U, // PseudoVLOXSEG3EI64_V_M4_MF2_MASK + 0U, // PseudoVLOXSEG3EI64_V_M8_M1 + 0U, // PseudoVLOXSEG3EI64_V_M8_M1_MASK + 0U, // PseudoVLOXSEG3EI64_V_M8_M2 + 0U, // PseudoVLOXSEG3EI64_V_M8_M2_MASK + 0U, // PseudoVLOXSEG3EI8_V_M1_M1 + 0U, // PseudoVLOXSEG3EI8_V_M1_M1_MASK + 0U, // PseudoVLOXSEG3EI8_V_M1_M2 + 0U, // PseudoVLOXSEG3EI8_V_M1_M2_MASK + 0U, // PseudoVLOXSEG3EI8_V_M2_M2 + 0U, // PseudoVLOXSEG3EI8_V_M2_M2_MASK + 0U, // PseudoVLOXSEG3EI8_V_MF2_M1 + 0U, // PseudoVLOXSEG3EI8_V_MF2_M1_MASK + 0U, // PseudoVLOXSEG3EI8_V_MF2_M2 + 0U, // PseudoVLOXSEG3EI8_V_MF2_M2_MASK + 0U, // PseudoVLOXSEG3EI8_V_MF2_MF2 + 0U, // PseudoVLOXSEG3EI8_V_MF2_MF2_MASK + 0U, // PseudoVLOXSEG3EI8_V_MF4_M1 + 0U, // PseudoVLOXSEG3EI8_V_MF4_M1_MASK + 0U, // PseudoVLOXSEG3EI8_V_MF4_M2 + 0U, // PseudoVLOXSEG3EI8_V_MF4_M2_MASK + 0U, // PseudoVLOXSEG3EI8_V_MF4_MF2 + 0U, // PseudoVLOXSEG3EI8_V_MF4_MF2_MASK + 0U, // PseudoVLOXSEG3EI8_V_MF4_MF4 + 0U, // PseudoVLOXSEG3EI8_V_MF4_MF4_MASK + 0U, // PseudoVLOXSEG3EI8_V_MF8_M1 + 0U, // PseudoVLOXSEG3EI8_V_MF8_M1_MASK + 0U, // PseudoVLOXSEG3EI8_V_MF8_MF2 + 0U, // PseudoVLOXSEG3EI8_V_MF8_MF2_MASK + 0U, // PseudoVLOXSEG3EI8_V_MF8_MF4 + 0U, // PseudoVLOXSEG3EI8_V_MF8_MF4_MASK + 0U, // PseudoVLOXSEG3EI8_V_MF8_MF8 + 0U, // PseudoVLOXSEG3EI8_V_MF8_MF8_MASK + 0U, // PseudoVLOXSEG4EI16_V_M1_M1 + 0U, // PseudoVLOXSEG4EI16_V_M1_M1_MASK + 0U, // PseudoVLOXSEG4EI16_V_M1_M2 + 0U, // PseudoVLOXSEG4EI16_V_M1_M2_MASK + 0U, // PseudoVLOXSEG4EI16_V_M1_MF2 + 0U, // PseudoVLOXSEG4EI16_V_M1_MF2_MASK + 0U, // PseudoVLOXSEG4EI16_V_M2_M1 + 0U, // PseudoVLOXSEG4EI16_V_M2_M1_MASK + 0U, // PseudoVLOXSEG4EI16_V_M2_M2 + 0U, // PseudoVLOXSEG4EI16_V_M2_M2_MASK + 0U, // PseudoVLOXSEG4EI16_V_M4_M2 + 0U, // PseudoVLOXSEG4EI16_V_M4_M2_MASK + 0U, // PseudoVLOXSEG4EI16_V_MF2_M1 + 0U, // PseudoVLOXSEG4EI16_V_MF2_M1_MASK + 0U, // PseudoVLOXSEG4EI16_V_MF2_M2 + 0U, // PseudoVLOXSEG4EI16_V_MF2_M2_MASK + 0U, // PseudoVLOXSEG4EI16_V_MF2_MF2 + 0U, // PseudoVLOXSEG4EI16_V_MF2_MF2_MASK + 0U, // PseudoVLOXSEG4EI16_V_MF2_MF4 + 0U, // PseudoVLOXSEG4EI16_V_MF2_MF4_MASK + 0U, // PseudoVLOXSEG4EI16_V_MF4_M1 + 0U, // PseudoVLOXSEG4EI16_V_MF4_M1_MASK + 0U, // PseudoVLOXSEG4EI16_V_MF4_MF2 + 0U, // PseudoVLOXSEG4EI16_V_MF4_MF2_MASK + 0U, // PseudoVLOXSEG4EI16_V_MF4_MF4 + 0U, // PseudoVLOXSEG4EI16_V_MF4_MF4_MASK + 0U, // PseudoVLOXSEG4EI16_V_MF4_MF8 + 0U, // PseudoVLOXSEG4EI16_V_MF4_MF8_MASK + 0U, // PseudoVLOXSEG4EI32_V_M1_M1 + 0U, // PseudoVLOXSEG4EI32_V_M1_M1_MASK + 0U, // PseudoVLOXSEG4EI32_V_M1_M2 + 0U, // PseudoVLOXSEG4EI32_V_M1_M2_MASK + 0U, // PseudoVLOXSEG4EI32_V_M1_MF2 + 0U, // PseudoVLOXSEG4EI32_V_M1_MF2_MASK + 0U, // PseudoVLOXSEG4EI32_V_M1_MF4 + 0U, // PseudoVLOXSEG4EI32_V_M1_MF4_MASK + 0U, // PseudoVLOXSEG4EI32_V_M2_M1 + 0U, // PseudoVLOXSEG4EI32_V_M2_M1_MASK + 0U, // PseudoVLOXSEG4EI32_V_M2_M2 + 0U, // PseudoVLOXSEG4EI32_V_M2_M2_MASK + 0U, // PseudoVLOXSEG4EI32_V_M2_MF2 + 0U, // PseudoVLOXSEG4EI32_V_M2_MF2_MASK + 0U, // PseudoVLOXSEG4EI32_V_M4_M1 + 0U, // PseudoVLOXSEG4EI32_V_M4_M1_MASK + 0U, // PseudoVLOXSEG4EI32_V_M4_M2 + 0U, // PseudoVLOXSEG4EI32_V_M4_M2_MASK + 0U, // PseudoVLOXSEG4EI32_V_M8_M2 + 0U, // PseudoVLOXSEG4EI32_V_M8_M2_MASK + 0U, // PseudoVLOXSEG4EI32_V_MF2_M1 + 0U, // PseudoVLOXSEG4EI32_V_MF2_M1_MASK + 0U, // PseudoVLOXSEG4EI32_V_MF2_MF2 + 0U, // PseudoVLOXSEG4EI32_V_MF2_MF2_MASK + 0U, // PseudoVLOXSEG4EI32_V_MF2_MF4 + 0U, // PseudoVLOXSEG4EI32_V_MF2_MF4_MASK + 0U, // PseudoVLOXSEG4EI32_V_MF2_MF8 + 0U, // PseudoVLOXSEG4EI32_V_MF2_MF8_MASK + 0U, // PseudoVLOXSEG4EI64_V_M1_M1 + 0U, // PseudoVLOXSEG4EI64_V_M1_M1_MASK + 0U, // PseudoVLOXSEG4EI64_V_M1_MF2 + 0U, // PseudoVLOXSEG4EI64_V_M1_MF2_MASK + 0U, // PseudoVLOXSEG4EI64_V_M1_MF4 + 0U, // PseudoVLOXSEG4EI64_V_M1_MF4_MASK + 0U, // PseudoVLOXSEG4EI64_V_M1_MF8 + 0U, // PseudoVLOXSEG4EI64_V_M1_MF8_MASK + 0U, // PseudoVLOXSEG4EI64_V_M2_M1 + 0U, // PseudoVLOXSEG4EI64_V_M2_M1_MASK + 0U, // PseudoVLOXSEG4EI64_V_M2_M2 + 0U, // PseudoVLOXSEG4EI64_V_M2_M2_MASK + 0U, // PseudoVLOXSEG4EI64_V_M2_MF2 + 0U, // PseudoVLOXSEG4EI64_V_M2_MF2_MASK + 0U, // PseudoVLOXSEG4EI64_V_M2_MF4 + 0U, // PseudoVLOXSEG4EI64_V_M2_MF4_MASK + 0U, // PseudoVLOXSEG4EI64_V_M4_M1 + 0U, // PseudoVLOXSEG4EI64_V_M4_M1_MASK + 0U, // PseudoVLOXSEG4EI64_V_M4_M2 + 0U, // PseudoVLOXSEG4EI64_V_M4_M2_MASK + 0U, // PseudoVLOXSEG4EI64_V_M4_MF2 + 0U, // PseudoVLOXSEG4EI64_V_M4_MF2_MASK + 0U, // PseudoVLOXSEG4EI64_V_M8_M1 + 0U, // PseudoVLOXSEG4EI64_V_M8_M1_MASK + 0U, // PseudoVLOXSEG4EI64_V_M8_M2 + 0U, // PseudoVLOXSEG4EI64_V_M8_M2_MASK + 0U, // PseudoVLOXSEG4EI8_V_M1_M1 + 0U, // PseudoVLOXSEG4EI8_V_M1_M1_MASK + 0U, // PseudoVLOXSEG4EI8_V_M1_M2 + 0U, // PseudoVLOXSEG4EI8_V_M1_M2_MASK + 0U, // PseudoVLOXSEG4EI8_V_M2_M2 + 0U, // PseudoVLOXSEG4EI8_V_M2_M2_MASK + 0U, // PseudoVLOXSEG4EI8_V_MF2_M1 + 0U, // PseudoVLOXSEG4EI8_V_MF2_M1_MASK + 0U, // PseudoVLOXSEG4EI8_V_MF2_M2 + 0U, // PseudoVLOXSEG4EI8_V_MF2_M2_MASK + 0U, // PseudoVLOXSEG4EI8_V_MF2_MF2 + 0U, // PseudoVLOXSEG4EI8_V_MF2_MF2_MASK + 0U, // PseudoVLOXSEG4EI8_V_MF4_M1 + 0U, // PseudoVLOXSEG4EI8_V_MF4_M1_MASK + 0U, // PseudoVLOXSEG4EI8_V_MF4_M2 + 0U, // PseudoVLOXSEG4EI8_V_MF4_M2_MASK + 0U, // PseudoVLOXSEG4EI8_V_MF4_MF2 + 0U, // PseudoVLOXSEG4EI8_V_MF4_MF2_MASK + 0U, // PseudoVLOXSEG4EI8_V_MF4_MF4 + 0U, // PseudoVLOXSEG4EI8_V_MF4_MF4_MASK + 0U, // PseudoVLOXSEG4EI8_V_MF8_M1 + 0U, // PseudoVLOXSEG4EI8_V_MF8_M1_MASK + 0U, // PseudoVLOXSEG4EI8_V_MF8_MF2 + 0U, // PseudoVLOXSEG4EI8_V_MF8_MF2_MASK + 0U, // PseudoVLOXSEG4EI8_V_MF8_MF4 + 0U, // PseudoVLOXSEG4EI8_V_MF8_MF4_MASK + 0U, // PseudoVLOXSEG4EI8_V_MF8_MF8 + 0U, // PseudoVLOXSEG4EI8_V_MF8_MF8_MASK + 0U, // PseudoVLOXSEG5EI16_V_M1_M1 + 0U, // PseudoVLOXSEG5EI16_V_M1_M1_MASK + 0U, // PseudoVLOXSEG5EI16_V_M1_MF2 + 0U, // PseudoVLOXSEG5EI16_V_M1_MF2_MASK + 0U, // PseudoVLOXSEG5EI16_V_M2_M1 + 0U, // PseudoVLOXSEG5EI16_V_M2_M1_MASK + 0U, // PseudoVLOXSEG5EI16_V_MF2_M1 + 0U, // PseudoVLOXSEG5EI16_V_MF2_M1_MASK + 0U, // PseudoVLOXSEG5EI16_V_MF2_MF2 + 0U, // PseudoVLOXSEG5EI16_V_MF2_MF2_MASK + 0U, // PseudoVLOXSEG5EI16_V_MF2_MF4 + 0U, // PseudoVLOXSEG5EI16_V_MF2_MF4_MASK + 0U, // PseudoVLOXSEG5EI16_V_MF4_M1 + 0U, // PseudoVLOXSEG5EI16_V_MF4_M1_MASK + 0U, // PseudoVLOXSEG5EI16_V_MF4_MF2 + 0U, // PseudoVLOXSEG5EI16_V_MF4_MF2_MASK + 0U, // PseudoVLOXSEG5EI16_V_MF4_MF4 + 0U, // PseudoVLOXSEG5EI16_V_MF4_MF4_MASK + 0U, // PseudoVLOXSEG5EI16_V_MF4_MF8 + 0U, // PseudoVLOXSEG5EI16_V_MF4_MF8_MASK + 0U, // PseudoVLOXSEG5EI32_V_M1_M1 + 0U, // PseudoVLOXSEG5EI32_V_M1_M1_MASK + 0U, // PseudoVLOXSEG5EI32_V_M1_MF2 + 0U, // PseudoVLOXSEG5EI32_V_M1_MF2_MASK + 0U, // PseudoVLOXSEG5EI32_V_M1_MF4 + 0U, // PseudoVLOXSEG5EI32_V_M1_MF4_MASK + 0U, // PseudoVLOXSEG5EI32_V_M2_M1 + 0U, // PseudoVLOXSEG5EI32_V_M2_M1_MASK + 0U, // PseudoVLOXSEG5EI32_V_M2_MF2 + 0U, // PseudoVLOXSEG5EI32_V_M2_MF2_MASK + 0U, // PseudoVLOXSEG5EI32_V_M4_M1 + 0U, // PseudoVLOXSEG5EI32_V_M4_M1_MASK + 0U, // PseudoVLOXSEG5EI32_V_MF2_M1 + 0U, // PseudoVLOXSEG5EI32_V_MF2_M1_MASK + 0U, // PseudoVLOXSEG5EI32_V_MF2_MF2 + 0U, // PseudoVLOXSEG5EI32_V_MF2_MF2_MASK + 0U, // PseudoVLOXSEG5EI32_V_MF2_MF4 + 0U, // PseudoVLOXSEG5EI32_V_MF2_MF4_MASK + 0U, // PseudoVLOXSEG5EI32_V_MF2_MF8 + 0U, // PseudoVLOXSEG5EI32_V_MF2_MF8_MASK + 0U, // PseudoVLOXSEG5EI64_V_M1_M1 + 0U, // PseudoVLOXSEG5EI64_V_M1_M1_MASK + 0U, // PseudoVLOXSEG5EI64_V_M1_MF2 + 0U, // PseudoVLOXSEG5EI64_V_M1_MF2_MASK + 0U, // PseudoVLOXSEG5EI64_V_M1_MF4 + 0U, // PseudoVLOXSEG5EI64_V_M1_MF4_MASK + 0U, // PseudoVLOXSEG5EI64_V_M1_MF8 + 0U, // PseudoVLOXSEG5EI64_V_M1_MF8_MASK + 0U, // PseudoVLOXSEG5EI64_V_M2_M1 + 0U, // PseudoVLOXSEG5EI64_V_M2_M1_MASK + 0U, // PseudoVLOXSEG5EI64_V_M2_MF2 + 0U, // PseudoVLOXSEG5EI64_V_M2_MF2_MASK + 0U, // PseudoVLOXSEG5EI64_V_M2_MF4 + 0U, // PseudoVLOXSEG5EI64_V_M2_MF4_MASK + 0U, // PseudoVLOXSEG5EI64_V_M4_M1 + 0U, // PseudoVLOXSEG5EI64_V_M4_M1_MASK + 0U, // PseudoVLOXSEG5EI64_V_M4_MF2 + 0U, // PseudoVLOXSEG5EI64_V_M4_MF2_MASK + 0U, // PseudoVLOXSEG5EI64_V_M8_M1 + 0U, // PseudoVLOXSEG5EI64_V_M8_M1_MASK + 0U, // PseudoVLOXSEG5EI8_V_M1_M1 + 0U, // PseudoVLOXSEG5EI8_V_M1_M1_MASK + 0U, // PseudoVLOXSEG5EI8_V_MF2_M1 + 0U, // PseudoVLOXSEG5EI8_V_MF2_M1_MASK + 0U, // PseudoVLOXSEG5EI8_V_MF2_MF2 + 0U, // PseudoVLOXSEG5EI8_V_MF2_MF2_MASK + 0U, // PseudoVLOXSEG5EI8_V_MF4_M1 + 0U, // PseudoVLOXSEG5EI8_V_MF4_M1_MASK + 0U, // PseudoVLOXSEG5EI8_V_MF4_MF2 + 0U, // PseudoVLOXSEG5EI8_V_MF4_MF2_MASK + 0U, // PseudoVLOXSEG5EI8_V_MF4_MF4 + 0U, // PseudoVLOXSEG5EI8_V_MF4_MF4_MASK + 0U, // PseudoVLOXSEG5EI8_V_MF8_M1 + 0U, // PseudoVLOXSEG5EI8_V_MF8_M1_MASK + 0U, // PseudoVLOXSEG5EI8_V_MF8_MF2 + 0U, // PseudoVLOXSEG5EI8_V_MF8_MF2_MASK + 0U, // PseudoVLOXSEG5EI8_V_MF8_MF4 + 0U, // PseudoVLOXSEG5EI8_V_MF8_MF4_MASK + 0U, // PseudoVLOXSEG5EI8_V_MF8_MF8 + 0U, // PseudoVLOXSEG5EI8_V_MF8_MF8_MASK + 0U, // PseudoVLOXSEG6EI16_V_M1_M1 + 0U, // PseudoVLOXSEG6EI16_V_M1_M1_MASK + 0U, // PseudoVLOXSEG6EI16_V_M1_MF2 + 0U, // PseudoVLOXSEG6EI16_V_M1_MF2_MASK + 0U, // PseudoVLOXSEG6EI16_V_M2_M1 + 0U, // PseudoVLOXSEG6EI16_V_M2_M1_MASK + 0U, // PseudoVLOXSEG6EI16_V_MF2_M1 + 0U, // PseudoVLOXSEG6EI16_V_MF2_M1_MASK + 0U, // PseudoVLOXSEG6EI16_V_MF2_MF2 + 0U, // PseudoVLOXSEG6EI16_V_MF2_MF2_MASK + 0U, // PseudoVLOXSEG6EI16_V_MF2_MF4 + 0U, // PseudoVLOXSEG6EI16_V_MF2_MF4_MASK + 0U, // PseudoVLOXSEG6EI16_V_MF4_M1 + 0U, // PseudoVLOXSEG6EI16_V_MF4_M1_MASK + 0U, // PseudoVLOXSEG6EI16_V_MF4_MF2 + 0U, // PseudoVLOXSEG6EI16_V_MF4_MF2_MASK + 0U, // PseudoVLOXSEG6EI16_V_MF4_MF4 + 0U, // PseudoVLOXSEG6EI16_V_MF4_MF4_MASK + 0U, // PseudoVLOXSEG6EI16_V_MF4_MF8 + 0U, // PseudoVLOXSEG6EI16_V_MF4_MF8_MASK + 0U, // PseudoVLOXSEG6EI32_V_M1_M1 + 0U, // PseudoVLOXSEG6EI32_V_M1_M1_MASK + 0U, // PseudoVLOXSEG6EI32_V_M1_MF2 + 0U, // PseudoVLOXSEG6EI32_V_M1_MF2_MASK + 0U, // PseudoVLOXSEG6EI32_V_M1_MF4 + 0U, // PseudoVLOXSEG6EI32_V_M1_MF4_MASK + 0U, // PseudoVLOXSEG6EI32_V_M2_M1 + 0U, // PseudoVLOXSEG6EI32_V_M2_M1_MASK + 0U, // PseudoVLOXSEG6EI32_V_M2_MF2 + 0U, // PseudoVLOXSEG6EI32_V_M2_MF2_MASK + 0U, // PseudoVLOXSEG6EI32_V_M4_M1 + 0U, // PseudoVLOXSEG6EI32_V_M4_M1_MASK + 0U, // PseudoVLOXSEG6EI32_V_MF2_M1 + 0U, // PseudoVLOXSEG6EI32_V_MF2_M1_MASK + 0U, // PseudoVLOXSEG6EI32_V_MF2_MF2 + 0U, // PseudoVLOXSEG6EI32_V_MF2_MF2_MASK + 0U, // PseudoVLOXSEG6EI32_V_MF2_MF4 + 0U, // PseudoVLOXSEG6EI32_V_MF2_MF4_MASK + 0U, // PseudoVLOXSEG6EI32_V_MF2_MF8 + 0U, // PseudoVLOXSEG6EI32_V_MF2_MF8_MASK + 0U, // PseudoVLOXSEG6EI64_V_M1_M1 + 0U, // PseudoVLOXSEG6EI64_V_M1_M1_MASK + 0U, // PseudoVLOXSEG6EI64_V_M1_MF2 + 0U, // PseudoVLOXSEG6EI64_V_M1_MF2_MASK + 0U, // PseudoVLOXSEG6EI64_V_M1_MF4 + 0U, // PseudoVLOXSEG6EI64_V_M1_MF4_MASK + 0U, // PseudoVLOXSEG6EI64_V_M1_MF8 + 0U, // PseudoVLOXSEG6EI64_V_M1_MF8_MASK + 0U, // PseudoVLOXSEG6EI64_V_M2_M1 + 0U, // PseudoVLOXSEG6EI64_V_M2_M1_MASK + 0U, // PseudoVLOXSEG6EI64_V_M2_MF2 + 0U, // PseudoVLOXSEG6EI64_V_M2_MF2_MASK + 0U, // PseudoVLOXSEG6EI64_V_M2_MF4 + 0U, // PseudoVLOXSEG6EI64_V_M2_MF4_MASK + 0U, // PseudoVLOXSEG6EI64_V_M4_M1 + 0U, // PseudoVLOXSEG6EI64_V_M4_M1_MASK + 0U, // PseudoVLOXSEG6EI64_V_M4_MF2 + 0U, // PseudoVLOXSEG6EI64_V_M4_MF2_MASK + 0U, // PseudoVLOXSEG6EI64_V_M8_M1 + 0U, // PseudoVLOXSEG6EI64_V_M8_M1_MASK + 0U, // PseudoVLOXSEG6EI8_V_M1_M1 + 0U, // PseudoVLOXSEG6EI8_V_M1_M1_MASK + 0U, // PseudoVLOXSEG6EI8_V_MF2_M1 + 0U, // PseudoVLOXSEG6EI8_V_MF2_M1_MASK + 0U, // PseudoVLOXSEG6EI8_V_MF2_MF2 + 0U, // PseudoVLOXSEG6EI8_V_MF2_MF2_MASK + 0U, // PseudoVLOXSEG6EI8_V_MF4_M1 + 0U, // PseudoVLOXSEG6EI8_V_MF4_M1_MASK + 0U, // PseudoVLOXSEG6EI8_V_MF4_MF2 + 0U, // PseudoVLOXSEG6EI8_V_MF4_MF2_MASK + 0U, // PseudoVLOXSEG6EI8_V_MF4_MF4 + 0U, // PseudoVLOXSEG6EI8_V_MF4_MF4_MASK + 0U, // PseudoVLOXSEG6EI8_V_MF8_M1 + 0U, // PseudoVLOXSEG6EI8_V_MF8_M1_MASK + 0U, // PseudoVLOXSEG6EI8_V_MF8_MF2 + 0U, // PseudoVLOXSEG6EI8_V_MF8_MF2_MASK + 0U, // PseudoVLOXSEG6EI8_V_MF8_MF4 + 0U, // PseudoVLOXSEG6EI8_V_MF8_MF4_MASK + 0U, // PseudoVLOXSEG6EI8_V_MF8_MF8 + 0U, // PseudoVLOXSEG6EI8_V_MF8_MF8_MASK + 0U, // PseudoVLOXSEG7EI16_V_M1_M1 + 0U, // PseudoVLOXSEG7EI16_V_M1_M1_MASK + 0U, // PseudoVLOXSEG7EI16_V_M1_MF2 + 0U, // PseudoVLOXSEG7EI16_V_M1_MF2_MASK + 0U, // PseudoVLOXSEG7EI16_V_M2_M1 + 0U, // PseudoVLOXSEG7EI16_V_M2_M1_MASK + 0U, // PseudoVLOXSEG7EI16_V_MF2_M1 + 0U, // PseudoVLOXSEG7EI16_V_MF2_M1_MASK + 0U, // PseudoVLOXSEG7EI16_V_MF2_MF2 + 0U, // PseudoVLOXSEG7EI16_V_MF2_MF2_MASK + 0U, // PseudoVLOXSEG7EI16_V_MF2_MF4 + 0U, // PseudoVLOXSEG7EI16_V_MF2_MF4_MASK + 0U, // PseudoVLOXSEG7EI16_V_MF4_M1 + 0U, // PseudoVLOXSEG7EI16_V_MF4_M1_MASK + 0U, // PseudoVLOXSEG7EI16_V_MF4_MF2 + 0U, // PseudoVLOXSEG7EI16_V_MF4_MF2_MASK + 0U, // PseudoVLOXSEG7EI16_V_MF4_MF4 + 0U, // PseudoVLOXSEG7EI16_V_MF4_MF4_MASK + 0U, // PseudoVLOXSEG7EI16_V_MF4_MF8 + 0U, // PseudoVLOXSEG7EI16_V_MF4_MF8_MASK + 0U, // PseudoVLOXSEG7EI32_V_M1_M1 + 0U, // PseudoVLOXSEG7EI32_V_M1_M1_MASK + 0U, // PseudoVLOXSEG7EI32_V_M1_MF2 + 0U, // PseudoVLOXSEG7EI32_V_M1_MF2_MASK + 0U, // PseudoVLOXSEG7EI32_V_M1_MF4 + 0U, // PseudoVLOXSEG7EI32_V_M1_MF4_MASK + 0U, // PseudoVLOXSEG7EI32_V_M2_M1 + 0U, // PseudoVLOXSEG7EI32_V_M2_M1_MASK + 0U, // PseudoVLOXSEG7EI32_V_M2_MF2 + 0U, // PseudoVLOXSEG7EI32_V_M2_MF2_MASK + 0U, // PseudoVLOXSEG7EI32_V_M4_M1 + 0U, // PseudoVLOXSEG7EI32_V_M4_M1_MASK + 0U, // PseudoVLOXSEG7EI32_V_MF2_M1 + 0U, // PseudoVLOXSEG7EI32_V_MF2_M1_MASK + 0U, // PseudoVLOXSEG7EI32_V_MF2_MF2 + 0U, // PseudoVLOXSEG7EI32_V_MF2_MF2_MASK + 0U, // PseudoVLOXSEG7EI32_V_MF2_MF4 + 0U, // PseudoVLOXSEG7EI32_V_MF2_MF4_MASK + 0U, // PseudoVLOXSEG7EI32_V_MF2_MF8 + 0U, // PseudoVLOXSEG7EI32_V_MF2_MF8_MASK + 0U, // PseudoVLOXSEG7EI64_V_M1_M1 + 0U, // PseudoVLOXSEG7EI64_V_M1_M1_MASK + 0U, // PseudoVLOXSEG7EI64_V_M1_MF2 + 0U, // PseudoVLOXSEG7EI64_V_M1_MF2_MASK + 0U, // PseudoVLOXSEG7EI64_V_M1_MF4 + 0U, // PseudoVLOXSEG7EI64_V_M1_MF4_MASK + 0U, // PseudoVLOXSEG7EI64_V_M1_MF8 + 0U, // PseudoVLOXSEG7EI64_V_M1_MF8_MASK + 0U, // PseudoVLOXSEG7EI64_V_M2_M1 + 0U, // PseudoVLOXSEG7EI64_V_M2_M1_MASK + 0U, // PseudoVLOXSEG7EI64_V_M2_MF2 + 0U, // PseudoVLOXSEG7EI64_V_M2_MF2_MASK + 0U, // PseudoVLOXSEG7EI64_V_M2_MF4 + 0U, // PseudoVLOXSEG7EI64_V_M2_MF4_MASK + 0U, // PseudoVLOXSEG7EI64_V_M4_M1 + 0U, // PseudoVLOXSEG7EI64_V_M4_M1_MASK + 0U, // PseudoVLOXSEG7EI64_V_M4_MF2 + 0U, // PseudoVLOXSEG7EI64_V_M4_MF2_MASK + 0U, // PseudoVLOXSEG7EI64_V_M8_M1 + 0U, // PseudoVLOXSEG7EI64_V_M8_M1_MASK + 0U, // PseudoVLOXSEG7EI8_V_M1_M1 + 0U, // PseudoVLOXSEG7EI8_V_M1_M1_MASK + 0U, // PseudoVLOXSEG7EI8_V_MF2_M1 + 0U, // PseudoVLOXSEG7EI8_V_MF2_M1_MASK + 0U, // PseudoVLOXSEG7EI8_V_MF2_MF2 + 0U, // PseudoVLOXSEG7EI8_V_MF2_MF2_MASK + 0U, // PseudoVLOXSEG7EI8_V_MF4_M1 + 0U, // PseudoVLOXSEG7EI8_V_MF4_M1_MASK + 0U, // PseudoVLOXSEG7EI8_V_MF4_MF2 + 0U, // PseudoVLOXSEG7EI8_V_MF4_MF2_MASK + 0U, // PseudoVLOXSEG7EI8_V_MF4_MF4 + 0U, // PseudoVLOXSEG7EI8_V_MF4_MF4_MASK + 0U, // PseudoVLOXSEG7EI8_V_MF8_M1 + 0U, // PseudoVLOXSEG7EI8_V_MF8_M1_MASK + 0U, // PseudoVLOXSEG7EI8_V_MF8_MF2 + 0U, // PseudoVLOXSEG7EI8_V_MF8_MF2_MASK + 0U, // PseudoVLOXSEG7EI8_V_MF8_MF4 + 0U, // PseudoVLOXSEG7EI8_V_MF8_MF4_MASK + 0U, // PseudoVLOXSEG7EI8_V_MF8_MF8 + 0U, // PseudoVLOXSEG7EI8_V_MF8_MF8_MASK + 0U, // PseudoVLOXSEG8EI16_V_M1_M1 + 0U, // PseudoVLOXSEG8EI16_V_M1_M1_MASK + 0U, // PseudoVLOXSEG8EI16_V_M1_MF2 + 0U, // PseudoVLOXSEG8EI16_V_M1_MF2_MASK + 0U, // PseudoVLOXSEG8EI16_V_M2_M1 + 0U, // PseudoVLOXSEG8EI16_V_M2_M1_MASK + 0U, // PseudoVLOXSEG8EI16_V_MF2_M1 + 0U, // PseudoVLOXSEG8EI16_V_MF2_M1_MASK + 0U, // PseudoVLOXSEG8EI16_V_MF2_MF2 + 0U, // PseudoVLOXSEG8EI16_V_MF2_MF2_MASK + 0U, // PseudoVLOXSEG8EI16_V_MF2_MF4 + 0U, // PseudoVLOXSEG8EI16_V_MF2_MF4_MASK + 0U, // PseudoVLOXSEG8EI16_V_MF4_M1 + 0U, // PseudoVLOXSEG8EI16_V_MF4_M1_MASK + 0U, // PseudoVLOXSEG8EI16_V_MF4_MF2 + 0U, // PseudoVLOXSEG8EI16_V_MF4_MF2_MASK + 0U, // PseudoVLOXSEG8EI16_V_MF4_MF4 + 0U, // PseudoVLOXSEG8EI16_V_MF4_MF4_MASK + 0U, // PseudoVLOXSEG8EI16_V_MF4_MF8 + 0U, // PseudoVLOXSEG8EI16_V_MF4_MF8_MASK + 0U, // PseudoVLOXSEG8EI32_V_M1_M1 + 0U, // PseudoVLOXSEG8EI32_V_M1_M1_MASK + 0U, // PseudoVLOXSEG8EI32_V_M1_MF2 + 0U, // PseudoVLOXSEG8EI32_V_M1_MF2_MASK + 0U, // PseudoVLOXSEG8EI32_V_M1_MF4 + 0U, // PseudoVLOXSEG8EI32_V_M1_MF4_MASK + 0U, // PseudoVLOXSEG8EI32_V_M2_M1 + 0U, // PseudoVLOXSEG8EI32_V_M2_M1_MASK + 0U, // PseudoVLOXSEG8EI32_V_M2_MF2 + 0U, // PseudoVLOXSEG8EI32_V_M2_MF2_MASK + 0U, // PseudoVLOXSEG8EI32_V_M4_M1 + 0U, // PseudoVLOXSEG8EI32_V_M4_M1_MASK + 0U, // PseudoVLOXSEG8EI32_V_MF2_M1 + 0U, // PseudoVLOXSEG8EI32_V_MF2_M1_MASK + 0U, // PseudoVLOXSEG8EI32_V_MF2_MF2 + 0U, // PseudoVLOXSEG8EI32_V_MF2_MF2_MASK + 0U, // PseudoVLOXSEG8EI32_V_MF2_MF4 + 0U, // PseudoVLOXSEG8EI32_V_MF2_MF4_MASK + 0U, // PseudoVLOXSEG8EI32_V_MF2_MF8 + 0U, // PseudoVLOXSEG8EI32_V_MF2_MF8_MASK + 0U, // PseudoVLOXSEG8EI64_V_M1_M1 + 0U, // PseudoVLOXSEG8EI64_V_M1_M1_MASK + 0U, // PseudoVLOXSEG8EI64_V_M1_MF2 + 0U, // PseudoVLOXSEG8EI64_V_M1_MF2_MASK + 0U, // PseudoVLOXSEG8EI64_V_M1_MF4 + 0U, // PseudoVLOXSEG8EI64_V_M1_MF4_MASK + 0U, // PseudoVLOXSEG8EI64_V_M1_MF8 + 0U, // PseudoVLOXSEG8EI64_V_M1_MF8_MASK + 0U, // PseudoVLOXSEG8EI64_V_M2_M1 + 0U, // PseudoVLOXSEG8EI64_V_M2_M1_MASK + 0U, // PseudoVLOXSEG8EI64_V_M2_MF2 + 0U, // PseudoVLOXSEG8EI64_V_M2_MF2_MASK + 0U, // PseudoVLOXSEG8EI64_V_M2_MF4 + 0U, // PseudoVLOXSEG8EI64_V_M2_MF4_MASK + 0U, // PseudoVLOXSEG8EI64_V_M4_M1 + 0U, // PseudoVLOXSEG8EI64_V_M4_M1_MASK + 0U, // PseudoVLOXSEG8EI64_V_M4_MF2 + 0U, // PseudoVLOXSEG8EI64_V_M4_MF2_MASK + 0U, // PseudoVLOXSEG8EI64_V_M8_M1 + 0U, // PseudoVLOXSEG8EI64_V_M8_M1_MASK + 0U, // PseudoVLOXSEG8EI8_V_M1_M1 + 0U, // PseudoVLOXSEG8EI8_V_M1_M1_MASK + 0U, // PseudoVLOXSEG8EI8_V_MF2_M1 + 0U, // PseudoVLOXSEG8EI8_V_MF2_M1_MASK + 0U, // PseudoVLOXSEG8EI8_V_MF2_MF2 + 0U, // PseudoVLOXSEG8EI8_V_MF2_MF2_MASK + 0U, // PseudoVLOXSEG8EI8_V_MF4_M1 + 0U, // PseudoVLOXSEG8EI8_V_MF4_M1_MASK + 0U, // PseudoVLOXSEG8EI8_V_MF4_MF2 + 0U, // PseudoVLOXSEG8EI8_V_MF4_MF2_MASK + 0U, // PseudoVLOXSEG8EI8_V_MF4_MF4 + 0U, // PseudoVLOXSEG8EI8_V_MF4_MF4_MASK + 0U, // PseudoVLOXSEG8EI8_V_MF8_M1 + 0U, // PseudoVLOXSEG8EI8_V_MF8_M1_MASK + 0U, // PseudoVLOXSEG8EI8_V_MF8_MF2 + 0U, // PseudoVLOXSEG8EI8_V_MF8_MF2_MASK + 0U, // PseudoVLOXSEG8EI8_V_MF8_MF4 + 0U, // PseudoVLOXSEG8EI8_V_MF8_MF4_MASK + 0U, // PseudoVLOXSEG8EI8_V_MF8_MF8 + 0U, // PseudoVLOXSEG8EI8_V_MF8_MF8_MASK + 0U, // PseudoVLSE16_V_M1 + 0U, // PseudoVLSE16_V_M1_MASK + 0U, // PseudoVLSE16_V_M2 + 0U, // PseudoVLSE16_V_M2_MASK + 0U, // PseudoVLSE16_V_M4 + 0U, // PseudoVLSE16_V_M4_MASK + 0U, // PseudoVLSE16_V_M8 + 0U, // PseudoVLSE16_V_M8_MASK + 0U, // PseudoVLSE16_V_MF2 + 0U, // PseudoVLSE16_V_MF2_MASK + 0U, // PseudoVLSE16_V_MF4 + 0U, // PseudoVLSE16_V_MF4_MASK + 0U, // PseudoVLSE32_V_M1 + 0U, // PseudoVLSE32_V_M1_MASK + 0U, // PseudoVLSE32_V_M2 + 0U, // PseudoVLSE32_V_M2_MASK + 0U, // PseudoVLSE32_V_M4 + 0U, // PseudoVLSE32_V_M4_MASK + 0U, // PseudoVLSE32_V_M8 + 0U, // PseudoVLSE32_V_M8_MASK + 0U, // PseudoVLSE32_V_MF2 + 0U, // PseudoVLSE32_V_MF2_MASK + 0U, // PseudoVLSE64_V_M1 + 0U, // PseudoVLSE64_V_M1_MASK + 0U, // PseudoVLSE64_V_M2 + 0U, // PseudoVLSE64_V_M2_MASK + 0U, // PseudoVLSE64_V_M4 + 0U, // PseudoVLSE64_V_M4_MASK + 0U, // PseudoVLSE64_V_M8 + 0U, // PseudoVLSE64_V_M8_MASK + 0U, // PseudoVLSE8_V_M1 + 0U, // PseudoVLSE8_V_M1_MASK + 0U, // PseudoVLSE8_V_M2 + 0U, // PseudoVLSE8_V_M2_MASK + 0U, // PseudoVLSE8_V_M4 + 0U, // PseudoVLSE8_V_M4_MASK + 0U, // PseudoVLSE8_V_M8 + 0U, // PseudoVLSE8_V_M8_MASK + 0U, // PseudoVLSE8_V_MF2 + 0U, // PseudoVLSE8_V_MF2_MASK + 0U, // PseudoVLSE8_V_MF4 + 0U, // PseudoVLSE8_V_MF4_MASK + 0U, // PseudoVLSE8_V_MF8 + 0U, // PseudoVLSE8_V_MF8_MASK + 0U, // PseudoVLSEG2E16FF_V_M1 + 0U, // PseudoVLSEG2E16FF_V_M1_MASK + 0U, // PseudoVLSEG2E16FF_V_M2 + 0U, // PseudoVLSEG2E16FF_V_M2_MASK + 0U, // PseudoVLSEG2E16FF_V_M4 + 0U, // PseudoVLSEG2E16FF_V_M4_MASK + 0U, // PseudoVLSEG2E16FF_V_MF2 + 0U, // PseudoVLSEG2E16FF_V_MF2_MASK + 0U, // PseudoVLSEG2E16FF_V_MF4 + 0U, // PseudoVLSEG2E16FF_V_MF4_MASK + 0U, // PseudoVLSEG2E16_V_M1 + 0U, // PseudoVLSEG2E16_V_M1_MASK + 0U, // PseudoVLSEG2E16_V_M2 + 0U, // PseudoVLSEG2E16_V_M2_MASK + 0U, // PseudoVLSEG2E16_V_M4 + 0U, // PseudoVLSEG2E16_V_M4_MASK + 0U, // PseudoVLSEG2E16_V_MF2 + 0U, // PseudoVLSEG2E16_V_MF2_MASK + 0U, // PseudoVLSEG2E16_V_MF4 + 0U, // PseudoVLSEG2E16_V_MF4_MASK + 0U, // PseudoVLSEG2E32FF_V_M1 + 0U, // PseudoVLSEG2E32FF_V_M1_MASK + 0U, // PseudoVLSEG2E32FF_V_M2 + 0U, // PseudoVLSEG2E32FF_V_M2_MASK + 0U, // PseudoVLSEG2E32FF_V_M4 + 0U, // PseudoVLSEG2E32FF_V_M4_MASK + 0U, // PseudoVLSEG2E32FF_V_MF2 + 0U, // PseudoVLSEG2E32FF_V_MF2_MASK + 0U, // PseudoVLSEG2E32_V_M1 + 0U, // PseudoVLSEG2E32_V_M1_MASK + 0U, // PseudoVLSEG2E32_V_M2 + 0U, // PseudoVLSEG2E32_V_M2_MASK + 0U, // PseudoVLSEG2E32_V_M4 + 0U, // PseudoVLSEG2E32_V_M4_MASK + 0U, // PseudoVLSEG2E32_V_MF2 + 0U, // PseudoVLSEG2E32_V_MF2_MASK + 0U, // PseudoVLSEG2E64FF_V_M1 + 0U, // PseudoVLSEG2E64FF_V_M1_MASK + 0U, // PseudoVLSEG2E64FF_V_M2 + 0U, // PseudoVLSEG2E64FF_V_M2_MASK + 0U, // PseudoVLSEG2E64FF_V_M4 + 0U, // PseudoVLSEG2E64FF_V_M4_MASK + 0U, // PseudoVLSEG2E64_V_M1 + 0U, // PseudoVLSEG2E64_V_M1_MASK + 0U, // PseudoVLSEG2E64_V_M2 + 0U, // PseudoVLSEG2E64_V_M2_MASK + 0U, // PseudoVLSEG2E64_V_M4 + 0U, // PseudoVLSEG2E64_V_M4_MASK + 0U, // PseudoVLSEG2E8FF_V_M1 + 0U, // PseudoVLSEG2E8FF_V_M1_MASK + 0U, // PseudoVLSEG2E8FF_V_M2 + 0U, // PseudoVLSEG2E8FF_V_M2_MASK + 0U, // PseudoVLSEG2E8FF_V_M4 + 0U, // PseudoVLSEG2E8FF_V_M4_MASK + 0U, // PseudoVLSEG2E8FF_V_MF2 + 0U, // PseudoVLSEG2E8FF_V_MF2_MASK + 0U, // PseudoVLSEG2E8FF_V_MF4 + 0U, // PseudoVLSEG2E8FF_V_MF4_MASK + 0U, // PseudoVLSEG2E8FF_V_MF8 + 0U, // PseudoVLSEG2E8FF_V_MF8_MASK + 0U, // PseudoVLSEG2E8_V_M1 + 0U, // PseudoVLSEG2E8_V_M1_MASK + 0U, // PseudoVLSEG2E8_V_M2 + 0U, // PseudoVLSEG2E8_V_M2_MASK + 0U, // PseudoVLSEG2E8_V_M4 + 0U, // PseudoVLSEG2E8_V_M4_MASK + 0U, // PseudoVLSEG2E8_V_MF2 + 0U, // PseudoVLSEG2E8_V_MF2_MASK + 0U, // PseudoVLSEG2E8_V_MF4 + 0U, // PseudoVLSEG2E8_V_MF4_MASK + 0U, // PseudoVLSEG2E8_V_MF8 + 0U, // PseudoVLSEG2E8_V_MF8_MASK + 0U, // PseudoVLSEG3E16FF_V_M1 + 0U, // PseudoVLSEG3E16FF_V_M1_MASK + 0U, // PseudoVLSEG3E16FF_V_M2 + 0U, // PseudoVLSEG3E16FF_V_M2_MASK + 0U, // PseudoVLSEG3E16FF_V_MF2 + 0U, // PseudoVLSEG3E16FF_V_MF2_MASK + 0U, // PseudoVLSEG3E16FF_V_MF4 + 0U, // PseudoVLSEG3E16FF_V_MF4_MASK + 0U, // PseudoVLSEG3E16_V_M1 + 0U, // PseudoVLSEG3E16_V_M1_MASK + 0U, // PseudoVLSEG3E16_V_M2 + 0U, // PseudoVLSEG3E16_V_M2_MASK + 0U, // PseudoVLSEG3E16_V_MF2 + 0U, // PseudoVLSEG3E16_V_MF2_MASK + 0U, // PseudoVLSEG3E16_V_MF4 + 0U, // PseudoVLSEG3E16_V_MF4_MASK + 0U, // PseudoVLSEG3E32FF_V_M1 + 0U, // PseudoVLSEG3E32FF_V_M1_MASK + 0U, // PseudoVLSEG3E32FF_V_M2 + 0U, // PseudoVLSEG3E32FF_V_M2_MASK + 0U, // PseudoVLSEG3E32FF_V_MF2 + 0U, // PseudoVLSEG3E32FF_V_MF2_MASK + 0U, // PseudoVLSEG3E32_V_M1 + 0U, // PseudoVLSEG3E32_V_M1_MASK + 0U, // PseudoVLSEG3E32_V_M2 + 0U, // PseudoVLSEG3E32_V_M2_MASK + 0U, // PseudoVLSEG3E32_V_MF2 + 0U, // PseudoVLSEG3E32_V_MF2_MASK + 0U, // PseudoVLSEG3E64FF_V_M1 + 0U, // PseudoVLSEG3E64FF_V_M1_MASK + 0U, // PseudoVLSEG3E64FF_V_M2 + 0U, // PseudoVLSEG3E64FF_V_M2_MASK + 0U, // PseudoVLSEG3E64_V_M1 + 0U, // PseudoVLSEG3E64_V_M1_MASK + 0U, // PseudoVLSEG3E64_V_M2 + 0U, // PseudoVLSEG3E64_V_M2_MASK + 0U, // PseudoVLSEG3E8FF_V_M1 + 0U, // PseudoVLSEG3E8FF_V_M1_MASK + 0U, // PseudoVLSEG3E8FF_V_M2 + 0U, // PseudoVLSEG3E8FF_V_M2_MASK + 0U, // PseudoVLSEG3E8FF_V_MF2 + 0U, // PseudoVLSEG3E8FF_V_MF2_MASK + 0U, // PseudoVLSEG3E8FF_V_MF4 + 0U, // PseudoVLSEG3E8FF_V_MF4_MASK + 0U, // PseudoVLSEG3E8FF_V_MF8 + 0U, // PseudoVLSEG3E8FF_V_MF8_MASK + 0U, // PseudoVLSEG3E8_V_M1 + 0U, // PseudoVLSEG3E8_V_M1_MASK + 0U, // PseudoVLSEG3E8_V_M2 + 0U, // PseudoVLSEG3E8_V_M2_MASK + 0U, // PseudoVLSEG3E8_V_MF2 + 0U, // PseudoVLSEG3E8_V_MF2_MASK + 0U, // PseudoVLSEG3E8_V_MF4 + 0U, // PseudoVLSEG3E8_V_MF4_MASK + 0U, // PseudoVLSEG3E8_V_MF8 + 0U, // PseudoVLSEG3E8_V_MF8_MASK + 0U, // PseudoVLSEG4E16FF_V_M1 + 0U, // PseudoVLSEG4E16FF_V_M1_MASK + 0U, // PseudoVLSEG4E16FF_V_M2 + 0U, // PseudoVLSEG4E16FF_V_M2_MASK + 0U, // PseudoVLSEG4E16FF_V_MF2 + 0U, // PseudoVLSEG4E16FF_V_MF2_MASK + 0U, // PseudoVLSEG4E16FF_V_MF4 + 0U, // PseudoVLSEG4E16FF_V_MF4_MASK + 0U, // PseudoVLSEG4E16_V_M1 + 0U, // PseudoVLSEG4E16_V_M1_MASK + 0U, // PseudoVLSEG4E16_V_M2 + 0U, // PseudoVLSEG4E16_V_M2_MASK + 0U, // PseudoVLSEG4E16_V_MF2 + 0U, // PseudoVLSEG4E16_V_MF2_MASK + 0U, // PseudoVLSEG4E16_V_MF4 + 0U, // PseudoVLSEG4E16_V_MF4_MASK + 0U, // PseudoVLSEG4E32FF_V_M1 + 0U, // PseudoVLSEG4E32FF_V_M1_MASK + 0U, // PseudoVLSEG4E32FF_V_M2 + 0U, // PseudoVLSEG4E32FF_V_M2_MASK + 0U, // PseudoVLSEG4E32FF_V_MF2 + 0U, // PseudoVLSEG4E32FF_V_MF2_MASK + 0U, // PseudoVLSEG4E32_V_M1 + 0U, // PseudoVLSEG4E32_V_M1_MASK + 0U, // PseudoVLSEG4E32_V_M2 + 0U, // PseudoVLSEG4E32_V_M2_MASK + 0U, // PseudoVLSEG4E32_V_MF2 + 0U, // PseudoVLSEG4E32_V_MF2_MASK + 0U, // PseudoVLSEG4E64FF_V_M1 + 0U, // PseudoVLSEG4E64FF_V_M1_MASK + 0U, // PseudoVLSEG4E64FF_V_M2 + 0U, // PseudoVLSEG4E64FF_V_M2_MASK + 0U, // PseudoVLSEG4E64_V_M1 + 0U, // PseudoVLSEG4E64_V_M1_MASK + 0U, // PseudoVLSEG4E64_V_M2 + 0U, // PseudoVLSEG4E64_V_M2_MASK + 0U, // PseudoVLSEG4E8FF_V_M1 + 0U, // PseudoVLSEG4E8FF_V_M1_MASK + 0U, // PseudoVLSEG4E8FF_V_M2 + 0U, // PseudoVLSEG4E8FF_V_M2_MASK + 0U, // PseudoVLSEG4E8FF_V_MF2 + 0U, // PseudoVLSEG4E8FF_V_MF2_MASK + 0U, // PseudoVLSEG4E8FF_V_MF4 + 0U, // PseudoVLSEG4E8FF_V_MF4_MASK + 0U, // PseudoVLSEG4E8FF_V_MF8 + 0U, // PseudoVLSEG4E8FF_V_MF8_MASK + 0U, // PseudoVLSEG4E8_V_M1 + 0U, // PseudoVLSEG4E8_V_M1_MASK + 0U, // PseudoVLSEG4E8_V_M2 + 0U, // PseudoVLSEG4E8_V_M2_MASK + 0U, // PseudoVLSEG4E8_V_MF2 + 0U, // PseudoVLSEG4E8_V_MF2_MASK + 0U, // PseudoVLSEG4E8_V_MF4 + 0U, // PseudoVLSEG4E8_V_MF4_MASK + 0U, // PseudoVLSEG4E8_V_MF8 + 0U, // PseudoVLSEG4E8_V_MF8_MASK + 0U, // PseudoVLSEG5E16FF_V_M1 + 0U, // PseudoVLSEG5E16FF_V_M1_MASK + 0U, // PseudoVLSEG5E16FF_V_MF2 + 0U, // PseudoVLSEG5E16FF_V_MF2_MASK + 0U, // PseudoVLSEG5E16FF_V_MF4 + 0U, // PseudoVLSEG5E16FF_V_MF4_MASK + 0U, // PseudoVLSEG5E16_V_M1 + 0U, // PseudoVLSEG5E16_V_M1_MASK + 0U, // PseudoVLSEG5E16_V_MF2 + 0U, // PseudoVLSEG5E16_V_MF2_MASK + 0U, // PseudoVLSEG5E16_V_MF4 + 0U, // PseudoVLSEG5E16_V_MF4_MASK + 0U, // PseudoVLSEG5E32FF_V_M1 + 0U, // PseudoVLSEG5E32FF_V_M1_MASK + 0U, // PseudoVLSEG5E32FF_V_MF2 + 0U, // PseudoVLSEG5E32FF_V_MF2_MASK + 0U, // PseudoVLSEG5E32_V_M1 + 0U, // PseudoVLSEG5E32_V_M1_MASK + 0U, // PseudoVLSEG5E32_V_MF2 + 0U, // PseudoVLSEG5E32_V_MF2_MASK + 0U, // PseudoVLSEG5E64FF_V_M1 + 0U, // PseudoVLSEG5E64FF_V_M1_MASK + 0U, // PseudoVLSEG5E64_V_M1 + 0U, // PseudoVLSEG5E64_V_M1_MASK + 0U, // PseudoVLSEG5E8FF_V_M1 + 0U, // PseudoVLSEG5E8FF_V_M1_MASK + 0U, // PseudoVLSEG5E8FF_V_MF2 + 0U, // PseudoVLSEG5E8FF_V_MF2_MASK + 0U, // PseudoVLSEG5E8FF_V_MF4 + 0U, // PseudoVLSEG5E8FF_V_MF4_MASK + 0U, // PseudoVLSEG5E8FF_V_MF8 + 0U, // PseudoVLSEG5E8FF_V_MF8_MASK + 0U, // PseudoVLSEG5E8_V_M1 + 0U, // PseudoVLSEG5E8_V_M1_MASK + 0U, // PseudoVLSEG5E8_V_MF2 + 0U, // PseudoVLSEG5E8_V_MF2_MASK + 0U, // PseudoVLSEG5E8_V_MF4 + 0U, // PseudoVLSEG5E8_V_MF4_MASK + 0U, // PseudoVLSEG5E8_V_MF8 + 0U, // PseudoVLSEG5E8_V_MF8_MASK + 0U, // PseudoVLSEG6E16FF_V_M1 + 0U, // PseudoVLSEG6E16FF_V_M1_MASK + 0U, // PseudoVLSEG6E16FF_V_MF2 + 0U, // PseudoVLSEG6E16FF_V_MF2_MASK + 0U, // PseudoVLSEG6E16FF_V_MF4 + 0U, // PseudoVLSEG6E16FF_V_MF4_MASK + 0U, // PseudoVLSEG6E16_V_M1 + 0U, // PseudoVLSEG6E16_V_M1_MASK + 0U, // PseudoVLSEG6E16_V_MF2 + 0U, // PseudoVLSEG6E16_V_MF2_MASK + 0U, // PseudoVLSEG6E16_V_MF4 + 0U, // PseudoVLSEG6E16_V_MF4_MASK + 0U, // PseudoVLSEG6E32FF_V_M1 + 0U, // PseudoVLSEG6E32FF_V_M1_MASK + 0U, // PseudoVLSEG6E32FF_V_MF2 + 0U, // PseudoVLSEG6E32FF_V_MF2_MASK + 0U, // PseudoVLSEG6E32_V_M1 + 0U, // PseudoVLSEG6E32_V_M1_MASK + 0U, // PseudoVLSEG6E32_V_MF2 + 0U, // PseudoVLSEG6E32_V_MF2_MASK + 0U, // PseudoVLSEG6E64FF_V_M1 + 0U, // PseudoVLSEG6E64FF_V_M1_MASK + 0U, // PseudoVLSEG6E64_V_M1 + 0U, // PseudoVLSEG6E64_V_M1_MASK + 0U, // PseudoVLSEG6E8FF_V_M1 + 0U, // PseudoVLSEG6E8FF_V_M1_MASK + 0U, // PseudoVLSEG6E8FF_V_MF2 + 0U, // PseudoVLSEG6E8FF_V_MF2_MASK + 0U, // PseudoVLSEG6E8FF_V_MF4 + 0U, // PseudoVLSEG6E8FF_V_MF4_MASK + 0U, // PseudoVLSEG6E8FF_V_MF8 + 0U, // PseudoVLSEG6E8FF_V_MF8_MASK + 0U, // PseudoVLSEG6E8_V_M1 + 0U, // PseudoVLSEG6E8_V_M1_MASK + 0U, // PseudoVLSEG6E8_V_MF2 + 0U, // PseudoVLSEG6E8_V_MF2_MASK + 0U, // PseudoVLSEG6E8_V_MF4 + 0U, // PseudoVLSEG6E8_V_MF4_MASK + 0U, // PseudoVLSEG6E8_V_MF8 + 0U, // PseudoVLSEG6E8_V_MF8_MASK + 0U, // PseudoVLSEG7E16FF_V_M1 + 0U, // PseudoVLSEG7E16FF_V_M1_MASK + 0U, // PseudoVLSEG7E16FF_V_MF2 + 0U, // PseudoVLSEG7E16FF_V_MF2_MASK + 0U, // PseudoVLSEG7E16FF_V_MF4 + 0U, // PseudoVLSEG7E16FF_V_MF4_MASK + 0U, // PseudoVLSEG7E16_V_M1 + 0U, // PseudoVLSEG7E16_V_M1_MASK + 0U, // PseudoVLSEG7E16_V_MF2 + 0U, // PseudoVLSEG7E16_V_MF2_MASK + 0U, // PseudoVLSEG7E16_V_MF4 + 0U, // PseudoVLSEG7E16_V_MF4_MASK + 0U, // PseudoVLSEG7E32FF_V_M1 + 0U, // PseudoVLSEG7E32FF_V_M1_MASK + 0U, // PseudoVLSEG7E32FF_V_MF2 + 0U, // PseudoVLSEG7E32FF_V_MF2_MASK + 0U, // PseudoVLSEG7E32_V_M1 + 0U, // PseudoVLSEG7E32_V_M1_MASK + 0U, // PseudoVLSEG7E32_V_MF2 + 0U, // PseudoVLSEG7E32_V_MF2_MASK + 0U, // PseudoVLSEG7E64FF_V_M1 + 0U, // PseudoVLSEG7E64FF_V_M1_MASK + 0U, // PseudoVLSEG7E64_V_M1 + 0U, // PseudoVLSEG7E64_V_M1_MASK + 0U, // PseudoVLSEG7E8FF_V_M1 + 0U, // PseudoVLSEG7E8FF_V_M1_MASK + 0U, // PseudoVLSEG7E8FF_V_MF2 + 0U, // PseudoVLSEG7E8FF_V_MF2_MASK + 0U, // PseudoVLSEG7E8FF_V_MF4 + 0U, // PseudoVLSEG7E8FF_V_MF4_MASK + 0U, // PseudoVLSEG7E8FF_V_MF8 + 0U, // PseudoVLSEG7E8FF_V_MF8_MASK + 0U, // PseudoVLSEG7E8_V_M1 + 0U, // PseudoVLSEG7E8_V_M1_MASK + 0U, // PseudoVLSEG7E8_V_MF2 + 0U, // PseudoVLSEG7E8_V_MF2_MASK + 0U, // PseudoVLSEG7E8_V_MF4 + 0U, // PseudoVLSEG7E8_V_MF4_MASK + 0U, // PseudoVLSEG7E8_V_MF8 + 0U, // PseudoVLSEG7E8_V_MF8_MASK + 0U, // PseudoVLSEG8E16FF_V_M1 + 0U, // PseudoVLSEG8E16FF_V_M1_MASK + 0U, // PseudoVLSEG8E16FF_V_MF2 + 0U, // PseudoVLSEG8E16FF_V_MF2_MASK + 0U, // PseudoVLSEG8E16FF_V_MF4 + 0U, // PseudoVLSEG8E16FF_V_MF4_MASK + 0U, // PseudoVLSEG8E16_V_M1 + 0U, // PseudoVLSEG8E16_V_M1_MASK + 0U, // PseudoVLSEG8E16_V_MF2 + 0U, // PseudoVLSEG8E16_V_MF2_MASK + 0U, // PseudoVLSEG8E16_V_MF4 + 0U, // PseudoVLSEG8E16_V_MF4_MASK + 0U, // PseudoVLSEG8E32FF_V_M1 + 0U, // PseudoVLSEG8E32FF_V_M1_MASK + 0U, // PseudoVLSEG8E32FF_V_MF2 + 0U, // PseudoVLSEG8E32FF_V_MF2_MASK + 0U, // PseudoVLSEG8E32_V_M1 + 0U, // PseudoVLSEG8E32_V_M1_MASK + 0U, // PseudoVLSEG8E32_V_MF2 + 0U, // PseudoVLSEG8E32_V_MF2_MASK + 0U, // PseudoVLSEG8E64FF_V_M1 + 0U, // PseudoVLSEG8E64FF_V_M1_MASK + 0U, // PseudoVLSEG8E64_V_M1 + 0U, // PseudoVLSEG8E64_V_M1_MASK + 0U, // PseudoVLSEG8E8FF_V_M1 + 0U, // PseudoVLSEG8E8FF_V_M1_MASK + 0U, // PseudoVLSEG8E8FF_V_MF2 + 0U, // PseudoVLSEG8E8FF_V_MF2_MASK + 0U, // PseudoVLSEG8E8FF_V_MF4 + 0U, // PseudoVLSEG8E8FF_V_MF4_MASK + 0U, // PseudoVLSEG8E8FF_V_MF8 + 0U, // PseudoVLSEG8E8FF_V_MF8_MASK + 0U, // PseudoVLSEG8E8_V_M1 + 0U, // PseudoVLSEG8E8_V_M1_MASK + 0U, // PseudoVLSEG8E8_V_MF2 + 0U, // PseudoVLSEG8E8_V_MF2_MASK + 0U, // PseudoVLSEG8E8_V_MF4 + 0U, // PseudoVLSEG8E8_V_MF4_MASK + 0U, // PseudoVLSEG8E8_V_MF8 + 0U, // PseudoVLSEG8E8_V_MF8_MASK + 0U, // PseudoVLSSEG2E16_V_M1 + 0U, // PseudoVLSSEG2E16_V_M1_MASK + 0U, // PseudoVLSSEG2E16_V_M2 + 0U, // PseudoVLSSEG2E16_V_M2_MASK + 0U, // PseudoVLSSEG2E16_V_M4 + 0U, // PseudoVLSSEG2E16_V_M4_MASK + 0U, // PseudoVLSSEG2E16_V_MF2 + 0U, // PseudoVLSSEG2E16_V_MF2_MASK + 0U, // PseudoVLSSEG2E16_V_MF4 + 0U, // PseudoVLSSEG2E16_V_MF4_MASK + 0U, // PseudoVLSSEG2E32_V_M1 + 0U, // PseudoVLSSEG2E32_V_M1_MASK + 0U, // PseudoVLSSEG2E32_V_M2 + 0U, // PseudoVLSSEG2E32_V_M2_MASK + 0U, // PseudoVLSSEG2E32_V_M4 + 0U, // PseudoVLSSEG2E32_V_M4_MASK + 0U, // PseudoVLSSEG2E32_V_MF2 + 0U, // PseudoVLSSEG2E32_V_MF2_MASK + 0U, // PseudoVLSSEG2E64_V_M1 + 0U, // PseudoVLSSEG2E64_V_M1_MASK + 0U, // PseudoVLSSEG2E64_V_M2 + 0U, // PseudoVLSSEG2E64_V_M2_MASK + 0U, // PseudoVLSSEG2E64_V_M4 + 0U, // PseudoVLSSEG2E64_V_M4_MASK + 0U, // PseudoVLSSEG2E8_V_M1 + 0U, // PseudoVLSSEG2E8_V_M1_MASK + 0U, // PseudoVLSSEG2E8_V_M2 + 0U, // PseudoVLSSEG2E8_V_M2_MASK + 0U, // PseudoVLSSEG2E8_V_M4 + 0U, // PseudoVLSSEG2E8_V_M4_MASK + 0U, // PseudoVLSSEG2E8_V_MF2 + 0U, // PseudoVLSSEG2E8_V_MF2_MASK + 0U, // PseudoVLSSEG2E8_V_MF4 + 0U, // PseudoVLSSEG2E8_V_MF4_MASK + 0U, // PseudoVLSSEG2E8_V_MF8 + 0U, // PseudoVLSSEG2E8_V_MF8_MASK + 0U, // PseudoVLSSEG3E16_V_M1 + 0U, // PseudoVLSSEG3E16_V_M1_MASK + 0U, // PseudoVLSSEG3E16_V_M2 + 0U, // PseudoVLSSEG3E16_V_M2_MASK + 0U, // PseudoVLSSEG3E16_V_MF2 + 0U, // PseudoVLSSEG3E16_V_MF2_MASK + 0U, // PseudoVLSSEG3E16_V_MF4 + 0U, // PseudoVLSSEG3E16_V_MF4_MASK + 0U, // PseudoVLSSEG3E32_V_M1 + 0U, // PseudoVLSSEG3E32_V_M1_MASK + 0U, // PseudoVLSSEG3E32_V_M2 + 0U, // PseudoVLSSEG3E32_V_M2_MASK + 0U, // PseudoVLSSEG3E32_V_MF2 + 0U, // PseudoVLSSEG3E32_V_MF2_MASK + 0U, // PseudoVLSSEG3E64_V_M1 + 0U, // PseudoVLSSEG3E64_V_M1_MASK + 0U, // PseudoVLSSEG3E64_V_M2 + 0U, // PseudoVLSSEG3E64_V_M2_MASK + 0U, // PseudoVLSSEG3E8_V_M1 + 0U, // PseudoVLSSEG3E8_V_M1_MASK + 0U, // PseudoVLSSEG3E8_V_M2 + 0U, // PseudoVLSSEG3E8_V_M2_MASK + 0U, // PseudoVLSSEG3E8_V_MF2 + 0U, // PseudoVLSSEG3E8_V_MF2_MASK + 0U, // PseudoVLSSEG3E8_V_MF4 + 0U, // PseudoVLSSEG3E8_V_MF4_MASK + 0U, // PseudoVLSSEG3E8_V_MF8 + 0U, // PseudoVLSSEG3E8_V_MF8_MASK + 0U, // PseudoVLSSEG4E16_V_M1 + 0U, // PseudoVLSSEG4E16_V_M1_MASK + 0U, // PseudoVLSSEG4E16_V_M2 + 0U, // PseudoVLSSEG4E16_V_M2_MASK + 0U, // PseudoVLSSEG4E16_V_MF2 + 0U, // PseudoVLSSEG4E16_V_MF2_MASK + 0U, // PseudoVLSSEG4E16_V_MF4 + 0U, // PseudoVLSSEG4E16_V_MF4_MASK + 0U, // PseudoVLSSEG4E32_V_M1 + 0U, // PseudoVLSSEG4E32_V_M1_MASK + 0U, // PseudoVLSSEG4E32_V_M2 + 0U, // PseudoVLSSEG4E32_V_M2_MASK + 0U, // PseudoVLSSEG4E32_V_MF2 + 0U, // PseudoVLSSEG4E32_V_MF2_MASK + 0U, // PseudoVLSSEG4E64_V_M1 + 0U, // PseudoVLSSEG4E64_V_M1_MASK + 0U, // PseudoVLSSEG4E64_V_M2 + 0U, // PseudoVLSSEG4E64_V_M2_MASK + 0U, // PseudoVLSSEG4E8_V_M1 + 0U, // PseudoVLSSEG4E8_V_M1_MASK + 0U, // PseudoVLSSEG4E8_V_M2 + 0U, // PseudoVLSSEG4E8_V_M2_MASK + 0U, // PseudoVLSSEG4E8_V_MF2 + 0U, // PseudoVLSSEG4E8_V_MF2_MASK + 0U, // PseudoVLSSEG4E8_V_MF4 + 0U, // PseudoVLSSEG4E8_V_MF4_MASK + 0U, // PseudoVLSSEG4E8_V_MF8 + 0U, // PseudoVLSSEG4E8_V_MF8_MASK + 0U, // PseudoVLSSEG5E16_V_M1 + 0U, // PseudoVLSSEG5E16_V_M1_MASK + 0U, // PseudoVLSSEG5E16_V_MF2 + 0U, // PseudoVLSSEG5E16_V_MF2_MASK + 0U, // PseudoVLSSEG5E16_V_MF4 + 0U, // PseudoVLSSEG5E16_V_MF4_MASK + 0U, // PseudoVLSSEG5E32_V_M1 + 0U, // PseudoVLSSEG5E32_V_M1_MASK + 0U, // PseudoVLSSEG5E32_V_MF2 + 0U, // PseudoVLSSEG5E32_V_MF2_MASK + 0U, // PseudoVLSSEG5E64_V_M1 + 0U, // PseudoVLSSEG5E64_V_M1_MASK + 0U, // PseudoVLSSEG5E8_V_M1 + 0U, // PseudoVLSSEG5E8_V_M1_MASK + 0U, // PseudoVLSSEG5E8_V_MF2 + 0U, // PseudoVLSSEG5E8_V_MF2_MASK + 0U, // PseudoVLSSEG5E8_V_MF4 + 0U, // PseudoVLSSEG5E8_V_MF4_MASK + 0U, // PseudoVLSSEG5E8_V_MF8 + 0U, // PseudoVLSSEG5E8_V_MF8_MASK + 0U, // PseudoVLSSEG6E16_V_M1 + 0U, // PseudoVLSSEG6E16_V_M1_MASK + 0U, // PseudoVLSSEG6E16_V_MF2 + 0U, // PseudoVLSSEG6E16_V_MF2_MASK + 0U, // PseudoVLSSEG6E16_V_MF4 + 0U, // PseudoVLSSEG6E16_V_MF4_MASK + 0U, // PseudoVLSSEG6E32_V_M1 + 0U, // PseudoVLSSEG6E32_V_M1_MASK + 0U, // PseudoVLSSEG6E32_V_MF2 + 0U, // PseudoVLSSEG6E32_V_MF2_MASK + 0U, // PseudoVLSSEG6E64_V_M1 + 0U, // PseudoVLSSEG6E64_V_M1_MASK + 0U, // PseudoVLSSEG6E8_V_M1 + 0U, // PseudoVLSSEG6E8_V_M1_MASK + 0U, // PseudoVLSSEG6E8_V_MF2 + 0U, // PseudoVLSSEG6E8_V_MF2_MASK + 0U, // PseudoVLSSEG6E8_V_MF4 + 0U, // PseudoVLSSEG6E8_V_MF4_MASK + 0U, // PseudoVLSSEG6E8_V_MF8 + 0U, // PseudoVLSSEG6E8_V_MF8_MASK + 0U, // PseudoVLSSEG7E16_V_M1 + 0U, // PseudoVLSSEG7E16_V_M1_MASK + 0U, // PseudoVLSSEG7E16_V_MF2 + 0U, // PseudoVLSSEG7E16_V_MF2_MASK + 0U, // PseudoVLSSEG7E16_V_MF4 + 0U, // PseudoVLSSEG7E16_V_MF4_MASK + 0U, // PseudoVLSSEG7E32_V_M1 + 0U, // PseudoVLSSEG7E32_V_M1_MASK + 0U, // PseudoVLSSEG7E32_V_MF2 + 0U, // PseudoVLSSEG7E32_V_MF2_MASK + 0U, // PseudoVLSSEG7E64_V_M1 + 0U, // PseudoVLSSEG7E64_V_M1_MASK + 0U, // PseudoVLSSEG7E8_V_M1 + 0U, // PseudoVLSSEG7E8_V_M1_MASK + 0U, // PseudoVLSSEG7E8_V_MF2 + 0U, // PseudoVLSSEG7E8_V_MF2_MASK + 0U, // PseudoVLSSEG7E8_V_MF4 + 0U, // PseudoVLSSEG7E8_V_MF4_MASK + 0U, // PseudoVLSSEG7E8_V_MF8 + 0U, // PseudoVLSSEG7E8_V_MF8_MASK + 0U, // PseudoVLSSEG8E16_V_M1 + 0U, // PseudoVLSSEG8E16_V_M1_MASK + 0U, // PseudoVLSSEG8E16_V_MF2 + 0U, // PseudoVLSSEG8E16_V_MF2_MASK + 0U, // PseudoVLSSEG8E16_V_MF4 + 0U, // PseudoVLSSEG8E16_V_MF4_MASK + 0U, // PseudoVLSSEG8E32_V_M1 + 0U, // PseudoVLSSEG8E32_V_M1_MASK + 0U, // PseudoVLSSEG8E32_V_MF2 + 0U, // PseudoVLSSEG8E32_V_MF2_MASK + 0U, // PseudoVLSSEG8E64_V_M1 + 0U, // PseudoVLSSEG8E64_V_M1_MASK + 0U, // PseudoVLSSEG8E8_V_M1 + 0U, // PseudoVLSSEG8E8_V_M1_MASK + 0U, // PseudoVLSSEG8E8_V_MF2 + 0U, // PseudoVLSSEG8E8_V_MF2_MASK + 0U, // PseudoVLSSEG8E8_V_MF4 + 0U, // PseudoVLSSEG8E8_V_MF4_MASK + 0U, // PseudoVLSSEG8E8_V_MF8 + 0U, // PseudoVLSSEG8E8_V_MF8_MASK + 0U, // PseudoVLUXEI16_V_M1_M1 + 0U, // PseudoVLUXEI16_V_M1_M1_MASK + 0U, // PseudoVLUXEI16_V_M1_M2 + 0U, // PseudoVLUXEI16_V_M1_M2_MASK + 0U, // PseudoVLUXEI16_V_M1_M4 + 0U, // PseudoVLUXEI16_V_M1_M4_MASK + 0U, // PseudoVLUXEI16_V_M1_MF2 + 0U, // PseudoVLUXEI16_V_M1_MF2_MASK + 0U, // PseudoVLUXEI16_V_M2_M1 + 0U, // PseudoVLUXEI16_V_M2_M1_MASK + 0U, // PseudoVLUXEI16_V_M2_M2 + 0U, // PseudoVLUXEI16_V_M2_M2_MASK + 0U, // PseudoVLUXEI16_V_M2_M4 + 0U, // PseudoVLUXEI16_V_M2_M4_MASK + 0U, // PseudoVLUXEI16_V_M2_M8 + 0U, // PseudoVLUXEI16_V_M2_M8_MASK + 0U, // PseudoVLUXEI16_V_M4_M2 + 0U, // PseudoVLUXEI16_V_M4_M2_MASK + 0U, // PseudoVLUXEI16_V_M4_M4 + 0U, // PseudoVLUXEI16_V_M4_M4_MASK + 0U, // PseudoVLUXEI16_V_M4_M8 + 0U, // PseudoVLUXEI16_V_M4_M8_MASK + 0U, // PseudoVLUXEI16_V_M8_M4 + 0U, // PseudoVLUXEI16_V_M8_M4_MASK + 0U, // PseudoVLUXEI16_V_M8_M8 + 0U, // PseudoVLUXEI16_V_M8_M8_MASK + 0U, // PseudoVLUXEI16_V_MF2_M1 + 0U, // PseudoVLUXEI16_V_MF2_M1_MASK + 0U, // PseudoVLUXEI16_V_MF2_M2 + 0U, // PseudoVLUXEI16_V_MF2_M2_MASK + 0U, // PseudoVLUXEI16_V_MF2_MF2 + 0U, // PseudoVLUXEI16_V_MF2_MF2_MASK + 0U, // PseudoVLUXEI16_V_MF2_MF4 + 0U, // PseudoVLUXEI16_V_MF2_MF4_MASK + 0U, // PseudoVLUXEI16_V_MF4_M1 + 0U, // PseudoVLUXEI16_V_MF4_M1_MASK + 0U, // PseudoVLUXEI16_V_MF4_MF2 + 0U, // PseudoVLUXEI16_V_MF4_MF2_MASK + 0U, // PseudoVLUXEI16_V_MF4_MF4 + 0U, // PseudoVLUXEI16_V_MF4_MF4_MASK + 0U, // PseudoVLUXEI16_V_MF4_MF8 + 0U, // PseudoVLUXEI16_V_MF4_MF8_MASK + 0U, // PseudoVLUXEI32_V_M1_M1 + 0U, // PseudoVLUXEI32_V_M1_M1_MASK + 0U, // PseudoVLUXEI32_V_M1_M2 + 0U, // PseudoVLUXEI32_V_M1_M2_MASK + 0U, // PseudoVLUXEI32_V_M1_MF2 + 0U, // PseudoVLUXEI32_V_M1_MF2_MASK + 0U, // PseudoVLUXEI32_V_M1_MF4 + 0U, // PseudoVLUXEI32_V_M1_MF4_MASK + 0U, // PseudoVLUXEI32_V_M2_M1 + 0U, // PseudoVLUXEI32_V_M2_M1_MASK + 0U, // PseudoVLUXEI32_V_M2_M2 + 0U, // PseudoVLUXEI32_V_M2_M2_MASK + 0U, // PseudoVLUXEI32_V_M2_M4 + 0U, // PseudoVLUXEI32_V_M2_M4_MASK + 0U, // PseudoVLUXEI32_V_M2_MF2 + 0U, // PseudoVLUXEI32_V_M2_MF2_MASK + 0U, // PseudoVLUXEI32_V_M4_M1 + 0U, // PseudoVLUXEI32_V_M4_M1_MASK + 0U, // PseudoVLUXEI32_V_M4_M2 + 0U, // PseudoVLUXEI32_V_M4_M2_MASK + 0U, // PseudoVLUXEI32_V_M4_M4 + 0U, // PseudoVLUXEI32_V_M4_M4_MASK + 0U, // PseudoVLUXEI32_V_M4_M8 + 0U, // PseudoVLUXEI32_V_M4_M8_MASK + 0U, // PseudoVLUXEI32_V_M8_M2 + 0U, // PseudoVLUXEI32_V_M8_M2_MASK + 0U, // PseudoVLUXEI32_V_M8_M4 + 0U, // PseudoVLUXEI32_V_M8_M4_MASK + 0U, // PseudoVLUXEI32_V_M8_M8 + 0U, // PseudoVLUXEI32_V_M8_M8_MASK + 0U, // PseudoVLUXEI32_V_MF2_M1 + 0U, // PseudoVLUXEI32_V_MF2_M1_MASK + 0U, // PseudoVLUXEI32_V_MF2_MF2 + 0U, // PseudoVLUXEI32_V_MF2_MF2_MASK + 0U, // PseudoVLUXEI32_V_MF2_MF4 + 0U, // PseudoVLUXEI32_V_MF2_MF4_MASK + 0U, // PseudoVLUXEI32_V_MF2_MF8 + 0U, // PseudoVLUXEI32_V_MF2_MF8_MASK + 0U, // PseudoVLUXEI64_V_M1_M1 + 0U, // PseudoVLUXEI64_V_M1_M1_MASK + 0U, // PseudoVLUXEI64_V_M1_MF2 + 0U, // PseudoVLUXEI64_V_M1_MF2_MASK + 0U, // PseudoVLUXEI64_V_M1_MF4 + 0U, // PseudoVLUXEI64_V_M1_MF4_MASK + 0U, // PseudoVLUXEI64_V_M1_MF8 + 0U, // PseudoVLUXEI64_V_M1_MF8_MASK + 0U, // PseudoVLUXEI64_V_M2_M1 + 0U, // PseudoVLUXEI64_V_M2_M1_MASK + 0U, // PseudoVLUXEI64_V_M2_M2 + 0U, // PseudoVLUXEI64_V_M2_M2_MASK + 0U, // PseudoVLUXEI64_V_M2_MF2 + 0U, // PseudoVLUXEI64_V_M2_MF2_MASK + 0U, // PseudoVLUXEI64_V_M2_MF4 + 0U, // PseudoVLUXEI64_V_M2_MF4_MASK + 0U, // PseudoVLUXEI64_V_M4_M1 + 0U, // PseudoVLUXEI64_V_M4_M1_MASK + 0U, // PseudoVLUXEI64_V_M4_M2 + 0U, // PseudoVLUXEI64_V_M4_M2_MASK + 0U, // PseudoVLUXEI64_V_M4_M4 + 0U, // PseudoVLUXEI64_V_M4_M4_MASK + 0U, // PseudoVLUXEI64_V_M4_MF2 + 0U, // PseudoVLUXEI64_V_M4_MF2_MASK + 0U, // PseudoVLUXEI64_V_M8_M1 + 0U, // PseudoVLUXEI64_V_M8_M1_MASK + 0U, // PseudoVLUXEI64_V_M8_M2 + 0U, // PseudoVLUXEI64_V_M8_M2_MASK + 0U, // PseudoVLUXEI64_V_M8_M4 + 0U, // PseudoVLUXEI64_V_M8_M4_MASK + 0U, // PseudoVLUXEI64_V_M8_M8 + 0U, // PseudoVLUXEI64_V_M8_M8_MASK + 0U, // PseudoVLUXEI8_V_M1_M1 + 0U, // PseudoVLUXEI8_V_M1_M1_MASK + 0U, // PseudoVLUXEI8_V_M1_M2 + 0U, // PseudoVLUXEI8_V_M1_M2_MASK + 0U, // PseudoVLUXEI8_V_M1_M4 + 0U, // PseudoVLUXEI8_V_M1_M4_MASK + 0U, // PseudoVLUXEI8_V_M1_M8 + 0U, // PseudoVLUXEI8_V_M1_M8_MASK + 0U, // PseudoVLUXEI8_V_M2_M2 + 0U, // PseudoVLUXEI8_V_M2_M2_MASK + 0U, // PseudoVLUXEI8_V_M2_M4 + 0U, // PseudoVLUXEI8_V_M2_M4_MASK + 0U, // PseudoVLUXEI8_V_M2_M8 + 0U, // PseudoVLUXEI8_V_M2_M8_MASK + 0U, // PseudoVLUXEI8_V_M4_M4 + 0U, // PseudoVLUXEI8_V_M4_M4_MASK + 0U, // PseudoVLUXEI8_V_M4_M8 + 0U, // PseudoVLUXEI8_V_M4_M8_MASK + 0U, // PseudoVLUXEI8_V_M8_M8 + 0U, // PseudoVLUXEI8_V_M8_M8_MASK + 0U, // PseudoVLUXEI8_V_MF2_M1 + 0U, // PseudoVLUXEI8_V_MF2_M1_MASK + 0U, // PseudoVLUXEI8_V_MF2_M2 + 0U, // PseudoVLUXEI8_V_MF2_M2_MASK + 0U, // PseudoVLUXEI8_V_MF2_M4 + 0U, // PseudoVLUXEI8_V_MF2_M4_MASK + 0U, // PseudoVLUXEI8_V_MF2_MF2 + 0U, // PseudoVLUXEI8_V_MF2_MF2_MASK + 0U, // PseudoVLUXEI8_V_MF4_M1 + 0U, // PseudoVLUXEI8_V_MF4_M1_MASK + 0U, // PseudoVLUXEI8_V_MF4_M2 + 0U, // PseudoVLUXEI8_V_MF4_M2_MASK + 0U, // PseudoVLUXEI8_V_MF4_MF2 + 0U, // PseudoVLUXEI8_V_MF4_MF2_MASK + 0U, // PseudoVLUXEI8_V_MF4_MF4 + 0U, // PseudoVLUXEI8_V_MF4_MF4_MASK + 0U, // PseudoVLUXEI8_V_MF8_M1 + 0U, // PseudoVLUXEI8_V_MF8_M1_MASK + 0U, // PseudoVLUXEI8_V_MF8_MF2 + 0U, // PseudoVLUXEI8_V_MF8_MF2_MASK + 0U, // PseudoVLUXEI8_V_MF8_MF4 + 0U, // PseudoVLUXEI8_V_MF8_MF4_MASK + 0U, // PseudoVLUXEI8_V_MF8_MF8 + 0U, // PseudoVLUXEI8_V_MF8_MF8_MASK + 0U, // PseudoVLUXSEG2EI16_V_M1_M1 + 0U, // PseudoVLUXSEG2EI16_V_M1_M1_MASK + 0U, // PseudoVLUXSEG2EI16_V_M1_M2 + 0U, // PseudoVLUXSEG2EI16_V_M1_M2_MASK + 0U, // PseudoVLUXSEG2EI16_V_M1_M4 + 0U, // PseudoVLUXSEG2EI16_V_M1_M4_MASK + 0U, // PseudoVLUXSEG2EI16_V_M1_MF2 + 0U, // PseudoVLUXSEG2EI16_V_M1_MF2_MASK + 0U, // PseudoVLUXSEG2EI16_V_M2_M1 + 0U, // PseudoVLUXSEG2EI16_V_M2_M1_MASK + 0U, // PseudoVLUXSEG2EI16_V_M2_M2 + 0U, // PseudoVLUXSEG2EI16_V_M2_M2_MASK + 0U, // PseudoVLUXSEG2EI16_V_M2_M4 + 0U, // PseudoVLUXSEG2EI16_V_M2_M4_MASK + 0U, // PseudoVLUXSEG2EI16_V_M4_M2 + 0U, // PseudoVLUXSEG2EI16_V_M4_M2_MASK + 0U, // PseudoVLUXSEG2EI16_V_M4_M4 + 0U, // PseudoVLUXSEG2EI16_V_M4_M4_MASK + 0U, // PseudoVLUXSEG2EI16_V_M8_M4 + 0U, // PseudoVLUXSEG2EI16_V_M8_M4_MASK + 0U, // PseudoVLUXSEG2EI16_V_MF2_M1 + 0U, // PseudoVLUXSEG2EI16_V_MF2_M1_MASK + 0U, // PseudoVLUXSEG2EI16_V_MF2_M2 + 0U, // PseudoVLUXSEG2EI16_V_MF2_M2_MASK + 0U, // PseudoVLUXSEG2EI16_V_MF2_MF2 + 0U, // PseudoVLUXSEG2EI16_V_MF2_MF2_MASK + 0U, // PseudoVLUXSEG2EI16_V_MF2_MF4 + 0U, // PseudoVLUXSEG2EI16_V_MF2_MF4_MASK + 0U, // PseudoVLUXSEG2EI16_V_MF4_M1 + 0U, // PseudoVLUXSEG2EI16_V_MF4_M1_MASK + 0U, // PseudoVLUXSEG2EI16_V_MF4_MF2 + 0U, // PseudoVLUXSEG2EI16_V_MF4_MF2_MASK + 0U, // PseudoVLUXSEG2EI16_V_MF4_MF4 + 0U, // PseudoVLUXSEG2EI16_V_MF4_MF4_MASK + 0U, // PseudoVLUXSEG2EI16_V_MF4_MF8 + 0U, // PseudoVLUXSEG2EI16_V_MF4_MF8_MASK + 0U, // PseudoVLUXSEG2EI32_V_M1_M1 + 0U, // PseudoVLUXSEG2EI32_V_M1_M1_MASK + 0U, // PseudoVLUXSEG2EI32_V_M1_M2 + 0U, // PseudoVLUXSEG2EI32_V_M1_M2_MASK + 0U, // PseudoVLUXSEG2EI32_V_M1_MF2 + 0U, // PseudoVLUXSEG2EI32_V_M1_MF2_MASK + 0U, // PseudoVLUXSEG2EI32_V_M1_MF4 + 0U, // PseudoVLUXSEG2EI32_V_M1_MF4_MASK + 0U, // PseudoVLUXSEG2EI32_V_M2_M1 + 0U, // PseudoVLUXSEG2EI32_V_M2_M1_MASK + 0U, // PseudoVLUXSEG2EI32_V_M2_M2 + 0U, // PseudoVLUXSEG2EI32_V_M2_M2_MASK + 0U, // PseudoVLUXSEG2EI32_V_M2_M4 + 0U, // PseudoVLUXSEG2EI32_V_M2_M4_MASK + 0U, // PseudoVLUXSEG2EI32_V_M2_MF2 + 0U, // PseudoVLUXSEG2EI32_V_M2_MF2_MASK + 0U, // PseudoVLUXSEG2EI32_V_M4_M1 + 0U, // PseudoVLUXSEG2EI32_V_M4_M1_MASK + 0U, // PseudoVLUXSEG2EI32_V_M4_M2 + 0U, // PseudoVLUXSEG2EI32_V_M4_M2_MASK + 0U, // PseudoVLUXSEG2EI32_V_M4_M4 + 0U, // PseudoVLUXSEG2EI32_V_M4_M4_MASK + 0U, // PseudoVLUXSEG2EI32_V_M8_M2 + 0U, // PseudoVLUXSEG2EI32_V_M8_M2_MASK + 0U, // PseudoVLUXSEG2EI32_V_M8_M4 + 0U, // PseudoVLUXSEG2EI32_V_M8_M4_MASK + 0U, // PseudoVLUXSEG2EI32_V_MF2_M1 + 0U, // PseudoVLUXSEG2EI32_V_MF2_M1_MASK + 0U, // PseudoVLUXSEG2EI32_V_MF2_MF2 + 0U, // PseudoVLUXSEG2EI32_V_MF2_MF2_MASK + 0U, // PseudoVLUXSEG2EI32_V_MF2_MF4 + 0U, // PseudoVLUXSEG2EI32_V_MF2_MF4_MASK + 0U, // PseudoVLUXSEG2EI32_V_MF2_MF8 + 0U, // PseudoVLUXSEG2EI32_V_MF2_MF8_MASK + 0U, // PseudoVLUXSEG2EI64_V_M1_M1 + 0U, // PseudoVLUXSEG2EI64_V_M1_M1_MASK + 0U, // PseudoVLUXSEG2EI64_V_M1_MF2 + 0U, // PseudoVLUXSEG2EI64_V_M1_MF2_MASK + 0U, // PseudoVLUXSEG2EI64_V_M1_MF4 + 0U, // PseudoVLUXSEG2EI64_V_M1_MF4_MASK + 0U, // PseudoVLUXSEG2EI64_V_M1_MF8 + 0U, // PseudoVLUXSEG2EI64_V_M1_MF8_MASK + 0U, // PseudoVLUXSEG2EI64_V_M2_M1 + 0U, // PseudoVLUXSEG2EI64_V_M2_M1_MASK + 0U, // PseudoVLUXSEG2EI64_V_M2_M2 + 0U, // PseudoVLUXSEG2EI64_V_M2_M2_MASK + 0U, // PseudoVLUXSEG2EI64_V_M2_MF2 + 0U, // PseudoVLUXSEG2EI64_V_M2_MF2_MASK + 0U, // PseudoVLUXSEG2EI64_V_M2_MF4 + 0U, // PseudoVLUXSEG2EI64_V_M2_MF4_MASK + 0U, // PseudoVLUXSEG2EI64_V_M4_M1 + 0U, // PseudoVLUXSEG2EI64_V_M4_M1_MASK + 0U, // PseudoVLUXSEG2EI64_V_M4_M2 + 0U, // PseudoVLUXSEG2EI64_V_M4_M2_MASK + 0U, // PseudoVLUXSEG2EI64_V_M4_M4 + 0U, // PseudoVLUXSEG2EI64_V_M4_M4_MASK + 0U, // PseudoVLUXSEG2EI64_V_M4_MF2 + 0U, // PseudoVLUXSEG2EI64_V_M4_MF2_MASK + 0U, // PseudoVLUXSEG2EI64_V_M8_M1 + 0U, // PseudoVLUXSEG2EI64_V_M8_M1_MASK + 0U, // PseudoVLUXSEG2EI64_V_M8_M2 + 0U, // PseudoVLUXSEG2EI64_V_M8_M2_MASK + 0U, // PseudoVLUXSEG2EI64_V_M8_M4 + 0U, // PseudoVLUXSEG2EI64_V_M8_M4_MASK + 0U, // PseudoVLUXSEG2EI8_V_M1_M1 + 0U, // PseudoVLUXSEG2EI8_V_M1_M1_MASK + 0U, // PseudoVLUXSEG2EI8_V_M1_M2 + 0U, // PseudoVLUXSEG2EI8_V_M1_M2_MASK + 0U, // PseudoVLUXSEG2EI8_V_M1_M4 + 0U, // PseudoVLUXSEG2EI8_V_M1_M4_MASK + 0U, // PseudoVLUXSEG2EI8_V_M2_M2 + 0U, // PseudoVLUXSEG2EI8_V_M2_M2_MASK + 0U, // PseudoVLUXSEG2EI8_V_M2_M4 + 0U, // PseudoVLUXSEG2EI8_V_M2_M4_MASK + 0U, // PseudoVLUXSEG2EI8_V_M4_M4 + 0U, // PseudoVLUXSEG2EI8_V_M4_M4_MASK + 0U, // PseudoVLUXSEG2EI8_V_MF2_M1 + 0U, // PseudoVLUXSEG2EI8_V_MF2_M1_MASK + 0U, // PseudoVLUXSEG2EI8_V_MF2_M2 + 0U, // PseudoVLUXSEG2EI8_V_MF2_M2_MASK + 0U, // PseudoVLUXSEG2EI8_V_MF2_M4 + 0U, // PseudoVLUXSEG2EI8_V_MF2_M4_MASK + 0U, // PseudoVLUXSEG2EI8_V_MF2_MF2 + 0U, // PseudoVLUXSEG2EI8_V_MF2_MF2_MASK + 0U, // PseudoVLUXSEG2EI8_V_MF4_M1 + 0U, // PseudoVLUXSEG2EI8_V_MF4_M1_MASK + 0U, // PseudoVLUXSEG2EI8_V_MF4_M2 + 0U, // PseudoVLUXSEG2EI8_V_MF4_M2_MASK + 0U, // PseudoVLUXSEG2EI8_V_MF4_MF2 + 0U, // PseudoVLUXSEG2EI8_V_MF4_MF2_MASK + 0U, // PseudoVLUXSEG2EI8_V_MF4_MF4 + 0U, // PseudoVLUXSEG2EI8_V_MF4_MF4_MASK + 0U, // PseudoVLUXSEG2EI8_V_MF8_M1 + 0U, // PseudoVLUXSEG2EI8_V_MF8_M1_MASK + 0U, // PseudoVLUXSEG2EI8_V_MF8_MF2 + 0U, // PseudoVLUXSEG2EI8_V_MF8_MF2_MASK + 0U, // PseudoVLUXSEG2EI8_V_MF8_MF4 + 0U, // PseudoVLUXSEG2EI8_V_MF8_MF4_MASK + 0U, // PseudoVLUXSEG2EI8_V_MF8_MF8 + 0U, // PseudoVLUXSEG2EI8_V_MF8_MF8_MASK + 0U, // PseudoVLUXSEG3EI16_V_M1_M1 + 0U, // PseudoVLUXSEG3EI16_V_M1_M1_MASK + 0U, // PseudoVLUXSEG3EI16_V_M1_M2 + 0U, // PseudoVLUXSEG3EI16_V_M1_M2_MASK + 0U, // PseudoVLUXSEG3EI16_V_M1_MF2 + 0U, // PseudoVLUXSEG3EI16_V_M1_MF2_MASK + 0U, // PseudoVLUXSEG3EI16_V_M2_M1 + 0U, // PseudoVLUXSEG3EI16_V_M2_M1_MASK + 0U, // PseudoVLUXSEG3EI16_V_M2_M2 + 0U, // PseudoVLUXSEG3EI16_V_M2_M2_MASK + 0U, // PseudoVLUXSEG3EI16_V_M4_M2 + 0U, // PseudoVLUXSEG3EI16_V_M4_M2_MASK + 0U, // PseudoVLUXSEG3EI16_V_MF2_M1 + 0U, // PseudoVLUXSEG3EI16_V_MF2_M1_MASK + 0U, // PseudoVLUXSEG3EI16_V_MF2_M2 + 0U, // PseudoVLUXSEG3EI16_V_MF2_M2_MASK + 0U, // PseudoVLUXSEG3EI16_V_MF2_MF2 + 0U, // PseudoVLUXSEG3EI16_V_MF2_MF2_MASK + 0U, // PseudoVLUXSEG3EI16_V_MF2_MF4 + 0U, // PseudoVLUXSEG3EI16_V_MF2_MF4_MASK + 0U, // PseudoVLUXSEG3EI16_V_MF4_M1 + 0U, // PseudoVLUXSEG3EI16_V_MF4_M1_MASK + 0U, // PseudoVLUXSEG3EI16_V_MF4_MF2 + 0U, // PseudoVLUXSEG3EI16_V_MF4_MF2_MASK + 0U, // PseudoVLUXSEG3EI16_V_MF4_MF4 + 0U, // PseudoVLUXSEG3EI16_V_MF4_MF4_MASK + 0U, // PseudoVLUXSEG3EI16_V_MF4_MF8 + 0U, // PseudoVLUXSEG3EI16_V_MF4_MF8_MASK + 0U, // PseudoVLUXSEG3EI32_V_M1_M1 + 0U, // PseudoVLUXSEG3EI32_V_M1_M1_MASK + 0U, // PseudoVLUXSEG3EI32_V_M1_M2 + 0U, // PseudoVLUXSEG3EI32_V_M1_M2_MASK + 0U, // PseudoVLUXSEG3EI32_V_M1_MF2 + 0U, // PseudoVLUXSEG3EI32_V_M1_MF2_MASK + 0U, // PseudoVLUXSEG3EI32_V_M1_MF4 + 0U, // PseudoVLUXSEG3EI32_V_M1_MF4_MASK + 0U, // PseudoVLUXSEG3EI32_V_M2_M1 + 0U, // PseudoVLUXSEG3EI32_V_M2_M1_MASK + 0U, // PseudoVLUXSEG3EI32_V_M2_M2 + 0U, // PseudoVLUXSEG3EI32_V_M2_M2_MASK + 0U, // PseudoVLUXSEG3EI32_V_M2_MF2 + 0U, // PseudoVLUXSEG3EI32_V_M2_MF2_MASK + 0U, // PseudoVLUXSEG3EI32_V_M4_M1 + 0U, // PseudoVLUXSEG3EI32_V_M4_M1_MASK + 0U, // PseudoVLUXSEG3EI32_V_M4_M2 + 0U, // PseudoVLUXSEG3EI32_V_M4_M2_MASK + 0U, // PseudoVLUXSEG3EI32_V_M8_M2 + 0U, // PseudoVLUXSEG3EI32_V_M8_M2_MASK + 0U, // PseudoVLUXSEG3EI32_V_MF2_M1 + 0U, // PseudoVLUXSEG3EI32_V_MF2_M1_MASK + 0U, // PseudoVLUXSEG3EI32_V_MF2_MF2 + 0U, // PseudoVLUXSEG3EI32_V_MF2_MF2_MASK + 0U, // PseudoVLUXSEG3EI32_V_MF2_MF4 + 0U, // PseudoVLUXSEG3EI32_V_MF2_MF4_MASK + 0U, // PseudoVLUXSEG3EI32_V_MF2_MF8 + 0U, // PseudoVLUXSEG3EI32_V_MF2_MF8_MASK + 0U, // PseudoVLUXSEG3EI64_V_M1_M1 + 0U, // PseudoVLUXSEG3EI64_V_M1_M1_MASK + 0U, // PseudoVLUXSEG3EI64_V_M1_MF2 + 0U, // PseudoVLUXSEG3EI64_V_M1_MF2_MASK + 0U, // PseudoVLUXSEG3EI64_V_M1_MF4 + 0U, // PseudoVLUXSEG3EI64_V_M1_MF4_MASK + 0U, // PseudoVLUXSEG3EI64_V_M1_MF8 + 0U, // PseudoVLUXSEG3EI64_V_M1_MF8_MASK + 0U, // PseudoVLUXSEG3EI64_V_M2_M1 + 0U, // PseudoVLUXSEG3EI64_V_M2_M1_MASK + 0U, // PseudoVLUXSEG3EI64_V_M2_M2 + 0U, // PseudoVLUXSEG3EI64_V_M2_M2_MASK + 0U, // PseudoVLUXSEG3EI64_V_M2_MF2 + 0U, // PseudoVLUXSEG3EI64_V_M2_MF2_MASK + 0U, // PseudoVLUXSEG3EI64_V_M2_MF4 + 0U, // PseudoVLUXSEG3EI64_V_M2_MF4_MASK + 0U, // PseudoVLUXSEG3EI64_V_M4_M1 + 0U, // PseudoVLUXSEG3EI64_V_M4_M1_MASK + 0U, // PseudoVLUXSEG3EI64_V_M4_M2 + 0U, // PseudoVLUXSEG3EI64_V_M4_M2_MASK + 0U, // PseudoVLUXSEG3EI64_V_M4_MF2 + 0U, // PseudoVLUXSEG3EI64_V_M4_MF2_MASK + 0U, // PseudoVLUXSEG3EI64_V_M8_M1 + 0U, // PseudoVLUXSEG3EI64_V_M8_M1_MASK + 0U, // PseudoVLUXSEG3EI64_V_M8_M2 + 0U, // PseudoVLUXSEG3EI64_V_M8_M2_MASK + 0U, // PseudoVLUXSEG3EI8_V_M1_M1 + 0U, // PseudoVLUXSEG3EI8_V_M1_M1_MASK + 0U, // PseudoVLUXSEG3EI8_V_M1_M2 + 0U, // PseudoVLUXSEG3EI8_V_M1_M2_MASK + 0U, // PseudoVLUXSEG3EI8_V_M2_M2 + 0U, // PseudoVLUXSEG3EI8_V_M2_M2_MASK + 0U, // PseudoVLUXSEG3EI8_V_MF2_M1 + 0U, // PseudoVLUXSEG3EI8_V_MF2_M1_MASK + 0U, // PseudoVLUXSEG3EI8_V_MF2_M2 + 0U, // PseudoVLUXSEG3EI8_V_MF2_M2_MASK + 0U, // PseudoVLUXSEG3EI8_V_MF2_MF2 + 0U, // PseudoVLUXSEG3EI8_V_MF2_MF2_MASK + 0U, // PseudoVLUXSEG3EI8_V_MF4_M1 + 0U, // PseudoVLUXSEG3EI8_V_MF4_M1_MASK + 0U, // PseudoVLUXSEG3EI8_V_MF4_M2 + 0U, // PseudoVLUXSEG3EI8_V_MF4_M2_MASK + 0U, // PseudoVLUXSEG3EI8_V_MF4_MF2 + 0U, // PseudoVLUXSEG3EI8_V_MF4_MF2_MASK + 0U, // PseudoVLUXSEG3EI8_V_MF4_MF4 + 0U, // PseudoVLUXSEG3EI8_V_MF4_MF4_MASK + 0U, // PseudoVLUXSEG3EI8_V_MF8_M1 + 0U, // PseudoVLUXSEG3EI8_V_MF8_M1_MASK + 0U, // PseudoVLUXSEG3EI8_V_MF8_MF2 + 0U, // PseudoVLUXSEG3EI8_V_MF8_MF2_MASK + 0U, // PseudoVLUXSEG3EI8_V_MF8_MF4 + 0U, // PseudoVLUXSEG3EI8_V_MF8_MF4_MASK + 0U, // PseudoVLUXSEG3EI8_V_MF8_MF8 + 0U, // PseudoVLUXSEG3EI8_V_MF8_MF8_MASK + 0U, // PseudoVLUXSEG4EI16_V_M1_M1 + 0U, // PseudoVLUXSEG4EI16_V_M1_M1_MASK + 0U, // PseudoVLUXSEG4EI16_V_M1_M2 + 0U, // PseudoVLUXSEG4EI16_V_M1_M2_MASK + 0U, // PseudoVLUXSEG4EI16_V_M1_MF2 + 0U, // PseudoVLUXSEG4EI16_V_M1_MF2_MASK + 0U, // PseudoVLUXSEG4EI16_V_M2_M1 + 0U, // PseudoVLUXSEG4EI16_V_M2_M1_MASK + 0U, // PseudoVLUXSEG4EI16_V_M2_M2 + 0U, // PseudoVLUXSEG4EI16_V_M2_M2_MASK + 0U, // PseudoVLUXSEG4EI16_V_M4_M2 + 0U, // PseudoVLUXSEG4EI16_V_M4_M2_MASK + 0U, // PseudoVLUXSEG4EI16_V_MF2_M1 + 0U, // PseudoVLUXSEG4EI16_V_MF2_M1_MASK + 0U, // PseudoVLUXSEG4EI16_V_MF2_M2 + 0U, // PseudoVLUXSEG4EI16_V_MF2_M2_MASK + 0U, // PseudoVLUXSEG4EI16_V_MF2_MF2 + 0U, // PseudoVLUXSEG4EI16_V_MF2_MF2_MASK + 0U, // PseudoVLUXSEG4EI16_V_MF2_MF4 + 0U, // PseudoVLUXSEG4EI16_V_MF2_MF4_MASK + 0U, // PseudoVLUXSEG4EI16_V_MF4_M1 + 0U, // PseudoVLUXSEG4EI16_V_MF4_M1_MASK + 0U, // PseudoVLUXSEG4EI16_V_MF4_MF2 + 0U, // PseudoVLUXSEG4EI16_V_MF4_MF2_MASK + 0U, // PseudoVLUXSEG4EI16_V_MF4_MF4 + 0U, // PseudoVLUXSEG4EI16_V_MF4_MF4_MASK + 0U, // PseudoVLUXSEG4EI16_V_MF4_MF8 + 0U, // PseudoVLUXSEG4EI16_V_MF4_MF8_MASK + 0U, // PseudoVLUXSEG4EI32_V_M1_M1 + 0U, // PseudoVLUXSEG4EI32_V_M1_M1_MASK + 0U, // PseudoVLUXSEG4EI32_V_M1_M2 + 0U, // PseudoVLUXSEG4EI32_V_M1_M2_MASK + 0U, // PseudoVLUXSEG4EI32_V_M1_MF2 + 0U, // PseudoVLUXSEG4EI32_V_M1_MF2_MASK + 0U, // PseudoVLUXSEG4EI32_V_M1_MF4 + 0U, // PseudoVLUXSEG4EI32_V_M1_MF4_MASK + 0U, // PseudoVLUXSEG4EI32_V_M2_M1 + 0U, // PseudoVLUXSEG4EI32_V_M2_M1_MASK + 0U, // PseudoVLUXSEG4EI32_V_M2_M2 + 0U, // PseudoVLUXSEG4EI32_V_M2_M2_MASK + 0U, // PseudoVLUXSEG4EI32_V_M2_MF2 + 0U, // PseudoVLUXSEG4EI32_V_M2_MF2_MASK + 0U, // PseudoVLUXSEG4EI32_V_M4_M1 + 0U, // PseudoVLUXSEG4EI32_V_M4_M1_MASK + 0U, // PseudoVLUXSEG4EI32_V_M4_M2 + 0U, // PseudoVLUXSEG4EI32_V_M4_M2_MASK + 0U, // PseudoVLUXSEG4EI32_V_M8_M2 + 0U, // PseudoVLUXSEG4EI32_V_M8_M2_MASK + 0U, // PseudoVLUXSEG4EI32_V_MF2_M1 + 0U, // PseudoVLUXSEG4EI32_V_MF2_M1_MASK + 0U, // PseudoVLUXSEG4EI32_V_MF2_MF2 + 0U, // PseudoVLUXSEG4EI32_V_MF2_MF2_MASK + 0U, // PseudoVLUXSEG4EI32_V_MF2_MF4 + 0U, // PseudoVLUXSEG4EI32_V_MF2_MF4_MASK + 0U, // PseudoVLUXSEG4EI32_V_MF2_MF8 + 0U, // PseudoVLUXSEG4EI32_V_MF2_MF8_MASK + 0U, // PseudoVLUXSEG4EI64_V_M1_M1 + 0U, // PseudoVLUXSEG4EI64_V_M1_M1_MASK + 0U, // PseudoVLUXSEG4EI64_V_M1_MF2 + 0U, // PseudoVLUXSEG4EI64_V_M1_MF2_MASK + 0U, // PseudoVLUXSEG4EI64_V_M1_MF4 + 0U, // PseudoVLUXSEG4EI64_V_M1_MF4_MASK + 0U, // PseudoVLUXSEG4EI64_V_M1_MF8 + 0U, // PseudoVLUXSEG4EI64_V_M1_MF8_MASK + 0U, // PseudoVLUXSEG4EI64_V_M2_M1 + 0U, // PseudoVLUXSEG4EI64_V_M2_M1_MASK + 0U, // PseudoVLUXSEG4EI64_V_M2_M2 + 0U, // PseudoVLUXSEG4EI64_V_M2_M2_MASK + 0U, // PseudoVLUXSEG4EI64_V_M2_MF2 + 0U, // PseudoVLUXSEG4EI64_V_M2_MF2_MASK + 0U, // PseudoVLUXSEG4EI64_V_M2_MF4 + 0U, // PseudoVLUXSEG4EI64_V_M2_MF4_MASK + 0U, // PseudoVLUXSEG4EI64_V_M4_M1 + 0U, // PseudoVLUXSEG4EI64_V_M4_M1_MASK + 0U, // PseudoVLUXSEG4EI64_V_M4_M2 + 0U, // PseudoVLUXSEG4EI64_V_M4_M2_MASK + 0U, // PseudoVLUXSEG4EI64_V_M4_MF2 + 0U, // PseudoVLUXSEG4EI64_V_M4_MF2_MASK + 0U, // PseudoVLUXSEG4EI64_V_M8_M1 + 0U, // PseudoVLUXSEG4EI64_V_M8_M1_MASK + 0U, // PseudoVLUXSEG4EI64_V_M8_M2 + 0U, // PseudoVLUXSEG4EI64_V_M8_M2_MASK + 0U, // PseudoVLUXSEG4EI8_V_M1_M1 + 0U, // PseudoVLUXSEG4EI8_V_M1_M1_MASK + 0U, // PseudoVLUXSEG4EI8_V_M1_M2 + 0U, // PseudoVLUXSEG4EI8_V_M1_M2_MASK + 0U, // PseudoVLUXSEG4EI8_V_M2_M2 + 0U, // PseudoVLUXSEG4EI8_V_M2_M2_MASK + 0U, // PseudoVLUXSEG4EI8_V_MF2_M1 + 0U, // PseudoVLUXSEG4EI8_V_MF2_M1_MASK + 0U, // PseudoVLUXSEG4EI8_V_MF2_M2 + 0U, // PseudoVLUXSEG4EI8_V_MF2_M2_MASK + 0U, // PseudoVLUXSEG4EI8_V_MF2_MF2 + 0U, // PseudoVLUXSEG4EI8_V_MF2_MF2_MASK + 0U, // PseudoVLUXSEG4EI8_V_MF4_M1 + 0U, // PseudoVLUXSEG4EI8_V_MF4_M1_MASK + 0U, // PseudoVLUXSEG4EI8_V_MF4_M2 + 0U, // PseudoVLUXSEG4EI8_V_MF4_M2_MASK + 0U, // PseudoVLUXSEG4EI8_V_MF4_MF2 + 0U, // PseudoVLUXSEG4EI8_V_MF4_MF2_MASK + 0U, // PseudoVLUXSEG4EI8_V_MF4_MF4 + 0U, // PseudoVLUXSEG4EI8_V_MF4_MF4_MASK + 0U, // PseudoVLUXSEG4EI8_V_MF8_M1 + 0U, // PseudoVLUXSEG4EI8_V_MF8_M1_MASK + 0U, // PseudoVLUXSEG4EI8_V_MF8_MF2 + 0U, // PseudoVLUXSEG4EI8_V_MF8_MF2_MASK + 0U, // PseudoVLUXSEG4EI8_V_MF8_MF4 + 0U, // PseudoVLUXSEG4EI8_V_MF8_MF4_MASK + 0U, // PseudoVLUXSEG4EI8_V_MF8_MF8 + 0U, // PseudoVLUXSEG4EI8_V_MF8_MF8_MASK + 0U, // PseudoVLUXSEG5EI16_V_M1_M1 + 0U, // PseudoVLUXSEG5EI16_V_M1_M1_MASK + 0U, // PseudoVLUXSEG5EI16_V_M1_MF2 + 0U, // PseudoVLUXSEG5EI16_V_M1_MF2_MASK + 0U, // PseudoVLUXSEG5EI16_V_M2_M1 + 0U, // PseudoVLUXSEG5EI16_V_M2_M1_MASK + 0U, // PseudoVLUXSEG5EI16_V_MF2_M1 + 0U, // PseudoVLUXSEG5EI16_V_MF2_M1_MASK + 0U, // PseudoVLUXSEG5EI16_V_MF2_MF2 + 0U, // PseudoVLUXSEG5EI16_V_MF2_MF2_MASK + 0U, // PseudoVLUXSEG5EI16_V_MF2_MF4 + 0U, // PseudoVLUXSEG5EI16_V_MF2_MF4_MASK + 0U, // PseudoVLUXSEG5EI16_V_MF4_M1 + 0U, // PseudoVLUXSEG5EI16_V_MF4_M1_MASK + 0U, // PseudoVLUXSEG5EI16_V_MF4_MF2 + 0U, // PseudoVLUXSEG5EI16_V_MF4_MF2_MASK + 0U, // PseudoVLUXSEG5EI16_V_MF4_MF4 + 0U, // PseudoVLUXSEG5EI16_V_MF4_MF4_MASK + 0U, // PseudoVLUXSEG5EI16_V_MF4_MF8 + 0U, // PseudoVLUXSEG5EI16_V_MF4_MF8_MASK + 0U, // PseudoVLUXSEG5EI32_V_M1_M1 + 0U, // PseudoVLUXSEG5EI32_V_M1_M1_MASK + 0U, // PseudoVLUXSEG5EI32_V_M1_MF2 + 0U, // PseudoVLUXSEG5EI32_V_M1_MF2_MASK + 0U, // PseudoVLUXSEG5EI32_V_M1_MF4 + 0U, // PseudoVLUXSEG5EI32_V_M1_MF4_MASK + 0U, // PseudoVLUXSEG5EI32_V_M2_M1 + 0U, // PseudoVLUXSEG5EI32_V_M2_M1_MASK + 0U, // PseudoVLUXSEG5EI32_V_M2_MF2 + 0U, // PseudoVLUXSEG5EI32_V_M2_MF2_MASK + 0U, // PseudoVLUXSEG5EI32_V_M4_M1 + 0U, // PseudoVLUXSEG5EI32_V_M4_M1_MASK + 0U, // PseudoVLUXSEG5EI32_V_MF2_M1 + 0U, // PseudoVLUXSEG5EI32_V_MF2_M1_MASK + 0U, // PseudoVLUXSEG5EI32_V_MF2_MF2 + 0U, // PseudoVLUXSEG5EI32_V_MF2_MF2_MASK + 0U, // PseudoVLUXSEG5EI32_V_MF2_MF4 + 0U, // PseudoVLUXSEG5EI32_V_MF2_MF4_MASK + 0U, // PseudoVLUXSEG5EI32_V_MF2_MF8 + 0U, // PseudoVLUXSEG5EI32_V_MF2_MF8_MASK + 0U, // PseudoVLUXSEG5EI64_V_M1_M1 + 0U, // PseudoVLUXSEG5EI64_V_M1_M1_MASK + 0U, // PseudoVLUXSEG5EI64_V_M1_MF2 + 0U, // PseudoVLUXSEG5EI64_V_M1_MF2_MASK + 0U, // PseudoVLUXSEG5EI64_V_M1_MF4 + 0U, // PseudoVLUXSEG5EI64_V_M1_MF4_MASK + 0U, // PseudoVLUXSEG5EI64_V_M1_MF8 + 0U, // PseudoVLUXSEG5EI64_V_M1_MF8_MASK + 0U, // PseudoVLUXSEG5EI64_V_M2_M1 + 0U, // PseudoVLUXSEG5EI64_V_M2_M1_MASK + 0U, // PseudoVLUXSEG5EI64_V_M2_MF2 + 0U, // PseudoVLUXSEG5EI64_V_M2_MF2_MASK + 0U, // PseudoVLUXSEG5EI64_V_M2_MF4 + 0U, // PseudoVLUXSEG5EI64_V_M2_MF4_MASK + 0U, // PseudoVLUXSEG5EI64_V_M4_M1 + 0U, // PseudoVLUXSEG5EI64_V_M4_M1_MASK + 0U, // PseudoVLUXSEG5EI64_V_M4_MF2 + 0U, // PseudoVLUXSEG5EI64_V_M4_MF2_MASK + 0U, // PseudoVLUXSEG5EI64_V_M8_M1 + 0U, // PseudoVLUXSEG5EI64_V_M8_M1_MASK + 0U, // PseudoVLUXSEG5EI8_V_M1_M1 + 0U, // PseudoVLUXSEG5EI8_V_M1_M1_MASK + 0U, // PseudoVLUXSEG5EI8_V_MF2_M1 + 0U, // PseudoVLUXSEG5EI8_V_MF2_M1_MASK + 0U, // PseudoVLUXSEG5EI8_V_MF2_MF2 + 0U, // PseudoVLUXSEG5EI8_V_MF2_MF2_MASK + 0U, // PseudoVLUXSEG5EI8_V_MF4_M1 + 0U, // PseudoVLUXSEG5EI8_V_MF4_M1_MASK + 0U, // PseudoVLUXSEG5EI8_V_MF4_MF2 + 0U, // PseudoVLUXSEG5EI8_V_MF4_MF2_MASK + 0U, // PseudoVLUXSEG5EI8_V_MF4_MF4 + 0U, // PseudoVLUXSEG5EI8_V_MF4_MF4_MASK + 0U, // PseudoVLUXSEG5EI8_V_MF8_M1 + 0U, // PseudoVLUXSEG5EI8_V_MF8_M1_MASK + 0U, // PseudoVLUXSEG5EI8_V_MF8_MF2 + 0U, // PseudoVLUXSEG5EI8_V_MF8_MF2_MASK + 0U, // PseudoVLUXSEG5EI8_V_MF8_MF4 + 0U, // PseudoVLUXSEG5EI8_V_MF8_MF4_MASK + 0U, // PseudoVLUXSEG5EI8_V_MF8_MF8 + 0U, // PseudoVLUXSEG5EI8_V_MF8_MF8_MASK + 0U, // PseudoVLUXSEG6EI16_V_M1_M1 + 0U, // PseudoVLUXSEG6EI16_V_M1_M1_MASK + 0U, // PseudoVLUXSEG6EI16_V_M1_MF2 + 0U, // PseudoVLUXSEG6EI16_V_M1_MF2_MASK + 0U, // PseudoVLUXSEG6EI16_V_M2_M1 + 0U, // PseudoVLUXSEG6EI16_V_M2_M1_MASK + 0U, // PseudoVLUXSEG6EI16_V_MF2_M1 + 0U, // PseudoVLUXSEG6EI16_V_MF2_M1_MASK + 0U, // PseudoVLUXSEG6EI16_V_MF2_MF2 + 0U, // PseudoVLUXSEG6EI16_V_MF2_MF2_MASK + 0U, // PseudoVLUXSEG6EI16_V_MF2_MF4 + 0U, // PseudoVLUXSEG6EI16_V_MF2_MF4_MASK + 0U, // PseudoVLUXSEG6EI16_V_MF4_M1 + 0U, // PseudoVLUXSEG6EI16_V_MF4_M1_MASK + 0U, // PseudoVLUXSEG6EI16_V_MF4_MF2 + 0U, // PseudoVLUXSEG6EI16_V_MF4_MF2_MASK + 0U, // PseudoVLUXSEG6EI16_V_MF4_MF4 + 0U, // PseudoVLUXSEG6EI16_V_MF4_MF4_MASK + 0U, // PseudoVLUXSEG6EI16_V_MF4_MF8 + 0U, // PseudoVLUXSEG6EI16_V_MF4_MF8_MASK + 0U, // PseudoVLUXSEG6EI32_V_M1_M1 + 0U, // PseudoVLUXSEG6EI32_V_M1_M1_MASK + 0U, // PseudoVLUXSEG6EI32_V_M1_MF2 + 0U, // PseudoVLUXSEG6EI32_V_M1_MF2_MASK + 0U, // PseudoVLUXSEG6EI32_V_M1_MF4 + 0U, // PseudoVLUXSEG6EI32_V_M1_MF4_MASK + 0U, // PseudoVLUXSEG6EI32_V_M2_M1 + 0U, // PseudoVLUXSEG6EI32_V_M2_M1_MASK + 0U, // PseudoVLUXSEG6EI32_V_M2_MF2 + 0U, // PseudoVLUXSEG6EI32_V_M2_MF2_MASK + 0U, // PseudoVLUXSEG6EI32_V_M4_M1 + 0U, // PseudoVLUXSEG6EI32_V_M4_M1_MASK + 0U, // PseudoVLUXSEG6EI32_V_MF2_M1 + 0U, // PseudoVLUXSEG6EI32_V_MF2_M1_MASK + 0U, // PseudoVLUXSEG6EI32_V_MF2_MF2 + 0U, // PseudoVLUXSEG6EI32_V_MF2_MF2_MASK + 0U, // PseudoVLUXSEG6EI32_V_MF2_MF4 + 0U, // PseudoVLUXSEG6EI32_V_MF2_MF4_MASK + 0U, // PseudoVLUXSEG6EI32_V_MF2_MF8 + 0U, // PseudoVLUXSEG6EI32_V_MF2_MF8_MASK + 0U, // PseudoVLUXSEG6EI64_V_M1_M1 + 0U, // PseudoVLUXSEG6EI64_V_M1_M1_MASK + 0U, // PseudoVLUXSEG6EI64_V_M1_MF2 + 0U, // PseudoVLUXSEG6EI64_V_M1_MF2_MASK + 0U, // PseudoVLUXSEG6EI64_V_M1_MF4 + 0U, // PseudoVLUXSEG6EI64_V_M1_MF4_MASK + 0U, // PseudoVLUXSEG6EI64_V_M1_MF8 + 0U, // PseudoVLUXSEG6EI64_V_M1_MF8_MASK + 0U, // PseudoVLUXSEG6EI64_V_M2_M1 + 0U, // PseudoVLUXSEG6EI64_V_M2_M1_MASK + 0U, // PseudoVLUXSEG6EI64_V_M2_MF2 + 0U, // PseudoVLUXSEG6EI64_V_M2_MF2_MASK + 0U, // PseudoVLUXSEG6EI64_V_M2_MF4 + 0U, // PseudoVLUXSEG6EI64_V_M2_MF4_MASK + 0U, // PseudoVLUXSEG6EI64_V_M4_M1 + 0U, // PseudoVLUXSEG6EI64_V_M4_M1_MASK + 0U, // PseudoVLUXSEG6EI64_V_M4_MF2 + 0U, // PseudoVLUXSEG6EI64_V_M4_MF2_MASK + 0U, // PseudoVLUXSEG6EI64_V_M8_M1 + 0U, // PseudoVLUXSEG6EI64_V_M8_M1_MASK + 0U, // PseudoVLUXSEG6EI8_V_M1_M1 + 0U, // PseudoVLUXSEG6EI8_V_M1_M1_MASK + 0U, // PseudoVLUXSEG6EI8_V_MF2_M1 + 0U, // PseudoVLUXSEG6EI8_V_MF2_M1_MASK + 0U, // PseudoVLUXSEG6EI8_V_MF2_MF2 + 0U, // PseudoVLUXSEG6EI8_V_MF2_MF2_MASK + 0U, // PseudoVLUXSEG6EI8_V_MF4_M1 + 0U, // PseudoVLUXSEG6EI8_V_MF4_M1_MASK + 0U, // PseudoVLUXSEG6EI8_V_MF4_MF2 + 0U, // PseudoVLUXSEG6EI8_V_MF4_MF2_MASK + 0U, // PseudoVLUXSEG6EI8_V_MF4_MF4 + 0U, // PseudoVLUXSEG6EI8_V_MF4_MF4_MASK + 0U, // PseudoVLUXSEG6EI8_V_MF8_M1 + 0U, // PseudoVLUXSEG6EI8_V_MF8_M1_MASK + 0U, // PseudoVLUXSEG6EI8_V_MF8_MF2 + 0U, // PseudoVLUXSEG6EI8_V_MF8_MF2_MASK + 0U, // PseudoVLUXSEG6EI8_V_MF8_MF4 + 0U, // PseudoVLUXSEG6EI8_V_MF8_MF4_MASK + 0U, // PseudoVLUXSEG6EI8_V_MF8_MF8 + 0U, // PseudoVLUXSEG6EI8_V_MF8_MF8_MASK + 0U, // PseudoVLUXSEG7EI16_V_M1_M1 + 0U, // PseudoVLUXSEG7EI16_V_M1_M1_MASK + 0U, // PseudoVLUXSEG7EI16_V_M1_MF2 + 0U, // PseudoVLUXSEG7EI16_V_M1_MF2_MASK + 0U, // PseudoVLUXSEG7EI16_V_M2_M1 + 0U, // PseudoVLUXSEG7EI16_V_M2_M1_MASK + 0U, // PseudoVLUXSEG7EI16_V_MF2_M1 + 0U, // PseudoVLUXSEG7EI16_V_MF2_M1_MASK + 0U, // PseudoVLUXSEG7EI16_V_MF2_MF2 + 0U, // PseudoVLUXSEG7EI16_V_MF2_MF2_MASK + 0U, // PseudoVLUXSEG7EI16_V_MF2_MF4 + 0U, // PseudoVLUXSEG7EI16_V_MF2_MF4_MASK + 0U, // PseudoVLUXSEG7EI16_V_MF4_M1 + 0U, // PseudoVLUXSEG7EI16_V_MF4_M1_MASK + 0U, // PseudoVLUXSEG7EI16_V_MF4_MF2 + 0U, // PseudoVLUXSEG7EI16_V_MF4_MF2_MASK + 0U, // PseudoVLUXSEG7EI16_V_MF4_MF4 + 0U, // PseudoVLUXSEG7EI16_V_MF4_MF4_MASK + 0U, // PseudoVLUXSEG7EI16_V_MF4_MF8 + 0U, // PseudoVLUXSEG7EI16_V_MF4_MF8_MASK + 0U, // PseudoVLUXSEG7EI32_V_M1_M1 + 0U, // PseudoVLUXSEG7EI32_V_M1_M1_MASK + 0U, // PseudoVLUXSEG7EI32_V_M1_MF2 + 0U, // PseudoVLUXSEG7EI32_V_M1_MF2_MASK + 0U, // PseudoVLUXSEG7EI32_V_M1_MF4 + 0U, // PseudoVLUXSEG7EI32_V_M1_MF4_MASK + 0U, // PseudoVLUXSEG7EI32_V_M2_M1 + 0U, // PseudoVLUXSEG7EI32_V_M2_M1_MASK + 0U, // PseudoVLUXSEG7EI32_V_M2_MF2 + 0U, // PseudoVLUXSEG7EI32_V_M2_MF2_MASK + 0U, // PseudoVLUXSEG7EI32_V_M4_M1 + 0U, // PseudoVLUXSEG7EI32_V_M4_M1_MASK + 0U, // PseudoVLUXSEG7EI32_V_MF2_M1 + 0U, // PseudoVLUXSEG7EI32_V_MF2_M1_MASK + 0U, // PseudoVLUXSEG7EI32_V_MF2_MF2 + 0U, // PseudoVLUXSEG7EI32_V_MF2_MF2_MASK + 0U, // PseudoVLUXSEG7EI32_V_MF2_MF4 + 0U, // PseudoVLUXSEG7EI32_V_MF2_MF4_MASK + 0U, // PseudoVLUXSEG7EI32_V_MF2_MF8 + 0U, // PseudoVLUXSEG7EI32_V_MF2_MF8_MASK + 0U, // PseudoVLUXSEG7EI64_V_M1_M1 + 0U, // PseudoVLUXSEG7EI64_V_M1_M1_MASK + 0U, // PseudoVLUXSEG7EI64_V_M1_MF2 + 0U, // PseudoVLUXSEG7EI64_V_M1_MF2_MASK + 0U, // PseudoVLUXSEG7EI64_V_M1_MF4 + 0U, // PseudoVLUXSEG7EI64_V_M1_MF4_MASK + 0U, // PseudoVLUXSEG7EI64_V_M1_MF8 + 0U, // PseudoVLUXSEG7EI64_V_M1_MF8_MASK + 0U, // PseudoVLUXSEG7EI64_V_M2_M1 + 0U, // PseudoVLUXSEG7EI64_V_M2_M1_MASK + 0U, // PseudoVLUXSEG7EI64_V_M2_MF2 + 0U, // PseudoVLUXSEG7EI64_V_M2_MF2_MASK + 0U, // PseudoVLUXSEG7EI64_V_M2_MF4 + 0U, // PseudoVLUXSEG7EI64_V_M2_MF4_MASK + 0U, // PseudoVLUXSEG7EI64_V_M4_M1 + 0U, // PseudoVLUXSEG7EI64_V_M4_M1_MASK + 0U, // PseudoVLUXSEG7EI64_V_M4_MF2 + 0U, // PseudoVLUXSEG7EI64_V_M4_MF2_MASK + 0U, // PseudoVLUXSEG7EI64_V_M8_M1 + 0U, // PseudoVLUXSEG7EI64_V_M8_M1_MASK + 0U, // PseudoVLUXSEG7EI8_V_M1_M1 + 0U, // PseudoVLUXSEG7EI8_V_M1_M1_MASK + 0U, // PseudoVLUXSEG7EI8_V_MF2_M1 + 0U, // PseudoVLUXSEG7EI8_V_MF2_M1_MASK + 0U, // PseudoVLUXSEG7EI8_V_MF2_MF2 + 0U, // PseudoVLUXSEG7EI8_V_MF2_MF2_MASK + 0U, // PseudoVLUXSEG7EI8_V_MF4_M1 + 0U, // PseudoVLUXSEG7EI8_V_MF4_M1_MASK + 0U, // PseudoVLUXSEG7EI8_V_MF4_MF2 + 0U, // PseudoVLUXSEG7EI8_V_MF4_MF2_MASK + 0U, // PseudoVLUXSEG7EI8_V_MF4_MF4 + 0U, // PseudoVLUXSEG7EI8_V_MF4_MF4_MASK + 0U, // PseudoVLUXSEG7EI8_V_MF8_M1 + 0U, // PseudoVLUXSEG7EI8_V_MF8_M1_MASK + 0U, // PseudoVLUXSEG7EI8_V_MF8_MF2 + 0U, // PseudoVLUXSEG7EI8_V_MF8_MF2_MASK + 0U, // PseudoVLUXSEG7EI8_V_MF8_MF4 + 0U, // PseudoVLUXSEG7EI8_V_MF8_MF4_MASK + 0U, // PseudoVLUXSEG7EI8_V_MF8_MF8 + 0U, // PseudoVLUXSEG7EI8_V_MF8_MF8_MASK + 0U, // PseudoVLUXSEG8EI16_V_M1_M1 + 0U, // PseudoVLUXSEG8EI16_V_M1_M1_MASK + 0U, // PseudoVLUXSEG8EI16_V_M1_MF2 + 0U, // PseudoVLUXSEG8EI16_V_M1_MF2_MASK + 0U, // PseudoVLUXSEG8EI16_V_M2_M1 + 0U, // PseudoVLUXSEG8EI16_V_M2_M1_MASK + 0U, // PseudoVLUXSEG8EI16_V_MF2_M1 + 0U, // PseudoVLUXSEG8EI16_V_MF2_M1_MASK + 0U, // PseudoVLUXSEG8EI16_V_MF2_MF2 + 0U, // PseudoVLUXSEG8EI16_V_MF2_MF2_MASK + 0U, // PseudoVLUXSEG8EI16_V_MF2_MF4 + 0U, // PseudoVLUXSEG8EI16_V_MF2_MF4_MASK + 0U, // PseudoVLUXSEG8EI16_V_MF4_M1 + 0U, // PseudoVLUXSEG8EI16_V_MF4_M1_MASK + 0U, // PseudoVLUXSEG8EI16_V_MF4_MF2 + 0U, // PseudoVLUXSEG8EI16_V_MF4_MF2_MASK + 0U, // PseudoVLUXSEG8EI16_V_MF4_MF4 + 0U, // PseudoVLUXSEG8EI16_V_MF4_MF4_MASK + 0U, // PseudoVLUXSEG8EI16_V_MF4_MF8 + 0U, // PseudoVLUXSEG8EI16_V_MF4_MF8_MASK + 0U, // PseudoVLUXSEG8EI32_V_M1_M1 + 0U, // PseudoVLUXSEG8EI32_V_M1_M1_MASK + 0U, // PseudoVLUXSEG8EI32_V_M1_MF2 + 0U, // PseudoVLUXSEG8EI32_V_M1_MF2_MASK + 0U, // PseudoVLUXSEG8EI32_V_M1_MF4 + 0U, // PseudoVLUXSEG8EI32_V_M1_MF4_MASK + 0U, // PseudoVLUXSEG8EI32_V_M2_M1 + 0U, // PseudoVLUXSEG8EI32_V_M2_M1_MASK + 0U, // PseudoVLUXSEG8EI32_V_M2_MF2 + 0U, // PseudoVLUXSEG8EI32_V_M2_MF2_MASK + 0U, // PseudoVLUXSEG8EI32_V_M4_M1 + 0U, // PseudoVLUXSEG8EI32_V_M4_M1_MASK + 0U, // PseudoVLUXSEG8EI32_V_MF2_M1 + 0U, // PseudoVLUXSEG8EI32_V_MF2_M1_MASK + 0U, // PseudoVLUXSEG8EI32_V_MF2_MF2 + 0U, // PseudoVLUXSEG8EI32_V_MF2_MF2_MASK + 0U, // PseudoVLUXSEG8EI32_V_MF2_MF4 + 0U, // PseudoVLUXSEG8EI32_V_MF2_MF4_MASK + 0U, // PseudoVLUXSEG8EI32_V_MF2_MF8 + 0U, // PseudoVLUXSEG8EI32_V_MF2_MF8_MASK + 0U, // PseudoVLUXSEG8EI64_V_M1_M1 + 0U, // PseudoVLUXSEG8EI64_V_M1_M1_MASK + 0U, // PseudoVLUXSEG8EI64_V_M1_MF2 + 0U, // PseudoVLUXSEG8EI64_V_M1_MF2_MASK + 0U, // PseudoVLUXSEG8EI64_V_M1_MF4 + 0U, // PseudoVLUXSEG8EI64_V_M1_MF4_MASK + 0U, // PseudoVLUXSEG8EI64_V_M1_MF8 + 0U, // PseudoVLUXSEG8EI64_V_M1_MF8_MASK + 0U, // PseudoVLUXSEG8EI64_V_M2_M1 + 0U, // PseudoVLUXSEG8EI64_V_M2_M1_MASK + 0U, // PseudoVLUXSEG8EI64_V_M2_MF2 + 0U, // PseudoVLUXSEG8EI64_V_M2_MF2_MASK + 0U, // PseudoVLUXSEG8EI64_V_M2_MF4 + 0U, // PseudoVLUXSEG8EI64_V_M2_MF4_MASK + 0U, // PseudoVLUXSEG8EI64_V_M4_M1 + 0U, // PseudoVLUXSEG8EI64_V_M4_M1_MASK + 0U, // PseudoVLUXSEG8EI64_V_M4_MF2 + 0U, // PseudoVLUXSEG8EI64_V_M4_MF2_MASK + 0U, // PseudoVLUXSEG8EI64_V_M8_M1 + 0U, // PseudoVLUXSEG8EI64_V_M8_M1_MASK + 0U, // PseudoVLUXSEG8EI8_V_M1_M1 + 0U, // PseudoVLUXSEG8EI8_V_M1_M1_MASK + 0U, // PseudoVLUXSEG8EI8_V_MF2_M1 + 0U, // PseudoVLUXSEG8EI8_V_MF2_M1_MASK + 0U, // PseudoVLUXSEG8EI8_V_MF2_MF2 + 0U, // PseudoVLUXSEG8EI8_V_MF2_MF2_MASK + 0U, // PseudoVLUXSEG8EI8_V_MF4_M1 + 0U, // PseudoVLUXSEG8EI8_V_MF4_M1_MASK + 0U, // PseudoVLUXSEG8EI8_V_MF4_MF2 + 0U, // PseudoVLUXSEG8EI8_V_MF4_MF2_MASK + 0U, // PseudoVLUXSEG8EI8_V_MF4_MF4 + 0U, // PseudoVLUXSEG8EI8_V_MF4_MF4_MASK + 0U, // PseudoVLUXSEG8EI8_V_MF8_M1 + 0U, // PseudoVLUXSEG8EI8_V_MF8_M1_MASK + 0U, // PseudoVLUXSEG8EI8_V_MF8_MF2 + 0U, // PseudoVLUXSEG8EI8_V_MF8_MF2_MASK + 0U, // PseudoVLUXSEG8EI8_V_MF8_MF4 + 0U, // PseudoVLUXSEG8EI8_V_MF8_MF4_MASK + 0U, // PseudoVLUXSEG8EI8_V_MF8_MF8 + 0U, // PseudoVLUXSEG8EI8_V_MF8_MF8_MASK + 0U, // PseudoVMACC_VV_M1 + 0U, // PseudoVMACC_VV_M1_MASK + 0U, // PseudoVMACC_VV_M2 + 0U, // PseudoVMACC_VV_M2_MASK + 0U, // PseudoVMACC_VV_M4 + 0U, // PseudoVMACC_VV_M4_MASK + 0U, // PseudoVMACC_VV_M8 + 0U, // PseudoVMACC_VV_M8_MASK + 0U, // PseudoVMACC_VV_MF2 + 0U, // PseudoVMACC_VV_MF2_MASK + 0U, // PseudoVMACC_VV_MF4 + 0U, // PseudoVMACC_VV_MF4_MASK + 0U, // PseudoVMACC_VV_MF8 + 0U, // PseudoVMACC_VV_MF8_MASK + 0U, // PseudoVMACC_VX_M1 + 0U, // PseudoVMACC_VX_M1_MASK + 0U, // PseudoVMACC_VX_M2 + 0U, // PseudoVMACC_VX_M2_MASK + 0U, // PseudoVMACC_VX_M4 + 0U, // PseudoVMACC_VX_M4_MASK + 0U, // PseudoVMACC_VX_M8 + 0U, // PseudoVMACC_VX_M8_MASK + 0U, // PseudoVMACC_VX_MF2 + 0U, // PseudoVMACC_VX_MF2_MASK + 0U, // PseudoVMACC_VX_MF4 + 0U, // PseudoVMACC_VX_MF4_MASK + 0U, // PseudoVMACC_VX_MF8 + 0U, // PseudoVMACC_VX_MF8_MASK + 0U, // PseudoVMADC_VIM_M1 + 0U, // PseudoVMADC_VIM_M2 + 0U, // PseudoVMADC_VIM_M4 + 0U, // PseudoVMADC_VIM_M8 + 0U, // PseudoVMADC_VIM_MF2 + 0U, // PseudoVMADC_VIM_MF4 + 0U, // PseudoVMADC_VIM_MF8 + 0U, // PseudoVMADC_VI_M1 + 0U, // PseudoVMADC_VI_M2 + 0U, // PseudoVMADC_VI_M4 + 0U, // PseudoVMADC_VI_M8 + 0U, // PseudoVMADC_VI_MF2 + 0U, // PseudoVMADC_VI_MF4 + 0U, // PseudoVMADC_VI_MF8 + 0U, // PseudoVMADC_VVM_M1 + 0U, // PseudoVMADC_VVM_M2 + 0U, // PseudoVMADC_VVM_M4 + 0U, // PseudoVMADC_VVM_M8 + 0U, // PseudoVMADC_VVM_MF2 + 0U, // PseudoVMADC_VVM_MF4 + 0U, // PseudoVMADC_VVM_MF8 + 0U, // PseudoVMADC_VV_M1 + 0U, // PseudoVMADC_VV_M2 + 0U, // PseudoVMADC_VV_M4 + 0U, // PseudoVMADC_VV_M8 + 0U, // PseudoVMADC_VV_MF2 + 0U, // PseudoVMADC_VV_MF4 + 0U, // PseudoVMADC_VV_MF8 + 0U, // PseudoVMADC_VXM_M1 + 0U, // PseudoVMADC_VXM_M2 + 0U, // PseudoVMADC_VXM_M4 + 0U, // PseudoVMADC_VXM_M8 + 0U, // PseudoVMADC_VXM_MF2 + 0U, // PseudoVMADC_VXM_MF4 + 0U, // PseudoVMADC_VXM_MF8 + 0U, // PseudoVMADC_VX_M1 + 0U, // PseudoVMADC_VX_M2 + 0U, // PseudoVMADC_VX_M4 + 0U, // PseudoVMADC_VX_M8 + 0U, // PseudoVMADC_VX_MF2 + 0U, // PseudoVMADC_VX_MF4 + 0U, // PseudoVMADC_VX_MF8 + 0U, // PseudoVMADD_VV_M1 + 0U, // PseudoVMADD_VV_M1_MASK + 0U, // PseudoVMADD_VV_M2 + 0U, // PseudoVMADD_VV_M2_MASK + 0U, // PseudoVMADD_VV_M4 + 0U, // PseudoVMADD_VV_M4_MASK + 0U, // PseudoVMADD_VV_M8 + 0U, // PseudoVMADD_VV_M8_MASK + 0U, // PseudoVMADD_VV_MF2 + 0U, // PseudoVMADD_VV_MF2_MASK + 0U, // PseudoVMADD_VV_MF4 + 0U, // PseudoVMADD_VV_MF4_MASK + 0U, // PseudoVMADD_VV_MF8 + 0U, // PseudoVMADD_VV_MF8_MASK + 0U, // PseudoVMADD_VX_M1 + 0U, // PseudoVMADD_VX_M1_MASK + 0U, // PseudoVMADD_VX_M2 + 0U, // PseudoVMADD_VX_M2_MASK + 0U, // PseudoVMADD_VX_M4 + 0U, // PseudoVMADD_VX_M4_MASK + 0U, // PseudoVMADD_VX_M8 + 0U, // PseudoVMADD_VX_M8_MASK + 0U, // PseudoVMADD_VX_MF2 + 0U, // PseudoVMADD_VX_MF2_MASK + 0U, // PseudoVMADD_VX_MF4 + 0U, // PseudoVMADD_VX_MF4_MASK + 0U, // PseudoVMADD_VX_MF8 + 0U, // PseudoVMADD_VX_MF8_MASK + 0U, // PseudoVMANDN_MM_M1 + 0U, // PseudoVMANDN_MM_M2 + 0U, // PseudoVMANDN_MM_M4 + 0U, // PseudoVMANDN_MM_M8 + 0U, // PseudoVMANDN_MM_MF2 + 0U, // PseudoVMANDN_MM_MF4 + 0U, // PseudoVMANDN_MM_MF8 + 0U, // PseudoVMAND_MM_M1 + 0U, // PseudoVMAND_MM_M2 + 0U, // PseudoVMAND_MM_M4 + 0U, // PseudoVMAND_MM_M8 + 0U, // PseudoVMAND_MM_MF2 + 0U, // PseudoVMAND_MM_MF4 + 0U, // PseudoVMAND_MM_MF8 + 0U, // PseudoVMAXU_VV_M1 + 0U, // PseudoVMAXU_VV_M1_MASK + 0U, // PseudoVMAXU_VV_M2 + 0U, // PseudoVMAXU_VV_M2_MASK + 0U, // PseudoVMAXU_VV_M4 + 0U, // PseudoVMAXU_VV_M4_MASK + 0U, // PseudoVMAXU_VV_M8 + 0U, // PseudoVMAXU_VV_M8_MASK + 0U, // PseudoVMAXU_VV_MF2 + 0U, // PseudoVMAXU_VV_MF2_MASK + 0U, // PseudoVMAXU_VV_MF4 + 0U, // PseudoVMAXU_VV_MF4_MASK + 0U, // PseudoVMAXU_VV_MF8 + 0U, // PseudoVMAXU_VV_MF8_MASK + 0U, // PseudoVMAXU_VX_M1 + 0U, // PseudoVMAXU_VX_M1_MASK + 0U, // PseudoVMAXU_VX_M2 + 0U, // PseudoVMAXU_VX_M2_MASK + 0U, // PseudoVMAXU_VX_M4 + 0U, // PseudoVMAXU_VX_M4_MASK + 0U, // PseudoVMAXU_VX_M8 + 0U, // PseudoVMAXU_VX_M8_MASK + 0U, // PseudoVMAXU_VX_MF2 + 0U, // PseudoVMAXU_VX_MF2_MASK + 0U, // PseudoVMAXU_VX_MF4 + 0U, // PseudoVMAXU_VX_MF4_MASK + 0U, // PseudoVMAXU_VX_MF8 + 0U, // PseudoVMAXU_VX_MF8_MASK + 0U, // PseudoVMAX_VV_M1 + 0U, // PseudoVMAX_VV_M1_MASK + 0U, // PseudoVMAX_VV_M2 + 0U, // PseudoVMAX_VV_M2_MASK + 0U, // PseudoVMAX_VV_M4 + 0U, // PseudoVMAX_VV_M4_MASK + 0U, // PseudoVMAX_VV_M8 + 0U, // PseudoVMAX_VV_M8_MASK + 0U, // PseudoVMAX_VV_MF2 + 0U, // PseudoVMAX_VV_MF2_MASK + 0U, // PseudoVMAX_VV_MF4 + 0U, // PseudoVMAX_VV_MF4_MASK + 0U, // PseudoVMAX_VV_MF8 + 0U, // PseudoVMAX_VV_MF8_MASK + 0U, // PseudoVMAX_VX_M1 + 0U, // PseudoVMAX_VX_M1_MASK + 0U, // PseudoVMAX_VX_M2 + 0U, // PseudoVMAX_VX_M2_MASK + 0U, // PseudoVMAX_VX_M4 + 0U, // PseudoVMAX_VX_M4_MASK + 0U, // PseudoVMAX_VX_M8 + 0U, // PseudoVMAX_VX_M8_MASK + 0U, // PseudoVMAX_VX_MF2 + 0U, // PseudoVMAX_VX_MF2_MASK + 0U, // PseudoVMAX_VX_MF4 + 0U, // PseudoVMAX_VX_MF4_MASK + 0U, // PseudoVMAX_VX_MF8 + 0U, // PseudoVMAX_VX_MF8_MASK + 0U, // PseudoVMCLR_M_B1 + 0U, // PseudoVMCLR_M_B16 + 0U, // PseudoVMCLR_M_B2 + 0U, // PseudoVMCLR_M_B32 + 0U, // PseudoVMCLR_M_B4 + 0U, // PseudoVMCLR_M_B64 + 0U, // PseudoVMCLR_M_B8 + 0U, // PseudoVMERGE_VIM_M1 + 0U, // PseudoVMERGE_VIM_M2 + 0U, // PseudoVMERGE_VIM_M4 + 0U, // PseudoVMERGE_VIM_M8 + 0U, // PseudoVMERGE_VIM_MF2 + 0U, // PseudoVMERGE_VIM_MF4 + 0U, // PseudoVMERGE_VIM_MF8 + 0U, // PseudoVMERGE_VVM_M1 + 0U, // PseudoVMERGE_VVM_M2 + 0U, // PseudoVMERGE_VVM_M4 + 0U, // PseudoVMERGE_VVM_M8 + 0U, // PseudoVMERGE_VVM_MF2 + 0U, // PseudoVMERGE_VVM_MF4 + 0U, // PseudoVMERGE_VVM_MF8 + 0U, // PseudoVMERGE_VXM_M1 + 0U, // PseudoVMERGE_VXM_M2 + 0U, // PseudoVMERGE_VXM_M4 + 0U, // PseudoVMERGE_VXM_M8 + 0U, // PseudoVMERGE_VXM_MF2 + 0U, // PseudoVMERGE_VXM_MF4 + 0U, // PseudoVMERGE_VXM_MF8 + 0U, // PseudoVMFEQ_VFPR16_M1 + 0U, // PseudoVMFEQ_VFPR16_M1_MASK + 0U, // PseudoVMFEQ_VFPR16_M2 + 0U, // PseudoVMFEQ_VFPR16_M2_MASK + 0U, // PseudoVMFEQ_VFPR16_M4 + 0U, // PseudoVMFEQ_VFPR16_M4_MASK + 0U, // PseudoVMFEQ_VFPR16_M8 + 0U, // PseudoVMFEQ_VFPR16_M8_MASK + 0U, // PseudoVMFEQ_VFPR16_MF2 + 0U, // PseudoVMFEQ_VFPR16_MF2_MASK + 0U, // PseudoVMFEQ_VFPR16_MF4 + 0U, // PseudoVMFEQ_VFPR16_MF4_MASK + 0U, // PseudoVMFEQ_VFPR32_M1 + 0U, // PseudoVMFEQ_VFPR32_M1_MASK + 0U, // PseudoVMFEQ_VFPR32_M2 + 0U, // PseudoVMFEQ_VFPR32_M2_MASK + 0U, // PseudoVMFEQ_VFPR32_M4 + 0U, // PseudoVMFEQ_VFPR32_M4_MASK + 0U, // PseudoVMFEQ_VFPR32_M8 + 0U, // PseudoVMFEQ_VFPR32_M8_MASK + 0U, // PseudoVMFEQ_VFPR32_MF2 + 0U, // PseudoVMFEQ_VFPR32_MF2_MASK + 0U, // PseudoVMFEQ_VFPR64_M1 + 0U, // PseudoVMFEQ_VFPR64_M1_MASK + 0U, // PseudoVMFEQ_VFPR64_M2 + 0U, // PseudoVMFEQ_VFPR64_M2_MASK + 0U, // PseudoVMFEQ_VFPR64_M4 + 0U, // PseudoVMFEQ_VFPR64_M4_MASK + 0U, // PseudoVMFEQ_VFPR64_M8 + 0U, // PseudoVMFEQ_VFPR64_M8_MASK + 0U, // PseudoVMFEQ_VV_M1 + 0U, // PseudoVMFEQ_VV_M1_MASK + 0U, // PseudoVMFEQ_VV_M2 + 0U, // PseudoVMFEQ_VV_M2_MASK + 0U, // PseudoVMFEQ_VV_M4 + 0U, // PseudoVMFEQ_VV_M4_MASK + 0U, // PseudoVMFEQ_VV_M8 + 0U, // PseudoVMFEQ_VV_M8_MASK + 0U, // PseudoVMFEQ_VV_MF2 + 0U, // PseudoVMFEQ_VV_MF2_MASK + 0U, // PseudoVMFEQ_VV_MF4 + 0U, // PseudoVMFEQ_VV_MF4_MASK + 0U, // PseudoVMFGE_VFPR16_M1 + 0U, // PseudoVMFGE_VFPR16_M1_MASK + 0U, // PseudoVMFGE_VFPR16_M2 + 0U, // PseudoVMFGE_VFPR16_M2_MASK + 0U, // PseudoVMFGE_VFPR16_M4 + 0U, // PseudoVMFGE_VFPR16_M4_MASK + 0U, // PseudoVMFGE_VFPR16_M8 + 0U, // PseudoVMFGE_VFPR16_M8_MASK + 0U, // PseudoVMFGE_VFPR16_MF2 + 0U, // PseudoVMFGE_VFPR16_MF2_MASK + 0U, // PseudoVMFGE_VFPR16_MF4 + 0U, // PseudoVMFGE_VFPR16_MF4_MASK + 0U, // PseudoVMFGE_VFPR32_M1 + 0U, // PseudoVMFGE_VFPR32_M1_MASK + 0U, // PseudoVMFGE_VFPR32_M2 + 0U, // PseudoVMFGE_VFPR32_M2_MASK + 0U, // PseudoVMFGE_VFPR32_M4 + 0U, // PseudoVMFGE_VFPR32_M4_MASK + 0U, // PseudoVMFGE_VFPR32_M8 + 0U, // PseudoVMFGE_VFPR32_M8_MASK + 0U, // PseudoVMFGE_VFPR32_MF2 + 0U, // PseudoVMFGE_VFPR32_MF2_MASK + 0U, // PseudoVMFGE_VFPR64_M1 + 0U, // PseudoVMFGE_VFPR64_M1_MASK + 0U, // PseudoVMFGE_VFPR64_M2 + 0U, // PseudoVMFGE_VFPR64_M2_MASK + 0U, // PseudoVMFGE_VFPR64_M4 + 0U, // PseudoVMFGE_VFPR64_M4_MASK + 0U, // PseudoVMFGE_VFPR64_M8 + 0U, // PseudoVMFGE_VFPR64_M8_MASK + 0U, // PseudoVMFGT_VFPR16_M1 + 0U, // PseudoVMFGT_VFPR16_M1_MASK + 0U, // PseudoVMFGT_VFPR16_M2 + 0U, // PseudoVMFGT_VFPR16_M2_MASK + 0U, // PseudoVMFGT_VFPR16_M4 + 0U, // PseudoVMFGT_VFPR16_M4_MASK + 0U, // PseudoVMFGT_VFPR16_M8 + 0U, // PseudoVMFGT_VFPR16_M8_MASK + 0U, // PseudoVMFGT_VFPR16_MF2 + 0U, // PseudoVMFGT_VFPR16_MF2_MASK + 0U, // PseudoVMFGT_VFPR16_MF4 + 0U, // PseudoVMFGT_VFPR16_MF4_MASK + 0U, // PseudoVMFGT_VFPR32_M1 + 0U, // PseudoVMFGT_VFPR32_M1_MASK + 0U, // PseudoVMFGT_VFPR32_M2 + 0U, // PseudoVMFGT_VFPR32_M2_MASK + 0U, // PseudoVMFGT_VFPR32_M4 + 0U, // PseudoVMFGT_VFPR32_M4_MASK + 0U, // PseudoVMFGT_VFPR32_M8 + 0U, // PseudoVMFGT_VFPR32_M8_MASK + 0U, // PseudoVMFGT_VFPR32_MF2 + 0U, // PseudoVMFGT_VFPR32_MF2_MASK + 0U, // PseudoVMFGT_VFPR64_M1 + 0U, // PseudoVMFGT_VFPR64_M1_MASK + 0U, // PseudoVMFGT_VFPR64_M2 + 0U, // PseudoVMFGT_VFPR64_M2_MASK + 0U, // PseudoVMFGT_VFPR64_M4 + 0U, // PseudoVMFGT_VFPR64_M4_MASK + 0U, // PseudoVMFGT_VFPR64_M8 + 0U, // PseudoVMFGT_VFPR64_M8_MASK + 0U, // PseudoVMFLE_VFPR16_M1 + 0U, // PseudoVMFLE_VFPR16_M1_MASK + 0U, // PseudoVMFLE_VFPR16_M2 + 0U, // PseudoVMFLE_VFPR16_M2_MASK + 0U, // PseudoVMFLE_VFPR16_M4 + 0U, // PseudoVMFLE_VFPR16_M4_MASK + 0U, // PseudoVMFLE_VFPR16_M8 + 0U, // PseudoVMFLE_VFPR16_M8_MASK + 0U, // PseudoVMFLE_VFPR16_MF2 + 0U, // PseudoVMFLE_VFPR16_MF2_MASK + 0U, // PseudoVMFLE_VFPR16_MF4 + 0U, // PseudoVMFLE_VFPR16_MF4_MASK + 0U, // PseudoVMFLE_VFPR32_M1 + 0U, // PseudoVMFLE_VFPR32_M1_MASK + 0U, // PseudoVMFLE_VFPR32_M2 + 0U, // PseudoVMFLE_VFPR32_M2_MASK + 0U, // PseudoVMFLE_VFPR32_M4 + 0U, // PseudoVMFLE_VFPR32_M4_MASK + 0U, // PseudoVMFLE_VFPR32_M8 + 0U, // PseudoVMFLE_VFPR32_M8_MASK + 0U, // PseudoVMFLE_VFPR32_MF2 + 0U, // PseudoVMFLE_VFPR32_MF2_MASK + 0U, // PseudoVMFLE_VFPR64_M1 + 0U, // PseudoVMFLE_VFPR64_M1_MASK + 0U, // PseudoVMFLE_VFPR64_M2 + 0U, // PseudoVMFLE_VFPR64_M2_MASK + 0U, // PseudoVMFLE_VFPR64_M4 + 0U, // PseudoVMFLE_VFPR64_M4_MASK + 0U, // PseudoVMFLE_VFPR64_M8 + 0U, // PseudoVMFLE_VFPR64_M8_MASK + 0U, // PseudoVMFLE_VV_M1 + 0U, // PseudoVMFLE_VV_M1_MASK + 0U, // PseudoVMFLE_VV_M2 + 0U, // PseudoVMFLE_VV_M2_MASK + 0U, // PseudoVMFLE_VV_M4 + 0U, // PseudoVMFLE_VV_M4_MASK + 0U, // PseudoVMFLE_VV_M8 + 0U, // PseudoVMFLE_VV_M8_MASK + 0U, // PseudoVMFLE_VV_MF2 + 0U, // PseudoVMFLE_VV_MF2_MASK + 0U, // PseudoVMFLE_VV_MF4 + 0U, // PseudoVMFLE_VV_MF4_MASK + 0U, // PseudoVMFLT_VFPR16_M1 + 0U, // PseudoVMFLT_VFPR16_M1_MASK + 0U, // PseudoVMFLT_VFPR16_M2 + 0U, // PseudoVMFLT_VFPR16_M2_MASK + 0U, // PseudoVMFLT_VFPR16_M4 + 0U, // PseudoVMFLT_VFPR16_M4_MASK + 0U, // PseudoVMFLT_VFPR16_M8 + 0U, // PseudoVMFLT_VFPR16_M8_MASK + 0U, // PseudoVMFLT_VFPR16_MF2 + 0U, // PseudoVMFLT_VFPR16_MF2_MASK + 0U, // PseudoVMFLT_VFPR16_MF4 + 0U, // PseudoVMFLT_VFPR16_MF4_MASK + 0U, // PseudoVMFLT_VFPR32_M1 + 0U, // PseudoVMFLT_VFPR32_M1_MASK + 0U, // PseudoVMFLT_VFPR32_M2 + 0U, // PseudoVMFLT_VFPR32_M2_MASK + 0U, // PseudoVMFLT_VFPR32_M4 + 0U, // PseudoVMFLT_VFPR32_M4_MASK + 0U, // PseudoVMFLT_VFPR32_M8 + 0U, // PseudoVMFLT_VFPR32_M8_MASK + 0U, // PseudoVMFLT_VFPR32_MF2 + 0U, // PseudoVMFLT_VFPR32_MF2_MASK + 0U, // PseudoVMFLT_VFPR64_M1 + 0U, // PseudoVMFLT_VFPR64_M1_MASK + 0U, // PseudoVMFLT_VFPR64_M2 + 0U, // PseudoVMFLT_VFPR64_M2_MASK + 0U, // PseudoVMFLT_VFPR64_M4 + 0U, // PseudoVMFLT_VFPR64_M4_MASK + 0U, // PseudoVMFLT_VFPR64_M8 + 0U, // PseudoVMFLT_VFPR64_M8_MASK + 0U, // PseudoVMFLT_VV_M1 + 0U, // PseudoVMFLT_VV_M1_MASK + 0U, // PseudoVMFLT_VV_M2 + 0U, // PseudoVMFLT_VV_M2_MASK + 0U, // PseudoVMFLT_VV_M4 + 0U, // PseudoVMFLT_VV_M4_MASK + 0U, // PseudoVMFLT_VV_M8 + 0U, // PseudoVMFLT_VV_M8_MASK + 0U, // PseudoVMFLT_VV_MF2 + 0U, // PseudoVMFLT_VV_MF2_MASK + 0U, // PseudoVMFLT_VV_MF4 + 0U, // PseudoVMFLT_VV_MF4_MASK + 0U, // PseudoVMFNE_VFPR16_M1 + 0U, // PseudoVMFNE_VFPR16_M1_MASK + 0U, // PseudoVMFNE_VFPR16_M2 + 0U, // PseudoVMFNE_VFPR16_M2_MASK + 0U, // PseudoVMFNE_VFPR16_M4 + 0U, // PseudoVMFNE_VFPR16_M4_MASK + 0U, // PseudoVMFNE_VFPR16_M8 + 0U, // PseudoVMFNE_VFPR16_M8_MASK + 0U, // PseudoVMFNE_VFPR16_MF2 + 0U, // PseudoVMFNE_VFPR16_MF2_MASK + 0U, // PseudoVMFNE_VFPR16_MF4 + 0U, // PseudoVMFNE_VFPR16_MF4_MASK + 0U, // PseudoVMFNE_VFPR32_M1 + 0U, // PseudoVMFNE_VFPR32_M1_MASK + 0U, // PseudoVMFNE_VFPR32_M2 + 0U, // PseudoVMFNE_VFPR32_M2_MASK + 0U, // PseudoVMFNE_VFPR32_M4 + 0U, // PseudoVMFNE_VFPR32_M4_MASK + 0U, // PseudoVMFNE_VFPR32_M8 + 0U, // PseudoVMFNE_VFPR32_M8_MASK + 0U, // PseudoVMFNE_VFPR32_MF2 + 0U, // PseudoVMFNE_VFPR32_MF2_MASK + 0U, // PseudoVMFNE_VFPR64_M1 + 0U, // PseudoVMFNE_VFPR64_M1_MASK + 0U, // PseudoVMFNE_VFPR64_M2 + 0U, // PseudoVMFNE_VFPR64_M2_MASK + 0U, // PseudoVMFNE_VFPR64_M4 + 0U, // PseudoVMFNE_VFPR64_M4_MASK + 0U, // PseudoVMFNE_VFPR64_M8 + 0U, // PseudoVMFNE_VFPR64_M8_MASK + 0U, // PseudoVMFNE_VV_M1 + 0U, // PseudoVMFNE_VV_M1_MASK + 0U, // PseudoVMFNE_VV_M2 + 0U, // PseudoVMFNE_VV_M2_MASK + 0U, // PseudoVMFNE_VV_M4 + 0U, // PseudoVMFNE_VV_M4_MASK + 0U, // PseudoVMFNE_VV_M8 + 0U, // PseudoVMFNE_VV_M8_MASK + 0U, // PseudoVMFNE_VV_MF2 + 0U, // PseudoVMFNE_VV_MF2_MASK + 0U, // PseudoVMFNE_VV_MF4 + 0U, // PseudoVMFNE_VV_MF4_MASK + 0U, // PseudoVMINU_VV_M1 + 0U, // PseudoVMINU_VV_M1_MASK + 0U, // PseudoVMINU_VV_M2 + 0U, // PseudoVMINU_VV_M2_MASK + 0U, // PseudoVMINU_VV_M4 + 0U, // PseudoVMINU_VV_M4_MASK + 0U, // PseudoVMINU_VV_M8 + 0U, // PseudoVMINU_VV_M8_MASK + 0U, // PseudoVMINU_VV_MF2 + 0U, // PseudoVMINU_VV_MF2_MASK + 0U, // PseudoVMINU_VV_MF4 + 0U, // PseudoVMINU_VV_MF4_MASK + 0U, // PseudoVMINU_VV_MF8 + 0U, // PseudoVMINU_VV_MF8_MASK + 0U, // PseudoVMINU_VX_M1 + 0U, // PseudoVMINU_VX_M1_MASK + 0U, // PseudoVMINU_VX_M2 + 0U, // PseudoVMINU_VX_M2_MASK + 0U, // PseudoVMINU_VX_M4 + 0U, // PseudoVMINU_VX_M4_MASK + 0U, // PseudoVMINU_VX_M8 + 0U, // PseudoVMINU_VX_M8_MASK + 0U, // PseudoVMINU_VX_MF2 + 0U, // PseudoVMINU_VX_MF2_MASK + 0U, // PseudoVMINU_VX_MF4 + 0U, // PseudoVMINU_VX_MF4_MASK + 0U, // PseudoVMINU_VX_MF8 + 0U, // PseudoVMINU_VX_MF8_MASK + 0U, // PseudoVMIN_VV_M1 + 0U, // PseudoVMIN_VV_M1_MASK + 0U, // PseudoVMIN_VV_M2 + 0U, // PseudoVMIN_VV_M2_MASK + 0U, // PseudoVMIN_VV_M4 + 0U, // PseudoVMIN_VV_M4_MASK + 0U, // PseudoVMIN_VV_M8 + 0U, // PseudoVMIN_VV_M8_MASK + 0U, // PseudoVMIN_VV_MF2 + 0U, // PseudoVMIN_VV_MF2_MASK + 0U, // PseudoVMIN_VV_MF4 + 0U, // PseudoVMIN_VV_MF4_MASK + 0U, // PseudoVMIN_VV_MF8 + 0U, // PseudoVMIN_VV_MF8_MASK + 0U, // PseudoVMIN_VX_M1 + 0U, // PseudoVMIN_VX_M1_MASK + 0U, // PseudoVMIN_VX_M2 + 0U, // PseudoVMIN_VX_M2_MASK + 0U, // PseudoVMIN_VX_M4 + 0U, // PseudoVMIN_VX_M4_MASK + 0U, // PseudoVMIN_VX_M8 + 0U, // PseudoVMIN_VX_M8_MASK + 0U, // PseudoVMIN_VX_MF2 + 0U, // PseudoVMIN_VX_MF2_MASK + 0U, // PseudoVMIN_VX_MF4 + 0U, // PseudoVMIN_VX_MF4_MASK + 0U, // PseudoVMIN_VX_MF8 + 0U, // PseudoVMIN_VX_MF8_MASK + 0U, // PseudoVMNAND_MM_M1 + 0U, // PseudoVMNAND_MM_M2 + 0U, // PseudoVMNAND_MM_M4 + 0U, // PseudoVMNAND_MM_M8 + 0U, // PseudoVMNAND_MM_MF2 + 0U, // PseudoVMNAND_MM_MF4 + 0U, // PseudoVMNAND_MM_MF8 + 0U, // PseudoVMNOR_MM_M1 + 0U, // PseudoVMNOR_MM_M2 + 0U, // PseudoVMNOR_MM_M4 + 0U, // PseudoVMNOR_MM_M8 + 0U, // PseudoVMNOR_MM_MF2 + 0U, // PseudoVMNOR_MM_MF4 + 0U, // PseudoVMNOR_MM_MF8 + 0U, // PseudoVMORN_MM_M1 + 0U, // PseudoVMORN_MM_M2 + 0U, // PseudoVMORN_MM_M4 + 0U, // PseudoVMORN_MM_M8 + 0U, // PseudoVMORN_MM_MF2 + 0U, // PseudoVMORN_MM_MF4 + 0U, // PseudoVMORN_MM_MF8 + 0U, // PseudoVMOR_MM_M1 + 0U, // PseudoVMOR_MM_M2 + 0U, // PseudoVMOR_MM_M4 + 0U, // PseudoVMOR_MM_M8 + 0U, // PseudoVMOR_MM_MF2 + 0U, // PseudoVMOR_MM_MF4 + 0U, // PseudoVMOR_MM_MF8 + 0U, // PseudoVMSBC_VVM_M1 + 0U, // PseudoVMSBC_VVM_M2 + 0U, // PseudoVMSBC_VVM_M4 + 0U, // PseudoVMSBC_VVM_M8 + 0U, // PseudoVMSBC_VVM_MF2 + 0U, // PseudoVMSBC_VVM_MF4 + 0U, // PseudoVMSBC_VVM_MF8 + 0U, // PseudoVMSBC_VV_M1 + 0U, // PseudoVMSBC_VV_M2 + 0U, // PseudoVMSBC_VV_M4 + 0U, // PseudoVMSBC_VV_M8 + 0U, // PseudoVMSBC_VV_MF2 + 0U, // PseudoVMSBC_VV_MF4 + 0U, // PseudoVMSBC_VV_MF8 + 0U, // PseudoVMSBC_VXM_M1 + 0U, // PseudoVMSBC_VXM_M2 + 0U, // PseudoVMSBC_VXM_M4 + 0U, // PseudoVMSBC_VXM_M8 + 0U, // PseudoVMSBC_VXM_MF2 + 0U, // PseudoVMSBC_VXM_MF4 + 0U, // PseudoVMSBC_VXM_MF8 + 0U, // PseudoVMSBC_VX_M1 + 0U, // PseudoVMSBC_VX_M2 + 0U, // PseudoVMSBC_VX_M4 + 0U, // PseudoVMSBC_VX_M8 + 0U, // PseudoVMSBC_VX_MF2 + 0U, // PseudoVMSBC_VX_MF4 + 0U, // PseudoVMSBC_VX_MF8 + 0U, // PseudoVMSBF_M_B1 + 0U, // PseudoVMSBF_M_B16 + 0U, // PseudoVMSBF_M_B16_MASK + 0U, // PseudoVMSBF_M_B1_MASK + 0U, // PseudoVMSBF_M_B2 + 0U, // PseudoVMSBF_M_B2_MASK + 0U, // PseudoVMSBF_M_B32 + 0U, // PseudoVMSBF_M_B32_MASK + 0U, // PseudoVMSBF_M_B4 + 0U, // PseudoVMSBF_M_B4_MASK + 0U, // PseudoVMSBF_M_B64 + 0U, // PseudoVMSBF_M_B64_MASK + 0U, // PseudoVMSBF_M_B8 + 0U, // PseudoVMSBF_M_B8_MASK + 0U, // PseudoVMSEQ_VI_M1 + 0U, // PseudoVMSEQ_VI_M1_MASK + 0U, // PseudoVMSEQ_VI_M2 + 0U, // PseudoVMSEQ_VI_M2_MASK + 0U, // PseudoVMSEQ_VI_M4 + 0U, // PseudoVMSEQ_VI_M4_MASK + 0U, // PseudoVMSEQ_VI_M8 + 0U, // PseudoVMSEQ_VI_M8_MASK + 0U, // PseudoVMSEQ_VI_MF2 + 0U, // PseudoVMSEQ_VI_MF2_MASK + 0U, // PseudoVMSEQ_VI_MF4 + 0U, // PseudoVMSEQ_VI_MF4_MASK + 0U, // PseudoVMSEQ_VI_MF8 + 0U, // PseudoVMSEQ_VI_MF8_MASK + 0U, // PseudoVMSEQ_VV_M1 + 0U, // PseudoVMSEQ_VV_M1_MASK + 0U, // PseudoVMSEQ_VV_M2 + 0U, // PseudoVMSEQ_VV_M2_MASK + 0U, // PseudoVMSEQ_VV_M4 + 0U, // PseudoVMSEQ_VV_M4_MASK + 0U, // PseudoVMSEQ_VV_M8 + 0U, // PseudoVMSEQ_VV_M8_MASK + 0U, // PseudoVMSEQ_VV_MF2 + 0U, // PseudoVMSEQ_VV_MF2_MASK + 0U, // PseudoVMSEQ_VV_MF4 + 0U, // PseudoVMSEQ_VV_MF4_MASK + 0U, // PseudoVMSEQ_VV_MF8 + 0U, // PseudoVMSEQ_VV_MF8_MASK + 0U, // PseudoVMSEQ_VX_M1 + 0U, // PseudoVMSEQ_VX_M1_MASK + 0U, // PseudoVMSEQ_VX_M2 + 0U, // PseudoVMSEQ_VX_M2_MASK + 0U, // PseudoVMSEQ_VX_M4 + 0U, // PseudoVMSEQ_VX_M4_MASK + 0U, // PseudoVMSEQ_VX_M8 + 0U, // PseudoVMSEQ_VX_M8_MASK + 0U, // PseudoVMSEQ_VX_MF2 + 0U, // PseudoVMSEQ_VX_MF2_MASK + 0U, // PseudoVMSEQ_VX_MF4 + 0U, // PseudoVMSEQ_VX_MF4_MASK + 0U, // PseudoVMSEQ_VX_MF8 + 0U, // PseudoVMSEQ_VX_MF8_MASK + 0U, // PseudoVMSET_M_B1 + 0U, // PseudoVMSET_M_B16 + 0U, // PseudoVMSET_M_B2 + 0U, // PseudoVMSET_M_B32 + 0U, // PseudoVMSET_M_B4 + 0U, // PseudoVMSET_M_B64 + 0U, // PseudoVMSET_M_B8 + 1U, // PseudoVMSGEU_VI + 0U, // PseudoVMSGEU_VX + 1U, // PseudoVMSGEU_VX_M + 5U, // PseudoVMSGEU_VX_M_T + 1U, // PseudoVMSGE_VI + 0U, // PseudoVMSGE_VX + 1U, // PseudoVMSGE_VX_M + 5U, // PseudoVMSGE_VX_M_T + 0U, // PseudoVMSGTU_VI_M1 + 0U, // PseudoVMSGTU_VI_M1_MASK + 0U, // PseudoVMSGTU_VI_M2 + 0U, // PseudoVMSGTU_VI_M2_MASK + 0U, // PseudoVMSGTU_VI_M4 + 0U, // PseudoVMSGTU_VI_M4_MASK + 0U, // PseudoVMSGTU_VI_M8 + 0U, // PseudoVMSGTU_VI_M8_MASK + 0U, // PseudoVMSGTU_VI_MF2 + 0U, // PseudoVMSGTU_VI_MF2_MASK + 0U, // PseudoVMSGTU_VI_MF4 + 0U, // PseudoVMSGTU_VI_MF4_MASK + 0U, // PseudoVMSGTU_VI_MF8 + 0U, // PseudoVMSGTU_VI_MF8_MASK + 0U, // PseudoVMSGTU_VX_M1 + 0U, // PseudoVMSGTU_VX_M1_MASK + 0U, // PseudoVMSGTU_VX_M2 + 0U, // PseudoVMSGTU_VX_M2_MASK + 0U, // PseudoVMSGTU_VX_M4 + 0U, // PseudoVMSGTU_VX_M4_MASK + 0U, // PseudoVMSGTU_VX_M8 + 0U, // PseudoVMSGTU_VX_M8_MASK + 0U, // PseudoVMSGTU_VX_MF2 + 0U, // PseudoVMSGTU_VX_MF2_MASK + 0U, // PseudoVMSGTU_VX_MF4 + 0U, // PseudoVMSGTU_VX_MF4_MASK + 0U, // PseudoVMSGTU_VX_MF8 + 0U, // PseudoVMSGTU_VX_MF8_MASK + 0U, // PseudoVMSGT_VI_M1 + 0U, // PseudoVMSGT_VI_M1_MASK + 0U, // PseudoVMSGT_VI_M2 + 0U, // PseudoVMSGT_VI_M2_MASK + 0U, // PseudoVMSGT_VI_M4 + 0U, // PseudoVMSGT_VI_M4_MASK + 0U, // PseudoVMSGT_VI_M8 + 0U, // PseudoVMSGT_VI_M8_MASK + 0U, // PseudoVMSGT_VI_MF2 + 0U, // PseudoVMSGT_VI_MF2_MASK + 0U, // PseudoVMSGT_VI_MF4 + 0U, // PseudoVMSGT_VI_MF4_MASK + 0U, // PseudoVMSGT_VI_MF8 + 0U, // PseudoVMSGT_VI_MF8_MASK + 0U, // PseudoVMSGT_VX_M1 + 0U, // PseudoVMSGT_VX_M1_MASK + 0U, // PseudoVMSGT_VX_M2 + 0U, // PseudoVMSGT_VX_M2_MASK + 0U, // PseudoVMSGT_VX_M4 + 0U, // PseudoVMSGT_VX_M4_MASK + 0U, // PseudoVMSGT_VX_M8 + 0U, // PseudoVMSGT_VX_M8_MASK + 0U, // PseudoVMSGT_VX_MF2 + 0U, // PseudoVMSGT_VX_MF2_MASK + 0U, // PseudoVMSGT_VX_MF4 + 0U, // PseudoVMSGT_VX_MF4_MASK + 0U, // PseudoVMSGT_VX_MF8 + 0U, // PseudoVMSGT_VX_MF8_MASK + 0U, // PseudoVMSIF_M_B1 + 0U, // PseudoVMSIF_M_B16 + 0U, // PseudoVMSIF_M_B16_MASK + 0U, // PseudoVMSIF_M_B1_MASK + 0U, // PseudoVMSIF_M_B2 + 0U, // PseudoVMSIF_M_B2_MASK + 0U, // PseudoVMSIF_M_B32 + 0U, // PseudoVMSIF_M_B32_MASK + 0U, // PseudoVMSIF_M_B4 + 0U, // PseudoVMSIF_M_B4_MASK + 0U, // PseudoVMSIF_M_B64 + 0U, // PseudoVMSIF_M_B64_MASK + 0U, // PseudoVMSIF_M_B8 + 0U, // PseudoVMSIF_M_B8_MASK + 0U, // PseudoVMSLEU_VI_M1 + 0U, // PseudoVMSLEU_VI_M1_MASK + 0U, // PseudoVMSLEU_VI_M2 + 0U, // PseudoVMSLEU_VI_M2_MASK + 0U, // PseudoVMSLEU_VI_M4 + 0U, // PseudoVMSLEU_VI_M4_MASK + 0U, // PseudoVMSLEU_VI_M8 + 0U, // PseudoVMSLEU_VI_M8_MASK + 0U, // PseudoVMSLEU_VI_MF2 + 0U, // PseudoVMSLEU_VI_MF2_MASK + 0U, // PseudoVMSLEU_VI_MF4 + 0U, // PseudoVMSLEU_VI_MF4_MASK + 0U, // PseudoVMSLEU_VI_MF8 + 0U, // PseudoVMSLEU_VI_MF8_MASK + 0U, // PseudoVMSLEU_VV_M1 + 0U, // PseudoVMSLEU_VV_M1_MASK + 0U, // PseudoVMSLEU_VV_M2 + 0U, // PseudoVMSLEU_VV_M2_MASK + 0U, // PseudoVMSLEU_VV_M4 + 0U, // PseudoVMSLEU_VV_M4_MASK + 0U, // PseudoVMSLEU_VV_M8 + 0U, // PseudoVMSLEU_VV_M8_MASK + 0U, // PseudoVMSLEU_VV_MF2 + 0U, // PseudoVMSLEU_VV_MF2_MASK + 0U, // PseudoVMSLEU_VV_MF4 + 0U, // PseudoVMSLEU_VV_MF4_MASK + 0U, // PseudoVMSLEU_VV_MF8 + 0U, // PseudoVMSLEU_VV_MF8_MASK + 0U, // PseudoVMSLEU_VX_M1 + 0U, // PseudoVMSLEU_VX_M1_MASK + 0U, // PseudoVMSLEU_VX_M2 + 0U, // PseudoVMSLEU_VX_M2_MASK + 0U, // PseudoVMSLEU_VX_M4 + 0U, // PseudoVMSLEU_VX_M4_MASK + 0U, // PseudoVMSLEU_VX_M8 + 0U, // PseudoVMSLEU_VX_M8_MASK + 0U, // PseudoVMSLEU_VX_MF2 + 0U, // PseudoVMSLEU_VX_MF2_MASK + 0U, // PseudoVMSLEU_VX_MF4 + 0U, // PseudoVMSLEU_VX_MF4_MASK + 0U, // PseudoVMSLEU_VX_MF8 + 0U, // PseudoVMSLEU_VX_MF8_MASK + 0U, // PseudoVMSLE_VI_M1 + 0U, // PseudoVMSLE_VI_M1_MASK + 0U, // PseudoVMSLE_VI_M2 + 0U, // PseudoVMSLE_VI_M2_MASK + 0U, // PseudoVMSLE_VI_M4 + 0U, // PseudoVMSLE_VI_M4_MASK + 0U, // PseudoVMSLE_VI_M8 + 0U, // PseudoVMSLE_VI_M8_MASK + 0U, // PseudoVMSLE_VI_MF2 + 0U, // PseudoVMSLE_VI_MF2_MASK + 0U, // PseudoVMSLE_VI_MF4 + 0U, // PseudoVMSLE_VI_MF4_MASK + 0U, // PseudoVMSLE_VI_MF8 + 0U, // PseudoVMSLE_VI_MF8_MASK + 0U, // PseudoVMSLE_VV_M1 + 0U, // PseudoVMSLE_VV_M1_MASK + 0U, // PseudoVMSLE_VV_M2 + 0U, // PseudoVMSLE_VV_M2_MASK + 0U, // PseudoVMSLE_VV_M4 + 0U, // PseudoVMSLE_VV_M4_MASK + 0U, // PseudoVMSLE_VV_M8 + 0U, // PseudoVMSLE_VV_M8_MASK + 0U, // PseudoVMSLE_VV_MF2 + 0U, // PseudoVMSLE_VV_MF2_MASK + 0U, // PseudoVMSLE_VV_MF4 + 0U, // PseudoVMSLE_VV_MF4_MASK + 0U, // PseudoVMSLE_VV_MF8 + 0U, // PseudoVMSLE_VV_MF8_MASK + 0U, // PseudoVMSLE_VX_M1 + 0U, // PseudoVMSLE_VX_M1_MASK + 0U, // PseudoVMSLE_VX_M2 + 0U, // PseudoVMSLE_VX_M2_MASK + 0U, // PseudoVMSLE_VX_M4 + 0U, // PseudoVMSLE_VX_M4_MASK + 0U, // PseudoVMSLE_VX_M8 + 0U, // PseudoVMSLE_VX_M8_MASK + 0U, // PseudoVMSLE_VX_MF2 + 0U, // PseudoVMSLE_VX_MF2_MASK + 0U, // PseudoVMSLE_VX_MF4 + 0U, // PseudoVMSLE_VX_MF4_MASK + 0U, // PseudoVMSLE_VX_MF8 + 0U, // PseudoVMSLE_VX_MF8_MASK + 1U, // PseudoVMSLTU_VI + 0U, // PseudoVMSLTU_VV_M1 + 0U, // PseudoVMSLTU_VV_M1_MASK + 0U, // PseudoVMSLTU_VV_M2 + 0U, // PseudoVMSLTU_VV_M2_MASK + 0U, // PseudoVMSLTU_VV_M4 + 0U, // PseudoVMSLTU_VV_M4_MASK + 0U, // PseudoVMSLTU_VV_M8 + 0U, // PseudoVMSLTU_VV_M8_MASK + 0U, // PseudoVMSLTU_VV_MF2 + 0U, // PseudoVMSLTU_VV_MF2_MASK + 0U, // PseudoVMSLTU_VV_MF4 + 0U, // PseudoVMSLTU_VV_MF4_MASK + 0U, // PseudoVMSLTU_VV_MF8 + 0U, // PseudoVMSLTU_VV_MF8_MASK + 0U, // PseudoVMSLTU_VX_M1 + 0U, // PseudoVMSLTU_VX_M1_MASK + 0U, // PseudoVMSLTU_VX_M2 + 0U, // PseudoVMSLTU_VX_M2_MASK + 0U, // PseudoVMSLTU_VX_M4 + 0U, // PseudoVMSLTU_VX_M4_MASK + 0U, // PseudoVMSLTU_VX_M8 + 0U, // PseudoVMSLTU_VX_M8_MASK + 0U, // PseudoVMSLTU_VX_MF2 + 0U, // PseudoVMSLTU_VX_MF2_MASK + 0U, // PseudoVMSLTU_VX_MF4 + 0U, // PseudoVMSLTU_VX_MF4_MASK + 0U, // PseudoVMSLTU_VX_MF8 + 0U, // PseudoVMSLTU_VX_MF8_MASK + 1U, // PseudoVMSLT_VI + 0U, // PseudoVMSLT_VV_M1 + 0U, // PseudoVMSLT_VV_M1_MASK + 0U, // PseudoVMSLT_VV_M2 + 0U, // PseudoVMSLT_VV_M2_MASK + 0U, // PseudoVMSLT_VV_M4 + 0U, // PseudoVMSLT_VV_M4_MASK + 0U, // PseudoVMSLT_VV_M8 + 0U, // PseudoVMSLT_VV_M8_MASK + 0U, // PseudoVMSLT_VV_MF2 + 0U, // PseudoVMSLT_VV_MF2_MASK + 0U, // PseudoVMSLT_VV_MF4 + 0U, // PseudoVMSLT_VV_MF4_MASK + 0U, // PseudoVMSLT_VV_MF8 + 0U, // PseudoVMSLT_VV_MF8_MASK + 0U, // PseudoVMSLT_VX_M1 + 0U, // PseudoVMSLT_VX_M1_MASK + 0U, // PseudoVMSLT_VX_M2 + 0U, // PseudoVMSLT_VX_M2_MASK + 0U, // PseudoVMSLT_VX_M4 + 0U, // PseudoVMSLT_VX_M4_MASK + 0U, // PseudoVMSLT_VX_M8 + 0U, // PseudoVMSLT_VX_M8_MASK + 0U, // PseudoVMSLT_VX_MF2 + 0U, // PseudoVMSLT_VX_MF2_MASK + 0U, // PseudoVMSLT_VX_MF4 + 0U, // PseudoVMSLT_VX_MF4_MASK + 0U, // PseudoVMSLT_VX_MF8 + 0U, // PseudoVMSLT_VX_MF8_MASK + 0U, // PseudoVMSNE_VI_M1 + 0U, // PseudoVMSNE_VI_M1_MASK + 0U, // PseudoVMSNE_VI_M2 + 0U, // PseudoVMSNE_VI_M2_MASK + 0U, // PseudoVMSNE_VI_M4 + 0U, // PseudoVMSNE_VI_M4_MASK + 0U, // PseudoVMSNE_VI_M8 + 0U, // PseudoVMSNE_VI_M8_MASK + 0U, // PseudoVMSNE_VI_MF2 + 0U, // PseudoVMSNE_VI_MF2_MASK + 0U, // PseudoVMSNE_VI_MF4 + 0U, // PseudoVMSNE_VI_MF4_MASK + 0U, // PseudoVMSNE_VI_MF8 + 0U, // PseudoVMSNE_VI_MF8_MASK + 0U, // PseudoVMSNE_VV_M1 + 0U, // PseudoVMSNE_VV_M1_MASK + 0U, // PseudoVMSNE_VV_M2 + 0U, // PseudoVMSNE_VV_M2_MASK + 0U, // PseudoVMSNE_VV_M4 + 0U, // PseudoVMSNE_VV_M4_MASK + 0U, // PseudoVMSNE_VV_M8 + 0U, // PseudoVMSNE_VV_M8_MASK + 0U, // PseudoVMSNE_VV_MF2 + 0U, // PseudoVMSNE_VV_MF2_MASK + 0U, // PseudoVMSNE_VV_MF4 + 0U, // PseudoVMSNE_VV_MF4_MASK + 0U, // PseudoVMSNE_VV_MF8 + 0U, // PseudoVMSNE_VV_MF8_MASK + 0U, // PseudoVMSNE_VX_M1 + 0U, // PseudoVMSNE_VX_M1_MASK + 0U, // PseudoVMSNE_VX_M2 + 0U, // PseudoVMSNE_VX_M2_MASK + 0U, // PseudoVMSNE_VX_M4 + 0U, // PseudoVMSNE_VX_M4_MASK + 0U, // PseudoVMSNE_VX_M8 + 0U, // PseudoVMSNE_VX_M8_MASK + 0U, // PseudoVMSNE_VX_MF2 + 0U, // PseudoVMSNE_VX_MF2_MASK + 0U, // PseudoVMSNE_VX_MF4 + 0U, // PseudoVMSNE_VX_MF4_MASK + 0U, // PseudoVMSNE_VX_MF8 + 0U, // PseudoVMSNE_VX_MF8_MASK + 0U, // PseudoVMSOF_M_B1 + 0U, // PseudoVMSOF_M_B16 + 0U, // PseudoVMSOF_M_B16_MASK + 0U, // PseudoVMSOF_M_B1_MASK + 0U, // PseudoVMSOF_M_B2 + 0U, // PseudoVMSOF_M_B2_MASK + 0U, // PseudoVMSOF_M_B32 + 0U, // PseudoVMSOF_M_B32_MASK + 0U, // PseudoVMSOF_M_B4 + 0U, // PseudoVMSOF_M_B4_MASK + 0U, // PseudoVMSOF_M_B64 + 0U, // PseudoVMSOF_M_B64_MASK + 0U, // PseudoVMSOF_M_B8 + 0U, // PseudoVMSOF_M_B8_MASK + 0U, // PseudoVMULHSU_VV_M1 + 0U, // PseudoVMULHSU_VV_M1_MASK + 0U, // PseudoVMULHSU_VV_M2 + 0U, // PseudoVMULHSU_VV_M2_MASK + 0U, // PseudoVMULHSU_VV_M4 + 0U, // PseudoVMULHSU_VV_M4_MASK + 0U, // PseudoVMULHSU_VV_M8 + 0U, // PseudoVMULHSU_VV_M8_MASK + 0U, // PseudoVMULHSU_VV_MF2 + 0U, // PseudoVMULHSU_VV_MF2_MASK + 0U, // PseudoVMULHSU_VV_MF4 + 0U, // PseudoVMULHSU_VV_MF4_MASK + 0U, // PseudoVMULHSU_VV_MF8 + 0U, // PseudoVMULHSU_VV_MF8_MASK + 0U, // PseudoVMULHSU_VX_M1 + 0U, // PseudoVMULHSU_VX_M1_MASK + 0U, // PseudoVMULHSU_VX_M2 + 0U, // PseudoVMULHSU_VX_M2_MASK + 0U, // PseudoVMULHSU_VX_M4 + 0U, // PseudoVMULHSU_VX_M4_MASK + 0U, // PseudoVMULHSU_VX_M8 + 0U, // PseudoVMULHSU_VX_M8_MASK + 0U, // PseudoVMULHSU_VX_MF2 + 0U, // PseudoVMULHSU_VX_MF2_MASK + 0U, // PseudoVMULHSU_VX_MF4 + 0U, // PseudoVMULHSU_VX_MF4_MASK + 0U, // PseudoVMULHSU_VX_MF8 + 0U, // PseudoVMULHSU_VX_MF8_MASK + 0U, // PseudoVMULHU_VV_M1 + 0U, // PseudoVMULHU_VV_M1_MASK + 0U, // PseudoVMULHU_VV_M2 + 0U, // PseudoVMULHU_VV_M2_MASK + 0U, // PseudoVMULHU_VV_M4 + 0U, // PseudoVMULHU_VV_M4_MASK + 0U, // PseudoVMULHU_VV_M8 + 0U, // PseudoVMULHU_VV_M8_MASK + 0U, // PseudoVMULHU_VV_MF2 + 0U, // PseudoVMULHU_VV_MF2_MASK + 0U, // PseudoVMULHU_VV_MF4 + 0U, // PseudoVMULHU_VV_MF4_MASK + 0U, // PseudoVMULHU_VV_MF8 + 0U, // PseudoVMULHU_VV_MF8_MASK + 0U, // PseudoVMULHU_VX_M1 + 0U, // PseudoVMULHU_VX_M1_MASK + 0U, // PseudoVMULHU_VX_M2 + 0U, // PseudoVMULHU_VX_M2_MASK + 0U, // PseudoVMULHU_VX_M4 + 0U, // PseudoVMULHU_VX_M4_MASK + 0U, // PseudoVMULHU_VX_M8 + 0U, // PseudoVMULHU_VX_M8_MASK + 0U, // PseudoVMULHU_VX_MF2 + 0U, // PseudoVMULHU_VX_MF2_MASK + 0U, // PseudoVMULHU_VX_MF4 + 0U, // PseudoVMULHU_VX_MF4_MASK + 0U, // PseudoVMULHU_VX_MF8 + 0U, // PseudoVMULHU_VX_MF8_MASK + 0U, // PseudoVMULH_VV_M1 + 0U, // PseudoVMULH_VV_M1_MASK + 0U, // PseudoVMULH_VV_M2 + 0U, // PseudoVMULH_VV_M2_MASK + 0U, // PseudoVMULH_VV_M4 + 0U, // PseudoVMULH_VV_M4_MASK + 0U, // PseudoVMULH_VV_M8 + 0U, // PseudoVMULH_VV_M8_MASK + 0U, // PseudoVMULH_VV_MF2 + 0U, // PseudoVMULH_VV_MF2_MASK + 0U, // PseudoVMULH_VV_MF4 + 0U, // PseudoVMULH_VV_MF4_MASK + 0U, // PseudoVMULH_VV_MF8 + 0U, // PseudoVMULH_VV_MF8_MASK + 0U, // PseudoVMULH_VX_M1 + 0U, // PseudoVMULH_VX_M1_MASK + 0U, // PseudoVMULH_VX_M2 + 0U, // PseudoVMULH_VX_M2_MASK + 0U, // PseudoVMULH_VX_M4 + 0U, // PseudoVMULH_VX_M4_MASK + 0U, // PseudoVMULH_VX_M8 + 0U, // PseudoVMULH_VX_M8_MASK + 0U, // PseudoVMULH_VX_MF2 + 0U, // PseudoVMULH_VX_MF2_MASK + 0U, // PseudoVMULH_VX_MF4 + 0U, // PseudoVMULH_VX_MF4_MASK + 0U, // PseudoVMULH_VX_MF8 + 0U, // PseudoVMULH_VX_MF8_MASK + 0U, // PseudoVMUL_VV_M1 + 0U, // PseudoVMUL_VV_M1_MASK + 0U, // PseudoVMUL_VV_M2 + 0U, // PseudoVMUL_VV_M2_MASK + 0U, // PseudoVMUL_VV_M4 + 0U, // PseudoVMUL_VV_M4_MASK + 0U, // PseudoVMUL_VV_M8 + 0U, // PseudoVMUL_VV_M8_MASK + 0U, // PseudoVMUL_VV_MF2 + 0U, // PseudoVMUL_VV_MF2_MASK + 0U, // PseudoVMUL_VV_MF4 + 0U, // PseudoVMUL_VV_MF4_MASK + 0U, // PseudoVMUL_VV_MF8 + 0U, // PseudoVMUL_VV_MF8_MASK + 0U, // PseudoVMUL_VX_M1 + 0U, // PseudoVMUL_VX_M1_MASK + 0U, // PseudoVMUL_VX_M2 + 0U, // PseudoVMUL_VX_M2_MASK + 0U, // PseudoVMUL_VX_M4 + 0U, // PseudoVMUL_VX_M4_MASK + 0U, // PseudoVMUL_VX_M8 + 0U, // PseudoVMUL_VX_M8_MASK + 0U, // PseudoVMUL_VX_MF2 + 0U, // PseudoVMUL_VX_MF2_MASK + 0U, // PseudoVMUL_VX_MF4 + 0U, // PseudoVMUL_VX_MF4_MASK + 0U, // PseudoVMUL_VX_MF8 + 0U, // PseudoVMUL_VX_MF8_MASK + 0U, // PseudoVMV_S_X + 0U, // PseudoVMV_V_I_M1 + 0U, // PseudoVMV_V_I_M2 + 0U, // PseudoVMV_V_I_M4 + 0U, // PseudoVMV_V_I_M8 + 0U, // PseudoVMV_V_I_MF2 + 0U, // PseudoVMV_V_I_MF4 + 0U, // PseudoVMV_V_I_MF8 + 0U, // PseudoVMV_V_V_M1 + 0U, // PseudoVMV_V_V_M2 + 0U, // PseudoVMV_V_V_M4 + 0U, // PseudoVMV_V_V_M8 + 0U, // PseudoVMV_V_V_MF2 + 0U, // PseudoVMV_V_V_MF4 + 0U, // PseudoVMV_V_V_MF8 + 0U, // PseudoVMV_V_X_M1 + 0U, // PseudoVMV_V_X_M2 + 0U, // PseudoVMV_V_X_M4 + 0U, // PseudoVMV_V_X_M8 + 0U, // PseudoVMV_V_X_MF2 + 0U, // PseudoVMV_V_X_MF4 + 0U, // PseudoVMV_V_X_MF8 + 0U, // PseudoVMV_X_S + 0U, // PseudoVMXNOR_MM_M1 + 0U, // PseudoVMXNOR_MM_M2 + 0U, // PseudoVMXNOR_MM_M4 + 0U, // PseudoVMXNOR_MM_M8 + 0U, // PseudoVMXNOR_MM_MF2 + 0U, // PseudoVMXNOR_MM_MF4 + 0U, // PseudoVMXNOR_MM_MF8 + 0U, // PseudoVMXOR_MM_M1 + 0U, // PseudoVMXOR_MM_M2 + 0U, // PseudoVMXOR_MM_M4 + 0U, // PseudoVMXOR_MM_M8 + 0U, // PseudoVMXOR_MM_MF2 + 0U, // PseudoVMXOR_MM_MF4 + 0U, // PseudoVMXOR_MM_MF8 + 0U, // PseudoVNCLIPU_WI_M1 + 0U, // PseudoVNCLIPU_WI_M1_MASK + 0U, // PseudoVNCLIPU_WI_M2 + 0U, // PseudoVNCLIPU_WI_M2_MASK + 0U, // PseudoVNCLIPU_WI_M4 + 0U, // PseudoVNCLIPU_WI_M4_MASK + 0U, // PseudoVNCLIPU_WI_MF2 + 0U, // PseudoVNCLIPU_WI_MF2_MASK + 0U, // PseudoVNCLIPU_WI_MF4 + 0U, // PseudoVNCLIPU_WI_MF4_MASK + 0U, // PseudoVNCLIPU_WI_MF8 + 0U, // PseudoVNCLIPU_WI_MF8_MASK + 0U, // PseudoVNCLIPU_WV_M1 + 0U, // PseudoVNCLIPU_WV_M1_MASK + 0U, // PseudoVNCLIPU_WV_M2 + 0U, // PseudoVNCLIPU_WV_M2_MASK + 0U, // PseudoVNCLIPU_WV_M4 + 0U, // PseudoVNCLIPU_WV_M4_MASK + 0U, // PseudoVNCLIPU_WV_MF2 + 0U, // PseudoVNCLIPU_WV_MF2_MASK + 0U, // PseudoVNCLIPU_WV_MF4 + 0U, // PseudoVNCLIPU_WV_MF4_MASK + 0U, // PseudoVNCLIPU_WV_MF8 + 0U, // PseudoVNCLIPU_WV_MF8_MASK + 0U, // PseudoVNCLIPU_WX_M1 + 0U, // PseudoVNCLIPU_WX_M1_MASK + 0U, // PseudoVNCLIPU_WX_M2 + 0U, // PseudoVNCLIPU_WX_M2_MASK + 0U, // PseudoVNCLIPU_WX_M4 + 0U, // PseudoVNCLIPU_WX_M4_MASK + 0U, // PseudoVNCLIPU_WX_MF2 + 0U, // PseudoVNCLIPU_WX_MF2_MASK + 0U, // PseudoVNCLIPU_WX_MF4 + 0U, // PseudoVNCLIPU_WX_MF4_MASK + 0U, // PseudoVNCLIPU_WX_MF8 + 0U, // PseudoVNCLIPU_WX_MF8_MASK + 0U, // PseudoVNCLIP_WI_M1 + 0U, // PseudoVNCLIP_WI_M1_MASK + 0U, // PseudoVNCLIP_WI_M2 + 0U, // PseudoVNCLIP_WI_M2_MASK + 0U, // PseudoVNCLIP_WI_M4 + 0U, // PseudoVNCLIP_WI_M4_MASK + 0U, // PseudoVNCLIP_WI_MF2 + 0U, // PseudoVNCLIP_WI_MF2_MASK + 0U, // PseudoVNCLIP_WI_MF4 + 0U, // PseudoVNCLIP_WI_MF4_MASK + 0U, // PseudoVNCLIP_WI_MF8 + 0U, // PseudoVNCLIP_WI_MF8_MASK + 0U, // PseudoVNCLIP_WV_M1 + 0U, // PseudoVNCLIP_WV_M1_MASK + 0U, // PseudoVNCLIP_WV_M2 + 0U, // PseudoVNCLIP_WV_M2_MASK + 0U, // PseudoVNCLIP_WV_M4 + 0U, // PseudoVNCLIP_WV_M4_MASK + 0U, // PseudoVNCLIP_WV_MF2 + 0U, // PseudoVNCLIP_WV_MF2_MASK + 0U, // PseudoVNCLIP_WV_MF4 + 0U, // PseudoVNCLIP_WV_MF4_MASK + 0U, // PseudoVNCLIP_WV_MF8 + 0U, // PseudoVNCLIP_WV_MF8_MASK + 0U, // PseudoVNCLIP_WX_M1 + 0U, // PseudoVNCLIP_WX_M1_MASK + 0U, // PseudoVNCLIP_WX_M2 + 0U, // PseudoVNCLIP_WX_M2_MASK + 0U, // PseudoVNCLIP_WX_M4 + 0U, // PseudoVNCLIP_WX_M4_MASK + 0U, // PseudoVNCLIP_WX_MF2 + 0U, // PseudoVNCLIP_WX_MF2_MASK + 0U, // PseudoVNCLIP_WX_MF4 + 0U, // PseudoVNCLIP_WX_MF4_MASK + 0U, // PseudoVNCLIP_WX_MF8 + 0U, // PseudoVNCLIP_WX_MF8_MASK + 0U, // PseudoVNMSAC_VV_M1 + 0U, // PseudoVNMSAC_VV_M1_MASK + 0U, // PseudoVNMSAC_VV_M2 + 0U, // PseudoVNMSAC_VV_M2_MASK + 0U, // PseudoVNMSAC_VV_M4 + 0U, // PseudoVNMSAC_VV_M4_MASK + 0U, // PseudoVNMSAC_VV_M8 + 0U, // PseudoVNMSAC_VV_M8_MASK + 0U, // PseudoVNMSAC_VV_MF2 + 0U, // PseudoVNMSAC_VV_MF2_MASK + 0U, // PseudoVNMSAC_VV_MF4 + 0U, // PseudoVNMSAC_VV_MF4_MASK + 0U, // PseudoVNMSAC_VV_MF8 + 0U, // PseudoVNMSAC_VV_MF8_MASK + 0U, // PseudoVNMSAC_VX_M1 + 0U, // PseudoVNMSAC_VX_M1_MASK + 0U, // PseudoVNMSAC_VX_M2 + 0U, // PseudoVNMSAC_VX_M2_MASK + 0U, // PseudoVNMSAC_VX_M4 + 0U, // PseudoVNMSAC_VX_M4_MASK + 0U, // PseudoVNMSAC_VX_M8 + 0U, // PseudoVNMSAC_VX_M8_MASK + 0U, // PseudoVNMSAC_VX_MF2 + 0U, // PseudoVNMSAC_VX_MF2_MASK + 0U, // PseudoVNMSAC_VX_MF4 + 0U, // PseudoVNMSAC_VX_MF4_MASK + 0U, // PseudoVNMSAC_VX_MF8 + 0U, // PseudoVNMSAC_VX_MF8_MASK + 0U, // PseudoVNMSUB_VV_M1 + 0U, // PseudoVNMSUB_VV_M1_MASK + 0U, // PseudoVNMSUB_VV_M2 + 0U, // PseudoVNMSUB_VV_M2_MASK + 0U, // PseudoVNMSUB_VV_M4 + 0U, // PseudoVNMSUB_VV_M4_MASK + 0U, // PseudoVNMSUB_VV_M8 + 0U, // PseudoVNMSUB_VV_M8_MASK + 0U, // PseudoVNMSUB_VV_MF2 + 0U, // PseudoVNMSUB_VV_MF2_MASK + 0U, // PseudoVNMSUB_VV_MF4 + 0U, // PseudoVNMSUB_VV_MF4_MASK + 0U, // PseudoVNMSUB_VV_MF8 + 0U, // PseudoVNMSUB_VV_MF8_MASK + 0U, // PseudoVNMSUB_VX_M1 + 0U, // PseudoVNMSUB_VX_M1_MASK + 0U, // PseudoVNMSUB_VX_M2 + 0U, // PseudoVNMSUB_VX_M2_MASK + 0U, // PseudoVNMSUB_VX_M4 + 0U, // PseudoVNMSUB_VX_M4_MASK + 0U, // PseudoVNMSUB_VX_M8 + 0U, // PseudoVNMSUB_VX_M8_MASK + 0U, // PseudoVNMSUB_VX_MF2 + 0U, // PseudoVNMSUB_VX_MF2_MASK + 0U, // PseudoVNMSUB_VX_MF4 + 0U, // PseudoVNMSUB_VX_MF4_MASK + 0U, // PseudoVNMSUB_VX_MF8 + 0U, // PseudoVNMSUB_VX_MF8_MASK + 0U, // PseudoVNSRA_WI_M1 + 0U, // PseudoVNSRA_WI_M1_MASK + 0U, // PseudoVNSRA_WI_M2 + 0U, // PseudoVNSRA_WI_M2_MASK + 0U, // PseudoVNSRA_WI_M4 + 0U, // PseudoVNSRA_WI_M4_MASK + 0U, // PseudoVNSRA_WI_MF2 + 0U, // PseudoVNSRA_WI_MF2_MASK + 0U, // PseudoVNSRA_WI_MF4 + 0U, // PseudoVNSRA_WI_MF4_MASK + 0U, // PseudoVNSRA_WI_MF8 + 0U, // PseudoVNSRA_WI_MF8_MASK + 0U, // PseudoVNSRA_WV_M1 + 0U, // PseudoVNSRA_WV_M1_MASK + 0U, // PseudoVNSRA_WV_M2 + 0U, // PseudoVNSRA_WV_M2_MASK + 0U, // PseudoVNSRA_WV_M4 + 0U, // PseudoVNSRA_WV_M4_MASK + 0U, // PseudoVNSRA_WV_MF2 + 0U, // PseudoVNSRA_WV_MF2_MASK + 0U, // PseudoVNSRA_WV_MF4 + 0U, // PseudoVNSRA_WV_MF4_MASK + 0U, // PseudoVNSRA_WV_MF8 + 0U, // PseudoVNSRA_WV_MF8_MASK + 0U, // PseudoVNSRA_WX_M1 + 0U, // PseudoVNSRA_WX_M1_MASK + 0U, // PseudoVNSRA_WX_M2 + 0U, // PseudoVNSRA_WX_M2_MASK + 0U, // PseudoVNSRA_WX_M4 + 0U, // PseudoVNSRA_WX_M4_MASK + 0U, // PseudoVNSRA_WX_MF2 + 0U, // PseudoVNSRA_WX_MF2_MASK + 0U, // PseudoVNSRA_WX_MF4 + 0U, // PseudoVNSRA_WX_MF4_MASK + 0U, // PseudoVNSRA_WX_MF8 + 0U, // PseudoVNSRA_WX_MF8_MASK + 0U, // PseudoVNSRL_WI_M1 + 0U, // PseudoVNSRL_WI_M1_MASK + 0U, // PseudoVNSRL_WI_M2 + 0U, // PseudoVNSRL_WI_M2_MASK + 0U, // PseudoVNSRL_WI_M4 + 0U, // PseudoVNSRL_WI_M4_MASK + 0U, // PseudoVNSRL_WI_MF2 + 0U, // PseudoVNSRL_WI_MF2_MASK + 0U, // PseudoVNSRL_WI_MF4 + 0U, // PseudoVNSRL_WI_MF4_MASK + 0U, // PseudoVNSRL_WI_MF8 + 0U, // PseudoVNSRL_WI_MF8_MASK + 0U, // PseudoVNSRL_WV_M1 + 0U, // PseudoVNSRL_WV_M1_MASK + 0U, // PseudoVNSRL_WV_M2 + 0U, // PseudoVNSRL_WV_M2_MASK + 0U, // PseudoVNSRL_WV_M4 + 0U, // PseudoVNSRL_WV_M4_MASK + 0U, // PseudoVNSRL_WV_MF2 + 0U, // PseudoVNSRL_WV_MF2_MASK + 0U, // PseudoVNSRL_WV_MF4 + 0U, // PseudoVNSRL_WV_MF4_MASK + 0U, // PseudoVNSRL_WV_MF8 + 0U, // PseudoVNSRL_WV_MF8_MASK + 0U, // PseudoVNSRL_WX_M1 + 0U, // PseudoVNSRL_WX_M1_MASK + 0U, // PseudoVNSRL_WX_M2 + 0U, // PseudoVNSRL_WX_M2_MASK + 0U, // PseudoVNSRL_WX_M4 + 0U, // PseudoVNSRL_WX_M4_MASK + 0U, // PseudoVNSRL_WX_MF2 + 0U, // PseudoVNSRL_WX_MF2_MASK + 0U, // PseudoVNSRL_WX_MF4 + 0U, // PseudoVNSRL_WX_MF4_MASK + 0U, // PseudoVNSRL_WX_MF8 + 0U, // PseudoVNSRL_WX_MF8_MASK + 0U, // PseudoVOR_VI_M1 + 0U, // PseudoVOR_VI_M1_MASK + 0U, // PseudoVOR_VI_M2 + 0U, // PseudoVOR_VI_M2_MASK + 0U, // PseudoVOR_VI_M4 + 0U, // PseudoVOR_VI_M4_MASK + 0U, // PseudoVOR_VI_M8 + 0U, // PseudoVOR_VI_M8_MASK + 0U, // PseudoVOR_VI_MF2 + 0U, // PseudoVOR_VI_MF2_MASK + 0U, // PseudoVOR_VI_MF4 + 0U, // PseudoVOR_VI_MF4_MASK + 0U, // PseudoVOR_VI_MF8 + 0U, // PseudoVOR_VI_MF8_MASK + 0U, // PseudoVOR_VV_M1 + 0U, // PseudoVOR_VV_M1_MASK + 0U, // PseudoVOR_VV_M2 + 0U, // PseudoVOR_VV_M2_MASK + 0U, // PseudoVOR_VV_M4 + 0U, // PseudoVOR_VV_M4_MASK + 0U, // PseudoVOR_VV_M8 + 0U, // PseudoVOR_VV_M8_MASK + 0U, // PseudoVOR_VV_MF2 + 0U, // PseudoVOR_VV_MF2_MASK + 0U, // PseudoVOR_VV_MF4 + 0U, // PseudoVOR_VV_MF4_MASK + 0U, // PseudoVOR_VV_MF8 + 0U, // PseudoVOR_VV_MF8_MASK + 0U, // PseudoVOR_VX_M1 + 0U, // PseudoVOR_VX_M1_MASK + 0U, // PseudoVOR_VX_M2 + 0U, // PseudoVOR_VX_M2_MASK + 0U, // PseudoVOR_VX_M4 + 0U, // PseudoVOR_VX_M4_MASK + 0U, // PseudoVOR_VX_M8 + 0U, // PseudoVOR_VX_M8_MASK + 0U, // PseudoVOR_VX_MF2 + 0U, // PseudoVOR_VX_MF2_MASK + 0U, // PseudoVOR_VX_MF4 + 0U, // PseudoVOR_VX_MF4_MASK + 0U, // PseudoVOR_VX_MF8 + 0U, // PseudoVOR_VX_MF8_MASK + 0U, // PseudoVQMACCSU_2x8x2_M1 + 0U, // PseudoVQMACCSU_2x8x2_M2 + 0U, // PseudoVQMACCSU_2x8x2_M4 + 0U, // PseudoVQMACCSU_2x8x2_M8 + 0U, // PseudoVQMACCSU_4x8x4_M1 + 0U, // PseudoVQMACCSU_4x8x4_M2 + 0U, // PseudoVQMACCSU_4x8x4_M4 + 0U, // PseudoVQMACCSU_4x8x4_MF2 + 0U, // PseudoVQMACCUS_2x8x2_M1 + 0U, // PseudoVQMACCUS_2x8x2_M2 + 0U, // PseudoVQMACCUS_2x8x2_M4 + 0U, // PseudoVQMACCUS_2x8x2_M8 + 0U, // PseudoVQMACCUS_4x8x4_M1 + 0U, // PseudoVQMACCUS_4x8x4_M2 + 0U, // PseudoVQMACCUS_4x8x4_M4 + 0U, // PseudoVQMACCUS_4x8x4_MF2 + 0U, // PseudoVQMACCU_2x8x2_M1 + 0U, // PseudoVQMACCU_2x8x2_M2 + 0U, // PseudoVQMACCU_2x8x2_M4 + 0U, // PseudoVQMACCU_2x8x2_M8 + 0U, // PseudoVQMACCU_4x8x4_M1 + 0U, // PseudoVQMACCU_4x8x4_M2 + 0U, // PseudoVQMACCU_4x8x4_M4 + 0U, // PseudoVQMACCU_4x8x4_MF2 + 0U, // PseudoVQMACC_2x8x2_M1 + 0U, // PseudoVQMACC_2x8x2_M2 + 0U, // PseudoVQMACC_2x8x2_M4 + 0U, // PseudoVQMACC_2x8x2_M8 + 0U, // PseudoVQMACC_4x8x4_M1 + 0U, // PseudoVQMACC_4x8x4_M2 + 0U, // PseudoVQMACC_4x8x4_M4 + 0U, // PseudoVQMACC_4x8x4_MF2 + 0U, // PseudoVREDAND_VS_M1_E16 + 0U, // PseudoVREDAND_VS_M1_E16_MASK + 0U, // PseudoVREDAND_VS_M1_E32 + 0U, // PseudoVREDAND_VS_M1_E32_MASK + 0U, // PseudoVREDAND_VS_M1_E64 + 0U, // PseudoVREDAND_VS_M1_E64_MASK + 0U, // PseudoVREDAND_VS_M1_E8 + 0U, // PseudoVREDAND_VS_M1_E8_MASK + 0U, // PseudoVREDAND_VS_M2_E16 + 0U, // PseudoVREDAND_VS_M2_E16_MASK + 0U, // PseudoVREDAND_VS_M2_E32 + 0U, // PseudoVREDAND_VS_M2_E32_MASK + 0U, // PseudoVREDAND_VS_M2_E64 + 0U, // PseudoVREDAND_VS_M2_E64_MASK + 0U, // PseudoVREDAND_VS_M2_E8 + 0U, // PseudoVREDAND_VS_M2_E8_MASK + 0U, // PseudoVREDAND_VS_M4_E16 + 0U, // PseudoVREDAND_VS_M4_E16_MASK + 0U, // PseudoVREDAND_VS_M4_E32 + 0U, // PseudoVREDAND_VS_M4_E32_MASK + 0U, // PseudoVREDAND_VS_M4_E64 + 0U, // PseudoVREDAND_VS_M4_E64_MASK + 0U, // PseudoVREDAND_VS_M4_E8 + 0U, // PseudoVREDAND_VS_M4_E8_MASK + 0U, // PseudoVREDAND_VS_M8_E16 + 0U, // PseudoVREDAND_VS_M8_E16_MASK + 0U, // PseudoVREDAND_VS_M8_E32 + 0U, // PseudoVREDAND_VS_M8_E32_MASK + 0U, // PseudoVREDAND_VS_M8_E64 + 0U, // PseudoVREDAND_VS_M8_E64_MASK + 0U, // PseudoVREDAND_VS_M8_E8 + 0U, // PseudoVREDAND_VS_M8_E8_MASK + 0U, // PseudoVREDAND_VS_MF2_E16 + 0U, // PseudoVREDAND_VS_MF2_E16_MASK + 0U, // PseudoVREDAND_VS_MF2_E32 + 0U, // PseudoVREDAND_VS_MF2_E32_MASK + 0U, // PseudoVREDAND_VS_MF2_E8 + 0U, // PseudoVREDAND_VS_MF2_E8_MASK + 0U, // PseudoVREDAND_VS_MF4_E16 + 0U, // PseudoVREDAND_VS_MF4_E16_MASK + 0U, // PseudoVREDAND_VS_MF4_E8 + 0U, // PseudoVREDAND_VS_MF4_E8_MASK + 0U, // PseudoVREDAND_VS_MF8_E8 + 0U, // PseudoVREDAND_VS_MF8_E8_MASK + 0U, // PseudoVREDMAXU_VS_M1_E16 + 0U, // PseudoVREDMAXU_VS_M1_E16_MASK + 0U, // PseudoVREDMAXU_VS_M1_E32 + 0U, // PseudoVREDMAXU_VS_M1_E32_MASK + 0U, // PseudoVREDMAXU_VS_M1_E64 + 0U, // PseudoVREDMAXU_VS_M1_E64_MASK + 0U, // PseudoVREDMAXU_VS_M1_E8 + 0U, // PseudoVREDMAXU_VS_M1_E8_MASK + 0U, // PseudoVREDMAXU_VS_M2_E16 + 0U, // PseudoVREDMAXU_VS_M2_E16_MASK + 0U, // PseudoVREDMAXU_VS_M2_E32 + 0U, // PseudoVREDMAXU_VS_M2_E32_MASK + 0U, // PseudoVREDMAXU_VS_M2_E64 + 0U, // PseudoVREDMAXU_VS_M2_E64_MASK + 0U, // PseudoVREDMAXU_VS_M2_E8 + 0U, // PseudoVREDMAXU_VS_M2_E8_MASK + 0U, // PseudoVREDMAXU_VS_M4_E16 + 0U, // PseudoVREDMAXU_VS_M4_E16_MASK + 0U, // PseudoVREDMAXU_VS_M4_E32 + 0U, // PseudoVREDMAXU_VS_M4_E32_MASK + 0U, // PseudoVREDMAXU_VS_M4_E64 + 0U, // PseudoVREDMAXU_VS_M4_E64_MASK + 0U, // PseudoVREDMAXU_VS_M4_E8 + 0U, // PseudoVREDMAXU_VS_M4_E8_MASK + 0U, // PseudoVREDMAXU_VS_M8_E16 + 0U, // PseudoVREDMAXU_VS_M8_E16_MASK + 0U, // PseudoVREDMAXU_VS_M8_E32 + 0U, // PseudoVREDMAXU_VS_M8_E32_MASK + 0U, // PseudoVREDMAXU_VS_M8_E64 + 0U, // PseudoVREDMAXU_VS_M8_E64_MASK + 0U, // PseudoVREDMAXU_VS_M8_E8 + 0U, // PseudoVREDMAXU_VS_M8_E8_MASK + 0U, // PseudoVREDMAXU_VS_MF2_E16 + 0U, // PseudoVREDMAXU_VS_MF2_E16_MASK + 0U, // PseudoVREDMAXU_VS_MF2_E32 + 0U, // PseudoVREDMAXU_VS_MF2_E32_MASK + 0U, // PseudoVREDMAXU_VS_MF2_E8 + 0U, // PseudoVREDMAXU_VS_MF2_E8_MASK + 0U, // PseudoVREDMAXU_VS_MF4_E16 + 0U, // PseudoVREDMAXU_VS_MF4_E16_MASK + 0U, // PseudoVREDMAXU_VS_MF4_E8 + 0U, // PseudoVREDMAXU_VS_MF4_E8_MASK + 0U, // PseudoVREDMAXU_VS_MF8_E8 + 0U, // PseudoVREDMAXU_VS_MF8_E8_MASK + 0U, // PseudoVREDMAX_VS_M1_E16 + 0U, // PseudoVREDMAX_VS_M1_E16_MASK + 0U, // PseudoVREDMAX_VS_M1_E32 + 0U, // PseudoVREDMAX_VS_M1_E32_MASK + 0U, // PseudoVREDMAX_VS_M1_E64 + 0U, // PseudoVREDMAX_VS_M1_E64_MASK + 0U, // PseudoVREDMAX_VS_M1_E8 + 0U, // PseudoVREDMAX_VS_M1_E8_MASK + 0U, // PseudoVREDMAX_VS_M2_E16 + 0U, // PseudoVREDMAX_VS_M2_E16_MASK + 0U, // PseudoVREDMAX_VS_M2_E32 + 0U, // PseudoVREDMAX_VS_M2_E32_MASK + 0U, // PseudoVREDMAX_VS_M2_E64 + 0U, // PseudoVREDMAX_VS_M2_E64_MASK + 0U, // PseudoVREDMAX_VS_M2_E8 + 0U, // PseudoVREDMAX_VS_M2_E8_MASK + 0U, // PseudoVREDMAX_VS_M4_E16 + 0U, // PseudoVREDMAX_VS_M4_E16_MASK + 0U, // PseudoVREDMAX_VS_M4_E32 + 0U, // PseudoVREDMAX_VS_M4_E32_MASK + 0U, // PseudoVREDMAX_VS_M4_E64 + 0U, // PseudoVREDMAX_VS_M4_E64_MASK + 0U, // PseudoVREDMAX_VS_M4_E8 + 0U, // PseudoVREDMAX_VS_M4_E8_MASK + 0U, // PseudoVREDMAX_VS_M8_E16 + 0U, // PseudoVREDMAX_VS_M8_E16_MASK + 0U, // PseudoVREDMAX_VS_M8_E32 + 0U, // PseudoVREDMAX_VS_M8_E32_MASK + 0U, // PseudoVREDMAX_VS_M8_E64 + 0U, // PseudoVREDMAX_VS_M8_E64_MASK + 0U, // PseudoVREDMAX_VS_M8_E8 + 0U, // PseudoVREDMAX_VS_M8_E8_MASK + 0U, // PseudoVREDMAX_VS_MF2_E16 + 0U, // PseudoVREDMAX_VS_MF2_E16_MASK + 0U, // PseudoVREDMAX_VS_MF2_E32 + 0U, // PseudoVREDMAX_VS_MF2_E32_MASK + 0U, // PseudoVREDMAX_VS_MF2_E8 + 0U, // PseudoVREDMAX_VS_MF2_E8_MASK + 0U, // PseudoVREDMAX_VS_MF4_E16 + 0U, // PseudoVREDMAX_VS_MF4_E16_MASK + 0U, // PseudoVREDMAX_VS_MF4_E8 + 0U, // PseudoVREDMAX_VS_MF4_E8_MASK + 0U, // PseudoVREDMAX_VS_MF8_E8 + 0U, // PseudoVREDMAX_VS_MF8_E8_MASK + 0U, // PseudoVREDMINU_VS_M1_E16 + 0U, // PseudoVREDMINU_VS_M1_E16_MASK + 0U, // PseudoVREDMINU_VS_M1_E32 + 0U, // PseudoVREDMINU_VS_M1_E32_MASK + 0U, // PseudoVREDMINU_VS_M1_E64 + 0U, // PseudoVREDMINU_VS_M1_E64_MASK + 0U, // PseudoVREDMINU_VS_M1_E8 + 0U, // PseudoVREDMINU_VS_M1_E8_MASK + 0U, // PseudoVREDMINU_VS_M2_E16 + 0U, // PseudoVREDMINU_VS_M2_E16_MASK + 0U, // PseudoVREDMINU_VS_M2_E32 + 0U, // PseudoVREDMINU_VS_M2_E32_MASK + 0U, // PseudoVREDMINU_VS_M2_E64 + 0U, // PseudoVREDMINU_VS_M2_E64_MASK + 0U, // PseudoVREDMINU_VS_M2_E8 + 0U, // PseudoVREDMINU_VS_M2_E8_MASK + 0U, // PseudoVREDMINU_VS_M4_E16 + 0U, // PseudoVREDMINU_VS_M4_E16_MASK + 0U, // PseudoVREDMINU_VS_M4_E32 + 0U, // PseudoVREDMINU_VS_M4_E32_MASK + 0U, // PseudoVREDMINU_VS_M4_E64 + 0U, // PseudoVREDMINU_VS_M4_E64_MASK + 0U, // PseudoVREDMINU_VS_M4_E8 + 0U, // PseudoVREDMINU_VS_M4_E8_MASK + 0U, // PseudoVREDMINU_VS_M8_E16 + 0U, // PseudoVREDMINU_VS_M8_E16_MASK + 0U, // PseudoVREDMINU_VS_M8_E32 + 0U, // PseudoVREDMINU_VS_M8_E32_MASK + 0U, // PseudoVREDMINU_VS_M8_E64 + 0U, // PseudoVREDMINU_VS_M8_E64_MASK + 0U, // PseudoVREDMINU_VS_M8_E8 + 0U, // PseudoVREDMINU_VS_M8_E8_MASK + 0U, // PseudoVREDMINU_VS_MF2_E16 + 0U, // PseudoVREDMINU_VS_MF2_E16_MASK + 0U, // PseudoVREDMINU_VS_MF2_E32 + 0U, // PseudoVREDMINU_VS_MF2_E32_MASK + 0U, // PseudoVREDMINU_VS_MF2_E8 + 0U, // PseudoVREDMINU_VS_MF2_E8_MASK + 0U, // PseudoVREDMINU_VS_MF4_E16 + 0U, // PseudoVREDMINU_VS_MF4_E16_MASK + 0U, // PseudoVREDMINU_VS_MF4_E8 + 0U, // PseudoVREDMINU_VS_MF4_E8_MASK + 0U, // PseudoVREDMINU_VS_MF8_E8 + 0U, // PseudoVREDMINU_VS_MF8_E8_MASK + 0U, // PseudoVREDMIN_VS_M1_E16 + 0U, // PseudoVREDMIN_VS_M1_E16_MASK + 0U, // PseudoVREDMIN_VS_M1_E32 + 0U, // PseudoVREDMIN_VS_M1_E32_MASK + 0U, // PseudoVREDMIN_VS_M1_E64 + 0U, // PseudoVREDMIN_VS_M1_E64_MASK + 0U, // PseudoVREDMIN_VS_M1_E8 + 0U, // PseudoVREDMIN_VS_M1_E8_MASK + 0U, // PseudoVREDMIN_VS_M2_E16 + 0U, // PseudoVREDMIN_VS_M2_E16_MASK + 0U, // PseudoVREDMIN_VS_M2_E32 + 0U, // PseudoVREDMIN_VS_M2_E32_MASK + 0U, // PseudoVREDMIN_VS_M2_E64 + 0U, // PseudoVREDMIN_VS_M2_E64_MASK + 0U, // PseudoVREDMIN_VS_M2_E8 + 0U, // PseudoVREDMIN_VS_M2_E8_MASK + 0U, // PseudoVREDMIN_VS_M4_E16 + 0U, // PseudoVREDMIN_VS_M4_E16_MASK + 0U, // PseudoVREDMIN_VS_M4_E32 + 0U, // PseudoVREDMIN_VS_M4_E32_MASK + 0U, // PseudoVREDMIN_VS_M4_E64 + 0U, // PseudoVREDMIN_VS_M4_E64_MASK + 0U, // PseudoVREDMIN_VS_M4_E8 + 0U, // PseudoVREDMIN_VS_M4_E8_MASK + 0U, // PseudoVREDMIN_VS_M8_E16 + 0U, // PseudoVREDMIN_VS_M8_E16_MASK + 0U, // PseudoVREDMIN_VS_M8_E32 + 0U, // PseudoVREDMIN_VS_M8_E32_MASK + 0U, // PseudoVREDMIN_VS_M8_E64 + 0U, // PseudoVREDMIN_VS_M8_E64_MASK + 0U, // PseudoVREDMIN_VS_M8_E8 + 0U, // PseudoVREDMIN_VS_M8_E8_MASK + 0U, // PseudoVREDMIN_VS_MF2_E16 + 0U, // PseudoVREDMIN_VS_MF2_E16_MASK + 0U, // PseudoVREDMIN_VS_MF2_E32 + 0U, // PseudoVREDMIN_VS_MF2_E32_MASK + 0U, // PseudoVREDMIN_VS_MF2_E8 + 0U, // PseudoVREDMIN_VS_MF2_E8_MASK + 0U, // PseudoVREDMIN_VS_MF4_E16 + 0U, // PseudoVREDMIN_VS_MF4_E16_MASK + 0U, // PseudoVREDMIN_VS_MF4_E8 + 0U, // PseudoVREDMIN_VS_MF4_E8_MASK + 0U, // PseudoVREDMIN_VS_MF8_E8 + 0U, // PseudoVREDMIN_VS_MF8_E8_MASK + 0U, // PseudoVREDOR_VS_M1_E16 + 0U, // PseudoVREDOR_VS_M1_E16_MASK + 0U, // PseudoVREDOR_VS_M1_E32 + 0U, // PseudoVREDOR_VS_M1_E32_MASK + 0U, // PseudoVREDOR_VS_M1_E64 + 0U, // PseudoVREDOR_VS_M1_E64_MASK + 0U, // PseudoVREDOR_VS_M1_E8 + 0U, // PseudoVREDOR_VS_M1_E8_MASK + 0U, // PseudoVREDOR_VS_M2_E16 + 0U, // PseudoVREDOR_VS_M2_E16_MASK + 0U, // PseudoVREDOR_VS_M2_E32 + 0U, // PseudoVREDOR_VS_M2_E32_MASK + 0U, // PseudoVREDOR_VS_M2_E64 + 0U, // PseudoVREDOR_VS_M2_E64_MASK + 0U, // PseudoVREDOR_VS_M2_E8 + 0U, // PseudoVREDOR_VS_M2_E8_MASK + 0U, // PseudoVREDOR_VS_M4_E16 + 0U, // PseudoVREDOR_VS_M4_E16_MASK + 0U, // PseudoVREDOR_VS_M4_E32 + 0U, // PseudoVREDOR_VS_M4_E32_MASK + 0U, // PseudoVREDOR_VS_M4_E64 + 0U, // PseudoVREDOR_VS_M4_E64_MASK + 0U, // PseudoVREDOR_VS_M4_E8 + 0U, // PseudoVREDOR_VS_M4_E8_MASK + 0U, // PseudoVREDOR_VS_M8_E16 + 0U, // PseudoVREDOR_VS_M8_E16_MASK + 0U, // PseudoVREDOR_VS_M8_E32 + 0U, // PseudoVREDOR_VS_M8_E32_MASK + 0U, // PseudoVREDOR_VS_M8_E64 + 0U, // PseudoVREDOR_VS_M8_E64_MASK + 0U, // PseudoVREDOR_VS_M8_E8 + 0U, // PseudoVREDOR_VS_M8_E8_MASK + 0U, // PseudoVREDOR_VS_MF2_E16 + 0U, // PseudoVREDOR_VS_MF2_E16_MASK + 0U, // PseudoVREDOR_VS_MF2_E32 + 0U, // PseudoVREDOR_VS_MF2_E32_MASK + 0U, // PseudoVREDOR_VS_MF2_E8 + 0U, // PseudoVREDOR_VS_MF2_E8_MASK + 0U, // PseudoVREDOR_VS_MF4_E16 + 0U, // PseudoVREDOR_VS_MF4_E16_MASK + 0U, // PseudoVREDOR_VS_MF4_E8 + 0U, // PseudoVREDOR_VS_MF4_E8_MASK + 0U, // PseudoVREDOR_VS_MF8_E8 + 0U, // PseudoVREDOR_VS_MF8_E8_MASK + 0U, // PseudoVREDSUM_VS_M1_E16 + 0U, // PseudoVREDSUM_VS_M1_E16_MASK + 0U, // PseudoVREDSUM_VS_M1_E32 + 0U, // PseudoVREDSUM_VS_M1_E32_MASK + 0U, // PseudoVREDSUM_VS_M1_E64 + 0U, // PseudoVREDSUM_VS_M1_E64_MASK + 0U, // PseudoVREDSUM_VS_M1_E8 + 0U, // PseudoVREDSUM_VS_M1_E8_MASK + 0U, // PseudoVREDSUM_VS_M2_E16 + 0U, // PseudoVREDSUM_VS_M2_E16_MASK + 0U, // PseudoVREDSUM_VS_M2_E32 + 0U, // PseudoVREDSUM_VS_M2_E32_MASK + 0U, // PseudoVREDSUM_VS_M2_E64 + 0U, // PseudoVREDSUM_VS_M2_E64_MASK + 0U, // PseudoVREDSUM_VS_M2_E8 + 0U, // PseudoVREDSUM_VS_M2_E8_MASK + 0U, // PseudoVREDSUM_VS_M4_E16 + 0U, // PseudoVREDSUM_VS_M4_E16_MASK + 0U, // PseudoVREDSUM_VS_M4_E32 + 0U, // PseudoVREDSUM_VS_M4_E32_MASK + 0U, // PseudoVREDSUM_VS_M4_E64 + 0U, // PseudoVREDSUM_VS_M4_E64_MASK + 0U, // PseudoVREDSUM_VS_M4_E8 + 0U, // PseudoVREDSUM_VS_M4_E8_MASK + 0U, // PseudoVREDSUM_VS_M8_E16 + 0U, // PseudoVREDSUM_VS_M8_E16_MASK + 0U, // PseudoVREDSUM_VS_M8_E32 + 0U, // PseudoVREDSUM_VS_M8_E32_MASK + 0U, // PseudoVREDSUM_VS_M8_E64 + 0U, // PseudoVREDSUM_VS_M8_E64_MASK + 0U, // PseudoVREDSUM_VS_M8_E8 + 0U, // PseudoVREDSUM_VS_M8_E8_MASK + 0U, // PseudoVREDSUM_VS_MF2_E16 + 0U, // PseudoVREDSUM_VS_MF2_E16_MASK + 0U, // PseudoVREDSUM_VS_MF2_E32 + 0U, // PseudoVREDSUM_VS_MF2_E32_MASK + 0U, // PseudoVREDSUM_VS_MF2_E8 + 0U, // PseudoVREDSUM_VS_MF2_E8_MASK + 0U, // PseudoVREDSUM_VS_MF4_E16 + 0U, // PseudoVREDSUM_VS_MF4_E16_MASK + 0U, // PseudoVREDSUM_VS_MF4_E8 + 0U, // PseudoVREDSUM_VS_MF4_E8_MASK + 0U, // PseudoVREDSUM_VS_MF8_E8 + 0U, // PseudoVREDSUM_VS_MF8_E8_MASK + 0U, // PseudoVREDXOR_VS_M1_E16 + 0U, // PseudoVREDXOR_VS_M1_E16_MASK + 0U, // PseudoVREDXOR_VS_M1_E32 + 0U, // PseudoVREDXOR_VS_M1_E32_MASK + 0U, // PseudoVREDXOR_VS_M1_E64 + 0U, // PseudoVREDXOR_VS_M1_E64_MASK + 0U, // PseudoVREDXOR_VS_M1_E8 + 0U, // PseudoVREDXOR_VS_M1_E8_MASK + 0U, // PseudoVREDXOR_VS_M2_E16 + 0U, // PseudoVREDXOR_VS_M2_E16_MASK + 0U, // PseudoVREDXOR_VS_M2_E32 + 0U, // PseudoVREDXOR_VS_M2_E32_MASK + 0U, // PseudoVREDXOR_VS_M2_E64 + 0U, // PseudoVREDXOR_VS_M2_E64_MASK + 0U, // PseudoVREDXOR_VS_M2_E8 + 0U, // PseudoVREDXOR_VS_M2_E8_MASK + 0U, // PseudoVREDXOR_VS_M4_E16 + 0U, // PseudoVREDXOR_VS_M4_E16_MASK + 0U, // PseudoVREDXOR_VS_M4_E32 + 0U, // PseudoVREDXOR_VS_M4_E32_MASK + 0U, // PseudoVREDXOR_VS_M4_E64 + 0U, // PseudoVREDXOR_VS_M4_E64_MASK + 0U, // PseudoVREDXOR_VS_M4_E8 + 0U, // PseudoVREDXOR_VS_M4_E8_MASK + 0U, // PseudoVREDXOR_VS_M8_E16 + 0U, // PseudoVREDXOR_VS_M8_E16_MASK + 0U, // PseudoVREDXOR_VS_M8_E32 + 0U, // PseudoVREDXOR_VS_M8_E32_MASK + 0U, // PseudoVREDXOR_VS_M8_E64 + 0U, // PseudoVREDXOR_VS_M8_E64_MASK + 0U, // PseudoVREDXOR_VS_M8_E8 + 0U, // PseudoVREDXOR_VS_M8_E8_MASK + 0U, // PseudoVREDXOR_VS_MF2_E16 + 0U, // PseudoVREDXOR_VS_MF2_E16_MASK + 0U, // PseudoVREDXOR_VS_MF2_E32 + 0U, // PseudoVREDXOR_VS_MF2_E32_MASK + 0U, // PseudoVREDXOR_VS_MF2_E8 + 0U, // PseudoVREDXOR_VS_MF2_E8_MASK + 0U, // PseudoVREDXOR_VS_MF4_E16 + 0U, // PseudoVREDXOR_VS_MF4_E16_MASK + 0U, // PseudoVREDXOR_VS_MF4_E8 + 0U, // PseudoVREDXOR_VS_MF4_E8_MASK + 0U, // PseudoVREDXOR_VS_MF8_E8 + 0U, // PseudoVREDXOR_VS_MF8_E8_MASK + 0U, // PseudoVRELOAD2_M1 + 0U, // PseudoVRELOAD2_M2 + 0U, // PseudoVRELOAD2_M4 + 0U, // PseudoVRELOAD2_MF2 + 0U, // PseudoVRELOAD2_MF4 + 0U, // PseudoVRELOAD2_MF8 + 0U, // PseudoVRELOAD3_M1 + 0U, // PseudoVRELOAD3_M2 + 0U, // PseudoVRELOAD3_MF2 + 0U, // PseudoVRELOAD3_MF4 + 0U, // PseudoVRELOAD3_MF8 + 0U, // PseudoVRELOAD4_M1 + 0U, // PseudoVRELOAD4_M2 + 0U, // PseudoVRELOAD4_MF2 + 0U, // PseudoVRELOAD4_MF4 + 0U, // PseudoVRELOAD4_MF8 + 0U, // PseudoVRELOAD5_M1 + 0U, // PseudoVRELOAD5_MF2 + 0U, // PseudoVRELOAD5_MF4 + 0U, // PseudoVRELOAD5_MF8 + 0U, // PseudoVRELOAD6_M1 + 0U, // PseudoVRELOAD6_MF2 + 0U, // PseudoVRELOAD6_MF4 + 0U, // PseudoVRELOAD6_MF8 + 0U, // PseudoVRELOAD7_M1 + 0U, // PseudoVRELOAD7_MF2 + 0U, // PseudoVRELOAD7_MF4 + 0U, // PseudoVRELOAD7_MF8 + 0U, // PseudoVRELOAD8_M1 + 0U, // PseudoVRELOAD8_MF2 + 0U, // PseudoVRELOAD8_MF4 + 0U, // PseudoVRELOAD8_MF8 + 0U, // PseudoVREMU_VV_M1_E16 + 0U, // PseudoVREMU_VV_M1_E16_MASK + 0U, // PseudoVREMU_VV_M1_E32 + 0U, // PseudoVREMU_VV_M1_E32_MASK + 0U, // PseudoVREMU_VV_M1_E64 + 0U, // PseudoVREMU_VV_M1_E64_MASK + 0U, // PseudoVREMU_VV_M1_E8 + 0U, // PseudoVREMU_VV_M1_E8_MASK + 0U, // PseudoVREMU_VV_M2_E16 + 0U, // PseudoVREMU_VV_M2_E16_MASK + 0U, // PseudoVREMU_VV_M2_E32 + 0U, // PseudoVREMU_VV_M2_E32_MASK + 0U, // PseudoVREMU_VV_M2_E64 + 0U, // PseudoVREMU_VV_M2_E64_MASK + 0U, // PseudoVREMU_VV_M2_E8 + 0U, // PseudoVREMU_VV_M2_E8_MASK + 0U, // PseudoVREMU_VV_M4_E16 + 0U, // PseudoVREMU_VV_M4_E16_MASK + 0U, // PseudoVREMU_VV_M4_E32 + 0U, // PseudoVREMU_VV_M4_E32_MASK + 0U, // PseudoVREMU_VV_M4_E64 + 0U, // PseudoVREMU_VV_M4_E64_MASK + 0U, // PseudoVREMU_VV_M4_E8 + 0U, // PseudoVREMU_VV_M4_E8_MASK + 0U, // PseudoVREMU_VV_M8_E16 + 0U, // PseudoVREMU_VV_M8_E16_MASK + 0U, // PseudoVREMU_VV_M8_E32 + 0U, // PseudoVREMU_VV_M8_E32_MASK + 0U, // PseudoVREMU_VV_M8_E64 + 0U, // PseudoVREMU_VV_M8_E64_MASK + 0U, // PseudoVREMU_VV_M8_E8 + 0U, // PseudoVREMU_VV_M8_E8_MASK + 0U, // PseudoVREMU_VV_MF2_E16 + 0U, // PseudoVREMU_VV_MF2_E16_MASK + 0U, // PseudoVREMU_VV_MF2_E32 + 0U, // PseudoVREMU_VV_MF2_E32_MASK + 0U, // PseudoVREMU_VV_MF2_E8 + 0U, // PseudoVREMU_VV_MF2_E8_MASK + 0U, // PseudoVREMU_VV_MF4_E16 + 0U, // PseudoVREMU_VV_MF4_E16_MASK + 0U, // PseudoVREMU_VV_MF4_E8 + 0U, // PseudoVREMU_VV_MF4_E8_MASK + 0U, // PseudoVREMU_VV_MF8_E8 + 0U, // PseudoVREMU_VV_MF8_E8_MASK + 0U, // PseudoVREMU_VX_M1_E16 + 0U, // PseudoVREMU_VX_M1_E16_MASK + 0U, // PseudoVREMU_VX_M1_E32 + 0U, // PseudoVREMU_VX_M1_E32_MASK + 0U, // PseudoVREMU_VX_M1_E64 + 0U, // PseudoVREMU_VX_M1_E64_MASK + 0U, // PseudoVREMU_VX_M1_E8 + 0U, // PseudoVREMU_VX_M1_E8_MASK + 0U, // PseudoVREMU_VX_M2_E16 + 0U, // PseudoVREMU_VX_M2_E16_MASK + 0U, // PseudoVREMU_VX_M2_E32 + 0U, // PseudoVREMU_VX_M2_E32_MASK + 0U, // PseudoVREMU_VX_M2_E64 + 0U, // PseudoVREMU_VX_M2_E64_MASK + 0U, // PseudoVREMU_VX_M2_E8 + 0U, // PseudoVREMU_VX_M2_E8_MASK + 0U, // PseudoVREMU_VX_M4_E16 + 0U, // PseudoVREMU_VX_M4_E16_MASK + 0U, // PseudoVREMU_VX_M4_E32 + 0U, // PseudoVREMU_VX_M4_E32_MASK + 0U, // PseudoVREMU_VX_M4_E64 + 0U, // PseudoVREMU_VX_M4_E64_MASK + 0U, // PseudoVREMU_VX_M4_E8 + 0U, // PseudoVREMU_VX_M4_E8_MASK + 0U, // PseudoVREMU_VX_M8_E16 + 0U, // PseudoVREMU_VX_M8_E16_MASK + 0U, // PseudoVREMU_VX_M8_E32 + 0U, // PseudoVREMU_VX_M8_E32_MASK + 0U, // PseudoVREMU_VX_M8_E64 + 0U, // PseudoVREMU_VX_M8_E64_MASK + 0U, // PseudoVREMU_VX_M8_E8 + 0U, // PseudoVREMU_VX_M8_E8_MASK + 0U, // PseudoVREMU_VX_MF2_E16 + 0U, // PseudoVREMU_VX_MF2_E16_MASK + 0U, // PseudoVREMU_VX_MF2_E32 + 0U, // PseudoVREMU_VX_MF2_E32_MASK + 0U, // PseudoVREMU_VX_MF2_E8 + 0U, // PseudoVREMU_VX_MF2_E8_MASK + 0U, // PseudoVREMU_VX_MF4_E16 + 0U, // PseudoVREMU_VX_MF4_E16_MASK + 0U, // PseudoVREMU_VX_MF4_E8 + 0U, // PseudoVREMU_VX_MF4_E8_MASK + 0U, // PseudoVREMU_VX_MF8_E8 + 0U, // PseudoVREMU_VX_MF8_E8_MASK + 0U, // PseudoVREM_VV_M1_E16 + 0U, // PseudoVREM_VV_M1_E16_MASK + 0U, // PseudoVREM_VV_M1_E32 + 0U, // PseudoVREM_VV_M1_E32_MASK + 0U, // PseudoVREM_VV_M1_E64 + 0U, // PseudoVREM_VV_M1_E64_MASK + 0U, // PseudoVREM_VV_M1_E8 + 0U, // PseudoVREM_VV_M1_E8_MASK + 0U, // PseudoVREM_VV_M2_E16 + 0U, // PseudoVREM_VV_M2_E16_MASK + 0U, // PseudoVREM_VV_M2_E32 + 0U, // PseudoVREM_VV_M2_E32_MASK + 0U, // PseudoVREM_VV_M2_E64 + 0U, // PseudoVREM_VV_M2_E64_MASK + 0U, // PseudoVREM_VV_M2_E8 + 0U, // PseudoVREM_VV_M2_E8_MASK + 0U, // PseudoVREM_VV_M4_E16 + 0U, // PseudoVREM_VV_M4_E16_MASK + 0U, // PseudoVREM_VV_M4_E32 + 0U, // PseudoVREM_VV_M4_E32_MASK + 0U, // PseudoVREM_VV_M4_E64 + 0U, // PseudoVREM_VV_M4_E64_MASK + 0U, // PseudoVREM_VV_M4_E8 + 0U, // PseudoVREM_VV_M4_E8_MASK + 0U, // PseudoVREM_VV_M8_E16 + 0U, // PseudoVREM_VV_M8_E16_MASK + 0U, // PseudoVREM_VV_M8_E32 + 0U, // PseudoVREM_VV_M8_E32_MASK + 0U, // PseudoVREM_VV_M8_E64 + 0U, // PseudoVREM_VV_M8_E64_MASK + 0U, // PseudoVREM_VV_M8_E8 + 0U, // PseudoVREM_VV_M8_E8_MASK + 0U, // PseudoVREM_VV_MF2_E16 + 0U, // PseudoVREM_VV_MF2_E16_MASK + 0U, // PseudoVREM_VV_MF2_E32 + 0U, // PseudoVREM_VV_MF2_E32_MASK + 0U, // PseudoVREM_VV_MF2_E8 + 0U, // PseudoVREM_VV_MF2_E8_MASK + 0U, // PseudoVREM_VV_MF4_E16 + 0U, // PseudoVREM_VV_MF4_E16_MASK + 0U, // PseudoVREM_VV_MF4_E8 + 0U, // PseudoVREM_VV_MF4_E8_MASK + 0U, // PseudoVREM_VV_MF8_E8 + 0U, // PseudoVREM_VV_MF8_E8_MASK + 0U, // PseudoVREM_VX_M1_E16 + 0U, // PseudoVREM_VX_M1_E16_MASK + 0U, // PseudoVREM_VX_M1_E32 + 0U, // PseudoVREM_VX_M1_E32_MASK + 0U, // PseudoVREM_VX_M1_E64 + 0U, // PseudoVREM_VX_M1_E64_MASK + 0U, // PseudoVREM_VX_M1_E8 + 0U, // PseudoVREM_VX_M1_E8_MASK + 0U, // PseudoVREM_VX_M2_E16 + 0U, // PseudoVREM_VX_M2_E16_MASK + 0U, // PseudoVREM_VX_M2_E32 + 0U, // PseudoVREM_VX_M2_E32_MASK + 0U, // PseudoVREM_VX_M2_E64 + 0U, // PseudoVREM_VX_M2_E64_MASK + 0U, // PseudoVREM_VX_M2_E8 + 0U, // PseudoVREM_VX_M2_E8_MASK + 0U, // PseudoVREM_VX_M4_E16 + 0U, // PseudoVREM_VX_M4_E16_MASK + 0U, // PseudoVREM_VX_M4_E32 + 0U, // PseudoVREM_VX_M4_E32_MASK + 0U, // PseudoVREM_VX_M4_E64 + 0U, // PseudoVREM_VX_M4_E64_MASK + 0U, // PseudoVREM_VX_M4_E8 + 0U, // PseudoVREM_VX_M4_E8_MASK + 0U, // PseudoVREM_VX_M8_E16 + 0U, // PseudoVREM_VX_M8_E16_MASK + 0U, // PseudoVREM_VX_M8_E32 + 0U, // PseudoVREM_VX_M8_E32_MASK + 0U, // PseudoVREM_VX_M8_E64 + 0U, // PseudoVREM_VX_M8_E64_MASK + 0U, // PseudoVREM_VX_M8_E8 + 0U, // PseudoVREM_VX_M8_E8_MASK + 0U, // PseudoVREM_VX_MF2_E16 + 0U, // PseudoVREM_VX_MF2_E16_MASK + 0U, // PseudoVREM_VX_MF2_E32 + 0U, // PseudoVREM_VX_MF2_E32_MASK + 0U, // PseudoVREM_VX_MF2_E8 + 0U, // PseudoVREM_VX_MF2_E8_MASK + 0U, // PseudoVREM_VX_MF4_E16 + 0U, // PseudoVREM_VX_MF4_E16_MASK + 0U, // PseudoVREM_VX_MF4_E8 + 0U, // PseudoVREM_VX_MF4_E8_MASK + 0U, // PseudoVREM_VX_MF8_E8 + 0U, // PseudoVREM_VX_MF8_E8_MASK + 0U, // PseudoVREV8_V_M1 + 0U, // PseudoVREV8_V_M1_MASK + 0U, // PseudoVREV8_V_M2 + 0U, // PseudoVREV8_V_M2_MASK + 0U, // PseudoVREV8_V_M4 + 0U, // PseudoVREV8_V_M4_MASK + 0U, // PseudoVREV8_V_M8 + 0U, // PseudoVREV8_V_M8_MASK + 0U, // PseudoVREV8_V_MF2 + 0U, // PseudoVREV8_V_MF2_MASK + 0U, // PseudoVREV8_V_MF4 + 0U, // PseudoVREV8_V_MF4_MASK + 0U, // PseudoVREV8_V_MF8 + 0U, // PseudoVREV8_V_MF8_MASK + 0U, // PseudoVRGATHEREI16_VV_M1_E16_M1 + 0U, // PseudoVRGATHEREI16_VV_M1_E16_M1_MASK + 0U, // PseudoVRGATHEREI16_VV_M1_E16_M2 + 0U, // PseudoVRGATHEREI16_VV_M1_E16_M2_MASK + 0U, // PseudoVRGATHEREI16_VV_M1_E16_MF2 + 0U, // PseudoVRGATHEREI16_VV_M1_E16_MF2_MASK + 0U, // PseudoVRGATHEREI16_VV_M1_E16_MF4 + 0U, // PseudoVRGATHEREI16_VV_M1_E16_MF4_MASK + 0U, // PseudoVRGATHEREI16_VV_M1_E32_M1 + 0U, // PseudoVRGATHEREI16_VV_M1_E32_M1_MASK + 0U, // PseudoVRGATHEREI16_VV_M1_E32_M2 + 0U, // PseudoVRGATHEREI16_VV_M1_E32_M2_MASK + 0U, // PseudoVRGATHEREI16_VV_M1_E32_MF2 + 0U, // PseudoVRGATHEREI16_VV_M1_E32_MF2_MASK + 0U, // PseudoVRGATHEREI16_VV_M1_E32_MF4 + 0U, // PseudoVRGATHEREI16_VV_M1_E32_MF4_MASK + 0U, // PseudoVRGATHEREI16_VV_M1_E64_M1 + 0U, // PseudoVRGATHEREI16_VV_M1_E64_M1_MASK + 0U, // PseudoVRGATHEREI16_VV_M1_E64_M2 + 0U, // PseudoVRGATHEREI16_VV_M1_E64_M2_MASK + 0U, // PseudoVRGATHEREI16_VV_M1_E64_MF2 + 0U, // PseudoVRGATHEREI16_VV_M1_E64_MF2_MASK + 0U, // PseudoVRGATHEREI16_VV_M1_E64_MF4 + 0U, // PseudoVRGATHEREI16_VV_M1_E64_MF4_MASK + 0U, // PseudoVRGATHEREI16_VV_M1_E8_M1 + 0U, // PseudoVRGATHEREI16_VV_M1_E8_M1_MASK + 0U, // PseudoVRGATHEREI16_VV_M1_E8_M2 + 0U, // PseudoVRGATHEREI16_VV_M1_E8_M2_MASK + 0U, // PseudoVRGATHEREI16_VV_M1_E8_MF2 + 0U, // PseudoVRGATHEREI16_VV_M1_E8_MF2_MASK + 0U, // PseudoVRGATHEREI16_VV_M1_E8_MF4 + 0U, // PseudoVRGATHEREI16_VV_M1_E8_MF4_MASK + 0U, // PseudoVRGATHEREI16_VV_M2_E16_M1 + 0U, // PseudoVRGATHEREI16_VV_M2_E16_M1_MASK + 0U, // PseudoVRGATHEREI16_VV_M2_E16_M2 + 0U, // PseudoVRGATHEREI16_VV_M2_E16_M2_MASK + 0U, // PseudoVRGATHEREI16_VV_M2_E16_M4 + 0U, // PseudoVRGATHEREI16_VV_M2_E16_M4_MASK + 0U, // PseudoVRGATHEREI16_VV_M2_E16_MF2 + 0U, // PseudoVRGATHEREI16_VV_M2_E16_MF2_MASK + 0U, // PseudoVRGATHEREI16_VV_M2_E32_M1 + 0U, // PseudoVRGATHEREI16_VV_M2_E32_M1_MASK + 0U, // PseudoVRGATHEREI16_VV_M2_E32_M2 + 0U, // PseudoVRGATHEREI16_VV_M2_E32_M2_MASK + 0U, // PseudoVRGATHEREI16_VV_M2_E32_M4 + 0U, // PseudoVRGATHEREI16_VV_M2_E32_M4_MASK + 0U, // PseudoVRGATHEREI16_VV_M2_E32_MF2 + 0U, // PseudoVRGATHEREI16_VV_M2_E32_MF2_MASK + 0U, // PseudoVRGATHEREI16_VV_M2_E64_M1 + 0U, // PseudoVRGATHEREI16_VV_M2_E64_M1_MASK + 0U, // PseudoVRGATHEREI16_VV_M2_E64_M2 + 0U, // PseudoVRGATHEREI16_VV_M2_E64_M2_MASK + 0U, // PseudoVRGATHEREI16_VV_M2_E64_M4 + 0U, // PseudoVRGATHEREI16_VV_M2_E64_M4_MASK + 0U, // PseudoVRGATHEREI16_VV_M2_E64_MF2 + 0U, // PseudoVRGATHEREI16_VV_M2_E64_MF2_MASK + 0U, // PseudoVRGATHEREI16_VV_M2_E8_M1 + 0U, // PseudoVRGATHEREI16_VV_M2_E8_M1_MASK + 0U, // PseudoVRGATHEREI16_VV_M2_E8_M2 + 0U, // PseudoVRGATHEREI16_VV_M2_E8_M2_MASK + 0U, // PseudoVRGATHEREI16_VV_M2_E8_M4 + 0U, // PseudoVRGATHEREI16_VV_M2_E8_M4_MASK + 0U, // PseudoVRGATHEREI16_VV_M2_E8_MF2 + 0U, // PseudoVRGATHEREI16_VV_M2_E8_MF2_MASK + 0U, // PseudoVRGATHEREI16_VV_M4_E16_M1 + 0U, // PseudoVRGATHEREI16_VV_M4_E16_M1_MASK + 0U, // PseudoVRGATHEREI16_VV_M4_E16_M2 + 0U, // PseudoVRGATHEREI16_VV_M4_E16_M2_MASK + 0U, // PseudoVRGATHEREI16_VV_M4_E16_M4 + 0U, // PseudoVRGATHEREI16_VV_M4_E16_M4_MASK + 0U, // PseudoVRGATHEREI16_VV_M4_E16_M8 + 0U, // PseudoVRGATHEREI16_VV_M4_E16_M8_MASK + 0U, // PseudoVRGATHEREI16_VV_M4_E32_M1 + 0U, // PseudoVRGATHEREI16_VV_M4_E32_M1_MASK + 0U, // PseudoVRGATHEREI16_VV_M4_E32_M2 + 0U, // PseudoVRGATHEREI16_VV_M4_E32_M2_MASK + 0U, // PseudoVRGATHEREI16_VV_M4_E32_M4 + 0U, // PseudoVRGATHEREI16_VV_M4_E32_M4_MASK + 0U, // PseudoVRGATHEREI16_VV_M4_E32_M8 + 0U, // PseudoVRGATHEREI16_VV_M4_E32_M8_MASK + 0U, // PseudoVRGATHEREI16_VV_M4_E64_M1 + 0U, // PseudoVRGATHEREI16_VV_M4_E64_M1_MASK + 0U, // PseudoVRGATHEREI16_VV_M4_E64_M2 + 0U, // PseudoVRGATHEREI16_VV_M4_E64_M2_MASK + 0U, // PseudoVRGATHEREI16_VV_M4_E64_M4 + 0U, // PseudoVRGATHEREI16_VV_M4_E64_M4_MASK + 0U, // PseudoVRGATHEREI16_VV_M4_E64_M8 + 0U, // PseudoVRGATHEREI16_VV_M4_E64_M8_MASK + 0U, // PseudoVRGATHEREI16_VV_M4_E8_M1 + 0U, // PseudoVRGATHEREI16_VV_M4_E8_M1_MASK + 0U, // PseudoVRGATHEREI16_VV_M4_E8_M2 + 0U, // PseudoVRGATHEREI16_VV_M4_E8_M2_MASK + 0U, // PseudoVRGATHEREI16_VV_M4_E8_M4 + 0U, // PseudoVRGATHEREI16_VV_M4_E8_M4_MASK + 0U, // PseudoVRGATHEREI16_VV_M4_E8_M8 + 0U, // PseudoVRGATHEREI16_VV_M4_E8_M8_MASK + 0U, // PseudoVRGATHEREI16_VV_M8_E16_M2 + 0U, // PseudoVRGATHEREI16_VV_M8_E16_M2_MASK + 0U, // PseudoVRGATHEREI16_VV_M8_E16_M4 + 0U, // PseudoVRGATHEREI16_VV_M8_E16_M4_MASK + 0U, // PseudoVRGATHEREI16_VV_M8_E16_M8 + 0U, // PseudoVRGATHEREI16_VV_M8_E16_M8_MASK + 0U, // PseudoVRGATHEREI16_VV_M8_E32_M2 + 0U, // PseudoVRGATHEREI16_VV_M8_E32_M2_MASK + 0U, // PseudoVRGATHEREI16_VV_M8_E32_M4 + 0U, // PseudoVRGATHEREI16_VV_M8_E32_M4_MASK + 0U, // PseudoVRGATHEREI16_VV_M8_E32_M8 + 0U, // PseudoVRGATHEREI16_VV_M8_E32_M8_MASK + 0U, // PseudoVRGATHEREI16_VV_M8_E64_M2 + 0U, // PseudoVRGATHEREI16_VV_M8_E64_M2_MASK + 0U, // PseudoVRGATHEREI16_VV_M8_E64_M4 + 0U, // PseudoVRGATHEREI16_VV_M8_E64_M4_MASK + 0U, // PseudoVRGATHEREI16_VV_M8_E64_M8 + 0U, // PseudoVRGATHEREI16_VV_M8_E64_M8_MASK + 0U, // PseudoVRGATHEREI16_VV_M8_E8_M2 + 0U, // PseudoVRGATHEREI16_VV_M8_E8_M2_MASK + 0U, // PseudoVRGATHEREI16_VV_M8_E8_M4 + 0U, // PseudoVRGATHEREI16_VV_M8_E8_M4_MASK + 0U, // PseudoVRGATHEREI16_VV_M8_E8_M8 + 0U, // PseudoVRGATHEREI16_VV_M8_E8_M8_MASK + 0U, // PseudoVRGATHEREI16_VV_MF2_E16_M1 + 0U, // PseudoVRGATHEREI16_VV_MF2_E16_M1_MASK + 0U, // PseudoVRGATHEREI16_VV_MF2_E16_MF2 + 0U, // PseudoVRGATHEREI16_VV_MF2_E16_MF2_MASK + 0U, // PseudoVRGATHEREI16_VV_MF2_E16_MF4 + 0U, // PseudoVRGATHEREI16_VV_MF2_E16_MF4_MASK + 0U, // PseudoVRGATHEREI16_VV_MF2_E16_MF8 + 0U, // PseudoVRGATHEREI16_VV_MF2_E16_MF8_MASK + 0U, // PseudoVRGATHEREI16_VV_MF2_E32_M1 + 0U, // PseudoVRGATHEREI16_VV_MF2_E32_M1_MASK + 0U, // PseudoVRGATHEREI16_VV_MF2_E32_MF2 + 0U, // PseudoVRGATHEREI16_VV_MF2_E32_MF2_MASK + 0U, // PseudoVRGATHEREI16_VV_MF2_E32_MF4 + 0U, // PseudoVRGATHEREI16_VV_MF2_E32_MF4_MASK + 0U, // PseudoVRGATHEREI16_VV_MF2_E32_MF8 + 0U, // PseudoVRGATHEREI16_VV_MF2_E32_MF8_MASK + 0U, // PseudoVRGATHEREI16_VV_MF2_E8_M1 + 0U, // PseudoVRGATHEREI16_VV_MF2_E8_M1_MASK + 0U, // PseudoVRGATHEREI16_VV_MF2_E8_MF2 + 0U, // PseudoVRGATHEREI16_VV_MF2_E8_MF2_MASK + 0U, // PseudoVRGATHEREI16_VV_MF2_E8_MF4 + 0U, // PseudoVRGATHEREI16_VV_MF2_E8_MF4_MASK + 0U, // PseudoVRGATHEREI16_VV_MF2_E8_MF8 + 0U, // PseudoVRGATHEREI16_VV_MF2_E8_MF8_MASK + 0U, // PseudoVRGATHEREI16_VV_MF4_E16_MF2 + 0U, // PseudoVRGATHEREI16_VV_MF4_E16_MF2_MASK + 0U, // PseudoVRGATHEREI16_VV_MF4_E16_MF4 + 0U, // PseudoVRGATHEREI16_VV_MF4_E16_MF4_MASK + 0U, // PseudoVRGATHEREI16_VV_MF4_E16_MF8 + 0U, // PseudoVRGATHEREI16_VV_MF4_E16_MF8_MASK + 0U, // PseudoVRGATHEREI16_VV_MF4_E8_MF2 + 0U, // PseudoVRGATHEREI16_VV_MF4_E8_MF2_MASK + 0U, // PseudoVRGATHEREI16_VV_MF4_E8_MF4 + 0U, // PseudoVRGATHEREI16_VV_MF4_E8_MF4_MASK + 0U, // PseudoVRGATHEREI16_VV_MF4_E8_MF8 + 0U, // PseudoVRGATHEREI16_VV_MF4_E8_MF8_MASK + 0U, // PseudoVRGATHEREI16_VV_MF8_E8_MF4 + 0U, // PseudoVRGATHEREI16_VV_MF8_E8_MF4_MASK + 0U, // PseudoVRGATHEREI16_VV_MF8_E8_MF8 + 0U, // PseudoVRGATHEREI16_VV_MF8_E8_MF8_MASK + 0U, // PseudoVRGATHER_VI_M1 + 0U, // PseudoVRGATHER_VI_M1_MASK + 0U, // PseudoVRGATHER_VI_M2 + 0U, // PseudoVRGATHER_VI_M2_MASK + 0U, // PseudoVRGATHER_VI_M4 + 0U, // PseudoVRGATHER_VI_M4_MASK + 0U, // PseudoVRGATHER_VI_M8 + 0U, // PseudoVRGATHER_VI_M8_MASK + 0U, // PseudoVRGATHER_VI_MF2 + 0U, // PseudoVRGATHER_VI_MF2_MASK + 0U, // PseudoVRGATHER_VI_MF4 + 0U, // PseudoVRGATHER_VI_MF4_MASK + 0U, // PseudoVRGATHER_VI_MF8 + 0U, // PseudoVRGATHER_VI_MF8_MASK + 0U, // PseudoVRGATHER_VV_M1_E16 + 0U, // PseudoVRGATHER_VV_M1_E16_MASK + 0U, // PseudoVRGATHER_VV_M1_E32 + 0U, // PseudoVRGATHER_VV_M1_E32_MASK + 0U, // PseudoVRGATHER_VV_M1_E64 + 0U, // PseudoVRGATHER_VV_M1_E64_MASK + 0U, // PseudoVRGATHER_VV_M1_E8 + 0U, // PseudoVRGATHER_VV_M1_E8_MASK + 0U, // PseudoVRGATHER_VV_M2_E16 + 0U, // PseudoVRGATHER_VV_M2_E16_MASK + 0U, // PseudoVRGATHER_VV_M2_E32 + 0U, // PseudoVRGATHER_VV_M2_E32_MASK + 0U, // PseudoVRGATHER_VV_M2_E64 + 0U, // PseudoVRGATHER_VV_M2_E64_MASK + 0U, // PseudoVRGATHER_VV_M2_E8 + 0U, // PseudoVRGATHER_VV_M2_E8_MASK + 0U, // PseudoVRGATHER_VV_M4_E16 + 0U, // PseudoVRGATHER_VV_M4_E16_MASK + 0U, // PseudoVRGATHER_VV_M4_E32 + 0U, // PseudoVRGATHER_VV_M4_E32_MASK + 0U, // PseudoVRGATHER_VV_M4_E64 + 0U, // PseudoVRGATHER_VV_M4_E64_MASK + 0U, // PseudoVRGATHER_VV_M4_E8 + 0U, // PseudoVRGATHER_VV_M4_E8_MASK + 0U, // PseudoVRGATHER_VV_M8_E16 + 0U, // PseudoVRGATHER_VV_M8_E16_MASK + 0U, // PseudoVRGATHER_VV_M8_E32 + 0U, // PseudoVRGATHER_VV_M8_E32_MASK + 0U, // PseudoVRGATHER_VV_M8_E64 + 0U, // PseudoVRGATHER_VV_M8_E64_MASK + 0U, // PseudoVRGATHER_VV_M8_E8 + 0U, // PseudoVRGATHER_VV_M8_E8_MASK + 0U, // PseudoVRGATHER_VV_MF2_E16 + 0U, // PseudoVRGATHER_VV_MF2_E16_MASK + 0U, // PseudoVRGATHER_VV_MF2_E32 + 0U, // PseudoVRGATHER_VV_MF2_E32_MASK + 0U, // PseudoVRGATHER_VV_MF2_E8 + 0U, // PseudoVRGATHER_VV_MF2_E8_MASK + 0U, // PseudoVRGATHER_VV_MF4_E16 + 0U, // PseudoVRGATHER_VV_MF4_E16_MASK + 0U, // PseudoVRGATHER_VV_MF4_E8 + 0U, // PseudoVRGATHER_VV_MF4_E8_MASK + 0U, // PseudoVRGATHER_VV_MF8_E8 + 0U, // PseudoVRGATHER_VV_MF8_E8_MASK + 0U, // PseudoVRGATHER_VX_M1 + 0U, // PseudoVRGATHER_VX_M1_MASK + 0U, // PseudoVRGATHER_VX_M2 + 0U, // PseudoVRGATHER_VX_M2_MASK + 0U, // PseudoVRGATHER_VX_M4 + 0U, // PseudoVRGATHER_VX_M4_MASK + 0U, // PseudoVRGATHER_VX_M8 + 0U, // PseudoVRGATHER_VX_M8_MASK + 0U, // PseudoVRGATHER_VX_MF2 + 0U, // PseudoVRGATHER_VX_MF2_MASK + 0U, // PseudoVRGATHER_VX_MF4 + 0U, // PseudoVRGATHER_VX_MF4_MASK + 0U, // PseudoVRGATHER_VX_MF8 + 0U, // PseudoVRGATHER_VX_MF8_MASK + 0U, // PseudoVROL_VV_M1 + 0U, // PseudoVROL_VV_M1_MASK + 0U, // PseudoVROL_VV_M2 + 0U, // PseudoVROL_VV_M2_MASK + 0U, // PseudoVROL_VV_M4 + 0U, // PseudoVROL_VV_M4_MASK + 0U, // PseudoVROL_VV_M8 + 0U, // PseudoVROL_VV_M8_MASK + 0U, // PseudoVROL_VV_MF2 + 0U, // PseudoVROL_VV_MF2_MASK + 0U, // PseudoVROL_VV_MF4 + 0U, // PseudoVROL_VV_MF4_MASK + 0U, // PseudoVROL_VV_MF8 + 0U, // PseudoVROL_VV_MF8_MASK + 0U, // PseudoVROL_VX_M1 + 0U, // PseudoVROL_VX_M1_MASK + 0U, // PseudoVROL_VX_M2 + 0U, // PseudoVROL_VX_M2_MASK + 0U, // PseudoVROL_VX_M4 + 0U, // PseudoVROL_VX_M4_MASK + 0U, // PseudoVROL_VX_M8 + 0U, // PseudoVROL_VX_M8_MASK + 0U, // PseudoVROL_VX_MF2 + 0U, // PseudoVROL_VX_MF2_MASK + 0U, // PseudoVROL_VX_MF4 + 0U, // PseudoVROL_VX_MF4_MASK + 0U, // PseudoVROL_VX_MF8 + 0U, // PseudoVROL_VX_MF8_MASK + 0U, // PseudoVROR_VI_M1 + 0U, // PseudoVROR_VI_M1_MASK + 0U, // PseudoVROR_VI_M2 + 0U, // PseudoVROR_VI_M2_MASK + 0U, // PseudoVROR_VI_M4 + 0U, // PseudoVROR_VI_M4_MASK + 0U, // PseudoVROR_VI_M8 + 0U, // PseudoVROR_VI_M8_MASK + 0U, // PseudoVROR_VI_MF2 + 0U, // PseudoVROR_VI_MF2_MASK + 0U, // PseudoVROR_VI_MF4 + 0U, // PseudoVROR_VI_MF4_MASK + 0U, // PseudoVROR_VI_MF8 + 0U, // PseudoVROR_VI_MF8_MASK + 0U, // PseudoVROR_VV_M1 + 0U, // PseudoVROR_VV_M1_MASK + 0U, // PseudoVROR_VV_M2 + 0U, // PseudoVROR_VV_M2_MASK + 0U, // PseudoVROR_VV_M4 + 0U, // PseudoVROR_VV_M4_MASK + 0U, // PseudoVROR_VV_M8 + 0U, // PseudoVROR_VV_M8_MASK + 0U, // PseudoVROR_VV_MF2 + 0U, // PseudoVROR_VV_MF2_MASK + 0U, // PseudoVROR_VV_MF4 + 0U, // PseudoVROR_VV_MF4_MASK + 0U, // PseudoVROR_VV_MF8 + 0U, // PseudoVROR_VV_MF8_MASK + 0U, // PseudoVROR_VX_M1 + 0U, // PseudoVROR_VX_M1_MASK + 0U, // PseudoVROR_VX_M2 + 0U, // PseudoVROR_VX_M2_MASK + 0U, // PseudoVROR_VX_M4 + 0U, // PseudoVROR_VX_M4_MASK + 0U, // PseudoVROR_VX_M8 + 0U, // PseudoVROR_VX_M8_MASK + 0U, // PseudoVROR_VX_MF2 + 0U, // PseudoVROR_VX_MF2_MASK + 0U, // PseudoVROR_VX_MF4 + 0U, // PseudoVROR_VX_MF4_MASK + 0U, // PseudoVROR_VX_MF8 + 0U, // PseudoVROR_VX_MF8_MASK + 0U, // PseudoVRSUB_VI_M1 + 0U, // PseudoVRSUB_VI_M1_MASK + 0U, // PseudoVRSUB_VI_M2 + 0U, // PseudoVRSUB_VI_M2_MASK + 0U, // PseudoVRSUB_VI_M4 + 0U, // PseudoVRSUB_VI_M4_MASK + 0U, // PseudoVRSUB_VI_M8 + 0U, // PseudoVRSUB_VI_M8_MASK + 0U, // PseudoVRSUB_VI_MF2 + 0U, // PseudoVRSUB_VI_MF2_MASK + 0U, // PseudoVRSUB_VI_MF4 + 0U, // PseudoVRSUB_VI_MF4_MASK + 0U, // PseudoVRSUB_VI_MF8 + 0U, // PseudoVRSUB_VI_MF8_MASK + 0U, // PseudoVRSUB_VX_M1 + 0U, // PseudoVRSUB_VX_M1_MASK + 0U, // PseudoVRSUB_VX_M2 + 0U, // PseudoVRSUB_VX_M2_MASK + 0U, // PseudoVRSUB_VX_M4 + 0U, // PseudoVRSUB_VX_M4_MASK + 0U, // PseudoVRSUB_VX_M8 + 0U, // PseudoVRSUB_VX_M8_MASK + 0U, // PseudoVRSUB_VX_MF2 + 0U, // PseudoVRSUB_VX_MF2_MASK + 0U, // PseudoVRSUB_VX_MF4 + 0U, // PseudoVRSUB_VX_MF4_MASK + 0U, // PseudoVRSUB_VX_MF8 + 0U, // PseudoVRSUB_VX_MF8_MASK + 0U, // PseudoVSADDU_VI_M1 + 0U, // PseudoVSADDU_VI_M1_MASK + 0U, // PseudoVSADDU_VI_M2 + 0U, // PseudoVSADDU_VI_M2_MASK + 0U, // PseudoVSADDU_VI_M4 + 0U, // PseudoVSADDU_VI_M4_MASK + 0U, // PseudoVSADDU_VI_M8 + 0U, // PseudoVSADDU_VI_M8_MASK + 0U, // PseudoVSADDU_VI_MF2 + 0U, // PseudoVSADDU_VI_MF2_MASK + 0U, // PseudoVSADDU_VI_MF4 + 0U, // PseudoVSADDU_VI_MF4_MASK + 0U, // PseudoVSADDU_VI_MF8 + 0U, // PseudoVSADDU_VI_MF8_MASK + 0U, // PseudoVSADDU_VV_M1 + 0U, // PseudoVSADDU_VV_M1_MASK + 0U, // PseudoVSADDU_VV_M2 + 0U, // PseudoVSADDU_VV_M2_MASK + 0U, // PseudoVSADDU_VV_M4 + 0U, // PseudoVSADDU_VV_M4_MASK + 0U, // PseudoVSADDU_VV_M8 + 0U, // PseudoVSADDU_VV_M8_MASK + 0U, // PseudoVSADDU_VV_MF2 + 0U, // PseudoVSADDU_VV_MF2_MASK + 0U, // PseudoVSADDU_VV_MF4 + 0U, // PseudoVSADDU_VV_MF4_MASK + 0U, // PseudoVSADDU_VV_MF8 + 0U, // PseudoVSADDU_VV_MF8_MASK + 0U, // PseudoVSADDU_VX_M1 + 0U, // PseudoVSADDU_VX_M1_MASK + 0U, // PseudoVSADDU_VX_M2 + 0U, // PseudoVSADDU_VX_M2_MASK + 0U, // PseudoVSADDU_VX_M4 + 0U, // PseudoVSADDU_VX_M4_MASK + 0U, // PseudoVSADDU_VX_M8 + 0U, // PseudoVSADDU_VX_M8_MASK + 0U, // PseudoVSADDU_VX_MF2 + 0U, // PseudoVSADDU_VX_MF2_MASK + 0U, // PseudoVSADDU_VX_MF4 + 0U, // PseudoVSADDU_VX_MF4_MASK + 0U, // PseudoVSADDU_VX_MF8 + 0U, // PseudoVSADDU_VX_MF8_MASK + 0U, // PseudoVSADD_VI_M1 + 0U, // PseudoVSADD_VI_M1_MASK + 0U, // PseudoVSADD_VI_M2 + 0U, // PseudoVSADD_VI_M2_MASK + 0U, // PseudoVSADD_VI_M4 + 0U, // PseudoVSADD_VI_M4_MASK + 0U, // PseudoVSADD_VI_M8 + 0U, // PseudoVSADD_VI_M8_MASK + 0U, // PseudoVSADD_VI_MF2 + 0U, // PseudoVSADD_VI_MF2_MASK + 0U, // PseudoVSADD_VI_MF4 + 0U, // PseudoVSADD_VI_MF4_MASK + 0U, // PseudoVSADD_VI_MF8 + 0U, // PseudoVSADD_VI_MF8_MASK + 0U, // PseudoVSADD_VV_M1 + 0U, // PseudoVSADD_VV_M1_MASK + 0U, // PseudoVSADD_VV_M2 + 0U, // PseudoVSADD_VV_M2_MASK + 0U, // PseudoVSADD_VV_M4 + 0U, // PseudoVSADD_VV_M4_MASK + 0U, // PseudoVSADD_VV_M8 + 0U, // PseudoVSADD_VV_M8_MASK + 0U, // PseudoVSADD_VV_MF2 + 0U, // PseudoVSADD_VV_MF2_MASK + 0U, // PseudoVSADD_VV_MF4 + 0U, // PseudoVSADD_VV_MF4_MASK + 0U, // PseudoVSADD_VV_MF8 + 0U, // PseudoVSADD_VV_MF8_MASK + 0U, // PseudoVSADD_VX_M1 + 0U, // PseudoVSADD_VX_M1_MASK + 0U, // PseudoVSADD_VX_M2 + 0U, // PseudoVSADD_VX_M2_MASK + 0U, // PseudoVSADD_VX_M4 + 0U, // PseudoVSADD_VX_M4_MASK + 0U, // PseudoVSADD_VX_M8 + 0U, // PseudoVSADD_VX_M8_MASK + 0U, // PseudoVSADD_VX_MF2 + 0U, // PseudoVSADD_VX_MF2_MASK + 0U, // PseudoVSADD_VX_MF4 + 0U, // PseudoVSADD_VX_MF4_MASK + 0U, // PseudoVSADD_VX_MF8 + 0U, // PseudoVSADD_VX_MF8_MASK + 0U, // PseudoVSBC_VVM_M1 + 0U, // PseudoVSBC_VVM_M2 + 0U, // PseudoVSBC_VVM_M4 + 0U, // PseudoVSBC_VVM_M8 + 0U, // PseudoVSBC_VVM_MF2 + 0U, // PseudoVSBC_VVM_MF4 + 0U, // PseudoVSBC_VVM_MF8 + 0U, // PseudoVSBC_VXM_M1 + 0U, // PseudoVSBC_VXM_M2 + 0U, // PseudoVSBC_VXM_M4 + 0U, // PseudoVSBC_VXM_M8 + 0U, // PseudoVSBC_VXM_MF2 + 0U, // PseudoVSBC_VXM_MF4 + 0U, // PseudoVSBC_VXM_MF8 + 0U, // PseudoVSE16_V_M1 + 0U, // PseudoVSE16_V_M1_MASK + 0U, // PseudoVSE16_V_M2 + 0U, // PseudoVSE16_V_M2_MASK + 0U, // PseudoVSE16_V_M4 + 0U, // PseudoVSE16_V_M4_MASK + 0U, // PseudoVSE16_V_M8 + 0U, // PseudoVSE16_V_M8_MASK + 0U, // PseudoVSE16_V_MF2 + 0U, // PseudoVSE16_V_MF2_MASK + 0U, // PseudoVSE16_V_MF4 + 0U, // PseudoVSE16_V_MF4_MASK + 0U, // PseudoVSE32_V_M1 + 0U, // PseudoVSE32_V_M1_MASK + 0U, // PseudoVSE32_V_M2 + 0U, // PseudoVSE32_V_M2_MASK + 0U, // PseudoVSE32_V_M4 + 0U, // PseudoVSE32_V_M4_MASK + 0U, // PseudoVSE32_V_M8 + 0U, // PseudoVSE32_V_M8_MASK + 0U, // PseudoVSE32_V_MF2 + 0U, // PseudoVSE32_V_MF2_MASK + 0U, // PseudoVSE64_V_M1 + 0U, // PseudoVSE64_V_M1_MASK + 0U, // PseudoVSE64_V_M2 + 0U, // PseudoVSE64_V_M2_MASK + 0U, // PseudoVSE64_V_M4 + 0U, // PseudoVSE64_V_M4_MASK + 0U, // PseudoVSE64_V_M8 + 0U, // PseudoVSE64_V_M8_MASK + 0U, // PseudoVSE8_V_M1 + 0U, // PseudoVSE8_V_M1_MASK + 0U, // PseudoVSE8_V_M2 + 0U, // PseudoVSE8_V_M2_MASK + 0U, // PseudoVSE8_V_M4 + 0U, // PseudoVSE8_V_M4_MASK + 0U, // PseudoVSE8_V_M8 + 0U, // PseudoVSE8_V_M8_MASK + 0U, // PseudoVSE8_V_MF2 + 0U, // PseudoVSE8_V_MF2_MASK + 0U, // PseudoVSE8_V_MF4 + 0U, // PseudoVSE8_V_MF4_MASK + 0U, // PseudoVSE8_V_MF8 + 0U, // PseudoVSE8_V_MF8_MASK + 0U, // PseudoVSETIVLI + 0U, // PseudoVSETVLI + 0U, // PseudoVSETVLIX0 + 0U, // PseudoVSEXT_VF2_M1 + 0U, // PseudoVSEXT_VF2_M1_MASK + 0U, // PseudoVSEXT_VF2_M2 + 0U, // PseudoVSEXT_VF2_M2_MASK + 0U, // PseudoVSEXT_VF2_M4 + 0U, // PseudoVSEXT_VF2_M4_MASK + 0U, // PseudoVSEXT_VF2_M8 + 0U, // PseudoVSEXT_VF2_M8_MASK + 0U, // PseudoVSEXT_VF2_MF2 + 0U, // PseudoVSEXT_VF2_MF2_MASK + 0U, // PseudoVSEXT_VF2_MF4 + 0U, // PseudoVSEXT_VF2_MF4_MASK + 0U, // PseudoVSEXT_VF4_M1 + 0U, // PseudoVSEXT_VF4_M1_MASK + 0U, // PseudoVSEXT_VF4_M2 + 0U, // PseudoVSEXT_VF4_M2_MASK + 0U, // PseudoVSEXT_VF4_M4 + 0U, // PseudoVSEXT_VF4_M4_MASK + 0U, // PseudoVSEXT_VF4_M8 + 0U, // PseudoVSEXT_VF4_M8_MASK + 0U, // PseudoVSEXT_VF4_MF2 + 0U, // PseudoVSEXT_VF4_MF2_MASK + 0U, // PseudoVSEXT_VF8_M1 + 0U, // PseudoVSEXT_VF8_M1_MASK + 0U, // PseudoVSEXT_VF8_M2 + 0U, // PseudoVSEXT_VF8_M2_MASK + 0U, // PseudoVSEXT_VF8_M4 + 0U, // PseudoVSEXT_VF8_M4_MASK + 0U, // PseudoVSEXT_VF8_M8 + 0U, // PseudoVSEXT_VF8_M8_MASK + 0U, // PseudoVSHA2CH_VV_M1 + 0U, // PseudoVSHA2CH_VV_M2 + 0U, // PseudoVSHA2CH_VV_M4 + 0U, // PseudoVSHA2CH_VV_M8 + 0U, // PseudoVSHA2CH_VV_MF2 + 0U, // PseudoVSHA2CL_VV_M1 + 0U, // PseudoVSHA2CL_VV_M2 + 0U, // PseudoVSHA2CL_VV_M4 + 0U, // PseudoVSHA2CL_VV_M8 + 0U, // PseudoVSHA2CL_VV_MF2 + 0U, // PseudoVSHA2MS_VV_M1 + 0U, // PseudoVSHA2MS_VV_M2 + 0U, // PseudoVSHA2MS_VV_M4 + 0U, // PseudoVSHA2MS_VV_M8 + 0U, // PseudoVSHA2MS_VV_MF2 + 0U, // PseudoVSLIDE1DOWN_VX_M1 + 0U, // PseudoVSLIDE1DOWN_VX_M1_MASK + 0U, // PseudoVSLIDE1DOWN_VX_M2 + 0U, // PseudoVSLIDE1DOWN_VX_M2_MASK + 0U, // PseudoVSLIDE1DOWN_VX_M4 + 0U, // PseudoVSLIDE1DOWN_VX_M4_MASK + 0U, // PseudoVSLIDE1DOWN_VX_M8 + 0U, // PseudoVSLIDE1DOWN_VX_M8_MASK + 0U, // PseudoVSLIDE1DOWN_VX_MF2 + 0U, // PseudoVSLIDE1DOWN_VX_MF2_MASK + 0U, // PseudoVSLIDE1DOWN_VX_MF4 + 0U, // PseudoVSLIDE1DOWN_VX_MF4_MASK + 0U, // PseudoVSLIDE1DOWN_VX_MF8 + 0U, // PseudoVSLIDE1DOWN_VX_MF8_MASK + 0U, // PseudoVSLIDE1UP_VX_M1 + 0U, // PseudoVSLIDE1UP_VX_M1_MASK + 0U, // PseudoVSLIDE1UP_VX_M2 + 0U, // PseudoVSLIDE1UP_VX_M2_MASK + 0U, // PseudoVSLIDE1UP_VX_M4 + 0U, // PseudoVSLIDE1UP_VX_M4_MASK + 0U, // PseudoVSLIDE1UP_VX_M8 + 0U, // PseudoVSLIDE1UP_VX_M8_MASK + 0U, // PseudoVSLIDE1UP_VX_MF2 + 0U, // PseudoVSLIDE1UP_VX_MF2_MASK + 0U, // PseudoVSLIDE1UP_VX_MF4 + 0U, // PseudoVSLIDE1UP_VX_MF4_MASK + 0U, // PseudoVSLIDE1UP_VX_MF8 + 0U, // PseudoVSLIDE1UP_VX_MF8_MASK + 0U, // PseudoVSLIDEDOWN_VI_M1 + 0U, // PseudoVSLIDEDOWN_VI_M1_MASK + 0U, // PseudoVSLIDEDOWN_VI_M2 + 0U, // PseudoVSLIDEDOWN_VI_M2_MASK + 0U, // PseudoVSLIDEDOWN_VI_M4 + 0U, // PseudoVSLIDEDOWN_VI_M4_MASK + 0U, // PseudoVSLIDEDOWN_VI_M8 + 0U, // PseudoVSLIDEDOWN_VI_M8_MASK + 0U, // PseudoVSLIDEDOWN_VI_MF2 + 0U, // PseudoVSLIDEDOWN_VI_MF2_MASK + 0U, // PseudoVSLIDEDOWN_VI_MF4 + 0U, // PseudoVSLIDEDOWN_VI_MF4_MASK + 0U, // PseudoVSLIDEDOWN_VI_MF8 + 0U, // PseudoVSLIDEDOWN_VI_MF8_MASK + 0U, // PseudoVSLIDEDOWN_VX_M1 + 0U, // PseudoVSLIDEDOWN_VX_M1_MASK + 0U, // PseudoVSLIDEDOWN_VX_M2 + 0U, // PseudoVSLIDEDOWN_VX_M2_MASK + 0U, // PseudoVSLIDEDOWN_VX_M4 + 0U, // PseudoVSLIDEDOWN_VX_M4_MASK + 0U, // PseudoVSLIDEDOWN_VX_M8 + 0U, // PseudoVSLIDEDOWN_VX_M8_MASK + 0U, // PseudoVSLIDEDOWN_VX_MF2 + 0U, // PseudoVSLIDEDOWN_VX_MF2_MASK + 0U, // PseudoVSLIDEDOWN_VX_MF4 + 0U, // PseudoVSLIDEDOWN_VX_MF4_MASK + 0U, // PseudoVSLIDEDOWN_VX_MF8 + 0U, // PseudoVSLIDEDOWN_VX_MF8_MASK + 0U, // PseudoVSLIDEUP_VI_M1 + 0U, // PseudoVSLIDEUP_VI_M1_MASK + 0U, // PseudoVSLIDEUP_VI_M2 + 0U, // PseudoVSLIDEUP_VI_M2_MASK + 0U, // PseudoVSLIDEUP_VI_M4 + 0U, // PseudoVSLIDEUP_VI_M4_MASK + 0U, // PseudoVSLIDEUP_VI_M8 + 0U, // PseudoVSLIDEUP_VI_M8_MASK + 0U, // PseudoVSLIDEUP_VI_MF2 + 0U, // PseudoVSLIDEUP_VI_MF2_MASK + 0U, // PseudoVSLIDEUP_VI_MF4 + 0U, // PseudoVSLIDEUP_VI_MF4_MASK + 0U, // PseudoVSLIDEUP_VI_MF8 + 0U, // PseudoVSLIDEUP_VI_MF8_MASK + 0U, // PseudoVSLIDEUP_VX_M1 + 0U, // PseudoVSLIDEUP_VX_M1_MASK + 0U, // PseudoVSLIDEUP_VX_M2 + 0U, // PseudoVSLIDEUP_VX_M2_MASK + 0U, // PseudoVSLIDEUP_VX_M4 + 0U, // PseudoVSLIDEUP_VX_M4_MASK + 0U, // PseudoVSLIDEUP_VX_M8 + 0U, // PseudoVSLIDEUP_VX_M8_MASK + 0U, // PseudoVSLIDEUP_VX_MF2 + 0U, // PseudoVSLIDEUP_VX_MF2_MASK + 0U, // PseudoVSLIDEUP_VX_MF4 + 0U, // PseudoVSLIDEUP_VX_MF4_MASK + 0U, // PseudoVSLIDEUP_VX_MF8 + 0U, // PseudoVSLIDEUP_VX_MF8_MASK + 0U, // PseudoVSLL_VI_M1 + 0U, // PseudoVSLL_VI_M1_MASK + 0U, // PseudoVSLL_VI_M2 + 0U, // PseudoVSLL_VI_M2_MASK + 0U, // PseudoVSLL_VI_M4 + 0U, // PseudoVSLL_VI_M4_MASK + 0U, // PseudoVSLL_VI_M8 + 0U, // PseudoVSLL_VI_M8_MASK + 0U, // PseudoVSLL_VI_MF2 + 0U, // PseudoVSLL_VI_MF2_MASK + 0U, // PseudoVSLL_VI_MF4 + 0U, // PseudoVSLL_VI_MF4_MASK + 0U, // PseudoVSLL_VI_MF8 + 0U, // PseudoVSLL_VI_MF8_MASK + 0U, // PseudoVSLL_VV_M1 + 0U, // PseudoVSLL_VV_M1_MASK + 0U, // PseudoVSLL_VV_M2 + 0U, // PseudoVSLL_VV_M2_MASK + 0U, // PseudoVSLL_VV_M4 + 0U, // PseudoVSLL_VV_M4_MASK + 0U, // PseudoVSLL_VV_M8 + 0U, // PseudoVSLL_VV_M8_MASK + 0U, // PseudoVSLL_VV_MF2 + 0U, // PseudoVSLL_VV_MF2_MASK + 0U, // PseudoVSLL_VV_MF4 + 0U, // PseudoVSLL_VV_MF4_MASK + 0U, // PseudoVSLL_VV_MF8 + 0U, // PseudoVSLL_VV_MF8_MASK + 0U, // PseudoVSLL_VX_M1 + 0U, // PseudoVSLL_VX_M1_MASK + 0U, // PseudoVSLL_VX_M2 + 0U, // PseudoVSLL_VX_M2_MASK + 0U, // PseudoVSLL_VX_M4 + 0U, // PseudoVSLL_VX_M4_MASK + 0U, // PseudoVSLL_VX_M8 + 0U, // PseudoVSLL_VX_M8_MASK + 0U, // PseudoVSLL_VX_MF2 + 0U, // PseudoVSLL_VX_MF2_MASK + 0U, // PseudoVSLL_VX_MF4 + 0U, // PseudoVSLL_VX_MF4_MASK + 0U, // PseudoVSLL_VX_MF8 + 0U, // PseudoVSLL_VX_MF8_MASK + 0U, // PseudoVSM3C_VI_M1 + 0U, // PseudoVSM3C_VI_M2 + 0U, // PseudoVSM3C_VI_M4 + 0U, // PseudoVSM3C_VI_M8 + 0U, // PseudoVSM3C_VI_MF2 + 0U, // PseudoVSM3ME_VV_M1 + 0U, // PseudoVSM3ME_VV_M2 + 0U, // PseudoVSM3ME_VV_M4 + 0U, // PseudoVSM3ME_VV_M8 + 0U, // PseudoVSM3ME_VV_MF2 + 0U, // PseudoVSM4K_VI_M1 + 0U, // PseudoVSM4K_VI_M2 + 0U, // PseudoVSM4K_VI_M4 + 0U, // PseudoVSM4K_VI_M8 + 0U, // PseudoVSM4K_VI_MF2 + 0U, // PseudoVSM4R_VS_M1_M1 + 0U, // PseudoVSM4R_VS_M1_MF2 + 0U, // PseudoVSM4R_VS_M1_MF4 + 0U, // PseudoVSM4R_VS_M1_MF8 + 0U, // PseudoVSM4R_VS_M2_M1 + 0U, // PseudoVSM4R_VS_M2_M2 + 0U, // PseudoVSM4R_VS_M2_MF2 + 0U, // PseudoVSM4R_VS_M2_MF4 + 0U, // PseudoVSM4R_VS_M2_MF8 + 0U, // PseudoVSM4R_VS_M4_M1 + 0U, // PseudoVSM4R_VS_M4_M2 + 0U, // PseudoVSM4R_VS_M4_M4 + 0U, // PseudoVSM4R_VS_M4_MF2 + 0U, // PseudoVSM4R_VS_M4_MF4 + 0U, // PseudoVSM4R_VS_M4_MF8 + 0U, // PseudoVSM4R_VS_M8_M1 + 0U, // PseudoVSM4R_VS_M8_M2 + 0U, // PseudoVSM4R_VS_M8_M4 + 0U, // PseudoVSM4R_VS_M8_MF2 + 0U, // PseudoVSM4R_VS_M8_MF4 + 0U, // PseudoVSM4R_VS_M8_MF8 + 0U, // PseudoVSM4R_VS_MF2_MF2 + 0U, // PseudoVSM4R_VS_MF2_MF4 + 0U, // PseudoVSM4R_VS_MF2_MF8 + 0U, // PseudoVSM4R_VV_M1 + 0U, // PseudoVSM4R_VV_M2 + 0U, // PseudoVSM4R_VV_M4 + 0U, // PseudoVSM4R_VV_M8 + 0U, // PseudoVSM4R_VV_MF2 + 0U, // PseudoVSMUL_VV_M1 + 0U, // PseudoVSMUL_VV_M1_MASK + 0U, // PseudoVSMUL_VV_M2 + 0U, // PseudoVSMUL_VV_M2_MASK + 0U, // PseudoVSMUL_VV_M4 + 0U, // PseudoVSMUL_VV_M4_MASK + 0U, // PseudoVSMUL_VV_M8 + 0U, // PseudoVSMUL_VV_M8_MASK + 0U, // PseudoVSMUL_VV_MF2 + 0U, // PseudoVSMUL_VV_MF2_MASK + 0U, // PseudoVSMUL_VV_MF4 + 0U, // PseudoVSMUL_VV_MF4_MASK + 0U, // PseudoVSMUL_VV_MF8 + 0U, // PseudoVSMUL_VV_MF8_MASK + 0U, // PseudoVSMUL_VX_M1 + 0U, // PseudoVSMUL_VX_M1_MASK + 0U, // PseudoVSMUL_VX_M2 + 0U, // PseudoVSMUL_VX_M2_MASK + 0U, // PseudoVSMUL_VX_M4 + 0U, // PseudoVSMUL_VX_M4_MASK + 0U, // PseudoVSMUL_VX_M8 + 0U, // PseudoVSMUL_VX_M8_MASK + 0U, // PseudoVSMUL_VX_MF2 + 0U, // PseudoVSMUL_VX_MF2_MASK + 0U, // PseudoVSMUL_VX_MF4 + 0U, // PseudoVSMUL_VX_MF4_MASK + 0U, // PseudoVSMUL_VX_MF8 + 0U, // PseudoVSMUL_VX_MF8_MASK + 0U, // PseudoVSM_V_B1 + 0U, // PseudoVSM_V_B16 + 0U, // PseudoVSM_V_B2 + 0U, // PseudoVSM_V_B32 + 0U, // PseudoVSM_V_B4 + 0U, // PseudoVSM_V_B64 + 0U, // PseudoVSM_V_B8 + 0U, // PseudoVSOXEI16_V_M1_M1 + 0U, // PseudoVSOXEI16_V_M1_M1_MASK + 0U, // PseudoVSOXEI16_V_M1_M2 + 0U, // PseudoVSOXEI16_V_M1_M2_MASK + 0U, // PseudoVSOXEI16_V_M1_M4 + 0U, // PseudoVSOXEI16_V_M1_M4_MASK + 0U, // PseudoVSOXEI16_V_M1_MF2 + 0U, // PseudoVSOXEI16_V_M1_MF2_MASK + 0U, // PseudoVSOXEI16_V_M2_M1 + 0U, // PseudoVSOXEI16_V_M2_M1_MASK + 0U, // PseudoVSOXEI16_V_M2_M2 + 0U, // PseudoVSOXEI16_V_M2_M2_MASK + 0U, // PseudoVSOXEI16_V_M2_M4 + 0U, // PseudoVSOXEI16_V_M2_M4_MASK + 0U, // PseudoVSOXEI16_V_M2_M8 + 0U, // PseudoVSOXEI16_V_M2_M8_MASK + 0U, // PseudoVSOXEI16_V_M4_M2 + 0U, // PseudoVSOXEI16_V_M4_M2_MASK + 0U, // PseudoVSOXEI16_V_M4_M4 + 0U, // PseudoVSOXEI16_V_M4_M4_MASK + 0U, // PseudoVSOXEI16_V_M4_M8 + 0U, // PseudoVSOXEI16_V_M4_M8_MASK + 0U, // PseudoVSOXEI16_V_M8_M4 + 0U, // PseudoVSOXEI16_V_M8_M4_MASK + 0U, // PseudoVSOXEI16_V_M8_M8 + 0U, // PseudoVSOXEI16_V_M8_M8_MASK + 0U, // PseudoVSOXEI16_V_MF2_M1 + 0U, // PseudoVSOXEI16_V_MF2_M1_MASK + 0U, // PseudoVSOXEI16_V_MF2_M2 + 0U, // PseudoVSOXEI16_V_MF2_M2_MASK + 0U, // PseudoVSOXEI16_V_MF2_MF2 + 0U, // PseudoVSOXEI16_V_MF2_MF2_MASK + 0U, // PseudoVSOXEI16_V_MF2_MF4 + 0U, // PseudoVSOXEI16_V_MF2_MF4_MASK + 0U, // PseudoVSOXEI16_V_MF4_M1 + 0U, // PseudoVSOXEI16_V_MF4_M1_MASK + 0U, // PseudoVSOXEI16_V_MF4_MF2 + 0U, // PseudoVSOXEI16_V_MF4_MF2_MASK + 0U, // PseudoVSOXEI16_V_MF4_MF4 + 0U, // PseudoVSOXEI16_V_MF4_MF4_MASK + 0U, // PseudoVSOXEI16_V_MF4_MF8 + 0U, // PseudoVSOXEI16_V_MF4_MF8_MASK + 0U, // PseudoVSOXEI32_V_M1_M1 + 0U, // PseudoVSOXEI32_V_M1_M1_MASK + 0U, // PseudoVSOXEI32_V_M1_M2 + 0U, // PseudoVSOXEI32_V_M1_M2_MASK + 0U, // PseudoVSOXEI32_V_M1_MF2 + 0U, // PseudoVSOXEI32_V_M1_MF2_MASK + 0U, // PseudoVSOXEI32_V_M1_MF4 + 0U, // PseudoVSOXEI32_V_M1_MF4_MASK + 0U, // PseudoVSOXEI32_V_M2_M1 + 0U, // PseudoVSOXEI32_V_M2_M1_MASK + 0U, // PseudoVSOXEI32_V_M2_M2 + 0U, // PseudoVSOXEI32_V_M2_M2_MASK + 0U, // PseudoVSOXEI32_V_M2_M4 + 0U, // PseudoVSOXEI32_V_M2_M4_MASK + 0U, // PseudoVSOXEI32_V_M2_MF2 + 0U, // PseudoVSOXEI32_V_M2_MF2_MASK + 0U, // PseudoVSOXEI32_V_M4_M1 + 0U, // PseudoVSOXEI32_V_M4_M1_MASK + 0U, // PseudoVSOXEI32_V_M4_M2 + 0U, // PseudoVSOXEI32_V_M4_M2_MASK + 0U, // PseudoVSOXEI32_V_M4_M4 + 0U, // PseudoVSOXEI32_V_M4_M4_MASK + 0U, // PseudoVSOXEI32_V_M4_M8 + 0U, // PseudoVSOXEI32_V_M4_M8_MASK + 0U, // PseudoVSOXEI32_V_M8_M2 + 0U, // PseudoVSOXEI32_V_M8_M2_MASK + 0U, // PseudoVSOXEI32_V_M8_M4 + 0U, // PseudoVSOXEI32_V_M8_M4_MASK + 0U, // PseudoVSOXEI32_V_M8_M8 + 0U, // PseudoVSOXEI32_V_M8_M8_MASK + 0U, // PseudoVSOXEI32_V_MF2_M1 + 0U, // PseudoVSOXEI32_V_MF2_M1_MASK + 0U, // PseudoVSOXEI32_V_MF2_MF2 + 0U, // PseudoVSOXEI32_V_MF2_MF2_MASK + 0U, // PseudoVSOXEI32_V_MF2_MF4 + 0U, // PseudoVSOXEI32_V_MF2_MF4_MASK + 0U, // PseudoVSOXEI32_V_MF2_MF8 + 0U, // PseudoVSOXEI32_V_MF2_MF8_MASK + 0U, // PseudoVSOXEI64_V_M1_M1 + 0U, // PseudoVSOXEI64_V_M1_M1_MASK + 0U, // PseudoVSOXEI64_V_M1_MF2 + 0U, // PseudoVSOXEI64_V_M1_MF2_MASK + 0U, // PseudoVSOXEI64_V_M1_MF4 + 0U, // PseudoVSOXEI64_V_M1_MF4_MASK + 0U, // PseudoVSOXEI64_V_M1_MF8 + 0U, // PseudoVSOXEI64_V_M1_MF8_MASK + 0U, // PseudoVSOXEI64_V_M2_M1 + 0U, // PseudoVSOXEI64_V_M2_M1_MASK + 0U, // PseudoVSOXEI64_V_M2_M2 + 0U, // PseudoVSOXEI64_V_M2_M2_MASK + 0U, // PseudoVSOXEI64_V_M2_MF2 + 0U, // PseudoVSOXEI64_V_M2_MF2_MASK + 0U, // PseudoVSOXEI64_V_M2_MF4 + 0U, // PseudoVSOXEI64_V_M2_MF4_MASK + 0U, // PseudoVSOXEI64_V_M4_M1 + 0U, // PseudoVSOXEI64_V_M4_M1_MASK + 0U, // PseudoVSOXEI64_V_M4_M2 + 0U, // PseudoVSOXEI64_V_M4_M2_MASK + 0U, // PseudoVSOXEI64_V_M4_M4 + 0U, // PseudoVSOXEI64_V_M4_M4_MASK + 0U, // PseudoVSOXEI64_V_M4_MF2 + 0U, // PseudoVSOXEI64_V_M4_MF2_MASK + 0U, // PseudoVSOXEI64_V_M8_M1 + 0U, // PseudoVSOXEI64_V_M8_M1_MASK + 0U, // PseudoVSOXEI64_V_M8_M2 + 0U, // PseudoVSOXEI64_V_M8_M2_MASK + 0U, // PseudoVSOXEI64_V_M8_M4 + 0U, // PseudoVSOXEI64_V_M8_M4_MASK + 0U, // PseudoVSOXEI64_V_M8_M8 + 0U, // PseudoVSOXEI64_V_M8_M8_MASK + 0U, // PseudoVSOXEI8_V_M1_M1 + 0U, // PseudoVSOXEI8_V_M1_M1_MASK + 0U, // PseudoVSOXEI8_V_M1_M2 + 0U, // PseudoVSOXEI8_V_M1_M2_MASK + 0U, // PseudoVSOXEI8_V_M1_M4 + 0U, // PseudoVSOXEI8_V_M1_M4_MASK + 0U, // PseudoVSOXEI8_V_M1_M8 + 0U, // PseudoVSOXEI8_V_M1_M8_MASK + 0U, // PseudoVSOXEI8_V_M2_M2 + 0U, // PseudoVSOXEI8_V_M2_M2_MASK + 0U, // PseudoVSOXEI8_V_M2_M4 + 0U, // PseudoVSOXEI8_V_M2_M4_MASK + 0U, // PseudoVSOXEI8_V_M2_M8 + 0U, // PseudoVSOXEI8_V_M2_M8_MASK + 0U, // PseudoVSOXEI8_V_M4_M4 + 0U, // PseudoVSOXEI8_V_M4_M4_MASK + 0U, // PseudoVSOXEI8_V_M4_M8 + 0U, // PseudoVSOXEI8_V_M4_M8_MASK + 0U, // PseudoVSOXEI8_V_M8_M8 + 0U, // PseudoVSOXEI8_V_M8_M8_MASK + 0U, // PseudoVSOXEI8_V_MF2_M1 + 0U, // PseudoVSOXEI8_V_MF2_M1_MASK + 0U, // PseudoVSOXEI8_V_MF2_M2 + 0U, // PseudoVSOXEI8_V_MF2_M2_MASK + 0U, // PseudoVSOXEI8_V_MF2_M4 + 0U, // PseudoVSOXEI8_V_MF2_M4_MASK + 0U, // PseudoVSOXEI8_V_MF2_MF2 + 0U, // PseudoVSOXEI8_V_MF2_MF2_MASK + 0U, // PseudoVSOXEI8_V_MF4_M1 + 0U, // PseudoVSOXEI8_V_MF4_M1_MASK + 0U, // PseudoVSOXEI8_V_MF4_M2 + 0U, // PseudoVSOXEI8_V_MF4_M2_MASK + 0U, // PseudoVSOXEI8_V_MF4_MF2 + 0U, // PseudoVSOXEI8_V_MF4_MF2_MASK + 0U, // PseudoVSOXEI8_V_MF4_MF4 + 0U, // PseudoVSOXEI8_V_MF4_MF4_MASK + 0U, // PseudoVSOXEI8_V_MF8_M1 + 0U, // PseudoVSOXEI8_V_MF8_M1_MASK + 0U, // PseudoVSOXEI8_V_MF8_MF2 + 0U, // PseudoVSOXEI8_V_MF8_MF2_MASK + 0U, // PseudoVSOXEI8_V_MF8_MF4 + 0U, // PseudoVSOXEI8_V_MF8_MF4_MASK + 0U, // PseudoVSOXEI8_V_MF8_MF8 + 0U, // PseudoVSOXEI8_V_MF8_MF8_MASK + 0U, // PseudoVSOXSEG2EI16_V_M1_M1 + 0U, // PseudoVSOXSEG2EI16_V_M1_M1_MASK + 0U, // PseudoVSOXSEG2EI16_V_M1_M2 + 0U, // PseudoVSOXSEG2EI16_V_M1_M2_MASK + 0U, // PseudoVSOXSEG2EI16_V_M1_M4 + 0U, // PseudoVSOXSEG2EI16_V_M1_M4_MASK + 0U, // PseudoVSOXSEG2EI16_V_M1_MF2 + 0U, // PseudoVSOXSEG2EI16_V_M1_MF2_MASK + 0U, // PseudoVSOXSEG2EI16_V_M2_M1 + 0U, // PseudoVSOXSEG2EI16_V_M2_M1_MASK + 0U, // PseudoVSOXSEG2EI16_V_M2_M2 + 0U, // PseudoVSOXSEG2EI16_V_M2_M2_MASK + 0U, // PseudoVSOXSEG2EI16_V_M2_M4 + 0U, // PseudoVSOXSEG2EI16_V_M2_M4_MASK + 0U, // PseudoVSOXSEG2EI16_V_M4_M2 + 0U, // PseudoVSOXSEG2EI16_V_M4_M2_MASK + 0U, // PseudoVSOXSEG2EI16_V_M4_M4 + 0U, // PseudoVSOXSEG2EI16_V_M4_M4_MASK + 0U, // PseudoVSOXSEG2EI16_V_M8_M4 + 0U, // PseudoVSOXSEG2EI16_V_M8_M4_MASK + 0U, // PseudoVSOXSEG2EI16_V_MF2_M1 + 0U, // PseudoVSOXSEG2EI16_V_MF2_M1_MASK + 0U, // PseudoVSOXSEG2EI16_V_MF2_M2 + 0U, // PseudoVSOXSEG2EI16_V_MF2_M2_MASK + 0U, // PseudoVSOXSEG2EI16_V_MF2_MF2 + 0U, // PseudoVSOXSEG2EI16_V_MF2_MF2_MASK + 0U, // PseudoVSOXSEG2EI16_V_MF2_MF4 + 0U, // PseudoVSOXSEG2EI16_V_MF2_MF4_MASK + 0U, // PseudoVSOXSEG2EI16_V_MF4_M1 + 0U, // PseudoVSOXSEG2EI16_V_MF4_M1_MASK + 0U, // PseudoVSOXSEG2EI16_V_MF4_MF2 + 0U, // PseudoVSOXSEG2EI16_V_MF4_MF2_MASK + 0U, // PseudoVSOXSEG2EI16_V_MF4_MF4 + 0U, // PseudoVSOXSEG2EI16_V_MF4_MF4_MASK + 0U, // PseudoVSOXSEG2EI16_V_MF4_MF8 + 0U, // PseudoVSOXSEG2EI16_V_MF4_MF8_MASK + 0U, // PseudoVSOXSEG2EI32_V_M1_M1 + 0U, // PseudoVSOXSEG2EI32_V_M1_M1_MASK + 0U, // PseudoVSOXSEG2EI32_V_M1_M2 + 0U, // PseudoVSOXSEG2EI32_V_M1_M2_MASK + 0U, // PseudoVSOXSEG2EI32_V_M1_MF2 + 0U, // PseudoVSOXSEG2EI32_V_M1_MF2_MASK + 0U, // PseudoVSOXSEG2EI32_V_M1_MF4 + 0U, // PseudoVSOXSEG2EI32_V_M1_MF4_MASK + 0U, // PseudoVSOXSEG2EI32_V_M2_M1 + 0U, // PseudoVSOXSEG2EI32_V_M2_M1_MASK + 0U, // PseudoVSOXSEG2EI32_V_M2_M2 + 0U, // PseudoVSOXSEG2EI32_V_M2_M2_MASK + 0U, // PseudoVSOXSEG2EI32_V_M2_M4 + 0U, // PseudoVSOXSEG2EI32_V_M2_M4_MASK + 0U, // PseudoVSOXSEG2EI32_V_M2_MF2 + 0U, // PseudoVSOXSEG2EI32_V_M2_MF2_MASK + 0U, // PseudoVSOXSEG2EI32_V_M4_M1 + 0U, // PseudoVSOXSEG2EI32_V_M4_M1_MASK + 0U, // PseudoVSOXSEG2EI32_V_M4_M2 + 0U, // PseudoVSOXSEG2EI32_V_M4_M2_MASK + 0U, // PseudoVSOXSEG2EI32_V_M4_M4 + 0U, // PseudoVSOXSEG2EI32_V_M4_M4_MASK + 0U, // PseudoVSOXSEG2EI32_V_M8_M2 + 0U, // PseudoVSOXSEG2EI32_V_M8_M2_MASK + 0U, // PseudoVSOXSEG2EI32_V_M8_M4 + 0U, // PseudoVSOXSEG2EI32_V_M8_M4_MASK + 0U, // PseudoVSOXSEG2EI32_V_MF2_M1 + 0U, // PseudoVSOXSEG2EI32_V_MF2_M1_MASK + 0U, // PseudoVSOXSEG2EI32_V_MF2_MF2 + 0U, // PseudoVSOXSEG2EI32_V_MF2_MF2_MASK + 0U, // PseudoVSOXSEG2EI32_V_MF2_MF4 + 0U, // PseudoVSOXSEG2EI32_V_MF2_MF4_MASK + 0U, // PseudoVSOXSEG2EI32_V_MF2_MF8 + 0U, // PseudoVSOXSEG2EI32_V_MF2_MF8_MASK + 0U, // PseudoVSOXSEG2EI64_V_M1_M1 + 0U, // PseudoVSOXSEG2EI64_V_M1_M1_MASK + 0U, // PseudoVSOXSEG2EI64_V_M1_MF2 + 0U, // PseudoVSOXSEG2EI64_V_M1_MF2_MASK + 0U, // PseudoVSOXSEG2EI64_V_M1_MF4 + 0U, // PseudoVSOXSEG2EI64_V_M1_MF4_MASK + 0U, // PseudoVSOXSEG2EI64_V_M1_MF8 + 0U, // PseudoVSOXSEG2EI64_V_M1_MF8_MASK + 0U, // PseudoVSOXSEG2EI64_V_M2_M1 + 0U, // PseudoVSOXSEG2EI64_V_M2_M1_MASK + 0U, // PseudoVSOXSEG2EI64_V_M2_M2 + 0U, // PseudoVSOXSEG2EI64_V_M2_M2_MASK + 0U, // PseudoVSOXSEG2EI64_V_M2_MF2 + 0U, // PseudoVSOXSEG2EI64_V_M2_MF2_MASK + 0U, // PseudoVSOXSEG2EI64_V_M2_MF4 + 0U, // PseudoVSOXSEG2EI64_V_M2_MF4_MASK + 0U, // PseudoVSOXSEG2EI64_V_M4_M1 + 0U, // PseudoVSOXSEG2EI64_V_M4_M1_MASK + 0U, // PseudoVSOXSEG2EI64_V_M4_M2 + 0U, // PseudoVSOXSEG2EI64_V_M4_M2_MASK + 0U, // PseudoVSOXSEG2EI64_V_M4_M4 + 0U, // PseudoVSOXSEG2EI64_V_M4_M4_MASK + 0U, // PseudoVSOXSEG2EI64_V_M4_MF2 + 0U, // PseudoVSOXSEG2EI64_V_M4_MF2_MASK + 0U, // PseudoVSOXSEG2EI64_V_M8_M1 + 0U, // PseudoVSOXSEG2EI64_V_M8_M1_MASK + 0U, // PseudoVSOXSEG2EI64_V_M8_M2 + 0U, // PseudoVSOXSEG2EI64_V_M8_M2_MASK + 0U, // PseudoVSOXSEG2EI64_V_M8_M4 + 0U, // PseudoVSOXSEG2EI64_V_M8_M4_MASK + 0U, // PseudoVSOXSEG2EI8_V_M1_M1 + 0U, // PseudoVSOXSEG2EI8_V_M1_M1_MASK + 0U, // PseudoVSOXSEG2EI8_V_M1_M2 + 0U, // PseudoVSOXSEG2EI8_V_M1_M2_MASK + 0U, // PseudoVSOXSEG2EI8_V_M1_M4 + 0U, // PseudoVSOXSEG2EI8_V_M1_M4_MASK + 0U, // PseudoVSOXSEG2EI8_V_M2_M2 + 0U, // PseudoVSOXSEG2EI8_V_M2_M2_MASK + 0U, // PseudoVSOXSEG2EI8_V_M2_M4 + 0U, // PseudoVSOXSEG2EI8_V_M2_M4_MASK + 0U, // PseudoVSOXSEG2EI8_V_M4_M4 + 0U, // PseudoVSOXSEG2EI8_V_M4_M4_MASK + 0U, // PseudoVSOXSEG2EI8_V_MF2_M1 + 0U, // PseudoVSOXSEG2EI8_V_MF2_M1_MASK + 0U, // PseudoVSOXSEG2EI8_V_MF2_M2 + 0U, // PseudoVSOXSEG2EI8_V_MF2_M2_MASK + 0U, // PseudoVSOXSEG2EI8_V_MF2_M4 + 0U, // PseudoVSOXSEG2EI8_V_MF2_M4_MASK + 0U, // PseudoVSOXSEG2EI8_V_MF2_MF2 + 0U, // PseudoVSOXSEG2EI8_V_MF2_MF2_MASK + 0U, // PseudoVSOXSEG2EI8_V_MF4_M1 + 0U, // PseudoVSOXSEG2EI8_V_MF4_M1_MASK + 0U, // PseudoVSOXSEG2EI8_V_MF4_M2 + 0U, // PseudoVSOXSEG2EI8_V_MF4_M2_MASK + 0U, // PseudoVSOXSEG2EI8_V_MF4_MF2 + 0U, // PseudoVSOXSEG2EI8_V_MF4_MF2_MASK + 0U, // PseudoVSOXSEG2EI8_V_MF4_MF4 + 0U, // PseudoVSOXSEG2EI8_V_MF4_MF4_MASK + 0U, // PseudoVSOXSEG2EI8_V_MF8_M1 + 0U, // PseudoVSOXSEG2EI8_V_MF8_M1_MASK + 0U, // PseudoVSOXSEG2EI8_V_MF8_MF2 + 0U, // PseudoVSOXSEG2EI8_V_MF8_MF2_MASK + 0U, // PseudoVSOXSEG2EI8_V_MF8_MF4 + 0U, // PseudoVSOXSEG2EI8_V_MF8_MF4_MASK + 0U, // PseudoVSOXSEG2EI8_V_MF8_MF8 + 0U, // PseudoVSOXSEG2EI8_V_MF8_MF8_MASK + 0U, // PseudoVSOXSEG3EI16_V_M1_M1 + 0U, // PseudoVSOXSEG3EI16_V_M1_M1_MASK + 0U, // PseudoVSOXSEG3EI16_V_M1_M2 + 0U, // PseudoVSOXSEG3EI16_V_M1_M2_MASK + 0U, // PseudoVSOXSEG3EI16_V_M1_MF2 + 0U, // PseudoVSOXSEG3EI16_V_M1_MF2_MASK + 0U, // PseudoVSOXSEG3EI16_V_M2_M1 + 0U, // PseudoVSOXSEG3EI16_V_M2_M1_MASK + 0U, // PseudoVSOXSEG3EI16_V_M2_M2 + 0U, // PseudoVSOXSEG3EI16_V_M2_M2_MASK + 0U, // PseudoVSOXSEG3EI16_V_M4_M2 + 0U, // PseudoVSOXSEG3EI16_V_M4_M2_MASK + 0U, // PseudoVSOXSEG3EI16_V_MF2_M1 + 0U, // PseudoVSOXSEG3EI16_V_MF2_M1_MASK + 0U, // PseudoVSOXSEG3EI16_V_MF2_M2 + 0U, // PseudoVSOXSEG3EI16_V_MF2_M2_MASK + 0U, // PseudoVSOXSEG3EI16_V_MF2_MF2 + 0U, // PseudoVSOXSEG3EI16_V_MF2_MF2_MASK + 0U, // PseudoVSOXSEG3EI16_V_MF2_MF4 + 0U, // PseudoVSOXSEG3EI16_V_MF2_MF4_MASK + 0U, // PseudoVSOXSEG3EI16_V_MF4_M1 + 0U, // PseudoVSOXSEG3EI16_V_MF4_M1_MASK + 0U, // PseudoVSOXSEG3EI16_V_MF4_MF2 + 0U, // PseudoVSOXSEG3EI16_V_MF4_MF2_MASK + 0U, // PseudoVSOXSEG3EI16_V_MF4_MF4 + 0U, // PseudoVSOXSEG3EI16_V_MF4_MF4_MASK + 0U, // PseudoVSOXSEG3EI16_V_MF4_MF8 + 0U, // PseudoVSOXSEG3EI16_V_MF4_MF8_MASK + 0U, // PseudoVSOXSEG3EI32_V_M1_M1 + 0U, // PseudoVSOXSEG3EI32_V_M1_M1_MASK + 0U, // PseudoVSOXSEG3EI32_V_M1_M2 + 0U, // PseudoVSOXSEG3EI32_V_M1_M2_MASK + 0U, // PseudoVSOXSEG3EI32_V_M1_MF2 + 0U, // PseudoVSOXSEG3EI32_V_M1_MF2_MASK + 0U, // PseudoVSOXSEG3EI32_V_M1_MF4 + 0U, // PseudoVSOXSEG3EI32_V_M1_MF4_MASK + 0U, // PseudoVSOXSEG3EI32_V_M2_M1 + 0U, // PseudoVSOXSEG3EI32_V_M2_M1_MASK + 0U, // PseudoVSOXSEG3EI32_V_M2_M2 + 0U, // PseudoVSOXSEG3EI32_V_M2_M2_MASK + 0U, // PseudoVSOXSEG3EI32_V_M2_MF2 + 0U, // PseudoVSOXSEG3EI32_V_M2_MF2_MASK + 0U, // PseudoVSOXSEG3EI32_V_M4_M1 + 0U, // PseudoVSOXSEG3EI32_V_M4_M1_MASK + 0U, // PseudoVSOXSEG3EI32_V_M4_M2 + 0U, // PseudoVSOXSEG3EI32_V_M4_M2_MASK + 0U, // PseudoVSOXSEG3EI32_V_M8_M2 + 0U, // PseudoVSOXSEG3EI32_V_M8_M2_MASK + 0U, // PseudoVSOXSEG3EI32_V_MF2_M1 + 0U, // PseudoVSOXSEG3EI32_V_MF2_M1_MASK + 0U, // PseudoVSOXSEG3EI32_V_MF2_MF2 + 0U, // PseudoVSOXSEG3EI32_V_MF2_MF2_MASK + 0U, // PseudoVSOXSEG3EI32_V_MF2_MF4 + 0U, // PseudoVSOXSEG3EI32_V_MF2_MF4_MASK + 0U, // PseudoVSOXSEG3EI32_V_MF2_MF8 + 0U, // PseudoVSOXSEG3EI32_V_MF2_MF8_MASK + 0U, // PseudoVSOXSEG3EI64_V_M1_M1 + 0U, // PseudoVSOXSEG3EI64_V_M1_M1_MASK + 0U, // PseudoVSOXSEG3EI64_V_M1_MF2 + 0U, // PseudoVSOXSEG3EI64_V_M1_MF2_MASK + 0U, // PseudoVSOXSEG3EI64_V_M1_MF4 + 0U, // PseudoVSOXSEG3EI64_V_M1_MF4_MASK + 0U, // PseudoVSOXSEG3EI64_V_M1_MF8 + 0U, // PseudoVSOXSEG3EI64_V_M1_MF8_MASK + 0U, // PseudoVSOXSEG3EI64_V_M2_M1 + 0U, // PseudoVSOXSEG3EI64_V_M2_M1_MASK + 0U, // PseudoVSOXSEG3EI64_V_M2_M2 + 0U, // PseudoVSOXSEG3EI64_V_M2_M2_MASK + 0U, // PseudoVSOXSEG3EI64_V_M2_MF2 + 0U, // PseudoVSOXSEG3EI64_V_M2_MF2_MASK + 0U, // PseudoVSOXSEG3EI64_V_M2_MF4 + 0U, // PseudoVSOXSEG3EI64_V_M2_MF4_MASK + 0U, // PseudoVSOXSEG3EI64_V_M4_M1 + 0U, // PseudoVSOXSEG3EI64_V_M4_M1_MASK + 0U, // PseudoVSOXSEG3EI64_V_M4_M2 + 0U, // PseudoVSOXSEG3EI64_V_M4_M2_MASK + 0U, // PseudoVSOXSEG3EI64_V_M4_MF2 + 0U, // PseudoVSOXSEG3EI64_V_M4_MF2_MASK + 0U, // PseudoVSOXSEG3EI64_V_M8_M1 + 0U, // PseudoVSOXSEG3EI64_V_M8_M1_MASK + 0U, // PseudoVSOXSEG3EI64_V_M8_M2 + 0U, // PseudoVSOXSEG3EI64_V_M8_M2_MASK + 0U, // PseudoVSOXSEG3EI8_V_M1_M1 + 0U, // PseudoVSOXSEG3EI8_V_M1_M1_MASK + 0U, // PseudoVSOXSEG3EI8_V_M1_M2 + 0U, // PseudoVSOXSEG3EI8_V_M1_M2_MASK + 0U, // PseudoVSOXSEG3EI8_V_M2_M2 + 0U, // PseudoVSOXSEG3EI8_V_M2_M2_MASK + 0U, // PseudoVSOXSEG3EI8_V_MF2_M1 + 0U, // PseudoVSOXSEG3EI8_V_MF2_M1_MASK + 0U, // PseudoVSOXSEG3EI8_V_MF2_M2 + 0U, // PseudoVSOXSEG3EI8_V_MF2_M2_MASK + 0U, // PseudoVSOXSEG3EI8_V_MF2_MF2 + 0U, // PseudoVSOXSEG3EI8_V_MF2_MF2_MASK + 0U, // PseudoVSOXSEG3EI8_V_MF4_M1 + 0U, // PseudoVSOXSEG3EI8_V_MF4_M1_MASK + 0U, // PseudoVSOXSEG3EI8_V_MF4_M2 + 0U, // PseudoVSOXSEG3EI8_V_MF4_M2_MASK + 0U, // PseudoVSOXSEG3EI8_V_MF4_MF2 + 0U, // PseudoVSOXSEG3EI8_V_MF4_MF2_MASK + 0U, // PseudoVSOXSEG3EI8_V_MF4_MF4 + 0U, // PseudoVSOXSEG3EI8_V_MF4_MF4_MASK + 0U, // PseudoVSOXSEG3EI8_V_MF8_M1 + 0U, // PseudoVSOXSEG3EI8_V_MF8_M1_MASK + 0U, // PseudoVSOXSEG3EI8_V_MF8_MF2 + 0U, // PseudoVSOXSEG3EI8_V_MF8_MF2_MASK + 0U, // PseudoVSOXSEG3EI8_V_MF8_MF4 + 0U, // PseudoVSOXSEG3EI8_V_MF8_MF4_MASK + 0U, // PseudoVSOXSEG3EI8_V_MF8_MF8 + 0U, // PseudoVSOXSEG3EI8_V_MF8_MF8_MASK + 0U, // PseudoVSOXSEG4EI16_V_M1_M1 + 0U, // PseudoVSOXSEG4EI16_V_M1_M1_MASK + 0U, // PseudoVSOXSEG4EI16_V_M1_M2 + 0U, // PseudoVSOXSEG4EI16_V_M1_M2_MASK + 0U, // PseudoVSOXSEG4EI16_V_M1_MF2 + 0U, // PseudoVSOXSEG4EI16_V_M1_MF2_MASK + 0U, // PseudoVSOXSEG4EI16_V_M2_M1 + 0U, // PseudoVSOXSEG4EI16_V_M2_M1_MASK + 0U, // PseudoVSOXSEG4EI16_V_M2_M2 + 0U, // PseudoVSOXSEG4EI16_V_M2_M2_MASK + 0U, // PseudoVSOXSEG4EI16_V_M4_M2 + 0U, // PseudoVSOXSEG4EI16_V_M4_M2_MASK + 0U, // PseudoVSOXSEG4EI16_V_MF2_M1 + 0U, // PseudoVSOXSEG4EI16_V_MF2_M1_MASK + 0U, // PseudoVSOXSEG4EI16_V_MF2_M2 + 0U, // PseudoVSOXSEG4EI16_V_MF2_M2_MASK + 0U, // PseudoVSOXSEG4EI16_V_MF2_MF2 + 0U, // PseudoVSOXSEG4EI16_V_MF2_MF2_MASK + 0U, // PseudoVSOXSEG4EI16_V_MF2_MF4 + 0U, // PseudoVSOXSEG4EI16_V_MF2_MF4_MASK + 0U, // PseudoVSOXSEG4EI16_V_MF4_M1 + 0U, // PseudoVSOXSEG4EI16_V_MF4_M1_MASK + 0U, // PseudoVSOXSEG4EI16_V_MF4_MF2 + 0U, // PseudoVSOXSEG4EI16_V_MF4_MF2_MASK + 0U, // PseudoVSOXSEG4EI16_V_MF4_MF4 + 0U, // PseudoVSOXSEG4EI16_V_MF4_MF4_MASK + 0U, // PseudoVSOXSEG4EI16_V_MF4_MF8 + 0U, // PseudoVSOXSEG4EI16_V_MF4_MF8_MASK + 0U, // PseudoVSOXSEG4EI32_V_M1_M1 + 0U, // PseudoVSOXSEG4EI32_V_M1_M1_MASK + 0U, // PseudoVSOXSEG4EI32_V_M1_M2 + 0U, // PseudoVSOXSEG4EI32_V_M1_M2_MASK + 0U, // PseudoVSOXSEG4EI32_V_M1_MF2 + 0U, // PseudoVSOXSEG4EI32_V_M1_MF2_MASK + 0U, // PseudoVSOXSEG4EI32_V_M1_MF4 + 0U, // PseudoVSOXSEG4EI32_V_M1_MF4_MASK + 0U, // PseudoVSOXSEG4EI32_V_M2_M1 + 0U, // PseudoVSOXSEG4EI32_V_M2_M1_MASK + 0U, // PseudoVSOXSEG4EI32_V_M2_M2 + 0U, // PseudoVSOXSEG4EI32_V_M2_M2_MASK + 0U, // PseudoVSOXSEG4EI32_V_M2_MF2 + 0U, // PseudoVSOXSEG4EI32_V_M2_MF2_MASK + 0U, // PseudoVSOXSEG4EI32_V_M4_M1 + 0U, // PseudoVSOXSEG4EI32_V_M4_M1_MASK + 0U, // PseudoVSOXSEG4EI32_V_M4_M2 + 0U, // PseudoVSOXSEG4EI32_V_M4_M2_MASK + 0U, // PseudoVSOXSEG4EI32_V_M8_M2 + 0U, // PseudoVSOXSEG4EI32_V_M8_M2_MASK + 0U, // PseudoVSOXSEG4EI32_V_MF2_M1 + 0U, // PseudoVSOXSEG4EI32_V_MF2_M1_MASK + 0U, // PseudoVSOXSEG4EI32_V_MF2_MF2 + 0U, // PseudoVSOXSEG4EI32_V_MF2_MF2_MASK + 0U, // PseudoVSOXSEG4EI32_V_MF2_MF4 + 0U, // PseudoVSOXSEG4EI32_V_MF2_MF4_MASK + 0U, // PseudoVSOXSEG4EI32_V_MF2_MF8 + 0U, // PseudoVSOXSEG4EI32_V_MF2_MF8_MASK + 0U, // PseudoVSOXSEG4EI64_V_M1_M1 + 0U, // PseudoVSOXSEG4EI64_V_M1_M1_MASK + 0U, // PseudoVSOXSEG4EI64_V_M1_MF2 + 0U, // PseudoVSOXSEG4EI64_V_M1_MF2_MASK + 0U, // PseudoVSOXSEG4EI64_V_M1_MF4 + 0U, // PseudoVSOXSEG4EI64_V_M1_MF4_MASK + 0U, // PseudoVSOXSEG4EI64_V_M1_MF8 + 0U, // PseudoVSOXSEG4EI64_V_M1_MF8_MASK + 0U, // PseudoVSOXSEG4EI64_V_M2_M1 + 0U, // PseudoVSOXSEG4EI64_V_M2_M1_MASK + 0U, // PseudoVSOXSEG4EI64_V_M2_M2 + 0U, // PseudoVSOXSEG4EI64_V_M2_M2_MASK + 0U, // PseudoVSOXSEG4EI64_V_M2_MF2 + 0U, // PseudoVSOXSEG4EI64_V_M2_MF2_MASK + 0U, // PseudoVSOXSEG4EI64_V_M2_MF4 + 0U, // PseudoVSOXSEG4EI64_V_M2_MF4_MASK + 0U, // PseudoVSOXSEG4EI64_V_M4_M1 + 0U, // PseudoVSOXSEG4EI64_V_M4_M1_MASK + 0U, // PseudoVSOXSEG4EI64_V_M4_M2 + 0U, // PseudoVSOXSEG4EI64_V_M4_M2_MASK + 0U, // PseudoVSOXSEG4EI64_V_M4_MF2 + 0U, // PseudoVSOXSEG4EI64_V_M4_MF2_MASK + 0U, // PseudoVSOXSEG4EI64_V_M8_M1 + 0U, // PseudoVSOXSEG4EI64_V_M8_M1_MASK + 0U, // PseudoVSOXSEG4EI64_V_M8_M2 + 0U, // PseudoVSOXSEG4EI64_V_M8_M2_MASK + 0U, // PseudoVSOXSEG4EI8_V_M1_M1 + 0U, // PseudoVSOXSEG4EI8_V_M1_M1_MASK + 0U, // PseudoVSOXSEG4EI8_V_M1_M2 + 0U, // PseudoVSOXSEG4EI8_V_M1_M2_MASK + 0U, // PseudoVSOXSEG4EI8_V_M2_M2 + 0U, // PseudoVSOXSEG4EI8_V_M2_M2_MASK + 0U, // PseudoVSOXSEG4EI8_V_MF2_M1 + 0U, // PseudoVSOXSEG4EI8_V_MF2_M1_MASK + 0U, // PseudoVSOXSEG4EI8_V_MF2_M2 + 0U, // PseudoVSOXSEG4EI8_V_MF2_M2_MASK + 0U, // PseudoVSOXSEG4EI8_V_MF2_MF2 + 0U, // PseudoVSOXSEG4EI8_V_MF2_MF2_MASK + 0U, // PseudoVSOXSEG4EI8_V_MF4_M1 + 0U, // PseudoVSOXSEG4EI8_V_MF4_M1_MASK + 0U, // PseudoVSOXSEG4EI8_V_MF4_M2 + 0U, // PseudoVSOXSEG4EI8_V_MF4_M2_MASK + 0U, // PseudoVSOXSEG4EI8_V_MF4_MF2 + 0U, // PseudoVSOXSEG4EI8_V_MF4_MF2_MASK + 0U, // PseudoVSOXSEG4EI8_V_MF4_MF4 + 0U, // PseudoVSOXSEG4EI8_V_MF4_MF4_MASK + 0U, // PseudoVSOXSEG4EI8_V_MF8_M1 + 0U, // PseudoVSOXSEG4EI8_V_MF8_M1_MASK + 0U, // PseudoVSOXSEG4EI8_V_MF8_MF2 + 0U, // PseudoVSOXSEG4EI8_V_MF8_MF2_MASK + 0U, // PseudoVSOXSEG4EI8_V_MF8_MF4 + 0U, // PseudoVSOXSEG4EI8_V_MF8_MF4_MASK + 0U, // PseudoVSOXSEG4EI8_V_MF8_MF8 + 0U, // PseudoVSOXSEG4EI8_V_MF8_MF8_MASK + 0U, // PseudoVSOXSEG5EI16_V_M1_M1 + 0U, // PseudoVSOXSEG5EI16_V_M1_M1_MASK + 0U, // PseudoVSOXSEG5EI16_V_M1_MF2 + 0U, // PseudoVSOXSEG5EI16_V_M1_MF2_MASK + 0U, // PseudoVSOXSEG5EI16_V_M2_M1 + 0U, // PseudoVSOXSEG5EI16_V_M2_M1_MASK + 0U, // PseudoVSOXSEG5EI16_V_MF2_M1 + 0U, // PseudoVSOXSEG5EI16_V_MF2_M1_MASK + 0U, // PseudoVSOXSEG5EI16_V_MF2_MF2 + 0U, // PseudoVSOXSEG5EI16_V_MF2_MF2_MASK + 0U, // PseudoVSOXSEG5EI16_V_MF2_MF4 + 0U, // PseudoVSOXSEG5EI16_V_MF2_MF4_MASK + 0U, // PseudoVSOXSEG5EI16_V_MF4_M1 + 0U, // PseudoVSOXSEG5EI16_V_MF4_M1_MASK + 0U, // PseudoVSOXSEG5EI16_V_MF4_MF2 + 0U, // PseudoVSOXSEG5EI16_V_MF4_MF2_MASK + 0U, // PseudoVSOXSEG5EI16_V_MF4_MF4 + 0U, // PseudoVSOXSEG5EI16_V_MF4_MF4_MASK + 0U, // PseudoVSOXSEG5EI16_V_MF4_MF8 + 0U, // PseudoVSOXSEG5EI16_V_MF4_MF8_MASK + 0U, // PseudoVSOXSEG5EI32_V_M1_M1 + 0U, // PseudoVSOXSEG5EI32_V_M1_M1_MASK + 0U, // PseudoVSOXSEG5EI32_V_M1_MF2 + 0U, // PseudoVSOXSEG5EI32_V_M1_MF2_MASK + 0U, // PseudoVSOXSEG5EI32_V_M1_MF4 + 0U, // PseudoVSOXSEG5EI32_V_M1_MF4_MASK + 0U, // PseudoVSOXSEG5EI32_V_M2_M1 + 0U, // PseudoVSOXSEG5EI32_V_M2_M1_MASK + 0U, // PseudoVSOXSEG5EI32_V_M2_MF2 + 0U, // PseudoVSOXSEG5EI32_V_M2_MF2_MASK + 0U, // PseudoVSOXSEG5EI32_V_M4_M1 + 0U, // PseudoVSOXSEG5EI32_V_M4_M1_MASK + 0U, // PseudoVSOXSEG5EI32_V_MF2_M1 + 0U, // PseudoVSOXSEG5EI32_V_MF2_M1_MASK + 0U, // PseudoVSOXSEG5EI32_V_MF2_MF2 + 0U, // PseudoVSOXSEG5EI32_V_MF2_MF2_MASK + 0U, // PseudoVSOXSEG5EI32_V_MF2_MF4 + 0U, // PseudoVSOXSEG5EI32_V_MF2_MF4_MASK + 0U, // PseudoVSOXSEG5EI32_V_MF2_MF8 + 0U, // PseudoVSOXSEG5EI32_V_MF2_MF8_MASK + 0U, // PseudoVSOXSEG5EI64_V_M1_M1 + 0U, // PseudoVSOXSEG5EI64_V_M1_M1_MASK + 0U, // PseudoVSOXSEG5EI64_V_M1_MF2 + 0U, // PseudoVSOXSEG5EI64_V_M1_MF2_MASK + 0U, // PseudoVSOXSEG5EI64_V_M1_MF4 + 0U, // PseudoVSOXSEG5EI64_V_M1_MF4_MASK + 0U, // PseudoVSOXSEG5EI64_V_M1_MF8 + 0U, // PseudoVSOXSEG5EI64_V_M1_MF8_MASK + 0U, // PseudoVSOXSEG5EI64_V_M2_M1 + 0U, // PseudoVSOXSEG5EI64_V_M2_M1_MASK + 0U, // PseudoVSOXSEG5EI64_V_M2_MF2 + 0U, // PseudoVSOXSEG5EI64_V_M2_MF2_MASK + 0U, // PseudoVSOXSEG5EI64_V_M2_MF4 + 0U, // PseudoVSOXSEG5EI64_V_M2_MF4_MASK + 0U, // PseudoVSOXSEG5EI64_V_M4_M1 + 0U, // PseudoVSOXSEG5EI64_V_M4_M1_MASK + 0U, // PseudoVSOXSEG5EI64_V_M4_MF2 + 0U, // PseudoVSOXSEG5EI64_V_M4_MF2_MASK + 0U, // PseudoVSOXSEG5EI64_V_M8_M1 + 0U, // PseudoVSOXSEG5EI64_V_M8_M1_MASK + 0U, // PseudoVSOXSEG5EI8_V_M1_M1 + 0U, // PseudoVSOXSEG5EI8_V_M1_M1_MASK + 0U, // PseudoVSOXSEG5EI8_V_MF2_M1 + 0U, // PseudoVSOXSEG5EI8_V_MF2_M1_MASK + 0U, // PseudoVSOXSEG5EI8_V_MF2_MF2 + 0U, // PseudoVSOXSEG5EI8_V_MF2_MF2_MASK + 0U, // PseudoVSOXSEG5EI8_V_MF4_M1 + 0U, // PseudoVSOXSEG5EI8_V_MF4_M1_MASK + 0U, // PseudoVSOXSEG5EI8_V_MF4_MF2 + 0U, // PseudoVSOXSEG5EI8_V_MF4_MF2_MASK + 0U, // PseudoVSOXSEG5EI8_V_MF4_MF4 + 0U, // PseudoVSOXSEG5EI8_V_MF4_MF4_MASK + 0U, // PseudoVSOXSEG5EI8_V_MF8_M1 + 0U, // PseudoVSOXSEG5EI8_V_MF8_M1_MASK + 0U, // PseudoVSOXSEG5EI8_V_MF8_MF2 + 0U, // PseudoVSOXSEG5EI8_V_MF8_MF2_MASK + 0U, // PseudoVSOXSEG5EI8_V_MF8_MF4 + 0U, // PseudoVSOXSEG5EI8_V_MF8_MF4_MASK + 0U, // PseudoVSOXSEG5EI8_V_MF8_MF8 + 0U, // PseudoVSOXSEG5EI8_V_MF8_MF8_MASK + 0U, // PseudoVSOXSEG6EI16_V_M1_M1 + 0U, // PseudoVSOXSEG6EI16_V_M1_M1_MASK + 0U, // PseudoVSOXSEG6EI16_V_M1_MF2 + 0U, // PseudoVSOXSEG6EI16_V_M1_MF2_MASK + 0U, // PseudoVSOXSEG6EI16_V_M2_M1 + 0U, // PseudoVSOXSEG6EI16_V_M2_M1_MASK + 0U, // PseudoVSOXSEG6EI16_V_MF2_M1 + 0U, // PseudoVSOXSEG6EI16_V_MF2_M1_MASK + 0U, // PseudoVSOXSEG6EI16_V_MF2_MF2 + 0U, // PseudoVSOXSEG6EI16_V_MF2_MF2_MASK + 0U, // PseudoVSOXSEG6EI16_V_MF2_MF4 + 0U, // PseudoVSOXSEG6EI16_V_MF2_MF4_MASK + 0U, // PseudoVSOXSEG6EI16_V_MF4_M1 + 0U, // PseudoVSOXSEG6EI16_V_MF4_M1_MASK + 0U, // PseudoVSOXSEG6EI16_V_MF4_MF2 + 0U, // PseudoVSOXSEG6EI16_V_MF4_MF2_MASK + 0U, // PseudoVSOXSEG6EI16_V_MF4_MF4 + 0U, // PseudoVSOXSEG6EI16_V_MF4_MF4_MASK + 0U, // PseudoVSOXSEG6EI16_V_MF4_MF8 + 0U, // PseudoVSOXSEG6EI16_V_MF4_MF8_MASK + 0U, // PseudoVSOXSEG6EI32_V_M1_M1 + 0U, // PseudoVSOXSEG6EI32_V_M1_M1_MASK + 0U, // PseudoVSOXSEG6EI32_V_M1_MF2 + 0U, // PseudoVSOXSEG6EI32_V_M1_MF2_MASK + 0U, // PseudoVSOXSEG6EI32_V_M1_MF4 + 0U, // PseudoVSOXSEG6EI32_V_M1_MF4_MASK + 0U, // PseudoVSOXSEG6EI32_V_M2_M1 + 0U, // PseudoVSOXSEG6EI32_V_M2_M1_MASK + 0U, // PseudoVSOXSEG6EI32_V_M2_MF2 + 0U, // PseudoVSOXSEG6EI32_V_M2_MF2_MASK + 0U, // PseudoVSOXSEG6EI32_V_M4_M1 + 0U, // PseudoVSOXSEG6EI32_V_M4_M1_MASK + 0U, // PseudoVSOXSEG6EI32_V_MF2_M1 + 0U, // PseudoVSOXSEG6EI32_V_MF2_M1_MASK + 0U, // PseudoVSOXSEG6EI32_V_MF2_MF2 + 0U, // PseudoVSOXSEG6EI32_V_MF2_MF2_MASK + 0U, // PseudoVSOXSEG6EI32_V_MF2_MF4 + 0U, // PseudoVSOXSEG6EI32_V_MF2_MF4_MASK + 0U, // PseudoVSOXSEG6EI32_V_MF2_MF8 + 0U, // PseudoVSOXSEG6EI32_V_MF2_MF8_MASK + 0U, // PseudoVSOXSEG6EI64_V_M1_M1 + 0U, // PseudoVSOXSEG6EI64_V_M1_M1_MASK + 0U, // PseudoVSOXSEG6EI64_V_M1_MF2 + 0U, // PseudoVSOXSEG6EI64_V_M1_MF2_MASK + 0U, // PseudoVSOXSEG6EI64_V_M1_MF4 + 0U, // PseudoVSOXSEG6EI64_V_M1_MF4_MASK + 0U, // PseudoVSOXSEG6EI64_V_M1_MF8 + 0U, // PseudoVSOXSEG6EI64_V_M1_MF8_MASK + 0U, // PseudoVSOXSEG6EI64_V_M2_M1 + 0U, // PseudoVSOXSEG6EI64_V_M2_M1_MASK + 0U, // PseudoVSOXSEG6EI64_V_M2_MF2 + 0U, // PseudoVSOXSEG6EI64_V_M2_MF2_MASK + 0U, // PseudoVSOXSEG6EI64_V_M2_MF4 + 0U, // PseudoVSOXSEG6EI64_V_M2_MF4_MASK + 0U, // PseudoVSOXSEG6EI64_V_M4_M1 + 0U, // PseudoVSOXSEG6EI64_V_M4_M1_MASK + 0U, // PseudoVSOXSEG6EI64_V_M4_MF2 + 0U, // PseudoVSOXSEG6EI64_V_M4_MF2_MASK + 0U, // PseudoVSOXSEG6EI64_V_M8_M1 + 0U, // PseudoVSOXSEG6EI64_V_M8_M1_MASK + 0U, // PseudoVSOXSEG6EI8_V_M1_M1 + 0U, // PseudoVSOXSEG6EI8_V_M1_M1_MASK + 0U, // PseudoVSOXSEG6EI8_V_MF2_M1 + 0U, // PseudoVSOXSEG6EI8_V_MF2_M1_MASK + 0U, // PseudoVSOXSEG6EI8_V_MF2_MF2 + 0U, // PseudoVSOXSEG6EI8_V_MF2_MF2_MASK + 0U, // PseudoVSOXSEG6EI8_V_MF4_M1 + 0U, // PseudoVSOXSEG6EI8_V_MF4_M1_MASK + 0U, // PseudoVSOXSEG6EI8_V_MF4_MF2 + 0U, // PseudoVSOXSEG6EI8_V_MF4_MF2_MASK + 0U, // PseudoVSOXSEG6EI8_V_MF4_MF4 + 0U, // PseudoVSOXSEG6EI8_V_MF4_MF4_MASK + 0U, // PseudoVSOXSEG6EI8_V_MF8_M1 + 0U, // PseudoVSOXSEG6EI8_V_MF8_M1_MASK + 0U, // PseudoVSOXSEG6EI8_V_MF8_MF2 + 0U, // PseudoVSOXSEG6EI8_V_MF8_MF2_MASK + 0U, // PseudoVSOXSEG6EI8_V_MF8_MF4 + 0U, // PseudoVSOXSEG6EI8_V_MF8_MF4_MASK + 0U, // PseudoVSOXSEG6EI8_V_MF8_MF8 + 0U, // PseudoVSOXSEG6EI8_V_MF8_MF8_MASK + 0U, // PseudoVSOXSEG7EI16_V_M1_M1 + 0U, // PseudoVSOXSEG7EI16_V_M1_M1_MASK + 0U, // PseudoVSOXSEG7EI16_V_M1_MF2 + 0U, // PseudoVSOXSEG7EI16_V_M1_MF2_MASK + 0U, // PseudoVSOXSEG7EI16_V_M2_M1 + 0U, // PseudoVSOXSEG7EI16_V_M2_M1_MASK + 0U, // PseudoVSOXSEG7EI16_V_MF2_M1 + 0U, // PseudoVSOXSEG7EI16_V_MF2_M1_MASK + 0U, // PseudoVSOXSEG7EI16_V_MF2_MF2 + 0U, // PseudoVSOXSEG7EI16_V_MF2_MF2_MASK + 0U, // PseudoVSOXSEG7EI16_V_MF2_MF4 + 0U, // PseudoVSOXSEG7EI16_V_MF2_MF4_MASK + 0U, // PseudoVSOXSEG7EI16_V_MF4_M1 + 0U, // PseudoVSOXSEG7EI16_V_MF4_M1_MASK + 0U, // PseudoVSOXSEG7EI16_V_MF4_MF2 + 0U, // PseudoVSOXSEG7EI16_V_MF4_MF2_MASK + 0U, // PseudoVSOXSEG7EI16_V_MF4_MF4 + 0U, // PseudoVSOXSEG7EI16_V_MF4_MF4_MASK + 0U, // PseudoVSOXSEG7EI16_V_MF4_MF8 + 0U, // PseudoVSOXSEG7EI16_V_MF4_MF8_MASK + 0U, // PseudoVSOXSEG7EI32_V_M1_M1 + 0U, // PseudoVSOXSEG7EI32_V_M1_M1_MASK + 0U, // PseudoVSOXSEG7EI32_V_M1_MF2 + 0U, // PseudoVSOXSEG7EI32_V_M1_MF2_MASK + 0U, // PseudoVSOXSEG7EI32_V_M1_MF4 + 0U, // PseudoVSOXSEG7EI32_V_M1_MF4_MASK + 0U, // PseudoVSOXSEG7EI32_V_M2_M1 + 0U, // PseudoVSOXSEG7EI32_V_M2_M1_MASK + 0U, // PseudoVSOXSEG7EI32_V_M2_MF2 + 0U, // PseudoVSOXSEG7EI32_V_M2_MF2_MASK + 0U, // PseudoVSOXSEG7EI32_V_M4_M1 + 0U, // PseudoVSOXSEG7EI32_V_M4_M1_MASK + 0U, // PseudoVSOXSEG7EI32_V_MF2_M1 + 0U, // PseudoVSOXSEG7EI32_V_MF2_M1_MASK + 0U, // PseudoVSOXSEG7EI32_V_MF2_MF2 + 0U, // PseudoVSOXSEG7EI32_V_MF2_MF2_MASK + 0U, // PseudoVSOXSEG7EI32_V_MF2_MF4 + 0U, // PseudoVSOXSEG7EI32_V_MF2_MF4_MASK + 0U, // PseudoVSOXSEG7EI32_V_MF2_MF8 + 0U, // PseudoVSOXSEG7EI32_V_MF2_MF8_MASK + 0U, // PseudoVSOXSEG7EI64_V_M1_M1 + 0U, // PseudoVSOXSEG7EI64_V_M1_M1_MASK + 0U, // PseudoVSOXSEG7EI64_V_M1_MF2 + 0U, // PseudoVSOXSEG7EI64_V_M1_MF2_MASK + 0U, // PseudoVSOXSEG7EI64_V_M1_MF4 + 0U, // PseudoVSOXSEG7EI64_V_M1_MF4_MASK + 0U, // PseudoVSOXSEG7EI64_V_M1_MF8 + 0U, // PseudoVSOXSEG7EI64_V_M1_MF8_MASK + 0U, // PseudoVSOXSEG7EI64_V_M2_M1 + 0U, // PseudoVSOXSEG7EI64_V_M2_M1_MASK + 0U, // PseudoVSOXSEG7EI64_V_M2_MF2 + 0U, // PseudoVSOXSEG7EI64_V_M2_MF2_MASK + 0U, // PseudoVSOXSEG7EI64_V_M2_MF4 + 0U, // PseudoVSOXSEG7EI64_V_M2_MF4_MASK + 0U, // PseudoVSOXSEG7EI64_V_M4_M1 + 0U, // PseudoVSOXSEG7EI64_V_M4_M1_MASK + 0U, // PseudoVSOXSEG7EI64_V_M4_MF2 + 0U, // PseudoVSOXSEG7EI64_V_M4_MF2_MASK + 0U, // PseudoVSOXSEG7EI64_V_M8_M1 + 0U, // PseudoVSOXSEG7EI64_V_M8_M1_MASK + 0U, // PseudoVSOXSEG7EI8_V_M1_M1 + 0U, // PseudoVSOXSEG7EI8_V_M1_M1_MASK + 0U, // PseudoVSOXSEG7EI8_V_MF2_M1 + 0U, // PseudoVSOXSEG7EI8_V_MF2_M1_MASK + 0U, // PseudoVSOXSEG7EI8_V_MF2_MF2 + 0U, // PseudoVSOXSEG7EI8_V_MF2_MF2_MASK + 0U, // PseudoVSOXSEG7EI8_V_MF4_M1 + 0U, // PseudoVSOXSEG7EI8_V_MF4_M1_MASK + 0U, // PseudoVSOXSEG7EI8_V_MF4_MF2 + 0U, // PseudoVSOXSEG7EI8_V_MF4_MF2_MASK + 0U, // PseudoVSOXSEG7EI8_V_MF4_MF4 + 0U, // PseudoVSOXSEG7EI8_V_MF4_MF4_MASK + 0U, // PseudoVSOXSEG7EI8_V_MF8_M1 + 0U, // PseudoVSOXSEG7EI8_V_MF8_M1_MASK + 0U, // PseudoVSOXSEG7EI8_V_MF8_MF2 + 0U, // PseudoVSOXSEG7EI8_V_MF8_MF2_MASK + 0U, // PseudoVSOXSEG7EI8_V_MF8_MF4 + 0U, // PseudoVSOXSEG7EI8_V_MF8_MF4_MASK + 0U, // PseudoVSOXSEG7EI8_V_MF8_MF8 + 0U, // PseudoVSOXSEG7EI8_V_MF8_MF8_MASK + 0U, // PseudoVSOXSEG8EI16_V_M1_M1 + 0U, // PseudoVSOXSEG8EI16_V_M1_M1_MASK + 0U, // PseudoVSOXSEG8EI16_V_M1_MF2 + 0U, // PseudoVSOXSEG8EI16_V_M1_MF2_MASK + 0U, // PseudoVSOXSEG8EI16_V_M2_M1 + 0U, // PseudoVSOXSEG8EI16_V_M2_M1_MASK + 0U, // PseudoVSOXSEG8EI16_V_MF2_M1 + 0U, // PseudoVSOXSEG8EI16_V_MF2_M1_MASK + 0U, // PseudoVSOXSEG8EI16_V_MF2_MF2 + 0U, // PseudoVSOXSEG8EI16_V_MF2_MF2_MASK + 0U, // PseudoVSOXSEG8EI16_V_MF2_MF4 + 0U, // PseudoVSOXSEG8EI16_V_MF2_MF4_MASK + 0U, // PseudoVSOXSEG8EI16_V_MF4_M1 + 0U, // PseudoVSOXSEG8EI16_V_MF4_M1_MASK + 0U, // PseudoVSOXSEG8EI16_V_MF4_MF2 + 0U, // PseudoVSOXSEG8EI16_V_MF4_MF2_MASK + 0U, // PseudoVSOXSEG8EI16_V_MF4_MF4 + 0U, // PseudoVSOXSEG8EI16_V_MF4_MF4_MASK + 0U, // PseudoVSOXSEG8EI16_V_MF4_MF8 + 0U, // PseudoVSOXSEG8EI16_V_MF4_MF8_MASK + 0U, // PseudoVSOXSEG8EI32_V_M1_M1 + 0U, // PseudoVSOXSEG8EI32_V_M1_M1_MASK + 0U, // PseudoVSOXSEG8EI32_V_M1_MF2 + 0U, // PseudoVSOXSEG8EI32_V_M1_MF2_MASK + 0U, // PseudoVSOXSEG8EI32_V_M1_MF4 + 0U, // PseudoVSOXSEG8EI32_V_M1_MF4_MASK + 0U, // PseudoVSOXSEG8EI32_V_M2_M1 + 0U, // PseudoVSOXSEG8EI32_V_M2_M1_MASK + 0U, // PseudoVSOXSEG8EI32_V_M2_MF2 + 0U, // PseudoVSOXSEG8EI32_V_M2_MF2_MASK + 0U, // PseudoVSOXSEG8EI32_V_M4_M1 + 0U, // PseudoVSOXSEG8EI32_V_M4_M1_MASK + 0U, // PseudoVSOXSEG8EI32_V_MF2_M1 + 0U, // PseudoVSOXSEG8EI32_V_MF2_M1_MASK + 0U, // PseudoVSOXSEG8EI32_V_MF2_MF2 + 0U, // PseudoVSOXSEG8EI32_V_MF2_MF2_MASK + 0U, // PseudoVSOXSEG8EI32_V_MF2_MF4 + 0U, // PseudoVSOXSEG8EI32_V_MF2_MF4_MASK + 0U, // PseudoVSOXSEG8EI32_V_MF2_MF8 + 0U, // PseudoVSOXSEG8EI32_V_MF2_MF8_MASK + 0U, // PseudoVSOXSEG8EI64_V_M1_M1 + 0U, // PseudoVSOXSEG8EI64_V_M1_M1_MASK + 0U, // PseudoVSOXSEG8EI64_V_M1_MF2 + 0U, // PseudoVSOXSEG8EI64_V_M1_MF2_MASK + 0U, // PseudoVSOXSEG8EI64_V_M1_MF4 + 0U, // PseudoVSOXSEG8EI64_V_M1_MF4_MASK + 0U, // PseudoVSOXSEG8EI64_V_M1_MF8 + 0U, // PseudoVSOXSEG8EI64_V_M1_MF8_MASK + 0U, // PseudoVSOXSEG8EI64_V_M2_M1 + 0U, // PseudoVSOXSEG8EI64_V_M2_M1_MASK + 0U, // PseudoVSOXSEG8EI64_V_M2_MF2 + 0U, // PseudoVSOXSEG8EI64_V_M2_MF2_MASK + 0U, // PseudoVSOXSEG8EI64_V_M2_MF4 + 0U, // PseudoVSOXSEG8EI64_V_M2_MF4_MASK + 0U, // PseudoVSOXSEG8EI64_V_M4_M1 + 0U, // PseudoVSOXSEG8EI64_V_M4_M1_MASK + 0U, // PseudoVSOXSEG8EI64_V_M4_MF2 + 0U, // PseudoVSOXSEG8EI64_V_M4_MF2_MASK + 0U, // PseudoVSOXSEG8EI64_V_M8_M1 + 0U, // PseudoVSOXSEG8EI64_V_M8_M1_MASK + 0U, // PseudoVSOXSEG8EI8_V_M1_M1 + 0U, // PseudoVSOXSEG8EI8_V_M1_M1_MASK + 0U, // PseudoVSOXSEG8EI8_V_MF2_M1 + 0U, // PseudoVSOXSEG8EI8_V_MF2_M1_MASK + 0U, // PseudoVSOXSEG8EI8_V_MF2_MF2 + 0U, // PseudoVSOXSEG8EI8_V_MF2_MF2_MASK + 0U, // PseudoVSOXSEG8EI8_V_MF4_M1 + 0U, // PseudoVSOXSEG8EI8_V_MF4_M1_MASK + 0U, // PseudoVSOXSEG8EI8_V_MF4_MF2 + 0U, // PseudoVSOXSEG8EI8_V_MF4_MF2_MASK + 0U, // PseudoVSOXSEG8EI8_V_MF4_MF4 + 0U, // PseudoVSOXSEG8EI8_V_MF4_MF4_MASK + 0U, // PseudoVSOXSEG8EI8_V_MF8_M1 + 0U, // PseudoVSOXSEG8EI8_V_MF8_M1_MASK + 0U, // PseudoVSOXSEG8EI8_V_MF8_MF2 + 0U, // PseudoVSOXSEG8EI8_V_MF8_MF2_MASK + 0U, // PseudoVSOXSEG8EI8_V_MF8_MF4 + 0U, // PseudoVSOXSEG8EI8_V_MF8_MF4_MASK + 0U, // PseudoVSOXSEG8EI8_V_MF8_MF8 + 0U, // PseudoVSOXSEG8EI8_V_MF8_MF8_MASK + 0U, // PseudoVSPILL2_M1 + 0U, // PseudoVSPILL2_M2 + 0U, // PseudoVSPILL2_M4 + 0U, // PseudoVSPILL2_MF2 + 0U, // PseudoVSPILL2_MF4 + 0U, // PseudoVSPILL2_MF8 + 0U, // PseudoVSPILL3_M1 + 0U, // PseudoVSPILL3_M2 + 0U, // PseudoVSPILL3_MF2 + 0U, // PseudoVSPILL3_MF4 + 0U, // PseudoVSPILL3_MF8 + 0U, // PseudoVSPILL4_M1 + 0U, // PseudoVSPILL4_M2 + 0U, // PseudoVSPILL4_MF2 + 0U, // PseudoVSPILL4_MF4 + 0U, // PseudoVSPILL4_MF8 + 0U, // PseudoVSPILL5_M1 + 0U, // PseudoVSPILL5_MF2 + 0U, // PseudoVSPILL5_MF4 + 0U, // PseudoVSPILL5_MF8 + 0U, // PseudoVSPILL6_M1 + 0U, // PseudoVSPILL6_MF2 + 0U, // PseudoVSPILL6_MF4 + 0U, // PseudoVSPILL6_MF8 + 0U, // PseudoVSPILL7_M1 + 0U, // PseudoVSPILL7_MF2 + 0U, // PseudoVSPILL7_MF4 + 0U, // PseudoVSPILL7_MF8 + 0U, // PseudoVSPILL8_M1 + 0U, // PseudoVSPILL8_MF2 + 0U, // PseudoVSPILL8_MF4 + 0U, // PseudoVSPILL8_MF8 + 0U, // PseudoVSRA_VI_M1 + 0U, // PseudoVSRA_VI_M1_MASK + 0U, // PseudoVSRA_VI_M2 + 0U, // PseudoVSRA_VI_M2_MASK + 0U, // PseudoVSRA_VI_M4 + 0U, // PseudoVSRA_VI_M4_MASK + 0U, // PseudoVSRA_VI_M8 + 0U, // PseudoVSRA_VI_M8_MASK + 0U, // PseudoVSRA_VI_MF2 + 0U, // PseudoVSRA_VI_MF2_MASK + 0U, // PseudoVSRA_VI_MF4 + 0U, // PseudoVSRA_VI_MF4_MASK + 0U, // PseudoVSRA_VI_MF8 + 0U, // PseudoVSRA_VI_MF8_MASK + 0U, // PseudoVSRA_VV_M1 + 0U, // PseudoVSRA_VV_M1_MASK + 0U, // PseudoVSRA_VV_M2 + 0U, // PseudoVSRA_VV_M2_MASK + 0U, // PseudoVSRA_VV_M4 + 0U, // PseudoVSRA_VV_M4_MASK + 0U, // PseudoVSRA_VV_M8 + 0U, // PseudoVSRA_VV_M8_MASK + 0U, // PseudoVSRA_VV_MF2 + 0U, // PseudoVSRA_VV_MF2_MASK + 0U, // PseudoVSRA_VV_MF4 + 0U, // PseudoVSRA_VV_MF4_MASK + 0U, // PseudoVSRA_VV_MF8 + 0U, // PseudoVSRA_VV_MF8_MASK + 0U, // PseudoVSRA_VX_M1 + 0U, // PseudoVSRA_VX_M1_MASK + 0U, // PseudoVSRA_VX_M2 + 0U, // PseudoVSRA_VX_M2_MASK + 0U, // PseudoVSRA_VX_M4 + 0U, // PseudoVSRA_VX_M4_MASK + 0U, // PseudoVSRA_VX_M8 + 0U, // PseudoVSRA_VX_M8_MASK + 0U, // PseudoVSRA_VX_MF2 + 0U, // PseudoVSRA_VX_MF2_MASK + 0U, // PseudoVSRA_VX_MF4 + 0U, // PseudoVSRA_VX_MF4_MASK + 0U, // PseudoVSRA_VX_MF8 + 0U, // PseudoVSRA_VX_MF8_MASK + 0U, // PseudoVSRL_VI_M1 + 0U, // PseudoVSRL_VI_M1_MASK + 0U, // PseudoVSRL_VI_M2 + 0U, // PseudoVSRL_VI_M2_MASK + 0U, // PseudoVSRL_VI_M4 + 0U, // PseudoVSRL_VI_M4_MASK + 0U, // PseudoVSRL_VI_M8 + 0U, // PseudoVSRL_VI_M8_MASK + 0U, // PseudoVSRL_VI_MF2 + 0U, // PseudoVSRL_VI_MF2_MASK + 0U, // PseudoVSRL_VI_MF4 + 0U, // PseudoVSRL_VI_MF4_MASK + 0U, // PseudoVSRL_VI_MF8 + 0U, // PseudoVSRL_VI_MF8_MASK + 0U, // PseudoVSRL_VV_M1 + 0U, // PseudoVSRL_VV_M1_MASK + 0U, // PseudoVSRL_VV_M2 + 0U, // PseudoVSRL_VV_M2_MASK + 0U, // PseudoVSRL_VV_M4 + 0U, // PseudoVSRL_VV_M4_MASK + 0U, // PseudoVSRL_VV_M8 + 0U, // PseudoVSRL_VV_M8_MASK + 0U, // PseudoVSRL_VV_MF2 + 0U, // PseudoVSRL_VV_MF2_MASK + 0U, // PseudoVSRL_VV_MF4 + 0U, // PseudoVSRL_VV_MF4_MASK + 0U, // PseudoVSRL_VV_MF8 + 0U, // PseudoVSRL_VV_MF8_MASK + 0U, // PseudoVSRL_VX_M1 + 0U, // PseudoVSRL_VX_M1_MASK + 0U, // PseudoVSRL_VX_M2 + 0U, // PseudoVSRL_VX_M2_MASK + 0U, // PseudoVSRL_VX_M4 + 0U, // PseudoVSRL_VX_M4_MASK + 0U, // PseudoVSRL_VX_M8 + 0U, // PseudoVSRL_VX_M8_MASK + 0U, // PseudoVSRL_VX_MF2 + 0U, // PseudoVSRL_VX_MF2_MASK + 0U, // PseudoVSRL_VX_MF4 + 0U, // PseudoVSRL_VX_MF4_MASK + 0U, // PseudoVSRL_VX_MF8 + 0U, // PseudoVSRL_VX_MF8_MASK + 0U, // PseudoVSSE16_V_M1 + 0U, // PseudoVSSE16_V_M1_MASK + 0U, // PseudoVSSE16_V_M2 + 0U, // PseudoVSSE16_V_M2_MASK + 0U, // PseudoVSSE16_V_M4 + 0U, // PseudoVSSE16_V_M4_MASK + 0U, // PseudoVSSE16_V_M8 + 0U, // PseudoVSSE16_V_M8_MASK + 0U, // PseudoVSSE16_V_MF2 + 0U, // PseudoVSSE16_V_MF2_MASK + 0U, // PseudoVSSE16_V_MF4 + 0U, // PseudoVSSE16_V_MF4_MASK + 0U, // PseudoVSSE32_V_M1 + 0U, // PseudoVSSE32_V_M1_MASK + 0U, // PseudoVSSE32_V_M2 + 0U, // PseudoVSSE32_V_M2_MASK + 0U, // PseudoVSSE32_V_M4 + 0U, // PseudoVSSE32_V_M4_MASK + 0U, // PseudoVSSE32_V_M8 + 0U, // PseudoVSSE32_V_M8_MASK + 0U, // PseudoVSSE32_V_MF2 + 0U, // PseudoVSSE32_V_MF2_MASK + 0U, // PseudoVSSE64_V_M1 + 0U, // PseudoVSSE64_V_M1_MASK + 0U, // PseudoVSSE64_V_M2 + 0U, // PseudoVSSE64_V_M2_MASK + 0U, // PseudoVSSE64_V_M4 + 0U, // PseudoVSSE64_V_M4_MASK + 0U, // PseudoVSSE64_V_M8 + 0U, // PseudoVSSE64_V_M8_MASK + 0U, // PseudoVSSE8_V_M1 + 0U, // PseudoVSSE8_V_M1_MASK + 0U, // PseudoVSSE8_V_M2 + 0U, // PseudoVSSE8_V_M2_MASK + 0U, // PseudoVSSE8_V_M4 + 0U, // PseudoVSSE8_V_M4_MASK + 0U, // PseudoVSSE8_V_M8 + 0U, // PseudoVSSE8_V_M8_MASK + 0U, // PseudoVSSE8_V_MF2 + 0U, // PseudoVSSE8_V_MF2_MASK + 0U, // PseudoVSSE8_V_MF4 + 0U, // PseudoVSSE8_V_MF4_MASK + 0U, // PseudoVSSE8_V_MF8 + 0U, // PseudoVSSE8_V_MF8_MASK + 0U, // PseudoVSSEG2E16_V_M1 + 0U, // PseudoVSSEG2E16_V_M1_MASK + 0U, // PseudoVSSEG2E16_V_M2 + 0U, // PseudoVSSEG2E16_V_M2_MASK + 0U, // PseudoVSSEG2E16_V_M4 + 0U, // PseudoVSSEG2E16_V_M4_MASK + 0U, // PseudoVSSEG2E16_V_MF2 + 0U, // PseudoVSSEG2E16_V_MF2_MASK + 0U, // PseudoVSSEG2E16_V_MF4 + 0U, // PseudoVSSEG2E16_V_MF4_MASK + 0U, // PseudoVSSEG2E32_V_M1 + 0U, // PseudoVSSEG2E32_V_M1_MASK + 0U, // PseudoVSSEG2E32_V_M2 + 0U, // PseudoVSSEG2E32_V_M2_MASK + 0U, // PseudoVSSEG2E32_V_M4 + 0U, // PseudoVSSEG2E32_V_M4_MASK + 0U, // PseudoVSSEG2E32_V_MF2 + 0U, // PseudoVSSEG2E32_V_MF2_MASK + 0U, // PseudoVSSEG2E64_V_M1 + 0U, // PseudoVSSEG2E64_V_M1_MASK + 0U, // PseudoVSSEG2E64_V_M2 + 0U, // PseudoVSSEG2E64_V_M2_MASK + 0U, // PseudoVSSEG2E64_V_M4 + 0U, // PseudoVSSEG2E64_V_M4_MASK + 0U, // PseudoVSSEG2E8_V_M1 + 0U, // PseudoVSSEG2E8_V_M1_MASK + 0U, // PseudoVSSEG2E8_V_M2 + 0U, // PseudoVSSEG2E8_V_M2_MASK + 0U, // PseudoVSSEG2E8_V_M4 + 0U, // PseudoVSSEG2E8_V_M4_MASK + 0U, // PseudoVSSEG2E8_V_MF2 + 0U, // PseudoVSSEG2E8_V_MF2_MASK + 0U, // PseudoVSSEG2E8_V_MF4 + 0U, // PseudoVSSEG2E8_V_MF4_MASK + 0U, // PseudoVSSEG2E8_V_MF8 + 0U, // PseudoVSSEG2E8_V_MF8_MASK + 0U, // PseudoVSSEG3E16_V_M1 + 0U, // PseudoVSSEG3E16_V_M1_MASK + 0U, // PseudoVSSEG3E16_V_M2 + 0U, // PseudoVSSEG3E16_V_M2_MASK + 0U, // PseudoVSSEG3E16_V_MF2 + 0U, // PseudoVSSEG3E16_V_MF2_MASK + 0U, // PseudoVSSEG3E16_V_MF4 + 0U, // PseudoVSSEG3E16_V_MF4_MASK + 0U, // PseudoVSSEG3E32_V_M1 + 0U, // PseudoVSSEG3E32_V_M1_MASK + 0U, // PseudoVSSEG3E32_V_M2 + 0U, // PseudoVSSEG3E32_V_M2_MASK + 0U, // PseudoVSSEG3E32_V_MF2 + 0U, // PseudoVSSEG3E32_V_MF2_MASK + 0U, // PseudoVSSEG3E64_V_M1 + 0U, // PseudoVSSEG3E64_V_M1_MASK + 0U, // PseudoVSSEG3E64_V_M2 + 0U, // PseudoVSSEG3E64_V_M2_MASK + 0U, // PseudoVSSEG3E8_V_M1 + 0U, // PseudoVSSEG3E8_V_M1_MASK + 0U, // PseudoVSSEG3E8_V_M2 + 0U, // PseudoVSSEG3E8_V_M2_MASK + 0U, // PseudoVSSEG3E8_V_MF2 + 0U, // PseudoVSSEG3E8_V_MF2_MASK + 0U, // PseudoVSSEG3E8_V_MF4 + 0U, // PseudoVSSEG3E8_V_MF4_MASK + 0U, // PseudoVSSEG3E8_V_MF8 + 0U, // PseudoVSSEG3E8_V_MF8_MASK + 0U, // PseudoVSSEG4E16_V_M1 + 0U, // PseudoVSSEG4E16_V_M1_MASK + 0U, // PseudoVSSEG4E16_V_M2 + 0U, // PseudoVSSEG4E16_V_M2_MASK + 0U, // PseudoVSSEG4E16_V_MF2 + 0U, // PseudoVSSEG4E16_V_MF2_MASK + 0U, // PseudoVSSEG4E16_V_MF4 + 0U, // PseudoVSSEG4E16_V_MF4_MASK + 0U, // PseudoVSSEG4E32_V_M1 + 0U, // PseudoVSSEG4E32_V_M1_MASK + 0U, // PseudoVSSEG4E32_V_M2 + 0U, // PseudoVSSEG4E32_V_M2_MASK + 0U, // PseudoVSSEG4E32_V_MF2 + 0U, // PseudoVSSEG4E32_V_MF2_MASK + 0U, // PseudoVSSEG4E64_V_M1 + 0U, // PseudoVSSEG4E64_V_M1_MASK + 0U, // PseudoVSSEG4E64_V_M2 + 0U, // PseudoVSSEG4E64_V_M2_MASK + 0U, // PseudoVSSEG4E8_V_M1 + 0U, // PseudoVSSEG4E8_V_M1_MASK + 0U, // PseudoVSSEG4E8_V_M2 + 0U, // PseudoVSSEG4E8_V_M2_MASK + 0U, // PseudoVSSEG4E8_V_MF2 + 0U, // PseudoVSSEG4E8_V_MF2_MASK + 0U, // PseudoVSSEG4E8_V_MF4 + 0U, // PseudoVSSEG4E8_V_MF4_MASK + 0U, // PseudoVSSEG4E8_V_MF8 + 0U, // PseudoVSSEG4E8_V_MF8_MASK + 0U, // PseudoVSSEG5E16_V_M1 + 0U, // PseudoVSSEG5E16_V_M1_MASK + 0U, // PseudoVSSEG5E16_V_MF2 + 0U, // PseudoVSSEG5E16_V_MF2_MASK + 0U, // PseudoVSSEG5E16_V_MF4 + 0U, // PseudoVSSEG5E16_V_MF4_MASK + 0U, // PseudoVSSEG5E32_V_M1 + 0U, // PseudoVSSEG5E32_V_M1_MASK + 0U, // PseudoVSSEG5E32_V_MF2 + 0U, // PseudoVSSEG5E32_V_MF2_MASK + 0U, // PseudoVSSEG5E64_V_M1 + 0U, // PseudoVSSEG5E64_V_M1_MASK + 0U, // PseudoVSSEG5E8_V_M1 + 0U, // PseudoVSSEG5E8_V_M1_MASK + 0U, // PseudoVSSEG5E8_V_MF2 + 0U, // PseudoVSSEG5E8_V_MF2_MASK + 0U, // PseudoVSSEG5E8_V_MF4 + 0U, // PseudoVSSEG5E8_V_MF4_MASK + 0U, // PseudoVSSEG5E8_V_MF8 + 0U, // PseudoVSSEG5E8_V_MF8_MASK + 0U, // PseudoVSSEG6E16_V_M1 + 0U, // PseudoVSSEG6E16_V_M1_MASK + 0U, // PseudoVSSEG6E16_V_MF2 + 0U, // PseudoVSSEG6E16_V_MF2_MASK + 0U, // PseudoVSSEG6E16_V_MF4 + 0U, // PseudoVSSEG6E16_V_MF4_MASK + 0U, // PseudoVSSEG6E32_V_M1 + 0U, // PseudoVSSEG6E32_V_M1_MASK + 0U, // PseudoVSSEG6E32_V_MF2 + 0U, // PseudoVSSEG6E32_V_MF2_MASK + 0U, // PseudoVSSEG6E64_V_M1 + 0U, // PseudoVSSEG6E64_V_M1_MASK + 0U, // PseudoVSSEG6E8_V_M1 + 0U, // PseudoVSSEG6E8_V_M1_MASK + 0U, // PseudoVSSEG6E8_V_MF2 + 0U, // PseudoVSSEG6E8_V_MF2_MASK + 0U, // PseudoVSSEG6E8_V_MF4 + 0U, // PseudoVSSEG6E8_V_MF4_MASK + 0U, // PseudoVSSEG6E8_V_MF8 + 0U, // PseudoVSSEG6E8_V_MF8_MASK + 0U, // PseudoVSSEG7E16_V_M1 + 0U, // PseudoVSSEG7E16_V_M1_MASK + 0U, // PseudoVSSEG7E16_V_MF2 + 0U, // PseudoVSSEG7E16_V_MF2_MASK + 0U, // PseudoVSSEG7E16_V_MF4 + 0U, // PseudoVSSEG7E16_V_MF4_MASK + 0U, // PseudoVSSEG7E32_V_M1 + 0U, // PseudoVSSEG7E32_V_M1_MASK + 0U, // PseudoVSSEG7E32_V_MF2 + 0U, // PseudoVSSEG7E32_V_MF2_MASK + 0U, // PseudoVSSEG7E64_V_M1 + 0U, // PseudoVSSEG7E64_V_M1_MASK + 0U, // PseudoVSSEG7E8_V_M1 + 0U, // PseudoVSSEG7E8_V_M1_MASK + 0U, // PseudoVSSEG7E8_V_MF2 + 0U, // PseudoVSSEG7E8_V_MF2_MASK + 0U, // PseudoVSSEG7E8_V_MF4 + 0U, // PseudoVSSEG7E8_V_MF4_MASK + 0U, // PseudoVSSEG7E8_V_MF8 + 0U, // PseudoVSSEG7E8_V_MF8_MASK + 0U, // PseudoVSSEG8E16_V_M1 + 0U, // PseudoVSSEG8E16_V_M1_MASK + 0U, // PseudoVSSEG8E16_V_MF2 + 0U, // PseudoVSSEG8E16_V_MF2_MASK + 0U, // PseudoVSSEG8E16_V_MF4 + 0U, // PseudoVSSEG8E16_V_MF4_MASK + 0U, // PseudoVSSEG8E32_V_M1 + 0U, // PseudoVSSEG8E32_V_M1_MASK + 0U, // PseudoVSSEG8E32_V_MF2 + 0U, // PseudoVSSEG8E32_V_MF2_MASK + 0U, // PseudoVSSEG8E64_V_M1 + 0U, // PseudoVSSEG8E64_V_M1_MASK + 0U, // PseudoVSSEG8E8_V_M1 + 0U, // PseudoVSSEG8E8_V_M1_MASK + 0U, // PseudoVSSEG8E8_V_MF2 + 0U, // PseudoVSSEG8E8_V_MF2_MASK + 0U, // PseudoVSSEG8E8_V_MF4 + 0U, // PseudoVSSEG8E8_V_MF4_MASK + 0U, // PseudoVSSEG8E8_V_MF8 + 0U, // PseudoVSSEG8E8_V_MF8_MASK + 0U, // PseudoVSSRA_VI_M1 + 0U, // PseudoVSSRA_VI_M1_MASK + 0U, // PseudoVSSRA_VI_M2 + 0U, // PseudoVSSRA_VI_M2_MASK + 0U, // PseudoVSSRA_VI_M4 + 0U, // PseudoVSSRA_VI_M4_MASK + 0U, // PseudoVSSRA_VI_M8 + 0U, // PseudoVSSRA_VI_M8_MASK + 0U, // PseudoVSSRA_VI_MF2 + 0U, // PseudoVSSRA_VI_MF2_MASK + 0U, // PseudoVSSRA_VI_MF4 + 0U, // PseudoVSSRA_VI_MF4_MASK + 0U, // PseudoVSSRA_VI_MF8 + 0U, // PseudoVSSRA_VI_MF8_MASK + 0U, // PseudoVSSRA_VV_M1 + 0U, // PseudoVSSRA_VV_M1_MASK + 0U, // PseudoVSSRA_VV_M2 + 0U, // PseudoVSSRA_VV_M2_MASK + 0U, // PseudoVSSRA_VV_M4 + 0U, // PseudoVSSRA_VV_M4_MASK + 0U, // PseudoVSSRA_VV_M8 + 0U, // PseudoVSSRA_VV_M8_MASK + 0U, // PseudoVSSRA_VV_MF2 + 0U, // PseudoVSSRA_VV_MF2_MASK + 0U, // PseudoVSSRA_VV_MF4 + 0U, // PseudoVSSRA_VV_MF4_MASK + 0U, // PseudoVSSRA_VV_MF8 + 0U, // PseudoVSSRA_VV_MF8_MASK + 0U, // PseudoVSSRA_VX_M1 + 0U, // PseudoVSSRA_VX_M1_MASK + 0U, // PseudoVSSRA_VX_M2 + 0U, // PseudoVSSRA_VX_M2_MASK + 0U, // PseudoVSSRA_VX_M4 + 0U, // PseudoVSSRA_VX_M4_MASK + 0U, // PseudoVSSRA_VX_M8 + 0U, // PseudoVSSRA_VX_M8_MASK + 0U, // PseudoVSSRA_VX_MF2 + 0U, // PseudoVSSRA_VX_MF2_MASK + 0U, // PseudoVSSRA_VX_MF4 + 0U, // PseudoVSSRA_VX_MF4_MASK + 0U, // PseudoVSSRA_VX_MF8 + 0U, // PseudoVSSRA_VX_MF8_MASK + 0U, // PseudoVSSRL_VI_M1 + 0U, // PseudoVSSRL_VI_M1_MASK + 0U, // PseudoVSSRL_VI_M2 + 0U, // PseudoVSSRL_VI_M2_MASK + 0U, // PseudoVSSRL_VI_M4 + 0U, // PseudoVSSRL_VI_M4_MASK + 0U, // PseudoVSSRL_VI_M8 + 0U, // PseudoVSSRL_VI_M8_MASK + 0U, // PseudoVSSRL_VI_MF2 + 0U, // PseudoVSSRL_VI_MF2_MASK + 0U, // PseudoVSSRL_VI_MF4 + 0U, // PseudoVSSRL_VI_MF4_MASK + 0U, // PseudoVSSRL_VI_MF8 + 0U, // PseudoVSSRL_VI_MF8_MASK + 0U, // PseudoVSSRL_VV_M1 + 0U, // PseudoVSSRL_VV_M1_MASK + 0U, // PseudoVSSRL_VV_M2 + 0U, // PseudoVSSRL_VV_M2_MASK + 0U, // PseudoVSSRL_VV_M4 + 0U, // PseudoVSSRL_VV_M4_MASK + 0U, // PseudoVSSRL_VV_M8 + 0U, // PseudoVSSRL_VV_M8_MASK + 0U, // PseudoVSSRL_VV_MF2 + 0U, // PseudoVSSRL_VV_MF2_MASK + 0U, // PseudoVSSRL_VV_MF4 + 0U, // PseudoVSSRL_VV_MF4_MASK + 0U, // PseudoVSSRL_VV_MF8 + 0U, // PseudoVSSRL_VV_MF8_MASK + 0U, // PseudoVSSRL_VX_M1 + 0U, // PseudoVSSRL_VX_M1_MASK + 0U, // PseudoVSSRL_VX_M2 + 0U, // PseudoVSSRL_VX_M2_MASK + 0U, // PseudoVSSRL_VX_M4 + 0U, // PseudoVSSRL_VX_M4_MASK + 0U, // PseudoVSSRL_VX_M8 + 0U, // PseudoVSSRL_VX_M8_MASK + 0U, // PseudoVSSRL_VX_MF2 + 0U, // PseudoVSSRL_VX_MF2_MASK + 0U, // PseudoVSSRL_VX_MF4 + 0U, // PseudoVSSRL_VX_MF4_MASK + 0U, // PseudoVSSRL_VX_MF8 + 0U, // PseudoVSSRL_VX_MF8_MASK + 0U, // PseudoVSSSEG2E16_V_M1 + 0U, // PseudoVSSSEG2E16_V_M1_MASK + 0U, // PseudoVSSSEG2E16_V_M2 + 0U, // PseudoVSSSEG2E16_V_M2_MASK + 0U, // PseudoVSSSEG2E16_V_M4 + 0U, // PseudoVSSSEG2E16_V_M4_MASK + 0U, // PseudoVSSSEG2E16_V_MF2 + 0U, // PseudoVSSSEG2E16_V_MF2_MASK + 0U, // PseudoVSSSEG2E16_V_MF4 + 0U, // PseudoVSSSEG2E16_V_MF4_MASK + 0U, // PseudoVSSSEG2E32_V_M1 + 0U, // PseudoVSSSEG2E32_V_M1_MASK + 0U, // PseudoVSSSEG2E32_V_M2 + 0U, // PseudoVSSSEG2E32_V_M2_MASK + 0U, // PseudoVSSSEG2E32_V_M4 + 0U, // PseudoVSSSEG2E32_V_M4_MASK + 0U, // PseudoVSSSEG2E32_V_MF2 + 0U, // PseudoVSSSEG2E32_V_MF2_MASK + 0U, // PseudoVSSSEG2E64_V_M1 + 0U, // PseudoVSSSEG2E64_V_M1_MASK + 0U, // PseudoVSSSEG2E64_V_M2 + 0U, // PseudoVSSSEG2E64_V_M2_MASK + 0U, // PseudoVSSSEG2E64_V_M4 + 0U, // PseudoVSSSEG2E64_V_M4_MASK + 0U, // PseudoVSSSEG2E8_V_M1 + 0U, // PseudoVSSSEG2E8_V_M1_MASK + 0U, // PseudoVSSSEG2E8_V_M2 + 0U, // PseudoVSSSEG2E8_V_M2_MASK + 0U, // PseudoVSSSEG2E8_V_M4 + 0U, // PseudoVSSSEG2E8_V_M4_MASK + 0U, // PseudoVSSSEG2E8_V_MF2 + 0U, // PseudoVSSSEG2E8_V_MF2_MASK + 0U, // PseudoVSSSEG2E8_V_MF4 + 0U, // PseudoVSSSEG2E8_V_MF4_MASK + 0U, // PseudoVSSSEG2E8_V_MF8 + 0U, // PseudoVSSSEG2E8_V_MF8_MASK + 0U, // PseudoVSSSEG3E16_V_M1 + 0U, // PseudoVSSSEG3E16_V_M1_MASK + 0U, // PseudoVSSSEG3E16_V_M2 + 0U, // PseudoVSSSEG3E16_V_M2_MASK + 0U, // PseudoVSSSEG3E16_V_MF2 + 0U, // PseudoVSSSEG3E16_V_MF2_MASK + 0U, // PseudoVSSSEG3E16_V_MF4 + 0U, // PseudoVSSSEG3E16_V_MF4_MASK + 0U, // PseudoVSSSEG3E32_V_M1 + 0U, // PseudoVSSSEG3E32_V_M1_MASK + 0U, // PseudoVSSSEG3E32_V_M2 + 0U, // PseudoVSSSEG3E32_V_M2_MASK + 0U, // PseudoVSSSEG3E32_V_MF2 + 0U, // PseudoVSSSEG3E32_V_MF2_MASK + 0U, // PseudoVSSSEG3E64_V_M1 + 0U, // PseudoVSSSEG3E64_V_M1_MASK + 0U, // PseudoVSSSEG3E64_V_M2 + 0U, // PseudoVSSSEG3E64_V_M2_MASK + 0U, // PseudoVSSSEG3E8_V_M1 + 0U, // PseudoVSSSEG3E8_V_M1_MASK + 0U, // PseudoVSSSEG3E8_V_M2 + 0U, // PseudoVSSSEG3E8_V_M2_MASK + 0U, // PseudoVSSSEG3E8_V_MF2 + 0U, // PseudoVSSSEG3E8_V_MF2_MASK + 0U, // PseudoVSSSEG3E8_V_MF4 + 0U, // PseudoVSSSEG3E8_V_MF4_MASK + 0U, // PseudoVSSSEG3E8_V_MF8 + 0U, // PseudoVSSSEG3E8_V_MF8_MASK + 0U, // PseudoVSSSEG4E16_V_M1 + 0U, // PseudoVSSSEG4E16_V_M1_MASK + 0U, // PseudoVSSSEG4E16_V_M2 + 0U, // PseudoVSSSEG4E16_V_M2_MASK + 0U, // PseudoVSSSEG4E16_V_MF2 + 0U, // PseudoVSSSEG4E16_V_MF2_MASK + 0U, // PseudoVSSSEG4E16_V_MF4 + 0U, // PseudoVSSSEG4E16_V_MF4_MASK + 0U, // PseudoVSSSEG4E32_V_M1 + 0U, // PseudoVSSSEG4E32_V_M1_MASK + 0U, // PseudoVSSSEG4E32_V_M2 + 0U, // PseudoVSSSEG4E32_V_M2_MASK + 0U, // PseudoVSSSEG4E32_V_MF2 + 0U, // PseudoVSSSEG4E32_V_MF2_MASK + 0U, // PseudoVSSSEG4E64_V_M1 + 0U, // PseudoVSSSEG4E64_V_M1_MASK + 0U, // PseudoVSSSEG4E64_V_M2 + 0U, // PseudoVSSSEG4E64_V_M2_MASK + 0U, // PseudoVSSSEG4E8_V_M1 + 0U, // PseudoVSSSEG4E8_V_M1_MASK + 0U, // PseudoVSSSEG4E8_V_M2 + 0U, // PseudoVSSSEG4E8_V_M2_MASK + 0U, // PseudoVSSSEG4E8_V_MF2 + 0U, // PseudoVSSSEG4E8_V_MF2_MASK + 0U, // PseudoVSSSEG4E8_V_MF4 + 0U, // PseudoVSSSEG4E8_V_MF4_MASK + 0U, // PseudoVSSSEG4E8_V_MF8 + 0U, // PseudoVSSSEG4E8_V_MF8_MASK + 0U, // PseudoVSSSEG5E16_V_M1 + 0U, // PseudoVSSSEG5E16_V_M1_MASK + 0U, // PseudoVSSSEG5E16_V_MF2 + 0U, // PseudoVSSSEG5E16_V_MF2_MASK + 0U, // PseudoVSSSEG5E16_V_MF4 + 0U, // PseudoVSSSEG5E16_V_MF4_MASK + 0U, // PseudoVSSSEG5E32_V_M1 + 0U, // PseudoVSSSEG5E32_V_M1_MASK + 0U, // PseudoVSSSEG5E32_V_MF2 + 0U, // PseudoVSSSEG5E32_V_MF2_MASK + 0U, // PseudoVSSSEG5E64_V_M1 + 0U, // PseudoVSSSEG5E64_V_M1_MASK + 0U, // PseudoVSSSEG5E8_V_M1 + 0U, // PseudoVSSSEG5E8_V_M1_MASK + 0U, // PseudoVSSSEG5E8_V_MF2 + 0U, // PseudoVSSSEG5E8_V_MF2_MASK + 0U, // PseudoVSSSEG5E8_V_MF4 + 0U, // PseudoVSSSEG5E8_V_MF4_MASK + 0U, // PseudoVSSSEG5E8_V_MF8 + 0U, // PseudoVSSSEG5E8_V_MF8_MASK + 0U, // PseudoVSSSEG6E16_V_M1 + 0U, // PseudoVSSSEG6E16_V_M1_MASK + 0U, // PseudoVSSSEG6E16_V_MF2 + 0U, // PseudoVSSSEG6E16_V_MF2_MASK + 0U, // PseudoVSSSEG6E16_V_MF4 + 0U, // PseudoVSSSEG6E16_V_MF4_MASK + 0U, // PseudoVSSSEG6E32_V_M1 + 0U, // PseudoVSSSEG6E32_V_M1_MASK + 0U, // PseudoVSSSEG6E32_V_MF2 + 0U, // PseudoVSSSEG6E32_V_MF2_MASK + 0U, // PseudoVSSSEG6E64_V_M1 + 0U, // PseudoVSSSEG6E64_V_M1_MASK + 0U, // PseudoVSSSEG6E8_V_M1 + 0U, // PseudoVSSSEG6E8_V_M1_MASK + 0U, // PseudoVSSSEG6E8_V_MF2 + 0U, // PseudoVSSSEG6E8_V_MF2_MASK + 0U, // PseudoVSSSEG6E8_V_MF4 + 0U, // PseudoVSSSEG6E8_V_MF4_MASK + 0U, // PseudoVSSSEG6E8_V_MF8 + 0U, // PseudoVSSSEG6E8_V_MF8_MASK + 0U, // PseudoVSSSEG7E16_V_M1 + 0U, // PseudoVSSSEG7E16_V_M1_MASK + 0U, // PseudoVSSSEG7E16_V_MF2 + 0U, // PseudoVSSSEG7E16_V_MF2_MASK + 0U, // PseudoVSSSEG7E16_V_MF4 + 0U, // PseudoVSSSEG7E16_V_MF4_MASK + 0U, // PseudoVSSSEG7E32_V_M1 + 0U, // PseudoVSSSEG7E32_V_M1_MASK + 0U, // PseudoVSSSEG7E32_V_MF2 + 0U, // PseudoVSSSEG7E32_V_MF2_MASK + 0U, // PseudoVSSSEG7E64_V_M1 + 0U, // PseudoVSSSEG7E64_V_M1_MASK + 0U, // PseudoVSSSEG7E8_V_M1 + 0U, // PseudoVSSSEG7E8_V_M1_MASK + 0U, // PseudoVSSSEG7E8_V_MF2 + 0U, // PseudoVSSSEG7E8_V_MF2_MASK + 0U, // PseudoVSSSEG7E8_V_MF4 + 0U, // PseudoVSSSEG7E8_V_MF4_MASK + 0U, // PseudoVSSSEG7E8_V_MF8 + 0U, // PseudoVSSSEG7E8_V_MF8_MASK + 0U, // PseudoVSSSEG8E16_V_M1 + 0U, // PseudoVSSSEG8E16_V_M1_MASK + 0U, // PseudoVSSSEG8E16_V_MF2 + 0U, // PseudoVSSSEG8E16_V_MF2_MASK + 0U, // PseudoVSSSEG8E16_V_MF4 + 0U, // PseudoVSSSEG8E16_V_MF4_MASK + 0U, // PseudoVSSSEG8E32_V_M1 + 0U, // PseudoVSSSEG8E32_V_M1_MASK + 0U, // PseudoVSSSEG8E32_V_MF2 + 0U, // PseudoVSSSEG8E32_V_MF2_MASK + 0U, // PseudoVSSSEG8E64_V_M1 + 0U, // PseudoVSSSEG8E64_V_M1_MASK + 0U, // PseudoVSSSEG8E8_V_M1 + 0U, // PseudoVSSSEG8E8_V_M1_MASK + 0U, // PseudoVSSSEG8E8_V_MF2 + 0U, // PseudoVSSSEG8E8_V_MF2_MASK + 0U, // PseudoVSSSEG8E8_V_MF4 + 0U, // PseudoVSSSEG8E8_V_MF4_MASK + 0U, // PseudoVSSSEG8E8_V_MF8 + 0U, // PseudoVSSSEG8E8_V_MF8_MASK + 0U, // PseudoVSSUBU_VV_M1 + 0U, // PseudoVSSUBU_VV_M1_MASK + 0U, // PseudoVSSUBU_VV_M2 + 0U, // PseudoVSSUBU_VV_M2_MASK + 0U, // PseudoVSSUBU_VV_M4 + 0U, // PseudoVSSUBU_VV_M4_MASK + 0U, // PseudoVSSUBU_VV_M8 + 0U, // PseudoVSSUBU_VV_M8_MASK + 0U, // PseudoVSSUBU_VV_MF2 + 0U, // PseudoVSSUBU_VV_MF2_MASK + 0U, // PseudoVSSUBU_VV_MF4 + 0U, // PseudoVSSUBU_VV_MF4_MASK + 0U, // PseudoVSSUBU_VV_MF8 + 0U, // PseudoVSSUBU_VV_MF8_MASK + 0U, // PseudoVSSUBU_VX_M1 + 0U, // PseudoVSSUBU_VX_M1_MASK + 0U, // PseudoVSSUBU_VX_M2 + 0U, // PseudoVSSUBU_VX_M2_MASK + 0U, // PseudoVSSUBU_VX_M4 + 0U, // PseudoVSSUBU_VX_M4_MASK + 0U, // PseudoVSSUBU_VX_M8 + 0U, // PseudoVSSUBU_VX_M8_MASK + 0U, // PseudoVSSUBU_VX_MF2 + 0U, // PseudoVSSUBU_VX_MF2_MASK + 0U, // PseudoVSSUBU_VX_MF4 + 0U, // PseudoVSSUBU_VX_MF4_MASK + 0U, // PseudoVSSUBU_VX_MF8 + 0U, // PseudoVSSUBU_VX_MF8_MASK + 0U, // PseudoVSSUB_VV_M1 + 0U, // PseudoVSSUB_VV_M1_MASK + 0U, // PseudoVSSUB_VV_M2 + 0U, // PseudoVSSUB_VV_M2_MASK + 0U, // PseudoVSSUB_VV_M4 + 0U, // PseudoVSSUB_VV_M4_MASK + 0U, // PseudoVSSUB_VV_M8 + 0U, // PseudoVSSUB_VV_M8_MASK + 0U, // PseudoVSSUB_VV_MF2 + 0U, // PseudoVSSUB_VV_MF2_MASK + 0U, // PseudoVSSUB_VV_MF4 + 0U, // PseudoVSSUB_VV_MF4_MASK + 0U, // PseudoVSSUB_VV_MF8 + 0U, // PseudoVSSUB_VV_MF8_MASK + 0U, // PseudoVSSUB_VX_M1 + 0U, // PseudoVSSUB_VX_M1_MASK + 0U, // PseudoVSSUB_VX_M2 + 0U, // PseudoVSSUB_VX_M2_MASK + 0U, // PseudoVSSUB_VX_M4 + 0U, // PseudoVSSUB_VX_M4_MASK + 0U, // PseudoVSSUB_VX_M8 + 0U, // PseudoVSSUB_VX_M8_MASK + 0U, // PseudoVSSUB_VX_MF2 + 0U, // PseudoVSSUB_VX_MF2_MASK + 0U, // PseudoVSSUB_VX_MF4 + 0U, // PseudoVSSUB_VX_MF4_MASK + 0U, // PseudoVSSUB_VX_MF8 + 0U, // PseudoVSSUB_VX_MF8_MASK + 0U, // PseudoVSUB_VV_M1 + 0U, // PseudoVSUB_VV_M1_MASK + 0U, // PseudoVSUB_VV_M2 + 0U, // PseudoVSUB_VV_M2_MASK + 0U, // PseudoVSUB_VV_M4 + 0U, // PseudoVSUB_VV_M4_MASK + 0U, // PseudoVSUB_VV_M8 + 0U, // PseudoVSUB_VV_M8_MASK + 0U, // PseudoVSUB_VV_MF2 + 0U, // PseudoVSUB_VV_MF2_MASK + 0U, // PseudoVSUB_VV_MF4 + 0U, // PseudoVSUB_VV_MF4_MASK + 0U, // PseudoVSUB_VV_MF8 + 0U, // PseudoVSUB_VV_MF8_MASK + 0U, // PseudoVSUB_VX_M1 + 0U, // PseudoVSUB_VX_M1_MASK + 0U, // PseudoVSUB_VX_M2 + 0U, // PseudoVSUB_VX_M2_MASK + 0U, // PseudoVSUB_VX_M4 + 0U, // PseudoVSUB_VX_M4_MASK + 0U, // PseudoVSUB_VX_M8 + 0U, // PseudoVSUB_VX_M8_MASK + 0U, // PseudoVSUB_VX_MF2 + 0U, // PseudoVSUB_VX_MF2_MASK + 0U, // PseudoVSUB_VX_MF4 + 0U, // PseudoVSUB_VX_MF4_MASK + 0U, // PseudoVSUB_VX_MF8 + 0U, // PseudoVSUB_VX_MF8_MASK + 0U, // PseudoVSUXEI16_V_M1_M1 + 0U, // PseudoVSUXEI16_V_M1_M1_MASK + 0U, // PseudoVSUXEI16_V_M1_M2 + 0U, // PseudoVSUXEI16_V_M1_M2_MASK + 0U, // PseudoVSUXEI16_V_M1_M4 + 0U, // PseudoVSUXEI16_V_M1_M4_MASK + 0U, // PseudoVSUXEI16_V_M1_MF2 + 0U, // PseudoVSUXEI16_V_M1_MF2_MASK + 0U, // PseudoVSUXEI16_V_M2_M1 + 0U, // PseudoVSUXEI16_V_M2_M1_MASK + 0U, // PseudoVSUXEI16_V_M2_M2 + 0U, // PseudoVSUXEI16_V_M2_M2_MASK + 0U, // PseudoVSUXEI16_V_M2_M4 + 0U, // PseudoVSUXEI16_V_M2_M4_MASK + 0U, // PseudoVSUXEI16_V_M2_M8 + 0U, // PseudoVSUXEI16_V_M2_M8_MASK + 0U, // PseudoVSUXEI16_V_M4_M2 + 0U, // PseudoVSUXEI16_V_M4_M2_MASK + 0U, // PseudoVSUXEI16_V_M4_M4 + 0U, // PseudoVSUXEI16_V_M4_M4_MASK + 0U, // PseudoVSUXEI16_V_M4_M8 + 0U, // PseudoVSUXEI16_V_M4_M8_MASK + 0U, // PseudoVSUXEI16_V_M8_M4 + 0U, // PseudoVSUXEI16_V_M8_M4_MASK + 0U, // PseudoVSUXEI16_V_M8_M8 + 0U, // PseudoVSUXEI16_V_M8_M8_MASK + 0U, // PseudoVSUXEI16_V_MF2_M1 + 0U, // PseudoVSUXEI16_V_MF2_M1_MASK + 0U, // PseudoVSUXEI16_V_MF2_M2 + 0U, // PseudoVSUXEI16_V_MF2_M2_MASK + 0U, // PseudoVSUXEI16_V_MF2_MF2 + 0U, // PseudoVSUXEI16_V_MF2_MF2_MASK + 0U, // PseudoVSUXEI16_V_MF2_MF4 + 0U, // PseudoVSUXEI16_V_MF2_MF4_MASK + 0U, // PseudoVSUXEI16_V_MF4_M1 + 0U, // PseudoVSUXEI16_V_MF4_M1_MASK + 0U, // PseudoVSUXEI16_V_MF4_MF2 + 0U, // PseudoVSUXEI16_V_MF4_MF2_MASK + 0U, // PseudoVSUXEI16_V_MF4_MF4 + 0U, // PseudoVSUXEI16_V_MF4_MF4_MASK + 0U, // PseudoVSUXEI16_V_MF4_MF8 + 0U, // PseudoVSUXEI16_V_MF4_MF8_MASK + 0U, // PseudoVSUXEI32_V_M1_M1 + 0U, // PseudoVSUXEI32_V_M1_M1_MASK + 0U, // PseudoVSUXEI32_V_M1_M2 + 0U, // PseudoVSUXEI32_V_M1_M2_MASK + 0U, // PseudoVSUXEI32_V_M1_MF2 + 0U, // PseudoVSUXEI32_V_M1_MF2_MASK + 0U, // PseudoVSUXEI32_V_M1_MF4 + 0U, // PseudoVSUXEI32_V_M1_MF4_MASK + 0U, // PseudoVSUXEI32_V_M2_M1 + 0U, // PseudoVSUXEI32_V_M2_M1_MASK + 0U, // PseudoVSUXEI32_V_M2_M2 + 0U, // PseudoVSUXEI32_V_M2_M2_MASK + 0U, // PseudoVSUXEI32_V_M2_M4 + 0U, // PseudoVSUXEI32_V_M2_M4_MASK + 0U, // PseudoVSUXEI32_V_M2_MF2 + 0U, // PseudoVSUXEI32_V_M2_MF2_MASK + 0U, // PseudoVSUXEI32_V_M4_M1 + 0U, // PseudoVSUXEI32_V_M4_M1_MASK + 0U, // PseudoVSUXEI32_V_M4_M2 + 0U, // PseudoVSUXEI32_V_M4_M2_MASK + 0U, // PseudoVSUXEI32_V_M4_M4 + 0U, // PseudoVSUXEI32_V_M4_M4_MASK + 0U, // PseudoVSUXEI32_V_M4_M8 + 0U, // PseudoVSUXEI32_V_M4_M8_MASK + 0U, // PseudoVSUXEI32_V_M8_M2 + 0U, // PseudoVSUXEI32_V_M8_M2_MASK + 0U, // PseudoVSUXEI32_V_M8_M4 + 0U, // PseudoVSUXEI32_V_M8_M4_MASK + 0U, // PseudoVSUXEI32_V_M8_M8 + 0U, // PseudoVSUXEI32_V_M8_M8_MASK + 0U, // PseudoVSUXEI32_V_MF2_M1 + 0U, // PseudoVSUXEI32_V_MF2_M1_MASK + 0U, // PseudoVSUXEI32_V_MF2_MF2 + 0U, // PseudoVSUXEI32_V_MF2_MF2_MASK + 0U, // PseudoVSUXEI32_V_MF2_MF4 + 0U, // PseudoVSUXEI32_V_MF2_MF4_MASK + 0U, // PseudoVSUXEI32_V_MF2_MF8 + 0U, // PseudoVSUXEI32_V_MF2_MF8_MASK + 0U, // PseudoVSUXEI64_V_M1_M1 + 0U, // PseudoVSUXEI64_V_M1_M1_MASK + 0U, // PseudoVSUXEI64_V_M1_MF2 + 0U, // PseudoVSUXEI64_V_M1_MF2_MASK + 0U, // PseudoVSUXEI64_V_M1_MF4 + 0U, // PseudoVSUXEI64_V_M1_MF4_MASK + 0U, // PseudoVSUXEI64_V_M1_MF8 + 0U, // PseudoVSUXEI64_V_M1_MF8_MASK + 0U, // PseudoVSUXEI64_V_M2_M1 + 0U, // PseudoVSUXEI64_V_M2_M1_MASK + 0U, // PseudoVSUXEI64_V_M2_M2 + 0U, // PseudoVSUXEI64_V_M2_M2_MASK + 0U, // PseudoVSUXEI64_V_M2_MF2 + 0U, // PseudoVSUXEI64_V_M2_MF2_MASK + 0U, // PseudoVSUXEI64_V_M2_MF4 + 0U, // PseudoVSUXEI64_V_M2_MF4_MASK + 0U, // PseudoVSUXEI64_V_M4_M1 + 0U, // PseudoVSUXEI64_V_M4_M1_MASK + 0U, // PseudoVSUXEI64_V_M4_M2 + 0U, // PseudoVSUXEI64_V_M4_M2_MASK + 0U, // PseudoVSUXEI64_V_M4_M4 + 0U, // PseudoVSUXEI64_V_M4_M4_MASK + 0U, // PseudoVSUXEI64_V_M4_MF2 + 0U, // PseudoVSUXEI64_V_M4_MF2_MASK + 0U, // PseudoVSUXEI64_V_M8_M1 + 0U, // PseudoVSUXEI64_V_M8_M1_MASK + 0U, // PseudoVSUXEI64_V_M8_M2 + 0U, // PseudoVSUXEI64_V_M8_M2_MASK + 0U, // PseudoVSUXEI64_V_M8_M4 + 0U, // PseudoVSUXEI64_V_M8_M4_MASK + 0U, // PseudoVSUXEI64_V_M8_M8 + 0U, // PseudoVSUXEI64_V_M8_M8_MASK + 0U, // PseudoVSUXEI8_V_M1_M1 + 0U, // PseudoVSUXEI8_V_M1_M1_MASK + 0U, // PseudoVSUXEI8_V_M1_M2 + 0U, // PseudoVSUXEI8_V_M1_M2_MASK + 0U, // PseudoVSUXEI8_V_M1_M4 + 0U, // PseudoVSUXEI8_V_M1_M4_MASK + 0U, // PseudoVSUXEI8_V_M1_M8 + 0U, // PseudoVSUXEI8_V_M1_M8_MASK + 0U, // PseudoVSUXEI8_V_M2_M2 + 0U, // PseudoVSUXEI8_V_M2_M2_MASK + 0U, // PseudoVSUXEI8_V_M2_M4 + 0U, // PseudoVSUXEI8_V_M2_M4_MASK + 0U, // PseudoVSUXEI8_V_M2_M8 + 0U, // PseudoVSUXEI8_V_M2_M8_MASK + 0U, // PseudoVSUXEI8_V_M4_M4 + 0U, // PseudoVSUXEI8_V_M4_M4_MASK + 0U, // PseudoVSUXEI8_V_M4_M8 + 0U, // PseudoVSUXEI8_V_M4_M8_MASK + 0U, // PseudoVSUXEI8_V_M8_M8 + 0U, // PseudoVSUXEI8_V_M8_M8_MASK + 0U, // PseudoVSUXEI8_V_MF2_M1 + 0U, // PseudoVSUXEI8_V_MF2_M1_MASK + 0U, // PseudoVSUXEI8_V_MF2_M2 + 0U, // PseudoVSUXEI8_V_MF2_M2_MASK + 0U, // PseudoVSUXEI8_V_MF2_M4 + 0U, // PseudoVSUXEI8_V_MF2_M4_MASK + 0U, // PseudoVSUXEI8_V_MF2_MF2 + 0U, // PseudoVSUXEI8_V_MF2_MF2_MASK + 0U, // PseudoVSUXEI8_V_MF4_M1 + 0U, // PseudoVSUXEI8_V_MF4_M1_MASK + 0U, // PseudoVSUXEI8_V_MF4_M2 + 0U, // PseudoVSUXEI8_V_MF4_M2_MASK + 0U, // PseudoVSUXEI8_V_MF4_MF2 + 0U, // PseudoVSUXEI8_V_MF4_MF2_MASK + 0U, // PseudoVSUXEI8_V_MF4_MF4 + 0U, // PseudoVSUXEI8_V_MF4_MF4_MASK + 0U, // PseudoVSUXEI8_V_MF8_M1 + 0U, // PseudoVSUXEI8_V_MF8_M1_MASK + 0U, // PseudoVSUXEI8_V_MF8_MF2 + 0U, // PseudoVSUXEI8_V_MF8_MF2_MASK + 0U, // PseudoVSUXEI8_V_MF8_MF4 + 0U, // PseudoVSUXEI8_V_MF8_MF4_MASK + 0U, // PseudoVSUXEI8_V_MF8_MF8 + 0U, // PseudoVSUXEI8_V_MF8_MF8_MASK + 0U, // PseudoVSUXSEG2EI16_V_M1_M1 + 0U, // PseudoVSUXSEG2EI16_V_M1_M1_MASK + 0U, // PseudoVSUXSEG2EI16_V_M1_M2 + 0U, // PseudoVSUXSEG2EI16_V_M1_M2_MASK + 0U, // PseudoVSUXSEG2EI16_V_M1_M4 + 0U, // PseudoVSUXSEG2EI16_V_M1_M4_MASK + 0U, // PseudoVSUXSEG2EI16_V_M1_MF2 + 0U, // PseudoVSUXSEG2EI16_V_M1_MF2_MASK + 0U, // PseudoVSUXSEG2EI16_V_M2_M1 + 0U, // PseudoVSUXSEG2EI16_V_M2_M1_MASK + 0U, // PseudoVSUXSEG2EI16_V_M2_M2 + 0U, // PseudoVSUXSEG2EI16_V_M2_M2_MASK + 0U, // PseudoVSUXSEG2EI16_V_M2_M4 + 0U, // PseudoVSUXSEG2EI16_V_M2_M4_MASK + 0U, // PseudoVSUXSEG2EI16_V_M4_M2 + 0U, // PseudoVSUXSEG2EI16_V_M4_M2_MASK + 0U, // PseudoVSUXSEG2EI16_V_M4_M4 + 0U, // PseudoVSUXSEG2EI16_V_M4_M4_MASK + 0U, // PseudoVSUXSEG2EI16_V_M8_M4 + 0U, // PseudoVSUXSEG2EI16_V_M8_M4_MASK + 0U, // PseudoVSUXSEG2EI16_V_MF2_M1 + 0U, // PseudoVSUXSEG2EI16_V_MF2_M1_MASK + 0U, // PseudoVSUXSEG2EI16_V_MF2_M2 + 0U, // PseudoVSUXSEG2EI16_V_MF2_M2_MASK + 0U, // PseudoVSUXSEG2EI16_V_MF2_MF2 + 0U, // PseudoVSUXSEG2EI16_V_MF2_MF2_MASK + 0U, // PseudoVSUXSEG2EI16_V_MF2_MF4 + 0U, // PseudoVSUXSEG2EI16_V_MF2_MF4_MASK + 0U, // PseudoVSUXSEG2EI16_V_MF4_M1 + 0U, // PseudoVSUXSEG2EI16_V_MF4_M1_MASK + 0U, // PseudoVSUXSEG2EI16_V_MF4_MF2 + 0U, // PseudoVSUXSEG2EI16_V_MF4_MF2_MASK + 0U, // PseudoVSUXSEG2EI16_V_MF4_MF4 + 0U, // PseudoVSUXSEG2EI16_V_MF4_MF4_MASK + 0U, // PseudoVSUXSEG2EI16_V_MF4_MF8 + 0U, // PseudoVSUXSEG2EI16_V_MF4_MF8_MASK + 0U, // PseudoVSUXSEG2EI32_V_M1_M1 + 0U, // PseudoVSUXSEG2EI32_V_M1_M1_MASK + 0U, // PseudoVSUXSEG2EI32_V_M1_M2 + 0U, // PseudoVSUXSEG2EI32_V_M1_M2_MASK + 0U, // PseudoVSUXSEG2EI32_V_M1_MF2 + 0U, // PseudoVSUXSEG2EI32_V_M1_MF2_MASK + 0U, // PseudoVSUXSEG2EI32_V_M1_MF4 + 0U, // PseudoVSUXSEG2EI32_V_M1_MF4_MASK + 0U, // PseudoVSUXSEG2EI32_V_M2_M1 + 0U, // PseudoVSUXSEG2EI32_V_M2_M1_MASK + 0U, // PseudoVSUXSEG2EI32_V_M2_M2 + 0U, // PseudoVSUXSEG2EI32_V_M2_M2_MASK + 0U, // PseudoVSUXSEG2EI32_V_M2_M4 + 0U, // PseudoVSUXSEG2EI32_V_M2_M4_MASK + 0U, // PseudoVSUXSEG2EI32_V_M2_MF2 + 0U, // PseudoVSUXSEG2EI32_V_M2_MF2_MASK + 0U, // PseudoVSUXSEG2EI32_V_M4_M1 + 0U, // PseudoVSUXSEG2EI32_V_M4_M1_MASK + 0U, // PseudoVSUXSEG2EI32_V_M4_M2 + 0U, // PseudoVSUXSEG2EI32_V_M4_M2_MASK + 0U, // PseudoVSUXSEG2EI32_V_M4_M4 + 0U, // PseudoVSUXSEG2EI32_V_M4_M4_MASK + 0U, // PseudoVSUXSEG2EI32_V_M8_M2 + 0U, // PseudoVSUXSEG2EI32_V_M8_M2_MASK + 0U, // PseudoVSUXSEG2EI32_V_M8_M4 + 0U, // PseudoVSUXSEG2EI32_V_M8_M4_MASK + 0U, // PseudoVSUXSEG2EI32_V_MF2_M1 + 0U, // PseudoVSUXSEG2EI32_V_MF2_M1_MASK + 0U, // PseudoVSUXSEG2EI32_V_MF2_MF2 + 0U, // PseudoVSUXSEG2EI32_V_MF2_MF2_MASK + 0U, // PseudoVSUXSEG2EI32_V_MF2_MF4 + 0U, // PseudoVSUXSEG2EI32_V_MF2_MF4_MASK + 0U, // PseudoVSUXSEG2EI32_V_MF2_MF8 + 0U, // PseudoVSUXSEG2EI32_V_MF2_MF8_MASK + 0U, // PseudoVSUXSEG2EI64_V_M1_M1 + 0U, // PseudoVSUXSEG2EI64_V_M1_M1_MASK + 0U, // PseudoVSUXSEG2EI64_V_M1_MF2 + 0U, // PseudoVSUXSEG2EI64_V_M1_MF2_MASK + 0U, // PseudoVSUXSEG2EI64_V_M1_MF4 + 0U, // PseudoVSUXSEG2EI64_V_M1_MF4_MASK + 0U, // PseudoVSUXSEG2EI64_V_M1_MF8 + 0U, // PseudoVSUXSEG2EI64_V_M1_MF8_MASK + 0U, // PseudoVSUXSEG2EI64_V_M2_M1 + 0U, // PseudoVSUXSEG2EI64_V_M2_M1_MASK + 0U, // PseudoVSUXSEG2EI64_V_M2_M2 + 0U, // PseudoVSUXSEG2EI64_V_M2_M2_MASK + 0U, // PseudoVSUXSEG2EI64_V_M2_MF2 + 0U, // PseudoVSUXSEG2EI64_V_M2_MF2_MASK + 0U, // PseudoVSUXSEG2EI64_V_M2_MF4 + 0U, // PseudoVSUXSEG2EI64_V_M2_MF4_MASK + 0U, // PseudoVSUXSEG2EI64_V_M4_M1 + 0U, // PseudoVSUXSEG2EI64_V_M4_M1_MASK + 0U, // PseudoVSUXSEG2EI64_V_M4_M2 + 0U, // PseudoVSUXSEG2EI64_V_M4_M2_MASK + 0U, // PseudoVSUXSEG2EI64_V_M4_M4 + 0U, // PseudoVSUXSEG2EI64_V_M4_M4_MASK + 0U, // PseudoVSUXSEG2EI64_V_M4_MF2 + 0U, // PseudoVSUXSEG2EI64_V_M4_MF2_MASK + 0U, // PseudoVSUXSEG2EI64_V_M8_M1 + 0U, // PseudoVSUXSEG2EI64_V_M8_M1_MASK + 0U, // PseudoVSUXSEG2EI64_V_M8_M2 + 0U, // PseudoVSUXSEG2EI64_V_M8_M2_MASK + 0U, // PseudoVSUXSEG2EI64_V_M8_M4 + 0U, // PseudoVSUXSEG2EI64_V_M8_M4_MASK + 0U, // PseudoVSUXSEG2EI8_V_M1_M1 + 0U, // PseudoVSUXSEG2EI8_V_M1_M1_MASK + 0U, // PseudoVSUXSEG2EI8_V_M1_M2 + 0U, // PseudoVSUXSEG2EI8_V_M1_M2_MASK + 0U, // PseudoVSUXSEG2EI8_V_M1_M4 + 0U, // PseudoVSUXSEG2EI8_V_M1_M4_MASK + 0U, // PseudoVSUXSEG2EI8_V_M2_M2 + 0U, // PseudoVSUXSEG2EI8_V_M2_M2_MASK + 0U, // PseudoVSUXSEG2EI8_V_M2_M4 + 0U, // PseudoVSUXSEG2EI8_V_M2_M4_MASK + 0U, // PseudoVSUXSEG2EI8_V_M4_M4 + 0U, // PseudoVSUXSEG2EI8_V_M4_M4_MASK + 0U, // PseudoVSUXSEG2EI8_V_MF2_M1 + 0U, // PseudoVSUXSEG2EI8_V_MF2_M1_MASK + 0U, // PseudoVSUXSEG2EI8_V_MF2_M2 + 0U, // PseudoVSUXSEG2EI8_V_MF2_M2_MASK + 0U, // PseudoVSUXSEG2EI8_V_MF2_M4 + 0U, // PseudoVSUXSEG2EI8_V_MF2_M4_MASK + 0U, // PseudoVSUXSEG2EI8_V_MF2_MF2 + 0U, // PseudoVSUXSEG2EI8_V_MF2_MF2_MASK + 0U, // PseudoVSUXSEG2EI8_V_MF4_M1 + 0U, // PseudoVSUXSEG2EI8_V_MF4_M1_MASK + 0U, // PseudoVSUXSEG2EI8_V_MF4_M2 + 0U, // PseudoVSUXSEG2EI8_V_MF4_M2_MASK + 0U, // PseudoVSUXSEG2EI8_V_MF4_MF2 + 0U, // PseudoVSUXSEG2EI8_V_MF4_MF2_MASK + 0U, // PseudoVSUXSEG2EI8_V_MF4_MF4 + 0U, // PseudoVSUXSEG2EI8_V_MF4_MF4_MASK + 0U, // PseudoVSUXSEG2EI8_V_MF8_M1 + 0U, // PseudoVSUXSEG2EI8_V_MF8_M1_MASK + 0U, // PseudoVSUXSEG2EI8_V_MF8_MF2 + 0U, // PseudoVSUXSEG2EI8_V_MF8_MF2_MASK + 0U, // PseudoVSUXSEG2EI8_V_MF8_MF4 + 0U, // PseudoVSUXSEG2EI8_V_MF8_MF4_MASK + 0U, // PseudoVSUXSEG2EI8_V_MF8_MF8 + 0U, // PseudoVSUXSEG2EI8_V_MF8_MF8_MASK + 0U, // PseudoVSUXSEG3EI16_V_M1_M1 + 0U, // PseudoVSUXSEG3EI16_V_M1_M1_MASK + 0U, // PseudoVSUXSEG3EI16_V_M1_M2 + 0U, // PseudoVSUXSEG3EI16_V_M1_M2_MASK + 0U, // PseudoVSUXSEG3EI16_V_M1_MF2 + 0U, // PseudoVSUXSEG3EI16_V_M1_MF2_MASK + 0U, // PseudoVSUXSEG3EI16_V_M2_M1 + 0U, // PseudoVSUXSEG3EI16_V_M2_M1_MASK + 0U, // PseudoVSUXSEG3EI16_V_M2_M2 + 0U, // PseudoVSUXSEG3EI16_V_M2_M2_MASK + 0U, // PseudoVSUXSEG3EI16_V_M4_M2 + 0U, // PseudoVSUXSEG3EI16_V_M4_M2_MASK + 0U, // PseudoVSUXSEG3EI16_V_MF2_M1 + 0U, // PseudoVSUXSEG3EI16_V_MF2_M1_MASK + 0U, // PseudoVSUXSEG3EI16_V_MF2_M2 + 0U, // PseudoVSUXSEG3EI16_V_MF2_M2_MASK + 0U, // PseudoVSUXSEG3EI16_V_MF2_MF2 + 0U, // PseudoVSUXSEG3EI16_V_MF2_MF2_MASK + 0U, // PseudoVSUXSEG3EI16_V_MF2_MF4 + 0U, // PseudoVSUXSEG3EI16_V_MF2_MF4_MASK + 0U, // PseudoVSUXSEG3EI16_V_MF4_M1 + 0U, // PseudoVSUXSEG3EI16_V_MF4_M1_MASK + 0U, // PseudoVSUXSEG3EI16_V_MF4_MF2 + 0U, // PseudoVSUXSEG3EI16_V_MF4_MF2_MASK + 0U, // PseudoVSUXSEG3EI16_V_MF4_MF4 + 0U, // PseudoVSUXSEG3EI16_V_MF4_MF4_MASK + 0U, // PseudoVSUXSEG3EI16_V_MF4_MF8 + 0U, // PseudoVSUXSEG3EI16_V_MF4_MF8_MASK + 0U, // PseudoVSUXSEG3EI32_V_M1_M1 + 0U, // PseudoVSUXSEG3EI32_V_M1_M1_MASK + 0U, // PseudoVSUXSEG3EI32_V_M1_M2 + 0U, // PseudoVSUXSEG3EI32_V_M1_M2_MASK + 0U, // PseudoVSUXSEG3EI32_V_M1_MF2 + 0U, // PseudoVSUXSEG3EI32_V_M1_MF2_MASK + 0U, // PseudoVSUXSEG3EI32_V_M1_MF4 + 0U, // PseudoVSUXSEG3EI32_V_M1_MF4_MASK + 0U, // PseudoVSUXSEG3EI32_V_M2_M1 + 0U, // PseudoVSUXSEG3EI32_V_M2_M1_MASK + 0U, // PseudoVSUXSEG3EI32_V_M2_M2 + 0U, // PseudoVSUXSEG3EI32_V_M2_M2_MASK + 0U, // PseudoVSUXSEG3EI32_V_M2_MF2 + 0U, // PseudoVSUXSEG3EI32_V_M2_MF2_MASK + 0U, // PseudoVSUXSEG3EI32_V_M4_M1 + 0U, // PseudoVSUXSEG3EI32_V_M4_M1_MASK + 0U, // PseudoVSUXSEG3EI32_V_M4_M2 + 0U, // PseudoVSUXSEG3EI32_V_M4_M2_MASK + 0U, // PseudoVSUXSEG3EI32_V_M8_M2 + 0U, // PseudoVSUXSEG3EI32_V_M8_M2_MASK + 0U, // PseudoVSUXSEG3EI32_V_MF2_M1 + 0U, // PseudoVSUXSEG3EI32_V_MF2_M1_MASK + 0U, // PseudoVSUXSEG3EI32_V_MF2_MF2 + 0U, // PseudoVSUXSEG3EI32_V_MF2_MF2_MASK + 0U, // PseudoVSUXSEG3EI32_V_MF2_MF4 + 0U, // PseudoVSUXSEG3EI32_V_MF2_MF4_MASK + 0U, // PseudoVSUXSEG3EI32_V_MF2_MF8 + 0U, // PseudoVSUXSEG3EI32_V_MF2_MF8_MASK + 0U, // PseudoVSUXSEG3EI64_V_M1_M1 + 0U, // PseudoVSUXSEG3EI64_V_M1_M1_MASK + 0U, // PseudoVSUXSEG3EI64_V_M1_MF2 + 0U, // PseudoVSUXSEG3EI64_V_M1_MF2_MASK + 0U, // PseudoVSUXSEG3EI64_V_M1_MF4 + 0U, // PseudoVSUXSEG3EI64_V_M1_MF4_MASK + 0U, // PseudoVSUXSEG3EI64_V_M1_MF8 + 0U, // PseudoVSUXSEG3EI64_V_M1_MF8_MASK + 0U, // PseudoVSUXSEG3EI64_V_M2_M1 + 0U, // PseudoVSUXSEG3EI64_V_M2_M1_MASK + 0U, // PseudoVSUXSEG3EI64_V_M2_M2 + 0U, // PseudoVSUXSEG3EI64_V_M2_M2_MASK + 0U, // PseudoVSUXSEG3EI64_V_M2_MF2 + 0U, // PseudoVSUXSEG3EI64_V_M2_MF2_MASK + 0U, // PseudoVSUXSEG3EI64_V_M2_MF4 + 0U, // PseudoVSUXSEG3EI64_V_M2_MF4_MASK + 0U, // PseudoVSUXSEG3EI64_V_M4_M1 + 0U, // PseudoVSUXSEG3EI64_V_M4_M1_MASK + 0U, // PseudoVSUXSEG3EI64_V_M4_M2 + 0U, // PseudoVSUXSEG3EI64_V_M4_M2_MASK + 0U, // PseudoVSUXSEG3EI64_V_M4_MF2 + 0U, // PseudoVSUXSEG3EI64_V_M4_MF2_MASK + 0U, // PseudoVSUXSEG3EI64_V_M8_M1 + 0U, // PseudoVSUXSEG3EI64_V_M8_M1_MASK + 0U, // PseudoVSUXSEG3EI64_V_M8_M2 + 0U, // PseudoVSUXSEG3EI64_V_M8_M2_MASK + 0U, // PseudoVSUXSEG3EI8_V_M1_M1 + 0U, // PseudoVSUXSEG3EI8_V_M1_M1_MASK + 0U, // PseudoVSUXSEG3EI8_V_M1_M2 + 0U, // PseudoVSUXSEG3EI8_V_M1_M2_MASK + 0U, // PseudoVSUXSEG3EI8_V_M2_M2 + 0U, // PseudoVSUXSEG3EI8_V_M2_M2_MASK + 0U, // PseudoVSUXSEG3EI8_V_MF2_M1 + 0U, // PseudoVSUXSEG3EI8_V_MF2_M1_MASK + 0U, // PseudoVSUXSEG3EI8_V_MF2_M2 + 0U, // PseudoVSUXSEG3EI8_V_MF2_M2_MASK + 0U, // PseudoVSUXSEG3EI8_V_MF2_MF2 + 0U, // PseudoVSUXSEG3EI8_V_MF2_MF2_MASK + 0U, // PseudoVSUXSEG3EI8_V_MF4_M1 + 0U, // PseudoVSUXSEG3EI8_V_MF4_M1_MASK + 0U, // PseudoVSUXSEG3EI8_V_MF4_M2 + 0U, // PseudoVSUXSEG3EI8_V_MF4_M2_MASK + 0U, // PseudoVSUXSEG3EI8_V_MF4_MF2 + 0U, // PseudoVSUXSEG3EI8_V_MF4_MF2_MASK + 0U, // PseudoVSUXSEG3EI8_V_MF4_MF4 + 0U, // PseudoVSUXSEG3EI8_V_MF4_MF4_MASK + 0U, // PseudoVSUXSEG3EI8_V_MF8_M1 + 0U, // PseudoVSUXSEG3EI8_V_MF8_M1_MASK + 0U, // PseudoVSUXSEG3EI8_V_MF8_MF2 + 0U, // PseudoVSUXSEG3EI8_V_MF8_MF2_MASK + 0U, // PseudoVSUXSEG3EI8_V_MF8_MF4 + 0U, // PseudoVSUXSEG3EI8_V_MF8_MF4_MASK + 0U, // PseudoVSUXSEG3EI8_V_MF8_MF8 + 0U, // PseudoVSUXSEG3EI8_V_MF8_MF8_MASK + 0U, // PseudoVSUXSEG4EI16_V_M1_M1 + 0U, // PseudoVSUXSEG4EI16_V_M1_M1_MASK + 0U, // PseudoVSUXSEG4EI16_V_M1_M2 + 0U, // PseudoVSUXSEG4EI16_V_M1_M2_MASK + 0U, // PseudoVSUXSEG4EI16_V_M1_MF2 + 0U, // PseudoVSUXSEG4EI16_V_M1_MF2_MASK + 0U, // PseudoVSUXSEG4EI16_V_M2_M1 + 0U, // PseudoVSUXSEG4EI16_V_M2_M1_MASK + 0U, // PseudoVSUXSEG4EI16_V_M2_M2 + 0U, // PseudoVSUXSEG4EI16_V_M2_M2_MASK + 0U, // PseudoVSUXSEG4EI16_V_M4_M2 + 0U, // PseudoVSUXSEG4EI16_V_M4_M2_MASK + 0U, // PseudoVSUXSEG4EI16_V_MF2_M1 + 0U, // PseudoVSUXSEG4EI16_V_MF2_M1_MASK + 0U, // PseudoVSUXSEG4EI16_V_MF2_M2 + 0U, // PseudoVSUXSEG4EI16_V_MF2_M2_MASK + 0U, // PseudoVSUXSEG4EI16_V_MF2_MF2 + 0U, // PseudoVSUXSEG4EI16_V_MF2_MF2_MASK + 0U, // PseudoVSUXSEG4EI16_V_MF2_MF4 + 0U, // PseudoVSUXSEG4EI16_V_MF2_MF4_MASK + 0U, // PseudoVSUXSEG4EI16_V_MF4_M1 + 0U, // PseudoVSUXSEG4EI16_V_MF4_M1_MASK + 0U, // PseudoVSUXSEG4EI16_V_MF4_MF2 + 0U, // PseudoVSUXSEG4EI16_V_MF4_MF2_MASK + 0U, // PseudoVSUXSEG4EI16_V_MF4_MF4 + 0U, // PseudoVSUXSEG4EI16_V_MF4_MF4_MASK + 0U, // PseudoVSUXSEG4EI16_V_MF4_MF8 + 0U, // PseudoVSUXSEG4EI16_V_MF4_MF8_MASK + 0U, // PseudoVSUXSEG4EI32_V_M1_M1 + 0U, // PseudoVSUXSEG4EI32_V_M1_M1_MASK + 0U, // PseudoVSUXSEG4EI32_V_M1_M2 + 0U, // PseudoVSUXSEG4EI32_V_M1_M2_MASK + 0U, // PseudoVSUXSEG4EI32_V_M1_MF2 + 0U, // PseudoVSUXSEG4EI32_V_M1_MF2_MASK + 0U, // PseudoVSUXSEG4EI32_V_M1_MF4 + 0U, // PseudoVSUXSEG4EI32_V_M1_MF4_MASK + 0U, // PseudoVSUXSEG4EI32_V_M2_M1 + 0U, // PseudoVSUXSEG4EI32_V_M2_M1_MASK + 0U, // PseudoVSUXSEG4EI32_V_M2_M2 + 0U, // PseudoVSUXSEG4EI32_V_M2_M2_MASK + 0U, // PseudoVSUXSEG4EI32_V_M2_MF2 + 0U, // PseudoVSUXSEG4EI32_V_M2_MF2_MASK + 0U, // PseudoVSUXSEG4EI32_V_M4_M1 + 0U, // PseudoVSUXSEG4EI32_V_M4_M1_MASK + 0U, // PseudoVSUXSEG4EI32_V_M4_M2 + 0U, // PseudoVSUXSEG4EI32_V_M4_M2_MASK + 0U, // PseudoVSUXSEG4EI32_V_M8_M2 + 0U, // PseudoVSUXSEG4EI32_V_M8_M2_MASK + 0U, // PseudoVSUXSEG4EI32_V_MF2_M1 + 0U, // PseudoVSUXSEG4EI32_V_MF2_M1_MASK + 0U, // PseudoVSUXSEG4EI32_V_MF2_MF2 + 0U, // PseudoVSUXSEG4EI32_V_MF2_MF2_MASK + 0U, // PseudoVSUXSEG4EI32_V_MF2_MF4 + 0U, // PseudoVSUXSEG4EI32_V_MF2_MF4_MASK + 0U, // PseudoVSUXSEG4EI32_V_MF2_MF8 + 0U, // PseudoVSUXSEG4EI32_V_MF2_MF8_MASK + 0U, // PseudoVSUXSEG4EI64_V_M1_M1 + 0U, // PseudoVSUXSEG4EI64_V_M1_M1_MASK + 0U, // PseudoVSUXSEG4EI64_V_M1_MF2 + 0U, // PseudoVSUXSEG4EI64_V_M1_MF2_MASK + 0U, // PseudoVSUXSEG4EI64_V_M1_MF4 + 0U, // PseudoVSUXSEG4EI64_V_M1_MF4_MASK + 0U, // PseudoVSUXSEG4EI64_V_M1_MF8 + 0U, // PseudoVSUXSEG4EI64_V_M1_MF8_MASK + 0U, // PseudoVSUXSEG4EI64_V_M2_M1 + 0U, // PseudoVSUXSEG4EI64_V_M2_M1_MASK + 0U, // PseudoVSUXSEG4EI64_V_M2_M2 + 0U, // PseudoVSUXSEG4EI64_V_M2_M2_MASK + 0U, // PseudoVSUXSEG4EI64_V_M2_MF2 + 0U, // PseudoVSUXSEG4EI64_V_M2_MF2_MASK + 0U, // PseudoVSUXSEG4EI64_V_M2_MF4 + 0U, // PseudoVSUXSEG4EI64_V_M2_MF4_MASK + 0U, // PseudoVSUXSEG4EI64_V_M4_M1 + 0U, // PseudoVSUXSEG4EI64_V_M4_M1_MASK + 0U, // PseudoVSUXSEG4EI64_V_M4_M2 + 0U, // PseudoVSUXSEG4EI64_V_M4_M2_MASK + 0U, // PseudoVSUXSEG4EI64_V_M4_MF2 + 0U, // PseudoVSUXSEG4EI64_V_M4_MF2_MASK + 0U, // PseudoVSUXSEG4EI64_V_M8_M1 + 0U, // PseudoVSUXSEG4EI64_V_M8_M1_MASK + 0U, // PseudoVSUXSEG4EI64_V_M8_M2 + 0U, // PseudoVSUXSEG4EI64_V_M8_M2_MASK + 0U, // PseudoVSUXSEG4EI8_V_M1_M1 + 0U, // PseudoVSUXSEG4EI8_V_M1_M1_MASK + 0U, // PseudoVSUXSEG4EI8_V_M1_M2 + 0U, // PseudoVSUXSEG4EI8_V_M1_M2_MASK + 0U, // PseudoVSUXSEG4EI8_V_M2_M2 + 0U, // PseudoVSUXSEG4EI8_V_M2_M2_MASK + 0U, // PseudoVSUXSEG4EI8_V_MF2_M1 + 0U, // PseudoVSUXSEG4EI8_V_MF2_M1_MASK + 0U, // PseudoVSUXSEG4EI8_V_MF2_M2 + 0U, // PseudoVSUXSEG4EI8_V_MF2_M2_MASK + 0U, // PseudoVSUXSEG4EI8_V_MF2_MF2 + 0U, // PseudoVSUXSEG4EI8_V_MF2_MF2_MASK + 0U, // PseudoVSUXSEG4EI8_V_MF4_M1 + 0U, // PseudoVSUXSEG4EI8_V_MF4_M1_MASK + 0U, // PseudoVSUXSEG4EI8_V_MF4_M2 + 0U, // PseudoVSUXSEG4EI8_V_MF4_M2_MASK + 0U, // PseudoVSUXSEG4EI8_V_MF4_MF2 + 0U, // PseudoVSUXSEG4EI8_V_MF4_MF2_MASK + 0U, // PseudoVSUXSEG4EI8_V_MF4_MF4 + 0U, // PseudoVSUXSEG4EI8_V_MF4_MF4_MASK + 0U, // PseudoVSUXSEG4EI8_V_MF8_M1 + 0U, // PseudoVSUXSEG4EI8_V_MF8_M1_MASK + 0U, // PseudoVSUXSEG4EI8_V_MF8_MF2 + 0U, // PseudoVSUXSEG4EI8_V_MF8_MF2_MASK + 0U, // PseudoVSUXSEG4EI8_V_MF8_MF4 + 0U, // PseudoVSUXSEG4EI8_V_MF8_MF4_MASK + 0U, // PseudoVSUXSEG4EI8_V_MF8_MF8 + 0U, // PseudoVSUXSEG4EI8_V_MF8_MF8_MASK + 0U, // PseudoVSUXSEG5EI16_V_M1_M1 + 0U, // PseudoVSUXSEG5EI16_V_M1_M1_MASK + 0U, // PseudoVSUXSEG5EI16_V_M1_MF2 + 0U, // PseudoVSUXSEG5EI16_V_M1_MF2_MASK + 0U, // PseudoVSUXSEG5EI16_V_M2_M1 + 0U, // PseudoVSUXSEG5EI16_V_M2_M1_MASK + 0U, // PseudoVSUXSEG5EI16_V_MF2_M1 + 0U, // PseudoVSUXSEG5EI16_V_MF2_M1_MASK + 0U, // PseudoVSUXSEG5EI16_V_MF2_MF2 + 0U, // PseudoVSUXSEG5EI16_V_MF2_MF2_MASK + 0U, // PseudoVSUXSEG5EI16_V_MF2_MF4 + 0U, // PseudoVSUXSEG5EI16_V_MF2_MF4_MASK + 0U, // PseudoVSUXSEG5EI16_V_MF4_M1 + 0U, // PseudoVSUXSEG5EI16_V_MF4_M1_MASK + 0U, // PseudoVSUXSEG5EI16_V_MF4_MF2 + 0U, // PseudoVSUXSEG5EI16_V_MF4_MF2_MASK + 0U, // PseudoVSUXSEG5EI16_V_MF4_MF4 + 0U, // PseudoVSUXSEG5EI16_V_MF4_MF4_MASK + 0U, // PseudoVSUXSEG5EI16_V_MF4_MF8 + 0U, // PseudoVSUXSEG5EI16_V_MF4_MF8_MASK + 0U, // PseudoVSUXSEG5EI32_V_M1_M1 + 0U, // PseudoVSUXSEG5EI32_V_M1_M1_MASK + 0U, // PseudoVSUXSEG5EI32_V_M1_MF2 + 0U, // PseudoVSUXSEG5EI32_V_M1_MF2_MASK + 0U, // PseudoVSUXSEG5EI32_V_M1_MF4 + 0U, // PseudoVSUXSEG5EI32_V_M1_MF4_MASK + 0U, // PseudoVSUXSEG5EI32_V_M2_M1 + 0U, // PseudoVSUXSEG5EI32_V_M2_M1_MASK + 0U, // PseudoVSUXSEG5EI32_V_M2_MF2 + 0U, // PseudoVSUXSEG5EI32_V_M2_MF2_MASK + 0U, // PseudoVSUXSEG5EI32_V_M4_M1 + 0U, // PseudoVSUXSEG5EI32_V_M4_M1_MASK + 0U, // PseudoVSUXSEG5EI32_V_MF2_M1 + 0U, // PseudoVSUXSEG5EI32_V_MF2_M1_MASK + 0U, // PseudoVSUXSEG5EI32_V_MF2_MF2 + 0U, // PseudoVSUXSEG5EI32_V_MF2_MF2_MASK + 0U, // PseudoVSUXSEG5EI32_V_MF2_MF4 + 0U, // PseudoVSUXSEG5EI32_V_MF2_MF4_MASK + 0U, // PseudoVSUXSEG5EI32_V_MF2_MF8 + 0U, // PseudoVSUXSEG5EI32_V_MF2_MF8_MASK + 0U, // PseudoVSUXSEG5EI64_V_M1_M1 + 0U, // PseudoVSUXSEG5EI64_V_M1_M1_MASK + 0U, // PseudoVSUXSEG5EI64_V_M1_MF2 + 0U, // PseudoVSUXSEG5EI64_V_M1_MF2_MASK + 0U, // PseudoVSUXSEG5EI64_V_M1_MF4 + 0U, // PseudoVSUXSEG5EI64_V_M1_MF4_MASK + 0U, // PseudoVSUXSEG5EI64_V_M1_MF8 + 0U, // PseudoVSUXSEG5EI64_V_M1_MF8_MASK + 0U, // PseudoVSUXSEG5EI64_V_M2_M1 + 0U, // PseudoVSUXSEG5EI64_V_M2_M1_MASK + 0U, // PseudoVSUXSEG5EI64_V_M2_MF2 + 0U, // PseudoVSUXSEG5EI64_V_M2_MF2_MASK + 0U, // PseudoVSUXSEG5EI64_V_M2_MF4 + 0U, // PseudoVSUXSEG5EI64_V_M2_MF4_MASK + 0U, // PseudoVSUXSEG5EI64_V_M4_M1 + 0U, // PseudoVSUXSEG5EI64_V_M4_M1_MASK + 0U, // PseudoVSUXSEG5EI64_V_M4_MF2 + 0U, // PseudoVSUXSEG5EI64_V_M4_MF2_MASK + 0U, // PseudoVSUXSEG5EI64_V_M8_M1 + 0U, // PseudoVSUXSEG5EI64_V_M8_M1_MASK + 0U, // PseudoVSUXSEG5EI8_V_M1_M1 + 0U, // PseudoVSUXSEG5EI8_V_M1_M1_MASK + 0U, // PseudoVSUXSEG5EI8_V_MF2_M1 + 0U, // PseudoVSUXSEG5EI8_V_MF2_M1_MASK + 0U, // PseudoVSUXSEG5EI8_V_MF2_MF2 + 0U, // PseudoVSUXSEG5EI8_V_MF2_MF2_MASK + 0U, // PseudoVSUXSEG5EI8_V_MF4_M1 + 0U, // PseudoVSUXSEG5EI8_V_MF4_M1_MASK + 0U, // PseudoVSUXSEG5EI8_V_MF4_MF2 + 0U, // PseudoVSUXSEG5EI8_V_MF4_MF2_MASK + 0U, // PseudoVSUXSEG5EI8_V_MF4_MF4 + 0U, // PseudoVSUXSEG5EI8_V_MF4_MF4_MASK + 0U, // PseudoVSUXSEG5EI8_V_MF8_M1 + 0U, // PseudoVSUXSEG5EI8_V_MF8_M1_MASK + 0U, // PseudoVSUXSEG5EI8_V_MF8_MF2 + 0U, // PseudoVSUXSEG5EI8_V_MF8_MF2_MASK + 0U, // PseudoVSUXSEG5EI8_V_MF8_MF4 + 0U, // PseudoVSUXSEG5EI8_V_MF8_MF4_MASK + 0U, // PseudoVSUXSEG5EI8_V_MF8_MF8 + 0U, // PseudoVSUXSEG5EI8_V_MF8_MF8_MASK + 0U, // PseudoVSUXSEG6EI16_V_M1_M1 + 0U, // PseudoVSUXSEG6EI16_V_M1_M1_MASK + 0U, // PseudoVSUXSEG6EI16_V_M1_MF2 + 0U, // PseudoVSUXSEG6EI16_V_M1_MF2_MASK + 0U, // PseudoVSUXSEG6EI16_V_M2_M1 + 0U, // PseudoVSUXSEG6EI16_V_M2_M1_MASK + 0U, // PseudoVSUXSEG6EI16_V_MF2_M1 + 0U, // PseudoVSUXSEG6EI16_V_MF2_M1_MASK + 0U, // PseudoVSUXSEG6EI16_V_MF2_MF2 + 0U, // PseudoVSUXSEG6EI16_V_MF2_MF2_MASK + 0U, // PseudoVSUXSEG6EI16_V_MF2_MF4 + 0U, // PseudoVSUXSEG6EI16_V_MF2_MF4_MASK + 0U, // PseudoVSUXSEG6EI16_V_MF4_M1 + 0U, // PseudoVSUXSEG6EI16_V_MF4_M1_MASK + 0U, // PseudoVSUXSEG6EI16_V_MF4_MF2 + 0U, // PseudoVSUXSEG6EI16_V_MF4_MF2_MASK + 0U, // PseudoVSUXSEG6EI16_V_MF4_MF4 + 0U, // PseudoVSUXSEG6EI16_V_MF4_MF4_MASK + 0U, // PseudoVSUXSEG6EI16_V_MF4_MF8 + 0U, // PseudoVSUXSEG6EI16_V_MF4_MF8_MASK + 0U, // PseudoVSUXSEG6EI32_V_M1_M1 + 0U, // PseudoVSUXSEG6EI32_V_M1_M1_MASK + 0U, // PseudoVSUXSEG6EI32_V_M1_MF2 + 0U, // PseudoVSUXSEG6EI32_V_M1_MF2_MASK + 0U, // PseudoVSUXSEG6EI32_V_M1_MF4 + 0U, // PseudoVSUXSEG6EI32_V_M1_MF4_MASK + 0U, // PseudoVSUXSEG6EI32_V_M2_M1 + 0U, // PseudoVSUXSEG6EI32_V_M2_M1_MASK + 0U, // PseudoVSUXSEG6EI32_V_M2_MF2 + 0U, // PseudoVSUXSEG6EI32_V_M2_MF2_MASK + 0U, // PseudoVSUXSEG6EI32_V_M4_M1 + 0U, // PseudoVSUXSEG6EI32_V_M4_M1_MASK + 0U, // PseudoVSUXSEG6EI32_V_MF2_M1 + 0U, // PseudoVSUXSEG6EI32_V_MF2_M1_MASK + 0U, // PseudoVSUXSEG6EI32_V_MF2_MF2 + 0U, // PseudoVSUXSEG6EI32_V_MF2_MF2_MASK + 0U, // PseudoVSUXSEG6EI32_V_MF2_MF4 + 0U, // PseudoVSUXSEG6EI32_V_MF2_MF4_MASK + 0U, // PseudoVSUXSEG6EI32_V_MF2_MF8 + 0U, // PseudoVSUXSEG6EI32_V_MF2_MF8_MASK + 0U, // PseudoVSUXSEG6EI64_V_M1_M1 + 0U, // PseudoVSUXSEG6EI64_V_M1_M1_MASK + 0U, // PseudoVSUXSEG6EI64_V_M1_MF2 + 0U, // PseudoVSUXSEG6EI64_V_M1_MF2_MASK + 0U, // PseudoVSUXSEG6EI64_V_M1_MF4 + 0U, // PseudoVSUXSEG6EI64_V_M1_MF4_MASK + 0U, // PseudoVSUXSEG6EI64_V_M1_MF8 + 0U, // PseudoVSUXSEG6EI64_V_M1_MF8_MASK + 0U, // PseudoVSUXSEG6EI64_V_M2_M1 + 0U, // PseudoVSUXSEG6EI64_V_M2_M1_MASK + 0U, // PseudoVSUXSEG6EI64_V_M2_MF2 + 0U, // PseudoVSUXSEG6EI64_V_M2_MF2_MASK + 0U, // PseudoVSUXSEG6EI64_V_M2_MF4 + 0U, // PseudoVSUXSEG6EI64_V_M2_MF4_MASK + 0U, // PseudoVSUXSEG6EI64_V_M4_M1 + 0U, // PseudoVSUXSEG6EI64_V_M4_M1_MASK + 0U, // PseudoVSUXSEG6EI64_V_M4_MF2 + 0U, // PseudoVSUXSEG6EI64_V_M4_MF2_MASK + 0U, // PseudoVSUXSEG6EI64_V_M8_M1 + 0U, // PseudoVSUXSEG6EI64_V_M8_M1_MASK + 0U, // PseudoVSUXSEG6EI8_V_M1_M1 + 0U, // PseudoVSUXSEG6EI8_V_M1_M1_MASK + 0U, // PseudoVSUXSEG6EI8_V_MF2_M1 + 0U, // PseudoVSUXSEG6EI8_V_MF2_M1_MASK + 0U, // PseudoVSUXSEG6EI8_V_MF2_MF2 + 0U, // PseudoVSUXSEG6EI8_V_MF2_MF2_MASK + 0U, // PseudoVSUXSEG6EI8_V_MF4_M1 + 0U, // PseudoVSUXSEG6EI8_V_MF4_M1_MASK + 0U, // PseudoVSUXSEG6EI8_V_MF4_MF2 + 0U, // PseudoVSUXSEG6EI8_V_MF4_MF2_MASK + 0U, // PseudoVSUXSEG6EI8_V_MF4_MF4 + 0U, // PseudoVSUXSEG6EI8_V_MF4_MF4_MASK + 0U, // PseudoVSUXSEG6EI8_V_MF8_M1 + 0U, // PseudoVSUXSEG6EI8_V_MF8_M1_MASK + 0U, // PseudoVSUXSEG6EI8_V_MF8_MF2 + 0U, // PseudoVSUXSEG6EI8_V_MF8_MF2_MASK + 0U, // PseudoVSUXSEG6EI8_V_MF8_MF4 + 0U, // PseudoVSUXSEG6EI8_V_MF8_MF4_MASK + 0U, // PseudoVSUXSEG6EI8_V_MF8_MF8 + 0U, // PseudoVSUXSEG6EI8_V_MF8_MF8_MASK + 0U, // PseudoVSUXSEG7EI16_V_M1_M1 + 0U, // PseudoVSUXSEG7EI16_V_M1_M1_MASK + 0U, // PseudoVSUXSEG7EI16_V_M1_MF2 + 0U, // PseudoVSUXSEG7EI16_V_M1_MF2_MASK + 0U, // PseudoVSUXSEG7EI16_V_M2_M1 + 0U, // PseudoVSUXSEG7EI16_V_M2_M1_MASK + 0U, // PseudoVSUXSEG7EI16_V_MF2_M1 + 0U, // PseudoVSUXSEG7EI16_V_MF2_M1_MASK + 0U, // PseudoVSUXSEG7EI16_V_MF2_MF2 + 0U, // PseudoVSUXSEG7EI16_V_MF2_MF2_MASK + 0U, // PseudoVSUXSEG7EI16_V_MF2_MF4 + 0U, // PseudoVSUXSEG7EI16_V_MF2_MF4_MASK + 0U, // PseudoVSUXSEG7EI16_V_MF4_M1 + 0U, // PseudoVSUXSEG7EI16_V_MF4_M1_MASK + 0U, // PseudoVSUXSEG7EI16_V_MF4_MF2 + 0U, // PseudoVSUXSEG7EI16_V_MF4_MF2_MASK + 0U, // PseudoVSUXSEG7EI16_V_MF4_MF4 + 0U, // PseudoVSUXSEG7EI16_V_MF4_MF4_MASK + 0U, // PseudoVSUXSEG7EI16_V_MF4_MF8 + 0U, // PseudoVSUXSEG7EI16_V_MF4_MF8_MASK + 0U, // PseudoVSUXSEG7EI32_V_M1_M1 + 0U, // PseudoVSUXSEG7EI32_V_M1_M1_MASK + 0U, // PseudoVSUXSEG7EI32_V_M1_MF2 + 0U, // PseudoVSUXSEG7EI32_V_M1_MF2_MASK + 0U, // PseudoVSUXSEG7EI32_V_M1_MF4 + 0U, // PseudoVSUXSEG7EI32_V_M1_MF4_MASK + 0U, // PseudoVSUXSEG7EI32_V_M2_M1 + 0U, // PseudoVSUXSEG7EI32_V_M2_M1_MASK + 0U, // PseudoVSUXSEG7EI32_V_M2_MF2 + 0U, // PseudoVSUXSEG7EI32_V_M2_MF2_MASK + 0U, // PseudoVSUXSEG7EI32_V_M4_M1 + 0U, // PseudoVSUXSEG7EI32_V_M4_M1_MASK + 0U, // PseudoVSUXSEG7EI32_V_MF2_M1 + 0U, // PseudoVSUXSEG7EI32_V_MF2_M1_MASK + 0U, // PseudoVSUXSEG7EI32_V_MF2_MF2 + 0U, // PseudoVSUXSEG7EI32_V_MF2_MF2_MASK + 0U, // PseudoVSUXSEG7EI32_V_MF2_MF4 + 0U, // PseudoVSUXSEG7EI32_V_MF2_MF4_MASK + 0U, // PseudoVSUXSEG7EI32_V_MF2_MF8 + 0U, // PseudoVSUXSEG7EI32_V_MF2_MF8_MASK + 0U, // PseudoVSUXSEG7EI64_V_M1_M1 + 0U, // PseudoVSUXSEG7EI64_V_M1_M1_MASK + 0U, // PseudoVSUXSEG7EI64_V_M1_MF2 + 0U, // PseudoVSUXSEG7EI64_V_M1_MF2_MASK + 0U, // PseudoVSUXSEG7EI64_V_M1_MF4 + 0U, // PseudoVSUXSEG7EI64_V_M1_MF4_MASK + 0U, // PseudoVSUXSEG7EI64_V_M1_MF8 + 0U, // PseudoVSUXSEG7EI64_V_M1_MF8_MASK + 0U, // PseudoVSUXSEG7EI64_V_M2_M1 + 0U, // PseudoVSUXSEG7EI64_V_M2_M1_MASK + 0U, // PseudoVSUXSEG7EI64_V_M2_MF2 + 0U, // PseudoVSUXSEG7EI64_V_M2_MF2_MASK + 0U, // PseudoVSUXSEG7EI64_V_M2_MF4 + 0U, // PseudoVSUXSEG7EI64_V_M2_MF4_MASK + 0U, // PseudoVSUXSEG7EI64_V_M4_M1 + 0U, // PseudoVSUXSEG7EI64_V_M4_M1_MASK + 0U, // PseudoVSUXSEG7EI64_V_M4_MF2 + 0U, // PseudoVSUXSEG7EI64_V_M4_MF2_MASK + 0U, // PseudoVSUXSEG7EI64_V_M8_M1 + 0U, // PseudoVSUXSEG7EI64_V_M8_M1_MASK + 0U, // PseudoVSUXSEG7EI8_V_M1_M1 + 0U, // PseudoVSUXSEG7EI8_V_M1_M1_MASK + 0U, // PseudoVSUXSEG7EI8_V_MF2_M1 + 0U, // PseudoVSUXSEG7EI8_V_MF2_M1_MASK + 0U, // PseudoVSUXSEG7EI8_V_MF2_MF2 + 0U, // PseudoVSUXSEG7EI8_V_MF2_MF2_MASK + 0U, // PseudoVSUXSEG7EI8_V_MF4_M1 + 0U, // PseudoVSUXSEG7EI8_V_MF4_M1_MASK + 0U, // PseudoVSUXSEG7EI8_V_MF4_MF2 + 0U, // PseudoVSUXSEG7EI8_V_MF4_MF2_MASK + 0U, // PseudoVSUXSEG7EI8_V_MF4_MF4 + 0U, // PseudoVSUXSEG7EI8_V_MF4_MF4_MASK + 0U, // PseudoVSUXSEG7EI8_V_MF8_M1 + 0U, // PseudoVSUXSEG7EI8_V_MF8_M1_MASK + 0U, // PseudoVSUXSEG7EI8_V_MF8_MF2 + 0U, // PseudoVSUXSEG7EI8_V_MF8_MF2_MASK + 0U, // PseudoVSUXSEG7EI8_V_MF8_MF4 + 0U, // PseudoVSUXSEG7EI8_V_MF8_MF4_MASK + 0U, // PseudoVSUXSEG7EI8_V_MF8_MF8 + 0U, // PseudoVSUXSEG7EI8_V_MF8_MF8_MASK + 0U, // PseudoVSUXSEG8EI16_V_M1_M1 + 0U, // PseudoVSUXSEG8EI16_V_M1_M1_MASK + 0U, // PseudoVSUXSEG8EI16_V_M1_MF2 + 0U, // PseudoVSUXSEG8EI16_V_M1_MF2_MASK + 0U, // PseudoVSUXSEG8EI16_V_M2_M1 + 0U, // PseudoVSUXSEG8EI16_V_M2_M1_MASK + 0U, // PseudoVSUXSEG8EI16_V_MF2_M1 + 0U, // PseudoVSUXSEG8EI16_V_MF2_M1_MASK + 0U, // PseudoVSUXSEG8EI16_V_MF2_MF2 + 0U, // PseudoVSUXSEG8EI16_V_MF2_MF2_MASK + 0U, // PseudoVSUXSEG8EI16_V_MF2_MF4 + 0U, // PseudoVSUXSEG8EI16_V_MF2_MF4_MASK + 0U, // PseudoVSUXSEG8EI16_V_MF4_M1 + 0U, // PseudoVSUXSEG8EI16_V_MF4_M1_MASK + 0U, // PseudoVSUXSEG8EI16_V_MF4_MF2 + 0U, // PseudoVSUXSEG8EI16_V_MF4_MF2_MASK + 0U, // PseudoVSUXSEG8EI16_V_MF4_MF4 + 0U, // PseudoVSUXSEG8EI16_V_MF4_MF4_MASK + 0U, // PseudoVSUXSEG8EI16_V_MF4_MF8 + 0U, // PseudoVSUXSEG8EI16_V_MF4_MF8_MASK + 0U, // PseudoVSUXSEG8EI32_V_M1_M1 + 0U, // PseudoVSUXSEG8EI32_V_M1_M1_MASK + 0U, // PseudoVSUXSEG8EI32_V_M1_MF2 + 0U, // PseudoVSUXSEG8EI32_V_M1_MF2_MASK + 0U, // PseudoVSUXSEG8EI32_V_M1_MF4 + 0U, // PseudoVSUXSEG8EI32_V_M1_MF4_MASK + 0U, // PseudoVSUXSEG8EI32_V_M2_M1 + 0U, // PseudoVSUXSEG8EI32_V_M2_M1_MASK + 0U, // PseudoVSUXSEG8EI32_V_M2_MF2 + 0U, // PseudoVSUXSEG8EI32_V_M2_MF2_MASK + 0U, // PseudoVSUXSEG8EI32_V_M4_M1 + 0U, // PseudoVSUXSEG8EI32_V_M4_M1_MASK + 0U, // PseudoVSUXSEG8EI32_V_MF2_M1 + 0U, // PseudoVSUXSEG8EI32_V_MF2_M1_MASK + 0U, // PseudoVSUXSEG8EI32_V_MF2_MF2 + 0U, // PseudoVSUXSEG8EI32_V_MF2_MF2_MASK + 0U, // PseudoVSUXSEG8EI32_V_MF2_MF4 + 0U, // PseudoVSUXSEG8EI32_V_MF2_MF4_MASK + 0U, // PseudoVSUXSEG8EI32_V_MF2_MF8 + 0U, // PseudoVSUXSEG8EI32_V_MF2_MF8_MASK + 0U, // PseudoVSUXSEG8EI64_V_M1_M1 + 0U, // PseudoVSUXSEG8EI64_V_M1_M1_MASK + 0U, // PseudoVSUXSEG8EI64_V_M1_MF2 + 0U, // PseudoVSUXSEG8EI64_V_M1_MF2_MASK + 0U, // PseudoVSUXSEG8EI64_V_M1_MF4 + 0U, // PseudoVSUXSEG8EI64_V_M1_MF4_MASK + 0U, // PseudoVSUXSEG8EI64_V_M1_MF8 + 0U, // PseudoVSUXSEG8EI64_V_M1_MF8_MASK + 0U, // PseudoVSUXSEG8EI64_V_M2_M1 + 0U, // PseudoVSUXSEG8EI64_V_M2_M1_MASK + 0U, // PseudoVSUXSEG8EI64_V_M2_MF2 + 0U, // PseudoVSUXSEG8EI64_V_M2_MF2_MASK + 0U, // PseudoVSUXSEG8EI64_V_M2_MF4 + 0U, // PseudoVSUXSEG8EI64_V_M2_MF4_MASK + 0U, // PseudoVSUXSEG8EI64_V_M4_M1 + 0U, // PseudoVSUXSEG8EI64_V_M4_M1_MASK + 0U, // PseudoVSUXSEG8EI64_V_M4_MF2 + 0U, // PseudoVSUXSEG8EI64_V_M4_MF2_MASK + 0U, // PseudoVSUXSEG8EI64_V_M8_M1 + 0U, // PseudoVSUXSEG8EI64_V_M8_M1_MASK + 0U, // PseudoVSUXSEG8EI8_V_M1_M1 + 0U, // PseudoVSUXSEG8EI8_V_M1_M1_MASK + 0U, // PseudoVSUXSEG8EI8_V_MF2_M1 + 0U, // PseudoVSUXSEG8EI8_V_MF2_M1_MASK + 0U, // PseudoVSUXSEG8EI8_V_MF2_MF2 + 0U, // PseudoVSUXSEG8EI8_V_MF2_MF2_MASK + 0U, // PseudoVSUXSEG8EI8_V_MF4_M1 + 0U, // PseudoVSUXSEG8EI8_V_MF4_M1_MASK + 0U, // PseudoVSUXSEG8EI8_V_MF4_MF2 + 0U, // PseudoVSUXSEG8EI8_V_MF4_MF2_MASK + 0U, // PseudoVSUXSEG8EI8_V_MF4_MF4 + 0U, // PseudoVSUXSEG8EI8_V_MF4_MF4_MASK + 0U, // PseudoVSUXSEG8EI8_V_MF8_M1 + 0U, // PseudoVSUXSEG8EI8_V_MF8_M1_MASK + 0U, // PseudoVSUXSEG8EI8_V_MF8_MF2 + 0U, // PseudoVSUXSEG8EI8_V_MF8_MF2_MASK + 0U, // PseudoVSUXSEG8EI8_V_MF8_MF4 + 0U, // PseudoVSUXSEG8EI8_V_MF8_MF4_MASK + 0U, // PseudoVSUXSEG8EI8_V_MF8_MF8 + 0U, // PseudoVSUXSEG8EI8_V_MF8_MF8_MASK + 0U, // PseudoVWADDU_VV_M1 + 0U, // PseudoVWADDU_VV_M1_MASK + 0U, // PseudoVWADDU_VV_M2 + 0U, // PseudoVWADDU_VV_M2_MASK + 0U, // PseudoVWADDU_VV_M4 + 0U, // PseudoVWADDU_VV_M4_MASK + 0U, // PseudoVWADDU_VV_MF2 + 0U, // PseudoVWADDU_VV_MF2_MASK + 0U, // PseudoVWADDU_VV_MF4 + 0U, // PseudoVWADDU_VV_MF4_MASK + 0U, // PseudoVWADDU_VV_MF8 + 0U, // PseudoVWADDU_VV_MF8_MASK + 0U, // PseudoVWADDU_VX_M1 + 0U, // PseudoVWADDU_VX_M1_MASK + 0U, // PseudoVWADDU_VX_M2 + 0U, // PseudoVWADDU_VX_M2_MASK + 0U, // PseudoVWADDU_VX_M4 + 0U, // PseudoVWADDU_VX_M4_MASK + 0U, // PseudoVWADDU_VX_MF2 + 0U, // PseudoVWADDU_VX_MF2_MASK + 0U, // PseudoVWADDU_VX_MF4 + 0U, // PseudoVWADDU_VX_MF4_MASK + 0U, // PseudoVWADDU_VX_MF8 + 0U, // PseudoVWADDU_VX_MF8_MASK + 0U, // PseudoVWADDU_WV_M1 + 0U, // PseudoVWADDU_WV_M1_MASK + 0U, // PseudoVWADDU_WV_M1_MASK_TIED + 0U, // PseudoVWADDU_WV_M1_TIED + 0U, // PseudoVWADDU_WV_M2 + 0U, // PseudoVWADDU_WV_M2_MASK + 0U, // PseudoVWADDU_WV_M2_MASK_TIED + 0U, // PseudoVWADDU_WV_M2_TIED + 0U, // PseudoVWADDU_WV_M4 + 0U, // PseudoVWADDU_WV_M4_MASK + 0U, // PseudoVWADDU_WV_M4_MASK_TIED + 0U, // PseudoVWADDU_WV_M4_TIED + 0U, // PseudoVWADDU_WV_MF2 + 0U, // PseudoVWADDU_WV_MF2_MASK + 0U, // PseudoVWADDU_WV_MF2_MASK_TIED + 0U, // PseudoVWADDU_WV_MF2_TIED + 0U, // PseudoVWADDU_WV_MF4 + 0U, // PseudoVWADDU_WV_MF4_MASK + 0U, // PseudoVWADDU_WV_MF4_MASK_TIED + 0U, // PseudoVWADDU_WV_MF4_TIED + 0U, // PseudoVWADDU_WV_MF8 + 0U, // PseudoVWADDU_WV_MF8_MASK + 0U, // PseudoVWADDU_WV_MF8_MASK_TIED + 0U, // PseudoVWADDU_WV_MF8_TIED + 0U, // PseudoVWADDU_WX_M1 + 0U, // PseudoVWADDU_WX_M1_MASK + 0U, // PseudoVWADDU_WX_M2 + 0U, // PseudoVWADDU_WX_M2_MASK + 0U, // PseudoVWADDU_WX_M4 + 0U, // PseudoVWADDU_WX_M4_MASK + 0U, // PseudoVWADDU_WX_MF2 + 0U, // PseudoVWADDU_WX_MF2_MASK + 0U, // PseudoVWADDU_WX_MF4 + 0U, // PseudoVWADDU_WX_MF4_MASK + 0U, // PseudoVWADDU_WX_MF8 + 0U, // PseudoVWADDU_WX_MF8_MASK + 0U, // PseudoVWADD_VV_M1 + 0U, // PseudoVWADD_VV_M1_MASK + 0U, // PseudoVWADD_VV_M2 + 0U, // PseudoVWADD_VV_M2_MASK + 0U, // PseudoVWADD_VV_M4 + 0U, // PseudoVWADD_VV_M4_MASK + 0U, // PseudoVWADD_VV_MF2 + 0U, // PseudoVWADD_VV_MF2_MASK + 0U, // PseudoVWADD_VV_MF4 + 0U, // PseudoVWADD_VV_MF4_MASK + 0U, // PseudoVWADD_VV_MF8 + 0U, // PseudoVWADD_VV_MF8_MASK + 0U, // PseudoVWADD_VX_M1 + 0U, // PseudoVWADD_VX_M1_MASK + 0U, // PseudoVWADD_VX_M2 + 0U, // PseudoVWADD_VX_M2_MASK + 0U, // PseudoVWADD_VX_M4 + 0U, // PseudoVWADD_VX_M4_MASK + 0U, // PseudoVWADD_VX_MF2 + 0U, // PseudoVWADD_VX_MF2_MASK + 0U, // PseudoVWADD_VX_MF4 + 0U, // PseudoVWADD_VX_MF4_MASK + 0U, // PseudoVWADD_VX_MF8 + 0U, // PseudoVWADD_VX_MF8_MASK + 0U, // PseudoVWADD_WV_M1 + 0U, // PseudoVWADD_WV_M1_MASK + 0U, // PseudoVWADD_WV_M1_MASK_TIED + 0U, // PseudoVWADD_WV_M1_TIED + 0U, // PseudoVWADD_WV_M2 + 0U, // PseudoVWADD_WV_M2_MASK + 0U, // PseudoVWADD_WV_M2_MASK_TIED + 0U, // PseudoVWADD_WV_M2_TIED + 0U, // PseudoVWADD_WV_M4 + 0U, // PseudoVWADD_WV_M4_MASK + 0U, // PseudoVWADD_WV_M4_MASK_TIED + 0U, // PseudoVWADD_WV_M4_TIED + 0U, // PseudoVWADD_WV_MF2 + 0U, // PseudoVWADD_WV_MF2_MASK + 0U, // PseudoVWADD_WV_MF2_MASK_TIED + 0U, // PseudoVWADD_WV_MF2_TIED + 0U, // PseudoVWADD_WV_MF4 + 0U, // PseudoVWADD_WV_MF4_MASK + 0U, // PseudoVWADD_WV_MF4_MASK_TIED + 0U, // PseudoVWADD_WV_MF4_TIED + 0U, // PseudoVWADD_WV_MF8 + 0U, // PseudoVWADD_WV_MF8_MASK + 0U, // PseudoVWADD_WV_MF8_MASK_TIED + 0U, // PseudoVWADD_WV_MF8_TIED + 0U, // PseudoVWADD_WX_M1 + 0U, // PseudoVWADD_WX_M1_MASK + 0U, // PseudoVWADD_WX_M2 + 0U, // PseudoVWADD_WX_M2_MASK + 0U, // PseudoVWADD_WX_M4 + 0U, // PseudoVWADD_WX_M4_MASK + 0U, // PseudoVWADD_WX_MF2 + 0U, // PseudoVWADD_WX_MF2_MASK + 0U, // PseudoVWADD_WX_MF4 + 0U, // PseudoVWADD_WX_MF4_MASK + 0U, // PseudoVWADD_WX_MF8 + 0U, // PseudoVWADD_WX_MF8_MASK + 0U, // PseudoVWMACCSU_VV_M1 + 0U, // PseudoVWMACCSU_VV_M1_MASK + 0U, // PseudoVWMACCSU_VV_M2 + 0U, // PseudoVWMACCSU_VV_M2_MASK + 0U, // PseudoVWMACCSU_VV_M4 + 0U, // PseudoVWMACCSU_VV_M4_MASK + 0U, // PseudoVWMACCSU_VV_MF2 + 0U, // PseudoVWMACCSU_VV_MF2_MASK + 0U, // PseudoVWMACCSU_VV_MF4 + 0U, // PseudoVWMACCSU_VV_MF4_MASK + 0U, // PseudoVWMACCSU_VV_MF8 + 0U, // PseudoVWMACCSU_VV_MF8_MASK + 0U, // PseudoVWMACCSU_VX_M1 + 0U, // PseudoVWMACCSU_VX_M1_MASK + 0U, // PseudoVWMACCSU_VX_M2 + 0U, // PseudoVWMACCSU_VX_M2_MASK + 0U, // PseudoVWMACCSU_VX_M4 + 0U, // PseudoVWMACCSU_VX_M4_MASK + 0U, // PseudoVWMACCSU_VX_MF2 + 0U, // PseudoVWMACCSU_VX_MF2_MASK + 0U, // PseudoVWMACCSU_VX_MF4 + 0U, // PseudoVWMACCSU_VX_MF4_MASK + 0U, // PseudoVWMACCSU_VX_MF8 + 0U, // PseudoVWMACCSU_VX_MF8_MASK + 0U, // PseudoVWMACCUS_VX_M1 + 0U, // PseudoVWMACCUS_VX_M1_MASK + 0U, // PseudoVWMACCUS_VX_M2 + 0U, // PseudoVWMACCUS_VX_M2_MASK + 0U, // PseudoVWMACCUS_VX_M4 + 0U, // PseudoVWMACCUS_VX_M4_MASK + 0U, // PseudoVWMACCUS_VX_MF2 + 0U, // PseudoVWMACCUS_VX_MF2_MASK + 0U, // PseudoVWMACCUS_VX_MF4 + 0U, // PseudoVWMACCUS_VX_MF4_MASK + 0U, // PseudoVWMACCUS_VX_MF8 + 0U, // PseudoVWMACCUS_VX_MF8_MASK + 0U, // PseudoVWMACCU_VV_M1 + 0U, // PseudoVWMACCU_VV_M1_MASK + 0U, // PseudoVWMACCU_VV_M2 + 0U, // PseudoVWMACCU_VV_M2_MASK + 0U, // PseudoVWMACCU_VV_M4 + 0U, // PseudoVWMACCU_VV_M4_MASK + 0U, // PseudoVWMACCU_VV_MF2 + 0U, // PseudoVWMACCU_VV_MF2_MASK + 0U, // PseudoVWMACCU_VV_MF4 + 0U, // PseudoVWMACCU_VV_MF4_MASK + 0U, // PseudoVWMACCU_VV_MF8 + 0U, // PseudoVWMACCU_VV_MF8_MASK + 0U, // PseudoVWMACCU_VX_M1 + 0U, // PseudoVWMACCU_VX_M1_MASK + 0U, // PseudoVWMACCU_VX_M2 + 0U, // PseudoVWMACCU_VX_M2_MASK + 0U, // PseudoVWMACCU_VX_M4 + 0U, // PseudoVWMACCU_VX_M4_MASK + 0U, // PseudoVWMACCU_VX_MF2 + 0U, // PseudoVWMACCU_VX_MF2_MASK + 0U, // PseudoVWMACCU_VX_MF4 + 0U, // PseudoVWMACCU_VX_MF4_MASK + 0U, // PseudoVWMACCU_VX_MF8 + 0U, // PseudoVWMACCU_VX_MF8_MASK + 0U, // PseudoVWMACC_VV_M1 + 0U, // PseudoVWMACC_VV_M1_MASK + 0U, // PseudoVWMACC_VV_M2 + 0U, // PseudoVWMACC_VV_M2_MASK + 0U, // PseudoVWMACC_VV_M4 + 0U, // PseudoVWMACC_VV_M4_MASK + 0U, // PseudoVWMACC_VV_MF2 + 0U, // PseudoVWMACC_VV_MF2_MASK + 0U, // PseudoVWMACC_VV_MF4 + 0U, // PseudoVWMACC_VV_MF4_MASK + 0U, // PseudoVWMACC_VV_MF8 + 0U, // PseudoVWMACC_VV_MF8_MASK + 0U, // PseudoVWMACC_VX_M1 + 0U, // PseudoVWMACC_VX_M1_MASK + 0U, // PseudoVWMACC_VX_M2 + 0U, // PseudoVWMACC_VX_M2_MASK + 0U, // PseudoVWMACC_VX_M4 + 0U, // PseudoVWMACC_VX_M4_MASK + 0U, // PseudoVWMACC_VX_MF2 + 0U, // PseudoVWMACC_VX_MF2_MASK + 0U, // PseudoVWMACC_VX_MF4 + 0U, // PseudoVWMACC_VX_MF4_MASK + 0U, // PseudoVWMACC_VX_MF8 + 0U, // PseudoVWMACC_VX_MF8_MASK + 0U, // PseudoVWMULSU_VV_M1 + 0U, // PseudoVWMULSU_VV_M1_MASK + 0U, // PseudoVWMULSU_VV_M2 + 0U, // PseudoVWMULSU_VV_M2_MASK + 0U, // PseudoVWMULSU_VV_M4 + 0U, // PseudoVWMULSU_VV_M4_MASK + 0U, // PseudoVWMULSU_VV_MF2 + 0U, // PseudoVWMULSU_VV_MF2_MASK + 0U, // PseudoVWMULSU_VV_MF4 + 0U, // PseudoVWMULSU_VV_MF4_MASK + 0U, // PseudoVWMULSU_VV_MF8 + 0U, // PseudoVWMULSU_VV_MF8_MASK + 0U, // PseudoVWMULSU_VX_M1 + 0U, // PseudoVWMULSU_VX_M1_MASK + 0U, // PseudoVWMULSU_VX_M2 + 0U, // PseudoVWMULSU_VX_M2_MASK + 0U, // PseudoVWMULSU_VX_M4 + 0U, // PseudoVWMULSU_VX_M4_MASK + 0U, // PseudoVWMULSU_VX_MF2 + 0U, // PseudoVWMULSU_VX_MF2_MASK + 0U, // PseudoVWMULSU_VX_MF4 + 0U, // PseudoVWMULSU_VX_MF4_MASK + 0U, // PseudoVWMULSU_VX_MF8 + 0U, // PseudoVWMULSU_VX_MF8_MASK + 0U, // PseudoVWMULU_VV_M1 + 0U, // PseudoVWMULU_VV_M1_MASK + 0U, // PseudoVWMULU_VV_M2 + 0U, // PseudoVWMULU_VV_M2_MASK + 0U, // PseudoVWMULU_VV_M4 + 0U, // PseudoVWMULU_VV_M4_MASK + 0U, // PseudoVWMULU_VV_MF2 + 0U, // PseudoVWMULU_VV_MF2_MASK + 0U, // PseudoVWMULU_VV_MF4 + 0U, // PseudoVWMULU_VV_MF4_MASK + 0U, // PseudoVWMULU_VV_MF8 + 0U, // PseudoVWMULU_VV_MF8_MASK + 0U, // PseudoVWMULU_VX_M1 + 0U, // PseudoVWMULU_VX_M1_MASK + 0U, // PseudoVWMULU_VX_M2 + 0U, // PseudoVWMULU_VX_M2_MASK + 0U, // PseudoVWMULU_VX_M4 + 0U, // PseudoVWMULU_VX_M4_MASK + 0U, // PseudoVWMULU_VX_MF2 + 0U, // PseudoVWMULU_VX_MF2_MASK + 0U, // PseudoVWMULU_VX_MF4 + 0U, // PseudoVWMULU_VX_MF4_MASK + 0U, // PseudoVWMULU_VX_MF8 + 0U, // PseudoVWMULU_VX_MF8_MASK + 0U, // PseudoVWMUL_VV_M1 + 0U, // PseudoVWMUL_VV_M1_MASK + 0U, // PseudoVWMUL_VV_M2 + 0U, // PseudoVWMUL_VV_M2_MASK + 0U, // PseudoVWMUL_VV_M4 + 0U, // PseudoVWMUL_VV_M4_MASK + 0U, // PseudoVWMUL_VV_MF2 + 0U, // PseudoVWMUL_VV_MF2_MASK + 0U, // PseudoVWMUL_VV_MF4 + 0U, // PseudoVWMUL_VV_MF4_MASK + 0U, // PseudoVWMUL_VV_MF8 + 0U, // PseudoVWMUL_VV_MF8_MASK + 0U, // PseudoVWMUL_VX_M1 + 0U, // PseudoVWMUL_VX_M1_MASK + 0U, // PseudoVWMUL_VX_M2 + 0U, // PseudoVWMUL_VX_M2_MASK + 0U, // PseudoVWMUL_VX_M4 + 0U, // PseudoVWMUL_VX_M4_MASK + 0U, // PseudoVWMUL_VX_MF2 + 0U, // PseudoVWMUL_VX_MF2_MASK + 0U, // PseudoVWMUL_VX_MF4 + 0U, // PseudoVWMUL_VX_MF4_MASK + 0U, // PseudoVWMUL_VX_MF8 + 0U, // PseudoVWMUL_VX_MF8_MASK + 0U, // PseudoVWREDSUMU_VS_M1_E16 + 0U, // PseudoVWREDSUMU_VS_M1_E16_MASK + 0U, // PseudoVWREDSUMU_VS_M1_E32 + 0U, // PseudoVWREDSUMU_VS_M1_E32_MASK + 0U, // PseudoVWREDSUMU_VS_M1_E8 + 0U, // PseudoVWREDSUMU_VS_M1_E8_MASK + 0U, // PseudoVWREDSUMU_VS_M2_E16 + 0U, // PseudoVWREDSUMU_VS_M2_E16_MASK + 0U, // PseudoVWREDSUMU_VS_M2_E32 + 0U, // PseudoVWREDSUMU_VS_M2_E32_MASK + 0U, // PseudoVWREDSUMU_VS_M2_E8 + 0U, // PseudoVWREDSUMU_VS_M2_E8_MASK + 0U, // PseudoVWREDSUMU_VS_M4_E16 + 0U, // PseudoVWREDSUMU_VS_M4_E16_MASK + 0U, // PseudoVWREDSUMU_VS_M4_E32 + 0U, // PseudoVWREDSUMU_VS_M4_E32_MASK + 0U, // PseudoVWREDSUMU_VS_M4_E8 + 0U, // PseudoVWREDSUMU_VS_M4_E8_MASK + 0U, // PseudoVWREDSUMU_VS_M8_E16 + 0U, // PseudoVWREDSUMU_VS_M8_E16_MASK + 0U, // PseudoVWREDSUMU_VS_M8_E32 + 0U, // PseudoVWREDSUMU_VS_M8_E32_MASK + 0U, // PseudoVWREDSUMU_VS_M8_E8 + 0U, // PseudoVWREDSUMU_VS_M8_E8_MASK + 0U, // PseudoVWREDSUMU_VS_MF2_E16 + 0U, // PseudoVWREDSUMU_VS_MF2_E16_MASK + 0U, // PseudoVWREDSUMU_VS_MF2_E32 + 0U, // PseudoVWREDSUMU_VS_MF2_E32_MASK + 0U, // PseudoVWREDSUMU_VS_MF2_E8 + 0U, // PseudoVWREDSUMU_VS_MF2_E8_MASK + 0U, // PseudoVWREDSUMU_VS_MF4_E16 + 0U, // PseudoVWREDSUMU_VS_MF4_E16_MASK + 0U, // PseudoVWREDSUMU_VS_MF4_E8 + 0U, // PseudoVWREDSUMU_VS_MF4_E8_MASK + 0U, // PseudoVWREDSUMU_VS_MF8_E8 + 0U, // PseudoVWREDSUMU_VS_MF8_E8_MASK + 0U, // PseudoVWREDSUM_VS_M1_E16 + 0U, // PseudoVWREDSUM_VS_M1_E16_MASK + 0U, // PseudoVWREDSUM_VS_M1_E32 + 0U, // PseudoVWREDSUM_VS_M1_E32_MASK + 0U, // PseudoVWREDSUM_VS_M1_E8 + 0U, // PseudoVWREDSUM_VS_M1_E8_MASK + 0U, // PseudoVWREDSUM_VS_M2_E16 + 0U, // PseudoVWREDSUM_VS_M2_E16_MASK + 0U, // PseudoVWREDSUM_VS_M2_E32 + 0U, // PseudoVWREDSUM_VS_M2_E32_MASK + 0U, // PseudoVWREDSUM_VS_M2_E8 + 0U, // PseudoVWREDSUM_VS_M2_E8_MASK + 0U, // PseudoVWREDSUM_VS_M4_E16 + 0U, // PseudoVWREDSUM_VS_M4_E16_MASK + 0U, // PseudoVWREDSUM_VS_M4_E32 + 0U, // PseudoVWREDSUM_VS_M4_E32_MASK + 0U, // PseudoVWREDSUM_VS_M4_E8 + 0U, // PseudoVWREDSUM_VS_M4_E8_MASK + 0U, // PseudoVWREDSUM_VS_M8_E16 + 0U, // PseudoVWREDSUM_VS_M8_E16_MASK + 0U, // PseudoVWREDSUM_VS_M8_E32 + 0U, // PseudoVWREDSUM_VS_M8_E32_MASK + 0U, // PseudoVWREDSUM_VS_M8_E8 + 0U, // PseudoVWREDSUM_VS_M8_E8_MASK + 0U, // PseudoVWREDSUM_VS_MF2_E16 + 0U, // PseudoVWREDSUM_VS_MF2_E16_MASK + 0U, // PseudoVWREDSUM_VS_MF2_E32 + 0U, // PseudoVWREDSUM_VS_MF2_E32_MASK + 0U, // PseudoVWREDSUM_VS_MF2_E8 + 0U, // PseudoVWREDSUM_VS_MF2_E8_MASK + 0U, // PseudoVWREDSUM_VS_MF4_E16 + 0U, // PseudoVWREDSUM_VS_MF4_E16_MASK + 0U, // PseudoVWREDSUM_VS_MF4_E8 + 0U, // PseudoVWREDSUM_VS_MF4_E8_MASK + 0U, // PseudoVWREDSUM_VS_MF8_E8 + 0U, // PseudoVWREDSUM_VS_MF8_E8_MASK + 0U, // PseudoVWSLL_VI_M1 + 0U, // PseudoVWSLL_VI_M1_MASK + 0U, // PseudoVWSLL_VI_M2 + 0U, // PseudoVWSLL_VI_M2_MASK + 0U, // PseudoVWSLL_VI_M4 + 0U, // PseudoVWSLL_VI_M4_MASK + 0U, // PseudoVWSLL_VI_MF2 + 0U, // PseudoVWSLL_VI_MF2_MASK + 0U, // PseudoVWSLL_VI_MF4 + 0U, // PseudoVWSLL_VI_MF4_MASK + 0U, // PseudoVWSLL_VI_MF8 + 0U, // PseudoVWSLL_VI_MF8_MASK + 0U, // PseudoVWSLL_VV_M1 + 0U, // PseudoVWSLL_VV_M1_MASK + 0U, // PseudoVWSLL_VV_M2 + 0U, // PseudoVWSLL_VV_M2_MASK + 0U, // PseudoVWSLL_VV_M4 + 0U, // PseudoVWSLL_VV_M4_MASK + 0U, // PseudoVWSLL_VV_MF2 + 0U, // PseudoVWSLL_VV_MF2_MASK + 0U, // PseudoVWSLL_VV_MF4 + 0U, // PseudoVWSLL_VV_MF4_MASK + 0U, // PseudoVWSLL_VV_MF8 + 0U, // PseudoVWSLL_VV_MF8_MASK + 0U, // PseudoVWSLL_VX_M1 + 0U, // PseudoVWSLL_VX_M1_MASK + 0U, // PseudoVWSLL_VX_M2 + 0U, // PseudoVWSLL_VX_M2_MASK + 0U, // PseudoVWSLL_VX_M4 + 0U, // PseudoVWSLL_VX_M4_MASK + 0U, // PseudoVWSLL_VX_MF2 + 0U, // PseudoVWSLL_VX_MF2_MASK + 0U, // PseudoVWSLL_VX_MF4 + 0U, // PseudoVWSLL_VX_MF4_MASK + 0U, // PseudoVWSLL_VX_MF8 + 0U, // PseudoVWSLL_VX_MF8_MASK + 0U, // PseudoVWSUBU_VV_M1 + 0U, // PseudoVWSUBU_VV_M1_MASK + 0U, // PseudoVWSUBU_VV_M2 + 0U, // PseudoVWSUBU_VV_M2_MASK + 0U, // PseudoVWSUBU_VV_M4 + 0U, // PseudoVWSUBU_VV_M4_MASK + 0U, // PseudoVWSUBU_VV_MF2 + 0U, // PseudoVWSUBU_VV_MF2_MASK + 0U, // PseudoVWSUBU_VV_MF4 + 0U, // PseudoVWSUBU_VV_MF4_MASK + 0U, // PseudoVWSUBU_VV_MF8 + 0U, // PseudoVWSUBU_VV_MF8_MASK + 0U, // PseudoVWSUBU_VX_M1 + 0U, // PseudoVWSUBU_VX_M1_MASK + 0U, // PseudoVWSUBU_VX_M2 + 0U, // PseudoVWSUBU_VX_M2_MASK + 0U, // PseudoVWSUBU_VX_M4 + 0U, // PseudoVWSUBU_VX_M4_MASK + 0U, // PseudoVWSUBU_VX_MF2 + 0U, // PseudoVWSUBU_VX_MF2_MASK + 0U, // PseudoVWSUBU_VX_MF4 + 0U, // PseudoVWSUBU_VX_MF4_MASK + 0U, // PseudoVWSUBU_VX_MF8 + 0U, // PseudoVWSUBU_VX_MF8_MASK + 0U, // PseudoVWSUBU_WV_M1 + 0U, // PseudoVWSUBU_WV_M1_MASK + 0U, // PseudoVWSUBU_WV_M1_MASK_TIED + 0U, // PseudoVWSUBU_WV_M1_TIED + 0U, // PseudoVWSUBU_WV_M2 + 0U, // PseudoVWSUBU_WV_M2_MASK + 0U, // PseudoVWSUBU_WV_M2_MASK_TIED + 0U, // PseudoVWSUBU_WV_M2_TIED + 0U, // PseudoVWSUBU_WV_M4 + 0U, // PseudoVWSUBU_WV_M4_MASK + 0U, // PseudoVWSUBU_WV_M4_MASK_TIED + 0U, // PseudoVWSUBU_WV_M4_TIED + 0U, // PseudoVWSUBU_WV_MF2 + 0U, // PseudoVWSUBU_WV_MF2_MASK + 0U, // PseudoVWSUBU_WV_MF2_MASK_TIED + 0U, // PseudoVWSUBU_WV_MF2_TIED + 0U, // PseudoVWSUBU_WV_MF4 + 0U, // PseudoVWSUBU_WV_MF4_MASK + 0U, // PseudoVWSUBU_WV_MF4_MASK_TIED + 0U, // PseudoVWSUBU_WV_MF4_TIED + 0U, // PseudoVWSUBU_WV_MF8 + 0U, // PseudoVWSUBU_WV_MF8_MASK + 0U, // PseudoVWSUBU_WV_MF8_MASK_TIED + 0U, // PseudoVWSUBU_WV_MF8_TIED + 0U, // PseudoVWSUBU_WX_M1 + 0U, // PseudoVWSUBU_WX_M1_MASK + 0U, // PseudoVWSUBU_WX_M2 + 0U, // PseudoVWSUBU_WX_M2_MASK + 0U, // PseudoVWSUBU_WX_M4 + 0U, // PseudoVWSUBU_WX_M4_MASK + 0U, // PseudoVWSUBU_WX_MF2 + 0U, // PseudoVWSUBU_WX_MF2_MASK + 0U, // PseudoVWSUBU_WX_MF4 + 0U, // PseudoVWSUBU_WX_MF4_MASK + 0U, // PseudoVWSUBU_WX_MF8 + 0U, // PseudoVWSUBU_WX_MF8_MASK + 0U, // PseudoVWSUB_VV_M1 + 0U, // PseudoVWSUB_VV_M1_MASK + 0U, // PseudoVWSUB_VV_M2 + 0U, // PseudoVWSUB_VV_M2_MASK + 0U, // PseudoVWSUB_VV_M4 + 0U, // PseudoVWSUB_VV_M4_MASK + 0U, // PseudoVWSUB_VV_MF2 + 0U, // PseudoVWSUB_VV_MF2_MASK + 0U, // PseudoVWSUB_VV_MF4 + 0U, // PseudoVWSUB_VV_MF4_MASK + 0U, // PseudoVWSUB_VV_MF8 + 0U, // PseudoVWSUB_VV_MF8_MASK + 0U, // PseudoVWSUB_VX_M1 + 0U, // PseudoVWSUB_VX_M1_MASK + 0U, // PseudoVWSUB_VX_M2 + 0U, // PseudoVWSUB_VX_M2_MASK + 0U, // PseudoVWSUB_VX_M4 + 0U, // PseudoVWSUB_VX_M4_MASK + 0U, // PseudoVWSUB_VX_MF2 + 0U, // PseudoVWSUB_VX_MF2_MASK + 0U, // PseudoVWSUB_VX_MF4 + 0U, // PseudoVWSUB_VX_MF4_MASK + 0U, // PseudoVWSUB_VX_MF8 + 0U, // PseudoVWSUB_VX_MF8_MASK + 0U, // PseudoVWSUB_WV_M1 + 0U, // PseudoVWSUB_WV_M1_MASK + 0U, // PseudoVWSUB_WV_M1_MASK_TIED + 0U, // PseudoVWSUB_WV_M1_TIED + 0U, // PseudoVWSUB_WV_M2 + 0U, // PseudoVWSUB_WV_M2_MASK + 0U, // PseudoVWSUB_WV_M2_MASK_TIED + 0U, // PseudoVWSUB_WV_M2_TIED + 0U, // PseudoVWSUB_WV_M4 + 0U, // PseudoVWSUB_WV_M4_MASK + 0U, // PseudoVWSUB_WV_M4_MASK_TIED + 0U, // PseudoVWSUB_WV_M4_TIED + 0U, // PseudoVWSUB_WV_MF2 + 0U, // PseudoVWSUB_WV_MF2_MASK + 0U, // PseudoVWSUB_WV_MF2_MASK_TIED + 0U, // PseudoVWSUB_WV_MF2_TIED + 0U, // PseudoVWSUB_WV_MF4 + 0U, // PseudoVWSUB_WV_MF4_MASK + 0U, // PseudoVWSUB_WV_MF4_MASK_TIED + 0U, // PseudoVWSUB_WV_MF4_TIED + 0U, // PseudoVWSUB_WV_MF8 + 0U, // PseudoVWSUB_WV_MF8_MASK + 0U, // PseudoVWSUB_WV_MF8_MASK_TIED + 0U, // PseudoVWSUB_WV_MF8_TIED + 0U, // PseudoVWSUB_WX_M1 + 0U, // PseudoVWSUB_WX_M1_MASK + 0U, // PseudoVWSUB_WX_M2 + 0U, // PseudoVWSUB_WX_M2_MASK + 0U, // PseudoVWSUB_WX_M4 + 0U, // PseudoVWSUB_WX_M4_MASK + 0U, // PseudoVWSUB_WX_MF2 + 0U, // PseudoVWSUB_WX_MF2_MASK + 0U, // PseudoVWSUB_WX_MF4 + 0U, // PseudoVWSUB_WX_MF4_MASK + 0U, // PseudoVWSUB_WX_MF8 + 0U, // PseudoVWSUB_WX_MF8_MASK + 0U, // PseudoVXOR_VI_M1 + 0U, // PseudoVXOR_VI_M1_MASK + 0U, // PseudoVXOR_VI_M2 + 0U, // PseudoVXOR_VI_M2_MASK + 0U, // PseudoVXOR_VI_M4 + 0U, // PseudoVXOR_VI_M4_MASK + 0U, // PseudoVXOR_VI_M8 + 0U, // PseudoVXOR_VI_M8_MASK + 0U, // PseudoVXOR_VI_MF2 + 0U, // PseudoVXOR_VI_MF2_MASK + 0U, // PseudoVXOR_VI_MF4 + 0U, // PseudoVXOR_VI_MF4_MASK + 0U, // PseudoVXOR_VI_MF8 + 0U, // PseudoVXOR_VI_MF8_MASK + 0U, // PseudoVXOR_VV_M1 + 0U, // PseudoVXOR_VV_M1_MASK + 0U, // PseudoVXOR_VV_M2 + 0U, // PseudoVXOR_VV_M2_MASK + 0U, // PseudoVXOR_VV_M4 + 0U, // PseudoVXOR_VV_M4_MASK + 0U, // PseudoVXOR_VV_M8 + 0U, // PseudoVXOR_VV_M8_MASK + 0U, // PseudoVXOR_VV_MF2 + 0U, // PseudoVXOR_VV_MF2_MASK + 0U, // PseudoVXOR_VV_MF4 + 0U, // PseudoVXOR_VV_MF4_MASK + 0U, // PseudoVXOR_VV_MF8 + 0U, // PseudoVXOR_VV_MF8_MASK + 0U, // PseudoVXOR_VX_M1 + 0U, // PseudoVXOR_VX_M1_MASK + 0U, // PseudoVXOR_VX_M2 + 0U, // PseudoVXOR_VX_M2_MASK + 0U, // PseudoVXOR_VX_M4 + 0U, // PseudoVXOR_VX_M4_MASK + 0U, // PseudoVXOR_VX_M8 + 0U, // PseudoVXOR_VX_M8_MASK + 0U, // PseudoVXOR_VX_MF2 + 0U, // PseudoVXOR_VX_MF2_MASK + 0U, // PseudoVXOR_VX_MF4 + 0U, // PseudoVXOR_VX_MF4_MASK + 0U, // PseudoVXOR_VX_MF8 + 0U, // PseudoVXOR_VX_MF8_MASK + 0U, // PseudoVZEXT_VF2_M1 + 0U, // PseudoVZEXT_VF2_M1_MASK + 0U, // PseudoVZEXT_VF2_M2 + 0U, // PseudoVZEXT_VF2_M2_MASK + 0U, // PseudoVZEXT_VF2_M4 + 0U, // PseudoVZEXT_VF2_M4_MASK + 0U, // PseudoVZEXT_VF2_M8 + 0U, // PseudoVZEXT_VF2_M8_MASK + 0U, // PseudoVZEXT_VF2_MF2 + 0U, // PseudoVZEXT_VF2_MF2_MASK + 0U, // PseudoVZEXT_VF2_MF4 + 0U, // PseudoVZEXT_VF2_MF4_MASK + 0U, // PseudoVZEXT_VF4_M1 + 0U, // PseudoVZEXT_VF4_M1_MASK + 0U, // PseudoVZEXT_VF4_M2 + 0U, // PseudoVZEXT_VF4_M2_MASK + 0U, // PseudoVZEXT_VF4_M4 + 0U, // PseudoVZEXT_VF4_M4_MASK + 0U, // PseudoVZEXT_VF4_M8 + 0U, // PseudoVZEXT_VF4_M8_MASK + 0U, // PseudoVZEXT_VF4_MF2 + 0U, // PseudoVZEXT_VF4_MF2_MASK + 0U, // PseudoVZEXT_VF8_M1 + 0U, // PseudoVZEXT_VF8_M1_MASK + 0U, // PseudoVZEXT_VF8_M2 + 0U, // PseudoVZEXT_VF8_M2_MASK + 0U, // PseudoVZEXT_VF8_M4 + 0U, // PseudoVZEXT_VF8_M4_MASK + 0U, // PseudoVZEXT_VF8_M8 + 0U, // PseudoVZEXT_VF8_M8_MASK + 0U, // PseudoZEXT_H + 0U, // PseudoZEXT_W + 0U, // ReadCycleWide + 0U, // ReadFFLAGS + 0U, // ReadFRM + 0U, // Select_FPR16INX_Using_CC_GPR + 0U, // Select_FPR16_Using_CC_GPR + 0U, // Select_FPR32INX_Using_CC_GPR 0U, // Select_FPR32_Using_CC_GPR + 0U, // Select_FPR64IN32X_Using_CC_GPR + 0U, // Select_FPR64INX_Using_CC_GPR 0U, // Select_FPR64_Using_CC_GPR 0U, // Select_GPR_Using_CC_GPR 0U, // SplitF64Pseudo - 4U, // ADD - 4U, // ADDI - 4U, // ADDIW - 4U, // ADDW - 9U, // AMOADD_D - 9U, // AMOADD_D_AQ - 9U, // AMOADD_D_AQ_RL - 9U, // AMOADD_D_RL - 9U, // AMOADD_W - 9U, // AMOADD_W_AQ - 9U, // AMOADD_W_AQ_RL - 9U, // AMOADD_W_RL - 9U, // AMOAND_D - 9U, // AMOAND_D_AQ - 9U, // AMOAND_D_AQ_RL - 9U, // AMOAND_D_RL - 9U, // AMOAND_W - 9U, // AMOAND_W_AQ - 9U, // AMOAND_W_AQ_RL - 9U, // AMOAND_W_RL - 9U, // AMOMAXU_D - 9U, // AMOMAXU_D_AQ - 9U, // AMOMAXU_D_AQ_RL - 9U, // AMOMAXU_D_RL - 9U, // AMOMAXU_W - 9U, // AMOMAXU_W_AQ - 9U, // AMOMAXU_W_AQ_RL - 9U, // AMOMAXU_W_RL - 9U, // AMOMAX_D - 9U, // AMOMAX_D_AQ - 9U, // AMOMAX_D_AQ_RL - 9U, // AMOMAX_D_RL - 9U, // AMOMAX_W - 9U, // AMOMAX_W_AQ - 9U, // AMOMAX_W_AQ_RL - 9U, // AMOMAX_W_RL - 9U, // AMOMINU_D - 9U, // AMOMINU_D_AQ - 9U, // AMOMINU_D_AQ_RL - 9U, // AMOMINU_D_RL - 9U, // AMOMINU_W - 9U, // AMOMINU_W_AQ - 9U, // AMOMINU_W_AQ_RL - 9U, // AMOMINU_W_RL - 9U, // AMOMIN_D - 9U, // AMOMIN_D_AQ - 9U, // AMOMIN_D_AQ_RL - 9U, // AMOMIN_D_RL - 9U, // AMOMIN_W - 9U, // AMOMIN_W_AQ - 9U, // AMOMIN_W_AQ_RL - 9U, // AMOMIN_W_RL - 9U, // AMOOR_D - 9U, // AMOOR_D_AQ - 9U, // AMOOR_D_AQ_RL - 9U, // AMOOR_D_RL - 9U, // AMOOR_W - 9U, // AMOOR_W_AQ - 9U, // AMOOR_W_AQ_RL - 9U, // AMOOR_W_RL - 9U, // AMOSWAP_D - 9U, // AMOSWAP_D_AQ - 9U, // AMOSWAP_D_AQ_RL - 9U, // AMOSWAP_D_RL - 9U, // AMOSWAP_W - 9U, // AMOSWAP_W_AQ - 9U, // AMOSWAP_W_AQ_RL - 9U, // AMOSWAP_W_RL - 9U, // AMOXOR_D - 9U, // AMOXOR_D_AQ - 9U, // AMOXOR_D_AQ_RL - 9U, // AMOXOR_D_RL - 9U, // AMOXOR_W - 9U, // AMOXOR_W_AQ - 9U, // AMOXOR_W_AQ_RL - 9U, // AMOXOR_W_RL - 4U, // AND - 4U, // ANDI + 0U, // SplitF64Pseudo_INX + 0U, // SwapFRMImm + 0U, // WriteFFLAGS + 0U, // WriteFRM + 0U, // WriteFRMImm + 0U, // WriteVXRMImm + 0U, // ADD + 0U, // ADDI + 0U, // ADDIW + 0U, // ADDW + 0U, // ADD_UW + 0U, // AES32DSI + 0U, // AES32DSMI + 0U, // AES32ESI + 0U, // AES32ESMI + 0U, // AES64DS + 0U, // AES64DSM + 0U, // AES64ES + 0U, // AES64ESM + 0U, // AES64IM + 0U, // AES64KS1I + 0U, // AES64KS2 + 0U, // AMOADD_D + 0U, // AMOADD_D_AQ + 0U, // AMOADD_D_AQ_RL + 0U, // AMOADD_D_RL + 0U, // AMOADD_W + 0U, // AMOADD_W_AQ + 0U, // AMOADD_W_AQ_RL + 0U, // AMOADD_W_RL + 0U, // AMOAND_D + 0U, // AMOAND_D_AQ + 0U, // AMOAND_D_AQ_RL + 0U, // AMOAND_D_RL + 0U, // AMOAND_W + 0U, // AMOAND_W_AQ + 0U, // AMOAND_W_AQ_RL + 0U, // AMOAND_W_RL + 0U, // AMOCAS_D_RV32 + 0U, // AMOCAS_D_RV32_AQ + 0U, // AMOCAS_D_RV32_AQ_RL + 0U, // AMOCAS_D_RV32_RL + 0U, // AMOCAS_D_RV64 + 0U, // AMOCAS_D_RV64_AQ + 0U, // AMOCAS_D_RV64_AQ_RL + 0U, // AMOCAS_D_RV64_RL + 0U, // AMOCAS_Q + 0U, // AMOCAS_Q_AQ + 0U, // AMOCAS_Q_AQ_RL + 0U, // AMOCAS_Q_RL + 0U, // AMOCAS_W + 0U, // AMOCAS_W_AQ + 0U, // AMOCAS_W_AQ_RL + 0U, // AMOCAS_W_RL + 0U, // AMOMAXU_D + 0U, // AMOMAXU_D_AQ + 0U, // AMOMAXU_D_AQ_RL + 0U, // AMOMAXU_D_RL + 0U, // AMOMAXU_W + 0U, // AMOMAXU_W_AQ + 0U, // AMOMAXU_W_AQ_RL + 0U, // AMOMAXU_W_RL + 0U, // AMOMAX_D + 0U, // AMOMAX_D_AQ + 0U, // AMOMAX_D_AQ_RL + 0U, // AMOMAX_D_RL + 0U, // AMOMAX_W + 0U, // AMOMAX_W_AQ + 0U, // AMOMAX_W_AQ_RL + 0U, // AMOMAX_W_RL + 0U, // AMOMINU_D + 0U, // AMOMINU_D_AQ + 0U, // AMOMINU_D_AQ_RL + 0U, // AMOMINU_D_RL + 0U, // AMOMINU_W + 0U, // AMOMINU_W_AQ + 0U, // AMOMINU_W_AQ_RL + 0U, // AMOMINU_W_RL + 0U, // AMOMIN_D + 0U, // AMOMIN_D_AQ + 0U, // AMOMIN_D_AQ_RL + 0U, // AMOMIN_D_RL + 0U, // AMOMIN_W + 0U, // AMOMIN_W_AQ + 0U, // AMOMIN_W_AQ_RL + 0U, // AMOMIN_W_RL + 0U, // AMOOR_D + 0U, // AMOOR_D_AQ + 0U, // AMOOR_D_AQ_RL + 0U, // AMOOR_D_RL + 0U, // AMOOR_W + 0U, // AMOOR_W_AQ + 0U, // AMOOR_W_AQ_RL + 0U, // AMOOR_W_RL + 0U, // AMOSWAP_D + 0U, // AMOSWAP_D_AQ + 0U, // AMOSWAP_D_AQ_RL + 0U, // AMOSWAP_D_RL + 0U, // AMOSWAP_W + 0U, // AMOSWAP_W_AQ + 0U, // AMOSWAP_W_AQ_RL + 0U, // AMOSWAP_W_RL + 0U, // AMOXOR_D + 0U, // AMOXOR_D_AQ + 0U, // AMOXOR_D_AQ_RL + 0U, // AMOXOR_D_RL + 0U, // AMOXOR_W + 0U, // AMOXOR_W_AQ + 0U, // AMOXOR_W_AQ_RL + 0U, // AMOXOR_W_RL + 0U, // AND + 0U, // ANDI + 0U, // ANDN 0U, // AUIPC - 4U, // BEQ - 4U, // BGE - 4U, // BGEU - 4U, // BLT - 4U, // BLTU - 4U, // BNE - 2U, // CSRRC - 2U, // CSRRCI - 2U, // CSRRS - 2U, // CSRRSI - 2U, // CSRRW - 2U, // CSRRWI + 0U, // BCLR + 0U, // BCLRI + 0U, // BEQ + 0U, // BEXT + 0U, // BEXTI + 0U, // BGE + 0U, // BGEU + 0U, // BINV + 0U, // BINVI + 0U, // BLT + 0U, // BLTU + 0U, // BNE + 0U, // BREV8 + 0U, // BSET + 0U, // BSETI + 0U, // CBO_CLEAN + 0U, // CBO_FLUSH + 0U, // CBO_INVAL + 0U, // CBO_ZERO + 0U, // CLMUL + 0U, // CLMULH + 0U, // CLMULR + 0U, // CLZ + 0U, // CLZW + 0U, // CMOP1 + 0U, // CMOP11 + 0U, // CMOP13 + 0U, // CMOP15 + 0U, // CMOP3 + 0U, // CMOP5 + 0U, // CMOP7 + 0U, // CMOP9 + 0U, // CM_JALT + 0U, // CM_JT + 0U, // CM_MVA01S + 0U, // CM_MVSA01 + 0U, // CM_POP + 0U, // CM_POPRET + 0U, // CM_POPRETZ + 0U, // CM_PUSH + 0U, // CPOP + 0U, // CPOPW + 0U, // CSRRC + 0U, // CSRRCI + 0U, // CSRRS + 0U, // CSRRSI + 0U, // CSRRW + 0U, // CSRRWI + 0U, // CTZ + 0U, // CTZW + 0U, // CV_ABS + 0U, // CV_ABS_B + 0U, // CV_ABS_H + 0U, // CV_ADDN + 0U, // CV_ADDNR + 0U, // CV_ADDRN + 0U, // CV_ADDRNR + 0U, // CV_ADDUN + 0U, // CV_ADDUNR + 0U, // CV_ADDURN + 0U, // CV_ADDURNR + 0U, // CV_ADD_B + 0U, // CV_ADD_DIV2 + 0U, // CV_ADD_DIV4 + 0U, // CV_ADD_DIV8 + 0U, // CV_ADD_H + 0U, // CV_ADD_SCI_B + 0U, // CV_ADD_SCI_H + 0U, // CV_ADD_SC_B + 0U, // CV_ADD_SC_H + 0U, // CV_AND_B + 0U, // CV_AND_H + 0U, // CV_AND_SCI_B + 0U, // CV_AND_SCI_H + 0U, // CV_AND_SC_B + 0U, // CV_AND_SC_H + 0U, // CV_AVGU_B + 0U, // CV_AVGU_H + 0U, // CV_AVGU_SCI_B + 0U, // CV_AVGU_SCI_H + 0U, // CV_AVGU_SC_B + 0U, // CV_AVGU_SC_H + 0U, // CV_AVG_B + 0U, // CV_AVG_H + 0U, // CV_AVG_SCI_B + 0U, // CV_AVG_SCI_H + 0U, // CV_AVG_SC_B + 0U, // CV_AVG_SC_H + 0U, // CV_BCLR + 0U, // CV_BCLRR + 0U, // CV_BEQIMM + 0U, // CV_BITREV + 0U, // CV_BNEIMM + 0U, // CV_BSET + 0U, // CV_BSETR + 0U, // CV_CLB + 0U, // CV_CLIP + 0U, // CV_CLIPR + 0U, // CV_CLIPU + 0U, // CV_CLIPUR + 0U, // CV_CMPEQ_B + 0U, // CV_CMPEQ_H + 0U, // CV_CMPEQ_SCI_B + 0U, // CV_CMPEQ_SCI_H + 0U, // CV_CMPEQ_SC_B + 0U, // CV_CMPEQ_SC_H + 0U, // CV_CMPGEU_B + 0U, // CV_CMPGEU_H + 0U, // CV_CMPGEU_SCI_B + 0U, // CV_CMPGEU_SCI_H + 0U, // CV_CMPGEU_SC_B + 0U, // CV_CMPGEU_SC_H + 0U, // CV_CMPGE_B + 0U, // CV_CMPGE_H + 0U, // CV_CMPGE_SCI_B + 0U, // CV_CMPGE_SCI_H + 0U, // CV_CMPGE_SC_B + 0U, // CV_CMPGE_SC_H + 0U, // CV_CMPGTU_B + 0U, // CV_CMPGTU_H + 0U, // CV_CMPGTU_SCI_B + 0U, // CV_CMPGTU_SCI_H + 0U, // CV_CMPGTU_SC_B + 0U, // CV_CMPGTU_SC_H + 0U, // CV_CMPGT_B + 0U, // CV_CMPGT_H + 0U, // CV_CMPGT_SCI_B + 0U, // CV_CMPGT_SCI_H + 0U, // CV_CMPGT_SC_B + 0U, // CV_CMPGT_SC_H + 0U, // CV_CMPLEU_B + 0U, // CV_CMPLEU_H + 0U, // CV_CMPLEU_SCI_B + 0U, // CV_CMPLEU_SCI_H + 0U, // CV_CMPLEU_SC_B + 0U, // CV_CMPLEU_SC_H + 0U, // CV_CMPLE_B + 0U, // CV_CMPLE_H + 0U, // CV_CMPLE_SCI_B + 0U, // CV_CMPLE_SCI_H + 0U, // CV_CMPLE_SC_B + 0U, // CV_CMPLE_SC_H + 0U, // CV_CMPLTU_B + 0U, // CV_CMPLTU_H + 0U, // CV_CMPLTU_SCI_B + 0U, // CV_CMPLTU_SCI_H + 0U, // CV_CMPLTU_SC_B + 0U, // CV_CMPLTU_SC_H + 0U, // CV_CMPLT_B + 0U, // CV_CMPLT_H + 0U, // CV_CMPLT_SCI_B + 0U, // CV_CMPLT_SCI_H + 0U, // CV_CMPLT_SC_B + 0U, // CV_CMPLT_SC_H + 0U, // CV_CMPNE_B + 0U, // CV_CMPNE_H + 0U, // CV_CMPNE_SCI_B + 0U, // CV_CMPNE_SCI_H + 0U, // CV_CMPNE_SC_B + 0U, // CV_CMPNE_SC_H + 0U, // CV_CNT + 0U, // CV_CPLXCONJ + 0U, // CV_CPLXMUL_I + 0U, // CV_CPLXMUL_I_DIV2 + 0U, // CV_CPLXMUL_I_DIV4 + 0U, // CV_CPLXMUL_I_DIV8 + 0U, // CV_CPLXMUL_R + 0U, // CV_CPLXMUL_R_DIV2 + 0U, // CV_CPLXMUL_R_DIV4 + 0U, // CV_CPLXMUL_R_DIV8 + 0U, // CV_DOTSP_B + 0U, // CV_DOTSP_H + 0U, // CV_DOTSP_SCI_B + 0U, // CV_DOTSP_SCI_H + 0U, // CV_DOTSP_SC_B + 0U, // CV_DOTSP_SC_H + 0U, // CV_DOTUP_B + 0U, // CV_DOTUP_H + 0U, // CV_DOTUP_SCI_B + 0U, // CV_DOTUP_SCI_H + 0U, // CV_DOTUP_SC_B + 0U, // CV_DOTUP_SC_H + 0U, // CV_DOTUSP_B + 0U, // CV_DOTUSP_H + 0U, // CV_DOTUSP_SCI_B + 0U, // CV_DOTUSP_SCI_H + 0U, // CV_DOTUSP_SC_B + 0U, // CV_DOTUSP_SC_H + 0U, // CV_ELW + 0U, // CV_EXTBS + 0U, // CV_EXTBZ + 0U, // CV_EXTHS + 0U, // CV_EXTHZ + 0U, // CV_EXTRACT + 0U, // CV_EXTRACTR + 0U, // CV_EXTRACTU + 0U, // CV_EXTRACTUR + 0U, // CV_EXTRACTU_B + 0U, // CV_EXTRACTU_H + 0U, // CV_EXTRACT_B + 0U, // CV_EXTRACT_H + 0U, // CV_FF1 + 0U, // CV_FL1 + 8U, // CV_INSERT + 0U, // CV_INSERTR + 0U, // CV_INSERT_B + 0U, // CV_INSERT_H + 0U, // CV_LBU_ri_inc + 0U, // CV_LBU_rr + 0U, // CV_LBU_rr_inc + 0U, // CV_LB_ri_inc + 0U, // CV_LB_rr + 0U, // CV_LB_rr_inc + 0U, // CV_LHU_ri_inc + 0U, // CV_LHU_rr + 0U, // CV_LHU_rr_inc + 0U, // CV_LH_ri_inc + 0U, // CV_LH_rr + 0U, // CV_LH_rr_inc + 0U, // CV_LW_ri_inc + 0U, // CV_LW_rr + 0U, // CV_LW_rr_inc + 0U, // CV_MAC + 8U, // CV_MACHHSN + 8U, // CV_MACHHSRN + 8U, // CV_MACHHUN + 8U, // CV_MACHHURN + 8U, // CV_MACSN + 8U, // CV_MACSRN + 8U, // CV_MACUN + 8U, // CV_MACURN + 0U, // CV_MAX + 0U, // CV_MAXU + 0U, // CV_MAXU_B + 0U, // CV_MAXU_H + 0U, // CV_MAXU_SCI_B + 0U, // CV_MAXU_SCI_H + 0U, // CV_MAXU_SC_B + 0U, // CV_MAXU_SC_H + 0U, // CV_MAX_B + 0U, // CV_MAX_H + 0U, // CV_MAX_SCI_B + 0U, // CV_MAX_SCI_H + 0U, // CV_MAX_SC_B + 0U, // CV_MAX_SC_H + 0U, // CV_MIN + 0U, // CV_MINU + 0U, // CV_MINU_B + 0U, // CV_MINU_H + 0U, // CV_MINU_SCI_B + 0U, // CV_MINU_SCI_H + 0U, // CV_MINU_SC_B + 0U, // CV_MINU_SC_H + 0U, // CV_MIN_B + 0U, // CV_MIN_H + 0U, // CV_MIN_SCI_B + 0U, // CV_MIN_SCI_H + 0U, // CV_MIN_SC_B + 0U, // CV_MIN_SC_H + 0U, // CV_MSU + 0U, // CV_MULHHSN + 0U, // CV_MULHHSRN + 0U, // CV_MULHHUN + 0U, // CV_MULHHURN + 0U, // CV_MULSN + 0U, // CV_MULSRN + 0U, // CV_MULUN + 0U, // CV_MULURN + 0U, // CV_OR_B + 0U, // CV_OR_H + 0U, // CV_OR_SCI_B + 0U, // CV_OR_SCI_H + 0U, // CV_OR_SC_B + 0U, // CV_OR_SC_H + 0U, // CV_PACK + 0U, // CV_PACKHI_B + 0U, // CV_PACKLO_B + 0U, // CV_PACK_H + 0U, // CV_ROR + 0U, // CV_SB_ri_inc + 0U, // CV_SB_rr + 0U, // CV_SB_rr_inc + 0U, // CV_SDOTSP_B + 0U, // CV_SDOTSP_H + 0U, // CV_SDOTSP_SCI_B + 0U, // CV_SDOTSP_SCI_H + 0U, // CV_SDOTSP_SC_B + 0U, // CV_SDOTSP_SC_H + 0U, // CV_SDOTUP_B + 0U, // CV_SDOTUP_H + 0U, // CV_SDOTUP_SCI_B + 0U, // CV_SDOTUP_SCI_H + 0U, // CV_SDOTUP_SC_B + 0U, // CV_SDOTUP_SC_H + 0U, // CV_SDOTUSP_B + 0U, // CV_SDOTUSP_H + 0U, // CV_SDOTUSP_SCI_B + 0U, // CV_SDOTUSP_SCI_H + 0U, // CV_SDOTUSP_SC_B + 0U, // CV_SDOTUSP_SC_H + 0U, // CV_SHUFFLE2_B + 0U, // CV_SHUFFLE2_H + 0U, // CV_SHUFFLEI0_SCI_B + 0U, // CV_SHUFFLEI1_SCI_B + 0U, // CV_SHUFFLEI2_SCI_B + 0U, // CV_SHUFFLEI3_SCI_B + 0U, // CV_SHUFFLE_B + 0U, // CV_SHUFFLE_H + 0U, // CV_SHUFFLE_SCI_H + 0U, // CV_SH_ri_inc + 0U, // CV_SH_rr + 0U, // CV_SH_rr_inc + 0U, // CV_SLET + 0U, // CV_SLETU + 0U, // CV_SLL_B + 0U, // CV_SLL_H + 0U, // CV_SLL_SCI_B + 0U, // CV_SLL_SCI_H + 0U, // CV_SLL_SC_B + 0U, // CV_SLL_SC_H + 0U, // CV_SRA_B + 0U, // CV_SRA_H + 0U, // CV_SRA_SCI_B + 0U, // CV_SRA_SCI_H + 0U, // CV_SRA_SC_B + 0U, // CV_SRA_SC_H + 0U, // CV_SRL_B + 0U, // CV_SRL_H + 0U, // CV_SRL_SCI_B + 0U, // CV_SRL_SCI_H + 0U, // CV_SRL_SC_B + 0U, // CV_SRL_SC_H + 0U, // CV_SUBN + 0U, // CV_SUBNR + 0U, // CV_SUBRN + 0U, // CV_SUBRNR + 0U, // CV_SUBROTMJ + 0U, // CV_SUBROTMJ_DIV2 + 0U, // CV_SUBROTMJ_DIV4 + 0U, // CV_SUBROTMJ_DIV8 + 0U, // CV_SUBUN + 0U, // CV_SUBUNR + 0U, // CV_SUBURN + 0U, // CV_SUBURNR + 0U, // CV_SUB_B + 0U, // CV_SUB_DIV2 + 0U, // CV_SUB_DIV4 + 0U, // CV_SUB_DIV8 + 0U, // CV_SUB_H + 0U, // CV_SUB_SCI_B + 0U, // CV_SUB_SCI_H + 0U, // CV_SUB_SC_B + 0U, // CV_SUB_SC_H + 0U, // CV_SW_ri_inc + 0U, // CV_SW_rr + 0U, // CV_SW_rr_inc + 0U, // CV_XOR_B + 0U, // CV_XOR_H + 0U, // CV_XOR_SCI_B + 0U, // CV_XOR_SCI_H + 0U, // CV_XOR_SC_B + 0U, // CV_XOR_SC_H + 0U, // CZERO_EQZ + 0U, // CZERO_NEZ 0U, // C_ADD 0U, // C_ADDI 0U, // C_ADDI16SP - 4U, // C_ADDI4SPN + 0U, // C_ADDI4SPN 0U, // C_ADDIW + 0U, // C_ADDI_HINT_IMM_ZERO + 0U, // C_ADDI_NOP 0U, // C_ADDW + 0U, // C_ADD_HINT 0U, // C_AND 0U, // C_ANDI 0U, // C_BEQZ 0U, // C_BNEZ 0U, // C_EBREAK - 13U, // C_FLD - 13U, // C_FLDSP - 13U, // C_FLW - 13U, // C_FLWSP - 13U, // C_FSD - 13U, // C_FSDSP - 13U, // C_FSW - 13U, // C_FSWSP + 0U, // C_FLD + 0U, // C_FLDSP + 0U, // C_FLW + 0U, // C_FLWSP + 0U, // C_FSD + 0U, // C_FSDSP + 0U, // C_FSW + 0U, // C_FSWSP 0U, // C_J 0U, // C_JAL 0U, // C_JALR 0U, // C_JR - 13U, // C_LD - 13U, // C_LDSP + 0U, // C_LBU + 0U, // C_LD + 0U, // C_LDSP + 0U, // C_LH + 0U, // C_LHU 0U, // C_LI + 0U, // C_LI_HINT 0U, // C_LUI - 13U, // C_LW - 13U, // C_LWSP + 0U, // C_LUI_HINT + 0U, // C_LW + 0U, // C_LWSP + 0U, // C_MUL 0U, // C_MV + 0U, // C_MV_HINT 0U, // C_NOP + 0U, // C_NOP_HINT + 0U, // C_NOT 0U, // C_OR - 13U, // C_SD - 13U, // C_SDSP + 0U, // C_SB + 0U, // C_SD + 0U, // C_SDSP + 0U, // C_SEXT_B + 0U, // C_SEXT_H + 0U, // C_SH 0U, // C_SLLI + 0U, // C_SLLI64_HINT + 0U, // C_SLLI_HINT 0U, // C_SRAI + 0U, // C_SRAI64_HINT 0U, // C_SRLI + 0U, // C_SRLI64_HINT + 0U, // C_SSPOPCHK + 0U, // C_SSPUSH 0U, // C_SUB 0U, // C_SUBW - 13U, // C_SW - 13U, // C_SWSP + 0U, // C_SW + 0U, // C_SWSP 0U, // C_UNIMP 0U, // C_XOR - 4U, // DIV - 4U, // DIVU - 4U, // DIVUW - 4U, // DIVW + 0U, // C_ZEXT_B + 0U, // C_ZEXT_H + 0U, // C_ZEXT_W + 0U, // DIV + 0U, // DIVU + 0U, // DIVUW + 0U, // DIVW + 0U, // DRET 0U, // EBREAK 0U, // ECALL - 36U, // FADD_D - 36U, // FADD_S + 2U, // FADD_D + 2U, // FADD_D_IN32X + 2U, // FADD_D_INX + 2U, // FADD_H + 2U, // FADD_H_INX + 2U, // FADD_S + 2U, // FADD_S_INX 0U, // FCLASS_D + 0U, // FCLASS_D_IN32X + 0U, // FCLASS_D_INX + 0U, // FCLASS_H + 0U, // FCLASS_H_INX 0U, // FCLASS_S - 20U, // FCVT_D_L - 20U, // FCVT_D_LU + 0U, // FCLASS_S_INX + 0U, // FCVTMOD_W_D + 0U, // FCVT_BF16_S + 0U, // FCVT_D_H + 0U, // FCVT_D_H_IN32X + 0U, // FCVT_D_H_INX + 0U, // FCVT_D_L + 0U, // FCVT_D_LU + 0U, // FCVT_D_LU_INX + 0U, // FCVT_D_L_INX 0U, // FCVT_D_S + 0U, // FCVT_D_S_IN32X + 0U, // FCVT_D_S_INX 0U, // FCVT_D_W 0U, // FCVT_D_WU - 20U, // FCVT_LU_D - 20U, // FCVT_LU_S - 20U, // FCVT_L_D - 20U, // FCVT_L_S - 20U, // FCVT_S_D - 20U, // FCVT_S_L - 20U, // FCVT_S_LU - 20U, // FCVT_S_W - 20U, // FCVT_S_WU - 20U, // FCVT_WU_D - 20U, // FCVT_WU_S - 20U, // FCVT_W_D - 20U, // FCVT_W_S - 36U, // FDIV_D - 36U, // FDIV_S + 0U, // FCVT_D_WU_IN32X + 0U, // FCVT_D_WU_INX + 0U, // FCVT_D_W_IN32X + 0U, // FCVT_D_W_INX + 0U, // FCVT_H_D + 0U, // FCVT_H_D_IN32X + 0U, // FCVT_H_D_INX + 0U, // FCVT_H_L + 0U, // FCVT_H_LU + 0U, // FCVT_H_LU_INX + 0U, // FCVT_H_L_INX + 0U, // FCVT_H_S + 0U, // FCVT_H_S_INX + 0U, // FCVT_H_W + 0U, // FCVT_H_WU + 0U, // FCVT_H_WU_INX + 0U, // FCVT_H_W_INX + 0U, // FCVT_LU_D + 0U, // FCVT_LU_D_INX + 0U, // FCVT_LU_H + 0U, // FCVT_LU_H_INX + 0U, // FCVT_LU_S + 0U, // FCVT_LU_S_INX + 0U, // FCVT_L_D + 0U, // FCVT_L_D_INX + 0U, // FCVT_L_H + 0U, // FCVT_L_H_INX + 0U, // FCVT_L_S + 0U, // FCVT_L_S_INX + 0U, // FCVT_S_BF16 + 0U, // FCVT_S_D + 0U, // FCVT_S_D_IN32X + 0U, // FCVT_S_D_INX + 0U, // FCVT_S_H + 0U, // FCVT_S_H_INX + 0U, // FCVT_S_L + 0U, // FCVT_S_LU + 0U, // FCVT_S_LU_INX + 0U, // FCVT_S_L_INX + 0U, // FCVT_S_W + 0U, // FCVT_S_WU + 0U, // FCVT_S_WU_INX + 0U, // FCVT_S_W_INX + 0U, // FCVT_WU_D + 0U, // FCVT_WU_D_IN32X + 0U, // FCVT_WU_D_INX + 0U, // FCVT_WU_H + 0U, // FCVT_WU_H_INX + 0U, // FCVT_WU_S + 0U, // FCVT_WU_S_INX + 0U, // FCVT_W_D + 0U, // FCVT_W_D_IN32X + 0U, // FCVT_W_D_INX + 0U, // FCVT_W_H + 0U, // FCVT_W_H_INX + 0U, // FCVT_W_S + 0U, // FCVT_W_S_INX + 2U, // FDIV_D + 2U, // FDIV_D_IN32X + 2U, // FDIV_D_INX + 2U, // FDIV_H + 2U, // FDIV_H_INX + 2U, // FDIV_S + 2U, // FDIV_S_INX 0U, // FENCE 0U, // FENCE_I 0U, // FENCE_TSO - 4U, // FEQ_D - 4U, // FEQ_S - 13U, // FLD - 4U, // FLE_D - 4U, // FLE_S - 4U, // FLT_D - 4U, // FLT_S - 13U, // FLW - 100U, // FMADD_D - 100U, // FMADD_S - 4U, // FMAX_D - 4U, // FMAX_S - 4U, // FMIN_D - 4U, // FMIN_S - 100U, // FMSUB_D - 100U, // FMSUB_S - 36U, // FMUL_D - 36U, // FMUL_S + 0U, // FEQ_D + 0U, // FEQ_D_IN32X + 0U, // FEQ_D_INX + 0U, // FEQ_H + 0U, // FEQ_H_INX + 0U, // FEQ_S + 0U, // FEQ_S_INX + 0U, // FLD + 0U, // FLEQ_D + 0U, // FLEQ_H + 0U, // FLEQ_S + 0U, // FLE_D + 0U, // FLE_D_IN32X + 0U, // FLE_D_INX + 0U, // FLE_H + 0U, // FLE_H_INX + 0U, // FLE_S + 0U, // FLE_S_INX + 0U, // FLH + 0U, // FLI_D + 0U, // FLI_H + 0U, // FLI_S + 0U, // FLTQ_D + 0U, // FLTQ_H + 0U, // FLTQ_S + 0U, // FLT_D + 0U, // FLT_D_IN32X + 0U, // FLT_D_INX + 0U, // FLT_H + 0U, // FLT_H_INX + 0U, // FLT_S + 0U, // FLT_S_INX + 0U, // FLW + 32U, // FMADD_D + 32U, // FMADD_D_IN32X + 32U, // FMADD_D_INX + 32U, // FMADD_H + 32U, // FMADD_H_INX + 32U, // FMADD_S + 32U, // FMADD_S_INX + 0U, // FMAXM_D + 0U, // FMAXM_H + 0U, // FMAXM_S + 0U, // FMAX_D + 0U, // FMAX_D_IN32X + 0U, // FMAX_D_INX + 0U, // FMAX_H + 0U, // FMAX_H_INX + 0U, // FMAX_S + 0U, // FMAX_S_INX + 0U, // FMINM_D + 0U, // FMINM_H + 0U, // FMINM_S + 0U, // FMIN_D + 0U, // FMIN_D_IN32X + 0U, // FMIN_D_INX + 0U, // FMIN_H + 0U, // FMIN_H_INX + 0U, // FMIN_S + 0U, // FMIN_S_INX + 32U, // FMSUB_D + 32U, // FMSUB_D_IN32X + 32U, // FMSUB_D_INX + 32U, // FMSUB_H + 32U, // FMSUB_H_INX + 32U, // FMSUB_S + 32U, // FMSUB_S_INX + 2U, // FMUL_D + 2U, // FMUL_D_IN32X + 2U, // FMUL_D_INX + 2U, // FMUL_H + 2U, // FMUL_H_INX + 2U, // FMUL_S + 2U, // FMUL_S_INX + 0U, // FMVH_X_D + 0U, // FMVP_D_X 0U, // FMV_D_X + 0U, // FMV_H_X 0U, // FMV_W_X 0U, // FMV_X_D + 0U, // FMV_X_H 0U, // FMV_X_W - 100U, // FNMADD_D - 100U, // FNMADD_S - 100U, // FNMSUB_D - 100U, // FNMSUB_S - 13U, // FSD - 4U, // FSGNJN_D - 4U, // FSGNJN_S - 4U, // FSGNJX_D - 4U, // FSGNJX_S - 4U, // FSGNJ_D - 4U, // FSGNJ_S - 20U, // FSQRT_D - 20U, // FSQRT_S - 36U, // FSUB_D - 36U, // FSUB_S - 13U, // FSW + 0U, // FMV_X_W_FPR64 + 32U, // FNMADD_D + 32U, // FNMADD_D_IN32X + 32U, // FNMADD_D_INX + 32U, // FNMADD_H + 32U, // FNMADD_H_INX + 32U, // FNMADD_S + 32U, // FNMADD_S_INX + 32U, // FNMSUB_D + 32U, // FNMSUB_D_IN32X + 32U, // FNMSUB_D_INX + 32U, // FNMSUB_H + 32U, // FNMSUB_H_INX + 32U, // FNMSUB_S + 32U, // FNMSUB_S_INX + 0U, // FROUNDNX_D + 0U, // FROUNDNX_H + 0U, // FROUNDNX_S + 0U, // FROUND_D + 0U, // FROUND_H + 0U, // FROUND_S + 0U, // FSD + 0U, // FSGNJN_D + 0U, // FSGNJN_D_IN32X + 0U, // FSGNJN_D_INX + 0U, // FSGNJN_H + 0U, // FSGNJN_H_INX + 0U, // FSGNJN_S + 0U, // FSGNJN_S_INX + 0U, // FSGNJX_D + 0U, // FSGNJX_D_IN32X + 0U, // FSGNJX_D_INX + 0U, // FSGNJX_H + 0U, // FSGNJX_H_INX + 0U, // FSGNJX_S + 0U, // FSGNJX_S_INX + 0U, // FSGNJ_D + 0U, // FSGNJ_D_IN32X + 0U, // FSGNJ_D_INX + 0U, // FSGNJ_H + 0U, // FSGNJ_H_INX + 0U, // FSGNJ_S + 0U, // FSGNJ_S_INX + 0U, // FSH + 0U, // FSQRT_D + 0U, // FSQRT_D_IN32X + 0U, // FSQRT_D_INX + 0U, // FSQRT_H + 0U, // FSQRT_H_INX + 0U, // FSQRT_S + 0U, // FSQRT_S_INX + 2U, // FSUB_D + 2U, // FSUB_D_IN32X + 2U, // FSUB_D_INX + 2U, // FSUB_H + 2U, // FSUB_H_INX + 2U, // FSUB_S + 2U, // FSUB_S_INX + 0U, // FSW + 0U, // HFENCE_GVMA + 0U, // HFENCE_VVMA + 0U, // HINVAL_GVMA + 0U, // HINVAL_VVMA + 0U, // HLVX_HU + 0U, // HLVX_WU + 0U, // HLV_B + 0U, // HLV_BU + 0U, // HLV_D + 0U, // HLV_H + 0U, // HLV_HU + 0U, // HLV_W + 0U, // HLV_WU + 0U, // HSV_B + 0U, // HSV_D + 0U, // HSV_H + 0U, // HSV_W + 64U, // InsnB + 12U, // InsnCA + 16U, // InsnCB + 0U, // InsnCI + 0U, // InsnCIW + 0U, // InsnCJ + 104U, // InsnCL + 0U, // InsnCR + 104U, // InsnCS + 0U, // InsnCSS + 192U, // InsnI + 104U, // InsnI_Mem + 0U, // InsnJ + 332U, // InsnR + 844U, // InsnR4 + 104U, // InsnS + 0U, // InsnU 0U, // JAL - 4U, // JALR - 13U, // LB - 13U, // LBU - 13U, // LD - 13U, // LH - 13U, // LHU + 0U, // JALR + 0U, // LB + 0U, // LBU + 0U, // LD + 0U, // LH + 0U, // LHU 0U, // LR_D 0U, // LR_D_AQ 0U, // LR_D_AQ_RL @@ -1133,90 +26869,1049 @@ static void printInstruction(MCInst *MI, SStream *O, MCRegisterInfo *MRI) 0U, // LR_W_AQ_RL 0U, // LR_W_RL 0U, // LUI - 13U, // LW - 13U, // LWU + 0U, // LW + 0U, // LWU + 0U, // MAX + 0U, // MAXU + 0U, // MIN + 0U, // MINU + 0U, // MOPR0 + 0U, // MOPR1 + 0U, // MOPR10 + 0U, // MOPR11 + 0U, // MOPR12 + 0U, // MOPR13 + 0U, // MOPR14 + 0U, // MOPR15 + 0U, // MOPR16 + 0U, // MOPR17 + 0U, // MOPR18 + 0U, // MOPR19 + 0U, // MOPR2 + 0U, // MOPR20 + 0U, // MOPR21 + 0U, // MOPR22 + 0U, // MOPR23 + 0U, // MOPR24 + 0U, // MOPR25 + 0U, // MOPR26 + 0U, // MOPR27 + 0U, // MOPR28 + 0U, // MOPR29 + 0U, // MOPR3 + 0U, // MOPR30 + 0U, // MOPR31 + 0U, // MOPR4 + 0U, // MOPR5 + 0U, // MOPR6 + 0U, // MOPR7 + 0U, // MOPR8 + 0U, // MOPR9 + 0U, // MOPRR0 + 0U, // MOPRR1 + 0U, // MOPRR2 + 0U, // MOPRR3 + 0U, // MOPRR4 + 0U, // MOPRR5 + 0U, // MOPRR6 + 0U, // MOPRR7 0U, // MRET - 4U, // MUL - 4U, // MULH - 4U, // MULHSU - 4U, // MULHU - 4U, // MULW - 4U, // OR - 4U, // ORI - 4U, // REM - 4U, // REMU - 4U, // REMUW - 4U, // REMW - 13U, // SB - 9U, // SC_D - 9U, // SC_D_AQ - 9U, // SC_D_AQ_RL - 9U, // SC_D_RL - 9U, // SC_W - 9U, // SC_W_AQ - 9U, // SC_W_AQ_RL - 9U, // SC_W_RL - 13U, // SD + 0U, // MUL + 0U, // MULH + 0U, // MULHSU + 0U, // MULHU + 0U, // MULW + 0U, // OR + 0U, // ORC_B + 0U, // ORI + 0U, // ORN + 0U, // PACK + 0U, // PACKH + 0U, // PACKW + 0U, // PREFETCH_I + 0U, // PREFETCH_R + 0U, // PREFETCH_W + 0U, // REM + 0U, // REMU + 0U, // REMUW + 0U, // REMW + 0U, // REV8_RV32 + 0U, // REV8_RV64 + 0U, // ROL + 0U, // ROLW + 0U, // ROR + 0U, // RORI + 0U, // RORIW + 0U, // RORW + 0U, // SB + 0U, // SC_D + 0U, // SC_D_AQ + 0U, // SC_D_AQ_RL + 0U, // SC_D_RL + 0U, // SC_W + 0U, // SC_W_AQ + 0U, // SC_W_AQ_RL + 0U, // SC_W_RL + 0U, // SD + 0U, // SEXT_B + 0U, // SEXT_H + 0U, // SFENCE_INVAL_IR 0U, // SFENCE_VMA - 13U, // SH - 4U, // SLL - 4U, // SLLI - 4U, // SLLIW - 4U, // SLLW - 4U, // SLT - 4U, // SLTI - 4U, // SLTIU - 4U, // SLTU - 4U, // SRA - 4U, // SRAI - 4U, // SRAIW - 4U, // SRAW + 0U, // SFENCE_W_INVAL + 0U, // SH + 0U, // SH1ADD + 0U, // SH1ADD_UW + 0U, // SH2ADD + 0U, // SH2ADD_UW + 0U, // SH3ADD + 0U, // SH3ADD_UW + 0U, // SHA256SIG0 + 0U, // SHA256SIG1 + 0U, // SHA256SUM0 + 0U, // SHA256SUM1 + 0U, // SHA512SIG0 + 0U, // SHA512SIG0H + 0U, // SHA512SIG0L + 0U, // SHA512SIG1 + 0U, // SHA512SIG1H + 0U, // SHA512SIG1L + 0U, // SHA512SUM0 + 0U, // SHA512SUM0R + 0U, // SHA512SUM1 + 0U, // SHA512SUM1R + 0U, // SINVAL_VMA + 0U, // SLL + 0U, // SLLI + 0U, // SLLIW + 0U, // SLLI_UW + 0U, // SLLW + 0U, // SLT + 0U, // SLTI + 0U, // SLTIU + 0U, // SLTU + 0U, // SM3P0 + 0U, // SM3P1 + 0U, // SM4ED + 0U, // SM4KS + 0U, // SRA + 0U, // SRAI + 0U, // SRAIW + 0U, // SRAW 0U, // SRET - 4U, // SRL - 4U, // SRLI - 4U, // SRLIW - 4U, // SRLW - 4U, // SUB - 4U, // SUBW - 13U, // SW + 0U, // SRL + 0U, // SRLI + 0U, // SRLIW + 0U, // SRLW + 0U, // SSAMOSWAP_D + 0U, // SSAMOSWAP_D_AQ + 0U, // SSAMOSWAP_D_AQ_RL + 0U, // SSAMOSWAP_D_RL + 0U, // SSAMOSWAP_W + 0U, // SSAMOSWAP_W_AQ + 0U, // SSAMOSWAP_W_AQ_RL + 0U, // SSAMOSWAP_W_RL + 0U, // SSPOPCHK + 0U, // SSPUSH + 0U, // SSRDP + 0U, // SUB + 0U, // SUBW + 0U, // SW + 21U, // THVdotVMAQASU_VV + 21U, // THVdotVMAQASU_VX + 21U, // THVdotVMAQAUS_VX + 21U, // THVdotVMAQAU_VV + 21U, // THVdotVMAQAU_VX + 21U, // THVdotVMAQA_VV + 21U, // THVdotVMAQA_VX + 0U, // TH_ADDSL + 0U, // TH_DCACHE_CALL + 0U, // TH_DCACHE_CIALL + 0U, // TH_DCACHE_CIPA + 0U, // TH_DCACHE_CISW + 0U, // TH_DCACHE_CIVA + 0U, // TH_DCACHE_CPA + 0U, // TH_DCACHE_CPAL1 + 0U, // TH_DCACHE_CSW + 0U, // TH_DCACHE_CVA + 0U, // TH_DCACHE_CVAL1 + 0U, // TH_DCACHE_IALL + 0U, // TH_DCACHE_IPA + 0U, // TH_DCACHE_ISW + 0U, // TH_DCACHE_IVA + 0U, // TH_EXT + 0U, // TH_EXTU + 0U, // TH_FF0 + 0U, // TH_FF1 + 0U, // TH_FLRD + 0U, // TH_FLRW + 0U, // TH_FLURD + 0U, // TH_FLURW + 0U, // TH_FSRD + 0U, // TH_FSRW + 0U, // TH_FSURD + 0U, // TH_FSURW + 0U, // TH_ICACHE_IALL + 0U, // TH_ICACHE_IALLS + 0U, // TH_ICACHE_IPA + 0U, // TH_ICACHE_IVA + 0U, // TH_L2CACHE_CALL + 0U, // TH_L2CACHE_CIALL + 0U, // TH_L2CACHE_IALL + 0U, // TH_LBIA + 0U, // TH_LBIB + 0U, // TH_LBUIA + 0U, // TH_LBUIB + 0U, // TH_LDD + 0U, // TH_LDIA + 0U, // TH_LDIB + 0U, // TH_LHIA + 0U, // TH_LHIB + 0U, // TH_LHUIA + 0U, // TH_LHUIB + 0U, // TH_LRB + 0U, // TH_LRBU + 0U, // TH_LRD + 0U, // TH_LRH + 0U, // TH_LRHU + 0U, // TH_LRW + 0U, // TH_LRWU + 0U, // TH_LURB + 0U, // TH_LURBU + 0U, // TH_LURD + 0U, // TH_LURH + 0U, // TH_LURHU + 0U, // TH_LURW + 0U, // TH_LURWU + 0U, // TH_LWD + 0U, // TH_LWIA + 0U, // TH_LWIB + 0U, // TH_LWUD + 0U, // TH_LWUIA + 0U, // TH_LWUIB + 0U, // TH_MULA + 0U, // TH_MULAH + 0U, // TH_MULAW + 0U, // TH_MULS + 0U, // TH_MULSH + 0U, // TH_MULSW + 0U, // TH_MVEQZ + 0U, // TH_MVNEZ + 0U, // TH_REV + 0U, // TH_REVW + 0U, // TH_SBIA + 0U, // TH_SBIB + 0U, // TH_SDD + 0U, // TH_SDIA + 0U, // TH_SDIB + 0U, // TH_SFENCE_VMAS + 0U, // TH_SHIA + 0U, // TH_SHIB + 0U, // TH_SRB + 0U, // TH_SRD + 0U, // TH_SRH + 0U, // TH_SRRI + 0U, // TH_SRRIW + 0U, // TH_SRW + 0U, // TH_SURB + 0U, // TH_SURD + 0U, // TH_SURH + 0U, // TH_SURW + 0U, // TH_SWD + 0U, // TH_SWIA + 0U, // TH_SWIB + 0U, // TH_SYNC + 0U, // TH_SYNC_I + 0U, // TH_SYNC_IS + 0U, // TH_SYNC_S + 0U, // TH_TST + 0U, // TH_TSTNBZ 0U, // UNIMP - 0U, // URET + 0U, // UNZIP_RV32 + 1U, // VAADDU_VV + 1U, // VAADDU_VX + 1U, // VAADD_VV + 1U, // VAADD_VX + 2U, // VADC_VIM + 2U, // VADC_VVM + 2U, // VADC_VXM + 1U, // VADD_VI + 1U, // VADD_VV + 1U, // VADD_VX + 0U, // VAESDF_VS + 0U, // VAESDF_VV + 0U, // VAESDM_VS + 0U, // VAESDM_VV + 0U, // VAESEF_VS + 0U, // VAESEF_VV + 0U, // VAESEM_VS + 0U, // VAESEM_VV + 0U, // VAESKF1_VI + 0U, // VAESKF2_VI + 0U, // VAESZ_VS + 1U, // VANDN_VV + 1U, // VANDN_VX + 1U, // VAND_VI + 1U, // VAND_VV + 1U, // VAND_VX + 1U, // VASUBU_VV + 1U, // VASUBU_VX + 1U, // VASUB_VV + 1U, // VASUB_VX + 0U, // VBREV8_V + 0U, // VBREV_V + 1U, // VCLMULH_VV + 1U, // VCLMULH_VX + 1U, // VCLMUL_VV + 1U, // VCLMUL_VX + 0U, // VCLZ_V + 0U, // VCOMPRESS_VM + 0U, // VCPOP_M + 0U, // VCPOP_V + 0U, // VCTZ_V + 0U, // VC_FV + 0U, // VC_FVV + 0U, // VC_FVW + 0U, // VC_I + 0U, // VC_IV + 0U, // VC_IVV + 0U, // VC_IVW + 0U, // VC_VV + 0U, // VC_VVV + 0U, // VC_VVW + 0U, // VC_V_FV + 8U, // VC_V_FVV + 8U, // VC_V_FVW + 0U, // VC_V_I + 0U, // VC_V_IV + 8U, // VC_V_IVV + 8U, // VC_V_IVW + 0U, // VC_V_VV + 8U, // VC_V_VVV + 8U, // VC_V_VVW + 0U, // VC_V_X + 0U, // VC_V_XV + 8U, // VC_V_XVV + 8U, // VC_V_XVW + 0U, // VC_X + 0U, // VC_XV + 0U, // VC_XVV + 0U, // VC_XVW + 1U, // VDIVU_VV + 1U, // VDIVU_VX + 1U, // VDIV_VV + 1U, // VDIV_VX + 1U, // VFADD_VF + 1U, // VFADD_VV + 0U, // VFCLASS_V + 0U, // VFCVT_F_XU_V + 0U, // VFCVT_F_X_V + 0U, // VFCVT_RTZ_XU_F_V + 0U, // VFCVT_RTZ_X_F_V + 0U, // VFCVT_XU_F_V + 0U, // VFCVT_X_F_V + 1U, // VFDIV_VF + 1U, // VFDIV_VV + 0U, // VFIRST_M + 21U, // VFMACC_VF + 21U, // VFMACC_VV + 21U, // VFMADD_VF + 21U, // VFMADD_VV + 1U, // VFMAX_VF + 1U, // VFMAX_VV + 2U, // VFMERGE_VFM + 1U, // VFMIN_VF + 1U, // VFMIN_VV + 21U, // VFMSAC_VF + 21U, // VFMSAC_VV + 21U, // VFMSUB_VF + 21U, // VFMSUB_VV + 1U, // VFMUL_VF + 1U, // VFMUL_VV + 0U, // VFMV_F_S + 0U, // VFMV_S_F + 0U, // VFMV_V_F + 0U, // VFNCVTBF16_F_F_W + 0U, // VFNCVT_F_F_W + 0U, // VFNCVT_F_XU_W + 0U, // VFNCVT_F_X_W + 0U, // VFNCVT_ROD_F_F_W + 0U, // VFNCVT_RTZ_XU_F_W + 0U, // VFNCVT_RTZ_X_F_W + 0U, // VFNCVT_XU_F_W + 0U, // VFNCVT_X_F_W + 21U, // VFNMACC_VF + 21U, // VFNMACC_VV + 21U, // VFNMADD_VF + 21U, // VFNMADD_VV + 21U, // VFNMSAC_VF + 21U, // VFNMSAC_VV + 21U, // VFNMSUB_VF + 21U, // VFNMSUB_VV + 1U, // VFNRCLIP_XU_F_QF + 1U, // VFNRCLIP_X_F_QF + 1U, // VFRDIV_VF + 0U, // VFREC7_V + 1U, // VFREDMAX_VS + 1U, // VFREDMIN_VS + 1U, // VFREDOSUM_VS + 1U, // VFREDUSUM_VS + 0U, // VFRSQRT7_V + 1U, // VFRSUB_VF + 1U, // VFSGNJN_VF + 1U, // VFSGNJN_VV + 1U, // VFSGNJX_VF + 1U, // VFSGNJX_VV + 1U, // VFSGNJ_VF + 1U, // VFSGNJ_VV + 1U, // VFSLIDE1DOWN_VF + 1U, // VFSLIDE1UP_VF + 0U, // VFSQRT_V + 1U, // VFSUB_VF + 1U, // VFSUB_VV + 1U, // VFWADD_VF + 1U, // VFWADD_VV + 1U, // VFWADD_WF + 1U, // VFWADD_WV + 0U, // VFWCVTBF16_F_F_V + 0U, // VFWCVT_F_F_V + 0U, // VFWCVT_F_XU_V + 0U, // VFWCVT_F_X_V + 0U, // VFWCVT_RTZ_XU_F_V + 0U, // VFWCVT_RTZ_X_F_V + 0U, // VFWCVT_XU_F_V + 0U, // VFWCVT_X_F_V + 21U, // VFWMACCBF16_VF + 21U, // VFWMACCBF16_VV + 0U, // VFWMACC_4x4x4 + 21U, // VFWMACC_VF + 21U, // VFWMACC_VV + 21U, // VFWMSAC_VF + 21U, // VFWMSAC_VV + 1U, // VFWMUL_VF + 1U, // VFWMUL_VV + 21U, // VFWNMACC_VF + 21U, // VFWNMACC_VV + 21U, // VFWNMSAC_VF + 21U, // VFWNMSAC_VV + 1U, // VFWREDOSUM_VS + 1U, // VFWREDUSUM_VS + 1U, // VFWSUB_VF + 1U, // VFWSUB_VV + 1U, // VFWSUB_WF + 1U, // VFWSUB_WV + 0U, // VGHSH_VV + 0U, // VGMUL_VV + 0U, // VID_V + 0U, // VIOTA_M + 0U, // VL1RE16_V + 0U, // VL1RE32_V + 0U, // VL1RE64_V + 0U, // VL1RE8_V + 0U, // VL2RE16_V + 0U, // VL2RE32_V + 0U, // VL2RE64_V + 0U, // VL2RE8_V + 0U, // VL4RE16_V + 0U, // VL4RE32_V + 0U, // VL4RE64_V + 0U, // VL4RE8_V + 0U, // VL8RE16_V + 0U, // VL8RE32_V + 0U, // VL8RE64_V + 0U, // VL8RE8_V + 0U, // VLE16FF_V + 0U, // VLE16_V + 0U, // VLE32FF_V + 0U, // VLE32_V + 0U, // VLE64FF_V + 0U, // VLE64_V + 0U, // VLE8FF_V + 0U, // VLE8_V + 0U, // VLM_V + 1U, // VLOXEI16_V + 1U, // VLOXEI32_V + 1U, // VLOXEI64_V + 1U, // VLOXEI8_V + 1U, // VLOXSEG2EI16_V + 1U, // VLOXSEG2EI32_V + 1U, // VLOXSEG2EI64_V + 1U, // VLOXSEG2EI8_V + 1U, // VLOXSEG3EI16_V + 1U, // VLOXSEG3EI32_V + 1U, // VLOXSEG3EI64_V + 1U, // VLOXSEG3EI8_V + 1U, // VLOXSEG4EI16_V + 1U, // VLOXSEG4EI32_V + 1U, // VLOXSEG4EI64_V + 1U, // VLOXSEG4EI8_V + 1U, // VLOXSEG5EI16_V + 1U, // VLOXSEG5EI32_V + 1U, // VLOXSEG5EI64_V + 1U, // VLOXSEG5EI8_V + 1U, // VLOXSEG6EI16_V + 1U, // VLOXSEG6EI32_V + 1U, // VLOXSEG6EI64_V + 1U, // VLOXSEG6EI8_V + 1U, // VLOXSEG7EI16_V + 1U, // VLOXSEG7EI32_V + 1U, // VLOXSEG7EI64_V + 1U, // VLOXSEG7EI8_V + 1U, // VLOXSEG8EI16_V + 1U, // VLOXSEG8EI32_V + 1U, // VLOXSEG8EI64_V + 1U, // VLOXSEG8EI8_V + 1U, // VLSE16_V + 1U, // VLSE32_V + 1U, // VLSE64_V + 1U, // VLSE8_V + 0U, // VLSEG2E16FF_V + 0U, // VLSEG2E16_V + 0U, // VLSEG2E32FF_V + 0U, // VLSEG2E32_V + 0U, // VLSEG2E64FF_V + 0U, // VLSEG2E64_V + 0U, // VLSEG2E8FF_V + 0U, // VLSEG2E8_V + 0U, // VLSEG3E16FF_V + 0U, // VLSEG3E16_V + 0U, // VLSEG3E32FF_V + 0U, // VLSEG3E32_V + 0U, // VLSEG3E64FF_V + 0U, // VLSEG3E64_V + 0U, // VLSEG3E8FF_V + 0U, // VLSEG3E8_V + 0U, // VLSEG4E16FF_V + 0U, // VLSEG4E16_V + 0U, // VLSEG4E32FF_V + 0U, // VLSEG4E32_V + 0U, // VLSEG4E64FF_V + 0U, // VLSEG4E64_V + 0U, // VLSEG4E8FF_V + 0U, // VLSEG4E8_V + 0U, // VLSEG5E16FF_V + 0U, // VLSEG5E16_V + 0U, // VLSEG5E32FF_V + 0U, // VLSEG5E32_V + 0U, // VLSEG5E64FF_V + 0U, // VLSEG5E64_V + 0U, // VLSEG5E8FF_V + 0U, // VLSEG5E8_V + 0U, // VLSEG6E16FF_V + 0U, // VLSEG6E16_V + 0U, // VLSEG6E32FF_V + 0U, // VLSEG6E32_V + 0U, // VLSEG6E64FF_V + 0U, // VLSEG6E64_V + 0U, // VLSEG6E8FF_V + 0U, // VLSEG6E8_V + 0U, // VLSEG7E16FF_V + 0U, // VLSEG7E16_V + 0U, // VLSEG7E32FF_V + 0U, // VLSEG7E32_V + 0U, // VLSEG7E64FF_V + 0U, // VLSEG7E64_V + 0U, // VLSEG7E8FF_V + 0U, // VLSEG7E8_V + 0U, // VLSEG8E16FF_V + 0U, // VLSEG8E16_V + 0U, // VLSEG8E32FF_V + 0U, // VLSEG8E32_V + 0U, // VLSEG8E64FF_V + 0U, // VLSEG8E64_V + 0U, // VLSEG8E8FF_V + 0U, // VLSEG8E8_V + 1U, // VLSSEG2E16_V + 1U, // VLSSEG2E32_V + 1U, // VLSSEG2E64_V + 1U, // VLSSEG2E8_V + 1U, // VLSSEG3E16_V + 1U, // VLSSEG3E32_V + 1U, // VLSSEG3E64_V + 1U, // VLSSEG3E8_V + 1U, // VLSSEG4E16_V + 1U, // VLSSEG4E32_V + 1U, // VLSSEG4E64_V + 1U, // VLSSEG4E8_V + 1U, // VLSSEG5E16_V + 1U, // VLSSEG5E32_V + 1U, // VLSSEG5E64_V + 1U, // VLSSEG5E8_V + 1U, // VLSSEG6E16_V + 1U, // VLSSEG6E32_V + 1U, // VLSSEG6E64_V + 1U, // VLSSEG6E8_V + 1U, // VLSSEG7E16_V + 1U, // VLSSEG7E32_V + 1U, // VLSSEG7E64_V + 1U, // VLSSEG7E8_V + 1U, // VLSSEG8E16_V + 1U, // VLSSEG8E32_V + 1U, // VLSSEG8E64_V + 1U, // VLSSEG8E8_V + 1U, // VLUXEI16_V + 1U, // VLUXEI32_V + 1U, // VLUXEI64_V + 1U, // VLUXEI8_V + 1U, // VLUXSEG2EI16_V + 1U, // VLUXSEG2EI32_V + 1U, // VLUXSEG2EI64_V + 1U, // VLUXSEG2EI8_V + 1U, // VLUXSEG3EI16_V + 1U, // VLUXSEG3EI32_V + 1U, // VLUXSEG3EI64_V + 1U, // VLUXSEG3EI8_V + 1U, // VLUXSEG4EI16_V + 1U, // VLUXSEG4EI32_V + 1U, // VLUXSEG4EI64_V + 1U, // VLUXSEG4EI8_V + 1U, // VLUXSEG5EI16_V + 1U, // VLUXSEG5EI32_V + 1U, // VLUXSEG5EI64_V + 1U, // VLUXSEG5EI8_V + 1U, // VLUXSEG6EI16_V + 1U, // VLUXSEG6EI32_V + 1U, // VLUXSEG6EI64_V + 1U, // VLUXSEG6EI8_V + 1U, // VLUXSEG7EI16_V + 1U, // VLUXSEG7EI32_V + 1U, // VLUXSEG7EI64_V + 1U, // VLUXSEG7EI8_V + 1U, // VLUXSEG8EI16_V + 1U, // VLUXSEG8EI32_V + 1U, // VLUXSEG8EI64_V + 1U, // VLUXSEG8EI8_V + 21U, // VMACC_VV + 21U, // VMACC_VX + 0U, // VMADC_VI + 2U, // VMADC_VIM + 0U, // VMADC_VV + 2U, // VMADC_VVM + 0U, // VMADC_VX + 2U, // VMADC_VXM + 21U, // VMADD_VV + 21U, // VMADD_VX + 0U, // VMANDN_MM + 0U, // VMAND_MM + 1U, // VMAXU_VV + 1U, // VMAXU_VX + 1U, // VMAX_VV + 1U, // VMAX_VX + 2U, // VMERGE_VIM + 2U, // VMERGE_VVM + 2U, // VMERGE_VXM + 1U, // VMFEQ_VF + 1U, // VMFEQ_VV + 1U, // VMFGE_VF + 1U, // VMFGT_VF + 1U, // VMFLE_VF + 1U, // VMFLE_VV + 1U, // VMFLT_VF + 1U, // VMFLT_VV + 1U, // VMFNE_VF + 1U, // VMFNE_VV + 1U, // VMINU_VV + 1U, // VMINU_VX + 1U, // VMIN_VV + 1U, // VMIN_VX + 0U, // VMNAND_MM + 0U, // VMNOR_MM + 0U, // VMORN_MM + 0U, // VMOR_MM + 0U, // VMSBC_VV + 2U, // VMSBC_VVM + 0U, // VMSBC_VX + 2U, // VMSBC_VXM + 0U, // VMSBF_M + 1U, // VMSEQ_VI + 1U, // VMSEQ_VV + 1U, // VMSEQ_VX + 1U, // VMSGTU_VI + 1U, // VMSGTU_VX + 1U, // VMSGT_VI + 1U, // VMSGT_VX + 0U, // VMSIF_M + 1U, // VMSLEU_VI + 1U, // VMSLEU_VV + 1U, // VMSLEU_VX + 1U, // VMSLE_VI + 1U, // VMSLE_VV + 1U, // VMSLE_VX + 1U, // VMSLTU_VV + 1U, // VMSLTU_VX + 1U, // VMSLT_VV + 1U, // VMSLT_VX + 1U, // VMSNE_VI + 1U, // VMSNE_VV + 1U, // VMSNE_VX + 0U, // VMSOF_M + 1U, // VMULHSU_VV + 1U, // VMULHSU_VX + 1U, // VMULHU_VV + 1U, // VMULHU_VX + 1U, // VMULH_VV + 1U, // VMULH_VX + 1U, // VMUL_VV + 1U, // VMUL_VX + 0U, // VMV1R_V + 0U, // VMV2R_V + 0U, // VMV4R_V + 0U, // VMV8R_V + 0U, // VMV_S_X + 0U, // VMV_V_I + 0U, // VMV_V_V + 0U, // VMV_V_X + 0U, // VMV_X_S + 0U, // VMXNOR_MM + 0U, // VMXOR_MM + 1U, // VNCLIPU_WI + 1U, // VNCLIPU_WV + 1U, // VNCLIPU_WX + 1U, // VNCLIP_WI + 1U, // VNCLIP_WV + 1U, // VNCLIP_WX + 21U, // VNMSAC_VV + 21U, // VNMSAC_VX + 21U, // VNMSUB_VV + 21U, // VNMSUB_VX + 1U, // VNSRA_WI + 1U, // VNSRA_WV + 1U, // VNSRA_WX + 1U, // VNSRL_WI + 1U, // VNSRL_WV + 1U, // VNSRL_WX + 1U, // VOR_VI + 1U, // VOR_VV + 1U, // VOR_VX + 0U, // VQMACCSU_2x8x2 + 0U, // VQMACCSU_4x8x4 + 0U, // VQMACCUS_2x8x2 + 0U, // VQMACCUS_4x8x4 + 0U, // VQMACCU_2x8x2 + 0U, // VQMACCU_4x8x4 + 0U, // VQMACC_2x8x2 + 0U, // VQMACC_4x8x4 + 1U, // VREDAND_VS + 1U, // VREDMAXU_VS + 1U, // VREDMAX_VS + 1U, // VREDMINU_VS + 1U, // VREDMIN_VS + 1U, // VREDOR_VS + 1U, // VREDSUM_VS + 1U, // VREDXOR_VS + 1U, // VREMU_VV + 1U, // VREMU_VX + 1U, // VREM_VV + 1U, // VREM_VX + 0U, // VREV8_V + 1U, // VRGATHEREI16_VV + 1U, // VRGATHER_VI + 1U, // VRGATHER_VV + 1U, // VRGATHER_VX + 1U, // VROL_VV + 1U, // VROL_VX + 1U, // VROR_VI + 1U, // VROR_VV + 1U, // VROR_VX + 1U, // VRSUB_VI + 1U, // VRSUB_VX + 0U, // VS1R_V + 0U, // VS2R_V + 0U, // VS4R_V + 0U, // VS8R_V + 1U, // VSADDU_VI + 1U, // VSADDU_VV + 1U, // VSADDU_VX + 1U, // VSADD_VI + 1U, // VSADD_VV + 1U, // VSADD_VX + 2U, // VSBC_VVM + 2U, // VSBC_VXM + 0U, // VSE16_V + 0U, // VSE32_V + 0U, // VSE64_V + 0U, // VSE8_V + 0U, // VSETIVLI + 0U, // VSETVL + 0U, // VSETVLI + 0U, // VSEXT_VF2 + 0U, // VSEXT_VF4 + 0U, // VSEXT_VF8 + 0U, // VSHA2CH_VV + 0U, // VSHA2CL_VV + 0U, // VSHA2MS_VV + 1U, // VSLIDE1DOWN_VX + 1U, // VSLIDE1UP_VX + 1U, // VSLIDEDOWN_VI + 1U, // VSLIDEDOWN_VX + 1U, // VSLIDEUP_VI + 1U, // VSLIDEUP_VX + 1U, // VSLL_VI + 1U, // VSLL_VV + 1U, // VSLL_VX + 0U, // VSM3C_VI + 0U, // VSM3ME_VV + 0U, // VSM4K_VI + 0U, // VSM4R_VS + 0U, // VSM4R_VV + 1U, // VSMUL_VV + 1U, // VSMUL_VX + 0U, // VSM_V + 1U, // VSOXEI16_V + 1U, // VSOXEI32_V + 1U, // VSOXEI64_V + 1U, // VSOXEI8_V + 1U, // VSOXSEG2EI16_V + 1U, // VSOXSEG2EI32_V + 1U, // VSOXSEG2EI64_V + 1U, // VSOXSEG2EI8_V + 1U, // VSOXSEG3EI16_V + 1U, // VSOXSEG3EI32_V + 1U, // VSOXSEG3EI64_V + 1U, // VSOXSEG3EI8_V + 1U, // VSOXSEG4EI16_V + 1U, // VSOXSEG4EI32_V + 1U, // VSOXSEG4EI64_V + 1U, // VSOXSEG4EI8_V + 1U, // VSOXSEG5EI16_V + 1U, // VSOXSEG5EI32_V + 1U, // VSOXSEG5EI64_V + 1U, // VSOXSEG5EI8_V + 1U, // VSOXSEG6EI16_V + 1U, // VSOXSEG6EI32_V + 1U, // VSOXSEG6EI64_V + 1U, // VSOXSEG6EI8_V + 1U, // VSOXSEG7EI16_V + 1U, // VSOXSEG7EI32_V + 1U, // VSOXSEG7EI64_V + 1U, // VSOXSEG7EI8_V + 1U, // VSOXSEG8EI16_V + 1U, // VSOXSEG8EI32_V + 1U, // VSOXSEG8EI64_V + 1U, // VSOXSEG8EI8_V + 1U, // VSRA_VI + 1U, // VSRA_VV + 1U, // VSRA_VX + 1U, // VSRL_VI + 1U, // VSRL_VV + 1U, // VSRL_VX + 1U, // VSSE16_V + 1U, // VSSE32_V + 1U, // VSSE64_V + 1U, // VSSE8_V + 0U, // VSSEG2E16_V + 0U, // VSSEG2E32_V + 0U, // VSSEG2E64_V + 0U, // VSSEG2E8_V + 0U, // VSSEG3E16_V + 0U, // VSSEG3E32_V + 0U, // VSSEG3E64_V + 0U, // VSSEG3E8_V + 0U, // VSSEG4E16_V + 0U, // VSSEG4E32_V + 0U, // VSSEG4E64_V + 0U, // VSSEG4E8_V + 0U, // VSSEG5E16_V + 0U, // VSSEG5E32_V + 0U, // VSSEG5E64_V + 0U, // VSSEG5E8_V + 0U, // VSSEG6E16_V + 0U, // VSSEG6E32_V + 0U, // VSSEG6E64_V + 0U, // VSSEG6E8_V + 0U, // VSSEG7E16_V + 0U, // VSSEG7E32_V + 0U, // VSSEG7E64_V + 0U, // VSSEG7E8_V + 0U, // VSSEG8E16_V + 0U, // VSSEG8E32_V + 0U, // VSSEG8E64_V + 0U, // VSSEG8E8_V + 1U, // VSSRA_VI + 1U, // VSSRA_VV + 1U, // VSSRA_VX + 1U, // VSSRL_VI + 1U, // VSSRL_VV + 1U, // VSSRL_VX + 1U, // VSSSEG2E16_V + 1U, // VSSSEG2E32_V + 1U, // VSSSEG2E64_V + 1U, // VSSSEG2E8_V + 1U, // VSSSEG3E16_V + 1U, // VSSSEG3E32_V + 1U, // VSSSEG3E64_V + 1U, // VSSSEG3E8_V + 1U, // VSSSEG4E16_V + 1U, // VSSSEG4E32_V + 1U, // VSSSEG4E64_V + 1U, // VSSSEG4E8_V + 1U, // VSSSEG5E16_V + 1U, // VSSSEG5E32_V + 1U, // VSSSEG5E64_V + 1U, // VSSSEG5E8_V + 1U, // VSSSEG6E16_V + 1U, // VSSSEG6E32_V + 1U, // VSSSEG6E64_V + 1U, // VSSSEG6E8_V + 1U, // VSSSEG7E16_V + 1U, // VSSSEG7E32_V + 1U, // VSSSEG7E64_V + 1U, // VSSSEG7E8_V + 1U, // VSSSEG8E16_V + 1U, // VSSSEG8E32_V + 1U, // VSSSEG8E64_V + 1U, // VSSSEG8E8_V + 1U, // VSSUBU_VV + 1U, // VSSUBU_VX + 1U, // VSSUB_VV + 1U, // VSSUB_VX + 1U, // VSUB_VV + 1U, // VSUB_VX + 1U, // VSUXEI16_V + 1U, // VSUXEI32_V + 1U, // VSUXEI64_V + 1U, // VSUXEI8_V + 1U, // VSUXSEG2EI16_V + 1U, // VSUXSEG2EI32_V + 1U, // VSUXSEG2EI64_V + 1U, // VSUXSEG2EI8_V + 1U, // VSUXSEG3EI16_V + 1U, // VSUXSEG3EI32_V + 1U, // VSUXSEG3EI64_V + 1U, // VSUXSEG3EI8_V + 1U, // VSUXSEG4EI16_V + 1U, // VSUXSEG4EI32_V + 1U, // VSUXSEG4EI64_V + 1U, // VSUXSEG4EI8_V + 1U, // VSUXSEG5EI16_V + 1U, // VSUXSEG5EI32_V + 1U, // VSUXSEG5EI64_V + 1U, // VSUXSEG5EI8_V + 1U, // VSUXSEG6EI16_V + 1U, // VSUXSEG6EI32_V + 1U, // VSUXSEG6EI64_V + 1U, // VSUXSEG6EI8_V + 1U, // VSUXSEG7EI16_V + 1U, // VSUXSEG7EI32_V + 1U, // VSUXSEG7EI64_V + 1U, // VSUXSEG7EI8_V + 1U, // VSUXSEG8EI16_V + 1U, // VSUXSEG8EI32_V + 1U, // VSUXSEG8EI64_V + 1U, // VSUXSEG8EI8_V + 0U, // VT_MASKC + 0U, // VT_MASKCN + 1U, // VWADDU_VV + 1U, // VWADDU_VX + 1U, // VWADDU_WV + 1U, // VWADDU_WX + 1U, // VWADD_VV + 1U, // VWADD_VX + 1U, // VWADD_WV + 1U, // VWADD_WX + 21U, // VWMACCSU_VV + 21U, // VWMACCSU_VX + 21U, // VWMACCUS_VX + 21U, // VWMACCU_VV + 21U, // VWMACCU_VX + 21U, // VWMACC_VV + 21U, // VWMACC_VX + 1U, // VWMULSU_VV + 1U, // VWMULSU_VX + 1U, // VWMULU_VV + 1U, // VWMULU_VX + 1U, // VWMUL_VV + 1U, // VWMUL_VX + 1U, // VWREDSUMU_VS + 1U, // VWREDSUM_VS + 1U, // VWSLL_VI + 1U, // VWSLL_VV + 1U, // VWSLL_VX + 1U, // VWSUBU_VV + 1U, // VWSUBU_VX + 1U, // VWSUBU_WV + 1U, // VWSUBU_WX + 1U, // VWSUB_VV + 1U, // VWSUB_VX + 1U, // VWSUB_WV + 1U, // VWSUB_WX + 1U, // VXOR_VI + 1U, // VXOR_VV + 1U, // VXOR_VX + 0U, // VZEXT_VF2 + 0U, // VZEXT_VF4 + 0U, // VZEXT_VF8 0U, // WFI - 4U, // XOR - 4U, // XORI + 0U, // WRS_NTO + 0U, // WRS_STO + 0U, // XNOR + 0U, // XOR + 0U, // XORI + 0U, // XPERM4 + 0U, // XPERM8 + 0U, // ZEXT_H_RV32 + 0U, // ZEXT_H_RV64 + 0U, // ZIP_RV32 }; // Emit the opcode for the instruction. - uint32_t Bits = 0; - Bits |= OpInfo0[MCInst_getOpcode(MI)] << 0; - Bits |= OpInfo1[MCInst_getOpcode(MI)] << 16; - CS_ASSERT(Bits != 0 && "Cannot print this instruction."); + uint64_t Bits = 0; + Bits |= (uint64_t)OpInfo0[MCInst_getOpcode(MI)] << 0; + Bits |= (uint64_t)OpInfo1[MCInst_getOpcode(MI)] << 32; + MnemonicBitsInfo MBI = { #ifndef CAPSTONE_DIET - SStream_concat0(O, AsmStrs+(Bits & 4095)-1); -#endif + AsmStrs+(Bits & 32767)-1, +#else + NULL, +#endif // CAPSTONE_DIET + Bits + }; + return MBI; +} + +/// printInstruction - This method is automatically generated by tablegen +/// from the instruction set description. +static void printInstruction(MCInst *MI, uint64_t Address, SStream *O) { + SStream_concat0(O, ""); + MnemonicBitsInfo MnemonicInfo = getMnemonic(MI, O); + SStream_concat0(O, MnemonicInfo.first); - // Fragment 0 encoded into 2 bits for 4 unique commands. - switch ((uint32_t)((Bits >> 12) & 3)) { - default: - CS_ASSERT(0 && "Invalid command number."); - return; + uint64_t Bits = MnemonicInfo.second; + CS_ASSERT_RET(Bits != 0 && "Cannot print this instruction."); + + // Fragment 0 encoded into 3 bits for 7 unique commands. + switch ((Bits >> 15) & 7) { + default: CS_ASSERT_RET(0 && "Invalid command number."); case 0: - // DBG_VALUE, DBG_LABEL, BUNDLE, LIFETIME_START, LIFETIME_END, FENTRY_CAL... + // DBG_VALUE, DBG_VALUE_LIST, DBG_INSTR_REF, DBG_PHI, DBG_LABEL, BUNDLE, ... return; break; case 1: - // PseudoCALL, PseudoLA, PseudoLI, PseudoLLA, PseudoTAIL, ADD, ADDI, ADDI... + // PseudoAddTPRel, PseudoCALL, PseudoCALLReg, PseudoLA, PseudoLAImm, Pseu... printOperand(MI, 0, O); break; case 2: - // C_ADD, C_ADDI, C_ADDI16SP, C_ADDIW, C_ADDW, C_AND, C_ANDI, C_OR, C_SLL... + // PseudoFLD, PseudoFLH, PseudoFLW, PseudoFSD, PseudoFSH, PseudoFSW, Pseu... printOperand(MI, 1, O); + break; + case 3: + // CBO_CLEAN, CBO_FLUSH, CBO_INVAL, CBO_ZERO + printZeroOffsetMemOp(MI, 0, O); + return; + break; + case 4: + // CM_POP, CM_POPRET, CM_POPRETZ, CM_PUSH + printRlist(MI, 0, O); SStream_concat0(O, ", "); - printOperand(MI, 2, O); + printSpimm(MI, 1, O); return; break; - case 3: + case 5: + // C_J, C_JAL + printBranchOperand(MI, Address, 0, O); + return; + break; + case 6: // FENCE printFenceArg(MI, 0, O); SStream_concat0(O, ", "); @@ -1226,113 +27921,310 @@ static void printInstruction(MCInst *MI, SStream *O, MCRegisterInfo *MRI) } - // Fragment 1 encoded into 2 bits for 3 unique commands. - switch ((uint32_t)((Bits >> 14) & 3)) { - default: - CS_ASSERT(0 && "Invalid command number."); - return; + // Fragment 1 encoded into 3 bits for 5 unique commands. + switch ((Bits >> 18) & 7) { + default: CS_ASSERT_RET(0 && "Invalid command number."); case 0: - // PseudoCALL, PseudoTAIL, C_J, C_JAL, C_JALR, C_JR - return; + // PseudoAddTPRel, PseudoCALLReg, PseudoFLD, PseudoFLH, PseudoFLW, Pseudo... + SStream_concat0(O, ", "); break; case 1: - // PseudoLA, PseudoLI, PseudoLLA, ADD, ADDI, ADDIW, ADDW, AMOADD_D, AMOAD... - SStream_concat0(O, ", "); + // PseudoCALL, PseudoTAIL, CM_JALT, CM_JT, C_JALR, C_JR, C_NOP_HINT, C_NO... + return; break; case 2: - // LR_D, LR_D_AQ, LR_D_AQ_RL, LR_D_RL, LR_W, LR_W_AQ, LR_W_AQ_RL, LR_W_RL + // CV_LBU_ri_inc, CV_LBU_rr_inc, CV_LB_ri_inc, CV_LB_rr_inc, CV_LHU_ri_in... SStream_concat0(O, ", ("); - printOperand(MI, 1, O); - SStream_concat0(O, ")"); + printOperand(MI, 2, O); + SStream_concat0(O, "), "); + printOperand(MI, 3, O); + break; + case 3: + // PREFETCH_I, PREFETCH_R, PREFETCH_W + SStream_concat1(O, '('); + printOperand(MI, 0, O); + SStream_concat1(O, ')'); + return; + break; + case 4: + // VID_V + printVMaskReg(MI, 1, O); return; break; } - // Fragment 2 encoded into 2 bits for 3 unique commands. - switch ((uint32_t)((Bits >> 16) & 3)) { - default: - CS_ASSERT(0 && "Invalid command number."); - return; + // Fragment 2 encoded into 4 bits for 11 unique commands. + switch ((Bits >> 21) & 15) { + default: CS_ASSERT_RET(0 && "Invalid command number."); case 0: - // PseudoLA, PseudoLI, PseudoLLA, ADD, ADDI, ADDIW, ADDW, AND, ANDI, AUIP... + // PseudoAddTPRel, PseudoCALLReg, PseudoLA, PseudoLAImm, PseudoLA_TLSDESC... printOperand(MI, 1, O); break; case 1: - // AMOADD_D, AMOADD_D_AQ, AMOADD_D_AQ_RL, AMOADD_D_RL, AMOADD_W, AMOADD_W... + // PseudoFLD, PseudoFLH, PseudoFLW, PseudoFSD, PseudoFSH, PseudoFSW, Pseu... printOperand(MI, 2, O); break; case 2: + // PseudoJump, InsnJ, InsnU, VC_V_FV, VC_V_IV, VC_V_VV, VC_V_XV + printOperand(MI, 0, O); + break; + case 3: + // AMOCAS_D_RV32, AMOCAS_D_RV32_AQ, AMOCAS_D_RV32_AQ_RL, AMOCAS_D_RV32_RL... + printOperand(MI, 3, O); + SStream_concat0(O, ", "); + printZeroOffsetMemOp(MI, 2, O); + return; + break; + case 4: // CSRRC, CSRRCI, CSRRS, CSRRSI, CSRRW, CSRRWI printCSRSystemRegister(MI, 1, O); SStream_concat0(O, ", "); printOperand(MI, 2, O); return; break; + case 5: + // CV_LBU_ri_inc, CV_LBU_rr_inc, CV_LB_ri_inc, CV_LB_rr_inc, CV_LHU_ri_in... + return; + break; + case 6: + // CV_LBU_rr, CV_LB_rr, CV_LHU_rr, CV_LH_rr, CV_LW_rr, CV_SB_rr, CV_SH_rr... + printRegReg(MI, 1, O); + return; + break; + case 7: + // C_BEQZ, C_BNEZ, JAL + printBranchOperand(MI, Address, 1, O); + return; + break; + case 8: + // FLI_D, FLI_H, FLI_S + printFPImmOperand(MI, 1, O); + return; + break; + case 9: + // HLVX_HU, HLVX_WU, HLV_B, HLV_BU, HLV_D, HLV_H, HLV_HU, HLV_W, HLV_WU, ... + printZeroOffsetMemOp(MI, 1, O); + break; + case 10: + // TH_LBIA, TH_LBIB, TH_LBUIA, TH_LBUIB, TH_LDIA, TH_LDIB, TH_LHIA, TH_LH... + SStream_concat0(O, ", "); + printOperand(MI, 4, O); + return; + break; } - // Fragment 3 encoded into 2 bits for 4 unique commands. - switch ((uint32_t)((Bits >> 18) & 3)) { - default: - CS_ASSERT(0 && "Invalid command number."); - return; + // Fragment 3 encoded into 3 bits for 7 unique commands. + switch ((Bits >> 25) & 7) { + default: CS_ASSERT_RET(0 && "Invalid command number."); case 0: - // PseudoLA, PseudoLI, PseudoLLA, AUIPC, C_BEQZ, C_BNEZ, C_LI, C_LUI, C_M... - return; + // PseudoAddTPRel, PseudoFLD, PseudoFLH, PseudoFLW, PseudoFSD, PseudoFSH,... + SStream_concat0(O, ", "); break; case 1: - // ADD, ADDI, ADDIW, ADDW, AND, ANDI, BEQ, BGE, BGEU, BLT, BLTU, BNE, C_A... - SStream_concat0(O, ", "); + // PseudoCALLReg, PseudoJump, PseudoLA, PseudoLAImm, PseudoLA_TLSDESC, Ps... + return; break; case 2: - // AMOADD_D, AMOADD_D_AQ, AMOADD_D_AQ_RL, AMOADD_D_RL, AMOADD_W, AMOADD_W... - SStream_concat0(O, ", ("); + // PseudoTLSDESCCall, CV_ELW, C_FLD, C_FLDSP, C_FLW, C_FLWSP, C_FSD, C_FS... + SStream_concat1(O, '('); printOperand(MI, 1, O); - SStream_concat0(O, ")"); - return; break; case 3: - // C_FLD, C_FLDSP, C_FLW, C_FLWSP, C_FSD, C_FSDSP, C_FSW, C_FSWSP, C_LD, ... - SStream_concat0(O, "("); - printOperand(MI, 1, O); - SStream_concat0(O, ")"); + // FCVTMOD_W_D, FCVT_BF16_S, FCVT_D_L, FCVT_D_LU, FCVT_D_LU_INX, FCVT_D_L... + printFRMArg(MI, 2, O); + return; + break; + case 4: + // FCVT_D_H, FCVT_D_H_IN32X, FCVT_D_H_INX, FCVT_D_S, FCVT_D_S_IN32X, FCVT... + printFRMArgLegacy(MI, 2, O); + return; + break; + case 5: + // TH_LDD, TH_LWD, TH_LWUD, TH_SDD, TH_SWD + SStream_concat0(O, ", ("); + printOperand(MI, 2, O); + SStream_concat0(O, "), "); + printOperand(MI, 3, O); + SStream_concat0(O, ", "); + printOperand(MI, 4, O); + return; + break; + case 6: + // VBREV8_V, VBREV_V, VCLZ_V, VCPOP_M, VCPOP_V, VCTZ_V, VFCLASS_V, VFCVT_... + printVMaskReg(MI, 2, O); return; break; } - // Fragment 4 encoded into 1 bits for 2 unique commands. - if ((Bits >> 20) & 1) { - // FCVT_D_L, FCVT_D_LU, FCVT_LU_D, FCVT_LU_S, FCVT_L_D, FCVT_L_S, FCVT_S_... - printFRMArg(MI, 2, O); - return; - } else { - // ADD, ADDI, ADDIW, ADDW, AND, ANDI, BEQ, BGE, BGEU, BLT, BLTU, BNE, C_A... + // Fragment 4 encoded into 3 bits for 8 unique commands. + switch ((Bits >> 28) & 7) { + default: CS_ASSERT_RET(0 && "Invalid command number."); + case 0: + // PseudoAddTPRel, PseudoVMSGEU_VI, PseudoVMSGEU_VX, PseudoVMSGEU_VX_M, P... printOperand(MI, 2, O); + break; + case 1: + // PseudoFLD, PseudoFLH, PseudoFLW, PseudoFSD, PseudoFSH, PseudoFSW, Pseu... + printOperand(MI, 0, O); + break; + case 2: + // PseudoTLSDESCCall + SStream_concat0(O, "), "); + printOperand(MI, 3, O); + return; + break; + case 3: + // PseudoVMSGEU_VX_M_T, PseudoVMSGE_VX_M_T, CV_ADDNR, CV_ADDRNR, CV_ADDUN... + printOperand(MI, 3, O); + break; + case 4: + // AMOADD_D, AMOADD_D_AQ, AMOADD_D_AQ_RL, AMOADD_D_RL, AMOADD_W, AMOADD_W... + printZeroOffsetMemOp(MI, 1, O); + return; + break; + case 5: + // BEQ, BGE, BGEU, BLT, BLTU, BNE, CV_BEQIMM, CV_BNEIMM, InsnCJ, InsnJ + printBranchOperand(MI, Address, 2, O); + return; + break; + case 6: + // CV_ELW, C_FLD, C_FLDSP, C_FLW, C_FLWSP, C_FSD, C_FSDSP, C_FSW, C_FSWSP... + SStream_concat1(O, ')'); + return; + break; + case 7: + // VSETIVLI, VSETVLI + printVTypeI(MI, 2, O); + return; + break; } - // Fragment 5 encoded into 1 bits for 2 unique commands. - if ((Bits >> 21) & 1) { - // FADD_D, FADD_S, FDIV_D, FDIV_S, FMADD_D, FMADD_S, FMSUB_D, FMSUB_S, FM... + // Fragment 5 encoded into 3 bits for 6 unique commands. + switch ((Bits >> 31) & 7) { + default: CS_ASSERT_RET(0 && "Invalid command number."); + case 0: + // PseudoAddTPRel, AES32DSI, AES32DSMI, AES32ESI, AES32ESMI, CV_ADDN, CV_... SStream_concat0(O, ", "); - } else { - // ADD, ADDI, ADDIW, ADDW, AND, ANDI, BEQ, BGE, BGEU, BLT, BLTU, BNE, C_A... + break; + case 1: + // PseudoFLD, PseudoFLH, PseudoFLW, PseudoFSD, PseudoFSH, PseudoFSW, Pseu... + return; + break; + case 2: + // PseudoVMSGEU_VI, PseudoVMSGEU_VX_M, PseudoVMSGE_VI, PseudoVMSGE_VX_M, ... + printVMaskReg(MI, 3, O); return; + break; + case 3: + // PseudoVMSGEU_VX_M_T, PseudoVMSGE_VX_M_T, THVdotVMAQASU_VV, THVdotVMAQA... + printVMaskReg(MI, 4, O); + break; + case 4: + // FADD_D, FADD_D_IN32X, FADD_D_INX, FADD_H, FADD_H_INX, FADD_S, FADD_S_I... + printFRMArg(MI, 3, O); + return; + break; + case 5: + // VADC_VIM, VADC_VVM, VADC_VXM, VFMERGE_VFM, VMADC_VIM, VMADC_VVM, VMADC... + SStream_concat0(O, ", v0"); + return; + break; } - // Fragment 6 encoded into 1 bits for 2 unique commands. - if ((Bits >> 22) & 1) { - // FMADD_D, FMADD_S, FMSUB_D, FMSUB_S, FNMADD_D, FNMADD_S, FNMSUB_D, FNMS... + // Fragment 6 encoded into 3 bits for 6 unique commands. + switch ((Bits >> 34) & 7) { + default: CS_ASSERT_RET(0 && "Invalid command number."); + case 0: + // PseudoAddTPRel, AES32DSI, AES32DSMI, AES32ESI, AES32ESMI, CV_ADDN, CV_... printOperand(MI, 3, O); + break; + case 1: + // PseudoVMSGEU_VX_M_T, PseudoVMSGE_VX_M_T + SStream_concat0(O, ", "); + printOperand(MI, 1, O); + return; + break; + case 2: + // CV_INSERT, CV_MACHHSN, CV_MACHHSRN, CV_MACHHUN, CV_MACHHURN, CV_MACSN,... + printOperand(MI, 4, O); + break; + case 3: + // InsnCA, InsnR, InsnR4 + printOperand(MI, 0, O); SStream_concat0(O, ", "); + printOperand(MI, 4, O); + break; + case 4: + // InsnCB + printBranchOperand(MI, Address, 3, O); + return; + break; + case 5: + // THVdotVMAQASU_VV, THVdotVMAQASU_VX, THVdotVMAQAUS_VX, THVdotVMAQAU_VV,... + return; + break; + } + + + // Fragment 7 encoded into 2 bits for 4 unique commands. + switch ((Bits >> 37) & 3) { + default: CS_ASSERT_RET(0 && "Invalid command number."); + case 0: + // PseudoAddTPRel, AES32DSI, AES32DSMI, AES32ESI, AES32ESMI, CV_ADDN, CV_... + return; + break; + case 1: + // FMADD_D, FMADD_D_IN32X, FMADD_D_INX, FMADD_H, FMADD_H_INX, FMADD_S, FM... printFRMArg(MI, 4, O); return; + break; + case 2: + // InsnB, InsnI, InsnR, InsnR4 + SStream_concat0(O, ", "); + break; + case 3: + // InsnCL, InsnCS, InsnI_Mem, InsnS + SStream_concat1(O, '('); + printOperand(MI, 3, O); + SStream_concat1(O, ')'); + return; + break; + } + + + // Fragment 8 encoded into 2 bits for 3 unique commands. + switch ((Bits >> 39) & 3) { + default: CS_ASSERT_RET(0 && "Invalid command number."); + case 0: + // InsnB + printBranchOperand(MI, Address, 4, O); + return; + break; + case 1: + // InsnI + printOperand(MI, 4, O); + return; + break; + case 2: + // InsnR, InsnR4 + printOperand(MI, 5, O); + break; + } + + + // Fragment 9 encoded into 1 bits for 2 unique commands. + if ((Bits >> 41) & 1) { + // InsnR4 + SStream_concat0(O, ", "); + printOperand(MI, 6, O); + return; } else { - // FADD_D, FADD_S, FDIV_D, FDIV_S, FMUL_D, FMUL_S, FSUB_D, FSUB_S - printFRMArg(MI, 3, O); + // InsnR return; } @@ -1343,1254 +28235,1257 @@ static void printInstruction(MCInst *MI, SStream *O, MCRegisterInfo *MRI) /// from the register set description. This returns the assembler name /// for the specified register. static const char * -getRegisterName(unsigned RegNo, unsigned AltIdx) -{ - CS_ASSERT(RegNo && RegNo < 97 && "Invalid register number!"); - +getRegisterName(unsigned RegNo, unsigned AltIdx) { #ifndef CAPSTONE_DIET - static const char AsmStrsABIRegAltName[] = { - /* 0 */ 'f', 's', '1', '0', 0, - /* 5 */ 'f', 't', '1', '0', 0, - /* 10 */ 'f', 'a', '0', 0, - /* 14 */ 'f', 's', '0', 0, - /* 18 */ 'f', 't', '0', 0, - /* 22 */ 'f', 's', '1', '1', 0, - /* 27 */ 'f', 't', '1', '1', 0, - /* 32 */ 'f', 'a', '1', 0, - /* 36 */ 'f', 's', '1', 0, - /* 40 */ 'f', 't', '1', 0, - /* 44 */ 'f', 'a', '2', 0, - /* 48 */ 'f', 's', '2', 0, - /* 52 */ 'f', 't', '2', 0, - /* 56 */ 'f', 'a', '3', 0, - /* 60 */ 'f', 's', '3', 0, - /* 64 */ 'f', 't', '3', 0, - /* 68 */ 'f', 'a', '4', 0, - /* 72 */ 'f', 's', '4', 0, - /* 76 */ 'f', 't', '4', 0, - /* 80 */ 'f', 'a', '5', 0, - /* 84 */ 'f', 's', '5', 0, - /* 88 */ 'f', 't', '5', 0, - /* 92 */ 'f', 'a', '6', 0, - /* 96 */ 'f', 's', '6', 0, - /* 100 */ 'f', 't', '6', 0, - /* 104 */ 'f', 'a', '7', 0, - /* 108 */ 'f', 's', '7', 0, - /* 112 */ 'f', 't', '7', 0, - /* 116 */ 'f', 's', '8', 0, - /* 120 */ 'f', 't', '8', 0, - /* 124 */ 'f', 's', '9', 0, - /* 128 */ 'f', 't', '9', 0, - /* 132 */ 'r', 'a', 0, - /* 135 */ 'z', 'e', 'r', 'o', 0, - /* 140 */ 'g', 'p', 0, - /* 143 */ 's', 'p', 0, - /* 146 */ 't', 'p', 0, - }; + CS_ASSERT_RET_VAL(RegNo && RegNo < 459 && "Invalid register number!", NULL); + static const char AsmStrsABIRegAltName[] = { + /* 0 */ "fs10\0" + /* 5 */ "ft10\0" + /* 10 */ "fa0\0" + /* 14 */ "fs0\0" + /* 18 */ "ft0\0" + /* 22 */ "fs11\0" + /* 27 */ "ft11\0" + /* 32 */ "fa1\0" + /* 36 */ "fs1\0" + /* 40 */ "ft1\0" + /* 44 */ "fa2\0" + /* 48 */ "fs2\0" + /* 52 */ "ft2\0" + /* 56 */ "fa3\0" + /* 60 */ "fs3\0" + /* 64 */ "ft3\0" + /* 68 */ "fa4\0" + /* 72 */ "fs4\0" + /* 76 */ "ft4\0" + /* 80 */ "fa5\0" + /* 84 */ "fs5\0" + /* 88 */ "ft5\0" + /* 92 */ "fa6\0" + /* 96 */ "fs6\0" + /* 100 */ "ft6\0" + /* 104 */ "fa7\0" + /* 108 */ "fs7\0" + /* 112 */ "ft7\0" + /* 116 */ "fs8\0" + /* 120 */ "ft8\0" + /* 124 */ "fs9\0" + /* 128 */ "ft9\0" + /* 132 */ "ra\0" + /* 135 */ "zero\0" + /* 140 */ "gp\0" + /* 143 */ "sp\0" + /* 146 */ "tp\0" +}; static const uint8_t RegAsmOffsetABIRegAltName[] = { - 135, 132, 143, 140, 146, 19, 41, 53, 15, 37, 11, 33, 45, 57, - 69, 81, 93, 105, 49, 61, 73, 85, 97, 109, 117, 125, 1, 23, - 65, 77, 89, 101, 18, 18, 40, 40, 52, 52, 64, 64, 76, 76, - 88, 88, 100, 100, 112, 112, 14, 14, 36, 36, 10, 10, 32, 32, - 44, 44, 56, 56, 68, 68, 80, 80, 92, 92, 104, 104, 48, 48, - 60, 60, 72, 72, 84, 84, 96, 96, 108, 108, 116, 116, 124, 124, - 0, 0, 22, 22, 120, 120, 128, 128, 5, 5, 27, 27, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 135, + 132, 143, 140, 146, 19, 41, 53, 15, 37, 11, 33, 45, 57, 69, + 81, 93, 105, 49, 61, 73, 85, 97, 109, 117, 125, 1, 23, 65, + 77, 89, 101, 18, 40, 52, 64, 76, 88, 100, 112, 14, 36, 10, + 32, 44, 56, 68, 80, 92, 104, 48, 60, 72, 84, 96, 108, 116, + 124, 0, 22, 120, 128, 5, 27, 18, 40, 52, 64, 76, 88, 100, + 112, 14, 36, 10, 32, 44, 56, 68, 80, 92, 104, 48, 60, 72, + 84, 96, 108, 116, 124, 0, 22, 120, 128, 5, 27, 18, 40, 52, + 64, 76, 88, 100, 112, 14, 36, 10, 32, 44, 56, 68, 80, 92, + 104, 48, 60, 72, 84, 96, 108, 116, 124, 0, 22, 120, 128, 5, + 27, 135, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 143, 146, 41, 15, 11, 45, 69, 93, 49, 73, 97, 117, + 1, 65, 89, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, }; static const char AsmStrsNoRegAltName[] = { - /* 0 */ 'f', '1', '0', 0, - /* 4 */ 'x', '1', '0', 0, - /* 8 */ 'f', '2', '0', 0, - /* 12 */ 'x', '2', '0', 0, - /* 16 */ 'f', '3', '0', 0, - /* 20 */ 'x', '3', '0', 0, - /* 24 */ 'f', '0', 0, - /* 27 */ 'x', '0', 0, - /* 30 */ 'f', '1', '1', 0, - /* 34 */ 'x', '1', '1', 0, - /* 38 */ 'f', '2', '1', 0, - /* 42 */ 'x', '2', '1', 0, - /* 46 */ 'f', '3', '1', 0, - /* 50 */ 'x', '3', '1', 0, - /* 54 */ 'f', '1', 0, - /* 57 */ 'x', '1', 0, - /* 60 */ 'f', '1', '2', 0, - /* 64 */ 'x', '1', '2', 0, - /* 68 */ 'f', '2', '2', 0, - /* 72 */ 'x', '2', '2', 0, - /* 76 */ 'f', '2', 0, - /* 79 */ 'x', '2', 0, - /* 82 */ 'f', '1', '3', 0, - /* 86 */ 'x', '1', '3', 0, - /* 90 */ 'f', '2', '3', 0, - /* 94 */ 'x', '2', '3', 0, - /* 98 */ 'f', '3', 0, - /* 101 */ 'x', '3', 0, - /* 104 */ 'f', '1', '4', 0, - /* 108 */ 'x', '1', '4', 0, - /* 112 */ 'f', '2', '4', 0, - /* 116 */ 'x', '2', '4', 0, - /* 120 */ 'f', '4', 0, - /* 123 */ 'x', '4', 0, - /* 126 */ 'f', '1', '5', 0, - /* 130 */ 'x', '1', '5', 0, - /* 134 */ 'f', '2', '5', 0, - /* 138 */ 'x', '2', '5', 0, - /* 142 */ 'f', '5', 0, - /* 145 */ 'x', '5', 0, - /* 148 */ 'f', '1', '6', 0, - /* 152 */ 'x', '1', '6', 0, - /* 156 */ 'f', '2', '6', 0, - /* 160 */ 'x', '2', '6', 0, - /* 164 */ 'f', '6', 0, - /* 167 */ 'x', '6', 0, - /* 170 */ 'f', '1', '7', 0, - /* 174 */ 'x', '1', '7', 0, - /* 178 */ 'f', '2', '7', 0, - /* 182 */ 'x', '2', '7', 0, - /* 186 */ 'f', '7', 0, - /* 189 */ 'x', '7', 0, - /* 192 */ 'f', '1', '8', 0, - /* 196 */ 'x', '1', '8', 0, - /* 200 */ 'f', '2', '8', 0, - /* 204 */ 'x', '2', '8', 0, - /* 208 */ 'f', '8', 0, - /* 211 */ 'x', '8', 0, - /* 214 */ 'f', '1', '9', 0, - /* 218 */ 'x', '1', '9', 0, - /* 222 */ 'f', '2', '9', 0, - /* 226 */ 'x', '2', '9', 0, - /* 230 */ 'f', '9', 0, - /* 233 */ 'x', '9', 0, - }; - - static const uint8_t RegAsmOffsetNoRegAltName[] = { - 27, 57, 79, 101, 123, 145, 167, 189, 211, 233, 4, 34, 64, 86, - 108, 130, 152, 174, 196, 218, 12, 42, 72, 94, 116, 138, 160, 182, - 204, 226, 20, 50, 24, 24, 54, 54, 76, 76, 98, 98, 120, 120, - 142, 142, 164, 164, 186, 186, 208, 208, 230, 230, 0, 0, 30, 30, - 60, 60, 82, 82, 104, 104, 126, 126, 148, 148, 170, 170, 192, 192, - 214, 214, 8, 8, 38, 38, 68, 68, 90, 90, 112, 112, 134, 134, - 156, 156, 178, 178, 200, 200, 222, 222, 16, 16, 46, 46, + /* 0 */ "V3_V4_V5_V6_V7_V8_V9_V10\0" + /* 25 */ "f10\0" + /* 29 */ "v10\0" + /* 33 */ "x10\0" + /* 37 */ "V13_V14_V15_V16_V17_V18_V19_V20\0" + /* 69 */ "f20\0" + /* 73 */ "v20\0" + /* 77 */ "x20\0" + /* 81 */ "V23_V24_V25_V26_V27_V28_V29_V30\0" + /* 113 */ "f30\0" + /* 117 */ "v30\0" + /* 121 */ "x30\0" + /* 125 */ "f0\0" + /* 128 */ "v0\0" + /* 131 */ "x0\0" + /* 134 */ "V4_V5_V6_V7_V8_V9_V10_V11\0" + /* 160 */ "f11\0" + /* 164 */ "v11\0" + /* 168 */ "x11\0" + /* 172 */ "V14_V15_V16_V17_V18_V19_V20_V21\0" + /* 204 */ "f21\0" + /* 208 */ "v21\0" + /* 212 */ "x21\0" + /* 216 */ "V24_V25_V26_V27_V28_V29_V30_V31\0" + /* 248 */ "f31\0" + /* 252 */ "v31\0" + /* 256 */ "x31\0" + /* 260 */ "V0_V1\0" + /* 266 */ "f1\0" + /* 269 */ "v1\0" + /* 272 */ "x1\0" + /* 275 */ "V5_V6_V7_V8_V9_V10_V11_V12\0" + /* 302 */ "f12\0" + /* 306 */ "v12\0" + /* 310 */ "x12\0" + /* 314 */ "V15_V16_V17_V18_V19_V20_V21_V22\0" + /* 346 */ "f22\0" + /* 350 */ "v22\0" + /* 354 */ "x22\0" + /* 358 */ "V4M2_V6M2_V8M2_V10M2\0" + /* 379 */ "V14M2_V16M2_V18M2_V20M2\0" + /* 403 */ "V24M2_V26M2_V28M2_V30M2\0" + /* 427 */ "V6M2_V8M2_V10M2_V12M2\0" + /* 449 */ "V16M2_V18M2_V20M2_V22M2\0" + /* 473 */ "V0M2_V2M2\0" + /* 483 */ "V8M2_V10M2_V12M2_V14M2\0" + /* 506 */ "V18M2_V20M2_V22M2_V24M2\0" + /* 530 */ "V0M2_V2M2_V4M2\0" + /* 545 */ "V10M2_V12M2_V14M2_V16M2\0" + /* 569 */ "V20M2_V22M2_V24M2_V26M2\0" + /* 593 */ "V0M2_V2M2_V4M2_V6M2\0" + /* 613 */ "V12M2_V14M2_V16M2_V18M2\0" + /* 637 */ "V22M2_V24M2_V26M2_V28M2\0" + /* 661 */ "V2M2_V4M2_V6M2_V8M2\0" + /* 681 */ "V0_V1_V2\0" + /* 690 */ "f2\0" + /* 693 */ "v2\0" + /* 696 */ "x2\0" + /* 699 */ "V6_V7_V8_V9_V10_V11_V12_V13\0" + /* 727 */ "f13\0" + /* 731 */ "v13\0" + /* 735 */ "x13\0" + /* 739 */ "V16_V17_V18_V19_V20_V21_V22_V23\0" + /* 771 */ "f23\0" + /* 775 */ "v23\0" + /* 779 */ "x23\0" + /* 783 */ "V0_V1_V2_V3\0" + /* 795 */ "f3\0" + /* 798 */ "v3\0" + /* 801 */ "x3\0" + /* 804 */ "V7_V8_V9_V10_V11_V12_V13_V14\0" + /* 833 */ "f14\0" + /* 837 */ "v14\0" + /* 841 */ "x14\0" + /* 845 */ "V17_V18_V19_V20_V21_V22_V23_V24\0" + /* 877 */ "f24\0" + /* 881 */ "v24\0" + /* 885 */ "x24\0" + /* 889 */ "V16M4_V20M4\0" + /* 901 */ "V8M4_V12M4\0" + /* 912 */ "V20M4_V24M4\0" + /* 924 */ "V0M4_V4M4\0" + /* 934 */ "V12M4_V16M4\0" + /* 946 */ "V24M4_V28M4\0" + /* 958 */ "V4M4_V8M4\0" + /* 968 */ "V0_V1_V2_V3_V4\0" + /* 983 */ "f4\0" + /* 986 */ "v4\0" + /* 989 */ "x4\0" + /* 992 */ "V8_V9_V10_V11_V12_V13_V14_V15\0" + /* 1022 */ "f15\0" + /* 1026 */ "v15\0" + /* 1030 */ "x15\0" + /* 1034 */ "V18_V19_V20_V21_V22_V23_V24_V25\0" + /* 1066 */ "f25\0" + /* 1070 */ "v25\0" + /* 1074 */ "x25\0" + /* 1078 */ "V0_V1_V2_V3_V4_V5\0" + /* 1096 */ "f5\0" + /* 1099 */ "v5\0" + /* 1102 */ "x5\0" + /* 1105 */ "V9_V10_V11_V12_V13_V14_V15_V16\0" + /* 1136 */ "f16\0" + /* 1140 */ "v16\0" + /* 1144 */ "x16\0" + /* 1148 */ "V19_V20_V21_V22_V23_V24_V25_V26\0" + /* 1180 */ "f26\0" + /* 1184 */ "v26\0" + /* 1188 */ "x26\0" + /* 1192 */ "V0_V1_V2_V3_V4_V5_V6\0" + /* 1213 */ "f6\0" + /* 1216 */ "v6\0" + /* 1219 */ "x6\0" + /* 1222 */ "V10_V11_V12_V13_V14_V15_V16_V17\0" + /* 1254 */ "f17\0" + /* 1258 */ "v17\0" + /* 1262 */ "x17\0" + /* 1266 */ "V20_V21_V22_V23_V24_V25_V26_V27\0" + /* 1298 */ "f27\0" + /* 1302 */ "v27\0" + /* 1306 */ "x27\0" + /* 1310 */ "V0_V1_V2_V3_V4_V5_V6_V7\0" + /* 1334 */ "f7\0" + /* 1337 */ "v7\0" + /* 1340 */ "x7\0" + /* 1343 */ "V11_V12_V13_V14_V15_V16_V17_V18\0" + /* 1375 */ "f18\0" + /* 1379 */ "v18\0" + /* 1383 */ "x18\0" + /* 1387 */ "V21_V22_V23_V24_V25_V26_V27_V28\0" + /* 1419 */ "f28\0" + /* 1423 */ "v28\0" + /* 1427 */ "x28\0" + /* 1431 */ "V1_V2_V3_V4_V5_V6_V7_V8\0" + /* 1455 */ "f8\0" + /* 1458 */ "v8\0" + /* 1461 */ "x8\0" + /* 1464 */ "V12_V13_V14_V15_V16_V17_V18_V19\0" + /* 1496 */ "f19\0" + /* 1500 */ "v19\0" + /* 1504 */ "x19\0" + /* 1508 */ "V22_V23_V24_V25_V26_V27_V28_V29\0" + /* 1540 */ "f29\0" + /* 1544 */ "v29\0" + /* 1548 */ "x29\0" + /* 1552 */ "V2_V3_V4_V5_V6_V7_V8_V9\0" + /* 1576 */ "f9\0" + /* 1579 */ "v9\0" + /* 1582 */ "x9\0" + /* 1585 */ "vlenb\0" + /* 1591 */ "vtype\0" + /* 1597 */ "vl\0" + /* 1600 */ "frm\0" + /* 1604 */ "vxrm\0" + /* 1609 */ "ssp\0" + /* 1613 */ "fflags\0" + /* 1620 */ "vxsat\0" +}; + static const uint16_t RegAsmOffsetNoRegAltName[] = { + 1613, 1600, 1609, 1597, 1585, 1591, 1604, 1620, 23, 128, 269, 693, 798, 986, + 1099, 1216, 1337, 1458, 1579, 29, 164, 306, 731, 837, 1026, 1140, 1258, 1379, + 1500, 73, 208, 350, 775, 881, 1070, 1184, 1302, 1423, 1544, 117, 252, 131, + 272, 696, 801, 989, 1102, 1219, 1340, 1461, 1582, 33, 168, 310, 735, 841, + 1030, 1144, 1262, 1383, 1504, 77, 212, 354, 779, 885, 1074, 1188, 1306, 1427, + 1548, 121, 256, 125, 266, 690, 795, 983, 1096, 1213, 1334, 1455, 1576, 25, + 160, 302, 727, 833, 1022, 1136, 1254, 1375, 1496, 69, 204, 346, 771, 877, + 1066, 1180, 1298, 1419, 1540, 113, 248, 125, 266, 690, 795, 983, 1096, 1213, + 1334, 1455, 1576, 25, 160, 302, 727, 833, 1022, 1136, 1254, 1375, 1496, 69, + 204, 346, 771, 877, 1066, 1180, 1298, 1419, 1540, 113, 248, 125, 266, 690, + 795, 983, 1096, 1213, 1334, 1455, 1576, 25, 160, 302, 727, 833, 1022, 1136, + 1254, 1375, 1496, 69, 204, 346, 771, 877, 1066, 1180, 1298, 1419, 1540, 113, + 248, 131, 128, 128, 128, 693, 986, 986, 1216, 1458, 1458, 1458, 29, 306, + 306, 837, 1140, 1140, 1140, 1379, 73, 73, 350, 881, 881, 881, 1184, 1423, + 1423, 117, 696, 989, 1219, 1461, 33, 310, 841, 1144, 1383, 77, 354, 885, + 1188, 1427, 121, 684, 789, 977, 1090, 1207, 1328, 1449, 1570, 18, 152, 294, + 719, 825, 1014, 1128, 1246, 1367, 1488, 61, 196, 338, 763, 869, 1058, 1172, + 1290, 1411, 1532, 105, 240, 260, 535, 603, 671, 368, 437, 494, 557, 625, + 391, 461, 518, 581, 649, 415, 473, 958, 901, 934, 889, 912, 946, 924, + 786, 974, 1087, 1204, 1325, 1446, 1567, 15, 149, 290, 715, 821, 1010, 1124, + 1242, 1363, 1484, 57, 192, 334, 759, 865, 1054, 1168, 1286, 1407, 1528, 101, + 236, 681, 598, 666, 363, 432, 488, 551, 619, 385, 455, 512, 575, 643, + 409, 530, 971, 1084, 1201, 1322, 1443, 1564, 12, 146, 287, 711, 817, 1006, + 1120, 1238, 1359, 1480, 53, 188, 330, 755, 861, 1050, 1164, 1282, 1403, 1524, + 97, 232, 783, 661, 358, 427, 483, 545, 613, 379, 449, 506, 569, 637, + 403, 593, 1081, 1198, 1319, 1440, 1561, 9, 143, 284, 708, 813, 1002, 1116, + 1234, 1355, 1476, 49, 184, 326, 751, 857, 1046, 1160, 1278, 1399, 1520, 93, + 228, 968, 1195, 1316, 1437, 1558, 6, 140, 281, 705, 810, 998, 1112, 1230, + 1351, 1472, 45, 180, 322, 747, 853, 1042, 1156, 1274, 1395, 1516, 89, 224, + 1078, 1313, 1434, 1555, 3, 137, 278, 702, 807, 995, 1108, 1226, 1347, 1468, + 41, 176, 318, 743, 849, 1038, 1152, 1270, 1391, 1512, 85, 220, 1192, 1431, + 1552, 0, 134, 275, 699, 804, 992, 1105, 1222, 1343, 1464, 37, 172, 314, + 739, 845, 1034, 1148, 1266, 1387, 1508, 81, 216, 1310, }; switch(AltIdx) { - default: - CS_ASSERT(0 && "Invalid register alt name index!"); - return 0; + default: CS_ASSERT_RET_VAL(0 && "Invalid register alt name index!", NULL); case RISCV_ABIRegAltName: - CS_ASSERT(*(AsmStrsABIRegAltName+RegAsmOffsetABIRegAltName[RegNo-1]) && - "Invalid alt name index for register!"); + if (!*(AsmStrsABIRegAltName+RegAsmOffsetABIRegAltName[RegNo-1])) + return getRegisterName(RegNo, RISCV_NoRegAltName); return AsmStrsABIRegAltName+RegAsmOffsetABIRegAltName[RegNo-1]; case RISCV_NoRegAltName: - CS_ASSERT(*(AsmStrsNoRegAltName+RegAsmOffsetNoRegAltName[RegNo-1]) && - "Invalid alt name index for register!"); + CS_ASSERT_RET_VAL(*(AsmStrsNoRegAltName+RegAsmOffsetNoRegAltName[RegNo-1]) && + "Invalid alt name index for register!", NULL); return AsmStrsNoRegAltName+RegAsmOffsetNoRegAltName[RegNo-1]; } #else return NULL; -#endif +#endif // CAPSTONE_DIET } - #ifdef PRINT_ALIAS_INSTR #undef PRINT_ALIAS_INSTR -static bool RISCVInstPrinterValidateMCOperand(MCOperand *MCOp, +static bool RISCVInstPrinterValidateMCOperand(const MCOperand *MCOp, unsigned PredicateIndex); +static bool printAliasInstr(MCInst *MI, uint64_t Address, SStream *OS) { +#ifndef CAPSTONE_DIET + static const PatternsForOpcode OpToPatterns[] = { + {RISCV_ADD, 0, 4 }, + {RISCV_ADDI, 4, 3 }, + {RISCV_ADDIW, 7, 1 }, + {RISCV_ADD_UW, 8, 1 }, + {RISCV_AUIPC, 9, 1 }, + {RISCV_BEQ, 10, 1 }, + {RISCV_BGE, 11, 2 }, + {RISCV_BLT, 13, 2 }, + {RISCV_BNE, 15, 1 }, + {RISCV_CSRRC, 16, 1 }, + {RISCV_CSRRCI, 17, 1 }, + {RISCV_CSRRS, 18, 11 }, + {RISCV_CSRRSI, 29, 1 }, + {RISCV_CSRRW, 30, 7 }, + {RISCV_CSRRWI, 37, 5 }, + {RISCV_CV_MULHHSN, 42, 1 }, + {RISCV_CV_MULHHUN, 43, 1 }, + {RISCV_CV_MULSN, 44, 1 }, + {RISCV_CV_MULUN, 45, 1 }, + {RISCV_C_ADD_HINT, 46, 4 }, + {RISCV_FENCE, 50, 2 }, + {RISCV_FSGNJN_D, 52, 1 }, + {RISCV_FSGNJN_D_IN32X, 53, 1 }, + {RISCV_FSGNJN_D_INX, 54, 1 }, + {RISCV_FSGNJN_H, 55, 1 }, + {RISCV_FSGNJN_H_INX, 56, 1 }, + {RISCV_FSGNJN_S, 57, 1 }, + {RISCV_FSGNJN_S_INX, 58, 1 }, + {RISCV_FSGNJX_D, 59, 1 }, + {RISCV_FSGNJX_D_IN32X, 60, 1 }, + {RISCV_FSGNJX_D_INX, 61, 1 }, + {RISCV_FSGNJX_H, 62, 1 }, + {RISCV_FSGNJX_H_INX, 63, 1 }, + {RISCV_FSGNJX_S, 64, 1 }, + {RISCV_FSGNJX_S_INX, 65, 1 }, + {RISCV_FSGNJ_D, 66, 1 }, + {RISCV_FSGNJ_H, 67, 1 }, + {RISCV_FSGNJ_H_INX, 68, 1 }, + {RISCV_FSGNJ_S, 69, 1 }, + {RISCV_HFENCE_GVMA, 70, 2 }, + {RISCV_HFENCE_VVMA, 72, 2 }, + {RISCV_JAL, 74, 2 }, + {RISCV_JALR, 76, 6 }, + {RISCV_SFENCE_VMA, 82, 2 }, + {RISCV_SLT, 84, 2 }, + {RISCV_SLTIU, 86, 1 }, + {RISCV_SLTU, 87, 1 }, + {RISCV_SUB, 88, 1 }, + {RISCV_SUBW, 89, 1 }, + {RISCV_VFSGNJN_VV, 90, 2 }, + {RISCV_VFSGNJX_VV, 92, 2 }, + {RISCV_VL1RE8_V, 94, 1 }, + {RISCV_VL2RE8_V, 95, 1 }, + {RISCV_VL4RE8_V, 96, 1 }, + {RISCV_VL8RE8_V, 97, 1 }, + {RISCV_VMAND_MM, 98, 1 }, + {RISCV_VMNAND_MM, 99, 1 }, + {RISCV_VMXNOR_MM, 100, 1 }, + {RISCV_VMXOR_MM, 101, 1 }, + {RISCV_VNSRL_WX, 102, 2 }, + {RISCV_VRSUB_VX, 104, 2 }, + {RISCV_VWADDU_VX, 106, 2 }, + {RISCV_VWADD_VX, 108, 2 }, + {RISCV_VXOR_VI, 110, 2 }, + {RISCV_XORI, 112, 1 }, + {0}, }; -static bool printAliasInstr(MCInst *MI, SStream * OS, void *info) -{ - MCRegisterInfo *MRI = (MCRegisterInfo *) info; - const char *AsmString; - unsigned I = 0; -#define ASMSTRING_CONTAIN_SIZE 64 - unsigned AsmStringLen = 0; - char tmpString_[ASMSTRING_CONTAIN_SIZE]; - char *tmpString = tmpString_; - switch (MCInst_getOpcode(MI)) { - default: return false; - case RISCV_ADDI: - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_getReg(MCInst_getOperand(MI, 0)) == RISCV_X0 && - MCOperand_getReg(MCInst_getOperand(MI, 1)) == RISCV_X0 && - MCOperand_isImm(MCInst_getOperand(MI, 2)) && - MCOperand_getImm(MCInst_getOperand(MI, 2)) == 0) { - // (ADDI X0, X0, 0) - AsmString = "nop"; - break; - } - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_isReg(MCInst_getOperand(MI, 1)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 1))) && - MCOperand_isImm(MCInst_getOperand(MI, 2)) && - MCOperand_getImm(MCInst_getOperand(MI, 2)) == 0) { - // (ADDI GPR:$rd, GPR:$rs, 0) - AsmString = "mv $\x01, $\x02"; - break; - } - return false; - case RISCV_ADDIW: - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_isReg(MCInst_getOperand(MI, 1)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 1))) && - MCOperand_isImm(MCInst_getOperand(MI, 2)) && - MCOperand_getImm(MCInst_getOperand(MI, 2)) == 0) { - // (ADDIW GPR:$rd, GPR:$rs, 0) - AsmString = "sext.w $\x01, $\x02"; - break; - } - return false; - case RISCV_BEQ: - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_getReg(MCInst_getOperand(MI, 1)) == RISCV_X0 && - RISCVInstPrinterValidateMCOperand(MCInst_getOperand(MI, 2), 1)) { - // (BEQ GPR:$rs, X0, simm13_lsb0:$offset) - AsmString = "beqz $\x01, $\x03"; - break; - } - return false; - case RISCV_BGE: - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_getReg(MCInst_getOperand(MI, 0)) == RISCV_X0 && - MCOperand_isReg(MCInst_getOperand(MI, 1)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 1))) && - RISCVInstPrinterValidateMCOperand(MCInst_getOperand(MI, 2), 1)) { - // (BGE X0, GPR:$rs, simm13_lsb0:$offset) - AsmString = "blez $\x02, $\x03"; - break; - } - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_getReg(MCInst_getOperand(MI, 1)) == RISCV_X0 && - RISCVInstPrinterValidateMCOperand(MCInst_getOperand(MI, 2), 1)) { - // (BGE GPR:$rs, X0, simm13_lsb0:$offset) - AsmString = "bgez $\x01, $\x03"; - break; - } - return false; - case RISCV_BLT: - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_getReg(MCInst_getOperand(MI, 1)) == RISCV_X0 && - RISCVInstPrinterValidateMCOperand(MCInst_getOperand(MI, 2), 1)) { - // (BLT GPR:$rs, X0, simm13_lsb0:$offset) - AsmString = "bltz $\x01, $\x03"; - break; - } - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_getReg(MCInst_getOperand(MI, 0)) == RISCV_X0 && - MCOperand_isReg(MCInst_getOperand(MI, 1)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 1))) && - RISCVInstPrinterValidateMCOperand(MCInst_getOperand(MI, 2), 1)) { - // (BLT X0, GPR:$rs, simm13_lsb0:$offset) - AsmString = "bgtz $\x02, $\x03"; - break; - } - return false; - case RISCV_BNE: - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_getReg(MCInst_getOperand(MI, 1)) == RISCV_X0 && - RISCVInstPrinterValidateMCOperand(MCInst_getOperand(MI, 2), 1)) { - // (BNE GPR:$rs, X0, simm13_lsb0:$offset) - AsmString = "bnez $\x01, $\x03"; - break; - } - return false; - case RISCV_CSRRC: - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_getReg(MCInst_getOperand(MI, 0)) == RISCV_X0 && - MCOperand_isReg(MCInst_getOperand(MI, 2)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 2)))) { - // (CSRRC X0, csr_sysreg:$csr, GPR:$rs) - AsmString = "csrc $\xFF\x02\x01, $\x03"; - break; - } - return false; - case RISCV_CSRRCI: - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_getReg(MCInst_getOperand(MI, 0)) == RISCV_X0) { - // (CSRRCI X0, csr_sysreg:$csr, uimm5:$imm) - AsmString = "csrci $\xFF\x02\x01, $\x03"; - break; - } - return false; - case RISCV_CSRRS: - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_isImm(MCInst_getOperand(MI, 1)) && - MCOperand_getImm(MCInst_getOperand(MI, 1)) == 3 && - MCOperand_getReg(MCInst_getOperand(MI, 2)) == RISCV_X0) { - // (CSRRS GPR:$rd, 3, X0) - AsmString = "frcsr $\x01"; - break; - } - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_isImm(MCInst_getOperand(MI, 1)) && - MCOperand_getImm(MCInst_getOperand(MI, 1)) == 2 && - MCOperand_getReg(MCInst_getOperand(MI, 2)) == RISCV_X0) { - // (CSRRS GPR:$rd, 2, X0) - AsmString = "frrm $\x01"; - break; - } - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_isImm(MCInst_getOperand(MI, 1)) && - MCOperand_getImm(MCInst_getOperand(MI, 1)) == 1 && - MCOperand_getReg(MCInst_getOperand(MI, 2)) == RISCV_X0) { - // (CSRRS GPR:$rd, 1, X0) - AsmString = "frflags $\x01"; - break; - } - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_isImm(MCInst_getOperand(MI, 1)) && - MCOperand_getImm(MCInst_getOperand(MI, 1)) == 3074 && - MCOperand_getReg(MCInst_getOperand(MI, 2)) == RISCV_X0) { - // (CSRRS GPR:$rd, 3074, X0) - AsmString = "rdinstret $\x01"; - break; - } - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_isImm(MCInst_getOperand(MI, 1)) && - MCOperand_getImm(MCInst_getOperand(MI, 1)) == 3072 && - MCOperand_getReg(MCInst_getOperand(MI, 2)) == RISCV_X0) { - // (CSRRS GPR:$rd, 3072, X0) - AsmString = "rdcycle $\x01"; - break; - } - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_isImm(MCInst_getOperand(MI, 1)) && - MCOperand_getImm(MCInst_getOperand(MI, 1)) == 3073 && - MCOperand_getReg(MCInst_getOperand(MI, 2)) == RISCV_X0) { - // (CSRRS GPR:$rd, 3073, X0) - AsmString = "rdtime $\x01"; - break; - } - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_isImm(MCInst_getOperand(MI, 1)) && - MCOperand_getImm(MCInst_getOperand(MI, 1)) == 3202 && - MCOperand_getReg(MCInst_getOperand(MI, 2)) == RISCV_X0) { - // (CSRRS GPR:$rd, 3202, X0) - AsmString = "rdinstreth $\x01"; - break; - } - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_isImm(MCInst_getOperand(MI, 1)) && - MCOperand_getImm(MCInst_getOperand(MI, 1)) == 3200 && - MCOperand_getReg(MCInst_getOperand(MI, 2)) == RISCV_X0) { - // (CSRRS GPR:$rd, 3200, X0) - AsmString = "rdcycleh $\x01"; - break; - } - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_isImm(MCInst_getOperand(MI, 1)) && - MCOperand_getImm(MCInst_getOperand(MI, 1)) == 3201 && - MCOperand_getReg(MCInst_getOperand(MI, 2)) == RISCV_X0) { - // (CSRRS GPR:$rd, 3201, X0) - AsmString = "rdtimeh $\x01"; - break; - } - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_getReg(MCInst_getOperand(MI, 2)) == RISCV_X0) { - // (CSRRS GPR:$rd, csr_sysreg:$csr, X0) - AsmString = "csrr $\x01, $\xFF\x02\x01"; - break; - } - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_getReg(MCInst_getOperand(MI, 0)) == RISCV_X0 && - MCOperand_isReg(MCInst_getOperand(MI, 2)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 2)))) { - // (CSRRS X0, csr_sysreg:$csr, GPR:$rs) - AsmString = "csrs $\xFF\x02\x01, $\x03"; - break; - } - return false; - case RISCV_CSRRSI: - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_getReg(MCInst_getOperand(MI, 0)) == RISCV_X0) { - // (CSRRSI X0, csr_sysreg:$csr, uimm5:$imm) - AsmString = "csrsi $\xFF\x02\x01, $\x03"; - break; - } - return false; - case RISCV_CSRRW: - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_getReg(MCInst_getOperand(MI, 0)) == RISCV_X0 && - MCOperand_isImm(MCInst_getOperand(MI, 1)) && - MCOperand_getImm(MCInst_getOperand(MI, 1)) == 3 && - MCOperand_isReg(MCInst_getOperand(MI, 2)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 2)))) { - // (CSRRW X0, 3, GPR:$rs) - AsmString = "fscsr $\x03"; - break; - } - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_getReg(MCInst_getOperand(MI, 0)) == RISCV_X0 && - MCOperand_isImm(MCInst_getOperand(MI, 1)) && - MCOperand_getImm(MCInst_getOperand(MI, 1)) == 2 && - MCOperand_isReg(MCInst_getOperand(MI, 2)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 2)))) { - // (CSRRW X0, 2, GPR:$rs) - AsmString = "fsrm $\x03"; - break; - } - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_getReg(MCInst_getOperand(MI, 0)) == RISCV_X0 && - MCOperand_isImm(MCInst_getOperand(MI, 1)) && - MCOperand_getImm(MCInst_getOperand(MI, 1)) == 1 && - MCOperand_isReg(MCInst_getOperand(MI, 2)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 2)))) { - // (CSRRW X0, 1, GPR:$rs) - AsmString = "fsflags $\x03"; - break; - } - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_getReg(MCInst_getOperand(MI, 0)) == RISCV_X0 && - MCOperand_isReg(MCInst_getOperand(MI, 2)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 2)))) { - // (CSRRW X0, csr_sysreg:$csr, GPR:$rs) - AsmString = "csrw $\xFF\x02\x01, $\x03"; - break; - } - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_isImm(MCInst_getOperand(MI, 1)) && - MCOperand_getImm(MCInst_getOperand(MI, 1)) == 3 && - MCOperand_isReg(MCInst_getOperand(MI, 2)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 2)))) { - // (CSRRW GPR:$rd, 3, GPR:$rs) - AsmString = "fscsr $\x01, $\x03"; - break; - } - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_isImm(MCInst_getOperand(MI, 1)) && - MCOperand_getImm(MCInst_getOperand(MI, 1)) == 2 && - MCOperand_isReg(MCInst_getOperand(MI, 2)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 2)))) { - // (CSRRW GPR:$rd, 2, GPR:$rs) - AsmString = "fsrm $\x01, $\x03"; - break; - } - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_isImm(MCInst_getOperand(MI, 1)) && - MCOperand_getImm(MCInst_getOperand(MI, 1)) == 1 && - MCOperand_isReg(MCInst_getOperand(MI, 2)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 2)))) { - // (CSRRW GPR:$rd, 1, GPR:$rs) - AsmString = "fsflags $\x01, $\x03"; - break; - } - return false; - case RISCV_CSRRWI: - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_getReg(MCInst_getOperand(MI, 0)) == RISCV_X0 && - MCOperand_isImm(MCInst_getOperand(MI, 1)) && - MCOperand_getImm(MCInst_getOperand(MI, 1)) == 2) { - // (CSRRWI X0, 2, uimm5:$imm) - AsmString = "fsrmi $\x03"; - break; - } - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_getReg(MCInst_getOperand(MI, 0)) == RISCV_X0 && - MCOperand_isImm(MCInst_getOperand(MI, 1)) && - MCOperand_getImm(MCInst_getOperand(MI, 1)) == 1) { - // (CSRRWI X0, 1, uimm5:$imm) - AsmString = "fsflagsi $\x03"; - break; - } - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_getReg(MCInst_getOperand(MI, 0)) == RISCV_X0) { - // (CSRRWI X0, csr_sysreg:$csr, uimm5:$imm) - AsmString = "csrwi $\xFF\x02\x01, $\x03"; - break; - } - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_isImm(MCInst_getOperand(MI, 1)) && - MCOperand_getImm(MCInst_getOperand(MI, 1)) == 2) { - // (CSRRWI GPR:$rd, 2, uimm5:$imm) - AsmString = "fsrmi $\x01, $\x03"; - break; - } - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_isImm(MCInst_getOperand(MI, 1)) && - MCOperand_getImm(MCInst_getOperand(MI, 1)) == 1) { - // (CSRRWI GPR:$rd, 1, uimm5:$imm) - AsmString = "fsflagsi $\x01, $\x03"; - break; - } - return false; - case RISCV_FADD_D: - if (MCInst_getNumOperands(MI) == 4 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR64RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_isReg(MCInst_getOperand(MI, 1)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR64RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 1))) && - MCOperand_isReg(MCInst_getOperand(MI, 2)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR64RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 2))) && - MCOperand_isImm(MCInst_getOperand(MI, 3)) && - MCOperand_getImm(MCInst_getOperand(MI, 3)) == 7) { - // (FADD_D FPR64:$rd, FPR64:$rs1, FPR64:$rs2, { 1, 1, 1 }) - AsmString = "fadd.d $\x01, $\x02, $\x03"; - break; - } - return false; - case RISCV_FADD_S: - if (MCInst_getNumOperands(MI) == 4 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR32RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_isReg(MCInst_getOperand(MI, 1)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR32RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 1))) && - MCOperand_isReg(MCInst_getOperand(MI, 2)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR32RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 2))) && - MCOperand_isImm(MCInst_getOperand(MI, 3)) && - MCOperand_getImm(MCInst_getOperand(MI, 3)) == 7) { - // (FADD_S FPR32:$rd, FPR32:$rs1, FPR32:$rs2, { 1, 1, 1 }) - AsmString = "fadd.s $\x01, $\x02, $\x03"; - break; - } - return false; - case RISCV_FCVT_D_L: - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR64RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_isReg(MCInst_getOperand(MI, 1)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 1))) && - MCOperand_isImm(MCInst_getOperand(MI, 2)) && - MCOperand_getImm(MCInst_getOperand(MI, 2)) == 7) { - // (FCVT_D_L FPR64:$rd, GPR:$rs1, { 1, 1, 1 }) - AsmString = "fcvt.d.l $\x01, $\x02"; - break; - } - return false; - case RISCV_FCVT_D_LU: - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR64RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_isReg(MCInst_getOperand(MI, 1)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 1))) && - MCOperand_isImm(MCInst_getOperand(MI, 2)) && - MCOperand_getImm(MCInst_getOperand(MI, 2)) == 7) { - // (FCVT_D_LU FPR64:$rd, GPR:$rs1, { 1, 1, 1 }) - AsmString = "fcvt.d.lu $\x01, $\x02"; - break; - } - return false; - case RISCV_FCVT_LU_D: - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_isReg(MCInst_getOperand(MI, 1)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR64RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 1))) && - MCOperand_isImm(MCInst_getOperand(MI, 2)) && - MCOperand_getImm(MCInst_getOperand(MI, 2)) == 7) { - // (FCVT_LU_D GPR:$rd, FPR64:$rs1, { 1, 1, 1 }) - AsmString = "fcvt.lu.d $\x01, $\x02"; - break; - } - return false; - case RISCV_FCVT_LU_S: - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_isReg(MCInst_getOperand(MI, 1)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR32RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 1))) && - MCOperand_isImm(MCInst_getOperand(MI, 2)) && - MCOperand_getImm(MCInst_getOperand(MI, 2)) == 7) { - // (FCVT_LU_S GPR:$rd, FPR32:$rs1, { 1, 1, 1 }) - AsmString = "fcvt.lu.s $\x01, $\x02"; - break; - } - return false; - case RISCV_FCVT_L_D: - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_isReg(MCInst_getOperand(MI, 1)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR64RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 1))) && - MCOperand_isImm(MCInst_getOperand(MI, 2)) && - MCOperand_getImm(MCInst_getOperand(MI, 2)) == 7) { - // (FCVT_L_D GPR:$rd, FPR64:$rs1, { 1, 1, 1 }) - AsmString = "fcvt.l.d $\x01, $\x02"; - break; - } - return false; - case RISCV_FCVT_L_S: - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_isReg(MCInst_getOperand(MI, 1)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR32RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 1))) && - MCOperand_isImm(MCInst_getOperand(MI, 2)) && - MCOperand_getImm(MCInst_getOperand(MI, 2)) == 7) { - // (FCVT_L_S GPR:$rd, FPR32:$rs1, { 1, 1, 1 }) - AsmString = "fcvt.l.s $\x01, $\x02"; - break; - } - return false; - case RISCV_FCVT_S_D: - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR32RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_isReg(MCInst_getOperand(MI, 1)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR64RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 1))) && - MCOperand_isImm(MCInst_getOperand(MI, 2)) && - MCOperand_getImm(MCInst_getOperand(MI, 2)) == 7) { - // (FCVT_S_D FPR32:$rd, FPR64:$rs1, { 1, 1, 1 }) - AsmString = "fcvt.s.d $\x01, $\x02"; - break; - } - return false; - case RISCV_FCVT_S_L: - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR32RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_isReg(MCInst_getOperand(MI, 1)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 1))) && - MCOperand_isImm(MCInst_getOperand(MI, 2)) && - MCOperand_getImm(MCInst_getOperand(MI, 2)) == 7) { - // (FCVT_S_L FPR32:$rd, GPR:$rs1, { 1, 1, 1 }) - AsmString = "fcvt.s.l $\x01, $\x02"; - break; - } - return false; - case RISCV_FCVT_S_LU: - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR32RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_isReg(MCInst_getOperand(MI, 1)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 1))) && - MCOperand_isImm(MCInst_getOperand(MI, 2)) && - MCOperand_getImm(MCInst_getOperand(MI, 2)) == 7) { - // (FCVT_S_LU FPR32:$rd, GPR:$rs1, { 1, 1, 1 }) - AsmString = "fcvt.s.lu $\x01, $\x02"; - break; - } - return false; - case RISCV_FCVT_S_W: - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR32RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_isReg(MCInst_getOperand(MI, 1)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 1))) && - MCOperand_isImm(MCInst_getOperand(MI, 2)) && - MCOperand_getImm(MCInst_getOperand(MI, 2)) == 7) { - // (FCVT_S_W FPR32:$rd, GPR:$rs1, { 1, 1, 1 }) - AsmString = "fcvt.s.w $\x01, $\x02"; - break; - } - return false; - case RISCV_FCVT_S_WU: - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR32RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_isReg(MCInst_getOperand(MI, 1)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 1))) && - MCOperand_isImm(MCInst_getOperand(MI, 2)) && - MCOperand_getImm(MCInst_getOperand(MI, 2)) == 7) { - // (FCVT_S_WU FPR32:$rd, GPR:$rs1, { 1, 1, 1 }) - AsmString = "fcvt.s.wu $\x01, $\x02"; - break; - } - return false; - case RISCV_FCVT_WU_D: - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_isReg(MCInst_getOperand(MI, 1)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR64RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 1))) && - MCOperand_isImm(MCInst_getOperand(MI, 2)) && - MCOperand_getImm(MCInst_getOperand(MI, 2)) == 7) { - // (FCVT_WU_D GPR:$rd, FPR64:$rs1, { 1, 1, 1 }) - AsmString = "fcvt.wu.d $\x01, $\x02"; - break; - } - return false; - case RISCV_FCVT_WU_S: - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_isReg(MCInst_getOperand(MI, 1)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR32RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 1))) && - MCOperand_isImm(MCInst_getOperand(MI, 2)) && - MCOperand_getImm(MCInst_getOperand(MI, 2)) == 7) { - // (FCVT_WU_S GPR:$rd, FPR32:$rs1, { 1, 1, 1 }) - AsmString = "fcvt.wu.s $\x01, $\x02"; - break; - } - return false; - case RISCV_FCVT_W_D: - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_isReg(MCInst_getOperand(MI, 1)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR64RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 1))) && - MCOperand_isImm(MCInst_getOperand(MI, 2)) && - MCOperand_getImm(MCInst_getOperand(MI, 2)) == 7) { - // (FCVT_W_D GPR:$rd, FPR64:$rs1, { 1, 1, 1 }) - AsmString = "fcvt.w.d $\x01, $\x02"; - break; - } - return false; - case RISCV_FCVT_W_S: - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_isReg(MCInst_getOperand(MI, 1)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR32RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 1))) && - MCOperand_isImm(MCInst_getOperand(MI, 2)) && - MCOperand_getImm(MCInst_getOperand(MI, 2)) == 7) { - // (FCVT_W_S GPR:$rd, FPR32:$rs1, { 1, 1, 1 }) - AsmString = "fcvt.w.s $\x01, $\x02"; - break; - } - return false; - case RISCV_FDIV_D: - if (MCInst_getNumOperands(MI) == 4 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR64RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_isReg(MCInst_getOperand(MI, 1)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR64RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 1))) && - MCOperand_isReg(MCInst_getOperand(MI, 2)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR64RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 2))) && - MCOperand_isImm(MCInst_getOperand(MI, 3)) && - MCOperand_getImm(MCInst_getOperand(MI, 3)) == 7) { - // (FDIV_D FPR64:$rd, FPR64:$rs1, FPR64:$rs2, { 1, 1, 1 }) - AsmString = "fdiv.d $\x01, $\x02, $\x03"; - break; - } - return false; - case RISCV_FDIV_S: - if (MCInst_getNumOperands(MI) == 4 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR32RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_isReg(MCInst_getOperand(MI, 1)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR32RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 1))) && - MCOperand_isReg(MCInst_getOperand(MI, 2)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR32RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 2))) && - MCOperand_isImm(MCInst_getOperand(MI, 3)) && - MCOperand_getImm(MCInst_getOperand(MI, 3)) == 7) { - // (FDIV_S FPR32:$rd, FPR32:$rs1, FPR32:$rs2, { 1, 1, 1 }) - AsmString = "fdiv.s $\x01, $\x02, $\x03"; - break; - } - return false; - case RISCV_FENCE: - if (MCInst_getNumOperands(MI) == 2 && - MCOperand_isImm(MCInst_getOperand(MI, 0)) && - MCOperand_getImm(MCInst_getOperand(MI, 0)) == 15 && - MCOperand_isImm(MCInst_getOperand(MI, 1)) && - MCOperand_getImm(MCInst_getOperand(MI, 1)) == 15) { - // (FENCE 15, 15) - AsmString = "fence"; - break; - } - return false; - case RISCV_FMADD_D: - if (MCInst_getNumOperands(MI) == 5 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR64RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_isReg(MCInst_getOperand(MI, 1)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR64RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 1))) && - MCOperand_isReg(MCInst_getOperand(MI, 2)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR64RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 2))) && - MCOperand_isReg(MCInst_getOperand(MI, 3)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR64RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 3))) && - MCOperand_isImm(MCInst_getOperand(MI, 4)) && - MCOperand_getImm(MCInst_getOperand(MI, 4)) == 7) { - // (FMADD_D FPR64:$rd, FPR64:$rs1, FPR64:$rs2, FPR64:$rs3, { 1, 1, 1 }) - AsmString = "fmadd.d $\x01, $\x02, $\x03, $\x04"; - break; - } - return false; - case RISCV_FMADD_S: - if (MCInst_getNumOperands(MI) == 5 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR32RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_isReg(MCInst_getOperand(MI, 1)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR32RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 1))) && - MCOperand_isReg(MCInst_getOperand(MI, 2)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR32RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 2))) && - MCOperand_isReg(MCInst_getOperand(MI, 3)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR32RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 3))) && - MCOperand_isImm(MCInst_getOperand(MI, 4)) && - MCOperand_getImm(MCInst_getOperand(MI, 4)) == 7) { - // (FMADD_S FPR32:$rd, FPR32:$rs1, FPR32:$rs2, FPR32:$rs3, { 1, 1, 1 }) - AsmString = "fmadd.s $\x01, $\x02, $\x03, $\x04"; - break; - } - return false; - case RISCV_FMSUB_D: - if (MCInst_getNumOperands(MI) == 5 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR64RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_isReg(MCInst_getOperand(MI, 1)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR64RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 1))) && - MCOperand_isReg(MCInst_getOperand(MI, 2)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR64RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 2))) && - MCOperand_isReg(MCInst_getOperand(MI, 3)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR64RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 3))) && - MCOperand_isImm(MCInst_getOperand(MI, 4)) && - MCOperand_getImm(MCInst_getOperand(MI, 4)) == 7) { - // (FMSUB_D FPR64:$rd, FPR64:$rs1, FPR64:$rs2, FPR64:$rs3, { 1, 1, 1 }) - AsmString = "fmsub.d $\x01, $\x02, $\x03, $\x04"; - break; - } - return false; - case RISCV_FMSUB_S: - if (MCInst_getNumOperands(MI) == 5 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR32RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_isReg(MCInst_getOperand(MI, 1)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR32RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 1))) && - MCOperand_isReg(MCInst_getOperand(MI, 2)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR32RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 2))) && - MCOperand_isReg(MCInst_getOperand(MI, 3)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR32RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 3))) && - MCOperand_isImm(MCInst_getOperand(MI, 4)) && - MCOperand_getImm(MCInst_getOperand(MI, 4)) == 7) { - // (FMSUB_S FPR32:$rd, FPR32:$rs1, FPR32:$rs2, FPR32:$rs3, { 1, 1, 1 }) - AsmString = "fmsub.s $\x01, $\x02, $\x03, $\x04"; - break; - } - return false; - case RISCV_FMUL_D: - if (MCInst_getNumOperands(MI) == 4 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR64RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_isReg(MCInst_getOperand(MI, 1)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR64RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 1))) && - MCOperand_isReg(MCInst_getOperand(MI, 2)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR64RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 2))) && - MCOperand_isImm(MCInst_getOperand(MI, 3)) && - MCOperand_getImm(MCInst_getOperand(MI, 3)) == 7) { - // (FMUL_D FPR64:$rd, FPR64:$rs1, FPR64:$rs2, { 1, 1, 1 }) - AsmString = "fmul.d $\x01, $\x02, $\x03"; - break; - } - return false; - case RISCV_FMUL_S: - if (MCInst_getNumOperands(MI) == 4 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR32RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_isReg(MCInst_getOperand(MI, 1)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR32RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 1))) && - MCOperand_isReg(MCInst_getOperand(MI, 2)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR32RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 2))) && - MCOperand_isImm(MCInst_getOperand(MI, 3)) && - MCOperand_getImm(MCInst_getOperand(MI, 3)) == 7) { - // (FMUL_S FPR32:$rd, FPR32:$rs1, FPR32:$rs2, { 1, 1, 1 }) - AsmString = "fmul.s $\x01, $\x02, $\x03"; - break; - } - return false; - case RISCV_FNMADD_D: - if (MCInst_getNumOperands(MI) == 5 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR64RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_isReg(MCInst_getOperand(MI, 1)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR64RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 1))) && - MCOperand_isReg(MCInst_getOperand(MI, 2)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR64RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 2))) && - MCOperand_isReg(MCInst_getOperand(MI, 3)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR64RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 3))) && - MCOperand_isImm(MCInst_getOperand(MI, 4)) && - MCOperand_getImm(MCInst_getOperand(MI, 4)) == 7) { - // (FNMADD_D FPR64:$rd, FPR64:$rs1, FPR64:$rs2, FPR64:$rs3, { 1, 1, 1 }) - AsmString = "fnmadd.d $\x01, $\x02, $\x03, $\x04"; - break; - } - return false; - case RISCV_FNMADD_S: - if (MCInst_getNumOperands(MI) == 5 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR32RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_isReg(MCInst_getOperand(MI, 1)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR32RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 1))) && - MCOperand_isReg(MCInst_getOperand(MI, 2)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR32RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 2))) && - MCOperand_isReg(MCInst_getOperand(MI, 3)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR32RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 3))) && - MCOperand_isImm(MCInst_getOperand(MI, 4)) && - MCOperand_getImm(MCInst_getOperand(MI, 4)) == 7) { - // (FNMADD_S FPR32:$rd, FPR32:$rs1, FPR32:$rs2, FPR32:$rs3, { 1, 1, 1 }) - AsmString = "fnmadd.s $\x01, $\x02, $\x03, $\x04"; - break; - } - return false; - case RISCV_FNMSUB_D: - if (MCInst_getNumOperands(MI) == 5 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR64RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_isReg(MCInst_getOperand(MI, 1)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR64RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 1))) && - MCOperand_isReg(MCInst_getOperand(MI, 2)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR64RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 2))) && - MCOperand_isReg(MCInst_getOperand(MI, 3)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR64RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 3))) && - MCOperand_isImm(MCInst_getOperand(MI, 4)) && - MCOperand_getImm(MCInst_getOperand(MI, 4)) == 7) { - // (FNMSUB_D FPR64:$rd, FPR64:$rs1, FPR64:$rs2, FPR64:$rs3, { 1, 1, 1 }) - AsmString = "fnmsub.d $\x01, $\x02, $\x03, $\x04"; - break; - } - return false; - case RISCV_FNMSUB_S: - if (MCInst_getNumOperands(MI) == 5 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR32RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_isReg(MCInst_getOperand(MI, 1)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR32RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 1))) && - MCOperand_isReg(MCInst_getOperand(MI, 2)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR32RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 2))) && - MCOperand_isReg(MCInst_getOperand(MI, 3)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR32RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 3))) && - MCOperand_isImm(MCInst_getOperand(MI, 4)) && - MCOperand_getImm(MCInst_getOperand(MI, 4)) == 7) { - // (FNMSUB_S FPR32:$rd, FPR32:$rs1, FPR32:$rs2, FPR32:$rs3, { 1, 1, 1 }) - AsmString = "fnmsub.s $\x01, $\x02, $\x03, $\x04"; - break; - } - return false; - case RISCV_FSGNJN_D: - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR64RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_isReg(MCInst_getOperand(MI, 1)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR64RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 1))) && - MCOperand_isReg(MCInst_getOperand(MI, 2)) && - MCOperand_getReg(MCInst_getOperand(MI, 2)) == MCOperand_getReg(MCInst_getOperand(MI, 1))) { - // (FSGNJN_D FPR64:$rd, FPR64:$rs, FPR64:$rs) - AsmString = "fneg.d $\x01, $\x02"; - break; - } - return false; - case RISCV_FSGNJN_S: - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR32RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_isReg(MCInst_getOperand(MI, 1)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR32RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 1))) && - MCOperand_isReg(MCInst_getOperand(MI, 2)) && - MCOperand_getReg(MCInst_getOperand(MI, 2)) == MCOperand_getReg(MCInst_getOperand(MI, 1))) { - // (FSGNJN_S FPR32:$rd, FPR32:$rs, FPR32:$rs) - AsmString = "fneg.s $\x01, $\x02"; - break; - } - return false; - case RISCV_FSGNJX_D: - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR64RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_isReg(MCInst_getOperand(MI, 1)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR64RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 1))) && - MCOperand_isReg(MCInst_getOperand(MI, 2)) && - MCOperand_getReg(MCInst_getOperand(MI, 2)) == MCOperand_getReg(MCInst_getOperand(MI, 1))) { - // (FSGNJX_D FPR64:$rd, FPR64:$rs, FPR64:$rs) - AsmString = "fabs.d $\x01, $\x02"; - break; - } - return false; - case RISCV_FSGNJX_S: - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR32RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_isReg(MCInst_getOperand(MI, 1)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR32RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 1))) && - MCOperand_isReg(MCInst_getOperand(MI, 2)) && - MCOperand_getReg(MCInst_getOperand(MI, 2)) == MCOperand_getReg(MCInst_getOperand(MI, 1))) { - // (FSGNJX_S FPR32:$rd, FPR32:$rs, FPR32:$rs) - AsmString = "fabs.s $\x01, $\x02"; - break; - } - return false; - case RISCV_FSGNJ_D: - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR64RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_isReg(MCInst_getOperand(MI, 1)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR64RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 1))) && - MCOperand_isReg(MCInst_getOperand(MI, 2)) && - MCOperand_getReg(MCInst_getOperand(MI, 2)) == MCOperand_getReg(MCInst_getOperand(MI, 1))) { - // (FSGNJ_D FPR64:$rd, FPR64:$rs, FPR64:$rs) - AsmString = "fmv.d $\x01, $\x02"; - break; - } - return false; - case RISCV_FSGNJ_S: - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR32RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_isReg(MCInst_getOperand(MI, 1)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR32RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 1))) && - MCOperand_isReg(MCInst_getOperand(MI, 2)) && - MCOperand_getReg(MCInst_getOperand(MI, 2)) == MCOperand_getReg(MCInst_getOperand(MI, 1))) { - // (FSGNJ_S FPR32:$rd, FPR32:$rs, FPR32:$rs) - AsmString = "fmv.s $\x01, $\x02"; - break; - } - return false; - case RISCV_FSQRT_D: - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR64RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_isReg(MCInst_getOperand(MI, 1)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR64RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 1))) && - MCOperand_isImm(MCInst_getOperand(MI, 2)) && - MCOperand_getImm(MCInst_getOperand(MI, 2)) == 7) { - // (FSQRT_D FPR64:$rd, FPR64:$rs1, { 1, 1, 1 }) - AsmString = "fsqrt.d $\x01, $\x02"; - break; - } - return false; - case RISCV_FSQRT_S: - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR32RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_isReg(MCInst_getOperand(MI, 1)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR32RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 1))) && - MCOperand_isImm(MCInst_getOperand(MI, 2)) && - MCOperand_getImm(MCInst_getOperand(MI, 2)) == 7) { - // (FSQRT_S FPR32:$rd, FPR32:$rs1, { 1, 1, 1 }) - AsmString = "fsqrt.s $\x01, $\x02"; - break; - } - return false; - case RISCV_FSUB_D: - if (MCInst_getNumOperands(MI) == 4 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR64RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_isReg(MCInst_getOperand(MI, 1)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR64RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 1))) && - MCOperand_isReg(MCInst_getOperand(MI, 2)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR64RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 2))) && - MCOperand_isImm(MCInst_getOperand(MI, 3)) && - MCOperand_getImm(MCInst_getOperand(MI, 3)) == 7) { - // (FSUB_D FPR64:$rd, FPR64:$rs1, FPR64:$rs2, { 1, 1, 1 }) - AsmString = "fsub.d $\x01, $\x02, $\x03"; - break; - } - return false; - case RISCV_FSUB_S: - if (MCInst_getNumOperands(MI) == 4 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR32RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_isReg(MCInst_getOperand(MI, 1)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR32RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 1))) && - MCOperand_isReg(MCInst_getOperand(MI, 2)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_FPR32RegClassID), MCOperand_getReg(MCInst_getOperand(MI, 2))) && - MCOperand_isImm(MCInst_getOperand(MI, 3)) && - MCOperand_getImm(MCInst_getOperand(MI, 3)) == 7) { - // (FSUB_S FPR32:$rd, FPR32:$rs1, FPR32:$rs2, { 1, 1, 1 }) - AsmString = "fsub.s $\x01, $\x02, $\x03"; - break; - } - return false; - case RISCV_JAL: - if (MCInst_getNumOperands(MI) == 2 && - MCOperand_getReg(MCInst_getOperand(MI, 0)) == RISCV_X0 && - RISCVInstPrinterValidateMCOperand(MCInst_getOperand(MI, 1), 2)) { - // (JAL X0, simm21_lsb0_jal:$offset) - AsmString = "j $\x02"; - break; - } - if (MCInst_getNumOperands(MI) == 2 && - MCOperand_getReg(MCInst_getOperand(MI, 0)) == RISCV_X1 && - RISCVInstPrinterValidateMCOperand(MCInst_getOperand(MI, 1), 2)) { - // (JAL X1, simm21_lsb0_jal:$offset) - AsmString = "jal $\x02"; - break; - } - return false; - case RISCV_JALR: - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_getReg(MCInst_getOperand(MI, 0)) == RISCV_X0 && - MCOperand_getReg(MCInst_getOperand(MI, 1)) == RISCV_X1 && - MCOperand_isImm(MCInst_getOperand(MI, 2)) && - MCOperand_getImm(MCInst_getOperand(MI, 2)) == 0) { - // (JALR X0, X1, 0) - AsmString = "ret"; - break; - } - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_getReg(MCInst_getOperand(MI, 0)) == RISCV_X0 && - MCOperand_isReg(MCInst_getOperand(MI, 1)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 1))) && - MCOperand_isImm(MCInst_getOperand(MI, 2)) && - MCOperand_getImm(MCInst_getOperand(MI, 2)) == 0) { - // (JALR X0, GPR:$rs, 0) - AsmString = "jr $\x02"; - break; - } - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_getReg(MCInst_getOperand(MI, 0)) == RISCV_X1 && - MCOperand_isReg(MCInst_getOperand(MI, 1)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 1))) && - MCOperand_isImm(MCInst_getOperand(MI, 2)) && - MCOperand_getImm(MCInst_getOperand(MI, 2)) == 0) { - // (JALR X1, GPR:$rs, 0) - AsmString = "jalr $\x02"; - break; - } - return false; - case RISCV_SFENCE_VMA: - if (MCInst_getNumOperands(MI) == 2 && - MCOperand_getReg(MCInst_getOperand(MI, 0)) == RISCV_X0 && - MCOperand_getReg(MCInst_getOperand(MI, 1)) == RISCV_X0) { - // (SFENCE_VMA X0, X0) - AsmString = "sfence.vma"; - break; - } - if (MCInst_getNumOperands(MI) == 2 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_getReg(MCInst_getOperand(MI, 1)) == RISCV_X0) { - // (SFENCE_VMA GPR:$rs, X0) - AsmString = "sfence.vma $\x01"; - break; - } - return false; - case RISCV_SLT: - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_isReg(MCInst_getOperand(MI, 1)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 1))) && - MCOperand_getReg(MCInst_getOperand(MI, 2)) == RISCV_X0) { - // (SLT GPR:$rd, GPR:$rs, X0) - AsmString = "sltz $\x01, $\x02"; - break; - } - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_getReg(MCInst_getOperand(MI, 1)) == RISCV_X0 && - MCOperand_isReg(MCInst_getOperand(MI, 2)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 2)))) { - // (SLT GPR:$rd, X0, GPR:$rs) - AsmString = "sgtz $\x01, $\x03"; - break; - } - return false; - case RISCV_SLTIU: - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_isReg(MCInst_getOperand(MI, 1)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 1))) && - MCOperand_isImm(MCInst_getOperand(MI, 2)) && - MCOperand_getImm(MCInst_getOperand(MI, 2)) == 1) { - // (SLTIU GPR:$rd, GPR:$rs, 1) - AsmString = "seqz $\x01, $\x02"; - break; - } - return false; - case RISCV_SLTU: - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_getReg(MCInst_getOperand(MI, 1)) == RISCV_X0 && - MCOperand_isReg(MCInst_getOperand(MI, 2)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 2)))) { - // (SLTU GPR:$rd, X0, GPR:$rs) - AsmString = "snez $\x01, $\x03"; - break; - } - return false; - case RISCV_SUB: - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_getReg(MCInst_getOperand(MI, 1)) == RISCV_X0 && - MCOperand_isReg(MCInst_getOperand(MI, 2)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 2)))) { - // (SUB GPR:$rd, X0, GPR:$rs) - AsmString = "neg $\x01, $\x03"; - break; - } - return false; - case RISCV_SUBW: - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_getReg(MCInst_getOperand(MI, 1)) == RISCV_X0 && - MCOperand_isReg(MCInst_getOperand(MI, 2)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 2)))) { - // (SUBW GPR:$rd, X0, GPR:$rs) - AsmString = "negw $\x01, $\x03"; - break; - } - return false; - case RISCV_XORI: - if (MCInst_getNumOperands(MI) == 3 && - MCOperand_isReg(MCInst_getOperand(MI, 0)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 0))) && - MCOperand_isReg(MCInst_getOperand(MI, 1)) && - MCRegisterClass_contains(MCRegisterInfo_getRegClass(MRI, RISCV_GPRRegClassID), MCOperand_getReg(MCInst_getOperand(MI, 1))) && - MCOperand_isImm(MCInst_getOperand(MI, 2)) && - MCOperand_getImm(MCInst_getOperand(MI, 2)) == -1) { - // (XORI GPR:$rd, GPR:$rs, -1) - AsmString = "not $\x01, $\x02"; - break; - } - return false; - } + static const AliasPattern Patterns[] = { + // RISCV_ADD - 0 + {0, 0, 3, 4 }, + {7, 4, 3, 4 }, + {16, 8, 3, 4 }, + {23, 12, 3, 4 }, + // RISCV_ADDI - 4 + {31, 16, 3, 3 }, + {35, 19, 3, 3 }, + {45, 22, 3, 3 }, + // RISCV_ADDIW - 7 + {55, 25, 3, 4 }, + // RISCV_ADD_UW - 8 + {69, 29, 3, 5 }, + // RISCV_AUIPC - 9 + {83, 34, 2, 3 }, + // RISCV_BEQ - 10 + {91, 37, 3, 3 }, + // RISCV_BGE - 11 + {105, 40, 3, 3 }, + {119, 43, 3, 3 }, + // RISCV_BLT - 13 + {133, 46, 3, 3 }, + {147, 49, 3, 3 }, + // RISCV_BNE - 15 + {161, 52, 3, 3 }, + // RISCV_CSRRC - 16 + {175, 55, 3, 3 }, + // RISCV_CSRRCI - 17 + {189, 58, 3, 2 }, + // RISCV_CSRRS - 18 + {204, 60, 3, 4 }, + {213, 64, 3, 4 }, + {221, 68, 3, 4 }, + {232, 72, 3, 3 }, + {245, 75, 3, 3 }, + {256, 78, 3, 3 }, + {266, 81, 3, 4 }, + {280, 85, 3, 4 }, + {292, 89, 3, 4 }, + {303, 93, 3, 3 }, + {317, 96, 3, 3 }, + // RISCV_CSRRSI - 29 + {331, 99, 3, 2 }, + // RISCV_CSRRW - 30 + {346, 101, 3, 4 }, + {355, 105, 3, 4 }, + {363, 109, 3, 4 }, + {374, 113, 3, 3 }, + {388, 116, 3, 4 }, + {401, 120, 3, 4 }, + {413, 124, 3, 4 }, + // RISCV_CSRRWI - 37 + {428, 128, 3, 3 }, + {437, 131, 3, 3 }, + {449, 134, 3, 2 }, + {464, 136, 3, 3 }, + {477, 139, 3, 3 }, + // RISCV_CV_MULHHSN - 42 + {493, 142, 4, 6 }, + // RISCV_CV_MULHHUN - 43 + {514, 148, 4, 6 }, + // RISCV_CV_MULSN - 44 + {535, 154, 4, 6 }, + // RISCV_CV_MULUN - 45 + {554, 160, 4, 6 }, + // RISCV_C_ADD_HINT - 46 + {573, 166, 3, 6 }, + {582, 172, 3, 6 }, + {593, 178, 3, 6 }, + {602, 184, 3, 6 }, + // RISCV_FENCE - 50 + {612, 190, 2, 2 }, + {618, 192, 2, 3 }, + // RISCV_FSGNJN_D - 52 + {624, 195, 3, 4 }, + // RISCV_FSGNJN_D_IN32X - 53 + {624, 199, 3, 5 }, + // RISCV_FSGNJN_D_INX - 54 + {624, 204, 3, 5 }, + // RISCV_FSGNJN_H - 55 + {638, 209, 3, 4 }, + // RISCV_FSGNJN_H_INX - 56 + {638, 213, 3, 4 }, + // RISCV_FSGNJN_S - 57 + {652, 217, 3, 4 }, + // RISCV_FSGNJN_S_INX - 58 + {652, 221, 3, 4 }, + // RISCV_FSGNJX_D - 59 + {666, 225, 3, 4 }, + // RISCV_FSGNJX_D_IN32X - 60 + {666, 229, 3, 5 }, + // RISCV_FSGNJX_D_INX - 61 + {666, 234, 3, 5 }, + // RISCV_FSGNJX_H - 62 + {680, 239, 3, 4 }, + // RISCV_FSGNJX_H_INX - 63 + {680, 243, 3, 4 }, + // RISCV_FSGNJX_S - 64 + {694, 247, 3, 4 }, + // RISCV_FSGNJX_S_INX - 65 + {694, 251, 3, 4 }, + // RISCV_FSGNJ_D - 66 + {708, 255, 3, 4 }, + // RISCV_FSGNJ_H - 67 + {721, 259, 3, 4 }, + // RISCV_FSGNJ_H_INX - 68 + {721, 263, 3, 4 }, + // RISCV_FSGNJ_S - 69 + {734, 267, 3, 4 }, + // RISCV_HFENCE_GVMA - 70 + {747, 271, 2, 2 }, + {759, 273, 2, 2 }, + // RISCV_HFENCE_VVMA - 72 + {774, 275, 2, 2 }, + {786, 277, 2, 2 }, + // RISCV_JAL - 74 + {801, 279, 2, 2 }, + {808, 281, 2, 2 }, + // RISCV_JALR - 76 + {817, 283, 3, 3 }, + {821, 286, 3, 3 }, + {827, 289, 3, 3 }, + {835, 292, 3, 3 }, + {847, 295, 3, 3 }, + {857, 298, 3, 3 }, + // RISCV_SFENCE_VMA - 82 + {869, 301, 2, 2 }, + {880, 303, 2, 2 }, + // RISCV_SLT - 84 + {894, 305, 3, 3 }, + {906, 308, 3, 3 }, + // RISCV_SLTIU - 86 + {918, 311, 3, 3 }, + // RISCV_SLTU - 87 + {930, 314, 3, 3 }, + // RISCV_SUB - 88 + {942, 317, 3, 3 }, + // RISCV_SUBW - 89 + {953, 320, 3, 4 }, + // RISCV_VFSGNJN_VV - 90 + {965, 324, 4, 6 }, + {984, 330, 4, 6 }, + // RISCV_VFSGNJX_VV - 92 + {999, 336, 4, 6 }, + {1018, 342, 4, 6 }, + // RISCV_VL1RE8_V - 94 + {1033, 348, 2, 4 }, + // RISCV_VL2RE8_V - 95 + {1049, 352, 2, 4 }, + // RISCV_VL4RE8_V - 96 + {1065, 356, 2, 4 }, + // RISCV_VL8RE8_V - 97 + {1081, 360, 2, 4 }, + // RISCV_VMAND_MM - 98 + {1097, 364, 3, 5 }, + // RISCV_VMNAND_MM - 99 + {1111, 369, 3, 5 }, + // RISCV_VMXNOR_MM - 100 + {1126, 374, 3, 5 }, + // RISCV_VMXOR_MM - 101 + {1137, 379, 3, 5 }, + // RISCV_VNSRL_WX - 102 + {1148, 384, 4, 6 }, + {1171, 390, 4, 6 }, + // RISCV_VRSUB_VX - 104 + {1190, 396, 4, 6 }, + {1208, 402, 4, 6 }, + // RISCV_VWADDU_VX - 106 + {1222, 408, 4, 6 }, + {1246, 414, 4, 6 }, + // RISCV_VWADD_VX - 108 + {1266, 420, 4, 6 }, + {1289, 426, 4, 6 }, + // RISCV_VXOR_VI - 110 + {1308, 432, 4, 6 }, + {1326, 438, 4, 6 }, + // RISCV_XORI - 112 + {1340, 444, 3, 3 }, + {0}, }; + + static const AliasPatternCond Conds[] = { + // (ADD X0, X0, X2) - 0 + {AliasPatternCond_K_Reg, RISCV_X0}, + {AliasPatternCond_K_Reg, RISCV_X0}, + {AliasPatternCond_K_Reg, RISCV_X2}, + {AliasPatternCond_K_Feature, RISCV_FeatureStdExtZihintntl}, + // (ADD X0, X0, X3) - 4 + {AliasPatternCond_K_Reg, RISCV_X0}, + {AliasPatternCond_K_Reg, RISCV_X0}, + {AliasPatternCond_K_Reg, RISCV_X3}, + {AliasPatternCond_K_Feature, RISCV_FeatureStdExtZihintntl}, + // (ADD X0, X0, X4) - 8 + {AliasPatternCond_K_Reg, RISCV_X0}, + {AliasPatternCond_K_Reg, RISCV_X0}, + {AliasPatternCond_K_Reg, RISCV_X4}, + {AliasPatternCond_K_Feature, RISCV_FeatureStdExtZihintntl}, + // (ADD X0, X0, X5) - 12 + {AliasPatternCond_K_Reg, RISCV_X0}, + {AliasPatternCond_K_Reg, RISCV_X0}, + {AliasPatternCond_K_Reg, RISCV_X5}, + {AliasPatternCond_K_Feature, RISCV_FeatureStdExtZihintntl}, + // (ADDI X0, X0, 0) - 16 + {AliasPatternCond_K_Reg, RISCV_X0}, + {AliasPatternCond_K_Reg, RISCV_X0}, + {AliasPatternCond_K_Imm, (uint32_t)0}, + // (ADDI GPR:$rd, X0, simm12:$imm) - 19 + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_Reg, RISCV_X0}, + {AliasPatternCond_K_Custom, 1}, + // (ADDI GPR:$rd, GPR:$rs, 0) - 22 + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_Imm, (uint32_t)0}, + // (ADDIW GPR:$rd, GPR:$rs, 0) - 25 + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_Imm, (uint32_t)0}, + {AliasPatternCond_K_Feature, RISCV_Feature64Bit}, + // (ADD_UW GPR:$rd, GPR:$rs, X0) - 29 + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_Reg, RISCV_X0}, + {AliasPatternCond_K_Feature, RISCV_FeatureStdExtZba}, + {AliasPatternCond_K_Feature, RISCV_Feature64Bit}, + // (AUIPC X0, uimm20:$imm20) - 34 + {AliasPatternCond_K_Reg, RISCV_X0}, + {AliasPatternCond_K_Custom, 2}, + {AliasPatternCond_K_Feature, RISCV_FeatureStdExtZicfilp}, + // (BEQ GPR:$rs, X0, simm13_lsb0:$offset) - 37 + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_Reg, RISCV_X0}, + {AliasPatternCond_K_Custom, 3}, + // (BGE X0, GPR:$rs, simm13_lsb0:$offset) - 40 + {AliasPatternCond_K_Reg, RISCV_X0}, + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_Custom, 3}, + // (BGE GPR:$rs, X0, simm13_lsb0:$offset) - 43 + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_Reg, RISCV_X0}, + {AliasPatternCond_K_Custom, 3}, + // (BLT GPR:$rs, X0, simm13_lsb0:$offset) - 46 + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_Reg, RISCV_X0}, + {AliasPatternCond_K_Custom, 3}, + // (BLT X0, GPR:$rs, simm13_lsb0:$offset) - 49 + {AliasPatternCond_K_Reg, RISCV_X0}, + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_Custom, 3}, + // (BNE GPR:$rs, X0, simm13_lsb0:$offset) - 52 + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_Reg, RISCV_X0}, + {AliasPatternCond_K_Custom, 3}, + // (CSRRC X0, csr_sysreg:$csr, GPR:$rs) - 55 + {AliasPatternCond_K_Reg, RISCV_X0}, + {AliasPatternCond_K_Ignore, 0}, + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + // (CSRRCI X0, csr_sysreg:$csr, uimm5:$imm) - 58 + {AliasPatternCond_K_Reg, RISCV_X0}, + {AliasPatternCond_K_Ignore, 0}, + // (CSRRS GPR:$rd, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1 }, X0) - 60 + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_Imm, (uint32_t)3}, + {AliasPatternCond_K_Reg, RISCV_X0}, + {AliasPatternCond_K_Feature, RISCV_FeatureStdExtF}, + // (CSRRS GPR:$rd, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0 }, X0) - 64 + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_Imm, (uint32_t)2}, + {AliasPatternCond_K_Reg, RISCV_X0}, + {AliasPatternCond_K_Feature, RISCV_FeatureStdExtF}, + // (CSRRS GPR:$rd, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 }, X0) - 68 + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_Imm, (uint32_t)1}, + {AliasPatternCond_K_Reg, RISCV_X0}, + {AliasPatternCond_K_Feature, RISCV_FeatureStdExtF}, + // (CSRRS GPR:$rd, { 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0 }, X0) - 72 + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_Imm, (uint32_t)3074}, + {AliasPatternCond_K_Reg, RISCV_X0}, + // (CSRRS GPR:$rd, { 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, X0) - 75 + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_Imm, (uint32_t)3072}, + {AliasPatternCond_K_Reg, RISCV_X0}, + // (CSRRS GPR:$rd, { 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 }, X0) - 78 + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_Imm, (uint32_t)3073}, + {AliasPatternCond_K_Reg, RISCV_X0}, + // (CSRRS GPR:$rd, { 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0 }, X0) - 81 + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_Imm, (uint32_t)3202}, + {AliasPatternCond_K_Reg, RISCV_X0}, + {AliasPatternCond_K_NegFeature, RISCV_Feature64Bit}, + // (CSRRS GPR:$rd, { 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0 }, X0) - 85 + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_Imm, (uint32_t)3200}, + {AliasPatternCond_K_Reg, RISCV_X0}, + {AliasPatternCond_K_NegFeature, RISCV_Feature64Bit}, + // (CSRRS GPR:$rd, { 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1 }, X0) - 89 + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_Imm, (uint32_t)3201}, + {AliasPatternCond_K_Reg, RISCV_X0}, + {AliasPatternCond_K_NegFeature, RISCV_Feature64Bit}, + // (CSRRS GPR:$rd, csr_sysreg:$csr, X0) - 93 + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_Ignore, 0}, + {AliasPatternCond_K_Reg, RISCV_X0}, + // (CSRRS X0, csr_sysreg:$csr, GPR:$rs) - 96 + {AliasPatternCond_K_Reg, RISCV_X0}, + {AliasPatternCond_K_Ignore, 0}, + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + // (CSRRSI X0, csr_sysreg:$csr, uimm5:$imm) - 99 + {AliasPatternCond_K_Reg, RISCV_X0}, + {AliasPatternCond_K_Ignore, 0}, + // (CSRRW X0, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1 }, GPR:$rs) - 101 + {AliasPatternCond_K_Reg, RISCV_X0}, + {AliasPatternCond_K_Imm, (uint32_t)3}, + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_Feature, RISCV_FeatureStdExtF}, + // (CSRRW X0, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0 }, GPR:$rs) - 105 + {AliasPatternCond_K_Reg, RISCV_X0}, + {AliasPatternCond_K_Imm, (uint32_t)2}, + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_Feature, RISCV_FeatureStdExtF}, + // (CSRRW X0, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 }, GPR:$rs) - 109 + {AliasPatternCond_K_Reg, RISCV_X0}, + {AliasPatternCond_K_Imm, (uint32_t)1}, + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_Feature, RISCV_FeatureStdExtF}, + // (CSRRW X0, csr_sysreg:$csr, GPR:$rs) - 113 + {AliasPatternCond_K_Reg, RISCV_X0}, + {AliasPatternCond_K_Ignore, 0}, + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + // (CSRRW GPR:$rd, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1 }, GPR:$rs) - 116 + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_Imm, (uint32_t)3}, + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_Feature, RISCV_FeatureStdExtF}, + // (CSRRW GPR:$rd, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0 }, GPR:$rs) - 120 + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_Imm, (uint32_t)2}, + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_Feature, RISCV_FeatureStdExtF}, + // (CSRRW GPR:$rd, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 }, GPR:$rs) - 124 + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_Imm, (uint32_t)1}, + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_Feature, RISCV_FeatureStdExtF}, + // (CSRRWI X0, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0 }, uimm5:$imm) - 128 + {AliasPatternCond_K_Reg, RISCV_X0}, + {AliasPatternCond_K_Imm, (uint32_t)2}, + {AliasPatternCond_K_Feature, RISCV_FeatureStdExtF}, + // (CSRRWI X0, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 }, uimm5:$imm) - 131 + {AliasPatternCond_K_Reg, RISCV_X0}, + {AliasPatternCond_K_Imm, (uint32_t)1}, + {AliasPatternCond_K_Feature, RISCV_FeatureStdExtF}, + // (CSRRWI X0, csr_sysreg:$csr, uimm5:$imm) - 134 + {AliasPatternCond_K_Reg, RISCV_X0}, + {AliasPatternCond_K_Ignore, 0}, + // (CSRRWI GPR:$rd, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0 }, uimm5:$imm) - 136 + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_Imm, (uint32_t)2}, + {AliasPatternCond_K_Feature, RISCV_FeatureStdExtF}, + // (CSRRWI GPR:$rd, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 }, uimm5:$imm) - 139 + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_Imm, (uint32_t)1}, + {AliasPatternCond_K_Feature, RISCV_FeatureStdExtF}, + // (CV_MULHHSN GPR:$rd1, GPR:$rs1, GPR:$rs2, 0) - 142 + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_Imm, (uint32_t)0}, + {AliasPatternCond_K_Feature, RISCV_FeatureVendorXCVmac}, + {AliasPatternCond_K_NegFeature, RISCV_Feature64Bit}, + // (CV_MULHHUN GPR:$rd1, GPR:$rs1, GPR:$rs2, 0) - 148 + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_Imm, (uint32_t)0}, + {AliasPatternCond_K_Feature, RISCV_FeatureVendorXCVmac}, + {AliasPatternCond_K_NegFeature, RISCV_Feature64Bit}, + // (CV_MULSN GPR:$rd1, GPR:$rs1, GPR:$rs2, 0) - 154 + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_Imm, (uint32_t)0}, + {AliasPatternCond_K_Feature, RISCV_FeatureVendorXCVmac}, + {AliasPatternCond_K_NegFeature, RISCV_Feature64Bit}, + // (CV_MULUN GPR:$rd1, GPR:$rs1, GPR:$rs2, 0) - 160 + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_Imm, (uint32_t)0}, + {AliasPatternCond_K_Feature, RISCV_FeatureVendorXCVmac}, + {AliasPatternCond_K_NegFeature, RISCV_Feature64Bit}, + // (C_ADD_HINT X0, X2) - 166 + {AliasPatternCond_K_Reg, RISCV_X0}, + {AliasPatternCond_K_Ignore, 0}, + {AliasPatternCond_K_Reg, RISCV_X2}, + {AliasPatternCond_K_Feature, RISCV_FeatureStdExtC}, + {AliasPatternCond_K_NegFeature, RISCV_FeatureNoRVCHints}, + {AliasPatternCond_K_Feature, RISCV_FeatureStdExtZihintntl}, + // (C_ADD_HINT X0, X3) - 172 + {AliasPatternCond_K_Reg, RISCV_X0}, + {AliasPatternCond_K_Ignore, 0}, + {AliasPatternCond_K_Reg, RISCV_X3}, + {AliasPatternCond_K_Feature, RISCV_FeatureStdExtC}, + {AliasPatternCond_K_NegFeature, RISCV_FeatureNoRVCHints}, + {AliasPatternCond_K_Feature, RISCV_FeatureStdExtZihintntl}, + // (C_ADD_HINT X0, X4) - 178 + {AliasPatternCond_K_Reg, RISCV_X0}, + {AliasPatternCond_K_Ignore, 0}, + {AliasPatternCond_K_Reg, RISCV_X4}, + {AliasPatternCond_K_Feature, RISCV_FeatureStdExtC}, + {AliasPatternCond_K_NegFeature, RISCV_FeatureNoRVCHints}, + {AliasPatternCond_K_Feature, RISCV_FeatureStdExtZihintntl}, + // (C_ADD_HINT X0, X5) - 184 + {AliasPatternCond_K_Reg, RISCV_X0}, + {AliasPatternCond_K_Ignore, 0}, + {AliasPatternCond_K_Reg, RISCV_X5}, + {AliasPatternCond_K_Feature, RISCV_FeatureStdExtC}, + {AliasPatternCond_K_NegFeature, RISCV_FeatureNoRVCHints}, + {AliasPatternCond_K_Feature, RISCV_FeatureStdExtZihintntl}, + // (FENCE 15, 15) - 190 + {AliasPatternCond_K_Imm, (uint32_t)15}, + {AliasPatternCond_K_Imm, (uint32_t)15}, + // (FENCE 1, 0) - 192 + {AliasPatternCond_K_Imm, (uint32_t)1}, + {AliasPatternCond_K_Imm, (uint32_t)0}, + {AliasPatternCond_K_Feature, RISCV_FeatureStdExtZihintpause}, + // (FSGNJN_D FPR64:$rd, FPR64:$rs, FPR64:$rs) - 195 + {AliasPatternCond_K_RegClass, RISCV_FPR64RegClassID}, + {AliasPatternCond_K_RegClass, RISCV_FPR64RegClassID}, + {AliasPatternCond_K_TiedReg, 1}, + {AliasPatternCond_K_Feature, RISCV_FeatureStdExtD}, + // (FSGNJN_D_IN32X FPR64IN32X:$rd, FPR64IN32X:$rs, FPR64IN32X:$rs) - 199 + {AliasPatternCond_K_RegClass, RISCV_GPRPairRegClassID}, + {AliasPatternCond_K_RegClass, RISCV_GPRPairRegClassID}, + {AliasPatternCond_K_TiedReg, 1}, + {AliasPatternCond_K_Feature, RISCV_FeatureStdExtZdinx}, + {AliasPatternCond_K_NegFeature, RISCV_Feature64Bit}, + // (FSGNJN_D_INX FPR64INX:$rd, FPR64INX:$rs, FPR64INX:$rs) - 204 + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_TiedReg, 1}, + {AliasPatternCond_K_Feature, RISCV_FeatureStdExtZdinx}, + {AliasPatternCond_K_Feature, RISCV_Feature64Bit}, + // (FSGNJN_H FPR16:$rd, FPR16:$rs, FPR16:$rs) - 209 + {AliasPatternCond_K_RegClass, RISCV_FPR16RegClassID}, + {AliasPatternCond_K_RegClass, RISCV_FPR16RegClassID}, + {AliasPatternCond_K_TiedReg, 1}, + {AliasPatternCond_K_Feature, RISCV_FeatureStdExtZfh}, + // (FSGNJN_H_INX FPR16INX:$rd, FPR16INX:$rs, FPR16INX:$rs) - 213 + {AliasPatternCond_K_RegClass, RISCV_GPRF16RegClassID}, + {AliasPatternCond_K_RegClass, RISCV_GPRF16RegClassID}, + {AliasPatternCond_K_TiedReg, 1}, + {AliasPatternCond_K_Feature, RISCV_FeatureStdExtZhinx}, + // (FSGNJN_S FPR32:$rd, FPR32:$rs, FPR32:$rs) - 217 + {AliasPatternCond_K_RegClass, RISCV_FPR32RegClassID}, + {AliasPatternCond_K_RegClass, RISCV_FPR32RegClassID}, + {AliasPatternCond_K_TiedReg, 1}, + {AliasPatternCond_K_Feature, RISCV_FeatureStdExtF}, + // (FSGNJN_S_INX FPR32INX:$rd, FPR32INX:$rs, FPR32INX:$rs) - 221 + {AliasPatternCond_K_RegClass, RISCV_GPRF32RegClassID}, + {AliasPatternCond_K_RegClass, RISCV_GPRF32RegClassID}, + {AliasPatternCond_K_TiedReg, 1}, + {AliasPatternCond_K_Feature, RISCV_FeatureStdExtZfinx}, + // (FSGNJX_D FPR64:$rd, FPR64:$rs, FPR64:$rs) - 225 + {AliasPatternCond_K_RegClass, RISCV_FPR64RegClassID}, + {AliasPatternCond_K_RegClass, RISCV_FPR64RegClassID}, + {AliasPatternCond_K_TiedReg, 1}, + {AliasPatternCond_K_Feature, RISCV_FeatureStdExtD}, + // (FSGNJX_D_IN32X FPR64IN32X:$rd, FPR64IN32X:$rs, FPR64IN32X:$rs) - 229 + {AliasPatternCond_K_RegClass, RISCV_GPRPairRegClassID}, + {AliasPatternCond_K_RegClass, RISCV_GPRPairRegClassID}, + {AliasPatternCond_K_TiedReg, 1}, + {AliasPatternCond_K_Feature, RISCV_FeatureStdExtZdinx}, + {AliasPatternCond_K_NegFeature, RISCV_Feature64Bit}, + // (FSGNJX_D_INX FPR64INX:$rd, FPR64INX:$rs, FPR64INX:$rs) - 234 + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_TiedReg, 1}, + {AliasPatternCond_K_Feature, RISCV_FeatureStdExtZdinx}, + {AliasPatternCond_K_Feature, RISCV_Feature64Bit}, + // (FSGNJX_H FPR16:$rd, FPR16:$rs, FPR16:$rs) - 239 + {AliasPatternCond_K_RegClass, RISCV_FPR16RegClassID}, + {AliasPatternCond_K_RegClass, RISCV_FPR16RegClassID}, + {AliasPatternCond_K_TiedReg, 1}, + {AliasPatternCond_K_Feature, RISCV_FeatureStdExtZfh}, + // (FSGNJX_H_INX FPR16INX:$rd, FPR16INX:$rs, FPR16INX:$rs) - 243 + {AliasPatternCond_K_RegClass, RISCV_GPRF16RegClassID}, + {AliasPatternCond_K_RegClass, RISCV_GPRF16RegClassID}, + {AliasPatternCond_K_TiedReg, 1}, + {AliasPatternCond_K_Feature, RISCV_FeatureStdExtZhinx}, + // (FSGNJX_S FPR32:$rd, FPR32:$rs, FPR32:$rs) - 247 + {AliasPatternCond_K_RegClass, RISCV_FPR32RegClassID}, + {AliasPatternCond_K_RegClass, RISCV_FPR32RegClassID}, + {AliasPatternCond_K_TiedReg, 1}, + {AliasPatternCond_K_Feature, RISCV_FeatureStdExtF}, + // (FSGNJX_S_INX FPR32INX:$rd, FPR32INX:$rs, FPR32INX:$rs) - 251 + {AliasPatternCond_K_RegClass, RISCV_GPRF32RegClassID}, + {AliasPatternCond_K_RegClass, RISCV_GPRF32RegClassID}, + {AliasPatternCond_K_TiedReg, 1}, + {AliasPatternCond_K_Feature, RISCV_FeatureStdExtZfinx}, + // (FSGNJ_D FPR64:$rd, FPR64:$rs, FPR64:$rs) - 255 + {AliasPatternCond_K_RegClass, RISCV_FPR64RegClassID}, + {AliasPatternCond_K_RegClass, RISCV_FPR64RegClassID}, + {AliasPatternCond_K_TiedReg, 1}, + {AliasPatternCond_K_Feature, RISCV_FeatureStdExtD}, + // (FSGNJ_H FPR16:$rd, FPR16:$rs, FPR16:$rs) - 259 + {AliasPatternCond_K_RegClass, RISCV_FPR16RegClassID}, + {AliasPatternCond_K_RegClass, RISCV_FPR16RegClassID}, + {AliasPatternCond_K_TiedReg, 1}, + {AliasPatternCond_K_Feature, RISCV_FeatureStdExtZfh}, + // (FSGNJ_H_INX FPR16INX:$rd, FPR16INX:$rs, FPR16INX:$rs) - 263 + {AliasPatternCond_K_RegClass, RISCV_GPRF16RegClassID}, + {AliasPatternCond_K_RegClass, RISCV_GPRF16RegClassID}, + {AliasPatternCond_K_TiedReg, 1}, + {AliasPatternCond_K_Feature, RISCV_FeatureStdExtZhinx}, + // (FSGNJ_S FPR32:$rd, FPR32:$rs, FPR32:$rs) - 267 + {AliasPatternCond_K_RegClass, RISCV_FPR32RegClassID}, + {AliasPatternCond_K_RegClass, RISCV_FPR32RegClassID}, + {AliasPatternCond_K_TiedReg, 1}, + {AliasPatternCond_K_Feature, RISCV_FeatureStdExtF}, + // (HFENCE_GVMA X0, X0) - 271 + {AliasPatternCond_K_Reg, RISCV_X0}, + {AliasPatternCond_K_Reg, RISCV_X0}, + // (HFENCE_GVMA GPR:$rs, X0) - 273 + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_Reg, RISCV_X0}, + // (HFENCE_VVMA X0, X0) - 275 + {AliasPatternCond_K_Reg, RISCV_X0}, + {AliasPatternCond_K_Reg, RISCV_X0}, + // (HFENCE_VVMA GPR:$rs, X0) - 277 + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_Reg, RISCV_X0}, + // (JAL X0, simm21_lsb0_jal:$offset) - 279 + {AliasPatternCond_K_Reg, RISCV_X0}, + {AliasPatternCond_K_Custom, 4}, + // (JAL X1, simm21_lsb0_jal:$offset) - 281 + {AliasPatternCond_K_Reg, RISCV_X1}, + {AliasPatternCond_K_Custom, 4}, + // (JALR X0, X1, 0) - 283 + {AliasPatternCond_K_Reg, RISCV_X0}, + {AliasPatternCond_K_Reg, RISCV_X1}, + {AliasPatternCond_K_Imm, (uint32_t)0}, + // (JALR X0, GPR:$rs, 0) - 286 + {AliasPatternCond_K_Reg, RISCV_X0}, + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_Imm, (uint32_t)0}, + // (JALR X1, GPR:$rs, 0) - 289 + {AliasPatternCond_K_Reg, RISCV_X1}, + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_Imm, (uint32_t)0}, + // (JALR GPR:$rd, GPR:$rs, 0) - 292 + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_Imm, (uint32_t)0}, + // (JALR X0, GPR:$rs, simm12:$offset) - 295 + {AliasPatternCond_K_Reg, RISCV_X0}, + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_Custom, 1}, + // (JALR X1, GPR:$rs, simm12:$offset) - 298 + {AliasPatternCond_K_Reg, RISCV_X1}, + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_Custom, 1}, + // (SFENCE_VMA X0, X0) - 301 + {AliasPatternCond_K_Reg, RISCV_X0}, + {AliasPatternCond_K_Reg, RISCV_X0}, + // (SFENCE_VMA GPR:$rs, X0) - 303 + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_Reg, RISCV_X0}, + // (SLT GPR:$rd, GPR:$rs, X0) - 305 + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_Reg, RISCV_X0}, + // (SLT GPR:$rd, X0, GPR:$rs) - 308 + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_Reg, RISCV_X0}, + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + // (SLTIU GPR:$rd, GPR:$rs, 1) - 311 + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_Imm, (uint32_t)1}, + // (SLTU GPR:$rd, X0, GPR:$rs) - 314 + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_Reg, RISCV_X0}, + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + // (SUB GPR:$rd, X0, GPR:$rs) - 317 + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_Reg, RISCV_X0}, + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + // (SUBW GPR:$rd, X0, GPR:$rs) - 320 + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_Reg, RISCV_X0}, + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_Feature, RISCV_Feature64Bit}, + // (VFSGNJN_VV VR:$vd, VR:$vs, VR:$vs, VMaskOp:$vm) - 324 + {AliasPatternCond_K_RegClass, RISCV_VRRegClassID}, + {AliasPatternCond_K_RegClass, RISCV_VRRegClassID}, + {AliasPatternCond_K_TiedReg, 1}, + {AliasPatternCond_K_RegClass, RISCV_VMV0RegClassID}, + {AliasPatternCond_K_OrFeature, RISCV_FeatureStdExtZve32f}, + {AliasPatternCond_K_EndOrFeatures, 0}, + // (VFSGNJN_VV VR:$vd, VR:$vs, VR:$vs, zero_reg) - 330 + {AliasPatternCond_K_RegClass, RISCV_VRRegClassID}, + {AliasPatternCond_K_RegClass, RISCV_VRRegClassID}, + {AliasPatternCond_K_TiedReg, 1}, + {AliasPatternCond_K_Reg, RISCV_NoRegister}, + {AliasPatternCond_K_OrFeature, RISCV_FeatureStdExtZve32f}, + {AliasPatternCond_K_EndOrFeatures, 0}, + // (VFSGNJX_VV VR:$vd, VR:$vs, VR:$vs, VMaskOp:$vm) - 336 + {AliasPatternCond_K_RegClass, RISCV_VRRegClassID}, + {AliasPatternCond_K_RegClass, RISCV_VRRegClassID}, + {AliasPatternCond_K_TiedReg, 1}, + {AliasPatternCond_K_RegClass, RISCV_VMV0RegClassID}, + {AliasPatternCond_K_OrFeature, RISCV_FeatureStdExtZve32f}, + {AliasPatternCond_K_EndOrFeatures, 0}, + // (VFSGNJX_VV VR:$vd, VR:$vs, VR:$vs, zero_reg) - 342 + {AliasPatternCond_K_RegClass, RISCV_VRRegClassID}, + {AliasPatternCond_K_RegClass, RISCV_VRRegClassID}, + {AliasPatternCond_K_TiedReg, 1}, + {AliasPatternCond_K_Reg, RISCV_NoRegister}, + {AliasPatternCond_K_OrFeature, RISCV_FeatureStdExtZve32f}, + {AliasPatternCond_K_EndOrFeatures, 0}, + // (VL1RE8_V VR:$vd, GPR:$rs1) - 348 + {AliasPatternCond_K_RegClass, RISCV_VRRegClassID}, + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_OrFeature, RISCV_FeatureStdExtZve32x}, + {AliasPatternCond_K_EndOrFeatures, 0}, + // (VL2RE8_V VRM2:$vd, GPR:$rs1) - 352 + {AliasPatternCond_K_RegClass, RISCV_VRM2RegClassID}, + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_OrFeature, RISCV_FeatureStdExtZve32x}, + {AliasPatternCond_K_EndOrFeatures, 0}, + // (VL4RE8_V VRM4:$vd, GPR:$rs1) - 356 + {AliasPatternCond_K_RegClass, RISCV_VRM4RegClassID}, + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_OrFeature, RISCV_FeatureStdExtZve32x}, + {AliasPatternCond_K_EndOrFeatures, 0}, + // (VL8RE8_V VRM8:$vd, GPR:$rs1) - 360 + {AliasPatternCond_K_RegClass, RISCV_VRM8RegClassID}, + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_OrFeature, RISCV_FeatureStdExtZve32x}, + {AliasPatternCond_K_EndOrFeatures, 0}, + // (VMAND_MM VR:$vd, VR:$vs, VR:$vs) - 364 + {AliasPatternCond_K_RegClass, RISCV_VRRegClassID}, + {AliasPatternCond_K_RegClass, RISCV_VRRegClassID}, + {AliasPatternCond_K_TiedReg, 1}, + {AliasPatternCond_K_OrFeature, RISCV_FeatureStdExtZve32x}, + {AliasPatternCond_K_EndOrFeatures, 0}, + // (VMNAND_MM VR:$vd, VR:$vs, VR:$vs) - 369 + {AliasPatternCond_K_RegClass, RISCV_VRRegClassID}, + {AliasPatternCond_K_RegClass, RISCV_VRRegClassID}, + {AliasPatternCond_K_TiedReg, 1}, + {AliasPatternCond_K_OrFeature, RISCV_FeatureStdExtZve32x}, + {AliasPatternCond_K_EndOrFeatures, 0}, + // (VMXNOR_MM VR:$vd, VR:$vd, VR:$vd) - 374 + {AliasPatternCond_K_RegClass, RISCV_VRRegClassID}, + {AliasPatternCond_K_TiedReg, 0}, + {AliasPatternCond_K_TiedReg, 0}, + {AliasPatternCond_K_OrFeature, RISCV_FeatureStdExtZve32x}, + {AliasPatternCond_K_EndOrFeatures, 0}, + // (VMXOR_MM VR:$vd, VR:$vd, VR:$vd) - 379 + {AliasPatternCond_K_RegClass, RISCV_VRRegClassID}, + {AliasPatternCond_K_TiedReg, 0}, + {AliasPatternCond_K_TiedReg, 0}, + {AliasPatternCond_K_OrFeature, RISCV_FeatureStdExtZve32x}, + {AliasPatternCond_K_EndOrFeatures, 0}, + // (VNSRL_WX VR:$vd, VR:$vs, X0, VMaskOp:$vm) - 384 + {AliasPatternCond_K_RegClass, RISCV_VRRegClassID}, + {AliasPatternCond_K_RegClass, RISCV_VRRegClassID}, + {AliasPatternCond_K_Reg, RISCV_X0}, + {AliasPatternCond_K_RegClass, RISCV_VMV0RegClassID}, + {AliasPatternCond_K_OrFeature, RISCV_FeatureStdExtZve32x}, + {AliasPatternCond_K_EndOrFeatures, 0}, + // (VNSRL_WX VR:$vd, VR:$vs, X0, zero_reg) - 390 + {AliasPatternCond_K_RegClass, RISCV_VRRegClassID}, + {AliasPatternCond_K_RegClass, RISCV_VRRegClassID}, + {AliasPatternCond_K_Reg, RISCV_X0}, + {AliasPatternCond_K_Reg, RISCV_NoRegister}, + {AliasPatternCond_K_OrFeature, RISCV_FeatureStdExtZve32x}, + {AliasPatternCond_K_EndOrFeatures, 0}, + // (VRSUB_VX VR:$vd, VR:$vs, X0, VMaskOp:$vm) - 396 + {AliasPatternCond_K_RegClass, RISCV_VRRegClassID}, + {AliasPatternCond_K_RegClass, RISCV_VRRegClassID}, + {AliasPatternCond_K_Reg, RISCV_X0}, + {AliasPatternCond_K_RegClass, RISCV_VMV0RegClassID}, + {AliasPatternCond_K_OrFeature, RISCV_FeatureStdExtZve32x}, + {AliasPatternCond_K_EndOrFeatures, 0}, + // (VRSUB_VX VR:$vd, VR:$vs, X0, zero_reg) - 402 + {AliasPatternCond_K_RegClass, RISCV_VRRegClassID}, + {AliasPatternCond_K_RegClass, RISCV_VRRegClassID}, + {AliasPatternCond_K_Reg, RISCV_X0}, + {AliasPatternCond_K_Reg, RISCV_NoRegister}, + {AliasPatternCond_K_OrFeature, RISCV_FeatureStdExtZve32x}, + {AliasPatternCond_K_EndOrFeatures, 0}, + // (VWADDU_VX VR:$vd, VR:$vs, X0, VMaskOp:$vm) - 408 + {AliasPatternCond_K_RegClass, RISCV_VRRegClassID}, + {AliasPatternCond_K_RegClass, RISCV_VRRegClassID}, + {AliasPatternCond_K_Reg, RISCV_X0}, + {AliasPatternCond_K_RegClass, RISCV_VMV0RegClassID}, + {AliasPatternCond_K_OrFeature, RISCV_FeatureStdExtZve32x}, + {AliasPatternCond_K_EndOrFeatures, 0}, + // (VWADDU_VX VR:$vd, VR:$vs, X0, zero_reg) - 414 + {AliasPatternCond_K_RegClass, RISCV_VRRegClassID}, + {AliasPatternCond_K_RegClass, RISCV_VRRegClassID}, + {AliasPatternCond_K_Reg, RISCV_X0}, + {AliasPatternCond_K_Reg, RISCV_NoRegister}, + {AliasPatternCond_K_OrFeature, RISCV_FeatureStdExtZve32x}, + {AliasPatternCond_K_EndOrFeatures, 0}, + // (VWADD_VX VR:$vd, VR:$vs, X0, VMaskOp:$vm) - 420 + {AliasPatternCond_K_RegClass, RISCV_VRRegClassID}, + {AliasPatternCond_K_RegClass, RISCV_VRRegClassID}, + {AliasPatternCond_K_Reg, RISCV_X0}, + {AliasPatternCond_K_RegClass, RISCV_VMV0RegClassID}, + {AliasPatternCond_K_OrFeature, RISCV_FeatureStdExtZve32x}, + {AliasPatternCond_K_EndOrFeatures, 0}, + // (VWADD_VX VR:$vd, VR:$vs, X0, zero_reg) - 426 + {AliasPatternCond_K_RegClass, RISCV_VRRegClassID}, + {AliasPatternCond_K_RegClass, RISCV_VRRegClassID}, + {AliasPatternCond_K_Reg, RISCV_X0}, + {AliasPatternCond_K_Reg, RISCV_NoRegister}, + {AliasPatternCond_K_OrFeature, RISCV_FeatureStdExtZve32x}, + {AliasPatternCond_K_EndOrFeatures, 0}, + // (VXOR_VI VR:$vd, VR:$vs, -1, VMaskOp:$vm) - 432 + {AliasPatternCond_K_RegClass, RISCV_VRRegClassID}, + {AliasPatternCond_K_RegClass, RISCV_VRRegClassID}, + {AliasPatternCond_K_Imm, (uint32_t)-1}, + {AliasPatternCond_K_RegClass, RISCV_VMV0RegClassID}, + {AliasPatternCond_K_OrFeature, RISCV_FeatureStdExtZve32x}, + {AliasPatternCond_K_EndOrFeatures, 0}, + // (VXOR_VI VR:$vd, VR:$vs, -1, zero_reg) - 438 + {AliasPatternCond_K_RegClass, RISCV_VRRegClassID}, + {AliasPatternCond_K_RegClass, RISCV_VRRegClassID}, + {AliasPatternCond_K_Imm, (uint32_t)-1}, + {AliasPatternCond_K_Reg, RISCV_NoRegister}, + {AliasPatternCond_K_OrFeature, RISCV_FeatureStdExtZve32x}, + {AliasPatternCond_K_EndOrFeatures, 0}, + // (XORI GPR:$rd, GPR:$rs, -1) - 444 + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_RegClass, RISCV_GPRRegClassID}, + {AliasPatternCond_K_Imm, (uint32_t)-1}, + {0}, }; - AsmStringLen = strlen(AsmString); - if (ASMSTRING_CONTAIN_SIZE - 1 < AsmStringLen) - tmpString = cs_strdup(AsmString); - else - tmpString = memcpy(tmpString, AsmString, 1 + AsmStringLen); + static const char AsmStrings[] = + /* 0 */ "ntl.p1\0" + /* 7 */ "ntl.pall\0" + /* 16 */ "ntl.s1\0" + /* 23 */ "ntl.all\0" + /* 31 */ "nop\0" + /* 35 */ "li $\x01, $\x03\0" + /* 45 */ "mv $\x01, $\x02\0" + /* 55 */ "sext.w $\x01, $\x02\0" + /* 69 */ "zext.w $\x01, $\x02\0" + /* 83 */ "lpad $\x02\0" + /* 91 */ "beqz $\x01, $\xFF\x03\x01\0" + /* 105 */ "blez $\x02, $\xFF\x03\x01\0" + /* 119 */ "bgez $\x01, $\xFF\x03\x01\0" + /* 133 */ "bltz $\x01, $\xFF\x03\x01\0" + /* 147 */ "bgtz $\x02, $\xFF\x03\x01\0" + /* 161 */ "bnez $\x01, $\xFF\x03\x01\0" + /* 175 */ "csrc $\xFF\x02\x02, $\x03\0" + /* 189 */ "csrci $\xFF\x02\x02, $\x03\0" + /* 204 */ "frcsr $\x01\0" + /* 213 */ "frrm $\x01\0" + /* 221 */ "frflags $\x01\0" + /* 232 */ "rdinstret $\x01\0" + /* 245 */ "rdcycle $\x01\0" + /* 256 */ "rdtime $\x01\0" + /* 266 */ "rdinstreth $\x01\0" + /* 280 */ "rdcycleh $\x01\0" + /* 292 */ "rdtimeh $\x01\0" + /* 303 */ "csrr $\x01, $\xFF\x02\x02\0" + /* 317 */ "csrs $\xFF\x02\x02, $\x03\0" + /* 331 */ "csrsi $\xFF\x02\x02, $\x03\0" + /* 346 */ "fscsr $\x03\0" + /* 355 */ "fsrm $\x03\0" + /* 363 */ "fsflags $\x03\0" + /* 374 */ "csrw $\xFF\x02\x02, $\x03\0" + /* 388 */ "fscsr $\x01, $\x03\0" + /* 401 */ "fsrm $\x01, $\x03\0" + /* 413 */ "fsflags $\x01, $\x03\0" + /* 428 */ "fsrmi $\x03\0" + /* 437 */ "fsflagsi $\x03\0" + /* 449 */ "csrwi $\xFF\x02\x02, $\x03\0" + /* 464 */ "fsrmi $\x01, $\x03\0" + /* 477 */ "fsflagsi $\x01, $\x03\0" + /* 493 */ "cv.mulhhs $\x01, $\x02, $\x03\0" + /* 514 */ "cv.mulhhu $\x01, $\x02, $\x03\0" + /* 535 */ "cv.muls $\x01, $\x02, $\x03\0" + /* 554 */ "cv.mulu $\x01, $\x02, $\x03\0" + /* 573 */ "c.ntl.p1\0" + /* 582 */ "c.ntl.pall\0" + /* 593 */ "c.ntl.s1\0" + /* 602 */ "c.ntl.all\0" + /* 612 */ "fence\0" + /* 618 */ "pause\0" + /* 624 */ "fneg.d $\x01, $\x02\0" + /* 638 */ "fneg.h $\x01, $\x02\0" + /* 652 */ "fneg.s $\x01, $\x02\0" + /* 666 */ "fabs.d $\x01, $\x02\0" + /* 680 */ "fabs.h $\x01, $\x02\0" + /* 694 */ "fabs.s $\x01, $\x02\0" + /* 708 */ "fmv.d $\x01, $\x02\0" + /* 721 */ "fmv.h $\x01, $\x02\0" + /* 734 */ "fmv.s $\x01, $\x02\0" + /* 747 */ "hfence.gvma\0" + /* 759 */ "hfence.gvma $\x01\0" + /* 774 */ "hfence.vvma\0" + /* 786 */ "hfence.vvma $\x01\0" + /* 801 */ "j $\xFF\x02\x01\0" + /* 808 */ "jal $\xFF\x02\x01\0" + /* 817 */ "ret\0" + /* 821 */ "jr $\x02\0" + /* 827 */ "jalr $\x02\0" + /* 835 */ "jalr $\x01, $\x02\0" + /* 847 */ "jr $\x03($\x02)\0" + /* 857 */ "jalr $\x03($\x02)\0" + /* 869 */ "sfence.vma\0" + /* 880 */ "sfence.vma $\x01\0" + /* 894 */ "sltz $\x01, $\x02\0" + /* 906 */ "sgtz $\x01, $\x03\0" + /* 918 */ "seqz $\x01, $\x02\0" + /* 930 */ "snez $\x01, $\x03\0" + /* 942 */ "neg $\x01, $\x03\0" + /* 953 */ "negw $\x01, $\x03\0" + /* 965 */ "vfneg.v $\x01, $\x02$\xFF\x04\x03\0" + /* 984 */ "vfneg.v $\x01, $\x02\0" + /* 999 */ "vfabs.v $\x01, $\x02$\xFF\x04\x03\0" + /* 1018 */ "vfabs.v $\x01, $\x02\0" + /* 1033 */ "vl1r.v $\x01, ($\x02)\0" + /* 1049 */ "vl2r.v $\x01, ($\x02)\0" + /* 1065 */ "vl4r.v $\x01, ($\x02)\0" + /* 1081 */ "vl8r.v $\x01, ($\x02)\0" + /* 1097 */ "vmmv.m $\x01, $\x02\0" + /* 1111 */ "vmnot.m $\x01, $\x02\0" + /* 1126 */ "vmset.m $\x01\0" + /* 1137 */ "vmclr.m $\x01\0" + /* 1148 */ "vncvt.x.x.w $\x01, $\x02$\xFF\x04\x03\0" + /* 1171 */ "vncvt.x.x.w $\x01, $\x02\0" + /* 1190 */ "vneg.v $\x01, $\x02$\xFF\x04\x03\0" + /* 1208 */ "vneg.v $\x01, $\x02\0" + /* 1222 */ "vwcvtu.x.x.v $\x01, $\x02$\xFF\x04\x03\0" + /* 1246 */ "vwcvtu.x.x.v $\x01, $\x02\0" + /* 1266 */ "vwcvt.x.x.v $\x01, $\x02$\xFF\x04\x03\0" + /* 1289 */ "vwcvt.x.x.v $\x01, $\x02\0" + /* 1308 */ "vnot.v $\x01, $\x02$\xFF\x04\x03\0" + /* 1326 */ "vnot.v $\x01, $\x02\0" + /* 1340 */ "not $\x01, $\x02\0" + ; +#ifndef NDEBUG + //static struct SortCheck { + // SortCheck(ArrayRef OpToPatterns) { + // assert(std::is_sorted( + // OpToPatterns.begin(), OpToPatterns.end(), + // [](const PatternsForOpcode &L, const //PatternsForOpcode &R) { + // return L.Opcode < R.Opcode; + // }) && + // "tablegen failed to sort opcode patterns"); + // } + //} sortCheckVar(OpToPatterns); +#endif + + AliasMatchingData M = { + OpToPatterns, + Patterns, + Conds, + AsmStrings, + RISCVInstPrinterValidateMCOperand, + }; + const char *AsmString = matchAliasPatterns(MI, &M); + if (!AsmString) return false; + + unsigned I = 0; while (AsmString[I] != ' ' && AsmString[I] != '\t' && AsmString[I] != '$' && AsmString[I] != '\0') ++I; - tmpString[I] = 0; - SStream_concat0(OS, tmpString); - if (ASMSTRING_CONTAIN_SIZE - 1 < AsmStringLen) - /* Free the possible cs_strdup() memory. PR#1424. */ - cs_mem_free(tmpString); -#undef ASMSTRING_CONTAIN_SIZE - + SStream_concat1(OS, '\t'); + char *substr = malloc(I+1); + memcpy(substr, AsmString, I); + substr[I] = '\0'; + SStream_concat0(OS, substr); + free(substr); if (AsmString[I] != '\0') { if (AsmString[I] == ' ' || AsmString[I] == '\t') { - SStream_concat0(OS, " "); + SStream_concat1(OS, '\t'); ++I; } do { @@ -2600,9 +29495,9 @@ static bool printAliasInstr(MCInst *MI, SStream * OS, void *info) ++I; int OpIdx = AsmString[I++] - 1; int PrintMethodIdx = AsmString[I++] - 1; - printCustomAliasOperand(MI, OpIdx, PrintMethodIdx, OS); + printCustomAliasOperand(MI, Address, OpIdx, PrintMethodIdx, OS); } else - printOperand(MI, (unsigned)(AsmString[I++]) - 1, OS); + printOperand(MI, ((unsigned)AsmString[I++]) - 1, OS); } else { SStream_concat1(OS, AsmString[I++]); } @@ -2610,52 +29505,68 @@ static bool printAliasInstr(MCInst *MI, SStream * OS, void *info) } return true; +#else + return false; +#endif // CAPSTONE_DIET } static void printCustomAliasOperand( - MCInst *MI, unsigned OpIdx, + MCInst *MI, uint64_t Address, unsigned OpIdx, unsigned PrintMethodIdx, SStream *OS) { +#ifndef CAPSTONE_DIET switch (PrintMethodIdx) { default: - CS_ASSERT(0 && "Unknown PrintMethod kind"); + CS_ASSERT_RET(0 && "Unknown PrintMethod kind"); break; case 0: + printBranchOperand(MI, Address, OpIdx, OS); + break; + case 1: printCSRSystemRegister(MI, OpIdx, OS); break; + case 2: + printVMaskReg(MI, OpIdx, OS); + break; } +#endif // CAPSTONE_DIET } -static bool RISCVInstPrinterValidateMCOperand(MCOperand *MCOp, +static bool RISCVInstPrinterValidateMCOperand(const MCOperand *MCOp, unsigned PredicateIndex) { - // TODO: need some constant untils operate the MCOperand, - // but current CAPSTONE doesn't have. - // So, We just return true - return true; - -#if 0 switch (PredicateIndex) { default: - llvm_unreachable("Unknown MCOperandPredicate kind"); - break; + CS_ASSERT_RET_VAL(0 && "Unknown MCOperandPredicate kind", false); + return false; case 1: { - int64_t Imm; - if (MCOp.evaluateAsConstantImm(Imm)) - return isShiftedInt<12, 1>(Imm); - return MCOp.isBareSymbolRef(); + if (MCOperand_isImm(MCOp)) + return isIntN(12, MCOperand_getImm(MCOp)); + return MCOperand_isExpr(MCOp); } case 2: { - int64_t Imm; - if (MCOp.evaluateAsConstantImm(Imm)) - return isShiftedInt<20, 1>(Imm); - return MCOp.isBareSymbolRef(); + if (!MCOperand_isImm(MCOp)) + return false; + return isUIntN(20, MCOperand_getImm(MCOp)); + + } + case 3: { + + if (MCOperand_isImm(MCOp)) + return isShiftedIntN(12,1, MCOperand_getImm(MCOp)); + return MCOperand_isExpr(MCOp); + + } + case 4: { + + if (MCOperand_isImm(MCOp)) + return isShiftedIntN(20, 1, MCOperand_getImm(MCOp)); + return MCOperand_isExpr(MCOp); } } -#endif } #endif // PRINT_ALIAS_INSTR diff --git a/arch/RISCV/RISCVGenCSAliasEnum.inc b/arch/RISCV/RISCVGenCSAliasEnum.inc new file mode 100644 index 0000000000..6fd7161e82 --- /dev/null +++ b/arch/RISCV/RISCVGenCSAliasEnum.inc @@ -0,0 +1,99 @@ +/* Capstone Disassembly Engine, https://www.capstone-engine.org */ +/* By Nguyen Anh Quynh , 2013-2022, */ +/* Rot127 2022-2024 */ +/* Automatically generated file by Capstone's LLVM TableGen Disassembler Backend. */ + +/* LLVM-commit: */ +/* LLVM-tag: */ + +/* Do not edit. */ + +/* Capstone's LLVM TableGen Backends: */ +/* https://github.com/capstone-engine/llvm-capstone */ + + RISCV_INS_ALIAS_NOP, // Real instr.: RISCV_ADDI + RISCV_INS_ALIAS_LI, // Real instr.: RISCV_ADDI + RISCV_INS_ALIAS_MV, // Real instr.: RISCV_ADDI + RISCV_INS_ALIAS_NOT, // Real instr.: RISCV_XORI + RISCV_INS_ALIAS_NEG, // Real instr.: RISCV_SUB + RISCV_INS_ALIAS_NEGW, // Real instr.: RISCV_SUBW + RISCV_INS_ALIAS_SEXT_W, // Real instr.: RISCV_ADDIW + RISCV_INS_ALIAS_SEQZ, // Real instr.: RISCV_SLTIU + RISCV_INS_ALIAS_SNEZ, // Real instr.: RISCV_SLTU + RISCV_INS_ALIAS_SLTZ, // Real instr.: RISCV_SLT + RISCV_INS_ALIAS_SGTZ, // Real instr.: RISCV_SLT + RISCV_INS_ALIAS_BEQZ, // Real instr.: RISCV_BEQ + RISCV_INS_ALIAS_BNEZ, // Real instr.: RISCV_BNE + RISCV_INS_ALIAS_BLEZ, // Real instr.: RISCV_BGE + RISCV_INS_ALIAS_BGEZ, // Real instr.: RISCV_BGE + RISCV_INS_ALIAS_BLTZ, // Real instr.: RISCV_BLT + RISCV_INS_ALIAS_BGTZ, // Real instr.: RISCV_BLT + RISCV_INS_ALIAS_J, // Real instr.: RISCV_JAL + RISCV_INS_ALIAS_JAL, // Real instr.: RISCV_JAL + RISCV_INS_ALIAS_JR, // Real instr.: RISCV_JALR + RISCV_INS_ALIAS_JALR, // Real instr.: RISCV_JALR + RISCV_INS_ALIAS_RET, // Real instr.: RISCV_JALR + RISCV_INS_ALIAS_FENCE, // Real instr.: RISCV_FENCE + RISCV_INS_ALIAS_PAUSE, // Real instr.: RISCV_FENCE + RISCV_INS_ALIAS_RDINSTRET, // Real instr.: RISCV_CSRRS + RISCV_INS_ALIAS_RDCYCLE, // Real instr.: RISCV_CSRRS + RISCV_INS_ALIAS_RDTIME, // Real instr.: RISCV_CSRRS + RISCV_INS_ALIAS_RDINSTRETH, // Real instr.: RISCV_CSRRS + RISCV_INS_ALIAS_RDCYCLEH, // Real instr.: RISCV_CSRRS + RISCV_INS_ALIAS_RDTIMEH, // Real instr.: RISCV_CSRRS + RISCV_INS_ALIAS_CSRR, // Real instr.: RISCV_CSRRS + RISCV_INS_ALIAS_CSRW, // Real instr.: RISCV_CSRRW + RISCV_INS_ALIAS_CSRS, // Real instr.: RISCV_CSRRS + RISCV_INS_ALIAS_CSRC, // Real instr.: RISCV_CSRRC + RISCV_INS_ALIAS_CSRWI, // Real instr.: RISCV_CSRRWI + RISCV_INS_ALIAS_CSRSI, // Real instr.: RISCV_CSRRSI + RISCV_INS_ALIAS_CSRCI, // Real instr.: RISCV_CSRRCI + RISCV_INS_ALIAS_SFENCE_VMA, // Real instr.: RISCV_SFENCE_VMA + RISCV_INS_ALIAS_HFENCE_GVMA, // Real instr.: RISCV_HFENCE_GVMA + RISCV_INS_ALIAS_HFENCE_VVMA, // Real instr.: RISCV_HFENCE_VVMA + RISCV_INS_ALIAS_NTL_P1, // Real instr.: RISCV_ADD + RISCV_INS_ALIAS_NTL_PALL, // Real instr.: RISCV_ADD + RISCV_INS_ALIAS_NTL_S1, // Real instr.: RISCV_ADD + RISCV_INS_ALIAS_NTL_ALL, // Real instr.: RISCV_ADD + RISCV_INS_ALIAS_LPAD, // Real instr.: RISCV_AUIPC + RISCV_INS_ALIAS_FMV_S, // Real instr.: RISCV_FSGNJ_S + RISCV_INS_ALIAS_FABS_S, // Real instr.: RISCV_FSGNJX_S + RISCV_INS_ALIAS_FNEG_S, // Real instr.: RISCV_FSGNJN_S + RISCV_INS_ALIAS_FRCSR, // Real instr.: RISCV_CSRRS + RISCV_INS_ALIAS_FSCSR, // Real instr.: RISCV_CSRRW + RISCV_INS_ALIAS_FRRM, // Real instr.: RISCV_CSRRS + RISCV_INS_ALIAS_FSRM, // Real instr.: RISCV_CSRRW + RISCV_INS_ALIAS_FSRMI, // Real instr.: RISCV_CSRRWI + RISCV_INS_ALIAS_FRFLAGS, // Real instr.: RISCV_CSRRS + RISCV_INS_ALIAS_FSFLAGS, // Real instr.: RISCV_CSRRW + RISCV_INS_ALIAS_FSFLAGSI, // Real instr.: RISCV_CSRRWI + RISCV_INS_ALIAS_FMV_D, // Real instr.: RISCV_FSGNJ_D + RISCV_INS_ALIAS_FABS_D, // Real instr.: RISCV_FSGNJX_D + RISCV_INS_ALIAS_FNEG_D, // Real instr.: RISCV_FSGNJN_D + RISCV_INS_ALIAS_FMV_H, // Real instr.: RISCV_FSGNJ_H + RISCV_INS_ALIAS_FABS_H, // Real instr.: RISCV_FSGNJX_H + RISCV_INS_ALIAS_FNEG_H, // Real instr.: RISCV_FSGNJN_H + RISCV_INS_ALIAS_ZEXT_W, // Real instr.: RISCV_ADD_UW + RISCV_INS_ALIAS_VL1R_V, // Real instr.: RISCV_VL1RE8_V + RISCV_INS_ALIAS_VL2R_V, // Real instr.: RISCV_VL2RE8_V + RISCV_INS_ALIAS_VL4R_V, // Real instr.: RISCV_VL4RE8_V + RISCV_INS_ALIAS_VL8R_V, // Real instr.: RISCV_VL8RE8_V + RISCV_INS_ALIAS_VNEG_V, // Real instr.: RISCV_VRSUB_VX + RISCV_INS_ALIAS_VWCVT_X_X_V, // Real instr.: RISCV_VWADD_VX + RISCV_INS_ALIAS_VWCVTU_X_X_V, // Real instr.: RISCV_VWADDU_VX + RISCV_INS_ALIAS_VNOT_V, // Real instr.: RISCV_VXOR_VI + RISCV_INS_ALIAS_VNCVT_X_X_W, // Real instr.: RISCV_VNSRL_WX + RISCV_INS_ALIAS_VFNEG_V, // Real instr.: RISCV_VFSGNJN_VV + RISCV_INS_ALIAS_VFABS_V, // Real instr.: RISCV_VFSGNJX_VV + RISCV_INS_ALIAS_VMMV_M, // Real instr.: RISCV_VMAND_MM + RISCV_INS_ALIAS_VMCLR_M, // Real instr.: RISCV_VMXOR_MM + RISCV_INS_ALIAS_VMSET_M, // Real instr.: RISCV_VMXNOR_MM + RISCV_INS_ALIAS_VMNOT_M, // Real instr.: RISCV_VMNAND_MM + RISCV_INS_ALIAS_C_NTL_P1, // Real instr.: RISCV_C_ADD_HINT + RISCV_INS_ALIAS_C_NTL_PALL, // Real instr.: RISCV_C_ADD_HINT + RISCV_INS_ALIAS_C_NTL_S1, // Real instr.: RISCV_C_ADD_HINT + RISCV_INS_ALIAS_C_NTL_ALL, // Real instr.: RISCV_C_ADD_HINT + RISCV_INS_ALIAS_CV_MULS, // Real instr.: RISCV_CV_MULSN + RISCV_INS_ALIAS_CV_MULHHS, // Real instr.: RISCV_CV_MULHHSN + RISCV_INS_ALIAS_CV_MULU, // Real instr.: RISCV_CV_MULUN + RISCV_INS_ALIAS_CV_MULHHU, // Real instr.: RISCV_CV_MULHHUN diff --git a/arch/RISCV/RISCVGenCSAliasMnemMap.inc b/arch/RISCV/RISCVGenCSAliasMnemMap.inc new file mode 100644 index 0000000000..db2b485d39 --- /dev/null +++ b/arch/RISCV/RISCVGenCSAliasMnemMap.inc @@ -0,0 +1,99 @@ +/* Capstone Disassembly Engine, https://www.capstone-engine.org */ +/* By Nguyen Anh Quynh , 2013-2022, */ +/* Rot127 2022-2024 */ +/* Automatically generated file by Capstone's LLVM TableGen Disassembler Backend. */ + +/* LLVM-commit: */ +/* LLVM-tag: */ + +/* Do not edit. */ + +/* Capstone's LLVM TableGen Backends: */ +/* https://github.com/capstone-engine/llvm-capstone */ + + { RISCV_INS_ALIAS_NOP, "nop" }, + { RISCV_INS_ALIAS_LI, "li" }, + { RISCV_INS_ALIAS_MV, "mv" }, + { RISCV_INS_ALIAS_NOT, "not" }, + { RISCV_INS_ALIAS_NEG, "neg" }, + { RISCV_INS_ALIAS_NEGW, "negw" }, + { RISCV_INS_ALIAS_SEXT_W, "sext_w" }, + { RISCV_INS_ALIAS_SEQZ, "seqz" }, + { RISCV_INS_ALIAS_SNEZ, "snez" }, + { RISCV_INS_ALIAS_SLTZ, "sltz" }, + { RISCV_INS_ALIAS_SGTZ, "sgtz" }, + { RISCV_INS_ALIAS_BEQZ, "beqz" }, + { RISCV_INS_ALIAS_BNEZ, "bnez" }, + { RISCV_INS_ALIAS_BLEZ, "blez" }, + { RISCV_INS_ALIAS_BGEZ, "bgez" }, + { RISCV_INS_ALIAS_BLTZ, "bltz" }, + { RISCV_INS_ALIAS_BGTZ, "bgtz" }, + { RISCV_INS_ALIAS_J, "j" }, + { RISCV_INS_ALIAS_JAL, "jal" }, + { RISCV_INS_ALIAS_JR, "jr" }, + { RISCV_INS_ALIAS_JALR, "jalr" }, + { RISCV_INS_ALIAS_RET, "ret" }, + { RISCV_INS_ALIAS_FENCE, "fence" }, + { RISCV_INS_ALIAS_PAUSE, "pause" }, + { RISCV_INS_ALIAS_RDINSTRET, "rdinstret" }, + { RISCV_INS_ALIAS_RDCYCLE, "rdcycle" }, + { RISCV_INS_ALIAS_RDTIME, "rdtime" }, + { RISCV_INS_ALIAS_RDINSTRETH, "rdinstreth" }, + { RISCV_INS_ALIAS_RDCYCLEH, "rdcycleh" }, + { RISCV_INS_ALIAS_RDTIMEH, "rdtimeh" }, + { RISCV_INS_ALIAS_CSRR, "csrr" }, + { RISCV_INS_ALIAS_CSRW, "csrw" }, + { RISCV_INS_ALIAS_CSRS, "csrs" }, + { RISCV_INS_ALIAS_CSRC, "csrc" }, + { RISCV_INS_ALIAS_CSRWI, "csrwi" }, + { RISCV_INS_ALIAS_CSRSI, "csrsi" }, + { RISCV_INS_ALIAS_CSRCI, "csrci" }, + { RISCV_INS_ALIAS_SFENCE_VMA, "sfence_vma" }, + { RISCV_INS_ALIAS_HFENCE_GVMA, "hfence_gvma" }, + { RISCV_INS_ALIAS_HFENCE_VVMA, "hfence_vvma" }, + { RISCV_INS_ALIAS_NTL_P1, "ntl_p1" }, + { RISCV_INS_ALIAS_NTL_PALL, "ntl_pall" }, + { RISCV_INS_ALIAS_NTL_S1, "ntl_s1" }, + { RISCV_INS_ALIAS_NTL_ALL, "ntl_all" }, + { RISCV_INS_ALIAS_LPAD, "lpad" }, + { RISCV_INS_ALIAS_FMV_S, "fmv_s" }, + { RISCV_INS_ALIAS_FABS_S, "fabs_s" }, + { RISCV_INS_ALIAS_FNEG_S, "fneg_s" }, + { RISCV_INS_ALIAS_FRCSR, "frcsr" }, + { RISCV_INS_ALIAS_FSCSR, "fscsr" }, + { RISCV_INS_ALIAS_FRRM, "frrm" }, + { RISCV_INS_ALIAS_FSRM, "fsrm" }, + { RISCV_INS_ALIAS_FSRMI, "fsrmi" }, + { RISCV_INS_ALIAS_FRFLAGS, "frflags" }, + { RISCV_INS_ALIAS_FSFLAGS, "fsflags" }, + { RISCV_INS_ALIAS_FSFLAGSI, "fsflagsi" }, + { RISCV_INS_ALIAS_FMV_D, "fmv_d" }, + { RISCV_INS_ALIAS_FABS_D, "fabs_d" }, + { RISCV_INS_ALIAS_FNEG_D, "fneg_d" }, + { RISCV_INS_ALIAS_FMV_H, "fmv_h" }, + { RISCV_INS_ALIAS_FABS_H, "fabs_h" }, + { RISCV_INS_ALIAS_FNEG_H, "fneg_h" }, + { RISCV_INS_ALIAS_ZEXT_W, "zext_w" }, + { RISCV_INS_ALIAS_VL1R_V, "vl1r_v" }, + { RISCV_INS_ALIAS_VL2R_V, "vl2r_v" }, + { RISCV_INS_ALIAS_VL4R_V, "vl4r_v" }, + { RISCV_INS_ALIAS_VL8R_V, "vl8r_v" }, + { RISCV_INS_ALIAS_VNEG_V, "vneg_v" }, + { RISCV_INS_ALIAS_VWCVT_X_X_V, "vwcvt_x_x_v" }, + { RISCV_INS_ALIAS_VWCVTU_X_X_V, "vwcvtu_x_x_v" }, + { RISCV_INS_ALIAS_VNOT_V, "vnot_v" }, + { RISCV_INS_ALIAS_VNCVT_X_X_W, "vncvt_x_x_w" }, + { RISCV_INS_ALIAS_VFNEG_V, "vfneg_v" }, + { RISCV_INS_ALIAS_VFABS_V, "vfabs_v" }, + { RISCV_INS_ALIAS_VMMV_M, "vmmv_m" }, + { RISCV_INS_ALIAS_VMCLR_M, "vmclr_m" }, + { RISCV_INS_ALIAS_VMSET_M, "vmset_m" }, + { RISCV_INS_ALIAS_VMNOT_M, "vmnot_m" }, + { RISCV_INS_ALIAS_C_NTL_P1, "c_ntl_p1" }, + { RISCV_INS_ALIAS_C_NTL_PALL, "c_ntl_pall" }, + { RISCV_INS_ALIAS_C_NTL_S1, "c_ntl_s1" }, + { RISCV_INS_ALIAS_C_NTL_ALL, "c_ntl_all" }, + { RISCV_INS_ALIAS_CV_MULS, "cv_muls" }, + { RISCV_INS_ALIAS_CV_MULHHS, "cv_mulhhs" }, + { RISCV_INS_ALIAS_CV_MULU, "cv_mulu" }, + { RISCV_INS_ALIAS_CV_MULHHU, "cv_mulhhu" }, diff --git a/arch/RISCV/RISCVGenCSFeatureEnum.inc b/arch/RISCV/RISCVGenCSFeatureEnum.inc new file mode 100644 index 0000000000..7884bdcd1d --- /dev/null +++ b/arch/RISCV/RISCVGenCSFeatureEnum.inc @@ -0,0 +1,113 @@ +/* Capstone Disassembly Engine, https://www.capstone-engine.org */ +/* By Nguyen Anh Quynh , 2013-2022, */ +/* Rot127 2022-2024 */ +/* Automatically generated file by Capstone's LLVM TableGen Disassembler Backend. */ + +/* LLVM-commit: */ +/* LLVM-tag: */ + +/* Do not edit. */ + +/* Capstone's LLVM TableGen Backends: */ +/* https://github.com/capstone-engine/llvm-capstone */ + +RISCV_FEATURE_HASSTDEXTI = 128, +RISCV_FEATURE_HASSTDEXTZICBOM, +RISCV_FEATURE_HASSTDEXTZICBOP, +RISCV_FEATURE_HASSTDEXTZICBOZ, +RISCV_FEATURE_HASSTDEXTZICSR, +RISCV_FEATURE_HASSTDEXTZICOND, +RISCV_FEATURE_HASSTDEXTZIFENCEI, +RISCV_FEATURE_HASSTDEXTZIHINTPAUSE, +RISCV_FEATURE_HASSTDEXTZIHINTNTL, +RISCV_FEATURE_HASSTDEXTZIMOP, +RISCV_FEATURE_HASSTDEXTZICFILP, +RISCV_FEATURE_HASSTDEXTZICFISS, +RISCV_FEATURE_HASSTDEXTM, +RISCV_FEATURE_HASSTDEXTMORZMMUL, +RISCV_FEATURE_HASSTDEXTA, +RISCV_FEATURE_HASSTDEXTZTSO, +RISCV_FEATURE_HASSTDEXTZACAS, +RISCV_FEATURE_HASSTDEXTZAWRS, +RISCV_FEATURE_HASSTDEXTF, +RISCV_FEATURE_HASSTDEXTD, +RISCV_FEATURE_HASSTDEXTZFHMIN, +RISCV_FEATURE_HASSTDEXTZFH, +RISCV_FEATURE_HASSTDEXTZFBFMIN, +RISCV_FEATURE_HASHALFFPLOADSTOREMOVE, +RISCV_FEATURE_HASSTDEXTZFA, +RISCV_FEATURE_HASSTDEXTZFINX, +RISCV_FEATURE_HASSTDEXTZDINX, +RISCV_FEATURE_HASSTDEXTZHINXMIN, +RISCV_FEATURE_HASSTDEXTZHINX, +RISCV_FEATURE_HASSTDEXTC, +RISCV_FEATURE_HASRVCHINTS, +RISCV_FEATURE_HASSTDEXTCORZCA, +RISCV_FEATURE_HASSTDEXTZCB, +RISCV_FEATURE_HASSTDEXTCORZCD, +RISCV_FEATURE_HASSTDEXTZCMP, +RISCV_FEATURE_HASSTDEXTZCMT, +RISCV_FEATURE_HASSTDEXTCORZCFORZCE, +RISCV_FEATURE_HASSTDEXTZCMOP, +RISCV_FEATURE_HASSTDEXTZBA, +RISCV_FEATURE_HASSTDEXTZBB, +RISCV_FEATURE_HASSTDEXTZBC, +RISCV_FEATURE_HASSTDEXTZBS, +RISCV_FEATURE_HASSTDEXTZBKB, +RISCV_FEATURE_HASSTDEXTZBKX, +RISCV_FEATURE_HASSTDEXTZBBORZBKB, +RISCV_FEATURE_HASSTDEXTZBKC, +RISCV_FEATURE_HASSTDEXTZBCORZBKC, +RISCV_FEATURE_HASSTDEXTZKND, +RISCV_FEATURE_HASSTDEXTZKNE, +RISCV_FEATURE_HASSTDEXTZKNDORZKNE, +RISCV_FEATURE_HASSTDEXTZKNH, +RISCV_FEATURE_HASSTDEXTZKSED, +RISCV_FEATURE_HASSTDEXTZKSH, +RISCV_FEATURE_HASSTDEXTZKR, +RISCV_FEATURE_HASSTDEXTZVFBFMIN, +RISCV_FEATURE_HASSTDEXTZVFBFWMA, +RISCV_FEATURE_HASSTDEXTZFHORZVFH, +RISCV_FEATURE_HASSTDEXTZVKB, +RISCV_FEATURE_HASSTDEXTZVBB, +RISCV_FEATURE_HASSTDEXTZVBC, +RISCV_FEATURE_HASSTDEXTZVKG, +RISCV_FEATURE_HASSTDEXTZVKNED, +RISCV_FEATURE_HASSTDEXTZVKNHA, +RISCV_FEATURE_HASSTDEXTZVKNHB, +RISCV_FEATURE_HASSTDEXTZVKNHAORZVKNHB, +RISCV_FEATURE_HASSTDEXTZVKSED, +RISCV_FEATURE_HASSTDEXTZVKSH, +RISCV_FEATURE_HASVINSTRUCTIONS, +RISCV_FEATURE_HASVINSTRUCTIONSI64, +RISCV_FEATURE_HASVINSTRUCTIONSANYF, +RISCV_FEATURE_HASVINSTRUCTIONSF16MINIMAL, +RISCV_FEATURE_HASSTDEXTH, +RISCV_FEATURE_HASSTDEXTSVINVAL, +RISCV_FEATURE_HASVENDORXVENTANACONDOPS, +RISCV_FEATURE_HASVENDORXTHEADBA, +RISCV_FEATURE_HASVENDORXTHEADBB, +RISCV_FEATURE_HASVENDORXTHEADBS, +RISCV_FEATURE_HASVENDORXTHEADCONDMOV, +RISCV_FEATURE_HASVENDORXTHEADCMO, +RISCV_FEATURE_HASVENDORXTHEADFMEMIDX, +RISCV_FEATURE_HASVENDORXTHEADMAC, +RISCV_FEATURE_HASVENDORXTHEADMEMIDX, +RISCV_FEATURE_HASVENDORXTHEADMEMPAIR, +RISCV_FEATURE_HASVENDORXTHEADSYNC, +RISCV_FEATURE_HASVENDORXTHEADVDOT, +RISCV_FEATURE_HASVENDORXSFVCP, +RISCV_FEATURE_HASVENDORXSFVQMACCDOD, +RISCV_FEATURE_HASVENDORXSFVQMACCQOQ, +RISCV_FEATURE_HASVENDORXSFVFWMACCQQQ, +RISCV_FEATURE_HASVENDORXSFVFNRCLIPXFQF, +RISCV_FEATURE_HASVENDORXCVELW, +RISCV_FEATURE_HASVENDORXCVBITMANIP, +RISCV_FEATURE_HASVENDORXCVMAC, +RISCV_FEATURE_HASVENDORXCVMEM, +RISCV_FEATURE_HASVENDORXCVALU, +RISCV_FEATURE_HASVENDORXCVSIMD, +RISCV_FEATURE_HASVENDORXCVBI, +RISCV_FEATURE_ISRV64, +RISCV_FEATURE_ISRV32, +RISCV_FEATURE_ISRVE, diff --git a/arch/RISCV/RISCVGenCSFeatureName.inc b/arch/RISCV/RISCVGenCSFeatureName.inc new file mode 100644 index 0000000000..0c2c90745a --- /dev/null +++ b/arch/RISCV/RISCVGenCSFeatureName.inc @@ -0,0 +1,113 @@ +/* Capstone Disassembly Engine, https://www.capstone-engine.org */ +/* By Nguyen Anh Quynh , 2013-2022, */ +/* Rot127 2022-2024 */ +/* Automatically generated file by Capstone's LLVM TableGen Disassembler Backend. */ + +/* LLVM-commit: */ +/* LLVM-tag: */ + +/* Do not edit. */ + +/* Capstone's LLVM TableGen Backends: */ +/* https://github.com/capstone-engine/llvm-capstone */ + +{ RISCV_FEATURE_HASSTDEXTI, "HasStdExtI" }, +{ RISCV_FEATURE_HASSTDEXTZICBOM, "HasStdExtZicbom" }, +{ RISCV_FEATURE_HASSTDEXTZICBOP, "HasStdExtZicbop" }, +{ RISCV_FEATURE_HASSTDEXTZICBOZ, "HasStdExtZicboz" }, +{ RISCV_FEATURE_HASSTDEXTZICSR, "HasStdExtZicsr" }, +{ RISCV_FEATURE_HASSTDEXTZICOND, "HasStdExtZicond" }, +{ RISCV_FEATURE_HASSTDEXTZIFENCEI, "HasStdExtZifencei" }, +{ RISCV_FEATURE_HASSTDEXTZIHINTPAUSE, "HasStdExtZihintpause" }, +{ RISCV_FEATURE_HASSTDEXTZIHINTNTL, "HasStdExtZihintntl" }, +{ RISCV_FEATURE_HASSTDEXTZIMOP, "HasStdExtZimop" }, +{ RISCV_FEATURE_HASSTDEXTZICFILP, "HasStdExtZicfilp" }, +{ RISCV_FEATURE_HASSTDEXTZICFISS, "HasStdExtZicfiss" }, +{ RISCV_FEATURE_HASSTDEXTM, "HasStdExtM" }, +{ RISCV_FEATURE_HASSTDEXTMORZMMUL, "HasStdExtMOrZmmul" }, +{ RISCV_FEATURE_HASSTDEXTA, "HasStdExtA" }, +{ RISCV_FEATURE_HASSTDEXTZTSO, "HasStdExtZtso" }, +{ RISCV_FEATURE_HASSTDEXTZACAS, "HasStdExtZacas" }, +{ RISCV_FEATURE_HASSTDEXTZAWRS, "HasStdExtZawrs" }, +{ RISCV_FEATURE_HASSTDEXTF, "HasStdExtF" }, +{ RISCV_FEATURE_HASSTDEXTD, "HasStdExtD" }, +{ RISCV_FEATURE_HASSTDEXTZFHMIN, "HasStdExtZfhmin" }, +{ RISCV_FEATURE_HASSTDEXTZFH, "HasStdExtZfh" }, +{ RISCV_FEATURE_HASSTDEXTZFBFMIN, "HasStdExtZfbfmin" }, +{ RISCV_FEATURE_HASHALFFPLOADSTOREMOVE, "HasHalfFPLoadStoreMove" }, +{ RISCV_FEATURE_HASSTDEXTZFA, "HasStdExtZfa" }, +{ RISCV_FEATURE_HASSTDEXTZFINX, "HasStdExtZfinx" }, +{ RISCV_FEATURE_HASSTDEXTZDINX, "HasStdExtZdinx" }, +{ RISCV_FEATURE_HASSTDEXTZHINXMIN, "HasStdExtZhinxmin" }, +{ RISCV_FEATURE_HASSTDEXTZHINX, "HasStdExtZhinx" }, +{ RISCV_FEATURE_HASSTDEXTC, "HasStdExtC" }, +{ RISCV_FEATURE_HASRVCHINTS, "HasRVCHints" }, +{ RISCV_FEATURE_HASSTDEXTCORZCA, "HasStdExtCOrZca" }, +{ RISCV_FEATURE_HASSTDEXTZCB, "HasStdExtZcb" }, +{ RISCV_FEATURE_HASSTDEXTCORZCD, "HasStdExtCOrZcd" }, +{ RISCV_FEATURE_HASSTDEXTZCMP, "HasStdExtZcmp" }, +{ RISCV_FEATURE_HASSTDEXTZCMT, "HasStdExtZcmt" }, +{ RISCV_FEATURE_HASSTDEXTCORZCFORZCE, "HasStdExtCOrZcfOrZce" }, +{ RISCV_FEATURE_HASSTDEXTZCMOP, "HasStdExtZcmop" }, +{ RISCV_FEATURE_HASSTDEXTZBA, "HasStdExtZba" }, +{ RISCV_FEATURE_HASSTDEXTZBB, "HasStdExtZbb" }, +{ RISCV_FEATURE_HASSTDEXTZBC, "HasStdExtZbc" }, +{ RISCV_FEATURE_HASSTDEXTZBS, "HasStdExtZbs" }, +{ RISCV_FEATURE_HASSTDEXTZBKB, "HasStdExtZbkb" }, +{ RISCV_FEATURE_HASSTDEXTZBKX, "HasStdExtZbkx" }, +{ RISCV_FEATURE_HASSTDEXTZBBORZBKB, "HasStdExtZbbOrZbkb" }, +{ RISCV_FEATURE_HASSTDEXTZBKC, "HasStdExtZbkc" }, +{ RISCV_FEATURE_HASSTDEXTZBCORZBKC, "HasStdExtZbcOrZbkc" }, +{ RISCV_FEATURE_HASSTDEXTZKND, "HasStdExtZknd" }, +{ RISCV_FEATURE_HASSTDEXTZKNE, "HasStdExtZkne" }, +{ RISCV_FEATURE_HASSTDEXTZKNDORZKNE, "HasStdExtZkndOrZkne" }, +{ RISCV_FEATURE_HASSTDEXTZKNH, "HasStdExtZknh" }, +{ RISCV_FEATURE_HASSTDEXTZKSED, "HasStdExtZksed" }, +{ RISCV_FEATURE_HASSTDEXTZKSH, "HasStdExtZksh" }, +{ RISCV_FEATURE_HASSTDEXTZKR, "HasStdExtZkr" }, +{ RISCV_FEATURE_HASSTDEXTZVFBFMIN, "HasStdExtZvfbfmin" }, +{ RISCV_FEATURE_HASSTDEXTZVFBFWMA, "HasStdExtZvfbfwma" }, +{ RISCV_FEATURE_HASSTDEXTZFHORZVFH, "HasStdExtZfhOrZvfh" }, +{ RISCV_FEATURE_HASSTDEXTZVKB, "HasStdExtZvkb" }, +{ RISCV_FEATURE_HASSTDEXTZVBB, "HasStdExtZvbb" }, +{ RISCV_FEATURE_HASSTDEXTZVBC, "HasStdExtZvbc" }, +{ RISCV_FEATURE_HASSTDEXTZVKG, "HasStdExtZvkg" }, +{ RISCV_FEATURE_HASSTDEXTZVKNED, "HasStdExtZvkned" }, +{ RISCV_FEATURE_HASSTDEXTZVKNHA, "HasStdExtZvknha" }, +{ RISCV_FEATURE_HASSTDEXTZVKNHB, "HasStdExtZvknhb" }, +{ RISCV_FEATURE_HASSTDEXTZVKNHAORZVKNHB, "HasStdExtZvknhaOrZvknhb" }, +{ RISCV_FEATURE_HASSTDEXTZVKSED, "HasStdExtZvksed" }, +{ RISCV_FEATURE_HASSTDEXTZVKSH, "HasStdExtZvksh" }, +{ RISCV_FEATURE_HASVINSTRUCTIONS, "HasVInstructions" }, +{ RISCV_FEATURE_HASVINSTRUCTIONSI64, "HasVInstructionsI64" }, +{ RISCV_FEATURE_HASVINSTRUCTIONSANYF, "HasVInstructionsAnyF" }, +{ RISCV_FEATURE_HASVINSTRUCTIONSF16MINIMAL, "HasVInstructionsF16Minimal" }, +{ RISCV_FEATURE_HASSTDEXTH, "HasStdExtH" }, +{ RISCV_FEATURE_HASSTDEXTSVINVAL, "HasStdExtSvinval" }, +{ RISCV_FEATURE_HASVENDORXVENTANACONDOPS, "HasVendorXVentanaCondOps" }, +{ RISCV_FEATURE_HASVENDORXTHEADBA, "HasVendorXTHeadBa" }, +{ RISCV_FEATURE_HASVENDORXTHEADBB, "HasVendorXTHeadBb" }, +{ RISCV_FEATURE_HASVENDORXTHEADBS, "HasVendorXTHeadBs" }, +{ RISCV_FEATURE_HASVENDORXTHEADCONDMOV, "HasVendorXTHeadCondMov" }, +{ RISCV_FEATURE_HASVENDORXTHEADCMO, "HasVendorXTHeadCmo" }, +{ RISCV_FEATURE_HASVENDORXTHEADFMEMIDX, "HasVendorXTHeadFMemIdx" }, +{ RISCV_FEATURE_HASVENDORXTHEADMAC, "HasVendorXTHeadMac" }, +{ RISCV_FEATURE_HASVENDORXTHEADMEMIDX, "HasVendorXTHeadMemIdx" }, +{ RISCV_FEATURE_HASVENDORXTHEADMEMPAIR, "HasVendorXTHeadMemPair" }, +{ RISCV_FEATURE_HASVENDORXTHEADSYNC, "HasVendorXTHeadSync" }, +{ RISCV_FEATURE_HASVENDORXTHEADVDOT, "HasVendorXTHeadVdot" }, +{ RISCV_FEATURE_HASVENDORXSFVCP, "HasVendorXSfvcp" }, +{ RISCV_FEATURE_HASVENDORXSFVQMACCDOD, "HasVendorXSfvqmaccdod" }, +{ RISCV_FEATURE_HASVENDORXSFVQMACCQOQ, "HasVendorXSfvqmaccqoq" }, +{ RISCV_FEATURE_HASVENDORXSFVFWMACCQQQ, "HasVendorXSfvfwmaccqqq" }, +{ RISCV_FEATURE_HASVENDORXSFVFNRCLIPXFQF, "HasVendorXSfvfnrclipxfqf" }, +{ RISCV_FEATURE_HASVENDORXCVELW, "HasVendorXCVelw" }, +{ RISCV_FEATURE_HASVENDORXCVBITMANIP, "HasVendorXCVbitmanip" }, +{ RISCV_FEATURE_HASVENDORXCVMAC, "HasVendorXCVmac" }, +{ RISCV_FEATURE_HASVENDORXCVMEM, "HasVendorXCVmem" }, +{ RISCV_FEATURE_HASVENDORXCVALU, "HasVendorXCValu" }, +{ RISCV_FEATURE_HASVENDORXCVSIMD, "HasVendorXCVsimd" }, +{ RISCV_FEATURE_HASVENDORXCVBI, "HasVendorXCVbi" }, +{ RISCV_FEATURE_ISRV64, "IsRV64" }, +{ RISCV_FEATURE_ISRV32, "IsRV32" }, +{ RISCV_FEATURE_ISRVE, "IsRVE" }, diff --git a/arch/RISCV/RISCVGenCSInsnEnum.inc b/arch/RISCV/RISCVGenCSInsnEnum.inc new file mode 100644 index 0000000000..068f621237 --- /dev/null +++ b/arch/RISCV/RISCVGenCSInsnEnum.inc @@ -0,0 +1,1688 @@ +/* Capstone Disassembly Engine, https://www.capstone-engine.org */ +/* By Nguyen Anh Quynh , 2013-2022, */ +/* Rot127 2022-2024 */ +/* Automatically generated file by Capstone's LLVM TableGen Disassembler Backend. */ + +/* LLVM-commit: */ +/* LLVM-tag: */ + +/* Do not edit. */ + +/* Capstone's LLVM TableGen Backends: */ +/* https://github.com/capstone-engine/llvm-capstone */ + + RISCV_INS_INVALID, + RISCV_INS_ADD, + RISCV_INS_CALL, + RISCV_INS_FLD, + RISCV_INS_FLH, + RISCV_INS_FLW, + RISCV_INS_FSD, + RISCV_INS_FSH, + RISCV_INS_FSW, + RISCV_INS_JUMP, + RISCV_INS_LA, + RISCV_INS_LA_TLSDESC, + RISCV_INS_LA_TLS_GD, + RISCV_INS_LA_TLS_IE, + RISCV_INS_LB, + RISCV_INS_LBU, + RISCV_INS_LD, + RISCV_INS_LGA, + RISCV_INS_LH, + RISCV_INS_LHU, + RISCV_INS_LI, + RISCV_INS_LLA, + RISCV_INS_LW, + RISCV_INS_LWU, + RISCV_INS_SB, + RISCV_INS_SD, + RISCV_INS_SEXT_B, + RISCV_INS_SEXT_H, + RISCV_INS_SH, + RISCV_INS_SW, + RISCV_INS_TAIL, + RISCV_INS_JALR, + RISCV_INS_VMSGEU_VI, + RISCV_INS_VMSGEU_VX, + RISCV_INS_VMSGE_VI, + RISCV_INS_VMSGE_VX, + RISCV_INS_VMSLTU_VI, + RISCV_INS_VMSLT_VI, + RISCV_INS_ZEXT_H, + RISCV_INS_ZEXT_W, + RISCV_INS_ADDI, + RISCV_INS_ADDIW, + RISCV_INS_ADDW, + RISCV_INS_ADD_UW, + RISCV_INS_AES32DSI, + RISCV_INS_AES32DSMI, + RISCV_INS_AES32ESI, + RISCV_INS_AES32ESMI, + RISCV_INS_AES64DS, + RISCV_INS_AES64DSM, + RISCV_INS_AES64ES, + RISCV_INS_AES64ESM, + RISCV_INS_AES64IM, + RISCV_INS_AES64KS1I, + RISCV_INS_AES64KS2, + RISCV_INS_AMOADD_D, + RISCV_INS_AMOADD_D_AQ, + RISCV_INS_AMOADD_D_AQRL, + RISCV_INS_AMOADD_D_RL, + RISCV_INS_AMOADD_W, + RISCV_INS_AMOADD_W_AQ, + RISCV_INS_AMOADD_W_AQRL, + RISCV_INS_AMOADD_W_RL, + RISCV_INS_AMOAND_D, + RISCV_INS_AMOAND_D_AQ, + RISCV_INS_AMOAND_D_AQRL, + RISCV_INS_AMOAND_D_RL, + RISCV_INS_AMOAND_W, + RISCV_INS_AMOAND_W_AQ, + RISCV_INS_AMOAND_W_AQRL, + RISCV_INS_AMOAND_W_RL, + RISCV_INS_AMOCAS_D, + RISCV_INS_AMOCAS_D_AQ, + RISCV_INS_AMOCAS_D_AQRL, + RISCV_INS_AMOCAS_D_RL, + RISCV_INS_AMOCAS_Q, + RISCV_INS_AMOCAS_Q_AQ, + RISCV_INS_AMOCAS_Q_AQRL, + RISCV_INS_AMOCAS_Q_RL, + RISCV_INS_AMOCAS_W, + RISCV_INS_AMOCAS_W_AQ, + RISCV_INS_AMOCAS_W_AQRL, + RISCV_INS_AMOCAS_W_RL, + RISCV_INS_AMOMAXU_D, + RISCV_INS_AMOMAXU_D_AQ, + RISCV_INS_AMOMAXU_D_AQRL, + RISCV_INS_AMOMAXU_D_RL, + RISCV_INS_AMOMAXU_W, + RISCV_INS_AMOMAXU_W_AQ, + RISCV_INS_AMOMAXU_W_AQRL, + RISCV_INS_AMOMAXU_W_RL, + RISCV_INS_AMOMAX_D, + RISCV_INS_AMOMAX_D_AQ, + RISCV_INS_AMOMAX_D_AQRL, + RISCV_INS_AMOMAX_D_RL, + RISCV_INS_AMOMAX_W, + RISCV_INS_AMOMAX_W_AQ, + RISCV_INS_AMOMAX_W_AQRL, + RISCV_INS_AMOMAX_W_RL, + RISCV_INS_AMOMINU_D, + RISCV_INS_AMOMINU_D_AQ, + RISCV_INS_AMOMINU_D_AQRL, + RISCV_INS_AMOMINU_D_RL, + RISCV_INS_AMOMINU_W, + RISCV_INS_AMOMINU_W_AQ, + RISCV_INS_AMOMINU_W_AQRL, + RISCV_INS_AMOMINU_W_RL, + RISCV_INS_AMOMIN_D, + RISCV_INS_AMOMIN_D_AQ, + RISCV_INS_AMOMIN_D_AQRL, + RISCV_INS_AMOMIN_D_RL, + RISCV_INS_AMOMIN_W, + RISCV_INS_AMOMIN_W_AQ, + RISCV_INS_AMOMIN_W_AQRL, + RISCV_INS_AMOMIN_W_RL, + RISCV_INS_AMOOR_D, + RISCV_INS_AMOOR_D_AQ, + RISCV_INS_AMOOR_D_AQRL, + RISCV_INS_AMOOR_D_RL, + RISCV_INS_AMOOR_W, + RISCV_INS_AMOOR_W_AQ, + RISCV_INS_AMOOR_W_AQRL, + RISCV_INS_AMOOR_W_RL, + RISCV_INS_AMOSWAP_D, + RISCV_INS_AMOSWAP_D_AQ, + RISCV_INS_AMOSWAP_D_AQRL, + RISCV_INS_AMOSWAP_D_RL, + RISCV_INS_AMOSWAP_W, + RISCV_INS_AMOSWAP_W_AQ, + RISCV_INS_AMOSWAP_W_AQRL, + RISCV_INS_AMOSWAP_W_RL, + RISCV_INS_AMOXOR_D, + RISCV_INS_AMOXOR_D_AQ, + RISCV_INS_AMOXOR_D_AQRL, + RISCV_INS_AMOXOR_D_RL, + RISCV_INS_AMOXOR_W, + RISCV_INS_AMOXOR_W_AQ, + RISCV_INS_AMOXOR_W_AQRL, + RISCV_INS_AMOXOR_W_RL, + RISCV_INS_AND, + RISCV_INS_ANDI, + RISCV_INS_ANDN, + RISCV_INS_AUIPC, + RISCV_INS_BCLR, + RISCV_INS_BCLRI, + RISCV_INS_BEQ, + RISCV_INS_BEXT, + RISCV_INS_BEXTI, + RISCV_INS_BGE, + RISCV_INS_BGEU, + RISCV_INS_BINV, + RISCV_INS_BINVI, + RISCV_INS_BLT, + RISCV_INS_BLTU, + RISCV_INS_BNE, + RISCV_INS_BREV8, + RISCV_INS_BSET, + RISCV_INS_BSETI, + RISCV_INS_CBO_CLEAN, + RISCV_INS_CBO_FLUSH, + RISCV_INS_CBO_INVAL, + RISCV_INS_CBO_ZERO, + RISCV_INS_CLMUL, + RISCV_INS_CLMULH, + RISCV_INS_CLMULR, + RISCV_INS_CLZ, + RISCV_INS_CLZW, + RISCV_INS_CMOP_1, + RISCV_INS_CMOP_11, + RISCV_INS_CMOP_13, + RISCV_INS_CMOP_15, + RISCV_INS_CMOP_3, + RISCV_INS_CMOP_5, + RISCV_INS_CMOP_7, + RISCV_INS_CMOP_9, + RISCV_INS_CM_JALT, + RISCV_INS_CM_JT, + RISCV_INS_CM_MVA01S, + RISCV_INS_CM_MVSA01, + RISCV_INS_CM_POP, + RISCV_INS_CM_POPRET, + RISCV_INS_CM_POPRETZ, + RISCV_INS_CM_PUSH, + RISCV_INS_CPOP, + RISCV_INS_CPOPW, + RISCV_INS_CSRRC, + RISCV_INS_CSRRCI, + RISCV_INS_CSRRS, + RISCV_INS_CSRRSI, + RISCV_INS_CSRRW, + RISCV_INS_CSRRWI, + RISCV_INS_CTZ, + RISCV_INS_CTZW, + RISCV_INS_CV_ABS, + RISCV_INS_CV_ABS_B, + RISCV_INS_CV_ABS_H, + RISCV_INS_CV_ADDN, + RISCV_INS_CV_ADDNR, + RISCV_INS_CV_ADDRN, + RISCV_INS_CV_ADDRNR, + RISCV_INS_CV_ADDUN, + RISCV_INS_CV_ADDUNR, + RISCV_INS_CV_ADDURN, + RISCV_INS_CV_ADDURNR, + RISCV_INS_CV_ADD_B, + RISCV_INS_CV_ADD_DIV2, + RISCV_INS_CV_ADD_DIV4, + RISCV_INS_CV_ADD_DIV8, + RISCV_INS_CV_ADD_H, + RISCV_INS_CV_ADD_SCI_B, + RISCV_INS_CV_ADD_SCI_H, + RISCV_INS_CV_ADD_SC_B, + RISCV_INS_CV_ADD_SC_H, + RISCV_INS_CV_AND_B, + RISCV_INS_CV_AND_H, + RISCV_INS_CV_AND_SCI_B, + RISCV_INS_CV_AND_SCI_H, + RISCV_INS_CV_AND_SC_B, + RISCV_INS_CV_AND_SC_H, + RISCV_INS_CV_AVGU_B, + RISCV_INS_CV_AVGU_H, + RISCV_INS_CV_AVGU_SCI_B, + RISCV_INS_CV_AVGU_SCI_H, + RISCV_INS_CV_AVGU_SC_B, + RISCV_INS_CV_AVGU_SC_H, + RISCV_INS_CV_AVG_B, + RISCV_INS_CV_AVG_H, + RISCV_INS_CV_AVG_SCI_B, + RISCV_INS_CV_AVG_SCI_H, + RISCV_INS_CV_AVG_SC_B, + RISCV_INS_CV_AVG_SC_H, + RISCV_INS_CV_BCLR, + RISCV_INS_CV_BCLRR, + RISCV_INS_CV_BEQIMM, + RISCV_INS_CV_BITREV, + RISCV_INS_CV_BNEIMM, + RISCV_INS_CV_BSET, + RISCV_INS_CV_BSETR, + RISCV_INS_CV_CLB, + RISCV_INS_CV_CLIP, + RISCV_INS_CV_CLIPR, + RISCV_INS_CV_CLIPU, + RISCV_INS_CV_CLIPUR, + RISCV_INS_CV_CMPEQ_B, + RISCV_INS_CV_CMPEQ_H, + RISCV_INS_CV_CMPEQ_SCI_B, + RISCV_INS_CV_CMPEQ_SCI_H, + RISCV_INS_CV_CMPEQ_SC_B, + RISCV_INS_CV_CMPEQ_SC_H, + RISCV_INS_CV_CMPGEU_B, + RISCV_INS_CV_CMPGEU_H, + RISCV_INS_CV_CMPGEU_SCI_B, + RISCV_INS_CV_CMPGEU_SCI_H, + RISCV_INS_CV_CMPGEU_SC_B, + RISCV_INS_CV_CMPGEU_SC_H, + RISCV_INS_CV_CMPGE_B, + RISCV_INS_CV_CMPGE_H, + RISCV_INS_CV_CMPGE_SCI_B, + RISCV_INS_CV_CMPGE_SCI_H, + RISCV_INS_CV_CMPGE_SC_B, + RISCV_INS_CV_CMPGE_SC_H, + RISCV_INS_CV_CMPGTU_B, + RISCV_INS_CV_CMPGTU_H, + RISCV_INS_CV_CMPGTU_SCI_B, + RISCV_INS_CV_CMPGTU_SCI_H, + RISCV_INS_CV_CMPGTU_SC_B, + RISCV_INS_CV_CMPGTU_SC_H, + RISCV_INS_CV_CMPGT_B, + RISCV_INS_CV_CMPGT_H, + RISCV_INS_CV_CMPGT_SCI_B, + RISCV_INS_CV_CMPGT_SCI_H, + RISCV_INS_CV_CMPGT_SC_B, + RISCV_INS_CV_CMPGT_SC_H, + RISCV_INS_CV_CMPLEU_B, + RISCV_INS_CV_CMPLEU_H, + RISCV_INS_CV_CMPLEU_SCI_B, + RISCV_INS_CV_CMPLEU_SCI_H, + RISCV_INS_CV_CMPLEU_SC_B, + RISCV_INS_CV_CMPLEU_SC_H, + RISCV_INS_CV_CMPLE_B, + RISCV_INS_CV_CMPLE_H, + RISCV_INS_CV_CMPLE_SCI_B, + RISCV_INS_CV_CMPLE_SCI_H, + RISCV_INS_CV_CMPLE_SC_B, + RISCV_INS_CV_CMPLE_SC_H, + RISCV_INS_CV_CMPLTU_B, + RISCV_INS_CV_CMPLTU_H, + RISCV_INS_CV_CMPLTU_SCI_B, + RISCV_INS_CV_CMPLTU_SCI_H, + RISCV_INS_CV_CMPLTU_SC_B, + RISCV_INS_CV_CMPLTU_SC_H, + RISCV_INS_CV_CMPLT_B, + RISCV_INS_CV_CMPLT_H, + RISCV_INS_CV_CMPLT_SCI_B, + RISCV_INS_CV_CMPLT_SCI_H, + RISCV_INS_CV_CMPLT_SC_B, + RISCV_INS_CV_CMPLT_SC_H, + RISCV_INS_CV_CMPNE_B, + RISCV_INS_CV_CMPNE_H, + RISCV_INS_CV_CMPNE_SCI_B, + RISCV_INS_CV_CMPNE_SCI_H, + RISCV_INS_CV_CMPNE_SC_B, + RISCV_INS_CV_CMPNE_SC_H, + RISCV_INS_CV_CNT, + RISCV_INS_CV_CPLXCONJ, + RISCV_INS_CV_CPLXMUL_I, + RISCV_INS_CV_CPLXMUL_I_DIV2, + RISCV_INS_CV_CPLXMUL_I_DIV4, + RISCV_INS_CV_CPLXMUL_I_DIV8, + RISCV_INS_CV_CPLXMUL_R, + RISCV_INS_CV_CPLXMUL_R_DIV2, + RISCV_INS_CV_CPLXMUL_R_DIV4, + RISCV_INS_CV_CPLXMUL_R_DIV8, + RISCV_INS_CV_DOTSP_B, + RISCV_INS_CV_DOTSP_H, + RISCV_INS_CV_DOTSP_SCI_B, + RISCV_INS_CV_DOTSP_SCI_H, + RISCV_INS_CV_DOTSP_SC_B, + RISCV_INS_CV_DOTSP_SC_H, + RISCV_INS_CV_DOTUP_B, + RISCV_INS_CV_DOTUP_H, + RISCV_INS_CV_DOTUP_SCI_B, + RISCV_INS_CV_DOTUP_SCI_H, + RISCV_INS_CV_DOTUP_SC_B, + RISCV_INS_CV_DOTUP_SC_H, + RISCV_INS_CV_DOTUSP_B, + RISCV_INS_CV_DOTUSP_H, + RISCV_INS_CV_DOTUSP_SCI_B, + RISCV_INS_CV_DOTUSP_SCI_H, + RISCV_INS_CV_DOTUSP_SC_B, + RISCV_INS_CV_DOTUSP_SC_H, + RISCV_INS_CV_ELW, + RISCV_INS_CV_EXTBS, + RISCV_INS_CV_EXTBZ, + RISCV_INS_CV_EXTHS, + RISCV_INS_CV_EXTHZ, + RISCV_INS_CV_EXTRACT, + RISCV_INS_CV_EXTRACTR, + RISCV_INS_CV_EXTRACTU, + RISCV_INS_CV_EXTRACTUR, + RISCV_INS_CV_EXTRACTU_B, + RISCV_INS_CV_EXTRACTU_H, + RISCV_INS_CV_EXTRACT_B, + RISCV_INS_CV_EXTRACT_H, + RISCV_INS_CV_FF1, + RISCV_INS_CV_FL1, + RISCV_INS_CV_INSERT, + RISCV_INS_CV_INSERTR, + RISCV_INS_CV_INSERT_B, + RISCV_INS_CV_INSERT_H, + RISCV_INS_CV_LBU, + RISCV_INS_CV_LB, + RISCV_INS_CV_LHU, + RISCV_INS_CV_LH, + RISCV_INS_CV_LW, + RISCV_INS_CV_MAC, + RISCV_INS_CV_MACHHSN, + RISCV_INS_CV_MACHHSRN, + RISCV_INS_CV_MACHHUN, + RISCV_INS_CV_MACHHURN, + RISCV_INS_CV_MACSN, + RISCV_INS_CV_MACSRN, + RISCV_INS_CV_MACUN, + RISCV_INS_CV_MACURN, + RISCV_INS_CV_MAX, + RISCV_INS_CV_MAXU, + RISCV_INS_CV_MAXU_B, + RISCV_INS_CV_MAXU_H, + RISCV_INS_CV_MAXU_SCI_B, + RISCV_INS_CV_MAXU_SCI_H, + RISCV_INS_CV_MAXU_SC_B, + RISCV_INS_CV_MAXU_SC_H, + RISCV_INS_CV_MAX_B, + RISCV_INS_CV_MAX_H, + RISCV_INS_CV_MAX_SCI_B, + RISCV_INS_CV_MAX_SCI_H, + RISCV_INS_CV_MAX_SC_B, + RISCV_INS_CV_MAX_SC_H, + RISCV_INS_CV_MIN, + RISCV_INS_CV_MINU, + RISCV_INS_CV_MINU_B, + RISCV_INS_CV_MINU_H, + RISCV_INS_CV_MINU_SCI_B, + RISCV_INS_CV_MINU_SCI_H, + RISCV_INS_CV_MINU_SC_B, + RISCV_INS_CV_MINU_SC_H, + RISCV_INS_CV_MIN_B, + RISCV_INS_CV_MIN_H, + RISCV_INS_CV_MIN_SCI_B, + RISCV_INS_CV_MIN_SCI_H, + RISCV_INS_CV_MIN_SC_B, + RISCV_INS_CV_MIN_SC_H, + RISCV_INS_CV_MSU, + RISCV_INS_CV_MULHHSN, + RISCV_INS_CV_MULHHSRN, + RISCV_INS_CV_MULHHUN, + RISCV_INS_CV_MULHHURN, + RISCV_INS_CV_MULSN, + RISCV_INS_CV_MULSRN, + RISCV_INS_CV_MULUN, + RISCV_INS_CV_MULURN, + RISCV_INS_CV_OR_B, + RISCV_INS_CV_OR_H, + RISCV_INS_CV_OR_SCI_B, + RISCV_INS_CV_OR_SCI_H, + RISCV_INS_CV_OR_SC_B, + RISCV_INS_CV_OR_SC_H, + RISCV_INS_CV_PACK, + RISCV_INS_CV_PACKHI_B, + RISCV_INS_CV_PACKLO_B, + RISCV_INS_CV_PACK_H, + RISCV_INS_CV_ROR, + RISCV_INS_CV_SB, + RISCV_INS_CV_SDOTSP_B, + RISCV_INS_CV_SDOTSP_H, + RISCV_INS_CV_SDOTSP_SCI_B, + RISCV_INS_CV_SDOTSP_SCI_H, + RISCV_INS_CV_SDOTSP_SC_B, + RISCV_INS_CV_SDOTSP_SC_H, + RISCV_INS_CV_SDOTUP_B, + RISCV_INS_CV_SDOTUP_H, + RISCV_INS_CV_SDOTUP_SCI_B, + RISCV_INS_CV_SDOTUP_SCI_H, + RISCV_INS_CV_SDOTUP_SC_B, + RISCV_INS_CV_SDOTUP_SC_H, + RISCV_INS_CV_SDOTUSP_B, + RISCV_INS_CV_SDOTUSP_H, + RISCV_INS_CV_SDOTUSP_SCI_B, + RISCV_INS_CV_SDOTUSP_SCI_H, + RISCV_INS_CV_SDOTUSP_SC_B, + RISCV_INS_CV_SDOTUSP_SC_H, + RISCV_INS_CV_SHUFFLE2_B, + RISCV_INS_CV_SHUFFLE2_H, + RISCV_INS_CV_SHUFFLEI0_SCI_B, + RISCV_INS_CV_SHUFFLEI1_SCI_B, + RISCV_INS_CV_SHUFFLEI2_SCI_B, + RISCV_INS_CV_SHUFFLEI3_SCI_B, + RISCV_INS_CV_SHUFFLE_B, + RISCV_INS_CV_SHUFFLE_H, + RISCV_INS_CV_SHUFFLE_SCI_H, + RISCV_INS_CV_SH, + RISCV_INS_CV_SLET, + RISCV_INS_CV_SLETU, + RISCV_INS_CV_SLL_B, + RISCV_INS_CV_SLL_H, + RISCV_INS_CV_SLL_SCI_B, + RISCV_INS_CV_SLL_SCI_H, + RISCV_INS_CV_SLL_SC_B, + RISCV_INS_CV_SLL_SC_H, + RISCV_INS_CV_SRA_B, + RISCV_INS_CV_SRA_H, + RISCV_INS_CV_SRA_SCI_B, + RISCV_INS_CV_SRA_SCI_H, + RISCV_INS_CV_SRA_SC_B, + RISCV_INS_CV_SRA_SC_H, + RISCV_INS_CV_SRL_B, + RISCV_INS_CV_SRL_H, + RISCV_INS_CV_SRL_SCI_B, + RISCV_INS_CV_SRL_SCI_H, + RISCV_INS_CV_SRL_SC_B, + RISCV_INS_CV_SRL_SC_H, + RISCV_INS_CV_SUBN, + RISCV_INS_CV_SUBNR, + RISCV_INS_CV_SUBRN, + RISCV_INS_CV_SUBRNR, + RISCV_INS_CV_SUBROTMJ, + RISCV_INS_CV_SUBROTMJ_DIV2, + RISCV_INS_CV_SUBROTMJ_DIV4, + RISCV_INS_CV_SUBROTMJ_DIV8, + RISCV_INS_CV_SUBUN, + RISCV_INS_CV_SUBUNR, + RISCV_INS_CV_SUBURN, + RISCV_INS_CV_SUBURNR, + RISCV_INS_CV_SUB_B, + RISCV_INS_CV_SUB_DIV2, + RISCV_INS_CV_SUB_DIV4, + RISCV_INS_CV_SUB_DIV8, + RISCV_INS_CV_SUB_H, + RISCV_INS_CV_SUB_SCI_B, + RISCV_INS_CV_SUB_SCI_H, + RISCV_INS_CV_SUB_SC_B, + RISCV_INS_CV_SUB_SC_H, + RISCV_INS_CV_SW, + RISCV_INS_CV_XOR_B, + RISCV_INS_CV_XOR_H, + RISCV_INS_CV_XOR_SCI_B, + RISCV_INS_CV_XOR_SCI_H, + RISCV_INS_CV_XOR_SC_B, + RISCV_INS_CV_XOR_SC_H, + RISCV_INS_CZERO_EQZ, + RISCV_INS_CZERO_NEZ, + RISCV_INS_C_ADD, + RISCV_INS_C_ADDI, + RISCV_INS_C_ADDI16SP, + RISCV_INS_C_ADDI4SPN, + RISCV_INS_C_ADDIW, + RISCV_INS_C_ADDW, + RISCV_INS_C_AND, + RISCV_INS_C_ANDI, + RISCV_INS_C_BEQZ, + RISCV_INS_C_BNEZ, + RISCV_INS_C_EBREAK, + RISCV_INS_C_FLD, + RISCV_INS_C_FLDSP, + RISCV_INS_C_FLW, + RISCV_INS_C_FLWSP, + RISCV_INS_C_FSD, + RISCV_INS_C_FSDSP, + RISCV_INS_C_FSW, + RISCV_INS_C_FSWSP, + RISCV_INS_C_J, + RISCV_INS_C_JAL, + RISCV_INS_C_JALR, + RISCV_INS_C_JR, + RISCV_INS_C_LBU, + RISCV_INS_C_LD, + RISCV_INS_C_LDSP, + RISCV_INS_C_LH, + RISCV_INS_C_LHU, + RISCV_INS_C_LI, + RISCV_INS_C_LUI, + RISCV_INS_C_LW, + RISCV_INS_C_LWSP, + RISCV_INS_C_MUL, + RISCV_INS_C_MV, + RISCV_INS_C_NOP, + RISCV_INS_C_NOT, + RISCV_INS_C_OR, + RISCV_INS_C_SB, + RISCV_INS_C_SD, + RISCV_INS_C_SDSP, + RISCV_INS_C_SEXT_B, + RISCV_INS_C_SEXT_H, + RISCV_INS_C_SH, + RISCV_INS_C_SLLI, + RISCV_INS_C_SLLI64, + RISCV_INS_C_SRAI, + RISCV_INS_C_SRAI64, + RISCV_INS_C_SRLI, + RISCV_INS_C_SRLI64, + RISCV_INS_C_SSPOPCHK, + RISCV_INS_C_SSPUSH, + RISCV_INS_C_SUB, + RISCV_INS_C_SUBW, + RISCV_INS_C_SW, + RISCV_INS_C_SWSP, + RISCV_INS_C_UNIMP, + RISCV_INS_C_XOR, + RISCV_INS_C_ZEXT_B, + RISCV_INS_C_ZEXT_H, + RISCV_INS_C_ZEXT_W, + RISCV_INS_DIV, + RISCV_INS_DIVU, + RISCV_INS_DIVUW, + RISCV_INS_DIVW, + RISCV_INS_DRET, + RISCV_INS_EBREAK, + RISCV_INS_ECALL, + RISCV_INS_FADD_D, + RISCV_INS_FADD_H, + RISCV_INS_FADD_S, + RISCV_INS_FCLASS_D, + RISCV_INS_FCLASS_H, + RISCV_INS_FCLASS_S, + RISCV_INS_FCVTMOD_W_D, + RISCV_INS_FCVT_BF16_S, + RISCV_INS_FCVT_D_H, + RISCV_INS_FCVT_D_L, + RISCV_INS_FCVT_D_LU, + RISCV_INS_FCVT_D_S, + RISCV_INS_FCVT_D_W, + RISCV_INS_FCVT_D_WU, + RISCV_INS_FCVT_H_D, + RISCV_INS_FCVT_H_L, + RISCV_INS_FCVT_H_LU, + RISCV_INS_FCVT_H_S, + RISCV_INS_FCVT_H_W, + RISCV_INS_FCVT_H_WU, + RISCV_INS_FCVT_LU_D, + RISCV_INS_FCVT_LU_H, + RISCV_INS_FCVT_LU_S, + RISCV_INS_FCVT_L_D, + RISCV_INS_FCVT_L_H, + RISCV_INS_FCVT_L_S, + RISCV_INS_FCVT_S_BF16, + RISCV_INS_FCVT_S_D, + RISCV_INS_FCVT_S_H, + RISCV_INS_FCVT_S_L, + RISCV_INS_FCVT_S_LU, + RISCV_INS_FCVT_S_W, + RISCV_INS_FCVT_S_WU, + RISCV_INS_FCVT_WU_D, + RISCV_INS_FCVT_WU_H, + RISCV_INS_FCVT_WU_S, + RISCV_INS_FCVT_W_D, + RISCV_INS_FCVT_W_H, + RISCV_INS_FCVT_W_S, + RISCV_INS_FDIV_D, + RISCV_INS_FDIV_H, + RISCV_INS_FDIV_S, + RISCV_INS_FENCE, + RISCV_INS_FENCE_I, + RISCV_INS_FENCE_TSO, + RISCV_INS_FEQ_D, + RISCV_INS_FEQ_H, + RISCV_INS_FEQ_S, + RISCV_INS_FLEQ_D, + RISCV_INS_FLEQ_H, + RISCV_INS_FLEQ_S, + RISCV_INS_FLE_D, + RISCV_INS_FLE_H, + RISCV_INS_FLE_S, + RISCV_INS_FLI_D, + RISCV_INS_FLI_H, + RISCV_INS_FLI_S, + RISCV_INS_FLTQ_D, + RISCV_INS_FLTQ_H, + RISCV_INS_FLTQ_S, + RISCV_INS_FLT_D, + RISCV_INS_FLT_H, + RISCV_INS_FLT_S, + RISCV_INS_FMADD_D, + RISCV_INS_FMADD_H, + RISCV_INS_FMADD_S, + RISCV_INS_FMAXM_D, + RISCV_INS_FMAXM_H, + RISCV_INS_FMAXM_S, + RISCV_INS_FMAX_D, + RISCV_INS_FMAX_H, + RISCV_INS_FMAX_S, + RISCV_INS_FMINM_D, + RISCV_INS_FMINM_H, + RISCV_INS_FMINM_S, + RISCV_INS_FMIN_D, + RISCV_INS_FMIN_H, + RISCV_INS_FMIN_S, + RISCV_INS_FMSUB_D, + RISCV_INS_FMSUB_H, + RISCV_INS_FMSUB_S, + RISCV_INS_FMUL_D, + RISCV_INS_FMUL_H, + RISCV_INS_FMUL_S, + RISCV_INS_FMVH_X_D, + RISCV_INS_FMVP_D_X, + RISCV_INS_FMV_D_X, + RISCV_INS_FMV_H_X, + RISCV_INS_FMV_W_X, + RISCV_INS_FMV_X_D, + RISCV_INS_FMV_X_H, + RISCV_INS_FMV_X_W, + RISCV_INS_FNMADD_D, + RISCV_INS_FNMADD_H, + RISCV_INS_FNMADD_S, + RISCV_INS_FNMSUB_D, + RISCV_INS_FNMSUB_H, + RISCV_INS_FNMSUB_S, + RISCV_INS_FROUNDNX_D, + RISCV_INS_FROUNDNX_H, + RISCV_INS_FROUNDNX_S, + RISCV_INS_FROUND_D, + RISCV_INS_FROUND_H, + RISCV_INS_FROUND_S, + RISCV_INS_FSGNJN_D, + RISCV_INS_FSGNJN_H, + RISCV_INS_FSGNJN_S, + RISCV_INS_FSGNJX_D, + RISCV_INS_FSGNJX_H, + RISCV_INS_FSGNJX_S, + RISCV_INS_FSGNJ_D, + RISCV_INS_FSGNJ_H, + RISCV_INS_FSGNJ_S, + RISCV_INS_FSQRT_D, + RISCV_INS_FSQRT_H, + RISCV_INS_FSQRT_S, + RISCV_INS_FSUB_D, + RISCV_INS_FSUB_H, + RISCV_INS_FSUB_S, + RISCV_INS_HFENCE_GVMA, + RISCV_INS_HFENCE_VVMA, + RISCV_INS_HINVAL_GVMA, + RISCV_INS_HINVAL_VVMA, + RISCV_INS_HLVX_HU, + RISCV_INS_HLVX_WU, + RISCV_INS_HLV_B, + RISCV_INS_HLV_BU, + RISCV_INS_HLV_D, + RISCV_INS_HLV_H, + RISCV_INS_HLV_HU, + RISCV_INS_HLV_W, + RISCV_INS_HLV_WU, + RISCV_INS_HSV_B, + RISCV_INS_HSV_D, + RISCV_INS_HSV_H, + RISCV_INS_HSV_W, + RISCV_INS_JAL, + RISCV_INS_LR_D, + RISCV_INS_LR_D_AQ, + RISCV_INS_LR_D_AQRL, + RISCV_INS_LR_D_RL, + RISCV_INS_LR_W, + RISCV_INS_LR_W_AQ, + RISCV_INS_LR_W_AQRL, + RISCV_INS_LR_W_RL, + RISCV_INS_LUI, + RISCV_INS_MAX, + RISCV_INS_MAXU, + RISCV_INS_MIN, + RISCV_INS_MINU, + RISCV_INS_MOP_R_0, + RISCV_INS_MOP_R_1, + RISCV_INS_MOP_R_10, + RISCV_INS_MOP_R_11, + RISCV_INS_MOP_R_12, + RISCV_INS_MOP_R_13, + RISCV_INS_MOP_R_14, + RISCV_INS_MOP_R_15, + RISCV_INS_MOP_R_16, + RISCV_INS_MOP_R_17, + RISCV_INS_MOP_R_18, + RISCV_INS_MOP_R_19, + RISCV_INS_MOP_R_2, + RISCV_INS_MOP_R_20, + RISCV_INS_MOP_R_21, + RISCV_INS_MOP_R_22, + RISCV_INS_MOP_R_23, + RISCV_INS_MOP_R_24, + RISCV_INS_MOP_R_25, + RISCV_INS_MOP_R_26, + RISCV_INS_MOP_R_27, + RISCV_INS_MOP_R_28, + RISCV_INS_MOP_R_29, + RISCV_INS_MOP_R_3, + RISCV_INS_MOP_R_30, + RISCV_INS_MOP_R_31, + RISCV_INS_MOP_R_4, + RISCV_INS_MOP_R_5, + RISCV_INS_MOP_R_6, + RISCV_INS_MOP_R_7, + RISCV_INS_MOP_R_8, + RISCV_INS_MOP_R_9, + RISCV_INS_MOP_RR_0, + RISCV_INS_MOP_RR_1, + RISCV_INS_MOP_RR_2, + RISCV_INS_MOP_RR_3, + RISCV_INS_MOP_RR_4, + RISCV_INS_MOP_RR_5, + RISCV_INS_MOP_RR_6, + RISCV_INS_MOP_RR_7, + RISCV_INS_MRET, + RISCV_INS_MUL, + RISCV_INS_MULH, + RISCV_INS_MULHSU, + RISCV_INS_MULHU, + RISCV_INS_MULW, + RISCV_INS_OR, + RISCV_INS_ORC_B, + RISCV_INS_ORI, + RISCV_INS_ORN, + RISCV_INS_PACK, + RISCV_INS_PACKH, + RISCV_INS_PACKW, + RISCV_INS_PREFETCH_I, + RISCV_INS_PREFETCH_R, + RISCV_INS_PREFETCH_W, + RISCV_INS_REM, + RISCV_INS_REMU, + RISCV_INS_REMUW, + RISCV_INS_REMW, + RISCV_INS_REV8, + RISCV_INS_ROL, + RISCV_INS_ROLW, + RISCV_INS_ROR, + RISCV_INS_RORI, + RISCV_INS_RORIW, + RISCV_INS_RORW, + RISCV_INS_SC_D, + RISCV_INS_SC_D_AQ, + RISCV_INS_SC_D_AQRL, + RISCV_INS_SC_D_RL, + RISCV_INS_SC_W, + RISCV_INS_SC_W_AQ, + RISCV_INS_SC_W_AQRL, + RISCV_INS_SC_W_RL, + RISCV_INS_SFENCE_INVAL_IR, + RISCV_INS_SFENCE_VMA, + RISCV_INS_SFENCE_W_INVAL, + RISCV_INS_SH1ADD, + RISCV_INS_SH1ADD_UW, + RISCV_INS_SH2ADD, + RISCV_INS_SH2ADD_UW, + RISCV_INS_SH3ADD, + RISCV_INS_SH3ADD_UW, + RISCV_INS_SHA256SIG0, + RISCV_INS_SHA256SIG1, + RISCV_INS_SHA256SUM0, + RISCV_INS_SHA256SUM1, + RISCV_INS_SHA512SIG0, + RISCV_INS_SHA512SIG0H, + RISCV_INS_SHA512SIG0L, + RISCV_INS_SHA512SIG1, + RISCV_INS_SHA512SIG1H, + RISCV_INS_SHA512SIG1L, + RISCV_INS_SHA512SUM0, + RISCV_INS_SHA512SUM0R, + RISCV_INS_SHA512SUM1, + RISCV_INS_SHA512SUM1R, + RISCV_INS_SINVAL_VMA, + RISCV_INS_SLL, + RISCV_INS_SLLI, + RISCV_INS_SLLIW, + RISCV_INS_SLLI_UW, + RISCV_INS_SLLW, + RISCV_INS_SLT, + RISCV_INS_SLTI, + RISCV_INS_SLTIU, + RISCV_INS_SLTU, + RISCV_INS_SM3P0, + RISCV_INS_SM3P1, + RISCV_INS_SM4ED, + RISCV_INS_SM4KS, + RISCV_INS_SRA, + RISCV_INS_SRAI, + RISCV_INS_SRAIW, + RISCV_INS_SRAW, + RISCV_INS_SRET, + RISCV_INS_SRL, + RISCV_INS_SRLI, + RISCV_INS_SRLIW, + RISCV_INS_SRLW, + RISCV_INS_SSAMOSWAP_D, + RISCV_INS_SSAMOSWAP_D_AQ, + RISCV_INS_SSAMOSWAP_D_AQRL, + RISCV_INS_SSAMOSWAP_D_RL, + RISCV_INS_SSAMOSWAP_W, + RISCV_INS_SSAMOSWAP_W_AQ, + RISCV_INS_SSAMOSWAP_W_AQRL, + RISCV_INS_SSAMOSWAP_W_RL, + RISCV_INS_SSPOPCHK, + RISCV_INS_SSPUSH, + RISCV_INS_SSRDP, + RISCV_INS_SUB, + RISCV_INS_SUBW, + RISCV_INS_TH_VMAQASU_VV, + RISCV_INS_TH_VMAQASU_VX, + RISCV_INS_TH_VMAQAUS_VX, + RISCV_INS_TH_VMAQAU_VV, + RISCV_INS_TH_VMAQAU_VX, + RISCV_INS_TH_VMAQA_VV, + RISCV_INS_TH_VMAQA_VX, + RISCV_INS_TH_ADDSL, + RISCV_INS_TH_DCACHE_CALL, + RISCV_INS_TH_DCACHE_CIALL, + RISCV_INS_TH_DCACHE_CIPA, + RISCV_INS_TH_DCACHE_CISW, + RISCV_INS_TH_DCACHE_CIVA, + RISCV_INS_TH_DCACHE_CPA, + RISCV_INS_TH_DCACHE_CPAL1, + RISCV_INS_TH_DCACHE_CSW, + RISCV_INS_TH_DCACHE_CVA, + RISCV_INS_TH_DCACHE_CVAL1, + RISCV_INS_TH_DCACHE_IALL, + RISCV_INS_TH_DCACHE_IPA, + RISCV_INS_TH_DCACHE_ISW, + RISCV_INS_TH_DCACHE_IVA, + RISCV_INS_TH_EXT, + RISCV_INS_TH_EXTU, + RISCV_INS_TH_FF0, + RISCV_INS_TH_FF1, + RISCV_INS_TH_FLRD, + RISCV_INS_TH_FLRW, + RISCV_INS_TH_FLURD, + RISCV_INS_TH_FLURW, + RISCV_INS_TH_FSRD, + RISCV_INS_TH_FSRW, + RISCV_INS_TH_FSURD, + RISCV_INS_TH_FSURW, + RISCV_INS_TH_ICACHE_IALL, + RISCV_INS_TH_ICACHE_IALLS, + RISCV_INS_TH_ICACHE_IPA, + RISCV_INS_TH_ICACHE_IVA, + RISCV_INS_TH_L2CACHE_CALL, + RISCV_INS_TH_L2CACHE_CIALL, + RISCV_INS_TH_L2CACHE_IALL, + RISCV_INS_TH_LBIA, + RISCV_INS_TH_LBIB, + RISCV_INS_TH_LBUIA, + RISCV_INS_TH_LBUIB, + RISCV_INS_TH_LDD, + RISCV_INS_TH_LDIA, + RISCV_INS_TH_LDIB, + RISCV_INS_TH_LHIA, + RISCV_INS_TH_LHIB, + RISCV_INS_TH_LHUIA, + RISCV_INS_TH_LHUIB, + RISCV_INS_TH_LRB, + RISCV_INS_TH_LRBU, + RISCV_INS_TH_LRD, + RISCV_INS_TH_LRH, + RISCV_INS_TH_LRHU, + RISCV_INS_TH_LRW, + RISCV_INS_TH_LRWU, + RISCV_INS_TH_LURB, + RISCV_INS_TH_LURBU, + RISCV_INS_TH_LURD, + RISCV_INS_TH_LURH, + RISCV_INS_TH_LURHU, + RISCV_INS_TH_LURW, + RISCV_INS_TH_LURWU, + RISCV_INS_TH_LWD, + RISCV_INS_TH_LWIA, + RISCV_INS_TH_LWIB, + RISCV_INS_TH_LWUD, + RISCV_INS_TH_LWUIA, + RISCV_INS_TH_LWUIB, + RISCV_INS_TH_MULA, + RISCV_INS_TH_MULAH, + RISCV_INS_TH_MULAW, + RISCV_INS_TH_MULS, + RISCV_INS_TH_MULSH, + RISCV_INS_TH_MULSW, + RISCV_INS_TH_MVEQZ, + RISCV_INS_TH_MVNEZ, + RISCV_INS_TH_REV, + RISCV_INS_TH_REVW, + RISCV_INS_TH_SBIA, + RISCV_INS_TH_SBIB, + RISCV_INS_TH_SDD, + RISCV_INS_TH_SDIA, + RISCV_INS_TH_SDIB, + RISCV_INS_TH_SFENCE_VMAS, + RISCV_INS_TH_SHIA, + RISCV_INS_TH_SHIB, + RISCV_INS_TH_SRB, + RISCV_INS_TH_SRD, + RISCV_INS_TH_SRH, + RISCV_INS_TH_SRRI, + RISCV_INS_TH_SRRIW, + RISCV_INS_TH_SRW, + RISCV_INS_TH_SURB, + RISCV_INS_TH_SURD, + RISCV_INS_TH_SURH, + RISCV_INS_TH_SURW, + RISCV_INS_TH_SWD, + RISCV_INS_TH_SWIA, + RISCV_INS_TH_SWIB, + RISCV_INS_TH_SYNC, + RISCV_INS_TH_SYNC_I, + RISCV_INS_TH_SYNC_IS, + RISCV_INS_TH_SYNC_S, + RISCV_INS_TH_TST, + RISCV_INS_TH_TSTNBZ, + RISCV_INS_UNIMP, + RISCV_INS_UNZIP, + RISCV_INS_VAADDU_VV, + RISCV_INS_VAADDU_VX, + RISCV_INS_VAADD_VV, + RISCV_INS_VAADD_VX, + RISCV_INS_VADC_VIM, + RISCV_INS_VADC_VVM, + RISCV_INS_VADC_VXM, + RISCV_INS_VADD_VI, + RISCV_INS_VADD_VV, + RISCV_INS_VADD_VX, + RISCV_INS_VAESDF_VS, + RISCV_INS_VAESDF_VV, + RISCV_INS_VAESDM_VS, + RISCV_INS_VAESDM_VV, + RISCV_INS_VAESEF_VS, + RISCV_INS_VAESEF_VV, + RISCV_INS_VAESEM_VS, + RISCV_INS_VAESEM_VV, + RISCV_INS_VAESKF1_VI, + RISCV_INS_VAESKF2_VI, + RISCV_INS_VAESZ_VS, + RISCV_INS_VANDN_VV, + RISCV_INS_VANDN_VX, + RISCV_INS_VAND_VI, + RISCV_INS_VAND_VV, + RISCV_INS_VAND_VX, + RISCV_INS_VASUBU_VV, + RISCV_INS_VASUBU_VX, + RISCV_INS_VASUB_VV, + RISCV_INS_VASUB_VX, + RISCV_INS_VBREV8_V, + RISCV_INS_VBREV_V, + RISCV_INS_VCLMULH_VV, + RISCV_INS_VCLMULH_VX, + RISCV_INS_VCLMUL_VV, + RISCV_INS_VCLMUL_VX, + RISCV_INS_VCLZ_V, + RISCV_INS_VCOMPRESS_VM, + RISCV_INS_VCPOP_M, + RISCV_INS_VCPOP_V, + RISCV_INS_VCTZ_V, + RISCV_INS_SF_VC_FV, + RISCV_INS_SF_VC_FVV, + RISCV_INS_SF_VC_FVW, + RISCV_INS_SF_VC_I, + RISCV_INS_SF_VC_IV, + RISCV_INS_SF_VC_IVV, + RISCV_INS_SF_VC_IVW, + RISCV_INS_SF_VC_VV, + RISCV_INS_SF_VC_VVV, + RISCV_INS_SF_VC_VVW, + RISCV_INS_SF_VC_V_FV, + RISCV_INS_SF_VC_V_FVV, + RISCV_INS_SF_VC_V_FVW, + RISCV_INS_SF_VC_V_I, + RISCV_INS_SF_VC_V_IV, + RISCV_INS_SF_VC_V_IVV, + RISCV_INS_SF_VC_V_IVW, + RISCV_INS_SF_VC_V_VV, + RISCV_INS_SF_VC_V_VVV, + RISCV_INS_SF_VC_V_VVW, + RISCV_INS_SF_VC_V_X, + RISCV_INS_SF_VC_V_XV, + RISCV_INS_SF_VC_V_XVV, + RISCV_INS_SF_VC_V_XVW, + RISCV_INS_SF_VC_X, + RISCV_INS_SF_VC_XV, + RISCV_INS_SF_VC_XVV, + RISCV_INS_SF_VC_XVW, + RISCV_INS_VDIVU_VV, + RISCV_INS_VDIVU_VX, + RISCV_INS_VDIV_VV, + RISCV_INS_VDIV_VX, + RISCV_INS_VFADD_VF, + RISCV_INS_VFADD_VV, + RISCV_INS_VFCLASS_V, + RISCV_INS_VFCVT_F_XU_V, + RISCV_INS_VFCVT_F_X_V, + RISCV_INS_VFCVT_RTZ_XU_F_V, + RISCV_INS_VFCVT_RTZ_X_F_V, + RISCV_INS_VFCVT_XU_F_V, + RISCV_INS_VFCVT_X_F_V, + RISCV_INS_VFDIV_VF, + RISCV_INS_VFDIV_VV, + RISCV_INS_VFIRST_M, + RISCV_INS_VFMACC_VF, + RISCV_INS_VFMACC_VV, + RISCV_INS_VFMADD_VF, + RISCV_INS_VFMADD_VV, + RISCV_INS_VFMAX_VF, + RISCV_INS_VFMAX_VV, + RISCV_INS_VFMERGE_VFM, + RISCV_INS_VFMIN_VF, + RISCV_INS_VFMIN_VV, + RISCV_INS_VFMSAC_VF, + RISCV_INS_VFMSAC_VV, + RISCV_INS_VFMSUB_VF, + RISCV_INS_VFMSUB_VV, + RISCV_INS_VFMUL_VF, + RISCV_INS_VFMUL_VV, + RISCV_INS_VFMV_F_S, + RISCV_INS_VFMV_S_F, + RISCV_INS_VFMV_V_F, + RISCV_INS_VFNCVTBF16_F_F_W, + RISCV_INS_VFNCVT_F_F_W, + RISCV_INS_VFNCVT_F_XU_W, + RISCV_INS_VFNCVT_F_X_W, + RISCV_INS_VFNCVT_ROD_F_F_W, + RISCV_INS_VFNCVT_RTZ_XU_F_W, + RISCV_INS_VFNCVT_RTZ_X_F_W, + RISCV_INS_VFNCVT_XU_F_W, + RISCV_INS_VFNCVT_X_F_W, + RISCV_INS_VFNMACC_VF, + RISCV_INS_VFNMACC_VV, + RISCV_INS_VFNMADD_VF, + RISCV_INS_VFNMADD_VV, + RISCV_INS_VFNMSAC_VF, + RISCV_INS_VFNMSAC_VV, + RISCV_INS_VFNMSUB_VF, + RISCV_INS_VFNMSUB_VV, + RISCV_INS_SF_VFNRCLIP_XU_F_QF, + RISCV_INS_SF_VFNRCLIP_X_F_QF, + RISCV_INS_VFRDIV_VF, + RISCV_INS_VFREC7_V, + RISCV_INS_VFREDMAX_VS, + RISCV_INS_VFREDMIN_VS, + RISCV_INS_VFREDOSUM_VS, + RISCV_INS_VFREDUSUM_VS, + RISCV_INS_VFRSQRT7_V, + RISCV_INS_VFRSUB_VF, + RISCV_INS_VFSGNJN_VF, + RISCV_INS_VFSGNJN_VV, + RISCV_INS_VFSGNJX_VF, + RISCV_INS_VFSGNJX_VV, + RISCV_INS_VFSGNJ_VF, + RISCV_INS_VFSGNJ_VV, + RISCV_INS_VFSLIDE1DOWN_VF, + RISCV_INS_VFSLIDE1UP_VF, + RISCV_INS_VFSQRT_V, + RISCV_INS_VFSUB_VF, + RISCV_INS_VFSUB_VV, + RISCV_INS_VFWADD_VF, + RISCV_INS_VFWADD_VV, + RISCV_INS_VFWADD_WF, + RISCV_INS_VFWADD_WV, + RISCV_INS_VFWCVTBF16_F_F_V, + RISCV_INS_VFWCVT_F_F_V, + RISCV_INS_VFWCVT_F_XU_V, + RISCV_INS_VFWCVT_F_X_V, + RISCV_INS_VFWCVT_RTZ_XU_F_V, + RISCV_INS_VFWCVT_RTZ_X_F_V, + RISCV_INS_VFWCVT_XU_F_V, + RISCV_INS_VFWCVT_X_F_V, + RISCV_INS_VFWMACCBF16_VF, + RISCV_INS_VFWMACCBF16_VV, + RISCV_INS_SF_VFWMACC_4X4X4, + RISCV_INS_VFWMACC_VF, + RISCV_INS_VFWMACC_VV, + RISCV_INS_VFWMSAC_VF, + RISCV_INS_VFWMSAC_VV, + RISCV_INS_VFWMUL_VF, + RISCV_INS_VFWMUL_VV, + RISCV_INS_VFWNMACC_VF, + RISCV_INS_VFWNMACC_VV, + RISCV_INS_VFWNMSAC_VF, + RISCV_INS_VFWNMSAC_VV, + RISCV_INS_VFWREDOSUM_VS, + RISCV_INS_VFWREDUSUM_VS, + RISCV_INS_VFWSUB_VF, + RISCV_INS_VFWSUB_VV, + RISCV_INS_VFWSUB_WF, + RISCV_INS_VFWSUB_WV, + RISCV_INS_VGHSH_VV, + RISCV_INS_VGMUL_VV, + RISCV_INS_VID_V, + RISCV_INS_VIOTA_M, + RISCV_INS_VL1RE16_V, + RISCV_INS_VL1RE32_V, + RISCV_INS_VL1RE64_V, + RISCV_INS_VL1RE8_V, + RISCV_INS_VL2RE16_V, + RISCV_INS_VL2RE32_V, + RISCV_INS_VL2RE64_V, + RISCV_INS_VL2RE8_V, + RISCV_INS_VL4RE16_V, + RISCV_INS_VL4RE32_V, + RISCV_INS_VL4RE64_V, + RISCV_INS_VL4RE8_V, + RISCV_INS_VL8RE16_V, + RISCV_INS_VL8RE32_V, + RISCV_INS_VL8RE64_V, + RISCV_INS_VL8RE8_V, + RISCV_INS_VLE16FF_V, + RISCV_INS_VLE16_V, + RISCV_INS_VLE32FF_V, + RISCV_INS_VLE32_V, + RISCV_INS_VLE64FF_V, + RISCV_INS_VLE64_V, + RISCV_INS_VLE8FF_V, + RISCV_INS_VLE8_V, + RISCV_INS_VLM_V, + RISCV_INS_VLOXEI16_V, + RISCV_INS_VLOXEI32_V, + RISCV_INS_VLOXEI64_V, + RISCV_INS_VLOXEI8_V, + RISCV_INS_VLOXSEG2EI16_V, + RISCV_INS_VLOXSEG2EI32_V, + RISCV_INS_VLOXSEG2EI64_V, + RISCV_INS_VLOXSEG2EI8_V, + RISCV_INS_VLOXSEG3EI16_V, + RISCV_INS_VLOXSEG3EI32_V, + RISCV_INS_VLOXSEG3EI64_V, + RISCV_INS_VLOXSEG3EI8_V, + RISCV_INS_VLOXSEG4EI16_V, + RISCV_INS_VLOXSEG4EI32_V, + RISCV_INS_VLOXSEG4EI64_V, + RISCV_INS_VLOXSEG4EI8_V, + RISCV_INS_VLOXSEG5EI16_V, + RISCV_INS_VLOXSEG5EI32_V, + RISCV_INS_VLOXSEG5EI64_V, + RISCV_INS_VLOXSEG5EI8_V, + RISCV_INS_VLOXSEG6EI16_V, + RISCV_INS_VLOXSEG6EI32_V, + RISCV_INS_VLOXSEG6EI64_V, + RISCV_INS_VLOXSEG6EI8_V, + RISCV_INS_VLOXSEG7EI16_V, + RISCV_INS_VLOXSEG7EI32_V, + RISCV_INS_VLOXSEG7EI64_V, + RISCV_INS_VLOXSEG7EI8_V, + RISCV_INS_VLOXSEG8EI16_V, + RISCV_INS_VLOXSEG8EI32_V, + RISCV_INS_VLOXSEG8EI64_V, + RISCV_INS_VLOXSEG8EI8_V, + RISCV_INS_VLSE16_V, + RISCV_INS_VLSE32_V, + RISCV_INS_VLSE64_V, + RISCV_INS_VLSE8_V, + RISCV_INS_VLSEG2E16FF_V, + RISCV_INS_VLSEG2E16_V, + RISCV_INS_VLSEG2E32FF_V, + RISCV_INS_VLSEG2E32_V, + RISCV_INS_VLSEG2E64FF_V, + RISCV_INS_VLSEG2E64_V, + RISCV_INS_VLSEG2E8FF_V, + RISCV_INS_VLSEG2E8_V, + RISCV_INS_VLSEG3E16FF_V, + RISCV_INS_VLSEG3E16_V, + RISCV_INS_VLSEG3E32FF_V, + RISCV_INS_VLSEG3E32_V, + RISCV_INS_VLSEG3E64FF_V, + RISCV_INS_VLSEG3E64_V, + RISCV_INS_VLSEG3E8FF_V, + RISCV_INS_VLSEG3E8_V, + RISCV_INS_VLSEG4E16FF_V, + RISCV_INS_VLSEG4E16_V, + RISCV_INS_VLSEG4E32FF_V, + RISCV_INS_VLSEG4E32_V, + RISCV_INS_VLSEG4E64FF_V, + RISCV_INS_VLSEG4E64_V, + RISCV_INS_VLSEG4E8FF_V, + RISCV_INS_VLSEG4E8_V, + RISCV_INS_VLSEG5E16FF_V, + RISCV_INS_VLSEG5E16_V, + RISCV_INS_VLSEG5E32FF_V, + RISCV_INS_VLSEG5E32_V, + RISCV_INS_VLSEG5E64FF_V, + RISCV_INS_VLSEG5E64_V, + RISCV_INS_VLSEG5E8FF_V, + RISCV_INS_VLSEG5E8_V, + RISCV_INS_VLSEG6E16FF_V, + RISCV_INS_VLSEG6E16_V, + RISCV_INS_VLSEG6E32FF_V, + RISCV_INS_VLSEG6E32_V, + RISCV_INS_VLSEG6E64FF_V, + RISCV_INS_VLSEG6E64_V, + RISCV_INS_VLSEG6E8FF_V, + RISCV_INS_VLSEG6E8_V, + RISCV_INS_VLSEG7E16FF_V, + RISCV_INS_VLSEG7E16_V, + RISCV_INS_VLSEG7E32FF_V, + RISCV_INS_VLSEG7E32_V, + RISCV_INS_VLSEG7E64FF_V, + RISCV_INS_VLSEG7E64_V, + RISCV_INS_VLSEG7E8FF_V, + RISCV_INS_VLSEG7E8_V, + RISCV_INS_VLSEG8E16FF_V, + RISCV_INS_VLSEG8E16_V, + RISCV_INS_VLSEG8E32FF_V, + RISCV_INS_VLSEG8E32_V, + RISCV_INS_VLSEG8E64FF_V, + RISCV_INS_VLSEG8E64_V, + RISCV_INS_VLSEG8E8FF_V, + RISCV_INS_VLSEG8E8_V, + RISCV_INS_VLSSEG2E16_V, + RISCV_INS_VLSSEG2E32_V, + RISCV_INS_VLSSEG2E64_V, + RISCV_INS_VLSSEG2E8_V, + RISCV_INS_VLSSEG3E16_V, + RISCV_INS_VLSSEG3E32_V, + RISCV_INS_VLSSEG3E64_V, + RISCV_INS_VLSSEG3E8_V, + RISCV_INS_VLSSEG4E16_V, + RISCV_INS_VLSSEG4E32_V, + RISCV_INS_VLSSEG4E64_V, + RISCV_INS_VLSSEG4E8_V, + RISCV_INS_VLSSEG5E16_V, + RISCV_INS_VLSSEG5E32_V, + RISCV_INS_VLSSEG5E64_V, + RISCV_INS_VLSSEG5E8_V, + RISCV_INS_VLSSEG6E16_V, + RISCV_INS_VLSSEG6E32_V, + RISCV_INS_VLSSEG6E64_V, + RISCV_INS_VLSSEG6E8_V, + RISCV_INS_VLSSEG7E16_V, + RISCV_INS_VLSSEG7E32_V, + RISCV_INS_VLSSEG7E64_V, + RISCV_INS_VLSSEG7E8_V, + RISCV_INS_VLSSEG8E16_V, + RISCV_INS_VLSSEG8E32_V, + RISCV_INS_VLSSEG8E64_V, + RISCV_INS_VLSSEG8E8_V, + RISCV_INS_VLUXEI16_V, + RISCV_INS_VLUXEI32_V, + RISCV_INS_VLUXEI64_V, + RISCV_INS_VLUXEI8_V, + RISCV_INS_VLUXSEG2EI16_V, + RISCV_INS_VLUXSEG2EI32_V, + RISCV_INS_VLUXSEG2EI64_V, + RISCV_INS_VLUXSEG2EI8_V, + RISCV_INS_VLUXSEG3EI16_V, + RISCV_INS_VLUXSEG3EI32_V, + RISCV_INS_VLUXSEG3EI64_V, + RISCV_INS_VLUXSEG3EI8_V, + RISCV_INS_VLUXSEG4EI16_V, + RISCV_INS_VLUXSEG4EI32_V, + RISCV_INS_VLUXSEG4EI64_V, + RISCV_INS_VLUXSEG4EI8_V, + RISCV_INS_VLUXSEG5EI16_V, + RISCV_INS_VLUXSEG5EI32_V, + RISCV_INS_VLUXSEG5EI64_V, + RISCV_INS_VLUXSEG5EI8_V, + RISCV_INS_VLUXSEG6EI16_V, + RISCV_INS_VLUXSEG6EI32_V, + RISCV_INS_VLUXSEG6EI64_V, + RISCV_INS_VLUXSEG6EI8_V, + RISCV_INS_VLUXSEG7EI16_V, + RISCV_INS_VLUXSEG7EI32_V, + RISCV_INS_VLUXSEG7EI64_V, + RISCV_INS_VLUXSEG7EI8_V, + RISCV_INS_VLUXSEG8EI16_V, + RISCV_INS_VLUXSEG8EI32_V, + RISCV_INS_VLUXSEG8EI64_V, + RISCV_INS_VLUXSEG8EI8_V, + RISCV_INS_VMACC_VV, + RISCV_INS_VMACC_VX, + RISCV_INS_VMADC_VI, + RISCV_INS_VMADC_VIM, + RISCV_INS_VMADC_VV, + RISCV_INS_VMADC_VVM, + RISCV_INS_VMADC_VX, + RISCV_INS_VMADC_VXM, + RISCV_INS_VMADD_VV, + RISCV_INS_VMADD_VX, + RISCV_INS_VMANDN_MM, + RISCV_INS_VMAND_MM, + RISCV_INS_VMAXU_VV, + RISCV_INS_VMAXU_VX, + RISCV_INS_VMAX_VV, + RISCV_INS_VMAX_VX, + RISCV_INS_VMERGE_VIM, + RISCV_INS_VMERGE_VVM, + RISCV_INS_VMERGE_VXM, + RISCV_INS_VMFEQ_VF, + RISCV_INS_VMFEQ_VV, + RISCV_INS_VMFGE_VF, + RISCV_INS_VMFGT_VF, + RISCV_INS_VMFLE_VF, + RISCV_INS_VMFLE_VV, + RISCV_INS_VMFLT_VF, + RISCV_INS_VMFLT_VV, + RISCV_INS_VMFNE_VF, + RISCV_INS_VMFNE_VV, + RISCV_INS_VMINU_VV, + RISCV_INS_VMINU_VX, + RISCV_INS_VMIN_VV, + RISCV_INS_VMIN_VX, + RISCV_INS_VMNAND_MM, + RISCV_INS_VMNOR_MM, + RISCV_INS_VMORN_MM, + RISCV_INS_VMOR_MM, + RISCV_INS_VMSBC_VV, + RISCV_INS_VMSBC_VVM, + RISCV_INS_VMSBC_VX, + RISCV_INS_VMSBC_VXM, + RISCV_INS_VMSBF_M, + RISCV_INS_VMSEQ_VI, + RISCV_INS_VMSEQ_VV, + RISCV_INS_VMSEQ_VX, + RISCV_INS_VMSGTU_VI, + RISCV_INS_VMSGTU_VX, + RISCV_INS_VMSGT_VI, + RISCV_INS_VMSGT_VX, + RISCV_INS_VMSIF_M, + RISCV_INS_VMSLEU_VI, + RISCV_INS_VMSLEU_VV, + RISCV_INS_VMSLEU_VX, + RISCV_INS_VMSLE_VI, + RISCV_INS_VMSLE_VV, + RISCV_INS_VMSLE_VX, + RISCV_INS_VMSLTU_VV, + RISCV_INS_VMSLTU_VX, + RISCV_INS_VMSLT_VV, + RISCV_INS_VMSLT_VX, + RISCV_INS_VMSNE_VI, + RISCV_INS_VMSNE_VV, + RISCV_INS_VMSNE_VX, + RISCV_INS_VMSOF_M, + RISCV_INS_VMULHSU_VV, + RISCV_INS_VMULHSU_VX, + RISCV_INS_VMULHU_VV, + RISCV_INS_VMULHU_VX, + RISCV_INS_VMULH_VV, + RISCV_INS_VMULH_VX, + RISCV_INS_VMUL_VV, + RISCV_INS_VMUL_VX, + RISCV_INS_VMV1R_V, + RISCV_INS_VMV2R_V, + RISCV_INS_VMV4R_V, + RISCV_INS_VMV8R_V, + RISCV_INS_VMV_S_X, + RISCV_INS_VMV_V_I, + RISCV_INS_VMV_V_V, + RISCV_INS_VMV_V_X, + RISCV_INS_VMV_X_S, + RISCV_INS_VMXNOR_MM, + RISCV_INS_VMXOR_MM, + RISCV_INS_VNCLIPU_WI, + RISCV_INS_VNCLIPU_WV, + RISCV_INS_VNCLIPU_WX, + RISCV_INS_VNCLIP_WI, + RISCV_INS_VNCLIP_WV, + RISCV_INS_VNCLIP_WX, + RISCV_INS_VNMSAC_VV, + RISCV_INS_VNMSAC_VX, + RISCV_INS_VNMSUB_VV, + RISCV_INS_VNMSUB_VX, + RISCV_INS_VNSRA_WI, + RISCV_INS_VNSRA_WV, + RISCV_INS_VNSRA_WX, + RISCV_INS_VNSRL_WI, + RISCV_INS_VNSRL_WV, + RISCV_INS_VNSRL_WX, + RISCV_INS_VOR_VI, + RISCV_INS_VOR_VV, + RISCV_INS_VOR_VX, + RISCV_INS_SF_VQMACCSU_2X8X2, + RISCV_INS_SF_VQMACCSU_4X8X4, + RISCV_INS_SF_VQMACCUS_2X8X2, + RISCV_INS_SF_VQMACCUS_4X8X4, + RISCV_INS_SF_VQMACCU_2X8X2, + RISCV_INS_SF_VQMACCU_4X8X4, + RISCV_INS_SF_VQMACC_2X8X2, + RISCV_INS_SF_VQMACC_4X8X4, + RISCV_INS_VREDAND_VS, + RISCV_INS_VREDMAXU_VS, + RISCV_INS_VREDMAX_VS, + RISCV_INS_VREDMINU_VS, + RISCV_INS_VREDMIN_VS, + RISCV_INS_VREDOR_VS, + RISCV_INS_VREDSUM_VS, + RISCV_INS_VREDXOR_VS, + RISCV_INS_VREMU_VV, + RISCV_INS_VREMU_VX, + RISCV_INS_VREM_VV, + RISCV_INS_VREM_VX, + RISCV_INS_VREV8_V, + RISCV_INS_VRGATHEREI16_VV, + RISCV_INS_VRGATHER_VI, + RISCV_INS_VRGATHER_VV, + RISCV_INS_VRGATHER_VX, + RISCV_INS_VROL_VV, + RISCV_INS_VROL_VX, + RISCV_INS_VROR_VI, + RISCV_INS_VROR_VV, + RISCV_INS_VROR_VX, + RISCV_INS_VRSUB_VI, + RISCV_INS_VRSUB_VX, + RISCV_INS_VS1R_V, + RISCV_INS_VS2R_V, + RISCV_INS_VS4R_V, + RISCV_INS_VS8R_V, + RISCV_INS_VSADDU_VI, + RISCV_INS_VSADDU_VV, + RISCV_INS_VSADDU_VX, + RISCV_INS_VSADD_VI, + RISCV_INS_VSADD_VV, + RISCV_INS_VSADD_VX, + RISCV_INS_VSBC_VVM, + RISCV_INS_VSBC_VXM, + RISCV_INS_VSE16_V, + RISCV_INS_VSE32_V, + RISCV_INS_VSE64_V, + RISCV_INS_VSE8_V, + RISCV_INS_VSETIVLI, + RISCV_INS_VSETVL, + RISCV_INS_VSETVLI, + RISCV_INS_VSEXT_VF2, + RISCV_INS_VSEXT_VF4, + RISCV_INS_VSEXT_VF8, + RISCV_INS_VSHA2CH_VV, + RISCV_INS_VSHA2CL_VV, + RISCV_INS_VSHA2MS_VV, + RISCV_INS_VSLIDE1DOWN_VX, + RISCV_INS_VSLIDE1UP_VX, + RISCV_INS_VSLIDEDOWN_VI, + RISCV_INS_VSLIDEDOWN_VX, + RISCV_INS_VSLIDEUP_VI, + RISCV_INS_VSLIDEUP_VX, + RISCV_INS_VSLL_VI, + RISCV_INS_VSLL_VV, + RISCV_INS_VSLL_VX, + RISCV_INS_VSM3C_VI, + RISCV_INS_VSM3ME_VV, + RISCV_INS_VSM4K_VI, + RISCV_INS_VSM4R_VS, + RISCV_INS_VSM4R_VV, + RISCV_INS_VSMUL_VV, + RISCV_INS_VSMUL_VX, + RISCV_INS_VSM_V, + RISCV_INS_VSOXEI16_V, + RISCV_INS_VSOXEI32_V, + RISCV_INS_VSOXEI64_V, + RISCV_INS_VSOXEI8_V, + RISCV_INS_VSOXSEG2EI16_V, + RISCV_INS_VSOXSEG2EI32_V, + RISCV_INS_VSOXSEG2EI64_V, + RISCV_INS_VSOXSEG2EI8_V, + RISCV_INS_VSOXSEG3EI16_V, + RISCV_INS_VSOXSEG3EI32_V, + RISCV_INS_VSOXSEG3EI64_V, + RISCV_INS_VSOXSEG3EI8_V, + RISCV_INS_VSOXSEG4EI16_V, + RISCV_INS_VSOXSEG4EI32_V, + RISCV_INS_VSOXSEG4EI64_V, + RISCV_INS_VSOXSEG4EI8_V, + RISCV_INS_VSOXSEG5EI16_V, + RISCV_INS_VSOXSEG5EI32_V, + RISCV_INS_VSOXSEG5EI64_V, + RISCV_INS_VSOXSEG5EI8_V, + RISCV_INS_VSOXSEG6EI16_V, + RISCV_INS_VSOXSEG6EI32_V, + RISCV_INS_VSOXSEG6EI64_V, + RISCV_INS_VSOXSEG6EI8_V, + RISCV_INS_VSOXSEG7EI16_V, + RISCV_INS_VSOXSEG7EI32_V, + RISCV_INS_VSOXSEG7EI64_V, + RISCV_INS_VSOXSEG7EI8_V, + RISCV_INS_VSOXSEG8EI16_V, + RISCV_INS_VSOXSEG8EI32_V, + RISCV_INS_VSOXSEG8EI64_V, + RISCV_INS_VSOXSEG8EI8_V, + RISCV_INS_VSRA_VI, + RISCV_INS_VSRA_VV, + RISCV_INS_VSRA_VX, + RISCV_INS_VSRL_VI, + RISCV_INS_VSRL_VV, + RISCV_INS_VSRL_VX, + RISCV_INS_VSSE16_V, + RISCV_INS_VSSE32_V, + RISCV_INS_VSSE64_V, + RISCV_INS_VSSE8_V, + RISCV_INS_VSSEG2E16_V, + RISCV_INS_VSSEG2E32_V, + RISCV_INS_VSSEG2E64_V, + RISCV_INS_VSSEG2E8_V, + RISCV_INS_VSSEG3E16_V, + RISCV_INS_VSSEG3E32_V, + RISCV_INS_VSSEG3E64_V, + RISCV_INS_VSSEG3E8_V, + RISCV_INS_VSSEG4E16_V, + RISCV_INS_VSSEG4E32_V, + RISCV_INS_VSSEG4E64_V, + RISCV_INS_VSSEG4E8_V, + RISCV_INS_VSSEG5E16_V, + RISCV_INS_VSSEG5E32_V, + RISCV_INS_VSSEG5E64_V, + RISCV_INS_VSSEG5E8_V, + RISCV_INS_VSSEG6E16_V, + RISCV_INS_VSSEG6E32_V, + RISCV_INS_VSSEG6E64_V, + RISCV_INS_VSSEG6E8_V, + RISCV_INS_VSSEG7E16_V, + RISCV_INS_VSSEG7E32_V, + RISCV_INS_VSSEG7E64_V, + RISCV_INS_VSSEG7E8_V, + RISCV_INS_VSSEG8E16_V, + RISCV_INS_VSSEG8E32_V, + RISCV_INS_VSSEG8E64_V, + RISCV_INS_VSSEG8E8_V, + RISCV_INS_VSSRA_VI, + RISCV_INS_VSSRA_VV, + RISCV_INS_VSSRA_VX, + RISCV_INS_VSSRL_VI, + RISCV_INS_VSSRL_VV, + RISCV_INS_VSSRL_VX, + RISCV_INS_VSSSEG2E16_V, + RISCV_INS_VSSSEG2E32_V, + RISCV_INS_VSSSEG2E64_V, + RISCV_INS_VSSSEG2E8_V, + RISCV_INS_VSSSEG3E16_V, + RISCV_INS_VSSSEG3E32_V, + RISCV_INS_VSSSEG3E64_V, + RISCV_INS_VSSSEG3E8_V, + RISCV_INS_VSSSEG4E16_V, + RISCV_INS_VSSSEG4E32_V, + RISCV_INS_VSSSEG4E64_V, + RISCV_INS_VSSSEG4E8_V, + RISCV_INS_VSSSEG5E16_V, + RISCV_INS_VSSSEG5E32_V, + RISCV_INS_VSSSEG5E64_V, + RISCV_INS_VSSSEG5E8_V, + RISCV_INS_VSSSEG6E16_V, + RISCV_INS_VSSSEG6E32_V, + RISCV_INS_VSSSEG6E64_V, + RISCV_INS_VSSSEG6E8_V, + RISCV_INS_VSSSEG7E16_V, + RISCV_INS_VSSSEG7E32_V, + RISCV_INS_VSSSEG7E64_V, + RISCV_INS_VSSSEG7E8_V, + RISCV_INS_VSSSEG8E16_V, + RISCV_INS_VSSSEG8E32_V, + RISCV_INS_VSSSEG8E64_V, + RISCV_INS_VSSSEG8E8_V, + RISCV_INS_VSSUBU_VV, + RISCV_INS_VSSUBU_VX, + RISCV_INS_VSSUB_VV, + RISCV_INS_VSSUB_VX, + RISCV_INS_VSUB_VV, + RISCV_INS_VSUB_VX, + RISCV_INS_VSUXEI16_V, + RISCV_INS_VSUXEI32_V, + RISCV_INS_VSUXEI64_V, + RISCV_INS_VSUXEI8_V, + RISCV_INS_VSUXSEG2EI16_V, + RISCV_INS_VSUXSEG2EI32_V, + RISCV_INS_VSUXSEG2EI64_V, + RISCV_INS_VSUXSEG2EI8_V, + RISCV_INS_VSUXSEG3EI16_V, + RISCV_INS_VSUXSEG3EI32_V, + RISCV_INS_VSUXSEG3EI64_V, + RISCV_INS_VSUXSEG3EI8_V, + RISCV_INS_VSUXSEG4EI16_V, + RISCV_INS_VSUXSEG4EI32_V, + RISCV_INS_VSUXSEG4EI64_V, + RISCV_INS_VSUXSEG4EI8_V, + RISCV_INS_VSUXSEG5EI16_V, + RISCV_INS_VSUXSEG5EI32_V, + RISCV_INS_VSUXSEG5EI64_V, + RISCV_INS_VSUXSEG5EI8_V, + RISCV_INS_VSUXSEG6EI16_V, + RISCV_INS_VSUXSEG6EI32_V, + RISCV_INS_VSUXSEG6EI64_V, + RISCV_INS_VSUXSEG6EI8_V, + RISCV_INS_VSUXSEG7EI16_V, + RISCV_INS_VSUXSEG7EI32_V, + RISCV_INS_VSUXSEG7EI64_V, + RISCV_INS_VSUXSEG7EI8_V, + RISCV_INS_VSUXSEG8EI16_V, + RISCV_INS_VSUXSEG8EI32_V, + RISCV_INS_VSUXSEG8EI64_V, + RISCV_INS_VSUXSEG8EI8_V, + RISCV_INS_VT_MASKC, + RISCV_INS_VT_MASKCN, + RISCV_INS_VWADDU_VV, + RISCV_INS_VWADDU_VX, + RISCV_INS_VWADDU_WV, + RISCV_INS_VWADDU_WX, + RISCV_INS_VWADD_VV, + RISCV_INS_VWADD_VX, + RISCV_INS_VWADD_WV, + RISCV_INS_VWADD_WX, + RISCV_INS_VWMACCSU_VV, + RISCV_INS_VWMACCSU_VX, + RISCV_INS_VWMACCUS_VX, + RISCV_INS_VWMACCU_VV, + RISCV_INS_VWMACCU_VX, + RISCV_INS_VWMACC_VV, + RISCV_INS_VWMACC_VX, + RISCV_INS_VWMULSU_VV, + RISCV_INS_VWMULSU_VX, + RISCV_INS_VWMULU_VV, + RISCV_INS_VWMULU_VX, + RISCV_INS_VWMUL_VV, + RISCV_INS_VWMUL_VX, + RISCV_INS_VWREDSUMU_VS, + RISCV_INS_VWREDSUM_VS, + RISCV_INS_VWSLL_VI, + RISCV_INS_VWSLL_VV, + RISCV_INS_VWSLL_VX, + RISCV_INS_VWSUBU_VV, + RISCV_INS_VWSUBU_VX, + RISCV_INS_VWSUBU_WV, + RISCV_INS_VWSUBU_WX, + RISCV_INS_VWSUB_VV, + RISCV_INS_VWSUB_VX, + RISCV_INS_VWSUB_WV, + RISCV_INS_VWSUB_WX, + RISCV_INS_VXOR_VI, + RISCV_INS_VXOR_VV, + RISCV_INS_VXOR_VX, + RISCV_INS_VZEXT_VF2, + RISCV_INS_VZEXT_VF4, + RISCV_INS_VZEXT_VF8, + RISCV_INS_WFI, + RISCV_INS_WRS_NTO, + RISCV_INS_WRS_STO, + RISCV_INS_XNOR, + RISCV_INS_XOR, + RISCV_INS_XORI, + RISCV_INS_XPERM4, + RISCV_INS_XPERM8, + RISCV_INS_ZIP, diff --git a/arch/RISCV/RISCVGenCSMappingInsn.inc b/arch/RISCV/RISCVGenCSMappingInsn.inc new file mode 100644 index 0000000000..5373c5b542 --- /dev/null +++ b/arch/RISCV/RISCVGenCSMappingInsn.inc @@ -0,0 +1,93486 @@ +/* Capstone Disassembly Engine, https://www.capstone-engine.org */ +/* By Nguyen Anh Quynh , 2013-2022, */ +/* Rot127 2022-2024 */ +/* Automatically generated file by Capstone's LLVM TableGen Disassembler Backend. */ + +/* LLVM-commit: */ +/* LLVM-tag: */ + +/* Do not edit. */ + +/* Capstone's LLVM TableGen Backends: */ +/* https://github.com/capstone-engine/llvm-capstone */ + +{ + /* PHINODE */ + RISCV_PHI /* 0 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_INLINEASM /* 1 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_INLINEASM_BR /* 2 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_CFI_INSTRUCTION /* 3 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_EH_LABEL /* 4 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_GC_LABEL /* 5 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_ANNOTATION_LABEL /* 6 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_KILL /* 7 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_EXTRACT_SUBREG /* 8 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_INSERT_SUBREG /* 9 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_IMPLICIT_DEF /* 10 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_SUBREG_TO_REG /* 11 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_COPY_TO_REGCLASS /* 12 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* DBG_VALUE */ + RISCV_DBG_VALUE /* 13 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* DBG_VALUE_LIST */ + RISCV_DBG_VALUE_LIST /* 14 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* DBG_INSTR_REF */ + RISCV_DBG_INSTR_REF /* 15 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* DBG_PHI */ + RISCV_DBG_PHI /* 16 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* DBG_LABEL */ + RISCV_DBG_LABEL /* 17 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_REG_SEQUENCE /* 18 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_COPY /* 19 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* BUNDLE */ + RISCV_BUNDLE /* 20 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* LIFETIME_START */ + RISCV_LIFETIME_START /* 21 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* LIFETIME_END */ + RISCV_LIFETIME_END /* 22 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* PSEUDO_PROBE */ + RISCV_PSEUDO_PROBE /* 23 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_ARITH_FENCE /* 24 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_STACKMAP /* 25 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* # FEntry call */ + RISCV_FENTRY_CALL /* 26 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PATCHPOINT /* 27 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_LOAD_STACK_GUARD /* 28 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PREALLOCATED_SETUP /* 29 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PREALLOCATED_ARG /* 30 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_STATEPOINT /* 31 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_LOCAL_ESCAPE /* 32 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_FAULTING_OP /* 33 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PATCHABLE_OP /* 34 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* # XRay Function Enter. */ + RISCV_PATCHABLE_FUNCTION_ENTER /* 35 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* # XRay Function Patchable RET. */ + RISCV_PATCHABLE_RET /* 36 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* # XRay Function Exit. */ + RISCV_PATCHABLE_FUNCTION_EXIT /* 37 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* # XRay Tail Call Exit. */ + RISCV_PATCHABLE_TAIL_CALL /* 38 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* # XRay Custom Event Log. */ + RISCV_PATCHABLE_EVENT_CALL /* 39 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* # XRay Typed Event Log. */ + RISCV_PATCHABLE_TYPED_EVENT_CALL /* 40 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_ICALL_BRANCH_FUNNEL /* 41 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_MEMBARRIER /* 42 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_JUMP_TABLE_DEBUG_INFO /* 43 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_ASSERT_SEXT /* 44 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_ASSERT_ZEXT /* 45 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_ASSERT_ALIGN /* 46 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_ADD /* 47 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_SUB /* 48 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_MUL /* 49 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_SDIV /* 50 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_UDIV /* 51 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_SREM /* 52 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_UREM /* 53 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_SDIVREM /* 54 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_UDIVREM /* 55 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_AND /* 56 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_OR /* 57 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_XOR /* 58 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_IMPLICIT_DEF /* 59 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_PHI /* 60 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_FRAME_INDEX /* 61 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_GLOBAL_VALUE /* 62 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_CONSTANT_POOL /* 63 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_EXTRACT /* 64 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_UNMERGE_VALUES /* 65 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_INSERT /* 66 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_MERGE_VALUES /* 67 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_BUILD_VECTOR /* 68 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_BUILD_VECTOR_TRUNC /* 69 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_CONCAT_VECTORS /* 70 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_PTRTOINT /* 71 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_INTTOPTR /* 72 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_BITCAST /* 73 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_FREEZE /* 74 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_CONSTANT_FOLD_BARRIER /* 75 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_INTRINSIC_FPTRUNC_ROUND /* 76 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_INTRINSIC_TRUNC /* 77 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_INTRINSIC_ROUND /* 78 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_INTRINSIC_LRINT /* 79 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_INTRINSIC_ROUNDEVEN /* 80 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_READCYCLECOUNTER /* 81 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_LOAD /* 82 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_SEXTLOAD /* 83 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_ZEXTLOAD /* 84 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_INDEXED_LOAD /* 85 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_INDEXED_SEXTLOAD /* 86 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_INDEXED_ZEXTLOAD /* 87 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_STORE /* 88 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_INDEXED_STORE /* 89 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_ATOMIC_CMPXCHG_WITH_SUCCESS /* 90 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_ATOMIC_CMPXCHG /* 91 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_ATOMICRMW_XCHG /* 92 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_ATOMICRMW_ADD /* 93 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_ATOMICRMW_SUB /* 94 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_ATOMICRMW_AND /* 95 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_ATOMICRMW_NAND /* 96 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_ATOMICRMW_OR /* 97 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_ATOMICRMW_XOR /* 98 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_ATOMICRMW_MAX /* 99 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_ATOMICRMW_MIN /* 100 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_ATOMICRMW_UMAX /* 101 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_ATOMICRMW_UMIN /* 102 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_ATOMICRMW_FADD /* 103 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_ATOMICRMW_FSUB /* 104 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_ATOMICRMW_FMAX /* 105 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_ATOMICRMW_FMIN /* 106 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_ATOMICRMW_UINC_WRAP /* 107 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_ATOMICRMW_UDEC_WRAP /* 108 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_FENCE /* 109 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_PREFETCH /* 110 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_BRCOND /* 111 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_BRINDIRECT /* 112 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_INVOKE_REGION_START /* 113 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_INTRINSIC /* 114 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_INTRINSIC_W_SIDE_EFFECTS /* 115 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_INTRINSIC_CONVERGENT /* 116 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_INTRINSIC_CONVERGENT_W_SIDE_EFFECTS /* 117 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_ANYEXT /* 118 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_TRUNC /* 119 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_CONSTANT /* 120 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_FCONSTANT /* 121 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_VASTART /* 122 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_VAARG /* 123 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_SEXT /* 124 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_SEXT_INREG /* 125 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_ZEXT /* 126 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_SHL /* 127 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_LSHR /* 128 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_ASHR /* 129 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_FSHL /* 130 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_FSHR /* 131 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_ROTR /* 132 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_ROTL /* 133 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_ICMP /* 134 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_FCMP /* 135 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_SELECT /* 136 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_UADDO /* 137 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_UADDE /* 138 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_USUBO /* 139 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_USUBE /* 140 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_SADDO /* 141 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_SADDE /* 142 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_SSUBO /* 143 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_SSUBE /* 144 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_UMULO /* 145 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_SMULO /* 146 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_UMULH /* 147 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_SMULH /* 148 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_UADDSAT /* 149 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_SADDSAT /* 150 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_USUBSAT /* 151 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_SSUBSAT /* 152 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_USHLSAT /* 153 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_SSHLSAT /* 154 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_SMULFIX /* 155 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_UMULFIX /* 156 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_SMULFIXSAT /* 157 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_UMULFIXSAT /* 158 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_SDIVFIX /* 159 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_UDIVFIX /* 160 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_SDIVFIXSAT /* 161 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_UDIVFIXSAT /* 162 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_FADD /* 163 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_FSUB /* 164 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_FMUL /* 165 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_FMA /* 166 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_FMAD /* 167 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_FDIV /* 168 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_FREM /* 169 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_FPOW /* 170 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_FPOWI /* 171 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_FEXP /* 172 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_FEXP2 /* 173 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_FEXP10 /* 174 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_FLOG /* 175 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_FLOG2 /* 176 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_FLOG10 /* 177 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_FLDEXP /* 178 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_FFREXP /* 179 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_FNEG /* 180 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_FPEXT /* 181 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_FPTRUNC /* 182 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_FPTOSI /* 183 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_FPTOUI /* 184 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_SITOFP /* 185 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_UITOFP /* 186 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_FABS /* 187 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_FCOPYSIGN /* 188 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_IS_FPCLASS /* 189 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_FCANONICALIZE /* 190 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_FMINNUM /* 191 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_FMAXNUM /* 192 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_FMINNUM_IEEE /* 193 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_FMAXNUM_IEEE /* 194 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_FMINIMUM /* 195 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_FMAXIMUM /* 196 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_GET_FPENV /* 197 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_SET_FPENV /* 198 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_RESET_FPENV /* 199 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_GET_FPMODE /* 200 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_SET_FPMODE /* 201 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_RESET_FPMODE /* 202 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_PTR_ADD /* 203 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_PTRMASK /* 204 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_SMIN /* 205 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_SMAX /* 206 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_UMIN /* 207 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_UMAX /* 208 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_ABS /* 209 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_LROUND /* 210 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_LLROUND /* 211 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_BR /* 212 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_BRJT /* 213 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_INSERT_VECTOR_ELT /* 214 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_EXTRACT_VECTOR_ELT /* 215 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_SHUFFLE_VECTOR /* 216 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_CTTZ /* 217 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_CTTZ_ZERO_UNDEF /* 218 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_CTLZ /* 219 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_CTLZ_ZERO_UNDEF /* 220 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_CTPOP /* 221 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_BSWAP /* 222 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_BITREVERSE /* 223 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_FCEIL /* 224 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_FCOS /* 225 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_FSIN /* 226 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_FSQRT /* 227 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_FFLOOR /* 228 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_FRINT /* 229 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_FNEARBYINT /* 230 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_ADDRSPACE_CAST /* 231 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_BLOCK_ADDR /* 232 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_JUMP_TABLE /* 233 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_DYN_STACKALLOC /* 234 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_STACKSAVE /* 235 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_STACKRESTORE /* 236 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_STRICT_FADD /* 237 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_STRICT_FSUB /* 238 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_STRICT_FMUL /* 239 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_STRICT_FDIV /* 240 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_STRICT_FREM /* 241 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_STRICT_FMA /* 242 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_STRICT_FSQRT /* 243 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_STRICT_FLDEXP /* 244 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_READ_REGISTER /* 245 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_WRITE_REGISTER /* 246 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_MEMCPY /* 247 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_MEMCPY_INLINE /* 248 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_MEMMOVE /* 249 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_MEMSET /* 250 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_BZERO /* 251 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_VECREDUCE_SEQ_FADD /* 252 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_VECREDUCE_SEQ_FMUL /* 253 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_VECREDUCE_FADD /* 254 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_VECREDUCE_FMUL /* 255 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_VECREDUCE_FMAX /* 256 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_VECREDUCE_FMIN /* 257 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_VECREDUCE_FMAXIMUM /* 258 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_VECREDUCE_FMINIMUM /* 259 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_VECREDUCE_ADD /* 260 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_VECREDUCE_MUL /* 261 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_VECREDUCE_AND /* 262 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_VECREDUCE_OR /* 263 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_VECREDUCE_XOR /* 264 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_VECREDUCE_SMAX /* 265 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_VECREDUCE_SMIN /* 266 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_VECREDUCE_UMAX /* 267 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_VECREDUCE_UMIN /* 268 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_SBFX /* 269 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_UBFX /* 270 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_ADJCALLSTACKDOWN /* 271 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_ADJCALLSTACKUP /* 272 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_BuildPairF64Pseudo /* 273 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_BuildPairF64Pseudo_INX /* 274 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_G_FCLASS /* 275 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_HWASAN_CHECK_MEMACCESS_SHORTGRANULES /* 276 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_KCFI_CHECK /* 277 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* add $rd, $rs1, $rs2, $src */ + RISCV_PseudoAddTPRel /* 278 */, RISCV_INS_ADD, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* */ + RISCV_PseudoAtomicLoadNand32 /* 279 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoAtomicLoadNand64 /* 280 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoBR /* 281 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoBRIND /* 282 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* call $func */ + RISCV_PseudoCALL /* 283 */, RISCV_INS_CALL, + #ifndef CAPSTONE_DIET + { 0 }, { RISCV_REG_X1, 0 }, { RISCV_GRP_CALL, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* */ + RISCV_PseudoCALLIndirect /* 284 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* call $rd, $func */ + RISCV_PseudoCALLReg /* 285 */, RISCV_INS_CALL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_GRP_CALL, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* */ + RISCV_PseudoCCADD /* 286 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoCCADDI /* 287 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoCCADDIW /* 288 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoCCADDW /* 289 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoCCAND /* 290 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoCCANDI /* 291 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoCCANDN /* 292 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoCCMOVGPR /* 293 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoCCMOVGPRNoX0 /* 294 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoCCOR /* 295 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoCCORI /* 296 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoCCORN /* 297 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoCCSLL /* 298 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoCCSLLI /* 299 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoCCSLLIW /* 300 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoCCSLLW /* 301 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoCCSRA /* 302 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoCCSRAI /* 303 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoCCSRAIW /* 304 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoCCSRAW /* 305 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoCCSRL /* 306 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoCCSRLI /* 307 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoCCSRLIW /* 308 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoCCSRLW /* 309 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoCCSUB /* 310 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoCCSUBW /* 311 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoCCXNOR /* 312 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoCCXOR /* 313 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoCCXORI /* 314 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoCmpXchg32 /* 315 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoCmpXchg64 /* 316 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* fld $rd, $addr, $tmp */ + RISCV_PseudoFLD /* 317 */, RISCV_INS_FLD, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTD, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* flh $rd, $addr, $tmp */ + RISCV_PseudoFLH /* 318 */, RISCV_INS_FLH, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFHMIN, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* flw $rd, $addr, $tmp */ + RISCV_PseudoFLW /* 319 */, RISCV_INS_FLW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* */ + RISCV_PseudoFROUND_D /* 320 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoFROUND_D_IN32X /* 321 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoFROUND_D_INX /* 322 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoFROUND_H /* 323 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoFROUND_H_INX /* 324 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoFROUND_S /* 325 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoFROUND_S_INX /* 326 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* fsd $rs, $addr, $tmp */ + RISCV_PseudoFSD /* 327 */, RISCV_INS_FSD, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTD, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fsh $rs, $addr, $tmp */ + RISCV_PseudoFSH /* 328 */, RISCV_INS_FSH, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFHMIN, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fsw $rs, $addr, $tmp */ + RISCV_PseudoFSW /* 329 */, RISCV_INS_FSW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* jump $target, $rd */ + RISCV_PseudoJump /* 330 */, RISCV_INS_JUMP, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_GRP_JUMP, 0 }, 1, 0, {{ 0 }} + + #endif +}, +{ + /* la $dst, $src */ + RISCV_PseudoLA /* 331 */, RISCV_INS_LA, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* la $rd, $imm */ + RISCV_PseudoLAImm /* 332 */, RISCV_INS_LA, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* la.tlsdesc $dst, $src */ + RISCV_PseudoLA_TLSDESC /* 333 */, RISCV_INS_LA_TLSDESC, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* la.tls.gd $dst, $src */ + RISCV_PseudoLA_TLS_GD /* 334 */, RISCV_INS_LA_TLS_GD, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* la.tls.ie $dst, $src */ + RISCV_PseudoLA_TLS_IE /* 335 */, RISCV_INS_LA_TLS_IE, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* lb $rd, $addr */ + RISCV_PseudoLB /* 336 */, RISCV_INS_LB, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* lbu $rd, $addr */ + RISCV_PseudoLBU /* 337 */, RISCV_INS_LBU, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* ld $rd, $addr */ + RISCV_PseudoLD /* 338 */, RISCV_INS_LD, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* lga $dst, $src */ + RISCV_PseudoLGA /* 339 */, RISCV_INS_LGA, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* lh $rd, $addr */ + RISCV_PseudoLH /* 340 */, RISCV_INS_LH, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* lhu $rd, $addr */ + RISCV_PseudoLHU /* 341 */, RISCV_INS_LHU, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* li $rd, $imm */ + RISCV_PseudoLI /* 342 */, RISCV_INS_LI, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* lla $dst, $src */ + RISCV_PseudoLLA /* 343 */, RISCV_INS_LLA, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* lla $dst, $imm */ + RISCV_PseudoLLAImm /* 344 */, RISCV_INS_LLA, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* lw $rd, $addr */ + RISCV_PseudoLW /* 345 */, RISCV_INS_LW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* lwu $rd, $addr */ + RISCV_PseudoLWU /* 346 */, RISCV_INS_LWU, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* */ + RISCV_PseudoLongBEQ /* 347 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoLongBGE /* 348 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoLongBGEU /* 349 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoLongBLT /* 350 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoLongBLTU /* 351 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoLongBNE /* 352 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoMaskedAtomicLoadAdd32 /* 353 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoMaskedAtomicLoadMax32 /* 354 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoMaskedAtomicLoadMin32 /* 355 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoMaskedAtomicLoadNand32 /* 356 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoMaskedAtomicLoadSub32 /* 357 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoMaskedAtomicLoadUMax32 /* 358 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoMaskedAtomicLoadUMin32 /* 359 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoMaskedAtomicSwap32 /* 360 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoMaskedCmpXchg32 /* 361 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoMovImm /* 362 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoQuietFLE_D /* 363 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoQuietFLE_D_IN32X /* 364 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoQuietFLE_D_INX /* 365 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoQuietFLE_H /* 366 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoQuietFLE_H_INX /* 367 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoQuietFLE_S /* 368 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoQuietFLE_S_INX /* 369 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoQuietFLT_D /* 370 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoQuietFLT_D_IN32X /* 371 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoQuietFLT_D_INX /* 372 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoQuietFLT_H /* 373 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoQuietFLT_H_INX /* 374 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoQuietFLT_S /* 375 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoQuietFLT_S_INX /* 376 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoRET /* 377 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoRV32ZdinxLD /* 378 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoRV32ZdinxSD /* 379 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoRVVInitUndefM1 /* 380 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoRVVInitUndefM2 /* 381 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoRVVInitUndefM4 /* 382 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoRVVInitUndefM8 /* 383 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoReadVL /* 384 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoReadVLENB /* 385 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* sb $rs, $addr, $tmp */ + RISCV_PseudoSB /* 386 */, RISCV_INS_SB, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sd $rs, $addr, $tmp */ + RISCV_PseudoSD /* 387 */, RISCV_INS_SD, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sext.b $rd, $rs */ + RISCV_PseudoSEXT_B /* 388 */, RISCV_INS_SEXT_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sext.h $rd, $rs */ + RISCV_PseudoSEXT_H /* 389 */, RISCV_INS_SEXT_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sh $rs, $addr, $tmp */ + RISCV_PseudoSH /* 390 */, RISCV_INS_SH, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sw $rs, $addr, $tmp */ + RISCV_PseudoSW /* 391 */, RISCV_INS_SW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* tail $dst */ + RISCV_PseudoTAIL /* 392 */, RISCV_INS_TAIL, + #ifndef CAPSTONE_DIET + { RISCV_REG_X2, 0 }, { 0 }, { RISCV_GRP_RET, RISCV_GRP_CALL, 0 }, 1, 0, {{ 0 }} + + #endif +}, +{ + /* */ + RISCV_PseudoTAILIndirect /* 393 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQASU_VV_M1 /* 394 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQASU_VV_M1_MASK /* 395 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQASU_VV_M2 /* 396 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQASU_VV_M2_MASK /* 397 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQASU_VV_M4 /* 398 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQASU_VV_M4_MASK /* 399 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQASU_VV_M8 /* 400 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQASU_VV_M8_MASK /* 401 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQASU_VV_MF2 /* 402 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQASU_VV_MF2_MASK /* 403 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQASU_VX_M1 /* 404 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQASU_VX_M1_MASK /* 405 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQASU_VX_M2 /* 406 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQASU_VX_M2_MASK /* 407 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQASU_VX_M4 /* 408 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQASU_VX_M4_MASK /* 409 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQASU_VX_M8 /* 410 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQASU_VX_M8_MASK /* 411 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQASU_VX_MF2 /* 412 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQASU_VX_MF2_MASK /* 413 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQAUS_VX_M1 /* 414 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQAUS_VX_M1_MASK /* 415 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQAUS_VX_M2 /* 416 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQAUS_VX_M2_MASK /* 417 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQAUS_VX_M4 /* 418 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQAUS_VX_M4_MASK /* 419 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQAUS_VX_M8 /* 420 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQAUS_VX_M8_MASK /* 421 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQAUS_VX_MF2 /* 422 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQAUS_VX_MF2_MASK /* 423 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQAU_VV_M1 /* 424 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQAU_VV_M1_MASK /* 425 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQAU_VV_M2 /* 426 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQAU_VV_M2_MASK /* 427 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQAU_VV_M4 /* 428 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQAU_VV_M4_MASK /* 429 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQAU_VV_M8 /* 430 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQAU_VV_M8_MASK /* 431 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQAU_VV_MF2 /* 432 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQAU_VV_MF2_MASK /* 433 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQAU_VX_M1 /* 434 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQAU_VX_M1_MASK /* 435 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQAU_VX_M2 /* 436 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQAU_VX_M2_MASK /* 437 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQAU_VX_M4 /* 438 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQAU_VX_M4_MASK /* 439 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQAU_VX_M8 /* 440 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQAU_VX_M8_MASK /* 441 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQAU_VX_MF2 /* 442 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQAU_VX_MF2_MASK /* 443 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQA_VV_M1 /* 444 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQA_VV_M1_MASK /* 445 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQA_VV_M2 /* 446 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQA_VV_M2_MASK /* 447 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQA_VV_M4 /* 448 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQA_VV_M4_MASK /* 449 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQA_VV_M8 /* 450 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQA_VV_M8_MASK /* 451 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQA_VV_MF2 /* 452 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQA_VV_MF2_MASK /* 453 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQA_VX_M1 /* 454 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQA_VX_M1_MASK /* 455 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQA_VX_M2 /* 456 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQA_VX_M2_MASK /* 457 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQA_VX_M4 /* 458 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQA_VX_M4_MASK /* 459 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQA_VX_M8 /* 460 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQA_VX_M8_MASK /* 461 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQA_VX_MF2 /* 462 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoTHVdotVMAQA_VX_MF2_MASK /* 463 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* jalr $rd, ${imm12}(${rs1}), $src */ + RISCV_PseudoTLSDESCCall /* 464 */, RISCV_INS_JALR, + #ifndef CAPSTONE_DIET + { RISCV_REG_X10, 0 }, { RISCV_REG_X10, 0 }, { RISCV_GRP_CALL, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* */ + RISCV_PseudoVAADDU_VV_M1 /* 465 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAADDU_VV_M1_MASK /* 466 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAADDU_VV_M2 /* 467 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAADDU_VV_M2_MASK /* 468 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAADDU_VV_M4 /* 469 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAADDU_VV_M4_MASK /* 470 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAADDU_VV_M8 /* 471 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAADDU_VV_M8_MASK /* 472 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAADDU_VV_MF2 /* 473 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAADDU_VV_MF2_MASK /* 474 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAADDU_VV_MF4 /* 475 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAADDU_VV_MF4_MASK /* 476 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAADDU_VV_MF8 /* 477 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAADDU_VV_MF8_MASK /* 478 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAADDU_VX_M1 /* 479 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAADDU_VX_M1_MASK /* 480 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAADDU_VX_M2 /* 481 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAADDU_VX_M2_MASK /* 482 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAADDU_VX_M4 /* 483 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAADDU_VX_M4_MASK /* 484 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAADDU_VX_M8 /* 485 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAADDU_VX_M8_MASK /* 486 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAADDU_VX_MF2 /* 487 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAADDU_VX_MF2_MASK /* 488 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAADDU_VX_MF4 /* 489 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAADDU_VX_MF4_MASK /* 490 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAADDU_VX_MF8 /* 491 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAADDU_VX_MF8_MASK /* 492 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAADD_VV_M1 /* 493 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAADD_VV_M1_MASK /* 494 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAADD_VV_M2 /* 495 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAADD_VV_M2_MASK /* 496 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAADD_VV_M4 /* 497 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAADD_VV_M4_MASK /* 498 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAADD_VV_M8 /* 499 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAADD_VV_M8_MASK /* 500 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAADD_VV_MF2 /* 501 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAADD_VV_MF2_MASK /* 502 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAADD_VV_MF4 /* 503 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAADD_VV_MF4_MASK /* 504 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAADD_VV_MF8 /* 505 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAADD_VV_MF8_MASK /* 506 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAADD_VX_M1 /* 507 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAADD_VX_M1_MASK /* 508 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAADD_VX_M2 /* 509 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAADD_VX_M2_MASK /* 510 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAADD_VX_M4 /* 511 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAADD_VX_M4_MASK /* 512 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAADD_VX_M8 /* 513 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAADD_VX_M8_MASK /* 514 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAADD_VX_MF2 /* 515 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAADD_VX_MF2_MASK /* 516 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAADD_VX_MF4 /* 517 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAADD_VX_MF4_MASK /* 518 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAADD_VX_MF8 /* 519 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAADD_VX_MF8_MASK /* 520 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADC_VIM_M1 /* 521 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADC_VIM_M2 /* 522 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADC_VIM_M4 /* 523 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADC_VIM_M8 /* 524 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADC_VIM_MF2 /* 525 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADC_VIM_MF4 /* 526 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADC_VIM_MF8 /* 527 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADC_VVM_M1 /* 528 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADC_VVM_M2 /* 529 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADC_VVM_M4 /* 530 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADC_VVM_M8 /* 531 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADC_VVM_MF2 /* 532 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADC_VVM_MF4 /* 533 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADC_VVM_MF8 /* 534 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADC_VXM_M1 /* 535 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADC_VXM_M2 /* 536 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADC_VXM_M4 /* 537 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADC_VXM_M8 /* 538 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADC_VXM_MF2 /* 539 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADC_VXM_MF4 /* 540 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADC_VXM_MF8 /* 541 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADD_VI_M1 /* 542 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADD_VI_M1_MASK /* 543 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADD_VI_M2 /* 544 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADD_VI_M2_MASK /* 545 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADD_VI_M4 /* 546 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADD_VI_M4_MASK /* 547 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADD_VI_M8 /* 548 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADD_VI_M8_MASK /* 549 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADD_VI_MF2 /* 550 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADD_VI_MF2_MASK /* 551 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADD_VI_MF4 /* 552 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADD_VI_MF4_MASK /* 553 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADD_VI_MF8 /* 554 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADD_VI_MF8_MASK /* 555 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADD_VV_M1 /* 556 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADD_VV_M1_MASK /* 557 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADD_VV_M2 /* 558 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADD_VV_M2_MASK /* 559 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADD_VV_M4 /* 560 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADD_VV_M4_MASK /* 561 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADD_VV_M8 /* 562 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADD_VV_M8_MASK /* 563 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADD_VV_MF2 /* 564 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADD_VV_MF2_MASK /* 565 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADD_VV_MF4 /* 566 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADD_VV_MF4_MASK /* 567 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADD_VV_MF8 /* 568 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADD_VV_MF8_MASK /* 569 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADD_VX_M1 /* 570 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADD_VX_M1_MASK /* 571 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADD_VX_M2 /* 572 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADD_VX_M2_MASK /* 573 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADD_VX_M4 /* 574 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADD_VX_M4_MASK /* 575 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADD_VX_M8 /* 576 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADD_VX_M8_MASK /* 577 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADD_VX_MF2 /* 578 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADD_VX_MF2_MASK /* 579 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADD_VX_MF4 /* 580 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADD_VX_MF4_MASK /* 581 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADD_VX_MF8 /* 582 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVADD_VX_MF8_MASK /* 583 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESDF_VS_M1_M1 /* 584 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESDF_VS_M1_MF2 /* 585 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESDF_VS_M1_MF4 /* 586 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESDF_VS_M1_MF8 /* 587 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESDF_VS_M2_M1 /* 588 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESDF_VS_M2_M2 /* 589 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESDF_VS_M2_MF2 /* 590 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESDF_VS_M2_MF4 /* 591 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESDF_VS_M2_MF8 /* 592 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESDF_VS_M4_M1 /* 593 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESDF_VS_M4_M2 /* 594 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESDF_VS_M4_M4 /* 595 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESDF_VS_M4_MF2 /* 596 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESDF_VS_M4_MF4 /* 597 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESDF_VS_M4_MF8 /* 598 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESDF_VS_M8_M1 /* 599 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESDF_VS_M8_M2 /* 600 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESDF_VS_M8_M4 /* 601 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESDF_VS_M8_MF2 /* 602 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESDF_VS_M8_MF4 /* 603 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESDF_VS_M8_MF8 /* 604 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESDF_VS_MF2_MF2 /* 605 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESDF_VS_MF2_MF4 /* 606 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESDF_VS_MF2_MF8 /* 607 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESDF_VV_M1 /* 608 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESDF_VV_M2 /* 609 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESDF_VV_M4 /* 610 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESDF_VV_M8 /* 611 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESDF_VV_MF2 /* 612 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESDM_VS_M1_M1 /* 613 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESDM_VS_M1_MF2 /* 614 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESDM_VS_M1_MF4 /* 615 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESDM_VS_M1_MF8 /* 616 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESDM_VS_M2_M1 /* 617 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESDM_VS_M2_M2 /* 618 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESDM_VS_M2_MF2 /* 619 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESDM_VS_M2_MF4 /* 620 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESDM_VS_M2_MF8 /* 621 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESDM_VS_M4_M1 /* 622 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESDM_VS_M4_M2 /* 623 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESDM_VS_M4_M4 /* 624 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESDM_VS_M4_MF2 /* 625 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESDM_VS_M4_MF4 /* 626 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESDM_VS_M4_MF8 /* 627 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESDM_VS_M8_M1 /* 628 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESDM_VS_M8_M2 /* 629 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESDM_VS_M8_M4 /* 630 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESDM_VS_M8_MF2 /* 631 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESDM_VS_M8_MF4 /* 632 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESDM_VS_M8_MF8 /* 633 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESDM_VS_MF2_MF2 /* 634 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESDM_VS_MF2_MF4 /* 635 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESDM_VS_MF2_MF8 /* 636 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESDM_VV_M1 /* 637 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESDM_VV_M2 /* 638 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESDM_VV_M4 /* 639 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESDM_VV_M8 /* 640 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESDM_VV_MF2 /* 641 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESEF_VS_M1_M1 /* 642 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESEF_VS_M1_MF2 /* 643 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESEF_VS_M1_MF4 /* 644 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESEF_VS_M1_MF8 /* 645 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESEF_VS_M2_M1 /* 646 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESEF_VS_M2_M2 /* 647 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESEF_VS_M2_MF2 /* 648 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESEF_VS_M2_MF4 /* 649 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESEF_VS_M2_MF8 /* 650 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESEF_VS_M4_M1 /* 651 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESEF_VS_M4_M2 /* 652 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESEF_VS_M4_M4 /* 653 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESEF_VS_M4_MF2 /* 654 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESEF_VS_M4_MF4 /* 655 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESEF_VS_M4_MF8 /* 656 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESEF_VS_M8_M1 /* 657 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESEF_VS_M8_M2 /* 658 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESEF_VS_M8_M4 /* 659 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESEF_VS_M8_MF2 /* 660 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESEF_VS_M8_MF4 /* 661 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESEF_VS_M8_MF8 /* 662 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESEF_VS_MF2_MF2 /* 663 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESEF_VS_MF2_MF4 /* 664 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESEF_VS_MF2_MF8 /* 665 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESEF_VV_M1 /* 666 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESEF_VV_M2 /* 667 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESEF_VV_M4 /* 668 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESEF_VV_M8 /* 669 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESEF_VV_MF2 /* 670 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESEM_VS_M1_M1 /* 671 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESEM_VS_M1_MF2 /* 672 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESEM_VS_M1_MF4 /* 673 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESEM_VS_M1_MF8 /* 674 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESEM_VS_M2_M1 /* 675 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESEM_VS_M2_M2 /* 676 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESEM_VS_M2_MF2 /* 677 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESEM_VS_M2_MF4 /* 678 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESEM_VS_M2_MF8 /* 679 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESEM_VS_M4_M1 /* 680 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESEM_VS_M4_M2 /* 681 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESEM_VS_M4_M4 /* 682 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESEM_VS_M4_MF2 /* 683 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESEM_VS_M4_MF4 /* 684 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESEM_VS_M4_MF8 /* 685 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESEM_VS_M8_M1 /* 686 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESEM_VS_M8_M2 /* 687 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESEM_VS_M8_M4 /* 688 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESEM_VS_M8_MF2 /* 689 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESEM_VS_M8_MF4 /* 690 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESEM_VS_M8_MF8 /* 691 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESEM_VS_MF2_MF2 /* 692 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESEM_VS_MF2_MF4 /* 693 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESEM_VS_MF2_MF8 /* 694 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESEM_VV_M1 /* 695 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESEM_VV_M2 /* 696 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESEM_VV_M4 /* 697 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESEM_VV_M8 /* 698 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESEM_VV_MF2 /* 699 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESKF1_VI_M1 /* 700 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESKF1_VI_M2 /* 701 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESKF1_VI_M4 /* 702 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESKF1_VI_M8 /* 703 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESKF1_VI_MF2 /* 704 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESKF2_VI_M1 /* 705 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESKF2_VI_M2 /* 706 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESKF2_VI_M4 /* 707 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESKF2_VI_M8 /* 708 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESKF2_VI_MF2 /* 709 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESZ_VS_M1_M1 /* 710 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESZ_VS_M1_MF2 /* 711 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESZ_VS_M1_MF4 /* 712 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESZ_VS_M1_MF8 /* 713 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESZ_VS_M2_M1 /* 714 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESZ_VS_M2_M2 /* 715 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESZ_VS_M2_MF2 /* 716 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESZ_VS_M2_MF4 /* 717 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESZ_VS_M2_MF8 /* 718 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESZ_VS_M4_M1 /* 719 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESZ_VS_M4_M2 /* 720 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESZ_VS_M4_M4 /* 721 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESZ_VS_M4_MF2 /* 722 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESZ_VS_M4_MF4 /* 723 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESZ_VS_M4_MF8 /* 724 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESZ_VS_M8_M1 /* 725 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESZ_VS_M8_M2 /* 726 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESZ_VS_M8_M4 /* 727 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESZ_VS_M8_MF2 /* 728 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESZ_VS_M8_MF4 /* 729 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESZ_VS_M8_MF8 /* 730 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESZ_VS_MF2_MF2 /* 731 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESZ_VS_MF2_MF4 /* 732 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAESZ_VS_MF2_MF8 /* 733 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVANDN_VV_M1 /* 734 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVANDN_VV_M1_MASK /* 735 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVANDN_VV_M2 /* 736 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVANDN_VV_M2_MASK /* 737 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVANDN_VV_M4 /* 738 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVANDN_VV_M4_MASK /* 739 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVANDN_VV_M8 /* 740 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVANDN_VV_M8_MASK /* 741 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVANDN_VV_MF2 /* 742 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVANDN_VV_MF2_MASK /* 743 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVANDN_VV_MF4 /* 744 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVANDN_VV_MF4_MASK /* 745 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVANDN_VV_MF8 /* 746 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVANDN_VV_MF8_MASK /* 747 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVANDN_VX_M1 /* 748 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVANDN_VX_M1_MASK /* 749 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVANDN_VX_M2 /* 750 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVANDN_VX_M2_MASK /* 751 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVANDN_VX_M4 /* 752 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVANDN_VX_M4_MASK /* 753 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVANDN_VX_M8 /* 754 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVANDN_VX_M8_MASK /* 755 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVANDN_VX_MF2 /* 756 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVANDN_VX_MF2_MASK /* 757 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVANDN_VX_MF4 /* 758 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVANDN_VX_MF4_MASK /* 759 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVANDN_VX_MF8 /* 760 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVANDN_VX_MF8_MASK /* 761 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAND_VI_M1 /* 762 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAND_VI_M1_MASK /* 763 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAND_VI_M2 /* 764 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAND_VI_M2_MASK /* 765 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAND_VI_M4 /* 766 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAND_VI_M4_MASK /* 767 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAND_VI_M8 /* 768 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAND_VI_M8_MASK /* 769 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAND_VI_MF2 /* 770 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAND_VI_MF2_MASK /* 771 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAND_VI_MF4 /* 772 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAND_VI_MF4_MASK /* 773 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAND_VI_MF8 /* 774 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAND_VI_MF8_MASK /* 775 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAND_VV_M1 /* 776 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAND_VV_M1_MASK /* 777 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAND_VV_M2 /* 778 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAND_VV_M2_MASK /* 779 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAND_VV_M4 /* 780 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAND_VV_M4_MASK /* 781 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAND_VV_M8 /* 782 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAND_VV_M8_MASK /* 783 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAND_VV_MF2 /* 784 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAND_VV_MF2_MASK /* 785 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAND_VV_MF4 /* 786 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAND_VV_MF4_MASK /* 787 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAND_VV_MF8 /* 788 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAND_VV_MF8_MASK /* 789 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAND_VX_M1 /* 790 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAND_VX_M1_MASK /* 791 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAND_VX_M2 /* 792 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAND_VX_M2_MASK /* 793 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAND_VX_M4 /* 794 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAND_VX_M4_MASK /* 795 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAND_VX_M8 /* 796 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAND_VX_M8_MASK /* 797 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAND_VX_MF2 /* 798 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAND_VX_MF2_MASK /* 799 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAND_VX_MF4 /* 800 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAND_VX_MF4_MASK /* 801 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAND_VX_MF8 /* 802 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVAND_VX_MF8_MASK /* 803 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVASUBU_VV_M1 /* 804 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVASUBU_VV_M1_MASK /* 805 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVASUBU_VV_M2 /* 806 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVASUBU_VV_M2_MASK /* 807 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVASUBU_VV_M4 /* 808 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVASUBU_VV_M4_MASK /* 809 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVASUBU_VV_M8 /* 810 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVASUBU_VV_M8_MASK /* 811 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVASUBU_VV_MF2 /* 812 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVASUBU_VV_MF2_MASK /* 813 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVASUBU_VV_MF4 /* 814 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVASUBU_VV_MF4_MASK /* 815 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVASUBU_VV_MF8 /* 816 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVASUBU_VV_MF8_MASK /* 817 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVASUBU_VX_M1 /* 818 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVASUBU_VX_M1_MASK /* 819 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVASUBU_VX_M2 /* 820 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVASUBU_VX_M2_MASK /* 821 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVASUBU_VX_M4 /* 822 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVASUBU_VX_M4_MASK /* 823 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVASUBU_VX_M8 /* 824 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVASUBU_VX_M8_MASK /* 825 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVASUBU_VX_MF2 /* 826 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVASUBU_VX_MF2_MASK /* 827 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVASUBU_VX_MF4 /* 828 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVASUBU_VX_MF4_MASK /* 829 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVASUBU_VX_MF8 /* 830 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVASUBU_VX_MF8_MASK /* 831 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVASUB_VV_M1 /* 832 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVASUB_VV_M1_MASK /* 833 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVASUB_VV_M2 /* 834 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVASUB_VV_M2_MASK /* 835 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVASUB_VV_M4 /* 836 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVASUB_VV_M4_MASK /* 837 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVASUB_VV_M8 /* 838 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVASUB_VV_M8_MASK /* 839 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVASUB_VV_MF2 /* 840 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVASUB_VV_MF2_MASK /* 841 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVASUB_VV_MF4 /* 842 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVASUB_VV_MF4_MASK /* 843 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVASUB_VV_MF8 /* 844 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVASUB_VV_MF8_MASK /* 845 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVASUB_VX_M1 /* 846 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVASUB_VX_M1_MASK /* 847 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVASUB_VX_M2 /* 848 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVASUB_VX_M2_MASK /* 849 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVASUB_VX_M4 /* 850 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVASUB_VX_M4_MASK /* 851 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVASUB_VX_M8 /* 852 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVASUB_VX_M8_MASK /* 853 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVASUB_VX_MF2 /* 854 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVASUB_VX_MF2_MASK /* 855 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVASUB_VX_MF4 /* 856 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVASUB_VX_MF4_MASK /* 857 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVASUB_VX_MF8 /* 858 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVASUB_VX_MF8_MASK /* 859 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVBREV8_V_M1 /* 860 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVBREV8_V_M1_MASK /* 861 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVBREV8_V_M2 /* 862 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVBREV8_V_M2_MASK /* 863 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVBREV8_V_M4 /* 864 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVBREV8_V_M4_MASK /* 865 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVBREV8_V_M8 /* 866 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVBREV8_V_M8_MASK /* 867 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVBREV8_V_MF2 /* 868 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVBREV8_V_MF2_MASK /* 869 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVBREV8_V_MF4 /* 870 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVBREV8_V_MF4_MASK /* 871 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVBREV8_V_MF8 /* 872 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVBREV8_V_MF8_MASK /* 873 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVBREV_V_M1 /* 874 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVBREV_V_M1_MASK /* 875 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVBREV_V_M2 /* 876 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVBREV_V_M2_MASK /* 877 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVBREV_V_M4 /* 878 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVBREV_V_M4_MASK /* 879 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVBREV_V_M8 /* 880 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVBREV_V_M8_MASK /* 881 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVBREV_V_MF2 /* 882 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVBREV_V_MF2_MASK /* 883 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVBREV_V_MF4 /* 884 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVBREV_V_MF4_MASK /* 885 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVBREV_V_MF8 /* 886 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVBREV_V_MF8_MASK /* 887 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLMULH_VV_M1 /* 888 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLMULH_VV_M1_MASK /* 889 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLMULH_VV_M2 /* 890 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLMULH_VV_M2_MASK /* 891 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLMULH_VV_M4 /* 892 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLMULH_VV_M4_MASK /* 893 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLMULH_VV_M8 /* 894 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLMULH_VV_M8_MASK /* 895 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLMULH_VV_MF2 /* 896 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLMULH_VV_MF2_MASK /* 897 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLMULH_VV_MF4 /* 898 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLMULH_VV_MF4_MASK /* 899 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLMULH_VV_MF8 /* 900 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLMULH_VV_MF8_MASK /* 901 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLMULH_VX_M1 /* 902 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLMULH_VX_M1_MASK /* 903 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLMULH_VX_M2 /* 904 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLMULH_VX_M2_MASK /* 905 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLMULH_VX_M4 /* 906 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLMULH_VX_M4_MASK /* 907 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLMULH_VX_M8 /* 908 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLMULH_VX_M8_MASK /* 909 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLMULH_VX_MF2 /* 910 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLMULH_VX_MF2_MASK /* 911 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLMULH_VX_MF4 /* 912 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLMULH_VX_MF4_MASK /* 913 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLMULH_VX_MF8 /* 914 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLMULH_VX_MF8_MASK /* 915 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLMUL_VV_M1 /* 916 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLMUL_VV_M1_MASK /* 917 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLMUL_VV_M2 /* 918 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLMUL_VV_M2_MASK /* 919 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLMUL_VV_M4 /* 920 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLMUL_VV_M4_MASK /* 921 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLMUL_VV_M8 /* 922 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLMUL_VV_M8_MASK /* 923 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLMUL_VV_MF2 /* 924 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLMUL_VV_MF2_MASK /* 925 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLMUL_VV_MF4 /* 926 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLMUL_VV_MF4_MASK /* 927 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLMUL_VV_MF8 /* 928 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLMUL_VV_MF8_MASK /* 929 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLMUL_VX_M1 /* 930 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLMUL_VX_M1_MASK /* 931 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLMUL_VX_M2 /* 932 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLMUL_VX_M2_MASK /* 933 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLMUL_VX_M4 /* 934 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLMUL_VX_M4_MASK /* 935 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLMUL_VX_M8 /* 936 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLMUL_VX_M8_MASK /* 937 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLMUL_VX_MF2 /* 938 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLMUL_VX_MF2_MASK /* 939 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLMUL_VX_MF4 /* 940 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLMUL_VX_MF4_MASK /* 941 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLMUL_VX_MF8 /* 942 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLMUL_VX_MF8_MASK /* 943 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLZ_V_M1 /* 944 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLZ_V_M1_MASK /* 945 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLZ_V_M2 /* 946 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLZ_V_M2_MASK /* 947 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLZ_V_M4 /* 948 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLZ_V_M4_MASK /* 949 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLZ_V_M8 /* 950 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLZ_V_M8_MASK /* 951 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLZ_V_MF2 /* 952 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLZ_V_MF2_MASK /* 953 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLZ_V_MF4 /* 954 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLZ_V_MF4_MASK /* 955 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLZ_V_MF8 /* 956 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCLZ_V_MF8_MASK /* 957 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCOMPRESS_VM_M1_E16 /* 958 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCOMPRESS_VM_M1_E32 /* 959 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCOMPRESS_VM_M1_E64 /* 960 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCOMPRESS_VM_M1_E8 /* 961 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCOMPRESS_VM_M2_E16 /* 962 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCOMPRESS_VM_M2_E32 /* 963 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCOMPRESS_VM_M2_E64 /* 964 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCOMPRESS_VM_M2_E8 /* 965 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCOMPRESS_VM_M4_E16 /* 966 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCOMPRESS_VM_M4_E32 /* 967 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCOMPRESS_VM_M4_E64 /* 968 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCOMPRESS_VM_M4_E8 /* 969 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCOMPRESS_VM_M8_E16 /* 970 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCOMPRESS_VM_M8_E32 /* 971 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCOMPRESS_VM_M8_E64 /* 972 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCOMPRESS_VM_M8_E8 /* 973 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCOMPRESS_VM_MF2_E16 /* 974 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCOMPRESS_VM_MF2_E32 /* 975 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCOMPRESS_VM_MF2_E8 /* 976 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCOMPRESS_VM_MF4_E16 /* 977 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCOMPRESS_VM_MF4_E8 /* 978 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCOMPRESS_VM_MF8_E8 /* 979 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCPOP_M_B1 /* 980 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCPOP_M_B16 /* 981 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCPOP_M_B16_MASK /* 982 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCPOP_M_B1_MASK /* 983 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCPOP_M_B2 /* 984 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCPOP_M_B2_MASK /* 985 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCPOP_M_B32 /* 986 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCPOP_M_B32_MASK /* 987 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCPOP_M_B4 /* 988 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCPOP_M_B4_MASK /* 989 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCPOP_M_B64 /* 990 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCPOP_M_B64_MASK /* 991 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCPOP_M_B8 /* 992 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCPOP_M_B8_MASK /* 993 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCPOP_V_M1 /* 994 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCPOP_V_M1_MASK /* 995 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCPOP_V_M2 /* 996 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCPOP_V_M2_MASK /* 997 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCPOP_V_M4 /* 998 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCPOP_V_M4_MASK /* 999 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCPOP_V_M8 /* 1000 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCPOP_V_M8_MASK /* 1001 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCPOP_V_MF2 /* 1002 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCPOP_V_MF2_MASK /* 1003 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCPOP_V_MF4 /* 1004 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCPOP_V_MF4_MASK /* 1005 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCPOP_V_MF8 /* 1006 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCPOP_V_MF8_MASK /* 1007 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCTZ_V_M1 /* 1008 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCTZ_V_M1_MASK /* 1009 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCTZ_V_M2 /* 1010 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCTZ_V_M2_MASK /* 1011 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCTZ_V_M4 /* 1012 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCTZ_V_M4_MASK /* 1013 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCTZ_V_M8 /* 1014 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCTZ_V_M8_MASK /* 1015 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCTZ_V_MF2 /* 1016 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCTZ_V_MF2_MASK /* 1017 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCTZ_V_MF4 /* 1018 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCTZ_V_MF4_MASK /* 1019 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCTZ_V_MF8 /* 1020 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVCTZ_V_MF8_MASK /* 1021 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_FPR16VV_SE_M1 /* 1022 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_FPR16VV_SE_M2 /* 1023 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_FPR16VV_SE_M4 /* 1024 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_FPR16VV_SE_M8 /* 1025 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_FPR16VV_SE_MF2 /* 1026 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_FPR16VV_SE_MF4 /* 1027 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_FPR16VW_SE_M1 /* 1028 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_FPR16VW_SE_M2 /* 1029 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_FPR16VW_SE_M4 /* 1030 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_FPR16VW_SE_M8 /* 1031 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_FPR16VW_SE_MF2 /* 1032 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_FPR16VW_SE_MF4 /* 1033 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_FPR16V_SE_M1 /* 1034 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_FPR16V_SE_M2 /* 1035 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_FPR16V_SE_M4 /* 1036 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_FPR16V_SE_M8 /* 1037 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_FPR16V_SE_MF2 /* 1038 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_FPR16V_SE_MF4 /* 1039 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_FPR32VV_SE_M1 /* 1040 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_FPR32VV_SE_M2 /* 1041 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_FPR32VV_SE_M4 /* 1042 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_FPR32VV_SE_M8 /* 1043 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_FPR32VV_SE_MF2 /* 1044 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_FPR32VW_SE_M1 /* 1045 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_FPR32VW_SE_M2 /* 1046 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_FPR32VW_SE_M4 /* 1047 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_FPR32VW_SE_M8 /* 1048 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_FPR32VW_SE_MF2 /* 1049 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_FPR32V_SE_M1 /* 1050 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_FPR32V_SE_M2 /* 1051 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_FPR32V_SE_M4 /* 1052 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_FPR32V_SE_M8 /* 1053 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_FPR32V_SE_MF2 /* 1054 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_FPR64VV_SE_M1 /* 1055 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_FPR64VV_SE_M2 /* 1056 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_FPR64VV_SE_M4 /* 1057 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_FPR64VV_SE_M8 /* 1058 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_FPR64V_SE_M1 /* 1059 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_FPR64V_SE_M2 /* 1060 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_FPR64V_SE_M4 /* 1061 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_FPR64V_SE_M8 /* 1062 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_IVV_SE_M1 /* 1063 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_IVV_SE_M2 /* 1064 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_IVV_SE_M4 /* 1065 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_IVV_SE_M8 /* 1066 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_IVV_SE_MF2 /* 1067 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_IVV_SE_MF4 /* 1068 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_IVV_SE_MF8 /* 1069 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_IVW_SE_M1 /* 1070 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_IVW_SE_M2 /* 1071 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_IVW_SE_M4 /* 1072 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_IVW_SE_MF2 /* 1073 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_IVW_SE_MF4 /* 1074 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_IVW_SE_MF8 /* 1075 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_IV_SE_M1 /* 1076 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_IV_SE_M2 /* 1077 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_IV_SE_M4 /* 1078 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_IV_SE_M8 /* 1079 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_IV_SE_MF2 /* 1080 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_IV_SE_MF4 /* 1081 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_IV_SE_MF8 /* 1082 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_I_SE_M1 /* 1083 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_I_SE_M2 /* 1084 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_I_SE_M4 /* 1085 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_I_SE_M8 /* 1086 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_I_SE_MF2 /* 1087 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_I_SE_MF4 /* 1088 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_I_SE_MF8 /* 1089 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_VVV_SE_M1 /* 1090 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_VVV_SE_M2 /* 1091 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_VVV_SE_M4 /* 1092 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_VVV_SE_M8 /* 1093 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_VVV_SE_MF2 /* 1094 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_VVV_SE_MF4 /* 1095 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_VVV_SE_MF8 /* 1096 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_VVW_SE_M1 /* 1097 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_VVW_SE_M2 /* 1098 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_VVW_SE_M4 /* 1099 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_VVW_SE_MF2 /* 1100 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_VVW_SE_MF4 /* 1101 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_VVW_SE_MF8 /* 1102 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_VV_SE_M1 /* 1103 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_VV_SE_M2 /* 1104 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_VV_SE_M4 /* 1105 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_VV_SE_M8 /* 1106 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_VV_SE_MF2 /* 1107 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_VV_SE_MF4 /* 1108 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_VV_SE_MF8 /* 1109 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR16VV_M1 /* 1110 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR16VV_M2 /* 1111 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR16VV_M4 /* 1112 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR16VV_M8 /* 1113 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR16VV_MF2 /* 1114 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR16VV_MF4 /* 1115 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR16VV_SE_M1 /* 1116 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR16VV_SE_M2 /* 1117 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR16VV_SE_M4 /* 1118 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR16VV_SE_M8 /* 1119 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR16VV_SE_MF2 /* 1120 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR16VV_SE_MF4 /* 1121 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR16VW_M1 /* 1122 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR16VW_M2 /* 1123 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR16VW_M4 /* 1124 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR16VW_M8 /* 1125 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR16VW_MF2 /* 1126 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR16VW_MF4 /* 1127 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR16VW_SE_M1 /* 1128 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR16VW_SE_M2 /* 1129 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR16VW_SE_M4 /* 1130 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR16VW_SE_M8 /* 1131 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR16VW_SE_MF2 /* 1132 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR16VW_SE_MF4 /* 1133 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR16V_M1 /* 1134 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR16V_M2 /* 1135 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR16V_M4 /* 1136 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR16V_M8 /* 1137 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR16V_MF2 /* 1138 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR16V_MF4 /* 1139 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR16V_SE_M1 /* 1140 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR16V_SE_M2 /* 1141 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR16V_SE_M4 /* 1142 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR16V_SE_M8 /* 1143 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR16V_SE_MF2 /* 1144 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR16V_SE_MF4 /* 1145 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR32VV_M1 /* 1146 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR32VV_M2 /* 1147 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR32VV_M4 /* 1148 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR32VV_M8 /* 1149 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR32VV_MF2 /* 1150 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR32VV_SE_M1 /* 1151 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR32VV_SE_M2 /* 1152 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR32VV_SE_M4 /* 1153 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR32VV_SE_M8 /* 1154 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR32VV_SE_MF2 /* 1155 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR32VW_M1 /* 1156 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR32VW_M2 /* 1157 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR32VW_M4 /* 1158 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR32VW_M8 /* 1159 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR32VW_MF2 /* 1160 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR32VW_SE_M1 /* 1161 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR32VW_SE_M2 /* 1162 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR32VW_SE_M4 /* 1163 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR32VW_SE_M8 /* 1164 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR32VW_SE_MF2 /* 1165 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR32V_M1 /* 1166 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR32V_M2 /* 1167 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR32V_M4 /* 1168 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR32V_M8 /* 1169 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR32V_MF2 /* 1170 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR32V_SE_M1 /* 1171 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR32V_SE_M2 /* 1172 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR32V_SE_M4 /* 1173 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR32V_SE_M8 /* 1174 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR32V_SE_MF2 /* 1175 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR64VV_M1 /* 1176 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR64VV_M2 /* 1177 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR64VV_M4 /* 1178 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR64VV_M8 /* 1179 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR64VV_SE_M1 /* 1180 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR64VV_SE_M2 /* 1181 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR64VV_SE_M4 /* 1182 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR64VV_SE_M8 /* 1183 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR64V_M1 /* 1184 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR64V_M2 /* 1185 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR64V_M4 /* 1186 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR64V_M8 /* 1187 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR64V_SE_M1 /* 1188 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR64V_SE_M2 /* 1189 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR64V_SE_M4 /* 1190 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_FPR64V_SE_M8 /* 1191 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_IVV_M1 /* 1192 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_IVV_M2 /* 1193 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_IVV_M4 /* 1194 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_IVV_M8 /* 1195 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_IVV_MF2 /* 1196 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_IVV_MF4 /* 1197 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_IVV_MF8 /* 1198 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_IVV_SE_M1 /* 1199 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_IVV_SE_M2 /* 1200 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_IVV_SE_M4 /* 1201 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_IVV_SE_M8 /* 1202 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_IVV_SE_MF2 /* 1203 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_IVV_SE_MF4 /* 1204 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_IVV_SE_MF8 /* 1205 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_IVW_M1 /* 1206 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_IVW_M2 /* 1207 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_IVW_M4 /* 1208 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_IVW_MF2 /* 1209 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_IVW_MF4 /* 1210 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_IVW_MF8 /* 1211 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_IVW_SE_M1 /* 1212 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_IVW_SE_M2 /* 1213 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_IVW_SE_M4 /* 1214 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_IVW_SE_MF2 /* 1215 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_IVW_SE_MF4 /* 1216 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_IVW_SE_MF8 /* 1217 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_IV_M1 /* 1218 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_IV_M2 /* 1219 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_IV_M4 /* 1220 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_IV_M8 /* 1221 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_IV_MF2 /* 1222 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_IV_MF4 /* 1223 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_IV_MF8 /* 1224 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_IV_SE_M1 /* 1225 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_IV_SE_M2 /* 1226 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_IV_SE_M4 /* 1227 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_IV_SE_M8 /* 1228 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_IV_SE_MF2 /* 1229 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_IV_SE_MF4 /* 1230 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_IV_SE_MF8 /* 1231 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_I_M1 /* 1232 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_I_M2 /* 1233 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_I_M4 /* 1234 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_I_M8 /* 1235 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_I_MF2 /* 1236 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_I_MF4 /* 1237 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_I_MF8 /* 1238 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_I_SE_M1 /* 1239 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_I_SE_M2 /* 1240 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_I_SE_M4 /* 1241 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_I_SE_M8 /* 1242 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_I_SE_MF2 /* 1243 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_I_SE_MF4 /* 1244 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_I_SE_MF8 /* 1245 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_VVV_M1 /* 1246 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_VVV_M2 /* 1247 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_VVV_M4 /* 1248 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_VVV_M8 /* 1249 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_VVV_MF2 /* 1250 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_VVV_MF4 /* 1251 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_VVV_MF8 /* 1252 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_VVV_SE_M1 /* 1253 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_VVV_SE_M2 /* 1254 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_VVV_SE_M4 /* 1255 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_VVV_SE_M8 /* 1256 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_VVV_SE_MF2 /* 1257 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_VVV_SE_MF4 /* 1258 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_VVV_SE_MF8 /* 1259 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_VVW_M1 /* 1260 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_VVW_M2 /* 1261 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_VVW_M4 /* 1262 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_VVW_MF2 /* 1263 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_VVW_MF4 /* 1264 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_VVW_MF8 /* 1265 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_VVW_SE_M1 /* 1266 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_VVW_SE_M2 /* 1267 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_VVW_SE_M4 /* 1268 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_VVW_SE_MF2 /* 1269 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_VVW_SE_MF4 /* 1270 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_VVW_SE_MF8 /* 1271 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_VV_M1 /* 1272 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_VV_M2 /* 1273 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_VV_M4 /* 1274 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_VV_M8 /* 1275 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_VV_MF2 /* 1276 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_VV_MF4 /* 1277 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_VV_MF8 /* 1278 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_VV_SE_M1 /* 1279 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_VV_SE_M2 /* 1280 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_VV_SE_M4 /* 1281 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_VV_SE_M8 /* 1282 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_VV_SE_MF2 /* 1283 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_VV_SE_MF4 /* 1284 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_VV_SE_MF8 /* 1285 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_XVV_M1 /* 1286 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_XVV_M2 /* 1287 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_XVV_M4 /* 1288 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_XVV_M8 /* 1289 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_XVV_MF2 /* 1290 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_XVV_MF4 /* 1291 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_XVV_MF8 /* 1292 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_XVV_SE_M1 /* 1293 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_XVV_SE_M2 /* 1294 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_XVV_SE_M4 /* 1295 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_XVV_SE_M8 /* 1296 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_XVV_SE_MF2 /* 1297 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_XVV_SE_MF4 /* 1298 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_XVV_SE_MF8 /* 1299 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_XVW_M1 /* 1300 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_XVW_M2 /* 1301 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_XVW_M4 /* 1302 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_XVW_MF2 /* 1303 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_XVW_MF4 /* 1304 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_XVW_MF8 /* 1305 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_XVW_SE_M1 /* 1306 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_XVW_SE_M2 /* 1307 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_XVW_SE_M4 /* 1308 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_XVW_SE_MF2 /* 1309 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_XVW_SE_MF4 /* 1310 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_XVW_SE_MF8 /* 1311 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_XV_M1 /* 1312 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_XV_M2 /* 1313 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_XV_M4 /* 1314 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_XV_M8 /* 1315 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_XV_MF2 /* 1316 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_XV_MF4 /* 1317 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_XV_MF8 /* 1318 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_XV_SE_M1 /* 1319 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_XV_SE_M2 /* 1320 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_XV_SE_M4 /* 1321 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_XV_SE_M8 /* 1322 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_XV_SE_MF2 /* 1323 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_XV_SE_MF4 /* 1324 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_XV_SE_MF8 /* 1325 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_X_M1 /* 1326 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_X_M2 /* 1327 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_X_M4 /* 1328 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_X_M8 /* 1329 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_X_MF2 /* 1330 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_X_MF4 /* 1331 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_X_MF8 /* 1332 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_X_SE_M1 /* 1333 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_X_SE_M2 /* 1334 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_X_SE_M4 /* 1335 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_X_SE_M8 /* 1336 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_X_SE_MF2 /* 1337 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_X_SE_MF4 /* 1338 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_V_X_SE_MF8 /* 1339 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_XVV_SE_M1 /* 1340 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_XVV_SE_M2 /* 1341 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_XVV_SE_M4 /* 1342 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_XVV_SE_M8 /* 1343 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_XVV_SE_MF2 /* 1344 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_XVV_SE_MF4 /* 1345 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_XVV_SE_MF8 /* 1346 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_XVW_SE_M1 /* 1347 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_XVW_SE_M2 /* 1348 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_XVW_SE_M4 /* 1349 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_XVW_SE_MF2 /* 1350 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_XVW_SE_MF4 /* 1351 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_XVW_SE_MF8 /* 1352 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_XV_SE_M1 /* 1353 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_XV_SE_M2 /* 1354 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_XV_SE_M4 /* 1355 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_XV_SE_M8 /* 1356 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_XV_SE_MF2 /* 1357 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_XV_SE_MF4 /* 1358 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_XV_SE_MF8 /* 1359 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_X_SE_M1 /* 1360 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_X_SE_M2 /* 1361 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_X_SE_M4 /* 1362 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_X_SE_M8 /* 1363 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_X_SE_MF2 /* 1364 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_X_SE_MF4 /* 1365 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVC_X_SE_MF8 /* 1366 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VV_M1_E16 /* 1367 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VV_M1_E16_MASK /* 1368 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VV_M1_E32 /* 1369 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VV_M1_E32_MASK /* 1370 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VV_M1_E64 /* 1371 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VV_M1_E64_MASK /* 1372 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VV_M1_E8 /* 1373 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VV_M1_E8_MASK /* 1374 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VV_M2_E16 /* 1375 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VV_M2_E16_MASK /* 1376 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VV_M2_E32 /* 1377 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VV_M2_E32_MASK /* 1378 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VV_M2_E64 /* 1379 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VV_M2_E64_MASK /* 1380 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VV_M2_E8 /* 1381 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VV_M2_E8_MASK /* 1382 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VV_M4_E16 /* 1383 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VV_M4_E16_MASK /* 1384 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VV_M4_E32 /* 1385 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VV_M4_E32_MASK /* 1386 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VV_M4_E64 /* 1387 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VV_M4_E64_MASK /* 1388 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VV_M4_E8 /* 1389 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VV_M4_E8_MASK /* 1390 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VV_M8_E16 /* 1391 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VV_M8_E16_MASK /* 1392 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VV_M8_E32 /* 1393 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VV_M8_E32_MASK /* 1394 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VV_M8_E64 /* 1395 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VV_M8_E64_MASK /* 1396 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VV_M8_E8 /* 1397 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VV_M8_E8_MASK /* 1398 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VV_MF2_E16 /* 1399 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VV_MF2_E16_MASK /* 1400 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VV_MF2_E32 /* 1401 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VV_MF2_E32_MASK /* 1402 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VV_MF2_E8 /* 1403 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VV_MF2_E8_MASK /* 1404 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VV_MF4_E16 /* 1405 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VV_MF4_E16_MASK /* 1406 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VV_MF4_E8 /* 1407 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VV_MF4_E8_MASK /* 1408 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VV_MF8_E8 /* 1409 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VV_MF8_E8_MASK /* 1410 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VX_M1_E16 /* 1411 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VX_M1_E16_MASK /* 1412 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VX_M1_E32 /* 1413 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VX_M1_E32_MASK /* 1414 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VX_M1_E64 /* 1415 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VX_M1_E64_MASK /* 1416 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VX_M1_E8 /* 1417 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VX_M1_E8_MASK /* 1418 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VX_M2_E16 /* 1419 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VX_M2_E16_MASK /* 1420 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VX_M2_E32 /* 1421 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VX_M2_E32_MASK /* 1422 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VX_M2_E64 /* 1423 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VX_M2_E64_MASK /* 1424 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VX_M2_E8 /* 1425 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VX_M2_E8_MASK /* 1426 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VX_M4_E16 /* 1427 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VX_M4_E16_MASK /* 1428 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VX_M4_E32 /* 1429 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VX_M4_E32_MASK /* 1430 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VX_M4_E64 /* 1431 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VX_M4_E64_MASK /* 1432 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VX_M4_E8 /* 1433 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VX_M4_E8_MASK /* 1434 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VX_M8_E16 /* 1435 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VX_M8_E16_MASK /* 1436 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VX_M8_E32 /* 1437 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VX_M8_E32_MASK /* 1438 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VX_M8_E64 /* 1439 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VX_M8_E64_MASK /* 1440 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VX_M8_E8 /* 1441 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VX_M8_E8_MASK /* 1442 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VX_MF2_E16 /* 1443 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VX_MF2_E16_MASK /* 1444 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VX_MF2_E32 /* 1445 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VX_MF2_E32_MASK /* 1446 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VX_MF2_E8 /* 1447 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VX_MF2_E8_MASK /* 1448 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VX_MF4_E16 /* 1449 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VX_MF4_E16_MASK /* 1450 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VX_MF4_E8 /* 1451 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VX_MF4_E8_MASK /* 1452 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VX_MF8_E8 /* 1453 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIVU_VX_MF8_E8_MASK /* 1454 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VV_M1_E16 /* 1455 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VV_M1_E16_MASK /* 1456 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VV_M1_E32 /* 1457 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VV_M1_E32_MASK /* 1458 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VV_M1_E64 /* 1459 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VV_M1_E64_MASK /* 1460 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VV_M1_E8 /* 1461 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VV_M1_E8_MASK /* 1462 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VV_M2_E16 /* 1463 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VV_M2_E16_MASK /* 1464 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VV_M2_E32 /* 1465 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VV_M2_E32_MASK /* 1466 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VV_M2_E64 /* 1467 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VV_M2_E64_MASK /* 1468 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VV_M2_E8 /* 1469 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VV_M2_E8_MASK /* 1470 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VV_M4_E16 /* 1471 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VV_M4_E16_MASK /* 1472 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VV_M4_E32 /* 1473 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VV_M4_E32_MASK /* 1474 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VV_M4_E64 /* 1475 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VV_M4_E64_MASK /* 1476 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VV_M4_E8 /* 1477 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VV_M4_E8_MASK /* 1478 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VV_M8_E16 /* 1479 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VV_M8_E16_MASK /* 1480 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VV_M8_E32 /* 1481 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VV_M8_E32_MASK /* 1482 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VV_M8_E64 /* 1483 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VV_M8_E64_MASK /* 1484 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VV_M8_E8 /* 1485 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VV_M8_E8_MASK /* 1486 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VV_MF2_E16 /* 1487 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VV_MF2_E16_MASK /* 1488 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VV_MF2_E32 /* 1489 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VV_MF2_E32_MASK /* 1490 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VV_MF2_E8 /* 1491 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VV_MF2_E8_MASK /* 1492 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VV_MF4_E16 /* 1493 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VV_MF4_E16_MASK /* 1494 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VV_MF4_E8 /* 1495 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VV_MF4_E8_MASK /* 1496 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VV_MF8_E8 /* 1497 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VV_MF8_E8_MASK /* 1498 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VX_M1_E16 /* 1499 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VX_M1_E16_MASK /* 1500 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VX_M1_E32 /* 1501 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VX_M1_E32_MASK /* 1502 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VX_M1_E64 /* 1503 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VX_M1_E64_MASK /* 1504 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VX_M1_E8 /* 1505 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VX_M1_E8_MASK /* 1506 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VX_M2_E16 /* 1507 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VX_M2_E16_MASK /* 1508 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VX_M2_E32 /* 1509 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VX_M2_E32_MASK /* 1510 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VX_M2_E64 /* 1511 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VX_M2_E64_MASK /* 1512 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VX_M2_E8 /* 1513 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VX_M2_E8_MASK /* 1514 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VX_M4_E16 /* 1515 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VX_M4_E16_MASK /* 1516 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VX_M4_E32 /* 1517 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VX_M4_E32_MASK /* 1518 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VX_M4_E64 /* 1519 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VX_M4_E64_MASK /* 1520 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VX_M4_E8 /* 1521 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VX_M4_E8_MASK /* 1522 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VX_M8_E16 /* 1523 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VX_M8_E16_MASK /* 1524 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VX_M8_E32 /* 1525 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VX_M8_E32_MASK /* 1526 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VX_M8_E64 /* 1527 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VX_M8_E64_MASK /* 1528 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VX_M8_E8 /* 1529 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VX_M8_E8_MASK /* 1530 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VX_MF2_E16 /* 1531 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VX_MF2_E16_MASK /* 1532 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VX_MF2_E32 /* 1533 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VX_MF2_E32_MASK /* 1534 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VX_MF2_E8 /* 1535 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VX_MF2_E8_MASK /* 1536 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VX_MF4_E16 /* 1537 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VX_MF4_E16_MASK /* 1538 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VX_MF4_E8 /* 1539 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VX_MF4_E8_MASK /* 1540 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VX_MF8_E8 /* 1541 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVDIV_VX_MF8_E8_MASK /* 1542 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFADD_VFPR16_M1 /* 1543 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFADD_VFPR16_M1_MASK /* 1544 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFADD_VFPR16_M2 /* 1545 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFADD_VFPR16_M2_MASK /* 1546 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFADD_VFPR16_M4 /* 1547 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFADD_VFPR16_M4_MASK /* 1548 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFADD_VFPR16_M8 /* 1549 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFADD_VFPR16_M8_MASK /* 1550 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFADD_VFPR16_MF2 /* 1551 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFADD_VFPR16_MF2_MASK /* 1552 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFADD_VFPR16_MF4 /* 1553 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFADD_VFPR16_MF4_MASK /* 1554 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFADD_VFPR32_M1 /* 1555 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFADD_VFPR32_M1_MASK /* 1556 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFADD_VFPR32_M2 /* 1557 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFADD_VFPR32_M2_MASK /* 1558 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFADD_VFPR32_M4 /* 1559 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFADD_VFPR32_M4_MASK /* 1560 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFADD_VFPR32_M8 /* 1561 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFADD_VFPR32_M8_MASK /* 1562 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFADD_VFPR32_MF2 /* 1563 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFADD_VFPR32_MF2_MASK /* 1564 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFADD_VFPR64_M1 /* 1565 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFADD_VFPR64_M1_MASK /* 1566 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFADD_VFPR64_M2 /* 1567 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFADD_VFPR64_M2_MASK /* 1568 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFADD_VFPR64_M4 /* 1569 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFADD_VFPR64_M4_MASK /* 1570 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFADD_VFPR64_M8 /* 1571 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFADD_VFPR64_M8_MASK /* 1572 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFADD_VV_M1 /* 1573 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFADD_VV_M1_MASK /* 1574 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFADD_VV_M2 /* 1575 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFADD_VV_M2_MASK /* 1576 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFADD_VV_M4 /* 1577 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFADD_VV_M4_MASK /* 1578 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFADD_VV_M8 /* 1579 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFADD_VV_M8_MASK /* 1580 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFADD_VV_MF2 /* 1581 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFADD_VV_MF2_MASK /* 1582 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFADD_VV_MF4 /* 1583 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFADD_VV_MF4_MASK /* 1584 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCLASS_V_M1 /* 1585 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCLASS_V_M1_MASK /* 1586 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCLASS_V_M2 /* 1587 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCLASS_V_M2_MASK /* 1588 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCLASS_V_M4 /* 1589 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCLASS_V_M4_MASK /* 1590 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCLASS_V_M8 /* 1591 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCLASS_V_M8_MASK /* 1592 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCLASS_V_MF2 /* 1593 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCLASS_V_MF2_MASK /* 1594 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCLASS_V_MF4 /* 1595 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCLASS_V_MF4_MASK /* 1596 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_F_XU_V_M1 /* 1597 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_F_XU_V_M1_MASK /* 1598 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_F_XU_V_M2 /* 1599 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_F_XU_V_M2_MASK /* 1600 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_F_XU_V_M4 /* 1601 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_F_XU_V_M4_MASK /* 1602 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_F_XU_V_M8 /* 1603 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_F_XU_V_M8_MASK /* 1604 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_F_XU_V_MF2 /* 1605 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_F_XU_V_MF2_MASK /* 1606 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_F_XU_V_MF4 /* 1607 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_F_XU_V_MF4_MASK /* 1608 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_F_X_V_M1 /* 1609 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_F_X_V_M1_MASK /* 1610 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_F_X_V_M2 /* 1611 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_F_X_V_M2_MASK /* 1612 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_F_X_V_M4 /* 1613 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_F_X_V_M4_MASK /* 1614 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_F_X_V_M8 /* 1615 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_F_X_V_M8_MASK /* 1616 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_F_X_V_MF2 /* 1617 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_F_X_V_MF2_MASK /* 1618 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_F_X_V_MF4 /* 1619 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_F_X_V_MF4_MASK /* 1620 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RM_F_XU_V_M1 /* 1621 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RM_F_XU_V_M1_MASK /* 1622 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RM_F_XU_V_M2 /* 1623 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RM_F_XU_V_M2_MASK /* 1624 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RM_F_XU_V_M4 /* 1625 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RM_F_XU_V_M4_MASK /* 1626 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RM_F_XU_V_M8 /* 1627 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RM_F_XU_V_M8_MASK /* 1628 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RM_F_XU_V_MF2 /* 1629 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RM_F_XU_V_MF2_MASK /* 1630 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RM_F_XU_V_MF4 /* 1631 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RM_F_XU_V_MF4_MASK /* 1632 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RM_F_X_V_M1 /* 1633 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RM_F_X_V_M1_MASK /* 1634 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RM_F_X_V_M2 /* 1635 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RM_F_X_V_M2_MASK /* 1636 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RM_F_X_V_M4 /* 1637 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RM_F_X_V_M4_MASK /* 1638 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RM_F_X_V_M8 /* 1639 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RM_F_X_V_M8_MASK /* 1640 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RM_F_X_V_MF2 /* 1641 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RM_F_X_V_MF2_MASK /* 1642 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RM_F_X_V_MF4 /* 1643 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RM_F_X_V_MF4_MASK /* 1644 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RM_XU_F_V_M1 /* 1645 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RM_XU_F_V_M1_MASK /* 1646 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RM_XU_F_V_M2 /* 1647 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RM_XU_F_V_M2_MASK /* 1648 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RM_XU_F_V_M4 /* 1649 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RM_XU_F_V_M4_MASK /* 1650 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RM_XU_F_V_M8 /* 1651 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RM_XU_F_V_M8_MASK /* 1652 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RM_XU_F_V_MF2 /* 1653 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RM_XU_F_V_MF2_MASK /* 1654 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RM_XU_F_V_MF4 /* 1655 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RM_XU_F_V_MF4_MASK /* 1656 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RM_X_F_V_M1 /* 1657 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RM_X_F_V_M1_MASK /* 1658 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RM_X_F_V_M2 /* 1659 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RM_X_F_V_M2_MASK /* 1660 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RM_X_F_V_M4 /* 1661 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RM_X_F_V_M4_MASK /* 1662 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RM_X_F_V_M8 /* 1663 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RM_X_F_V_M8_MASK /* 1664 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RM_X_F_V_MF2 /* 1665 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RM_X_F_V_MF2_MASK /* 1666 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RM_X_F_V_MF4 /* 1667 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RM_X_F_V_MF4_MASK /* 1668 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RTZ_XU_F_V_M1 /* 1669 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RTZ_XU_F_V_M1_MASK /* 1670 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RTZ_XU_F_V_M2 /* 1671 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RTZ_XU_F_V_M2_MASK /* 1672 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RTZ_XU_F_V_M4 /* 1673 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RTZ_XU_F_V_M4_MASK /* 1674 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RTZ_XU_F_V_M8 /* 1675 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RTZ_XU_F_V_M8_MASK /* 1676 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RTZ_XU_F_V_MF2 /* 1677 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RTZ_XU_F_V_MF2_MASK /* 1678 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RTZ_XU_F_V_MF4 /* 1679 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RTZ_XU_F_V_MF4_MASK /* 1680 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RTZ_X_F_V_M1 /* 1681 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RTZ_X_F_V_M1_MASK /* 1682 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RTZ_X_F_V_M2 /* 1683 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RTZ_X_F_V_M2_MASK /* 1684 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RTZ_X_F_V_M4 /* 1685 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RTZ_X_F_V_M4_MASK /* 1686 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RTZ_X_F_V_M8 /* 1687 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RTZ_X_F_V_M8_MASK /* 1688 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RTZ_X_F_V_MF2 /* 1689 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RTZ_X_F_V_MF2_MASK /* 1690 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RTZ_X_F_V_MF4 /* 1691 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_RTZ_X_F_V_MF4_MASK /* 1692 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_XU_F_V_M1 /* 1693 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_XU_F_V_M1_MASK /* 1694 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_XU_F_V_M2 /* 1695 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_XU_F_V_M2_MASK /* 1696 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_XU_F_V_M4 /* 1697 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_XU_F_V_M4_MASK /* 1698 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_XU_F_V_M8 /* 1699 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_XU_F_V_M8_MASK /* 1700 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_XU_F_V_MF2 /* 1701 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_XU_F_V_MF2_MASK /* 1702 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_XU_F_V_MF4 /* 1703 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_XU_F_V_MF4_MASK /* 1704 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_X_F_V_M1 /* 1705 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_X_F_V_M1_MASK /* 1706 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_X_F_V_M2 /* 1707 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_X_F_V_M2_MASK /* 1708 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_X_F_V_M4 /* 1709 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_X_F_V_M4_MASK /* 1710 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_X_F_V_M8 /* 1711 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_X_F_V_M8_MASK /* 1712 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_X_F_V_MF2 /* 1713 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_X_F_V_MF2_MASK /* 1714 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_X_F_V_MF4 /* 1715 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFCVT_X_F_V_MF4_MASK /* 1716 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VFPR16_M1_E16 /* 1717 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VFPR16_M1_E16_MASK /* 1718 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VFPR16_M2_E16 /* 1719 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VFPR16_M2_E16_MASK /* 1720 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VFPR16_M4_E16 /* 1721 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VFPR16_M4_E16_MASK /* 1722 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VFPR16_M8_E16 /* 1723 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VFPR16_M8_E16_MASK /* 1724 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VFPR16_MF2_E16 /* 1725 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VFPR16_MF2_E16_MASK /* 1726 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VFPR16_MF4_E16 /* 1727 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VFPR16_MF4_E16_MASK /* 1728 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VFPR32_M1_E32 /* 1729 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VFPR32_M1_E32_MASK /* 1730 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VFPR32_M2_E32 /* 1731 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VFPR32_M2_E32_MASK /* 1732 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VFPR32_M4_E32 /* 1733 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VFPR32_M4_E32_MASK /* 1734 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VFPR32_M8_E32 /* 1735 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VFPR32_M8_E32_MASK /* 1736 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VFPR32_MF2_E32 /* 1737 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VFPR32_MF2_E32_MASK /* 1738 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VFPR64_M1_E64 /* 1739 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VFPR64_M1_E64_MASK /* 1740 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VFPR64_M2_E64 /* 1741 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VFPR64_M2_E64_MASK /* 1742 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VFPR64_M4_E64 /* 1743 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VFPR64_M4_E64_MASK /* 1744 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VFPR64_M8_E64 /* 1745 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VFPR64_M8_E64_MASK /* 1746 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VV_M1_E16 /* 1747 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VV_M1_E16_MASK /* 1748 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VV_M1_E32 /* 1749 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VV_M1_E32_MASK /* 1750 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VV_M1_E64 /* 1751 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VV_M1_E64_MASK /* 1752 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VV_M2_E16 /* 1753 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VV_M2_E16_MASK /* 1754 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VV_M2_E32 /* 1755 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VV_M2_E32_MASK /* 1756 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VV_M2_E64 /* 1757 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VV_M2_E64_MASK /* 1758 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VV_M4_E16 /* 1759 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VV_M4_E16_MASK /* 1760 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VV_M4_E32 /* 1761 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VV_M4_E32_MASK /* 1762 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VV_M4_E64 /* 1763 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VV_M4_E64_MASK /* 1764 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VV_M8_E16 /* 1765 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VV_M8_E16_MASK /* 1766 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VV_M8_E32 /* 1767 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VV_M8_E32_MASK /* 1768 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VV_M8_E64 /* 1769 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VV_M8_E64_MASK /* 1770 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VV_MF2_E16 /* 1771 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VV_MF2_E16_MASK /* 1772 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VV_MF2_E32 /* 1773 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VV_MF2_E32_MASK /* 1774 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VV_MF4_E16 /* 1775 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFDIV_VV_MF4_E16_MASK /* 1776 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFIRST_M_B1 /* 1777 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFIRST_M_B16 /* 1778 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFIRST_M_B16_MASK /* 1779 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFIRST_M_B1_MASK /* 1780 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFIRST_M_B2 /* 1781 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFIRST_M_B2_MASK /* 1782 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFIRST_M_B32 /* 1783 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFIRST_M_B32_MASK /* 1784 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFIRST_M_B4 /* 1785 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFIRST_M_B4_MASK /* 1786 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFIRST_M_B64 /* 1787 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFIRST_M_B64_MASK /* 1788 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFIRST_M_B8 /* 1789 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFIRST_M_B8_MASK /* 1790 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMACC_VFPR16_M1 /* 1791 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMACC_VFPR16_M1_MASK /* 1792 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMACC_VFPR16_M2 /* 1793 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMACC_VFPR16_M2_MASK /* 1794 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMACC_VFPR16_M4 /* 1795 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMACC_VFPR16_M4_MASK /* 1796 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMACC_VFPR16_M8 /* 1797 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMACC_VFPR16_M8_MASK /* 1798 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMACC_VFPR16_MF2 /* 1799 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMACC_VFPR16_MF2_MASK /* 1800 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMACC_VFPR16_MF4 /* 1801 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMACC_VFPR16_MF4_MASK /* 1802 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMACC_VFPR32_M1 /* 1803 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMACC_VFPR32_M1_MASK /* 1804 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMACC_VFPR32_M2 /* 1805 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMACC_VFPR32_M2_MASK /* 1806 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMACC_VFPR32_M4 /* 1807 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMACC_VFPR32_M4_MASK /* 1808 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMACC_VFPR32_M8 /* 1809 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMACC_VFPR32_M8_MASK /* 1810 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMACC_VFPR32_MF2 /* 1811 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMACC_VFPR32_MF2_MASK /* 1812 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMACC_VFPR64_M1 /* 1813 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMACC_VFPR64_M1_MASK /* 1814 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMACC_VFPR64_M2 /* 1815 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMACC_VFPR64_M2_MASK /* 1816 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMACC_VFPR64_M4 /* 1817 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMACC_VFPR64_M4_MASK /* 1818 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMACC_VFPR64_M8 /* 1819 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMACC_VFPR64_M8_MASK /* 1820 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMACC_VV_M1 /* 1821 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMACC_VV_M1_MASK /* 1822 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMACC_VV_M2 /* 1823 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMACC_VV_M2_MASK /* 1824 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMACC_VV_M4 /* 1825 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMACC_VV_M4_MASK /* 1826 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMACC_VV_M8 /* 1827 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMACC_VV_M8_MASK /* 1828 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMACC_VV_MF2 /* 1829 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMACC_VV_MF2_MASK /* 1830 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMACC_VV_MF4 /* 1831 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMACC_VV_MF4_MASK /* 1832 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMADD_VFPR16_M1 /* 1833 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMADD_VFPR16_M1_MASK /* 1834 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMADD_VFPR16_M2 /* 1835 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMADD_VFPR16_M2_MASK /* 1836 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMADD_VFPR16_M4 /* 1837 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMADD_VFPR16_M4_MASK /* 1838 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMADD_VFPR16_M8 /* 1839 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMADD_VFPR16_M8_MASK /* 1840 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMADD_VFPR16_MF2 /* 1841 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMADD_VFPR16_MF2_MASK /* 1842 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMADD_VFPR16_MF4 /* 1843 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMADD_VFPR16_MF4_MASK /* 1844 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMADD_VFPR32_M1 /* 1845 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMADD_VFPR32_M1_MASK /* 1846 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMADD_VFPR32_M2 /* 1847 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMADD_VFPR32_M2_MASK /* 1848 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMADD_VFPR32_M4 /* 1849 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMADD_VFPR32_M4_MASK /* 1850 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMADD_VFPR32_M8 /* 1851 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMADD_VFPR32_M8_MASK /* 1852 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMADD_VFPR32_MF2 /* 1853 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMADD_VFPR32_MF2_MASK /* 1854 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMADD_VFPR64_M1 /* 1855 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMADD_VFPR64_M1_MASK /* 1856 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMADD_VFPR64_M2 /* 1857 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMADD_VFPR64_M2_MASK /* 1858 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMADD_VFPR64_M4 /* 1859 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMADD_VFPR64_M4_MASK /* 1860 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMADD_VFPR64_M8 /* 1861 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMADD_VFPR64_M8_MASK /* 1862 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMADD_VV_M1 /* 1863 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMADD_VV_M1_MASK /* 1864 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMADD_VV_M2 /* 1865 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMADD_VV_M2_MASK /* 1866 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMADD_VV_M4 /* 1867 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMADD_VV_M4_MASK /* 1868 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMADD_VV_M8 /* 1869 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMADD_VV_M8_MASK /* 1870 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMADD_VV_MF2 /* 1871 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMADD_VV_MF2_MASK /* 1872 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMADD_VV_MF4 /* 1873 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMADD_VV_MF4_MASK /* 1874 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMAX_VFPR16_M1 /* 1875 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMAX_VFPR16_M1_MASK /* 1876 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMAX_VFPR16_M2 /* 1877 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMAX_VFPR16_M2_MASK /* 1878 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMAX_VFPR16_M4 /* 1879 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMAX_VFPR16_M4_MASK /* 1880 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMAX_VFPR16_M8 /* 1881 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMAX_VFPR16_M8_MASK /* 1882 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMAX_VFPR16_MF2 /* 1883 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMAX_VFPR16_MF2_MASK /* 1884 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMAX_VFPR16_MF4 /* 1885 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMAX_VFPR16_MF4_MASK /* 1886 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMAX_VFPR32_M1 /* 1887 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMAX_VFPR32_M1_MASK /* 1888 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMAX_VFPR32_M2 /* 1889 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMAX_VFPR32_M2_MASK /* 1890 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMAX_VFPR32_M4 /* 1891 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMAX_VFPR32_M4_MASK /* 1892 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMAX_VFPR32_M8 /* 1893 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMAX_VFPR32_M8_MASK /* 1894 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMAX_VFPR32_MF2 /* 1895 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMAX_VFPR32_MF2_MASK /* 1896 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMAX_VFPR64_M1 /* 1897 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMAX_VFPR64_M1_MASK /* 1898 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMAX_VFPR64_M2 /* 1899 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMAX_VFPR64_M2_MASK /* 1900 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMAX_VFPR64_M4 /* 1901 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMAX_VFPR64_M4_MASK /* 1902 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMAX_VFPR64_M8 /* 1903 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMAX_VFPR64_M8_MASK /* 1904 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMAX_VV_M1 /* 1905 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMAX_VV_M1_MASK /* 1906 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMAX_VV_M2 /* 1907 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMAX_VV_M2_MASK /* 1908 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMAX_VV_M4 /* 1909 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMAX_VV_M4_MASK /* 1910 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMAX_VV_M8 /* 1911 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMAX_VV_M8_MASK /* 1912 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMAX_VV_MF2 /* 1913 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMAX_VV_MF2_MASK /* 1914 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMAX_VV_MF4 /* 1915 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMAX_VV_MF4_MASK /* 1916 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMERGE_VFPR16M_M1 /* 1917 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMERGE_VFPR16M_M2 /* 1918 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMERGE_VFPR16M_M4 /* 1919 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMERGE_VFPR16M_M8 /* 1920 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMERGE_VFPR16M_MF2 /* 1921 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMERGE_VFPR16M_MF4 /* 1922 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMERGE_VFPR32M_M1 /* 1923 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMERGE_VFPR32M_M2 /* 1924 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMERGE_VFPR32M_M4 /* 1925 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMERGE_VFPR32M_M8 /* 1926 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMERGE_VFPR32M_MF2 /* 1927 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMERGE_VFPR64M_M1 /* 1928 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMERGE_VFPR64M_M2 /* 1929 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMERGE_VFPR64M_M4 /* 1930 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMERGE_VFPR64M_M8 /* 1931 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMIN_VFPR16_M1 /* 1932 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMIN_VFPR16_M1_MASK /* 1933 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMIN_VFPR16_M2 /* 1934 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMIN_VFPR16_M2_MASK /* 1935 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMIN_VFPR16_M4 /* 1936 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMIN_VFPR16_M4_MASK /* 1937 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMIN_VFPR16_M8 /* 1938 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMIN_VFPR16_M8_MASK /* 1939 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMIN_VFPR16_MF2 /* 1940 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMIN_VFPR16_MF2_MASK /* 1941 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMIN_VFPR16_MF4 /* 1942 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMIN_VFPR16_MF4_MASK /* 1943 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMIN_VFPR32_M1 /* 1944 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMIN_VFPR32_M1_MASK /* 1945 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMIN_VFPR32_M2 /* 1946 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMIN_VFPR32_M2_MASK /* 1947 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMIN_VFPR32_M4 /* 1948 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMIN_VFPR32_M4_MASK /* 1949 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMIN_VFPR32_M8 /* 1950 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMIN_VFPR32_M8_MASK /* 1951 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMIN_VFPR32_MF2 /* 1952 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMIN_VFPR32_MF2_MASK /* 1953 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMIN_VFPR64_M1 /* 1954 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMIN_VFPR64_M1_MASK /* 1955 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMIN_VFPR64_M2 /* 1956 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMIN_VFPR64_M2_MASK /* 1957 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMIN_VFPR64_M4 /* 1958 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMIN_VFPR64_M4_MASK /* 1959 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMIN_VFPR64_M8 /* 1960 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMIN_VFPR64_M8_MASK /* 1961 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMIN_VV_M1 /* 1962 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMIN_VV_M1_MASK /* 1963 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMIN_VV_M2 /* 1964 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMIN_VV_M2_MASK /* 1965 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMIN_VV_M4 /* 1966 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMIN_VV_M4_MASK /* 1967 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMIN_VV_M8 /* 1968 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMIN_VV_M8_MASK /* 1969 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMIN_VV_MF2 /* 1970 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMIN_VV_MF2_MASK /* 1971 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMIN_VV_MF4 /* 1972 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMIN_VV_MF4_MASK /* 1973 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSAC_VFPR16_M1 /* 1974 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSAC_VFPR16_M1_MASK /* 1975 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSAC_VFPR16_M2 /* 1976 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSAC_VFPR16_M2_MASK /* 1977 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSAC_VFPR16_M4 /* 1978 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSAC_VFPR16_M4_MASK /* 1979 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSAC_VFPR16_M8 /* 1980 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSAC_VFPR16_M8_MASK /* 1981 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSAC_VFPR16_MF2 /* 1982 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSAC_VFPR16_MF2_MASK /* 1983 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSAC_VFPR16_MF4 /* 1984 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSAC_VFPR16_MF4_MASK /* 1985 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSAC_VFPR32_M1 /* 1986 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSAC_VFPR32_M1_MASK /* 1987 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSAC_VFPR32_M2 /* 1988 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSAC_VFPR32_M2_MASK /* 1989 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSAC_VFPR32_M4 /* 1990 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSAC_VFPR32_M4_MASK /* 1991 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSAC_VFPR32_M8 /* 1992 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSAC_VFPR32_M8_MASK /* 1993 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSAC_VFPR32_MF2 /* 1994 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSAC_VFPR32_MF2_MASK /* 1995 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSAC_VFPR64_M1 /* 1996 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSAC_VFPR64_M1_MASK /* 1997 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSAC_VFPR64_M2 /* 1998 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSAC_VFPR64_M2_MASK /* 1999 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSAC_VFPR64_M4 /* 2000 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSAC_VFPR64_M4_MASK /* 2001 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSAC_VFPR64_M8 /* 2002 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSAC_VFPR64_M8_MASK /* 2003 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSAC_VV_M1 /* 2004 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSAC_VV_M1_MASK /* 2005 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSAC_VV_M2 /* 2006 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSAC_VV_M2_MASK /* 2007 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSAC_VV_M4 /* 2008 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSAC_VV_M4_MASK /* 2009 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSAC_VV_M8 /* 2010 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSAC_VV_M8_MASK /* 2011 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSAC_VV_MF2 /* 2012 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSAC_VV_MF2_MASK /* 2013 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSAC_VV_MF4 /* 2014 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSAC_VV_MF4_MASK /* 2015 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSUB_VFPR16_M1 /* 2016 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSUB_VFPR16_M1_MASK /* 2017 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSUB_VFPR16_M2 /* 2018 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSUB_VFPR16_M2_MASK /* 2019 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSUB_VFPR16_M4 /* 2020 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSUB_VFPR16_M4_MASK /* 2021 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSUB_VFPR16_M8 /* 2022 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSUB_VFPR16_M8_MASK /* 2023 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSUB_VFPR16_MF2 /* 2024 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSUB_VFPR16_MF2_MASK /* 2025 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSUB_VFPR16_MF4 /* 2026 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSUB_VFPR16_MF4_MASK /* 2027 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSUB_VFPR32_M1 /* 2028 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSUB_VFPR32_M1_MASK /* 2029 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSUB_VFPR32_M2 /* 2030 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSUB_VFPR32_M2_MASK /* 2031 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSUB_VFPR32_M4 /* 2032 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSUB_VFPR32_M4_MASK /* 2033 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSUB_VFPR32_M8 /* 2034 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSUB_VFPR32_M8_MASK /* 2035 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSUB_VFPR32_MF2 /* 2036 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSUB_VFPR32_MF2_MASK /* 2037 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSUB_VFPR64_M1 /* 2038 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSUB_VFPR64_M1_MASK /* 2039 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSUB_VFPR64_M2 /* 2040 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSUB_VFPR64_M2_MASK /* 2041 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSUB_VFPR64_M4 /* 2042 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSUB_VFPR64_M4_MASK /* 2043 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSUB_VFPR64_M8 /* 2044 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSUB_VFPR64_M8_MASK /* 2045 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSUB_VV_M1 /* 2046 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSUB_VV_M1_MASK /* 2047 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSUB_VV_M2 /* 2048 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSUB_VV_M2_MASK /* 2049 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSUB_VV_M4 /* 2050 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSUB_VV_M4_MASK /* 2051 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSUB_VV_M8 /* 2052 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSUB_VV_M8_MASK /* 2053 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSUB_VV_MF2 /* 2054 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSUB_VV_MF2_MASK /* 2055 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSUB_VV_MF4 /* 2056 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMSUB_VV_MF4_MASK /* 2057 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMUL_VFPR16_M1 /* 2058 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMUL_VFPR16_M1_MASK /* 2059 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMUL_VFPR16_M2 /* 2060 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMUL_VFPR16_M2_MASK /* 2061 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMUL_VFPR16_M4 /* 2062 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMUL_VFPR16_M4_MASK /* 2063 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMUL_VFPR16_M8 /* 2064 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMUL_VFPR16_M8_MASK /* 2065 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMUL_VFPR16_MF2 /* 2066 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMUL_VFPR16_MF2_MASK /* 2067 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMUL_VFPR16_MF4 /* 2068 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMUL_VFPR16_MF4_MASK /* 2069 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMUL_VFPR32_M1 /* 2070 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMUL_VFPR32_M1_MASK /* 2071 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMUL_VFPR32_M2 /* 2072 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMUL_VFPR32_M2_MASK /* 2073 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMUL_VFPR32_M4 /* 2074 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMUL_VFPR32_M4_MASK /* 2075 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMUL_VFPR32_M8 /* 2076 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMUL_VFPR32_M8_MASK /* 2077 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMUL_VFPR32_MF2 /* 2078 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMUL_VFPR32_MF2_MASK /* 2079 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMUL_VFPR64_M1 /* 2080 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMUL_VFPR64_M1_MASK /* 2081 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMUL_VFPR64_M2 /* 2082 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMUL_VFPR64_M2_MASK /* 2083 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMUL_VFPR64_M4 /* 2084 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMUL_VFPR64_M4_MASK /* 2085 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMUL_VFPR64_M8 /* 2086 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMUL_VFPR64_M8_MASK /* 2087 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMUL_VV_M1 /* 2088 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMUL_VV_M1_MASK /* 2089 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMUL_VV_M2 /* 2090 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMUL_VV_M2_MASK /* 2091 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMUL_VV_M4 /* 2092 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMUL_VV_M4_MASK /* 2093 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMUL_VV_M8 /* 2094 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMUL_VV_M8_MASK /* 2095 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMUL_VV_MF2 /* 2096 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMUL_VV_MF2_MASK /* 2097 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMUL_VV_MF4 /* 2098 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMUL_VV_MF4_MASK /* 2099 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMV_FPR16_S_M1 /* 2100 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMV_FPR16_S_M2 /* 2101 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMV_FPR16_S_M4 /* 2102 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMV_FPR16_S_M8 /* 2103 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMV_FPR16_S_MF2 /* 2104 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMV_FPR16_S_MF4 /* 2105 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMV_FPR32_S_M1 /* 2106 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMV_FPR32_S_M2 /* 2107 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMV_FPR32_S_M4 /* 2108 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMV_FPR32_S_M8 /* 2109 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMV_FPR32_S_MF2 /* 2110 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMV_FPR64_S_M1 /* 2111 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMV_FPR64_S_M2 /* 2112 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMV_FPR64_S_M4 /* 2113 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMV_FPR64_S_M8 /* 2114 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMV_S_FPR16_M1 /* 2115 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMV_S_FPR16_M2 /* 2116 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMV_S_FPR16_M4 /* 2117 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMV_S_FPR16_M8 /* 2118 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMV_S_FPR16_MF2 /* 2119 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMV_S_FPR16_MF4 /* 2120 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMV_S_FPR32_M1 /* 2121 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMV_S_FPR32_M2 /* 2122 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMV_S_FPR32_M4 /* 2123 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMV_S_FPR32_M8 /* 2124 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMV_S_FPR32_MF2 /* 2125 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMV_S_FPR64_M1 /* 2126 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMV_S_FPR64_M2 /* 2127 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMV_S_FPR64_M4 /* 2128 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMV_S_FPR64_M8 /* 2129 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMV_V_FPR16_M1 /* 2130 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMV_V_FPR16_M2 /* 2131 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMV_V_FPR16_M4 /* 2132 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMV_V_FPR16_M8 /* 2133 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMV_V_FPR16_MF2 /* 2134 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMV_V_FPR16_MF4 /* 2135 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMV_V_FPR32_M1 /* 2136 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMV_V_FPR32_M2 /* 2137 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMV_V_FPR32_M4 /* 2138 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMV_V_FPR32_M8 /* 2139 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMV_V_FPR32_MF2 /* 2140 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMV_V_FPR64_M1 /* 2141 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMV_V_FPR64_M2 /* 2142 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMV_V_FPR64_M4 /* 2143 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFMV_V_FPR64_M8 /* 2144 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVTBF16_F_F_W_M1 /* 2145 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVTBF16_F_F_W_M1_MASK /* 2146 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVTBF16_F_F_W_M2 /* 2147 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVTBF16_F_F_W_M2_MASK /* 2148 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVTBF16_F_F_W_M4 /* 2149 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVTBF16_F_F_W_M4_MASK /* 2150 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVTBF16_F_F_W_MF2 /* 2151 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVTBF16_F_F_W_MF2_MASK /* 2152 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVTBF16_F_F_W_MF4 /* 2153 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVTBF16_F_F_W_MF4_MASK /* 2154 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_F_F_W_M1 /* 2155 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_F_F_W_M1_MASK /* 2156 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_F_F_W_M2 /* 2157 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_F_F_W_M2_MASK /* 2158 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_F_F_W_M4 /* 2159 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_F_F_W_M4_MASK /* 2160 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_F_F_W_MF2 /* 2161 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_F_F_W_MF2_MASK /* 2162 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_F_F_W_MF4 /* 2163 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_F_F_W_MF4_MASK /* 2164 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_F_XU_W_M1 /* 2165 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_F_XU_W_M1_MASK /* 2166 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_F_XU_W_M2 /* 2167 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_F_XU_W_M2_MASK /* 2168 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_F_XU_W_M4 /* 2169 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_F_XU_W_M4_MASK /* 2170 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_F_XU_W_MF2 /* 2171 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_F_XU_W_MF2_MASK /* 2172 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_F_XU_W_MF4 /* 2173 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_F_XU_W_MF4_MASK /* 2174 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_F_X_W_M1 /* 2175 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_F_X_W_M1_MASK /* 2176 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_F_X_W_M2 /* 2177 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_F_X_W_M2_MASK /* 2178 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_F_X_W_M4 /* 2179 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_F_X_W_M4_MASK /* 2180 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_F_X_W_MF2 /* 2181 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_F_X_W_MF2_MASK /* 2182 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_F_X_W_MF4 /* 2183 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_F_X_W_MF4_MASK /* 2184 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RM_F_XU_W_M1 /* 2185 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RM_F_XU_W_M1_MASK /* 2186 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RM_F_XU_W_M2 /* 2187 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RM_F_XU_W_M2_MASK /* 2188 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RM_F_XU_W_M4 /* 2189 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RM_F_XU_W_M4_MASK /* 2190 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RM_F_XU_W_MF2 /* 2191 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RM_F_XU_W_MF2_MASK /* 2192 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RM_F_XU_W_MF4 /* 2193 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RM_F_XU_W_MF4_MASK /* 2194 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RM_F_X_W_M1 /* 2195 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RM_F_X_W_M1_MASK /* 2196 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RM_F_X_W_M2 /* 2197 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RM_F_X_W_M2_MASK /* 2198 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RM_F_X_W_M4 /* 2199 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RM_F_X_W_M4_MASK /* 2200 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RM_F_X_W_MF2 /* 2201 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RM_F_X_W_MF2_MASK /* 2202 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RM_F_X_W_MF4 /* 2203 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RM_F_X_W_MF4_MASK /* 2204 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RM_XU_F_W_M1 /* 2205 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RM_XU_F_W_M1_MASK /* 2206 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RM_XU_F_W_M2 /* 2207 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RM_XU_F_W_M2_MASK /* 2208 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RM_XU_F_W_M4 /* 2209 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RM_XU_F_W_M4_MASK /* 2210 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RM_XU_F_W_MF2 /* 2211 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RM_XU_F_W_MF2_MASK /* 2212 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RM_XU_F_W_MF4 /* 2213 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RM_XU_F_W_MF4_MASK /* 2214 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RM_XU_F_W_MF8 /* 2215 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RM_XU_F_W_MF8_MASK /* 2216 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RM_X_F_W_M1 /* 2217 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RM_X_F_W_M1_MASK /* 2218 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RM_X_F_W_M2 /* 2219 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RM_X_F_W_M2_MASK /* 2220 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RM_X_F_W_M4 /* 2221 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RM_X_F_W_M4_MASK /* 2222 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RM_X_F_W_MF2 /* 2223 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RM_X_F_W_MF2_MASK /* 2224 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RM_X_F_W_MF4 /* 2225 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RM_X_F_W_MF4_MASK /* 2226 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RM_X_F_W_MF8 /* 2227 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RM_X_F_W_MF8_MASK /* 2228 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_ROD_F_F_W_M1 /* 2229 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_ROD_F_F_W_M1_MASK /* 2230 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_ROD_F_F_W_M2 /* 2231 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_ROD_F_F_W_M2_MASK /* 2232 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_ROD_F_F_W_M4 /* 2233 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_ROD_F_F_W_M4_MASK /* 2234 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_ROD_F_F_W_MF2 /* 2235 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_ROD_F_F_W_MF2_MASK /* 2236 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_ROD_F_F_W_MF4 /* 2237 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_ROD_F_F_W_MF4_MASK /* 2238 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RTZ_XU_F_W_M1 /* 2239 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RTZ_XU_F_W_M1_MASK /* 2240 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RTZ_XU_F_W_M2 /* 2241 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RTZ_XU_F_W_M2_MASK /* 2242 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RTZ_XU_F_W_M4 /* 2243 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RTZ_XU_F_W_M4_MASK /* 2244 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RTZ_XU_F_W_MF2 /* 2245 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RTZ_XU_F_W_MF2_MASK /* 2246 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RTZ_XU_F_W_MF4 /* 2247 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RTZ_XU_F_W_MF4_MASK /* 2248 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RTZ_XU_F_W_MF8 /* 2249 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RTZ_XU_F_W_MF8_MASK /* 2250 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RTZ_X_F_W_M1 /* 2251 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RTZ_X_F_W_M1_MASK /* 2252 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RTZ_X_F_W_M2 /* 2253 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RTZ_X_F_W_M2_MASK /* 2254 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RTZ_X_F_W_M4 /* 2255 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RTZ_X_F_W_M4_MASK /* 2256 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RTZ_X_F_W_MF2 /* 2257 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RTZ_X_F_W_MF2_MASK /* 2258 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RTZ_X_F_W_MF4 /* 2259 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RTZ_X_F_W_MF4_MASK /* 2260 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RTZ_X_F_W_MF8 /* 2261 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_RTZ_X_F_W_MF8_MASK /* 2262 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_XU_F_W_M1 /* 2263 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_XU_F_W_M1_MASK /* 2264 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_XU_F_W_M2 /* 2265 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_XU_F_W_M2_MASK /* 2266 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_XU_F_W_M4 /* 2267 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_XU_F_W_M4_MASK /* 2268 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_XU_F_W_MF2 /* 2269 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_XU_F_W_MF2_MASK /* 2270 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_XU_F_W_MF4 /* 2271 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_XU_F_W_MF4_MASK /* 2272 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_XU_F_W_MF8 /* 2273 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_XU_F_W_MF8_MASK /* 2274 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_X_F_W_M1 /* 2275 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_X_F_W_M1_MASK /* 2276 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_X_F_W_M2 /* 2277 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_X_F_W_M2_MASK /* 2278 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_X_F_W_M4 /* 2279 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_X_F_W_M4_MASK /* 2280 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_X_F_W_MF2 /* 2281 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_X_F_W_MF2_MASK /* 2282 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_X_F_W_MF4 /* 2283 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_X_F_W_MF4_MASK /* 2284 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_X_F_W_MF8 /* 2285 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNCVT_X_F_W_MF8_MASK /* 2286 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMACC_VFPR16_M1 /* 2287 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMACC_VFPR16_M1_MASK /* 2288 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMACC_VFPR16_M2 /* 2289 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMACC_VFPR16_M2_MASK /* 2290 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMACC_VFPR16_M4 /* 2291 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMACC_VFPR16_M4_MASK /* 2292 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMACC_VFPR16_M8 /* 2293 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMACC_VFPR16_M8_MASK /* 2294 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMACC_VFPR16_MF2 /* 2295 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMACC_VFPR16_MF2_MASK /* 2296 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMACC_VFPR16_MF4 /* 2297 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMACC_VFPR16_MF4_MASK /* 2298 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMACC_VFPR32_M1 /* 2299 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMACC_VFPR32_M1_MASK /* 2300 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMACC_VFPR32_M2 /* 2301 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMACC_VFPR32_M2_MASK /* 2302 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMACC_VFPR32_M4 /* 2303 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMACC_VFPR32_M4_MASK /* 2304 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMACC_VFPR32_M8 /* 2305 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMACC_VFPR32_M8_MASK /* 2306 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMACC_VFPR32_MF2 /* 2307 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMACC_VFPR32_MF2_MASK /* 2308 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMACC_VFPR64_M1 /* 2309 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMACC_VFPR64_M1_MASK /* 2310 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMACC_VFPR64_M2 /* 2311 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMACC_VFPR64_M2_MASK /* 2312 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMACC_VFPR64_M4 /* 2313 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMACC_VFPR64_M4_MASK /* 2314 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMACC_VFPR64_M8 /* 2315 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMACC_VFPR64_M8_MASK /* 2316 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMACC_VV_M1 /* 2317 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMACC_VV_M1_MASK /* 2318 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMACC_VV_M2 /* 2319 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMACC_VV_M2_MASK /* 2320 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMACC_VV_M4 /* 2321 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMACC_VV_M4_MASK /* 2322 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMACC_VV_M8 /* 2323 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMACC_VV_M8_MASK /* 2324 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMACC_VV_MF2 /* 2325 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMACC_VV_MF2_MASK /* 2326 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMACC_VV_MF4 /* 2327 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMACC_VV_MF4_MASK /* 2328 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMADD_VFPR16_M1 /* 2329 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMADD_VFPR16_M1_MASK /* 2330 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMADD_VFPR16_M2 /* 2331 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMADD_VFPR16_M2_MASK /* 2332 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMADD_VFPR16_M4 /* 2333 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMADD_VFPR16_M4_MASK /* 2334 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMADD_VFPR16_M8 /* 2335 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMADD_VFPR16_M8_MASK /* 2336 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMADD_VFPR16_MF2 /* 2337 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMADD_VFPR16_MF2_MASK /* 2338 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMADD_VFPR16_MF4 /* 2339 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMADD_VFPR16_MF4_MASK /* 2340 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMADD_VFPR32_M1 /* 2341 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMADD_VFPR32_M1_MASK /* 2342 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMADD_VFPR32_M2 /* 2343 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMADD_VFPR32_M2_MASK /* 2344 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMADD_VFPR32_M4 /* 2345 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMADD_VFPR32_M4_MASK /* 2346 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMADD_VFPR32_M8 /* 2347 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMADD_VFPR32_M8_MASK /* 2348 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMADD_VFPR32_MF2 /* 2349 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMADD_VFPR32_MF2_MASK /* 2350 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMADD_VFPR64_M1 /* 2351 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMADD_VFPR64_M1_MASK /* 2352 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMADD_VFPR64_M2 /* 2353 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMADD_VFPR64_M2_MASK /* 2354 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMADD_VFPR64_M4 /* 2355 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMADD_VFPR64_M4_MASK /* 2356 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMADD_VFPR64_M8 /* 2357 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMADD_VFPR64_M8_MASK /* 2358 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMADD_VV_M1 /* 2359 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMADD_VV_M1_MASK /* 2360 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMADD_VV_M2 /* 2361 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMADD_VV_M2_MASK /* 2362 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMADD_VV_M4 /* 2363 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMADD_VV_M4_MASK /* 2364 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMADD_VV_M8 /* 2365 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMADD_VV_M8_MASK /* 2366 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMADD_VV_MF2 /* 2367 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMADD_VV_MF2_MASK /* 2368 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMADD_VV_MF4 /* 2369 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMADD_VV_MF4_MASK /* 2370 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSAC_VFPR16_M1 /* 2371 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSAC_VFPR16_M1_MASK /* 2372 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSAC_VFPR16_M2 /* 2373 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSAC_VFPR16_M2_MASK /* 2374 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSAC_VFPR16_M4 /* 2375 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSAC_VFPR16_M4_MASK /* 2376 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSAC_VFPR16_M8 /* 2377 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSAC_VFPR16_M8_MASK /* 2378 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSAC_VFPR16_MF2 /* 2379 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSAC_VFPR16_MF2_MASK /* 2380 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSAC_VFPR16_MF4 /* 2381 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSAC_VFPR16_MF4_MASK /* 2382 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSAC_VFPR32_M1 /* 2383 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSAC_VFPR32_M1_MASK /* 2384 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSAC_VFPR32_M2 /* 2385 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSAC_VFPR32_M2_MASK /* 2386 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSAC_VFPR32_M4 /* 2387 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSAC_VFPR32_M4_MASK /* 2388 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSAC_VFPR32_M8 /* 2389 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSAC_VFPR32_M8_MASK /* 2390 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSAC_VFPR32_MF2 /* 2391 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSAC_VFPR32_MF2_MASK /* 2392 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSAC_VFPR64_M1 /* 2393 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSAC_VFPR64_M1_MASK /* 2394 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSAC_VFPR64_M2 /* 2395 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSAC_VFPR64_M2_MASK /* 2396 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSAC_VFPR64_M4 /* 2397 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSAC_VFPR64_M4_MASK /* 2398 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSAC_VFPR64_M8 /* 2399 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSAC_VFPR64_M8_MASK /* 2400 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSAC_VV_M1 /* 2401 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSAC_VV_M1_MASK /* 2402 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSAC_VV_M2 /* 2403 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSAC_VV_M2_MASK /* 2404 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSAC_VV_M4 /* 2405 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSAC_VV_M4_MASK /* 2406 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSAC_VV_M8 /* 2407 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSAC_VV_M8_MASK /* 2408 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSAC_VV_MF2 /* 2409 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSAC_VV_MF2_MASK /* 2410 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSAC_VV_MF4 /* 2411 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSAC_VV_MF4_MASK /* 2412 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSUB_VFPR16_M1 /* 2413 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSUB_VFPR16_M1_MASK /* 2414 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSUB_VFPR16_M2 /* 2415 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSUB_VFPR16_M2_MASK /* 2416 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSUB_VFPR16_M4 /* 2417 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSUB_VFPR16_M4_MASK /* 2418 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSUB_VFPR16_M8 /* 2419 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSUB_VFPR16_M8_MASK /* 2420 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSUB_VFPR16_MF2 /* 2421 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSUB_VFPR16_MF2_MASK /* 2422 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSUB_VFPR16_MF4 /* 2423 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSUB_VFPR16_MF4_MASK /* 2424 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSUB_VFPR32_M1 /* 2425 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSUB_VFPR32_M1_MASK /* 2426 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSUB_VFPR32_M2 /* 2427 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSUB_VFPR32_M2_MASK /* 2428 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSUB_VFPR32_M4 /* 2429 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSUB_VFPR32_M4_MASK /* 2430 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSUB_VFPR32_M8 /* 2431 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSUB_VFPR32_M8_MASK /* 2432 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSUB_VFPR32_MF2 /* 2433 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSUB_VFPR32_MF2_MASK /* 2434 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSUB_VFPR64_M1 /* 2435 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSUB_VFPR64_M1_MASK /* 2436 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSUB_VFPR64_M2 /* 2437 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSUB_VFPR64_M2_MASK /* 2438 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSUB_VFPR64_M4 /* 2439 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSUB_VFPR64_M4_MASK /* 2440 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSUB_VFPR64_M8 /* 2441 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSUB_VFPR64_M8_MASK /* 2442 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSUB_VV_M1 /* 2443 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSUB_VV_M1_MASK /* 2444 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSUB_VV_M2 /* 2445 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSUB_VV_M2_MASK /* 2446 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSUB_VV_M4 /* 2447 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSUB_VV_M4_MASK /* 2448 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSUB_VV_M8 /* 2449 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSUB_VV_M8_MASK /* 2450 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSUB_VV_MF2 /* 2451 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSUB_VV_MF2_MASK /* 2452 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSUB_VV_MF4 /* 2453 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNMSUB_VV_MF4_MASK /* 2454 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNRCLIP_XU_F_QF_M1 /* 2455 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNRCLIP_XU_F_QF_M1_MASK /* 2456 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNRCLIP_XU_F_QF_M2 /* 2457 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNRCLIP_XU_F_QF_M2_MASK /* 2458 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNRCLIP_XU_F_QF_MF2 /* 2459 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNRCLIP_XU_F_QF_MF2_MASK /* 2460 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNRCLIP_XU_F_QF_MF4 /* 2461 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNRCLIP_XU_F_QF_MF4_MASK /* 2462 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNRCLIP_XU_F_QF_MF8 /* 2463 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNRCLIP_XU_F_QF_MF8_MASK /* 2464 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNRCLIP_X_F_QF_M1 /* 2465 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNRCLIP_X_F_QF_M1_MASK /* 2466 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNRCLIP_X_F_QF_M2 /* 2467 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNRCLIP_X_F_QF_M2_MASK /* 2468 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNRCLIP_X_F_QF_MF2 /* 2469 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNRCLIP_X_F_QF_MF2_MASK /* 2470 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNRCLIP_X_F_QF_MF4 /* 2471 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNRCLIP_X_F_QF_MF4_MASK /* 2472 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNRCLIP_X_F_QF_MF8 /* 2473 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFNRCLIP_X_F_QF_MF8_MASK /* 2474 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRDIV_VFPR16_M1_E16 /* 2475 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRDIV_VFPR16_M1_E16_MASK /* 2476 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRDIV_VFPR16_M2_E16 /* 2477 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRDIV_VFPR16_M2_E16_MASK /* 2478 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRDIV_VFPR16_M4_E16 /* 2479 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRDIV_VFPR16_M4_E16_MASK /* 2480 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRDIV_VFPR16_M8_E16 /* 2481 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRDIV_VFPR16_M8_E16_MASK /* 2482 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRDIV_VFPR16_MF2_E16 /* 2483 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRDIV_VFPR16_MF2_E16_MASK /* 2484 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRDIV_VFPR16_MF4_E16 /* 2485 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRDIV_VFPR16_MF4_E16_MASK /* 2486 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRDIV_VFPR32_M1_E32 /* 2487 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRDIV_VFPR32_M1_E32_MASK /* 2488 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRDIV_VFPR32_M2_E32 /* 2489 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRDIV_VFPR32_M2_E32_MASK /* 2490 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRDIV_VFPR32_M4_E32 /* 2491 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRDIV_VFPR32_M4_E32_MASK /* 2492 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRDIV_VFPR32_M8_E32 /* 2493 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRDIV_VFPR32_M8_E32_MASK /* 2494 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRDIV_VFPR32_MF2_E32 /* 2495 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRDIV_VFPR32_MF2_E32_MASK /* 2496 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRDIV_VFPR64_M1_E64 /* 2497 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRDIV_VFPR64_M1_E64_MASK /* 2498 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRDIV_VFPR64_M2_E64 /* 2499 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRDIV_VFPR64_M2_E64_MASK /* 2500 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRDIV_VFPR64_M4_E64 /* 2501 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRDIV_VFPR64_M4_E64_MASK /* 2502 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRDIV_VFPR64_M8_E64 /* 2503 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRDIV_VFPR64_M8_E64_MASK /* 2504 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREC7_V_M1 /* 2505 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREC7_V_M1_MASK /* 2506 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREC7_V_M2 /* 2507 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREC7_V_M2_MASK /* 2508 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREC7_V_M4 /* 2509 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREC7_V_M4_MASK /* 2510 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREC7_V_M8 /* 2511 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREC7_V_M8_MASK /* 2512 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREC7_V_MF2 /* 2513 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREC7_V_MF2_MASK /* 2514 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREC7_V_MF4 /* 2515 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREC7_V_MF4_MASK /* 2516 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMAX_VS_M1_E16 /* 2517 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMAX_VS_M1_E16_MASK /* 2518 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMAX_VS_M1_E32 /* 2519 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMAX_VS_M1_E32_MASK /* 2520 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMAX_VS_M1_E64 /* 2521 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMAX_VS_M1_E64_MASK /* 2522 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMAX_VS_M2_E16 /* 2523 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMAX_VS_M2_E16_MASK /* 2524 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMAX_VS_M2_E32 /* 2525 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMAX_VS_M2_E32_MASK /* 2526 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMAX_VS_M2_E64 /* 2527 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMAX_VS_M2_E64_MASK /* 2528 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMAX_VS_M4_E16 /* 2529 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMAX_VS_M4_E16_MASK /* 2530 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMAX_VS_M4_E32 /* 2531 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMAX_VS_M4_E32_MASK /* 2532 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMAX_VS_M4_E64 /* 2533 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMAX_VS_M4_E64_MASK /* 2534 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMAX_VS_M8_E16 /* 2535 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMAX_VS_M8_E16_MASK /* 2536 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMAX_VS_M8_E32 /* 2537 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMAX_VS_M8_E32_MASK /* 2538 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMAX_VS_M8_E64 /* 2539 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMAX_VS_M8_E64_MASK /* 2540 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMAX_VS_MF2_E16 /* 2541 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMAX_VS_MF2_E16_MASK /* 2542 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMAX_VS_MF2_E32 /* 2543 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMAX_VS_MF2_E32_MASK /* 2544 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMAX_VS_MF4_E16 /* 2545 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMAX_VS_MF4_E16_MASK /* 2546 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMIN_VS_M1_E16 /* 2547 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMIN_VS_M1_E16_MASK /* 2548 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMIN_VS_M1_E32 /* 2549 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMIN_VS_M1_E32_MASK /* 2550 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMIN_VS_M1_E64 /* 2551 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMIN_VS_M1_E64_MASK /* 2552 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMIN_VS_M2_E16 /* 2553 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMIN_VS_M2_E16_MASK /* 2554 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMIN_VS_M2_E32 /* 2555 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMIN_VS_M2_E32_MASK /* 2556 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMIN_VS_M2_E64 /* 2557 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMIN_VS_M2_E64_MASK /* 2558 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMIN_VS_M4_E16 /* 2559 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMIN_VS_M4_E16_MASK /* 2560 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMIN_VS_M4_E32 /* 2561 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMIN_VS_M4_E32_MASK /* 2562 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMIN_VS_M4_E64 /* 2563 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMIN_VS_M4_E64_MASK /* 2564 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMIN_VS_M8_E16 /* 2565 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMIN_VS_M8_E16_MASK /* 2566 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMIN_VS_M8_E32 /* 2567 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMIN_VS_M8_E32_MASK /* 2568 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMIN_VS_M8_E64 /* 2569 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMIN_VS_M8_E64_MASK /* 2570 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMIN_VS_MF2_E16 /* 2571 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMIN_VS_MF2_E16_MASK /* 2572 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMIN_VS_MF2_E32 /* 2573 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMIN_VS_MF2_E32_MASK /* 2574 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMIN_VS_MF4_E16 /* 2575 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDMIN_VS_MF4_E16_MASK /* 2576 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDOSUM_VS_M1_E16 /* 2577 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDOSUM_VS_M1_E16_MASK /* 2578 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDOSUM_VS_M1_E32 /* 2579 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDOSUM_VS_M1_E32_MASK /* 2580 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDOSUM_VS_M1_E64 /* 2581 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDOSUM_VS_M1_E64_MASK /* 2582 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDOSUM_VS_M2_E16 /* 2583 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDOSUM_VS_M2_E16_MASK /* 2584 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDOSUM_VS_M2_E32 /* 2585 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDOSUM_VS_M2_E32_MASK /* 2586 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDOSUM_VS_M2_E64 /* 2587 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDOSUM_VS_M2_E64_MASK /* 2588 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDOSUM_VS_M4_E16 /* 2589 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDOSUM_VS_M4_E16_MASK /* 2590 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDOSUM_VS_M4_E32 /* 2591 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDOSUM_VS_M4_E32_MASK /* 2592 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDOSUM_VS_M4_E64 /* 2593 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDOSUM_VS_M4_E64_MASK /* 2594 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDOSUM_VS_M8_E16 /* 2595 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDOSUM_VS_M8_E16_MASK /* 2596 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDOSUM_VS_M8_E32 /* 2597 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDOSUM_VS_M8_E32_MASK /* 2598 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDOSUM_VS_M8_E64 /* 2599 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDOSUM_VS_M8_E64_MASK /* 2600 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDOSUM_VS_MF2_E16 /* 2601 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDOSUM_VS_MF2_E16_MASK /* 2602 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDOSUM_VS_MF2_E32 /* 2603 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDOSUM_VS_MF2_E32_MASK /* 2604 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDOSUM_VS_MF4_E16 /* 2605 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDOSUM_VS_MF4_E16_MASK /* 2606 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDUSUM_VS_M1_E16 /* 2607 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDUSUM_VS_M1_E16_MASK /* 2608 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDUSUM_VS_M1_E32 /* 2609 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDUSUM_VS_M1_E32_MASK /* 2610 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDUSUM_VS_M1_E64 /* 2611 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDUSUM_VS_M1_E64_MASK /* 2612 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDUSUM_VS_M2_E16 /* 2613 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDUSUM_VS_M2_E16_MASK /* 2614 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDUSUM_VS_M2_E32 /* 2615 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDUSUM_VS_M2_E32_MASK /* 2616 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDUSUM_VS_M2_E64 /* 2617 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDUSUM_VS_M2_E64_MASK /* 2618 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDUSUM_VS_M4_E16 /* 2619 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDUSUM_VS_M4_E16_MASK /* 2620 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDUSUM_VS_M4_E32 /* 2621 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDUSUM_VS_M4_E32_MASK /* 2622 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDUSUM_VS_M4_E64 /* 2623 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDUSUM_VS_M4_E64_MASK /* 2624 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDUSUM_VS_M8_E16 /* 2625 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDUSUM_VS_M8_E16_MASK /* 2626 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDUSUM_VS_M8_E32 /* 2627 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDUSUM_VS_M8_E32_MASK /* 2628 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDUSUM_VS_M8_E64 /* 2629 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDUSUM_VS_M8_E64_MASK /* 2630 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDUSUM_VS_MF2_E16 /* 2631 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDUSUM_VS_MF2_E16_MASK /* 2632 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDUSUM_VS_MF2_E32 /* 2633 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDUSUM_VS_MF2_E32_MASK /* 2634 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDUSUM_VS_MF4_E16 /* 2635 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFREDUSUM_VS_MF4_E16_MASK /* 2636 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFROUND_NOEXCEPT_V_M1_MASK /* 2637 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFROUND_NOEXCEPT_V_M2_MASK /* 2638 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFROUND_NOEXCEPT_V_M4_MASK /* 2639 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFROUND_NOEXCEPT_V_M8_MASK /* 2640 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFROUND_NOEXCEPT_V_MF2_MASK /* 2641 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFROUND_NOEXCEPT_V_MF4_MASK /* 2642 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRSQRT7_V_M1 /* 2643 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRSQRT7_V_M1_MASK /* 2644 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRSQRT7_V_M2 /* 2645 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRSQRT7_V_M2_MASK /* 2646 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRSQRT7_V_M4 /* 2647 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRSQRT7_V_M4_MASK /* 2648 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRSQRT7_V_M8 /* 2649 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRSQRT7_V_M8_MASK /* 2650 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRSQRT7_V_MF2 /* 2651 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRSQRT7_V_MF2_MASK /* 2652 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRSQRT7_V_MF4 /* 2653 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRSQRT7_V_MF4_MASK /* 2654 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRSUB_VFPR16_M1 /* 2655 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRSUB_VFPR16_M1_MASK /* 2656 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRSUB_VFPR16_M2 /* 2657 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRSUB_VFPR16_M2_MASK /* 2658 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRSUB_VFPR16_M4 /* 2659 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRSUB_VFPR16_M4_MASK /* 2660 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRSUB_VFPR16_M8 /* 2661 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRSUB_VFPR16_M8_MASK /* 2662 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRSUB_VFPR16_MF2 /* 2663 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRSUB_VFPR16_MF2_MASK /* 2664 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRSUB_VFPR16_MF4 /* 2665 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRSUB_VFPR16_MF4_MASK /* 2666 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRSUB_VFPR32_M1 /* 2667 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRSUB_VFPR32_M1_MASK /* 2668 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRSUB_VFPR32_M2 /* 2669 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRSUB_VFPR32_M2_MASK /* 2670 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRSUB_VFPR32_M4 /* 2671 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRSUB_VFPR32_M4_MASK /* 2672 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRSUB_VFPR32_M8 /* 2673 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRSUB_VFPR32_M8_MASK /* 2674 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRSUB_VFPR32_MF2 /* 2675 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRSUB_VFPR32_MF2_MASK /* 2676 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRSUB_VFPR64_M1 /* 2677 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRSUB_VFPR64_M1_MASK /* 2678 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRSUB_VFPR64_M2 /* 2679 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRSUB_VFPR64_M2_MASK /* 2680 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRSUB_VFPR64_M4 /* 2681 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRSUB_VFPR64_M4_MASK /* 2682 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRSUB_VFPR64_M8 /* 2683 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFRSUB_VFPR64_M8_MASK /* 2684 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJN_VFPR16_M1 /* 2685 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJN_VFPR16_M1_MASK /* 2686 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJN_VFPR16_M2 /* 2687 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJN_VFPR16_M2_MASK /* 2688 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJN_VFPR16_M4 /* 2689 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJN_VFPR16_M4_MASK /* 2690 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJN_VFPR16_M8 /* 2691 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJN_VFPR16_M8_MASK /* 2692 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJN_VFPR16_MF2 /* 2693 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJN_VFPR16_MF2_MASK /* 2694 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJN_VFPR16_MF4 /* 2695 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJN_VFPR16_MF4_MASK /* 2696 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJN_VFPR32_M1 /* 2697 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJN_VFPR32_M1_MASK /* 2698 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJN_VFPR32_M2 /* 2699 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJN_VFPR32_M2_MASK /* 2700 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJN_VFPR32_M4 /* 2701 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJN_VFPR32_M4_MASK /* 2702 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJN_VFPR32_M8 /* 2703 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJN_VFPR32_M8_MASK /* 2704 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJN_VFPR32_MF2 /* 2705 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJN_VFPR32_MF2_MASK /* 2706 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJN_VFPR64_M1 /* 2707 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJN_VFPR64_M1_MASK /* 2708 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJN_VFPR64_M2 /* 2709 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJN_VFPR64_M2_MASK /* 2710 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJN_VFPR64_M4 /* 2711 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJN_VFPR64_M4_MASK /* 2712 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJN_VFPR64_M8 /* 2713 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJN_VFPR64_M8_MASK /* 2714 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJN_VV_M1 /* 2715 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJN_VV_M1_MASK /* 2716 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJN_VV_M2 /* 2717 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJN_VV_M2_MASK /* 2718 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJN_VV_M4 /* 2719 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJN_VV_M4_MASK /* 2720 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJN_VV_M8 /* 2721 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJN_VV_M8_MASK /* 2722 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJN_VV_MF2 /* 2723 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJN_VV_MF2_MASK /* 2724 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJN_VV_MF4 /* 2725 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJN_VV_MF4_MASK /* 2726 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJX_VFPR16_M1 /* 2727 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJX_VFPR16_M1_MASK /* 2728 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJX_VFPR16_M2 /* 2729 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJX_VFPR16_M2_MASK /* 2730 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJX_VFPR16_M4 /* 2731 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJX_VFPR16_M4_MASK /* 2732 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJX_VFPR16_M8 /* 2733 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJX_VFPR16_M8_MASK /* 2734 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJX_VFPR16_MF2 /* 2735 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJX_VFPR16_MF2_MASK /* 2736 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJX_VFPR16_MF4 /* 2737 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJX_VFPR16_MF4_MASK /* 2738 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJX_VFPR32_M1 /* 2739 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJX_VFPR32_M1_MASK /* 2740 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJX_VFPR32_M2 /* 2741 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJX_VFPR32_M2_MASK /* 2742 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJX_VFPR32_M4 /* 2743 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJX_VFPR32_M4_MASK /* 2744 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJX_VFPR32_M8 /* 2745 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJX_VFPR32_M8_MASK /* 2746 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJX_VFPR32_MF2 /* 2747 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJX_VFPR32_MF2_MASK /* 2748 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJX_VFPR64_M1 /* 2749 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJX_VFPR64_M1_MASK /* 2750 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJX_VFPR64_M2 /* 2751 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJX_VFPR64_M2_MASK /* 2752 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJX_VFPR64_M4 /* 2753 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJX_VFPR64_M4_MASK /* 2754 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJX_VFPR64_M8 /* 2755 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJX_VFPR64_M8_MASK /* 2756 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJX_VV_M1 /* 2757 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJX_VV_M1_MASK /* 2758 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJX_VV_M2 /* 2759 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJX_VV_M2_MASK /* 2760 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJX_VV_M4 /* 2761 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJX_VV_M4_MASK /* 2762 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJX_VV_M8 /* 2763 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJX_VV_M8_MASK /* 2764 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJX_VV_MF2 /* 2765 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJX_VV_MF2_MASK /* 2766 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJX_VV_MF4 /* 2767 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJX_VV_MF4_MASK /* 2768 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJ_VFPR16_M1 /* 2769 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJ_VFPR16_M1_MASK /* 2770 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJ_VFPR16_M2 /* 2771 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJ_VFPR16_M2_MASK /* 2772 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJ_VFPR16_M4 /* 2773 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJ_VFPR16_M4_MASK /* 2774 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJ_VFPR16_M8 /* 2775 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJ_VFPR16_M8_MASK /* 2776 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJ_VFPR16_MF2 /* 2777 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJ_VFPR16_MF2_MASK /* 2778 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJ_VFPR16_MF4 /* 2779 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJ_VFPR16_MF4_MASK /* 2780 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJ_VFPR32_M1 /* 2781 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJ_VFPR32_M1_MASK /* 2782 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJ_VFPR32_M2 /* 2783 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJ_VFPR32_M2_MASK /* 2784 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJ_VFPR32_M4 /* 2785 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJ_VFPR32_M4_MASK /* 2786 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJ_VFPR32_M8 /* 2787 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJ_VFPR32_M8_MASK /* 2788 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJ_VFPR32_MF2 /* 2789 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJ_VFPR32_MF2_MASK /* 2790 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJ_VFPR64_M1 /* 2791 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJ_VFPR64_M1_MASK /* 2792 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJ_VFPR64_M2 /* 2793 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJ_VFPR64_M2_MASK /* 2794 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJ_VFPR64_M4 /* 2795 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJ_VFPR64_M4_MASK /* 2796 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJ_VFPR64_M8 /* 2797 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJ_VFPR64_M8_MASK /* 2798 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJ_VV_M1 /* 2799 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJ_VV_M1_MASK /* 2800 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJ_VV_M2 /* 2801 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJ_VV_M2_MASK /* 2802 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJ_VV_M4 /* 2803 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJ_VV_M4_MASK /* 2804 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJ_VV_M8 /* 2805 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJ_VV_M8_MASK /* 2806 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJ_VV_MF2 /* 2807 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJ_VV_MF2_MASK /* 2808 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJ_VV_MF4 /* 2809 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSGNJ_VV_MF4_MASK /* 2810 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1DOWN_VFPR16_M1 /* 2811 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1DOWN_VFPR16_M1_MASK /* 2812 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1DOWN_VFPR16_M2 /* 2813 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1DOWN_VFPR16_M2_MASK /* 2814 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1DOWN_VFPR16_M4 /* 2815 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1DOWN_VFPR16_M4_MASK /* 2816 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1DOWN_VFPR16_M8 /* 2817 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1DOWN_VFPR16_M8_MASK /* 2818 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1DOWN_VFPR16_MF2 /* 2819 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1DOWN_VFPR16_MF2_MASK /* 2820 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1DOWN_VFPR16_MF4 /* 2821 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1DOWN_VFPR16_MF4_MASK /* 2822 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1DOWN_VFPR32_M1 /* 2823 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1DOWN_VFPR32_M1_MASK /* 2824 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1DOWN_VFPR32_M2 /* 2825 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1DOWN_VFPR32_M2_MASK /* 2826 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1DOWN_VFPR32_M4 /* 2827 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1DOWN_VFPR32_M4_MASK /* 2828 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1DOWN_VFPR32_M8 /* 2829 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1DOWN_VFPR32_M8_MASK /* 2830 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1DOWN_VFPR32_MF2 /* 2831 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1DOWN_VFPR32_MF2_MASK /* 2832 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1DOWN_VFPR64_M1 /* 2833 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1DOWN_VFPR64_M1_MASK /* 2834 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1DOWN_VFPR64_M2 /* 2835 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1DOWN_VFPR64_M2_MASK /* 2836 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1DOWN_VFPR64_M4 /* 2837 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1DOWN_VFPR64_M4_MASK /* 2838 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1DOWN_VFPR64_M8 /* 2839 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1DOWN_VFPR64_M8_MASK /* 2840 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1UP_VFPR16_M1 /* 2841 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1UP_VFPR16_M1_MASK /* 2842 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1UP_VFPR16_M2 /* 2843 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1UP_VFPR16_M2_MASK /* 2844 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1UP_VFPR16_M4 /* 2845 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1UP_VFPR16_M4_MASK /* 2846 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1UP_VFPR16_M8 /* 2847 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1UP_VFPR16_M8_MASK /* 2848 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1UP_VFPR16_MF2 /* 2849 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1UP_VFPR16_MF2_MASK /* 2850 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1UP_VFPR16_MF4 /* 2851 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1UP_VFPR16_MF4_MASK /* 2852 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1UP_VFPR32_M1 /* 2853 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1UP_VFPR32_M1_MASK /* 2854 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1UP_VFPR32_M2 /* 2855 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1UP_VFPR32_M2_MASK /* 2856 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1UP_VFPR32_M4 /* 2857 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1UP_VFPR32_M4_MASK /* 2858 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1UP_VFPR32_M8 /* 2859 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1UP_VFPR32_M8_MASK /* 2860 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1UP_VFPR32_MF2 /* 2861 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1UP_VFPR32_MF2_MASK /* 2862 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1UP_VFPR64_M1 /* 2863 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1UP_VFPR64_M1_MASK /* 2864 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1UP_VFPR64_M2 /* 2865 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1UP_VFPR64_M2_MASK /* 2866 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1UP_VFPR64_M4 /* 2867 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1UP_VFPR64_M4_MASK /* 2868 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1UP_VFPR64_M8 /* 2869 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSLIDE1UP_VFPR64_M8_MASK /* 2870 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSQRT_V_M1_E16 /* 2871 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSQRT_V_M1_E16_MASK /* 2872 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSQRT_V_M1_E32 /* 2873 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSQRT_V_M1_E32_MASK /* 2874 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSQRT_V_M1_E64 /* 2875 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSQRT_V_M1_E64_MASK /* 2876 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSQRT_V_M2_E16 /* 2877 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSQRT_V_M2_E16_MASK /* 2878 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSQRT_V_M2_E32 /* 2879 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSQRT_V_M2_E32_MASK /* 2880 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSQRT_V_M2_E64 /* 2881 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSQRT_V_M2_E64_MASK /* 2882 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSQRT_V_M4_E16 /* 2883 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSQRT_V_M4_E16_MASK /* 2884 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSQRT_V_M4_E32 /* 2885 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSQRT_V_M4_E32_MASK /* 2886 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSQRT_V_M4_E64 /* 2887 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSQRT_V_M4_E64_MASK /* 2888 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSQRT_V_M8_E16 /* 2889 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSQRT_V_M8_E16_MASK /* 2890 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSQRT_V_M8_E32 /* 2891 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSQRT_V_M8_E32_MASK /* 2892 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSQRT_V_M8_E64 /* 2893 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSQRT_V_M8_E64_MASK /* 2894 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSQRT_V_MF2_E16 /* 2895 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSQRT_V_MF2_E16_MASK /* 2896 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSQRT_V_MF2_E32 /* 2897 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSQRT_V_MF2_E32_MASK /* 2898 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSQRT_V_MF4_E16 /* 2899 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSQRT_V_MF4_E16_MASK /* 2900 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSUB_VFPR16_M1 /* 2901 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSUB_VFPR16_M1_MASK /* 2902 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSUB_VFPR16_M2 /* 2903 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSUB_VFPR16_M2_MASK /* 2904 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSUB_VFPR16_M4 /* 2905 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSUB_VFPR16_M4_MASK /* 2906 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSUB_VFPR16_M8 /* 2907 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSUB_VFPR16_M8_MASK /* 2908 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSUB_VFPR16_MF2 /* 2909 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSUB_VFPR16_MF2_MASK /* 2910 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSUB_VFPR16_MF4 /* 2911 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSUB_VFPR16_MF4_MASK /* 2912 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSUB_VFPR32_M1 /* 2913 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSUB_VFPR32_M1_MASK /* 2914 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSUB_VFPR32_M2 /* 2915 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSUB_VFPR32_M2_MASK /* 2916 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSUB_VFPR32_M4 /* 2917 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSUB_VFPR32_M4_MASK /* 2918 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSUB_VFPR32_M8 /* 2919 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSUB_VFPR32_M8_MASK /* 2920 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSUB_VFPR32_MF2 /* 2921 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSUB_VFPR32_MF2_MASK /* 2922 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSUB_VFPR64_M1 /* 2923 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSUB_VFPR64_M1_MASK /* 2924 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSUB_VFPR64_M2 /* 2925 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSUB_VFPR64_M2_MASK /* 2926 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSUB_VFPR64_M4 /* 2927 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSUB_VFPR64_M4_MASK /* 2928 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSUB_VFPR64_M8 /* 2929 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSUB_VFPR64_M8_MASK /* 2930 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSUB_VV_M1 /* 2931 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSUB_VV_M1_MASK /* 2932 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSUB_VV_M2 /* 2933 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSUB_VV_M2_MASK /* 2934 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSUB_VV_M4 /* 2935 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSUB_VV_M4_MASK /* 2936 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSUB_VV_M8 /* 2937 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSUB_VV_M8_MASK /* 2938 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSUB_VV_MF2 /* 2939 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSUB_VV_MF2_MASK /* 2940 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSUB_VV_MF4 /* 2941 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFSUB_VV_MF4_MASK /* 2942 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_VFPR16_M1 /* 2943 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_VFPR16_M1_MASK /* 2944 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_VFPR16_M2 /* 2945 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_VFPR16_M2_MASK /* 2946 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_VFPR16_M4 /* 2947 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_VFPR16_M4_MASK /* 2948 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_VFPR16_MF2 /* 2949 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_VFPR16_MF2_MASK /* 2950 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_VFPR16_MF4 /* 2951 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_VFPR16_MF4_MASK /* 2952 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_VFPR32_M1 /* 2953 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_VFPR32_M1_MASK /* 2954 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_VFPR32_M2 /* 2955 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_VFPR32_M2_MASK /* 2956 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_VFPR32_M4 /* 2957 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_VFPR32_M4_MASK /* 2958 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_VFPR32_MF2 /* 2959 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_VFPR32_MF2_MASK /* 2960 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_VV_M1 /* 2961 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_VV_M1_MASK /* 2962 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_VV_M2 /* 2963 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_VV_M2_MASK /* 2964 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_VV_M4 /* 2965 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_VV_M4_MASK /* 2966 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_VV_MF2 /* 2967 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_VV_MF2_MASK /* 2968 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_VV_MF4 /* 2969 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_VV_MF4_MASK /* 2970 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_WFPR16_M1 /* 2971 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_WFPR16_M1_MASK /* 2972 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_WFPR16_M2 /* 2973 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_WFPR16_M2_MASK /* 2974 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_WFPR16_M4 /* 2975 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_WFPR16_M4_MASK /* 2976 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_WFPR16_MF2 /* 2977 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_WFPR16_MF2_MASK /* 2978 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_WFPR16_MF4 /* 2979 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_WFPR16_MF4_MASK /* 2980 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_WFPR32_M1 /* 2981 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_WFPR32_M1_MASK /* 2982 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_WFPR32_M2 /* 2983 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_WFPR32_M2_MASK /* 2984 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_WFPR32_M4 /* 2985 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_WFPR32_M4_MASK /* 2986 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_WFPR32_MF2 /* 2987 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_WFPR32_MF2_MASK /* 2988 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_WV_M1 /* 2989 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_WV_M1_MASK /* 2990 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_WV_M1_MASK_TIED /* 2991 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_WV_M1_TIED /* 2992 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_WV_M2 /* 2993 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_WV_M2_MASK /* 2994 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_WV_M2_MASK_TIED /* 2995 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_WV_M2_TIED /* 2996 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_WV_M4 /* 2997 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_WV_M4_MASK /* 2998 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_WV_M4_MASK_TIED /* 2999 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_WV_M4_TIED /* 3000 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_WV_MF2 /* 3001 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_WV_MF2_MASK /* 3002 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_WV_MF2_MASK_TIED /* 3003 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_WV_MF2_TIED /* 3004 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_WV_MF4 /* 3005 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_WV_MF4_MASK /* 3006 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_WV_MF4_MASK_TIED /* 3007 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWADD_WV_MF4_TIED /* 3008 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVTBF16_F_F_V_M1 /* 3009 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVTBF16_F_F_V_M1_MASK /* 3010 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVTBF16_F_F_V_M2 /* 3011 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVTBF16_F_F_V_M2_MASK /* 3012 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVTBF16_F_F_V_M4 /* 3013 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVTBF16_F_F_V_M4_MASK /* 3014 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVTBF16_F_F_V_MF2 /* 3015 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVTBF16_F_F_V_MF2_MASK /* 3016 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVTBF16_F_F_V_MF4 /* 3017 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVTBF16_F_F_V_MF4_MASK /* 3018 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_F_F_V_M1 /* 3019 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_F_F_V_M1_MASK /* 3020 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_F_F_V_M2 /* 3021 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_F_F_V_M2_MASK /* 3022 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_F_F_V_M4 /* 3023 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_F_F_V_M4_MASK /* 3024 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_F_F_V_MF2 /* 3025 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_F_F_V_MF2_MASK /* 3026 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_F_F_V_MF4 /* 3027 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_F_F_V_MF4_MASK /* 3028 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_F_XU_V_M1 /* 3029 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_F_XU_V_M1_MASK /* 3030 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_F_XU_V_M2 /* 3031 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_F_XU_V_M2_MASK /* 3032 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_F_XU_V_M4 /* 3033 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_F_XU_V_M4_MASK /* 3034 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_F_XU_V_MF2 /* 3035 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_F_XU_V_MF2_MASK /* 3036 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_F_XU_V_MF4 /* 3037 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_F_XU_V_MF4_MASK /* 3038 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_F_XU_V_MF8 /* 3039 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_F_XU_V_MF8_MASK /* 3040 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_F_X_V_M1 /* 3041 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_F_X_V_M1_MASK /* 3042 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_F_X_V_M2 /* 3043 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_F_X_V_M2_MASK /* 3044 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_F_X_V_M4 /* 3045 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_F_X_V_M4_MASK /* 3046 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_F_X_V_MF2 /* 3047 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_F_X_V_MF2_MASK /* 3048 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_F_X_V_MF4 /* 3049 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_F_X_V_MF4_MASK /* 3050 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_F_X_V_MF8 /* 3051 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_F_X_V_MF8_MASK /* 3052 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_RM_XU_F_V_M1 /* 3053 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_RM_XU_F_V_M1_MASK /* 3054 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_RM_XU_F_V_M2 /* 3055 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_RM_XU_F_V_M2_MASK /* 3056 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_RM_XU_F_V_M4 /* 3057 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_RM_XU_F_V_M4_MASK /* 3058 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_RM_XU_F_V_MF2 /* 3059 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_RM_XU_F_V_MF2_MASK /* 3060 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_RM_XU_F_V_MF4 /* 3061 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_RM_XU_F_V_MF4_MASK /* 3062 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_RM_X_F_V_M1 /* 3063 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_RM_X_F_V_M1_MASK /* 3064 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_RM_X_F_V_M2 /* 3065 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_RM_X_F_V_M2_MASK /* 3066 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_RM_X_F_V_M4 /* 3067 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_RM_X_F_V_M4_MASK /* 3068 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_RM_X_F_V_MF2 /* 3069 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_RM_X_F_V_MF2_MASK /* 3070 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_RM_X_F_V_MF4 /* 3071 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_RM_X_F_V_MF4_MASK /* 3072 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_RTZ_XU_F_V_M1 /* 3073 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_RTZ_XU_F_V_M1_MASK /* 3074 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_RTZ_XU_F_V_M2 /* 3075 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_RTZ_XU_F_V_M2_MASK /* 3076 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_RTZ_XU_F_V_M4 /* 3077 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_RTZ_XU_F_V_M4_MASK /* 3078 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_RTZ_XU_F_V_MF2 /* 3079 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_RTZ_XU_F_V_MF2_MASK /* 3080 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_RTZ_XU_F_V_MF4 /* 3081 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_RTZ_XU_F_V_MF4_MASK /* 3082 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_RTZ_X_F_V_M1 /* 3083 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_RTZ_X_F_V_M1_MASK /* 3084 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_RTZ_X_F_V_M2 /* 3085 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_RTZ_X_F_V_M2_MASK /* 3086 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_RTZ_X_F_V_M4 /* 3087 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_RTZ_X_F_V_M4_MASK /* 3088 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_RTZ_X_F_V_MF2 /* 3089 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_RTZ_X_F_V_MF2_MASK /* 3090 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_RTZ_X_F_V_MF4 /* 3091 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_RTZ_X_F_V_MF4_MASK /* 3092 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_XU_F_V_M1 /* 3093 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_XU_F_V_M1_MASK /* 3094 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_XU_F_V_M2 /* 3095 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_XU_F_V_M2_MASK /* 3096 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_XU_F_V_M4 /* 3097 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_XU_F_V_M4_MASK /* 3098 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_XU_F_V_MF2 /* 3099 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_XU_F_V_MF2_MASK /* 3100 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_XU_F_V_MF4 /* 3101 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_XU_F_V_MF4_MASK /* 3102 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_X_F_V_M1 /* 3103 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_X_F_V_M1_MASK /* 3104 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_X_F_V_M2 /* 3105 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_X_F_V_M2_MASK /* 3106 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_X_F_V_M4 /* 3107 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_X_F_V_M4_MASK /* 3108 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_X_F_V_MF2 /* 3109 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_X_F_V_MF2_MASK /* 3110 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_X_F_V_MF4 /* 3111 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWCVT_X_F_V_MF4_MASK /* 3112 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMACCBF16_VFPR16_M1 /* 3113 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMACCBF16_VFPR16_M1_MASK /* 3114 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMACCBF16_VFPR16_M2 /* 3115 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMACCBF16_VFPR16_M2_MASK /* 3116 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMACCBF16_VFPR16_M4 /* 3117 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMACCBF16_VFPR16_M4_MASK /* 3118 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMACCBF16_VFPR16_MF2 /* 3119 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMACCBF16_VFPR16_MF2_MASK /* 3120 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMACCBF16_VFPR16_MF4 /* 3121 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMACCBF16_VFPR16_MF4_MASK /* 3122 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMACCBF16_VV_M1 /* 3123 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMACCBF16_VV_M1_MASK /* 3124 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMACCBF16_VV_M2 /* 3125 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMACCBF16_VV_M2_MASK /* 3126 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMACCBF16_VV_M4 /* 3127 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMACCBF16_VV_M4_MASK /* 3128 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMACCBF16_VV_MF2 /* 3129 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMACCBF16_VV_MF2_MASK /* 3130 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMACCBF16_VV_MF4 /* 3131 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMACCBF16_VV_MF4_MASK /* 3132 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMACC_4x4x4_M1 /* 3133 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMACC_4x4x4_M2 /* 3134 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMACC_4x4x4_M4 /* 3135 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMACC_4x4x4_M8 /* 3136 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMACC_4x4x4_MF2 /* 3137 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMACC_4x4x4_MF4 /* 3138 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMACC_VFPR16_M1 /* 3139 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMACC_VFPR16_M1_MASK /* 3140 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMACC_VFPR16_M2 /* 3141 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMACC_VFPR16_M2_MASK /* 3142 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMACC_VFPR16_M4 /* 3143 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMACC_VFPR16_M4_MASK /* 3144 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMACC_VFPR16_MF2 /* 3145 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMACC_VFPR16_MF2_MASK /* 3146 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMACC_VFPR16_MF4 /* 3147 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMACC_VFPR16_MF4_MASK /* 3148 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMACC_VFPR32_M1 /* 3149 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMACC_VFPR32_M1_MASK /* 3150 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMACC_VFPR32_M2 /* 3151 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMACC_VFPR32_M2_MASK /* 3152 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMACC_VFPR32_M4 /* 3153 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMACC_VFPR32_M4_MASK /* 3154 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMACC_VFPR32_MF2 /* 3155 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMACC_VFPR32_MF2_MASK /* 3156 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMACC_VV_M1 /* 3157 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMACC_VV_M1_MASK /* 3158 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMACC_VV_M2 /* 3159 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMACC_VV_M2_MASK /* 3160 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMACC_VV_M4 /* 3161 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMACC_VV_M4_MASK /* 3162 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMACC_VV_MF2 /* 3163 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMACC_VV_MF2_MASK /* 3164 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMACC_VV_MF4 /* 3165 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMACC_VV_MF4_MASK /* 3166 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMSAC_VFPR16_M1 /* 3167 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMSAC_VFPR16_M1_MASK /* 3168 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMSAC_VFPR16_M2 /* 3169 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMSAC_VFPR16_M2_MASK /* 3170 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMSAC_VFPR16_M4 /* 3171 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMSAC_VFPR16_M4_MASK /* 3172 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMSAC_VFPR16_MF2 /* 3173 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMSAC_VFPR16_MF2_MASK /* 3174 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMSAC_VFPR16_MF4 /* 3175 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMSAC_VFPR16_MF4_MASK /* 3176 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMSAC_VFPR32_M1 /* 3177 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMSAC_VFPR32_M1_MASK /* 3178 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMSAC_VFPR32_M2 /* 3179 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMSAC_VFPR32_M2_MASK /* 3180 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMSAC_VFPR32_M4 /* 3181 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMSAC_VFPR32_M4_MASK /* 3182 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMSAC_VFPR32_MF2 /* 3183 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMSAC_VFPR32_MF2_MASK /* 3184 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMSAC_VV_M1 /* 3185 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMSAC_VV_M1_MASK /* 3186 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMSAC_VV_M2 /* 3187 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMSAC_VV_M2_MASK /* 3188 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMSAC_VV_M4 /* 3189 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMSAC_VV_M4_MASK /* 3190 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMSAC_VV_MF2 /* 3191 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMSAC_VV_MF2_MASK /* 3192 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMSAC_VV_MF4 /* 3193 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMSAC_VV_MF4_MASK /* 3194 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMUL_VFPR16_M1 /* 3195 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMUL_VFPR16_M1_MASK /* 3196 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMUL_VFPR16_M2 /* 3197 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMUL_VFPR16_M2_MASK /* 3198 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMUL_VFPR16_M4 /* 3199 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMUL_VFPR16_M4_MASK /* 3200 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMUL_VFPR16_MF2 /* 3201 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMUL_VFPR16_MF2_MASK /* 3202 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMUL_VFPR16_MF4 /* 3203 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMUL_VFPR16_MF4_MASK /* 3204 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMUL_VFPR32_M1 /* 3205 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMUL_VFPR32_M1_MASK /* 3206 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMUL_VFPR32_M2 /* 3207 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMUL_VFPR32_M2_MASK /* 3208 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMUL_VFPR32_M4 /* 3209 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMUL_VFPR32_M4_MASK /* 3210 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMUL_VFPR32_MF2 /* 3211 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMUL_VFPR32_MF2_MASK /* 3212 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMUL_VV_M1 /* 3213 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMUL_VV_M1_MASK /* 3214 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMUL_VV_M2 /* 3215 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMUL_VV_M2_MASK /* 3216 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMUL_VV_M4 /* 3217 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMUL_VV_M4_MASK /* 3218 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMUL_VV_MF2 /* 3219 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMUL_VV_MF2_MASK /* 3220 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMUL_VV_MF4 /* 3221 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWMUL_VV_MF4_MASK /* 3222 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWNMACC_VFPR16_M1 /* 3223 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWNMACC_VFPR16_M1_MASK /* 3224 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWNMACC_VFPR16_M2 /* 3225 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWNMACC_VFPR16_M2_MASK /* 3226 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWNMACC_VFPR16_M4 /* 3227 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWNMACC_VFPR16_M4_MASK /* 3228 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWNMACC_VFPR16_MF2 /* 3229 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWNMACC_VFPR16_MF2_MASK /* 3230 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWNMACC_VFPR16_MF4 /* 3231 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWNMACC_VFPR16_MF4_MASK /* 3232 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWNMACC_VFPR32_M1 /* 3233 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWNMACC_VFPR32_M1_MASK /* 3234 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWNMACC_VFPR32_M2 /* 3235 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWNMACC_VFPR32_M2_MASK /* 3236 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWNMACC_VFPR32_M4 /* 3237 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWNMACC_VFPR32_M4_MASK /* 3238 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWNMACC_VFPR32_MF2 /* 3239 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWNMACC_VFPR32_MF2_MASK /* 3240 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWNMACC_VV_M1 /* 3241 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWNMACC_VV_M1_MASK /* 3242 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWNMACC_VV_M2 /* 3243 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWNMACC_VV_M2_MASK /* 3244 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWNMACC_VV_M4 /* 3245 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWNMACC_VV_M4_MASK /* 3246 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWNMACC_VV_MF2 /* 3247 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWNMACC_VV_MF2_MASK /* 3248 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWNMACC_VV_MF4 /* 3249 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWNMACC_VV_MF4_MASK /* 3250 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWNMSAC_VFPR16_M1 /* 3251 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWNMSAC_VFPR16_M1_MASK /* 3252 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWNMSAC_VFPR16_M2 /* 3253 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWNMSAC_VFPR16_M2_MASK /* 3254 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWNMSAC_VFPR16_M4 /* 3255 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWNMSAC_VFPR16_M4_MASK /* 3256 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWNMSAC_VFPR16_MF2 /* 3257 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWNMSAC_VFPR16_MF2_MASK /* 3258 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWNMSAC_VFPR16_MF4 /* 3259 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWNMSAC_VFPR16_MF4_MASK /* 3260 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWNMSAC_VFPR32_M1 /* 3261 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWNMSAC_VFPR32_M1_MASK /* 3262 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWNMSAC_VFPR32_M2 /* 3263 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWNMSAC_VFPR32_M2_MASK /* 3264 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWNMSAC_VFPR32_M4 /* 3265 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWNMSAC_VFPR32_M4_MASK /* 3266 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWNMSAC_VFPR32_MF2 /* 3267 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWNMSAC_VFPR32_MF2_MASK /* 3268 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWNMSAC_VV_M1 /* 3269 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWNMSAC_VV_M1_MASK /* 3270 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWNMSAC_VV_M2 /* 3271 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWNMSAC_VV_M2_MASK /* 3272 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWNMSAC_VV_M4 /* 3273 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWNMSAC_VV_M4_MASK /* 3274 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWNMSAC_VV_MF2 /* 3275 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWNMSAC_VV_MF2_MASK /* 3276 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWNMSAC_VV_MF4 /* 3277 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWNMSAC_VV_MF4_MASK /* 3278 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWREDOSUM_VS_M1_E16 /* 3279 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWREDOSUM_VS_M1_E16_MASK /* 3280 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWREDOSUM_VS_M1_E32 /* 3281 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWREDOSUM_VS_M1_E32_MASK /* 3282 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWREDOSUM_VS_M2_E16 /* 3283 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWREDOSUM_VS_M2_E16_MASK /* 3284 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWREDOSUM_VS_M2_E32 /* 3285 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWREDOSUM_VS_M2_E32_MASK /* 3286 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWREDOSUM_VS_M4_E16 /* 3287 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWREDOSUM_VS_M4_E16_MASK /* 3288 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWREDOSUM_VS_M4_E32 /* 3289 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWREDOSUM_VS_M4_E32_MASK /* 3290 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWREDOSUM_VS_M8_E16 /* 3291 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWREDOSUM_VS_M8_E16_MASK /* 3292 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWREDOSUM_VS_M8_E32 /* 3293 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWREDOSUM_VS_M8_E32_MASK /* 3294 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWREDOSUM_VS_MF2_E16 /* 3295 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWREDOSUM_VS_MF2_E16_MASK /* 3296 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWREDOSUM_VS_MF2_E32 /* 3297 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWREDOSUM_VS_MF2_E32_MASK /* 3298 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWREDOSUM_VS_MF4_E16 /* 3299 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWREDOSUM_VS_MF4_E16_MASK /* 3300 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWREDUSUM_VS_M1_E16 /* 3301 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWREDUSUM_VS_M1_E16_MASK /* 3302 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWREDUSUM_VS_M1_E32 /* 3303 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWREDUSUM_VS_M1_E32_MASK /* 3304 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWREDUSUM_VS_M2_E16 /* 3305 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWREDUSUM_VS_M2_E16_MASK /* 3306 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWREDUSUM_VS_M2_E32 /* 3307 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWREDUSUM_VS_M2_E32_MASK /* 3308 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWREDUSUM_VS_M4_E16 /* 3309 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWREDUSUM_VS_M4_E16_MASK /* 3310 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWREDUSUM_VS_M4_E32 /* 3311 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWREDUSUM_VS_M4_E32_MASK /* 3312 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWREDUSUM_VS_M8_E16 /* 3313 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWREDUSUM_VS_M8_E16_MASK /* 3314 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWREDUSUM_VS_M8_E32 /* 3315 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWREDUSUM_VS_M8_E32_MASK /* 3316 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWREDUSUM_VS_MF2_E16 /* 3317 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWREDUSUM_VS_MF2_E16_MASK /* 3318 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWREDUSUM_VS_MF2_E32 /* 3319 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWREDUSUM_VS_MF2_E32_MASK /* 3320 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWREDUSUM_VS_MF4_E16 /* 3321 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWREDUSUM_VS_MF4_E16_MASK /* 3322 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_VFPR16_M1 /* 3323 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_VFPR16_M1_MASK /* 3324 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_VFPR16_M2 /* 3325 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_VFPR16_M2_MASK /* 3326 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_VFPR16_M4 /* 3327 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_VFPR16_M4_MASK /* 3328 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_VFPR16_MF2 /* 3329 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_VFPR16_MF2_MASK /* 3330 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_VFPR16_MF4 /* 3331 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_VFPR16_MF4_MASK /* 3332 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_VFPR32_M1 /* 3333 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_VFPR32_M1_MASK /* 3334 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_VFPR32_M2 /* 3335 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_VFPR32_M2_MASK /* 3336 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_VFPR32_M4 /* 3337 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_VFPR32_M4_MASK /* 3338 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_VFPR32_MF2 /* 3339 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_VFPR32_MF2_MASK /* 3340 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_VV_M1 /* 3341 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_VV_M1_MASK /* 3342 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_VV_M2 /* 3343 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_VV_M2_MASK /* 3344 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_VV_M4 /* 3345 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_VV_M4_MASK /* 3346 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_VV_MF2 /* 3347 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_VV_MF2_MASK /* 3348 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_VV_MF4 /* 3349 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_VV_MF4_MASK /* 3350 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_WFPR16_M1 /* 3351 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_WFPR16_M1_MASK /* 3352 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_WFPR16_M2 /* 3353 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_WFPR16_M2_MASK /* 3354 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_WFPR16_M4 /* 3355 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_WFPR16_M4_MASK /* 3356 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_WFPR16_MF2 /* 3357 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_WFPR16_MF2_MASK /* 3358 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_WFPR16_MF4 /* 3359 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_WFPR16_MF4_MASK /* 3360 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_WFPR32_M1 /* 3361 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_WFPR32_M1_MASK /* 3362 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_WFPR32_M2 /* 3363 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_WFPR32_M2_MASK /* 3364 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_WFPR32_M4 /* 3365 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_WFPR32_M4_MASK /* 3366 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_WFPR32_MF2 /* 3367 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_WFPR32_MF2_MASK /* 3368 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_WV_M1 /* 3369 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_WV_M1_MASK /* 3370 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_WV_M1_MASK_TIED /* 3371 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_WV_M1_TIED /* 3372 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_WV_M2 /* 3373 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_WV_M2_MASK /* 3374 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_WV_M2_MASK_TIED /* 3375 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_WV_M2_TIED /* 3376 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_WV_M4 /* 3377 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_WV_M4_MASK /* 3378 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_WV_M4_MASK_TIED /* 3379 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_WV_M4_TIED /* 3380 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_WV_MF2 /* 3381 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_WV_MF2_MASK /* 3382 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_WV_MF2_MASK_TIED /* 3383 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_WV_MF2_TIED /* 3384 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_WV_MF4 /* 3385 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_WV_MF4_MASK /* 3386 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_WV_MF4_MASK_TIED /* 3387 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVFWSUB_WV_MF4_TIED /* 3388 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVGHSH_VV_M1 /* 3389 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVGHSH_VV_M2 /* 3390 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVGHSH_VV_M4 /* 3391 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVGHSH_VV_M8 /* 3392 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVGHSH_VV_MF2 /* 3393 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVGMUL_VV_M1 /* 3394 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVGMUL_VV_M2 /* 3395 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVGMUL_VV_M4 /* 3396 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVGMUL_VV_M8 /* 3397 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVGMUL_VV_MF2 /* 3398 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVID_V_M1 /* 3399 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVID_V_M1_MASK /* 3400 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVID_V_M2 /* 3401 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVID_V_M2_MASK /* 3402 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVID_V_M4 /* 3403 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVID_V_M4_MASK /* 3404 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVID_V_M8 /* 3405 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVID_V_M8_MASK /* 3406 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVID_V_MF2 /* 3407 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVID_V_MF2_MASK /* 3408 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVID_V_MF4 /* 3409 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVID_V_MF4_MASK /* 3410 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVID_V_MF8 /* 3411 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVID_V_MF8_MASK /* 3412 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVIOTA_M_M1 /* 3413 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVIOTA_M_M1_MASK /* 3414 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVIOTA_M_M2 /* 3415 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVIOTA_M_M2_MASK /* 3416 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVIOTA_M_M4 /* 3417 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVIOTA_M_M4_MASK /* 3418 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVIOTA_M_M8 /* 3419 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVIOTA_M_M8_MASK /* 3420 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVIOTA_M_MF2 /* 3421 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVIOTA_M_MF2_MASK /* 3422 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVIOTA_M_MF4 /* 3423 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVIOTA_M_MF4_MASK /* 3424 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVIOTA_M_MF8 /* 3425 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVIOTA_M_MF8_MASK /* 3426 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE16FF_V_M1 /* 3427 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE16FF_V_M1_MASK /* 3428 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE16FF_V_M2 /* 3429 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE16FF_V_M2_MASK /* 3430 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE16FF_V_M4 /* 3431 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE16FF_V_M4_MASK /* 3432 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE16FF_V_M8 /* 3433 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE16FF_V_M8_MASK /* 3434 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE16FF_V_MF2 /* 3435 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE16FF_V_MF2_MASK /* 3436 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE16FF_V_MF4 /* 3437 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE16FF_V_MF4_MASK /* 3438 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE16_V_M1 /* 3439 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE16_V_M1_MASK /* 3440 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE16_V_M2 /* 3441 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE16_V_M2_MASK /* 3442 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE16_V_M4 /* 3443 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE16_V_M4_MASK /* 3444 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE16_V_M8 /* 3445 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE16_V_M8_MASK /* 3446 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE16_V_MF2 /* 3447 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE16_V_MF2_MASK /* 3448 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE16_V_MF4 /* 3449 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE16_V_MF4_MASK /* 3450 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE32FF_V_M1 /* 3451 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE32FF_V_M1_MASK /* 3452 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE32FF_V_M2 /* 3453 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE32FF_V_M2_MASK /* 3454 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE32FF_V_M4 /* 3455 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE32FF_V_M4_MASK /* 3456 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE32FF_V_M8 /* 3457 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE32FF_V_M8_MASK /* 3458 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE32FF_V_MF2 /* 3459 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE32FF_V_MF2_MASK /* 3460 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE32_V_M1 /* 3461 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE32_V_M1_MASK /* 3462 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE32_V_M2 /* 3463 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE32_V_M2_MASK /* 3464 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE32_V_M4 /* 3465 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE32_V_M4_MASK /* 3466 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE32_V_M8 /* 3467 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE32_V_M8_MASK /* 3468 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE32_V_MF2 /* 3469 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE32_V_MF2_MASK /* 3470 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE64FF_V_M1 /* 3471 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE64FF_V_M1_MASK /* 3472 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE64FF_V_M2 /* 3473 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE64FF_V_M2_MASK /* 3474 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE64FF_V_M4 /* 3475 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE64FF_V_M4_MASK /* 3476 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE64FF_V_M8 /* 3477 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE64FF_V_M8_MASK /* 3478 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE64_V_M1 /* 3479 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE64_V_M1_MASK /* 3480 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE64_V_M2 /* 3481 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE64_V_M2_MASK /* 3482 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE64_V_M4 /* 3483 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE64_V_M4_MASK /* 3484 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE64_V_M8 /* 3485 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE64_V_M8_MASK /* 3486 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE8FF_V_M1 /* 3487 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE8FF_V_M1_MASK /* 3488 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE8FF_V_M2 /* 3489 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE8FF_V_M2_MASK /* 3490 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE8FF_V_M4 /* 3491 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE8FF_V_M4_MASK /* 3492 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE8FF_V_M8 /* 3493 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE8FF_V_M8_MASK /* 3494 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE8FF_V_MF2 /* 3495 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE8FF_V_MF2_MASK /* 3496 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE8FF_V_MF4 /* 3497 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE8FF_V_MF4_MASK /* 3498 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE8FF_V_MF8 /* 3499 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE8FF_V_MF8_MASK /* 3500 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE8_V_M1 /* 3501 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE8_V_M1_MASK /* 3502 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE8_V_M2 /* 3503 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE8_V_M2_MASK /* 3504 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE8_V_M4 /* 3505 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE8_V_M4_MASK /* 3506 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE8_V_M8 /* 3507 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE8_V_M8_MASK /* 3508 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE8_V_MF2 /* 3509 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE8_V_MF2_MASK /* 3510 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE8_V_MF4 /* 3511 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE8_V_MF4_MASK /* 3512 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE8_V_MF8 /* 3513 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLE8_V_MF8_MASK /* 3514 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLM_V_B1 /* 3515 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLM_V_B16 /* 3516 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLM_V_B2 /* 3517 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLM_V_B32 /* 3518 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLM_V_B4 /* 3519 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLM_V_B64 /* 3520 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLM_V_B8 /* 3521 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI16_V_M1_M1 /* 3522 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI16_V_M1_M1_MASK /* 3523 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI16_V_M1_M2 /* 3524 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI16_V_M1_M2_MASK /* 3525 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI16_V_M1_M4 /* 3526 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI16_V_M1_M4_MASK /* 3527 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI16_V_M1_MF2 /* 3528 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI16_V_M1_MF2_MASK /* 3529 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI16_V_M2_M1 /* 3530 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI16_V_M2_M1_MASK /* 3531 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI16_V_M2_M2 /* 3532 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI16_V_M2_M2_MASK /* 3533 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI16_V_M2_M4 /* 3534 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI16_V_M2_M4_MASK /* 3535 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI16_V_M2_M8 /* 3536 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI16_V_M2_M8_MASK /* 3537 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI16_V_M4_M2 /* 3538 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI16_V_M4_M2_MASK /* 3539 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI16_V_M4_M4 /* 3540 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI16_V_M4_M4_MASK /* 3541 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI16_V_M4_M8 /* 3542 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI16_V_M4_M8_MASK /* 3543 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI16_V_M8_M4 /* 3544 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI16_V_M8_M4_MASK /* 3545 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI16_V_M8_M8 /* 3546 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI16_V_M8_M8_MASK /* 3547 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI16_V_MF2_M1 /* 3548 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI16_V_MF2_M1_MASK /* 3549 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI16_V_MF2_M2 /* 3550 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI16_V_MF2_M2_MASK /* 3551 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI16_V_MF2_MF2 /* 3552 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI16_V_MF2_MF2_MASK /* 3553 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI16_V_MF2_MF4 /* 3554 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI16_V_MF2_MF4_MASK /* 3555 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI16_V_MF4_M1 /* 3556 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI16_V_MF4_M1_MASK /* 3557 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI16_V_MF4_MF2 /* 3558 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI16_V_MF4_MF2_MASK /* 3559 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI16_V_MF4_MF4 /* 3560 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI16_V_MF4_MF4_MASK /* 3561 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI16_V_MF4_MF8 /* 3562 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI16_V_MF4_MF8_MASK /* 3563 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI32_V_M1_M1 /* 3564 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI32_V_M1_M1_MASK /* 3565 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI32_V_M1_M2 /* 3566 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI32_V_M1_M2_MASK /* 3567 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI32_V_M1_MF2 /* 3568 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI32_V_M1_MF2_MASK /* 3569 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI32_V_M1_MF4 /* 3570 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI32_V_M1_MF4_MASK /* 3571 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI32_V_M2_M1 /* 3572 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI32_V_M2_M1_MASK /* 3573 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI32_V_M2_M2 /* 3574 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI32_V_M2_M2_MASK /* 3575 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI32_V_M2_M4 /* 3576 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI32_V_M2_M4_MASK /* 3577 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI32_V_M2_MF2 /* 3578 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI32_V_M2_MF2_MASK /* 3579 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI32_V_M4_M1 /* 3580 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI32_V_M4_M1_MASK /* 3581 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI32_V_M4_M2 /* 3582 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI32_V_M4_M2_MASK /* 3583 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI32_V_M4_M4 /* 3584 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI32_V_M4_M4_MASK /* 3585 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI32_V_M4_M8 /* 3586 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI32_V_M4_M8_MASK /* 3587 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI32_V_M8_M2 /* 3588 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI32_V_M8_M2_MASK /* 3589 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI32_V_M8_M4 /* 3590 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI32_V_M8_M4_MASK /* 3591 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI32_V_M8_M8 /* 3592 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI32_V_M8_M8_MASK /* 3593 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI32_V_MF2_M1 /* 3594 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI32_V_MF2_M1_MASK /* 3595 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI32_V_MF2_MF2 /* 3596 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI32_V_MF2_MF2_MASK /* 3597 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI32_V_MF2_MF4 /* 3598 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI32_V_MF2_MF4_MASK /* 3599 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI32_V_MF2_MF8 /* 3600 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI32_V_MF2_MF8_MASK /* 3601 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI64_V_M1_M1 /* 3602 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI64_V_M1_M1_MASK /* 3603 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI64_V_M1_MF2 /* 3604 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI64_V_M1_MF2_MASK /* 3605 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI64_V_M1_MF4 /* 3606 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI64_V_M1_MF4_MASK /* 3607 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI64_V_M1_MF8 /* 3608 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI64_V_M1_MF8_MASK /* 3609 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI64_V_M2_M1 /* 3610 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI64_V_M2_M1_MASK /* 3611 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI64_V_M2_M2 /* 3612 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI64_V_M2_M2_MASK /* 3613 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI64_V_M2_MF2 /* 3614 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI64_V_M2_MF2_MASK /* 3615 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI64_V_M2_MF4 /* 3616 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI64_V_M2_MF4_MASK /* 3617 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI64_V_M4_M1 /* 3618 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI64_V_M4_M1_MASK /* 3619 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI64_V_M4_M2 /* 3620 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI64_V_M4_M2_MASK /* 3621 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI64_V_M4_M4 /* 3622 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI64_V_M4_M4_MASK /* 3623 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI64_V_M4_MF2 /* 3624 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI64_V_M4_MF2_MASK /* 3625 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI64_V_M8_M1 /* 3626 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI64_V_M8_M1_MASK /* 3627 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI64_V_M8_M2 /* 3628 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI64_V_M8_M2_MASK /* 3629 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI64_V_M8_M4 /* 3630 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI64_V_M8_M4_MASK /* 3631 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI64_V_M8_M8 /* 3632 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI64_V_M8_M8_MASK /* 3633 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI8_V_M1_M1 /* 3634 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI8_V_M1_M1_MASK /* 3635 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI8_V_M1_M2 /* 3636 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI8_V_M1_M2_MASK /* 3637 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI8_V_M1_M4 /* 3638 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI8_V_M1_M4_MASK /* 3639 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI8_V_M1_M8 /* 3640 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI8_V_M1_M8_MASK /* 3641 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI8_V_M2_M2 /* 3642 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI8_V_M2_M2_MASK /* 3643 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI8_V_M2_M4 /* 3644 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI8_V_M2_M4_MASK /* 3645 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI8_V_M2_M8 /* 3646 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI8_V_M2_M8_MASK /* 3647 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI8_V_M4_M4 /* 3648 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI8_V_M4_M4_MASK /* 3649 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI8_V_M4_M8 /* 3650 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI8_V_M4_M8_MASK /* 3651 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI8_V_M8_M8 /* 3652 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI8_V_M8_M8_MASK /* 3653 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI8_V_MF2_M1 /* 3654 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI8_V_MF2_M1_MASK /* 3655 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI8_V_MF2_M2 /* 3656 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI8_V_MF2_M2_MASK /* 3657 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI8_V_MF2_M4 /* 3658 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI8_V_MF2_M4_MASK /* 3659 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI8_V_MF2_MF2 /* 3660 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI8_V_MF2_MF2_MASK /* 3661 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI8_V_MF4_M1 /* 3662 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI8_V_MF4_M1_MASK /* 3663 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI8_V_MF4_M2 /* 3664 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI8_V_MF4_M2_MASK /* 3665 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI8_V_MF4_MF2 /* 3666 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI8_V_MF4_MF2_MASK /* 3667 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI8_V_MF4_MF4 /* 3668 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI8_V_MF4_MF4_MASK /* 3669 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI8_V_MF8_M1 /* 3670 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI8_V_MF8_M1_MASK /* 3671 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI8_V_MF8_MF2 /* 3672 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI8_V_MF8_MF2_MASK /* 3673 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI8_V_MF8_MF4 /* 3674 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI8_V_MF8_MF4_MASK /* 3675 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI8_V_MF8_MF8 /* 3676 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXEI8_V_MF8_MF8_MASK /* 3677 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI16_V_M1_M1 /* 3678 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI16_V_M1_M1_MASK /* 3679 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI16_V_M1_M2 /* 3680 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI16_V_M1_M2_MASK /* 3681 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI16_V_M1_M4 /* 3682 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI16_V_M1_M4_MASK /* 3683 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI16_V_M1_MF2 /* 3684 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI16_V_M1_MF2_MASK /* 3685 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI16_V_M2_M1 /* 3686 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI16_V_M2_M1_MASK /* 3687 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI16_V_M2_M2 /* 3688 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI16_V_M2_M2_MASK /* 3689 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI16_V_M2_M4 /* 3690 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI16_V_M2_M4_MASK /* 3691 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI16_V_M4_M2 /* 3692 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI16_V_M4_M2_MASK /* 3693 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI16_V_M4_M4 /* 3694 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI16_V_M4_M4_MASK /* 3695 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI16_V_M8_M4 /* 3696 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI16_V_M8_M4_MASK /* 3697 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI16_V_MF2_M1 /* 3698 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI16_V_MF2_M1_MASK /* 3699 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI16_V_MF2_M2 /* 3700 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI16_V_MF2_M2_MASK /* 3701 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI16_V_MF2_MF2 /* 3702 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI16_V_MF2_MF2_MASK /* 3703 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI16_V_MF2_MF4 /* 3704 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI16_V_MF2_MF4_MASK /* 3705 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI16_V_MF4_M1 /* 3706 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI16_V_MF4_M1_MASK /* 3707 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI16_V_MF4_MF2 /* 3708 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI16_V_MF4_MF2_MASK /* 3709 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI16_V_MF4_MF4 /* 3710 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI16_V_MF4_MF4_MASK /* 3711 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI16_V_MF4_MF8 /* 3712 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI16_V_MF4_MF8_MASK /* 3713 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI32_V_M1_M1 /* 3714 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI32_V_M1_M1_MASK /* 3715 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI32_V_M1_M2 /* 3716 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI32_V_M1_M2_MASK /* 3717 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI32_V_M1_MF2 /* 3718 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI32_V_M1_MF2_MASK /* 3719 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI32_V_M1_MF4 /* 3720 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI32_V_M1_MF4_MASK /* 3721 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI32_V_M2_M1 /* 3722 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI32_V_M2_M1_MASK /* 3723 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI32_V_M2_M2 /* 3724 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI32_V_M2_M2_MASK /* 3725 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI32_V_M2_M4 /* 3726 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI32_V_M2_M4_MASK /* 3727 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI32_V_M2_MF2 /* 3728 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI32_V_M2_MF2_MASK /* 3729 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI32_V_M4_M1 /* 3730 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI32_V_M4_M1_MASK /* 3731 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI32_V_M4_M2 /* 3732 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI32_V_M4_M2_MASK /* 3733 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI32_V_M4_M4 /* 3734 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI32_V_M4_M4_MASK /* 3735 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI32_V_M8_M2 /* 3736 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI32_V_M8_M2_MASK /* 3737 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI32_V_M8_M4 /* 3738 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI32_V_M8_M4_MASK /* 3739 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI32_V_MF2_M1 /* 3740 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI32_V_MF2_M1_MASK /* 3741 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI32_V_MF2_MF2 /* 3742 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI32_V_MF2_MF2_MASK /* 3743 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI32_V_MF2_MF4 /* 3744 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI32_V_MF2_MF4_MASK /* 3745 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI32_V_MF2_MF8 /* 3746 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI32_V_MF2_MF8_MASK /* 3747 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI64_V_M1_M1 /* 3748 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI64_V_M1_M1_MASK /* 3749 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI64_V_M1_MF2 /* 3750 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI64_V_M1_MF2_MASK /* 3751 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI64_V_M1_MF4 /* 3752 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI64_V_M1_MF4_MASK /* 3753 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI64_V_M1_MF8 /* 3754 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI64_V_M1_MF8_MASK /* 3755 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI64_V_M2_M1 /* 3756 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI64_V_M2_M1_MASK /* 3757 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI64_V_M2_M2 /* 3758 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI64_V_M2_M2_MASK /* 3759 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI64_V_M2_MF2 /* 3760 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI64_V_M2_MF2_MASK /* 3761 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI64_V_M2_MF4 /* 3762 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI64_V_M2_MF4_MASK /* 3763 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI64_V_M4_M1 /* 3764 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI64_V_M4_M1_MASK /* 3765 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI64_V_M4_M2 /* 3766 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI64_V_M4_M2_MASK /* 3767 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI64_V_M4_M4 /* 3768 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI64_V_M4_M4_MASK /* 3769 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI64_V_M4_MF2 /* 3770 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI64_V_M4_MF2_MASK /* 3771 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI64_V_M8_M1 /* 3772 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI64_V_M8_M1_MASK /* 3773 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI64_V_M8_M2 /* 3774 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI64_V_M8_M2_MASK /* 3775 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI64_V_M8_M4 /* 3776 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI64_V_M8_M4_MASK /* 3777 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI8_V_M1_M1 /* 3778 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI8_V_M1_M1_MASK /* 3779 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI8_V_M1_M2 /* 3780 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI8_V_M1_M2_MASK /* 3781 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI8_V_M1_M4 /* 3782 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI8_V_M1_M4_MASK /* 3783 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI8_V_M2_M2 /* 3784 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI8_V_M2_M2_MASK /* 3785 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI8_V_M2_M4 /* 3786 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI8_V_M2_M4_MASK /* 3787 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI8_V_M4_M4 /* 3788 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI8_V_M4_M4_MASK /* 3789 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI8_V_MF2_M1 /* 3790 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI8_V_MF2_M1_MASK /* 3791 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI8_V_MF2_M2 /* 3792 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI8_V_MF2_M2_MASK /* 3793 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI8_V_MF2_M4 /* 3794 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI8_V_MF2_M4_MASK /* 3795 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI8_V_MF2_MF2 /* 3796 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI8_V_MF2_MF2_MASK /* 3797 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI8_V_MF4_M1 /* 3798 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI8_V_MF4_M1_MASK /* 3799 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI8_V_MF4_M2 /* 3800 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI8_V_MF4_M2_MASK /* 3801 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI8_V_MF4_MF2 /* 3802 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI8_V_MF4_MF2_MASK /* 3803 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI8_V_MF4_MF4 /* 3804 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI8_V_MF4_MF4_MASK /* 3805 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI8_V_MF8_M1 /* 3806 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI8_V_MF8_M1_MASK /* 3807 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI8_V_MF8_MF2 /* 3808 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI8_V_MF8_MF2_MASK /* 3809 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI8_V_MF8_MF4 /* 3810 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI8_V_MF8_MF4_MASK /* 3811 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI8_V_MF8_MF8 /* 3812 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG2EI8_V_MF8_MF8_MASK /* 3813 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI16_V_M1_M1 /* 3814 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI16_V_M1_M1_MASK /* 3815 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI16_V_M1_M2 /* 3816 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI16_V_M1_M2_MASK /* 3817 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI16_V_M1_MF2 /* 3818 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI16_V_M1_MF2_MASK /* 3819 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI16_V_M2_M1 /* 3820 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI16_V_M2_M1_MASK /* 3821 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI16_V_M2_M2 /* 3822 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI16_V_M2_M2_MASK /* 3823 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI16_V_M4_M2 /* 3824 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI16_V_M4_M2_MASK /* 3825 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI16_V_MF2_M1 /* 3826 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI16_V_MF2_M1_MASK /* 3827 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI16_V_MF2_M2 /* 3828 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI16_V_MF2_M2_MASK /* 3829 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI16_V_MF2_MF2 /* 3830 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI16_V_MF2_MF2_MASK /* 3831 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI16_V_MF2_MF4 /* 3832 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI16_V_MF2_MF4_MASK /* 3833 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI16_V_MF4_M1 /* 3834 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI16_V_MF4_M1_MASK /* 3835 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI16_V_MF4_MF2 /* 3836 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI16_V_MF4_MF2_MASK /* 3837 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI16_V_MF4_MF4 /* 3838 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI16_V_MF4_MF4_MASK /* 3839 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI16_V_MF4_MF8 /* 3840 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI16_V_MF4_MF8_MASK /* 3841 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI32_V_M1_M1 /* 3842 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI32_V_M1_M1_MASK /* 3843 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI32_V_M1_M2 /* 3844 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI32_V_M1_M2_MASK /* 3845 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI32_V_M1_MF2 /* 3846 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI32_V_M1_MF2_MASK /* 3847 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI32_V_M1_MF4 /* 3848 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI32_V_M1_MF4_MASK /* 3849 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI32_V_M2_M1 /* 3850 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI32_V_M2_M1_MASK /* 3851 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI32_V_M2_M2 /* 3852 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI32_V_M2_M2_MASK /* 3853 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI32_V_M2_MF2 /* 3854 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI32_V_M2_MF2_MASK /* 3855 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI32_V_M4_M1 /* 3856 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI32_V_M4_M1_MASK /* 3857 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI32_V_M4_M2 /* 3858 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI32_V_M4_M2_MASK /* 3859 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI32_V_M8_M2 /* 3860 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI32_V_M8_M2_MASK /* 3861 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI32_V_MF2_M1 /* 3862 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI32_V_MF2_M1_MASK /* 3863 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI32_V_MF2_MF2 /* 3864 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI32_V_MF2_MF2_MASK /* 3865 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI32_V_MF2_MF4 /* 3866 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI32_V_MF2_MF4_MASK /* 3867 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI32_V_MF2_MF8 /* 3868 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI32_V_MF2_MF8_MASK /* 3869 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI64_V_M1_M1 /* 3870 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI64_V_M1_M1_MASK /* 3871 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI64_V_M1_MF2 /* 3872 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI64_V_M1_MF2_MASK /* 3873 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI64_V_M1_MF4 /* 3874 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI64_V_M1_MF4_MASK /* 3875 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI64_V_M1_MF8 /* 3876 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI64_V_M1_MF8_MASK /* 3877 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI64_V_M2_M1 /* 3878 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI64_V_M2_M1_MASK /* 3879 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI64_V_M2_M2 /* 3880 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI64_V_M2_M2_MASK /* 3881 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI64_V_M2_MF2 /* 3882 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI64_V_M2_MF2_MASK /* 3883 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI64_V_M2_MF4 /* 3884 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI64_V_M2_MF4_MASK /* 3885 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI64_V_M4_M1 /* 3886 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI64_V_M4_M1_MASK /* 3887 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI64_V_M4_M2 /* 3888 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI64_V_M4_M2_MASK /* 3889 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI64_V_M4_MF2 /* 3890 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI64_V_M4_MF2_MASK /* 3891 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI64_V_M8_M1 /* 3892 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI64_V_M8_M1_MASK /* 3893 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI64_V_M8_M2 /* 3894 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI64_V_M8_M2_MASK /* 3895 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI8_V_M1_M1 /* 3896 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI8_V_M1_M1_MASK /* 3897 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI8_V_M1_M2 /* 3898 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI8_V_M1_M2_MASK /* 3899 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI8_V_M2_M2 /* 3900 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI8_V_M2_M2_MASK /* 3901 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI8_V_MF2_M1 /* 3902 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI8_V_MF2_M1_MASK /* 3903 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI8_V_MF2_M2 /* 3904 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI8_V_MF2_M2_MASK /* 3905 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI8_V_MF2_MF2 /* 3906 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI8_V_MF2_MF2_MASK /* 3907 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI8_V_MF4_M1 /* 3908 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI8_V_MF4_M1_MASK /* 3909 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI8_V_MF4_M2 /* 3910 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI8_V_MF4_M2_MASK /* 3911 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI8_V_MF4_MF2 /* 3912 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI8_V_MF4_MF2_MASK /* 3913 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI8_V_MF4_MF4 /* 3914 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI8_V_MF4_MF4_MASK /* 3915 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI8_V_MF8_M1 /* 3916 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI8_V_MF8_M1_MASK /* 3917 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI8_V_MF8_MF2 /* 3918 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI8_V_MF8_MF2_MASK /* 3919 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI8_V_MF8_MF4 /* 3920 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI8_V_MF8_MF4_MASK /* 3921 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI8_V_MF8_MF8 /* 3922 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG3EI8_V_MF8_MF8_MASK /* 3923 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI16_V_M1_M1 /* 3924 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI16_V_M1_M1_MASK /* 3925 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI16_V_M1_M2 /* 3926 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI16_V_M1_M2_MASK /* 3927 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI16_V_M1_MF2 /* 3928 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI16_V_M1_MF2_MASK /* 3929 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI16_V_M2_M1 /* 3930 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI16_V_M2_M1_MASK /* 3931 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI16_V_M2_M2 /* 3932 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI16_V_M2_M2_MASK /* 3933 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI16_V_M4_M2 /* 3934 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI16_V_M4_M2_MASK /* 3935 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI16_V_MF2_M1 /* 3936 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI16_V_MF2_M1_MASK /* 3937 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI16_V_MF2_M2 /* 3938 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI16_V_MF2_M2_MASK /* 3939 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI16_V_MF2_MF2 /* 3940 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI16_V_MF2_MF2_MASK /* 3941 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI16_V_MF2_MF4 /* 3942 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI16_V_MF2_MF4_MASK /* 3943 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI16_V_MF4_M1 /* 3944 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI16_V_MF4_M1_MASK /* 3945 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI16_V_MF4_MF2 /* 3946 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI16_V_MF4_MF2_MASK /* 3947 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI16_V_MF4_MF4 /* 3948 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI16_V_MF4_MF4_MASK /* 3949 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI16_V_MF4_MF8 /* 3950 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI16_V_MF4_MF8_MASK /* 3951 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI32_V_M1_M1 /* 3952 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI32_V_M1_M1_MASK /* 3953 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI32_V_M1_M2 /* 3954 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI32_V_M1_M2_MASK /* 3955 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI32_V_M1_MF2 /* 3956 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI32_V_M1_MF2_MASK /* 3957 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI32_V_M1_MF4 /* 3958 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI32_V_M1_MF4_MASK /* 3959 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI32_V_M2_M1 /* 3960 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI32_V_M2_M1_MASK /* 3961 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI32_V_M2_M2 /* 3962 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI32_V_M2_M2_MASK /* 3963 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI32_V_M2_MF2 /* 3964 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI32_V_M2_MF2_MASK /* 3965 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI32_V_M4_M1 /* 3966 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI32_V_M4_M1_MASK /* 3967 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI32_V_M4_M2 /* 3968 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI32_V_M4_M2_MASK /* 3969 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI32_V_M8_M2 /* 3970 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI32_V_M8_M2_MASK /* 3971 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI32_V_MF2_M1 /* 3972 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI32_V_MF2_M1_MASK /* 3973 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI32_V_MF2_MF2 /* 3974 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI32_V_MF2_MF2_MASK /* 3975 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI32_V_MF2_MF4 /* 3976 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI32_V_MF2_MF4_MASK /* 3977 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI32_V_MF2_MF8 /* 3978 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI32_V_MF2_MF8_MASK /* 3979 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI64_V_M1_M1 /* 3980 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI64_V_M1_M1_MASK /* 3981 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI64_V_M1_MF2 /* 3982 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI64_V_M1_MF2_MASK /* 3983 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI64_V_M1_MF4 /* 3984 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI64_V_M1_MF4_MASK /* 3985 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI64_V_M1_MF8 /* 3986 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI64_V_M1_MF8_MASK /* 3987 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI64_V_M2_M1 /* 3988 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI64_V_M2_M1_MASK /* 3989 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI64_V_M2_M2 /* 3990 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI64_V_M2_M2_MASK /* 3991 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI64_V_M2_MF2 /* 3992 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI64_V_M2_MF2_MASK /* 3993 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI64_V_M2_MF4 /* 3994 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI64_V_M2_MF4_MASK /* 3995 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI64_V_M4_M1 /* 3996 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI64_V_M4_M1_MASK /* 3997 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI64_V_M4_M2 /* 3998 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI64_V_M4_M2_MASK /* 3999 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI64_V_M4_MF2 /* 4000 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI64_V_M4_MF2_MASK /* 4001 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI64_V_M8_M1 /* 4002 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI64_V_M8_M1_MASK /* 4003 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI64_V_M8_M2 /* 4004 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI64_V_M8_M2_MASK /* 4005 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI8_V_M1_M1 /* 4006 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI8_V_M1_M1_MASK /* 4007 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI8_V_M1_M2 /* 4008 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI8_V_M1_M2_MASK /* 4009 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI8_V_M2_M2 /* 4010 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI8_V_M2_M2_MASK /* 4011 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI8_V_MF2_M1 /* 4012 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI8_V_MF2_M1_MASK /* 4013 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI8_V_MF2_M2 /* 4014 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI8_V_MF2_M2_MASK /* 4015 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI8_V_MF2_MF2 /* 4016 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI8_V_MF2_MF2_MASK /* 4017 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI8_V_MF4_M1 /* 4018 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI8_V_MF4_M1_MASK /* 4019 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI8_V_MF4_M2 /* 4020 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI8_V_MF4_M2_MASK /* 4021 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI8_V_MF4_MF2 /* 4022 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI8_V_MF4_MF2_MASK /* 4023 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI8_V_MF4_MF4 /* 4024 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI8_V_MF4_MF4_MASK /* 4025 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI8_V_MF8_M1 /* 4026 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI8_V_MF8_M1_MASK /* 4027 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI8_V_MF8_MF2 /* 4028 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI8_V_MF8_MF2_MASK /* 4029 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI8_V_MF8_MF4 /* 4030 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI8_V_MF8_MF4_MASK /* 4031 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI8_V_MF8_MF8 /* 4032 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG4EI8_V_MF8_MF8_MASK /* 4033 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI16_V_M1_M1 /* 4034 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI16_V_M1_M1_MASK /* 4035 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI16_V_M1_MF2 /* 4036 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI16_V_M1_MF2_MASK /* 4037 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI16_V_M2_M1 /* 4038 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI16_V_M2_M1_MASK /* 4039 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI16_V_MF2_M1 /* 4040 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI16_V_MF2_M1_MASK /* 4041 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI16_V_MF2_MF2 /* 4042 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI16_V_MF2_MF2_MASK /* 4043 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI16_V_MF2_MF4 /* 4044 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI16_V_MF2_MF4_MASK /* 4045 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI16_V_MF4_M1 /* 4046 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI16_V_MF4_M1_MASK /* 4047 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI16_V_MF4_MF2 /* 4048 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI16_V_MF4_MF2_MASK /* 4049 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI16_V_MF4_MF4 /* 4050 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI16_V_MF4_MF4_MASK /* 4051 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI16_V_MF4_MF8 /* 4052 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI16_V_MF4_MF8_MASK /* 4053 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI32_V_M1_M1 /* 4054 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI32_V_M1_M1_MASK /* 4055 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI32_V_M1_MF2 /* 4056 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI32_V_M1_MF2_MASK /* 4057 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI32_V_M1_MF4 /* 4058 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI32_V_M1_MF4_MASK /* 4059 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI32_V_M2_M1 /* 4060 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI32_V_M2_M1_MASK /* 4061 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI32_V_M2_MF2 /* 4062 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI32_V_M2_MF2_MASK /* 4063 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI32_V_M4_M1 /* 4064 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI32_V_M4_M1_MASK /* 4065 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI32_V_MF2_M1 /* 4066 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI32_V_MF2_M1_MASK /* 4067 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI32_V_MF2_MF2 /* 4068 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI32_V_MF2_MF2_MASK /* 4069 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI32_V_MF2_MF4 /* 4070 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI32_V_MF2_MF4_MASK /* 4071 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI32_V_MF2_MF8 /* 4072 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI32_V_MF2_MF8_MASK /* 4073 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI64_V_M1_M1 /* 4074 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI64_V_M1_M1_MASK /* 4075 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI64_V_M1_MF2 /* 4076 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI64_V_M1_MF2_MASK /* 4077 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI64_V_M1_MF4 /* 4078 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI64_V_M1_MF4_MASK /* 4079 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI64_V_M1_MF8 /* 4080 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI64_V_M1_MF8_MASK /* 4081 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI64_V_M2_M1 /* 4082 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI64_V_M2_M1_MASK /* 4083 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI64_V_M2_MF2 /* 4084 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI64_V_M2_MF2_MASK /* 4085 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI64_V_M2_MF4 /* 4086 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI64_V_M2_MF4_MASK /* 4087 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI64_V_M4_M1 /* 4088 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI64_V_M4_M1_MASK /* 4089 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI64_V_M4_MF2 /* 4090 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI64_V_M4_MF2_MASK /* 4091 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI64_V_M8_M1 /* 4092 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI64_V_M8_M1_MASK /* 4093 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI8_V_M1_M1 /* 4094 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI8_V_M1_M1_MASK /* 4095 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI8_V_MF2_M1 /* 4096 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI8_V_MF2_M1_MASK /* 4097 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI8_V_MF2_MF2 /* 4098 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI8_V_MF2_MF2_MASK /* 4099 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI8_V_MF4_M1 /* 4100 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI8_V_MF4_M1_MASK /* 4101 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI8_V_MF4_MF2 /* 4102 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI8_V_MF4_MF2_MASK /* 4103 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI8_V_MF4_MF4 /* 4104 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI8_V_MF4_MF4_MASK /* 4105 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI8_V_MF8_M1 /* 4106 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI8_V_MF8_M1_MASK /* 4107 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI8_V_MF8_MF2 /* 4108 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI8_V_MF8_MF2_MASK /* 4109 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI8_V_MF8_MF4 /* 4110 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI8_V_MF8_MF4_MASK /* 4111 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI8_V_MF8_MF8 /* 4112 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG5EI8_V_MF8_MF8_MASK /* 4113 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI16_V_M1_M1 /* 4114 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI16_V_M1_M1_MASK /* 4115 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI16_V_M1_MF2 /* 4116 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI16_V_M1_MF2_MASK /* 4117 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI16_V_M2_M1 /* 4118 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI16_V_M2_M1_MASK /* 4119 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI16_V_MF2_M1 /* 4120 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI16_V_MF2_M1_MASK /* 4121 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI16_V_MF2_MF2 /* 4122 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI16_V_MF2_MF2_MASK /* 4123 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI16_V_MF2_MF4 /* 4124 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI16_V_MF2_MF4_MASK /* 4125 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI16_V_MF4_M1 /* 4126 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI16_V_MF4_M1_MASK /* 4127 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI16_V_MF4_MF2 /* 4128 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI16_V_MF4_MF2_MASK /* 4129 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI16_V_MF4_MF4 /* 4130 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI16_V_MF4_MF4_MASK /* 4131 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI16_V_MF4_MF8 /* 4132 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI16_V_MF4_MF8_MASK /* 4133 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI32_V_M1_M1 /* 4134 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI32_V_M1_M1_MASK /* 4135 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI32_V_M1_MF2 /* 4136 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI32_V_M1_MF2_MASK /* 4137 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI32_V_M1_MF4 /* 4138 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI32_V_M1_MF4_MASK /* 4139 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI32_V_M2_M1 /* 4140 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI32_V_M2_M1_MASK /* 4141 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI32_V_M2_MF2 /* 4142 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI32_V_M2_MF2_MASK /* 4143 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI32_V_M4_M1 /* 4144 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI32_V_M4_M1_MASK /* 4145 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI32_V_MF2_M1 /* 4146 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI32_V_MF2_M1_MASK /* 4147 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI32_V_MF2_MF2 /* 4148 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI32_V_MF2_MF2_MASK /* 4149 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI32_V_MF2_MF4 /* 4150 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI32_V_MF2_MF4_MASK /* 4151 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI32_V_MF2_MF8 /* 4152 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI32_V_MF2_MF8_MASK /* 4153 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI64_V_M1_M1 /* 4154 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI64_V_M1_M1_MASK /* 4155 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI64_V_M1_MF2 /* 4156 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI64_V_M1_MF2_MASK /* 4157 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI64_V_M1_MF4 /* 4158 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI64_V_M1_MF4_MASK /* 4159 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI64_V_M1_MF8 /* 4160 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI64_V_M1_MF8_MASK /* 4161 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI64_V_M2_M1 /* 4162 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI64_V_M2_M1_MASK /* 4163 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI64_V_M2_MF2 /* 4164 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI64_V_M2_MF2_MASK /* 4165 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI64_V_M2_MF4 /* 4166 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI64_V_M2_MF4_MASK /* 4167 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI64_V_M4_M1 /* 4168 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI64_V_M4_M1_MASK /* 4169 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI64_V_M4_MF2 /* 4170 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI64_V_M4_MF2_MASK /* 4171 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI64_V_M8_M1 /* 4172 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI64_V_M8_M1_MASK /* 4173 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI8_V_M1_M1 /* 4174 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI8_V_M1_M1_MASK /* 4175 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI8_V_MF2_M1 /* 4176 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI8_V_MF2_M1_MASK /* 4177 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI8_V_MF2_MF2 /* 4178 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI8_V_MF2_MF2_MASK /* 4179 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI8_V_MF4_M1 /* 4180 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI8_V_MF4_M1_MASK /* 4181 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI8_V_MF4_MF2 /* 4182 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI8_V_MF4_MF2_MASK /* 4183 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI8_V_MF4_MF4 /* 4184 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI8_V_MF4_MF4_MASK /* 4185 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI8_V_MF8_M1 /* 4186 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI8_V_MF8_M1_MASK /* 4187 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI8_V_MF8_MF2 /* 4188 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI8_V_MF8_MF2_MASK /* 4189 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI8_V_MF8_MF4 /* 4190 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI8_V_MF8_MF4_MASK /* 4191 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI8_V_MF8_MF8 /* 4192 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG6EI8_V_MF8_MF8_MASK /* 4193 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI16_V_M1_M1 /* 4194 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI16_V_M1_M1_MASK /* 4195 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI16_V_M1_MF2 /* 4196 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI16_V_M1_MF2_MASK /* 4197 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI16_V_M2_M1 /* 4198 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI16_V_M2_M1_MASK /* 4199 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI16_V_MF2_M1 /* 4200 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI16_V_MF2_M1_MASK /* 4201 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI16_V_MF2_MF2 /* 4202 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI16_V_MF2_MF2_MASK /* 4203 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI16_V_MF2_MF4 /* 4204 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI16_V_MF2_MF4_MASK /* 4205 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI16_V_MF4_M1 /* 4206 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI16_V_MF4_M1_MASK /* 4207 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI16_V_MF4_MF2 /* 4208 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI16_V_MF4_MF2_MASK /* 4209 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI16_V_MF4_MF4 /* 4210 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI16_V_MF4_MF4_MASK /* 4211 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI16_V_MF4_MF8 /* 4212 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI16_V_MF4_MF8_MASK /* 4213 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI32_V_M1_M1 /* 4214 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI32_V_M1_M1_MASK /* 4215 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI32_V_M1_MF2 /* 4216 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI32_V_M1_MF2_MASK /* 4217 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI32_V_M1_MF4 /* 4218 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI32_V_M1_MF4_MASK /* 4219 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI32_V_M2_M1 /* 4220 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI32_V_M2_M1_MASK /* 4221 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI32_V_M2_MF2 /* 4222 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI32_V_M2_MF2_MASK /* 4223 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI32_V_M4_M1 /* 4224 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI32_V_M4_M1_MASK /* 4225 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI32_V_MF2_M1 /* 4226 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI32_V_MF2_M1_MASK /* 4227 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI32_V_MF2_MF2 /* 4228 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI32_V_MF2_MF2_MASK /* 4229 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI32_V_MF2_MF4 /* 4230 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI32_V_MF2_MF4_MASK /* 4231 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI32_V_MF2_MF8 /* 4232 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI32_V_MF2_MF8_MASK /* 4233 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI64_V_M1_M1 /* 4234 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI64_V_M1_M1_MASK /* 4235 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI64_V_M1_MF2 /* 4236 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI64_V_M1_MF2_MASK /* 4237 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI64_V_M1_MF4 /* 4238 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI64_V_M1_MF4_MASK /* 4239 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI64_V_M1_MF8 /* 4240 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI64_V_M1_MF8_MASK /* 4241 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI64_V_M2_M1 /* 4242 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI64_V_M2_M1_MASK /* 4243 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI64_V_M2_MF2 /* 4244 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI64_V_M2_MF2_MASK /* 4245 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI64_V_M2_MF4 /* 4246 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI64_V_M2_MF4_MASK /* 4247 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI64_V_M4_M1 /* 4248 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI64_V_M4_M1_MASK /* 4249 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI64_V_M4_MF2 /* 4250 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI64_V_M4_MF2_MASK /* 4251 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI64_V_M8_M1 /* 4252 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI64_V_M8_M1_MASK /* 4253 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI8_V_M1_M1 /* 4254 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI8_V_M1_M1_MASK /* 4255 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI8_V_MF2_M1 /* 4256 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI8_V_MF2_M1_MASK /* 4257 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI8_V_MF2_MF2 /* 4258 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI8_V_MF2_MF2_MASK /* 4259 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI8_V_MF4_M1 /* 4260 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI8_V_MF4_M1_MASK /* 4261 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI8_V_MF4_MF2 /* 4262 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI8_V_MF4_MF2_MASK /* 4263 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI8_V_MF4_MF4 /* 4264 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI8_V_MF4_MF4_MASK /* 4265 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI8_V_MF8_M1 /* 4266 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI8_V_MF8_M1_MASK /* 4267 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI8_V_MF8_MF2 /* 4268 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI8_V_MF8_MF2_MASK /* 4269 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI8_V_MF8_MF4 /* 4270 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI8_V_MF8_MF4_MASK /* 4271 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI8_V_MF8_MF8 /* 4272 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG7EI8_V_MF8_MF8_MASK /* 4273 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI16_V_M1_M1 /* 4274 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI16_V_M1_M1_MASK /* 4275 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI16_V_M1_MF2 /* 4276 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI16_V_M1_MF2_MASK /* 4277 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI16_V_M2_M1 /* 4278 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI16_V_M2_M1_MASK /* 4279 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI16_V_MF2_M1 /* 4280 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI16_V_MF2_M1_MASK /* 4281 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI16_V_MF2_MF2 /* 4282 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI16_V_MF2_MF2_MASK /* 4283 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI16_V_MF2_MF4 /* 4284 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI16_V_MF2_MF4_MASK /* 4285 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI16_V_MF4_M1 /* 4286 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI16_V_MF4_M1_MASK /* 4287 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI16_V_MF4_MF2 /* 4288 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI16_V_MF4_MF2_MASK /* 4289 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI16_V_MF4_MF4 /* 4290 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI16_V_MF4_MF4_MASK /* 4291 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI16_V_MF4_MF8 /* 4292 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI16_V_MF4_MF8_MASK /* 4293 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI32_V_M1_M1 /* 4294 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI32_V_M1_M1_MASK /* 4295 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI32_V_M1_MF2 /* 4296 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI32_V_M1_MF2_MASK /* 4297 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI32_V_M1_MF4 /* 4298 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI32_V_M1_MF4_MASK /* 4299 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI32_V_M2_M1 /* 4300 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI32_V_M2_M1_MASK /* 4301 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI32_V_M2_MF2 /* 4302 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI32_V_M2_MF2_MASK /* 4303 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI32_V_M4_M1 /* 4304 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI32_V_M4_M1_MASK /* 4305 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI32_V_MF2_M1 /* 4306 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI32_V_MF2_M1_MASK /* 4307 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI32_V_MF2_MF2 /* 4308 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI32_V_MF2_MF2_MASK /* 4309 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI32_V_MF2_MF4 /* 4310 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI32_V_MF2_MF4_MASK /* 4311 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI32_V_MF2_MF8 /* 4312 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI32_V_MF2_MF8_MASK /* 4313 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI64_V_M1_M1 /* 4314 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI64_V_M1_M1_MASK /* 4315 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI64_V_M1_MF2 /* 4316 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI64_V_M1_MF2_MASK /* 4317 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI64_V_M1_MF4 /* 4318 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI64_V_M1_MF4_MASK /* 4319 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI64_V_M1_MF8 /* 4320 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI64_V_M1_MF8_MASK /* 4321 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI64_V_M2_M1 /* 4322 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI64_V_M2_M1_MASK /* 4323 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI64_V_M2_MF2 /* 4324 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI64_V_M2_MF2_MASK /* 4325 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI64_V_M2_MF4 /* 4326 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI64_V_M2_MF4_MASK /* 4327 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI64_V_M4_M1 /* 4328 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI64_V_M4_M1_MASK /* 4329 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI64_V_M4_MF2 /* 4330 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI64_V_M4_MF2_MASK /* 4331 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI64_V_M8_M1 /* 4332 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI64_V_M8_M1_MASK /* 4333 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI8_V_M1_M1 /* 4334 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI8_V_M1_M1_MASK /* 4335 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI8_V_MF2_M1 /* 4336 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI8_V_MF2_M1_MASK /* 4337 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI8_V_MF2_MF2 /* 4338 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI8_V_MF2_MF2_MASK /* 4339 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI8_V_MF4_M1 /* 4340 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI8_V_MF4_M1_MASK /* 4341 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI8_V_MF4_MF2 /* 4342 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI8_V_MF4_MF2_MASK /* 4343 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI8_V_MF4_MF4 /* 4344 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI8_V_MF4_MF4_MASK /* 4345 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI8_V_MF8_M1 /* 4346 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI8_V_MF8_M1_MASK /* 4347 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI8_V_MF8_MF2 /* 4348 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI8_V_MF8_MF2_MASK /* 4349 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI8_V_MF8_MF4 /* 4350 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI8_V_MF8_MF4_MASK /* 4351 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI8_V_MF8_MF8 /* 4352 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLOXSEG8EI8_V_MF8_MF8_MASK /* 4353 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSE16_V_M1 /* 4354 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSE16_V_M1_MASK /* 4355 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSE16_V_M2 /* 4356 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSE16_V_M2_MASK /* 4357 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSE16_V_M4 /* 4358 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSE16_V_M4_MASK /* 4359 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSE16_V_M8 /* 4360 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSE16_V_M8_MASK /* 4361 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSE16_V_MF2 /* 4362 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSE16_V_MF2_MASK /* 4363 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSE16_V_MF4 /* 4364 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSE16_V_MF4_MASK /* 4365 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSE32_V_M1 /* 4366 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSE32_V_M1_MASK /* 4367 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSE32_V_M2 /* 4368 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSE32_V_M2_MASK /* 4369 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSE32_V_M4 /* 4370 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSE32_V_M4_MASK /* 4371 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSE32_V_M8 /* 4372 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSE32_V_M8_MASK /* 4373 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSE32_V_MF2 /* 4374 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSE32_V_MF2_MASK /* 4375 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSE64_V_M1 /* 4376 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSE64_V_M1_MASK /* 4377 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSE64_V_M2 /* 4378 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSE64_V_M2_MASK /* 4379 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSE64_V_M4 /* 4380 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSE64_V_M4_MASK /* 4381 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSE64_V_M8 /* 4382 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSE64_V_M8_MASK /* 4383 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSE8_V_M1 /* 4384 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSE8_V_M1_MASK /* 4385 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSE8_V_M2 /* 4386 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSE8_V_M2_MASK /* 4387 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSE8_V_M4 /* 4388 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSE8_V_M4_MASK /* 4389 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSE8_V_M8 /* 4390 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSE8_V_M8_MASK /* 4391 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSE8_V_MF2 /* 4392 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSE8_V_MF2_MASK /* 4393 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSE8_V_MF4 /* 4394 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSE8_V_MF4_MASK /* 4395 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSE8_V_MF8 /* 4396 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSE8_V_MF8_MASK /* 4397 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E16FF_V_M1 /* 4398 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E16FF_V_M1_MASK /* 4399 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E16FF_V_M2 /* 4400 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E16FF_V_M2_MASK /* 4401 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E16FF_V_M4 /* 4402 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E16FF_V_M4_MASK /* 4403 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E16FF_V_MF2 /* 4404 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E16FF_V_MF2_MASK /* 4405 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E16FF_V_MF4 /* 4406 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E16FF_V_MF4_MASK /* 4407 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E16_V_M1 /* 4408 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E16_V_M1_MASK /* 4409 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E16_V_M2 /* 4410 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E16_V_M2_MASK /* 4411 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E16_V_M4 /* 4412 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E16_V_M4_MASK /* 4413 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E16_V_MF2 /* 4414 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E16_V_MF2_MASK /* 4415 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E16_V_MF4 /* 4416 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E16_V_MF4_MASK /* 4417 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E32FF_V_M1 /* 4418 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E32FF_V_M1_MASK /* 4419 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E32FF_V_M2 /* 4420 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E32FF_V_M2_MASK /* 4421 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E32FF_V_M4 /* 4422 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E32FF_V_M4_MASK /* 4423 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E32FF_V_MF2 /* 4424 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E32FF_V_MF2_MASK /* 4425 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E32_V_M1 /* 4426 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E32_V_M1_MASK /* 4427 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E32_V_M2 /* 4428 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E32_V_M2_MASK /* 4429 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E32_V_M4 /* 4430 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E32_V_M4_MASK /* 4431 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E32_V_MF2 /* 4432 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E32_V_MF2_MASK /* 4433 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E64FF_V_M1 /* 4434 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E64FF_V_M1_MASK /* 4435 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E64FF_V_M2 /* 4436 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E64FF_V_M2_MASK /* 4437 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E64FF_V_M4 /* 4438 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E64FF_V_M4_MASK /* 4439 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E64_V_M1 /* 4440 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E64_V_M1_MASK /* 4441 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E64_V_M2 /* 4442 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E64_V_M2_MASK /* 4443 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E64_V_M4 /* 4444 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E64_V_M4_MASK /* 4445 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E8FF_V_M1 /* 4446 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E8FF_V_M1_MASK /* 4447 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E8FF_V_M2 /* 4448 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E8FF_V_M2_MASK /* 4449 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E8FF_V_M4 /* 4450 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E8FF_V_M4_MASK /* 4451 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E8FF_V_MF2 /* 4452 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E8FF_V_MF2_MASK /* 4453 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E8FF_V_MF4 /* 4454 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E8FF_V_MF4_MASK /* 4455 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E8FF_V_MF8 /* 4456 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E8FF_V_MF8_MASK /* 4457 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E8_V_M1 /* 4458 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E8_V_M1_MASK /* 4459 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E8_V_M2 /* 4460 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E8_V_M2_MASK /* 4461 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E8_V_M4 /* 4462 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E8_V_M4_MASK /* 4463 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E8_V_MF2 /* 4464 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E8_V_MF2_MASK /* 4465 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E8_V_MF4 /* 4466 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E8_V_MF4_MASK /* 4467 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E8_V_MF8 /* 4468 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG2E8_V_MF8_MASK /* 4469 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG3E16FF_V_M1 /* 4470 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG3E16FF_V_M1_MASK /* 4471 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG3E16FF_V_M2 /* 4472 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG3E16FF_V_M2_MASK /* 4473 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG3E16FF_V_MF2 /* 4474 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG3E16FF_V_MF2_MASK /* 4475 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG3E16FF_V_MF4 /* 4476 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG3E16FF_V_MF4_MASK /* 4477 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG3E16_V_M1 /* 4478 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG3E16_V_M1_MASK /* 4479 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG3E16_V_M2 /* 4480 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG3E16_V_M2_MASK /* 4481 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG3E16_V_MF2 /* 4482 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG3E16_V_MF2_MASK /* 4483 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG3E16_V_MF4 /* 4484 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG3E16_V_MF4_MASK /* 4485 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG3E32FF_V_M1 /* 4486 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG3E32FF_V_M1_MASK /* 4487 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG3E32FF_V_M2 /* 4488 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG3E32FF_V_M2_MASK /* 4489 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG3E32FF_V_MF2 /* 4490 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG3E32FF_V_MF2_MASK /* 4491 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG3E32_V_M1 /* 4492 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG3E32_V_M1_MASK /* 4493 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG3E32_V_M2 /* 4494 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG3E32_V_M2_MASK /* 4495 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG3E32_V_MF2 /* 4496 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG3E32_V_MF2_MASK /* 4497 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG3E64FF_V_M1 /* 4498 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG3E64FF_V_M1_MASK /* 4499 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG3E64FF_V_M2 /* 4500 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG3E64FF_V_M2_MASK /* 4501 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG3E64_V_M1 /* 4502 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG3E64_V_M1_MASK /* 4503 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG3E64_V_M2 /* 4504 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG3E64_V_M2_MASK /* 4505 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG3E8FF_V_M1 /* 4506 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG3E8FF_V_M1_MASK /* 4507 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG3E8FF_V_M2 /* 4508 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG3E8FF_V_M2_MASK /* 4509 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG3E8FF_V_MF2 /* 4510 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG3E8FF_V_MF2_MASK /* 4511 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG3E8FF_V_MF4 /* 4512 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG3E8FF_V_MF4_MASK /* 4513 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG3E8FF_V_MF8 /* 4514 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG3E8FF_V_MF8_MASK /* 4515 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG3E8_V_M1 /* 4516 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG3E8_V_M1_MASK /* 4517 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG3E8_V_M2 /* 4518 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG3E8_V_M2_MASK /* 4519 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG3E8_V_MF2 /* 4520 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG3E8_V_MF2_MASK /* 4521 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG3E8_V_MF4 /* 4522 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG3E8_V_MF4_MASK /* 4523 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG3E8_V_MF8 /* 4524 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG3E8_V_MF8_MASK /* 4525 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG4E16FF_V_M1 /* 4526 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG4E16FF_V_M1_MASK /* 4527 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG4E16FF_V_M2 /* 4528 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG4E16FF_V_M2_MASK /* 4529 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG4E16FF_V_MF2 /* 4530 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG4E16FF_V_MF2_MASK /* 4531 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG4E16FF_V_MF4 /* 4532 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG4E16FF_V_MF4_MASK /* 4533 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG4E16_V_M1 /* 4534 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG4E16_V_M1_MASK /* 4535 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG4E16_V_M2 /* 4536 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG4E16_V_M2_MASK /* 4537 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG4E16_V_MF2 /* 4538 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG4E16_V_MF2_MASK /* 4539 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG4E16_V_MF4 /* 4540 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG4E16_V_MF4_MASK /* 4541 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG4E32FF_V_M1 /* 4542 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG4E32FF_V_M1_MASK /* 4543 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG4E32FF_V_M2 /* 4544 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG4E32FF_V_M2_MASK /* 4545 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG4E32FF_V_MF2 /* 4546 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG4E32FF_V_MF2_MASK /* 4547 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG4E32_V_M1 /* 4548 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG4E32_V_M1_MASK /* 4549 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG4E32_V_M2 /* 4550 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG4E32_V_M2_MASK /* 4551 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG4E32_V_MF2 /* 4552 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG4E32_V_MF2_MASK /* 4553 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG4E64FF_V_M1 /* 4554 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG4E64FF_V_M1_MASK /* 4555 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG4E64FF_V_M2 /* 4556 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG4E64FF_V_M2_MASK /* 4557 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG4E64_V_M1 /* 4558 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG4E64_V_M1_MASK /* 4559 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG4E64_V_M2 /* 4560 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG4E64_V_M2_MASK /* 4561 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG4E8FF_V_M1 /* 4562 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG4E8FF_V_M1_MASK /* 4563 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG4E8FF_V_M2 /* 4564 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG4E8FF_V_M2_MASK /* 4565 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG4E8FF_V_MF2 /* 4566 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG4E8FF_V_MF2_MASK /* 4567 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG4E8FF_V_MF4 /* 4568 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG4E8FF_V_MF4_MASK /* 4569 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG4E8FF_V_MF8 /* 4570 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG4E8FF_V_MF8_MASK /* 4571 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG4E8_V_M1 /* 4572 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG4E8_V_M1_MASK /* 4573 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG4E8_V_M2 /* 4574 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG4E8_V_M2_MASK /* 4575 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG4E8_V_MF2 /* 4576 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG4E8_V_MF2_MASK /* 4577 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG4E8_V_MF4 /* 4578 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG4E8_V_MF4_MASK /* 4579 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG4E8_V_MF8 /* 4580 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG4E8_V_MF8_MASK /* 4581 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG5E16FF_V_M1 /* 4582 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG5E16FF_V_M1_MASK /* 4583 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG5E16FF_V_MF2 /* 4584 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG5E16FF_V_MF2_MASK /* 4585 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG5E16FF_V_MF4 /* 4586 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG5E16FF_V_MF4_MASK /* 4587 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG5E16_V_M1 /* 4588 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG5E16_V_M1_MASK /* 4589 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG5E16_V_MF2 /* 4590 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG5E16_V_MF2_MASK /* 4591 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG5E16_V_MF4 /* 4592 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG5E16_V_MF4_MASK /* 4593 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG5E32FF_V_M1 /* 4594 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG5E32FF_V_M1_MASK /* 4595 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG5E32FF_V_MF2 /* 4596 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG5E32FF_V_MF2_MASK /* 4597 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG5E32_V_M1 /* 4598 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG5E32_V_M1_MASK /* 4599 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG5E32_V_MF2 /* 4600 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG5E32_V_MF2_MASK /* 4601 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG5E64FF_V_M1 /* 4602 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG5E64FF_V_M1_MASK /* 4603 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG5E64_V_M1 /* 4604 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG5E64_V_M1_MASK /* 4605 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG5E8FF_V_M1 /* 4606 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG5E8FF_V_M1_MASK /* 4607 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG5E8FF_V_MF2 /* 4608 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG5E8FF_V_MF2_MASK /* 4609 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG5E8FF_V_MF4 /* 4610 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG5E8FF_V_MF4_MASK /* 4611 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG5E8FF_V_MF8 /* 4612 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG5E8FF_V_MF8_MASK /* 4613 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG5E8_V_M1 /* 4614 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG5E8_V_M1_MASK /* 4615 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG5E8_V_MF2 /* 4616 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG5E8_V_MF2_MASK /* 4617 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG5E8_V_MF4 /* 4618 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG5E8_V_MF4_MASK /* 4619 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG5E8_V_MF8 /* 4620 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG5E8_V_MF8_MASK /* 4621 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG6E16FF_V_M1 /* 4622 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG6E16FF_V_M1_MASK /* 4623 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG6E16FF_V_MF2 /* 4624 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG6E16FF_V_MF2_MASK /* 4625 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG6E16FF_V_MF4 /* 4626 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG6E16FF_V_MF4_MASK /* 4627 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG6E16_V_M1 /* 4628 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG6E16_V_M1_MASK /* 4629 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG6E16_V_MF2 /* 4630 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG6E16_V_MF2_MASK /* 4631 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG6E16_V_MF4 /* 4632 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG6E16_V_MF4_MASK /* 4633 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG6E32FF_V_M1 /* 4634 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG6E32FF_V_M1_MASK /* 4635 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG6E32FF_V_MF2 /* 4636 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG6E32FF_V_MF2_MASK /* 4637 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG6E32_V_M1 /* 4638 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG6E32_V_M1_MASK /* 4639 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG6E32_V_MF2 /* 4640 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG6E32_V_MF2_MASK /* 4641 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG6E64FF_V_M1 /* 4642 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG6E64FF_V_M1_MASK /* 4643 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG6E64_V_M1 /* 4644 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG6E64_V_M1_MASK /* 4645 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG6E8FF_V_M1 /* 4646 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG6E8FF_V_M1_MASK /* 4647 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG6E8FF_V_MF2 /* 4648 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG6E8FF_V_MF2_MASK /* 4649 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG6E8FF_V_MF4 /* 4650 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG6E8FF_V_MF4_MASK /* 4651 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG6E8FF_V_MF8 /* 4652 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG6E8FF_V_MF8_MASK /* 4653 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG6E8_V_M1 /* 4654 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG6E8_V_M1_MASK /* 4655 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG6E8_V_MF2 /* 4656 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG6E8_V_MF2_MASK /* 4657 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG6E8_V_MF4 /* 4658 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG6E8_V_MF4_MASK /* 4659 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG6E8_V_MF8 /* 4660 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG6E8_V_MF8_MASK /* 4661 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG7E16FF_V_M1 /* 4662 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG7E16FF_V_M1_MASK /* 4663 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG7E16FF_V_MF2 /* 4664 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG7E16FF_V_MF2_MASK /* 4665 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG7E16FF_V_MF4 /* 4666 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG7E16FF_V_MF4_MASK /* 4667 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG7E16_V_M1 /* 4668 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG7E16_V_M1_MASK /* 4669 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG7E16_V_MF2 /* 4670 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG7E16_V_MF2_MASK /* 4671 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG7E16_V_MF4 /* 4672 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG7E16_V_MF4_MASK /* 4673 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG7E32FF_V_M1 /* 4674 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG7E32FF_V_M1_MASK /* 4675 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG7E32FF_V_MF2 /* 4676 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG7E32FF_V_MF2_MASK /* 4677 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG7E32_V_M1 /* 4678 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG7E32_V_M1_MASK /* 4679 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG7E32_V_MF2 /* 4680 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG7E32_V_MF2_MASK /* 4681 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG7E64FF_V_M1 /* 4682 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG7E64FF_V_M1_MASK /* 4683 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG7E64_V_M1 /* 4684 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG7E64_V_M1_MASK /* 4685 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG7E8FF_V_M1 /* 4686 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG7E8FF_V_M1_MASK /* 4687 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG7E8FF_V_MF2 /* 4688 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG7E8FF_V_MF2_MASK /* 4689 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG7E8FF_V_MF4 /* 4690 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG7E8FF_V_MF4_MASK /* 4691 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG7E8FF_V_MF8 /* 4692 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG7E8FF_V_MF8_MASK /* 4693 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG7E8_V_M1 /* 4694 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG7E8_V_M1_MASK /* 4695 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG7E8_V_MF2 /* 4696 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG7E8_V_MF2_MASK /* 4697 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG7E8_V_MF4 /* 4698 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG7E8_V_MF4_MASK /* 4699 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG7E8_V_MF8 /* 4700 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG7E8_V_MF8_MASK /* 4701 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG8E16FF_V_M1 /* 4702 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG8E16FF_V_M1_MASK /* 4703 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG8E16FF_V_MF2 /* 4704 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG8E16FF_V_MF2_MASK /* 4705 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG8E16FF_V_MF4 /* 4706 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG8E16FF_V_MF4_MASK /* 4707 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG8E16_V_M1 /* 4708 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG8E16_V_M1_MASK /* 4709 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG8E16_V_MF2 /* 4710 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG8E16_V_MF2_MASK /* 4711 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG8E16_V_MF4 /* 4712 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG8E16_V_MF4_MASK /* 4713 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG8E32FF_V_M1 /* 4714 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG8E32FF_V_M1_MASK /* 4715 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG8E32FF_V_MF2 /* 4716 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG8E32FF_V_MF2_MASK /* 4717 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG8E32_V_M1 /* 4718 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG8E32_V_M1_MASK /* 4719 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG8E32_V_MF2 /* 4720 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG8E32_V_MF2_MASK /* 4721 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG8E64FF_V_M1 /* 4722 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG8E64FF_V_M1_MASK /* 4723 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG8E64_V_M1 /* 4724 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG8E64_V_M1_MASK /* 4725 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG8E8FF_V_M1 /* 4726 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG8E8FF_V_M1_MASK /* 4727 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG8E8FF_V_MF2 /* 4728 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG8E8FF_V_MF2_MASK /* 4729 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG8E8FF_V_MF4 /* 4730 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG8E8FF_V_MF4_MASK /* 4731 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG8E8FF_V_MF8 /* 4732 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG8E8FF_V_MF8_MASK /* 4733 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG8E8_V_M1 /* 4734 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG8E8_V_M1_MASK /* 4735 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG8E8_V_MF2 /* 4736 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG8E8_V_MF2_MASK /* 4737 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG8E8_V_MF4 /* 4738 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG8E8_V_MF4_MASK /* 4739 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG8E8_V_MF8 /* 4740 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSEG8E8_V_MF8_MASK /* 4741 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG2E16_V_M1 /* 4742 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG2E16_V_M1_MASK /* 4743 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG2E16_V_M2 /* 4744 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG2E16_V_M2_MASK /* 4745 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG2E16_V_M4 /* 4746 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG2E16_V_M4_MASK /* 4747 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG2E16_V_MF2 /* 4748 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG2E16_V_MF2_MASK /* 4749 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG2E16_V_MF4 /* 4750 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG2E16_V_MF4_MASK /* 4751 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG2E32_V_M1 /* 4752 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG2E32_V_M1_MASK /* 4753 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG2E32_V_M2 /* 4754 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG2E32_V_M2_MASK /* 4755 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG2E32_V_M4 /* 4756 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG2E32_V_M4_MASK /* 4757 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG2E32_V_MF2 /* 4758 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG2E32_V_MF2_MASK /* 4759 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG2E64_V_M1 /* 4760 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG2E64_V_M1_MASK /* 4761 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG2E64_V_M2 /* 4762 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG2E64_V_M2_MASK /* 4763 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG2E64_V_M4 /* 4764 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG2E64_V_M4_MASK /* 4765 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG2E8_V_M1 /* 4766 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG2E8_V_M1_MASK /* 4767 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG2E8_V_M2 /* 4768 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG2E8_V_M2_MASK /* 4769 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG2E8_V_M4 /* 4770 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG2E8_V_M4_MASK /* 4771 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG2E8_V_MF2 /* 4772 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG2E8_V_MF2_MASK /* 4773 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG2E8_V_MF4 /* 4774 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG2E8_V_MF4_MASK /* 4775 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG2E8_V_MF8 /* 4776 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG2E8_V_MF8_MASK /* 4777 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG3E16_V_M1 /* 4778 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG3E16_V_M1_MASK /* 4779 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG3E16_V_M2 /* 4780 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG3E16_V_M2_MASK /* 4781 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG3E16_V_MF2 /* 4782 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG3E16_V_MF2_MASK /* 4783 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG3E16_V_MF4 /* 4784 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG3E16_V_MF4_MASK /* 4785 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG3E32_V_M1 /* 4786 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG3E32_V_M1_MASK /* 4787 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG3E32_V_M2 /* 4788 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG3E32_V_M2_MASK /* 4789 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG3E32_V_MF2 /* 4790 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG3E32_V_MF2_MASK /* 4791 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG3E64_V_M1 /* 4792 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG3E64_V_M1_MASK /* 4793 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG3E64_V_M2 /* 4794 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG3E64_V_M2_MASK /* 4795 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG3E8_V_M1 /* 4796 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG3E8_V_M1_MASK /* 4797 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG3E8_V_M2 /* 4798 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG3E8_V_M2_MASK /* 4799 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG3E8_V_MF2 /* 4800 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG3E8_V_MF2_MASK /* 4801 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG3E8_V_MF4 /* 4802 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG3E8_V_MF4_MASK /* 4803 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG3E8_V_MF8 /* 4804 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG3E8_V_MF8_MASK /* 4805 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG4E16_V_M1 /* 4806 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG4E16_V_M1_MASK /* 4807 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG4E16_V_M2 /* 4808 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG4E16_V_M2_MASK /* 4809 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG4E16_V_MF2 /* 4810 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG4E16_V_MF2_MASK /* 4811 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG4E16_V_MF4 /* 4812 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG4E16_V_MF4_MASK /* 4813 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG4E32_V_M1 /* 4814 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG4E32_V_M1_MASK /* 4815 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG4E32_V_M2 /* 4816 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG4E32_V_M2_MASK /* 4817 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG4E32_V_MF2 /* 4818 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG4E32_V_MF2_MASK /* 4819 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG4E64_V_M1 /* 4820 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG4E64_V_M1_MASK /* 4821 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG4E64_V_M2 /* 4822 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG4E64_V_M2_MASK /* 4823 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG4E8_V_M1 /* 4824 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG4E8_V_M1_MASK /* 4825 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG4E8_V_M2 /* 4826 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG4E8_V_M2_MASK /* 4827 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG4E8_V_MF2 /* 4828 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG4E8_V_MF2_MASK /* 4829 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG4E8_V_MF4 /* 4830 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG4E8_V_MF4_MASK /* 4831 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG4E8_V_MF8 /* 4832 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG4E8_V_MF8_MASK /* 4833 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG5E16_V_M1 /* 4834 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG5E16_V_M1_MASK /* 4835 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG5E16_V_MF2 /* 4836 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG5E16_V_MF2_MASK /* 4837 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG5E16_V_MF4 /* 4838 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG5E16_V_MF4_MASK /* 4839 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG5E32_V_M1 /* 4840 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG5E32_V_M1_MASK /* 4841 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG5E32_V_MF2 /* 4842 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG5E32_V_MF2_MASK /* 4843 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG5E64_V_M1 /* 4844 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG5E64_V_M1_MASK /* 4845 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG5E8_V_M1 /* 4846 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG5E8_V_M1_MASK /* 4847 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG5E8_V_MF2 /* 4848 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG5E8_V_MF2_MASK /* 4849 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG5E8_V_MF4 /* 4850 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG5E8_V_MF4_MASK /* 4851 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG5E8_V_MF8 /* 4852 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG5E8_V_MF8_MASK /* 4853 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG6E16_V_M1 /* 4854 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG6E16_V_M1_MASK /* 4855 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG6E16_V_MF2 /* 4856 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG6E16_V_MF2_MASK /* 4857 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG6E16_V_MF4 /* 4858 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG6E16_V_MF4_MASK /* 4859 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG6E32_V_M1 /* 4860 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG6E32_V_M1_MASK /* 4861 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG6E32_V_MF2 /* 4862 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG6E32_V_MF2_MASK /* 4863 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG6E64_V_M1 /* 4864 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG6E64_V_M1_MASK /* 4865 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG6E8_V_M1 /* 4866 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG6E8_V_M1_MASK /* 4867 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG6E8_V_MF2 /* 4868 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG6E8_V_MF2_MASK /* 4869 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG6E8_V_MF4 /* 4870 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG6E8_V_MF4_MASK /* 4871 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG6E8_V_MF8 /* 4872 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG6E8_V_MF8_MASK /* 4873 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG7E16_V_M1 /* 4874 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG7E16_V_M1_MASK /* 4875 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG7E16_V_MF2 /* 4876 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG7E16_V_MF2_MASK /* 4877 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG7E16_V_MF4 /* 4878 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG7E16_V_MF4_MASK /* 4879 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG7E32_V_M1 /* 4880 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG7E32_V_M1_MASK /* 4881 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG7E32_V_MF2 /* 4882 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG7E32_V_MF2_MASK /* 4883 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG7E64_V_M1 /* 4884 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG7E64_V_M1_MASK /* 4885 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG7E8_V_M1 /* 4886 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG7E8_V_M1_MASK /* 4887 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG7E8_V_MF2 /* 4888 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG7E8_V_MF2_MASK /* 4889 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG7E8_V_MF4 /* 4890 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG7E8_V_MF4_MASK /* 4891 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG7E8_V_MF8 /* 4892 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG7E8_V_MF8_MASK /* 4893 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG8E16_V_M1 /* 4894 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG8E16_V_M1_MASK /* 4895 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG8E16_V_MF2 /* 4896 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG8E16_V_MF2_MASK /* 4897 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG8E16_V_MF4 /* 4898 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG8E16_V_MF4_MASK /* 4899 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG8E32_V_M1 /* 4900 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG8E32_V_M1_MASK /* 4901 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG8E32_V_MF2 /* 4902 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG8E32_V_MF2_MASK /* 4903 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG8E64_V_M1 /* 4904 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG8E64_V_M1_MASK /* 4905 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG8E8_V_M1 /* 4906 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG8E8_V_M1_MASK /* 4907 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG8E8_V_MF2 /* 4908 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG8E8_V_MF2_MASK /* 4909 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG8E8_V_MF4 /* 4910 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG8E8_V_MF4_MASK /* 4911 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG8E8_V_MF8 /* 4912 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLSSEG8E8_V_MF8_MASK /* 4913 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI16_V_M1_M1 /* 4914 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI16_V_M1_M1_MASK /* 4915 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI16_V_M1_M2 /* 4916 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI16_V_M1_M2_MASK /* 4917 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI16_V_M1_M4 /* 4918 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI16_V_M1_M4_MASK /* 4919 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI16_V_M1_MF2 /* 4920 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI16_V_M1_MF2_MASK /* 4921 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI16_V_M2_M1 /* 4922 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI16_V_M2_M1_MASK /* 4923 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI16_V_M2_M2 /* 4924 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI16_V_M2_M2_MASK /* 4925 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI16_V_M2_M4 /* 4926 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI16_V_M2_M4_MASK /* 4927 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI16_V_M2_M8 /* 4928 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI16_V_M2_M8_MASK /* 4929 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI16_V_M4_M2 /* 4930 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI16_V_M4_M2_MASK /* 4931 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI16_V_M4_M4 /* 4932 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI16_V_M4_M4_MASK /* 4933 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI16_V_M4_M8 /* 4934 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI16_V_M4_M8_MASK /* 4935 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI16_V_M8_M4 /* 4936 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI16_V_M8_M4_MASK /* 4937 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI16_V_M8_M8 /* 4938 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI16_V_M8_M8_MASK /* 4939 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI16_V_MF2_M1 /* 4940 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI16_V_MF2_M1_MASK /* 4941 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI16_V_MF2_M2 /* 4942 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI16_V_MF2_M2_MASK /* 4943 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI16_V_MF2_MF2 /* 4944 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI16_V_MF2_MF2_MASK /* 4945 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI16_V_MF2_MF4 /* 4946 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI16_V_MF2_MF4_MASK /* 4947 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI16_V_MF4_M1 /* 4948 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI16_V_MF4_M1_MASK /* 4949 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI16_V_MF4_MF2 /* 4950 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI16_V_MF4_MF2_MASK /* 4951 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI16_V_MF4_MF4 /* 4952 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI16_V_MF4_MF4_MASK /* 4953 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI16_V_MF4_MF8 /* 4954 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI16_V_MF4_MF8_MASK /* 4955 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI32_V_M1_M1 /* 4956 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI32_V_M1_M1_MASK /* 4957 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI32_V_M1_M2 /* 4958 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI32_V_M1_M2_MASK /* 4959 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI32_V_M1_MF2 /* 4960 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI32_V_M1_MF2_MASK /* 4961 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI32_V_M1_MF4 /* 4962 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI32_V_M1_MF4_MASK /* 4963 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI32_V_M2_M1 /* 4964 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI32_V_M2_M1_MASK /* 4965 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI32_V_M2_M2 /* 4966 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI32_V_M2_M2_MASK /* 4967 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI32_V_M2_M4 /* 4968 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI32_V_M2_M4_MASK /* 4969 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI32_V_M2_MF2 /* 4970 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI32_V_M2_MF2_MASK /* 4971 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI32_V_M4_M1 /* 4972 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI32_V_M4_M1_MASK /* 4973 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI32_V_M4_M2 /* 4974 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI32_V_M4_M2_MASK /* 4975 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI32_V_M4_M4 /* 4976 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI32_V_M4_M4_MASK /* 4977 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI32_V_M4_M8 /* 4978 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI32_V_M4_M8_MASK /* 4979 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI32_V_M8_M2 /* 4980 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI32_V_M8_M2_MASK /* 4981 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI32_V_M8_M4 /* 4982 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI32_V_M8_M4_MASK /* 4983 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI32_V_M8_M8 /* 4984 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI32_V_M8_M8_MASK /* 4985 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI32_V_MF2_M1 /* 4986 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI32_V_MF2_M1_MASK /* 4987 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI32_V_MF2_MF2 /* 4988 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI32_V_MF2_MF2_MASK /* 4989 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI32_V_MF2_MF4 /* 4990 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI32_V_MF2_MF4_MASK /* 4991 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI32_V_MF2_MF8 /* 4992 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI32_V_MF2_MF8_MASK /* 4993 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI64_V_M1_M1 /* 4994 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI64_V_M1_M1_MASK /* 4995 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI64_V_M1_MF2 /* 4996 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI64_V_M1_MF2_MASK /* 4997 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI64_V_M1_MF4 /* 4998 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI64_V_M1_MF4_MASK /* 4999 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI64_V_M1_MF8 /* 5000 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI64_V_M1_MF8_MASK /* 5001 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI64_V_M2_M1 /* 5002 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI64_V_M2_M1_MASK /* 5003 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI64_V_M2_M2 /* 5004 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI64_V_M2_M2_MASK /* 5005 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI64_V_M2_MF2 /* 5006 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI64_V_M2_MF2_MASK /* 5007 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI64_V_M2_MF4 /* 5008 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI64_V_M2_MF4_MASK /* 5009 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI64_V_M4_M1 /* 5010 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI64_V_M4_M1_MASK /* 5011 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI64_V_M4_M2 /* 5012 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI64_V_M4_M2_MASK /* 5013 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI64_V_M4_M4 /* 5014 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI64_V_M4_M4_MASK /* 5015 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI64_V_M4_MF2 /* 5016 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI64_V_M4_MF2_MASK /* 5017 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI64_V_M8_M1 /* 5018 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI64_V_M8_M1_MASK /* 5019 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI64_V_M8_M2 /* 5020 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI64_V_M8_M2_MASK /* 5021 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI64_V_M8_M4 /* 5022 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI64_V_M8_M4_MASK /* 5023 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI64_V_M8_M8 /* 5024 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI64_V_M8_M8_MASK /* 5025 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI8_V_M1_M1 /* 5026 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI8_V_M1_M1_MASK /* 5027 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI8_V_M1_M2 /* 5028 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI8_V_M1_M2_MASK /* 5029 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI8_V_M1_M4 /* 5030 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI8_V_M1_M4_MASK /* 5031 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI8_V_M1_M8 /* 5032 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI8_V_M1_M8_MASK /* 5033 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI8_V_M2_M2 /* 5034 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI8_V_M2_M2_MASK /* 5035 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI8_V_M2_M4 /* 5036 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI8_V_M2_M4_MASK /* 5037 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI8_V_M2_M8 /* 5038 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI8_V_M2_M8_MASK /* 5039 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI8_V_M4_M4 /* 5040 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI8_V_M4_M4_MASK /* 5041 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI8_V_M4_M8 /* 5042 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI8_V_M4_M8_MASK /* 5043 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI8_V_M8_M8 /* 5044 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI8_V_M8_M8_MASK /* 5045 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI8_V_MF2_M1 /* 5046 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI8_V_MF2_M1_MASK /* 5047 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI8_V_MF2_M2 /* 5048 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI8_V_MF2_M2_MASK /* 5049 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI8_V_MF2_M4 /* 5050 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI8_V_MF2_M4_MASK /* 5051 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI8_V_MF2_MF2 /* 5052 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI8_V_MF2_MF2_MASK /* 5053 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI8_V_MF4_M1 /* 5054 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI8_V_MF4_M1_MASK /* 5055 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI8_V_MF4_M2 /* 5056 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI8_V_MF4_M2_MASK /* 5057 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI8_V_MF4_MF2 /* 5058 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI8_V_MF4_MF2_MASK /* 5059 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI8_V_MF4_MF4 /* 5060 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI8_V_MF4_MF4_MASK /* 5061 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI8_V_MF8_M1 /* 5062 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI8_V_MF8_M1_MASK /* 5063 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI8_V_MF8_MF2 /* 5064 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI8_V_MF8_MF2_MASK /* 5065 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI8_V_MF8_MF4 /* 5066 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI8_V_MF8_MF4_MASK /* 5067 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI8_V_MF8_MF8 /* 5068 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXEI8_V_MF8_MF8_MASK /* 5069 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI16_V_M1_M1 /* 5070 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI16_V_M1_M1_MASK /* 5071 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI16_V_M1_M2 /* 5072 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI16_V_M1_M2_MASK /* 5073 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI16_V_M1_M4 /* 5074 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI16_V_M1_M4_MASK /* 5075 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI16_V_M1_MF2 /* 5076 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI16_V_M1_MF2_MASK /* 5077 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI16_V_M2_M1 /* 5078 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI16_V_M2_M1_MASK /* 5079 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI16_V_M2_M2 /* 5080 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI16_V_M2_M2_MASK /* 5081 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI16_V_M2_M4 /* 5082 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI16_V_M2_M4_MASK /* 5083 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI16_V_M4_M2 /* 5084 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI16_V_M4_M2_MASK /* 5085 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI16_V_M4_M4 /* 5086 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI16_V_M4_M4_MASK /* 5087 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI16_V_M8_M4 /* 5088 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI16_V_M8_M4_MASK /* 5089 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI16_V_MF2_M1 /* 5090 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI16_V_MF2_M1_MASK /* 5091 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI16_V_MF2_M2 /* 5092 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI16_V_MF2_M2_MASK /* 5093 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI16_V_MF2_MF2 /* 5094 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI16_V_MF2_MF2_MASK /* 5095 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI16_V_MF2_MF4 /* 5096 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI16_V_MF2_MF4_MASK /* 5097 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI16_V_MF4_M1 /* 5098 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI16_V_MF4_M1_MASK /* 5099 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI16_V_MF4_MF2 /* 5100 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI16_V_MF4_MF2_MASK /* 5101 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI16_V_MF4_MF4 /* 5102 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI16_V_MF4_MF4_MASK /* 5103 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI16_V_MF4_MF8 /* 5104 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI16_V_MF4_MF8_MASK /* 5105 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI32_V_M1_M1 /* 5106 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI32_V_M1_M1_MASK /* 5107 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI32_V_M1_M2 /* 5108 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI32_V_M1_M2_MASK /* 5109 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI32_V_M1_MF2 /* 5110 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI32_V_M1_MF2_MASK /* 5111 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI32_V_M1_MF4 /* 5112 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI32_V_M1_MF4_MASK /* 5113 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI32_V_M2_M1 /* 5114 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI32_V_M2_M1_MASK /* 5115 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI32_V_M2_M2 /* 5116 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI32_V_M2_M2_MASK /* 5117 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI32_V_M2_M4 /* 5118 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI32_V_M2_M4_MASK /* 5119 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI32_V_M2_MF2 /* 5120 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI32_V_M2_MF2_MASK /* 5121 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI32_V_M4_M1 /* 5122 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI32_V_M4_M1_MASK /* 5123 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI32_V_M4_M2 /* 5124 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI32_V_M4_M2_MASK /* 5125 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI32_V_M4_M4 /* 5126 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI32_V_M4_M4_MASK /* 5127 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI32_V_M8_M2 /* 5128 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI32_V_M8_M2_MASK /* 5129 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI32_V_M8_M4 /* 5130 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI32_V_M8_M4_MASK /* 5131 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI32_V_MF2_M1 /* 5132 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI32_V_MF2_M1_MASK /* 5133 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI32_V_MF2_MF2 /* 5134 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI32_V_MF2_MF2_MASK /* 5135 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI32_V_MF2_MF4 /* 5136 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI32_V_MF2_MF4_MASK /* 5137 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI32_V_MF2_MF8 /* 5138 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI32_V_MF2_MF8_MASK /* 5139 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI64_V_M1_M1 /* 5140 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI64_V_M1_M1_MASK /* 5141 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI64_V_M1_MF2 /* 5142 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI64_V_M1_MF2_MASK /* 5143 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI64_V_M1_MF4 /* 5144 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI64_V_M1_MF4_MASK /* 5145 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI64_V_M1_MF8 /* 5146 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI64_V_M1_MF8_MASK /* 5147 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI64_V_M2_M1 /* 5148 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI64_V_M2_M1_MASK /* 5149 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI64_V_M2_M2 /* 5150 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI64_V_M2_M2_MASK /* 5151 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI64_V_M2_MF2 /* 5152 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI64_V_M2_MF2_MASK /* 5153 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI64_V_M2_MF4 /* 5154 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI64_V_M2_MF4_MASK /* 5155 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI64_V_M4_M1 /* 5156 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI64_V_M4_M1_MASK /* 5157 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI64_V_M4_M2 /* 5158 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI64_V_M4_M2_MASK /* 5159 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI64_V_M4_M4 /* 5160 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI64_V_M4_M4_MASK /* 5161 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI64_V_M4_MF2 /* 5162 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI64_V_M4_MF2_MASK /* 5163 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI64_V_M8_M1 /* 5164 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI64_V_M8_M1_MASK /* 5165 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI64_V_M8_M2 /* 5166 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI64_V_M8_M2_MASK /* 5167 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI64_V_M8_M4 /* 5168 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI64_V_M8_M4_MASK /* 5169 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI8_V_M1_M1 /* 5170 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI8_V_M1_M1_MASK /* 5171 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI8_V_M1_M2 /* 5172 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI8_V_M1_M2_MASK /* 5173 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI8_V_M1_M4 /* 5174 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI8_V_M1_M4_MASK /* 5175 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI8_V_M2_M2 /* 5176 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI8_V_M2_M2_MASK /* 5177 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI8_V_M2_M4 /* 5178 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI8_V_M2_M4_MASK /* 5179 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI8_V_M4_M4 /* 5180 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI8_V_M4_M4_MASK /* 5181 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI8_V_MF2_M1 /* 5182 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI8_V_MF2_M1_MASK /* 5183 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI8_V_MF2_M2 /* 5184 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI8_V_MF2_M2_MASK /* 5185 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI8_V_MF2_M4 /* 5186 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI8_V_MF2_M4_MASK /* 5187 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI8_V_MF2_MF2 /* 5188 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI8_V_MF2_MF2_MASK /* 5189 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI8_V_MF4_M1 /* 5190 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI8_V_MF4_M1_MASK /* 5191 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI8_V_MF4_M2 /* 5192 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI8_V_MF4_M2_MASK /* 5193 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI8_V_MF4_MF2 /* 5194 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI8_V_MF4_MF2_MASK /* 5195 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI8_V_MF4_MF4 /* 5196 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI8_V_MF4_MF4_MASK /* 5197 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI8_V_MF8_M1 /* 5198 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI8_V_MF8_M1_MASK /* 5199 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI8_V_MF8_MF2 /* 5200 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI8_V_MF8_MF2_MASK /* 5201 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI8_V_MF8_MF4 /* 5202 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI8_V_MF8_MF4_MASK /* 5203 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI8_V_MF8_MF8 /* 5204 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG2EI8_V_MF8_MF8_MASK /* 5205 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI16_V_M1_M1 /* 5206 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI16_V_M1_M1_MASK /* 5207 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI16_V_M1_M2 /* 5208 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI16_V_M1_M2_MASK /* 5209 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI16_V_M1_MF2 /* 5210 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI16_V_M1_MF2_MASK /* 5211 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI16_V_M2_M1 /* 5212 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI16_V_M2_M1_MASK /* 5213 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI16_V_M2_M2 /* 5214 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI16_V_M2_M2_MASK /* 5215 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI16_V_M4_M2 /* 5216 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI16_V_M4_M2_MASK /* 5217 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI16_V_MF2_M1 /* 5218 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI16_V_MF2_M1_MASK /* 5219 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI16_V_MF2_M2 /* 5220 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI16_V_MF2_M2_MASK /* 5221 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI16_V_MF2_MF2 /* 5222 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI16_V_MF2_MF2_MASK /* 5223 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI16_V_MF2_MF4 /* 5224 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI16_V_MF2_MF4_MASK /* 5225 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI16_V_MF4_M1 /* 5226 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI16_V_MF4_M1_MASK /* 5227 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI16_V_MF4_MF2 /* 5228 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI16_V_MF4_MF2_MASK /* 5229 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI16_V_MF4_MF4 /* 5230 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI16_V_MF4_MF4_MASK /* 5231 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI16_V_MF4_MF8 /* 5232 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI16_V_MF4_MF8_MASK /* 5233 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI32_V_M1_M1 /* 5234 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI32_V_M1_M1_MASK /* 5235 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI32_V_M1_M2 /* 5236 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI32_V_M1_M2_MASK /* 5237 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI32_V_M1_MF2 /* 5238 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI32_V_M1_MF2_MASK /* 5239 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI32_V_M1_MF4 /* 5240 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI32_V_M1_MF4_MASK /* 5241 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI32_V_M2_M1 /* 5242 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI32_V_M2_M1_MASK /* 5243 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI32_V_M2_M2 /* 5244 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI32_V_M2_M2_MASK /* 5245 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI32_V_M2_MF2 /* 5246 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI32_V_M2_MF2_MASK /* 5247 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI32_V_M4_M1 /* 5248 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI32_V_M4_M1_MASK /* 5249 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI32_V_M4_M2 /* 5250 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI32_V_M4_M2_MASK /* 5251 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI32_V_M8_M2 /* 5252 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI32_V_M8_M2_MASK /* 5253 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI32_V_MF2_M1 /* 5254 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI32_V_MF2_M1_MASK /* 5255 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI32_V_MF2_MF2 /* 5256 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI32_V_MF2_MF2_MASK /* 5257 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI32_V_MF2_MF4 /* 5258 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI32_V_MF2_MF4_MASK /* 5259 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI32_V_MF2_MF8 /* 5260 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI32_V_MF2_MF8_MASK /* 5261 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI64_V_M1_M1 /* 5262 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI64_V_M1_M1_MASK /* 5263 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI64_V_M1_MF2 /* 5264 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI64_V_M1_MF2_MASK /* 5265 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI64_V_M1_MF4 /* 5266 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI64_V_M1_MF4_MASK /* 5267 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI64_V_M1_MF8 /* 5268 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI64_V_M1_MF8_MASK /* 5269 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI64_V_M2_M1 /* 5270 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI64_V_M2_M1_MASK /* 5271 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI64_V_M2_M2 /* 5272 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI64_V_M2_M2_MASK /* 5273 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI64_V_M2_MF2 /* 5274 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI64_V_M2_MF2_MASK /* 5275 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI64_V_M2_MF4 /* 5276 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI64_V_M2_MF4_MASK /* 5277 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI64_V_M4_M1 /* 5278 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI64_V_M4_M1_MASK /* 5279 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI64_V_M4_M2 /* 5280 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI64_V_M4_M2_MASK /* 5281 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI64_V_M4_MF2 /* 5282 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI64_V_M4_MF2_MASK /* 5283 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI64_V_M8_M1 /* 5284 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI64_V_M8_M1_MASK /* 5285 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI64_V_M8_M2 /* 5286 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI64_V_M8_M2_MASK /* 5287 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI8_V_M1_M1 /* 5288 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI8_V_M1_M1_MASK /* 5289 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI8_V_M1_M2 /* 5290 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI8_V_M1_M2_MASK /* 5291 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI8_V_M2_M2 /* 5292 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI8_V_M2_M2_MASK /* 5293 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI8_V_MF2_M1 /* 5294 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI8_V_MF2_M1_MASK /* 5295 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI8_V_MF2_M2 /* 5296 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI8_V_MF2_M2_MASK /* 5297 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI8_V_MF2_MF2 /* 5298 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI8_V_MF2_MF2_MASK /* 5299 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI8_V_MF4_M1 /* 5300 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI8_V_MF4_M1_MASK /* 5301 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI8_V_MF4_M2 /* 5302 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI8_V_MF4_M2_MASK /* 5303 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI8_V_MF4_MF2 /* 5304 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI8_V_MF4_MF2_MASK /* 5305 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI8_V_MF4_MF4 /* 5306 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI8_V_MF4_MF4_MASK /* 5307 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI8_V_MF8_M1 /* 5308 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI8_V_MF8_M1_MASK /* 5309 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI8_V_MF8_MF2 /* 5310 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI8_V_MF8_MF2_MASK /* 5311 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI8_V_MF8_MF4 /* 5312 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI8_V_MF8_MF4_MASK /* 5313 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI8_V_MF8_MF8 /* 5314 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG3EI8_V_MF8_MF8_MASK /* 5315 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI16_V_M1_M1 /* 5316 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI16_V_M1_M1_MASK /* 5317 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI16_V_M1_M2 /* 5318 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI16_V_M1_M2_MASK /* 5319 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI16_V_M1_MF2 /* 5320 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI16_V_M1_MF2_MASK /* 5321 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI16_V_M2_M1 /* 5322 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI16_V_M2_M1_MASK /* 5323 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI16_V_M2_M2 /* 5324 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI16_V_M2_M2_MASK /* 5325 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI16_V_M4_M2 /* 5326 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI16_V_M4_M2_MASK /* 5327 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI16_V_MF2_M1 /* 5328 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI16_V_MF2_M1_MASK /* 5329 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI16_V_MF2_M2 /* 5330 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI16_V_MF2_M2_MASK /* 5331 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI16_V_MF2_MF2 /* 5332 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI16_V_MF2_MF2_MASK /* 5333 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI16_V_MF2_MF4 /* 5334 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI16_V_MF2_MF4_MASK /* 5335 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI16_V_MF4_M1 /* 5336 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI16_V_MF4_M1_MASK /* 5337 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI16_V_MF4_MF2 /* 5338 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI16_V_MF4_MF2_MASK /* 5339 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI16_V_MF4_MF4 /* 5340 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI16_V_MF4_MF4_MASK /* 5341 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI16_V_MF4_MF8 /* 5342 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI16_V_MF4_MF8_MASK /* 5343 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI32_V_M1_M1 /* 5344 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI32_V_M1_M1_MASK /* 5345 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI32_V_M1_M2 /* 5346 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI32_V_M1_M2_MASK /* 5347 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI32_V_M1_MF2 /* 5348 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI32_V_M1_MF2_MASK /* 5349 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI32_V_M1_MF4 /* 5350 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI32_V_M1_MF4_MASK /* 5351 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI32_V_M2_M1 /* 5352 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI32_V_M2_M1_MASK /* 5353 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI32_V_M2_M2 /* 5354 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI32_V_M2_M2_MASK /* 5355 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI32_V_M2_MF2 /* 5356 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI32_V_M2_MF2_MASK /* 5357 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI32_V_M4_M1 /* 5358 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI32_V_M4_M1_MASK /* 5359 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI32_V_M4_M2 /* 5360 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI32_V_M4_M2_MASK /* 5361 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI32_V_M8_M2 /* 5362 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI32_V_M8_M2_MASK /* 5363 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI32_V_MF2_M1 /* 5364 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI32_V_MF2_M1_MASK /* 5365 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI32_V_MF2_MF2 /* 5366 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI32_V_MF2_MF2_MASK /* 5367 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI32_V_MF2_MF4 /* 5368 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI32_V_MF2_MF4_MASK /* 5369 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI32_V_MF2_MF8 /* 5370 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI32_V_MF2_MF8_MASK /* 5371 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI64_V_M1_M1 /* 5372 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI64_V_M1_M1_MASK /* 5373 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI64_V_M1_MF2 /* 5374 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI64_V_M1_MF2_MASK /* 5375 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI64_V_M1_MF4 /* 5376 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI64_V_M1_MF4_MASK /* 5377 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI64_V_M1_MF8 /* 5378 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI64_V_M1_MF8_MASK /* 5379 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI64_V_M2_M1 /* 5380 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI64_V_M2_M1_MASK /* 5381 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI64_V_M2_M2 /* 5382 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI64_V_M2_M2_MASK /* 5383 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI64_V_M2_MF2 /* 5384 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI64_V_M2_MF2_MASK /* 5385 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI64_V_M2_MF4 /* 5386 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI64_V_M2_MF4_MASK /* 5387 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI64_V_M4_M1 /* 5388 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI64_V_M4_M1_MASK /* 5389 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI64_V_M4_M2 /* 5390 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI64_V_M4_M2_MASK /* 5391 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI64_V_M4_MF2 /* 5392 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI64_V_M4_MF2_MASK /* 5393 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI64_V_M8_M1 /* 5394 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI64_V_M8_M1_MASK /* 5395 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI64_V_M8_M2 /* 5396 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI64_V_M8_M2_MASK /* 5397 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI8_V_M1_M1 /* 5398 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI8_V_M1_M1_MASK /* 5399 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI8_V_M1_M2 /* 5400 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI8_V_M1_M2_MASK /* 5401 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI8_V_M2_M2 /* 5402 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI8_V_M2_M2_MASK /* 5403 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI8_V_MF2_M1 /* 5404 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI8_V_MF2_M1_MASK /* 5405 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI8_V_MF2_M2 /* 5406 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI8_V_MF2_M2_MASK /* 5407 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI8_V_MF2_MF2 /* 5408 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI8_V_MF2_MF2_MASK /* 5409 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI8_V_MF4_M1 /* 5410 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI8_V_MF4_M1_MASK /* 5411 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI8_V_MF4_M2 /* 5412 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI8_V_MF4_M2_MASK /* 5413 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI8_V_MF4_MF2 /* 5414 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI8_V_MF4_MF2_MASK /* 5415 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI8_V_MF4_MF4 /* 5416 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI8_V_MF4_MF4_MASK /* 5417 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI8_V_MF8_M1 /* 5418 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI8_V_MF8_M1_MASK /* 5419 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI8_V_MF8_MF2 /* 5420 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI8_V_MF8_MF2_MASK /* 5421 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI8_V_MF8_MF4 /* 5422 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI8_V_MF8_MF4_MASK /* 5423 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI8_V_MF8_MF8 /* 5424 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG4EI8_V_MF8_MF8_MASK /* 5425 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI16_V_M1_M1 /* 5426 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI16_V_M1_M1_MASK /* 5427 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI16_V_M1_MF2 /* 5428 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI16_V_M1_MF2_MASK /* 5429 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI16_V_M2_M1 /* 5430 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI16_V_M2_M1_MASK /* 5431 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI16_V_MF2_M1 /* 5432 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI16_V_MF2_M1_MASK /* 5433 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI16_V_MF2_MF2 /* 5434 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI16_V_MF2_MF2_MASK /* 5435 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI16_V_MF2_MF4 /* 5436 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI16_V_MF2_MF4_MASK /* 5437 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI16_V_MF4_M1 /* 5438 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI16_V_MF4_M1_MASK /* 5439 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI16_V_MF4_MF2 /* 5440 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI16_V_MF4_MF2_MASK /* 5441 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI16_V_MF4_MF4 /* 5442 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI16_V_MF4_MF4_MASK /* 5443 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI16_V_MF4_MF8 /* 5444 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI16_V_MF4_MF8_MASK /* 5445 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI32_V_M1_M1 /* 5446 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI32_V_M1_M1_MASK /* 5447 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI32_V_M1_MF2 /* 5448 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI32_V_M1_MF2_MASK /* 5449 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI32_V_M1_MF4 /* 5450 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI32_V_M1_MF4_MASK /* 5451 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI32_V_M2_M1 /* 5452 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI32_V_M2_M1_MASK /* 5453 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI32_V_M2_MF2 /* 5454 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI32_V_M2_MF2_MASK /* 5455 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI32_V_M4_M1 /* 5456 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI32_V_M4_M1_MASK /* 5457 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI32_V_MF2_M1 /* 5458 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI32_V_MF2_M1_MASK /* 5459 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI32_V_MF2_MF2 /* 5460 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI32_V_MF2_MF2_MASK /* 5461 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI32_V_MF2_MF4 /* 5462 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI32_V_MF2_MF4_MASK /* 5463 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI32_V_MF2_MF8 /* 5464 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI32_V_MF2_MF8_MASK /* 5465 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI64_V_M1_M1 /* 5466 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI64_V_M1_M1_MASK /* 5467 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI64_V_M1_MF2 /* 5468 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI64_V_M1_MF2_MASK /* 5469 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI64_V_M1_MF4 /* 5470 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI64_V_M1_MF4_MASK /* 5471 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI64_V_M1_MF8 /* 5472 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI64_V_M1_MF8_MASK /* 5473 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI64_V_M2_M1 /* 5474 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI64_V_M2_M1_MASK /* 5475 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI64_V_M2_MF2 /* 5476 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI64_V_M2_MF2_MASK /* 5477 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI64_V_M2_MF4 /* 5478 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI64_V_M2_MF4_MASK /* 5479 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI64_V_M4_M1 /* 5480 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI64_V_M4_M1_MASK /* 5481 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI64_V_M4_MF2 /* 5482 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI64_V_M4_MF2_MASK /* 5483 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI64_V_M8_M1 /* 5484 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI64_V_M8_M1_MASK /* 5485 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI8_V_M1_M1 /* 5486 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI8_V_M1_M1_MASK /* 5487 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI8_V_MF2_M1 /* 5488 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI8_V_MF2_M1_MASK /* 5489 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI8_V_MF2_MF2 /* 5490 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI8_V_MF2_MF2_MASK /* 5491 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI8_V_MF4_M1 /* 5492 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI8_V_MF4_M1_MASK /* 5493 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI8_V_MF4_MF2 /* 5494 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI8_V_MF4_MF2_MASK /* 5495 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI8_V_MF4_MF4 /* 5496 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI8_V_MF4_MF4_MASK /* 5497 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI8_V_MF8_M1 /* 5498 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI8_V_MF8_M1_MASK /* 5499 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI8_V_MF8_MF2 /* 5500 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI8_V_MF8_MF2_MASK /* 5501 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI8_V_MF8_MF4 /* 5502 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI8_V_MF8_MF4_MASK /* 5503 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI8_V_MF8_MF8 /* 5504 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG5EI8_V_MF8_MF8_MASK /* 5505 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI16_V_M1_M1 /* 5506 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI16_V_M1_M1_MASK /* 5507 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI16_V_M1_MF2 /* 5508 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI16_V_M1_MF2_MASK /* 5509 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI16_V_M2_M1 /* 5510 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI16_V_M2_M1_MASK /* 5511 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI16_V_MF2_M1 /* 5512 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI16_V_MF2_M1_MASK /* 5513 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI16_V_MF2_MF2 /* 5514 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI16_V_MF2_MF2_MASK /* 5515 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI16_V_MF2_MF4 /* 5516 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI16_V_MF2_MF4_MASK /* 5517 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI16_V_MF4_M1 /* 5518 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI16_V_MF4_M1_MASK /* 5519 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI16_V_MF4_MF2 /* 5520 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI16_V_MF4_MF2_MASK /* 5521 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI16_V_MF4_MF4 /* 5522 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI16_V_MF4_MF4_MASK /* 5523 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI16_V_MF4_MF8 /* 5524 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI16_V_MF4_MF8_MASK /* 5525 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI32_V_M1_M1 /* 5526 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI32_V_M1_M1_MASK /* 5527 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI32_V_M1_MF2 /* 5528 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI32_V_M1_MF2_MASK /* 5529 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI32_V_M1_MF4 /* 5530 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI32_V_M1_MF4_MASK /* 5531 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI32_V_M2_M1 /* 5532 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI32_V_M2_M1_MASK /* 5533 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI32_V_M2_MF2 /* 5534 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI32_V_M2_MF2_MASK /* 5535 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI32_V_M4_M1 /* 5536 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI32_V_M4_M1_MASK /* 5537 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI32_V_MF2_M1 /* 5538 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI32_V_MF2_M1_MASK /* 5539 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI32_V_MF2_MF2 /* 5540 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI32_V_MF2_MF2_MASK /* 5541 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI32_V_MF2_MF4 /* 5542 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI32_V_MF2_MF4_MASK /* 5543 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI32_V_MF2_MF8 /* 5544 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI32_V_MF2_MF8_MASK /* 5545 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI64_V_M1_M1 /* 5546 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI64_V_M1_M1_MASK /* 5547 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI64_V_M1_MF2 /* 5548 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI64_V_M1_MF2_MASK /* 5549 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI64_V_M1_MF4 /* 5550 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI64_V_M1_MF4_MASK /* 5551 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI64_V_M1_MF8 /* 5552 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI64_V_M1_MF8_MASK /* 5553 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI64_V_M2_M1 /* 5554 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI64_V_M2_M1_MASK /* 5555 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI64_V_M2_MF2 /* 5556 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI64_V_M2_MF2_MASK /* 5557 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI64_V_M2_MF4 /* 5558 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI64_V_M2_MF4_MASK /* 5559 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI64_V_M4_M1 /* 5560 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI64_V_M4_M1_MASK /* 5561 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI64_V_M4_MF2 /* 5562 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI64_V_M4_MF2_MASK /* 5563 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI64_V_M8_M1 /* 5564 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI64_V_M8_M1_MASK /* 5565 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI8_V_M1_M1 /* 5566 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI8_V_M1_M1_MASK /* 5567 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI8_V_MF2_M1 /* 5568 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI8_V_MF2_M1_MASK /* 5569 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI8_V_MF2_MF2 /* 5570 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI8_V_MF2_MF2_MASK /* 5571 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI8_V_MF4_M1 /* 5572 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI8_V_MF4_M1_MASK /* 5573 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI8_V_MF4_MF2 /* 5574 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI8_V_MF4_MF2_MASK /* 5575 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI8_V_MF4_MF4 /* 5576 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI8_V_MF4_MF4_MASK /* 5577 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI8_V_MF8_M1 /* 5578 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI8_V_MF8_M1_MASK /* 5579 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI8_V_MF8_MF2 /* 5580 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI8_V_MF8_MF2_MASK /* 5581 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI8_V_MF8_MF4 /* 5582 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI8_V_MF8_MF4_MASK /* 5583 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI8_V_MF8_MF8 /* 5584 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG6EI8_V_MF8_MF8_MASK /* 5585 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI16_V_M1_M1 /* 5586 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI16_V_M1_M1_MASK /* 5587 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI16_V_M1_MF2 /* 5588 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI16_V_M1_MF2_MASK /* 5589 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI16_V_M2_M1 /* 5590 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI16_V_M2_M1_MASK /* 5591 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI16_V_MF2_M1 /* 5592 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI16_V_MF2_M1_MASK /* 5593 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI16_V_MF2_MF2 /* 5594 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI16_V_MF2_MF2_MASK /* 5595 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI16_V_MF2_MF4 /* 5596 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI16_V_MF2_MF4_MASK /* 5597 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI16_V_MF4_M1 /* 5598 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI16_V_MF4_M1_MASK /* 5599 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI16_V_MF4_MF2 /* 5600 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI16_V_MF4_MF2_MASK /* 5601 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI16_V_MF4_MF4 /* 5602 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI16_V_MF4_MF4_MASK /* 5603 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI16_V_MF4_MF8 /* 5604 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI16_V_MF4_MF8_MASK /* 5605 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI32_V_M1_M1 /* 5606 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI32_V_M1_M1_MASK /* 5607 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI32_V_M1_MF2 /* 5608 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI32_V_M1_MF2_MASK /* 5609 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI32_V_M1_MF4 /* 5610 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI32_V_M1_MF4_MASK /* 5611 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI32_V_M2_M1 /* 5612 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI32_V_M2_M1_MASK /* 5613 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI32_V_M2_MF2 /* 5614 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI32_V_M2_MF2_MASK /* 5615 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI32_V_M4_M1 /* 5616 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI32_V_M4_M1_MASK /* 5617 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI32_V_MF2_M1 /* 5618 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI32_V_MF2_M1_MASK /* 5619 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI32_V_MF2_MF2 /* 5620 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI32_V_MF2_MF2_MASK /* 5621 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI32_V_MF2_MF4 /* 5622 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI32_V_MF2_MF4_MASK /* 5623 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI32_V_MF2_MF8 /* 5624 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI32_V_MF2_MF8_MASK /* 5625 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI64_V_M1_M1 /* 5626 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI64_V_M1_M1_MASK /* 5627 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI64_V_M1_MF2 /* 5628 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI64_V_M1_MF2_MASK /* 5629 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI64_V_M1_MF4 /* 5630 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI64_V_M1_MF4_MASK /* 5631 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI64_V_M1_MF8 /* 5632 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI64_V_M1_MF8_MASK /* 5633 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI64_V_M2_M1 /* 5634 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI64_V_M2_M1_MASK /* 5635 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI64_V_M2_MF2 /* 5636 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI64_V_M2_MF2_MASK /* 5637 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI64_V_M2_MF4 /* 5638 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI64_V_M2_MF4_MASK /* 5639 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI64_V_M4_M1 /* 5640 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI64_V_M4_M1_MASK /* 5641 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI64_V_M4_MF2 /* 5642 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI64_V_M4_MF2_MASK /* 5643 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI64_V_M8_M1 /* 5644 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI64_V_M8_M1_MASK /* 5645 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI8_V_M1_M1 /* 5646 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI8_V_M1_M1_MASK /* 5647 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI8_V_MF2_M1 /* 5648 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI8_V_MF2_M1_MASK /* 5649 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI8_V_MF2_MF2 /* 5650 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI8_V_MF2_MF2_MASK /* 5651 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI8_V_MF4_M1 /* 5652 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI8_V_MF4_M1_MASK /* 5653 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI8_V_MF4_MF2 /* 5654 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI8_V_MF4_MF2_MASK /* 5655 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI8_V_MF4_MF4 /* 5656 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI8_V_MF4_MF4_MASK /* 5657 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI8_V_MF8_M1 /* 5658 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI8_V_MF8_M1_MASK /* 5659 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI8_V_MF8_MF2 /* 5660 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI8_V_MF8_MF2_MASK /* 5661 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI8_V_MF8_MF4 /* 5662 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI8_V_MF8_MF4_MASK /* 5663 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI8_V_MF8_MF8 /* 5664 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG7EI8_V_MF8_MF8_MASK /* 5665 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI16_V_M1_M1 /* 5666 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI16_V_M1_M1_MASK /* 5667 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI16_V_M1_MF2 /* 5668 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI16_V_M1_MF2_MASK /* 5669 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI16_V_M2_M1 /* 5670 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI16_V_M2_M1_MASK /* 5671 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI16_V_MF2_M1 /* 5672 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI16_V_MF2_M1_MASK /* 5673 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI16_V_MF2_MF2 /* 5674 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI16_V_MF2_MF2_MASK /* 5675 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI16_V_MF2_MF4 /* 5676 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI16_V_MF2_MF4_MASK /* 5677 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI16_V_MF4_M1 /* 5678 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI16_V_MF4_M1_MASK /* 5679 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI16_V_MF4_MF2 /* 5680 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI16_V_MF4_MF2_MASK /* 5681 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI16_V_MF4_MF4 /* 5682 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI16_V_MF4_MF4_MASK /* 5683 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI16_V_MF4_MF8 /* 5684 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI16_V_MF4_MF8_MASK /* 5685 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI32_V_M1_M1 /* 5686 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI32_V_M1_M1_MASK /* 5687 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI32_V_M1_MF2 /* 5688 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI32_V_M1_MF2_MASK /* 5689 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI32_V_M1_MF4 /* 5690 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI32_V_M1_MF4_MASK /* 5691 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI32_V_M2_M1 /* 5692 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI32_V_M2_M1_MASK /* 5693 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI32_V_M2_MF2 /* 5694 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI32_V_M2_MF2_MASK /* 5695 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI32_V_M4_M1 /* 5696 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI32_V_M4_M1_MASK /* 5697 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI32_V_MF2_M1 /* 5698 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI32_V_MF2_M1_MASK /* 5699 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI32_V_MF2_MF2 /* 5700 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI32_V_MF2_MF2_MASK /* 5701 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI32_V_MF2_MF4 /* 5702 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI32_V_MF2_MF4_MASK /* 5703 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI32_V_MF2_MF8 /* 5704 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI32_V_MF2_MF8_MASK /* 5705 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI64_V_M1_M1 /* 5706 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI64_V_M1_M1_MASK /* 5707 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI64_V_M1_MF2 /* 5708 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI64_V_M1_MF2_MASK /* 5709 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI64_V_M1_MF4 /* 5710 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI64_V_M1_MF4_MASK /* 5711 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI64_V_M1_MF8 /* 5712 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI64_V_M1_MF8_MASK /* 5713 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI64_V_M2_M1 /* 5714 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI64_V_M2_M1_MASK /* 5715 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI64_V_M2_MF2 /* 5716 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI64_V_M2_MF2_MASK /* 5717 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI64_V_M2_MF4 /* 5718 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI64_V_M2_MF4_MASK /* 5719 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI64_V_M4_M1 /* 5720 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI64_V_M4_M1_MASK /* 5721 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI64_V_M4_MF2 /* 5722 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI64_V_M4_MF2_MASK /* 5723 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI64_V_M8_M1 /* 5724 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI64_V_M8_M1_MASK /* 5725 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI8_V_M1_M1 /* 5726 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI8_V_M1_M1_MASK /* 5727 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI8_V_MF2_M1 /* 5728 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI8_V_MF2_M1_MASK /* 5729 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI8_V_MF2_MF2 /* 5730 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI8_V_MF2_MF2_MASK /* 5731 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI8_V_MF4_M1 /* 5732 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI8_V_MF4_M1_MASK /* 5733 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI8_V_MF4_MF2 /* 5734 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI8_V_MF4_MF2_MASK /* 5735 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI8_V_MF4_MF4 /* 5736 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI8_V_MF4_MF4_MASK /* 5737 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI8_V_MF8_M1 /* 5738 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI8_V_MF8_M1_MASK /* 5739 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI8_V_MF8_MF2 /* 5740 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI8_V_MF8_MF2_MASK /* 5741 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI8_V_MF8_MF4 /* 5742 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI8_V_MF8_MF4_MASK /* 5743 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI8_V_MF8_MF8 /* 5744 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVLUXSEG8EI8_V_MF8_MF8_MASK /* 5745 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMACC_VV_M1 /* 5746 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMACC_VV_M1_MASK /* 5747 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMACC_VV_M2 /* 5748 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMACC_VV_M2_MASK /* 5749 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMACC_VV_M4 /* 5750 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMACC_VV_M4_MASK /* 5751 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMACC_VV_M8 /* 5752 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMACC_VV_M8_MASK /* 5753 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMACC_VV_MF2 /* 5754 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMACC_VV_MF2_MASK /* 5755 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMACC_VV_MF4 /* 5756 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMACC_VV_MF4_MASK /* 5757 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMACC_VV_MF8 /* 5758 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMACC_VV_MF8_MASK /* 5759 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMACC_VX_M1 /* 5760 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMACC_VX_M1_MASK /* 5761 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMACC_VX_M2 /* 5762 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMACC_VX_M2_MASK /* 5763 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMACC_VX_M4 /* 5764 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMACC_VX_M4_MASK /* 5765 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMACC_VX_M8 /* 5766 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMACC_VX_M8_MASK /* 5767 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMACC_VX_MF2 /* 5768 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMACC_VX_MF2_MASK /* 5769 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMACC_VX_MF4 /* 5770 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMACC_VX_MF4_MASK /* 5771 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMACC_VX_MF8 /* 5772 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMACC_VX_MF8_MASK /* 5773 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADC_VIM_M1 /* 5774 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADC_VIM_M2 /* 5775 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADC_VIM_M4 /* 5776 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADC_VIM_M8 /* 5777 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADC_VIM_MF2 /* 5778 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADC_VIM_MF4 /* 5779 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADC_VIM_MF8 /* 5780 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADC_VI_M1 /* 5781 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADC_VI_M2 /* 5782 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADC_VI_M4 /* 5783 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADC_VI_M8 /* 5784 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADC_VI_MF2 /* 5785 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADC_VI_MF4 /* 5786 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADC_VI_MF8 /* 5787 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADC_VVM_M1 /* 5788 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADC_VVM_M2 /* 5789 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADC_VVM_M4 /* 5790 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADC_VVM_M8 /* 5791 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADC_VVM_MF2 /* 5792 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADC_VVM_MF4 /* 5793 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADC_VVM_MF8 /* 5794 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADC_VV_M1 /* 5795 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADC_VV_M2 /* 5796 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADC_VV_M4 /* 5797 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADC_VV_M8 /* 5798 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADC_VV_MF2 /* 5799 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADC_VV_MF4 /* 5800 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADC_VV_MF8 /* 5801 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADC_VXM_M1 /* 5802 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADC_VXM_M2 /* 5803 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADC_VXM_M4 /* 5804 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADC_VXM_M8 /* 5805 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADC_VXM_MF2 /* 5806 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADC_VXM_MF4 /* 5807 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADC_VXM_MF8 /* 5808 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADC_VX_M1 /* 5809 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADC_VX_M2 /* 5810 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADC_VX_M4 /* 5811 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADC_VX_M8 /* 5812 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADC_VX_MF2 /* 5813 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADC_VX_MF4 /* 5814 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADC_VX_MF8 /* 5815 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADD_VV_M1 /* 5816 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADD_VV_M1_MASK /* 5817 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADD_VV_M2 /* 5818 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADD_VV_M2_MASK /* 5819 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADD_VV_M4 /* 5820 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADD_VV_M4_MASK /* 5821 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADD_VV_M8 /* 5822 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADD_VV_M8_MASK /* 5823 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADD_VV_MF2 /* 5824 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADD_VV_MF2_MASK /* 5825 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADD_VV_MF4 /* 5826 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADD_VV_MF4_MASK /* 5827 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADD_VV_MF8 /* 5828 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADD_VV_MF8_MASK /* 5829 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADD_VX_M1 /* 5830 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADD_VX_M1_MASK /* 5831 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADD_VX_M2 /* 5832 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADD_VX_M2_MASK /* 5833 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADD_VX_M4 /* 5834 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADD_VX_M4_MASK /* 5835 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADD_VX_M8 /* 5836 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADD_VX_M8_MASK /* 5837 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADD_VX_MF2 /* 5838 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADD_VX_MF2_MASK /* 5839 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADD_VX_MF4 /* 5840 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADD_VX_MF4_MASK /* 5841 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADD_VX_MF8 /* 5842 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMADD_VX_MF8_MASK /* 5843 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMANDN_MM_M1 /* 5844 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMANDN_MM_M2 /* 5845 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMANDN_MM_M4 /* 5846 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMANDN_MM_M8 /* 5847 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMANDN_MM_MF2 /* 5848 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMANDN_MM_MF4 /* 5849 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMANDN_MM_MF8 /* 5850 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAND_MM_M1 /* 5851 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAND_MM_M2 /* 5852 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAND_MM_M4 /* 5853 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAND_MM_M8 /* 5854 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAND_MM_MF2 /* 5855 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAND_MM_MF4 /* 5856 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAND_MM_MF8 /* 5857 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAXU_VV_M1 /* 5858 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAXU_VV_M1_MASK /* 5859 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAXU_VV_M2 /* 5860 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAXU_VV_M2_MASK /* 5861 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAXU_VV_M4 /* 5862 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAXU_VV_M4_MASK /* 5863 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAXU_VV_M8 /* 5864 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAXU_VV_M8_MASK /* 5865 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAXU_VV_MF2 /* 5866 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAXU_VV_MF2_MASK /* 5867 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAXU_VV_MF4 /* 5868 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAXU_VV_MF4_MASK /* 5869 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAXU_VV_MF8 /* 5870 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAXU_VV_MF8_MASK /* 5871 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAXU_VX_M1 /* 5872 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAXU_VX_M1_MASK /* 5873 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAXU_VX_M2 /* 5874 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAXU_VX_M2_MASK /* 5875 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAXU_VX_M4 /* 5876 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAXU_VX_M4_MASK /* 5877 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAXU_VX_M8 /* 5878 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAXU_VX_M8_MASK /* 5879 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAXU_VX_MF2 /* 5880 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAXU_VX_MF2_MASK /* 5881 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAXU_VX_MF4 /* 5882 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAXU_VX_MF4_MASK /* 5883 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAXU_VX_MF8 /* 5884 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAXU_VX_MF8_MASK /* 5885 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAX_VV_M1 /* 5886 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAX_VV_M1_MASK /* 5887 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAX_VV_M2 /* 5888 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAX_VV_M2_MASK /* 5889 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAX_VV_M4 /* 5890 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAX_VV_M4_MASK /* 5891 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAX_VV_M8 /* 5892 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAX_VV_M8_MASK /* 5893 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAX_VV_MF2 /* 5894 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAX_VV_MF2_MASK /* 5895 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAX_VV_MF4 /* 5896 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAX_VV_MF4_MASK /* 5897 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAX_VV_MF8 /* 5898 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAX_VV_MF8_MASK /* 5899 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAX_VX_M1 /* 5900 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAX_VX_M1_MASK /* 5901 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAX_VX_M2 /* 5902 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAX_VX_M2_MASK /* 5903 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAX_VX_M4 /* 5904 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAX_VX_M4_MASK /* 5905 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAX_VX_M8 /* 5906 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAX_VX_M8_MASK /* 5907 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAX_VX_MF2 /* 5908 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAX_VX_MF2_MASK /* 5909 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAX_VX_MF4 /* 5910 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAX_VX_MF4_MASK /* 5911 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAX_VX_MF8 /* 5912 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMAX_VX_MF8_MASK /* 5913 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMCLR_M_B1 /* 5914 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMCLR_M_B16 /* 5915 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMCLR_M_B2 /* 5916 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMCLR_M_B32 /* 5917 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMCLR_M_B4 /* 5918 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMCLR_M_B64 /* 5919 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMCLR_M_B8 /* 5920 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMERGE_VIM_M1 /* 5921 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMERGE_VIM_M2 /* 5922 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMERGE_VIM_M4 /* 5923 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMERGE_VIM_M8 /* 5924 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMERGE_VIM_MF2 /* 5925 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMERGE_VIM_MF4 /* 5926 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMERGE_VIM_MF8 /* 5927 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMERGE_VVM_M1 /* 5928 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMERGE_VVM_M2 /* 5929 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMERGE_VVM_M4 /* 5930 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMERGE_VVM_M8 /* 5931 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMERGE_VVM_MF2 /* 5932 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMERGE_VVM_MF4 /* 5933 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMERGE_VVM_MF8 /* 5934 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMERGE_VXM_M1 /* 5935 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMERGE_VXM_M2 /* 5936 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMERGE_VXM_M4 /* 5937 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMERGE_VXM_M8 /* 5938 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMERGE_VXM_MF2 /* 5939 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMERGE_VXM_MF4 /* 5940 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMERGE_VXM_MF8 /* 5941 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFEQ_VFPR16_M1 /* 5942 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFEQ_VFPR16_M1_MASK /* 5943 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFEQ_VFPR16_M2 /* 5944 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFEQ_VFPR16_M2_MASK /* 5945 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFEQ_VFPR16_M4 /* 5946 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFEQ_VFPR16_M4_MASK /* 5947 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFEQ_VFPR16_M8 /* 5948 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFEQ_VFPR16_M8_MASK /* 5949 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFEQ_VFPR16_MF2 /* 5950 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFEQ_VFPR16_MF2_MASK /* 5951 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFEQ_VFPR16_MF4 /* 5952 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFEQ_VFPR16_MF4_MASK /* 5953 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFEQ_VFPR32_M1 /* 5954 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFEQ_VFPR32_M1_MASK /* 5955 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFEQ_VFPR32_M2 /* 5956 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFEQ_VFPR32_M2_MASK /* 5957 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFEQ_VFPR32_M4 /* 5958 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFEQ_VFPR32_M4_MASK /* 5959 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFEQ_VFPR32_M8 /* 5960 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFEQ_VFPR32_M8_MASK /* 5961 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFEQ_VFPR32_MF2 /* 5962 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFEQ_VFPR32_MF2_MASK /* 5963 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFEQ_VFPR64_M1 /* 5964 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFEQ_VFPR64_M1_MASK /* 5965 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFEQ_VFPR64_M2 /* 5966 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFEQ_VFPR64_M2_MASK /* 5967 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFEQ_VFPR64_M4 /* 5968 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFEQ_VFPR64_M4_MASK /* 5969 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFEQ_VFPR64_M8 /* 5970 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFEQ_VFPR64_M8_MASK /* 5971 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFEQ_VV_M1 /* 5972 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFEQ_VV_M1_MASK /* 5973 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFEQ_VV_M2 /* 5974 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFEQ_VV_M2_MASK /* 5975 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFEQ_VV_M4 /* 5976 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFEQ_VV_M4_MASK /* 5977 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFEQ_VV_M8 /* 5978 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFEQ_VV_M8_MASK /* 5979 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFEQ_VV_MF2 /* 5980 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFEQ_VV_MF2_MASK /* 5981 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFEQ_VV_MF4 /* 5982 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFEQ_VV_MF4_MASK /* 5983 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGE_VFPR16_M1 /* 5984 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGE_VFPR16_M1_MASK /* 5985 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGE_VFPR16_M2 /* 5986 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGE_VFPR16_M2_MASK /* 5987 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGE_VFPR16_M4 /* 5988 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGE_VFPR16_M4_MASK /* 5989 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGE_VFPR16_M8 /* 5990 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGE_VFPR16_M8_MASK /* 5991 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGE_VFPR16_MF2 /* 5992 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGE_VFPR16_MF2_MASK /* 5993 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGE_VFPR16_MF4 /* 5994 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGE_VFPR16_MF4_MASK /* 5995 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGE_VFPR32_M1 /* 5996 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGE_VFPR32_M1_MASK /* 5997 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGE_VFPR32_M2 /* 5998 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGE_VFPR32_M2_MASK /* 5999 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGE_VFPR32_M4 /* 6000 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGE_VFPR32_M4_MASK /* 6001 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGE_VFPR32_M8 /* 6002 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGE_VFPR32_M8_MASK /* 6003 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGE_VFPR32_MF2 /* 6004 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGE_VFPR32_MF2_MASK /* 6005 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGE_VFPR64_M1 /* 6006 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGE_VFPR64_M1_MASK /* 6007 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGE_VFPR64_M2 /* 6008 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGE_VFPR64_M2_MASK /* 6009 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGE_VFPR64_M4 /* 6010 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGE_VFPR64_M4_MASK /* 6011 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGE_VFPR64_M8 /* 6012 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGE_VFPR64_M8_MASK /* 6013 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGT_VFPR16_M1 /* 6014 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGT_VFPR16_M1_MASK /* 6015 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGT_VFPR16_M2 /* 6016 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGT_VFPR16_M2_MASK /* 6017 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGT_VFPR16_M4 /* 6018 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGT_VFPR16_M4_MASK /* 6019 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGT_VFPR16_M8 /* 6020 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGT_VFPR16_M8_MASK /* 6021 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGT_VFPR16_MF2 /* 6022 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGT_VFPR16_MF2_MASK /* 6023 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGT_VFPR16_MF4 /* 6024 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGT_VFPR16_MF4_MASK /* 6025 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGT_VFPR32_M1 /* 6026 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGT_VFPR32_M1_MASK /* 6027 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGT_VFPR32_M2 /* 6028 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGT_VFPR32_M2_MASK /* 6029 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGT_VFPR32_M4 /* 6030 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGT_VFPR32_M4_MASK /* 6031 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGT_VFPR32_M8 /* 6032 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGT_VFPR32_M8_MASK /* 6033 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGT_VFPR32_MF2 /* 6034 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGT_VFPR32_MF2_MASK /* 6035 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGT_VFPR64_M1 /* 6036 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGT_VFPR64_M1_MASK /* 6037 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGT_VFPR64_M2 /* 6038 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGT_VFPR64_M2_MASK /* 6039 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGT_VFPR64_M4 /* 6040 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGT_VFPR64_M4_MASK /* 6041 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGT_VFPR64_M8 /* 6042 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFGT_VFPR64_M8_MASK /* 6043 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLE_VFPR16_M1 /* 6044 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLE_VFPR16_M1_MASK /* 6045 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLE_VFPR16_M2 /* 6046 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLE_VFPR16_M2_MASK /* 6047 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLE_VFPR16_M4 /* 6048 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLE_VFPR16_M4_MASK /* 6049 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLE_VFPR16_M8 /* 6050 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLE_VFPR16_M8_MASK /* 6051 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLE_VFPR16_MF2 /* 6052 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLE_VFPR16_MF2_MASK /* 6053 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLE_VFPR16_MF4 /* 6054 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLE_VFPR16_MF4_MASK /* 6055 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLE_VFPR32_M1 /* 6056 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLE_VFPR32_M1_MASK /* 6057 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLE_VFPR32_M2 /* 6058 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLE_VFPR32_M2_MASK /* 6059 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLE_VFPR32_M4 /* 6060 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLE_VFPR32_M4_MASK /* 6061 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLE_VFPR32_M8 /* 6062 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLE_VFPR32_M8_MASK /* 6063 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLE_VFPR32_MF2 /* 6064 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLE_VFPR32_MF2_MASK /* 6065 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLE_VFPR64_M1 /* 6066 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLE_VFPR64_M1_MASK /* 6067 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLE_VFPR64_M2 /* 6068 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLE_VFPR64_M2_MASK /* 6069 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLE_VFPR64_M4 /* 6070 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLE_VFPR64_M4_MASK /* 6071 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLE_VFPR64_M8 /* 6072 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLE_VFPR64_M8_MASK /* 6073 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLE_VV_M1 /* 6074 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLE_VV_M1_MASK /* 6075 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLE_VV_M2 /* 6076 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLE_VV_M2_MASK /* 6077 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLE_VV_M4 /* 6078 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLE_VV_M4_MASK /* 6079 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLE_VV_M8 /* 6080 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLE_VV_M8_MASK /* 6081 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLE_VV_MF2 /* 6082 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLE_VV_MF2_MASK /* 6083 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLE_VV_MF4 /* 6084 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLE_VV_MF4_MASK /* 6085 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLT_VFPR16_M1 /* 6086 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLT_VFPR16_M1_MASK /* 6087 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLT_VFPR16_M2 /* 6088 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLT_VFPR16_M2_MASK /* 6089 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLT_VFPR16_M4 /* 6090 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLT_VFPR16_M4_MASK /* 6091 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLT_VFPR16_M8 /* 6092 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLT_VFPR16_M8_MASK /* 6093 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLT_VFPR16_MF2 /* 6094 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLT_VFPR16_MF2_MASK /* 6095 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLT_VFPR16_MF4 /* 6096 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLT_VFPR16_MF4_MASK /* 6097 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLT_VFPR32_M1 /* 6098 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLT_VFPR32_M1_MASK /* 6099 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLT_VFPR32_M2 /* 6100 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLT_VFPR32_M2_MASK /* 6101 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLT_VFPR32_M4 /* 6102 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLT_VFPR32_M4_MASK /* 6103 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLT_VFPR32_M8 /* 6104 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLT_VFPR32_M8_MASK /* 6105 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLT_VFPR32_MF2 /* 6106 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLT_VFPR32_MF2_MASK /* 6107 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLT_VFPR64_M1 /* 6108 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLT_VFPR64_M1_MASK /* 6109 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLT_VFPR64_M2 /* 6110 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLT_VFPR64_M2_MASK /* 6111 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLT_VFPR64_M4 /* 6112 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLT_VFPR64_M4_MASK /* 6113 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLT_VFPR64_M8 /* 6114 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLT_VFPR64_M8_MASK /* 6115 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLT_VV_M1 /* 6116 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLT_VV_M1_MASK /* 6117 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLT_VV_M2 /* 6118 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLT_VV_M2_MASK /* 6119 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLT_VV_M4 /* 6120 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLT_VV_M4_MASK /* 6121 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLT_VV_M8 /* 6122 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLT_VV_M8_MASK /* 6123 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLT_VV_MF2 /* 6124 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLT_VV_MF2_MASK /* 6125 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLT_VV_MF4 /* 6126 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFLT_VV_MF4_MASK /* 6127 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFNE_VFPR16_M1 /* 6128 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFNE_VFPR16_M1_MASK /* 6129 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFNE_VFPR16_M2 /* 6130 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFNE_VFPR16_M2_MASK /* 6131 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFNE_VFPR16_M4 /* 6132 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFNE_VFPR16_M4_MASK /* 6133 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFNE_VFPR16_M8 /* 6134 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFNE_VFPR16_M8_MASK /* 6135 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFNE_VFPR16_MF2 /* 6136 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFNE_VFPR16_MF2_MASK /* 6137 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFNE_VFPR16_MF4 /* 6138 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFNE_VFPR16_MF4_MASK /* 6139 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFNE_VFPR32_M1 /* 6140 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFNE_VFPR32_M1_MASK /* 6141 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFNE_VFPR32_M2 /* 6142 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFNE_VFPR32_M2_MASK /* 6143 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFNE_VFPR32_M4 /* 6144 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFNE_VFPR32_M4_MASK /* 6145 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFNE_VFPR32_M8 /* 6146 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFNE_VFPR32_M8_MASK /* 6147 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFNE_VFPR32_MF2 /* 6148 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFNE_VFPR32_MF2_MASK /* 6149 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFNE_VFPR64_M1 /* 6150 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFNE_VFPR64_M1_MASK /* 6151 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFNE_VFPR64_M2 /* 6152 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFNE_VFPR64_M2_MASK /* 6153 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFNE_VFPR64_M4 /* 6154 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFNE_VFPR64_M4_MASK /* 6155 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFNE_VFPR64_M8 /* 6156 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFNE_VFPR64_M8_MASK /* 6157 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFNE_VV_M1 /* 6158 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFNE_VV_M1_MASK /* 6159 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFNE_VV_M2 /* 6160 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFNE_VV_M2_MASK /* 6161 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFNE_VV_M4 /* 6162 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFNE_VV_M4_MASK /* 6163 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFNE_VV_M8 /* 6164 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFNE_VV_M8_MASK /* 6165 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFNE_VV_MF2 /* 6166 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFNE_VV_MF2_MASK /* 6167 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFNE_VV_MF4 /* 6168 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMFNE_VV_MF4_MASK /* 6169 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMINU_VV_M1 /* 6170 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMINU_VV_M1_MASK /* 6171 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMINU_VV_M2 /* 6172 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMINU_VV_M2_MASK /* 6173 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMINU_VV_M4 /* 6174 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMINU_VV_M4_MASK /* 6175 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMINU_VV_M8 /* 6176 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMINU_VV_M8_MASK /* 6177 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMINU_VV_MF2 /* 6178 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMINU_VV_MF2_MASK /* 6179 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMINU_VV_MF4 /* 6180 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMINU_VV_MF4_MASK /* 6181 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMINU_VV_MF8 /* 6182 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMINU_VV_MF8_MASK /* 6183 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMINU_VX_M1 /* 6184 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMINU_VX_M1_MASK /* 6185 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMINU_VX_M2 /* 6186 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMINU_VX_M2_MASK /* 6187 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMINU_VX_M4 /* 6188 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMINU_VX_M4_MASK /* 6189 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMINU_VX_M8 /* 6190 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMINU_VX_M8_MASK /* 6191 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMINU_VX_MF2 /* 6192 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMINU_VX_MF2_MASK /* 6193 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMINU_VX_MF4 /* 6194 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMINU_VX_MF4_MASK /* 6195 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMINU_VX_MF8 /* 6196 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMINU_VX_MF8_MASK /* 6197 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMIN_VV_M1 /* 6198 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMIN_VV_M1_MASK /* 6199 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMIN_VV_M2 /* 6200 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMIN_VV_M2_MASK /* 6201 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMIN_VV_M4 /* 6202 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMIN_VV_M4_MASK /* 6203 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMIN_VV_M8 /* 6204 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMIN_VV_M8_MASK /* 6205 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMIN_VV_MF2 /* 6206 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMIN_VV_MF2_MASK /* 6207 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMIN_VV_MF4 /* 6208 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMIN_VV_MF4_MASK /* 6209 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMIN_VV_MF8 /* 6210 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMIN_VV_MF8_MASK /* 6211 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMIN_VX_M1 /* 6212 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMIN_VX_M1_MASK /* 6213 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMIN_VX_M2 /* 6214 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMIN_VX_M2_MASK /* 6215 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMIN_VX_M4 /* 6216 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMIN_VX_M4_MASK /* 6217 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMIN_VX_M8 /* 6218 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMIN_VX_M8_MASK /* 6219 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMIN_VX_MF2 /* 6220 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMIN_VX_MF2_MASK /* 6221 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMIN_VX_MF4 /* 6222 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMIN_VX_MF4_MASK /* 6223 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMIN_VX_MF8 /* 6224 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMIN_VX_MF8_MASK /* 6225 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMNAND_MM_M1 /* 6226 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMNAND_MM_M2 /* 6227 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMNAND_MM_M4 /* 6228 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMNAND_MM_M8 /* 6229 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMNAND_MM_MF2 /* 6230 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMNAND_MM_MF4 /* 6231 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMNAND_MM_MF8 /* 6232 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMNOR_MM_M1 /* 6233 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMNOR_MM_M2 /* 6234 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMNOR_MM_M4 /* 6235 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMNOR_MM_M8 /* 6236 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMNOR_MM_MF2 /* 6237 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMNOR_MM_MF4 /* 6238 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMNOR_MM_MF8 /* 6239 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMORN_MM_M1 /* 6240 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMORN_MM_M2 /* 6241 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMORN_MM_M4 /* 6242 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMORN_MM_M8 /* 6243 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMORN_MM_MF2 /* 6244 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMORN_MM_MF4 /* 6245 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMORN_MM_MF8 /* 6246 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMOR_MM_M1 /* 6247 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMOR_MM_M2 /* 6248 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMOR_MM_M4 /* 6249 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMOR_MM_M8 /* 6250 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMOR_MM_MF2 /* 6251 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMOR_MM_MF4 /* 6252 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMOR_MM_MF8 /* 6253 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSBC_VVM_M1 /* 6254 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSBC_VVM_M2 /* 6255 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSBC_VVM_M4 /* 6256 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSBC_VVM_M8 /* 6257 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSBC_VVM_MF2 /* 6258 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSBC_VVM_MF4 /* 6259 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSBC_VVM_MF8 /* 6260 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSBC_VV_M1 /* 6261 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSBC_VV_M2 /* 6262 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSBC_VV_M4 /* 6263 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSBC_VV_M8 /* 6264 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSBC_VV_MF2 /* 6265 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSBC_VV_MF4 /* 6266 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSBC_VV_MF8 /* 6267 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSBC_VXM_M1 /* 6268 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSBC_VXM_M2 /* 6269 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSBC_VXM_M4 /* 6270 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSBC_VXM_M8 /* 6271 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSBC_VXM_MF2 /* 6272 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSBC_VXM_MF4 /* 6273 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSBC_VXM_MF8 /* 6274 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSBC_VX_M1 /* 6275 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSBC_VX_M2 /* 6276 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSBC_VX_M4 /* 6277 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSBC_VX_M8 /* 6278 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSBC_VX_MF2 /* 6279 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSBC_VX_MF4 /* 6280 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSBC_VX_MF8 /* 6281 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSBF_M_B1 /* 6282 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSBF_M_B16 /* 6283 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSBF_M_B16_MASK /* 6284 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSBF_M_B1_MASK /* 6285 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSBF_M_B2 /* 6286 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSBF_M_B2_MASK /* 6287 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSBF_M_B32 /* 6288 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSBF_M_B32_MASK /* 6289 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSBF_M_B4 /* 6290 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSBF_M_B4_MASK /* 6291 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSBF_M_B64 /* 6292 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSBF_M_B64_MASK /* 6293 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSBF_M_B8 /* 6294 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSBF_M_B8_MASK /* 6295 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSEQ_VI_M1 /* 6296 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSEQ_VI_M1_MASK /* 6297 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSEQ_VI_M2 /* 6298 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSEQ_VI_M2_MASK /* 6299 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSEQ_VI_M4 /* 6300 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSEQ_VI_M4_MASK /* 6301 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSEQ_VI_M8 /* 6302 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSEQ_VI_M8_MASK /* 6303 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSEQ_VI_MF2 /* 6304 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSEQ_VI_MF2_MASK /* 6305 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSEQ_VI_MF4 /* 6306 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSEQ_VI_MF4_MASK /* 6307 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSEQ_VI_MF8 /* 6308 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSEQ_VI_MF8_MASK /* 6309 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSEQ_VV_M1 /* 6310 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSEQ_VV_M1_MASK /* 6311 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSEQ_VV_M2 /* 6312 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSEQ_VV_M2_MASK /* 6313 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSEQ_VV_M4 /* 6314 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSEQ_VV_M4_MASK /* 6315 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSEQ_VV_M8 /* 6316 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSEQ_VV_M8_MASK /* 6317 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSEQ_VV_MF2 /* 6318 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSEQ_VV_MF2_MASK /* 6319 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSEQ_VV_MF4 /* 6320 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSEQ_VV_MF4_MASK /* 6321 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSEQ_VV_MF8 /* 6322 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSEQ_VV_MF8_MASK /* 6323 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSEQ_VX_M1 /* 6324 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSEQ_VX_M1_MASK /* 6325 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSEQ_VX_M2 /* 6326 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSEQ_VX_M2_MASK /* 6327 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSEQ_VX_M4 /* 6328 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSEQ_VX_M4_MASK /* 6329 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSEQ_VX_M8 /* 6330 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSEQ_VX_M8_MASK /* 6331 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSEQ_VX_MF2 /* 6332 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSEQ_VX_MF2_MASK /* 6333 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSEQ_VX_MF4 /* 6334 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSEQ_VX_MF4_MASK /* 6335 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSEQ_VX_MF8 /* 6336 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSEQ_VX_MF8_MASK /* 6337 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSET_M_B1 /* 6338 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSET_M_B16 /* 6339 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSET_M_B2 /* 6340 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSET_M_B32 /* 6341 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSET_M_B4 /* 6342 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSET_M_B64 /* 6343 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSET_M_B8 /* 6344 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* vmsgeu.vi $vd, $vs2, $imm$vm */ + RISCV_PseudoVMSGEU_VI /* 6345 */, RISCV_INS_VMSGEU_VI, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmsgeu.vx $vd, $vs2, $rs1 */ + RISCV_PseudoVMSGEU_VX /* 6346 */, RISCV_INS_VMSGEU_VX, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmsgeu.vx $vd, $vs2, $rs1$vm */ + RISCV_PseudoVMSGEU_VX_M /* 6347 */, RISCV_INS_VMSGEU_VX, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmsgeu.vx $vd, $vs2, $rs1$vm, $scratch */ + RISCV_PseudoVMSGEU_VX_M_T /* 6348 */, RISCV_INS_VMSGEU_VX, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmsge.vi $vd, $vs2, $imm$vm */ + RISCV_PseudoVMSGE_VI /* 6349 */, RISCV_INS_VMSGE_VI, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmsge.vx $vd, $vs2, $rs1 */ + RISCV_PseudoVMSGE_VX /* 6350 */, RISCV_INS_VMSGE_VX, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmsge.vx $vd, $vs2, $rs1$vm */ + RISCV_PseudoVMSGE_VX_M /* 6351 */, RISCV_INS_VMSGE_VX, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmsge.vx $vd, $vs2, $rs1$vm, $scratch */ + RISCV_PseudoVMSGE_VX_M_T /* 6352 */, RISCV_INS_VMSGE_VX, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* */ + RISCV_PseudoVMSGTU_VI_M1 /* 6353 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSGTU_VI_M1_MASK /* 6354 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSGTU_VI_M2 /* 6355 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSGTU_VI_M2_MASK /* 6356 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSGTU_VI_M4 /* 6357 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSGTU_VI_M4_MASK /* 6358 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSGTU_VI_M8 /* 6359 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSGTU_VI_M8_MASK /* 6360 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSGTU_VI_MF2 /* 6361 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSGTU_VI_MF2_MASK /* 6362 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSGTU_VI_MF4 /* 6363 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSGTU_VI_MF4_MASK /* 6364 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSGTU_VI_MF8 /* 6365 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSGTU_VI_MF8_MASK /* 6366 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSGTU_VX_M1 /* 6367 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSGTU_VX_M1_MASK /* 6368 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSGTU_VX_M2 /* 6369 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSGTU_VX_M2_MASK /* 6370 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSGTU_VX_M4 /* 6371 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSGTU_VX_M4_MASK /* 6372 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSGTU_VX_M8 /* 6373 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSGTU_VX_M8_MASK /* 6374 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSGTU_VX_MF2 /* 6375 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSGTU_VX_MF2_MASK /* 6376 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSGTU_VX_MF4 /* 6377 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSGTU_VX_MF4_MASK /* 6378 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSGTU_VX_MF8 /* 6379 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSGTU_VX_MF8_MASK /* 6380 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSGT_VI_M1 /* 6381 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSGT_VI_M1_MASK /* 6382 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSGT_VI_M2 /* 6383 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSGT_VI_M2_MASK /* 6384 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSGT_VI_M4 /* 6385 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSGT_VI_M4_MASK /* 6386 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSGT_VI_M8 /* 6387 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSGT_VI_M8_MASK /* 6388 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSGT_VI_MF2 /* 6389 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSGT_VI_MF2_MASK /* 6390 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSGT_VI_MF4 /* 6391 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSGT_VI_MF4_MASK /* 6392 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSGT_VI_MF8 /* 6393 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSGT_VI_MF8_MASK /* 6394 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSGT_VX_M1 /* 6395 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSGT_VX_M1_MASK /* 6396 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSGT_VX_M2 /* 6397 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSGT_VX_M2_MASK /* 6398 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSGT_VX_M4 /* 6399 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSGT_VX_M4_MASK /* 6400 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSGT_VX_M8 /* 6401 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSGT_VX_M8_MASK /* 6402 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSGT_VX_MF2 /* 6403 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSGT_VX_MF2_MASK /* 6404 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSGT_VX_MF4 /* 6405 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSGT_VX_MF4_MASK /* 6406 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSGT_VX_MF8 /* 6407 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSGT_VX_MF8_MASK /* 6408 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSIF_M_B1 /* 6409 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSIF_M_B16 /* 6410 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSIF_M_B16_MASK /* 6411 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSIF_M_B1_MASK /* 6412 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSIF_M_B2 /* 6413 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSIF_M_B2_MASK /* 6414 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSIF_M_B32 /* 6415 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSIF_M_B32_MASK /* 6416 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSIF_M_B4 /* 6417 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSIF_M_B4_MASK /* 6418 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSIF_M_B64 /* 6419 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSIF_M_B64_MASK /* 6420 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSIF_M_B8 /* 6421 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSIF_M_B8_MASK /* 6422 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLEU_VI_M1 /* 6423 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLEU_VI_M1_MASK /* 6424 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLEU_VI_M2 /* 6425 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLEU_VI_M2_MASK /* 6426 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLEU_VI_M4 /* 6427 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLEU_VI_M4_MASK /* 6428 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLEU_VI_M8 /* 6429 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLEU_VI_M8_MASK /* 6430 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLEU_VI_MF2 /* 6431 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLEU_VI_MF2_MASK /* 6432 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLEU_VI_MF4 /* 6433 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLEU_VI_MF4_MASK /* 6434 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLEU_VI_MF8 /* 6435 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLEU_VI_MF8_MASK /* 6436 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLEU_VV_M1 /* 6437 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLEU_VV_M1_MASK /* 6438 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLEU_VV_M2 /* 6439 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLEU_VV_M2_MASK /* 6440 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLEU_VV_M4 /* 6441 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLEU_VV_M4_MASK /* 6442 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLEU_VV_M8 /* 6443 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLEU_VV_M8_MASK /* 6444 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLEU_VV_MF2 /* 6445 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLEU_VV_MF2_MASK /* 6446 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLEU_VV_MF4 /* 6447 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLEU_VV_MF4_MASK /* 6448 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLEU_VV_MF8 /* 6449 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLEU_VV_MF8_MASK /* 6450 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLEU_VX_M1 /* 6451 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLEU_VX_M1_MASK /* 6452 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLEU_VX_M2 /* 6453 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLEU_VX_M2_MASK /* 6454 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLEU_VX_M4 /* 6455 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLEU_VX_M4_MASK /* 6456 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLEU_VX_M8 /* 6457 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLEU_VX_M8_MASK /* 6458 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLEU_VX_MF2 /* 6459 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLEU_VX_MF2_MASK /* 6460 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLEU_VX_MF4 /* 6461 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLEU_VX_MF4_MASK /* 6462 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLEU_VX_MF8 /* 6463 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLEU_VX_MF8_MASK /* 6464 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLE_VI_M1 /* 6465 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLE_VI_M1_MASK /* 6466 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLE_VI_M2 /* 6467 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLE_VI_M2_MASK /* 6468 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLE_VI_M4 /* 6469 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLE_VI_M4_MASK /* 6470 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLE_VI_M8 /* 6471 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLE_VI_M8_MASK /* 6472 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLE_VI_MF2 /* 6473 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLE_VI_MF2_MASK /* 6474 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLE_VI_MF4 /* 6475 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLE_VI_MF4_MASK /* 6476 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLE_VI_MF8 /* 6477 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLE_VI_MF8_MASK /* 6478 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLE_VV_M1 /* 6479 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLE_VV_M1_MASK /* 6480 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLE_VV_M2 /* 6481 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLE_VV_M2_MASK /* 6482 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLE_VV_M4 /* 6483 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLE_VV_M4_MASK /* 6484 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLE_VV_M8 /* 6485 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLE_VV_M8_MASK /* 6486 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLE_VV_MF2 /* 6487 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLE_VV_MF2_MASK /* 6488 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLE_VV_MF4 /* 6489 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLE_VV_MF4_MASK /* 6490 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLE_VV_MF8 /* 6491 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLE_VV_MF8_MASK /* 6492 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLE_VX_M1 /* 6493 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLE_VX_M1_MASK /* 6494 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLE_VX_M2 /* 6495 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLE_VX_M2_MASK /* 6496 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLE_VX_M4 /* 6497 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLE_VX_M4_MASK /* 6498 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLE_VX_M8 /* 6499 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLE_VX_M8_MASK /* 6500 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLE_VX_MF2 /* 6501 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLE_VX_MF2_MASK /* 6502 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLE_VX_MF4 /* 6503 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLE_VX_MF4_MASK /* 6504 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLE_VX_MF8 /* 6505 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLE_VX_MF8_MASK /* 6506 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* vmsltu.vi $vd, $vs2, $imm$vm */ + RISCV_PseudoVMSLTU_VI /* 6507 */, RISCV_INS_VMSLTU_VI, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* */ + RISCV_PseudoVMSLTU_VV_M1 /* 6508 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLTU_VV_M1_MASK /* 6509 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLTU_VV_M2 /* 6510 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLTU_VV_M2_MASK /* 6511 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLTU_VV_M4 /* 6512 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLTU_VV_M4_MASK /* 6513 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLTU_VV_M8 /* 6514 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLTU_VV_M8_MASK /* 6515 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLTU_VV_MF2 /* 6516 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLTU_VV_MF2_MASK /* 6517 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLTU_VV_MF4 /* 6518 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLTU_VV_MF4_MASK /* 6519 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLTU_VV_MF8 /* 6520 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLTU_VV_MF8_MASK /* 6521 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLTU_VX_M1 /* 6522 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLTU_VX_M1_MASK /* 6523 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLTU_VX_M2 /* 6524 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLTU_VX_M2_MASK /* 6525 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLTU_VX_M4 /* 6526 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLTU_VX_M4_MASK /* 6527 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLTU_VX_M8 /* 6528 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLTU_VX_M8_MASK /* 6529 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLTU_VX_MF2 /* 6530 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLTU_VX_MF2_MASK /* 6531 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLTU_VX_MF4 /* 6532 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLTU_VX_MF4_MASK /* 6533 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLTU_VX_MF8 /* 6534 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLTU_VX_MF8_MASK /* 6535 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* vmslt.vi $vd, $vs2, $imm$vm */ + RISCV_PseudoVMSLT_VI /* 6536 */, RISCV_INS_VMSLT_VI, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* */ + RISCV_PseudoVMSLT_VV_M1 /* 6537 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLT_VV_M1_MASK /* 6538 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLT_VV_M2 /* 6539 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLT_VV_M2_MASK /* 6540 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLT_VV_M4 /* 6541 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLT_VV_M4_MASK /* 6542 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLT_VV_M8 /* 6543 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLT_VV_M8_MASK /* 6544 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLT_VV_MF2 /* 6545 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLT_VV_MF2_MASK /* 6546 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLT_VV_MF4 /* 6547 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLT_VV_MF4_MASK /* 6548 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLT_VV_MF8 /* 6549 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLT_VV_MF8_MASK /* 6550 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLT_VX_M1 /* 6551 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLT_VX_M1_MASK /* 6552 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLT_VX_M2 /* 6553 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLT_VX_M2_MASK /* 6554 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLT_VX_M4 /* 6555 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLT_VX_M4_MASK /* 6556 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLT_VX_M8 /* 6557 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLT_VX_M8_MASK /* 6558 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLT_VX_MF2 /* 6559 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLT_VX_MF2_MASK /* 6560 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLT_VX_MF4 /* 6561 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLT_VX_MF4_MASK /* 6562 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLT_VX_MF8 /* 6563 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSLT_VX_MF8_MASK /* 6564 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSNE_VI_M1 /* 6565 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSNE_VI_M1_MASK /* 6566 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSNE_VI_M2 /* 6567 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSNE_VI_M2_MASK /* 6568 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSNE_VI_M4 /* 6569 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSNE_VI_M4_MASK /* 6570 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSNE_VI_M8 /* 6571 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSNE_VI_M8_MASK /* 6572 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSNE_VI_MF2 /* 6573 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSNE_VI_MF2_MASK /* 6574 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSNE_VI_MF4 /* 6575 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSNE_VI_MF4_MASK /* 6576 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSNE_VI_MF8 /* 6577 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSNE_VI_MF8_MASK /* 6578 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSNE_VV_M1 /* 6579 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSNE_VV_M1_MASK /* 6580 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSNE_VV_M2 /* 6581 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSNE_VV_M2_MASK /* 6582 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSNE_VV_M4 /* 6583 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSNE_VV_M4_MASK /* 6584 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSNE_VV_M8 /* 6585 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSNE_VV_M8_MASK /* 6586 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSNE_VV_MF2 /* 6587 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSNE_VV_MF2_MASK /* 6588 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSNE_VV_MF4 /* 6589 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSNE_VV_MF4_MASK /* 6590 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSNE_VV_MF8 /* 6591 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSNE_VV_MF8_MASK /* 6592 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSNE_VX_M1 /* 6593 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSNE_VX_M1_MASK /* 6594 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSNE_VX_M2 /* 6595 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSNE_VX_M2_MASK /* 6596 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSNE_VX_M4 /* 6597 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSNE_VX_M4_MASK /* 6598 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSNE_VX_M8 /* 6599 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSNE_VX_M8_MASK /* 6600 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSNE_VX_MF2 /* 6601 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSNE_VX_MF2_MASK /* 6602 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSNE_VX_MF4 /* 6603 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSNE_VX_MF4_MASK /* 6604 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSNE_VX_MF8 /* 6605 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSNE_VX_MF8_MASK /* 6606 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSOF_M_B1 /* 6607 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSOF_M_B16 /* 6608 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSOF_M_B16_MASK /* 6609 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSOF_M_B1_MASK /* 6610 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSOF_M_B2 /* 6611 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSOF_M_B2_MASK /* 6612 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSOF_M_B32 /* 6613 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSOF_M_B32_MASK /* 6614 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSOF_M_B4 /* 6615 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSOF_M_B4_MASK /* 6616 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSOF_M_B64 /* 6617 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSOF_M_B64_MASK /* 6618 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSOF_M_B8 /* 6619 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMSOF_M_B8_MASK /* 6620 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULHSU_VV_M1 /* 6621 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULHSU_VV_M1_MASK /* 6622 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULHSU_VV_M2 /* 6623 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULHSU_VV_M2_MASK /* 6624 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULHSU_VV_M4 /* 6625 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULHSU_VV_M4_MASK /* 6626 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULHSU_VV_M8 /* 6627 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULHSU_VV_M8_MASK /* 6628 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULHSU_VV_MF2 /* 6629 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULHSU_VV_MF2_MASK /* 6630 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULHSU_VV_MF4 /* 6631 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULHSU_VV_MF4_MASK /* 6632 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULHSU_VV_MF8 /* 6633 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULHSU_VV_MF8_MASK /* 6634 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULHSU_VX_M1 /* 6635 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULHSU_VX_M1_MASK /* 6636 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULHSU_VX_M2 /* 6637 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULHSU_VX_M2_MASK /* 6638 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULHSU_VX_M4 /* 6639 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULHSU_VX_M4_MASK /* 6640 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULHSU_VX_M8 /* 6641 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULHSU_VX_M8_MASK /* 6642 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULHSU_VX_MF2 /* 6643 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULHSU_VX_MF2_MASK /* 6644 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULHSU_VX_MF4 /* 6645 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULHSU_VX_MF4_MASK /* 6646 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULHSU_VX_MF8 /* 6647 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULHSU_VX_MF8_MASK /* 6648 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULHU_VV_M1 /* 6649 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULHU_VV_M1_MASK /* 6650 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULHU_VV_M2 /* 6651 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULHU_VV_M2_MASK /* 6652 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULHU_VV_M4 /* 6653 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULHU_VV_M4_MASK /* 6654 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULHU_VV_M8 /* 6655 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULHU_VV_M8_MASK /* 6656 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULHU_VV_MF2 /* 6657 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULHU_VV_MF2_MASK /* 6658 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULHU_VV_MF4 /* 6659 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULHU_VV_MF4_MASK /* 6660 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULHU_VV_MF8 /* 6661 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULHU_VV_MF8_MASK /* 6662 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULHU_VX_M1 /* 6663 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULHU_VX_M1_MASK /* 6664 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULHU_VX_M2 /* 6665 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULHU_VX_M2_MASK /* 6666 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULHU_VX_M4 /* 6667 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULHU_VX_M4_MASK /* 6668 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULHU_VX_M8 /* 6669 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULHU_VX_M8_MASK /* 6670 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULHU_VX_MF2 /* 6671 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULHU_VX_MF2_MASK /* 6672 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULHU_VX_MF4 /* 6673 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULHU_VX_MF4_MASK /* 6674 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULHU_VX_MF8 /* 6675 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULHU_VX_MF8_MASK /* 6676 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULH_VV_M1 /* 6677 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULH_VV_M1_MASK /* 6678 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULH_VV_M2 /* 6679 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULH_VV_M2_MASK /* 6680 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULH_VV_M4 /* 6681 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULH_VV_M4_MASK /* 6682 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULH_VV_M8 /* 6683 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULH_VV_M8_MASK /* 6684 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULH_VV_MF2 /* 6685 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULH_VV_MF2_MASK /* 6686 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULH_VV_MF4 /* 6687 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULH_VV_MF4_MASK /* 6688 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULH_VV_MF8 /* 6689 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULH_VV_MF8_MASK /* 6690 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULH_VX_M1 /* 6691 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULH_VX_M1_MASK /* 6692 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULH_VX_M2 /* 6693 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULH_VX_M2_MASK /* 6694 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULH_VX_M4 /* 6695 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULH_VX_M4_MASK /* 6696 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULH_VX_M8 /* 6697 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULH_VX_M8_MASK /* 6698 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULH_VX_MF2 /* 6699 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULH_VX_MF2_MASK /* 6700 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULH_VX_MF4 /* 6701 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULH_VX_MF4_MASK /* 6702 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULH_VX_MF8 /* 6703 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMULH_VX_MF8_MASK /* 6704 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMUL_VV_M1 /* 6705 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMUL_VV_M1_MASK /* 6706 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMUL_VV_M2 /* 6707 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMUL_VV_M2_MASK /* 6708 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMUL_VV_M4 /* 6709 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMUL_VV_M4_MASK /* 6710 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMUL_VV_M8 /* 6711 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMUL_VV_M8_MASK /* 6712 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMUL_VV_MF2 /* 6713 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMUL_VV_MF2_MASK /* 6714 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMUL_VV_MF4 /* 6715 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMUL_VV_MF4_MASK /* 6716 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMUL_VV_MF8 /* 6717 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMUL_VV_MF8_MASK /* 6718 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMUL_VX_M1 /* 6719 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMUL_VX_M1_MASK /* 6720 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMUL_VX_M2 /* 6721 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMUL_VX_M2_MASK /* 6722 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMUL_VX_M4 /* 6723 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMUL_VX_M4_MASK /* 6724 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMUL_VX_M8 /* 6725 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMUL_VX_M8_MASK /* 6726 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMUL_VX_MF2 /* 6727 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMUL_VX_MF2_MASK /* 6728 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMUL_VX_MF4 /* 6729 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMUL_VX_MF4_MASK /* 6730 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMUL_VX_MF8 /* 6731 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMUL_VX_MF8_MASK /* 6732 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMV_S_X /* 6733 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMV_V_I_M1 /* 6734 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMV_V_I_M2 /* 6735 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMV_V_I_M4 /* 6736 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMV_V_I_M8 /* 6737 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMV_V_I_MF2 /* 6738 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMV_V_I_MF4 /* 6739 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMV_V_I_MF8 /* 6740 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMV_V_V_M1 /* 6741 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMV_V_V_M2 /* 6742 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMV_V_V_M4 /* 6743 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMV_V_V_M8 /* 6744 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMV_V_V_MF2 /* 6745 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMV_V_V_MF4 /* 6746 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMV_V_V_MF8 /* 6747 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMV_V_X_M1 /* 6748 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMV_V_X_M2 /* 6749 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMV_V_X_M4 /* 6750 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMV_V_X_M8 /* 6751 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMV_V_X_MF2 /* 6752 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMV_V_X_MF4 /* 6753 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMV_V_X_MF8 /* 6754 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMV_X_S /* 6755 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMXNOR_MM_M1 /* 6756 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMXNOR_MM_M2 /* 6757 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMXNOR_MM_M4 /* 6758 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMXNOR_MM_M8 /* 6759 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMXNOR_MM_MF2 /* 6760 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMXNOR_MM_MF4 /* 6761 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMXNOR_MM_MF8 /* 6762 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMXOR_MM_M1 /* 6763 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMXOR_MM_M2 /* 6764 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMXOR_MM_M4 /* 6765 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMXOR_MM_M8 /* 6766 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMXOR_MM_MF2 /* 6767 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMXOR_MM_MF4 /* 6768 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVMXOR_MM_MF8 /* 6769 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIPU_WI_M1 /* 6770 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIPU_WI_M1_MASK /* 6771 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIPU_WI_M2 /* 6772 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIPU_WI_M2_MASK /* 6773 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIPU_WI_M4 /* 6774 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIPU_WI_M4_MASK /* 6775 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIPU_WI_MF2 /* 6776 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIPU_WI_MF2_MASK /* 6777 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIPU_WI_MF4 /* 6778 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIPU_WI_MF4_MASK /* 6779 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIPU_WI_MF8 /* 6780 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIPU_WI_MF8_MASK /* 6781 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIPU_WV_M1 /* 6782 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIPU_WV_M1_MASK /* 6783 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIPU_WV_M2 /* 6784 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIPU_WV_M2_MASK /* 6785 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIPU_WV_M4 /* 6786 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIPU_WV_M4_MASK /* 6787 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIPU_WV_MF2 /* 6788 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIPU_WV_MF2_MASK /* 6789 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIPU_WV_MF4 /* 6790 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIPU_WV_MF4_MASK /* 6791 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIPU_WV_MF8 /* 6792 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIPU_WV_MF8_MASK /* 6793 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIPU_WX_M1 /* 6794 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIPU_WX_M1_MASK /* 6795 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIPU_WX_M2 /* 6796 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIPU_WX_M2_MASK /* 6797 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIPU_WX_M4 /* 6798 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIPU_WX_M4_MASK /* 6799 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIPU_WX_MF2 /* 6800 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIPU_WX_MF2_MASK /* 6801 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIPU_WX_MF4 /* 6802 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIPU_WX_MF4_MASK /* 6803 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIPU_WX_MF8 /* 6804 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIPU_WX_MF8_MASK /* 6805 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIP_WI_M1 /* 6806 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIP_WI_M1_MASK /* 6807 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIP_WI_M2 /* 6808 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIP_WI_M2_MASK /* 6809 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIP_WI_M4 /* 6810 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIP_WI_M4_MASK /* 6811 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIP_WI_MF2 /* 6812 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIP_WI_MF2_MASK /* 6813 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIP_WI_MF4 /* 6814 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIP_WI_MF4_MASK /* 6815 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIP_WI_MF8 /* 6816 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIP_WI_MF8_MASK /* 6817 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIP_WV_M1 /* 6818 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIP_WV_M1_MASK /* 6819 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIP_WV_M2 /* 6820 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIP_WV_M2_MASK /* 6821 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIP_WV_M4 /* 6822 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIP_WV_M4_MASK /* 6823 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIP_WV_MF2 /* 6824 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIP_WV_MF2_MASK /* 6825 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIP_WV_MF4 /* 6826 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIP_WV_MF4_MASK /* 6827 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIP_WV_MF8 /* 6828 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIP_WV_MF8_MASK /* 6829 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIP_WX_M1 /* 6830 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIP_WX_M1_MASK /* 6831 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIP_WX_M2 /* 6832 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIP_WX_M2_MASK /* 6833 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIP_WX_M4 /* 6834 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIP_WX_M4_MASK /* 6835 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIP_WX_MF2 /* 6836 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIP_WX_MF2_MASK /* 6837 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIP_WX_MF4 /* 6838 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIP_WX_MF4_MASK /* 6839 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIP_WX_MF8 /* 6840 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNCLIP_WX_MF8_MASK /* 6841 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNMSAC_VV_M1 /* 6842 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNMSAC_VV_M1_MASK /* 6843 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNMSAC_VV_M2 /* 6844 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNMSAC_VV_M2_MASK /* 6845 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNMSAC_VV_M4 /* 6846 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNMSAC_VV_M4_MASK /* 6847 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNMSAC_VV_M8 /* 6848 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNMSAC_VV_M8_MASK /* 6849 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNMSAC_VV_MF2 /* 6850 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNMSAC_VV_MF2_MASK /* 6851 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNMSAC_VV_MF4 /* 6852 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNMSAC_VV_MF4_MASK /* 6853 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNMSAC_VV_MF8 /* 6854 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNMSAC_VV_MF8_MASK /* 6855 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNMSAC_VX_M1 /* 6856 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNMSAC_VX_M1_MASK /* 6857 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNMSAC_VX_M2 /* 6858 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNMSAC_VX_M2_MASK /* 6859 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNMSAC_VX_M4 /* 6860 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNMSAC_VX_M4_MASK /* 6861 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNMSAC_VX_M8 /* 6862 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNMSAC_VX_M8_MASK /* 6863 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNMSAC_VX_MF2 /* 6864 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNMSAC_VX_MF2_MASK /* 6865 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNMSAC_VX_MF4 /* 6866 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNMSAC_VX_MF4_MASK /* 6867 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNMSAC_VX_MF8 /* 6868 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNMSAC_VX_MF8_MASK /* 6869 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNMSUB_VV_M1 /* 6870 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNMSUB_VV_M1_MASK /* 6871 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNMSUB_VV_M2 /* 6872 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNMSUB_VV_M2_MASK /* 6873 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNMSUB_VV_M4 /* 6874 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNMSUB_VV_M4_MASK /* 6875 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNMSUB_VV_M8 /* 6876 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNMSUB_VV_M8_MASK /* 6877 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNMSUB_VV_MF2 /* 6878 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNMSUB_VV_MF2_MASK /* 6879 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNMSUB_VV_MF4 /* 6880 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNMSUB_VV_MF4_MASK /* 6881 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNMSUB_VV_MF8 /* 6882 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNMSUB_VV_MF8_MASK /* 6883 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNMSUB_VX_M1 /* 6884 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNMSUB_VX_M1_MASK /* 6885 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNMSUB_VX_M2 /* 6886 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNMSUB_VX_M2_MASK /* 6887 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNMSUB_VX_M4 /* 6888 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNMSUB_VX_M4_MASK /* 6889 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNMSUB_VX_M8 /* 6890 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNMSUB_VX_M8_MASK /* 6891 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNMSUB_VX_MF2 /* 6892 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNMSUB_VX_MF2_MASK /* 6893 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNMSUB_VX_MF4 /* 6894 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNMSUB_VX_MF4_MASK /* 6895 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNMSUB_VX_MF8 /* 6896 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNMSUB_VX_MF8_MASK /* 6897 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRA_WI_M1 /* 6898 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRA_WI_M1_MASK /* 6899 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRA_WI_M2 /* 6900 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRA_WI_M2_MASK /* 6901 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRA_WI_M4 /* 6902 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRA_WI_M4_MASK /* 6903 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRA_WI_MF2 /* 6904 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRA_WI_MF2_MASK /* 6905 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRA_WI_MF4 /* 6906 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRA_WI_MF4_MASK /* 6907 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRA_WI_MF8 /* 6908 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRA_WI_MF8_MASK /* 6909 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRA_WV_M1 /* 6910 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRA_WV_M1_MASK /* 6911 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRA_WV_M2 /* 6912 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRA_WV_M2_MASK /* 6913 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRA_WV_M4 /* 6914 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRA_WV_M4_MASK /* 6915 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRA_WV_MF2 /* 6916 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRA_WV_MF2_MASK /* 6917 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRA_WV_MF4 /* 6918 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRA_WV_MF4_MASK /* 6919 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRA_WV_MF8 /* 6920 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRA_WV_MF8_MASK /* 6921 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRA_WX_M1 /* 6922 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRA_WX_M1_MASK /* 6923 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRA_WX_M2 /* 6924 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRA_WX_M2_MASK /* 6925 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRA_WX_M4 /* 6926 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRA_WX_M4_MASK /* 6927 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRA_WX_MF2 /* 6928 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRA_WX_MF2_MASK /* 6929 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRA_WX_MF4 /* 6930 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRA_WX_MF4_MASK /* 6931 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRA_WX_MF8 /* 6932 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRA_WX_MF8_MASK /* 6933 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRL_WI_M1 /* 6934 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRL_WI_M1_MASK /* 6935 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRL_WI_M2 /* 6936 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRL_WI_M2_MASK /* 6937 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRL_WI_M4 /* 6938 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRL_WI_M4_MASK /* 6939 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRL_WI_MF2 /* 6940 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRL_WI_MF2_MASK /* 6941 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRL_WI_MF4 /* 6942 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRL_WI_MF4_MASK /* 6943 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRL_WI_MF8 /* 6944 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRL_WI_MF8_MASK /* 6945 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRL_WV_M1 /* 6946 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRL_WV_M1_MASK /* 6947 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRL_WV_M2 /* 6948 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRL_WV_M2_MASK /* 6949 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRL_WV_M4 /* 6950 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRL_WV_M4_MASK /* 6951 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRL_WV_MF2 /* 6952 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRL_WV_MF2_MASK /* 6953 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRL_WV_MF4 /* 6954 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRL_WV_MF4_MASK /* 6955 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRL_WV_MF8 /* 6956 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRL_WV_MF8_MASK /* 6957 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRL_WX_M1 /* 6958 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRL_WX_M1_MASK /* 6959 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRL_WX_M2 /* 6960 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRL_WX_M2_MASK /* 6961 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRL_WX_M4 /* 6962 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRL_WX_M4_MASK /* 6963 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRL_WX_MF2 /* 6964 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRL_WX_MF2_MASK /* 6965 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRL_WX_MF4 /* 6966 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRL_WX_MF4_MASK /* 6967 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRL_WX_MF8 /* 6968 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVNSRL_WX_MF8_MASK /* 6969 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVOR_VI_M1 /* 6970 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVOR_VI_M1_MASK /* 6971 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVOR_VI_M2 /* 6972 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVOR_VI_M2_MASK /* 6973 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVOR_VI_M4 /* 6974 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVOR_VI_M4_MASK /* 6975 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVOR_VI_M8 /* 6976 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVOR_VI_M8_MASK /* 6977 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVOR_VI_MF2 /* 6978 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVOR_VI_MF2_MASK /* 6979 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVOR_VI_MF4 /* 6980 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVOR_VI_MF4_MASK /* 6981 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVOR_VI_MF8 /* 6982 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVOR_VI_MF8_MASK /* 6983 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVOR_VV_M1 /* 6984 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVOR_VV_M1_MASK /* 6985 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVOR_VV_M2 /* 6986 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVOR_VV_M2_MASK /* 6987 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVOR_VV_M4 /* 6988 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVOR_VV_M4_MASK /* 6989 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVOR_VV_M8 /* 6990 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVOR_VV_M8_MASK /* 6991 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVOR_VV_MF2 /* 6992 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVOR_VV_MF2_MASK /* 6993 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVOR_VV_MF4 /* 6994 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVOR_VV_MF4_MASK /* 6995 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVOR_VV_MF8 /* 6996 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVOR_VV_MF8_MASK /* 6997 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVOR_VX_M1 /* 6998 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVOR_VX_M1_MASK /* 6999 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVOR_VX_M2 /* 7000 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVOR_VX_M2_MASK /* 7001 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVOR_VX_M4 /* 7002 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVOR_VX_M4_MASK /* 7003 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVOR_VX_M8 /* 7004 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVOR_VX_M8_MASK /* 7005 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVOR_VX_MF2 /* 7006 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVOR_VX_MF2_MASK /* 7007 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVOR_VX_MF4 /* 7008 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVOR_VX_MF4_MASK /* 7009 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVOR_VX_MF8 /* 7010 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVOR_VX_MF8_MASK /* 7011 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVQMACCSU_2x8x2_M1 /* 7012 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVQMACCSU_2x8x2_M2 /* 7013 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVQMACCSU_2x8x2_M4 /* 7014 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVQMACCSU_2x8x2_M8 /* 7015 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVQMACCSU_4x8x4_M1 /* 7016 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVQMACCSU_4x8x4_M2 /* 7017 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVQMACCSU_4x8x4_M4 /* 7018 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVQMACCSU_4x8x4_MF2 /* 7019 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVQMACCUS_2x8x2_M1 /* 7020 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVQMACCUS_2x8x2_M2 /* 7021 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVQMACCUS_2x8x2_M4 /* 7022 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVQMACCUS_2x8x2_M8 /* 7023 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVQMACCUS_4x8x4_M1 /* 7024 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVQMACCUS_4x8x4_M2 /* 7025 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVQMACCUS_4x8x4_M4 /* 7026 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVQMACCUS_4x8x4_MF2 /* 7027 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVQMACCU_2x8x2_M1 /* 7028 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVQMACCU_2x8x2_M2 /* 7029 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVQMACCU_2x8x2_M4 /* 7030 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVQMACCU_2x8x2_M8 /* 7031 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVQMACCU_4x8x4_M1 /* 7032 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVQMACCU_4x8x4_M2 /* 7033 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVQMACCU_4x8x4_M4 /* 7034 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVQMACCU_4x8x4_MF2 /* 7035 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVQMACC_2x8x2_M1 /* 7036 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVQMACC_2x8x2_M2 /* 7037 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVQMACC_2x8x2_M4 /* 7038 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVQMACC_2x8x2_M8 /* 7039 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVQMACC_4x8x4_M1 /* 7040 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVQMACC_4x8x4_M2 /* 7041 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVQMACC_4x8x4_M4 /* 7042 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVQMACC_4x8x4_MF2 /* 7043 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDAND_VS_M1_E16 /* 7044 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDAND_VS_M1_E16_MASK /* 7045 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDAND_VS_M1_E32 /* 7046 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDAND_VS_M1_E32_MASK /* 7047 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDAND_VS_M1_E64 /* 7048 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDAND_VS_M1_E64_MASK /* 7049 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDAND_VS_M1_E8 /* 7050 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDAND_VS_M1_E8_MASK /* 7051 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDAND_VS_M2_E16 /* 7052 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDAND_VS_M2_E16_MASK /* 7053 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDAND_VS_M2_E32 /* 7054 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDAND_VS_M2_E32_MASK /* 7055 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDAND_VS_M2_E64 /* 7056 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDAND_VS_M2_E64_MASK /* 7057 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDAND_VS_M2_E8 /* 7058 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDAND_VS_M2_E8_MASK /* 7059 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDAND_VS_M4_E16 /* 7060 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDAND_VS_M4_E16_MASK /* 7061 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDAND_VS_M4_E32 /* 7062 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDAND_VS_M4_E32_MASK /* 7063 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDAND_VS_M4_E64 /* 7064 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDAND_VS_M4_E64_MASK /* 7065 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDAND_VS_M4_E8 /* 7066 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDAND_VS_M4_E8_MASK /* 7067 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDAND_VS_M8_E16 /* 7068 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDAND_VS_M8_E16_MASK /* 7069 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDAND_VS_M8_E32 /* 7070 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDAND_VS_M8_E32_MASK /* 7071 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDAND_VS_M8_E64 /* 7072 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDAND_VS_M8_E64_MASK /* 7073 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDAND_VS_M8_E8 /* 7074 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDAND_VS_M8_E8_MASK /* 7075 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDAND_VS_MF2_E16 /* 7076 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDAND_VS_MF2_E16_MASK /* 7077 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDAND_VS_MF2_E32 /* 7078 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDAND_VS_MF2_E32_MASK /* 7079 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDAND_VS_MF2_E8 /* 7080 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDAND_VS_MF2_E8_MASK /* 7081 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDAND_VS_MF4_E16 /* 7082 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDAND_VS_MF4_E16_MASK /* 7083 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDAND_VS_MF4_E8 /* 7084 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDAND_VS_MF4_E8_MASK /* 7085 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDAND_VS_MF8_E8 /* 7086 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDAND_VS_MF8_E8_MASK /* 7087 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAXU_VS_M1_E16 /* 7088 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAXU_VS_M1_E16_MASK /* 7089 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAXU_VS_M1_E32 /* 7090 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAXU_VS_M1_E32_MASK /* 7091 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAXU_VS_M1_E64 /* 7092 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAXU_VS_M1_E64_MASK /* 7093 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAXU_VS_M1_E8 /* 7094 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAXU_VS_M1_E8_MASK /* 7095 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAXU_VS_M2_E16 /* 7096 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAXU_VS_M2_E16_MASK /* 7097 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAXU_VS_M2_E32 /* 7098 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAXU_VS_M2_E32_MASK /* 7099 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAXU_VS_M2_E64 /* 7100 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAXU_VS_M2_E64_MASK /* 7101 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAXU_VS_M2_E8 /* 7102 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAXU_VS_M2_E8_MASK /* 7103 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAXU_VS_M4_E16 /* 7104 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAXU_VS_M4_E16_MASK /* 7105 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAXU_VS_M4_E32 /* 7106 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAXU_VS_M4_E32_MASK /* 7107 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAXU_VS_M4_E64 /* 7108 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAXU_VS_M4_E64_MASK /* 7109 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAXU_VS_M4_E8 /* 7110 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAXU_VS_M4_E8_MASK /* 7111 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAXU_VS_M8_E16 /* 7112 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAXU_VS_M8_E16_MASK /* 7113 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAXU_VS_M8_E32 /* 7114 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAXU_VS_M8_E32_MASK /* 7115 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAXU_VS_M8_E64 /* 7116 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAXU_VS_M8_E64_MASK /* 7117 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAXU_VS_M8_E8 /* 7118 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAXU_VS_M8_E8_MASK /* 7119 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAXU_VS_MF2_E16 /* 7120 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAXU_VS_MF2_E16_MASK /* 7121 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAXU_VS_MF2_E32 /* 7122 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAXU_VS_MF2_E32_MASK /* 7123 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAXU_VS_MF2_E8 /* 7124 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAXU_VS_MF2_E8_MASK /* 7125 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAXU_VS_MF4_E16 /* 7126 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAXU_VS_MF4_E16_MASK /* 7127 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAXU_VS_MF4_E8 /* 7128 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAXU_VS_MF4_E8_MASK /* 7129 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAXU_VS_MF8_E8 /* 7130 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAXU_VS_MF8_E8_MASK /* 7131 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAX_VS_M1_E16 /* 7132 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAX_VS_M1_E16_MASK /* 7133 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAX_VS_M1_E32 /* 7134 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAX_VS_M1_E32_MASK /* 7135 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAX_VS_M1_E64 /* 7136 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAX_VS_M1_E64_MASK /* 7137 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAX_VS_M1_E8 /* 7138 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAX_VS_M1_E8_MASK /* 7139 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAX_VS_M2_E16 /* 7140 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAX_VS_M2_E16_MASK /* 7141 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAX_VS_M2_E32 /* 7142 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAX_VS_M2_E32_MASK /* 7143 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAX_VS_M2_E64 /* 7144 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAX_VS_M2_E64_MASK /* 7145 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAX_VS_M2_E8 /* 7146 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAX_VS_M2_E8_MASK /* 7147 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAX_VS_M4_E16 /* 7148 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAX_VS_M4_E16_MASK /* 7149 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAX_VS_M4_E32 /* 7150 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAX_VS_M4_E32_MASK /* 7151 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAX_VS_M4_E64 /* 7152 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAX_VS_M4_E64_MASK /* 7153 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAX_VS_M4_E8 /* 7154 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAX_VS_M4_E8_MASK /* 7155 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAX_VS_M8_E16 /* 7156 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAX_VS_M8_E16_MASK /* 7157 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAX_VS_M8_E32 /* 7158 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAX_VS_M8_E32_MASK /* 7159 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAX_VS_M8_E64 /* 7160 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAX_VS_M8_E64_MASK /* 7161 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAX_VS_M8_E8 /* 7162 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAX_VS_M8_E8_MASK /* 7163 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAX_VS_MF2_E16 /* 7164 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAX_VS_MF2_E16_MASK /* 7165 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAX_VS_MF2_E32 /* 7166 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAX_VS_MF2_E32_MASK /* 7167 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAX_VS_MF2_E8 /* 7168 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAX_VS_MF2_E8_MASK /* 7169 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAX_VS_MF4_E16 /* 7170 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAX_VS_MF4_E16_MASK /* 7171 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAX_VS_MF4_E8 /* 7172 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAX_VS_MF4_E8_MASK /* 7173 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAX_VS_MF8_E8 /* 7174 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMAX_VS_MF8_E8_MASK /* 7175 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMINU_VS_M1_E16 /* 7176 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMINU_VS_M1_E16_MASK /* 7177 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMINU_VS_M1_E32 /* 7178 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMINU_VS_M1_E32_MASK /* 7179 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMINU_VS_M1_E64 /* 7180 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMINU_VS_M1_E64_MASK /* 7181 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMINU_VS_M1_E8 /* 7182 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMINU_VS_M1_E8_MASK /* 7183 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMINU_VS_M2_E16 /* 7184 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMINU_VS_M2_E16_MASK /* 7185 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMINU_VS_M2_E32 /* 7186 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMINU_VS_M2_E32_MASK /* 7187 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMINU_VS_M2_E64 /* 7188 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMINU_VS_M2_E64_MASK /* 7189 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMINU_VS_M2_E8 /* 7190 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMINU_VS_M2_E8_MASK /* 7191 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMINU_VS_M4_E16 /* 7192 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMINU_VS_M4_E16_MASK /* 7193 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMINU_VS_M4_E32 /* 7194 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMINU_VS_M4_E32_MASK /* 7195 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMINU_VS_M4_E64 /* 7196 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMINU_VS_M4_E64_MASK /* 7197 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMINU_VS_M4_E8 /* 7198 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMINU_VS_M4_E8_MASK /* 7199 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMINU_VS_M8_E16 /* 7200 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMINU_VS_M8_E16_MASK /* 7201 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMINU_VS_M8_E32 /* 7202 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMINU_VS_M8_E32_MASK /* 7203 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMINU_VS_M8_E64 /* 7204 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMINU_VS_M8_E64_MASK /* 7205 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMINU_VS_M8_E8 /* 7206 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMINU_VS_M8_E8_MASK /* 7207 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMINU_VS_MF2_E16 /* 7208 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMINU_VS_MF2_E16_MASK /* 7209 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMINU_VS_MF2_E32 /* 7210 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMINU_VS_MF2_E32_MASK /* 7211 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMINU_VS_MF2_E8 /* 7212 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMINU_VS_MF2_E8_MASK /* 7213 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMINU_VS_MF4_E16 /* 7214 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMINU_VS_MF4_E16_MASK /* 7215 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMINU_VS_MF4_E8 /* 7216 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMINU_VS_MF4_E8_MASK /* 7217 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMINU_VS_MF8_E8 /* 7218 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMINU_VS_MF8_E8_MASK /* 7219 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMIN_VS_M1_E16 /* 7220 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMIN_VS_M1_E16_MASK /* 7221 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMIN_VS_M1_E32 /* 7222 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMIN_VS_M1_E32_MASK /* 7223 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMIN_VS_M1_E64 /* 7224 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMIN_VS_M1_E64_MASK /* 7225 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMIN_VS_M1_E8 /* 7226 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMIN_VS_M1_E8_MASK /* 7227 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMIN_VS_M2_E16 /* 7228 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMIN_VS_M2_E16_MASK /* 7229 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMIN_VS_M2_E32 /* 7230 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMIN_VS_M2_E32_MASK /* 7231 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMIN_VS_M2_E64 /* 7232 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMIN_VS_M2_E64_MASK /* 7233 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMIN_VS_M2_E8 /* 7234 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMIN_VS_M2_E8_MASK /* 7235 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMIN_VS_M4_E16 /* 7236 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMIN_VS_M4_E16_MASK /* 7237 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMIN_VS_M4_E32 /* 7238 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMIN_VS_M4_E32_MASK /* 7239 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMIN_VS_M4_E64 /* 7240 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMIN_VS_M4_E64_MASK /* 7241 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMIN_VS_M4_E8 /* 7242 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMIN_VS_M4_E8_MASK /* 7243 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMIN_VS_M8_E16 /* 7244 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMIN_VS_M8_E16_MASK /* 7245 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMIN_VS_M8_E32 /* 7246 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMIN_VS_M8_E32_MASK /* 7247 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMIN_VS_M8_E64 /* 7248 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMIN_VS_M8_E64_MASK /* 7249 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMIN_VS_M8_E8 /* 7250 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMIN_VS_M8_E8_MASK /* 7251 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMIN_VS_MF2_E16 /* 7252 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMIN_VS_MF2_E16_MASK /* 7253 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMIN_VS_MF2_E32 /* 7254 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMIN_VS_MF2_E32_MASK /* 7255 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMIN_VS_MF2_E8 /* 7256 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMIN_VS_MF2_E8_MASK /* 7257 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMIN_VS_MF4_E16 /* 7258 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMIN_VS_MF4_E16_MASK /* 7259 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMIN_VS_MF4_E8 /* 7260 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMIN_VS_MF4_E8_MASK /* 7261 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMIN_VS_MF8_E8 /* 7262 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDMIN_VS_MF8_E8_MASK /* 7263 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDOR_VS_M1_E16 /* 7264 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDOR_VS_M1_E16_MASK /* 7265 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDOR_VS_M1_E32 /* 7266 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDOR_VS_M1_E32_MASK /* 7267 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDOR_VS_M1_E64 /* 7268 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDOR_VS_M1_E64_MASK /* 7269 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDOR_VS_M1_E8 /* 7270 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDOR_VS_M1_E8_MASK /* 7271 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDOR_VS_M2_E16 /* 7272 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDOR_VS_M2_E16_MASK /* 7273 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDOR_VS_M2_E32 /* 7274 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDOR_VS_M2_E32_MASK /* 7275 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDOR_VS_M2_E64 /* 7276 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDOR_VS_M2_E64_MASK /* 7277 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDOR_VS_M2_E8 /* 7278 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDOR_VS_M2_E8_MASK /* 7279 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDOR_VS_M4_E16 /* 7280 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDOR_VS_M4_E16_MASK /* 7281 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDOR_VS_M4_E32 /* 7282 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDOR_VS_M4_E32_MASK /* 7283 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDOR_VS_M4_E64 /* 7284 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDOR_VS_M4_E64_MASK /* 7285 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDOR_VS_M4_E8 /* 7286 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDOR_VS_M4_E8_MASK /* 7287 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDOR_VS_M8_E16 /* 7288 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDOR_VS_M8_E16_MASK /* 7289 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDOR_VS_M8_E32 /* 7290 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDOR_VS_M8_E32_MASK /* 7291 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDOR_VS_M8_E64 /* 7292 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDOR_VS_M8_E64_MASK /* 7293 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDOR_VS_M8_E8 /* 7294 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDOR_VS_M8_E8_MASK /* 7295 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDOR_VS_MF2_E16 /* 7296 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDOR_VS_MF2_E16_MASK /* 7297 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDOR_VS_MF2_E32 /* 7298 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDOR_VS_MF2_E32_MASK /* 7299 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDOR_VS_MF2_E8 /* 7300 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDOR_VS_MF2_E8_MASK /* 7301 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDOR_VS_MF4_E16 /* 7302 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDOR_VS_MF4_E16_MASK /* 7303 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDOR_VS_MF4_E8 /* 7304 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDOR_VS_MF4_E8_MASK /* 7305 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDOR_VS_MF8_E8 /* 7306 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDOR_VS_MF8_E8_MASK /* 7307 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDSUM_VS_M1_E16 /* 7308 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDSUM_VS_M1_E16_MASK /* 7309 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDSUM_VS_M1_E32 /* 7310 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDSUM_VS_M1_E32_MASK /* 7311 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDSUM_VS_M1_E64 /* 7312 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDSUM_VS_M1_E64_MASK /* 7313 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDSUM_VS_M1_E8 /* 7314 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDSUM_VS_M1_E8_MASK /* 7315 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDSUM_VS_M2_E16 /* 7316 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDSUM_VS_M2_E16_MASK /* 7317 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDSUM_VS_M2_E32 /* 7318 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDSUM_VS_M2_E32_MASK /* 7319 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDSUM_VS_M2_E64 /* 7320 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDSUM_VS_M2_E64_MASK /* 7321 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDSUM_VS_M2_E8 /* 7322 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDSUM_VS_M2_E8_MASK /* 7323 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDSUM_VS_M4_E16 /* 7324 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDSUM_VS_M4_E16_MASK /* 7325 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDSUM_VS_M4_E32 /* 7326 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDSUM_VS_M4_E32_MASK /* 7327 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDSUM_VS_M4_E64 /* 7328 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDSUM_VS_M4_E64_MASK /* 7329 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDSUM_VS_M4_E8 /* 7330 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDSUM_VS_M4_E8_MASK /* 7331 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDSUM_VS_M8_E16 /* 7332 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDSUM_VS_M8_E16_MASK /* 7333 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDSUM_VS_M8_E32 /* 7334 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDSUM_VS_M8_E32_MASK /* 7335 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDSUM_VS_M8_E64 /* 7336 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDSUM_VS_M8_E64_MASK /* 7337 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDSUM_VS_M8_E8 /* 7338 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDSUM_VS_M8_E8_MASK /* 7339 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDSUM_VS_MF2_E16 /* 7340 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDSUM_VS_MF2_E16_MASK /* 7341 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDSUM_VS_MF2_E32 /* 7342 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDSUM_VS_MF2_E32_MASK /* 7343 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDSUM_VS_MF2_E8 /* 7344 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDSUM_VS_MF2_E8_MASK /* 7345 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDSUM_VS_MF4_E16 /* 7346 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDSUM_VS_MF4_E16_MASK /* 7347 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDSUM_VS_MF4_E8 /* 7348 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDSUM_VS_MF4_E8_MASK /* 7349 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDSUM_VS_MF8_E8 /* 7350 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDSUM_VS_MF8_E8_MASK /* 7351 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDXOR_VS_M1_E16 /* 7352 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDXOR_VS_M1_E16_MASK /* 7353 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDXOR_VS_M1_E32 /* 7354 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDXOR_VS_M1_E32_MASK /* 7355 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDXOR_VS_M1_E64 /* 7356 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDXOR_VS_M1_E64_MASK /* 7357 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDXOR_VS_M1_E8 /* 7358 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDXOR_VS_M1_E8_MASK /* 7359 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDXOR_VS_M2_E16 /* 7360 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDXOR_VS_M2_E16_MASK /* 7361 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDXOR_VS_M2_E32 /* 7362 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDXOR_VS_M2_E32_MASK /* 7363 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDXOR_VS_M2_E64 /* 7364 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDXOR_VS_M2_E64_MASK /* 7365 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDXOR_VS_M2_E8 /* 7366 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDXOR_VS_M2_E8_MASK /* 7367 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDXOR_VS_M4_E16 /* 7368 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDXOR_VS_M4_E16_MASK /* 7369 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDXOR_VS_M4_E32 /* 7370 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDXOR_VS_M4_E32_MASK /* 7371 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDXOR_VS_M4_E64 /* 7372 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDXOR_VS_M4_E64_MASK /* 7373 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDXOR_VS_M4_E8 /* 7374 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDXOR_VS_M4_E8_MASK /* 7375 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDXOR_VS_M8_E16 /* 7376 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDXOR_VS_M8_E16_MASK /* 7377 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDXOR_VS_M8_E32 /* 7378 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDXOR_VS_M8_E32_MASK /* 7379 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDXOR_VS_M8_E64 /* 7380 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDXOR_VS_M8_E64_MASK /* 7381 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDXOR_VS_M8_E8 /* 7382 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDXOR_VS_M8_E8_MASK /* 7383 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDXOR_VS_MF2_E16 /* 7384 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDXOR_VS_MF2_E16_MASK /* 7385 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDXOR_VS_MF2_E32 /* 7386 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDXOR_VS_MF2_E32_MASK /* 7387 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDXOR_VS_MF2_E8 /* 7388 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDXOR_VS_MF2_E8_MASK /* 7389 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDXOR_VS_MF4_E16 /* 7390 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDXOR_VS_MF4_E16_MASK /* 7391 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDXOR_VS_MF4_E8 /* 7392 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDXOR_VS_MF4_E8_MASK /* 7393 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDXOR_VS_MF8_E8 /* 7394 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREDXOR_VS_MF8_E8_MASK /* 7395 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRELOAD2_M1 /* 7396 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRELOAD2_M2 /* 7397 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRELOAD2_M4 /* 7398 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRELOAD2_MF2 /* 7399 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRELOAD2_MF4 /* 7400 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRELOAD2_MF8 /* 7401 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRELOAD3_M1 /* 7402 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRELOAD3_M2 /* 7403 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRELOAD3_MF2 /* 7404 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRELOAD3_MF4 /* 7405 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRELOAD3_MF8 /* 7406 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRELOAD4_M1 /* 7407 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRELOAD4_M2 /* 7408 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRELOAD4_MF2 /* 7409 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRELOAD4_MF4 /* 7410 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRELOAD4_MF8 /* 7411 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRELOAD5_M1 /* 7412 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRELOAD5_MF2 /* 7413 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRELOAD5_MF4 /* 7414 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRELOAD5_MF8 /* 7415 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRELOAD6_M1 /* 7416 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRELOAD6_MF2 /* 7417 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRELOAD6_MF4 /* 7418 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRELOAD6_MF8 /* 7419 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRELOAD7_M1 /* 7420 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRELOAD7_MF2 /* 7421 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRELOAD7_MF4 /* 7422 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRELOAD7_MF8 /* 7423 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRELOAD8_M1 /* 7424 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRELOAD8_MF2 /* 7425 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRELOAD8_MF4 /* 7426 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRELOAD8_MF8 /* 7427 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VV_M1_E16 /* 7428 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VV_M1_E16_MASK /* 7429 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VV_M1_E32 /* 7430 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VV_M1_E32_MASK /* 7431 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VV_M1_E64 /* 7432 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VV_M1_E64_MASK /* 7433 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VV_M1_E8 /* 7434 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VV_M1_E8_MASK /* 7435 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VV_M2_E16 /* 7436 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VV_M2_E16_MASK /* 7437 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VV_M2_E32 /* 7438 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VV_M2_E32_MASK /* 7439 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VV_M2_E64 /* 7440 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VV_M2_E64_MASK /* 7441 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VV_M2_E8 /* 7442 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VV_M2_E8_MASK /* 7443 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VV_M4_E16 /* 7444 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VV_M4_E16_MASK /* 7445 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VV_M4_E32 /* 7446 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VV_M4_E32_MASK /* 7447 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VV_M4_E64 /* 7448 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VV_M4_E64_MASK /* 7449 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VV_M4_E8 /* 7450 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VV_M4_E8_MASK /* 7451 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VV_M8_E16 /* 7452 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VV_M8_E16_MASK /* 7453 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VV_M8_E32 /* 7454 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VV_M8_E32_MASK /* 7455 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VV_M8_E64 /* 7456 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VV_M8_E64_MASK /* 7457 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VV_M8_E8 /* 7458 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VV_M8_E8_MASK /* 7459 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VV_MF2_E16 /* 7460 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VV_MF2_E16_MASK /* 7461 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VV_MF2_E32 /* 7462 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VV_MF2_E32_MASK /* 7463 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VV_MF2_E8 /* 7464 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VV_MF2_E8_MASK /* 7465 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VV_MF4_E16 /* 7466 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VV_MF4_E16_MASK /* 7467 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VV_MF4_E8 /* 7468 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VV_MF4_E8_MASK /* 7469 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VV_MF8_E8 /* 7470 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VV_MF8_E8_MASK /* 7471 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VX_M1_E16 /* 7472 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VX_M1_E16_MASK /* 7473 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VX_M1_E32 /* 7474 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VX_M1_E32_MASK /* 7475 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VX_M1_E64 /* 7476 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VX_M1_E64_MASK /* 7477 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VX_M1_E8 /* 7478 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VX_M1_E8_MASK /* 7479 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VX_M2_E16 /* 7480 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VX_M2_E16_MASK /* 7481 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VX_M2_E32 /* 7482 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VX_M2_E32_MASK /* 7483 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VX_M2_E64 /* 7484 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VX_M2_E64_MASK /* 7485 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VX_M2_E8 /* 7486 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VX_M2_E8_MASK /* 7487 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VX_M4_E16 /* 7488 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VX_M4_E16_MASK /* 7489 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VX_M4_E32 /* 7490 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VX_M4_E32_MASK /* 7491 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VX_M4_E64 /* 7492 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VX_M4_E64_MASK /* 7493 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VX_M4_E8 /* 7494 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VX_M4_E8_MASK /* 7495 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VX_M8_E16 /* 7496 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VX_M8_E16_MASK /* 7497 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VX_M8_E32 /* 7498 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VX_M8_E32_MASK /* 7499 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VX_M8_E64 /* 7500 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VX_M8_E64_MASK /* 7501 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VX_M8_E8 /* 7502 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VX_M8_E8_MASK /* 7503 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VX_MF2_E16 /* 7504 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VX_MF2_E16_MASK /* 7505 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VX_MF2_E32 /* 7506 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VX_MF2_E32_MASK /* 7507 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VX_MF2_E8 /* 7508 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VX_MF2_E8_MASK /* 7509 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VX_MF4_E16 /* 7510 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VX_MF4_E16_MASK /* 7511 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VX_MF4_E8 /* 7512 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VX_MF4_E8_MASK /* 7513 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VX_MF8_E8 /* 7514 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREMU_VX_MF8_E8_MASK /* 7515 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VV_M1_E16 /* 7516 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VV_M1_E16_MASK /* 7517 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VV_M1_E32 /* 7518 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VV_M1_E32_MASK /* 7519 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VV_M1_E64 /* 7520 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VV_M1_E64_MASK /* 7521 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VV_M1_E8 /* 7522 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VV_M1_E8_MASK /* 7523 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VV_M2_E16 /* 7524 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VV_M2_E16_MASK /* 7525 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VV_M2_E32 /* 7526 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VV_M2_E32_MASK /* 7527 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VV_M2_E64 /* 7528 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VV_M2_E64_MASK /* 7529 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VV_M2_E8 /* 7530 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VV_M2_E8_MASK /* 7531 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VV_M4_E16 /* 7532 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VV_M4_E16_MASK /* 7533 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VV_M4_E32 /* 7534 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VV_M4_E32_MASK /* 7535 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VV_M4_E64 /* 7536 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VV_M4_E64_MASK /* 7537 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VV_M4_E8 /* 7538 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VV_M4_E8_MASK /* 7539 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VV_M8_E16 /* 7540 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VV_M8_E16_MASK /* 7541 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VV_M8_E32 /* 7542 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VV_M8_E32_MASK /* 7543 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VV_M8_E64 /* 7544 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VV_M8_E64_MASK /* 7545 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VV_M8_E8 /* 7546 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VV_M8_E8_MASK /* 7547 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VV_MF2_E16 /* 7548 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VV_MF2_E16_MASK /* 7549 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VV_MF2_E32 /* 7550 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VV_MF2_E32_MASK /* 7551 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VV_MF2_E8 /* 7552 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VV_MF2_E8_MASK /* 7553 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VV_MF4_E16 /* 7554 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VV_MF4_E16_MASK /* 7555 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VV_MF4_E8 /* 7556 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VV_MF4_E8_MASK /* 7557 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VV_MF8_E8 /* 7558 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VV_MF8_E8_MASK /* 7559 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VX_M1_E16 /* 7560 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VX_M1_E16_MASK /* 7561 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VX_M1_E32 /* 7562 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VX_M1_E32_MASK /* 7563 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VX_M1_E64 /* 7564 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VX_M1_E64_MASK /* 7565 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VX_M1_E8 /* 7566 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VX_M1_E8_MASK /* 7567 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VX_M2_E16 /* 7568 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VX_M2_E16_MASK /* 7569 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VX_M2_E32 /* 7570 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VX_M2_E32_MASK /* 7571 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VX_M2_E64 /* 7572 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VX_M2_E64_MASK /* 7573 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VX_M2_E8 /* 7574 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VX_M2_E8_MASK /* 7575 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VX_M4_E16 /* 7576 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VX_M4_E16_MASK /* 7577 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VX_M4_E32 /* 7578 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VX_M4_E32_MASK /* 7579 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VX_M4_E64 /* 7580 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VX_M4_E64_MASK /* 7581 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VX_M4_E8 /* 7582 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VX_M4_E8_MASK /* 7583 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VX_M8_E16 /* 7584 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VX_M8_E16_MASK /* 7585 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VX_M8_E32 /* 7586 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VX_M8_E32_MASK /* 7587 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VX_M8_E64 /* 7588 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VX_M8_E64_MASK /* 7589 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VX_M8_E8 /* 7590 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VX_M8_E8_MASK /* 7591 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VX_MF2_E16 /* 7592 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VX_MF2_E16_MASK /* 7593 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VX_MF2_E32 /* 7594 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VX_MF2_E32_MASK /* 7595 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VX_MF2_E8 /* 7596 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VX_MF2_E8_MASK /* 7597 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VX_MF4_E16 /* 7598 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VX_MF4_E16_MASK /* 7599 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VX_MF4_E8 /* 7600 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VX_MF4_E8_MASK /* 7601 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VX_MF8_E8 /* 7602 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREM_VX_MF8_E8_MASK /* 7603 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREV8_V_M1 /* 7604 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREV8_V_M1_MASK /* 7605 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREV8_V_M2 /* 7606 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREV8_V_M2_MASK /* 7607 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREV8_V_M4 /* 7608 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREV8_V_M4_MASK /* 7609 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREV8_V_M8 /* 7610 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREV8_V_M8_MASK /* 7611 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREV8_V_MF2 /* 7612 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREV8_V_MF2_MASK /* 7613 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREV8_V_MF4 /* 7614 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREV8_V_MF4_MASK /* 7615 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREV8_V_MF8 /* 7616 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVREV8_V_MF8_MASK /* 7617 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M1_E16_M1 /* 7618 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M1_E16_M1_MASK /* 7619 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M1_E16_M2 /* 7620 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M1_E16_M2_MASK /* 7621 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M1_E16_MF2 /* 7622 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M1_E16_MF2_MASK /* 7623 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M1_E16_MF4 /* 7624 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M1_E16_MF4_MASK /* 7625 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M1_E32_M1 /* 7626 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M1_E32_M1_MASK /* 7627 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M1_E32_M2 /* 7628 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M1_E32_M2_MASK /* 7629 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M1_E32_MF2 /* 7630 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M1_E32_MF2_MASK /* 7631 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M1_E32_MF4 /* 7632 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M1_E32_MF4_MASK /* 7633 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M1_E64_M1 /* 7634 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M1_E64_M1_MASK /* 7635 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M1_E64_M2 /* 7636 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M1_E64_M2_MASK /* 7637 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M1_E64_MF2 /* 7638 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M1_E64_MF2_MASK /* 7639 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M1_E64_MF4 /* 7640 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M1_E64_MF4_MASK /* 7641 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M1_E8_M1 /* 7642 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M1_E8_M1_MASK /* 7643 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M1_E8_M2 /* 7644 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M1_E8_M2_MASK /* 7645 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M1_E8_MF2 /* 7646 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M1_E8_MF2_MASK /* 7647 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M1_E8_MF4 /* 7648 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M1_E8_MF4_MASK /* 7649 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M2_E16_M1 /* 7650 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M2_E16_M1_MASK /* 7651 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M2_E16_M2 /* 7652 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M2_E16_M2_MASK /* 7653 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M2_E16_M4 /* 7654 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M2_E16_M4_MASK /* 7655 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M2_E16_MF2 /* 7656 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M2_E16_MF2_MASK /* 7657 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M2_E32_M1 /* 7658 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M2_E32_M1_MASK /* 7659 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M2_E32_M2 /* 7660 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M2_E32_M2_MASK /* 7661 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M2_E32_M4 /* 7662 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M2_E32_M4_MASK /* 7663 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M2_E32_MF2 /* 7664 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M2_E32_MF2_MASK /* 7665 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M2_E64_M1 /* 7666 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M2_E64_M1_MASK /* 7667 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M2_E64_M2 /* 7668 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M2_E64_M2_MASK /* 7669 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M2_E64_M4 /* 7670 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M2_E64_M4_MASK /* 7671 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M2_E64_MF2 /* 7672 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M2_E64_MF2_MASK /* 7673 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M2_E8_M1 /* 7674 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M2_E8_M1_MASK /* 7675 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M2_E8_M2 /* 7676 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M2_E8_M2_MASK /* 7677 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M2_E8_M4 /* 7678 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M2_E8_M4_MASK /* 7679 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M2_E8_MF2 /* 7680 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M2_E8_MF2_MASK /* 7681 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M4_E16_M1 /* 7682 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M4_E16_M1_MASK /* 7683 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M4_E16_M2 /* 7684 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M4_E16_M2_MASK /* 7685 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M4_E16_M4 /* 7686 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M4_E16_M4_MASK /* 7687 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M4_E16_M8 /* 7688 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M4_E16_M8_MASK /* 7689 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M4_E32_M1 /* 7690 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M4_E32_M1_MASK /* 7691 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M4_E32_M2 /* 7692 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M4_E32_M2_MASK /* 7693 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M4_E32_M4 /* 7694 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M4_E32_M4_MASK /* 7695 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M4_E32_M8 /* 7696 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M4_E32_M8_MASK /* 7697 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M4_E64_M1 /* 7698 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M4_E64_M1_MASK /* 7699 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M4_E64_M2 /* 7700 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M4_E64_M2_MASK /* 7701 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M4_E64_M4 /* 7702 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M4_E64_M4_MASK /* 7703 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M4_E64_M8 /* 7704 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M4_E64_M8_MASK /* 7705 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M4_E8_M1 /* 7706 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M4_E8_M1_MASK /* 7707 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M4_E8_M2 /* 7708 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M4_E8_M2_MASK /* 7709 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M4_E8_M4 /* 7710 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M4_E8_M4_MASK /* 7711 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M4_E8_M8 /* 7712 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M4_E8_M8_MASK /* 7713 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M8_E16_M2 /* 7714 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M8_E16_M2_MASK /* 7715 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M8_E16_M4 /* 7716 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M8_E16_M4_MASK /* 7717 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M8_E16_M8 /* 7718 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M8_E16_M8_MASK /* 7719 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M8_E32_M2 /* 7720 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M8_E32_M2_MASK /* 7721 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M8_E32_M4 /* 7722 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M8_E32_M4_MASK /* 7723 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M8_E32_M8 /* 7724 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M8_E32_M8_MASK /* 7725 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M8_E64_M2 /* 7726 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M8_E64_M2_MASK /* 7727 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M8_E64_M4 /* 7728 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M8_E64_M4_MASK /* 7729 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M8_E64_M8 /* 7730 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M8_E64_M8_MASK /* 7731 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M8_E8_M2 /* 7732 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M8_E8_M2_MASK /* 7733 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M8_E8_M4 /* 7734 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M8_E8_M4_MASK /* 7735 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M8_E8_M8 /* 7736 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_M8_E8_M8_MASK /* 7737 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_MF2_E16_M1 /* 7738 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_MF2_E16_M1_MASK /* 7739 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_MF2_E16_MF2 /* 7740 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_MF2_E16_MF2_MASK /* 7741 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_MF2_E16_MF4 /* 7742 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_MF2_E16_MF4_MASK /* 7743 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_MF2_E16_MF8 /* 7744 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_MF2_E16_MF8_MASK /* 7745 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_MF2_E32_M1 /* 7746 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_MF2_E32_M1_MASK /* 7747 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_MF2_E32_MF2 /* 7748 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_MF2_E32_MF2_MASK /* 7749 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_MF2_E32_MF4 /* 7750 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_MF2_E32_MF4_MASK /* 7751 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_MF2_E32_MF8 /* 7752 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_MF2_E32_MF8_MASK /* 7753 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_MF2_E8_M1 /* 7754 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_MF2_E8_M1_MASK /* 7755 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_MF2_E8_MF2 /* 7756 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_MF2_E8_MF2_MASK /* 7757 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_MF2_E8_MF4 /* 7758 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_MF2_E8_MF4_MASK /* 7759 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_MF2_E8_MF8 /* 7760 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_MF2_E8_MF8_MASK /* 7761 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_MF4_E16_MF2 /* 7762 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_MF4_E16_MF2_MASK /* 7763 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_MF4_E16_MF4 /* 7764 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_MF4_E16_MF4_MASK /* 7765 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_MF4_E16_MF8 /* 7766 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_MF4_E16_MF8_MASK /* 7767 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_MF4_E8_MF2 /* 7768 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_MF4_E8_MF2_MASK /* 7769 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_MF4_E8_MF4 /* 7770 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_MF4_E8_MF4_MASK /* 7771 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_MF4_E8_MF8 /* 7772 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_MF4_E8_MF8_MASK /* 7773 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_MF8_E8_MF4 /* 7774 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_MF8_E8_MF4_MASK /* 7775 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_MF8_E8_MF8 /* 7776 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHEREI16_VV_MF8_E8_MF8_MASK /* 7777 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VI_M1 /* 7778 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VI_M1_MASK /* 7779 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VI_M2 /* 7780 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VI_M2_MASK /* 7781 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VI_M4 /* 7782 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VI_M4_MASK /* 7783 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VI_M8 /* 7784 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VI_M8_MASK /* 7785 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VI_MF2 /* 7786 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VI_MF2_MASK /* 7787 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VI_MF4 /* 7788 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VI_MF4_MASK /* 7789 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VI_MF8 /* 7790 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VI_MF8_MASK /* 7791 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VV_M1_E16 /* 7792 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VV_M1_E16_MASK /* 7793 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VV_M1_E32 /* 7794 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VV_M1_E32_MASK /* 7795 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VV_M1_E64 /* 7796 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VV_M1_E64_MASK /* 7797 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VV_M1_E8 /* 7798 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VV_M1_E8_MASK /* 7799 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VV_M2_E16 /* 7800 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VV_M2_E16_MASK /* 7801 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VV_M2_E32 /* 7802 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VV_M2_E32_MASK /* 7803 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VV_M2_E64 /* 7804 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VV_M2_E64_MASK /* 7805 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VV_M2_E8 /* 7806 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VV_M2_E8_MASK /* 7807 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VV_M4_E16 /* 7808 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VV_M4_E16_MASK /* 7809 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VV_M4_E32 /* 7810 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VV_M4_E32_MASK /* 7811 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VV_M4_E64 /* 7812 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VV_M4_E64_MASK /* 7813 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VV_M4_E8 /* 7814 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VV_M4_E8_MASK /* 7815 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VV_M8_E16 /* 7816 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VV_M8_E16_MASK /* 7817 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VV_M8_E32 /* 7818 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VV_M8_E32_MASK /* 7819 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VV_M8_E64 /* 7820 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VV_M8_E64_MASK /* 7821 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VV_M8_E8 /* 7822 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VV_M8_E8_MASK /* 7823 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VV_MF2_E16 /* 7824 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VV_MF2_E16_MASK /* 7825 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VV_MF2_E32 /* 7826 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VV_MF2_E32_MASK /* 7827 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VV_MF2_E8 /* 7828 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VV_MF2_E8_MASK /* 7829 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VV_MF4_E16 /* 7830 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VV_MF4_E16_MASK /* 7831 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VV_MF4_E8 /* 7832 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VV_MF4_E8_MASK /* 7833 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VV_MF8_E8 /* 7834 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VV_MF8_E8_MASK /* 7835 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VX_M1 /* 7836 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VX_M1_MASK /* 7837 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VX_M2 /* 7838 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VX_M2_MASK /* 7839 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VX_M4 /* 7840 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VX_M4_MASK /* 7841 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VX_M8 /* 7842 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VX_M8_MASK /* 7843 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VX_MF2 /* 7844 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VX_MF2_MASK /* 7845 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VX_MF4 /* 7846 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VX_MF4_MASK /* 7847 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VX_MF8 /* 7848 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRGATHER_VX_MF8_MASK /* 7849 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROL_VV_M1 /* 7850 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROL_VV_M1_MASK /* 7851 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROL_VV_M2 /* 7852 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROL_VV_M2_MASK /* 7853 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROL_VV_M4 /* 7854 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROL_VV_M4_MASK /* 7855 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROL_VV_M8 /* 7856 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROL_VV_M8_MASK /* 7857 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROL_VV_MF2 /* 7858 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROL_VV_MF2_MASK /* 7859 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROL_VV_MF4 /* 7860 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROL_VV_MF4_MASK /* 7861 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROL_VV_MF8 /* 7862 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROL_VV_MF8_MASK /* 7863 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROL_VX_M1 /* 7864 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROL_VX_M1_MASK /* 7865 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROL_VX_M2 /* 7866 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROL_VX_M2_MASK /* 7867 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROL_VX_M4 /* 7868 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROL_VX_M4_MASK /* 7869 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROL_VX_M8 /* 7870 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROL_VX_M8_MASK /* 7871 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROL_VX_MF2 /* 7872 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROL_VX_MF2_MASK /* 7873 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROL_VX_MF4 /* 7874 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROL_VX_MF4_MASK /* 7875 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROL_VX_MF8 /* 7876 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROL_VX_MF8_MASK /* 7877 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROR_VI_M1 /* 7878 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROR_VI_M1_MASK /* 7879 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROR_VI_M2 /* 7880 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROR_VI_M2_MASK /* 7881 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROR_VI_M4 /* 7882 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROR_VI_M4_MASK /* 7883 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROR_VI_M8 /* 7884 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROR_VI_M8_MASK /* 7885 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROR_VI_MF2 /* 7886 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROR_VI_MF2_MASK /* 7887 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROR_VI_MF4 /* 7888 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROR_VI_MF4_MASK /* 7889 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROR_VI_MF8 /* 7890 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROR_VI_MF8_MASK /* 7891 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROR_VV_M1 /* 7892 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROR_VV_M1_MASK /* 7893 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROR_VV_M2 /* 7894 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROR_VV_M2_MASK /* 7895 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROR_VV_M4 /* 7896 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROR_VV_M4_MASK /* 7897 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROR_VV_M8 /* 7898 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROR_VV_M8_MASK /* 7899 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROR_VV_MF2 /* 7900 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROR_VV_MF2_MASK /* 7901 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROR_VV_MF4 /* 7902 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROR_VV_MF4_MASK /* 7903 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROR_VV_MF8 /* 7904 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROR_VV_MF8_MASK /* 7905 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROR_VX_M1 /* 7906 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROR_VX_M1_MASK /* 7907 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROR_VX_M2 /* 7908 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROR_VX_M2_MASK /* 7909 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROR_VX_M4 /* 7910 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROR_VX_M4_MASK /* 7911 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROR_VX_M8 /* 7912 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROR_VX_M8_MASK /* 7913 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROR_VX_MF2 /* 7914 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROR_VX_MF2_MASK /* 7915 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROR_VX_MF4 /* 7916 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROR_VX_MF4_MASK /* 7917 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROR_VX_MF8 /* 7918 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVROR_VX_MF8_MASK /* 7919 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRSUB_VI_M1 /* 7920 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRSUB_VI_M1_MASK /* 7921 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRSUB_VI_M2 /* 7922 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRSUB_VI_M2_MASK /* 7923 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRSUB_VI_M4 /* 7924 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRSUB_VI_M4_MASK /* 7925 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRSUB_VI_M8 /* 7926 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRSUB_VI_M8_MASK /* 7927 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRSUB_VI_MF2 /* 7928 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRSUB_VI_MF2_MASK /* 7929 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRSUB_VI_MF4 /* 7930 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRSUB_VI_MF4_MASK /* 7931 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRSUB_VI_MF8 /* 7932 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRSUB_VI_MF8_MASK /* 7933 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRSUB_VX_M1 /* 7934 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRSUB_VX_M1_MASK /* 7935 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRSUB_VX_M2 /* 7936 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRSUB_VX_M2_MASK /* 7937 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRSUB_VX_M4 /* 7938 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRSUB_VX_M4_MASK /* 7939 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRSUB_VX_M8 /* 7940 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRSUB_VX_M8_MASK /* 7941 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRSUB_VX_MF2 /* 7942 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRSUB_VX_MF2_MASK /* 7943 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRSUB_VX_MF4 /* 7944 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRSUB_VX_MF4_MASK /* 7945 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRSUB_VX_MF8 /* 7946 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVRSUB_VX_MF8_MASK /* 7947 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADDU_VI_M1 /* 7948 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADDU_VI_M1_MASK /* 7949 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADDU_VI_M2 /* 7950 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADDU_VI_M2_MASK /* 7951 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADDU_VI_M4 /* 7952 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADDU_VI_M4_MASK /* 7953 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADDU_VI_M8 /* 7954 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADDU_VI_M8_MASK /* 7955 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADDU_VI_MF2 /* 7956 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADDU_VI_MF2_MASK /* 7957 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADDU_VI_MF4 /* 7958 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADDU_VI_MF4_MASK /* 7959 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADDU_VI_MF8 /* 7960 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADDU_VI_MF8_MASK /* 7961 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADDU_VV_M1 /* 7962 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADDU_VV_M1_MASK /* 7963 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADDU_VV_M2 /* 7964 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADDU_VV_M2_MASK /* 7965 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADDU_VV_M4 /* 7966 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADDU_VV_M4_MASK /* 7967 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADDU_VV_M8 /* 7968 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADDU_VV_M8_MASK /* 7969 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADDU_VV_MF2 /* 7970 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADDU_VV_MF2_MASK /* 7971 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADDU_VV_MF4 /* 7972 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADDU_VV_MF4_MASK /* 7973 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADDU_VV_MF8 /* 7974 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADDU_VV_MF8_MASK /* 7975 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADDU_VX_M1 /* 7976 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADDU_VX_M1_MASK /* 7977 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADDU_VX_M2 /* 7978 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADDU_VX_M2_MASK /* 7979 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADDU_VX_M4 /* 7980 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADDU_VX_M4_MASK /* 7981 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADDU_VX_M8 /* 7982 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADDU_VX_M8_MASK /* 7983 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADDU_VX_MF2 /* 7984 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADDU_VX_MF2_MASK /* 7985 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADDU_VX_MF4 /* 7986 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADDU_VX_MF4_MASK /* 7987 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADDU_VX_MF8 /* 7988 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADDU_VX_MF8_MASK /* 7989 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADD_VI_M1 /* 7990 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADD_VI_M1_MASK /* 7991 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADD_VI_M2 /* 7992 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADD_VI_M2_MASK /* 7993 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADD_VI_M4 /* 7994 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADD_VI_M4_MASK /* 7995 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADD_VI_M8 /* 7996 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADD_VI_M8_MASK /* 7997 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADD_VI_MF2 /* 7998 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADD_VI_MF2_MASK /* 7999 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADD_VI_MF4 /* 8000 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADD_VI_MF4_MASK /* 8001 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADD_VI_MF8 /* 8002 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADD_VI_MF8_MASK /* 8003 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADD_VV_M1 /* 8004 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADD_VV_M1_MASK /* 8005 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADD_VV_M2 /* 8006 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADD_VV_M2_MASK /* 8007 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADD_VV_M4 /* 8008 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADD_VV_M4_MASK /* 8009 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADD_VV_M8 /* 8010 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADD_VV_M8_MASK /* 8011 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADD_VV_MF2 /* 8012 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADD_VV_MF2_MASK /* 8013 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADD_VV_MF4 /* 8014 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADD_VV_MF4_MASK /* 8015 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADD_VV_MF8 /* 8016 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADD_VV_MF8_MASK /* 8017 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADD_VX_M1 /* 8018 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADD_VX_M1_MASK /* 8019 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADD_VX_M2 /* 8020 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADD_VX_M2_MASK /* 8021 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADD_VX_M4 /* 8022 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADD_VX_M4_MASK /* 8023 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADD_VX_M8 /* 8024 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADD_VX_M8_MASK /* 8025 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADD_VX_MF2 /* 8026 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADD_VX_MF2_MASK /* 8027 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADD_VX_MF4 /* 8028 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADD_VX_MF4_MASK /* 8029 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADD_VX_MF8 /* 8030 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSADD_VX_MF8_MASK /* 8031 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSBC_VVM_M1 /* 8032 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSBC_VVM_M2 /* 8033 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSBC_VVM_M4 /* 8034 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSBC_VVM_M8 /* 8035 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSBC_VVM_MF2 /* 8036 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSBC_VVM_MF4 /* 8037 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSBC_VVM_MF8 /* 8038 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSBC_VXM_M1 /* 8039 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSBC_VXM_M2 /* 8040 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSBC_VXM_M4 /* 8041 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSBC_VXM_M8 /* 8042 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSBC_VXM_MF2 /* 8043 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSBC_VXM_MF4 /* 8044 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSBC_VXM_MF8 /* 8045 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSE16_V_M1 /* 8046 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSE16_V_M1_MASK /* 8047 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSE16_V_M2 /* 8048 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSE16_V_M2_MASK /* 8049 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSE16_V_M4 /* 8050 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSE16_V_M4_MASK /* 8051 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSE16_V_M8 /* 8052 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSE16_V_M8_MASK /* 8053 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSE16_V_MF2 /* 8054 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSE16_V_MF2_MASK /* 8055 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSE16_V_MF4 /* 8056 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSE16_V_MF4_MASK /* 8057 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSE32_V_M1 /* 8058 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSE32_V_M1_MASK /* 8059 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSE32_V_M2 /* 8060 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSE32_V_M2_MASK /* 8061 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSE32_V_M4 /* 8062 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSE32_V_M4_MASK /* 8063 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSE32_V_M8 /* 8064 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSE32_V_M8_MASK /* 8065 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSE32_V_MF2 /* 8066 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSE32_V_MF2_MASK /* 8067 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSE64_V_M1 /* 8068 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSE64_V_M1_MASK /* 8069 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSE64_V_M2 /* 8070 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSE64_V_M2_MASK /* 8071 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSE64_V_M4 /* 8072 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSE64_V_M4_MASK /* 8073 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSE64_V_M8 /* 8074 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSE64_V_M8_MASK /* 8075 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSE8_V_M1 /* 8076 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSE8_V_M1_MASK /* 8077 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSE8_V_M2 /* 8078 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSE8_V_M2_MASK /* 8079 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSE8_V_M4 /* 8080 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSE8_V_M4_MASK /* 8081 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSE8_V_M8 /* 8082 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSE8_V_M8_MASK /* 8083 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSE8_V_MF2 /* 8084 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSE8_V_MF2_MASK /* 8085 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSE8_V_MF4 /* 8086 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSE8_V_MF4_MASK /* 8087 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSE8_V_MF8 /* 8088 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSE8_V_MF8_MASK /* 8089 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSETIVLI /* 8090 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSETVLI /* 8091 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSETVLIX0 /* 8092 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSEXT_VF2_M1 /* 8093 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSEXT_VF2_M1_MASK /* 8094 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSEXT_VF2_M2 /* 8095 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSEXT_VF2_M2_MASK /* 8096 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSEXT_VF2_M4 /* 8097 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSEXT_VF2_M4_MASK /* 8098 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSEXT_VF2_M8 /* 8099 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSEXT_VF2_M8_MASK /* 8100 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSEXT_VF2_MF2 /* 8101 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSEXT_VF2_MF2_MASK /* 8102 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSEXT_VF2_MF4 /* 8103 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSEXT_VF2_MF4_MASK /* 8104 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSEXT_VF4_M1 /* 8105 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSEXT_VF4_M1_MASK /* 8106 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSEXT_VF4_M2 /* 8107 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSEXT_VF4_M2_MASK /* 8108 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSEXT_VF4_M4 /* 8109 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSEXT_VF4_M4_MASK /* 8110 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSEXT_VF4_M8 /* 8111 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSEXT_VF4_M8_MASK /* 8112 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSEXT_VF4_MF2 /* 8113 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSEXT_VF4_MF2_MASK /* 8114 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSEXT_VF8_M1 /* 8115 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSEXT_VF8_M1_MASK /* 8116 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSEXT_VF8_M2 /* 8117 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSEXT_VF8_M2_MASK /* 8118 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSEXT_VF8_M4 /* 8119 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSEXT_VF8_M4_MASK /* 8120 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSEXT_VF8_M8 /* 8121 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSEXT_VF8_M8_MASK /* 8122 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSHA2CH_VV_M1 /* 8123 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSHA2CH_VV_M2 /* 8124 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSHA2CH_VV_M4 /* 8125 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSHA2CH_VV_M8 /* 8126 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSHA2CH_VV_MF2 /* 8127 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSHA2CL_VV_M1 /* 8128 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSHA2CL_VV_M2 /* 8129 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSHA2CL_VV_M4 /* 8130 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSHA2CL_VV_M8 /* 8131 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSHA2CL_VV_MF2 /* 8132 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSHA2MS_VV_M1 /* 8133 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSHA2MS_VV_M2 /* 8134 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSHA2MS_VV_M4 /* 8135 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSHA2MS_VV_M8 /* 8136 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSHA2MS_VV_MF2 /* 8137 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDE1DOWN_VX_M1 /* 8138 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDE1DOWN_VX_M1_MASK /* 8139 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDE1DOWN_VX_M2 /* 8140 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDE1DOWN_VX_M2_MASK /* 8141 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDE1DOWN_VX_M4 /* 8142 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDE1DOWN_VX_M4_MASK /* 8143 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDE1DOWN_VX_M8 /* 8144 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDE1DOWN_VX_M8_MASK /* 8145 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDE1DOWN_VX_MF2 /* 8146 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDE1DOWN_VX_MF2_MASK /* 8147 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDE1DOWN_VX_MF4 /* 8148 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDE1DOWN_VX_MF4_MASK /* 8149 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDE1DOWN_VX_MF8 /* 8150 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDE1DOWN_VX_MF8_MASK /* 8151 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDE1UP_VX_M1 /* 8152 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDE1UP_VX_M1_MASK /* 8153 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDE1UP_VX_M2 /* 8154 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDE1UP_VX_M2_MASK /* 8155 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDE1UP_VX_M4 /* 8156 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDE1UP_VX_M4_MASK /* 8157 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDE1UP_VX_M8 /* 8158 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDE1UP_VX_M8_MASK /* 8159 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDE1UP_VX_MF2 /* 8160 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDE1UP_VX_MF2_MASK /* 8161 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDE1UP_VX_MF4 /* 8162 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDE1UP_VX_MF4_MASK /* 8163 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDE1UP_VX_MF8 /* 8164 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDE1UP_VX_MF8_MASK /* 8165 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDEDOWN_VI_M1 /* 8166 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDEDOWN_VI_M1_MASK /* 8167 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDEDOWN_VI_M2 /* 8168 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDEDOWN_VI_M2_MASK /* 8169 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDEDOWN_VI_M4 /* 8170 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDEDOWN_VI_M4_MASK /* 8171 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDEDOWN_VI_M8 /* 8172 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDEDOWN_VI_M8_MASK /* 8173 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDEDOWN_VI_MF2 /* 8174 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDEDOWN_VI_MF2_MASK /* 8175 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDEDOWN_VI_MF4 /* 8176 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDEDOWN_VI_MF4_MASK /* 8177 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDEDOWN_VI_MF8 /* 8178 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDEDOWN_VI_MF8_MASK /* 8179 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDEDOWN_VX_M1 /* 8180 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDEDOWN_VX_M1_MASK /* 8181 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDEDOWN_VX_M2 /* 8182 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDEDOWN_VX_M2_MASK /* 8183 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDEDOWN_VX_M4 /* 8184 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDEDOWN_VX_M4_MASK /* 8185 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDEDOWN_VX_M8 /* 8186 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDEDOWN_VX_M8_MASK /* 8187 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDEDOWN_VX_MF2 /* 8188 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDEDOWN_VX_MF2_MASK /* 8189 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDEDOWN_VX_MF4 /* 8190 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDEDOWN_VX_MF4_MASK /* 8191 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDEDOWN_VX_MF8 /* 8192 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDEDOWN_VX_MF8_MASK /* 8193 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDEUP_VI_M1 /* 8194 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDEUP_VI_M1_MASK /* 8195 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDEUP_VI_M2 /* 8196 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDEUP_VI_M2_MASK /* 8197 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDEUP_VI_M4 /* 8198 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDEUP_VI_M4_MASK /* 8199 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDEUP_VI_M8 /* 8200 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDEUP_VI_M8_MASK /* 8201 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDEUP_VI_MF2 /* 8202 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDEUP_VI_MF2_MASK /* 8203 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDEUP_VI_MF4 /* 8204 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDEUP_VI_MF4_MASK /* 8205 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDEUP_VI_MF8 /* 8206 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDEUP_VI_MF8_MASK /* 8207 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDEUP_VX_M1 /* 8208 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDEUP_VX_M1_MASK /* 8209 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDEUP_VX_M2 /* 8210 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDEUP_VX_M2_MASK /* 8211 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDEUP_VX_M4 /* 8212 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDEUP_VX_M4_MASK /* 8213 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDEUP_VX_M8 /* 8214 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDEUP_VX_M8_MASK /* 8215 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDEUP_VX_MF2 /* 8216 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDEUP_VX_MF2_MASK /* 8217 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDEUP_VX_MF4 /* 8218 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDEUP_VX_MF4_MASK /* 8219 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDEUP_VX_MF8 /* 8220 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLIDEUP_VX_MF8_MASK /* 8221 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLL_VI_M1 /* 8222 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLL_VI_M1_MASK /* 8223 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLL_VI_M2 /* 8224 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLL_VI_M2_MASK /* 8225 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLL_VI_M4 /* 8226 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLL_VI_M4_MASK /* 8227 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLL_VI_M8 /* 8228 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLL_VI_M8_MASK /* 8229 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLL_VI_MF2 /* 8230 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLL_VI_MF2_MASK /* 8231 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLL_VI_MF4 /* 8232 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLL_VI_MF4_MASK /* 8233 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLL_VI_MF8 /* 8234 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLL_VI_MF8_MASK /* 8235 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLL_VV_M1 /* 8236 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLL_VV_M1_MASK /* 8237 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLL_VV_M2 /* 8238 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLL_VV_M2_MASK /* 8239 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLL_VV_M4 /* 8240 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLL_VV_M4_MASK /* 8241 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLL_VV_M8 /* 8242 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLL_VV_M8_MASK /* 8243 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLL_VV_MF2 /* 8244 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLL_VV_MF2_MASK /* 8245 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLL_VV_MF4 /* 8246 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLL_VV_MF4_MASK /* 8247 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLL_VV_MF8 /* 8248 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLL_VV_MF8_MASK /* 8249 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLL_VX_M1 /* 8250 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLL_VX_M1_MASK /* 8251 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLL_VX_M2 /* 8252 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLL_VX_M2_MASK /* 8253 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLL_VX_M4 /* 8254 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLL_VX_M4_MASK /* 8255 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLL_VX_M8 /* 8256 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLL_VX_M8_MASK /* 8257 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLL_VX_MF2 /* 8258 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLL_VX_MF2_MASK /* 8259 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLL_VX_MF4 /* 8260 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLL_VX_MF4_MASK /* 8261 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLL_VX_MF8 /* 8262 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSLL_VX_MF8_MASK /* 8263 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSM3C_VI_M1 /* 8264 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSM3C_VI_M2 /* 8265 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSM3C_VI_M4 /* 8266 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSM3C_VI_M8 /* 8267 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSM3C_VI_MF2 /* 8268 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSM3ME_VV_M1 /* 8269 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSM3ME_VV_M2 /* 8270 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSM3ME_VV_M4 /* 8271 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSM3ME_VV_M8 /* 8272 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSM3ME_VV_MF2 /* 8273 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSM4K_VI_M1 /* 8274 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSM4K_VI_M2 /* 8275 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSM4K_VI_M4 /* 8276 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSM4K_VI_M8 /* 8277 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSM4K_VI_MF2 /* 8278 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSM4R_VS_M1_M1 /* 8279 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSM4R_VS_M1_MF2 /* 8280 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSM4R_VS_M1_MF4 /* 8281 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSM4R_VS_M1_MF8 /* 8282 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSM4R_VS_M2_M1 /* 8283 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSM4R_VS_M2_M2 /* 8284 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSM4R_VS_M2_MF2 /* 8285 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSM4R_VS_M2_MF4 /* 8286 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSM4R_VS_M2_MF8 /* 8287 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSM4R_VS_M4_M1 /* 8288 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSM4R_VS_M4_M2 /* 8289 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSM4R_VS_M4_M4 /* 8290 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSM4R_VS_M4_MF2 /* 8291 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSM4R_VS_M4_MF4 /* 8292 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSM4R_VS_M4_MF8 /* 8293 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSM4R_VS_M8_M1 /* 8294 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSM4R_VS_M8_M2 /* 8295 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSM4R_VS_M8_M4 /* 8296 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSM4R_VS_M8_MF2 /* 8297 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSM4R_VS_M8_MF4 /* 8298 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSM4R_VS_M8_MF8 /* 8299 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSM4R_VS_MF2_MF2 /* 8300 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSM4R_VS_MF2_MF4 /* 8301 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSM4R_VS_MF2_MF8 /* 8302 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSM4R_VV_M1 /* 8303 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSM4R_VV_M2 /* 8304 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSM4R_VV_M4 /* 8305 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSM4R_VV_M8 /* 8306 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSM4R_VV_MF2 /* 8307 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSMUL_VV_M1 /* 8308 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSMUL_VV_M1_MASK /* 8309 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSMUL_VV_M2 /* 8310 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSMUL_VV_M2_MASK /* 8311 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSMUL_VV_M4 /* 8312 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSMUL_VV_M4_MASK /* 8313 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSMUL_VV_M8 /* 8314 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSMUL_VV_M8_MASK /* 8315 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSMUL_VV_MF2 /* 8316 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSMUL_VV_MF2_MASK /* 8317 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSMUL_VV_MF4 /* 8318 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSMUL_VV_MF4_MASK /* 8319 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSMUL_VV_MF8 /* 8320 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSMUL_VV_MF8_MASK /* 8321 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSMUL_VX_M1 /* 8322 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSMUL_VX_M1_MASK /* 8323 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSMUL_VX_M2 /* 8324 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSMUL_VX_M2_MASK /* 8325 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSMUL_VX_M4 /* 8326 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSMUL_VX_M4_MASK /* 8327 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSMUL_VX_M8 /* 8328 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSMUL_VX_M8_MASK /* 8329 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSMUL_VX_MF2 /* 8330 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSMUL_VX_MF2_MASK /* 8331 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSMUL_VX_MF4 /* 8332 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSMUL_VX_MF4_MASK /* 8333 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSMUL_VX_MF8 /* 8334 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSMUL_VX_MF8_MASK /* 8335 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSM_V_B1 /* 8336 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSM_V_B16 /* 8337 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSM_V_B2 /* 8338 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSM_V_B32 /* 8339 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSM_V_B4 /* 8340 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSM_V_B64 /* 8341 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSM_V_B8 /* 8342 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI16_V_M1_M1 /* 8343 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI16_V_M1_M1_MASK /* 8344 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI16_V_M1_M2 /* 8345 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI16_V_M1_M2_MASK /* 8346 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI16_V_M1_M4 /* 8347 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI16_V_M1_M4_MASK /* 8348 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI16_V_M1_MF2 /* 8349 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI16_V_M1_MF2_MASK /* 8350 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI16_V_M2_M1 /* 8351 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI16_V_M2_M1_MASK /* 8352 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI16_V_M2_M2 /* 8353 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI16_V_M2_M2_MASK /* 8354 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI16_V_M2_M4 /* 8355 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI16_V_M2_M4_MASK /* 8356 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI16_V_M2_M8 /* 8357 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI16_V_M2_M8_MASK /* 8358 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI16_V_M4_M2 /* 8359 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI16_V_M4_M2_MASK /* 8360 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI16_V_M4_M4 /* 8361 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI16_V_M4_M4_MASK /* 8362 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI16_V_M4_M8 /* 8363 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI16_V_M4_M8_MASK /* 8364 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI16_V_M8_M4 /* 8365 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI16_V_M8_M4_MASK /* 8366 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI16_V_M8_M8 /* 8367 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI16_V_M8_M8_MASK /* 8368 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI16_V_MF2_M1 /* 8369 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI16_V_MF2_M1_MASK /* 8370 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI16_V_MF2_M2 /* 8371 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI16_V_MF2_M2_MASK /* 8372 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI16_V_MF2_MF2 /* 8373 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI16_V_MF2_MF2_MASK /* 8374 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI16_V_MF2_MF4 /* 8375 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI16_V_MF2_MF4_MASK /* 8376 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI16_V_MF4_M1 /* 8377 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI16_V_MF4_M1_MASK /* 8378 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI16_V_MF4_MF2 /* 8379 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI16_V_MF4_MF2_MASK /* 8380 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI16_V_MF4_MF4 /* 8381 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI16_V_MF4_MF4_MASK /* 8382 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI16_V_MF4_MF8 /* 8383 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI16_V_MF4_MF8_MASK /* 8384 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI32_V_M1_M1 /* 8385 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI32_V_M1_M1_MASK /* 8386 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI32_V_M1_M2 /* 8387 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI32_V_M1_M2_MASK /* 8388 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI32_V_M1_MF2 /* 8389 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI32_V_M1_MF2_MASK /* 8390 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI32_V_M1_MF4 /* 8391 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI32_V_M1_MF4_MASK /* 8392 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI32_V_M2_M1 /* 8393 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI32_V_M2_M1_MASK /* 8394 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI32_V_M2_M2 /* 8395 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI32_V_M2_M2_MASK /* 8396 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI32_V_M2_M4 /* 8397 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI32_V_M2_M4_MASK /* 8398 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI32_V_M2_MF2 /* 8399 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI32_V_M2_MF2_MASK /* 8400 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI32_V_M4_M1 /* 8401 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI32_V_M4_M1_MASK /* 8402 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI32_V_M4_M2 /* 8403 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI32_V_M4_M2_MASK /* 8404 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI32_V_M4_M4 /* 8405 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI32_V_M4_M4_MASK /* 8406 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI32_V_M4_M8 /* 8407 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI32_V_M4_M8_MASK /* 8408 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI32_V_M8_M2 /* 8409 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI32_V_M8_M2_MASK /* 8410 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI32_V_M8_M4 /* 8411 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI32_V_M8_M4_MASK /* 8412 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI32_V_M8_M8 /* 8413 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI32_V_M8_M8_MASK /* 8414 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI32_V_MF2_M1 /* 8415 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI32_V_MF2_M1_MASK /* 8416 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI32_V_MF2_MF2 /* 8417 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI32_V_MF2_MF2_MASK /* 8418 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI32_V_MF2_MF4 /* 8419 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI32_V_MF2_MF4_MASK /* 8420 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI32_V_MF2_MF8 /* 8421 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI32_V_MF2_MF8_MASK /* 8422 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI64_V_M1_M1 /* 8423 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI64_V_M1_M1_MASK /* 8424 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI64_V_M1_MF2 /* 8425 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI64_V_M1_MF2_MASK /* 8426 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI64_V_M1_MF4 /* 8427 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI64_V_M1_MF4_MASK /* 8428 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI64_V_M1_MF8 /* 8429 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI64_V_M1_MF8_MASK /* 8430 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI64_V_M2_M1 /* 8431 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI64_V_M2_M1_MASK /* 8432 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI64_V_M2_M2 /* 8433 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI64_V_M2_M2_MASK /* 8434 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI64_V_M2_MF2 /* 8435 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI64_V_M2_MF2_MASK /* 8436 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI64_V_M2_MF4 /* 8437 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI64_V_M2_MF4_MASK /* 8438 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI64_V_M4_M1 /* 8439 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI64_V_M4_M1_MASK /* 8440 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI64_V_M4_M2 /* 8441 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI64_V_M4_M2_MASK /* 8442 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI64_V_M4_M4 /* 8443 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI64_V_M4_M4_MASK /* 8444 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI64_V_M4_MF2 /* 8445 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI64_V_M4_MF2_MASK /* 8446 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI64_V_M8_M1 /* 8447 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI64_V_M8_M1_MASK /* 8448 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI64_V_M8_M2 /* 8449 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI64_V_M8_M2_MASK /* 8450 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI64_V_M8_M4 /* 8451 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI64_V_M8_M4_MASK /* 8452 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI64_V_M8_M8 /* 8453 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI64_V_M8_M8_MASK /* 8454 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI8_V_M1_M1 /* 8455 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI8_V_M1_M1_MASK /* 8456 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI8_V_M1_M2 /* 8457 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI8_V_M1_M2_MASK /* 8458 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI8_V_M1_M4 /* 8459 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI8_V_M1_M4_MASK /* 8460 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI8_V_M1_M8 /* 8461 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI8_V_M1_M8_MASK /* 8462 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI8_V_M2_M2 /* 8463 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI8_V_M2_M2_MASK /* 8464 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI8_V_M2_M4 /* 8465 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI8_V_M2_M4_MASK /* 8466 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI8_V_M2_M8 /* 8467 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI8_V_M2_M8_MASK /* 8468 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI8_V_M4_M4 /* 8469 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI8_V_M4_M4_MASK /* 8470 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI8_V_M4_M8 /* 8471 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI8_V_M4_M8_MASK /* 8472 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI8_V_M8_M8 /* 8473 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI8_V_M8_M8_MASK /* 8474 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI8_V_MF2_M1 /* 8475 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI8_V_MF2_M1_MASK /* 8476 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI8_V_MF2_M2 /* 8477 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI8_V_MF2_M2_MASK /* 8478 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI8_V_MF2_M4 /* 8479 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI8_V_MF2_M4_MASK /* 8480 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI8_V_MF2_MF2 /* 8481 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI8_V_MF2_MF2_MASK /* 8482 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI8_V_MF4_M1 /* 8483 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI8_V_MF4_M1_MASK /* 8484 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI8_V_MF4_M2 /* 8485 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI8_V_MF4_M2_MASK /* 8486 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI8_V_MF4_MF2 /* 8487 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI8_V_MF4_MF2_MASK /* 8488 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI8_V_MF4_MF4 /* 8489 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI8_V_MF4_MF4_MASK /* 8490 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI8_V_MF8_M1 /* 8491 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI8_V_MF8_M1_MASK /* 8492 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI8_V_MF8_MF2 /* 8493 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI8_V_MF8_MF2_MASK /* 8494 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI8_V_MF8_MF4 /* 8495 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI8_V_MF8_MF4_MASK /* 8496 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI8_V_MF8_MF8 /* 8497 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXEI8_V_MF8_MF8_MASK /* 8498 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI16_V_M1_M1 /* 8499 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI16_V_M1_M1_MASK /* 8500 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI16_V_M1_M2 /* 8501 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI16_V_M1_M2_MASK /* 8502 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI16_V_M1_M4 /* 8503 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI16_V_M1_M4_MASK /* 8504 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI16_V_M1_MF2 /* 8505 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI16_V_M1_MF2_MASK /* 8506 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI16_V_M2_M1 /* 8507 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI16_V_M2_M1_MASK /* 8508 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI16_V_M2_M2 /* 8509 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI16_V_M2_M2_MASK /* 8510 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI16_V_M2_M4 /* 8511 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI16_V_M2_M4_MASK /* 8512 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI16_V_M4_M2 /* 8513 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI16_V_M4_M2_MASK /* 8514 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI16_V_M4_M4 /* 8515 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI16_V_M4_M4_MASK /* 8516 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI16_V_M8_M4 /* 8517 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI16_V_M8_M4_MASK /* 8518 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI16_V_MF2_M1 /* 8519 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI16_V_MF2_M1_MASK /* 8520 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI16_V_MF2_M2 /* 8521 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI16_V_MF2_M2_MASK /* 8522 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI16_V_MF2_MF2 /* 8523 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI16_V_MF2_MF2_MASK /* 8524 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI16_V_MF2_MF4 /* 8525 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI16_V_MF2_MF4_MASK /* 8526 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI16_V_MF4_M1 /* 8527 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI16_V_MF4_M1_MASK /* 8528 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI16_V_MF4_MF2 /* 8529 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI16_V_MF4_MF2_MASK /* 8530 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI16_V_MF4_MF4 /* 8531 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI16_V_MF4_MF4_MASK /* 8532 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI16_V_MF4_MF8 /* 8533 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI16_V_MF4_MF8_MASK /* 8534 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI32_V_M1_M1 /* 8535 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI32_V_M1_M1_MASK /* 8536 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI32_V_M1_M2 /* 8537 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI32_V_M1_M2_MASK /* 8538 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI32_V_M1_MF2 /* 8539 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI32_V_M1_MF2_MASK /* 8540 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI32_V_M1_MF4 /* 8541 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI32_V_M1_MF4_MASK /* 8542 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI32_V_M2_M1 /* 8543 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI32_V_M2_M1_MASK /* 8544 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI32_V_M2_M2 /* 8545 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI32_V_M2_M2_MASK /* 8546 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI32_V_M2_M4 /* 8547 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI32_V_M2_M4_MASK /* 8548 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI32_V_M2_MF2 /* 8549 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI32_V_M2_MF2_MASK /* 8550 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI32_V_M4_M1 /* 8551 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI32_V_M4_M1_MASK /* 8552 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI32_V_M4_M2 /* 8553 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI32_V_M4_M2_MASK /* 8554 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI32_V_M4_M4 /* 8555 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI32_V_M4_M4_MASK /* 8556 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI32_V_M8_M2 /* 8557 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI32_V_M8_M2_MASK /* 8558 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI32_V_M8_M4 /* 8559 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI32_V_M8_M4_MASK /* 8560 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI32_V_MF2_M1 /* 8561 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI32_V_MF2_M1_MASK /* 8562 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI32_V_MF2_MF2 /* 8563 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI32_V_MF2_MF2_MASK /* 8564 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI32_V_MF2_MF4 /* 8565 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI32_V_MF2_MF4_MASK /* 8566 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI32_V_MF2_MF8 /* 8567 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI32_V_MF2_MF8_MASK /* 8568 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI64_V_M1_M1 /* 8569 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI64_V_M1_M1_MASK /* 8570 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI64_V_M1_MF2 /* 8571 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI64_V_M1_MF2_MASK /* 8572 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI64_V_M1_MF4 /* 8573 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI64_V_M1_MF4_MASK /* 8574 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI64_V_M1_MF8 /* 8575 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI64_V_M1_MF8_MASK /* 8576 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI64_V_M2_M1 /* 8577 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI64_V_M2_M1_MASK /* 8578 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI64_V_M2_M2 /* 8579 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI64_V_M2_M2_MASK /* 8580 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI64_V_M2_MF2 /* 8581 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI64_V_M2_MF2_MASK /* 8582 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI64_V_M2_MF4 /* 8583 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI64_V_M2_MF4_MASK /* 8584 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI64_V_M4_M1 /* 8585 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI64_V_M4_M1_MASK /* 8586 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI64_V_M4_M2 /* 8587 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI64_V_M4_M2_MASK /* 8588 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI64_V_M4_M4 /* 8589 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI64_V_M4_M4_MASK /* 8590 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI64_V_M4_MF2 /* 8591 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI64_V_M4_MF2_MASK /* 8592 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI64_V_M8_M1 /* 8593 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI64_V_M8_M1_MASK /* 8594 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI64_V_M8_M2 /* 8595 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI64_V_M8_M2_MASK /* 8596 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI64_V_M8_M4 /* 8597 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI64_V_M8_M4_MASK /* 8598 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI8_V_M1_M1 /* 8599 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI8_V_M1_M1_MASK /* 8600 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI8_V_M1_M2 /* 8601 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI8_V_M1_M2_MASK /* 8602 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI8_V_M1_M4 /* 8603 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI8_V_M1_M4_MASK /* 8604 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI8_V_M2_M2 /* 8605 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI8_V_M2_M2_MASK /* 8606 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI8_V_M2_M4 /* 8607 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI8_V_M2_M4_MASK /* 8608 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI8_V_M4_M4 /* 8609 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI8_V_M4_M4_MASK /* 8610 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI8_V_MF2_M1 /* 8611 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI8_V_MF2_M1_MASK /* 8612 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI8_V_MF2_M2 /* 8613 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI8_V_MF2_M2_MASK /* 8614 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI8_V_MF2_M4 /* 8615 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI8_V_MF2_M4_MASK /* 8616 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI8_V_MF2_MF2 /* 8617 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI8_V_MF2_MF2_MASK /* 8618 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI8_V_MF4_M1 /* 8619 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI8_V_MF4_M1_MASK /* 8620 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI8_V_MF4_M2 /* 8621 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI8_V_MF4_M2_MASK /* 8622 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI8_V_MF4_MF2 /* 8623 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI8_V_MF4_MF2_MASK /* 8624 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI8_V_MF4_MF4 /* 8625 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI8_V_MF4_MF4_MASK /* 8626 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI8_V_MF8_M1 /* 8627 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI8_V_MF8_M1_MASK /* 8628 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI8_V_MF8_MF2 /* 8629 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI8_V_MF8_MF2_MASK /* 8630 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI8_V_MF8_MF4 /* 8631 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI8_V_MF8_MF4_MASK /* 8632 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI8_V_MF8_MF8 /* 8633 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG2EI8_V_MF8_MF8_MASK /* 8634 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI16_V_M1_M1 /* 8635 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI16_V_M1_M1_MASK /* 8636 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI16_V_M1_M2 /* 8637 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI16_V_M1_M2_MASK /* 8638 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI16_V_M1_MF2 /* 8639 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI16_V_M1_MF2_MASK /* 8640 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI16_V_M2_M1 /* 8641 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI16_V_M2_M1_MASK /* 8642 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI16_V_M2_M2 /* 8643 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI16_V_M2_M2_MASK /* 8644 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI16_V_M4_M2 /* 8645 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI16_V_M4_M2_MASK /* 8646 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI16_V_MF2_M1 /* 8647 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI16_V_MF2_M1_MASK /* 8648 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI16_V_MF2_M2 /* 8649 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI16_V_MF2_M2_MASK /* 8650 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI16_V_MF2_MF2 /* 8651 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI16_V_MF2_MF2_MASK /* 8652 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI16_V_MF2_MF4 /* 8653 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI16_V_MF2_MF4_MASK /* 8654 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI16_V_MF4_M1 /* 8655 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI16_V_MF4_M1_MASK /* 8656 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI16_V_MF4_MF2 /* 8657 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI16_V_MF4_MF2_MASK /* 8658 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI16_V_MF4_MF4 /* 8659 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI16_V_MF4_MF4_MASK /* 8660 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI16_V_MF4_MF8 /* 8661 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI16_V_MF4_MF8_MASK /* 8662 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI32_V_M1_M1 /* 8663 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI32_V_M1_M1_MASK /* 8664 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI32_V_M1_M2 /* 8665 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI32_V_M1_M2_MASK /* 8666 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI32_V_M1_MF2 /* 8667 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI32_V_M1_MF2_MASK /* 8668 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI32_V_M1_MF4 /* 8669 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI32_V_M1_MF4_MASK /* 8670 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI32_V_M2_M1 /* 8671 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI32_V_M2_M1_MASK /* 8672 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI32_V_M2_M2 /* 8673 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI32_V_M2_M2_MASK /* 8674 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI32_V_M2_MF2 /* 8675 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI32_V_M2_MF2_MASK /* 8676 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI32_V_M4_M1 /* 8677 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI32_V_M4_M1_MASK /* 8678 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI32_V_M4_M2 /* 8679 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI32_V_M4_M2_MASK /* 8680 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI32_V_M8_M2 /* 8681 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI32_V_M8_M2_MASK /* 8682 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI32_V_MF2_M1 /* 8683 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI32_V_MF2_M1_MASK /* 8684 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI32_V_MF2_MF2 /* 8685 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI32_V_MF2_MF2_MASK /* 8686 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI32_V_MF2_MF4 /* 8687 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI32_V_MF2_MF4_MASK /* 8688 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI32_V_MF2_MF8 /* 8689 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI32_V_MF2_MF8_MASK /* 8690 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI64_V_M1_M1 /* 8691 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI64_V_M1_M1_MASK /* 8692 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI64_V_M1_MF2 /* 8693 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI64_V_M1_MF2_MASK /* 8694 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI64_V_M1_MF4 /* 8695 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI64_V_M1_MF4_MASK /* 8696 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI64_V_M1_MF8 /* 8697 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI64_V_M1_MF8_MASK /* 8698 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI64_V_M2_M1 /* 8699 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI64_V_M2_M1_MASK /* 8700 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI64_V_M2_M2 /* 8701 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI64_V_M2_M2_MASK /* 8702 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI64_V_M2_MF2 /* 8703 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI64_V_M2_MF2_MASK /* 8704 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI64_V_M2_MF4 /* 8705 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI64_V_M2_MF4_MASK /* 8706 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI64_V_M4_M1 /* 8707 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI64_V_M4_M1_MASK /* 8708 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI64_V_M4_M2 /* 8709 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI64_V_M4_M2_MASK /* 8710 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI64_V_M4_MF2 /* 8711 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI64_V_M4_MF2_MASK /* 8712 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI64_V_M8_M1 /* 8713 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI64_V_M8_M1_MASK /* 8714 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI64_V_M8_M2 /* 8715 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI64_V_M8_M2_MASK /* 8716 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI8_V_M1_M1 /* 8717 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI8_V_M1_M1_MASK /* 8718 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI8_V_M1_M2 /* 8719 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI8_V_M1_M2_MASK /* 8720 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI8_V_M2_M2 /* 8721 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI8_V_M2_M2_MASK /* 8722 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI8_V_MF2_M1 /* 8723 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI8_V_MF2_M1_MASK /* 8724 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI8_V_MF2_M2 /* 8725 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI8_V_MF2_M2_MASK /* 8726 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI8_V_MF2_MF2 /* 8727 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI8_V_MF2_MF2_MASK /* 8728 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI8_V_MF4_M1 /* 8729 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI8_V_MF4_M1_MASK /* 8730 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI8_V_MF4_M2 /* 8731 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI8_V_MF4_M2_MASK /* 8732 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI8_V_MF4_MF2 /* 8733 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI8_V_MF4_MF2_MASK /* 8734 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI8_V_MF4_MF4 /* 8735 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI8_V_MF4_MF4_MASK /* 8736 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI8_V_MF8_M1 /* 8737 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI8_V_MF8_M1_MASK /* 8738 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI8_V_MF8_MF2 /* 8739 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI8_V_MF8_MF2_MASK /* 8740 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI8_V_MF8_MF4 /* 8741 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI8_V_MF8_MF4_MASK /* 8742 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI8_V_MF8_MF8 /* 8743 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG3EI8_V_MF8_MF8_MASK /* 8744 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI16_V_M1_M1 /* 8745 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI16_V_M1_M1_MASK /* 8746 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI16_V_M1_M2 /* 8747 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI16_V_M1_M2_MASK /* 8748 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI16_V_M1_MF2 /* 8749 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI16_V_M1_MF2_MASK /* 8750 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI16_V_M2_M1 /* 8751 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI16_V_M2_M1_MASK /* 8752 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI16_V_M2_M2 /* 8753 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI16_V_M2_M2_MASK /* 8754 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI16_V_M4_M2 /* 8755 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI16_V_M4_M2_MASK /* 8756 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI16_V_MF2_M1 /* 8757 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI16_V_MF2_M1_MASK /* 8758 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI16_V_MF2_M2 /* 8759 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI16_V_MF2_M2_MASK /* 8760 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI16_V_MF2_MF2 /* 8761 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI16_V_MF2_MF2_MASK /* 8762 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI16_V_MF2_MF4 /* 8763 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI16_V_MF2_MF4_MASK /* 8764 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI16_V_MF4_M1 /* 8765 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI16_V_MF4_M1_MASK /* 8766 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI16_V_MF4_MF2 /* 8767 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI16_V_MF4_MF2_MASK /* 8768 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI16_V_MF4_MF4 /* 8769 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI16_V_MF4_MF4_MASK /* 8770 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI16_V_MF4_MF8 /* 8771 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI16_V_MF4_MF8_MASK /* 8772 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI32_V_M1_M1 /* 8773 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI32_V_M1_M1_MASK /* 8774 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI32_V_M1_M2 /* 8775 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI32_V_M1_M2_MASK /* 8776 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI32_V_M1_MF2 /* 8777 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI32_V_M1_MF2_MASK /* 8778 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI32_V_M1_MF4 /* 8779 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI32_V_M1_MF4_MASK /* 8780 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI32_V_M2_M1 /* 8781 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI32_V_M2_M1_MASK /* 8782 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI32_V_M2_M2 /* 8783 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI32_V_M2_M2_MASK /* 8784 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI32_V_M2_MF2 /* 8785 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI32_V_M2_MF2_MASK /* 8786 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI32_V_M4_M1 /* 8787 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI32_V_M4_M1_MASK /* 8788 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI32_V_M4_M2 /* 8789 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI32_V_M4_M2_MASK /* 8790 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI32_V_M8_M2 /* 8791 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI32_V_M8_M2_MASK /* 8792 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI32_V_MF2_M1 /* 8793 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI32_V_MF2_M1_MASK /* 8794 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI32_V_MF2_MF2 /* 8795 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI32_V_MF2_MF2_MASK /* 8796 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI32_V_MF2_MF4 /* 8797 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI32_V_MF2_MF4_MASK /* 8798 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI32_V_MF2_MF8 /* 8799 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI32_V_MF2_MF8_MASK /* 8800 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI64_V_M1_M1 /* 8801 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI64_V_M1_M1_MASK /* 8802 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI64_V_M1_MF2 /* 8803 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI64_V_M1_MF2_MASK /* 8804 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI64_V_M1_MF4 /* 8805 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI64_V_M1_MF4_MASK /* 8806 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI64_V_M1_MF8 /* 8807 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI64_V_M1_MF8_MASK /* 8808 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI64_V_M2_M1 /* 8809 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI64_V_M2_M1_MASK /* 8810 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI64_V_M2_M2 /* 8811 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI64_V_M2_M2_MASK /* 8812 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI64_V_M2_MF2 /* 8813 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI64_V_M2_MF2_MASK /* 8814 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI64_V_M2_MF4 /* 8815 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI64_V_M2_MF4_MASK /* 8816 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI64_V_M4_M1 /* 8817 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI64_V_M4_M1_MASK /* 8818 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI64_V_M4_M2 /* 8819 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI64_V_M4_M2_MASK /* 8820 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI64_V_M4_MF2 /* 8821 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI64_V_M4_MF2_MASK /* 8822 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI64_V_M8_M1 /* 8823 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI64_V_M8_M1_MASK /* 8824 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI64_V_M8_M2 /* 8825 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI64_V_M8_M2_MASK /* 8826 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI8_V_M1_M1 /* 8827 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI8_V_M1_M1_MASK /* 8828 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI8_V_M1_M2 /* 8829 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI8_V_M1_M2_MASK /* 8830 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI8_V_M2_M2 /* 8831 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI8_V_M2_M2_MASK /* 8832 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI8_V_MF2_M1 /* 8833 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI8_V_MF2_M1_MASK /* 8834 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI8_V_MF2_M2 /* 8835 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI8_V_MF2_M2_MASK /* 8836 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI8_V_MF2_MF2 /* 8837 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI8_V_MF2_MF2_MASK /* 8838 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI8_V_MF4_M1 /* 8839 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI8_V_MF4_M1_MASK /* 8840 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI8_V_MF4_M2 /* 8841 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI8_V_MF4_M2_MASK /* 8842 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI8_V_MF4_MF2 /* 8843 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI8_V_MF4_MF2_MASK /* 8844 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI8_V_MF4_MF4 /* 8845 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI8_V_MF4_MF4_MASK /* 8846 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI8_V_MF8_M1 /* 8847 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI8_V_MF8_M1_MASK /* 8848 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI8_V_MF8_MF2 /* 8849 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI8_V_MF8_MF2_MASK /* 8850 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI8_V_MF8_MF4 /* 8851 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI8_V_MF8_MF4_MASK /* 8852 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI8_V_MF8_MF8 /* 8853 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG4EI8_V_MF8_MF8_MASK /* 8854 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI16_V_M1_M1 /* 8855 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI16_V_M1_M1_MASK /* 8856 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI16_V_M1_MF2 /* 8857 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI16_V_M1_MF2_MASK /* 8858 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI16_V_M2_M1 /* 8859 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI16_V_M2_M1_MASK /* 8860 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI16_V_MF2_M1 /* 8861 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI16_V_MF2_M1_MASK /* 8862 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI16_V_MF2_MF2 /* 8863 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI16_V_MF2_MF2_MASK /* 8864 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI16_V_MF2_MF4 /* 8865 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI16_V_MF2_MF4_MASK /* 8866 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI16_V_MF4_M1 /* 8867 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI16_V_MF4_M1_MASK /* 8868 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI16_V_MF4_MF2 /* 8869 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI16_V_MF4_MF2_MASK /* 8870 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI16_V_MF4_MF4 /* 8871 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI16_V_MF4_MF4_MASK /* 8872 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI16_V_MF4_MF8 /* 8873 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI16_V_MF4_MF8_MASK /* 8874 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI32_V_M1_M1 /* 8875 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI32_V_M1_M1_MASK /* 8876 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI32_V_M1_MF2 /* 8877 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI32_V_M1_MF2_MASK /* 8878 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI32_V_M1_MF4 /* 8879 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI32_V_M1_MF4_MASK /* 8880 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI32_V_M2_M1 /* 8881 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI32_V_M2_M1_MASK /* 8882 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI32_V_M2_MF2 /* 8883 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI32_V_M2_MF2_MASK /* 8884 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI32_V_M4_M1 /* 8885 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI32_V_M4_M1_MASK /* 8886 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI32_V_MF2_M1 /* 8887 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI32_V_MF2_M1_MASK /* 8888 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI32_V_MF2_MF2 /* 8889 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI32_V_MF2_MF2_MASK /* 8890 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI32_V_MF2_MF4 /* 8891 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI32_V_MF2_MF4_MASK /* 8892 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI32_V_MF2_MF8 /* 8893 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI32_V_MF2_MF8_MASK /* 8894 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI64_V_M1_M1 /* 8895 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI64_V_M1_M1_MASK /* 8896 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI64_V_M1_MF2 /* 8897 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI64_V_M1_MF2_MASK /* 8898 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI64_V_M1_MF4 /* 8899 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI64_V_M1_MF4_MASK /* 8900 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI64_V_M1_MF8 /* 8901 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI64_V_M1_MF8_MASK /* 8902 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI64_V_M2_M1 /* 8903 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI64_V_M2_M1_MASK /* 8904 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI64_V_M2_MF2 /* 8905 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI64_V_M2_MF2_MASK /* 8906 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI64_V_M2_MF4 /* 8907 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI64_V_M2_MF4_MASK /* 8908 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI64_V_M4_M1 /* 8909 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI64_V_M4_M1_MASK /* 8910 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI64_V_M4_MF2 /* 8911 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI64_V_M4_MF2_MASK /* 8912 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI64_V_M8_M1 /* 8913 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI64_V_M8_M1_MASK /* 8914 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI8_V_M1_M1 /* 8915 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI8_V_M1_M1_MASK /* 8916 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI8_V_MF2_M1 /* 8917 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI8_V_MF2_M1_MASK /* 8918 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI8_V_MF2_MF2 /* 8919 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI8_V_MF2_MF2_MASK /* 8920 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI8_V_MF4_M1 /* 8921 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI8_V_MF4_M1_MASK /* 8922 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI8_V_MF4_MF2 /* 8923 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI8_V_MF4_MF2_MASK /* 8924 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI8_V_MF4_MF4 /* 8925 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI8_V_MF4_MF4_MASK /* 8926 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI8_V_MF8_M1 /* 8927 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI8_V_MF8_M1_MASK /* 8928 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI8_V_MF8_MF2 /* 8929 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI8_V_MF8_MF2_MASK /* 8930 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI8_V_MF8_MF4 /* 8931 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI8_V_MF8_MF4_MASK /* 8932 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI8_V_MF8_MF8 /* 8933 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG5EI8_V_MF8_MF8_MASK /* 8934 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI16_V_M1_M1 /* 8935 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI16_V_M1_M1_MASK /* 8936 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI16_V_M1_MF2 /* 8937 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI16_V_M1_MF2_MASK /* 8938 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI16_V_M2_M1 /* 8939 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI16_V_M2_M1_MASK /* 8940 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI16_V_MF2_M1 /* 8941 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI16_V_MF2_M1_MASK /* 8942 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI16_V_MF2_MF2 /* 8943 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI16_V_MF2_MF2_MASK /* 8944 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI16_V_MF2_MF4 /* 8945 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI16_V_MF2_MF4_MASK /* 8946 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI16_V_MF4_M1 /* 8947 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI16_V_MF4_M1_MASK /* 8948 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI16_V_MF4_MF2 /* 8949 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI16_V_MF4_MF2_MASK /* 8950 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI16_V_MF4_MF4 /* 8951 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI16_V_MF4_MF4_MASK /* 8952 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI16_V_MF4_MF8 /* 8953 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI16_V_MF4_MF8_MASK /* 8954 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI32_V_M1_M1 /* 8955 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI32_V_M1_M1_MASK /* 8956 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI32_V_M1_MF2 /* 8957 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI32_V_M1_MF2_MASK /* 8958 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI32_V_M1_MF4 /* 8959 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI32_V_M1_MF4_MASK /* 8960 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI32_V_M2_M1 /* 8961 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI32_V_M2_M1_MASK /* 8962 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI32_V_M2_MF2 /* 8963 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI32_V_M2_MF2_MASK /* 8964 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI32_V_M4_M1 /* 8965 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI32_V_M4_M1_MASK /* 8966 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI32_V_MF2_M1 /* 8967 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI32_V_MF2_M1_MASK /* 8968 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI32_V_MF2_MF2 /* 8969 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI32_V_MF2_MF2_MASK /* 8970 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI32_V_MF2_MF4 /* 8971 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI32_V_MF2_MF4_MASK /* 8972 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI32_V_MF2_MF8 /* 8973 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI32_V_MF2_MF8_MASK /* 8974 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI64_V_M1_M1 /* 8975 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI64_V_M1_M1_MASK /* 8976 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI64_V_M1_MF2 /* 8977 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI64_V_M1_MF2_MASK /* 8978 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI64_V_M1_MF4 /* 8979 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI64_V_M1_MF4_MASK /* 8980 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI64_V_M1_MF8 /* 8981 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI64_V_M1_MF8_MASK /* 8982 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI64_V_M2_M1 /* 8983 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI64_V_M2_M1_MASK /* 8984 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI64_V_M2_MF2 /* 8985 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI64_V_M2_MF2_MASK /* 8986 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI64_V_M2_MF4 /* 8987 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI64_V_M2_MF4_MASK /* 8988 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI64_V_M4_M1 /* 8989 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI64_V_M4_M1_MASK /* 8990 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI64_V_M4_MF2 /* 8991 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI64_V_M4_MF2_MASK /* 8992 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI64_V_M8_M1 /* 8993 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI64_V_M8_M1_MASK /* 8994 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI8_V_M1_M1 /* 8995 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI8_V_M1_M1_MASK /* 8996 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI8_V_MF2_M1 /* 8997 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI8_V_MF2_M1_MASK /* 8998 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI8_V_MF2_MF2 /* 8999 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI8_V_MF2_MF2_MASK /* 9000 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI8_V_MF4_M1 /* 9001 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI8_V_MF4_M1_MASK /* 9002 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI8_V_MF4_MF2 /* 9003 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI8_V_MF4_MF2_MASK /* 9004 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI8_V_MF4_MF4 /* 9005 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI8_V_MF4_MF4_MASK /* 9006 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI8_V_MF8_M1 /* 9007 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI8_V_MF8_M1_MASK /* 9008 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI8_V_MF8_MF2 /* 9009 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI8_V_MF8_MF2_MASK /* 9010 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI8_V_MF8_MF4 /* 9011 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI8_V_MF8_MF4_MASK /* 9012 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI8_V_MF8_MF8 /* 9013 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG6EI8_V_MF8_MF8_MASK /* 9014 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI16_V_M1_M1 /* 9015 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI16_V_M1_M1_MASK /* 9016 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI16_V_M1_MF2 /* 9017 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI16_V_M1_MF2_MASK /* 9018 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI16_V_M2_M1 /* 9019 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI16_V_M2_M1_MASK /* 9020 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI16_V_MF2_M1 /* 9021 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI16_V_MF2_M1_MASK /* 9022 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI16_V_MF2_MF2 /* 9023 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI16_V_MF2_MF2_MASK /* 9024 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI16_V_MF2_MF4 /* 9025 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI16_V_MF2_MF4_MASK /* 9026 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI16_V_MF4_M1 /* 9027 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI16_V_MF4_M1_MASK /* 9028 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI16_V_MF4_MF2 /* 9029 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI16_V_MF4_MF2_MASK /* 9030 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI16_V_MF4_MF4 /* 9031 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI16_V_MF4_MF4_MASK /* 9032 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI16_V_MF4_MF8 /* 9033 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI16_V_MF4_MF8_MASK /* 9034 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI32_V_M1_M1 /* 9035 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI32_V_M1_M1_MASK /* 9036 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI32_V_M1_MF2 /* 9037 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI32_V_M1_MF2_MASK /* 9038 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI32_V_M1_MF4 /* 9039 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI32_V_M1_MF4_MASK /* 9040 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI32_V_M2_M1 /* 9041 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI32_V_M2_M1_MASK /* 9042 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI32_V_M2_MF2 /* 9043 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI32_V_M2_MF2_MASK /* 9044 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI32_V_M4_M1 /* 9045 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI32_V_M4_M1_MASK /* 9046 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI32_V_MF2_M1 /* 9047 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI32_V_MF2_M1_MASK /* 9048 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI32_V_MF2_MF2 /* 9049 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI32_V_MF2_MF2_MASK /* 9050 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI32_V_MF2_MF4 /* 9051 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI32_V_MF2_MF4_MASK /* 9052 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI32_V_MF2_MF8 /* 9053 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI32_V_MF2_MF8_MASK /* 9054 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI64_V_M1_M1 /* 9055 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI64_V_M1_M1_MASK /* 9056 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI64_V_M1_MF2 /* 9057 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI64_V_M1_MF2_MASK /* 9058 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI64_V_M1_MF4 /* 9059 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI64_V_M1_MF4_MASK /* 9060 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI64_V_M1_MF8 /* 9061 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI64_V_M1_MF8_MASK /* 9062 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI64_V_M2_M1 /* 9063 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI64_V_M2_M1_MASK /* 9064 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI64_V_M2_MF2 /* 9065 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI64_V_M2_MF2_MASK /* 9066 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI64_V_M2_MF4 /* 9067 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI64_V_M2_MF4_MASK /* 9068 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI64_V_M4_M1 /* 9069 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI64_V_M4_M1_MASK /* 9070 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI64_V_M4_MF2 /* 9071 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI64_V_M4_MF2_MASK /* 9072 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI64_V_M8_M1 /* 9073 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI64_V_M8_M1_MASK /* 9074 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI8_V_M1_M1 /* 9075 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI8_V_M1_M1_MASK /* 9076 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI8_V_MF2_M1 /* 9077 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI8_V_MF2_M1_MASK /* 9078 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI8_V_MF2_MF2 /* 9079 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI8_V_MF2_MF2_MASK /* 9080 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI8_V_MF4_M1 /* 9081 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI8_V_MF4_M1_MASK /* 9082 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI8_V_MF4_MF2 /* 9083 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI8_V_MF4_MF2_MASK /* 9084 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI8_V_MF4_MF4 /* 9085 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI8_V_MF4_MF4_MASK /* 9086 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI8_V_MF8_M1 /* 9087 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI8_V_MF8_M1_MASK /* 9088 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI8_V_MF8_MF2 /* 9089 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI8_V_MF8_MF2_MASK /* 9090 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI8_V_MF8_MF4 /* 9091 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI8_V_MF8_MF4_MASK /* 9092 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI8_V_MF8_MF8 /* 9093 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG7EI8_V_MF8_MF8_MASK /* 9094 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI16_V_M1_M1 /* 9095 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI16_V_M1_M1_MASK /* 9096 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI16_V_M1_MF2 /* 9097 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI16_V_M1_MF2_MASK /* 9098 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI16_V_M2_M1 /* 9099 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI16_V_M2_M1_MASK /* 9100 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI16_V_MF2_M1 /* 9101 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI16_V_MF2_M1_MASK /* 9102 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI16_V_MF2_MF2 /* 9103 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI16_V_MF2_MF2_MASK /* 9104 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI16_V_MF2_MF4 /* 9105 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI16_V_MF2_MF4_MASK /* 9106 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI16_V_MF4_M1 /* 9107 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI16_V_MF4_M1_MASK /* 9108 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI16_V_MF4_MF2 /* 9109 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI16_V_MF4_MF2_MASK /* 9110 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI16_V_MF4_MF4 /* 9111 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI16_V_MF4_MF4_MASK /* 9112 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI16_V_MF4_MF8 /* 9113 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI16_V_MF4_MF8_MASK /* 9114 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI32_V_M1_M1 /* 9115 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI32_V_M1_M1_MASK /* 9116 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI32_V_M1_MF2 /* 9117 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI32_V_M1_MF2_MASK /* 9118 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI32_V_M1_MF4 /* 9119 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI32_V_M1_MF4_MASK /* 9120 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI32_V_M2_M1 /* 9121 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI32_V_M2_M1_MASK /* 9122 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI32_V_M2_MF2 /* 9123 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI32_V_M2_MF2_MASK /* 9124 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI32_V_M4_M1 /* 9125 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI32_V_M4_M1_MASK /* 9126 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI32_V_MF2_M1 /* 9127 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI32_V_MF2_M1_MASK /* 9128 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI32_V_MF2_MF2 /* 9129 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI32_V_MF2_MF2_MASK /* 9130 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI32_V_MF2_MF4 /* 9131 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI32_V_MF2_MF4_MASK /* 9132 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI32_V_MF2_MF8 /* 9133 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI32_V_MF2_MF8_MASK /* 9134 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI64_V_M1_M1 /* 9135 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI64_V_M1_M1_MASK /* 9136 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI64_V_M1_MF2 /* 9137 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI64_V_M1_MF2_MASK /* 9138 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI64_V_M1_MF4 /* 9139 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI64_V_M1_MF4_MASK /* 9140 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI64_V_M1_MF8 /* 9141 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI64_V_M1_MF8_MASK /* 9142 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI64_V_M2_M1 /* 9143 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI64_V_M2_M1_MASK /* 9144 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI64_V_M2_MF2 /* 9145 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI64_V_M2_MF2_MASK /* 9146 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI64_V_M2_MF4 /* 9147 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI64_V_M2_MF4_MASK /* 9148 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI64_V_M4_M1 /* 9149 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI64_V_M4_M1_MASK /* 9150 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI64_V_M4_MF2 /* 9151 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI64_V_M4_MF2_MASK /* 9152 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI64_V_M8_M1 /* 9153 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI64_V_M8_M1_MASK /* 9154 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI8_V_M1_M1 /* 9155 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI8_V_M1_M1_MASK /* 9156 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI8_V_MF2_M1 /* 9157 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI8_V_MF2_M1_MASK /* 9158 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI8_V_MF2_MF2 /* 9159 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI8_V_MF2_MF2_MASK /* 9160 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI8_V_MF4_M1 /* 9161 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI8_V_MF4_M1_MASK /* 9162 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI8_V_MF4_MF2 /* 9163 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI8_V_MF4_MF2_MASK /* 9164 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI8_V_MF4_MF4 /* 9165 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI8_V_MF4_MF4_MASK /* 9166 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI8_V_MF8_M1 /* 9167 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI8_V_MF8_M1_MASK /* 9168 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI8_V_MF8_MF2 /* 9169 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI8_V_MF8_MF2_MASK /* 9170 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI8_V_MF8_MF4 /* 9171 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI8_V_MF8_MF4_MASK /* 9172 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI8_V_MF8_MF8 /* 9173 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSOXSEG8EI8_V_MF8_MF8_MASK /* 9174 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSPILL2_M1 /* 9175 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSPILL2_M2 /* 9176 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSPILL2_M4 /* 9177 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSPILL2_MF2 /* 9178 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSPILL2_MF4 /* 9179 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSPILL2_MF8 /* 9180 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSPILL3_M1 /* 9181 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSPILL3_M2 /* 9182 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSPILL3_MF2 /* 9183 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSPILL3_MF4 /* 9184 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSPILL3_MF8 /* 9185 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSPILL4_M1 /* 9186 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSPILL4_M2 /* 9187 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSPILL4_MF2 /* 9188 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSPILL4_MF4 /* 9189 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSPILL4_MF8 /* 9190 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSPILL5_M1 /* 9191 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSPILL5_MF2 /* 9192 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSPILL5_MF4 /* 9193 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSPILL5_MF8 /* 9194 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSPILL6_M1 /* 9195 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSPILL6_MF2 /* 9196 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSPILL6_MF4 /* 9197 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSPILL6_MF8 /* 9198 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSPILL7_M1 /* 9199 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSPILL7_MF2 /* 9200 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSPILL7_MF4 /* 9201 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSPILL7_MF8 /* 9202 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSPILL8_M1 /* 9203 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSPILL8_MF2 /* 9204 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSPILL8_MF4 /* 9205 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSPILL8_MF8 /* 9206 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRA_VI_M1 /* 9207 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRA_VI_M1_MASK /* 9208 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRA_VI_M2 /* 9209 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRA_VI_M2_MASK /* 9210 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRA_VI_M4 /* 9211 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRA_VI_M4_MASK /* 9212 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRA_VI_M8 /* 9213 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRA_VI_M8_MASK /* 9214 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRA_VI_MF2 /* 9215 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRA_VI_MF2_MASK /* 9216 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRA_VI_MF4 /* 9217 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRA_VI_MF4_MASK /* 9218 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRA_VI_MF8 /* 9219 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRA_VI_MF8_MASK /* 9220 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRA_VV_M1 /* 9221 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRA_VV_M1_MASK /* 9222 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRA_VV_M2 /* 9223 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRA_VV_M2_MASK /* 9224 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRA_VV_M4 /* 9225 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRA_VV_M4_MASK /* 9226 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRA_VV_M8 /* 9227 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRA_VV_M8_MASK /* 9228 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRA_VV_MF2 /* 9229 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRA_VV_MF2_MASK /* 9230 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRA_VV_MF4 /* 9231 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRA_VV_MF4_MASK /* 9232 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRA_VV_MF8 /* 9233 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRA_VV_MF8_MASK /* 9234 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRA_VX_M1 /* 9235 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRA_VX_M1_MASK /* 9236 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRA_VX_M2 /* 9237 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRA_VX_M2_MASK /* 9238 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRA_VX_M4 /* 9239 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRA_VX_M4_MASK /* 9240 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRA_VX_M8 /* 9241 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRA_VX_M8_MASK /* 9242 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRA_VX_MF2 /* 9243 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRA_VX_MF2_MASK /* 9244 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRA_VX_MF4 /* 9245 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRA_VX_MF4_MASK /* 9246 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRA_VX_MF8 /* 9247 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRA_VX_MF8_MASK /* 9248 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRL_VI_M1 /* 9249 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRL_VI_M1_MASK /* 9250 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRL_VI_M2 /* 9251 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRL_VI_M2_MASK /* 9252 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRL_VI_M4 /* 9253 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRL_VI_M4_MASK /* 9254 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRL_VI_M8 /* 9255 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRL_VI_M8_MASK /* 9256 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRL_VI_MF2 /* 9257 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRL_VI_MF2_MASK /* 9258 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRL_VI_MF4 /* 9259 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRL_VI_MF4_MASK /* 9260 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRL_VI_MF8 /* 9261 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRL_VI_MF8_MASK /* 9262 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRL_VV_M1 /* 9263 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRL_VV_M1_MASK /* 9264 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRL_VV_M2 /* 9265 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRL_VV_M2_MASK /* 9266 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRL_VV_M4 /* 9267 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRL_VV_M4_MASK /* 9268 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRL_VV_M8 /* 9269 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRL_VV_M8_MASK /* 9270 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRL_VV_MF2 /* 9271 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRL_VV_MF2_MASK /* 9272 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRL_VV_MF4 /* 9273 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRL_VV_MF4_MASK /* 9274 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRL_VV_MF8 /* 9275 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRL_VV_MF8_MASK /* 9276 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRL_VX_M1 /* 9277 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRL_VX_M1_MASK /* 9278 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRL_VX_M2 /* 9279 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRL_VX_M2_MASK /* 9280 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRL_VX_M4 /* 9281 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRL_VX_M4_MASK /* 9282 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRL_VX_M8 /* 9283 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRL_VX_M8_MASK /* 9284 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRL_VX_MF2 /* 9285 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRL_VX_MF2_MASK /* 9286 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRL_VX_MF4 /* 9287 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRL_VX_MF4_MASK /* 9288 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRL_VX_MF8 /* 9289 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSRL_VX_MF8_MASK /* 9290 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSE16_V_M1 /* 9291 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSE16_V_M1_MASK /* 9292 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSE16_V_M2 /* 9293 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSE16_V_M2_MASK /* 9294 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSE16_V_M4 /* 9295 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSE16_V_M4_MASK /* 9296 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSE16_V_M8 /* 9297 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSE16_V_M8_MASK /* 9298 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSE16_V_MF2 /* 9299 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSE16_V_MF2_MASK /* 9300 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSE16_V_MF4 /* 9301 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSE16_V_MF4_MASK /* 9302 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSE32_V_M1 /* 9303 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSE32_V_M1_MASK /* 9304 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSE32_V_M2 /* 9305 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSE32_V_M2_MASK /* 9306 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSE32_V_M4 /* 9307 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSE32_V_M4_MASK /* 9308 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSE32_V_M8 /* 9309 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSE32_V_M8_MASK /* 9310 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSE32_V_MF2 /* 9311 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSE32_V_MF2_MASK /* 9312 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSE64_V_M1 /* 9313 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSE64_V_M1_MASK /* 9314 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSE64_V_M2 /* 9315 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSE64_V_M2_MASK /* 9316 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSE64_V_M4 /* 9317 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSE64_V_M4_MASK /* 9318 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSE64_V_M8 /* 9319 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSE64_V_M8_MASK /* 9320 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSE8_V_M1 /* 9321 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSE8_V_M1_MASK /* 9322 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSE8_V_M2 /* 9323 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSE8_V_M2_MASK /* 9324 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSE8_V_M4 /* 9325 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSE8_V_M4_MASK /* 9326 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSE8_V_M8 /* 9327 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSE8_V_M8_MASK /* 9328 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSE8_V_MF2 /* 9329 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSE8_V_MF2_MASK /* 9330 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSE8_V_MF4 /* 9331 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSE8_V_MF4_MASK /* 9332 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSE8_V_MF8 /* 9333 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSE8_V_MF8_MASK /* 9334 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG2E16_V_M1 /* 9335 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG2E16_V_M1_MASK /* 9336 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG2E16_V_M2 /* 9337 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG2E16_V_M2_MASK /* 9338 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG2E16_V_M4 /* 9339 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG2E16_V_M4_MASK /* 9340 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG2E16_V_MF2 /* 9341 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG2E16_V_MF2_MASK /* 9342 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG2E16_V_MF4 /* 9343 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG2E16_V_MF4_MASK /* 9344 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG2E32_V_M1 /* 9345 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG2E32_V_M1_MASK /* 9346 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG2E32_V_M2 /* 9347 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG2E32_V_M2_MASK /* 9348 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG2E32_V_M4 /* 9349 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG2E32_V_M4_MASK /* 9350 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG2E32_V_MF2 /* 9351 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG2E32_V_MF2_MASK /* 9352 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG2E64_V_M1 /* 9353 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG2E64_V_M1_MASK /* 9354 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG2E64_V_M2 /* 9355 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG2E64_V_M2_MASK /* 9356 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG2E64_V_M4 /* 9357 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG2E64_V_M4_MASK /* 9358 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG2E8_V_M1 /* 9359 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG2E8_V_M1_MASK /* 9360 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG2E8_V_M2 /* 9361 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG2E8_V_M2_MASK /* 9362 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG2E8_V_M4 /* 9363 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG2E8_V_M4_MASK /* 9364 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG2E8_V_MF2 /* 9365 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG2E8_V_MF2_MASK /* 9366 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG2E8_V_MF4 /* 9367 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG2E8_V_MF4_MASK /* 9368 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG2E8_V_MF8 /* 9369 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG2E8_V_MF8_MASK /* 9370 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG3E16_V_M1 /* 9371 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG3E16_V_M1_MASK /* 9372 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG3E16_V_M2 /* 9373 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG3E16_V_M2_MASK /* 9374 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG3E16_V_MF2 /* 9375 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG3E16_V_MF2_MASK /* 9376 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG3E16_V_MF4 /* 9377 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG3E16_V_MF4_MASK /* 9378 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG3E32_V_M1 /* 9379 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG3E32_V_M1_MASK /* 9380 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG3E32_V_M2 /* 9381 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG3E32_V_M2_MASK /* 9382 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG3E32_V_MF2 /* 9383 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG3E32_V_MF2_MASK /* 9384 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG3E64_V_M1 /* 9385 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG3E64_V_M1_MASK /* 9386 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG3E64_V_M2 /* 9387 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG3E64_V_M2_MASK /* 9388 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG3E8_V_M1 /* 9389 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG3E8_V_M1_MASK /* 9390 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG3E8_V_M2 /* 9391 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG3E8_V_M2_MASK /* 9392 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG3E8_V_MF2 /* 9393 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG3E8_V_MF2_MASK /* 9394 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG3E8_V_MF4 /* 9395 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG3E8_V_MF4_MASK /* 9396 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG3E8_V_MF8 /* 9397 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG3E8_V_MF8_MASK /* 9398 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG4E16_V_M1 /* 9399 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG4E16_V_M1_MASK /* 9400 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG4E16_V_M2 /* 9401 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG4E16_V_M2_MASK /* 9402 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG4E16_V_MF2 /* 9403 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG4E16_V_MF2_MASK /* 9404 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG4E16_V_MF4 /* 9405 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG4E16_V_MF4_MASK /* 9406 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG4E32_V_M1 /* 9407 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG4E32_V_M1_MASK /* 9408 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG4E32_V_M2 /* 9409 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG4E32_V_M2_MASK /* 9410 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG4E32_V_MF2 /* 9411 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG4E32_V_MF2_MASK /* 9412 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG4E64_V_M1 /* 9413 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG4E64_V_M1_MASK /* 9414 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG4E64_V_M2 /* 9415 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG4E64_V_M2_MASK /* 9416 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG4E8_V_M1 /* 9417 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG4E8_V_M1_MASK /* 9418 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG4E8_V_M2 /* 9419 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG4E8_V_M2_MASK /* 9420 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG4E8_V_MF2 /* 9421 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG4E8_V_MF2_MASK /* 9422 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG4E8_V_MF4 /* 9423 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG4E8_V_MF4_MASK /* 9424 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG4E8_V_MF8 /* 9425 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG4E8_V_MF8_MASK /* 9426 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG5E16_V_M1 /* 9427 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG5E16_V_M1_MASK /* 9428 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG5E16_V_MF2 /* 9429 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG5E16_V_MF2_MASK /* 9430 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG5E16_V_MF4 /* 9431 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG5E16_V_MF4_MASK /* 9432 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG5E32_V_M1 /* 9433 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG5E32_V_M1_MASK /* 9434 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG5E32_V_MF2 /* 9435 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG5E32_V_MF2_MASK /* 9436 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG5E64_V_M1 /* 9437 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG5E64_V_M1_MASK /* 9438 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG5E8_V_M1 /* 9439 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG5E8_V_M1_MASK /* 9440 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG5E8_V_MF2 /* 9441 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG5E8_V_MF2_MASK /* 9442 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG5E8_V_MF4 /* 9443 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG5E8_V_MF4_MASK /* 9444 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG5E8_V_MF8 /* 9445 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG5E8_V_MF8_MASK /* 9446 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG6E16_V_M1 /* 9447 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG6E16_V_M1_MASK /* 9448 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG6E16_V_MF2 /* 9449 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG6E16_V_MF2_MASK /* 9450 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG6E16_V_MF4 /* 9451 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG6E16_V_MF4_MASK /* 9452 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG6E32_V_M1 /* 9453 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG6E32_V_M1_MASK /* 9454 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG6E32_V_MF2 /* 9455 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG6E32_V_MF2_MASK /* 9456 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG6E64_V_M1 /* 9457 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG6E64_V_M1_MASK /* 9458 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG6E8_V_M1 /* 9459 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG6E8_V_M1_MASK /* 9460 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG6E8_V_MF2 /* 9461 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG6E8_V_MF2_MASK /* 9462 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG6E8_V_MF4 /* 9463 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG6E8_V_MF4_MASK /* 9464 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG6E8_V_MF8 /* 9465 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG6E8_V_MF8_MASK /* 9466 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG7E16_V_M1 /* 9467 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG7E16_V_M1_MASK /* 9468 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG7E16_V_MF2 /* 9469 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG7E16_V_MF2_MASK /* 9470 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG7E16_V_MF4 /* 9471 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG7E16_V_MF4_MASK /* 9472 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG7E32_V_M1 /* 9473 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG7E32_V_M1_MASK /* 9474 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG7E32_V_MF2 /* 9475 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG7E32_V_MF2_MASK /* 9476 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG7E64_V_M1 /* 9477 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG7E64_V_M1_MASK /* 9478 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG7E8_V_M1 /* 9479 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG7E8_V_M1_MASK /* 9480 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG7E8_V_MF2 /* 9481 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG7E8_V_MF2_MASK /* 9482 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG7E8_V_MF4 /* 9483 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG7E8_V_MF4_MASK /* 9484 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG7E8_V_MF8 /* 9485 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG7E8_V_MF8_MASK /* 9486 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG8E16_V_M1 /* 9487 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG8E16_V_M1_MASK /* 9488 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG8E16_V_MF2 /* 9489 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG8E16_V_MF2_MASK /* 9490 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG8E16_V_MF4 /* 9491 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG8E16_V_MF4_MASK /* 9492 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG8E32_V_M1 /* 9493 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG8E32_V_M1_MASK /* 9494 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG8E32_V_MF2 /* 9495 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG8E32_V_MF2_MASK /* 9496 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG8E64_V_M1 /* 9497 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG8E64_V_M1_MASK /* 9498 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG8E8_V_M1 /* 9499 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG8E8_V_M1_MASK /* 9500 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG8E8_V_MF2 /* 9501 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG8E8_V_MF2_MASK /* 9502 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG8E8_V_MF4 /* 9503 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG8E8_V_MF4_MASK /* 9504 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG8E8_V_MF8 /* 9505 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSEG8E8_V_MF8_MASK /* 9506 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRA_VI_M1 /* 9507 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRA_VI_M1_MASK /* 9508 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRA_VI_M2 /* 9509 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRA_VI_M2_MASK /* 9510 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRA_VI_M4 /* 9511 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRA_VI_M4_MASK /* 9512 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRA_VI_M8 /* 9513 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRA_VI_M8_MASK /* 9514 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRA_VI_MF2 /* 9515 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRA_VI_MF2_MASK /* 9516 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRA_VI_MF4 /* 9517 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRA_VI_MF4_MASK /* 9518 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRA_VI_MF8 /* 9519 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRA_VI_MF8_MASK /* 9520 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRA_VV_M1 /* 9521 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRA_VV_M1_MASK /* 9522 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRA_VV_M2 /* 9523 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRA_VV_M2_MASK /* 9524 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRA_VV_M4 /* 9525 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRA_VV_M4_MASK /* 9526 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRA_VV_M8 /* 9527 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRA_VV_M8_MASK /* 9528 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRA_VV_MF2 /* 9529 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRA_VV_MF2_MASK /* 9530 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRA_VV_MF4 /* 9531 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRA_VV_MF4_MASK /* 9532 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRA_VV_MF8 /* 9533 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRA_VV_MF8_MASK /* 9534 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRA_VX_M1 /* 9535 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRA_VX_M1_MASK /* 9536 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRA_VX_M2 /* 9537 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRA_VX_M2_MASK /* 9538 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRA_VX_M4 /* 9539 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRA_VX_M4_MASK /* 9540 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRA_VX_M8 /* 9541 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRA_VX_M8_MASK /* 9542 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRA_VX_MF2 /* 9543 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRA_VX_MF2_MASK /* 9544 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRA_VX_MF4 /* 9545 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRA_VX_MF4_MASK /* 9546 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRA_VX_MF8 /* 9547 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRA_VX_MF8_MASK /* 9548 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRL_VI_M1 /* 9549 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRL_VI_M1_MASK /* 9550 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRL_VI_M2 /* 9551 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRL_VI_M2_MASK /* 9552 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRL_VI_M4 /* 9553 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRL_VI_M4_MASK /* 9554 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRL_VI_M8 /* 9555 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRL_VI_M8_MASK /* 9556 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRL_VI_MF2 /* 9557 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRL_VI_MF2_MASK /* 9558 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRL_VI_MF4 /* 9559 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRL_VI_MF4_MASK /* 9560 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRL_VI_MF8 /* 9561 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRL_VI_MF8_MASK /* 9562 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRL_VV_M1 /* 9563 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRL_VV_M1_MASK /* 9564 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRL_VV_M2 /* 9565 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRL_VV_M2_MASK /* 9566 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRL_VV_M4 /* 9567 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRL_VV_M4_MASK /* 9568 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRL_VV_M8 /* 9569 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRL_VV_M8_MASK /* 9570 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRL_VV_MF2 /* 9571 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRL_VV_MF2_MASK /* 9572 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRL_VV_MF4 /* 9573 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRL_VV_MF4_MASK /* 9574 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRL_VV_MF8 /* 9575 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRL_VV_MF8_MASK /* 9576 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRL_VX_M1 /* 9577 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRL_VX_M1_MASK /* 9578 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRL_VX_M2 /* 9579 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRL_VX_M2_MASK /* 9580 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRL_VX_M4 /* 9581 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRL_VX_M4_MASK /* 9582 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRL_VX_M8 /* 9583 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRL_VX_M8_MASK /* 9584 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRL_VX_MF2 /* 9585 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRL_VX_MF2_MASK /* 9586 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRL_VX_MF4 /* 9587 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRL_VX_MF4_MASK /* 9588 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRL_VX_MF8 /* 9589 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSRL_VX_MF8_MASK /* 9590 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG2E16_V_M1 /* 9591 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG2E16_V_M1_MASK /* 9592 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG2E16_V_M2 /* 9593 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG2E16_V_M2_MASK /* 9594 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG2E16_V_M4 /* 9595 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG2E16_V_M4_MASK /* 9596 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG2E16_V_MF2 /* 9597 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG2E16_V_MF2_MASK /* 9598 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG2E16_V_MF4 /* 9599 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG2E16_V_MF4_MASK /* 9600 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG2E32_V_M1 /* 9601 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG2E32_V_M1_MASK /* 9602 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG2E32_V_M2 /* 9603 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG2E32_V_M2_MASK /* 9604 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG2E32_V_M4 /* 9605 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG2E32_V_M4_MASK /* 9606 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG2E32_V_MF2 /* 9607 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG2E32_V_MF2_MASK /* 9608 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG2E64_V_M1 /* 9609 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG2E64_V_M1_MASK /* 9610 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG2E64_V_M2 /* 9611 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG2E64_V_M2_MASK /* 9612 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG2E64_V_M4 /* 9613 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG2E64_V_M4_MASK /* 9614 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG2E8_V_M1 /* 9615 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG2E8_V_M1_MASK /* 9616 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG2E8_V_M2 /* 9617 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG2E8_V_M2_MASK /* 9618 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG2E8_V_M4 /* 9619 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG2E8_V_M4_MASK /* 9620 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG2E8_V_MF2 /* 9621 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG2E8_V_MF2_MASK /* 9622 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG2E8_V_MF4 /* 9623 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG2E8_V_MF4_MASK /* 9624 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG2E8_V_MF8 /* 9625 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG2E8_V_MF8_MASK /* 9626 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG3E16_V_M1 /* 9627 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG3E16_V_M1_MASK /* 9628 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG3E16_V_M2 /* 9629 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG3E16_V_M2_MASK /* 9630 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG3E16_V_MF2 /* 9631 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG3E16_V_MF2_MASK /* 9632 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG3E16_V_MF4 /* 9633 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG3E16_V_MF4_MASK /* 9634 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG3E32_V_M1 /* 9635 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG3E32_V_M1_MASK /* 9636 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG3E32_V_M2 /* 9637 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG3E32_V_M2_MASK /* 9638 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG3E32_V_MF2 /* 9639 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG3E32_V_MF2_MASK /* 9640 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG3E64_V_M1 /* 9641 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG3E64_V_M1_MASK /* 9642 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG3E64_V_M2 /* 9643 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG3E64_V_M2_MASK /* 9644 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG3E8_V_M1 /* 9645 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG3E8_V_M1_MASK /* 9646 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG3E8_V_M2 /* 9647 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG3E8_V_M2_MASK /* 9648 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG3E8_V_MF2 /* 9649 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG3E8_V_MF2_MASK /* 9650 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG3E8_V_MF4 /* 9651 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG3E8_V_MF4_MASK /* 9652 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG3E8_V_MF8 /* 9653 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG3E8_V_MF8_MASK /* 9654 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG4E16_V_M1 /* 9655 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG4E16_V_M1_MASK /* 9656 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG4E16_V_M2 /* 9657 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG4E16_V_M2_MASK /* 9658 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG4E16_V_MF2 /* 9659 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG4E16_V_MF2_MASK /* 9660 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG4E16_V_MF4 /* 9661 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG4E16_V_MF4_MASK /* 9662 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG4E32_V_M1 /* 9663 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG4E32_V_M1_MASK /* 9664 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG4E32_V_M2 /* 9665 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG4E32_V_M2_MASK /* 9666 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG4E32_V_MF2 /* 9667 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG4E32_V_MF2_MASK /* 9668 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG4E64_V_M1 /* 9669 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG4E64_V_M1_MASK /* 9670 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG4E64_V_M2 /* 9671 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG4E64_V_M2_MASK /* 9672 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG4E8_V_M1 /* 9673 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG4E8_V_M1_MASK /* 9674 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG4E8_V_M2 /* 9675 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG4E8_V_M2_MASK /* 9676 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG4E8_V_MF2 /* 9677 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG4E8_V_MF2_MASK /* 9678 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG4E8_V_MF4 /* 9679 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG4E8_V_MF4_MASK /* 9680 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG4E8_V_MF8 /* 9681 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG4E8_V_MF8_MASK /* 9682 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG5E16_V_M1 /* 9683 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG5E16_V_M1_MASK /* 9684 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG5E16_V_MF2 /* 9685 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG5E16_V_MF2_MASK /* 9686 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG5E16_V_MF4 /* 9687 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG5E16_V_MF4_MASK /* 9688 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG5E32_V_M1 /* 9689 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG5E32_V_M1_MASK /* 9690 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG5E32_V_MF2 /* 9691 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG5E32_V_MF2_MASK /* 9692 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG5E64_V_M1 /* 9693 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG5E64_V_M1_MASK /* 9694 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG5E8_V_M1 /* 9695 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG5E8_V_M1_MASK /* 9696 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG5E8_V_MF2 /* 9697 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG5E8_V_MF2_MASK /* 9698 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG5E8_V_MF4 /* 9699 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG5E8_V_MF4_MASK /* 9700 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG5E8_V_MF8 /* 9701 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG5E8_V_MF8_MASK /* 9702 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG6E16_V_M1 /* 9703 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG6E16_V_M1_MASK /* 9704 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG6E16_V_MF2 /* 9705 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG6E16_V_MF2_MASK /* 9706 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG6E16_V_MF4 /* 9707 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG6E16_V_MF4_MASK /* 9708 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG6E32_V_M1 /* 9709 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG6E32_V_M1_MASK /* 9710 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG6E32_V_MF2 /* 9711 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG6E32_V_MF2_MASK /* 9712 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG6E64_V_M1 /* 9713 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG6E64_V_M1_MASK /* 9714 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG6E8_V_M1 /* 9715 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG6E8_V_M1_MASK /* 9716 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG6E8_V_MF2 /* 9717 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG6E8_V_MF2_MASK /* 9718 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG6E8_V_MF4 /* 9719 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG6E8_V_MF4_MASK /* 9720 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG6E8_V_MF8 /* 9721 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG6E8_V_MF8_MASK /* 9722 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG7E16_V_M1 /* 9723 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG7E16_V_M1_MASK /* 9724 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG7E16_V_MF2 /* 9725 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG7E16_V_MF2_MASK /* 9726 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG7E16_V_MF4 /* 9727 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG7E16_V_MF4_MASK /* 9728 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG7E32_V_M1 /* 9729 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG7E32_V_M1_MASK /* 9730 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG7E32_V_MF2 /* 9731 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG7E32_V_MF2_MASK /* 9732 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG7E64_V_M1 /* 9733 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG7E64_V_M1_MASK /* 9734 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG7E8_V_M1 /* 9735 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG7E8_V_M1_MASK /* 9736 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG7E8_V_MF2 /* 9737 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG7E8_V_MF2_MASK /* 9738 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG7E8_V_MF4 /* 9739 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG7E8_V_MF4_MASK /* 9740 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG7E8_V_MF8 /* 9741 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG7E8_V_MF8_MASK /* 9742 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG8E16_V_M1 /* 9743 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG8E16_V_M1_MASK /* 9744 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG8E16_V_MF2 /* 9745 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG8E16_V_MF2_MASK /* 9746 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG8E16_V_MF4 /* 9747 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG8E16_V_MF4_MASK /* 9748 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG8E32_V_M1 /* 9749 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG8E32_V_M1_MASK /* 9750 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG8E32_V_MF2 /* 9751 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG8E32_V_MF2_MASK /* 9752 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG8E64_V_M1 /* 9753 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG8E64_V_M1_MASK /* 9754 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG8E8_V_M1 /* 9755 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG8E8_V_M1_MASK /* 9756 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG8E8_V_MF2 /* 9757 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG8E8_V_MF2_MASK /* 9758 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG8E8_V_MF4 /* 9759 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG8E8_V_MF4_MASK /* 9760 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG8E8_V_MF8 /* 9761 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSSEG8E8_V_MF8_MASK /* 9762 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSUBU_VV_M1 /* 9763 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSUBU_VV_M1_MASK /* 9764 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSUBU_VV_M2 /* 9765 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSUBU_VV_M2_MASK /* 9766 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSUBU_VV_M4 /* 9767 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSUBU_VV_M4_MASK /* 9768 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSUBU_VV_M8 /* 9769 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSUBU_VV_M8_MASK /* 9770 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSUBU_VV_MF2 /* 9771 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSUBU_VV_MF2_MASK /* 9772 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSUBU_VV_MF4 /* 9773 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSUBU_VV_MF4_MASK /* 9774 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSUBU_VV_MF8 /* 9775 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSUBU_VV_MF8_MASK /* 9776 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSUBU_VX_M1 /* 9777 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSUBU_VX_M1_MASK /* 9778 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSUBU_VX_M2 /* 9779 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSUBU_VX_M2_MASK /* 9780 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSUBU_VX_M4 /* 9781 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSUBU_VX_M4_MASK /* 9782 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSUBU_VX_M8 /* 9783 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSUBU_VX_M8_MASK /* 9784 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSUBU_VX_MF2 /* 9785 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSUBU_VX_MF2_MASK /* 9786 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSUBU_VX_MF4 /* 9787 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSUBU_VX_MF4_MASK /* 9788 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSUBU_VX_MF8 /* 9789 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSUBU_VX_MF8_MASK /* 9790 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSUB_VV_M1 /* 9791 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSUB_VV_M1_MASK /* 9792 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSUB_VV_M2 /* 9793 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSUB_VV_M2_MASK /* 9794 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSUB_VV_M4 /* 9795 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSUB_VV_M4_MASK /* 9796 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSUB_VV_M8 /* 9797 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSUB_VV_M8_MASK /* 9798 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSUB_VV_MF2 /* 9799 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSUB_VV_MF2_MASK /* 9800 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSUB_VV_MF4 /* 9801 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSUB_VV_MF4_MASK /* 9802 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSUB_VV_MF8 /* 9803 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSUB_VV_MF8_MASK /* 9804 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSUB_VX_M1 /* 9805 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSUB_VX_M1_MASK /* 9806 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSUB_VX_M2 /* 9807 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSUB_VX_M2_MASK /* 9808 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSUB_VX_M4 /* 9809 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSUB_VX_M4_MASK /* 9810 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSUB_VX_M8 /* 9811 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSUB_VX_M8_MASK /* 9812 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSUB_VX_MF2 /* 9813 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSUB_VX_MF2_MASK /* 9814 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSUB_VX_MF4 /* 9815 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSUB_VX_MF4_MASK /* 9816 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSUB_VX_MF8 /* 9817 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSSUB_VX_MF8_MASK /* 9818 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUB_VV_M1 /* 9819 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUB_VV_M1_MASK /* 9820 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUB_VV_M2 /* 9821 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUB_VV_M2_MASK /* 9822 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUB_VV_M4 /* 9823 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUB_VV_M4_MASK /* 9824 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUB_VV_M8 /* 9825 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUB_VV_M8_MASK /* 9826 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUB_VV_MF2 /* 9827 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUB_VV_MF2_MASK /* 9828 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUB_VV_MF4 /* 9829 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUB_VV_MF4_MASK /* 9830 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUB_VV_MF8 /* 9831 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUB_VV_MF8_MASK /* 9832 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUB_VX_M1 /* 9833 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUB_VX_M1_MASK /* 9834 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUB_VX_M2 /* 9835 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUB_VX_M2_MASK /* 9836 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUB_VX_M4 /* 9837 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUB_VX_M4_MASK /* 9838 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUB_VX_M8 /* 9839 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUB_VX_M8_MASK /* 9840 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUB_VX_MF2 /* 9841 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUB_VX_MF2_MASK /* 9842 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUB_VX_MF4 /* 9843 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUB_VX_MF4_MASK /* 9844 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUB_VX_MF8 /* 9845 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUB_VX_MF8_MASK /* 9846 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI16_V_M1_M1 /* 9847 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI16_V_M1_M1_MASK /* 9848 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI16_V_M1_M2 /* 9849 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI16_V_M1_M2_MASK /* 9850 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI16_V_M1_M4 /* 9851 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI16_V_M1_M4_MASK /* 9852 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI16_V_M1_MF2 /* 9853 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI16_V_M1_MF2_MASK /* 9854 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI16_V_M2_M1 /* 9855 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI16_V_M2_M1_MASK /* 9856 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI16_V_M2_M2 /* 9857 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI16_V_M2_M2_MASK /* 9858 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI16_V_M2_M4 /* 9859 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI16_V_M2_M4_MASK /* 9860 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI16_V_M2_M8 /* 9861 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI16_V_M2_M8_MASK /* 9862 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI16_V_M4_M2 /* 9863 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI16_V_M4_M2_MASK /* 9864 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI16_V_M4_M4 /* 9865 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI16_V_M4_M4_MASK /* 9866 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI16_V_M4_M8 /* 9867 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI16_V_M4_M8_MASK /* 9868 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI16_V_M8_M4 /* 9869 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI16_V_M8_M4_MASK /* 9870 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI16_V_M8_M8 /* 9871 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI16_V_M8_M8_MASK /* 9872 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI16_V_MF2_M1 /* 9873 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI16_V_MF2_M1_MASK /* 9874 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI16_V_MF2_M2 /* 9875 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI16_V_MF2_M2_MASK /* 9876 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI16_V_MF2_MF2 /* 9877 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI16_V_MF2_MF2_MASK /* 9878 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI16_V_MF2_MF4 /* 9879 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI16_V_MF2_MF4_MASK /* 9880 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI16_V_MF4_M1 /* 9881 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI16_V_MF4_M1_MASK /* 9882 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI16_V_MF4_MF2 /* 9883 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI16_V_MF4_MF2_MASK /* 9884 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI16_V_MF4_MF4 /* 9885 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI16_V_MF4_MF4_MASK /* 9886 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI16_V_MF4_MF8 /* 9887 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI16_V_MF4_MF8_MASK /* 9888 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI32_V_M1_M1 /* 9889 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI32_V_M1_M1_MASK /* 9890 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI32_V_M1_M2 /* 9891 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI32_V_M1_M2_MASK /* 9892 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI32_V_M1_MF2 /* 9893 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI32_V_M1_MF2_MASK /* 9894 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI32_V_M1_MF4 /* 9895 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI32_V_M1_MF4_MASK /* 9896 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI32_V_M2_M1 /* 9897 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI32_V_M2_M1_MASK /* 9898 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI32_V_M2_M2 /* 9899 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI32_V_M2_M2_MASK /* 9900 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI32_V_M2_M4 /* 9901 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI32_V_M2_M4_MASK /* 9902 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI32_V_M2_MF2 /* 9903 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI32_V_M2_MF2_MASK /* 9904 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI32_V_M4_M1 /* 9905 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI32_V_M4_M1_MASK /* 9906 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI32_V_M4_M2 /* 9907 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI32_V_M4_M2_MASK /* 9908 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI32_V_M4_M4 /* 9909 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI32_V_M4_M4_MASK /* 9910 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI32_V_M4_M8 /* 9911 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI32_V_M4_M8_MASK /* 9912 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI32_V_M8_M2 /* 9913 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI32_V_M8_M2_MASK /* 9914 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI32_V_M8_M4 /* 9915 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI32_V_M8_M4_MASK /* 9916 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI32_V_M8_M8 /* 9917 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI32_V_M8_M8_MASK /* 9918 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI32_V_MF2_M1 /* 9919 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI32_V_MF2_M1_MASK /* 9920 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI32_V_MF2_MF2 /* 9921 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI32_V_MF2_MF2_MASK /* 9922 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI32_V_MF2_MF4 /* 9923 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI32_V_MF2_MF4_MASK /* 9924 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI32_V_MF2_MF8 /* 9925 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI32_V_MF2_MF8_MASK /* 9926 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI64_V_M1_M1 /* 9927 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI64_V_M1_M1_MASK /* 9928 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI64_V_M1_MF2 /* 9929 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI64_V_M1_MF2_MASK /* 9930 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI64_V_M1_MF4 /* 9931 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI64_V_M1_MF4_MASK /* 9932 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI64_V_M1_MF8 /* 9933 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI64_V_M1_MF8_MASK /* 9934 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI64_V_M2_M1 /* 9935 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI64_V_M2_M1_MASK /* 9936 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI64_V_M2_M2 /* 9937 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI64_V_M2_M2_MASK /* 9938 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI64_V_M2_MF2 /* 9939 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI64_V_M2_MF2_MASK /* 9940 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI64_V_M2_MF4 /* 9941 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI64_V_M2_MF4_MASK /* 9942 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI64_V_M4_M1 /* 9943 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI64_V_M4_M1_MASK /* 9944 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI64_V_M4_M2 /* 9945 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI64_V_M4_M2_MASK /* 9946 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI64_V_M4_M4 /* 9947 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI64_V_M4_M4_MASK /* 9948 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI64_V_M4_MF2 /* 9949 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI64_V_M4_MF2_MASK /* 9950 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI64_V_M8_M1 /* 9951 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI64_V_M8_M1_MASK /* 9952 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI64_V_M8_M2 /* 9953 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI64_V_M8_M2_MASK /* 9954 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI64_V_M8_M4 /* 9955 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI64_V_M8_M4_MASK /* 9956 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI64_V_M8_M8 /* 9957 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI64_V_M8_M8_MASK /* 9958 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI8_V_M1_M1 /* 9959 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI8_V_M1_M1_MASK /* 9960 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI8_V_M1_M2 /* 9961 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI8_V_M1_M2_MASK /* 9962 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI8_V_M1_M4 /* 9963 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI8_V_M1_M4_MASK /* 9964 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI8_V_M1_M8 /* 9965 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI8_V_M1_M8_MASK /* 9966 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI8_V_M2_M2 /* 9967 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI8_V_M2_M2_MASK /* 9968 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI8_V_M2_M4 /* 9969 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI8_V_M2_M4_MASK /* 9970 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI8_V_M2_M8 /* 9971 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI8_V_M2_M8_MASK /* 9972 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI8_V_M4_M4 /* 9973 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI8_V_M4_M4_MASK /* 9974 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI8_V_M4_M8 /* 9975 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI8_V_M4_M8_MASK /* 9976 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI8_V_M8_M8 /* 9977 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI8_V_M8_M8_MASK /* 9978 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI8_V_MF2_M1 /* 9979 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI8_V_MF2_M1_MASK /* 9980 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI8_V_MF2_M2 /* 9981 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI8_V_MF2_M2_MASK /* 9982 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI8_V_MF2_M4 /* 9983 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI8_V_MF2_M4_MASK /* 9984 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI8_V_MF2_MF2 /* 9985 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI8_V_MF2_MF2_MASK /* 9986 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI8_V_MF4_M1 /* 9987 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI8_V_MF4_M1_MASK /* 9988 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI8_V_MF4_M2 /* 9989 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI8_V_MF4_M2_MASK /* 9990 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI8_V_MF4_MF2 /* 9991 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI8_V_MF4_MF2_MASK /* 9992 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI8_V_MF4_MF4 /* 9993 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI8_V_MF4_MF4_MASK /* 9994 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI8_V_MF8_M1 /* 9995 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI8_V_MF8_M1_MASK /* 9996 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI8_V_MF8_MF2 /* 9997 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI8_V_MF8_MF2_MASK /* 9998 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI8_V_MF8_MF4 /* 9999 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI8_V_MF8_MF4_MASK /* 10000 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI8_V_MF8_MF8 /* 10001 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXEI8_V_MF8_MF8_MASK /* 10002 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI16_V_M1_M1 /* 10003 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI16_V_M1_M1_MASK /* 10004 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI16_V_M1_M2 /* 10005 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI16_V_M1_M2_MASK /* 10006 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI16_V_M1_M4 /* 10007 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI16_V_M1_M4_MASK /* 10008 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI16_V_M1_MF2 /* 10009 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI16_V_M1_MF2_MASK /* 10010 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI16_V_M2_M1 /* 10011 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI16_V_M2_M1_MASK /* 10012 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI16_V_M2_M2 /* 10013 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI16_V_M2_M2_MASK /* 10014 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI16_V_M2_M4 /* 10015 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI16_V_M2_M4_MASK /* 10016 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI16_V_M4_M2 /* 10017 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI16_V_M4_M2_MASK /* 10018 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI16_V_M4_M4 /* 10019 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI16_V_M4_M4_MASK /* 10020 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI16_V_M8_M4 /* 10021 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI16_V_M8_M4_MASK /* 10022 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI16_V_MF2_M1 /* 10023 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI16_V_MF2_M1_MASK /* 10024 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI16_V_MF2_M2 /* 10025 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI16_V_MF2_M2_MASK /* 10026 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI16_V_MF2_MF2 /* 10027 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI16_V_MF2_MF2_MASK /* 10028 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI16_V_MF2_MF4 /* 10029 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI16_V_MF2_MF4_MASK /* 10030 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI16_V_MF4_M1 /* 10031 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI16_V_MF4_M1_MASK /* 10032 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI16_V_MF4_MF2 /* 10033 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI16_V_MF4_MF2_MASK /* 10034 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI16_V_MF4_MF4 /* 10035 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI16_V_MF4_MF4_MASK /* 10036 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI16_V_MF4_MF8 /* 10037 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI16_V_MF4_MF8_MASK /* 10038 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI32_V_M1_M1 /* 10039 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI32_V_M1_M1_MASK /* 10040 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI32_V_M1_M2 /* 10041 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI32_V_M1_M2_MASK /* 10042 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI32_V_M1_MF2 /* 10043 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI32_V_M1_MF2_MASK /* 10044 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI32_V_M1_MF4 /* 10045 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI32_V_M1_MF4_MASK /* 10046 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI32_V_M2_M1 /* 10047 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI32_V_M2_M1_MASK /* 10048 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI32_V_M2_M2 /* 10049 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI32_V_M2_M2_MASK /* 10050 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI32_V_M2_M4 /* 10051 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI32_V_M2_M4_MASK /* 10052 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI32_V_M2_MF2 /* 10053 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI32_V_M2_MF2_MASK /* 10054 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI32_V_M4_M1 /* 10055 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI32_V_M4_M1_MASK /* 10056 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI32_V_M4_M2 /* 10057 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI32_V_M4_M2_MASK /* 10058 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI32_V_M4_M4 /* 10059 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI32_V_M4_M4_MASK /* 10060 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI32_V_M8_M2 /* 10061 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI32_V_M8_M2_MASK /* 10062 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI32_V_M8_M4 /* 10063 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI32_V_M8_M4_MASK /* 10064 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI32_V_MF2_M1 /* 10065 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI32_V_MF2_M1_MASK /* 10066 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI32_V_MF2_MF2 /* 10067 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI32_V_MF2_MF2_MASK /* 10068 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI32_V_MF2_MF4 /* 10069 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI32_V_MF2_MF4_MASK /* 10070 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI32_V_MF2_MF8 /* 10071 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI32_V_MF2_MF8_MASK /* 10072 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI64_V_M1_M1 /* 10073 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI64_V_M1_M1_MASK /* 10074 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI64_V_M1_MF2 /* 10075 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI64_V_M1_MF2_MASK /* 10076 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI64_V_M1_MF4 /* 10077 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI64_V_M1_MF4_MASK /* 10078 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI64_V_M1_MF8 /* 10079 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI64_V_M1_MF8_MASK /* 10080 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI64_V_M2_M1 /* 10081 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI64_V_M2_M1_MASK /* 10082 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI64_V_M2_M2 /* 10083 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI64_V_M2_M2_MASK /* 10084 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI64_V_M2_MF2 /* 10085 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI64_V_M2_MF2_MASK /* 10086 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI64_V_M2_MF4 /* 10087 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI64_V_M2_MF4_MASK /* 10088 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI64_V_M4_M1 /* 10089 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI64_V_M4_M1_MASK /* 10090 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI64_V_M4_M2 /* 10091 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI64_V_M4_M2_MASK /* 10092 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI64_V_M4_M4 /* 10093 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI64_V_M4_M4_MASK /* 10094 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI64_V_M4_MF2 /* 10095 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI64_V_M4_MF2_MASK /* 10096 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI64_V_M8_M1 /* 10097 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI64_V_M8_M1_MASK /* 10098 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI64_V_M8_M2 /* 10099 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI64_V_M8_M2_MASK /* 10100 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI64_V_M8_M4 /* 10101 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI64_V_M8_M4_MASK /* 10102 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI8_V_M1_M1 /* 10103 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI8_V_M1_M1_MASK /* 10104 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI8_V_M1_M2 /* 10105 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI8_V_M1_M2_MASK /* 10106 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI8_V_M1_M4 /* 10107 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI8_V_M1_M4_MASK /* 10108 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI8_V_M2_M2 /* 10109 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI8_V_M2_M2_MASK /* 10110 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI8_V_M2_M4 /* 10111 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI8_V_M2_M4_MASK /* 10112 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI8_V_M4_M4 /* 10113 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI8_V_M4_M4_MASK /* 10114 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI8_V_MF2_M1 /* 10115 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI8_V_MF2_M1_MASK /* 10116 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI8_V_MF2_M2 /* 10117 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI8_V_MF2_M2_MASK /* 10118 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI8_V_MF2_M4 /* 10119 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI8_V_MF2_M4_MASK /* 10120 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI8_V_MF2_MF2 /* 10121 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI8_V_MF2_MF2_MASK /* 10122 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI8_V_MF4_M1 /* 10123 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI8_V_MF4_M1_MASK /* 10124 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI8_V_MF4_M2 /* 10125 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI8_V_MF4_M2_MASK /* 10126 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI8_V_MF4_MF2 /* 10127 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI8_V_MF4_MF2_MASK /* 10128 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI8_V_MF4_MF4 /* 10129 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI8_V_MF4_MF4_MASK /* 10130 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI8_V_MF8_M1 /* 10131 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI8_V_MF8_M1_MASK /* 10132 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI8_V_MF8_MF2 /* 10133 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI8_V_MF8_MF2_MASK /* 10134 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI8_V_MF8_MF4 /* 10135 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI8_V_MF8_MF4_MASK /* 10136 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI8_V_MF8_MF8 /* 10137 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG2EI8_V_MF8_MF8_MASK /* 10138 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI16_V_M1_M1 /* 10139 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI16_V_M1_M1_MASK /* 10140 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI16_V_M1_M2 /* 10141 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI16_V_M1_M2_MASK /* 10142 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI16_V_M1_MF2 /* 10143 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI16_V_M1_MF2_MASK /* 10144 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI16_V_M2_M1 /* 10145 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI16_V_M2_M1_MASK /* 10146 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI16_V_M2_M2 /* 10147 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI16_V_M2_M2_MASK /* 10148 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI16_V_M4_M2 /* 10149 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI16_V_M4_M2_MASK /* 10150 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI16_V_MF2_M1 /* 10151 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI16_V_MF2_M1_MASK /* 10152 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI16_V_MF2_M2 /* 10153 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI16_V_MF2_M2_MASK /* 10154 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI16_V_MF2_MF2 /* 10155 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI16_V_MF2_MF2_MASK /* 10156 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI16_V_MF2_MF4 /* 10157 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI16_V_MF2_MF4_MASK /* 10158 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI16_V_MF4_M1 /* 10159 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI16_V_MF4_M1_MASK /* 10160 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI16_V_MF4_MF2 /* 10161 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI16_V_MF4_MF2_MASK /* 10162 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI16_V_MF4_MF4 /* 10163 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI16_V_MF4_MF4_MASK /* 10164 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI16_V_MF4_MF8 /* 10165 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI16_V_MF4_MF8_MASK /* 10166 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI32_V_M1_M1 /* 10167 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI32_V_M1_M1_MASK /* 10168 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI32_V_M1_M2 /* 10169 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI32_V_M1_M2_MASK /* 10170 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI32_V_M1_MF2 /* 10171 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI32_V_M1_MF2_MASK /* 10172 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI32_V_M1_MF4 /* 10173 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI32_V_M1_MF4_MASK /* 10174 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI32_V_M2_M1 /* 10175 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI32_V_M2_M1_MASK /* 10176 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI32_V_M2_M2 /* 10177 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI32_V_M2_M2_MASK /* 10178 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI32_V_M2_MF2 /* 10179 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI32_V_M2_MF2_MASK /* 10180 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI32_V_M4_M1 /* 10181 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI32_V_M4_M1_MASK /* 10182 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI32_V_M4_M2 /* 10183 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI32_V_M4_M2_MASK /* 10184 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI32_V_M8_M2 /* 10185 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI32_V_M8_M2_MASK /* 10186 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI32_V_MF2_M1 /* 10187 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI32_V_MF2_M1_MASK /* 10188 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI32_V_MF2_MF2 /* 10189 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI32_V_MF2_MF2_MASK /* 10190 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI32_V_MF2_MF4 /* 10191 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI32_V_MF2_MF4_MASK /* 10192 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI32_V_MF2_MF8 /* 10193 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI32_V_MF2_MF8_MASK /* 10194 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI64_V_M1_M1 /* 10195 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI64_V_M1_M1_MASK /* 10196 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI64_V_M1_MF2 /* 10197 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI64_V_M1_MF2_MASK /* 10198 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI64_V_M1_MF4 /* 10199 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI64_V_M1_MF4_MASK /* 10200 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI64_V_M1_MF8 /* 10201 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI64_V_M1_MF8_MASK /* 10202 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI64_V_M2_M1 /* 10203 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI64_V_M2_M1_MASK /* 10204 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI64_V_M2_M2 /* 10205 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI64_V_M2_M2_MASK /* 10206 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI64_V_M2_MF2 /* 10207 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI64_V_M2_MF2_MASK /* 10208 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI64_V_M2_MF4 /* 10209 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI64_V_M2_MF4_MASK /* 10210 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI64_V_M4_M1 /* 10211 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI64_V_M4_M1_MASK /* 10212 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI64_V_M4_M2 /* 10213 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI64_V_M4_M2_MASK /* 10214 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI64_V_M4_MF2 /* 10215 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI64_V_M4_MF2_MASK /* 10216 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI64_V_M8_M1 /* 10217 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI64_V_M8_M1_MASK /* 10218 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI64_V_M8_M2 /* 10219 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI64_V_M8_M2_MASK /* 10220 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI8_V_M1_M1 /* 10221 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI8_V_M1_M1_MASK /* 10222 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI8_V_M1_M2 /* 10223 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI8_V_M1_M2_MASK /* 10224 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI8_V_M2_M2 /* 10225 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI8_V_M2_M2_MASK /* 10226 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI8_V_MF2_M1 /* 10227 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI8_V_MF2_M1_MASK /* 10228 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI8_V_MF2_M2 /* 10229 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI8_V_MF2_M2_MASK /* 10230 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI8_V_MF2_MF2 /* 10231 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI8_V_MF2_MF2_MASK /* 10232 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI8_V_MF4_M1 /* 10233 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI8_V_MF4_M1_MASK /* 10234 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI8_V_MF4_M2 /* 10235 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI8_V_MF4_M2_MASK /* 10236 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI8_V_MF4_MF2 /* 10237 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI8_V_MF4_MF2_MASK /* 10238 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI8_V_MF4_MF4 /* 10239 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI8_V_MF4_MF4_MASK /* 10240 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI8_V_MF8_M1 /* 10241 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI8_V_MF8_M1_MASK /* 10242 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI8_V_MF8_MF2 /* 10243 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI8_V_MF8_MF2_MASK /* 10244 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI8_V_MF8_MF4 /* 10245 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI8_V_MF8_MF4_MASK /* 10246 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI8_V_MF8_MF8 /* 10247 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG3EI8_V_MF8_MF8_MASK /* 10248 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI16_V_M1_M1 /* 10249 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI16_V_M1_M1_MASK /* 10250 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI16_V_M1_M2 /* 10251 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI16_V_M1_M2_MASK /* 10252 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI16_V_M1_MF2 /* 10253 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI16_V_M1_MF2_MASK /* 10254 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI16_V_M2_M1 /* 10255 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI16_V_M2_M1_MASK /* 10256 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI16_V_M2_M2 /* 10257 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI16_V_M2_M2_MASK /* 10258 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI16_V_M4_M2 /* 10259 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI16_V_M4_M2_MASK /* 10260 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI16_V_MF2_M1 /* 10261 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI16_V_MF2_M1_MASK /* 10262 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI16_V_MF2_M2 /* 10263 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI16_V_MF2_M2_MASK /* 10264 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI16_V_MF2_MF2 /* 10265 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI16_V_MF2_MF2_MASK /* 10266 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI16_V_MF2_MF4 /* 10267 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI16_V_MF2_MF4_MASK /* 10268 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI16_V_MF4_M1 /* 10269 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI16_V_MF4_M1_MASK /* 10270 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI16_V_MF4_MF2 /* 10271 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI16_V_MF4_MF2_MASK /* 10272 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI16_V_MF4_MF4 /* 10273 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI16_V_MF4_MF4_MASK /* 10274 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI16_V_MF4_MF8 /* 10275 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI16_V_MF4_MF8_MASK /* 10276 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI32_V_M1_M1 /* 10277 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI32_V_M1_M1_MASK /* 10278 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI32_V_M1_M2 /* 10279 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI32_V_M1_M2_MASK /* 10280 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI32_V_M1_MF2 /* 10281 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI32_V_M1_MF2_MASK /* 10282 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI32_V_M1_MF4 /* 10283 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI32_V_M1_MF4_MASK /* 10284 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI32_V_M2_M1 /* 10285 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI32_V_M2_M1_MASK /* 10286 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI32_V_M2_M2 /* 10287 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI32_V_M2_M2_MASK /* 10288 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI32_V_M2_MF2 /* 10289 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI32_V_M2_MF2_MASK /* 10290 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI32_V_M4_M1 /* 10291 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI32_V_M4_M1_MASK /* 10292 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI32_V_M4_M2 /* 10293 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI32_V_M4_M2_MASK /* 10294 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI32_V_M8_M2 /* 10295 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI32_V_M8_M2_MASK /* 10296 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI32_V_MF2_M1 /* 10297 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI32_V_MF2_M1_MASK /* 10298 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI32_V_MF2_MF2 /* 10299 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI32_V_MF2_MF2_MASK /* 10300 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI32_V_MF2_MF4 /* 10301 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI32_V_MF2_MF4_MASK /* 10302 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI32_V_MF2_MF8 /* 10303 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI32_V_MF2_MF8_MASK /* 10304 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI64_V_M1_M1 /* 10305 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI64_V_M1_M1_MASK /* 10306 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI64_V_M1_MF2 /* 10307 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI64_V_M1_MF2_MASK /* 10308 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI64_V_M1_MF4 /* 10309 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI64_V_M1_MF4_MASK /* 10310 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI64_V_M1_MF8 /* 10311 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI64_V_M1_MF8_MASK /* 10312 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI64_V_M2_M1 /* 10313 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI64_V_M2_M1_MASK /* 10314 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI64_V_M2_M2 /* 10315 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI64_V_M2_M2_MASK /* 10316 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI64_V_M2_MF2 /* 10317 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI64_V_M2_MF2_MASK /* 10318 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI64_V_M2_MF4 /* 10319 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI64_V_M2_MF4_MASK /* 10320 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI64_V_M4_M1 /* 10321 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI64_V_M4_M1_MASK /* 10322 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI64_V_M4_M2 /* 10323 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI64_V_M4_M2_MASK /* 10324 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI64_V_M4_MF2 /* 10325 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI64_V_M4_MF2_MASK /* 10326 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI64_V_M8_M1 /* 10327 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI64_V_M8_M1_MASK /* 10328 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI64_V_M8_M2 /* 10329 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI64_V_M8_M2_MASK /* 10330 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI8_V_M1_M1 /* 10331 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI8_V_M1_M1_MASK /* 10332 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI8_V_M1_M2 /* 10333 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI8_V_M1_M2_MASK /* 10334 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI8_V_M2_M2 /* 10335 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI8_V_M2_M2_MASK /* 10336 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI8_V_MF2_M1 /* 10337 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI8_V_MF2_M1_MASK /* 10338 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI8_V_MF2_M2 /* 10339 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI8_V_MF2_M2_MASK /* 10340 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI8_V_MF2_MF2 /* 10341 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI8_V_MF2_MF2_MASK /* 10342 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI8_V_MF4_M1 /* 10343 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI8_V_MF4_M1_MASK /* 10344 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI8_V_MF4_M2 /* 10345 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI8_V_MF4_M2_MASK /* 10346 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI8_V_MF4_MF2 /* 10347 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI8_V_MF4_MF2_MASK /* 10348 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI8_V_MF4_MF4 /* 10349 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI8_V_MF4_MF4_MASK /* 10350 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI8_V_MF8_M1 /* 10351 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI8_V_MF8_M1_MASK /* 10352 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI8_V_MF8_MF2 /* 10353 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI8_V_MF8_MF2_MASK /* 10354 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI8_V_MF8_MF4 /* 10355 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI8_V_MF8_MF4_MASK /* 10356 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI8_V_MF8_MF8 /* 10357 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG4EI8_V_MF8_MF8_MASK /* 10358 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI16_V_M1_M1 /* 10359 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI16_V_M1_M1_MASK /* 10360 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI16_V_M1_MF2 /* 10361 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI16_V_M1_MF2_MASK /* 10362 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI16_V_M2_M1 /* 10363 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI16_V_M2_M1_MASK /* 10364 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI16_V_MF2_M1 /* 10365 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI16_V_MF2_M1_MASK /* 10366 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI16_V_MF2_MF2 /* 10367 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI16_V_MF2_MF2_MASK /* 10368 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI16_V_MF2_MF4 /* 10369 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI16_V_MF2_MF4_MASK /* 10370 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI16_V_MF4_M1 /* 10371 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI16_V_MF4_M1_MASK /* 10372 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI16_V_MF4_MF2 /* 10373 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI16_V_MF4_MF2_MASK /* 10374 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI16_V_MF4_MF4 /* 10375 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI16_V_MF4_MF4_MASK /* 10376 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI16_V_MF4_MF8 /* 10377 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI16_V_MF4_MF8_MASK /* 10378 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI32_V_M1_M1 /* 10379 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI32_V_M1_M1_MASK /* 10380 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI32_V_M1_MF2 /* 10381 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI32_V_M1_MF2_MASK /* 10382 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI32_V_M1_MF4 /* 10383 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI32_V_M1_MF4_MASK /* 10384 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI32_V_M2_M1 /* 10385 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI32_V_M2_M1_MASK /* 10386 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI32_V_M2_MF2 /* 10387 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI32_V_M2_MF2_MASK /* 10388 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI32_V_M4_M1 /* 10389 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI32_V_M4_M1_MASK /* 10390 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI32_V_MF2_M1 /* 10391 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI32_V_MF2_M1_MASK /* 10392 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI32_V_MF2_MF2 /* 10393 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI32_V_MF2_MF2_MASK /* 10394 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI32_V_MF2_MF4 /* 10395 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI32_V_MF2_MF4_MASK /* 10396 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI32_V_MF2_MF8 /* 10397 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI32_V_MF2_MF8_MASK /* 10398 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI64_V_M1_M1 /* 10399 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI64_V_M1_M1_MASK /* 10400 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI64_V_M1_MF2 /* 10401 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI64_V_M1_MF2_MASK /* 10402 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI64_V_M1_MF4 /* 10403 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI64_V_M1_MF4_MASK /* 10404 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI64_V_M1_MF8 /* 10405 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI64_V_M1_MF8_MASK /* 10406 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI64_V_M2_M1 /* 10407 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI64_V_M2_M1_MASK /* 10408 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI64_V_M2_MF2 /* 10409 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI64_V_M2_MF2_MASK /* 10410 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI64_V_M2_MF4 /* 10411 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI64_V_M2_MF4_MASK /* 10412 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI64_V_M4_M1 /* 10413 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI64_V_M4_M1_MASK /* 10414 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI64_V_M4_MF2 /* 10415 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI64_V_M4_MF2_MASK /* 10416 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI64_V_M8_M1 /* 10417 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI64_V_M8_M1_MASK /* 10418 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI8_V_M1_M1 /* 10419 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI8_V_M1_M1_MASK /* 10420 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI8_V_MF2_M1 /* 10421 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI8_V_MF2_M1_MASK /* 10422 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI8_V_MF2_MF2 /* 10423 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI8_V_MF2_MF2_MASK /* 10424 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI8_V_MF4_M1 /* 10425 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI8_V_MF4_M1_MASK /* 10426 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI8_V_MF4_MF2 /* 10427 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI8_V_MF4_MF2_MASK /* 10428 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI8_V_MF4_MF4 /* 10429 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI8_V_MF4_MF4_MASK /* 10430 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI8_V_MF8_M1 /* 10431 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI8_V_MF8_M1_MASK /* 10432 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI8_V_MF8_MF2 /* 10433 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI8_V_MF8_MF2_MASK /* 10434 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI8_V_MF8_MF4 /* 10435 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI8_V_MF8_MF4_MASK /* 10436 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI8_V_MF8_MF8 /* 10437 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG5EI8_V_MF8_MF8_MASK /* 10438 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI16_V_M1_M1 /* 10439 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI16_V_M1_M1_MASK /* 10440 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI16_V_M1_MF2 /* 10441 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI16_V_M1_MF2_MASK /* 10442 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI16_V_M2_M1 /* 10443 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI16_V_M2_M1_MASK /* 10444 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI16_V_MF2_M1 /* 10445 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI16_V_MF2_M1_MASK /* 10446 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI16_V_MF2_MF2 /* 10447 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI16_V_MF2_MF2_MASK /* 10448 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI16_V_MF2_MF4 /* 10449 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI16_V_MF2_MF4_MASK /* 10450 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI16_V_MF4_M1 /* 10451 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI16_V_MF4_M1_MASK /* 10452 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI16_V_MF4_MF2 /* 10453 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI16_V_MF4_MF2_MASK /* 10454 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI16_V_MF4_MF4 /* 10455 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI16_V_MF4_MF4_MASK /* 10456 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI16_V_MF4_MF8 /* 10457 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI16_V_MF4_MF8_MASK /* 10458 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI32_V_M1_M1 /* 10459 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI32_V_M1_M1_MASK /* 10460 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI32_V_M1_MF2 /* 10461 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI32_V_M1_MF2_MASK /* 10462 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI32_V_M1_MF4 /* 10463 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI32_V_M1_MF4_MASK /* 10464 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI32_V_M2_M1 /* 10465 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI32_V_M2_M1_MASK /* 10466 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI32_V_M2_MF2 /* 10467 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI32_V_M2_MF2_MASK /* 10468 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI32_V_M4_M1 /* 10469 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI32_V_M4_M1_MASK /* 10470 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI32_V_MF2_M1 /* 10471 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI32_V_MF2_M1_MASK /* 10472 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI32_V_MF2_MF2 /* 10473 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI32_V_MF2_MF2_MASK /* 10474 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI32_V_MF2_MF4 /* 10475 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI32_V_MF2_MF4_MASK /* 10476 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI32_V_MF2_MF8 /* 10477 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI32_V_MF2_MF8_MASK /* 10478 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI64_V_M1_M1 /* 10479 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI64_V_M1_M1_MASK /* 10480 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI64_V_M1_MF2 /* 10481 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI64_V_M1_MF2_MASK /* 10482 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI64_V_M1_MF4 /* 10483 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI64_V_M1_MF4_MASK /* 10484 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI64_V_M1_MF8 /* 10485 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI64_V_M1_MF8_MASK /* 10486 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI64_V_M2_M1 /* 10487 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI64_V_M2_M1_MASK /* 10488 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI64_V_M2_MF2 /* 10489 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI64_V_M2_MF2_MASK /* 10490 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI64_V_M2_MF4 /* 10491 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI64_V_M2_MF4_MASK /* 10492 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI64_V_M4_M1 /* 10493 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI64_V_M4_M1_MASK /* 10494 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI64_V_M4_MF2 /* 10495 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI64_V_M4_MF2_MASK /* 10496 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI64_V_M8_M1 /* 10497 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI64_V_M8_M1_MASK /* 10498 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI8_V_M1_M1 /* 10499 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI8_V_M1_M1_MASK /* 10500 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI8_V_MF2_M1 /* 10501 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI8_V_MF2_M1_MASK /* 10502 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI8_V_MF2_MF2 /* 10503 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI8_V_MF2_MF2_MASK /* 10504 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI8_V_MF4_M1 /* 10505 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI8_V_MF4_M1_MASK /* 10506 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI8_V_MF4_MF2 /* 10507 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI8_V_MF4_MF2_MASK /* 10508 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI8_V_MF4_MF4 /* 10509 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI8_V_MF4_MF4_MASK /* 10510 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI8_V_MF8_M1 /* 10511 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI8_V_MF8_M1_MASK /* 10512 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI8_V_MF8_MF2 /* 10513 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI8_V_MF8_MF2_MASK /* 10514 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI8_V_MF8_MF4 /* 10515 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI8_V_MF8_MF4_MASK /* 10516 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI8_V_MF8_MF8 /* 10517 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG6EI8_V_MF8_MF8_MASK /* 10518 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI16_V_M1_M1 /* 10519 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI16_V_M1_M1_MASK /* 10520 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI16_V_M1_MF2 /* 10521 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI16_V_M1_MF2_MASK /* 10522 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI16_V_M2_M1 /* 10523 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI16_V_M2_M1_MASK /* 10524 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI16_V_MF2_M1 /* 10525 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI16_V_MF2_M1_MASK /* 10526 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI16_V_MF2_MF2 /* 10527 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI16_V_MF2_MF2_MASK /* 10528 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI16_V_MF2_MF4 /* 10529 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI16_V_MF2_MF4_MASK /* 10530 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI16_V_MF4_M1 /* 10531 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI16_V_MF4_M1_MASK /* 10532 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI16_V_MF4_MF2 /* 10533 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI16_V_MF4_MF2_MASK /* 10534 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI16_V_MF4_MF4 /* 10535 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI16_V_MF4_MF4_MASK /* 10536 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI16_V_MF4_MF8 /* 10537 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI16_V_MF4_MF8_MASK /* 10538 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI32_V_M1_M1 /* 10539 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI32_V_M1_M1_MASK /* 10540 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI32_V_M1_MF2 /* 10541 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI32_V_M1_MF2_MASK /* 10542 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI32_V_M1_MF4 /* 10543 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI32_V_M1_MF4_MASK /* 10544 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI32_V_M2_M1 /* 10545 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI32_V_M2_M1_MASK /* 10546 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI32_V_M2_MF2 /* 10547 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI32_V_M2_MF2_MASK /* 10548 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI32_V_M4_M1 /* 10549 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI32_V_M4_M1_MASK /* 10550 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI32_V_MF2_M1 /* 10551 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI32_V_MF2_M1_MASK /* 10552 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI32_V_MF2_MF2 /* 10553 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI32_V_MF2_MF2_MASK /* 10554 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI32_V_MF2_MF4 /* 10555 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI32_V_MF2_MF4_MASK /* 10556 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI32_V_MF2_MF8 /* 10557 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI32_V_MF2_MF8_MASK /* 10558 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI64_V_M1_M1 /* 10559 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI64_V_M1_M1_MASK /* 10560 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI64_V_M1_MF2 /* 10561 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI64_V_M1_MF2_MASK /* 10562 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI64_V_M1_MF4 /* 10563 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI64_V_M1_MF4_MASK /* 10564 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI64_V_M1_MF8 /* 10565 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI64_V_M1_MF8_MASK /* 10566 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI64_V_M2_M1 /* 10567 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI64_V_M2_M1_MASK /* 10568 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI64_V_M2_MF2 /* 10569 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI64_V_M2_MF2_MASK /* 10570 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI64_V_M2_MF4 /* 10571 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI64_V_M2_MF4_MASK /* 10572 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI64_V_M4_M1 /* 10573 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI64_V_M4_M1_MASK /* 10574 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI64_V_M4_MF2 /* 10575 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI64_V_M4_MF2_MASK /* 10576 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI64_V_M8_M1 /* 10577 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI64_V_M8_M1_MASK /* 10578 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI8_V_M1_M1 /* 10579 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI8_V_M1_M1_MASK /* 10580 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI8_V_MF2_M1 /* 10581 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI8_V_MF2_M1_MASK /* 10582 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI8_V_MF2_MF2 /* 10583 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI8_V_MF2_MF2_MASK /* 10584 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI8_V_MF4_M1 /* 10585 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI8_V_MF4_M1_MASK /* 10586 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI8_V_MF4_MF2 /* 10587 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI8_V_MF4_MF2_MASK /* 10588 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI8_V_MF4_MF4 /* 10589 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI8_V_MF4_MF4_MASK /* 10590 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI8_V_MF8_M1 /* 10591 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI8_V_MF8_M1_MASK /* 10592 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI8_V_MF8_MF2 /* 10593 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI8_V_MF8_MF2_MASK /* 10594 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI8_V_MF8_MF4 /* 10595 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI8_V_MF8_MF4_MASK /* 10596 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI8_V_MF8_MF8 /* 10597 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG7EI8_V_MF8_MF8_MASK /* 10598 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI16_V_M1_M1 /* 10599 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI16_V_M1_M1_MASK /* 10600 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI16_V_M1_MF2 /* 10601 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI16_V_M1_MF2_MASK /* 10602 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI16_V_M2_M1 /* 10603 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI16_V_M2_M1_MASK /* 10604 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI16_V_MF2_M1 /* 10605 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI16_V_MF2_M1_MASK /* 10606 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI16_V_MF2_MF2 /* 10607 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI16_V_MF2_MF2_MASK /* 10608 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI16_V_MF2_MF4 /* 10609 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI16_V_MF2_MF4_MASK /* 10610 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI16_V_MF4_M1 /* 10611 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI16_V_MF4_M1_MASK /* 10612 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI16_V_MF4_MF2 /* 10613 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI16_V_MF4_MF2_MASK /* 10614 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI16_V_MF4_MF4 /* 10615 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI16_V_MF4_MF4_MASK /* 10616 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI16_V_MF4_MF8 /* 10617 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI16_V_MF4_MF8_MASK /* 10618 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI32_V_M1_M1 /* 10619 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI32_V_M1_M1_MASK /* 10620 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI32_V_M1_MF2 /* 10621 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI32_V_M1_MF2_MASK /* 10622 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI32_V_M1_MF4 /* 10623 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI32_V_M1_MF4_MASK /* 10624 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI32_V_M2_M1 /* 10625 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI32_V_M2_M1_MASK /* 10626 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI32_V_M2_MF2 /* 10627 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI32_V_M2_MF2_MASK /* 10628 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI32_V_M4_M1 /* 10629 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI32_V_M4_M1_MASK /* 10630 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI32_V_MF2_M1 /* 10631 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI32_V_MF2_M1_MASK /* 10632 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI32_V_MF2_MF2 /* 10633 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI32_V_MF2_MF2_MASK /* 10634 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI32_V_MF2_MF4 /* 10635 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI32_V_MF2_MF4_MASK /* 10636 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI32_V_MF2_MF8 /* 10637 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI32_V_MF2_MF8_MASK /* 10638 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI64_V_M1_M1 /* 10639 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI64_V_M1_M1_MASK /* 10640 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI64_V_M1_MF2 /* 10641 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI64_V_M1_MF2_MASK /* 10642 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI64_V_M1_MF4 /* 10643 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI64_V_M1_MF4_MASK /* 10644 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI64_V_M1_MF8 /* 10645 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI64_V_M1_MF8_MASK /* 10646 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI64_V_M2_M1 /* 10647 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI64_V_M2_M1_MASK /* 10648 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI64_V_M2_MF2 /* 10649 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI64_V_M2_MF2_MASK /* 10650 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI64_V_M2_MF4 /* 10651 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI64_V_M2_MF4_MASK /* 10652 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI64_V_M4_M1 /* 10653 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI64_V_M4_M1_MASK /* 10654 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI64_V_M4_MF2 /* 10655 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI64_V_M4_MF2_MASK /* 10656 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI64_V_M8_M1 /* 10657 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI64_V_M8_M1_MASK /* 10658 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI8_V_M1_M1 /* 10659 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI8_V_M1_M1_MASK /* 10660 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI8_V_MF2_M1 /* 10661 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI8_V_MF2_M1_MASK /* 10662 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI8_V_MF2_MF2 /* 10663 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI8_V_MF2_MF2_MASK /* 10664 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI8_V_MF4_M1 /* 10665 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI8_V_MF4_M1_MASK /* 10666 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI8_V_MF4_MF2 /* 10667 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI8_V_MF4_MF2_MASK /* 10668 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI8_V_MF4_MF4 /* 10669 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI8_V_MF4_MF4_MASK /* 10670 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI8_V_MF8_M1 /* 10671 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI8_V_MF8_M1_MASK /* 10672 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI8_V_MF8_MF2 /* 10673 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI8_V_MF8_MF2_MASK /* 10674 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI8_V_MF8_MF4 /* 10675 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI8_V_MF8_MF4_MASK /* 10676 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI8_V_MF8_MF8 /* 10677 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVSUXSEG8EI8_V_MF8_MF8_MASK /* 10678 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_VV_M1 /* 10679 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_VV_M1_MASK /* 10680 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_VV_M2 /* 10681 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_VV_M2_MASK /* 10682 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_VV_M4 /* 10683 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_VV_M4_MASK /* 10684 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_VV_MF2 /* 10685 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_VV_MF2_MASK /* 10686 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_VV_MF4 /* 10687 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_VV_MF4_MASK /* 10688 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_VV_MF8 /* 10689 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_VV_MF8_MASK /* 10690 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_VX_M1 /* 10691 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_VX_M1_MASK /* 10692 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_VX_M2 /* 10693 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_VX_M2_MASK /* 10694 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_VX_M4 /* 10695 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_VX_M4_MASK /* 10696 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_VX_MF2 /* 10697 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_VX_MF2_MASK /* 10698 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_VX_MF4 /* 10699 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_VX_MF4_MASK /* 10700 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_VX_MF8 /* 10701 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_VX_MF8_MASK /* 10702 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_WV_M1 /* 10703 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_WV_M1_MASK /* 10704 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_WV_M1_MASK_TIED /* 10705 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_WV_M1_TIED /* 10706 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_WV_M2 /* 10707 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_WV_M2_MASK /* 10708 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_WV_M2_MASK_TIED /* 10709 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_WV_M2_TIED /* 10710 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_WV_M4 /* 10711 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_WV_M4_MASK /* 10712 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_WV_M4_MASK_TIED /* 10713 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_WV_M4_TIED /* 10714 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_WV_MF2 /* 10715 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_WV_MF2_MASK /* 10716 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_WV_MF2_MASK_TIED /* 10717 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_WV_MF2_TIED /* 10718 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_WV_MF4 /* 10719 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_WV_MF4_MASK /* 10720 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_WV_MF4_MASK_TIED /* 10721 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_WV_MF4_TIED /* 10722 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_WV_MF8 /* 10723 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_WV_MF8_MASK /* 10724 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_WV_MF8_MASK_TIED /* 10725 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_WV_MF8_TIED /* 10726 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_WX_M1 /* 10727 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_WX_M1_MASK /* 10728 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_WX_M2 /* 10729 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_WX_M2_MASK /* 10730 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_WX_M4 /* 10731 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_WX_M4_MASK /* 10732 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_WX_MF2 /* 10733 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_WX_MF2_MASK /* 10734 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_WX_MF4 /* 10735 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_WX_MF4_MASK /* 10736 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_WX_MF8 /* 10737 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADDU_WX_MF8_MASK /* 10738 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_VV_M1 /* 10739 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_VV_M1_MASK /* 10740 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_VV_M2 /* 10741 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_VV_M2_MASK /* 10742 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_VV_M4 /* 10743 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_VV_M4_MASK /* 10744 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_VV_MF2 /* 10745 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_VV_MF2_MASK /* 10746 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_VV_MF4 /* 10747 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_VV_MF4_MASK /* 10748 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_VV_MF8 /* 10749 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_VV_MF8_MASK /* 10750 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_VX_M1 /* 10751 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_VX_M1_MASK /* 10752 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_VX_M2 /* 10753 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_VX_M2_MASK /* 10754 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_VX_M4 /* 10755 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_VX_M4_MASK /* 10756 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_VX_MF2 /* 10757 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_VX_MF2_MASK /* 10758 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_VX_MF4 /* 10759 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_VX_MF4_MASK /* 10760 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_VX_MF8 /* 10761 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_VX_MF8_MASK /* 10762 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_WV_M1 /* 10763 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_WV_M1_MASK /* 10764 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_WV_M1_MASK_TIED /* 10765 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_WV_M1_TIED /* 10766 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_WV_M2 /* 10767 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_WV_M2_MASK /* 10768 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_WV_M2_MASK_TIED /* 10769 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_WV_M2_TIED /* 10770 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_WV_M4 /* 10771 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_WV_M4_MASK /* 10772 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_WV_M4_MASK_TIED /* 10773 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_WV_M4_TIED /* 10774 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_WV_MF2 /* 10775 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_WV_MF2_MASK /* 10776 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_WV_MF2_MASK_TIED /* 10777 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_WV_MF2_TIED /* 10778 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_WV_MF4 /* 10779 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_WV_MF4_MASK /* 10780 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_WV_MF4_MASK_TIED /* 10781 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_WV_MF4_TIED /* 10782 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_WV_MF8 /* 10783 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_WV_MF8_MASK /* 10784 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_WV_MF8_MASK_TIED /* 10785 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_WV_MF8_TIED /* 10786 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_WX_M1 /* 10787 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_WX_M1_MASK /* 10788 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_WX_M2 /* 10789 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_WX_M2_MASK /* 10790 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_WX_M4 /* 10791 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_WX_M4_MASK /* 10792 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_WX_MF2 /* 10793 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_WX_MF2_MASK /* 10794 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_WX_MF4 /* 10795 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_WX_MF4_MASK /* 10796 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_WX_MF8 /* 10797 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWADD_WX_MF8_MASK /* 10798 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCSU_VV_M1 /* 10799 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCSU_VV_M1_MASK /* 10800 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCSU_VV_M2 /* 10801 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCSU_VV_M2_MASK /* 10802 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCSU_VV_M4 /* 10803 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCSU_VV_M4_MASK /* 10804 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCSU_VV_MF2 /* 10805 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCSU_VV_MF2_MASK /* 10806 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCSU_VV_MF4 /* 10807 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCSU_VV_MF4_MASK /* 10808 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCSU_VV_MF8 /* 10809 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCSU_VV_MF8_MASK /* 10810 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCSU_VX_M1 /* 10811 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCSU_VX_M1_MASK /* 10812 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCSU_VX_M2 /* 10813 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCSU_VX_M2_MASK /* 10814 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCSU_VX_M4 /* 10815 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCSU_VX_M4_MASK /* 10816 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCSU_VX_MF2 /* 10817 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCSU_VX_MF2_MASK /* 10818 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCSU_VX_MF4 /* 10819 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCSU_VX_MF4_MASK /* 10820 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCSU_VX_MF8 /* 10821 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCSU_VX_MF8_MASK /* 10822 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCUS_VX_M1 /* 10823 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCUS_VX_M1_MASK /* 10824 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCUS_VX_M2 /* 10825 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCUS_VX_M2_MASK /* 10826 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCUS_VX_M4 /* 10827 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCUS_VX_M4_MASK /* 10828 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCUS_VX_MF2 /* 10829 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCUS_VX_MF2_MASK /* 10830 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCUS_VX_MF4 /* 10831 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCUS_VX_MF4_MASK /* 10832 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCUS_VX_MF8 /* 10833 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCUS_VX_MF8_MASK /* 10834 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCU_VV_M1 /* 10835 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCU_VV_M1_MASK /* 10836 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCU_VV_M2 /* 10837 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCU_VV_M2_MASK /* 10838 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCU_VV_M4 /* 10839 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCU_VV_M4_MASK /* 10840 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCU_VV_MF2 /* 10841 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCU_VV_MF2_MASK /* 10842 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCU_VV_MF4 /* 10843 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCU_VV_MF4_MASK /* 10844 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCU_VV_MF8 /* 10845 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCU_VV_MF8_MASK /* 10846 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCU_VX_M1 /* 10847 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCU_VX_M1_MASK /* 10848 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCU_VX_M2 /* 10849 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCU_VX_M2_MASK /* 10850 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCU_VX_M4 /* 10851 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCU_VX_M4_MASK /* 10852 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCU_VX_MF2 /* 10853 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCU_VX_MF2_MASK /* 10854 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCU_VX_MF4 /* 10855 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCU_VX_MF4_MASK /* 10856 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCU_VX_MF8 /* 10857 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACCU_VX_MF8_MASK /* 10858 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACC_VV_M1 /* 10859 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACC_VV_M1_MASK /* 10860 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACC_VV_M2 /* 10861 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACC_VV_M2_MASK /* 10862 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACC_VV_M4 /* 10863 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACC_VV_M4_MASK /* 10864 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACC_VV_MF2 /* 10865 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACC_VV_MF2_MASK /* 10866 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACC_VV_MF4 /* 10867 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACC_VV_MF4_MASK /* 10868 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACC_VV_MF8 /* 10869 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACC_VV_MF8_MASK /* 10870 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACC_VX_M1 /* 10871 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACC_VX_M1_MASK /* 10872 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACC_VX_M2 /* 10873 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACC_VX_M2_MASK /* 10874 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACC_VX_M4 /* 10875 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACC_VX_M4_MASK /* 10876 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACC_VX_MF2 /* 10877 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACC_VX_MF2_MASK /* 10878 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACC_VX_MF4 /* 10879 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACC_VX_MF4_MASK /* 10880 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACC_VX_MF8 /* 10881 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMACC_VX_MF8_MASK /* 10882 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMULSU_VV_M1 /* 10883 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMULSU_VV_M1_MASK /* 10884 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMULSU_VV_M2 /* 10885 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMULSU_VV_M2_MASK /* 10886 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMULSU_VV_M4 /* 10887 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMULSU_VV_M4_MASK /* 10888 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMULSU_VV_MF2 /* 10889 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMULSU_VV_MF2_MASK /* 10890 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMULSU_VV_MF4 /* 10891 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMULSU_VV_MF4_MASK /* 10892 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMULSU_VV_MF8 /* 10893 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMULSU_VV_MF8_MASK /* 10894 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMULSU_VX_M1 /* 10895 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMULSU_VX_M1_MASK /* 10896 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMULSU_VX_M2 /* 10897 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMULSU_VX_M2_MASK /* 10898 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMULSU_VX_M4 /* 10899 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMULSU_VX_M4_MASK /* 10900 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMULSU_VX_MF2 /* 10901 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMULSU_VX_MF2_MASK /* 10902 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMULSU_VX_MF4 /* 10903 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMULSU_VX_MF4_MASK /* 10904 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMULSU_VX_MF8 /* 10905 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMULSU_VX_MF8_MASK /* 10906 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMULU_VV_M1 /* 10907 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMULU_VV_M1_MASK /* 10908 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMULU_VV_M2 /* 10909 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMULU_VV_M2_MASK /* 10910 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMULU_VV_M4 /* 10911 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMULU_VV_M4_MASK /* 10912 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMULU_VV_MF2 /* 10913 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMULU_VV_MF2_MASK /* 10914 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMULU_VV_MF4 /* 10915 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMULU_VV_MF4_MASK /* 10916 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMULU_VV_MF8 /* 10917 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMULU_VV_MF8_MASK /* 10918 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMULU_VX_M1 /* 10919 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMULU_VX_M1_MASK /* 10920 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMULU_VX_M2 /* 10921 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMULU_VX_M2_MASK /* 10922 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMULU_VX_M4 /* 10923 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMULU_VX_M4_MASK /* 10924 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMULU_VX_MF2 /* 10925 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMULU_VX_MF2_MASK /* 10926 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMULU_VX_MF4 /* 10927 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMULU_VX_MF4_MASK /* 10928 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMULU_VX_MF8 /* 10929 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMULU_VX_MF8_MASK /* 10930 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMUL_VV_M1 /* 10931 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMUL_VV_M1_MASK /* 10932 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMUL_VV_M2 /* 10933 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMUL_VV_M2_MASK /* 10934 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMUL_VV_M4 /* 10935 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMUL_VV_M4_MASK /* 10936 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMUL_VV_MF2 /* 10937 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMUL_VV_MF2_MASK /* 10938 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMUL_VV_MF4 /* 10939 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMUL_VV_MF4_MASK /* 10940 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMUL_VV_MF8 /* 10941 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMUL_VV_MF8_MASK /* 10942 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMUL_VX_M1 /* 10943 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMUL_VX_M1_MASK /* 10944 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMUL_VX_M2 /* 10945 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMUL_VX_M2_MASK /* 10946 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMUL_VX_M4 /* 10947 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMUL_VX_M4_MASK /* 10948 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMUL_VX_MF2 /* 10949 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMUL_VX_MF2_MASK /* 10950 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMUL_VX_MF4 /* 10951 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMUL_VX_MF4_MASK /* 10952 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMUL_VX_MF8 /* 10953 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWMUL_VX_MF8_MASK /* 10954 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUMU_VS_M1_E16 /* 10955 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUMU_VS_M1_E16_MASK /* 10956 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUMU_VS_M1_E32 /* 10957 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUMU_VS_M1_E32_MASK /* 10958 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUMU_VS_M1_E8 /* 10959 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUMU_VS_M1_E8_MASK /* 10960 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUMU_VS_M2_E16 /* 10961 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUMU_VS_M2_E16_MASK /* 10962 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUMU_VS_M2_E32 /* 10963 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUMU_VS_M2_E32_MASK /* 10964 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUMU_VS_M2_E8 /* 10965 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUMU_VS_M2_E8_MASK /* 10966 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUMU_VS_M4_E16 /* 10967 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUMU_VS_M4_E16_MASK /* 10968 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUMU_VS_M4_E32 /* 10969 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUMU_VS_M4_E32_MASK /* 10970 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUMU_VS_M4_E8 /* 10971 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUMU_VS_M4_E8_MASK /* 10972 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUMU_VS_M8_E16 /* 10973 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUMU_VS_M8_E16_MASK /* 10974 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUMU_VS_M8_E32 /* 10975 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUMU_VS_M8_E32_MASK /* 10976 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUMU_VS_M8_E8 /* 10977 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUMU_VS_M8_E8_MASK /* 10978 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUMU_VS_MF2_E16 /* 10979 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUMU_VS_MF2_E16_MASK /* 10980 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUMU_VS_MF2_E32 /* 10981 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUMU_VS_MF2_E32_MASK /* 10982 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUMU_VS_MF2_E8 /* 10983 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUMU_VS_MF2_E8_MASK /* 10984 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUMU_VS_MF4_E16 /* 10985 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUMU_VS_MF4_E16_MASK /* 10986 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUMU_VS_MF4_E8 /* 10987 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUMU_VS_MF4_E8_MASK /* 10988 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUMU_VS_MF8_E8 /* 10989 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUMU_VS_MF8_E8_MASK /* 10990 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUM_VS_M1_E16 /* 10991 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUM_VS_M1_E16_MASK /* 10992 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUM_VS_M1_E32 /* 10993 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUM_VS_M1_E32_MASK /* 10994 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUM_VS_M1_E8 /* 10995 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUM_VS_M1_E8_MASK /* 10996 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUM_VS_M2_E16 /* 10997 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUM_VS_M2_E16_MASK /* 10998 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUM_VS_M2_E32 /* 10999 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUM_VS_M2_E32_MASK /* 11000 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUM_VS_M2_E8 /* 11001 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUM_VS_M2_E8_MASK /* 11002 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUM_VS_M4_E16 /* 11003 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUM_VS_M4_E16_MASK /* 11004 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUM_VS_M4_E32 /* 11005 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUM_VS_M4_E32_MASK /* 11006 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUM_VS_M4_E8 /* 11007 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUM_VS_M4_E8_MASK /* 11008 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUM_VS_M8_E16 /* 11009 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUM_VS_M8_E16_MASK /* 11010 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUM_VS_M8_E32 /* 11011 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUM_VS_M8_E32_MASK /* 11012 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUM_VS_M8_E8 /* 11013 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUM_VS_M8_E8_MASK /* 11014 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUM_VS_MF2_E16 /* 11015 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUM_VS_MF2_E16_MASK /* 11016 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUM_VS_MF2_E32 /* 11017 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUM_VS_MF2_E32_MASK /* 11018 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUM_VS_MF2_E8 /* 11019 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUM_VS_MF2_E8_MASK /* 11020 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUM_VS_MF4_E16 /* 11021 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUM_VS_MF4_E16_MASK /* 11022 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUM_VS_MF4_E8 /* 11023 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUM_VS_MF4_E8_MASK /* 11024 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUM_VS_MF8_E8 /* 11025 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWREDSUM_VS_MF8_E8_MASK /* 11026 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSLL_VI_M1 /* 11027 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSLL_VI_M1_MASK /* 11028 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSLL_VI_M2 /* 11029 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSLL_VI_M2_MASK /* 11030 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSLL_VI_M4 /* 11031 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSLL_VI_M4_MASK /* 11032 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSLL_VI_MF2 /* 11033 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSLL_VI_MF2_MASK /* 11034 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSLL_VI_MF4 /* 11035 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSLL_VI_MF4_MASK /* 11036 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSLL_VI_MF8 /* 11037 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSLL_VI_MF8_MASK /* 11038 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSLL_VV_M1 /* 11039 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSLL_VV_M1_MASK /* 11040 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSLL_VV_M2 /* 11041 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSLL_VV_M2_MASK /* 11042 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSLL_VV_M4 /* 11043 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSLL_VV_M4_MASK /* 11044 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSLL_VV_MF2 /* 11045 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSLL_VV_MF2_MASK /* 11046 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSLL_VV_MF4 /* 11047 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSLL_VV_MF4_MASK /* 11048 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSLL_VV_MF8 /* 11049 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSLL_VV_MF8_MASK /* 11050 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSLL_VX_M1 /* 11051 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSLL_VX_M1_MASK /* 11052 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSLL_VX_M2 /* 11053 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSLL_VX_M2_MASK /* 11054 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSLL_VX_M4 /* 11055 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSLL_VX_M4_MASK /* 11056 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSLL_VX_MF2 /* 11057 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSLL_VX_MF2_MASK /* 11058 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSLL_VX_MF4 /* 11059 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSLL_VX_MF4_MASK /* 11060 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSLL_VX_MF8 /* 11061 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSLL_VX_MF8_MASK /* 11062 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_VV_M1 /* 11063 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_VV_M1_MASK /* 11064 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_VV_M2 /* 11065 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_VV_M2_MASK /* 11066 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_VV_M4 /* 11067 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_VV_M4_MASK /* 11068 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_VV_MF2 /* 11069 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_VV_MF2_MASK /* 11070 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_VV_MF4 /* 11071 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_VV_MF4_MASK /* 11072 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_VV_MF8 /* 11073 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_VV_MF8_MASK /* 11074 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_VX_M1 /* 11075 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_VX_M1_MASK /* 11076 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_VX_M2 /* 11077 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_VX_M2_MASK /* 11078 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_VX_M4 /* 11079 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_VX_M4_MASK /* 11080 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_VX_MF2 /* 11081 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_VX_MF2_MASK /* 11082 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_VX_MF4 /* 11083 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_VX_MF4_MASK /* 11084 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_VX_MF8 /* 11085 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_VX_MF8_MASK /* 11086 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_WV_M1 /* 11087 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_WV_M1_MASK /* 11088 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_WV_M1_MASK_TIED /* 11089 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_WV_M1_TIED /* 11090 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_WV_M2 /* 11091 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_WV_M2_MASK /* 11092 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_WV_M2_MASK_TIED /* 11093 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_WV_M2_TIED /* 11094 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_WV_M4 /* 11095 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_WV_M4_MASK /* 11096 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_WV_M4_MASK_TIED /* 11097 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_WV_M4_TIED /* 11098 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_WV_MF2 /* 11099 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_WV_MF2_MASK /* 11100 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_WV_MF2_MASK_TIED /* 11101 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_WV_MF2_TIED /* 11102 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_WV_MF4 /* 11103 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_WV_MF4_MASK /* 11104 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_WV_MF4_MASK_TIED /* 11105 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_WV_MF4_TIED /* 11106 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_WV_MF8 /* 11107 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_WV_MF8_MASK /* 11108 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_WV_MF8_MASK_TIED /* 11109 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_WV_MF8_TIED /* 11110 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_WX_M1 /* 11111 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_WX_M1_MASK /* 11112 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_WX_M2 /* 11113 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_WX_M2_MASK /* 11114 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_WX_M4 /* 11115 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_WX_M4_MASK /* 11116 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_WX_MF2 /* 11117 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_WX_MF2_MASK /* 11118 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_WX_MF4 /* 11119 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_WX_MF4_MASK /* 11120 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_WX_MF8 /* 11121 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUBU_WX_MF8_MASK /* 11122 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_VV_M1 /* 11123 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_VV_M1_MASK /* 11124 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_VV_M2 /* 11125 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_VV_M2_MASK /* 11126 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_VV_M4 /* 11127 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_VV_M4_MASK /* 11128 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_VV_MF2 /* 11129 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_VV_MF2_MASK /* 11130 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_VV_MF4 /* 11131 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_VV_MF4_MASK /* 11132 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_VV_MF8 /* 11133 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_VV_MF8_MASK /* 11134 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_VX_M1 /* 11135 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_VX_M1_MASK /* 11136 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_VX_M2 /* 11137 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_VX_M2_MASK /* 11138 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_VX_M4 /* 11139 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_VX_M4_MASK /* 11140 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_VX_MF2 /* 11141 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_VX_MF2_MASK /* 11142 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_VX_MF4 /* 11143 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_VX_MF4_MASK /* 11144 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_VX_MF8 /* 11145 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_VX_MF8_MASK /* 11146 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_WV_M1 /* 11147 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_WV_M1_MASK /* 11148 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_WV_M1_MASK_TIED /* 11149 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_WV_M1_TIED /* 11150 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_WV_M2 /* 11151 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_WV_M2_MASK /* 11152 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_WV_M2_MASK_TIED /* 11153 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_WV_M2_TIED /* 11154 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_WV_M4 /* 11155 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_WV_M4_MASK /* 11156 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_WV_M4_MASK_TIED /* 11157 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_WV_M4_TIED /* 11158 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_WV_MF2 /* 11159 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_WV_MF2_MASK /* 11160 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_WV_MF2_MASK_TIED /* 11161 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_WV_MF2_TIED /* 11162 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_WV_MF4 /* 11163 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_WV_MF4_MASK /* 11164 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_WV_MF4_MASK_TIED /* 11165 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_WV_MF4_TIED /* 11166 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_WV_MF8 /* 11167 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_WV_MF8_MASK /* 11168 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_WV_MF8_MASK_TIED /* 11169 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_WV_MF8_TIED /* 11170 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_WX_M1 /* 11171 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_WX_M1_MASK /* 11172 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_WX_M2 /* 11173 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_WX_M2_MASK /* 11174 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_WX_M4 /* 11175 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_WX_M4_MASK /* 11176 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_WX_MF2 /* 11177 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_WX_MF2_MASK /* 11178 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_WX_MF4 /* 11179 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_WX_MF4_MASK /* 11180 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_WX_MF8 /* 11181 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVWSUB_WX_MF8_MASK /* 11182 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVXOR_VI_M1 /* 11183 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVXOR_VI_M1_MASK /* 11184 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVXOR_VI_M2 /* 11185 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVXOR_VI_M2_MASK /* 11186 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVXOR_VI_M4 /* 11187 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVXOR_VI_M4_MASK /* 11188 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVXOR_VI_M8 /* 11189 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVXOR_VI_M8_MASK /* 11190 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVXOR_VI_MF2 /* 11191 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVXOR_VI_MF2_MASK /* 11192 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVXOR_VI_MF4 /* 11193 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVXOR_VI_MF4_MASK /* 11194 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVXOR_VI_MF8 /* 11195 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVXOR_VI_MF8_MASK /* 11196 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVXOR_VV_M1 /* 11197 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVXOR_VV_M1_MASK /* 11198 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVXOR_VV_M2 /* 11199 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVXOR_VV_M2_MASK /* 11200 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVXOR_VV_M4 /* 11201 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVXOR_VV_M4_MASK /* 11202 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVXOR_VV_M8 /* 11203 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVXOR_VV_M8_MASK /* 11204 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVXOR_VV_MF2 /* 11205 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVXOR_VV_MF2_MASK /* 11206 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVXOR_VV_MF4 /* 11207 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVXOR_VV_MF4_MASK /* 11208 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVXOR_VV_MF8 /* 11209 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVXOR_VV_MF8_MASK /* 11210 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVXOR_VX_M1 /* 11211 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVXOR_VX_M1_MASK /* 11212 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVXOR_VX_M2 /* 11213 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVXOR_VX_M2_MASK /* 11214 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVXOR_VX_M4 /* 11215 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVXOR_VX_M4_MASK /* 11216 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVXOR_VX_M8 /* 11217 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVXOR_VX_M8_MASK /* 11218 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVXOR_VX_MF2 /* 11219 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVXOR_VX_MF2_MASK /* 11220 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVXOR_VX_MF4 /* 11221 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVXOR_VX_MF4_MASK /* 11222 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVXOR_VX_MF8 /* 11223 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVXOR_VX_MF8_MASK /* 11224 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVZEXT_VF2_M1 /* 11225 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVZEXT_VF2_M1_MASK /* 11226 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVZEXT_VF2_M2 /* 11227 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVZEXT_VF2_M2_MASK /* 11228 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVZEXT_VF2_M4 /* 11229 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVZEXT_VF2_M4_MASK /* 11230 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVZEXT_VF2_M8 /* 11231 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVZEXT_VF2_M8_MASK /* 11232 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVZEXT_VF2_MF2 /* 11233 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVZEXT_VF2_MF2_MASK /* 11234 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVZEXT_VF2_MF4 /* 11235 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVZEXT_VF2_MF4_MASK /* 11236 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVZEXT_VF4_M1 /* 11237 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVZEXT_VF4_M1_MASK /* 11238 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVZEXT_VF4_M2 /* 11239 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVZEXT_VF4_M2_MASK /* 11240 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVZEXT_VF4_M4 /* 11241 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVZEXT_VF4_M4_MASK /* 11242 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVZEXT_VF4_M8 /* 11243 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVZEXT_VF4_M8_MASK /* 11244 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVZEXT_VF4_MF2 /* 11245 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVZEXT_VF4_MF2_MASK /* 11246 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVZEXT_VF8_M1 /* 11247 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVZEXT_VF8_M1_MASK /* 11248 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVZEXT_VF8_M2 /* 11249 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVZEXT_VF8_M2_MASK /* 11250 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVZEXT_VF8_M4 /* 11251 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVZEXT_VF8_M4_MASK /* 11252 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVZEXT_VF8_M8 /* 11253 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_PseudoVZEXT_VF8_M8_MASK /* 11254 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* zext.h $rd, $rs */ + RISCV_PseudoZEXT_H /* 11255 */, RISCV_INS_ZEXT_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* zext.w $rd, $rs */ + RISCV_PseudoZEXT_W /* 11256 */, RISCV_INS_ZEXT_W, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* */ + RISCV_ReadCycleWide /* 11257 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_ReadFFLAGS /* 11258 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_ReadFRM /* 11259 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_Select_FPR16INX_Using_CC_GPR /* 11260 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_Select_FPR16_Using_CC_GPR /* 11261 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_Select_FPR32INX_Using_CC_GPR /* 11262 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_Select_FPR32_Using_CC_GPR /* 11263 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_Select_FPR64IN32X_Using_CC_GPR /* 11264 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_Select_FPR64INX_Using_CC_GPR /* 11265 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_Select_FPR64_Using_CC_GPR /* 11266 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_Select_GPR_Using_CC_GPR /* 11267 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_SplitF64Pseudo /* 11268 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_SplitF64Pseudo_INX /* 11269 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_SwapFRMImm /* 11270 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_WriteFFLAGS /* 11271 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_WriteFRM /* 11272 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_WriteFRMImm /* 11273 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* */ + RISCV_WriteVXRMImm /* 11274 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* add $rd, $rs1, $rs2 */ + RISCV_ADD /* 11275 */, RISCV_INS_ADD, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* addi $rd, $rs1, $imm12 */ + RISCV_ADDI /* 11276 */, RISCV_INS_ADDI, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* addiw $rd, $rs1, $imm12 */ + RISCV_ADDIW /* 11277 */, RISCV_INS_ADDIW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* addw $rd, $rs1, $rs2 */ + RISCV_ADDW /* 11278 */, RISCV_INS_ADDW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* add.uw $rd, $rs1, $rs2 */ + RISCV_ADD_UW /* 11279 */, RISCV_INS_ADD_UW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZBA, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* aes32dsi $rd, $rs1, $rs2, $bs */ + RISCV_AES32DSI /* 11280 */, RISCV_INS_AES32DSI, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZKND, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* aes32dsmi $rd, $rs1, $rs2, $bs */ + RISCV_AES32DSMI /* 11281 */, RISCV_INS_AES32DSMI, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZKND, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* aes32esi $rd, $rs1, $rs2, $bs */ + RISCV_AES32ESI /* 11282 */, RISCV_INS_AES32ESI, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZKNE, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* aes32esmi $rd, $rs1, $rs2, $bs */ + RISCV_AES32ESMI /* 11283 */, RISCV_INS_AES32ESMI, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZKNE, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* aes64ds $rd, $rs1, $rs2 */ + RISCV_AES64DS /* 11284 */, RISCV_INS_AES64DS, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZKND, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* aes64dsm $rd, $rs1, $rs2 */ + RISCV_AES64DSM /* 11285 */, RISCV_INS_AES64DSM, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZKND, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* aes64es $rd, $rs1, $rs2 */ + RISCV_AES64ES /* 11286 */, RISCV_INS_AES64ES, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZKNE, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* aes64esm $rd, $rs1, $rs2 */ + RISCV_AES64ESM /* 11287 */, RISCV_INS_AES64ESM, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZKNE, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* aes64im $rd, $rs1 */ + RISCV_AES64IM /* 11288 */, RISCV_INS_AES64IM, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZKND, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* aes64ks1i $rd, $rs1, $rnum */ + RISCV_AES64KS1I /* 11289 */, RISCV_INS_AES64KS1I, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZKNDORZKNE, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* aes64ks2 $rd, $rs1, $rs2 */ + RISCV_AES64KS2 /* 11290 */, RISCV_INS_AES64KS2, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZKNDORZKNE, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amoadd.d $rd, $rs2, $rs1 */ + RISCV_AMOADD_D /* 11291 */, RISCV_INS_AMOADD_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amoadd.d.aq $rd, $rs2, $rs1 */ + RISCV_AMOADD_D_AQ /* 11292 */, RISCV_INS_AMOADD_D_AQ, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amoadd.d.aqrl $rd, $rs2, $rs1 */ + RISCV_AMOADD_D_AQ_RL /* 11293 */, RISCV_INS_AMOADD_D_AQRL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amoadd.d.rl $rd, $rs2, $rs1 */ + RISCV_AMOADD_D_RL /* 11294 */, RISCV_INS_AMOADD_D_RL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amoadd.w $rd, $rs2, $rs1 */ + RISCV_AMOADD_W /* 11295 */, RISCV_INS_AMOADD_W, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amoadd.w.aq $rd, $rs2, $rs1 */ + RISCV_AMOADD_W_AQ /* 11296 */, RISCV_INS_AMOADD_W_AQ, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amoadd.w.aqrl $rd, $rs2, $rs1 */ + RISCV_AMOADD_W_AQ_RL /* 11297 */, RISCV_INS_AMOADD_W_AQRL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amoadd.w.rl $rd, $rs2, $rs1 */ + RISCV_AMOADD_W_RL /* 11298 */, RISCV_INS_AMOADD_W_RL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amoand.d $rd, $rs2, $rs1 */ + RISCV_AMOAND_D /* 11299 */, RISCV_INS_AMOAND_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amoand.d.aq $rd, $rs2, $rs1 */ + RISCV_AMOAND_D_AQ /* 11300 */, RISCV_INS_AMOAND_D_AQ, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amoand.d.aqrl $rd, $rs2, $rs1 */ + RISCV_AMOAND_D_AQ_RL /* 11301 */, RISCV_INS_AMOAND_D_AQRL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amoand.d.rl $rd, $rs2, $rs1 */ + RISCV_AMOAND_D_RL /* 11302 */, RISCV_INS_AMOAND_D_RL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amoand.w $rd, $rs2, $rs1 */ + RISCV_AMOAND_W /* 11303 */, RISCV_INS_AMOAND_W, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amoand.w.aq $rd, $rs2, $rs1 */ + RISCV_AMOAND_W_AQ /* 11304 */, RISCV_INS_AMOAND_W_AQ, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amoand.w.aqrl $rd, $rs2, $rs1 */ + RISCV_AMOAND_W_AQ_RL /* 11305 */, RISCV_INS_AMOAND_W_AQRL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amoand.w.rl $rd, $rs2, $rs1 */ + RISCV_AMOAND_W_RL /* 11306 */, RISCV_INS_AMOAND_W_RL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amocas.d $rd, $rs2, $rs1 */ + RISCV_AMOCAS_D_RV32 /* 11307 */, RISCV_INS_AMOCAS_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZACAS, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amocas.d.aq $rd, $rs2, $rs1 */ + RISCV_AMOCAS_D_RV32_AQ /* 11308 */, RISCV_INS_AMOCAS_D_AQ, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZACAS, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amocas.d.aqrl $rd, $rs2, $rs1 */ + RISCV_AMOCAS_D_RV32_AQ_RL /* 11309 */, RISCV_INS_AMOCAS_D_AQRL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZACAS, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amocas.d.rl $rd, $rs2, $rs1 */ + RISCV_AMOCAS_D_RV32_RL /* 11310 */, RISCV_INS_AMOCAS_D_RL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZACAS, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amocas.d $rd, $rs2, $rs1 */ + RISCV_AMOCAS_D_RV64 /* 11311 */, RISCV_INS_AMOCAS_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZACAS, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amocas.d.aq $rd, $rs2, $rs1 */ + RISCV_AMOCAS_D_RV64_AQ /* 11312 */, RISCV_INS_AMOCAS_D_AQ, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZACAS, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amocas.d.aqrl $rd, $rs2, $rs1 */ + RISCV_AMOCAS_D_RV64_AQ_RL /* 11313 */, RISCV_INS_AMOCAS_D_AQRL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZACAS, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amocas.d.rl $rd, $rs2, $rs1 */ + RISCV_AMOCAS_D_RV64_RL /* 11314 */, RISCV_INS_AMOCAS_D_RL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZACAS, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amocas.q $rd, $rs2, $rs1 */ + RISCV_AMOCAS_Q /* 11315 */, RISCV_INS_AMOCAS_Q, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZACAS, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amocas.q.aq $rd, $rs2, $rs1 */ + RISCV_AMOCAS_Q_AQ /* 11316 */, RISCV_INS_AMOCAS_Q_AQ, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZACAS, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amocas.q.aqrl $rd, $rs2, $rs1 */ + RISCV_AMOCAS_Q_AQ_RL /* 11317 */, RISCV_INS_AMOCAS_Q_AQRL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZACAS, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amocas.q.rl $rd, $rs2, $rs1 */ + RISCV_AMOCAS_Q_RL /* 11318 */, RISCV_INS_AMOCAS_Q_RL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZACAS, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amocas.w $rd, $rs2, $rs1 */ + RISCV_AMOCAS_W /* 11319 */, RISCV_INS_AMOCAS_W, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZACAS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amocas.w.aq $rd, $rs2, $rs1 */ + RISCV_AMOCAS_W_AQ /* 11320 */, RISCV_INS_AMOCAS_W_AQ, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZACAS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amocas.w.aqrl $rd, $rs2, $rs1 */ + RISCV_AMOCAS_W_AQ_RL /* 11321 */, RISCV_INS_AMOCAS_W_AQRL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZACAS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amocas.w.rl $rd, $rs2, $rs1 */ + RISCV_AMOCAS_W_RL /* 11322 */, RISCV_INS_AMOCAS_W_RL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZACAS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amomaxu.d $rd, $rs2, $rs1 */ + RISCV_AMOMAXU_D /* 11323 */, RISCV_INS_AMOMAXU_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amomaxu.d.aq $rd, $rs2, $rs1 */ + RISCV_AMOMAXU_D_AQ /* 11324 */, RISCV_INS_AMOMAXU_D_AQ, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amomaxu.d.aqrl $rd, $rs2, $rs1 */ + RISCV_AMOMAXU_D_AQ_RL /* 11325 */, RISCV_INS_AMOMAXU_D_AQRL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amomaxu.d.rl $rd, $rs2, $rs1 */ + RISCV_AMOMAXU_D_RL /* 11326 */, RISCV_INS_AMOMAXU_D_RL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amomaxu.w $rd, $rs2, $rs1 */ + RISCV_AMOMAXU_W /* 11327 */, RISCV_INS_AMOMAXU_W, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amomaxu.w.aq $rd, $rs2, $rs1 */ + RISCV_AMOMAXU_W_AQ /* 11328 */, RISCV_INS_AMOMAXU_W_AQ, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amomaxu.w.aqrl $rd, $rs2, $rs1 */ + RISCV_AMOMAXU_W_AQ_RL /* 11329 */, RISCV_INS_AMOMAXU_W_AQRL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amomaxu.w.rl $rd, $rs2, $rs1 */ + RISCV_AMOMAXU_W_RL /* 11330 */, RISCV_INS_AMOMAXU_W_RL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amomax.d $rd, $rs2, $rs1 */ + RISCV_AMOMAX_D /* 11331 */, RISCV_INS_AMOMAX_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amomax.d.aq $rd, $rs2, $rs1 */ + RISCV_AMOMAX_D_AQ /* 11332 */, RISCV_INS_AMOMAX_D_AQ, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amomax.d.aqrl $rd, $rs2, $rs1 */ + RISCV_AMOMAX_D_AQ_RL /* 11333 */, RISCV_INS_AMOMAX_D_AQRL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amomax.d.rl $rd, $rs2, $rs1 */ + RISCV_AMOMAX_D_RL /* 11334 */, RISCV_INS_AMOMAX_D_RL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amomax.w $rd, $rs2, $rs1 */ + RISCV_AMOMAX_W /* 11335 */, RISCV_INS_AMOMAX_W, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amomax.w.aq $rd, $rs2, $rs1 */ + RISCV_AMOMAX_W_AQ /* 11336 */, RISCV_INS_AMOMAX_W_AQ, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amomax.w.aqrl $rd, $rs2, $rs1 */ + RISCV_AMOMAX_W_AQ_RL /* 11337 */, RISCV_INS_AMOMAX_W_AQRL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amomax.w.rl $rd, $rs2, $rs1 */ + RISCV_AMOMAX_W_RL /* 11338 */, RISCV_INS_AMOMAX_W_RL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amominu.d $rd, $rs2, $rs1 */ + RISCV_AMOMINU_D /* 11339 */, RISCV_INS_AMOMINU_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amominu.d.aq $rd, $rs2, $rs1 */ + RISCV_AMOMINU_D_AQ /* 11340 */, RISCV_INS_AMOMINU_D_AQ, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amominu.d.aqrl $rd, $rs2, $rs1 */ + RISCV_AMOMINU_D_AQ_RL /* 11341 */, RISCV_INS_AMOMINU_D_AQRL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amominu.d.rl $rd, $rs2, $rs1 */ + RISCV_AMOMINU_D_RL /* 11342 */, RISCV_INS_AMOMINU_D_RL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amominu.w $rd, $rs2, $rs1 */ + RISCV_AMOMINU_W /* 11343 */, RISCV_INS_AMOMINU_W, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amominu.w.aq $rd, $rs2, $rs1 */ + RISCV_AMOMINU_W_AQ /* 11344 */, RISCV_INS_AMOMINU_W_AQ, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amominu.w.aqrl $rd, $rs2, $rs1 */ + RISCV_AMOMINU_W_AQ_RL /* 11345 */, RISCV_INS_AMOMINU_W_AQRL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amominu.w.rl $rd, $rs2, $rs1 */ + RISCV_AMOMINU_W_RL /* 11346 */, RISCV_INS_AMOMINU_W_RL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amomin.d $rd, $rs2, $rs1 */ + RISCV_AMOMIN_D /* 11347 */, RISCV_INS_AMOMIN_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amomin.d.aq $rd, $rs2, $rs1 */ + RISCV_AMOMIN_D_AQ /* 11348 */, RISCV_INS_AMOMIN_D_AQ, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amomin.d.aqrl $rd, $rs2, $rs1 */ + RISCV_AMOMIN_D_AQ_RL /* 11349 */, RISCV_INS_AMOMIN_D_AQRL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amomin.d.rl $rd, $rs2, $rs1 */ + RISCV_AMOMIN_D_RL /* 11350 */, RISCV_INS_AMOMIN_D_RL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amomin.w $rd, $rs2, $rs1 */ + RISCV_AMOMIN_W /* 11351 */, RISCV_INS_AMOMIN_W, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amomin.w.aq $rd, $rs2, $rs1 */ + RISCV_AMOMIN_W_AQ /* 11352 */, RISCV_INS_AMOMIN_W_AQ, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amomin.w.aqrl $rd, $rs2, $rs1 */ + RISCV_AMOMIN_W_AQ_RL /* 11353 */, RISCV_INS_AMOMIN_W_AQRL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amomin.w.rl $rd, $rs2, $rs1 */ + RISCV_AMOMIN_W_RL /* 11354 */, RISCV_INS_AMOMIN_W_RL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amoor.d $rd, $rs2, $rs1 */ + RISCV_AMOOR_D /* 11355 */, RISCV_INS_AMOOR_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amoor.d.aq $rd, $rs2, $rs1 */ + RISCV_AMOOR_D_AQ /* 11356 */, RISCV_INS_AMOOR_D_AQ, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amoor.d.aqrl $rd, $rs2, $rs1 */ + RISCV_AMOOR_D_AQ_RL /* 11357 */, RISCV_INS_AMOOR_D_AQRL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amoor.d.rl $rd, $rs2, $rs1 */ + RISCV_AMOOR_D_RL /* 11358 */, RISCV_INS_AMOOR_D_RL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amoor.w $rd, $rs2, $rs1 */ + RISCV_AMOOR_W /* 11359 */, RISCV_INS_AMOOR_W, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amoor.w.aq $rd, $rs2, $rs1 */ + RISCV_AMOOR_W_AQ /* 11360 */, RISCV_INS_AMOOR_W_AQ, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amoor.w.aqrl $rd, $rs2, $rs1 */ + RISCV_AMOOR_W_AQ_RL /* 11361 */, RISCV_INS_AMOOR_W_AQRL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amoor.w.rl $rd, $rs2, $rs1 */ + RISCV_AMOOR_W_RL /* 11362 */, RISCV_INS_AMOOR_W_RL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amoswap.d $rd, $rs2, $rs1 */ + RISCV_AMOSWAP_D /* 11363 */, RISCV_INS_AMOSWAP_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amoswap.d.aq $rd, $rs2, $rs1 */ + RISCV_AMOSWAP_D_AQ /* 11364 */, RISCV_INS_AMOSWAP_D_AQ, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amoswap.d.aqrl $rd, $rs2, $rs1 */ + RISCV_AMOSWAP_D_AQ_RL /* 11365 */, RISCV_INS_AMOSWAP_D_AQRL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amoswap.d.rl $rd, $rs2, $rs1 */ + RISCV_AMOSWAP_D_RL /* 11366 */, RISCV_INS_AMOSWAP_D_RL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amoswap.w $rd, $rs2, $rs1 */ + RISCV_AMOSWAP_W /* 11367 */, RISCV_INS_AMOSWAP_W, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amoswap.w.aq $rd, $rs2, $rs1 */ + RISCV_AMOSWAP_W_AQ /* 11368 */, RISCV_INS_AMOSWAP_W_AQ, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amoswap.w.aqrl $rd, $rs2, $rs1 */ + RISCV_AMOSWAP_W_AQ_RL /* 11369 */, RISCV_INS_AMOSWAP_W_AQRL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amoswap.w.rl $rd, $rs2, $rs1 */ + RISCV_AMOSWAP_W_RL /* 11370 */, RISCV_INS_AMOSWAP_W_RL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amoxor.d $rd, $rs2, $rs1 */ + RISCV_AMOXOR_D /* 11371 */, RISCV_INS_AMOXOR_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amoxor.d.aq $rd, $rs2, $rs1 */ + RISCV_AMOXOR_D_AQ /* 11372 */, RISCV_INS_AMOXOR_D_AQ, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amoxor.d.aqrl $rd, $rs2, $rs1 */ + RISCV_AMOXOR_D_AQ_RL /* 11373 */, RISCV_INS_AMOXOR_D_AQRL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amoxor.d.rl $rd, $rs2, $rs1 */ + RISCV_AMOXOR_D_RL /* 11374 */, RISCV_INS_AMOXOR_D_RL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amoxor.w $rd, $rs2, $rs1 */ + RISCV_AMOXOR_W /* 11375 */, RISCV_INS_AMOXOR_W, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amoxor.w.aq $rd, $rs2, $rs1 */ + RISCV_AMOXOR_W_AQ /* 11376 */, RISCV_INS_AMOXOR_W_AQ, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amoxor.w.aqrl $rd, $rs2, $rs1 */ + RISCV_AMOXOR_W_AQ_RL /* 11377 */, RISCV_INS_AMOXOR_W_AQRL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* amoxor.w.rl $rd, $rs2, $rs1 */ + RISCV_AMOXOR_W_RL /* 11378 */, RISCV_INS_AMOXOR_W_RL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* and $rd, $rs1, $rs2 */ + RISCV_AND /* 11379 */, RISCV_INS_AND, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* andi $rd, $rs1, $imm12 */ + RISCV_ANDI /* 11380 */, RISCV_INS_ANDI, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* andn $rd, $rs1, $rs2 */ + RISCV_ANDN /* 11381 */, RISCV_INS_ANDN, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZBBORZBKB, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* auipc $rd, $imm20 */ + RISCV_AUIPC /* 11382 */, RISCV_INS_AUIPC, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* bclr $rd, $rs1, $rs2 */ + RISCV_BCLR /* 11383 */, RISCV_INS_BCLR, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZBS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* bclri $rd, $rs1, $shamt */ + RISCV_BCLRI /* 11384 */, RISCV_INS_BCLRI, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZBS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* beq $rs1, $rs2, $imm12 */ + RISCV_BEQ /* 11385 */, RISCV_INS_BEQ, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_GRP_JUMP, RISCV_GRP_BRANCH_RELATIVE, 0 }, 1, 0, {{ 0 }} + + #endif +}, +{ + /* bext $rd, $rs1, $rs2 */ + RISCV_BEXT /* 11386 */, RISCV_INS_BEXT, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZBS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* bexti $rd, $rs1, $shamt */ + RISCV_BEXTI /* 11387 */, RISCV_INS_BEXTI, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZBS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* bge $rs1, $rs2, $imm12 */ + RISCV_BGE /* 11388 */, RISCV_INS_BGE, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_GRP_JUMP, RISCV_GRP_BRANCH_RELATIVE, 0 }, 1, 0, {{ 0 }} + + #endif +}, +{ + /* bgeu $rs1, $rs2, $imm12 */ + RISCV_BGEU /* 11389 */, RISCV_INS_BGEU, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_GRP_JUMP, RISCV_GRP_BRANCH_RELATIVE, 0 }, 1, 0, {{ 0 }} + + #endif +}, +{ + /* binv $rd, $rs1, $rs2 */ + RISCV_BINV /* 11390 */, RISCV_INS_BINV, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZBS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* binvi $rd, $rs1, $shamt */ + RISCV_BINVI /* 11391 */, RISCV_INS_BINVI, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZBS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* blt $rs1, $rs2, $imm12 */ + RISCV_BLT /* 11392 */, RISCV_INS_BLT, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_GRP_JUMP, RISCV_GRP_BRANCH_RELATIVE, 0 }, 1, 0, {{ 0 }} + + #endif +}, +{ + /* bltu $rs1, $rs2, $imm12 */ + RISCV_BLTU /* 11393 */, RISCV_INS_BLTU, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_GRP_JUMP, RISCV_GRP_BRANCH_RELATIVE, 0 }, 1, 0, {{ 0 }} + + #endif +}, +{ + /* bne $rs1, $rs2, $imm12 */ + RISCV_BNE /* 11394 */, RISCV_INS_BNE, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_GRP_JUMP, RISCV_GRP_BRANCH_RELATIVE, 0 }, 1, 0, {{ 0 }} + + #endif +}, +{ + /* brev8 $rd, $rs1 */ + RISCV_BREV8 /* 11395 */, RISCV_INS_BREV8, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZBKB, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* bset $rd, $rs1, $rs2 */ + RISCV_BSET /* 11396 */, RISCV_INS_BSET, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZBS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* bseti $rd, $rs1, $shamt */ + RISCV_BSETI /* 11397 */, RISCV_INS_BSETI, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZBS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cbo.clean $rs1 */ + RISCV_CBO_CLEAN /* 11398 */, RISCV_INS_CBO_CLEAN, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZICBOM, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cbo.flush $rs1 */ + RISCV_CBO_FLUSH /* 11399 */, RISCV_INS_CBO_FLUSH, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZICBOM, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cbo.inval $rs1 */ + RISCV_CBO_INVAL /* 11400 */, RISCV_INS_CBO_INVAL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZICBOM, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cbo.zero $rs1 */ + RISCV_CBO_ZERO /* 11401 */, RISCV_INS_CBO_ZERO, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZICBOZ, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* clmul $rd, $rs1, $rs2 */ + RISCV_CLMUL /* 11402 */, RISCV_INS_CLMUL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZBCORZBKC, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* clmulh $rd, $rs1, $rs2 */ + RISCV_CLMULH /* 11403 */, RISCV_INS_CLMULH, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZBCORZBKC, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* clmulr $rd, $rs1, $rs2 */ + RISCV_CLMULR /* 11404 */, RISCV_INS_CLMULR, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZBC, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* clz $rd, $rs1 */ + RISCV_CLZ /* 11405 */, RISCV_INS_CLZ, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZBB, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* clzw $rd, $rs1 */ + RISCV_CLZW /* 11406 */, RISCV_INS_CLZW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZBB, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cmop.1 */ + RISCV_CMOP1 /* 11407 */, RISCV_INS_CMOP_1, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZCMOP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cmop.11 */ + RISCV_CMOP11 /* 11408 */, RISCV_INS_CMOP_11, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZCMOP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cmop.13 */ + RISCV_CMOP13 /* 11409 */, RISCV_INS_CMOP_13, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZCMOP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cmop.15 */ + RISCV_CMOP15 /* 11410 */, RISCV_INS_CMOP_15, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZCMOP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cmop.3 */ + RISCV_CMOP3 /* 11411 */, RISCV_INS_CMOP_3, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZCMOP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cmop.5 */ + RISCV_CMOP5 /* 11412 */, RISCV_INS_CMOP_5, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZCMOP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cmop.7 */ + RISCV_CMOP7 /* 11413 */, RISCV_INS_CMOP_7, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZCMOP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cmop.9 */ + RISCV_CMOP9 /* 11414 */, RISCV_INS_CMOP_9, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZCMOP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cm.jalt $index */ + RISCV_CM_JALT /* 11415 */, RISCV_INS_CM_JALT, + #ifndef CAPSTONE_DIET + { 0 }, { RISCV_REG_X1, 0 }, { RISCV_FEATURE_HASSTDEXTZCMT, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cm.jt $index */ + RISCV_CM_JT /* 11416 */, RISCV_INS_CM_JT, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZCMT, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cm.mva01s $rs1, $rs2 */ + RISCV_CM_MVA01S /* 11417 */, RISCV_INS_CM_MVA01S, + #ifndef CAPSTONE_DIET + { 0 }, { RISCV_REG_X10, RISCV_REG_X11, 0 }, { RISCV_FEATURE_HASSTDEXTZCMP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cm.mvsa01 $rs1, $rs2 */ + RISCV_CM_MVSA01 /* 11418 */, RISCV_INS_CM_MVSA01, + #ifndef CAPSTONE_DIET + { 0 }, { RISCV_REG_X10, RISCV_REG_X11, 0 }, { RISCV_FEATURE_HASSTDEXTZCMP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cm.pop $rlist, $spimm */ + RISCV_CM_POP /* 11419 */, RISCV_INS_CM_POP, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZCMP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cm.popret $rlist, $spimm */ + RISCV_CM_POPRET /* 11420 */, RISCV_INS_CM_POPRET, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZCMP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cm.popretz $rlist, $spimm */ + RISCV_CM_POPRETZ /* 11421 */, RISCV_INS_CM_POPRETZ, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZCMP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cm.push $rlist, $spimm */ + RISCV_CM_PUSH /* 11422 */, RISCV_INS_CM_PUSH, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZCMP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cpop $rd, $rs1 */ + RISCV_CPOP /* 11423 */, RISCV_INS_CPOP, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZBB, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cpopw $rd, $rs1 */ + RISCV_CPOPW /* 11424 */, RISCV_INS_CPOPW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZBB, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* csrrc $rd, $imm12, $rs1 */ + RISCV_CSRRC /* 11425 */, RISCV_INS_CSRRC, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* csrrci $rd, $imm12, $rs1 */ + RISCV_CSRRCI /* 11426 */, RISCV_INS_CSRRCI, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* csrrs $rd, $imm12, $rs1 */ + RISCV_CSRRS /* 11427 */, RISCV_INS_CSRRS, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* csrrsi $rd, $imm12, $rs1 */ + RISCV_CSRRSI /* 11428 */, RISCV_INS_CSRRSI, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* csrrw $rd, $imm12, $rs1 */ + RISCV_CSRRW /* 11429 */, RISCV_INS_CSRRW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* csrrwi $rd, $imm12, $rs1 */ + RISCV_CSRRWI /* 11430 */, RISCV_INS_CSRRWI, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* ctz $rd, $rs1 */ + RISCV_CTZ /* 11431 */, RISCV_INS_CTZ, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZBB, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* ctzw $rd, $rs1 */ + RISCV_CTZW /* 11432 */, RISCV_INS_CTZW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZBB, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.abs $rd, $rs1 */ + RISCV_CV_ABS /* 11433 */, RISCV_INS_CV_ABS, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVALU, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.abs.b $rd, $rs1 */ + RISCV_CV_ABS_B /* 11434 */, RISCV_INS_CV_ABS_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.abs.h $rd, $rs1 */ + RISCV_CV_ABS_H /* 11435 */, RISCV_INS_CV_ABS_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.addn $rd, $rs1, $rs2, $imm5 */ + RISCV_CV_ADDN /* 11436 */, RISCV_INS_CV_ADDN, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVALU, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.addnr $rd, $rs1, $rs2 */ + RISCV_CV_ADDNR /* 11437 */, RISCV_INS_CV_ADDNR, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVALU, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.addrn $rd, $rs1, $rs2, $imm5 */ + RISCV_CV_ADDRN /* 11438 */, RISCV_INS_CV_ADDRN, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVALU, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.addrnr $rd, $rs1, $rs2 */ + RISCV_CV_ADDRNR /* 11439 */, RISCV_INS_CV_ADDRNR, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVALU, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.addun $rd, $rs1, $rs2, $imm5 */ + RISCV_CV_ADDUN /* 11440 */, RISCV_INS_CV_ADDUN, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVALU, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.addunr $rd, $rs1, $rs2 */ + RISCV_CV_ADDUNR /* 11441 */, RISCV_INS_CV_ADDUNR, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVALU, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.addurn $rd, $rs1, $rs2, $imm5 */ + RISCV_CV_ADDURN /* 11442 */, RISCV_INS_CV_ADDURN, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVALU, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.addurnr $rd, $rs1, $rs2 */ + RISCV_CV_ADDURNR /* 11443 */, RISCV_INS_CV_ADDURNR, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVALU, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.add.b $rd, $rs1, $rs2 */ + RISCV_CV_ADD_B /* 11444 */, RISCV_INS_CV_ADD_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.add.div2 $rd, $rs1, $rs2 */ + RISCV_CV_ADD_DIV2 /* 11445 */, RISCV_INS_CV_ADD_DIV2, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.add.div4 $rd, $rs1, $rs2 */ + RISCV_CV_ADD_DIV4 /* 11446 */, RISCV_INS_CV_ADD_DIV4, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.add.div8 $rd, $rs1, $rs2 */ + RISCV_CV_ADD_DIV8 /* 11447 */, RISCV_INS_CV_ADD_DIV8, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.add.h $rd, $rs1, $rs2 */ + RISCV_CV_ADD_H /* 11448 */, RISCV_INS_CV_ADD_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.add.sci.b $rd, $rs1, $imm6 */ + RISCV_CV_ADD_SCI_B /* 11449 */, RISCV_INS_CV_ADD_SCI_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.add.sci.h $rd, $rs1, $imm6 */ + RISCV_CV_ADD_SCI_H /* 11450 */, RISCV_INS_CV_ADD_SCI_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.add.sc.b $rd, $rs1, $rs2 */ + RISCV_CV_ADD_SC_B /* 11451 */, RISCV_INS_CV_ADD_SC_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.add.sc.h $rd, $rs1, $rs2 */ + RISCV_CV_ADD_SC_H /* 11452 */, RISCV_INS_CV_ADD_SC_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.and.b $rd, $rs1, $rs2 */ + RISCV_CV_AND_B /* 11453 */, RISCV_INS_CV_AND_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.and.h $rd, $rs1, $rs2 */ + RISCV_CV_AND_H /* 11454 */, RISCV_INS_CV_AND_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.and.sci.b $rd, $rs1, $imm6 */ + RISCV_CV_AND_SCI_B /* 11455 */, RISCV_INS_CV_AND_SCI_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.and.sci.h $rd, $rs1, $imm6 */ + RISCV_CV_AND_SCI_H /* 11456 */, RISCV_INS_CV_AND_SCI_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.and.sc.b $rd, $rs1, $rs2 */ + RISCV_CV_AND_SC_B /* 11457 */, RISCV_INS_CV_AND_SC_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.and.sc.h $rd, $rs1, $rs2 */ + RISCV_CV_AND_SC_H /* 11458 */, RISCV_INS_CV_AND_SC_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.avgu.b $rd, $rs1, $rs2 */ + RISCV_CV_AVGU_B /* 11459 */, RISCV_INS_CV_AVGU_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.avgu.h $rd, $rs1, $rs2 */ + RISCV_CV_AVGU_H /* 11460 */, RISCV_INS_CV_AVGU_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.avgu.sci.b $rd, $rs1, $imm6 */ + RISCV_CV_AVGU_SCI_B /* 11461 */, RISCV_INS_CV_AVGU_SCI_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.avgu.sci.h $rd, $rs1, $imm6 */ + RISCV_CV_AVGU_SCI_H /* 11462 */, RISCV_INS_CV_AVGU_SCI_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.avgu.sc.b $rd, $rs1, $rs2 */ + RISCV_CV_AVGU_SC_B /* 11463 */, RISCV_INS_CV_AVGU_SC_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.avgu.sc.h $rd, $rs1, $rs2 */ + RISCV_CV_AVGU_SC_H /* 11464 */, RISCV_INS_CV_AVGU_SC_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.avg.b $rd, $rs1, $rs2 */ + RISCV_CV_AVG_B /* 11465 */, RISCV_INS_CV_AVG_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.avg.h $rd, $rs1, $rs2 */ + RISCV_CV_AVG_H /* 11466 */, RISCV_INS_CV_AVG_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.avg.sci.b $rd, $rs1, $imm6 */ + RISCV_CV_AVG_SCI_B /* 11467 */, RISCV_INS_CV_AVG_SCI_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.avg.sci.h $rd, $rs1, $imm6 */ + RISCV_CV_AVG_SCI_H /* 11468 */, RISCV_INS_CV_AVG_SCI_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.avg.sc.b $rd, $rs1, $rs2 */ + RISCV_CV_AVG_SC_B /* 11469 */, RISCV_INS_CV_AVG_SC_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.avg.sc.h $rd, $rs1, $rs2 */ + RISCV_CV_AVG_SC_H /* 11470 */, RISCV_INS_CV_AVG_SC_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.bclr $rd, $rs1, $is3, $is2 */ + RISCV_CV_BCLR /* 11471 */, RISCV_INS_CV_BCLR, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVBITMANIP, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.bclrr $rd, $rs1, $rs2 */ + RISCV_CV_BCLRR /* 11472 */, RISCV_INS_CV_BCLRR, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVBITMANIP, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.beqimm $rs1, $imm5, $imm12 */ + RISCV_CV_BEQIMM /* 11473 */, RISCV_INS_CV_BEQIMM, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_GRP_JUMP, RISCV_GRP_BRANCH_RELATIVE, RISCV_FEATURE_HASVENDORXCVBI, RISCV_FEATURE_ISRV32, 0 }, 1, 0, {{ 0 }} + + #endif +}, +{ + /* cv.bitrev $rd, $rs1, $is3, $is2 */ + RISCV_CV_BITREV /* 11474 */, RISCV_INS_CV_BITREV, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVBITMANIP, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.bneimm $rs1, $imm5, $imm12 */ + RISCV_CV_BNEIMM /* 11475 */, RISCV_INS_CV_BNEIMM, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_GRP_JUMP, RISCV_GRP_BRANCH_RELATIVE, RISCV_FEATURE_HASVENDORXCVBI, RISCV_FEATURE_ISRV32, 0 }, 1, 0, {{ 0 }} + + #endif +}, +{ + /* cv.bset $rd, $rs1, $is3, $is2 */ + RISCV_CV_BSET /* 11476 */, RISCV_INS_CV_BSET, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVBITMANIP, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.bsetr $rd, $rs1, $rs2 */ + RISCV_CV_BSETR /* 11477 */, RISCV_INS_CV_BSETR, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVBITMANIP, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.clb $rd, $rs1 */ + RISCV_CV_CLB /* 11478 */, RISCV_INS_CV_CLB, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVBITMANIP, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.clip $rd, $rs1, $imm5 */ + RISCV_CV_CLIP /* 11479 */, RISCV_INS_CV_CLIP, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVALU, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.clipr $rd, $rs1, $rs2 */ + RISCV_CV_CLIPR /* 11480 */, RISCV_INS_CV_CLIPR, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVALU, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.clipu $rd, $rs1, $imm5 */ + RISCV_CV_CLIPU /* 11481 */, RISCV_INS_CV_CLIPU, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVALU, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.clipur $rd, $rs1, $rs2 */ + RISCV_CV_CLIPUR /* 11482 */, RISCV_INS_CV_CLIPUR, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVALU, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmpeq.b $rd, $rs1, $rs2 */ + RISCV_CV_CMPEQ_B /* 11483 */, RISCV_INS_CV_CMPEQ_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmpeq.h $rd, $rs1, $rs2 */ + RISCV_CV_CMPEQ_H /* 11484 */, RISCV_INS_CV_CMPEQ_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmpeq.sci.b $rd, $rs1, $imm6 */ + RISCV_CV_CMPEQ_SCI_B /* 11485 */, RISCV_INS_CV_CMPEQ_SCI_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmpeq.sci.h $rd, $rs1, $imm6 */ + RISCV_CV_CMPEQ_SCI_H /* 11486 */, RISCV_INS_CV_CMPEQ_SCI_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmpeq.sc.b $rd, $rs1, $rs2 */ + RISCV_CV_CMPEQ_SC_B /* 11487 */, RISCV_INS_CV_CMPEQ_SC_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmpeq.sc.h $rd, $rs1, $rs2 */ + RISCV_CV_CMPEQ_SC_H /* 11488 */, RISCV_INS_CV_CMPEQ_SC_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmpgeu.b $rd, $rs1, $rs2 */ + RISCV_CV_CMPGEU_B /* 11489 */, RISCV_INS_CV_CMPGEU_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmpgeu.h $rd, $rs1, $rs2 */ + RISCV_CV_CMPGEU_H /* 11490 */, RISCV_INS_CV_CMPGEU_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmpgeu.sci.b $rd, $rs1, $imm6 */ + RISCV_CV_CMPGEU_SCI_B /* 11491 */, RISCV_INS_CV_CMPGEU_SCI_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmpgeu.sci.h $rd, $rs1, $imm6 */ + RISCV_CV_CMPGEU_SCI_H /* 11492 */, RISCV_INS_CV_CMPGEU_SCI_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmpgeu.sc.b $rd, $rs1, $rs2 */ + RISCV_CV_CMPGEU_SC_B /* 11493 */, RISCV_INS_CV_CMPGEU_SC_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmpgeu.sc.h $rd, $rs1, $rs2 */ + RISCV_CV_CMPGEU_SC_H /* 11494 */, RISCV_INS_CV_CMPGEU_SC_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmpge.b $rd, $rs1, $rs2 */ + RISCV_CV_CMPGE_B /* 11495 */, RISCV_INS_CV_CMPGE_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmpge.h $rd, $rs1, $rs2 */ + RISCV_CV_CMPGE_H /* 11496 */, RISCV_INS_CV_CMPGE_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmpge.sci.b $rd, $rs1, $imm6 */ + RISCV_CV_CMPGE_SCI_B /* 11497 */, RISCV_INS_CV_CMPGE_SCI_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmpge.sci.h $rd, $rs1, $imm6 */ + RISCV_CV_CMPGE_SCI_H /* 11498 */, RISCV_INS_CV_CMPGE_SCI_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmpge.sc.b $rd, $rs1, $rs2 */ + RISCV_CV_CMPGE_SC_B /* 11499 */, RISCV_INS_CV_CMPGE_SC_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmpge.sc.h $rd, $rs1, $rs2 */ + RISCV_CV_CMPGE_SC_H /* 11500 */, RISCV_INS_CV_CMPGE_SC_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmpgtu.b $rd, $rs1, $rs2 */ + RISCV_CV_CMPGTU_B /* 11501 */, RISCV_INS_CV_CMPGTU_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmpgtu.h $rd, $rs1, $rs2 */ + RISCV_CV_CMPGTU_H /* 11502 */, RISCV_INS_CV_CMPGTU_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmpgtu.sci.b $rd, $rs1, $imm6 */ + RISCV_CV_CMPGTU_SCI_B /* 11503 */, RISCV_INS_CV_CMPGTU_SCI_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmpgtu.sci.h $rd, $rs1, $imm6 */ + RISCV_CV_CMPGTU_SCI_H /* 11504 */, RISCV_INS_CV_CMPGTU_SCI_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmpgtu.sc.b $rd, $rs1, $rs2 */ + RISCV_CV_CMPGTU_SC_B /* 11505 */, RISCV_INS_CV_CMPGTU_SC_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmpgtu.sc.h $rd, $rs1, $rs2 */ + RISCV_CV_CMPGTU_SC_H /* 11506 */, RISCV_INS_CV_CMPGTU_SC_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmpgt.b $rd, $rs1, $rs2 */ + RISCV_CV_CMPGT_B /* 11507 */, RISCV_INS_CV_CMPGT_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmpgt.h $rd, $rs1, $rs2 */ + RISCV_CV_CMPGT_H /* 11508 */, RISCV_INS_CV_CMPGT_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmpgt.sci.b $rd, $rs1, $imm6 */ + RISCV_CV_CMPGT_SCI_B /* 11509 */, RISCV_INS_CV_CMPGT_SCI_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmpgt.sci.h $rd, $rs1, $imm6 */ + RISCV_CV_CMPGT_SCI_H /* 11510 */, RISCV_INS_CV_CMPGT_SCI_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmpgt.sc.b $rd, $rs1, $rs2 */ + RISCV_CV_CMPGT_SC_B /* 11511 */, RISCV_INS_CV_CMPGT_SC_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmpgt.sc.h $rd, $rs1, $rs2 */ + RISCV_CV_CMPGT_SC_H /* 11512 */, RISCV_INS_CV_CMPGT_SC_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmpleu.b $rd, $rs1, $rs2 */ + RISCV_CV_CMPLEU_B /* 11513 */, RISCV_INS_CV_CMPLEU_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmpleu.h $rd, $rs1, $rs2 */ + RISCV_CV_CMPLEU_H /* 11514 */, RISCV_INS_CV_CMPLEU_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmpleu.sci.b $rd, $rs1, $imm6 */ + RISCV_CV_CMPLEU_SCI_B /* 11515 */, RISCV_INS_CV_CMPLEU_SCI_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmpleu.sci.h $rd, $rs1, $imm6 */ + RISCV_CV_CMPLEU_SCI_H /* 11516 */, RISCV_INS_CV_CMPLEU_SCI_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmpleu.sc.b $rd, $rs1, $rs2 */ + RISCV_CV_CMPLEU_SC_B /* 11517 */, RISCV_INS_CV_CMPLEU_SC_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmpleu.sc.h $rd, $rs1, $rs2 */ + RISCV_CV_CMPLEU_SC_H /* 11518 */, RISCV_INS_CV_CMPLEU_SC_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmple.b $rd, $rs1, $rs2 */ + RISCV_CV_CMPLE_B /* 11519 */, RISCV_INS_CV_CMPLE_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmple.h $rd, $rs1, $rs2 */ + RISCV_CV_CMPLE_H /* 11520 */, RISCV_INS_CV_CMPLE_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmple.sci.b $rd, $rs1, $imm6 */ + RISCV_CV_CMPLE_SCI_B /* 11521 */, RISCV_INS_CV_CMPLE_SCI_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmple.sci.h $rd, $rs1, $imm6 */ + RISCV_CV_CMPLE_SCI_H /* 11522 */, RISCV_INS_CV_CMPLE_SCI_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmple.sc.b $rd, $rs1, $rs2 */ + RISCV_CV_CMPLE_SC_B /* 11523 */, RISCV_INS_CV_CMPLE_SC_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmple.sc.h $rd, $rs1, $rs2 */ + RISCV_CV_CMPLE_SC_H /* 11524 */, RISCV_INS_CV_CMPLE_SC_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmpltu.b $rd, $rs1, $rs2 */ + RISCV_CV_CMPLTU_B /* 11525 */, RISCV_INS_CV_CMPLTU_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmpltu.h $rd, $rs1, $rs2 */ + RISCV_CV_CMPLTU_H /* 11526 */, RISCV_INS_CV_CMPLTU_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmpltu.sci.b $rd, $rs1, $imm6 */ + RISCV_CV_CMPLTU_SCI_B /* 11527 */, RISCV_INS_CV_CMPLTU_SCI_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmpltu.sci.h $rd, $rs1, $imm6 */ + RISCV_CV_CMPLTU_SCI_H /* 11528 */, RISCV_INS_CV_CMPLTU_SCI_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmpltu.sc.b $rd, $rs1, $rs2 */ + RISCV_CV_CMPLTU_SC_B /* 11529 */, RISCV_INS_CV_CMPLTU_SC_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmpltu.sc.h $rd, $rs1, $rs2 */ + RISCV_CV_CMPLTU_SC_H /* 11530 */, RISCV_INS_CV_CMPLTU_SC_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmplt.b $rd, $rs1, $rs2 */ + RISCV_CV_CMPLT_B /* 11531 */, RISCV_INS_CV_CMPLT_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmplt.h $rd, $rs1, $rs2 */ + RISCV_CV_CMPLT_H /* 11532 */, RISCV_INS_CV_CMPLT_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmplt.sci.b $rd, $rs1, $imm6 */ + RISCV_CV_CMPLT_SCI_B /* 11533 */, RISCV_INS_CV_CMPLT_SCI_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmplt.sci.h $rd, $rs1, $imm6 */ + RISCV_CV_CMPLT_SCI_H /* 11534 */, RISCV_INS_CV_CMPLT_SCI_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmplt.sc.b $rd, $rs1, $rs2 */ + RISCV_CV_CMPLT_SC_B /* 11535 */, RISCV_INS_CV_CMPLT_SC_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmplt.sc.h $rd, $rs1, $rs2 */ + RISCV_CV_CMPLT_SC_H /* 11536 */, RISCV_INS_CV_CMPLT_SC_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmpne.b $rd, $rs1, $rs2 */ + RISCV_CV_CMPNE_B /* 11537 */, RISCV_INS_CV_CMPNE_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmpne.h $rd, $rs1, $rs2 */ + RISCV_CV_CMPNE_H /* 11538 */, RISCV_INS_CV_CMPNE_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmpne.sci.b $rd, $rs1, $imm6 */ + RISCV_CV_CMPNE_SCI_B /* 11539 */, RISCV_INS_CV_CMPNE_SCI_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmpne.sci.h $rd, $rs1, $imm6 */ + RISCV_CV_CMPNE_SCI_H /* 11540 */, RISCV_INS_CV_CMPNE_SCI_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmpne.sc.b $rd, $rs1, $rs2 */ + RISCV_CV_CMPNE_SC_B /* 11541 */, RISCV_INS_CV_CMPNE_SC_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cmpne.sc.h $rd, $rs1, $rs2 */ + RISCV_CV_CMPNE_SC_H /* 11542 */, RISCV_INS_CV_CMPNE_SC_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cnt $rd, $rs1 */ + RISCV_CV_CNT /* 11543 */, RISCV_INS_CV_CNT, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVBITMANIP, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cplxconj $rd, $rs1 */ + RISCV_CV_CPLXCONJ /* 11544 */, RISCV_INS_CV_CPLXCONJ, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cplxmul.i $rd, $rs1, $rs2 */ + RISCV_CV_CPLXMUL_I /* 11545 */, RISCV_INS_CV_CPLXMUL_I, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cplxmul.i.div2 $rd, $rs1, $rs2 */ + RISCV_CV_CPLXMUL_I_DIV2 /* 11546 */, RISCV_INS_CV_CPLXMUL_I_DIV2, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cplxmul.i.div4 $rd, $rs1, $rs2 */ + RISCV_CV_CPLXMUL_I_DIV4 /* 11547 */, RISCV_INS_CV_CPLXMUL_I_DIV4, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cplxmul.i.div8 $rd, $rs1, $rs2 */ + RISCV_CV_CPLXMUL_I_DIV8 /* 11548 */, RISCV_INS_CV_CPLXMUL_I_DIV8, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cplxmul.r $rd, $rs1, $rs2 */ + RISCV_CV_CPLXMUL_R /* 11549 */, RISCV_INS_CV_CPLXMUL_R, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cplxmul.r.div2 $rd, $rs1, $rs2 */ + RISCV_CV_CPLXMUL_R_DIV2 /* 11550 */, RISCV_INS_CV_CPLXMUL_R_DIV2, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cplxmul.r.div4 $rd, $rs1, $rs2 */ + RISCV_CV_CPLXMUL_R_DIV4 /* 11551 */, RISCV_INS_CV_CPLXMUL_R_DIV4, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.cplxmul.r.div8 $rd, $rs1, $rs2 */ + RISCV_CV_CPLXMUL_R_DIV8 /* 11552 */, RISCV_INS_CV_CPLXMUL_R_DIV8, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.dotsp.b $rd, $rs1, $rs2 */ + RISCV_CV_DOTSP_B /* 11553 */, RISCV_INS_CV_DOTSP_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.dotsp.h $rd, $rs1, $rs2 */ + RISCV_CV_DOTSP_H /* 11554 */, RISCV_INS_CV_DOTSP_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.dotsp.sci.b $rd, $rs1, $imm6 */ + RISCV_CV_DOTSP_SCI_B /* 11555 */, RISCV_INS_CV_DOTSP_SCI_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.dotsp.sci.h $rd, $rs1, $imm6 */ + RISCV_CV_DOTSP_SCI_H /* 11556 */, RISCV_INS_CV_DOTSP_SCI_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.dotsp.sc.b $rd, $rs1, $rs2 */ + RISCV_CV_DOTSP_SC_B /* 11557 */, RISCV_INS_CV_DOTSP_SC_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.dotsp.sc.h $rd, $rs1, $rs2 */ + RISCV_CV_DOTSP_SC_H /* 11558 */, RISCV_INS_CV_DOTSP_SC_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.dotup.b $rd, $rs1, $rs2 */ + RISCV_CV_DOTUP_B /* 11559 */, RISCV_INS_CV_DOTUP_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.dotup.h $rd, $rs1, $rs2 */ + RISCV_CV_DOTUP_H /* 11560 */, RISCV_INS_CV_DOTUP_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.dotup.sci.b $rd, $rs1, $imm6 */ + RISCV_CV_DOTUP_SCI_B /* 11561 */, RISCV_INS_CV_DOTUP_SCI_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.dotup.sci.h $rd, $rs1, $imm6 */ + RISCV_CV_DOTUP_SCI_H /* 11562 */, RISCV_INS_CV_DOTUP_SCI_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.dotup.sc.b $rd, $rs1, $rs2 */ + RISCV_CV_DOTUP_SC_B /* 11563 */, RISCV_INS_CV_DOTUP_SC_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.dotup.sc.h $rd, $rs1, $rs2 */ + RISCV_CV_DOTUP_SC_H /* 11564 */, RISCV_INS_CV_DOTUP_SC_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.dotusp.b $rd, $rs1, $rs2 */ + RISCV_CV_DOTUSP_B /* 11565 */, RISCV_INS_CV_DOTUSP_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.dotusp.h $rd, $rs1, $rs2 */ + RISCV_CV_DOTUSP_H /* 11566 */, RISCV_INS_CV_DOTUSP_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.dotusp.sci.b $rd, $rs1, $imm6 */ + RISCV_CV_DOTUSP_SCI_B /* 11567 */, RISCV_INS_CV_DOTUSP_SCI_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.dotusp.sci.h $rd, $rs1, $imm6 */ + RISCV_CV_DOTUSP_SCI_H /* 11568 */, RISCV_INS_CV_DOTUSP_SCI_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.dotusp.sc.b $rd, $rs1, $rs2 */ + RISCV_CV_DOTUSP_SC_B /* 11569 */, RISCV_INS_CV_DOTUSP_SC_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.dotusp.sc.h $rd, $rs1, $rs2 */ + RISCV_CV_DOTUSP_SC_H /* 11570 */, RISCV_INS_CV_DOTUSP_SC_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.elw $rd, ${imm12}(${rs1}) */ + RISCV_CV_ELW /* 11571 */, RISCV_INS_CV_ELW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVELW, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.extbs $rd, $rs1 */ + RISCV_CV_EXTBS /* 11572 */, RISCV_INS_CV_EXTBS, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVALU, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.extbz $rd, $rs1 */ + RISCV_CV_EXTBZ /* 11573 */, RISCV_INS_CV_EXTBZ, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVALU, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.exths $rd, $rs1 */ + RISCV_CV_EXTHS /* 11574 */, RISCV_INS_CV_EXTHS, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVALU, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.exthz $rd, $rs1 */ + RISCV_CV_EXTHZ /* 11575 */, RISCV_INS_CV_EXTHZ, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVALU, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.extract $rd, $rs1, $is3, $is2 */ + RISCV_CV_EXTRACT /* 11576 */, RISCV_INS_CV_EXTRACT, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVBITMANIP, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.extractr $rd, $rs1, $rs2 */ + RISCV_CV_EXTRACTR /* 11577 */, RISCV_INS_CV_EXTRACTR, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVBITMANIP, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.extractu $rd, $rs1, $is3, $is2 */ + RISCV_CV_EXTRACTU /* 11578 */, RISCV_INS_CV_EXTRACTU, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVBITMANIP, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.extractur $rd, $rs1, $rs2 */ + RISCV_CV_EXTRACTUR /* 11579 */, RISCV_INS_CV_EXTRACTUR, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVBITMANIP, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.extractu.b $rd, $rs1, $imm6 */ + RISCV_CV_EXTRACTU_B /* 11580 */, RISCV_INS_CV_EXTRACTU_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.extractu.h $rd, $rs1, $imm6 */ + RISCV_CV_EXTRACTU_H /* 11581 */, RISCV_INS_CV_EXTRACTU_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.extract.b $rd, $rs1, $imm6 */ + RISCV_CV_EXTRACT_B /* 11582 */, RISCV_INS_CV_EXTRACT_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.extract.h $rd, $rs1, $imm6 */ + RISCV_CV_EXTRACT_H /* 11583 */, RISCV_INS_CV_EXTRACT_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.ff1 $rd, $rs1 */ + RISCV_CV_FF1 /* 11584 */, RISCV_INS_CV_FF1, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVBITMANIP, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.fl1 $rd, $rs1 */ + RISCV_CV_FL1 /* 11585 */, RISCV_INS_CV_FL1, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVBITMANIP, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.insert $rd, $rs1, $is3, $is2 */ + RISCV_CV_INSERT /* 11586 */, RISCV_INS_CV_INSERT, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVBITMANIP, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.insertr $rd, $rs1, $rs2 */ + RISCV_CV_INSERTR /* 11587 */, RISCV_INS_CV_INSERTR, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVBITMANIP, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.insert.b $rd, $rs1, $imm6 */ + RISCV_CV_INSERT_B /* 11588 */, RISCV_INS_CV_INSERT_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.insert.h $rd, $rs1, $imm6 */ + RISCV_CV_INSERT_H /* 11589 */, RISCV_INS_CV_INSERT_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.lbu $rd, (${rs1}), ${imm12} */ + RISCV_CV_LBU_ri_inc /* 11590 */, RISCV_INS_CV_LBU, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVMEM, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.lbu $rd, $cvrr */ + RISCV_CV_LBU_rr /* 11591 */, RISCV_INS_CV_LBU, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVMEM, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.lbu $rd, (${rs1}), ${rs2} */ + RISCV_CV_LBU_rr_inc /* 11592 */, RISCV_INS_CV_LBU, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVMEM, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.lb $rd, (${rs1}), ${imm12} */ + RISCV_CV_LB_ri_inc /* 11593 */, RISCV_INS_CV_LB, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVMEM, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.lb $rd, $cvrr */ + RISCV_CV_LB_rr /* 11594 */, RISCV_INS_CV_LB, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVMEM, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.lb $rd, (${rs1}), ${rs2} */ + RISCV_CV_LB_rr_inc /* 11595 */, RISCV_INS_CV_LB, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVMEM, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.lhu $rd, (${rs1}), ${imm12} */ + RISCV_CV_LHU_ri_inc /* 11596 */, RISCV_INS_CV_LHU, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVMEM, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.lhu $rd, $cvrr */ + RISCV_CV_LHU_rr /* 11597 */, RISCV_INS_CV_LHU, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVMEM, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.lhu $rd, (${rs1}), ${rs2} */ + RISCV_CV_LHU_rr_inc /* 11598 */, RISCV_INS_CV_LHU, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVMEM, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.lh $rd, (${rs1}), ${imm12} */ + RISCV_CV_LH_ri_inc /* 11599 */, RISCV_INS_CV_LH, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVMEM, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.lh $rd, $cvrr */ + RISCV_CV_LH_rr /* 11600 */, RISCV_INS_CV_LH, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVMEM, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.lh $rd, (${rs1}), ${rs2} */ + RISCV_CV_LH_rr_inc /* 11601 */, RISCV_INS_CV_LH, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVMEM, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.lw $rd, (${rs1}), ${imm12} */ + RISCV_CV_LW_ri_inc /* 11602 */, RISCV_INS_CV_LW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVMEM, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.lw $rd, $cvrr */ + RISCV_CV_LW_rr /* 11603 */, RISCV_INS_CV_LW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVMEM, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.lw $rd, (${rs1}), ${rs2} */ + RISCV_CV_LW_rr_inc /* 11604 */, RISCV_INS_CV_LW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVMEM, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.mac $rd, $rs1, $rs2 */ + RISCV_CV_MAC /* 11605 */, RISCV_INS_CV_MAC, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVMAC, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.machhsn $rd, $rs1, $rs2, $imm5 */ + RISCV_CV_MACHHSN /* 11606 */, RISCV_INS_CV_MACHHSN, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVMAC, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.machhsrn $rd, $rs1, $rs2, $imm5 */ + RISCV_CV_MACHHSRN /* 11607 */, RISCV_INS_CV_MACHHSRN, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVMAC, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.machhun $rd, $rs1, $rs2, $imm5 */ + RISCV_CV_MACHHUN /* 11608 */, RISCV_INS_CV_MACHHUN, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVMAC, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.machhurn $rd, $rs1, $rs2, $imm5 */ + RISCV_CV_MACHHURN /* 11609 */, RISCV_INS_CV_MACHHURN, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVMAC, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.macsn $rd, $rs1, $rs2, $imm5 */ + RISCV_CV_MACSN /* 11610 */, RISCV_INS_CV_MACSN, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVMAC, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.macsrn $rd, $rs1, $rs2, $imm5 */ + RISCV_CV_MACSRN /* 11611 */, RISCV_INS_CV_MACSRN, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVMAC, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.macun $rd, $rs1, $rs2, $imm5 */ + RISCV_CV_MACUN /* 11612 */, RISCV_INS_CV_MACUN, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVMAC, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.macurn $rd, $rs1, $rs2, $imm5 */ + RISCV_CV_MACURN /* 11613 */, RISCV_INS_CV_MACURN, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVMAC, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.max $rd, $rs1, $rs2 */ + RISCV_CV_MAX /* 11614 */, RISCV_INS_CV_MAX, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVALU, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.maxu $rd, $rs1, $rs2 */ + RISCV_CV_MAXU /* 11615 */, RISCV_INS_CV_MAXU, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVALU, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.maxu.b $rd, $rs1, $rs2 */ + RISCV_CV_MAXU_B /* 11616 */, RISCV_INS_CV_MAXU_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.maxu.h $rd, $rs1, $rs2 */ + RISCV_CV_MAXU_H /* 11617 */, RISCV_INS_CV_MAXU_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.maxu.sci.b $rd, $rs1, $imm6 */ + RISCV_CV_MAXU_SCI_B /* 11618 */, RISCV_INS_CV_MAXU_SCI_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.maxu.sci.h $rd, $rs1, $imm6 */ + RISCV_CV_MAXU_SCI_H /* 11619 */, RISCV_INS_CV_MAXU_SCI_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.maxu.sc.b $rd, $rs1, $rs2 */ + RISCV_CV_MAXU_SC_B /* 11620 */, RISCV_INS_CV_MAXU_SC_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.maxu.sc.h $rd, $rs1, $rs2 */ + RISCV_CV_MAXU_SC_H /* 11621 */, RISCV_INS_CV_MAXU_SC_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.max.b $rd, $rs1, $rs2 */ + RISCV_CV_MAX_B /* 11622 */, RISCV_INS_CV_MAX_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.max.h $rd, $rs1, $rs2 */ + RISCV_CV_MAX_H /* 11623 */, RISCV_INS_CV_MAX_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.max.sci.b $rd, $rs1, $imm6 */ + RISCV_CV_MAX_SCI_B /* 11624 */, RISCV_INS_CV_MAX_SCI_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.max.sci.h $rd, $rs1, $imm6 */ + RISCV_CV_MAX_SCI_H /* 11625 */, RISCV_INS_CV_MAX_SCI_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.max.sc.b $rd, $rs1, $rs2 */ + RISCV_CV_MAX_SC_B /* 11626 */, RISCV_INS_CV_MAX_SC_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.max.sc.h $rd, $rs1, $rs2 */ + RISCV_CV_MAX_SC_H /* 11627 */, RISCV_INS_CV_MAX_SC_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.min $rd, $rs1, $rs2 */ + RISCV_CV_MIN /* 11628 */, RISCV_INS_CV_MIN, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVALU, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.minu $rd, $rs1, $rs2 */ + RISCV_CV_MINU /* 11629 */, RISCV_INS_CV_MINU, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVALU, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.minu.b $rd, $rs1, $rs2 */ + RISCV_CV_MINU_B /* 11630 */, RISCV_INS_CV_MINU_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.minu.h $rd, $rs1, $rs2 */ + RISCV_CV_MINU_H /* 11631 */, RISCV_INS_CV_MINU_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.minu.sci.b $rd, $rs1, $imm6 */ + RISCV_CV_MINU_SCI_B /* 11632 */, RISCV_INS_CV_MINU_SCI_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.minu.sci.h $rd, $rs1, $imm6 */ + RISCV_CV_MINU_SCI_H /* 11633 */, RISCV_INS_CV_MINU_SCI_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.minu.sc.b $rd, $rs1, $rs2 */ + RISCV_CV_MINU_SC_B /* 11634 */, RISCV_INS_CV_MINU_SC_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.minu.sc.h $rd, $rs1, $rs2 */ + RISCV_CV_MINU_SC_H /* 11635 */, RISCV_INS_CV_MINU_SC_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.min.b $rd, $rs1, $rs2 */ + RISCV_CV_MIN_B /* 11636 */, RISCV_INS_CV_MIN_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.min.h $rd, $rs1, $rs2 */ + RISCV_CV_MIN_H /* 11637 */, RISCV_INS_CV_MIN_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.min.sci.b $rd, $rs1, $imm6 */ + RISCV_CV_MIN_SCI_B /* 11638 */, RISCV_INS_CV_MIN_SCI_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.min.sci.h $rd, $rs1, $imm6 */ + RISCV_CV_MIN_SCI_H /* 11639 */, RISCV_INS_CV_MIN_SCI_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.min.sc.b $rd, $rs1, $rs2 */ + RISCV_CV_MIN_SC_B /* 11640 */, RISCV_INS_CV_MIN_SC_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.min.sc.h $rd, $rs1, $rs2 */ + RISCV_CV_MIN_SC_H /* 11641 */, RISCV_INS_CV_MIN_SC_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.msu $rd, $rs1, $rs2 */ + RISCV_CV_MSU /* 11642 */, RISCV_INS_CV_MSU, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVMAC, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.mulhhsn $rd, $rs1, $rs2, $imm5 */ + RISCV_CV_MULHHSN /* 11643 */, RISCV_INS_CV_MULHHSN, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVMAC, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.mulhhsrn $rd, $rs1, $rs2, $imm5 */ + RISCV_CV_MULHHSRN /* 11644 */, RISCV_INS_CV_MULHHSRN, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVMAC, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.mulhhun $rd, $rs1, $rs2, $imm5 */ + RISCV_CV_MULHHUN /* 11645 */, RISCV_INS_CV_MULHHUN, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVMAC, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.mulhhurn $rd, $rs1, $rs2, $imm5 */ + RISCV_CV_MULHHURN /* 11646 */, RISCV_INS_CV_MULHHURN, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVMAC, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.mulsn $rd, $rs1, $rs2, $imm5 */ + RISCV_CV_MULSN /* 11647 */, RISCV_INS_CV_MULSN, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVMAC, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.mulsrn $rd, $rs1, $rs2, $imm5 */ + RISCV_CV_MULSRN /* 11648 */, RISCV_INS_CV_MULSRN, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVMAC, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.mulun $rd, $rs1, $rs2, $imm5 */ + RISCV_CV_MULUN /* 11649 */, RISCV_INS_CV_MULUN, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVMAC, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.mulurn $rd, $rs1, $rs2, $imm5 */ + RISCV_CV_MULURN /* 11650 */, RISCV_INS_CV_MULURN, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVMAC, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.or.b $rd, $rs1, $rs2 */ + RISCV_CV_OR_B /* 11651 */, RISCV_INS_CV_OR_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.or.h $rd, $rs1, $rs2 */ + RISCV_CV_OR_H /* 11652 */, RISCV_INS_CV_OR_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.or.sci.b $rd, $rs1, $imm6 */ + RISCV_CV_OR_SCI_B /* 11653 */, RISCV_INS_CV_OR_SCI_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.or.sci.h $rd, $rs1, $imm6 */ + RISCV_CV_OR_SCI_H /* 11654 */, RISCV_INS_CV_OR_SCI_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.or.sc.b $rd, $rs1, $rs2 */ + RISCV_CV_OR_SC_B /* 11655 */, RISCV_INS_CV_OR_SC_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.or.sc.h $rd, $rs1, $rs2 */ + RISCV_CV_OR_SC_H /* 11656 */, RISCV_INS_CV_OR_SC_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.pack $rd, $rs1, $rs2 */ + RISCV_CV_PACK /* 11657 */, RISCV_INS_CV_PACK, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.packhi.b $rd, $rs1, $rs2 */ + RISCV_CV_PACKHI_B /* 11658 */, RISCV_INS_CV_PACKHI_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.packlo.b $rd, $rs1, $rs2 */ + RISCV_CV_PACKLO_B /* 11659 */, RISCV_INS_CV_PACKLO_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.pack.h $rd, $rs1, $rs2 */ + RISCV_CV_PACK_H /* 11660 */, RISCV_INS_CV_PACK_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.ror $rd, $rs1, $rs2 */ + RISCV_CV_ROR /* 11661 */, RISCV_INS_CV_ROR, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVBITMANIP, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.sb $rs2, (${rs1}), ${imm12} */ + RISCV_CV_SB_ri_inc /* 11662 */, RISCV_INS_CV_SB, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVMEM, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.sb $rs2, $cvrr */ + RISCV_CV_SB_rr /* 11663 */, RISCV_INS_CV_SB, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVMEM, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.sb $rs2, (${rs1}), ${rs3} */ + RISCV_CV_SB_rr_inc /* 11664 */, RISCV_INS_CV_SB, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVMEM, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.sdotsp.b $rd, $rs1, $rs2 */ + RISCV_CV_SDOTSP_B /* 11665 */, RISCV_INS_CV_SDOTSP_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.sdotsp.h $rd, $rs1, $rs2 */ + RISCV_CV_SDOTSP_H /* 11666 */, RISCV_INS_CV_SDOTSP_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.sdotsp.sci.b $rd, $rs1, $imm6 */ + RISCV_CV_SDOTSP_SCI_B /* 11667 */, RISCV_INS_CV_SDOTSP_SCI_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.sdotsp.sci.h $rd, $rs1, $imm6 */ + RISCV_CV_SDOTSP_SCI_H /* 11668 */, RISCV_INS_CV_SDOTSP_SCI_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.sdotsp.sc.b $rd, $rs1, $rs2 */ + RISCV_CV_SDOTSP_SC_B /* 11669 */, RISCV_INS_CV_SDOTSP_SC_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.sdotsp.sc.h $rd, $rs1, $rs2 */ + RISCV_CV_SDOTSP_SC_H /* 11670 */, RISCV_INS_CV_SDOTSP_SC_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.sdotup.b $rd, $rs1, $rs2 */ + RISCV_CV_SDOTUP_B /* 11671 */, RISCV_INS_CV_SDOTUP_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.sdotup.h $rd, $rs1, $rs2 */ + RISCV_CV_SDOTUP_H /* 11672 */, RISCV_INS_CV_SDOTUP_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.sdotup.sci.b $rd, $rs1, $imm6 */ + RISCV_CV_SDOTUP_SCI_B /* 11673 */, RISCV_INS_CV_SDOTUP_SCI_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.sdotup.sci.h $rd, $rs1, $imm6 */ + RISCV_CV_SDOTUP_SCI_H /* 11674 */, RISCV_INS_CV_SDOTUP_SCI_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.sdotup.sc.b $rd, $rs1, $rs2 */ + RISCV_CV_SDOTUP_SC_B /* 11675 */, RISCV_INS_CV_SDOTUP_SC_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.sdotup.sc.h $rd, $rs1, $rs2 */ + RISCV_CV_SDOTUP_SC_H /* 11676 */, RISCV_INS_CV_SDOTUP_SC_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.sdotusp.b $rd, $rs1, $rs2 */ + RISCV_CV_SDOTUSP_B /* 11677 */, RISCV_INS_CV_SDOTUSP_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.sdotusp.h $rd, $rs1, $rs2 */ + RISCV_CV_SDOTUSP_H /* 11678 */, RISCV_INS_CV_SDOTUSP_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.sdotusp.sci.b $rd, $rs1, $imm6 */ + RISCV_CV_SDOTUSP_SCI_B /* 11679 */, RISCV_INS_CV_SDOTUSP_SCI_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.sdotusp.sci.h $rd, $rs1, $imm6 */ + RISCV_CV_SDOTUSP_SCI_H /* 11680 */, RISCV_INS_CV_SDOTUSP_SCI_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.sdotusp.sc.b $rd, $rs1, $rs2 */ + RISCV_CV_SDOTUSP_SC_B /* 11681 */, RISCV_INS_CV_SDOTUSP_SC_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.sdotusp.sc.h $rd, $rs1, $rs2 */ + RISCV_CV_SDOTUSP_SC_H /* 11682 */, RISCV_INS_CV_SDOTUSP_SC_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.shuffle2.b $rd, $rs1, $rs2 */ + RISCV_CV_SHUFFLE2_B /* 11683 */, RISCV_INS_CV_SHUFFLE2_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.shuffle2.h $rd, $rs1, $rs2 */ + RISCV_CV_SHUFFLE2_H /* 11684 */, RISCV_INS_CV_SHUFFLE2_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.shufflei0.sci.b $rd, $rs1, $imm6 */ + RISCV_CV_SHUFFLEI0_SCI_B /* 11685 */, RISCV_INS_CV_SHUFFLEI0_SCI_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.shufflei1.sci.b $rd, $rs1, $imm6 */ + RISCV_CV_SHUFFLEI1_SCI_B /* 11686 */, RISCV_INS_CV_SHUFFLEI1_SCI_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.shufflei2.sci.b $rd, $rs1, $imm6 */ + RISCV_CV_SHUFFLEI2_SCI_B /* 11687 */, RISCV_INS_CV_SHUFFLEI2_SCI_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.shufflei3.sci.b $rd, $rs1, $imm6 */ + RISCV_CV_SHUFFLEI3_SCI_B /* 11688 */, RISCV_INS_CV_SHUFFLEI3_SCI_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.shuffle.b $rd, $rs1, $rs2 */ + RISCV_CV_SHUFFLE_B /* 11689 */, RISCV_INS_CV_SHUFFLE_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.shuffle.h $rd, $rs1, $rs2 */ + RISCV_CV_SHUFFLE_H /* 11690 */, RISCV_INS_CV_SHUFFLE_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.shuffle.sci.h $rd, $rs1, $imm6 */ + RISCV_CV_SHUFFLE_SCI_H /* 11691 */, RISCV_INS_CV_SHUFFLE_SCI_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.sh $rs2, (${rs1}), ${imm12} */ + RISCV_CV_SH_ri_inc /* 11692 */, RISCV_INS_CV_SH, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVMEM, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.sh $rs2, $cvrr */ + RISCV_CV_SH_rr /* 11693 */, RISCV_INS_CV_SH, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVMEM, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.sh $rs2, (${rs1}), ${rs3} */ + RISCV_CV_SH_rr_inc /* 11694 */, RISCV_INS_CV_SH, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVMEM, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.slet $rd, $rs1, $rs2 */ + RISCV_CV_SLET /* 11695 */, RISCV_INS_CV_SLET, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVALU, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.sletu $rd, $rs1, $rs2 */ + RISCV_CV_SLETU /* 11696 */, RISCV_INS_CV_SLETU, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVALU, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.sll.b $rd, $rs1, $rs2 */ + RISCV_CV_SLL_B /* 11697 */, RISCV_INS_CV_SLL_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.sll.h $rd, $rs1, $rs2 */ + RISCV_CV_SLL_H /* 11698 */, RISCV_INS_CV_SLL_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.sll.sci.b $rd, $rs1, $imm6 */ + RISCV_CV_SLL_SCI_B /* 11699 */, RISCV_INS_CV_SLL_SCI_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.sll.sci.h $rd, $rs1, $imm6 */ + RISCV_CV_SLL_SCI_H /* 11700 */, RISCV_INS_CV_SLL_SCI_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.sll.sc.b $rd, $rs1, $rs2 */ + RISCV_CV_SLL_SC_B /* 11701 */, RISCV_INS_CV_SLL_SC_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.sll.sc.h $rd, $rs1, $rs2 */ + RISCV_CV_SLL_SC_H /* 11702 */, RISCV_INS_CV_SLL_SC_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.sra.b $rd, $rs1, $rs2 */ + RISCV_CV_SRA_B /* 11703 */, RISCV_INS_CV_SRA_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.sra.h $rd, $rs1, $rs2 */ + RISCV_CV_SRA_H /* 11704 */, RISCV_INS_CV_SRA_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.sra.sci.b $rd, $rs1, $imm6 */ + RISCV_CV_SRA_SCI_B /* 11705 */, RISCV_INS_CV_SRA_SCI_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.sra.sci.h $rd, $rs1, $imm6 */ + RISCV_CV_SRA_SCI_H /* 11706 */, RISCV_INS_CV_SRA_SCI_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.sra.sc.b $rd, $rs1, $rs2 */ + RISCV_CV_SRA_SC_B /* 11707 */, RISCV_INS_CV_SRA_SC_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.sra.sc.h $rd, $rs1, $rs2 */ + RISCV_CV_SRA_SC_H /* 11708 */, RISCV_INS_CV_SRA_SC_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.srl.b $rd, $rs1, $rs2 */ + RISCV_CV_SRL_B /* 11709 */, RISCV_INS_CV_SRL_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.srl.h $rd, $rs1, $rs2 */ + RISCV_CV_SRL_H /* 11710 */, RISCV_INS_CV_SRL_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.srl.sci.b $rd, $rs1, $imm6 */ + RISCV_CV_SRL_SCI_B /* 11711 */, RISCV_INS_CV_SRL_SCI_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.srl.sci.h $rd, $rs1, $imm6 */ + RISCV_CV_SRL_SCI_H /* 11712 */, RISCV_INS_CV_SRL_SCI_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.srl.sc.b $rd, $rs1, $rs2 */ + RISCV_CV_SRL_SC_B /* 11713 */, RISCV_INS_CV_SRL_SC_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.srl.sc.h $rd, $rs1, $rs2 */ + RISCV_CV_SRL_SC_H /* 11714 */, RISCV_INS_CV_SRL_SC_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.subn $rd, $rs1, $rs2, $imm5 */ + RISCV_CV_SUBN /* 11715 */, RISCV_INS_CV_SUBN, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVALU, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.subnr $rd, $rs1, $rs2 */ + RISCV_CV_SUBNR /* 11716 */, RISCV_INS_CV_SUBNR, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVALU, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.subrn $rd, $rs1, $rs2, $imm5 */ + RISCV_CV_SUBRN /* 11717 */, RISCV_INS_CV_SUBRN, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVALU, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.subrnr $rd, $rs1, $rs2 */ + RISCV_CV_SUBRNR /* 11718 */, RISCV_INS_CV_SUBRNR, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVALU, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.subrotmj $rd, $rs1, $rs2 */ + RISCV_CV_SUBROTMJ /* 11719 */, RISCV_INS_CV_SUBROTMJ, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.subrotmj.div2 $rd, $rs1, $rs2 */ + RISCV_CV_SUBROTMJ_DIV2 /* 11720 */, RISCV_INS_CV_SUBROTMJ_DIV2, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.subrotmj.div4 $rd, $rs1, $rs2 */ + RISCV_CV_SUBROTMJ_DIV4 /* 11721 */, RISCV_INS_CV_SUBROTMJ_DIV4, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.subrotmj.div8 $rd, $rs1, $rs2 */ + RISCV_CV_SUBROTMJ_DIV8 /* 11722 */, RISCV_INS_CV_SUBROTMJ_DIV8, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.subun $rd, $rs1, $rs2, $imm5 */ + RISCV_CV_SUBUN /* 11723 */, RISCV_INS_CV_SUBUN, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVALU, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.subunr $rd, $rs1, $rs2 */ + RISCV_CV_SUBUNR /* 11724 */, RISCV_INS_CV_SUBUNR, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVALU, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.suburn $rd, $rs1, $rs2, $imm5 */ + RISCV_CV_SUBURN /* 11725 */, RISCV_INS_CV_SUBURN, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVALU, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.suburnr $rd, $rs1, $rs2 */ + RISCV_CV_SUBURNR /* 11726 */, RISCV_INS_CV_SUBURNR, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVALU, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.sub.b $rd, $rs1, $rs2 */ + RISCV_CV_SUB_B /* 11727 */, RISCV_INS_CV_SUB_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.sub.div2 $rd, $rs1, $rs2 */ + RISCV_CV_SUB_DIV2 /* 11728 */, RISCV_INS_CV_SUB_DIV2, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.sub.div4 $rd, $rs1, $rs2 */ + RISCV_CV_SUB_DIV4 /* 11729 */, RISCV_INS_CV_SUB_DIV4, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.sub.div8 $rd, $rs1, $rs2 */ + RISCV_CV_SUB_DIV8 /* 11730 */, RISCV_INS_CV_SUB_DIV8, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.sub.h $rd, $rs1, $rs2 */ + RISCV_CV_SUB_H /* 11731 */, RISCV_INS_CV_SUB_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.sub.sci.b $rd, $rs1, $imm6 */ + RISCV_CV_SUB_SCI_B /* 11732 */, RISCV_INS_CV_SUB_SCI_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.sub.sci.h $rd, $rs1, $imm6 */ + RISCV_CV_SUB_SCI_H /* 11733 */, RISCV_INS_CV_SUB_SCI_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.sub.sc.b $rd, $rs1, $rs2 */ + RISCV_CV_SUB_SC_B /* 11734 */, RISCV_INS_CV_SUB_SC_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.sub.sc.h $rd, $rs1, $rs2 */ + RISCV_CV_SUB_SC_H /* 11735 */, RISCV_INS_CV_SUB_SC_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.sw $rs2, (${rs1}), ${imm12} */ + RISCV_CV_SW_ri_inc /* 11736 */, RISCV_INS_CV_SW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVMEM, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.sw $rs2, $cvrr */ + RISCV_CV_SW_rr /* 11737 */, RISCV_INS_CV_SW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVMEM, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.sw $rs2, (${rs1}), ${rs3} */ + RISCV_CV_SW_rr_inc /* 11738 */, RISCV_INS_CV_SW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVMEM, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.xor.b $rd, $rs1, $rs2 */ + RISCV_CV_XOR_B /* 11739 */, RISCV_INS_CV_XOR_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.xor.h $rd, $rs1, $rs2 */ + RISCV_CV_XOR_H /* 11740 */, RISCV_INS_CV_XOR_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.xor.sci.b $rd, $rs1, $imm6 */ + RISCV_CV_XOR_SCI_B /* 11741 */, RISCV_INS_CV_XOR_SCI_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.xor.sci.h $rd, $rs1, $imm6 */ + RISCV_CV_XOR_SCI_H /* 11742 */, RISCV_INS_CV_XOR_SCI_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.xor.sc.b $rd, $rs1, $rs2 */ + RISCV_CV_XOR_SC_B /* 11743 */, RISCV_INS_CV_XOR_SC_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* cv.xor.sc.h $rd, $rs1, $rs2 */ + RISCV_CV_XOR_SC_H /* 11744 */, RISCV_INS_CV_XOR_SC_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXCVSIMD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* czero.eqz $rd, $rs1, $rs2 */ + RISCV_CZERO_EQZ /* 11745 */, RISCV_INS_CZERO_EQZ, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZICOND, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* czero.nez $rd, $rs1, $rs2 */ + RISCV_CZERO_NEZ /* 11746 */, RISCV_INS_CZERO_NEZ, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZICOND, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.add $rs1, $rs2 */ + RISCV_C_ADD /* 11747 */, RISCV_INS_C_ADD, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTCORZCA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.addi $rd, $imm */ + RISCV_C_ADDI /* 11748 */, RISCV_INS_C_ADDI, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTCORZCA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.addi16sp $rd, $imm */ + RISCV_C_ADDI16SP /* 11749 */, RISCV_INS_C_ADDI16SP, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTCORZCA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.addi4spn $rd, $rs1, $imm */ + RISCV_C_ADDI4SPN /* 11750 */, RISCV_INS_C_ADDI4SPN, + #ifndef CAPSTONE_DIET + { RISCV_REG_X2, 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTCORZCA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.addiw $rd, $imm */ + RISCV_C_ADDIW /* 11751 */, RISCV_INS_C_ADDIW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTCORZCA, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.addi $rd, $imm */ + RISCV_C_ADDI_HINT_IMM_ZERO /* 11752 */, RISCV_INS_C_ADDI, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTCORZCA, RISCV_FEATURE_HASRVCHINTS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.addi $rd, $imm */ + RISCV_C_ADDI_NOP /* 11753 */, RISCV_INS_C_ADDI, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTCORZCA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.addw $rd, $rs2 */ + RISCV_C_ADDW /* 11754 */, RISCV_INS_C_ADDW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTCORZCA, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.add $rs1, $rs2 */ + RISCV_C_ADD_HINT /* 11755 */, RISCV_INS_C_ADD, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTCORZCA, RISCV_FEATURE_HASRVCHINTS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.and $rd, $rs2 */ + RISCV_C_AND /* 11756 */, RISCV_INS_C_AND, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTCORZCA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.andi $rs1, $imm */ + RISCV_C_ANDI /* 11757 */, RISCV_INS_C_ANDI, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTCORZCA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.beqz $rs1, $imm */ + RISCV_C_BEQZ /* 11758 */, RISCV_INS_C_BEQZ, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_GRP_JUMP, RISCV_GRP_BRANCH_RELATIVE, RISCV_FEATURE_HASSTDEXTCORZCA, 0 }, 1, 0, {{ 0 }} + + #endif +}, +{ + /* c.bnez $rs1, $imm */ + RISCV_C_BNEZ /* 11759 */, RISCV_INS_C_BNEZ, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_GRP_JUMP, RISCV_GRP_BRANCH_RELATIVE, RISCV_FEATURE_HASSTDEXTCORZCA, 0 }, 1, 0, {{ 0 }} + + #endif +}, +{ + /* c.ebreak */ + RISCV_C_EBREAK /* 11760 */, RISCV_INS_C_EBREAK, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTCORZCA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.fld $rd, ${imm}(${rs1}) */ + RISCV_C_FLD /* 11761 */, RISCV_INS_C_FLD, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTCORZCD, RISCV_FEATURE_HASSTDEXTD, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.fldsp $rd, ${imm}(${rs1}) */ + RISCV_C_FLDSP /* 11762 */, RISCV_INS_C_FLDSP, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTCORZCD, RISCV_FEATURE_HASSTDEXTD, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.flw $rd, ${imm}(${rs1}) */ + RISCV_C_FLW /* 11763 */, RISCV_INS_C_FLW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTCORZCFORZCE, RISCV_FEATURE_HASSTDEXTF, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.flwsp $rd, ${imm}(${rs1}) */ + RISCV_C_FLWSP /* 11764 */, RISCV_INS_C_FLWSP, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTCORZCFORZCE, RISCV_FEATURE_HASSTDEXTF, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.fsd $rs2, ${imm}(${rs1}) */ + RISCV_C_FSD /* 11765 */, RISCV_INS_C_FSD, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTCORZCD, RISCV_FEATURE_HASSTDEXTD, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.fsdsp $rs2, ${imm}(${rs1}) */ + RISCV_C_FSDSP /* 11766 */, RISCV_INS_C_FSDSP, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTCORZCD, RISCV_FEATURE_HASSTDEXTD, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.fsw $rs2, ${imm}(${rs1}) */ + RISCV_C_FSW /* 11767 */, RISCV_INS_C_FSW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTCORZCFORZCE, RISCV_FEATURE_HASSTDEXTF, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.fswsp $rs2, ${imm}(${rs1}) */ + RISCV_C_FSWSP /* 11768 */, RISCV_INS_C_FSWSP, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTCORZCFORZCE, RISCV_FEATURE_HASSTDEXTF, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.j $offset */ + RISCV_C_J /* 11769 */, RISCV_INS_C_J, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_GRP_JUMP, RISCV_GRP_BRANCH_RELATIVE, RISCV_FEATURE_HASSTDEXTCORZCA, 0 }, 1, 0, {{ 0 }} + + #endif +}, +{ + /* c.jal $offset */ + RISCV_C_JAL /* 11770 */, RISCV_INS_C_JAL, + #ifndef CAPSTONE_DIET + { 0 }, { RISCV_REG_X1, 0 }, { RISCV_GRP_CALL, RISCV_GRP_BRANCH_RELATIVE, RISCV_FEATURE_HASSTDEXTCORZCA, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.jalr $rs1 */ + RISCV_C_JALR /* 11771 */, RISCV_INS_C_JALR, + #ifndef CAPSTONE_DIET + { 0 }, { RISCV_REG_X1, 0 }, { RISCV_GRP_CALL, RISCV_FEATURE_HASSTDEXTCORZCA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.jr $rs1 */ + RISCV_C_JR /* 11772 */, RISCV_INS_C_JR, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_GRP_JUMP, RISCV_FEATURE_HASSTDEXTCORZCA, 0 }, 1, 0, {{ 0 }} + + #endif +}, +{ + /* c.lbu $rd, ${imm}(${rs1}) */ + RISCV_C_LBU /* 11773 */, RISCV_INS_C_LBU, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZCB, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.ld $rd, ${imm}(${rs1}) */ + RISCV_C_LD /* 11774 */, RISCV_INS_C_LD, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTCORZCA, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.ldsp $rd, ${imm}(${rs1}) */ + RISCV_C_LDSP /* 11775 */, RISCV_INS_C_LDSP, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTCORZCA, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.lh $rd, ${imm}(${rs1}) */ + RISCV_C_LH /* 11776 */, RISCV_INS_C_LH, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZCB, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.lhu $rd, ${imm}(${rs1}) */ + RISCV_C_LHU /* 11777 */, RISCV_INS_C_LHU, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZCB, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.li $rd, $imm */ + RISCV_C_LI /* 11778 */, RISCV_INS_C_LI, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTCORZCA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.li $rd, $imm */ + RISCV_C_LI_HINT /* 11779 */, RISCV_INS_C_LI, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTCORZCA, RISCV_FEATURE_HASRVCHINTS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.lui $rd, $imm */ + RISCV_C_LUI /* 11780 */, RISCV_INS_C_LUI, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTCORZCA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.lui $rd, $imm */ + RISCV_C_LUI_HINT /* 11781 */, RISCV_INS_C_LUI, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTCORZCA, RISCV_FEATURE_HASRVCHINTS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.lw $rd, ${imm}(${rs1}) */ + RISCV_C_LW /* 11782 */, RISCV_INS_C_LW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTCORZCA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.lwsp $rd, ${imm}(${rs1}) */ + RISCV_C_LWSP /* 11783 */, RISCV_INS_C_LWSP, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTCORZCA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.mul $rd, $rs2 */ + RISCV_C_MUL /* 11784 */, RISCV_INS_C_MUL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZCB, RISCV_FEATURE_HASSTDEXTMORZMMUL, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.mv $rs1, $rs2 */ + RISCV_C_MV /* 11785 */, RISCV_INS_C_MV, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTCORZCA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.mv $rs1, $rs2 */ + RISCV_C_MV_HINT /* 11786 */, RISCV_INS_C_MV, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTCORZCA, RISCV_FEATURE_HASRVCHINTS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.nop */ + RISCV_C_NOP /* 11787 */, RISCV_INS_C_NOP, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTCORZCA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.nop $imm */ + RISCV_C_NOP_HINT /* 11788 */, RISCV_INS_C_NOP, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTCORZCA, RISCV_FEATURE_HASRVCHINTS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.not $rd */ + RISCV_C_NOT /* 11789 */, RISCV_INS_C_NOT, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZCB, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.or $rd, $rs2 */ + RISCV_C_OR /* 11790 */, RISCV_INS_C_OR, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTCORZCA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.sb $rs2, ${imm}(${rs1}) */ + RISCV_C_SB /* 11791 */, RISCV_INS_C_SB, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZCB, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.sd $rs2, ${imm}(${rs1}) */ + RISCV_C_SD /* 11792 */, RISCV_INS_C_SD, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTCORZCA, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.sdsp $rs2, ${imm}(${rs1}) */ + RISCV_C_SDSP /* 11793 */, RISCV_INS_C_SDSP, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTCORZCA, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.sext.b $rd */ + RISCV_C_SEXT_B /* 11794 */, RISCV_INS_C_SEXT_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZCB, RISCV_FEATURE_HASSTDEXTZBB, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.sext.h $rd */ + RISCV_C_SEXT_H /* 11795 */, RISCV_INS_C_SEXT_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZCB, RISCV_FEATURE_HASSTDEXTZBB, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.sh $rs2, ${imm}(${rs1}) */ + RISCV_C_SH /* 11796 */, RISCV_INS_C_SH, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZCB, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.slli $rd, $imm */ + RISCV_C_SLLI /* 11797 */, RISCV_INS_C_SLLI, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTCORZCA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.slli64 $rd */ + RISCV_C_SLLI64_HINT /* 11798 */, RISCV_INS_C_SLLI64, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTCORZCA, RISCV_FEATURE_HASRVCHINTS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.slli $rd, $imm */ + RISCV_C_SLLI_HINT /* 11799 */, RISCV_INS_C_SLLI, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTCORZCA, RISCV_FEATURE_HASRVCHINTS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.srai $rs1, $imm */ + RISCV_C_SRAI /* 11800 */, RISCV_INS_C_SRAI, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTCORZCA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.srai64 $rd */ + RISCV_C_SRAI64_HINT /* 11801 */, RISCV_INS_C_SRAI64, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTCORZCA, RISCV_FEATURE_HASRVCHINTS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.srli $rs1, $imm */ + RISCV_C_SRLI /* 11802 */, RISCV_INS_C_SRLI, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTCORZCA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.srli64 $rd */ + RISCV_C_SRLI64_HINT /* 11803 */, RISCV_INS_C_SRLI64, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTCORZCA, RISCV_FEATURE_HASRVCHINTS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.sspopchk $rs1 */ + RISCV_C_SSPOPCHK /* 11804 */, RISCV_INS_C_SSPOPCHK, + #ifndef CAPSTONE_DIET + { RISCV_REG_SSP, 0 }, { RISCV_REG_SSP, 0 }, { RISCV_FEATURE_HASSTDEXTZICFISS, RISCV_FEATURE_HASSTDEXTZCMOP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.sspush $rs1 */ + RISCV_C_SSPUSH /* 11805 */, RISCV_INS_C_SSPUSH, + #ifndef CAPSTONE_DIET + { RISCV_REG_SSP, 0 }, { RISCV_REG_SSP, 0 }, { RISCV_FEATURE_HASSTDEXTZICFISS, RISCV_FEATURE_HASSTDEXTZCMOP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.sub $rd, $rs2 */ + RISCV_C_SUB /* 11806 */, RISCV_INS_C_SUB, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTCORZCA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.subw $rd, $rs2 */ + RISCV_C_SUBW /* 11807 */, RISCV_INS_C_SUBW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTCORZCA, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.sw $rs2, ${imm}(${rs1}) */ + RISCV_C_SW /* 11808 */, RISCV_INS_C_SW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTCORZCA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.swsp $rs2, ${imm}(${rs1}) */ + RISCV_C_SWSP /* 11809 */, RISCV_INS_C_SWSP, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTCORZCA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.unimp */ + RISCV_C_UNIMP /* 11810 */, RISCV_INS_C_UNIMP, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTCORZCA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.xor $rd, $rs2 */ + RISCV_C_XOR /* 11811 */, RISCV_INS_C_XOR, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTCORZCA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.zext.b $rd */ + RISCV_C_ZEXT_B /* 11812 */, RISCV_INS_C_ZEXT_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZCB, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.zext.h $rd */ + RISCV_C_ZEXT_H /* 11813 */, RISCV_INS_C_ZEXT_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZCB, RISCV_FEATURE_HASSTDEXTZBB, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* c.zext.w $rd */ + RISCV_C_ZEXT_W /* 11814 */, RISCV_INS_C_ZEXT_W, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZCB, RISCV_FEATURE_HASSTDEXTZBA, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* div $rd, $rs1, $rs2 */ + RISCV_DIV /* 11815 */, RISCV_INS_DIV, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTM, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* divu $rd, $rs1, $rs2 */ + RISCV_DIVU /* 11816 */, RISCV_INS_DIVU, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTM, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* divuw $rd, $rs1, $rs2 */ + RISCV_DIVUW /* 11817 */, RISCV_INS_DIVUW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTM, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* divw $rd, $rs1, $rs2 */ + RISCV_DIVW /* 11818 */, RISCV_INS_DIVW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTM, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* dret */ + RISCV_DRET /* 11819 */, RISCV_INS_DRET, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_GRP_JUMP, RISCV_GRP_RET, 0 }, 1, 0, {{ 0 }} + + #endif +}, +{ + /* ebreak */ + RISCV_EBREAK /* 11820 */, RISCV_INS_EBREAK, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* ecall */ + RISCV_ECALL /* 11821 */, RISCV_INS_ECALL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fadd.d $rd, $rs1, $rs2$frm */ + RISCV_FADD_D /* 11822 */, RISCV_INS_FADD_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTD, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fadd.d $rd, $rs1, $rs2$frm */ + RISCV_FADD_D_IN32X /* 11823 */, RISCV_INS_FADD_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZDINX, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fadd.d $rd, $rs1, $rs2$frm */ + RISCV_FADD_D_INX /* 11824 */, RISCV_INS_FADD_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZDINX, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fadd.h $rd, $rs1, $rs2$frm */ + RISCV_FADD_H /* 11825 */, RISCV_INS_FADD_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFH, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fadd.h $rd, $rs1, $rs2$frm */ + RISCV_FADD_H_INX /* 11826 */, RISCV_INS_FADD_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZHINX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fadd.s $rd, $rs1, $rs2$frm */ + RISCV_FADD_S /* 11827 */, RISCV_INS_FADD_S, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fadd.s $rd, $rs1, $rs2$frm */ + RISCV_FADD_S_INX /* 11828 */, RISCV_INS_FADD_S, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFINX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fclass.d $rd, $rs1 */ + RISCV_FCLASS_D /* 11829 */, RISCV_INS_FCLASS_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTD, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fclass.d $rd, $rs1 */ + RISCV_FCLASS_D_IN32X /* 11830 */, RISCV_INS_FCLASS_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZDINX, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fclass.d $rd, $rs1 */ + RISCV_FCLASS_D_INX /* 11831 */, RISCV_INS_FCLASS_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZDINX, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fclass.h $rd, $rs1 */ + RISCV_FCLASS_H /* 11832 */, RISCV_INS_FCLASS_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFH, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fclass.h $rd, $rs1 */ + RISCV_FCLASS_H_INX /* 11833 */, RISCV_INS_FCLASS_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZHINX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fclass.s $rd, $rs1 */ + RISCV_FCLASS_S /* 11834 */, RISCV_INS_FCLASS_S, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fclass.s $rd, $rs1 */ + RISCV_FCLASS_S_INX /* 11835 */, RISCV_INS_FCLASS_S, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFINX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvtmod.w.d $rd, $rs1$frm */ + RISCV_FCVTMOD_W_D /* 11836 */, RISCV_INS_FCVTMOD_W_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFA, RISCV_FEATURE_HASSTDEXTD, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.bf16.s $rd, $rs1$frm */ + RISCV_FCVT_BF16_S /* 11837 */, RISCV_INS_FCVT_BF16_S, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFBFMIN, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.d.h $rd, $rs1$frm */ + RISCV_FCVT_D_H /* 11838 */, RISCV_INS_FCVT_D_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFHMIN, RISCV_FEATURE_HASSTDEXTD, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.d.h $rd, $rs1$frm */ + RISCV_FCVT_D_H_IN32X /* 11839 */, RISCV_INS_FCVT_D_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZHINXMIN, RISCV_FEATURE_HASSTDEXTZDINX, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.d.h $rd, $rs1$frm */ + RISCV_FCVT_D_H_INX /* 11840 */, RISCV_INS_FCVT_D_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZHINXMIN, RISCV_FEATURE_HASSTDEXTZDINX, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.d.l $rd, $rs1$frm */ + RISCV_FCVT_D_L /* 11841 */, RISCV_INS_FCVT_D_L, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTD, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.d.lu $rd, $rs1$frm */ + RISCV_FCVT_D_LU /* 11842 */, RISCV_INS_FCVT_D_LU, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTD, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.d.lu $rd, $rs1$frm */ + RISCV_FCVT_D_LU_INX /* 11843 */, RISCV_INS_FCVT_D_LU, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZDINX, RISCV_FEATURE_ISRV64, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.d.l $rd, $rs1$frm */ + RISCV_FCVT_D_L_INX /* 11844 */, RISCV_INS_FCVT_D_L, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZDINX, RISCV_FEATURE_ISRV64, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.d.s $rd, $rs1$frm */ + RISCV_FCVT_D_S /* 11845 */, RISCV_INS_FCVT_D_S, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTD, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.d.s $rd, $rs1$frm */ + RISCV_FCVT_D_S_IN32X /* 11846 */, RISCV_INS_FCVT_D_S, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZDINX, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.d.s $rd, $rs1$frm */ + RISCV_FCVT_D_S_INX /* 11847 */, RISCV_INS_FCVT_D_S, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZDINX, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.d.w $rd, $rs1$frm */ + RISCV_FCVT_D_W /* 11848 */, RISCV_INS_FCVT_D_W, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTD, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.d.wu $rd, $rs1$frm */ + RISCV_FCVT_D_WU /* 11849 */, RISCV_INS_FCVT_D_WU, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTD, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.d.wu $rd, $rs1$frm */ + RISCV_FCVT_D_WU_IN32X /* 11850 */, RISCV_INS_FCVT_D_WU, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZDINX, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.d.wu $rd, $rs1$frm */ + RISCV_FCVT_D_WU_INX /* 11851 */, RISCV_INS_FCVT_D_WU, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZDINX, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.d.w $rd, $rs1$frm */ + RISCV_FCVT_D_W_IN32X /* 11852 */, RISCV_INS_FCVT_D_W, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZDINX, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.d.w $rd, $rs1$frm */ + RISCV_FCVT_D_W_INX /* 11853 */, RISCV_INS_FCVT_D_W, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZDINX, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.h.d $rd, $rs1$frm */ + RISCV_FCVT_H_D /* 11854 */, RISCV_INS_FCVT_H_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFHMIN, RISCV_FEATURE_HASSTDEXTD, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.h.d $rd, $rs1$frm */ + RISCV_FCVT_H_D_IN32X /* 11855 */, RISCV_INS_FCVT_H_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZHINXMIN, RISCV_FEATURE_HASSTDEXTZDINX, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.h.d $rd, $rs1$frm */ + RISCV_FCVT_H_D_INX /* 11856 */, RISCV_INS_FCVT_H_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZHINXMIN, RISCV_FEATURE_HASSTDEXTZDINX, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.h.l $rd, $rs1$frm */ + RISCV_FCVT_H_L /* 11857 */, RISCV_INS_FCVT_H_L, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFH, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.h.lu $rd, $rs1$frm */ + RISCV_FCVT_H_LU /* 11858 */, RISCV_INS_FCVT_H_LU, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFH, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.h.lu $rd, $rs1$frm */ + RISCV_FCVT_H_LU_INX /* 11859 */, RISCV_INS_FCVT_H_LU, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZHINX, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.h.l $rd, $rs1$frm */ + RISCV_FCVT_H_L_INX /* 11860 */, RISCV_INS_FCVT_H_L, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZHINX, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.h.s $rd, $rs1$frm */ + RISCV_FCVT_H_S /* 11861 */, RISCV_INS_FCVT_H_S, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFHMIN, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.h.s $rd, $rs1$frm */ + RISCV_FCVT_H_S_INX /* 11862 */, RISCV_INS_FCVT_H_S, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZHINXMIN, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.h.w $rd, $rs1$frm */ + RISCV_FCVT_H_W /* 11863 */, RISCV_INS_FCVT_H_W, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFH, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.h.wu $rd, $rs1$frm */ + RISCV_FCVT_H_WU /* 11864 */, RISCV_INS_FCVT_H_WU, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFH, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.h.wu $rd, $rs1$frm */ + RISCV_FCVT_H_WU_INX /* 11865 */, RISCV_INS_FCVT_H_WU, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZHINX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.h.w $rd, $rs1$frm */ + RISCV_FCVT_H_W_INX /* 11866 */, RISCV_INS_FCVT_H_W, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZHINX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.lu.d $rd, $rs1$frm */ + RISCV_FCVT_LU_D /* 11867 */, RISCV_INS_FCVT_LU_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTD, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.lu.d $rd, $rs1$frm */ + RISCV_FCVT_LU_D_INX /* 11868 */, RISCV_INS_FCVT_LU_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZDINX, RISCV_FEATURE_ISRV64, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.lu.h $rd, $rs1$frm */ + RISCV_FCVT_LU_H /* 11869 */, RISCV_INS_FCVT_LU_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFH, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.lu.h $rd, $rs1$frm */ + RISCV_FCVT_LU_H_INX /* 11870 */, RISCV_INS_FCVT_LU_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZHINX, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.lu.s $rd, $rs1$frm */ + RISCV_FCVT_LU_S /* 11871 */, RISCV_INS_FCVT_LU_S, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTF, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.lu.s $rd, $rs1$frm */ + RISCV_FCVT_LU_S_INX /* 11872 */, RISCV_INS_FCVT_LU_S, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFINX, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.l.d $rd, $rs1$frm */ + RISCV_FCVT_L_D /* 11873 */, RISCV_INS_FCVT_L_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTD, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.l.d $rd, $rs1$frm */ + RISCV_FCVT_L_D_INX /* 11874 */, RISCV_INS_FCVT_L_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZDINX, RISCV_FEATURE_ISRV64, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.l.h $rd, $rs1$frm */ + RISCV_FCVT_L_H /* 11875 */, RISCV_INS_FCVT_L_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFH, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.l.h $rd, $rs1$frm */ + RISCV_FCVT_L_H_INX /* 11876 */, RISCV_INS_FCVT_L_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZHINX, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.l.s $rd, $rs1$frm */ + RISCV_FCVT_L_S /* 11877 */, RISCV_INS_FCVT_L_S, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTF, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.l.s $rd, $rs1$frm */ + RISCV_FCVT_L_S_INX /* 11878 */, RISCV_INS_FCVT_L_S, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFINX, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.s.bf16 $rd, $rs1$frm */ + RISCV_FCVT_S_BF16 /* 11879 */, RISCV_INS_FCVT_S_BF16, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFBFMIN, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.s.d $rd, $rs1$frm */ + RISCV_FCVT_S_D /* 11880 */, RISCV_INS_FCVT_S_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTD, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.s.d $rd, $rs1$frm */ + RISCV_FCVT_S_D_IN32X /* 11881 */, RISCV_INS_FCVT_S_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZDINX, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.s.d $rd, $rs1$frm */ + RISCV_FCVT_S_D_INX /* 11882 */, RISCV_INS_FCVT_S_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZDINX, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.s.h $rd, $rs1$frm */ + RISCV_FCVT_S_H /* 11883 */, RISCV_INS_FCVT_S_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFHMIN, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.s.h $rd, $rs1$frm */ + RISCV_FCVT_S_H_INX /* 11884 */, RISCV_INS_FCVT_S_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZHINXMIN, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.s.l $rd, $rs1$frm */ + RISCV_FCVT_S_L /* 11885 */, RISCV_INS_FCVT_S_L, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTF, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.s.lu $rd, $rs1$frm */ + RISCV_FCVT_S_LU /* 11886 */, RISCV_INS_FCVT_S_LU, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTF, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.s.lu $rd, $rs1$frm */ + RISCV_FCVT_S_LU_INX /* 11887 */, RISCV_INS_FCVT_S_LU, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFINX, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.s.l $rd, $rs1$frm */ + RISCV_FCVT_S_L_INX /* 11888 */, RISCV_INS_FCVT_S_L, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFINX, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.s.w $rd, $rs1$frm */ + RISCV_FCVT_S_W /* 11889 */, RISCV_INS_FCVT_S_W, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.s.wu $rd, $rs1$frm */ + RISCV_FCVT_S_WU /* 11890 */, RISCV_INS_FCVT_S_WU, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.s.wu $rd, $rs1$frm */ + RISCV_FCVT_S_WU_INX /* 11891 */, RISCV_INS_FCVT_S_WU, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFINX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.s.w $rd, $rs1$frm */ + RISCV_FCVT_S_W_INX /* 11892 */, RISCV_INS_FCVT_S_W, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFINX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.wu.d $rd, $rs1$frm */ + RISCV_FCVT_WU_D /* 11893 */, RISCV_INS_FCVT_WU_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTD, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.wu.d $rd, $rs1$frm */ + RISCV_FCVT_WU_D_IN32X /* 11894 */, RISCV_INS_FCVT_WU_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZDINX, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.wu.d $rd, $rs1$frm */ + RISCV_FCVT_WU_D_INX /* 11895 */, RISCV_INS_FCVT_WU_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZDINX, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.wu.h $rd, $rs1$frm */ + RISCV_FCVT_WU_H /* 11896 */, RISCV_INS_FCVT_WU_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFH, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.wu.h $rd, $rs1$frm */ + RISCV_FCVT_WU_H_INX /* 11897 */, RISCV_INS_FCVT_WU_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZHINX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.wu.s $rd, $rs1$frm */ + RISCV_FCVT_WU_S /* 11898 */, RISCV_INS_FCVT_WU_S, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.wu.s $rd, $rs1$frm */ + RISCV_FCVT_WU_S_INX /* 11899 */, RISCV_INS_FCVT_WU_S, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFINX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.w.d $rd, $rs1$frm */ + RISCV_FCVT_W_D /* 11900 */, RISCV_INS_FCVT_W_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTD, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.w.d $rd, $rs1$frm */ + RISCV_FCVT_W_D_IN32X /* 11901 */, RISCV_INS_FCVT_W_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZDINX, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.w.d $rd, $rs1$frm */ + RISCV_FCVT_W_D_INX /* 11902 */, RISCV_INS_FCVT_W_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZDINX, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.w.h $rd, $rs1$frm */ + RISCV_FCVT_W_H /* 11903 */, RISCV_INS_FCVT_W_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFH, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.w.h $rd, $rs1$frm */ + RISCV_FCVT_W_H_INX /* 11904 */, RISCV_INS_FCVT_W_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZHINX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.w.s $rd, $rs1$frm */ + RISCV_FCVT_W_S /* 11905 */, RISCV_INS_FCVT_W_S, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fcvt.w.s $rd, $rs1$frm */ + RISCV_FCVT_W_S_INX /* 11906 */, RISCV_INS_FCVT_W_S, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFINX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fdiv.d $rd, $rs1, $rs2$frm */ + RISCV_FDIV_D /* 11907 */, RISCV_INS_FDIV_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTD, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fdiv.d $rd, $rs1, $rs2$frm */ + RISCV_FDIV_D_IN32X /* 11908 */, RISCV_INS_FDIV_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZDINX, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fdiv.d $rd, $rs1, $rs2$frm */ + RISCV_FDIV_D_INX /* 11909 */, RISCV_INS_FDIV_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZDINX, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fdiv.h $rd, $rs1, $rs2$frm */ + RISCV_FDIV_H /* 11910 */, RISCV_INS_FDIV_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFH, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fdiv.h $rd, $rs1, $rs2$frm */ + RISCV_FDIV_H_INX /* 11911 */, RISCV_INS_FDIV_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZHINX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fdiv.s $rd, $rs1, $rs2$frm */ + RISCV_FDIV_S /* 11912 */, RISCV_INS_FDIV_S, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fdiv.s $rd, $rs1, $rs2$frm */ + RISCV_FDIV_S_INX /* 11913 */, RISCV_INS_FDIV_S, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFINX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fence $pred, $succ */ + RISCV_FENCE /* 11914 */, RISCV_INS_FENCE, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fence.i */ + RISCV_FENCE_I /* 11915 */, RISCV_INS_FENCE_I, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fence.tso */ + RISCV_FENCE_TSO /* 11916 */, RISCV_INS_FENCE_TSO, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* feq.d $rd, $rs1, $rs2 */ + RISCV_FEQ_D /* 11917 */, RISCV_INS_FEQ_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTD, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* feq.d $rd, $rs1, $rs2 */ + RISCV_FEQ_D_IN32X /* 11918 */, RISCV_INS_FEQ_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZDINX, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* feq.d $rd, $rs1, $rs2 */ + RISCV_FEQ_D_INX /* 11919 */, RISCV_INS_FEQ_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZDINX, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* feq.h $rd, $rs1, $rs2 */ + RISCV_FEQ_H /* 11920 */, RISCV_INS_FEQ_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFH, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* feq.h $rd, $rs1, $rs2 */ + RISCV_FEQ_H_INX /* 11921 */, RISCV_INS_FEQ_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZHINX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* feq.s $rd, $rs1, $rs2 */ + RISCV_FEQ_S /* 11922 */, RISCV_INS_FEQ_S, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* feq.s $rd, $rs1, $rs2 */ + RISCV_FEQ_S_INX /* 11923 */, RISCV_INS_FEQ_S, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFINX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fld $rd, ${imm12}(${rs1}) */ + RISCV_FLD /* 11924 */, RISCV_INS_FLD, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTD, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fleq.d $rd, $rs1, $rs2 */ + RISCV_FLEQ_D /* 11925 */, RISCV_INS_FLEQ_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFA, RISCV_FEATURE_HASSTDEXTD, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fleq.h $rd, $rs1, $rs2 */ + RISCV_FLEQ_H /* 11926 */, RISCV_INS_FLEQ_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFA, RISCV_FEATURE_HASSTDEXTZFH, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fleq.s $rd, $rs1, $rs2 */ + RISCV_FLEQ_S /* 11927 */, RISCV_INS_FLEQ_S, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fle.d $rd, $rs1, $rs2 */ + RISCV_FLE_D /* 11928 */, RISCV_INS_FLE_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTD, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fle.d $rd, $rs1, $rs2 */ + RISCV_FLE_D_IN32X /* 11929 */, RISCV_INS_FLE_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZDINX, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fle.d $rd, $rs1, $rs2 */ + RISCV_FLE_D_INX /* 11930 */, RISCV_INS_FLE_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZDINX, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fle.h $rd, $rs1, $rs2 */ + RISCV_FLE_H /* 11931 */, RISCV_INS_FLE_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFH, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fle.h $rd, $rs1, $rs2 */ + RISCV_FLE_H_INX /* 11932 */, RISCV_INS_FLE_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZHINX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fle.s $rd, $rs1, $rs2 */ + RISCV_FLE_S /* 11933 */, RISCV_INS_FLE_S, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fle.s $rd, $rs1, $rs2 */ + RISCV_FLE_S_INX /* 11934 */, RISCV_INS_FLE_S, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFINX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* flh $rd, ${imm12}(${rs1}) */ + RISCV_FLH /* 11935 */, RISCV_INS_FLH, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASHALFFPLOADSTOREMOVE, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fli.d $rd, $imm */ + RISCV_FLI_D /* 11936 */, RISCV_INS_FLI_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFA, RISCV_FEATURE_HASSTDEXTD, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fli.h $rd, $imm */ + RISCV_FLI_H /* 11937 */, RISCV_INS_FLI_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFA, RISCV_FEATURE_HASSTDEXTZFHORZVFH, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fli.s $rd, $imm */ + RISCV_FLI_S /* 11938 */, RISCV_INS_FLI_S, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fltq.d $rd, $rs1, $rs2 */ + RISCV_FLTQ_D /* 11939 */, RISCV_INS_FLTQ_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFA, RISCV_FEATURE_HASSTDEXTD, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fltq.h $rd, $rs1, $rs2 */ + RISCV_FLTQ_H /* 11940 */, RISCV_INS_FLTQ_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFA, RISCV_FEATURE_HASSTDEXTZFH, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fltq.s $rd, $rs1, $rs2 */ + RISCV_FLTQ_S /* 11941 */, RISCV_INS_FLTQ_S, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* flt.d $rd, $rs1, $rs2 */ + RISCV_FLT_D /* 11942 */, RISCV_INS_FLT_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTD, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* flt.d $rd, $rs1, $rs2 */ + RISCV_FLT_D_IN32X /* 11943 */, RISCV_INS_FLT_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZDINX, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* flt.d $rd, $rs1, $rs2 */ + RISCV_FLT_D_INX /* 11944 */, RISCV_INS_FLT_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZDINX, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* flt.h $rd, $rs1, $rs2 */ + RISCV_FLT_H /* 11945 */, RISCV_INS_FLT_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFH, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* flt.h $rd, $rs1, $rs2 */ + RISCV_FLT_H_INX /* 11946 */, RISCV_INS_FLT_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZHINX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* flt.s $rd, $rs1, $rs2 */ + RISCV_FLT_S /* 11947 */, RISCV_INS_FLT_S, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* flt.s $rd, $rs1, $rs2 */ + RISCV_FLT_S_INX /* 11948 */, RISCV_INS_FLT_S, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFINX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* flw $rd, ${imm12}(${rs1}) */ + RISCV_FLW /* 11949 */, RISCV_INS_FLW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fmadd.d $rd, $rs1, $rs2, $rs3$frm */ + RISCV_FMADD_D /* 11950 */, RISCV_INS_FMADD_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTD, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fmadd.d $rd, $rs1, $rs2, $rs3$frm */ + RISCV_FMADD_D_IN32X /* 11951 */, RISCV_INS_FMADD_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZDINX, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fmadd.d $rd, $rs1, $rs2, $rs3$frm */ + RISCV_FMADD_D_INX /* 11952 */, RISCV_INS_FMADD_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZDINX, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fmadd.h $rd, $rs1, $rs2, $rs3$frm */ + RISCV_FMADD_H /* 11953 */, RISCV_INS_FMADD_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFH, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fmadd.h $rd, $rs1, $rs2, $rs3$frm */ + RISCV_FMADD_H_INX /* 11954 */, RISCV_INS_FMADD_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZHINX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fmadd.s $rd, $rs1, $rs2, $rs3$frm */ + RISCV_FMADD_S /* 11955 */, RISCV_INS_FMADD_S, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fmadd.s $rd, $rs1, $rs2, $rs3$frm */ + RISCV_FMADD_S_INX /* 11956 */, RISCV_INS_FMADD_S, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFINX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fmaxm.d $rd, $rs1, $rs2 */ + RISCV_FMAXM_D /* 11957 */, RISCV_INS_FMAXM_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFA, RISCV_FEATURE_HASSTDEXTD, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fmaxm.h $rd, $rs1, $rs2 */ + RISCV_FMAXM_H /* 11958 */, RISCV_INS_FMAXM_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFA, RISCV_FEATURE_HASSTDEXTZFH, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fmaxm.s $rd, $rs1, $rs2 */ + RISCV_FMAXM_S /* 11959 */, RISCV_INS_FMAXM_S, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fmax.d $rd, $rs1, $rs2 */ + RISCV_FMAX_D /* 11960 */, RISCV_INS_FMAX_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTD, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fmax.d $rd, $rs1, $rs2 */ + RISCV_FMAX_D_IN32X /* 11961 */, RISCV_INS_FMAX_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZDINX, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fmax.d $rd, $rs1, $rs2 */ + RISCV_FMAX_D_INX /* 11962 */, RISCV_INS_FMAX_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZDINX, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fmax.h $rd, $rs1, $rs2 */ + RISCV_FMAX_H /* 11963 */, RISCV_INS_FMAX_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFH, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fmax.h $rd, $rs1, $rs2 */ + RISCV_FMAX_H_INX /* 11964 */, RISCV_INS_FMAX_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZHINX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fmax.s $rd, $rs1, $rs2 */ + RISCV_FMAX_S /* 11965 */, RISCV_INS_FMAX_S, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fmax.s $rd, $rs1, $rs2 */ + RISCV_FMAX_S_INX /* 11966 */, RISCV_INS_FMAX_S, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFINX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fminm.d $rd, $rs1, $rs2 */ + RISCV_FMINM_D /* 11967 */, RISCV_INS_FMINM_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFA, RISCV_FEATURE_HASSTDEXTD, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fminm.h $rd, $rs1, $rs2 */ + RISCV_FMINM_H /* 11968 */, RISCV_INS_FMINM_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFA, RISCV_FEATURE_HASSTDEXTZFH, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fminm.s $rd, $rs1, $rs2 */ + RISCV_FMINM_S /* 11969 */, RISCV_INS_FMINM_S, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fmin.d $rd, $rs1, $rs2 */ + RISCV_FMIN_D /* 11970 */, RISCV_INS_FMIN_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTD, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fmin.d $rd, $rs1, $rs2 */ + RISCV_FMIN_D_IN32X /* 11971 */, RISCV_INS_FMIN_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZDINX, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fmin.d $rd, $rs1, $rs2 */ + RISCV_FMIN_D_INX /* 11972 */, RISCV_INS_FMIN_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZDINX, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fmin.h $rd, $rs1, $rs2 */ + RISCV_FMIN_H /* 11973 */, RISCV_INS_FMIN_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFH, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fmin.h $rd, $rs1, $rs2 */ + RISCV_FMIN_H_INX /* 11974 */, RISCV_INS_FMIN_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZHINX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fmin.s $rd, $rs1, $rs2 */ + RISCV_FMIN_S /* 11975 */, RISCV_INS_FMIN_S, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fmin.s $rd, $rs1, $rs2 */ + RISCV_FMIN_S_INX /* 11976 */, RISCV_INS_FMIN_S, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFINX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fmsub.d $rd, $rs1, $rs2, $rs3$frm */ + RISCV_FMSUB_D /* 11977 */, RISCV_INS_FMSUB_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTD, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fmsub.d $rd, $rs1, $rs2, $rs3$frm */ + RISCV_FMSUB_D_IN32X /* 11978 */, RISCV_INS_FMSUB_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZDINX, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fmsub.d $rd, $rs1, $rs2, $rs3$frm */ + RISCV_FMSUB_D_INX /* 11979 */, RISCV_INS_FMSUB_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZDINX, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fmsub.h $rd, $rs1, $rs2, $rs3$frm */ + RISCV_FMSUB_H /* 11980 */, RISCV_INS_FMSUB_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFH, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fmsub.h $rd, $rs1, $rs2, $rs3$frm */ + RISCV_FMSUB_H_INX /* 11981 */, RISCV_INS_FMSUB_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZHINX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fmsub.s $rd, $rs1, $rs2, $rs3$frm */ + RISCV_FMSUB_S /* 11982 */, RISCV_INS_FMSUB_S, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fmsub.s $rd, $rs1, $rs2, $rs3$frm */ + RISCV_FMSUB_S_INX /* 11983 */, RISCV_INS_FMSUB_S, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFINX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fmul.d $rd, $rs1, $rs2$frm */ + RISCV_FMUL_D /* 11984 */, RISCV_INS_FMUL_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTD, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fmul.d $rd, $rs1, $rs2$frm */ + RISCV_FMUL_D_IN32X /* 11985 */, RISCV_INS_FMUL_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZDINX, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fmul.d $rd, $rs1, $rs2$frm */ + RISCV_FMUL_D_INX /* 11986 */, RISCV_INS_FMUL_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZDINX, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fmul.h $rd, $rs1, $rs2$frm */ + RISCV_FMUL_H /* 11987 */, RISCV_INS_FMUL_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFH, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fmul.h $rd, $rs1, $rs2$frm */ + RISCV_FMUL_H_INX /* 11988 */, RISCV_INS_FMUL_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZHINX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fmul.s $rd, $rs1, $rs2$frm */ + RISCV_FMUL_S /* 11989 */, RISCV_INS_FMUL_S, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fmul.s $rd, $rs1, $rs2$frm */ + RISCV_FMUL_S_INX /* 11990 */, RISCV_INS_FMUL_S, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFINX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fmvh.x.d $rd, $rs1 */ + RISCV_FMVH_X_D /* 11991 */, RISCV_INS_FMVH_X_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFA, RISCV_FEATURE_HASSTDEXTD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fmvp.d.x $rd, $rs1, $rs2 */ + RISCV_FMVP_D_X /* 11992 */, RISCV_INS_FMVP_D_X, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFA, RISCV_FEATURE_HASSTDEXTD, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fmv.d.x $rd, $rs1 */ + RISCV_FMV_D_X /* 11993 */, RISCV_INS_FMV_D_X, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTD, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fmv.h.x $rd, $rs1 */ + RISCV_FMV_H_X /* 11994 */, RISCV_INS_FMV_H_X, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASHALFFPLOADSTOREMOVE, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fmv.w.x $rd, $rs1 */ + RISCV_FMV_W_X /* 11995 */, RISCV_INS_FMV_W_X, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fmv.x.d $rd, $rs1 */ + RISCV_FMV_X_D /* 11996 */, RISCV_INS_FMV_X_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTD, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fmv.x.h $rd, $rs1 */ + RISCV_FMV_X_H /* 11997 */, RISCV_INS_FMV_X_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASHALFFPLOADSTOREMOVE, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fmv.x.w $rd, $rs1 */ + RISCV_FMV_X_W /* 11998 */, RISCV_INS_FMV_X_W, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fmv.x.w $rd, $rs1 */ + RISCV_FMV_X_W_FPR64 /* 11999 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* fnmadd.d $rd, $rs1, $rs2, $rs3$frm */ + RISCV_FNMADD_D /* 12000 */, RISCV_INS_FNMADD_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTD, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fnmadd.d $rd, $rs1, $rs2, $rs3$frm */ + RISCV_FNMADD_D_IN32X /* 12001 */, RISCV_INS_FNMADD_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZDINX, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fnmadd.d $rd, $rs1, $rs2, $rs3$frm */ + RISCV_FNMADD_D_INX /* 12002 */, RISCV_INS_FNMADD_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZDINX, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fnmadd.h $rd, $rs1, $rs2, $rs3$frm */ + RISCV_FNMADD_H /* 12003 */, RISCV_INS_FNMADD_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFH, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fnmadd.h $rd, $rs1, $rs2, $rs3$frm */ + RISCV_FNMADD_H_INX /* 12004 */, RISCV_INS_FNMADD_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZHINX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fnmadd.s $rd, $rs1, $rs2, $rs3$frm */ + RISCV_FNMADD_S /* 12005 */, RISCV_INS_FNMADD_S, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fnmadd.s $rd, $rs1, $rs2, $rs3$frm */ + RISCV_FNMADD_S_INX /* 12006 */, RISCV_INS_FNMADD_S, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFINX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fnmsub.d $rd, $rs1, $rs2, $rs3$frm */ + RISCV_FNMSUB_D /* 12007 */, RISCV_INS_FNMSUB_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTD, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fnmsub.d $rd, $rs1, $rs2, $rs3$frm */ + RISCV_FNMSUB_D_IN32X /* 12008 */, RISCV_INS_FNMSUB_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZDINX, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fnmsub.d $rd, $rs1, $rs2, $rs3$frm */ + RISCV_FNMSUB_D_INX /* 12009 */, RISCV_INS_FNMSUB_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZDINX, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fnmsub.h $rd, $rs1, $rs2, $rs3$frm */ + RISCV_FNMSUB_H /* 12010 */, RISCV_INS_FNMSUB_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFH, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fnmsub.h $rd, $rs1, $rs2, $rs3$frm */ + RISCV_FNMSUB_H_INX /* 12011 */, RISCV_INS_FNMSUB_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZHINX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fnmsub.s $rd, $rs1, $rs2, $rs3$frm */ + RISCV_FNMSUB_S /* 12012 */, RISCV_INS_FNMSUB_S, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fnmsub.s $rd, $rs1, $rs2, $rs3$frm */ + RISCV_FNMSUB_S_INX /* 12013 */, RISCV_INS_FNMSUB_S, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFINX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* froundnx.d $rd, $rs1$frm */ + RISCV_FROUNDNX_D /* 12014 */, RISCV_INS_FROUNDNX_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFA, RISCV_FEATURE_HASSTDEXTD, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* froundnx.h $rd, $rs1$frm */ + RISCV_FROUNDNX_H /* 12015 */, RISCV_INS_FROUNDNX_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFA, RISCV_FEATURE_HASSTDEXTZFH, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* froundnx.s $rd, $rs1$frm */ + RISCV_FROUNDNX_S /* 12016 */, RISCV_INS_FROUNDNX_S, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fround.d $rd, $rs1$frm */ + RISCV_FROUND_D /* 12017 */, RISCV_INS_FROUND_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFA, RISCV_FEATURE_HASSTDEXTD, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fround.h $rd, $rs1$frm */ + RISCV_FROUND_H /* 12018 */, RISCV_INS_FROUND_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFA, RISCV_FEATURE_HASSTDEXTZFH, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fround.s $rd, $rs1$frm */ + RISCV_FROUND_S /* 12019 */, RISCV_INS_FROUND_S, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fsd $rs2, ${imm12}(${rs1}) */ + RISCV_FSD /* 12020 */, RISCV_INS_FSD, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTD, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fsgnjn.d $rd, $rs1, $rs2 */ + RISCV_FSGNJN_D /* 12021 */, RISCV_INS_FSGNJN_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTD, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fsgnjn.d $rd, $rs1, $rs2 */ + RISCV_FSGNJN_D_IN32X /* 12022 */, RISCV_INS_FSGNJN_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZDINX, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fsgnjn.d $rd, $rs1, $rs2 */ + RISCV_FSGNJN_D_INX /* 12023 */, RISCV_INS_FSGNJN_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZDINX, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fsgnjn.h $rd, $rs1, $rs2 */ + RISCV_FSGNJN_H /* 12024 */, RISCV_INS_FSGNJN_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFH, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fsgnjn.h $rd, $rs1, $rs2 */ + RISCV_FSGNJN_H_INX /* 12025 */, RISCV_INS_FSGNJN_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZHINX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fsgnjn.s $rd, $rs1, $rs2 */ + RISCV_FSGNJN_S /* 12026 */, RISCV_INS_FSGNJN_S, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fsgnjn.s $rd, $rs1, $rs2 */ + RISCV_FSGNJN_S_INX /* 12027 */, RISCV_INS_FSGNJN_S, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFINX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fsgnjx.d $rd, $rs1, $rs2 */ + RISCV_FSGNJX_D /* 12028 */, RISCV_INS_FSGNJX_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTD, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fsgnjx.d $rd, $rs1, $rs2 */ + RISCV_FSGNJX_D_IN32X /* 12029 */, RISCV_INS_FSGNJX_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZDINX, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fsgnjx.d $rd, $rs1, $rs2 */ + RISCV_FSGNJX_D_INX /* 12030 */, RISCV_INS_FSGNJX_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZDINX, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fsgnjx.h $rd, $rs1, $rs2 */ + RISCV_FSGNJX_H /* 12031 */, RISCV_INS_FSGNJX_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFH, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fsgnjx.h $rd, $rs1, $rs2 */ + RISCV_FSGNJX_H_INX /* 12032 */, RISCV_INS_FSGNJX_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZHINX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fsgnjx.s $rd, $rs1, $rs2 */ + RISCV_FSGNJX_S /* 12033 */, RISCV_INS_FSGNJX_S, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fsgnjx.s $rd, $rs1, $rs2 */ + RISCV_FSGNJX_S_INX /* 12034 */, RISCV_INS_FSGNJX_S, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFINX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fsgnj.d $rd, $rs1, $rs2 */ + RISCV_FSGNJ_D /* 12035 */, RISCV_INS_FSGNJ_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTD, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fsgnj.d $rd, $rs1, $rs2 */ + RISCV_FSGNJ_D_IN32X /* 12036 */, RISCV_INS_FSGNJ_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZDINX, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fsgnj.d $rd, $rs1, $rs2 */ + RISCV_FSGNJ_D_INX /* 12037 */, RISCV_INS_FSGNJ_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZDINX, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fsgnj.h $rd, $rs1, $rs2 */ + RISCV_FSGNJ_H /* 12038 */, RISCV_INS_FSGNJ_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFH, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fsgnj.h $rd, $rs1, $rs2 */ + RISCV_FSGNJ_H_INX /* 12039 */, RISCV_INS_FSGNJ_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZHINX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fsgnj.s $rd, $rs1, $rs2 */ + RISCV_FSGNJ_S /* 12040 */, RISCV_INS_FSGNJ_S, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fsgnj.s $rd, $rs1, $rs2 */ + RISCV_FSGNJ_S_INX /* 12041 */, RISCV_INS_FSGNJ_S, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFINX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fsh $rs2, ${imm12}(${rs1}) */ + RISCV_FSH /* 12042 */, RISCV_INS_FSH, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASHALFFPLOADSTOREMOVE, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fsqrt.d $rd, $rs1$frm */ + RISCV_FSQRT_D /* 12043 */, RISCV_INS_FSQRT_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTD, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fsqrt.d $rd, $rs1$frm */ + RISCV_FSQRT_D_IN32X /* 12044 */, RISCV_INS_FSQRT_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZDINX, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fsqrt.d $rd, $rs1$frm */ + RISCV_FSQRT_D_INX /* 12045 */, RISCV_INS_FSQRT_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZDINX, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fsqrt.h $rd, $rs1$frm */ + RISCV_FSQRT_H /* 12046 */, RISCV_INS_FSQRT_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFH, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fsqrt.h $rd, $rs1$frm */ + RISCV_FSQRT_H_INX /* 12047 */, RISCV_INS_FSQRT_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZHINX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fsqrt.s $rd, $rs1$frm */ + RISCV_FSQRT_S /* 12048 */, RISCV_INS_FSQRT_S, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fsqrt.s $rd, $rs1$frm */ + RISCV_FSQRT_S_INX /* 12049 */, RISCV_INS_FSQRT_S, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFINX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fsub.d $rd, $rs1, $rs2$frm */ + RISCV_FSUB_D /* 12050 */, RISCV_INS_FSUB_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTD, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fsub.d $rd, $rs1, $rs2$frm */ + RISCV_FSUB_D_IN32X /* 12051 */, RISCV_INS_FSUB_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZDINX, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fsub.d $rd, $rs1, $rs2$frm */ + RISCV_FSUB_D_INX /* 12052 */, RISCV_INS_FSUB_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZDINX, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fsub.h $rd, $rs1, $rs2$frm */ + RISCV_FSUB_H /* 12053 */, RISCV_INS_FSUB_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFH, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fsub.h $rd, $rs1, $rs2$frm */ + RISCV_FSUB_H_INX /* 12054 */, RISCV_INS_FSUB_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZHINX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fsub.s $rd, $rs1, $rs2$frm */ + RISCV_FSUB_S /* 12055 */, RISCV_INS_FSUB_S, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fsub.s $rd, $rs1, $rs2$frm */ + RISCV_FSUB_S_INX /* 12056 */, RISCV_INS_FSUB_S, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZFINX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* fsw $rs2, ${imm12}(${rs1}) */ + RISCV_FSW /* 12057 */, RISCV_INS_FSW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* hfence.gvma $rs1, $rs2 */ + RISCV_HFENCE_GVMA /* 12058 */, RISCV_INS_HFENCE_GVMA, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTH, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* hfence.vvma $rs1, $rs2 */ + RISCV_HFENCE_VVMA /* 12059 */, RISCV_INS_HFENCE_VVMA, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTH, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* hinval.gvma $rs1, $rs2 */ + RISCV_HINVAL_GVMA /* 12060 */, RISCV_INS_HINVAL_GVMA, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTSVINVAL, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* hinval.vvma $rs1, $rs2 */ + RISCV_HINVAL_VVMA /* 12061 */, RISCV_INS_HINVAL_VVMA, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTSVINVAL, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* hlvx.hu $rd, $rs1 */ + RISCV_HLVX_HU /* 12062 */, RISCV_INS_HLVX_HU, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTH, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* hlvx.wu $rd, $rs1 */ + RISCV_HLVX_WU /* 12063 */, RISCV_INS_HLVX_WU, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTH, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* hlv.b $rd, $rs1 */ + RISCV_HLV_B /* 12064 */, RISCV_INS_HLV_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTH, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* hlv.bu $rd, $rs1 */ + RISCV_HLV_BU /* 12065 */, RISCV_INS_HLV_BU, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTH, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* hlv.d $rd, $rs1 */ + RISCV_HLV_D /* 12066 */, RISCV_INS_HLV_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_ISRV64, RISCV_FEATURE_HASSTDEXTH, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* hlv.h $rd, $rs1 */ + RISCV_HLV_H /* 12067 */, RISCV_INS_HLV_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTH, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* hlv.hu $rd, $rs1 */ + RISCV_HLV_HU /* 12068 */, RISCV_INS_HLV_HU, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTH, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* hlv.w $rd, $rs1 */ + RISCV_HLV_W /* 12069 */, RISCV_INS_HLV_W, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTH, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* hlv.wu $rd, $rs1 */ + RISCV_HLV_WU /* 12070 */, RISCV_INS_HLV_WU, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_ISRV64, RISCV_FEATURE_HASSTDEXTH, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* hsv.b $rs2, $rs1 */ + RISCV_HSV_B /* 12071 */, RISCV_INS_HSV_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTH, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* hsv.d $rs2, $rs1 */ + RISCV_HSV_D /* 12072 */, RISCV_INS_HSV_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_ISRV64, RISCV_FEATURE_HASSTDEXTH, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* hsv.h $rs2, $rs1 */ + RISCV_HSV_H /* 12073 */, RISCV_INS_HSV_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTH, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* hsv.w $rs2, $rs1 */ + RISCV_HSV_W /* 12074 */, RISCV_INS_HSV_W, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTH, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* .insn b $opcode, $funct3, $rs1, $rs2, $imm12 */ + RISCV_InsnB /* 12075 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* .insn ca $opcode, $funct6, $funct2, $rd, $rs2 */ + RISCV_InsnCA /* 12076 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* .insn cb $opcode, $funct3, $rs1, $imm8 */ + RISCV_InsnCB /* 12077 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* .insn ci $opcode, $funct3, $rd, $imm6 */ + RISCV_InsnCI /* 12078 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* .insn ciw $opcode, $funct3, $rd, $imm8 */ + RISCV_InsnCIW /* 12079 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* .insn cj $opcode, $funct3, $imm11 */ + RISCV_InsnCJ /* 12080 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* .insn cl $opcode, $funct3, $rd, ${imm5}(${rs1}) */ + RISCV_InsnCL /* 12081 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* .insn cr $opcode, $funct4, $rd, $rs2 */ + RISCV_InsnCR /* 12082 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* .insn cs $opcode, $funct3, $rs2, ${imm5}(${rs1}) */ + RISCV_InsnCS /* 12083 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* .insn css $opcode, $funct3, $rs2, $imm6 */ + RISCV_InsnCSS /* 12084 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* .insn i $opcode, $funct3, $rd, $rs1, $imm12 */ + RISCV_InsnI /* 12085 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* .insn i $opcode, $funct3, $rd, ${imm12}(${rs1}) */ + RISCV_InsnI_Mem /* 12086 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* .insn j $opcode, $rd, $imm20 */ + RISCV_InsnJ /* 12087 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* .insn r $opcode, $funct3, $funct7, $rd, $rs1, $rs2 */ + RISCV_InsnR /* 12088 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* .insn r4 $opcode, $funct3, $funct2, $rd, $rs1, $rs2, $rs3 */ + RISCV_InsnR4 /* 12089 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* .insn s $opcode, $funct3, $rs2, ${imm12}(${rs1}) */ + RISCV_InsnS /* 12090 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* .insn u $opcode, $rd, $imm20 */ + RISCV_InsnU /* 12091 */, RISCV_INS_INVALID, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + #endif +}, +{ + /* jal $rd, $imm20 */ + RISCV_JAL /* 12092 */, RISCV_INS_JAL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_GRP_CALL, RISCV_GRP_BRANCH_RELATIVE, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* jalr $rd, ${imm12}(${rs1}) */ + RISCV_JALR /* 12093 */, RISCV_INS_JALR, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_GRP_CALL, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* lb $rd, ${imm12}(${rs1}) */ + RISCV_LB /* 12094 */, RISCV_INS_LB, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* lbu $rd, ${imm12}(${rs1}) */ + RISCV_LBU /* 12095 */, RISCV_INS_LBU, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* ld $rd, ${imm12}(${rs1}) */ + RISCV_LD /* 12096 */, RISCV_INS_LD, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* lh $rd, ${imm12}(${rs1}) */ + RISCV_LH /* 12097 */, RISCV_INS_LH, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* lhu $rd, ${imm12}(${rs1}) */ + RISCV_LHU /* 12098 */, RISCV_INS_LHU, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* lr.d $rd, $rs1 */ + RISCV_LR_D /* 12099 */, RISCV_INS_LR_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* lr.d.aq $rd, $rs1 */ + RISCV_LR_D_AQ /* 12100 */, RISCV_INS_LR_D_AQ, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* lr.d.aqrl $rd, $rs1 */ + RISCV_LR_D_AQ_RL /* 12101 */, RISCV_INS_LR_D_AQRL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* lr.d.rl $rd, $rs1 */ + RISCV_LR_D_RL /* 12102 */, RISCV_INS_LR_D_RL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* lr.w $rd, $rs1 */ + RISCV_LR_W /* 12103 */, RISCV_INS_LR_W, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* lr.w.aq $rd, $rs1 */ + RISCV_LR_W_AQ /* 12104 */, RISCV_INS_LR_W_AQ, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* lr.w.aqrl $rd, $rs1 */ + RISCV_LR_W_AQ_RL /* 12105 */, RISCV_INS_LR_W_AQRL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* lr.w.rl $rd, $rs1 */ + RISCV_LR_W_RL /* 12106 */, RISCV_INS_LR_W_RL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* lui $rd, $imm20 */ + RISCV_LUI /* 12107 */, RISCV_INS_LUI, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* lw $rd, ${imm12}(${rs1}) */ + RISCV_LW /* 12108 */, RISCV_INS_LW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* lwu $rd, ${imm12}(${rs1}) */ + RISCV_LWU /* 12109 */, RISCV_INS_LWU, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* max $rd, $rs1, $rs2 */ + RISCV_MAX /* 12110 */, RISCV_INS_MAX, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZBB, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* maxu $rd, $rs1, $rs2 */ + RISCV_MAXU /* 12111 */, RISCV_INS_MAXU, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZBB, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* min $rd, $rs1, $rs2 */ + RISCV_MIN /* 12112 */, RISCV_INS_MIN, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZBB, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* minu $rd, $rs1, $rs2 */ + RISCV_MINU /* 12113 */, RISCV_INS_MINU, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZBB, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* mop.r.0 $rd, $rs1 */ + RISCV_MOPR0 /* 12114 */, RISCV_INS_MOP_R_0, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZIMOP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* mop.r.1 $rd, $rs1 */ + RISCV_MOPR1 /* 12115 */, RISCV_INS_MOP_R_1, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZIMOP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* mop.r.10 $rd, $rs1 */ + RISCV_MOPR10 /* 12116 */, RISCV_INS_MOP_R_10, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZIMOP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* mop.r.11 $rd, $rs1 */ + RISCV_MOPR11 /* 12117 */, RISCV_INS_MOP_R_11, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZIMOP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* mop.r.12 $rd, $rs1 */ + RISCV_MOPR12 /* 12118 */, RISCV_INS_MOP_R_12, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZIMOP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* mop.r.13 $rd, $rs1 */ + RISCV_MOPR13 /* 12119 */, RISCV_INS_MOP_R_13, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZIMOP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* mop.r.14 $rd, $rs1 */ + RISCV_MOPR14 /* 12120 */, RISCV_INS_MOP_R_14, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZIMOP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* mop.r.15 $rd, $rs1 */ + RISCV_MOPR15 /* 12121 */, RISCV_INS_MOP_R_15, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZIMOP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* mop.r.16 $rd, $rs1 */ + RISCV_MOPR16 /* 12122 */, RISCV_INS_MOP_R_16, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZIMOP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* mop.r.17 $rd, $rs1 */ + RISCV_MOPR17 /* 12123 */, RISCV_INS_MOP_R_17, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZIMOP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* mop.r.18 $rd, $rs1 */ + RISCV_MOPR18 /* 12124 */, RISCV_INS_MOP_R_18, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZIMOP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* mop.r.19 $rd, $rs1 */ + RISCV_MOPR19 /* 12125 */, RISCV_INS_MOP_R_19, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZIMOP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* mop.r.2 $rd, $rs1 */ + RISCV_MOPR2 /* 12126 */, RISCV_INS_MOP_R_2, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZIMOP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* mop.r.20 $rd, $rs1 */ + RISCV_MOPR20 /* 12127 */, RISCV_INS_MOP_R_20, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZIMOP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* mop.r.21 $rd, $rs1 */ + RISCV_MOPR21 /* 12128 */, RISCV_INS_MOP_R_21, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZIMOP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* mop.r.22 $rd, $rs1 */ + RISCV_MOPR22 /* 12129 */, RISCV_INS_MOP_R_22, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZIMOP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* mop.r.23 $rd, $rs1 */ + RISCV_MOPR23 /* 12130 */, RISCV_INS_MOP_R_23, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZIMOP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* mop.r.24 $rd, $rs1 */ + RISCV_MOPR24 /* 12131 */, RISCV_INS_MOP_R_24, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZIMOP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* mop.r.25 $rd, $rs1 */ + RISCV_MOPR25 /* 12132 */, RISCV_INS_MOP_R_25, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZIMOP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* mop.r.26 $rd, $rs1 */ + RISCV_MOPR26 /* 12133 */, RISCV_INS_MOP_R_26, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZIMOP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* mop.r.27 $rd, $rs1 */ + RISCV_MOPR27 /* 12134 */, RISCV_INS_MOP_R_27, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZIMOP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* mop.r.28 $rd, $rs1 */ + RISCV_MOPR28 /* 12135 */, RISCV_INS_MOP_R_28, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZIMOP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* mop.r.29 $rd, $rs1 */ + RISCV_MOPR29 /* 12136 */, RISCV_INS_MOP_R_29, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZIMOP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* mop.r.3 $rd, $rs1 */ + RISCV_MOPR3 /* 12137 */, RISCV_INS_MOP_R_3, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZIMOP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* mop.r.30 $rd, $rs1 */ + RISCV_MOPR30 /* 12138 */, RISCV_INS_MOP_R_30, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZIMOP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* mop.r.31 $rd, $rs1 */ + RISCV_MOPR31 /* 12139 */, RISCV_INS_MOP_R_31, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZIMOP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* mop.r.4 $rd, $rs1 */ + RISCV_MOPR4 /* 12140 */, RISCV_INS_MOP_R_4, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZIMOP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* mop.r.5 $rd, $rs1 */ + RISCV_MOPR5 /* 12141 */, RISCV_INS_MOP_R_5, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZIMOP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* mop.r.6 $rd, $rs1 */ + RISCV_MOPR6 /* 12142 */, RISCV_INS_MOP_R_6, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZIMOP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* mop.r.7 $rd, $rs1 */ + RISCV_MOPR7 /* 12143 */, RISCV_INS_MOP_R_7, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZIMOP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* mop.r.8 $rd, $rs1 */ + RISCV_MOPR8 /* 12144 */, RISCV_INS_MOP_R_8, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZIMOP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* mop.r.9 $rd, $rs1 */ + RISCV_MOPR9 /* 12145 */, RISCV_INS_MOP_R_9, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZIMOP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* mop.rr.0 $rd, $rs1, $rs2 */ + RISCV_MOPRR0 /* 12146 */, RISCV_INS_MOP_RR_0, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZIMOP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* mop.rr.1 $rd, $rs1, $rs2 */ + RISCV_MOPRR1 /* 12147 */, RISCV_INS_MOP_RR_1, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZIMOP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* mop.rr.2 $rd, $rs1, $rs2 */ + RISCV_MOPRR2 /* 12148 */, RISCV_INS_MOP_RR_2, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZIMOP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* mop.rr.3 $rd, $rs1, $rs2 */ + RISCV_MOPRR3 /* 12149 */, RISCV_INS_MOP_RR_3, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZIMOP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* mop.rr.4 $rd, $rs1, $rs2 */ + RISCV_MOPRR4 /* 12150 */, RISCV_INS_MOP_RR_4, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZIMOP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* mop.rr.5 $rd, $rs1, $rs2 */ + RISCV_MOPRR5 /* 12151 */, RISCV_INS_MOP_RR_5, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZIMOP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* mop.rr.6 $rd, $rs1, $rs2 */ + RISCV_MOPRR6 /* 12152 */, RISCV_INS_MOP_RR_6, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZIMOP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* mop.rr.7 $rd, $rs1, $rs2 */ + RISCV_MOPRR7 /* 12153 */, RISCV_INS_MOP_RR_7, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZIMOP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* mret */ + RISCV_MRET /* 12154 */, RISCV_INS_MRET, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_GRP_JUMP, RISCV_GRP_RET, 0 }, 1, 0, {{ 0 }} + + #endif +}, +{ + /* mul $rd, $rs1, $rs2 */ + RISCV_MUL /* 12155 */, RISCV_INS_MUL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTMORZMMUL, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* mulh $rd, $rs1, $rs2 */ + RISCV_MULH /* 12156 */, RISCV_INS_MULH, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTMORZMMUL, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* mulhsu $rd, $rs1, $rs2 */ + RISCV_MULHSU /* 12157 */, RISCV_INS_MULHSU, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTMORZMMUL, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* mulhu $rd, $rs1, $rs2 */ + RISCV_MULHU /* 12158 */, RISCV_INS_MULHU, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTMORZMMUL, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* mulw $rd, $rs1, $rs2 */ + RISCV_MULW /* 12159 */, RISCV_INS_MULW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTMORZMMUL, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* or $rd, $rs1, $rs2 */ + RISCV_OR /* 12160 */, RISCV_INS_OR, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* orc.b $rd, $rs1 */ + RISCV_ORC_B /* 12161 */, RISCV_INS_ORC_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZBB, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* ori $rd, $rs1, $imm12 */ + RISCV_ORI /* 12162 */, RISCV_INS_ORI, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* orn $rd, $rs1, $rs2 */ + RISCV_ORN /* 12163 */, RISCV_INS_ORN, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZBBORZBKB, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* pack $rd, $rs1, $rs2 */ + RISCV_PACK /* 12164 */, RISCV_INS_PACK, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZBKB, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* packh $rd, $rs1, $rs2 */ + RISCV_PACKH /* 12165 */, RISCV_INS_PACKH, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZBKB, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* packw $rd, $rs1, $rs2 */ + RISCV_PACKW /* 12166 */, RISCV_INS_PACKW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZBKB, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* prefetch.i ${imm12}(${rs1}) */ + RISCV_PREFETCH_I /* 12167 */, RISCV_INS_PREFETCH_I, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZICBOP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* prefetch.r ${imm12}(${rs1}) */ + RISCV_PREFETCH_R /* 12168 */, RISCV_INS_PREFETCH_R, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZICBOP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* prefetch.w ${imm12}(${rs1}) */ + RISCV_PREFETCH_W /* 12169 */, RISCV_INS_PREFETCH_W, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZICBOP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* rem $rd, $rs1, $rs2 */ + RISCV_REM /* 12170 */, RISCV_INS_REM, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTM, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* remu $rd, $rs1, $rs2 */ + RISCV_REMU /* 12171 */, RISCV_INS_REMU, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTM, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* remuw $rd, $rs1, $rs2 */ + RISCV_REMUW /* 12172 */, RISCV_INS_REMUW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTM, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* remw $rd, $rs1, $rs2 */ + RISCV_REMW /* 12173 */, RISCV_INS_REMW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTM, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* rev8 $rd, $rs1 */ + RISCV_REV8_RV32 /* 12174 */, RISCV_INS_REV8, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZBBORZBKB, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* rev8 $rd, $rs1 */ + RISCV_REV8_RV64 /* 12175 */, RISCV_INS_REV8, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZBBORZBKB, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* rol $rd, $rs1, $rs2 */ + RISCV_ROL /* 12176 */, RISCV_INS_ROL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZBBORZBKB, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* rolw $rd, $rs1, $rs2 */ + RISCV_ROLW /* 12177 */, RISCV_INS_ROLW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZBBORZBKB, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* ror $rd, $rs1, $rs2 */ + RISCV_ROR /* 12178 */, RISCV_INS_ROR, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZBBORZBKB, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* rori $rd, $rs1, $shamt */ + RISCV_RORI /* 12179 */, RISCV_INS_RORI, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZBBORZBKB, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* roriw $rd, $rs1, $shamt */ + RISCV_RORIW /* 12180 */, RISCV_INS_RORIW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZBBORZBKB, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* rorw $rd, $rs1, $rs2 */ + RISCV_RORW /* 12181 */, RISCV_INS_RORW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZBBORZBKB, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sb $rs2, ${imm12}(${rs1}) */ + RISCV_SB /* 12182 */, RISCV_INS_SB, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sc.d $rd, $rs2, $rs1 */ + RISCV_SC_D /* 12183 */, RISCV_INS_SC_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sc.d.aq $rd, $rs2, $rs1 */ + RISCV_SC_D_AQ /* 12184 */, RISCV_INS_SC_D_AQ, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sc.d.aqrl $rd, $rs2, $rs1 */ + RISCV_SC_D_AQ_RL /* 12185 */, RISCV_INS_SC_D_AQRL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sc.d.rl $rd, $rs2, $rs1 */ + RISCV_SC_D_RL /* 12186 */, RISCV_INS_SC_D_RL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sc.w $rd, $rs2, $rs1 */ + RISCV_SC_W /* 12187 */, RISCV_INS_SC_W, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sc.w.aq $rd, $rs2, $rs1 */ + RISCV_SC_W_AQ /* 12188 */, RISCV_INS_SC_W_AQ, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sc.w.aqrl $rd, $rs2, $rs1 */ + RISCV_SC_W_AQ_RL /* 12189 */, RISCV_INS_SC_W_AQRL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sc.w.rl $rd, $rs2, $rs1 */ + RISCV_SC_W_RL /* 12190 */, RISCV_INS_SC_W_RL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sd $rs2, ${imm12}(${rs1}) */ + RISCV_SD /* 12191 */, RISCV_INS_SD, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sext.b $rd, $rs1 */ + RISCV_SEXT_B /* 12192 */, RISCV_INS_SEXT_B, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZBB, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sext.h $rd, $rs1 */ + RISCV_SEXT_H /* 12193 */, RISCV_INS_SEXT_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZBB, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sfence.inval.ir */ + RISCV_SFENCE_INVAL_IR /* 12194 */, RISCV_INS_SFENCE_INVAL_IR, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTSVINVAL, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sfence.vma $rs1, $rs2 */ + RISCV_SFENCE_VMA /* 12195 */, RISCV_INS_SFENCE_VMA, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sfence.w.inval */ + RISCV_SFENCE_W_INVAL /* 12196 */, RISCV_INS_SFENCE_W_INVAL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTSVINVAL, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sh $rs2, ${imm12}(${rs1}) */ + RISCV_SH /* 12197 */, RISCV_INS_SH, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sh1add $rd, $rs1, $rs2 */ + RISCV_SH1ADD /* 12198 */, RISCV_INS_SH1ADD, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZBA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sh1add.uw $rd, $rs1, $rs2 */ + RISCV_SH1ADD_UW /* 12199 */, RISCV_INS_SH1ADD_UW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZBA, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sh2add $rd, $rs1, $rs2 */ + RISCV_SH2ADD /* 12200 */, RISCV_INS_SH2ADD, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZBA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sh2add.uw $rd, $rs1, $rs2 */ + RISCV_SH2ADD_UW /* 12201 */, RISCV_INS_SH2ADD_UW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZBA, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sh3add $rd, $rs1, $rs2 */ + RISCV_SH3ADD /* 12202 */, RISCV_INS_SH3ADD, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZBA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sh3add.uw $rd, $rs1, $rs2 */ + RISCV_SH3ADD_UW /* 12203 */, RISCV_INS_SH3ADD_UW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZBA, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sha256sig0 $rd, $rs1 */ + RISCV_SHA256SIG0 /* 12204 */, RISCV_INS_SHA256SIG0, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZKNH, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sha256sig1 $rd, $rs1 */ + RISCV_SHA256SIG1 /* 12205 */, RISCV_INS_SHA256SIG1, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZKNH, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sha256sum0 $rd, $rs1 */ + RISCV_SHA256SUM0 /* 12206 */, RISCV_INS_SHA256SUM0, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZKNH, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sha256sum1 $rd, $rs1 */ + RISCV_SHA256SUM1 /* 12207 */, RISCV_INS_SHA256SUM1, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZKNH, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sha512sig0 $rd, $rs1 */ + RISCV_SHA512SIG0 /* 12208 */, RISCV_INS_SHA512SIG0, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZKNH, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sha512sig0h $rd, $rs1, $rs2 */ + RISCV_SHA512SIG0H /* 12209 */, RISCV_INS_SHA512SIG0H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZKNH, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sha512sig0l $rd, $rs1, $rs2 */ + RISCV_SHA512SIG0L /* 12210 */, RISCV_INS_SHA512SIG0L, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZKNH, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sha512sig1 $rd, $rs1 */ + RISCV_SHA512SIG1 /* 12211 */, RISCV_INS_SHA512SIG1, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZKNH, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sha512sig1h $rd, $rs1, $rs2 */ + RISCV_SHA512SIG1H /* 12212 */, RISCV_INS_SHA512SIG1H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZKNH, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sha512sig1l $rd, $rs1, $rs2 */ + RISCV_SHA512SIG1L /* 12213 */, RISCV_INS_SHA512SIG1L, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZKNH, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sha512sum0 $rd, $rs1 */ + RISCV_SHA512SUM0 /* 12214 */, RISCV_INS_SHA512SUM0, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZKNH, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sha512sum0r $rd, $rs1, $rs2 */ + RISCV_SHA512SUM0R /* 12215 */, RISCV_INS_SHA512SUM0R, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZKNH, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sha512sum1 $rd, $rs1 */ + RISCV_SHA512SUM1 /* 12216 */, RISCV_INS_SHA512SUM1, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZKNH, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sha512sum1r $rd, $rs1, $rs2 */ + RISCV_SHA512SUM1R /* 12217 */, RISCV_INS_SHA512SUM1R, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZKNH, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sinval.vma $rs1, $rs2 */ + RISCV_SINVAL_VMA /* 12218 */, RISCV_INS_SINVAL_VMA, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTSVINVAL, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sll $rd, $rs1, $rs2 */ + RISCV_SLL /* 12219 */, RISCV_INS_SLL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* slli $rd, $rs1, $shamt */ + RISCV_SLLI /* 12220 */, RISCV_INS_SLLI, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* slliw $rd, $rs1, $shamt */ + RISCV_SLLIW /* 12221 */, RISCV_INS_SLLIW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* slli.uw $rd, $rs1, $shamt */ + RISCV_SLLI_UW /* 12222 */, RISCV_INS_SLLI_UW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZBA, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sllw $rd, $rs1, $rs2 */ + RISCV_SLLW /* 12223 */, RISCV_INS_SLLW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* slt $rd, $rs1, $rs2 */ + RISCV_SLT /* 12224 */, RISCV_INS_SLT, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* slti $rd, $rs1, $imm12 */ + RISCV_SLTI /* 12225 */, RISCV_INS_SLTI, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sltiu $rd, $rs1, $imm12 */ + RISCV_SLTIU /* 12226 */, RISCV_INS_SLTIU, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sltu $rd, $rs1, $rs2 */ + RISCV_SLTU /* 12227 */, RISCV_INS_SLTU, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sm3p0 $rd, $rs1 */ + RISCV_SM3P0 /* 12228 */, RISCV_INS_SM3P0, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZKSH, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sm3p1 $rd, $rs1 */ + RISCV_SM3P1 /* 12229 */, RISCV_INS_SM3P1, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZKSH, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sm4ed $rd, $rs1, $rs2, $bs */ + RISCV_SM4ED /* 12230 */, RISCV_INS_SM4ED, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZKSED, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sm4ks $rd, $rs1, $rs2, $bs */ + RISCV_SM4KS /* 12231 */, RISCV_INS_SM4KS, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZKSED, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sra $rd, $rs1, $rs2 */ + RISCV_SRA /* 12232 */, RISCV_INS_SRA, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* srai $rd, $rs1, $shamt */ + RISCV_SRAI /* 12233 */, RISCV_INS_SRAI, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sraiw $rd, $rs1, $shamt */ + RISCV_SRAIW /* 12234 */, RISCV_INS_SRAIW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sraw $rd, $rs1, $rs2 */ + RISCV_SRAW /* 12235 */, RISCV_INS_SRAW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sret */ + RISCV_SRET /* 12236 */, RISCV_INS_SRET, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_GRP_JUMP, RISCV_GRP_RET, 0 }, 1, 0, {{ 0 }} + + #endif +}, +{ + /* srl $rd, $rs1, $rs2 */ + RISCV_SRL /* 12237 */, RISCV_INS_SRL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* srli $rd, $rs1, $shamt */ + RISCV_SRLI /* 12238 */, RISCV_INS_SRLI, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* srliw $rd, $rs1, $shamt */ + RISCV_SRLIW /* 12239 */, RISCV_INS_SRLIW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* srlw $rd, $rs1, $rs2 */ + RISCV_SRLW /* 12240 */, RISCV_INS_SRLW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* ssamoswap.d $rd, $rs2, $rs1 */ + RISCV_SSAMOSWAP_D /* 12241 */, RISCV_INS_SSAMOSWAP_D, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZICFISS, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* ssamoswap.d.aq $rd, $rs2, $rs1 */ + RISCV_SSAMOSWAP_D_AQ /* 12242 */, RISCV_INS_SSAMOSWAP_D_AQ, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZICFISS, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* ssamoswap.d.aqrl $rd, $rs2, $rs1 */ + RISCV_SSAMOSWAP_D_AQ_RL /* 12243 */, RISCV_INS_SSAMOSWAP_D_AQRL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZICFISS, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* ssamoswap.d.rl $rd, $rs2, $rs1 */ + RISCV_SSAMOSWAP_D_RL /* 12244 */, RISCV_INS_SSAMOSWAP_D_RL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZICFISS, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* ssamoswap.w $rd, $rs2, $rs1 */ + RISCV_SSAMOSWAP_W /* 12245 */, RISCV_INS_SSAMOSWAP_W, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZICFISS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* ssamoswap.w.aq $rd, $rs2, $rs1 */ + RISCV_SSAMOSWAP_W_AQ /* 12246 */, RISCV_INS_SSAMOSWAP_W_AQ, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZICFISS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* ssamoswap.w.aqrl $rd, $rs2, $rs1 */ + RISCV_SSAMOSWAP_W_AQ_RL /* 12247 */, RISCV_INS_SSAMOSWAP_W_AQRL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZICFISS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* ssamoswap.w.rl $rd, $rs2, $rs1 */ + RISCV_SSAMOSWAP_W_RL /* 12248 */, RISCV_INS_SSAMOSWAP_W_RL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZICFISS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sspopchk $rs1 */ + RISCV_SSPOPCHK /* 12249 */, RISCV_INS_SSPOPCHK, + #ifndef CAPSTONE_DIET + { RISCV_REG_SSP, 0 }, { RISCV_REG_SSP, 0 }, { RISCV_FEATURE_HASSTDEXTZICFISS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sspush $rs2 */ + RISCV_SSPUSH /* 12250 */, RISCV_INS_SSPUSH, + #ifndef CAPSTONE_DIET + { RISCV_REG_SSP, 0 }, { RISCV_REG_SSP, 0 }, { RISCV_FEATURE_HASSTDEXTZICFISS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* ssrdp $rd */ + RISCV_SSRDP /* 12251 */, RISCV_INS_SSRDP, + #ifndef CAPSTONE_DIET + { RISCV_REG_SSP, 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZICFISS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sub $rd, $rs1, $rs2 */ + RISCV_SUB /* 12252 */, RISCV_INS_SUB, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* subw $rd, $rs1, $rs2 */ + RISCV_SUBW /* 12253 */, RISCV_INS_SUBW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sw $rs2, ${imm12}(${rs1}) */ + RISCV_SW /* 12254 */, RISCV_INS_SW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.vmaqasu.vv $vd, $vs1, $vs2$vm */ + RISCV_THVdotVMAQASU_VV /* 12255 */, RISCV_INS_TH_VMAQASU_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADVDOT, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.vmaqasu.vx $vd, $rs1, $vs2$vm */ + RISCV_THVdotVMAQASU_VX /* 12256 */, RISCV_INS_TH_VMAQASU_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADVDOT, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.vmaqaus.vx $vd, $rs1, $vs2$vm */ + RISCV_THVdotVMAQAUS_VX /* 12257 */, RISCV_INS_TH_VMAQAUS_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADVDOT, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.vmaqau.vv $vd, $vs1, $vs2$vm */ + RISCV_THVdotVMAQAU_VV /* 12258 */, RISCV_INS_TH_VMAQAU_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADVDOT, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.vmaqau.vx $vd, $rs1, $vs2$vm */ + RISCV_THVdotVMAQAU_VX /* 12259 */, RISCV_INS_TH_VMAQAU_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADVDOT, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.vmaqa.vv $vd, $vs1, $vs2$vm */ + RISCV_THVdotVMAQA_VV /* 12260 */, RISCV_INS_TH_VMAQA_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADVDOT, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.vmaqa.vx $vd, $rs1, $vs2$vm */ + RISCV_THVdotVMAQA_VX /* 12261 */, RISCV_INS_TH_VMAQA_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADVDOT, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.addsl $rd, $rs1, $rs2, $uimm2 */ + RISCV_TH_ADDSL /* 12262 */, RISCV_INS_TH_ADDSL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADBA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.dcache.call */ + RISCV_TH_DCACHE_CALL /* 12263 */, RISCV_INS_TH_DCACHE_CALL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADCMO, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.dcache.ciall */ + RISCV_TH_DCACHE_CIALL /* 12264 */, RISCV_INS_TH_DCACHE_CIALL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADCMO, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.dcache.cipa $rs1 */ + RISCV_TH_DCACHE_CIPA /* 12265 */, RISCV_INS_TH_DCACHE_CIPA, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADCMO, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.dcache.cisw $rs1 */ + RISCV_TH_DCACHE_CISW /* 12266 */, RISCV_INS_TH_DCACHE_CISW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADCMO, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.dcache.civa $rs1 */ + RISCV_TH_DCACHE_CIVA /* 12267 */, RISCV_INS_TH_DCACHE_CIVA, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADCMO, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.dcache.cpa $rs1 */ + RISCV_TH_DCACHE_CPA /* 12268 */, RISCV_INS_TH_DCACHE_CPA, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADCMO, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.dcache.cpal1 $rs1 */ + RISCV_TH_DCACHE_CPAL1 /* 12269 */, RISCV_INS_TH_DCACHE_CPAL1, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADCMO, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.dcache.csw $rs1 */ + RISCV_TH_DCACHE_CSW /* 12270 */, RISCV_INS_TH_DCACHE_CSW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADCMO, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.dcache.cva $rs1 */ + RISCV_TH_DCACHE_CVA /* 12271 */, RISCV_INS_TH_DCACHE_CVA, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADCMO, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.dcache.cval1 $rs1 */ + RISCV_TH_DCACHE_CVAL1 /* 12272 */, RISCV_INS_TH_DCACHE_CVAL1, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADCMO, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.dcache.iall */ + RISCV_TH_DCACHE_IALL /* 12273 */, RISCV_INS_TH_DCACHE_IALL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADCMO, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.dcache.ipa $rs1 */ + RISCV_TH_DCACHE_IPA /* 12274 */, RISCV_INS_TH_DCACHE_IPA, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADCMO, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.dcache.isw $rs1 */ + RISCV_TH_DCACHE_ISW /* 12275 */, RISCV_INS_TH_DCACHE_ISW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADCMO, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.dcache.iva $rs1 */ + RISCV_TH_DCACHE_IVA /* 12276 */, RISCV_INS_TH_DCACHE_IVA, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADCMO, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.ext $rd, $rs1, $msb, $lsb */ + RISCV_TH_EXT /* 12277 */, RISCV_INS_TH_EXT, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADBB, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.extu $rd, $rs1, $msb, $lsb */ + RISCV_TH_EXTU /* 12278 */, RISCV_INS_TH_EXTU, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADBB, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.ff0 $rd, $rs1 */ + RISCV_TH_FF0 /* 12279 */, RISCV_INS_TH_FF0, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADBB, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.ff1 $rd, $rs1 */ + RISCV_TH_FF1 /* 12280 */, RISCV_INS_TH_FF1, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADBB, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.flrd $rd, $rs1, $rs2, $uimm2 */ + RISCV_TH_FLRD /* 12281 */, RISCV_INS_TH_FLRD, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADFMEMIDX, RISCV_FEATURE_HASSTDEXTD, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.flrw $rd, $rs1, $rs2, $uimm2 */ + RISCV_TH_FLRW /* 12282 */, RISCV_INS_TH_FLRW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADFMEMIDX, RISCV_FEATURE_HASSTDEXTF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.flurd $rd, $rs1, $rs2, $uimm2 */ + RISCV_TH_FLURD /* 12283 */, RISCV_INS_TH_FLURD, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADFMEMIDX, RISCV_FEATURE_HASSTDEXTD, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.flurw $rd, $rs1, $rs2, $uimm2 */ + RISCV_TH_FLURW /* 12284 */, RISCV_INS_TH_FLURW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADFMEMIDX, RISCV_FEATURE_HASSTDEXTF, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.fsrd $rd, $rs1, $rs2, $uimm2 */ + RISCV_TH_FSRD /* 12285 */, RISCV_INS_TH_FSRD, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADFMEMIDX, RISCV_FEATURE_HASSTDEXTD, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.fsrw $rd, $rs1, $rs2, $uimm2 */ + RISCV_TH_FSRW /* 12286 */, RISCV_INS_TH_FSRW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADFMEMIDX, RISCV_FEATURE_HASSTDEXTF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.fsurd $rd, $rs1, $rs2, $uimm2 */ + RISCV_TH_FSURD /* 12287 */, RISCV_INS_TH_FSURD, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADFMEMIDX, RISCV_FEATURE_HASSTDEXTD, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.fsurw $rd, $rs1, $rs2, $uimm2 */ + RISCV_TH_FSURW /* 12288 */, RISCV_INS_TH_FSURW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADFMEMIDX, RISCV_FEATURE_HASSTDEXTF, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.icache.iall */ + RISCV_TH_ICACHE_IALL /* 12289 */, RISCV_INS_TH_ICACHE_IALL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADCMO, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.icache.ialls */ + RISCV_TH_ICACHE_IALLS /* 12290 */, RISCV_INS_TH_ICACHE_IALLS, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADCMO, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.icache.ipa $rs1 */ + RISCV_TH_ICACHE_IPA /* 12291 */, RISCV_INS_TH_ICACHE_IPA, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADCMO, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.icache.iva $rs1 */ + RISCV_TH_ICACHE_IVA /* 12292 */, RISCV_INS_TH_ICACHE_IVA, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADCMO, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.l2cache.call */ + RISCV_TH_L2CACHE_CALL /* 12293 */, RISCV_INS_TH_L2CACHE_CALL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADCMO, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.l2cache.ciall */ + RISCV_TH_L2CACHE_CIALL /* 12294 */, RISCV_INS_TH_L2CACHE_CIALL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADCMO, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.l2cache.iall */ + RISCV_TH_L2CACHE_IALL /* 12295 */, RISCV_INS_TH_L2CACHE_IALL, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADCMO, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.lbia $rd, (${rs1}), $simm5, $uimm2 */ + RISCV_TH_LBIA /* 12296 */, RISCV_INS_TH_LBIA, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADMEMIDX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.lbib $rd, (${rs1}), $simm5, $uimm2 */ + RISCV_TH_LBIB /* 12297 */, RISCV_INS_TH_LBIB, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADMEMIDX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.lbuia $rd, (${rs1}), $simm5, $uimm2 */ + RISCV_TH_LBUIA /* 12298 */, RISCV_INS_TH_LBUIA, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADMEMIDX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.lbuib $rd, (${rs1}), $simm5, $uimm2 */ + RISCV_TH_LBUIB /* 12299 */, RISCV_INS_TH_LBUIB, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADMEMIDX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.ldd $rd, $rs2, (${rs1}), $uimm2, $const3or4 */ + RISCV_TH_LDD /* 12300 */, RISCV_INS_TH_LDD, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADMEMPAIR, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.ldia $rd, (${rs1}), $simm5, $uimm2 */ + RISCV_TH_LDIA /* 12301 */, RISCV_INS_TH_LDIA, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADMEMIDX, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.ldib $rd, (${rs1}), $simm5, $uimm2 */ + RISCV_TH_LDIB /* 12302 */, RISCV_INS_TH_LDIB, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADMEMIDX, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.lhia $rd, (${rs1}), $simm5, $uimm2 */ + RISCV_TH_LHIA /* 12303 */, RISCV_INS_TH_LHIA, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADMEMIDX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.lhib $rd, (${rs1}), $simm5, $uimm2 */ + RISCV_TH_LHIB /* 12304 */, RISCV_INS_TH_LHIB, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADMEMIDX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.lhuia $rd, (${rs1}), $simm5, $uimm2 */ + RISCV_TH_LHUIA /* 12305 */, RISCV_INS_TH_LHUIA, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADMEMIDX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.lhuib $rd, (${rs1}), $simm5, $uimm2 */ + RISCV_TH_LHUIB /* 12306 */, RISCV_INS_TH_LHUIB, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADMEMIDX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.lrb $rd, $rs1, $rs2, $uimm2 */ + RISCV_TH_LRB /* 12307 */, RISCV_INS_TH_LRB, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADMEMIDX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.lrbu $rd, $rs1, $rs2, $uimm2 */ + RISCV_TH_LRBU /* 12308 */, RISCV_INS_TH_LRBU, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADMEMIDX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.lrd $rd, $rs1, $rs2, $uimm2 */ + RISCV_TH_LRD /* 12309 */, RISCV_INS_TH_LRD, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADMEMIDX, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.lrh $rd, $rs1, $rs2, $uimm2 */ + RISCV_TH_LRH /* 12310 */, RISCV_INS_TH_LRH, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADMEMIDX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.lrhu $rd, $rs1, $rs2, $uimm2 */ + RISCV_TH_LRHU /* 12311 */, RISCV_INS_TH_LRHU, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADMEMIDX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.lrw $rd, $rs1, $rs2, $uimm2 */ + RISCV_TH_LRW /* 12312 */, RISCV_INS_TH_LRW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADMEMIDX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.lrwu $rd, $rs1, $rs2, $uimm2 */ + RISCV_TH_LRWU /* 12313 */, RISCV_INS_TH_LRWU, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADMEMIDX, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.lurb $rd, $rs1, $rs2, $uimm2 */ + RISCV_TH_LURB /* 12314 */, RISCV_INS_TH_LURB, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADMEMIDX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.lurbu $rd, $rs1, $rs2, $uimm2 */ + RISCV_TH_LURBU /* 12315 */, RISCV_INS_TH_LURBU, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADMEMIDX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.lurd $rd, $rs1, $rs2, $uimm2 */ + RISCV_TH_LURD /* 12316 */, RISCV_INS_TH_LURD, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADMEMIDX, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.lurh $rd, $rs1, $rs2, $uimm2 */ + RISCV_TH_LURH /* 12317 */, RISCV_INS_TH_LURH, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADMEMIDX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.lurhu $rd, $rs1, $rs2, $uimm2 */ + RISCV_TH_LURHU /* 12318 */, RISCV_INS_TH_LURHU, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADMEMIDX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.lurw $rd, $rs1, $rs2, $uimm2 */ + RISCV_TH_LURW /* 12319 */, RISCV_INS_TH_LURW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADMEMIDX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.lurwu $rd, $rs1, $rs2, $uimm2 */ + RISCV_TH_LURWU /* 12320 */, RISCV_INS_TH_LURWU, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADMEMIDX, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.lwd $rd, $rs2, (${rs1}), $uimm2, $const3or4 */ + RISCV_TH_LWD /* 12321 */, RISCV_INS_TH_LWD, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADMEMPAIR, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.lwia $rd, (${rs1}), $simm5, $uimm2 */ + RISCV_TH_LWIA /* 12322 */, RISCV_INS_TH_LWIA, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADMEMIDX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.lwib $rd, (${rs1}), $simm5, $uimm2 */ + RISCV_TH_LWIB /* 12323 */, RISCV_INS_TH_LWIB, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADMEMIDX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.lwud $rd, $rs2, (${rs1}), $uimm2, $const3or4 */ + RISCV_TH_LWUD /* 12324 */, RISCV_INS_TH_LWUD, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADMEMPAIR, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.lwuia $rd, (${rs1}), $simm5, $uimm2 */ + RISCV_TH_LWUIA /* 12325 */, RISCV_INS_TH_LWUIA, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADMEMIDX, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.lwuib $rd, (${rs1}), $simm5, $uimm2 */ + RISCV_TH_LWUIB /* 12326 */, RISCV_INS_TH_LWUIB, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADMEMIDX, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.mula $rd, $rs1, $rs2 */ + RISCV_TH_MULA /* 12327 */, RISCV_INS_TH_MULA, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADMAC, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.mulah $rd, $rs1, $rs2 */ + RISCV_TH_MULAH /* 12328 */, RISCV_INS_TH_MULAH, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADMAC, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.mulaw $rd, $rs1, $rs2 */ + RISCV_TH_MULAW /* 12329 */, RISCV_INS_TH_MULAW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADMAC, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.muls $rd, $rs1, $rs2 */ + RISCV_TH_MULS /* 12330 */, RISCV_INS_TH_MULS, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADMAC, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.mulsh $rd, $rs1, $rs2 */ + RISCV_TH_MULSH /* 12331 */, RISCV_INS_TH_MULSH, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADMAC, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.mulsw $rd, $rs1, $rs2 */ + RISCV_TH_MULSW /* 12332 */, RISCV_INS_TH_MULSW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADMAC, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.mveqz $rd, $rs1, $rs2 */ + RISCV_TH_MVEQZ /* 12333 */, RISCV_INS_TH_MVEQZ, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADCONDMOV, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.mvnez $rd, $rs1, $rs2 */ + RISCV_TH_MVNEZ /* 12334 */, RISCV_INS_TH_MVNEZ, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADCONDMOV, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.rev $rd, $rs1 */ + RISCV_TH_REV /* 12335 */, RISCV_INS_TH_REV, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADBB, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.revw $rd, $rs1 */ + RISCV_TH_REVW /* 12336 */, RISCV_INS_TH_REVW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADBB, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.sbia $rd, (${rs1}), $simm5, $uimm2 */ + RISCV_TH_SBIA /* 12337 */, RISCV_INS_TH_SBIA, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADMEMIDX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.sbib $rd, (${rs1}), $simm5, $uimm2 */ + RISCV_TH_SBIB /* 12338 */, RISCV_INS_TH_SBIB, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADMEMIDX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.sdd $rd, $rs2, (${rs1}), $uimm2, $const3or4 */ + RISCV_TH_SDD /* 12339 */, RISCV_INS_TH_SDD, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADMEMPAIR, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.sdia $rd, (${rs1}), $simm5, $uimm2 */ + RISCV_TH_SDIA /* 12340 */, RISCV_INS_TH_SDIA, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADMEMIDX, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.sdib $rd, (${rs1}), $simm5, $uimm2 */ + RISCV_TH_SDIB /* 12341 */, RISCV_INS_TH_SDIB, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADMEMIDX, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.sfence.vmas $rs1, $rs2 */ + RISCV_TH_SFENCE_VMAS /* 12342 */, RISCV_INS_TH_SFENCE_VMAS, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADSYNC, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.shia $rd, (${rs1}), $simm5, $uimm2 */ + RISCV_TH_SHIA /* 12343 */, RISCV_INS_TH_SHIA, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADMEMIDX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.shib $rd, (${rs1}), $simm5, $uimm2 */ + RISCV_TH_SHIB /* 12344 */, RISCV_INS_TH_SHIB, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADMEMIDX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.srb $rd, $rs1, $rs2, $uimm2 */ + RISCV_TH_SRB /* 12345 */, RISCV_INS_TH_SRB, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADMEMIDX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.srd $rd, $rs1, $rs2, $uimm2 */ + RISCV_TH_SRD /* 12346 */, RISCV_INS_TH_SRD, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADMEMIDX, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.srh $rd, $rs1, $rs2, $uimm2 */ + RISCV_TH_SRH /* 12347 */, RISCV_INS_TH_SRH, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADMEMIDX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.srri $rd, $rs1, $shamt */ + RISCV_TH_SRRI /* 12348 */, RISCV_INS_TH_SRRI, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADBB, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.srriw $rd, $rs1, $shamt */ + RISCV_TH_SRRIW /* 12349 */, RISCV_INS_TH_SRRIW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADBB, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.srw $rd, $rs1, $rs2, $uimm2 */ + RISCV_TH_SRW /* 12350 */, RISCV_INS_TH_SRW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADMEMIDX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.surb $rd, $rs1, $rs2, $uimm2 */ + RISCV_TH_SURB /* 12351 */, RISCV_INS_TH_SURB, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADMEMIDX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.surd $rd, $rs1, $rs2, $uimm2 */ + RISCV_TH_SURD /* 12352 */, RISCV_INS_TH_SURD, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADMEMIDX, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.surh $rd, $rs1, $rs2, $uimm2 */ + RISCV_TH_SURH /* 12353 */, RISCV_INS_TH_SURH, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADMEMIDX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.surw $rd, $rs1, $rs2, $uimm2 */ + RISCV_TH_SURW /* 12354 */, RISCV_INS_TH_SURW, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADMEMIDX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.swd $rd, $rs2, (${rs1}), $uimm2, $const3or4 */ + RISCV_TH_SWD /* 12355 */, RISCV_INS_TH_SWD, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADMEMPAIR, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.swia $rd, (${rs1}), $simm5, $uimm2 */ + RISCV_TH_SWIA /* 12356 */, RISCV_INS_TH_SWIA, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADMEMIDX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.swib $rd, (${rs1}), $simm5, $uimm2 */ + RISCV_TH_SWIB /* 12357 */, RISCV_INS_TH_SWIB, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADMEMIDX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.sync */ + RISCV_TH_SYNC /* 12358 */, RISCV_INS_TH_SYNC, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADSYNC, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.sync.i */ + RISCV_TH_SYNC_I /* 12359 */, RISCV_INS_TH_SYNC_I, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADSYNC, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.sync.is */ + RISCV_TH_SYNC_IS /* 12360 */, RISCV_INS_TH_SYNC_IS, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADSYNC, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.sync.s */ + RISCV_TH_SYNC_S /* 12361 */, RISCV_INS_TH_SYNC_S, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADSYNC, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.tst $rd, $rs1, $shamt */ + RISCV_TH_TST /* 12362 */, RISCV_INS_TH_TST, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADBS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* th.tstnbz $rd, $rs1 */ + RISCV_TH_TSTNBZ /* 12363 */, RISCV_INS_TH_TSTNBZ, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXTHEADBB, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* unimp */ + RISCV_UNIMP /* 12364 */, RISCV_INS_UNIMP, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* unzip $rd, $rs1 */ + RISCV_UNZIP_RV32 /* 12365 */, RISCV_INS_UNZIP, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZBKB, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vaaddu.vv $vd, $vs2, $vs1$vm */ + RISCV_VAADDU_VV /* 12366 */, RISCV_INS_VAADDU_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vaaddu.vx $vd, $vs2, $rs1$vm */ + RISCV_VAADDU_VX /* 12367 */, RISCV_INS_VAADDU_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vaadd.vv $vd, $vs2, $vs1$vm */ + RISCV_VAADD_VV /* 12368 */, RISCV_INS_VAADD_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vaadd.vx $vd, $vs2, $rs1$vm */ + RISCV_VAADD_VX /* 12369 */, RISCV_INS_VAADD_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vadc.vim $vd, $vs2, $imm, v0 */ + RISCV_VADC_VIM /* 12370 */, RISCV_INS_VADC_VIM, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vadc.vvm $vd, $vs2, $vs1, v0 */ + RISCV_VADC_VVM /* 12371 */, RISCV_INS_VADC_VVM, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vadc.vxm $vd, $vs2, $rs1, v0 */ + RISCV_VADC_VXM /* 12372 */, RISCV_INS_VADC_VXM, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vadd.vi $vd, $vs2, $imm$vm */ + RISCV_VADD_VI /* 12373 */, RISCV_INS_VADD_VI, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vadd.vv $vd, $vs2, $vs1$vm */ + RISCV_VADD_VV /* 12374 */, RISCV_INS_VADD_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vadd.vx $vd, $vs2, $rs1$vm */ + RISCV_VADD_VX /* 12375 */, RISCV_INS_VADD_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vaesdf.vs $vd, $vs2 */ + RISCV_VAESDF_VS /* 12376 */, RISCV_INS_VAESDF_VS, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZVKNED, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vaesdf.vv $vd, $vs2 */ + RISCV_VAESDF_VV /* 12377 */, RISCV_INS_VAESDF_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZVKNED, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vaesdm.vs $vd, $vs2 */ + RISCV_VAESDM_VS /* 12378 */, RISCV_INS_VAESDM_VS, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZVKNED, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vaesdm.vv $vd, $vs2 */ + RISCV_VAESDM_VV /* 12379 */, RISCV_INS_VAESDM_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZVKNED, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vaesef.vs $vd, $vs2 */ + RISCV_VAESEF_VS /* 12380 */, RISCV_INS_VAESEF_VS, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZVKNED, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vaesef.vv $vd, $vs2 */ + RISCV_VAESEF_VV /* 12381 */, RISCV_INS_VAESEF_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZVKNED, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vaesem.vs $vd, $vs2 */ + RISCV_VAESEM_VS /* 12382 */, RISCV_INS_VAESEM_VS, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZVKNED, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vaesem.vv $vd, $vs2 */ + RISCV_VAESEM_VV /* 12383 */, RISCV_INS_VAESEM_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZVKNED, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vaeskf1.vi $vd, $vs2, $imm */ + RISCV_VAESKF1_VI /* 12384 */, RISCV_INS_VAESKF1_VI, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZVKNED, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vaeskf2.vi $vd, $vs2, $imm */ + RISCV_VAESKF2_VI /* 12385 */, RISCV_INS_VAESKF2_VI, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZVKNED, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vaesz.vs $vd, $vs2 */ + RISCV_VAESZ_VS /* 12386 */, RISCV_INS_VAESZ_VS, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZVKNED, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vandn.vv $vd, $vs2, $vs1$vm */ + RISCV_VANDN_VV /* 12387 */, RISCV_INS_VANDN_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZVKB, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vandn.vx $vd, $vs2, $rs1$vm */ + RISCV_VANDN_VX /* 12388 */, RISCV_INS_VANDN_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZVKB, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vand.vi $vd, $vs2, $imm$vm */ + RISCV_VAND_VI /* 12389 */, RISCV_INS_VAND_VI, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vand.vv $vd, $vs2, $vs1$vm */ + RISCV_VAND_VV /* 12390 */, RISCV_INS_VAND_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vand.vx $vd, $vs2, $rs1$vm */ + RISCV_VAND_VX /* 12391 */, RISCV_INS_VAND_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vasubu.vv $vd, $vs2, $vs1$vm */ + RISCV_VASUBU_VV /* 12392 */, RISCV_INS_VASUBU_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vasubu.vx $vd, $vs2, $rs1$vm */ + RISCV_VASUBU_VX /* 12393 */, RISCV_INS_VASUBU_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vasub.vv $vd, $vs2, $vs1$vm */ + RISCV_VASUB_VV /* 12394 */, RISCV_INS_VASUB_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vasub.vx $vd, $vs2, $rs1$vm */ + RISCV_VASUB_VX /* 12395 */, RISCV_INS_VASUB_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vbrev8.v $vd, $vs2$vm */ + RISCV_VBREV8_V /* 12396 */, RISCV_INS_VBREV8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZVKB, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vbrev.v $vd, $vs2$vm */ + RISCV_VBREV_V /* 12397 */, RISCV_INS_VBREV_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZVBB, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vclmulh.vv $vd, $vs2, $vs1$vm */ + RISCV_VCLMULH_VV /* 12398 */, RISCV_INS_VCLMULH_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZVBC, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vclmulh.vx $vd, $vs2, $rs1$vm */ + RISCV_VCLMULH_VX /* 12399 */, RISCV_INS_VCLMULH_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZVBC, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vclmul.vv $vd, $vs2, $vs1$vm */ + RISCV_VCLMUL_VV /* 12400 */, RISCV_INS_VCLMUL_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZVBC, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vclmul.vx $vd, $vs2, $rs1$vm */ + RISCV_VCLMUL_VX /* 12401 */, RISCV_INS_VCLMUL_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZVBC, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vclz.v $vd, $vs2$vm */ + RISCV_VCLZ_V /* 12402 */, RISCV_INS_VCLZ_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZVBB, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vcompress.vm $vd, $vs2, $vs1 */ + RISCV_VCOMPRESS_VM /* 12403 */, RISCV_INS_VCOMPRESS_VM, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vcpop.m $vd, $vs2$vm */ + RISCV_VCPOP_M /* 12404 */, RISCV_INS_VCPOP_M, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vcpop.v $vd, $vs2$vm */ + RISCV_VCPOP_V /* 12405 */, RISCV_INS_VCPOP_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZVBB, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vctz.v $vd, $vs2$vm */ + RISCV_VCTZ_V /* 12406 */, RISCV_INS_VCTZ_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZVBB, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sf.vc.fv $funct6_lo1, $rd, $rs2, $rs1 */ + RISCV_VC_FV /* 12407 */, RISCV_INS_SF_VC_FV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXSFVCP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sf.vc.fvv $funct6_lo1, $rd, $rs2, $rs1 */ + RISCV_VC_FVV /* 12408 */, RISCV_INS_SF_VC_FVV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXSFVCP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sf.vc.fvw $funct6_lo1, $rd, $rs2, $rs1 */ + RISCV_VC_FVW /* 12409 */, RISCV_INS_SF_VC_FVW, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXSFVCP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sf.vc.i $funct6_lo2, $rs2, $rd, $rs1 */ + RISCV_VC_I /* 12410 */, RISCV_INS_SF_VC_I, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXSFVCP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sf.vc.iv $funct6_lo2, $rd, $rs2, $rs1 */ + RISCV_VC_IV /* 12411 */, RISCV_INS_SF_VC_IV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXSFVCP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sf.vc.ivv $funct6_lo2, $rd, $rs2, $rs1 */ + RISCV_VC_IVV /* 12412 */, RISCV_INS_SF_VC_IVV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXSFVCP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sf.vc.ivw $funct6_lo2, $rd, $rs2, $rs1 */ + RISCV_VC_IVW /* 12413 */, RISCV_INS_SF_VC_IVW, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXSFVCP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sf.vc.vv $funct6_lo2, $rd, $rs2, $rs1 */ + RISCV_VC_VV /* 12414 */, RISCV_INS_SF_VC_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXSFVCP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sf.vc.vvv $funct6_lo2, $rd, $rs2, $rs1 */ + RISCV_VC_VVV /* 12415 */, RISCV_INS_SF_VC_VVV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXSFVCP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sf.vc.vvw $funct6_lo2, $rd, $rs2, $rs1 */ + RISCV_VC_VVW /* 12416 */, RISCV_INS_SF_VC_VVW, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXSFVCP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sf.vc.v.fv $funct6_lo1, $rd, $rs2, $rs1 */ + RISCV_VC_V_FV /* 12417 */, RISCV_INS_SF_VC_V_FV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXSFVCP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sf.vc.v.fvv $funct6_lo1, $rd, $rs2, $rs1 */ + RISCV_VC_V_FVV /* 12418 */, RISCV_INS_SF_VC_V_FVV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXSFVCP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sf.vc.v.fvw $funct6_lo1, $rd, $rs2, $rs1 */ + RISCV_VC_V_FVW /* 12419 */, RISCV_INS_SF_VC_V_FVW, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXSFVCP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sf.vc.v.i $funct6_lo2, $rs2, $rd, $rs1 */ + RISCV_VC_V_I /* 12420 */, RISCV_INS_SF_VC_V_I, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXSFVCP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sf.vc.v.iv $funct6_lo2, $rd, $rs2, $rs1 */ + RISCV_VC_V_IV /* 12421 */, RISCV_INS_SF_VC_V_IV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXSFVCP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sf.vc.v.ivv $funct6_lo2, $rd, $rs2, $rs1 */ + RISCV_VC_V_IVV /* 12422 */, RISCV_INS_SF_VC_V_IVV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXSFVCP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sf.vc.v.ivw $funct6_lo2, $rd, $rs2, $rs1 */ + RISCV_VC_V_IVW /* 12423 */, RISCV_INS_SF_VC_V_IVW, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXSFVCP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sf.vc.v.vv $funct6_lo2, $rd, $rs2, $rs1 */ + RISCV_VC_V_VV /* 12424 */, RISCV_INS_SF_VC_V_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXSFVCP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sf.vc.v.vvv $funct6_lo2, $rd, $rs2, $rs1 */ + RISCV_VC_V_VVV /* 12425 */, RISCV_INS_SF_VC_V_VVV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXSFVCP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sf.vc.v.vvw $funct6_lo2, $rd, $rs2, $rs1 */ + RISCV_VC_V_VVW /* 12426 */, RISCV_INS_SF_VC_V_VVW, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXSFVCP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sf.vc.v.x $funct6_lo2, $rs2, $rd, $rs1 */ + RISCV_VC_V_X /* 12427 */, RISCV_INS_SF_VC_V_X, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXSFVCP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sf.vc.v.xv $funct6_lo2, $rd, $rs2, $rs1 */ + RISCV_VC_V_XV /* 12428 */, RISCV_INS_SF_VC_V_XV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXSFVCP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sf.vc.v.xvv $funct6_lo2, $rd, $rs2, $rs1 */ + RISCV_VC_V_XVV /* 12429 */, RISCV_INS_SF_VC_V_XVV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXSFVCP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sf.vc.v.xvw $funct6_lo2, $rd, $rs2, $rs1 */ + RISCV_VC_V_XVW /* 12430 */, RISCV_INS_SF_VC_V_XVW, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXSFVCP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sf.vc.x $funct6_lo2, $rs2, $rd, $rs1 */ + RISCV_VC_X /* 12431 */, RISCV_INS_SF_VC_X, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXSFVCP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sf.vc.xv $funct6_lo2, $rd, $rs2, $rs1 */ + RISCV_VC_XV /* 12432 */, RISCV_INS_SF_VC_XV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXSFVCP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sf.vc.xvv $funct6_lo2, $rd, $rs2, $rs1 */ + RISCV_VC_XVV /* 12433 */, RISCV_INS_SF_VC_XVV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXSFVCP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sf.vc.xvw $funct6_lo2, $rd, $rs2, $rs1 */ + RISCV_VC_XVW /* 12434 */, RISCV_INS_SF_VC_XVW, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXSFVCP, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vdivu.vv $vd, $vs2, $vs1$vm */ + RISCV_VDIVU_VV /* 12435 */, RISCV_INS_VDIVU_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vdivu.vx $vd, $vs2, $rs1$vm */ + RISCV_VDIVU_VX /* 12436 */, RISCV_INS_VDIVU_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vdiv.vv $vd, $vs2, $vs1$vm */ + RISCV_VDIV_VV /* 12437 */, RISCV_INS_VDIV_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vdiv.vx $vd, $vs2, $rs1$vm */ + RISCV_VDIV_VX /* 12438 */, RISCV_INS_VDIV_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfadd.vf $vd, $vs2, $rs1$vm */ + RISCV_VFADD_VF /* 12439 */, RISCV_INS_VFADD_VF, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfadd.vv $vd, $vs2, $vs1$vm */ + RISCV_VFADD_VV /* 12440 */, RISCV_INS_VFADD_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfclass.v $vd, $vs2$vm */ + RISCV_VFCLASS_V /* 12441 */, RISCV_INS_VFCLASS_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfcvt.f.xu.v $vd, $vs2$vm */ + RISCV_VFCVT_F_XU_V /* 12442 */, RISCV_INS_VFCVT_F_XU_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfcvt.f.x.v $vd, $vs2$vm */ + RISCV_VFCVT_F_X_V /* 12443 */, RISCV_INS_VFCVT_F_X_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfcvt.rtz.xu.f.v $vd, $vs2$vm */ + RISCV_VFCVT_RTZ_XU_F_V /* 12444 */, RISCV_INS_VFCVT_RTZ_XU_F_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfcvt.rtz.x.f.v $vd, $vs2$vm */ + RISCV_VFCVT_RTZ_X_F_V /* 12445 */, RISCV_INS_VFCVT_RTZ_X_F_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfcvt.xu.f.v $vd, $vs2$vm */ + RISCV_VFCVT_XU_F_V /* 12446 */, RISCV_INS_VFCVT_XU_F_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfcvt.x.f.v $vd, $vs2$vm */ + RISCV_VFCVT_X_F_V /* 12447 */, RISCV_INS_VFCVT_X_F_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfdiv.vf $vd, $vs2, $rs1$vm */ + RISCV_VFDIV_VF /* 12448 */, RISCV_INS_VFDIV_VF, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfdiv.vv $vd, $vs2, $vs1$vm */ + RISCV_VFDIV_VV /* 12449 */, RISCV_INS_VFDIV_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfirst.m $vd, $vs2$vm */ + RISCV_VFIRST_M /* 12450 */, RISCV_INS_VFIRST_M, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfmacc.vf $vd, $rs1, $vs2$vm */ + RISCV_VFMACC_VF /* 12451 */, RISCV_INS_VFMACC_VF, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfmacc.vv $vd, $vs1, $vs2$vm */ + RISCV_VFMACC_VV /* 12452 */, RISCV_INS_VFMACC_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfmadd.vf $vd, $rs1, $vs2$vm */ + RISCV_VFMADD_VF /* 12453 */, RISCV_INS_VFMADD_VF, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfmadd.vv $vd, $vs1, $vs2$vm */ + RISCV_VFMADD_VV /* 12454 */, RISCV_INS_VFMADD_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfmax.vf $vd, $vs2, $rs1$vm */ + RISCV_VFMAX_VF /* 12455 */, RISCV_INS_VFMAX_VF, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfmax.vv $vd, $vs2, $vs1$vm */ + RISCV_VFMAX_VV /* 12456 */, RISCV_INS_VFMAX_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfmerge.vfm $vd, $vs2, $rs1, v0 */ + RISCV_VFMERGE_VFM /* 12457 */, RISCV_INS_VFMERGE_VFM, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfmin.vf $vd, $vs2, $rs1$vm */ + RISCV_VFMIN_VF /* 12458 */, RISCV_INS_VFMIN_VF, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfmin.vv $vd, $vs2, $vs1$vm */ + RISCV_VFMIN_VV /* 12459 */, RISCV_INS_VFMIN_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfmsac.vf $vd, $rs1, $vs2$vm */ + RISCV_VFMSAC_VF /* 12460 */, RISCV_INS_VFMSAC_VF, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfmsac.vv $vd, $vs1, $vs2$vm */ + RISCV_VFMSAC_VV /* 12461 */, RISCV_INS_VFMSAC_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfmsub.vf $vd, $rs1, $vs2$vm */ + RISCV_VFMSUB_VF /* 12462 */, RISCV_INS_VFMSUB_VF, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfmsub.vv $vd, $vs1, $vs2$vm */ + RISCV_VFMSUB_VV /* 12463 */, RISCV_INS_VFMSUB_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfmul.vf $vd, $vs2, $rs1$vm */ + RISCV_VFMUL_VF /* 12464 */, RISCV_INS_VFMUL_VF, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfmul.vv $vd, $vs2, $vs1$vm */ + RISCV_VFMUL_VV /* 12465 */, RISCV_INS_VFMUL_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfmv.f.s $vd, $vs2 */ + RISCV_VFMV_F_S /* 12466 */, RISCV_INS_VFMV_F_S, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfmv.s.f $vd, $rs1 */ + RISCV_VFMV_S_F /* 12467 */, RISCV_INS_VFMV_S_F, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfmv.v.f $vd, $rs1 */ + RISCV_VFMV_V_F /* 12468 */, RISCV_INS_VFMV_V_F, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfncvtbf16.f.f.w $vd, $vs2$vm */ + RISCV_VFNCVTBF16_F_F_W /* 12469 */, RISCV_INS_VFNCVTBF16_F_F_W, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZVFBFMIN, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfncvt.f.f.w $vd, $vs2$vm */ + RISCV_VFNCVT_F_F_W /* 12470 */, RISCV_INS_VFNCVT_F_F_W, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfncvt.f.xu.w $vd, $vs2$vm */ + RISCV_VFNCVT_F_XU_W /* 12471 */, RISCV_INS_VFNCVT_F_XU_W, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfncvt.f.x.w $vd, $vs2$vm */ + RISCV_VFNCVT_F_X_W /* 12472 */, RISCV_INS_VFNCVT_F_X_W, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfncvt.rod.f.f.w $vd, $vs2$vm */ + RISCV_VFNCVT_ROD_F_F_W /* 12473 */, RISCV_INS_VFNCVT_ROD_F_F_W, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfncvt.rtz.xu.f.w $vd, $vs2$vm */ + RISCV_VFNCVT_RTZ_XU_F_W /* 12474 */, RISCV_INS_VFNCVT_RTZ_XU_F_W, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfncvt.rtz.x.f.w $vd, $vs2$vm */ + RISCV_VFNCVT_RTZ_X_F_W /* 12475 */, RISCV_INS_VFNCVT_RTZ_X_F_W, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfncvt.xu.f.w $vd, $vs2$vm */ + RISCV_VFNCVT_XU_F_W /* 12476 */, RISCV_INS_VFNCVT_XU_F_W, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfncvt.x.f.w $vd, $vs2$vm */ + RISCV_VFNCVT_X_F_W /* 12477 */, RISCV_INS_VFNCVT_X_F_W, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfnmacc.vf $vd, $rs1, $vs2$vm */ + RISCV_VFNMACC_VF /* 12478 */, RISCV_INS_VFNMACC_VF, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfnmacc.vv $vd, $vs1, $vs2$vm */ + RISCV_VFNMACC_VV /* 12479 */, RISCV_INS_VFNMACC_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfnmadd.vf $vd, $rs1, $vs2$vm */ + RISCV_VFNMADD_VF /* 12480 */, RISCV_INS_VFNMADD_VF, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfnmadd.vv $vd, $vs1, $vs2$vm */ + RISCV_VFNMADD_VV /* 12481 */, RISCV_INS_VFNMADD_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfnmsac.vf $vd, $rs1, $vs2$vm */ + RISCV_VFNMSAC_VF /* 12482 */, RISCV_INS_VFNMSAC_VF, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfnmsac.vv $vd, $vs1, $vs2$vm */ + RISCV_VFNMSAC_VV /* 12483 */, RISCV_INS_VFNMSAC_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfnmsub.vf $vd, $rs1, $vs2$vm */ + RISCV_VFNMSUB_VF /* 12484 */, RISCV_INS_VFNMSUB_VF, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfnmsub.vv $vd, $vs1, $vs2$vm */ + RISCV_VFNMSUB_VV /* 12485 */, RISCV_INS_VFNMSUB_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sf.vfnrclip.xu.f.qf $vd, $vs2, $rs1$vm */ + RISCV_VFNRCLIP_XU_F_QF /* 12486 */, RISCV_INS_SF_VFNRCLIP_XU_F_QF, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXSFVFNRCLIPXFQF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sf.vfnrclip.x.f.qf $vd, $vs2, $rs1$vm */ + RISCV_VFNRCLIP_X_F_QF /* 12487 */, RISCV_INS_SF_VFNRCLIP_X_F_QF, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXSFVFNRCLIPXFQF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfrdiv.vf $vd, $vs2, $rs1$vm */ + RISCV_VFRDIV_VF /* 12488 */, RISCV_INS_VFRDIV_VF, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfrec7.v $vd, $vs2$vm */ + RISCV_VFREC7_V /* 12489 */, RISCV_INS_VFREC7_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfredmax.vs $vd, $vs2, $vs1$vm */ + RISCV_VFREDMAX_VS /* 12490 */, RISCV_INS_VFREDMAX_VS, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfredmin.vs $vd, $vs2, $vs1$vm */ + RISCV_VFREDMIN_VS /* 12491 */, RISCV_INS_VFREDMIN_VS, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfredosum.vs $vd, $vs2, $vs1$vm */ + RISCV_VFREDOSUM_VS /* 12492 */, RISCV_INS_VFREDOSUM_VS, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfredusum.vs $vd, $vs2, $vs1$vm */ + RISCV_VFREDUSUM_VS /* 12493 */, RISCV_INS_VFREDUSUM_VS, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfrsqrt7.v $vd, $vs2$vm */ + RISCV_VFRSQRT7_V /* 12494 */, RISCV_INS_VFRSQRT7_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfrsub.vf $vd, $vs2, $rs1$vm */ + RISCV_VFRSUB_VF /* 12495 */, RISCV_INS_VFRSUB_VF, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfsgnjn.vf $vd, $vs2, $rs1$vm */ + RISCV_VFSGNJN_VF /* 12496 */, RISCV_INS_VFSGNJN_VF, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfsgnjn.vv $vd, $vs2, $vs1$vm */ + RISCV_VFSGNJN_VV /* 12497 */, RISCV_INS_VFSGNJN_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfsgnjx.vf $vd, $vs2, $rs1$vm */ + RISCV_VFSGNJX_VF /* 12498 */, RISCV_INS_VFSGNJX_VF, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfsgnjx.vv $vd, $vs2, $vs1$vm */ + RISCV_VFSGNJX_VV /* 12499 */, RISCV_INS_VFSGNJX_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfsgnj.vf $vd, $vs2, $rs1$vm */ + RISCV_VFSGNJ_VF /* 12500 */, RISCV_INS_VFSGNJ_VF, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfsgnj.vv $vd, $vs2, $vs1$vm */ + RISCV_VFSGNJ_VV /* 12501 */, RISCV_INS_VFSGNJ_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfslide1down.vf $vd, $vs2, $rs1$vm */ + RISCV_VFSLIDE1DOWN_VF /* 12502 */, RISCV_INS_VFSLIDE1DOWN_VF, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfslide1up.vf $vd, $vs2, $rs1$vm */ + RISCV_VFSLIDE1UP_VF /* 12503 */, RISCV_INS_VFSLIDE1UP_VF, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfsqrt.v $vd, $vs2$vm */ + RISCV_VFSQRT_V /* 12504 */, RISCV_INS_VFSQRT_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfsub.vf $vd, $vs2, $rs1$vm */ + RISCV_VFSUB_VF /* 12505 */, RISCV_INS_VFSUB_VF, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfsub.vv $vd, $vs2, $vs1$vm */ + RISCV_VFSUB_VV /* 12506 */, RISCV_INS_VFSUB_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfwadd.vf $vd, $vs2, $rs1$vm */ + RISCV_VFWADD_VF /* 12507 */, RISCV_INS_VFWADD_VF, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfwadd.vv $vd, $vs2, $vs1$vm */ + RISCV_VFWADD_VV /* 12508 */, RISCV_INS_VFWADD_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfwadd.wf $vd, $vs2, $rs1$vm */ + RISCV_VFWADD_WF /* 12509 */, RISCV_INS_VFWADD_WF, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfwadd.wv $vd, $vs2, $vs1$vm */ + RISCV_VFWADD_WV /* 12510 */, RISCV_INS_VFWADD_WV, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfwcvtbf16.f.f.v $vd, $vs2$vm */ + RISCV_VFWCVTBF16_F_F_V /* 12511 */, RISCV_INS_VFWCVTBF16_F_F_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZVFBFMIN, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfwcvt.f.f.v $vd, $vs2$vm */ + RISCV_VFWCVT_F_F_V /* 12512 */, RISCV_INS_VFWCVT_F_F_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfwcvt.f.xu.v $vd, $vs2$vm */ + RISCV_VFWCVT_F_XU_V /* 12513 */, RISCV_INS_VFWCVT_F_XU_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfwcvt.f.x.v $vd, $vs2$vm */ + RISCV_VFWCVT_F_X_V /* 12514 */, RISCV_INS_VFWCVT_F_X_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfwcvt.rtz.xu.f.v $vd, $vs2$vm */ + RISCV_VFWCVT_RTZ_XU_F_V /* 12515 */, RISCV_INS_VFWCVT_RTZ_XU_F_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfwcvt.rtz.x.f.v $vd, $vs2$vm */ + RISCV_VFWCVT_RTZ_X_F_V /* 12516 */, RISCV_INS_VFWCVT_RTZ_X_F_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfwcvt.xu.f.v $vd, $vs2$vm */ + RISCV_VFWCVT_XU_F_V /* 12517 */, RISCV_INS_VFWCVT_XU_F_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfwcvt.x.f.v $vd, $vs2$vm */ + RISCV_VFWCVT_X_F_V /* 12518 */, RISCV_INS_VFWCVT_X_F_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfwmaccbf16.vf $vd, $rs1, $vs2$vm */ + RISCV_VFWMACCBF16_VF /* 12519 */, RISCV_INS_VFWMACCBF16_VF, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZVFBFWMA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfwmaccbf16.vv $vd, $vs1, $vs2$vm */ + RISCV_VFWMACCBF16_VV /* 12520 */, RISCV_INS_VFWMACCBF16_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZVFBFWMA, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sf.vfwmacc.4x4x4 $rd, $rs1, $rs2 */ + RISCV_VFWMACC_4x4x4 /* 12521 */, RISCV_INS_SF_VFWMACC_4X4X4, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXSFVFWMACCQQQ, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfwmacc.vf $vd, $rs1, $vs2$vm */ + RISCV_VFWMACC_VF /* 12522 */, RISCV_INS_VFWMACC_VF, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfwmacc.vv $vd, $vs1, $vs2$vm */ + RISCV_VFWMACC_VV /* 12523 */, RISCV_INS_VFWMACC_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfwmsac.vf $vd, $rs1, $vs2$vm */ + RISCV_VFWMSAC_VF /* 12524 */, RISCV_INS_VFWMSAC_VF, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfwmsac.vv $vd, $vs1, $vs2$vm */ + RISCV_VFWMSAC_VV /* 12525 */, RISCV_INS_VFWMSAC_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfwmul.vf $vd, $vs2, $rs1$vm */ + RISCV_VFWMUL_VF /* 12526 */, RISCV_INS_VFWMUL_VF, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfwmul.vv $vd, $vs2, $vs1$vm */ + RISCV_VFWMUL_VV /* 12527 */, RISCV_INS_VFWMUL_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfwnmacc.vf $vd, $rs1, $vs2$vm */ + RISCV_VFWNMACC_VF /* 12528 */, RISCV_INS_VFWNMACC_VF, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfwnmacc.vv $vd, $vs1, $vs2$vm */ + RISCV_VFWNMACC_VV /* 12529 */, RISCV_INS_VFWNMACC_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfwnmsac.vf $vd, $rs1, $vs2$vm */ + RISCV_VFWNMSAC_VF /* 12530 */, RISCV_INS_VFWNMSAC_VF, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfwnmsac.vv $vd, $vs1, $vs2$vm */ + RISCV_VFWNMSAC_VV /* 12531 */, RISCV_INS_VFWNMSAC_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfwredosum.vs $vd, $vs2, $vs1$vm */ + RISCV_VFWREDOSUM_VS /* 12532 */, RISCV_INS_VFWREDOSUM_VS, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfwredusum.vs $vd, $vs2, $vs1$vm */ + RISCV_VFWREDUSUM_VS /* 12533 */, RISCV_INS_VFWREDUSUM_VS, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfwsub.vf $vd, $vs2, $rs1$vm */ + RISCV_VFWSUB_VF /* 12534 */, RISCV_INS_VFWSUB_VF, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfwsub.vv $vd, $vs2, $vs1$vm */ + RISCV_VFWSUB_VV /* 12535 */, RISCV_INS_VFWSUB_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfwsub.wf $vd, $vs2, $rs1$vm */ + RISCV_VFWSUB_WF /* 12536 */, RISCV_INS_VFWSUB_WF, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vfwsub.wv $vd, $vs2, $vs1$vm */ + RISCV_VFWSUB_WV /* 12537 */, RISCV_INS_VFWSUB_WV, + #ifndef CAPSTONE_DIET + { RISCV_REG_FRM, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vghsh.vv $vd, $vs2, $vs1 */ + RISCV_VGHSH_VV /* 12538 */, RISCV_INS_VGHSH_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZVKG, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vgmul.vv $vd, $vs2 */ + RISCV_VGMUL_VV /* 12539 */, RISCV_INS_VGMUL_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZVKG, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vid.v $vd$vm */ + RISCV_VID_V /* 12540 */, RISCV_INS_VID_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* viota.m $vd, $vs2$vm */ + RISCV_VIOTA_M /* 12541 */, RISCV_INS_VIOTA_M, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vl1re16.v $vd, $rs1 */ + RISCV_VL1RE16_V /* 12542 */, RISCV_INS_VL1RE16_V, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vl1re32.v $vd, $rs1 */ + RISCV_VL1RE32_V /* 12543 */, RISCV_INS_VL1RE32_V, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vl1re64.v $vd, $rs1 */ + RISCV_VL1RE64_V /* 12544 */, RISCV_INS_VL1RE64_V, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vl1re8.v $vd, $rs1 */ + RISCV_VL1RE8_V /* 12545 */, RISCV_INS_VL1RE8_V, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vl2re16.v $vd, $rs1 */ + RISCV_VL2RE16_V /* 12546 */, RISCV_INS_VL2RE16_V, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vl2re32.v $vd, $rs1 */ + RISCV_VL2RE32_V /* 12547 */, RISCV_INS_VL2RE32_V, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vl2re64.v $vd, $rs1 */ + RISCV_VL2RE64_V /* 12548 */, RISCV_INS_VL2RE64_V, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vl2re8.v $vd, $rs1 */ + RISCV_VL2RE8_V /* 12549 */, RISCV_INS_VL2RE8_V, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vl4re16.v $vd, $rs1 */ + RISCV_VL4RE16_V /* 12550 */, RISCV_INS_VL4RE16_V, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vl4re32.v $vd, $rs1 */ + RISCV_VL4RE32_V /* 12551 */, RISCV_INS_VL4RE32_V, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vl4re64.v $vd, $rs1 */ + RISCV_VL4RE64_V /* 12552 */, RISCV_INS_VL4RE64_V, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vl4re8.v $vd, $rs1 */ + RISCV_VL4RE8_V /* 12553 */, RISCV_INS_VL4RE8_V, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vl8re16.v $vd, $rs1 */ + RISCV_VL8RE16_V /* 12554 */, RISCV_INS_VL8RE16_V, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vl8re32.v $vd, $rs1 */ + RISCV_VL8RE32_V /* 12555 */, RISCV_INS_VL8RE32_V, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vl8re64.v $vd, $rs1 */ + RISCV_VL8RE64_V /* 12556 */, RISCV_INS_VL8RE64_V, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vl8re8.v $vd, $rs1 */ + RISCV_VL8RE8_V /* 12557 */, RISCV_INS_VL8RE8_V, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vle16ff.v $vd, ${rs1}$vm */ + RISCV_VLE16FF_V /* 12558 */, RISCV_INS_VLE16FF_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vle16.v $vd, ${rs1}$vm */ + RISCV_VLE16_V /* 12559 */, RISCV_INS_VLE16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vle32ff.v $vd, ${rs1}$vm */ + RISCV_VLE32FF_V /* 12560 */, RISCV_INS_VLE32FF_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vle32.v $vd, ${rs1}$vm */ + RISCV_VLE32_V /* 12561 */, RISCV_INS_VLE32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vle64ff.v $vd, ${rs1}$vm */ + RISCV_VLE64FF_V /* 12562 */, RISCV_INS_VLE64FF_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vle64.v $vd, ${rs1}$vm */ + RISCV_VLE64_V /* 12563 */, RISCV_INS_VLE64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vle8ff.v $vd, ${rs1}$vm */ + RISCV_VLE8FF_V /* 12564 */, RISCV_INS_VLE8FF_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vle8.v $vd, ${rs1}$vm */ + RISCV_VLE8_V /* 12565 */, RISCV_INS_VLE8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlm.v $vd, $rs1 */ + RISCV_VLM_V /* 12566 */, RISCV_INS_VLM_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vloxei16.v $vd, $rs1, $vs2$vm */ + RISCV_VLOXEI16_V /* 12567 */, RISCV_INS_VLOXEI16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vloxei32.v $vd, $rs1, $vs2$vm */ + RISCV_VLOXEI32_V /* 12568 */, RISCV_INS_VLOXEI32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vloxei64.v $vd, $rs1, $vs2$vm */ + RISCV_VLOXEI64_V /* 12569 */, RISCV_INS_VLOXEI64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_ISRV64, RISCV_FEATURE_HASVINSTRUCTIONSI64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vloxei8.v $vd, $rs1, $vs2$vm */ + RISCV_VLOXEI8_V /* 12570 */, RISCV_INS_VLOXEI8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vloxseg2ei16.v $vd, $rs1, $vs2$vm */ + RISCV_VLOXSEG2EI16_V /* 12571 */, RISCV_INS_VLOXSEG2EI16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vloxseg2ei32.v $vd, $rs1, $vs2$vm */ + RISCV_VLOXSEG2EI32_V /* 12572 */, RISCV_INS_VLOXSEG2EI32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vloxseg2ei64.v $vd, $rs1, $vs2$vm */ + RISCV_VLOXSEG2EI64_V /* 12573 */, RISCV_INS_VLOXSEG2EI64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vloxseg2ei8.v $vd, $rs1, $vs2$vm */ + RISCV_VLOXSEG2EI8_V /* 12574 */, RISCV_INS_VLOXSEG2EI8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vloxseg3ei16.v $vd, $rs1, $vs2$vm */ + RISCV_VLOXSEG3EI16_V /* 12575 */, RISCV_INS_VLOXSEG3EI16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vloxseg3ei32.v $vd, $rs1, $vs2$vm */ + RISCV_VLOXSEG3EI32_V /* 12576 */, RISCV_INS_VLOXSEG3EI32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vloxseg3ei64.v $vd, $rs1, $vs2$vm */ + RISCV_VLOXSEG3EI64_V /* 12577 */, RISCV_INS_VLOXSEG3EI64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vloxseg3ei8.v $vd, $rs1, $vs2$vm */ + RISCV_VLOXSEG3EI8_V /* 12578 */, RISCV_INS_VLOXSEG3EI8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vloxseg4ei16.v $vd, $rs1, $vs2$vm */ + RISCV_VLOXSEG4EI16_V /* 12579 */, RISCV_INS_VLOXSEG4EI16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vloxseg4ei32.v $vd, $rs1, $vs2$vm */ + RISCV_VLOXSEG4EI32_V /* 12580 */, RISCV_INS_VLOXSEG4EI32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vloxseg4ei64.v $vd, $rs1, $vs2$vm */ + RISCV_VLOXSEG4EI64_V /* 12581 */, RISCV_INS_VLOXSEG4EI64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vloxseg4ei8.v $vd, $rs1, $vs2$vm */ + RISCV_VLOXSEG4EI8_V /* 12582 */, RISCV_INS_VLOXSEG4EI8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vloxseg5ei16.v $vd, $rs1, $vs2$vm */ + RISCV_VLOXSEG5EI16_V /* 12583 */, RISCV_INS_VLOXSEG5EI16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vloxseg5ei32.v $vd, $rs1, $vs2$vm */ + RISCV_VLOXSEG5EI32_V /* 12584 */, RISCV_INS_VLOXSEG5EI32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vloxseg5ei64.v $vd, $rs1, $vs2$vm */ + RISCV_VLOXSEG5EI64_V /* 12585 */, RISCV_INS_VLOXSEG5EI64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vloxseg5ei8.v $vd, $rs1, $vs2$vm */ + RISCV_VLOXSEG5EI8_V /* 12586 */, RISCV_INS_VLOXSEG5EI8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vloxseg6ei16.v $vd, $rs1, $vs2$vm */ + RISCV_VLOXSEG6EI16_V /* 12587 */, RISCV_INS_VLOXSEG6EI16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vloxseg6ei32.v $vd, $rs1, $vs2$vm */ + RISCV_VLOXSEG6EI32_V /* 12588 */, RISCV_INS_VLOXSEG6EI32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vloxseg6ei64.v $vd, $rs1, $vs2$vm */ + RISCV_VLOXSEG6EI64_V /* 12589 */, RISCV_INS_VLOXSEG6EI64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vloxseg6ei8.v $vd, $rs1, $vs2$vm */ + RISCV_VLOXSEG6EI8_V /* 12590 */, RISCV_INS_VLOXSEG6EI8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vloxseg7ei16.v $vd, $rs1, $vs2$vm */ + RISCV_VLOXSEG7EI16_V /* 12591 */, RISCV_INS_VLOXSEG7EI16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vloxseg7ei32.v $vd, $rs1, $vs2$vm */ + RISCV_VLOXSEG7EI32_V /* 12592 */, RISCV_INS_VLOXSEG7EI32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vloxseg7ei64.v $vd, $rs1, $vs2$vm */ + RISCV_VLOXSEG7EI64_V /* 12593 */, RISCV_INS_VLOXSEG7EI64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vloxseg7ei8.v $vd, $rs1, $vs2$vm */ + RISCV_VLOXSEG7EI8_V /* 12594 */, RISCV_INS_VLOXSEG7EI8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vloxseg8ei16.v $vd, $rs1, $vs2$vm */ + RISCV_VLOXSEG8EI16_V /* 12595 */, RISCV_INS_VLOXSEG8EI16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vloxseg8ei32.v $vd, $rs1, $vs2$vm */ + RISCV_VLOXSEG8EI32_V /* 12596 */, RISCV_INS_VLOXSEG8EI32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vloxseg8ei64.v $vd, $rs1, $vs2$vm */ + RISCV_VLOXSEG8EI64_V /* 12597 */, RISCV_INS_VLOXSEG8EI64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vloxseg8ei8.v $vd, $rs1, $vs2$vm */ + RISCV_VLOXSEG8EI8_V /* 12598 */, RISCV_INS_VLOXSEG8EI8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlse16.v $vd, $rs1, $rs2$vm */ + RISCV_VLSE16_V /* 12599 */, RISCV_INS_VLSE16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlse32.v $vd, $rs1, $rs2$vm */ + RISCV_VLSE32_V /* 12600 */, RISCV_INS_VLSE32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlse64.v $vd, $rs1, $rs2$vm */ + RISCV_VLSE64_V /* 12601 */, RISCV_INS_VLSE64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlse8.v $vd, $rs1, $rs2$vm */ + RISCV_VLSE8_V /* 12602 */, RISCV_INS_VLSE8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlseg2e16ff.v $vd, ${rs1}$vm */ + RISCV_VLSEG2E16FF_V /* 12603 */, RISCV_INS_VLSEG2E16FF_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlseg2e16.v $vd, ${rs1}$vm */ + RISCV_VLSEG2E16_V /* 12604 */, RISCV_INS_VLSEG2E16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlseg2e32ff.v $vd, ${rs1}$vm */ + RISCV_VLSEG2E32FF_V /* 12605 */, RISCV_INS_VLSEG2E32FF_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlseg2e32.v $vd, ${rs1}$vm */ + RISCV_VLSEG2E32_V /* 12606 */, RISCV_INS_VLSEG2E32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlseg2e64ff.v $vd, ${rs1}$vm */ + RISCV_VLSEG2E64FF_V /* 12607 */, RISCV_INS_VLSEG2E64FF_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlseg2e64.v $vd, ${rs1}$vm */ + RISCV_VLSEG2E64_V /* 12608 */, RISCV_INS_VLSEG2E64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlseg2e8ff.v $vd, ${rs1}$vm */ + RISCV_VLSEG2E8FF_V /* 12609 */, RISCV_INS_VLSEG2E8FF_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlseg2e8.v $vd, ${rs1}$vm */ + RISCV_VLSEG2E8_V /* 12610 */, RISCV_INS_VLSEG2E8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlseg3e16ff.v $vd, ${rs1}$vm */ + RISCV_VLSEG3E16FF_V /* 12611 */, RISCV_INS_VLSEG3E16FF_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlseg3e16.v $vd, ${rs1}$vm */ + RISCV_VLSEG3E16_V /* 12612 */, RISCV_INS_VLSEG3E16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlseg3e32ff.v $vd, ${rs1}$vm */ + RISCV_VLSEG3E32FF_V /* 12613 */, RISCV_INS_VLSEG3E32FF_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlseg3e32.v $vd, ${rs1}$vm */ + RISCV_VLSEG3E32_V /* 12614 */, RISCV_INS_VLSEG3E32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlseg3e64ff.v $vd, ${rs1}$vm */ + RISCV_VLSEG3E64FF_V /* 12615 */, RISCV_INS_VLSEG3E64FF_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlseg3e64.v $vd, ${rs1}$vm */ + RISCV_VLSEG3E64_V /* 12616 */, RISCV_INS_VLSEG3E64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlseg3e8ff.v $vd, ${rs1}$vm */ + RISCV_VLSEG3E8FF_V /* 12617 */, RISCV_INS_VLSEG3E8FF_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlseg3e8.v $vd, ${rs1}$vm */ + RISCV_VLSEG3E8_V /* 12618 */, RISCV_INS_VLSEG3E8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlseg4e16ff.v $vd, ${rs1}$vm */ + RISCV_VLSEG4E16FF_V /* 12619 */, RISCV_INS_VLSEG4E16FF_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlseg4e16.v $vd, ${rs1}$vm */ + RISCV_VLSEG4E16_V /* 12620 */, RISCV_INS_VLSEG4E16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlseg4e32ff.v $vd, ${rs1}$vm */ + RISCV_VLSEG4E32FF_V /* 12621 */, RISCV_INS_VLSEG4E32FF_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlseg4e32.v $vd, ${rs1}$vm */ + RISCV_VLSEG4E32_V /* 12622 */, RISCV_INS_VLSEG4E32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlseg4e64ff.v $vd, ${rs1}$vm */ + RISCV_VLSEG4E64FF_V /* 12623 */, RISCV_INS_VLSEG4E64FF_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlseg4e64.v $vd, ${rs1}$vm */ + RISCV_VLSEG4E64_V /* 12624 */, RISCV_INS_VLSEG4E64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlseg4e8ff.v $vd, ${rs1}$vm */ + RISCV_VLSEG4E8FF_V /* 12625 */, RISCV_INS_VLSEG4E8FF_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlseg4e8.v $vd, ${rs1}$vm */ + RISCV_VLSEG4E8_V /* 12626 */, RISCV_INS_VLSEG4E8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlseg5e16ff.v $vd, ${rs1}$vm */ + RISCV_VLSEG5E16FF_V /* 12627 */, RISCV_INS_VLSEG5E16FF_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlseg5e16.v $vd, ${rs1}$vm */ + RISCV_VLSEG5E16_V /* 12628 */, RISCV_INS_VLSEG5E16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlseg5e32ff.v $vd, ${rs1}$vm */ + RISCV_VLSEG5E32FF_V /* 12629 */, RISCV_INS_VLSEG5E32FF_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlseg5e32.v $vd, ${rs1}$vm */ + RISCV_VLSEG5E32_V /* 12630 */, RISCV_INS_VLSEG5E32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlseg5e64ff.v $vd, ${rs1}$vm */ + RISCV_VLSEG5E64FF_V /* 12631 */, RISCV_INS_VLSEG5E64FF_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlseg5e64.v $vd, ${rs1}$vm */ + RISCV_VLSEG5E64_V /* 12632 */, RISCV_INS_VLSEG5E64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlseg5e8ff.v $vd, ${rs1}$vm */ + RISCV_VLSEG5E8FF_V /* 12633 */, RISCV_INS_VLSEG5E8FF_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlseg5e8.v $vd, ${rs1}$vm */ + RISCV_VLSEG5E8_V /* 12634 */, RISCV_INS_VLSEG5E8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlseg6e16ff.v $vd, ${rs1}$vm */ + RISCV_VLSEG6E16FF_V /* 12635 */, RISCV_INS_VLSEG6E16FF_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlseg6e16.v $vd, ${rs1}$vm */ + RISCV_VLSEG6E16_V /* 12636 */, RISCV_INS_VLSEG6E16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlseg6e32ff.v $vd, ${rs1}$vm */ + RISCV_VLSEG6E32FF_V /* 12637 */, RISCV_INS_VLSEG6E32FF_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlseg6e32.v $vd, ${rs1}$vm */ + RISCV_VLSEG6E32_V /* 12638 */, RISCV_INS_VLSEG6E32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlseg6e64ff.v $vd, ${rs1}$vm */ + RISCV_VLSEG6E64FF_V /* 12639 */, RISCV_INS_VLSEG6E64FF_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlseg6e64.v $vd, ${rs1}$vm */ + RISCV_VLSEG6E64_V /* 12640 */, RISCV_INS_VLSEG6E64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlseg6e8ff.v $vd, ${rs1}$vm */ + RISCV_VLSEG6E8FF_V /* 12641 */, RISCV_INS_VLSEG6E8FF_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlseg6e8.v $vd, ${rs1}$vm */ + RISCV_VLSEG6E8_V /* 12642 */, RISCV_INS_VLSEG6E8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlseg7e16ff.v $vd, ${rs1}$vm */ + RISCV_VLSEG7E16FF_V /* 12643 */, RISCV_INS_VLSEG7E16FF_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlseg7e16.v $vd, ${rs1}$vm */ + RISCV_VLSEG7E16_V /* 12644 */, RISCV_INS_VLSEG7E16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlseg7e32ff.v $vd, ${rs1}$vm */ + RISCV_VLSEG7E32FF_V /* 12645 */, RISCV_INS_VLSEG7E32FF_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlseg7e32.v $vd, ${rs1}$vm */ + RISCV_VLSEG7E32_V /* 12646 */, RISCV_INS_VLSEG7E32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlseg7e64ff.v $vd, ${rs1}$vm */ + RISCV_VLSEG7E64FF_V /* 12647 */, RISCV_INS_VLSEG7E64FF_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlseg7e64.v $vd, ${rs1}$vm */ + RISCV_VLSEG7E64_V /* 12648 */, RISCV_INS_VLSEG7E64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlseg7e8ff.v $vd, ${rs1}$vm */ + RISCV_VLSEG7E8FF_V /* 12649 */, RISCV_INS_VLSEG7E8FF_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlseg7e8.v $vd, ${rs1}$vm */ + RISCV_VLSEG7E8_V /* 12650 */, RISCV_INS_VLSEG7E8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlseg8e16ff.v $vd, ${rs1}$vm */ + RISCV_VLSEG8E16FF_V /* 12651 */, RISCV_INS_VLSEG8E16FF_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlseg8e16.v $vd, ${rs1}$vm */ + RISCV_VLSEG8E16_V /* 12652 */, RISCV_INS_VLSEG8E16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlseg8e32ff.v $vd, ${rs1}$vm */ + RISCV_VLSEG8E32FF_V /* 12653 */, RISCV_INS_VLSEG8E32FF_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlseg8e32.v $vd, ${rs1}$vm */ + RISCV_VLSEG8E32_V /* 12654 */, RISCV_INS_VLSEG8E32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlseg8e64ff.v $vd, ${rs1}$vm */ + RISCV_VLSEG8E64FF_V /* 12655 */, RISCV_INS_VLSEG8E64FF_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlseg8e64.v $vd, ${rs1}$vm */ + RISCV_VLSEG8E64_V /* 12656 */, RISCV_INS_VLSEG8E64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlseg8e8ff.v $vd, ${rs1}$vm */ + RISCV_VLSEG8E8FF_V /* 12657 */, RISCV_INS_VLSEG8E8FF_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlseg8e8.v $vd, ${rs1}$vm */ + RISCV_VLSEG8E8_V /* 12658 */, RISCV_INS_VLSEG8E8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlsseg2e16.v $vd, $rs1, $rs2$vm */ + RISCV_VLSSEG2E16_V /* 12659 */, RISCV_INS_VLSSEG2E16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlsseg2e32.v $vd, $rs1, $rs2$vm */ + RISCV_VLSSEG2E32_V /* 12660 */, RISCV_INS_VLSSEG2E32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlsseg2e64.v $vd, $rs1, $rs2$vm */ + RISCV_VLSSEG2E64_V /* 12661 */, RISCV_INS_VLSSEG2E64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlsseg2e8.v $vd, $rs1, $rs2$vm */ + RISCV_VLSSEG2E8_V /* 12662 */, RISCV_INS_VLSSEG2E8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlsseg3e16.v $vd, $rs1, $rs2$vm */ + RISCV_VLSSEG3E16_V /* 12663 */, RISCV_INS_VLSSEG3E16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlsseg3e32.v $vd, $rs1, $rs2$vm */ + RISCV_VLSSEG3E32_V /* 12664 */, RISCV_INS_VLSSEG3E32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlsseg3e64.v $vd, $rs1, $rs2$vm */ + RISCV_VLSSEG3E64_V /* 12665 */, RISCV_INS_VLSSEG3E64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlsseg3e8.v $vd, $rs1, $rs2$vm */ + RISCV_VLSSEG3E8_V /* 12666 */, RISCV_INS_VLSSEG3E8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlsseg4e16.v $vd, $rs1, $rs2$vm */ + RISCV_VLSSEG4E16_V /* 12667 */, RISCV_INS_VLSSEG4E16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlsseg4e32.v $vd, $rs1, $rs2$vm */ + RISCV_VLSSEG4E32_V /* 12668 */, RISCV_INS_VLSSEG4E32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlsseg4e64.v $vd, $rs1, $rs2$vm */ + RISCV_VLSSEG4E64_V /* 12669 */, RISCV_INS_VLSSEG4E64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlsseg4e8.v $vd, $rs1, $rs2$vm */ + RISCV_VLSSEG4E8_V /* 12670 */, RISCV_INS_VLSSEG4E8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlsseg5e16.v $vd, $rs1, $rs2$vm */ + RISCV_VLSSEG5E16_V /* 12671 */, RISCV_INS_VLSSEG5E16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlsseg5e32.v $vd, $rs1, $rs2$vm */ + RISCV_VLSSEG5E32_V /* 12672 */, RISCV_INS_VLSSEG5E32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlsseg5e64.v $vd, $rs1, $rs2$vm */ + RISCV_VLSSEG5E64_V /* 12673 */, RISCV_INS_VLSSEG5E64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlsseg5e8.v $vd, $rs1, $rs2$vm */ + RISCV_VLSSEG5E8_V /* 12674 */, RISCV_INS_VLSSEG5E8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlsseg6e16.v $vd, $rs1, $rs2$vm */ + RISCV_VLSSEG6E16_V /* 12675 */, RISCV_INS_VLSSEG6E16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlsseg6e32.v $vd, $rs1, $rs2$vm */ + RISCV_VLSSEG6E32_V /* 12676 */, RISCV_INS_VLSSEG6E32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlsseg6e64.v $vd, $rs1, $rs2$vm */ + RISCV_VLSSEG6E64_V /* 12677 */, RISCV_INS_VLSSEG6E64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlsseg6e8.v $vd, $rs1, $rs2$vm */ + RISCV_VLSSEG6E8_V /* 12678 */, RISCV_INS_VLSSEG6E8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlsseg7e16.v $vd, $rs1, $rs2$vm */ + RISCV_VLSSEG7E16_V /* 12679 */, RISCV_INS_VLSSEG7E16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlsseg7e32.v $vd, $rs1, $rs2$vm */ + RISCV_VLSSEG7E32_V /* 12680 */, RISCV_INS_VLSSEG7E32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlsseg7e64.v $vd, $rs1, $rs2$vm */ + RISCV_VLSSEG7E64_V /* 12681 */, RISCV_INS_VLSSEG7E64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlsseg7e8.v $vd, $rs1, $rs2$vm */ + RISCV_VLSSEG7E8_V /* 12682 */, RISCV_INS_VLSSEG7E8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlsseg8e16.v $vd, $rs1, $rs2$vm */ + RISCV_VLSSEG8E16_V /* 12683 */, RISCV_INS_VLSSEG8E16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlsseg8e32.v $vd, $rs1, $rs2$vm */ + RISCV_VLSSEG8E32_V /* 12684 */, RISCV_INS_VLSSEG8E32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlsseg8e64.v $vd, $rs1, $rs2$vm */ + RISCV_VLSSEG8E64_V /* 12685 */, RISCV_INS_VLSSEG8E64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vlsseg8e8.v $vd, $rs1, $rs2$vm */ + RISCV_VLSSEG8E8_V /* 12686 */, RISCV_INS_VLSSEG8E8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vluxei16.v $vd, $rs1, $vs2$vm */ + RISCV_VLUXEI16_V /* 12687 */, RISCV_INS_VLUXEI16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vluxei32.v $vd, $rs1, $vs2$vm */ + RISCV_VLUXEI32_V /* 12688 */, RISCV_INS_VLUXEI32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vluxei64.v $vd, $rs1, $vs2$vm */ + RISCV_VLUXEI64_V /* 12689 */, RISCV_INS_VLUXEI64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_ISRV64, RISCV_FEATURE_HASVINSTRUCTIONSI64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vluxei8.v $vd, $rs1, $vs2$vm */ + RISCV_VLUXEI8_V /* 12690 */, RISCV_INS_VLUXEI8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vluxseg2ei16.v $vd, $rs1, $vs2$vm */ + RISCV_VLUXSEG2EI16_V /* 12691 */, RISCV_INS_VLUXSEG2EI16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vluxseg2ei32.v $vd, $rs1, $vs2$vm */ + RISCV_VLUXSEG2EI32_V /* 12692 */, RISCV_INS_VLUXSEG2EI32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vluxseg2ei64.v $vd, $rs1, $vs2$vm */ + RISCV_VLUXSEG2EI64_V /* 12693 */, RISCV_INS_VLUXSEG2EI64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vluxseg2ei8.v $vd, $rs1, $vs2$vm */ + RISCV_VLUXSEG2EI8_V /* 12694 */, RISCV_INS_VLUXSEG2EI8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vluxseg3ei16.v $vd, $rs1, $vs2$vm */ + RISCV_VLUXSEG3EI16_V /* 12695 */, RISCV_INS_VLUXSEG3EI16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vluxseg3ei32.v $vd, $rs1, $vs2$vm */ + RISCV_VLUXSEG3EI32_V /* 12696 */, RISCV_INS_VLUXSEG3EI32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vluxseg3ei64.v $vd, $rs1, $vs2$vm */ + RISCV_VLUXSEG3EI64_V /* 12697 */, RISCV_INS_VLUXSEG3EI64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vluxseg3ei8.v $vd, $rs1, $vs2$vm */ + RISCV_VLUXSEG3EI8_V /* 12698 */, RISCV_INS_VLUXSEG3EI8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vluxseg4ei16.v $vd, $rs1, $vs2$vm */ + RISCV_VLUXSEG4EI16_V /* 12699 */, RISCV_INS_VLUXSEG4EI16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vluxseg4ei32.v $vd, $rs1, $vs2$vm */ + RISCV_VLUXSEG4EI32_V /* 12700 */, RISCV_INS_VLUXSEG4EI32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vluxseg4ei64.v $vd, $rs1, $vs2$vm */ + RISCV_VLUXSEG4EI64_V /* 12701 */, RISCV_INS_VLUXSEG4EI64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vluxseg4ei8.v $vd, $rs1, $vs2$vm */ + RISCV_VLUXSEG4EI8_V /* 12702 */, RISCV_INS_VLUXSEG4EI8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vluxseg5ei16.v $vd, $rs1, $vs2$vm */ + RISCV_VLUXSEG5EI16_V /* 12703 */, RISCV_INS_VLUXSEG5EI16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vluxseg5ei32.v $vd, $rs1, $vs2$vm */ + RISCV_VLUXSEG5EI32_V /* 12704 */, RISCV_INS_VLUXSEG5EI32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vluxseg5ei64.v $vd, $rs1, $vs2$vm */ + RISCV_VLUXSEG5EI64_V /* 12705 */, RISCV_INS_VLUXSEG5EI64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vluxseg5ei8.v $vd, $rs1, $vs2$vm */ + RISCV_VLUXSEG5EI8_V /* 12706 */, RISCV_INS_VLUXSEG5EI8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vluxseg6ei16.v $vd, $rs1, $vs2$vm */ + RISCV_VLUXSEG6EI16_V /* 12707 */, RISCV_INS_VLUXSEG6EI16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vluxseg6ei32.v $vd, $rs1, $vs2$vm */ + RISCV_VLUXSEG6EI32_V /* 12708 */, RISCV_INS_VLUXSEG6EI32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vluxseg6ei64.v $vd, $rs1, $vs2$vm */ + RISCV_VLUXSEG6EI64_V /* 12709 */, RISCV_INS_VLUXSEG6EI64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vluxseg6ei8.v $vd, $rs1, $vs2$vm */ + RISCV_VLUXSEG6EI8_V /* 12710 */, RISCV_INS_VLUXSEG6EI8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vluxseg7ei16.v $vd, $rs1, $vs2$vm */ + RISCV_VLUXSEG7EI16_V /* 12711 */, RISCV_INS_VLUXSEG7EI16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vluxseg7ei32.v $vd, $rs1, $vs2$vm */ + RISCV_VLUXSEG7EI32_V /* 12712 */, RISCV_INS_VLUXSEG7EI32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vluxseg7ei64.v $vd, $rs1, $vs2$vm */ + RISCV_VLUXSEG7EI64_V /* 12713 */, RISCV_INS_VLUXSEG7EI64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vluxseg7ei8.v $vd, $rs1, $vs2$vm */ + RISCV_VLUXSEG7EI8_V /* 12714 */, RISCV_INS_VLUXSEG7EI8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vluxseg8ei16.v $vd, $rs1, $vs2$vm */ + RISCV_VLUXSEG8EI16_V /* 12715 */, RISCV_INS_VLUXSEG8EI16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vluxseg8ei32.v $vd, $rs1, $vs2$vm */ + RISCV_VLUXSEG8EI32_V /* 12716 */, RISCV_INS_VLUXSEG8EI32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vluxseg8ei64.v $vd, $rs1, $vs2$vm */ + RISCV_VLUXSEG8EI64_V /* 12717 */, RISCV_INS_VLUXSEG8EI64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vluxseg8ei8.v $vd, $rs1, $vs2$vm */ + RISCV_VLUXSEG8EI8_V /* 12718 */, RISCV_INS_VLUXSEG8EI8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmacc.vv $vd, $vs1, $vs2$vm */ + RISCV_VMACC_VV /* 12719 */, RISCV_INS_VMACC_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmacc.vx $vd, $rs1, $vs2$vm */ + RISCV_VMACC_VX /* 12720 */, RISCV_INS_VMACC_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmadc.vi $vd, $vs2, $imm */ + RISCV_VMADC_VI /* 12721 */, RISCV_INS_VMADC_VI, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmadc.vim $vd, $vs2, $imm, v0 */ + RISCV_VMADC_VIM /* 12722 */, RISCV_INS_VMADC_VIM, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmadc.vv $vd, $vs2, $vs1 */ + RISCV_VMADC_VV /* 12723 */, RISCV_INS_VMADC_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmadc.vvm $vd, $vs2, $vs1, v0 */ + RISCV_VMADC_VVM /* 12724 */, RISCV_INS_VMADC_VVM, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmadc.vx $vd, $vs2, $rs1 */ + RISCV_VMADC_VX /* 12725 */, RISCV_INS_VMADC_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmadc.vxm $vd, $vs2, $rs1, v0 */ + RISCV_VMADC_VXM /* 12726 */, RISCV_INS_VMADC_VXM, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmadd.vv $vd, $vs1, $vs2$vm */ + RISCV_VMADD_VV /* 12727 */, RISCV_INS_VMADD_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmadd.vx $vd, $rs1, $vs2$vm */ + RISCV_VMADD_VX /* 12728 */, RISCV_INS_VMADD_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmandn.mm $vd, $vs2, $vs1 */ + RISCV_VMANDN_MM /* 12729 */, RISCV_INS_VMANDN_MM, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmand.mm $vd, $vs2, $vs1 */ + RISCV_VMAND_MM /* 12730 */, RISCV_INS_VMAND_MM, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmaxu.vv $vd, $vs2, $vs1$vm */ + RISCV_VMAXU_VV /* 12731 */, RISCV_INS_VMAXU_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmaxu.vx $vd, $vs2, $rs1$vm */ + RISCV_VMAXU_VX /* 12732 */, RISCV_INS_VMAXU_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmax.vv $vd, $vs2, $vs1$vm */ + RISCV_VMAX_VV /* 12733 */, RISCV_INS_VMAX_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmax.vx $vd, $vs2, $rs1$vm */ + RISCV_VMAX_VX /* 12734 */, RISCV_INS_VMAX_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmerge.vim $vd, $vs2, $imm, v0 */ + RISCV_VMERGE_VIM /* 12735 */, RISCV_INS_VMERGE_VIM, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmerge.vvm $vd, $vs2, $vs1, v0 */ + RISCV_VMERGE_VVM /* 12736 */, RISCV_INS_VMERGE_VVM, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmerge.vxm $vd, $vs2, $rs1, v0 */ + RISCV_VMERGE_VXM /* 12737 */, RISCV_INS_VMERGE_VXM, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmfeq.vf $vd, $vs2, $rs1$vm */ + RISCV_VMFEQ_VF /* 12738 */, RISCV_INS_VMFEQ_VF, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmfeq.vv $vd, $vs2, $vs1$vm */ + RISCV_VMFEQ_VV /* 12739 */, RISCV_INS_VMFEQ_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmfge.vf $vd, $vs2, $rs1$vm */ + RISCV_VMFGE_VF /* 12740 */, RISCV_INS_VMFGE_VF, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmfgt.vf $vd, $vs2, $rs1$vm */ + RISCV_VMFGT_VF /* 12741 */, RISCV_INS_VMFGT_VF, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmfle.vf $vd, $vs2, $rs1$vm */ + RISCV_VMFLE_VF /* 12742 */, RISCV_INS_VMFLE_VF, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmfle.vv $vd, $vs2, $vs1$vm */ + RISCV_VMFLE_VV /* 12743 */, RISCV_INS_VMFLE_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmflt.vf $vd, $vs2, $rs1$vm */ + RISCV_VMFLT_VF /* 12744 */, RISCV_INS_VMFLT_VF, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmflt.vv $vd, $vs2, $vs1$vm */ + RISCV_VMFLT_VV /* 12745 */, RISCV_INS_VMFLT_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmfne.vf $vd, $vs2, $rs1$vm */ + RISCV_VMFNE_VF /* 12746 */, RISCV_INS_VMFNE_VF, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmfne.vv $vd, $vs2, $vs1$vm */ + RISCV_VMFNE_VV /* 12747 */, RISCV_INS_VMFNE_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSANYF, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vminu.vv $vd, $vs2, $vs1$vm */ + RISCV_VMINU_VV /* 12748 */, RISCV_INS_VMINU_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vminu.vx $vd, $vs2, $rs1$vm */ + RISCV_VMINU_VX /* 12749 */, RISCV_INS_VMINU_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmin.vv $vd, $vs2, $vs1$vm */ + RISCV_VMIN_VV /* 12750 */, RISCV_INS_VMIN_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmin.vx $vd, $vs2, $rs1$vm */ + RISCV_VMIN_VX /* 12751 */, RISCV_INS_VMIN_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmnand.mm $vd, $vs2, $vs1 */ + RISCV_VMNAND_MM /* 12752 */, RISCV_INS_VMNAND_MM, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmnor.mm $vd, $vs2, $vs1 */ + RISCV_VMNOR_MM /* 12753 */, RISCV_INS_VMNOR_MM, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmorn.mm $vd, $vs2, $vs1 */ + RISCV_VMORN_MM /* 12754 */, RISCV_INS_VMORN_MM, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmor.mm $vd, $vs2, $vs1 */ + RISCV_VMOR_MM /* 12755 */, RISCV_INS_VMOR_MM, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmsbc.vv $vd, $vs2, $vs1 */ + RISCV_VMSBC_VV /* 12756 */, RISCV_INS_VMSBC_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmsbc.vvm $vd, $vs2, $vs1, v0 */ + RISCV_VMSBC_VVM /* 12757 */, RISCV_INS_VMSBC_VVM, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmsbc.vx $vd, $vs2, $rs1 */ + RISCV_VMSBC_VX /* 12758 */, RISCV_INS_VMSBC_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmsbc.vxm $vd, $vs2, $rs1, v0 */ + RISCV_VMSBC_VXM /* 12759 */, RISCV_INS_VMSBC_VXM, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmsbf.m $vd, $vs2$vm */ + RISCV_VMSBF_M /* 12760 */, RISCV_INS_VMSBF_M, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmseq.vi $vd, $vs2, $imm$vm */ + RISCV_VMSEQ_VI /* 12761 */, RISCV_INS_VMSEQ_VI, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmseq.vv $vd, $vs2, $vs1$vm */ + RISCV_VMSEQ_VV /* 12762 */, RISCV_INS_VMSEQ_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmseq.vx $vd, $vs2, $rs1$vm */ + RISCV_VMSEQ_VX /* 12763 */, RISCV_INS_VMSEQ_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmsgtu.vi $vd, $vs2, $imm$vm */ + RISCV_VMSGTU_VI /* 12764 */, RISCV_INS_VMSGTU_VI, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmsgtu.vx $vd, $vs2, $rs1$vm */ + RISCV_VMSGTU_VX /* 12765 */, RISCV_INS_VMSGTU_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmsgt.vi $vd, $vs2, $imm$vm */ + RISCV_VMSGT_VI /* 12766 */, RISCV_INS_VMSGT_VI, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmsgt.vx $vd, $vs2, $rs1$vm */ + RISCV_VMSGT_VX /* 12767 */, RISCV_INS_VMSGT_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmsif.m $vd, $vs2$vm */ + RISCV_VMSIF_M /* 12768 */, RISCV_INS_VMSIF_M, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmsleu.vi $vd, $vs2, $imm$vm */ + RISCV_VMSLEU_VI /* 12769 */, RISCV_INS_VMSLEU_VI, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmsleu.vv $vd, $vs2, $vs1$vm */ + RISCV_VMSLEU_VV /* 12770 */, RISCV_INS_VMSLEU_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmsleu.vx $vd, $vs2, $rs1$vm */ + RISCV_VMSLEU_VX /* 12771 */, RISCV_INS_VMSLEU_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmsle.vi $vd, $vs2, $imm$vm */ + RISCV_VMSLE_VI /* 12772 */, RISCV_INS_VMSLE_VI, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmsle.vv $vd, $vs2, $vs1$vm */ + RISCV_VMSLE_VV /* 12773 */, RISCV_INS_VMSLE_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmsle.vx $vd, $vs2, $rs1$vm */ + RISCV_VMSLE_VX /* 12774 */, RISCV_INS_VMSLE_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmsltu.vv $vd, $vs2, $vs1$vm */ + RISCV_VMSLTU_VV /* 12775 */, RISCV_INS_VMSLTU_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmsltu.vx $vd, $vs2, $rs1$vm */ + RISCV_VMSLTU_VX /* 12776 */, RISCV_INS_VMSLTU_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmslt.vv $vd, $vs2, $vs1$vm */ + RISCV_VMSLT_VV /* 12777 */, RISCV_INS_VMSLT_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmslt.vx $vd, $vs2, $rs1$vm */ + RISCV_VMSLT_VX /* 12778 */, RISCV_INS_VMSLT_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmsne.vi $vd, $vs2, $imm$vm */ + RISCV_VMSNE_VI /* 12779 */, RISCV_INS_VMSNE_VI, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmsne.vv $vd, $vs2, $vs1$vm */ + RISCV_VMSNE_VV /* 12780 */, RISCV_INS_VMSNE_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmsne.vx $vd, $vs2, $rs1$vm */ + RISCV_VMSNE_VX /* 12781 */, RISCV_INS_VMSNE_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmsof.m $vd, $vs2$vm */ + RISCV_VMSOF_M /* 12782 */, RISCV_INS_VMSOF_M, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmulhsu.vv $vd, $vs2, $vs1$vm */ + RISCV_VMULHSU_VV /* 12783 */, RISCV_INS_VMULHSU_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmulhsu.vx $vd, $vs2, $rs1$vm */ + RISCV_VMULHSU_VX /* 12784 */, RISCV_INS_VMULHSU_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmulhu.vv $vd, $vs2, $vs1$vm */ + RISCV_VMULHU_VV /* 12785 */, RISCV_INS_VMULHU_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmulhu.vx $vd, $vs2, $rs1$vm */ + RISCV_VMULHU_VX /* 12786 */, RISCV_INS_VMULHU_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmulh.vv $vd, $vs2, $vs1$vm */ + RISCV_VMULH_VV /* 12787 */, RISCV_INS_VMULH_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmulh.vx $vd, $vs2, $rs1$vm */ + RISCV_VMULH_VX /* 12788 */, RISCV_INS_VMULH_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmul.vv $vd, $vs2, $vs1$vm */ + RISCV_VMUL_VV /* 12789 */, RISCV_INS_VMUL_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmul.vx $vd, $vs2, $rs1$vm */ + RISCV_VMUL_VX /* 12790 */, RISCV_INS_VMUL_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmv1r.v $vd, $vs2 */ + RISCV_VMV1R_V /* 12791 */, RISCV_INS_VMV1R_V, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmv2r.v $vd, $vs2 */ + RISCV_VMV2R_V /* 12792 */, RISCV_INS_VMV2R_V, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmv4r.v $vd, $vs2 */ + RISCV_VMV4R_V /* 12793 */, RISCV_INS_VMV4R_V, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmv8r.v $vd, $vs2 */ + RISCV_VMV8R_V /* 12794 */, RISCV_INS_VMV8R_V, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmv.s.x $vd, $rs1 */ + RISCV_VMV_S_X /* 12795 */, RISCV_INS_VMV_S_X, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmv.v.i $vd, $imm */ + RISCV_VMV_V_I /* 12796 */, RISCV_INS_VMV_V_I, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmv.v.v $vd, $vs1 */ + RISCV_VMV_V_V /* 12797 */, RISCV_INS_VMV_V_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmv.v.x $vd, $rs1 */ + RISCV_VMV_V_X /* 12798 */, RISCV_INS_VMV_V_X, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmv.x.s $vd, $vs2 */ + RISCV_VMV_X_S /* 12799 */, RISCV_INS_VMV_X_S, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmxnor.mm $vd, $vs2, $vs1 */ + RISCV_VMXNOR_MM /* 12800 */, RISCV_INS_VMXNOR_MM, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vmxor.mm $vd, $vs2, $vs1 */ + RISCV_VMXOR_MM /* 12801 */, RISCV_INS_VMXOR_MM, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vnclipu.wi $vd, $vs2, $imm$vm */ + RISCV_VNCLIPU_WI /* 12802 */, RISCV_INS_VNCLIPU_WI, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vnclipu.wv $vd, $vs2, $vs1$vm */ + RISCV_VNCLIPU_WV /* 12803 */, RISCV_INS_VNCLIPU_WV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vnclipu.wx $vd, $vs2, $rs1$vm */ + RISCV_VNCLIPU_WX /* 12804 */, RISCV_INS_VNCLIPU_WX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vnclip.wi $vd, $vs2, $imm$vm */ + RISCV_VNCLIP_WI /* 12805 */, RISCV_INS_VNCLIP_WI, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vnclip.wv $vd, $vs2, $vs1$vm */ + RISCV_VNCLIP_WV /* 12806 */, RISCV_INS_VNCLIP_WV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vnclip.wx $vd, $vs2, $rs1$vm */ + RISCV_VNCLIP_WX /* 12807 */, RISCV_INS_VNCLIP_WX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vnmsac.vv $vd, $vs1, $vs2$vm */ + RISCV_VNMSAC_VV /* 12808 */, RISCV_INS_VNMSAC_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vnmsac.vx $vd, $rs1, $vs2$vm */ + RISCV_VNMSAC_VX /* 12809 */, RISCV_INS_VNMSAC_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vnmsub.vv $vd, $vs1, $vs2$vm */ + RISCV_VNMSUB_VV /* 12810 */, RISCV_INS_VNMSUB_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vnmsub.vx $vd, $rs1, $vs2$vm */ + RISCV_VNMSUB_VX /* 12811 */, RISCV_INS_VNMSUB_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vnsra.wi $vd, $vs2, $imm$vm */ + RISCV_VNSRA_WI /* 12812 */, RISCV_INS_VNSRA_WI, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vnsra.wv $vd, $vs2, $vs1$vm */ + RISCV_VNSRA_WV /* 12813 */, RISCV_INS_VNSRA_WV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vnsra.wx $vd, $vs2, $rs1$vm */ + RISCV_VNSRA_WX /* 12814 */, RISCV_INS_VNSRA_WX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vnsrl.wi $vd, $vs2, $imm$vm */ + RISCV_VNSRL_WI /* 12815 */, RISCV_INS_VNSRL_WI, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vnsrl.wv $vd, $vs2, $vs1$vm */ + RISCV_VNSRL_WV /* 12816 */, RISCV_INS_VNSRL_WV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vnsrl.wx $vd, $vs2, $rs1$vm */ + RISCV_VNSRL_WX /* 12817 */, RISCV_INS_VNSRL_WX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vor.vi $vd, $vs2, $imm$vm */ + RISCV_VOR_VI /* 12818 */, RISCV_INS_VOR_VI, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vor.vv $vd, $vs2, $vs1$vm */ + RISCV_VOR_VV /* 12819 */, RISCV_INS_VOR_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vor.vx $vd, $vs2, $rs1$vm */ + RISCV_VOR_VX /* 12820 */, RISCV_INS_VOR_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sf.vqmaccsu.2x8x2 $rd, $rs1, $rs2 */ + RISCV_VQMACCSU_2x8x2 /* 12821 */, RISCV_INS_SF_VQMACCSU_2X8X2, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXSFVQMACCDOD, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sf.vqmaccsu.4x8x4 $rd, $rs1, $rs2 */ + RISCV_VQMACCSU_4x8x4 /* 12822 */, RISCV_INS_SF_VQMACCSU_4X8X4, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXSFVQMACCQOQ, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sf.vqmaccus.2x8x2 $rd, $rs1, $rs2 */ + RISCV_VQMACCUS_2x8x2 /* 12823 */, RISCV_INS_SF_VQMACCUS_2X8X2, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXSFVQMACCDOD, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sf.vqmaccus.4x8x4 $rd, $rs1, $rs2 */ + RISCV_VQMACCUS_4x8x4 /* 12824 */, RISCV_INS_SF_VQMACCUS_4X8X4, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXSFVQMACCQOQ, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sf.vqmaccu.2x8x2 $rd, $rs1, $rs2 */ + RISCV_VQMACCU_2x8x2 /* 12825 */, RISCV_INS_SF_VQMACCU_2X8X2, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXSFVQMACCDOD, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sf.vqmaccu.4x8x4 $rd, $rs1, $rs2 */ + RISCV_VQMACCU_4x8x4 /* 12826 */, RISCV_INS_SF_VQMACCU_4X8X4, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXSFVQMACCQOQ, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sf.vqmacc.2x8x2 $rd, $rs1, $rs2 */ + RISCV_VQMACC_2x8x2 /* 12827 */, RISCV_INS_SF_VQMACC_2X8X2, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXSFVQMACCDOD, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* sf.vqmacc.4x8x4 $rd, $rs1, $rs2 */ + RISCV_VQMACC_4x8x4 /* 12828 */, RISCV_INS_SF_VQMACC_4X8X4, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVENDORXSFVQMACCQOQ, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vredand.vs $vd, $vs2, $vs1$vm */ + RISCV_VREDAND_VS /* 12829 */, RISCV_INS_VREDAND_VS, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vredmaxu.vs $vd, $vs2, $vs1$vm */ + RISCV_VREDMAXU_VS /* 12830 */, RISCV_INS_VREDMAXU_VS, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vredmax.vs $vd, $vs2, $vs1$vm */ + RISCV_VREDMAX_VS /* 12831 */, RISCV_INS_VREDMAX_VS, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vredminu.vs $vd, $vs2, $vs1$vm */ + RISCV_VREDMINU_VS /* 12832 */, RISCV_INS_VREDMINU_VS, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vredmin.vs $vd, $vs2, $vs1$vm */ + RISCV_VREDMIN_VS /* 12833 */, RISCV_INS_VREDMIN_VS, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vredor.vs $vd, $vs2, $vs1$vm */ + RISCV_VREDOR_VS /* 12834 */, RISCV_INS_VREDOR_VS, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vredsum.vs $vd, $vs2, $vs1$vm */ + RISCV_VREDSUM_VS /* 12835 */, RISCV_INS_VREDSUM_VS, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vredxor.vs $vd, $vs2, $vs1$vm */ + RISCV_VREDXOR_VS /* 12836 */, RISCV_INS_VREDXOR_VS, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vremu.vv $vd, $vs2, $vs1$vm */ + RISCV_VREMU_VV /* 12837 */, RISCV_INS_VREMU_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vremu.vx $vd, $vs2, $rs1$vm */ + RISCV_VREMU_VX /* 12838 */, RISCV_INS_VREMU_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vrem.vv $vd, $vs2, $vs1$vm */ + RISCV_VREM_VV /* 12839 */, RISCV_INS_VREM_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vrem.vx $vd, $vs2, $rs1$vm */ + RISCV_VREM_VX /* 12840 */, RISCV_INS_VREM_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vrev8.v $vd, $vs2$vm */ + RISCV_VREV8_V /* 12841 */, RISCV_INS_VREV8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZVKB, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vrgatherei16.vv $vd, $vs2, $vs1$vm */ + RISCV_VRGATHEREI16_VV /* 12842 */, RISCV_INS_VRGATHEREI16_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vrgather.vi $vd, $vs2, $imm$vm */ + RISCV_VRGATHER_VI /* 12843 */, RISCV_INS_VRGATHER_VI, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vrgather.vv $vd, $vs2, $vs1$vm */ + RISCV_VRGATHER_VV /* 12844 */, RISCV_INS_VRGATHER_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vrgather.vx $vd, $vs2, $rs1$vm */ + RISCV_VRGATHER_VX /* 12845 */, RISCV_INS_VRGATHER_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vrol.vv $vd, $vs2, $vs1$vm */ + RISCV_VROL_VV /* 12846 */, RISCV_INS_VROL_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZVKB, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vrol.vx $vd, $vs2, $rs1$vm */ + RISCV_VROL_VX /* 12847 */, RISCV_INS_VROL_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZVKB, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vror.vi $vd, $vs2, $imm$vm */ + RISCV_VROR_VI /* 12848 */, RISCV_INS_VROR_VI, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZVKB, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vror.vv $vd, $vs2, $vs1$vm */ + RISCV_VROR_VV /* 12849 */, RISCV_INS_VROR_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZVKB, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vror.vx $vd, $vs2, $rs1$vm */ + RISCV_VROR_VX /* 12850 */, RISCV_INS_VROR_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZVKB, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vrsub.vi $vd, $vs2, $imm$vm */ + RISCV_VRSUB_VI /* 12851 */, RISCV_INS_VRSUB_VI, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vrsub.vx $vd, $vs2, $rs1$vm */ + RISCV_VRSUB_VX /* 12852 */, RISCV_INS_VRSUB_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vs1r.v $vs3, $rs1 */ + RISCV_VS1R_V /* 12853 */, RISCV_INS_VS1R_V, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vs2r.v $vs3, $rs1 */ + RISCV_VS2R_V /* 12854 */, RISCV_INS_VS2R_V, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vs4r.v $vs3, $rs1 */ + RISCV_VS4R_V /* 12855 */, RISCV_INS_VS4R_V, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vs8r.v $vs3, $rs1 */ + RISCV_VS8R_V /* 12856 */, RISCV_INS_VS8R_V, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsaddu.vi $vd, $vs2, $imm$vm */ + RISCV_VSADDU_VI /* 12857 */, RISCV_INS_VSADDU_VI, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsaddu.vv $vd, $vs2, $vs1$vm */ + RISCV_VSADDU_VV /* 12858 */, RISCV_INS_VSADDU_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsaddu.vx $vd, $vs2, $rs1$vm */ + RISCV_VSADDU_VX /* 12859 */, RISCV_INS_VSADDU_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsadd.vi $vd, $vs2, $imm$vm */ + RISCV_VSADD_VI /* 12860 */, RISCV_INS_VSADD_VI, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsadd.vv $vd, $vs2, $vs1$vm */ + RISCV_VSADD_VV /* 12861 */, RISCV_INS_VSADD_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsadd.vx $vd, $vs2, $rs1$vm */ + RISCV_VSADD_VX /* 12862 */, RISCV_INS_VSADD_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsbc.vvm $vd, $vs2, $vs1, v0 */ + RISCV_VSBC_VVM /* 12863 */, RISCV_INS_VSBC_VVM, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsbc.vxm $vd, $vs2, $rs1, v0 */ + RISCV_VSBC_VXM /* 12864 */, RISCV_INS_VSBC_VXM, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vse16.v $vs3, ${rs1}$vm */ + RISCV_VSE16_V /* 12865 */, RISCV_INS_VSE16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vse32.v $vs3, ${rs1}$vm */ + RISCV_VSE32_V /* 12866 */, RISCV_INS_VSE32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vse64.v $vs3, ${rs1}$vm */ + RISCV_VSE64_V /* 12867 */, RISCV_INS_VSE64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vse8.v $vs3, ${rs1}$vm */ + RISCV_VSE8_V /* 12868 */, RISCV_INS_VSE8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsetivli $rd, $uimm, $vtypei */ + RISCV_VSETIVLI /* 12869 */, RISCV_INS_VSETIVLI, + #ifndef CAPSTONE_DIET + { 0 }, { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsetvl $rd, $rs1, $rs2 */ + RISCV_VSETVL /* 12870 */, RISCV_INS_VSETVL, + #ifndef CAPSTONE_DIET + { 0 }, { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsetvli $rd, $rs1, $vtypei */ + RISCV_VSETVLI /* 12871 */, RISCV_INS_VSETVLI, + #ifndef CAPSTONE_DIET + { 0 }, { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsext.vf2 $vd, $vs2$vm */ + RISCV_VSEXT_VF2 /* 12872 */, RISCV_INS_VSEXT_VF2, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsext.vf4 $vd, $vs2$vm */ + RISCV_VSEXT_VF4 /* 12873 */, RISCV_INS_VSEXT_VF4, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsext.vf8 $vd, $vs2$vm */ + RISCV_VSEXT_VF8 /* 12874 */, RISCV_INS_VSEXT_VF8, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsha2ch.vv $vd, $vs2, $vs1 */ + RISCV_VSHA2CH_VV /* 12875 */, RISCV_INS_VSHA2CH_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZVKNHAORZVKNHB, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsha2cl.vv $vd, $vs2, $vs1 */ + RISCV_VSHA2CL_VV /* 12876 */, RISCV_INS_VSHA2CL_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZVKNHAORZVKNHB, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsha2ms.vv $vd, $vs2, $vs1 */ + RISCV_VSHA2MS_VV /* 12877 */, RISCV_INS_VSHA2MS_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZVKNHAORZVKNHB, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vslide1down.vx $vd, $vs2, $rs1$vm */ + RISCV_VSLIDE1DOWN_VX /* 12878 */, RISCV_INS_VSLIDE1DOWN_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vslide1up.vx $vd, $vs2, $rs1$vm */ + RISCV_VSLIDE1UP_VX /* 12879 */, RISCV_INS_VSLIDE1UP_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vslidedown.vi $vd, $vs2, $imm$vm */ + RISCV_VSLIDEDOWN_VI /* 12880 */, RISCV_INS_VSLIDEDOWN_VI, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vslidedown.vx $vd, $vs2, $rs1$vm */ + RISCV_VSLIDEDOWN_VX /* 12881 */, RISCV_INS_VSLIDEDOWN_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vslideup.vi $vd, $vs2, $imm$vm */ + RISCV_VSLIDEUP_VI /* 12882 */, RISCV_INS_VSLIDEUP_VI, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vslideup.vx $vd, $vs2, $rs1$vm */ + RISCV_VSLIDEUP_VX /* 12883 */, RISCV_INS_VSLIDEUP_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsll.vi $vd, $vs2, $imm$vm */ + RISCV_VSLL_VI /* 12884 */, RISCV_INS_VSLL_VI, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsll.vv $vd, $vs2, $vs1$vm */ + RISCV_VSLL_VV /* 12885 */, RISCV_INS_VSLL_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsll.vx $vd, $vs2, $rs1$vm */ + RISCV_VSLL_VX /* 12886 */, RISCV_INS_VSLL_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsm3c.vi $vd, $vs2, $imm */ + RISCV_VSM3C_VI /* 12887 */, RISCV_INS_VSM3C_VI, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZVKSH, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsm3me.vv $vd, $vs2, $vs1 */ + RISCV_VSM3ME_VV /* 12888 */, RISCV_INS_VSM3ME_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZVKSH, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsm4k.vi $vd, $vs2, $imm */ + RISCV_VSM4K_VI /* 12889 */, RISCV_INS_VSM4K_VI, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZVKSED, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsm4r.vs $vd, $vs2 */ + RISCV_VSM4R_VS /* 12890 */, RISCV_INS_VSM4R_VS, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZVKSED, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsm4r.vv $vd, $vs2 */ + RISCV_VSM4R_VV /* 12891 */, RISCV_INS_VSM4R_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZVKSED, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsmul.vv $vd, $vs2, $vs1$vm */ + RISCV_VSMUL_VV /* 12892 */, RISCV_INS_VSMUL_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsmul.vx $vd, $vs2, $rs1$vm */ + RISCV_VSMUL_VX /* 12893 */, RISCV_INS_VSMUL_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsm.v $vs3, $rs1 */ + RISCV_VSM_V /* 12894 */, RISCV_INS_VSM_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsoxei16.v $vs3, $rs1, $vs2$vm */ + RISCV_VSOXEI16_V /* 12895 */, RISCV_INS_VSOXEI16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsoxei32.v $vs3, $rs1, $vs2$vm */ + RISCV_VSOXEI32_V /* 12896 */, RISCV_INS_VSOXEI32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsoxei64.v $vs3, $rs1, $vs2$vm */ + RISCV_VSOXEI64_V /* 12897 */, RISCV_INS_VSOXEI64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_ISRV64, RISCV_FEATURE_HASVINSTRUCTIONSI64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsoxei8.v $vs3, $rs1, $vs2$vm */ + RISCV_VSOXEI8_V /* 12898 */, RISCV_INS_VSOXEI8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsoxseg2ei16.v $vs3, $rs1, $vs2$vm */ + RISCV_VSOXSEG2EI16_V /* 12899 */, RISCV_INS_VSOXSEG2EI16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsoxseg2ei32.v $vs3, $rs1, $vs2$vm */ + RISCV_VSOXSEG2EI32_V /* 12900 */, RISCV_INS_VSOXSEG2EI32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsoxseg2ei64.v $vs3, $rs1, $vs2$vm */ + RISCV_VSOXSEG2EI64_V /* 12901 */, RISCV_INS_VSOXSEG2EI64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsoxseg2ei8.v $vs3, $rs1, $vs2$vm */ + RISCV_VSOXSEG2EI8_V /* 12902 */, RISCV_INS_VSOXSEG2EI8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsoxseg3ei16.v $vs3, $rs1, $vs2$vm */ + RISCV_VSOXSEG3EI16_V /* 12903 */, RISCV_INS_VSOXSEG3EI16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsoxseg3ei32.v $vs3, $rs1, $vs2$vm */ + RISCV_VSOXSEG3EI32_V /* 12904 */, RISCV_INS_VSOXSEG3EI32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsoxseg3ei64.v $vs3, $rs1, $vs2$vm */ + RISCV_VSOXSEG3EI64_V /* 12905 */, RISCV_INS_VSOXSEG3EI64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsoxseg3ei8.v $vs3, $rs1, $vs2$vm */ + RISCV_VSOXSEG3EI8_V /* 12906 */, RISCV_INS_VSOXSEG3EI8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsoxseg4ei16.v $vs3, $rs1, $vs2$vm */ + RISCV_VSOXSEG4EI16_V /* 12907 */, RISCV_INS_VSOXSEG4EI16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsoxseg4ei32.v $vs3, $rs1, $vs2$vm */ + RISCV_VSOXSEG4EI32_V /* 12908 */, RISCV_INS_VSOXSEG4EI32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsoxseg4ei64.v $vs3, $rs1, $vs2$vm */ + RISCV_VSOXSEG4EI64_V /* 12909 */, RISCV_INS_VSOXSEG4EI64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsoxseg4ei8.v $vs3, $rs1, $vs2$vm */ + RISCV_VSOXSEG4EI8_V /* 12910 */, RISCV_INS_VSOXSEG4EI8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsoxseg5ei16.v $vs3, $rs1, $vs2$vm */ + RISCV_VSOXSEG5EI16_V /* 12911 */, RISCV_INS_VSOXSEG5EI16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsoxseg5ei32.v $vs3, $rs1, $vs2$vm */ + RISCV_VSOXSEG5EI32_V /* 12912 */, RISCV_INS_VSOXSEG5EI32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsoxseg5ei64.v $vs3, $rs1, $vs2$vm */ + RISCV_VSOXSEG5EI64_V /* 12913 */, RISCV_INS_VSOXSEG5EI64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsoxseg5ei8.v $vs3, $rs1, $vs2$vm */ + RISCV_VSOXSEG5EI8_V /* 12914 */, RISCV_INS_VSOXSEG5EI8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsoxseg6ei16.v $vs3, $rs1, $vs2$vm */ + RISCV_VSOXSEG6EI16_V /* 12915 */, RISCV_INS_VSOXSEG6EI16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsoxseg6ei32.v $vs3, $rs1, $vs2$vm */ + RISCV_VSOXSEG6EI32_V /* 12916 */, RISCV_INS_VSOXSEG6EI32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsoxseg6ei64.v $vs3, $rs1, $vs2$vm */ + RISCV_VSOXSEG6EI64_V /* 12917 */, RISCV_INS_VSOXSEG6EI64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsoxseg6ei8.v $vs3, $rs1, $vs2$vm */ + RISCV_VSOXSEG6EI8_V /* 12918 */, RISCV_INS_VSOXSEG6EI8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsoxseg7ei16.v $vs3, $rs1, $vs2$vm */ + RISCV_VSOXSEG7EI16_V /* 12919 */, RISCV_INS_VSOXSEG7EI16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsoxseg7ei32.v $vs3, $rs1, $vs2$vm */ + RISCV_VSOXSEG7EI32_V /* 12920 */, RISCV_INS_VSOXSEG7EI32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsoxseg7ei64.v $vs3, $rs1, $vs2$vm */ + RISCV_VSOXSEG7EI64_V /* 12921 */, RISCV_INS_VSOXSEG7EI64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsoxseg7ei8.v $vs3, $rs1, $vs2$vm */ + RISCV_VSOXSEG7EI8_V /* 12922 */, RISCV_INS_VSOXSEG7EI8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsoxseg8ei16.v $vs3, $rs1, $vs2$vm */ + RISCV_VSOXSEG8EI16_V /* 12923 */, RISCV_INS_VSOXSEG8EI16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsoxseg8ei32.v $vs3, $rs1, $vs2$vm */ + RISCV_VSOXSEG8EI32_V /* 12924 */, RISCV_INS_VSOXSEG8EI32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsoxseg8ei64.v $vs3, $rs1, $vs2$vm */ + RISCV_VSOXSEG8EI64_V /* 12925 */, RISCV_INS_VSOXSEG8EI64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsoxseg8ei8.v $vs3, $rs1, $vs2$vm */ + RISCV_VSOXSEG8EI8_V /* 12926 */, RISCV_INS_VSOXSEG8EI8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsra.vi $vd, $vs2, $imm$vm */ + RISCV_VSRA_VI /* 12927 */, RISCV_INS_VSRA_VI, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsra.vv $vd, $vs2, $vs1$vm */ + RISCV_VSRA_VV /* 12928 */, RISCV_INS_VSRA_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsra.vx $vd, $vs2, $rs1$vm */ + RISCV_VSRA_VX /* 12929 */, RISCV_INS_VSRA_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsrl.vi $vd, $vs2, $imm$vm */ + RISCV_VSRL_VI /* 12930 */, RISCV_INS_VSRL_VI, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsrl.vv $vd, $vs2, $vs1$vm */ + RISCV_VSRL_VV /* 12931 */, RISCV_INS_VSRL_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsrl.vx $vd, $vs2, $rs1$vm */ + RISCV_VSRL_VX /* 12932 */, RISCV_INS_VSRL_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsse16.v $vs3, $rs1, $rs2$vm */ + RISCV_VSSE16_V /* 12933 */, RISCV_INS_VSSE16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsse32.v $vs3, $rs1, $rs2$vm */ + RISCV_VSSE32_V /* 12934 */, RISCV_INS_VSSE32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsse64.v $vs3, $rs1, $rs2$vm */ + RISCV_VSSE64_V /* 12935 */, RISCV_INS_VSSE64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsse8.v $vs3, $rs1, $rs2$vm */ + RISCV_VSSE8_V /* 12936 */, RISCV_INS_VSSE8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsseg2e16.v $vs3, ${rs1}$vm */ + RISCV_VSSEG2E16_V /* 12937 */, RISCV_INS_VSSEG2E16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsseg2e32.v $vs3, ${rs1}$vm */ + RISCV_VSSEG2E32_V /* 12938 */, RISCV_INS_VSSEG2E32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsseg2e64.v $vs3, ${rs1}$vm */ + RISCV_VSSEG2E64_V /* 12939 */, RISCV_INS_VSSEG2E64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsseg2e8.v $vs3, ${rs1}$vm */ + RISCV_VSSEG2E8_V /* 12940 */, RISCV_INS_VSSEG2E8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsseg3e16.v $vs3, ${rs1}$vm */ + RISCV_VSSEG3E16_V /* 12941 */, RISCV_INS_VSSEG3E16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsseg3e32.v $vs3, ${rs1}$vm */ + RISCV_VSSEG3E32_V /* 12942 */, RISCV_INS_VSSEG3E32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsseg3e64.v $vs3, ${rs1}$vm */ + RISCV_VSSEG3E64_V /* 12943 */, RISCV_INS_VSSEG3E64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsseg3e8.v $vs3, ${rs1}$vm */ + RISCV_VSSEG3E8_V /* 12944 */, RISCV_INS_VSSEG3E8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsseg4e16.v $vs3, ${rs1}$vm */ + RISCV_VSSEG4E16_V /* 12945 */, RISCV_INS_VSSEG4E16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsseg4e32.v $vs3, ${rs1}$vm */ + RISCV_VSSEG4E32_V /* 12946 */, RISCV_INS_VSSEG4E32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsseg4e64.v $vs3, ${rs1}$vm */ + RISCV_VSSEG4E64_V /* 12947 */, RISCV_INS_VSSEG4E64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsseg4e8.v $vs3, ${rs1}$vm */ + RISCV_VSSEG4E8_V /* 12948 */, RISCV_INS_VSSEG4E8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsseg5e16.v $vs3, ${rs1}$vm */ + RISCV_VSSEG5E16_V /* 12949 */, RISCV_INS_VSSEG5E16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsseg5e32.v $vs3, ${rs1}$vm */ + RISCV_VSSEG5E32_V /* 12950 */, RISCV_INS_VSSEG5E32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsseg5e64.v $vs3, ${rs1}$vm */ + RISCV_VSSEG5E64_V /* 12951 */, RISCV_INS_VSSEG5E64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsseg5e8.v $vs3, ${rs1}$vm */ + RISCV_VSSEG5E8_V /* 12952 */, RISCV_INS_VSSEG5E8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsseg6e16.v $vs3, ${rs1}$vm */ + RISCV_VSSEG6E16_V /* 12953 */, RISCV_INS_VSSEG6E16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsseg6e32.v $vs3, ${rs1}$vm */ + RISCV_VSSEG6E32_V /* 12954 */, RISCV_INS_VSSEG6E32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsseg6e64.v $vs3, ${rs1}$vm */ + RISCV_VSSEG6E64_V /* 12955 */, RISCV_INS_VSSEG6E64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsseg6e8.v $vs3, ${rs1}$vm */ + RISCV_VSSEG6E8_V /* 12956 */, RISCV_INS_VSSEG6E8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsseg7e16.v $vs3, ${rs1}$vm */ + RISCV_VSSEG7E16_V /* 12957 */, RISCV_INS_VSSEG7E16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsseg7e32.v $vs3, ${rs1}$vm */ + RISCV_VSSEG7E32_V /* 12958 */, RISCV_INS_VSSEG7E32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsseg7e64.v $vs3, ${rs1}$vm */ + RISCV_VSSEG7E64_V /* 12959 */, RISCV_INS_VSSEG7E64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsseg7e8.v $vs3, ${rs1}$vm */ + RISCV_VSSEG7E8_V /* 12960 */, RISCV_INS_VSSEG7E8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsseg8e16.v $vs3, ${rs1}$vm */ + RISCV_VSSEG8E16_V /* 12961 */, RISCV_INS_VSSEG8E16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsseg8e32.v $vs3, ${rs1}$vm */ + RISCV_VSSEG8E32_V /* 12962 */, RISCV_INS_VSSEG8E32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsseg8e64.v $vs3, ${rs1}$vm */ + RISCV_VSSEG8E64_V /* 12963 */, RISCV_INS_VSSEG8E64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsseg8e8.v $vs3, ${rs1}$vm */ + RISCV_VSSEG8E8_V /* 12964 */, RISCV_INS_VSSEG8E8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vssra.vi $vd, $vs2, $imm$vm */ + RISCV_VSSRA_VI /* 12965 */, RISCV_INS_VSSRA_VI, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vssra.vv $vd, $vs2, $vs1$vm */ + RISCV_VSSRA_VV /* 12966 */, RISCV_INS_VSSRA_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vssra.vx $vd, $vs2, $rs1$vm */ + RISCV_VSSRA_VX /* 12967 */, RISCV_INS_VSSRA_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vssrl.vi $vd, $vs2, $imm$vm */ + RISCV_VSSRL_VI /* 12968 */, RISCV_INS_VSSRL_VI, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vssrl.vv $vd, $vs2, $vs1$vm */ + RISCV_VSSRL_VV /* 12969 */, RISCV_INS_VSSRL_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vssrl.vx $vd, $vs2, $rs1$vm */ + RISCV_VSSRL_VX /* 12970 */, RISCV_INS_VSSRL_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vssseg2e16.v $vs3, $rs1, $rs2$vm */ + RISCV_VSSSEG2E16_V /* 12971 */, RISCV_INS_VSSSEG2E16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vssseg2e32.v $vs3, $rs1, $rs2$vm */ + RISCV_VSSSEG2E32_V /* 12972 */, RISCV_INS_VSSSEG2E32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vssseg2e64.v $vs3, $rs1, $rs2$vm */ + RISCV_VSSSEG2E64_V /* 12973 */, RISCV_INS_VSSSEG2E64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vssseg2e8.v $vs3, $rs1, $rs2$vm */ + RISCV_VSSSEG2E8_V /* 12974 */, RISCV_INS_VSSSEG2E8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vssseg3e16.v $vs3, $rs1, $rs2$vm */ + RISCV_VSSSEG3E16_V /* 12975 */, RISCV_INS_VSSSEG3E16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vssseg3e32.v $vs3, $rs1, $rs2$vm */ + RISCV_VSSSEG3E32_V /* 12976 */, RISCV_INS_VSSSEG3E32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vssseg3e64.v $vs3, $rs1, $rs2$vm */ + RISCV_VSSSEG3E64_V /* 12977 */, RISCV_INS_VSSSEG3E64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vssseg3e8.v $vs3, $rs1, $rs2$vm */ + RISCV_VSSSEG3E8_V /* 12978 */, RISCV_INS_VSSSEG3E8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vssseg4e16.v $vs3, $rs1, $rs2$vm */ + RISCV_VSSSEG4E16_V /* 12979 */, RISCV_INS_VSSSEG4E16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vssseg4e32.v $vs3, $rs1, $rs2$vm */ + RISCV_VSSSEG4E32_V /* 12980 */, RISCV_INS_VSSSEG4E32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vssseg4e64.v $vs3, $rs1, $rs2$vm */ + RISCV_VSSSEG4E64_V /* 12981 */, RISCV_INS_VSSSEG4E64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vssseg4e8.v $vs3, $rs1, $rs2$vm */ + RISCV_VSSSEG4E8_V /* 12982 */, RISCV_INS_VSSSEG4E8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vssseg5e16.v $vs3, $rs1, $rs2$vm */ + RISCV_VSSSEG5E16_V /* 12983 */, RISCV_INS_VSSSEG5E16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vssseg5e32.v $vs3, $rs1, $rs2$vm */ + RISCV_VSSSEG5E32_V /* 12984 */, RISCV_INS_VSSSEG5E32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vssseg5e64.v $vs3, $rs1, $rs2$vm */ + RISCV_VSSSEG5E64_V /* 12985 */, RISCV_INS_VSSSEG5E64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vssseg5e8.v $vs3, $rs1, $rs2$vm */ + RISCV_VSSSEG5E8_V /* 12986 */, RISCV_INS_VSSSEG5E8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vssseg6e16.v $vs3, $rs1, $rs2$vm */ + RISCV_VSSSEG6E16_V /* 12987 */, RISCV_INS_VSSSEG6E16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vssseg6e32.v $vs3, $rs1, $rs2$vm */ + RISCV_VSSSEG6E32_V /* 12988 */, RISCV_INS_VSSSEG6E32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vssseg6e64.v $vs3, $rs1, $rs2$vm */ + RISCV_VSSSEG6E64_V /* 12989 */, RISCV_INS_VSSSEG6E64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vssseg6e8.v $vs3, $rs1, $rs2$vm */ + RISCV_VSSSEG6E8_V /* 12990 */, RISCV_INS_VSSSEG6E8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vssseg7e16.v $vs3, $rs1, $rs2$vm */ + RISCV_VSSSEG7E16_V /* 12991 */, RISCV_INS_VSSSEG7E16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vssseg7e32.v $vs3, $rs1, $rs2$vm */ + RISCV_VSSSEG7E32_V /* 12992 */, RISCV_INS_VSSSEG7E32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vssseg7e64.v $vs3, $rs1, $rs2$vm */ + RISCV_VSSSEG7E64_V /* 12993 */, RISCV_INS_VSSSEG7E64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vssseg7e8.v $vs3, $rs1, $rs2$vm */ + RISCV_VSSSEG7E8_V /* 12994 */, RISCV_INS_VSSSEG7E8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vssseg8e16.v $vs3, $rs1, $rs2$vm */ + RISCV_VSSSEG8E16_V /* 12995 */, RISCV_INS_VSSSEG8E16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vssseg8e32.v $vs3, $rs1, $rs2$vm */ + RISCV_VSSSEG8E32_V /* 12996 */, RISCV_INS_VSSSEG8E32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vssseg8e64.v $vs3, $rs1, $rs2$vm */ + RISCV_VSSSEG8E64_V /* 12997 */, RISCV_INS_VSSSEG8E64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vssseg8e8.v $vs3, $rs1, $rs2$vm */ + RISCV_VSSSEG8E8_V /* 12998 */, RISCV_INS_VSSSEG8E8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vssubu.vv $vd, $vs2, $vs1$vm */ + RISCV_VSSUBU_VV /* 12999 */, RISCV_INS_VSSUBU_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vssubu.vx $vd, $vs2, $rs1$vm */ + RISCV_VSSUBU_VX /* 13000 */, RISCV_INS_VSSUBU_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vssub.vv $vd, $vs2, $vs1$vm */ + RISCV_VSSUB_VV /* 13001 */, RISCV_INS_VSSUB_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vssub.vx $vd, $vs2, $rs1$vm */ + RISCV_VSSUB_VX /* 13002 */, RISCV_INS_VSSUB_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsub.vv $vd, $vs2, $vs1$vm */ + RISCV_VSUB_VV /* 13003 */, RISCV_INS_VSUB_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsub.vx $vd, $vs2, $rs1$vm */ + RISCV_VSUB_VX /* 13004 */, RISCV_INS_VSUB_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsuxei16.v $vs3, $rs1, $vs2$vm */ + RISCV_VSUXEI16_V /* 13005 */, RISCV_INS_VSUXEI16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsuxei32.v $vs3, $rs1, $vs2$vm */ + RISCV_VSUXEI32_V /* 13006 */, RISCV_INS_VSUXEI32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsuxei64.v $vs3, $rs1, $vs2$vm */ + RISCV_VSUXEI64_V /* 13007 */, RISCV_INS_VSUXEI64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_ISRV64, RISCV_FEATURE_HASVINSTRUCTIONSI64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsuxei8.v $vs3, $rs1, $vs2$vm */ + RISCV_VSUXEI8_V /* 13008 */, RISCV_INS_VSUXEI8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsuxseg2ei16.v $vs3, $rs1, $vs2$vm */ + RISCV_VSUXSEG2EI16_V /* 13009 */, RISCV_INS_VSUXSEG2EI16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsuxseg2ei32.v $vs3, $rs1, $vs2$vm */ + RISCV_VSUXSEG2EI32_V /* 13010 */, RISCV_INS_VSUXSEG2EI32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsuxseg2ei64.v $vs3, $rs1, $vs2$vm */ + RISCV_VSUXSEG2EI64_V /* 13011 */, RISCV_INS_VSUXSEG2EI64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsuxseg2ei8.v $vs3, $rs1, $vs2$vm */ + RISCV_VSUXSEG2EI8_V /* 13012 */, RISCV_INS_VSUXSEG2EI8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsuxseg3ei16.v $vs3, $rs1, $vs2$vm */ + RISCV_VSUXSEG3EI16_V /* 13013 */, RISCV_INS_VSUXSEG3EI16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsuxseg3ei32.v $vs3, $rs1, $vs2$vm */ + RISCV_VSUXSEG3EI32_V /* 13014 */, RISCV_INS_VSUXSEG3EI32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsuxseg3ei64.v $vs3, $rs1, $vs2$vm */ + RISCV_VSUXSEG3EI64_V /* 13015 */, RISCV_INS_VSUXSEG3EI64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsuxseg3ei8.v $vs3, $rs1, $vs2$vm */ + RISCV_VSUXSEG3EI8_V /* 13016 */, RISCV_INS_VSUXSEG3EI8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsuxseg4ei16.v $vs3, $rs1, $vs2$vm */ + RISCV_VSUXSEG4EI16_V /* 13017 */, RISCV_INS_VSUXSEG4EI16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsuxseg4ei32.v $vs3, $rs1, $vs2$vm */ + RISCV_VSUXSEG4EI32_V /* 13018 */, RISCV_INS_VSUXSEG4EI32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsuxseg4ei64.v $vs3, $rs1, $vs2$vm */ + RISCV_VSUXSEG4EI64_V /* 13019 */, RISCV_INS_VSUXSEG4EI64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsuxseg4ei8.v $vs3, $rs1, $vs2$vm */ + RISCV_VSUXSEG4EI8_V /* 13020 */, RISCV_INS_VSUXSEG4EI8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsuxseg5ei16.v $vs3, $rs1, $vs2$vm */ + RISCV_VSUXSEG5EI16_V /* 13021 */, RISCV_INS_VSUXSEG5EI16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsuxseg5ei32.v $vs3, $rs1, $vs2$vm */ + RISCV_VSUXSEG5EI32_V /* 13022 */, RISCV_INS_VSUXSEG5EI32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsuxseg5ei64.v $vs3, $rs1, $vs2$vm */ + RISCV_VSUXSEG5EI64_V /* 13023 */, RISCV_INS_VSUXSEG5EI64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsuxseg5ei8.v $vs3, $rs1, $vs2$vm */ + RISCV_VSUXSEG5EI8_V /* 13024 */, RISCV_INS_VSUXSEG5EI8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsuxseg6ei16.v $vs3, $rs1, $vs2$vm */ + RISCV_VSUXSEG6EI16_V /* 13025 */, RISCV_INS_VSUXSEG6EI16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsuxseg6ei32.v $vs3, $rs1, $vs2$vm */ + RISCV_VSUXSEG6EI32_V /* 13026 */, RISCV_INS_VSUXSEG6EI32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsuxseg6ei64.v $vs3, $rs1, $vs2$vm */ + RISCV_VSUXSEG6EI64_V /* 13027 */, RISCV_INS_VSUXSEG6EI64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsuxseg6ei8.v $vs3, $rs1, $vs2$vm */ + RISCV_VSUXSEG6EI8_V /* 13028 */, RISCV_INS_VSUXSEG6EI8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsuxseg7ei16.v $vs3, $rs1, $vs2$vm */ + RISCV_VSUXSEG7EI16_V /* 13029 */, RISCV_INS_VSUXSEG7EI16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsuxseg7ei32.v $vs3, $rs1, $vs2$vm */ + RISCV_VSUXSEG7EI32_V /* 13030 */, RISCV_INS_VSUXSEG7EI32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsuxseg7ei64.v $vs3, $rs1, $vs2$vm */ + RISCV_VSUXSEG7EI64_V /* 13031 */, RISCV_INS_VSUXSEG7EI64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsuxseg7ei8.v $vs3, $rs1, $vs2$vm */ + RISCV_VSUXSEG7EI8_V /* 13032 */, RISCV_INS_VSUXSEG7EI8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsuxseg8ei16.v $vs3, $rs1, $vs2$vm */ + RISCV_VSUXSEG8EI16_V /* 13033 */, RISCV_INS_VSUXSEG8EI16_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsuxseg8ei32.v $vs3, $rs1, $vs2$vm */ + RISCV_VSUXSEG8EI32_V /* 13034 */, RISCV_INS_VSUXSEG8EI32_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsuxseg8ei64.v $vs3, $rs1, $vs2$vm */ + RISCV_VSUXSEG8EI64_V /* 13035 */, RISCV_INS_VSUXSEG8EI64_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONSI64, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vsuxseg8ei8.v $vs3, $rs1, $vs2$vm */ + RISCV_VSUXSEG8EI8_V /* 13036 */, RISCV_INS_VSUXSEG8EI8_V, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vt.maskc $rd, $rs1, $rs2 */ + RISCV_VT_MASKC /* 13037 */, RISCV_INS_VT_MASKC, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_ISRV64, RISCV_FEATURE_HASVENDORXVENTANACONDOPS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vt.maskcn $rd, $rs1, $rs2 */ + RISCV_VT_MASKCN /* 13038 */, RISCV_INS_VT_MASKCN, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_ISRV64, RISCV_FEATURE_HASVENDORXVENTANACONDOPS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vwaddu.vv $vd, $vs2, $vs1$vm */ + RISCV_VWADDU_VV /* 13039 */, RISCV_INS_VWADDU_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vwaddu.vx $vd, $vs2, $rs1$vm */ + RISCV_VWADDU_VX /* 13040 */, RISCV_INS_VWADDU_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vwaddu.wv $vd, $vs2, $vs1$vm */ + RISCV_VWADDU_WV /* 13041 */, RISCV_INS_VWADDU_WV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vwaddu.wx $vd, $vs2, $rs1$vm */ + RISCV_VWADDU_WX /* 13042 */, RISCV_INS_VWADDU_WX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vwadd.vv $vd, $vs2, $vs1$vm */ + RISCV_VWADD_VV /* 13043 */, RISCV_INS_VWADD_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vwadd.vx $vd, $vs2, $rs1$vm */ + RISCV_VWADD_VX /* 13044 */, RISCV_INS_VWADD_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vwadd.wv $vd, $vs2, $vs1$vm */ + RISCV_VWADD_WV /* 13045 */, RISCV_INS_VWADD_WV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vwadd.wx $vd, $vs2, $rs1$vm */ + RISCV_VWADD_WX /* 13046 */, RISCV_INS_VWADD_WX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vwmaccsu.vv $vd, $vs1, $vs2$vm */ + RISCV_VWMACCSU_VV /* 13047 */, RISCV_INS_VWMACCSU_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vwmaccsu.vx $vd, $rs1, $vs2$vm */ + RISCV_VWMACCSU_VX /* 13048 */, RISCV_INS_VWMACCSU_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vwmaccus.vx $vd, $rs1, $vs2$vm */ + RISCV_VWMACCUS_VX /* 13049 */, RISCV_INS_VWMACCUS_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vwmaccu.vv $vd, $vs1, $vs2$vm */ + RISCV_VWMACCU_VV /* 13050 */, RISCV_INS_VWMACCU_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vwmaccu.vx $vd, $rs1, $vs2$vm */ + RISCV_VWMACCU_VX /* 13051 */, RISCV_INS_VWMACCU_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vwmacc.vv $vd, $vs1, $vs2$vm */ + RISCV_VWMACC_VV /* 13052 */, RISCV_INS_VWMACC_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vwmacc.vx $vd, $rs1, $vs2$vm */ + RISCV_VWMACC_VX /* 13053 */, RISCV_INS_VWMACC_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vwmulsu.vv $vd, $vs2, $vs1$vm */ + RISCV_VWMULSU_VV /* 13054 */, RISCV_INS_VWMULSU_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vwmulsu.vx $vd, $vs2, $rs1$vm */ + RISCV_VWMULSU_VX /* 13055 */, RISCV_INS_VWMULSU_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vwmulu.vv $vd, $vs2, $vs1$vm */ + RISCV_VWMULU_VV /* 13056 */, RISCV_INS_VWMULU_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vwmulu.vx $vd, $vs2, $rs1$vm */ + RISCV_VWMULU_VX /* 13057 */, RISCV_INS_VWMULU_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vwmul.vv $vd, $vs2, $vs1$vm */ + RISCV_VWMUL_VV /* 13058 */, RISCV_INS_VWMUL_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vwmul.vx $vd, $vs2, $rs1$vm */ + RISCV_VWMUL_VX /* 13059 */, RISCV_INS_VWMUL_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vwredsumu.vs $vd, $vs2, $vs1$vm */ + RISCV_VWREDSUMU_VS /* 13060 */, RISCV_INS_VWREDSUMU_VS, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vwredsum.vs $vd, $vs2, $vs1$vm */ + RISCV_VWREDSUM_VS /* 13061 */, RISCV_INS_VWREDSUM_VS, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vwsll.vi $vd, $vs2, $imm$vm */ + RISCV_VWSLL_VI /* 13062 */, RISCV_INS_VWSLL_VI, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZVBB, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vwsll.vv $vd, $vs2, $vs1$vm */ + RISCV_VWSLL_VV /* 13063 */, RISCV_INS_VWSLL_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZVBB, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vwsll.vx $vd, $vs2, $rs1$vm */ + RISCV_VWSLL_VX /* 13064 */, RISCV_INS_VWSLL_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZVBB, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vwsubu.vv $vd, $vs2, $vs1$vm */ + RISCV_VWSUBU_VV /* 13065 */, RISCV_INS_VWSUBU_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vwsubu.vx $vd, $vs2, $rs1$vm */ + RISCV_VWSUBU_VX /* 13066 */, RISCV_INS_VWSUBU_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vwsubu.wv $vd, $vs2, $vs1$vm */ + RISCV_VWSUBU_WV /* 13067 */, RISCV_INS_VWSUBU_WV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vwsubu.wx $vd, $vs2, $rs1$vm */ + RISCV_VWSUBU_WX /* 13068 */, RISCV_INS_VWSUBU_WX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vwsub.vv $vd, $vs2, $vs1$vm */ + RISCV_VWSUB_VV /* 13069 */, RISCV_INS_VWSUB_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vwsub.vx $vd, $vs2, $rs1$vm */ + RISCV_VWSUB_VX /* 13070 */, RISCV_INS_VWSUB_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vwsub.wv $vd, $vs2, $vs1$vm */ + RISCV_VWSUB_WV /* 13071 */, RISCV_INS_VWSUB_WV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vwsub.wx $vd, $vs2, $rs1$vm */ + RISCV_VWSUB_WX /* 13072 */, RISCV_INS_VWSUB_WX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vxor.vi $vd, $vs2, $imm$vm */ + RISCV_VXOR_VI /* 13073 */, RISCV_INS_VXOR_VI, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vxor.vv $vd, $vs2, $vs1$vm */ + RISCV_VXOR_VV /* 13074 */, RISCV_INS_VXOR_VV, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vxor.vx $vd, $vs2, $rs1$vm */ + RISCV_VXOR_VX /* 13075 */, RISCV_INS_VXOR_VX, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vzext.vf2 $vd, $vs2$vm */ + RISCV_VZEXT_VF2 /* 13076 */, RISCV_INS_VZEXT_VF2, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vzext.vf4 $vd, $vs2$vm */ + RISCV_VZEXT_VF4 /* 13077 */, RISCV_INS_VZEXT_VF4, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* vzext.vf8 $vd, $vs2$vm */ + RISCV_VZEXT_VF8 /* 13078 */, RISCV_INS_VZEXT_VF8, + #ifndef CAPSTONE_DIET + { RISCV_REG_VTYPE, RISCV_REG_VL, 0 }, { 0 }, { RISCV_FEATURE_HASVINSTRUCTIONS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* wfi */ + RISCV_WFI /* 13079 */, RISCV_INS_WFI, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* wrs.nto */ + RISCV_WRS_NTO /* 13080 */, RISCV_INS_WRS_NTO, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZAWRS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* wrs.sto */ + RISCV_WRS_STO /* 13081 */, RISCV_INS_WRS_STO, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZAWRS, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* xnor $rd, $rs1, $rs2 */ + RISCV_XNOR /* 13082 */, RISCV_INS_XNOR, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZBBORZBKB, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* xor $rd, $rs1, $rs2 */ + RISCV_XOR /* 13083 */, RISCV_INS_XOR, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* xori $rd, $rs1, $imm12 */ + RISCV_XORI /* 13084 */, RISCV_INS_XORI, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* xperm4 $rd, $rs1, $rs2 */ + RISCV_XPERM4 /* 13085 */, RISCV_INS_XPERM4, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZBKX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* xperm8 $rd, $rs1, $rs2 */ + RISCV_XPERM8 /* 13086 */, RISCV_INS_XPERM8, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZBKX, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* zext.h $rd, $rs1 */ + RISCV_ZEXT_H_RV32 /* 13087 */, RISCV_INS_ZEXT_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZBB, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* zext.h $rd, $rs1 */ + RISCV_ZEXT_H_RV64 /* 13088 */, RISCV_INS_ZEXT_H, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZBB, RISCV_FEATURE_ISRV64, 0 }, 0, 0, {{ 0 }} + + #endif +}, +{ + /* zip $rd, $rs1 */ + RISCV_ZIP_RV32 /* 13089 */, RISCV_INS_ZIP, + #ifndef CAPSTONE_DIET + { 0 }, { 0 }, { RISCV_FEATURE_HASSTDEXTZBKB, RISCV_FEATURE_ISRV32, 0 }, 0, 0, {{ 0 }} + + #endif +}, diff --git a/arch/RISCV/RISCVGenCSMappingInsnName.inc b/arch/RISCV/RISCVGenCSMappingInsnName.inc new file mode 100644 index 0000000000..1199c27700 --- /dev/null +++ b/arch/RISCV/RISCVGenCSMappingInsnName.inc @@ -0,0 +1,1688 @@ +/* Capstone Disassembly Engine, https://www.capstone-engine.org */ +/* By Nguyen Anh Quynh , 2013-2022, */ +/* Rot127 2022-2024 */ +/* Automatically generated file by Capstone's LLVM TableGen Disassembler Backend. */ + +/* LLVM-commit: */ +/* LLVM-tag: */ + +/* Do not edit. */ + +/* Capstone's LLVM TableGen Backends: */ +/* https://github.com/capstone-engine/llvm-capstone */ + + "invalid", // RISCV_INS_INVALID + "add", // RISCV_INS_ADD + "call", // RISCV_INS_CALL + "fld", // RISCV_INS_FLD + "flh", // RISCV_INS_FLH + "flw", // RISCV_INS_FLW + "fsd", // RISCV_INS_FSD + "fsh", // RISCV_INS_FSH + "fsw", // RISCV_INS_FSW + "jump", // RISCV_INS_JUMP + "la", // RISCV_INS_LA + "la_tlsdesc", // RISCV_INS_LA_TLSDESC + "la_tls_gd", // RISCV_INS_LA_TLS_GD + "la_tls_ie", // RISCV_INS_LA_TLS_IE + "lb", // RISCV_INS_LB + "lbu", // RISCV_INS_LBU + "ld", // RISCV_INS_LD + "lga", // RISCV_INS_LGA + "lh", // RISCV_INS_LH + "lhu", // RISCV_INS_LHU + "li", // RISCV_INS_LI + "lla", // RISCV_INS_LLA + "lw", // RISCV_INS_LW + "lwu", // RISCV_INS_LWU + "sb", // RISCV_INS_SB + "sd", // RISCV_INS_SD + "sext_b", // RISCV_INS_SEXT_B + "sext_h", // RISCV_INS_SEXT_H + "sh", // RISCV_INS_SH + "sw", // RISCV_INS_SW + "tail", // RISCV_INS_TAIL + "jalr", // RISCV_INS_JALR + "vmsgeu_vi", // RISCV_INS_VMSGEU_VI + "vmsgeu_vx", // RISCV_INS_VMSGEU_VX + "vmsge_vi", // RISCV_INS_VMSGE_VI + "vmsge_vx", // RISCV_INS_VMSGE_VX + "vmsltu_vi", // RISCV_INS_VMSLTU_VI + "vmslt_vi", // RISCV_INS_VMSLT_VI + "zext_h", // RISCV_INS_ZEXT_H + "zext_w", // RISCV_INS_ZEXT_W + "addi", // RISCV_INS_ADDI + "addiw", // RISCV_INS_ADDIW + "addw", // RISCV_INS_ADDW + "add_uw", // RISCV_INS_ADD_UW + "aes32dsi", // RISCV_INS_AES32DSI + "aes32dsmi", // RISCV_INS_AES32DSMI + "aes32esi", // RISCV_INS_AES32ESI + "aes32esmi", // RISCV_INS_AES32ESMI + "aes64ds", // RISCV_INS_AES64DS + "aes64dsm", // RISCV_INS_AES64DSM + "aes64es", // RISCV_INS_AES64ES + "aes64esm", // RISCV_INS_AES64ESM + "aes64im", // RISCV_INS_AES64IM + "aes64ks1i", // RISCV_INS_AES64KS1I + "aes64ks2", // RISCV_INS_AES64KS2 + "amoadd_d", // RISCV_INS_AMOADD_D + "amoadd_d_aq", // RISCV_INS_AMOADD_D_AQ + "amoadd_d_aqrl", // RISCV_INS_AMOADD_D_AQRL + "amoadd_d_rl", // RISCV_INS_AMOADD_D_RL + "amoadd_w", // RISCV_INS_AMOADD_W + "amoadd_w_aq", // RISCV_INS_AMOADD_W_AQ + "amoadd_w_aqrl", // RISCV_INS_AMOADD_W_AQRL + "amoadd_w_rl", // RISCV_INS_AMOADD_W_RL + "amoand_d", // RISCV_INS_AMOAND_D + "amoand_d_aq", // RISCV_INS_AMOAND_D_AQ + "amoand_d_aqrl", // RISCV_INS_AMOAND_D_AQRL + "amoand_d_rl", // RISCV_INS_AMOAND_D_RL + "amoand_w", // RISCV_INS_AMOAND_W + "amoand_w_aq", // RISCV_INS_AMOAND_W_AQ + "amoand_w_aqrl", // RISCV_INS_AMOAND_W_AQRL + "amoand_w_rl", // RISCV_INS_AMOAND_W_RL + "amocas_d", // RISCV_INS_AMOCAS_D + "amocas_d_aq", // RISCV_INS_AMOCAS_D_AQ + "amocas_d_aqrl", // RISCV_INS_AMOCAS_D_AQRL + "amocas_d_rl", // RISCV_INS_AMOCAS_D_RL + "amocas_q", // RISCV_INS_AMOCAS_Q + "amocas_q_aq", // RISCV_INS_AMOCAS_Q_AQ + "amocas_q_aqrl", // RISCV_INS_AMOCAS_Q_AQRL + "amocas_q_rl", // RISCV_INS_AMOCAS_Q_RL + "amocas_w", // RISCV_INS_AMOCAS_W + "amocas_w_aq", // RISCV_INS_AMOCAS_W_AQ + "amocas_w_aqrl", // RISCV_INS_AMOCAS_W_AQRL + "amocas_w_rl", // RISCV_INS_AMOCAS_W_RL + "amomaxu_d", // RISCV_INS_AMOMAXU_D + "amomaxu_d_aq", // RISCV_INS_AMOMAXU_D_AQ + "amomaxu_d_aqrl", // RISCV_INS_AMOMAXU_D_AQRL + "amomaxu_d_rl", // RISCV_INS_AMOMAXU_D_RL + "amomaxu_w", // RISCV_INS_AMOMAXU_W + "amomaxu_w_aq", // RISCV_INS_AMOMAXU_W_AQ + "amomaxu_w_aqrl", // RISCV_INS_AMOMAXU_W_AQRL + "amomaxu_w_rl", // RISCV_INS_AMOMAXU_W_RL + "amomax_d", // RISCV_INS_AMOMAX_D + "amomax_d_aq", // RISCV_INS_AMOMAX_D_AQ + "amomax_d_aqrl", // RISCV_INS_AMOMAX_D_AQRL + "amomax_d_rl", // RISCV_INS_AMOMAX_D_RL + "amomax_w", // RISCV_INS_AMOMAX_W + "amomax_w_aq", // RISCV_INS_AMOMAX_W_AQ + "amomax_w_aqrl", // RISCV_INS_AMOMAX_W_AQRL + "amomax_w_rl", // RISCV_INS_AMOMAX_W_RL + "amominu_d", // RISCV_INS_AMOMINU_D + "amominu_d_aq", // RISCV_INS_AMOMINU_D_AQ + "amominu_d_aqrl", // RISCV_INS_AMOMINU_D_AQRL + "amominu_d_rl", // RISCV_INS_AMOMINU_D_RL + "amominu_w", // RISCV_INS_AMOMINU_W + "amominu_w_aq", // RISCV_INS_AMOMINU_W_AQ + "amominu_w_aqrl", // RISCV_INS_AMOMINU_W_AQRL + "amominu_w_rl", // RISCV_INS_AMOMINU_W_RL + "amomin_d", // RISCV_INS_AMOMIN_D + "amomin_d_aq", // RISCV_INS_AMOMIN_D_AQ + "amomin_d_aqrl", // RISCV_INS_AMOMIN_D_AQRL + "amomin_d_rl", // RISCV_INS_AMOMIN_D_RL + "amomin_w", // RISCV_INS_AMOMIN_W + "amomin_w_aq", // RISCV_INS_AMOMIN_W_AQ + "amomin_w_aqrl", // RISCV_INS_AMOMIN_W_AQRL + "amomin_w_rl", // RISCV_INS_AMOMIN_W_RL + "amoor_d", // RISCV_INS_AMOOR_D + "amoor_d_aq", // RISCV_INS_AMOOR_D_AQ + "amoor_d_aqrl", // RISCV_INS_AMOOR_D_AQRL + "amoor_d_rl", // RISCV_INS_AMOOR_D_RL + "amoor_w", // RISCV_INS_AMOOR_W + "amoor_w_aq", // RISCV_INS_AMOOR_W_AQ + "amoor_w_aqrl", // RISCV_INS_AMOOR_W_AQRL + "amoor_w_rl", // RISCV_INS_AMOOR_W_RL + "amoswap_d", // RISCV_INS_AMOSWAP_D + "amoswap_d_aq", // RISCV_INS_AMOSWAP_D_AQ + "amoswap_d_aqrl", // RISCV_INS_AMOSWAP_D_AQRL + "amoswap_d_rl", // RISCV_INS_AMOSWAP_D_RL + "amoswap_w", // RISCV_INS_AMOSWAP_W + "amoswap_w_aq", // RISCV_INS_AMOSWAP_W_AQ + "amoswap_w_aqrl", // RISCV_INS_AMOSWAP_W_AQRL + "amoswap_w_rl", // RISCV_INS_AMOSWAP_W_RL + "amoxor_d", // RISCV_INS_AMOXOR_D + "amoxor_d_aq", // RISCV_INS_AMOXOR_D_AQ + "amoxor_d_aqrl", // RISCV_INS_AMOXOR_D_AQRL + "amoxor_d_rl", // RISCV_INS_AMOXOR_D_RL + "amoxor_w", // RISCV_INS_AMOXOR_W + "amoxor_w_aq", // RISCV_INS_AMOXOR_W_AQ + "amoxor_w_aqrl", // RISCV_INS_AMOXOR_W_AQRL + "amoxor_w_rl", // RISCV_INS_AMOXOR_W_RL + "and", // RISCV_INS_AND + "andi", // RISCV_INS_ANDI + "andn", // RISCV_INS_ANDN + "auipc", // RISCV_INS_AUIPC + "bclr", // RISCV_INS_BCLR + "bclri", // RISCV_INS_BCLRI + "beq", // RISCV_INS_BEQ + "bext", // RISCV_INS_BEXT + "bexti", // RISCV_INS_BEXTI + "bge", // RISCV_INS_BGE + "bgeu", // RISCV_INS_BGEU + "binv", // RISCV_INS_BINV + "binvi", // RISCV_INS_BINVI + "blt", // RISCV_INS_BLT + "bltu", // RISCV_INS_BLTU + "bne", // RISCV_INS_BNE + "brev8", // RISCV_INS_BREV8 + "bset", // RISCV_INS_BSET + "bseti", // RISCV_INS_BSETI + "cbo_clean", // RISCV_INS_CBO_CLEAN + "cbo_flush", // RISCV_INS_CBO_FLUSH + "cbo_inval", // RISCV_INS_CBO_INVAL + "cbo_zero", // RISCV_INS_CBO_ZERO + "clmul", // RISCV_INS_CLMUL + "clmulh", // RISCV_INS_CLMULH + "clmulr", // RISCV_INS_CLMULR + "clz", // RISCV_INS_CLZ + "clzw", // RISCV_INS_CLZW + "cmop_1", // RISCV_INS_CMOP_1 + "cmop_11", // RISCV_INS_CMOP_11 + "cmop_13", // RISCV_INS_CMOP_13 + "cmop_15", // RISCV_INS_CMOP_15 + "cmop_3", // RISCV_INS_CMOP_3 + "cmop_5", // RISCV_INS_CMOP_5 + "cmop_7", // RISCV_INS_CMOP_7 + "cmop_9", // RISCV_INS_CMOP_9 + "cm_jalt", // RISCV_INS_CM_JALT + "cm_jt", // RISCV_INS_CM_JT + "cm_mva01s", // RISCV_INS_CM_MVA01S + "cm_mvsa01", // RISCV_INS_CM_MVSA01 + "cm_pop", // RISCV_INS_CM_POP + "cm_popret", // RISCV_INS_CM_POPRET + "cm_popretz", // RISCV_INS_CM_POPRETZ + "cm_push", // RISCV_INS_CM_PUSH + "cpop", // RISCV_INS_CPOP + "cpopw", // RISCV_INS_CPOPW + "csrrc", // RISCV_INS_CSRRC + "csrrci", // RISCV_INS_CSRRCI + "csrrs", // RISCV_INS_CSRRS + "csrrsi", // RISCV_INS_CSRRSI + "csrrw", // RISCV_INS_CSRRW + "csrrwi", // RISCV_INS_CSRRWI + "ctz", // RISCV_INS_CTZ + "ctzw", // RISCV_INS_CTZW + "cv_abs", // RISCV_INS_CV_ABS + "cv_abs_b", // RISCV_INS_CV_ABS_B + "cv_abs_h", // RISCV_INS_CV_ABS_H + "cv_addn", // RISCV_INS_CV_ADDN + "cv_addnr", // RISCV_INS_CV_ADDNR + "cv_addrn", // RISCV_INS_CV_ADDRN + "cv_addrnr", // RISCV_INS_CV_ADDRNR + "cv_addun", // RISCV_INS_CV_ADDUN + "cv_addunr", // RISCV_INS_CV_ADDUNR + "cv_addurn", // RISCV_INS_CV_ADDURN + "cv_addurnr", // RISCV_INS_CV_ADDURNR + "cv_add_b", // RISCV_INS_CV_ADD_B + "cv_add_div2", // RISCV_INS_CV_ADD_DIV2 + "cv_add_div4", // RISCV_INS_CV_ADD_DIV4 + "cv_add_div8", // RISCV_INS_CV_ADD_DIV8 + "cv_add_h", // RISCV_INS_CV_ADD_H + "cv_add_sci_b", // RISCV_INS_CV_ADD_SCI_B + "cv_add_sci_h", // RISCV_INS_CV_ADD_SCI_H + "cv_add_sc_b", // RISCV_INS_CV_ADD_SC_B + "cv_add_sc_h", // RISCV_INS_CV_ADD_SC_H + "cv_and_b", // RISCV_INS_CV_AND_B + "cv_and_h", // RISCV_INS_CV_AND_H + "cv_and_sci_b", // RISCV_INS_CV_AND_SCI_B + "cv_and_sci_h", // RISCV_INS_CV_AND_SCI_H + "cv_and_sc_b", // RISCV_INS_CV_AND_SC_B + "cv_and_sc_h", // RISCV_INS_CV_AND_SC_H + "cv_avgu_b", // RISCV_INS_CV_AVGU_B + "cv_avgu_h", // RISCV_INS_CV_AVGU_H + "cv_avgu_sci_b", // RISCV_INS_CV_AVGU_SCI_B + "cv_avgu_sci_h", // RISCV_INS_CV_AVGU_SCI_H + "cv_avgu_sc_b", // RISCV_INS_CV_AVGU_SC_B + "cv_avgu_sc_h", // RISCV_INS_CV_AVGU_SC_H + "cv_avg_b", // RISCV_INS_CV_AVG_B + "cv_avg_h", // RISCV_INS_CV_AVG_H + "cv_avg_sci_b", // RISCV_INS_CV_AVG_SCI_B + "cv_avg_sci_h", // RISCV_INS_CV_AVG_SCI_H + "cv_avg_sc_b", // RISCV_INS_CV_AVG_SC_B + "cv_avg_sc_h", // RISCV_INS_CV_AVG_SC_H + "cv_bclr", // RISCV_INS_CV_BCLR + "cv_bclrr", // RISCV_INS_CV_BCLRR + "cv_beqimm", // RISCV_INS_CV_BEQIMM + "cv_bitrev", // RISCV_INS_CV_BITREV + "cv_bneimm", // RISCV_INS_CV_BNEIMM + "cv_bset", // RISCV_INS_CV_BSET + "cv_bsetr", // RISCV_INS_CV_BSETR + "cv_clb", // RISCV_INS_CV_CLB + "cv_clip", // RISCV_INS_CV_CLIP + "cv_clipr", // RISCV_INS_CV_CLIPR + "cv_clipu", // RISCV_INS_CV_CLIPU + "cv_clipur", // RISCV_INS_CV_CLIPUR + "cv_cmpeq_b", // RISCV_INS_CV_CMPEQ_B + "cv_cmpeq_h", // RISCV_INS_CV_CMPEQ_H + "cv_cmpeq_sci_b", // RISCV_INS_CV_CMPEQ_SCI_B + "cv_cmpeq_sci_h", // RISCV_INS_CV_CMPEQ_SCI_H + "cv_cmpeq_sc_b", // RISCV_INS_CV_CMPEQ_SC_B + "cv_cmpeq_sc_h", // RISCV_INS_CV_CMPEQ_SC_H + "cv_cmpgeu_b", // RISCV_INS_CV_CMPGEU_B + "cv_cmpgeu_h", // RISCV_INS_CV_CMPGEU_H + "cv_cmpgeu_sci_b", // RISCV_INS_CV_CMPGEU_SCI_B + "cv_cmpgeu_sci_h", // RISCV_INS_CV_CMPGEU_SCI_H + "cv_cmpgeu_sc_b", // RISCV_INS_CV_CMPGEU_SC_B + "cv_cmpgeu_sc_h", // RISCV_INS_CV_CMPGEU_SC_H + "cv_cmpge_b", // RISCV_INS_CV_CMPGE_B + "cv_cmpge_h", // RISCV_INS_CV_CMPGE_H + "cv_cmpge_sci_b", // RISCV_INS_CV_CMPGE_SCI_B + "cv_cmpge_sci_h", // RISCV_INS_CV_CMPGE_SCI_H + "cv_cmpge_sc_b", // RISCV_INS_CV_CMPGE_SC_B + "cv_cmpge_sc_h", // RISCV_INS_CV_CMPGE_SC_H + "cv_cmpgtu_b", // RISCV_INS_CV_CMPGTU_B + "cv_cmpgtu_h", // RISCV_INS_CV_CMPGTU_H + "cv_cmpgtu_sci_b", // RISCV_INS_CV_CMPGTU_SCI_B + "cv_cmpgtu_sci_h", // RISCV_INS_CV_CMPGTU_SCI_H + "cv_cmpgtu_sc_b", // RISCV_INS_CV_CMPGTU_SC_B + "cv_cmpgtu_sc_h", // RISCV_INS_CV_CMPGTU_SC_H + "cv_cmpgt_b", // RISCV_INS_CV_CMPGT_B + "cv_cmpgt_h", // RISCV_INS_CV_CMPGT_H + "cv_cmpgt_sci_b", // RISCV_INS_CV_CMPGT_SCI_B + "cv_cmpgt_sci_h", // RISCV_INS_CV_CMPGT_SCI_H + "cv_cmpgt_sc_b", // RISCV_INS_CV_CMPGT_SC_B + "cv_cmpgt_sc_h", // RISCV_INS_CV_CMPGT_SC_H + "cv_cmpleu_b", // RISCV_INS_CV_CMPLEU_B + "cv_cmpleu_h", // RISCV_INS_CV_CMPLEU_H + "cv_cmpleu_sci_b", // RISCV_INS_CV_CMPLEU_SCI_B + "cv_cmpleu_sci_h", // RISCV_INS_CV_CMPLEU_SCI_H + "cv_cmpleu_sc_b", // RISCV_INS_CV_CMPLEU_SC_B + "cv_cmpleu_sc_h", // RISCV_INS_CV_CMPLEU_SC_H + "cv_cmple_b", // RISCV_INS_CV_CMPLE_B + "cv_cmple_h", // RISCV_INS_CV_CMPLE_H + "cv_cmple_sci_b", // RISCV_INS_CV_CMPLE_SCI_B + "cv_cmple_sci_h", // RISCV_INS_CV_CMPLE_SCI_H + "cv_cmple_sc_b", // RISCV_INS_CV_CMPLE_SC_B + "cv_cmple_sc_h", // RISCV_INS_CV_CMPLE_SC_H + "cv_cmpltu_b", // RISCV_INS_CV_CMPLTU_B + "cv_cmpltu_h", // RISCV_INS_CV_CMPLTU_H + "cv_cmpltu_sci_b", // RISCV_INS_CV_CMPLTU_SCI_B + "cv_cmpltu_sci_h", // RISCV_INS_CV_CMPLTU_SCI_H + "cv_cmpltu_sc_b", // RISCV_INS_CV_CMPLTU_SC_B + "cv_cmpltu_sc_h", // RISCV_INS_CV_CMPLTU_SC_H + "cv_cmplt_b", // RISCV_INS_CV_CMPLT_B + "cv_cmplt_h", // RISCV_INS_CV_CMPLT_H + "cv_cmplt_sci_b", // RISCV_INS_CV_CMPLT_SCI_B + "cv_cmplt_sci_h", // RISCV_INS_CV_CMPLT_SCI_H + "cv_cmplt_sc_b", // RISCV_INS_CV_CMPLT_SC_B + "cv_cmplt_sc_h", // RISCV_INS_CV_CMPLT_SC_H + "cv_cmpne_b", // RISCV_INS_CV_CMPNE_B + "cv_cmpne_h", // RISCV_INS_CV_CMPNE_H + "cv_cmpne_sci_b", // RISCV_INS_CV_CMPNE_SCI_B + "cv_cmpne_sci_h", // RISCV_INS_CV_CMPNE_SCI_H + "cv_cmpne_sc_b", // RISCV_INS_CV_CMPNE_SC_B + "cv_cmpne_sc_h", // RISCV_INS_CV_CMPNE_SC_H + "cv_cnt", // RISCV_INS_CV_CNT + "cv_cplxconj", // RISCV_INS_CV_CPLXCONJ + "cv_cplxmul_i", // RISCV_INS_CV_CPLXMUL_I + "cv_cplxmul_i_div2", // RISCV_INS_CV_CPLXMUL_I_DIV2 + "cv_cplxmul_i_div4", // RISCV_INS_CV_CPLXMUL_I_DIV4 + "cv_cplxmul_i_div8", // RISCV_INS_CV_CPLXMUL_I_DIV8 + "cv_cplxmul_r", // RISCV_INS_CV_CPLXMUL_R + "cv_cplxmul_r_div2", // RISCV_INS_CV_CPLXMUL_R_DIV2 + "cv_cplxmul_r_div4", // RISCV_INS_CV_CPLXMUL_R_DIV4 + "cv_cplxmul_r_div8", // RISCV_INS_CV_CPLXMUL_R_DIV8 + "cv_dotsp_b", // RISCV_INS_CV_DOTSP_B + "cv_dotsp_h", // RISCV_INS_CV_DOTSP_H + "cv_dotsp_sci_b", // RISCV_INS_CV_DOTSP_SCI_B + "cv_dotsp_sci_h", // RISCV_INS_CV_DOTSP_SCI_H + "cv_dotsp_sc_b", // RISCV_INS_CV_DOTSP_SC_B + "cv_dotsp_sc_h", // RISCV_INS_CV_DOTSP_SC_H + "cv_dotup_b", // RISCV_INS_CV_DOTUP_B + "cv_dotup_h", // RISCV_INS_CV_DOTUP_H + "cv_dotup_sci_b", // RISCV_INS_CV_DOTUP_SCI_B + "cv_dotup_sci_h", // RISCV_INS_CV_DOTUP_SCI_H + "cv_dotup_sc_b", // RISCV_INS_CV_DOTUP_SC_B + "cv_dotup_sc_h", // RISCV_INS_CV_DOTUP_SC_H + "cv_dotusp_b", // RISCV_INS_CV_DOTUSP_B + "cv_dotusp_h", // RISCV_INS_CV_DOTUSP_H + "cv_dotusp_sci_b", // RISCV_INS_CV_DOTUSP_SCI_B + "cv_dotusp_sci_h", // RISCV_INS_CV_DOTUSP_SCI_H + "cv_dotusp_sc_b", // RISCV_INS_CV_DOTUSP_SC_B + "cv_dotusp_sc_h", // RISCV_INS_CV_DOTUSP_SC_H + "cv_elw", // RISCV_INS_CV_ELW + "cv_extbs", // RISCV_INS_CV_EXTBS + "cv_extbz", // RISCV_INS_CV_EXTBZ + "cv_exths", // RISCV_INS_CV_EXTHS + "cv_exthz", // RISCV_INS_CV_EXTHZ + "cv_extract", // RISCV_INS_CV_EXTRACT + "cv_extractr", // RISCV_INS_CV_EXTRACTR + "cv_extractu", // RISCV_INS_CV_EXTRACTU + "cv_extractur", // RISCV_INS_CV_EXTRACTUR + "cv_extractu_b", // RISCV_INS_CV_EXTRACTU_B + "cv_extractu_h", // RISCV_INS_CV_EXTRACTU_H + "cv_extract_b", // RISCV_INS_CV_EXTRACT_B + "cv_extract_h", // RISCV_INS_CV_EXTRACT_H + "cv_ff1", // RISCV_INS_CV_FF1 + "cv_fl1", // RISCV_INS_CV_FL1 + "cv_insert", // RISCV_INS_CV_INSERT + "cv_insertr", // RISCV_INS_CV_INSERTR + "cv_insert_b", // RISCV_INS_CV_INSERT_B + "cv_insert_h", // RISCV_INS_CV_INSERT_H + "cv_lbu", // RISCV_INS_CV_LBU + "cv_lb", // RISCV_INS_CV_LB + "cv_lhu", // RISCV_INS_CV_LHU + "cv_lh", // RISCV_INS_CV_LH + "cv_lw", // RISCV_INS_CV_LW + "cv_mac", // RISCV_INS_CV_MAC + "cv_machhsn", // RISCV_INS_CV_MACHHSN + "cv_machhsrn", // RISCV_INS_CV_MACHHSRN + "cv_machhun", // RISCV_INS_CV_MACHHUN + "cv_machhurn", // RISCV_INS_CV_MACHHURN + "cv_macsn", // RISCV_INS_CV_MACSN + "cv_macsrn", // RISCV_INS_CV_MACSRN + "cv_macun", // RISCV_INS_CV_MACUN + "cv_macurn", // RISCV_INS_CV_MACURN + "cv_max", // RISCV_INS_CV_MAX + "cv_maxu", // RISCV_INS_CV_MAXU + "cv_maxu_b", // RISCV_INS_CV_MAXU_B + "cv_maxu_h", // RISCV_INS_CV_MAXU_H + "cv_maxu_sci_b", // RISCV_INS_CV_MAXU_SCI_B + "cv_maxu_sci_h", // RISCV_INS_CV_MAXU_SCI_H + "cv_maxu_sc_b", // RISCV_INS_CV_MAXU_SC_B + "cv_maxu_sc_h", // RISCV_INS_CV_MAXU_SC_H + "cv_max_b", // RISCV_INS_CV_MAX_B + "cv_max_h", // RISCV_INS_CV_MAX_H + "cv_max_sci_b", // RISCV_INS_CV_MAX_SCI_B + "cv_max_sci_h", // RISCV_INS_CV_MAX_SCI_H + "cv_max_sc_b", // RISCV_INS_CV_MAX_SC_B + "cv_max_sc_h", // RISCV_INS_CV_MAX_SC_H + "cv_min", // RISCV_INS_CV_MIN + "cv_minu", // RISCV_INS_CV_MINU + "cv_minu_b", // RISCV_INS_CV_MINU_B + "cv_minu_h", // RISCV_INS_CV_MINU_H + "cv_minu_sci_b", // RISCV_INS_CV_MINU_SCI_B + "cv_minu_sci_h", // RISCV_INS_CV_MINU_SCI_H + "cv_minu_sc_b", // RISCV_INS_CV_MINU_SC_B + "cv_minu_sc_h", // RISCV_INS_CV_MINU_SC_H + "cv_min_b", // RISCV_INS_CV_MIN_B + "cv_min_h", // RISCV_INS_CV_MIN_H + "cv_min_sci_b", // RISCV_INS_CV_MIN_SCI_B + "cv_min_sci_h", // RISCV_INS_CV_MIN_SCI_H + "cv_min_sc_b", // RISCV_INS_CV_MIN_SC_B + "cv_min_sc_h", // RISCV_INS_CV_MIN_SC_H + "cv_msu", // RISCV_INS_CV_MSU + "cv_mulhhsn", // RISCV_INS_CV_MULHHSN + "cv_mulhhsrn", // RISCV_INS_CV_MULHHSRN + "cv_mulhhun", // RISCV_INS_CV_MULHHUN + "cv_mulhhurn", // RISCV_INS_CV_MULHHURN + "cv_mulsn", // RISCV_INS_CV_MULSN + "cv_mulsrn", // RISCV_INS_CV_MULSRN + "cv_mulun", // RISCV_INS_CV_MULUN + "cv_mulurn", // RISCV_INS_CV_MULURN + "cv_or_b", // RISCV_INS_CV_OR_B + "cv_or_h", // RISCV_INS_CV_OR_H + "cv_or_sci_b", // RISCV_INS_CV_OR_SCI_B + "cv_or_sci_h", // RISCV_INS_CV_OR_SCI_H + "cv_or_sc_b", // RISCV_INS_CV_OR_SC_B + "cv_or_sc_h", // RISCV_INS_CV_OR_SC_H + "cv_pack", // RISCV_INS_CV_PACK + "cv_packhi_b", // RISCV_INS_CV_PACKHI_B + "cv_packlo_b", // RISCV_INS_CV_PACKLO_B + "cv_pack_h", // RISCV_INS_CV_PACK_H + "cv_ror", // RISCV_INS_CV_ROR + "cv_sb", // RISCV_INS_CV_SB + "cv_sdotsp_b", // RISCV_INS_CV_SDOTSP_B + "cv_sdotsp_h", // RISCV_INS_CV_SDOTSP_H + "cv_sdotsp_sci_b", // RISCV_INS_CV_SDOTSP_SCI_B + "cv_sdotsp_sci_h", // RISCV_INS_CV_SDOTSP_SCI_H + "cv_sdotsp_sc_b", // RISCV_INS_CV_SDOTSP_SC_B + "cv_sdotsp_sc_h", // RISCV_INS_CV_SDOTSP_SC_H + "cv_sdotup_b", // RISCV_INS_CV_SDOTUP_B + "cv_sdotup_h", // RISCV_INS_CV_SDOTUP_H + "cv_sdotup_sci_b", // RISCV_INS_CV_SDOTUP_SCI_B + "cv_sdotup_sci_h", // RISCV_INS_CV_SDOTUP_SCI_H + "cv_sdotup_sc_b", // RISCV_INS_CV_SDOTUP_SC_B + "cv_sdotup_sc_h", // RISCV_INS_CV_SDOTUP_SC_H + "cv_sdotusp_b", // RISCV_INS_CV_SDOTUSP_B + "cv_sdotusp_h", // RISCV_INS_CV_SDOTUSP_H + "cv_sdotusp_sci_b", // RISCV_INS_CV_SDOTUSP_SCI_B + "cv_sdotusp_sci_h", // RISCV_INS_CV_SDOTUSP_SCI_H + "cv_sdotusp_sc_b", // RISCV_INS_CV_SDOTUSP_SC_B + "cv_sdotusp_sc_h", // RISCV_INS_CV_SDOTUSP_SC_H + "cv_shuffle2_b", // RISCV_INS_CV_SHUFFLE2_B + "cv_shuffle2_h", // RISCV_INS_CV_SHUFFLE2_H + "cv_shufflei0_sci_b", // RISCV_INS_CV_SHUFFLEI0_SCI_B + "cv_shufflei1_sci_b", // RISCV_INS_CV_SHUFFLEI1_SCI_B + "cv_shufflei2_sci_b", // RISCV_INS_CV_SHUFFLEI2_SCI_B + "cv_shufflei3_sci_b", // RISCV_INS_CV_SHUFFLEI3_SCI_B + "cv_shuffle_b", // RISCV_INS_CV_SHUFFLE_B + "cv_shuffle_h", // RISCV_INS_CV_SHUFFLE_H + "cv_shuffle_sci_h", // RISCV_INS_CV_SHUFFLE_SCI_H + "cv_sh", // RISCV_INS_CV_SH + "cv_slet", // RISCV_INS_CV_SLET + "cv_sletu", // RISCV_INS_CV_SLETU + "cv_sll_b", // RISCV_INS_CV_SLL_B + "cv_sll_h", // RISCV_INS_CV_SLL_H + "cv_sll_sci_b", // RISCV_INS_CV_SLL_SCI_B + "cv_sll_sci_h", // RISCV_INS_CV_SLL_SCI_H + "cv_sll_sc_b", // RISCV_INS_CV_SLL_SC_B + "cv_sll_sc_h", // RISCV_INS_CV_SLL_SC_H + "cv_sra_b", // RISCV_INS_CV_SRA_B + "cv_sra_h", // RISCV_INS_CV_SRA_H + "cv_sra_sci_b", // RISCV_INS_CV_SRA_SCI_B + "cv_sra_sci_h", // RISCV_INS_CV_SRA_SCI_H + "cv_sra_sc_b", // RISCV_INS_CV_SRA_SC_B + "cv_sra_sc_h", // RISCV_INS_CV_SRA_SC_H + "cv_srl_b", // RISCV_INS_CV_SRL_B + "cv_srl_h", // RISCV_INS_CV_SRL_H + "cv_srl_sci_b", // RISCV_INS_CV_SRL_SCI_B + "cv_srl_sci_h", // RISCV_INS_CV_SRL_SCI_H + "cv_srl_sc_b", // RISCV_INS_CV_SRL_SC_B + "cv_srl_sc_h", // RISCV_INS_CV_SRL_SC_H + "cv_subn", // RISCV_INS_CV_SUBN + "cv_subnr", // RISCV_INS_CV_SUBNR + "cv_subrn", // RISCV_INS_CV_SUBRN + "cv_subrnr", // RISCV_INS_CV_SUBRNR + "cv_subrotmj", // RISCV_INS_CV_SUBROTMJ + "cv_subrotmj_div2", // RISCV_INS_CV_SUBROTMJ_DIV2 + "cv_subrotmj_div4", // RISCV_INS_CV_SUBROTMJ_DIV4 + "cv_subrotmj_div8", // RISCV_INS_CV_SUBROTMJ_DIV8 + "cv_subun", // RISCV_INS_CV_SUBUN + "cv_subunr", // RISCV_INS_CV_SUBUNR + "cv_suburn", // RISCV_INS_CV_SUBURN + "cv_suburnr", // RISCV_INS_CV_SUBURNR + "cv_sub_b", // RISCV_INS_CV_SUB_B + "cv_sub_div2", // RISCV_INS_CV_SUB_DIV2 + "cv_sub_div4", // RISCV_INS_CV_SUB_DIV4 + "cv_sub_div8", // RISCV_INS_CV_SUB_DIV8 + "cv_sub_h", // RISCV_INS_CV_SUB_H + "cv_sub_sci_b", // RISCV_INS_CV_SUB_SCI_B + "cv_sub_sci_h", // RISCV_INS_CV_SUB_SCI_H + "cv_sub_sc_b", // RISCV_INS_CV_SUB_SC_B + "cv_sub_sc_h", // RISCV_INS_CV_SUB_SC_H + "cv_sw", // RISCV_INS_CV_SW + "cv_xor_b", // RISCV_INS_CV_XOR_B + "cv_xor_h", // RISCV_INS_CV_XOR_H + "cv_xor_sci_b", // RISCV_INS_CV_XOR_SCI_B + "cv_xor_sci_h", // RISCV_INS_CV_XOR_SCI_H + "cv_xor_sc_b", // RISCV_INS_CV_XOR_SC_B + "cv_xor_sc_h", // RISCV_INS_CV_XOR_SC_H + "czero_eqz", // RISCV_INS_CZERO_EQZ + "czero_nez", // RISCV_INS_CZERO_NEZ + "c_add", // RISCV_INS_C_ADD + "c_addi", // RISCV_INS_C_ADDI + "c_addi16sp", // RISCV_INS_C_ADDI16SP + "c_addi4spn", // RISCV_INS_C_ADDI4SPN + "c_addiw", // RISCV_INS_C_ADDIW + "c_addw", // RISCV_INS_C_ADDW + "c_and", // RISCV_INS_C_AND + "c_andi", // RISCV_INS_C_ANDI + "c_beqz", // RISCV_INS_C_BEQZ + "c_bnez", // RISCV_INS_C_BNEZ + "c_ebreak", // RISCV_INS_C_EBREAK + "c_fld", // RISCV_INS_C_FLD + "c_fldsp", // RISCV_INS_C_FLDSP + "c_flw", // RISCV_INS_C_FLW + "c_flwsp", // RISCV_INS_C_FLWSP + "c_fsd", // RISCV_INS_C_FSD + "c_fsdsp", // RISCV_INS_C_FSDSP + "c_fsw", // RISCV_INS_C_FSW + "c_fswsp", // RISCV_INS_C_FSWSP + "c_j", // RISCV_INS_C_J + "c_jal", // RISCV_INS_C_JAL + "c_jalr", // RISCV_INS_C_JALR + "c_jr", // RISCV_INS_C_JR + "c_lbu", // RISCV_INS_C_LBU + "c_ld", // RISCV_INS_C_LD + "c_ldsp", // RISCV_INS_C_LDSP + "c_lh", // RISCV_INS_C_LH + "c_lhu", // RISCV_INS_C_LHU + "c_li", // RISCV_INS_C_LI + "c_lui", // RISCV_INS_C_LUI + "c_lw", // RISCV_INS_C_LW + "c_lwsp", // RISCV_INS_C_LWSP + "c_mul", // RISCV_INS_C_MUL + "c_mv", // RISCV_INS_C_MV + "c_nop", // RISCV_INS_C_NOP + "c_not", // RISCV_INS_C_NOT + "c_or", // RISCV_INS_C_OR + "c_sb", // RISCV_INS_C_SB + "c_sd", // RISCV_INS_C_SD + "c_sdsp", // RISCV_INS_C_SDSP + "c_sext_b", // RISCV_INS_C_SEXT_B + "c_sext_h", // RISCV_INS_C_SEXT_H + "c_sh", // RISCV_INS_C_SH + "c_slli", // RISCV_INS_C_SLLI + "c_slli64", // RISCV_INS_C_SLLI64 + "c_srai", // RISCV_INS_C_SRAI + "c_srai64", // RISCV_INS_C_SRAI64 + "c_srli", // RISCV_INS_C_SRLI + "c_srli64", // RISCV_INS_C_SRLI64 + "c_sspopchk", // RISCV_INS_C_SSPOPCHK + "c_sspush", // RISCV_INS_C_SSPUSH + "c_sub", // RISCV_INS_C_SUB + "c_subw", // RISCV_INS_C_SUBW + "c_sw", // RISCV_INS_C_SW + "c_swsp", // RISCV_INS_C_SWSP + "c_unimp", // RISCV_INS_C_UNIMP + "c_xor", // RISCV_INS_C_XOR + "c_zext_b", // RISCV_INS_C_ZEXT_B + "c_zext_h", // RISCV_INS_C_ZEXT_H + "c_zext_w", // RISCV_INS_C_ZEXT_W + "div", // RISCV_INS_DIV + "divu", // RISCV_INS_DIVU + "divuw", // RISCV_INS_DIVUW + "divw", // RISCV_INS_DIVW + "dret", // RISCV_INS_DRET + "ebreak", // RISCV_INS_EBREAK + "ecall", // RISCV_INS_ECALL + "fadd_d", // RISCV_INS_FADD_D + "fadd_h", // RISCV_INS_FADD_H + "fadd_s", // RISCV_INS_FADD_S + "fclass_d", // RISCV_INS_FCLASS_D + "fclass_h", // RISCV_INS_FCLASS_H + "fclass_s", // RISCV_INS_FCLASS_S + "fcvtmod_w_d", // RISCV_INS_FCVTMOD_W_D + "fcvt_bf16_s", // RISCV_INS_FCVT_BF16_S + "fcvt_d_h", // RISCV_INS_FCVT_D_H + "fcvt_d_l", // RISCV_INS_FCVT_D_L + "fcvt_d_lu", // RISCV_INS_FCVT_D_LU + "fcvt_d_s", // RISCV_INS_FCVT_D_S + "fcvt_d_w", // RISCV_INS_FCVT_D_W + "fcvt_d_wu", // RISCV_INS_FCVT_D_WU + "fcvt_h_d", // RISCV_INS_FCVT_H_D + "fcvt_h_l", // RISCV_INS_FCVT_H_L + "fcvt_h_lu", // RISCV_INS_FCVT_H_LU + "fcvt_h_s", // RISCV_INS_FCVT_H_S + "fcvt_h_w", // RISCV_INS_FCVT_H_W + "fcvt_h_wu", // RISCV_INS_FCVT_H_WU + "fcvt_lu_d", // RISCV_INS_FCVT_LU_D + "fcvt_lu_h", // RISCV_INS_FCVT_LU_H + "fcvt_lu_s", // RISCV_INS_FCVT_LU_S + "fcvt_l_d", // RISCV_INS_FCVT_L_D + "fcvt_l_h", // RISCV_INS_FCVT_L_H + "fcvt_l_s", // RISCV_INS_FCVT_L_S + "fcvt_s_bf16", // RISCV_INS_FCVT_S_BF16 + "fcvt_s_d", // RISCV_INS_FCVT_S_D + "fcvt_s_h", // RISCV_INS_FCVT_S_H + "fcvt_s_l", // RISCV_INS_FCVT_S_L + "fcvt_s_lu", // RISCV_INS_FCVT_S_LU + "fcvt_s_w", // RISCV_INS_FCVT_S_W + "fcvt_s_wu", // RISCV_INS_FCVT_S_WU + "fcvt_wu_d", // RISCV_INS_FCVT_WU_D + "fcvt_wu_h", // RISCV_INS_FCVT_WU_H + "fcvt_wu_s", // RISCV_INS_FCVT_WU_S + "fcvt_w_d", // RISCV_INS_FCVT_W_D + "fcvt_w_h", // RISCV_INS_FCVT_W_H + "fcvt_w_s", // RISCV_INS_FCVT_W_S + "fdiv_d", // RISCV_INS_FDIV_D + "fdiv_h", // RISCV_INS_FDIV_H + "fdiv_s", // RISCV_INS_FDIV_S + "fence", // RISCV_INS_FENCE + "fence_i", // RISCV_INS_FENCE_I + "fence_tso", // RISCV_INS_FENCE_TSO + "feq_d", // RISCV_INS_FEQ_D + "feq_h", // RISCV_INS_FEQ_H + "feq_s", // RISCV_INS_FEQ_S + "fleq_d", // RISCV_INS_FLEQ_D + "fleq_h", // RISCV_INS_FLEQ_H + "fleq_s", // RISCV_INS_FLEQ_S + "fle_d", // RISCV_INS_FLE_D + "fle_h", // RISCV_INS_FLE_H + "fle_s", // RISCV_INS_FLE_S + "fli_d", // RISCV_INS_FLI_D + "fli_h", // RISCV_INS_FLI_H + "fli_s", // RISCV_INS_FLI_S + "fltq_d", // RISCV_INS_FLTQ_D + "fltq_h", // RISCV_INS_FLTQ_H + "fltq_s", // RISCV_INS_FLTQ_S + "flt_d", // RISCV_INS_FLT_D + "flt_h", // RISCV_INS_FLT_H + "flt_s", // RISCV_INS_FLT_S + "fmadd_d", // RISCV_INS_FMADD_D + "fmadd_h", // RISCV_INS_FMADD_H + "fmadd_s", // RISCV_INS_FMADD_S + "fmaxm_d", // RISCV_INS_FMAXM_D + "fmaxm_h", // RISCV_INS_FMAXM_H + "fmaxm_s", // RISCV_INS_FMAXM_S + "fmax_d", // RISCV_INS_FMAX_D + "fmax_h", // RISCV_INS_FMAX_H + "fmax_s", // RISCV_INS_FMAX_S + "fminm_d", // RISCV_INS_FMINM_D + "fminm_h", // RISCV_INS_FMINM_H + "fminm_s", // RISCV_INS_FMINM_S + "fmin_d", // RISCV_INS_FMIN_D + "fmin_h", // RISCV_INS_FMIN_H + "fmin_s", // RISCV_INS_FMIN_S + "fmsub_d", // RISCV_INS_FMSUB_D + "fmsub_h", // RISCV_INS_FMSUB_H + "fmsub_s", // RISCV_INS_FMSUB_S + "fmul_d", // RISCV_INS_FMUL_D + "fmul_h", // RISCV_INS_FMUL_H + "fmul_s", // RISCV_INS_FMUL_S + "fmvh_x_d", // RISCV_INS_FMVH_X_D + "fmvp_d_x", // RISCV_INS_FMVP_D_X + "fmv_d_x", // RISCV_INS_FMV_D_X + "fmv_h_x", // RISCV_INS_FMV_H_X + "fmv_w_x", // RISCV_INS_FMV_W_X + "fmv_x_d", // RISCV_INS_FMV_X_D + "fmv_x_h", // RISCV_INS_FMV_X_H + "fmv_x_w", // RISCV_INS_FMV_X_W + "fnmadd_d", // RISCV_INS_FNMADD_D + "fnmadd_h", // RISCV_INS_FNMADD_H + "fnmadd_s", // RISCV_INS_FNMADD_S + "fnmsub_d", // RISCV_INS_FNMSUB_D + "fnmsub_h", // RISCV_INS_FNMSUB_H + "fnmsub_s", // RISCV_INS_FNMSUB_S + "froundnx_d", // RISCV_INS_FROUNDNX_D + "froundnx_h", // RISCV_INS_FROUNDNX_H + "froundnx_s", // RISCV_INS_FROUNDNX_S + "fround_d", // RISCV_INS_FROUND_D + "fround_h", // RISCV_INS_FROUND_H + "fround_s", // RISCV_INS_FROUND_S + "fsgnjn_d", // RISCV_INS_FSGNJN_D + "fsgnjn_h", // RISCV_INS_FSGNJN_H + "fsgnjn_s", // RISCV_INS_FSGNJN_S + "fsgnjx_d", // RISCV_INS_FSGNJX_D + "fsgnjx_h", // RISCV_INS_FSGNJX_H + "fsgnjx_s", // RISCV_INS_FSGNJX_S + "fsgnj_d", // RISCV_INS_FSGNJ_D + "fsgnj_h", // RISCV_INS_FSGNJ_H + "fsgnj_s", // RISCV_INS_FSGNJ_S + "fsqrt_d", // RISCV_INS_FSQRT_D + "fsqrt_h", // RISCV_INS_FSQRT_H + "fsqrt_s", // RISCV_INS_FSQRT_S + "fsub_d", // RISCV_INS_FSUB_D + "fsub_h", // RISCV_INS_FSUB_H + "fsub_s", // RISCV_INS_FSUB_S + "hfence_gvma", // RISCV_INS_HFENCE_GVMA + "hfence_vvma", // RISCV_INS_HFENCE_VVMA + "hinval_gvma", // RISCV_INS_HINVAL_GVMA + "hinval_vvma", // RISCV_INS_HINVAL_VVMA + "hlvx_hu", // RISCV_INS_HLVX_HU + "hlvx_wu", // RISCV_INS_HLVX_WU + "hlv_b", // RISCV_INS_HLV_B + "hlv_bu", // RISCV_INS_HLV_BU + "hlv_d", // RISCV_INS_HLV_D + "hlv_h", // RISCV_INS_HLV_H + "hlv_hu", // RISCV_INS_HLV_HU + "hlv_w", // RISCV_INS_HLV_W + "hlv_wu", // RISCV_INS_HLV_WU + "hsv_b", // RISCV_INS_HSV_B + "hsv_d", // RISCV_INS_HSV_D + "hsv_h", // RISCV_INS_HSV_H + "hsv_w", // RISCV_INS_HSV_W + "jal", // RISCV_INS_JAL + "lr_d", // RISCV_INS_LR_D + "lr_d_aq", // RISCV_INS_LR_D_AQ + "lr_d_aqrl", // RISCV_INS_LR_D_AQRL + "lr_d_rl", // RISCV_INS_LR_D_RL + "lr_w", // RISCV_INS_LR_W + "lr_w_aq", // RISCV_INS_LR_W_AQ + "lr_w_aqrl", // RISCV_INS_LR_W_AQRL + "lr_w_rl", // RISCV_INS_LR_W_RL + "lui", // RISCV_INS_LUI + "max", // RISCV_INS_MAX + "maxu", // RISCV_INS_MAXU + "min", // RISCV_INS_MIN + "minu", // RISCV_INS_MINU + "mop_r_0", // RISCV_INS_MOP_R_0 + "mop_r_1", // RISCV_INS_MOP_R_1 + "mop_r_10", // RISCV_INS_MOP_R_10 + "mop_r_11", // RISCV_INS_MOP_R_11 + "mop_r_12", // RISCV_INS_MOP_R_12 + "mop_r_13", // RISCV_INS_MOP_R_13 + "mop_r_14", // RISCV_INS_MOP_R_14 + "mop_r_15", // RISCV_INS_MOP_R_15 + "mop_r_16", // RISCV_INS_MOP_R_16 + "mop_r_17", // RISCV_INS_MOP_R_17 + "mop_r_18", // RISCV_INS_MOP_R_18 + "mop_r_19", // RISCV_INS_MOP_R_19 + "mop_r_2", // RISCV_INS_MOP_R_2 + "mop_r_20", // RISCV_INS_MOP_R_20 + "mop_r_21", // RISCV_INS_MOP_R_21 + "mop_r_22", // RISCV_INS_MOP_R_22 + "mop_r_23", // RISCV_INS_MOP_R_23 + "mop_r_24", // RISCV_INS_MOP_R_24 + "mop_r_25", // RISCV_INS_MOP_R_25 + "mop_r_26", // RISCV_INS_MOP_R_26 + "mop_r_27", // RISCV_INS_MOP_R_27 + "mop_r_28", // RISCV_INS_MOP_R_28 + "mop_r_29", // RISCV_INS_MOP_R_29 + "mop_r_3", // RISCV_INS_MOP_R_3 + "mop_r_30", // RISCV_INS_MOP_R_30 + "mop_r_31", // RISCV_INS_MOP_R_31 + "mop_r_4", // RISCV_INS_MOP_R_4 + "mop_r_5", // RISCV_INS_MOP_R_5 + "mop_r_6", // RISCV_INS_MOP_R_6 + "mop_r_7", // RISCV_INS_MOP_R_7 + "mop_r_8", // RISCV_INS_MOP_R_8 + "mop_r_9", // RISCV_INS_MOP_R_9 + "mop_rr_0", // RISCV_INS_MOP_RR_0 + "mop_rr_1", // RISCV_INS_MOP_RR_1 + "mop_rr_2", // RISCV_INS_MOP_RR_2 + "mop_rr_3", // RISCV_INS_MOP_RR_3 + "mop_rr_4", // RISCV_INS_MOP_RR_4 + "mop_rr_5", // RISCV_INS_MOP_RR_5 + "mop_rr_6", // RISCV_INS_MOP_RR_6 + "mop_rr_7", // RISCV_INS_MOP_RR_7 + "mret", // RISCV_INS_MRET + "mul", // RISCV_INS_MUL + "mulh", // RISCV_INS_MULH + "mulhsu", // RISCV_INS_MULHSU + "mulhu", // RISCV_INS_MULHU + "mulw", // RISCV_INS_MULW + "or", // RISCV_INS_OR + "orc_b", // RISCV_INS_ORC_B + "ori", // RISCV_INS_ORI + "orn", // RISCV_INS_ORN + "pack", // RISCV_INS_PACK + "packh", // RISCV_INS_PACKH + "packw", // RISCV_INS_PACKW + "prefetch_i", // RISCV_INS_PREFETCH_I + "prefetch_r", // RISCV_INS_PREFETCH_R + "prefetch_w", // RISCV_INS_PREFETCH_W + "rem", // RISCV_INS_REM + "remu", // RISCV_INS_REMU + "remuw", // RISCV_INS_REMUW + "remw", // RISCV_INS_REMW + "rev8", // RISCV_INS_REV8 + "rol", // RISCV_INS_ROL + "rolw", // RISCV_INS_ROLW + "ror", // RISCV_INS_ROR + "rori", // RISCV_INS_RORI + "roriw", // RISCV_INS_RORIW + "rorw", // RISCV_INS_RORW + "sc_d", // RISCV_INS_SC_D + "sc_d_aq", // RISCV_INS_SC_D_AQ + "sc_d_aqrl", // RISCV_INS_SC_D_AQRL + "sc_d_rl", // RISCV_INS_SC_D_RL + "sc_w", // RISCV_INS_SC_W + "sc_w_aq", // RISCV_INS_SC_W_AQ + "sc_w_aqrl", // RISCV_INS_SC_W_AQRL + "sc_w_rl", // RISCV_INS_SC_W_RL + "sfence_inval_ir", // RISCV_INS_SFENCE_INVAL_IR + "sfence_vma", // RISCV_INS_SFENCE_VMA + "sfence_w_inval", // RISCV_INS_SFENCE_W_INVAL + "sh1add", // RISCV_INS_SH1ADD + "sh1add_uw", // RISCV_INS_SH1ADD_UW + "sh2add", // RISCV_INS_SH2ADD + "sh2add_uw", // RISCV_INS_SH2ADD_UW + "sh3add", // RISCV_INS_SH3ADD + "sh3add_uw", // RISCV_INS_SH3ADD_UW + "sha256sig0", // RISCV_INS_SHA256SIG0 + "sha256sig1", // RISCV_INS_SHA256SIG1 + "sha256sum0", // RISCV_INS_SHA256SUM0 + "sha256sum1", // RISCV_INS_SHA256SUM1 + "sha512sig0", // RISCV_INS_SHA512SIG0 + "sha512sig0h", // RISCV_INS_SHA512SIG0H + "sha512sig0l", // RISCV_INS_SHA512SIG0L + "sha512sig1", // RISCV_INS_SHA512SIG1 + "sha512sig1h", // RISCV_INS_SHA512SIG1H + "sha512sig1l", // RISCV_INS_SHA512SIG1L + "sha512sum0", // RISCV_INS_SHA512SUM0 + "sha512sum0r", // RISCV_INS_SHA512SUM0R + "sha512sum1", // RISCV_INS_SHA512SUM1 + "sha512sum1r", // RISCV_INS_SHA512SUM1R + "sinval_vma", // RISCV_INS_SINVAL_VMA + "sll", // RISCV_INS_SLL + "slli", // RISCV_INS_SLLI + "slliw", // RISCV_INS_SLLIW + "slli_uw", // RISCV_INS_SLLI_UW + "sllw", // RISCV_INS_SLLW + "slt", // RISCV_INS_SLT + "slti", // RISCV_INS_SLTI + "sltiu", // RISCV_INS_SLTIU + "sltu", // RISCV_INS_SLTU + "sm3p0", // RISCV_INS_SM3P0 + "sm3p1", // RISCV_INS_SM3P1 + "sm4ed", // RISCV_INS_SM4ED + "sm4ks", // RISCV_INS_SM4KS + "sra", // RISCV_INS_SRA + "srai", // RISCV_INS_SRAI + "sraiw", // RISCV_INS_SRAIW + "sraw", // RISCV_INS_SRAW + "sret", // RISCV_INS_SRET + "srl", // RISCV_INS_SRL + "srli", // RISCV_INS_SRLI + "srliw", // RISCV_INS_SRLIW + "srlw", // RISCV_INS_SRLW + "ssamoswap_d", // RISCV_INS_SSAMOSWAP_D + "ssamoswap_d_aq", // RISCV_INS_SSAMOSWAP_D_AQ + "ssamoswap_d_aqrl", // RISCV_INS_SSAMOSWAP_D_AQRL + "ssamoswap_d_rl", // RISCV_INS_SSAMOSWAP_D_RL + "ssamoswap_w", // RISCV_INS_SSAMOSWAP_W + "ssamoswap_w_aq", // RISCV_INS_SSAMOSWAP_W_AQ + "ssamoswap_w_aqrl", // RISCV_INS_SSAMOSWAP_W_AQRL + "ssamoswap_w_rl", // RISCV_INS_SSAMOSWAP_W_RL + "sspopchk", // RISCV_INS_SSPOPCHK + "sspush", // RISCV_INS_SSPUSH + "ssrdp", // RISCV_INS_SSRDP + "sub", // RISCV_INS_SUB + "subw", // RISCV_INS_SUBW + "th_vmaqasu_vv", // RISCV_INS_TH_VMAQASU_VV + "th_vmaqasu_vx", // RISCV_INS_TH_VMAQASU_VX + "th_vmaqaus_vx", // RISCV_INS_TH_VMAQAUS_VX + "th_vmaqau_vv", // RISCV_INS_TH_VMAQAU_VV + "th_vmaqau_vx", // RISCV_INS_TH_VMAQAU_VX + "th_vmaqa_vv", // RISCV_INS_TH_VMAQA_VV + "th_vmaqa_vx", // RISCV_INS_TH_VMAQA_VX + "th_addsl", // RISCV_INS_TH_ADDSL + "th_dcache_call", // RISCV_INS_TH_DCACHE_CALL + "th_dcache_ciall", // RISCV_INS_TH_DCACHE_CIALL + "th_dcache_cipa", // RISCV_INS_TH_DCACHE_CIPA + "th_dcache_cisw", // RISCV_INS_TH_DCACHE_CISW + "th_dcache_civa", // RISCV_INS_TH_DCACHE_CIVA + "th_dcache_cpa", // RISCV_INS_TH_DCACHE_CPA + "th_dcache_cpal1", // RISCV_INS_TH_DCACHE_CPAL1 + "th_dcache_csw", // RISCV_INS_TH_DCACHE_CSW + "th_dcache_cva", // RISCV_INS_TH_DCACHE_CVA + "th_dcache_cval1", // RISCV_INS_TH_DCACHE_CVAL1 + "th_dcache_iall", // RISCV_INS_TH_DCACHE_IALL + "th_dcache_ipa", // RISCV_INS_TH_DCACHE_IPA + "th_dcache_isw", // RISCV_INS_TH_DCACHE_ISW + "th_dcache_iva", // RISCV_INS_TH_DCACHE_IVA + "th_ext", // RISCV_INS_TH_EXT + "th_extu", // RISCV_INS_TH_EXTU + "th_ff0", // RISCV_INS_TH_FF0 + "th_ff1", // RISCV_INS_TH_FF1 + "th_flrd", // RISCV_INS_TH_FLRD + "th_flrw", // RISCV_INS_TH_FLRW + "th_flurd", // RISCV_INS_TH_FLURD + "th_flurw", // RISCV_INS_TH_FLURW + "th_fsrd", // RISCV_INS_TH_FSRD + "th_fsrw", // RISCV_INS_TH_FSRW + "th_fsurd", // RISCV_INS_TH_FSURD + "th_fsurw", // RISCV_INS_TH_FSURW + "th_icache_iall", // RISCV_INS_TH_ICACHE_IALL + "th_icache_ialls", // RISCV_INS_TH_ICACHE_IALLS + "th_icache_ipa", // RISCV_INS_TH_ICACHE_IPA + "th_icache_iva", // RISCV_INS_TH_ICACHE_IVA + "th_l2cache_call", // RISCV_INS_TH_L2CACHE_CALL + "th_l2cache_ciall", // RISCV_INS_TH_L2CACHE_CIALL + "th_l2cache_iall", // RISCV_INS_TH_L2CACHE_IALL + "th_lbia", // RISCV_INS_TH_LBIA + "th_lbib", // RISCV_INS_TH_LBIB + "th_lbuia", // RISCV_INS_TH_LBUIA + "th_lbuib", // RISCV_INS_TH_LBUIB + "th_ldd", // RISCV_INS_TH_LDD + "th_ldia", // RISCV_INS_TH_LDIA + "th_ldib", // RISCV_INS_TH_LDIB + "th_lhia", // RISCV_INS_TH_LHIA + "th_lhib", // RISCV_INS_TH_LHIB + "th_lhuia", // RISCV_INS_TH_LHUIA + "th_lhuib", // RISCV_INS_TH_LHUIB + "th_lrb", // RISCV_INS_TH_LRB + "th_lrbu", // RISCV_INS_TH_LRBU + "th_lrd", // RISCV_INS_TH_LRD + "th_lrh", // RISCV_INS_TH_LRH + "th_lrhu", // RISCV_INS_TH_LRHU + "th_lrw", // RISCV_INS_TH_LRW + "th_lrwu", // RISCV_INS_TH_LRWU + "th_lurb", // RISCV_INS_TH_LURB + "th_lurbu", // RISCV_INS_TH_LURBU + "th_lurd", // RISCV_INS_TH_LURD + "th_lurh", // RISCV_INS_TH_LURH + "th_lurhu", // RISCV_INS_TH_LURHU + "th_lurw", // RISCV_INS_TH_LURW + "th_lurwu", // RISCV_INS_TH_LURWU + "th_lwd", // RISCV_INS_TH_LWD + "th_lwia", // RISCV_INS_TH_LWIA + "th_lwib", // RISCV_INS_TH_LWIB + "th_lwud", // RISCV_INS_TH_LWUD + "th_lwuia", // RISCV_INS_TH_LWUIA + "th_lwuib", // RISCV_INS_TH_LWUIB + "th_mula", // RISCV_INS_TH_MULA + "th_mulah", // RISCV_INS_TH_MULAH + "th_mulaw", // RISCV_INS_TH_MULAW + "th_muls", // RISCV_INS_TH_MULS + "th_mulsh", // RISCV_INS_TH_MULSH + "th_mulsw", // RISCV_INS_TH_MULSW + "th_mveqz", // RISCV_INS_TH_MVEQZ + "th_mvnez", // RISCV_INS_TH_MVNEZ + "th_rev", // RISCV_INS_TH_REV + "th_revw", // RISCV_INS_TH_REVW + "th_sbia", // RISCV_INS_TH_SBIA + "th_sbib", // RISCV_INS_TH_SBIB + "th_sdd", // RISCV_INS_TH_SDD + "th_sdia", // RISCV_INS_TH_SDIA + "th_sdib", // RISCV_INS_TH_SDIB + "th_sfence_vmas", // RISCV_INS_TH_SFENCE_VMAS + "th_shia", // RISCV_INS_TH_SHIA + "th_shib", // RISCV_INS_TH_SHIB + "th_srb", // RISCV_INS_TH_SRB + "th_srd", // RISCV_INS_TH_SRD + "th_srh", // RISCV_INS_TH_SRH + "th_srri", // RISCV_INS_TH_SRRI + "th_srriw", // RISCV_INS_TH_SRRIW + "th_srw", // RISCV_INS_TH_SRW + "th_surb", // RISCV_INS_TH_SURB + "th_surd", // RISCV_INS_TH_SURD + "th_surh", // RISCV_INS_TH_SURH + "th_surw", // RISCV_INS_TH_SURW + "th_swd", // RISCV_INS_TH_SWD + "th_swia", // RISCV_INS_TH_SWIA + "th_swib", // RISCV_INS_TH_SWIB + "th_sync", // RISCV_INS_TH_SYNC + "th_sync_i", // RISCV_INS_TH_SYNC_I + "th_sync_is", // RISCV_INS_TH_SYNC_IS + "th_sync_s", // RISCV_INS_TH_SYNC_S + "th_tst", // RISCV_INS_TH_TST + "th_tstnbz", // RISCV_INS_TH_TSTNBZ + "unimp", // RISCV_INS_UNIMP + "unzip", // RISCV_INS_UNZIP + "vaaddu_vv", // RISCV_INS_VAADDU_VV + "vaaddu_vx", // RISCV_INS_VAADDU_VX + "vaadd_vv", // RISCV_INS_VAADD_VV + "vaadd_vx", // RISCV_INS_VAADD_VX + "vadc_vim", // RISCV_INS_VADC_VIM + "vadc_vvm", // RISCV_INS_VADC_VVM + "vadc_vxm", // RISCV_INS_VADC_VXM + "vadd_vi", // RISCV_INS_VADD_VI + "vadd_vv", // RISCV_INS_VADD_VV + "vadd_vx", // RISCV_INS_VADD_VX + "vaesdf_vs", // RISCV_INS_VAESDF_VS + "vaesdf_vv", // RISCV_INS_VAESDF_VV + "vaesdm_vs", // RISCV_INS_VAESDM_VS + "vaesdm_vv", // RISCV_INS_VAESDM_VV + "vaesef_vs", // RISCV_INS_VAESEF_VS + "vaesef_vv", // RISCV_INS_VAESEF_VV + "vaesem_vs", // RISCV_INS_VAESEM_VS + "vaesem_vv", // RISCV_INS_VAESEM_VV + "vaeskf1_vi", // RISCV_INS_VAESKF1_VI + "vaeskf2_vi", // RISCV_INS_VAESKF2_VI + "vaesz_vs", // RISCV_INS_VAESZ_VS + "vandn_vv", // RISCV_INS_VANDN_VV + "vandn_vx", // RISCV_INS_VANDN_VX + "vand_vi", // RISCV_INS_VAND_VI + "vand_vv", // RISCV_INS_VAND_VV + "vand_vx", // RISCV_INS_VAND_VX + "vasubu_vv", // RISCV_INS_VASUBU_VV + "vasubu_vx", // RISCV_INS_VASUBU_VX + "vasub_vv", // RISCV_INS_VASUB_VV + "vasub_vx", // RISCV_INS_VASUB_VX + "vbrev8_v", // RISCV_INS_VBREV8_V + "vbrev_v", // RISCV_INS_VBREV_V + "vclmulh_vv", // RISCV_INS_VCLMULH_VV + "vclmulh_vx", // RISCV_INS_VCLMULH_VX + "vclmul_vv", // RISCV_INS_VCLMUL_VV + "vclmul_vx", // RISCV_INS_VCLMUL_VX + "vclz_v", // RISCV_INS_VCLZ_V + "vcompress_vm", // RISCV_INS_VCOMPRESS_VM + "vcpop_m", // RISCV_INS_VCPOP_M + "vcpop_v", // RISCV_INS_VCPOP_V + "vctz_v", // RISCV_INS_VCTZ_V + "sf_vc_fv", // RISCV_INS_SF_VC_FV + "sf_vc_fvv", // RISCV_INS_SF_VC_FVV + "sf_vc_fvw", // RISCV_INS_SF_VC_FVW + "sf_vc_i", // RISCV_INS_SF_VC_I + "sf_vc_iv", // RISCV_INS_SF_VC_IV + "sf_vc_ivv", // RISCV_INS_SF_VC_IVV + "sf_vc_ivw", // RISCV_INS_SF_VC_IVW + "sf_vc_vv", // RISCV_INS_SF_VC_VV + "sf_vc_vvv", // RISCV_INS_SF_VC_VVV + "sf_vc_vvw", // RISCV_INS_SF_VC_VVW + "sf_vc_v_fv", // RISCV_INS_SF_VC_V_FV + "sf_vc_v_fvv", // RISCV_INS_SF_VC_V_FVV + "sf_vc_v_fvw", // RISCV_INS_SF_VC_V_FVW + "sf_vc_v_i", // RISCV_INS_SF_VC_V_I + "sf_vc_v_iv", // RISCV_INS_SF_VC_V_IV + "sf_vc_v_ivv", // RISCV_INS_SF_VC_V_IVV + "sf_vc_v_ivw", // RISCV_INS_SF_VC_V_IVW + "sf_vc_v_vv", // RISCV_INS_SF_VC_V_VV + "sf_vc_v_vvv", // RISCV_INS_SF_VC_V_VVV + "sf_vc_v_vvw", // RISCV_INS_SF_VC_V_VVW + "sf_vc_v_x", // RISCV_INS_SF_VC_V_X + "sf_vc_v_xv", // RISCV_INS_SF_VC_V_XV + "sf_vc_v_xvv", // RISCV_INS_SF_VC_V_XVV + "sf_vc_v_xvw", // RISCV_INS_SF_VC_V_XVW + "sf_vc_x", // RISCV_INS_SF_VC_X + "sf_vc_xv", // RISCV_INS_SF_VC_XV + "sf_vc_xvv", // RISCV_INS_SF_VC_XVV + "sf_vc_xvw", // RISCV_INS_SF_VC_XVW + "vdivu_vv", // RISCV_INS_VDIVU_VV + "vdivu_vx", // RISCV_INS_VDIVU_VX + "vdiv_vv", // RISCV_INS_VDIV_VV + "vdiv_vx", // RISCV_INS_VDIV_VX + "vfadd_vf", // RISCV_INS_VFADD_VF + "vfadd_vv", // RISCV_INS_VFADD_VV + "vfclass_v", // RISCV_INS_VFCLASS_V + "vfcvt_f_xu_v", // RISCV_INS_VFCVT_F_XU_V + "vfcvt_f_x_v", // RISCV_INS_VFCVT_F_X_V + "vfcvt_rtz_xu_f_v", // RISCV_INS_VFCVT_RTZ_XU_F_V + "vfcvt_rtz_x_f_v", // RISCV_INS_VFCVT_RTZ_X_F_V + "vfcvt_xu_f_v", // RISCV_INS_VFCVT_XU_F_V + "vfcvt_x_f_v", // RISCV_INS_VFCVT_X_F_V + "vfdiv_vf", // RISCV_INS_VFDIV_VF + "vfdiv_vv", // RISCV_INS_VFDIV_VV + "vfirst_m", // RISCV_INS_VFIRST_M + "vfmacc_vf", // RISCV_INS_VFMACC_VF + "vfmacc_vv", // RISCV_INS_VFMACC_VV + "vfmadd_vf", // RISCV_INS_VFMADD_VF + "vfmadd_vv", // RISCV_INS_VFMADD_VV + "vfmax_vf", // RISCV_INS_VFMAX_VF + "vfmax_vv", // RISCV_INS_VFMAX_VV + "vfmerge_vfm", // RISCV_INS_VFMERGE_VFM + "vfmin_vf", // RISCV_INS_VFMIN_VF + "vfmin_vv", // RISCV_INS_VFMIN_VV + "vfmsac_vf", // RISCV_INS_VFMSAC_VF + "vfmsac_vv", // RISCV_INS_VFMSAC_VV + "vfmsub_vf", // RISCV_INS_VFMSUB_VF + "vfmsub_vv", // RISCV_INS_VFMSUB_VV + "vfmul_vf", // RISCV_INS_VFMUL_VF + "vfmul_vv", // RISCV_INS_VFMUL_VV + "vfmv_f_s", // RISCV_INS_VFMV_F_S + "vfmv_s_f", // RISCV_INS_VFMV_S_F + "vfmv_v_f", // RISCV_INS_VFMV_V_F + "vfncvtbf16_f_f_w", // RISCV_INS_VFNCVTBF16_F_F_W + "vfncvt_f_f_w", // RISCV_INS_VFNCVT_F_F_W + "vfncvt_f_xu_w", // RISCV_INS_VFNCVT_F_XU_W + "vfncvt_f_x_w", // RISCV_INS_VFNCVT_F_X_W + "vfncvt_rod_f_f_w", // RISCV_INS_VFNCVT_ROD_F_F_W + "vfncvt_rtz_xu_f_w", // RISCV_INS_VFNCVT_RTZ_XU_F_W + "vfncvt_rtz_x_f_w", // RISCV_INS_VFNCVT_RTZ_X_F_W + "vfncvt_xu_f_w", // RISCV_INS_VFNCVT_XU_F_W + "vfncvt_x_f_w", // RISCV_INS_VFNCVT_X_F_W + "vfnmacc_vf", // RISCV_INS_VFNMACC_VF + "vfnmacc_vv", // RISCV_INS_VFNMACC_VV + "vfnmadd_vf", // RISCV_INS_VFNMADD_VF + "vfnmadd_vv", // RISCV_INS_VFNMADD_VV + "vfnmsac_vf", // RISCV_INS_VFNMSAC_VF + "vfnmsac_vv", // RISCV_INS_VFNMSAC_VV + "vfnmsub_vf", // RISCV_INS_VFNMSUB_VF + "vfnmsub_vv", // RISCV_INS_VFNMSUB_VV + "sf_vfnrclip_xu_f_qf", // RISCV_INS_SF_VFNRCLIP_XU_F_QF + "sf_vfnrclip_x_f_qf", // RISCV_INS_SF_VFNRCLIP_X_F_QF + "vfrdiv_vf", // RISCV_INS_VFRDIV_VF + "vfrec7_v", // RISCV_INS_VFREC7_V + "vfredmax_vs", // RISCV_INS_VFREDMAX_VS + "vfredmin_vs", // RISCV_INS_VFREDMIN_VS + "vfredosum_vs", // RISCV_INS_VFREDOSUM_VS + "vfredusum_vs", // RISCV_INS_VFREDUSUM_VS + "vfrsqrt7_v", // RISCV_INS_VFRSQRT7_V + "vfrsub_vf", // RISCV_INS_VFRSUB_VF + "vfsgnjn_vf", // RISCV_INS_VFSGNJN_VF + "vfsgnjn_vv", // RISCV_INS_VFSGNJN_VV + "vfsgnjx_vf", // RISCV_INS_VFSGNJX_VF + "vfsgnjx_vv", // RISCV_INS_VFSGNJX_VV + "vfsgnj_vf", // RISCV_INS_VFSGNJ_VF + "vfsgnj_vv", // RISCV_INS_VFSGNJ_VV + "vfslide1down_vf", // RISCV_INS_VFSLIDE1DOWN_VF + "vfslide1up_vf", // RISCV_INS_VFSLIDE1UP_VF + "vfsqrt_v", // RISCV_INS_VFSQRT_V + "vfsub_vf", // RISCV_INS_VFSUB_VF + "vfsub_vv", // RISCV_INS_VFSUB_VV + "vfwadd_vf", // RISCV_INS_VFWADD_VF + "vfwadd_vv", // RISCV_INS_VFWADD_VV + "vfwadd_wf", // RISCV_INS_VFWADD_WF + "vfwadd_wv", // RISCV_INS_VFWADD_WV + "vfwcvtbf16_f_f_v", // RISCV_INS_VFWCVTBF16_F_F_V + "vfwcvt_f_f_v", // RISCV_INS_VFWCVT_F_F_V + "vfwcvt_f_xu_v", // RISCV_INS_VFWCVT_F_XU_V + "vfwcvt_f_x_v", // RISCV_INS_VFWCVT_F_X_V + "vfwcvt_rtz_xu_f_v", // RISCV_INS_VFWCVT_RTZ_XU_F_V + "vfwcvt_rtz_x_f_v", // RISCV_INS_VFWCVT_RTZ_X_F_V + "vfwcvt_xu_f_v", // RISCV_INS_VFWCVT_XU_F_V + "vfwcvt_x_f_v", // RISCV_INS_VFWCVT_X_F_V + "vfwmaccbf16_vf", // RISCV_INS_VFWMACCBF16_VF + "vfwmaccbf16_vv", // RISCV_INS_VFWMACCBF16_VV + "sf_vfwmacc_4x4x4", // RISCV_INS_SF_VFWMACC_4X4X4 + "vfwmacc_vf", // RISCV_INS_VFWMACC_VF + "vfwmacc_vv", // RISCV_INS_VFWMACC_VV + "vfwmsac_vf", // RISCV_INS_VFWMSAC_VF + "vfwmsac_vv", // RISCV_INS_VFWMSAC_VV + "vfwmul_vf", // RISCV_INS_VFWMUL_VF + "vfwmul_vv", // RISCV_INS_VFWMUL_VV + "vfwnmacc_vf", // RISCV_INS_VFWNMACC_VF + "vfwnmacc_vv", // RISCV_INS_VFWNMACC_VV + "vfwnmsac_vf", // RISCV_INS_VFWNMSAC_VF + "vfwnmsac_vv", // RISCV_INS_VFWNMSAC_VV + "vfwredosum_vs", // RISCV_INS_VFWREDOSUM_VS + "vfwredusum_vs", // RISCV_INS_VFWREDUSUM_VS + "vfwsub_vf", // RISCV_INS_VFWSUB_VF + "vfwsub_vv", // RISCV_INS_VFWSUB_VV + "vfwsub_wf", // RISCV_INS_VFWSUB_WF + "vfwsub_wv", // RISCV_INS_VFWSUB_WV + "vghsh_vv", // RISCV_INS_VGHSH_VV + "vgmul_vv", // RISCV_INS_VGMUL_VV + "vid_v", // RISCV_INS_VID_V + "viota_m", // RISCV_INS_VIOTA_M + "vl1re16_v", // RISCV_INS_VL1RE16_V + "vl1re32_v", // RISCV_INS_VL1RE32_V + "vl1re64_v", // RISCV_INS_VL1RE64_V + "vl1re8_v", // RISCV_INS_VL1RE8_V + "vl2re16_v", // RISCV_INS_VL2RE16_V + "vl2re32_v", // RISCV_INS_VL2RE32_V + "vl2re64_v", // RISCV_INS_VL2RE64_V + "vl2re8_v", // RISCV_INS_VL2RE8_V + "vl4re16_v", // RISCV_INS_VL4RE16_V + "vl4re32_v", // RISCV_INS_VL4RE32_V + "vl4re64_v", // RISCV_INS_VL4RE64_V + "vl4re8_v", // RISCV_INS_VL4RE8_V + "vl8re16_v", // RISCV_INS_VL8RE16_V + "vl8re32_v", // RISCV_INS_VL8RE32_V + "vl8re64_v", // RISCV_INS_VL8RE64_V + "vl8re8_v", // RISCV_INS_VL8RE8_V + "vle16ff_v", // RISCV_INS_VLE16FF_V + "vle16_v", // RISCV_INS_VLE16_V + "vle32ff_v", // RISCV_INS_VLE32FF_V + "vle32_v", // RISCV_INS_VLE32_V + "vle64ff_v", // RISCV_INS_VLE64FF_V + "vle64_v", // RISCV_INS_VLE64_V + "vle8ff_v", // RISCV_INS_VLE8FF_V + "vle8_v", // RISCV_INS_VLE8_V + "vlm_v", // RISCV_INS_VLM_V + "vloxei16_v", // RISCV_INS_VLOXEI16_V + "vloxei32_v", // RISCV_INS_VLOXEI32_V + "vloxei64_v", // RISCV_INS_VLOXEI64_V + "vloxei8_v", // RISCV_INS_VLOXEI8_V + "vloxseg2ei16_v", // RISCV_INS_VLOXSEG2EI16_V + "vloxseg2ei32_v", // RISCV_INS_VLOXSEG2EI32_V + "vloxseg2ei64_v", // RISCV_INS_VLOXSEG2EI64_V + "vloxseg2ei8_v", // RISCV_INS_VLOXSEG2EI8_V + "vloxseg3ei16_v", // RISCV_INS_VLOXSEG3EI16_V + "vloxseg3ei32_v", // RISCV_INS_VLOXSEG3EI32_V + "vloxseg3ei64_v", // RISCV_INS_VLOXSEG3EI64_V + "vloxseg3ei8_v", // RISCV_INS_VLOXSEG3EI8_V + "vloxseg4ei16_v", // RISCV_INS_VLOXSEG4EI16_V + "vloxseg4ei32_v", // RISCV_INS_VLOXSEG4EI32_V + "vloxseg4ei64_v", // RISCV_INS_VLOXSEG4EI64_V + "vloxseg4ei8_v", // RISCV_INS_VLOXSEG4EI8_V + "vloxseg5ei16_v", // RISCV_INS_VLOXSEG5EI16_V + "vloxseg5ei32_v", // RISCV_INS_VLOXSEG5EI32_V + "vloxseg5ei64_v", // RISCV_INS_VLOXSEG5EI64_V + "vloxseg5ei8_v", // RISCV_INS_VLOXSEG5EI8_V + "vloxseg6ei16_v", // RISCV_INS_VLOXSEG6EI16_V + "vloxseg6ei32_v", // RISCV_INS_VLOXSEG6EI32_V + "vloxseg6ei64_v", // RISCV_INS_VLOXSEG6EI64_V + "vloxseg6ei8_v", // RISCV_INS_VLOXSEG6EI8_V + "vloxseg7ei16_v", // RISCV_INS_VLOXSEG7EI16_V + "vloxseg7ei32_v", // RISCV_INS_VLOXSEG7EI32_V + "vloxseg7ei64_v", // RISCV_INS_VLOXSEG7EI64_V + "vloxseg7ei8_v", // RISCV_INS_VLOXSEG7EI8_V + "vloxseg8ei16_v", // RISCV_INS_VLOXSEG8EI16_V + "vloxseg8ei32_v", // RISCV_INS_VLOXSEG8EI32_V + "vloxseg8ei64_v", // RISCV_INS_VLOXSEG8EI64_V + "vloxseg8ei8_v", // RISCV_INS_VLOXSEG8EI8_V + "vlse16_v", // RISCV_INS_VLSE16_V + "vlse32_v", // RISCV_INS_VLSE32_V + "vlse64_v", // RISCV_INS_VLSE64_V + "vlse8_v", // RISCV_INS_VLSE8_V + "vlseg2e16ff_v", // RISCV_INS_VLSEG2E16FF_V + "vlseg2e16_v", // RISCV_INS_VLSEG2E16_V + "vlseg2e32ff_v", // RISCV_INS_VLSEG2E32FF_V + "vlseg2e32_v", // RISCV_INS_VLSEG2E32_V + "vlseg2e64ff_v", // RISCV_INS_VLSEG2E64FF_V + "vlseg2e64_v", // RISCV_INS_VLSEG2E64_V + "vlseg2e8ff_v", // RISCV_INS_VLSEG2E8FF_V + "vlseg2e8_v", // RISCV_INS_VLSEG2E8_V + "vlseg3e16ff_v", // RISCV_INS_VLSEG3E16FF_V + "vlseg3e16_v", // RISCV_INS_VLSEG3E16_V + "vlseg3e32ff_v", // RISCV_INS_VLSEG3E32FF_V + "vlseg3e32_v", // RISCV_INS_VLSEG3E32_V + "vlseg3e64ff_v", // RISCV_INS_VLSEG3E64FF_V + "vlseg3e64_v", // RISCV_INS_VLSEG3E64_V + "vlseg3e8ff_v", // RISCV_INS_VLSEG3E8FF_V + "vlseg3e8_v", // RISCV_INS_VLSEG3E8_V + "vlseg4e16ff_v", // RISCV_INS_VLSEG4E16FF_V + "vlseg4e16_v", // RISCV_INS_VLSEG4E16_V + "vlseg4e32ff_v", // RISCV_INS_VLSEG4E32FF_V + "vlseg4e32_v", // RISCV_INS_VLSEG4E32_V + "vlseg4e64ff_v", // RISCV_INS_VLSEG4E64FF_V + "vlseg4e64_v", // RISCV_INS_VLSEG4E64_V + "vlseg4e8ff_v", // RISCV_INS_VLSEG4E8FF_V + "vlseg4e8_v", // RISCV_INS_VLSEG4E8_V + "vlseg5e16ff_v", // RISCV_INS_VLSEG5E16FF_V + "vlseg5e16_v", // RISCV_INS_VLSEG5E16_V + "vlseg5e32ff_v", // RISCV_INS_VLSEG5E32FF_V + "vlseg5e32_v", // RISCV_INS_VLSEG5E32_V + "vlseg5e64ff_v", // RISCV_INS_VLSEG5E64FF_V + "vlseg5e64_v", // RISCV_INS_VLSEG5E64_V + "vlseg5e8ff_v", // RISCV_INS_VLSEG5E8FF_V + "vlseg5e8_v", // RISCV_INS_VLSEG5E8_V + "vlseg6e16ff_v", // RISCV_INS_VLSEG6E16FF_V + "vlseg6e16_v", // RISCV_INS_VLSEG6E16_V + "vlseg6e32ff_v", // RISCV_INS_VLSEG6E32FF_V + "vlseg6e32_v", // RISCV_INS_VLSEG6E32_V + "vlseg6e64ff_v", // RISCV_INS_VLSEG6E64FF_V + "vlseg6e64_v", // RISCV_INS_VLSEG6E64_V + "vlseg6e8ff_v", // RISCV_INS_VLSEG6E8FF_V + "vlseg6e8_v", // RISCV_INS_VLSEG6E8_V + "vlseg7e16ff_v", // RISCV_INS_VLSEG7E16FF_V + "vlseg7e16_v", // RISCV_INS_VLSEG7E16_V + "vlseg7e32ff_v", // RISCV_INS_VLSEG7E32FF_V + "vlseg7e32_v", // RISCV_INS_VLSEG7E32_V + "vlseg7e64ff_v", // RISCV_INS_VLSEG7E64FF_V + "vlseg7e64_v", // RISCV_INS_VLSEG7E64_V + "vlseg7e8ff_v", // RISCV_INS_VLSEG7E8FF_V + "vlseg7e8_v", // RISCV_INS_VLSEG7E8_V + "vlseg8e16ff_v", // RISCV_INS_VLSEG8E16FF_V + "vlseg8e16_v", // RISCV_INS_VLSEG8E16_V + "vlseg8e32ff_v", // RISCV_INS_VLSEG8E32FF_V + "vlseg8e32_v", // RISCV_INS_VLSEG8E32_V + "vlseg8e64ff_v", // RISCV_INS_VLSEG8E64FF_V + "vlseg8e64_v", // RISCV_INS_VLSEG8E64_V + "vlseg8e8ff_v", // RISCV_INS_VLSEG8E8FF_V + "vlseg8e8_v", // RISCV_INS_VLSEG8E8_V + "vlsseg2e16_v", // RISCV_INS_VLSSEG2E16_V + "vlsseg2e32_v", // RISCV_INS_VLSSEG2E32_V + "vlsseg2e64_v", // RISCV_INS_VLSSEG2E64_V + "vlsseg2e8_v", // RISCV_INS_VLSSEG2E8_V + "vlsseg3e16_v", // RISCV_INS_VLSSEG3E16_V + "vlsseg3e32_v", // RISCV_INS_VLSSEG3E32_V + "vlsseg3e64_v", // RISCV_INS_VLSSEG3E64_V + "vlsseg3e8_v", // RISCV_INS_VLSSEG3E8_V + "vlsseg4e16_v", // RISCV_INS_VLSSEG4E16_V + "vlsseg4e32_v", // RISCV_INS_VLSSEG4E32_V + "vlsseg4e64_v", // RISCV_INS_VLSSEG4E64_V + "vlsseg4e8_v", // RISCV_INS_VLSSEG4E8_V + "vlsseg5e16_v", // RISCV_INS_VLSSEG5E16_V + "vlsseg5e32_v", // RISCV_INS_VLSSEG5E32_V + "vlsseg5e64_v", // RISCV_INS_VLSSEG5E64_V + "vlsseg5e8_v", // RISCV_INS_VLSSEG5E8_V + "vlsseg6e16_v", // RISCV_INS_VLSSEG6E16_V + "vlsseg6e32_v", // RISCV_INS_VLSSEG6E32_V + "vlsseg6e64_v", // RISCV_INS_VLSSEG6E64_V + "vlsseg6e8_v", // RISCV_INS_VLSSEG6E8_V + "vlsseg7e16_v", // RISCV_INS_VLSSEG7E16_V + "vlsseg7e32_v", // RISCV_INS_VLSSEG7E32_V + "vlsseg7e64_v", // RISCV_INS_VLSSEG7E64_V + "vlsseg7e8_v", // RISCV_INS_VLSSEG7E8_V + "vlsseg8e16_v", // RISCV_INS_VLSSEG8E16_V + "vlsseg8e32_v", // RISCV_INS_VLSSEG8E32_V + "vlsseg8e64_v", // RISCV_INS_VLSSEG8E64_V + "vlsseg8e8_v", // RISCV_INS_VLSSEG8E8_V + "vluxei16_v", // RISCV_INS_VLUXEI16_V + "vluxei32_v", // RISCV_INS_VLUXEI32_V + "vluxei64_v", // RISCV_INS_VLUXEI64_V + "vluxei8_v", // RISCV_INS_VLUXEI8_V + "vluxseg2ei16_v", // RISCV_INS_VLUXSEG2EI16_V + "vluxseg2ei32_v", // RISCV_INS_VLUXSEG2EI32_V + "vluxseg2ei64_v", // RISCV_INS_VLUXSEG2EI64_V + "vluxseg2ei8_v", // RISCV_INS_VLUXSEG2EI8_V + "vluxseg3ei16_v", // RISCV_INS_VLUXSEG3EI16_V + "vluxseg3ei32_v", // RISCV_INS_VLUXSEG3EI32_V + "vluxseg3ei64_v", // RISCV_INS_VLUXSEG3EI64_V + "vluxseg3ei8_v", // RISCV_INS_VLUXSEG3EI8_V + "vluxseg4ei16_v", // RISCV_INS_VLUXSEG4EI16_V + "vluxseg4ei32_v", // RISCV_INS_VLUXSEG4EI32_V + "vluxseg4ei64_v", // RISCV_INS_VLUXSEG4EI64_V + "vluxseg4ei8_v", // RISCV_INS_VLUXSEG4EI8_V + "vluxseg5ei16_v", // RISCV_INS_VLUXSEG5EI16_V + "vluxseg5ei32_v", // RISCV_INS_VLUXSEG5EI32_V + "vluxseg5ei64_v", // RISCV_INS_VLUXSEG5EI64_V + "vluxseg5ei8_v", // RISCV_INS_VLUXSEG5EI8_V + "vluxseg6ei16_v", // RISCV_INS_VLUXSEG6EI16_V + "vluxseg6ei32_v", // RISCV_INS_VLUXSEG6EI32_V + "vluxseg6ei64_v", // RISCV_INS_VLUXSEG6EI64_V + "vluxseg6ei8_v", // RISCV_INS_VLUXSEG6EI8_V + "vluxseg7ei16_v", // RISCV_INS_VLUXSEG7EI16_V + "vluxseg7ei32_v", // RISCV_INS_VLUXSEG7EI32_V + "vluxseg7ei64_v", // RISCV_INS_VLUXSEG7EI64_V + "vluxseg7ei8_v", // RISCV_INS_VLUXSEG7EI8_V + "vluxseg8ei16_v", // RISCV_INS_VLUXSEG8EI16_V + "vluxseg8ei32_v", // RISCV_INS_VLUXSEG8EI32_V + "vluxseg8ei64_v", // RISCV_INS_VLUXSEG8EI64_V + "vluxseg8ei8_v", // RISCV_INS_VLUXSEG8EI8_V + "vmacc_vv", // RISCV_INS_VMACC_VV + "vmacc_vx", // RISCV_INS_VMACC_VX + "vmadc_vi", // RISCV_INS_VMADC_VI + "vmadc_vim", // RISCV_INS_VMADC_VIM + "vmadc_vv", // RISCV_INS_VMADC_VV + "vmadc_vvm", // RISCV_INS_VMADC_VVM + "vmadc_vx", // RISCV_INS_VMADC_VX + "vmadc_vxm", // RISCV_INS_VMADC_VXM + "vmadd_vv", // RISCV_INS_VMADD_VV + "vmadd_vx", // RISCV_INS_VMADD_VX + "vmandn_mm", // RISCV_INS_VMANDN_MM + "vmand_mm", // RISCV_INS_VMAND_MM + "vmaxu_vv", // RISCV_INS_VMAXU_VV + "vmaxu_vx", // RISCV_INS_VMAXU_VX + "vmax_vv", // RISCV_INS_VMAX_VV + "vmax_vx", // RISCV_INS_VMAX_VX + "vmerge_vim", // RISCV_INS_VMERGE_VIM + "vmerge_vvm", // RISCV_INS_VMERGE_VVM + "vmerge_vxm", // RISCV_INS_VMERGE_VXM + "vmfeq_vf", // RISCV_INS_VMFEQ_VF + "vmfeq_vv", // RISCV_INS_VMFEQ_VV + "vmfge_vf", // RISCV_INS_VMFGE_VF + "vmfgt_vf", // RISCV_INS_VMFGT_VF + "vmfle_vf", // RISCV_INS_VMFLE_VF + "vmfle_vv", // RISCV_INS_VMFLE_VV + "vmflt_vf", // RISCV_INS_VMFLT_VF + "vmflt_vv", // RISCV_INS_VMFLT_VV + "vmfne_vf", // RISCV_INS_VMFNE_VF + "vmfne_vv", // RISCV_INS_VMFNE_VV + "vminu_vv", // RISCV_INS_VMINU_VV + "vminu_vx", // RISCV_INS_VMINU_VX + "vmin_vv", // RISCV_INS_VMIN_VV + "vmin_vx", // RISCV_INS_VMIN_VX + "vmnand_mm", // RISCV_INS_VMNAND_MM + "vmnor_mm", // RISCV_INS_VMNOR_MM + "vmorn_mm", // RISCV_INS_VMORN_MM + "vmor_mm", // RISCV_INS_VMOR_MM + "vmsbc_vv", // RISCV_INS_VMSBC_VV + "vmsbc_vvm", // RISCV_INS_VMSBC_VVM + "vmsbc_vx", // RISCV_INS_VMSBC_VX + "vmsbc_vxm", // RISCV_INS_VMSBC_VXM + "vmsbf_m", // RISCV_INS_VMSBF_M + "vmseq_vi", // RISCV_INS_VMSEQ_VI + "vmseq_vv", // RISCV_INS_VMSEQ_VV + "vmseq_vx", // RISCV_INS_VMSEQ_VX + "vmsgtu_vi", // RISCV_INS_VMSGTU_VI + "vmsgtu_vx", // RISCV_INS_VMSGTU_VX + "vmsgt_vi", // RISCV_INS_VMSGT_VI + "vmsgt_vx", // RISCV_INS_VMSGT_VX + "vmsif_m", // RISCV_INS_VMSIF_M + "vmsleu_vi", // RISCV_INS_VMSLEU_VI + "vmsleu_vv", // RISCV_INS_VMSLEU_VV + "vmsleu_vx", // RISCV_INS_VMSLEU_VX + "vmsle_vi", // RISCV_INS_VMSLE_VI + "vmsle_vv", // RISCV_INS_VMSLE_VV + "vmsle_vx", // RISCV_INS_VMSLE_VX + "vmsltu_vv", // RISCV_INS_VMSLTU_VV + "vmsltu_vx", // RISCV_INS_VMSLTU_VX + "vmslt_vv", // RISCV_INS_VMSLT_VV + "vmslt_vx", // RISCV_INS_VMSLT_VX + "vmsne_vi", // RISCV_INS_VMSNE_VI + "vmsne_vv", // RISCV_INS_VMSNE_VV + "vmsne_vx", // RISCV_INS_VMSNE_VX + "vmsof_m", // RISCV_INS_VMSOF_M + "vmulhsu_vv", // RISCV_INS_VMULHSU_VV + "vmulhsu_vx", // RISCV_INS_VMULHSU_VX + "vmulhu_vv", // RISCV_INS_VMULHU_VV + "vmulhu_vx", // RISCV_INS_VMULHU_VX + "vmulh_vv", // RISCV_INS_VMULH_VV + "vmulh_vx", // RISCV_INS_VMULH_VX + "vmul_vv", // RISCV_INS_VMUL_VV + "vmul_vx", // RISCV_INS_VMUL_VX + "vmv1r_v", // RISCV_INS_VMV1R_V + "vmv2r_v", // RISCV_INS_VMV2R_V + "vmv4r_v", // RISCV_INS_VMV4R_V + "vmv8r_v", // RISCV_INS_VMV8R_V + "vmv_s_x", // RISCV_INS_VMV_S_X + "vmv_v_i", // RISCV_INS_VMV_V_I + "vmv_v_v", // RISCV_INS_VMV_V_V + "vmv_v_x", // RISCV_INS_VMV_V_X + "vmv_x_s", // RISCV_INS_VMV_X_S + "vmxnor_mm", // RISCV_INS_VMXNOR_MM + "vmxor_mm", // RISCV_INS_VMXOR_MM + "vnclipu_wi", // RISCV_INS_VNCLIPU_WI + "vnclipu_wv", // RISCV_INS_VNCLIPU_WV + "vnclipu_wx", // RISCV_INS_VNCLIPU_WX + "vnclip_wi", // RISCV_INS_VNCLIP_WI + "vnclip_wv", // RISCV_INS_VNCLIP_WV + "vnclip_wx", // RISCV_INS_VNCLIP_WX + "vnmsac_vv", // RISCV_INS_VNMSAC_VV + "vnmsac_vx", // RISCV_INS_VNMSAC_VX + "vnmsub_vv", // RISCV_INS_VNMSUB_VV + "vnmsub_vx", // RISCV_INS_VNMSUB_VX + "vnsra_wi", // RISCV_INS_VNSRA_WI + "vnsra_wv", // RISCV_INS_VNSRA_WV + "vnsra_wx", // RISCV_INS_VNSRA_WX + "vnsrl_wi", // RISCV_INS_VNSRL_WI + "vnsrl_wv", // RISCV_INS_VNSRL_WV + "vnsrl_wx", // RISCV_INS_VNSRL_WX + "vor_vi", // RISCV_INS_VOR_VI + "vor_vv", // RISCV_INS_VOR_VV + "vor_vx", // RISCV_INS_VOR_VX + "sf_vqmaccsu_2x8x2", // RISCV_INS_SF_VQMACCSU_2X8X2 + "sf_vqmaccsu_4x8x4", // RISCV_INS_SF_VQMACCSU_4X8X4 + "sf_vqmaccus_2x8x2", // RISCV_INS_SF_VQMACCUS_2X8X2 + "sf_vqmaccus_4x8x4", // RISCV_INS_SF_VQMACCUS_4X8X4 + "sf_vqmaccu_2x8x2", // RISCV_INS_SF_VQMACCU_2X8X2 + "sf_vqmaccu_4x8x4", // RISCV_INS_SF_VQMACCU_4X8X4 + "sf_vqmacc_2x8x2", // RISCV_INS_SF_VQMACC_2X8X2 + "sf_vqmacc_4x8x4", // RISCV_INS_SF_VQMACC_4X8X4 + "vredand_vs", // RISCV_INS_VREDAND_VS + "vredmaxu_vs", // RISCV_INS_VREDMAXU_VS + "vredmax_vs", // RISCV_INS_VREDMAX_VS + "vredminu_vs", // RISCV_INS_VREDMINU_VS + "vredmin_vs", // RISCV_INS_VREDMIN_VS + "vredor_vs", // RISCV_INS_VREDOR_VS + "vredsum_vs", // RISCV_INS_VREDSUM_VS + "vredxor_vs", // RISCV_INS_VREDXOR_VS + "vremu_vv", // RISCV_INS_VREMU_VV + "vremu_vx", // RISCV_INS_VREMU_VX + "vrem_vv", // RISCV_INS_VREM_VV + "vrem_vx", // RISCV_INS_VREM_VX + "vrev8_v", // RISCV_INS_VREV8_V + "vrgatherei16_vv", // RISCV_INS_VRGATHEREI16_VV + "vrgather_vi", // RISCV_INS_VRGATHER_VI + "vrgather_vv", // RISCV_INS_VRGATHER_VV + "vrgather_vx", // RISCV_INS_VRGATHER_VX + "vrol_vv", // RISCV_INS_VROL_VV + "vrol_vx", // RISCV_INS_VROL_VX + "vror_vi", // RISCV_INS_VROR_VI + "vror_vv", // RISCV_INS_VROR_VV + "vror_vx", // RISCV_INS_VROR_VX + "vrsub_vi", // RISCV_INS_VRSUB_VI + "vrsub_vx", // RISCV_INS_VRSUB_VX + "vs1r_v", // RISCV_INS_VS1R_V + "vs2r_v", // RISCV_INS_VS2R_V + "vs4r_v", // RISCV_INS_VS4R_V + "vs8r_v", // RISCV_INS_VS8R_V + "vsaddu_vi", // RISCV_INS_VSADDU_VI + "vsaddu_vv", // RISCV_INS_VSADDU_VV + "vsaddu_vx", // RISCV_INS_VSADDU_VX + "vsadd_vi", // RISCV_INS_VSADD_VI + "vsadd_vv", // RISCV_INS_VSADD_VV + "vsadd_vx", // RISCV_INS_VSADD_VX + "vsbc_vvm", // RISCV_INS_VSBC_VVM + "vsbc_vxm", // RISCV_INS_VSBC_VXM + "vse16_v", // RISCV_INS_VSE16_V + "vse32_v", // RISCV_INS_VSE32_V + "vse64_v", // RISCV_INS_VSE64_V + "vse8_v", // RISCV_INS_VSE8_V + "vsetivli", // RISCV_INS_VSETIVLI + "vsetvl", // RISCV_INS_VSETVL + "vsetvli", // RISCV_INS_VSETVLI + "vsext_vf2", // RISCV_INS_VSEXT_VF2 + "vsext_vf4", // RISCV_INS_VSEXT_VF4 + "vsext_vf8", // RISCV_INS_VSEXT_VF8 + "vsha2ch_vv", // RISCV_INS_VSHA2CH_VV + "vsha2cl_vv", // RISCV_INS_VSHA2CL_VV + "vsha2ms_vv", // RISCV_INS_VSHA2MS_VV + "vslide1down_vx", // RISCV_INS_VSLIDE1DOWN_VX + "vslide1up_vx", // RISCV_INS_VSLIDE1UP_VX + "vslidedown_vi", // RISCV_INS_VSLIDEDOWN_VI + "vslidedown_vx", // RISCV_INS_VSLIDEDOWN_VX + "vslideup_vi", // RISCV_INS_VSLIDEUP_VI + "vslideup_vx", // RISCV_INS_VSLIDEUP_VX + "vsll_vi", // RISCV_INS_VSLL_VI + "vsll_vv", // RISCV_INS_VSLL_VV + "vsll_vx", // RISCV_INS_VSLL_VX + "vsm3c_vi", // RISCV_INS_VSM3C_VI + "vsm3me_vv", // RISCV_INS_VSM3ME_VV + "vsm4k_vi", // RISCV_INS_VSM4K_VI + "vsm4r_vs", // RISCV_INS_VSM4R_VS + "vsm4r_vv", // RISCV_INS_VSM4R_VV + "vsmul_vv", // RISCV_INS_VSMUL_VV + "vsmul_vx", // RISCV_INS_VSMUL_VX + "vsm_v", // RISCV_INS_VSM_V + "vsoxei16_v", // RISCV_INS_VSOXEI16_V + "vsoxei32_v", // RISCV_INS_VSOXEI32_V + "vsoxei64_v", // RISCV_INS_VSOXEI64_V + "vsoxei8_v", // RISCV_INS_VSOXEI8_V + "vsoxseg2ei16_v", // RISCV_INS_VSOXSEG2EI16_V + "vsoxseg2ei32_v", // RISCV_INS_VSOXSEG2EI32_V + "vsoxseg2ei64_v", // RISCV_INS_VSOXSEG2EI64_V + "vsoxseg2ei8_v", // RISCV_INS_VSOXSEG2EI8_V + "vsoxseg3ei16_v", // RISCV_INS_VSOXSEG3EI16_V + "vsoxseg3ei32_v", // RISCV_INS_VSOXSEG3EI32_V + "vsoxseg3ei64_v", // RISCV_INS_VSOXSEG3EI64_V + "vsoxseg3ei8_v", // RISCV_INS_VSOXSEG3EI8_V + "vsoxseg4ei16_v", // RISCV_INS_VSOXSEG4EI16_V + "vsoxseg4ei32_v", // RISCV_INS_VSOXSEG4EI32_V + "vsoxseg4ei64_v", // RISCV_INS_VSOXSEG4EI64_V + "vsoxseg4ei8_v", // RISCV_INS_VSOXSEG4EI8_V + "vsoxseg5ei16_v", // RISCV_INS_VSOXSEG5EI16_V + "vsoxseg5ei32_v", // RISCV_INS_VSOXSEG5EI32_V + "vsoxseg5ei64_v", // RISCV_INS_VSOXSEG5EI64_V + "vsoxseg5ei8_v", // RISCV_INS_VSOXSEG5EI8_V + "vsoxseg6ei16_v", // RISCV_INS_VSOXSEG6EI16_V + "vsoxseg6ei32_v", // RISCV_INS_VSOXSEG6EI32_V + "vsoxseg6ei64_v", // RISCV_INS_VSOXSEG6EI64_V + "vsoxseg6ei8_v", // RISCV_INS_VSOXSEG6EI8_V + "vsoxseg7ei16_v", // RISCV_INS_VSOXSEG7EI16_V + "vsoxseg7ei32_v", // RISCV_INS_VSOXSEG7EI32_V + "vsoxseg7ei64_v", // RISCV_INS_VSOXSEG7EI64_V + "vsoxseg7ei8_v", // RISCV_INS_VSOXSEG7EI8_V + "vsoxseg8ei16_v", // RISCV_INS_VSOXSEG8EI16_V + "vsoxseg8ei32_v", // RISCV_INS_VSOXSEG8EI32_V + "vsoxseg8ei64_v", // RISCV_INS_VSOXSEG8EI64_V + "vsoxseg8ei8_v", // RISCV_INS_VSOXSEG8EI8_V + "vsra_vi", // RISCV_INS_VSRA_VI + "vsra_vv", // RISCV_INS_VSRA_VV + "vsra_vx", // RISCV_INS_VSRA_VX + "vsrl_vi", // RISCV_INS_VSRL_VI + "vsrl_vv", // RISCV_INS_VSRL_VV + "vsrl_vx", // RISCV_INS_VSRL_VX + "vsse16_v", // RISCV_INS_VSSE16_V + "vsse32_v", // RISCV_INS_VSSE32_V + "vsse64_v", // RISCV_INS_VSSE64_V + "vsse8_v", // RISCV_INS_VSSE8_V + "vsseg2e16_v", // RISCV_INS_VSSEG2E16_V + "vsseg2e32_v", // RISCV_INS_VSSEG2E32_V + "vsseg2e64_v", // RISCV_INS_VSSEG2E64_V + "vsseg2e8_v", // RISCV_INS_VSSEG2E8_V + "vsseg3e16_v", // RISCV_INS_VSSEG3E16_V + "vsseg3e32_v", // RISCV_INS_VSSEG3E32_V + "vsseg3e64_v", // RISCV_INS_VSSEG3E64_V + "vsseg3e8_v", // RISCV_INS_VSSEG3E8_V + "vsseg4e16_v", // RISCV_INS_VSSEG4E16_V + "vsseg4e32_v", // RISCV_INS_VSSEG4E32_V + "vsseg4e64_v", // RISCV_INS_VSSEG4E64_V + "vsseg4e8_v", // RISCV_INS_VSSEG4E8_V + "vsseg5e16_v", // RISCV_INS_VSSEG5E16_V + "vsseg5e32_v", // RISCV_INS_VSSEG5E32_V + "vsseg5e64_v", // RISCV_INS_VSSEG5E64_V + "vsseg5e8_v", // RISCV_INS_VSSEG5E8_V + "vsseg6e16_v", // RISCV_INS_VSSEG6E16_V + "vsseg6e32_v", // RISCV_INS_VSSEG6E32_V + "vsseg6e64_v", // RISCV_INS_VSSEG6E64_V + "vsseg6e8_v", // RISCV_INS_VSSEG6E8_V + "vsseg7e16_v", // RISCV_INS_VSSEG7E16_V + "vsseg7e32_v", // RISCV_INS_VSSEG7E32_V + "vsseg7e64_v", // RISCV_INS_VSSEG7E64_V + "vsseg7e8_v", // RISCV_INS_VSSEG7E8_V + "vsseg8e16_v", // RISCV_INS_VSSEG8E16_V + "vsseg8e32_v", // RISCV_INS_VSSEG8E32_V + "vsseg8e64_v", // RISCV_INS_VSSEG8E64_V + "vsseg8e8_v", // RISCV_INS_VSSEG8E8_V + "vssra_vi", // RISCV_INS_VSSRA_VI + "vssra_vv", // RISCV_INS_VSSRA_VV + "vssra_vx", // RISCV_INS_VSSRA_VX + "vssrl_vi", // RISCV_INS_VSSRL_VI + "vssrl_vv", // RISCV_INS_VSSRL_VV + "vssrl_vx", // RISCV_INS_VSSRL_VX + "vssseg2e16_v", // RISCV_INS_VSSSEG2E16_V + "vssseg2e32_v", // RISCV_INS_VSSSEG2E32_V + "vssseg2e64_v", // RISCV_INS_VSSSEG2E64_V + "vssseg2e8_v", // RISCV_INS_VSSSEG2E8_V + "vssseg3e16_v", // RISCV_INS_VSSSEG3E16_V + "vssseg3e32_v", // RISCV_INS_VSSSEG3E32_V + "vssseg3e64_v", // RISCV_INS_VSSSEG3E64_V + "vssseg3e8_v", // RISCV_INS_VSSSEG3E8_V + "vssseg4e16_v", // RISCV_INS_VSSSEG4E16_V + "vssseg4e32_v", // RISCV_INS_VSSSEG4E32_V + "vssseg4e64_v", // RISCV_INS_VSSSEG4E64_V + "vssseg4e8_v", // RISCV_INS_VSSSEG4E8_V + "vssseg5e16_v", // RISCV_INS_VSSSEG5E16_V + "vssseg5e32_v", // RISCV_INS_VSSSEG5E32_V + "vssseg5e64_v", // RISCV_INS_VSSSEG5E64_V + "vssseg5e8_v", // RISCV_INS_VSSSEG5E8_V + "vssseg6e16_v", // RISCV_INS_VSSSEG6E16_V + "vssseg6e32_v", // RISCV_INS_VSSSEG6E32_V + "vssseg6e64_v", // RISCV_INS_VSSSEG6E64_V + "vssseg6e8_v", // RISCV_INS_VSSSEG6E8_V + "vssseg7e16_v", // RISCV_INS_VSSSEG7E16_V + "vssseg7e32_v", // RISCV_INS_VSSSEG7E32_V + "vssseg7e64_v", // RISCV_INS_VSSSEG7E64_V + "vssseg7e8_v", // RISCV_INS_VSSSEG7E8_V + "vssseg8e16_v", // RISCV_INS_VSSSEG8E16_V + "vssseg8e32_v", // RISCV_INS_VSSSEG8E32_V + "vssseg8e64_v", // RISCV_INS_VSSSEG8E64_V + "vssseg8e8_v", // RISCV_INS_VSSSEG8E8_V + "vssubu_vv", // RISCV_INS_VSSUBU_VV + "vssubu_vx", // RISCV_INS_VSSUBU_VX + "vssub_vv", // RISCV_INS_VSSUB_VV + "vssub_vx", // RISCV_INS_VSSUB_VX + "vsub_vv", // RISCV_INS_VSUB_VV + "vsub_vx", // RISCV_INS_VSUB_VX + "vsuxei16_v", // RISCV_INS_VSUXEI16_V + "vsuxei32_v", // RISCV_INS_VSUXEI32_V + "vsuxei64_v", // RISCV_INS_VSUXEI64_V + "vsuxei8_v", // RISCV_INS_VSUXEI8_V + "vsuxseg2ei16_v", // RISCV_INS_VSUXSEG2EI16_V + "vsuxseg2ei32_v", // RISCV_INS_VSUXSEG2EI32_V + "vsuxseg2ei64_v", // RISCV_INS_VSUXSEG2EI64_V + "vsuxseg2ei8_v", // RISCV_INS_VSUXSEG2EI8_V + "vsuxseg3ei16_v", // RISCV_INS_VSUXSEG3EI16_V + "vsuxseg3ei32_v", // RISCV_INS_VSUXSEG3EI32_V + "vsuxseg3ei64_v", // RISCV_INS_VSUXSEG3EI64_V + "vsuxseg3ei8_v", // RISCV_INS_VSUXSEG3EI8_V + "vsuxseg4ei16_v", // RISCV_INS_VSUXSEG4EI16_V + "vsuxseg4ei32_v", // RISCV_INS_VSUXSEG4EI32_V + "vsuxseg4ei64_v", // RISCV_INS_VSUXSEG4EI64_V + "vsuxseg4ei8_v", // RISCV_INS_VSUXSEG4EI8_V + "vsuxseg5ei16_v", // RISCV_INS_VSUXSEG5EI16_V + "vsuxseg5ei32_v", // RISCV_INS_VSUXSEG5EI32_V + "vsuxseg5ei64_v", // RISCV_INS_VSUXSEG5EI64_V + "vsuxseg5ei8_v", // RISCV_INS_VSUXSEG5EI8_V + "vsuxseg6ei16_v", // RISCV_INS_VSUXSEG6EI16_V + "vsuxseg6ei32_v", // RISCV_INS_VSUXSEG6EI32_V + "vsuxseg6ei64_v", // RISCV_INS_VSUXSEG6EI64_V + "vsuxseg6ei8_v", // RISCV_INS_VSUXSEG6EI8_V + "vsuxseg7ei16_v", // RISCV_INS_VSUXSEG7EI16_V + "vsuxseg7ei32_v", // RISCV_INS_VSUXSEG7EI32_V + "vsuxseg7ei64_v", // RISCV_INS_VSUXSEG7EI64_V + "vsuxseg7ei8_v", // RISCV_INS_VSUXSEG7EI8_V + "vsuxseg8ei16_v", // RISCV_INS_VSUXSEG8EI16_V + "vsuxseg8ei32_v", // RISCV_INS_VSUXSEG8EI32_V + "vsuxseg8ei64_v", // RISCV_INS_VSUXSEG8EI64_V + "vsuxseg8ei8_v", // RISCV_INS_VSUXSEG8EI8_V + "vt_maskc", // RISCV_INS_VT_MASKC + "vt_maskcn", // RISCV_INS_VT_MASKCN + "vwaddu_vv", // RISCV_INS_VWADDU_VV + "vwaddu_vx", // RISCV_INS_VWADDU_VX + "vwaddu_wv", // RISCV_INS_VWADDU_WV + "vwaddu_wx", // RISCV_INS_VWADDU_WX + "vwadd_vv", // RISCV_INS_VWADD_VV + "vwadd_vx", // RISCV_INS_VWADD_VX + "vwadd_wv", // RISCV_INS_VWADD_WV + "vwadd_wx", // RISCV_INS_VWADD_WX + "vwmaccsu_vv", // RISCV_INS_VWMACCSU_VV + "vwmaccsu_vx", // RISCV_INS_VWMACCSU_VX + "vwmaccus_vx", // RISCV_INS_VWMACCUS_VX + "vwmaccu_vv", // RISCV_INS_VWMACCU_VV + "vwmaccu_vx", // RISCV_INS_VWMACCU_VX + "vwmacc_vv", // RISCV_INS_VWMACC_VV + "vwmacc_vx", // RISCV_INS_VWMACC_VX + "vwmulsu_vv", // RISCV_INS_VWMULSU_VV + "vwmulsu_vx", // RISCV_INS_VWMULSU_VX + "vwmulu_vv", // RISCV_INS_VWMULU_VV + "vwmulu_vx", // RISCV_INS_VWMULU_VX + "vwmul_vv", // RISCV_INS_VWMUL_VV + "vwmul_vx", // RISCV_INS_VWMUL_VX + "vwredsumu_vs", // RISCV_INS_VWREDSUMU_VS + "vwredsum_vs", // RISCV_INS_VWREDSUM_VS + "vwsll_vi", // RISCV_INS_VWSLL_VI + "vwsll_vv", // RISCV_INS_VWSLL_VV + "vwsll_vx", // RISCV_INS_VWSLL_VX + "vwsubu_vv", // RISCV_INS_VWSUBU_VV + "vwsubu_vx", // RISCV_INS_VWSUBU_VX + "vwsubu_wv", // RISCV_INS_VWSUBU_WV + "vwsubu_wx", // RISCV_INS_VWSUBU_WX + "vwsub_vv", // RISCV_INS_VWSUB_VV + "vwsub_vx", // RISCV_INS_VWSUB_VX + "vwsub_wv", // RISCV_INS_VWSUB_WV + "vwsub_wx", // RISCV_INS_VWSUB_WX + "vxor_vi", // RISCV_INS_VXOR_VI + "vxor_vv", // RISCV_INS_VXOR_VV + "vxor_vx", // RISCV_INS_VXOR_VX + "vzext_vf2", // RISCV_INS_VZEXT_VF2 + "vzext_vf4", // RISCV_INS_VZEXT_VF4 + "vzext_vf8", // RISCV_INS_VZEXT_VF8 + "wfi", // RISCV_INS_WFI + "wrs_nto", // RISCV_INS_WRS_NTO + "wrs_sto", // RISCV_INS_WRS_STO + "xnor", // RISCV_INS_XNOR + "xor", // RISCV_INS_XOR + "xori", // RISCV_INS_XORI + "xperm4", // RISCV_INS_XPERM4 + "xperm8", // RISCV_INS_XPERM8 + "zip", // RISCV_INS_ZIP diff --git a/arch/RISCV/RISCVGenCSMappingInsnOp.inc b/arch/RISCV/RISCVGenCSMappingInsnOp.inc new file mode 100644 index 0000000000..f826377da1 --- /dev/null +++ b/arch/RISCV/RISCVGenCSMappingInsnOp.inc @@ -0,0 +1,47133 @@ +/* Capstone Disassembly Engine, https://www.capstone-engine.org */ +/* By Nguyen Anh Quynh , 2013-2022, */ +/* Rot127 2022-2024 */ +/* Automatically generated file by Capstone's LLVM TableGen Disassembler Backend. */ + +/* LLVM-commit: */ +/* LLVM-tag: */ + +/* Do not edit. */ + +/* Capstone's LLVM TableGen Backends: */ +/* https://github.com/capstone-engine/llvm-capstone */ + +{{{ /* RISCV_PHI (0) - RISCV_INS_INVALID - PHINODE */ + 0 +}}}, +{{{ /* RISCV_INLINEASM (1) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_INLINEASM_BR (2) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_CFI_INSTRUCTION (3) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_EH_LABEL (4) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_GC_LABEL (5) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_ANNOTATION_LABEL (6) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_KILL (7) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_EXTRACT_SUBREG (8) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_INSERT_SUBREG (9) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_IMPLICIT_DEF (10) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_SUBREG_TO_REG (11) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_COPY_TO_REGCLASS (12) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_DBG_VALUE (13) - RISCV_INS_INVALID - DBG_VALUE */ + 0 +}}}, +{{{ /* RISCV_DBG_VALUE_LIST (14) - RISCV_INS_INVALID - DBG_VALUE_LIST */ + 0 +}}}, +{{{ /* RISCV_DBG_INSTR_REF (15) - RISCV_INS_INVALID - DBG_INSTR_REF */ + 0 +}}}, +{{{ /* RISCV_DBG_PHI (16) - RISCV_INS_INVALID - DBG_PHI */ + 0 +}}}, +{{{ /* RISCV_DBG_LABEL (17) - RISCV_INS_INVALID - DBG_LABEL */ + 0 +}}}, +{{{ /* RISCV_REG_SEQUENCE (18) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_COPY (19) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_BUNDLE (20) - RISCV_INS_INVALID - BUNDLE */ + 0 +}}}, +{{{ /* RISCV_LIFETIME_START (21) - RISCV_INS_INVALID - LIFETIME_START */ + 0 +}}}, +{{{ /* RISCV_LIFETIME_END (22) - RISCV_INS_INVALID - LIFETIME_END */ + 0 +}}}, +{{{ /* RISCV_PSEUDO_PROBE (23) - RISCV_INS_INVALID - PSEUDO_PROBE */ + 0 +}}}, +{{{ /* RISCV_ARITH_FENCE (24) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_STACKMAP (25) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_FENTRY_CALL (26) - RISCV_INS_INVALID - # FEntry call */ + 0 +}}}, +{{{ /* RISCV_PATCHPOINT (27) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_LOAD_STACK_GUARD (28) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PREALLOCATED_SETUP (29) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PREALLOCATED_ARG (30) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_STATEPOINT (31) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_LOCAL_ESCAPE (32) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_FAULTING_OP (33) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PATCHABLE_OP (34) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PATCHABLE_FUNCTION_ENTER (35) - RISCV_INS_INVALID - # XRay Function Enter. */ + 0 +}}}, +{{{ /* RISCV_PATCHABLE_RET (36) - RISCV_INS_INVALID - # XRay Function Patchable RET. */ + 0 +}}}, +{{{ /* RISCV_PATCHABLE_FUNCTION_EXIT (37) - RISCV_INS_INVALID - # XRay Function Exit. */ + 0 +}}}, +{{{ /* RISCV_PATCHABLE_TAIL_CALL (38) - RISCV_INS_INVALID - # XRay Tail Call Exit. */ + 0 +}}}, +{{{ /* RISCV_PATCHABLE_EVENT_CALL (39) - RISCV_INS_INVALID - # XRay Custom Event Log. */ + 0 +}}}, +{{{ /* RISCV_PATCHABLE_TYPED_EVENT_CALL (40) - RISCV_INS_INVALID - # XRay Typed Event Log. */ + 0 +}}}, +{{{ /* RISCV_ICALL_BRANCH_FUNNEL (41) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_MEMBARRIER (42) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_JUMP_TABLE_DEBUG_INFO (43) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_ASSERT_SEXT (44) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_ASSERT_ZEXT (45) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_ASSERT_ALIGN (46) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_ADD (47) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_SUB (48) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_MUL (49) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_SDIV (50) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_UDIV (51) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_SREM (52) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_UREM (53) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_SDIVREM (54) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_UDIVREM (55) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_AND (56) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_OR (57) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_XOR (58) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_IMPLICIT_DEF (59) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_PHI (60) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_FRAME_INDEX (61) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_GLOBAL_VALUE (62) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_CONSTANT_POOL (63) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_EXTRACT (64) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_UNMERGE_VALUES (65) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_INSERT (66) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_MERGE_VALUES (67) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_BUILD_VECTOR (68) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_BUILD_VECTOR_TRUNC (69) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_CONCAT_VECTORS (70) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_PTRTOINT (71) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_INTTOPTR (72) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_BITCAST (73) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_FREEZE (74) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_CONSTANT_FOLD_BARRIER (75) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_INTRINSIC_FPTRUNC_ROUND (76) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_INTRINSIC_TRUNC (77) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_INTRINSIC_ROUND (78) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_INTRINSIC_LRINT (79) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_INTRINSIC_ROUNDEVEN (80) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_READCYCLECOUNTER (81) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_LOAD (82) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_SEXTLOAD (83) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_ZEXTLOAD (84) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_INDEXED_LOAD (85) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_INDEXED_SEXTLOAD (86) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_INDEXED_ZEXTLOAD (87) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_STORE (88) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_INDEXED_STORE (89) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_ATOMIC_CMPXCHG_WITH_SUCCESS (90) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_ATOMIC_CMPXCHG (91) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_ATOMICRMW_XCHG (92) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_ATOMICRMW_ADD (93) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_ATOMICRMW_SUB (94) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_ATOMICRMW_AND (95) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_ATOMICRMW_NAND (96) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_ATOMICRMW_OR (97) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_ATOMICRMW_XOR (98) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_ATOMICRMW_MAX (99) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_ATOMICRMW_MIN (100) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_ATOMICRMW_UMAX (101) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_ATOMICRMW_UMIN (102) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_ATOMICRMW_FADD (103) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_ATOMICRMW_FSUB (104) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_ATOMICRMW_FMAX (105) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_ATOMICRMW_FMIN (106) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_ATOMICRMW_UINC_WRAP (107) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_ATOMICRMW_UDEC_WRAP (108) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_FENCE (109) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_PREFETCH (110) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_BRCOND (111) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_BRINDIRECT (112) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_INVOKE_REGION_START (113) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_INTRINSIC (114) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_INTRINSIC_W_SIDE_EFFECTS (115) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_INTRINSIC_CONVERGENT (116) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_INTRINSIC_CONVERGENT_W_SIDE_EFFECTS (117) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_ANYEXT (118) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_TRUNC (119) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_CONSTANT (120) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_FCONSTANT (121) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_VASTART (122) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_VAARG (123) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_SEXT (124) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_SEXT_INREG (125) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_ZEXT (126) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_SHL (127) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_LSHR (128) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_ASHR (129) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_FSHL (130) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_FSHR (131) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_ROTR (132) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_ROTL (133) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_ICMP (134) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_FCMP (135) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_SELECT (136) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_UADDO (137) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_UADDE (138) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_USUBO (139) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_USUBE (140) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_SADDO (141) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_SADDE (142) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_SSUBO (143) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_SSUBE (144) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_UMULO (145) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_SMULO (146) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_UMULH (147) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_SMULH (148) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_UADDSAT (149) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_SADDSAT (150) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_USUBSAT (151) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_SSUBSAT (152) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_USHLSAT (153) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_SSHLSAT (154) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_SMULFIX (155) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_UMULFIX (156) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_SMULFIXSAT (157) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_UMULFIXSAT (158) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_SDIVFIX (159) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_UDIVFIX (160) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_SDIVFIXSAT (161) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_UDIVFIXSAT (162) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_FADD (163) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_FSUB (164) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_FMUL (165) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_FMA (166) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_FMAD (167) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_FDIV (168) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_FREM (169) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_FPOW (170) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_FPOWI (171) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_FEXP (172) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_FEXP2 (173) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_FEXP10 (174) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_FLOG (175) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_FLOG2 (176) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_FLOG10 (177) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_FLDEXP (178) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_FFREXP (179) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_FNEG (180) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_FPEXT (181) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_FPTRUNC (182) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_FPTOSI (183) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_FPTOUI (184) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_SITOFP (185) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_UITOFP (186) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_FABS (187) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_FCOPYSIGN (188) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_IS_FPCLASS (189) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_FCANONICALIZE (190) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_FMINNUM (191) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_FMAXNUM (192) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_FMINNUM_IEEE (193) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_FMAXNUM_IEEE (194) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_FMINIMUM (195) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_FMAXIMUM (196) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_GET_FPENV (197) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_SET_FPENV (198) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_RESET_FPENV (199) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_GET_FPMODE (200) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_SET_FPMODE (201) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_RESET_FPMODE (202) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_PTR_ADD (203) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_PTRMASK (204) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_SMIN (205) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_SMAX (206) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_UMIN (207) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_UMAX (208) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_ABS (209) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_LROUND (210) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_LLROUND (211) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_BR (212) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_BRJT (213) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_INSERT_VECTOR_ELT (214) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_EXTRACT_VECTOR_ELT (215) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_SHUFFLE_VECTOR (216) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_CTTZ (217) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_CTTZ_ZERO_UNDEF (218) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_CTLZ (219) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_CTLZ_ZERO_UNDEF (220) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_CTPOP (221) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_BSWAP (222) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_BITREVERSE (223) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_FCEIL (224) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_FCOS (225) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_FSIN (226) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_FSQRT (227) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_FFLOOR (228) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_FRINT (229) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_FNEARBYINT (230) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_ADDRSPACE_CAST (231) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_BLOCK_ADDR (232) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_JUMP_TABLE (233) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_DYN_STACKALLOC (234) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_STACKSAVE (235) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_STACKRESTORE (236) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_STRICT_FADD (237) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_STRICT_FSUB (238) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_STRICT_FMUL (239) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_STRICT_FDIV (240) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_STRICT_FREM (241) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_STRICT_FMA (242) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_STRICT_FSQRT (243) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_STRICT_FLDEXP (244) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_READ_REGISTER (245) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_WRITE_REGISTER (246) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_MEMCPY (247) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_MEMCPY_INLINE (248) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_MEMMOVE (249) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_MEMSET (250) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_BZERO (251) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_VECREDUCE_SEQ_FADD (252) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_VECREDUCE_SEQ_FMUL (253) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_VECREDUCE_FADD (254) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_VECREDUCE_FMUL (255) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_VECREDUCE_FMAX (256) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_VECREDUCE_FMIN (257) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_VECREDUCE_FMAXIMUM (258) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_VECREDUCE_FMINIMUM (259) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_VECREDUCE_ADD (260) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_VECREDUCE_MUL (261) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_VECREDUCE_AND (262) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_VECREDUCE_OR (263) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_VECREDUCE_XOR (264) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_VECREDUCE_SMAX (265) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_VECREDUCE_SMIN (266) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_VECREDUCE_UMAX (267) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_VECREDUCE_UMIN (268) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_SBFX (269) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_UBFX (270) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_ADJCALLSTACKDOWN (271) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_ADJCALLSTACKUP (272) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_BuildPairF64Pseudo (273) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_BuildPairF64Pseudo_INX (274) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_G_FCLASS (275) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_HWASAN_CHECK_MEMACCESS_SHORTGRANULES (276) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_KCFI_CHECK (277) - RISCV_INS_INVALID - */ + 0 +}}}, +{ /* RISCV_PseudoAddTPRel (278) - RISCV_INS_ADD - add $rd, $rs1, $rs2, $src */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* src */ + { 0 } +}}, +{{{ /* RISCV_PseudoAtomicLoadNand32 (279) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoAtomicLoadNand64 (280) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoBR (281) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoBRIND (282) - RISCV_INS_INVALID - */ + 0 +}}}, +{ /* RISCV_PseudoCALL (283) - RISCV_INS_CALL - call $func */ +{ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* func */ + { 0 } +}}, +{{{ /* RISCV_PseudoCALLIndirect (284) - RISCV_INS_INVALID - */ + 0 +}}}, +{ /* RISCV_PseudoCALLReg (285) - RISCV_INS_CALL - call $rd, $func */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* func */ + { 0 } +}}, +{{{ /* RISCV_PseudoCCADD (286) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoCCADDI (287) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoCCADDIW (288) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoCCADDW (289) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoCCAND (290) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoCCANDI (291) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoCCANDN (292) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoCCMOVGPR (293) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoCCMOVGPRNoX0 (294) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoCCOR (295) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoCCORI (296) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoCCORN (297) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoCCSLL (298) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoCCSLLI (299) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoCCSLLIW (300) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoCCSLLW (301) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoCCSRA (302) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoCCSRAI (303) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoCCSRAIW (304) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoCCSRAW (305) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoCCSRL (306) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoCCSRLI (307) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoCCSRLIW (308) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoCCSRLW (309) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoCCSUB (310) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoCCSUBW (311) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoCCXNOR (312) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoCCXOR (313) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoCCXORI (314) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoCmpXchg32 (315) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoCmpXchg64 (316) - RISCV_INS_INVALID - */ + 0 +}}}, +{ /* RISCV_PseudoFLD (317) - RISCV_INS_FLD - fld $rd, $addr, $tmp */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* tmp */ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* addr */ + { 0 } +}}, +{ /* RISCV_PseudoFLH (318) - RISCV_INS_FLH - flh $rd, $addr, $tmp */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* tmp */ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* addr */ + { 0 } +}}, +{ /* RISCV_PseudoFLW (319) - RISCV_INS_FLW - flw $rd, $addr, $tmp */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* tmp */ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* addr */ + { 0 } +}}, +{{{ /* RISCV_PseudoFROUND_D (320) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoFROUND_D_IN32X (321) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoFROUND_D_INX (322) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoFROUND_H (323) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoFROUND_H_INX (324) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoFROUND_S (325) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoFROUND_S_INX (326) - RISCV_INS_INVALID - */ + 0 +}}}, +{ /* RISCV_PseudoFSD (327) - RISCV_INS_FSD - fsd $rs, $addr, $tmp */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* tmp */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* addr */ + { 0 } +}}, +{ /* RISCV_PseudoFSH (328) - RISCV_INS_FSH - fsh $rs, $addr, $tmp */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* tmp */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rs */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* addr */ + { 0 } +}}, +{ /* RISCV_PseudoFSW (329) - RISCV_INS_FSW - fsw $rs, $addr, $tmp */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* tmp */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* addr */ + { 0 } +}}, +{ /* RISCV_PseudoJump (330) - RISCV_INS_JUMP - jump $target, $rd */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* target */ + { 0 } +}}, +{ /* RISCV_PseudoLA (331) - RISCV_INS_LA - la $dst, $src */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* dst */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* src */ + { 0 } +}}, +{ /* RISCV_PseudoLAImm (332) - RISCV_INS_LA - la $rd, $imm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { 0 } +}}, +{ /* RISCV_PseudoLA_TLSDESC (333) - RISCV_INS_LA_TLSDESC - la.tlsdesc $dst, $src */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* dst */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* src */ + { 0 } +}}, +{ /* RISCV_PseudoLA_TLS_GD (334) - RISCV_INS_LA_TLS_GD - la.tls.gd $dst, $src */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* dst */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* src */ + { 0 } +}}, +{ /* RISCV_PseudoLA_TLS_IE (335) - RISCV_INS_LA_TLS_IE - la.tls.ie $dst, $src */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* dst */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* src */ + { 0 } +}}, +{ /* RISCV_PseudoLB (336) - RISCV_INS_LB - lb $rd, $addr */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* addr */ + { 0 } +}}, +{ /* RISCV_PseudoLBU (337) - RISCV_INS_LBU - lbu $rd, $addr */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* addr */ + { 0 } +}}, +{ /* RISCV_PseudoLD (338) - RISCV_INS_LD - ld $rd, $addr */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* addr */ + { 0 } +}}, +{ /* RISCV_PseudoLGA (339) - RISCV_INS_LGA - lga $dst, $src */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* dst */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* src */ + { 0 } +}}, +{ /* RISCV_PseudoLH (340) - RISCV_INS_LH - lh $rd, $addr */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* addr */ + { 0 } +}}, +{ /* RISCV_PseudoLHU (341) - RISCV_INS_LHU - lhu $rd, $addr */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* addr */ + { 0 } +}}, +{ /* RISCV_PseudoLI (342) - RISCV_INS_LI - li $rd, $imm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { 0 } +}}, +{ /* RISCV_PseudoLLA (343) - RISCV_INS_LLA - lla $dst, $src */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* dst */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* src */ + { 0 } +}}, +{ /* RISCV_PseudoLLAImm (344) - RISCV_INS_LLA - lla $dst, $imm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* dst */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { 0 } +}}, +{ /* RISCV_PseudoLW (345) - RISCV_INS_LW - lw $rd, $addr */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* addr */ + { 0 } +}}, +{ /* RISCV_PseudoLWU (346) - RISCV_INS_LWU - lwu $rd, $addr */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* addr */ + { 0 } +}}, +{{{ /* RISCV_PseudoLongBEQ (347) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoLongBGE (348) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoLongBGEU (349) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoLongBLT (350) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoLongBLTU (351) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoLongBNE (352) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoMaskedAtomicLoadAdd32 (353) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoMaskedAtomicLoadMax32 (354) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoMaskedAtomicLoadMin32 (355) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoMaskedAtomicLoadNand32 (356) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoMaskedAtomicLoadSub32 (357) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoMaskedAtomicLoadUMax32 (358) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoMaskedAtomicLoadUMin32 (359) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoMaskedAtomicSwap32 (360) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoMaskedCmpXchg32 (361) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoMovImm (362) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoQuietFLE_D (363) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoQuietFLE_D_IN32X (364) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoQuietFLE_D_INX (365) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoQuietFLE_H (366) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoQuietFLE_H_INX (367) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoQuietFLE_S (368) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoQuietFLE_S_INX (369) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoQuietFLT_D (370) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoQuietFLT_D_IN32X (371) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoQuietFLT_D_INX (372) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoQuietFLT_H (373) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoQuietFLT_H_INX (374) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoQuietFLT_S (375) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoQuietFLT_S_INX (376) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoRET (377) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoRV32ZdinxLD (378) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoRV32ZdinxSD (379) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoRVVInitUndefM1 (380) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoRVVInitUndefM2 (381) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoRVVInitUndefM4 (382) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoRVVInitUndefM8 (383) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoReadVL (384) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoReadVLENB (385) - RISCV_INS_INVALID - */ + 0 +}}}, +{ /* RISCV_PseudoSB (386) - RISCV_INS_SB - sb $rs, $addr, $tmp */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* tmp */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* addr */ + { 0 } +}}, +{ /* RISCV_PseudoSD (387) - RISCV_INS_SD - sd $rs, $addr, $tmp */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* tmp */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* addr */ + { 0 } +}}, +{ /* RISCV_PseudoSEXT_B (388) - RISCV_INS_SEXT_B - sext.b $rd, $rs */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs */ + { 0 } +}}, +{ /* RISCV_PseudoSEXT_H (389) - RISCV_INS_SEXT_H - sext.h $rd, $rs */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs */ + { 0 } +}}, +{ /* RISCV_PseudoSH (390) - RISCV_INS_SH - sh $rs, $addr, $tmp */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* tmp */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* addr */ + { 0 } +}}, +{ /* RISCV_PseudoSW (391) - RISCV_INS_SW - sw $rs, $addr, $tmp */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* tmp */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* addr */ + { 0 } +}}, +{ /* RISCV_PseudoTAIL (392) - RISCV_INS_TAIL - tail $dst */ +{ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* dst */ + { 0 } +}}, +{{{ /* RISCV_PseudoTAILIndirect (393) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQASU_VV_M1 (394) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQASU_VV_M1_MASK (395) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQASU_VV_M2 (396) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQASU_VV_M2_MASK (397) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQASU_VV_M4 (398) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQASU_VV_M4_MASK (399) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQASU_VV_M8 (400) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQASU_VV_M8_MASK (401) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQASU_VV_MF2 (402) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQASU_VV_MF2_MASK (403) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQASU_VX_M1 (404) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQASU_VX_M1_MASK (405) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQASU_VX_M2 (406) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQASU_VX_M2_MASK (407) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQASU_VX_M4 (408) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQASU_VX_M4_MASK (409) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQASU_VX_M8 (410) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQASU_VX_M8_MASK (411) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQASU_VX_MF2 (412) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQASU_VX_MF2_MASK (413) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQAUS_VX_M1 (414) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQAUS_VX_M1_MASK (415) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQAUS_VX_M2 (416) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQAUS_VX_M2_MASK (417) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQAUS_VX_M4 (418) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQAUS_VX_M4_MASK (419) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQAUS_VX_M8 (420) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQAUS_VX_M8_MASK (421) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQAUS_VX_MF2 (422) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQAUS_VX_MF2_MASK (423) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQAU_VV_M1 (424) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQAU_VV_M1_MASK (425) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQAU_VV_M2 (426) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQAU_VV_M2_MASK (427) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQAU_VV_M4 (428) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQAU_VV_M4_MASK (429) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQAU_VV_M8 (430) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQAU_VV_M8_MASK (431) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQAU_VV_MF2 (432) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQAU_VV_MF2_MASK (433) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQAU_VX_M1 (434) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQAU_VX_M1_MASK (435) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQAU_VX_M2 (436) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQAU_VX_M2_MASK (437) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQAU_VX_M4 (438) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQAU_VX_M4_MASK (439) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQAU_VX_M8 (440) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQAU_VX_M8_MASK (441) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQAU_VX_MF2 (442) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQAU_VX_MF2_MASK (443) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQA_VV_M1 (444) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQA_VV_M1_MASK (445) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQA_VV_M2 (446) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQA_VV_M2_MASK (447) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQA_VV_M4 (448) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQA_VV_M4_MASK (449) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQA_VV_M8 (450) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQA_VV_M8_MASK (451) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQA_VV_MF2 (452) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQA_VV_MF2_MASK (453) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQA_VX_M1 (454) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQA_VX_M1_MASK (455) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQA_VX_M2 (456) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQA_VX_M2_MASK (457) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQA_VX_M4 (458) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQA_VX_M4_MASK (459) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQA_VX_M8 (460) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQA_VX_M8_MASK (461) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQA_VX_MF2 (462) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoTHVdotVMAQA_VX_MF2_MASK (463) - RISCV_INS_INVALID - */ + 0 +}}}, +{ /* RISCV_PseudoTLSDESCCall (464) - RISCV_INS_JALR - jalr $rd, ${imm12}(${rs1}), $src */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm12 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* src */ + { 0 } +}}, +{{{ /* RISCV_PseudoVAADDU_VV_M1 (465) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAADDU_VV_M1_MASK (466) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAADDU_VV_M2 (467) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAADDU_VV_M2_MASK (468) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAADDU_VV_M4 (469) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAADDU_VV_M4_MASK (470) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAADDU_VV_M8 (471) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAADDU_VV_M8_MASK (472) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAADDU_VV_MF2 (473) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAADDU_VV_MF2_MASK (474) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAADDU_VV_MF4 (475) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAADDU_VV_MF4_MASK (476) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAADDU_VV_MF8 (477) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAADDU_VV_MF8_MASK (478) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAADDU_VX_M1 (479) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAADDU_VX_M1_MASK (480) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAADDU_VX_M2 (481) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAADDU_VX_M2_MASK (482) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAADDU_VX_M4 (483) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAADDU_VX_M4_MASK (484) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAADDU_VX_M8 (485) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAADDU_VX_M8_MASK (486) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAADDU_VX_MF2 (487) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAADDU_VX_MF2_MASK (488) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAADDU_VX_MF4 (489) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAADDU_VX_MF4_MASK (490) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAADDU_VX_MF8 (491) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAADDU_VX_MF8_MASK (492) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAADD_VV_M1 (493) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAADD_VV_M1_MASK (494) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAADD_VV_M2 (495) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAADD_VV_M2_MASK (496) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAADD_VV_M4 (497) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAADD_VV_M4_MASK (498) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAADD_VV_M8 (499) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAADD_VV_M8_MASK (500) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAADD_VV_MF2 (501) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAADD_VV_MF2_MASK (502) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAADD_VV_MF4 (503) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAADD_VV_MF4_MASK (504) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAADD_VV_MF8 (505) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAADD_VV_MF8_MASK (506) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAADD_VX_M1 (507) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAADD_VX_M1_MASK (508) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAADD_VX_M2 (509) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAADD_VX_M2_MASK (510) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAADD_VX_M4 (511) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAADD_VX_M4_MASK (512) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAADD_VX_M8 (513) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAADD_VX_M8_MASK (514) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAADD_VX_MF2 (515) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAADD_VX_MF2_MASK (516) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAADD_VX_MF4 (517) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAADD_VX_MF4_MASK (518) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAADD_VX_MF8 (519) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAADD_VX_MF8_MASK (520) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADC_VIM_M1 (521) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADC_VIM_M2 (522) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADC_VIM_M4 (523) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADC_VIM_M8 (524) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADC_VIM_MF2 (525) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADC_VIM_MF4 (526) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADC_VIM_MF8 (527) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADC_VVM_M1 (528) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADC_VVM_M2 (529) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADC_VVM_M4 (530) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADC_VVM_M8 (531) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADC_VVM_MF2 (532) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADC_VVM_MF4 (533) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADC_VVM_MF8 (534) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADC_VXM_M1 (535) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADC_VXM_M2 (536) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADC_VXM_M4 (537) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADC_VXM_M8 (538) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADC_VXM_MF2 (539) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADC_VXM_MF4 (540) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADC_VXM_MF8 (541) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADD_VI_M1 (542) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADD_VI_M1_MASK (543) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADD_VI_M2 (544) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADD_VI_M2_MASK (545) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADD_VI_M4 (546) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADD_VI_M4_MASK (547) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADD_VI_M8 (548) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADD_VI_M8_MASK (549) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADD_VI_MF2 (550) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADD_VI_MF2_MASK (551) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADD_VI_MF4 (552) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADD_VI_MF4_MASK (553) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADD_VI_MF8 (554) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADD_VI_MF8_MASK (555) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADD_VV_M1 (556) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADD_VV_M1_MASK (557) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADD_VV_M2 (558) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADD_VV_M2_MASK (559) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADD_VV_M4 (560) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADD_VV_M4_MASK (561) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADD_VV_M8 (562) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADD_VV_M8_MASK (563) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADD_VV_MF2 (564) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADD_VV_MF2_MASK (565) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADD_VV_MF4 (566) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADD_VV_MF4_MASK (567) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADD_VV_MF8 (568) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADD_VV_MF8_MASK (569) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADD_VX_M1 (570) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADD_VX_M1_MASK (571) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADD_VX_M2 (572) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADD_VX_M2_MASK (573) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADD_VX_M4 (574) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADD_VX_M4_MASK (575) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADD_VX_M8 (576) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADD_VX_M8_MASK (577) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADD_VX_MF2 (578) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADD_VX_MF2_MASK (579) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADD_VX_MF4 (580) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADD_VX_MF4_MASK (581) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADD_VX_MF8 (582) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVADD_VX_MF8_MASK (583) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESDF_VS_M1_M1 (584) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESDF_VS_M1_MF2 (585) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESDF_VS_M1_MF4 (586) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESDF_VS_M1_MF8 (587) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESDF_VS_M2_M1 (588) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESDF_VS_M2_M2 (589) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESDF_VS_M2_MF2 (590) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESDF_VS_M2_MF4 (591) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESDF_VS_M2_MF8 (592) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESDF_VS_M4_M1 (593) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESDF_VS_M4_M2 (594) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESDF_VS_M4_M4 (595) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESDF_VS_M4_MF2 (596) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESDF_VS_M4_MF4 (597) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESDF_VS_M4_MF8 (598) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESDF_VS_M8_M1 (599) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESDF_VS_M8_M2 (600) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESDF_VS_M8_M4 (601) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESDF_VS_M8_MF2 (602) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESDF_VS_M8_MF4 (603) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESDF_VS_M8_MF8 (604) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESDF_VS_MF2_MF2 (605) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESDF_VS_MF2_MF4 (606) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESDF_VS_MF2_MF8 (607) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESDF_VV_M1 (608) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESDF_VV_M2 (609) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESDF_VV_M4 (610) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESDF_VV_M8 (611) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESDF_VV_MF2 (612) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESDM_VS_M1_M1 (613) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESDM_VS_M1_MF2 (614) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESDM_VS_M1_MF4 (615) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESDM_VS_M1_MF8 (616) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESDM_VS_M2_M1 (617) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESDM_VS_M2_M2 (618) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESDM_VS_M2_MF2 (619) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESDM_VS_M2_MF4 (620) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESDM_VS_M2_MF8 (621) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESDM_VS_M4_M1 (622) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESDM_VS_M4_M2 (623) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESDM_VS_M4_M4 (624) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESDM_VS_M4_MF2 (625) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESDM_VS_M4_MF4 (626) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESDM_VS_M4_MF8 (627) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESDM_VS_M8_M1 (628) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESDM_VS_M8_M2 (629) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESDM_VS_M8_M4 (630) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESDM_VS_M8_MF2 (631) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESDM_VS_M8_MF4 (632) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESDM_VS_M8_MF8 (633) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESDM_VS_MF2_MF2 (634) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESDM_VS_MF2_MF4 (635) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESDM_VS_MF2_MF8 (636) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESDM_VV_M1 (637) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESDM_VV_M2 (638) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESDM_VV_M4 (639) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESDM_VV_M8 (640) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESDM_VV_MF2 (641) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESEF_VS_M1_M1 (642) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESEF_VS_M1_MF2 (643) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESEF_VS_M1_MF4 (644) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESEF_VS_M1_MF8 (645) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESEF_VS_M2_M1 (646) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESEF_VS_M2_M2 (647) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESEF_VS_M2_MF2 (648) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESEF_VS_M2_MF4 (649) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESEF_VS_M2_MF8 (650) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESEF_VS_M4_M1 (651) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESEF_VS_M4_M2 (652) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESEF_VS_M4_M4 (653) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESEF_VS_M4_MF2 (654) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESEF_VS_M4_MF4 (655) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESEF_VS_M4_MF8 (656) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESEF_VS_M8_M1 (657) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESEF_VS_M8_M2 (658) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESEF_VS_M8_M4 (659) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESEF_VS_M8_MF2 (660) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESEF_VS_M8_MF4 (661) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESEF_VS_M8_MF8 (662) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESEF_VS_MF2_MF2 (663) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESEF_VS_MF2_MF4 (664) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESEF_VS_MF2_MF8 (665) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESEF_VV_M1 (666) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESEF_VV_M2 (667) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESEF_VV_M4 (668) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESEF_VV_M8 (669) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESEF_VV_MF2 (670) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESEM_VS_M1_M1 (671) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESEM_VS_M1_MF2 (672) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESEM_VS_M1_MF4 (673) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESEM_VS_M1_MF8 (674) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESEM_VS_M2_M1 (675) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESEM_VS_M2_M2 (676) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESEM_VS_M2_MF2 (677) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESEM_VS_M2_MF4 (678) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESEM_VS_M2_MF8 (679) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESEM_VS_M4_M1 (680) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESEM_VS_M4_M2 (681) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESEM_VS_M4_M4 (682) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESEM_VS_M4_MF2 (683) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESEM_VS_M4_MF4 (684) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESEM_VS_M4_MF8 (685) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESEM_VS_M8_M1 (686) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESEM_VS_M8_M2 (687) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESEM_VS_M8_M4 (688) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESEM_VS_M8_MF2 (689) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESEM_VS_M8_MF4 (690) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESEM_VS_M8_MF8 (691) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESEM_VS_MF2_MF2 (692) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESEM_VS_MF2_MF4 (693) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESEM_VS_MF2_MF8 (694) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESEM_VV_M1 (695) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESEM_VV_M2 (696) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESEM_VV_M4 (697) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESEM_VV_M8 (698) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESEM_VV_MF2 (699) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESKF1_VI_M1 (700) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESKF1_VI_M2 (701) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESKF1_VI_M4 (702) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESKF1_VI_M8 (703) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESKF1_VI_MF2 (704) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESKF2_VI_M1 (705) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESKF2_VI_M2 (706) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESKF2_VI_M4 (707) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESKF2_VI_M8 (708) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESKF2_VI_MF2 (709) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESZ_VS_M1_M1 (710) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESZ_VS_M1_MF2 (711) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESZ_VS_M1_MF4 (712) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESZ_VS_M1_MF8 (713) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESZ_VS_M2_M1 (714) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESZ_VS_M2_M2 (715) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESZ_VS_M2_MF2 (716) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESZ_VS_M2_MF4 (717) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESZ_VS_M2_MF8 (718) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESZ_VS_M4_M1 (719) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESZ_VS_M4_M2 (720) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESZ_VS_M4_M4 (721) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESZ_VS_M4_MF2 (722) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESZ_VS_M4_MF4 (723) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESZ_VS_M4_MF8 (724) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESZ_VS_M8_M1 (725) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESZ_VS_M8_M2 (726) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESZ_VS_M8_M4 (727) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESZ_VS_M8_MF2 (728) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESZ_VS_M8_MF4 (729) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESZ_VS_M8_MF8 (730) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESZ_VS_MF2_MF2 (731) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESZ_VS_MF2_MF4 (732) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAESZ_VS_MF2_MF8 (733) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVANDN_VV_M1 (734) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVANDN_VV_M1_MASK (735) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVANDN_VV_M2 (736) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVANDN_VV_M2_MASK (737) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVANDN_VV_M4 (738) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVANDN_VV_M4_MASK (739) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVANDN_VV_M8 (740) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVANDN_VV_M8_MASK (741) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVANDN_VV_MF2 (742) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVANDN_VV_MF2_MASK (743) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVANDN_VV_MF4 (744) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVANDN_VV_MF4_MASK (745) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVANDN_VV_MF8 (746) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVANDN_VV_MF8_MASK (747) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVANDN_VX_M1 (748) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVANDN_VX_M1_MASK (749) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVANDN_VX_M2 (750) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVANDN_VX_M2_MASK (751) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVANDN_VX_M4 (752) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVANDN_VX_M4_MASK (753) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVANDN_VX_M8 (754) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVANDN_VX_M8_MASK (755) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVANDN_VX_MF2 (756) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVANDN_VX_MF2_MASK (757) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVANDN_VX_MF4 (758) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVANDN_VX_MF4_MASK (759) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVANDN_VX_MF8 (760) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVANDN_VX_MF8_MASK (761) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAND_VI_M1 (762) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAND_VI_M1_MASK (763) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAND_VI_M2 (764) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAND_VI_M2_MASK (765) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAND_VI_M4 (766) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAND_VI_M4_MASK (767) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAND_VI_M8 (768) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAND_VI_M8_MASK (769) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAND_VI_MF2 (770) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAND_VI_MF2_MASK (771) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAND_VI_MF4 (772) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAND_VI_MF4_MASK (773) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAND_VI_MF8 (774) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAND_VI_MF8_MASK (775) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAND_VV_M1 (776) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAND_VV_M1_MASK (777) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAND_VV_M2 (778) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAND_VV_M2_MASK (779) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAND_VV_M4 (780) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAND_VV_M4_MASK (781) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAND_VV_M8 (782) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAND_VV_M8_MASK (783) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAND_VV_MF2 (784) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAND_VV_MF2_MASK (785) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAND_VV_MF4 (786) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAND_VV_MF4_MASK (787) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAND_VV_MF8 (788) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAND_VV_MF8_MASK (789) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAND_VX_M1 (790) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAND_VX_M1_MASK (791) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAND_VX_M2 (792) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAND_VX_M2_MASK (793) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAND_VX_M4 (794) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAND_VX_M4_MASK (795) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAND_VX_M8 (796) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAND_VX_M8_MASK (797) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAND_VX_MF2 (798) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAND_VX_MF2_MASK (799) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAND_VX_MF4 (800) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAND_VX_MF4_MASK (801) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAND_VX_MF8 (802) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVAND_VX_MF8_MASK (803) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVASUBU_VV_M1 (804) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVASUBU_VV_M1_MASK (805) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVASUBU_VV_M2 (806) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVASUBU_VV_M2_MASK (807) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVASUBU_VV_M4 (808) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVASUBU_VV_M4_MASK (809) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVASUBU_VV_M8 (810) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVASUBU_VV_M8_MASK (811) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVASUBU_VV_MF2 (812) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVASUBU_VV_MF2_MASK (813) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVASUBU_VV_MF4 (814) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVASUBU_VV_MF4_MASK (815) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVASUBU_VV_MF8 (816) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVASUBU_VV_MF8_MASK (817) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVASUBU_VX_M1 (818) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVASUBU_VX_M1_MASK (819) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVASUBU_VX_M2 (820) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVASUBU_VX_M2_MASK (821) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVASUBU_VX_M4 (822) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVASUBU_VX_M4_MASK (823) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVASUBU_VX_M8 (824) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVASUBU_VX_M8_MASK (825) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVASUBU_VX_MF2 (826) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVASUBU_VX_MF2_MASK (827) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVASUBU_VX_MF4 (828) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVASUBU_VX_MF4_MASK (829) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVASUBU_VX_MF8 (830) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVASUBU_VX_MF8_MASK (831) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVASUB_VV_M1 (832) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVASUB_VV_M1_MASK (833) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVASUB_VV_M2 (834) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVASUB_VV_M2_MASK (835) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVASUB_VV_M4 (836) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVASUB_VV_M4_MASK (837) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVASUB_VV_M8 (838) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVASUB_VV_M8_MASK (839) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVASUB_VV_MF2 (840) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVASUB_VV_MF2_MASK (841) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVASUB_VV_MF4 (842) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVASUB_VV_MF4_MASK (843) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVASUB_VV_MF8 (844) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVASUB_VV_MF8_MASK (845) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVASUB_VX_M1 (846) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVASUB_VX_M1_MASK (847) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVASUB_VX_M2 (848) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVASUB_VX_M2_MASK (849) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVASUB_VX_M4 (850) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVASUB_VX_M4_MASK (851) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVASUB_VX_M8 (852) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVASUB_VX_M8_MASK (853) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVASUB_VX_MF2 (854) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVASUB_VX_MF2_MASK (855) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVASUB_VX_MF4 (856) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVASUB_VX_MF4_MASK (857) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVASUB_VX_MF8 (858) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVASUB_VX_MF8_MASK (859) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVBREV8_V_M1 (860) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVBREV8_V_M1_MASK (861) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVBREV8_V_M2 (862) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVBREV8_V_M2_MASK (863) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVBREV8_V_M4 (864) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVBREV8_V_M4_MASK (865) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVBREV8_V_M8 (866) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVBREV8_V_M8_MASK (867) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVBREV8_V_MF2 (868) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVBREV8_V_MF2_MASK (869) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVBREV8_V_MF4 (870) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVBREV8_V_MF4_MASK (871) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVBREV8_V_MF8 (872) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVBREV8_V_MF8_MASK (873) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVBREV_V_M1 (874) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVBREV_V_M1_MASK (875) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVBREV_V_M2 (876) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVBREV_V_M2_MASK (877) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVBREV_V_M4 (878) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVBREV_V_M4_MASK (879) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVBREV_V_M8 (880) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVBREV_V_M8_MASK (881) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVBREV_V_MF2 (882) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVBREV_V_MF2_MASK (883) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVBREV_V_MF4 (884) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVBREV_V_MF4_MASK (885) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVBREV_V_MF8 (886) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVBREV_V_MF8_MASK (887) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLMULH_VV_M1 (888) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLMULH_VV_M1_MASK (889) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLMULH_VV_M2 (890) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLMULH_VV_M2_MASK (891) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLMULH_VV_M4 (892) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLMULH_VV_M4_MASK (893) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLMULH_VV_M8 (894) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLMULH_VV_M8_MASK (895) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLMULH_VV_MF2 (896) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLMULH_VV_MF2_MASK (897) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLMULH_VV_MF4 (898) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLMULH_VV_MF4_MASK (899) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLMULH_VV_MF8 (900) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLMULH_VV_MF8_MASK (901) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLMULH_VX_M1 (902) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLMULH_VX_M1_MASK (903) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLMULH_VX_M2 (904) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLMULH_VX_M2_MASK (905) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLMULH_VX_M4 (906) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLMULH_VX_M4_MASK (907) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLMULH_VX_M8 (908) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLMULH_VX_M8_MASK (909) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLMULH_VX_MF2 (910) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLMULH_VX_MF2_MASK (911) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLMULH_VX_MF4 (912) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLMULH_VX_MF4_MASK (913) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLMULH_VX_MF8 (914) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLMULH_VX_MF8_MASK (915) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLMUL_VV_M1 (916) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLMUL_VV_M1_MASK (917) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLMUL_VV_M2 (918) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLMUL_VV_M2_MASK (919) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLMUL_VV_M4 (920) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLMUL_VV_M4_MASK (921) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLMUL_VV_M8 (922) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLMUL_VV_M8_MASK (923) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLMUL_VV_MF2 (924) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLMUL_VV_MF2_MASK (925) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLMUL_VV_MF4 (926) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLMUL_VV_MF4_MASK (927) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLMUL_VV_MF8 (928) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLMUL_VV_MF8_MASK (929) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLMUL_VX_M1 (930) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLMUL_VX_M1_MASK (931) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLMUL_VX_M2 (932) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLMUL_VX_M2_MASK (933) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLMUL_VX_M4 (934) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLMUL_VX_M4_MASK (935) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLMUL_VX_M8 (936) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLMUL_VX_M8_MASK (937) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLMUL_VX_MF2 (938) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLMUL_VX_MF2_MASK (939) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLMUL_VX_MF4 (940) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLMUL_VX_MF4_MASK (941) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLMUL_VX_MF8 (942) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLMUL_VX_MF8_MASK (943) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLZ_V_M1 (944) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLZ_V_M1_MASK (945) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLZ_V_M2 (946) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLZ_V_M2_MASK (947) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLZ_V_M4 (948) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLZ_V_M4_MASK (949) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLZ_V_M8 (950) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLZ_V_M8_MASK (951) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLZ_V_MF2 (952) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLZ_V_MF2_MASK (953) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLZ_V_MF4 (954) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLZ_V_MF4_MASK (955) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLZ_V_MF8 (956) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCLZ_V_MF8_MASK (957) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCOMPRESS_VM_M1_E16 (958) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCOMPRESS_VM_M1_E32 (959) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCOMPRESS_VM_M1_E64 (960) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCOMPRESS_VM_M1_E8 (961) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCOMPRESS_VM_M2_E16 (962) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCOMPRESS_VM_M2_E32 (963) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCOMPRESS_VM_M2_E64 (964) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCOMPRESS_VM_M2_E8 (965) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCOMPRESS_VM_M4_E16 (966) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCOMPRESS_VM_M4_E32 (967) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCOMPRESS_VM_M4_E64 (968) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCOMPRESS_VM_M4_E8 (969) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCOMPRESS_VM_M8_E16 (970) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCOMPRESS_VM_M8_E32 (971) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCOMPRESS_VM_M8_E64 (972) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCOMPRESS_VM_M8_E8 (973) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCOMPRESS_VM_MF2_E16 (974) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCOMPRESS_VM_MF2_E32 (975) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCOMPRESS_VM_MF2_E8 (976) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCOMPRESS_VM_MF4_E16 (977) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCOMPRESS_VM_MF4_E8 (978) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCOMPRESS_VM_MF8_E8 (979) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCPOP_M_B1 (980) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCPOP_M_B16 (981) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCPOP_M_B16_MASK (982) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCPOP_M_B1_MASK (983) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCPOP_M_B2 (984) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCPOP_M_B2_MASK (985) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCPOP_M_B32 (986) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCPOP_M_B32_MASK (987) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCPOP_M_B4 (988) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCPOP_M_B4_MASK (989) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCPOP_M_B64 (990) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCPOP_M_B64_MASK (991) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCPOP_M_B8 (992) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCPOP_M_B8_MASK (993) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCPOP_V_M1 (994) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCPOP_V_M1_MASK (995) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCPOP_V_M2 (996) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCPOP_V_M2_MASK (997) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCPOP_V_M4 (998) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCPOP_V_M4_MASK (999) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCPOP_V_M8 (1000) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCPOP_V_M8_MASK (1001) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCPOP_V_MF2 (1002) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCPOP_V_MF2_MASK (1003) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCPOP_V_MF4 (1004) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCPOP_V_MF4_MASK (1005) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCPOP_V_MF8 (1006) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCPOP_V_MF8_MASK (1007) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCTZ_V_M1 (1008) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCTZ_V_M1_MASK (1009) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCTZ_V_M2 (1010) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCTZ_V_M2_MASK (1011) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCTZ_V_M4 (1012) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCTZ_V_M4_MASK (1013) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCTZ_V_M8 (1014) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCTZ_V_M8_MASK (1015) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCTZ_V_MF2 (1016) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCTZ_V_MF2_MASK (1017) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCTZ_V_MF4 (1018) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCTZ_V_MF4_MASK (1019) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCTZ_V_MF8 (1020) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVCTZ_V_MF8_MASK (1021) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_FPR16VV_SE_M1 (1022) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_FPR16VV_SE_M2 (1023) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_FPR16VV_SE_M4 (1024) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_FPR16VV_SE_M8 (1025) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_FPR16VV_SE_MF2 (1026) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_FPR16VV_SE_MF4 (1027) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_FPR16VW_SE_M1 (1028) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_FPR16VW_SE_M2 (1029) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_FPR16VW_SE_M4 (1030) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_FPR16VW_SE_M8 (1031) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_FPR16VW_SE_MF2 (1032) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_FPR16VW_SE_MF4 (1033) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_FPR16V_SE_M1 (1034) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_FPR16V_SE_M2 (1035) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_FPR16V_SE_M4 (1036) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_FPR16V_SE_M8 (1037) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_FPR16V_SE_MF2 (1038) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_FPR16V_SE_MF4 (1039) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_FPR32VV_SE_M1 (1040) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_FPR32VV_SE_M2 (1041) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_FPR32VV_SE_M4 (1042) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_FPR32VV_SE_M8 (1043) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_FPR32VV_SE_MF2 (1044) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_FPR32VW_SE_M1 (1045) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_FPR32VW_SE_M2 (1046) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_FPR32VW_SE_M4 (1047) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_FPR32VW_SE_M8 (1048) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_FPR32VW_SE_MF2 (1049) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_FPR32V_SE_M1 (1050) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_FPR32V_SE_M2 (1051) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_FPR32V_SE_M4 (1052) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_FPR32V_SE_M8 (1053) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_FPR32V_SE_MF2 (1054) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_FPR64VV_SE_M1 (1055) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_FPR64VV_SE_M2 (1056) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_FPR64VV_SE_M4 (1057) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_FPR64VV_SE_M8 (1058) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_FPR64V_SE_M1 (1059) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_FPR64V_SE_M2 (1060) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_FPR64V_SE_M4 (1061) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_FPR64V_SE_M8 (1062) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_IVV_SE_M1 (1063) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_IVV_SE_M2 (1064) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_IVV_SE_M4 (1065) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_IVV_SE_M8 (1066) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_IVV_SE_MF2 (1067) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_IVV_SE_MF4 (1068) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_IVV_SE_MF8 (1069) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_IVW_SE_M1 (1070) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_IVW_SE_M2 (1071) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_IVW_SE_M4 (1072) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_IVW_SE_MF2 (1073) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_IVW_SE_MF4 (1074) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_IVW_SE_MF8 (1075) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_IV_SE_M1 (1076) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_IV_SE_M2 (1077) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_IV_SE_M4 (1078) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_IV_SE_M8 (1079) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_IV_SE_MF2 (1080) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_IV_SE_MF4 (1081) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_IV_SE_MF8 (1082) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_I_SE_M1 (1083) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_I_SE_M2 (1084) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_I_SE_M4 (1085) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_I_SE_M8 (1086) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_I_SE_MF2 (1087) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_I_SE_MF4 (1088) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_I_SE_MF8 (1089) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_VVV_SE_M1 (1090) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_VVV_SE_M2 (1091) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_VVV_SE_M4 (1092) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_VVV_SE_M8 (1093) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_VVV_SE_MF2 (1094) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_VVV_SE_MF4 (1095) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_VVV_SE_MF8 (1096) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_VVW_SE_M1 (1097) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_VVW_SE_M2 (1098) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_VVW_SE_M4 (1099) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_VVW_SE_MF2 (1100) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_VVW_SE_MF4 (1101) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_VVW_SE_MF8 (1102) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_VV_SE_M1 (1103) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_VV_SE_M2 (1104) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_VV_SE_M4 (1105) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_VV_SE_M8 (1106) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_VV_SE_MF2 (1107) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_VV_SE_MF4 (1108) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_VV_SE_MF8 (1109) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR16VV_M1 (1110) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR16VV_M2 (1111) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR16VV_M4 (1112) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR16VV_M8 (1113) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR16VV_MF2 (1114) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR16VV_MF4 (1115) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR16VV_SE_M1 (1116) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR16VV_SE_M2 (1117) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR16VV_SE_M4 (1118) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR16VV_SE_M8 (1119) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR16VV_SE_MF2 (1120) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR16VV_SE_MF4 (1121) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR16VW_M1 (1122) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR16VW_M2 (1123) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR16VW_M4 (1124) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR16VW_M8 (1125) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR16VW_MF2 (1126) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR16VW_MF4 (1127) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR16VW_SE_M1 (1128) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR16VW_SE_M2 (1129) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR16VW_SE_M4 (1130) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR16VW_SE_M8 (1131) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR16VW_SE_MF2 (1132) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR16VW_SE_MF4 (1133) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR16V_M1 (1134) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR16V_M2 (1135) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR16V_M4 (1136) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR16V_M8 (1137) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR16V_MF2 (1138) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR16V_MF4 (1139) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR16V_SE_M1 (1140) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR16V_SE_M2 (1141) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR16V_SE_M4 (1142) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR16V_SE_M8 (1143) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR16V_SE_MF2 (1144) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR16V_SE_MF4 (1145) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR32VV_M1 (1146) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR32VV_M2 (1147) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR32VV_M4 (1148) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR32VV_M8 (1149) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR32VV_MF2 (1150) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR32VV_SE_M1 (1151) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR32VV_SE_M2 (1152) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR32VV_SE_M4 (1153) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR32VV_SE_M8 (1154) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR32VV_SE_MF2 (1155) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR32VW_M1 (1156) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR32VW_M2 (1157) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR32VW_M4 (1158) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR32VW_M8 (1159) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR32VW_MF2 (1160) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR32VW_SE_M1 (1161) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR32VW_SE_M2 (1162) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR32VW_SE_M4 (1163) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR32VW_SE_M8 (1164) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR32VW_SE_MF2 (1165) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR32V_M1 (1166) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR32V_M2 (1167) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR32V_M4 (1168) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR32V_M8 (1169) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR32V_MF2 (1170) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR32V_SE_M1 (1171) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR32V_SE_M2 (1172) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR32V_SE_M4 (1173) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR32V_SE_M8 (1174) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR32V_SE_MF2 (1175) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR64VV_M1 (1176) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR64VV_M2 (1177) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR64VV_M4 (1178) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR64VV_M8 (1179) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR64VV_SE_M1 (1180) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR64VV_SE_M2 (1181) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR64VV_SE_M4 (1182) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR64VV_SE_M8 (1183) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR64V_M1 (1184) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR64V_M2 (1185) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR64V_M4 (1186) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR64V_M8 (1187) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR64V_SE_M1 (1188) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR64V_SE_M2 (1189) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR64V_SE_M4 (1190) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_FPR64V_SE_M8 (1191) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_IVV_M1 (1192) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_IVV_M2 (1193) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_IVV_M4 (1194) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_IVV_M8 (1195) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_IVV_MF2 (1196) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_IVV_MF4 (1197) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_IVV_MF8 (1198) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_IVV_SE_M1 (1199) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_IVV_SE_M2 (1200) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_IVV_SE_M4 (1201) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_IVV_SE_M8 (1202) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_IVV_SE_MF2 (1203) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_IVV_SE_MF4 (1204) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_IVV_SE_MF8 (1205) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_IVW_M1 (1206) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_IVW_M2 (1207) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_IVW_M4 (1208) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_IVW_MF2 (1209) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_IVW_MF4 (1210) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_IVW_MF8 (1211) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_IVW_SE_M1 (1212) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_IVW_SE_M2 (1213) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_IVW_SE_M4 (1214) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_IVW_SE_MF2 (1215) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_IVW_SE_MF4 (1216) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_IVW_SE_MF8 (1217) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_IV_M1 (1218) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_IV_M2 (1219) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_IV_M4 (1220) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_IV_M8 (1221) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_IV_MF2 (1222) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_IV_MF4 (1223) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_IV_MF8 (1224) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_IV_SE_M1 (1225) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_IV_SE_M2 (1226) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_IV_SE_M4 (1227) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_IV_SE_M8 (1228) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_IV_SE_MF2 (1229) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_IV_SE_MF4 (1230) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_IV_SE_MF8 (1231) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_I_M1 (1232) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_I_M2 (1233) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_I_M4 (1234) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_I_M8 (1235) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_I_MF2 (1236) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_I_MF4 (1237) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_I_MF8 (1238) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_I_SE_M1 (1239) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_I_SE_M2 (1240) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_I_SE_M4 (1241) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_I_SE_M8 (1242) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_I_SE_MF2 (1243) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_I_SE_MF4 (1244) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_I_SE_MF8 (1245) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_VVV_M1 (1246) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_VVV_M2 (1247) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_VVV_M4 (1248) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_VVV_M8 (1249) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_VVV_MF2 (1250) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_VVV_MF4 (1251) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_VVV_MF8 (1252) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_VVV_SE_M1 (1253) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_VVV_SE_M2 (1254) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_VVV_SE_M4 (1255) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_VVV_SE_M8 (1256) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_VVV_SE_MF2 (1257) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_VVV_SE_MF4 (1258) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_VVV_SE_MF8 (1259) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_VVW_M1 (1260) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_VVW_M2 (1261) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_VVW_M4 (1262) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_VVW_MF2 (1263) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_VVW_MF4 (1264) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_VVW_MF8 (1265) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_VVW_SE_M1 (1266) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_VVW_SE_M2 (1267) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_VVW_SE_M4 (1268) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_VVW_SE_MF2 (1269) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_VVW_SE_MF4 (1270) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_VVW_SE_MF8 (1271) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_VV_M1 (1272) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_VV_M2 (1273) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_VV_M4 (1274) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_VV_M8 (1275) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_VV_MF2 (1276) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_VV_MF4 (1277) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_VV_MF8 (1278) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_VV_SE_M1 (1279) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_VV_SE_M2 (1280) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_VV_SE_M4 (1281) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_VV_SE_M8 (1282) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_VV_SE_MF2 (1283) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_VV_SE_MF4 (1284) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_VV_SE_MF8 (1285) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_XVV_M1 (1286) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_XVV_M2 (1287) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_XVV_M4 (1288) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_XVV_M8 (1289) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_XVV_MF2 (1290) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_XVV_MF4 (1291) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_XVV_MF8 (1292) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_XVV_SE_M1 (1293) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_XVV_SE_M2 (1294) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_XVV_SE_M4 (1295) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_XVV_SE_M8 (1296) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_XVV_SE_MF2 (1297) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_XVV_SE_MF4 (1298) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_XVV_SE_MF8 (1299) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_XVW_M1 (1300) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_XVW_M2 (1301) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_XVW_M4 (1302) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_XVW_MF2 (1303) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_XVW_MF4 (1304) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_XVW_MF8 (1305) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_XVW_SE_M1 (1306) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_XVW_SE_M2 (1307) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_XVW_SE_M4 (1308) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_XVW_SE_MF2 (1309) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_XVW_SE_MF4 (1310) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_XVW_SE_MF8 (1311) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_XV_M1 (1312) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_XV_M2 (1313) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_XV_M4 (1314) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_XV_M8 (1315) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_XV_MF2 (1316) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_XV_MF4 (1317) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_XV_MF8 (1318) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_XV_SE_M1 (1319) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_XV_SE_M2 (1320) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_XV_SE_M4 (1321) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_XV_SE_M8 (1322) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_XV_SE_MF2 (1323) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_XV_SE_MF4 (1324) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_XV_SE_MF8 (1325) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_X_M1 (1326) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_X_M2 (1327) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_X_M4 (1328) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_X_M8 (1329) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_X_MF2 (1330) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_X_MF4 (1331) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_X_MF8 (1332) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_X_SE_M1 (1333) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_X_SE_M2 (1334) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_X_SE_M4 (1335) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_X_SE_M8 (1336) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_X_SE_MF2 (1337) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_X_SE_MF4 (1338) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_V_X_SE_MF8 (1339) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_XVV_SE_M1 (1340) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_XVV_SE_M2 (1341) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_XVV_SE_M4 (1342) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_XVV_SE_M8 (1343) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_XVV_SE_MF2 (1344) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_XVV_SE_MF4 (1345) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_XVV_SE_MF8 (1346) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_XVW_SE_M1 (1347) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_XVW_SE_M2 (1348) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_XVW_SE_M4 (1349) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_XVW_SE_MF2 (1350) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_XVW_SE_MF4 (1351) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_XVW_SE_MF8 (1352) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_XV_SE_M1 (1353) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_XV_SE_M2 (1354) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_XV_SE_M4 (1355) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_XV_SE_M8 (1356) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_XV_SE_MF2 (1357) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_XV_SE_MF4 (1358) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_XV_SE_MF8 (1359) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_X_SE_M1 (1360) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_X_SE_M2 (1361) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_X_SE_M4 (1362) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_X_SE_M8 (1363) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_X_SE_MF2 (1364) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_X_SE_MF4 (1365) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVC_X_SE_MF8 (1366) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VV_M1_E16 (1367) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VV_M1_E16_MASK (1368) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VV_M1_E32 (1369) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VV_M1_E32_MASK (1370) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VV_M1_E64 (1371) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VV_M1_E64_MASK (1372) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VV_M1_E8 (1373) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VV_M1_E8_MASK (1374) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VV_M2_E16 (1375) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VV_M2_E16_MASK (1376) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VV_M2_E32 (1377) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VV_M2_E32_MASK (1378) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VV_M2_E64 (1379) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VV_M2_E64_MASK (1380) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VV_M2_E8 (1381) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VV_M2_E8_MASK (1382) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VV_M4_E16 (1383) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VV_M4_E16_MASK (1384) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VV_M4_E32 (1385) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VV_M4_E32_MASK (1386) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VV_M4_E64 (1387) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VV_M4_E64_MASK (1388) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VV_M4_E8 (1389) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VV_M4_E8_MASK (1390) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VV_M8_E16 (1391) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VV_M8_E16_MASK (1392) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VV_M8_E32 (1393) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VV_M8_E32_MASK (1394) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VV_M8_E64 (1395) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VV_M8_E64_MASK (1396) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VV_M8_E8 (1397) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VV_M8_E8_MASK (1398) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VV_MF2_E16 (1399) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VV_MF2_E16_MASK (1400) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VV_MF2_E32 (1401) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VV_MF2_E32_MASK (1402) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VV_MF2_E8 (1403) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VV_MF2_E8_MASK (1404) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VV_MF4_E16 (1405) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VV_MF4_E16_MASK (1406) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VV_MF4_E8 (1407) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VV_MF4_E8_MASK (1408) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VV_MF8_E8 (1409) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VV_MF8_E8_MASK (1410) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VX_M1_E16 (1411) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VX_M1_E16_MASK (1412) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VX_M1_E32 (1413) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VX_M1_E32_MASK (1414) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VX_M1_E64 (1415) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VX_M1_E64_MASK (1416) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VX_M1_E8 (1417) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VX_M1_E8_MASK (1418) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VX_M2_E16 (1419) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VX_M2_E16_MASK (1420) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VX_M2_E32 (1421) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VX_M2_E32_MASK (1422) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VX_M2_E64 (1423) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VX_M2_E64_MASK (1424) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VX_M2_E8 (1425) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VX_M2_E8_MASK (1426) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VX_M4_E16 (1427) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VX_M4_E16_MASK (1428) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VX_M4_E32 (1429) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VX_M4_E32_MASK (1430) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VX_M4_E64 (1431) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VX_M4_E64_MASK (1432) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VX_M4_E8 (1433) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VX_M4_E8_MASK (1434) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VX_M8_E16 (1435) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VX_M8_E16_MASK (1436) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VX_M8_E32 (1437) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VX_M8_E32_MASK (1438) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VX_M8_E64 (1439) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VX_M8_E64_MASK (1440) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VX_M8_E8 (1441) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VX_M8_E8_MASK (1442) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VX_MF2_E16 (1443) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VX_MF2_E16_MASK (1444) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VX_MF2_E32 (1445) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VX_MF2_E32_MASK (1446) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VX_MF2_E8 (1447) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VX_MF2_E8_MASK (1448) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VX_MF4_E16 (1449) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VX_MF4_E16_MASK (1450) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VX_MF4_E8 (1451) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VX_MF4_E8_MASK (1452) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VX_MF8_E8 (1453) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIVU_VX_MF8_E8_MASK (1454) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VV_M1_E16 (1455) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VV_M1_E16_MASK (1456) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VV_M1_E32 (1457) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VV_M1_E32_MASK (1458) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VV_M1_E64 (1459) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VV_M1_E64_MASK (1460) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VV_M1_E8 (1461) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VV_M1_E8_MASK (1462) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VV_M2_E16 (1463) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VV_M2_E16_MASK (1464) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VV_M2_E32 (1465) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VV_M2_E32_MASK (1466) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VV_M2_E64 (1467) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VV_M2_E64_MASK (1468) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VV_M2_E8 (1469) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VV_M2_E8_MASK (1470) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VV_M4_E16 (1471) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VV_M4_E16_MASK (1472) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VV_M4_E32 (1473) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VV_M4_E32_MASK (1474) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VV_M4_E64 (1475) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VV_M4_E64_MASK (1476) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VV_M4_E8 (1477) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VV_M4_E8_MASK (1478) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VV_M8_E16 (1479) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VV_M8_E16_MASK (1480) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VV_M8_E32 (1481) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VV_M8_E32_MASK (1482) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VV_M8_E64 (1483) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VV_M8_E64_MASK (1484) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VV_M8_E8 (1485) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VV_M8_E8_MASK (1486) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VV_MF2_E16 (1487) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VV_MF2_E16_MASK (1488) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VV_MF2_E32 (1489) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VV_MF2_E32_MASK (1490) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VV_MF2_E8 (1491) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VV_MF2_E8_MASK (1492) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VV_MF4_E16 (1493) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VV_MF4_E16_MASK (1494) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VV_MF4_E8 (1495) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VV_MF4_E8_MASK (1496) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VV_MF8_E8 (1497) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VV_MF8_E8_MASK (1498) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VX_M1_E16 (1499) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VX_M1_E16_MASK (1500) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VX_M1_E32 (1501) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VX_M1_E32_MASK (1502) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VX_M1_E64 (1503) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VX_M1_E64_MASK (1504) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VX_M1_E8 (1505) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VX_M1_E8_MASK (1506) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VX_M2_E16 (1507) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VX_M2_E16_MASK (1508) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VX_M2_E32 (1509) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VX_M2_E32_MASK (1510) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VX_M2_E64 (1511) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VX_M2_E64_MASK (1512) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VX_M2_E8 (1513) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VX_M2_E8_MASK (1514) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VX_M4_E16 (1515) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VX_M4_E16_MASK (1516) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VX_M4_E32 (1517) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VX_M4_E32_MASK (1518) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VX_M4_E64 (1519) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VX_M4_E64_MASK (1520) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VX_M4_E8 (1521) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VX_M4_E8_MASK (1522) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VX_M8_E16 (1523) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VX_M8_E16_MASK (1524) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VX_M8_E32 (1525) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VX_M8_E32_MASK (1526) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VX_M8_E64 (1527) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VX_M8_E64_MASK (1528) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VX_M8_E8 (1529) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VX_M8_E8_MASK (1530) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VX_MF2_E16 (1531) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VX_MF2_E16_MASK (1532) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VX_MF2_E32 (1533) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VX_MF2_E32_MASK (1534) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VX_MF2_E8 (1535) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VX_MF2_E8_MASK (1536) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VX_MF4_E16 (1537) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VX_MF4_E16_MASK (1538) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VX_MF4_E8 (1539) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VX_MF4_E8_MASK (1540) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VX_MF8_E8 (1541) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVDIV_VX_MF8_E8_MASK (1542) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFADD_VFPR16_M1 (1543) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFADD_VFPR16_M1_MASK (1544) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFADD_VFPR16_M2 (1545) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFADD_VFPR16_M2_MASK (1546) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFADD_VFPR16_M4 (1547) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFADD_VFPR16_M4_MASK (1548) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFADD_VFPR16_M8 (1549) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFADD_VFPR16_M8_MASK (1550) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFADD_VFPR16_MF2 (1551) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFADD_VFPR16_MF2_MASK (1552) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFADD_VFPR16_MF4 (1553) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFADD_VFPR16_MF4_MASK (1554) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFADD_VFPR32_M1 (1555) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFADD_VFPR32_M1_MASK (1556) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFADD_VFPR32_M2 (1557) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFADD_VFPR32_M2_MASK (1558) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFADD_VFPR32_M4 (1559) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFADD_VFPR32_M4_MASK (1560) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFADD_VFPR32_M8 (1561) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFADD_VFPR32_M8_MASK (1562) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFADD_VFPR32_MF2 (1563) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFADD_VFPR32_MF2_MASK (1564) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFADD_VFPR64_M1 (1565) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFADD_VFPR64_M1_MASK (1566) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFADD_VFPR64_M2 (1567) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFADD_VFPR64_M2_MASK (1568) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFADD_VFPR64_M4 (1569) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFADD_VFPR64_M4_MASK (1570) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFADD_VFPR64_M8 (1571) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFADD_VFPR64_M8_MASK (1572) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFADD_VV_M1 (1573) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFADD_VV_M1_MASK (1574) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFADD_VV_M2 (1575) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFADD_VV_M2_MASK (1576) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFADD_VV_M4 (1577) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFADD_VV_M4_MASK (1578) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFADD_VV_M8 (1579) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFADD_VV_M8_MASK (1580) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFADD_VV_MF2 (1581) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFADD_VV_MF2_MASK (1582) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFADD_VV_MF4 (1583) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFADD_VV_MF4_MASK (1584) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCLASS_V_M1 (1585) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCLASS_V_M1_MASK (1586) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCLASS_V_M2 (1587) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCLASS_V_M2_MASK (1588) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCLASS_V_M4 (1589) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCLASS_V_M4_MASK (1590) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCLASS_V_M8 (1591) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCLASS_V_M8_MASK (1592) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCLASS_V_MF2 (1593) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCLASS_V_MF2_MASK (1594) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCLASS_V_MF4 (1595) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCLASS_V_MF4_MASK (1596) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_F_XU_V_M1 (1597) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_F_XU_V_M1_MASK (1598) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_F_XU_V_M2 (1599) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_F_XU_V_M2_MASK (1600) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_F_XU_V_M4 (1601) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_F_XU_V_M4_MASK (1602) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_F_XU_V_M8 (1603) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_F_XU_V_M8_MASK (1604) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_F_XU_V_MF2 (1605) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_F_XU_V_MF2_MASK (1606) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_F_XU_V_MF4 (1607) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_F_XU_V_MF4_MASK (1608) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_F_X_V_M1 (1609) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_F_X_V_M1_MASK (1610) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_F_X_V_M2 (1611) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_F_X_V_M2_MASK (1612) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_F_X_V_M4 (1613) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_F_X_V_M4_MASK (1614) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_F_X_V_M8 (1615) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_F_X_V_M8_MASK (1616) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_F_X_V_MF2 (1617) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_F_X_V_MF2_MASK (1618) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_F_X_V_MF4 (1619) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_F_X_V_MF4_MASK (1620) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RM_F_XU_V_M1 (1621) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RM_F_XU_V_M1_MASK (1622) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RM_F_XU_V_M2 (1623) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RM_F_XU_V_M2_MASK (1624) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RM_F_XU_V_M4 (1625) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RM_F_XU_V_M4_MASK (1626) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RM_F_XU_V_M8 (1627) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RM_F_XU_V_M8_MASK (1628) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RM_F_XU_V_MF2 (1629) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RM_F_XU_V_MF2_MASK (1630) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RM_F_XU_V_MF4 (1631) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RM_F_XU_V_MF4_MASK (1632) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RM_F_X_V_M1 (1633) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RM_F_X_V_M1_MASK (1634) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RM_F_X_V_M2 (1635) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RM_F_X_V_M2_MASK (1636) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RM_F_X_V_M4 (1637) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RM_F_X_V_M4_MASK (1638) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RM_F_X_V_M8 (1639) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RM_F_X_V_M8_MASK (1640) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RM_F_X_V_MF2 (1641) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RM_F_X_V_MF2_MASK (1642) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RM_F_X_V_MF4 (1643) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RM_F_X_V_MF4_MASK (1644) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RM_XU_F_V_M1 (1645) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RM_XU_F_V_M1_MASK (1646) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RM_XU_F_V_M2 (1647) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RM_XU_F_V_M2_MASK (1648) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RM_XU_F_V_M4 (1649) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RM_XU_F_V_M4_MASK (1650) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RM_XU_F_V_M8 (1651) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RM_XU_F_V_M8_MASK (1652) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RM_XU_F_V_MF2 (1653) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RM_XU_F_V_MF2_MASK (1654) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RM_XU_F_V_MF4 (1655) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RM_XU_F_V_MF4_MASK (1656) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RM_X_F_V_M1 (1657) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RM_X_F_V_M1_MASK (1658) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RM_X_F_V_M2 (1659) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RM_X_F_V_M2_MASK (1660) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RM_X_F_V_M4 (1661) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RM_X_F_V_M4_MASK (1662) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RM_X_F_V_M8 (1663) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RM_X_F_V_M8_MASK (1664) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RM_X_F_V_MF2 (1665) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RM_X_F_V_MF2_MASK (1666) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RM_X_F_V_MF4 (1667) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RM_X_F_V_MF4_MASK (1668) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RTZ_XU_F_V_M1 (1669) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RTZ_XU_F_V_M1_MASK (1670) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RTZ_XU_F_V_M2 (1671) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RTZ_XU_F_V_M2_MASK (1672) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RTZ_XU_F_V_M4 (1673) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RTZ_XU_F_V_M4_MASK (1674) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RTZ_XU_F_V_M8 (1675) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RTZ_XU_F_V_M8_MASK (1676) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RTZ_XU_F_V_MF2 (1677) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RTZ_XU_F_V_MF2_MASK (1678) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RTZ_XU_F_V_MF4 (1679) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RTZ_XU_F_V_MF4_MASK (1680) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RTZ_X_F_V_M1 (1681) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RTZ_X_F_V_M1_MASK (1682) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RTZ_X_F_V_M2 (1683) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RTZ_X_F_V_M2_MASK (1684) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RTZ_X_F_V_M4 (1685) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RTZ_X_F_V_M4_MASK (1686) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RTZ_X_F_V_M8 (1687) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RTZ_X_F_V_M8_MASK (1688) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RTZ_X_F_V_MF2 (1689) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RTZ_X_F_V_MF2_MASK (1690) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RTZ_X_F_V_MF4 (1691) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_RTZ_X_F_V_MF4_MASK (1692) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_XU_F_V_M1 (1693) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_XU_F_V_M1_MASK (1694) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_XU_F_V_M2 (1695) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_XU_F_V_M2_MASK (1696) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_XU_F_V_M4 (1697) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_XU_F_V_M4_MASK (1698) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_XU_F_V_M8 (1699) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_XU_F_V_M8_MASK (1700) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_XU_F_V_MF2 (1701) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_XU_F_V_MF2_MASK (1702) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_XU_F_V_MF4 (1703) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_XU_F_V_MF4_MASK (1704) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_X_F_V_M1 (1705) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_X_F_V_M1_MASK (1706) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_X_F_V_M2 (1707) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_X_F_V_M2_MASK (1708) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_X_F_V_M4 (1709) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_X_F_V_M4_MASK (1710) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_X_F_V_M8 (1711) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_X_F_V_M8_MASK (1712) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_X_F_V_MF2 (1713) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_X_F_V_MF2_MASK (1714) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_X_F_V_MF4 (1715) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFCVT_X_F_V_MF4_MASK (1716) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VFPR16_M1_E16 (1717) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VFPR16_M1_E16_MASK (1718) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VFPR16_M2_E16 (1719) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VFPR16_M2_E16_MASK (1720) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VFPR16_M4_E16 (1721) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VFPR16_M4_E16_MASK (1722) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VFPR16_M8_E16 (1723) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VFPR16_M8_E16_MASK (1724) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VFPR16_MF2_E16 (1725) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VFPR16_MF2_E16_MASK (1726) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VFPR16_MF4_E16 (1727) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VFPR16_MF4_E16_MASK (1728) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VFPR32_M1_E32 (1729) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VFPR32_M1_E32_MASK (1730) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VFPR32_M2_E32 (1731) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VFPR32_M2_E32_MASK (1732) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VFPR32_M4_E32 (1733) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VFPR32_M4_E32_MASK (1734) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VFPR32_M8_E32 (1735) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VFPR32_M8_E32_MASK (1736) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VFPR32_MF2_E32 (1737) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VFPR32_MF2_E32_MASK (1738) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VFPR64_M1_E64 (1739) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VFPR64_M1_E64_MASK (1740) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VFPR64_M2_E64 (1741) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VFPR64_M2_E64_MASK (1742) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VFPR64_M4_E64 (1743) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VFPR64_M4_E64_MASK (1744) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VFPR64_M8_E64 (1745) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VFPR64_M8_E64_MASK (1746) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VV_M1_E16 (1747) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VV_M1_E16_MASK (1748) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VV_M1_E32 (1749) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VV_M1_E32_MASK (1750) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VV_M1_E64 (1751) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VV_M1_E64_MASK (1752) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VV_M2_E16 (1753) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VV_M2_E16_MASK (1754) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VV_M2_E32 (1755) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VV_M2_E32_MASK (1756) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VV_M2_E64 (1757) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VV_M2_E64_MASK (1758) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VV_M4_E16 (1759) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VV_M4_E16_MASK (1760) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VV_M4_E32 (1761) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VV_M4_E32_MASK (1762) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VV_M4_E64 (1763) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VV_M4_E64_MASK (1764) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VV_M8_E16 (1765) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VV_M8_E16_MASK (1766) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VV_M8_E32 (1767) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VV_M8_E32_MASK (1768) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VV_M8_E64 (1769) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VV_M8_E64_MASK (1770) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VV_MF2_E16 (1771) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VV_MF2_E16_MASK (1772) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VV_MF2_E32 (1773) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VV_MF2_E32_MASK (1774) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VV_MF4_E16 (1775) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFDIV_VV_MF4_E16_MASK (1776) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFIRST_M_B1 (1777) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFIRST_M_B16 (1778) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFIRST_M_B16_MASK (1779) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFIRST_M_B1_MASK (1780) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFIRST_M_B2 (1781) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFIRST_M_B2_MASK (1782) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFIRST_M_B32 (1783) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFIRST_M_B32_MASK (1784) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFIRST_M_B4 (1785) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFIRST_M_B4_MASK (1786) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFIRST_M_B64 (1787) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFIRST_M_B64_MASK (1788) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFIRST_M_B8 (1789) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFIRST_M_B8_MASK (1790) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMACC_VFPR16_M1 (1791) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMACC_VFPR16_M1_MASK (1792) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMACC_VFPR16_M2 (1793) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMACC_VFPR16_M2_MASK (1794) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMACC_VFPR16_M4 (1795) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMACC_VFPR16_M4_MASK (1796) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMACC_VFPR16_M8 (1797) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMACC_VFPR16_M8_MASK (1798) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMACC_VFPR16_MF2 (1799) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMACC_VFPR16_MF2_MASK (1800) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMACC_VFPR16_MF4 (1801) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMACC_VFPR16_MF4_MASK (1802) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMACC_VFPR32_M1 (1803) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMACC_VFPR32_M1_MASK (1804) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMACC_VFPR32_M2 (1805) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMACC_VFPR32_M2_MASK (1806) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMACC_VFPR32_M4 (1807) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMACC_VFPR32_M4_MASK (1808) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMACC_VFPR32_M8 (1809) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMACC_VFPR32_M8_MASK (1810) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMACC_VFPR32_MF2 (1811) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMACC_VFPR32_MF2_MASK (1812) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMACC_VFPR64_M1 (1813) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMACC_VFPR64_M1_MASK (1814) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMACC_VFPR64_M2 (1815) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMACC_VFPR64_M2_MASK (1816) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMACC_VFPR64_M4 (1817) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMACC_VFPR64_M4_MASK (1818) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMACC_VFPR64_M8 (1819) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMACC_VFPR64_M8_MASK (1820) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMACC_VV_M1 (1821) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMACC_VV_M1_MASK (1822) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMACC_VV_M2 (1823) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMACC_VV_M2_MASK (1824) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMACC_VV_M4 (1825) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMACC_VV_M4_MASK (1826) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMACC_VV_M8 (1827) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMACC_VV_M8_MASK (1828) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMACC_VV_MF2 (1829) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMACC_VV_MF2_MASK (1830) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMACC_VV_MF4 (1831) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMACC_VV_MF4_MASK (1832) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMADD_VFPR16_M1 (1833) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMADD_VFPR16_M1_MASK (1834) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMADD_VFPR16_M2 (1835) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMADD_VFPR16_M2_MASK (1836) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMADD_VFPR16_M4 (1837) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMADD_VFPR16_M4_MASK (1838) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMADD_VFPR16_M8 (1839) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMADD_VFPR16_M8_MASK (1840) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMADD_VFPR16_MF2 (1841) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMADD_VFPR16_MF2_MASK (1842) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMADD_VFPR16_MF4 (1843) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMADD_VFPR16_MF4_MASK (1844) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMADD_VFPR32_M1 (1845) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMADD_VFPR32_M1_MASK (1846) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMADD_VFPR32_M2 (1847) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMADD_VFPR32_M2_MASK (1848) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMADD_VFPR32_M4 (1849) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMADD_VFPR32_M4_MASK (1850) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMADD_VFPR32_M8 (1851) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMADD_VFPR32_M8_MASK (1852) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMADD_VFPR32_MF2 (1853) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMADD_VFPR32_MF2_MASK (1854) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMADD_VFPR64_M1 (1855) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMADD_VFPR64_M1_MASK (1856) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMADD_VFPR64_M2 (1857) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMADD_VFPR64_M2_MASK (1858) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMADD_VFPR64_M4 (1859) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMADD_VFPR64_M4_MASK (1860) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMADD_VFPR64_M8 (1861) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMADD_VFPR64_M8_MASK (1862) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMADD_VV_M1 (1863) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMADD_VV_M1_MASK (1864) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMADD_VV_M2 (1865) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMADD_VV_M2_MASK (1866) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMADD_VV_M4 (1867) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMADD_VV_M4_MASK (1868) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMADD_VV_M8 (1869) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMADD_VV_M8_MASK (1870) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMADD_VV_MF2 (1871) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMADD_VV_MF2_MASK (1872) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMADD_VV_MF4 (1873) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMADD_VV_MF4_MASK (1874) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMAX_VFPR16_M1 (1875) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMAX_VFPR16_M1_MASK (1876) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMAX_VFPR16_M2 (1877) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMAX_VFPR16_M2_MASK (1878) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMAX_VFPR16_M4 (1879) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMAX_VFPR16_M4_MASK (1880) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMAX_VFPR16_M8 (1881) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMAX_VFPR16_M8_MASK (1882) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMAX_VFPR16_MF2 (1883) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMAX_VFPR16_MF2_MASK (1884) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMAX_VFPR16_MF4 (1885) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMAX_VFPR16_MF4_MASK (1886) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMAX_VFPR32_M1 (1887) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMAX_VFPR32_M1_MASK (1888) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMAX_VFPR32_M2 (1889) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMAX_VFPR32_M2_MASK (1890) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMAX_VFPR32_M4 (1891) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMAX_VFPR32_M4_MASK (1892) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMAX_VFPR32_M8 (1893) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMAX_VFPR32_M8_MASK (1894) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMAX_VFPR32_MF2 (1895) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMAX_VFPR32_MF2_MASK (1896) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMAX_VFPR64_M1 (1897) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMAX_VFPR64_M1_MASK (1898) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMAX_VFPR64_M2 (1899) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMAX_VFPR64_M2_MASK (1900) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMAX_VFPR64_M4 (1901) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMAX_VFPR64_M4_MASK (1902) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMAX_VFPR64_M8 (1903) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMAX_VFPR64_M8_MASK (1904) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMAX_VV_M1 (1905) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMAX_VV_M1_MASK (1906) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMAX_VV_M2 (1907) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMAX_VV_M2_MASK (1908) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMAX_VV_M4 (1909) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMAX_VV_M4_MASK (1910) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMAX_VV_M8 (1911) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMAX_VV_M8_MASK (1912) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMAX_VV_MF2 (1913) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMAX_VV_MF2_MASK (1914) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMAX_VV_MF4 (1915) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMAX_VV_MF4_MASK (1916) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMERGE_VFPR16M_M1 (1917) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMERGE_VFPR16M_M2 (1918) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMERGE_VFPR16M_M4 (1919) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMERGE_VFPR16M_M8 (1920) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMERGE_VFPR16M_MF2 (1921) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMERGE_VFPR16M_MF4 (1922) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMERGE_VFPR32M_M1 (1923) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMERGE_VFPR32M_M2 (1924) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMERGE_VFPR32M_M4 (1925) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMERGE_VFPR32M_M8 (1926) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMERGE_VFPR32M_MF2 (1927) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMERGE_VFPR64M_M1 (1928) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMERGE_VFPR64M_M2 (1929) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMERGE_VFPR64M_M4 (1930) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMERGE_VFPR64M_M8 (1931) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMIN_VFPR16_M1 (1932) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMIN_VFPR16_M1_MASK (1933) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMIN_VFPR16_M2 (1934) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMIN_VFPR16_M2_MASK (1935) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMIN_VFPR16_M4 (1936) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMIN_VFPR16_M4_MASK (1937) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMIN_VFPR16_M8 (1938) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMIN_VFPR16_M8_MASK (1939) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMIN_VFPR16_MF2 (1940) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMIN_VFPR16_MF2_MASK (1941) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMIN_VFPR16_MF4 (1942) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMIN_VFPR16_MF4_MASK (1943) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMIN_VFPR32_M1 (1944) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMIN_VFPR32_M1_MASK (1945) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMIN_VFPR32_M2 (1946) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMIN_VFPR32_M2_MASK (1947) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMIN_VFPR32_M4 (1948) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMIN_VFPR32_M4_MASK (1949) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMIN_VFPR32_M8 (1950) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMIN_VFPR32_M8_MASK (1951) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMIN_VFPR32_MF2 (1952) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMIN_VFPR32_MF2_MASK (1953) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMIN_VFPR64_M1 (1954) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMIN_VFPR64_M1_MASK (1955) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMIN_VFPR64_M2 (1956) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMIN_VFPR64_M2_MASK (1957) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMIN_VFPR64_M4 (1958) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMIN_VFPR64_M4_MASK (1959) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMIN_VFPR64_M8 (1960) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMIN_VFPR64_M8_MASK (1961) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMIN_VV_M1 (1962) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMIN_VV_M1_MASK (1963) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMIN_VV_M2 (1964) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMIN_VV_M2_MASK (1965) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMIN_VV_M4 (1966) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMIN_VV_M4_MASK (1967) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMIN_VV_M8 (1968) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMIN_VV_M8_MASK (1969) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMIN_VV_MF2 (1970) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMIN_VV_MF2_MASK (1971) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMIN_VV_MF4 (1972) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMIN_VV_MF4_MASK (1973) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSAC_VFPR16_M1 (1974) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSAC_VFPR16_M1_MASK (1975) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSAC_VFPR16_M2 (1976) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSAC_VFPR16_M2_MASK (1977) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSAC_VFPR16_M4 (1978) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSAC_VFPR16_M4_MASK (1979) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSAC_VFPR16_M8 (1980) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSAC_VFPR16_M8_MASK (1981) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSAC_VFPR16_MF2 (1982) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSAC_VFPR16_MF2_MASK (1983) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSAC_VFPR16_MF4 (1984) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSAC_VFPR16_MF4_MASK (1985) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSAC_VFPR32_M1 (1986) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSAC_VFPR32_M1_MASK (1987) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSAC_VFPR32_M2 (1988) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSAC_VFPR32_M2_MASK (1989) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSAC_VFPR32_M4 (1990) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSAC_VFPR32_M4_MASK (1991) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSAC_VFPR32_M8 (1992) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSAC_VFPR32_M8_MASK (1993) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSAC_VFPR32_MF2 (1994) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSAC_VFPR32_MF2_MASK (1995) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSAC_VFPR64_M1 (1996) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSAC_VFPR64_M1_MASK (1997) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSAC_VFPR64_M2 (1998) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSAC_VFPR64_M2_MASK (1999) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSAC_VFPR64_M4 (2000) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSAC_VFPR64_M4_MASK (2001) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSAC_VFPR64_M8 (2002) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSAC_VFPR64_M8_MASK (2003) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSAC_VV_M1 (2004) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSAC_VV_M1_MASK (2005) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSAC_VV_M2 (2006) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSAC_VV_M2_MASK (2007) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSAC_VV_M4 (2008) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSAC_VV_M4_MASK (2009) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSAC_VV_M8 (2010) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSAC_VV_M8_MASK (2011) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSAC_VV_MF2 (2012) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSAC_VV_MF2_MASK (2013) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSAC_VV_MF4 (2014) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSAC_VV_MF4_MASK (2015) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSUB_VFPR16_M1 (2016) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSUB_VFPR16_M1_MASK (2017) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSUB_VFPR16_M2 (2018) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSUB_VFPR16_M2_MASK (2019) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSUB_VFPR16_M4 (2020) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSUB_VFPR16_M4_MASK (2021) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSUB_VFPR16_M8 (2022) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSUB_VFPR16_M8_MASK (2023) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSUB_VFPR16_MF2 (2024) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSUB_VFPR16_MF2_MASK (2025) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSUB_VFPR16_MF4 (2026) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSUB_VFPR16_MF4_MASK (2027) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSUB_VFPR32_M1 (2028) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSUB_VFPR32_M1_MASK (2029) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSUB_VFPR32_M2 (2030) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSUB_VFPR32_M2_MASK (2031) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSUB_VFPR32_M4 (2032) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSUB_VFPR32_M4_MASK (2033) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSUB_VFPR32_M8 (2034) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSUB_VFPR32_M8_MASK (2035) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSUB_VFPR32_MF2 (2036) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSUB_VFPR32_MF2_MASK (2037) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSUB_VFPR64_M1 (2038) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSUB_VFPR64_M1_MASK (2039) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSUB_VFPR64_M2 (2040) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSUB_VFPR64_M2_MASK (2041) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSUB_VFPR64_M4 (2042) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSUB_VFPR64_M4_MASK (2043) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSUB_VFPR64_M8 (2044) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSUB_VFPR64_M8_MASK (2045) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSUB_VV_M1 (2046) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSUB_VV_M1_MASK (2047) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSUB_VV_M2 (2048) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSUB_VV_M2_MASK (2049) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSUB_VV_M4 (2050) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSUB_VV_M4_MASK (2051) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSUB_VV_M8 (2052) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSUB_VV_M8_MASK (2053) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSUB_VV_MF2 (2054) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSUB_VV_MF2_MASK (2055) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSUB_VV_MF4 (2056) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMSUB_VV_MF4_MASK (2057) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMUL_VFPR16_M1 (2058) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMUL_VFPR16_M1_MASK (2059) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMUL_VFPR16_M2 (2060) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMUL_VFPR16_M2_MASK (2061) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMUL_VFPR16_M4 (2062) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMUL_VFPR16_M4_MASK (2063) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMUL_VFPR16_M8 (2064) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMUL_VFPR16_M8_MASK (2065) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMUL_VFPR16_MF2 (2066) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMUL_VFPR16_MF2_MASK (2067) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMUL_VFPR16_MF4 (2068) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMUL_VFPR16_MF4_MASK (2069) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMUL_VFPR32_M1 (2070) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMUL_VFPR32_M1_MASK (2071) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMUL_VFPR32_M2 (2072) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMUL_VFPR32_M2_MASK (2073) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMUL_VFPR32_M4 (2074) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMUL_VFPR32_M4_MASK (2075) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMUL_VFPR32_M8 (2076) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMUL_VFPR32_M8_MASK (2077) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMUL_VFPR32_MF2 (2078) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMUL_VFPR32_MF2_MASK (2079) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMUL_VFPR64_M1 (2080) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMUL_VFPR64_M1_MASK (2081) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMUL_VFPR64_M2 (2082) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMUL_VFPR64_M2_MASK (2083) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMUL_VFPR64_M4 (2084) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMUL_VFPR64_M4_MASK (2085) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMUL_VFPR64_M8 (2086) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMUL_VFPR64_M8_MASK (2087) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMUL_VV_M1 (2088) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMUL_VV_M1_MASK (2089) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMUL_VV_M2 (2090) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMUL_VV_M2_MASK (2091) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMUL_VV_M4 (2092) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMUL_VV_M4_MASK (2093) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMUL_VV_M8 (2094) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMUL_VV_M8_MASK (2095) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMUL_VV_MF2 (2096) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMUL_VV_MF2_MASK (2097) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMUL_VV_MF4 (2098) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMUL_VV_MF4_MASK (2099) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMV_FPR16_S_M1 (2100) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMV_FPR16_S_M2 (2101) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMV_FPR16_S_M4 (2102) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMV_FPR16_S_M8 (2103) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMV_FPR16_S_MF2 (2104) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMV_FPR16_S_MF4 (2105) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMV_FPR32_S_M1 (2106) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMV_FPR32_S_M2 (2107) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMV_FPR32_S_M4 (2108) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMV_FPR32_S_M8 (2109) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMV_FPR32_S_MF2 (2110) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMV_FPR64_S_M1 (2111) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMV_FPR64_S_M2 (2112) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMV_FPR64_S_M4 (2113) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMV_FPR64_S_M8 (2114) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMV_S_FPR16_M1 (2115) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMV_S_FPR16_M2 (2116) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMV_S_FPR16_M4 (2117) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMV_S_FPR16_M8 (2118) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMV_S_FPR16_MF2 (2119) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMV_S_FPR16_MF4 (2120) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMV_S_FPR32_M1 (2121) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMV_S_FPR32_M2 (2122) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMV_S_FPR32_M4 (2123) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMV_S_FPR32_M8 (2124) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMV_S_FPR32_MF2 (2125) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMV_S_FPR64_M1 (2126) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMV_S_FPR64_M2 (2127) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMV_S_FPR64_M4 (2128) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMV_S_FPR64_M8 (2129) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMV_V_FPR16_M1 (2130) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMV_V_FPR16_M2 (2131) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMV_V_FPR16_M4 (2132) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMV_V_FPR16_M8 (2133) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMV_V_FPR16_MF2 (2134) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMV_V_FPR16_MF4 (2135) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMV_V_FPR32_M1 (2136) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMV_V_FPR32_M2 (2137) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMV_V_FPR32_M4 (2138) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMV_V_FPR32_M8 (2139) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMV_V_FPR32_MF2 (2140) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMV_V_FPR64_M1 (2141) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMV_V_FPR64_M2 (2142) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMV_V_FPR64_M4 (2143) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFMV_V_FPR64_M8 (2144) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVTBF16_F_F_W_M1 (2145) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVTBF16_F_F_W_M1_MASK (2146) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVTBF16_F_F_W_M2 (2147) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVTBF16_F_F_W_M2_MASK (2148) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVTBF16_F_F_W_M4 (2149) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVTBF16_F_F_W_M4_MASK (2150) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVTBF16_F_F_W_MF2 (2151) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVTBF16_F_F_W_MF2_MASK (2152) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVTBF16_F_F_W_MF4 (2153) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVTBF16_F_F_W_MF4_MASK (2154) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_F_F_W_M1 (2155) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_F_F_W_M1_MASK (2156) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_F_F_W_M2 (2157) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_F_F_W_M2_MASK (2158) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_F_F_W_M4 (2159) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_F_F_W_M4_MASK (2160) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_F_F_W_MF2 (2161) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_F_F_W_MF2_MASK (2162) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_F_F_W_MF4 (2163) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_F_F_W_MF4_MASK (2164) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_F_XU_W_M1 (2165) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_F_XU_W_M1_MASK (2166) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_F_XU_W_M2 (2167) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_F_XU_W_M2_MASK (2168) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_F_XU_W_M4 (2169) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_F_XU_W_M4_MASK (2170) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_F_XU_W_MF2 (2171) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_F_XU_W_MF2_MASK (2172) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_F_XU_W_MF4 (2173) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_F_XU_W_MF4_MASK (2174) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_F_X_W_M1 (2175) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_F_X_W_M1_MASK (2176) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_F_X_W_M2 (2177) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_F_X_W_M2_MASK (2178) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_F_X_W_M4 (2179) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_F_X_W_M4_MASK (2180) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_F_X_W_MF2 (2181) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_F_X_W_MF2_MASK (2182) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_F_X_W_MF4 (2183) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_F_X_W_MF4_MASK (2184) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RM_F_XU_W_M1 (2185) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RM_F_XU_W_M1_MASK (2186) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RM_F_XU_W_M2 (2187) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RM_F_XU_W_M2_MASK (2188) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RM_F_XU_W_M4 (2189) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RM_F_XU_W_M4_MASK (2190) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RM_F_XU_W_MF2 (2191) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RM_F_XU_W_MF2_MASK (2192) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RM_F_XU_W_MF4 (2193) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RM_F_XU_W_MF4_MASK (2194) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RM_F_X_W_M1 (2195) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RM_F_X_W_M1_MASK (2196) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RM_F_X_W_M2 (2197) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RM_F_X_W_M2_MASK (2198) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RM_F_X_W_M4 (2199) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RM_F_X_W_M4_MASK (2200) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RM_F_X_W_MF2 (2201) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RM_F_X_W_MF2_MASK (2202) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RM_F_X_W_MF4 (2203) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RM_F_X_W_MF4_MASK (2204) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RM_XU_F_W_M1 (2205) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RM_XU_F_W_M1_MASK (2206) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RM_XU_F_W_M2 (2207) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RM_XU_F_W_M2_MASK (2208) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RM_XU_F_W_M4 (2209) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RM_XU_F_W_M4_MASK (2210) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RM_XU_F_W_MF2 (2211) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RM_XU_F_W_MF2_MASK (2212) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RM_XU_F_W_MF4 (2213) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RM_XU_F_W_MF4_MASK (2214) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RM_XU_F_W_MF8 (2215) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RM_XU_F_W_MF8_MASK (2216) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RM_X_F_W_M1 (2217) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RM_X_F_W_M1_MASK (2218) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RM_X_F_W_M2 (2219) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RM_X_F_W_M2_MASK (2220) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RM_X_F_W_M4 (2221) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RM_X_F_W_M4_MASK (2222) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RM_X_F_W_MF2 (2223) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RM_X_F_W_MF2_MASK (2224) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RM_X_F_W_MF4 (2225) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RM_X_F_W_MF4_MASK (2226) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RM_X_F_W_MF8 (2227) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RM_X_F_W_MF8_MASK (2228) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_ROD_F_F_W_M1 (2229) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_ROD_F_F_W_M1_MASK (2230) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_ROD_F_F_W_M2 (2231) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_ROD_F_F_W_M2_MASK (2232) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_ROD_F_F_W_M4 (2233) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_ROD_F_F_W_M4_MASK (2234) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_ROD_F_F_W_MF2 (2235) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_ROD_F_F_W_MF2_MASK (2236) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_ROD_F_F_W_MF4 (2237) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_ROD_F_F_W_MF4_MASK (2238) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RTZ_XU_F_W_M1 (2239) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RTZ_XU_F_W_M1_MASK (2240) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RTZ_XU_F_W_M2 (2241) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RTZ_XU_F_W_M2_MASK (2242) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RTZ_XU_F_W_M4 (2243) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RTZ_XU_F_W_M4_MASK (2244) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RTZ_XU_F_W_MF2 (2245) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RTZ_XU_F_W_MF2_MASK (2246) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RTZ_XU_F_W_MF4 (2247) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RTZ_XU_F_W_MF4_MASK (2248) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RTZ_XU_F_W_MF8 (2249) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RTZ_XU_F_W_MF8_MASK (2250) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RTZ_X_F_W_M1 (2251) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RTZ_X_F_W_M1_MASK (2252) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RTZ_X_F_W_M2 (2253) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RTZ_X_F_W_M2_MASK (2254) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RTZ_X_F_W_M4 (2255) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RTZ_X_F_W_M4_MASK (2256) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RTZ_X_F_W_MF2 (2257) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RTZ_X_F_W_MF2_MASK (2258) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RTZ_X_F_W_MF4 (2259) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RTZ_X_F_W_MF4_MASK (2260) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RTZ_X_F_W_MF8 (2261) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_RTZ_X_F_W_MF8_MASK (2262) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_XU_F_W_M1 (2263) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_XU_F_W_M1_MASK (2264) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_XU_F_W_M2 (2265) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_XU_F_W_M2_MASK (2266) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_XU_F_W_M4 (2267) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_XU_F_W_M4_MASK (2268) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_XU_F_W_MF2 (2269) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_XU_F_W_MF2_MASK (2270) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_XU_F_W_MF4 (2271) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_XU_F_W_MF4_MASK (2272) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_XU_F_W_MF8 (2273) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_XU_F_W_MF8_MASK (2274) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_X_F_W_M1 (2275) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_X_F_W_M1_MASK (2276) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_X_F_W_M2 (2277) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_X_F_W_M2_MASK (2278) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_X_F_W_M4 (2279) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_X_F_W_M4_MASK (2280) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_X_F_W_MF2 (2281) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_X_F_W_MF2_MASK (2282) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_X_F_W_MF4 (2283) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_X_F_W_MF4_MASK (2284) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_X_F_W_MF8 (2285) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNCVT_X_F_W_MF8_MASK (2286) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMACC_VFPR16_M1 (2287) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMACC_VFPR16_M1_MASK (2288) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMACC_VFPR16_M2 (2289) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMACC_VFPR16_M2_MASK (2290) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMACC_VFPR16_M4 (2291) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMACC_VFPR16_M4_MASK (2292) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMACC_VFPR16_M8 (2293) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMACC_VFPR16_M8_MASK (2294) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMACC_VFPR16_MF2 (2295) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMACC_VFPR16_MF2_MASK (2296) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMACC_VFPR16_MF4 (2297) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMACC_VFPR16_MF4_MASK (2298) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMACC_VFPR32_M1 (2299) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMACC_VFPR32_M1_MASK (2300) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMACC_VFPR32_M2 (2301) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMACC_VFPR32_M2_MASK (2302) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMACC_VFPR32_M4 (2303) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMACC_VFPR32_M4_MASK (2304) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMACC_VFPR32_M8 (2305) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMACC_VFPR32_M8_MASK (2306) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMACC_VFPR32_MF2 (2307) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMACC_VFPR32_MF2_MASK (2308) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMACC_VFPR64_M1 (2309) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMACC_VFPR64_M1_MASK (2310) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMACC_VFPR64_M2 (2311) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMACC_VFPR64_M2_MASK (2312) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMACC_VFPR64_M4 (2313) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMACC_VFPR64_M4_MASK (2314) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMACC_VFPR64_M8 (2315) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMACC_VFPR64_M8_MASK (2316) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMACC_VV_M1 (2317) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMACC_VV_M1_MASK (2318) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMACC_VV_M2 (2319) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMACC_VV_M2_MASK (2320) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMACC_VV_M4 (2321) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMACC_VV_M4_MASK (2322) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMACC_VV_M8 (2323) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMACC_VV_M8_MASK (2324) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMACC_VV_MF2 (2325) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMACC_VV_MF2_MASK (2326) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMACC_VV_MF4 (2327) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMACC_VV_MF4_MASK (2328) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMADD_VFPR16_M1 (2329) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMADD_VFPR16_M1_MASK (2330) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMADD_VFPR16_M2 (2331) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMADD_VFPR16_M2_MASK (2332) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMADD_VFPR16_M4 (2333) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMADD_VFPR16_M4_MASK (2334) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMADD_VFPR16_M8 (2335) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMADD_VFPR16_M8_MASK (2336) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMADD_VFPR16_MF2 (2337) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMADD_VFPR16_MF2_MASK (2338) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMADD_VFPR16_MF4 (2339) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMADD_VFPR16_MF4_MASK (2340) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMADD_VFPR32_M1 (2341) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMADD_VFPR32_M1_MASK (2342) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMADD_VFPR32_M2 (2343) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMADD_VFPR32_M2_MASK (2344) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMADD_VFPR32_M4 (2345) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMADD_VFPR32_M4_MASK (2346) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMADD_VFPR32_M8 (2347) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMADD_VFPR32_M8_MASK (2348) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMADD_VFPR32_MF2 (2349) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMADD_VFPR32_MF2_MASK (2350) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMADD_VFPR64_M1 (2351) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMADD_VFPR64_M1_MASK (2352) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMADD_VFPR64_M2 (2353) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMADD_VFPR64_M2_MASK (2354) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMADD_VFPR64_M4 (2355) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMADD_VFPR64_M4_MASK (2356) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMADD_VFPR64_M8 (2357) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMADD_VFPR64_M8_MASK (2358) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMADD_VV_M1 (2359) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMADD_VV_M1_MASK (2360) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMADD_VV_M2 (2361) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMADD_VV_M2_MASK (2362) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMADD_VV_M4 (2363) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMADD_VV_M4_MASK (2364) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMADD_VV_M8 (2365) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMADD_VV_M8_MASK (2366) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMADD_VV_MF2 (2367) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMADD_VV_MF2_MASK (2368) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMADD_VV_MF4 (2369) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMADD_VV_MF4_MASK (2370) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSAC_VFPR16_M1 (2371) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSAC_VFPR16_M1_MASK (2372) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSAC_VFPR16_M2 (2373) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSAC_VFPR16_M2_MASK (2374) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSAC_VFPR16_M4 (2375) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSAC_VFPR16_M4_MASK (2376) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSAC_VFPR16_M8 (2377) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSAC_VFPR16_M8_MASK (2378) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSAC_VFPR16_MF2 (2379) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSAC_VFPR16_MF2_MASK (2380) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSAC_VFPR16_MF4 (2381) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSAC_VFPR16_MF4_MASK (2382) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSAC_VFPR32_M1 (2383) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSAC_VFPR32_M1_MASK (2384) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSAC_VFPR32_M2 (2385) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSAC_VFPR32_M2_MASK (2386) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSAC_VFPR32_M4 (2387) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSAC_VFPR32_M4_MASK (2388) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSAC_VFPR32_M8 (2389) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSAC_VFPR32_M8_MASK (2390) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSAC_VFPR32_MF2 (2391) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSAC_VFPR32_MF2_MASK (2392) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSAC_VFPR64_M1 (2393) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSAC_VFPR64_M1_MASK (2394) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSAC_VFPR64_M2 (2395) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSAC_VFPR64_M2_MASK (2396) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSAC_VFPR64_M4 (2397) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSAC_VFPR64_M4_MASK (2398) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSAC_VFPR64_M8 (2399) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSAC_VFPR64_M8_MASK (2400) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSAC_VV_M1 (2401) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSAC_VV_M1_MASK (2402) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSAC_VV_M2 (2403) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSAC_VV_M2_MASK (2404) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSAC_VV_M4 (2405) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSAC_VV_M4_MASK (2406) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSAC_VV_M8 (2407) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSAC_VV_M8_MASK (2408) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSAC_VV_MF2 (2409) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSAC_VV_MF2_MASK (2410) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSAC_VV_MF4 (2411) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSAC_VV_MF4_MASK (2412) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSUB_VFPR16_M1 (2413) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSUB_VFPR16_M1_MASK (2414) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSUB_VFPR16_M2 (2415) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSUB_VFPR16_M2_MASK (2416) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSUB_VFPR16_M4 (2417) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSUB_VFPR16_M4_MASK (2418) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSUB_VFPR16_M8 (2419) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSUB_VFPR16_M8_MASK (2420) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSUB_VFPR16_MF2 (2421) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSUB_VFPR16_MF2_MASK (2422) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSUB_VFPR16_MF4 (2423) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSUB_VFPR16_MF4_MASK (2424) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSUB_VFPR32_M1 (2425) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSUB_VFPR32_M1_MASK (2426) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSUB_VFPR32_M2 (2427) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSUB_VFPR32_M2_MASK (2428) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSUB_VFPR32_M4 (2429) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSUB_VFPR32_M4_MASK (2430) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSUB_VFPR32_M8 (2431) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSUB_VFPR32_M8_MASK (2432) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSUB_VFPR32_MF2 (2433) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSUB_VFPR32_MF2_MASK (2434) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSUB_VFPR64_M1 (2435) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSUB_VFPR64_M1_MASK (2436) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSUB_VFPR64_M2 (2437) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSUB_VFPR64_M2_MASK (2438) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSUB_VFPR64_M4 (2439) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSUB_VFPR64_M4_MASK (2440) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSUB_VFPR64_M8 (2441) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSUB_VFPR64_M8_MASK (2442) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSUB_VV_M1 (2443) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSUB_VV_M1_MASK (2444) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSUB_VV_M2 (2445) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSUB_VV_M2_MASK (2446) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSUB_VV_M4 (2447) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSUB_VV_M4_MASK (2448) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSUB_VV_M8 (2449) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSUB_VV_M8_MASK (2450) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSUB_VV_MF2 (2451) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSUB_VV_MF2_MASK (2452) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSUB_VV_MF4 (2453) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNMSUB_VV_MF4_MASK (2454) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNRCLIP_XU_F_QF_M1 (2455) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNRCLIP_XU_F_QF_M1_MASK (2456) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNRCLIP_XU_F_QF_M2 (2457) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNRCLIP_XU_F_QF_M2_MASK (2458) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNRCLIP_XU_F_QF_MF2 (2459) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNRCLIP_XU_F_QF_MF2_MASK (2460) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNRCLIP_XU_F_QF_MF4 (2461) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNRCLIP_XU_F_QF_MF4_MASK (2462) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNRCLIP_XU_F_QF_MF8 (2463) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNRCLIP_XU_F_QF_MF8_MASK (2464) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNRCLIP_X_F_QF_M1 (2465) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNRCLIP_X_F_QF_M1_MASK (2466) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNRCLIP_X_F_QF_M2 (2467) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNRCLIP_X_F_QF_M2_MASK (2468) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNRCLIP_X_F_QF_MF2 (2469) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNRCLIP_X_F_QF_MF2_MASK (2470) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNRCLIP_X_F_QF_MF4 (2471) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNRCLIP_X_F_QF_MF4_MASK (2472) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNRCLIP_X_F_QF_MF8 (2473) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFNRCLIP_X_F_QF_MF8_MASK (2474) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRDIV_VFPR16_M1_E16 (2475) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRDIV_VFPR16_M1_E16_MASK (2476) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRDIV_VFPR16_M2_E16 (2477) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRDIV_VFPR16_M2_E16_MASK (2478) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRDIV_VFPR16_M4_E16 (2479) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRDIV_VFPR16_M4_E16_MASK (2480) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRDIV_VFPR16_M8_E16 (2481) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRDIV_VFPR16_M8_E16_MASK (2482) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRDIV_VFPR16_MF2_E16 (2483) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRDIV_VFPR16_MF2_E16_MASK (2484) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRDIV_VFPR16_MF4_E16 (2485) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRDIV_VFPR16_MF4_E16_MASK (2486) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRDIV_VFPR32_M1_E32 (2487) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRDIV_VFPR32_M1_E32_MASK (2488) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRDIV_VFPR32_M2_E32 (2489) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRDIV_VFPR32_M2_E32_MASK (2490) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRDIV_VFPR32_M4_E32 (2491) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRDIV_VFPR32_M4_E32_MASK (2492) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRDIV_VFPR32_M8_E32 (2493) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRDIV_VFPR32_M8_E32_MASK (2494) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRDIV_VFPR32_MF2_E32 (2495) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRDIV_VFPR32_MF2_E32_MASK (2496) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRDIV_VFPR64_M1_E64 (2497) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRDIV_VFPR64_M1_E64_MASK (2498) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRDIV_VFPR64_M2_E64 (2499) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRDIV_VFPR64_M2_E64_MASK (2500) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRDIV_VFPR64_M4_E64 (2501) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRDIV_VFPR64_M4_E64_MASK (2502) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRDIV_VFPR64_M8_E64 (2503) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRDIV_VFPR64_M8_E64_MASK (2504) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREC7_V_M1 (2505) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREC7_V_M1_MASK (2506) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREC7_V_M2 (2507) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREC7_V_M2_MASK (2508) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREC7_V_M4 (2509) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREC7_V_M4_MASK (2510) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREC7_V_M8 (2511) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREC7_V_M8_MASK (2512) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREC7_V_MF2 (2513) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREC7_V_MF2_MASK (2514) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREC7_V_MF4 (2515) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREC7_V_MF4_MASK (2516) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMAX_VS_M1_E16 (2517) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMAX_VS_M1_E16_MASK (2518) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMAX_VS_M1_E32 (2519) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMAX_VS_M1_E32_MASK (2520) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMAX_VS_M1_E64 (2521) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMAX_VS_M1_E64_MASK (2522) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMAX_VS_M2_E16 (2523) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMAX_VS_M2_E16_MASK (2524) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMAX_VS_M2_E32 (2525) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMAX_VS_M2_E32_MASK (2526) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMAX_VS_M2_E64 (2527) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMAX_VS_M2_E64_MASK (2528) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMAX_VS_M4_E16 (2529) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMAX_VS_M4_E16_MASK (2530) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMAX_VS_M4_E32 (2531) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMAX_VS_M4_E32_MASK (2532) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMAX_VS_M4_E64 (2533) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMAX_VS_M4_E64_MASK (2534) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMAX_VS_M8_E16 (2535) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMAX_VS_M8_E16_MASK (2536) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMAX_VS_M8_E32 (2537) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMAX_VS_M8_E32_MASK (2538) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMAX_VS_M8_E64 (2539) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMAX_VS_M8_E64_MASK (2540) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMAX_VS_MF2_E16 (2541) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMAX_VS_MF2_E16_MASK (2542) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMAX_VS_MF2_E32 (2543) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMAX_VS_MF2_E32_MASK (2544) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMAX_VS_MF4_E16 (2545) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMAX_VS_MF4_E16_MASK (2546) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMIN_VS_M1_E16 (2547) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMIN_VS_M1_E16_MASK (2548) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMIN_VS_M1_E32 (2549) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMIN_VS_M1_E32_MASK (2550) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMIN_VS_M1_E64 (2551) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMIN_VS_M1_E64_MASK (2552) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMIN_VS_M2_E16 (2553) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMIN_VS_M2_E16_MASK (2554) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMIN_VS_M2_E32 (2555) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMIN_VS_M2_E32_MASK (2556) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMIN_VS_M2_E64 (2557) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMIN_VS_M2_E64_MASK (2558) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMIN_VS_M4_E16 (2559) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMIN_VS_M4_E16_MASK (2560) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMIN_VS_M4_E32 (2561) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMIN_VS_M4_E32_MASK (2562) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMIN_VS_M4_E64 (2563) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMIN_VS_M4_E64_MASK (2564) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMIN_VS_M8_E16 (2565) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMIN_VS_M8_E16_MASK (2566) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMIN_VS_M8_E32 (2567) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMIN_VS_M8_E32_MASK (2568) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMIN_VS_M8_E64 (2569) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMIN_VS_M8_E64_MASK (2570) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMIN_VS_MF2_E16 (2571) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMIN_VS_MF2_E16_MASK (2572) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMIN_VS_MF2_E32 (2573) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMIN_VS_MF2_E32_MASK (2574) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMIN_VS_MF4_E16 (2575) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDMIN_VS_MF4_E16_MASK (2576) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDOSUM_VS_M1_E16 (2577) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDOSUM_VS_M1_E16_MASK (2578) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDOSUM_VS_M1_E32 (2579) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDOSUM_VS_M1_E32_MASK (2580) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDOSUM_VS_M1_E64 (2581) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDOSUM_VS_M1_E64_MASK (2582) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDOSUM_VS_M2_E16 (2583) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDOSUM_VS_M2_E16_MASK (2584) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDOSUM_VS_M2_E32 (2585) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDOSUM_VS_M2_E32_MASK (2586) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDOSUM_VS_M2_E64 (2587) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDOSUM_VS_M2_E64_MASK (2588) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDOSUM_VS_M4_E16 (2589) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDOSUM_VS_M4_E16_MASK (2590) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDOSUM_VS_M4_E32 (2591) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDOSUM_VS_M4_E32_MASK (2592) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDOSUM_VS_M4_E64 (2593) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDOSUM_VS_M4_E64_MASK (2594) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDOSUM_VS_M8_E16 (2595) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDOSUM_VS_M8_E16_MASK (2596) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDOSUM_VS_M8_E32 (2597) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDOSUM_VS_M8_E32_MASK (2598) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDOSUM_VS_M8_E64 (2599) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDOSUM_VS_M8_E64_MASK (2600) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDOSUM_VS_MF2_E16 (2601) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDOSUM_VS_MF2_E16_MASK (2602) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDOSUM_VS_MF2_E32 (2603) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDOSUM_VS_MF2_E32_MASK (2604) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDOSUM_VS_MF4_E16 (2605) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDOSUM_VS_MF4_E16_MASK (2606) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDUSUM_VS_M1_E16 (2607) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDUSUM_VS_M1_E16_MASK (2608) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDUSUM_VS_M1_E32 (2609) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDUSUM_VS_M1_E32_MASK (2610) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDUSUM_VS_M1_E64 (2611) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDUSUM_VS_M1_E64_MASK (2612) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDUSUM_VS_M2_E16 (2613) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDUSUM_VS_M2_E16_MASK (2614) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDUSUM_VS_M2_E32 (2615) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDUSUM_VS_M2_E32_MASK (2616) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDUSUM_VS_M2_E64 (2617) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDUSUM_VS_M2_E64_MASK (2618) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDUSUM_VS_M4_E16 (2619) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDUSUM_VS_M4_E16_MASK (2620) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDUSUM_VS_M4_E32 (2621) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDUSUM_VS_M4_E32_MASK (2622) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDUSUM_VS_M4_E64 (2623) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDUSUM_VS_M4_E64_MASK (2624) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDUSUM_VS_M8_E16 (2625) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDUSUM_VS_M8_E16_MASK (2626) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDUSUM_VS_M8_E32 (2627) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDUSUM_VS_M8_E32_MASK (2628) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDUSUM_VS_M8_E64 (2629) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDUSUM_VS_M8_E64_MASK (2630) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDUSUM_VS_MF2_E16 (2631) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDUSUM_VS_MF2_E16_MASK (2632) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDUSUM_VS_MF2_E32 (2633) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDUSUM_VS_MF2_E32_MASK (2634) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDUSUM_VS_MF4_E16 (2635) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFREDUSUM_VS_MF4_E16_MASK (2636) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFROUND_NOEXCEPT_V_M1_MASK (2637) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFROUND_NOEXCEPT_V_M2_MASK (2638) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFROUND_NOEXCEPT_V_M4_MASK (2639) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFROUND_NOEXCEPT_V_M8_MASK (2640) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFROUND_NOEXCEPT_V_MF2_MASK (2641) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFROUND_NOEXCEPT_V_MF4_MASK (2642) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRSQRT7_V_M1 (2643) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRSQRT7_V_M1_MASK (2644) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRSQRT7_V_M2 (2645) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRSQRT7_V_M2_MASK (2646) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRSQRT7_V_M4 (2647) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRSQRT7_V_M4_MASK (2648) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRSQRT7_V_M8 (2649) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRSQRT7_V_M8_MASK (2650) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRSQRT7_V_MF2 (2651) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRSQRT7_V_MF2_MASK (2652) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRSQRT7_V_MF4 (2653) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRSQRT7_V_MF4_MASK (2654) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRSUB_VFPR16_M1 (2655) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRSUB_VFPR16_M1_MASK (2656) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRSUB_VFPR16_M2 (2657) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRSUB_VFPR16_M2_MASK (2658) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRSUB_VFPR16_M4 (2659) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRSUB_VFPR16_M4_MASK (2660) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRSUB_VFPR16_M8 (2661) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRSUB_VFPR16_M8_MASK (2662) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRSUB_VFPR16_MF2 (2663) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRSUB_VFPR16_MF2_MASK (2664) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRSUB_VFPR16_MF4 (2665) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRSUB_VFPR16_MF4_MASK (2666) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRSUB_VFPR32_M1 (2667) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRSUB_VFPR32_M1_MASK (2668) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRSUB_VFPR32_M2 (2669) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRSUB_VFPR32_M2_MASK (2670) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRSUB_VFPR32_M4 (2671) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRSUB_VFPR32_M4_MASK (2672) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRSUB_VFPR32_M8 (2673) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRSUB_VFPR32_M8_MASK (2674) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRSUB_VFPR32_MF2 (2675) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRSUB_VFPR32_MF2_MASK (2676) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRSUB_VFPR64_M1 (2677) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRSUB_VFPR64_M1_MASK (2678) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRSUB_VFPR64_M2 (2679) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRSUB_VFPR64_M2_MASK (2680) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRSUB_VFPR64_M4 (2681) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRSUB_VFPR64_M4_MASK (2682) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRSUB_VFPR64_M8 (2683) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFRSUB_VFPR64_M8_MASK (2684) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJN_VFPR16_M1 (2685) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJN_VFPR16_M1_MASK (2686) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJN_VFPR16_M2 (2687) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJN_VFPR16_M2_MASK (2688) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJN_VFPR16_M4 (2689) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJN_VFPR16_M4_MASK (2690) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJN_VFPR16_M8 (2691) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJN_VFPR16_M8_MASK (2692) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJN_VFPR16_MF2 (2693) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJN_VFPR16_MF2_MASK (2694) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJN_VFPR16_MF4 (2695) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJN_VFPR16_MF4_MASK (2696) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJN_VFPR32_M1 (2697) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJN_VFPR32_M1_MASK (2698) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJN_VFPR32_M2 (2699) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJN_VFPR32_M2_MASK (2700) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJN_VFPR32_M4 (2701) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJN_VFPR32_M4_MASK (2702) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJN_VFPR32_M8 (2703) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJN_VFPR32_M8_MASK (2704) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJN_VFPR32_MF2 (2705) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJN_VFPR32_MF2_MASK (2706) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJN_VFPR64_M1 (2707) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJN_VFPR64_M1_MASK (2708) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJN_VFPR64_M2 (2709) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJN_VFPR64_M2_MASK (2710) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJN_VFPR64_M4 (2711) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJN_VFPR64_M4_MASK (2712) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJN_VFPR64_M8 (2713) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJN_VFPR64_M8_MASK (2714) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJN_VV_M1 (2715) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJN_VV_M1_MASK (2716) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJN_VV_M2 (2717) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJN_VV_M2_MASK (2718) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJN_VV_M4 (2719) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJN_VV_M4_MASK (2720) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJN_VV_M8 (2721) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJN_VV_M8_MASK (2722) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJN_VV_MF2 (2723) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJN_VV_MF2_MASK (2724) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJN_VV_MF4 (2725) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJN_VV_MF4_MASK (2726) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJX_VFPR16_M1 (2727) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJX_VFPR16_M1_MASK (2728) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJX_VFPR16_M2 (2729) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJX_VFPR16_M2_MASK (2730) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJX_VFPR16_M4 (2731) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJX_VFPR16_M4_MASK (2732) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJX_VFPR16_M8 (2733) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJX_VFPR16_M8_MASK (2734) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJX_VFPR16_MF2 (2735) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJX_VFPR16_MF2_MASK (2736) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJX_VFPR16_MF4 (2737) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJX_VFPR16_MF4_MASK (2738) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJX_VFPR32_M1 (2739) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJX_VFPR32_M1_MASK (2740) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJX_VFPR32_M2 (2741) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJX_VFPR32_M2_MASK (2742) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJX_VFPR32_M4 (2743) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJX_VFPR32_M4_MASK (2744) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJX_VFPR32_M8 (2745) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJX_VFPR32_M8_MASK (2746) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJX_VFPR32_MF2 (2747) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJX_VFPR32_MF2_MASK (2748) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJX_VFPR64_M1 (2749) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJX_VFPR64_M1_MASK (2750) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJX_VFPR64_M2 (2751) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJX_VFPR64_M2_MASK (2752) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJX_VFPR64_M4 (2753) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJX_VFPR64_M4_MASK (2754) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJX_VFPR64_M8 (2755) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJX_VFPR64_M8_MASK (2756) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJX_VV_M1 (2757) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJX_VV_M1_MASK (2758) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJX_VV_M2 (2759) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJX_VV_M2_MASK (2760) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJX_VV_M4 (2761) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJX_VV_M4_MASK (2762) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJX_VV_M8 (2763) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJX_VV_M8_MASK (2764) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJX_VV_MF2 (2765) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJX_VV_MF2_MASK (2766) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJX_VV_MF4 (2767) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJX_VV_MF4_MASK (2768) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJ_VFPR16_M1 (2769) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJ_VFPR16_M1_MASK (2770) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJ_VFPR16_M2 (2771) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJ_VFPR16_M2_MASK (2772) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJ_VFPR16_M4 (2773) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJ_VFPR16_M4_MASK (2774) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJ_VFPR16_M8 (2775) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJ_VFPR16_M8_MASK (2776) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJ_VFPR16_MF2 (2777) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJ_VFPR16_MF2_MASK (2778) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJ_VFPR16_MF4 (2779) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJ_VFPR16_MF4_MASK (2780) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJ_VFPR32_M1 (2781) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJ_VFPR32_M1_MASK (2782) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJ_VFPR32_M2 (2783) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJ_VFPR32_M2_MASK (2784) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJ_VFPR32_M4 (2785) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJ_VFPR32_M4_MASK (2786) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJ_VFPR32_M8 (2787) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJ_VFPR32_M8_MASK (2788) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJ_VFPR32_MF2 (2789) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJ_VFPR32_MF2_MASK (2790) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJ_VFPR64_M1 (2791) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJ_VFPR64_M1_MASK (2792) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJ_VFPR64_M2 (2793) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJ_VFPR64_M2_MASK (2794) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJ_VFPR64_M4 (2795) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJ_VFPR64_M4_MASK (2796) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJ_VFPR64_M8 (2797) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJ_VFPR64_M8_MASK (2798) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJ_VV_M1 (2799) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJ_VV_M1_MASK (2800) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJ_VV_M2 (2801) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJ_VV_M2_MASK (2802) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJ_VV_M4 (2803) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJ_VV_M4_MASK (2804) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJ_VV_M8 (2805) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJ_VV_M8_MASK (2806) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJ_VV_MF2 (2807) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJ_VV_MF2_MASK (2808) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJ_VV_MF4 (2809) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSGNJ_VV_MF4_MASK (2810) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1DOWN_VFPR16_M1 (2811) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1DOWN_VFPR16_M1_MASK (2812) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1DOWN_VFPR16_M2 (2813) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1DOWN_VFPR16_M2_MASK (2814) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1DOWN_VFPR16_M4 (2815) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1DOWN_VFPR16_M4_MASK (2816) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1DOWN_VFPR16_M8 (2817) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1DOWN_VFPR16_M8_MASK (2818) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1DOWN_VFPR16_MF2 (2819) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1DOWN_VFPR16_MF2_MASK (2820) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1DOWN_VFPR16_MF4 (2821) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1DOWN_VFPR16_MF4_MASK (2822) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1DOWN_VFPR32_M1 (2823) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1DOWN_VFPR32_M1_MASK (2824) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1DOWN_VFPR32_M2 (2825) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1DOWN_VFPR32_M2_MASK (2826) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1DOWN_VFPR32_M4 (2827) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1DOWN_VFPR32_M4_MASK (2828) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1DOWN_VFPR32_M8 (2829) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1DOWN_VFPR32_M8_MASK (2830) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1DOWN_VFPR32_MF2 (2831) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1DOWN_VFPR32_MF2_MASK (2832) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1DOWN_VFPR64_M1 (2833) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1DOWN_VFPR64_M1_MASK (2834) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1DOWN_VFPR64_M2 (2835) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1DOWN_VFPR64_M2_MASK (2836) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1DOWN_VFPR64_M4 (2837) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1DOWN_VFPR64_M4_MASK (2838) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1DOWN_VFPR64_M8 (2839) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1DOWN_VFPR64_M8_MASK (2840) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1UP_VFPR16_M1 (2841) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1UP_VFPR16_M1_MASK (2842) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1UP_VFPR16_M2 (2843) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1UP_VFPR16_M2_MASK (2844) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1UP_VFPR16_M4 (2845) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1UP_VFPR16_M4_MASK (2846) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1UP_VFPR16_M8 (2847) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1UP_VFPR16_M8_MASK (2848) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1UP_VFPR16_MF2 (2849) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1UP_VFPR16_MF2_MASK (2850) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1UP_VFPR16_MF4 (2851) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1UP_VFPR16_MF4_MASK (2852) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1UP_VFPR32_M1 (2853) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1UP_VFPR32_M1_MASK (2854) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1UP_VFPR32_M2 (2855) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1UP_VFPR32_M2_MASK (2856) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1UP_VFPR32_M4 (2857) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1UP_VFPR32_M4_MASK (2858) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1UP_VFPR32_M8 (2859) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1UP_VFPR32_M8_MASK (2860) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1UP_VFPR32_MF2 (2861) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1UP_VFPR32_MF2_MASK (2862) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1UP_VFPR64_M1 (2863) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1UP_VFPR64_M1_MASK (2864) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1UP_VFPR64_M2 (2865) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1UP_VFPR64_M2_MASK (2866) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1UP_VFPR64_M4 (2867) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1UP_VFPR64_M4_MASK (2868) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1UP_VFPR64_M8 (2869) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSLIDE1UP_VFPR64_M8_MASK (2870) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSQRT_V_M1_E16 (2871) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSQRT_V_M1_E16_MASK (2872) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSQRT_V_M1_E32 (2873) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSQRT_V_M1_E32_MASK (2874) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSQRT_V_M1_E64 (2875) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSQRT_V_M1_E64_MASK (2876) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSQRT_V_M2_E16 (2877) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSQRT_V_M2_E16_MASK (2878) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSQRT_V_M2_E32 (2879) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSQRT_V_M2_E32_MASK (2880) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSQRT_V_M2_E64 (2881) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSQRT_V_M2_E64_MASK (2882) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSQRT_V_M4_E16 (2883) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSQRT_V_M4_E16_MASK (2884) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSQRT_V_M4_E32 (2885) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSQRT_V_M4_E32_MASK (2886) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSQRT_V_M4_E64 (2887) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSQRT_V_M4_E64_MASK (2888) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSQRT_V_M8_E16 (2889) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSQRT_V_M8_E16_MASK (2890) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSQRT_V_M8_E32 (2891) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSQRT_V_M8_E32_MASK (2892) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSQRT_V_M8_E64 (2893) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSQRT_V_M8_E64_MASK (2894) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSQRT_V_MF2_E16 (2895) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSQRT_V_MF2_E16_MASK (2896) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSQRT_V_MF2_E32 (2897) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSQRT_V_MF2_E32_MASK (2898) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSQRT_V_MF4_E16 (2899) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSQRT_V_MF4_E16_MASK (2900) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSUB_VFPR16_M1 (2901) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSUB_VFPR16_M1_MASK (2902) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSUB_VFPR16_M2 (2903) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSUB_VFPR16_M2_MASK (2904) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSUB_VFPR16_M4 (2905) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSUB_VFPR16_M4_MASK (2906) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSUB_VFPR16_M8 (2907) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSUB_VFPR16_M8_MASK (2908) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSUB_VFPR16_MF2 (2909) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSUB_VFPR16_MF2_MASK (2910) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSUB_VFPR16_MF4 (2911) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSUB_VFPR16_MF4_MASK (2912) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSUB_VFPR32_M1 (2913) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSUB_VFPR32_M1_MASK (2914) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSUB_VFPR32_M2 (2915) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSUB_VFPR32_M2_MASK (2916) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSUB_VFPR32_M4 (2917) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSUB_VFPR32_M4_MASK (2918) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSUB_VFPR32_M8 (2919) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSUB_VFPR32_M8_MASK (2920) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSUB_VFPR32_MF2 (2921) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSUB_VFPR32_MF2_MASK (2922) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSUB_VFPR64_M1 (2923) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSUB_VFPR64_M1_MASK (2924) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSUB_VFPR64_M2 (2925) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSUB_VFPR64_M2_MASK (2926) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSUB_VFPR64_M4 (2927) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSUB_VFPR64_M4_MASK (2928) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSUB_VFPR64_M8 (2929) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSUB_VFPR64_M8_MASK (2930) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSUB_VV_M1 (2931) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSUB_VV_M1_MASK (2932) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSUB_VV_M2 (2933) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSUB_VV_M2_MASK (2934) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSUB_VV_M4 (2935) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSUB_VV_M4_MASK (2936) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSUB_VV_M8 (2937) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSUB_VV_M8_MASK (2938) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSUB_VV_MF2 (2939) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSUB_VV_MF2_MASK (2940) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSUB_VV_MF4 (2941) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFSUB_VV_MF4_MASK (2942) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_VFPR16_M1 (2943) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_VFPR16_M1_MASK (2944) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_VFPR16_M2 (2945) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_VFPR16_M2_MASK (2946) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_VFPR16_M4 (2947) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_VFPR16_M4_MASK (2948) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_VFPR16_MF2 (2949) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_VFPR16_MF2_MASK (2950) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_VFPR16_MF4 (2951) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_VFPR16_MF4_MASK (2952) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_VFPR32_M1 (2953) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_VFPR32_M1_MASK (2954) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_VFPR32_M2 (2955) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_VFPR32_M2_MASK (2956) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_VFPR32_M4 (2957) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_VFPR32_M4_MASK (2958) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_VFPR32_MF2 (2959) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_VFPR32_MF2_MASK (2960) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_VV_M1 (2961) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_VV_M1_MASK (2962) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_VV_M2 (2963) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_VV_M2_MASK (2964) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_VV_M4 (2965) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_VV_M4_MASK (2966) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_VV_MF2 (2967) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_VV_MF2_MASK (2968) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_VV_MF4 (2969) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_VV_MF4_MASK (2970) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_WFPR16_M1 (2971) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_WFPR16_M1_MASK (2972) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_WFPR16_M2 (2973) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_WFPR16_M2_MASK (2974) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_WFPR16_M4 (2975) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_WFPR16_M4_MASK (2976) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_WFPR16_MF2 (2977) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_WFPR16_MF2_MASK (2978) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_WFPR16_MF4 (2979) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_WFPR16_MF4_MASK (2980) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_WFPR32_M1 (2981) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_WFPR32_M1_MASK (2982) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_WFPR32_M2 (2983) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_WFPR32_M2_MASK (2984) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_WFPR32_M4 (2985) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_WFPR32_M4_MASK (2986) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_WFPR32_MF2 (2987) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_WFPR32_MF2_MASK (2988) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_WV_M1 (2989) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_WV_M1_MASK (2990) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_WV_M1_MASK_TIED (2991) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_WV_M1_TIED (2992) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_WV_M2 (2993) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_WV_M2_MASK (2994) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_WV_M2_MASK_TIED (2995) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_WV_M2_TIED (2996) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_WV_M4 (2997) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_WV_M4_MASK (2998) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_WV_M4_MASK_TIED (2999) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_WV_M4_TIED (3000) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_WV_MF2 (3001) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_WV_MF2_MASK (3002) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_WV_MF2_MASK_TIED (3003) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_WV_MF2_TIED (3004) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_WV_MF4 (3005) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_WV_MF4_MASK (3006) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_WV_MF4_MASK_TIED (3007) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWADD_WV_MF4_TIED (3008) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVTBF16_F_F_V_M1 (3009) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVTBF16_F_F_V_M1_MASK (3010) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVTBF16_F_F_V_M2 (3011) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVTBF16_F_F_V_M2_MASK (3012) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVTBF16_F_F_V_M4 (3013) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVTBF16_F_F_V_M4_MASK (3014) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVTBF16_F_F_V_MF2 (3015) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVTBF16_F_F_V_MF2_MASK (3016) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVTBF16_F_F_V_MF4 (3017) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVTBF16_F_F_V_MF4_MASK (3018) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_F_F_V_M1 (3019) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_F_F_V_M1_MASK (3020) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_F_F_V_M2 (3021) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_F_F_V_M2_MASK (3022) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_F_F_V_M4 (3023) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_F_F_V_M4_MASK (3024) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_F_F_V_MF2 (3025) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_F_F_V_MF2_MASK (3026) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_F_F_V_MF4 (3027) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_F_F_V_MF4_MASK (3028) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_F_XU_V_M1 (3029) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_F_XU_V_M1_MASK (3030) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_F_XU_V_M2 (3031) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_F_XU_V_M2_MASK (3032) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_F_XU_V_M4 (3033) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_F_XU_V_M4_MASK (3034) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_F_XU_V_MF2 (3035) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_F_XU_V_MF2_MASK (3036) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_F_XU_V_MF4 (3037) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_F_XU_V_MF4_MASK (3038) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_F_XU_V_MF8 (3039) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_F_XU_V_MF8_MASK (3040) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_F_X_V_M1 (3041) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_F_X_V_M1_MASK (3042) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_F_X_V_M2 (3043) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_F_X_V_M2_MASK (3044) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_F_X_V_M4 (3045) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_F_X_V_M4_MASK (3046) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_F_X_V_MF2 (3047) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_F_X_V_MF2_MASK (3048) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_F_X_V_MF4 (3049) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_F_X_V_MF4_MASK (3050) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_F_X_V_MF8 (3051) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_F_X_V_MF8_MASK (3052) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_RM_XU_F_V_M1 (3053) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_RM_XU_F_V_M1_MASK (3054) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_RM_XU_F_V_M2 (3055) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_RM_XU_F_V_M2_MASK (3056) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_RM_XU_F_V_M4 (3057) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_RM_XU_F_V_M4_MASK (3058) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_RM_XU_F_V_MF2 (3059) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_RM_XU_F_V_MF2_MASK (3060) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_RM_XU_F_V_MF4 (3061) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_RM_XU_F_V_MF4_MASK (3062) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_RM_X_F_V_M1 (3063) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_RM_X_F_V_M1_MASK (3064) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_RM_X_F_V_M2 (3065) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_RM_X_F_V_M2_MASK (3066) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_RM_X_F_V_M4 (3067) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_RM_X_F_V_M4_MASK (3068) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_RM_X_F_V_MF2 (3069) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_RM_X_F_V_MF2_MASK (3070) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_RM_X_F_V_MF4 (3071) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_RM_X_F_V_MF4_MASK (3072) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_RTZ_XU_F_V_M1 (3073) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_RTZ_XU_F_V_M1_MASK (3074) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_RTZ_XU_F_V_M2 (3075) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_RTZ_XU_F_V_M2_MASK (3076) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_RTZ_XU_F_V_M4 (3077) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_RTZ_XU_F_V_M4_MASK (3078) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_RTZ_XU_F_V_MF2 (3079) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_RTZ_XU_F_V_MF2_MASK (3080) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_RTZ_XU_F_V_MF4 (3081) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_RTZ_XU_F_V_MF4_MASK (3082) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_RTZ_X_F_V_M1 (3083) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_RTZ_X_F_V_M1_MASK (3084) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_RTZ_X_F_V_M2 (3085) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_RTZ_X_F_V_M2_MASK (3086) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_RTZ_X_F_V_M4 (3087) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_RTZ_X_F_V_M4_MASK (3088) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_RTZ_X_F_V_MF2 (3089) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_RTZ_X_F_V_MF2_MASK (3090) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_RTZ_X_F_V_MF4 (3091) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_RTZ_X_F_V_MF4_MASK (3092) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_XU_F_V_M1 (3093) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_XU_F_V_M1_MASK (3094) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_XU_F_V_M2 (3095) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_XU_F_V_M2_MASK (3096) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_XU_F_V_M4 (3097) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_XU_F_V_M4_MASK (3098) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_XU_F_V_MF2 (3099) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_XU_F_V_MF2_MASK (3100) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_XU_F_V_MF4 (3101) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_XU_F_V_MF4_MASK (3102) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_X_F_V_M1 (3103) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_X_F_V_M1_MASK (3104) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_X_F_V_M2 (3105) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_X_F_V_M2_MASK (3106) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_X_F_V_M4 (3107) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_X_F_V_M4_MASK (3108) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_X_F_V_MF2 (3109) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_X_F_V_MF2_MASK (3110) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_X_F_V_MF4 (3111) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWCVT_X_F_V_MF4_MASK (3112) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMACCBF16_VFPR16_M1 (3113) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMACCBF16_VFPR16_M1_MASK (3114) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMACCBF16_VFPR16_M2 (3115) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMACCBF16_VFPR16_M2_MASK (3116) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMACCBF16_VFPR16_M4 (3117) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMACCBF16_VFPR16_M4_MASK (3118) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMACCBF16_VFPR16_MF2 (3119) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMACCBF16_VFPR16_MF2_MASK (3120) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMACCBF16_VFPR16_MF4 (3121) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMACCBF16_VFPR16_MF4_MASK (3122) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMACCBF16_VV_M1 (3123) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMACCBF16_VV_M1_MASK (3124) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMACCBF16_VV_M2 (3125) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMACCBF16_VV_M2_MASK (3126) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMACCBF16_VV_M4 (3127) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMACCBF16_VV_M4_MASK (3128) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMACCBF16_VV_MF2 (3129) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMACCBF16_VV_MF2_MASK (3130) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMACCBF16_VV_MF4 (3131) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMACCBF16_VV_MF4_MASK (3132) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMACC_4x4x4_M1 (3133) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMACC_4x4x4_M2 (3134) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMACC_4x4x4_M4 (3135) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMACC_4x4x4_M8 (3136) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMACC_4x4x4_MF2 (3137) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMACC_4x4x4_MF4 (3138) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMACC_VFPR16_M1 (3139) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMACC_VFPR16_M1_MASK (3140) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMACC_VFPR16_M2 (3141) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMACC_VFPR16_M2_MASK (3142) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMACC_VFPR16_M4 (3143) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMACC_VFPR16_M4_MASK (3144) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMACC_VFPR16_MF2 (3145) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMACC_VFPR16_MF2_MASK (3146) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMACC_VFPR16_MF4 (3147) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMACC_VFPR16_MF4_MASK (3148) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMACC_VFPR32_M1 (3149) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMACC_VFPR32_M1_MASK (3150) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMACC_VFPR32_M2 (3151) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMACC_VFPR32_M2_MASK (3152) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMACC_VFPR32_M4 (3153) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMACC_VFPR32_M4_MASK (3154) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMACC_VFPR32_MF2 (3155) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMACC_VFPR32_MF2_MASK (3156) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMACC_VV_M1 (3157) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMACC_VV_M1_MASK (3158) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMACC_VV_M2 (3159) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMACC_VV_M2_MASK (3160) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMACC_VV_M4 (3161) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMACC_VV_M4_MASK (3162) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMACC_VV_MF2 (3163) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMACC_VV_MF2_MASK (3164) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMACC_VV_MF4 (3165) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMACC_VV_MF4_MASK (3166) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMSAC_VFPR16_M1 (3167) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMSAC_VFPR16_M1_MASK (3168) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMSAC_VFPR16_M2 (3169) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMSAC_VFPR16_M2_MASK (3170) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMSAC_VFPR16_M4 (3171) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMSAC_VFPR16_M4_MASK (3172) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMSAC_VFPR16_MF2 (3173) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMSAC_VFPR16_MF2_MASK (3174) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMSAC_VFPR16_MF4 (3175) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMSAC_VFPR16_MF4_MASK (3176) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMSAC_VFPR32_M1 (3177) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMSAC_VFPR32_M1_MASK (3178) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMSAC_VFPR32_M2 (3179) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMSAC_VFPR32_M2_MASK (3180) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMSAC_VFPR32_M4 (3181) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMSAC_VFPR32_M4_MASK (3182) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMSAC_VFPR32_MF2 (3183) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMSAC_VFPR32_MF2_MASK (3184) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMSAC_VV_M1 (3185) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMSAC_VV_M1_MASK (3186) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMSAC_VV_M2 (3187) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMSAC_VV_M2_MASK (3188) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMSAC_VV_M4 (3189) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMSAC_VV_M4_MASK (3190) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMSAC_VV_MF2 (3191) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMSAC_VV_MF2_MASK (3192) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMSAC_VV_MF4 (3193) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMSAC_VV_MF4_MASK (3194) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMUL_VFPR16_M1 (3195) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMUL_VFPR16_M1_MASK (3196) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMUL_VFPR16_M2 (3197) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMUL_VFPR16_M2_MASK (3198) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMUL_VFPR16_M4 (3199) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMUL_VFPR16_M4_MASK (3200) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMUL_VFPR16_MF2 (3201) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMUL_VFPR16_MF2_MASK (3202) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMUL_VFPR16_MF4 (3203) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMUL_VFPR16_MF4_MASK (3204) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMUL_VFPR32_M1 (3205) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMUL_VFPR32_M1_MASK (3206) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMUL_VFPR32_M2 (3207) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMUL_VFPR32_M2_MASK (3208) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMUL_VFPR32_M4 (3209) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMUL_VFPR32_M4_MASK (3210) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMUL_VFPR32_MF2 (3211) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMUL_VFPR32_MF2_MASK (3212) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMUL_VV_M1 (3213) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMUL_VV_M1_MASK (3214) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMUL_VV_M2 (3215) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMUL_VV_M2_MASK (3216) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMUL_VV_M4 (3217) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMUL_VV_M4_MASK (3218) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMUL_VV_MF2 (3219) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMUL_VV_MF2_MASK (3220) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMUL_VV_MF4 (3221) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWMUL_VV_MF4_MASK (3222) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWNMACC_VFPR16_M1 (3223) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWNMACC_VFPR16_M1_MASK (3224) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWNMACC_VFPR16_M2 (3225) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWNMACC_VFPR16_M2_MASK (3226) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWNMACC_VFPR16_M4 (3227) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWNMACC_VFPR16_M4_MASK (3228) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWNMACC_VFPR16_MF2 (3229) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWNMACC_VFPR16_MF2_MASK (3230) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWNMACC_VFPR16_MF4 (3231) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWNMACC_VFPR16_MF4_MASK (3232) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWNMACC_VFPR32_M1 (3233) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWNMACC_VFPR32_M1_MASK (3234) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWNMACC_VFPR32_M2 (3235) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWNMACC_VFPR32_M2_MASK (3236) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWNMACC_VFPR32_M4 (3237) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWNMACC_VFPR32_M4_MASK (3238) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWNMACC_VFPR32_MF2 (3239) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWNMACC_VFPR32_MF2_MASK (3240) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWNMACC_VV_M1 (3241) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWNMACC_VV_M1_MASK (3242) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWNMACC_VV_M2 (3243) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWNMACC_VV_M2_MASK (3244) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWNMACC_VV_M4 (3245) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWNMACC_VV_M4_MASK (3246) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWNMACC_VV_MF2 (3247) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWNMACC_VV_MF2_MASK (3248) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWNMACC_VV_MF4 (3249) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWNMACC_VV_MF4_MASK (3250) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWNMSAC_VFPR16_M1 (3251) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWNMSAC_VFPR16_M1_MASK (3252) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWNMSAC_VFPR16_M2 (3253) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWNMSAC_VFPR16_M2_MASK (3254) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWNMSAC_VFPR16_M4 (3255) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWNMSAC_VFPR16_M4_MASK (3256) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWNMSAC_VFPR16_MF2 (3257) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWNMSAC_VFPR16_MF2_MASK (3258) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWNMSAC_VFPR16_MF4 (3259) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWNMSAC_VFPR16_MF4_MASK (3260) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWNMSAC_VFPR32_M1 (3261) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWNMSAC_VFPR32_M1_MASK (3262) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWNMSAC_VFPR32_M2 (3263) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWNMSAC_VFPR32_M2_MASK (3264) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWNMSAC_VFPR32_M4 (3265) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWNMSAC_VFPR32_M4_MASK (3266) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWNMSAC_VFPR32_MF2 (3267) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWNMSAC_VFPR32_MF2_MASK (3268) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWNMSAC_VV_M1 (3269) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWNMSAC_VV_M1_MASK (3270) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWNMSAC_VV_M2 (3271) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWNMSAC_VV_M2_MASK (3272) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWNMSAC_VV_M4 (3273) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWNMSAC_VV_M4_MASK (3274) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWNMSAC_VV_MF2 (3275) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWNMSAC_VV_MF2_MASK (3276) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWNMSAC_VV_MF4 (3277) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWNMSAC_VV_MF4_MASK (3278) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWREDOSUM_VS_M1_E16 (3279) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWREDOSUM_VS_M1_E16_MASK (3280) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWREDOSUM_VS_M1_E32 (3281) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWREDOSUM_VS_M1_E32_MASK (3282) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWREDOSUM_VS_M2_E16 (3283) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWREDOSUM_VS_M2_E16_MASK (3284) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWREDOSUM_VS_M2_E32 (3285) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWREDOSUM_VS_M2_E32_MASK (3286) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWREDOSUM_VS_M4_E16 (3287) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWREDOSUM_VS_M4_E16_MASK (3288) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWREDOSUM_VS_M4_E32 (3289) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWREDOSUM_VS_M4_E32_MASK (3290) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWREDOSUM_VS_M8_E16 (3291) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWREDOSUM_VS_M8_E16_MASK (3292) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWREDOSUM_VS_M8_E32 (3293) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWREDOSUM_VS_M8_E32_MASK (3294) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWREDOSUM_VS_MF2_E16 (3295) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWREDOSUM_VS_MF2_E16_MASK (3296) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWREDOSUM_VS_MF2_E32 (3297) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWREDOSUM_VS_MF2_E32_MASK (3298) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWREDOSUM_VS_MF4_E16 (3299) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWREDOSUM_VS_MF4_E16_MASK (3300) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWREDUSUM_VS_M1_E16 (3301) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWREDUSUM_VS_M1_E16_MASK (3302) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWREDUSUM_VS_M1_E32 (3303) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWREDUSUM_VS_M1_E32_MASK (3304) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWREDUSUM_VS_M2_E16 (3305) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWREDUSUM_VS_M2_E16_MASK (3306) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWREDUSUM_VS_M2_E32 (3307) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWREDUSUM_VS_M2_E32_MASK (3308) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWREDUSUM_VS_M4_E16 (3309) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWREDUSUM_VS_M4_E16_MASK (3310) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWREDUSUM_VS_M4_E32 (3311) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWREDUSUM_VS_M4_E32_MASK (3312) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWREDUSUM_VS_M8_E16 (3313) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWREDUSUM_VS_M8_E16_MASK (3314) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWREDUSUM_VS_M8_E32 (3315) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWREDUSUM_VS_M8_E32_MASK (3316) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWREDUSUM_VS_MF2_E16 (3317) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWREDUSUM_VS_MF2_E16_MASK (3318) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWREDUSUM_VS_MF2_E32 (3319) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWREDUSUM_VS_MF2_E32_MASK (3320) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWREDUSUM_VS_MF4_E16 (3321) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWREDUSUM_VS_MF4_E16_MASK (3322) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_VFPR16_M1 (3323) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_VFPR16_M1_MASK (3324) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_VFPR16_M2 (3325) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_VFPR16_M2_MASK (3326) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_VFPR16_M4 (3327) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_VFPR16_M4_MASK (3328) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_VFPR16_MF2 (3329) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_VFPR16_MF2_MASK (3330) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_VFPR16_MF4 (3331) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_VFPR16_MF4_MASK (3332) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_VFPR32_M1 (3333) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_VFPR32_M1_MASK (3334) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_VFPR32_M2 (3335) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_VFPR32_M2_MASK (3336) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_VFPR32_M4 (3337) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_VFPR32_M4_MASK (3338) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_VFPR32_MF2 (3339) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_VFPR32_MF2_MASK (3340) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_VV_M1 (3341) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_VV_M1_MASK (3342) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_VV_M2 (3343) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_VV_M2_MASK (3344) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_VV_M4 (3345) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_VV_M4_MASK (3346) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_VV_MF2 (3347) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_VV_MF2_MASK (3348) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_VV_MF4 (3349) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_VV_MF4_MASK (3350) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_WFPR16_M1 (3351) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_WFPR16_M1_MASK (3352) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_WFPR16_M2 (3353) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_WFPR16_M2_MASK (3354) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_WFPR16_M4 (3355) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_WFPR16_M4_MASK (3356) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_WFPR16_MF2 (3357) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_WFPR16_MF2_MASK (3358) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_WFPR16_MF4 (3359) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_WFPR16_MF4_MASK (3360) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_WFPR32_M1 (3361) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_WFPR32_M1_MASK (3362) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_WFPR32_M2 (3363) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_WFPR32_M2_MASK (3364) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_WFPR32_M4 (3365) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_WFPR32_M4_MASK (3366) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_WFPR32_MF2 (3367) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_WFPR32_MF2_MASK (3368) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_WV_M1 (3369) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_WV_M1_MASK (3370) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_WV_M1_MASK_TIED (3371) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_WV_M1_TIED (3372) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_WV_M2 (3373) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_WV_M2_MASK (3374) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_WV_M2_MASK_TIED (3375) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_WV_M2_TIED (3376) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_WV_M4 (3377) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_WV_M4_MASK (3378) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_WV_M4_MASK_TIED (3379) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_WV_M4_TIED (3380) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_WV_MF2 (3381) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_WV_MF2_MASK (3382) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_WV_MF2_MASK_TIED (3383) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_WV_MF2_TIED (3384) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_WV_MF4 (3385) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_WV_MF4_MASK (3386) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_WV_MF4_MASK_TIED (3387) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVFWSUB_WV_MF4_TIED (3388) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVGHSH_VV_M1 (3389) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVGHSH_VV_M2 (3390) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVGHSH_VV_M4 (3391) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVGHSH_VV_M8 (3392) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVGHSH_VV_MF2 (3393) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVGMUL_VV_M1 (3394) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVGMUL_VV_M2 (3395) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVGMUL_VV_M4 (3396) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVGMUL_VV_M8 (3397) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVGMUL_VV_MF2 (3398) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVID_V_M1 (3399) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVID_V_M1_MASK (3400) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVID_V_M2 (3401) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVID_V_M2_MASK (3402) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVID_V_M4 (3403) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVID_V_M4_MASK (3404) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVID_V_M8 (3405) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVID_V_M8_MASK (3406) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVID_V_MF2 (3407) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVID_V_MF2_MASK (3408) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVID_V_MF4 (3409) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVID_V_MF4_MASK (3410) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVID_V_MF8 (3411) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVID_V_MF8_MASK (3412) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVIOTA_M_M1 (3413) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVIOTA_M_M1_MASK (3414) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVIOTA_M_M2 (3415) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVIOTA_M_M2_MASK (3416) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVIOTA_M_M4 (3417) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVIOTA_M_M4_MASK (3418) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVIOTA_M_M8 (3419) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVIOTA_M_M8_MASK (3420) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVIOTA_M_MF2 (3421) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVIOTA_M_MF2_MASK (3422) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVIOTA_M_MF4 (3423) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVIOTA_M_MF4_MASK (3424) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVIOTA_M_MF8 (3425) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVIOTA_M_MF8_MASK (3426) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE16FF_V_M1 (3427) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE16FF_V_M1_MASK (3428) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE16FF_V_M2 (3429) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE16FF_V_M2_MASK (3430) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE16FF_V_M4 (3431) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE16FF_V_M4_MASK (3432) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE16FF_V_M8 (3433) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE16FF_V_M8_MASK (3434) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE16FF_V_MF2 (3435) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE16FF_V_MF2_MASK (3436) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE16FF_V_MF4 (3437) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE16FF_V_MF4_MASK (3438) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE16_V_M1 (3439) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE16_V_M1_MASK (3440) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE16_V_M2 (3441) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE16_V_M2_MASK (3442) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE16_V_M4 (3443) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE16_V_M4_MASK (3444) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE16_V_M8 (3445) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE16_V_M8_MASK (3446) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE16_V_MF2 (3447) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE16_V_MF2_MASK (3448) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE16_V_MF4 (3449) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE16_V_MF4_MASK (3450) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE32FF_V_M1 (3451) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE32FF_V_M1_MASK (3452) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE32FF_V_M2 (3453) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE32FF_V_M2_MASK (3454) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE32FF_V_M4 (3455) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE32FF_V_M4_MASK (3456) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE32FF_V_M8 (3457) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE32FF_V_M8_MASK (3458) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE32FF_V_MF2 (3459) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE32FF_V_MF2_MASK (3460) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE32_V_M1 (3461) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE32_V_M1_MASK (3462) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE32_V_M2 (3463) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE32_V_M2_MASK (3464) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE32_V_M4 (3465) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE32_V_M4_MASK (3466) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE32_V_M8 (3467) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE32_V_M8_MASK (3468) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE32_V_MF2 (3469) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE32_V_MF2_MASK (3470) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE64FF_V_M1 (3471) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE64FF_V_M1_MASK (3472) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE64FF_V_M2 (3473) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE64FF_V_M2_MASK (3474) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE64FF_V_M4 (3475) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE64FF_V_M4_MASK (3476) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE64FF_V_M8 (3477) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE64FF_V_M8_MASK (3478) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE64_V_M1 (3479) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE64_V_M1_MASK (3480) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE64_V_M2 (3481) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE64_V_M2_MASK (3482) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE64_V_M4 (3483) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE64_V_M4_MASK (3484) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE64_V_M8 (3485) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE64_V_M8_MASK (3486) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE8FF_V_M1 (3487) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE8FF_V_M1_MASK (3488) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE8FF_V_M2 (3489) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE8FF_V_M2_MASK (3490) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE8FF_V_M4 (3491) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE8FF_V_M4_MASK (3492) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE8FF_V_M8 (3493) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE8FF_V_M8_MASK (3494) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE8FF_V_MF2 (3495) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE8FF_V_MF2_MASK (3496) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE8FF_V_MF4 (3497) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE8FF_V_MF4_MASK (3498) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE8FF_V_MF8 (3499) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE8FF_V_MF8_MASK (3500) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE8_V_M1 (3501) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE8_V_M1_MASK (3502) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE8_V_M2 (3503) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE8_V_M2_MASK (3504) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE8_V_M4 (3505) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE8_V_M4_MASK (3506) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE8_V_M8 (3507) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE8_V_M8_MASK (3508) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE8_V_MF2 (3509) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE8_V_MF2_MASK (3510) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE8_V_MF4 (3511) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE8_V_MF4_MASK (3512) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE8_V_MF8 (3513) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLE8_V_MF8_MASK (3514) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLM_V_B1 (3515) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLM_V_B16 (3516) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLM_V_B2 (3517) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLM_V_B32 (3518) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLM_V_B4 (3519) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLM_V_B64 (3520) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLM_V_B8 (3521) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI16_V_M1_M1 (3522) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI16_V_M1_M1_MASK (3523) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI16_V_M1_M2 (3524) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI16_V_M1_M2_MASK (3525) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI16_V_M1_M4 (3526) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI16_V_M1_M4_MASK (3527) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI16_V_M1_MF2 (3528) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI16_V_M1_MF2_MASK (3529) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI16_V_M2_M1 (3530) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI16_V_M2_M1_MASK (3531) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI16_V_M2_M2 (3532) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI16_V_M2_M2_MASK (3533) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI16_V_M2_M4 (3534) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI16_V_M2_M4_MASK (3535) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI16_V_M2_M8 (3536) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI16_V_M2_M8_MASK (3537) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI16_V_M4_M2 (3538) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI16_V_M4_M2_MASK (3539) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI16_V_M4_M4 (3540) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI16_V_M4_M4_MASK (3541) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI16_V_M4_M8 (3542) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI16_V_M4_M8_MASK (3543) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI16_V_M8_M4 (3544) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI16_V_M8_M4_MASK (3545) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI16_V_M8_M8 (3546) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI16_V_M8_M8_MASK (3547) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI16_V_MF2_M1 (3548) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI16_V_MF2_M1_MASK (3549) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI16_V_MF2_M2 (3550) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI16_V_MF2_M2_MASK (3551) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI16_V_MF2_MF2 (3552) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI16_V_MF2_MF2_MASK (3553) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI16_V_MF2_MF4 (3554) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI16_V_MF2_MF4_MASK (3555) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI16_V_MF4_M1 (3556) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI16_V_MF4_M1_MASK (3557) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI16_V_MF4_MF2 (3558) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI16_V_MF4_MF2_MASK (3559) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI16_V_MF4_MF4 (3560) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI16_V_MF4_MF4_MASK (3561) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI16_V_MF4_MF8 (3562) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI16_V_MF4_MF8_MASK (3563) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI32_V_M1_M1 (3564) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI32_V_M1_M1_MASK (3565) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI32_V_M1_M2 (3566) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI32_V_M1_M2_MASK (3567) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI32_V_M1_MF2 (3568) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI32_V_M1_MF2_MASK (3569) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI32_V_M1_MF4 (3570) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI32_V_M1_MF4_MASK (3571) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI32_V_M2_M1 (3572) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI32_V_M2_M1_MASK (3573) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI32_V_M2_M2 (3574) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI32_V_M2_M2_MASK (3575) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI32_V_M2_M4 (3576) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI32_V_M2_M4_MASK (3577) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI32_V_M2_MF2 (3578) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI32_V_M2_MF2_MASK (3579) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI32_V_M4_M1 (3580) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI32_V_M4_M1_MASK (3581) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI32_V_M4_M2 (3582) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI32_V_M4_M2_MASK (3583) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI32_V_M4_M4 (3584) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI32_V_M4_M4_MASK (3585) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI32_V_M4_M8 (3586) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI32_V_M4_M8_MASK (3587) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI32_V_M8_M2 (3588) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI32_V_M8_M2_MASK (3589) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI32_V_M8_M4 (3590) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI32_V_M8_M4_MASK (3591) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI32_V_M8_M8 (3592) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI32_V_M8_M8_MASK (3593) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI32_V_MF2_M1 (3594) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI32_V_MF2_M1_MASK (3595) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI32_V_MF2_MF2 (3596) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI32_V_MF2_MF2_MASK (3597) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI32_V_MF2_MF4 (3598) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI32_V_MF2_MF4_MASK (3599) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI32_V_MF2_MF8 (3600) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI32_V_MF2_MF8_MASK (3601) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI64_V_M1_M1 (3602) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI64_V_M1_M1_MASK (3603) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI64_V_M1_MF2 (3604) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI64_V_M1_MF2_MASK (3605) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI64_V_M1_MF4 (3606) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI64_V_M1_MF4_MASK (3607) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI64_V_M1_MF8 (3608) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI64_V_M1_MF8_MASK (3609) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI64_V_M2_M1 (3610) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI64_V_M2_M1_MASK (3611) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI64_V_M2_M2 (3612) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI64_V_M2_M2_MASK (3613) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI64_V_M2_MF2 (3614) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI64_V_M2_MF2_MASK (3615) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI64_V_M2_MF4 (3616) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI64_V_M2_MF4_MASK (3617) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI64_V_M4_M1 (3618) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI64_V_M4_M1_MASK (3619) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI64_V_M4_M2 (3620) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI64_V_M4_M2_MASK (3621) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI64_V_M4_M4 (3622) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI64_V_M4_M4_MASK (3623) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI64_V_M4_MF2 (3624) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI64_V_M4_MF2_MASK (3625) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI64_V_M8_M1 (3626) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI64_V_M8_M1_MASK (3627) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI64_V_M8_M2 (3628) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI64_V_M8_M2_MASK (3629) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI64_V_M8_M4 (3630) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI64_V_M8_M4_MASK (3631) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI64_V_M8_M8 (3632) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI64_V_M8_M8_MASK (3633) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI8_V_M1_M1 (3634) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI8_V_M1_M1_MASK (3635) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI8_V_M1_M2 (3636) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI8_V_M1_M2_MASK (3637) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI8_V_M1_M4 (3638) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI8_V_M1_M4_MASK (3639) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI8_V_M1_M8 (3640) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI8_V_M1_M8_MASK (3641) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI8_V_M2_M2 (3642) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI8_V_M2_M2_MASK (3643) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI8_V_M2_M4 (3644) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI8_V_M2_M4_MASK (3645) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI8_V_M2_M8 (3646) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI8_V_M2_M8_MASK (3647) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI8_V_M4_M4 (3648) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI8_V_M4_M4_MASK (3649) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI8_V_M4_M8 (3650) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI8_V_M4_M8_MASK (3651) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI8_V_M8_M8 (3652) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI8_V_M8_M8_MASK (3653) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI8_V_MF2_M1 (3654) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI8_V_MF2_M1_MASK (3655) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI8_V_MF2_M2 (3656) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI8_V_MF2_M2_MASK (3657) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI8_V_MF2_M4 (3658) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI8_V_MF2_M4_MASK (3659) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI8_V_MF2_MF2 (3660) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI8_V_MF2_MF2_MASK (3661) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI8_V_MF4_M1 (3662) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI8_V_MF4_M1_MASK (3663) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI8_V_MF4_M2 (3664) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI8_V_MF4_M2_MASK (3665) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI8_V_MF4_MF2 (3666) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI8_V_MF4_MF2_MASK (3667) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI8_V_MF4_MF4 (3668) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI8_V_MF4_MF4_MASK (3669) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI8_V_MF8_M1 (3670) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI8_V_MF8_M1_MASK (3671) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI8_V_MF8_MF2 (3672) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI8_V_MF8_MF2_MASK (3673) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI8_V_MF8_MF4 (3674) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI8_V_MF8_MF4_MASK (3675) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI8_V_MF8_MF8 (3676) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXEI8_V_MF8_MF8_MASK (3677) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI16_V_M1_M1 (3678) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI16_V_M1_M1_MASK (3679) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI16_V_M1_M2 (3680) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI16_V_M1_M2_MASK (3681) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI16_V_M1_M4 (3682) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI16_V_M1_M4_MASK (3683) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI16_V_M1_MF2 (3684) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI16_V_M1_MF2_MASK (3685) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI16_V_M2_M1 (3686) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI16_V_M2_M1_MASK (3687) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI16_V_M2_M2 (3688) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI16_V_M2_M2_MASK (3689) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI16_V_M2_M4 (3690) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI16_V_M2_M4_MASK (3691) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI16_V_M4_M2 (3692) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI16_V_M4_M2_MASK (3693) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI16_V_M4_M4 (3694) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI16_V_M4_M4_MASK (3695) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI16_V_M8_M4 (3696) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI16_V_M8_M4_MASK (3697) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI16_V_MF2_M1 (3698) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI16_V_MF2_M1_MASK (3699) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI16_V_MF2_M2 (3700) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI16_V_MF2_M2_MASK (3701) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI16_V_MF2_MF2 (3702) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI16_V_MF2_MF2_MASK (3703) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI16_V_MF2_MF4 (3704) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI16_V_MF2_MF4_MASK (3705) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI16_V_MF4_M1 (3706) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI16_V_MF4_M1_MASK (3707) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI16_V_MF4_MF2 (3708) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI16_V_MF4_MF2_MASK (3709) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI16_V_MF4_MF4 (3710) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI16_V_MF4_MF4_MASK (3711) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI16_V_MF4_MF8 (3712) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI16_V_MF4_MF8_MASK (3713) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI32_V_M1_M1 (3714) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI32_V_M1_M1_MASK (3715) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI32_V_M1_M2 (3716) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI32_V_M1_M2_MASK (3717) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI32_V_M1_MF2 (3718) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI32_V_M1_MF2_MASK (3719) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI32_V_M1_MF4 (3720) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI32_V_M1_MF4_MASK (3721) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI32_V_M2_M1 (3722) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI32_V_M2_M1_MASK (3723) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI32_V_M2_M2 (3724) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI32_V_M2_M2_MASK (3725) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI32_V_M2_M4 (3726) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI32_V_M2_M4_MASK (3727) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI32_V_M2_MF2 (3728) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI32_V_M2_MF2_MASK (3729) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI32_V_M4_M1 (3730) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI32_V_M4_M1_MASK (3731) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI32_V_M4_M2 (3732) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI32_V_M4_M2_MASK (3733) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI32_V_M4_M4 (3734) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI32_V_M4_M4_MASK (3735) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI32_V_M8_M2 (3736) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI32_V_M8_M2_MASK (3737) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI32_V_M8_M4 (3738) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI32_V_M8_M4_MASK (3739) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI32_V_MF2_M1 (3740) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI32_V_MF2_M1_MASK (3741) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI32_V_MF2_MF2 (3742) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI32_V_MF2_MF2_MASK (3743) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI32_V_MF2_MF4 (3744) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI32_V_MF2_MF4_MASK (3745) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI32_V_MF2_MF8 (3746) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI32_V_MF2_MF8_MASK (3747) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI64_V_M1_M1 (3748) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI64_V_M1_M1_MASK (3749) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI64_V_M1_MF2 (3750) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI64_V_M1_MF2_MASK (3751) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI64_V_M1_MF4 (3752) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI64_V_M1_MF4_MASK (3753) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI64_V_M1_MF8 (3754) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI64_V_M1_MF8_MASK (3755) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI64_V_M2_M1 (3756) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI64_V_M2_M1_MASK (3757) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI64_V_M2_M2 (3758) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI64_V_M2_M2_MASK (3759) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI64_V_M2_MF2 (3760) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI64_V_M2_MF2_MASK (3761) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI64_V_M2_MF4 (3762) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI64_V_M2_MF4_MASK (3763) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI64_V_M4_M1 (3764) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI64_V_M4_M1_MASK (3765) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI64_V_M4_M2 (3766) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI64_V_M4_M2_MASK (3767) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI64_V_M4_M4 (3768) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI64_V_M4_M4_MASK (3769) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI64_V_M4_MF2 (3770) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI64_V_M4_MF2_MASK (3771) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI64_V_M8_M1 (3772) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI64_V_M8_M1_MASK (3773) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI64_V_M8_M2 (3774) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI64_V_M8_M2_MASK (3775) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI64_V_M8_M4 (3776) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI64_V_M8_M4_MASK (3777) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI8_V_M1_M1 (3778) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI8_V_M1_M1_MASK (3779) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI8_V_M1_M2 (3780) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI8_V_M1_M2_MASK (3781) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI8_V_M1_M4 (3782) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI8_V_M1_M4_MASK (3783) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI8_V_M2_M2 (3784) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI8_V_M2_M2_MASK (3785) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI8_V_M2_M4 (3786) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI8_V_M2_M4_MASK (3787) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI8_V_M4_M4 (3788) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI8_V_M4_M4_MASK (3789) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI8_V_MF2_M1 (3790) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI8_V_MF2_M1_MASK (3791) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI8_V_MF2_M2 (3792) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI8_V_MF2_M2_MASK (3793) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI8_V_MF2_M4 (3794) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI8_V_MF2_M4_MASK (3795) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI8_V_MF2_MF2 (3796) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI8_V_MF2_MF2_MASK (3797) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI8_V_MF4_M1 (3798) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI8_V_MF4_M1_MASK (3799) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI8_V_MF4_M2 (3800) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI8_V_MF4_M2_MASK (3801) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI8_V_MF4_MF2 (3802) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI8_V_MF4_MF2_MASK (3803) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI8_V_MF4_MF4 (3804) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI8_V_MF4_MF4_MASK (3805) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI8_V_MF8_M1 (3806) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI8_V_MF8_M1_MASK (3807) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI8_V_MF8_MF2 (3808) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI8_V_MF8_MF2_MASK (3809) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI8_V_MF8_MF4 (3810) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI8_V_MF8_MF4_MASK (3811) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI8_V_MF8_MF8 (3812) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG2EI8_V_MF8_MF8_MASK (3813) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI16_V_M1_M1 (3814) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI16_V_M1_M1_MASK (3815) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI16_V_M1_M2 (3816) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI16_V_M1_M2_MASK (3817) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI16_V_M1_MF2 (3818) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI16_V_M1_MF2_MASK (3819) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI16_V_M2_M1 (3820) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI16_V_M2_M1_MASK (3821) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI16_V_M2_M2 (3822) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI16_V_M2_M2_MASK (3823) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI16_V_M4_M2 (3824) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI16_V_M4_M2_MASK (3825) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI16_V_MF2_M1 (3826) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI16_V_MF2_M1_MASK (3827) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI16_V_MF2_M2 (3828) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI16_V_MF2_M2_MASK (3829) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI16_V_MF2_MF2 (3830) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI16_V_MF2_MF2_MASK (3831) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI16_V_MF2_MF4 (3832) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI16_V_MF2_MF4_MASK (3833) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI16_V_MF4_M1 (3834) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI16_V_MF4_M1_MASK (3835) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI16_V_MF4_MF2 (3836) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI16_V_MF4_MF2_MASK (3837) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI16_V_MF4_MF4 (3838) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI16_V_MF4_MF4_MASK (3839) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI16_V_MF4_MF8 (3840) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI16_V_MF4_MF8_MASK (3841) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI32_V_M1_M1 (3842) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI32_V_M1_M1_MASK (3843) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI32_V_M1_M2 (3844) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI32_V_M1_M2_MASK (3845) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI32_V_M1_MF2 (3846) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI32_V_M1_MF2_MASK (3847) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI32_V_M1_MF4 (3848) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI32_V_M1_MF4_MASK (3849) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI32_V_M2_M1 (3850) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI32_V_M2_M1_MASK (3851) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI32_V_M2_M2 (3852) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI32_V_M2_M2_MASK (3853) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI32_V_M2_MF2 (3854) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI32_V_M2_MF2_MASK (3855) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI32_V_M4_M1 (3856) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI32_V_M4_M1_MASK (3857) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI32_V_M4_M2 (3858) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI32_V_M4_M2_MASK (3859) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI32_V_M8_M2 (3860) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI32_V_M8_M2_MASK (3861) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI32_V_MF2_M1 (3862) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI32_V_MF2_M1_MASK (3863) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI32_V_MF2_MF2 (3864) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI32_V_MF2_MF2_MASK (3865) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI32_V_MF2_MF4 (3866) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI32_V_MF2_MF4_MASK (3867) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI32_V_MF2_MF8 (3868) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI32_V_MF2_MF8_MASK (3869) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI64_V_M1_M1 (3870) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI64_V_M1_M1_MASK (3871) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI64_V_M1_MF2 (3872) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI64_V_M1_MF2_MASK (3873) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI64_V_M1_MF4 (3874) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI64_V_M1_MF4_MASK (3875) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI64_V_M1_MF8 (3876) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI64_V_M1_MF8_MASK (3877) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI64_V_M2_M1 (3878) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI64_V_M2_M1_MASK (3879) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI64_V_M2_M2 (3880) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI64_V_M2_M2_MASK (3881) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI64_V_M2_MF2 (3882) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI64_V_M2_MF2_MASK (3883) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI64_V_M2_MF4 (3884) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI64_V_M2_MF4_MASK (3885) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI64_V_M4_M1 (3886) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI64_V_M4_M1_MASK (3887) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI64_V_M4_M2 (3888) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI64_V_M4_M2_MASK (3889) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI64_V_M4_MF2 (3890) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI64_V_M4_MF2_MASK (3891) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI64_V_M8_M1 (3892) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI64_V_M8_M1_MASK (3893) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI64_V_M8_M2 (3894) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI64_V_M8_M2_MASK (3895) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI8_V_M1_M1 (3896) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI8_V_M1_M1_MASK (3897) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI8_V_M1_M2 (3898) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI8_V_M1_M2_MASK (3899) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI8_V_M2_M2 (3900) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI8_V_M2_M2_MASK (3901) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI8_V_MF2_M1 (3902) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI8_V_MF2_M1_MASK (3903) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI8_V_MF2_M2 (3904) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI8_V_MF2_M2_MASK (3905) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI8_V_MF2_MF2 (3906) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI8_V_MF2_MF2_MASK (3907) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI8_V_MF4_M1 (3908) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI8_V_MF4_M1_MASK (3909) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI8_V_MF4_M2 (3910) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI8_V_MF4_M2_MASK (3911) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI8_V_MF4_MF2 (3912) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI8_V_MF4_MF2_MASK (3913) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI8_V_MF4_MF4 (3914) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI8_V_MF4_MF4_MASK (3915) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI8_V_MF8_M1 (3916) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI8_V_MF8_M1_MASK (3917) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI8_V_MF8_MF2 (3918) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI8_V_MF8_MF2_MASK (3919) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI8_V_MF8_MF4 (3920) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI8_V_MF8_MF4_MASK (3921) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI8_V_MF8_MF8 (3922) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG3EI8_V_MF8_MF8_MASK (3923) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI16_V_M1_M1 (3924) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI16_V_M1_M1_MASK (3925) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI16_V_M1_M2 (3926) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI16_V_M1_M2_MASK (3927) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI16_V_M1_MF2 (3928) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI16_V_M1_MF2_MASK (3929) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI16_V_M2_M1 (3930) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI16_V_M2_M1_MASK (3931) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI16_V_M2_M2 (3932) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI16_V_M2_M2_MASK (3933) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI16_V_M4_M2 (3934) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI16_V_M4_M2_MASK (3935) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI16_V_MF2_M1 (3936) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI16_V_MF2_M1_MASK (3937) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI16_V_MF2_M2 (3938) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI16_V_MF2_M2_MASK (3939) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI16_V_MF2_MF2 (3940) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI16_V_MF2_MF2_MASK (3941) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI16_V_MF2_MF4 (3942) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI16_V_MF2_MF4_MASK (3943) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI16_V_MF4_M1 (3944) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI16_V_MF4_M1_MASK (3945) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI16_V_MF4_MF2 (3946) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI16_V_MF4_MF2_MASK (3947) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI16_V_MF4_MF4 (3948) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI16_V_MF4_MF4_MASK (3949) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI16_V_MF4_MF8 (3950) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI16_V_MF4_MF8_MASK (3951) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI32_V_M1_M1 (3952) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI32_V_M1_M1_MASK (3953) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI32_V_M1_M2 (3954) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI32_V_M1_M2_MASK (3955) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI32_V_M1_MF2 (3956) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI32_V_M1_MF2_MASK (3957) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI32_V_M1_MF4 (3958) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI32_V_M1_MF4_MASK (3959) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI32_V_M2_M1 (3960) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI32_V_M2_M1_MASK (3961) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI32_V_M2_M2 (3962) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI32_V_M2_M2_MASK (3963) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI32_V_M2_MF2 (3964) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI32_V_M2_MF2_MASK (3965) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI32_V_M4_M1 (3966) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI32_V_M4_M1_MASK (3967) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI32_V_M4_M2 (3968) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI32_V_M4_M2_MASK (3969) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI32_V_M8_M2 (3970) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI32_V_M8_M2_MASK (3971) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI32_V_MF2_M1 (3972) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI32_V_MF2_M1_MASK (3973) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI32_V_MF2_MF2 (3974) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI32_V_MF2_MF2_MASK (3975) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI32_V_MF2_MF4 (3976) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI32_V_MF2_MF4_MASK (3977) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI32_V_MF2_MF8 (3978) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI32_V_MF2_MF8_MASK (3979) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI64_V_M1_M1 (3980) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI64_V_M1_M1_MASK (3981) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI64_V_M1_MF2 (3982) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI64_V_M1_MF2_MASK (3983) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI64_V_M1_MF4 (3984) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI64_V_M1_MF4_MASK (3985) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI64_V_M1_MF8 (3986) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI64_V_M1_MF8_MASK (3987) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI64_V_M2_M1 (3988) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI64_V_M2_M1_MASK (3989) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI64_V_M2_M2 (3990) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI64_V_M2_M2_MASK (3991) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI64_V_M2_MF2 (3992) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI64_V_M2_MF2_MASK (3993) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI64_V_M2_MF4 (3994) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI64_V_M2_MF4_MASK (3995) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI64_V_M4_M1 (3996) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI64_V_M4_M1_MASK (3997) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI64_V_M4_M2 (3998) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI64_V_M4_M2_MASK (3999) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI64_V_M4_MF2 (4000) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI64_V_M4_MF2_MASK (4001) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI64_V_M8_M1 (4002) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI64_V_M8_M1_MASK (4003) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI64_V_M8_M2 (4004) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI64_V_M8_M2_MASK (4005) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI8_V_M1_M1 (4006) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI8_V_M1_M1_MASK (4007) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI8_V_M1_M2 (4008) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI8_V_M1_M2_MASK (4009) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI8_V_M2_M2 (4010) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI8_V_M2_M2_MASK (4011) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI8_V_MF2_M1 (4012) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI8_V_MF2_M1_MASK (4013) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI8_V_MF2_M2 (4014) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI8_V_MF2_M2_MASK (4015) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI8_V_MF2_MF2 (4016) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI8_V_MF2_MF2_MASK (4017) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI8_V_MF4_M1 (4018) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI8_V_MF4_M1_MASK (4019) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI8_V_MF4_M2 (4020) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI8_V_MF4_M2_MASK (4021) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI8_V_MF4_MF2 (4022) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI8_V_MF4_MF2_MASK (4023) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI8_V_MF4_MF4 (4024) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI8_V_MF4_MF4_MASK (4025) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI8_V_MF8_M1 (4026) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI8_V_MF8_M1_MASK (4027) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI8_V_MF8_MF2 (4028) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI8_V_MF8_MF2_MASK (4029) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI8_V_MF8_MF4 (4030) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI8_V_MF8_MF4_MASK (4031) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI8_V_MF8_MF8 (4032) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG4EI8_V_MF8_MF8_MASK (4033) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI16_V_M1_M1 (4034) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI16_V_M1_M1_MASK (4035) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI16_V_M1_MF2 (4036) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI16_V_M1_MF2_MASK (4037) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI16_V_M2_M1 (4038) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI16_V_M2_M1_MASK (4039) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI16_V_MF2_M1 (4040) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI16_V_MF2_M1_MASK (4041) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI16_V_MF2_MF2 (4042) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI16_V_MF2_MF2_MASK (4043) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI16_V_MF2_MF4 (4044) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI16_V_MF2_MF4_MASK (4045) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI16_V_MF4_M1 (4046) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI16_V_MF4_M1_MASK (4047) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI16_V_MF4_MF2 (4048) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI16_V_MF4_MF2_MASK (4049) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI16_V_MF4_MF4 (4050) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI16_V_MF4_MF4_MASK (4051) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI16_V_MF4_MF8 (4052) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI16_V_MF4_MF8_MASK (4053) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI32_V_M1_M1 (4054) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI32_V_M1_M1_MASK (4055) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI32_V_M1_MF2 (4056) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI32_V_M1_MF2_MASK (4057) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI32_V_M1_MF4 (4058) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI32_V_M1_MF4_MASK (4059) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI32_V_M2_M1 (4060) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI32_V_M2_M1_MASK (4061) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI32_V_M2_MF2 (4062) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI32_V_M2_MF2_MASK (4063) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI32_V_M4_M1 (4064) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI32_V_M4_M1_MASK (4065) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI32_V_MF2_M1 (4066) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI32_V_MF2_M1_MASK (4067) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI32_V_MF2_MF2 (4068) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI32_V_MF2_MF2_MASK (4069) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI32_V_MF2_MF4 (4070) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI32_V_MF2_MF4_MASK (4071) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI32_V_MF2_MF8 (4072) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI32_V_MF2_MF8_MASK (4073) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI64_V_M1_M1 (4074) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI64_V_M1_M1_MASK (4075) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI64_V_M1_MF2 (4076) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI64_V_M1_MF2_MASK (4077) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI64_V_M1_MF4 (4078) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI64_V_M1_MF4_MASK (4079) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI64_V_M1_MF8 (4080) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI64_V_M1_MF8_MASK (4081) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI64_V_M2_M1 (4082) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI64_V_M2_M1_MASK (4083) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI64_V_M2_MF2 (4084) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI64_V_M2_MF2_MASK (4085) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI64_V_M2_MF4 (4086) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI64_V_M2_MF4_MASK (4087) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI64_V_M4_M1 (4088) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI64_V_M4_M1_MASK (4089) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI64_V_M4_MF2 (4090) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI64_V_M4_MF2_MASK (4091) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI64_V_M8_M1 (4092) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI64_V_M8_M1_MASK (4093) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI8_V_M1_M1 (4094) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI8_V_M1_M1_MASK (4095) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI8_V_MF2_M1 (4096) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI8_V_MF2_M1_MASK (4097) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI8_V_MF2_MF2 (4098) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI8_V_MF2_MF2_MASK (4099) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI8_V_MF4_M1 (4100) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI8_V_MF4_M1_MASK (4101) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI8_V_MF4_MF2 (4102) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI8_V_MF4_MF2_MASK (4103) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI8_V_MF4_MF4 (4104) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI8_V_MF4_MF4_MASK (4105) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI8_V_MF8_M1 (4106) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI8_V_MF8_M1_MASK (4107) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI8_V_MF8_MF2 (4108) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI8_V_MF8_MF2_MASK (4109) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI8_V_MF8_MF4 (4110) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI8_V_MF8_MF4_MASK (4111) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI8_V_MF8_MF8 (4112) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG5EI8_V_MF8_MF8_MASK (4113) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI16_V_M1_M1 (4114) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI16_V_M1_M1_MASK (4115) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI16_V_M1_MF2 (4116) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI16_V_M1_MF2_MASK (4117) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI16_V_M2_M1 (4118) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI16_V_M2_M1_MASK (4119) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI16_V_MF2_M1 (4120) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI16_V_MF2_M1_MASK (4121) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI16_V_MF2_MF2 (4122) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI16_V_MF2_MF2_MASK (4123) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI16_V_MF2_MF4 (4124) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI16_V_MF2_MF4_MASK (4125) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI16_V_MF4_M1 (4126) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI16_V_MF4_M1_MASK (4127) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI16_V_MF4_MF2 (4128) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI16_V_MF4_MF2_MASK (4129) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI16_V_MF4_MF4 (4130) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI16_V_MF4_MF4_MASK (4131) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI16_V_MF4_MF8 (4132) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI16_V_MF4_MF8_MASK (4133) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI32_V_M1_M1 (4134) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI32_V_M1_M1_MASK (4135) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI32_V_M1_MF2 (4136) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI32_V_M1_MF2_MASK (4137) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI32_V_M1_MF4 (4138) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI32_V_M1_MF4_MASK (4139) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI32_V_M2_M1 (4140) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI32_V_M2_M1_MASK (4141) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI32_V_M2_MF2 (4142) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI32_V_M2_MF2_MASK (4143) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI32_V_M4_M1 (4144) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI32_V_M4_M1_MASK (4145) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI32_V_MF2_M1 (4146) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI32_V_MF2_M1_MASK (4147) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI32_V_MF2_MF2 (4148) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI32_V_MF2_MF2_MASK (4149) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI32_V_MF2_MF4 (4150) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI32_V_MF2_MF4_MASK (4151) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI32_V_MF2_MF8 (4152) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI32_V_MF2_MF8_MASK (4153) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI64_V_M1_M1 (4154) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI64_V_M1_M1_MASK (4155) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI64_V_M1_MF2 (4156) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI64_V_M1_MF2_MASK (4157) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI64_V_M1_MF4 (4158) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI64_V_M1_MF4_MASK (4159) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI64_V_M1_MF8 (4160) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI64_V_M1_MF8_MASK (4161) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI64_V_M2_M1 (4162) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI64_V_M2_M1_MASK (4163) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI64_V_M2_MF2 (4164) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI64_V_M2_MF2_MASK (4165) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI64_V_M2_MF4 (4166) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI64_V_M2_MF4_MASK (4167) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI64_V_M4_M1 (4168) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI64_V_M4_M1_MASK (4169) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI64_V_M4_MF2 (4170) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI64_V_M4_MF2_MASK (4171) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI64_V_M8_M1 (4172) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI64_V_M8_M1_MASK (4173) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI8_V_M1_M1 (4174) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI8_V_M1_M1_MASK (4175) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI8_V_MF2_M1 (4176) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI8_V_MF2_M1_MASK (4177) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI8_V_MF2_MF2 (4178) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI8_V_MF2_MF2_MASK (4179) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI8_V_MF4_M1 (4180) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI8_V_MF4_M1_MASK (4181) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI8_V_MF4_MF2 (4182) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI8_V_MF4_MF2_MASK (4183) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI8_V_MF4_MF4 (4184) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI8_V_MF4_MF4_MASK (4185) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI8_V_MF8_M1 (4186) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI8_V_MF8_M1_MASK (4187) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI8_V_MF8_MF2 (4188) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI8_V_MF8_MF2_MASK (4189) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI8_V_MF8_MF4 (4190) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI8_V_MF8_MF4_MASK (4191) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI8_V_MF8_MF8 (4192) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG6EI8_V_MF8_MF8_MASK (4193) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI16_V_M1_M1 (4194) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI16_V_M1_M1_MASK (4195) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI16_V_M1_MF2 (4196) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI16_V_M1_MF2_MASK (4197) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI16_V_M2_M1 (4198) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI16_V_M2_M1_MASK (4199) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI16_V_MF2_M1 (4200) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI16_V_MF2_M1_MASK (4201) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI16_V_MF2_MF2 (4202) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI16_V_MF2_MF2_MASK (4203) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI16_V_MF2_MF4 (4204) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI16_V_MF2_MF4_MASK (4205) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI16_V_MF4_M1 (4206) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI16_V_MF4_M1_MASK (4207) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI16_V_MF4_MF2 (4208) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI16_V_MF4_MF2_MASK (4209) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI16_V_MF4_MF4 (4210) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI16_V_MF4_MF4_MASK (4211) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI16_V_MF4_MF8 (4212) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI16_V_MF4_MF8_MASK (4213) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI32_V_M1_M1 (4214) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI32_V_M1_M1_MASK (4215) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI32_V_M1_MF2 (4216) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI32_V_M1_MF2_MASK (4217) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI32_V_M1_MF4 (4218) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI32_V_M1_MF4_MASK (4219) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI32_V_M2_M1 (4220) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI32_V_M2_M1_MASK (4221) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI32_V_M2_MF2 (4222) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI32_V_M2_MF2_MASK (4223) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI32_V_M4_M1 (4224) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI32_V_M4_M1_MASK (4225) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI32_V_MF2_M1 (4226) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI32_V_MF2_M1_MASK (4227) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI32_V_MF2_MF2 (4228) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI32_V_MF2_MF2_MASK (4229) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI32_V_MF2_MF4 (4230) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI32_V_MF2_MF4_MASK (4231) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI32_V_MF2_MF8 (4232) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI32_V_MF2_MF8_MASK (4233) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI64_V_M1_M1 (4234) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI64_V_M1_M1_MASK (4235) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI64_V_M1_MF2 (4236) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI64_V_M1_MF2_MASK (4237) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI64_V_M1_MF4 (4238) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI64_V_M1_MF4_MASK (4239) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI64_V_M1_MF8 (4240) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI64_V_M1_MF8_MASK (4241) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI64_V_M2_M1 (4242) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI64_V_M2_M1_MASK (4243) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI64_V_M2_MF2 (4244) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI64_V_M2_MF2_MASK (4245) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI64_V_M2_MF4 (4246) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI64_V_M2_MF4_MASK (4247) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI64_V_M4_M1 (4248) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI64_V_M4_M1_MASK (4249) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI64_V_M4_MF2 (4250) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI64_V_M4_MF2_MASK (4251) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI64_V_M8_M1 (4252) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI64_V_M8_M1_MASK (4253) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI8_V_M1_M1 (4254) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI8_V_M1_M1_MASK (4255) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI8_V_MF2_M1 (4256) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI8_V_MF2_M1_MASK (4257) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI8_V_MF2_MF2 (4258) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI8_V_MF2_MF2_MASK (4259) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI8_V_MF4_M1 (4260) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI8_V_MF4_M1_MASK (4261) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI8_V_MF4_MF2 (4262) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI8_V_MF4_MF2_MASK (4263) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI8_V_MF4_MF4 (4264) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI8_V_MF4_MF4_MASK (4265) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI8_V_MF8_M1 (4266) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI8_V_MF8_M1_MASK (4267) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI8_V_MF8_MF2 (4268) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI8_V_MF8_MF2_MASK (4269) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI8_V_MF8_MF4 (4270) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI8_V_MF8_MF4_MASK (4271) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI8_V_MF8_MF8 (4272) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG7EI8_V_MF8_MF8_MASK (4273) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI16_V_M1_M1 (4274) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI16_V_M1_M1_MASK (4275) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI16_V_M1_MF2 (4276) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI16_V_M1_MF2_MASK (4277) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI16_V_M2_M1 (4278) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI16_V_M2_M1_MASK (4279) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI16_V_MF2_M1 (4280) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI16_V_MF2_M1_MASK (4281) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI16_V_MF2_MF2 (4282) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI16_V_MF2_MF2_MASK (4283) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI16_V_MF2_MF4 (4284) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI16_V_MF2_MF4_MASK (4285) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI16_V_MF4_M1 (4286) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI16_V_MF4_M1_MASK (4287) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI16_V_MF4_MF2 (4288) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI16_V_MF4_MF2_MASK (4289) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI16_V_MF4_MF4 (4290) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI16_V_MF4_MF4_MASK (4291) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI16_V_MF4_MF8 (4292) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI16_V_MF4_MF8_MASK (4293) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI32_V_M1_M1 (4294) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI32_V_M1_M1_MASK (4295) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI32_V_M1_MF2 (4296) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI32_V_M1_MF2_MASK (4297) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI32_V_M1_MF4 (4298) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI32_V_M1_MF4_MASK (4299) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI32_V_M2_M1 (4300) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI32_V_M2_M1_MASK (4301) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI32_V_M2_MF2 (4302) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI32_V_M2_MF2_MASK (4303) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI32_V_M4_M1 (4304) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI32_V_M4_M1_MASK (4305) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI32_V_MF2_M1 (4306) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI32_V_MF2_M1_MASK (4307) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI32_V_MF2_MF2 (4308) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI32_V_MF2_MF2_MASK (4309) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI32_V_MF2_MF4 (4310) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI32_V_MF2_MF4_MASK (4311) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI32_V_MF2_MF8 (4312) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI32_V_MF2_MF8_MASK (4313) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI64_V_M1_M1 (4314) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI64_V_M1_M1_MASK (4315) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI64_V_M1_MF2 (4316) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI64_V_M1_MF2_MASK (4317) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI64_V_M1_MF4 (4318) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI64_V_M1_MF4_MASK (4319) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI64_V_M1_MF8 (4320) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI64_V_M1_MF8_MASK (4321) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI64_V_M2_M1 (4322) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI64_V_M2_M1_MASK (4323) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI64_V_M2_MF2 (4324) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI64_V_M2_MF2_MASK (4325) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI64_V_M2_MF4 (4326) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI64_V_M2_MF4_MASK (4327) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI64_V_M4_M1 (4328) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI64_V_M4_M1_MASK (4329) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI64_V_M4_MF2 (4330) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI64_V_M4_MF2_MASK (4331) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI64_V_M8_M1 (4332) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI64_V_M8_M1_MASK (4333) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI8_V_M1_M1 (4334) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI8_V_M1_M1_MASK (4335) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI8_V_MF2_M1 (4336) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI8_V_MF2_M1_MASK (4337) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI8_V_MF2_MF2 (4338) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI8_V_MF2_MF2_MASK (4339) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI8_V_MF4_M1 (4340) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI8_V_MF4_M1_MASK (4341) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI8_V_MF4_MF2 (4342) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI8_V_MF4_MF2_MASK (4343) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI8_V_MF4_MF4 (4344) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI8_V_MF4_MF4_MASK (4345) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI8_V_MF8_M1 (4346) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI8_V_MF8_M1_MASK (4347) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI8_V_MF8_MF2 (4348) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI8_V_MF8_MF2_MASK (4349) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI8_V_MF8_MF4 (4350) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI8_V_MF8_MF4_MASK (4351) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI8_V_MF8_MF8 (4352) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLOXSEG8EI8_V_MF8_MF8_MASK (4353) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSE16_V_M1 (4354) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSE16_V_M1_MASK (4355) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSE16_V_M2 (4356) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSE16_V_M2_MASK (4357) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSE16_V_M4 (4358) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSE16_V_M4_MASK (4359) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSE16_V_M8 (4360) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSE16_V_M8_MASK (4361) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSE16_V_MF2 (4362) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSE16_V_MF2_MASK (4363) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSE16_V_MF4 (4364) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSE16_V_MF4_MASK (4365) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSE32_V_M1 (4366) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSE32_V_M1_MASK (4367) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSE32_V_M2 (4368) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSE32_V_M2_MASK (4369) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSE32_V_M4 (4370) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSE32_V_M4_MASK (4371) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSE32_V_M8 (4372) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSE32_V_M8_MASK (4373) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSE32_V_MF2 (4374) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSE32_V_MF2_MASK (4375) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSE64_V_M1 (4376) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSE64_V_M1_MASK (4377) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSE64_V_M2 (4378) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSE64_V_M2_MASK (4379) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSE64_V_M4 (4380) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSE64_V_M4_MASK (4381) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSE64_V_M8 (4382) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSE64_V_M8_MASK (4383) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSE8_V_M1 (4384) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSE8_V_M1_MASK (4385) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSE8_V_M2 (4386) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSE8_V_M2_MASK (4387) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSE8_V_M4 (4388) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSE8_V_M4_MASK (4389) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSE8_V_M8 (4390) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSE8_V_M8_MASK (4391) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSE8_V_MF2 (4392) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSE8_V_MF2_MASK (4393) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSE8_V_MF4 (4394) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSE8_V_MF4_MASK (4395) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSE8_V_MF8 (4396) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSE8_V_MF8_MASK (4397) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E16FF_V_M1 (4398) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E16FF_V_M1_MASK (4399) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E16FF_V_M2 (4400) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E16FF_V_M2_MASK (4401) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E16FF_V_M4 (4402) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E16FF_V_M4_MASK (4403) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E16FF_V_MF2 (4404) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E16FF_V_MF2_MASK (4405) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E16FF_V_MF4 (4406) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E16FF_V_MF4_MASK (4407) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E16_V_M1 (4408) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E16_V_M1_MASK (4409) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E16_V_M2 (4410) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E16_V_M2_MASK (4411) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E16_V_M4 (4412) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E16_V_M4_MASK (4413) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E16_V_MF2 (4414) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E16_V_MF2_MASK (4415) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E16_V_MF4 (4416) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E16_V_MF4_MASK (4417) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E32FF_V_M1 (4418) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E32FF_V_M1_MASK (4419) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E32FF_V_M2 (4420) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E32FF_V_M2_MASK (4421) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E32FF_V_M4 (4422) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E32FF_V_M4_MASK (4423) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E32FF_V_MF2 (4424) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E32FF_V_MF2_MASK (4425) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E32_V_M1 (4426) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E32_V_M1_MASK (4427) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E32_V_M2 (4428) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E32_V_M2_MASK (4429) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E32_V_M4 (4430) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E32_V_M4_MASK (4431) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E32_V_MF2 (4432) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E32_V_MF2_MASK (4433) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E64FF_V_M1 (4434) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E64FF_V_M1_MASK (4435) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E64FF_V_M2 (4436) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E64FF_V_M2_MASK (4437) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E64FF_V_M4 (4438) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E64FF_V_M4_MASK (4439) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E64_V_M1 (4440) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E64_V_M1_MASK (4441) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E64_V_M2 (4442) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E64_V_M2_MASK (4443) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E64_V_M4 (4444) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E64_V_M4_MASK (4445) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E8FF_V_M1 (4446) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E8FF_V_M1_MASK (4447) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E8FF_V_M2 (4448) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E8FF_V_M2_MASK (4449) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E8FF_V_M4 (4450) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E8FF_V_M4_MASK (4451) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E8FF_V_MF2 (4452) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E8FF_V_MF2_MASK (4453) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E8FF_V_MF4 (4454) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E8FF_V_MF4_MASK (4455) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E8FF_V_MF8 (4456) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E8FF_V_MF8_MASK (4457) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E8_V_M1 (4458) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E8_V_M1_MASK (4459) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E8_V_M2 (4460) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E8_V_M2_MASK (4461) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E8_V_M4 (4462) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E8_V_M4_MASK (4463) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E8_V_MF2 (4464) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E8_V_MF2_MASK (4465) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E8_V_MF4 (4466) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E8_V_MF4_MASK (4467) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E8_V_MF8 (4468) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG2E8_V_MF8_MASK (4469) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG3E16FF_V_M1 (4470) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG3E16FF_V_M1_MASK (4471) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG3E16FF_V_M2 (4472) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG3E16FF_V_M2_MASK (4473) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG3E16FF_V_MF2 (4474) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG3E16FF_V_MF2_MASK (4475) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG3E16FF_V_MF4 (4476) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG3E16FF_V_MF4_MASK (4477) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG3E16_V_M1 (4478) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG3E16_V_M1_MASK (4479) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG3E16_V_M2 (4480) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG3E16_V_M2_MASK (4481) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG3E16_V_MF2 (4482) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG3E16_V_MF2_MASK (4483) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG3E16_V_MF4 (4484) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG3E16_V_MF4_MASK (4485) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG3E32FF_V_M1 (4486) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG3E32FF_V_M1_MASK (4487) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG3E32FF_V_M2 (4488) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG3E32FF_V_M2_MASK (4489) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG3E32FF_V_MF2 (4490) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG3E32FF_V_MF2_MASK (4491) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG3E32_V_M1 (4492) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG3E32_V_M1_MASK (4493) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG3E32_V_M2 (4494) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG3E32_V_M2_MASK (4495) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG3E32_V_MF2 (4496) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG3E32_V_MF2_MASK (4497) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG3E64FF_V_M1 (4498) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG3E64FF_V_M1_MASK (4499) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG3E64FF_V_M2 (4500) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG3E64FF_V_M2_MASK (4501) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG3E64_V_M1 (4502) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG3E64_V_M1_MASK (4503) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG3E64_V_M2 (4504) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG3E64_V_M2_MASK (4505) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG3E8FF_V_M1 (4506) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG3E8FF_V_M1_MASK (4507) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG3E8FF_V_M2 (4508) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG3E8FF_V_M2_MASK (4509) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG3E8FF_V_MF2 (4510) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG3E8FF_V_MF2_MASK (4511) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG3E8FF_V_MF4 (4512) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG3E8FF_V_MF4_MASK (4513) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG3E8FF_V_MF8 (4514) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG3E8FF_V_MF8_MASK (4515) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG3E8_V_M1 (4516) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG3E8_V_M1_MASK (4517) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG3E8_V_M2 (4518) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG3E8_V_M2_MASK (4519) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG3E8_V_MF2 (4520) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG3E8_V_MF2_MASK (4521) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG3E8_V_MF4 (4522) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG3E8_V_MF4_MASK (4523) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG3E8_V_MF8 (4524) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG3E8_V_MF8_MASK (4525) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG4E16FF_V_M1 (4526) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG4E16FF_V_M1_MASK (4527) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG4E16FF_V_M2 (4528) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG4E16FF_V_M2_MASK (4529) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG4E16FF_V_MF2 (4530) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG4E16FF_V_MF2_MASK (4531) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG4E16FF_V_MF4 (4532) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG4E16FF_V_MF4_MASK (4533) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG4E16_V_M1 (4534) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG4E16_V_M1_MASK (4535) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG4E16_V_M2 (4536) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG4E16_V_M2_MASK (4537) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG4E16_V_MF2 (4538) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG4E16_V_MF2_MASK (4539) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG4E16_V_MF4 (4540) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG4E16_V_MF4_MASK (4541) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG4E32FF_V_M1 (4542) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG4E32FF_V_M1_MASK (4543) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG4E32FF_V_M2 (4544) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG4E32FF_V_M2_MASK (4545) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG4E32FF_V_MF2 (4546) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG4E32FF_V_MF2_MASK (4547) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG4E32_V_M1 (4548) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG4E32_V_M1_MASK (4549) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG4E32_V_M2 (4550) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG4E32_V_M2_MASK (4551) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG4E32_V_MF2 (4552) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG4E32_V_MF2_MASK (4553) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG4E64FF_V_M1 (4554) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG4E64FF_V_M1_MASK (4555) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG4E64FF_V_M2 (4556) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG4E64FF_V_M2_MASK (4557) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG4E64_V_M1 (4558) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG4E64_V_M1_MASK (4559) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG4E64_V_M2 (4560) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG4E64_V_M2_MASK (4561) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG4E8FF_V_M1 (4562) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG4E8FF_V_M1_MASK (4563) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG4E8FF_V_M2 (4564) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG4E8FF_V_M2_MASK (4565) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG4E8FF_V_MF2 (4566) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG4E8FF_V_MF2_MASK (4567) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG4E8FF_V_MF4 (4568) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG4E8FF_V_MF4_MASK (4569) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG4E8FF_V_MF8 (4570) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG4E8FF_V_MF8_MASK (4571) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG4E8_V_M1 (4572) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG4E8_V_M1_MASK (4573) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG4E8_V_M2 (4574) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG4E8_V_M2_MASK (4575) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG4E8_V_MF2 (4576) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG4E8_V_MF2_MASK (4577) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG4E8_V_MF4 (4578) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG4E8_V_MF4_MASK (4579) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG4E8_V_MF8 (4580) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG4E8_V_MF8_MASK (4581) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG5E16FF_V_M1 (4582) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG5E16FF_V_M1_MASK (4583) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG5E16FF_V_MF2 (4584) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG5E16FF_V_MF2_MASK (4585) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG5E16FF_V_MF4 (4586) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG5E16FF_V_MF4_MASK (4587) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG5E16_V_M1 (4588) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG5E16_V_M1_MASK (4589) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG5E16_V_MF2 (4590) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG5E16_V_MF2_MASK (4591) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG5E16_V_MF4 (4592) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG5E16_V_MF4_MASK (4593) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG5E32FF_V_M1 (4594) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG5E32FF_V_M1_MASK (4595) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG5E32FF_V_MF2 (4596) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG5E32FF_V_MF2_MASK (4597) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG5E32_V_M1 (4598) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG5E32_V_M1_MASK (4599) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG5E32_V_MF2 (4600) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG5E32_V_MF2_MASK (4601) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG5E64FF_V_M1 (4602) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG5E64FF_V_M1_MASK (4603) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG5E64_V_M1 (4604) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG5E64_V_M1_MASK (4605) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG5E8FF_V_M1 (4606) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG5E8FF_V_M1_MASK (4607) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG5E8FF_V_MF2 (4608) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG5E8FF_V_MF2_MASK (4609) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG5E8FF_V_MF4 (4610) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG5E8FF_V_MF4_MASK (4611) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG5E8FF_V_MF8 (4612) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG5E8FF_V_MF8_MASK (4613) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG5E8_V_M1 (4614) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG5E8_V_M1_MASK (4615) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG5E8_V_MF2 (4616) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG5E8_V_MF2_MASK (4617) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG5E8_V_MF4 (4618) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG5E8_V_MF4_MASK (4619) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG5E8_V_MF8 (4620) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG5E8_V_MF8_MASK (4621) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG6E16FF_V_M1 (4622) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG6E16FF_V_M1_MASK (4623) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG6E16FF_V_MF2 (4624) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG6E16FF_V_MF2_MASK (4625) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG6E16FF_V_MF4 (4626) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG6E16FF_V_MF4_MASK (4627) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG6E16_V_M1 (4628) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG6E16_V_M1_MASK (4629) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG6E16_V_MF2 (4630) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG6E16_V_MF2_MASK (4631) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG6E16_V_MF4 (4632) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG6E16_V_MF4_MASK (4633) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG6E32FF_V_M1 (4634) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG6E32FF_V_M1_MASK (4635) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG6E32FF_V_MF2 (4636) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG6E32FF_V_MF2_MASK (4637) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG6E32_V_M1 (4638) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG6E32_V_M1_MASK (4639) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG6E32_V_MF2 (4640) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG6E32_V_MF2_MASK (4641) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG6E64FF_V_M1 (4642) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG6E64FF_V_M1_MASK (4643) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG6E64_V_M1 (4644) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG6E64_V_M1_MASK (4645) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG6E8FF_V_M1 (4646) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG6E8FF_V_M1_MASK (4647) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG6E8FF_V_MF2 (4648) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG6E8FF_V_MF2_MASK (4649) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG6E8FF_V_MF4 (4650) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG6E8FF_V_MF4_MASK (4651) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG6E8FF_V_MF8 (4652) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG6E8FF_V_MF8_MASK (4653) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG6E8_V_M1 (4654) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG6E8_V_M1_MASK (4655) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG6E8_V_MF2 (4656) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG6E8_V_MF2_MASK (4657) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG6E8_V_MF4 (4658) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG6E8_V_MF4_MASK (4659) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG6E8_V_MF8 (4660) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG6E8_V_MF8_MASK (4661) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG7E16FF_V_M1 (4662) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG7E16FF_V_M1_MASK (4663) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG7E16FF_V_MF2 (4664) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG7E16FF_V_MF2_MASK (4665) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG7E16FF_V_MF4 (4666) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG7E16FF_V_MF4_MASK (4667) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG7E16_V_M1 (4668) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG7E16_V_M1_MASK (4669) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG7E16_V_MF2 (4670) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG7E16_V_MF2_MASK (4671) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG7E16_V_MF4 (4672) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG7E16_V_MF4_MASK (4673) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG7E32FF_V_M1 (4674) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG7E32FF_V_M1_MASK (4675) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG7E32FF_V_MF2 (4676) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG7E32FF_V_MF2_MASK (4677) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG7E32_V_M1 (4678) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG7E32_V_M1_MASK (4679) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG7E32_V_MF2 (4680) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG7E32_V_MF2_MASK (4681) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG7E64FF_V_M1 (4682) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG7E64FF_V_M1_MASK (4683) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG7E64_V_M1 (4684) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG7E64_V_M1_MASK (4685) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG7E8FF_V_M1 (4686) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG7E8FF_V_M1_MASK (4687) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG7E8FF_V_MF2 (4688) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG7E8FF_V_MF2_MASK (4689) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG7E8FF_V_MF4 (4690) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG7E8FF_V_MF4_MASK (4691) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG7E8FF_V_MF8 (4692) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG7E8FF_V_MF8_MASK (4693) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG7E8_V_M1 (4694) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG7E8_V_M1_MASK (4695) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG7E8_V_MF2 (4696) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG7E8_V_MF2_MASK (4697) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG7E8_V_MF4 (4698) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG7E8_V_MF4_MASK (4699) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG7E8_V_MF8 (4700) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG7E8_V_MF8_MASK (4701) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG8E16FF_V_M1 (4702) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG8E16FF_V_M1_MASK (4703) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG8E16FF_V_MF2 (4704) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG8E16FF_V_MF2_MASK (4705) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG8E16FF_V_MF4 (4706) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG8E16FF_V_MF4_MASK (4707) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG8E16_V_M1 (4708) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG8E16_V_M1_MASK (4709) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG8E16_V_MF2 (4710) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG8E16_V_MF2_MASK (4711) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG8E16_V_MF4 (4712) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG8E16_V_MF4_MASK (4713) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG8E32FF_V_M1 (4714) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG8E32FF_V_M1_MASK (4715) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG8E32FF_V_MF2 (4716) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG8E32FF_V_MF2_MASK (4717) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG8E32_V_M1 (4718) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG8E32_V_M1_MASK (4719) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG8E32_V_MF2 (4720) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG8E32_V_MF2_MASK (4721) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG8E64FF_V_M1 (4722) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG8E64FF_V_M1_MASK (4723) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG8E64_V_M1 (4724) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG8E64_V_M1_MASK (4725) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG8E8FF_V_M1 (4726) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG8E8FF_V_M1_MASK (4727) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG8E8FF_V_MF2 (4728) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG8E8FF_V_MF2_MASK (4729) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG8E8FF_V_MF4 (4730) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG8E8FF_V_MF4_MASK (4731) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG8E8FF_V_MF8 (4732) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG8E8FF_V_MF8_MASK (4733) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG8E8_V_M1 (4734) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG8E8_V_M1_MASK (4735) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG8E8_V_MF2 (4736) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG8E8_V_MF2_MASK (4737) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG8E8_V_MF4 (4738) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG8E8_V_MF4_MASK (4739) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG8E8_V_MF8 (4740) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSEG8E8_V_MF8_MASK (4741) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG2E16_V_M1 (4742) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG2E16_V_M1_MASK (4743) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG2E16_V_M2 (4744) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG2E16_V_M2_MASK (4745) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG2E16_V_M4 (4746) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG2E16_V_M4_MASK (4747) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG2E16_V_MF2 (4748) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG2E16_V_MF2_MASK (4749) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG2E16_V_MF4 (4750) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG2E16_V_MF4_MASK (4751) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG2E32_V_M1 (4752) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG2E32_V_M1_MASK (4753) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG2E32_V_M2 (4754) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG2E32_V_M2_MASK (4755) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG2E32_V_M4 (4756) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG2E32_V_M4_MASK (4757) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG2E32_V_MF2 (4758) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG2E32_V_MF2_MASK (4759) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG2E64_V_M1 (4760) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG2E64_V_M1_MASK (4761) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG2E64_V_M2 (4762) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG2E64_V_M2_MASK (4763) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG2E64_V_M4 (4764) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG2E64_V_M4_MASK (4765) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG2E8_V_M1 (4766) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG2E8_V_M1_MASK (4767) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG2E8_V_M2 (4768) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG2E8_V_M2_MASK (4769) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG2E8_V_M4 (4770) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG2E8_V_M4_MASK (4771) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG2E8_V_MF2 (4772) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG2E8_V_MF2_MASK (4773) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG2E8_V_MF4 (4774) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG2E8_V_MF4_MASK (4775) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG2E8_V_MF8 (4776) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG2E8_V_MF8_MASK (4777) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG3E16_V_M1 (4778) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG3E16_V_M1_MASK (4779) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG3E16_V_M2 (4780) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG3E16_V_M2_MASK (4781) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG3E16_V_MF2 (4782) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG3E16_V_MF2_MASK (4783) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG3E16_V_MF4 (4784) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG3E16_V_MF4_MASK (4785) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG3E32_V_M1 (4786) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG3E32_V_M1_MASK (4787) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG3E32_V_M2 (4788) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG3E32_V_M2_MASK (4789) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG3E32_V_MF2 (4790) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG3E32_V_MF2_MASK (4791) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG3E64_V_M1 (4792) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG3E64_V_M1_MASK (4793) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG3E64_V_M2 (4794) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG3E64_V_M2_MASK (4795) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG3E8_V_M1 (4796) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG3E8_V_M1_MASK (4797) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG3E8_V_M2 (4798) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG3E8_V_M2_MASK (4799) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG3E8_V_MF2 (4800) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG3E8_V_MF2_MASK (4801) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG3E8_V_MF4 (4802) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG3E8_V_MF4_MASK (4803) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG3E8_V_MF8 (4804) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG3E8_V_MF8_MASK (4805) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG4E16_V_M1 (4806) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG4E16_V_M1_MASK (4807) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG4E16_V_M2 (4808) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG4E16_V_M2_MASK (4809) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG4E16_V_MF2 (4810) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG4E16_V_MF2_MASK (4811) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG4E16_V_MF4 (4812) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG4E16_V_MF4_MASK (4813) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG4E32_V_M1 (4814) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG4E32_V_M1_MASK (4815) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG4E32_V_M2 (4816) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG4E32_V_M2_MASK (4817) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG4E32_V_MF2 (4818) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG4E32_V_MF2_MASK (4819) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG4E64_V_M1 (4820) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG4E64_V_M1_MASK (4821) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG4E64_V_M2 (4822) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG4E64_V_M2_MASK (4823) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG4E8_V_M1 (4824) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG4E8_V_M1_MASK (4825) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG4E8_V_M2 (4826) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG4E8_V_M2_MASK (4827) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG4E8_V_MF2 (4828) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG4E8_V_MF2_MASK (4829) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG4E8_V_MF4 (4830) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG4E8_V_MF4_MASK (4831) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG4E8_V_MF8 (4832) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG4E8_V_MF8_MASK (4833) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG5E16_V_M1 (4834) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG5E16_V_M1_MASK (4835) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG5E16_V_MF2 (4836) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG5E16_V_MF2_MASK (4837) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG5E16_V_MF4 (4838) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG5E16_V_MF4_MASK (4839) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG5E32_V_M1 (4840) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG5E32_V_M1_MASK (4841) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG5E32_V_MF2 (4842) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG5E32_V_MF2_MASK (4843) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG5E64_V_M1 (4844) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG5E64_V_M1_MASK (4845) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG5E8_V_M1 (4846) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG5E8_V_M1_MASK (4847) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG5E8_V_MF2 (4848) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG5E8_V_MF2_MASK (4849) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG5E8_V_MF4 (4850) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG5E8_V_MF4_MASK (4851) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG5E8_V_MF8 (4852) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG5E8_V_MF8_MASK (4853) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG6E16_V_M1 (4854) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG6E16_V_M1_MASK (4855) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG6E16_V_MF2 (4856) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG6E16_V_MF2_MASK (4857) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG6E16_V_MF4 (4858) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG6E16_V_MF4_MASK (4859) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG6E32_V_M1 (4860) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG6E32_V_M1_MASK (4861) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG6E32_V_MF2 (4862) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG6E32_V_MF2_MASK (4863) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG6E64_V_M1 (4864) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG6E64_V_M1_MASK (4865) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG6E8_V_M1 (4866) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG6E8_V_M1_MASK (4867) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG6E8_V_MF2 (4868) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG6E8_V_MF2_MASK (4869) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG6E8_V_MF4 (4870) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG6E8_V_MF4_MASK (4871) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG6E8_V_MF8 (4872) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG6E8_V_MF8_MASK (4873) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG7E16_V_M1 (4874) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG7E16_V_M1_MASK (4875) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG7E16_V_MF2 (4876) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG7E16_V_MF2_MASK (4877) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG7E16_V_MF4 (4878) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG7E16_V_MF4_MASK (4879) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG7E32_V_M1 (4880) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG7E32_V_M1_MASK (4881) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG7E32_V_MF2 (4882) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG7E32_V_MF2_MASK (4883) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG7E64_V_M1 (4884) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG7E64_V_M1_MASK (4885) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG7E8_V_M1 (4886) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG7E8_V_M1_MASK (4887) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG7E8_V_MF2 (4888) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG7E8_V_MF2_MASK (4889) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG7E8_V_MF4 (4890) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG7E8_V_MF4_MASK (4891) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG7E8_V_MF8 (4892) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG7E8_V_MF8_MASK (4893) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG8E16_V_M1 (4894) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG8E16_V_M1_MASK (4895) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG8E16_V_MF2 (4896) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG8E16_V_MF2_MASK (4897) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG8E16_V_MF4 (4898) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG8E16_V_MF4_MASK (4899) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG8E32_V_M1 (4900) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG8E32_V_M1_MASK (4901) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG8E32_V_MF2 (4902) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG8E32_V_MF2_MASK (4903) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG8E64_V_M1 (4904) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG8E64_V_M1_MASK (4905) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG8E8_V_M1 (4906) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG8E8_V_M1_MASK (4907) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG8E8_V_MF2 (4908) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG8E8_V_MF2_MASK (4909) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG8E8_V_MF4 (4910) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG8E8_V_MF4_MASK (4911) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG8E8_V_MF8 (4912) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLSSEG8E8_V_MF8_MASK (4913) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI16_V_M1_M1 (4914) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI16_V_M1_M1_MASK (4915) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI16_V_M1_M2 (4916) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI16_V_M1_M2_MASK (4917) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI16_V_M1_M4 (4918) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI16_V_M1_M4_MASK (4919) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI16_V_M1_MF2 (4920) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI16_V_M1_MF2_MASK (4921) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI16_V_M2_M1 (4922) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI16_V_M2_M1_MASK (4923) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI16_V_M2_M2 (4924) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI16_V_M2_M2_MASK (4925) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI16_V_M2_M4 (4926) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI16_V_M2_M4_MASK (4927) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI16_V_M2_M8 (4928) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI16_V_M2_M8_MASK (4929) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI16_V_M4_M2 (4930) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI16_V_M4_M2_MASK (4931) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI16_V_M4_M4 (4932) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI16_V_M4_M4_MASK (4933) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI16_V_M4_M8 (4934) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI16_V_M4_M8_MASK (4935) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI16_V_M8_M4 (4936) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI16_V_M8_M4_MASK (4937) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI16_V_M8_M8 (4938) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI16_V_M8_M8_MASK (4939) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI16_V_MF2_M1 (4940) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI16_V_MF2_M1_MASK (4941) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI16_V_MF2_M2 (4942) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI16_V_MF2_M2_MASK (4943) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI16_V_MF2_MF2 (4944) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI16_V_MF2_MF2_MASK (4945) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI16_V_MF2_MF4 (4946) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI16_V_MF2_MF4_MASK (4947) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI16_V_MF4_M1 (4948) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI16_V_MF4_M1_MASK (4949) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI16_V_MF4_MF2 (4950) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI16_V_MF4_MF2_MASK (4951) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI16_V_MF4_MF4 (4952) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI16_V_MF4_MF4_MASK (4953) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI16_V_MF4_MF8 (4954) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI16_V_MF4_MF8_MASK (4955) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI32_V_M1_M1 (4956) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI32_V_M1_M1_MASK (4957) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI32_V_M1_M2 (4958) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI32_V_M1_M2_MASK (4959) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI32_V_M1_MF2 (4960) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI32_V_M1_MF2_MASK (4961) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI32_V_M1_MF4 (4962) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI32_V_M1_MF4_MASK (4963) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI32_V_M2_M1 (4964) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI32_V_M2_M1_MASK (4965) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI32_V_M2_M2 (4966) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI32_V_M2_M2_MASK (4967) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI32_V_M2_M4 (4968) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI32_V_M2_M4_MASK (4969) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI32_V_M2_MF2 (4970) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI32_V_M2_MF2_MASK (4971) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI32_V_M4_M1 (4972) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI32_V_M4_M1_MASK (4973) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI32_V_M4_M2 (4974) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI32_V_M4_M2_MASK (4975) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI32_V_M4_M4 (4976) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI32_V_M4_M4_MASK (4977) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI32_V_M4_M8 (4978) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI32_V_M4_M8_MASK (4979) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI32_V_M8_M2 (4980) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI32_V_M8_M2_MASK (4981) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI32_V_M8_M4 (4982) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI32_V_M8_M4_MASK (4983) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI32_V_M8_M8 (4984) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI32_V_M8_M8_MASK (4985) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI32_V_MF2_M1 (4986) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI32_V_MF2_M1_MASK (4987) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI32_V_MF2_MF2 (4988) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI32_V_MF2_MF2_MASK (4989) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI32_V_MF2_MF4 (4990) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI32_V_MF2_MF4_MASK (4991) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI32_V_MF2_MF8 (4992) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI32_V_MF2_MF8_MASK (4993) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI64_V_M1_M1 (4994) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI64_V_M1_M1_MASK (4995) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI64_V_M1_MF2 (4996) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI64_V_M1_MF2_MASK (4997) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI64_V_M1_MF4 (4998) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI64_V_M1_MF4_MASK (4999) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI64_V_M1_MF8 (5000) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI64_V_M1_MF8_MASK (5001) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI64_V_M2_M1 (5002) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI64_V_M2_M1_MASK (5003) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI64_V_M2_M2 (5004) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI64_V_M2_M2_MASK (5005) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI64_V_M2_MF2 (5006) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI64_V_M2_MF2_MASK (5007) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI64_V_M2_MF4 (5008) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI64_V_M2_MF4_MASK (5009) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI64_V_M4_M1 (5010) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI64_V_M4_M1_MASK (5011) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI64_V_M4_M2 (5012) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI64_V_M4_M2_MASK (5013) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI64_V_M4_M4 (5014) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI64_V_M4_M4_MASK (5015) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI64_V_M4_MF2 (5016) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI64_V_M4_MF2_MASK (5017) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI64_V_M8_M1 (5018) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI64_V_M8_M1_MASK (5019) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI64_V_M8_M2 (5020) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI64_V_M8_M2_MASK (5021) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI64_V_M8_M4 (5022) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI64_V_M8_M4_MASK (5023) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI64_V_M8_M8 (5024) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI64_V_M8_M8_MASK (5025) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI8_V_M1_M1 (5026) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI8_V_M1_M1_MASK (5027) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI8_V_M1_M2 (5028) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI8_V_M1_M2_MASK (5029) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI8_V_M1_M4 (5030) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI8_V_M1_M4_MASK (5031) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI8_V_M1_M8 (5032) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI8_V_M1_M8_MASK (5033) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI8_V_M2_M2 (5034) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI8_V_M2_M2_MASK (5035) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI8_V_M2_M4 (5036) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI8_V_M2_M4_MASK (5037) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI8_V_M2_M8 (5038) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI8_V_M2_M8_MASK (5039) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI8_V_M4_M4 (5040) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI8_V_M4_M4_MASK (5041) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI8_V_M4_M8 (5042) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI8_V_M4_M8_MASK (5043) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI8_V_M8_M8 (5044) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI8_V_M8_M8_MASK (5045) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI8_V_MF2_M1 (5046) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI8_V_MF2_M1_MASK (5047) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI8_V_MF2_M2 (5048) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI8_V_MF2_M2_MASK (5049) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI8_V_MF2_M4 (5050) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI8_V_MF2_M4_MASK (5051) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI8_V_MF2_MF2 (5052) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI8_V_MF2_MF2_MASK (5053) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI8_V_MF4_M1 (5054) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI8_V_MF4_M1_MASK (5055) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI8_V_MF4_M2 (5056) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI8_V_MF4_M2_MASK (5057) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI8_V_MF4_MF2 (5058) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI8_V_MF4_MF2_MASK (5059) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI8_V_MF4_MF4 (5060) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI8_V_MF4_MF4_MASK (5061) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI8_V_MF8_M1 (5062) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI8_V_MF8_M1_MASK (5063) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI8_V_MF8_MF2 (5064) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI8_V_MF8_MF2_MASK (5065) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI8_V_MF8_MF4 (5066) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI8_V_MF8_MF4_MASK (5067) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI8_V_MF8_MF8 (5068) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXEI8_V_MF8_MF8_MASK (5069) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI16_V_M1_M1 (5070) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI16_V_M1_M1_MASK (5071) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI16_V_M1_M2 (5072) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI16_V_M1_M2_MASK (5073) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI16_V_M1_M4 (5074) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI16_V_M1_M4_MASK (5075) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI16_V_M1_MF2 (5076) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI16_V_M1_MF2_MASK (5077) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI16_V_M2_M1 (5078) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI16_V_M2_M1_MASK (5079) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI16_V_M2_M2 (5080) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI16_V_M2_M2_MASK (5081) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI16_V_M2_M4 (5082) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI16_V_M2_M4_MASK (5083) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI16_V_M4_M2 (5084) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI16_V_M4_M2_MASK (5085) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI16_V_M4_M4 (5086) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI16_V_M4_M4_MASK (5087) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI16_V_M8_M4 (5088) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI16_V_M8_M4_MASK (5089) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI16_V_MF2_M1 (5090) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI16_V_MF2_M1_MASK (5091) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI16_V_MF2_M2 (5092) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI16_V_MF2_M2_MASK (5093) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI16_V_MF2_MF2 (5094) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI16_V_MF2_MF2_MASK (5095) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI16_V_MF2_MF4 (5096) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI16_V_MF2_MF4_MASK (5097) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI16_V_MF4_M1 (5098) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI16_V_MF4_M1_MASK (5099) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI16_V_MF4_MF2 (5100) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI16_V_MF4_MF2_MASK (5101) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI16_V_MF4_MF4 (5102) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI16_V_MF4_MF4_MASK (5103) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI16_V_MF4_MF8 (5104) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI16_V_MF4_MF8_MASK (5105) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI32_V_M1_M1 (5106) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI32_V_M1_M1_MASK (5107) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI32_V_M1_M2 (5108) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI32_V_M1_M2_MASK (5109) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI32_V_M1_MF2 (5110) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI32_V_M1_MF2_MASK (5111) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI32_V_M1_MF4 (5112) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI32_V_M1_MF4_MASK (5113) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI32_V_M2_M1 (5114) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI32_V_M2_M1_MASK (5115) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI32_V_M2_M2 (5116) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI32_V_M2_M2_MASK (5117) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI32_V_M2_M4 (5118) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI32_V_M2_M4_MASK (5119) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI32_V_M2_MF2 (5120) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI32_V_M2_MF2_MASK (5121) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI32_V_M4_M1 (5122) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI32_V_M4_M1_MASK (5123) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI32_V_M4_M2 (5124) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI32_V_M4_M2_MASK (5125) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI32_V_M4_M4 (5126) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI32_V_M4_M4_MASK (5127) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI32_V_M8_M2 (5128) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI32_V_M8_M2_MASK (5129) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI32_V_M8_M4 (5130) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI32_V_M8_M4_MASK (5131) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI32_V_MF2_M1 (5132) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI32_V_MF2_M1_MASK (5133) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI32_V_MF2_MF2 (5134) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI32_V_MF2_MF2_MASK (5135) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI32_V_MF2_MF4 (5136) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI32_V_MF2_MF4_MASK (5137) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI32_V_MF2_MF8 (5138) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI32_V_MF2_MF8_MASK (5139) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI64_V_M1_M1 (5140) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI64_V_M1_M1_MASK (5141) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI64_V_M1_MF2 (5142) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI64_V_M1_MF2_MASK (5143) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI64_V_M1_MF4 (5144) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI64_V_M1_MF4_MASK (5145) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI64_V_M1_MF8 (5146) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI64_V_M1_MF8_MASK (5147) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI64_V_M2_M1 (5148) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI64_V_M2_M1_MASK (5149) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI64_V_M2_M2 (5150) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI64_V_M2_M2_MASK (5151) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI64_V_M2_MF2 (5152) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI64_V_M2_MF2_MASK (5153) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI64_V_M2_MF4 (5154) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI64_V_M2_MF4_MASK (5155) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI64_V_M4_M1 (5156) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI64_V_M4_M1_MASK (5157) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI64_V_M4_M2 (5158) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI64_V_M4_M2_MASK (5159) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI64_V_M4_M4 (5160) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI64_V_M4_M4_MASK (5161) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI64_V_M4_MF2 (5162) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI64_V_M4_MF2_MASK (5163) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI64_V_M8_M1 (5164) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI64_V_M8_M1_MASK (5165) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI64_V_M8_M2 (5166) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI64_V_M8_M2_MASK (5167) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI64_V_M8_M4 (5168) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI64_V_M8_M4_MASK (5169) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI8_V_M1_M1 (5170) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI8_V_M1_M1_MASK (5171) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI8_V_M1_M2 (5172) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI8_V_M1_M2_MASK (5173) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI8_V_M1_M4 (5174) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI8_V_M1_M4_MASK (5175) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI8_V_M2_M2 (5176) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI8_V_M2_M2_MASK (5177) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI8_V_M2_M4 (5178) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI8_V_M2_M4_MASK (5179) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI8_V_M4_M4 (5180) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI8_V_M4_M4_MASK (5181) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI8_V_MF2_M1 (5182) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI8_V_MF2_M1_MASK (5183) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI8_V_MF2_M2 (5184) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI8_V_MF2_M2_MASK (5185) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI8_V_MF2_M4 (5186) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI8_V_MF2_M4_MASK (5187) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI8_V_MF2_MF2 (5188) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI8_V_MF2_MF2_MASK (5189) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI8_V_MF4_M1 (5190) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI8_V_MF4_M1_MASK (5191) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI8_V_MF4_M2 (5192) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI8_V_MF4_M2_MASK (5193) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI8_V_MF4_MF2 (5194) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI8_V_MF4_MF2_MASK (5195) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI8_V_MF4_MF4 (5196) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI8_V_MF4_MF4_MASK (5197) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI8_V_MF8_M1 (5198) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI8_V_MF8_M1_MASK (5199) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI8_V_MF8_MF2 (5200) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI8_V_MF8_MF2_MASK (5201) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI8_V_MF8_MF4 (5202) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI8_V_MF8_MF4_MASK (5203) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI8_V_MF8_MF8 (5204) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG2EI8_V_MF8_MF8_MASK (5205) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI16_V_M1_M1 (5206) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI16_V_M1_M1_MASK (5207) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI16_V_M1_M2 (5208) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI16_V_M1_M2_MASK (5209) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI16_V_M1_MF2 (5210) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI16_V_M1_MF2_MASK (5211) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI16_V_M2_M1 (5212) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI16_V_M2_M1_MASK (5213) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI16_V_M2_M2 (5214) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI16_V_M2_M2_MASK (5215) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI16_V_M4_M2 (5216) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI16_V_M4_M2_MASK (5217) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI16_V_MF2_M1 (5218) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI16_V_MF2_M1_MASK (5219) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI16_V_MF2_M2 (5220) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI16_V_MF2_M2_MASK (5221) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI16_V_MF2_MF2 (5222) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI16_V_MF2_MF2_MASK (5223) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI16_V_MF2_MF4 (5224) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI16_V_MF2_MF4_MASK (5225) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI16_V_MF4_M1 (5226) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI16_V_MF4_M1_MASK (5227) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI16_V_MF4_MF2 (5228) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI16_V_MF4_MF2_MASK (5229) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI16_V_MF4_MF4 (5230) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI16_V_MF4_MF4_MASK (5231) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI16_V_MF4_MF8 (5232) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI16_V_MF4_MF8_MASK (5233) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI32_V_M1_M1 (5234) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI32_V_M1_M1_MASK (5235) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI32_V_M1_M2 (5236) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI32_V_M1_M2_MASK (5237) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI32_V_M1_MF2 (5238) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI32_V_M1_MF2_MASK (5239) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI32_V_M1_MF4 (5240) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI32_V_M1_MF4_MASK (5241) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI32_V_M2_M1 (5242) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI32_V_M2_M1_MASK (5243) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI32_V_M2_M2 (5244) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI32_V_M2_M2_MASK (5245) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI32_V_M2_MF2 (5246) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI32_V_M2_MF2_MASK (5247) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI32_V_M4_M1 (5248) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI32_V_M4_M1_MASK (5249) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI32_V_M4_M2 (5250) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI32_V_M4_M2_MASK (5251) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI32_V_M8_M2 (5252) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI32_V_M8_M2_MASK (5253) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI32_V_MF2_M1 (5254) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI32_V_MF2_M1_MASK (5255) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI32_V_MF2_MF2 (5256) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI32_V_MF2_MF2_MASK (5257) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI32_V_MF2_MF4 (5258) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI32_V_MF2_MF4_MASK (5259) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI32_V_MF2_MF8 (5260) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI32_V_MF2_MF8_MASK (5261) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI64_V_M1_M1 (5262) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI64_V_M1_M1_MASK (5263) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI64_V_M1_MF2 (5264) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI64_V_M1_MF2_MASK (5265) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI64_V_M1_MF4 (5266) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI64_V_M1_MF4_MASK (5267) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI64_V_M1_MF8 (5268) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI64_V_M1_MF8_MASK (5269) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI64_V_M2_M1 (5270) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI64_V_M2_M1_MASK (5271) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI64_V_M2_M2 (5272) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI64_V_M2_M2_MASK (5273) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI64_V_M2_MF2 (5274) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI64_V_M2_MF2_MASK (5275) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI64_V_M2_MF4 (5276) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI64_V_M2_MF4_MASK (5277) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI64_V_M4_M1 (5278) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI64_V_M4_M1_MASK (5279) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI64_V_M4_M2 (5280) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI64_V_M4_M2_MASK (5281) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI64_V_M4_MF2 (5282) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI64_V_M4_MF2_MASK (5283) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI64_V_M8_M1 (5284) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI64_V_M8_M1_MASK (5285) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI64_V_M8_M2 (5286) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI64_V_M8_M2_MASK (5287) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI8_V_M1_M1 (5288) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI8_V_M1_M1_MASK (5289) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI8_V_M1_M2 (5290) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI8_V_M1_M2_MASK (5291) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI8_V_M2_M2 (5292) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI8_V_M2_M2_MASK (5293) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI8_V_MF2_M1 (5294) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI8_V_MF2_M1_MASK (5295) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI8_V_MF2_M2 (5296) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI8_V_MF2_M2_MASK (5297) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI8_V_MF2_MF2 (5298) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI8_V_MF2_MF2_MASK (5299) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI8_V_MF4_M1 (5300) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI8_V_MF4_M1_MASK (5301) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI8_V_MF4_M2 (5302) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI8_V_MF4_M2_MASK (5303) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI8_V_MF4_MF2 (5304) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI8_V_MF4_MF2_MASK (5305) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI8_V_MF4_MF4 (5306) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI8_V_MF4_MF4_MASK (5307) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI8_V_MF8_M1 (5308) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI8_V_MF8_M1_MASK (5309) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI8_V_MF8_MF2 (5310) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI8_V_MF8_MF2_MASK (5311) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI8_V_MF8_MF4 (5312) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI8_V_MF8_MF4_MASK (5313) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI8_V_MF8_MF8 (5314) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG3EI8_V_MF8_MF8_MASK (5315) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI16_V_M1_M1 (5316) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI16_V_M1_M1_MASK (5317) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI16_V_M1_M2 (5318) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI16_V_M1_M2_MASK (5319) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI16_V_M1_MF2 (5320) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI16_V_M1_MF2_MASK (5321) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI16_V_M2_M1 (5322) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI16_V_M2_M1_MASK (5323) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI16_V_M2_M2 (5324) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI16_V_M2_M2_MASK (5325) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI16_V_M4_M2 (5326) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI16_V_M4_M2_MASK (5327) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI16_V_MF2_M1 (5328) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI16_V_MF2_M1_MASK (5329) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI16_V_MF2_M2 (5330) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI16_V_MF2_M2_MASK (5331) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI16_V_MF2_MF2 (5332) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI16_V_MF2_MF2_MASK (5333) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI16_V_MF2_MF4 (5334) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI16_V_MF2_MF4_MASK (5335) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI16_V_MF4_M1 (5336) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI16_V_MF4_M1_MASK (5337) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI16_V_MF4_MF2 (5338) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI16_V_MF4_MF2_MASK (5339) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI16_V_MF4_MF4 (5340) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI16_V_MF4_MF4_MASK (5341) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI16_V_MF4_MF8 (5342) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI16_V_MF4_MF8_MASK (5343) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI32_V_M1_M1 (5344) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI32_V_M1_M1_MASK (5345) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI32_V_M1_M2 (5346) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI32_V_M1_M2_MASK (5347) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI32_V_M1_MF2 (5348) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI32_V_M1_MF2_MASK (5349) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI32_V_M1_MF4 (5350) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI32_V_M1_MF4_MASK (5351) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI32_V_M2_M1 (5352) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI32_V_M2_M1_MASK (5353) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI32_V_M2_M2 (5354) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI32_V_M2_M2_MASK (5355) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI32_V_M2_MF2 (5356) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI32_V_M2_MF2_MASK (5357) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI32_V_M4_M1 (5358) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI32_V_M4_M1_MASK (5359) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI32_V_M4_M2 (5360) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI32_V_M4_M2_MASK (5361) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI32_V_M8_M2 (5362) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI32_V_M8_M2_MASK (5363) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI32_V_MF2_M1 (5364) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI32_V_MF2_M1_MASK (5365) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI32_V_MF2_MF2 (5366) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI32_V_MF2_MF2_MASK (5367) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI32_V_MF2_MF4 (5368) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI32_V_MF2_MF4_MASK (5369) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI32_V_MF2_MF8 (5370) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI32_V_MF2_MF8_MASK (5371) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI64_V_M1_M1 (5372) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI64_V_M1_M1_MASK (5373) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI64_V_M1_MF2 (5374) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI64_V_M1_MF2_MASK (5375) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI64_V_M1_MF4 (5376) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI64_V_M1_MF4_MASK (5377) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI64_V_M1_MF8 (5378) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI64_V_M1_MF8_MASK (5379) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI64_V_M2_M1 (5380) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI64_V_M2_M1_MASK (5381) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI64_V_M2_M2 (5382) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI64_V_M2_M2_MASK (5383) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI64_V_M2_MF2 (5384) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI64_V_M2_MF2_MASK (5385) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI64_V_M2_MF4 (5386) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI64_V_M2_MF4_MASK (5387) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI64_V_M4_M1 (5388) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI64_V_M4_M1_MASK (5389) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI64_V_M4_M2 (5390) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI64_V_M4_M2_MASK (5391) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI64_V_M4_MF2 (5392) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI64_V_M4_MF2_MASK (5393) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI64_V_M8_M1 (5394) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI64_V_M8_M1_MASK (5395) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI64_V_M8_M2 (5396) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI64_V_M8_M2_MASK (5397) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI8_V_M1_M1 (5398) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI8_V_M1_M1_MASK (5399) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI8_V_M1_M2 (5400) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI8_V_M1_M2_MASK (5401) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI8_V_M2_M2 (5402) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI8_V_M2_M2_MASK (5403) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI8_V_MF2_M1 (5404) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI8_V_MF2_M1_MASK (5405) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI8_V_MF2_M2 (5406) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI8_V_MF2_M2_MASK (5407) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI8_V_MF2_MF2 (5408) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI8_V_MF2_MF2_MASK (5409) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI8_V_MF4_M1 (5410) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI8_V_MF4_M1_MASK (5411) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI8_V_MF4_M2 (5412) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI8_V_MF4_M2_MASK (5413) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI8_V_MF4_MF2 (5414) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI8_V_MF4_MF2_MASK (5415) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI8_V_MF4_MF4 (5416) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI8_V_MF4_MF4_MASK (5417) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI8_V_MF8_M1 (5418) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI8_V_MF8_M1_MASK (5419) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI8_V_MF8_MF2 (5420) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI8_V_MF8_MF2_MASK (5421) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI8_V_MF8_MF4 (5422) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI8_V_MF8_MF4_MASK (5423) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI8_V_MF8_MF8 (5424) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG4EI8_V_MF8_MF8_MASK (5425) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI16_V_M1_M1 (5426) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI16_V_M1_M1_MASK (5427) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI16_V_M1_MF2 (5428) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI16_V_M1_MF2_MASK (5429) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI16_V_M2_M1 (5430) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI16_V_M2_M1_MASK (5431) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI16_V_MF2_M1 (5432) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI16_V_MF2_M1_MASK (5433) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI16_V_MF2_MF2 (5434) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI16_V_MF2_MF2_MASK (5435) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI16_V_MF2_MF4 (5436) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI16_V_MF2_MF4_MASK (5437) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI16_V_MF4_M1 (5438) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI16_V_MF4_M1_MASK (5439) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI16_V_MF4_MF2 (5440) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI16_V_MF4_MF2_MASK (5441) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI16_V_MF4_MF4 (5442) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI16_V_MF4_MF4_MASK (5443) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI16_V_MF4_MF8 (5444) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI16_V_MF4_MF8_MASK (5445) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI32_V_M1_M1 (5446) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI32_V_M1_M1_MASK (5447) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI32_V_M1_MF2 (5448) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI32_V_M1_MF2_MASK (5449) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI32_V_M1_MF4 (5450) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI32_V_M1_MF4_MASK (5451) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI32_V_M2_M1 (5452) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI32_V_M2_M1_MASK (5453) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI32_V_M2_MF2 (5454) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI32_V_M2_MF2_MASK (5455) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI32_V_M4_M1 (5456) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI32_V_M4_M1_MASK (5457) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI32_V_MF2_M1 (5458) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI32_V_MF2_M1_MASK (5459) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI32_V_MF2_MF2 (5460) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI32_V_MF2_MF2_MASK (5461) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI32_V_MF2_MF4 (5462) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI32_V_MF2_MF4_MASK (5463) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI32_V_MF2_MF8 (5464) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI32_V_MF2_MF8_MASK (5465) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI64_V_M1_M1 (5466) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI64_V_M1_M1_MASK (5467) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI64_V_M1_MF2 (5468) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI64_V_M1_MF2_MASK (5469) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI64_V_M1_MF4 (5470) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI64_V_M1_MF4_MASK (5471) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI64_V_M1_MF8 (5472) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI64_V_M1_MF8_MASK (5473) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI64_V_M2_M1 (5474) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI64_V_M2_M1_MASK (5475) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI64_V_M2_MF2 (5476) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI64_V_M2_MF2_MASK (5477) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI64_V_M2_MF4 (5478) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI64_V_M2_MF4_MASK (5479) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI64_V_M4_M1 (5480) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI64_V_M4_M1_MASK (5481) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI64_V_M4_MF2 (5482) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI64_V_M4_MF2_MASK (5483) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI64_V_M8_M1 (5484) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI64_V_M8_M1_MASK (5485) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI8_V_M1_M1 (5486) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI8_V_M1_M1_MASK (5487) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI8_V_MF2_M1 (5488) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI8_V_MF2_M1_MASK (5489) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI8_V_MF2_MF2 (5490) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI8_V_MF2_MF2_MASK (5491) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI8_V_MF4_M1 (5492) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI8_V_MF4_M1_MASK (5493) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI8_V_MF4_MF2 (5494) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI8_V_MF4_MF2_MASK (5495) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI8_V_MF4_MF4 (5496) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI8_V_MF4_MF4_MASK (5497) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI8_V_MF8_M1 (5498) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI8_V_MF8_M1_MASK (5499) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI8_V_MF8_MF2 (5500) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI8_V_MF8_MF2_MASK (5501) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI8_V_MF8_MF4 (5502) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI8_V_MF8_MF4_MASK (5503) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI8_V_MF8_MF8 (5504) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG5EI8_V_MF8_MF8_MASK (5505) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI16_V_M1_M1 (5506) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI16_V_M1_M1_MASK (5507) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI16_V_M1_MF2 (5508) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI16_V_M1_MF2_MASK (5509) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI16_V_M2_M1 (5510) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI16_V_M2_M1_MASK (5511) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI16_V_MF2_M1 (5512) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI16_V_MF2_M1_MASK (5513) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI16_V_MF2_MF2 (5514) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI16_V_MF2_MF2_MASK (5515) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI16_V_MF2_MF4 (5516) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI16_V_MF2_MF4_MASK (5517) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI16_V_MF4_M1 (5518) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI16_V_MF4_M1_MASK (5519) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI16_V_MF4_MF2 (5520) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI16_V_MF4_MF2_MASK (5521) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI16_V_MF4_MF4 (5522) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI16_V_MF4_MF4_MASK (5523) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI16_V_MF4_MF8 (5524) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI16_V_MF4_MF8_MASK (5525) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI32_V_M1_M1 (5526) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI32_V_M1_M1_MASK (5527) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI32_V_M1_MF2 (5528) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI32_V_M1_MF2_MASK (5529) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI32_V_M1_MF4 (5530) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI32_V_M1_MF4_MASK (5531) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI32_V_M2_M1 (5532) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI32_V_M2_M1_MASK (5533) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI32_V_M2_MF2 (5534) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI32_V_M2_MF2_MASK (5535) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI32_V_M4_M1 (5536) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI32_V_M4_M1_MASK (5537) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI32_V_MF2_M1 (5538) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI32_V_MF2_M1_MASK (5539) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI32_V_MF2_MF2 (5540) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI32_V_MF2_MF2_MASK (5541) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI32_V_MF2_MF4 (5542) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI32_V_MF2_MF4_MASK (5543) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI32_V_MF2_MF8 (5544) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI32_V_MF2_MF8_MASK (5545) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI64_V_M1_M1 (5546) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI64_V_M1_M1_MASK (5547) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI64_V_M1_MF2 (5548) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI64_V_M1_MF2_MASK (5549) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI64_V_M1_MF4 (5550) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI64_V_M1_MF4_MASK (5551) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI64_V_M1_MF8 (5552) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI64_V_M1_MF8_MASK (5553) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI64_V_M2_M1 (5554) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI64_V_M2_M1_MASK (5555) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI64_V_M2_MF2 (5556) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI64_V_M2_MF2_MASK (5557) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI64_V_M2_MF4 (5558) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI64_V_M2_MF4_MASK (5559) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI64_V_M4_M1 (5560) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI64_V_M4_M1_MASK (5561) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI64_V_M4_MF2 (5562) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI64_V_M4_MF2_MASK (5563) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI64_V_M8_M1 (5564) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI64_V_M8_M1_MASK (5565) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI8_V_M1_M1 (5566) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI8_V_M1_M1_MASK (5567) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI8_V_MF2_M1 (5568) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI8_V_MF2_M1_MASK (5569) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI8_V_MF2_MF2 (5570) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI8_V_MF2_MF2_MASK (5571) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI8_V_MF4_M1 (5572) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI8_V_MF4_M1_MASK (5573) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI8_V_MF4_MF2 (5574) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI8_V_MF4_MF2_MASK (5575) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI8_V_MF4_MF4 (5576) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI8_V_MF4_MF4_MASK (5577) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI8_V_MF8_M1 (5578) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI8_V_MF8_M1_MASK (5579) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI8_V_MF8_MF2 (5580) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI8_V_MF8_MF2_MASK (5581) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI8_V_MF8_MF4 (5582) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI8_V_MF8_MF4_MASK (5583) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI8_V_MF8_MF8 (5584) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG6EI8_V_MF8_MF8_MASK (5585) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI16_V_M1_M1 (5586) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI16_V_M1_M1_MASK (5587) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI16_V_M1_MF2 (5588) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI16_V_M1_MF2_MASK (5589) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI16_V_M2_M1 (5590) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI16_V_M2_M1_MASK (5591) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI16_V_MF2_M1 (5592) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI16_V_MF2_M1_MASK (5593) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI16_V_MF2_MF2 (5594) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI16_V_MF2_MF2_MASK (5595) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI16_V_MF2_MF4 (5596) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI16_V_MF2_MF4_MASK (5597) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI16_V_MF4_M1 (5598) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI16_V_MF4_M1_MASK (5599) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI16_V_MF4_MF2 (5600) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI16_V_MF4_MF2_MASK (5601) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI16_V_MF4_MF4 (5602) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI16_V_MF4_MF4_MASK (5603) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI16_V_MF4_MF8 (5604) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI16_V_MF4_MF8_MASK (5605) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI32_V_M1_M1 (5606) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI32_V_M1_M1_MASK (5607) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI32_V_M1_MF2 (5608) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI32_V_M1_MF2_MASK (5609) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI32_V_M1_MF4 (5610) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI32_V_M1_MF4_MASK (5611) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI32_V_M2_M1 (5612) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI32_V_M2_M1_MASK (5613) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI32_V_M2_MF2 (5614) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI32_V_M2_MF2_MASK (5615) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI32_V_M4_M1 (5616) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI32_V_M4_M1_MASK (5617) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI32_V_MF2_M1 (5618) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI32_V_MF2_M1_MASK (5619) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI32_V_MF2_MF2 (5620) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI32_V_MF2_MF2_MASK (5621) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI32_V_MF2_MF4 (5622) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI32_V_MF2_MF4_MASK (5623) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI32_V_MF2_MF8 (5624) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI32_V_MF2_MF8_MASK (5625) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI64_V_M1_M1 (5626) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI64_V_M1_M1_MASK (5627) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI64_V_M1_MF2 (5628) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI64_V_M1_MF2_MASK (5629) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI64_V_M1_MF4 (5630) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI64_V_M1_MF4_MASK (5631) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI64_V_M1_MF8 (5632) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI64_V_M1_MF8_MASK (5633) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI64_V_M2_M1 (5634) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI64_V_M2_M1_MASK (5635) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI64_V_M2_MF2 (5636) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI64_V_M2_MF2_MASK (5637) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI64_V_M2_MF4 (5638) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI64_V_M2_MF4_MASK (5639) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI64_V_M4_M1 (5640) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI64_V_M4_M1_MASK (5641) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI64_V_M4_MF2 (5642) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI64_V_M4_MF2_MASK (5643) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI64_V_M8_M1 (5644) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI64_V_M8_M1_MASK (5645) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI8_V_M1_M1 (5646) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI8_V_M1_M1_MASK (5647) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI8_V_MF2_M1 (5648) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI8_V_MF2_M1_MASK (5649) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI8_V_MF2_MF2 (5650) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI8_V_MF2_MF2_MASK (5651) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI8_V_MF4_M1 (5652) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI8_V_MF4_M1_MASK (5653) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI8_V_MF4_MF2 (5654) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI8_V_MF4_MF2_MASK (5655) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI8_V_MF4_MF4 (5656) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI8_V_MF4_MF4_MASK (5657) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI8_V_MF8_M1 (5658) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI8_V_MF8_M1_MASK (5659) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI8_V_MF8_MF2 (5660) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI8_V_MF8_MF2_MASK (5661) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI8_V_MF8_MF4 (5662) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI8_V_MF8_MF4_MASK (5663) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI8_V_MF8_MF8 (5664) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG7EI8_V_MF8_MF8_MASK (5665) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI16_V_M1_M1 (5666) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI16_V_M1_M1_MASK (5667) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI16_V_M1_MF2 (5668) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI16_V_M1_MF2_MASK (5669) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI16_V_M2_M1 (5670) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI16_V_M2_M1_MASK (5671) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI16_V_MF2_M1 (5672) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI16_V_MF2_M1_MASK (5673) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI16_V_MF2_MF2 (5674) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI16_V_MF2_MF2_MASK (5675) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI16_V_MF2_MF4 (5676) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI16_V_MF2_MF4_MASK (5677) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI16_V_MF4_M1 (5678) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI16_V_MF4_M1_MASK (5679) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI16_V_MF4_MF2 (5680) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI16_V_MF4_MF2_MASK (5681) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI16_V_MF4_MF4 (5682) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI16_V_MF4_MF4_MASK (5683) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI16_V_MF4_MF8 (5684) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI16_V_MF4_MF8_MASK (5685) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI32_V_M1_M1 (5686) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI32_V_M1_M1_MASK (5687) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI32_V_M1_MF2 (5688) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI32_V_M1_MF2_MASK (5689) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI32_V_M1_MF4 (5690) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI32_V_M1_MF4_MASK (5691) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI32_V_M2_M1 (5692) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI32_V_M2_M1_MASK (5693) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI32_V_M2_MF2 (5694) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI32_V_M2_MF2_MASK (5695) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI32_V_M4_M1 (5696) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI32_V_M4_M1_MASK (5697) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI32_V_MF2_M1 (5698) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI32_V_MF2_M1_MASK (5699) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI32_V_MF2_MF2 (5700) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI32_V_MF2_MF2_MASK (5701) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI32_V_MF2_MF4 (5702) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI32_V_MF2_MF4_MASK (5703) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI32_V_MF2_MF8 (5704) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI32_V_MF2_MF8_MASK (5705) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI64_V_M1_M1 (5706) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI64_V_M1_M1_MASK (5707) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI64_V_M1_MF2 (5708) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI64_V_M1_MF2_MASK (5709) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI64_V_M1_MF4 (5710) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI64_V_M1_MF4_MASK (5711) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI64_V_M1_MF8 (5712) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI64_V_M1_MF8_MASK (5713) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI64_V_M2_M1 (5714) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI64_V_M2_M1_MASK (5715) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI64_V_M2_MF2 (5716) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI64_V_M2_MF2_MASK (5717) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI64_V_M2_MF4 (5718) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI64_V_M2_MF4_MASK (5719) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI64_V_M4_M1 (5720) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI64_V_M4_M1_MASK (5721) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI64_V_M4_MF2 (5722) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI64_V_M4_MF2_MASK (5723) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI64_V_M8_M1 (5724) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI64_V_M8_M1_MASK (5725) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI8_V_M1_M1 (5726) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI8_V_M1_M1_MASK (5727) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI8_V_MF2_M1 (5728) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI8_V_MF2_M1_MASK (5729) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI8_V_MF2_MF2 (5730) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI8_V_MF2_MF2_MASK (5731) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI8_V_MF4_M1 (5732) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI8_V_MF4_M1_MASK (5733) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI8_V_MF4_MF2 (5734) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI8_V_MF4_MF2_MASK (5735) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI8_V_MF4_MF4 (5736) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI8_V_MF4_MF4_MASK (5737) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI8_V_MF8_M1 (5738) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI8_V_MF8_M1_MASK (5739) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI8_V_MF8_MF2 (5740) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI8_V_MF8_MF2_MASK (5741) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI8_V_MF8_MF4 (5742) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI8_V_MF8_MF4_MASK (5743) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI8_V_MF8_MF8 (5744) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVLUXSEG8EI8_V_MF8_MF8_MASK (5745) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMACC_VV_M1 (5746) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMACC_VV_M1_MASK (5747) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMACC_VV_M2 (5748) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMACC_VV_M2_MASK (5749) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMACC_VV_M4 (5750) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMACC_VV_M4_MASK (5751) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMACC_VV_M8 (5752) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMACC_VV_M8_MASK (5753) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMACC_VV_MF2 (5754) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMACC_VV_MF2_MASK (5755) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMACC_VV_MF4 (5756) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMACC_VV_MF4_MASK (5757) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMACC_VV_MF8 (5758) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMACC_VV_MF8_MASK (5759) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMACC_VX_M1 (5760) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMACC_VX_M1_MASK (5761) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMACC_VX_M2 (5762) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMACC_VX_M2_MASK (5763) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMACC_VX_M4 (5764) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMACC_VX_M4_MASK (5765) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMACC_VX_M8 (5766) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMACC_VX_M8_MASK (5767) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMACC_VX_MF2 (5768) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMACC_VX_MF2_MASK (5769) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMACC_VX_MF4 (5770) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMACC_VX_MF4_MASK (5771) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMACC_VX_MF8 (5772) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMACC_VX_MF8_MASK (5773) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADC_VIM_M1 (5774) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADC_VIM_M2 (5775) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADC_VIM_M4 (5776) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADC_VIM_M8 (5777) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADC_VIM_MF2 (5778) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADC_VIM_MF4 (5779) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADC_VIM_MF8 (5780) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADC_VI_M1 (5781) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADC_VI_M2 (5782) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADC_VI_M4 (5783) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADC_VI_M8 (5784) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADC_VI_MF2 (5785) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADC_VI_MF4 (5786) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADC_VI_MF8 (5787) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADC_VVM_M1 (5788) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADC_VVM_M2 (5789) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADC_VVM_M4 (5790) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADC_VVM_M8 (5791) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADC_VVM_MF2 (5792) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADC_VVM_MF4 (5793) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADC_VVM_MF8 (5794) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADC_VV_M1 (5795) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADC_VV_M2 (5796) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADC_VV_M4 (5797) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADC_VV_M8 (5798) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADC_VV_MF2 (5799) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADC_VV_MF4 (5800) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADC_VV_MF8 (5801) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADC_VXM_M1 (5802) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADC_VXM_M2 (5803) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADC_VXM_M4 (5804) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADC_VXM_M8 (5805) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADC_VXM_MF2 (5806) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADC_VXM_MF4 (5807) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADC_VXM_MF8 (5808) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADC_VX_M1 (5809) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADC_VX_M2 (5810) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADC_VX_M4 (5811) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADC_VX_M8 (5812) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADC_VX_MF2 (5813) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADC_VX_MF4 (5814) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADC_VX_MF8 (5815) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADD_VV_M1 (5816) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADD_VV_M1_MASK (5817) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADD_VV_M2 (5818) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADD_VV_M2_MASK (5819) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADD_VV_M4 (5820) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADD_VV_M4_MASK (5821) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADD_VV_M8 (5822) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADD_VV_M8_MASK (5823) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADD_VV_MF2 (5824) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADD_VV_MF2_MASK (5825) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADD_VV_MF4 (5826) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADD_VV_MF4_MASK (5827) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADD_VV_MF8 (5828) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADD_VV_MF8_MASK (5829) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADD_VX_M1 (5830) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADD_VX_M1_MASK (5831) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADD_VX_M2 (5832) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADD_VX_M2_MASK (5833) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADD_VX_M4 (5834) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADD_VX_M4_MASK (5835) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADD_VX_M8 (5836) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADD_VX_M8_MASK (5837) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADD_VX_MF2 (5838) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADD_VX_MF2_MASK (5839) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADD_VX_MF4 (5840) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADD_VX_MF4_MASK (5841) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADD_VX_MF8 (5842) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMADD_VX_MF8_MASK (5843) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMANDN_MM_M1 (5844) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMANDN_MM_M2 (5845) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMANDN_MM_M4 (5846) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMANDN_MM_M8 (5847) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMANDN_MM_MF2 (5848) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMANDN_MM_MF4 (5849) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMANDN_MM_MF8 (5850) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAND_MM_M1 (5851) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAND_MM_M2 (5852) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAND_MM_M4 (5853) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAND_MM_M8 (5854) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAND_MM_MF2 (5855) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAND_MM_MF4 (5856) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAND_MM_MF8 (5857) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAXU_VV_M1 (5858) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAXU_VV_M1_MASK (5859) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAXU_VV_M2 (5860) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAXU_VV_M2_MASK (5861) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAXU_VV_M4 (5862) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAXU_VV_M4_MASK (5863) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAXU_VV_M8 (5864) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAXU_VV_M8_MASK (5865) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAXU_VV_MF2 (5866) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAXU_VV_MF2_MASK (5867) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAXU_VV_MF4 (5868) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAXU_VV_MF4_MASK (5869) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAXU_VV_MF8 (5870) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAXU_VV_MF8_MASK (5871) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAXU_VX_M1 (5872) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAXU_VX_M1_MASK (5873) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAXU_VX_M2 (5874) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAXU_VX_M2_MASK (5875) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAXU_VX_M4 (5876) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAXU_VX_M4_MASK (5877) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAXU_VX_M8 (5878) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAXU_VX_M8_MASK (5879) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAXU_VX_MF2 (5880) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAXU_VX_MF2_MASK (5881) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAXU_VX_MF4 (5882) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAXU_VX_MF4_MASK (5883) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAXU_VX_MF8 (5884) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAXU_VX_MF8_MASK (5885) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAX_VV_M1 (5886) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAX_VV_M1_MASK (5887) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAX_VV_M2 (5888) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAX_VV_M2_MASK (5889) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAX_VV_M4 (5890) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAX_VV_M4_MASK (5891) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAX_VV_M8 (5892) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAX_VV_M8_MASK (5893) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAX_VV_MF2 (5894) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAX_VV_MF2_MASK (5895) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAX_VV_MF4 (5896) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAX_VV_MF4_MASK (5897) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAX_VV_MF8 (5898) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAX_VV_MF8_MASK (5899) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAX_VX_M1 (5900) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAX_VX_M1_MASK (5901) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAX_VX_M2 (5902) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAX_VX_M2_MASK (5903) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAX_VX_M4 (5904) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAX_VX_M4_MASK (5905) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAX_VX_M8 (5906) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAX_VX_M8_MASK (5907) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAX_VX_MF2 (5908) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAX_VX_MF2_MASK (5909) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAX_VX_MF4 (5910) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAX_VX_MF4_MASK (5911) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAX_VX_MF8 (5912) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMAX_VX_MF8_MASK (5913) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMCLR_M_B1 (5914) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMCLR_M_B16 (5915) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMCLR_M_B2 (5916) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMCLR_M_B32 (5917) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMCLR_M_B4 (5918) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMCLR_M_B64 (5919) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMCLR_M_B8 (5920) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMERGE_VIM_M1 (5921) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMERGE_VIM_M2 (5922) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMERGE_VIM_M4 (5923) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMERGE_VIM_M8 (5924) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMERGE_VIM_MF2 (5925) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMERGE_VIM_MF4 (5926) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMERGE_VIM_MF8 (5927) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMERGE_VVM_M1 (5928) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMERGE_VVM_M2 (5929) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMERGE_VVM_M4 (5930) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMERGE_VVM_M8 (5931) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMERGE_VVM_MF2 (5932) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMERGE_VVM_MF4 (5933) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMERGE_VVM_MF8 (5934) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMERGE_VXM_M1 (5935) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMERGE_VXM_M2 (5936) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMERGE_VXM_M4 (5937) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMERGE_VXM_M8 (5938) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMERGE_VXM_MF2 (5939) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMERGE_VXM_MF4 (5940) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMERGE_VXM_MF8 (5941) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFEQ_VFPR16_M1 (5942) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFEQ_VFPR16_M1_MASK (5943) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFEQ_VFPR16_M2 (5944) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFEQ_VFPR16_M2_MASK (5945) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFEQ_VFPR16_M4 (5946) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFEQ_VFPR16_M4_MASK (5947) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFEQ_VFPR16_M8 (5948) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFEQ_VFPR16_M8_MASK (5949) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFEQ_VFPR16_MF2 (5950) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFEQ_VFPR16_MF2_MASK (5951) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFEQ_VFPR16_MF4 (5952) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFEQ_VFPR16_MF4_MASK (5953) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFEQ_VFPR32_M1 (5954) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFEQ_VFPR32_M1_MASK (5955) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFEQ_VFPR32_M2 (5956) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFEQ_VFPR32_M2_MASK (5957) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFEQ_VFPR32_M4 (5958) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFEQ_VFPR32_M4_MASK (5959) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFEQ_VFPR32_M8 (5960) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFEQ_VFPR32_M8_MASK (5961) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFEQ_VFPR32_MF2 (5962) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFEQ_VFPR32_MF2_MASK (5963) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFEQ_VFPR64_M1 (5964) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFEQ_VFPR64_M1_MASK (5965) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFEQ_VFPR64_M2 (5966) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFEQ_VFPR64_M2_MASK (5967) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFEQ_VFPR64_M4 (5968) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFEQ_VFPR64_M4_MASK (5969) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFEQ_VFPR64_M8 (5970) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFEQ_VFPR64_M8_MASK (5971) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFEQ_VV_M1 (5972) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFEQ_VV_M1_MASK (5973) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFEQ_VV_M2 (5974) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFEQ_VV_M2_MASK (5975) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFEQ_VV_M4 (5976) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFEQ_VV_M4_MASK (5977) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFEQ_VV_M8 (5978) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFEQ_VV_M8_MASK (5979) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFEQ_VV_MF2 (5980) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFEQ_VV_MF2_MASK (5981) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFEQ_VV_MF4 (5982) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFEQ_VV_MF4_MASK (5983) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGE_VFPR16_M1 (5984) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGE_VFPR16_M1_MASK (5985) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGE_VFPR16_M2 (5986) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGE_VFPR16_M2_MASK (5987) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGE_VFPR16_M4 (5988) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGE_VFPR16_M4_MASK (5989) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGE_VFPR16_M8 (5990) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGE_VFPR16_M8_MASK (5991) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGE_VFPR16_MF2 (5992) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGE_VFPR16_MF2_MASK (5993) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGE_VFPR16_MF4 (5994) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGE_VFPR16_MF4_MASK (5995) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGE_VFPR32_M1 (5996) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGE_VFPR32_M1_MASK (5997) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGE_VFPR32_M2 (5998) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGE_VFPR32_M2_MASK (5999) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGE_VFPR32_M4 (6000) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGE_VFPR32_M4_MASK (6001) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGE_VFPR32_M8 (6002) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGE_VFPR32_M8_MASK (6003) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGE_VFPR32_MF2 (6004) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGE_VFPR32_MF2_MASK (6005) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGE_VFPR64_M1 (6006) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGE_VFPR64_M1_MASK (6007) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGE_VFPR64_M2 (6008) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGE_VFPR64_M2_MASK (6009) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGE_VFPR64_M4 (6010) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGE_VFPR64_M4_MASK (6011) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGE_VFPR64_M8 (6012) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGE_VFPR64_M8_MASK (6013) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGT_VFPR16_M1 (6014) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGT_VFPR16_M1_MASK (6015) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGT_VFPR16_M2 (6016) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGT_VFPR16_M2_MASK (6017) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGT_VFPR16_M4 (6018) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGT_VFPR16_M4_MASK (6019) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGT_VFPR16_M8 (6020) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGT_VFPR16_M8_MASK (6021) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGT_VFPR16_MF2 (6022) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGT_VFPR16_MF2_MASK (6023) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGT_VFPR16_MF4 (6024) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGT_VFPR16_MF4_MASK (6025) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGT_VFPR32_M1 (6026) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGT_VFPR32_M1_MASK (6027) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGT_VFPR32_M2 (6028) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGT_VFPR32_M2_MASK (6029) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGT_VFPR32_M4 (6030) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGT_VFPR32_M4_MASK (6031) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGT_VFPR32_M8 (6032) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGT_VFPR32_M8_MASK (6033) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGT_VFPR32_MF2 (6034) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGT_VFPR32_MF2_MASK (6035) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGT_VFPR64_M1 (6036) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGT_VFPR64_M1_MASK (6037) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGT_VFPR64_M2 (6038) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGT_VFPR64_M2_MASK (6039) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGT_VFPR64_M4 (6040) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGT_VFPR64_M4_MASK (6041) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGT_VFPR64_M8 (6042) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFGT_VFPR64_M8_MASK (6043) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLE_VFPR16_M1 (6044) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLE_VFPR16_M1_MASK (6045) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLE_VFPR16_M2 (6046) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLE_VFPR16_M2_MASK (6047) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLE_VFPR16_M4 (6048) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLE_VFPR16_M4_MASK (6049) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLE_VFPR16_M8 (6050) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLE_VFPR16_M8_MASK (6051) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLE_VFPR16_MF2 (6052) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLE_VFPR16_MF2_MASK (6053) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLE_VFPR16_MF4 (6054) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLE_VFPR16_MF4_MASK (6055) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLE_VFPR32_M1 (6056) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLE_VFPR32_M1_MASK (6057) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLE_VFPR32_M2 (6058) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLE_VFPR32_M2_MASK (6059) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLE_VFPR32_M4 (6060) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLE_VFPR32_M4_MASK (6061) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLE_VFPR32_M8 (6062) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLE_VFPR32_M8_MASK (6063) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLE_VFPR32_MF2 (6064) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLE_VFPR32_MF2_MASK (6065) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLE_VFPR64_M1 (6066) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLE_VFPR64_M1_MASK (6067) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLE_VFPR64_M2 (6068) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLE_VFPR64_M2_MASK (6069) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLE_VFPR64_M4 (6070) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLE_VFPR64_M4_MASK (6071) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLE_VFPR64_M8 (6072) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLE_VFPR64_M8_MASK (6073) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLE_VV_M1 (6074) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLE_VV_M1_MASK (6075) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLE_VV_M2 (6076) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLE_VV_M2_MASK (6077) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLE_VV_M4 (6078) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLE_VV_M4_MASK (6079) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLE_VV_M8 (6080) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLE_VV_M8_MASK (6081) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLE_VV_MF2 (6082) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLE_VV_MF2_MASK (6083) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLE_VV_MF4 (6084) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLE_VV_MF4_MASK (6085) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLT_VFPR16_M1 (6086) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLT_VFPR16_M1_MASK (6087) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLT_VFPR16_M2 (6088) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLT_VFPR16_M2_MASK (6089) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLT_VFPR16_M4 (6090) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLT_VFPR16_M4_MASK (6091) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLT_VFPR16_M8 (6092) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLT_VFPR16_M8_MASK (6093) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLT_VFPR16_MF2 (6094) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLT_VFPR16_MF2_MASK (6095) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLT_VFPR16_MF4 (6096) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLT_VFPR16_MF4_MASK (6097) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLT_VFPR32_M1 (6098) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLT_VFPR32_M1_MASK (6099) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLT_VFPR32_M2 (6100) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLT_VFPR32_M2_MASK (6101) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLT_VFPR32_M4 (6102) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLT_VFPR32_M4_MASK (6103) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLT_VFPR32_M8 (6104) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLT_VFPR32_M8_MASK (6105) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLT_VFPR32_MF2 (6106) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLT_VFPR32_MF2_MASK (6107) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLT_VFPR64_M1 (6108) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLT_VFPR64_M1_MASK (6109) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLT_VFPR64_M2 (6110) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLT_VFPR64_M2_MASK (6111) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLT_VFPR64_M4 (6112) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLT_VFPR64_M4_MASK (6113) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLT_VFPR64_M8 (6114) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLT_VFPR64_M8_MASK (6115) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLT_VV_M1 (6116) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLT_VV_M1_MASK (6117) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLT_VV_M2 (6118) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLT_VV_M2_MASK (6119) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLT_VV_M4 (6120) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLT_VV_M4_MASK (6121) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLT_VV_M8 (6122) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLT_VV_M8_MASK (6123) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLT_VV_MF2 (6124) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLT_VV_MF2_MASK (6125) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLT_VV_MF4 (6126) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFLT_VV_MF4_MASK (6127) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFNE_VFPR16_M1 (6128) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFNE_VFPR16_M1_MASK (6129) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFNE_VFPR16_M2 (6130) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFNE_VFPR16_M2_MASK (6131) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFNE_VFPR16_M4 (6132) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFNE_VFPR16_M4_MASK (6133) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFNE_VFPR16_M8 (6134) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFNE_VFPR16_M8_MASK (6135) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFNE_VFPR16_MF2 (6136) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFNE_VFPR16_MF2_MASK (6137) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFNE_VFPR16_MF4 (6138) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFNE_VFPR16_MF4_MASK (6139) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFNE_VFPR32_M1 (6140) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFNE_VFPR32_M1_MASK (6141) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFNE_VFPR32_M2 (6142) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFNE_VFPR32_M2_MASK (6143) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFNE_VFPR32_M4 (6144) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFNE_VFPR32_M4_MASK (6145) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFNE_VFPR32_M8 (6146) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFNE_VFPR32_M8_MASK (6147) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFNE_VFPR32_MF2 (6148) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFNE_VFPR32_MF2_MASK (6149) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFNE_VFPR64_M1 (6150) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFNE_VFPR64_M1_MASK (6151) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFNE_VFPR64_M2 (6152) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFNE_VFPR64_M2_MASK (6153) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFNE_VFPR64_M4 (6154) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFNE_VFPR64_M4_MASK (6155) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFNE_VFPR64_M8 (6156) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFNE_VFPR64_M8_MASK (6157) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFNE_VV_M1 (6158) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFNE_VV_M1_MASK (6159) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFNE_VV_M2 (6160) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFNE_VV_M2_MASK (6161) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFNE_VV_M4 (6162) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFNE_VV_M4_MASK (6163) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFNE_VV_M8 (6164) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFNE_VV_M8_MASK (6165) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFNE_VV_MF2 (6166) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFNE_VV_MF2_MASK (6167) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFNE_VV_MF4 (6168) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMFNE_VV_MF4_MASK (6169) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMINU_VV_M1 (6170) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMINU_VV_M1_MASK (6171) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMINU_VV_M2 (6172) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMINU_VV_M2_MASK (6173) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMINU_VV_M4 (6174) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMINU_VV_M4_MASK (6175) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMINU_VV_M8 (6176) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMINU_VV_M8_MASK (6177) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMINU_VV_MF2 (6178) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMINU_VV_MF2_MASK (6179) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMINU_VV_MF4 (6180) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMINU_VV_MF4_MASK (6181) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMINU_VV_MF8 (6182) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMINU_VV_MF8_MASK (6183) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMINU_VX_M1 (6184) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMINU_VX_M1_MASK (6185) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMINU_VX_M2 (6186) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMINU_VX_M2_MASK (6187) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMINU_VX_M4 (6188) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMINU_VX_M4_MASK (6189) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMINU_VX_M8 (6190) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMINU_VX_M8_MASK (6191) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMINU_VX_MF2 (6192) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMINU_VX_MF2_MASK (6193) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMINU_VX_MF4 (6194) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMINU_VX_MF4_MASK (6195) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMINU_VX_MF8 (6196) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMINU_VX_MF8_MASK (6197) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMIN_VV_M1 (6198) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMIN_VV_M1_MASK (6199) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMIN_VV_M2 (6200) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMIN_VV_M2_MASK (6201) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMIN_VV_M4 (6202) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMIN_VV_M4_MASK (6203) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMIN_VV_M8 (6204) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMIN_VV_M8_MASK (6205) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMIN_VV_MF2 (6206) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMIN_VV_MF2_MASK (6207) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMIN_VV_MF4 (6208) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMIN_VV_MF4_MASK (6209) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMIN_VV_MF8 (6210) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMIN_VV_MF8_MASK (6211) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMIN_VX_M1 (6212) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMIN_VX_M1_MASK (6213) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMIN_VX_M2 (6214) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMIN_VX_M2_MASK (6215) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMIN_VX_M4 (6216) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMIN_VX_M4_MASK (6217) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMIN_VX_M8 (6218) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMIN_VX_M8_MASK (6219) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMIN_VX_MF2 (6220) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMIN_VX_MF2_MASK (6221) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMIN_VX_MF4 (6222) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMIN_VX_MF4_MASK (6223) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMIN_VX_MF8 (6224) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMIN_VX_MF8_MASK (6225) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMNAND_MM_M1 (6226) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMNAND_MM_M2 (6227) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMNAND_MM_M4 (6228) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMNAND_MM_M8 (6229) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMNAND_MM_MF2 (6230) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMNAND_MM_MF4 (6231) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMNAND_MM_MF8 (6232) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMNOR_MM_M1 (6233) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMNOR_MM_M2 (6234) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMNOR_MM_M4 (6235) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMNOR_MM_M8 (6236) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMNOR_MM_MF2 (6237) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMNOR_MM_MF4 (6238) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMNOR_MM_MF8 (6239) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMORN_MM_M1 (6240) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMORN_MM_M2 (6241) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMORN_MM_M4 (6242) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMORN_MM_M8 (6243) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMORN_MM_MF2 (6244) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMORN_MM_MF4 (6245) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMORN_MM_MF8 (6246) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMOR_MM_M1 (6247) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMOR_MM_M2 (6248) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMOR_MM_M4 (6249) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMOR_MM_M8 (6250) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMOR_MM_MF2 (6251) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMOR_MM_MF4 (6252) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMOR_MM_MF8 (6253) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSBC_VVM_M1 (6254) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSBC_VVM_M2 (6255) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSBC_VVM_M4 (6256) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSBC_VVM_M8 (6257) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSBC_VVM_MF2 (6258) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSBC_VVM_MF4 (6259) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSBC_VVM_MF8 (6260) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSBC_VV_M1 (6261) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSBC_VV_M2 (6262) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSBC_VV_M4 (6263) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSBC_VV_M8 (6264) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSBC_VV_MF2 (6265) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSBC_VV_MF4 (6266) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSBC_VV_MF8 (6267) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSBC_VXM_M1 (6268) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSBC_VXM_M2 (6269) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSBC_VXM_M4 (6270) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSBC_VXM_M8 (6271) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSBC_VXM_MF2 (6272) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSBC_VXM_MF4 (6273) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSBC_VXM_MF8 (6274) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSBC_VX_M1 (6275) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSBC_VX_M2 (6276) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSBC_VX_M4 (6277) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSBC_VX_M8 (6278) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSBC_VX_MF2 (6279) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSBC_VX_MF4 (6280) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSBC_VX_MF8 (6281) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSBF_M_B1 (6282) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSBF_M_B16 (6283) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSBF_M_B16_MASK (6284) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSBF_M_B1_MASK (6285) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSBF_M_B2 (6286) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSBF_M_B2_MASK (6287) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSBF_M_B32 (6288) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSBF_M_B32_MASK (6289) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSBF_M_B4 (6290) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSBF_M_B4_MASK (6291) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSBF_M_B64 (6292) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSBF_M_B64_MASK (6293) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSBF_M_B8 (6294) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSBF_M_B8_MASK (6295) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSEQ_VI_M1 (6296) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSEQ_VI_M1_MASK (6297) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSEQ_VI_M2 (6298) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSEQ_VI_M2_MASK (6299) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSEQ_VI_M4 (6300) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSEQ_VI_M4_MASK (6301) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSEQ_VI_M8 (6302) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSEQ_VI_M8_MASK (6303) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSEQ_VI_MF2 (6304) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSEQ_VI_MF2_MASK (6305) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSEQ_VI_MF4 (6306) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSEQ_VI_MF4_MASK (6307) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSEQ_VI_MF8 (6308) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSEQ_VI_MF8_MASK (6309) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSEQ_VV_M1 (6310) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSEQ_VV_M1_MASK (6311) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSEQ_VV_M2 (6312) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSEQ_VV_M2_MASK (6313) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSEQ_VV_M4 (6314) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSEQ_VV_M4_MASK (6315) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSEQ_VV_M8 (6316) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSEQ_VV_M8_MASK (6317) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSEQ_VV_MF2 (6318) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSEQ_VV_MF2_MASK (6319) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSEQ_VV_MF4 (6320) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSEQ_VV_MF4_MASK (6321) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSEQ_VV_MF8 (6322) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSEQ_VV_MF8_MASK (6323) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSEQ_VX_M1 (6324) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSEQ_VX_M1_MASK (6325) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSEQ_VX_M2 (6326) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSEQ_VX_M2_MASK (6327) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSEQ_VX_M4 (6328) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSEQ_VX_M4_MASK (6329) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSEQ_VX_M8 (6330) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSEQ_VX_M8_MASK (6331) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSEQ_VX_MF2 (6332) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSEQ_VX_MF2_MASK (6333) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSEQ_VX_MF4 (6334) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSEQ_VX_MF4_MASK (6335) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSEQ_VX_MF8 (6336) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSEQ_VX_MF8_MASK (6337) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSET_M_B1 (6338) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSET_M_B16 (6339) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSET_M_B2 (6340) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSET_M_B32 (6341) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSET_M_B4 (6342) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSET_M_B64 (6343) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSET_M_B8 (6344) - RISCV_INS_INVALID - */ + 0 +}}}, +{ /* RISCV_PseudoVMSGEU_VI (6345) - RISCV_INS_VMSGEU_VI - vmsgeu.vi $vd, $vs2, $imm$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_PseudoVMSGEU_VX (6346) - RISCV_INS_VMSGEU_VX - vmsgeu.vx $vd, $vs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_PseudoVMSGEU_VX_M (6347) - RISCV_INS_VMSGEU_VX - vmsgeu.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_PseudoVMSGEU_VX_M_T (6348) - RISCV_INS_VMSGEU_VX - vmsgeu.vx $vd, $vs2, $rs1$vm, $scratch */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* scratch */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_PseudoVMSGE_VI (6349) - RISCV_INS_VMSGE_VI - vmsge.vi $vd, $vs2, $imm$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_PseudoVMSGE_VX (6350) - RISCV_INS_VMSGE_VX - vmsge.vx $vd, $vs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_PseudoVMSGE_VX_M (6351) - RISCV_INS_VMSGE_VX - vmsge.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_PseudoVMSGE_VX_M_T (6352) - RISCV_INS_VMSGE_VX - vmsge.vx $vd, $vs2, $rs1$vm, $scratch */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* scratch */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{{{ /* RISCV_PseudoVMSGTU_VI_M1 (6353) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSGTU_VI_M1_MASK (6354) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSGTU_VI_M2 (6355) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSGTU_VI_M2_MASK (6356) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSGTU_VI_M4 (6357) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSGTU_VI_M4_MASK (6358) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSGTU_VI_M8 (6359) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSGTU_VI_M8_MASK (6360) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSGTU_VI_MF2 (6361) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSGTU_VI_MF2_MASK (6362) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSGTU_VI_MF4 (6363) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSGTU_VI_MF4_MASK (6364) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSGTU_VI_MF8 (6365) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSGTU_VI_MF8_MASK (6366) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSGTU_VX_M1 (6367) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSGTU_VX_M1_MASK (6368) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSGTU_VX_M2 (6369) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSGTU_VX_M2_MASK (6370) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSGTU_VX_M4 (6371) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSGTU_VX_M4_MASK (6372) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSGTU_VX_M8 (6373) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSGTU_VX_M8_MASK (6374) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSGTU_VX_MF2 (6375) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSGTU_VX_MF2_MASK (6376) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSGTU_VX_MF4 (6377) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSGTU_VX_MF4_MASK (6378) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSGTU_VX_MF8 (6379) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSGTU_VX_MF8_MASK (6380) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSGT_VI_M1 (6381) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSGT_VI_M1_MASK (6382) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSGT_VI_M2 (6383) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSGT_VI_M2_MASK (6384) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSGT_VI_M4 (6385) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSGT_VI_M4_MASK (6386) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSGT_VI_M8 (6387) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSGT_VI_M8_MASK (6388) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSGT_VI_MF2 (6389) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSGT_VI_MF2_MASK (6390) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSGT_VI_MF4 (6391) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSGT_VI_MF4_MASK (6392) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSGT_VI_MF8 (6393) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSGT_VI_MF8_MASK (6394) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSGT_VX_M1 (6395) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSGT_VX_M1_MASK (6396) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSGT_VX_M2 (6397) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSGT_VX_M2_MASK (6398) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSGT_VX_M4 (6399) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSGT_VX_M4_MASK (6400) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSGT_VX_M8 (6401) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSGT_VX_M8_MASK (6402) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSGT_VX_MF2 (6403) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSGT_VX_MF2_MASK (6404) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSGT_VX_MF4 (6405) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSGT_VX_MF4_MASK (6406) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSGT_VX_MF8 (6407) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSGT_VX_MF8_MASK (6408) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSIF_M_B1 (6409) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSIF_M_B16 (6410) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSIF_M_B16_MASK (6411) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSIF_M_B1_MASK (6412) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSIF_M_B2 (6413) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSIF_M_B2_MASK (6414) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSIF_M_B32 (6415) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSIF_M_B32_MASK (6416) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSIF_M_B4 (6417) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSIF_M_B4_MASK (6418) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSIF_M_B64 (6419) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSIF_M_B64_MASK (6420) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSIF_M_B8 (6421) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSIF_M_B8_MASK (6422) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLEU_VI_M1 (6423) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLEU_VI_M1_MASK (6424) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLEU_VI_M2 (6425) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLEU_VI_M2_MASK (6426) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLEU_VI_M4 (6427) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLEU_VI_M4_MASK (6428) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLEU_VI_M8 (6429) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLEU_VI_M8_MASK (6430) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLEU_VI_MF2 (6431) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLEU_VI_MF2_MASK (6432) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLEU_VI_MF4 (6433) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLEU_VI_MF4_MASK (6434) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLEU_VI_MF8 (6435) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLEU_VI_MF8_MASK (6436) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLEU_VV_M1 (6437) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLEU_VV_M1_MASK (6438) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLEU_VV_M2 (6439) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLEU_VV_M2_MASK (6440) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLEU_VV_M4 (6441) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLEU_VV_M4_MASK (6442) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLEU_VV_M8 (6443) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLEU_VV_M8_MASK (6444) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLEU_VV_MF2 (6445) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLEU_VV_MF2_MASK (6446) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLEU_VV_MF4 (6447) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLEU_VV_MF4_MASK (6448) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLEU_VV_MF8 (6449) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLEU_VV_MF8_MASK (6450) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLEU_VX_M1 (6451) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLEU_VX_M1_MASK (6452) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLEU_VX_M2 (6453) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLEU_VX_M2_MASK (6454) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLEU_VX_M4 (6455) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLEU_VX_M4_MASK (6456) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLEU_VX_M8 (6457) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLEU_VX_M8_MASK (6458) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLEU_VX_MF2 (6459) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLEU_VX_MF2_MASK (6460) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLEU_VX_MF4 (6461) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLEU_VX_MF4_MASK (6462) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLEU_VX_MF8 (6463) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLEU_VX_MF8_MASK (6464) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLE_VI_M1 (6465) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLE_VI_M1_MASK (6466) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLE_VI_M2 (6467) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLE_VI_M2_MASK (6468) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLE_VI_M4 (6469) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLE_VI_M4_MASK (6470) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLE_VI_M8 (6471) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLE_VI_M8_MASK (6472) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLE_VI_MF2 (6473) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLE_VI_MF2_MASK (6474) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLE_VI_MF4 (6475) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLE_VI_MF4_MASK (6476) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLE_VI_MF8 (6477) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLE_VI_MF8_MASK (6478) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLE_VV_M1 (6479) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLE_VV_M1_MASK (6480) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLE_VV_M2 (6481) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLE_VV_M2_MASK (6482) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLE_VV_M4 (6483) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLE_VV_M4_MASK (6484) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLE_VV_M8 (6485) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLE_VV_M8_MASK (6486) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLE_VV_MF2 (6487) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLE_VV_MF2_MASK (6488) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLE_VV_MF4 (6489) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLE_VV_MF4_MASK (6490) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLE_VV_MF8 (6491) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLE_VV_MF8_MASK (6492) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLE_VX_M1 (6493) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLE_VX_M1_MASK (6494) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLE_VX_M2 (6495) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLE_VX_M2_MASK (6496) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLE_VX_M4 (6497) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLE_VX_M4_MASK (6498) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLE_VX_M8 (6499) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLE_VX_M8_MASK (6500) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLE_VX_MF2 (6501) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLE_VX_MF2_MASK (6502) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLE_VX_MF4 (6503) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLE_VX_MF4_MASK (6504) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLE_VX_MF8 (6505) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLE_VX_MF8_MASK (6506) - RISCV_INS_INVALID - */ + 0 +}}}, +{ /* RISCV_PseudoVMSLTU_VI (6507) - RISCV_INS_VMSLTU_VI - vmsltu.vi $vd, $vs2, $imm$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{{{ /* RISCV_PseudoVMSLTU_VV_M1 (6508) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLTU_VV_M1_MASK (6509) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLTU_VV_M2 (6510) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLTU_VV_M2_MASK (6511) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLTU_VV_M4 (6512) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLTU_VV_M4_MASK (6513) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLTU_VV_M8 (6514) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLTU_VV_M8_MASK (6515) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLTU_VV_MF2 (6516) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLTU_VV_MF2_MASK (6517) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLTU_VV_MF4 (6518) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLTU_VV_MF4_MASK (6519) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLTU_VV_MF8 (6520) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLTU_VV_MF8_MASK (6521) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLTU_VX_M1 (6522) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLTU_VX_M1_MASK (6523) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLTU_VX_M2 (6524) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLTU_VX_M2_MASK (6525) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLTU_VX_M4 (6526) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLTU_VX_M4_MASK (6527) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLTU_VX_M8 (6528) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLTU_VX_M8_MASK (6529) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLTU_VX_MF2 (6530) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLTU_VX_MF2_MASK (6531) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLTU_VX_MF4 (6532) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLTU_VX_MF4_MASK (6533) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLTU_VX_MF8 (6534) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLTU_VX_MF8_MASK (6535) - RISCV_INS_INVALID - */ + 0 +}}}, +{ /* RISCV_PseudoVMSLT_VI (6536) - RISCV_INS_VMSLT_VI - vmslt.vi $vd, $vs2, $imm$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{{{ /* RISCV_PseudoVMSLT_VV_M1 (6537) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLT_VV_M1_MASK (6538) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLT_VV_M2 (6539) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLT_VV_M2_MASK (6540) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLT_VV_M4 (6541) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLT_VV_M4_MASK (6542) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLT_VV_M8 (6543) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLT_VV_M8_MASK (6544) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLT_VV_MF2 (6545) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLT_VV_MF2_MASK (6546) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLT_VV_MF4 (6547) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLT_VV_MF4_MASK (6548) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLT_VV_MF8 (6549) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLT_VV_MF8_MASK (6550) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLT_VX_M1 (6551) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLT_VX_M1_MASK (6552) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLT_VX_M2 (6553) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLT_VX_M2_MASK (6554) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLT_VX_M4 (6555) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLT_VX_M4_MASK (6556) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLT_VX_M8 (6557) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLT_VX_M8_MASK (6558) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLT_VX_MF2 (6559) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLT_VX_MF2_MASK (6560) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLT_VX_MF4 (6561) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLT_VX_MF4_MASK (6562) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLT_VX_MF8 (6563) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSLT_VX_MF8_MASK (6564) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSNE_VI_M1 (6565) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSNE_VI_M1_MASK (6566) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSNE_VI_M2 (6567) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSNE_VI_M2_MASK (6568) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSNE_VI_M4 (6569) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSNE_VI_M4_MASK (6570) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSNE_VI_M8 (6571) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSNE_VI_M8_MASK (6572) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSNE_VI_MF2 (6573) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSNE_VI_MF2_MASK (6574) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSNE_VI_MF4 (6575) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSNE_VI_MF4_MASK (6576) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSNE_VI_MF8 (6577) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSNE_VI_MF8_MASK (6578) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSNE_VV_M1 (6579) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSNE_VV_M1_MASK (6580) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSNE_VV_M2 (6581) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSNE_VV_M2_MASK (6582) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSNE_VV_M4 (6583) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSNE_VV_M4_MASK (6584) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSNE_VV_M8 (6585) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSNE_VV_M8_MASK (6586) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSNE_VV_MF2 (6587) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSNE_VV_MF2_MASK (6588) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSNE_VV_MF4 (6589) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSNE_VV_MF4_MASK (6590) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSNE_VV_MF8 (6591) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSNE_VV_MF8_MASK (6592) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSNE_VX_M1 (6593) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSNE_VX_M1_MASK (6594) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSNE_VX_M2 (6595) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSNE_VX_M2_MASK (6596) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSNE_VX_M4 (6597) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSNE_VX_M4_MASK (6598) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSNE_VX_M8 (6599) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSNE_VX_M8_MASK (6600) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSNE_VX_MF2 (6601) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSNE_VX_MF2_MASK (6602) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSNE_VX_MF4 (6603) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSNE_VX_MF4_MASK (6604) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSNE_VX_MF8 (6605) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSNE_VX_MF8_MASK (6606) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSOF_M_B1 (6607) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSOF_M_B16 (6608) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSOF_M_B16_MASK (6609) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSOF_M_B1_MASK (6610) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSOF_M_B2 (6611) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSOF_M_B2_MASK (6612) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSOF_M_B32 (6613) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSOF_M_B32_MASK (6614) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSOF_M_B4 (6615) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSOF_M_B4_MASK (6616) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSOF_M_B64 (6617) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSOF_M_B64_MASK (6618) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSOF_M_B8 (6619) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMSOF_M_B8_MASK (6620) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULHSU_VV_M1 (6621) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULHSU_VV_M1_MASK (6622) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULHSU_VV_M2 (6623) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULHSU_VV_M2_MASK (6624) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULHSU_VV_M4 (6625) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULHSU_VV_M4_MASK (6626) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULHSU_VV_M8 (6627) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULHSU_VV_M8_MASK (6628) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULHSU_VV_MF2 (6629) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULHSU_VV_MF2_MASK (6630) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULHSU_VV_MF4 (6631) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULHSU_VV_MF4_MASK (6632) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULHSU_VV_MF8 (6633) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULHSU_VV_MF8_MASK (6634) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULHSU_VX_M1 (6635) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULHSU_VX_M1_MASK (6636) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULHSU_VX_M2 (6637) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULHSU_VX_M2_MASK (6638) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULHSU_VX_M4 (6639) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULHSU_VX_M4_MASK (6640) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULHSU_VX_M8 (6641) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULHSU_VX_M8_MASK (6642) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULHSU_VX_MF2 (6643) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULHSU_VX_MF2_MASK (6644) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULHSU_VX_MF4 (6645) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULHSU_VX_MF4_MASK (6646) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULHSU_VX_MF8 (6647) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULHSU_VX_MF8_MASK (6648) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULHU_VV_M1 (6649) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULHU_VV_M1_MASK (6650) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULHU_VV_M2 (6651) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULHU_VV_M2_MASK (6652) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULHU_VV_M4 (6653) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULHU_VV_M4_MASK (6654) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULHU_VV_M8 (6655) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULHU_VV_M8_MASK (6656) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULHU_VV_MF2 (6657) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULHU_VV_MF2_MASK (6658) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULHU_VV_MF4 (6659) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULHU_VV_MF4_MASK (6660) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULHU_VV_MF8 (6661) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULHU_VV_MF8_MASK (6662) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULHU_VX_M1 (6663) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULHU_VX_M1_MASK (6664) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULHU_VX_M2 (6665) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULHU_VX_M2_MASK (6666) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULHU_VX_M4 (6667) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULHU_VX_M4_MASK (6668) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULHU_VX_M8 (6669) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULHU_VX_M8_MASK (6670) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULHU_VX_MF2 (6671) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULHU_VX_MF2_MASK (6672) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULHU_VX_MF4 (6673) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULHU_VX_MF4_MASK (6674) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULHU_VX_MF8 (6675) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULHU_VX_MF8_MASK (6676) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULH_VV_M1 (6677) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULH_VV_M1_MASK (6678) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULH_VV_M2 (6679) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULH_VV_M2_MASK (6680) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULH_VV_M4 (6681) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULH_VV_M4_MASK (6682) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULH_VV_M8 (6683) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULH_VV_M8_MASK (6684) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULH_VV_MF2 (6685) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULH_VV_MF2_MASK (6686) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULH_VV_MF4 (6687) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULH_VV_MF4_MASK (6688) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULH_VV_MF8 (6689) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULH_VV_MF8_MASK (6690) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULH_VX_M1 (6691) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULH_VX_M1_MASK (6692) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULH_VX_M2 (6693) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULH_VX_M2_MASK (6694) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULH_VX_M4 (6695) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULH_VX_M4_MASK (6696) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULH_VX_M8 (6697) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULH_VX_M8_MASK (6698) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULH_VX_MF2 (6699) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULH_VX_MF2_MASK (6700) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULH_VX_MF4 (6701) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULH_VX_MF4_MASK (6702) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULH_VX_MF8 (6703) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMULH_VX_MF8_MASK (6704) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMUL_VV_M1 (6705) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMUL_VV_M1_MASK (6706) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMUL_VV_M2 (6707) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMUL_VV_M2_MASK (6708) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMUL_VV_M4 (6709) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMUL_VV_M4_MASK (6710) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMUL_VV_M8 (6711) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMUL_VV_M8_MASK (6712) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMUL_VV_MF2 (6713) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMUL_VV_MF2_MASK (6714) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMUL_VV_MF4 (6715) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMUL_VV_MF4_MASK (6716) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMUL_VV_MF8 (6717) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMUL_VV_MF8_MASK (6718) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMUL_VX_M1 (6719) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMUL_VX_M1_MASK (6720) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMUL_VX_M2 (6721) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMUL_VX_M2_MASK (6722) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMUL_VX_M4 (6723) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMUL_VX_M4_MASK (6724) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMUL_VX_M8 (6725) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMUL_VX_M8_MASK (6726) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMUL_VX_MF2 (6727) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMUL_VX_MF2_MASK (6728) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMUL_VX_MF4 (6729) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMUL_VX_MF4_MASK (6730) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMUL_VX_MF8 (6731) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMUL_VX_MF8_MASK (6732) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMV_S_X (6733) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMV_V_I_M1 (6734) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMV_V_I_M2 (6735) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMV_V_I_M4 (6736) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMV_V_I_M8 (6737) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMV_V_I_MF2 (6738) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMV_V_I_MF4 (6739) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMV_V_I_MF8 (6740) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMV_V_V_M1 (6741) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMV_V_V_M2 (6742) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMV_V_V_M4 (6743) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMV_V_V_M8 (6744) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMV_V_V_MF2 (6745) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMV_V_V_MF4 (6746) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMV_V_V_MF8 (6747) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMV_V_X_M1 (6748) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMV_V_X_M2 (6749) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMV_V_X_M4 (6750) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMV_V_X_M8 (6751) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMV_V_X_MF2 (6752) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMV_V_X_MF4 (6753) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMV_V_X_MF8 (6754) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMV_X_S (6755) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMXNOR_MM_M1 (6756) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMXNOR_MM_M2 (6757) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMXNOR_MM_M4 (6758) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMXNOR_MM_M8 (6759) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMXNOR_MM_MF2 (6760) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMXNOR_MM_MF4 (6761) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMXNOR_MM_MF8 (6762) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMXOR_MM_M1 (6763) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMXOR_MM_M2 (6764) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMXOR_MM_M4 (6765) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMXOR_MM_M8 (6766) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMXOR_MM_MF2 (6767) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMXOR_MM_MF4 (6768) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVMXOR_MM_MF8 (6769) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIPU_WI_M1 (6770) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIPU_WI_M1_MASK (6771) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIPU_WI_M2 (6772) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIPU_WI_M2_MASK (6773) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIPU_WI_M4 (6774) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIPU_WI_M4_MASK (6775) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIPU_WI_MF2 (6776) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIPU_WI_MF2_MASK (6777) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIPU_WI_MF4 (6778) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIPU_WI_MF4_MASK (6779) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIPU_WI_MF8 (6780) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIPU_WI_MF8_MASK (6781) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIPU_WV_M1 (6782) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIPU_WV_M1_MASK (6783) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIPU_WV_M2 (6784) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIPU_WV_M2_MASK (6785) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIPU_WV_M4 (6786) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIPU_WV_M4_MASK (6787) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIPU_WV_MF2 (6788) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIPU_WV_MF2_MASK (6789) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIPU_WV_MF4 (6790) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIPU_WV_MF4_MASK (6791) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIPU_WV_MF8 (6792) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIPU_WV_MF8_MASK (6793) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIPU_WX_M1 (6794) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIPU_WX_M1_MASK (6795) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIPU_WX_M2 (6796) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIPU_WX_M2_MASK (6797) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIPU_WX_M4 (6798) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIPU_WX_M4_MASK (6799) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIPU_WX_MF2 (6800) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIPU_WX_MF2_MASK (6801) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIPU_WX_MF4 (6802) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIPU_WX_MF4_MASK (6803) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIPU_WX_MF8 (6804) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIPU_WX_MF8_MASK (6805) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIP_WI_M1 (6806) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIP_WI_M1_MASK (6807) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIP_WI_M2 (6808) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIP_WI_M2_MASK (6809) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIP_WI_M4 (6810) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIP_WI_M4_MASK (6811) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIP_WI_MF2 (6812) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIP_WI_MF2_MASK (6813) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIP_WI_MF4 (6814) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIP_WI_MF4_MASK (6815) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIP_WI_MF8 (6816) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIP_WI_MF8_MASK (6817) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIP_WV_M1 (6818) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIP_WV_M1_MASK (6819) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIP_WV_M2 (6820) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIP_WV_M2_MASK (6821) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIP_WV_M4 (6822) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIP_WV_M4_MASK (6823) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIP_WV_MF2 (6824) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIP_WV_MF2_MASK (6825) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIP_WV_MF4 (6826) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIP_WV_MF4_MASK (6827) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIP_WV_MF8 (6828) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIP_WV_MF8_MASK (6829) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIP_WX_M1 (6830) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIP_WX_M1_MASK (6831) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIP_WX_M2 (6832) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIP_WX_M2_MASK (6833) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIP_WX_M4 (6834) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIP_WX_M4_MASK (6835) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIP_WX_MF2 (6836) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIP_WX_MF2_MASK (6837) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIP_WX_MF4 (6838) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIP_WX_MF4_MASK (6839) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIP_WX_MF8 (6840) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNCLIP_WX_MF8_MASK (6841) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNMSAC_VV_M1 (6842) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNMSAC_VV_M1_MASK (6843) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNMSAC_VV_M2 (6844) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNMSAC_VV_M2_MASK (6845) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNMSAC_VV_M4 (6846) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNMSAC_VV_M4_MASK (6847) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNMSAC_VV_M8 (6848) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNMSAC_VV_M8_MASK (6849) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNMSAC_VV_MF2 (6850) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNMSAC_VV_MF2_MASK (6851) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNMSAC_VV_MF4 (6852) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNMSAC_VV_MF4_MASK (6853) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNMSAC_VV_MF8 (6854) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNMSAC_VV_MF8_MASK (6855) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNMSAC_VX_M1 (6856) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNMSAC_VX_M1_MASK (6857) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNMSAC_VX_M2 (6858) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNMSAC_VX_M2_MASK (6859) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNMSAC_VX_M4 (6860) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNMSAC_VX_M4_MASK (6861) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNMSAC_VX_M8 (6862) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNMSAC_VX_M8_MASK (6863) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNMSAC_VX_MF2 (6864) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNMSAC_VX_MF2_MASK (6865) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNMSAC_VX_MF4 (6866) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNMSAC_VX_MF4_MASK (6867) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNMSAC_VX_MF8 (6868) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNMSAC_VX_MF8_MASK (6869) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNMSUB_VV_M1 (6870) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNMSUB_VV_M1_MASK (6871) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNMSUB_VV_M2 (6872) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNMSUB_VV_M2_MASK (6873) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNMSUB_VV_M4 (6874) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNMSUB_VV_M4_MASK (6875) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNMSUB_VV_M8 (6876) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNMSUB_VV_M8_MASK (6877) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNMSUB_VV_MF2 (6878) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNMSUB_VV_MF2_MASK (6879) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNMSUB_VV_MF4 (6880) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNMSUB_VV_MF4_MASK (6881) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNMSUB_VV_MF8 (6882) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNMSUB_VV_MF8_MASK (6883) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNMSUB_VX_M1 (6884) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNMSUB_VX_M1_MASK (6885) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNMSUB_VX_M2 (6886) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNMSUB_VX_M2_MASK (6887) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNMSUB_VX_M4 (6888) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNMSUB_VX_M4_MASK (6889) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNMSUB_VX_M8 (6890) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNMSUB_VX_M8_MASK (6891) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNMSUB_VX_MF2 (6892) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNMSUB_VX_MF2_MASK (6893) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNMSUB_VX_MF4 (6894) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNMSUB_VX_MF4_MASK (6895) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNMSUB_VX_MF8 (6896) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNMSUB_VX_MF8_MASK (6897) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRA_WI_M1 (6898) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRA_WI_M1_MASK (6899) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRA_WI_M2 (6900) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRA_WI_M2_MASK (6901) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRA_WI_M4 (6902) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRA_WI_M4_MASK (6903) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRA_WI_MF2 (6904) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRA_WI_MF2_MASK (6905) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRA_WI_MF4 (6906) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRA_WI_MF4_MASK (6907) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRA_WI_MF8 (6908) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRA_WI_MF8_MASK (6909) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRA_WV_M1 (6910) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRA_WV_M1_MASK (6911) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRA_WV_M2 (6912) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRA_WV_M2_MASK (6913) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRA_WV_M4 (6914) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRA_WV_M4_MASK (6915) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRA_WV_MF2 (6916) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRA_WV_MF2_MASK (6917) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRA_WV_MF4 (6918) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRA_WV_MF4_MASK (6919) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRA_WV_MF8 (6920) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRA_WV_MF8_MASK (6921) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRA_WX_M1 (6922) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRA_WX_M1_MASK (6923) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRA_WX_M2 (6924) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRA_WX_M2_MASK (6925) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRA_WX_M4 (6926) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRA_WX_M4_MASK (6927) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRA_WX_MF2 (6928) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRA_WX_MF2_MASK (6929) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRA_WX_MF4 (6930) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRA_WX_MF4_MASK (6931) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRA_WX_MF8 (6932) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRA_WX_MF8_MASK (6933) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRL_WI_M1 (6934) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRL_WI_M1_MASK (6935) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRL_WI_M2 (6936) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRL_WI_M2_MASK (6937) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRL_WI_M4 (6938) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRL_WI_M4_MASK (6939) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRL_WI_MF2 (6940) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRL_WI_MF2_MASK (6941) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRL_WI_MF4 (6942) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRL_WI_MF4_MASK (6943) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRL_WI_MF8 (6944) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRL_WI_MF8_MASK (6945) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRL_WV_M1 (6946) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRL_WV_M1_MASK (6947) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRL_WV_M2 (6948) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRL_WV_M2_MASK (6949) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRL_WV_M4 (6950) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRL_WV_M4_MASK (6951) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRL_WV_MF2 (6952) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRL_WV_MF2_MASK (6953) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRL_WV_MF4 (6954) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRL_WV_MF4_MASK (6955) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRL_WV_MF8 (6956) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRL_WV_MF8_MASK (6957) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRL_WX_M1 (6958) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRL_WX_M1_MASK (6959) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRL_WX_M2 (6960) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRL_WX_M2_MASK (6961) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRL_WX_M4 (6962) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRL_WX_M4_MASK (6963) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRL_WX_MF2 (6964) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRL_WX_MF2_MASK (6965) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRL_WX_MF4 (6966) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRL_WX_MF4_MASK (6967) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRL_WX_MF8 (6968) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVNSRL_WX_MF8_MASK (6969) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVOR_VI_M1 (6970) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVOR_VI_M1_MASK (6971) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVOR_VI_M2 (6972) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVOR_VI_M2_MASK (6973) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVOR_VI_M4 (6974) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVOR_VI_M4_MASK (6975) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVOR_VI_M8 (6976) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVOR_VI_M8_MASK (6977) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVOR_VI_MF2 (6978) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVOR_VI_MF2_MASK (6979) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVOR_VI_MF4 (6980) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVOR_VI_MF4_MASK (6981) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVOR_VI_MF8 (6982) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVOR_VI_MF8_MASK (6983) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVOR_VV_M1 (6984) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVOR_VV_M1_MASK (6985) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVOR_VV_M2 (6986) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVOR_VV_M2_MASK (6987) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVOR_VV_M4 (6988) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVOR_VV_M4_MASK (6989) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVOR_VV_M8 (6990) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVOR_VV_M8_MASK (6991) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVOR_VV_MF2 (6992) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVOR_VV_MF2_MASK (6993) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVOR_VV_MF4 (6994) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVOR_VV_MF4_MASK (6995) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVOR_VV_MF8 (6996) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVOR_VV_MF8_MASK (6997) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVOR_VX_M1 (6998) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVOR_VX_M1_MASK (6999) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVOR_VX_M2 (7000) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVOR_VX_M2_MASK (7001) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVOR_VX_M4 (7002) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVOR_VX_M4_MASK (7003) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVOR_VX_M8 (7004) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVOR_VX_M8_MASK (7005) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVOR_VX_MF2 (7006) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVOR_VX_MF2_MASK (7007) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVOR_VX_MF4 (7008) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVOR_VX_MF4_MASK (7009) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVOR_VX_MF8 (7010) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVOR_VX_MF8_MASK (7011) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVQMACCSU_2x8x2_M1 (7012) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVQMACCSU_2x8x2_M2 (7013) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVQMACCSU_2x8x2_M4 (7014) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVQMACCSU_2x8x2_M8 (7015) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVQMACCSU_4x8x4_M1 (7016) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVQMACCSU_4x8x4_M2 (7017) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVQMACCSU_4x8x4_M4 (7018) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVQMACCSU_4x8x4_MF2 (7019) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVQMACCUS_2x8x2_M1 (7020) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVQMACCUS_2x8x2_M2 (7021) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVQMACCUS_2x8x2_M4 (7022) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVQMACCUS_2x8x2_M8 (7023) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVQMACCUS_4x8x4_M1 (7024) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVQMACCUS_4x8x4_M2 (7025) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVQMACCUS_4x8x4_M4 (7026) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVQMACCUS_4x8x4_MF2 (7027) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVQMACCU_2x8x2_M1 (7028) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVQMACCU_2x8x2_M2 (7029) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVQMACCU_2x8x2_M4 (7030) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVQMACCU_2x8x2_M8 (7031) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVQMACCU_4x8x4_M1 (7032) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVQMACCU_4x8x4_M2 (7033) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVQMACCU_4x8x4_M4 (7034) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVQMACCU_4x8x4_MF2 (7035) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVQMACC_2x8x2_M1 (7036) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVQMACC_2x8x2_M2 (7037) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVQMACC_2x8x2_M4 (7038) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVQMACC_2x8x2_M8 (7039) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVQMACC_4x8x4_M1 (7040) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVQMACC_4x8x4_M2 (7041) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVQMACC_4x8x4_M4 (7042) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVQMACC_4x8x4_MF2 (7043) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDAND_VS_M1_E16 (7044) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDAND_VS_M1_E16_MASK (7045) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDAND_VS_M1_E32 (7046) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDAND_VS_M1_E32_MASK (7047) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDAND_VS_M1_E64 (7048) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDAND_VS_M1_E64_MASK (7049) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDAND_VS_M1_E8 (7050) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDAND_VS_M1_E8_MASK (7051) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDAND_VS_M2_E16 (7052) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDAND_VS_M2_E16_MASK (7053) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDAND_VS_M2_E32 (7054) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDAND_VS_M2_E32_MASK (7055) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDAND_VS_M2_E64 (7056) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDAND_VS_M2_E64_MASK (7057) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDAND_VS_M2_E8 (7058) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDAND_VS_M2_E8_MASK (7059) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDAND_VS_M4_E16 (7060) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDAND_VS_M4_E16_MASK (7061) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDAND_VS_M4_E32 (7062) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDAND_VS_M4_E32_MASK (7063) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDAND_VS_M4_E64 (7064) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDAND_VS_M4_E64_MASK (7065) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDAND_VS_M4_E8 (7066) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDAND_VS_M4_E8_MASK (7067) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDAND_VS_M8_E16 (7068) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDAND_VS_M8_E16_MASK (7069) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDAND_VS_M8_E32 (7070) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDAND_VS_M8_E32_MASK (7071) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDAND_VS_M8_E64 (7072) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDAND_VS_M8_E64_MASK (7073) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDAND_VS_M8_E8 (7074) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDAND_VS_M8_E8_MASK (7075) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDAND_VS_MF2_E16 (7076) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDAND_VS_MF2_E16_MASK (7077) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDAND_VS_MF2_E32 (7078) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDAND_VS_MF2_E32_MASK (7079) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDAND_VS_MF2_E8 (7080) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDAND_VS_MF2_E8_MASK (7081) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDAND_VS_MF4_E16 (7082) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDAND_VS_MF4_E16_MASK (7083) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDAND_VS_MF4_E8 (7084) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDAND_VS_MF4_E8_MASK (7085) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDAND_VS_MF8_E8 (7086) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDAND_VS_MF8_E8_MASK (7087) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAXU_VS_M1_E16 (7088) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAXU_VS_M1_E16_MASK (7089) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAXU_VS_M1_E32 (7090) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAXU_VS_M1_E32_MASK (7091) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAXU_VS_M1_E64 (7092) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAXU_VS_M1_E64_MASK (7093) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAXU_VS_M1_E8 (7094) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAXU_VS_M1_E8_MASK (7095) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAXU_VS_M2_E16 (7096) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAXU_VS_M2_E16_MASK (7097) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAXU_VS_M2_E32 (7098) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAXU_VS_M2_E32_MASK (7099) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAXU_VS_M2_E64 (7100) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAXU_VS_M2_E64_MASK (7101) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAXU_VS_M2_E8 (7102) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAXU_VS_M2_E8_MASK (7103) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAXU_VS_M4_E16 (7104) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAXU_VS_M4_E16_MASK (7105) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAXU_VS_M4_E32 (7106) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAXU_VS_M4_E32_MASK (7107) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAXU_VS_M4_E64 (7108) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAXU_VS_M4_E64_MASK (7109) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAXU_VS_M4_E8 (7110) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAXU_VS_M4_E8_MASK (7111) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAXU_VS_M8_E16 (7112) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAXU_VS_M8_E16_MASK (7113) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAXU_VS_M8_E32 (7114) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAXU_VS_M8_E32_MASK (7115) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAXU_VS_M8_E64 (7116) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAXU_VS_M8_E64_MASK (7117) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAXU_VS_M8_E8 (7118) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAXU_VS_M8_E8_MASK (7119) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAXU_VS_MF2_E16 (7120) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAXU_VS_MF2_E16_MASK (7121) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAXU_VS_MF2_E32 (7122) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAXU_VS_MF2_E32_MASK (7123) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAXU_VS_MF2_E8 (7124) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAXU_VS_MF2_E8_MASK (7125) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAXU_VS_MF4_E16 (7126) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAXU_VS_MF4_E16_MASK (7127) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAXU_VS_MF4_E8 (7128) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAXU_VS_MF4_E8_MASK (7129) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAXU_VS_MF8_E8 (7130) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAXU_VS_MF8_E8_MASK (7131) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAX_VS_M1_E16 (7132) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAX_VS_M1_E16_MASK (7133) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAX_VS_M1_E32 (7134) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAX_VS_M1_E32_MASK (7135) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAX_VS_M1_E64 (7136) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAX_VS_M1_E64_MASK (7137) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAX_VS_M1_E8 (7138) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAX_VS_M1_E8_MASK (7139) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAX_VS_M2_E16 (7140) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAX_VS_M2_E16_MASK (7141) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAX_VS_M2_E32 (7142) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAX_VS_M2_E32_MASK (7143) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAX_VS_M2_E64 (7144) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAX_VS_M2_E64_MASK (7145) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAX_VS_M2_E8 (7146) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAX_VS_M2_E8_MASK (7147) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAX_VS_M4_E16 (7148) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAX_VS_M4_E16_MASK (7149) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAX_VS_M4_E32 (7150) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAX_VS_M4_E32_MASK (7151) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAX_VS_M4_E64 (7152) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAX_VS_M4_E64_MASK (7153) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAX_VS_M4_E8 (7154) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAX_VS_M4_E8_MASK (7155) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAX_VS_M8_E16 (7156) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAX_VS_M8_E16_MASK (7157) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAX_VS_M8_E32 (7158) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAX_VS_M8_E32_MASK (7159) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAX_VS_M8_E64 (7160) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAX_VS_M8_E64_MASK (7161) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAX_VS_M8_E8 (7162) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAX_VS_M8_E8_MASK (7163) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAX_VS_MF2_E16 (7164) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAX_VS_MF2_E16_MASK (7165) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAX_VS_MF2_E32 (7166) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAX_VS_MF2_E32_MASK (7167) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAX_VS_MF2_E8 (7168) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAX_VS_MF2_E8_MASK (7169) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAX_VS_MF4_E16 (7170) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAX_VS_MF4_E16_MASK (7171) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAX_VS_MF4_E8 (7172) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAX_VS_MF4_E8_MASK (7173) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAX_VS_MF8_E8 (7174) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMAX_VS_MF8_E8_MASK (7175) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMINU_VS_M1_E16 (7176) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMINU_VS_M1_E16_MASK (7177) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMINU_VS_M1_E32 (7178) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMINU_VS_M1_E32_MASK (7179) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMINU_VS_M1_E64 (7180) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMINU_VS_M1_E64_MASK (7181) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMINU_VS_M1_E8 (7182) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMINU_VS_M1_E8_MASK (7183) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMINU_VS_M2_E16 (7184) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMINU_VS_M2_E16_MASK (7185) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMINU_VS_M2_E32 (7186) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMINU_VS_M2_E32_MASK (7187) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMINU_VS_M2_E64 (7188) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMINU_VS_M2_E64_MASK (7189) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMINU_VS_M2_E8 (7190) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMINU_VS_M2_E8_MASK (7191) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMINU_VS_M4_E16 (7192) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMINU_VS_M4_E16_MASK (7193) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMINU_VS_M4_E32 (7194) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMINU_VS_M4_E32_MASK (7195) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMINU_VS_M4_E64 (7196) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMINU_VS_M4_E64_MASK (7197) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMINU_VS_M4_E8 (7198) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMINU_VS_M4_E8_MASK (7199) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMINU_VS_M8_E16 (7200) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMINU_VS_M8_E16_MASK (7201) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMINU_VS_M8_E32 (7202) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMINU_VS_M8_E32_MASK (7203) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMINU_VS_M8_E64 (7204) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMINU_VS_M8_E64_MASK (7205) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMINU_VS_M8_E8 (7206) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMINU_VS_M8_E8_MASK (7207) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMINU_VS_MF2_E16 (7208) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMINU_VS_MF2_E16_MASK (7209) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMINU_VS_MF2_E32 (7210) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMINU_VS_MF2_E32_MASK (7211) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMINU_VS_MF2_E8 (7212) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMINU_VS_MF2_E8_MASK (7213) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMINU_VS_MF4_E16 (7214) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMINU_VS_MF4_E16_MASK (7215) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMINU_VS_MF4_E8 (7216) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMINU_VS_MF4_E8_MASK (7217) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMINU_VS_MF8_E8 (7218) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMINU_VS_MF8_E8_MASK (7219) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMIN_VS_M1_E16 (7220) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMIN_VS_M1_E16_MASK (7221) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMIN_VS_M1_E32 (7222) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMIN_VS_M1_E32_MASK (7223) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMIN_VS_M1_E64 (7224) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMIN_VS_M1_E64_MASK (7225) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMIN_VS_M1_E8 (7226) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMIN_VS_M1_E8_MASK (7227) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMIN_VS_M2_E16 (7228) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMIN_VS_M2_E16_MASK (7229) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMIN_VS_M2_E32 (7230) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMIN_VS_M2_E32_MASK (7231) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMIN_VS_M2_E64 (7232) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMIN_VS_M2_E64_MASK (7233) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMIN_VS_M2_E8 (7234) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMIN_VS_M2_E8_MASK (7235) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMIN_VS_M4_E16 (7236) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMIN_VS_M4_E16_MASK (7237) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMIN_VS_M4_E32 (7238) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMIN_VS_M4_E32_MASK (7239) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMIN_VS_M4_E64 (7240) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMIN_VS_M4_E64_MASK (7241) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMIN_VS_M4_E8 (7242) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMIN_VS_M4_E8_MASK (7243) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMIN_VS_M8_E16 (7244) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMIN_VS_M8_E16_MASK (7245) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMIN_VS_M8_E32 (7246) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMIN_VS_M8_E32_MASK (7247) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMIN_VS_M8_E64 (7248) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMIN_VS_M8_E64_MASK (7249) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMIN_VS_M8_E8 (7250) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMIN_VS_M8_E8_MASK (7251) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMIN_VS_MF2_E16 (7252) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMIN_VS_MF2_E16_MASK (7253) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMIN_VS_MF2_E32 (7254) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMIN_VS_MF2_E32_MASK (7255) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMIN_VS_MF2_E8 (7256) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMIN_VS_MF2_E8_MASK (7257) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMIN_VS_MF4_E16 (7258) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMIN_VS_MF4_E16_MASK (7259) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMIN_VS_MF4_E8 (7260) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMIN_VS_MF4_E8_MASK (7261) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMIN_VS_MF8_E8 (7262) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDMIN_VS_MF8_E8_MASK (7263) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDOR_VS_M1_E16 (7264) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDOR_VS_M1_E16_MASK (7265) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDOR_VS_M1_E32 (7266) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDOR_VS_M1_E32_MASK (7267) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDOR_VS_M1_E64 (7268) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDOR_VS_M1_E64_MASK (7269) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDOR_VS_M1_E8 (7270) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDOR_VS_M1_E8_MASK (7271) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDOR_VS_M2_E16 (7272) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDOR_VS_M2_E16_MASK (7273) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDOR_VS_M2_E32 (7274) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDOR_VS_M2_E32_MASK (7275) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDOR_VS_M2_E64 (7276) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDOR_VS_M2_E64_MASK (7277) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDOR_VS_M2_E8 (7278) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDOR_VS_M2_E8_MASK (7279) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDOR_VS_M4_E16 (7280) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDOR_VS_M4_E16_MASK (7281) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDOR_VS_M4_E32 (7282) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDOR_VS_M4_E32_MASK (7283) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDOR_VS_M4_E64 (7284) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDOR_VS_M4_E64_MASK (7285) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDOR_VS_M4_E8 (7286) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDOR_VS_M4_E8_MASK (7287) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDOR_VS_M8_E16 (7288) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDOR_VS_M8_E16_MASK (7289) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDOR_VS_M8_E32 (7290) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDOR_VS_M8_E32_MASK (7291) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDOR_VS_M8_E64 (7292) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDOR_VS_M8_E64_MASK (7293) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDOR_VS_M8_E8 (7294) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDOR_VS_M8_E8_MASK (7295) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDOR_VS_MF2_E16 (7296) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDOR_VS_MF2_E16_MASK (7297) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDOR_VS_MF2_E32 (7298) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDOR_VS_MF2_E32_MASK (7299) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDOR_VS_MF2_E8 (7300) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDOR_VS_MF2_E8_MASK (7301) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDOR_VS_MF4_E16 (7302) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDOR_VS_MF4_E16_MASK (7303) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDOR_VS_MF4_E8 (7304) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDOR_VS_MF4_E8_MASK (7305) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDOR_VS_MF8_E8 (7306) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDOR_VS_MF8_E8_MASK (7307) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDSUM_VS_M1_E16 (7308) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDSUM_VS_M1_E16_MASK (7309) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDSUM_VS_M1_E32 (7310) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDSUM_VS_M1_E32_MASK (7311) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDSUM_VS_M1_E64 (7312) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDSUM_VS_M1_E64_MASK (7313) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDSUM_VS_M1_E8 (7314) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDSUM_VS_M1_E8_MASK (7315) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDSUM_VS_M2_E16 (7316) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDSUM_VS_M2_E16_MASK (7317) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDSUM_VS_M2_E32 (7318) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDSUM_VS_M2_E32_MASK (7319) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDSUM_VS_M2_E64 (7320) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDSUM_VS_M2_E64_MASK (7321) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDSUM_VS_M2_E8 (7322) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDSUM_VS_M2_E8_MASK (7323) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDSUM_VS_M4_E16 (7324) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDSUM_VS_M4_E16_MASK (7325) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDSUM_VS_M4_E32 (7326) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDSUM_VS_M4_E32_MASK (7327) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDSUM_VS_M4_E64 (7328) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDSUM_VS_M4_E64_MASK (7329) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDSUM_VS_M4_E8 (7330) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDSUM_VS_M4_E8_MASK (7331) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDSUM_VS_M8_E16 (7332) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDSUM_VS_M8_E16_MASK (7333) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDSUM_VS_M8_E32 (7334) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDSUM_VS_M8_E32_MASK (7335) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDSUM_VS_M8_E64 (7336) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDSUM_VS_M8_E64_MASK (7337) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDSUM_VS_M8_E8 (7338) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDSUM_VS_M8_E8_MASK (7339) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDSUM_VS_MF2_E16 (7340) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDSUM_VS_MF2_E16_MASK (7341) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDSUM_VS_MF2_E32 (7342) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDSUM_VS_MF2_E32_MASK (7343) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDSUM_VS_MF2_E8 (7344) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDSUM_VS_MF2_E8_MASK (7345) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDSUM_VS_MF4_E16 (7346) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDSUM_VS_MF4_E16_MASK (7347) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDSUM_VS_MF4_E8 (7348) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDSUM_VS_MF4_E8_MASK (7349) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDSUM_VS_MF8_E8 (7350) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDSUM_VS_MF8_E8_MASK (7351) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDXOR_VS_M1_E16 (7352) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDXOR_VS_M1_E16_MASK (7353) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDXOR_VS_M1_E32 (7354) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDXOR_VS_M1_E32_MASK (7355) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDXOR_VS_M1_E64 (7356) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDXOR_VS_M1_E64_MASK (7357) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDXOR_VS_M1_E8 (7358) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDXOR_VS_M1_E8_MASK (7359) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDXOR_VS_M2_E16 (7360) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDXOR_VS_M2_E16_MASK (7361) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDXOR_VS_M2_E32 (7362) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDXOR_VS_M2_E32_MASK (7363) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDXOR_VS_M2_E64 (7364) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDXOR_VS_M2_E64_MASK (7365) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDXOR_VS_M2_E8 (7366) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDXOR_VS_M2_E8_MASK (7367) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDXOR_VS_M4_E16 (7368) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDXOR_VS_M4_E16_MASK (7369) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDXOR_VS_M4_E32 (7370) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDXOR_VS_M4_E32_MASK (7371) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDXOR_VS_M4_E64 (7372) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDXOR_VS_M4_E64_MASK (7373) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDXOR_VS_M4_E8 (7374) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDXOR_VS_M4_E8_MASK (7375) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDXOR_VS_M8_E16 (7376) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDXOR_VS_M8_E16_MASK (7377) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDXOR_VS_M8_E32 (7378) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDXOR_VS_M8_E32_MASK (7379) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDXOR_VS_M8_E64 (7380) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDXOR_VS_M8_E64_MASK (7381) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDXOR_VS_M8_E8 (7382) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDXOR_VS_M8_E8_MASK (7383) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDXOR_VS_MF2_E16 (7384) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDXOR_VS_MF2_E16_MASK (7385) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDXOR_VS_MF2_E32 (7386) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDXOR_VS_MF2_E32_MASK (7387) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDXOR_VS_MF2_E8 (7388) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDXOR_VS_MF2_E8_MASK (7389) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDXOR_VS_MF4_E16 (7390) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDXOR_VS_MF4_E16_MASK (7391) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDXOR_VS_MF4_E8 (7392) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDXOR_VS_MF4_E8_MASK (7393) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDXOR_VS_MF8_E8 (7394) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREDXOR_VS_MF8_E8_MASK (7395) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRELOAD2_M1 (7396) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRELOAD2_M2 (7397) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRELOAD2_M4 (7398) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRELOAD2_MF2 (7399) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRELOAD2_MF4 (7400) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRELOAD2_MF8 (7401) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRELOAD3_M1 (7402) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRELOAD3_M2 (7403) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRELOAD3_MF2 (7404) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRELOAD3_MF4 (7405) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRELOAD3_MF8 (7406) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRELOAD4_M1 (7407) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRELOAD4_M2 (7408) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRELOAD4_MF2 (7409) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRELOAD4_MF4 (7410) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRELOAD4_MF8 (7411) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRELOAD5_M1 (7412) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRELOAD5_MF2 (7413) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRELOAD5_MF4 (7414) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRELOAD5_MF8 (7415) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRELOAD6_M1 (7416) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRELOAD6_MF2 (7417) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRELOAD6_MF4 (7418) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRELOAD6_MF8 (7419) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRELOAD7_M1 (7420) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRELOAD7_MF2 (7421) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRELOAD7_MF4 (7422) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRELOAD7_MF8 (7423) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRELOAD8_M1 (7424) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRELOAD8_MF2 (7425) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRELOAD8_MF4 (7426) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRELOAD8_MF8 (7427) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VV_M1_E16 (7428) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VV_M1_E16_MASK (7429) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VV_M1_E32 (7430) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VV_M1_E32_MASK (7431) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VV_M1_E64 (7432) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VV_M1_E64_MASK (7433) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VV_M1_E8 (7434) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VV_M1_E8_MASK (7435) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VV_M2_E16 (7436) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VV_M2_E16_MASK (7437) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VV_M2_E32 (7438) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VV_M2_E32_MASK (7439) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VV_M2_E64 (7440) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VV_M2_E64_MASK (7441) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VV_M2_E8 (7442) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VV_M2_E8_MASK (7443) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VV_M4_E16 (7444) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VV_M4_E16_MASK (7445) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VV_M4_E32 (7446) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VV_M4_E32_MASK (7447) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VV_M4_E64 (7448) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VV_M4_E64_MASK (7449) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VV_M4_E8 (7450) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VV_M4_E8_MASK (7451) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VV_M8_E16 (7452) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VV_M8_E16_MASK (7453) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VV_M8_E32 (7454) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VV_M8_E32_MASK (7455) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VV_M8_E64 (7456) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VV_M8_E64_MASK (7457) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VV_M8_E8 (7458) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VV_M8_E8_MASK (7459) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VV_MF2_E16 (7460) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VV_MF2_E16_MASK (7461) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VV_MF2_E32 (7462) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VV_MF2_E32_MASK (7463) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VV_MF2_E8 (7464) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VV_MF2_E8_MASK (7465) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VV_MF4_E16 (7466) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VV_MF4_E16_MASK (7467) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VV_MF4_E8 (7468) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VV_MF4_E8_MASK (7469) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VV_MF8_E8 (7470) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VV_MF8_E8_MASK (7471) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VX_M1_E16 (7472) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VX_M1_E16_MASK (7473) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VX_M1_E32 (7474) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VX_M1_E32_MASK (7475) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VX_M1_E64 (7476) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VX_M1_E64_MASK (7477) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VX_M1_E8 (7478) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VX_M1_E8_MASK (7479) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VX_M2_E16 (7480) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VX_M2_E16_MASK (7481) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VX_M2_E32 (7482) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VX_M2_E32_MASK (7483) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VX_M2_E64 (7484) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VX_M2_E64_MASK (7485) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VX_M2_E8 (7486) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VX_M2_E8_MASK (7487) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VX_M4_E16 (7488) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VX_M4_E16_MASK (7489) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VX_M4_E32 (7490) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VX_M4_E32_MASK (7491) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VX_M4_E64 (7492) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VX_M4_E64_MASK (7493) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VX_M4_E8 (7494) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VX_M4_E8_MASK (7495) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VX_M8_E16 (7496) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VX_M8_E16_MASK (7497) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VX_M8_E32 (7498) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VX_M8_E32_MASK (7499) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VX_M8_E64 (7500) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VX_M8_E64_MASK (7501) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VX_M8_E8 (7502) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VX_M8_E8_MASK (7503) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VX_MF2_E16 (7504) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VX_MF2_E16_MASK (7505) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VX_MF2_E32 (7506) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VX_MF2_E32_MASK (7507) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VX_MF2_E8 (7508) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VX_MF2_E8_MASK (7509) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VX_MF4_E16 (7510) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VX_MF4_E16_MASK (7511) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VX_MF4_E8 (7512) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VX_MF4_E8_MASK (7513) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VX_MF8_E8 (7514) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREMU_VX_MF8_E8_MASK (7515) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VV_M1_E16 (7516) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VV_M1_E16_MASK (7517) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VV_M1_E32 (7518) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VV_M1_E32_MASK (7519) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VV_M1_E64 (7520) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VV_M1_E64_MASK (7521) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VV_M1_E8 (7522) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VV_M1_E8_MASK (7523) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VV_M2_E16 (7524) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VV_M2_E16_MASK (7525) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VV_M2_E32 (7526) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VV_M2_E32_MASK (7527) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VV_M2_E64 (7528) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VV_M2_E64_MASK (7529) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VV_M2_E8 (7530) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VV_M2_E8_MASK (7531) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VV_M4_E16 (7532) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VV_M4_E16_MASK (7533) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VV_M4_E32 (7534) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VV_M4_E32_MASK (7535) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VV_M4_E64 (7536) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VV_M4_E64_MASK (7537) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VV_M4_E8 (7538) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VV_M4_E8_MASK (7539) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VV_M8_E16 (7540) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VV_M8_E16_MASK (7541) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VV_M8_E32 (7542) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VV_M8_E32_MASK (7543) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VV_M8_E64 (7544) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VV_M8_E64_MASK (7545) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VV_M8_E8 (7546) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VV_M8_E8_MASK (7547) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VV_MF2_E16 (7548) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VV_MF2_E16_MASK (7549) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VV_MF2_E32 (7550) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VV_MF2_E32_MASK (7551) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VV_MF2_E8 (7552) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VV_MF2_E8_MASK (7553) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VV_MF4_E16 (7554) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VV_MF4_E16_MASK (7555) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VV_MF4_E8 (7556) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VV_MF4_E8_MASK (7557) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VV_MF8_E8 (7558) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VV_MF8_E8_MASK (7559) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VX_M1_E16 (7560) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VX_M1_E16_MASK (7561) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VX_M1_E32 (7562) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VX_M1_E32_MASK (7563) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VX_M1_E64 (7564) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VX_M1_E64_MASK (7565) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VX_M1_E8 (7566) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VX_M1_E8_MASK (7567) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VX_M2_E16 (7568) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VX_M2_E16_MASK (7569) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VX_M2_E32 (7570) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VX_M2_E32_MASK (7571) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VX_M2_E64 (7572) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VX_M2_E64_MASK (7573) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VX_M2_E8 (7574) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VX_M2_E8_MASK (7575) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VX_M4_E16 (7576) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VX_M4_E16_MASK (7577) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VX_M4_E32 (7578) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VX_M4_E32_MASK (7579) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VX_M4_E64 (7580) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VX_M4_E64_MASK (7581) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VX_M4_E8 (7582) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VX_M4_E8_MASK (7583) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VX_M8_E16 (7584) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VX_M8_E16_MASK (7585) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VX_M8_E32 (7586) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VX_M8_E32_MASK (7587) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VX_M8_E64 (7588) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VX_M8_E64_MASK (7589) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VX_M8_E8 (7590) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VX_M8_E8_MASK (7591) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VX_MF2_E16 (7592) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VX_MF2_E16_MASK (7593) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VX_MF2_E32 (7594) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VX_MF2_E32_MASK (7595) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VX_MF2_E8 (7596) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VX_MF2_E8_MASK (7597) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VX_MF4_E16 (7598) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VX_MF4_E16_MASK (7599) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VX_MF4_E8 (7600) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VX_MF4_E8_MASK (7601) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VX_MF8_E8 (7602) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREM_VX_MF8_E8_MASK (7603) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREV8_V_M1 (7604) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREV8_V_M1_MASK (7605) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREV8_V_M2 (7606) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREV8_V_M2_MASK (7607) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREV8_V_M4 (7608) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREV8_V_M4_MASK (7609) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREV8_V_M8 (7610) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREV8_V_M8_MASK (7611) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREV8_V_MF2 (7612) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREV8_V_MF2_MASK (7613) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREV8_V_MF4 (7614) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREV8_V_MF4_MASK (7615) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREV8_V_MF8 (7616) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVREV8_V_MF8_MASK (7617) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M1_E16_M1 (7618) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M1_E16_M1_MASK (7619) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M1_E16_M2 (7620) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M1_E16_M2_MASK (7621) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M1_E16_MF2 (7622) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M1_E16_MF2_MASK (7623) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M1_E16_MF4 (7624) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M1_E16_MF4_MASK (7625) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M1_E32_M1 (7626) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M1_E32_M1_MASK (7627) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M1_E32_M2 (7628) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M1_E32_M2_MASK (7629) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M1_E32_MF2 (7630) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M1_E32_MF2_MASK (7631) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M1_E32_MF4 (7632) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M1_E32_MF4_MASK (7633) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M1_E64_M1 (7634) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M1_E64_M1_MASK (7635) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M1_E64_M2 (7636) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M1_E64_M2_MASK (7637) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M1_E64_MF2 (7638) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M1_E64_MF2_MASK (7639) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M1_E64_MF4 (7640) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M1_E64_MF4_MASK (7641) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M1_E8_M1 (7642) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M1_E8_M1_MASK (7643) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M1_E8_M2 (7644) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M1_E8_M2_MASK (7645) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M1_E8_MF2 (7646) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M1_E8_MF2_MASK (7647) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M1_E8_MF4 (7648) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M1_E8_MF4_MASK (7649) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M2_E16_M1 (7650) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M2_E16_M1_MASK (7651) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M2_E16_M2 (7652) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M2_E16_M2_MASK (7653) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M2_E16_M4 (7654) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M2_E16_M4_MASK (7655) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M2_E16_MF2 (7656) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M2_E16_MF2_MASK (7657) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M2_E32_M1 (7658) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M2_E32_M1_MASK (7659) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M2_E32_M2 (7660) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M2_E32_M2_MASK (7661) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M2_E32_M4 (7662) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M2_E32_M4_MASK (7663) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M2_E32_MF2 (7664) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M2_E32_MF2_MASK (7665) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M2_E64_M1 (7666) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M2_E64_M1_MASK (7667) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M2_E64_M2 (7668) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M2_E64_M2_MASK (7669) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M2_E64_M4 (7670) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M2_E64_M4_MASK (7671) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M2_E64_MF2 (7672) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M2_E64_MF2_MASK (7673) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M2_E8_M1 (7674) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M2_E8_M1_MASK (7675) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M2_E8_M2 (7676) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M2_E8_M2_MASK (7677) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M2_E8_M4 (7678) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M2_E8_M4_MASK (7679) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M2_E8_MF2 (7680) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M2_E8_MF2_MASK (7681) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M4_E16_M1 (7682) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M4_E16_M1_MASK (7683) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M4_E16_M2 (7684) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M4_E16_M2_MASK (7685) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M4_E16_M4 (7686) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M4_E16_M4_MASK (7687) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M4_E16_M8 (7688) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M4_E16_M8_MASK (7689) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M4_E32_M1 (7690) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M4_E32_M1_MASK (7691) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M4_E32_M2 (7692) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M4_E32_M2_MASK (7693) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M4_E32_M4 (7694) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M4_E32_M4_MASK (7695) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M4_E32_M8 (7696) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M4_E32_M8_MASK (7697) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M4_E64_M1 (7698) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M4_E64_M1_MASK (7699) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M4_E64_M2 (7700) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M4_E64_M2_MASK (7701) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M4_E64_M4 (7702) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M4_E64_M4_MASK (7703) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M4_E64_M8 (7704) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M4_E64_M8_MASK (7705) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M4_E8_M1 (7706) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M4_E8_M1_MASK (7707) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M4_E8_M2 (7708) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M4_E8_M2_MASK (7709) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M4_E8_M4 (7710) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M4_E8_M4_MASK (7711) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M4_E8_M8 (7712) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M4_E8_M8_MASK (7713) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M8_E16_M2 (7714) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M8_E16_M2_MASK (7715) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M8_E16_M4 (7716) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M8_E16_M4_MASK (7717) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M8_E16_M8 (7718) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M8_E16_M8_MASK (7719) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M8_E32_M2 (7720) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M8_E32_M2_MASK (7721) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M8_E32_M4 (7722) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M8_E32_M4_MASK (7723) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M8_E32_M8 (7724) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M8_E32_M8_MASK (7725) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M8_E64_M2 (7726) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M8_E64_M2_MASK (7727) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M8_E64_M4 (7728) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M8_E64_M4_MASK (7729) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M8_E64_M8 (7730) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M8_E64_M8_MASK (7731) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M8_E8_M2 (7732) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M8_E8_M2_MASK (7733) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M8_E8_M4 (7734) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M8_E8_M4_MASK (7735) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M8_E8_M8 (7736) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_M8_E8_M8_MASK (7737) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_MF2_E16_M1 (7738) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_MF2_E16_M1_MASK (7739) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_MF2_E16_MF2 (7740) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_MF2_E16_MF2_MASK (7741) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_MF2_E16_MF4 (7742) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_MF2_E16_MF4_MASK (7743) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_MF2_E16_MF8 (7744) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_MF2_E16_MF8_MASK (7745) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_MF2_E32_M1 (7746) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_MF2_E32_M1_MASK (7747) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_MF2_E32_MF2 (7748) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_MF2_E32_MF2_MASK (7749) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_MF2_E32_MF4 (7750) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_MF2_E32_MF4_MASK (7751) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_MF2_E32_MF8 (7752) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_MF2_E32_MF8_MASK (7753) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_MF2_E8_M1 (7754) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_MF2_E8_M1_MASK (7755) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_MF2_E8_MF2 (7756) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_MF2_E8_MF2_MASK (7757) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_MF2_E8_MF4 (7758) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_MF2_E8_MF4_MASK (7759) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_MF2_E8_MF8 (7760) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_MF2_E8_MF8_MASK (7761) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_MF4_E16_MF2 (7762) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_MF4_E16_MF2_MASK (7763) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_MF4_E16_MF4 (7764) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_MF4_E16_MF4_MASK (7765) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_MF4_E16_MF8 (7766) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_MF4_E16_MF8_MASK (7767) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_MF4_E8_MF2 (7768) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_MF4_E8_MF2_MASK (7769) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_MF4_E8_MF4 (7770) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_MF4_E8_MF4_MASK (7771) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_MF4_E8_MF8 (7772) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_MF4_E8_MF8_MASK (7773) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_MF8_E8_MF4 (7774) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_MF8_E8_MF4_MASK (7775) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_MF8_E8_MF8 (7776) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHEREI16_VV_MF8_E8_MF8_MASK (7777) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VI_M1 (7778) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VI_M1_MASK (7779) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VI_M2 (7780) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VI_M2_MASK (7781) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VI_M4 (7782) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VI_M4_MASK (7783) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VI_M8 (7784) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VI_M8_MASK (7785) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VI_MF2 (7786) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VI_MF2_MASK (7787) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VI_MF4 (7788) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VI_MF4_MASK (7789) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VI_MF8 (7790) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VI_MF8_MASK (7791) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VV_M1_E16 (7792) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VV_M1_E16_MASK (7793) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VV_M1_E32 (7794) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VV_M1_E32_MASK (7795) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VV_M1_E64 (7796) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VV_M1_E64_MASK (7797) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VV_M1_E8 (7798) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VV_M1_E8_MASK (7799) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VV_M2_E16 (7800) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VV_M2_E16_MASK (7801) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VV_M2_E32 (7802) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VV_M2_E32_MASK (7803) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VV_M2_E64 (7804) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VV_M2_E64_MASK (7805) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VV_M2_E8 (7806) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VV_M2_E8_MASK (7807) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VV_M4_E16 (7808) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VV_M4_E16_MASK (7809) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VV_M4_E32 (7810) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VV_M4_E32_MASK (7811) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VV_M4_E64 (7812) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VV_M4_E64_MASK (7813) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VV_M4_E8 (7814) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VV_M4_E8_MASK (7815) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VV_M8_E16 (7816) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VV_M8_E16_MASK (7817) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VV_M8_E32 (7818) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VV_M8_E32_MASK (7819) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VV_M8_E64 (7820) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VV_M8_E64_MASK (7821) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VV_M8_E8 (7822) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VV_M8_E8_MASK (7823) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VV_MF2_E16 (7824) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VV_MF2_E16_MASK (7825) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VV_MF2_E32 (7826) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VV_MF2_E32_MASK (7827) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VV_MF2_E8 (7828) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VV_MF2_E8_MASK (7829) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VV_MF4_E16 (7830) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VV_MF4_E16_MASK (7831) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VV_MF4_E8 (7832) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VV_MF4_E8_MASK (7833) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VV_MF8_E8 (7834) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VV_MF8_E8_MASK (7835) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VX_M1 (7836) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VX_M1_MASK (7837) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VX_M2 (7838) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VX_M2_MASK (7839) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VX_M4 (7840) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VX_M4_MASK (7841) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VX_M8 (7842) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VX_M8_MASK (7843) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VX_MF2 (7844) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VX_MF2_MASK (7845) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VX_MF4 (7846) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VX_MF4_MASK (7847) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VX_MF8 (7848) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRGATHER_VX_MF8_MASK (7849) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROL_VV_M1 (7850) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROL_VV_M1_MASK (7851) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROL_VV_M2 (7852) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROL_VV_M2_MASK (7853) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROL_VV_M4 (7854) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROL_VV_M4_MASK (7855) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROL_VV_M8 (7856) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROL_VV_M8_MASK (7857) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROL_VV_MF2 (7858) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROL_VV_MF2_MASK (7859) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROL_VV_MF4 (7860) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROL_VV_MF4_MASK (7861) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROL_VV_MF8 (7862) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROL_VV_MF8_MASK (7863) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROL_VX_M1 (7864) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROL_VX_M1_MASK (7865) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROL_VX_M2 (7866) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROL_VX_M2_MASK (7867) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROL_VX_M4 (7868) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROL_VX_M4_MASK (7869) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROL_VX_M8 (7870) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROL_VX_M8_MASK (7871) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROL_VX_MF2 (7872) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROL_VX_MF2_MASK (7873) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROL_VX_MF4 (7874) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROL_VX_MF4_MASK (7875) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROL_VX_MF8 (7876) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROL_VX_MF8_MASK (7877) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROR_VI_M1 (7878) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROR_VI_M1_MASK (7879) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROR_VI_M2 (7880) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROR_VI_M2_MASK (7881) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROR_VI_M4 (7882) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROR_VI_M4_MASK (7883) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROR_VI_M8 (7884) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROR_VI_M8_MASK (7885) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROR_VI_MF2 (7886) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROR_VI_MF2_MASK (7887) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROR_VI_MF4 (7888) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROR_VI_MF4_MASK (7889) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROR_VI_MF8 (7890) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROR_VI_MF8_MASK (7891) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROR_VV_M1 (7892) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROR_VV_M1_MASK (7893) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROR_VV_M2 (7894) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROR_VV_M2_MASK (7895) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROR_VV_M4 (7896) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROR_VV_M4_MASK (7897) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROR_VV_M8 (7898) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROR_VV_M8_MASK (7899) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROR_VV_MF2 (7900) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROR_VV_MF2_MASK (7901) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROR_VV_MF4 (7902) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROR_VV_MF4_MASK (7903) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROR_VV_MF8 (7904) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROR_VV_MF8_MASK (7905) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROR_VX_M1 (7906) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROR_VX_M1_MASK (7907) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROR_VX_M2 (7908) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROR_VX_M2_MASK (7909) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROR_VX_M4 (7910) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROR_VX_M4_MASK (7911) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROR_VX_M8 (7912) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROR_VX_M8_MASK (7913) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROR_VX_MF2 (7914) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROR_VX_MF2_MASK (7915) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROR_VX_MF4 (7916) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROR_VX_MF4_MASK (7917) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROR_VX_MF8 (7918) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVROR_VX_MF8_MASK (7919) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRSUB_VI_M1 (7920) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRSUB_VI_M1_MASK (7921) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRSUB_VI_M2 (7922) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRSUB_VI_M2_MASK (7923) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRSUB_VI_M4 (7924) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRSUB_VI_M4_MASK (7925) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRSUB_VI_M8 (7926) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRSUB_VI_M8_MASK (7927) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRSUB_VI_MF2 (7928) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRSUB_VI_MF2_MASK (7929) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRSUB_VI_MF4 (7930) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRSUB_VI_MF4_MASK (7931) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRSUB_VI_MF8 (7932) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRSUB_VI_MF8_MASK (7933) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRSUB_VX_M1 (7934) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRSUB_VX_M1_MASK (7935) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRSUB_VX_M2 (7936) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRSUB_VX_M2_MASK (7937) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRSUB_VX_M4 (7938) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRSUB_VX_M4_MASK (7939) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRSUB_VX_M8 (7940) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRSUB_VX_M8_MASK (7941) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRSUB_VX_MF2 (7942) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRSUB_VX_MF2_MASK (7943) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRSUB_VX_MF4 (7944) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRSUB_VX_MF4_MASK (7945) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRSUB_VX_MF8 (7946) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVRSUB_VX_MF8_MASK (7947) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADDU_VI_M1 (7948) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADDU_VI_M1_MASK (7949) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADDU_VI_M2 (7950) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADDU_VI_M2_MASK (7951) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADDU_VI_M4 (7952) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADDU_VI_M4_MASK (7953) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADDU_VI_M8 (7954) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADDU_VI_M8_MASK (7955) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADDU_VI_MF2 (7956) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADDU_VI_MF2_MASK (7957) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADDU_VI_MF4 (7958) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADDU_VI_MF4_MASK (7959) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADDU_VI_MF8 (7960) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADDU_VI_MF8_MASK (7961) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADDU_VV_M1 (7962) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADDU_VV_M1_MASK (7963) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADDU_VV_M2 (7964) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADDU_VV_M2_MASK (7965) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADDU_VV_M4 (7966) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADDU_VV_M4_MASK (7967) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADDU_VV_M8 (7968) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADDU_VV_M8_MASK (7969) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADDU_VV_MF2 (7970) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADDU_VV_MF2_MASK (7971) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADDU_VV_MF4 (7972) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADDU_VV_MF4_MASK (7973) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADDU_VV_MF8 (7974) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADDU_VV_MF8_MASK (7975) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADDU_VX_M1 (7976) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADDU_VX_M1_MASK (7977) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADDU_VX_M2 (7978) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADDU_VX_M2_MASK (7979) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADDU_VX_M4 (7980) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADDU_VX_M4_MASK (7981) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADDU_VX_M8 (7982) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADDU_VX_M8_MASK (7983) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADDU_VX_MF2 (7984) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADDU_VX_MF2_MASK (7985) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADDU_VX_MF4 (7986) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADDU_VX_MF4_MASK (7987) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADDU_VX_MF8 (7988) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADDU_VX_MF8_MASK (7989) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADD_VI_M1 (7990) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADD_VI_M1_MASK (7991) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADD_VI_M2 (7992) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADD_VI_M2_MASK (7993) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADD_VI_M4 (7994) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADD_VI_M4_MASK (7995) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADD_VI_M8 (7996) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADD_VI_M8_MASK (7997) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADD_VI_MF2 (7998) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADD_VI_MF2_MASK (7999) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADD_VI_MF4 (8000) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADD_VI_MF4_MASK (8001) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADD_VI_MF8 (8002) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADD_VI_MF8_MASK (8003) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADD_VV_M1 (8004) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADD_VV_M1_MASK (8005) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADD_VV_M2 (8006) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADD_VV_M2_MASK (8007) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADD_VV_M4 (8008) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADD_VV_M4_MASK (8009) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADD_VV_M8 (8010) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADD_VV_M8_MASK (8011) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADD_VV_MF2 (8012) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADD_VV_MF2_MASK (8013) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADD_VV_MF4 (8014) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADD_VV_MF4_MASK (8015) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADD_VV_MF8 (8016) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADD_VV_MF8_MASK (8017) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADD_VX_M1 (8018) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADD_VX_M1_MASK (8019) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADD_VX_M2 (8020) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADD_VX_M2_MASK (8021) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADD_VX_M4 (8022) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADD_VX_M4_MASK (8023) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADD_VX_M8 (8024) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADD_VX_M8_MASK (8025) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADD_VX_MF2 (8026) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADD_VX_MF2_MASK (8027) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADD_VX_MF4 (8028) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADD_VX_MF4_MASK (8029) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADD_VX_MF8 (8030) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSADD_VX_MF8_MASK (8031) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSBC_VVM_M1 (8032) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSBC_VVM_M2 (8033) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSBC_VVM_M4 (8034) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSBC_VVM_M8 (8035) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSBC_VVM_MF2 (8036) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSBC_VVM_MF4 (8037) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSBC_VVM_MF8 (8038) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSBC_VXM_M1 (8039) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSBC_VXM_M2 (8040) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSBC_VXM_M4 (8041) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSBC_VXM_M8 (8042) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSBC_VXM_MF2 (8043) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSBC_VXM_MF4 (8044) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSBC_VXM_MF8 (8045) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSE16_V_M1 (8046) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSE16_V_M1_MASK (8047) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSE16_V_M2 (8048) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSE16_V_M2_MASK (8049) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSE16_V_M4 (8050) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSE16_V_M4_MASK (8051) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSE16_V_M8 (8052) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSE16_V_M8_MASK (8053) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSE16_V_MF2 (8054) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSE16_V_MF2_MASK (8055) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSE16_V_MF4 (8056) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSE16_V_MF4_MASK (8057) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSE32_V_M1 (8058) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSE32_V_M1_MASK (8059) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSE32_V_M2 (8060) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSE32_V_M2_MASK (8061) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSE32_V_M4 (8062) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSE32_V_M4_MASK (8063) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSE32_V_M8 (8064) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSE32_V_M8_MASK (8065) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSE32_V_MF2 (8066) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSE32_V_MF2_MASK (8067) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSE64_V_M1 (8068) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSE64_V_M1_MASK (8069) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSE64_V_M2 (8070) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSE64_V_M2_MASK (8071) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSE64_V_M4 (8072) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSE64_V_M4_MASK (8073) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSE64_V_M8 (8074) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSE64_V_M8_MASK (8075) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSE8_V_M1 (8076) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSE8_V_M1_MASK (8077) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSE8_V_M2 (8078) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSE8_V_M2_MASK (8079) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSE8_V_M4 (8080) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSE8_V_M4_MASK (8081) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSE8_V_M8 (8082) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSE8_V_M8_MASK (8083) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSE8_V_MF2 (8084) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSE8_V_MF2_MASK (8085) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSE8_V_MF4 (8086) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSE8_V_MF4_MASK (8087) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSE8_V_MF8 (8088) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSE8_V_MF8_MASK (8089) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSETIVLI (8090) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSETVLI (8091) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSETVLIX0 (8092) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSEXT_VF2_M1 (8093) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSEXT_VF2_M1_MASK (8094) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSEXT_VF2_M2 (8095) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSEXT_VF2_M2_MASK (8096) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSEXT_VF2_M4 (8097) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSEXT_VF2_M4_MASK (8098) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSEXT_VF2_M8 (8099) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSEXT_VF2_M8_MASK (8100) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSEXT_VF2_MF2 (8101) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSEXT_VF2_MF2_MASK (8102) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSEXT_VF2_MF4 (8103) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSEXT_VF2_MF4_MASK (8104) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSEXT_VF4_M1 (8105) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSEXT_VF4_M1_MASK (8106) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSEXT_VF4_M2 (8107) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSEXT_VF4_M2_MASK (8108) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSEXT_VF4_M4 (8109) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSEXT_VF4_M4_MASK (8110) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSEXT_VF4_M8 (8111) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSEXT_VF4_M8_MASK (8112) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSEXT_VF4_MF2 (8113) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSEXT_VF4_MF2_MASK (8114) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSEXT_VF8_M1 (8115) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSEXT_VF8_M1_MASK (8116) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSEXT_VF8_M2 (8117) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSEXT_VF8_M2_MASK (8118) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSEXT_VF8_M4 (8119) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSEXT_VF8_M4_MASK (8120) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSEXT_VF8_M8 (8121) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSEXT_VF8_M8_MASK (8122) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSHA2CH_VV_M1 (8123) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSHA2CH_VV_M2 (8124) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSHA2CH_VV_M4 (8125) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSHA2CH_VV_M8 (8126) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSHA2CH_VV_MF2 (8127) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSHA2CL_VV_M1 (8128) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSHA2CL_VV_M2 (8129) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSHA2CL_VV_M4 (8130) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSHA2CL_VV_M8 (8131) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSHA2CL_VV_MF2 (8132) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSHA2MS_VV_M1 (8133) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSHA2MS_VV_M2 (8134) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSHA2MS_VV_M4 (8135) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSHA2MS_VV_M8 (8136) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSHA2MS_VV_MF2 (8137) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDE1DOWN_VX_M1 (8138) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDE1DOWN_VX_M1_MASK (8139) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDE1DOWN_VX_M2 (8140) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDE1DOWN_VX_M2_MASK (8141) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDE1DOWN_VX_M4 (8142) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDE1DOWN_VX_M4_MASK (8143) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDE1DOWN_VX_M8 (8144) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDE1DOWN_VX_M8_MASK (8145) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDE1DOWN_VX_MF2 (8146) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDE1DOWN_VX_MF2_MASK (8147) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDE1DOWN_VX_MF4 (8148) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDE1DOWN_VX_MF4_MASK (8149) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDE1DOWN_VX_MF8 (8150) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDE1DOWN_VX_MF8_MASK (8151) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDE1UP_VX_M1 (8152) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDE1UP_VX_M1_MASK (8153) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDE1UP_VX_M2 (8154) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDE1UP_VX_M2_MASK (8155) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDE1UP_VX_M4 (8156) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDE1UP_VX_M4_MASK (8157) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDE1UP_VX_M8 (8158) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDE1UP_VX_M8_MASK (8159) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDE1UP_VX_MF2 (8160) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDE1UP_VX_MF2_MASK (8161) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDE1UP_VX_MF4 (8162) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDE1UP_VX_MF4_MASK (8163) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDE1UP_VX_MF8 (8164) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDE1UP_VX_MF8_MASK (8165) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDEDOWN_VI_M1 (8166) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDEDOWN_VI_M1_MASK (8167) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDEDOWN_VI_M2 (8168) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDEDOWN_VI_M2_MASK (8169) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDEDOWN_VI_M4 (8170) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDEDOWN_VI_M4_MASK (8171) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDEDOWN_VI_M8 (8172) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDEDOWN_VI_M8_MASK (8173) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDEDOWN_VI_MF2 (8174) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDEDOWN_VI_MF2_MASK (8175) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDEDOWN_VI_MF4 (8176) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDEDOWN_VI_MF4_MASK (8177) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDEDOWN_VI_MF8 (8178) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDEDOWN_VI_MF8_MASK (8179) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDEDOWN_VX_M1 (8180) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDEDOWN_VX_M1_MASK (8181) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDEDOWN_VX_M2 (8182) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDEDOWN_VX_M2_MASK (8183) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDEDOWN_VX_M4 (8184) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDEDOWN_VX_M4_MASK (8185) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDEDOWN_VX_M8 (8186) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDEDOWN_VX_M8_MASK (8187) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDEDOWN_VX_MF2 (8188) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDEDOWN_VX_MF2_MASK (8189) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDEDOWN_VX_MF4 (8190) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDEDOWN_VX_MF4_MASK (8191) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDEDOWN_VX_MF8 (8192) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDEDOWN_VX_MF8_MASK (8193) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDEUP_VI_M1 (8194) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDEUP_VI_M1_MASK (8195) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDEUP_VI_M2 (8196) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDEUP_VI_M2_MASK (8197) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDEUP_VI_M4 (8198) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDEUP_VI_M4_MASK (8199) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDEUP_VI_M8 (8200) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDEUP_VI_M8_MASK (8201) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDEUP_VI_MF2 (8202) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDEUP_VI_MF2_MASK (8203) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDEUP_VI_MF4 (8204) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDEUP_VI_MF4_MASK (8205) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDEUP_VI_MF8 (8206) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDEUP_VI_MF8_MASK (8207) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDEUP_VX_M1 (8208) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDEUP_VX_M1_MASK (8209) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDEUP_VX_M2 (8210) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDEUP_VX_M2_MASK (8211) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDEUP_VX_M4 (8212) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDEUP_VX_M4_MASK (8213) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDEUP_VX_M8 (8214) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDEUP_VX_M8_MASK (8215) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDEUP_VX_MF2 (8216) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDEUP_VX_MF2_MASK (8217) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDEUP_VX_MF4 (8218) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDEUP_VX_MF4_MASK (8219) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDEUP_VX_MF8 (8220) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLIDEUP_VX_MF8_MASK (8221) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLL_VI_M1 (8222) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLL_VI_M1_MASK (8223) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLL_VI_M2 (8224) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLL_VI_M2_MASK (8225) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLL_VI_M4 (8226) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLL_VI_M4_MASK (8227) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLL_VI_M8 (8228) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLL_VI_M8_MASK (8229) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLL_VI_MF2 (8230) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLL_VI_MF2_MASK (8231) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLL_VI_MF4 (8232) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLL_VI_MF4_MASK (8233) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLL_VI_MF8 (8234) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLL_VI_MF8_MASK (8235) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLL_VV_M1 (8236) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLL_VV_M1_MASK (8237) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLL_VV_M2 (8238) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLL_VV_M2_MASK (8239) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLL_VV_M4 (8240) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLL_VV_M4_MASK (8241) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLL_VV_M8 (8242) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLL_VV_M8_MASK (8243) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLL_VV_MF2 (8244) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLL_VV_MF2_MASK (8245) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLL_VV_MF4 (8246) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLL_VV_MF4_MASK (8247) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLL_VV_MF8 (8248) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLL_VV_MF8_MASK (8249) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLL_VX_M1 (8250) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLL_VX_M1_MASK (8251) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLL_VX_M2 (8252) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLL_VX_M2_MASK (8253) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLL_VX_M4 (8254) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLL_VX_M4_MASK (8255) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLL_VX_M8 (8256) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLL_VX_M8_MASK (8257) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLL_VX_MF2 (8258) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLL_VX_MF2_MASK (8259) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLL_VX_MF4 (8260) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLL_VX_MF4_MASK (8261) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLL_VX_MF8 (8262) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSLL_VX_MF8_MASK (8263) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSM3C_VI_M1 (8264) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSM3C_VI_M2 (8265) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSM3C_VI_M4 (8266) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSM3C_VI_M8 (8267) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSM3C_VI_MF2 (8268) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSM3ME_VV_M1 (8269) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSM3ME_VV_M2 (8270) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSM3ME_VV_M4 (8271) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSM3ME_VV_M8 (8272) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSM3ME_VV_MF2 (8273) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSM4K_VI_M1 (8274) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSM4K_VI_M2 (8275) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSM4K_VI_M4 (8276) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSM4K_VI_M8 (8277) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSM4K_VI_MF2 (8278) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSM4R_VS_M1_M1 (8279) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSM4R_VS_M1_MF2 (8280) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSM4R_VS_M1_MF4 (8281) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSM4R_VS_M1_MF8 (8282) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSM4R_VS_M2_M1 (8283) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSM4R_VS_M2_M2 (8284) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSM4R_VS_M2_MF2 (8285) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSM4R_VS_M2_MF4 (8286) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSM4R_VS_M2_MF8 (8287) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSM4R_VS_M4_M1 (8288) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSM4R_VS_M4_M2 (8289) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSM4R_VS_M4_M4 (8290) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSM4R_VS_M4_MF2 (8291) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSM4R_VS_M4_MF4 (8292) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSM4R_VS_M4_MF8 (8293) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSM4R_VS_M8_M1 (8294) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSM4R_VS_M8_M2 (8295) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSM4R_VS_M8_M4 (8296) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSM4R_VS_M8_MF2 (8297) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSM4R_VS_M8_MF4 (8298) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSM4R_VS_M8_MF8 (8299) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSM4R_VS_MF2_MF2 (8300) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSM4R_VS_MF2_MF4 (8301) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSM4R_VS_MF2_MF8 (8302) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSM4R_VV_M1 (8303) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSM4R_VV_M2 (8304) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSM4R_VV_M4 (8305) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSM4R_VV_M8 (8306) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSM4R_VV_MF2 (8307) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSMUL_VV_M1 (8308) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSMUL_VV_M1_MASK (8309) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSMUL_VV_M2 (8310) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSMUL_VV_M2_MASK (8311) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSMUL_VV_M4 (8312) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSMUL_VV_M4_MASK (8313) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSMUL_VV_M8 (8314) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSMUL_VV_M8_MASK (8315) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSMUL_VV_MF2 (8316) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSMUL_VV_MF2_MASK (8317) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSMUL_VV_MF4 (8318) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSMUL_VV_MF4_MASK (8319) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSMUL_VV_MF8 (8320) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSMUL_VV_MF8_MASK (8321) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSMUL_VX_M1 (8322) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSMUL_VX_M1_MASK (8323) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSMUL_VX_M2 (8324) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSMUL_VX_M2_MASK (8325) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSMUL_VX_M4 (8326) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSMUL_VX_M4_MASK (8327) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSMUL_VX_M8 (8328) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSMUL_VX_M8_MASK (8329) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSMUL_VX_MF2 (8330) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSMUL_VX_MF2_MASK (8331) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSMUL_VX_MF4 (8332) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSMUL_VX_MF4_MASK (8333) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSMUL_VX_MF8 (8334) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSMUL_VX_MF8_MASK (8335) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSM_V_B1 (8336) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSM_V_B16 (8337) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSM_V_B2 (8338) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSM_V_B32 (8339) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSM_V_B4 (8340) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSM_V_B64 (8341) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSM_V_B8 (8342) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI16_V_M1_M1 (8343) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI16_V_M1_M1_MASK (8344) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI16_V_M1_M2 (8345) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI16_V_M1_M2_MASK (8346) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI16_V_M1_M4 (8347) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI16_V_M1_M4_MASK (8348) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI16_V_M1_MF2 (8349) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI16_V_M1_MF2_MASK (8350) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI16_V_M2_M1 (8351) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI16_V_M2_M1_MASK (8352) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI16_V_M2_M2 (8353) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI16_V_M2_M2_MASK (8354) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI16_V_M2_M4 (8355) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI16_V_M2_M4_MASK (8356) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI16_V_M2_M8 (8357) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI16_V_M2_M8_MASK (8358) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI16_V_M4_M2 (8359) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI16_V_M4_M2_MASK (8360) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI16_V_M4_M4 (8361) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI16_V_M4_M4_MASK (8362) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI16_V_M4_M8 (8363) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI16_V_M4_M8_MASK (8364) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI16_V_M8_M4 (8365) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI16_V_M8_M4_MASK (8366) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI16_V_M8_M8 (8367) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI16_V_M8_M8_MASK (8368) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI16_V_MF2_M1 (8369) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI16_V_MF2_M1_MASK (8370) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI16_V_MF2_M2 (8371) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI16_V_MF2_M2_MASK (8372) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI16_V_MF2_MF2 (8373) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI16_V_MF2_MF2_MASK (8374) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI16_V_MF2_MF4 (8375) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI16_V_MF2_MF4_MASK (8376) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI16_V_MF4_M1 (8377) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI16_V_MF4_M1_MASK (8378) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI16_V_MF4_MF2 (8379) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI16_V_MF4_MF2_MASK (8380) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI16_V_MF4_MF4 (8381) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI16_V_MF4_MF4_MASK (8382) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI16_V_MF4_MF8 (8383) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI16_V_MF4_MF8_MASK (8384) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI32_V_M1_M1 (8385) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI32_V_M1_M1_MASK (8386) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI32_V_M1_M2 (8387) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI32_V_M1_M2_MASK (8388) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI32_V_M1_MF2 (8389) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI32_V_M1_MF2_MASK (8390) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI32_V_M1_MF4 (8391) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI32_V_M1_MF4_MASK (8392) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI32_V_M2_M1 (8393) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI32_V_M2_M1_MASK (8394) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI32_V_M2_M2 (8395) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI32_V_M2_M2_MASK (8396) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI32_V_M2_M4 (8397) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI32_V_M2_M4_MASK (8398) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI32_V_M2_MF2 (8399) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI32_V_M2_MF2_MASK (8400) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI32_V_M4_M1 (8401) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI32_V_M4_M1_MASK (8402) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI32_V_M4_M2 (8403) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI32_V_M4_M2_MASK (8404) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI32_V_M4_M4 (8405) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI32_V_M4_M4_MASK (8406) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI32_V_M4_M8 (8407) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI32_V_M4_M8_MASK (8408) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI32_V_M8_M2 (8409) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI32_V_M8_M2_MASK (8410) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI32_V_M8_M4 (8411) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI32_V_M8_M4_MASK (8412) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI32_V_M8_M8 (8413) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI32_V_M8_M8_MASK (8414) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI32_V_MF2_M1 (8415) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI32_V_MF2_M1_MASK (8416) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI32_V_MF2_MF2 (8417) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI32_V_MF2_MF2_MASK (8418) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI32_V_MF2_MF4 (8419) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI32_V_MF2_MF4_MASK (8420) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI32_V_MF2_MF8 (8421) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI32_V_MF2_MF8_MASK (8422) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI64_V_M1_M1 (8423) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI64_V_M1_M1_MASK (8424) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI64_V_M1_MF2 (8425) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI64_V_M1_MF2_MASK (8426) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI64_V_M1_MF4 (8427) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI64_V_M1_MF4_MASK (8428) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI64_V_M1_MF8 (8429) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI64_V_M1_MF8_MASK (8430) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI64_V_M2_M1 (8431) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI64_V_M2_M1_MASK (8432) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI64_V_M2_M2 (8433) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI64_V_M2_M2_MASK (8434) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI64_V_M2_MF2 (8435) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI64_V_M2_MF2_MASK (8436) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI64_V_M2_MF4 (8437) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI64_V_M2_MF4_MASK (8438) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI64_V_M4_M1 (8439) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI64_V_M4_M1_MASK (8440) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI64_V_M4_M2 (8441) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI64_V_M4_M2_MASK (8442) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI64_V_M4_M4 (8443) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI64_V_M4_M4_MASK (8444) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI64_V_M4_MF2 (8445) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI64_V_M4_MF2_MASK (8446) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI64_V_M8_M1 (8447) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI64_V_M8_M1_MASK (8448) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI64_V_M8_M2 (8449) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI64_V_M8_M2_MASK (8450) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI64_V_M8_M4 (8451) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI64_V_M8_M4_MASK (8452) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI64_V_M8_M8 (8453) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI64_V_M8_M8_MASK (8454) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI8_V_M1_M1 (8455) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI8_V_M1_M1_MASK (8456) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI8_V_M1_M2 (8457) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI8_V_M1_M2_MASK (8458) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI8_V_M1_M4 (8459) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI8_V_M1_M4_MASK (8460) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI8_V_M1_M8 (8461) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI8_V_M1_M8_MASK (8462) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI8_V_M2_M2 (8463) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI8_V_M2_M2_MASK (8464) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI8_V_M2_M4 (8465) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI8_V_M2_M4_MASK (8466) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI8_V_M2_M8 (8467) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI8_V_M2_M8_MASK (8468) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI8_V_M4_M4 (8469) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI8_V_M4_M4_MASK (8470) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI8_V_M4_M8 (8471) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI8_V_M4_M8_MASK (8472) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI8_V_M8_M8 (8473) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI8_V_M8_M8_MASK (8474) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI8_V_MF2_M1 (8475) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI8_V_MF2_M1_MASK (8476) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI8_V_MF2_M2 (8477) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI8_V_MF2_M2_MASK (8478) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI8_V_MF2_M4 (8479) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI8_V_MF2_M4_MASK (8480) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI8_V_MF2_MF2 (8481) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI8_V_MF2_MF2_MASK (8482) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI8_V_MF4_M1 (8483) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI8_V_MF4_M1_MASK (8484) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI8_V_MF4_M2 (8485) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI8_V_MF4_M2_MASK (8486) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI8_V_MF4_MF2 (8487) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI8_V_MF4_MF2_MASK (8488) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI8_V_MF4_MF4 (8489) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI8_V_MF4_MF4_MASK (8490) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI8_V_MF8_M1 (8491) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI8_V_MF8_M1_MASK (8492) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI8_V_MF8_MF2 (8493) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI8_V_MF8_MF2_MASK (8494) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI8_V_MF8_MF4 (8495) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI8_V_MF8_MF4_MASK (8496) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI8_V_MF8_MF8 (8497) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXEI8_V_MF8_MF8_MASK (8498) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI16_V_M1_M1 (8499) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI16_V_M1_M1_MASK (8500) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI16_V_M1_M2 (8501) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI16_V_M1_M2_MASK (8502) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI16_V_M1_M4 (8503) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI16_V_M1_M4_MASK (8504) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI16_V_M1_MF2 (8505) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI16_V_M1_MF2_MASK (8506) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI16_V_M2_M1 (8507) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI16_V_M2_M1_MASK (8508) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI16_V_M2_M2 (8509) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI16_V_M2_M2_MASK (8510) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI16_V_M2_M4 (8511) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI16_V_M2_M4_MASK (8512) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI16_V_M4_M2 (8513) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI16_V_M4_M2_MASK (8514) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI16_V_M4_M4 (8515) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI16_V_M4_M4_MASK (8516) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI16_V_M8_M4 (8517) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI16_V_M8_M4_MASK (8518) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI16_V_MF2_M1 (8519) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI16_V_MF2_M1_MASK (8520) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI16_V_MF2_M2 (8521) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI16_V_MF2_M2_MASK (8522) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI16_V_MF2_MF2 (8523) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI16_V_MF2_MF2_MASK (8524) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI16_V_MF2_MF4 (8525) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI16_V_MF2_MF4_MASK (8526) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI16_V_MF4_M1 (8527) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI16_V_MF4_M1_MASK (8528) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI16_V_MF4_MF2 (8529) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI16_V_MF4_MF2_MASK (8530) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI16_V_MF4_MF4 (8531) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI16_V_MF4_MF4_MASK (8532) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI16_V_MF4_MF8 (8533) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI16_V_MF4_MF8_MASK (8534) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI32_V_M1_M1 (8535) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI32_V_M1_M1_MASK (8536) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI32_V_M1_M2 (8537) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI32_V_M1_M2_MASK (8538) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI32_V_M1_MF2 (8539) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI32_V_M1_MF2_MASK (8540) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI32_V_M1_MF4 (8541) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI32_V_M1_MF4_MASK (8542) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI32_V_M2_M1 (8543) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI32_V_M2_M1_MASK (8544) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI32_V_M2_M2 (8545) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI32_V_M2_M2_MASK (8546) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI32_V_M2_M4 (8547) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI32_V_M2_M4_MASK (8548) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI32_V_M2_MF2 (8549) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI32_V_M2_MF2_MASK (8550) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI32_V_M4_M1 (8551) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI32_V_M4_M1_MASK (8552) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI32_V_M4_M2 (8553) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI32_V_M4_M2_MASK (8554) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI32_V_M4_M4 (8555) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI32_V_M4_M4_MASK (8556) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI32_V_M8_M2 (8557) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI32_V_M8_M2_MASK (8558) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI32_V_M8_M4 (8559) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI32_V_M8_M4_MASK (8560) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI32_V_MF2_M1 (8561) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI32_V_MF2_M1_MASK (8562) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI32_V_MF2_MF2 (8563) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI32_V_MF2_MF2_MASK (8564) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI32_V_MF2_MF4 (8565) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI32_V_MF2_MF4_MASK (8566) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI32_V_MF2_MF8 (8567) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI32_V_MF2_MF8_MASK (8568) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI64_V_M1_M1 (8569) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI64_V_M1_M1_MASK (8570) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI64_V_M1_MF2 (8571) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI64_V_M1_MF2_MASK (8572) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI64_V_M1_MF4 (8573) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI64_V_M1_MF4_MASK (8574) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI64_V_M1_MF8 (8575) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI64_V_M1_MF8_MASK (8576) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI64_V_M2_M1 (8577) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI64_V_M2_M1_MASK (8578) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI64_V_M2_M2 (8579) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI64_V_M2_M2_MASK (8580) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI64_V_M2_MF2 (8581) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI64_V_M2_MF2_MASK (8582) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI64_V_M2_MF4 (8583) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI64_V_M2_MF4_MASK (8584) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI64_V_M4_M1 (8585) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI64_V_M4_M1_MASK (8586) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI64_V_M4_M2 (8587) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI64_V_M4_M2_MASK (8588) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI64_V_M4_M4 (8589) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI64_V_M4_M4_MASK (8590) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI64_V_M4_MF2 (8591) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI64_V_M4_MF2_MASK (8592) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI64_V_M8_M1 (8593) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI64_V_M8_M1_MASK (8594) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI64_V_M8_M2 (8595) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI64_V_M8_M2_MASK (8596) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI64_V_M8_M4 (8597) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI64_V_M8_M4_MASK (8598) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI8_V_M1_M1 (8599) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI8_V_M1_M1_MASK (8600) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI8_V_M1_M2 (8601) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI8_V_M1_M2_MASK (8602) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI8_V_M1_M4 (8603) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI8_V_M1_M4_MASK (8604) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI8_V_M2_M2 (8605) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI8_V_M2_M2_MASK (8606) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI8_V_M2_M4 (8607) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI8_V_M2_M4_MASK (8608) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI8_V_M4_M4 (8609) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI8_V_M4_M4_MASK (8610) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI8_V_MF2_M1 (8611) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI8_V_MF2_M1_MASK (8612) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI8_V_MF2_M2 (8613) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI8_V_MF2_M2_MASK (8614) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI8_V_MF2_M4 (8615) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI8_V_MF2_M4_MASK (8616) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI8_V_MF2_MF2 (8617) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI8_V_MF2_MF2_MASK (8618) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI8_V_MF4_M1 (8619) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI8_V_MF4_M1_MASK (8620) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI8_V_MF4_M2 (8621) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI8_V_MF4_M2_MASK (8622) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI8_V_MF4_MF2 (8623) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI8_V_MF4_MF2_MASK (8624) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI8_V_MF4_MF4 (8625) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI8_V_MF4_MF4_MASK (8626) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI8_V_MF8_M1 (8627) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI8_V_MF8_M1_MASK (8628) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI8_V_MF8_MF2 (8629) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI8_V_MF8_MF2_MASK (8630) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI8_V_MF8_MF4 (8631) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI8_V_MF8_MF4_MASK (8632) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI8_V_MF8_MF8 (8633) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG2EI8_V_MF8_MF8_MASK (8634) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI16_V_M1_M1 (8635) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI16_V_M1_M1_MASK (8636) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI16_V_M1_M2 (8637) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI16_V_M1_M2_MASK (8638) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI16_V_M1_MF2 (8639) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI16_V_M1_MF2_MASK (8640) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI16_V_M2_M1 (8641) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI16_V_M2_M1_MASK (8642) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI16_V_M2_M2 (8643) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI16_V_M2_M2_MASK (8644) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI16_V_M4_M2 (8645) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI16_V_M4_M2_MASK (8646) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI16_V_MF2_M1 (8647) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI16_V_MF2_M1_MASK (8648) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI16_V_MF2_M2 (8649) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI16_V_MF2_M2_MASK (8650) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI16_V_MF2_MF2 (8651) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI16_V_MF2_MF2_MASK (8652) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI16_V_MF2_MF4 (8653) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI16_V_MF2_MF4_MASK (8654) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI16_V_MF4_M1 (8655) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI16_V_MF4_M1_MASK (8656) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI16_V_MF4_MF2 (8657) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI16_V_MF4_MF2_MASK (8658) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI16_V_MF4_MF4 (8659) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI16_V_MF4_MF4_MASK (8660) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI16_V_MF4_MF8 (8661) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI16_V_MF4_MF8_MASK (8662) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI32_V_M1_M1 (8663) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI32_V_M1_M1_MASK (8664) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI32_V_M1_M2 (8665) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI32_V_M1_M2_MASK (8666) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI32_V_M1_MF2 (8667) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI32_V_M1_MF2_MASK (8668) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI32_V_M1_MF4 (8669) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI32_V_M1_MF4_MASK (8670) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI32_V_M2_M1 (8671) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI32_V_M2_M1_MASK (8672) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI32_V_M2_M2 (8673) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI32_V_M2_M2_MASK (8674) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI32_V_M2_MF2 (8675) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI32_V_M2_MF2_MASK (8676) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI32_V_M4_M1 (8677) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI32_V_M4_M1_MASK (8678) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI32_V_M4_M2 (8679) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI32_V_M4_M2_MASK (8680) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI32_V_M8_M2 (8681) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI32_V_M8_M2_MASK (8682) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI32_V_MF2_M1 (8683) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI32_V_MF2_M1_MASK (8684) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI32_V_MF2_MF2 (8685) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI32_V_MF2_MF2_MASK (8686) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI32_V_MF2_MF4 (8687) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI32_V_MF2_MF4_MASK (8688) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI32_V_MF2_MF8 (8689) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI32_V_MF2_MF8_MASK (8690) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI64_V_M1_M1 (8691) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI64_V_M1_M1_MASK (8692) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI64_V_M1_MF2 (8693) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI64_V_M1_MF2_MASK (8694) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI64_V_M1_MF4 (8695) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI64_V_M1_MF4_MASK (8696) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI64_V_M1_MF8 (8697) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI64_V_M1_MF8_MASK (8698) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI64_V_M2_M1 (8699) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI64_V_M2_M1_MASK (8700) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI64_V_M2_M2 (8701) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI64_V_M2_M2_MASK (8702) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI64_V_M2_MF2 (8703) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI64_V_M2_MF2_MASK (8704) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI64_V_M2_MF4 (8705) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI64_V_M2_MF4_MASK (8706) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI64_V_M4_M1 (8707) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI64_V_M4_M1_MASK (8708) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI64_V_M4_M2 (8709) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI64_V_M4_M2_MASK (8710) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI64_V_M4_MF2 (8711) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI64_V_M4_MF2_MASK (8712) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI64_V_M8_M1 (8713) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI64_V_M8_M1_MASK (8714) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI64_V_M8_M2 (8715) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI64_V_M8_M2_MASK (8716) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI8_V_M1_M1 (8717) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI8_V_M1_M1_MASK (8718) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI8_V_M1_M2 (8719) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI8_V_M1_M2_MASK (8720) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI8_V_M2_M2 (8721) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI8_V_M2_M2_MASK (8722) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI8_V_MF2_M1 (8723) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI8_V_MF2_M1_MASK (8724) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI8_V_MF2_M2 (8725) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI8_V_MF2_M2_MASK (8726) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI8_V_MF2_MF2 (8727) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI8_V_MF2_MF2_MASK (8728) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI8_V_MF4_M1 (8729) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI8_V_MF4_M1_MASK (8730) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI8_V_MF4_M2 (8731) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI8_V_MF4_M2_MASK (8732) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI8_V_MF4_MF2 (8733) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI8_V_MF4_MF2_MASK (8734) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI8_V_MF4_MF4 (8735) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI8_V_MF4_MF4_MASK (8736) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI8_V_MF8_M1 (8737) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI8_V_MF8_M1_MASK (8738) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI8_V_MF8_MF2 (8739) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI8_V_MF8_MF2_MASK (8740) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI8_V_MF8_MF4 (8741) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI8_V_MF8_MF4_MASK (8742) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI8_V_MF8_MF8 (8743) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG3EI8_V_MF8_MF8_MASK (8744) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI16_V_M1_M1 (8745) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI16_V_M1_M1_MASK (8746) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI16_V_M1_M2 (8747) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI16_V_M1_M2_MASK (8748) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI16_V_M1_MF2 (8749) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI16_V_M1_MF2_MASK (8750) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI16_V_M2_M1 (8751) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI16_V_M2_M1_MASK (8752) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI16_V_M2_M2 (8753) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI16_V_M2_M2_MASK (8754) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI16_V_M4_M2 (8755) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI16_V_M4_M2_MASK (8756) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI16_V_MF2_M1 (8757) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI16_V_MF2_M1_MASK (8758) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI16_V_MF2_M2 (8759) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI16_V_MF2_M2_MASK (8760) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI16_V_MF2_MF2 (8761) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI16_V_MF2_MF2_MASK (8762) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI16_V_MF2_MF4 (8763) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI16_V_MF2_MF4_MASK (8764) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI16_V_MF4_M1 (8765) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI16_V_MF4_M1_MASK (8766) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI16_V_MF4_MF2 (8767) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI16_V_MF4_MF2_MASK (8768) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI16_V_MF4_MF4 (8769) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI16_V_MF4_MF4_MASK (8770) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI16_V_MF4_MF8 (8771) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI16_V_MF4_MF8_MASK (8772) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI32_V_M1_M1 (8773) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI32_V_M1_M1_MASK (8774) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI32_V_M1_M2 (8775) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI32_V_M1_M2_MASK (8776) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI32_V_M1_MF2 (8777) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI32_V_M1_MF2_MASK (8778) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI32_V_M1_MF4 (8779) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI32_V_M1_MF4_MASK (8780) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI32_V_M2_M1 (8781) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI32_V_M2_M1_MASK (8782) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI32_V_M2_M2 (8783) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI32_V_M2_M2_MASK (8784) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI32_V_M2_MF2 (8785) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI32_V_M2_MF2_MASK (8786) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI32_V_M4_M1 (8787) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI32_V_M4_M1_MASK (8788) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI32_V_M4_M2 (8789) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI32_V_M4_M2_MASK (8790) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI32_V_M8_M2 (8791) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI32_V_M8_M2_MASK (8792) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI32_V_MF2_M1 (8793) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI32_V_MF2_M1_MASK (8794) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI32_V_MF2_MF2 (8795) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI32_V_MF2_MF2_MASK (8796) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI32_V_MF2_MF4 (8797) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI32_V_MF2_MF4_MASK (8798) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI32_V_MF2_MF8 (8799) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI32_V_MF2_MF8_MASK (8800) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI64_V_M1_M1 (8801) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI64_V_M1_M1_MASK (8802) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI64_V_M1_MF2 (8803) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI64_V_M1_MF2_MASK (8804) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI64_V_M1_MF4 (8805) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI64_V_M1_MF4_MASK (8806) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI64_V_M1_MF8 (8807) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI64_V_M1_MF8_MASK (8808) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI64_V_M2_M1 (8809) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI64_V_M2_M1_MASK (8810) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI64_V_M2_M2 (8811) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI64_V_M2_M2_MASK (8812) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI64_V_M2_MF2 (8813) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI64_V_M2_MF2_MASK (8814) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI64_V_M2_MF4 (8815) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI64_V_M2_MF4_MASK (8816) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI64_V_M4_M1 (8817) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI64_V_M4_M1_MASK (8818) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI64_V_M4_M2 (8819) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI64_V_M4_M2_MASK (8820) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI64_V_M4_MF2 (8821) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI64_V_M4_MF2_MASK (8822) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI64_V_M8_M1 (8823) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI64_V_M8_M1_MASK (8824) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI64_V_M8_M2 (8825) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI64_V_M8_M2_MASK (8826) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI8_V_M1_M1 (8827) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI8_V_M1_M1_MASK (8828) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI8_V_M1_M2 (8829) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI8_V_M1_M2_MASK (8830) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI8_V_M2_M2 (8831) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI8_V_M2_M2_MASK (8832) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI8_V_MF2_M1 (8833) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI8_V_MF2_M1_MASK (8834) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI8_V_MF2_M2 (8835) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI8_V_MF2_M2_MASK (8836) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI8_V_MF2_MF2 (8837) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI8_V_MF2_MF2_MASK (8838) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI8_V_MF4_M1 (8839) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI8_V_MF4_M1_MASK (8840) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI8_V_MF4_M2 (8841) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI8_V_MF4_M2_MASK (8842) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI8_V_MF4_MF2 (8843) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI8_V_MF4_MF2_MASK (8844) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI8_V_MF4_MF4 (8845) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI8_V_MF4_MF4_MASK (8846) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI8_V_MF8_M1 (8847) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI8_V_MF8_M1_MASK (8848) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI8_V_MF8_MF2 (8849) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI8_V_MF8_MF2_MASK (8850) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI8_V_MF8_MF4 (8851) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI8_V_MF8_MF4_MASK (8852) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI8_V_MF8_MF8 (8853) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG4EI8_V_MF8_MF8_MASK (8854) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI16_V_M1_M1 (8855) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI16_V_M1_M1_MASK (8856) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI16_V_M1_MF2 (8857) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI16_V_M1_MF2_MASK (8858) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI16_V_M2_M1 (8859) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI16_V_M2_M1_MASK (8860) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI16_V_MF2_M1 (8861) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI16_V_MF2_M1_MASK (8862) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI16_V_MF2_MF2 (8863) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI16_V_MF2_MF2_MASK (8864) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI16_V_MF2_MF4 (8865) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI16_V_MF2_MF4_MASK (8866) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI16_V_MF4_M1 (8867) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI16_V_MF4_M1_MASK (8868) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI16_V_MF4_MF2 (8869) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI16_V_MF4_MF2_MASK (8870) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI16_V_MF4_MF4 (8871) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI16_V_MF4_MF4_MASK (8872) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI16_V_MF4_MF8 (8873) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI16_V_MF4_MF8_MASK (8874) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI32_V_M1_M1 (8875) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI32_V_M1_M1_MASK (8876) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI32_V_M1_MF2 (8877) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI32_V_M1_MF2_MASK (8878) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI32_V_M1_MF4 (8879) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI32_V_M1_MF4_MASK (8880) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI32_V_M2_M1 (8881) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI32_V_M2_M1_MASK (8882) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI32_V_M2_MF2 (8883) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI32_V_M2_MF2_MASK (8884) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI32_V_M4_M1 (8885) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI32_V_M4_M1_MASK (8886) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI32_V_MF2_M1 (8887) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI32_V_MF2_M1_MASK (8888) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI32_V_MF2_MF2 (8889) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI32_V_MF2_MF2_MASK (8890) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI32_V_MF2_MF4 (8891) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI32_V_MF2_MF4_MASK (8892) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI32_V_MF2_MF8 (8893) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI32_V_MF2_MF8_MASK (8894) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI64_V_M1_M1 (8895) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI64_V_M1_M1_MASK (8896) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI64_V_M1_MF2 (8897) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI64_V_M1_MF2_MASK (8898) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI64_V_M1_MF4 (8899) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI64_V_M1_MF4_MASK (8900) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI64_V_M1_MF8 (8901) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI64_V_M1_MF8_MASK (8902) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI64_V_M2_M1 (8903) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI64_V_M2_M1_MASK (8904) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI64_V_M2_MF2 (8905) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI64_V_M2_MF2_MASK (8906) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI64_V_M2_MF4 (8907) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI64_V_M2_MF4_MASK (8908) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI64_V_M4_M1 (8909) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI64_V_M4_M1_MASK (8910) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI64_V_M4_MF2 (8911) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI64_V_M4_MF2_MASK (8912) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI64_V_M8_M1 (8913) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI64_V_M8_M1_MASK (8914) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI8_V_M1_M1 (8915) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI8_V_M1_M1_MASK (8916) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI8_V_MF2_M1 (8917) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI8_V_MF2_M1_MASK (8918) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI8_V_MF2_MF2 (8919) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI8_V_MF2_MF2_MASK (8920) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI8_V_MF4_M1 (8921) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI8_V_MF4_M1_MASK (8922) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI8_V_MF4_MF2 (8923) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI8_V_MF4_MF2_MASK (8924) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI8_V_MF4_MF4 (8925) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI8_V_MF4_MF4_MASK (8926) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI8_V_MF8_M1 (8927) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI8_V_MF8_M1_MASK (8928) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI8_V_MF8_MF2 (8929) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI8_V_MF8_MF2_MASK (8930) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI8_V_MF8_MF4 (8931) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI8_V_MF8_MF4_MASK (8932) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI8_V_MF8_MF8 (8933) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG5EI8_V_MF8_MF8_MASK (8934) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI16_V_M1_M1 (8935) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI16_V_M1_M1_MASK (8936) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI16_V_M1_MF2 (8937) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI16_V_M1_MF2_MASK (8938) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI16_V_M2_M1 (8939) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI16_V_M2_M1_MASK (8940) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI16_V_MF2_M1 (8941) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI16_V_MF2_M1_MASK (8942) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI16_V_MF2_MF2 (8943) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI16_V_MF2_MF2_MASK (8944) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI16_V_MF2_MF4 (8945) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI16_V_MF2_MF4_MASK (8946) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI16_V_MF4_M1 (8947) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI16_V_MF4_M1_MASK (8948) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI16_V_MF4_MF2 (8949) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI16_V_MF4_MF2_MASK (8950) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI16_V_MF4_MF4 (8951) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI16_V_MF4_MF4_MASK (8952) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI16_V_MF4_MF8 (8953) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI16_V_MF4_MF8_MASK (8954) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI32_V_M1_M1 (8955) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI32_V_M1_M1_MASK (8956) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI32_V_M1_MF2 (8957) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI32_V_M1_MF2_MASK (8958) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI32_V_M1_MF4 (8959) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI32_V_M1_MF4_MASK (8960) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI32_V_M2_M1 (8961) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI32_V_M2_M1_MASK (8962) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI32_V_M2_MF2 (8963) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI32_V_M2_MF2_MASK (8964) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI32_V_M4_M1 (8965) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI32_V_M4_M1_MASK (8966) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI32_V_MF2_M1 (8967) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI32_V_MF2_M1_MASK (8968) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI32_V_MF2_MF2 (8969) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI32_V_MF2_MF2_MASK (8970) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI32_V_MF2_MF4 (8971) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI32_V_MF2_MF4_MASK (8972) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI32_V_MF2_MF8 (8973) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI32_V_MF2_MF8_MASK (8974) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI64_V_M1_M1 (8975) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI64_V_M1_M1_MASK (8976) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI64_V_M1_MF2 (8977) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI64_V_M1_MF2_MASK (8978) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI64_V_M1_MF4 (8979) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI64_V_M1_MF4_MASK (8980) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI64_V_M1_MF8 (8981) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI64_V_M1_MF8_MASK (8982) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI64_V_M2_M1 (8983) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI64_V_M2_M1_MASK (8984) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI64_V_M2_MF2 (8985) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI64_V_M2_MF2_MASK (8986) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI64_V_M2_MF4 (8987) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI64_V_M2_MF4_MASK (8988) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI64_V_M4_M1 (8989) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI64_V_M4_M1_MASK (8990) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI64_V_M4_MF2 (8991) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI64_V_M4_MF2_MASK (8992) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI64_V_M8_M1 (8993) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI64_V_M8_M1_MASK (8994) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI8_V_M1_M1 (8995) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI8_V_M1_M1_MASK (8996) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI8_V_MF2_M1 (8997) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI8_V_MF2_M1_MASK (8998) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI8_V_MF2_MF2 (8999) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI8_V_MF2_MF2_MASK (9000) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI8_V_MF4_M1 (9001) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI8_V_MF4_M1_MASK (9002) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI8_V_MF4_MF2 (9003) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI8_V_MF4_MF2_MASK (9004) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI8_V_MF4_MF4 (9005) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI8_V_MF4_MF4_MASK (9006) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI8_V_MF8_M1 (9007) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI8_V_MF8_M1_MASK (9008) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI8_V_MF8_MF2 (9009) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI8_V_MF8_MF2_MASK (9010) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI8_V_MF8_MF4 (9011) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI8_V_MF8_MF4_MASK (9012) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI8_V_MF8_MF8 (9013) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG6EI8_V_MF8_MF8_MASK (9014) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI16_V_M1_M1 (9015) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI16_V_M1_M1_MASK (9016) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI16_V_M1_MF2 (9017) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI16_V_M1_MF2_MASK (9018) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI16_V_M2_M1 (9019) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI16_V_M2_M1_MASK (9020) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI16_V_MF2_M1 (9021) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI16_V_MF2_M1_MASK (9022) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI16_V_MF2_MF2 (9023) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI16_V_MF2_MF2_MASK (9024) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI16_V_MF2_MF4 (9025) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI16_V_MF2_MF4_MASK (9026) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI16_V_MF4_M1 (9027) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI16_V_MF4_M1_MASK (9028) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI16_V_MF4_MF2 (9029) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI16_V_MF4_MF2_MASK (9030) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI16_V_MF4_MF4 (9031) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI16_V_MF4_MF4_MASK (9032) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI16_V_MF4_MF8 (9033) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI16_V_MF4_MF8_MASK (9034) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI32_V_M1_M1 (9035) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI32_V_M1_M1_MASK (9036) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI32_V_M1_MF2 (9037) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI32_V_M1_MF2_MASK (9038) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI32_V_M1_MF4 (9039) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI32_V_M1_MF4_MASK (9040) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI32_V_M2_M1 (9041) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI32_V_M2_M1_MASK (9042) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI32_V_M2_MF2 (9043) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI32_V_M2_MF2_MASK (9044) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI32_V_M4_M1 (9045) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI32_V_M4_M1_MASK (9046) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI32_V_MF2_M1 (9047) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI32_V_MF2_M1_MASK (9048) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI32_V_MF2_MF2 (9049) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI32_V_MF2_MF2_MASK (9050) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI32_V_MF2_MF4 (9051) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI32_V_MF2_MF4_MASK (9052) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI32_V_MF2_MF8 (9053) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI32_V_MF2_MF8_MASK (9054) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI64_V_M1_M1 (9055) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI64_V_M1_M1_MASK (9056) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI64_V_M1_MF2 (9057) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI64_V_M1_MF2_MASK (9058) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI64_V_M1_MF4 (9059) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI64_V_M1_MF4_MASK (9060) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI64_V_M1_MF8 (9061) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI64_V_M1_MF8_MASK (9062) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI64_V_M2_M1 (9063) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI64_V_M2_M1_MASK (9064) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI64_V_M2_MF2 (9065) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI64_V_M2_MF2_MASK (9066) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI64_V_M2_MF4 (9067) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI64_V_M2_MF4_MASK (9068) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI64_V_M4_M1 (9069) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI64_V_M4_M1_MASK (9070) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI64_V_M4_MF2 (9071) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI64_V_M4_MF2_MASK (9072) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI64_V_M8_M1 (9073) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI64_V_M8_M1_MASK (9074) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI8_V_M1_M1 (9075) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI8_V_M1_M1_MASK (9076) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI8_V_MF2_M1 (9077) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI8_V_MF2_M1_MASK (9078) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI8_V_MF2_MF2 (9079) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI8_V_MF2_MF2_MASK (9080) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI8_V_MF4_M1 (9081) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI8_V_MF4_M1_MASK (9082) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI8_V_MF4_MF2 (9083) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI8_V_MF4_MF2_MASK (9084) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI8_V_MF4_MF4 (9085) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI8_V_MF4_MF4_MASK (9086) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI8_V_MF8_M1 (9087) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI8_V_MF8_M1_MASK (9088) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI8_V_MF8_MF2 (9089) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI8_V_MF8_MF2_MASK (9090) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI8_V_MF8_MF4 (9091) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI8_V_MF8_MF4_MASK (9092) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI8_V_MF8_MF8 (9093) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG7EI8_V_MF8_MF8_MASK (9094) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI16_V_M1_M1 (9095) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI16_V_M1_M1_MASK (9096) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI16_V_M1_MF2 (9097) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI16_V_M1_MF2_MASK (9098) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI16_V_M2_M1 (9099) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI16_V_M2_M1_MASK (9100) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI16_V_MF2_M1 (9101) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI16_V_MF2_M1_MASK (9102) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI16_V_MF2_MF2 (9103) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI16_V_MF2_MF2_MASK (9104) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI16_V_MF2_MF4 (9105) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI16_V_MF2_MF4_MASK (9106) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI16_V_MF4_M1 (9107) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI16_V_MF4_M1_MASK (9108) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI16_V_MF4_MF2 (9109) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI16_V_MF4_MF2_MASK (9110) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI16_V_MF4_MF4 (9111) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI16_V_MF4_MF4_MASK (9112) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI16_V_MF4_MF8 (9113) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI16_V_MF4_MF8_MASK (9114) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI32_V_M1_M1 (9115) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI32_V_M1_M1_MASK (9116) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI32_V_M1_MF2 (9117) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI32_V_M1_MF2_MASK (9118) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI32_V_M1_MF4 (9119) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI32_V_M1_MF4_MASK (9120) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI32_V_M2_M1 (9121) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI32_V_M2_M1_MASK (9122) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI32_V_M2_MF2 (9123) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI32_V_M2_MF2_MASK (9124) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI32_V_M4_M1 (9125) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI32_V_M4_M1_MASK (9126) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI32_V_MF2_M1 (9127) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI32_V_MF2_M1_MASK (9128) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI32_V_MF2_MF2 (9129) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI32_V_MF2_MF2_MASK (9130) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI32_V_MF2_MF4 (9131) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI32_V_MF2_MF4_MASK (9132) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI32_V_MF2_MF8 (9133) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI32_V_MF2_MF8_MASK (9134) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI64_V_M1_M1 (9135) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI64_V_M1_M1_MASK (9136) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI64_V_M1_MF2 (9137) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI64_V_M1_MF2_MASK (9138) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI64_V_M1_MF4 (9139) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI64_V_M1_MF4_MASK (9140) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI64_V_M1_MF8 (9141) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI64_V_M1_MF8_MASK (9142) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI64_V_M2_M1 (9143) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI64_V_M2_M1_MASK (9144) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI64_V_M2_MF2 (9145) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI64_V_M2_MF2_MASK (9146) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI64_V_M2_MF4 (9147) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI64_V_M2_MF4_MASK (9148) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI64_V_M4_M1 (9149) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI64_V_M4_M1_MASK (9150) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI64_V_M4_MF2 (9151) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI64_V_M4_MF2_MASK (9152) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI64_V_M8_M1 (9153) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI64_V_M8_M1_MASK (9154) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI8_V_M1_M1 (9155) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI8_V_M1_M1_MASK (9156) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI8_V_MF2_M1 (9157) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI8_V_MF2_M1_MASK (9158) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI8_V_MF2_MF2 (9159) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI8_V_MF2_MF2_MASK (9160) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI8_V_MF4_M1 (9161) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI8_V_MF4_M1_MASK (9162) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI8_V_MF4_MF2 (9163) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI8_V_MF4_MF2_MASK (9164) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI8_V_MF4_MF4 (9165) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI8_V_MF4_MF4_MASK (9166) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI8_V_MF8_M1 (9167) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI8_V_MF8_M1_MASK (9168) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI8_V_MF8_MF2 (9169) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI8_V_MF8_MF2_MASK (9170) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI8_V_MF8_MF4 (9171) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI8_V_MF8_MF4_MASK (9172) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI8_V_MF8_MF8 (9173) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSOXSEG8EI8_V_MF8_MF8_MASK (9174) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSPILL2_M1 (9175) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSPILL2_M2 (9176) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSPILL2_M4 (9177) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSPILL2_MF2 (9178) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSPILL2_MF4 (9179) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSPILL2_MF8 (9180) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSPILL3_M1 (9181) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSPILL3_M2 (9182) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSPILL3_MF2 (9183) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSPILL3_MF4 (9184) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSPILL3_MF8 (9185) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSPILL4_M1 (9186) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSPILL4_M2 (9187) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSPILL4_MF2 (9188) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSPILL4_MF4 (9189) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSPILL4_MF8 (9190) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSPILL5_M1 (9191) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSPILL5_MF2 (9192) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSPILL5_MF4 (9193) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSPILL5_MF8 (9194) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSPILL6_M1 (9195) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSPILL6_MF2 (9196) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSPILL6_MF4 (9197) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSPILL6_MF8 (9198) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSPILL7_M1 (9199) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSPILL7_MF2 (9200) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSPILL7_MF4 (9201) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSPILL7_MF8 (9202) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSPILL8_M1 (9203) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSPILL8_MF2 (9204) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSPILL8_MF4 (9205) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSPILL8_MF8 (9206) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRA_VI_M1 (9207) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRA_VI_M1_MASK (9208) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRA_VI_M2 (9209) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRA_VI_M2_MASK (9210) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRA_VI_M4 (9211) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRA_VI_M4_MASK (9212) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRA_VI_M8 (9213) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRA_VI_M8_MASK (9214) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRA_VI_MF2 (9215) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRA_VI_MF2_MASK (9216) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRA_VI_MF4 (9217) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRA_VI_MF4_MASK (9218) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRA_VI_MF8 (9219) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRA_VI_MF8_MASK (9220) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRA_VV_M1 (9221) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRA_VV_M1_MASK (9222) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRA_VV_M2 (9223) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRA_VV_M2_MASK (9224) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRA_VV_M4 (9225) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRA_VV_M4_MASK (9226) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRA_VV_M8 (9227) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRA_VV_M8_MASK (9228) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRA_VV_MF2 (9229) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRA_VV_MF2_MASK (9230) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRA_VV_MF4 (9231) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRA_VV_MF4_MASK (9232) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRA_VV_MF8 (9233) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRA_VV_MF8_MASK (9234) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRA_VX_M1 (9235) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRA_VX_M1_MASK (9236) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRA_VX_M2 (9237) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRA_VX_M2_MASK (9238) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRA_VX_M4 (9239) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRA_VX_M4_MASK (9240) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRA_VX_M8 (9241) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRA_VX_M8_MASK (9242) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRA_VX_MF2 (9243) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRA_VX_MF2_MASK (9244) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRA_VX_MF4 (9245) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRA_VX_MF4_MASK (9246) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRA_VX_MF8 (9247) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRA_VX_MF8_MASK (9248) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRL_VI_M1 (9249) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRL_VI_M1_MASK (9250) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRL_VI_M2 (9251) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRL_VI_M2_MASK (9252) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRL_VI_M4 (9253) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRL_VI_M4_MASK (9254) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRL_VI_M8 (9255) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRL_VI_M8_MASK (9256) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRL_VI_MF2 (9257) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRL_VI_MF2_MASK (9258) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRL_VI_MF4 (9259) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRL_VI_MF4_MASK (9260) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRL_VI_MF8 (9261) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRL_VI_MF8_MASK (9262) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRL_VV_M1 (9263) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRL_VV_M1_MASK (9264) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRL_VV_M2 (9265) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRL_VV_M2_MASK (9266) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRL_VV_M4 (9267) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRL_VV_M4_MASK (9268) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRL_VV_M8 (9269) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRL_VV_M8_MASK (9270) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRL_VV_MF2 (9271) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRL_VV_MF2_MASK (9272) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRL_VV_MF4 (9273) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRL_VV_MF4_MASK (9274) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRL_VV_MF8 (9275) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRL_VV_MF8_MASK (9276) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRL_VX_M1 (9277) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRL_VX_M1_MASK (9278) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRL_VX_M2 (9279) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRL_VX_M2_MASK (9280) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRL_VX_M4 (9281) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRL_VX_M4_MASK (9282) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRL_VX_M8 (9283) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRL_VX_M8_MASK (9284) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRL_VX_MF2 (9285) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRL_VX_MF2_MASK (9286) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRL_VX_MF4 (9287) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRL_VX_MF4_MASK (9288) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRL_VX_MF8 (9289) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSRL_VX_MF8_MASK (9290) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSE16_V_M1 (9291) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSE16_V_M1_MASK (9292) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSE16_V_M2 (9293) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSE16_V_M2_MASK (9294) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSE16_V_M4 (9295) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSE16_V_M4_MASK (9296) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSE16_V_M8 (9297) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSE16_V_M8_MASK (9298) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSE16_V_MF2 (9299) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSE16_V_MF2_MASK (9300) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSE16_V_MF4 (9301) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSE16_V_MF4_MASK (9302) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSE32_V_M1 (9303) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSE32_V_M1_MASK (9304) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSE32_V_M2 (9305) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSE32_V_M2_MASK (9306) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSE32_V_M4 (9307) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSE32_V_M4_MASK (9308) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSE32_V_M8 (9309) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSE32_V_M8_MASK (9310) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSE32_V_MF2 (9311) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSE32_V_MF2_MASK (9312) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSE64_V_M1 (9313) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSE64_V_M1_MASK (9314) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSE64_V_M2 (9315) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSE64_V_M2_MASK (9316) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSE64_V_M4 (9317) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSE64_V_M4_MASK (9318) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSE64_V_M8 (9319) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSE64_V_M8_MASK (9320) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSE8_V_M1 (9321) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSE8_V_M1_MASK (9322) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSE8_V_M2 (9323) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSE8_V_M2_MASK (9324) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSE8_V_M4 (9325) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSE8_V_M4_MASK (9326) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSE8_V_M8 (9327) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSE8_V_M8_MASK (9328) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSE8_V_MF2 (9329) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSE8_V_MF2_MASK (9330) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSE8_V_MF4 (9331) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSE8_V_MF4_MASK (9332) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSE8_V_MF8 (9333) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSE8_V_MF8_MASK (9334) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG2E16_V_M1 (9335) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG2E16_V_M1_MASK (9336) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG2E16_V_M2 (9337) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG2E16_V_M2_MASK (9338) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG2E16_V_M4 (9339) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG2E16_V_M4_MASK (9340) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG2E16_V_MF2 (9341) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG2E16_V_MF2_MASK (9342) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG2E16_V_MF4 (9343) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG2E16_V_MF4_MASK (9344) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG2E32_V_M1 (9345) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG2E32_V_M1_MASK (9346) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG2E32_V_M2 (9347) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG2E32_V_M2_MASK (9348) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG2E32_V_M4 (9349) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG2E32_V_M4_MASK (9350) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG2E32_V_MF2 (9351) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG2E32_V_MF2_MASK (9352) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG2E64_V_M1 (9353) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG2E64_V_M1_MASK (9354) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG2E64_V_M2 (9355) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG2E64_V_M2_MASK (9356) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG2E64_V_M4 (9357) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG2E64_V_M4_MASK (9358) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG2E8_V_M1 (9359) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG2E8_V_M1_MASK (9360) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG2E8_V_M2 (9361) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG2E8_V_M2_MASK (9362) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG2E8_V_M4 (9363) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG2E8_V_M4_MASK (9364) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG2E8_V_MF2 (9365) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG2E8_V_MF2_MASK (9366) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG2E8_V_MF4 (9367) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG2E8_V_MF4_MASK (9368) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG2E8_V_MF8 (9369) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG2E8_V_MF8_MASK (9370) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG3E16_V_M1 (9371) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG3E16_V_M1_MASK (9372) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG3E16_V_M2 (9373) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG3E16_V_M2_MASK (9374) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG3E16_V_MF2 (9375) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG3E16_V_MF2_MASK (9376) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG3E16_V_MF4 (9377) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG3E16_V_MF4_MASK (9378) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG3E32_V_M1 (9379) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG3E32_V_M1_MASK (9380) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG3E32_V_M2 (9381) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG3E32_V_M2_MASK (9382) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG3E32_V_MF2 (9383) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG3E32_V_MF2_MASK (9384) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG3E64_V_M1 (9385) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG3E64_V_M1_MASK (9386) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG3E64_V_M2 (9387) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG3E64_V_M2_MASK (9388) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG3E8_V_M1 (9389) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG3E8_V_M1_MASK (9390) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG3E8_V_M2 (9391) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG3E8_V_M2_MASK (9392) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG3E8_V_MF2 (9393) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG3E8_V_MF2_MASK (9394) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG3E8_V_MF4 (9395) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG3E8_V_MF4_MASK (9396) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG3E8_V_MF8 (9397) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG3E8_V_MF8_MASK (9398) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG4E16_V_M1 (9399) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG4E16_V_M1_MASK (9400) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG4E16_V_M2 (9401) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG4E16_V_M2_MASK (9402) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG4E16_V_MF2 (9403) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG4E16_V_MF2_MASK (9404) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG4E16_V_MF4 (9405) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG4E16_V_MF4_MASK (9406) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG4E32_V_M1 (9407) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG4E32_V_M1_MASK (9408) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG4E32_V_M2 (9409) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG4E32_V_M2_MASK (9410) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG4E32_V_MF2 (9411) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG4E32_V_MF2_MASK (9412) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG4E64_V_M1 (9413) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG4E64_V_M1_MASK (9414) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG4E64_V_M2 (9415) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG4E64_V_M2_MASK (9416) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG4E8_V_M1 (9417) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG4E8_V_M1_MASK (9418) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG4E8_V_M2 (9419) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG4E8_V_M2_MASK (9420) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG4E8_V_MF2 (9421) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG4E8_V_MF2_MASK (9422) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG4E8_V_MF4 (9423) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG4E8_V_MF4_MASK (9424) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG4E8_V_MF8 (9425) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG4E8_V_MF8_MASK (9426) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG5E16_V_M1 (9427) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG5E16_V_M1_MASK (9428) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG5E16_V_MF2 (9429) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG5E16_V_MF2_MASK (9430) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG5E16_V_MF4 (9431) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG5E16_V_MF4_MASK (9432) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG5E32_V_M1 (9433) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG5E32_V_M1_MASK (9434) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG5E32_V_MF2 (9435) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG5E32_V_MF2_MASK (9436) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG5E64_V_M1 (9437) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG5E64_V_M1_MASK (9438) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG5E8_V_M1 (9439) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG5E8_V_M1_MASK (9440) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG5E8_V_MF2 (9441) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG5E8_V_MF2_MASK (9442) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG5E8_V_MF4 (9443) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG5E8_V_MF4_MASK (9444) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG5E8_V_MF8 (9445) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG5E8_V_MF8_MASK (9446) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG6E16_V_M1 (9447) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG6E16_V_M1_MASK (9448) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG6E16_V_MF2 (9449) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG6E16_V_MF2_MASK (9450) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG6E16_V_MF4 (9451) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG6E16_V_MF4_MASK (9452) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG6E32_V_M1 (9453) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG6E32_V_M1_MASK (9454) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG6E32_V_MF2 (9455) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG6E32_V_MF2_MASK (9456) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG6E64_V_M1 (9457) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG6E64_V_M1_MASK (9458) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG6E8_V_M1 (9459) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG6E8_V_M1_MASK (9460) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG6E8_V_MF2 (9461) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG6E8_V_MF2_MASK (9462) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG6E8_V_MF4 (9463) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG6E8_V_MF4_MASK (9464) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG6E8_V_MF8 (9465) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG6E8_V_MF8_MASK (9466) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG7E16_V_M1 (9467) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG7E16_V_M1_MASK (9468) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG7E16_V_MF2 (9469) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG7E16_V_MF2_MASK (9470) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG7E16_V_MF4 (9471) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG7E16_V_MF4_MASK (9472) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG7E32_V_M1 (9473) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG7E32_V_M1_MASK (9474) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG7E32_V_MF2 (9475) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG7E32_V_MF2_MASK (9476) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG7E64_V_M1 (9477) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG7E64_V_M1_MASK (9478) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG7E8_V_M1 (9479) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG7E8_V_M1_MASK (9480) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG7E8_V_MF2 (9481) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG7E8_V_MF2_MASK (9482) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG7E8_V_MF4 (9483) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG7E8_V_MF4_MASK (9484) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG7E8_V_MF8 (9485) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG7E8_V_MF8_MASK (9486) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG8E16_V_M1 (9487) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG8E16_V_M1_MASK (9488) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG8E16_V_MF2 (9489) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG8E16_V_MF2_MASK (9490) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG8E16_V_MF4 (9491) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG8E16_V_MF4_MASK (9492) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG8E32_V_M1 (9493) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG8E32_V_M1_MASK (9494) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG8E32_V_MF2 (9495) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG8E32_V_MF2_MASK (9496) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG8E64_V_M1 (9497) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG8E64_V_M1_MASK (9498) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG8E8_V_M1 (9499) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG8E8_V_M1_MASK (9500) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG8E8_V_MF2 (9501) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG8E8_V_MF2_MASK (9502) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG8E8_V_MF4 (9503) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG8E8_V_MF4_MASK (9504) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG8E8_V_MF8 (9505) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSEG8E8_V_MF8_MASK (9506) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRA_VI_M1 (9507) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRA_VI_M1_MASK (9508) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRA_VI_M2 (9509) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRA_VI_M2_MASK (9510) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRA_VI_M4 (9511) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRA_VI_M4_MASK (9512) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRA_VI_M8 (9513) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRA_VI_M8_MASK (9514) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRA_VI_MF2 (9515) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRA_VI_MF2_MASK (9516) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRA_VI_MF4 (9517) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRA_VI_MF4_MASK (9518) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRA_VI_MF8 (9519) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRA_VI_MF8_MASK (9520) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRA_VV_M1 (9521) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRA_VV_M1_MASK (9522) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRA_VV_M2 (9523) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRA_VV_M2_MASK (9524) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRA_VV_M4 (9525) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRA_VV_M4_MASK (9526) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRA_VV_M8 (9527) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRA_VV_M8_MASK (9528) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRA_VV_MF2 (9529) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRA_VV_MF2_MASK (9530) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRA_VV_MF4 (9531) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRA_VV_MF4_MASK (9532) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRA_VV_MF8 (9533) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRA_VV_MF8_MASK (9534) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRA_VX_M1 (9535) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRA_VX_M1_MASK (9536) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRA_VX_M2 (9537) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRA_VX_M2_MASK (9538) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRA_VX_M4 (9539) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRA_VX_M4_MASK (9540) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRA_VX_M8 (9541) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRA_VX_M8_MASK (9542) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRA_VX_MF2 (9543) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRA_VX_MF2_MASK (9544) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRA_VX_MF4 (9545) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRA_VX_MF4_MASK (9546) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRA_VX_MF8 (9547) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRA_VX_MF8_MASK (9548) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRL_VI_M1 (9549) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRL_VI_M1_MASK (9550) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRL_VI_M2 (9551) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRL_VI_M2_MASK (9552) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRL_VI_M4 (9553) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRL_VI_M4_MASK (9554) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRL_VI_M8 (9555) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRL_VI_M8_MASK (9556) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRL_VI_MF2 (9557) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRL_VI_MF2_MASK (9558) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRL_VI_MF4 (9559) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRL_VI_MF4_MASK (9560) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRL_VI_MF8 (9561) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRL_VI_MF8_MASK (9562) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRL_VV_M1 (9563) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRL_VV_M1_MASK (9564) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRL_VV_M2 (9565) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRL_VV_M2_MASK (9566) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRL_VV_M4 (9567) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRL_VV_M4_MASK (9568) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRL_VV_M8 (9569) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRL_VV_M8_MASK (9570) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRL_VV_MF2 (9571) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRL_VV_MF2_MASK (9572) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRL_VV_MF4 (9573) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRL_VV_MF4_MASK (9574) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRL_VV_MF8 (9575) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRL_VV_MF8_MASK (9576) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRL_VX_M1 (9577) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRL_VX_M1_MASK (9578) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRL_VX_M2 (9579) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRL_VX_M2_MASK (9580) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRL_VX_M4 (9581) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRL_VX_M4_MASK (9582) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRL_VX_M8 (9583) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRL_VX_M8_MASK (9584) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRL_VX_MF2 (9585) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRL_VX_MF2_MASK (9586) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRL_VX_MF4 (9587) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRL_VX_MF4_MASK (9588) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRL_VX_MF8 (9589) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSRL_VX_MF8_MASK (9590) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG2E16_V_M1 (9591) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG2E16_V_M1_MASK (9592) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG2E16_V_M2 (9593) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG2E16_V_M2_MASK (9594) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG2E16_V_M4 (9595) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG2E16_V_M4_MASK (9596) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG2E16_V_MF2 (9597) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG2E16_V_MF2_MASK (9598) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG2E16_V_MF4 (9599) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG2E16_V_MF4_MASK (9600) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG2E32_V_M1 (9601) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG2E32_V_M1_MASK (9602) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG2E32_V_M2 (9603) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG2E32_V_M2_MASK (9604) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG2E32_V_M4 (9605) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG2E32_V_M4_MASK (9606) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG2E32_V_MF2 (9607) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG2E32_V_MF2_MASK (9608) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG2E64_V_M1 (9609) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG2E64_V_M1_MASK (9610) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG2E64_V_M2 (9611) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG2E64_V_M2_MASK (9612) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG2E64_V_M4 (9613) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG2E64_V_M4_MASK (9614) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG2E8_V_M1 (9615) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG2E8_V_M1_MASK (9616) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG2E8_V_M2 (9617) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG2E8_V_M2_MASK (9618) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG2E8_V_M4 (9619) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG2E8_V_M4_MASK (9620) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG2E8_V_MF2 (9621) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG2E8_V_MF2_MASK (9622) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG2E8_V_MF4 (9623) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG2E8_V_MF4_MASK (9624) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG2E8_V_MF8 (9625) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG2E8_V_MF8_MASK (9626) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG3E16_V_M1 (9627) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG3E16_V_M1_MASK (9628) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG3E16_V_M2 (9629) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG3E16_V_M2_MASK (9630) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG3E16_V_MF2 (9631) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG3E16_V_MF2_MASK (9632) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG3E16_V_MF4 (9633) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG3E16_V_MF4_MASK (9634) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG3E32_V_M1 (9635) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG3E32_V_M1_MASK (9636) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG3E32_V_M2 (9637) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG3E32_V_M2_MASK (9638) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG3E32_V_MF2 (9639) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG3E32_V_MF2_MASK (9640) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG3E64_V_M1 (9641) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG3E64_V_M1_MASK (9642) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG3E64_V_M2 (9643) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG3E64_V_M2_MASK (9644) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG3E8_V_M1 (9645) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG3E8_V_M1_MASK (9646) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG3E8_V_M2 (9647) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG3E8_V_M2_MASK (9648) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG3E8_V_MF2 (9649) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG3E8_V_MF2_MASK (9650) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG3E8_V_MF4 (9651) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG3E8_V_MF4_MASK (9652) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG3E8_V_MF8 (9653) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG3E8_V_MF8_MASK (9654) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG4E16_V_M1 (9655) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG4E16_V_M1_MASK (9656) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG4E16_V_M2 (9657) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG4E16_V_M2_MASK (9658) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG4E16_V_MF2 (9659) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG4E16_V_MF2_MASK (9660) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG4E16_V_MF4 (9661) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG4E16_V_MF4_MASK (9662) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG4E32_V_M1 (9663) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG4E32_V_M1_MASK (9664) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG4E32_V_M2 (9665) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG4E32_V_M2_MASK (9666) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG4E32_V_MF2 (9667) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG4E32_V_MF2_MASK (9668) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG4E64_V_M1 (9669) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG4E64_V_M1_MASK (9670) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG4E64_V_M2 (9671) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG4E64_V_M2_MASK (9672) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG4E8_V_M1 (9673) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG4E8_V_M1_MASK (9674) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG4E8_V_M2 (9675) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG4E8_V_M2_MASK (9676) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG4E8_V_MF2 (9677) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG4E8_V_MF2_MASK (9678) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG4E8_V_MF4 (9679) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG4E8_V_MF4_MASK (9680) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG4E8_V_MF8 (9681) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG4E8_V_MF8_MASK (9682) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG5E16_V_M1 (9683) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG5E16_V_M1_MASK (9684) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG5E16_V_MF2 (9685) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG5E16_V_MF2_MASK (9686) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG5E16_V_MF4 (9687) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG5E16_V_MF4_MASK (9688) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG5E32_V_M1 (9689) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG5E32_V_M1_MASK (9690) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG5E32_V_MF2 (9691) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG5E32_V_MF2_MASK (9692) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG5E64_V_M1 (9693) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG5E64_V_M1_MASK (9694) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG5E8_V_M1 (9695) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG5E8_V_M1_MASK (9696) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG5E8_V_MF2 (9697) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG5E8_V_MF2_MASK (9698) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG5E8_V_MF4 (9699) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG5E8_V_MF4_MASK (9700) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG5E8_V_MF8 (9701) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG5E8_V_MF8_MASK (9702) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG6E16_V_M1 (9703) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG6E16_V_M1_MASK (9704) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG6E16_V_MF2 (9705) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG6E16_V_MF2_MASK (9706) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG6E16_V_MF4 (9707) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG6E16_V_MF4_MASK (9708) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG6E32_V_M1 (9709) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG6E32_V_M1_MASK (9710) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG6E32_V_MF2 (9711) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG6E32_V_MF2_MASK (9712) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG6E64_V_M1 (9713) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG6E64_V_M1_MASK (9714) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG6E8_V_M1 (9715) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG6E8_V_M1_MASK (9716) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG6E8_V_MF2 (9717) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG6E8_V_MF2_MASK (9718) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG6E8_V_MF4 (9719) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG6E8_V_MF4_MASK (9720) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG6E8_V_MF8 (9721) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG6E8_V_MF8_MASK (9722) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG7E16_V_M1 (9723) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG7E16_V_M1_MASK (9724) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG7E16_V_MF2 (9725) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG7E16_V_MF2_MASK (9726) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG7E16_V_MF4 (9727) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG7E16_V_MF4_MASK (9728) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG7E32_V_M1 (9729) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG7E32_V_M1_MASK (9730) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG7E32_V_MF2 (9731) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG7E32_V_MF2_MASK (9732) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG7E64_V_M1 (9733) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG7E64_V_M1_MASK (9734) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG7E8_V_M1 (9735) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG7E8_V_M1_MASK (9736) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG7E8_V_MF2 (9737) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG7E8_V_MF2_MASK (9738) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG7E8_V_MF4 (9739) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG7E8_V_MF4_MASK (9740) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG7E8_V_MF8 (9741) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG7E8_V_MF8_MASK (9742) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG8E16_V_M1 (9743) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG8E16_V_M1_MASK (9744) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG8E16_V_MF2 (9745) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG8E16_V_MF2_MASK (9746) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG8E16_V_MF4 (9747) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG8E16_V_MF4_MASK (9748) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG8E32_V_M1 (9749) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG8E32_V_M1_MASK (9750) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG8E32_V_MF2 (9751) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG8E32_V_MF2_MASK (9752) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG8E64_V_M1 (9753) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG8E64_V_M1_MASK (9754) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG8E8_V_M1 (9755) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG8E8_V_M1_MASK (9756) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG8E8_V_MF2 (9757) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG8E8_V_MF2_MASK (9758) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG8E8_V_MF4 (9759) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG8E8_V_MF4_MASK (9760) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG8E8_V_MF8 (9761) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSSEG8E8_V_MF8_MASK (9762) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSUBU_VV_M1 (9763) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSUBU_VV_M1_MASK (9764) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSUBU_VV_M2 (9765) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSUBU_VV_M2_MASK (9766) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSUBU_VV_M4 (9767) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSUBU_VV_M4_MASK (9768) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSUBU_VV_M8 (9769) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSUBU_VV_M8_MASK (9770) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSUBU_VV_MF2 (9771) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSUBU_VV_MF2_MASK (9772) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSUBU_VV_MF4 (9773) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSUBU_VV_MF4_MASK (9774) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSUBU_VV_MF8 (9775) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSUBU_VV_MF8_MASK (9776) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSUBU_VX_M1 (9777) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSUBU_VX_M1_MASK (9778) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSUBU_VX_M2 (9779) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSUBU_VX_M2_MASK (9780) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSUBU_VX_M4 (9781) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSUBU_VX_M4_MASK (9782) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSUBU_VX_M8 (9783) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSUBU_VX_M8_MASK (9784) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSUBU_VX_MF2 (9785) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSUBU_VX_MF2_MASK (9786) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSUBU_VX_MF4 (9787) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSUBU_VX_MF4_MASK (9788) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSUBU_VX_MF8 (9789) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSUBU_VX_MF8_MASK (9790) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSUB_VV_M1 (9791) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSUB_VV_M1_MASK (9792) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSUB_VV_M2 (9793) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSUB_VV_M2_MASK (9794) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSUB_VV_M4 (9795) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSUB_VV_M4_MASK (9796) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSUB_VV_M8 (9797) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSUB_VV_M8_MASK (9798) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSUB_VV_MF2 (9799) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSUB_VV_MF2_MASK (9800) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSUB_VV_MF4 (9801) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSUB_VV_MF4_MASK (9802) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSUB_VV_MF8 (9803) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSUB_VV_MF8_MASK (9804) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSUB_VX_M1 (9805) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSUB_VX_M1_MASK (9806) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSUB_VX_M2 (9807) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSUB_VX_M2_MASK (9808) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSUB_VX_M4 (9809) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSUB_VX_M4_MASK (9810) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSUB_VX_M8 (9811) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSUB_VX_M8_MASK (9812) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSUB_VX_MF2 (9813) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSUB_VX_MF2_MASK (9814) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSUB_VX_MF4 (9815) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSUB_VX_MF4_MASK (9816) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSUB_VX_MF8 (9817) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSSUB_VX_MF8_MASK (9818) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUB_VV_M1 (9819) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUB_VV_M1_MASK (9820) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUB_VV_M2 (9821) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUB_VV_M2_MASK (9822) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUB_VV_M4 (9823) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUB_VV_M4_MASK (9824) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUB_VV_M8 (9825) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUB_VV_M8_MASK (9826) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUB_VV_MF2 (9827) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUB_VV_MF2_MASK (9828) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUB_VV_MF4 (9829) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUB_VV_MF4_MASK (9830) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUB_VV_MF8 (9831) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUB_VV_MF8_MASK (9832) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUB_VX_M1 (9833) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUB_VX_M1_MASK (9834) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUB_VX_M2 (9835) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUB_VX_M2_MASK (9836) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUB_VX_M4 (9837) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUB_VX_M4_MASK (9838) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUB_VX_M8 (9839) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUB_VX_M8_MASK (9840) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUB_VX_MF2 (9841) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUB_VX_MF2_MASK (9842) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUB_VX_MF4 (9843) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUB_VX_MF4_MASK (9844) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUB_VX_MF8 (9845) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUB_VX_MF8_MASK (9846) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI16_V_M1_M1 (9847) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI16_V_M1_M1_MASK (9848) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI16_V_M1_M2 (9849) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI16_V_M1_M2_MASK (9850) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI16_V_M1_M4 (9851) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI16_V_M1_M4_MASK (9852) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI16_V_M1_MF2 (9853) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI16_V_M1_MF2_MASK (9854) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI16_V_M2_M1 (9855) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI16_V_M2_M1_MASK (9856) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI16_V_M2_M2 (9857) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI16_V_M2_M2_MASK (9858) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI16_V_M2_M4 (9859) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI16_V_M2_M4_MASK (9860) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI16_V_M2_M8 (9861) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI16_V_M2_M8_MASK (9862) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI16_V_M4_M2 (9863) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI16_V_M4_M2_MASK (9864) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI16_V_M4_M4 (9865) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI16_V_M4_M4_MASK (9866) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI16_V_M4_M8 (9867) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI16_V_M4_M8_MASK (9868) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI16_V_M8_M4 (9869) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI16_V_M8_M4_MASK (9870) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI16_V_M8_M8 (9871) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI16_V_M8_M8_MASK (9872) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI16_V_MF2_M1 (9873) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI16_V_MF2_M1_MASK (9874) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI16_V_MF2_M2 (9875) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI16_V_MF2_M2_MASK (9876) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI16_V_MF2_MF2 (9877) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI16_V_MF2_MF2_MASK (9878) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI16_V_MF2_MF4 (9879) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI16_V_MF2_MF4_MASK (9880) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI16_V_MF4_M1 (9881) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI16_V_MF4_M1_MASK (9882) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI16_V_MF4_MF2 (9883) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI16_V_MF4_MF2_MASK (9884) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI16_V_MF4_MF4 (9885) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI16_V_MF4_MF4_MASK (9886) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI16_V_MF4_MF8 (9887) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI16_V_MF4_MF8_MASK (9888) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI32_V_M1_M1 (9889) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI32_V_M1_M1_MASK (9890) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI32_V_M1_M2 (9891) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI32_V_M1_M2_MASK (9892) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI32_V_M1_MF2 (9893) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI32_V_M1_MF2_MASK (9894) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI32_V_M1_MF4 (9895) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI32_V_M1_MF4_MASK (9896) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI32_V_M2_M1 (9897) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI32_V_M2_M1_MASK (9898) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI32_V_M2_M2 (9899) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI32_V_M2_M2_MASK (9900) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI32_V_M2_M4 (9901) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI32_V_M2_M4_MASK (9902) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI32_V_M2_MF2 (9903) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI32_V_M2_MF2_MASK (9904) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI32_V_M4_M1 (9905) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI32_V_M4_M1_MASK (9906) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI32_V_M4_M2 (9907) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI32_V_M4_M2_MASK (9908) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI32_V_M4_M4 (9909) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI32_V_M4_M4_MASK (9910) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI32_V_M4_M8 (9911) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI32_V_M4_M8_MASK (9912) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI32_V_M8_M2 (9913) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI32_V_M8_M2_MASK (9914) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI32_V_M8_M4 (9915) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI32_V_M8_M4_MASK (9916) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI32_V_M8_M8 (9917) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI32_V_M8_M8_MASK (9918) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI32_V_MF2_M1 (9919) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI32_V_MF2_M1_MASK (9920) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI32_V_MF2_MF2 (9921) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI32_V_MF2_MF2_MASK (9922) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI32_V_MF2_MF4 (9923) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI32_V_MF2_MF4_MASK (9924) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI32_V_MF2_MF8 (9925) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI32_V_MF2_MF8_MASK (9926) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI64_V_M1_M1 (9927) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI64_V_M1_M1_MASK (9928) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI64_V_M1_MF2 (9929) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI64_V_M1_MF2_MASK (9930) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI64_V_M1_MF4 (9931) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI64_V_M1_MF4_MASK (9932) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI64_V_M1_MF8 (9933) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI64_V_M1_MF8_MASK (9934) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI64_V_M2_M1 (9935) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI64_V_M2_M1_MASK (9936) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI64_V_M2_M2 (9937) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI64_V_M2_M2_MASK (9938) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI64_V_M2_MF2 (9939) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI64_V_M2_MF2_MASK (9940) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI64_V_M2_MF4 (9941) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI64_V_M2_MF4_MASK (9942) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI64_V_M4_M1 (9943) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI64_V_M4_M1_MASK (9944) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI64_V_M4_M2 (9945) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI64_V_M4_M2_MASK (9946) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI64_V_M4_M4 (9947) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI64_V_M4_M4_MASK (9948) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI64_V_M4_MF2 (9949) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI64_V_M4_MF2_MASK (9950) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI64_V_M8_M1 (9951) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI64_V_M8_M1_MASK (9952) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI64_V_M8_M2 (9953) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI64_V_M8_M2_MASK (9954) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI64_V_M8_M4 (9955) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI64_V_M8_M4_MASK (9956) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI64_V_M8_M8 (9957) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI64_V_M8_M8_MASK (9958) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI8_V_M1_M1 (9959) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI8_V_M1_M1_MASK (9960) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI8_V_M1_M2 (9961) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI8_V_M1_M2_MASK (9962) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI8_V_M1_M4 (9963) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI8_V_M1_M4_MASK (9964) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI8_V_M1_M8 (9965) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI8_V_M1_M8_MASK (9966) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI8_V_M2_M2 (9967) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI8_V_M2_M2_MASK (9968) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI8_V_M2_M4 (9969) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI8_V_M2_M4_MASK (9970) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI8_V_M2_M8 (9971) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI8_V_M2_M8_MASK (9972) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI8_V_M4_M4 (9973) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI8_V_M4_M4_MASK (9974) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI8_V_M4_M8 (9975) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI8_V_M4_M8_MASK (9976) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI8_V_M8_M8 (9977) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI8_V_M8_M8_MASK (9978) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI8_V_MF2_M1 (9979) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI8_V_MF2_M1_MASK (9980) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI8_V_MF2_M2 (9981) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI8_V_MF2_M2_MASK (9982) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI8_V_MF2_M4 (9983) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI8_V_MF2_M4_MASK (9984) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI8_V_MF2_MF2 (9985) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI8_V_MF2_MF2_MASK (9986) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI8_V_MF4_M1 (9987) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI8_V_MF4_M1_MASK (9988) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI8_V_MF4_M2 (9989) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI8_V_MF4_M2_MASK (9990) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI8_V_MF4_MF2 (9991) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI8_V_MF4_MF2_MASK (9992) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI8_V_MF4_MF4 (9993) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI8_V_MF4_MF4_MASK (9994) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI8_V_MF8_M1 (9995) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI8_V_MF8_M1_MASK (9996) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI8_V_MF8_MF2 (9997) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI8_V_MF8_MF2_MASK (9998) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI8_V_MF8_MF4 (9999) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI8_V_MF8_MF4_MASK (10000) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI8_V_MF8_MF8 (10001) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXEI8_V_MF8_MF8_MASK (10002) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI16_V_M1_M1 (10003) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI16_V_M1_M1_MASK (10004) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI16_V_M1_M2 (10005) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI16_V_M1_M2_MASK (10006) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI16_V_M1_M4 (10007) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI16_V_M1_M4_MASK (10008) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI16_V_M1_MF2 (10009) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI16_V_M1_MF2_MASK (10010) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI16_V_M2_M1 (10011) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI16_V_M2_M1_MASK (10012) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI16_V_M2_M2 (10013) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI16_V_M2_M2_MASK (10014) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI16_V_M2_M4 (10015) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI16_V_M2_M4_MASK (10016) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI16_V_M4_M2 (10017) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI16_V_M4_M2_MASK (10018) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI16_V_M4_M4 (10019) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI16_V_M4_M4_MASK (10020) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI16_V_M8_M4 (10021) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI16_V_M8_M4_MASK (10022) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI16_V_MF2_M1 (10023) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI16_V_MF2_M1_MASK (10024) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI16_V_MF2_M2 (10025) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI16_V_MF2_M2_MASK (10026) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI16_V_MF2_MF2 (10027) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI16_V_MF2_MF2_MASK (10028) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI16_V_MF2_MF4 (10029) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI16_V_MF2_MF4_MASK (10030) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI16_V_MF4_M1 (10031) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI16_V_MF4_M1_MASK (10032) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI16_V_MF4_MF2 (10033) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI16_V_MF4_MF2_MASK (10034) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI16_V_MF4_MF4 (10035) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI16_V_MF4_MF4_MASK (10036) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI16_V_MF4_MF8 (10037) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI16_V_MF4_MF8_MASK (10038) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI32_V_M1_M1 (10039) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI32_V_M1_M1_MASK (10040) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI32_V_M1_M2 (10041) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI32_V_M1_M2_MASK (10042) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI32_V_M1_MF2 (10043) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI32_V_M1_MF2_MASK (10044) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI32_V_M1_MF4 (10045) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI32_V_M1_MF4_MASK (10046) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI32_V_M2_M1 (10047) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI32_V_M2_M1_MASK (10048) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI32_V_M2_M2 (10049) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI32_V_M2_M2_MASK (10050) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI32_V_M2_M4 (10051) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI32_V_M2_M4_MASK (10052) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI32_V_M2_MF2 (10053) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI32_V_M2_MF2_MASK (10054) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI32_V_M4_M1 (10055) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI32_V_M4_M1_MASK (10056) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI32_V_M4_M2 (10057) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI32_V_M4_M2_MASK (10058) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI32_V_M4_M4 (10059) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI32_V_M4_M4_MASK (10060) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI32_V_M8_M2 (10061) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI32_V_M8_M2_MASK (10062) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI32_V_M8_M4 (10063) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI32_V_M8_M4_MASK (10064) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI32_V_MF2_M1 (10065) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI32_V_MF2_M1_MASK (10066) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI32_V_MF2_MF2 (10067) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI32_V_MF2_MF2_MASK (10068) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI32_V_MF2_MF4 (10069) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI32_V_MF2_MF4_MASK (10070) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI32_V_MF2_MF8 (10071) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI32_V_MF2_MF8_MASK (10072) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI64_V_M1_M1 (10073) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI64_V_M1_M1_MASK (10074) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI64_V_M1_MF2 (10075) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI64_V_M1_MF2_MASK (10076) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI64_V_M1_MF4 (10077) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI64_V_M1_MF4_MASK (10078) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI64_V_M1_MF8 (10079) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI64_V_M1_MF8_MASK (10080) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI64_V_M2_M1 (10081) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI64_V_M2_M1_MASK (10082) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI64_V_M2_M2 (10083) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI64_V_M2_M2_MASK (10084) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI64_V_M2_MF2 (10085) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI64_V_M2_MF2_MASK (10086) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI64_V_M2_MF4 (10087) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI64_V_M2_MF4_MASK (10088) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI64_V_M4_M1 (10089) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI64_V_M4_M1_MASK (10090) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI64_V_M4_M2 (10091) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI64_V_M4_M2_MASK (10092) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI64_V_M4_M4 (10093) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI64_V_M4_M4_MASK (10094) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI64_V_M4_MF2 (10095) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI64_V_M4_MF2_MASK (10096) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI64_V_M8_M1 (10097) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI64_V_M8_M1_MASK (10098) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI64_V_M8_M2 (10099) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI64_V_M8_M2_MASK (10100) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI64_V_M8_M4 (10101) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI64_V_M8_M4_MASK (10102) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI8_V_M1_M1 (10103) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI8_V_M1_M1_MASK (10104) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI8_V_M1_M2 (10105) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI8_V_M1_M2_MASK (10106) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI8_V_M1_M4 (10107) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI8_V_M1_M4_MASK (10108) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI8_V_M2_M2 (10109) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI8_V_M2_M2_MASK (10110) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI8_V_M2_M4 (10111) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI8_V_M2_M4_MASK (10112) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI8_V_M4_M4 (10113) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI8_V_M4_M4_MASK (10114) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI8_V_MF2_M1 (10115) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI8_V_MF2_M1_MASK (10116) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI8_V_MF2_M2 (10117) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI8_V_MF2_M2_MASK (10118) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI8_V_MF2_M4 (10119) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI8_V_MF2_M4_MASK (10120) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI8_V_MF2_MF2 (10121) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI8_V_MF2_MF2_MASK (10122) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI8_V_MF4_M1 (10123) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI8_V_MF4_M1_MASK (10124) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI8_V_MF4_M2 (10125) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI8_V_MF4_M2_MASK (10126) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI8_V_MF4_MF2 (10127) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI8_V_MF4_MF2_MASK (10128) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI8_V_MF4_MF4 (10129) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI8_V_MF4_MF4_MASK (10130) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI8_V_MF8_M1 (10131) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI8_V_MF8_M1_MASK (10132) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI8_V_MF8_MF2 (10133) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI8_V_MF8_MF2_MASK (10134) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI8_V_MF8_MF4 (10135) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI8_V_MF8_MF4_MASK (10136) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI8_V_MF8_MF8 (10137) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG2EI8_V_MF8_MF8_MASK (10138) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI16_V_M1_M1 (10139) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI16_V_M1_M1_MASK (10140) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI16_V_M1_M2 (10141) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI16_V_M1_M2_MASK (10142) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI16_V_M1_MF2 (10143) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI16_V_M1_MF2_MASK (10144) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI16_V_M2_M1 (10145) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI16_V_M2_M1_MASK (10146) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI16_V_M2_M2 (10147) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI16_V_M2_M2_MASK (10148) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI16_V_M4_M2 (10149) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI16_V_M4_M2_MASK (10150) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI16_V_MF2_M1 (10151) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI16_V_MF2_M1_MASK (10152) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI16_V_MF2_M2 (10153) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI16_V_MF2_M2_MASK (10154) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI16_V_MF2_MF2 (10155) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI16_V_MF2_MF2_MASK (10156) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI16_V_MF2_MF4 (10157) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI16_V_MF2_MF4_MASK (10158) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI16_V_MF4_M1 (10159) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI16_V_MF4_M1_MASK (10160) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI16_V_MF4_MF2 (10161) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI16_V_MF4_MF2_MASK (10162) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI16_V_MF4_MF4 (10163) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI16_V_MF4_MF4_MASK (10164) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI16_V_MF4_MF8 (10165) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI16_V_MF4_MF8_MASK (10166) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI32_V_M1_M1 (10167) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI32_V_M1_M1_MASK (10168) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI32_V_M1_M2 (10169) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI32_V_M1_M2_MASK (10170) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI32_V_M1_MF2 (10171) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI32_V_M1_MF2_MASK (10172) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI32_V_M1_MF4 (10173) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI32_V_M1_MF4_MASK (10174) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI32_V_M2_M1 (10175) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI32_V_M2_M1_MASK (10176) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI32_V_M2_M2 (10177) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI32_V_M2_M2_MASK (10178) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI32_V_M2_MF2 (10179) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI32_V_M2_MF2_MASK (10180) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI32_V_M4_M1 (10181) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI32_V_M4_M1_MASK (10182) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI32_V_M4_M2 (10183) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI32_V_M4_M2_MASK (10184) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI32_V_M8_M2 (10185) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI32_V_M8_M2_MASK (10186) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI32_V_MF2_M1 (10187) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI32_V_MF2_M1_MASK (10188) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI32_V_MF2_MF2 (10189) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI32_V_MF2_MF2_MASK (10190) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI32_V_MF2_MF4 (10191) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI32_V_MF2_MF4_MASK (10192) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI32_V_MF2_MF8 (10193) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI32_V_MF2_MF8_MASK (10194) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI64_V_M1_M1 (10195) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI64_V_M1_M1_MASK (10196) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI64_V_M1_MF2 (10197) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI64_V_M1_MF2_MASK (10198) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI64_V_M1_MF4 (10199) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI64_V_M1_MF4_MASK (10200) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI64_V_M1_MF8 (10201) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI64_V_M1_MF8_MASK (10202) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI64_V_M2_M1 (10203) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI64_V_M2_M1_MASK (10204) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI64_V_M2_M2 (10205) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI64_V_M2_M2_MASK (10206) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI64_V_M2_MF2 (10207) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI64_V_M2_MF2_MASK (10208) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI64_V_M2_MF4 (10209) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI64_V_M2_MF4_MASK (10210) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI64_V_M4_M1 (10211) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI64_V_M4_M1_MASK (10212) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI64_V_M4_M2 (10213) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI64_V_M4_M2_MASK (10214) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI64_V_M4_MF2 (10215) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI64_V_M4_MF2_MASK (10216) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI64_V_M8_M1 (10217) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI64_V_M8_M1_MASK (10218) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI64_V_M8_M2 (10219) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI64_V_M8_M2_MASK (10220) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI8_V_M1_M1 (10221) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI8_V_M1_M1_MASK (10222) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI8_V_M1_M2 (10223) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI8_V_M1_M2_MASK (10224) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI8_V_M2_M2 (10225) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI8_V_M2_M2_MASK (10226) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI8_V_MF2_M1 (10227) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI8_V_MF2_M1_MASK (10228) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI8_V_MF2_M2 (10229) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI8_V_MF2_M2_MASK (10230) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI8_V_MF2_MF2 (10231) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI8_V_MF2_MF2_MASK (10232) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI8_V_MF4_M1 (10233) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI8_V_MF4_M1_MASK (10234) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI8_V_MF4_M2 (10235) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI8_V_MF4_M2_MASK (10236) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI8_V_MF4_MF2 (10237) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI8_V_MF4_MF2_MASK (10238) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI8_V_MF4_MF4 (10239) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI8_V_MF4_MF4_MASK (10240) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI8_V_MF8_M1 (10241) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI8_V_MF8_M1_MASK (10242) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI8_V_MF8_MF2 (10243) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI8_V_MF8_MF2_MASK (10244) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI8_V_MF8_MF4 (10245) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI8_V_MF8_MF4_MASK (10246) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI8_V_MF8_MF8 (10247) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG3EI8_V_MF8_MF8_MASK (10248) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI16_V_M1_M1 (10249) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI16_V_M1_M1_MASK (10250) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI16_V_M1_M2 (10251) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI16_V_M1_M2_MASK (10252) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI16_V_M1_MF2 (10253) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI16_V_M1_MF2_MASK (10254) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI16_V_M2_M1 (10255) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI16_V_M2_M1_MASK (10256) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI16_V_M2_M2 (10257) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI16_V_M2_M2_MASK (10258) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI16_V_M4_M2 (10259) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI16_V_M4_M2_MASK (10260) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI16_V_MF2_M1 (10261) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI16_V_MF2_M1_MASK (10262) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI16_V_MF2_M2 (10263) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI16_V_MF2_M2_MASK (10264) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI16_V_MF2_MF2 (10265) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI16_V_MF2_MF2_MASK (10266) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI16_V_MF2_MF4 (10267) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI16_V_MF2_MF4_MASK (10268) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI16_V_MF4_M1 (10269) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI16_V_MF4_M1_MASK (10270) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI16_V_MF4_MF2 (10271) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI16_V_MF4_MF2_MASK (10272) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI16_V_MF4_MF4 (10273) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI16_V_MF4_MF4_MASK (10274) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI16_V_MF4_MF8 (10275) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI16_V_MF4_MF8_MASK (10276) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI32_V_M1_M1 (10277) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI32_V_M1_M1_MASK (10278) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI32_V_M1_M2 (10279) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI32_V_M1_M2_MASK (10280) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI32_V_M1_MF2 (10281) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI32_V_M1_MF2_MASK (10282) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI32_V_M1_MF4 (10283) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI32_V_M1_MF4_MASK (10284) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI32_V_M2_M1 (10285) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI32_V_M2_M1_MASK (10286) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI32_V_M2_M2 (10287) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI32_V_M2_M2_MASK (10288) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI32_V_M2_MF2 (10289) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI32_V_M2_MF2_MASK (10290) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI32_V_M4_M1 (10291) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI32_V_M4_M1_MASK (10292) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI32_V_M4_M2 (10293) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI32_V_M4_M2_MASK (10294) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI32_V_M8_M2 (10295) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI32_V_M8_M2_MASK (10296) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI32_V_MF2_M1 (10297) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI32_V_MF2_M1_MASK (10298) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI32_V_MF2_MF2 (10299) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI32_V_MF2_MF2_MASK (10300) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI32_V_MF2_MF4 (10301) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI32_V_MF2_MF4_MASK (10302) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI32_V_MF2_MF8 (10303) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI32_V_MF2_MF8_MASK (10304) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI64_V_M1_M1 (10305) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI64_V_M1_M1_MASK (10306) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI64_V_M1_MF2 (10307) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI64_V_M1_MF2_MASK (10308) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI64_V_M1_MF4 (10309) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI64_V_M1_MF4_MASK (10310) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI64_V_M1_MF8 (10311) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI64_V_M1_MF8_MASK (10312) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI64_V_M2_M1 (10313) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI64_V_M2_M1_MASK (10314) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI64_V_M2_M2 (10315) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI64_V_M2_M2_MASK (10316) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI64_V_M2_MF2 (10317) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI64_V_M2_MF2_MASK (10318) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI64_V_M2_MF4 (10319) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI64_V_M2_MF4_MASK (10320) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI64_V_M4_M1 (10321) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI64_V_M4_M1_MASK (10322) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI64_V_M4_M2 (10323) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI64_V_M4_M2_MASK (10324) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI64_V_M4_MF2 (10325) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI64_V_M4_MF2_MASK (10326) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI64_V_M8_M1 (10327) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI64_V_M8_M1_MASK (10328) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI64_V_M8_M2 (10329) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI64_V_M8_M2_MASK (10330) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI8_V_M1_M1 (10331) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI8_V_M1_M1_MASK (10332) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI8_V_M1_M2 (10333) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI8_V_M1_M2_MASK (10334) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI8_V_M2_M2 (10335) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI8_V_M2_M2_MASK (10336) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI8_V_MF2_M1 (10337) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI8_V_MF2_M1_MASK (10338) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI8_V_MF2_M2 (10339) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI8_V_MF2_M2_MASK (10340) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI8_V_MF2_MF2 (10341) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI8_V_MF2_MF2_MASK (10342) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI8_V_MF4_M1 (10343) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI8_V_MF4_M1_MASK (10344) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI8_V_MF4_M2 (10345) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI8_V_MF4_M2_MASK (10346) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI8_V_MF4_MF2 (10347) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI8_V_MF4_MF2_MASK (10348) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI8_V_MF4_MF4 (10349) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI8_V_MF4_MF4_MASK (10350) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI8_V_MF8_M1 (10351) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI8_V_MF8_M1_MASK (10352) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI8_V_MF8_MF2 (10353) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI8_V_MF8_MF2_MASK (10354) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI8_V_MF8_MF4 (10355) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI8_V_MF8_MF4_MASK (10356) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI8_V_MF8_MF8 (10357) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG4EI8_V_MF8_MF8_MASK (10358) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI16_V_M1_M1 (10359) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI16_V_M1_M1_MASK (10360) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI16_V_M1_MF2 (10361) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI16_V_M1_MF2_MASK (10362) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI16_V_M2_M1 (10363) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI16_V_M2_M1_MASK (10364) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI16_V_MF2_M1 (10365) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI16_V_MF2_M1_MASK (10366) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI16_V_MF2_MF2 (10367) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI16_V_MF2_MF2_MASK (10368) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI16_V_MF2_MF4 (10369) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI16_V_MF2_MF4_MASK (10370) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI16_V_MF4_M1 (10371) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI16_V_MF4_M1_MASK (10372) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI16_V_MF4_MF2 (10373) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI16_V_MF4_MF2_MASK (10374) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI16_V_MF4_MF4 (10375) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI16_V_MF4_MF4_MASK (10376) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI16_V_MF4_MF8 (10377) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI16_V_MF4_MF8_MASK (10378) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI32_V_M1_M1 (10379) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI32_V_M1_M1_MASK (10380) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI32_V_M1_MF2 (10381) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI32_V_M1_MF2_MASK (10382) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI32_V_M1_MF4 (10383) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI32_V_M1_MF4_MASK (10384) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI32_V_M2_M1 (10385) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI32_V_M2_M1_MASK (10386) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI32_V_M2_MF2 (10387) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI32_V_M2_MF2_MASK (10388) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI32_V_M4_M1 (10389) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI32_V_M4_M1_MASK (10390) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI32_V_MF2_M1 (10391) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI32_V_MF2_M1_MASK (10392) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI32_V_MF2_MF2 (10393) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI32_V_MF2_MF2_MASK (10394) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI32_V_MF2_MF4 (10395) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI32_V_MF2_MF4_MASK (10396) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI32_V_MF2_MF8 (10397) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI32_V_MF2_MF8_MASK (10398) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI64_V_M1_M1 (10399) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI64_V_M1_M1_MASK (10400) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI64_V_M1_MF2 (10401) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI64_V_M1_MF2_MASK (10402) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI64_V_M1_MF4 (10403) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI64_V_M1_MF4_MASK (10404) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI64_V_M1_MF8 (10405) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI64_V_M1_MF8_MASK (10406) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI64_V_M2_M1 (10407) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI64_V_M2_M1_MASK (10408) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI64_V_M2_MF2 (10409) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI64_V_M2_MF2_MASK (10410) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI64_V_M2_MF4 (10411) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI64_V_M2_MF4_MASK (10412) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI64_V_M4_M1 (10413) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI64_V_M4_M1_MASK (10414) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI64_V_M4_MF2 (10415) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI64_V_M4_MF2_MASK (10416) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI64_V_M8_M1 (10417) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI64_V_M8_M1_MASK (10418) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI8_V_M1_M1 (10419) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI8_V_M1_M1_MASK (10420) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI8_V_MF2_M1 (10421) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI8_V_MF2_M1_MASK (10422) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI8_V_MF2_MF2 (10423) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI8_V_MF2_MF2_MASK (10424) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI8_V_MF4_M1 (10425) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI8_V_MF4_M1_MASK (10426) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI8_V_MF4_MF2 (10427) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI8_V_MF4_MF2_MASK (10428) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI8_V_MF4_MF4 (10429) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI8_V_MF4_MF4_MASK (10430) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI8_V_MF8_M1 (10431) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI8_V_MF8_M1_MASK (10432) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI8_V_MF8_MF2 (10433) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI8_V_MF8_MF2_MASK (10434) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI8_V_MF8_MF4 (10435) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI8_V_MF8_MF4_MASK (10436) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI8_V_MF8_MF8 (10437) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG5EI8_V_MF8_MF8_MASK (10438) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI16_V_M1_M1 (10439) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI16_V_M1_M1_MASK (10440) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI16_V_M1_MF2 (10441) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI16_V_M1_MF2_MASK (10442) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI16_V_M2_M1 (10443) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI16_V_M2_M1_MASK (10444) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI16_V_MF2_M1 (10445) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI16_V_MF2_M1_MASK (10446) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI16_V_MF2_MF2 (10447) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI16_V_MF2_MF2_MASK (10448) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI16_V_MF2_MF4 (10449) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI16_V_MF2_MF4_MASK (10450) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI16_V_MF4_M1 (10451) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI16_V_MF4_M1_MASK (10452) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI16_V_MF4_MF2 (10453) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI16_V_MF4_MF2_MASK (10454) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI16_V_MF4_MF4 (10455) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI16_V_MF4_MF4_MASK (10456) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI16_V_MF4_MF8 (10457) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI16_V_MF4_MF8_MASK (10458) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI32_V_M1_M1 (10459) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI32_V_M1_M1_MASK (10460) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI32_V_M1_MF2 (10461) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI32_V_M1_MF2_MASK (10462) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI32_V_M1_MF4 (10463) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI32_V_M1_MF4_MASK (10464) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI32_V_M2_M1 (10465) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI32_V_M2_M1_MASK (10466) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI32_V_M2_MF2 (10467) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI32_V_M2_MF2_MASK (10468) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI32_V_M4_M1 (10469) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI32_V_M4_M1_MASK (10470) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI32_V_MF2_M1 (10471) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI32_V_MF2_M1_MASK (10472) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI32_V_MF2_MF2 (10473) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI32_V_MF2_MF2_MASK (10474) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI32_V_MF2_MF4 (10475) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI32_V_MF2_MF4_MASK (10476) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI32_V_MF2_MF8 (10477) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI32_V_MF2_MF8_MASK (10478) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI64_V_M1_M1 (10479) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI64_V_M1_M1_MASK (10480) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI64_V_M1_MF2 (10481) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI64_V_M1_MF2_MASK (10482) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI64_V_M1_MF4 (10483) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI64_V_M1_MF4_MASK (10484) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI64_V_M1_MF8 (10485) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI64_V_M1_MF8_MASK (10486) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI64_V_M2_M1 (10487) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI64_V_M2_M1_MASK (10488) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI64_V_M2_MF2 (10489) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI64_V_M2_MF2_MASK (10490) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI64_V_M2_MF4 (10491) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI64_V_M2_MF4_MASK (10492) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI64_V_M4_M1 (10493) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI64_V_M4_M1_MASK (10494) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI64_V_M4_MF2 (10495) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI64_V_M4_MF2_MASK (10496) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI64_V_M8_M1 (10497) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI64_V_M8_M1_MASK (10498) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI8_V_M1_M1 (10499) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI8_V_M1_M1_MASK (10500) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI8_V_MF2_M1 (10501) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI8_V_MF2_M1_MASK (10502) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI8_V_MF2_MF2 (10503) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI8_V_MF2_MF2_MASK (10504) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI8_V_MF4_M1 (10505) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI8_V_MF4_M1_MASK (10506) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI8_V_MF4_MF2 (10507) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI8_V_MF4_MF2_MASK (10508) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI8_V_MF4_MF4 (10509) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI8_V_MF4_MF4_MASK (10510) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI8_V_MF8_M1 (10511) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI8_V_MF8_M1_MASK (10512) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI8_V_MF8_MF2 (10513) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI8_V_MF8_MF2_MASK (10514) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI8_V_MF8_MF4 (10515) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI8_V_MF8_MF4_MASK (10516) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI8_V_MF8_MF8 (10517) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG6EI8_V_MF8_MF8_MASK (10518) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI16_V_M1_M1 (10519) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI16_V_M1_M1_MASK (10520) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI16_V_M1_MF2 (10521) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI16_V_M1_MF2_MASK (10522) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI16_V_M2_M1 (10523) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI16_V_M2_M1_MASK (10524) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI16_V_MF2_M1 (10525) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI16_V_MF2_M1_MASK (10526) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI16_V_MF2_MF2 (10527) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI16_V_MF2_MF2_MASK (10528) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI16_V_MF2_MF4 (10529) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI16_V_MF2_MF4_MASK (10530) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI16_V_MF4_M1 (10531) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI16_V_MF4_M1_MASK (10532) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI16_V_MF4_MF2 (10533) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI16_V_MF4_MF2_MASK (10534) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI16_V_MF4_MF4 (10535) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI16_V_MF4_MF4_MASK (10536) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI16_V_MF4_MF8 (10537) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI16_V_MF4_MF8_MASK (10538) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI32_V_M1_M1 (10539) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI32_V_M1_M1_MASK (10540) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI32_V_M1_MF2 (10541) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI32_V_M1_MF2_MASK (10542) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI32_V_M1_MF4 (10543) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI32_V_M1_MF4_MASK (10544) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI32_V_M2_M1 (10545) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI32_V_M2_M1_MASK (10546) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI32_V_M2_MF2 (10547) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI32_V_M2_MF2_MASK (10548) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI32_V_M4_M1 (10549) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI32_V_M4_M1_MASK (10550) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI32_V_MF2_M1 (10551) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI32_V_MF2_M1_MASK (10552) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI32_V_MF2_MF2 (10553) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI32_V_MF2_MF2_MASK (10554) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI32_V_MF2_MF4 (10555) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI32_V_MF2_MF4_MASK (10556) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI32_V_MF2_MF8 (10557) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI32_V_MF2_MF8_MASK (10558) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI64_V_M1_M1 (10559) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI64_V_M1_M1_MASK (10560) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI64_V_M1_MF2 (10561) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI64_V_M1_MF2_MASK (10562) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI64_V_M1_MF4 (10563) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI64_V_M1_MF4_MASK (10564) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI64_V_M1_MF8 (10565) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI64_V_M1_MF8_MASK (10566) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI64_V_M2_M1 (10567) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI64_V_M2_M1_MASK (10568) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI64_V_M2_MF2 (10569) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI64_V_M2_MF2_MASK (10570) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI64_V_M2_MF4 (10571) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI64_V_M2_MF4_MASK (10572) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI64_V_M4_M1 (10573) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI64_V_M4_M1_MASK (10574) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI64_V_M4_MF2 (10575) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI64_V_M4_MF2_MASK (10576) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI64_V_M8_M1 (10577) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI64_V_M8_M1_MASK (10578) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI8_V_M1_M1 (10579) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI8_V_M1_M1_MASK (10580) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI8_V_MF2_M1 (10581) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI8_V_MF2_M1_MASK (10582) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI8_V_MF2_MF2 (10583) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI8_V_MF2_MF2_MASK (10584) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI8_V_MF4_M1 (10585) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI8_V_MF4_M1_MASK (10586) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI8_V_MF4_MF2 (10587) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI8_V_MF4_MF2_MASK (10588) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI8_V_MF4_MF4 (10589) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI8_V_MF4_MF4_MASK (10590) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI8_V_MF8_M1 (10591) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI8_V_MF8_M1_MASK (10592) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI8_V_MF8_MF2 (10593) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI8_V_MF8_MF2_MASK (10594) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI8_V_MF8_MF4 (10595) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI8_V_MF8_MF4_MASK (10596) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI8_V_MF8_MF8 (10597) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG7EI8_V_MF8_MF8_MASK (10598) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI16_V_M1_M1 (10599) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI16_V_M1_M1_MASK (10600) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI16_V_M1_MF2 (10601) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI16_V_M1_MF2_MASK (10602) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI16_V_M2_M1 (10603) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI16_V_M2_M1_MASK (10604) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI16_V_MF2_M1 (10605) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI16_V_MF2_M1_MASK (10606) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI16_V_MF2_MF2 (10607) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI16_V_MF2_MF2_MASK (10608) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI16_V_MF2_MF4 (10609) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI16_V_MF2_MF4_MASK (10610) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI16_V_MF4_M1 (10611) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI16_V_MF4_M1_MASK (10612) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI16_V_MF4_MF2 (10613) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI16_V_MF4_MF2_MASK (10614) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI16_V_MF4_MF4 (10615) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI16_V_MF4_MF4_MASK (10616) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI16_V_MF4_MF8 (10617) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI16_V_MF4_MF8_MASK (10618) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI32_V_M1_M1 (10619) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI32_V_M1_M1_MASK (10620) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI32_V_M1_MF2 (10621) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI32_V_M1_MF2_MASK (10622) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI32_V_M1_MF4 (10623) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI32_V_M1_MF4_MASK (10624) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI32_V_M2_M1 (10625) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI32_V_M2_M1_MASK (10626) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI32_V_M2_MF2 (10627) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI32_V_M2_MF2_MASK (10628) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI32_V_M4_M1 (10629) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI32_V_M4_M1_MASK (10630) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI32_V_MF2_M1 (10631) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI32_V_MF2_M1_MASK (10632) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI32_V_MF2_MF2 (10633) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI32_V_MF2_MF2_MASK (10634) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI32_V_MF2_MF4 (10635) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI32_V_MF2_MF4_MASK (10636) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI32_V_MF2_MF8 (10637) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI32_V_MF2_MF8_MASK (10638) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI64_V_M1_M1 (10639) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI64_V_M1_M1_MASK (10640) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI64_V_M1_MF2 (10641) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI64_V_M1_MF2_MASK (10642) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI64_V_M1_MF4 (10643) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI64_V_M1_MF4_MASK (10644) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI64_V_M1_MF8 (10645) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI64_V_M1_MF8_MASK (10646) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI64_V_M2_M1 (10647) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI64_V_M2_M1_MASK (10648) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI64_V_M2_MF2 (10649) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI64_V_M2_MF2_MASK (10650) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI64_V_M2_MF4 (10651) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI64_V_M2_MF4_MASK (10652) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI64_V_M4_M1 (10653) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI64_V_M4_M1_MASK (10654) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI64_V_M4_MF2 (10655) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI64_V_M4_MF2_MASK (10656) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI64_V_M8_M1 (10657) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI64_V_M8_M1_MASK (10658) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI8_V_M1_M1 (10659) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI8_V_M1_M1_MASK (10660) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI8_V_MF2_M1 (10661) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI8_V_MF2_M1_MASK (10662) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI8_V_MF2_MF2 (10663) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI8_V_MF2_MF2_MASK (10664) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI8_V_MF4_M1 (10665) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI8_V_MF4_M1_MASK (10666) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI8_V_MF4_MF2 (10667) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI8_V_MF4_MF2_MASK (10668) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI8_V_MF4_MF4 (10669) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI8_V_MF4_MF4_MASK (10670) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI8_V_MF8_M1 (10671) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI8_V_MF8_M1_MASK (10672) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI8_V_MF8_MF2 (10673) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI8_V_MF8_MF2_MASK (10674) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI8_V_MF8_MF4 (10675) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI8_V_MF8_MF4_MASK (10676) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI8_V_MF8_MF8 (10677) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVSUXSEG8EI8_V_MF8_MF8_MASK (10678) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_VV_M1 (10679) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_VV_M1_MASK (10680) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_VV_M2 (10681) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_VV_M2_MASK (10682) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_VV_M4 (10683) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_VV_M4_MASK (10684) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_VV_MF2 (10685) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_VV_MF2_MASK (10686) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_VV_MF4 (10687) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_VV_MF4_MASK (10688) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_VV_MF8 (10689) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_VV_MF8_MASK (10690) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_VX_M1 (10691) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_VX_M1_MASK (10692) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_VX_M2 (10693) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_VX_M2_MASK (10694) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_VX_M4 (10695) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_VX_M4_MASK (10696) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_VX_MF2 (10697) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_VX_MF2_MASK (10698) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_VX_MF4 (10699) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_VX_MF4_MASK (10700) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_VX_MF8 (10701) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_VX_MF8_MASK (10702) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_WV_M1 (10703) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_WV_M1_MASK (10704) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_WV_M1_MASK_TIED (10705) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_WV_M1_TIED (10706) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_WV_M2 (10707) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_WV_M2_MASK (10708) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_WV_M2_MASK_TIED (10709) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_WV_M2_TIED (10710) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_WV_M4 (10711) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_WV_M4_MASK (10712) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_WV_M4_MASK_TIED (10713) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_WV_M4_TIED (10714) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_WV_MF2 (10715) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_WV_MF2_MASK (10716) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_WV_MF2_MASK_TIED (10717) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_WV_MF2_TIED (10718) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_WV_MF4 (10719) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_WV_MF4_MASK (10720) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_WV_MF4_MASK_TIED (10721) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_WV_MF4_TIED (10722) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_WV_MF8 (10723) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_WV_MF8_MASK (10724) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_WV_MF8_MASK_TIED (10725) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_WV_MF8_TIED (10726) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_WX_M1 (10727) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_WX_M1_MASK (10728) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_WX_M2 (10729) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_WX_M2_MASK (10730) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_WX_M4 (10731) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_WX_M4_MASK (10732) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_WX_MF2 (10733) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_WX_MF2_MASK (10734) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_WX_MF4 (10735) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_WX_MF4_MASK (10736) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_WX_MF8 (10737) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADDU_WX_MF8_MASK (10738) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_VV_M1 (10739) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_VV_M1_MASK (10740) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_VV_M2 (10741) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_VV_M2_MASK (10742) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_VV_M4 (10743) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_VV_M4_MASK (10744) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_VV_MF2 (10745) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_VV_MF2_MASK (10746) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_VV_MF4 (10747) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_VV_MF4_MASK (10748) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_VV_MF8 (10749) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_VV_MF8_MASK (10750) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_VX_M1 (10751) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_VX_M1_MASK (10752) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_VX_M2 (10753) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_VX_M2_MASK (10754) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_VX_M4 (10755) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_VX_M4_MASK (10756) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_VX_MF2 (10757) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_VX_MF2_MASK (10758) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_VX_MF4 (10759) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_VX_MF4_MASK (10760) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_VX_MF8 (10761) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_VX_MF8_MASK (10762) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_WV_M1 (10763) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_WV_M1_MASK (10764) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_WV_M1_MASK_TIED (10765) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_WV_M1_TIED (10766) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_WV_M2 (10767) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_WV_M2_MASK (10768) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_WV_M2_MASK_TIED (10769) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_WV_M2_TIED (10770) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_WV_M4 (10771) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_WV_M4_MASK (10772) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_WV_M4_MASK_TIED (10773) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_WV_M4_TIED (10774) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_WV_MF2 (10775) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_WV_MF2_MASK (10776) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_WV_MF2_MASK_TIED (10777) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_WV_MF2_TIED (10778) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_WV_MF4 (10779) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_WV_MF4_MASK (10780) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_WV_MF4_MASK_TIED (10781) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_WV_MF4_TIED (10782) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_WV_MF8 (10783) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_WV_MF8_MASK (10784) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_WV_MF8_MASK_TIED (10785) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_WV_MF8_TIED (10786) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_WX_M1 (10787) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_WX_M1_MASK (10788) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_WX_M2 (10789) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_WX_M2_MASK (10790) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_WX_M4 (10791) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_WX_M4_MASK (10792) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_WX_MF2 (10793) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_WX_MF2_MASK (10794) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_WX_MF4 (10795) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_WX_MF4_MASK (10796) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_WX_MF8 (10797) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWADD_WX_MF8_MASK (10798) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCSU_VV_M1 (10799) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCSU_VV_M1_MASK (10800) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCSU_VV_M2 (10801) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCSU_VV_M2_MASK (10802) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCSU_VV_M4 (10803) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCSU_VV_M4_MASK (10804) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCSU_VV_MF2 (10805) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCSU_VV_MF2_MASK (10806) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCSU_VV_MF4 (10807) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCSU_VV_MF4_MASK (10808) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCSU_VV_MF8 (10809) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCSU_VV_MF8_MASK (10810) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCSU_VX_M1 (10811) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCSU_VX_M1_MASK (10812) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCSU_VX_M2 (10813) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCSU_VX_M2_MASK (10814) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCSU_VX_M4 (10815) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCSU_VX_M4_MASK (10816) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCSU_VX_MF2 (10817) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCSU_VX_MF2_MASK (10818) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCSU_VX_MF4 (10819) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCSU_VX_MF4_MASK (10820) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCSU_VX_MF8 (10821) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCSU_VX_MF8_MASK (10822) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCUS_VX_M1 (10823) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCUS_VX_M1_MASK (10824) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCUS_VX_M2 (10825) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCUS_VX_M2_MASK (10826) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCUS_VX_M4 (10827) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCUS_VX_M4_MASK (10828) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCUS_VX_MF2 (10829) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCUS_VX_MF2_MASK (10830) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCUS_VX_MF4 (10831) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCUS_VX_MF4_MASK (10832) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCUS_VX_MF8 (10833) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCUS_VX_MF8_MASK (10834) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCU_VV_M1 (10835) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCU_VV_M1_MASK (10836) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCU_VV_M2 (10837) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCU_VV_M2_MASK (10838) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCU_VV_M4 (10839) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCU_VV_M4_MASK (10840) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCU_VV_MF2 (10841) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCU_VV_MF2_MASK (10842) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCU_VV_MF4 (10843) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCU_VV_MF4_MASK (10844) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCU_VV_MF8 (10845) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCU_VV_MF8_MASK (10846) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCU_VX_M1 (10847) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCU_VX_M1_MASK (10848) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCU_VX_M2 (10849) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCU_VX_M2_MASK (10850) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCU_VX_M4 (10851) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCU_VX_M4_MASK (10852) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCU_VX_MF2 (10853) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCU_VX_MF2_MASK (10854) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCU_VX_MF4 (10855) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCU_VX_MF4_MASK (10856) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCU_VX_MF8 (10857) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACCU_VX_MF8_MASK (10858) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACC_VV_M1 (10859) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACC_VV_M1_MASK (10860) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACC_VV_M2 (10861) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACC_VV_M2_MASK (10862) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACC_VV_M4 (10863) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACC_VV_M4_MASK (10864) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACC_VV_MF2 (10865) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACC_VV_MF2_MASK (10866) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACC_VV_MF4 (10867) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACC_VV_MF4_MASK (10868) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACC_VV_MF8 (10869) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACC_VV_MF8_MASK (10870) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACC_VX_M1 (10871) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACC_VX_M1_MASK (10872) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACC_VX_M2 (10873) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACC_VX_M2_MASK (10874) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACC_VX_M4 (10875) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACC_VX_M4_MASK (10876) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACC_VX_MF2 (10877) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACC_VX_MF2_MASK (10878) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACC_VX_MF4 (10879) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACC_VX_MF4_MASK (10880) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACC_VX_MF8 (10881) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMACC_VX_MF8_MASK (10882) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMULSU_VV_M1 (10883) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMULSU_VV_M1_MASK (10884) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMULSU_VV_M2 (10885) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMULSU_VV_M2_MASK (10886) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMULSU_VV_M4 (10887) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMULSU_VV_M4_MASK (10888) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMULSU_VV_MF2 (10889) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMULSU_VV_MF2_MASK (10890) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMULSU_VV_MF4 (10891) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMULSU_VV_MF4_MASK (10892) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMULSU_VV_MF8 (10893) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMULSU_VV_MF8_MASK (10894) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMULSU_VX_M1 (10895) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMULSU_VX_M1_MASK (10896) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMULSU_VX_M2 (10897) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMULSU_VX_M2_MASK (10898) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMULSU_VX_M4 (10899) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMULSU_VX_M4_MASK (10900) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMULSU_VX_MF2 (10901) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMULSU_VX_MF2_MASK (10902) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMULSU_VX_MF4 (10903) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMULSU_VX_MF4_MASK (10904) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMULSU_VX_MF8 (10905) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMULSU_VX_MF8_MASK (10906) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMULU_VV_M1 (10907) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMULU_VV_M1_MASK (10908) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMULU_VV_M2 (10909) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMULU_VV_M2_MASK (10910) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMULU_VV_M4 (10911) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMULU_VV_M4_MASK (10912) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMULU_VV_MF2 (10913) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMULU_VV_MF2_MASK (10914) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMULU_VV_MF4 (10915) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMULU_VV_MF4_MASK (10916) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMULU_VV_MF8 (10917) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMULU_VV_MF8_MASK (10918) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMULU_VX_M1 (10919) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMULU_VX_M1_MASK (10920) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMULU_VX_M2 (10921) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMULU_VX_M2_MASK (10922) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMULU_VX_M4 (10923) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMULU_VX_M4_MASK (10924) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMULU_VX_MF2 (10925) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMULU_VX_MF2_MASK (10926) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMULU_VX_MF4 (10927) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMULU_VX_MF4_MASK (10928) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMULU_VX_MF8 (10929) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMULU_VX_MF8_MASK (10930) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMUL_VV_M1 (10931) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMUL_VV_M1_MASK (10932) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMUL_VV_M2 (10933) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMUL_VV_M2_MASK (10934) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMUL_VV_M4 (10935) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMUL_VV_M4_MASK (10936) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMUL_VV_MF2 (10937) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMUL_VV_MF2_MASK (10938) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMUL_VV_MF4 (10939) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMUL_VV_MF4_MASK (10940) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMUL_VV_MF8 (10941) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMUL_VV_MF8_MASK (10942) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMUL_VX_M1 (10943) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMUL_VX_M1_MASK (10944) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMUL_VX_M2 (10945) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMUL_VX_M2_MASK (10946) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMUL_VX_M4 (10947) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMUL_VX_M4_MASK (10948) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMUL_VX_MF2 (10949) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMUL_VX_MF2_MASK (10950) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMUL_VX_MF4 (10951) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMUL_VX_MF4_MASK (10952) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMUL_VX_MF8 (10953) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWMUL_VX_MF8_MASK (10954) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUMU_VS_M1_E16 (10955) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUMU_VS_M1_E16_MASK (10956) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUMU_VS_M1_E32 (10957) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUMU_VS_M1_E32_MASK (10958) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUMU_VS_M1_E8 (10959) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUMU_VS_M1_E8_MASK (10960) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUMU_VS_M2_E16 (10961) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUMU_VS_M2_E16_MASK (10962) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUMU_VS_M2_E32 (10963) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUMU_VS_M2_E32_MASK (10964) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUMU_VS_M2_E8 (10965) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUMU_VS_M2_E8_MASK (10966) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUMU_VS_M4_E16 (10967) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUMU_VS_M4_E16_MASK (10968) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUMU_VS_M4_E32 (10969) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUMU_VS_M4_E32_MASK (10970) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUMU_VS_M4_E8 (10971) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUMU_VS_M4_E8_MASK (10972) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUMU_VS_M8_E16 (10973) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUMU_VS_M8_E16_MASK (10974) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUMU_VS_M8_E32 (10975) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUMU_VS_M8_E32_MASK (10976) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUMU_VS_M8_E8 (10977) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUMU_VS_M8_E8_MASK (10978) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUMU_VS_MF2_E16 (10979) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUMU_VS_MF2_E16_MASK (10980) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUMU_VS_MF2_E32 (10981) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUMU_VS_MF2_E32_MASK (10982) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUMU_VS_MF2_E8 (10983) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUMU_VS_MF2_E8_MASK (10984) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUMU_VS_MF4_E16 (10985) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUMU_VS_MF4_E16_MASK (10986) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUMU_VS_MF4_E8 (10987) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUMU_VS_MF4_E8_MASK (10988) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUMU_VS_MF8_E8 (10989) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUMU_VS_MF8_E8_MASK (10990) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUM_VS_M1_E16 (10991) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUM_VS_M1_E16_MASK (10992) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUM_VS_M1_E32 (10993) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUM_VS_M1_E32_MASK (10994) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUM_VS_M1_E8 (10995) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUM_VS_M1_E8_MASK (10996) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUM_VS_M2_E16 (10997) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUM_VS_M2_E16_MASK (10998) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUM_VS_M2_E32 (10999) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUM_VS_M2_E32_MASK (11000) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUM_VS_M2_E8 (11001) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUM_VS_M2_E8_MASK (11002) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUM_VS_M4_E16 (11003) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUM_VS_M4_E16_MASK (11004) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUM_VS_M4_E32 (11005) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUM_VS_M4_E32_MASK (11006) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUM_VS_M4_E8 (11007) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUM_VS_M4_E8_MASK (11008) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUM_VS_M8_E16 (11009) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUM_VS_M8_E16_MASK (11010) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUM_VS_M8_E32 (11011) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUM_VS_M8_E32_MASK (11012) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUM_VS_M8_E8 (11013) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUM_VS_M8_E8_MASK (11014) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUM_VS_MF2_E16 (11015) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUM_VS_MF2_E16_MASK (11016) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUM_VS_MF2_E32 (11017) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUM_VS_MF2_E32_MASK (11018) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUM_VS_MF2_E8 (11019) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUM_VS_MF2_E8_MASK (11020) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUM_VS_MF4_E16 (11021) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUM_VS_MF4_E16_MASK (11022) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUM_VS_MF4_E8 (11023) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUM_VS_MF4_E8_MASK (11024) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUM_VS_MF8_E8 (11025) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWREDSUM_VS_MF8_E8_MASK (11026) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSLL_VI_M1 (11027) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSLL_VI_M1_MASK (11028) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSLL_VI_M2 (11029) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSLL_VI_M2_MASK (11030) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSLL_VI_M4 (11031) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSLL_VI_M4_MASK (11032) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSLL_VI_MF2 (11033) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSLL_VI_MF2_MASK (11034) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSLL_VI_MF4 (11035) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSLL_VI_MF4_MASK (11036) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSLL_VI_MF8 (11037) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSLL_VI_MF8_MASK (11038) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSLL_VV_M1 (11039) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSLL_VV_M1_MASK (11040) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSLL_VV_M2 (11041) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSLL_VV_M2_MASK (11042) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSLL_VV_M4 (11043) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSLL_VV_M4_MASK (11044) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSLL_VV_MF2 (11045) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSLL_VV_MF2_MASK (11046) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSLL_VV_MF4 (11047) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSLL_VV_MF4_MASK (11048) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSLL_VV_MF8 (11049) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSLL_VV_MF8_MASK (11050) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSLL_VX_M1 (11051) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSLL_VX_M1_MASK (11052) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSLL_VX_M2 (11053) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSLL_VX_M2_MASK (11054) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSLL_VX_M4 (11055) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSLL_VX_M4_MASK (11056) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSLL_VX_MF2 (11057) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSLL_VX_MF2_MASK (11058) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSLL_VX_MF4 (11059) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSLL_VX_MF4_MASK (11060) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSLL_VX_MF8 (11061) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSLL_VX_MF8_MASK (11062) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_VV_M1 (11063) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_VV_M1_MASK (11064) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_VV_M2 (11065) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_VV_M2_MASK (11066) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_VV_M4 (11067) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_VV_M4_MASK (11068) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_VV_MF2 (11069) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_VV_MF2_MASK (11070) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_VV_MF4 (11071) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_VV_MF4_MASK (11072) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_VV_MF8 (11073) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_VV_MF8_MASK (11074) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_VX_M1 (11075) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_VX_M1_MASK (11076) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_VX_M2 (11077) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_VX_M2_MASK (11078) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_VX_M4 (11079) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_VX_M4_MASK (11080) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_VX_MF2 (11081) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_VX_MF2_MASK (11082) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_VX_MF4 (11083) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_VX_MF4_MASK (11084) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_VX_MF8 (11085) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_VX_MF8_MASK (11086) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_WV_M1 (11087) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_WV_M1_MASK (11088) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_WV_M1_MASK_TIED (11089) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_WV_M1_TIED (11090) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_WV_M2 (11091) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_WV_M2_MASK (11092) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_WV_M2_MASK_TIED (11093) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_WV_M2_TIED (11094) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_WV_M4 (11095) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_WV_M4_MASK (11096) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_WV_M4_MASK_TIED (11097) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_WV_M4_TIED (11098) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_WV_MF2 (11099) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_WV_MF2_MASK (11100) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_WV_MF2_MASK_TIED (11101) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_WV_MF2_TIED (11102) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_WV_MF4 (11103) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_WV_MF4_MASK (11104) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_WV_MF4_MASK_TIED (11105) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_WV_MF4_TIED (11106) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_WV_MF8 (11107) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_WV_MF8_MASK (11108) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_WV_MF8_MASK_TIED (11109) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_WV_MF8_TIED (11110) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_WX_M1 (11111) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_WX_M1_MASK (11112) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_WX_M2 (11113) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_WX_M2_MASK (11114) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_WX_M4 (11115) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_WX_M4_MASK (11116) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_WX_MF2 (11117) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_WX_MF2_MASK (11118) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_WX_MF4 (11119) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_WX_MF4_MASK (11120) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_WX_MF8 (11121) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUBU_WX_MF8_MASK (11122) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_VV_M1 (11123) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_VV_M1_MASK (11124) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_VV_M2 (11125) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_VV_M2_MASK (11126) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_VV_M4 (11127) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_VV_M4_MASK (11128) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_VV_MF2 (11129) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_VV_MF2_MASK (11130) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_VV_MF4 (11131) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_VV_MF4_MASK (11132) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_VV_MF8 (11133) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_VV_MF8_MASK (11134) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_VX_M1 (11135) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_VX_M1_MASK (11136) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_VX_M2 (11137) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_VX_M2_MASK (11138) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_VX_M4 (11139) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_VX_M4_MASK (11140) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_VX_MF2 (11141) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_VX_MF2_MASK (11142) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_VX_MF4 (11143) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_VX_MF4_MASK (11144) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_VX_MF8 (11145) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_VX_MF8_MASK (11146) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_WV_M1 (11147) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_WV_M1_MASK (11148) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_WV_M1_MASK_TIED (11149) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_WV_M1_TIED (11150) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_WV_M2 (11151) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_WV_M2_MASK (11152) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_WV_M2_MASK_TIED (11153) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_WV_M2_TIED (11154) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_WV_M4 (11155) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_WV_M4_MASK (11156) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_WV_M4_MASK_TIED (11157) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_WV_M4_TIED (11158) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_WV_MF2 (11159) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_WV_MF2_MASK (11160) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_WV_MF2_MASK_TIED (11161) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_WV_MF2_TIED (11162) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_WV_MF4 (11163) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_WV_MF4_MASK (11164) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_WV_MF4_MASK_TIED (11165) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_WV_MF4_TIED (11166) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_WV_MF8 (11167) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_WV_MF8_MASK (11168) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_WV_MF8_MASK_TIED (11169) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_WV_MF8_TIED (11170) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_WX_M1 (11171) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_WX_M1_MASK (11172) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_WX_M2 (11173) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_WX_M2_MASK (11174) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_WX_M4 (11175) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_WX_M4_MASK (11176) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_WX_MF2 (11177) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_WX_MF2_MASK (11178) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_WX_MF4 (11179) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_WX_MF4_MASK (11180) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_WX_MF8 (11181) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVWSUB_WX_MF8_MASK (11182) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVXOR_VI_M1 (11183) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVXOR_VI_M1_MASK (11184) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVXOR_VI_M2 (11185) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVXOR_VI_M2_MASK (11186) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVXOR_VI_M4 (11187) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVXOR_VI_M4_MASK (11188) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVXOR_VI_M8 (11189) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVXOR_VI_M8_MASK (11190) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVXOR_VI_MF2 (11191) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVXOR_VI_MF2_MASK (11192) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVXOR_VI_MF4 (11193) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVXOR_VI_MF4_MASK (11194) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVXOR_VI_MF8 (11195) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVXOR_VI_MF8_MASK (11196) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVXOR_VV_M1 (11197) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVXOR_VV_M1_MASK (11198) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVXOR_VV_M2 (11199) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVXOR_VV_M2_MASK (11200) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVXOR_VV_M4 (11201) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVXOR_VV_M4_MASK (11202) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVXOR_VV_M8 (11203) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVXOR_VV_M8_MASK (11204) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVXOR_VV_MF2 (11205) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVXOR_VV_MF2_MASK (11206) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVXOR_VV_MF4 (11207) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVXOR_VV_MF4_MASK (11208) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVXOR_VV_MF8 (11209) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVXOR_VV_MF8_MASK (11210) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVXOR_VX_M1 (11211) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVXOR_VX_M1_MASK (11212) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVXOR_VX_M2 (11213) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVXOR_VX_M2_MASK (11214) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVXOR_VX_M4 (11215) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVXOR_VX_M4_MASK (11216) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVXOR_VX_M8 (11217) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVXOR_VX_M8_MASK (11218) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVXOR_VX_MF2 (11219) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVXOR_VX_MF2_MASK (11220) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVXOR_VX_MF4 (11221) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVXOR_VX_MF4_MASK (11222) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVXOR_VX_MF8 (11223) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVXOR_VX_MF8_MASK (11224) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVZEXT_VF2_M1 (11225) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVZEXT_VF2_M1_MASK (11226) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVZEXT_VF2_M2 (11227) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVZEXT_VF2_M2_MASK (11228) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVZEXT_VF2_M4 (11229) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVZEXT_VF2_M4_MASK (11230) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVZEXT_VF2_M8 (11231) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVZEXT_VF2_M8_MASK (11232) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVZEXT_VF2_MF2 (11233) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVZEXT_VF2_MF2_MASK (11234) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVZEXT_VF2_MF4 (11235) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVZEXT_VF2_MF4_MASK (11236) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVZEXT_VF4_M1 (11237) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVZEXT_VF4_M1_MASK (11238) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVZEXT_VF4_M2 (11239) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVZEXT_VF4_M2_MASK (11240) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVZEXT_VF4_M4 (11241) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVZEXT_VF4_M4_MASK (11242) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVZEXT_VF4_M8 (11243) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVZEXT_VF4_M8_MASK (11244) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVZEXT_VF4_MF2 (11245) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVZEXT_VF4_MF2_MASK (11246) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVZEXT_VF8_M1 (11247) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVZEXT_VF8_M1_MASK (11248) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVZEXT_VF8_M2 (11249) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVZEXT_VF8_M2_MASK (11250) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVZEXT_VF8_M4 (11251) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVZEXT_VF8_M4_MASK (11252) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVZEXT_VF8_M8 (11253) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_PseudoVZEXT_VF8_M8_MASK (11254) - RISCV_INS_INVALID - */ + 0 +}}}, +{ /* RISCV_PseudoZEXT_H (11255) - RISCV_INS_ZEXT_H - zext.h $rd, $rs */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs */ + { 0 } +}}, +{ /* RISCV_PseudoZEXT_W (11256) - RISCV_INS_ZEXT_W - zext.w $rd, $rs */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs */ + { 0 } +}}, +{{{ /* RISCV_ReadCycleWide (11257) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_ReadFFLAGS (11258) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_ReadFRM (11259) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_Select_FPR16INX_Using_CC_GPR (11260) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_Select_FPR16_Using_CC_GPR (11261) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_Select_FPR32INX_Using_CC_GPR (11262) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_Select_FPR32_Using_CC_GPR (11263) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_Select_FPR64IN32X_Using_CC_GPR (11264) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_Select_FPR64INX_Using_CC_GPR (11265) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_Select_FPR64_Using_CC_GPR (11266) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_Select_GPR_Using_CC_GPR (11267) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_SplitF64Pseudo (11268) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_SplitF64Pseudo_INX (11269) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_SwapFRMImm (11270) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_WriteFFLAGS (11271) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_WriteFRM (11272) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_WriteFRMImm (11273) - RISCV_INS_INVALID - */ + 0 +}}}, +{{{ /* RISCV_WriteVXRMImm (11274) - RISCV_INS_INVALID - */ + 0 +}}}, +{ /* RISCV_ADD (11275) - RISCV_INS_ADD - add $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_ADDI (11276) - RISCV_INS_ADDI - addi $rd, $rs1, $imm12 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm12 */ + { 0 } +}}, +{ /* RISCV_ADDIW (11277) - RISCV_INS_ADDIW - addiw $rd, $rs1, $imm12 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm12 */ + { 0 } +}}, +{ /* RISCV_ADDW (11278) - RISCV_INS_ADDW - addw $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_ADD_UW (11279) - RISCV_INS_ADD_UW - add.uw $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AES32DSI (11280) - RISCV_INS_AES32DSI - aes32dsi $rd, $rs1, $rs2, $bs */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* bs */ + { 0 } +}}, +{ /* RISCV_AES32DSMI (11281) - RISCV_INS_AES32DSMI - aes32dsmi $rd, $rs1, $rs2, $bs */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* bs */ + { 0 } +}}, +{ /* RISCV_AES32ESI (11282) - RISCV_INS_AES32ESI - aes32esi $rd, $rs1, $rs2, $bs */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* bs */ + { 0 } +}}, +{ /* RISCV_AES32ESMI (11283) - RISCV_INS_AES32ESMI - aes32esmi $rd, $rs1, $rs2, $bs */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* bs */ + { 0 } +}}, +{ /* RISCV_AES64DS (11284) - RISCV_INS_AES64DS - aes64ds $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AES64DSM (11285) - RISCV_INS_AES64DSM - aes64dsm $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AES64ES (11286) - RISCV_INS_AES64ES - aes64es $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AES64ESM (11287) - RISCV_INS_AES64ESM - aes64esm $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AES64IM (11288) - RISCV_INS_AES64IM - aes64im $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_AES64KS1I (11289) - RISCV_INS_AES64KS1I - aes64ks1i $rd, $rs1, $rnum */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rnum */ + { 0 } +}}, +{ /* RISCV_AES64KS2 (11290) - RISCV_INS_AES64KS2 - aes64ks2 $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOADD_D (11291) - RISCV_INS_AMOADD_D - amoadd.d $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOADD_D_AQ (11292) - RISCV_INS_AMOADD_D_AQ - amoadd.d.aq $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOADD_D_AQ_RL (11293) - RISCV_INS_AMOADD_D_AQRL - amoadd.d.aqrl $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOADD_D_RL (11294) - RISCV_INS_AMOADD_D_RL - amoadd.d.rl $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOADD_W (11295) - RISCV_INS_AMOADD_W - amoadd.w $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOADD_W_AQ (11296) - RISCV_INS_AMOADD_W_AQ - amoadd.w.aq $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOADD_W_AQ_RL (11297) - RISCV_INS_AMOADD_W_AQRL - amoadd.w.aqrl $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOADD_W_RL (11298) - RISCV_INS_AMOADD_W_RL - amoadd.w.rl $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOAND_D (11299) - RISCV_INS_AMOAND_D - amoand.d $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOAND_D_AQ (11300) - RISCV_INS_AMOAND_D_AQ - amoand.d.aq $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOAND_D_AQ_RL (11301) - RISCV_INS_AMOAND_D_AQRL - amoand.d.aqrl $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOAND_D_RL (11302) - RISCV_INS_AMOAND_D_RL - amoand.d.rl $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOAND_W (11303) - RISCV_INS_AMOAND_W - amoand.w $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOAND_W_AQ (11304) - RISCV_INS_AMOAND_W_AQ - amoand.w.aq $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOAND_W_AQ_RL (11305) - RISCV_INS_AMOAND_W_AQRL - amoand.w.aqrl $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOAND_W_RL (11306) - RISCV_INS_AMOAND_W_RL - amoand.w.rl $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOCAS_D_RV32 (11307) - RISCV_INS_AMOCAS_D - amocas.d $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOCAS_D_RV32_AQ (11308) - RISCV_INS_AMOCAS_D_AQ - amocas.d.aq $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOCAS_D_RV32_AQ_RL (11309) - RISCV_INS_AMOCAS_D_AQRL - amocas.d.aqrl $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOCAS_D_RV32_RL (11310) - RISCV_INS_AMOCAS_D_RL - amocas.d.rl $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOCAS_D_RV64 (11311) - RISCV_INS_AMOCAS_D - amocas.d $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOCAS_D_RV64_AQ (11312) - RISCV_INS_AMOCAS_D_AQ - amocas.d.aq $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOCAS_D_RV64_AQ_RL (11313) - RISCV_INS_AMOCAS_D_AQRL - amocas.d.aqrl $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOCAS_D_RV64_RL (11314) - RISCV_INS_AMOCAS_D_RL - amocas.d.rl $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOCAS_Q (11315) - RISCV_INS_AMOCAS_Q - amocas.q $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOCAS_Q_AQ (11316) - RISCV_INS_AMOCAS_Q_AQ - amocas.q.aq $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOCAS_Q_AQ_RL (11317) - RISCV_INS_AMOCAS_Q_AQRL - amocas.q.aqrl $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOCAS_Q_RL (11318) - RISCV_INS_AMOCAS_Q_RL - amocas.q.rl $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOCAS_W (11319) - RISCV_INS_AMOCAS_W - amocas.w $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOCAS_W_AQ (11320) - RISCV_INS_AMOCAS_W_AQ - amocas.w.aq $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOCAS_W_AQ_RL (11321) - RISCV_INS_AMOCAS_W_AQRL - amocas.w.aqrl $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOCAS_W_RL (11322) - RISCV_INS_AMOCAS_W_RL - amocas.w.rl $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOMAXU_D (11323) - RISCV_INS_AMOMAXU_D - amomaxu.d $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOMAXU_D_AQ (11324) - RISCV_INS_AMOMAXU_D_AQ - amomaxu.d.aq $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOMAXU_D_AQ_RL (11325) - RISCV_INS_AMOMAXU_D_AQRL - amomaxu.d.aqrl $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOMAXU_D_RL (11326) - RISCV_INS_AMOMAXU_D_RL - amomaxu.d.rl $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOMAXU_W (11327) - RISCV_INS_AMOMAXU_W - amomaxu.w $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOMAXU_W_AQ (11328) - RISCV_INS_AMOMAXU_W_AQ - amomaxu.w.aq $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOMAXU_W_AQ_RL (11329) - RISCV_INS_AMOMAXU_W_AQRL - amomaxu.w.aqrl $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOMAXU_W_RL (11330) - RISCV_INS_AMOMAXU_W_RL - amomaxu.w.rl $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOMAX_D (11331) - RISCV_INS_AMOMAX_D - amomax.d $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOMAX_D_AQ (11332) - RISCV_INS_AMOMAX_D_AQ - amomax.d.aq $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOMAX_D_AQ_RL (11333) - RISCV_INS_AMOMAX_D_AQRL - amomax.d.aqrl $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOMAX_D_RL (11334) - RISCV_INS_AMOMAX_D_RL - amomax.d.rl $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOMAX_W (11335) - RISCV_INS_AMOMAX_W - amomax.w $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOMAX_W_AQ (11336) - RISCV_INS_AMOMAX_W_AQ - amomax.w.aq $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOMAX_W_AQ_RL (11337) - RISCV_INS_AMOMAX_W_AQRL - amomax.w.aqrl $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOMAX_W_RL (11338) - RISCV_INS_AMOMAX_W_RL - amomax.w.rl $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOMINU_D (11339) - RISCV_INS_AMOMINU_D - amominu.d $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOMINU_D_AQ (11340) - RISCV_INS_AMOMINU_D_AQ - amominu.d.aq $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOMINU_D_AQ_RL (11341) - RISCV_INS_AMOMINU_D_AQRL - amominu.d.aqrl $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOMINU_D_RL (11342) - RISCV_INS_AMOMINU_D_RL - amominu.d.rl $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOMINU_W (11343) - RISCV_INS_AMOMINU_W - amominu.w $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOMINU_W_AQ (11344) - RISCV_INS_AMOMINU_W_AQ - amominu.w.aq $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOMINU_W_AQ_RL (11345) - RISCV_INS_AMOMINU_W_AQRL - amominu.w.aqrl $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOMINU_W_RL (11346) - RISCV_INS_AMOMINU_W_RL - amominu.w.rl $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOMIN_D (11347) - RISCV_INS_AMOMIN_D - amomin.d $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOMIN_D_AQ (11348) - RISCV_INS_AMOMIN_D_AQ - amomin.d.aq $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOMIN_D_AQ_RL (11349) - RISCV_INS_AMOMIN_D_AQRL - amomin.d.aqrl $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOMIN_D_RL (11350) - RISCV_INS_AMOMIN_D_RL - amomin.d.rl $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOMIN_W (11351) - RISCV_INS_AMOMIN_W - amomin.w $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOMIN_W_AQ (11352) - RISCV_INS_AMOMIN_W_AQ - amomin.w.aq $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOMIN_W_AQ_RL (11353) - RISCV_INS_AMOMIN_W_AQRL - amomin.w.aqrl $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOMIN_W_RL (11354) - RISCV_INS_AMOMIN_W_RL - amomin.w.rl $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOOR_D (11355) - RISCV_INS_AMOOR_D - amoor.d $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOOR_D_AQ (11356) - RISCV_INS_AMOOR_D_AQ - amoor.d.aq $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOOR_D_AQ_RL (11357) - RISCV_INS_AMOOR_D_AQRL - amoor.d.aqrl $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOOR_D_RL (11358) - RISCV_INS_AMOOR_D_RL - amoor.d.rl $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOOR_W (11359) - RISCV_INS_AMOOR_W - amoor.w $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOOR_W_AQ (11360) - RISCV_INS_AMOOR_W_AQ - amoor.w.aq $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOOR_W_AQ_RL (11361) - RISCV_INS_AMOOR_W_AQRL - amoor.w.aqrl $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOOR_W_RL (11362) - RISCV_INS_AMOOR_W_RL - amoor.w.rl $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOSWAP_D (11363) - RISCV_INS_AMOSWAP_D - amoswap.d $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOSWAP_D_AQ (11364) - RISCV_INS_AMOSWAP_D_AQ - amoswap.d.aq $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOSWAP_D_AQ_RL (11365) - RISCV_INS_AMOSWAP_D_AQRL - amoswap.d.aqrl $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOSWAP_D_RL (11366) - RISCV_INS_AMOSWAP_D_RL - amoswap.d.rl $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOSWAP_W (11367) - RISCV_INS_AMOSWAP_W - amoswap.w $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOSWAP_W_AQ (11368) - RISCV_INS_AMOSWAP_W_AQ - amoswap.w.aq $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOSWAP_W_AQ_RL (11369) - RISCV_INS_AMOSWAP_W_AQRL - amoswap.w.aqrl $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOSWAP_W_RL (11370) - RISCV_INS_AMOSWAP_W_RL - amoswap.w.rl $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOXOR_D (11371) - RISCV_INS_AMOXOR_D - amoxor.d $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOXOR_D_AQ (11372) - RISCV_INS_AMOXOR_D_AQ - amoxor.d.aq $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOXOR_D_AQ_RL (11373) - RISCV_INS_AMOXOR_D_AQRL - amoxor.d.aqrl $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOXOR_D_RL (11374) - RISCV_INS_AMOXOR_D_RL - amoxor.d.rl $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOXOR_W (11375) - RISCV_INS_AMOXOR_W - amoxor.w $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOXOR_W_AQ (11376) - RISCV_INS_AMOXOR_W_AQ - amoxor.w.aq $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOXOR_W_AQ_RL (11377) - RISCV_INS_AMOXOR_W_AQRL - amoxor.w.aqrl $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AMOXOR_W_RL (11378) - RISCV_INS_AMOXOR_W_RL - amoxor.w.rl $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AND (11379) - RISCV_INS_AND - and $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_ANDI (11380) - RISCV_INS_ANDI - andi $rd, $rs1, $imm12 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm12 */ + { 0 } +}}, +{ /* RISCV_ANDN (11381) - RISCV_INS_ANDN - andn $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_AUIPC (11382) - RISCV_INS_AUIPC - auipc $rd, $imm20 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm20 */ + { 0 } +}}, +{ /* RISCV_BCLR (11383) - RISCV_INS_BCLR - bclr $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_BCLRI (11384) - RISCV_INS_BCLRI - bclri $rd, $rs1, $shamt */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* shamt */ + { 0 } +}}, +{ /* RISCV_BEQ (11385) - RISCV_INS_BEQ - beq $rs1, $rs2, $imm12 */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST } }, /* imm12 */ + { 0 } +}}, +{ /* RISCV_BEXT (11386) - RISCV_INS_BEXT - bext $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_BEXTI (11387) - RISCV_INS_BEXTI - bexti $rd, $rs1, $shamt */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* shamt */ + { 0 } +}}, +{ /* RISCV_BGE (11388) - RISCV_INS_BGE - bge $rs1, $rs2, $imm12 */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST } }, /* imm12 */ + { 0 } +}}, +{ /* RISCV_BGEU (11389) - RISCV_INS_BGEU - bgeu $rs1, $rs2, $imm12 */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST } }, /* imm12 */ + { 0 } +}}, +{ /* RISCV_BINV (11390) - RISCV_INS_BINV - binv $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_BINVI (11391) - RISCV_INS_BINVI - binvi $rd, $rs1, $shamt */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* shamt */ + { 0 } +}}, +{ /* RISCV_BLT (11392) - RISCV_INS_BLT - blt $rs1, $rs2, $imm12 */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST } }, /* imm12 */ + { 0 } +}}, +{ /* RISCV_BLTU (11393) - RISCV_INS_BLTU - bltu $rs1, $rs2, $imm12 */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST } }, /* imm12 */ + { 0 } +}}, +{ /* RISCV_BNE (11394) - RISCV_INS_BNE - bne $rs1, $rs2, $imm12 */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST } }, /* imm12 */ + { 0 } +}}, +{ /* RISCV_BREV8 (11395) - RISCV_INS_BREV8 - brev8 $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_BSET (11396) - RISCV_INS_BSET - bset $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_BSETI (11397) - RISCV_INS_BSETI - bseti $rd, $rs1, $shamt */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* shamt */ + { 0 } +}}, +{ /* RISCV_CBO_CLEAN (11398) - RISCV_INS_CBO_CLEAN - cbo.clean $rs1 */ +{ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_CBO_FLUSH (11399) - RISCV_INS_CBO_FLUSH - cbo.flush $rs1 */ +{ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_CBO_INVAL (11400) - RISCV_INS_CBO_INVAL - cbo.inval $rs1 */ +{ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_CBO_ZERO (11401) - RISCV_INS_CBO_ZERO - cbo.zero $rs1 */ +{ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_CLMUL (11402) - RISCV_INS_CLMUL - clmul $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CLMULH (11403) - RISCV_INS_CLMULH - clmulh $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CLMULR (11404) - RISCV_INS_CLMULR - clmulr $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CLZ (11405) - RISCV_INS_CLZ - clz $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_CLZW (11406) - RISCV_INS_CLZW - clzw $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_CMOP1 (11407) - RISCV_INS_CMOP_1 - cmop.1 */ +{ + { 0 } +}}, +{ /* RISCV_CMOP11 (11408) - RISCV_INS_CMOP_11 - cmop.11 */ +{ + { 0 } +}}, +{ /* RISCV_CMOP13 (11409) - RISCV_INS_CMOP_13 - cmop.13 */ +{ + { 0 } +}}, +{ /* RISCV_CMOP15 (11410) - RISCV_INS_CMOP_15 - cmop.15 */ +{ + { 0 } +}}, +{ /* RISCV_CMOP3 (11411) - RISCV_INS_CMOP_3 - cmop.3 */ +{ + { 0 } +}}, +{ /* RISCV_CMOP5 (11412) - RISCV_INS_CMOP_5 - cmop.5 */ +{ + { 0 } +}}, +{ /* RISCV_CMOP7 (11413) - RISCV_INS_CMOP_7 - cmop.7 */ +{ + { 0 } +}}, +{ /* RISCV_CMOP9 (11414) - RISCV_INS_CMOP_9 - cmop.9 */ +{ + { 0 } +}}, +{ /* RISCV_CM_JALT (11415) - RISCV_INS_CM_JALT - cm.jalt $index */ +{ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* index */ + { 0 } +}}, +{ /* RISCV_CM_JT (11416) - RISCV_INS_CM_JT - cm.jt $index */ +{ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* index */ + { 0 } +}}, +{ /* RISCV_CM_MVA01S (11417) - RISCV_INS_CM_MVA01S - cm.mva01s $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CM_MVSA01 (11418) - RISCV_INS_CM_MVSA01 - cm.mvsa01 $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CM_POP (11419) - RISCV_INS_CM_POP - cm.pop $rlist, $spimm */ +{ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST } }, /* rlist */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST } }, /* spimm */ + { 0 } +}}, +{ /* RISCV_CM_POPRET (11420) - RISCV_INS_CM_POPRET - cm.popret $rlist, $spimm */ +{ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST } }, /* rlist */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST } }, /* spimm */ + { 0 } +}}, +{ /* RISCV_CM_POPRETZ (11421) - RISCV_INS_CM_POPRETZ - cm.popretz $rlist, $spimm */ +{ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST } }, /* rlist */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST } }, /* spimm */ + { 0 } +}}, +{ /* RISCV_CM_PUSH (11422) - RISCV_INS_CM_PUSH - cm.push $rlist, $spimm */ +{ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST } }, /* rlist */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST } }, /* spimm */ + { 0 } +}}, +{ /* RISCV_CPOP (11423) - RISCV_INS_CPOP - cpop $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_CPOPW (11424) - RISCV_INS_CPOPW - cpopw $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_CSRRC (11425) - RISCV_INS_CSRRC - csrrc $rd, $imm12, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm12 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_CSRRCI (11426) - RISCV_INS_CSRRCI - csrrci $rd, $imm12, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm12 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_CSRRS (11427) - RISCV_INS_CSRRS - csrrs $rd, $imm12, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm12 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_CSRRSI (11428) - RISCV_INS_CSRRSI - csrrsi $rd, $imm12, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm12 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_CSRRW (11429) - RISCV_INS_CSRRW - csrrw $rd, $imm12, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm12 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_CSRRWI (11430) - RISCV_INS_CSRRWI - csrrwi $rd, $imm12, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm12 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_CTZ (11431) - RISCV_INS_CTZ - ctz $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_CTZW (11432) - RISCV_INS_CTZW - ctzw $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_CV_ABS (11433) - RISCV_INS_CV_ABS - cv.abs $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_CV_ABS_B (11434) - RISCV_INS_CV_ABS_B - cv.abs.b $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_CV_ABS_H (11435) - RISCV_INS_CV_ABS_H - cv.abs.h $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_CV_ADDN (11436) - RISCV_INS_CV_ADDN - cv.addn $rd, $rs1, $rs2, $imm5 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm5 */ + { 0 } +}}, +{ /* RISCV_CV_ADDNR (11437) - RISCV_INS_CV_ADDNR - cv.addnr $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_ADDRN (11438) - RISCV_INS_CV_ADDRN - cv.addrn $rd, $rs1, $rs2, $imm5 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm5 */ + { 0 } +}}, +{ /* RISCV_CV_ADDRNR (11439) - RISCV_INS_CV_ADDRNR - cv.addrnr $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_ADDUN (11440) - RISCV_INS_CV_ADDUN - cv.addun $rd, $rs1, $rs2, $imm5 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm5 */ + { 0 } +}}, +{ /* RISCV_CV_ADDUNR (11441) - RISCV_INS_CV_ADDUNR - cv.addunr $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_ADDURN (11442) - RISCV_INS_CV_ADDURN - cv.addurn $rd, $rs1, $rs2, $imm5 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm5 */ + { 0 } +}}, +{ /* RISCV_CV_ADDURNR (11443) - RISCV_INS_CV_ADDURNR - cv.addurnr $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_ADD_B (11444) - RISCV_INS_CV_ADD_B - cv.add.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_ADD_DIV2 (11445) - RISCV_INS_CV_ADD_DIV2 - cv.add.div2 $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_ADD_DIV4 (11446) - RISCV_INS_CV_ADD_DIV4 - cv.add.div4 $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_ADD_DIV8 (11447) - RISCV_INS_CV_ADD_DIV8 - cv.add.div8 $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_ADD_H (11448) - RISCV_INS_CV_ADD_H - cv.add.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_ADD_SCI_B (11449) - RISCV_INS_CV_ADD_SCI_B - cv.add.sci.b $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_ADD_SCI_H (11450) - RISCV_INS_CV_ADD_SCI_H - cv.add.sci.h $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_ADD_SC_B (11451) - RISCV_INS_CV_ADD_SC_B - cv.add.sc.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_ADD_SC_H (11452) - RISCV_INS_CV_ADD_SC_H - cv.add.sc.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_AND_B (11453) - RISCV_INS_CV_AND_B - cv.and.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_AND_H (11454) - RISCV_INS_CV_AND_H - cv.and.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_AND_SCI_B (11455) - RISCV_INS_CV_AND_SCI_B - cv.and.sci.b $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_AND_SCI_H (11456) - RISCV_INS_CV_AND_SCI_H - cv.and.sci.h $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_AND_SC_B (11457) - RISCV_INS_CV_AND_SC_B - cv.and.sc.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_AND_SC_H (11458) - RISCV_INS_CV_AND_SC_H - cv.and.sc.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_AVGU_B (11459) - RISCV_INS_CV_AVGU_B - cv.avgu.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_AVGU_H (11460) - RISCV_INS_CV_AVGU_H - cv.avgu.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_AVGU_SCI_B (11461) - RISCV_INS_CV_AVGU_SCI_B - cv.avgu.sci.b $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_AVGU_SCI_H (11462) - RISCV_INS_CV_AVGU_SCI_H - cv.avgu.sci.h $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_AVGU_SC_B (11463) - RISCV_INS_CV_AVGU_SC_B - cv.avgu.sc.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_AVGU_SC_H (11464) - RISCV_INS_CV_AVGU_SC_H - cv.avgu.sc.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_AVG_B (11465) - RISCV_INS_CV_AVG_B - cv.avg.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_AVG_H (11466) - RISCV_INS_CV_AVG_H - cv.avg.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_AVG_SCI_B (11467) - RISCV_INS_CV_AVG_SCI_B - cv.avg.sci.b $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_AVG_SCI_H (11468) - RISCV_INS_CV_AVG_SCI_H - cv.avg.sci.h $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_AVG_SC_B (11469) - RISCV_INS_CV_AVG_SC_B - cv.avg.sc.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_AVG_SC_H (11470) - RISCV_INS_CV_AVG_SC_H - cv.avg.sc.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_BCLR (11471) - RISCV_INS_CV_BCLR - cv.bclr $rd, $rs1, $is3, $is2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* is3 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* is2 */ + { 0 } +}}, +{ /* RISCV_CV_BCLRR (11472) - RISCV_INS_CV_BCLRR - cv.bclrr $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_BEQIMM (11473) - RISCV_INS_CV_BEQIMM - cv.beqimm $rs1, $imm5, $imm12 */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm5 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST } }, /* imm12 */ + { 0 } +}}, +{ /* RISCV_CV_BITREV (11474) - RISCV_INS_CV_BITREV - cv.bitrev $rd, $rs1, $is3, $is2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* is3 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* is2 */ + { 0 } +}}, +{ /* RISCV_CV_BNEIMM (11475) - RISCV_INS_CV_BNEIMM - cv.bneimm $rs1, $imm5, $imm12 */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm5 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST } }, /* imm12 */ + { 0 } +}}, +{ /* RISCV_CV_BSET (11476) - RISCV_INS_CV_BSET - cv.bset $rd, $rs1, $is3, $is2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* is3 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* is2 */ + { 0 } +}}, +{ /* RISCV_CV_BSETR (11477) - RISCV_INS_CV_BSETR - cv.bsetr $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_CLB (11478) - RISCV_INS_CV_CLB - cv.clb $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_CV_CLIP (11479) - RISCV_INS_CV_CLIP - cv.clip $rd, $rs1, $imm5 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm5 */ + { 0 } +}}, +{ /* RISCV_CV_CLIPR (11480) - RISCV_INS_CV_CLIPR - cv.clipr $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_CLIPU (11481) - RISCV_INS_CV_CLIPU - cv.clipu $rd, $rs1, $imm5 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm5 */ + { 0 } +}}, +{ /* RISCV_CV_CLIPUR (11482) - RISCV_INS_CV_CLIPUR - cv.clipur $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_CMPEQ_B (11483) - RISCV_INS_CV_CMPEQ_B - cv.cmpeq.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_CMPEQ_H (11484) - RISCV_INS_CV_CMPEQ_H - cv.cmpeq.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_CMPEQ_SCI_B (11485) - RISCV_INS_CV_CMPEQ_SCI_B - cv.cmpeq.sci.b $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_CMPEQ_SCI_H (11486) - RISCV_INS_CV_CMPEQ_SCI_H - cv.cmpeq.sci.h $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_CMPEQ_SC_B (11487) - RISCV_INS_CV_CMPEQ_SC_B - cv.cmpeq.sc.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_CMPEQ_SC_H (11488) - RISCV_INS_CV_CMPEQ_SC_H - cv.cmpeq.sc.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_CMPGEU_B (11489) - RISCV_INS_CV_CMPGEU_B - cv.cmpgeu.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_CMPGEU_H (11490) - RISCV_INS_CV_CMPGEU_H - cv.cmpgeu.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_CMPGEU_SCI_B (11491) - RISCV_INS_CV_CMPGEU_SCI_B - cv.cmpgeu.sci.b $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_CMPGEU_SCI_H (11492) - RISCV_INS_CV_CMPGEU_SCI_H - cv.cmpgeu.sci.h $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_CMPGEU_SC_B (11493) - RISCV_INS_CV_CMPGEU_SC_B - cv.cmpgeu.sc.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_CMPGEU_SC_H (11494) - RISCV_INS_CV_CMPGEU_SC_H - cv.cmpgeu.sc.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_CMPGE_B (11495) - RISCV_INS_CV_CMPGE_B - cv.cmpge.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_CMPGE_H (11496) - RISCV_INS_CV_CMPGE_H - cv.cmpge.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_CMPGE_SCI_B (11497) - RISCV_INS_CV_CMPGE_SCI_B - cv.cmpge.sci.b $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_CMPGE_SCI_H (11498) - RISCV_INS_CV_CMPGE_SCI_H - cv.cmpge.sci.h $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_CMPGE_SC_B (11499) - RISCV_INS_CV_CMPGE_SC_B - cv.cmpge.sc.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_CMPGE_SC_H (11500) - RISCV_INS_CV_CMPGE_SC_H - cv.cmpge.sc.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_CMPGTU_B (11501) - RISCV_INS_CV_CMPGTU_B - cv.cmpgtu.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_CMPGTU_H (11502) - RISCV_INS_CV_CMPGTU_H - cv.cmpgtu.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_CMPGTU_SCI_B (11503) - RISCV_INS_CV_CMPGTU_SCI_B - cv.cmpgtu.sci.b $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_CMPGTU_SCI_H (11504) - RISCV_INS_CV_CMPGTU_SCI_H - cv.cmpgtu.sci.h $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_CMPGTU_SC_B (11505) - RISCV_INS_CV_CMPGTU_SC_B - cv.cmpgtu.sc.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_CMPGTU_SC_H (11506) - RISCV_INS_CV_CMPGTU_SC_H - cv.cmpgtu.sc.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_CMPGT_B (11507) - RISCV_INS_CV_CMPGT_B - cv.cmpgt.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_CMPGT_H (11508) - RISCV_INS_CV_CMPGT_H - cv.cmpgt.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_CMPGT_SCI_B (11509) - RISCV_INS_CV_CMPGT_SCI_B - cv.cmpgt.sci.b $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_CMPGT_SCI_H (11510) - RISCV_INS_CV_CMPGT_SCI_H - cv.cmpgt.sci.h $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_CMPGT_SC_B (11511) - RISCV_INS_CV_CMPGT_SC_B - cv.cmpgt.sc.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_CMPGT_SC_H (11512) - RISCV_INS_CV_CMPGT_SC_H - cv.cmpgt.sc.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_CMPLEU_B (11513) - RISCV_INS_CV_CMPLEU_B - cv.cmpleu.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_CMPLEU_H (11514) - RISCV_INS_CV_CMPLEU_H - cv.cmpleu.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_CMPLEU_SCI_B (11515) - RISCV_INS_CV_CMPLEU_SCI_B - cv.cmpleu.sci.b $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_CMPLEU_SCI_H (11516) - RISCV_INS_CV_CMPLEU_SCI_H - cv.cmpleu.sci.h $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_CMPLEU_SC_B (11517) - RISCV_INS_CV_CMPLEU_SC_B - cv.cmpleu.sc.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_CMPLEU_SC_H (11518) - RISCV_INS_CV_CMPLEU_SC_H - cv.cmpleu.sc.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_CMPLE_B (11519) - RISCV_INS_CV_CMPLE_B - cv.cmple.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_CMPLE_H (11520) - RISCV_INS_CV_CMPLE_H - cv.cmple.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_CMPLE_SCI_B (11521) - RISCV_INS_CV_CMPLE_SCI_B - cv.cmple.sci.b $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_CMPLE_SCI_H (11522) - RISCV_INS_CV_CMPLE_SCI_H - cv.cmple.sci.h $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_CMPLE_SC_B (11523) - RISCV_INS_CV_CMPLE_SC_B - cv.cmple.sc.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_CMPLE_SC_H (11524) - RISCV_INS_CV_CMPLE_SC_H - cv.cmple.sc.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_CMPLTU_B (11525) - RISCV_INS_CV_CMPLTU_B - cv.cmpltu.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_CMPLTU_H (11526) - RISCV_INS_CV_CMPLTU_H - cv.cmpltu.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_CMPLTU_SCI_B (11527) - RISCV_INS_CV_CMPLTU_SCI_B - cv.cmpltu.sci.b $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_CMPLTU_SCI_H (11528) - RISCV_INS_CV_CMPLTU_SCI_H - cv.cmpltu.sci.h $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_CMPLTU_SC_B (11529) - RISCV_INS_CV_CMPLTU_SC_B - cv.cmpltu.sc.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_CMPLTU_SC_H (11530) - RISCV_INS_CV_CMPLTU_SC_H - cv.cmpltu.sc.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_CMPLT_B (11531) - RISCV_INS_CV_CMPLT_B - cv.cmplt.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_CMPLT_H (11532) - RISCV_INS_CV_CMPLT_H - cv.cmplt.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_CMPLT_SCI_B (11533) - RISCV_INS_CV_CMPLT_SCI_B - cv.cmplt.sci.b $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_CMPLT_SCI_H (11534) - RISCV_INS_CV_CMPLT_SCI_H - cv.cmplt.sci.h $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_CMPLT_SC_B (11535) - RISCV_INS_CV_CMPLT_SC_B - cv.cmplt.sc.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_CMPLT_SC_H (11536) - RISCV_INS_CV_CMPLT_SC_H - cv.cmplt.sc.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_CMPNE_B (11537) - RISCV_INS_CV_CMPNE_B - cv.cmpne.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_CMPNE_H (11538) - RISCV_INS_CV_CMPNE_H - cv.cmpne.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_CMPNE_SCI_B (11539) - RISCV_INS_CV_CMPNE_SCI_B - cv.cmpne.sci.b $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_CMPNE_SCI_H (11540) - RISCV_INS_CV_CMPNE_SCI_H - cv.cmpne.sci.h $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_CMPNE_SC_B (11541) - RISCV_INS_CV_CMPNE_SC_B - cv.cmpne.sc.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_CMPNE_SC_H (11542) - RISCV_INS_CV_CMPNE_SC_H - cv.cmpne.sc.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_CNT (11543) - RISCV_INS_CV_CNT - cv.cnt $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_CV_CPLXCONJ (11544) - RISCV_INS_CV_CPLXCONJ - cv.cplxconj $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_CV_CPLXMUL_I (11545) - RISCV_INS_CV_CPLXMUL_I - cv.cplxmul.i $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_CPLXMUL_I_DIV2 (11546) - RISCV_INS_CV_CPLXMUL_I_DIV2 - cv.cplxmul.i.div2 $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_CPLXMUL_I_DIV4 (11547) - RISCV_INS_CV_CPLXMUL_I_DIV4 - cv.cplxmul.i.div4 $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_CPLXMUL_I_DIV8 (11548) - RISCV_INS_CV_CPLXMUL_I_DIV8 - cv.cplxmul.i.div8 $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_CPLXMUL_R (11549) - RISCV_INS_CV_CPLXMUL_R - cv.cplxmul.r $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_CPLXMUL_R_DIV2 (11550) - RISCV_INS_CV_CPLXMUL_R_DIV2 - cv.cplxmul.r.div2 $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_CPLXMUL_R_DIV4 (11551) - RISCV_INS_CV_CPLXMUL_R_DIV4 - cv.cplxmul.r.div4 $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_CPLXMUL_R_DIV8 (11552) - RISCV_INS_CV_CPLXMUL_R_DIV8 - cv.cplxmul.r.div8 $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_DOTSP_B (11553) - RISCV_INS_CV_DOTSP_B - cv.dotsp.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_DOTSP_H (11554) - RISCV_INS_CV_DOTSP_H - cv.dotsp.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_DOTSP_SCI_B (11555) - RISCV_INS_CV_DOTSP_SCI_B - cv.dotsp.sci.b $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_DOTSP_SCI_H (11556) - RISCV_INS_CV_DOTSP_SCI_H - cv.dotsp.sci.h $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_DOTSP_SC_B (11557) - RISCV_INS_CV_DOTSP_SC_B - cv.dotsp.sc.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_DOTSP_SC_H (11558) - RISCV_INS_CV_DOTSP_SC_H - cv.dotsp.sc.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_DOTUP_B (11559) - RISCV_INS_CV_DOTUP_B - cv.dotup.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_DOTUP_H (11560) - RISCV_INS_CV_DOTUP_H - cv.dotup.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_DOTUP_SCI_B (11561) - RISCV_INS_CV_DOTUP_SCI_B - cv.dotup.sci.b $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_DOTUP_SCI_H (11562) - RISCV_INS_CV_DOTUP_SCI_H - cv.dotup.sci.h $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_DOTUP_SC_B (11563) - RISCV_INS_CV_DOTUP_SC_B - cv.dotup.sc.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_DOTUP_SC_H (11564) - RISCV_INS_CV_DOTUP_SC_H - cv.dotup.sc.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_DOTUSP_B (11565) - RISCV_INS_CV_DOTUSP_B - cv.dotusp.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_DOTUSP_H (11566) - RISCV_INS_CV_DOTUSP_H - cv.dotusp.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_DOTUSP_SCI_B (11567) - RISCV_INS_CV_DOTUSP_SCI_B - cv.dotusp.sci.b $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_DOTUSP_SCI_H (11568) - RISCV_INS_CV_DOTUSP_SCI_H - cv.dotusp.sci.h $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_DOTUSP_SC_B (11569) - RISCV_INS_CV_DOTUSP_SC_B - cv.dotusp.sc.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_DOTUSP_SC_H (11570) - RISCV_INS_CV_DOTUSP_SC_H - cv.dotusp.sc.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_ELW (11571) - RISCV_INS_CV_ELW - cv.elw $rd, ${imm12}(${rs1}) */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm12 */ + { 0 } +}}, +{ /* RISCV_CV_EXTBS (11572) - RISCV_INS_CV_EXTBS - cv.extbs $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_CV_EXTBZ (11573) - RISCV_INS_CV_EXTBZ - cv.extbz $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_CV_EXTHS (11574) - RISCV_INS_CV_EXTHS - cv.exths $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_CV_EXTHZ (11575) - RISCV_INS_CV_EXTHZ - cv.exthz $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_CV_EXTRACT (11576) - RISCV_INS_CV_EXTRACT - cv.extract $rd, $rs1, $is3, $is2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* is3 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* is2 */ + { 0 } +}}, +{ /* RISCV_CV_EXTRACTR (11577) - RISCV_INS_CV_EXTRACTR - cv.extractr $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_EXTRACTU (11578) - RISCV_INS_CV_EXTRACTU - cv.extractu $rd, $rs1, $is3, $is2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* is3 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* is2 */ + { 0 } +}}, +{ /* RISCV_CV_EXTRACTUR (11579) - RISCV_INS_CV_EXTRACTUR - cv.extractur $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_EXTRACTU_B (11580) - RISCV_INS_CV_EXTRACTU_B - cv.extractu.b $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_EXTRACTU_H (11581) - RISCV_INS_CV_EXTRACTU_H - cv.extractu.h $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_EXTRACT_B (11582) - RISCV_INS_CV_EXTRACT_B - cv.extract.b $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_EXTRACT_H (11583) - RISCV_INS_CV_EXTRACT_H - cv.extract.h $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_FF1 (11584) - RISCV_INS_CV_FF1 - cv.ff1 $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_CV_FL1 (11585) - RISCV_INS_CV_FL1 - cv.fl1 $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_CV_INSERT (11586) - RISCV_INS_CV_INSERT - cv.insert $rd, $rs1, $is3, $is2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* is3 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* is2 */ + { 0 } +}}, +{ /* RISCV_CV_INSERTR (11587) - RISCV_INS_CV_INSERTR - cv.insertr $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_INSERT_B (11588) - RISCV_INS_CV_INSERT_B - cv.insert.b $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_INSERT_H (11589) - RISCV_INS_CV_INSERT_H - cv.insert.h $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_LBU_ri_inc (11590) - RISCV_INS_CV_LBU - cv.lbu $rd, (${rs1}), ${imm12} */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1_wb */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm12 */ + { 0 } +}}, +{ /* RISCV_CV_LBU_rr (11591) - RISCV_INS_CV_LBU - cv.lbu $rd, $cvrr */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST } }, /* cvrr */ + { 0 } +}}, +{ /* RISCV_CV_LBU_rr_inc (11592) - RISCV_INS_CV_LBU - cv.lbu $rd, (${rs1}), ${rs2} */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1_wb */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_LB_ri_inc (11593) - RISCV_INS_CV_LB - cv.lb $rd, (${rs1}), ${imm12} */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1_wb */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm12 */ + { 0 } +}}, +{ /* RISCV_CV_LB_rr (11594) - RISCV_INS_CV_LB - cv.lb $rd, $cvrr */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST } }, /* cvrr */ + { 0 } +}}, +{ /* RISCV_CV_LB_rr_inc (11595) - RISCV_INS_CV_LB - cv.lb $rd, (${rs1}), ${rs2} */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1_wb */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_LHU_ri_inc (11596) - RISCV_INS_CV_LHU - cv.lhu $rd, (${rs1}), ${imm12} */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1_wb */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm12 */ + { 0 } +}}, +{ /* RISCV_CV_LHU_rr (11597) - RISCV_INS_CV_LHU - cv.lhu $rd, $cvrr */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST } }, /* cvrr */ + { 0 } +}}, +{ /* RISCV_CV_LHU_rr_inc (11598) - RISCV_INS_CV_LHU - cv.lhu $rd, (${rs1}), ${rs2} */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1_wb */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_LH_ri_inc (11599) - RISCV_INS_CV_LH - cv.lh $rd, (${rs1}), ${imm12} */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1_wb */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm12 */ + { 0 } +}}, +{ /* RISCV_CV_LH_rr (11600) - RISCV_INS_CV_LH - cv.lh $rd, $cvrr */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST } }, /* cvrr */ + { 0 } +}}, +{ /* RISCV_CV_LH_rr_inc (11601) - RISCV_INS_CV_LH - cv.lh $rd, (${rs1}), ${rs2} */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1_wb */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_LW_ri_inc (11602) - RISCV_INS_CV_LW - cv.lw $rd, (${rs1}), ${imm12} */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1_wb */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm12 */ + { 0 } +}}, +{ /* RISCV_CV_LW_rr (11603) - RISCV_INS_CV_LW - cv.lw $rd, $cvrr */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST } }, /* cvrr */ + { 0 } +}}, +{ /* RISCV_CV_LW_rr_inc (11604) - RISCV_INS_CV_LW - cv.lw $rd, (${rs1}), ${rs2} */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1_wb */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_MAC (11605) - RISCV_INS_CV_MAC - cv.mac $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_MACHHSN (11606) - RISCV_INS_CV_MACHHSN - cv.machhsn $rd, $rs1, $rs2, $imm5 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm5 */ + { 0 } +}}, +{ /* RISCV_CV_MACHHSRN (11607) - RISCV_INS_CV_MACHHSRN - cv.machhsrn $rd, $rs1, $rs2, $imm5 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm5 */ + { 0 } +}}, +{ /* RISCV_CV_MACHHUN (11608) - RISCV_INS_CV_MACHHUN - cv.machhun $rd, $rs1, $rs2, $imm5 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm5 */ + { 0 } +}}, +{ /* RISCV_CV_MACHHURN (11609) - RISCV_INS_CV_MACHHURN - cv.machhurn $rd, $rs1, $rs2, $imm5 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm5 */ + { 0 } +}}, +{ /* RISCV_CV_MACSN (11610) - RISCV_INS_CV_MACSN - cv.macsn $rd, $rs1, $rs2, $imm5 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm5 */ + { 0 } +}}, +{ /* RISCV_CV_MACSRN (11611) - RISCV_INS_CV_MACSRN - cv.macsrn $rd, $rs1, $rs2, $imm5 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm5 */ + { 0 } +}}, +{ /* RISCV_CV_MACUN (11612) - RISCV_INS_CV_MACUN - cv.macun $rd, $rs1, $rs2, $imm5 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm5 */ + { 0 } +}}, +{ /* RISCV_CV_MACURN (11613) - RISCV_INS_CV_MACURN - cv.macurn $rd, $rs1, $rs2, $imm5 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm5 */ + { 0 } +}}, +{ /* RISCV_CV_MAX (11614) - RISCV_INS_CV_MAX - cv.max $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_MAXU (11615) - RISCV_INS_CV_MAXU - cv.maxu $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_MAXU_B (11616) - RISCV_INS_CV_MAXU_B - cv.maxu.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_MAXU_H (11617) - RISCV_INS_CV_MAXU_H - cv.maxu.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_MAXU_SCI_B (11618) - RISCV_INS_CV_MAXU_SCI_B - cv.maxu.sci.b $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_MAXU_SCI_H (11619) - RISCV_INS_CV_MAXU_SCI_H - cv.maxu.sci.h $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_MAXU_SC_B (11620) - RISCV_INS_CV_MAXU_SC_B - cv.maxu.sc.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_MAXU_SC_H (11621) - RISCV_INS_CV_MAXU_SC_H - cv.maxu.sc.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_MAX_B (11622) - RISCV_INS_CV_MAX_B - cv.max.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_MAX_H (11623) - RISCV_INS_CV_MAX_H - cv.max.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_MAX_SCI_B (11624) - RISCV_INS_CV_MAX_SCI_B - cv.max.sci.b $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_MAX_SCI_H (11625) - RISCV_INS_CV_MAX_SCI_H - cv.max.sci.h $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_MAX_SC_B (11626) - RISCV_INS_CV_MAX_SC_B - cv.max.sc.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_MAX_SC_H (11627) - RISCV_INS_CV_MAX_SC_H - cv.max.sc.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_MIN (11628) - RISCV_INS_CV_MIN - cv.min $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_MINU (11629) - RISCV_INS_CV_MINU - cv.minu $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_MINU_B (11630) - RISCV_INS_CV_MINU_B - cv.minu.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_MINU_H (11631) - RISCV_INS_CV_MINU_H - cv.minu.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_MINU_SCI_B (11632) - RISCV_INS_CV_MINU_SCI_B - cv.minu.sci.b $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_MINU_SCI_H (11633) - RISCV_INS_CV_MINU_SCI_H - cv.minu.sci.h $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_MINU_SC_B (11634) - RISCV_INS_CV_MINU_SC_B - cv.minu.sc.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_MINU_SC_H (11635) - RISCV_INS_CV_MINU_SC_H - cv.minu.sc.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_MIN_B (11636) - RISCV_INS_CV_MIN_B - cv.min.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_MIN_H (11637) - RISCV_INS_CV_MIN_H - cv.min.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_MIN_SCI_B (11638) - RISCV_INS_CV_MIN_SCI_B - cv.min.sci.b $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_MIN_SCI_H (11639) - RISCV_INS_CV_MIN_SCI_H - cv.min.sci.h $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_MIN_SC_B (11640) - RISCV_INS_CV_MIN_SC_B - cv.min.sc.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_MIN_SC_H (11641) - RISCV_INS_CV_MIN_SC_H - cv.min.sc.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_MSU (11642) - RISCV_INS_CV_MSU - cv.msu $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_MULHHSN (11643) - RISCV_INS_CV_MULHHSN - cv.mulhhsn $rd, $rs1, $rs2, $imm5 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm5 */ + { 0 } +}}, +{ /* RISCV_CV_MULHHSRN (11644) - RISCV_INS_CV_MULHHSRN - cv.mulhhsrn $rd, $rs1, $rs2, $imm5 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm5 */ + { 0 } +}}, +{ /* RISCV_CV_MULHHUN (11645) - RISCV_INS_CV_MULHHUN - cv.mulhhun $rd, $rs1, $rs2, $imm5 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm5 */ + { 0 } +}}, +{ /* RISCV_CV_MULHHURN (11646) - RISCV_INS_CV_MULHHURN - cv.mulhhurn $rd, $rs1, $rs2, $imm5 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm5 */ + { 0 } +}}, +{ /* RISCV_CV_MULSN (11647) - RISCV_INS_CV_MULSN - cv.mulsn $rd, $rs1, $rs2, $imm5 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm5 */ + { 0 } +}}, +{ /* RISCV_CV_MULSRN (11648) - RISCV_INS_CV_MULSRN - cv.mulsrn $rd, $rs1, $rs2, $imm5 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm5 */ + { 0 } +}}, +{ /* RISCV_CV_MULUN (11649) - RISCV_INS_CV_MULUN - cv.mulun $rd, $rs1, $rs2, $imm5 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm5 */ + { 0 } +}}, +{ /* RISCV_CV_MULURN (11650) - RISCV_INS_CV_MULURN - cv.mulurn $rd, $rs1, $rs2, $imm5 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm5 */ + { 0 } +}}, +{ /* RISCV_CV_OR_B (11651) - RISCV_INS_CV_OR_B - cv.or.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_OR_H (11652) - RISCV_INS_CV_OR_H - cv.or.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_OR_SCI_B (11653) - RISCV_INS_CV_OR_SCI_B - cv.or.sci.b $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_OR_SCI_H (11654) - RISCV_INS_CV_OR_SCI_H - cv.or.sci.h $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_OR_SC_B (11655) - RISCV_INS_CV_OR_SC_B - cv.or.sc.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_OR_SC_H (11656) - RISCV_INS_CV_OR_SC_H - cv.or.sc.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_PACK (11657) - RISCV_INS_CV_PACK - cv.pack $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_PACKHI_B (11658) - RISCV_INS_CV_PACKHI_B - cv.packhi.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_PACKLO_B (11659) - RISCV_INS_CV_PACKLO_B - cv.packlo.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_PACK_H (11660) - RISCV_INS_CV_PACK_H - cv.pack.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_ROR (11661) - RISCV_INS_CV_ROR - cv.ror $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_SB_ri_inc (11662) - RISCV_INS_CV_SB - cv.sb $rs2, (${rs1}), ${imm12} */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG | CS_OP_MEM, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm12 */ + { 0 } +}}, +{ /* RISCV_CV_SB_rr (11663) - RISCV_INS_CV_SB - cv.sb $rs2, $cvrr */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST } }, /* cvrr */ + { 0 } +}}, +{ /* RISCV_CV_SB_rr_inc (11664) - RISCV_INS_CV_SB - cv.sb $rs2, (${rs1}), ${rs3} */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG | CS_OP_MEM, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs3 */ + { 0 } +}}, +{ /* RISCV_CV_SDOTSP_B (11665) - RISCV_INS_CV_SDOTSP_B - cv.sdotsp.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_SDOTSP_H (11666) - RISCV_INS_CV_SDOTSP_H - cv.sdotsp.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_SDOTSP_SCI_B (11667) - RISCV_INS_CV_SDOTSP_SCI_B - cv.sdotsp.sci.b $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_SDOTSP_SCI_H (11668) - RISCV_INS_CV_SDOTSP_SCI_H - cv.sdotsp.sci.h $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_SDOTSP_SC_B (11669) - RISCV_INS_CV_SDOTSP_SC_B - cv.sdotsp.sc.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_SDOTSP_SC_H (11670) - RISCV_INS_CV_SDOTSP_SC_H - cv.sdotsp.sc.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_SDOTUP_B (11671) - RISCV_INS_CV_SDOTUP_B - cv.sdotup.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_SDOTUP_H (11672) - RISCV_INS_CV_SDOTUP_H - cv.sdotup.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_SDOTUP_SCI_B (11673) - RISCV_INS_CV_SDOTUP_SCI_B - cv.sdotup.sci.b $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_SDOTUP_SCI_H (11674) - RISCV_INS_CV_SDOTUP_SCI_H - cv.sdotup.sci.h $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_SDOTUP_SC_B (11675) - RISCV_INS_CV_SDOTUP_SC_B - cv.sdotup.sc.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_SDOTUP_SC_H (11676) - RISCV_INS_CV_SDOTUP_SC_H - cv.sdotup.sc.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_SDOTUSP_B (11677) - RISCV_INS_CV_SDOTUSP_B - cv.sdotusp.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_SDOTUSP_H (11678) - RISCV_INS_CV_SDOTUSP_H - cv.sdotusp.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_SDOTUSP_SCI_B (11679) - RISCV_INS_CV_SDOTUSP_SCI_B - cv.sdotusp.sci.b $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_SDOTUSP_SCI_H (11680) - RISCV_INS_CV_SDOTUSP_SCI_H - cv.sdotusp.sci.h $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_SDOTUSP_SC_B (11681) - RISCV_INS_CV_SDOTUSP_SC_B - cv.sdotusp.sc.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_SDOTUSP_SC_H (11682) - RISCV_INS_CV_SDOTUSP_SC_H - cv.sdotusp.sc.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_SHUFFLE2_B (11683) - RISCV_INS_CV_SHUFFLE2_B - cv.shuffle2.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_SHUFFLE2_H (11684) - RISCV_INS_CV_SHUFFLE2_H - cv.shuffle2.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_SHUFFLEI0_SCI_B (11685) - RISCV_INS_CV_SHUFFLEI0_SCI_B - cv.shufflei0.sci.b $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_SHUFFLEI1_SCI_B (11686) - RISCV_INS_CV_SHUFFLEI1_SCI_B - cv.shufflei1.sci.b $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_SHUFFLEI2_SCI_B (11687) - RISCV_INS_CV_SHUFFLEI2_SCI_B - cv.shufflei2.sci.b $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_SHUFFLEI3_SCI_B (11688) - RISCV_INS_CV_SHUFFLEI3_SCI_B - cv.shufflei3.sci.b $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_SHUFFLE_B (11689) - RISCV_INS_CV_SHUFFLE_B - cv.shuffle.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_SHUFFLE_H (11690) - RISCV_INS_CV_SHUFFLE_H - cv.shuffle.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_SHUFFLE_SCI_H (11691) - RISCV_INS_CV_SHUFFLE_SCI_H - cv.shuffle.sci.h $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_SH_ri_inc (11692) - RISCV_INS_CV_SH - cv.sh $rs2, (${rs1}), ${imm12} */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG | CS_OP_MEM, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm12 */ + { 0 } +}}, +{ /* RISCV_CV_SH_rr (11693) - RISCV_INS_CV_SH - cv.sh $rs2, $cvrr */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST } }, /* cvrr */ + { 0 } +}}, +{ /* RISCV_CV_SH_rr_inc (11694) - RISCV_INS_CV_SH - cv.sh $rs2, (${rs1}), ${rs3} */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG | CS_OP_MEM, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs3 */ + { 0 } +}}, +{ /* RISCV_CV_SLET (11695) - RISCV_INS_CV_SLET - cv.slet $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_SLETU (11696) - RISCV_INS_CV_SLETU - cv.sletu $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_SLL_B (11697) - RISCV_INS_CV_SLL_B - cv.sll.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_SLL_H (11698) - RISCV_INS_CV_SLL_H - cv.sll.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_SLL_SCI_B (11699) - RISCV_INS_CV_SLL_SCI_B - cv.sll.sci.b $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_SLL_SCI_H (11700) - RISCV_INS_CV_SLL_SCI_H - cv.sll.sci.h $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_SLL_SC_B (11701) - RISCV_INS_CV_SLL_SC_B - cv.sll.sc.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_SLL_SC_H (11702) - RISCV_INS_CV_SLL_SC_H - cv.sll.sc.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_SRA_B (11703) - RISCV_INS_CV_SRA_B - cv.sra.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_SRA_H (11704) - RISCV_INS_CV_SRA_H - cv.sra.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_SRA_SCI_B (11705) - RISCV_INS_CV_SRA_SCI_B - cv.sra.sci.b $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_SRA_SCI_H (11706) - RISCV_INS_CV_SRA_SCI_H - cv.sra.sci.h $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_SRA_SC_B (11707) - RISCV_INS_CV_SRA_SC_B - cv.sra.sc.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_SRA_SC_H (11708) - RISCV_INS_CV_SRA_SC_H - cv.sra.sc.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_SRL_B (11709) - RISCV_INS_CV_SRL_B - cv.srl.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_SRL_H (11710) - RISCV_INS_CV_SRL_H - cv.srl.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_SRL_SCI_B (11711) - RISCV_INS_CV_SRL_SCI_B - cv.srl.sci.b $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_SRL_SCI_H (11712) - RISCV_INS_CV_SRL_SCI_H - cv.srl.sci.h $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_SRL_SC_B (11713) - RISCV_INS_CV_SRL_SC_B - cv.srl.sc.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_SRL_SC_H (11714) - RISCV_INS_CV_SRL_SC_H - cv.srl.sc.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_SUBN (11715) - RISCV_INS_CV_SUBN - cv.subn $rd, $rs1, $rs2, $imm5 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm5 */ + { 0 } +}}, +{ /* RISCV_CV_SUBNR (11716) - RISCV_INS_CV_SUBNR - cv.subnr $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_SUBRN (11717) - RISCV_INS_CV_SUBRN - cv.subrn $rd, $rs1, $rs2, $imm5 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm5 */ + { 0 } +}}, +{ /* RISCV_CV_SUBRNR (11718) - RISCV_INS_CV_SUBRNR - cv.subrnr $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_SUBROTMJ (11719) - RISCV_INS_CV_SUBROTMJ - cv.subrotmj $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_SUBROTMJ_DIV2 (11720) - RISCV_INS_CV_SUBROTMJ_DIV2 - cv.subrotmj.div2 $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_SUBROTMJ_DIV4 (11721) - RISCV_INS_CV_SUBROTMJ_DIV4 - cv.subrotmj.div4 $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_SUBROTMJ_DIV8 (11722) - RISCV_INS_CV_SUBROTMJ_DIV8 - cv.subrotmj.div8 $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_SUBUN (11723) - RISCV_INS_CV_SUBUN - cv.subun $rd, $rs1, $rs2, $imm5 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm5 */ + { 0 } +}}, +{ /* RISCV_CV_SUBUNR (11724) - RISCV_INS_CV_SUBUNR - cv.subunr $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_SUBURN (11725) - RISCV_INS_CV_SUBURN - cv.suburn $rd, $rs1, $rs2, $imm5 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm5 */ + { 0 } +}}, +{ /* RISCV_CV_SUBURNR (11726) - RISCV_INS_CV_SUBURNR - cv.suburnr $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_SUB_B (11727) - RISCV_INS_CV_SUB_B - cv.sub.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_SUB_DIV2 (11728) - RISCV_INS_CV_SUB_DIV2 - cv.sub.div2 $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_SUB_DIV4 (11729) - RISCV_INS_CV_SUB_DIV4 - cv.sub.div4 $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_SUB_DIV8 (11730) - RISCV_INS_CV_SUB_DIV8 - cv.sub.div8 $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_SUB_H (11731) - RISCV_INS_CV_SUB_H - cv.sub.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_SUB_SCI_B (11732) - RISCV_INS_CV_SUB_SCI_B - cv.sub.sci.b $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_SUB_SCI_H (11733) - RISCV_INS_CV_SUB_SCI_H - cv.sub.sci.h $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_SUB_SC_B (11734) - RISCV_INS_CV_SUB_SC_B - cv.sub.sc.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_SUB_SC_H (11735) - RISCV_INS_CV_SUB_SC_H - cv.sub.sc.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_SW_ri_inc (11736) - RISCV_INS_CV_SW - cv.sw $rs2, (${rs1}), ${imm12} */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG | CS_OP_MEM, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm12 */ + { 0 } +}}, +{ /* RISCV_CV_SW_rr (11737) - RISCV_INS_CV_SW - cv.sw $rs2, $cvrr */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST } }, /* cvrr */ + { 0 } +}}, +{ /* RISCV_CV_SW_rr_inc (11738) - RISCV_INS_CV_SW - cv.sw $rs2, (${rs1}), ${rs3} */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG | CS_OP_MEM, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs3 */ + { 0 } +}}, +{ /* RISCV_CV_XOR_B (11739) - RISCV_INS_CV_XOR_B - cv.xor.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_XOR_H (11740) - RISCV_INS_CV_XOR_H - cv.xor.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_XOR_SCI_B (11741) - RISCV_INS_CV_XOR_SCI_B - cv.xor.sci.b $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_XOR_SCI_H (11742) - RISCV_INS_CV_XOR_SCI_H - cv.xor.sci.h $rd, $rs1, $imm6 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm6 */ + { 0 } +}}, +{ /* RISCV_CV_XOR_SC_B (11743) - RISCV_INS_CV_XOR_SC_B - cv.xor.sc.b $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CV_XOR_SC_H (11744) - RISCV_INS_CV_XOR_SC_H - cv.xor.sc.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CZERO_EQZ (11745) - RISCV_INS_CZERO_EQZ - czero.eqz $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_CZERO_NEZ (11746) - RISCV_INS_CZERO_NEZ - czero.nez $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_C_ADD (11747) - RISCV_INS_C_ADD - c.add $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_C_ADDI (11748) - RISCV_INS_C_ADDI - c.addi $rd, $imm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { 0 } +}}, +{ /* RISCV_C_ADDI16SP (11749) - RISCV_INS_C_ADDI16SP - c.addi16sp $rd, $imm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { 0 } +}}, +{ /* RISCV_C_ADDI4SPN (11750) - RISCV_INS_C_ADDI4SPN - c.addi4spn $rd, $rs1, $imm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { 0 } +}}, +{ /* RISCV_C_ADDIW (11751) - RISCV_INS_C_ADDIW - c.addiw $rd, $imm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { 0 } +}}, +{ /* RISCV_C_ADDI_HINT_IMM_ZERO (11752) - RISCV_INS_C_ADDI - c.addi $rd, $imm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { 0 } +}}, +{ /* RISCV_C_ADDI_NOP (11753) - RISCV_INS_C_ADDI - c.addi $rd, $imm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { 0 } +}}, +{ /* RISCV_C_ADDW (11754) - RISCV_INS_C_ADDW - c.addw $rd, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_C_ADD_HINT (11755) - RISCV_INS_C_ADD - c.add $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_C_AND (11756) - RISCV_INS_C_AND - c.and $rd, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_C_ANDI (11757) - RISCV_INS_C_ANDI - c.andi $rs1, $imm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { 0 } +}}, +{ /* RISCV_C_BEQZ (11758) - RISCV_INS_C_BEQZ - c.beqz $rs1, $imm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST } }, /* imm */ + { 0 } +}}, +{ /* RISCV_C_BNEZ (11759) - RISCV_INS_C_BNEZ - c.bnez $rs1, $imm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST } }, /* imm */ + { 0 } +}}, +{ /* RISCV_C_EBREAK (11760) - RISCV_INS_C_EBREAK - c.ebreak */ +{ + { 0 } +}}, +{ /* RISCV_C_FLD (11761) - RISCV_INS_C_FLD - c.fld $rd, ${imm}(${rs1}) */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { 0 } +}}, +{ /* RISCV_C_FLDSP (11762) - RISCV_INS_C_FLDSP - c.fldsp $rd, ${imm}(${rs1}) */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { 0 } +}}, +{ /* RISCV_C_FLW (11763) - RISCV_INS_C_FLW - c.flw $rd, ${imm}(${rs1}) */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { 0 } +}}, +{ /* RISCV_C_FLWSP (11764) - RISCV_INS_C_FLWSP - c.flwsp $rd, ${imm}(${rs1}) */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { 0 } +}}, +{ /* RISCV_C_FSD (11765) - RISCV_INS_C_FSD - c.fsd $rs2, ${imm}(${rs1}) */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM | CS_OP_MEM, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { 0 } +}}, +{ /* RISCV_C_FSDSP (11766) - RISCV_INS_C_FSDSP - c.fsdsp $rs2, ${imm}(${rs1}) */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM | CS_OP_MEM, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { 0 } +}}, +{ /* RISCV_C_FSW (11767) - RISCV_INS_C_FSW - c.fsw $rs2, ${imm}(${rs1}) */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM | CS_OP_MEM, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { 0 } +}}, +{ /* RISCV_C_FSWSP (11768) - RISCV_INS_C_FSWSP - c.fswsp $rs2, ${imm}(${rs1}) */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM | CS_OP_MEM, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { 0 } +}}, +{ /* RISCV_C_J (11769) - RISCV_INS_C_J - c.j $offset */ +{ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* offset */ + { 0 } +}}, +{ /* RISCV_C_JAL (11770) - RISCV_INS_C_JAL - c.jal $offset */ +{ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* offset */ + { 0 } +}}, +{ /* RISCV_C_JALR (11771) - RISCV_INS_C_JALR - c.jalr $rs1 */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_C_JR (11772) - RISCV_INS_C_JR - c.jr $rs1 */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_C_LBU (11773) - RISCV_INS_C_LBU - c.lbu $rd, ${imm}(${rs1}) */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { 0 } +}}, +{ /* RISCV_C_LD (11774) - RISCV_INS_C_LD - c.ld $rd, ${imm}(${rs1}) */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { 0 } +}}, +{ /* RISCV_C_LDSP (11775) - RISCV_INS_C_LDSP - c.ldsp $rd, ${imm}(${rs1}) */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { 0 } +}}, +{ /* RISCV_C_LH (11776) - RISCV_INS_C_LH - c.lh $rd, ${imm}(${rs1}) */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { 0 } +}}, +{ /* RISCV_C_LHU (11777) - RISCV_INS_C_LHU - c.lhu $rd, ${imm}(${rs1}) */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { 0 } +}}, +{ /* RISCV_C_LI (11778) - RISCV_INS_C_LI - c.li $rd, $imm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { 0 } +}}, +{ /* RISCV_C_LI_HINT (11779) - RISCV_INS_C_LI - c.li $rd, $imm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { 0 } +}}, +{ /* RISCV_C_LUI (11780) - RISCV_INS_C_LUI - c.lui $rd, $imm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { 0 } +}}, +{ /* RISCV_C_LUI_HINT (11781) - RISCV_INS_C_LUI - c.lui $rd, $imm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { 0 } +}}, +{ /* RISCV_C_LW (11782) - RISCV_INS_C_LW - c.lw $rd, ${imm}(${rs1}) */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { 0 } +}}, +{ /* RISCV_C_LWSP (11783) - RISCV_INS_C_LWSP - c.lwsp $rd, ${imm}(${rs1}) */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { 0 } +}}, +{ /* RISCV_C_MUL (11784) - RISCV_INS_C_MUL - c.mul $rd, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_C_MV (11785) - RISCV_INS_C_MV - c.mv $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_C_MV_HINT (11786) - RISCV_INS_C_MV - c.mv $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_C_NOP (11787) - RISCV_INS_C_NOP - c.nop */ +{ + { 0 } +}}, +{ /* RISCV_C_NOP_HINT (11788) - RISCV_INS_C_NOP - c.nop $imm */ +{ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { 0 } +}}, +{ /* RISCV_C_NOT (11789) - RISCV_INS_C_NOT - c.not $rd */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { 0 } +}}, +{ /* RISCV_C_OR (11790) - RISCV_INS_C_OR - c.or $rd, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_C_SB (11791) - RISCV_INS_C_SB - c.sb $rs2, ${imm}(${rs1}) */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM | CS_OP_MEM, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { 0 } +}}, +{ /* RISCV_C_SD (11792) - RISCV_INS_C_SD - c.sd $rs2, ${imm}(${rs1}) */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM | CS_OP_MEM, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { 0 } +}}, +{ /* RISCV_C_SDSP (11793) - RISCV_INS_C_SDSP - c.sdsp $rs2, ${imm}(${rs1}) */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM | CS_OP_MEM, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { 0 } +}}, +{ /* RISCV_C_SEXT_B (11794) - RISCV_INS_C_SEXT_B - c.sext.b $rd */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { 0 } +}}, +{ /* RISCV_C_SEXT_H (11795) - RISCV_INS_C_SEXT_H - c.sext.h $rd */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { 0 } +}}, +{ /* RISCV_C_SH (11796) - RISCV_INS_C_SH - c.sh $rs2, ${imm}(${rs1}) */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM | CS_OP_MEM, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { 0 } +}}, +{ /* RISCV_C_SLLI (11797) - RISCV_INS_C_SLLI - c.slli $rd, $imm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { 0 } +}}, +{ /* RISCV_C_SLLI64_HINT (11798) - RISCV_INS_C_SLLI64 - c.slli64 $rd */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { 0 } +}}, +{ /* RISCV_C_SLLI_HINT (11799) - RISCV_INS_C_SLLI - c.slli $rd, $imm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { 0 } +}}, +{ /* RISCV_C_SRAI (11800) - RISCV_INS_C_SRAI - c.srai $rs1, $imm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { 0 } +}}, +{ /* RISCV_C_SRAI64_HINT (11801) - RISCV_INS_C_SRAI64 - c.srai64 $rd */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { 0 } +}}, +{ /* RISCV_C_SRLI (11802) - RISCV_INS_C_SRLI - c.srli $rs1, $imm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { 0 } +}}, +{ /* RISCV_C_SRLI64_HINT (11803) - RISCV_INS_C_SRLI64 - c.srli64 $rd */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { 0 } +}}, +{ /* RISCV_C_SSPOPCHK (11804) - RISCV_INS_C_SSPOPCHK - c.sspopchk $rs1 */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_C_SSPUSH (11805) - RISCV_INS_C_SSPUSH - c.sspush $rs1 */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_C_SUB (11806) - RISCV_INS_C_SUB - c.sub $rd, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_C_SUBW (11807) - RISCV_INS_C_SUBW - c.subw $rd, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_C_SW (11808) - RISCV_INS_C_SW - c.sw $rs2, ${imm}(${rs1}) */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM | CS_OP_MEM, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { 0 } +}}, +{ /* RISCV_C_SWSP (11809) - RISCV_INS_C_SWSP - c.swsp $rs2, ${imm}(${rs1}) */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM | CS_OP_MEM, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { 0 } +}}, +{ /* RISCV_C_UNIMP (11810) - RISCV_INS_C_UNIMP - c.unimp */ +{ + { 0 } +}}, +{ /* RISCV_C_XOR (11811) - RISCV_INS_C_XOR - c.xor $rd, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_C_ZEXT_B (11812) - RISCV_INS_C_ZEXT_B - c.zext.b $rd */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { 0 } +}}, +{ /* RISCV_C_ZEXT_H (11813) - RISCV_INS_C_ZEXT_H - c.zext.h $rd */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { 0 } +}}, +{ /* RISCV_C_ZEXT_W (11814) - RISCV_INS_C_ZEXT_W - c.zext.w $rd */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { 0 } +}}, +{ /* RISCV_DIV (11815) - RISCV_INS_DIV - div $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_DIVU (11816) - RISCV_INS_DIVU - divu $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_DIVUW (11817) - RISCV_INS_DIVUW - divuw $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_DIVW (11818) - RISCV_INS_DIVW - divw $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_DRET (11819) - RISCV_INS_DRET - dret */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_EBREAK (11820) - RISCV_INS_EBREAK - ebreak */ +{ + { 0 } +}}, +{ /* RISCV_ECALL (11821) - RISCV_INS_ECALL - ecall */ +{ + { 0 } +}}, +{ /* RISCV_FADD_D (11822) - RISCV_INS_FADD_D - fadd.d $rd, $rs1, $rs2$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FADD_D_IN32X (11823) - RISCV_INS_FADD_D - fadd.d $rd, $rs1, $rs2$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FADD_D_INX (11824) - RISCV_INS_FADD_D - fadd.d $rd, $rs1, $rs2$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FADD_H (11825) - RISCV_INS_FADD_H - fadd.h $rd, $rs1, $rs2$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FADD_H_INX (11826) - RISCV_INS_FADD_H - fadd.h $rd, $rs1, $rs2$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FADD_S (11827) - RISCV_INS_FADD_S - fadd.s $rd, $rs1, $rs2$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FADD_S_INX (11828) - RISCV_INS_FADD_S - fadd.s $rd, $rs1, $rs2$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCLASS_D (11829) - RISCV_INS_FCLASS_D - fclass.d $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_FCLASS_D_IN32X (11830) - RISCV_INS_FCLASS_D - fclass.d $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_FCLASS_D_INX (11831) - RISCV_INS_FCLASS_D - fclass.d $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_FCLASS_H (11832) - RISCV_INS_FCLASS_H - fclass.h $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_FCLASS_H_INX (11833) - RISCV_INS_FCLASS_H - fclass.h $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_FCLASS_S (11834) - RISCV_INS_FCLASS_S - fclass.s $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_FCLASS_S_INX (11835) - RISCV_INS_FCLASS_S - fclass.s $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_FCVTMOD_W_D (11836) - RISCV_INS_FCVTMOD_W_D - fcvtmod.w.d $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_BF16_S (11837) - RISCV_INS_FCVT_BF16_S - fcvt.bf16.s $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_D_H (11838) - RISCV_INS_FCVT_D_H - fcvt.d.h $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_D_H_IN32X (11839) - RISCV_INS_FCVT_D_H - fcvt.d.h $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_D_H_INX (11840) - RISCV_INS_FCVT_D_H - fcvt.d.h $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_D_L (11841) - RISCV_INS_FCVT_D_L - fcvt.d.l $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_D_LU (11842) - RISCV_INS_FCVT_D_LU - fcvt.d.lu $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_D_LU_INX (11843) - RISCV_INS_FCVT_D_LU - fcvt.d.lu $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_D_L_INX (11844) - RISCV_INS_FCVT_D_L - fcvt.d.l $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_D_S (11845) - RISCV_INS_FCVT_D_S - fcvt.d.s $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_D_S_IN32X (11846) - RISCV_INS_FCVT_D_S - fcvt.d.s $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_D_S_INX (11847) - RISCV_INS_FCVT_D_S - fcvt.d.s $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_D_W (11848) - RISCV_INS_FCVT_D_W - fcvt.d.w $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_D_WU (11849) - RISCV_INS_FCVT_D_WU - fcvt.d.wu $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_D_WU_IN32X (11850) - RISCV_INS_FCVT_D_WU - fcvt.d.wu $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_D_WU_INX (11851) - RISCV_INS_FCVT_D_WU - fcvt.d.wu $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_D_W_IN32X (11852) - RISCV_INS_FCVT_D_W - fcvt.d.w $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_D_W_INX (11853) - RISCV_INS_FCVT_D_W - fcvt.d.w $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_H_D (11854) - RISCV_INS_FCVT_H_D - fcvt.h.d $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_H_D_IN32X (11855) - RISCV_INS_FCVT_H_D - fcvt.h.d $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_H_D_INX (11856) - RISCV_INS_FCVT_H_D - fcvt.h.d $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_H_L (11857) - RISCV_INS_FCVT_H_L - fcvt.h.l $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_H_LU (11858) - RISCV_INS_FCVT_H_LU - fcvt.h.lu $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_H_LU_INX (11859) - RISCV_INS_FCVT_H_LU - fcvt.h.lu $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_H_L_INX (11860) - RISCV_INS_FCVT_H_L - fcvt.h.l $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_H_S (11861) - RISCV_INS_FCVT_H_S - fcvt.h.s $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_H_S_INX (11862) - RISCV_INS_FCVT_H_S - fcvt.h.s $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_H_W (11863) - RISCV_INS_FCVT_H_W - fcvt.h.w $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_H_WU (11864) - RISCV_INS_FCVT_H_WU - fcvt.h.wu $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_H_WU_INX (11865) - RISCV_INS_FCVT_H_WU - fcvt.h.wu $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_H_W_INX (11866) - RISCV_INS_FCVT_H_W - fcvt.h.w $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_LU_D (11867) - RISCV_INS_FCVT_LU_D - fcvt.lu.d $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_LU_D_INX (11868) - RISCV_INS_FCVT_LU_D - fcvt.lu.d $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_LU_H (11869) - RISCV_INS_FCVT_LU_H - fcvt.lu.h $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_LU_H_INX (11870) - RISCV_INS_FCVT_LU_H - fcvt.lu.h $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_LU_S (11871) - RISCV_INS_FCVT_LU_S - fcvt.lu.s $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_LU_S_INX (11872) - RISCV_INS_FCVT_LU_S - fcvt.lu.s $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_L_D (11873) - RISCV_INS_FCVT_L_D - fcvt.l.d $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_L_D_INX (11874) - RISCV_INS_FCVT_L_D - fcvt.l.d $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_L_H (11875) - RISCV_INS_FCVT_L_H - fcvt.l.h $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_L_H_INX (11876) - RISCV_INS_FCVT_L_H - fcvt.l.h $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_L_S (11877) - RISCV_INS_FCVT_L_S - fcvt.l.s $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_L_S_INX (11878) - RISCV_INS_FCVT_L_S - fcvt.l.s $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_S_BF16 (11879) - RISCV_INS_FCVT_S_BF16 - fcvt.s.bf16 $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_S_D (11880) - RISCV_INS_FCVT_S_D - fcvt.s.d $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_S_D_IN32X (11881) - RISCV_INS_FCVT_S_D - fcvt.s.d $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_S_D_INX (11882) - RISCV_INS_FCVT_S_D - fcvt.s.d $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_S_H (11883) - RISCV_INS_FCVT_S_H - fcvt.s.h $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_S_H_INX (11884) - RISCV_INS_FCVT_S_H - fcvt.s.h $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_S_L (11885) - RISCV_INS_FCVT_S_L - fcvt.s.l $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_S_LU (11886) - RISCV_INS_FCVT_S_LU - fcvt.s.lu $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_S_LU_INX (11887) - RISCV_INS_FCVT_S_LU - fcvt.s.lu $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_S_L_INX (11888) - RISCV_INS_FCVT_S_L - fcvt.s.l $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_S_W (11889) - RISCV_INS_FCVT_S_W - fcvt.s.w $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_S_WU (11890) - RISCV_INS_FCVT_S_WU - fcvt.s.wu $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_S_WU_INX (11891) - RISCV_INS_FCVT_S_WU - fcvt.s.wu $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_S_W_INX (11892) - RISCV_INS_FCVT_S_W - fcvt.s.w $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_WU_D (11893) - RISCV_INS_FCVT_WU_D - fcvt.wu.d $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_WU_D_IN32X (11894) - RISCV_INS_FCVT_WU_D - fcvt.wu.d $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_WU_D_INX (11895) - RISCV_INS_FCVT_WU_D - fcvt.wu.d $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_WU_H (11896) - RISCV_INS_FCVT_WU_H - fcvt.wu.h $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_WU_H_INX (11897) - RISCV_INS_FCVT_WU_H - fcvt.wu.h $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_WU_S (11898) - RISCV_INS_FCVT_WU_S - fcvt.wu.s $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_WU_S_INX (11899) - RISCV_INS_FCVT_WU_S - fcvt.wu.s $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_W_D (11900) - RISCV_INS_FCVT_W_D - fcvt.w.d $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_W_D_IN32X (11901) - RISCV_INS_FCVT_W_D - fcvt.w.d $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_W_D_INX (11902) - RISCV_INS_FCVT_W_D - fcvt.w.d $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_W_H (11903) - RISCV_INS_FCVT_W_H - fcvt.w.h $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_W_H_INX (11904) - RISCV_INS_FCVT_W_H - fcvt.w.h $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_W_S (11905) - RISCV_INS_FCVT_W_S - fcvt.w.s $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FCVT_W_S_INX (11906) - RISCV_INS_FCVT_W_S - fcvt.w.s $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FDIV_D (11907) - RISCV_INS_FDIV_D - fdiv.d $rd, $rs1, $rs2$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FDIV_D_IN32X (11908) - RISCV_INS_FDIV_D - fdiv.d $rd, $rs1, $rs2$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FDIV_D_INX (11909) - RISCV_INS_FDIV_D - fdiv.d $rd, $rs1, $rs2$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FDIV_H (11910) - RISCV_INS_FDIV_H - fdiv.h $rd, $rs1, $rs2$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FDIV_H_INX (11911) - RISCV_INS_FDIV_H - fdiv.h $rd, $rs1, $rs2$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FDIV_S (11912) - RISCV_INS_FDIV_S - fdiv.s $rd, $rs1, $rs2$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FDIV_S_INX (11913) - RISCV_INS_FDIV_S - fdiv.s $rd, $rs1, $rs2$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FENCE (11914) - RISCV_INS_FENCE - fence $pred, $succ */ +{ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* pred */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* succ */ + { 0 } +}}, +{ /* RISCV_FENCE_I (11915) - RISCV_INS_FENCE_I - fence.i */ +{ + { 0 } +}}, +{ /* RISCV_FENCE_TSO (11916) - RISCV_INS_FENCE_TSO - fence.tso */ +{ + { 0 } +}}, +{ /* RISCV_FEQ_D (11917) - RISCV_INS_FEQ_D - feq.d $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FEQ_D_IN32X (11918) - RISCV_INS_FEQ_D - feq.d $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FEQ_D_INX (11919) - RISCV_INS_FEQ_D - feq.d $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FEQ_H (11920) - RISCV_INS_FEQ_H - feq.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FEQ_H_INX (11921) - RISCV_INS_FEQ_H - feq.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FEQ_S (11922) - RISCV_INS_FEQ_S - feq.s $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FEQ_S_INX (11923) - RISCV_INS_FEQ_S - feq.s $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FLD (11924) - RISCV_INS_FLD - fld $rd, ${imm12}(${rs1}) */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm12 */ + { 0 } +}}, +{ /* RISCV_FLEQ_D (11925) - RISCV_INS_FLEQ_D - fleq.d $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FLEQ_H (11926) - RISCV_INS_FLEQ_H - fleq.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FLEQ_S (11927) - RISCV_INS_FLEQ_S - fleq.s $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FLE_D (11928) - RISCV_INS_FLE_D - fle.d $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FLE_D_IN32X (11929) - RISCV_INS_FLE_D - fle.d $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FLE_D_INX (11930) - RISCV_INS_FLE_D - fle.d $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FLE_H (11931) - RISCV_INS_FLE_H - fle.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FLE_H_INX (11932) - RISCV_INS_FLE_H - fle.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FLE_S (11933) - RISCV_INS_FLE_S - fle.s $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FLE_S_INX (11934) - RISCV_INS_FLE_S - fle.s $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FLH (11935) - RISCV_INS_FLH - flh $rd, ${imm12}(${rs1}) */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm12 */ + { 0 } +}}, +{ /* RISCV_FLI_D (11936) - RISCV_INS_FLI_D - fli.d $rd, $imm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { 0 } +}}, +{ /* RISCV_FLI_H (11937) - RISCV_INS_FLI_H - fli.h $rd, $imm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { 0 } +}}, +{ /* RISCV_FLI_S (11938) - RISCV_INS_FLI_S - fli.s $rd, $imm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { 0 } +}}, +{ /* RISCV_FLTQ_D (11939) - RISCV_INS_FLTQ_D - fltq.d $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FLTQ_H (11940) - RISCV_INS_FLTQ_H - fltq.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FLTQ_S (11941) - RISCV_INS_FLTQ_S - fltq.s $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FLT_D (11942) - RISCV_INS_FLT_D - flt.d $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FLT_D_IN32X (11943) - RISCV_INS_FLT_D - flt.d $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FLT_D_INX (11944) - RISCV_INS_FLT_D - flt.d $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FLT_H (11945) - RISCV_INS_FLT_H - flt.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FLT_H_INX (11946) - RISCV_INS_FLT_H - flt.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FLT_S (11947) - RISCV_INS_FLT_S - flt.s $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FLT_S_INX (11948) - RISCV_INS_FLT_S - flt.s $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FLW (11949) - RISCV_INS_FLW - flw $rd, ${imm12}(${rs1}) */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm12 */ + { 0 } +}}, +{ /* RISCV_FMADD_D (11950) - RISCV_INS_FMADD_D - fmadd.d $rd, $rs1, $rs2, $rs3$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs3 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FMADD_D_IN32X (11951) - RISCV_INS_FMADD_D - fmadd.d $rd, $rs1, $rs2, $rs3$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs3 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FMADD_D_INX (11952) - RISCV_INS_FMADD_D - fmadd.d $rd, $rs1, $rs2, $rs3$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs3 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FMADD_H (11953) - RISCV_INS_FMADD_H - fmadd.h $rd, $rs1, $rs2, $rs3$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rs3 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FMADD_H_INX (11954) - RISCV_INS_FMADD_H - fmadd.h $rd, $rs1, $rs2, $rs3$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rs3 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FMADD_S (11955) - RISCV_INS_FMADD_S - fmadd.s $rd, $rs1, $rs2, $rs3$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs3 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FMADD_S_INX (11956) - RISCV_INS_FMADD_S - fmadd.s $rd, $rs1, $rs2, $rs3$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs3 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FMAXM_D (11957) - RISCV_INS_FMAXM_D - fmaxm.d $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FMAXM_H (11958) - RISCV_INS_FMAXM_H - fmaxm.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FMAXM_S (11959) - RISCV_INS_FMAXM_S - fmaxm.s $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FMAX_D (11960) - RISCV_INS_FMAX_D - fmax.d $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FMAX_D_IN32X (11961) - RISCV_INS_FMAX_D - fmax.d $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FMAX_D_INX (11962) - RISCV_INS_FMAX_D - fmax.d $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FMAX_H (11963) - RISCV_INS_FMAX_H - fmax.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FMAX_H_INX (11964) - RISCV_INS_FMAX_H - fmax.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FMAX_S (11965) - RISCV_INS_FMAX_S - fmax.s $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FMAX_S_INX (11966) - RISCV_INS_FMAX_S - fmax.s $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FMINM_D (11967) - RISCV_INS_FMINM_D - fminm.d $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FMINM_H (11968) - RISCV_INS_FMINM_H - fminm.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FMINM_S (11969) - RISCV_INS_FMINM_S - fminm.s $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FMIN_D (11970) - RISCV_INS_FMIN_D - fmin.d $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FMIN_D_IN32X (11971) - RISCV_INS_FMIN_D - fmin.d $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FMIN_D_INX (11972) - RISCV_INS_FMIN_D - fmin.d $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FMIN_H (11973) - RISCV_INS_FMIN_H - fmin.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FMIN_H_INX (11974) - RISCV_INS_FMIN_H - fmin.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FMIN_S (11975) - RISCV_INS_FMIN_S - fmin.s $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FMIN_S_INX (11976) - RISCV_INS_FMIN_S - fmin.s $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FMSUB_D (11977) - RISCV_INS_FMSUB_D - fmsub.d $rd, $rs1, $rs2, $rs3$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs3 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FMSUB_D_IN32X (11978) - RISCV_INS_FMSUB_D - fmsub.d $rd, $rs1, $rs2, $rs3$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs3 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FMSUB_D_INX (11979) - RISCV_INS_FMSUB_D - fmsub.d $rd, $rs1, $rs2, $rs3$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs3 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FMSUB_H (11980) - RISCV_INS_FMSUB_H - fmsub.h $rd, $rs1, $rs2, $rs3$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rs3 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FMSUB_H_INX (11981) - RISCV_INS_FMSUB_H - fmsub.h $rd, $rs1, $rs2, $rs3$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rs3 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FMSUB_S (11982) - RISCV_INS_FMSUB_S - fmsub.s $rd, $rs1, $rs2, $rs3$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs3 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FMSUB_S_INX (11983) - RISCV_INS_FMSUB_S - fmsub.s $rd, $rs1, $rs2, $rs3$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs3 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FMUL_D (11984) - RISCV_INS_FMUL_D - fmul.d $rd, $rs1, $rs2$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FMUL_D_IN32X (11985) - RISCV_INS_FMUL_D - fmul.d $rd, $rs1, $rs2$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FMUL_D_INX (11986) - RISCV_INS_FMUL_D - fmul.d $rd, $rs1, $rs2$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FMUL_H (11987) - RISCV_INS_FMUL_H - fmul.h $rd, $rs1, $rs2$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FMUL_H_INX (11988) - RISCV_INS_FMUL_H - fmul.h $rd, $rs1, $rs2$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FMUL_S (11989) - RISCV_INS_FMUL_S - fmul.s $rd, $rs1, $rs2$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FMUL_S_INX (11990) - RISCV_INS_FMUL_S - fmul.s $rd, $rs1, $rs2$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FMVH_X_D (11991) - RISCV_INS_FMVH_X_D - fmvh.x.d $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_FMVP_D_X (11992) - RISCV_INS_FMVP_D_X - fmvp.d.x $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FMV_D_X (11993) - RISCV_INS_FMV_D_X - fmv.d.x $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_FMV_H_X (11994) - RISCV_INS_FMV_H_X - fmv.h.x $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_FMV_W_X (11995) - RISCV_INS_FMV_W_X - fmv.w.x $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_FMV_X_D (11996) - RISCV_INS_FMV_X_D - fmv.x.d $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_FMV_X_H (11997) - RISCV_INS_FMV_X_H - fmv.x.h $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_FMV_X_W (11998) - RISCV_INS_FMV_X_W - fmv.x.w $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{{{ /* RISCV_FMV_X_W_FPR64 (11999) - RISCV_INS_INVALID - fmv.x.w $rd, $rs1 */ + 0 +}}}, +{ /* RISCV_FNMADD_D (12000) - RISCV_INS_FNMADD_D - fnmadd.d $rd, $rs1, $rs2, $rs3$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs3 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FNMADD_D_IN32X (12001) - RISCV_INS_FNMADD_D - fnmadd.d $rd, $rs1, $rs2, $rs3$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs3 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FNMADD_D_INX (12002) - RISCV_INS_FNMADD_D - fnmadd.d $rd, $rs1, $rs2, $rs3$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs3 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FNMADD_H (12003) - RISCV_INS_FNMADD_H - fnmadd.h $rd, $rs1, $rs2, $rs3$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rs3 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FNMADD_H_INX (12004) - RISCV_INS_FNMADD_H - fnmadd.h $rd, $rs1, $rs2, $rs3$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rs3 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FNMADD_S (12005) - RISCV_INS_FNMADD_S - fnmadd.s $rd, $rs1, $rs2, $rs3$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs3 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FNMADD_S_INX (12006) - RISCV_INS_FNMADD_S - fnmadd.s $rd, $rs1, $rs2, $rs3$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs3 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FNMSUB_D (12007) - RISCV_INS_FNMSUB_D - fnmsub.d $rd, $rs1, $rs2, $rs3$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs3 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FNMSUB_D_IN32X (12008) - RISCV_INS_FNMSUB_D - fnmsub.d $rd, $rs1, $rs2, $rs3$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs3 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FNMSUB_D_INX (12009) - RISCV_INS_FNMSUB_D - fnmsub.d $rd, $rs1, $rs2, $rs3$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs3 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FNMSUB_H (12010) - RISCV_INS_FNMSUB_H - fnmsub.h $rd, $rs1, $rs2, $rs3$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rs3 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FNMSUB_H_INX (12011) - RISCV_INS_FNMSUB_H - fnmsub.h $rd, $rs1, $rs2, $rs3$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rs3 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FNMSUB_S (12012) - RISCV_INS_FNMSUB_S - fnmsub.s $rd, $rs1, $rs2, $rs3$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs3 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FNMSUB_S_INX (12013) - RISCV_INS_FNMSUB_S - fnmsub.s $rd, $rs1, $rs2, $rs3$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs3 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FROUNDNX_D (12014) - RISCV_INS_FROUNDNX_D - froundnx.d $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FROUNDNX_H (12015) - RISCV_INS_FROUNDNX_H - froundnx.h $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FROUNDNX_S (12016) - RISCV_INS_FROUNDNX_S - froundnx.s $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FROUND_D (12017) - RISCV_INS_FROUND_D - fround.d $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FROUND_H (12018) - RISCV_INS_FROUND_H - fround.h $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FROUND_S (12019) - RISCV_INS_FROUND_S - fround.s $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FSD (12020) - RISCV_INS_FSD - fsd $rs2, ${imm12}(${rs1}) */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM | CS_OP_MEM, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm12 */ + { 0 } +}}, +{ /* RISCV_FSGNJN_D (12021) - RISCV_INS_FSGNJN_D - fsgnjn.d $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FSGNJN_D_IN32X (12022) - RISCV_INS_FSGNJN_D - fsgnjn.d $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FSGNJN_D_INX (12023) - RISCV_INS_FSGNJN_D - fsgnjn.d $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FSGNJN_H (12024) - RISCV_INS_FSGNJN_H - fsgnjn.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FSGNJN_H_INX (12025) - RISCV_INS_FSGNJN_H - fsgnjn.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FSGNJN_S (12026) - RISCV_INS_FSGNJN_S - fsgnjn.s $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FSGNJN_S_INX (12027) - RISCV_INS_FSGNJN_S - fsgnjn.s $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FSGNJX_D (12028) - RISCV_INS_FSGNJX_D - fsgnjx.d $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FSGNJX_D_IN32X (12029) - RISCV_INS_FSGNJX_D - fsgnjx.d $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FSGNJX_D_INX (12030) - RISCV_INS_FSGNJX_D - fsgnjx.d $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FSGNJX_H (12031) - RISCV_INS_FSGNJX_H - fsgnjx.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FSGNJX_H_INX (12032) - RISCV_INS_FSGNJX_H - fsgnjx.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FSGNJX_S (12033) - RISCV_INS_FSGNJX_S - fsgnjx.s $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FSGNJX_S_INX (12034) - RISCV_INS_FSGNJX_S - fsgnjx.s $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FSGNJ_D (12035) - RISCV_INS_FSGNJ_D - fsgnj.d $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FSGNJ_D_IN32X (12036) - RISCV_INS_FSGNJ_D - fsgnj.d $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FSGNJ_D_INX (12037) - RISCV_INS_FSGNJ_D - fsgnj.d $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FSGNJ_H (12038) - RISCV_INS_FSGNJ_H - fsgnj.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FSGNJ_H_INX (12039) - RISCV_INS_FSGNJ_H - fsgnj.h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FSGNJ_S (12040) - RISCV_INS_FSGNJ_S - fsgnj.s $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FSGNJ_S_INX (12041) - RISCV_INS_FSGNJ_S - fsgnj.s $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_FSH (12042) - RISCV_INS_FSH - fsh $rs2, ${imm12}(${rs1}) */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM | CS_OP_MEM, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm12 */ + { 0 } +}}, +{ /* RISCV_FSQRT_D (12043) - RISCV_INS_FSQRT_D - fsqrt.d $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FSQRT_D_IN32X (12044) - RISCV_INS_FSQRT_D - fsqrt.d $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FSQRT_D_INX (12045) - RISCV_INS_FSQRT_D - fsqrt.d $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FSQRT_H (12046) - RISCV_INS_FSQRT_H - fsqrt.h $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FSQRT_H_INX (12047) - RISCV_INS_FSQRT_H - fsqrt.h $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FSQRT_S (12048) - RISCV_INS_FSQRT_S - fsqrt.s $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FSQRT_S_INX (12049) - RISCV_INS_FSQRT_S - fsqrt.s $rd, $rs1$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FSUB_D (12050) - RISCV_INS_FSUB_D - fsub.d $rd, $rs1, $rs2$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FSUB_D_IN32X (12051) - RISCV_INS_FSUB_D - fsub.d $rd, $rs1, $rs2$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FSUB_D_INX (12052) - RISCV_INS_FSUB_D - fsub.d $rd, $rs1, $rs2$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FSUB_H (12053) - RISCV_INS_FSUB_H - fsub.h $rd, $rs1, $rs2$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_bf16, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FSUB_H_INX (12054) - RISCV_INS_FSUB_H - fsub.h $rd, $rs1, $rs2$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f16, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FSUB_S (12055) - RISCV_INS_FSUB_S - fsub.s $rd, $rs1, $rs2$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FSUB_S_INX (12056) - RISCV_INS_FSUB_S - fsub.s $rd, $rs1, $rs2$frm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_INVALID, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* frm */ + { 0 } +}}, +{ /* RISCV_FSW (12057) - RISCV_INS_FSW - fsw $rs2, ${imm12}(${rs1}) */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM | CS_OP_MEM, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm12 */ + { 0 } +}}, +{ /* RISCV_HFENCE_GVMA (12058) - RISCV_INS_HFENCE_GVMA - hfence.gvma $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_HFENCE_VVMA (12059) - RISCV_INS_HFENCE_VVMA - hfence.vvma $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_HINVAL_GVMA (12060) - RISCV_INS_HINVAL_GVMA - hinval.gvma $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_HINVAL_VVMA (12061) - RISCV_INS_HINVAL_VVMA - hinval.vvma $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_HLVX_HU (12062) - RISCV_INS_HLVX_HU - hlvx.hu $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_HLVX_WU (12063) - RISCV_INS_HLVX_WU - hlvx.wu $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_HLV_B (12064) - RISCV_INS_HLV_B - hlv.b $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_HLV_BU (12065) - RISCV_INS_HLV_BU - hlv.bu $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_HLV_D (12066) - RISCV_INS_HLV_D - hlv.d $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_HLV_H (12067) - RISCV_INS_HLV_H - hlv.h $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_HLV_HU (12068) - RISCV_INS_HLV_HU - hlv.hu $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_HLV_W (12069) - RISCV_INS_HLV_W - hlv.w $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_HLV_WU (12070) - RISCV_INS_HLV_WU - hlv.wu $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_HSV_B (12071) - RISCV_INS_HSV_B - hsv.b $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_HSV_D (12072) - RISCV_INS_HSV_D - hsv.d $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_HSV_H (12073) - RISCV_INS_HSV_H - hsv.h $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_HSV_W (12074) - RISCV_INS_HSV_W - hsv.w $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{{{ /* RISCV_InsnB (12075) - RISCV_INS_INVALID - .insn b $opcode, $funct3, $rs1, $rs2, $imm12 */ + 0 +}}}, +{{{ /* RISCV_InsnCA (12076) - RISCV_INS_INVALID - .insn ca $opcode, $funct6, $funct2, $rd, $rs2 */ + 0 +}}}, +{{{ /* RISCV_InsnCB (12077) - RISCV_INS_INVALID - .insn cb $opcode, $funct3, $rs1, $imm8 */ + 0 +}}}, +{{{ /* RISCV_InsnCI (12078) - RISCV_INS_INVALID - .insn ci $opcode, $funct3, $rd, $imm6 */ + 0 +}}}, +{{{ /* RISCV_InsnCIW (12079) - RISCV_INS_INVALID - .insn ciw $opcode, $funct3, $rd, $imm8 */ + 0 +}}}, +{{{ /* RISCV_InsnCJ (12080) - RISCV_INS_INVALID - .insn cj $opcode, $funct3, $imm11 */ + 0 +}}}, +{{{ /* RISCV_InsnCL (12081) - RISCV_INS_INVALID - .insn cl $opcode, $funct3, $rd, ${imm5}(${rs1}) */ + 0 +}}}, +{{{ /* RISCV_InsnCR (12082) - RISCV_INS_INVALID - .insn cr $opcode, $funct4, $rd, $rs2 */ + 0 +}}}, +{{{ /* RISCV_InsnCS (12083) - RISCV_INS_INVALID - .insn cs $opcode, $funct3, $rs2, ${imm5}(${rs1}) */ + 0 +}}}, +{{{ /* RISCV_InsnCSS (12084) - RISCV_INS_INVALID - .insn css $opcode, $funct3, $rs2, $imm6 */ + 0 +}}}, +{{{ /* RISCV_InsnI (12085) - RISCV_INS_INVALID - .insn i $opcode, $funct3, $rd, $rs1, $imm12 */ + 0 +}}}, +{{{ /* RISCV_InsnI_Mem (12086) - RISCV_INS_INVALID - .insn i $opcode, $funct3, $rd, ${imm12}(${rs1}) */ + 0 +}}}, +{{{ /* RISCV_InsnJ (12087) - RISCV_INS_INVALID - .insn j $opcode, $rd, $imm20 */ + 0 +}}}, +{{{ /* RISCV_InsnR (12088) - RISCV_INS_INVALID - .insn r $opcode, $funct3, $funct7, $rd, $rs1, $rs2 */ + 0 +}}}, +{{{ /* RISCV_InsnR4 (12089) - RISCV_INS_INVALID - .insn r4 $opcode, $funct3, $funct2, $rd, $rs1, $rs2, $rs3 */ + 0 +}}}, +{{{ /* RISCV_InsnS (12090) - RISCV_INS_INVALID - .insn s $opcode, $funct3, $rs2, ${imm12}(${rs1}) */ + 0 +}}}, +{{{ /* RISCV_InsnU (12091) - RISCV_INS_INVALID - .insn u $opcode, $rd, $imm20 */ + 0 +}}}, +{ /* RISCV_JAL (12092) - RISCV_INS_JAL - jal $rd, $imm20 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST } }, /* imm20 */ + { 0 } +}}, +{ /* RISCV_JALR (12093) - RISCV_INS_JALR - jalr $rd, ${imm12}(${rs1}) */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm12 */ + { 0 } +}}, +{ /* RISCV_LB (12094) - RISCV_INS_LB - lb $rd, ${imm12}(${rs1}) */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm12 */ + { 0 } +}}, +{ /* RISCV_LBU (12095) - RISCV_INS_LBU - lbu $rd, ${imm12}(${rs1}) */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm12 */ + { 0 } +}}, +{ /* RISCV_LD (12096) - RISCV_INS_LD - ld $rd, ${imm12}(${rs1}) */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm12 */ + { 0 } +}}, +{ /* RISCV_LH (12097) - RISCV_INS_LH - lh $rd, ${imm12}(${rs1}) */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm12 */ + { 0 } +}}, +{ /* RISCV_LHU (12098) - RISCV_INS_LHU - lhu $rd, ${imm12}(${rs1}) */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm12 */ + { 0 } +}}, +{ /* RISCV_LR_D (12099) - RISCV_INS_LR_D - lr.d $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_LR_D_AQ (12100) - RISCV_INS_LR_D_AQ - lr.d.aq $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_LR_D_AQ_RL (12101) - RISCV_INS_LR_D_AQRL - lr.d.aqrl $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_LR_D_RL (12102) - RISCV_INS_LR_D_RL - lr.d.rl $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_LR_W (12103) - RISCV_INS_LR_W - lr.w $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_LR_W_AQ (12104) - RISCV_INS_LR_W_AQ - lr.w.aq $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_LR_W_AQ_RL (12105) - RISCV_INS_LR_W_AQRL - lr.w.aqrl $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_LR_W_RL (12106) - RISCV_INS_LR_W_RL - lr.w.rl $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_LUI (12107) - RISCV_INS_LUI - lui $rd, $imm20 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm20 */ + { 0 } +}}, +{ /* RISCV_LW (12108) - RISCV_INS_LW - lw $rd, ${imm12}(${rs1}) */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm12 */ + { 0 } +}}, +{ /* RISCV_LWU (12109) - RISCV_INS_LWU - lwu $rd, ${imm12}(${rs1}) */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm12 */ + { 0 } +}}, +{ /* RISCV_MAX (12110) - RISCV_INS_MAX - max $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_MAXU (12111) - RISCV_INS_MAXU - maxu $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_MIN (12112) - RISCV_INS_MIN - min $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_MINU (12113) - RISCV_INS_MINU - minu $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_MOPR0 (12114) - RISCV_INS_MOP_R_0 - mop.r.0 $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_MOPR1 (12115) - RISCV_INS_MOP_R_1 - mop.r.1 $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_MOPR10 (12116) - RISCV_INS_MOP_R_10 - mop.r.10 $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_MOPR11 (12117) - RISCV_INS_MOP_R_11 - mop.r.11 $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_MOPR12 (12118) - RISCV_INS_MOP_R_12 - mop.r.12 $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_MOPR13 (12119) - RISCV_INS_MOP_R_13 - mop.r.13 $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_MOPR14 (12120) - RISCV_INS_MOP_R_14 - mop.r.14 $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_MOPR15 (12121) - RISCV_INS_MOP_R_15 - mop.r.15 $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_MOPR16 (12122) - RISCV_INS_MOP_R_16 - mop.r.16 $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_MOPR17 (12123) - RISCV_INS_MOP_R_17 - mop.r.17 $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_MOPR18 (12124) - RISCV_INS_MOP_R_18 - mop.r.18 $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_MOPR19 (12125) - RISCV_INS_MOP_R_19 - mop.r.19 $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_MOPR2 (12126) - RISCV_INS_MOP_R_2 - mop.r.2 $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_MOPR20 (12127) - RISCV_INS_MOP_R_20 - mop.r.20 $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_MOPR21 (12128) - RISCV_INS_MOP_R_21 - mop.r.21 $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_MOPR22 (12129) - RISCV_INS_MOP_R_22 - mop.r.22 $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_MOPR23 (12130) - RISCV_INS_MOP_R_23 - mop.r.23 $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_MOPR24 (12131) - RISCV_INS_MOP_R_24 - mop.r.24 $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_MOPR25 (12132) - RISCV_INS_MOP_R_25 - mop.r.25 $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_MOPR26 (12133) - RISCV_INS_MOP_R_26 - mop.r.26 $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_MOPR27 (12134) - RISCV_INS_MOP_R_27 - mop.r.27 $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_MOPR28 (12135) - RISCV_INS_MOP_R_28 - mop.r.28 $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_MOPR29 (12136) - RISCV_INS_MOP_R_29 - mop.r.29 $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_MOPR3 (12137) - RISCV_INS_MOP_R_3 - mop.r.3 $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_MOPR30 (12138) - RISCV_INS_MOP_R_30 - mop.r.30 $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_MOPR31 (12139) - RISCV_INS_MOP_R_31 - mop.r.31 $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_MOPR4 (12140) - RISCV_INS_MOP_R_4 - mop.r.4 $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_MOPR5 (12141) - RISCV_INS_MOP_R_5 - mop.r.5 $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_MOPR6 (12142) - RISCV_INS_MOP_R_6 - mop.r.6 $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_MOPR7 (12143) - RISCV_INS_MOP_R_7 - mop.r.7 $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_MOPR8 (12144) - RISCV_INS_MOP_R_8 - mop.r.8 $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_MOPR9 (12145) - RISCV_INS_MOP_R_9 - mop.r.9 $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_MOPRR0 (12146) - RISCV_INS_MOP_RR_0 - mop.rr.0 $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_MOPRR1 (12147) - RISCV_INS_MOP_RR_1 - mop.rr.1 $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_MOPRR2 (12148) - RISCV_INS_MOP_RR_2 - mop.rr.2 $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_MOPRR3 (12149) - RISCV_INS_MOP_RR_3 - mop.rr.3 $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_MOPRR4 (12150) - RISCV_INS_MOP_RR_4 - mop.rr.4 $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_MOPRR5 (12151) - RISCV_INS_MOP_RR_5 - mop.rr.5 $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_MOPRR6 (12152) - RISCV_INS_MOP_RR_6 - mop.rr.6 $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_MOPRR7 (12153) - RISCV_INS_MOP_RR_7 - mop.rr.7 $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_MRET (12154) - RISCV_INS_MRET - mret */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_MUL (12155) - RISCV_INS_MUL - mul $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_MULH (12156) - RISCV_INS_MULH - mulh $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_MULHSU (12157) - RISCV_INS_MULHSU - mulhsu $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_MULHU (12158) - RISCV_INS_MULHU - mulhu $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_MULW (12159) - RISCV_INS_MULW - mulw $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_OR (12160) - RISCV_INS_OR - or $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_ORC_B (12161) - RISCV_INS_ORC_B - orc.b $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_ORI (12162) - RISCV_INS_ORI - ori $rd, $rs1, $imm12 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm12 */ + { 0 } +}}, +{ /* RISCV_ORN (12163) - RISCV_INS_ORN - orn $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_PACK (12164) - RISCV_INS_PACK - pack $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_PACKH (12165) - RISCV_INS_PACKH - packh $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_PACKW (12166) - RISCV_INS_PACKW - packw $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_PREFETCH_I (12167) - RISCV_INS_PREFETCH_I - prefetch.i ${imm12}(${rs1}) */ +{ + { CS_OP_REG | CS_OP_MEM, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM | CS_OP_MEM, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm12 */ + { 0 } +}}, +{ /* RISCV_PREFETCH_R (12168) - RISCV_INS_PREFETCH_R - prefetch.r ${imm12}(${rs1}) */ +{ + { CS_OP_REG | CS_OP_MEM, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM | CS_OP_MEM, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm12 */ + { 0 } +}}, +{ /* RISCV_PREFETCH_W (12169) - RISCV_INS_PREFETCH_W - prefetch.w ${imm12}(${rs1}) */ +{ + { CS_OP_REG | CS_OP_MEM, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM | CS_OP_MEM, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm12 */ + { 0 } +}}, +{ /* RISCV_REM (12170) - RISCV_INS_REM - rem $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_REMU (12171) - RISCV_INS_REMU - remu $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_REMUW (12172) - RISCV_INS_REMUW - remuw $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_REMW (12173) - RISCV_INS_REMW - remw $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_REV8_RV32 (12174) - RISCV_INS_REV8 - rev8 $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_REV8_RV64 (12175) - RISCV_INS_REV8 - rev8 $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_ROL (12176) - RISCV_INS_ROL - rol $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_ROLW (12177) - RISCV_INS_ROLW - rolw $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_ROR (12178) - RISCV_INS_ROR - ror $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_RORI (12179) - RISCV_INS_RORI - rori $rd, $rs1, $shamt */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* shamt */ + { 0 } +}}, +{ /* RISCV_RORIW (12180) - RISCV_INS_RORIW - roriw $rd, $rs1, $shamt */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* shamt */ + { 0 } +}}, +{ /* RISCV_RORW (12181) - RISCV_INS_RORW - rorw $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_SB (12182) - RISCV_INS_SB - sb $rs2, ${imm12}(${rs1}) */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM | CS_OP_MEM, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm12 */ + { 0 } +}}, +{ /* RISCV_SC_D (12183) - RISCV_INS_SC_D - sc.d $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_SC_D_AQ (12184) - RISCV_INS_SC_D_AQ - sc.d.aq $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_SC_D_AQ_RL (12185) - RISCV_INS_SC_D_AQRL - sc.d.aqrl $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_SC_D_RL (12186) - RISCV_INS_SC_D_RL - sc.d.rl $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_SC_W (12187) - RISCV_INS_SC_W - sc.w $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_SC_W_AQ (12188) - RISCV_INS_SC_W_AQ - sc.w.aq $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_SC_W_AQ_RL (12189) - RISCV_INS_SC_W_AQRL - sc.w.aqrl $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_SC_W_RL (12190) - RISCV_INS_SC_W_RL - sc.w.rl $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_SD (12191) - RISCV_INS_SD - sd $rs2, ${imm12}(${rs1}) */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM | CS_OP_MEM, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm12 */ + { 0 } +}}, +{ /* RISCV_SEXT_B (12192) - RISCV_INS_SEXT_B - sext.b $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_SEXT_H (12193) - RISCV_INS_SEXT_H - sext.h $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_SFENCE_INVAL_IR (12194) - RISCV_INS_SFENCE_INVAL_IR - sfence.inval.ir */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_SFENCE_VMA (12195) - RISCV_INS_SFENCE_VMA - sfence.vma $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_SFENCE_W_INVAL (12196) - RISCV_INS_SFENCE_W_INVAL - sfence.w.inval */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_SH (12197) - RISCV_INS_SH - sh $rs2, ${imm12}(${rs1}) */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM | CS_OP_MEM, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm12 */ + { 0 } +}}, +{ /* RISCV_SH1ADD (12198) - RISCV_INS_SH1ADD - sh1add $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_SH1ADD_UW (12199) - RISCV_INS_SH1ADD_UW - sh1add.uw $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_SH2ADD (12200) - RISCV_INS_SH2ADD - sh2add $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_SH2ADD_UW (12201) - RISCV_INS_SH2ADD_UW - sh2add.uw $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_SH3ADD (12202) - RISCV_INS_SH3ADD - sh3add $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_SH3ADD_UW (12203) - RISCV_INS_SH3ADD_UW - sh3add.uw $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_SHA256SIG0 (12204) - RISCV_INS_SHA256SIG0 - sha256sig0 $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_SHA256SIG1 (12205) - RISCV_INS_SHA256SIG1 - sha256sig1 $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_SHA256SUM0 (12206) - RISCV_INS_SHA256SUM0 - sha256sum0 $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_SHA256SUM1 (12207) - RISCV_INS_SHA256SUM1 - sha256sum1 $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_SHA512SIG0 (12208) - RISCV_INS_SHA512SIG0 - sha512sig0 $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_SHA512SIG0H (12209) - RISCV_INS_SHA512SIG0H - sha512sig0h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_SHA512SIG0L (12210) - RISCV_INS_SHA512SIG0L - sha512sig0l $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_SHA512SIG1 (12211) - RISCV_INS_SHA512SIG1 - sha512sig1 $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_SHA512SIG1H (12212) - RISCV_INS_SHA512SIG1H - sha512sig1h $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_SHA512SIG1L (12213) - RISCV_INS_SHA512SIG1L - sha512sig1l $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_SHA512SUM0 (12214) - RISCV_INS_SHA512SUM0 - sha512sum0 $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_SHA512SUM0R (12215) - RISCV_INS_SHA512SUM0R - sha512sum0r $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_SHA512SUM1 (12216) - RISCV_INS_SHA512SUM1 - sha512sum1 $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_SHA512SUM1R (12217) - RISCV_INS_SHA512SUM1R - sha512sum1r $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_SINVAL_VMA (12218) - RISCV_INS_SINVAL_VMA - sinval.vma $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_SLL (12219) - RISCV_INS_SLL - sll $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_SLLI (12220) - RISCV_INS_SLLI - slli $rd, $rs1, $shamt */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* shamt */ + { 0 } +}}, +{ /* RISCV_SLLIW (12221) - RISCV_INS_SLLIW - slliw $rd, $rs1, $shamt */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* shamt */ + { 0 } +}}, +{ /* RISCV_SLLI_UW (12222) - RISCV_INS_SLLI_UW - slli.uw $rd, $rs1, $shamt */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* shamt */ + { 0 } +}}, +{ /* RISCV_SLLW (12223) - RISCV_INS_SLLW - sllw $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_SLT (12224) - RISCV_INS_SLT - slt $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_SLTI (12225) - RISCV_INS_SLTI - slti $rd, $rs1, $imm12 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm12 */ + { 0 } +}}, +{ /* RISCV_SLTIU (12226) - RISCV_INS_SLTIU - sltiu $rd, $rs1, $imm12 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm12 */ + { 0 } +}}, +{ /* RISCV_SLTU (12227) - RISCV_INS_SLTU - sltu $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_SM3P0 (12228) - RISCV_INS_SM3P0 - sm3p0 $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_SM3P1 (12229) - RISCV_INS_SM3P1 - sm3p1 $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_SM4ED (12230) - RISCV_INS_SM4ED - sm4ed $rd, $rs1, $rs2, $bs */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* bs */ + { 0 } +}}, +{ /* RISCV_SM4KS (12231) - RISCV_INS_SM4KS - sm4ks $rd, $rs1, $rs2, $bs */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* bs */ + { 0 } +}}, +{ /* RISCV_SRA (12232) - RISCV_INS_SRA - sra $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_SRAI (12233) - RISCV_INS_SRAI - srai $rd, $rs1, $shamt */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* shamt */ + { 0 } +}}, +{ /* RISCV_SRAIW (12234) - RISCV_INS_SRAIW - sraiw $rd, $rs1, $shamt */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* shamt */ + { 0 } +}}, +{ /* RISCV_SRAW (12235) - RISCV_INS_SRAW - sraw $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_SRET (12236) - RISCV_INS_SRET - sret */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_SRL (12237) - RISCV_INS_SRL - srl $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_SRLI (12238) - RISCV_INS_SRLI - srli $rd, $rs1, $shamt */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* shamt */ + { 0 } +}}, +{ /* RISCV_SRLIW (12239) - RISCV_INS_SRLIW - srliw $rd, $rs1, $shamt */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* shamt */ + { 0 } +}}, +{ /* RISCV_SRLW (12240) - RISCV_INS_SRLW - srlw $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_SSAMOSWAP_D (12241) - RISCV_INS_SSAMOSWAP_D - ssamoswap.d $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_SSAMOSWAP_D_AQ (12242) - RISCV_INS_SSAMOSWAP_D_AQ - ssamoswap.d.aq $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_SSAMOSWAP_D_AQ_RL (12243) - RISCV_INS_SSAMOSWAP_D_AQRL - ssamoswap.d.aqrl $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_SSAMOSWAP_D_RL (12244) - RISCV_INS_SSAMOSWAP_D_RL - ssamoswap.d.rl $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_SSAMOSWAP_W (12245) - RISCV_INS_SSAMOSWAP_W - ssamoswap.w $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_SSAMOSWAP_W_AQ (12246) - RISCV_INS_SSAMOSWAP_W_AQ - ssamoswap.w.aq $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_SSAMOSWAP_W_AQ_RL (12247) - RISCV_INS_SSAMOSWAP_W_AQRL - ssamoswap.w.aqrl $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_SSAMOSWAP_W_RL (12248) - RISCV_INS_SSAMOSWAP_W_RL - ssamoswap.w.rl $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_SSPOPCHK (12249) - RISCV_INS_SSPOPCHK - sspopchk $rs1 */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_SSPUSH (12250) - RISCV_INS_SSPUSH - sspush $rs2 */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_SSRDP (12251) - RISCV_INS_SSRDP - ssrdp $rd */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { 0 } +}}, +{ /* RISCV_SUB (12252) - RISCV_INS_SUB - sub $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_SUBW (12253) - RISCV_INS_SUBW - subw $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_SW (12254) - RISCV_INS_SW - sw $rs2, ${imm12}(${rs1}) */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM | CS_OP_MEM, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm12 */ + { 0 } +}}, +{ /* RISCV_THVdotVMAQASU_VV (12255) - RISCV_INS_TH_VMAQASU_VV - th.vmaqasu.vv $vd, $vs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_THVdotVMAQASU_VX (12256) - RISCV_INS_TH_VMAQASU_VX - th.vmaqasu.vx $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_THVdotVMAQAUS_VX (12257) - RISCV_INS_TH_VMAQAUS_VX - th.vmaqaus.vx $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_THVdotVMAQAU_VV (12258) - RISCV_INS_TH_VMAQAU_VV - th.vmaqau.vv $vd, $vs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_THVdotVMAQAU_VX (12259) - RISCV_INS_TH_VMAQAU_VX - th.vmaqau.vx $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_THVdotVMAQA_VV (12260) - RISCV_INS_TH_VMAQA_VV - th.vmaqa.vv $vd, $vs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_THVdotVMAQA_VX (12261) - RISCV_INS_TH_VMAQA_VX - th.vmaqa.vx $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_TH_ADDSL (12262) - RISCV_INS_TH_ADDSL - th.addsl $rd, $rs1, $rs2, $uimm2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* uimm2 */ + { 0 } +}}, +{ /* RISCV_TH_DCACHE_CALL (12263) - RISCV_INS_TH_DCACHE_CALL - th.dcache.call */ +{ + { 0 } +}}, +{ /* RISCV_TH_DCACHE_CIALL (12264) - RISCV_INS_TH_DCACHE_CIALL - th.dcache.ciall */ +{ + { 0 } +}}, +{ /* RISCV_TH_DCACHE_CIPA (12265) - RISCV_INS_TH_DCACHE_CIPA - th.dcache.cipa $rs1 */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_TH_DCACHE_CISW (12266) - RISCV_INS_TH_DCACHE_CISW - th.dcache.cisw $rs1 */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_TH_DCACHE_CIVA (12267) - RISCV_INS_TH_DCACHE_CIVA - th.dcache.civa $rs1 */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_TH_DCACHE_CPA (12268) - RISCV_INS_TH_DCACHE_CPA - th.dcache.cpa $rs1 */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_TH_DCACHE_CPAL1 (12269) - RISCV_INS_TH_DCACHE_CPAL1 - th.dcache.cpal1 $rs1 */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_TH_DCACHE_CSW (12270) - RISCV_INS_TH_DCACHE_CSW - th.dcache.csw $rs1 */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_TH_DCACHE_CVA (12271) - RISCV_INS_TH_DCACHE_CVA - th.dcache.cva $rs1 */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_TH_DCACHE_CVAL1 (12272) - RISCV_INS_TH_DCACHE_CVAL1 - th.dcache.cval1 $rs1 */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_TH_DCACHE_IALL (12273) - RISCV_INS_TH_DCACHE_IALL - th.dcache.iall */ +{ + { 0 } +}}, +{ /* RISCV_TH_DCACHE_IPA (12274) - RISCV_INS_TH_DCACHE_IPA - th.dcache.ipa $rs1 */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_TH_DCACHE_ISW (12275) - RISCV_INS_TH_DCACHE_ISW - th.dcache.isw $rs1 */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_TH_DCACHE_IVA (12276) - RISCV_INS_TH_DCACHE_IVA - th.dcache.iva $rs1 */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_TH_EXT (12277) - RISCV_INS_TH_EXT - th.ext $rd, $rs1, $msb, $lsb */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* msb */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* lsb */ + { 0 } +}}, +{ /* RISCV_TH_EXTU (12278) - RISCV_INS_TH_EXTU - th.extu $rd, $rs1, $msb, $lsb */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* msb */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* lsb */ + { 0 } +}}, +{ /* RISCV_TH_FF0 (12279) - RISCV_INS_TH_FF0 - th.ff0 $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_TH_FF1 (12280) - RISCV_INS_TH_FF1 - th.ff1 $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_TH_FLRD (12281) - RISCV_INS_TH_FLRD - th.flrd $rd, $rs1, $rs2, $uimm2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* uimm2 */ + { 0 } +}}, +{ /* RISCV_TH_FLRW (12282) - RISCV_INS_TH_FLRW - th.flrw $rd, $rs1, $rs2, $uimm2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* uimm2 */ + { 0 } +}}, +{ /* RISCV_TH_FLURD (12283) - RISCV_INS_TH_FLURD - th.flurd $rd, $rs1, $rs2, $uimm2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* uimm2 */ + { 0 } +}}, +{ /* RISCV_TH_FLURW (12284) - RISCV_INS_TH_FLURW - th.flurw $rd, $rs1, $rs2, $uimm2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* uimm2 */ + { 0 } +}}, +{ /* RISCV_TH_FSRD (12285) - RISCV_INS_TH_FSRD - th.fsrd $rd, $rs1, $rs2, $uimm2 */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG | CS_OP_MEM, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG | CS_OP_MEM, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM | CS_OP_MEM, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* uimm2 */ + { 0 } +}}, +{ /* RISCV_TH_FSRW (12286) - RISCV_INS_TH_FSRW - th.fsrw $rd, $rs1, $rs2, $uimm2 */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG | CS_OP_MEM, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG | CS_OP_MEM, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM | CS_OP_MEM, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* uimm2 */ + { 0 } +}}, +{ /* RISCV_TH_FSURD (12287) - RISCV_INS_TH_FSURD - th.fsurd $rd, $rs1, $rs2, $uimm2 */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* uimm2 */ + { 0 } +}}, +{ /* RISCV_TH_FSURW (12288) - RISCV_INS_TH_FSURW - th.fsurw $rd, $rs1, $rs2, $uimm2 */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* uimm2 */ + { 0 } +}}, +{ /* RISCV_TH_ICACHE_IALL (12289) - RISCV_INS_TH_ICACHE_IALL - th.icache.iall */ +{ + { 0 } +}}, +{ /* RISCV_TH_ICACHE_IALLS (12290) - RISCV_INS_TH_ICACHE_IALLS - th.icache.ialls */ +{ + { 0 } +}}, +{ /* RISCV_TH_ICACHE_IPA (12291) - RISCV_INS_TH_ICACHE_IPA - th.icache.ipa $rs1 */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_TH_ICACHE_IVA (12292) - RISCV_INS_TH_ICACHE_IVA - th.icache.iva $rs1 */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_TH_L2CACHE_CALL (12293) - RISCV_INS_TH_L2CACHE_CALL - th.l2cache.call */ +{ + { 0 } +}}, +{ /* RISCV_TH_L2CACHE_CIALL (12294) - RISCV_INS_TH_L2CACHE_CIALL - th.l2cache.ciall */ +{ + { 0 } +}}, +{ /* RISCV_TH_L2CACHE_IALL (12295) - RISCV_INS_TH_L2CACHE_IALL - th.l2cache.iall */ +{ + { 0 } +}}, +{ /* RISCV_TH_LBIA (12296) - RISCV_INS_TH_LBIA - th.lbia $rd, (${rs1}), $simm5, $uimm2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1_wb */ + { CS_OP_REG | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* simm5 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* uimm2 */ + { 0 } +}}, +{ /* RISCV_TH_LBIB (12297) - RISCV_INS_TH_LBIB - th.lbib $rd, (${rs1}), $simm5, $uimm2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1_wb */ + { CS_OP_REG | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* simm5 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* uimm2 */ + { 0 } +}}, +{ /* RISCV_TH_LBUIA (12298) - RISCV_INS_TH_LBUIA - th.lbuia $rd, (${rs1}), $simm5, $uimm2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1_wb */ + { CS_OP_REG | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* simm5 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* uimm2 */ + { 0 } +}}, +{ /* RISCV_TH_LBUIB (12299) - RISCV_INS_TH_LBUIB - th.lbuib $rd, (${rs1}), $simm5, $uimm2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1_wb */ + { CS_OP_REG | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* simm5 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* uimm2 */ + { 0 } +}}, +{ /* RISCV_TH_LDD (12300) - RISCV_INS_TH_LDD - th.ldd $rd, $rs2, (${rs1}), $uimm2, $const3or4 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* uimm2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* const3or4 */ + { 0 } +}}, +{ /* RISCV_TH_LDIA (12301) - RISCV_INS_TH_LDIA - th.ldia $rd, (${rs1}), $simm5, $uimm2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1_wb */ + { CS_OP_REG | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* simm5 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* uimm2 */ + { 0 } +}}, +{ /* RISCV_TH_LDIB (12302) - RISCV_INS_TH_LDIB - th.ldib $rd, (${rs1}), $simm5, $uimm2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1_wb */ + { CS_OP_REG | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* simm5 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* uimm2 */ + { 0 } +}}, +{ /* RISCV_TH_LHIA (12303) - RISCV_INS_TH_LHIA - th.lhia $rd, (${rs1}), $simm5, $uimm2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1_wb */ + { CS_OP_REG | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* simm5 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* uimm2 */ + { 0 } +}}, +{ /* RISCV_TH_LHIB (12304) - RISCV_INS_TH_LHIB - th.lhib $rd, (${rs1}), $simm5, $uimm2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1_wb */ + { CS_OP_REG | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* simm5 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* uimm2 */ + { 0 } +}}, +{ /* RISCV_TH_LHUIA (12305) - RISCV_INS_TH_LHUIA - th.lhuia $rd, (${rs1}), $simm5, $uimm2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1_wb */ + { CS_OP_REG | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* simm5 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* uimm2 */ + { 0 } +}}, +{ /* RISCV_TH_LHUIB (12306) - RISCV_INS_TH_LHUIB - th.lhuib $rd, (${rs1}), $simm5, $uimm2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1_wb */ + { CS_OP_REG | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* simm5 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* uimm2 */ + { 0 } +}}, +{ /* RISCV_TH_LRB (12307) - RISCV_INS_TH_LRB - th.lrb $rd, $rs1, $rs2, $uimm2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* uimm2 */ + { 0 } +}}, +{ /* RISCV_TH_LRBU (12308) - RISCV_INS_TH_LRBU - th.lrbu $rd, $rs1, $rs2, $uimm2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* uimm2 */ + { 0 } +}}, +{ /* RISCV_TH_LRD (12309) - RISCV_INS_TH_LRD - th.lrd $rd, $rs1, $rs2, $uimm2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* uimm2 */ + { 0 } +}}, +{ /* RISCV_TH_LRH (12310) - RISCV_INS_TH_LRH - th.lrh $rd, $rs1, $rs2, $uimm2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* uimm2 */ + { 0 } +}}, +{ /* RISCV_TH_LRHU (12311) - RISCV_INS_TH_LRHU - th.lrhu $rd, $rs1, $rs2, $uimm2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* uimm2 */ + { 0 } +}}, +{ /* RISCV_TH_LRW (12312) - RISCV_INS_TH_LRW - th.lrw $rd, $rs1, $rs2, $uimm2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* uimm2 */ + { 0 } +}}, +{ /* RISCV_TH_LRWU (12313) - RISCV_INS_TH_LRWU - th.lrwu $rd, $rs1, $rs2, $uimm2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* uimm2 */ + { 0 } +}}, +{ /* RISCV_TH_LURB (12314) - RISCV_INS_TH_LURB - th.lurb $rd, $rs1, $rs2, $uimm2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* uimm2 */ + { 0 } +}}, +{ /* RISCV_TH_LURBU (12315) - RISCV_INS_TH_LURBU - th.lurbu $rd, $rs1, $rs2, $uimm2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* uimm2 */ + { 0 } +}}, +{ /* RISCV_TH_LURD (12316) - RISCV_INS_TH_LURD - th.lurd $rd, $rs1, $rs2, $uimm2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* uimm2 */ + { 0 } +}}, +{ /* RISCV_TH_LURH (12317) - RISCV_INS_TH_LURH - th.lurh $rd, $rs1, $rs2, $uimm2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* uimm2 */ + { 0 } +}}, +{ /* RISCV_TH_LURHU (12318) - RISCV_INS_TH_LURHU - th.lurhu $rd, $rs1, $rs2, $uimm2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* uimm2 */ + { 0 } +}}, +{ /* RISCV_TH_LURW (12319) - RISCV_INS_TH_LURW - th.lurw $rd, $rs1, $rs2, $uimm2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* uimm2 */ + { 0 } +}}, +{ /* RISCV_TH_LURWU (12320) - RISCV_INS_TH_LURWU - th.lurwu $rd, $rs1, $rs2, $uimm2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* uimm2 */ + { 0 } +}}, +{ /* RISCV_TH_LWD (12321) - RISCV_INS_TH_LWD - th.lwd $rd, $rs2, (${rs1}), $uimm2, $const3or4 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* uimm2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* const3or4 */ + { 0 } +}}, +{ /* RISCV_TH_LWIA (12322) - RISCV_INS_TH_LWIA - th.lwia $rd, (${rs1}), $simm5, $uimm2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1_wb */ + { CS_OP_REG | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* simm5 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* uimm2 */ + { 0 } +}}, +{ /* RISCV_TH_LWIB (12323) - RISCV_INS_TH_LWIB - th.lwib $rd, (${rs1}), $simm5, $uimm2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1_wb */ + { CS_OP_REG | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* simm5 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* uimm2 */ + { 0 } +}}, +{ /* RISCV_TH_LWUD (12324) - RISCV_INS_TH_LWUD - th.lwud $rd, $rs2, (${rs1}), $uimm2, $const3or4 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* uimm2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* const3or4 */ + { 0 } +}}, +{ /* RISCV_TH_LWUIA (12325) - RISCV_INS_TH_LWUIA - th.lwuia $rd, (${rs1}), $simm5, $uimm2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1_wb */ + { CS_OP_REG | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* simm5 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* uimm2 */ + { 0 } +}}, +{ /* RISCV_TH_LWUIB (12326) - RISCV_INS_TH_LWUIB - th.lwuib $rd, (${rs1}), $simm5, $uimm2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1_wb */ + { CS_OP_REG | CS_OP_MEM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* simm5 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* uimm2 */ + { 0 } +}}, +{ /* RISCV_TH_MULA (12327) - RISCV_INS_TH_MULA - th.mula $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_TH_MULAH (12328) - RISCV_INS_TH_MULAH - th.mulah $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_TH_MULAW (12329) - RISCV_INS_TH_MULAW - th.mulaw $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_TH_MULS (12330) - RISCV_INS_TH_MULS - th.muls $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_TH_MULSH (12331) - RISCV_INS_TH_MULSH - th.mulsh $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_TH_MULSW (12332) - RISCV_INS_TH_MULSW - th.mulsw $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_TH_MVEQZ (12333) - RISCV_INS_TH_MVEQZ - th.mveqz $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_TH_MVNEZ (12334) - RISCV_INS_TH_MVNEZ - th.mvnez $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_TH_REV (12335) - RISCV_INS_TH_REV - th.rev $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_TH_REVW (12336) - RISCV_INS_TH_REVW - th.revw $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_TH_SBIA (12337) - RISCV_INS_TH_SBIA - th.sbia $rd, (${rs1}), $simm5, $uimm2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1_up */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG | CS_OP_MEM, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* simm5 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* uimm2 */ + { 0 } +}}, +{ /* RISCV_TH_SBIB (12338) - RISCV_INS_TH_SBIB - th.sbib $rd, (${rs1}), $simm5, $uimm2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1_up */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG | CS_OP_MEM, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* simm5 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* uimm2 */ + { 0 } +}}, +{ /* RISCV_TH_SDD (12339) - RISCV_INS_TH_SDD - th.sdd $rd, $rs2, (${rs1}), $uimm2, $const3or4 */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG | CS_OP_MEM, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* uimm2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* const3or4 */ + { 0 } +}}, +{ /* RISCV_TH_SDIA (12340) - RISCV_INS_TH_SDIA - th.sdia $rd, (${rs1}), $simm5, $uimm2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1_up */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG | CS_OP_MEM, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* simm5 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* uimm2 */ + { 0 } +}}, +{ /* RISCV_TH_SDIB (12341) - RISCV_INS_TH_SDIB - th.sdib $rd, (${rs1}), $simm5, $uimm2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1_up */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG | CS_OP_MEM, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* simm5 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* uimm2 */ + { 0 } +}}, +{ /* RISCV_TH_SFENCE_VMAS (12342) - RISCV_INS_TH_SFENCE_VMAS - th.sfence.vmas $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_TH_SHIA (12343) - RISCV_INS_TH_SHIA - th.shia $rd, (${rs1}), $simm5, $uimm2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1_up */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG | CS_OP_MEM, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* simm5 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* uimm2 */ + { 0 } +}}, +{ /* RISCV_TH_SHIB (12344) - RISCV_INS_TH_SHIB - th.shib $rd, (${rs1}), $simm5, $uimm2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1_up */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG | CS_OP_MEM, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* simm5 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* uimm2 */ + { 0 } +}}, +{ /* RISCV_TH_SRB (12345) - RISCV_INS_TH_SRB - th.srb $rd, $rs1, $rs2, $uimm2 */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG | CS_OP_MEM, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG | CS_OP_MEM, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM | CS_OP_MEM, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* uimm2 */ + { 0 } +}}, +{ /* RISCV_TH_SRD (12346) - RISCV_INS_TH_SRD - th.srd $rd, $rs1, $rs2, $uimm2 */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG | CS_OP_MEM, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG | CS_OP_MEM, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM | CS_OP_MEM, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* uimm2 */ + { 0 } +}}, +{ /* RISCV_TH_SRH (12347) - RISCV_INS_TH_SRH - th.srh $rd, $rs1, $rs2, $uimm2 */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG | CS_OP_MEM, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG | CS_OP_MEM, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM | CS_OP_MEM, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* uimm2 */ + { 0 } +}}, +{ /* RISCV_TH_SRRI (12348) - RISCV_INS_TH_SRRI - th.srri $rd, $rs1, $shamt */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* shamt */ + { 0 } +}}, +{ /* RISCV_TH_SRRIW (12349) - RISCV_INS_TH_SRRIW - th.srriw $rd, $rs1, $shamt */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* shamt */ + { 0 } +}}, +{ /* RISCV_TH_SRW (12350) - RISCV_INS_TH_SRW - th.srw $rd, $rs1, $rs2, $uimm2 */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG | CS_OP_MEM, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG | CS_OP_MEM, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM | CS_OP_MEM, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* uimm2 */ + { 0 } +}}, +{ /* RISCV_TH_SURB (12351) - RISCV_INS_TH_SURB - th.surb $rd, $rs1, $rs2, $uimm2 */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* uimm2 */ + { 0 } +}}, +{ /* RISCV_TH_SURD (12352) - RISCV_INS_TH_SURD - th.surd $rd, $rs1, $rs2, $uimm2 */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* uimm2 */ + { 0 } +}}, +{ /* RISCV_TH_SURH (12353) - RISCV_INS_TH_SURH - th.surh $rd, $rs1, $rs2, $uimm2 */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* uimm2 */ + { 0 } +}}, +{ /* RISCV_TH_SURW (12354) - RISCV_INS_TH_SURW - th.surw $rd, $rs1, $rs2, $uimm2 */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* uimm2 */ + { 0 } +}}, +{ /* RISCV_TH_SWD (12355) - RISCV_INS_TH_SWD - th.swd $rd, $rs2, (${rs1}), $uimm2, $const3or4 */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG | CS_OP_MEM, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* uimm2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* const3or4 */ + { 0 } +}}, +{ /* RISCV_TH_SWIA (12356) - RISCV_INS_TH_SWIA - th.swia $rd, (${rs1}), $simm5, $uimm2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1_up */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG | CS_OP_MEM, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* simm5 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* uimm2 */ + { 0 } +}}, +{ /* RISCV_TH_SWIB (12357) - RISCV_INS_TH_SWIB - th.swib $rd, (${rs1}), $simm5, $uimm2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1_up */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG | CS_OP_MEM, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* simm5 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* uimm2 */ + { 0 } +}}, +{ /* RISCV_TH_SYNC (12358) - RISCV_INS_TH_SYNC - th.sync */ +{ + { 0 } +}}, +{ /* RISCV_TH_SYNC_I (12359) - RISCV_INS_TH_SYNC_I - th.sync.i */ +{ + { 0 } +}}, +{ /* RISCV_TH_SYNC_IS (12360) - RISCV_INS_TH_SYNC_IS - th.sync.is */ +{ + { 0 } +}}, +{ /* RISCV_TH_SYNC_S (12361) - RISCV_INS_TH_SYNC_S - th.sync.s */ +{ + { 0 } +}}, +{ /* RISCV_TH_TST (12362) - RISCV_INS_TH_TST - th.tst $rd, $rs1, $shamt */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* shamt */ + { 0 } +}}, +{ /* RISCV_TH_TSTNBZ (12363) - RISCV_INS_TH_TSTNBZ - th.tstnbz $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_UNIMP (12364) - RISCV_INS_UNIMP - unimp */ +{ + { 0 } +}}, +{ /* RISCV_UNZIP_RV32 (12365) - RISCV_INS_UNZIP - unzip $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_VAADDU_VV (12366) - RISCV_INS_VAADDU_VV - vaaddu.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VAADDU_VX (12367) - RISCV_INS_VAADDU_VX - vaaddu.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VAADD_VV (12368) - RISCV_INS_VAADD_VV - vaadd.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VAADD_VX (12369) - RISCV_INS_VAADD_VX - vaadd.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VADC_VIM (12370) - RISCV_INS_VADC_VIM - vadc.vim $vd, $vs2, $imm, v0 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* v0 */ + { 0 } +}}, +{ /* RISCV_VADC_VVM (12371) - RISCV_INS_VADC_VVM - vadc.vvm $vd, $vs2, $vs1, v0 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* v0 */ + { 0 } +}}, +{ /* RISCV_VADC_VXM (12372) - RISCV_INS_VADC_VXM - vadc.vxm $vd, $vs2, $rs1, v0 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* v0 */ + { 0 } +}}, +{ /* RISCV_VADD_VI (12373) - RISCV_INS_VADD_VI - vadd.vi $vd, $vs2, $imm$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VADD_VV (12374) - RISCV_INS_VADD_VV - vadd.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VADD_VX (12375) - RISCV_INS_VADD_VX - vadd.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VAESDF_VS (12376) - RISCV_INS_VAESDF_VS - vaesdf.vs $vd, $vs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { 0 } +}}, +{ /* RISCV_VAESDF_VV (12377) - RISCV_INS_VAESDF_VV - vaesdf.vv $vd, $vs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { 0 } +}}, +{ /* RISCV_VAESDM_VS (12378) - RISCV_INS_VAESDM_VS - vaesdm.vs $vd, $vs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { 0 } +}}, +{ /* RISCV_VAESDM_VV (12379) - RISCV_INS_VAESDM_VV - vaesdm.vv $vd, $vs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { 0 } +}}, +{ /* RISCV_VAESEF_VS (12380) - RISCV_INS_VAESEF_VS - vaesef.vs $vd, $vs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { 0 } +}}, +{ /* RISCV_VAESEF_VV (12381) - RISCV_INS_VAESEF_VV - vaesef.vv $vd, $vs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { 0 } +}}, +{ /* RISCV_VAESEM_VS (12382) - RISCV_INS_VAESEM_VS - vaesem.vs $vd, $vs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { 0 } +}}, +{ /* RISCV_VAESEM_VV (12383) - RISCV_INS_VAESEM_VV - vaesem.vv $vd, $vs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { 0 } +}}, +{ /* RISCV_VAESKF1_VI (12384) - RISCV_INS_VAESKF1_VI - vaeskf1.vi $vd, $vs2, $imm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { 0 } +}}, +{ /* RISCV_VAESKF2_VI (12385) - RISCV_INS_VAESKF2_VI - vaeskf2.vi $vd, $vs2, $imm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { 0 } +}}, +{ /* RISCV_VAESZ_VS (12386) - RISCV_INS_VAESZ_VS - vaesz.vs $vd, $vs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { 0 } +}}, +{ /* RISCV_VANDN_VV (12387) - RISCV_INS_VANDN_VV - vandn.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VANDN_VX (12388) - RISCV_INS_VANDN_VX - vandn.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VAND_VI (12389) - RISCV_INS_VAND_VI - vand.vi $vd, $vs2, $imm$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VAND_VV (12390) - RISCV_INS_VAND_VV - vand.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VAND_VX (12391) - RISCV_INS_VAND_VX - vand.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VASUBU_VV (12392) - RISCV_INS_VASUBU_VV - vasubu.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VASUBU_VX (12393) - RISCV_INS_VASUBU_VX - vasubu.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VASUB_VV (12394) - RISCV_INS_VASUB_VV - vasub.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VASUB_VX (12395) - RISCV_INS_VASUB_VX - vasub.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VBREV8_V (12396) - RISCV_INS_VBREV8_V - vbrev8.v $vd, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VBREV_V (12397) - RISCV_INS_VBREV_V - vbrev.v $vd, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VCLMULH_VV (12398) - RISCV_INS_VCLMULH_VV - vclmulh.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VCLMULH_VX (12399) - RISCV_INS_VCLMULH_VX - vclmulh.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VCLMUL_VV (12400) - RISCV_INS_VCLMUL_VV - vclmul.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VCLMUL_VX (12401) - RISCV_INS_VCLMUL_VX - vclmul.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VCLZ_V (12402) - RISCV_INS_VCLZ_V - vclz.v $vd, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VCOMPRESS_VM (12403) - RISCV_INS_VCOMPRESS_VM - vcompress.vm $vd, $vs2, $vs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { 0 } +}}, +{ /* RISCV_VCPOP_M (12404) - RISCV_INS_VCPOP_M - vcpop.m $vd, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VCPOP_V (12405) - RISCV_INS_VCPOP_V - vcpop.v $vd, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VCTZ_V (12406) - RISCV_INS_VCTZ_V - vctz.v $vd, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VC_FV (12407) - RISCV_INS_SF_VC_FV - sf.vc.fv $funct6_lo1, $rd, $rs2, $rs1 */ +{ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* funct6_lo1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_VC_FVV (12408) - RISCV_INS_SF_VC_FVV - sf.vc.fvv $funct6_lo1, $rd, $rs2, $rs1 */ +{ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* funct6_lo1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_VC_FVW (12409) - RISCV_INS_SF_VC_FVW - sf.vc.fvw $funct6_lo1, $rd, $rs2, $rs1 */ +{ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* funct6_lo1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_VC_I (12410) - RISCV_INS_SF_VC_I - sf.vc.i $funct6_lo2, $rs2, $rd, $rs1 */ +{ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* funct6_lo2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_VC_IV (12411) - RISCV_INS_SF_VC_IV - sf.vc.iv $funct6_lo2, $rd, $rs2, $rs1 */ +{ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* funct6_lo2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_VC_IVV (12412) - RISCV_INS_SF_VC_IVV - sf.vc.ivv $funct6_lo2, $rd, $rs2, $rs1 */ +{ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* funct6_lo2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_VC_IVW (12413) - RISCV_INS_SF_VC_IVW - sf.vc.ivw $funct6_lo2, $rd, $rs2, $rs1 */ +{ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* funct6_lo2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_VC_VV (12414) - RISCV_INS_SF_VC_VV - sf.vc.vv $funct6_lo2, $rd, $rs2, $rs1 */ +{ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* funct6_lo2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_VC_VVV (12415) - RISCV_INS_SF_VC_VVV - sf.vc.vvv $funct6_lo2, $rd, $rs2, $rs1 */ +{ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* funct6_lo2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_VC_VVW (12416) - RISCV_INS_SF_VC_VVW - sf.vc.vvw $funct6_lo2, $rd, $rs2, $rs1 */ +{ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* funct6_lo2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_VC_V_FV (12417) - RISCV_INS_SF_VC_V_FV - sf.vc.v.fv $funct6_lo1, $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* funct6_lo1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_VC_V_FVV (12418) - RISCV_INS_SF_VC_V_FVV - sf.vc.v.fvv $funct6_lo1, $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* funct6_lo1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_VC_V_FVW (12419) - RISCV_INS_SF_VC_V_FVW - sf.vc.v.fvw $funct6_lo1, $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* funct6_lo1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_VC_V_I (12420) - RISCV_INS_SF_VC_V_I - sf.vc.v.i $funct6_lo2, $rs2, $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* funct6_lo2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_VC_V_IV (12421) - RISCV_INS_SF_VC_V_IV - sf.vc.v.iv $funct6_lo2, $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* funct6_lo2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_VC_V_IVV (12422) - RISCV_INS_SF_VC_V_IVV - sf.vc.v.ivv $funct6_lo2, $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* funct6_lo2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_VC_V_IVW (12423) - RISCV_INS_SF_VC_V_IVW - sf.vc.v.ivw $funct6_lo2, $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* funct6_lo2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_VC_V_VV (12424) - RISCV_INS_SF_VC_V_VV - sf.vc.v.vv $funct6_lo2, $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* funct6_lo2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_VC_V_VVV (12425) - RISCV_INS_SF_VC_V_VVV - sf.vc.v.vvv $funct6_lo2, $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* funct6_lo2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_VC_V_VVW (12426) - RISCV_INS_SF_VC_V_VVW - sf.vc.v.vvw $funct6_lo2, $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* funct6_lo2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_VC_V_X (12427) - RISCV_INS_SF_VC_V_X - sf.vc.v.x $funct6_lo2, $rs2, $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* funct6_lo2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_VC_V_XV (12428) - RISCV_INS_SF_VC_V_XV - sf.vc.v.xv $funct6_lo2, $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* funct6_lo2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_VC_V_XVV (12429) - RISCV_INS_SF_VC_V_XVV - sf.vc.v.xvv $funct6_lo2, $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* funct6_lo2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_VC_V_XVW (12430) - RISCV_INS_SF_VC_V_XVW - sf.vc.v.xvw $funct6_lo2, $rd, $rs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rd_wb */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* funct6_lo2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_VC_X (12431) - RISCV_INS_SF_VC_X - sf.vc.x $funct6_lo2, $rs2, $rd, $rs1 */ +{ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* funct6_lo2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_VC_XV (12432) - RISCV_INS_SF_VC_XV - sf.vc.xv $funct6_lo2, $rd, $rs2, $rs1 */ +{ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* funct6_lo2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_VC_XVV (12433) - RISCV_INS_SF_VC_XVV - sf.vc.xvv $funct6_lo2, $rd, $rs2, $rs1 */ +{ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* funct6_lo2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_VC_XVW (12434) - RISCV_INS_SF_VC_XVW - sf.vc.xvw $funct6_lo2, $rd, $rs2, $rs1 */ +{ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* funct6_lo2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_VDIVU_VV (12435) - RISCV_INS_VDIVU_VV - vdivu.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VDIVU_VX (12436) - RISCV_INS_VDIVU_VX - vdivu.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VDIV_VV (12437) - RISCV_INS_VDIV_VV - vdiv.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VDIV_VX (12438) - RISCV_INS_VDIV_VX - vdiv.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFADD_VF (12439) - RISCV_INS_VFADD_VF - vfadd.vf $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFADD_VV (12440) - RISCV_INS_VFADD_VV - vfadd.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFCLASS_V (12441) - RISCV_INS_VFCLASS_V - vfclass.v $vd, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFCVT_F_XU_V (12442) - RISCV_INS_VFCVT_F_XU_V - vfcvt.f.xu.v $vd, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFCVT_F_X_V (12443) - RISCV_INS_VFCVT_F_X_V - vfcvt.f.x.v $vd, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFCVT_RTZ_XU_F_V (12444) - RISCV_INS_VFCVT_RTZ_XU_F_V - vfcvt.rtz.xu.f.v $vd, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFCVT_RTZ_X_F_V (12445) - RISCV_INS_VFCVT_RTZ_X_F_V - vfcvt.rtz.x.f.v $vd, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFCVT_XU_F_V (12446) - RISCV_INS_VFCVT_XU_F_V - vfcvt.xu.f.v $vd, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFCVT_X_F_V (12447) - RISCV_INS_VFCVT_X_F_V - vfcvt.x.f.v $vd, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFDIV_VF (12448) - RISCV_INS_VFDIV_VF - vfdiv.vf $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFDIV_VV (12449) - RISCV_INS_VFDIV_VV - vfdiv.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFIRST_M (12450) - RISCV_INS_VFIRST_M - vfirst.m $vd, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFMACC_VF (12451) - RISCV_INS_VFMACC_VF - vfmacc.vf $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFMACC_VV (12452) - RISCV_INS_VFMACC_VV - vfmacc.vv $vd, $vs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFMADD_VF (12453) - RISCV_INS_VFMADD_VF - vfmadd.vf $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFMADD_VV (12454) - RISCV_INS_VFMADD_VV - vfmadd.vv $vd, $vs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFMAX_VF (12455) - RISCV_INS_VFMAX_VF - vfmax.vf $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFMAX_VV (12456) - RISCV_INS_VFMAX_VV - vfmax.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFMERGE_VFM (12457) - RISCV_INS_VFMERGE_VFM - vfmerge.vfm $vd, $vs2, $rs1, v0 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* v0 */ + { 0 } +}}, +{ /* RISCV_VFMIN_VF (12458) - RISCV_INS_VFMIN_VF - vfmin.vf $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFMIN_VV (12459) - RISCV_INS_VFMIN_VV - vfmin.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFMSAC_VF (12460) - RISCV_INS_VFMSAC_VF - vfmsac.vf $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFMSAC_VV (12461) - RISCV_INS_VFMSAC_VV - vfmsac.vv $vd, $vs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFMSUB_VF (12462) - RISCV_INS_VFMSUB_VF - vfmsub.vf $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFMSUB_VV (12463) - RISCV_INS_VFMSUB_VV - vfmsub.vv $vd, $vs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFMUL_VF (12464) - RISCV_INS_VFMUL_VF - vfmul.vf $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFMUL_VV (12465) - RISCV_INS_VFMUL_VV - vfmul.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFMV_F_S (12466) - RISCV_INS_VFMV_F_S - vfmv.f.s $vd, $vs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { 0 } +}}, +{ /* RISCV_VFMV_S_F (12467) - RISCV_INS_VFMV_S_F - vfmv.s.f $vd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_VFMV_V_F (12468) - RISCV_INS_VFMV_V_F - vfmv.v.f $vd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_VFNCVTBF16_F_F_W (12469) - RISCV_INS_VFNCVTBF16_F_F_W - vfncvtbf16.f.f.w $vd, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFNCVT_F_F_W (12470) - RISCV_INS_VFNCVT_F_F_W - vfncvt.f.f.w $vd, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFNCVT_F_XU_W (12471) - RISCV_INS_VFNCVT_F_XU_W - vfncvt.f.xu.w $vd, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFNCVT_F_X_W (12472) - RISCV_INS_VFNCVT_F_X_W - vfncvt.f.x.w $vd, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFNCVT_ROD_F_F_W (12473) - RISCV_INS_VFNCVT_ROD_F_F_W - vfncvt.rod.f.f.w $vd, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFNCVT_RTZ_XU_F_W (12474) - RISCV_INS_VFNCVT_RTZ_XU_F_W - vfncvt.rtz.xu.f.w $vd, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFNCVT_RTZ_X_F_W (12475) - RISCV_INS_VFNCVT_RTZ_X_F_W - vfncvt.rtz.x.f.w $vd, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFNCVT_XU_F_W (12476) - RISCV_INS_VFNCVT_XU_F_W - vfncvt.xu.f.w $vd, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFNCVT_X_F_W (12477) - RISCV_INS_VFNCVT_X_F_W - vfncvt.x.f.w $vd, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFNMACC_VF (12478) - RISCV_INS_VFNMACC_VF - vfnmacc.vf $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFNMACC_VV (12479) - RISCV_INS_VFNMACC_VV - vfnmacc.vv $vd, $vs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFNMADD_VF (12480) - RISCV_INS_VFNMADD_VF - vfnmadd.vf $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFNMADD_VV (12481) - RISCV_INS_VFNMADD_VV - vfnmadd.vv $vd, $vs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFNMSAC_VF (12482) - RISCV_INS_VFNMSAC_VF - vfnmsac.vf $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFNMSAC_VV (12483) - RISCV_INS_VFNMSAC_VV - vfnmsac.vv $vd, $vs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFNMSUB_VF (12484) - RISCV_INS_VFNMSUB_VF - vfnmsub.vf $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFNMSUB_VV (12485) - RISCV_INS_VFNMSUB_VV - vfnmsub.vv $vd, $vs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFNRCLIP_XU_F_QF (12486) - RISCV_INS_SF_VFNRCLIP_XU_F_QF - sf.vfnrclip.xu.f.qf $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFNRCLIP_X_F_QF (12487) - RISCV_INS_SF_VFNRCLIP_X_F_QF - sf.vfnrclip.x.f.qf $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFRDIV_VF (12488) - RISCV_INS_VFRDIV_VF - vfrdiv.vf $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFREC7_V (12489) - RISCV_INS_VFREC7_V - vfrec7.v $vd, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFREDMAX_VS (12490) - RISCV_INS_VFREDMAX_VS - vfredmax.vs $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFREDMIN_VS (12491) - RISCV_INS_VFREDMIN_VS - vfredmin.vs $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFREDOSUM_VS (12492) - RISCV_INS_VFREDOSUM_VS - vfredosum.vs $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFREDUSUM_VS (12493) - RISCV_INS_VFREDUSUM_VS - vfredusum.vs $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFRSQRT7_V (12494) - RISCV_INS_VFRSQRT7_V - vfrsqrt7.v $vd, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFRSUB_VF (12495) - RISCV_INS_VFRSUB_VF - vfrsub.vf $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFSGNJN_VF (12496) - RISCV_INS_VFSGNJN_VF - vfsgnjn.vf $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFSGNJN_VV (12497) - RISCV_INS_VFSGNJN_VV - vfsgnjn.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFSGNJX_VF (12498) - RISCV_INS_VFSGNJX_VF - vfsgnjx.vf $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFSGNJX_VV (12499) - RISCV_INS_VFSGNJX_VV - vfsgnjx.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFSGNJ_VF (12500) - RISCV_INS_VFSGNJ_VF - vfsgnj.vf $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFSGNJ_VV (12501) - RISCV_INS_VFSGNJ_VV - vfsgnj.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFSLIDE1DOWN_VF (12502) - RISCV_INS_VFSLIDE1DOWN_VF - vfslide1down.vf $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFSLIDE1UP_VF (12503) - RISCV_INS_VFSLIDE1UP_VF - vfslide1up.vf $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFSQRT_V (12504) - RISCV_INS_VFSQRT_V - vfsqrt.v $vd, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFSUB_VF (12505) - RISCV_INS_VFSUB_VF - vfsub.vf $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFSUB_VV (12506) - RISCV_INS_VFSUB_VV - vfsub.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFWADD_VF (12507) - RISCV_INS_VFWADD_VF - vfwadd.vf $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFWADD_VV (12508) - RISCV_INS_VFWADD_VV - vfwadd.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFWADD_WF (12509) - RISCV_INS_VFWADD_WF - vfwadd.wf $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFWADD_WV (12510) - RISCV_INS_VFWADD_WV - vfwadd.wv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFWCVTBF16_F_F_V (12511) - RISCV_INS_VFWCVTBF16_F_F_V - vfwcvtbf16.f.f.v $vd, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFWCVT_F_F_V (12512) - RISCV_INS_VFWCVT_F_F_V - vfwcvt.f.f.v $vd, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFWCVT_F_XU_V (12513) - RISCV_INS_VFWCVT_F_XU_V - vfwcvt.f.xu.v $vd, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFWCVT_F_X_V (12514) - RISCV_INS_VFWCVT_F_X_V - vfwcvt.f.x.v $vd, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFWCVT_RTZ_XU_F_V (12515) - RISCV_INS_VFWCVT_RTZ_XU_F_V - vfwcvt.rtz.xu.f.v $vd, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFWCVT_RTZ_X_F_V (12516) - RISCV_INS_VFWCVT_RTZ_X_F_V - vfwcvt.rtz.x.f.v $vd, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFWCVT_XU_F_V (12517) - RISCV_INS_VFWCVT_XU_F_V - vfwcvt.xu.f.v $vd, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFWCVT_X_F_V (12518) - RISCV_INS_VFWCVT_X_F_V - vfwcvt.x.f.v $vd, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFWMACCBF16_VF (12519) - RISCV_INS_VFWMACCBF16_VF - vfwmaccbf16.vf $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFWMACCBF16_VV (12520) - RISCV_INS_VFWMACCBF16_VV - vfwmaccbf16.vv $vd, $vs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFWMACC_4x4x4 (12521) - RISCV_INS_SF_VFWMACC_4X4X4 - sf.vfwmacc.4x4x4 $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_VFWMACC_VF (12522) - RISCV_INS_VFWMACC_VF - vfwmacc.vf $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFWMACC_VV (12523) - RISCV_INS_VFWMACC_VV - vfwmacc.vv $vd, $vs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFWMSAC_VF (12524) - RISCV_INS_VFWMSAC_VF - vfwmsac.vf $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFWMSAC_VV (12525) - RISCV_INS_VFWMSAC_VV - vfwmsac.vv $vd, $vs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFWMUL_VF (12526) - RISCV_INS_VFWMUL_VF - vfwmul.vf $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFWMUL_VV (12527) - RISCV_INS_VFWMUL_VV - vfwmul.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFWNMACC_VF (12528) - RISCV_INS_VFWNMACC_VF - vfwnmacc.vf $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFWNMACC_VV (12529) - RISCV_INS_VFWNMACC_VV - vfwnmacc.vv $vd, $vs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFWNMSAC_VF (12530) - RISCV_INS_VFWNMSAC_VF - vfwnmsac.vf $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFWNMSAC_VV (12531) - RISCV_INS_VFWNMSAC_VV - vfwnmsac.vv $vd, $vs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFWREDOSUM_VS (12532) - RISCV_INS_VFWREDOSUM_VS - vfwredosum.vs $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFWREDUSUM_VS (12533) - RISCV_INS_VFWREDUSUM_VS - vfwredusum.vs $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFWSUB_VF (12534) - RISCV_INS_VFWSUB_VF - vfwsub.vf $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFWSUB_VV (12535) - RISCV_INS_VFWSUB_VV - vfwsub.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFWSUB_WF (12536) - RISCV_INS_VFWSUB_WF - vfwsub.wf $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VFWSUB_WV (12537) - RISCV_INS_VFWSUB_WV - vfwsub.wv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VGHSH_VV (12538) - RISCV_INS_VGHSH_VV - vghsh.vv $vd, $vs2, $vs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { 0 } +}}, +{ /* RISCV_VGMUL_VV (12539) - RISCV_INS_VGMUL_VV - vgmul.vv $vd, $vs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { 0 } +}}, +{ /* RISCV_VID_V (12540) - RISCV_INS_VID_V - vid.v $vd$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VIOTA_M (12541) - RISCV_INS_VIOTA_M - viota.m $vd, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VL1RE16_V (12542) - RISCV_INS_VL1RE16_V - vl1re16.v $vd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_VL1RE32_V (12543) - RISCV_INS_VL1RE32_V - vl1re32.v $vd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_VL1RE64_V (12544) - RISCV_INS_VL1RE64_V - vl1re64.v $vd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_VL1RE8_V (12545) - RISCV_INS_VL1RE8_V - vl1re8.v $vd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_VL2RE16_V (12546) - RISCV_INS_VL2RE16_V - vl2re16.v $vd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv16i8, CS_DATA_TYPE_nxv8i16, CS_DATA_TYPE_nxv4i32, CS_DATA_TYPE_nxv2i64, CS_DATA_TYPE_nxv8f16, CS_DATA_TYPE_nxv8bf16, CS_DATA_TYPE_nxv4f32, CS_DATA_TYPE_nxv2f64, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_VL2RE32_V (12547) - RISCV_INS_VL2RE32_V - vl2re32.v $vd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv16i8, CS_DATA_TYPE_nxv8i16, CS_DATA_TYPE_nxv4i32, CS_DATA_TYPE_nxv2i64, CS_DATA_TYPE_nxv8f16, CS_DATA_TYPE_nxv8bf16, CS_DATA_TYPE_nxv4f32, CS_DATA_TYPE_nxv2f64, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_VL2RE64_V (12548) - RISCV_INS_VL2RE64_V - vl2re64.v $vd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv16i8, CS_DATA_TYPE_nxv8i16, CS_DATA_TYPE_nxv4i32, CS_DATA_TYPE_nxv2i64, CS_DATA_TYPE_nxv8f16, CS_DATA_TYPE_nxv8bf16, CS_DATA_TYPE_nxv4f32, CS_DATA_TYPE_nxv2f64, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_VL2RE8_V (12549) - RISCV_INS_VL2RE8_V - vl2re8.v $vd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv16i8, CS_DATA_TYPE_nxv8i16, CS_DATA_TYPE_nxv4i32, CS_DATA_TYPE_nxv2i64, CS_DATA_TYPE_nxv8f16, CS_DATA_TYPE_nxv8bf16, CS_DATA_TYPE_nxv4f32, CS_DATA_TYPE_nxv2f64, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_VL4RE16_V (12550) - RISCV_INS_VL4RE16_V - vl4re16.v $vd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv32i8, CS_DATA_TYPE_nxv16i16, CS_DATA_TYPE_nxv8i32, CS_DATA_TYPE_nxv4i64, CS_DATA_TYPE_nxv16f16, CS_DATA_TYPE_nxv16bf16, CS_DATA_TYPE_nxv8f32, CS_DATA_TYPE_nxv4f64, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_VL4RE32_V (12551) - RISCV_INS_VL4RE32_V - vl4re32.v $vd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv32i8, CS_DATA_TYPE_nxv16i16, CS_DATA_TYPE_nxv8i32, CS_DATA_TYPE_nxv4i64, CS_DATA_TYPE_nxv16f16, CS_DATA_TYPE_nxv16bf16, CS_DATA_TYPE_nxv8f32, CS_DATA_TYPE_nxv4f64, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_VL4RE64_V (12552) - RISCV_INS_VL4RE64_V - vl4re64.v $vd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv32i8, CS_DATA_TYPE_nxv16i16, CS_DATA_TYPE_nxv8i32, CS_DATA_TYPE_nxv4i64, CS_DATA_TYPE_nxv16f16, CS_DATA_TYPE_nxv16bf16, CS_DATA_TYPE_nxv8f32, CS_DATA_TYPE_nxv4f64, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_VL4RE8_V (12553) - RISCV_INS_VL4RE8_V - vl4re8.v $vd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv32i8, CS_DATA_TYPE_nxv16i16, CS_DATA_TYPE_nxv8i32, CS_DATA_TYPE_nxv4i64, CS_DATA_TYPE_nxv16f16, CS_DATA_TYPE_nxv16bf16, CS_DATA_TYPE_nxv8f32, CS_DATA_TYPE_nxv4f64, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_VL8RE16_V (12554) - RISCV_INS_VL8RE16_V - vl8re16.v $vd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv64i8, CS_DATA_TYPE_nxv32i16, CS_DATA_TYPE_nxv16i32, CS_DATA_TYPE_nxv8i64, CS_DATA_TYPE_nxv32f16, CS_DATA_TYPE_nxv32bf16, CS_DATA_TYPE_nxv16f32, CS_DATA_TYPE_nxv8f64, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_VL8RE32_V (12555) - RISCV_INS_VL8RE32_V - vl8re32.v $vd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv64i8, CS_DATA_TYPE_nxv32i16, CS_DATA_TYPE_nxv16i32, CS_DATA_TYPE_nxv8i64, CS_DATA_TYPE_nxv32f16, CS_DATA_TYPE_nxv32bf16, CS_DATA_TYPE_nxv16f32, CS_DATA_TYPE_nxv8f64, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_VL8RE64_V (12556) - RISCV_INS_VL8RE64_V - vl8re64.v $vd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv64i8, CS_DATA_TYPE_nxv32i16, CS_DATA_TYPE_nxv16i32, CS_DATA_TYPE_nxv8i64, CS_DATA_TYPE_nxv32f16, CS_DATA_TYPE_nxv32bf16, CS_DATA_TYPE_nxv16f32, CS_DATA_TYPE_nxv8f64, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_VL8RE8_V (12557) - RISCV_INS_VL8RE8_V - vl8re8.v $vd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv64i8, CS_DATA_TYPE_nxv32i16, CS_DATA_TYPE_nxv16i32, CS_DATA_TYPE_nxv8i64, CS_DATA_TYPE_nxv32f16, CS_DATA_TYPE_nxv32bf16, CS_DATA_TYPE_nxv16f32, CS_DATA_TYPE_nxv8f64, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_VLE16FF_V (12558) - RISCV_INS_VLE16FF_V - vle16ff.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLE16_V (12559) - RISCV_INS_VLE16_V - vle16.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLE32FF_V (12560) - RISCV_INS_VLE32FF_V - vle32ff.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLE32_V (12561) - RISCV_INS_VLE32_V - vle32.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLE64FF_V (12562) - RISCV_INS_VLE64FF_V - vle64ff.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLE64_V (12563) - RISCV_INS_VLE64_V - vle64.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLE8FF_V (12564) - RISCV_INS_VLE8FF_V - vle8ff.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLE8_V (12565) - RISCV_INS_VLE8_V - vle8.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLM_V (12566) - RISCV_INS_VLM_V - vlm.v $vd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_VLOXEI16_V (12567) - RISCV_INS_VLOXEI16_V - vloxei16.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLOXEI32_V (12568) - RISCV_INS_VLOXEI32_V - vloxei32.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLOXEI64_V (12569) - RISCV_INS_VLOXEI64_V - vloxei64.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLOXEI8_V (12570) - RISCV_INS_VLOXEI8_V - vloxei8.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLOXSEG2EI16_V (12571) - RISCV_INS_VLOXSEG2EI16_V - vloxseg2ei16.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLOXSEG2EI32_V (12572) - RISCV_INS_VLOXSEG2EI32_V - vloxseg2ei32.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLOXSEG2EI64_V (12573) - RISCV_INS_VLOXSEG2EI64_V - vloxseg2ei64.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLOXSEG2EI8_V (12574) - RISCV_INS_VLOXSEG2EI8_V - vloxseg2ei8.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLOXSEG3EI16_V (12575) - RISCV_INS_VLOXSEG3EI16_V - vloxseg3ei16.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLOXSEG3EI32_V (12576) - RISCV_INS_VLOXSEG3EI32_V - vloxseg3ei32.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLOXSEG3EI64_V (12577) - RISCV_INS_VLOXSEG3EI64_V - vloxseg3ei64.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLOXSEG3EI8_V (12578) - RISCV_INS_VLOXSEG3EI8_V - vloxseg3ei8.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLOXSEG4EI16_V (12579) - RISCV_INS_VLOXSEG4EI16_V - vloxseg4ei16.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLOXSEG4EI32_V (12580) - RISCV_INS_VLOXSEG4EI32_V - vloxseg4ei32.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLOXSEG4EI64_V (12581) - RISCV_INS_VLOXSEG4EI64_V - vloxseg4ei64.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLOXSEG4EI8_V (12582) - RISCV_INS_VLOXSEG4EI8_V - vloxseg4ei8.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLOXSEG5EI16_V (12583) - RISCV_INS_VLOXSEG5EI16_V - vloxseg5ei16.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLOXSEG5EI32_V (12584) - RISCV_INS_VLOXSEG5EI32_V - vloxseg5ei32.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLOXSEG5EI64_V (12585) - RISCV_INS_VLOXSEG5EI64_V - vloxseg5ei64.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLOXSEG5EI8_V (12586) - RISCV_INS_VLOXSEG5EI8_V - vloxseg5ei8.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLOXSEG6EI16_V (12587) - RISCV_INS_VLOXSEG6EI16_V - vloxseg6ei16.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLOXSEG6EI32_V (12588) - RISCV_INS_VLOXSEG6EI32_V - vloxseg6ei32.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLOXSEG6EI64_V (12589) - RISCV_INS_VLOXSEG6EI64_V - vloxseg6ei64.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLOXSEG6EI8_V (12590) - RISCV_INS_VLOXSEG6EI8_V - vloxseg6ei8.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLOXSEG7EI16_V (12591) - RISCV_INS_VLOXSEG7EI16_V - vloxseg7ei16.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLOXSEG7EI32_V (12592) - RISCV_INS_VLOXSEG7EI32_V - vloxseg7ei32.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLOXSEG7EI64_V (12593) - RISCV_INS_VLOXSEG7EI64_V - vloxseg7ei64.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLOXSEG7EI8_V (12594) - RISCV_INS_VLOXSEG7EI8_V - vloxseg7ei8.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLOXSEG8EI16_V (12595) - RISCV_INS_VLOXSEG8EI16_V - vloxseg8ei16.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLOXSEG8EI32_V (12596) - RISCV_INS_VLOXSEG8EI32_V - vloxseg8ei32.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLOXSEG8EI64_V (12597) - RISCV_INS_VLOXSEG8EI64_V - vloxseg8ei64.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLOXSEG8EI8_V (12598) - RISCV_INS_VLOXSEG8EI8_V - vloxseg8ei8.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSE16_V (12599) - RISCV_INS_VLSE16_V - vlse16.v $vd, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSE32_V (12600) - RISCV_INS_VLSE32_V - vlse32.v $vd, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSE64_V (12601) - RISCV_INS_VLSE64_V - vlse64.v $vd, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSE8_V (12602) - RISCV_INS_VLSE8_V - vlse8.v $vd, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSEG2E16FF_V (12603) - RISCV_INS_VLSEG2E16FF_V - vlseg2e16ff.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSEG2E16_V (12604) - RISCV_INS_VLSEG2E16_V - vlseg2e16.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSEG2E32FF_V (12605) - RISCV_INS_VLSEG2E32FF_V - vlseg2e32ff.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSEG2E32_V (12606) - RISCV_INS_VLSEG2E32_V - vlseg2e32.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSEG2E64FF_V (12607) - RISCV_INS_VLSEG2E64FF_V - vlseg2e64ff.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSEG2E64_V (12608) - RISCV_INS_VLSEG2E64_V - vlseg2e64.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSEG2E8FF_V (12609) - RISCV_INS_VLSEG2E8FF_V - vlseg2e8ff.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSEG2E8_V (12610) - RISCV_INS_VLSEG2E8_V - vlseg2e8.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSEG3E16FF_V (12611) - RISCV_INS_VLSEG3E16FF_V - vlseg3e16ff.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSEG3E16_V (12612) - RISCV_INS_VLSEG3E16_V - vlseg3e16.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSEG3E32FF_V (12613) - RISCV_INS_VLSEG3E32FF_V - vlseg3e32ff.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSEG3E32_V (12614) - RISCV_INS_VLSEG3E32_V - vlseg3e32.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSEG3E64FF_V (12615) - RISCV_INS_VLSEG3E64FF_V - vlseg3e64ff.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSEG3E64_V (12616) - RISCV_INS_VLSEG3E64_V - vlseg3e64.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSEG3E8FF_V (12617) - RISCV_INS_VLSEG3E8FF_V - vlseg3e8ff.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSEG3E8_V (12618) - RISCV_INS_VLSEG3E8_V - vlseg3e8.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSEG4E16FF_V (12619) - RISCV_INS_VLSEG4E16FF_V - vlseg4e16ff.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSEG4E16_V (12620) - RISCV_INS_VLSEG4E16_V - vlseg4e16.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSEG4E32FF_V (12621) - RISCV_INS_VLSEG4E32FF_V - vlseg4e32ff.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSEG4E32_V (12622) - RISCV_INS_VLSEG4E32_V - vlseg4e32.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSEG4E64FF_V (12623) - RISCV_INS_VLSEG4E64FF_V - vlseg4e64ff.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSEG4E64_V (12624) - RISCV_INS_VLSEG4E64_V - vlseg4e64.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSEG4E8FF_V (12625) - RISCV_INS_VLSEG4E8FF_V - vlseg4e8ff.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSEG4E8_V (12626) - RISCV_INS_VLSEG4E8_V - vlseg4e8.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSEG5E16FF_V (12627) - RISCV_INS_VLSEG5E16FF_V - vlseg5e16ff.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSEG5E16_V (12628) - RISCV_INS_VLSEG5E16_V - vlseg5e16.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSEG5E32FF_V (12629) - RISCV_INS_VLSEG5E32FF_V - vlseg5e32ff.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSEG5E32_V (12630) - RISCV_INS_VLSEG5E32_V - vlseg5e32.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSEG5E64FF_V (12631) - RISCV_INS_VLSEG5E64FF_V - vlseg5e64ff.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSEG5E64_V (12632) - RISCV_INS_VLSEG5E64_V - vlseg5e64.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSEG5E8FF_V (12633) - RISCV_INS_VLSEG5E8FF_V - vlseg5e8ff.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSEG5E8_V (12634) - RISCV_INS_VLSEG5E8_V - vlseg5e8.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSEG6E16FF_V (12635) - RISCV_INS_VLSEG6E16FF_V - vlseg6e16ff.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSEG6E16_V (12636) - RISCV_INS_VLSEG6E16_V - vlseg6e16.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSEG6E32FF_V (12637) - RISCV_INS_VLSEG6E32FF_V - vlseg6e32ff.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSEG6E32_V (12638) - RISCV_INS_VLSEG6E32_V - vlseg6e32.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSEG6E64FF_V (12639) - RISCV_INS_VLSEG6E64FF_V - vlseg6e64ff.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSEG6E64_V (12640) - RISCV_INS_VLSEG6E64_V - vlseg6e64.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSEG6E8FF_V (12641) - RISCV_INS_VLSEG6E8FF_V - vlseg6e8ff.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSEG6E8_V (12642) - RISCV_INS_VLSEG6E8_V - vlseg6e8.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSEG7E16FF_V (12643) - RISCV_INS_VLSEG7E16FF_V - vlseg7e16ff.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSEG7E16_V (12644) - RISCV_INS_VLSEG7E16_V - vlseg7e16.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSEG7E32FF_V (12645) - RISCV_INS_VLSEG7E32FF_V - vlseg7e32ff.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSEG7E32_V (12646) - RISCV_INS_VLSEG7E32_V - vlseg7e32.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSEG7E64FF_V (12647) - RISCV_INS_VLSEG7E64FF_V - vlseg7e64ff.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSEG7E64_V (12648) - RISCV_INS_VLSEG7E64_V - vlseg7e64.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSEG7E8FF_V (12649) - RISCV_INS_VLSEG7E8FF_V - vlseg7e8ff.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSEG7E8_V (12650) - RISCV_INS_VLSEG7E8_V - vlseg7e8.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSEG8E16FF_V (12651) - RISCV_INS_VLSEG8E16FF_V - vlseg8e16ff.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSEG8E16_V (12652) - RISCV_INS_VLSEG8E16_V - vlseg8e16.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSEG8E32FF_V (12653) - RISCV_INS_VLSEG8E32FF_V - vlseg8e32ff.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSEG8E32_V (12654) - RISCV_INS_VLSEG8E32_V - vlseg8e32.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSEG8E64FF_V (12655) - RISCV_INS_VLSEG8E64FF_V - vlseg8e64ff.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSEG8E64_V (12656) - RISCV_INS_VLSEG8E64_V - vlseg8e64.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSEG8E8FF_V (12657) - RISCV_INS_VLSEG8E8FF_V - vlseg8e8ff.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSEG8E8_V (12658) - RISCV_INS_VLSEG8E8_V - vlseg8e8.v $vd, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSSEG2E16_V (12659) - RISCV_INS_VLSSEG2E16_V - vlsseg2e16.v $vd, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSSEG2E32_V (12660) - RISCV_INS_VLSSEG2E32_V - vlsseg2e32.v $vd, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSSEG2E64_V (12661) - RISCV_INS_VLSSEG2E64_V - vlsseg2e64.v $vd, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSSEG2E8_V (12662) - RISCV_INS_VLSSEG2E8_V - vlsseg2e8.v $vd, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSSEG3E16_V (12663) - RISCV_INS_VLSSEG3E16_V - vlsseg3e16.v $vd, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSSEG3E32_V (12664) - RISCV_INS_VLSSEG3E32_V - vlsseg3e32.v $vd, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSSEG3E64_V (12665) - RISCV_INS_VLSSEG3E64_V - vlsseg3e64.v $vd, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSSEG3E8_V (12666) - RISCV_INS_VLSSEG3E8_V - vlsseg3e8.v $vd, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSSEG4E16_V (12667) - RISCV_INS_VLSSEG4E16_V - vlsseg4e16.v $vd, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSSEG4E32_V (12668) - RISCV_INS_VLSSEG4E32_V - vlsseg4e32.v $vd, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSSEG4E64_V (12669) - RISCV_INS_VLSSEG4E64_V - vlsseg4e64.v $vd, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSSEG4E8_V (12670) - RISCV_INS_VLSSEG4E8_V - vlsseg4e8.v $vd, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSSEG5E16_V (12671) - RISCV_INS_VLSSEG5E16_V - vlsseg5e16.v $vd, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSSEG5E32_V (12672) - RISCV_INS_VLSSEG5E32_V - vlsseg5e32.v $vd, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSSEG5E64_V (12673) - RISCV_INS_VLSSEG5E64_V - vlsseg5e64.v $vd, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSSEG5E8_V (12674) - RISCV_INS_VLSSEG5E8_V - vlsseg5e8.v $vd, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSSEG6E16_V (12675) - RISCV_INS_VLSSEG6E16_V - vlsseg6e16.v $vd, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSSEG6E32_V (12676) - RISCV_INS_VLSSEG6E32_V - vlsseg6e32.v $vd, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSSEG6E64_V (12677) - RISCV_INS_VLSSEG6E64_V - vlsseg6e64.v $vd, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSSEG6E8_V (12678) - RISCV_INS_VLSSEG6E8_V - vlsseg6e8.v $vd, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSSEG7E16_V (12679) - RISCV_INS_VLSSEG7E16_V - vlsseg7e16.v $vd, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSSEG7E32_V (12680) - RISCV_INS_VLSSEG7E32_V - vlsseg7e32.v $vd, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSSEG7E64_V (12681) - RISCV_INS_VLSSEG7E64_V - vlsseg7e64.v $vd, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSSEG7E8_V (12682) - RISCV_INS_VLSSEG7E8_V - vlsseg7e8.v $vd, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSSEG8E16_V (12683) - RISCV_INS_VLSSEG8E16_V - vlsseg8e16.v $vd, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSSEG8E32_V (12684) - RISCV_INS_VLSSEG8E32_V - vlsseg8e32.v $vd, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSSEG8E64_V (12685) - RISCV_INS_VLSSEG8E64_V - vlsseg8e64.v $vd, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLSSEG8E8_V (12686) - RISCV_INS_VLSSEG8E8_V - vlsseg8e8.v $vd, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLUXEI16_V (12687) - RISCV_INS_VLUXEI16_V - vluxei16.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLUXEI32_V (12688) - RISCV_INS_VLUXEI32_V - vluxei32.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLUXEI64_V (12689) - RISCV_INS_VLUXEI64_V - vluxei64.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLUXEI8_V (12690) - RISCV_INS_VLUXEI8_V - vluxei8.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLUXSEG2EI16_V (12691) - RISCV_INS_VLUXSEG2EI16_V - vluxseg2ei16.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLUXSEG2EI32_V (12692) - RISCV_INS_VLUXSEG2EI32_V - vluxseg2ei32.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLUXSEG2EI64_V (12693) - RISCV_INS_VLUXSEG2EI64_V - vluxseg2ei64.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLUXSEG2EI8_V (12694) - RISCV_INS_VLUXSEG2EI8_V - vluxseg2ei8.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLUXSEG3EI16_V (12695) - RISCV_INS_VLUXSEG3EI16_V - vluxseg3ei16.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLUXSEG3EI32_V (12696) - RISCV_INS_VLUXSEG3EI32_V - vluxseg3ei32.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLUXSEG3EI64_V (12697) - RISCV_INS_VLUXSEG3EI64_V - vluxseg3ei64.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLUXSEG3EI8_V (12698) - RISCV_INS_VLUXSEG3EI8_V - vluxseg3ei8.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLUXSEG4EI16_V (12699) - RISCV_INS_VLUXSEG4EI16_V - vluxseg4ei16.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLUXSEG4EI32_V (12700) - RISCV_INS_VLUXSEG4EI32_V - vluxseg4ei32.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLUXSEG4EI64_V (12701) - RISCV_INS_VLUXSEG4EI64_V - vluxseg4ei64.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLUXSEG4EI8_V (12702) - RISCV_INS_VLUXSEG4EI8_V - vluxseg4ei8.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLUXSEG5EI16_V (12703) - RISCV_INS_VLUXSEG5EI16_V - vluxseg5ei16.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLUXSEG5EI32_V (12704) - RISCV_INS_VLUXSEG5EI32_V - vluxseg5ei32.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLUXSEG5EI64_V (12705) - RISCV_INS_VLUXSEG5EI64_V - vluxseg5ei64.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLUXSEG5EI8_V (12706) - RISCV_INS_VLUXSEG5EI8_V - vluxseg5ei8.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLUXSEG6EI16_V (12707) - RISCV_INS_VLUXSEG6EI16_V - vluxseg6ei16.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLUXSEG6EI32_V (12708) - RISCV_INS_VLUXSEG6EI32_V - vluxseg6ei32.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLUXSEG6EI64_V (12709) - RISCV_INS_VLUXSEG6EI64_V - vluxseg6ei64.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLUXSEG6EI8_V (12710) - RISCV_INS_VLUXSEG6EI8_V - vluxseg6ei8.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLUXSEG7EI16_V (12711) - RISCV_INS_VLUXSEG7EI16_V - vluxseg7ei16.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLUXSEG7EI32_V (12712) - RISCV_INS_VLUXSEG7EI32_V - vluxseg7ei32.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLUXSEG7EI64_V (12713) - RISCV_INS_VLUXSEG7EI64_V - vluxseg7ei64.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLUXSEG7EI8_V (12714) - RISCV_INS_VLUXSEG7EI8_V - vluxseg7ei8.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLUXSEG8EI16_V (12715) - RISCV_INS_VLUXSEG8EI16_V - vluxseg8ei16.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLUXSEG8EI32_V (12716) - RISCV_INS_VLUXSEG8EI32_V - vluxseg8ei32.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLUXSEG8EI64_V (12717) - RISCV_INS_VLUXSEG8EI64_V - vluxseg8ei64.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VLUXSEG8EI8_V (12718) - RISCV_INS_VLUXSEG8EI8_V - vluxseg8ei8.v $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_MEM | CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VMACC_VV (12719) - RISCV_INS_VMACC_VV - vmacc.vv $vd, $vs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VMACC_VX (12720) - RISCV_INS_VMACC_VX - vmacc.vx $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VMADC_VI (12721) - RISCV_INS_VMADC_VI - vmadc.vi $vd, $vs2, $imm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { 0 } +}}, +{ /* RISCV_VMADC_VIM (12722) - RISCV_INS_VMADC_VIM - vmadc.vim $vd, $vs2, $imm, v0 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* v0 */ + { 0 } +}}, +{ /* RISCV_VMADC_VV (12723) - RISCV_INS_VMADC_VV - vmadc.vv $vd, $vs2, $vs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { 0 } +}}, +{ /* RISCV_VMADC_VVM (12724) - RISCV_INS_VMADC_VVM - vmadc.vvm $vd, $vs2, $vs1, v0 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* v0 */ + { 0 } +}}, +{ /* RISCV_VMADC_VX (12725) - RISCV_INS_VMADC_VX - vmadc.vx $vd, $vs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_VMADC_VXM (12726) - RISCV_INS_VMADC_VXM - vmadc.vxm $vd, $vs2, $rs1, v0 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* v0 */ + { 0 } +}}, +{ /* RISCV_VMADD_VV (12727) - RISCV_INS_VMADD_VV - vmadd.vv $vd, $vs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VMADD_VX (12728) - RISCV_INS_VMADD_VX - vmadd.vx $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VMANDN_MM (12729) - RISCV_INS_VMANDN_MM - vmandn.mm $vd, $vs2, $vs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { 0 } +}}, +{ /* RISCV_VMAND_MM (12730) - RISCV_INS_VMAND_MM - vmand.mm $vd, $vs2, $vs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { 0 } +}}, +{ /* RISCV_VMAXU_VV (12731) - RISCV_INS_VMAXU_VV - vmaxu.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VMAXU_VX (12732) - RISCV_INS_VMAXU_VX - vmaxu.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VMAX_VV (12733) - RISCV_INS_VMAX_VV - vmax.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VMAX_VX (12734) - RISCV_INS_VMAX_VX - vmax.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VMERGE_VIM (12735) - RISCV_INS_VMERGE_VIM - vmerge.vim $vd, $vs2, $imm, v0 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* v0 */ + { 0 } +}}, +{ /* RISCV_VMERGE_VVM (12736) - RISCV_INS_VMERGE_VVM - vmerge.vvm $vd, $vs2, $vs1, v0 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* v0 */ + { 0 } +}}, +{ /* RISCV_VMERGE_VXM (12737) - RISCV_INS_VMERGE_VXM - vmerge.vxm $vd, $vs2, $rs1, v0 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* v0 */ + { 0 } +}}, +{ /* RISCV_VMFEQ_VF (12738) - RISCV_INS_VMFEQ_VF - vmfeq.vf $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VMFEQ_VV (12739) - RISCV_INS_VMFEQ_VV - vmfeq.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VMFGE_VF (12740) - RISCV_INS_VMFGE_VF - vmfge.vf $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VMFGT_VF (12741) - RISCV_INS_VMFGT_VF - vmfgt.vf $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VMFLE_VF (12742) - RISCV_INS_VMFLE_VF - vmfle.vf $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VMFLE_VV (12743) - RISCV_INS_VMFLE_VV - vmfle.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VMFLT_VF (12744) - RISCV_INS_VMFLT_VF - vmflt.vf $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VMFLT_VV (12745) - RISCV_INS_VMFLT_VV - vmflt.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VMFNE_VF (12746) - RISCV_INS_VMFNE_VF - vmfne.vf $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VMFNE_VV (12747) - RISCV_INS_VMFNE_VV - vmfne.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VMINU_VV (12748) - RISCV_INS_VMINU_VV - vminu.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VMINU_VX (12749) - RISCV_INS_VMINU_VX - vminu.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VMIN_VV (12750) - RISCV_INS_VMIN_VV - vmin.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VMIN_VX (12751) - RISCV_INS_VMIN_VX - vmin.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VMNAND_MM (12752) - RISCV_INS_VMNAND_MM - vmnand.mm $vd, $vs2, $vs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { 0 } +}}, +{ /* RISCV_VMNOR_MM (12753) - RISCV_INS_VMNOR_MM - vmnor.mm $vd, $vs2, $vs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { 0 } +}}, +{ /* RISCV_VMORN_MM (12754) - RISCV_INS_VMORN_MM - vmorn.mm $vd, $vs2, $vs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { 0 } +}}, +{ /* RISCV_VMOR_MM (12755) - RISCV_INS_VMOR_MM - vmor.mm $vd, $vs2, $vs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { 0 } +}}, +{ /* RISCV_VMSBC_VV (12756) - RISCV_INS_VMSBC_VV - vmsbc.vv $vd, $vs2, $vs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { 0 } +}}, +{ /* RISCV_VMSBC_VVM (12757) - RISCV_INS_VMSBC_VVM - vmsbc.vvm $vd, $vs2, $vs1, v0 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* v0 */ + { 0 } +}}, +{ /* RISCV_VMSBC_VX (12758) - RISCV_INS_VMSBC_VX - vmsbc.vx $vd, $vs2, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_VMSBC_VXM (12759) - RISCV_INS_VMSBC_VXM - vmsbc.vxm $vd, $vs2, $rs1, v0 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* v0 */ + { 0 } +}}, +{ /* RISCV_VMSBF_M (12760) - RISCV_INS_VMSBF_M - vmsbf.m $vd, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VMSEQ_VI (12761) - RISCV_INS_VMSEQ_VI - vmseq.vi $vd, $vs2, $imm$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VMSEQ_VV (12762) - RISCV_INS_VMSEQ_VV - vmseq.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VMSEQ_VX (12763) - RISCV_INS_VMSEQ_VX - vmseq.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VMSGTU_VI (12764) - RISCV_INS_VMSGTU_VI - vmsgtu.vi $vd, $vs2, $imm$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VMSGTU_VX (12765) - RISCV_INS_VMSGTU_VX - vmsgtu.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VMSGT_VI (12766) - RISCV_INS_VMSGT_VI - vmsgt.vi $vd, $vs2, $imm$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VMSGT_VX (12767) - RISCV_INS_VMSGT_VX - vmsgt.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VMSIF_M (12768) - RISCV_INS_VMSIF_M - vmsif.m $vd, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VMSLEU_VI (12769) - RISCV_INS_VMSLEU_VI - vmsleu.vi $vd, $vs2, $imm$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VMSLEU_VV (12770) - RISCV_INS_VMSLEU_VV - vmsleu.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VMSLEU_VX (12771) - RISCV_INS_VMSLEU_VX - vmsleu.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VMSLE_VI (12772) - RISCV_INS_VMSLE_VI - vmsle.vi $vd, $vs2, $imm$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VMSLE_VV (12773) - RISCV_INS_VMSLE_VV - vmsle.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VMSLE_VX (12774) - RISCV_INS_VMSLE_VX - vmsle.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VMSLTU_VV (12775) - RISCV_INS_VMSLTU_VV - vmsltu.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VMSLTU_VX (12776) - RISCV_INS_VMSLTU_VX - vmsltu.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VMSLT_VV (12777) - RISCV_INS_VMSLT_VV - vmslt.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VMSLT_VX (12778) - RISCV_INS_VMSLT_VX - vmslt.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VMSNE_VI (12779) - RISCV_INS_VMSNE_VI - vmsne.vi $vd, $vs2, $imm$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VMSNE_VV (12780) - RISCV_INS_VMSNE_VV - vmsne.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VMSNE_VX (12781) - RISCV_INS_VMSNE_VX - vmsne.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VMSOF_M (12782) - RISCV_INS_VMSOF_M - vmsof.m $vd, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VMULHSU_VV (12783) - RISCV_INS_VMULHSU_VV - vmulhsu.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VMULHSU_VX (12784) - RISCV_INS_VMULHSU_VX - vmulhsu.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VMULHU_VV (12785) - RISCV_INS_VMULHU_VV - vmulhu.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VMULHU_VX (12786) - RISCV_INS_VMULHU_VX - vmulhu.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VMULH_VV (12787) - RISCV_INS_VMULH_VV - vmulh.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VMULH_VX (12788) - RISCV_INS_VMULH_VX - vmulh.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VMUL_VV (12789) - RISCV_INS_VMUL_VV - vmul.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VMUL_VX (12790) - RISCV_INS_VMUL_VX - vmul.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VMV1R_V (12791) - RISCV_INS_VMV1R_V - vmv1r.v $vd, $vs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { 0 } +}}, +{ /* RISCV_VMV2R_V (12792) - RISCV_INS_VMV2R_V - vmv2r.v $vd, $vs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv16i8, CS_DATA_TYPE_nxv8i16, CS_DATA_TYPE_nxv4i32, CS_DATA_TYPE_nxv2i64, CS_DATA_TYPE_nxv8f16, CS_DATA_TYPE_nxv8bf16, CS_DATA_TYPE_nxv4f32, CS_DATA_TYPE_nxv2f64, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv16i8, CS_DATA_TYPE_nxv8i16, CS_DATA_TYPE_nxv4i32, CS_DATA_TYPE_nxv2i64, CS_DATA_TYPE_nxv8f16, CS_DATA_TYPE_nxv8bf16, CS_DATA_TYPE_nxv4f32, CS_DATA_TYPE_nxv2f64, CS_DATA_TYPE_LAST } }, /* vs2 */ + { 0 } +}}, +{ /* RISCV_VMV4R_V (12793) - RISCV_INS_VMV4R_V - vmv4r.v $vd, $vs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv32i8, CS_DATA_TYPE_nxv16i16, CS_DATA_TYPE_nxv8i32, CS_DATA_TYPE_nxv4i64, CS_DATA_TYPE_nxv16f16, CS_DATA_TYPE_nxv16bf16, CS_DATA_TYPE_nxv8f32, CS_DATA_TYPE_nxv4f64, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv32i8, CS_DATA_TYPE_nxv16i16, CS_DATA_TYPE_nxv8i32, CS_DATA_TYPE_nxv4i64, CS_DATA_TYPE_nxv16f16, CS_DATA_TYPE_nxv16bf16, CS_DATA_TYPE_nxv8f32, CS_DATA_TYPE_nxv4f64, CS_DATA_TYPE_LAST } }, /* vs2 */ + { 0 } +}}, +{ /* RISCV_VMV8R_V (12794) - RISCV_INS_VMV8R_V - vmv8r.v $vd, $vs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv64i8, CS_DATA_TYPE_nxv32i16, CS_DATA_TYPE_nxv16i32, CS_DATA_TYPE_nxv8i64, CS_DATA_TYPE_nxv32f16, CS_DATA_TYPE_nxv32bf16, CS_DATA_TYPE_nxv16f32, CS_DATA_TYPE_nxv8f64, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i8, CS_DATA_TYPE_nxv32i16, CS_DATA_TYPE_nxv16i32, CS_DATA_TYPE_nxv8i64, CS_DATA_TYPE_nxv32f16, CS_DATA_TYPE_nxv32bf16, CS_DATA_TYPE_nxv16f32, CS_DATA_TYPE_nxv8f64, CS_DATA_TYPE_LAST } }, /* vs2 */ + { 0 } +}}, +{ /* RISCV_VMV_S_X (12795) - RISCV_INS_VMV_S_X - vmv.s.x $vd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_VMV_V_I (12796) - RISCV_INS_VMV_V_I - vmv.v.i $vd, $imm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { 0 } +}}, +{ /* RISCV_VMV_V_V (12797) - RISCV_INS_VMV_V_V - vmv.v.v $vd, $vs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { 0 } +}}, +{ /* RISCV_VMV_V_X (12798) - RISCV_INS_VMV_V_X - vmv.v.x $vd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_VMV_X_S (12799) - RISCV_INS_VMV_X_S - vmv.x.s $vd, $vs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { 0 } +}}, +{ /* RISCV_VMXNOR_MM (12800) - RISCV_INS_VMXNOR_MM - vmxnor.mm $vd, $vs2, $vs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { 0 } +}}, +{ /* RISCV_VMXOR_MM (12801) - RISCV_INS_VMXOR_MM - vmxor.mm $vd, $vs2, $vs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { 0 } +}}, +{ /* RISCV_VNCLIPU_WI (12802) - RISCV_INS_VNCLIPU_WI - vnclipu.wi $vd, $vs2, $imm$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VNCLIPU_WV (12803) - RISCV_INS_VNCLIPU_WV - vnclipu.wv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VNCLIPU_WX (12804) - RISCV_INS_VNCLIPU_WX - vnclipu.wx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VNCLIP_WI (12805) - RISCV_INS_VNCLIP_WI - vnclip.wi $vd, $vs2, $imm$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VNCLIP_WV (12806) - RISCV_INS_VNCLIP_WV - vnclip.wv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VNCLIP_WX (12807) - RISCV_INS_VNCLIP_WX - vnclip.wx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VNMSAC_VV (12808) - RISCV_INS_VNMSAC_VV - vnmsac.vv $vd, $vs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VNMSAC_VX (12809) - RISCV_INS_VNMSAC_VX - vnmsac.vx $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VNMSUB_VV (12810) - RISCV_INS_VNMSUB_VV - vnmsub.vv $vd, $vs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VNMSUB_VX (12811) - RISCV_INS_VNMSUB_VX - vnmsub.vx $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VNSRA_WI (12812) - RISCV_INS_VNSRA_WI - vnsra.wi $vd, $vs2, $imm$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VNSRA_WV (12813) - RISCV_INS_VNSRA_WV - vnsra.wv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VNSRA_WX (12814) - RISCV_INS_VNSRA_WX - vnsra.wx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VNSRL_WI (12815) - RISCV_INS_VNSRL_WI - vnsrl.wi $vd, $vs2, $imm$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VNSRL_WV (12816) - RISCV_INS_VNSRL_WV - vnsrl.wv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VNSRL_WX (12817) - RISCV_INS_VNSRL_WX - vnsrl.wx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VOR_VI (12818) - RISCV_INS_VOR_VI - vor.vi $vd, $vs2, $imm$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VOR_VV (12819) - RISCV_INS_VOR_VV - vor.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VOR_VX (12820) - RISCV_INS_VOR_VX - vor.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VQMACCSU_2x8x2 (12821) - RISCV_INS_SF_VQMACCSU_2X8X2 - sf.vqmaccsu.2x8x2 $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_VQMACCSU_4x8x4 (12822) - RISCV_INS_SF_VQMACCSU_4X8X4 - sf.vqmaccsu.4x8x4 $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_VQMACCUS_2x8x2 (12823) - RISCV_INS_SF_VQMACCUS_2X8X2 - sf.vqmaccus.2x8x2 $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_VQMACCUS_4x8x4 (12824) - RISCV_INS_SF_VQMACCUS_4X8X4 - sf.vqmaccus.4x8x4 $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_VQMACCU_2x8x2 (12825) - RISCV_INS_SF_VQMACCU_2X8X2 - sf.vqmaccu.2x8x2 $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_VQMACCU_4x8x4 (12826) - RISCV_INS_SF_VQMACCU_4X8X4 - sf.vqmaccu.4x8x4 $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_VQMACC_2x8x2 (12827) - RISCV_INS_SF_VQMACC_2X8X2 - sf.vqmacc.2x8x2 $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_VQMACC_4x8x4 (12828) - RISCV_INS_SF_VQMACC_4X8X4 - sf.vqmacc.4x8x4 $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_VREDAND_VS (12829) - RISCV_INS_VREDAND_VS - vredand.vs $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VREDMAXU_VS (12830) - RISCV_INS_VREDMAXU_VS - vredmaxu.vs $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VREDMAX_VS (12831) - RISCV_INS_VREDMAX_VS - vredmax.vs $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VREDMINU_VS (12832) - RISCV_INS_VREDMINU_VS - vredminu.vs $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VREDMIN_VS (12833) - RISCV_INS_VREDMIN_VS - vredmin.vs $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VREDOR_VS (12834) - RISCV_INS_VREDOR_VS - vredor.vs $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VREDSUM_VS (12835) - RISCV_INS_VREDSUM_VS - vredsum.vs $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VREDXOR_VS (12836) - RISCV_INS_VREDXOR_VS - vredxor.vs $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VREMU_VV (12837) - RISCV_INS_VREMU_VV - vremu.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VREMU_VX (12838) - RISCV_INS_VREMU_VX - vremu.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VREM_VV (12839) - RISCV_INS_VREM_VV - vrem.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VREM_VX (12840) - RISCV_INS_VREM_VX - vrem.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VREV8_V (12841) - RISCV_INS_VREV8_V - vrev8.v $vd, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VRGATHEREI16_VV (12842) - RISCV_INS_VRGATHEREI16_VV - vrgatherei16.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VRGATHER_VI (12843) - RISCV_INS_VRGATHER_VI - vrgather.vi $vd, $vs2, $imm$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VRGATHER_VV (12844) - RISCV_INS_VRGATHER_VV - vrgather.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VRGATHER_VX (12845) - RISCV_INS_VRGATHER_VX - vrgather.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VROL_VV (12846) - RISCV_INS_VROL_VV - vrol.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VROL_VX (12847) - RISCV_INS_VROL_VX - vrol.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VROR_VI (12848) - RISCV_INS_VROR_VI - vror.vi $vd, $vs2, $imm$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VROR_VV (12849) - RISCV_INS_VROR_VV - vror.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VROR_VX (12850) - RISCV_INS_VROR_VX - vror.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VRSUB_VI (12851) - RISCV_INS_VRSUB_VI - vrsub.vi $vd, $vs2, $imm$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VRSUB_VX (12852) - RISCV_INS_VRSUB_VX - vrsub.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VS1R_V (12853) - RISCV_INS_VS1R_V - vs1r.v $vs3, $rs1 */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_VS2R_V (12854) - RISCV_INS_VS2R_V - vs2r.v $vs3, $rs1 */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv16i8, CS_DATA_TYPE_nxv8i16, CS_DATA_TYPE_nxv4i32, CS_DATA_TYPE_nxv2i64, CS_DATA_TYPE_nxv8f16, CS_DATA_TYPE_nxv8bf16, CS_DATA_TYPE_nxv4f32, CS_DATA_TYPE_nxv2f64, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_VS4R_V (12855) - RISCV_INS_VS4R_V - vs4r.v $vs3, $rs1 */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv32i8, CS_DATA_TYPE_nxv16i16, CS_DATA_TYPE_nxv8i32, CS_DATA_TYPE_nxv4i64, CS_DATA_TYPE_nxv16f16, CS_DATA_TYPE_nxv16bf16, CS_DATA_TYPE_nxv8f32, CS_DATA_TYPE_nxv4f64, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_VS8R_V (12856) - RISCV_INS_VS8R_V - vs8r.v $vs3, $rs1 */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i8, CS_DATA_TYPE_nxv32i16, CS_DATA_TYPE_nxv16i32, CS_DATA_TYPE_nxv8i64, CS_DATA_TYPE_nxv32f16, CS_DATA_TYPE_nxv32bf16, CS_DATA_TYPE_nxv16f32, CS_DATA_TYPE_nxv8f64, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_VSADDU_VI (12857) - RISCV_INS_VSADDU_VI - vsaddu.vi $vd, $vs2, $imm$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSADDU_VV (12858) - RISCV_INS_VSADDU_VV - vsaddu.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSADDU_VX (12859) - RISCV_INS_VSADDU_VX - vsaddu.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSADD_VI (12860) - RISCV_INS_VSADD_VI - vsadd.vi $vd, $vs2, $imm$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSADD_VV (12861) - RISCV_INS_VSADD_VV - vsadd.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSADD_VX (12862) - RISCV_INS_VSADD_VX - vsadd.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSBC_VVM (12863) - RISCV_INS_VSBC_VVM - vsbc.vvm $vd, $vs2, $vs1, v0 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* v0 */ + { 0 } +}}, +{ /* RISCV_VSBC_VXM (12864) - RISCV_INS_VSBC_VXM - vsbc.vxm $vd, $vs2, $rs1, v0 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* v0 */ + { 0 } +}}, +{ /* RISCV_VSE16_V (12865) - RISCV_INS_VSE16_V - vse16.v $vs3, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSE32_V (12866) - RISCV_INS_VSE32_V - vse32.v $vs3, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSE64_V (12867) - RISCV_INS_VSE64_V - vse64.v $vs3, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSE8_V (12868) - RISCV_INS_VSE8_V - vse8.v $vs3, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSETIVLI (12869) - RISCV_INS_VSETIVLI - vsetivli $rd, $uimm, $vtypei */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* uimm */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* vtypei */ + { 0 } +}}, +{ /* RISCV_VSETVL (12870) - RISCV_INS_VSETVL - vsetvl $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_VSETVLI (12871) - RISCV_INS_VSETVLI - vsetvli $rd, $rs1, $vtypei */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* vtypei */ + { 0 } +}}, +{ /* RISCV_VSEXT_VF2 (12872) - RISCV_INS_VSEXT_VF2 - vsext.vf2 $vd, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSEXT_VF4 (12873) - RISCV_INS_VSEXT_VF4 - vsext.vf4 $vd, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSEXT_VF8 (12874) - RISCV_INS_VSEXT_VF8 - vsext.vf8 $vd, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSHA2CH_VV (12875) - RISCV_INS_VSHA2CH_VV - vsha2ch.vv $vd, $vs2, $vs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { 0 } +}}, +{ /* RISCV_VSHA2CL_VV (12876) - RISCV_INS_VSHA2CL_VV - vsha2cl.vv $vd, $vs2, $vs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { 0 } +}}, +{ /* RISCV_VSHA2MS_VV (12877) - RISCV_INS_VSHA2MS_VV - vsha2ms.vv $vd, $vs2, $vs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { 0 } +}}, +{ /* RISCV_VSLIDE1DOWN_VX (12878) - RISCV_INS_VSLIDE1DOWN_VX - vslide1down.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSLIDE1UP_VX (12879) - RISCV_INS_VSLIDE1UP_VX - vslide1up.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSLIDEDOWN_VI (12880) - RISCV_INS_VSLIDEDOWN_VI - vslidedown.vi $vd, $vs2, $imm$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSLIDEDOWN_VX (12881) - RISCV_INS_VSLIDEDOWN_VX - vslidedown.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSLIDEUP_VI (12882) - RISCV_INS_VSLIDEUP_VI - vslideup.vi $vd, $vs2, $imm$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSLIDEUP_VX (12883) - RISCV_INS_VSLIDEUP_VX - vslideup.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSLL_VI (12884) - RISCV_INS_VSLL_VI - vsll.vi $vd, $vs2, $imm$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSLL_VV (12885) - RISCV_INS_VSLL_VV - vsll.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSLL_VX (12886) - RISCV_INS_VSLL_VX - vsll.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSM3C_VI (12887) - RISCV_INS_VSM3C_VI - vsm3c.vi $vd, $vs2, $imm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { 0 } +}}, +{ /* RISCV_VSM3ME_VV (12888) - RISCV_INS_VSM3ME_VV - vsm3me.vv $vd, $vs2, $vs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { 0 } +}}, +{ /* RISCV_VSM4K_VI (12889) - RISCV_INS_VSM4K_VI - vsm4k.vi $vd, $vs2, $imm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { 0 } +}}, +{ /* RISCV_VSM4R_VS (12890) - RISCV_INS_VSM4R_VS - vsm4r.vs $vd, $vs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { 0 } +}}, +{ /* RISCV_VSM4R_VV (12891) - RISCV_INS_VSM4R_VV - vsm4r.vv $vd, $vs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { 0 } +}}, +{ /* RISCV_VSMUL_VV (12892) - RISCV_INS_VSMUL_VV - vsmul.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSMUL_VX (12893) - RISCV_INS_VSMUL_VX - vsmul.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSM_V (12894) - RISCV_INS_VSM_V - vsm.v $vs3, $rs1 */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_VSOXEI16_V (12895) - RISCV_INS_VSOXEI16_V - vsoxei16.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSOXEI32_V (12896) - RISCV_INS_VSOXEI32_V - vsoxei32.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSOXEI64_V (12897) - RISCV_INS_VSOXEI64_V - vsoxei64.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSOXEI8_V (12898) - RISCV_INS_VSOXEI8_V - vsoxei8.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSOXSEG2EI16_V (12899) - RISCV_INS_VSOXSEG2EI16_V - vsoxseg2ei16.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSOXSEG2EI32_V (12900) - RISCV_INS_VSOXSEG2EI32_V - vsoxseg2ei32.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSOXSEG2EI64_V (12901) - RISCV_INS_VSOXSEG2EI64_V - vsoxseg2ei64.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSOXSEG2EI8_V (12902) - RISCV_INS_VSOXSEG2EI8_V - vsoxseg2ei8.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSOXSEG3EI16_V (12903) - RISCV_INS_VSOXSEG3EI16_V - vsoxseg3ei16.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSOXSEG3EI32_V (12904) - RISCV_INS_VSOXSEG3EI32_V - vsoxseg3ei32.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSOXSEG3EI64_V (12905) - RISCV_INS_VSOXSEG3EI64_V - vsoxseg3ei64.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSOXSEG3EI8_V (12906) - RISCV_INS_VSOXSEG3EI8_V - vsoxseg3ei8.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSOXSEG4EI16_V (12907) - RISCV_INS_VSOXSEG4EI16_V - vsoxseg4ei16.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSOXSEG4EI32_V (12908) - RISCV_INS_VSOXSEG4EI32_V - vsoxseg4ei32.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSOXSEG4EI64_V (12909) - RISCV_INS_VSOXSEG4EI64_V - vsoxseg4ei64.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSOXSEG4EI8_V (12910) - RISCV_INS_VSOXSEG4EI8_V - vsoxseg4ei8.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSOXSEG5EI16_V (12911) - RISCV_INS_VSOXSEG5EI16_V - vsoxseg5ei16.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSOXSEG5EI32_V (12912) - RISCV_INS_VSOXSEG5EI32_V - vsoxseg5ei32.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSOXSEG5EI64_V (12913) - RISCV_INS_VSOXSEG5EI64_V - vsoxseg5ei64.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSOXSEG5EI8_V (12914) - RISCV_INS_VSOXSEG5EI8_V - vsoxseg5ei8.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSOXSEG6EI16_V (12915) - RISCV_INS_VSOXSEG6EI16_V - vsoxseg6ei16.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSOXSEG6EI32_V (12916) - RISCV_INS_VSOXSEG6EI32_V - vsoxseg6ei32.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSOXSEG6EI64_V (12917) - RISCV_INS_VSOXSEG6EI64_V - vsoxseg6ei64.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSOXSEG6EI8_V (12918) - RISCV_INS_VSOXSEG6EI8_V - vsoxseg6ei8.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSOXSEG7EI16_V (12919) - RISCV_INS_VSOXSEG7EI16_V - vsoxseg7ei16.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSOXSEG7EI32_V (12920) - RISCV_INS_VSOXSEG7EI32_V - vsoxseg7ei32.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSOXSEG7EI64_V (12921) - RISCV_INS_VSOXSEG7EI64_V - vsoxseg7ei64.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSOXSEG7EI8_V (12922) - RISCV_INS_VSOXSEG7EI8_V - vsoxseg7ei8.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSOXSEG8EI16_V (12923) - RISCV_INS_VSOXSEG8EI16_V - vsoxseg8ei16.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSOXSEG8EI32_V (12924) - RISCV_INS_VSOXSEG8EI32_V - vsoxseg8ei32.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSOXSEG8EI64_V (12925) - RISCV_INS_VSOXSEG8EI64_V - vsoxseg8ei64.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSOXSEG8EI8_V (12926) - RISCV_INS_VSOXSEG8EI8_V - vsoxseg8ei8.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSRA_VI (12927) - RISCV_INS_VSRA_VI - vsra.vi $vd, $vs2, $imm$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSRA_VV (12928) - RISCV_INS_VSRA_VV - vsra.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSRA_VX (12929) - RISCV_INS_VSRA_VX - vsra.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSRL_VI (12930) - RISCV_INS_VSRL_VI - vsrl.vi $vd, $vs2, $imm$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSRL_VV (12931) - RISCV_INS_VSRL_VV - vsrl.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSRL_VX (12932) - RISCV_INS_VSRL_VX - vsrl.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSE16_V (12933) - RISCV_INS_VSSE16_V - vsse16.v $vs3, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSE32_V (12934) - RISCV_INS_VSSE32_V - vsse32.v $vs3, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSE64_V (12935) - RISCV_INS_VSSE64_V - vsse64.v $vs3, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSE8_V (12936) - RISCV_INS_VSSE8_V - vsse8.v $vs3, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSEG2E16_V (12937) - RISCV_INS_VSSEG2E16_V - vsseg2e16.v $vs3, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSEG2E32_V (12938) - RISCV_INS_VSSEG2E32_V - vsseg2e32.v $vs3, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSEG2E64_V (12939) - RISCV_INS_VSSEG2E64_V - vsseg2e64.v $vs3, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSEG2E8_V (12940) - RISCV_INS_VSSEG2E8_V - vsseg2e8.v $vs3, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSEG3E16_V (12941) - RISCV_INS_VSSEG3E16_V - vsseg3e16.v $vs3, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSEG3E32_V (12942) - RISCV_INS_VSSEG3E32_V - vsseg3e32.v $vs3, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSEG3E64_V (12943) - RISCV_INS_VSSEG3E64_V - vsseg3e64.v $vs3, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSEG3E8_V (12944) - RISCV_INS_VSSEG3E8_V - vsseg3e8.v $vs3, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSEG4E16_V (12945) - RISCV_INS_VSSEG4E16_V - vsseg4e16.v $vs3, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSEG4E32_V (12946) - RISCV_INS_VSSEG4E32_V - vsseg4e32.v $vs3, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSEG4E64_V (12947) - RISCV_INS_VSSEG4E64_V - vsseg4e64.v $vs3, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSEG4E8_V (12948) - RISCV_INS_VSSEG4E8_V - vsseg4e8.v $vs3, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSEG5E16_V (12949) - RISCV_INS_VSSEG5E16_V - vsseg5e16.v $vs3, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSEG5E32_V (12950) - RISCV_INS_VSSEG5E32_V - vsseg5e32.v $vs3, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSEG5E64_V (12951) - RISCV_INS_VSSEG5E64_V - vsseg5e64.v $vs3, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSEG5E8_V (12952) - RISCV_INS_VSSEG5E8_V - vsseg5e8.v $vs3, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSEG6E16_V (12953) - RISCV_INS_VSSEG6E16_V - vsseg6e16.v $vs3, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSEG6E32_V (12954) - RISCV_INS_VSSEG6E32_V - vsseg6e32.v $vs3, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSEG6E64_V (12955) - RISCV_INS_VSSEG6E64_V - vsseg6e64.v $vs3, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSEG6E8_V (12956) - RISCV_INS_VSSEG6E8_V - vsseg6e8.v $vs3, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSEG7E16_V (12957) - RISCV_INS_VSSEG7E16_V - vsseg7e16.v $vs3, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSEG7E32_V (12958) - RISCV_INS_VSSEG7E32_V - vsseg7e32.v $vs3, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSEG7E64_V (12959) - RISCV_INS_VSSEG7E64_V - vsseg7e64.v $vs3, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSEG7E8_V (12960) - RISCV_INS_VSSEG7E8_V - vsseg7e8.v $vs3, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSEG8E16_V (12961) - RISCV_INS_VSSEG8E16_V - vsseg8e16.v $vs3, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSEG8E32_V (12962) - RISCV_INS_VSSEG8E32_V - vsseg8e32.v $vs3, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSEG8E64_V (12963) - RISCV_INS_VSSEG8E64_V - vsseg8e64.v $vs3, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSEG8E8_V (12964) - RISCV_INS_VSSEG8E8_V - vsseg8e8.v $vs3, ${rs1}$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSRA_VI (12965) - RISCV_INS_VSSRA_VI - vssra.vi $vd, $vs2, $imm$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSRA_VV (12966) - RISCV_INS_VSSRA_VV - vssra.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSRA_VX (12967) - RISCV_INS_VSSRA_VX - vssra.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSRL_VI (12968) - RISCV_INS_VSSRL_VI - vssrl.vi $vd, $vs2, $imm$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSRL_VV (12969) - RISCV_INS_VSSRL_VV - vssrl.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSRL_VX (12970) - RISCV_INS_VSSRL_VX - vssrl.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSSEG2E16_V (12971) - RISCV_INS_VSSSEG2E16_V - vssseg2e16.v $vs3, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSSEG2E32_V (12972) - RISCV_INS_VSSSEG2E32_V - vssseg2e32.v $vs3, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSSEG2E64_V (12973) - RISCV_INS_VSSSEG2E64_V - vssseg2e64.v $vs3, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSSEG2E8_V (12974) - RISCV_INS_VSSSEG2E8_V - vssseg2e8.v $vs3, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSSEG3E16_V (12975) - RISCV_INS_VSSSEG3E16_V - vssseg3e16.v $vs3, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSSEG3E32_V (12976) - RISCV_INS_VSSSEG3E32_V - vssseg3e32.v $vs3, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSSEG3E64_V (12977) - RISCV_INS_VSSSEG3E64_V - vssseg3e64.v $vs3, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSSEG3E8_V (12978) - RISCV_INS_VSSSEG3E8_V - vssseg3e8.v $vs3, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSSEG4E16_V (12979) - RISCV_INS_VSSSEG4E16_V - vssseg4e16.v $vs3, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSSEG4E32_V (12980) - RISCV_INS_VSSSEG4E32_V - vssseg4e32.v $vs3, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSSEG4E64_V (12981) - RISCV_INS_VSSSEG4E64_V - vssseg4e64.v $vs3, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSSEG4E8_V (12982) - RISCV_INS_VSSSEG4E8_V - vssseg4e8.v $vs3, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSSEG5E16_V (12983) - RISCV_INS_VSSSEG5E16_V - vssseg5e16.v $vs3, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSSEG5E32_V (12984) - RISCV_INS_VSSSEG5E32_V - vssseg5e32.v $vs3, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSSEG5E64_V (12985) - RISCV_INS_VSSSEG5E64_V - vssseg5e64.v $vs3, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSSEG5E8_V (12986) - RISCV_INS_VSSSEG5E8_V - vssseg5e8.v $vs3, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSSEG6E16_V (12987) - RISCV_INS_VSSSEG6E16_V - vssseg6e16.v $vs3, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSSEG6E32_V (12988) - RISCV_INS_VSSSEG6E32_V - vssseg6e32.v $vs3, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSSEG6E64_V (12989) - RISCV_INS_VSSSEG6E64_V - vssseg6e64.v $vs3, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSSEG6E8_V (12990) - RISCV_INS_VSSSEG6E8_V - vssseg6e8.v $vs3, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSSEG7E16_V (12991) - RISCV_INS_VSSSEG7E16_V - vssseg7e16.v $vs3, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSSEG7E32_V (12992) - RISCV_INS_VSSSEG7E32_V - vssseg7e32.v $vs3, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSSEG7E64_V (12993) - RISCV_INS_VSSSEG7E64_V - vssseg7e64.v $vs3, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSSEG7E8_V (12994) - RISCV_INS_VSSSEG7E8_V - vssseg7e8.v $vs3, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSSEG8E16_V (12995) - RISCV_INS_VSSSEG8E16_V - vssseg8e16.v $vs3, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSSEG8E32_V (12996) - RISCV_INS_VSSSEG8E32_V - vssseg8e32.v $vs3, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSSEG8E64_V (12997) - RISCV_INS_VSSSEG8E64_V - vssseg8e64.v $vs3, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSSEG8E8_V (12998) - RISCV_INS_VSSSEG8E8_V - vssseg8e8.v $vs3, $rs1, $rs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSUBU_VV (12999) - RISCV_INS_VSSUBU_VV - vssubu.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSUBU_VX (13000) - RISCV_INS_VSSUBU_VX - vssubu.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSUB_VV (13001) - RISCV_INS_VSSUB_VV - vssub.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSSUB_VX (13002) - RISCV_INS_VSSUB_VX - vssub.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSUB_VV (13003) - RISCV_INS_VSUB_VV - vsub.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSUB_VX (13004) - RISCV_INS_VSUB_VX - vsub.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSUXEI16_V (13005) - RISCV_INS_VSUXEI16_V - vsuxei16.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSUXEI32_V (13006) - RISCV_INS_VSUXEI32_V - vsuxei32.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSUXEI64_V (13007) - RISCV_INS_VSUXEI64_V - vsuxei64.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSUXEI8_V (13008) - RISCV_INS_VSUXEI8_V - vsuxei8.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSUXSEG2EI16_V (13009) - RISCV_INS_VSUXSEG2EI16_V - vsuxseg2ei16.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSUXSEG2EI32_V (13010) - RISCV_INS_VSUXSEG2EI32_V - vsuxseg2ei32.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSUXSEG2EI64_V (13011) - RISCV_INS_VSUXSEG2EI64_V - vsuxseg2ei64.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSUXSEG2EI8_V (13012) - RISCV_INS_VSUXSEG2EI8_V - vsuxseg2ei8.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSUXSEG3EI16_V (13013) - RISCV_INS_VSUXSEG3EI16_V - vsuxseg3ei16.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSUXSEG3EI32_V (13014) - RISCV_INS_VSUXSEG3EI32_V - vsuxseg3ei32.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSUXSEG3EI64_V (13015) - RISCV_INS_VSUXSEG3EI64_V - vsuxseg3ei64.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSUXSEG3EI8_V (13016) - RISCV_INS_VSUXSEG3EI8_V - vsuxseg3ei8.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSUXSEG4EI16_V (13017) - RISCV_INS_VSUXSEG4EI16_V - vsuxseg4ei16.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSUXSEG4EI32_V (13018) - RISCV_INS_VSUXSEG4EI32_V - vsuxseg4ei32.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSUXSEG4EI64_V (13019) - RISCV_INS_VSUXSEG4EI64_V - vsuxseg4ei64.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSUXSEG4EI8_V (13020) - RISCV_INS_VSUXSEG4EI8_V - vsuxseg4ei8.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSUXSEG5EI16_V (13021) - RISCV_INS_VSUXSEG5EI16_V - vsuxseg5ei16.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSUXSEG5EI32_V (13022) - RISCV_INS_VSUXSEG5EI32_V - vsuxseg5ei32.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSUXSEG5EI64_V (13023) - RISCV_INS_VSUXSEG5EI64_V - vsuxseg5ei64.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSUXSEG5EI8_V (13024) - RISCV_INS_VSUXSEG5EI8_V - vsuxseg5ei8.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSUXSEG6EI16_V (13025) - RISCV_INS_VSUXSEG6EI16_V - vsuxseg6ei16.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSUXSEG6EI32_V (13026) - RISCV_INS_VSUXSEG6EI32_V - vsuxseg6ei32.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSUXSEG6EI64_V (13027) - RISCV_INS_VSUXSEG6EI64_V - vsuxseg6ei64.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSUXSEG6EI8_V (13028) - RISCV_INS_VSUXSEG6EI8_V - vsuxseg6ei8.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSUXSEG7EI16_V (13029) - RISCV_INS_VSUXSEG7EI16_V - vsuxseg7ei16.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSUXSEG7EI32_V (13030) - RISCV_INS_VSUXSEG7EI32_V - vsuxseg7ei32.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSUXSEG7EI64_V (13031) - RISCV_INS_VSUXSEG7EI64_V - vsuxseg7ei64.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSUXSEG7EI8_V (13032) - RISCV_INS_VSUXSEG7EI8_V - vsuxseg7ei8.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSUXSEG8EI16_V (13033) - RISCV_INS_VSUXSEG8EI16_V - vsuxseg8ei16.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSUXSEG8EI32_V (13034) - RISCV_INS_VSUXSEG8EI32_V - vsuxseg8ei32.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSUXSEG8EI64_V (13035) - RISCV_INS_VSUXSEG8EI64_V - vsuxseg8ei64.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VSUXSEG8EI8_V (13036) - RISCV_INS_VSUXSEG8EI8_V - vsuxseg8ei8.v $vs3, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs3 */ + { CS_OP_MEM | CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VT_MASKC (13037) - RISCV_INS_VT_MASKC - vt.maskc $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_VT_MASKCN (13038) - RISCV_INS_VT_MASKCN - vt.maskcn $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_VWADDU_VV (13039) - RISCV_INS_VWADDU_VV - vwaddu.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VWADDU_VX (13040) - RISCV_INS_VWADDU_VX - vwaddu.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VWADDU_WV (13041) - RISCV_INS_VWADDU_WV - vwaddu.wv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VWADDU_WX (13042) - RISCV_INS_VWADDU_WX - vwaddu.wx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VWADD_VV (13043) - RISCV_INS_VWADD_VV - vwadd.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VWADD_VX (13044) - RISCV_INS_VWADD_VX - vwadd.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VWADD_WV (13045) - RISCV_INS_VWADD_WV - vwadd.wv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VWADD_WX (13046) - RISCV_INS_VWADD_WX - vwadd.wx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VWMACCSU_VV (13047) - RISCV_INS_VWMACCSU_VV - vwmaccsu.vv $vd, $vs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VWMACCSU_VX (13048) - RISCV_INS_VWMACCSU_VX - vwmaccsu.vx $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VWMACCUS_VX (13049) - RISCV_INS_VWMACCUS_VX - vwmaccus.vx $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VWMACCU_VV (13050) - RISCV_INS_VWMACCU_VV - vwmaccu.vv $vd, $vs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VWMACCU_VX (13051) - RISCV_INS_VWMACCU_VX - vwmaccu.vx $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VWMACC_VV (13052) - RISCV_INS_VWMACC_VV - vwmacc.vv $vd, $vs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VWMACC_VX (13053) - RISCV_INS_VWMACC_VX - vwmacc.vx $vd, $rs1, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd_wb */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VWMULSU_VV (13054) - RISCV_INS_VWMULSU_VV - vwmulsu.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VWMULSU_VX (13055) - RISCV_INS_VWMULSU_VX - vwmulsu.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VWMULU_VV (13056) - RISCV_INS_VWMULU_VV - vwmulu.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VWMULU_VX (13057) - RISCV_INS_VWMULU_VX - vwmulu.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VWMUL_VV (13058) - RISCV_INS_VWMUL_VV - vwmul.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VWMUL_VX (13059) - RISCV_INS_VWMUL_VX - vwmul.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VWREDSUMU_VS (13060) - RISCV_INS_VWREDSUMU_VS - vwredsumu.vs $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VWREDSUM_VS (13061) - RISCV_INS_VWREDSUM_VS - vwredsum.vs $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VWSLL_VI (13062) - RISCV_INS_VWSLL_VI - vwsll.vi $vd, $vs2, $imm$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VWSLL_VV (13063) - RISCV_INS_VWSLL_VV - vwsll.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VWSLL_VX (13064) - RISCV_INS_VWSLL_VX - vwsll.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VWSUBU_VV (13065) - RISCV_INS_VWSUBU_VV - vwsubu.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VWSUBU_VX (13066) - RISCV_INS_VWSUBU_VX - vwsubu.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VWSUBU_WV (13067) - RISCV_INS_VWSUBU_WV - vwsubu.wv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VWSUBU_WX (13068) - RISCV_INS_VWSUBU_WX - vwsubu.wx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VWSUB_VV (13069) - RISCV_INS_VWSUB_VV - vwsub.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VWSUB_VX (13070) - RISCV_INS_VWSUB_VX - vwsub.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VWSUB_WV (13071) - RISCV_INS_VWSUB_WV - vwsub.wv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VWSUB_WX (13072) - RISCV_INS_VWSUB_WX - vwsub.wx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VXOR_VI (13073) - RISCV_INS_VXOR_VI - vxor.vi $vd, $vs2, $imm$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VXOR_VV (13074) - RISCV_INS_VXOR_VV - vxor.vv $vd, $vs2, $vs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VXOR_VX (13075) - RISCV_INS_VXOR_VX - vxor.vx $vd, $vs2, $rs1$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VZEXT_VF2 (13076) - RISCV_INS_VZEXT_VF2 - vzext.vf2 $vd, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VZEXT_VF4 (13077) - RISCV_INS_VZEXT_VF4 - vzext.vf4 $vd, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_VZEXT_VF8 (13078) - RISCV_INS_VZEXT_VF8 - vzext.vf8 $vd, $vs2$vm */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv8i8, CS_DATA_TYPE_nxv4i16, CS_DATA_TYPE_nxv2i32, CS_DATA_TYPE_nxv1i64, CS_DATA_TYPE_nxv4bf16, CS_DATA_TYPE_nxv4f16, CS_DATA_TYPE_nxv2f32, CS_DATA_TYPE_nxv1f64, CS_DATA_TYPE_nxv4i8, CS_DATA_TYPE_nxv2i8, CS_DATA_TYPE_nxv1i8, CS_DATA_TYPE_nxv2i16, CS_DATA_TYPE_nxv1i16, CS_DATA_TYPE_nxv1i32, CS_DATA_TYPE_nxv1f16, CS_DATA_TYPE_nxv2f16, CS_DATA_TYPE_nxv1bf16, CS_DATA_TYPE_nxv2bf16, CS_DATA_TYPE_nxv1f32, CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vs2 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_nxv64i1, CS_DATA_TYPE_nxv32i1, CS_DATA_TYPE_nxv16i1, CS_DATA_TYPE_nxv8i1, CS_DATA_TYPE_nxv4i1, CS_DATA_TYPE_nxv2i1, CS_DATA_TYPE_nxv1i1, CS_DATA_TYPE_LAST } }, /* vm */ + { 0 } +}}, +{ /* RISCV_WFI (13079) - RISCV_INS_WFI - wfi */ +{ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_WRS_NTO (13080) - RISCV_INS_WRS_NTO - wrs.nto */ +{ + { 0 } +}}, +{ /* RISCV_WRS_STO (13081) - RISCV_INS_WRS_STO - wrs.sto */ +{ + { 0 } +}}, +{ /* RISCV_XNOR (13082) - RISCV_INS_XNOR - xnor $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_XOR (13083) - RISCV_INS_XOR - xor $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_XORI (13084) - RISCV_INS_XORI - xori $rd, $rs1, $imm12 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_LAST } }, /* imm12 */ + { 0 } +}}, +{ /* RISCV_XPERM4 (13085) - RISCV_INS_XPERM4 - xperm4 $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_XPERM8 (13086) - RISCV_INS_XPERM8 - xperm8 $rd, $rs1, $rs2 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs2 */ + { 0 } +}}, +{ /* RISCV_ZEXT_H_RV32 (13087) - RISCV_INS_ZEXT_H - zext.h $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_ZEXT_H_RV64 (13088) - RISCV_INS_ZEXT_H - zext.h $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, +{ /* RISCV_ZIP_RV32 (13089) - RISCV_INS_ZIP - zip $rd, $rs1 */ +{ + { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rd */ + { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_INVALID_SIMPLE_VALUE_TYPE, CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST } }, /* rs1 */ + { 0 } +}}, diff --git a/arch/RISCV/RISCVGenCSOpGroup.inc b/arch/RISCV/RISCVGenCSOpGroup.inc new file mode 100644 index 0000000000..e97c9ed6ae --- /dev/null +++ b/arch/RISCV/RISCVGenCSOpGroup.inc @@ -0,0 +1,26 @@ +/* Capstone Disassembly Engine, https://www.capstone-engine.org */ +/* By Nguyen Anh Quynh , 2013-2022, */ +/* Rot127 2022-2024 */ +/* Automatically generated file by Capstone's LLVM TableGen Disassembler Backend. */ + +/* LLVM-commit: */ +/* LLVM-tag: */ + +/* Do not edit. */ + +/* Capstone's LLVM TableGen Backends: */ +/* https://github.com/capstone-engine/llvm-capstone */ + + RISCV_OP_GROUP_Operand = 0, + RISCV_OP_GROUP_BranchOperand = 1, + RISCV_OP_GROUP_VMaskReg = 2, + RISCV_OP_GROUP_VTypeI = 3, + RISCV_OP_GROUP_ZeroOffsetMemOp = 4, + RISCV_OP_GROUP_Rlist = 5, + RISCV_OP_GROUP_Spimm = 6, + RISCV_OP_GROUP_CSRSystemRegister = 7, + RISCV_OP_GROUP_RegReg = 8, + RISCV_OP_GROUP_FRMArg = 9, + RISCV_OP_GROUP_FRMArgLegacy = 10, + RISCV_OP_GROUP_FenceArg = 11, + RISCV_OP_GROUP_FPImmOperand = 12, diff --git a/arch/RISCV/RISCVGenCSRegEnum.inc b/arch/RISCV/RISCVGenCSRegEnum.inc new file mode 100644 index 0000000000..e31f7b3ecf --- /dev/null +++ b/arch/RISCV/RISCVGenCSRegEnum.inc @@ -0,0 +1,473 @@ +/* Capstone Disassembly Engine, https://www.capstone-engine.org */ +/* By Nguyen Anh Quynh , 2013-2022, */ +/* Rot127 2022-2024 */ +/* Automatically generated file by Capstone's LLVM TableGen Disassembler Backend. */ + +/* LLVM-commit: */ +/* LLVM-tag: */ + +/* Do not edit. */ + +/* Capstone's LLVM TableGen Backends: */ +/* https://github.com/capstone-engine/llvm-capstone */ + + RISCV_REG_INVALID = 0, + RISCV_REG_FFLAGS = 1, + RISCV_REG_FRM = 2, + RISCV_REG_SSP = 3, + RISCV_REG_VL = 4, + RISCV_REG_VLENB = 5, + RISCV_REG_VTYPE = 6, + RISCV_REG_VXRM = 7, + RISCV_REG_VXSAT = 8, + RISCV_REG_DUMMY_REG_PAIR_WITH_X0 = 9, + RISCV_REG_V0 = 10, + RISCV_REG_V1 = 11, + RISCV_REG_V2 = 12, + RISCV_REG_V3 = 13, + RISCV_REG_V4 = 14, + RISCV_REG_V5 = 15, + RISCV_REG_V6 = 16, + RISCV_REG_V7 = 17, + RISCV_REG_V8 = 18, + RISCV_REG_V9 = 19, + RISCV_REG_V10 = 20, + RISCV_REG_V11 = 21, + RISCV_REG_V12 = 22, + RISCV_REG_V13 = 23, + RISCV_REG_V14 = 24, + RISCV_REG_V15 = 25, + RISCV_REG_V16 = 26, + RISCV_REG_V17 = 27, + RISCV_REG_V18 = 28, + RISCV_REG_V19 = 29, + RISCV_REG_V20 = 30, + RISCV_REG_V21 = 31, + RISCV_REG_V22 = 32, + RISCV_REG_V23 = 33, + RISCV_REG_V24 = 34, + RISCV_REG_V25 = 35, + RISCV_REG_V26 = 36, + RISCV_REG_V27 = 37, + RISCV_REG_V28 = 38, + RISCV_REG_V29 = 39, + RISCV_REG_V30 = 40, + RISCV_REG_V31 = 41, + RISCV_REG_X0 = 42, + RISCV_REG_X1 = 43, + RISCV_REG_X2 = 44, + RISCV_REG_X3 = 45, + RISCV_REG_X4 = 46, + RISCV_REG_X5 = 47, + RISCV_REG_X6 = 48, + RISCV_REG_X7 = 49, + RISCV_REG_X8 = 50, + RISCV_REG_X9 = 51, + RISCV_REG_X10 = 52, + RISCV_REG_X11 = 53, + RISCV_REG_X12 = 54, + RISCV_REG_X13 = 55, + RISCV_REG_X14 = 56, + RISCV_REG_X15 = 57, + RISCV_REG_X16 = 58, + RISCV_REG_X17 = 59, + RISCV_REG_X18 = 60, + RISCV_REG_X19 = 61, + RISCV_REG_X20 = 62, + RISCV_REG_X21 = 63, + RISCV_REG_X22 = 64, + RISCV_REG_X23 = 65, + RISCV_REG_X24 = 66, + RISCV_REG_X25 = 67, + RISCV_REG_X26 = 68, + RISCV_REG_X27 = 69, + RISCV_REG_X28 = 70, + RISCV_REG_X29 = 71, + RISCV_REG_X30 = 72, + RISCV_REG_X31 = 73, + RISCV_REG_F0_D = 74, + RISCV_REG_F1_D = 75, + RISCV_REG_F2_D = 76, + RISCV_REG_F3_D = 77, + RISCV_REG_F4_D = 78, + RISCV_REG_F5_D = 79, + RISCV_REG_F6_D = 80, + RISCV_REG_F7_D = 81, + RISCV_REG_F8_D = 82, + RISCV_REG_F9_D = 83, + RISCV_REG_F10_D = 84, + RISCV_REG_F11_D = 85, + RISCV_REG_F12_D = 86, + RISCV_REG_F13_D = 87, + RISCV_REG_F14_D = 88, + RISCV_REG_F15_D = 89, + RISCV_REG_F16_D = 90, + RISCV_REG_F17_D = 91, + RISCV_REG_F18_D = 92, + RISCV_REG_F19_D = 93, + RISCV_REG_F20_D = 94, + RISCV_REG_F21_D = 95, + RISCV_REG_F22_D = 96, + RISCV_REG_F23_D = 97, + RISCV_REG_F24_D = 98, + RISCV_REG_F25_D = 99, + RISCV_REG_F26_D = 100, + RISCV_REG_F27_D = 101, + RISCV_REG_F28_D = 102, + RISCV_REG_F29_D = 103, + RISCV_REG_F30_D = 104, + RISCV_REG_F31_D = 105, + RISCV_REG_F0_F = 106, + RISCV_REG_F1_F = 107, + RISCV_REG_F2_F = 108, + RISCV_REG_F3_F = 109, + RISCV_REG_F4_F = 110, + RISCV_REG_F5_F = 111, + RISCV_REG_F6_F = 112, + RISCV_REG_F7_F = 113, + RISCV_REG_F8_F = 114, + RISCV_REG_F9_F = 115, + RISCV_REG_F10_F = 116, + RISCV_REG_F11_F = 117, + RISCV_REG_F12_F = 118, + RISCV_REG_F13_F = 119, + RISCV_REG_F14_F = 120, + RISCV_REG_F15_F = 121, + RISCV_REG_F16_F = 122, + RISCV_REG_F17_F = 123, + RISCV_REG_F18_F = 124, + RISCV_REG_F19_F = 125, + RISCV_REG_F20_F = 126, + RISCV_REG_F21_F = 127, + RISCV_REG_F22_F = 128, + RISCV_REG_F23_F = 129, + RISCV_REG_F24_F = 130, + RISCV_REG_F25_F = 131, + RISCV_REG_F26_F = 132, + RISCV_REG_F27_F = 133, + RISCV_REG_F28_F = 134, + RISCV_REG_F29_F = 135, + RISCV_REG_F30_F = 136, + RISCV_REG_F31_F = 137, + RISCV_REG_F0_H = 138, + RISCV_REG_F1_H = 139, + RISCV_REG_F2_H = 140, + RISCV_REG_F3_H = 141, + RISCV_REG_F4_H = 142, + RISCV_REG_F5_H = 143, + RISCV_REG_F6_H = 144, + RISCV_REG_F7_H = 145, + RISCV_REG_F8_H = 146, + RISCV_REG_F9_H = 147, + RISCV_REG_F10_H = 148, + RISCV_REG_F11_H = 149, + RISCV_REG_F12_H = 150, + RISCV_REG_F13_H = 151, + RISCV_REG_F14_H = 152, + RISCV_REG_F15_H = 153, + RISCV_REG_F16_H = 154, + RISCV_REG_F17_H = 155, + RISCV_REG_F18_H = 156, + RISCV_REG_F19_H = 157, + RISCV_REG_F20_H = 158, + RISCV_REG_F21_H = 159, + RISCV_REG_F22_H = 160, + RISCV_REG_F23_H = 161, + RISCV_REG_F24_H = 162, + RISCV_REG_F25_H = 163, + RISCV_REG_F26_H = 164, + RISCV_REG_F27_H = 165, + RISCV_REG_F28_H = 166, + RISCV_REG_F29_H = 167, + RISCV_REG_F30_H = 168, + RISCV_REG_F31_H = 169, + RISCV_REG_X0_PAIR = 170, + RISCV_REG_V0M2 = 171, + RISCV_REG_V0M4 = 172, + RISCV_REG_V0M8 = 173, + RISCV_REG_V2M2 = 174, + RISCV_REG_V4M2 = 175, + RISCV_REG_V4M4 = 176, + RISCV_REG_V6M2 = 177, + RISCV_REG_V8M2 = 178, + RISCV_REG_V8M4 = 179, + RISCV_REG_V8M8 = 180, + RISCV_REG_V10M2 = 181, + RISCV_REG_V12M2 = 182, + RISCV_REG_V12M4 = 183, + RISCV_REG_V14M2 = 184, + RISCV_REG_V16M2 = 185, + RISCV_REG_V16M4 = 186, + RISCV_REG_V16M8 = 187, + RISCV_REG_V18M2 = 188, + RISCV_REG_V20M2 = 189, + RISCV_REG_V20M4 = 190, + RISCV_REG_V22M2 = 191, + RISCV_REG_V24M2 = 192, + RISCV_REG_V24M4 = 193, + RISCV_REG_V24M8 = 194, + RISCV_REG_V26M2 = 195, + RISCV_REG_V28M2 = 196, + RISCV_REG_V28M4 = 197, + RISCV_REG_V30M2 = 198, + RISCV_REG_X2_X3 = 199, + RISCV_REG_X4_X5 = 200, + RISCV_REG_X6_X7 = 201, + RISCV_REG_X8_X9 = 202, + RISCV_REG_X10_X11 = 203, + RISCV_REG_X12_X13 = 204, + RISCV_REG_X14_X15 = 205, + RISCV_REG_X16_X17 = 206, + RISCV_REG_X18_X19 = 207, + RISCV_REG_X20_X21 = 208, + RISCV_REG_X22_X23 = 209, + RISCV_REG_X24_X25 = 210, + RISCV_REG_X26_X27 = 211, + RISCV_REG_X28_X29 = 212, + RISCV_REG_X30_X31 = 213, + RISCV_REG_V1_V2 = 214, + RISCV_REG_V2_V3 = 215, + RISCV_REG_V3_V4 = 216, + RISCV_REG_V4_V5 = 217, + RISCV_REG_V5_V6 = 218, + RISCV_REG_V6_V7 = 219, + RISCV_REG_V7_V8 = 220, + RISCV_REG_V8_V9 = 221, + RISCV_REG_V9_V10 = 222, + RISCV_REG_V10_V11 = 223, + RISCV_REG_V11_V12 = 224, + RISCV_REG_V12_V13 = 225, + RISCV_REG_V13_V14 = 226, + RISCV_REG_V14_V15 = 227, + RISCV_REG_V15_V16 = 228, + RISCV_REG_V16_V17 = 229, + RISCV_REG_V17_V18 = 230, + RISCV_REG_V18_V19 = 231, + RISCV_REG_V19_V20 = 232, + RISCV_REG_V20_V21 = 233, + RISCV_REG_V21_V22 = 234, + RISCV_REG_V22_V23 = 235, + RISCV_REG_V23_V24 = 236, + RISCV_REG_V24_V25 = 237, + RISCV_REG_V25_V26 = 238, + RISCV_REG_V26_V27 = 239, + RISCV_REG_V27_V28 = 240, + RISCV_REG_V28_V29 = 241, + RISCV_REG_V29_V30 = 242, + RISCV_REG_V30_V31 = 243, + RISCV_REG_V0_V1 = 244, + RISCV_REG_V2M2_V4M2 = 245, + RISCV_REG_V4M2_V6M2 = 246, + RISCV_REG_V6M2_V8M2 = 247, + RISCV_REG_V8M2_V10M2 = 248, + RISCV_REG_V10M2_V12M2 = 249, + RISCV_REG_V12M2_V14M2 = 250, + RISCV_REG_V14M2_V16M2 = 251, + RISCV_REG_V16M2_V18M2 = 252, + RISCV_REG_V18M2_V20M2 = 253, + RISCV_REG_V20M2_V22M2 = 254, + RISCV_REG_V22M2_V24M2 = 255, + RISCV_REG_V24M2_V26M2 = 256, + RISCV_REG_V26M2_V28M2 = 257, + RISCV_REG_V28M2_V30M2 = 258, + RISCV_REG_V0M2_V2M2 = 259, + RISCV_REG_V4M4_V8M4 = 260, + RISCV_REG_V8M4_V12M4 = 261, + RISCV_REG_V12M4_V16M4 = 262, + RISCV_REG_V16M4_V20M4 = 263, + RISCV_REG_V20M4_V24M4 = 264, + RISCV_REG_V24M4_V28M4 = 265, + RISCV_REG_V0M4_V4M4 = 266, + RISCV_REG_V1_V2_V3 = 267, + RISCV_REG_V2_V3_V4 = 268, + RISCV_REG_V3_V4_V5 = 269, + RISCV_REG_V4_V5_V6 = 270, + RISCV_REG_V5_V6_V7 = 271, + RISCV_REG_V6_V7_V8 = 272, + RISCV_REG_V7_V8_V9 = 273, + RISCV_REG_V8_V9_V10 = 274, + RISCV_REG_V9_V10_V11 = 275, + RISCV_REG_V10_V11_V12 = 276, + RISCV_REG_V11_V12_V13 = 277, + RISCV_REG_V12_V13_V14 = 278, + RISCV_REG_V13_V14_V15 = 279, + RISCV_REG_V14_V15_V16 = 280, + RISCV_REG_V15_V16_V17 = 281, + RISCV_REG_V16_V17_V18 = 282, + RISCV_REG_V17_V18_V19 = 283, + RISCV_REG_V18_V19_V20 = 284, + RISCV_REG_V19_V20_V21 = 285, + RISCV_REG_V20_V21_V22 = 286, + RISCV_REG_V21_V22_V23 = 287, + RISCV_REG_V22_V23_V24 = 288, + RISCV_REG_V23_V24_V25 = 289, + RISCV_REG_V24_V25_V26 = 290, + RISCV_REG_V25_V26_V27 = 291, + RISCV_REG_V26_V27_V28 = 292, + RISCV_REG_V27_V28_V29 = 293, + RISCV_REG_V28_V29_V30 = 294, + RISCV_REG_V29_V30_V31 = 295, + RISCV_REG_V0_V1_V2 = 296, + RISCV_REG_V2M2_V4M2_V6M2 = 297, + RISCV_REG_V4M2_V6M2_V8M2 = 298, + RISCV_REG_V6M2_V8M2_V10M2 = 299, + RISCV_REG_V8M2_V10M2_V12M2 = 300, + RISCV_REG_V10M2_V12M2_V14M2 = 301, + RISCV_REG_V12M2_V14M2_V16M2 = 302, + RISCV_REG_V14M2_V16M2_V18M2 = 303, + RISCV_REG_V16M2_V18M2_V20M2 = 304, + RISCV_REG_V18M2_V20M2_V22M2 = 305, + RISCV_REG_V20M2_V22M2_V24M2 = 306, + RISCV_REG_V22M2_V24M2_V26M2 = 307, + RISCV_REG_V24M2_V26M2_V28M2 = 308, + RISCV_REG_V26M2_V28M2_V30M2 = 309, + RISCV_REG_V0M2_V2M2_V4M2 = 310, + RISCV_REG_V1_V2_V3_V4 = 311, + RISCV_REG_V2_V3_V4_V5 = 312, + RISCV_REG_V3_V4_V5_V6 = 313, + RISCV_REG_V4_V5_V6_V7 = 314, + RISCV_REG_V5_V6_V7_V8 = 315, + RISCV_REG_V6_V7_V8_V9 = 316, + RISCV_REG_V7_V8_V9_V10 = 317, + RISCV_REG_V8_V9_V10_V11 = 318, + RISCV_REG_V9_V10_V11_V12 = 319, + RISCV_REG_V10_V11_V12_V13 = 320, + RISCV_REG_V11_V12_V13_V14 = 321, + RISCV_REG_V12_V13_V14_V15 = 322, + RISCV_REG_V13_V14_V15_V16 = 323, + RISCV_REG_V14_V15_V16_V17 = 324, + RISCV_REG_V15_V16_V17_V18 = 325, + RISCV_REG_V16_V17_V18_V19 = 326, + RISCV_REG_V17_V18_V19_V20 = 327, + RISCV_REG_V18_V19_V20_V21 = 328, + RISCV_REG_V19_V20_V21_V22 = 329, + RISCV_REG_V20_V21_V22_V23 = 330, + RISCV_REG_V21_V22_V23_V24 = 331, + RISCV_REG_V22_V23_V24_V25 = 332, + RISCV_REG_V23_V24_V25_V26 = 333, + RISCV_REG_V24_V25_V26_V27 = 334, + RISCV_REG_V25_V26_V27_V28 = 335, + RISCV_REG_V26_V27_V28_V29 = 336, + RISCV_REG_V27_V28_V29_V30 = 337, + RISCV_REG_V28_V29_V30_V31 = 338, + RISCV_REG_V0_V1_V2_V3 = 339, + RISCV_REG_V2M2_V4M2_V6M2_V8M2 = 340, + RISCV_REG_V4M2_V6M2_V8M2_V10M2 = 341, + RISCV_REG_V6M2_V8M2_V10M2_V12M2 = 342, + RISCV_REG_V8M2_V10M2_V12M2_V14M2 = 343, + RISCV_REG_V10M2_V12M2_V14M2_V16M2 = 344, + RISCV_REG_V12M2_V14M2_V16M2_V18M2 = 345, + RISCV_REG_V14M2_V16M2_V18M2_V20M2 = 346, + RISCV_REG_V16M2_V18M2_V20M2_V22M2 = 347, + RISCV_REG_V18M2_V20M2_V22M2_V24M2 = 348, + RISCV_REG_V20M2_V22M2_V24M2_V26M2 = 349, + RISCV_REG_V22M2_V24M2_V26M2_V28M2 = 350, + RISCV_REG_V24M2_V26M2_V28M2_V30M2 = 351, + RISCV_REG_V0M2_V2M2_V4M2_V6M2 = 352, + RISCV_REG_V1_V2_V3_V4_V5 = 353, + RISCV_REG_V2_V3_V4_V5_V6 = 354, + RISCV_REG_V3_V4_V5_V6_V7 = 355, + RISCV_REG_V4_V5_V6_V7_V8 = 356, + RISCV_REG_V5_V6_V7_V8_V9 = 357, + RISCV_REG_V6_V7_V8_V9_V10 = 358, + RISCV_REG_V7_V8_V9_V10_V11 = 359, + RISCV_REG_V8_V9_V10_V11_V12 = 360, + RISCV_REG_V9_V10_V11_V12_V13 = 361, + RISCV_REG_V10_V11_V12_V13_V14 = 362, + RISCV_REG_V11_V12_V13_V14_V15 = 363, + RISCV_REG_V12_V13_V14_V15_V16 = 364, + RISCV_REG_V13_V14_V15_V16_V17 = 365, + RISCV_REG_V14_V15_V16_V17_V18 = 366, + RISCV_REG_V15_V16_V17_V18_V19 = 367, + RISCV_REG_V16_V17_V18_V19_V20 = 368, + RISCV_REG_V17_V18_V19_V20_V21 = 369, + RISCV_REG_V18_V19_V20_V21_V22 = 370, + RISCV_REG_V19_V20_V21_V22_V23 = 371, + RISCV_REG_V20_V21_V22_V23_V24 = 372, + RISCV_REG_V21_V22_V23_V24_V25 = 373, + RISCV_REG_V22_V23_V24_V25_V26 = 374, + RISCV_REG_V23_V24_V25_V26_V27 = 375, + RISCV_REG_V24_V25_V26_V27_V28 = 376, + RISCV_REG_V25_V26_V27_V28_V29 = 377, + RISCV_REG_V26_V27_V28_V29_V30 = 378, + RISCV_REG_V27_V28_V29_V30_V31 = 379, + RISCV_REG_V0_V1_V2_V3_V4 = 380, + RISCV_REG_V1_V2_V3_V4_V5_V6 = 381, + RISCV_REG_V2_V3_V4_V5_V6_V7 = 382, + RISCV_REG_V3_V4_V5_V6_V7_V8 = 383, + RISCV_REG_V4_V5_V6_V7_V8_V9 = 384, + RISCV_REG_V5_V6_V7_V8_V9_V10 = 385, + RISCV_REG_V6_V7_V8_V9_V10_V11 = 386, + RISCV_REG_V7_V8_V9_V10_V11_V12 = 387, + RISCV_REG_V8_V9_V10_V11_V12_V13 = 388, + RISCV_REG_V9_V10_V11_V12_V13_V14 = 389, + RISCV_REG_V10_V11_V12_V13_V14_V15 = 390, + RISCV_REG_V11_V12_V13_V14_V15_V16 = 391, + RISCV_REG_V12_V13_V14_V15_V16_V17 = 392, + RISCV_REG_V13_V14_V15_V16_V17_V18 = 393, + RISCV_REG_V14_V15_V16_V17_V18_V19 = 394, + RISCV_REG_V15_V16_V17_V18_V19_V20 = 395, + RISCV_REG_V16_V17_V18_V19_V20_V21 = 396, + RISCV_REG_V17_V18_V19_V20_V21_V22 = 397, + RISCV_REG_V18_V19_V20_V21_V22_V23 = 398, + RISCV_REG_V19_V20_V21_V22_V23_V24 = 399, + RISCV_REG_V20_V21_V22_V23_V24_V25 = 400, + RISCV_REG_V21_V22_V23_V24_V25_V26 = 401, + RISCV_REG_V22_V23_V24_V25_V26_V27 = 402, + RISCV_REG_V23_V24_V25_V26_V27_V28 = 403, + RISCV_REG_V24_V25_V26_V27_V28_V29 = 404, + RISCV_REG_V25_V26_V27_V28_V29_V30 = 405, + RISCV_REG_V26_V27_V28_V29_V30_V31 = 406, + RISCV_REG_V0_V1_V2_V3_V4_V5 = 407, + RISCV_REG_V1_V2_V3_V4_V5_V6_V7 = 408, + RISCV_REG_V2_V3_V4_V5_V6_V7_V8 = 409, + RISCV_REG_V3_V4_V5_V6_V7_V8_V9 = 410, + RISCV_REG_V4_V5_V6_V7_V8_V9_V10 = 411, + RISCV_REG_V5_V6_V7_V8_V9_V10_V11 = 412, + RISCV_REG_V6_V7_V8_V9_V10_V11_V12 = 413, + RISCV_REG_V7_V8_V9_V10_V11_V12_V13 = 414, + RISCV_REG_V8_V9_V10_V11_V12_V13_V14 = 415, + RISCV_REG_V9_V10_V11_V12_V13_V14_V15 = 416, + RISCV_REG_V10_V11_V12_V13_V14_V15_V16 = 417, + RISCV_REG_V11_V12_V13_V14_V15_V16_V17 = 418, + RISCV_REG_V12_V13_V14_V15_V16_V17_V18 = 419, + RISCV_REG_V13_V14_V15_V16_V17_V18_V19 = 420, + RISCV_REG_V14_V15_V16_V17_V18_V19_V20 = 421, + RISCV_REG_V15_V16_V17_V18_V19_V20_V21 = 422, + RISCV_REG_V16_V17_V18_V19_V20_V21_V22 = 423, + RISCV_REG_V17_V18_V19_V20_V21_V22_V23 = 424, + RISCV_REG_V18_V19_V20_V21_V22_V23_V24 = 425, + RISCV_REG_V19_V20_V21_V22_V23_V24_V25 = 426, + RISCV_REG_V20_V21_V22_V23_V24_V25_V26 = 427, + RISCV_REG_V21_V22_V23_V24_V25_V26_V27 = 428, + RISCV_REG_V22_V23_V24_V25_V26_V27_V28 = 429, + RISCV_REG_V23_V24_V25_V26_V27_V28_V29 = 430, + RISCV_REG_V24_V25_V26_V27_V28_V29_V30 = 431, + RISCV_REG_V25_V26_V27_V28_V29_V30_V31 = 432, + RISCV_REG_V0_V1_V2_V3_V4_V5_V6 = 433, + RISCV_REG_V1_V2_V3_V4_V5_V6_V7_V8 = 434, + RISCV_REG_V2_V3_V4_V5_V6_V7_V8_V9 = 435, + RISCV_REG_V3_V4_V5_V6_V7_V8_V9_V10 = 436, + RISCV_REG_V4_V5_V6_V7_V8_V9_V10_V11 = 437, + RISCV_REG_V5_V6_V7_V8_V9_V10_V11_V12 = 438, + RISCV_REG_V6_V7_V8_V9_V10_V11_V12_V13 = 439, + RISCV_REG_V7_V8_V9_V10_V11_V12_V13_V14 = 440, + RISCV_REG_V8_V9_V10_V11_V12_V13_V14_V15 = 441, + RISCV_REG_V9_V10_V11_V12_V13_V14_V15_V16 = 442, + RISCV_REG_V10_V11_V12_V13_V14_V15_V16_V17 = 443, + RISCV_REG_V11_V12_V13_V14_V15_V16_V17_V18 = 444, + RISCV_REG_V12_V13_V14_V15_V16_V17_V18_V19 = 445, + RISCV_REG_V13_V14_V15_V16_V17_V18_V19_V20 = 446, + RISCV_REG_V14_V15_V16_V17_V18_V19_V20_V21 = 447, + RISCV_REG_V15_V16_V17_V18_V19_V20_V21_V22 = 448, + RISCV_REG_V16_V17_V18_V19_V20_V21_V22_V23 = 449, + RISCV_REG_V17_V18_V19_V20_V21_V22_V23_V24 = 450, + RISCV_REG_V18_V19_V20_V21_V22_V23_V24_V25 = 451, + RISCV_REG_V19_V20_V21_V22_V23_V24_V25_V26 = 452, + RISCV_REG_V20_V21_V22_V23_V24_V25_V26_V27 = 453, + RISCV_REG_V21_V22_V23_V24_V25_V26_V27_V28 = 454, + RISCV_REG_V22_V23_V24_V25_V26_V27_V28_V29 = 455, + RISCV_REG_V23_V24_V25_V26_V27_V28_V29_V30 = 456, + RISCV_REG_V24_V25_V26_V27_V28_V29_V30_V31 = 457, + RISCV_REG_V0_V1_V2_V3_V4_V5_V6_V7 = 458, + RISCV_REG_ENDING, // 459 diff --git a/arch/RISCV/RISCVGenCSSystemOperandsEnum.inc b/arch/RISCV/RISCVGenCSSystemOperandsEnum.inc new file mode 100644 index 0000000000..dc45dde557 --- /dev/null +++ b/arch/RISCV/RISCVGenCSSystemOperandsEnum.inc @@ -0,0 +1,510 @@ +/* Capstone Disassembly Engine, https://www.capstone-engine.org */ +/* By Nguyen Anh Quynh , 2013-2022, */ +/* Rot127 2022-2024 */ +/* Automatically generated file by Capstone's LLVM TableGen Disassembler Backend. */ + +/* LLVM-commit: */ +/* LLVM-tag: */ + +/* Do not edit. */ + +/* Capstone's LLVM TableGen Backends: */ +/* https://github.com/capstone-engine/llvm-capstone */ + +#ifdef GET_ENUM_VALUES_RISCVMaskedPseudoInfo +#undef GET_ENUM_VALUES_RISCVMaskedPseudoInfo +#endif + +#ifdef GET_ENUM_VALUES_RISCVOpcode +#undef GET_ENUM_VALUES_RISCVOpcode + RISCV_RISCVOPCODE_LOAD = 0x3, + RISCV_RISCVOPCODE_LOAD_FP = 0x7, + RISCV_RISCVOPCODE_CUSTOM_0 = 0xb, + RISCV_RISCVOPCODE_MISC_MEM = 0xf, + RISCV_RISCVOPCODE_OP_IMM = 0x13, + RISCV_RISCVOPCODE_AUIPC = 0x17, + RISCV_RISCVOPCODE_OP_IMM_32 = 0x1b, + RISCV_RISCVOPCODE_STORE = 0x23, + RISCV_RISCVOPCODE_STORE_FP = 0x27, + RISCV_RISCVOPCODE_CUSTOM_1 = 0x2b, + RISCV_RISCVOPCODE_AMO = 0x2f, + RISCV_RISCVOPCODE_OP = 0x33, + RISCV_RISCVOPCODE_LUI = 0x37, + RISCV_RISCVOPCODE_OP_32 = 0x3b, + RISCV_RISCVOPCODE_MADD = 0x43, + RISCV_RISCVOPCODE_MSUB = 0x47, + RISCV_RISCVOPCODE_NMSUB = 0x4b, + RISCV_RISCVOPCODE_NMADD = 0x4f, + RISCV_RISCVOPCODE_OP_FP = 0x53, + RISCV_RISCVOPCODE_OP_V = 0x57, + RISCV_RISCVOPCODE_CUSTOM_2 = 0x5b, + RISCV_RISCVOPCODE_BRANCH = 0x63, + RISCV_RISCVOPCODE_JALR = 0x67, + RISCV_RISCVOPCODE_JAL = 0x6f, + RISCV_RISCVOPCODE_SYSTEM = 0x73, + RISCV_RISCVOPCODE_OP_P = 0x77, + RISCV_RISCVOPCODE_CUSTOM_3 = 0x7b, +#endif + +#ifdef GET_ENUM_VALUES_RISCVTuneInfo +#undef GET_ENUM_VALUES_RISCVTuneInfo + RISCV_RISCVTUNEINFO_GENERIC = 0x0, + RISCV_RISCVTUNEINFO_GENERIC-RV32 = 0x0, + RISCV_RISCVTUNEINFO_GENERIC-RV64 = 0x0, +#endif + +#ifdef GET_ENUM_VALUES_RISCVVIntrinsicInfo +#undef GET_ENUM_VALUES_RISCVVIntrinsicInfo +#endif + +#ifdef GET_ENUM_VALUES_PseudoInfo +#undef GET_ENUM_VALUES_PseudoInfo +#endif + +#ifdef GET_ENUM_VALUES_VLEPseudo +#undef GET_ENUM_VALUES_VLEPseudo +#endif + +#ifdef GET_ENUM_VALUES_VLSEGPseudo +#undef GET_ENUM_VALUES_VLSEGPseudo +#endif + +#ifdef GET_ENUM_VALUES_VLXSEGPseudo +#undef GET_ENUM_VALUES_VLXSEGPseudo +#endif + +#ifdef GET_ENUM_VALUES_VLX_VSXPseudo +#undef GET_ENUM_VALUES_VLX_VSXPseudo +#endif + +#ifdef GET_ENUM_VALUES_PseudoInfo +#undef GET_ENUM_VALUES_PseudoInfo +#endif + +#ifdef GET_ENUM_VALUES_VSEPseudo +#undef GET_ENUM_VALUES_VSEPseudo +#endif + +#ifdef GET_ENUM_VALUES_VSSEGPseudo +#undef GET_ENUM_VALUES_VSSEGPseudo +#endif + +#ifdef GET_ENUM_VALUES_VSXSEGPseudo +#undef GET_ENUM_VALUES_VSXSEGPseudo +#endif + +#ifdef GET_ENUM_VALUES_VLX_VSXPseudo +#undef GET_ENUM_VALUES_VLX_VSXPseudo +#endif + +#ifdef GET_ENUM_VALUES_SysReg +#undef GET_ENUM_VALUES_SysReg + RISCV_SYSREG_FFLAGS = 0x1, + RISCV_SYSREG_FRM = 0x2, + RISCV_SYSREG_FCSR = 0x3, + RISCV_SYSREG_VSTART = 0x8, + RISCV_SYSREG_VXSAT = 0x9, + RISCV_SYSREG_VXRM = 0xa, + RISCV_SYSREG_VCSR = 0xf, + RISCV_SYSREG_SEED = 0x15, + RISCV_SYSREG_JVT = 0x17, + RISCV_SYSREG_SSTATUS = 0x100, + RISCV_SYSREG_SIE = 0x104, + RISCV_SYSREG_STVEC = 0x105, + RISCV_SYSREG_SCOUNTEREN = 0x106, + RISCV_SYSREG_SENVCFG = 0x10a, + RISCV_SYSREG_SSTATEEN0 = 0x10c, + RISCV_SYSREG_SSTATEEN1 = 0x10d, + RISCV_SYSREG_SSTATEEN2 = 0x10e, + RISCV_SYSREG_SSTATEEN3 = 0x10f, + RISCV_SYSREG_SIEH = 0x114, + RISCV_SYSREG_SSCRATCH = 0x140, + RISCV_SYSREG_SEPC = 0x141, + RISCV_SYSREG_SCAUSE = 0x142, + RISCV_SYSREG_STVAL = 0x143, + RISCV_SYSREG_SIP = 0x144, + RISCV_SYSREG_STIMECMP = 0x14d, + RISCV_SYSREG_SISELECT = 0x150, + RISCV_SYSREG_SIREG = 0x151, + RISCV_SYSREG_SIPH = 0x154, + RISCV_SYSREG_STOPEI = 0x15c, + RISCV_SYSREG_STIMECMPH = 0x15d, + RISCV_SYSREG_SATP = 0x180, + RISCV_SYSREG_VSSTATUS = 0x200, + RISCV_SYSREG_VSIE = 0x204, + RISCV_SYSREG_VSTVEC = 0x205, + RISCV_SYSREG_VSIEH = 0x214, + RISCV_SYSREG_VSSCRATCH = 0x240, + RISCV_SYSREG_VSEPC = 0x241, + RISCV_SYSREG_VSCAUSE = 0x242, + RISCV_SYSREG_VSTVAL = 0x243, + RISCV_SYSREG_VSIP = 0x244, + RISCV_SYSREG_VSTIMECMP = 0x24d, + RISCV_SYSREG_VSISELECT = 0x250, + RISCV_SYSREG_VSIREG = 0x251, + RISCV_SYSREG_VSIPH = 0x254, + RISCV_SYSREG_VSTOPEI = 0x25c, + RISCV_SYSREG_VSTIMECMPH = 0x25d, + RISCV_SYSREG_VSATP = 0x280, + RISCV_SYSREG_MSTATUS = 0x300, + RISCV_SYSREG_MISA = 0x301, + RISCV_SYSREG_MEDELEG = 0x302, + RISCV_SYSREG_MIDELEG = 0x303, + RISCV_SYSREG_MIE = 0x304, + RISCV_SYSREG_MTVEC = 0x305, + RISCV_SYSREG_MCOUNTEREN = 0x306, + RISCV_SYSREG_MVIEN = 0x308, + RISCV_SYSREG_MVIP = 0x309, + RISCV_SYSREG_MENVCFG = 0x30a, + RISCV_SYSREG_MSTATEEN0 = 0x30c, + RISCV_SYSREG_MSTATEEN1 = 0x30d, + RISCV_SYSREG_MSTATEEN2 = 0x30e, + RISCV_SYSREG_MSTATEEN3 = 0x30f, + RISCV_SYSREG_MSTATUSH = 0x310, + RISCV_SYSREG_MIDELEGH = 0x313, + RISCV_SYSREG_MIEH = 0x314, + RISCV_SYSREG_MVIENH = 0x318, + RISCV_SYSREG_MVIPH = 0x319, + RISCV_SYSREG_MENVCFGH = 0x31a, + RISCV_SYSREG_MSTATEEN0H = 0x31c, + RISCV_SYSREG_MSTATEEN1H = 0x31d, + RISCV_SYSREG_MSTATEEN2H = 0x31e, + RISCV_SYSREG_MSTATEEN3H = 0x31f, + RISCV_SYSREG_MCOUNTINHIBIT = 0x320, + RISCV_SYSREG_MUCOUNTEREN = 0x320, + RISCV_SYSREG_MHPMEVENT3 = 0x323, + RISCV_SYSREG_MHPMEVENT4 = 0x324, + RISCV_SYSREG_MHPMEVENT5 = 0x325, + RISCV_SYSREG_MHPMEVENT6 = 0x326, + RISCV_SYSREG_MHPMEVENT7 = 0x327, + RISCV_SYSREG_MHPMEVENT8 = 0x328, + RISCV_SYSREG_MHPMEVENT9 = 0x329, + RISCV_SYSREG_MHPMEVENT10 = 0x32a, + RISCV_SYSREG_MHPMEVENT11 = 0x32b, + RISCV_SYSREG_MHPMEVENT12 = 0x32c, + RISCV_SYSREG_MHPMEVENT13 = 0x32d, + RISCV_SYSREG_MHPMEVENT14 = 0x32e, + RISCV_SYSREG_MHPMEVENT15 = 0x32f, + RISCV_SYSREG_MHPMEVENT16 = 0x330, + RISCV_SYSREG_MHPMEVENT17 = 0x331, + RISCV_SYSREG_MHPMEVENT18 = 0x332, + RISCV_SYSREG_MHPMEVENT19 = 0x333, + RISCV_SYSREG_MHPMEVENT20 = 0x334, + RISCV_SYSREG_MHPMEVENT21 = 0x335, + RISCV_SYSREG_MHPMEVENT22 = 0x336, + RISCV_SYSREG_MHPMEVENT23 = 0x337, + RISCV_SYSREG_MHPMEVENT24 = 0x338, + RISCV_SYSREG_MHPMEVENT25 = 0x339, + RISCV_SYSREG_MHPMEVENT26 = 0x33a, + RISCV_SYSREG_MHPMEVENT27 = 0x33b, + RISCV_SYSREG_MHPMEVENT28 = 0x33c, + RISCV_SYSREG_MHPMEVENT29 = 0x33d, + RISCV_SYSREG_MHPMEVENT30 = 0x33e, + RISCV_SYSREG_MHPMEVENT31 = 0x33f, + RISCV_SYSREG_MSCRATCH = 0x340, + RISCV_SYSREG_MEPC = 0x341, + RISCV_SYSREG_MCAUSE = 0x342, + RISCV_SYSREG_MTVAL = 0x343, + RISCV_SYSREG_MIP = 0x344, + RISCV_SYSREG_MTINST = 0x34a, + RISCV_SYSREG_MTVAL2 = 0x34b, + RISCV_SYSREG_MISELECT = 0x350, + RISCV_SYSREG_MIREG = 0x351, + RISCV_SYSREG_MIPH = 0x354, + RISCV_SYSREG_MTOPEI = 0x35c, + RISCV_SYSREG_PMPCFG0 = 0x3a0, + RISCV_SYSREG_PMPCFG1 = 0x3a1, + RISCV_SYSREG_PMPCFG2 = 0x3a2, + RISCV_SYSREG_PMPCFG3 = 0x3a3, + RISCV_SYSREG_PMPCFG4 = 0x3a4, + RISCV_SYSREG_PMPCFG5 = 0x3a5, + RISCV_SYSREG_PMPCFG6 = 0x3a6, + RISCV_SYSREG_PMPCFG7 = 0x3a7, + RISCV_SYSREG_PMPCFG8 = 0x3a8, + RISCV_SYSREG_PMPCFG9 = 0x3a9, + RISCV_SYSREG_PMPCFG10 = 0x3aa, + RISCV_SYSREG_PMPCFG11 = 0x3ab, + RISCV_SYSREG_PMPCFG12 = 0x3ac, + RISCV_SYSREG_PMPCFG13 = 0x3ad, + RISCV_SYSREG_PMPCFG14 = 0x3ae, + RISCV_SYSREG_PMPCFG15 = 0x3af, + RISCV_SYSREG_PMPADDR0 = 0x3b0, + RISCV_SYSREG_PMPADDR1 = 0x3b1, + RISCV_SYSREG_PMPADDR2 = 0x3b2, + RISCV_SYSREG_PMPADDR3 = 0x3b3, + RISCV_SYSREG_PMPADDR4 = 0x3b4, + RISCV_SYSREG_PMPADDR5 = 0x3b5, + RISCV_SYSREG_PMPADDR6 = 0x3b6, + RISCV_SYSREG_PMPADDR7 = 0x3b7, + RISCV_SYSREG_PMPADDR8 = 0x3b8, + RISCV_SYSREG_PMPADDR9 = 0x3b9, + RISCV_SYSREG_PMPADDR10 = 0x3ba, + RISCV_SYSREG_PMPADDR11 = 0x3bb, + RISCV_SYSREG_PMPADDR12 = 0x3bc, + RISCV_SYSREG_PMPADDR13 = 0x3bd, + RISCV_SYSREG_PMPADDR14 = 0x3be, + RISCV_SYSREG_PMPADDR15 = 0x3bf, + RISCV_SYSREG_PMPADDR16 = 0x3c0, + RISCV_SYSREG_PMPADDR17 = 0x3c1, + RISCV_SYSREG_PMPADDR18 = 0x3c2, + RISCV_SYSREG_PMPADDR19 = 0x3c3, + RISCV_SYSREG_PMPADDR20 = 0x3c4, + RISCV_SYSREG_PMPADDR21 = 0x3c5, + RISCV_SYSREG_PMPADDR22 = 0x3c6, + RISCV_SYSREG_PMPADDR23 = 0x3c7, + RISCV_SYSREG_PMPADDR24 = 0x3c8, + RISCV_SYSREG_PMPADDR25 = 0x3c9, + RISCV_SYSREG_PMPADDR26 = 0x3ca, + RISCV_SYSREG_PMPADDR27 = 0x3cb, + RISCV_SYSREG_PMPADDR28 = 0x3cc, + RISCV_SYSREG_PMPADDR29 = 0x3cd, + RISCV_SYSREG_PMPADDR30 = 0x3ce, + RISCV_SYSREG_PMPADDR31 = 0x3cf, + RISCV_SYSREG_PMPADDR32 = 0x3d0, + RISCV_SYSREG_PMPADDR33 = 0x3d1, + RISCV_SYSREG_PMPADDR34 = 0x3d2, + RISCV_SYSREG_PMPADDR35 = 0x3d3, + RISCV_SYSREG_PMPADDR36 = 0x3d4, + RISCV_SYSREG_PMPADDR37 = 0x3d5, + RISCV_SYSREG_PMPADDR38 = 0x3d6, + RISCV_SYSREG_PMPADDR39 = 0x3d7, + RISCV_SYSREG_PMPADDR40 = 0x3d8, + RISCV_SYSREG_PMPADDR41 = 0x3d9, + RISCV_SYSREG_PMPADDR42 = 0x3da, + RISCV_SYSREG_PMPADDR43 = 0x3db, + RISCV_SYSREG_PMPADDR44 = 0x3dc, + RISCV_SYSREG_PMPADDR45 = 0x3dd, + RISCV_SYSREG_PMPADDR46 = 0x3de, + RISCV_SYSREG_PMPADDR47 = 0x3df, + RISCV_SYSREG_PMPADDR48 = 0x3e0, + RISCV_SYSREG_PMPADDR49 = 0x3e1, + RISCV_SYSREG_PMPADDR50 = 0x3e2, + RISCV_SYSREG_PMPADDR51 = 0x3e3, + RISCV_SYSREG_PMPADDR52 = 0x3e4, + RISCV_SYSREG_PMPADDR53 = 0x3e5, + RISCV_SYSREG_PMPADDR54 = 0x3e6, + RISCV_SYSREG_PMPADDR55 = 0x3e7, + RISCV_SYSREG_PMPADDR56 = 0x3e8, + RISCV_SYSREG_PMPADDR57 = 0x3e9, + RISCV_SYSREG_PMPADDR58 = 0x3ea, + RISCV_SYSREG_PMPADDR59 = 0x3eb, + RISCV_SYSREG_PMPADDR60 = 0x3ec, + RISCV_SYSREG_PMPADDR61 = 0x3ed, + RISCV_SYSREG_PMPADDR62 = 0x3ee, + RISCV_SYSREG_PMPADDR63 = 0x3ef, + RISCV_SYSREG_SCONTEXT = 0x5a8, + RISCV_SYSREG_HSTATUS = 0x600, + RISCV_SYSREG_HEDELEG = 0x602, + RISCV_SYSREG_HIDELEG = 0x603, + RISCV_SYSREG_HIE = 0x604, + RISCV_SYSREG_HTIMEDELTA = 0x605, + RISCV_SYSREG_HCOUNTEREN = 0x606, + RISCV_SYSREG_HGEIE = 0x607, + RISCV_SYSREG_HVIEN = 0x608, + RISCV_SYSREG_HVICTL = 0x609, + RISCV_SYSREG_HENVCFG = 0x60a, + RISCV_SYSREG_HSTATEEN0 = 0x60c, + RISCV_SYSREG_HSTATEEN1 = 0x60d, + RISCV_SYSREG_HSTATEEN2 = 0x60e, + RISCV_SYSREG_HSTATEEN3 = 0x60f, + RISCV_SYSREG_HIDELEGH = 0x613, + RISCV_SYSREG_HTIMEDELTAH = 0x615, + RISCV_SYSREG_HVIENH = 0x618, + RISCV_SYSREG_HENVCFGH = 0x61a, + RISCV_SYSREG_HSTATEEN0H = 0x61c, + RISCV_SYSREG_HSTATEEN1H = 0x61d, + RISCV_SYSREG_HSTATEEN2H = 0x61e, + RISCV_SYSREG_HSTATEEN3H = 0x61f, + RISCV_SYSREG_HTVAL = 0x643, + RISCV_SYSREG_HIP = 0x644, + RISCV_SYSREG_HVIP = 0x645, + RISCV_SYSREG_HVIPRIO1 = 0x646, + RISCV_SYSREG_HVIPRIO2 = 0x647, + RISCV_SYSREG_HTINST = 0x64a, + RISCV_SYSREG_HVIPH = 0x655, + RISCV_SYSREG_HVIPRIO1H = 0x656, + RISCV_SYSREG_HVIPRIO2H = 0x657, + RISCV_SYSREG_HGATP = 0x680, + RISCV_SYSREG_HCONTEXT = 0x6a8, + RISCV_SYSREG_MHPMEVENT3H = 0x723, + RISCV_SYSREG_MHPMEVENT4H = 0x724, + RISCV_SYSREG_MHPMEVENT5H = 0x725, + RISCV_SYSREG_MHPMEVENT6H = 0x726, + RISCV_SYSREG_MHPMEVENT7H = 0x727, + RISCV_SYSREG_MHPMEVENT8H = 0x728, + RISCV_SYSREG_MHPMEVENT9H = 0x729, + RISCV_SYSREG_MHPMEVENT10H = 0x72a, + RISCV_SYSREG_MHPMEVENT11H = 0x72b, + RISCV_SYSREG_MHPMEVENT12H = 0x72c, + RISCV_SYSREG_MHPMEVENT13H = 0x72d, + RISCV_SYSREG_MHPMEVENT14H = 0x72e, + RISCV_SYSREG_MHPMEVENT15H = 0x72f, + RISCV_SYSREG_MHPMEVENT16H = 0x730, + RISCV_SYSREG_MHPMEVENT17H = 0x731, + RISCV_SYSREG_MHPMEVENT18H = 0x732, + RISCV_SYSREG_MHPMEVENT19H = 0x733, + RISCV_SYSREG_MHPMEVENT20H = 0x734, + RISCV_SYSREG_MHPMEVENT21H = 0x735, + RISCV_SYSREG_MHPMEVENT22H = 0x736, + RISCV_SYSREG_MHPMEVENT23H = 0x737, + RISCV_SYSREG_MHPMEVENT24H = 0x738, + RISCV_SYSREG_MHPMEVENT25H = 0x739, + RISCV_SYSREG_MHPMEVENT26H = 0x73a, + RISCV_SYSREG_MHPMEVENT27H = 0x73b, + RISCV_SYSREG_MHPMEVENT28H = 0x73c, + RISCV_SYSREG_MHPMEVENT29H = 0x73d, + RISCV_SYSREG_MHPMEVENT30H = 0x73e, + RISCV_SYSREG_MHPMEVENT31H = 0x73f, + RISCV_SYSREG_MSECCFG = 0x747, + RISCV_SYSREG_MSECCFGH = 0x757, + RISCV_SYSREG_TSELECT = 0x7a0, + RISCV_SYSREG_TDATA1 = 0x7a1, + RISCV_SYSREG_TDATA2 = 0x7a2, + RISCV_SYSREG_TDATA3 = 0x7a3, + RISCV_SYSREG_MCONTEXT = 0x7a8, + RISCV_SYSREG_DCSR = 0x7b0, + RISCV_SYSREG_DPC = 0x7b1, + RISCV_SYSREG_DSCRATCH0 = 0x7b2, + RISCV_SYSREG_DSCRATCH = 0x7b2, + RISCV_SYSREG_DSCRATCH1 = 0x7b3, + RISCV_SYSREG_MCYCLE = 0xb00, + RISCV_SYSREG_MINSTRET = 0xb02, + RISCV_SYSREG_MHPMCOUNTER3 = 0xb03, + RISCV_SYSREG_MHPMCOUNTER4 = 0xb04, + RISCV_SYSREG_MHPMCOUNTER5 = 0xb05, + RISCV_SYSREG_MHPMCOUNTER6 = 0xb06, + RISCV_SYSREG_MHPMCOUNTER7 = 0xb07, + RISCV_SYSREG_MHPMCOUNTER8 = 0xb08, + RISCV_SYSREG_MHPMCOUNTER9 = 0xb09, + RISCV_SYSREG_MHPMCOUNTER10 = 0xb0a, + RISCV_SYSREG_MHPMCOUNTER11 = 0xb0b, + RISCV_SYSREG_MHPMCOUNTER12 = 0xb0c, + RISCV_SYSREG_MHPMCOUNTER13 = 0xb0d, + RISCV_SYSREG_MHPMCOUNTER14 = 0xb0e, + RISCV_SYSREG_MHPMCOUNTER15 = 0xb0f, + RISCV_SYSREG_MHPMCOUNTER16 = 0xb10, + RISCV_SYSREG_MHPMCOUNTER17 = 0xb11, + RISCV_SYSREG_MHPMCOUNTER18 = 0xb12, + RISCV_SYSREG_MHPMCOUNTER19 = 0xb13, + RISCV_SYSREG_MHPMCOUNTER20 = 0xb14, + RISCV_SYSREG_MHPMCOUNTER21 = 0xb15, + RISCV_SYSREG_MHPMCOUNTER22 = 0xb16, + RISCV_SYSREG_MHPMCOUNTER23 = 0xb17, + RISCV_SYSREG_MHPMCOUNTER24 = 0xb18, + RISCV_SYSREG_MHPMCOUNTER25 = 0xb19, + RISCV_SYSREG_MHPMCOUNTER26 = 0xb1a, + RISCV_SYSREG_MHPMCOUNTER27 = 0xb1b, + RISCV_SYSREG_MHPMCOUNTER28 = 0xb1c, + RISCV_SYSREG_MHPMCOUNTER29 = 0xb1d, + RISCV_SYSREG_MHPMCOUNTER30 = 0xb1e, + RISCV_SYSREG_MHPMCOUNTER31 = 0xb1f, + RISCV_SYSREG_MCYCLEH = 0xb80, + RISCV_SYSREG_MINSTRETH = 0xb82, + RISCV_SYSREG_MHPMCOUNTER3H = 0xb83, + RISCV_SYSREG_MHPMCOUNTER4H = 0xb84, + RISCV_SYSREG_MHPMCOUNTER5H = 0xb85, + RISCV_SYSREG_MHPMCOUNTER6H = 0xb86, + RISCV_SYSREG_MHPMCOUNTER7H = 0xb87, + RISCV_SYSREG_MHPMCOUNTER8H = 0xb88, + RISCV_SYSREG_MHPMCOUNTER9H = 0xb89, + RISCV_SYSREG_MHPMCOUNTER10H = 0xb8a, + RISCV_SYSREG_MHPMCOUNTER11H = 0xb8b, + RISCV_SYSREG_MHPMCOUNTER12H = 0xb8c, + RISCV_SYSREG_MHPMCOUNTER13H = 0xb8d, + RISCV_SYSREG_MHPMCOUNTER14H = 0xb8e, + RISCV_SYSREG_MHPMCOUNTER15H = 0xb8f, + RISCV_SYSREG_MHPMCOUNTER16H = 0xb90, + RISCV_SYSREG_MHPMCOUNTER17H = 0xb91, + RISCV_SYSREG_MHPMCOUNTER18H = 0xb92, + RISCV_SYSREG_MHPMCOUNTER19H = 0xb93, + RISCV_SYSREG_MHPMCOUNTER20H = 0xb94, + RISCV_SYSREG_MHPMCOUNTER21H = 0xb95, + RISCV_SYSREG_MHPMCOUNTER22H = 0xb96, + RISCV_SYSREG_MHPMCOUNTER23H = 0xb97, + RISCV_SYSREG_MHPMCOUNTER24H = 0xb98, + RISCV_SYSREG_MHPMCOUNTER25H = 0xb99, + RISCV_SYSREG_MHPMCOUNTER26H = 0xb9a, + RISCV_SYSREG_MHPMCOUNTER27H = 0xb9b, + RISCV_SYSREG_MHPMCOUNTER28H = 0xb9c, + RISCV_SYSREG_MHPMCOUNTER29H = 0xb9d, + RISCV_SYSREG_MHPMCOUNTER30H = 0xb9e, + RISCV_SYSREG_MHPMCOUNTER31H = 0xb9f, + RISCV_SYSREG_CYCLE = 0xc00, + RISCV_SYSREG_TIME = 0xc01, + RISCV_SYSREG_INSTRET = 0xc02, + RISCV_SYSREG_HPMCOUNTER3 = 0xc03, + RISCV_SYSREG_HPMCOUNTER4 = 0xc04, + RISCV_SYSREG_HPMCOUNTER5 = 0xc05, + RISCV_SYSREG_HPMCOUNTER6 = 0xc06, + RISCV_SYSREG_HPMCOUNTER7 = 0xc07, + RISCV_SYSREG_HPMCOUNTER8 = 0xc08, + RISCV_SYSREG_HPMCOUNTER9 = 0xc09, + RISCV_SYSREG_HPMCOUNTER10 = 0xc0a, + RISCV_SYSREG_HPMCOUNTER11 = 0xc0b, + RISCV_SYSREG_HPMCOUNTER12 = 0xc0c, + RISCV_SYSREG_HPMCOUNTER13 = 0xc0d, + RISCV_SYSREG_HPMCOUNTER14 = 0xc0e, + RISCV_SYSREG_HPMCOUNTER15 = 0xc0f, + RISCV_SYSREG_HPMCOUNTER16 = 0xc10, + RISCV_SYSREG_HPMCOUNTER17 = 0xc11, + RISCV_SYSREG_HPMCOUNTER18 = 0xc12, + RISCV_SYSREG_HPMCOUNTER19 = 0xc13, + RISCV_SYSREG_HPMCOUNTER20 = 0xc14, + RISCV_SYSREG_HPMCOUNTER21 = 0xc15, + RISCV_SYSREG_HPMCOUNTER22 = 0xc16, + RISCV_SYSREG_HPMCOUNTER23 = 0xc17, + RISCV_SYSREG_HPMCOUNTER24 = 0xc18, + RISCV_SYSREG_HPMCOUNTER25 = 0xc19, + RISCV_SYSREG_HPMCOUNTER26 = 0xc1a, + RISCV_SYSREG_HPMCOUNTER27 = 0xc1b, + RISCV_SYSREG_HPMCOUNTER28 = 0xc1c, + RISCV_SYSREG_HPMCOUNTER29 = 0xc1d, + RISCV_SYSREG_HPMCOUNTER30 = 0xc1e, + RISCV_SYSREG_HPMCOUNTER31 = 0xc1f, + RISCV_SYSREG_VL = 0xc20, + RISCV_SYSREG_VTYPE = 0xc21, + RISCV_SYSREG_VLENB = 0xc22, + RISCV_SYSREG_CYCLEH = 0xc80, + RISCV_SYSREG_TIMEH = 0xc81, + RISCV_SYSREG_INSTRETH = 0xc82, + RISCV_SYSREG_HPMCOUNTER3H = 0xc83, + RISCV_SYSREG_HPMCOUNTER4H = 0xc84, + RISCV_SYSREG_HPMCOUNTER5H = 0xc85, + RISCV_SYSREG_HPMCOUNTER6H = 0xc86, + RISCV_SYSREG_HPMCOUNTER7H = 0xc87, + RISCV_SYSREG_HPMCOUNTER8H = 0xc88, + RISCV_SYSREG_HPMCOUNTER9H = 0xc89, + RISCV_SYSREG_HPMCOUNTER10H = 0xc8a, + RISCV_SYSREG_HPMCOUNTER11H = 0xc8b, + RISCV_SYSREG_HPMCOUNTER12H = 0xc8c, + RISCV_SYSREG_HPMCOUNTER13H = 0xc8d, + RISCV_SYSREG_HPMCOUNTER14H = 0xc8e, + RISCV_SYSREG_HPMCOUNTER15H = 0xc8f, + RISCV_SYSREG_HPMCOUNTER16H = 0xc90, + RISCV_SYSREG_HPMCOUNTER17H = 0xc91, + RISCV_SYSREG_HPMCOUNTER18H = 0xc92, + RISCV_SYSREG_HPMCOUNTER19H = 0xc93, + RISCV_SYSREG_HPMCOUNTER20H = 0xc94, + RISCV_SYSREG_HPMCOUNTER21H = 0xc95, + RISCV_SYSREG_HPMCOUNTER22H = 0xc96, + RISCV_SYSREG_HPMCOUNTER23H = 0xc97, + RISCV_SYSREG_HPMCOUNTER24H = 0xc98, + RISCV_SYSREG_HPMCOUNTER25H = 0xc99, + RISCV_SYSREG_HPMCOUNTER26H = 0xc9a, + RISCV_SYSREG_HPMCOUNTER27H = 0xc9b, + RISCV_SYSREG_HPMCOUNTER28H = 0xc9c, + RISCV_SYSREG_HPMCOUNTER29H = 0xc9d, + RISCV_SYSREG_HPMCOUNTER30H = 0xc9e, + RISCV_SYSREG_HPMCOUNTER31H = 0xc9f, + RISCV_SYSREG_SCOUNTOVF = 0xda0, + RISCV_SYSREG_STOPI = 0xdb0, + RISCV_SYSREG_HGEIP = 0xe12, + RISCV_SYSREG_VSTOPI = 0xeb0, + RISCV_SYSREG_MVENDORID = 0xf11, + RISCV_SYSREG_MARCHID = 0xf12, + RISCV_SYSREG_MIMPID = 0xf13, + RISCV_SYSREG_MHARTID = 0xf14, + RISCV_SYSREG_MCONFIGPTR = 0xf15, + RISCV_SYSREG_MTOPI = 0xfb0, +#endif + diff --git a/arch/RISCV/RISCVGenCompressedInstructionsInfo.inc b/arch/RISCV/RISCVGenCompressedInstructionsInfo.inc new file mode 100644 index 0000000000..204b5a2f91 --- /dev/null +++ b/arch/RISCV/RISCVGenCompressedInstructionsInfo.inc @@ -0,0 +1,3674 @@ +/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\ +|* *| +|* Compress instruction Source Fragment *| +|* *| +|* Automatically generated file, do not edit! *| +|* From: RISCV.td *| +|* *| +\*===----------------------------------------------------------------------===*/ + + +#ifdef GEN_COMPRESS_INSTR +#undef GEN_COMPRESS_INSTR + +static bool RISCVValidateMCOperandForCompress(MCInst *MI,MCOperand *MCOp, + unsigned PredicateIndex) { + switch (PredicateIndex) { + default: + CS_ASSERT_RET_VAL(0,false); + return false; + break; + case 1: { + // uimm10_lsb00nonzero + + int64_t Imm; + if (!(Imm = MCOperand_getImm(MCOp), MCOperand_isImm(MCOp))) + return false; + return isShiftedUIntN(8, 2, Imm) && (Imm != 0); + + } + case 2: { + // simm6nonzero + + int64_t Imm; + if ((Imm = MCOperand_getImm(MCOp), MCOperand_isImm(MCOp))) + return (Imm != 0) && isIntN(6, Imm); + return MCOperand_isExpr(MCOp); + + } + case 3: { + // simm6 + + int64_t Imm; + if ((Imm = MCOperand_getImm(MCOp), MCOperand_isImm(MCOp))) + return isIntN(6, Imm); + return MCOperand_isExpr(MCOp); + + } + case 4: { + // simm10_lsb0000nonzero + + int64_t Imm; + if (!(Imm = MCOperand_getImm(MCOp), MCOperand_isImm(MCOp))) + return false; + return isShiftedIntN(6, 4, Imm) && (Imm != 0); + + } + case 5: { + // simm9_lsb0 + + int64_t Imm; + if ((Imm = MCOperand_getImm(MCOp), MCOperand_isImm(MCOp))) + return isShiftedIntN(8, 1, Imm); + return MCOperand_isExpr(MCOp); + + + } + case 6: { + // uimm8_lsb000 + + int64_t Imm; + if (!(Imm = MCOperand_getImm(MCOp), MCOperand_isImm(MCOp))) + return false; + return isShiftedUIntN(5, 3, Imm); + + } + case 7: { + // uimm9_lsb000 + + int64_t Imm; + if (!(Imm = MCOperand_getImm(MCOp), MCOperand_isImm(MCOp))) + return false; + return isShiftedUIntN(6, 3, Imm); + + } + case 8: { + // uimm7_lsb00 + + int64_t Imm; + if (!(Imm = MCOperand_getImm(MCOp), MCOperand_isImm(MCOp))) + return false; + return isShiftedUIntN(5, 2, Imm); + + } + case 9: { + // uimm8_lsb00 + + int64_t Imm; + if (!(Imm = MCOperand_getImm(MCOp), MCOperand_isImm(MCOp))) + return false; + return isShiftedUIntN(6, 2, Imm); + + } + case 10: { + // simm12_lsb0 + + int64_t Imm; + if ((Imm = MCOperand_getImm(MCOp), MCOperand_isImm(MCOp))) + return isShiftedIntN(11, 1, Imm); + return MCOperand_isExpr(MCOp); + + } + case 11: { + // uimm2 + + int64_t Imm; + if (!(Imm = MCOperand_getImm(MCOp), MCOperand_isImm(MCOp))) + return false; + return isUIntN(2, Imm); + + } + case 12: { + // uimm2_lsb0 + + int64_t Imm; + if (!(Imm = MCOperand_getImm(MCOp), MCOperand_isImm(MCOp))) + return false; + return isShiftedUIntN(1, 1, Imm); + + } + case 13: { + // c_lui_imm + + int64_t Imm; + if ((Imm = MCOperand_getImm(MCOp), MCOperand_isImm(MCOp))) + return (Imm != 0) && (isUIntN(5, Imm) || + (Imm >= 0xfffe0 && Imm <= 0xfffff)); + return MCOperand_isExpr(MCOp); + + } + case 14: { + // uimmlog2xlennonzero + + int64_t Imm; + if (!(Imm = MCOperand_getImm(MCOp), MCOperand_isImm(MCOp))) + return false; + if (RISCV_getFeatureBits(MI->csh->mode,RISCV_Feature64Bit)) + return isUIntN(6, Imm) && (Imm != 0); + return isUIntN(5, Imm) && (Imm != 0); + + } + } + return false; +} + +static bool compressInst(MCInst *OutInst, + MCInst *MI) { + switch (MCInst_getOpcode(MI)) { + default: return false; + case RISCV_ADD: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCOperand_getReg(MCInst_getOperand(MI, 1)) == RISCV_X0) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRNoX0RegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 2))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRNoX0RegClassID),MCOperand_getReg(MCInst_getOperand(MI, 2))))) { + // c.mv $rs1, $rs2 + MCInst_setOpcode(OutInst, RISCV_C_MV); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs2 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 2))) && + (MCOperand_getReg(MCInst_getOperand(MI, 2)) == RISCV_X0) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRNoX0RegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRNoX0RegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1))))) { + // c.mv $rs1, $rs2 + MCInst_setOpcode(OutInst, RISCV_C_MV); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs2 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + + return true; + } // if + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 1)) == MCOperand_getReg(MCInst_getOperand(MI, 0))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRNoX0RegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 2))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRNoX0RegClassID),MCOperand_getReg(MCInst_getOperand(MI, 2))))) { + // c.add $rs1, $rs2 + MCInst_setOpcode(OutInst, RISCV_C_ADD); + // Operand: rs1_wb + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: rs2 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 2))) && (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 2)) == MCOperand_getReg(MCInst_getOperand(MI, 0))) && + (MCOperand_isReg(MCInst_getOperand(MI, 2))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRNoX0RegClassID),MCOperand_getReg(MCInst_getOperand(MI, 2)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRNoX0RegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1))))) { + // c.add $rs1, $rs2 + MCInst_setOpcode(OutInst, RISCV_C_ADD); + // Operand: rs1_wb + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + // Operand: rs2 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + + return true; + } // if + break; + } // case ADD + case RISCV_ADDI: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_SPRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + RISCVValidateMCOperandForCompress(MI,MCInst_getOperand(MI, 2), 1)) { + // c.addi4spn $rd, $rs1, $imm + MCInst_setOpcode(OutInst, RISCV_C_ADDI4SPN); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: imm + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 0)) == RISCV_X0) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCOperand_getReg(MCInst_getOperand(MI, 1)) == RISCV_X0) && + (MCOperand_isImm(MCInst_getOperand(MI, 2))) && + (MCOperand_getImm(MCInst_getOperand(MI, 2)) == 0)) { + // c.nop + MCInst_setOpcode(OutInst, RISCV_C_NOP); + + return true; + } // if + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 1)) == MCOperand_getReg(MCInst_getOperand(MI, 0))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRNoX0RegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + RISCVValidateMCOperandForCompress(MI,MCInst_getOperand(MI, 2), 2)) { + // c.addi $rd, $imm + MCInst_setOpcode(OutInst, RISCV_C_ADDI); + // Operand: rd_wb + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: imm + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCOperand_getReg(MCInst_getOperand(MI, 1)) == RISCV_X0) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRNoX0RegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + RISCVValidateMCOperandForCompress(MI,MCInst_getOperand(MI, 2), 3)) { + // c.li $rd, $imm + MCInst_setOpcode(OutInst, RISCV_C_LI); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: imm + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 0)) == RISCV_X2) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCOperand_getReg(MCInst_getOperand(MI, 1)) == RISCV_X2) && + RISCVValidateMCOperandForCompress(MI,MCInst_getOperand(MI, 2), 4)) { + // c.addi16sp $rd, $imm + MCInst_setOpcode(OutInst, RISCV_C_ADDI16SP); + // Operand: rd_wb + MCOperand_CreateReg0(OutInst, RISCV_X2); + // Operand: rd + MCOperand_CreateReg0(OutInst, RISCV_X2); + // Operand: imm + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isImm(MCInst_getOperand(MI, 2))) && + (MCOperand_getImm(MCInst_getOperand(MI, 2)) == 0) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRNoX0RegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRNoX0RegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1))))) { + // c.mv $rs1, $rs2 + MCInst_setOpcode(OutInst, RISCV_C_MV); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs2 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + + return true; + } // if + break; + } // case ADDI + case RISCV_ADDIW: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_Feature64Bit) && + (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 1)) == MCOperand_getReg(MCInst_getOperand(MI, 0))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRNoX0RegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + RISCVValidateMCOperandForCompress(MI,MCInst_getOperand(MI, 2), 3)) { + // c.addiw $rd, $imm + MCInst_setOpcode(OutInst, RISCV_C_ADDIW); + // Operand: rd_wb + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: imm + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_Feature64Bit) && + (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCOperand_getReg(MCInst_getOperand(MI, 1)) == RISCV_X0) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRNoX0RegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + RISCVValidateMCOperandForCompress(MI,MCInst_getOperand(MI, 2), 3)) { + // c.li $rd, $imm + MCInst_setOpcode(OutInst, RISCV_C_LI); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: imm + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + break; + } // case ADDIW + case RISCV_ADDW: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_Feature64Bit) && + (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 1)) == MCOperand_getReg(MCInst_getOperand(MI, 0))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 2))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 2))))) { + // c.addw $rd, $rs2 + MCInst_setOpcode(OutInst, RISCV_C_ADDW); + // Operand: rd_wb + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: rs2 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_Feature64Bit) && + (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 2))) && (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 2)) == MCOperand_getReg(MCInst_getOperand(MI, 0))) && + (MCOperand_isReg(MCInst_getOperand(MI, 2))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 2)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1))))) { + // c.addw $rd, $rs2 + MCInst_setOpcode(OutInst, RISCV_C_ADDW); + // Operand: rd_wb + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + // Operand: rs2 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + + return true; + } // if + break; + } // case ADDW + case RISCV_ADD_UW: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_Feature64Bit) && + RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZba) && + RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcb) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 1)) == MCOperand_getReg(MCInst_getOperand(MI, 0))) && + (MCOperand_isReg(MCInst_getOperand(MI, 2))) && + (MCOperand_getReg(MCInst_getOperand(MI, 2)) == RISCV_X0) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1))))) { + // c.zext.w $rd + MCInst_setOpcode(OutInst, RISCV_C_ZEXT_W); + // Operand: rd_wb + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + + return true; + } // if + break; + } // case ADD_UW + case RISCV_AND: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 1)) == MCOperand_getReg(MCInst_getOperand(MI, 0))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 2))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 2))))) { + // c.and $rd, $rs2 + MCInst_setOpcode(OutInst, RISCV_C_AND); + // Operand: rd_wb + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: rs2 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 2))) && (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 2)) == MCOperand_getReg(MCInst_getOperand(MI, 0))) && + (MCOperand_isReg(MCInst_getOperand(MI, 2))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 2)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1))))) { + // c.and $rd, $rs2 + MCInst_setOpcode(OutInst, RISCV_C_AND); + // Operand: rd_wb + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + // Operand: rs2 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + + return true; + } // if + break; + } // case AND + case RISCV_ANDI: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 1)) == MCOperand_getReg(MCInst_getOperand(MI, 0))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + RISCVValidateMCOperandForCompress(MI,MCInst_getOperand(MI, 2), 3)) { + // c.andi $rs1, $imm + MCInst_setOpcode(OutInst, RISCV_C_ANDI); + // Operand: rs1_wb + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: imm + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcb) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 1)) == MCOperand_getReg(MCInst_getOperand(MI, 0))) && + (MCOperand_isImm(MCInst_getOperand(MI, 2))) && + (MCOperand_getImm(MCInst_getOperand(MI, 2)) == 255) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1))))) { + // c.zext.b $rd + MCInst_setOpcode(OutInst, RISCV_C_ZEXT_B); + // Operand: rd_wb + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + + return true; + } // if + break; + } // case ANDI + case RISCV_BEQ: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCOperand_getReg(MCInst_getOperand(MI, 1)) == RISCV_X0) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + RISCVValidateMCOperandForCompress(MI,MCInst_getOperand(MI, 2), 5)) { + // c.beqz $rs1, $imm + MCInst_setOpcode(OutInst, RISCV_C_BEQZ); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: imm + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 0)) == RISCV_X0) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + RISCVValidateMCOperandForCompress(MI,MCInst_getOperand(MI, 2), 5)) { + // c.beqz $rs1, $imm + MCInst_setOpcode(OutInst, RISCV_C_BEQZ); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: imm + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + break; + } // case BEQ + case RISCV_BNE: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCOperand_getReg(MCInst_getOperand(MI, 1)) == RISCV_X0) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + RISCVValidateMCOperandForCompress(MI,MCInst_getOperand(MI, 2), 5)) { + // c.bnez $rs1, $imm + MCInst_setOpcode(OutInst, RISCV_C_BNEZ); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: imm + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 0)) == RISCV_X0) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + RISCVValidateMCOperandForCompress(MI,MCInst_getOperand(MI, 2), 5)) { + // c.bnez $rs1, $imm + MCInst_setOpcode(OutInst, RISCV_C_BNEZ); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: imm + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + break; + } // case BNE + case RISCV_EBREAK: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca))) { + // c.ebreak + MCInst_setOpcode(OutInst, RISCV_C_EBREAK); + + return true; + } // if + break; + } // case EBREAK + case RISCV_FLD: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtD) && + (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcd)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_FPR64CRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + RISCVValidateMCOperandForCompress(MI,MCInst_getOperand(MI, 2), 6)) { + // c.fld $rd, ${imm}(${rs1}) + MCInst_setOpcode(OutInst, RISCV_C_FLD); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: imm + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtD) && + (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcd)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_FPR64RegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_SPRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + RISCVValidateMCOperandForCompress(MI,MCInst_getOperand(MI, 2), 7)) { + // c.fldsp $rd, ${imm}(${rs1}) + MCInst_setOpcode(OutInst, RISCV_C_FLDSP); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: imm + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + break; + } // case FLD + case RISCV_FLW: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtF) && + !RISCV_getFeatureBits(MI->csh->mode, RISCV_Feature64Bit) && + (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZce) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcf)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_FPR32CRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + RISCVValidateMCOperandForCompress(MI,MCInst_getOperand(MI, 2), 8)) { + // c.flw $rd, ${imm}(${rs1}) + MCInst_setOpcode(OutInst, RISCV_C_FLW); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: imm + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtF) && + !RISCV_getFeatureBits(MI->csh->mode, RISCV_Feature64Bit) && + (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZce) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcf)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_FPR32RegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_SPRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + RISCVValidateMCOperandForCompress(MI,MCInst_getOperand(MI, 2), 9)) { + // c.flwsp $rd, ${imm}(${rs1}) + MCInst_setOpcode(OutInst, RISCV_C_FLWSP); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: imm + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + break; + } // case FLW + case RISCV_FSD: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtD) && + (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcd)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_FPR64CRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + RISCVValidateMCOperandForCompress(MI,MCInst_getOperand(MI, 2), 6)) { + // c.fsd $rs2, ${imm}(${rs1}) + MCInst_setOpcode(OutInst, RISCV_C_FSD); + // Operand: rs2 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: imm + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtD) && + (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcd)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_FPR64RegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_SPRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + RISCVValidateMCOperandForCompress(MI,MCInst_getOperand(MI, 2), 7)) { + // c.fsdsp $rs2, ${imm}(${rs1}) + MCInst_setOpcode(OutInst, RISCV_C_FSDSP); + // Operand: rs2 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: imm + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + break; + } // case FSD + case RISCV_FSW: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtF) && + !RISCV_getFeatureBits(MI->csh->mode, RISCV_Feature64Bit) && + (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZce) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcf)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_FPR32CRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + RISCVValidateMCOperandForCompress(MI,MCInst_getOperand(MI, 2), 8)) { + // c.fsw $rs2, ${imm}(${rs1}) + MCInst_setOpcode(OutInst, RISCV_C_FSW); + // Operand: rs2 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: imm + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtF) && + !RISCV_getFeatureBits(MI->csh->mode, RISCV_Feature64Bit) && + (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZce) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcf)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_FPR32RegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_SPRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + RISCVValidateMCOperandForCompress(MI,MCInst_getOperand(MI, 2), 9)) { + // c.fswsp $rs2, ${imm}(${rs1}) + MCInst_setOpcode(OutInst, RISCV_C_FSWSP); + // Operand: rs2 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: imm + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + break; + } // case FSW + case RISCV_JAL: { + if (!RISCV_getFeatureBits(MI->csh->mode, RISCV_Feature64Bit) && + (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 0)) == RISCV_X1) && + RISCVValidateMCOperandForCompress(MI,MCInst_getOperand(MI, 1), 10)) { + // c.jal $offset + MCInst_setOpcode(OutInst, RISCV_C_JAL); + // Operand: offset + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + + return true; + } // if + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 0)) == RISCV_X0) && + RISCVValidateMCOperandForCompress(MI,MCInst_getOperand(MI, 1), 10)) { + // c.j $offset + MCInst_setOpcode(OutInst, RISCV_C_J); + // Operand: offset + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + + return true; + } // if + break; + } // case JAL + case RISCV_JALR: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 0)) == RISCV_X0) && + (MCOperand_isImm(MCInst_getOperand(MI, 2))) && + (MCOperand_getImm(MCInst_getOperand(MI, 2)) == 0) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRNoX0RegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1))))) { + // c.jr $rs1 + MCInst_setOpcode(OutInst, RISCV_C_JR); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + + return true; + } // if + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 0)) == RISCV_X1) && + (MCOperand_isImm(MCInst_getOperand(MI, 2))) && + (MCOperand_getImm(MCInst_getOperand(MI, 2)) == 0) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRNoX0RegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1))))) { + // c.jalr $rs1 + MCInst_setOpcode(OutInst, RISCV_C_JALR); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + + return true; + } // if + break; + } // case JALR + case RISCV_LBU: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcb) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + RISCVValidateMCOperandForCompress(MI,MCInst_getOperand(MI, 2), 11)) { + // c.lbu $rd, ${imm}(${rs1}) + MCInst_setOpcode(OutInst, RISCV_C_LBU); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: imm + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + break; + } // case LBU + case RISCV_LD: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_Feature64Bit) && + (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + RISCVValidateMCOperandForCompress(MI,MCInst_getOperand(MI, 2), 6)) { + // c.ld $rd, ${imm}(${rs1}) + MCInst_setOpcode(OutInst, RISCV_C_LD); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: imm + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_Feature64Bit) && + (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRNoX0RegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_SPRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + RISCVValidateMCOperandForCompress(MI,MCInst_getOperand(MI, 2), 7)) { + // c.ldsp $rd, ${imm}(${rs1}) + MCInst_setOpcode(OutInst, RISCV_C_LDSP); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: imm + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + break; + } // case LD + case RISCV_LH: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcb) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + RISCVValidateMCOperandForCompress(MI,MCInst_getOperand(MI, 2), 12)) { + // c.lh $rd, ${imm}(${rs1}) + MCInst_setOpcode(OutInst, RISCV_C_LH); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: imm + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + break; + } // case LH + case RISCV_LHU: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcb) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + RISCVValidateMCOperandForCompress(MI,MCInst_getOperand(MI, 2), 12)) { + // c.lhu $rd, ${imm}(${rs1}) + MCInst_setOpcode(OutInst, RISCV_C_LHU); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: imm + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + break; + } // case LHU + case RISCV_LUI: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRNoX0X2RegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + RISCVValidateMCOperandForCompress(MI,MCInst_getOperand(MI, 1), 13)) { + // c.lui $rd, $imm + MCInst_setOpcode(OutInst, RISCV_C_LUI); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: imm + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + + return true; + } // if + break; + } // case LUI + case RISCV_LW: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + RISCVValidateMCOperandForCompress(MI,MCInst_getOperand(MI, 2), 8)) { + // c.lw $rd, ${imm}(${rs1}) + MCInst_setOpcode(OutInst, RISCV_C_LW); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: imm + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRNoX0RegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_SPRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + RISCVValidateMCOperandForCompress(MI,MCInst_getOperand(MI, 2), 9)) { + // c.lwsp $rd, ${imm}(${rs1}) + MCInst_setOpcode(OutInst, RISCV_C_LWSP); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: imm + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + break; + } // case LW + case RISCV_MUL: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcb) && + (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtM) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZmmul)) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 1)) == MCOperand_getReg(MCInst_getOperand(MI, 0))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 2))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 2))))) { + // c.mul $rd, $rs2 + MCInst_setOpcode(OutInst, RISCV_C_MUL); + // Operand: rd_wb + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: rs2 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcb) && + (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtM) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZmmul)) && + (MCOperand_isReg(MCInst_getOperand(MI, 2))) && (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 2)) == MCOperand_getReg(MCInst_getOperand(MI, 0))) && + (MCOperand_isReg(MCInst_getOperand(MI, 2))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 2)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1))))) { + // c.mul $rd, $rs2 + MCInst_setOpcode(OutInst, RISCV_C_MUL); + // Operand: rd_wb + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + // Operand: rs2 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + + return true; + } // if + break; + } // case MUL + case RISCV_OR: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 1)) == MCOperand_getReg(MCInst_getOperand(MI, 0))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 2))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 2))))) { + // c.or $rd, $rs2 + MCInst_setOpcode(OutInst, RISCV_C_OR); + // Operand: rd_wb + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: rs2 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 2))) && (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 2)) == MCOperand_getReg(MCInst_getOperand(MI, 0))) && + (MCOperand_isReg(MCInst_getOperand(MI, 2))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 2)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1))))) { + // c.or $rd, $rs2 + MCInst_setOpcode(OutInst, RISCV_C_OR); + // Operand: rd_wb + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + // Operand: rs2 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + + return true; + } // if + break; + } // case OR + case RISCV_SB: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcb) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + RISCVValidateMCOperandForCompress(MI,MCInst_getOperand(MI, 2), 11)) { + // c.sb $rs2, ${imm}(${rs1}) + MCInst_setOpcode(OutInst, RISCV_C_SB); + // Operand: rs2 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: imm + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + break; + } // case SB + case RISCV_SD: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_Feature64Bit) && + (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + RISCVValidateMCOperandForCompress(MI,MCInst_getOperand(MI, 2), 6)) { + // c.sd $rs2, ${imm}(${rs1}) + MCInst_setOpcode(OutInst, RISCV_C_SD); + // Operand: rs2 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: imm + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_Feature64Bit) && + (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_SPRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + RISCVValidateMCOperandForCompress(MI,MCInst_getOperand(MI, 2), 7)) { + // c.sdsp $rs2, ${imm}(${rs1}) + MCInst_setOpcode(OutInst, RISCV_C_SDSP); + // Operand: rs2 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: imm + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + break; + } // case SD + case RISCV_SEXT_B: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZbb) && + RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcb) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 1)) == MCOperand_getReg(MCInst_getOperand(MI, 0))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1))))) { + // c.sext.b $rd + MCInst_setOpcode(OutInst, RISCV_C_SEXT_B); + // Operand: rd_wb + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + + return true; + } // if + break; + } // case SEXT_B + case RISCV_SEXT_H: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZbb) && + RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcb) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 1)) == MCOperand_getReg(MCInst_getOperand(MI, 0))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1))))) { + // c.sext.h $rd + MCInst_setOpcode(OutInst, RISCV_C_SEXT_H); + // Operand: rd_wb + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + + return true; + } // if + break; + } // case SEXT_H + case RISCV_SH: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcb) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + RISCVValidateMCOperandForCompress(MI,MCInst_getOperand(MI, 2), 12)) { + // c.sh $rs2, ${imm}(${rs1}) + MCInst_setOpcode(OutInst, RISCV_C_SH); + // Operand: rs2 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: imm + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + break; + } // case SH + case RISCV_SLLI: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 1)) == MCOperand_getReg(MCInst_getOperand(MI, 0))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRNoX0RegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + RISCVValidateMCOperandForCompress(MI,MCInst_getOperand(MI, 2), 14)) { + // c.slli $rd, $imm + MCInst_setOpcode(OutInst, RISCV_C_SLLI); + // Operand: rd_wb + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: imm + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + break; + } // case SLLI + case RISCV_SRAI: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 1)) == MCOperand_getReg(MCInst_getOperand(MI, 0))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + RISCVValidateMCOperandForCompress(MI,MCInst_getOperand(MI, 2), 14)) { + // c.srai $rs1, $imm + MCInst_setOpcode(OutInst, RISCV_C_SRAI); + // Operand: rs1_wb + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: imm + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + break; + } // case SRAI + case RISCV_SRLI: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 1)) == MCOperand_getReg(MCInst_getOperand(MI, 0))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + RISCVValidateMCOperandForCompress(MI,MCInst_getOperand(MI, 2), 14)) { + // c.srli $rs1, $imm + MCInst_setOpcode(OutInst, RISCV_C_SRLI); + // Operand: rs1_wb + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: imm + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + break; + } // case SRLI + case RISCV_SSPOPCHK: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcmop) && + RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZicfiss) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 0)) == RISCV_X5)) { + // c.sspopchk $rs1 + MCInst_setOpcode(OutInst, RISCV_C_SSPOPCHK); + // Operand: rs1 + MCOperand_CreateReg0(OutInst, RISCV_X5); + + return true; + } // if + break; + } // case SSPOPCHK + case RISCV_SSPUSH: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcmop) && + RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZicfiss) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 0)) == RISCV_X1)) { + // c.sspush $rs1 + MCInst_setOpcode(OutInst, RISCV_C_SSPUSH); + // Operand: rs1 + MCOperand_CreateReg0(OutInst, RISCV_X1); + + return true; + } // if + break; + } // case SSPUSH + case RISCV_SUB: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 1)) == MCOperand_getReg(MCInst_getOperand(MI, 0))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 2))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 2))))) { + // c.sub $rd, $rs2 + MCInst_setOpcode(OutInst, RISCV_C_SUB); + // Operand: rd_wb + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: rs2 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + break; + } // case SUB + case RISCV_SUBW: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_Feature64Bit) && + (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 1)) == MCOperand_getReg(MCInst_getOperand(MI, 0))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 2))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 2))))) { + // c.subw $rd, $rs2 + MCInst_setOpcode(OutInst, RISCV_C_SUBW); + // Operand: rd_wb + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: rs2 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + break; + } // case SUBW + case RISCV_SW: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + RISCVValidateMCOperandForCompress(MI,MCInst_getOperand(MI, 2), 8)) { + // c.sw $rs2, ${imm}(${rs1}) + MCInst_setOpcode(OutInst, RISCV_C_SW); + // Operand: rs2 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: imm + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_SPRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + RISCVValidateMCOperandForCompress(MI,MCInst_getOperand(MI, 2), 9)) { + // c.swsp $rs2, ${imm}(${rs1}) + MCInst_setOpcode(OutInst, RISCV_C_SWSP); + // Operand: rs2 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: imm + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + break; + } // case SW + case RISCV_UNIMP: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca))) { + // c.unimp + MCInst_setOpcode(OutInst, RISCV_C_UNIMP); + + return true; + } // if + break; + } // case UNIMP + case RISCV_XOR: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 1)) == MCOperand_getReg(MCInst_getOperand(MI, 0))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 2))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 2))))) { + // c.xor $rd, $rs2 + MCInst_setOpcode(OutInst, RISCV_C_XOR); + // Operand: rd_wb + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: rs2 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 2))) && (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 2)) == MCOperand_getReg(MCInst_getOperand(MI, 0))) && + (MCOperand_isReg(MCInst_getOperand(MI, 2))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 2)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1))))) { + // c.xor $rd, $rs2 + MCInst_setOpcode(OutInst, RISCV_C_XOR); + // Operand: rd_wb + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + // Operand: rs2 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + + return true; + } // if + break; + } // case XOR + case RISCV_XORI: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcb) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 1)) == MCOperand_getReg(MCInst_getOperand(MI, 0))) && + (MCOperand_isImm(MCInst_getOperand(MI, 2))) && + (MCOperand_getImm(MCInst_getOperand(MI, 2)) == -1) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1))))) { + // c.not $rd + MCInst_setOpcode(OutInst, RISCV_C_NOT); + // Operand: rd_wb + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + + return true; + } // if + break; + } // case XORI + case RISCV_ZEXT_H_RV32: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZbb) && + RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcb) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 1)) == MCOperand_getReg(MCInst_getOperand(MI, 0))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1))))) { + // c.zext.h $rd + MCInst_setOpcode(OutInst, RISCV_C_ZEXT_H); + // Operand: rd_wb + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + + return true; + } // if + break; + } // case ZEXT_H_RV32 + case RISCV_ZEXT_H_RV64: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZbb) && + RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcb) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 1)) == MCOperand_getReg(MCInst_getOperand(MI, 0))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1))))) { + // c.zext.h $rd + MCInst_setOpcode(OutInst, RISCV_C_ZEXT_H); + // Operand: rd_wb + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + + return true; + } // if + + } // case ZEXT_H_RV64 + } // switch + return false; +} + +#endif //GEN_COMPRESS_INSTR + +#ifdef GEN_UNCOMPRESS_INSTR +#undef GEN_UNCOMPRESS_INSTR + +static bool RISCVValidateMCOperandForUncompress(MCInst *MI,MCOperand *MCOp, + unsigned PredicateIndex) { + switch (PredicateIndex) { + default: + CS_ASSERT_RET_VAL(0,false); + return false; + break; + case 1: { + // simm12 + + int64_t Imm; + if ((Imm = MCOperand_getImm(MCOp), MCOperand_isImm(MCOp))) + return isIntN(12, Imm); + return MCOperand_isExpr(MCOp); + + } + case 2: { + // simm13_lsb0 + + int64_t Imm; + if ((Imm = MCOperand_getImm(MCOp), MCOperand_isImm(MCOp))) + return isShiftedIntN(12, 1, Imm); + return MCOperand_isExpr(MCOp); + + } + case 3: { + // simm21_lsb0_jal + + int64_t Imm; + if ((Imm = MCOperand_getImm(MCOp), MCOperand_isImm(MCOp))) + return isShiftedIntN(20, 1, Imm); + return MCOperand_isExpr(MCOp); + + } + case 4: { + // uimm20_lui + + int64_t Imm; + if ((Imm = MCOperand_getImm(MCOp), MCOperand_isImm(MCOp))) + return isUIntN(20, Imm); + return MCOperand_isExpr(MCOp); + + } + case 5: { + // uimmlog2xlen + + int64_t Imm; + if (!(Imm = MCOperand_getImm(MCOp), MCOperand_isImm(MCOp))) + return false; + if (RISCV_getFeatureBits(MI->csh->mode,RISCV_Feature64Bit)) + return isUIntN(6, Imm); + return isUIntN(5, Imm); + + } + } + return false; +} + +static bool uncompressInst(MCInst *OutInst, + MCInst *MI) { + switch (MCInst_getOpcode(MI)) { + default: return false; + case RISCV_C_ADD: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 2))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 2))))) { + // add $rd, $rs1, $rs2 + MCInst_setOpcode(OutInst, RISCV_ADD); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs2 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + break; + } // case C_ADD + case RISCV_C_ADDI: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + RISCVValidateMCOperandForUncompress(MI,MCInst_getOperand(MI, 2), 1)) { + // addi $rd, $rs1, $imm12 + MCInst_setOpcode(OutInst, RISCV_ADDI); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: imm12 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + break; + } // case C_ADDI + case RISCV_C_ADDI16SP: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 0)) == RISCV_X2) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCOperand_getReg(MCInst_getOperand(MI, 1)) == RISCV_X2) && + RISCVValidateMCOperandForUncompress(MI,MCInst_getOperand(MI, 2), 1)) { + // addi $rd, $rs1, $imm12 + MCInst_setOpcode(OutInst, RISCV_ADDI); + // Operand: rd + MCOperand_CreateReg0(OutInst, RISCV_X2); + // Operand: rs1 + MCOperand_CreateReg0(OutInst, RISCV_X2); + // Operand: imm12 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + break; + } // case C_ADDI16SP + case RISCV_C_ADDI4SPN: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + RISCVValidateMCOperandForUncompress(MI,MCInst_getOperand(MI, 2), 1)) { + // addi $rd, $rs1, $imm12 + MCInst_setOpcode(OutInst, RISCV_ADDI); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: imm12 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + break; + } // case C_ADDI4SPN + case RISCV_C_ADDIW: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_Feature64Bit) && + (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + RISCVValidateMCOperandForUncompress(MI,MCInst_getOperand(MI, 2), 1)) { + // addiw $rd, $rs1, $imm12 + MCInst_setOpcode(OutInst, RISCV_ADDIW); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: imm12 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + break; + } // case C_ADDIW + case RISCV_C_ADDW: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_Feature64Bit) && + (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 2))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 2))))) { + // addw $rd, $rs1, $rs2 + MCInst_setOpcode(OutInst, RISCV_ADDW); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs2 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + break; + } // case C_ADDW + case RISCV_C_AND: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 2))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 2))))) { + // and $rd, $rs1, $rs2 + MCInst_setOpcode(OutInst, RISCV_AND); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs2 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + break; + } // case C_AND + case RISCV_C_ANDI: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + RISCVValidateMCOperandForUncompress(MI,MCInst_getOperand(MI, 2), 1)) { + // andi $rd, $rs1, $imm12 + MCInst_setOpcode(OutInst, RISCV_ANDI); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: imm12 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + break; + } // case C_ANDI + case RISCV_C_BEQZ: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + RISCVValidateMCOperandForUncompress(MI,MCInst_getOperand(MI, 1), 2)) { + // beq $rs1, $rs2, $imm12 + MCInst_setOpcode(OutInst, RISCV_BEQ); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs2 + MCOperand_CreateReg0(OutInst, RISCV_X0); + // Operand: imm12 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + + return true; + } // if + break; + } // case C_BEQZ + case RISCV_C_BNEZ: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + RISCVValidateMCOperandForUncompress(MI,MCInst_getOperand(MI, 1), 2)) { + // bne $rs1, $rs2, $imm12 + MCInst_setOpcode(OutInst, RISCV_BNE); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs2 + MCOperand_CreateReg0(OutInst, RISCV_X0); + // Operand: imm12 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + + return true; + } // if + break; + } // case C_BNEZ + case RISCV_C_EBREAK: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca))) { + // ebreak + MCInst_setOpcode(OutInst, RISCV_EBREAK); + + return true; + } // if + break; + } // case C_EBREAK + case RISCV_C_FLD: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtD) && + (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcd)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_FPR64RegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + RISCVValidateMCOperandForUncompress(MI,MCInst_getOperand(MI, 2), 1)) { + // fld $rd, ${imm12}(${rs1}) + MCInst_setOpcode(OutInst, RISCV_FLD); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: imm12 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + break; + } // case C_FLD + case RISCV_C_FLDSP: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtD) && + (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcd)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_FPR64RegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + RISCVValidateMCOperandForUncompress(MI,MCInst_getOperand(MI, 2), 1)) { + // fld $rd, ${imm12}(${rs1}) + MCInst_setOpcode(OutInst, RISCV_FLD); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: imm12 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + break; + } // case C_FLDSP + case RISCV_C_FLW: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtF) && + !RISCV_getFeatureBits(MI->csh->mode, RISCV_Feature64Bit) && + (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZce) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcf)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_FPR32RegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + RISCVValidateMCOperandForUncompress(MI,MCInst_getOperand(MI, 2), 1)) { + // flw $rd, ${imm12}(${rs1}) + MCInst_setOpcode(OutInst, RISCV_FLW); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: imm12 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + break; + } // case C_FLW + case RISCV_C_FLWSP: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtF) && + !RISCV_getFeatureBits(MI->csh->mode, RISCV_Feature64Bit) && + (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZce) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcf)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_FPR32RegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + RISCVValidateMCOperandForUncompress(MI,MCInst_getOperand(MI, 2), 1)) { + // flw $rd, ${imm12}(${rs1}) + MCInst_setOpcode(OutInst, RISCV_FLW); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: imm12 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + break; + } // case C_FLWSP + case RISCV_C_FSD: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtD) && + (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcd)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_FPR64RegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + RISCVValidateMCOperandForUncompress(MI,MCInst_getOperand(MI, 2), 1)) { + // fsd $rs2, ${imm12}(${rs1}) + MCInst_setOpcode(OutInst, RISCV_FSD); + // Operand: rs2 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: imm12 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + break; + } // case C_FSD + case RISCV_C_FSDSP: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtD) && + (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcd)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_FPR64RegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + RISCVValidateMCOperandForUncompress(MI,MCInst_getOperand(MI, 2), 1)) { + // fsd $rs2, ${imm12}(${rs1}) + MCInst_setOpcode(OutInst, RISCV_FSD); + // Operand: rs2 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: imm12 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + break; + } // case C_FSDSP + case RISCV_C_FSW: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtF) && + !RISCV_getFeatureBits(MI->csh->mode, RISCV_Feature64Bit) && + (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZce) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcf)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_FPR32RegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + RISCVValidateMCOperandForUncompress(MI,MCInst_getOperand(MI, 2), 1)) { + // fsw $rs2, ${imm12}(${rs1}) + MCInst_setOpcode(OutInst, RISCV_FSW); + // Operand: rs2 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: imm12 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + break; + } // case C_FSW + case RISCV_C_FSWSP: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtF) && + !RISCV_getFeatureBits(MI->csh->mode, RISCV_Feature64Bit) && + (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZce) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcf)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_FPR32RegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + RISCVValidateMCOperandForUncompress(MI,MCInst_getOperand(MI, 2), 1)) { + // fsw $rs2, ${imm12}(${rs1}) + MCInst_setOpcode(OutInst, RISCV_FSW); + // Operand: rs2 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: imm12 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + break; + } // case C_FSWSP + case RISCV_C_J: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + RISCVValidateMCOperandForUncompress(MI,MCInst_getOperand(MI, 0), 3)) { + // jal $rd, $imm20 + MCInst_setOpcode(OutInst, RISCV_JAL); + // Operand: rd + MCOperand_CreateReg0(OutInst, RISCV_X0); + // Operand: imm20 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + + return true; + } // if + break; + } // case C_J + case RISCV_C_JAL: { + if (!RISCV_getFeatureBits(MI->csh->mode, RISCV_Feature64Bit) && + (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + RISCVValidateMCOperandForUncompress(MI,MCInst_getOperand(MI, 0), 3)) { + // jal $rd, $imm20 + MCInst_setOpcode(OutInst, RISCV_JAL); + // Operand: rd + MCOperand_CreateReg0(OutInst, RISCV_X1); + // Operand: imm20 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + + return true; + } // if + break; + } // case C_JAL + case RISCV_C_JALR: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + RISCVValidateMCOperandForUncompress(MI,MCOperand_CreateImm1(MI, 0), 1)) { + // jalr $rd, ${imm12}(${rs1}) + MCInst_setOpcode(OutInst, RISCV_JALR); + // Operand: rd + MCOperand_CreateReg0(OutInst, RISCV_X1); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: imm12 + MCOperand_CreateImm0(OutInst, 0); + + return true; + } // if + break; + } // case C_JALR + case RISCV_C_JR: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + RISCVValidateMCOperandForUncompress(MI,MCOperand_CreateImm1(MI, 0), 1)) { + // jalr $rd, ${imm12}(${rs1}) + MCInst_setOpcode(OutInst, RISCV_JALR); + // Operand: rd + MCOperand_CreateReg0(OutInst, RISCV_X0); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: imm12 + MCOperand_CreateImm0(OutInst, 0); + + return true; + } // if + break; + } // case C_JR + case RISCV_C_LBU: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcb) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + RISCVValidateMCOperandForUncompress(MI,MCInst_getOperand(MI, 2), 1)) { + // lbu $rd, ${imm12}(${rs1}) + MCInst_setOpcode(OutInst, RISCV_LBU); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: imm12 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + break; + } // case C_LBU + case RISCV_C_LD: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_Feature64Bit) && + (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + RISCVValidateMCOperandForUncompress(MI,MCInst_getOperand(MI, 2), 1)) { + // ld $rd, ${imm12}(${rs1}) + MCInst_setOpcode(OutInst, RISCV_LD); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: imm12 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + break; + } // case C_LD + case RISCV_C_LDSP: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_Feature64Bit) && + (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + RISCVValidateMCOperandForUncompress(MI,MCInst_getOperand(MI, 2), 1)) { + // ld $rd, ${imm12}(${rs1}) + MCInst_setOpcode(OutInst, RISCV_LD); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: imm12 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + break; + } // case C_LDSP + case RISCV_C_LH: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcb) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + RISCVValidateMCOperandForUncompress(MI,MCInst_getOperand(MI, 2), 1)) { + // lh $rd, ${imm12}(${rs1}) + MCInst_setOpcode(OutInst, RISCV_LH); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: imm12 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + break; + } // case C_LH + case RISCV_C_LHU: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcb) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + RISCVValidateMCOperandForUncompress(MI,MCInst_getOperand(MI, 2), 1)) { + // lhu $rd, ${imm12}(${rs1}) + MCInst_setOpcode(OutInst, RISCV_LHU); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: imm12 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + break; + } // case C_LHU + case RISCV_C_LI: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + RISCVValidateMCOperandForUncompress(MI,MCInst_getOperand(MI, 1), 1)) { + // addi $rd, $rs1, $imm12 + MCInst_setOpcode(OutInst, RISCV_ADDI); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCOperand_CreateReg0(OutInst, RISCV_X0); + // Operand: imm12 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + + return true; + } // if + break; + } // case C_LI + case RISCV_C_LUI: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + RISCVValidateMCOperandForUncompress(MI,MCInst_getOperand(MI, 1), 4)) { + // lui $rd, $imm20 + MCInst_setOpcode(OutInst, RISCV_LUI); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: imm20 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + + return true; + } // if + break; + } // case C_LUI + case RISCV_C_LW: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + RISCVValidateMCOperandForUncompress(MI,MCInst_getOperand(MI, 2), 1)) { + // lw $rd, ${imm12}(${rs1}) + MCInst_setOpcode(OutInst, RISCV_LW); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: imm12 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + break; + } // case C_LW + case RISCV_C_LWSP: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + RISCVValidateMCOperandForUncompress(MI,MCInst_getOperand(MI, 2), 1)) { + // lw $rd, ${imm12}(${rs1}) + MCInst_setOpcode(OutInst, RISCV_LW); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: imm12 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + break; + } // case C_LWSP + case RISCV_C_MUL: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcb) && + (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtM) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZmmul)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 2))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 2))))) { + // mul $rd, $rs1, $rs2 + MCInst_setOpcode(OutInst, RISCV_MUL); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs2 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + break; + } // case C_MUL + case RISCV_C_MV: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + RISCVValidateMCOperandForUncompress(MI,MCOperand_CreateImm1(MI, 0), 1)) { + // addi $rd, $rs1, $imm12 + MCInst_setOpcode(OutInst, RISCV_ADDI); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: imm12 + MCOperand_CreateImm0(OutInst, 0); + + return true; + } // if + break; + } // case C_MV + case RISCV_C_NOP: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + RISCVValidateMCOperandForUncompress(MI,MCOperand_CreateImm1(MI, 0), 1)) { + // addi $rd, $rs1, $imm12 + MCInst_setOpcode(OutInst, RISCV_ADDI); + // Operand: rd + MCOperand_CreateReg0(OutInst, RISCV_X0); + // Operand: rs1 + MCOperand_CreateReg0(OutInst, RISCV_X0); + // Operand: imm12 + MCOperand_CreateImm0(OutInst, 0); + + return true; + } // if + break; + } // case C_NOP + case RISCV_C_NOT: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcb) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + RISCVValidateMCOperandForUncompress(MI,MCOperand_CreateImm1(MI, -1), 1)) { + // xori $rd, $rs1, $imm12 + MCInst_setOpcode(OutInst, RISCV_XORI); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: imm12 + MCOperand_CreateImm0(OutInst, -1); + + return true; + } // if + break; + } // case C_NOT + case RISCV_C_OR: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 2))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 2))))) { + // or $rd, $rs1, $rs2 + MCInst_setOpcode(OutInst, RISCV_OR); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs2 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + break; + } // case C_OR + case RISCV_C_SB: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcb) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + RISCVValidateMCOperandForUncompress(MI,MCInst_getOperand(MI, 2), 1)) { + // sb $rs2, ${imm12}(${rs1}) + MCInst_setOpcode(OutInst, RISCV_SB); + // Operand: rs2 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: imm12 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + break; + } // case C_SB + case RISCV_C_SD: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_Feature64Bit) && + (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + RISCVValidateMCOperandForUncompress(MI,MCInst_getOperand(MI, 2), 1)) { + // sd $rs2, ${imm12}(${rs1}) + MCInst_setOpcode(OutInst, RISCV_SD); + // Operand: rs2 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: imm12 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + break; + } // case C_SD + case RISCV_C_SDSP: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_Feature64Bit) && + (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + RISCVValidateMCOperandForUncompress(MI,MCInst_getOperand(MI, 2), 1)) { + // sd $rs2, ${imm12}(${rs1}) + MCInst_setOpcode(OutInst, RISCV_SD); + // Operand: rs2 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: imm12 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + break; + } // case C_SDSP + case RISCV_C_SEXT_B: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZbb) && + RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcb) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0))))) { + // sext.b $rd, $rs1 + MCInst_setOpcode(OutInst, RISCV_SEXT_B); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + + return true; + } // if + break; + } // case C_SEXT_B + case RISCV_C_SEXT_H: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZbb) && + RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcb) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0))))) { + // sext.h $rd, $rs1 + MCInst_setOpcode(OutInst, RISCV_SEXT_H); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + + return true; + } // if + break; + } // case C_SEXT_H + case RISCV_C_SH: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcb) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + RISCVValidateMCOperandForUncompress(MI,MCInst_getOperand(MI, 2), 1)) { + // sh $rs2, ${imm12}(${rs1}) + MCInst_setOpcode(OutInst, RISCV_SH); + // Operand: rs2 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: imm12 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + break; + } // case C_SH + case RISCV_C_SLLI: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + RISCVValidateMCOperandForUncompress(MI,MCInst_getOperand(MI, 2), 5)) { + // slli $rd, $rs1, $shamt + MCInst_setOpcode(OutInst, RISCV_SLLI); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: shamt + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + break; + } // case C_SLLI + case RISCV_C_SRAI: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + RISCVValidateMCOperandForUncompress(MI,MCInst_getOperand(MI, 2), 5)) { + // srai $rd, $rs1, $shamt + MCInst_setOpcode(OutInst, RISCV_SRAI); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: shamt + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + break; + } // case C_SRAI + case RISCV_C_SRLI: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + RISCVValidateMCOperandForUncompress(MI,MCInst_getOperand(MI, 2), 5)) { + // srli $rd, $rs1, $shamt + MCInst_setOpcode(OutInst, RISCV_SRLI); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: shamt + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + break; + } // case C_SRLI + case RISCV_C_SSPOPCHK: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcmop) && + RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZicfiss) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 0)) == RISCV_X5)) { + // sspopchk $rs1 + MCInst_setOpcode(OutInst, RISCV_SSPOPCHK); + // Operand: rs1 + MCOperand_CreateReg0(OutInst, RISCV_X5); + + return true; + } // if + break; + } // case C_SSPOPCHK + case RISCV_C_SSPUSH: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcmop) && + RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZicfiss) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 0)) == RISCV_X1)) { + // sspush $rs2 + MCInst_setOpcode(OutInst, RISCV_SSPUSH); + // Operand: rs2 + MCOperand_CreateReg0(OutInst, RISCV_X1); + + return true; + } // if + break; + } // case C_SSPUSH + case RISCV_C_SUB: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 2))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 2))))) { + // sub $rd, $rs1, $rs2 + MCInst_setOpcode(OutInst, RISCV_SUB); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs2 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + break; + } // case C_SUB + case RISCV_C_SUBW: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_Feature64Bit) && + (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 2))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 2))))) { + // subw $rd, $rs1, $rs2 + MCInst_setOpcode(OutInst, RISCV_SUBW); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs2 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + break; + } // case C_SUBW + case RISCV_C_SW: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + RISCVValidateMCOperandForUncompress(MI,MCInst_getOperand(MI, 2), 1)) { + // sw $rs2, ${imm12}(${rs1}) + MCInst_setOpcode(OutInst, RISCV_SW); + // Operand: rs2 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: imm12 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + break; + } // case C_SW + case RISCV_C_SWSP: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + RISCVValidateMCOperandForUncompress(MI,MCInst_getOperand(MI, 2), 1)) { + // sw $rs2, ${imm12}(${rs1}) + MCInst_setOpcode(OutInst, RISCV_SW); + // Operand: rs2 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 1)); + // Operand: imm12 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + break; + } // case C_SWSP + case RISCV_C_UNIMP: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca))) { + // unimp + MCInst_setOpcode(OutInst, RISCV_UNIMP); + + return true; + } // if + break; + } // case C_UNIMP + case RISCV_C_XOR: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 2))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 2))))) { + // xor $rd, $rs1, $rs2 + MCInst_setOpcode(OutInst, RISCV_XOR); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs2 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 2)); + + return true; + } // if + break; + } // case C_XOR + case RISCV_C_ZEXT_B: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcb) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + RISCVValidateMCOperandForUncompress(MI,MCOperand_CreateImm1(MI, 255), 1)) { + // andi $rd, $rs1, $imm12 + MCInst_setOpcode(OutInst, RISCV_ANDI); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: imm12 + MCOperand_CreateImm0(OutInst, 255); + + return true; + } // if + break; + } // case C_ZEXT_B + case RISCV_C_ZEXT_H: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZbb) && + RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcb) && + !RISCV_getFeatureBits(MI->csh->mode, RISCV_Feature64Bit) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0))))) { + // zext.h $rd, $rs1 + MCInst_setOpcode(OutInst, RISCV_ZEXT_H_RV32); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + + return true; + } // if + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_Feature64Bit) && + RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZbb) && + RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcb) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0))))) { + // zext.h $rd, $rs1 + MCInst_setOpcode(OutInst, RISCV_ZEXT_H_RV64); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + + return true; + } // if + break; + } // case C_ZEXT_H + case RISCV_C_ZEXT_W: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_Feature64Bit) && + RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZba) && + RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcb) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0))))) { + // add.uw $rd, $rs1, $rs2 + MCInst_setOpcode(OutInst, RISCV_ADD_UW); + // Operand: rd + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs1 + MCInst_addOperand2(OutInst, MCInst_getOperand(MI, 0)); + // Operand: rs2 + MCOperand_CreateReg0(OutInst, RISCV_X0); + + return true; + } // if + + } // case C_ZEXT_W + } // switch + return false; +} + +#endif //GEN_UNCOMPRESS_INSTR + + +#ifdef GEN_CHECK_COMPRESS_INSTR +#undef GEN_CHECK_COMPRESS_INSTR + +static bool RISCVValidateMachineOperand(MCInst *MI,MCOperand *MO, + unsigned PredicateIndex) { + int64_t Imm = MCOperand_getImm(MO); + switch (PredicateIndex) { + default: + CS_ASSERT_RET_VAL(0,false); + return false; + break; + case 1: { + // simm6nonzero + return (Imm != 0) && isIntN(6, Imm); + } + case 2: { + // simm10_lsb0000nonzero + return (Imm != 0) && isShiftedIntN(6, 4, Imm); + } + case 3: { + // uimm10_lsb00nonzero + return isShiftedUIntN(8, 2, Imm) && (Imm != 0); + } + case 4: { + // simm6 + return isIntN(6, Imm); + } + case 5: { + // simm9_lsb0 + return isShiftedIntN(8, 1, Imm); + } + case 6: { + // uimm8_lsb000 + return isShiftedUIntN(5, 3, Imm); + } + case 7: { + // uimm9_lsb000 + return isShiftedUIntN(6, 3, Imm); + } + case 8: { + // uimm7_lsb00 + return isShiftedUIntN(5, 2, Imm); + } + case 9: { + // uimm8_lsb00 + return isShiftedUIntN(6, 2, Imm); + } + case 10: { + // simm12_lsb0 + return isShiftedIntN(11, 1, Imm); + } + case 11: { + // uimm2 + return isUIntN(2, Imm); + } + case 12: { + // uimm2_lsb0 + return isShiftedUIntN(1, 1, Imm); + } + case 13: { + // c_lui_imm + return (Imm != 0) && + (isUIntN(5, Imm) || + (Imm >= 0xfffe0 && Imm <= 0xfffff)); + } + case 14: { + // uimmlog2xlennonzero + + if (RISCV_getFeatureBits(MI->csh->mode,RISCV_Feature64Bit)) + return isUIntN(6, Imm) && (Imm != 0); + return isUIntN(5, Imm) && (Imm != 0); + + } + } + return false; +} + +static bool isCompressibleInst(MCInst *MI) { + switch (MCInst_getOpcode(MI)) { + default: return false; + case RISCV_ADD: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 1)) == MCOperand_getReg(MCInst_getOperand(MI, 0))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRNoX0RegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 2))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRNoX0RegClassID),MCOperand_getReg(MCInst_getOperand(MI, 2))))) { + // c.add $rs1, $rs2 + // Operand: rs1_wb + // Operand: rs1 + // Operand: rs2 + return true; + } // if + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 2))) && (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 2)) == MCOperand_getReg(MCInst_getOperand(MI, 0))) && + (MCOperand_isReg(MCInst_getOperand(MI, 2))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRNoX0RegClassID),MCOperand_getReg(MCInst_getOperand(MI, 2)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRNoX0RegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1))))) { + // c.add $rs1, $rs2 + // Operand: rs1_wb + // Operand: rs1 + // Operand: rs2 + return true; + } // if + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCOperand_getReg(MCInst_getOperand(MI, 1)) == RISCV_X0) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRNoX0RegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 2))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRNoX0RegClassID),MCOperand_getReg(MCInst_getOperand(MI, 2))))) { + // c.mv $rs1, $rs2 + // Operand: rs1 + // Operand: rs2 + return true; + } // if + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 2))) && + (MCOperand_getReg(MCInst_getOperand(MI, 2)) == RISCV_X0) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRNoX0RegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRNoX0RegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1))))) { + // c.mv $rs1, $rs2 + // Operand: rs1 + // Operand: rs2 + return true; + } // if + break; + } // case ADD + case RISCV_ADDI: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 1)) == MCOperand_getReg(MCInst_getOperand(MI, 0))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRNoX0RegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + MCOperand_isImm(MCInst_getOperand(MI, 2)) && + RISCVValidateMachineOperand(MI,MCInst_getOperand(MI, 2), 1)) { + // c.addi $rd, $imm + // Operand: rd_wb + // Operand: rd + // Operand: imm + return true; + } // if + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 0)) == RISCV_X2) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCOperand_getReg(MCInst_getOperand(MI, 1)) == RISCV_X2) && + MCOperand_isImm(MCInst_getOperand(MI, 2)) && + RISCVValidateMachineOperand(MI,MCInst_getOperand(MI, 2), 2)) { + // c.addi16sp $rd, $imm + // Operand: rd_wb + // Operand: rd + // Operand: imm + return true; + } // if + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_SPRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + MCOperand_isImm(MCInst_getOperand(MI, 2)) && + RISCVValidateMachineOperand(MI,MCInst_getOperand(MI, 2), 3)) { + // c.addi4spn $rd, $rs1, $imm + // Operand: rd + // Operand: rs1 + // Operand: imm + return true; + } // if + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCOperand_getReg(MCInst_getOperand(MI, 1)) == RISCV_X0) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRNoX0RegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + MCOperand_isImm(MCInst_getOperand(MI, 2)) && + RISCVValidateMachineOperand(MI,MCInst_getOperand(MI, 2), 4)) { + // c.li $rd, $imm + // Operand: rd + // Operand: imm + return true; + } // if + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isImm(MCInst_getOperand(MI, 2))) && + (MCOperand_getImm(MCInst_getOperand(MI, 2)) == 0) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRNoX0RegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRNoX0RegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1))))) { + // c.mv $rs1, $rs2 + // Operand: rs1 + // Operand: rs2 + return true; + } // if + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 0)) == RISCV_X0) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCOperand_getReg(MCInst_getOperand(MI, 1)) == RISCV_X0) && + (MCOperand_isImm(MCInst_getOperand(MI, 2))) && + (MCOperand_getImm(MCInst_getOperand(MI, 2)) == 0)) { + // c.nop + return true; + } // if + break; + } // case ADDI + case RISCV_ADDIW: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_Feature64Bit) && + (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 1)) == MCOperand_getReg(MCInst_getOperand(MI, 0))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRNoX0RegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + MCOperand_isImm(MCInst_getOperand(MI, 2)) && + RISCVValidateMachineOperand(MI,MCInst_getOperand(MI, 2), 4)) { + // c.addiw $rd, $imm + // Operand: rd_wb + // Operand: rd + // Operand: imm + return true; + } // if + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_Feature64Bit) && + (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCOperand_getReg(MCInst_getOperand(MI, 1)) == RISCV_X0) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRNoX0RegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + MCOperand_isImm(MCInst_getOperand(MI, 2)) && + RISCVValidateMachineOperand(MI,MCInst_getOperand(MI, 2), 4)) { + // c.li $rd, $imm + // Operand: rd + // Operand: imm + return true; + } // if + break; + } // case ADDIW + case RISCV_ADDW: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_Feature64Bit) && + (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 1)) == MCOperand_getReg(MCInst_getOperand(MI, 0))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 2))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 2))))) { + // c.addw $rd, $rs2 + // Operand: rd_wb + // Operand: rd + // Operand: rs2 + return true; + } // if + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_Feature64Bit) && + (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 2))) && (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 2)) == MCOperand_getReg(MCInst_getOperand(MI, 0))) && + (MCOperand_isReg(MCInst_getOperand(MI, 2))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 2)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1))))) { + // c.addw $rd, $rs2 + // Operand: rd_wb + // Operand: rd + // Operand: rs2 + return true; + } // if + break; + } // case ADDW + case RISCV_ADD_UW: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_Feature64Bit) && + RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZba) && + RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcb) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 1)) == MCOperand_getReg(MCInst_getOperand(MI, 0))) && + (MCOperand_isReg(MCInst_getOperand(MI, 2))) && + (MCOperand_getReg(MCInst_getOperand(MI, 2)) == RISCV_X0) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1))))) { + // c.zext.w $rd + // Operand: rd_wb + // Operand: rd + return true; + } // if + break; + } // case ADD_UW + case RISCV_AND: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 1)) == MCOperand_getReg(MCInst_getOperand(MI, 0))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 2))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 2))))) { + // c.and $rd, $rs2 + // Operand: rd_wb + // Operand: rd + // Operand: rs2 + return true; + } // if + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 2))) && (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 2)) == MCOperand_getReg(MCInst_getOperand(MI, 0))) && + (MCOperand_isReg(MCInst_getOperand(MI, 2))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 2)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1))))) { + // c.and $rd, $rs2 + // Operand: rd_wb + // Operand: rd + // Operand: rs2 + return true; + } // if + break; + } // case AND + case RISCV_ANDI: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 1)) == MCOperand_getReg(MCInst_getOperand(MI, 0))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + MCOperand_isImm(MCInst_getOperand(MI, 2)) && + RISCVValidateMachineOperand(MI,MCInst_getOperand(MI, 2), 4)) { + // c.andi $rs1, $imm + // Operand: rs1_wb + // Operand: rs1 + // Operand: imm + return true; + } // if + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcb) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 1)) == MCOperand_getReg(MCInst_getOperand(MI, 0))) && + (MCOperand_isImm(MCInst_getOperand(MI, 2))) && + (MCOperand_getImm(MCInst_getOperand(MI, 2)) == 255) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1))))) { + // c.zext.b $rd + // Operand: rd_wb + // Operand: rd + return true; + } // if + break; + } // case ANDI + case RISCV_BEQ: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCOperand_getReg(MCInst_getOperand(MI, 1)) == RISCV_X0) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + MCOperand_isImm(MCInst_getOperand(MI, 2)) && + RISCVValidateMachineOperand(MI,MCInst_getOperand(MI, 2), 5)) { + // c.beqz $rs1, $imm + // Operand: rs1 + // Operand: imm + return true; + } // if + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 0)) == RISCV_X0) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + MCOperand_isImm(MCInst_getOperand(MI, 2)) && + RISCVValidateMachineOperand(MI,MCInst_getOperand(MI, 2), 5)) { + // c.beqz $rs1, $imm + // Operand: rs1 + // Operand: imm + return true; + } // if + break; + } // case BEQ + case RISCV_BNE: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCOperand_getReg(MCInst_getOperand(MI, 1)) == RISCV_X0) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + MCOperand_isImm(MCInst_getOperand(MI, 2)) && + RISCVValidateMachineOperand(MI,MCInst_getOperand(MI, 2), 5)) { + // c.bnez $rs1, $imm + // Operand: rs1 + // Operand: imm + return true; + } // if + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 0)) == RISCV_X0) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + MCOperand_isImm(MCInst_getOperand(MI, 2)) && + RISCVValidateMachineOperand(MI,MCInst_getOperand(MI, 2), 5)) { + // c.bnez $rs1, $imm + // Operand: rs1 + // Operand: imm + return true; + } // if + break; + } // case BNE + case RISCV_EBREAK: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca))) { + // c.ebreak + return true; + } // if + break; + } // case EBREAK + case RISCV_FLD: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtD) && + (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcd)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_FPR64CRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + MCOperand_isImm(MCInst_getOperand(MI, 2)) && + RISCVValidateMachineOperand(MI,MCInst_getOperand(MI, 2), 6)) { + // c.fld $rd, ${imm}(${rs1}) + // Operand: rd + // Operand: rs1 + // Operand: imm + return true; + } // if + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtD) && + (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcd)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_FPR64RegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_SPRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + MCOperand_isImm(MCInst_getOperand(MI, 2)) && + RISCVValidateMachineOperand(MI,MCInst_getOperand(MI, 2), 7)) { + // c.fldsp $rd, ${imm}(${rs1}) + // Operand: rd + // Operand: rs1 + // Operand: imm + return true; + } // if + break; + } // case FLD + case RISCV_FLW: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtF) && + !RISCV_getFeatureBits(MI->csh->mode, RISCV_Feature64Bit) && + (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZce) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcf)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_FPR32CRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + MCOperand_isImm(MCInst_getOperand(MI, 2)) && + RISCVValidateMachineOperand(MI,MCInst_getOperand(MI, 2), 8)) { + // c.flw $rd, ${imm}(${rs1}) + // Operand: rd + // Operand: rs1 + // Operand: imm + return true; + } // if + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtF) && + !RISCV_getFeatureBits(MI->csh->mode, RISCV_Feature64Bit) && + (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZce) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcf)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_FPR32RegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_SPRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + MCOperand_isImm(MCInst_getOperand(MI, 2)) && + RISCVValidateMachineOperand(MI,MCInst_getOperand(MI, 2), 9)) { + // c.flwsp $rd, ${imm}(${rs1}) + // Operand: rd + // Operand: rs1 + // Operand: imm + return true; + } // if + break; + } // case FLW + case RISCV_FSD: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtD) && + (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcd)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_FPR64CRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + MCOperand_isImm(MCInst_getOperand(MI, 2)) && + RISCVValidateMachineOperand(MI,MCInst_getOperand(MI, 2), 6)) { + // c.fsd $rs2, ${imm}(${rs1}) + // Operand: rs2 + // Operand: rs1 + // Operand: imm + return true; + } // if + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtD) && + (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcd)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_FPR64RegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_SPRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + MCOperand_isImm(MCInst_getOperand(MI, 2)) && + RISCVValidateMachineOperand(MI,MCInst_getOperand(MI, 2), 7)) { + // c.fsdsp $rs2, ${imm}(${rs1}) + // Operand: rs2 + // Operand: rs1 + // Operand: imm + return true; + } // if + break; + } // case FSD + case RISCV_FSW: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtF) && + !RISCV_getFeatureBits(MI->csh->mode, RISCV_Feature64Bit) && + (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZce) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcf)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_FPR32CRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + MCOperand_isImm(MCInst_getOperand(MI, 2)) && + RISCVValidateMachineOperand(MI,MCInst_getOperand(MI, 2), 8)) { + // c.fsw $rs2, ${imm}(${rs1}) + // Operand: rs2 + // Operand: rs1 + // Operand: imm + return true; + } // if + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtF) && + !RISCV_getFeatureBits(MI->csh->mode, RISCV_Feature64Bit) && + (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZce) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcf)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_FPR32RegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_SPRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + MCOperand_isImm(MCInst_getOperand(MI, 2)) && + RISCVValidateMachineOperand(MI,MCInst_getOperand(MI, 2), 9)) { + // c.fswsp $rs2, ${imm}(${rs1}) + // Operand: rs2 + // Operand: rs1 + // Operand: imm + return true; + } // if + break; + } // case FSW + case RISCV_JAL: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 0)) == RISCV_X0) && + MCOperand_isImm(MCInst_getOperand(MI, 1)) && + RISCVValidateMachineOperand(MI,MCInst_getOperand(MI, 1), 10)) { + // c.j $offset + // Operand: offset + return true; + } // if + if (!RISCV_getFeatureBits(MI->csh->mode, RISCV_Feature64Bit) && + (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 0)) == RISCV_X1) && + MCOperand_isImm(MCInst_getOperand(MI, 1)) && + RISCVValidateMachineOperand(MI,MCInst_getOperand(MI, 1), 10)) { + // c.jal $offset + // Operand: offset + return true; + } // if + break; + } // case JAL + case RISCV_JALR: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 0)) == RISCV_X1) && + (MCOperand_isImm(MCInst_getOperand(MI, 2))) && + (MCOperand_getImm(MCInst_getOperand(MI, 2)) == 0) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRNoX0RegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1))))) { + // c.jalr $rs1 + // Operand: rs1 + return true; + } // if + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 0)) == RISCV_X0) && + (MCOperand_isImm(MCInst_getOperand(MI, 2))) && + (MCOperand_getImm(MCInst_getOperand(MI, 2)) == 0) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRNoX0RegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1))))) { + // c.jr $rs1 + // Operand: rs1 + return true; + } // if + break; + } // case JALR + case RISCV_LBU: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcb) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + MCOperand_isImm(MCInst_getOperand(MI, 2)) && + RISCVValidateMachineOperand(MI,MCInst_getOperand(MI, 2), 11)) { + // c.lbu $rd, ${imm}(${rs1}) + // Operand: rd + // Operand: rs1 + // Operand: imm + return true; + } // if + break; + } // case LBU + case RISCV_LD: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_Feature64Bit) && + (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + MCOperand_isImm(MCInst_getOperand(MI, 2)) && + RISCVValidateMachineOperand(MI,MCInst_getOperand(MI, 2), 6)) { + // c.ld $rd, ${imm}(${rs1}) + // Operand: rd + // Operand: rs1 + // Operand: imm + return true; + } // if + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_Feature64Bit) && + (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRNoX0RegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_SPRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + MCOperand_isImm(MCInst_getOperand(MI, 2)) && + RISCVValidateMachineOperand(MI,MCInst_getOperand(MI, 2), 7)) { + // c.ldsp $rd, ${imm}(${rs1}) + // Operand: rd + // Operand: rs1 + // Operand: imm + return true; + } // if + break; + } // case LD + case RISCV_LH: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcb) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + MCOperand_isImm(MCInst_getOperand(MI, 2)) && + RISCVValidateMachineOperand(MI,MCInst_getOperand(MI, 2), 12)) { + // c.lh $rd, ${imm}(${rs1}) + // Operand: rd + // Operand: rs1 + // Operand: imm + return true; + } // if + break; + } // case LH + case RISCV_LHU: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcb) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + MCOperand_isImm(MCInst_getOperand(MI, 2)) && + RISCVValidateMachineOperand(MI,MCInst_getOperand(MI, 2), 12)) { + // c.lhu $rd, ${imm}(${rs1}) + // Operand: rd + // Operand: rs1 + // Operand: imm + return true; + } // if + break; + } // case LHU + case RISCV_LUI: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRNoX0X2RegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + MCOperand_isImm(MCInst_getOperand(MI, 1)) && + RISCVValidateMachineOperand(MI,MCInst_getOperand(MI, 1), 13)) { + // c.lui $rd, $imm + // Operand: rd + // Operand: imm + return true; + } // if + break; + } // case LUI + case RISCV_LW: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + MCOperand_isImm(MCInst_getOperand(MI, 2)) && + RISCVValidateMachineOperand(MI,MCInst_getOperand(MI, 2), 8)) { + // c.lw $rd, ${imm}(${rs1}) + // Operand: rd + // Operand: rs1 + // Operand: imm + return true; + } // if + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRNoX0RegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_SPRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + MCOperand_isImm(MCInst_getOperand(MI, 2)) && + RISCVValidateMachineOperand(MI,MCInst_getOperand(MI, 2), 9)) { + // c.lwsp $rd, ${imm}(${rs1}) + // Operand: rd + // Operand: rs1 + // Operand: imm + return true; + } // if + break; + } // case LW + case RISCV_MUL: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcb) && + (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtM) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZmmul)) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 1)) == MCOperand_getReg(MCInst_getOperand(MI, 0))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 2))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 2))))) { + // c.mul $rd, $rs2 + // Operand: rd_wb + // Operand: rd + // Operand: rs2 + return true; + } // if + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcb) && + (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtM) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZmmul)) && + (MCOperand_isReg(MCInst_getOperand(MI, 2))) && (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 2)) == MCOperand_getReg(MCInst_getOperand(MI, 0))) && + (MCOperand_isReg(MCInst_getOperand(MI, 2))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 2)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1))))) { + // c.mul $rd, $rs2 + // Operand: rd_wb + // Operand: rd + // Operand: rs2 + return true; + } // if + break; + } // case MUL + case RISCV_OR: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 1)) == MCOperand_getReg(MCInst_getOperand(MI, 0))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 2))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 2))))) { + // c.or $rd, $rs2 + // Operand: rd_wb + // Operand: rd + // Operand: rs2 + return true; + } // if + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 2))) && (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 2)) == MCOperand_getReg(MCInst_getOperand(MI, 0))) && + (MCOperand_isReg(MCInst_getOperand(MI, 2))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 2)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1))))) { + // c.or $rd, $rs2 + // Operand: rd_wb + // Operand: rd + // Operand: rs2 + return true; + } // if + break; + } // case OR + case RISCV_SB: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcb) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + MCOperand_isImm(MCInst_getOperand(MI, 2)) && + RISCVValidateMachineOperand(MI,MCInst_getOperand(MI, 2), 11)) { + // c.sb $rs2, ${imm}(${rs1}) + // Operand: rs2 + // Operand: rs1 + // Operand: imm + return true; + } // if + break; + } // case SB + case RISCV_SD: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_Feature64Bit) && + (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + MCOperand_isImm(MCInst_getOperand(MI, 2)) && + RISCVValidateMachineOperand(MI,MCInst_getOperand(MI, 2), 6)) { + // c.sd $rs2, ${imm}(${rs1}) + // Operand: rs2 + // Operand: rs1 + // Operand: imm + return true; + } // if + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_Feature64Bit) && + (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_SPRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + MCOperand_isImm(MCInst_getOperand(MI, 2)) && + RISCVValidateMachineOperand(MI,MCInst_getOperand(MI, 2), 7)) { + // c.sdsp $rs2, ${imm}(${rs1}) + // Operand: rs2 + // Operand: rs1 + // Operand: imm + return true; + } // if + break; + } // case SD + case RISCV_SEXT_B: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZbb) && + RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcb) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 1)) == MCOperand_getReg(MCInst_getOperand(MI, 0))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1))))) { + // c.sext.b $rd + // Operand: rd_wb + // Operand: rd + return true; + } // if + break; + } // case SEXT_B + case RISCV_SEXT_H: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZbb) && + RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcb) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 1)) == MCOperand_getReg(MCInst_getOperand(MI, 0))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1))))) { + // c.sext.h $rd + // Operand: rd_wb + // Operand: rd + return true; + } // if + break; + } // case SEXT_H + case RISCV_SH: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcb) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + MCOperand_isImm(MCInst_getOperand(MI, 2)) && + RISCVValidateMachineOperand(MI,MCInst_getOperand(MI, 2), 12)) { + // c.sh $rs2, ${imm}(${rs1}) + // Operand: rs2 + // Operand: rs1 + // Operand: imm + return true; + } // if + break; + } // case SH + case RISCV_SLLI: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 1)) == MCOperand_getReg(MCInst_getOperand(MI, 0))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRNoX0RegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + MCOperand_isImm(MCInst_getOperand(MI, 2)) && + RISCVValidateMachineOperand(MI,MCInst_getOperand(MI, 2), 14)) { + // c.slli $rd, $imm + // Operand: rd_wb + // Operand: rd + // Operand: imm + return true; + } // if + break; + } // case SLLI + case RISCV_SRAI: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 1)) == MCOperand_getReg(MCInst_getOperand(MI, 0))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + MCOperand_isImm(MCInst_getOperand(MI, 2)) && + RISCVValidateMachineOperand(MI,MCInst_getOperand(MI, 2), 14)) { + // c.srai $rs1, $imm + // Operand: rs1_wb + // Operand: rs1 + // Operand: imm + return true; + } // if + break; + } // case SRAI + case RISCV_SRLI: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 1)) == MCOperand_getReg(MCInst_getOperand(MI, 0))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + MCOperand_isImm(MCInst_getOperand(MI, 2)) && + RISCVValidateMachineOperand(MI,MCInst_getOperand(MI, 2), 14)) { + // c.srli $rs1, $imm + // Operand: rs1_wb + // Operand: rs1 + // Operand: imm + return true; + } // if + break; + } // case SRLI + case RISCV_SSPOPCHK: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcmop) && + RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZicfiss) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 0)) == RISCV_X5)) { + // c.sspopchk $rs1 + // Operand: rs1 + return true; + } // if + break; + } // case SSPOPCHK + case RISCV_SSPUSH: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcmop) && + RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZicfiss) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 0)) == RISCV_X1)) { + // c.sspush $rs1 + // Operand: rs1 + return true; + } // if + break; + } // case SSPUSH + case RISCV_SUB: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 1)) == MCOperand_getReg(MCInst_getOperand(MI, 0))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 2))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 2))))) { + // c.sub $rd, $rs2 + // Operand: rd_wb + // Operand: rd + // Operand: rs2 + return true; + } // if + break; + } // case SUB + case RISCV_SUBW: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_Feature64Bit) && + (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 1)) == MCOperand_getReg(MCInst_getOperand(MI, 0))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 2))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 2))))) { + // c.subw $rd, $rs2 + // Operand: rd_wb + // Operand: rd + // Operand: rs2 + return true; + } // if + break; + } // case SUBW + case RISCV_SW: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + MCOperand_isImm(MCInst_getOperand(MI, 2)) && + RISCVValidateMachineOperand(MI,MCInst_getOperand(MI, 2), 8)) { + // c.sw $rs2, ${imm}(${rs1}) + // Operand: rs2 + // Operand: rs1 + // Operand: imm + return true; + } // if + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 0)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_SPRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + MCOperand_isImm(MCInst_getOperand(MI, 2)) && + RISCVValidateMachineOperand(MI,MCInst_getOperand(MI, 2), 9)) { + // c.swsp $rs2, ${imm}(${rs1}) + // Operand: rs2 + // Operand: rs1 + // Operand: imm + return true; + } // if + break; + } // case SW + case RISCV_UNIMP: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca))) { + // c.unimp + return true; + } // if + break; + } // case UNIMP + case RISCV_XOR: { + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 1)) == MCOperand_getReg(MCInst_getOperand(MI, 0))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 2))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 2))))) { + // c.xor $rd, $rs2 + // Operand: rd_wb + // Operand: rd + // Operand: rs2 + return true; + } // if + if ((RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZca)) && + (MCOperand_isReg(MCInst_getOperand(MI, 2))) && (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 2)) == MCOperand_getReg(MCInst_getOperand(MI, 0))) && + (MCOperand_isReg(MCInst_getOperand(MI, 2))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 2)))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1))))) { + // c.xor $rd, $rs2 + // Operand: rd_wb + // Operand: rd + // Operand: rs2 + return true; + } // if + break; + } // case XOR + case RISCV_XORI: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcb) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 1)) == MCOperand_getReg(MCInst_getOperand(MI, 0))) && + (MCOperand_isImm(MCInst_getOperand(MI, 2))) && + (MCOperand_getImm(MCInst_getOperand(MI, 2)) == -1) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1))))) { + // c.not $rd + // Operand: rd_wb + // Operand: rd + return true; + } // if + break; + } // case XORI + case RISCV_ZEXT_H_RV32: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZbb) && + RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcb) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 1)) == MCOperand_getReg(MCInst_getOperand(MI, 0))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1))))) { + // c.zext.h $rd + // Operand: rd_wb + // Operand: rd + return true; + } // if + break; + } // case ZEXT_H_RV32 + case RISCV_ZEXT_H_RV64: { + if (RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZbb) && + RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureStdExtZcb) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && (MCOperand_isReg(MCInst_getOperand(MI, 0))) && + (MCOperand_getReg(MCInst_getOperand(MI, 1)) == MCOperand_getReg(MCInst_getOperand(MI, 0))) && + (MCOperand_isReg(MCInst_getOperand(MI, 1))) && + (MCRegisterClass_contains(MCRegisterInfo_getRegClass(MI->MRI, RISCV_GPRCRegClassID),MCOperand_getReg(MCInst_getOperand(MI, 1))))) { + // c.zext.h $rd + // Operand: rd_wb + // Operand: rd + return true; + } // if + + } // case ZEXT_H_RV64 + } // switch + return false; +} + +#endif //GEN_CHECK_COMPRESS_INSTR + diff --git a/arch/RISCV/RISCVGenDisassemblerTables.inc b/arch/RISCV/RISCVGenDisassemblerTables.inc index d3f5c86160..967d9f8adc 100644 --- a/arch/RISCV/RISCVGenDisassemblerTables.inc +++ b/arch/RISCV/RISCVGenDisassemblerTables.inc @@ -1,188 +1,287 @@ -/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\ -|* *| -|* * RISCV Disassembler *| -|* *| -|* Automatically generated file, do not edit! *| -|* *| -\*===----------------------------------------------------------------------===*/ +/* Capstone Disassembly Engine, https://www.capstone-engine.org */ +/* By Nguyen Anh Quynh , 2013-2022, */ +/* Rot127 2022-2024 */ +/* Automatically generated file by Capstone's LLVM TableGen Disassembler Backend. */ -/* Capstone Disassembly Engine */ -/* By Nguyen Anh Quynh , 2013-2015 */ +/* LLVM-commit: */ +/* LLVM-tag: */ + +/* Do not edit. */ + +/* Capstone's LLVM TableGen Backends: */ +/* https://github.com/capstone-engine/llvm-capstone */ #include "../../MCInst.h" -#include "../../LEB128.h" #include "../../cs_priv.h" +#include "../../LEB128.h" -// Helper functions for extracting fields from encoded instructions. -// InsnType must either be integral or an APInt-like object that must: -// * Have a static const max_size_in_bits equal to the number of bits in the -// encoding. -// * be default-constructible and copy-constructible -// * be constructible from a uint64_t -// * be constructible from an APInt (this can be private) -// * Support getBitsSet(loBit, hiBit) -// * be convertible to uint64_t -// * Support the ~, &, ==, !=, and |= operators with other objects of the same type -// * Support shift (<<, >>) with signed and unsigned integers on the RHS -// * Support put (<<) to raw_ostream& +// Helper function for extracting fields from encoded instructions. #define FieldFromInstruction(fname, InsnType) \ static InsnType fname(InsnType insn, unsigned startBit, unsigned numBits) \ { \ InsnType fieldMask; \ - if (numBits == sizeof(InsnType)*8) \ + if (numBits == sizeof(InsnType) * 8) \ fieldMask = (InsnType)(-1LL); \ else \ fieldMask = (((InsnType)1 << numBits) - 1) << startBit; \ return (insn & fieldMask) >> startBit; \ } +static bool Check(DecodeStatus *Out, const DecodeStatus In) { + *Out = (DecodeStatus) (*Out & In); + return *Out != MCDisassembler_Fail; +} + static const uint8_t DecoderTable16[] = { /* 0 */ MCD_OPC_ExtractField, 13, 3, // Inst{15-13} ... -/* 3 */ MCD_OPC_FilterValue, 0, 77, 0, 0, // Skip to: 85 +/* 3 */ MCD_OPC_FilterValue, 0, 155, 0, 0, // Skip to: 163 /* 8 */ MCD_OPC_ExtractField, 0, 2, // Inst{1-0} ... /* 11 */ MCD_OPC_FilterValue, 0, 25, 0, 0, // Skip to: 41 /* 16 */ MCD_OPC_CheckPredicate, 0, 11, 0, 0, // Skip to: 32 /* 21 */ MCD_OPC_CheckField, 2, 11, 0, 4, 0, 0, // Skip to: 32 -/* 28 */ MCD_OPC_Decode, 182, 2, 0, // Opcode: C_UNIMP -/* 32 */ MCD_OPC_CheckPredicate, 0, 124, 2, 0, // Skip to: 673 -/* 37 */ MCD_OPC_Decode, 144, 2, 1, // Opcode: C_ADDI4SPN -/* 41 */ MCD_OPC_FilterValue, 1, 25, 0, 0, // Skip to: 71 +/* 28 */ MCD_OPC_Decode, 162, 92, 0, // Opcode: C_UNIMP +/* 32 */ MCD_OPC_CheckPredicate, 0, 113, 4, 0, // Skip to: 1174 +/* 37 */ MCD_OPC_Decode, 230, 91, 1, // Opcode: C_ADDI4SPN +/* 41 */ MCD_OPC_FilterValue, 1, 64, 0, 0, // Skip to: 110 /* 46 */ MCD_OPC_CheckPredicate, 0, 11, 0, 0, // Skip to: 62 -/* 51 */ MCD_OPC_CheckField, 7, 6, 0, 4, 0, 0, // Skip to: 62 -/* 58 */ MCD_OPC_Decode, 171, 2, 0, // Opcode: C_NOP -/* 62 */ MCD_OPC_CheckPredicate, 0, 94, 2, 0, // Skip to: 673 -/* 67 */ MCD_OPC_Decode, 142, 2, 2, // Opcode: C_ADDI -/* 71 */ MCD_OPC_FilterValue, 2, 85, 2, 0, // Skip to: 673 -/* 76 */ MCD_OPC_CheckPredicate, 0, 80, 2, 0, // Skip to: 673 -/* 81 */ MCD_OPC_Decode, 175, 2, 3, // Opcode: C_SLLI -/* 85 */ MCD_OPC_FilterValue, 1, 45, 0, 0, // Skip to: 135 -/* 90 */ MCD_OPC_ExtractField, 0, 2, // Inst{1-0} ... -/* 93 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 107 -/* 98 */ MCD_OPC_CheckPredicate, 1, 58, 2, 0, // Skip to: 673 -/* 103 */ MCD_OPC_Decode, 152, 2, 4, // Opcode: C_FLD -/* 107 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 121 -/* 112 */ MCD_OPC_CheckPredicate, 2, 44, 2, 0, // Skip to: 673 -/* 117 */ MCD_OPC_Decode, 145, 2, 2, // Opcode: C_ADDIW -/* 121 */ MCD_OPC_FilterValue, 2, 35, 2, 0, // Skip to: 673 -/* 126 */ MCD_OPC_CheckPredicate, 1, 30, 2, 0, // Skip to: 673 -/* 131 */ MCD_OPC_Decode, 153, 2, 5, // Opcode: C_FLDSP -/* 135 */ MCD_OPC_FilterValue, 2, 45, 0, 0, // Skip to: 185 -/* 140 */ MCD_OPC_ExtractField, 0, 2, // Inst{1-0} ... -/* 143 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 157 -/* 148 */ MCD_OPC_CheckPredicate, 0, 8, 2, 0, // Skip to: 673 -/* 153 */ MCD_OPC_Decode, 168, 2, 6, // Opcode: C_LW -/* 157 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 171 -/* 162 */ MCD_OPC_CheckPredicate, 0, 250, 1, 0, // Skip to: 673 -/* 167 */ MCD_OPC_Decode, 166, 2, 7, // Opcode: C_LI -/* 171 */ MCD_OPC_FilterValue, 2, 241, 1, 0, // Skip to: 673 -/* 176 */ MCD_OPC_CheckPredicate, 0, 236, 1, 0, // Skip to: 673 -/* 181 */ MCD_OPC_Decode, 169, 2, 8, // Opcode: C_LWSP -/* 185 */ MCD_OPC_FilterValue, 3, 61, 0, 0, // Skip to: 251 -/* 190 */ MCD_OPC_ExtractField, 0, 2, // Inst{1-0} ... -/* 193 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 207 -/* 198 */ MCD_OPC_CheckPredicate, 2, 214, 1, 0, // Skip to: 673 -/* 203 */ MCD_OPC_Decode, 164, 2, 9, // Opcode: C_LD -/* 207 */ MCD_OPC_FilterValue, 1, 25, 0, 0, // Skip to: 237 -/* 212 */ MCD_OPC_CheckPredicate, 0, 11, 0, 0, // Skip to: 228 -/* 217 */ MCD_OPC_CheckField, 7, 5, 2, 4, 0, 0, // Skip to: 228 -/* 224 */ MCD_OPC_Decode, 143, 2, 10, // Opcode: C_ADDI16SP -/* 228 */ MCD_OPC_CheckPredicate, 0, 184, 1, 0, // Skip to: 673 -/* 233 */ MCD_OPC_Decode, 167, 2, 11, // Opcode: C_LUI -/* 237 */ MCD_OPC_FilterValue, 2, 175, 1, 0, // Skip to: 673 -/* 242 */ MCD_OPC_CheckPredicate, 2, 170, 1, 0, // Skip to: 673 -/* 247 */ MCD_OPC_Decode, 165, 2, 12, // Opcode: C_LDSP -/* 251 */ MCD_OPC_FilterValue, 4, 11, 1, 0, // Skip to: 523 -/* 256 */ MCD_OPC_ExtractField, 0, 2, // Inst{1-0} ... -/* 259 */ MCD_OPC_FilterValue, 1, 175, 0, 0, // Skip to: 439 -/* 264 */ MCD_OPC_ExtractField, 10, 2, // Inst{11-10} ... -/* 267 */ MCD_OPC_FilterValue, 0, 17, 0, 0, // Skip to: 289 -/* 272 */ MCD_OPC_CheckPredicate, 0, 140, 1, 0, // Skip to: 673 -/* 277 */ MCD_OPC_ExtractField, 12, 1, // Inst{12} ... -/* 280 */ MCD_OPC_FilterValue, 0, 132, 1, 0, // Skip to: 673 -/* 285 */ MCD_OPC_Decode, 177, 2, 13, // Opcode: C_SRLI -/* 289 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 303 -/* 294 */ MCD_OPC_CheckPredicate, 0, 118, 1, 0, // Skip to: 673 -/* 299 */ MCD_OPC_Decode, 176, 2, 13, // Opcode: C_SRAI -/* 303 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 317 -/* 308 */ MCD_OPC_CheckPredicate, 0, 104, 1, 0, // Skip to: 673 -/* 313 */ MCD_OPC_Decode, 148, 2, 14, // Opcode: C_ANDI -/* 317 */ MCD_OPC_FilterValue, 3, 95, 1, 0, // Skip to: 673 -/* 322 */ MCD_OPC_ExtractField, 5, 2, // Inst{6-5} ... -/* 325 */ MCD_OPC_FilterValue, 0, 31, 0, 0, // Skip to: 361 -/* 330 */ MCD_OPC_ExtractField, 12, 1, // Inst{12} ... -/* 333 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 347 -/* 338 */ MCD_OPC_CheckPredicate, 0, 74, 1, 0, // Skip to: 673 -/* 343 */ MCD_OPC_Decode, 178, 2, 15, // Opcode: C_SUB -/* 347 */ MCD_OPC_FilterValue, 1, 65, 1, 0, // Skip to: 673 -/* 352 */ MCD_OPC_CheckPredicate, 2, 60, 1, 0, // Skip to: 673 -/* 357 */ MCD_OPC_Decode, 179, 2, 15, // Opcode: C_SUBW -/* 361 */ MCD_OPC_FilterValue, 1, 31, 0, 0, // Skip to: 397 -/* 366 */ MCD_OPC_ExtractField, 12, 1, // Inst{12} ... -/* 369 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 383 -/* 374 */ MCD_OPC_CheckPredicate, 0, 38, 1, 0, // Skip to: 673 -/* 379 */ MCD_OPC_Decode, 183, 2, 15, // Opcode: C_XOR -/* 383 */ MCD_OPC_FilterValue, 1, 29, 1, 0, // Skip to: 673 -/* 388 */ MCD_OPC_CheckPredicate, 2, 24, 1, 0, // Skip to: 673 -/* 393 */ MCD_OPC_Decode, 146, 2, 15, // Opcode: C_ADDW -/* 397 */ MCD_OPC_FilterValue, 2, 16, 0, 0, // Skip to: 418 -/* 402 */ MCD_OPC_CheckPredicate, 0, 10, 1, 0, // Skip to: 673 -/* 407 */ MCD_OPC_CheckField, 12, 1, 0, 3, 1, 0, // Skip to: 673 -/* 414 */ MCD_OPC_Decode, 172, 2, 15, // Opcode: C_OR -/* 418 */ MCD_OPC_FilterValue, 3, 250, 0, 0, // Skip to: 673 -/* 423 */ MCD_OPC_CheckPredicate, 0, 245, 0, 0, // Skip to: 673 -/* 428 */ MCD_OPC_CheckField, 12, 1, 0, 238, 0, 0, // Skip to: 673 -/* 435 */ MCD_OPC_Decode, 147, 2, 15, // Opcode: C_AND -/* 439 */ MCD_OPC_FilterValue, 2, 229, 0, 0, // Skip to: 673 -/* 444 */ MCD_OPC_ExtractField, 12, 1, // Inst{12} ... -/* 447 */ MCD_OPC_FilterValue, 0, 25, 0, 0, // Skip to: 477 -/* 452 */ MCD_OPC_CheckPredicate, 0, 11, 0, 0, // Skip to: 468 -/* 457 */ MCD_OPC_CheckField, 2, 5, 0, 4, 0, 0, // Skip to: 468 -/* 464 */ MCD_OPC_Decode, 163, 2, 16, // Opcode: C_JR -/* 468 */ MCD_OPC_CheckPredicate, 0, 200, 0, 0, // Skip to: 673 -/* 473 */ MCD_OPC_Decode, 170, 2, 17, // Opcode: C_MV -/* 477 */ MCD_OPC_FilterValue, 1, 191, 0, 0, // Skip to: 673 -/* 482 */ MCD_OPC_CheckPredicate, 0, 11, 0, 0, // Skip to: 498 -/* 487 */ MCD_OPC_CheckField, 2, 10, 0, 4, 0, 0, // Skip to: 498 -/* 494 */ MCD_OPC_Decode, 151, 2, 0, // Opcode: C_EBREAK -/* 498 */ MCD_OPC_CheckPredicate, 0, 11, 0, 0, // Skip to: 514 -/* 503 */ MCD_OPC_CheckField, 2, 5, 0, 4, 0, 0, // Skip to: 514 -/* 510 */ MCD_OPC_Decode, 162, 2, 16, // Opcode: C_JALR -/* 514 */ MCD_OPC_CheckPredicate, 0, 154, 0, 0, // Skip to: 673 -/* 519 */ MCD_OPC_Decode, 141, 2, 18, // Opcode: C_ADD -/* 523 */ MCD_OPC_FilterValue, 5, 45, 0, 0, // Skip to: 573 -/* 528 */ MCD_OPC_ExtractField, 0, 2, // Inst{1-0} ... -/* 531 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 545 -/* 536 */ MCD_OPC_CheckPredicate, 1, 132, 0, 0, // Skip to: 673 -/* 541 */ MCD_OPC_Decode, 156, 2, 4, // Opcode: C_FSD -/* 545 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 559 -/* 550 */ MCD_OPC_CheckPredicate, 0, 118, 0, 0, // Skip to: 673 -/* 555 */ MCD_OPC_Decode, 160, 2, 19, // Opcode: C_J -/* 559 */ MCD_OPC_FilterValue, 2, 109, 0, 0, // Skip to: 673 -/* 564 */ MCD_OPC_CheckPredicate, 1, 104, 0, 0, // Skip to: 673 -/* 569 */ MCD_OPC_Decode, 157, 2, 20, // Opcode: C_FSDSP -/* 573 */ MCD_OPC_FilterValue, 6, 45, 0, 0, // Skip to: 623 -/* 578 */ MCD_OPC_ExtractField, 0, 2, // Inst{1-0} ... -/* 581 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 595 -/* 586 */ MCD_OPC_CheckPredicate, 0, 82, 0, 0, // Skip to: 673 -/* 591 */ MCD_OPC_Decode, 180, 2, 6, // Opcode: C_SW -/* 595 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 609 -/* 600 */ MCD_OPC_CheckPredicate, 0, 68, 0, 0, // Skip to: 673 -/* 605 */ MCD_OPC_Decode, 149, 2, 21, // Opcode: C_BEQZ -/* 609 */ MCD_OPC_FilterValue, 2, 59, 0, 0, // Skip to: 673 -/* 614 */ MCD_OPC_CheckPredicate, 0, 54, 0, 0, // Skip to: 673 -/* 619 */ MCD_OPC_Decode, 181, 2, 22, // Opcode: C_SWSP -/* 623 */ MCD_OPC_FilterValue, 7, 45, 0, 0, // Skip to: 673 -/* 628 */ MCD_OPC_ExtractField, 0, 2, // Inst{1-0} ... -/* 631 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 645 -/* 636 */ MCD_OPC_CheckPredicate, 2, 32, 0, 0, // Skip to: 673 -/* 641 */ MCD_OPC_Decode, 173, 2, 9, // Opcode: C_SD -/* 645 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 659 -/* 650 */ MCD_OPC_CheckPredicate, 0, 18, 0, 0, // Skip to: 673 -/* 655 */ MCD_OPC_Decode, 150, 2, 21, // Opcode: C_BNEZ -/* 659 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 673 -/* 664 */ MCD_OPC_CheckPredicate, 2, 4, 0, 0, // Skip to: 673 -/* 669 */ MCD_OPC_Decode, 174, 2, 23, // Opcode: C_SDSP -/* 673 */ MCD_OPC_Fail, +/* 51 */ MCD_OPC_CheckField, 2, 11, 0, 4, 0, 0, // Skip to: 62 +/* 58 */ MCD_OPC_Decode, 139, 92, 0, // Opcode: C_NOP +/* 62 */ MCD_OPC_CheckPredicate, 1, 18, 0, 0, // Skip to: 85 +/* 67 */ MCD_OPC_CheckField, 12, 1, 0, 11, 0, 0, // Skip to: 85 +/* 74 */ MCD_OPC_CheckField, 2, 5, 0, 4, 0, 0, // Skip to: 85 +/* 81 */ MCD_OPC_Decode, 232, 91, 2, // Opcode: C_ADDI_HINT_IMM_ZERO +/* 85 */ MCD_OPC_CheckPredicate, 1, 11, 0, 0, // Skip to: 101 +/* 90 */ MCD_OPC_CheckField, 7, 5, 0, 4, 0, 0, // Skip to: 101 +/* 97 */ MCD_OPC_Decode, 140, 92, 3, // Opcode: C_NOP_HINT +/* 101 */ MCD_OPC_CheckPredicate, 0, 44, 4, 0, // Skip to: 1174 +/* 106 */ MCD_OPC_Decode, 228, 91, 4, // Opcode: C_ADDI +/* 110 */ MCD_OPC_FilterValue, 2, 35, 4, 0, // Skip to: 1174 +/* 115 */ MCD_OPC_CheckPredicate, 1, 18, 0, 0, // Skip to: 138 +/* 120 */ MCD_OPC_CheckField, 12, 1, 0, 11, 0, 0, // Skip to: 138 +/* 127 */ MCD_OPC_CheckField, 2, 5, 0, 4, 0, 0, // Skip to: 138 +/* 134 */ MCD_OPC_Decode, 150, 92, 5, // Opcode: C_SLLI64_HINT +/* 138 */ MCD_OPC_CheckPredicate, 1, 11, 0, 0, // Skip to: 154 +/* 143 */ MCD_OPC_CheckField, 7, 5, 0, 4, 0, 0, // Skip to: 154 +/* 150 */ MCD_OPC_Decode, 151, 92, 6, // Opcode: C_SLLI_HINT +/* 154 */ MCD_OPC_CheckPredicate, 0, 247, 3, 0, // Skip to: 1174 +/* 159 */ MCD_OPC_Decode, 149, 92, 7, // Opcode: C_SLLI +/* 163 */ MCD_OPC_FilterValue, 1, 45, 0, 0, // Skip to: 213 +/* 168 */ MCD_OPC_ExtractField, 0, 2, // Inst{1-0} ... +/* 171 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 185 +/* 176 */ MCD_OPC_CheckPredicate, 2, 225, 3, 0, // Skip to: 1174 +/* 181 */ MCD_OPC_Decode, 241, 91, 8, // Opcode: C_FLD +/* 185 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 199 +/* 190 */ MCD_OPC_CheckPredicate, 3, 211, 3, 0, // Skip to: 1174 +/* 195 */ MCD_OPC_Decode, 231, 91, 9, // Opcode: C_ADDIW +/* 199 */ MCD_OPC_FilterValue, 2, 202, 3, 0, // Skip to: 1174 +/* 204 */ MCD_OPC_CheckPredicate, 2, 197, 3, 0, // Skip to: 1174 +/* 209 */ MCD_OPC_Decode, 242, 91, 10, // Opcode: C_FLDSP +/* 213 */ MCD_OPC_FilterValue, 2, 61, 0, 0, // Skip to: 279 +/* 218 */ MCD_OPC_ExtractField, 0, 2, // Inst{1-0} ... +/* 221 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 235 +/* 226 */ MCD_OPC_CheckPredicate, 0, 175, 3, 0, // Skip to: 1174 +/* 231 */ MCD_OPC_Decode, 134, 92, 11, // Opcode: C_LW +/* 235 */ MCD_OPC_FilterValue, 1, 25, 0, 0, // Skip to: 265 +/* 240 */ MCD_OPC_CheckPredicate, 1, 11, 0, 0, // Skip to: 256 +/* 245 */ MCD_OPC_CheckField, 7, 5, 0, 4, 0, 0, // Skip to: 256 +/* 252 */ MCD_OPC_Decode, 131, 92, 12, // Opcode: C_LI_HINT +/* 256 */ MCD_OPC_CheckPredicate, 0, 145, 3, 0, // Skip to: 1174 +/* 261 */ MCD_OPC_Decode, 130, 92, 13, // Opcode: C_LI +/* 265 */ MCD_OPC_FilterValue, 2, 136, 3, 0, // Skip to: 1174 +/* 270 */ MCD_OPC_CheckPredicate, 0, 131, 3, 0, // Skip to: 1174 +/* 275 */ MCD_OPC_Decode, 135, 92, 14, // Opcode: C_LWSP +/* 279 */ MCD_OPC_FilterValue, 3, 197, 0, 0, // Skip to: 481 +/* 284 */ MCD_OPC_ExtractField, 0, 2, // Inst{1-0} ... +/* 287 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 301 +/* 292 */ MCD_OPC_CheckPredicate, 3, 109, 3, 0, // Skip to: 1174 +/* 297 */ MCD_OPC_Decode, 254, 91, 15, // Opcode: C_LD +/* 301 */ MCD_OPC_FilterValue, 1, 161, 0, 0, // Skip to: 467 +/* 306 */ MCD_OPC_ExtractField, 2, 11, // Inst{12-2} ... +/* 309 */ MCD_OPC_FilterValue, 32, 9, 0, 0, // Skip to: 323 +/* 314 */ MCD_OPC_CheckPredicate, 4, 108, 0, 0, // Skip to: 427 +/* 319 */ MCD_OPC_Decode, 143, 89, 0, // Opcode: CMOP1 +/* 323 */ MCD_OPC_FilterValue, 96, 9, 0, 0, // Skip to: 337 +/* 328 */ MCD_OPC_CheckPredicate, 4, 94, 0, 0, // Skip to: 427 +/* 333 */ MCD_OPC_Decode, 147, 89, 0, // Opcode: CMOP3 +/* 337 */ MCD_OPC_FilterValue, 160, 1, 9, 0, 0, // Skip to: 352 +/* 343 */ MCD_OPC_CheckPredicate, 4, 79, 0, 0, // Skip to: 427 +/* 348 */ MCD_OPC_Decode, 148, 89, 0, // Opcode: CMOP5 +/* 352 */ MCD_OPC_FilterValue, 224, 1, 9, 0, 0, // Skip to: 367 +/* 358 */ MCD_OPC_CheckPredicate, 4, 64, 0, 0, // Skip to: 427 +/* 363 */ MCD_OPC_Decode, 149, 89, 0, // Opcode: CMOP7 +/* 367 */ MCD_OPC_FilterValue, 160, 2, 9, 0, 0, // Skip to: 382 +/* 373 */ MCD_OPC_CheckPredicate, 4, 49, 0, 0, // Skip to: 427 +/* 378 */ MCD_OPC_Decode, 150, 89, 0, // Opcode: CMOP9 +/* 382 */ MCD_OPC_FilterValue, 224, 2, 9, 0, 0, // Skip to: 397 +/* 388 */ MCD_OPC_CheckPredicate, 4, 34, 0, 0, // Skip to: 427 +/* 393 */ MCD_OPC_Decode, 144, 89, 0, // Opcode: CMOP11 +/* 397 */ MCD_OPC_FilterValue, 160, 3, 9, 0, 0, // Skip to: 412 +/* 403 */ MCD_OPC_CheckPredicate, 4, 19, 0, 0, // Skip to: 427 +/* 408 */ MCD_OPC_Decode, 145, 89, 0, // Opcode: CMOP13 +/* 412 */ MCD_OPC_FilterValue, 224, 3, 9, 0, 0, // Skip to: 427 +/* 418 */ MCD_OPC_CheckPredicate, 4, 4, 0, 0, // Skip to: 427 +/* 423 */ MCD_OPC_Decode, 146, 89, 0, // Opcode: CMOP15 +/* 427 */ MCD_OPC_ExtractField, 7, 5, // Inst{11-7} ... +/* 430 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 444 +/* 435 */ MCD_OPC_CheckPredicate, 1, 18, 0, 0, // Skip to: 458 +/* 440 */ MCD_OPC_Decode, 133, 92, 12, // Opcode: C_LUI_HINT +/* 444 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 458 +/* 449 */ MCD_OPC_CheckPredicate, 0, 4, 0, 0, // Skip to: 458 +/* 454 */ MCD_OPC_Decode, 229, 91, 16, // Opcode: C_ADDI16SP +/* 458 */ MCD_OPC_CheckPredicate, 0, 199, 2, 0, // Skip to: 1174 +/* 463 */ MCD_OPC_Decode, 132, 92, 17, // Opcode: C_LUI +/* 467 */ MCD_OPC_FilterValue, 2, 190, 2, 0, // Skip to: 1174 +/* 472 */ MCD_OPC_CheckPredicate, 3, 185, 2, 0, // Skip to: 1174 +/* 477 */ MCD_OPC_Decode, 255, 91, 18, // Opcode: C_LDSP +/* 481 */ MCD_OPC_FilterValue, 4, 26, 2, 0, // Skip to: 1024 +/* 486 */ MCD_OPC_ExtractField, 0, 2, // Inst{1-0} ... +/* 489 */ MCD_OPC_FilterValue, 0, 88, 0, 0, // Skip to: 582 +/* 494 */ MCD_OPC_ExtractField, 10, 3, // Inst{12-10} ... +/* 497 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 511 +/* 502 */ MCD_OPC_CheckPredicate, 5, 155, 2, 0, // Skip to: 1174 +/* 507 */ MCD_OPC_Decode, 253, 91, 19, // Opcode: C_LBU +/* 511 */ MCD_OPC_FilterValue, 1, 31, 0, 0, // Skip to: 547 +/* 516 */ MCD_OPC_ExtractField, 6, 1, // Inst{6} ... +/* 519 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 533 +/* 524 */ MCD_OPC_CheckPredicate, 5, 133, 2, 0, // Skip to: 1174 +/* 529 */ MCD_OPC_Decode, 129, 92, 20, // Opcode: C_LHU +/* 533 */ MCD_OPC_FilterValue, 1, 124, 2, 0, // Skip to: 1174 +/* 538 */ MCD_OPC_CheckPredicate, 5, 119, 2, 0, // Skip to: 1174 +/* 543 */ MCD_OPC_Decode, 128, 92, 20, // Opcode: C_LH +/* 547 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 561 +/* 552 */ MCD_OPC_CheckPredicate, 5, 105, 2, 0, // Skip to: 1174 +/* 557 */ MCD_OPC_Decode, 143, 92, 19, // Opcode: C_SB +/* 561 */ MCD_OPC_FilterValue, 3, 96, 2, 0, // Skip to: 1174 +/* 566 */ MCD_OPC_CheckPredicate, 5, 91, 2, 0, // Skip to: 1174 +/* 571 */ MCD_OPC_CheckField, 6, 1, 0, 84, 2, 0, // Skip to: 1174 +/* 578 */ MCD_OPC_Decode, 148, 92, 20, // Opcode: C_SH +/* 582 */ MCD_OPC_FilterValue, 1, 65, 1, 0, // Skip to: 908 +/* 587 */ MCD_OPC_ExtractField, 10, 2, // Inst{11-10} ... +/* 590 */ MCD_OPC_FilterValue, 0, 32, 0, 0, // Skip to: 627 +/* 595 */ MCD_OPC_CheckPredicate, 1, 18, 0, 0, // Skip to: 618 +/* 600 */ MCD_OPC_CheckField, 12, 1, 0, 11, 0, 0, // Skip to: 618 +/* 607 */ MCD_OPC_CheckField, 2, 5, 0, 4, 0, 0, // Skip to: 618 +/* 614 */ MCD_OPC_Decode, 155, 92, 21, // Opcode: C_SRLI64_HINT +/* 618 */ MCD_OPC_CheckPredicate, 0, 39, 2, 0, // Skip to: 1174 +/* 623 */ MCD_OPC_Decode, 154, 92, 22, // Opcode: C_SRLI +/* 627 */ MCD_OPC_FilterValue, 1, 32, 0, 0, // Skip to: 664 +/* 632 */ MCD_OPC_CheckPredicate, 1, 18, 0, 0, // Skip to: 655 +/* 637 */ MCD_OPC_CheckField, 12, 1, 0, 11, 0, 0, // Skip to: 655 +/* 644 */ MCD_OPC_CheckField, 2, 5, 0, 4, 0, 0, // Skip to: 655 +/* 651 */ MCD_OPC_Decode, 153, 92, 21, // Opcode: C_SRAI64_HINT +/* 655 */ MCD_OPC_CheckPredicate, 0, 2, 2, 0, // Skip to: 1174 +/* 660 */ MCD_OPC_Decode, 152, 92, 22, // Opcode: C_SRAI +/* 664 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 678 +/* 669 */ MCD_OPC_CheckPredicate, 0, 244, 1, 0, // Skip to: 1174 +/* 674 */ MCD_OPC_Decode, 237, 91, 23, // Opcode: C_ANDI +/* 678 */ MCD_OPC_FilterValue, 3, 235, 1, 0, // Skip to: 1174 +/* 683 */ MCD_OPC_ExtractField, 5, 2, // Inst{6-5} ... +/* 686 */ MCD_OPC_FilterValue, 0, 31, 0, 0, // Skip to: 722 +/* 691 */ MCD_OPC_ExtractField, 12, 1, // Inst{12} ... +/* 694 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 708 +/* 699 */ MCD_OPC_CheckPredicate, 0, 214, 1, 0, // Skip to: 1174 +/* 704 */ MCD_OPC_Decode, 158, 92, 24, // Opcode: C_SUB +/* 708 */ MCD_OPC_FilterValue, 1, 205, 1, 0, // Skip to: 1174 +/* 713 */ MCD_OPC_CheckPredicate, 3, 200, 1, 0, // Skip to: 1174 +/* 718 */ MCD_OPC_Decode, 159, 92, 24, // Opcode: C_SUBW +/* 722 */ MCD_OPC_FilterValue, 1, 31, 0, 0, // Skip to: 758 +/* 727 */ MCD_OPC_ExtractField, 12, 1, // Inst{12} ... +/* 730 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 744 +/* 735 */ MCD_OPC_CheckPredicate, 0, 178, 1, 0, // Skip to: 1174 +/* 740 */ MCD_OPC_Decode, 163, 92, 24, // Opcode: C_XOR +/* 744 */ MCD_OPC_FilterValue, 1, 169, 1, 0, // Skip to: 1174 +/* 749 */ MCD_OPC_CheckPredicate, 3, 164, 1, 0, // Skip to: 1174 +/* 754 */ MCD_OPC_Decode, 234, 91, 24, // Opcode: C_ADDW +/* 758 */ MCD_OPC_FilterValue, 2, 31, 0, 0, // Skip to: 794 +/* 763 */ MCD_OPC_ExtractField, 12, 1, // Inst{12} ... +/* 766 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 780 +/* 771 */ MCD_OPC_CheckPredicate, 0, 142, 1, 0, // Skip to: 1174 +/* 776 */ MCD_OPC_Decode, 142, 92, 24, // Opcode: C_OR +/* 780 */ MCD_OPC_FilterValue, 1, 133, 1, 0, // Skip to: 1174 +/* 785 */ MCD_OPC_CheckPredicate, 6, 128, 1, 0, // Skip to: 1174 +/* 790 */ MCD_OPC_Decode, 136, 92, 24, // Opcode: C_MUL +/* 794 */ MCD_OPC_FilterValue, 3, 119, 1, 0, // Skip to: 1174 +/* 799 */ MCD_OPC_ExtractField, 12, 1, // Inst{12} ... +/* 802 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 816 +/* 807 */ MCD_OPC_CheckPredicate, 0, 106, 1, 0, // Skip to: 1174 +/* 812 */ MCD_OPC_Decode, 236, 91, 24, // Opcode: C_AND +/* 816 */ MCD_OPC_FilterValue, 1, 97, 1, 0, // Skip to: 1174 +/* 821 */ MCD_OPC_ExtractField, 2, 3, // Inst{4-2} ... +/* 824 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 838 +/* 829 */ MCD_OPC_CheckPredicate, 5, 84, 1, 0, // Skip to: 1174 +/* 834 */ MCD_OPC_Decode, 164, 92, 21, // Opcode: C_ZEXT_B +/* 838 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 852 +/* 843 */ MCD_OPC_CheckPredicate, 7, 70, 1, 0, // Skip to: 1174 +/* 848 */ MCD_OPC_Decode, 146, 92, 21, // Opcode: C_SEXT_B +/* 852 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 866 +/* 857 */ MCD_OPC_CheckPredicate, 7, 56, 1, 0, // Skip to: 1174 +/* 862 */ MCD_OPC_Decode, 165, 92, 21, // Opcode: C_ZEXT_H +/* 866 */ MCD_OPC_FilterValue, 3, 9, 0, 0, // Skip to: 880 +/* 871 */ MCD_OPC_CheckPredicate, 7, 42, 1, 0, // Skip to: 1174 +/* 876 */ MCD_OPC_Decode, 147, 92, 21, // Opcode: C_SEXT_H +/* 880 */ MCD_OPC_FilterValue, 4, 9, 0, 0, // Skip to: 894 +/* 885 */ MCD_OPC_CheckPredicate, 8, 28, 1, 0, // Skip to: 1174 +/* 890 */ MCD_OPC_Decode, 166, 92, 21, // Opcode: C_ZEXT_W +/* 894 */ MCD_OPC_FilterValue, 5, 19, 1, 0, // Skip to: 1174 +/* 899 */ MCD_OPC_CheckPredicate, 5, 14, 1, 0, // Skip to: 1174 +/* 904 */ MCD_OPC_Decode, 141, 92, 21, // Opcode: C_NOT +/* 908 */ MCD_OPC_FilterValue, 2, 5, 1, 0, // Skip to: 1174 +/* 913 */ MCD_OPC_ExtractField, 12, 1, // Inst{12} ... +/* 916 */ MCD_OPC_FilterValue, 0, 41, 0, 0, // Skip to: 962 +/* 921 */ MCD_OPC_CheckPredicate, 0, 11, 0, 0, // Skip to: 937 +/* 926 */ MCD_OPC_CheckField, 2, 5, 0, 4, 0, 0, // Skip to: 937 +/* 933 */ MCD_OPC_Decode, 252, 91, 25, // Opcode: C_JR +/* 937 */ MCD_OPC_CheckPredicate, 1, 11, 0, 0, // Skip to: 953 +/* 942 */ MCD_OPC_CheckField, 7, 5, 0, 4, 0, 0, // Skip to: 953 +/* 949 */ MCD_OPC_Decode, 138, 92, 26, // Opcode: C_MV_HINT +/* 953 */ MCD_OPC_CheckPredicate, 0, 216, 0, 0, // Skip to: 1174 +/* 958 */ MCD_OPC_Decode, 137, 92, 27, // Opcode: C_MV +/* 962 */ MCD_OPC_FilterValue, 1, 207, 0, 0, // Skip to: 1174 +/* 967 */ MCD_OPC_CheckPredicate, 0, 11, 0, 0, // Skip to: 983 +/* 972 */ MCD_OPC_CheckField, 2, 10, 0, 4, 0, 0, // Skip to: 983 +/* 979 */ MCD_OPC_Decode, 240, 91, 0, // Opcode: C_EBREAK +/* 983 */ MCD_OPC_CheckPredicate, 1, 11, 0, 0, // Skip to: 999 +/* 988 */ MCD_OPC_CheckField, 7, 5, 0, 4, 0, 0, // Skip to: 999 +/* 995 */ MCD_OPC_Decode, 235, 91, 28, // Opcode: C_ADD_HINT +/* 999 */ MCD_OPC_CheckPredicate, 0, 11, 0, 0, // Skip to: 1015 +/* 1004 */ MCD_OPC_CheckField, 2, 5, 0, 4, 0, 0, // Skip to: 1015 +/* 1011 */ MCD_OPC_Decode, 251, 91, 25, // Opcode: C_JALR +/* 1015 */ MCD_OPC_CheckPredicate, 0, 154, 0, 0, // Skip to: 1174 +/* 1020 */ MCD_OPC_Decode, 227, 91, 29, // Opcode: C_ADD +/* 1024 */ MCD_OPC_FilterValue, 5, 45, 0, 0, // Skip to: 1074 +/* 1029 */ MCD_OPC_ExtractField, 0, 2, // Inst{1-0} ... +/* 1032 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 1046 +/* 1037 */ MCD_OPC_CheckPredicate, 2, 132, 0, 0, // Skip to: 1174 +/* 1042 */ MCD_OPC_Decode, 245, 91, 8, // Opcode: C_FSD +/* 1046 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 1060 +/* 1051 */ MCD_OPC_CheckPredicate, 0, 118, 0, 0, // Skip to: 1174 +/* 1056 */ MCD_OPC_Decode, 249, 91, 30, // Opcode: C_J +/* 1060 */ MCD_OPC_FilterValue, 2, 109, 0, 0, // Skip to: 1174 +/* 1065 */ MCD_OPC_CheckPredicate, 2, 104, 0, 0, // Skip to: 1174 +/* 1070 */ MCD_OPC_Decode, 246, 91, 31, // Opcode: C_FSDSP +/* 1074 */ MCD_OPC_FilterValue, 6, 45, 0, 0, // Skip to: 1124 +/* 1079 */ MCD_OPC_ExtractField, 0, 2, // Inst{1-0} ... +/* 1082 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 1096 +/* 1087 */ MCD_OPC_CheckPredicate, 0, 82, 0, 0, // Skip to: 1174 +/* 1092 */ MCD_OPC_Decode, 160, 92, 11, // Opcode: C_SW +/* 1096 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 1110 +/* 1101 */ MCD_OPC_CheckPredicate, 0, 68, 0, 0, // Skip to: 1174 +/* 1106 */ MCD_OPC_Decode, 238, 91, 32, // Opcode: C_BEQZ +/* 1110 */ MCD_OPC_FilterValue, 2, 59, 0, 0, // Skip to: 1174 +/* 1115 */ MCD_OPC_CheckPredicate, 0, 54, 0, 0, // Skip to: 1174 +/* 1120 */ MCD_OPC_Decode, 161, 92, 33, // Opcode: C_SWSP +/* 1124 */ MCD_OPC_FilterValue, 7, 45, 0, 0, // Skip to: 1174 +/* 1129 */ MCD_OPC_ExtractField, 0, 2, // Inst{1-0} ... +/* 1132 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 1146 +/* 1137 */ MCD_OPC_CheckPredicate, 3, 32, 0, 0, // Skip to: 1174 +/* 1142 */ MCD_OPC_Decode, 144, 92, 15, // Opcode: C_SD +/* 1146 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 1160 +/* 1151 */ MCD_OPC_CheckPredicate, 0, 18, 0, 0, // Skip to: 1174 +/* 1156 */ MCD_OPC_Decode, 239, 91, 32, // Opcode: C_BNEZ +/* 1160 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 1174 +/* 1165 */ MCD_OPC_CheckPredicate, 3, 4, 0, 0, // Skip to: 1174 +/* 1170 */ MCD_OPC_Decode, 145, 92, 34, // Opcode: C_SDSP +/* 1174 */ MCD_OPC_Fail, 0 }; @@ -191,1091 +290,7450 @@ static const uint8_t DecoderTable32[] = { /* 3 */ MCD_OPC_FilterValue, 3, 76, 0, 0, // Skip to: 84 /* 8 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... /* 11 */ MCD_OPC_FilterValue, 0, 4, 0, 0, // Skip to: 20 -/* 16 */ MCD_OPC_Decode, 129, 3, 24, // Opcode: LB +/* 16 */ MCD_OPC_Decode, 190, 94, 35, // Opcode: LB /* 20 */ MCD_OPC_FilterValue, 1, 4, 0, 0, // Skip to: 29 -/* 25 */ MCD_OPC_Decode, 132, 3, 24, // Opcode: LH +/* 25 */ MCD_OPC_Decode, 193, 94, 35, // Opcode: LH /* 29 */ MCD_OPC_FilterValue, 2, 4, 0, 0, // Skip to: 38 -/* 34 */ MCD_OPC_Decode, 143, 3, 24, // Opcode: LW +/* 34 */ MCD_OPC_Decode, 204, 94, 35, // Opcode: LW /* 38 */ MCD_OPC_FilterValue, 3, 9, 0, 0, // Skip to: 52 -/* 43 */ MCD_OPC_CheckPredicate, 3, 55, 15, 0, // Skip to: 3943 -/* 48 */ MCD_OPC_Decode, 131, 3, 24, // Opcode: LD +/* 43 */ MCD_OPC_CheckPredicate, 9, 2, 74, 0, // Skip to: 18994 +/* 48 */ MCD_OPC_Decode, 192, 94, 35, // Opcode: LD /* 52 */ MCD_OPC_FilterValue, 4, 4, 0, 0, // Skip to: 61 -/* 57 */ MCD_OPC_Decode, 130, 3, 24, // Opcode: LBU +/* 57 */ MCD_OPC_Decode, 191, 94, 35, // Opcode: LBU /* 61 */ MCD_OPC_FilterValue, 5, 4, 0, 0, // Skip to: 70 -/* 66 */ MCD_OPC_Decode, 133, 3, 24, // Opcode: LHU -/* 70 */ MCD_OPC_FilterValue, 6, 28, 15, 0, // Skip to: 3943 -/* 75 */ MCD_OPC_CheckPredicate, 3, 23, 15, 0, // Skip to: 3943 -/* 80 */ MCD_OPC_Decode, 144, 3, 24, // Opcode: LWU -/* 84 */ MCD_OPC_FilterValue, 7, 31, 0, 0, // Skip to: 120 +/* 66 */ MCD_OPC_Decode, 194, 94, 35, // Opcode: LHU +/* 70 */ MCD_OPC_FilterValue, 6, 231, 73, 0, // Skip to: 18994 +/* 75 */ MCD_OPC_CheckPredicate, 9, 226, 73, 0, // Skip to: 18994 +/* 80 */ MCD_OPC_Decode, 205, 94, 35, // Opcode: LWU +/* 84 */ MCD_OPC_FilterValue, 7, 114, 11, 0, // Skip to: 3019 /* 89 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 92 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 106 -/* 97 */ MCD_OPC_CheckPredicate, 4, 1, 15, 0, // Skip to: 3943 -/* 102 */ MCD_OPC_Decode, 224, 2, 25, // Opcode: FLW -/* 106 */ MCD_OPC_FilterValue, 3, 248, 14, 0, // Skip to: 3943 -/* 111 */ MCD_OPC_CheckPredicate, 5, 243, 14, 0, // Skip to: 3943 -/* 116 */ MCD_OPC_Decode, 219, 2, 26, // Opcode: FLD -/* 120 */ MCD_OPC_FilterValue, 15, 52, 0, 0, // Skip to: 177 -/* 125 */ MCD_OPC_ExtractField, 7, 13, // Inst{19-7} ... -/* 128 */ MCD_OPC_FilterValue, 0, 28, 0, 0, // Skip to: 161 -/* 133 */ MCD_OPC_ExtractField, 28, 4, // Inst{31-28} ... -/* 136 */ MCD_OPC_FilterValue, 0, 4, 0, 0, // Skip to: 145 -/* 141 */ MCD_OPC_Decode, 214, 2, 27, // Opcode: FENCE -/* 145 */ MCD_OPC_FilterValue, 8, 209, 14, 0, // Skip to: 3943 -/* 150 */ MCD_OPC_CheckField, 20, 8, 51, 202, 14, 0, // Skip to: 3943 -/* 157 */ MCD_OPC_Decode, 216, 2, 0, // Opcode: FENCE_TSO -/* 161 */ MCD_OPC_FilterValue, 32, 193, 14, 0, // Skip to: 3943 -/* 166 */ MCD_OPC_CheckField, 20, 12, 0, 186, 14, 0, // Skip to: 3943 -/* 173 */ MCD_OPC_Decode, 215, 2, 0, // Opcode: FENCE_I -/* 177 */ MCD_OPC_FilterValue, 19, 99, 0, 0, // Skip to: 281 -/* 182 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 185 */ MCD_OPC_FilterValue, 0, 4, 0, 0, // Skip to: 194 -/* 190 */ MCD_OPC_Decode, 179, 1, 24, // Opcode: ADDI -/* 194 */ MCD_OPC_FilterValue, 1, 11, 0, 0, // Skip to: 210 -/* 199 */ MCD_OPC_CheckField, 26, 6, 0, 153, 14, 0, // Skip to: 3943 -/* 206 */ MCD_OPC_Decode, 170, 3, 28, // Opcode: SLLI -/* 210 */ MCD_OPC_FilterValue, 2, 4, 0, 0, // Skip to: 219 -/* 215 */ MCD_OPC_Decode, 174, 3, 24, // Opcode: SLTI -/* 219 */ MCD_OPC_FilterValue, 3, 4, 0, 0, // Skip to: 228 -/* 224 */ MCD_OPC_Decode, 175, 3, 24, // Opcode: SLTIU -/* 228 */ MCD_OPC_FilterValue, 4, 4, 0, 0, // Skip to: 237 -/* 233 */ MCD_OPC_Decode, 193, 3, 24, // Opcode: XORI -/* 237 */ MCD_OPC_FilterValue, 5, 21, 0, 0, // Skip to: 263 -/* 242 */ MCD_OPC_ExtractField, 26, 6, // Inst{31-26} ... -/* 245 */ MCD_OPC_FilterValue, 0, 4, 0, 0, // Skip to: 254 -/* 250 */ MCD_OPC_Decode, 183, 3, 28, // Opcode: SRLI -/* 254 */ MCD_OPC_FilterValue, 16, 100, 14, 0, // Skip to: 3943 -/* 259 */ MCD_OPC_Decode, 178, 3, 28, // Opcode: SRAI -/* 263 */ MCD_OPC_FilterValue, 6, 4, 0, 0, // Skip to: 272 -/* 268 */ MCD_OPC_Decode, 152, 3, 24, // Opcode: ORI -/* 272 */ MCD_OPC_FilterValue, 7, 82, 14, 0, // Skip to: 3943 -/* 277 */ MCD_OPC_Decode, 255, 1, 24, // Opcode: ANDI -/* 281 */ MCD_OPC_FilterValue, 23, 4, 0, 0, // Skip to: 290 -/* 286 */ MCD_OPC_Decode, 128, 2, 29, // Opcode: AUIPC -/* 290 */ MCD_OPC_FilterValue, 27, 74, 0, 0, // Skip to: 369 -/* 295 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 298 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 312 -/* 303 */ MCD_OPC_CheckPredicate, 3, 51, 14, 0, // Skip to: 3943 -/* 308 */ MCD_OPC_Decode, 180, 1, 24, // Opcode: ADDIW -/* 312 */ MCD_OPC_FilterValue, 1, 16, 0, 0, // Skip to: 333 -/* 317 */ MCD_OPC_CheckPredicate, 3, 37, 14, 0, // Skip to: 3943 -/* 322 */ MCD_OPC_CheckField, 25, 7, 0, 30, 14, 0, // Skip to: 3943 -/* 329 */ MCD_OPC_Decode, 171, 3, 30, // Opcode: SLLIW -/* 333 */ MCD_OPC_FilterValue, 5, 21, 14, 0, // Skip to: 3943 -/* 338 */ MCD_OPC_ExtractField, 25, 7, // Inst{31-25} ... -/* 341 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 355 -/* 346 */ MCD_OPC_CheckPredicate, 3, 8, 14, 0, // Skip to: 3943 -/* 351 */ MCD_OPC_Decode, 184, 3, 30, // Opcode: SRLIW -/* 355 */ MCD_OPC_FilterValue, 32, 255, 13, 0, // Skip to: 3943 -/* 360 */ MCD_OPC_CheckPredicate, 3, 250, 13, 0, // Skip to: 3943 -/* 365 */ MCD_OPC_Decode, 179, 3, 30, // Opcode: SRAIW -/* 369 */ MCD_OPC_FilterValue, 35, 44, 0, 0, // Skip to: 418 -/* 374 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 377 */ MCD_OPC_FilterValue, 0, 4, 0, 0, // Skip to: 386 -/* 382 */ MCD_OPC_Decode, 157, 3, 31, // Opcode: SB -/* 386 */ MCD_OPC_FilterValue, 1, 4, 0, 0, // Skip to: 395 -/* 391 */ MCD_OPC_Decode, 168, 3, 31, // Opcode: SH -/* 395 */ MCD_OPC_FilterValue, 2, 4, 0, 0, // Skip to: 404 -/* 400 */ MCD_OPC_Decode, 188, 3, 31, // Opcode: SW -/* 404 */ MCD_OPC_FilterValue, 3, 206, 13, 0, // Skip to: 3943 -/* 409 */ MCD_OPC_CheckPredicate, 3, 201, 13, 0, // Skip to: 3943 -/* 414 */ MCD_OPC_Decode, 166, 3, 31, // Opcode: SD -/* 418 */ MCD_OPC_FilterValue, 39, 31, 0, 0, // Skip to: 454 -/* 423 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 426 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 440 -/* 431 */ MCD_OPC_CheckPredicate, 4, 179, 13, 0, // Skip to: 3943 -/* 436 */ MCD_OPC_Decode, 254, 2, 32, // Opcode: FSW -/* 440 */ MCD_OPC_FilterValue, 3, 170, 13, 0, // Skip to: 3943 -/* 445 */ MCD_OPC_CheckPredicate, 5, 165, 13, 0, // Skip to: 3943 -/* 450 */ MCD_OPC_Decode, 243, 2, 33, // Opcode: FSD -/* 454 */ MCD_OPC_FilterValue, 47, 107, 6, 0, // Skip to: 2102 -/* 459 */ MCD_OPC_ExtractField, 25, 7, // Inst{31-25} ... -/* 462 */ MCD_OPC_FilterValue, 0, 31, 0, 0, // Skip to: 498 -/* 467 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 470 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 484 -/* 475 */ MCD_OPC_CheckPredicate, 6, 135, 13, 0, // Skip to: 3943 -/* 480 */ MCD_OPC_Decode, 186, 1, 34, // Opcode: AMOADD_W -/* 484 */ MCD_OPC_FilterValue, 3, 126, 13, 0, // Skip to: 3943 -/* 489 */ MCD_OPC_CheckPredicate, 7, 121, 13, 0, // Skip to: 3943 -/* 494 */ MCD_OPC_Decode, 182, 1, 34, // Opcode: AMOADD_D -/* 498 */ MCD_OPC_FilterValue, 1, 31, 0, 0, // Skip to: 534 -/* 503 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 506 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 520 -/* 511 */ MCD_OPC_CheckPredicate, 6, 99, 13, 0, // Skip to: 3943 -/* 516 */ MCD_OPC_Decode, 189, 1, 34, // Opcode: AMOADD_W_RL -/* 520 */ MCD_OPC_FilterValue, 3, 90, 13, 0, // Skip to: 3943 -/* 525 */ MCD_OPC_CheckPredicate, 7, 85, 13, 0, // Skip to: 3943 -/* 530 */ MCD_OPC_Decode, 185, 1, 34, // Opcode: AMOADD_D_RL -/* 534 */ MCD_OPC_FilterValue, 2, 31, 0, 0, // Skip to: 570 -/* 539 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 542 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 556 -/* 547 */ MCD_OPC_CheckPredicate, 6, 63, 13, 0, // Skip to: 3943 -/* 552 */ MCD_OPC_Decode, 187, 1, 34, // Opcode: AMOADD_W_AQ -/* 556 */ MCD_OPC_FilterValue, 3, 54, 13, 0, // Skip to: 3943 -/* 561 */ MCD_OPC_CheckPredicate, 7, 49, 13, 0, // Skip to: 3943 -/* 566 */ MCD_OPC_Decode, 183, 1, 34, // Opcode: AMOADD_D_AQ -/* 570 */ MCD_OPC_FilterValue, 3, 31, 0, 0, // Skip to: 606 -/* 575 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 578 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 592 -/* 583 */ MCD_OPC_CheckPredicate, 6, 27, 13, 0, // Skip to: 3943 -/* 588 */ MCD_OPC_Decode, 188, 1, 34, // Opcode: AMOADD_W_AQ_RL -/* 592 */ MCD_OPC_FilterValue, 3, 18, 13, 0, // Skip to: 3943 -/* 597 */ MCD_OPC_CheckPredicate, 7, 13, 13, 0, // Skip to: 3943 -/* 602 */ MCD_OPC_Decode, 184, 1, 34, // Opcode: AMOADD_D_AQ_RL -/* 606 */ MCD_OPC_FilterValue, 4, 31, 0, 0, // Skip to: 642 -/* 611 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 614 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 628 -/* 619 */ MCD_OPC_CheckPredicate, 6, 247, 12, 0, // Skip to: 3943 -/* 624 */ MCD_OPC_Decode, 242, 1, 34, // Opcode: AMOSWAP_W -/* 628 */ MCD_OPC_FilterValue, 3, 238, 12, 0, // Skip to: 3943 -/* 633 */ MCD_OPC_CheckPredicate, 7, 233, 12, 0, // Skip to: 3943 -/* 638 */ MCD_OPC_Decode, 238, 1, 34, // Opcode: AMOSWAP_D -/* 642 */ MCD_OPC_FilterValue, 5, 31, 0, 0, // Skip to: 678 -/* 647 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 650 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 664 -/* 655 */ MCD_OPC_CheckPredicate, 6, 211, 12, 0, // Skip to: 3943 -/* 660 */ MCD_OPC_Decode, 245, 1, 34, // Opcode: AMOSWAP_W_RL -/* 664 */ MCD_OPC_FilterValue, 3, 202, 12, 0, // Skip to: 3943 -/* 669 */ MCD_OPC_CheckPredicate, 7, 197, 12, 0, // Skip to: 3943 -/* 674 */ MCD_OPC_Decode, 241, 1, 34, // Opcode: AMOSWAP_D_RL -/* 678 */ MCD_OPC_FilterValue, 6, 31, 0, 0, // Skip to: 714 -/* 683 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 686 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 700 -/* 691 */ MCD_OPC_CheckPredicate, 6, 175, 12, 0, // Skip to: 3943 -/* 696 */ MCD_OPC_Decode, 243, 1, 34, // Opcode: AMOSWAP_W_AQ -/* 700 */ MCD_OPC_FilterValue, 3, 166, 12, 0, // Skip to: 3943 -/* 705 */ MCD_OPC_CheckPredicate, 7, 161, 12, 0, // Skip to: 3943 -/* 710 */ MCD_OPC_Decode, 239, 1, 34, // Opcode: AMOSWAP_D_AQ -/* 714 */ MCD_OPC_FilterValue, 7, 31, 0, 0, // Skip to: 750 -/* 719 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 722 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 736 -/* 727 */ MCD_OPC_CheckPredicate, 6, 139, 12, 0, // Skip to: 3943 -/* 732 */ MCD_OPC_Decode, 244, 1, 34, // Opcode: AMOSWAP_W_AQ_RL -/* 736 */ MCD_OPC_FilterValue, 3, 130, 12, 0, // Skip to: 3943 -/* 741 */ MCD_OPC_CheckPredicate, 7, 125, 12, 0, // Skip to: 3943 -/* 746 */ MCD_OPC_Decode, 240, 1, 34, // Opcode: AMOSWAP_D_AQ_RL -/* 750 */ MCD_OPC_FilterValue, 8, 45, 0, 0, // Skip to: 800 -/* 755 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 758 */ MCD_OPC_FilterValue, 2, 16, 0, 0, // Skip to: 779 -/* 763 */ MCD_OPC_CheckPredicate, 6, 103, 12, 0, // Skip to: 3943 -/* 768 */ MCD_OPC_CheckField, 20, 5, 0, 96, 12, 0, // Skip to: 3943 -/* 775 */ MCD_OPC_Decode, 138, 3, 35, // Opcode: LR_W -/* 779 */ MCD_OPC_FilterValue, 3, 87, 12, 0, // Skip to: 3943 -/* 784 */ MCD_OPC_CheckPredicate, 7, 82, 12, 0, // Skip to: 3943 -/* 789 */ MCD_OPC_CheckField, 20, 5, 0, 75, 12, 0, // Skip to: 3943 -/* 796 */ MCD_OPC_Decode, 134, 3, 35, // Opcode: LR_D -/* 800 */ MCD_OPC_FilterValue, 9, 45, 0, 0, // Skip to: 850 -/* 805 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 808 */ MCD_OPC_FilterValue, 2, 16, 0, 0, // Skip to: 829 -/* 813 */ MCD_OPC_CheckPredicate, 6, 53, 12, 0, // Skip to: 3943 -/* 818 */ MCD_OPC_CheckField, 20, 5, 0, 46, 12, 0, // Skip to: 3943 -/* 825 */ MCD_OPC_Decode, 141, 3, 35, // Opcode: LR_W_RL -/* 829 */ MCD_OPC_FilterValue, 3, 37, 12, 0, // Skip to: 3943 -/* 834 */ MCD_OPC_CheckPredicate, 7, 32, 12, 0, // Skip to: 3943 -/* 839 */ MCD_OPC_CheckField, 20, 5, 0, 25, 12, 0, // Skip to: 3943 -/* 846 */ MCD_OPC_Decode, 137, 3, 35, // Opcode: LR_D_RL -/* 850 */ MCD_OPC_FilterValue, 10, 45, 0, 0, // Skip to: 900 -/* 855 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 858 */ MCD_OPC_FilterValue, 2, 16, 0, 0, // Skip to: 879 -/* 863 */ MCD_OPC_CheckPredicate, 6, 3, 12, 0, // Skip to: 3943 -/* 868 */ MCD_OPC_CheckField, 20, 5, 0, 252, 11, 0, // Skip to: 3943 -/* 875 */ MCD_OPC_Decode, 139, 3, 35, // Opcode: LR_W_AQ -/* 879 */ MCD_OPC_FilterValue, 3, 243, 11, 0, // Skip to: 3943 -/* 884 */ MCD_OPC_CheckPredicate, 7, 238, 11, 0, // Skip to: 3943 -/* 889 */ MCD_OPC_CheckField, 20, 5, 0, 231, 11, 0, // Skip to: 3943 -/* 896 */ MCD_OPC_Decode, 135, 3, 35, // Opcode: LR_D_AQ -/* 900 */ MCD_OPC_FilterValue, 11, 45, 0, 0, // Skip to: 950 -/* 905 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 908 */ MCD_OPC_FilterValue, 2, 16, 0, 0, // Skip to: 929 -/* 913 */ MCD_OPC_CheckPredicate, 6, 209, 11, 0, // Skip to: 3943 -/* 918 */ MCD_OPC_CheckField, 20, 5, 0, 202, 11, 0, // Skip to: 3943 -/* 925 */ MCD_OPC_Decode, 140, 3, 35, // Opcode: LR_W_AQ_RL -/* 929 */ MCD_OPC_FilterValue, 3, 193, 11, 0, // Skip to: 3943 -/* 934 */ MCD_OPC_CheckPredicate, 7, 188, 11, 0, // Skip to: 3943 -/* 939 */ MCD_OPC_CheckField, 20, 5, 0, 181, 11, 0, // Skip to: 3943 -/* 946 */ MCD_OPC_Decode, 136, 3, 35, // Opcode: LR_D_AQ_RL -/* 950 */ MCD_OPC_FilterValue, 12, 31, 0, 0, // Skip to: 986 -/* 955 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 958 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 972 -/* 963 */ MCD_OPC_CheckPredicate, 6, 159, 11, 0, // Skip to: 3943 -/* 968 */ MCD_OPC_Decode, 162, 3, 34, // Opcode: SC_W -/* 972 */ MCD_OPC_FilterValue, 3, 150, 11, 0, // Skip to: 3943 -/* 977 */ MCD_OPC_CheckPredicate, 7, 145, 11, 0, // Skip to: 3943 -/* 982 */ MCD_OPC_Decode, 158, 3, 34, // Opcode: SC_D -/* 986 */ MCD_OPC_FilterValue, 13, 31, 0, 0, // Skip to: 1022 -/* 991 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 994 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 1008 -/* 999 */ MCD_OPC_CheckPredicate, 6, 123, 11, 0, // Skip to: 3943 -/* 1004 */ MCD_OPC_Decode, 165, 3, 34, // Opcode: SC_W_RL -/* 1008 */ MCD_OPC_FilterValue, 3, 114, 11, 0, // Skip to: 3943 -/* 1013 */ MCD_OPC_CheckPredicate, 7, 109, 11, 0, // Skip to: 3943 -/* 1018 */ MCD_OPC_Decode, 161, 3, 34, // Opcode: SC_D_RL -/* 1022 */ MCD_OPC_FilterValue, 14, 31, 0, 0, // Skip to: 1058 -/* 1027 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 1030 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 1044 -/* 1035 */ MCD_OPC_CheckPredicate, 6, 87, 11, 0, // Skip to: 3943 -/* 1040 */ MCD_OPC_Decode, 163, 3, 34, // Opcode: SC_W_AQ -/* 1044 */ MCD_OPC_FilterValue, 3, 78, 11, 0, // Skip to: 3943 -/* 1049 */ MCD_OPC_CheckPredicate, 7, 73, 11, 0, // Skip to: 3943 -/* 1054 */ MCD_OPC_Decode, 159, 3, 34, // Opcode: SC_D_AQ -/* 1058 */ MCD_OPC_FilterValue, 15, 31, 0, 0, // Skip to: 1094 -/* 1063 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 1066 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 1080 -/* 1071 */ MCD_OPC_CheckPredicate, 6, 51, 11, 0, // Skip to: 3943 -/* 1076 */ MCD_OPC_Decode, 164, 3, 34, // Opcode: SC_W_AQ_RL -/* 1080 */ MCD_OPC_FilterValue, 3, 42, 11, 0, // Skip to: 3943 -/* 1085 */ MCD_OPC_CheckPredicate, 7, 37, 11, 0, // Skip to: 3943 -/* 1090 */ MCD_OPC_Decode, 160, 3, 34, // Opcode: SC_D_AQ_RL -/* 1094 */ MCD_OPC_FilterValue, 16, 31, 0, 0, // Skip to: 1130 -/* 1099 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 1102 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 1116 -/* 1107 */ MCD_OPC_CheckPredicate, 6, 15, 11, 0, // Skip to: 3943 -/* 1112 */ MCD_OPC_Decode, 250, 1, 34, // Opcode: AMOXOR_W -/* 1116 */ MCD_OPC_FilterValue, 3, 6, 11, 0, // Skip to: 3943 -/* 1121 */ MCD_OPC_CheckPredicate, 7, 1, 11, 0, // Skip to: 3943 -/* 1126 */ MCD_OPC_Decode, 246, 1, 34, // Opcode: AMOXOR_D -/* 1130 */ MCD_OPC_FilterValue, 17, 31, 0, 0, // Skip to: 1166 -/* 1135 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 1138 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 1152 -/* 1143 */ MCD_OPC_CheckPredicate, 6, 235, 10, 0, // Skip to: 3943 -/* 1148 */ MCD_OPC_Decode, 253, 1, 34, // Opcode: AMOXOR_W_RL -/* 1152 */ MCD_OPC_FilterValue, 3, 226, 10, 0, // Skip to: 3943 -/* 1157 */ MCD_OPC_CheckPredicate, 7, 221, 10, 0, // Skip to: 3943 -/* 1162 */ MCD_OPC_Decode, 249, 1, 34, // Opcode: AMOXOR_D_RL -/* 1166 */ MCD_OPC_FilterValue, 18, 31, 0, 0, // Skip to: 1202 -/* 1171 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 1174 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 1188 -/* 1179 */ MCD_OPC_CheckPredicate, 6, 199, 10, 0, // Skip to: 3943 -/* 1184 */ MCD_OPC_Decode, 251, 1, 34, // Opcode: AMOXOR_W_AQ -/* 1188 */ MCD_OPC_FilterValue, 3, 190, 10, 0, // Skip to: 3943 -/* 1193 */ MCD_OPC_CheckPredicate, 7, 185, 10, 0, // Skip to: 3943 -/* 1198 */ MCD_OPC_Decode, 247, 1, 34, // Opcode: AMOXOR_D_AQ -/* 1202 */ MCD_OPC_FilterValue, 19, 31, 0, 0, // Skip to: 1238 -/* 1207 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 1210 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 1224 -/* 1215 */ MCD_OPC_CheckPredicate, 6, 163, 10, 0, // Skip to: 3943 -/* 1220 */ MCD_OPC_Decode, 252, 1, 34, // Opcode: AMOXOR_W_AQ_RL -/* 1224 */ MCD_OPC_FilterValue, 3, 154, 10, 0, // Skip to: 3943 -/* 1229 */ MCD_OPC_CheckPredicate, 7, 149, 10, 0, // Skip to: 3943 -/* 1234 */ MCD_OPC_Decode, 248, 1, 34, // Opcode: AMOXOR_D_AQ_RL -/* 1238 */ MCD_OPC_FilterValue, 32, 31, 0, 0, // Skip to: 1274 -/* 1243 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 1246 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 1260 -/* 1251 */ MCD_OPC_CheckPredicate, 6, 127, 10, 0, // Skip to: 3943 -/* 1256 */ MCD_OPC_Decode, 234, 1, 34, // Opcode: AMOOR_W -/* 1260 */ MCD_OPC_FilterValue, 3, 118, 10, 0, // Skip to: 3943 -/* 1265 */ MCD_OPC_CheckPredicate, 7, 113, 10, 0, // Skip to: 3943 -/* 1270 */ MCD_OPC_Decode, 230, 1, 34, // Opcode: AMOOR_D -/* 1274 */ MCD_OPC_FilterValue, 33, 31, 0, 0, // Skip to: 1310 -/* 1279 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 1282 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 1296 -/* 1287 */ MCD_OPC_CheckPredicate, 6, 91, 10, 0, // Skip to: 3943 -/* 1292 */ MCD_OPC_Decode, 237, 1, 34, // Opcode: AMOOR_W_RL -/* 1296 */ MCD_OPC_FilterValue, 3, 82, 10, 0, // Skip to: 3943 -/* 1301 */ MCD_OPC_CheckPredicate, 7, 77, 10, 0, // Skip to: 3943 -/* 1306 */ MCD_OPC_Decode, 233, 1, 34, // Opcode: AMOOR_D_RL -/* 1310 */ MCD_OPC_FilterValue, 34, 31, 0, 0, // Skip to: 1346 -/* 1315 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 1318 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 1332 -/* 1323 */ MCD_OPC_CheckPredicate, 6, 55, 10, 0, // Skip to: 3943 -/* 1328 */ MCD_OPC_Decode, 235, 1, 34, // Opcode: AMOOR_W_AQ -/* 1332 */ MCD_OPC_FilterValue, 3, 46, 10, 0, // Skip to: 3943 -/* 1337 */ MCD_OPC_CheckPredicate, 7, 41, 10, 0, // Skip to: 3943 -/* 1342 */ MCD_OPC_Decode, 231, 1, 34, // Opcode: AMOOR_D_AQ -/* 1346 */ MCD_OPC_FilterValue, 35, 31, 0, 0, // Skip to: 1382 -/* 1351 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 1354 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 1368 -/* 1359 */ MCD_OPC_CheckPredicate, 6, 19, 10, 0, // Skip to: 3943 -/* 1364 */ MCD_OPC_Decode, 236, 1, 34, // Opcode: AMOOR_W_AQ_RL -/* 1368 */ MCD_OPC_FilterValue, 3, 10, 10, 0, // Skip to: 3943 -/* 1373 */ MCD_OPC_CheckPredicate, 7, 5, 10, 0, // Skip to: 3943 -/* 1378 */ MCD_OPC_Decode, 232, 1, 34, // Opcode: AMOOR_D_AQ_RL -/* 1382 */ MCD_OPC_FilterValue, 48, 31, 0, 0, // Skip to: 1418 -/* 1387 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 1390 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 1404 -/* 1395 */ MCD_OPC_CheckPredicate, 6, 239, 9, 0, // Skip to: 3943 -/* 1400 */ MCD_OPC_Decode, 194, 1, 34, // Opcode: AMOAND_W -/* 1404 */ MCD_OPC_FilterValue, 3, 230, 9, 0, // Skip to: 3943 -/* 1409 */ MCD_OPC_CheckPredicate, 7, 225, 9, 0, // Skip to: 3943 -/* 1414 */ MCD_OPC_Decode, 190, 1, 34, // Opcode: AMOAND_D -/* 1418 */ MCD_OPC_FilterValue, 49, 31, 0, 0, // Skip to: 1454 -/* 1423 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 1426 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 1440 -/* 1431 */ MCD_OPC_CheckPredicate, 6, 203, 9, 0, // Skip to: 3943 -/* 1436 */ MCD_OPC_Decode, 197, 1, 34, // Opcode: AMOAND_W_RL -/* 1440 */ MCD_OPC_FilterValue, 3, 194, 9, 0, // Skip to: 3943 -/* 1445 */ MCD_OPC_CheckPredicate, 7, 189, 9, 0, // Skip to: 3943 -/* 1450 */ MCD_OPC_Decode, 193, 1, 34, // Opcode: AMOAND_D_RL -/* 1454 */ MCD_OPC_FilterValue, 50, 31, 0, 0, // Skip to: 1490 -/* 1459 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 1462 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 1476 -/* 1467 */ MCD_OPC_CheckPredicate, 6, 167, 9, 0, // Skip to: 3943 -/* 1472 */ MCD_OPC_Decode, 195, 1, 34, // Opcode: AMOAND_W_AQ -/* 1476 */ MCD_OPC_FilterValue, 3, 158, 9, 0, // Skip to: 3943 -/* 1481 */ MCD_OPC_CheckPredicate, 7, 153, 9, 0, // Skip to: 3943 -/* 1486 */ MCD_OPC_Decode, 191, 1, 34, // Opcode: AMOAND_D_AQ -/* 1490 */ MCD_OPC_FilterValue, 51, 31, 0, 0, // Skip to: 1526 -/* 1495 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 1498 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 1512 -/* 1503 */ MCD_OPC_CheckPredicate, 6, 131, 9, 0, // Skip to: 3943 -/* 1508 */ MCD_OPC_Decode, 196, 1, 34, // Opcode: AMOAND_W_AQ_RL -/* 1512 */ MCD_OPC_FilterValue, 3, 122, 9, 0, // Skip to: 3943 -/* 1517 */ MCD_OPC_CheckPredicate, 7, 117, 9, 0, // Skip to: 3943 -/* 1522 */ MCD_OPC_Decode, 192, 1, 34, // Opcode: AMOAND_D_AQ_RL -/* 1526 */ MCD_OPC_FilterValue, 64, 31, 0, 0, // Skip to: 1562 -/* 1531 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 1534 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 1548 -/* 1539 */ MCD_OPC_CheckPredicate, 6, 95, 9, 0, // Skip to: 3943 -/* 1544 */ MCD_OPC_Decode, 226, 1, 34, // Opcode: AMOMIN_W -/* 1548 */ MCD_OPC_FilterValue, 3, 86, 9, 0, // Skip to: 3943 -/* 1553 */ MCD_OPC_CheckPredicate, 7, 81, 9, 0, // Skip to: 3943 -/* 1558 */ MCD_OPC_Decode, 222, 1, 34, // Opcode: AMOMIN_D -/* 1562 */ MCD_OPC_FilterValue, 65, 31, 0, 0, // Skip to: 1598 -/* 1567 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 1570 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 1584 -/* 1575 */ MCD_OPC_CheckPredicate, 6, 59, 9, 0, // Skip to: 3943 -/* 1580 */ MCD_OPC_Decode, 229, 1, 34, // Opcode: AMOMIN_W_RL -/* 1584 */ MCD_OPC_FilterValue, 3, 50, 9, 0, // Skip to: 3943 -/* 1589 */ MCD_OPC_CheckPredicate, 7, 45, 9, 0, // Skip to: 3943 -/* 1594 */ MCD_OPC_Decode, 225, 1, 34, // Opcode: AMOMIN_D_RL -/* 1598 */ MCD_OPC_FilterValue, 66, 31, 0, 0, // Skip to: 1634 -/* 1603 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 1606 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 1620 -/* 1611 */ MCD_OPC_CheckPredicate, 6, 23, 9, 0, // Skip to: 3943 -/* 1616 */ MCD_OPC_Decode, 227, 1, 34, // Opcode: AMOMIN_W_AQ -/* 1620 */ MCD_OPC_FilterValue, 3, 14, 9, 0, // Skip to: 3943 -/* 1625 */ MCD_OPC_CheckPredicate, 7, 9, 9, 0, // Skip to: 3943 -/* 1630 */ MCD_OPC_Decode, 223, 1, 34, // Opcode: AMOMIN_D_AQ -/* 1634 */ MCD_OPC_FilterValue, 67, 31, 0, 0, // Skip to: 1670 -/* 1639 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 1642 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 1656 -/* 1647 */ MCD_OPC_CheckPredicate, 6, 243, 8, 0, // Skip to: 3943 -/* 1652 */ MCD_OPC_Decode, 228, 1, 34, // Opcode: AMOMIN_W_AQ_RL -/* 1656 */ MCD_OPC_FilterValue, 3, 234, 8, 0, // Skip to: 3943 -/* 1661 */ MCD_OPC_CheckPredicate, 7, 229, 8, 0, // Skip to: 3943 -/* 1666 */ MCD_OPC_Decode, 224, 1, 34, // Opcode: AMOMIN_D_AQ_RL -/* 1670 */ MCD_OPC_FilterValue, 80, 31, 0, 0, // Skip to: 1706 -/* 1675 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 1678 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 1692 -/* 1683 */ MCD_OPC_CheckPredicate, 6, 207, 8, 0, // Skip to: 3943 -/* 1688 */ MCD_OPC_Decode, 210, 1, 34, // Opcode: AMOMAX_W -/* 1692 */ MCD_OPC_FilterValue, 3, 198, 8, 0, // Skip to: 3943 -/* 1697 */ MCD_OPC_CheckPredicate, 7, 193, 8, 0, // Skip to: 3943 -/* 1702 */ MCD_OPC_Decode, 206, 1, 34, // Opcode: AMOMAX_D -/* 1706 */ MCD_OPC_FilterValue, 81, 31, 0, 0, // Skip to: 1742 -/* 1711 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 1714 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 1728 -/* 1719 */ MCD_OPC_CheckPredicate, 6, 171, 8, 0, // Skip to: 3943 -/* 1724 */ MCD_OPC_Decode, 213, 1, 34, // Opcode: AMOMAX_W_RL -/* 1728 */ MCD_OPC_FilterValue, 3, 162, 8, 0, // Skip to: 3943 -/* 1733 */ MCD_OPC_CheckPredicate, 7, 157, 8, 0, // Skip to: 3943 -/* 1738 */ MCD_OPC_Decode, 209, 1, 34, // Opcode: AMOMAX_D_RL -/* 1742 */ MCD_OPC_FilterValue, 82, 31, 0, 0, // Skip to: 1778 -/* 1747 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 1750 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 1764 -/* 1755 */ MCD_OPC_CheckPredicate, 6, 135, 8, 0, // Skip to: 3943 -/* 1760 */ MCD_OPC_Decode, 211, 1, 34, // Opcode: AMOMAX_W_AQ -/* 1764 */ MCD_OPC_FilterValue, 3, 126, 8, 0, // Skip to: 3943 -/* 1769 */ MCD_OPC_CheckPredicate, 7, 121, 8, 0, // Skip to: 3943 -/* 1774 */ MCD_OPC_Decode, 207, 1, 34, // Opcode: AMOMAX_D_AQ -/* 1778 */ MCD_OPC_FilterValue, 83, 31, 0, 0, // Skip to: 1814 -/* 1783 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 1786 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 1800 -/* 1791 */ MCD_OPC_CheckPredicate, 6, 99, 8, 0, // Skip to: 3943 -/* 1796 */ MCD_OPC_Decode, 212, 1, 34, // Opcode: AMOMAX_W_AQ_RL -/* 1800 */ MCD_OPC_FilterValue, 3, 90, 8, 0, // Skip to: 3943 -/* 1805 */ MCD_OPC_CheckPredicate, 7, 85, 8, 0, // Skip to: 3943 -/* 1810 */ MCD_OPC_Decode, 208, 1, 34, // Opcode: AMOMAX_D_AQ_RL -/* 1814 */ MCD_OPC_FilterValue, 96, 31, 0, 0, // Skip to: 1850 -/* 1819 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 1822 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 1836 -/* 1827 */ MCD_OPC_CheckPredicate, 6, 63, 8, 0, // Skip to: 3943 -/* 1832 */ MCD_OPC_Decode, 218, 1, 34, // Opcode: AMOMINU_W -/* 1836 */ MCD_OPC_FilterValue, 3, 54, 8, 0, // Skip to: 3943 -/* 1841 */ MCD_OPC_CheckPredicate, 7, 49, 8, 0, // Skip to: 3943 -/* 1846 */ MCD_OPC_Decode, 214, 1, 34, // Opcode: AMOMINU_D -/* 1850 */ MCD_OPC_FilterValue, 97, 31, 0, 0, // Skip to: 1886 -/* 1855 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 1858 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 1872 -/* 1863 */ MCD_OPC_CheckPredicate, 6, 27, 8, 0, // Skip to: 3943 -/* 1868 */ MCD_OPC_Decode, 221, 1, 34, // Opcode: AMOMINU_W_RL -/* 1872 */ MCD_OPC_FilterValue, 3, 18, 8, 0, // Skip to: 3943 -/* 1877 */ MCD_OPC_CheckPredicate, 7, 13, 8, 0, // Skip to: 3943 -/* 1882 */ MCD_OPC_Decode, 217, 1, 34, // Opcode: AMOMINU_D_RL -/* 1886 */ MCD_OPC_FilterValue, 98, 31, 0, 0, // Skip to: 1922 -/* 1891 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 1894 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 1908 -/* 1899 */ MCD_OPC_CheckPredicate, 6, 247, 7, 0, // Skip to: 3943 -/* 1904 */ MCD_OPC_Decode, 219, 1, 34, // Opcode: AMOMINU_W_AQ -/* 1908 */ MCD_OPC_FilterValue, 3, 238, 7, 0, // Skip to: 3943 -/* 1913 */ MCD_OPC_CheckPredicate, 7, 233, 7, 0, // Skip to: 3943 -/* 1918 */ MCD_OPC_Decode, 215, 1, 34, // Opcode: AMOMINU_D_AQ -/* 1922 */ MCD_OPC_FilterValue, 99, 31, 0, 0, // Skip to: 1958 -/* 1927 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 1930 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 1944 -/* 1935 */ MCD_OPC_CheckPredicate, 6, 211, 7, 0, // Skip to: 3943 -/* 1940 */ MCD_OPC_Decode, 220, 1, 34, // Opcode: AMOMINU_W_AQ_RL -/* 1944 */ MCD_OPC_FilterValue, 3, 202, 7, 0, // Skip to: 3943 -/* 1949 */ MCD_OPC_CheckPredicate, 7, 197, 7, 0, // Skip to: 3943 -/* 1954 */ MCD_OPC_Decode, 216, 1, 34, // Opcode: AMOMINU_D_AQ_RL -/* 1958 */ MCD_OPC_FilterValue, 112, 31, 0, 0, // Skip to: 1994 -/* 1963 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 1966 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 1980 -/* 1971 */ MCD_OPC_CheckPredicate, 6, 175, 7, 0, // Skip to: 3943 -/* 1976 */ MCD_OPC_Decode, 202, 1, 34, // Opcode: AMOMAXU_W -/* 1980 */ MCD_OPC_FilterValue, 3, 166, 7, 0, // Skip to: 3943 -/* 1985 */ MCD_OPC_CheckPredicate, 7, 161, 7, 0, // Skip to: 3943 -/* 1990 */ MCD_OPC_Decode, 198, 1, 34, // Opcode: AMOMAXU_D -/* 1994 */ MCD_OPC_FilterValue, 113, 31, 0, 0, // Skip to: 2030 -/* 1999 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 2002 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 2016 -/* 2007 */ MCD_OPC_CheckPredicate, 6, 139, 7, 0, // Skip to: 3943 -/* 2012 */ MCD_OPC_Decode, 205, 1, 34, // Opcode: AMOMAXU_W_RL -/* 2016 */ MCD_OPC_FilterValue, 3, 130, 7, 0, // Skip to: 3943 -/* 2021 */ MCD_OPC_CheckPredicate, 7, 125, 7, 0, // Skip to: 3943 -/* 2026 */ MCD_OPC_Decode, 201, 1, 34, // Opcode: AMOMAXU_D_RL -/* 2030 */ MCD_OPC_FilterValue, 114, 31, 0, 0, // Skip to: 2066 -/* 2035 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 2038 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 2052 -/* 2043 */ MCD_OPC_CheckPredicate, 6, 103, 7, 0, // Skip to: 3943 -/* 2048 */ MCD_OPC_Decode, 203, 1, 34, // Opcode: AMOMAXU_W_AQ -/* 2052 */ MCD_OPC_FilterValue, 3, 94, 7, 0, // Skip to: 3943 -/* 2057 */ MCD_OPC_CheckPredicate, 7, 89, 7, 0, // Skip to: 3943 -/* 2062 */ MCD_OPC_Decode, 199, 1, 34, // Opcode: AMOMAXU_D_AQ -/* 2066 */ MCD_OPC_FilterValue, 115, 80, 7, 0, // Skip to: 3943 -/* 2071 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 2074 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 2088 -/* 2079 */ MCD_OPC_CheckPredicate, 6, 67, 7, 0, // Skip to: 3943 -/* 2084 */ MCD_OPC_Decode, 204, 1, 34, // Opcode: AMOMAXU_W_AQ_RL -/* 2088 */ MCD_OPC_FilterValue, 3, 58, 7, 0, // Skip to: 3943 -/* 2093 */ MCD_OPC_CheckPredicate, 7, 53, 7, 0, // Skip to: 3943 -/* 2098 */ MCD_OPC_Decode, 200, 1, 34, // Opcode: AMOMAXU_D_AQ_RL -/* 2102 */ MCD_OPC_FilterValue, 51, 13, 1, 0, // Skip to: 2376 -/* 2107 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 2110 */ MCD_OPC_FilterValue, 0, 35, 0, 0, // Skip to: 2150 -/* 2115 */ MCD_OPC_ExtractField, 25, 7, // Inst{31-25} ... -/* 2118 */ MCD_OPC_FilterValue, 0, 4, 0, 0, // Skip to: 2127 -/* 2123 */ MCD_OPC_Decode, 178, 1, 34, // Opcode: ADD -/* 2127 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 2141 -/* 2132 */ MCD_OPC_CheckPredicate, 8, 14, 7, 0, // Skip to: 3943 -/* 2137 */ MCD_OPC_Decode, 146, 3, 34, // Opcode: MUL -/* 2141 */ MCD_OPC_FilterValue, 32, 5, 7, 0, // Skip to: 3943 -/* 2146 */ MCD_OPC_Decode, 186, 3, 34, // Opcode: SUB -/* 2150 */ MCD_OPC_FilterValue, 1, 26, 0, 0, // Skip to: 2181 -/* 2155 */ MCD_OPC_ExtractField, 25, 7, // Inst{31-25} ... -/* 2158 */ MCD_OPC_FilterValue, 0, 4, 0, 0, // Skip to: 2167 -/* 2163 */ MCD_OPC_Decode, 169, 3, 34, // Opcode: SLL -/* 2167 */ MCD_OPC_FilterValue, 1, 235, 6, 0, // Skip to: 3943 -/* 2172 */ MCD_OPC_CheckPredicate, 8, 230, 6, 0, // Skip to: 3943 -/* 2177 */ MCD_OPC_Decode, 147, 3, 34, // Opcode: MULH -/* 2181 */ MCD_OPC_FilterValue, 2, 26, 0, 0, // Skip to: 2212 -/* 2186 */ MCD_OPC_ExtractField, 25, 7, // Inst{31-25} ... -/* 2189 */ MCD_OPC_FilterValue, 0, 4, 0, 0, // Skip to: 2198 -/* 2194 */ MCD_OPC_Decode, 173, 3, 34, // Opcode: SLT -/* 2198 */ MCD_OPC_FilterValue, 1, 204, 6, 0, // Skip to: 3943 -/* 2203 */ MCD_OPC_CheckPredicate, 8, 199, 6, 0, // Skip to: 3943 -/* 2208 */ MCD_OPC_Decode, 148, 3, 34, // Opcode: MULHSU -/* 2212 */ MCD_OPC_FilterValue, 3, 26, 0, 0, // Skip to: 2243 -/* 2217 */ MCD_OPC_ExtractField, 25, 7, // Inst{31-25} ... -/* 2220 */ MCD_OPC_FilterValue, 0, 4, 0, 0, // Skip to: 2229 -/* 2225 */ MCD_OPC_Decode, 176, 3, 34, // Opcode: SLTU -/* 2229 */ MCD_OPC_FilterValue, 1, 173, 6, 0, // Skip to: 3943 -/* 2234 */ MCD_OPC_CheckPredicate, 8, 168, 6, 0, // Skip to: 3943 -/* 2239 */ MCD_OPC_Decode, 149, 3, 34, // Opcode: MULHU -/* 2243 */ MCD_OPC_FilterValue, 4, 26, 0, 0, // Skip to: 2274 -/* 2248 */ MCD_OPC_ExtractField, 25, 7, // Inst{31-25} ... -/* 2251 */ MCD_OPC_FilterValue, 0, 4, 0, 0, // Skip to: 2260 -/* 2256 */ MCD_OPC_Decode, 192, 3, 34, // Opcode: XOR -/* 2260 */ MCD_OPC_FilterValue, 1, 142, 6, 0, // Skip to: 3943 -/* 2265 */ MCD_OPC_CheckPredicate, 8, 137, 6, 0, // Skip to: 3943 -/* 2270 */ MCD_OPC_Decode, 184, 2, 34, // Opcode: DIV -/* 2274 */ MCD_OPC_FilterValue, 5, 35, 0, 0, // Skip to: 2314 -/* 2279 */ MCD_OPC_ExtractField, 25, 7, // Inst{31-25} ... -/* 2282 */ MCD_OPC_FilterValue, 0, 4, 0, 0, // Skip to: 2291 -/* 2287 */ MCD_OPC_Decode, 182, 3, 34, // Opcode: SRL -/* 2291 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 2305 -/* 2296 */ MCD_OPC_CheckPredicate, 8, 106, 6, 0, // Skip to: 3943 -/* 2301 */ MCD_OPC_Decode, 185, 2, 34, // Opcode: DIVU -/* 2305 */ MCD_OPC_FilterValue, 32, 97, 6, 0, // Skip to: 3943 -/* 2310 */ MCD_OPC_Decode, 177, 3, 34, // Opcode: SRA -/* 2314 */ MCD_OPC_FilterValue, 6, 26, 0, 0, // Skip to: 2345 -/* 2319 */ MCD_OPC_ExtractField, 25, 7, // Inst{31-25} ... -/* 2322 */ MCD_OPC_FilterValue, 0, 4, 0, 0, // Skip to: 2331 -/* 2327 */ MCD_OPC_Decode, 151, 3, 34, // Opcode: OR -/* 2331 */ MCD_OPC_FilterValue, 1, 71, 6, 0, // Skip to: 3943 -/* 2336 */ MCD_OPC_CheckPredicate, 8, 66, 6, 0, // Skip to: 3943 -/* 2341 */ MCD_OPC_Decode, 153, 3, 34, // Opcode: REM -/* 2345 */ MCD_OPC_FilterValue, 7, 57, 6, 0, // Skip to: 3943 -/* 2350 */ MCD_OPC_ExtractField, 25, 7, // Inst{31-25} ... -/* 2353 */ MCD_OPC_FilterValue, 0, 4, 0, 0, // Skip to: 2362 -/* 2358 */ MCD_OPC_Decode, 254, 1, 34, // Opcode: AND -/* 2362 */ MCD_OPC_FilterValue, 1, 40, 6, 0, // Skip to: 3943 -/* 2367 */ MCD_OPC_CheckPredicate, 8, 35, 6, 0, // Skip to: 3943 -/* 2372 */ MCD_OPC_Decode, 154, 3, 34, // Opcode: REMU -/* 2376 */ MCD_OPC_FilterValue, 55, 4, 0, 0, // Skip to: 2385 -/* 2381 */ MCD_OPC_Decode, 142, 3, 29, // Opcode: LUI -/* 2385 */ MCD_OPC_FilterValue, 59, 187, 0, 0, // Skip to: 2577 -/* 2390 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 2393 */ MCD_OPC_FilterValue, 0, 45, 0, 0, // Skip to: 2443 -/* 2398 */ MCD_OPC_ExtractField, 25, 7, // Inst{31-25} ... -/* 2401 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 2415 -/* 2406 */ MCD_OPC_CheckPredicate, 3, 252, 5, 0, // Skip to: 3943 -/* 2411 */ MCD_OPC_Decode, 181, 1, 34, // Opcode: ADDW -/* 2415 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 2429 -/* 2420 */ MCD_OPC_CheckPredicate, 9, 238, 5, 0, // Skip to: 3943 -/* 2425 */ MCD_OPC_Decode, 150, 3, 34, // Opcode: MULW -/* 2429 */ MCD_OPC_FilterValue, 32, 229, 5, 0, // Skip to: 3943 -/* 2434 */ MCD_OPC_CheckPredicate, 3, 224, 5, 0, // Skip to: 3943 -/* 2439 */ MCD_OPC_Decode, 187, 3, 34, // Opcode: SUBW -/* 2443 */ MCD_OPC_FilterValue, 1, 16, 0, 0, // Skip to: 2464 -/* 2448 */ MCD_OPC_CheckPredicate, 3, 210, 5, 0, // Skip to: 3943 -/* 2453 */ MCD_OPC_CheckField, 25, 7, 0, 203, 5, 0, // Skip to: 3943 -/* 2460 */ MCD_OPC_Decode, 172, 3, 34, // Opcode: SLLW -/* 2464 */ MCD_OPC_FilterValue, 4, 16, 0, 0, // Skip to: 2485 -/* 2469 */ MCD_OPC_CheckPredicate, 9, 189, 5, 0, // Skip to: 3943 -/* 2474 */ MCD_OPC_CheckField, 25, 7, 1, 182, 5, 0, // Skip to: 3943 -/* 2481 */ MCD_OPC_Decode, 187, 2, 34, // Opcode: DIVW -/* 2485 */ MCD_OPC_FilterValue, 5, 45, 0, 0, // Skip to: 2535 -/* 2490 */ MCD_OPC_ExtractField, 25, 7, // Inst{31-25} ... -/* 2493 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 2507 -/* 2498 */ MCD_OPC_CheckPredicate, 3, 160, 5, 0, // Skip to: 3943 -/* 2503 */ MCD_OPC_Decode, 185, 3, 34, // Opcode: SRLW -/* 2507 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 2521 -/* 2512 */ MCD_OPC_CheckPredicate, 9, 146, 5, 0, // Skip to: 3943 -/* 2517 */ MCD_OPC_Decode, 186, 2, 34, // Opcode: DIVUW -/* 2521 */ MCD_OPC_FilterValue, 32, 137, 5, 0, // Skip to: 3943 -/* 2526 */ MCD_OPC_CheckPredicate, 3, 132, 5, 0, // Skip to: 3943 -/* 2531 */ MCD_OPC_Decode, 180, 3, 34, // Opcode: SRAW -/* 2535 */ MCD_OPC_FilterValue, 6, 16, 0, 0, // Skip to: 2556 -/* 2540 */ MCD_OPC_CheckPredicate, 9, 118, 5, 0, // Skip to: 3943 -/* 2545 */ MCD_OPC_CheckField, 25, 7, 1, 111, 5, 0, // Skip to: 3943 -/* 2552 */ MCD_OPC_Decode, 156, 3, 34, // Opcode: REMW -/* 2556 */ MCD_OPC_FilterValue, 7, 102, 5, 0, // Skip to: 3943 -/* 2561 */ MCD_OPC_CheckPredicate, 9, 97, 5, 0, // Skip to: 3943 -/* 2566 */ MCD_OPC_CheckField, 25, 7, 1, 90, 5, 0, // Skip to: 3943 -/* 2573 */ MCD_OPC_Decode, 155, 3, 34, // Opcode: REMUW -/* 2577 */ MCD_OPC_FilterValue, 67, 31, 0, 0, // Skip to: 2613 -/* 2582 */ MCD_OPC_ExtractField, 25, 2, // Inst{26-25} ... -/* 2585 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 2599 -/* 2590 */ MCD_OPC_CheckPredicate, 4, 68, 5, 0, // Skip to: 3943 -/* 2595 */ MCD_OPC_Decode, 226, 2, 36, // Opcode: FMADD_S -/* 2599 */ MCD_OPC_FilterValue, 1, 59, 5, 0, // Skip to: 3943 -/* 2604 */ MCD_OPC_CheckPredicate, 5, 54, 5, 0, // Skip to: 3943 -/* 2609 */ MCD_OPC_Decode, 225, 2, 37, // Opcode: FMADD_D -/* 2613 */ MCD_OPC_FilterValue, 71, 31, 0, 0, // Skip to: 2649 -/* 2618 */ MCD_OPC_ExtractField, 25, 2, // Inst{26-25} ... -/* 2621 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 2635 -/* 2626 */ MCD_OPC_CheckPredicate, 4, 32, 5, 0, // Skip to: 3943 -/* 2631 */ MCD_OPC_Decode, 232, 2, 36, // Opcode: FMSUB_S -/* 2635 */ MCD_OPC_FilterValue, 1, 23, 5, 0, // Skip to: 3943 -/* 2640 */ MCD_OPC_CheckPredicate, 5, 18, 5, 0, // Skip to: 3943 -/* 2645 */ MCD_OPC_Decode, 231, 2, 37, // Opcode: FMSUB_D -/* 2649 */ MCD_OPC_FilterValue, 75, 31, 0, 0, // Skip to: 2685 -/* 2654 */ MCD_OPC_ExtractField, 25, 2, // Inst{26-25} ... -/* 2657 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 2671 -/* 2662 */ MCD_OPC_CheckPredicate, 4, 252, 4, 0, // Skip to: 3943 -/* 2667 */ MCD_OPC_Decode, 242, 2, 36, // Opcode: FNMSUB_S -/* 2671 */ MCD_OPC_FilterValue, 1, 243, 4, 0, // Skip to: 3943 -/* 2676 */ MCD_OPC_CheckPredicate, 5, 238, 4, 0, // Skip to: 3943 -/* 2681 */ MCD_OPC_Decode, 241, 2, 37, // Opcode: FNMSUB_D -/* 2685 */ MCD_OPC_FilterValue, 79, 31, 0, 0, // Skip to: 2721 -/* 2690 */ MCD_OPC_ExtractField, 25, 2, // Inst{26-25} ... -/* 2693 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 2707 -/* 2698 */ MCD_OPC_CheckPredicate, 4, 216, 4, 0, // Skip to: 3943 -/* 2703 */ MCD_OPC_Decode, 240, 2, 36, // Opcode: FNMADD_S -/* 2707 */ MCD_OPC_FilterValue, 1, 207, 4, 0, // Skip to: 3943 -/* 2712 */ MCD_OPC_CheckPredicate, 5, 202, 4, 0, // Skip to: 3943 -/* 2717 */ MCD_OPC_Decode, 239, 2, 37, // Opcode: FNMADD_D -/* 2721 */ MCD_OPC_FilterValue, 83, 136, 3, 0, // Skip to: 3630 -/* 2726 */ MCD_OPC_ExtractField, 25, 7, // Inst{31-25} ... -/* 2729 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 2743 -/* 2734 */ MCD_OPC_CheckPredicate, 4, 180, 4, 0, // Skip to: 3943 -/* 2739 */ MCD_OPC_Decode, 191, 2, 38, // Opcode: FADD_S -/* 2743 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 2757 -/* 2748 */ MCD_OPC_CheckPredicate, 5, 166, 4, 0, // Skip to: 3943 -/* 2753 */ MCD_OPC_Decode, 190, 2, 39, // Opcode: FADD_D -/* 2757 */ MCD_OPC_FilterValue, 4, 9, 0, 0, // Skip to: 2771 -/* 2762 */ MCD_OPC_CheckPredicate, 4, 152, 4, 0, // Skip to: 3943 -/* 2767 */ MCD_OPC_Decode, 253, 2, 38, // Opcode: FSUB_S -/* 2771 */ MCD_OPC_FilterValue, 5, 9, 0, 0, // Skip to: 2785 -/* 2776 */ MCD_OPC_CheckPredicate, 5, 138, 4, 0, // Skip to: 3943 -/* 2781 */ MCD_OPC_Decode, 252, 2, 39, // Opcode: FSUB_D -/* 2785 */ MCD_OPC_FilterValue, 8, 9, 0, 0, // Skip to: 2799 -/* 2790 */ MCD_OPC_CheckPredicate, 4, 124, 4, 0, // Skip to: 3943 -/* 2795 */ MCD_OPC_Decode, 234, 2, 38, // Opcode: FMUL_S -/* 2799 */ MCD_OPC_FilterValue, 9, 9, 0, 0, // Skip to: 2813 -/* 2804 */ MCD_OPC_CheckPredicate, 5, 110, 4, 0, // Skip to: 3943 -/* 2809 */ MCD_OPC_Decode, 233, 2, 39, // Opcode: FMUL_D -/* 2813 */ MCD_OPC_FilterValue, 12, 9, 0, 0, // Skip to: 2827 -/* 2818 */ MCD_OPC_CheckPredicate, 4, 96, 4, 0, // Skip to: 3943 -/* 2823 */ MCD_OPC_Decode, 213, 2, 38, // Opcode: FDIV_S -/* 2827 */ MCD_OPC_FilterValue, 13, 9, 0, 0, // Skip to: 2841 -/* 2832 */ MCD_OPC_CheckPredicate, 5, 82, 4, 0, // Skip to: 3943 -/* 2837 */ MCD_OPC_Decode, 212, 2, 39, // Opcode: FDIV_D -/* 2841 */ MCD_OPC_FilterValue, 16, 45, 0, 0, // Skip to: 2891 -/* 2846 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 2849 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 2863 -/* 2854 */ MCD_OPC_CheckPredicate, 4, 60, 4, 0, // Skip to: 3943 -/* 2859 */ MCD_OPC_Decode, 249, 2, 40, // Opcode: FSGNJ_S -/* 2863 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 2877 -/* 2868 */ MCD_OPC_CheckPredicate, 4, 46, 4, 0, // Skip to: 3943 -/* 2873 */ MCD_OPC_Decode, 245, 2, 40, // Opcode: FSGNJN_S -/* 2877 */ MCD_OPC_FilterValue, 2, 37, 4, 0, // Skip to: 3943 -/* 2882 */ MCD_OPC_CheckPredicate, 4, 32, 4, 0, // Skip to: 3943 -/* 2887 */ MCD_OPC_Decode, 247, 2, 40, // Opcode: FSGNJX_S -/* 2891 */ MCD_OPC_FilterValue, 17, 45, 0, 0, // Skip to: 2941 -/* 2896 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 2899 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 2913 -/* 2904 */ MCD_OPC_CheckPredicate, 5, 10, 4, 0, // Skip to: 3943 -/* 2909 */ MCD_OPC_Decode, 248, 2, 41, // Opcode: FSGNJ_D -/* 2913 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 2927 -/* 2918 */ MCD_OPC_CheckPredicate, 5, 252, 3, 0, // Skip to: 3943 -/* 2923 */ MCD_OPC_Decode, 244, 2, 41, // Opcode: FSGNJN_D -/* 2927 */ MCD_OPC_FilterValue, 2, 243, 3, 0, // Skip to: 3943 -/* 2932 */ MCD_OPC_CheckPredicate, 5, 238, 3, 0, // Skip to: 3943 -/* 2937 */ MCD_OPC_Decode, 246, 2, 41, // Opcode: FSGNJX_D -/* 2941 */ MCD_OPC_FilterValue, 20, 31, 0, 0, // Skip to: 2977 -/* 2946 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 2949 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 2963 -/* 2954 */ MCD_OPC_CheckPredicate, 4, 216, 3, 0, // Skip to: 3943 -/* 2959 */ MCD_OPC_Decode, 230, 2, 40, // Opcode: FMIN_S -/* 2963 */ MCD_OPC_FilterValue, 1, 207, 3, 0, // Skip to: 3943 -/* 2968 */ MCD_OPC_CheckPredicate, 4, 202, 3, 0, // Skip to: 3943 -/* 2973 */ MCD_OPC_Decode, 228, 2, 40, // Opcode: FMAX_S -/* 2977 */ MCD_OPC_FilterValue, 21, 31, 0, 0, // Skip to: 3013 -/* 2982 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 2985 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 2999 -/* 2990 */ MCD_OPC_CheckPredicate, 5, 180, 3, 0, // Skip to: 3943 -/* 2995 */ MCD_OPC_Decode, 229, 2, 41, // Opcode: FMIN_D -/* 2999 */ MCD_OPC_FilterValue, 1, 171, 3, 0, // Skip to: 3943 -/* 3004 */ MCD_OPC_CheckPredicate, 5, 166, 3, 0, // Skip to: 3943 -/* 3009 */ MCD_OPC_Decode, 227, 2, 41, // Opcode: FMAX_D -/* 3013 */ MCD_OPC_FilterValue, 32, 16, 0, 0, // Skip to: 3034 -/* 3018 */ MCD_OPC_CheckPredicate, 5, 152, 3, 0, // Skip to: 3943 -/* 3023 */ MCD_OPC_CheckField, 20, 5, 1, 145, 3, 0, // Skip to: 3943 -/* 3030 */ MCD_OPC_Decode, 203, 2, 42, // Opcode: FCVT_S_D -/* 3034 */ MCD_OPC_FilterValue, 33, 23, 0, 0, // Skip to: 3062 -/* 3039 */ MCD_OPC_CheckPredicate, 5, 131, 3, 0, // Skip to: 3943 -/* 3044 */ MCD_OPC_CheckField, 20, 5, 0, 124, 3, 0, // Skip to: 3943 -/* 3051 */ MCD_OPC_CheckField, 12, 3, 0, 117, 3, 0, // Skip to: 3943 -/* 3058 */ MCD_OPC_Decode, 196, 2, 43, // Opcode: FCVT_D_S -/* 3062 */ MCD_OPC_FilterValue, 44, 16, 0, 0, // Skip to: 3083 -/* 3067 */ MCD_OPC_CheckPredicate, 4, 103, 3, 0, // Skip to: 3943 -/* 3072 */ MCD_OPC_CheckField, 20, 5, 0, 96, 3, 0, // Skip to: 3943 -/* 3079 */ MCD_OPC_Decode, 251, 2, 44, // Opcode: FSQRT_S -/* 3083 */ MCD_OPC_FilterValue, 45, 16, 0, 0, // Skip to: 3104 -/* 3088 */ MCD_OPC_CheckPredicate, 5, 82, 3, 0, // Skip to: 3943 -/* 3093 */ MCD_OPC_CheckField, 20, 5, 0, 75, 3, 0, // Skip to: 3943 -/* 3100 */ MCD_OPC_Decode, 250, 2, 45, // Opcode: FSQRT_D -/* 3104 */ MCD_OPC_FilterValue, 80, 45, 0, 0, // Skip to: 3154 -/* 3109 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 3112 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 3126 -/* 3117 */ MCD_OPC_CheckPredicate, 4, 53, 3, 0, // Skip to: 3943 -/* 3122 */ MCD_OPC_Decode, 221, 2, 46, // Opcode: FLE_S -/* 3126 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 3140 -/* 3131 */ MCD_OPC_CheckPredicate, 4, 39, 3, 0, // Skip to: 3943 -/* 3136 */ MCD_OPC_Decode, 223, 2, 46, // Opcode: FLT_S -/* 3140 */ MCD_OPC_FilterValue, 2, 30, 3, 0, // Skip to: 3943 -/* 3145 */ MCD_OPC_CheckPredicate, 4, 25, 3, 0, // Skip to: 3943 -/* 3150 */ MCD_OPC_Decode, 218, 2, 46, // Opcode: FEQ_S -/* 3154 */ MCD_OPC_FilterValue, 81, 45, 0, 0, // Skip to: 3204 -/* 3159 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 3162 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 3176 -/* 3167 */ MCD_OPC_CheckPredicate, 5, 3, 3, 0, // Skip to: 3943 -/* 3172 */ MCD_OPC_Decode, 220, 2, 47, // Opcode: FLE_D -/* 3176 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 3190 -/* 3181 */ MCD_OPC_CheckPredicate, 5, 245, 2, 0, // Skip to: 3943 -/* 3186 */ MCD_OPC_Decode, 222, 2, 47, // Opcode: FLT_D -/* 3190 */ MCD_OPC_FilterValue, 2, 236, 2, 0, // Skip to: 3943 -/* 3195 */ MCD_OPC_CheckPredicate, 5, 231, 2, 0, // Skip to: 3943 -/* 3200 */ MCD_OPC_Decode, 217, 2, 47, // Opcode: FEQ_D -/* 3204 */ MCD_OPC_FilterValue, 96, 59, 0, 0, // Skip to: 3268 -/* 3209 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... -/* 3212 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 3226 -/* 3217 */ MCD_OPC_CheckPredicate, 4, 209, 2, 0, // Skip to: 3943 -/* 3222 */ MCD_OPC_Decode, 211, 2, 48, // Opcode: FCVT_W_S -/* 3226 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 3240 -/* 3231 */ MCD_OPC_CheckPredicate, 4, 195, 2, 0, // Skip to: 3943 -/* 3236 */ MCD_OPC_Decode, 209, 2, 48, // Opcode: FCVT_WU_S -/* 3240 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 3254 -/* 3245 */ MCD_OPC_CheckPredicate, 10, 181, 2, 0, // Skip to: 3943 -/* 3250 */ MCD_OPC_Decode, 202, 2, 48, // Opcode: FCVT_L_S -/* 3254 */ MCD_OPC_FilterValue, 3, 172, 2, 0, // Skip to: 3943 -/* 3259 */ MCD_OPC_CheckPredicate, 10, 167, 2, 0, // Skip to: 3943 -/* 3264 */ MCD_OPC_Decode, 200, 2, 48, // Opcode: FCVT_LU_S -/* 3268 */ MCD_OPC_FilterValue, 97, 59, 0, 0, // Skip to: 3332 -/* 3273 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... -/* 3276 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 3290 -/* 3281 */ MCD_OPC_CheckPredicate, 5, 145, 2, 0, // Skip to: 3943 -/* 3286 */ MCD_OPC_Decode, 210, 2, 49, // Opcode: FCVT_W_D -/* 3290 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 3304 -/* 3295 */ MCD_OPC_CheckPredicate, 5, 131, 2, 0, // Skip to: 3943 -/* 3300 */ MCD_OPC_Decode, 208, 2, 49, // Opcode: FCVT_WU_D -/* 3304 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 3318 -/* 3309 */ MCD_OPC_CheckPredicate, 11, 117, 2, 0, // Skip to: 3943 -/* 3314 */ MCD_OPC_Decode, 201, 2, 49, // Opcode: FCVT_L_D -/* 3318 */ MCD_OPC_FilterValue, 3, 108, 2, 0, // Skip to: 3943 -/* 3323 */ MCD_OPC_CheckPredicate, 11, 103, 2, 0, // Skip to: 3943 -/* 3328 */ MCD_OPC_Decode, 199, 2, 49, // Opcode: FCVT_LU_D -/* 3332 */ MCD_OPC_FilterValue, 104, 59, 0, 0, // Skip to: 3396 -/* 3337 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... -/* 3340 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 3354 -/* 3345 */ MCD_OPC_CheckPredicate, 4, 81, 2, 0, // Skip to: 3943 -/* 3350 */ MCD_OPC_Decode, 206, 2, 50, // Opcode: FCVT_S_W -/* 3354 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 3368 -/* 3359 */ MCD_OPC_CheckPredicate, 4, 67, 2, 0, // Skip to: 3943 -/* 3364 */ MCD_OPC_Decode, 207, 2, 50, // Opcode: FCVT_S_WU -/* 3368 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 3382 -/* 3373 */ MCD_OPC_CheckPredicate, 10, 53, 2, 0, // Skip to: 3943 -/* 3378 */ MCD_OPC_Decode, 204, 2, 50, // Opcode: FCVT_S_L -/* 3382 */ MCD_OPC_FilterValue, 3, 44, 2, 0, // Skip to: 3943 -/* 3387 */ MCD_OPC_CheckPredicate, 10, 39, 2, 0, // Skip to: 3943 -/* 3392 */ MCD_OPC_Decode, 205, 2, 50, // Opcode: FCVT_S_LU -/* 3396 */ MCD_OPC_FilterValue, 105, 73, 0, 0, // Skip to: 3474 -/* 3401 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... -/* 3404 */ MCD_OPC_FilterValue, 0, 16, 0, 0, // Skip to: 3425 -/* 3409 */ MCD_OPC_CheckPredicate, 5, 17, 2, 0, // Skip to: 3943 -/* 3414 */ MCD_OPC_CheckField, 12, 3, 0, 10, 2, 0, // Skip to: 3943 -/* 3421 */ MCD_OPC_Decode, 197, 2, 51, // Opcode: FCVT_D_W -/* 3425 */ MCD_OPC_FilterValue, 1, 16, 0, 0, // Skip to: 3446 -/* 3430 */ MCD_OPC_CheckPredicate, 5, 252, 1, 0, // Skip to: 3943 -/* 3435 */ MCD_OPC_CheckField, 12, 3, 0, 245, 1, 0, // Skip to: 3943 -/* 3442 */ MCD_OPC_Decode, 198, 2, 51, // Opcode: FCVT_D_WU -/* 3446 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 3460 -/* 3451 */ MCD_OPC_CheckPredicate, 11, 231, 1, 0, // Skip to: 3943 -/* 3456 */ MCD_OPC_Decode, 194, 2, 52, // Opcode: FCVT_D_L -/* 3460 */ MCD_OPC_FilterValue, 3, 222, 1, 0, // Skip to: 3943 -/* 3465 */ MCD_OPC_CheckPredicate, 11, 217, 1, 0, // Skip to: 3943 -/* 3470 */ MCD_OPC_Decode, 195, 2, 52, // Opcode: FCVT_D_LU -/* 3474 */ MCD_OPC_FilterValue, 112, 45, 0, 0, // Skip to: 3524 -/* 3479 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 3482 */ MCD_OPC_FilterValue, 0, 16, 0, 0, // Skip to: 3503 -/* 3487 */ MCD_OPC_CheckPredicate, 4, 195, 1, 0, // Skip to: 3943 -/* 3492 */ MCD_OPC_CheckField, 20, 5, 0, 188, 1, 0, // Skip to: 3943 -/* 3499 */ MCD_OPC_Decode, 238, 2, 53, // Opcode: FMV_X_W -/* 3503 */ MCD_OPC_FilterValue, 1, 179, 1, 0, // Skip to: 3943 -/* 3508 */ MCD_OPC_CheckPredicate, 4, 174, 1, 0, // Skip to: 3943 -/* 3513 */ MCD_OPC_CheckField, 20, 5, 0, 167, 1, 0, // Skip to: 3943 -/* 3520 */ MCD_OPC_Decode, 193, 2, 53, // Opcode: FCLASS_S -/* 3524 */ MCD_OPC_FilterValue, 113, 45, 0, 0, // Skip to: 3574 -/* 3529 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 3532 */ MCD_OPC_FilterValue, 0, 16, 0, 0, // Skip to: 3553 -/* 3537 */ MCD_OPC_CheckPredicate, 11, 145, 1, 0, // Skip to: 3943 -/* 3542 */ MCD_OPC_CheckField, 20, 5, 0, 138, 1, 0, // Skip to: 3943 -/* 3549 */ MCD_OPC_Decode, 237, 2, 54, // Opcode: FMV_X_D -/* 3553 */ MCD_OPC_FilterValue, 1, 129, 1, 0, // Skip to: 3943 -/* 3558 */ MCD_OPC_CheckPredicate, 5, 124, 1, 0, // Skip to: 3943 -/* 3563 */ MCD_OPC_CheckField, 20, 5, 0, 117, 1, 0, // Skip to: 3943 -/* 3570 */ MCD_OPC_Decode, 192, 2, 54, // Opcode: FCLASS_D -/* 3574 */ MCD_OPC_FilterValue, 120, 23, 0, 0, // Skip to: 3602 -/* 3579 */ MCD_OPC_CheckPredicate, 4, 103, 1, 0, // Skip to: 3943 -/* 3584 */ MCD_OPC_CheckField, 20, 5, 0, 96, 1, 0, // Skip to: 3943 -/* 3591 */ MCD_OPC_CheckField, 12, 3, 0, 89, 1, 0, // Skip to: 3943 -/* 3598 */ MCD_OPC_Decode, 236, 2, 55, // Opcode: FMV_W_X -/* 3602 */ MCD_OPC_FilterValue, 121, 80, 1, 0, // Skip to: 3943 -/* 3607 */ MCD_OPC_CheckPredicate, 11, 75, 1, 0, // Skip to: 3943 -/* 3612 */ MCD_OPC_CheckField, 20, 5, 0, 68, 1, 0, // Skip to: 3943 -/* 3619 */ MCD_OPC_CheckField, 12, 3, 0, 61, 1, 0, // Skip to: 3943 -/* 3626 */ MCD_OPC_Decode, 235, 2, 51, // Opcode: FMV_D_X -/* 3630 */ MCD_OPC_FilterValue, 99, 57, 0, 0, // Skip to: 3692 -/* 3635 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 3638 */ MCD_OPC_FilterValue, 0, 4, 0, 0, // Skip to: 3647 -/* 3643 */ MCD_OPC_Decode, 129, 2, 56, // Opcode: BEQ -/* 3647 */ MCD_OPC_FilterValue, 1, 4, 0, 0, // Skip to: 3656 -/* 3652 */ MCD_OPC_Decode, 134, 2, 56, // Opcode: BNE -/* 3656 */ MCD_OPC_FilterValue, 4, 4, 0, 0, // Skip to: 3665 -/* 3661 */ MCD_OPC_Decode, 132, 2, 56, // Opcode: BLT -/* 3665 */ MCD_OPC_FilterValue, 5, 4, 0, 0, // Skip to: 3674 -/* 3670 */ MCD_OPC_Decode, 130, 2, 56, // Opcode: BGE -/* 3674 */ MCD_OPC_FilterValue, 6, 4, 0, 0, // Skip to: 3683 -/* 3679 */ MCD_OPC_Decode, 133, 2, 56, // Opcode: BLTU -/* 3683 */ MCD_OPC_FilterValue, 7, 255, 0, 0, // Skip to: 3943 -/* 3688 */ MCD_OPC_Decode, 131, 2, 56, // Opcode: BGEU -/* 3692 */ MCD_OPC_FilterValue, 103, 11, 0, 0, // Skip to: 3708 -/* 3697 */ MCD_OPC_CheckField, 12, 3, 0, 239, 0, 0, // Skip to: 3943 -/* 3704 */ MCD_OPC_Decode, 128, 3, 24, // Opcode: JALR -/* 3708 */ MCD_OPC_FilterValue, 111, 4, 0, 0, // Skip to: 3717 -/* 3713 */ MCD_OPC_Decode, 255, 2, 57, // Opcode: JAL -/* 3717 */ MCD_OPC_FilterValue, 115, 221, 0, 0, // Skip to: 3943 -/* 3722 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... -/* 3725 */ MCD_OPC_FilterValue, 0, 139, 0, 0, // Skip to: 3869 -/* 3730 */ MCD_OPC_ExtractField, 25, 7, // Inst{31-25} ... -/* 3733 */ MCD_OPC_FilterValue, 0, 51, 0, 0, // Skip to: 3789 -/* 3738 */ MCD_OPC_ExtractField, 15, 10, // Inst{24-15} ... -/* 3741 */ MCD_OPC_FilterValue, 0, 11, 0, 0, // Skip to: 3757 -/* 3746 */ MCD_OPC_CheckField, 7, 5, 0, 190, 0, 0, // Skip to: 3943 -/* 3753 */ MCD_OPC_Decode, 189, 2, 0, // Opcode: ECALL -/* 3757 */ MCD_OPC_FilterValue, 32, 11, 0, 0, // Skip to: 3773 -/* 3762 */ MCD_OPC_CheckField, 7, 5, 0, 174, 0, 0, // Skip to: 3943 -/* 3769 */ MCD_OPC_Decode, 188, 2, 0, // Opcode: EBREAK -/* 3773 */ MCD_OPC_FilterValue, 64, 165, 0, 0, // Skip to: 3943 -/* 3778 */ MCD_OPC_CheckField, 7, 5, 0, 158, 0, 0, // Skip to: 3943 -/* 3785 */ MCD_OPC_Decode, 190, 3, 0, // Opcode: URET -/* 3789 */ MCD_OPC_FilterValue, 8, 36, 0, 0, // Skip to: 3830 -/* 3794 */ MCD_OPC_ExtractField, 15, 10, // Inst{24-15} ... -/* 3797 */ MCD_OPC_FilterValue, 64, 11, 0, 0, // Skip to: 3813 -/* 3802 */ MCD_OPC_CheckField, 7, 5, 0, 134, 0, 0, // Skip to: 3943 -/* 3809 */ MCD_OPC_Decode, 181, 3, 0, // Opcode: SRET -/* 3813 */ MCD_OPC_FilterValue, 160, 1, 124, 0, 0, // Skip to: 3943 -/* 3819 */ MCD_OPC_CheckField, 7, 5, 0, 117, 0, 0, // Skip to: 3943 -/* 3826 */ MCD_OPC_Decode, 191, 3, 0, // Opcode: WFI -/* 3830 */ MCD_OPC_FilterValue, 9, 11, 0, 0, // Skip to: 3846 -/* 3835 */ MCD_OPC_CheckField, 7, 5, 0, 101, 0, 0, // Skip to: 3943 -/* 3842 */ MCD_OPC_Decode, 167, 3, 58, // Opcode: SFENCE_VMA -/* 3846 */ MCD_OPC_FilterValue, 24, 92, 0, 0, // Skip to: 3943 -/* 3851 */ MCD_OPC_CheckField, 15, 10, 64, 85, 0, 0, // Skip to: 3943 -/* 3858 */ MCD_OPC_CheckField, 7, 5, 0, 78, 0, 0, // Skip to: 3943 -/* 3865 */ MCD_OPC_Decode, 145, 3, 0, // Opcode: MRET -/* 3869 */ MCD_OPC_FilterValue, 1, 24, 0, 0, // Skip to: 3898 -/* 3874 */ MCD_OPC_CheckField, 15, 17, 128, 128, 6, 11, 0, 0, // Skip to: 3894 -/* 3883 */ MCD_OPC_CheckField, 7, 5, 0, 4, 0, 0, // Skip to: 3894 -/* 3890 */ MCD_OPC_Decode, 189, 3, 0, // Opcode: UNIMP -/* 3894 */ MCD_OPC_Decode, 139, 2, 59, // Opcode: CSRRW -/* 3898 */ MCD_OPC_FilterValue, 2, 4, 0, 0, // Skip to: 3907 -/* 3903 */ MCD_OPC_Decode, 137, 2, 59, // Opcode: CSRRS -/* 3907 */ MCD_OPC_FilterValue, 3, 4, 0, 0, // Skip to: 3916 -/* 3912 */ MCD_OPC_Decode, 135, 2, 59, // Opcode: CSRRC -/* 3916 */ MCD_OPC_FilterValue, 5, 4, 0, 0, // Skip to: 3925 -/* 3921 */ MCD_OPC_Decode, 140, 2, 60, // Opcode: CSRRWI -/* 3925 */ MCD_OPC_FilterValue, 6, 4, 0, 0, // Skip to: 3934 -/* 3930 */ MCD_OPC_Decode, 138, 2, 60, // Opcode: CSRRSI -/* 3934 */ MCD_OPC_FilterValue, 7, 4, 0, 0, // Skip to: 3943 -/* 3939 */ MCD_OPC_Decode, 136, 2, 60, // Opcode: CSRRCI -/* 3943 */ MCD_OPC_Fail, +/* 92 */ MCD_OPC_FilterValue, 0, 220, 2, 0, // Skip to: 829 +/* 97 */ MCD_OPC_ExtractField, 26, 6, // Inst{31-26} ... +/* 100 */ MCD_OPC_FilterValue, 0, 73, 0, 0, // Skip to: 178 +/* 105 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 108 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 122 +/* 113 */ MCD_OPC_CheckPredicate, 10, 188, 73, 0, // Skip to: 18994 +/* 118 */ MCD_OPC_Decode, 149, 98, 36, // Opcode: VLE8_V +/* 122 */ MCD_OPC_FilterValue, 8, 16, 0, 0, // Skip to: 143 +/* 127 */ MCD_OPC_CheckPredicate, 10, 174, 73, 0, // Skip to: 18994 +/* 132 */ MCD_OPC_CheckField, 25, 1, 1, 167, 73, 0, // Skip to: 18994 +/* 139 */ MCD_OPC_Decode, 129, 98, 37, // Opcode: VL1RE8_V +/* 143 */ MCD_OPC_FilterValue, 11, 16, 0, 0, // Skip to: 164 +/* 148 */ MCD_OPC_CheckPredicate, 10, 153, 73, 0, // Skip to: 18994 +/* 153 */ MCD_OPC_CheckField, 25, 1, 1, 146, 73, 0, // Skip to: 18994 +/* 160 */ MCD_OPC_Decode, 150, 98, 37, // Opcode: VLM_V +/* 164 */ MCD_OPC_FilterValue, 16, 137, 73, 0, // Skip to: 18994 +/* 169 */ MCD_OPC_CheckPredicate, 10, 132, 73, 0, // Skip to: 18994 +/* 174 */ MCD_OPC_Decode, 148, 98, 36, // Opcode: VLE8FF_V +/* 178 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 192 +/* 183 */ MCD_OPC_CheckPredicate, 10, 118, 73, 0, // Skip to: 18994 +/* 188 */ MCD_OPC_Decode, 146, 99, 38, // Opcode: VLUXEI8_V +/* 192 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 206 +/* 197 */ MCD_OPC_CheckPredicate, 10, 104, 73, 0, // Skip to: 18994 +/* 202 */ MCD_OPC_Decode, 186, 98, 39, // Opcode: VLSE8_V +/* 206 */ MCD_OPC_FilterValue, 3, 9, 0, 0, // Skip to: 220 +/* 211 */ MCD_OPC_CheckPredicate, 10, 90, 73, 0, // Skip to: 18994 +/* 216 */ MCD_OPC_Decode, 154, 98, 38, // Opcode: VLOXEI8_V +/* 220 */ MCD_OPC_FilterValue, 8, 52, 0, 0, // Skip to: 277 +/* 225 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 228 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 242 +/* 233 */ MCD_OPC_CheckPredicate, 10, 68, 73, 0, // Skip to: 18994 +/* 238 */ MCD_OPC_Decode, 194, 98, 36, // Opcode: VLSEG2E8_V +/* 242 */ MCD_OPC_FilterValue, 8, 16, 0, 0, // Skip to: 263 +/* 247 */ MCD_OPC_CheckPredicate, 10, 54, 73, 0, // Skip to: 18994 +/* 252 */ MCD_OPC_CheckField, 25, 1, 1, 47, 73, 0, // Skip to: 18994 +/* 259 */ MCD_OPC_Decode, 133, 98, 40, // Opcode: VL2RE8_V +/* 263 */ MCD_OPC_FilterValue, 16, 38, 73, 0, // Skip to: 18994 +/* 268 */ MCD_OPC_CheckPredicate, 10, 33, 73, 0, // Skip to: 18994 +/* 273 */ MCD_OPC_Decode, 193, 98, 36, // Opcode: VLSEG2E8FF_V +/* 277 */ MCD_OPC_FilterValue, 9, 9, 0, 0, // Skip to: 291 +/* 282 */ MCD_OPC_CheckPredicate, 10, 19, 73, 0, // Skip to: 18994 +/* 287 */ MCD_OPC_Decode, 150, 99, 38, // Opcode: VLUXSEG2EI8_V +/* 291 */ MCD_OPC_FilterValue, 10, 9, 0, 0, // Skip to: 305 +/* 296 */ MCD_OPC_CheckPredicate, 10, 5, 73, 0, // Skip to: 18994 +/* 301 */ MCD_OPC_Decode, 246, 98, 39, // Opcode: VLSSEG2E8_V +/* 305 */ MCD_OPC_FilterValue, 11, 9, 0, 0, // Skip to: 319 +/* 310 */ MCD_OPC_CheckPredicate, 10, 247, 72, 0, // Skip to: 18994 +/* 315 */ MCD_OPC_Decode, 158, 98, 38, // Opcode: VLOXSEG2EI8_V +/* 319 */ MCD_OPC_FilterValue, 16, 31, 0, 0, // Skip to: 355 +/* 324 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 327 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 341 +/* 332 */ MCD_OPC_CheckPredicate, 10, 225, 72, 0, // Skip to: 18994 +/* 337 */ MCD_OPC_Decode, 202, 98, 36, // Opcode: VLSEG3E8_V +/* 341 */ MCD_OPC_FilterValue, 16, 216, 72, 0, // Skip to: 18994 +/* 346 */ MCD_OPC_CheckPredicate, 10, 211, 72, 0, // Skip to: 18994 +/* 351 */ MCD_OPC_Decode, 201, 98, 36, // Opcode: VLSEG3E8FF_V +/* 355 */ MCD_OPC_FilterValue, 17, 9, 0, 0, // Skip to: 369 +/* 360 */ MCD_OPC_CheckPredicate, 10, 197, 72, 0, // Skip to: 18994 +/* 365 */ MCD_OPC_Decode, 154, 99, 38, // Opcode: VLUXSEG3EI8_V +/* 369 */ MCD_OPC_FilterValue, 18, 9, 0, 0, // Skip to: 383 +/* 374 */ MCD_OPC_CheckPredicate, 10, 183, 72, 0, // Skip to: 18994 +/* 379 */ MCD_OPC_Decode, 250, 98, 39, // Opcode: VLSSEG3E8_V +/* 383 */ MCD_OPC_FilterValue, 19, 9, 0, 0, // Skip to: 397 +/* 388 */ MCD_OPC_CheckPredicate, 10, 169, 72, 0, // Skip to: 18994 +/* 393 */ MCD_OPC_Decode, 162, 98, 38, // Opcode: VLOXSEG3EI8_V +/* 397 */ MCD_OPC_FilterValue, 24, 52, 0, 0, // Skip to: 454 +/* 402 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 405 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 419 +/* 410 */ MCD_OPC_CheckPredicate, 10, 147, 72, 0, // Skip to: 18994 +/* 415 */ MCD_OPC_Decode, 210, 98, 36, // Opcode: VLSEG4E8_V +/* 419 */ MCD_OPC_FilterValue, 8, 16, 0, 0, // Skip to: 440 +/* 424 */ MCD_OPC_CheckPredicate, 10, 133, 72, 0, // Skip to: 18994 +/* 429 */ MCD_OPC_CheckField, 25, 1, 1, 126, 72, 0, // Skip to: 18994 +/* 436 */ MCD_OPC_Decode, 137, 98, 41, // Opcode: VL4RE8_V +/* 440 */ MCD_OPC_FilterValue, 16, 117, 72, 0, // Skip to: 18994 +/* 445 */ MCD_OPC_CheckPredicate, 10, 112, 72, 0, // Skip to: 18994 +/* 450 */ MCD_OPC_Decode, 209, 98, 36, // Opcode: VLSEG4E8FF_V +/* 454 */ MCD_OPC_FilterValue, 25, 9, 0, 0, // Skip to: 468 +/* 459 */ MCD_OPC_CheckPredicate, 10, 98, 72, 0, // Skip to: 18994 +/* 464 */ MCD_OPC_Decode, 158, 99, 38, // Opcode: VLUXSEG4EI8_V +/* 468 */ MCD_OPC_FilterValue, 26, 9, 0, 0, // Skip to: 482 +/* 473 */ MCD_OPC_CheckPredicate, 10, 84, 72, 0, // Skip to: 18994 +/* 478 */ MCD_OPC_Decode, 254, 98, 39, // Opcode: VLSSEG4E8_V +/* 482 */ MCD_OPC_FilterValue, 27, 9, 0, 0, // Skip to: 496 +/* 487 */ MCD_OPC_CheckPredicate, 10, 70, 72, 0, // Skip to: 18994 +/* 492 */ MCD_OPC_Decode, 166, 98, 38, // Opcode: VLOXSEG4EI8_V +/* 496 */ MCD_OPC_FilterValue, 32, 31, 0, 0, // Skip to: 532 +/* 501 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 504 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 518 +/* 509 */ MCD_OPC_CheckPredicate, 10, 48, 72, 0, // Skip to: 18994 +/* 514 */ MCD_OPC_Decode, 218, 98, 36, // Opcode: VLSEG5E8_V +/* 518 */ MCD_OPC_FilterValue, 16, 39, 72, 0, // Skip to: 18994 +/* 523 */ MCD_OPC_CheckPredicate, 10, 34, 72, 0, // Skip to: 18994 +/* 528 */ MCD_OPC_Decode, 217, 98, 36, // Opcode: VLSEG5E8FF_V +/* 532 */ MCD_OPC_FilterValue, 33, 9, 0, 0, // Skip to: 546 +/* 537 */ MCD_OPC_CheckPredicate, 10, 20, 72, 0, // Skip to: 18994 +/* 542 */ MCD_OPC_Decode, 162, 99, 38, // Opcode: VLUXSEG5EI8_V +/* 546 */ MCD_OPC_FilterValue, 34, 9, 0, 0, // Skip to: 560 +/* 551 */ MCD_OPC_CheckPredicate, 10, 6, 72, 0, // Skip to: 18994 +/* 556 */ MCD_OPC_Decode, 130, 99, 39, // Opcode: VLSSEG5E8_V +/* 560 */ MCD_OPC_FilterValue, 35, 9, 0, 0, // Skip to: 574 +/* 565 */ MCD_OPC_CheckPredicate, 10, 248, 71, 0, // Skip to: 18994 +/* 570 */ MCD_OPC_Decode, 170, 98, 38, // Opcode: VLOXSEG5EI8_V +/* 574 */ MCD_OPC_FilterValue, 40, 31, 0, 0, // Skip to: 610 +/* 579 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 582 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 596 +/* 587 */ MCD_OPC_CheckPredicate, 10, 226, 71, 0, // Skip to: 18994 +/* 592 */ MCD_OPC_Decode, 226, 98, 36, // Opcode: VLSEG6E8_V +/* 596 */ MCD_OPC_FilterValue, 16, 217, 71, 0, // Skip to: 18994 +/* 601 */ MCD_OPC_CheckPredicate, 10, 212, 71, 0, // Skip to: 18994 +/* 606 */ MCD_OPC_Decode, 225, 98, 36, // Opcode: VLSEG6E8FF_V +/* 610 */ MCD_OPC_FilterValue, 41, 9, 0, 0, // Skip to: 624 +/* 615 */ MCD_OPC_CheckPredicate, 10, 198, 71, 0, // Skip to: 18994 +/* 620 */ MCD_OPC_Decode, 166, 99, 38, // Opcode: VLUXSEG6EI8_V +/* 624 */ MCD_OPC_FilterValue, 42, 9, 0, 0, // Skip to: 638 +/* 629 */ MCD_OPC_CheckPredicate, 10, 184, 71, 0, // Skip to: 18994 +/* 634 */ MCD_OPC_Decode, 134, 99, 39, // Opcode: VLSSEG6E8_V +/* 638 */ MCD_OPC_FilterValue, 43, 9, 0, 0, // Skip to: 652 +/* 643 */ MCD_OPC_CheckPredicate, 10, 170, 71, 0, // Skip to: 18994 +/* 648 */ MCD_OPC_Decode, 174, 98, 38, // Opcode: VLOXSEG6EI8_V +/* 652 */ MCD_OPC_FilterValue, 48, 31, 0, 0, // Skip to: 688 +/* 657 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 660 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 674 +/* 665 */ MCD_OPC_CheckPredicate, 10, 148, 71, 0, // Skip to: 18994 +/* 670 */ MCD_OPC_Decode, 234, 98, 36, // Opcode: VLSEG7E8_V +/* 674 */ MCD_OPC_FilterValue, 16, 139, 71, 0, // Skip to: 18994 +/* 679 */ MCD_OPC_CheckPredicate, 10, 134, 71, 0, // Skip to: 18994 +/* 684 */ MCD_OPC_Decode, 233, 98, 36, // Opcode: VLSEG7E8FF_V +/* 688 */ MCD_OPC_FilterValue, 49, 9, 0, 0, // Skip to: 702 +/* 693 */ MCD_OPC_CheckPredicate, 10, 120, 71, 0, // Skip to: 18994 +/* 698 */ MCD_OPC_Decode, 170, 99, 38, // Opcode: VLUXSEG7EI8_V +/* 702 */ MCD_OPC_FilterValue, 50, 9, 0, 0, // Skip to: 716 +/* 707 */ MCD_OPC_CheckPredicate, 10, 106, 71, 0, // Skip to: 18994 +/* 712 */ MCD_OPC_Decode, 138, 99, 39, // Opcode: VLSSEG7E8_V +/* 716 */ MCD_OPC_FilterValue, 51, 9, 0, 0, // Skip to: 730 +/* 721 */ MCD_OPC_CheckPredicate, 10, 92, 71, 0, // Skip to: 18994 +/* 726 */ MCD_OPC_Decode, 178, 98, 38, // Opcode: VLOXSEG7EI8_V +/* 730 */ MCD_OPC_FilterValue, 56, 52, 0, 0, // Skip to: 787 +/* 735 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 738 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 752 +/* 743 */ MCD_OPC_CheckPredicate, 10, 70, 71, 0, // Skip to: 18994 +/* 748 */ MCD_OPC_Decode, 242, 98, 36, // Opcode: VLSEG8E8_V +/* 752 */ MCD_OPC_FilterValue, 8, 16, 0, 0, // Skip to: 773 +/* 757 */ MCD_OPC_CheckPredicate, 10, 56, 71, 0, // Skip to: 18994 +/* 762 */ MCD_OPC_CheckField, 25, 1, 1, 49, 71, 0, // Skip to: 18994 +/* 769 */ MCD_OPC_Decode, 141, 98, 42, // Opcode: VL8RE8_V +/* 773 */ MCD_OPC_FilterValue, 16, 40, 71, 0, // Skip to: 18994 +/* 778 */ MCD_OPC_CheckPredicate, 10, 35, 71, 0, // Skip to: 18994 +/* 783 */ MCD_OPC_Decode, 241, 98, 36, // Opcode: VLSEG8E8FF_V +/* 787 */ MCD_OPC_FilterValue, 57, 9, 0, 0, // Skip to: 801 +/* 792 */ MCD_OPC_CheckPredicate, 10, 21, 71, 0, // Skip to: 18994 +/* 797 */ MCD_OPC_Decode, 174, 99, 38, // Opcode: VLUXSEG8EI8_V +/* 801 */ MCD_OPC_FilterValue, 58, 9, 0, 0, // Skip to: 815 +/* 806 */ MCD_OPC_CheckPredicate, 10, 7, 71, 0, // Skip to: 18994 +/* 811 */ MCD_OPC_Decode, 142, 99, 39, // Opcode: VLSSEG8E8_V +/* 815 */ MCD_OPC_FilterValue, 59, 254, 70, 0, // Skip to: 18994 +/* 820 */ MCD_OPC_CheckPredicate, 10, 249, 70, 0, // Skip to: 18994 +/* 825 */ MCD_OPC_Decode, 182, 98, 38, // Opcode: VLOXSEG8EI8_V +/* 829 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 843 +/* 834 */ MCD_OPC_CheckPredicate, 11, 235, 70, 0, // Skip to: 18994 +/* 839 */ MCD_OPC_Decode, 159, 93, 43, // Opcode: FLH +/* 843 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 857 +/* 848 */ MCD_OPC_CheckPredicate, 12, 221, 70, 0, // Skip to: 18994 +/* 853 */ MCD_OPC_Decode, 173, 93, 44, // Opcode: FLW +/* 857 */ MCD_OPC_FilterValue, 3, 9, 0, 0, // Skip to: 871 +/* 862 */ MCD_OPC_CheckPredicate, 13, 207, 70, 0, // Skip to: 18994 +/* 867 */ MCD_OPC_Decode, 148, 93, 45, // Opcode: FLD +/* 871 */ MCD_OPC_FilterValue, 5, 199, 2, 0, // Skip to: 1587 +/* 876 */ MCD_OPC_ExtractField, 26, 6, // Inst{31-26} ... +/* 879 */ MCD_OPC_FilterValue, 0, 52, 0, 0, // Skip to: 936 +/* 884 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 887 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 901 +/* 892 */ MCD_OPC_CheckPredicate, 10, 177, 70, 0, // Skip to: 18994 +/* 897 */ MCD_OPC_Decode, 143, 98, 36, // Opcode: VLE16_V +/* 901 */ MCD_OPC_FilterValue, 8, 16, 0, 0, // Skip to: 922 +/* 906 */ MCD_OPC_CheckPredicate, 10, 163, 70, 0, // Skip to: 18994 +/* 911 */ MCD_OPC_CheckField, 25, 1, 1, 156, 70, 0, // Skip to: 18994 +/* 918 */ MCD_OPC_Decode, 254, 97, 37, // Opcode: VL1RE16_V +/* 922 */ MCD_OPC_FilterValue, 16, 147, 70, 0, // Skip to: 18994 +/* 927 */ MCD_OPC_CheckPredicate, 10, 142, 70, 0, // Skip to: 18994 +/* 932 */ MCD_OPC_Decode, 142, 98, 36, // Opcode: VLE16FF_V +/* 936 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 950 +/* 941 */ MCD_OPC_CheckPredicate, 10, 128, 70, 0, // Skip to: 18994 +/* 946 */ MCD_OPC_Decode, 143, 99, 38, // Opcode: VLUXEI16_V +/* 950 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 964 +/* 955 */ MCD_OPC_CheckPredicate, 10, 114, 70, 0, // Skip to: 18994 +/* 960 */ MCD_OPC_Decode, 183, 98, 39, // Opcode: VLSE16_V +/* 964 */ MCD_OPC_FilterValue, 3, 9, 0, 0, // Skip to: 978 +/* 969 */ MCD_OPC_CheckPredicate, 10, 100, 70, 0, // Skip to: 18994 +/* 974 */ MCD_OPC_Decode, 151, 98, 38, // Opcode: VLOXEI16_V +/* 978 */ MCD_OPC_FilterValue, 8, 52, 0, 0, // Skip to: 1035 +/* 983 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 986 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 1000 +/* 991 */ MCD_OPC_CheckPredicate, 10, 78, 70, 0, // Skip to: 18994 +/* 996 */ MCD_OPC_Decode, 188, 98, 36, // Opcode: VLSEG2E16_V +/* 1000 */ MCD_OPC_FilterValue, 8, 16, 0, 0, // Skip to: 1021 +/* 1005 */ MCD_OPC_CheckPredicate, 10, 64, 70, 0, // Skip to: 18994 +/* 1010 */ MCD_OPC_CheckField, 25, 1, 1, 57, 70, 0, // Skip to: 18994 +/* 1017 */ MCD_OPC_Decode, 130, 98, 40, // Opcode: VL2RE16_V +/* 1021 */ MCD_OPC_FilterValue, 16, 48, 70, 0, // Skip to: 18994 +/* 1026 */ MCD_OPC_CheckPredicate, 10, 43, 70, 0, // Skip to: 18994 +/* 1031 */ MCD_OPC_Decode, 187, 98, 36, // Opcode: VLSEG2E16FF_V +/* 1035 */ MCD_OPC_FilterValue, 9, 9, 0, 0, // Skip to: 1049 +/* 1040 */ MCD_OPC_CheckPredicate, 10, 29, 70, 0, // Skip to: 18994 +/* 1045 */ MCD_OPC_Decode, 147, 99, 38, // Opcode: VLUXSEG2EI16_V +/* 1049 */ MCD_OPC_FilterValue, 10, 9, 0, 0, // Skip to: 1063 +/* 1054 */ MCD_OPC_CheckPredicate, 10, 15, 70, 0, // Skip to: 18994 +/* 1059 */ MCD_OPC_Decode, 243, 98, 39, // Opcode: VLSSEG2E16_V +/* 1063 */ MCD_OPC_FilterValue, 11, 9, 0, 0, // Skip to: 1077 +/* 1068 */ MCD_OPC_CheckPredicate, 10, 1, 70, 0, // Skip to: 18994 +/* 1073 */ MCD_OPC_Decode, 155, 98, 38, // Opcode: VLOXSEG2EI16_V +/* 1077 */ MCD_OPC_FilterValue, 16, 31, 0, 0, // Skip to: 1113 +/* 1082 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 1085 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 1099 +/* 1090 */ MCD_OPC_CheckPredicate, 10, 235, 69, 0, // Skip to: 18994 +/* 1095 */ MCD_OPC_Decode, 196, 98, 36, // Opcode: VLSEG3E16_V +/* 1099 */ MCD_OPC_FilterValue, 16, 226, 69, 0, // Skip to: 18994 +/* 1104 */ MCD_OPC_CheckPredicate, 10, 221, 69, 0, // Skip to: 18994 +/* 1109 */ MCD_OPC_Decode, 195, 98, 36, // Opcode: VLSEG3E16FF_V +/* 1113 */ MCD_OPC_FilterValue, 17, 9, 0, 0, // Skip to: 1127 +/* 1118 */ MCD_OPC_CheckPredicate, 10, 207, 69, 0, // Skip to: 18994 +/* 1123 */ MCD_OPC_Decode, 151, 99, 38, // Opcode: VLUXSEG3EI16_V +/* 1127 */ MCD_OPC_FilterValue, 18, 9, 0, 0, // Skip to: 1141 +/* 1132 */ MCD_OPC_CheckPredicate, 10, 193, 69, 0, // Skip to: 18994 +/* 1137 */ MCD_OPC_Decode, 247, 98, 39, // Opcode: VLSSEG3E16_V +/* 1141 */ MCD_OPC_FilterValue, 19, 9, 0, 0, // Skip to: 1155 +/* 1146 */ MCD_OPC_CheckPredicate, 10, 179, 69, 0, // Skip to: 18994 +/* 1151 */ MCD_OPC_Decode, 159, 98, 38, // Opcode: VLOXSEG3EI16_V +/* 1155 */ MCD_OPC_FilterValue, 24, 52, 0, 0, // Skip to: 1212 +/* 1160 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 1163 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 1177 +/* 1168 */ MCD_OPC_CheckPredicate, 10, 157, 69, 0, // Skip to: 18994 +/* 1173 */ MCD_OPC_Decode, 204, 98, 36, // Opcode: VLSEG4E16_V +/* 1177 */ MCD_OPC_FilterValue, 8, 16, 0, 0, // Skip to: 1198 +/* 1182 */ MCD_OPC_CheckPredicate, 10, 143, 69, 0, // Skip to: 18994 +/* 1187 */ MCD_OPC_CheckField, 25, 1, 1, 136, 69, 0, // Skip to: 18994 +/* 1194 */ MCD_OPC_Decode, 134, 98, 41, // Opcode: VL4RE16_V +/* 1198 */ MCD_OPC_FilterValue, 16, 127, 69, 0, // Skip to: 18994 +/* 1203 */ MCD_OPC_CheckPredicate, 10, 122, 69, 0, // Skip to: 18994 +/* 1208 */ MCD_OPC_Decode, 203, 98, 36, // Opcode: VLSEG4E16FF_V +/* 1212 */ MCD_OPC_FilterValue, 25, 9, 0, 0, // Skip to: 1226 +/* 1217 */ MCD_OPC_CheckPredicate, 10, 108, 69, 0, // Skip to: 18994 +/* 1222 */ MCD_OPC_Decode, 155, 99, 38, // Opcode: VLUXSEG4EI16_V +/* 1226 */ MCD_OPC_FilterValue, 26, 9, 0, 0, // Skip to: 1240 +/* 1231 */ MCD_OPC_CheckPredicate, 10, 94, 69, 0, // Skip to: 18994 +/* 1236 */ MCD_OPC_Decode, 251, 98, 39, // Opcode: VLSSEG4E16_V +/* 1240 */ MCD_OPC_FilterValue, 27, 9, 0, 0, // Skip to: 1254 +/* 1245 */ MCD_OPC_CheckPredicate, 10, 80, 69, 0, // Skip to: 18994 +/* 1250 */ MCD_OPC_Decode, 163, 98, 38, // Opcode: VLOXSEG4EI16_V +/* 1254 */ MCD_OPC_FilterValue, 32, 31, 0, 0, // Skip to: 1290 +/* 1259 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 1262 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 1276 +/* 1267 */ MCD_OPC_CheckPredicate, 10, 58, 69, 0, // Skip to: 18994 +/* 1272 */ MCD_OPC_Decode, 212, 98, 36, // Opcode: VLSEG5E16_V +/* 1276 */ MCD_OPC_FilterValue, 16, 49, 69, 0, // Skip to: 18994 +/* 1281 */ MCD_OPC_CheckPredicate, 10, 44, 69, 0, // Skip to: 18994 +/* 1286 */ MCD_OPC_Decode, 211, 98, 36, // Opcode: VLSEG5E16FF_V +/* 1290 */ MCD_OPC_FilterValue, 33, 9, 0, 0, // Skip to: 1304 +/* 1295 */ MCD_OPC_CheckPredicate, 10, 30, 69, 0, // Skip to: 18994 +/* 1300 */ MCD_OPC_Decode, 159, 99, 38, // Opcode: VLUXSEG5EI16_V +/* 1304 */ MCD_OPC_FilterValue, 34, 9, 0, 0, // Skip to: 1318 +/* 1309 */ MCD_OPC_CheckPredicate, 10, 16, 69, 0, // Skip to: 18994 +/* 1314 */ MCD_OPC_Decode, 255, 98, 39, // Opcode: VLSSEG5E16_V +/* 1318 */ MCD_OPC_FilterValue, 35, 9, 0, 0, // Skip to: 1332 +/* 1323 */ MCD_OPC_CheckPredicate, 10, 2, 69, 0, // Skip to: 18994 +/* 1328 */ MCD_OPC_Decode, 167, 98, 38, // Opcode: VLOXSEG5EI16_V +/* 1332 */ MCD_OPC_FilterValue, 40, 31, 0, 0, // Skip to: 1368 +/* 1337 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 1340 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 1354 +/* 1345 */ MCD_OPC_CheckPredicate, 10, 236, 68, 0, // Skip to: 18994 +/* 1350 */ MCD_OPC_Decode, 220, 98, 36, // Opcode: VLSEG6E16_V +/* 1354 */ MCD_OPC_FilterValue, 16, 227, 68, 0, // Skip to: 18994 +/* 1359 */ MCD_OPC_CheckPredicate, 10, 222, 68, 0, // Skip to: 18994 +/* 1364 */ MCD_OPC_Decode, 219, 98, 36, // Opcode: VLSEG6E16FF_V +/* 1368 */ MCD_OPC_FilterValue, 41, 9, 0, 0, // Skip to: 1382 +/* 1373 */ MCD_OPC_CheckPredicate, 10, 208, 68, 0, // Skip to: 18994 +/* 1378 */ MCD_OPC_Decode, 163, 99, 38, // Opcode: VLUXSEG6EI16_V +/* 1382 */ MCD_OPC_FilterValue, 42, 9, 0, 0, // Skip to: 1396 +/* 1387 */ MCD_OPC_CheckPredicate, 10, 194, 68, 0, // Skip to: 18994 +/* 1392 */ MCD_OPC_Decode, 131, 99, 39, // Opcode: VLSSEG6E16_V +/* 1396 */ MCD_OPC_FilterValue, 43, 9, 0, 0, // Skip to: 1410 +/* 1401 */ MCD_OPC_CheckPredicate, 10, 180, 68, 0, // Skip to: 18994 +/* 1406 */ MCD_OPC_Decode, 171, 98, 38, // Opcode: VLOXSEG6EI16_V +/* 1410 */ MCD_OPC_FilterValue, 48, 31, 0, 0, // Skip to: 1446 +/* 1415 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 1418 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 1432 +/* 1423 */ MCD_OPC_CheckPredicate, 10, 158, 68, 0, // Skip to: 18994 +/* 1428 */ MCD_OPC_Decode, 228, 98, 36, // Opcode: VLSEG7E16_V +/* 1432 */ MCD_OPC_FilterValue, 16, 149, 68, 0, // Skip to: 18994 +/* 1437 */ MCD_OPC_CheckPredicate, 10, 144, 68, 0, // Skip to: 18994 +/* 1442 */ MCD_OPC_Decode, 227, 98, 36, // Opcode: VLSEG7E16FF_V +/* 1446 */ MCD_OPC_FilterValue, 49, 9, 0, 0, // Skip to: 1460 +/* 1451 */ MCD_OPC_CheckPredicate, 10, 130, 68, 0, // Skip to: 18994 +/* 1456 */ MCD_OPC_Decode, 167, 99, 38, // Opcode: VLUXSEG7EI16_V +/* 1460 */ MCD_OPC_FilterValue, 50, 9, 0, 0, // Skip to: 1474 +/* 1465 */ MCD_OPC_CheckPredicate, 10, 116, 68, 0, // Skip to: 18994 +/* 1470 */ MCD_OPC_Decode, 135, 99, 39, // Opcode: VLSSEG7E16_V +/* 1474 */ MCD_OPC_FilterValue, 51, 9, 0, 0, // Skip to: 1488 +/* 1479 */ MCD_OPC_CheckPredicate, 10, 102, 68, 0, // Skip to: 18994 +/* 1484 */ MCD_OPC_Decode, 175, 98, 38, // Opcode: VLOXSEG7EI16_V +/* 1488 */ MCD_OPC_FilterValue, 56, 52, 0, 0, // Skip to: 1545 +/* 1493 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 1496 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 1510 +/* 1501 */ MCD_OPC_CheckPredicate, 10, 80, 68, 0, // Skip to: 18994 +/* 1506 */ MCD_OPC_Decode, 236, 98, 36, // Opcode: VLSEG8E16_V +/* 1510 */ MCD_OPC_FilterValue, 8, 16, 0, 0, // Skip to: 1531 +/* 1515 */ MCD_OPC_CheckPredicate, 10, 66, 68, 0, // Skip to: 18994 +/* 1520 */ MCD_OPC_CheckField, 25, 1, 1, 59, 68, 0, // Skip to: 18994 +/* 1527 */ MCD_OPC_Decode, 138, 98, 42, // Opcode: VL8RE16_V +/* 1531 */ MCD_OPC_FilterValue, 16, 50, 68, 0, // Skip to: 18994 +/* 1536 */ MCD_OPC_CheckPredicate, 10, 45, 68, 0, // Skip to: 18994 +/* 1541 */ MCD_OPC_Decode, 235, 98, 36, // Opcode: VLSEG8E16FF_V +/* 1545 */ MCD_OPC_FilterValue, 57, 9, 0, 0, // Skip to: 1559 +/* 1550 */ MCD_OPC_CheckPredicate, 10, 31, 68, 0, // Skip to: 18994 +/* 1555 */ MCD_OPC_Decode, 171, 99, 38, // Opcode: VLUXSEG8EI16_V +/* 1559 */ MCD_OPC_FilterValue, 58, 9, 0, 0, // Skip to: 1573 +/* 1564 */ MCD_OPC_CheckPredicate, 10, 17, 68, 0, // Skip to: 18994 +/* 1569 */ MCD_OPC_Decode, 139, 99, 39, // Opcode: VLSSEG8E16_V +/* 1573 */ MCD_OPC_FilterValue, 59, 8, 68, 0, // Skip to: 18994 +/* 1578 */ MCD_OPC_CheckPredicate, 10, 3, 68, 0, // Skip to: 18994 +/* 1583 */ MCD_OPC_Decode, 179, 98, 38, // Opcode: VLOXSEG8EI16_V +/* 1587 */ MCD_OPC_FilterValue, 6, 199, 2, 0, // Skip to: 2303 +/* 1592 */ MCD_OPC_ExtractField, 26, 6, // Inst{31-26} ... +/* 1595 */ MCD_OPC_FilterValue, 0, 52, 0, 0, // Skip to: 1652 +/* 1600 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 1603 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 1617 +/* 1608 */ MCD_OPC_CheckPredicate, 10, 229, 67, 0, // Skip to: 18994 +/* 1613 */ MCD_OPC_Decode, 145, 98, 36, // Opcode: VLE32_V +/* 1617 */ MCD_OPC_FilterValue, 8, 16, 0, 0, // Skip to: 1638 +/* 1622 */ MCD_OPC_CheckPredicate, 10, 215, 67, 0, // Skip to: 18994 +/* 1627 */ MCD_OPC_CheckField, 25, 1, 1, 208, 67, 0, // Skip to: 18994 +/* 1634 */ MCD_OPC_Decode, 255, 97, 37, // Opcode: VL1RE32_V +/* 1638 */ MCD_OPC_FilterValue, 16, 199, 67, 0, // Skip to: 18994 +/* 1643 */ MCD_OPC_CheckPredicate, 10, 194, 67, 0, // Skip to: 18994 +/* 1648 */ MCD_OPC_Decode, 144, 98, 36, // Opcode: VLE32FF_V +/* 1652 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 1666 +/* 1657 */ MCD_OPC_CheckPredicate, 10, 180, 67, 0, // Skip to: 18994 +/* 1662 */ MCD_OPC_Decode, 144, 99, 38, // Opcode: VLUXEI32_V +/* 1666 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 1680 +/* 1671 */ MCD_OPC_CheckPredicate, 10, 166, 67, 0, // Skip to: 18994 +/* 1676 */ MCD_OPC_Decode, 184, 98, 39, // Opcode: VLSE32_V +/* 1680 */ MCD_OPC_FilterValue, 3, 9, 0, 0, // Skip to: 1694 +/* 1685 */ MCD_OPC_CheckPredicate, 10, 152, 67, 0, // Skip to: 18994 +/* 1690 */ MCD_OPC_Decode, 152, 98, 38, // Opcode: VLOXEI32_V +/* 1694 */ MCD_OPC_FilterValue, 8, 52, 0, 0, // Skip to: 1751 +/* 1699 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 1702 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 1716 +/* 1707 */ MCD_OPC_CheckPredicate, 10, 130, 67, 0, // Skip to: 18994 +/* 1712 */ MCD_OPC_Decode, 190, 98, 36, // Opcode: VLSEG2E32_V +/* 1716 */ MCD_OPC_FilterValue, 8, 16, 0, 0, // Skip to: 1737 +/* 1721 */ MCD_OPC_CheckPredicate, 10, 116, 67, 0, // Skip to: 18994 +/* 1726 */ MCD_OPC_CheckField, 25, 1, 1, 109, 67, 0, // Skip to: 18994 +/* 1733 */ MCD_OPC_Decode, 131, 98, 40, // Opcode: VL2RE32_V +/* 1737 */ MCD_OPC_FilterValue, 16, 100, 67, 0, // Skip to: 18994 +/* 1742 */ MCD_OPC_CheckPredicate, 10, 95, 67, 0, // Skip to: 18994 +/* 1747 */ MCD_OPC_Decode, 189, 98, 36, // Opcode: VLSEG2E32FF_V +/* 1751 */ MCD_OPC_FilterValue, 9, 9, 0, 0, // Skip to: 1765 +/* 1756 */ MCD_OPC_CheckPredicate, 10, 81, 67, 0, // Skip to: 18994 +/* 1761 */ MCD_OPC_Decode, 148, 99, 38, // Opcode: VLUXSEG2EI32_V +/* 1765 */ MCD_OPC_FilterValue, 10, 9, 0, 0, // Skip to: 1779 +/* 1770 */ MCD_OPC_CheckPredicate, 10, 67, 67, 0, // Skip to: 18994 +/* 1775 */ MCD_OPC_Decode, 244, 98, 39, // Opcode: VLSSEG2E32_V +/* 1779 */ MCD_OPC_FilterValue, 11, 9, 0, 0, // Skip to: 1793 +/* 1784 */ MCD_OPC_CheckPredicate, 10, 53, 67, 0, // Skip to: 18994 +/* 1789 */ MCD_OPC_Decode, 156, 98, 38, // Opcode: VLOXSEG2EI32_V +/* 1793 */ MCD_OPC_FilterValue, 16, 31, 0, 0, // Skip to: 1829 +/* 1798 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 1801 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 1815 +/* 1806 */ MCD_OPC_CheckPredicate, 10, 31, 67, 0, // Skip to: 18994 +/* 1811 */ MCD_OPC_Decode, 198, 98, 36, // Opcode: VLSEG3E32_V +/* 1815 */ MCD_OPC_FilterValue, 16, 22, 67, 0, // Skip to: 18994 +/* 1820 */ MCD_OPC_CheckPredicate, 10, 17, 67, 0, // Skip to: 18994 +/* 1825 */ MCD_OPC_Decode, 197, 98, 36, // Opcode: VLSEG3E32FF_V +/* 1829 */ MCD_OPC_FilterValue, 17, 9, 0, 0, // Skip to: 1843 +/* 1834 */ MCD_OPC_CheckPredicate, 10, 3, 67, 0, // Skip to: 18994 +/* 1839 */ MCD_OPC_Decode, 152, 99, 38, // Opcode: VLUXSEG3EI32_V +/* 1843 */ MCD_OPC_FilterValue, 18, 9, 0, 0, // Skip to: 1857 +/* 1848 */ MCD_OPC_CheckPredicate, 10, 245, 66, 0, // Skip to: 18994 +/* 1853 */ MCD_OPC_Decode, 248, 98, 39, // Opcode: VLSSEG3E32_V +/* 1857 */ MCD_OPC_FilterValue, 19, 9, 0, 0, // Skip to: 1871 +/* 1862 */ MCD_OPC_CheckPredicate, 10, 231, 66, 0, // Skip to: 18994 +/* 1867 */ MCD_OPC_Decode, 160, 98, 38, // Opcode: VLOXSEG3EI32_V +/* 1871 */ MCD_OPC_FilterValue, 24, 52, 0, 0, // Skip to: 1928 +/* 1876 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 1879 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 1893 +/* 1884 */ MCD_OPC_CheckPredicate, 10, 209, 66, 0, // Skip to: 18994 +/* 1889 */ MCD_OPC_Decode, 206, 98, 36, // Opcode: VLSEG4E32_V +/* 1893 */ MCD_OPC_FilterValue, 8, 16, 0, 0, // Skip to: 1914 +/* 1898 */ MCD_OPC_CheckPredicate, 10, 195, 66, 0, // Skip to: 18994 +/* 1903 */ MCD_OPC_CheckField, 25, 1, 1, 188, 66, 0, // Skip to: 18994 +/* 1910 */ MCD_OPC_Decode, 135, 98, 41, // Opcode: VL4RE32_V +/* 1914 */ MCD_OPC_FilterValue, 16, 179, 66, 0, // Skip to: 18994 +/* 1919 */ MCD_OPC_CheckPredicate, 10, 174, 66, 0, // Skip to: 18994 +/* 1924 */ MCD_OPC_Decode, 205, 98, 36, // Opcode: VLSEG4E32FF_V +/* 1928 */ MCD_OPC_FilterValue, 25, 9, 0, 0, // Skip to: 1942 +/* 1933 */ MCD_OPC_CheckPredicate, 10, 160, 66, 0, // Skip to: 18994 +/* 1938 */ MCD_OPC_Decode, 156, 99, 38, // Opcode: VLUXSEG4EI32_V +/* 1942 */ MCD_OPC_FilterValue, 26, 9, 0, 0, // Skip to: 1956 +/* 1947 */ MCD_OPC_CheckPredicate, 10, 146, 66, 0, // Skip to: 18994 +/* 1952 */ MCD_OPC_Decode, 252, 98, 39, // Opcode: VLSSEG4E32_V +/* 1956 */ MCD_OPC_FilterValue, 27, 9, 0, 0, // Skip to: 1970 +/* 1961 */ MCD_OPC_CheckPredicate, 10, 132, 66, 0, // Skip to: 18994 +/* 1966 */ MCD_OPC_Decode, 164, 98, 38, // Opcode: VLOXSEG4EI32_V +/* 1970 */ MCD_OPC_FilterValue, 32, 31, 0, 0, // Skip to: 2006 +/* 1975 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 1978 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 1992 +/* 1983 */ MCD_OPC_CheckPredicate, 10, 110, 66, 0, // Skip to: 18994 +/* 1988 */ MCD_OPC_Decode, 214, 98, 36, // Opcode: VLSEG5E32_V +/* 1992 */ MCD_OPC_FilterValue, 16, 101, 66, 0, // Skip to: 18994 +/* 1997 */ MCD_OPC_CheckPredicate, 10, 96, 66, 0, // Skip to: 18994 +/* 2002 */ MCD_OPC_Decode, 213, 98, 36, // Opcode: VLSEG5E32FF_V +/* 2006 */ MCD_OPC_FilterValue, 33, 9, 0, 0, // Skip to: 2020 +/* 2011 */ MCD_OPC_CheckPredicate, 10, 82, 66, 0, // Skip to: 18994 +/* 2016 */ MCD_OPC_Decode, 160, 99, 38, // Opcode: VLUXSEG5EI32_V +/* 2020 */ MCD_OPC_FilterValue, 34, 9, 0, 0, // Skip to: 2034 +/* 2025 */ MCD_OPC_CheckPredicate, 10, 68, 66, 0, // Skip to: 18994 +/* 2030 */ MCD_OPC_Decode, 128, 99, 39, // Opcode: VLSSEG5E32_V +/* 2034 */ MCD_OPC_FilterValue, 35, 9, 0, 0, // Skip to: 2048 +/* 2039 */ MCD_OPC_CheckPredicate, 10, 54, 66, 0, // Skip to: 18994 +/* 2044 */ MCD_OPC_Decode, 168, 98, 38, // Opcode: VLOXSEG5EI32_V +/* 2048 */ MCD_OPC_FilterValue, 40, 31, 0, 0, // Skip to: 2084 +/* 2053 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 2056 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 2070 +/* 2061 */ MCD_OPC_CheckPredicate, 10, 32, 66, 0, // Skip to: 18994 +/* 2066 */ MCD_OPC_Decode, 222, 98, 36, // Opcode: VLSEG6E32_V +/* 2070 */ MCD_OPC_FilterValue, 16, 23, 66, 0, // Skip to: 18994 +/* 2075 */ MCD_OPC_CheckPredicate, 10, 18, 66, 0, // Skip to: 18994 +/* 2080 */ MCD_OPC_Decode, 221, 98, 36, // Opcode: VLSEG6E32FF_V +/* 2084 */ MCD_OPC_FilterValue, 41, 9, 0, 0, // Skip to: 2098 +/* 2089 */ MCD_OPC_CheckPredicate, 10, 4, 66, 0, // Skip to: 18994 +/* 2094 */ MCD_OPC_Decode, 164, 99, 38, // Opcode: VLUXSEG6EI32_V +/* 2098 */ MCD_OPC_FilterValue, 42, 9, 0, 0, // Skip to: 2112 +/* 2103 */ MCD_OPC_CheckPredicate, 10, 246, 65, 0, // Skip to: 18994 +/* 2108 */ MCD_OPC_Decode, 132, 99, 39, // Opcode: VLSSEG6E32_V +/* 2112 */ MCD_OPC_FilterValue, 43, 9, 0, 0, // Skip to: 2126 +/* 2117 */ MCD_OPC_CheckPredicate, 10, 232, 65, 0, // Skip to: 18994 +/* 2122 */ MCD_OPC_Decode, 172, 98, 38, // Opcode: VLOXSEG6EI32_V +/* 2126 */ MCD_OPC_FilterValue, 48, 31, 0, 0, // Skip to: 2162 +/* 2131 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 2134 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 2148 +/* 2139 */ MCD_OPC_CheckPredicate, 10, 210, 65, 0, // Skip to: 18994 +/* 2144 */ MCD_OPC_Decode, 230, 98, 36, // Opcode: VLSEG7E32_V +/* 2148 */ MCD_OPC_FilterValue, 16, 201, 65, 0, // Skip to: 18994 +/* 2153 */ MCD_OPC_CheckPredicate, 10, 196, 65, 0, // Skip to: 18994 +/* 2158 */ MCD_OPC_Decode, 229, 98, 36, // Opcode: VLSEG7E32FF_V +/* 2162 */ MCD_OPC_FilterValue, 49, 9, 0, 0, // Skip to: 2176 +/* 2167 */ MCD_OPC_CheckPredicate, 10, 182, 65, 0, // Skip to: 18994 +/* 2172 */ MCD_OPC_Decode, 168, 99, 38, // Opcode: VLUXSEG7EI32_V +/* 2176 */ MCD_OPC_FilterValue, 50, 9, 0, 0, // Skip to: 2190 +/* 2181 */ MCD_OPC_CheckPredicate, 10, 168, 65, 0, // Skip to: 18994 +/* 2186 */ MCD_OPC_Decode, 136, 99, 39, // Opcode: VLSSEG7E32_V +/* 2190 */ MCD_OPC_FilterValue, 51, 9, 0, 0, // Skip to: 2204 +/* 2195 */ MCD_OPC_CheckPredicate, 10, 154, 65, 0, // Skip to: 18994 +/* 2200 */ MCD_OPC_Decode, 176, 98, 38, // Opcode: VLOXSEG7EI32_V +/* 2204 */ MCD_OPC_FilterValue, 56, 52, 0, 0, // Skip to: 2261 +/* 2209 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 2212 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 2226 +/* 2217 */ MCD_OPC_CheckPredicate, 10, 132, 65, 0, // Skip to: 18994 +/* 2222 */ MCD_OPC_Decode, 238, 98, 36, // Opcode: VLSEG8E32_V +/* 2226 */ MCD_OPC_FilterValue, 8, 16, 0, 0, // Skip to: 2247 +/* 2231 */ MCD_OPC_CheckPredicate, 10, 118, 65, 0, // Skip to: 18994 +/* 2236 */ MCD_OPC_CheckField, 25, 1, 1, 111, 65, 0, // Skip to: 18994 +/* 2243 */ MCD_OPC_Decode, 139, 98, 42, // Opcode: VL8RE32_V +/* 2247 */ MCD_OPC_FilterValue, 16, 102, 65, 0, // Skip to: 18994 +/* 2252 */ MCD_OPC_CheckPredicate, 10, 97, 65, 0, // Skip to: 18994 +/* 2257 */ MCD_OPC_Decode, 237, 98, 36, // Opcode: VLSEG8E32FF_V +/* 2261 */ MCD_OPC_FilterValue, 57, 9, 0, 0, // Skip to: 2275 +/* 2266 */ MCD_OPC_CheckPredicate, 10, 83, 65, 0, // Skip to: 18994 +/* 2271 */ MCD_OPC_Decode, 172, 99, 38, // Opcode: VLUXSEG8EI32_V +/* 2275 */ MCD_OPC_FilterValue, 58, 9, 0, 0, // Skip to: 2289 +/* 2280 */ MCD_OPC_CheckPredicate, 10, 69, 65, 0, // Skip to: 18994 +/* 2285 */ MCD_OPC_Decode, 140, 99, 39, // Opcode: VLSSEG8E32_V +/* 2289 */ MCD_OPC_FilterValue, 59, 60, 65, 0, // Skip to: 18994 +/* 2294 */ MCD_OPC_CheckPredicate, 10, 55, 65, 0, // Skip to: 18994 +/* 2299 */ MCD_OPC_Decode, 180, 98, 38, // Opcode: VLOXSEG8EI32_V +/* 2303 */ MCD_OPC_FilterValue, 7, 46, 65, 0, // Skip to: 18994 +/* 2308 */ MCD_OPC_ExtractField, 26, 6, // Inst{31-26} ... +/* 2311 */ MCD_OPC_FilterValue, 0, 52, 0, 0, // Skip to: 2368 +/* 2316 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 2319 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 2333 +/* 2324 */ MCD_OPC_CheckPredicate, 14, 25, 65, 0, // Skip to: 18994 +/* 2329 */ MCD_OPC_Decode, 147, 98, 36, // Opcode: VLE64_V +/* 2333 */ MCD_OPC_FilterValue, 8, 16, 0, 0, // Skip to: 2354 +/* 2338 */ MCD_OPC_CheckPredicate, 14, 11, 65, 0, // Skip to: 18994 +/* 2343 */ MCD_OPC_CheckField, 25, 1, 1, 4, 65, 0, // Skip to: 18994 +/* 2350 */ MCD_OPC_Decode, 128, 98, 37, // Opcode: VL1RE64_V +/* 2354 */ MCD_OPC_FilterValue, 16, 251, 64, 0, // Skip to: 18994 +/* 2359 */ MCD_OPC_CheckPredicate, 14, 246, 64, 0, // Skip to: 18994 +/* 2364 */ MCD_OPC_Decode, 146, 98, 36, // Opcode: VLE64FF_V +/* 2368 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 2382 +/* 2373 */ MCD_OPC_CheckPredicate, 15, 232, 64, 0, // Skip to: 18994 +/* 2378 */ MCD_OPC_Decode, 145, 99, 38, // Opcode: VLUXEI64_V +/* 2382 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 2396 +/* 2387 */ MCD_OPC_CheckPredicate, 14, 218, 64, 0, // Skip to: 18994 +/* 2392 */ MCD_OPC_Decode, 185, 98, 39, // Opcode: VLSE64_V +/* 2396 */ MCD_OPC_FilterValue, 3, 9, 0, 0, // Skip to: 2410 +/* 2401 */ MCD_OPC_CheckPredicate, 15, 204, 64, 0, // Skip to: 18994 +/* 2406 */ MCD_OPC_Decode, 153, 98, 38, // Opcode: VLOXEI64_V +/* 2410 */ MCD_OPC_FilterValue, 8, 52, 0, 0, // Skip to: 2467 +/* 2415 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 2418 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 2432 +/* 2423 */ MCD_OPC_CheckPredicate, 14, 182, 64, 0, // Skip to: 18994 +/* 2428 */ MCD_OPC_Decode, 192, 98, 36, // Opcode: VLSEG2E64_V +/* 2432 */ MCD_OPC_FilterValue, 8, 16, 0, 0, // Skip to: 2453 +/* 2437 */ MCD_OPC_CheckPredicate, 14, 168, 64, 0, // Skip to: 18994 +/* 2442 */ MCD_OPC_CheckField, 25, 1, 1, 161, 64, 0, // Skip to: 18994 +/* 2449 */ MCD_OPC_Decode, 132, 98, 40, // Opcode: VL2RE64_V +/* 2453 */ MCD_OPC_FilterValue, 16, 152, 64, 0, // Skip to: 18994 +/* 2458 */ MCD_OPC_CheckPredicate, 14, 147, 64, 0, // Skip to: 18994 +/* 2463 */ MCD_OPC_Decode, 191, 98, 36, // Opcode: VLSEG2E64FF_V +/* 2467 */ MCD_OPC_FilterValue, 9, 9, 0, 0, // Skip to: 2481 +/* 2472 */ MCD_OPC_CheckPredicate, 16, 133, 64, 0, // Skip to: 18994 +/* 2477 */ MCD_OPC_Decode, 149, 99, 38, // Opcode: VLUXSEG2EI64_V +/* 2481 */ MCD_OPC_FilterValue, 10, 9, 0, 0, // Skip to: 2495 +/* 2486 */ MCD_OPC_CheckPredicate, 14, 119, 64, 0, // Skip to: 18994 +/* 2491 */ MCD_OPC_Decode, 245, 98, 39, // Opcode: VLSSEG2E64_V +/* 2495 */ MCD_OPC_FilterValue, 11, 9, 0, 0, // Skip to: 2509 +/* 2500 */ MCD_OPC_CheckPredicate, 16, 105, 64, 0, // Skip to: 18994 +/* 2505 */ MCD_OPC_Decode, 157, 98, 38, // Opcode: VLOXSEG2EI64_V +/* 2509 */ MCD_OPC_FilterValue, 16, 31, 0, 0, // Skip to: 2545 +/* 2514 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 2517 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 2531 +/* 2522 */ MCD_OPC_CheckPredicate, 14, 83, 64, 0, // Skip to: 18994 +/* 2527 */ MCD_OPC_Decode, 200, 98, 36, // Opcode: VLSEG3E64_V +/* 2531 */ MCD_OPC_FilterValue, 16, 74, 64, 0, // Skip to: 18994 +/* 2536 */ MCD_OPC_CheckPredicate, 14, 69, 64, 0, // Skip to: 18994 +/* 2541 */ MCD_OPC_Decode, 199, 98, 36, // Opcode: VLSEG3E64FF_V +/* 2545 */ MCD_OPC_FilterValue, 17, 9, 0, 0, // Skip to: 2559 +/* 2550 */ MCD_OPC_CheckPredicate, 16, 55, 64, 0, // Skip to: 18994 +/* 2555 */ MCD_OPC_Decode, 153, 99, 38, // Opcode: VLUXSEG3EI64_V +/* 2559 */ MCD_OPC_FilterValue, 18, 9, 0, 0, // Skip to: 2573 +/* 2564 */ MCD_OPC_CheckPredicate, 14, 41, 64, 0, // Skip to: 18994 +/* 2569 */ MCD_OPC_Decode, 249, 98, 39, // Opcode: VLSSEG3E64_V +/* 2573 */ MCD_OPC_FilterValue, 19, 9, 0, 0, // Skip to: 2587 +/* 2578 */ MCD_OPC_CheckPredicate, 16, 27, 64, 0, // Skip to: 18994 +/* 2583 */ MCD_OPC_Decode, 161, 98, 38, // Opcode: VLOXSEG3EI64_V +/* 2587 */ MCD_OPC_FilterValue, 24, 52, 0, 0, // Skip to: 2644 +/* 2592 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 2595 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 2609 +/* 2600 */ MCD_OPC_CheckPredicate, 14, 5, 64, 0, // Skip to: 18994 +/* 2605 */ MCD_OPC_Decode, 208, 98, 36, // Opcode: VLSEG4E64_V +/* 2609 */ MCD_OPC_FilterValue, 8, 16, 0, 0, // Skip to: 2630 +/* 2614 */ MCD_OPC_CheckPredicate, 14, 247, 63, 0, // Skip to: 18994 +/* 2619 */ MCD_OPC_CheckField, 25, 1, 1, 240, 63, 0, // Skip to: 18994 +/* 2626 */ MCD_OPC_Decode, 136, 98, 41, // Opcode: VL4RE64_V +/* 2630 */ MCD_OPC_FilterValue, 16, 231, 63, 0, // Skip to: 18994 +/* 2635 */ MCD_OPC_CheckPredicate, 14, 226, 63, 0, // Skip to: 18994 +/* 2640 */ MCD_OPC_Decode, 207, 98, 36, // Opcode: VLSEG4E64FF_V +/* 2644 */ MCD_OPC_FilterValue, 25, 9, 0, 0, // Skip to: 2658 +/* 2649 */ MCD_OPC_CheckPredicate, 16, 212, 63, 0, // Skip to: 18994 +/* 2654 */ MCD_OPC_Decode, 157, 99, 38, // Opcode: VLUXSEG4EI64_V +/* 2658 */ MCD_OPC_FilterValue, 26, 9, 0, 0, // Skip to: 2672 +/* 2663 */ MCD_OPC_CheckPredicate, 14, 198, 63, 0, // Skip to: 18994 +/* 2668 */ MCD_OPC_Decode, 253, 98, 39, // Opcode: VLSSEG4E64_V +/* 2672 */ MCD_OPC_FilterValue, 27, 9, 0, 0, // Skip to: 2686 +/* 2677 */ MCD_OPC_CheckPredicate, 16, 184, 63, 0, // Skip to: 18994 +/* 2682 */ MCD_OPC_Decode, 165, 98, 38, // Opcode: VLOXSEG4EI64_V +/* 2686 */ MCD_OPC_FilterValue, 32, 31, 0, 0, // Skip to: 2722 +/* 2691 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 2694 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 2708 +/* 2699 */ MCD_OPC_CheckPredicate, 14, 162, 63, 0, // Skip to: 18994 +/* 2704 */ MCD_OPC_Decode, 216, 98, 36, // Opcode: VLSEG5E64_V +/* 2708 */ MCD_OPC_FilterValue, 16, 153, 63, 0, // Skip to: 18994 +/* 2713 */ MCD_OPC_CheckPredicate, 14, 148, 63, 0, // Skip to: 18994 +/* 2718 */ MCD_OPC_Decode, 215, 98, 36, // Opcode: VLSEG5E64FF_V +/* 2722 */ MCD_OPC_FilterValue, 33, 9, 0, 0, // Skip to: 2736 +/* 2727 */ MCD_OPC_CheckPredicate, 16, 134, 63, 0, // Skip to: 18994 +/* 2732 */ MCD_OPC_Decode, 161, 99, 38, // Opcode: VLUXSEG5EI64_V +/* 2736 */ MCD_OPC_FilterValue, 34, 9, 0, 0, // Skip to: 2750 +/* 2741 */ MCD_OPC_CheckPredicate, 14, 120, 63, 0, // Skip to: 18994 +/* 2746 */ MCD_OPC_Decode, 129, 99, 39, // Opcode: VLSSEG5E64_V +/* 2750 */ MCD_OPC_FilterValue, 35, 9, 0, 0, // Skip to: 2764 +/* 2755 */ MCD_OPC_CheckPredicate, 16, 106, 63, 0, // Skip to: 18994 +/* 2760 */ MCD_OPC_Decode, 169, 98, 38, // Opcode: VLOXSEG5EI64_V +/* 2764 */ MCD_OPC_FilterValue, 40, 31, 0, 0, // Skip to: 2800 +/* 2769 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 2772 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 2786 +/* 2777 */ MCD_OPC_CheckPredicate, 14, 84, 63, 0, // Skip to: 18994 +/* 2782 */ MCD_OPC_Decode, 224, 98, 36, // Opcode: VLSEG6E64_V +/* 2786 */ MCD_OPC_FilterValue, 16, 75, 63, 0, // Skip to: 18994 +/* 2791 */ MCD_OPC_CheckPredicate, 14, 70, 63, 0, // Skip to: 18994 +/* 2796 */ MCD_OPC_Decode, 223, 98, 36, // Opcode: VLSEG6E64FF_V +/* 2800 */ MCD_OPC_FilterValue, 41, 9, 0, 0, // Skip to: 2814 +/* 2805 */ MCD_OPC_CheckPredicate, 16, 56, 63, 0, // Skip to: 18994 +/* 2810 */ MCD_OPC_Decode, 165, 99, 38, // Opcode: VLUXSEG6EI64_V +/* 2814 */ MCD_OPC_FilterValue, 42, 9, 0, 0, // Skip to: 2828 +/* 2819 */ MCD_OPC_CheckPredicate, 14, 42, 63, 0, // Skip to: 18994 +/* 2824 */ MCD_OPC_Decode, 133, 99, 39, // Opcode: VLSSEG6E64_V +/* 2828 */ MCD_OPC_FilterValue, 43, 9, 0, 0, // Skip to: 2842 +/* 2833 */ MCD_OPC_CheckPredicate, 16, 28, 63, 0, // Skip to: 18994 +/* 2838 */ MCD_OPC_Decode, 173, 98, 38, // Opcode: VLOXSEG6EI64_V +/* 2842 */ MCD_OPC_FilterValue, 48, 31, 0, 0, // Skip to: 2878 +/* 2847 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 2850 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 2864 +/* 2855 */ MCD_OPC_CheckPredicate, 14, 6, 63, 0, // Skip to: 18994 +/* 2860 */ MCD_OPC_Decode, 232, 98, 36, // Opcode: VLSEG7E64_V +/* 2864 */ MCD_OPC_FilterValue, 16, 253, 62, 0, // Skip to: 18994 +/* 2869 */ MCD_OPC_CheckPredicate, 14, 248, 62, 0, // Skip to: 18994 +/* 2874 */ MCD_OPC_Decode, 231, 98, 36, // Opcode: VLSEG7E64FF_V +/* 2878 */ MCD_OPC_FilterValue, 49, 9, 0, 0, // Skip to: 2892 +/* 2883 */ MCD_OPC_CheckPredicate, 16, 234, 62, 0, // Skip to: 18994 +/* 2888 */ MCD_OPC_Decode, 169, 99, 38, // Opcode: VLUXSEG7EI64_V +/* 2892 */ MCD_OPC_FilterValue, 50, 9, 0, 0, // Skip to: 2906 +/* 2897 */ MCD_OPC_CheckPredicate, 14, 220, 62, 0, // Skip to: 18994 +/* 2902 */ MCD_OPC_Decode, 137, 99, 39, // Opcode: VLSSEG7E64_V +/* 2906 */ MCD_OPC_FilterValue, 51, 9, 0, 0, // Skip to: 2920 +/* 2911 */ MCD_OPC_CheckPredicate, 16, 206, 62, 0, // Skip to: 18994 +/* 2916 */ MCD_OPC_Decode, 177, 98, 38, // Opcode: VLOXSEG7EI64_V +/* 2920 */ MCD_OPC_FilterValue, 56, 52, 0, 0, // Skip to: 2977 +/* 2925 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 2928 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 2942 +/* 2933 */ MCD_OPC_CheckPredicate, 14, 184, 62, 0, // Skip to: 18994 +/* 2938 */ MCD_OPC_Decode, 240, 98, 36, // Opcode: VLSEG8E64_V +/* 2942 */ MCD_OPC_FilterValue, 8, 16, 0, 0, // Skip to: 2963 +/* 2947 */ MCD_OPC_CheckPredicate, 14, 170, 62, 0, // Skip to: 18994 +/* 2952 */ MCD_OPC_CheckField, 25, 1, 1, 163, 62, 0, // Skip to: 18994 +/* 2959 */ MCD_OPC_Decode, 140, 98, 42, // Opcode: VL8RE64_V +/* 2963 */ MCD_OPC_FilterValue, 16, 154, 62, 0, // Skip to: 18994 +/* 2968 */ MCD_OPC_CheckPredicate, 14, 149, 62, 0, // Skip to: 18994 +/* 2973 */ MCD_OPC_Decode, 239, 98, 36, // Opcode: VLSEG8E64FF_V +/* 2977 */ MCD_OPC_FilterValue, 57, 9, 0, 0, // Skip to: 2991 +/* 2982 */ MCD_OPC_CheckPredicate, 16, 135, 62, 0, // Skip to: 18994 +/* 2987 */ MCD_OPC_Decode, 173, 99, 38, // Opcode: VLUXSEG8EI64_V +/* 2991 */ MCD_OPC_FilterValue, 58, 9, 0, 0, // Skip to: 3005 +/* 2996 */ MCD_OPC_CheckPredicate, 14, 121, 62, 0, // Skip to: 18994 +/* 3001 */ MCD_OPC_Decode, 141, 99, 39, // Opcode: VLSSEG8E64_V +/* 3005 */ MCD_OPC_FilterValue, 59, 112, 62, 0, // Skip to: 18994 +/* 3010 */ MCD_OPC_CheckPredicate, 16, 107, 62, 0, // Skip to: 18994 +/* 3015 */ MCD_OPC_Decode, 181, 98, 38, // Opcode: VLOXSEG8EI64_V +/* 3019 */ MCD_OPC_FilterValue, 15, 124, 0, 0, // Skip to: 3148 +/* 3024 */ MCD_OPC_ExtractField, 7, 8, // Inst{14-7} ... +/* 3027 */ MCD_OPC_FilterValue, 0, 36, 0, 0, // Skip to: 3068 +/* 3032 */ MCD_OPC_ExtractField, 28, 4, // Inst{31-28} ... +/* 3035 */ MCD_OPC_FilterValue, 0, 11, 0, 0, // Skip to: 3051 +/* 3040 */ MCD_OPC_CheckField, 15, 5, 0, 75, 62, 0, // Skip to: 18994 +/* 3047 */ MCD_OPC_Decode, 138, 93, 46, // Opcode: FENCE +/* 3051 */ MCD_OPC_FilterValue, 8, 66, 62, 0, // Skip to: 18994 +/* 3056 */ MCD_OPC_CheckField, 15, 13, 224, 12, 58, 62, 0, // Skip to: 18994 +/* 3064 */ MCD_OPC_Decode, 140, 93, 0, // Opcode: FENCE_TSO +/* 3068 */ MCD_OPC_FilterValue, 32, 11, 0, 0, // Skip to: 3084 +/* 3073 */ MCD_OPC_CheckField, 15, 17, 0, 42, 62, 0, // Skip to: 18994 +/* 3080 */ MCD_OPC_Decode, 139, 93, 0, // Opcode: FENCE_I +/* 3084 */ MCD_OPC_FilterValue, 64, 33, 62, 0, // Skip to: 18994 +/* 3089 */ MCD_OPC_ExtractField, 20, 12, // Inst{31-20} ... +/* 3092 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 3106 +/* 3097 */ MCD_OPC_CheckPredicate, 17, 20, 62, 0, // Skip to: 18994 +/* 3102 */ MCD_OPC_Decode, 136, 89, 47, // Opcode: CBO_INVAL +/* 3106 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 3120 +/* 3111 */ MCD_OPC_CheckPredicate, 17, 6, 62, 0, // Skip to: 18994 +/* 3116 */ MCD_OPC_Decode, 134, 89, 47, // Opcode: CBO_CLEAN +/* 3120 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 3134 +/* 3125 */ MCD_OPC_CheckPredicate, 17, 248, 61, 0, // Skip to: 18994 +/* 3130 */ MCD_OPC_Decode, 135, 89, 47, // Opcode: CBO_FLUSH +/* 3134 */ MCD_OPC_FilterValue, 4, 239, 61, 0, // Skip to: 18994 +/* 3139 */ MCD_OPC_CheckPredicate, 18, 234, 61, 0, // Skip to: 18994 +/* 3144 */ MCD_OPC_Decode, 137, 89, 47, // Opcode: CBO_ZERO +/* 3148 */ MCD_OPC_FilterValue, 19, 106, 2, 0, // Skip to: 3771 +/* 3153 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 3156 */ MCD_OPC_FilterValue, 0, 4, 0, 0, // Skip to: 3165 +/* 3161 */ MCD_OPC_Decode, 140, 88, 35, // Opcode: ADDI +/* 3165 */ MCD_OPC_FilterValue, 1, 88, 1, 0, // Skip to: 3514 +/* 3170 */ MCD_OPC_ExtractField, 26, 6, // Inst{31-26} ... +/* 3173 */ MCD_OPC_FilterValue, 0, 4, 0, 0, // Skip to: 3182 +/* 3178 */ MCD_OPC_Decode, 188, 95, 48, // Opcode: SLLI +/* 3182 */ MCD_OPC_FilterValue, 2, 16, 0, 0, // Skip to: 3203 +/* 3187 */ MCD_OPC_CheckPredicate, 19, 186, 61, 0, // Skip to: 18994 +/* 3192 */ MCD_OPC_CheckField, 20, 6, 15, 179, 61, 0, // Skip to: 18994 +/* 3199 */ MCD_OPC_Decode, 161, 102, 49, // Opcode: ZIP_RV32 +/* 3203 */ MCD_OPC_FilterValue, 4, 143, 0, 0, // Skip to: 3351 +/* 3208 */ MCD_OPC_ExtractField, 20, 6, // Inst{25-20} ... +/* 3211 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 3225 +/* 3216 */ MCD_OPC_CheckPredicate, 20, 157, 61, 0, // Skip to: 18994 +/* 3221 */ MCD_OPC_Decode, 174, 95, 49, // Opcode: SHA256SUM0 +/* 3225 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 3239 +/* 3230 */ MCD_OPC_CheckPredicate, 20, 143, 61, 0, // Skip to: 18994 +/* 3235 */ MCD_OPC_Decode, 175, 95, 49, // Opcode: SHA256SUM1 +/* 3239 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 3253 +/* 3244 */ MCD_OPC_CheckPredicate, 20, 129, 61, 0, // Skip to: 18994 +/* 3249 */ MCD_OPC_Decode, 172, 95, 49, // Opcode: SHA256SIG0 +/* 3253 */ MCD_OPC_FilterValue, 3, 9, 0, 0, // Skip to: 3267 +/* 3258 */ MCD_OPC_CheckPredicate, 20, 115, 61, 0, // Skip to: 18994 +/* 3263 */ MCD_OPC_Decode, 173, 95, 49, // Opcode: SHA256SIG1 +/* 3267 */ MCD_OPC_FilterValue, 4, 9, 0, 0, // Skip to: 3281 +/* 3272 */ MCD_OPC_CheckPredicate, 21, 101, 61, 0, // Skip to: 18994 +/* 3277 */ MCD_OPC_Decode, 182, 95, 49, // Opcode: SHA512SUM0 +/* 3281 */ MCD_OPC_FilterValue, 5, 9, 0, 0, // Skip to: 3295 +/* 3286 */ MCD_OPC_CheckPredicate, 21, 87, 61, 0, // Skip to: 18994 +/* 3291 */ MCD_OPC_Decode, 184, 95, 49, // Opcode: SHA512SUM1 +/* 3295 */ MCD_OPC_FilterValue, 6, 9, 0, 0, // Skip to: 3309 +/* 3300 */ MCD_OPC_CheckPredicate, 21, 73, 61, 0, // Skip to: 18994 +/* 3305 */ MCD_OPC_Decode, 176, 95, 49, // Opcode: SHA512SIG0 +/* 3309 */ MCD_OPC_FilterValue, 7, 9, 0, 0, // Skip to: 3323 +/* 3314 */ MCD_OPC_CheckPredicate, 21, 59, 61, 0, // Skip to: 18994 +/* 3319 */ MCD_OPC_Decode, 179, 95, 49, // Opcode: SHA512SIG1 +/* 3323 */ MCD_OPC_FilterValue, 8, 9, 0, 0, // Skip to: 3337 +/* 3328 */ MCD_OPC_CheckPredicate, 22, 45, 61, 0, // Skip to: 18994 +/* 3333 */ MCD_OPC_Decode, 196, 95, 49, // Opcode: SM3P0 +/* 3337 */ MCD_OPC_FilterValue, 9, 36, 61, 0, // Skip to: 18994 +/* 3342 */ MCD_OPC_CheckPredicate, 22, 31, 61, 0, // Skip to: 18994 +/* 3347 */ MCD_OPC_Decode, 197, 95, 49, // Opcode: SM3P1 +/* 3351 */ MCD_OPC_FilterValue, 10, 9, 0, 0, // Skip to: 3365 +/* 3356 */ MCD_OPC_CheckPredicate, 23, 17, 61, 0, // Skip to: 18994 +/* 3361 */ MCD_OPC_Decode, 133, 89, 48, // Opcode: BSETI +/* 3365 */ MCD_OPC_FilterValue, 12, 38, 0, 0, // Skip to: 3408 +/* 3370 */ MCD_OPC_ExtractField, 24, 2, // Inst{25-24} ... +/* 3373 */ MCD_OPC_FilterValue, 0, 16, 0, 0, // Skip to: 3394 +/* 3378 */ MCD_OPC_CheckPredicate, 24, 251, 60, 0, // Skip to: 18994 +/* 3383 */ MCD_OPC_CheckField, 20, 4, 0, 244, 60, 0, // Skip to: 18994 +/* 3390 */ MCD_OPC_Decode, 152, 88, 49, // Opcode: AES64IM +/* 3394 */ MCD_OPC_FilterValue, 1, 235, 60, 0, // Skip to: 18994 +/* 3399 */ MCD_OPC_CheckPredicate, 25, 230, 60, 0, // Skip to: 18994 +/* 3404 */ MCD_OPC_Decode, 153, 88, 50, // Opcode: AES64KS1I +/* 3408 */ MCD_OPC_FilterValue, 18, 9, 0, 0, // Skip to: 3422 +/* 3413 */ MCD_OPC_CheckPredicate, 23, 216, 60, 0, // Skip to: 18994 +/* 3418 */ MCD_OPC_Decode, 248, 88, 48, // Opcode: BCLRI +/* 3422 */ MCD_OPC_FilterValue, 24, 73, 0, 0, // Skip to: 3500 +/* 3427 */ MCD_OPC_ExtractField, 20, 6, // Inst{25-20} ... +/* 3430 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 3444 +/* 3435 */ MCD_OPC_CheckPredicate, 26, 194, 60, 0, // Skip to: 18994 +/* 3440 */ MCD_OPC_Decode, 141, 89, 49, // Opcode: CLZ +/* 3444 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 3458 +/* 3449 */ MCD_OPC_CheckPredicate, 26, 180, 60, 0, // Skip to: 18994 +/* 3454 */ MCD_OPC_Decode, 167, 89, 49, // Opcode: CTZ +/* 3458 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 3472 +/* 3463 */ MCD_OPC_CheckPredicate, 26, 166, 60, 0, // Skip to: 18994 +/* 3468 */ MCD_OPC_Decode, 159, 89, 49, // Opcode: CPOP +/* 3472 */ MCD_OPC_FilterValue, 4, 9, 0, 0, // Skip to: 3486 +/* 3477 */ MCD_OPC_CheckPredicate, 26, 152, 60, 0, // Skip to: 18994 +/* 3482 */ MCD_OPC_Decode, 160, 95, 49, // Opcode: SEXT_B +/* 3486 */ MCD_OPC_FilterValue, 5, 143, 60, 0, // Skip to: 18994 +/* 3491 */ MCD_OPC_CheckPredicate, 26, 138, 60, 0, // Skip to: 18994 +/* 3496 */ MCD_OPC_Decode, 161, 95, 49, // Opcode: SEXT_H +/* 3500 */ MCD_OPC_FilterValue, 26, 129, 60, 0, // Skip to: 18994 +/* 3505 */ MCD_OPC_CheckPredicate, 23, 124, 60, 0, // Skip to: 18994 +/* 3510 */ MCD_OPC_Decode, 255, 88, 48, // Opcode: BINVI +/* 3514 */ MCD_OPC_FilterValue, 2, 4, 0, 0, // Skip to: 3523 +/* 3519 */ MCD_OPC_Decode, 193, 95, 35, // Opcode: SLTI +/* 3523 */ MCD_OPC_FilterValue, 3, 4, 0, 0, // Skip to: 3532 +/* 3528 */ MCD_OPC_Decode, 194, 95, 35, // Opcode: SLTIU +/* 3532 */ MCD_OPC_FilterValue, 4, 4, 0, 0, // Skip to: 3541 +/* 3537 */ MCD_OPC_Decode, 156, 102, 35, // Opcode: XORI +/* 3541 */ MCD_OPC_FilterValue, 5, 141, 0, 0, // Skip to: 3687 +/* 3546 */ MCD_OPC_ExtractField, 26, 6, // Inst{31-26} ... +/* 3549 */ MCD_OPC_FilterValue, 0, 4, 0, 0, // Skip to: 3558 +/* 3554 */ MCD_OPC_Decode, 206, 95, 48, // Opcode: SRLI +/* 3558 */ MCD_OPC_FilterValue, 2, 16, 0, 0, // Skip to: 3579 +/* 3563 */ MCD_OPC_CheckPredicate, 19, 66, 60, 0, // Skip to: 18994 +/* 3568 */ MCD_OPC_CheckField, 20, 6, 15, 59, 60, 0, // Skip to: 18994 +/* 3575 */ MCD_OPC_Decode, 205, 96, 49, // Opcode: UNZIP_RV32 +/* 3579 */ MCD_OPC_FilterValue, 10, 16, 0, 0, // Skip to: 3600 +/* 3584 */ MCD_OPC_CheckPredicate, 26, 45, 60, 0, // Skip to: 18994 +/* 3589 */ MCD_OPC_CheckField, 20, 6, 7, 38, 60, 0, // Skip to: 18994 +/* 3596 */ MCD_OPC_Decode, 129, 95, 49, // Opcode: ORC_B +/* 3600 */ MCD_OPC_FilterValue, 16, 4, 0, 0, // Skip to: 3609 +/* 3605 */ MCD_OPC_Decode, 201, 95, 48, // Opcode: SRAI +/* 3609 */ MCD_OPC_FilterValue, 18, 9, 0, 0, // Skip to: 3623 +/* 3614 */ MCD_OPC_CheckPredicate, 23, 15, 60, 0, // Skip to: 18994 +/* 3619 */ MCD_OPC_Decode, 251, 88, 48, // Opcode: BEXTI +/* 3623 */ MCD_OPC_FilterValue, 24, 9, 0, 0, // Skip to: 3637 +/* 3628 */ MCD_OPC_CheckPredicate, 27, 1, 60, 0, // Skip to: 18994 +/* 3633 */ MCD_OPC_Decode, 147, 95, 48, // Opcode: RORI +/* 3637 */ MCD_OPC_FilterValue, 26, 248, 59, 0, // Skip to: 18994 +/* 3642 */ MCD_OPC_ExtractField, 20, 6, // Inst{25-20} ... +/* 3645 */ MCD_OPC_FilterValue, 7, 9, 0, 0, // Skip to: 3659 +/* 3650 */ MCD_OPC_CheckPredicate, 28, 235, 59, 0, // Skip to: 18994 +/* 3655 */ MCD_OPC_Decode, 131, 89, 49, // Opcode: BREV8 +/* 3659 */ MCD_OPC_FilterValue, 24, 9, 0, 0, // Skip to: 3673 +/* 3664 */ MCD_OPC_CheckPredicate, 29, 221, 59, 0, // Skip to: 18994 +/* 3669 */ MCD_OPC_Decode, 142, 95, 49, // Opcode: REV8_RV32 +/* 3673 */ MCD_OPC_FilterValue, 56, 212, 59, 0, // Skip to: 18994 +/* 3678 */ MCD_OPC_CheckPredicate, 30, 207, 59, 0, // Skip to: 18994 +/* 3683 */ MCD_OPC_Decode, 143, 95, 49, // Opcode: REV8_RV64 +/* 3687 */ MCD_OPC_FilterValue, 6, 70, 0, 0, // Skip to: 3762 +/* 3692 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 3695 */ MCD_OPC_FilterValue, 0, 16, 0, 0, // Skip to: 3716 +/* 3700 */ MCD_OPC_CheckPredicate, 31, 53, 0, 0, // Skip to: 3758 +/* 3705 */ MCD_OPC_CheckField, 7, 5, 0, 46, 0, 0, // Skip to: 3758 +/* 3712 */ MCD_OPC_Decode, 135, 95, 51, // Opcode: PREFETCH_I +/* 3716 */ MCD_OPC_FilterValue, 1, 16, 0, 0, // Skip to: 3737 +/* 3721 */ MCD_OPC_CheckPredicate, 31, 32, 0, 0, // Skip to: 3758 +/* 3726 */ MCD_OPC_CheckField, 7, 5, 0, 25, 0, 0, // Skip to: 3758 +/* 3733 */ MCD_OPC_Decode, 136, 95, 51, // Opcode: PREFETCH_R +/* 3737 */ MCD_OPC_FilterValue, 3, 16, 0, 0, // Skip to: 3758 +/* 3742 */ MCD_OPC_CheckPredicate, 31, 11, 0, 0, // Skip to: 3758 +/* 3747 */ MCD_OPC_CheckField, 7, 5, 0, 4, 0, 0, // Skip to: 3758 +/* 3754 */ MCD_OPC_Decode, 137, 95, 51, // Opcode: PREFETCH_W +/* 3758 */ MCD_OPC_Decode, 130, 95, 35, // Opcode: ORI +/* 3762 */ MCD_OPC_FilterValue, 7, 123, 59, 0, // Skip to: 18994 +/* 3767 */ MCD_OPC_Decode, 244, 88, 35, // Opcode: ANDI +/* 3771 */ MCD_OPC_FilterValue, 23, 4, 0, 0, // Skip to: 3780 +/* 3776 */ MCD_OPC_Decode, 246, 88, 52, // Opcode: AUIPC +/* 3780 */ MCD_OPC_FilterValue, 27, 160, 0, 0, // Skip to: 3945 +/* 3785 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 3788 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 3802 +/* 3793 */ MCD_OPC_CheckPredicate, 9, 92, 59, 0, // Skip to: 18994 +/* 3798 */ MCD_OPC_Decode, 141, 88, 35, // Opcode: ADDIW +/* 3802 */ MCD_OPC_FilterValue, 1, 88, 0, 0, // Skip to: 3895 +/* 3807 */ MCD_OPC_ExtractField, 26, 6, // Inst{31-26} ... +/* 3810 */ MCD_OPC_FilterValue, 0, 16, 0, 0, // Skip to: 3831 +/* 3815 */ MCD_OPC_CheckPredicate, 9, 70, 59, 0, // Skip to: 18994 +/* 3820 */ MCD_OPC_CheckField, 25, 1, 0, 63, 59, 0, // Skip to: 18994 +/* 3827 */ MCD_OPC_Decode, 189, 95, 53, // Opcode: SLLIW +/* 3831 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 3845 +/* 3836 */ MCD_OPC_CheckPredicate, 32, 49, 59, 0, // Skip to: 18994 +/* 3841 */ MCD_OPC_Decode, 190, 95, 48, // Opcode: SLLI_UW +/* 3845 */ MCD_OPC_FilterValue, 24, 40, 59, 0, // Skip to: 18994 +/* 3850 */ MCD_OPC_ExtractField, 20, 6, // Inst{25-20} ... +/* 3853 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 3867 +/* 3858 */ MCD_OPC_CheckPredicate, 33, 27, 59, 0, // Skip to: 18994 +/* 3863 */ MCD_OPC_Decode, 142, 89, 49, // Opcode: CLZW +/* 3867 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 3881 +/* 3872 */ MCD_OPC_CheckPredicate, 33, 13, 59, 0, // Skip to: 18994 +/* 3877 */ MCD_OPC_Decode, 168, 89, 49, // Opcode: CTZW +/* 3881 */ MCD_OPC_FilterValue, 2, 4, 59, 0, // Skip to: 18994 +/* 3886 */ MCD_OPC_CheckPredicate, 33, 255, 58, 0, // Skip to: 18994 +/* 3891 */ MCD_OPC_Decode, 160, 89, 49, // Opcode: CPOPW +/* 3895 */ MCD_OPC_FilterValue, 5, 246, 58, 0, // Skip to: 18994 +/* 3900 */ MCD_OPC_ExtractField, 25, 7, // Inst{31-25} ... +/* 3903 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 3917 +/* 3908 */ MCD_OPC_CheckPredicate, 9, 233, 58, 0, // Skip to: 18994 +/* 3913 */ MCD_OPC_Decode, 207, 95, 53, // Opcode: SRLIW +/* 3917 */ MCD_OPC_FilterValue, 32, 9, 0, 0, // Skip to: 3931 +/* 3922 */ MCD_OPC_CheckPredicate, 9, 219, 58, 0, // Skip to: 18994 +/* 3927 */ MCD_OPC_Decode, 202, 95, 53, // Opcode: SRAIW +/* 3931 */ MCD_OPC_FilterValue, 48, 210, 58, 0, // Skip to: 18994 +/* 3936 */ MCD_OPC_CheckPredicate, 30, 205, 58, 0, // Skip to: 18994 +/* 3941 */ MCD_OPC_Decode, 148, 95, 53, // Opcode: RORIW +/* 3945 */ MCD_OPC_FilterValue, 35, 44, 0, 0, // Skip to: 3994 +/* 3950 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 3953 */ MCD_OPC_FilterValue, 0, 4, 0, 0, // Skip to: 3962 +/* 3958 */ MCD_OPC_Decode, 150, 95, 54, // Opcode: SB +/* 3962 */ MCD_OPC_FilterValue, 1, 4, 0, 0, // Skip to: 3971 +/* 3967 */ MCD_OPC_Decode, 165, 95, 54, // Opcode: SH +/* 3971 */ MCD_OPC_FilterValue, 2, 4, 0, 0, // Skip to: 3980 +/* 3976 */ MCD_OPC_Decode, 222, 95, 54, // Opcode: SW +/* 3980 */ MCD_OPC_FilterValue, 3, 161, 58, 0, // Skip to: 18994 +/* 3985 */ MCD_OPC_CheckPredicate, 9, 156, 58, 0, // Skip to: 18994 +/* 3990 */ MCD_OPC_Decode, 159, 95, 54, // Opcode: SD +/* 3994 */ MCD_OPC_FilterValue, 39, 154, 8, 0, // Skip to: 6201 +/* 3999 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 4002 */ MCD_OPC_FilterValue, 0, 104, 2, 0, // Skip to: 4623 +/* 4007 */ MCD_OPC_ExtractField, 26, 6, // Inst{31-26} ... +/* 4010 */ MCD_OPC_FilterValue, 0, 59, 0, 0, // Skip to: 4074 +/* 4015 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 4018 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 4032 +/* 4023 */ MCD_OPC_CheckPredicate, 10, 118, 58, 0, // Skip to: 18994 +/* 4028 */ MCD_OPC_Decode, 196, 100, 36, // Opcode: VSE8_V +/* 4032 */ MCD_OPC_FilterValue, 8, 16, 0, 0, // Skip to: 4053 +/* 4037 */ MCD_OPC_CheckPredicate, 10, 104, 58, 0, // Skip to: 18994 +/* 4042 */ MCD_OPC_CheckField, 25, 1, 1, 97, 58, 0, // Skip to: 18994 +/* 4049 */ MCD_OPC_Decode, 181, 100, 37, // Opcode: VS1R_V +/* 4053 */ MCD_OPC_FilterValue, 11, 88, 58, 0, // Skip to: 18994 +/* 4058 */ MCD_OPC_CheckPredicate, 10, 83, 58, 0, // Skip to: 18994 +/* 4063 */ MCD_OPC_CheckField, 25, 1, 1, 76, 58, 0, // Skip to: 18994 +/* 4070 */ MCD_OPC_Decode, 222, 100, 37, // Opcode: VSM_V +/* 4074 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 4088 +/* 4079 */ MCD_OPC_CheckPredicate, 10, 62, 58, 0, // Skip to: 18994 +/* 4084 */ MCD_OPC_Decode, 208, 101, 38, // Opcode: VSUXEI8_V +/* 4088 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 4102 +/* 4093 */ MCD_OPC_CheckPredicate, 10, 48, 58, 0, // Skip to: 18994 +/* 4098 */ MCD_OPC_Decode, 136, 101, 39, // Opcode: VSSE8_V +/* 4102 */ MCD_OPC_FilterValue, 3, 9, 0, 0, // Skip to: 4116 +/* 4107 */ MCD_OPC_CheckPredicate, 10, 34, 58, 0, // Skip to: 18994 +/* 4112 */ MCD_OPC_Decode, 226, 100, 38, // Opcode: VSOXEI8_V +/* 4116 */ MCD_OPC_FilterValue, 8, 38, 0, 0, // Skip to: 4159 +/* 4121 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 4124 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 4138 +/* 4129 */ MCD_OPC_CheckPredicate, 10, 12, 58, 0, // Skip to: 18994 +/* 4134 */ MCD_OPC_Decode, 140, 101, 36, // Opcode: VSSEG2E8_V +/* 4138 */ MCD_OPC_FilterValue, 8, 3, 58, 0, // Skip to: 18994 +/* 4143 */ MCD_OPC_CheckPredicate, 10, 254, 57, 0, // Skip to: 18994 +/* 4148 */ MCD_OPC_CheckField, 25, 1, 1, 247, 57, 0, // Skip to: 18994 +/* 4155 */ MCD_OPC_Decode, 182, 100, 40, // Opcode: VS2R_V +/* 4159 */ MCD_OPC_FilterValue, 9, 9, 0, 0, // Skip to: 4173 +/* 4164 */ MCD_OPC_CheckPredicate, 10, 233, 57, 0, // Skip to: 18994 +/* 4169 */ MCD_OPC_Decode, 212, 101, 38, // Opcode: VSUXSEG2EI8_V +/* 4173 */ MCD_OPC_FilterValue, 10, 9, 0, 0, // Skip to: 4187 +/* 4178 */ MCD_OPC_CheckPredicate, 10, 219, 57, 0, // Skip to: 18994 +/* 4183 */ MCD_OPC_Decode, 174, 101, 39, // Opcode: VSSSEG2E8_V +/* 4187 */ MCD_OPC_FilterValue, 11, 9, 0, 0, // Skip to: 4201 +/* 4192 */ MCD_OPC_CheckPredicate, 10, 205, 57, 0, // Skip to: 18994 +/* 4197 */ MCD_OPC_Decode, 230, 100, 38, // Opcode: VSOXSEG2EI8_V +/* 4201 */ MCD_OPC_FilterValue, 16, 16, 0, 0, // Skip to: 4222 +/* 4206 */ MCD_OPC_CheckPredicate, 10, 191, 57, 0, // Skip to: 18994 +/* 4211 */ MCD_OPC_CheckField, 20, 5, 0, 184, 57, 0, // Skip to: 18994 +/* 4218 */ MCD_OPC_Decode, 144, 101, 36, // Opcode: VSSEG3E8_V +/* 4222 */ MCD_OPC_FilterValue, 17, 9, 0, 0, // Skip to: 4236 +/* 4227 */ MCD_OPC_CheckPredicate, 10, 170, 57, 0, // Skip to: 18994 +/* 4232 */ MCD_OPC_Decode, 216, 101, 38, // Opcode: VSUXSEG3EI8_V +/* 4236 */ MCD_OPC_FilterValue, 18, 9, 0, 0, // Skip to: 4250 +/* 4241 */ MCD_OPC_CheckPredicate, 10, 156, 57, 0, // Skip to: 18994 +/* 4246 */ MCD_OPC_Decode, 178, 101, 39, // Opcode: VSSSEG3E8_V +/* 4250 */ MCD_OPC_FilterValue, 19, 9, 0, 0, // Skip to: 4264 +/* 4255 */ MCD_OPC_CheckPredicate, 10, 142, 57, 0, // Skip to: 18994 +/* 4260 */ MCD_OPC_Decode, 234, 100, 38, // Opcode: VSOXSEG3EI8_V +/* 4264 */ MCD_OPC_FilterValue, 24, 38, 0, 0, // Skip to: 4307 +/* 4269 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 4272 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 4286 +/* 4277 */ MCD_OPC_CheckPredicate, 10, 120, 57, 0, // Skip to: 18994 +/* 4282 */ MCD_OPC_Decode, 148, 101, 36, // Opcode: VSSEG4E8_V +/* 4286 */ MCD_OPC_FilterValue, 8, 111, 57, 0, // Skip to: 18994 +/* 4291 */ MCD_OPC_CheckPredicate, 10, 106, 57, 0, // Skip to: 18994 +/* 4296 */ MCD_OPC_CheckField, 25, 1, 1, 99, 57, 0, // Skip to: 18994 +/* 4303 */ MCD_OPC_Decode, 183, 100, 41, // Opcode: VS4R_V +/* 4307 */ MCD_OPC_FilterValue, 25, 9, 0, 0, // Skip to: 4321 +/* 4312 */ MCD_OPC_CheckPredicate, 10, 85, 57, 0, // Skip to: 18994 +/* 4317 */ MCD_OPC_Decode, 220, 101, 38, // Opcode: VSUXSEG4EI8_V +/* 4321 */ MCD_OPC_FilterValue, 26, 9, 0, 0, // Skip to: 4335 +/* 4326 */ MCD_OPC_CheckPredicate, 10, 71, 57, 0, // Skip to: 18994 +/* 4331 */ MCD_OPC_Decode, 182, 101, 39, // Opcode: VSSSEG4E8_V +/* 4335 */ MCD_OPC_FilterValue, 27, 9, 0, 0, // Skip to: 4349 +/* 4340 */ MCD_OPC_CheckPredicate, 10, 57, 57, 0, // Skip to: 18994 +/* 4345 */ MCD_OPC_Decode, 238, 100, 38, // Opcode: VSOXSEG4EI8_V +/* 4349 */ MCD_OPC_FilterValue, 32, 16, 0, 0, // Skip to: 4370 +/* 4354 */ MCD_OPC_CheckPredicate, 10, 43, 57, 0, // Skip to: 18994 +/* 4359 */ MCD_OPC_CheckField, 20, 5, 0, 36, 57, 0, // Skip to: 18994 +/* 4366 */ MCD_OPC_Decode, 152, 101, 36, // Opcode: VSSEG5E8_V +/* 4370 */ MCD_OPC_FilterValue, 33, 9, 0, 0, // Skip to: 4384 +/* 4375 */ MCD_OPC_CheckPredicate, 10, 22, 57, 0, // Skip to: 18994 +/* 4380 */ MCD_OPC_Decode, 224, 101, 38, // Opcode: VSUXSEG5EI8_V +/* 4384 */ MCD_OPC_FilterValue, 34, 9, 0, 0, // Skip to: 4398 +/* 4389 */ MCD_OPC_CheckPredicate, 10, 8, 57, 0, // Skip to: 18994 +/* 4394 */ MCD_OPC_Decode, 186, 101, 39, // Opcode: VSSSEG5E8_V +/* 4398 */ MCD_OPC_FilterValue, 35, 9, 0, 0, // Skip to: 4412 +/* 4403 */ MCD_OPC_CheckPredicate, 10, 250, 56, 0, // Skip to: 18994 +/* 4408 */ MCD_OPC_Decode, 242, 100, 38, // Opcode: VSOXSEG5EI8_V +/* 4412 */ MCD_OPC_FilterValue, 40, 16, 0, 0, // Skip to: 4433 +/* 4417 */ MCD_OPC_CheckPredicate, 10, 236, 56, 0, // Skip to: 18994 +/* 4422 */ MCD_OPC_CheckField, 20, 5, 0, 229, 56, 0, // Skip to: 18994 +/* 4429 */ MCD_OPC_Decode, 156, 101, 36, // Opcode: VSSEG6E8_V +/* 4433 */ MCD_OPC_FilterValue, 41, 9, 0, 0, // Skip to: 4447 +/* 4438 */ MCD_OPC_CheckPredicate, 10, 215, 56, 0, // Skip to: 18994 +/* 4443 */ MCD_OPC_Decode, 228, 101, 38, // Opcode: VSUXSEG6EI8_V +/* 4447 */ MCD_OPC_FilterValue, 42, 9, 0, 0, // Skip to: 4461 +/* 4452 */ MCD_OPC_CheckPredicate, 10, 201, 56, 0, // Skip to: 18994 +/* 4457 */ MCD_OPC_Decode, 190, 101, 39, // Opcode: VSSSEG6E8_V +/* 4461 */ MCD_OPC_FilterValue, 43, 9, 0, 0, // Skip to: 4475 +/* 4466 */ MCD_OPC_CheckPredicate, 10, 187, 56, 0, // Skip to: 18994 +/* 4471 */ MCD_OPC_Decode, 246, 100, 38, // Opcode: VSOXSEG6EI8_V +/* 4475 */ MCD_OPC_FilterValue, 48, 16, 0, 0, // Skip to: 4496 +/* 4480 */ MCD_OPC_CheckPredicate, 10, 173, 56, 0, // Skip to: 18994 +/* 4485 */ MCD_OPC_CheckField, 20, 5, 0, 166, 56, 0, // Skip to: 18994 +/* 4492 */ MCD_OPC_Decode, 160, 101, 36, // Opcode: VSSEG7E8_V +/* 4496 */ MCD_OPC_FilterValue, 49, 9, 0, 0, // Skip to: 4510 +/* 4501 */ MCD_OPC_CheckPredicate, 10, 152, 56, 0, // Skip to: 18994 +/* 4506 */ MCD_OPC_Decode, 232, 101, 38, // Opcode: VSUXSEG7EI8_V +/* 4510 */ MCD_OPC_FilterValue, 50, 9, 0, 0, // Skip to: 4524 +/* 4515 */ MCD_OPC_CheckPredicate, 10, 138, 56, 0, // Skip to: 18994 +/* 4520 */ MCD_OPC_Decode, 194, 101, 39, // Opcode: VSSSEG7E8_V +/* 4524 */ MCD_OPC_FilterValue, 51, 9, 0, 0, // Skip to: 4538 +/* 4529 */ MCD_OPC_CheckPredicate, 10, 124, 56, 0, // Skip to: 18994 +/* 4534 */ MCD_OPC_Decode, 250, 100, 38, // Opcode: VSOXSEG7EI8_V +/* 4538 */ MCD_OPC_FilterValue, 56, 38, 0, 0, // Skip to: 4581 +/* 4543 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 4546 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 4560 +/* 4551 */ MCD_OPC_CheckPredicate, 10, 102, 56, 0, // Skip to: 18994 +/* 4556 */ MCD_OPC_Decode, 164, 101, 36, // Opcode: VSSEG8E8_V +/* 4560 */ MCD_OPC_FilterValue, 8, 93, 56, 0, // Skip to: 18994 +/* 4565 */ MCD_OPC_CheckPredicate, 10, 88, 56, 0, // Skip to: 18994 +/* 4570 */ MCD_OPC_CheckField, 25, 1, 1, 81, 56, 0, // Skip to: 18994 +/* 4577 */ MCD_OPC_Decode, 184, 100, 42, // Opcode: VS8R_V +/* 4581 */ MCD_OPC_FilterValue, 57, 9, 0, 0, // Skip to: 4595 +/* 4586 */ MCD_OPC_CheckPredicate, 10, 67, 56, 0, // Skip to: 18994 +/* 4591 */ MCD_OPC_Decode, 236, 101, 38, // Opcode: VSUXSEG8EI8_V +/* 4595 */ MCD_OPC_FilterValue, 58, 9, 0, 0, // Skip to: 4609 +/* 4600 */ MCD_OPC_CheckPredicate, 10, 53, 56, 0, // Skip to: 18994 +/* 4605 */ MCD_OPC_Decode, 198, 101, 39, // Opcode: VSSSEG8E8_V +/* 4609 */ MCD_OPC_FilterValue, 59, 44, 56, 0, // Skip to: 18994 +/* 4614 */ MCD_OPC_CheckPredicate, 10, 39, 56, 0, // Skip to: 18994 +/* 4619 */ MCD_OPC_Decode, 254, 100, 38, // Opcode: VSOXSEG8EI8_V +/* 4623 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 4637 +/* 4628 */ MCD_OPC_CheckPredicate, 11, 25, 56, 0, // Skip to: 18994 +/* 4633 */ MCD_OPC_Decode, 138, 94, 55, // Opcode: FSH +/* 4637 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 4651 +/* 4642 */ MCD_OPC_CheckPredicate, 12, 11, 56, 0, // Skip to: 18994 +/* 4647 */ MCD_OPC_Decode, 153, 94, 56, // Opcode: FSW +/* 4651 */ MCD_OPC_FilterValue, 3, 9, 0, 0, // Skip to: 4665 +/* 4656 */ MCD_OPC_CheckPredicate, 13, 253, 55, 0, // Skip to: 18994 +/* 4661 */ MCD_OPC_Decode, 244, 93, 57, // Opcode: FSD +/* 4665 */ MCD_OPC_FilterValue, 5, 251, 1, 0, // Skip to: 5177 +/* 4670 */ MCD_OPC_ExtractField, 26, 6, // Inst{31-26} ... +/* 4673 */ MCD_OPC_FilterValue, 0, 16, 0, 0, // Skip to: 4694 +/* 4678 */ MCD_OPC_CheckPredicate, 10, 231, 55, 0, // Skip to: 18994 +/* 4683 */ MCD_OPC_CheckField, 20, 5, 0, 224, 55, 0, // Skip to: 18994 +/* 4690 */ MCD_OPC_Decode, 193, 100, 36, // Opcode: VSE16_V +/* 4694 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 4708 +/* 4699 */ MCD_OPC_CheckPredicate, 10, 210, 55, 0, // Skip to: 18994 +/* 4704 */ MCD_OPC_Decode, 205, 101, 38, // Opcode: VSUXEI16_V +/* 4708 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 4722 +/* 4713 */ MCD_OPC_CheckPredicate, 10, 196, 55, 0, // Skip to: 18994 +/* 4718 */ MCD_OPC_Decode, 133, 101, 39, // Opcode: VSSE16_V +/* 4722 */ MCD_OPC_FilterValue, 3, 9, 0, 0, // Skip to: 4736 +/* 4727 */ MCD_OPC_CheckPredicate, 10, 182, 55, 0, // Skip to: 18994 +/* 4732 */ MCD_OPC_Decode, 223, 100, 38, // Opcode: VSOXEI16_V +/* 4736 */ MCD_OPC_FilterValue, 8, 16, 0, 0, // Skip to: 4757 +/* 4741 */ MCD_OPC_CheckPredicate, 10, 168, 55, 0, // Skip to: 18994 +/* 4746 */ MCD_OPC_CheckField, 20, 5, 0, 161, 55, 0, // Skip to: 18994 +/* 4753 */ MCD_OPC_Decode, 137, 101, 36, // Opcode: VSSEG2E16_V +/* 4757 */ MCD_OPC_FilterValue, 9, 9, 0, 0, // Skip to: 4771 +/* 4762 */ MCD_OPC_CheckPredicate, 10, 147, 55, 0, // Skip to: 18994 +/* 4767 */ MCD_OPC_Decode, 209, 101, 38, // Opcode: VSUXSEG2EI16_V +/* 4771 */ MCD_OPC_FilterValue, 10, 9, 0, 0, // Skip to: 4785 +/* 4776 */ MCD_OPC_CheckPredicate, 10, 133, 55, 0, // Skip to: 18994 +/* 4781 */ MCD_OPC_Decode, 171, 101, 39, // Opcode: VSSSEG2E16_V +/* 4785 */ MCD_OPC_FilterValue, 11, 9, 0, 0, // Skip to: 4799 +/* 4790 */ MCD_OPC_CheckPredicate, 10, 119, 55, 0, // Skip to: 18994 +/* 4795 */ MCD_OPC_Decode, 227, 100, 38, // Opcode: VSOXSEG2EI16_V +/* 4799 */ MCD_OPC_FilterValue, 16, 16, 0, 0, // Skip to: 4820 +/* 4804 */ MCD_OPC_CheckPredicate, 10, 105, 55, 0, // Skip to: 18994 +/* 4809 */ MCD_OPC_CheckField, 20, 5, 0, 98, 55, 0, // Skip to: 18994 +/* 4816 */ MCD_OPC_Decode, 141, 101, 36, // Opcode: VSSEG3E16_V +/* 4820 */ MCD_OPC_FilterValue, 17, 9, 0, 0, // Skip to: 4834 +/* 4825 */ MCD_OPC_CheckPredicate, 10, 84, 55, 0, // Skip to: 18994 +/* 4830 */ MCD_OPC_Decode, 213, 101, 38, // Opcode: VSUXSEG3EI16_V +/* 4834 */ MCD_OPC_FilterValue, 18, 9, 0, 0, // Skip to: 4848 +/* 4839 */ MCD_OPC_CheckPredicate, 10, 70, 55, 0, // Skip to: 18994 +/* 4844 */ MCD_OPC_Decode, 175, 101, 39, // Opcode: VSSSEG3E16_V +/* 4848 */ MCD_OPC_FilterValue, 19, 9, 0, 0, // Skip to: 4862 +/* 4853 */ MCD_OPC_CheckPredicate, 10, 56, 55, 0, // Skip to: 18994 +/* 4858 */ MCD_OPC_Decode, 231, 100, 38, // Opcode: VSOXSEG3EI16_V +/* 4862 */ MCD_OPC_FilterValue, 24, 16, 0, 0, // Skip to: 4883 +/* 4867 */ MCD_OPC_CheckPredicate, 10, 42, 55, 0, // Skip to: 18994 +/* 4872 */ MCD_OPC_CheckField, 20, 5, 0, 35, 55, 0, // Skip to: 18994 +/* 4879 */ MCD_OPC_Decode, 145, 101, 36, // Opcode: VSSEG4E16_V +/* 4883 */ MCD_OPC_FilterValue, 25, 9, 0, 0, // Skip to: 4897 +/* 4888 */ MCD_OPC_CheckPredicate, 10, 21, 55, 0, // Skip to: 18994 +/* 4893 */ MCD_OPC_Decode, 217, 101, 38, // Opcode: VSUXSEG4EI16_V +/* 4897 */ MCD_OPC_FilterValue, 26, 9, 0, 0, // Skip to: 4911 +/* 4902 */ MCD_OPC_CheckPredicate, 10, 7, 55, 0, // Skip to: 18994 +/* 4907 */ MCD_OPC_Decode, 179, 101, 39, // Opcode: VSSSEG4E16_V +/* 4911 */ MCD_OPC_FilterValue, 27, 9, 0, 0, // Skip to: 4925 +/* 4916 */ MCD_OPC_CheckPredicate, 10, 249, 54, 0, // Skip to: 18994 +/* 4921 */ MCD_OPC_Decode, 235, 100, 38, // Opcode: VSOXSEG4EI16_V +/* 4925 */ MCD_OPC_FilterValue, 32, 16, 0, 0, // Skip to: 4946 +/* 4930 */ MCD_OPC_CheckPredicate, 10, 235, 54, 0, // Skip to: 18994 +/* 4935 */ MCD_OPC_CheckField, 20, 5, 0, 228, 54, 0, // Skip to: 18994 +/* 4942 */ MCD_OPC_Decode, 149, 101, 36, // Opcode: VSSEG5E16_V +/* 4946 */ MCD_OPC_FilterValue, 33, 9, 0, 0, // Skip to: 4960 +/* 4951 */ MCD_OPC_CheckPredicate, 10, 214, 54, 0, // Skip to: 18994 +/* 4956 */ MCD_OPC_Decode, 221, 101, 38, // Opcode: VSUXSEG5EI16_V +/* 4960 */ MCD_OPC_FilterValue, 34, 9, 0, 0, // Skip to: 4974 +/* 4965 */ MCD_OPC_CheckPredicate, 10, 200, 54, 0, // Skip to: 18994 +/* 4970 */ MCD_OPC_Decode, 183, 101, 39, // Opcode: VSSSEG5E16_V +/* 4974 */ MCD_OPC_FilterValue, 35, 9, 0, 0, // Skip to: 4988 +/* 4979 */ MCD_OPC_CheckPredicate, 10, 186, 54, 0, // Skip to: 18994 +/* 4984 */ MCD_OPC_Decode, 239, 100, 38, // Opcode: VSOXSEG5EI16_V +/* 4988 */ MCD_OPC_FilterValue, 40, 16, 0, 0, // Skip to: 5009 +/* 4993 */ MCD_OPC_CheckPredicate, 10, 172, 54, 0, // Skip to: 18994 +/* 4998 */ MCD_OPC_CheckField, 20, 5, 0, 165, 54, 0, // Skip to: 18994 +/* 5005 */ MCD_OPC_Decode, 153, 101, 36, // Opcode: VSSEG6E16_V +/* 5009 */ MCD_OPC_FilterValue, 41, 9, 0, 0, // Skip to: 5023 +/* 5014 */ MCD_OPC_CheckPredicate, 10, 151, 54, 0, // Skip to: 18994 +/* 5019 */ MCD_OPC_Decode, 225, 101, 38, // Opcode: VSUXSEG6EI16_V +/* 5023 */ MCD_OPC_FilterValue, 42, 9, 0, 0, // Skip to: 5037 +/* 5028 */ MCD_OPC_CheckPredicate, 10, 137, 54, 0, // Skip to: 18994 +/* 5033 */ MCD_OPC_Decode, 187, 101, 39, // Opcode: VSSSEG6E16_V +/* 5037 */ MCD_OPC_FilterValue, 43, 9, 0, 0, // Skip to: 5051 +/* 5042 */ MCD_OPC_CheckPredicate, 10, 123, 54, 0, // Skip to: 18994 +/* 5047 */ MCD_OPC_Decode, 243, 100, 38, // Opcode: VSOXSEG6EI16_V +/* 5051 */ MCD_OPC_FilterValue, 48, 16, 0, 0, // Skip to: 5072 +/* 5056 */ MCD_OPC_CheckPredicate, 10, 109, 54, 0, // Skip to: 18994 +/* 5061 */ MCD_OPC_CheckField, 20, 5, 0, 102, 54, 0, // Skip to: 18994 +/* 5068 */ MCD_OPC_Decode, 157, 101, 36, // Opcode: VSSEG7E16_V +/* 5072 */ MCD_OPC_FilterValue, 49, 9, 0, 0, // Skip to: 5086 +/* 5077 */ MCD_OPC_CheckPredicate, 10, 88, 54, 0, // Skip to: 18994 +/* 5082 */ MCD_OPC_Decode, 229, 101, 38, // Opcode: VSUXSEG7EI16_V +/* 5086 */ MCD_OPC_FilterValue, 50, 9, 0, 0, // Skip to: 5100 +/* 5091 */ MCD_OPC_CheckPredicate, 10, 74, 54, 0, // Skip to: 18994 +/* 5096 */ MCD_OPC_Decode, 191, 101, 39, // Opcode: VSSSEG7E16_V +/* 5100 */ MCD_OPC_FilterValue, 51, 9, 0, 0, // Skip to: 5114 +/* 5105 */ MCD_OPC_CheckPredicate, 10, 60, 54, 0, // Skip to: 18994 +/* 5110 */ MCD_OPC_Decode, 247, 100, 38, // Opcode: VSOXSEG7EI16_V +/* 5114 */ MCD_OPC_FilterValue, 56, 16, 0, 0, // Skip to: 5135 +/* 5119 */ MCD_OPC_CheckPredicate, 10, 46, 54, 0, // Skip to: 18994 +/* 5124 */ MCD_OPC_CheckField, 20, 5, 0, 39, 54, 0, // Skip to: 18994 +/* 5131 */ MCD_OPC_Decode, 161, 101, 36, // Opcode: VSSEG8E16_V +/* 5135 */ MCD_OPC_FilterValue, 57, 9, 0, 0, // Skip to: 5149 +/* 5140 */ MCD_OPC_CheckPredicate, 10, 25, 54, 0, // Skip to: 18994 +/* 5145 */ MCD_OPC_Decode, 233, 101, 38, // Opcode: VSUXSEG8EI16_V +/* 5149 */ MCD_OPC_FilterValue, 58, 9, 0, 0, // Skip to: 5163 +/* 5154 */ MCD_OPC_CheckPredicate, 10, 11, 54, 0, // Skip to: 18994 +/* 5159 */ MCD_OPC_Decode, 195, 101, 39, // Opcode: VSSSEG8E16_V +/* 5163 */ MCD_OPC_FilterValue, 59, 2, 54, 0, // Skip to: 18994 +/* 5168 */ MCD_OPC_CheckPredicate, 10, 253, 53, 0, // Skip to: 18994 +/* 5173 */ MCD_OPC_Decode, 251, 100, 38, // Opcode: VSOXSEG8EI16_V +/* 5177 */ MCD_OPC_FilterValue, 6, 251, 1, 0, // Skip to: 5689 +/* 5182 */ MCD_OPC_ExtractField, 26, 6, // Inst{31-26} ... +/* 5185 */ MCD_OPC_FilterValue, 0, 16, 0, 0, // Skip to: 5206 +/* 5190 */ MCD_OPC_CheckPredicate, 10, 231, 53, 0, // Skip to: 18994 +/* 5195 */ MCD_OPC_CheckField, 20, 5, 0, 224, 53, 0, // Skip to: 18994 +/* 5202 */ MCD_OPC_Decode, 194, 100, 36, // Opcode: VSE32_V +/* 5206 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 5220 +/* 5211 */ MCD_OPC_CheckPredicate, 10, 210, 53, 0, // Skip to: 18994 +/* 5216 */ MCD_OPC_Decode, 206, 101, 38, // Opcode: VSUXEI32_V +/* 5220 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 5234 +/* 5225 */ MCD_OPC_CheckPredicate, 10, 196, 53, 0, // Skip to: 18994 +/* 5230 */ MCD_OPC_Decode, 134, 101, 39, // Opcode: VSSE32_V +/* 5234 */ MCD_OPC_FilterValue, 3, 9, 0, 0, // Skip to: 5248 +/* 5239 */ MCD_OPC_CheckPredicate, 10, 182, 53, 0, // Skip to: 18994 +/* 5244 */ MCD_OPC_Decode, 224, 100, 38, // Opcode: VSOXEI32_V +/* 5248 */ MCD_OPC_FilterValue, 8, 16, 0, 0, // Skip to: 5269 +/* 5253 */ MCD_OPC_CheckPredicate, 10, 168, 53, 0, // Skip to: 18994 +/* 5258 */ MCD_OPC_CheckField, 20, 5, 0, 161, 53, 0, // Skip to: 18994 +/* 5265 */ MCD_OPC_Decode, 138, 101, 36, // Opcode: VSSEG2E32_V +/* 5269 */ MCD_OPC_FilterValue, 9, 9, 0, 0, // Skip to: 5283 +/* 5274 */ MCD_OPC_CheckPredicate, 10, 147, 53, 0, // Skip to: 18994 +/* 5279 */ MCD_OPC_Decode, 210, 101, 38, // Opcode: VSUXSEG2EI32_V +/* 5283 */ MCD_OPC_FilterValue, 10, 9, 0, 0, // Skip to: 5297 +/* 5288 */ MCD_OPC_CheckPredicate, 10, 133, 53, 0, // Skip to: 18994 +/* 5293 */ MCD_OPC_Decode, 172, 101, 39, // Opcode: VSSSEG2E32_V +/* 5297 */ MCD_OPC_FilterValue, 11, 9, 0, 0, // Skip to: 5311 +/* 5302 */ MCD_OPC_CheckPredicate, 10, 119, 53, 0, // Skip to: 18994 +/* 5307 */ MCD_OPC_Decode, 228, 100, 38, // Opcode: VSOXSEG2EI32_V +/* 5311 */ MCD_OPC_FilterValue, 16, 16, 0, 0, // Skip to: 5332 +/* 5316 */ MCD_OPC_CheckPredicate, 10, 105, 53, 0, // Skip to: 18994 +/* 5321 */ MCD_OPC_CheckField, 20, 5, 0, 98, 53, 0, // Skip to: 18994 +/* 5328 */ MCD_OPC_Decode, 142, 101, 36, // Opcode: VSSEG3E32_V +/* 5332 */ MCD_OPC_FilterValue, 17, 9, 0, 0, // Skip to: 5346 +/* 5337 */ MCD_OPC_CheckPredicate, 10, 84, 53, 0, // Skip to: 18994 +/* 5342 */ MCD_OPC_Decode, 214, 101, 38, // Opcode: VSUXSEG3EI32_V +/* 5346 */ MCD_OPC_FilterValue, 18, 9, 0, 0, // Skip to: 5360 +/* 5351 */ MCD_OPC_CheckPredicate, 10, 70, 53, 0, // Skip to: 18994 +/* 5356 */ MCD_OPC_Decode, 176, 101, 39, // Opcode: VSSSEG3E32_V +/* 5360 */ MCD_OPC_FilterValue, 19, 9, 0, 0, // Skip to: 5374 +/* 5365 */ MCD_OPC_CheckPredicate, 10, 56, 53, 0, // Skip to: 18994 +/* 5370 */ MCD_OPC_Decode, 232, 100, 38, // Opcode: VSOXSEG3EI32_V +/* 5374 */ MCD_OPC_FilterValue, 24, 16, 0, 0, // Skip to: 5395 +/* 5379 */ MCD_OPC_CheckPredicate, 10, 42, 53, 0, // Skip to: 18994 +/* 5384 */ MCD_OPC_CheckField, 20, 5, 0, 35, 53, 0, // Skip to: 18994 +/* 5391 */ MCD_OPC_Decode, 146, 101, 36, // Opcode: VSSEG4E32_V +/* 5395 */ MCD_OPC_FilterValue, 25, 9, 0, 0, // Skip to: 5409 +/* 5400 */ MCD_OPC_CheckPredicate, 10, 21, 53, 0, // Skip to: 18994 +/* 5405 */ MCD_OPC_Decode, 218, 101, 38, // Opcode: VSUXSEG4EI32_V +/* 5409 */ MCD_OPC_FilterValue, 26, 9, 0, 0, // Skip to: 5423 +/* 5414 */ MCD_OPC_CheckPredicate, 10, 7, 53, 0, // Skip to: 18994 +/* 5419 */ MCD_OPC_Decode, 180, 101, 39, // Opcode: VSSSEG4E32_V +/* 5423 */ MCD_OPC_FilterValue, 27, 9, 0, 0, // Skip to: 5437 +/* 5428 */ MCD_OPC_CheckPredicate, 10, 249, 52, 0, // Skip to: 18994 +/* 5433 */ MCD_OPC_Decode, 236, 100, 38, // Opcode: VSOXSEG4EI32_V +/* 5437 */ MCD_OPC_FilterValue, 32, 16, 0, 0, // Skip to: 5458 +/* 5442 */ MCD_OPC_CheckPredicate, 10, 235, 52, 0, // Skip to: 18994 +/* 5447 */ MCD_OPC_CheckField, 20, 5, 0, 228, 52, 0, // Skip to: 18994 +/* 5454 */ MCD_OPC_Decode, 150, 101, 36, // Opcode: VSSEG5E32_V +/* 5458 */ MCD_OPC_FilterValue, 33, 9, 0, 0, // Skip to: 5472 +/* 5463 */ MCD_OPC_CheckPredicate, 10, 214, 52, 0, // Skip to: 18994 +/* 5468 */ MCD_OPC_Decode, 222, 101, 38, // Opcode: VSUXSEG5EI32_V +/* 5472 */ MCD_OPC_FilterValue, 34, 9, 0, 0, // Skip to: 5486 +/* 5477 */ MCD_OPC_CheckPredicate, 10, 200, 52, 0, // Skip to: 18994 +/* 5482 */ MCD_OPC_Decode, 184, 101, 39, // Opcode: VSSSEG5E32_V +/* 5486 */ MCD_OPC_FilterValue, 35, 9, 0, 0, // Skip to: 5500 +/* 5491 */ MCD_OPC_CheckPredicate, 10, 186, 52, 0, // Skip to: 18994 +/* 5496 */ MCD_OPC_Decode, 240, 100, 38, // Opcode: VSOXSEG5EI32_V +/* 5500 */ MCD_OPC_FilterValue, 40, 16, 0, 0, // Skip to: 5521 +/* 5505 */ MCD_OPC_CheckPredicate, 10, 172, 52, 0, // Skip to: 18994 +/* 5510 */ MCD_OPC_CheckField, 20, 5, 0, 165, 52, 0, // Skip to: 18994 +/* 5517 */ MCD_OPC_Decode, 154, 101, 36, // Opcode: VSSEG6E32_V +/* 5521 */ MCD_OPC_FilterValue, 41, 9, 0, 0, // Skip to: 5535 +/* 5526 */ MCD_OPC_CheckPredicate, 10, 151, 52, 0, // Skip to: 18994 +/* 5531 */ MCD_OPC_Decode, 226, 101, 38, // Opcode: VSUXSEG6EI32_V +/* 5535 */ MCD_OPC_FilterValue, 42, 9, 0, 0, // Skip to: 5549 +/* 5540 */ MCD_OPC_CheckPredicate, 10, 137, 52, 0, // Skip to: 18994 +/* 5545 */ MCD_OPC_Decode, 188, 101, 39, // Opcode: VSSSEG6E32_V +/* 5549 */ MCD_OPC_FilterValue, 43, 9, 0, 0, // Skip to: 5563 +/* 5554 */ MCD_OPC_CheckPredicate, 10, 123, 52, 0, // Skip to: 18994 +/* 5559 */ MCD_OPC_Decode, 244, 100, 38, // Opcode: VSOXSEG6EI32_V +/* 5563 */ MCD_OPC_FilterValue, 48, 16, 0, 0, // Skip to: 5584 +/* 5568 */ MCD_OPC_CheckPredicate, 10, 109, 52, 0, // Skip to: 18994 +/* 5573 */ MCD_OPC_CheckField, 20, 5, 0, 102, 52, 0, // Skip to: 18994 +/* 5580 */ MCD_OPC_Decode, 158, 101, 36, // Opcode: VSSEG7E32_V +/* 5584 */ MCD_OPC_FilterValue, 49, 9, 0, 0, // Skip to: 5598 +/* 5589 */ MCD_OPC_CheckPredicate, 10, 88, 52, 0, // Skip to: 18994 +/* 5594 */ MCD_OPC_Decode, 230, 101, 38, // Opcode: VSUXSEG7EI32_V +/* 5598 */ MCD_OPC_FilterValue, 50, 9, 0, 0, // Skip to: 5612 +/* 5603 */ MCD_OPC_CheckPredicate, 10, 74, 52, 0, // Skip to: 18994 +/* 5608 */ MCD_OPC_Decode, 192, 101, 39, // Opcode: VSSSEG7E32_V +/* 5612 */ MCD_OPC_FilterValue, 51, 9, 0, 0, // Skip to: 5626 +/* 5617 */ MCD_OPC_CheckPredicate, 10, 60, 52, 0, // Skip to: 18994 +/* 5622 */ MCD_OPC_Decode, 248, 100, 38, // Opcode: VSOXSEG7EI32_V +/* 5626 */ MCD_OPC_FilterValue, 56, 16, 0, 0, // Skip to: 5647 +/* 5631 */ MCD_OPC_CheckPredicate, 10, 46, 52, 0, // Skip to: 18994 +/* 5636 */ MCD_OPC_CheckField, 20, 5, 0, 39, 52, 0, // Skip to: 18994 +/* 5643 */ MCD_OPC_Decode, 162, 101, 36, // Opcode: VSSEG8E32_V +/* 5647 */ MCD_OPC_FilterValue, 57, 9, 0, 0, // Skip to: 5661 +/* 5652 */ MCD_OPC_CheckPredicate, 10, 25, 52, 0, // Skip to: 18994 +/* 5657 */ MCD_OPC_Decode, 234, 101, 38, // Opcode: VSUXSEG8EI32_V +/* 5661 */ MCD_OPC_FilterValue, 58, 9, 0, 0, // Skip to: 5675 +/* 5666 */ MCD_OPC_CheckPredicate, 10, 11, 52, 0, // Skip to: 18994 +/* 5671 */ MCD_OPC_Decode, 196, 101, 39, // Opcode: VSSSEG8E32_V +/* 5675 */ MCD_OPC_FilterValue, 59, 2, 52, 0, // Skip to: 18994 +/* 5680 */ MCD_OPC_CheckPredicate, 10, 253, 51, 0, // Skip to: 18994 +/* 5685 */ MCD_OPC_Decode, 252, 100, 38, // Opcode: VSOXSEG8EI32_V +/* 5689 */ MCD_OPC_FilterValue, 7, 244, 51, 0, // Skip to: 18994 +/* 5694 */ MCD_OPC_ExtractField, 26, 6, // Inst{31-26} ... +/* 5697 */ MCD_OPC_FilterValue, 0, 16, 0, 0, // Skip to: 5718 +/* 5702 */ MCD_OPC_CheckPredicate, 14, 231, 51, 0, // Skip to: 18994 +/* 5707 */ MCD_OPC_CheckField, 20, 5, 0, 224, 51, 0, // Skip to: 18994 +/* 5714 */ MCD_OPC_Decode, 195, 100, 36, // Opcode: VSE64_V +/* 5718 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 5732 +/* 5723 */ MCD_OPC_CheckPredicate, 15, 210, 51, 0, // Skip to: 18994 +/* 5728 */ MCD_OPC_Decode, 207, 101, 38, // Opcode: VSUXEI64_V +/* 5732 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 5746 +/* 5737 */ MCD_OPC_CheckPredicate, 14, 196, 51, 0, // Skip to: 18994 +/* 5742 */ MCD_OPC_Decode, 135, 101, 39, // Opcode: VSSE64_V +/* 5746 */ MCD_OPC_FilterValue, 3, 9, 0, 0, // Skip to: 5760 +/* 5751 */ MCD_OPC_CheckPredicate, 15, 182, 51, 0, // Skip to: 18994 +/* 5756 */ MCD_OPC_Decode, 225, 100, 38, // Opcode: VSOXEI64_V +/* 5760 */ MCD_OPC_FilterValue, 8, 16, 0, 0, // Skip to: 5781 +/* 5765 */ MCD_OPC_CheckPredicate, 14, 168, 51, 0, // Skip to: 18994 +/* 5770 */ MCD_OPC_CheckField, 20, 5, 0, 161, 51, 0, // Skip to: 18994 +/* 5777 */ MCD_OPC_Decode, 139, 101, 36, // Opcode: VSSEG2E64_V +/* 5781 */ MCD_OPC_FilterValue, 9, 9, 0, 0, // Skip to: 5795 +/* 5786 */ MCD_OPC_CheckPredicate, 16, 147, 51, 0, // Skip to: 18994 +/* 5791 */ MCD_OPC_Decode, 211, 101, 38, // Opcode: VSUXSEG2EI64_V +/* 5795 */ MCD_OPC_FilterValue, 10, 9, 0, 0, // Skip to: 5809 +/* 5800 */ MCD_OPC_CheckPredicate, 14, 133, 51, 0, // Skip to: 18994 +/* 5805 */ MCD_OPC_Decode, 173, 101, 39, // Opcode: VSSSEG2E64_V +/* 5809 */ MCD_OPC_FilterValue, 11, 9, 0, 0, // Skip to: 5823 +/* 5814 */ MCD_OPC_CheckPredicate, 16, 119, 51, 0, // Skip to: 18994 +/* 5819 */ MCD_OPC_Decode, 229, 100, 38, // Opcode: VSOXSEG2EI64_V +/* 5823 */ MCD_OPC_FilterValue, 16, 16, 0, 0, // Skip to: 5844 +/* 5828 */ MCD_OPC_CheckPredicate, 14, 105, 51, 0, // Skip to: 18994 +/* 5833 */ MCD_OPC_CheckField, 20, 5, 0, 98, 51, 0, // Skip to: 18994 +/* 5840 */ MCD_OPC_Decode, 143, 101, 36, // Opcode: VSSEG3E64_V +/* 5844 */ MCD_OPC_FilterValue, 17, 9, 0, 0, // Skip to: 5858 +/* 5849 */ MCD_OPC_CheckPredicate, 16, 84, 51, 0, // Skip to: 18994 +/* 5854 */ MCD_OPC_Decode, 215, 101, 38, // Opcode: VSUXSEG3EI64_V +/* 5858 */ MCD_OPC_FilterValue, 18, 9, 0, 0, // Skip to: 5872 +/* 5863 */ MCD_OPC_CheckPredicate, 14, 70, 51, 0, // Skip to: 18994 +/* 5868 */ MCD_OPC_Decode, 177, 101, 39, // Opcode: VSSSEG3E64_V +/* 5872 */ MCD_OPC_FilterValue, 19, 9, 0, 0, // Skip to: 5886 +/* 5877 */ MCD_OPC_CheckPredicate, 16, 56, 51, 0, // Skip to: 18994 +/* 5882 */ MCD_OPC_Decode, 233, 100, 38, // Opcode: VSOXSEG3EI64_V +/* 5886 */ MCD_OPC_FilterValue, 24, 16, 0, 0, // Skip to: 5907 +/* 5891 */ MCD_OPC_CheckPredicate, 14, 42, 51, 0, // Skip to: 18994 +/* 5896 */ MCD_OPC_CheckField, 20, 5, 0, 35, 51, 0, // Skip to: 18994 +/* 5903 */ MCD_OPC_Decode, 147, 101, 36, // Opcode: VSSEG4E64_V +/* 5907 */ MCD_OPC_FilterValue, 25, 9, 0, 0, // Skip to: 5921 +/* 5912 */ MCD_OPC_CheckPredicate, 16, 21, 51, 0, // Skip to: 18994 +/* 5917 */ MCD_OPC_Decode, 219, 101, 38, // Opcode: VSUXSEG4EI64_V +/* 5921 */ MCD_OPC_FilterValue, 26, 9, 0, 0, // Skip to: 5935 +/* 5926 */ MCD_OPC_CheckPredicate, 14, 7, 51, 0, // Skip to: 18994 +/* 5931 */ MCD_OPC_Decode, 181, 101, 39, // Opcode: VSSSEG4E64_V +/* 5935 */ MCD_OPC_FilterValue, 27, 9, 0, 0, // Skip to: 5949 +/* 5940 */ MCD_OPC_CheckPredicate, 16, 249, 50, 0, // Skip to: 18994 +/* 5945 */ MCD_OPC_Decode, 237, 100, 38, // Opcode: VSOXSEG4EI64_V +/* 5949 */ MCD_OPC_FilterValue, 32, 16, 0, 0, // Skip to: 5970 +/* 5954 */ MCD_OPC_CheckPredicate, 14, 235, 50, 0, // Skip to: 18994 +/* 5959 */ MCD_OPC_CheckField, 20, 5, 0, 228, 50, 0, // Skip to: 18994 +/* 5966 */ MCD_OPC_Decode, 151, 101, 36, // Opcode: VSSEG5E64_V +/* 5970 */ MCD_OPC_FilterValue, 33, 9, 0, 0, // Skip to: 5984 +/* 5975 */ MCD_OPC_CheckPredicate, 16, 214, 50, 0, // Skip to: 18994 +/* 5980 */ MCD_OPC_Decode, 223, 101, 38, // Opcode: VSUXSEG5EI64_V +/* 5984 */ MCD_OPC_FilterValue, 34, 9, 0, 0, // Skip to: 5998 +/* 5989 */ MCD_OPC_CheckPredicate, 14, 200, 50, 0, // Skip to: 18994 +/* 5994 */ MCD_OPC_Decode, 185, 101, 39, // Opcode: VSSSEG5E64_V +/* 5998 */ MCD_OPC_FilterValue, 35, 9, 0, 0, // Skip to: 6012 +/* 6003 */ MCD_OPC_CheckPredicate, 16, 186, 50, 0, // Skip to: 18994 +/* 6008 */ MCD_OPC_Decode, 241, 100, 38, // Opcode: VSOXSEG5EI64_V +/* 6012 */ MCD_OPC_FilterValue, 40, 16, 0, 0, // Skip to: 6033 +/* 6017 */ MCD_OPC_CheckPredicate, 14, 172, 50, 0, // Skip to: 18994 +/* 6022 */ MCD_OPC_CheckField, 20, 5, 0, 165, 50, 0, // Skip to: 18994 +/* 6029 */ MCD_OPC_Decode, 155, 101, 36, // Opcode: VSSEG6E64_V +/* 6033 */ MCD_OPC_FilterValue, 41, 9, 0, 0, // Skip to: 6047 +/* 6038 */ MCD_OPC_CheckPredicate, 16, 151, 50, 0, // Skip to: 18994 +/* 6043 */ MCD_OPC_Decode, 227, 101, 38, // Opcode: VSUXSEG6EI64_V +/* 6047 */ MCD_OPC_FilterValue, 42, 9, 0, 0, // Skip to: 6061 +/* 6052 */ MCD_OPC_CheckPredicate, 14, 137, 50, 0, // Skip to: 18994 +/* 6057 */ MCD_OPC_Decode, 189, 101, 39, // Opcode: VSSSEG6E64_V +/* 6061 */ MCD_OPC_FilterValue, 43, 9, 0, 0, // Skip to: 6075 +/* 6066 */ MCD_OPC_CheckPredicate, 16, 123, 50, 0, // Skip to: 18994 +/* 6071 */ MCD_OPC_Decode, 245, 100, 38, // Opcode: VSOXSEG6EI64_V +/* 6075 */ MCD_OPC_FilterValue, 48, 16, 0, 0, // Skip to: 6096 +/* 6080 */ MCD_OPC_CheckPredicate, 14, 109, 50, 0, // Skip to: 18994 +/* 6085 */ MCD_OPC_CheckField, 20, 5, 0, 102, 50, 0, // Skip to: 18994 +/* 6092 */ MCD_OPC_Decode, 159, 101, 36, // Opcode: VSSEG7E64_V +/* 6096 */ MCD_OPC_FilterValue, 49, 9, 0, 0, // Skip to: 6110 +/* 6101 */ MCD_OPC_CheckPredicate, 16, 88, 50, 0, // Skip to: 18994 +/* 6106 */ MCD_OPC_Decode, 231, 101, 38, // Opcode: VSUXSEG7EI64_V +/* 6110 */ MCD_OPC_FilterValue, 50, 9, 0, 0, // Skip to: 6124 +/* 6115 */ MCD_OPC_CheckPredicate, 14, 74, 50, 0, // Skip to: 18994 +/* 6120 */ MCD_OPC_Decode, 193, 101, 39, // Opcode: VSSSEG7E64_V +/* 6124 */ MCD_OPC_FilterValue, 51, 9, 0, 0, // Skip to: 6138 +/* 6129 */ MCD_OPC_CheckPredicate, 16, 60, 50, 0, // Skip to: 18994 +/* 6134 */ MCD_OPC_Decode, 249, 100, 38, // Opcode: VSOXSEG7EI64_V +/* 6138 */ MCD_OPC_FilterValue, 56, 16, 0, 0, // Skip to: 6159 +/* 6143 */ MCD_OPC_CheckPredicate, 14, 46, 50, 0, // Skip to: 18994 +/* 6148 */ MCD_OPC_CheckField, 20, 5, 0, 39, 50, 0, // Skip to: 18994 +/* 6155 */ MCD_OPC_Decode, 163, 101, 36, // Opcode: VSSEG8E64_V +/* 6159 */ MCD_OPC_FilterValue, 57, 9, 0, 0, // Skip to: 6173 +/* 6164 */ MCD_OPC_CheckPredicate, 16, 25, 50, 0, // Skip to: 18994 +/* 6169 */ MCD_OPC_Decode, 235, 101, 38, // Opcode: VSUXSEG8EI64_V +/* 6173 */ MCD_OPC_FilterValue, 58, 9, 0, 0, // Skip to: 6187 +/* 6178 */ MCD_OPC_CheckPredicate, 14, 11, 50, 0, // Skip to: 18994 +/* 6183 */ MCD_OPC_Decode, 197, 101, 39, // Opcode: VSSSEG8E64_V +/* 6187 */ MCD_OPC_FilterValue, 59, 2, 50, 0, // Skip to: 18994 +/* 6192 */ MCD_OPC_CheckPredicate, 16, 253, 49, 0, // Skip to: 18994 +/* 6197 */ MCD_OPC_Decode, 253, 100, 38, // Opcode: VSOXSEG8EI64_V +/* 6201 */ MCD_OPC_FilterValue, 43, 23, 0, 0, // Skip to: 6229 +/* 6206 */ MCD_OPC_CheckPredicate, 34, 239, 49, 0, // Skip to: 18994 +/* 6211 */ MCD_OPC_CheckField, 25, 7, 26, 232, 49, 0, // Skip to: 18994 +/* 6218 */ MCD_OPC_CheckField, 12, 3, 3, 225, 49, 0, // Skip to: 18994 +/* 6225 */ MCD_OPC_Decode, 195, 90, 58, // Opcode: CV_INSERTR +/* 6229 */ MCD_OPC_FilterValue, 47, 195, 7, 0, // Skip to: 8221 +/* 6234 */ MCD_OPC_ExtractField, 25, 7, // Inst{31-25} ... +/* 6237 */ MCD_OPC_FilterValue, 0, 31, 0, 0, // Skip to: 6273 +/* 6242 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 6245 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 6259 +/* 6250 */ MCD_OPC_CheckPredicate, 35, 195, 49, 0, // Skip to: 18994 +/* 6255 */ MCD_OPC_Decode, 159, 88, 59, // Opcode: AMOADD_W +/* 6259 */ MCD_OPC_FilterValue, 3, 186, 49, 0, // Skip to: 18994 +/* 6264 */ MCD_OPC_CheckPredicate, 36, 181, 49, 0, // Skip to: 18994 +/* 6269 */ MCD_OPC_Decode, 155, 88, 59, // Opcode: AMOADD_D +/* 6273 */ MCD_OPC_FilterValue, 1, 31, 0, 0, // Skip to: 6309 +/* 6278 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 6281 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 6295 +/* 6286 */ MCD_OPC_CheckPredicate, 35, 159, 49, 0, // Skip to: 18994 +/* 6291 */ MCD_OPC_Decode, 162, 88, 59, // Opcode: AMOADD_W_RL +/* 6295 */ MCD_OPC_FilterValue, 3, 150, 49, 0, // Skip to: 18994 +/* 6300 */ MCD_OPC_CheckPredicate, 36, 145, 49, 0, // Skip to: 18994 +/* 6305 */ MCD_OPC_Decode, 158, 88, 59, // Opcode: AMOADD_D_RL +/* 6309 */ MCD_OPC_FilterValue, 2, 31, 0, 0, // Skip to: 6345 +/* 6314 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 6317 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 6331 +/* 6322 */ MCD_OPC_CheckPredicate, 35, 123, 49, 0, // Skip to: 18994 +/* 6327 */ MCD_OPC_Decode, 160, 88, 59, // Opcode: AMOADD_W_AQ +/* 6331 */ MCD_OPC_FilterValue, 3, 114, 49, 0, // Skip to: 18994 +/* 6336 */ MCD_OPC_CheckPredicate, 36, 109, 49, 0, // Skip to: 18994 +/* 6341 */ MCD_OPC_Decode, 156, 88, 59, // Opcode: AMOADD_D_AQ +/* 6345 */ MCD_OPC_FilterValue, 3, 31, 0, 0, // Skip to: 6381 +/* 6350 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 6353 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 6367 +/* 6358 */ MCD_OPC_CheckPredicate, 35, 87, 49, 0, // Skip to: 18994 +/* 6363 */ MCD_OPC_Decode, 161, 88, 59, // Opcode: AMOADD_W_AQ_RL +/* 6367 */ MCD_OPC_FilterValue, 3, 78, 49, 0, // Skip to: 18994 +/* 6372 */ MCD_OPC_CheckPredicate, 36, 73, 49, 0, // Skip to: 18994 +/* 6377 */ MCD_OPC_Decode, 157, 88, 59, // Opcode: AMOADD_D_AQ_RL +/* 6381 */ MCD_OPC_FilterValue, 4, 31, 0, 0, // Skip to: 6417 +/* 6386 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 6389 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 6403 +/* 6394 */ MCD_OPC_CheckPredicate, 35, 51, 49, 0, // Skip to: 18994 +/* 6399 */ MCD_OPC_Decode, 231, 88, 59, // Opcode: AMOSWAP_W +/* 6403 */ MCD_OPC_FilterValue, 3, 42, 49, 0, // Skip to: 18994 +/* 6408 */ MCD_OPC_CheckPredicate, 36, 37, 49, 0, // Skip to: 18994 +/* 6413 */ MCD_OPC_Decode, 227, 88, 59, // Opcode: AMOSWAP_D +/* 6417 */ MCD_OPC_FilterValue, 5, 31, 0, 0, // Skip to: 6453 +/* 6422 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 6425 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 6439 +/* 6430 */ MCD_OPC_CheckPredicate, 35, 15, 49, 0, // Skip to: 18994 +/* 6435 */ MCD_OPC_Decode, 234, 88, 59, // Opcode: AMOSWAP_W_RL +/* 6439 */ MCD_OPC_FilterValue, 3, 6, 49, 0, // Skip to: 18994 +/* 6444 */ MCD_OPC_CheckPredicate, 36, 1, 49, 0, // Skip to: 18994 +/* 6449 */ MCD_OPC_Decode, 230, 88, 59, // Opcode: AMOSWAP_D_RL +/* 6453 */ MCD_OPC_FilterValue, 6, 31, 0, 0, // Skip to: 6489 +/* 6458 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 6461 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 6475 +/* 6466 */ MCD_OPC_CheckPredicate, 35, 235, 48, 0, // Skip to: 18994 +/* 6471 */ MCD_OPC_Decode, 232, 88, 59, // Opcode: AMOSWAP_W_AQ +/* 6475 */ MCD_OPC_FilterValue, 3, 226, 48, 0, // Skip to: 18994 +/* 6480 */ MCD_OPC_CheckPredicate, 36, 221, 48, 0, // Skip to: 18994 +/* 6485 */ MCD_OPC_Decode, 228, 88, 59, // Opcode: AMOSWAP_D_AQ +/* 6489 */ MCD_OPC_FilterValue, 7, 31, 0, 0, // Skip to: 6525 +/* 6494 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 6497 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 6511 +/* 6502 */ MCD_OPC_CheckPredicate, 35, 199, 48, 0, // Skip to: 18994 +/* 6507 */ MCD_OPC_Decode, 233, 88, 59, // Opcode: AMOSWAP_W_AQ_RL +/* 6511 */ MCD_OPC_FilterValue, 3, 190, 48, 0, // Skip to: 18994 +/* 6516 */ MCD_OPC_CheckPredicate, 36, 185, 48, 0, // Skip to: 18994 +/* 6521 */ MCD_OPC_Decode, 229, 88, 59, // Opcode: AMOSWAP_D_AQ_RL +/* 6525 */ MCD_OPC_FilterValue, 8, 45, 0, 0, // Skip to: 6575 +/* 6530 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 6533 */ MCD_OPC_FilterValue, 2, 16, 0, 0, // Skip to: 6554 +/* 6538 */ MCD_OPC_CheckPredicate, 35, 163, 48, 0, // Skip to: 18994 +/* 6543 */ MCD_OPC_CheckField, 20, 5, 0, 156, 48, 0, // Skip to: 18994 +/* 6550 */ MCD_OPC_Decode, 199, 94, 49, // Opcode: LR_W +/* 6554 */ MCD_OPC_FilterValue, 3, 147, 48, 0, // Skip to: 18994 +/* 6559 */ MCD_OPC_CheckPredicate, 36, 142, 48, 0, // Skip to: 18994 +/* 6564 */ MCD_OPC_CheckField, 20, 5, 0, 135, 48, 0, // Skip to: 18994 +/* 6571 */ MCD_OPC_Decode, 195, 94, 49, // Opcode: LR_D +/* 6575 */ MCD_OPC_FilterValue, 9, 45, 0, 0, // Skip to: 6625 +/* 6580 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 6583 */ MCD_OPC_FilterValue, 2, 16, 0, 0, // Skip to: 6604 +/* 6588 */ MCD_OPC_CheckPredicate, 35, 113, 48, 0, // Skip to: 18994 +/* 6593 */ MCD_OPC_CheckField, 20, 5, 0, 106, 48, 0, // Skip to: 18994 +/* 6600 */ MCD_OPC_Decode, 202, 94, 49, // Opcode: LR_W_RL +/* 6604 */ MCD_OPC_FilterValue, 3, 97, 48, 0, // Skip to: 18994 +/* 6609 */ MCD_OPC_CheckPredicate, 36, 92, 48, 0, // Skip to: 18994 +/* 6614 */ MCD_OPC_CheckField, 20, 5, 0, 85, 48, 0, // Skip to: 18994 +/* 6621 */ MCD_OPC_Decode, 198, 94, 49, // Opcode: LR_D_RL +/* 6625 */ MCD_OPC_FilterValue, 10, 45, 0, 0, // Skip to: 6675 +/* 6630 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 6633 */ MCD_OPC_FilterValue, 2, 16, 0, 0, // Skip to: 6654 +/* 6638 */ MCD_OPC_CheckPredicate, 35, 63, 48, 0, // Skip to: 18994 +/* 6643 */ MCD_OPC_CheckField, 20, 5, 0, 56, 48, 0, // Skip to: 18994 +/* 6650 */ MCD_OPC_Decode, 200, 94, 49, // Opcode: LR_W_AQ +/* 6654 */ MCD_OPC_FilterValue, 3, 47, 48, 0, // Skip to: 18994 +/* 6659 */ MCD_OPC_CheckPredicate, 36, 42, 48, 0, // Skip to: 18994 +/* 6664 */ MCD_OPC_CheckField, 20, 5, 0, 35, 48, 0, // Skip to: 18994 +/* 6671 */ MCD_OPC_Decode, 196, 94, 49, // Opcode: LR_D_AQ +/* 6675 */ MCD_OPC_FilterValue, 11, 45, 0, 0, // Skip to: 6725 +/* 6680 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 6683 */ MCD_OPC_FilterValue, 2, 16, 0, 0, // Skip to: 6704 +/* 6688 */ MCD_OPC_CheckPredicate, 35, 13, 48, 0, // Skip to: 18994 +/* 6693 */ MCD_OPC_CheckField, 20, 5, 0, 6, 48, 0, // Skip to: 18994 +/* 6700 */ MCD_OPC_Decode, 201, 94, 49, // Opcode: LR_W_AQ_RL +/* 6704 */ MCD_OPC_FilterValue, 3, 253, 47, 0, // Skip to: 18994 +/* 6709 */ MCD_OPC_CheckPredicate, 36, 248, 47, 0, // Skip to: 18994 +/* 6714 */ MCD_OPC_CheckField, 20, 5, 0, 241, 47, 0, // Skip to: 18994 +/* 6721 */ MCD_OPC_Decode, 197, 94, 49, // Opcode: LR_D_AQ_RL +/* 6725 */ MCD_OPC_FilterValue, 12, 31, 0, 0, // Skip to: 6761 +/* 6730 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 6733 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 6747 +/* 6738 */ MCD_OPC_CheckPredicate, 35, 219, 47, 0, // Skip to: 18994 +/* 6743 */ MCD_OPC_Decode, 155, 95, 59, // Opcode: SC_W +/* 6747 */ MCD_OPC_FilterValue, 3, 210, 47, 0, // Skip to: 18994 +/* 6752 */ MCD_OPC_CheckPredicate, 36, 205, 47, 0, // Skip to: 18994 +/* 6757 */ MCD_OPC_Decode, 151, 95, 59, // Opcode: SC_D +/* 6761 */ MCD_OPC_FilterValue, 13, 31, 0, 0, // Skip to: 6797 +/* 6766 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 6769 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 6783 +/* 6774 */ MCD_OPC_CheckPredicate, 35, 183, 47, 0, // Skip to: 18994 +/* 6779 */ MCD_OPC_Decode, 158, 95, 59, // Opcode: SC_W_RL +/* 6783 */ MCD_OPC_FilterValue, 3, 174, 47, 0, // Skip to: 18994 +/* 6788 */ MCD_OPC_CheckPredicate, 36, 169, 47, 0, // Skip to: 18994 +/* 6793 */ MCD_OPC_Decode, 154, 95, 59, // Opcode: SC_D_RL +/* 6797 */ MCD_OPC_FilterValue, 14, 31, 0, 0, // Skip to: 6833 +/* 6802 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 6805 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 6819 +/* 6810 */ MCD_OPC_CheckPredicate, 35, 147, 47, 0, // Skip to: 18994 +/* 6815 */ MCD_OPC_Decode, 156, 95, 59, // Opcode: SC_W_AQ +/* 6819 */ MCD_OPC_FilterValue, 3, 138, 47, 0, // Skip to: 18994 +/* 6824 */ MCD_OPC_CheckPredicate, 36, 133, 47, 0, // Skip to: 18994 +/* 6829 */ MCD_OPC_Decode, 152, 95, 59, // Opcode: SC_D_AQ +/* 6833 */ MCD_OPC_FilterValue, 15, 31, 0, 0, // Skip to: 6869 +/* 6838 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 6841 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 6855 +/* 6846 */ MCD_OPC_CheckPredicate, 35, 111, 47, 0, // Skip to: 18994 +/* 6851 */ MCD_OPC_Decode, 157, 95, 59, // Opcode: SC_W_AQ_RL +/* 6855 */ MCD_OPC_FilterValue, 3, 102, 47, 0, // Skip to: 18994 +/* 6860 */ MCD_OPC_CheckPredicate, 36, 97, 47, 0, // Skip to: 18994 +/* 6865 */ MCD_OPC_Decode, 153, 95, 59, // Opcode: SC_D_AQ_RL +/* 6869 */ MCD_OPC_FilterValue, 16, 31, 0, 0, // Skip to: 6905 +/* 6874 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 6877 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 6891 +/* 6882 */ MCD_OPC_CheckPredicate, 35, 75, 47, 0, // Skip to: 18994 +/* 6887 */ MCD_OPC_Decode, 239, 88, 59, // Opcode: AMOXOR_W +/* 6891 */ MCD_OPC_FilterValue, 3, 66, 47, 0, // Skip to: 18994 +/* 6896 */ MCD_OPC_CheckPredicate, 36, 61, 47, 0, // Skip to: 18994 +/* 6901 */ MCD_OPC_Decode, 235, 88, 59, // Opcode: AMOXOR_D +/* 6905 */ MCD_OPC_FilterValue, 17, 31, 0, 0, // Skip to: 6941 +/* 6910 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 6913 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 6927 +/* 6918 */ MCD_OPC_CheckPredicate, 35, 39, 47, 0, // Skip to: 18994 +/* 6923 */ MCD_OPC_Decode, 242, 88, 59, // Opcode: AMOXOR_W_RL +/* 6927 */ MCD_OPC_FilterValue, 3, 30, 47, 0, // Skip to: 18994 +/* 6932 */ MCD_OPC_CheckPredicate, 36, 25, 47, 0, // Skip to: 18994 +/* 6937 */ MCD_OPC_Decode, 238, 88, 59, // Opcode: AMOXOR_D_RL +/* 6941 */ MCD_OPC_FilterValue, 18, 31, 0, 0, // Skip to: 6977 +/* 6946 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 6949 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 6963 +/* 6954 */ MCD_OPC_CheckPredicate, 35, 3, 47, 0, // Skip to: 18994 +/* 6959 */ MCD_OPC_Decode, 240, 88, 59, // Opcode: AMOXOR_W_AQ +/* 6963 */ MCD_OPC_FilterValue, 3, 250, 46, 0, // Skip to: 18994 +/* 6968 */ MCD_OPC_CheckPredicate, 36, 245, 46, 0, // Skip to: 18994 +/* 6973 */ MCD_OPC_Decode, 236, 88, 59, // Opcode: AMOXOR_D_AQ +/* 6977 */ MCD_OPC_FilterValue, 19, 31, 0, 0, // Skip to: 7013 +/* 6982 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 6985 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 6999 +/* 6990 */ MCD_OPC_CheckPredicate, 35, 223, 46, 0, // Skip to: 18994 +/* 6995 */ MCD_OPC_Decode, 241, 88, 59, // Opcode: AMOXOR_W_AQ_RL +/* 6999 */ MCD_OPC_FilterValue, 3, 214, 46, 0, // Skip to: 18994 +/* 7004 */ MCD_OPC_CheckPredicate, 36, 209, 46, 0, // Skip to: 18994 +/* 7009 */ MCD_OPC_Decode, 237, 88, 59, // Opcode: AMOXOR_D_AQ_RL +/* 7013 */ MCD_OPC_FilterValue, 20, 45, 0, 0, // Skip to: 7063 +/* 7018 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 7021 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 7035 +/* 7026 */ MCD_OPC_CheckPredicate, 37, 187, 46, 0, // Skip to: 18994 +/* 7031 */ MCD_OPC_Decode, 183, 88, 58, // Opcode: AMOCAS_W +/* 7035 */ MCD_OPC_FilterValue, 3, 9, 0, 0, // Skip to: 7049 +/* 7040 */ MCD_OPC_CheckPredicate, 38, 173, 46, 0, // Skip to: 18994 +/* 7045 */ MCD_OPC_Decode, 175, 88, 58, // Opcode: AMOCAS_D_RV64 +/* 7049 */ MCD_OPC_FilterValue, 4, 164, 46, 0, // Skip to: 18994 +/* 7054 */ MCD_OPC_CheckPredicate, 38, 159, 46, 0, // Skip to: 18994 +/* 7059 */ MCD_OPC_Decode, 179, 88, 60, // Opcode: AMOCAS_Q +/* 7063 */ MCD_OPC_FilterValue, 21, 45, 0, 0, // Skip to: 7113 +/* 7068 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 7071 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 7085 +/* 7076 */ MCD_OPC_CheckPredicate, 37, 137, 46, 0, // Skip to: 18994 +/* 7081 */ MCD_OPC_Decode, 186, 88, 58, // Opcode: AMOCAS_W_RL +/* 7085 */ MCD_OPC_FilterValue, 3, 9, 0, 0, // Skip to: 7099 +/* 7090 */ MCD_OPC_CheckPredicate, 38, 123, 46, 0, // Skip to: 18994 +/* 7095 */ MCD_OPC_Decode, 178, 88, 58, // Opcode: AMOCAS_D_RV64_RL +/* 7099 */ MCD_OPC_FilterValue, 4, 114, 46, 0, // Skip to: 18994 +/* 7104 */ MCD_OPC_CheckPredicate, 38, 109, 46, 0, // Skip to: 18994 +/* 7109 */ MCD_OPC_Decode, 182, 88, 60, // Opcode: AMOCAS_Q_RL +/* 7113 */ MCD_OPC_FilterValue, 22, 45, 0, 0, // Skip to: 7163 +/* 7118 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 7121 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 7135 +/* 7126 */ MCD_OPC_CheckPredicate, 37, 87, 46, 0, // Skip to: 18994 +/* 7131 */ MCD_OPC_Decode, 184, 88, 58, // Opcode: AMOCAS_W_AQ +/* 7135 */ MCD_OPC_FilterValue, 3, 9, 0, 0, // Skip to: 7149 +/* 7140 */ MCD_OPC_CheckPredicate, 38, 73, 46, 0, // Skip to: 18994 +/* 7145 */ MCD_OPC_Decode, 176, 88, 58, // Opcode: AMOCAS_D_RV64_AQ +/* 7149 */ MCD_OPC_FilterValue, 4, 64, 46, 0, // Skip to: 18994 +/* 7154 */ MCD_OPC_CheckPredicate, 38, 59, 46, 0, // Skip to: 18994 +/* 7159 */ MCD_OPC_Decode, 180, 88, 60, // Opcode: AMOCAS_Q_AQ +/* 7163 */ MCD_OPC_FilterValue, 23, 45, 0, 0, // Skip to: 7213 +/* 7168 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 7171 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 7185 +/* 7176 */ MCD_OPC_CheckPredicate, 37, 37, 46, 0, // Skip to: 18994 +/* 7181 */ MCD_OPC_Decode, 185, 88, 58, // Opcode: AMOCAS_W_AQ_RL +/* 7185 */ MCD_OPC_FilterValue, 3, 9, 0, 0, // Skip to: 7199 +/* 7190 */ MCD_OPC_CheckPredicate, 38, 23, 46, 0, // Skip to: 18994 +/* 7195 */ MCD_OPC_Decode, 177, 88, 58, // Opcode: AMOCAS_D_RV64_AQ_RL +/* 7199 */ MCD_OPC_FilterValue, 4, 14, 46, 0, // Skip to: 18994 +/* 7204 */ MCD_OPC_CheckPredicate, 38, 9, 46, 0, // Skip to: 18994 +/* 7209 */ MCD_OPC_Decode, 181, 88, 60, // Opcode: AMOCAS_Q_AQ_RL +/* 7213 */ MCD_OPC_FilterValue, 32, 31, 0, 0, // Skip to: 7249 +/* 7218 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 7221 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 7235 +/* 7226 */ MCD_OPC_CheckPredicate, 35, 243, 45, 0, // Skip to: 18994 +/* 7231 */ MCD_OPC_Decode, 223, 88, 59, // Opcode: AMOOR_W +/* 7235 */ MCD_OPC_FilterValue, 3, 234, 45, 0, // Skip to: 18994 +/* 7240 */ MCD_OPC_CheckPredicate, 36, 229, 45, 0, // Skip to: 18994 +/* 7245 */ MCD_OPC_Decode, 219, 88, 59, // Opcode: AMOOR_D +/* 7249 */ MCD_OPC_FilterValue, 33, 31, 0, 0, // Skip to: 7285 +/* 7254 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 7257 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 7271 +/* 7262 */ MCD_OPC_CheckPredicate, 35, 207, 45, 0, // Skip to: 18994 +/* 7267 */ MCD_OPC_Decode, 226, 88, 59, // Opcode: AMOOR_W_RL +/* 7271 */ MCD_OPC_FilterValue, 3, 198, 45, 0, // Skip to: 18994 +/* 7276 */ MCD_OPC_CheckPredicate, 36, 193, 45, 0, // Skip to: 18994 +/* 7281 */ MCD_OPC_Decode, 222, 88, 59, // Opcode: AMOOR_D_RL +/* 7285 */ MCD_OPC_FilterValue, 34, 31, 0, 0, // Skip to: 7321 +/* 7290 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 7293 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 7307 +/* 7298 */ MCD_OPC_CheckPredicate, 35, 171, 45, 0, // Skip to: 18994 +/* 7303 */ MCD_OPC_Decode, 224, 88, 59, // Opcode: AMOOR_W_AQ +/* 7307 */ MCD_OPC_FilterValue, 3, 162, 45, 0, // Skip to: 18994 +/* 7312 */ MCD_OPC_CheckPredicate, 36, 157, 45, 0, // Skip to: 18994 +/* 7317 */ MCD_OPC_Decode, 220, 88, 59, // Opcode: AMOOR_D_AQ +/* 7321 */ MCD_OPC_FilterValue, 35, 31, 0, 0, // Skip to: 7357 +/* 7326 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 7329 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 7343 +/* 7334 */ MCD_OPC_CheckPredicate, 35, 135, 45, 0, // Skip to: 18994 +/* 7339 */ MCD_OPC_Decode, 225, 88, 59, // Opcode: AMOOR_W_AQ_RL +/* 7343 */ MCD_OPC_FilterValue, 3, 126, 45, 0, // Skip to: 18994 +/* 7348 */ MCD_OPC_CheckPredicate, 36, 121, 45, 0, // Skip to: 18994 +/* 7353 */ MCD_OPC_Decode, 221, 88, 59, // Opcode: AMOOR_D_AQ_RL +/* 7357 */ MCD_OPC_FilterValue, 36, 31, 0, 0, // Skip to: 7393 +/* 7362 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 7365 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 7379 +/* 7370 */ MCD_OPC_CheckPredicate, 39, 99, 45, 0, // Skip to: 18994 +/* 7375 */ MCD_OPC_Decode, 213, 95, 59, // Opcode: SSAMOSWAP_W +/* 7379 */ MCD_OPC_FilterValue, 3, 90, 45, 0, // Skip to: 18994 +/* 7384 */ MCD_OPC_CheckPredicate, 40, 85, 45, 0, // Skip to: 18994 +/* 7389 */ MCD_OPC_Decode, 209, 95, 59, // Opcode: SSAMOSWAP_D +/* 7393 */ MCD_OPC_FilterValue, 37, 31, 0, 0, // Skip to: 7429 +/* 7398 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 7401 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 7415 +/* 7406 */ MCD_OPC_CheckPredicate, 39, 63, 45, 0, // Skip to: 18994 +/* 7411 */ MCD_OPC_Decode, 216, 95, 59, // Opcode: SSAMOSWAP_W_RL +/* 7415 */ MCD_OPC_FilterValue, 3, 54, 45, 0, // Skip to: 18994 +/* 7420 */ MCD_OPC_CheckPredicate, 40, 49, 45, 0, // Skip to: 18994 +/* 7425 */ MCD_OPC_Decode, 212, 95, 59, // Opcode: SSAMOSWAP_D_RL +/* 7429 */ MCD_OPC_FilterValue, 38, 31, 0, 0, // Skip to: 7465 +/* 7434 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 7437 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 7451 +/* 7442 */ MCD_OPC_CheckPredicate, 39, 27, 45, 0, // Skip to: 18994 +/* 7447 */ MCD_OPC_Decode, 214, 95, 59, // Opcode: SSAMOSWAP_W_AQ +/* 7451 */ MCD_OPC_FilterValue, 3, 18, 45, 0, // Skip to: 18994 +/* 7456 */ MCD_OPC_CheckPredicate, 40, 13, 45, 0, // Skip to: 18994 +/* 7461 */ MCD_OPC_Decode, 210, 95, 59, // Opcode: SSAMOSWAP_D_AQ +/* 7465 */ MCD_OPC_FilterValue, 39, 31, 0, 0, // Skip to: 7501 +/* 7470 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 7473 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 7487 +/* 7478 */ MCD_OPC_CheckPredicate, 39, 247, 44, 0, // Skip to: 18994 +/* 7483 */ MCD_OPC_Decode, 215, 95, 59, // Opcode: SSAMOSWAP_W_AQ_RL +/* 7487 */ MCD_OPC_FilterValue, 3, 238, 44, 0, // Skip to: 18994 +/* 7492 */ MCD_OPC_CheckPredicate, 40, 233, 44, 0, // Skip to: 18994 +/* 7497 */ MCD_OPC_Decode, 211, 95, 59, // Opcode: SSAMOSWAP_D_AQ_RL +/* 7501 */ MCD_OPC_FilterValue, 48, 31, 0, 0, // Skip to: 7537 +/* 7506 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 7509 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 7523 +/* 7514 */ MCD_OPC_CheckPredicate, 35, 211, 44, 0, // Skip to: 18994 +/* 7519 */ MCD_OPC_Decode, 167, 88, 59, // Opcode: AMOAND_W +/* 7523 */ MCD_OPC_FilterValue, 3, 202, 44, 0, // Skip to: 18994 +/* 7528 */ MCD_OPC_CheckPredicate, 36, 197, 44, 0, // Skip to: 18994 +/* 7533 */ MCD_OPC_Decode, 163, 88, 59, // Opcode: AMOAND_D +/* 7537 */ MCD_OPC_FilterValue, 49, 31, 0, 0, // Skip to: 7573 +/* 7542 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 7545 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 7559 +/* 7550 */ MCD_OPC_CheckPredicate, 35, 175, 44, 0, // Skip to: 18994 +/* 7555 */ MCD_OPC_Decode, 170, 88, 59, // Opcode: AMOAND_W_RL +/* 7559 */ MCD_OPC_FilterValue, 3, 166, 44, 0, // Skip to: 18994 +/* 7564 */ MCD_OPC_CheckPredicate, 36, 161, 44, 0, // Skip to: 18994 +/* 7569 */ MCD_OPC_Decode, 166, 88, 59, // Opcode: AMOAND_D_RL +/* 7573 */ MCD_OPC_FilterValue, 50, 31, 0, 0, // Skip to: 7609 +/* 7578 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 7581 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 7595 +/* 7586 */ MCD_OPC_CheckPredicate, 35, 139, 44, 0, // Skip to: 18994 +/* 7591 */ MCD_OPC_Decode, 168, 88, 59, // Opcode: AMOAND_W_AQ +/* 7595 */ MCD_OPC_FilterValue, 3, 130, 44, 0, // Skip to: 18994 +/* 7600 */ MCD_OPC_CheckPredicate, 36, 125, 44, 0, // Skip to: 18994 +/* 7605 */ MCD_OPC_Decode, 164, 88, 59, // Opcode: AMOAND_D_AQ +/* 7609 */ MCD_OPC_FilterValue, 51, 31, 0, 0, // Skip to: 7645 +/* 7614 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 7617 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 7631 +/* 7622 */ MCD_OPC_CheckPredicate, 35, 103, 44, 0, // Skip to: 18994 +/* 7627 */ MCD_OPC_Decode, 169, 88, 59, // Opcode: AMOAND_W_AQ_RL +/* 7631 */ MCD_OPC_FilterValue, 3, 94, 44, 0, // Skip to: 18994 +/* 7636 */ MCD_OPC_CheckPredicate, 36, 89, 44, 0, // Skip to: 18994 +/* 7641 */ MCD_OPC_Decode, 165, 88, 59, // Opcode: AMOAND_D_AQ_RL +/* 7645 */ MCD_OPC_FilterValue, 64, 31, 0, 0, // Skip to: 7681 +/* 7650 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 7653 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 7667 +/* 7658 */ MCD_OPC_CheckPredicate, 35, 67, 44, 0, // Skip to: 18994 +/* 7663 */ MCD_OPC_Decode, 215, 88, 59, // Opcode: AMOMIN_W +/* 7667 */ MCD_OPC_FilterValue, 3, 58, 44, 0, // Skip to: 18994 +/* 7672 */ MCD_OPC_CheckPredicate, 36, 53, 44, 0, // Skip to: 18994 +/* 7677 */ MCD_OPC_Decode, 211, 88, 59, // Opcode: AMOMIN_D +/* 7681 */ MCD_OPC_FilterValue, 65, 31, 0, 0, // Skip to: 7717 +/* 7686 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 7689 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 7703 +/* 7694 */ MCD_OPC_CheckPredicate, 35, 31, 44, 0, // Skip to: 18994 +/* 7699 */ MCD_OPC_Decode, 218, 88, 59, // Opcode: AMOMIN_W_RL +/* 7703 */ MCD_OPC_FilterValue, 3, 22, 44, 0, // Skip to: 18994 +/* 7708 */ MCD_OPC_CheckPredicate, 36, 17, 44, 0, // Skip to: 18994 +/* 7713 */ MCD_OPC_Decode, 214, 88, 59, // Opcode: AMOMIN_D_RL +/* 7717 */ MCD_OPC_FilterValue, 66, 31, 0, 0, // Skip to: 7753 +/* 7722 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 7725 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 7739 +/* 7730 */ MCD_OPC_CheckPredicate, 35, 251, 43, 0, // Skip to: 18994 +/* 7735 */ MCD_OPC_Decode, 216, 88, 59, // Opcode: AMOMIN_W_AQ +/* 7739 */ MCD_OPC_FilterValue, 3, 242, 43, 0, // Skip to: 18994 +/* 7744 */ MCD_OPC_CheckPredicate, 36, 237, 43, 0, // Skip to: 18994 +/* 7749 */ MCD_OPC_Decode, 212, 88, 59, // Opcode: AMOMIN_D_AQ +/* 7753 */ MCD_OPC_FilterValue, 67, 31, 0, 0, // Skip to: 7789 +/* 7758 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 7761 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 7775 +/* 7766 */ MCD_OPC_CheckPredicate, 35, 215, 43, 0, // Skip to: 18994 +/* 7771 */ MCD_OPC_Decode, 217, 88, 59, // Opcode: AMOMIN_W_AQ_RL +/* 7775 */ MCD_OPC_FilterValue, 3, 206, 43, 0, // Skip to: 18994 +/* 7780 */ MCD_OPC_CheckPredicate, 36, 201, 43, 0, // Skip to: 18994 +/* 7785 */ MCD_OPC_Decode, 213, 88, 59, // Opcode: AMOMIN_D_AQ_RL +/* 7789 */ MCD_OPC_FilterValue, 80, 31, 0, 0, // Skip to: 7825 +/* 7794 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 7797 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 7811 +/* 7802 */ MCD_OPC_CheckPredicate, 35, 179, 43, 0, // Skip to: 18994 +/* 7807 */ MCD_OPC_Decode, 199, 88, 59, // Opcode: AMOMAX_W +/* 7811 */ MCD_OPC_FilterValue, 3, 170, 43, 0, // Skip to: 18994 +/* 7816 */ MCD_OPC_CheckPredicate, 36, 165, 43, 0, // Skip to: 18994 +/* 7821 */ MCD_OPC_Decode, 195, 88, 59, // Opcode: AMOMAX_D +/* 7825 */ MCD_OPC_FilterValue, 81, 31, 0, 0, // Skip to: 7861 +/* 7830 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 7833 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 7847 +/* 7838 */ MCD_OPC_CheckPredicate, 35, 143, 43, 0, // Skip to: 18994 +/* 7843 */ MCD_OPC_Decode, 202, 88, 59, // Opcode: AMOMAX_W_RL +/* 7847 */ MCD_OPC_FilterValue, 3, 134, 43, 0, // Skip to: 18994 +/* 7852 */ MCD_OPC_CheckPredicate, 36, 129, 43, 0, // Skip to: 18994 +/* 7857 */ MCD_OPC_Decode, 198, 88, 59, // Opcode: AMOMAX_D_RL +/* 7861 */ MCD_OPC_FilterValue, 82, 31, 0, 0, // Skip to: 7897 +/* 7866 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 7869 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 7883 +/* 7874 */ MCD_OPC_CheckPredicate, 35, 107, 43, 0, // Skip to: 18994 +/* 7879 */ MCD_OPC_Decode, 200, 88, 59, // Opcode: AMOMAX_W_AQ +/* 7883 */ MCD_OPC_FilterValue, 3, 98, 43, 0, // Skip to: 18994 +/* 7888 */ MCD_OPC_CheckPredicate, 36, 93, 43, 0, // Skip to: 18994 +/* 7893 */ MCD_OPC_Decode, 196, 88, 59, // Opcode: AMOMAX_D_AQ +/* 7897 */ MCD_OPC_FilterValue, 83, 31, 0, 0, // Skip to: 7933 +/* 7902 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 7905 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 7919 +/* 7910 */ MCD_OPC_CheckPredicate, 35, 71, 43, 0, // Skip to: 18994 +/* 7915 */ MCD_OPC_Decode, 201, 88, 59, // Opcode: AMOMAX_W_AQ_RL +/* 7919 */ MCD_OPC_FilterValue, 3, 62, 43, 0, // Skip to: 18994 +/* 7924 */ MCD_OPC_CheckPredicate, 36, 57, 43, 0, // Skip to: 18994 +/* 7929 */ MCD_OPC_Decode, 197, 88, 59, // Opcode: AMOMAX_D_AQ_RL +/* 7933 */ MCD_OPC_FilterValue, 96, 31, 0, 0, // Skip to: 7969 +/* 7938 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 7941 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 7955 +/* 7946 */ MCD_OPC_CheckPredicate, 35, 35, 43, 0, // Skip to: 18994 +/* 7951 */ MCD_OPC_Decode, 207, 88, 59, // Opcode: AMOMINU_W +/* 7955 */ MCD_OPC_FilterValue, 3, 26, 43, 0, // Skip to: 18994 +/* 7960 */ MCD_OPC_CheckPredicate, 36, 21, 43, 0, // Skip to: 18994 +/* 7965 */ MCD_OPC_Decode, 203, 88, 59, // Opcode: AMOMINU_D +/* 7969 */ MCD_OPC_FilterValue, 97, 31, 0, 0, // Skip to: 8005 +/* 7974 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 7977 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 7991 +/* 7982 */ MCD_OPC_CheckPredicate, 35, 255, 42, 0, // Skip to: 18994 +/* 7987 */ MCD_OPC_Decode, 210, 88, 59, // Opcode: AMOMINU_W_RL +/* 7991 */ MCD_OPC_FilterValue, 3, 246, 42, 0, // Skip to: 18994 +/* 7996 */ MCD_OPC_CheckPredicate, 36, 241, 42, 0, // Skip to: 18994 +/* 8001 */ MCD_OPC_Decode, 206, 88, 59, // Opcode: AMOMINU_D_RL +/* 8005 */ MCD_OPC_FilterValue, 98, 31, 0, 0, // Skip to: 8041 +/* 8010 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 8013 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 8027 +/* 8018 */ MCD_OPC_CheckPredicate, 35, 219, 42, 0, // Skip to: 18994 +/* 8023 */ MCD_OPC_Decode, 208, 88, 59, // Opcode: AMOMINU_W_AQ +/* 8027 */ MCD_OPC_FilterValue, 3, 210, 42, 0, // Skip to: 18994 +/* 8032 */ MCD_OPC_CheckPredicate, 36, 205, 42, 0, // Skip to: 18994 +/* 8037 */ MCD_OPC_Decode, 204, 88, 59, // Opcode: AMOMINU_D_AQ +/* 8041 */ MCD_OPC_FilterValue, 99, 31, 0, 0, // Skip to: 8077 +/* 8046 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 8049 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 8063 +/* 8054 */ MCD_OPC_CheckPredicate, 35, 183, 42, 0, // Skip to: 18994 +/* 8059 */ MCD_OPC_Decode, 209, 88, 59, // Opcode: AMOMINU_W_AQ_RL +/* 8063 */ MCD_OPC_FilterValue, 3, 174, 42, 0, // Skip to: 18994 +/* 8068 */ MCD_OPC_CheckPredicate, 36, 169, 42, 0, // Skip to: 18994 +/* 8073 */ MCD_OPC_Decode, 205, 88, 59, // Opcode: AMOMINU_D_AQ_RL +/* 8077 */ MCD_OPC_FilterValue, 112, 31, 0, 0, // Skip to: 8113 +/* 8082 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 8085 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 8099 +/* 8090 */ MCD_OPC_CheckPredicate, 35, 147, 42, 0, // Skip to: 18994 +/* 8095 */ MCD_OPC_Decode, 191, 88, 59, // Opcode: AMOMAXU_W +/* 8099 */ MCD_OPC_FilterValue, 3, 138, 42, 0, // Skip to: 18994 +/* 8104 */ MCD_OPC_CheckPredicate, 36, 133, 42, 0, // Skip to: 18994 +/* 8109 */ MCD_OPC_Decode, 187, 88, 59, // Opcode: AMOMAXU_D +/* 8113 */ MCD_OPC_FilterValue, 113, 31, 0, 0, // Skip to: 8149 +/* 8118 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 8121 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 8135 +/* 8126 */ MCD_OPC_CheckPredicate, 35, 111, 42, 0, // Skip to: 18994 +/* 8131 */ MCD_OPC_Decode, 194, 88, 59, // Opcode: AMOMAXU_W_RL +/* 8135 */ MCD_OPC_FilterValue, 3, 102, 42, 0, // Skip to: 18994 +/* 8140 */ MCD_OPC_CheckPredicate, 36, 97, 42, 0, // Skip to: 18994 +/* 8145 */ MCD_OPC_Decode, 190, 88, 59, // Opcode: AMOMAXU_D_RL +/* 8149 */ MCD_OPC_FilterValue, 114, 31, 0, 0, // Skip to: 8185 +/* 8154 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 8157 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 8171 +/* 8162 */ MCD_OPC_CheckPredicate, 35, 75, 42, 0, // Skip to: 18994 +/* 8167 */ MCD_OPC_Decode, 192, 88, 59, // Opcode: AMOMAXU_W_AQ +/* 8171 */ MCD_OPC_FilterValue, 3, 66, 42, 0, // Skip to: 18994 +/* 8176 */ MCD_OPC_CheckPredicate, 36, 61, 42, 0, // Skip to: 18994 +/* 8181 */ MCD_OPC_Decode, 188, 88, 59, // Opcode: AMOMAXU_D_AQ +/* 8185 */ MCD_OPC_FilterValue, 115, 52, 42, 0, // Skip to: 18994 +/* 8190 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 8193 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 8207 +/* 8198 */ MCD_OPC_CheckPredicate, 35, 39, 42, 0, // Skip to: 18994 +/* 8203 */ MCD_OPC_Decode, 193, 88, 59, // Opcode: AMOMAXU_W_AQ_RL +/* 8207 */ MCD_OPC_FilterValue, 3, 30, 42, 0, // Skip to: 18994 +/* 8212 */ MCD_OPC_CheckPredicate, 36, 25, 42, 0, // Skip to: 18994 +/* 8217 */ MCD_OPC_Decode, 189, 88, 59, // Opcode: AMOMAXU_D_AQ_RL +/* 8221 */ MCD_OPC_FilterValue, 51, 41, 5, 0, // Skip to: 9547 +/* 8226 */ MCD_OPC_ExtractField, 25, 5, // Inst{29-25} ... +/* 8229 */ MCD_OPC_FilterValue, 0, 196, 0, 0, // Skip to: 8430 +/* 8234 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 8237 */ MCD_OPC_FilterValue, 0, 21, 0, 0, // Skip to: 8263 +/* 8242 */ MCD_OPC_ExtractField, 30, 2, // Inst{31-30} ... +/* 8245 */ MCD_OPC_FilterValue, 0, 4, 0, 0, // Skip to: 8254 +/* 8250 */ MCD_OPC_Decode, 139, 88, 59, // Opcode: ADD +/* 8254 */ MCD_OPC_FilterValue, 1, 239, 41, 0, // Skip to: 18994 +/* 8259 */ MCD_OPC_Decode, 220, 95, 59, // Opcode: SUB +/* 8263 */ MCD_OPC_FilterValue, 1, 11, 0, 0, // Skip to: 8279 +/* 8268 */ MCD_OPC_CheckField, 30, 2, 0, 223, 41, 0, // Skip to: 18994 +/* 8275 */ MCD_OPC_Decode, 187, 95, 59, // Opcode: SLL +/* 8279 */ MCD_OPC_FilterValue, 2, 11, 0, 0, // Skip to: 8295 +/* 8284 */ MCD_OPC_CheckField, 30, 2, 0, 207, 41, 0, // Skip to: 18994 +/* 8291 */ MCD_OPC_Decode, 192, 95, 59, // Opcode: SLT +/* 8295 */ MCD_OPC_FilterValue, 3, 11, 0, 0, // Skip to: 8311 +/* 8300 */ MCD_OPC_CheckField, 30, 2, 0, 191, 41, 0, // Skip to: 18994 +/* 8307 */ MCD_OPC_Decode, 195, 95, 59, // Opcode: SLTU +/* 8311 */ MCD_OPC_FilterValue, 4, 26, 0, 0, // Skip to: 8342 +/* 8316 */ MCD_OPC_ExtractField, 30, 2, // Inst{31-30} ... +/* 8319 */ MCD_OPC_FilterValue, 0, 4, 0, 0, // Skip to: 8328 +/* 8324 */ MCD_OPC_Decode, 155, 102, 59, // Opcode: XOR +/* 8328 */ MCD_OPC_FilterValue, 1, 165, 41, 0, // Skip to: 18994 +/* 8333 */ MCD_OPC_CheckPredicate, 27, 160, 41, 0, // Skip to: 18994 +/* 8338 */ MCD_OPC_Decode, 154, 102, 59, // Opcode: XNOR +/* 8342 */ MCD_OPC_FilterValue, 5, 21, 0, 0, // Skip to: 8368 +/* 8347 */ MCD_OPC_ExtractField, 30, 2, // Inst{31-30} ... +/* 8350 */ MCD_OPC_FilterValue, 0, 4, 0, 0, // Skip to: 8359 +/* 8355 */ MCD_OPC_Decode, 205, 95, 59, // Opcode: SRL +/* 8359 */ MCD_OPC_FilterValue, 1, 134, 41, 0, // Skip to: 18994 +/* 8364 */ MCD_OPC_Decode, 200, 95, 59, // Opcode: SRA +/* 8368 */ MCD_OPC_FilterValue, 6, 26, 0, 0, // Skip to: 8399 +/* 8373 */ MCD_OPC_ExtractField, 30, 2, // Inst{31-30} ... +/* 8376 */ MCD_OPC_FilterValue, 0, 4, 0, 0, // Skip to: 8385 +/* 8381 */ MCD_OPC_Decode, 128, 95, 59, // Opcode: OR +/* 8385 */ MCD_OPC_FilterValue, 1, 108, 41, 0, // Skip to: 18994 +/* 8390 */ MCD_OPC_CheckPredicate, 27, 103, 41, 0, // Skip to: 18994 +/* 8395 */ MCD_OPC_Decode, 131, 95, 59, // Opcode: ORN +/* 8399 */ MCD_OPC_FilterValue, 7, 94, 41, 0, // Skip to: 18994 +/* 8404 */ MCD_OPC_ExtractField, 30, 2, // Inst{31-30} ... +/* 8407 */ MCD_OPC_FilterValue, 0, 4, 0, 0, // Skip to: 8416 +/* 8412 */ MCD_OPC_Decode, 243, 88, 59, // Opcode: AND +/* 8416 */ MCD_OPC_FilterValue, 1, 77, 41, 0, // Skip to: 18994 +/* 8421 */ MCD_OPC_CheckPredicate, 27, 72, 41, 0, // Skip to: 18994 +/* 8426 */ MCD_OPC_Decode, 245, 88, 59, // Opcode: ANDN +/* 8430 */ MCD_OPC_FilterValue, 1, 171, 0, 0, // Skip to: 8606 +/* 8435 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 8438 */ MCD_OPC_FilterValue, 0, 16, 0, 0, // Skip to: 8459 +/* 8443 */ MCD_OPC_CheckPredicate, 41, 50, 41, 0, // Skip to: 18994 +/* 8448 */ MCD_OPC_CheckField, 30, 2, 0, 43, 41, 0, // Skip to: 18994 +/* 8455 */ MCD_OPC_Decode, 251, 94, 59, // Opcode: MUL +/* 8459 */ MCD_OPC_FilterValue, 1, 16, 0, 0, // Skip to: 8480 +/* 8464 */ MCD_OPC_CheckPredicate, 41, 29, 41, 0, // Skip to: 18994 +/* 8469 */ MCD_OPC_CheckField, 30, 2, 0, 22, 41, 0, // Skip to: 18994 +/* 8476 */ MCD_OPC_Decode, 252, 94, 59, // Opcode: MULH +/* 8480 */ MCD_OPC_FilterValue, 2, 16, 0, 0, // Skip to: 8501 +/* 8485 */ MCD_OPC_CheckPredicate, 41, 8, 41, 0, // Skip to: 18994 +/* 8490 */ MCD_OPC_CheckField, 30, 2, 0, 1, 41, 0, // Skip to: 18994 +/* 8497 */ MCD_OPC_Decode, 253, 94, 59, // Opcode: MULHSU +/* 8501 */ MCD_OPC_FilterValue, 3, 16, 0, 0, // Skip to: 8522 +/* 8506 */ MCD_OPC_CheckPredicate, 41, 243, 40, 0, // Skip to: 18994 +/* 8511 */ MCD_OPC_CheckField, 30, 2, 0, 236, 40, 0, // Skip to: 18994 +/* 8518 */ MCD_OPC_Decode, 254, 94, 59, // Opcode: MULHU +/* 8522 */ MCD_OPC_FilterValue, 4, 16, 0, 0, // Skip to: 8543 +/* 8527 */ MCD_OPC_CheckPredicate, 42, 222, 40, 0, // Skip to: 18994 +/* 8532 */ MCD_OPC_CheckField, 30, 2, 0, 215, 40, 0, // Skip to: 18994 +/* 8539 */ MCD_OPC_Decode, 167, 92, 59, // Opcode: DIV +/* 8543 */ MCD_OPC_FilterValue, 5, 16, 0, 0, // Skip to: 8564 +/* 8548 */ MCD_OPC_CheckPredicate, 42, 201, 40, 0, // Skip to: 18994 +/* 8553 */ MCD_OPC_CheckField, 30, 2, 0, 194, 40, 0, // Skip to: 18994 +/* 8560 */ MCD_OPC_Decode, 168, 92, 59, // Opcode: DIVU +/* 8564 */ MCD_OPC_FilterValue, 6, 16, 0, 0, // Skip to: 8585 +/* 8569 */ MCD_OPC_CheckPredicate, 42, 180, 40, 0, // Skip to: 18994 +/* 8574 */ MCD_OPC_CheckField, 30, 2, 0, 173, 40, 0, // Skip to: 18994 +/* 8581 */ MCD_OPC_Decode, 138, 95, 59, // Opcode: REM +/* 8585 */ MCD_OPC_FilterValue, 7, 164, 40, 0, // Skip to: 18994 +/* 8590 */ MCD_OPC_CheckPredicate, 42, 159, 40, 0, // Skip to: 18994 +/* 8595 */ MCD_OPC_CheckField, 30, 2, 0, 152, 40, 0, // Skip to: 18994 +/* 8602 */ MCD_OPC_Decode, 139, 95, 59, // Opcode: REMU +/* 8606 */ MCD_OPC_FilterValue, 4, 104, 0, 0, // Skip to: 8715 +/* 8611 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 8614 */ MCD_OPC_FilterValue, 1, 16, 0, 0, // Skip to: 8635 +/* 8619 */ MCD_OPC_CheckPredicate, 23, 130, 40, 0, // Skip to: 18994 +/* 8624 */ MCD_OPC_CheckField, 30, 2, 1, 123, 40, 0, // Skip to: 18994 +/* 8631 */ MCD_OPC_Decode, 247, 88, 59, // Opcode: BCLR +/* 8635 */ MCD_OPC_FilterValue, 4, 33, 0, 0, // Skip to: 8673 +/* 8640 */ MCD_OPC_ExtractField, 30, 2, // Inst{31-30} ... +/* 8643 */ MCD_OPC_FilterValue, 0, 106, 40, 0, // Skip to: 18994 +/* 8648 */ MCD_OPC_CheckPredicate, 43, 11, 0, 0, // Skip to: 8664 +/* 8653 */ MCD_OPC_CheckField, 20, 5, 0, 4, 0, 0, // Skip to: 8664 +/* 8660 */ MCD_OPC_Decode, 159, 102, 49, // Opcode: ZEXT_H_RV32 +/* 8664 */ MCD_OPC_CheckPredicate, 28, 85, 40, 0, // Skip to: 18994 +/* 8669 */ MCD_OPC_Decode, 132, 95, 59, // Opcode: PACK +/* 8673 */ MCD_OPC_FilterValue, 5, 16, 0, 0, // Skip to: 8694 +/* 8678 */ MCD_OPC_CheckPredicate, 23, 71, 40, 0, // Skip to: 18994 +/* 8683 */ MCD_OPC_CheckField, 30, 2, 1, 64, 40, 0, // Skip to: 18994 +/* 8690 */ MCD_OPC_Decode, 250, 88, 59, // Opcode: BEXT +/* 8694 */ MCD_OPC_FilterValue, 7, 55, 40, 0, // Skip to: 18994 +/* 8699 */ MCD_OPC_CheckPredicate, 28, 50, 40, 0, // Skip to: 18994 +/* 8704 */ MCD_OPC_CheckField, 30, 2, 0, 43, 40, 0, // Skip to: 18994 +/* 8711 */ MCD_OPC_Decode, 133, 95, 59, // Opcode: PACKH +/* 8715 */ MCD_OPC_FilterValue, 5, 150, 0, 0, // Skip to: 8870 +/* 8720 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 8723 */ MCD_OPC_FilterValue, 1, 16, 0, 0, // Skip to: 8744 +/* 8728 */ MCD_OPC_CheckPredicate, 44, 21, 40, 0, // Skip to: 18994 +/* 8733 */ MCD_OPC_CheckField, 30, 2, 0, 14, 40, 0, // Skip to: 18994 +/* 8740 */ MCD_OPC_Decode, 138, 89, 59, // Opcode: CLMUL +/* 8744 */ MCD_OPC_FilterValue, 2, 16, 0, 0, // Skip to: 8765 +/* 8749 */ MCD_OPC_CheckPredicate, 45, 0, 40, 0, // Skip to: 18994 +/* 8754 */ MCD_OPC_CheckField, 30, 2, 0, 249, 39, 0, // Skip to: 18994 +/* 8761 */ MCD_OPC_Decode, 140, 89, 59, // Opcode: CLMULR +/* 8765 */ MCD_OPC_FilterValue, 3, 16, 0, 0, // Skip to: 8786 +/* 8770 */ MCD_OPC_CheckPredicate, 44, 235, 39, 0, // Skip to: 18994 +/* 8775 */ MCD_OPC_CheckField, 30, 2, 0, 228, 39, 0, // Skip to: 18994 +/* 8782 */ MCD_OPC_Decode, 139, 89, 59, // Opcode: CLMULH +/* 8786 */ MCD_OPC_FilterValue, 4, 16, 0, 0, // Skip to: 8807 +/* 8791 */ MCD_OPC_CheckPredicate, 26, 214, 39, 0, // Skip to: 18994 +/* 8796 */ MCD_OPC_CheckField, 30, 2, 0, 207, 39, 0, // Skip to: 18994 +/* 8803 */ MCD_OPC_Decode, 208, 94, 59, // Opcode: MIN +/* 8807 */ MCD_OPC_FilterValue, 5, 16, 0, 0, // Skip to: 8828 +/* 8812 */ MCD_OPC_CheckPredicate, 26, 193, 39, 0, // Skip to: 18994 +/* 8817 */ MCD_OPC_CheckField, 30, 2, 0, 186, 39, 0, // Skip to: 18994 +/* 8824 */ MCD_OPC_Decode, 209, 94, 59, // Opcode: MINU +/* 8828 */ MCD_OPC_FilterValue, 6, 16, 0, 0, // Skip to: 8849 +/* 8833 */ MCD_OPC_CheckPredicate, 26, 172, 39, 0, // Skip to: 18994 +/* 8838 */ MCD_OPC_CheckField, 30, 2, 0, 165, 39, 0, // Skip to: 18994 +/* 8845 */ MCD_OPC_Decode, 206, 94, 59, // Opcode: MAX +/* 8849 */ MCD_OPC_FilterValue, 7, 156, 39, 0, // Skip to: 18994 +/* 8854 */ MCD_OPC_CheckPredicate, 26, 151, 39, 0, // Skip to: 18994 +/* 8859 */ MCD_OPC_CheckField, 30, 2, 0, 144, 39, 0, // Skip to: 18994 +/* 8866 */ MCD_OPC_Decode, 207, 94, 59, // Opcode: MAXU +/* 8870 */ MCD_OPC_FilterValue, 7, 45, 0, 0, // Skip to: 8920 +/* 8875 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 8878 */ MCD_OPC_FilterValue, 5, 16, 0, 0, // Skip to: 8899 +/* 8883 */ MCD_OPC_CheckPredicate, 46, 122, 39, 0, // Skip to: 18994 +/* 8888 */ MCD_OPC_CheckField, 30, 2, 0, 115, 39, 0, // Skip to: 18994 +/* 8895 */ MCD_OPC_Decode, 225, 91, 59, // Opcode: CZERO_EQZ +/* 8899 */ MCD_OPC_FilterValue, 7, 106, 39, 0, // Skip to: 18994 +/* 8904 */ MCD_OPC_CheckPredicate, 46, 101, 39, 0, // Skip to: 18994 +/* 8909 */ MCD_OPC_CheckField, 30, 2, 0, 94, 39, 0, // Skip to: 18994 +/* 8916 */ MCD_OPC_Decode, 226, 91, 59, // Opcode: CZERO_NEZ +/* 8920 */ MCD_OPC_FilterValue, 8, 23, 0, 0, // Skip to: 8948 +/* 8925 */ MCD_OPC_CheckPredicate, 47, 80, 39, 0, // Skip to: 18994 +/* 8930 */ MCD_OPC_CheckField, 30, 2, 1, 73, 39, 0, // Skip to: 18994 +/* 8937 */ MCD_OPC_CheckField, 12, 3, 0, 66, 39, 0, // Skip to: 18994 +/* 8944 */ MCD_OPC_Decode, 183, 95, 59, // Opcode: SHA512SUM0R +/* 8948 */ MCD_OPC_FilterValue, 9, 23, 0, 0, // Skip to: 8976 +/* 8953 */ MCD_OPC_CheckPredicate, 47, 52, 39, 0, // Skip to: 18994 +/* 8958 */ MCD_OPC_CheckField, 30, 2, 1, 45, 39, 0, // Skip to: 18994 +/* 8965 */ MCD_OPC_CheckField, 12, 3, 0, 38, 39, 0, // Skip to: 18994 +/* 8972 */ MCD_OPC_Decode, 185, 95, 59, // Opcode: SHA512SUM1R +/* 8976 */ MCD_OPC_FilterValue, 10, 23, 0, 0, // Skip to: 9004 +/* 8981 */ MCD_OPC_CheckPredicate, 47, 24, 39, 0, // Skip to: 18994 +/* 8986 */ MCD_OPC_CheckField, 30, 2, 1, 17, 39, 0, // Skip to: 18994 +/* 8993 */ MCD_OPC_CheckField, 12, 3, 0, 10, 39, 0, // Skip to: 18994 +/* 9000 */ MCD_OPC_Decode, 178, 95, 59, // Opcode: SHA512SIG0L +/* 9004 */ MCD_OPC_FilterValue, 11, 23, 0, 0, // Skip to: 9032 +/* 9009 */ MCD_OPC_CheckPredicate, 47, 252, 38, 0, // Skip to: 18994 +/* 9014 */ MCD_OPC_CheckField, 30, 2, 1, 245, 38, 0, // Skip to: 18994 +/* 9021 */ MCD_OPC_CheckField, 12, 3, 0, 238, 38, 0, // Skip to: 18994 +/* 9028 */ MCD_OPC_Decode, 181, 95, 59, // Opcode: SHA512SIG1L +/* 9032 */ MCD_OPC_FilterValue, 14, 23, 0, 0, // Skip to: 9060 +/* 9037 */ MCD_OPC_CheckPredicate, 47, 224, 38, 0, // Skip to: 18994 +/* 9042 */ MCD_OPC_CheckField, 30, 2, 1, 217, 38, 0, // Skip to: 18994 +/* 9049 */ MCD_OPC_CheckField, 12, 3, 0, 210, 38, 0, // Skip to: 18994 +/* 9056 */ MCD_OPC_Decode, 177, 95, 59, // Opcode: SHA512SIG0H +/* 9060 */ MCD_OPC_FilterValue, 15, 23, 0, 0, // Skip to: 9088 +/* 9065 */ MCD_OPC_CheckPredicate, 47, 196, 38, 0, // Skip to: 18994 +/* 9070 */ MCD_OPC_CheckField, 30, 2, 1, 189, 38, 0, // Skip to: 18994 +/* 9077 */ MCD_OPC_CheckField, 12, 3, 0, 182, 38, 0, // Skip to: 18994 +/* 9084 */ MCD_OPC_Decode, 180, 95, 59, // Opcode: SHA512SIG1H +/* 9088 */ MCD_OPC_FilterValue, 16, 108, 0, 0, // Skip to: 9201 +/* 9093 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 9096 */ MCD_OPC_FilterValue, 1, 16, 0, 0, // Skip to: 9117 +/* 9101 */ MCD_OPC_CheckPredicate, 27, 160, 38, 0, // Skip to: 18994 +/* 9106 */ MCD_OPC_CheckField, 30, 2, 1, 153, 38, 0, // Skip to: 18994 +/* 9113 */ MCD_OPC_Decode, 144, 95, 59, // Opcode: ROL +/* 9117 */ MCD_OPC_FilterValue, 2, 16, 0, 0, // Skip to: 9138 +/* 9122 */ MCD_OPC_CheckPredicate, 48, 139, 38, 0, // Skip to: 18994 +/* 9127 */ MCD_OPC_CheckField, 30, 2, 0, 132, 38, 0, // Skip to: 18994 +/* 9134 */ MCD_OPC_Decode, 166, 95, 59, // Opcode: SH1ADD +/* 9138 */ MCD_OPC_FilterValue, 4, 16, 0, 0, // Skip to: 9159 +/* 9143 */ MCD_OPC_CheckPredicate, 48, 118, 38, 0, // Skip to: 18994 +/* 9148 */ MCD_OPC_CheckField, 30, 2, 0, 111, 38, 0, // Skip to: 18994 +/* 9155 */ MCD_OPC_Decode, 168, 95, 59, // Opcode: SH2ADD +/* 9159 */ MCD_OPC_FilterValue, 5, 16, 0, 0, // Skip to: 9180 +/* 9164 */ MCD_OPC_CheckPredicate, 27, 97, 38, 0, // Skip to: 18994 +/* 9169 */ MCD_OPC_CheckField, 30, 2, 1, 90, 38, 0, // Skip to: 18994 +/* 9176 */ MCD_OPC_Decode, 146, 95, 59, // Opcode: ROR +/* 9180 */ MCD_OPC_FilterValue, 6, 81, 38, 0, // Skip to: 18994 +/* 9185 */ MCD_OPC_CheckPredicate, 48, 76, 38, 0, // Skip to: 18994 +/* 9190 */ MCD_OPC_CheckField, 30, 2, 0, 69, 38, 0, // Skip to: 18994 +/* 9197 */ MCD_OPC_Decode, 170, 95, 59, // Opcode: SH3ADD +/* 9201 */ MCD_OPC_FilterValue, 17, 16, 0, 0, // Skip to: 9222 +/* 9206 */ MCD_OPC_CheckPredicate, 49, 55, 38, 0, // Skip to: 18994 +/* 9211 */ MCD_OPC_CheckField, 12, 3, 0, 48, 38, 0, // Skip to: 18994 +/* 9218 */ MCD_OPC_Decode, 146, 88, 61, // Opcode: AES32ESI +/* 9222 */ MCD_OPC_FilterValue, 19, 16, 0, 0, // Skip to: 9243 +/* 9227 */ MCD_OPC_CheckPredicate, 49, 34, 38, 0, // Skip to: 18994 +/* 9232 */ MCD_OPC_CheckField, 12, 3, 0, 27, 38, 0, // Skip to: 18994 +/* 9239 */ MCD_OPC_Decode, 147, 88, 61, // Opcode: AES32ESMI +/* 9243 */ MCD_OPC_FilterValue, 20, 81, 0, 0, // Skip to: 9329 +/* 9248 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 9251 */ MCD_OPC_FilterValue, 1, 31, 0, 0, // Skip to: 9287 +/* 9256 */ MCD_OPC_ExtractField, 30, 2, // Inst{31-30} ... +/* 9259 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 9273 +/* 9264 */ MCD_OPC_CheckPredicate, 23, 253, 37, 0, // Skip to: 18994 +/* 9269 */ MCD_OPC_Decode, 132, 89, 59, // Opcode: BSET +/* 9273 */ MCD_OPC_FilterValue, 1, 244, 37, 0, // Skip to: 18994 +/* 9278 */ MCD_OPC_CheckPredicate, 23, 239, 37, 0, // Skip to: 18994 +/* 9283 */ MCD_OPC_Decode, 254, 88, 59, // Opcode: BINV +/* 9287 */ MCD_OPC_FilterValue, 2, 16, 0, 0, // Skip to: 9308 +/* 9292 */ MCD_OPC_CheckPredicate, 50, 225, 37, 0, // Skip to: 18994 +/* 9297 */ MCD_OPC_CheckField, 30, 2, 0, 218, 37, 0, // Skip to: 18994 +/* 9304 */ MCD_OPC_Decode, 157, 102, 59, // Opcode: XPERM4 +/* 9308 */ MCD_OPC_FilterValue, 4, 209, 37, 0, // Skip to: 18994 +/* 9313 */ MCD_OPC_CheckPredicate, 50, 204, 37, 0, // Skip to: 18994 +/* 9318 */ MCD_OPC_CheckField, 30, 2, 0, 197, 37, 0, // Skip to: 18994 +/* 9325 */ MCD_OPC_Decode, 158, 102, 59, // Opcode: XPERM8 +/* 9329 */ MCD_OPC_FilterValue, 21, 16, 0, 0, // Skip to: 9350 +/* 9334 */ MCD_OPC_CheckPredicate, 51, 183, 37, 0, // Skip to: 18994 +/* 9339 */ MCD_OPC_CheckField, 12, 3, 0, 176, 37, 0, // Skip to: 18994 +/* 9346 */ MCD_OPC_Decode, 144, 88, 61, // Opcode: AES32DSI +/* 9350 */ MCD_OPC_FilterValue, 23, 16, 0, 0, // Skip to: 9371 +/* 9355 */ MCD_OPC_CheckPredicate, 51, 162, 37, 0, // Skip to: 18994 +/* 9360 */ MCD_OPC_CheckField, 12, 3, 0, 155, 37, 0, // Skip to: 18994 +/* 9367 */ MCD_OPC_Decode, 145, 88, 61, // Opcode: AES32DSMI +/* 9371 */ MCD_OPC_FilterValue, 24, 16, 0, 0, // Skip to: 9392 +/* 9376 */ MCD_OPC_CheckPredicate, 52, 141, 37, 0, // Skip to: 18994 +/* 9381 */ MCD_OPC_CheckField, 12, 3, 0, 134, 37, 0, // Skip to: 18994 +/* 9388 */ MCD_OPC_Decode, 198, 95, 61, // Opcode: SM4ED +/* 9392 */ MCD_OPC_FilterValue, 25, 23, 0, 0, // Skip to: 9420 +/* 9397 */ MCD_OPC_CheckPredicate, 53, 120, 37, 0, // Skip to: 18994 +/* 9402 */ MCD_OPC_CheckField, 30, 2, 0, 113, 37, 0, // Skip to: 18994 +/* 9409 */ MCD_OPC_CheckField, 12, 3, 0, 106, 37, 0, // Skip to: 18994 +/* 9416 */ MCD_OPC_Decode, 150, 88, 59, // Opcode: AES64ES +/* 9420 */ MCD_OPC_FilterValue, 26, 16, 0, 0, // Skip to: 9441 +/* 9425 */ MCD_OPC_CheckPredicate, 52, 92, 37, 0, // Skip to: 18994 +/* 9430 */ MCD_OPC_CheckField, 12, 3, 0, 85, 37, 0, // Skip to: 18994 +/* 9437 */ MCD_OPC_Decode, 199, 95, 61, // Opcode: SM4KS +/* 9441 */ MCD_OPC_FilterValue, 27, 23, 0, 0, // Skip to: 9469 +/* 9446 */ MCD_OPC_CheckPredicate, 53, 71, 37, 0, // Skip to: 18994 +/* 9451 */ MCD_OPC_CheckField, 30, 2, 0, 64, 37, 0, // Skip to: 18994 +/* 9458 */ MCD_OPC_CheckField, 12, 3, 0, 57, 37, 0, // Skip to: 18994 +/* 9465 */ MCD_OPC_Decode, 151, 88, 59, // Opcode: AES64ESM +/* 9469 */ MCD_OPC_FilterValue, 29, 23, 0, 0, // Skip to: 9497 +/* 9474 */ MCD_OPC_CheckPredicate, 24, 43, 37, 0, // Skip to: 18994 +/* 9479 */ MCD_OPC_CheckField, 30, 2, 0, 36, 37, 0, // Skip to: 18994 +/* 9486 */ MCD_OPC_CheckField, 12, 3, 0, 29, 37, 0, // Skip to: 18994 +/* 9493 */ MCD_OPC_Decode, 148, 88, 59, // Opcode: AES64DS +/* 9497 */ MCD_OPC_FilterValue, 31, 20, 37, 0, // Skip to: 18994 +/* 9502 */ MCD_OPC_ExtractField, 30, 2, // Inst{31-30} ... +/* 9505 */ MCD_OPC_FilterValue, 0, 16, 0, 0, // Skip to: 9526 +/* 9510 */ MCD_OPC_CheckPredicate, 24, 7, 37, 0, // Skip to: 18994 +/* 9515 */ MCD_OPC_CheckField, 12, 3, 0, 0, 37, 0, // Skip to: 18994 +/* 9522 */ MCD_OPC_Decode, 149, 88, 59, // Opcode: AES64DSM +/* 9526 */ MCD_OPC_FilterValue, 1, 247, 36, 0, // Skip to: 18994 +/* 9531 */ MCD_OPC_CheckPredicate, 25, 242, 36, 0, // Skip to: 18994 +/* 9536 */ MCD_OPC_CheckField, 12, 3, 0, 235, 36, 0, // Skip to: 18994 +/* 9543 */ MCD_OPC_Decode, 154, 88, 59, // Opcode: AES64KS2 +/* 9547 */ MCD_OPC_FilterValue, 55, 4, 0, 0, // Skip to: 9556 +/* 9552 */ MCD_OPC_Decode, 203, 94, 52, // Opcode: LUI +/* 9556 */ MCD_OPC_FilterValue, 59, 55, 1, 0, // Skip to: 9872 +/* 9561 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 9564 */ MCD_OPC_FilterValue, 0, 59, 0, 0, // Skip to: 9628 +/* 9569 */ MCD_OPC_ExtractField, 25, 7, // Inst{31-25} ... +/* 9572 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 9586 +/* 9577 */ MCD_OPC_CheckPredicate, 9, 196, 36, 0, // Skip to: 18994 +/* 9582 */ MCD_OPC_Decode, 142, 88, 59, // Opcode: ADDW +/* 9586 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 9600 +/* 9591 */ MCD_OPC_CheckPredicate, 54, 182, 36, 0, // Skip to: 18994 +/* 9596 */ MCD_OPC_Decode, 255, 94, 59, // Opcode: MULW +/* 9600 */ MCD_OPC_FilterValue, 4, 9, 0, 0, // Skip to: 9614 +/* 9605 */ MCD_OPC_CheckPredicate, 32, 168, 36, 0, // Skip to: 18994 +/* 9610 */ MCD_OPC_Decode, 143, 88, 59, // Opcode: ADD_UW +/* 9614 */ MCD_OPC_FilterValue, 32, 159, 36, 0, // Skip to: 18994 +/* 9619 */ MCD_OPC_CheckPredicate, 9, 154, 36, 0, // Skip to: 18994 +/* 9624 */ MCD_OPC_Decode, 221, 95, 59, // Opcode: SUBW +/* 9628 */ MCD_OPC_FilterValue, 1, 31, 0, 0, // Skip to: 9664 +/* 9633 */ MCD_OPC_ExtractField, 25, 7, // Inst{31-25} ... +/* 9636 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 9650 +/* 9641 */ MCD_OPC_CheckPredicate, 9, 132, 36, 0, // Skip to: 18994 +/* 9646 */ MCD_OPC_Decode, 191, 95, 59, // Opcode: SLLW +/* 9650 */ MCD_OPC_FilterValue, 48, 123, 36, 0, // Skip to: 18994 +/* 9655 */ MCD_OPC_CheckPredicate, 30, 118, 36, 0, // Skip to: 18994 +/* 9660 */ MCD_OPC_Decode, 145, 95, 59, // Opcode: ROLW +/* 9664 */ MCD_OPC_FilterValue, 2, 16, 0, 0, // Skip to: 9685 +/* 9669 */ MCD_OPC_CheckPredicate, 32, 104, 36, 0, // Skip to: 18994 +/* 9674 */ MCD_OPC_CheckField, 25, 7, 16, 97, 36, 0, // Skip to: 18994 +/* 9681 */ MCD_OPC_Decode, 167, 95, 59, // Opcode: SH1ADD_UW +/* 9685 */ MCD_OPC_FilterValue, 4, 61, 0, 0, // Skip to: 9751 +/* 9690 */ MCD_OPC_ExtractField, 25, 7, // Inst{31-25} ... +/* 9693 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 9707 +/* 9698 */ MCD_OPC_CheckPredicate, 55, 75, 36, 0, // Skip to: 18994 +/* 9703 */ MCD_OPC_Decode, 170, 92, 59, // Opcode: DIVW +/* 9707 */ MCD_OPC_FilterValue, 4, 25, 0, 0, // Skip to: 9737 +/* 9712 */ MCD_OPC_CheckPredicate, 33, 11, 0, 0, // Skip to: 9728 +/* 9717 */ MCD_OPC_CheckField, 20, 5, 0, 4, 0, 0, // Skip to: 9728 +/* 9724 */ MCD_OPC_Decode, 160, 102, 49, // Opcode: ZEXT_H_RV64 +/* 9728 */ MCD_OPC_CheckPredicate, 56, 45, 36, 0, // Skip to: 18994 +/* 9733 */ MCD_OPC_Decode, 134, 95, 59, // Opcode: PACKW +/* 9737 */ MCD_OPC_FilterValue, 16, 36, 36, 0, // Skip to: 18994 +/* 9742 */ MCD_OPC_CheckPredicate, 32, 31, 36, 0, // Skip to: 18994 +/* 9747 */ MCD_OPC_Decode, 169, 95, 59, // Opcode: SH2ADD_UW +/* 9751 */ MCD_OPC_FilterValue, 5, 59, 0, 0, // Skip to: 9815 +/* 9756 */ MCD_OPC_ExtractField, 25, 7, // Inst{31-25} ... +/* 9759 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 9773 +/* 9764 */ MCD_OPC_CheckPredicate, 9, 9, 36, 0, // Skip to: 18994 +/* 9769 */ MCD_OPC_Decode, 208, 95, 59, // Opcode: SRLW +/* 9773 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 9787 +/* 9778 */ MCD_OPC_CheckPredicate, 55, 251, 35, 0, // Skip to: 18994 +/* 9783 */ MCD_OPC_Decode, 169, 92, 59, // Opcode: DIVUW +/* 9787 */ MCD_OPC_FilterValue, 32, 9, 0, 0, // Skip to: 9801 +/* 9792 */ MCD_OPC_CheckPredicate, 9, 237, 35, 0, // Skip to: 18994 +/* 9797 */ MCD_OPC_Decode, 203, 95, 59, // Opcode: SRAW +/* 9801 */ MCD_OPC_FilterValue, 48, 228, 35, 0, // Skip to: 18994 +/* 9806 */ MCD_OPC_CheckPredicate, 30, 223, 35, 0, // Skip to: 18994 +/* 9811 */ MCD_OPC_Decode, 149, 95, 59, // Opcode: RORW +/* 9815 */ MCD_OPC_FilterValue, 6, 31, 0, 0, // Skip to: 9851 +/* 9820 */ MCD_OPC_ExtractField, 25, 7, // Inst{31-25} ... +/* 9823 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 9837 +/* 9828 */ MCD_OPC_CheckPredicate, 55, 201, 35, 0, // Skip to: 18994 +/* 9833 */ MCD_OPC_Decode, 141, 95, 59, // Opcode: REMW +/* 9837 */ MCD_OPC_FilterValue, 16, 192, 35, 0, // Skip to: 18994 +/* 9842 */ MCD_OPC_CheckPredicate, 32, 187, 35, 0, // Skip to: 18994 +/* 9847 */ MCD_OPC_Decode, 171, 95, 59, // Opcode: SH3ADD_UW +/* 9851 */ MCD_OPC_FilterValue, 7, 178, 35, 0, // Skip to: 18994 +/* 9856 */ MCD_OPC_CheckPredicate, 55, 173, 35, 0, // Skip to: 18994 +/* 9861 */ MCD_OPC_CheckField, 25, 7, 1, 166, 35, 0, // Skip to: 18994 +/* 9868 */ MCD_OPC_Decode, 140, 95, 59, // Opcode: REMUW +/* 9872 */ MCD_OPC_FilterValue, 67, 45, 0, 0, // Skip to: 9922 +/* 9877 */ MCD_OPC_ExtractField, 25, 2, // Inst{26-25} ... +/* 9880 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 9894 +/* 9885 */ MCD_OPC_CheckPredicate, 12, 144, 35, 0, // Skip to: 18994 +/* 9890 */ MCD_OPC_Decode, 179, 93, 62, // Opcode: FMADD_S +/* 9894 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 9908 +/* 9899 */ MCD_OPC_CheckPredicate, 13, 130, 35, 0, // Skip to: 18994 +/* 9904 */ MCD_OPC_Decode, 174, 93, 63, // Opcode: FMADD_D +/* 9908 */ MCD_OPC_FilterValue, 2, 121, 35, 0, // Skip to: 18994 +/* 9913 */ MCD_OPC_CheckPredicate, 57, 116, 35, 0, // Skip to: 18994 +/* 9918 */ MCD_OPC_Decode, 177, 93, 64, // Opcode: FMADD_H +/* 9922 */ MCD_OPC_FilterValue, 71, 45, 0, 0, // Skip to: 9972 +/* 9927 */ MCD_OPC_ExtractField, 25, 2, // Inst{26-25} ... +/* 9930 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 9944 +/* 9935 */ MCD_OPC_CheckPredicate, 12, 94, 35, 0, // Skip to: 18994 +/* 9940 */ MCD_OPC_Decode, 206, 93, 62, // Opcode: FMSUB_S +/* 9944 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 9958 +/* 9949 */ MCD_OPC_CheckPredicate, 13, 80, 35, 0, // Skip to: 18994 +/* 9954 */ MCD_OPC_Decode, 201, 93, 63, // Opcode: FMSUB_D +/* 9958 */ MCD_OPC_FilterValue, 2, 71, 35, 0, // Skip to: 18994 +/* 9963 */ MCD_OPC_CheckPredicate, 57, 66, 35, 0, // Skip to: 18994 +/* 9968 */ MCD_OPC_Decode, 204, 93, 64, // Opcode: FMSUB_H +/* 9972 */ MCD_OPC_FilterValue, 75, 45, 0, 0, // Skip to: 10022 +/* 9977 */ MCD_OPC_ExtractField, 25, 2, // Inst{26-25} ... +/* 9980 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 9994 +/* 9985 */ MCD_OPC_CheckPredicate, 12, 44, 35, 0, // Skip to: 18994 +/* 9990 */ MCD_OPC_Decode, 236, 93, 62, // Opcode: FNMSUB_S +/* 9994 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 10008 +/* 9999 */ MCD_OPC_CheckPredicate, 13, 30, 35, 0, // Skip to: 18994 +/* 10004 */ MCD_OPC_Decode, 231, 93, 63, // Opcode: FNMSUB_D +/* 10008 */ MCD_OPC_FilterValue, 2, 21, 35, 0, // Skip to: 18994 +/* 10013 */ MCD_OPC_CheckPredicate, 57, 16, 35, 0, // Skip to: 18994 +/* 10018 */ MCD_OPC_Decode, 234, 93, 64, // Opcode: FNMSUB_H +/* 10022 */ MCD_OPC_FilterValue, 79, 45, 0, 0, // Skip to: 10072 +/* 10027 */ MCD_OPC_ExtractField, 25, 2, // Inst{26-25} ... +/* 10030 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 10044 +/* 10035 */ MCD_OPC_CheckPredicate, 12, 250, 34, 0, // Skip to: 18994 +/* 10040 */ MCD_OPC_Decode, 229, 93, 62, // Opcode: FNMADD_S +/* 10044 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 10058 +/* 10049 */ MCD_OPC_CheckPredicate, 13, 236, 34, 0, // Skip to: 18994 +/* 10054 */ MCD_OPC_Decode, 224, 93, 63, // Opcode: FNMADD_D +/* 10058 */ MCD_OPC_FilterValue, 2, 227, 34, 0, // Skip to: 18994 +/* 10063 */ MCD_OPC_CheckPredicate, 57, 222, 34, 0, // Skip to: 18994 +/* 10068 */ MCD_OPC_Decode, 227, 93, 64, // Opcode: FNMADD_H +/* 10072 */ MCD_OPC_FilterValue, 83, 228, 6, 0, // Skip to: 11841 +/* 10077 */ MCD_OPC_ExtractField, 25, 7, // Inst{31-25} ... +/* 10080 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 10094 +/* 10085 */ MCD_OPC_CheckPredicate, 12, 200, 34, 0, // Skip to: 18994 +/* 10090 */ MCD_OPC_Decode, 179, 92, 65, // Opcode: FADD_S +/* 10094 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 10108 +/* 10099 */ MCD_OPC_CheckPredicate, 13, 186, 34, 0, // Skip to: 18994 +/* 10104 */ MCD_OPC_Decode, 174, 92, 66, // Opcode: FADD_D +/* 10108 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 10122 +/* 10113 */ MCD_OPC_CheckPredicate, 57, 172, 34, 0, // Skip to: 18994 +/* 10118 */ MCD_OPC_Decode, 177, 92, 67, // Opcode: FADD_H +/* 10122 */ MCD_OPC_FilterValue, 4, 9, 0, 0, // Skip to: 10136 +/* 10127 */ MCD_OPC_CheckPredicate, 12, 158, 34, 0, // Skip to: 18994 +/* 10132 */ MCD_OPC_Decode, 151, 94, 65, // Opcode: FSUB_S +/* 10136 */ MCD_OPC_FilterValue, 5, 9, 0, 0, // Skip to: 10150 +/* 10141 */ MCD_OPC_CheckPredicate, 13, 144, 34, 0, // Skip to: 18994 +/* 10146 */ MCD_OPC_Decode, 146, 94, 66, // Opcode: FSUB_D +/* 10150 */ MCD_OPC_FilterValue, 6, 9, 0, 0, // Skip to: 10164 +/* 10155 */ MCD_OPC_CheckPredicate, 57, 130, 34, 0, // Skip to: 18994 +/* 10160 */ MCD_OPC_Decode, 149, 94, 67, // Opcode: FSUB_H +/* 10164 */ MCD_OPC_FilterValue, 8, 9, 0, 0, // Skip to: 10178 +/* 10169 */ MCD_OPC_CheckPredicate, 12, 116, 34, 0, // Skip to: 18994 +/* 10174 */ MCD_OPC_Decode, 213, 93, 65, // Opcode: FMUL_S +/* 10178 */ MCD_OPC_FilterValue, 9, 9, 0, 0, // Skip to: 10192 +/* 10183 */ MCD_OPC_CheckPredicate, 13, 102, 34, 0, // Skip to: 18994 +/* 10188 */ MCD_OPC_Decode, 208, 93, 66, // Opcode: FMUL_D +/* 10192 */ MCD_OPC_FilterValue, 10, 9, 0, 0, // Skip to: 10206 +/* 10197 */ MCD_OPC_CheckPredicate, 57, 88, 34, 0, // Skip to: 18994 +/* 10202 */ MCD_OPC_Decode, 211, 93, 67, // Opcode: FMUL_H +/* 10206 */ MCD_OPC_FilterValue, 12, 9, 0, 0, // Skip to: 10220 +/* 10211 */ MCD_OPC_CheckPredicate, 12, 74, 34, 0, // Skip to: 18994 +/* 10216 */ MCD_OPC_Decode, 136, 93, 65, // Opcode: FDIV_S +/* 10220 */ MCD_OPC_FilterValue, 13, 9, 0, 0, // Skip to: 10234 +/* 10225 */ MCD_OPC_CheckPredicate, 13, 60, 34, 0, // Skip to: 18994 +/* 10230 */ MCD_OPC_Decode, 131, 93, 66, // Opcode: FDIV_D +/* 10234 */ MCD_OPC_FilterValue, 14, 9, 0, 0, // Skip to: 10248 +/* 10239 */ MCD_OPC_CheckPredicate, 57, 46, 34, 0, // Skip to: 18994 +/* 10244 */ MCD_OPC_Decode, 134, 93, 67, // Opcode: FDIV_H +/* 10248 */ MCD_OPC_FilterValue, 16, 45, 0, 0, // Skip to: 10298 +/* 10253 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 10256 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 10270 +/* 10261 */ MCD_OPC_CheckPredicate, 12, 24, 34, 0, // Skip to: 18994 +/* 10266 */ MCD_OPC_Decode, 136, 94, 68, // Opcode: FSGNJ_S +/* 10270 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 10284 +/* 10275 */ MCD_OPC_CheckPredicate, 12, 10, 34, 0, // Skip to: 18994 +/* 10280 */ MCD_OPC_Decode, 250, 93, 68, // Opcode: FSGNJN_S +/* 10284 */ MCD_OPC_FilterValue, 2, 1, 34, 0, // Skip to: 18994 +/* 10289 */ MCD_OPC_CheckPredicate, 12, 252, 33, 0, // Skip to: 18994 +/* 10294 */ MCD_OPC_Decode, 129, 94, 68, // Opcode: FSGNJX_S +/* 10298 */ MCD_OPC_FilterValue, 17, 45, 0, 0, // Skip to: 10348 +/* 10303 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 10306 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 10320 +/* 10311 */ MCD_OPC_CheckPredicate, 13, 230, 33, 0, // Skip to: 18994 +/* 10316 */ MCD_OPC_Decode, 131, 94, 69, // Opcode: FSGNJ_D +/* 10320 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 10334 +/* 10325 */ MCD_OPC_CheckPredicate, 13, 216, 33, 0, // Skip to: 18994 +/* 10330 */ MCD_OPC_Decode, 245, 93, 69, // Opcode: FSGNJN_D +/* 10334 */ MCD_OPC_FilterValue, 2, 207, 33, 0, // Skip to: 18994 +/* 10339 */ MCD_OPC_CheckPredicate, 13, 202, 33, 0, // Skip to: 18994 +/* 10344 */ MCD_OPC_Decode, 252, 93, 69, // Opcode: FSGNJX_D +/* 10348 */ MCD_OPC_FilterValue, 18, 45, 0, 0, // Skip to: 10398 +/* 10353 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 10356 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 10370 +/* 10361 */ MCD_OPC_CheckPredicate, 57, 180, 33, 0, // Skip to: 18994 +/* 10366 */ MCD_OPC_Decode, 134, 94, 70, // Opcode: FSGNJ_H +/* 10370 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 10384 +/* 10375 */ MCD_OPC_CheckPredicate, 57, 166, 33, 0, // Skip to: 18994 +/* 10380 */ MCD_OPC_Decode, 248, 93, 70, // Opcode: FSGNJN_H +/* 10384 */ MCD_OPC_FilterValue, 2, 157, 33, 0, // Skip to: 18994 +/* 10389 */ MCD_OPC_CheckPredicate, 57, 152, 33, 0, // Skip to: 18994 +/* 10394 */ MCD_OPC_Decode, 255, 93, 70, // Opcode: FSGNJX_H +/* 10398 */ MCD_OPC_FilterValue, 20, 59, 0, 0, // Skip to: 10462 +/* 10403 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 10406 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 10420 +/* 10411 */ MCD_OPC_CheckPredicate, 12, 130, 33, 0, // Skip to: 18994 +/* 10416 */ MCD_OPC_Decode, 199, 93, 68, // Opcode: FMIN_S +/* 10420 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 10434 +/* 10425 */ MCD_OPC_CheckPredicate, 12, 116, 33, 0, // Skip to: 18994 +/* 10430 */ MCD_OPC_Decode, 189, 93, 68, // Opcode: FMAX_S +/* 10434 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 10448 +/* 10439 */ MCD_OPC_CheckPredicate, 58, 102, 33, 0, // Skip to: 18994 +/* 10444 */ MCD_OPC_Decode, 193, 93, 68, // Opcode: FMINM_S +/* 10448 */ MCD_OPC_FilterValue, 3, 93, 33, 0, // Skip to: 18994 +/* 10453 */ MCD_OPC_CheckPredicate, 58, 88, 33, 0, // Skip to: 18994 +/* 10458 */ MCD_OPC_Decode, 183, 93, 68, // Opcode: FMAXM_S +/* 10462 */ MCD_OPC_FilterValue, 21, 59, 0, 0, // Skip to: 10526 +/* 10467 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 10470 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 10484 +/* 10475 */ MCD_OPC_CheckPredicate, 13, 66, 33, 0, // Skip to: 18994 +/* 10480 */ MCD_OPC_Decode, 194, 93, 69, // Opcode: FMIN_D +/* 10484 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 10498 +/* 10489 */ MCD_OPC_CheckPredicate, 13, 52, 33, 0, // Skip to: 18994 +/* 10494 */ MCD_OPC_Decode, 184, 93, 69, // Opcode: FMAX_D +/* 10498 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 10512 +/* 10503 */ MCD_OPC_CheckPredicate, 59, 38, 33, 0, // Skip to: 18994 +/* 10508 */ MCD_OPC_Decode, 191, 93, 69, // Opcode: FMINM_D +/* 10512 */ MCD_OPC_FilterValue, 3, 29, 33, 0, // Skip to: 18994 +/* 10517 */ MCD_OPC_CheckPredicate, 59, 24, 33, 0, // Skip to: 18994 +/* 10522 */ MCD_OPC_Decode, 181, 93, 69, // Opcode: FMAXM_D +/* 10526 */ MCD_OPC_FilterValue, 22, 59, 0, 0, // Skip to: 10590 +/* 10531 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 10534 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 10548 +/* 10539 */ MCD_OPC_CheckPredicate, 57, 2, 33, 0, // Skip to: 18994 +/* 10544 */ MCD_OPC_Decode, 197, 93, 70, // Opcode: FMIN_H +/* 10548 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 10562 +/* 10553 */ MCD_OPC_CheckPredicate, 57, 244, 32, 0, // Skip to: 18994 +/* 10558 */ MCD_OPC_Decode, 187, 93, 70, // Opcode: FMAX_H +/* 10562 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 10576 +/* 10567 */ MCD_OPC_CheckPredicate, 60, 230, 32, 0, // Skip to: 18994 +/* 10572 */ MCD_OPC_Decode, 192, 93, 70, // Opcode: FMINM_H +/* 10576 */ MCD_OPC_FilterValue, 3, 221, 32, 0, // Skip to: 18994 +/* 10581 */ MCD_OPC_CheckPredicate, 60, 216, 32, 0, // Skip to: 18994 +/* 10586 */ MCD_OPC_Decode, 182, 93, 70, // Opcode: FMAXM_H +/* 10590 */ MCD_OPC_FilterValue, 32, 73, 0, 0, // Skip to: 10668 +/* 10595 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 10598 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 10612 +/* 10603 */ MCD_OPC_CheckPredicate, 13, 194, 32, 0, // Skip to: 18994 +/* 10608 */ MCD_OPC_Decode, 232, 92, 71, // Opcode: FCVT_S_D +/* 10612 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 10626 +/* 10617 */ MCD_OPC_CheckPredicate, 61, 180, 32, 0, // Skip to: 18994 +/* 10622 */ MCD_OPC_Decode, 235, 92, 72, // Opcode: FCVT_S_H +/* 10626 */ MCD_OPC_FilterValue, 4, 9, 0, 0, // Skip to: 10640 +/* 10631 */ MCD_OPC_CheckPredicate, 58, 166, 32, 0, // Skip to: 18994 +/* 10636 */ MCD_OPC_Decode, 243, 93, 73, // Opcode: FROUND_S +/* 10640 */ MCD_OPC_FilterValue, 5, 9, 0, 0, // Skip to: 10654 +/* 10645 */ MCD_OPC_CheckPredicate, 58, 152, 32, 0, // Skip to: 18994 +/* 10650 */ MCD_OPC_Decode, 240, 93, 73, // Opcode: FROUNDNX_S +/* 10654 */ MCD_OPC_FilterValue, 6, 143, 32, 0, // Skip to: 18994 +/* 10659 */ MCD_OPC_CheckPredicate, 62, 138, 32, 0, // Skip to: 18994 +/* 10664 */ MCD_OPC_Decode, 231, 92, 72, // Opcode: FCVT_S_BF16 +/* 10668 */ MCD_OPC_FilterValue, 33, 59, 0, 0, // Skip to: 10732 +/* 10673 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 10676 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 10690 +/* 10681 */ MCD_OPC_CheckPredicate, 13, 116, 32, 0, // Skip to: 18994 +/* 10686 */ MCD_OPC_Decode, 197, 92, 74, // Opcode: FCVT_D_S +/* 10690 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 10704 +/* 10695 */ MCD_OPC_CheckPredicate, 63, 102, 32, 0, // Skip to: 18994 +/* 10700 */ MCD_OPC_Decode, 190, 92, 75, // Opcode: FCVT_D_H +/* 10704 */ MCD_OPC_FilterValue, 4, 9, 0, 0, // Skip to: 10718 +/* 10709 */ MCD_OPC_CheckPredicate, 59, 88, 32, 0, // Skip to: 18994 +/* 10714 */ MCD_OPC_Decode, 241, 93, 76, // Opcode: FROUND_D +/* 10718 */ MCD_OPC_FilterValue, 5, 79, 32, 0, // Skip to: 18994 +/* 10723 */ MCD_OPC_CheckPredicate, 59, 74, 32, 0, // Skip to: 18994 +/* 10728 */ MCD_OPC_Decode, 238, 93, 76, // Opcode: FROUNDNX_D +/* 10732 */ MCD_OPC_FilterValue, 34, 73, 0, 0, // Skip to: 10810 +/* 10737 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 10740 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 10754 +/* 10745 */ MCD_OPC_CheckPredicate, 61, 52, 32, 0, // Skip to: 18994 +/* 10750 */ MCD_OPC_Decode, 213, 92, 77, // Opcode: FCVT_H_S +/* 10754 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 10768 +/* 10759 */ MCD_OPC_CheckPredicate, 63, 38, 32, 0, // Skip to: 18994 +/* 10764 */ MCD_OPC_Decode, 206, 92, 78, // Opcode: FCVT_H_D +/* 10768 */ MCD_OPC_FilterValue, 4, 9, 0, 0, // Skip to: 10782 +/* 10773 */ MCD_OPC_CheckPredicate, 60, 24, 32, 0, // Skip to: 18994 +/* 10778 */ MCD_OPC_Decode, 242, 93, 79, // Opcode: FROUND_H +/* 10782 */ MCD_OPC_FilterValue, 5, 9, 0, 0, // Skip to: 10796 +/* 10787 */ MCD_OPC_CheckPredicate, 60, 10, 32, 0, // Skip to: 18994 +/* 10792 */ MCD_OPC_Decode, 239, 93, 79, // Opcode: FROUNDNX_H +/* 10796 */ MCD_OPC_FilterValue, 8, 1, 32, 0, // Skip to: 18994 +/* 10801 */ MCD_OPC_CheckPredicate, 62, 252, 31, 0, // Skip to: 18994 +/* 10806 */ MCD_OPC_Decode, 189, 92, 77, // Opcode: FCVT_BF16_S +/* 10810 */ MCD_OPC_FilterValue, 44, 16, 0, 0, // Skip to: 10831 +/* 10815 */ MCD_OPC_CheckPredicate, 12, 238, 31, 0, // Skip to: 18994 +/* 10820 */ MCD_OPC_CheckField, 20, 5, 0, 231, 31, 0, // Skip to: 18994 +/* 10827 */ MCD_OPC_Decode, 144, 94, 73, // Opcode: FSQRT_S +/* 10831 */ MCD_OPC_FilterValue, 45, 16, 0, 0, // Skip to: 10852 +/* 10836 */ MCD_OPC_CheckPredicate, 13, 217, 31, 0, // Skip to: 18994 +/* 10841 */ MCD_OPC_CheckField, 20, 5, 0, 210, 31, 0, // Skip to: 18994 +/* 10848 */ MCD_OPC_Decode, 139, 94, 76, // Opcode: FSQRT_D +/* 10852 */ MCD_OPC_FilterValue, 46, 16, 0, 0, // Skip to: 10873 +/* 10857 */ MCD_OPC_CheckPredicate, 57, 196, 31, 0, // Skip to: 18994 +/* 10862 */ MCD_OPC_CheckField, 20, 5, 0, 189, 31, 0, // Skip to: 18994 +/* 10869 */ MCD_OPC_Decode, 142, 94, 79, // Opcode: FSQRT_H +/* 10873 */ MCD_OPC_FilterValue, 80, 73, 0, 0, // Skip to: 10951 +/* 10878 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 10881 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 10895 +/* 10886 */ MCD_OPC_CheckPredicate, 12, 167, 31, 0, // Skip to: 18994 +/* 10891 */ MCD_OPC_Decode, 157, 93, 80, // Opcode: FLE_S +/* 10895 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 10909 +/* 10900 */ MCD_OPC_CheckPredicate, 12, 153, 31, 0, // Skip to: 18994 +/* 10905 */ MCD_OPC_Decode, 171, 93, 80, // Opcode: FLT_S +/* 10909 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 10923 +/* 10914 */ MCD_OPC_CheckPredicate, 12, 139, 31, 0, // Skip to: 18994 +/* 10919 */ MCD_OPC_Decode, 146, 93, 80, // Opcode: FEQ_S +/* 10923 */ MCD_OPC_FilterValue, 4, 9, 0, 0, // Skip to: 10937 +/* 10928 */ MCD_OPC_CheckPredicate, 58, 125, 31, 0, // Skip to: 18994 +/* 10933 */ MCD_OPC_Decode, 151, 93, 80, // Opcode: FLEQ_S +/* 10937 */ MCD_OPC_FilterValue, 5, 116, 31, 0, // Skip to: 18994 +/* 10942 */ MCD_OPC_CheckPredicate, 58, 111, 31, 0, // Skip to: 18994 +/* 10947 */ MCD_OPC_Decode, 165, 93, 80, // Opcode: FLTQ_S +/* 10951 */ MCD_OPC_FilterValue, 81, 73, 0, 0, // Skip to: 11029 +/* 10956 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 10959 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 10973 +/* 10964 */ MCD_OPC_CheckPredicate, 13, 89, 31, 0, // Skip to: 18994 +/* 10969 */ MCD_OPC_Decode, 152, 93, 81, // Opcode: FLE_D +/* 10973 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 10987 +/* 10978 */ MCD_OPC_CheckPredicate, 13, 75, 31, 0, // Skip to: 18994 +/* 10983 */ MCD_OPC_Decode, 166, 93, 81, // Opcode: FLT_D +/* 10987 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 11001 +/* 10992 */ MCD_OPC_CheckPredicate, 13, 61, 31, 0, // Skip to: 18994 +/* 10997 */ MCD_OPC_Decode, 141, 93, 81, // Opcode: FEQ_D +/* 11001 */ MCD_OPC_FilterValue, 4, 9, 0, 0, // Skip to: 11015 +/* 11006 */ MCD_OPC_CheckPredicate, 59, 47, 31, 0, // Skip to: 18994 +/* 11011 */ MCD_OPC_Decode, 149, 93, 81, // Opcode: FLEQ_D +/* 11015 */ MCD_OPC_FilterValue, 5, 38, 31, 0, // Skip to: 18994 +/* 11020 */ MCD_OPC_CheckPredicate, 59, 33, 31, 0, // Skip to: 18994 +/* 11025 */ MCD_OPC_Decode, 163, 93, 81, // Opcode: FLTQ_D +/* 11029 */ MCD_OPC_FilterValue, 82, 73, 0, 0, // Skip to: 11107 +/* 11034 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 11037 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 11051 +/* 11042 */ MCD_OPC_CheckPredicate, 57, 11, 31, 0, // Skip to: 18994 +/* 11047 */ MCD_OPC_Decode, 155, 93, 82, // Opcode: FLE_H +/* 11051 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 11065 +/* 11056 */ MCD_OPC_CheckPredicate, 57, 253, 30, 0, // Skip to: 18994 +/* 11061 */ MCD_OPC_Decode, 169, 93, 82, // Opcode: FLT_H +/* 11065 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 11079 +/* 11070 */ MCD_OPC_CheckPredicate, 57, 239, 30, 0, // Skip to: 18994 +/* 11075 */ MCD_OPC_Decode, 144, 93, 82, // Opcode: FEQ_H +/* 11079 */ MCD_OPC_FilterValue, 4, 9, 0, 0, // Skip to: 11093 +/* 11084 */ MCD_OPC_CheckPredicate, 60, 225, 30, 0, // Skip to: 18994 +/* 11089 */ MCD_OPC_Decode, 150, 93, 82, // Opcode: FLEQ_H +/* 11093 */ MCD_OPC_FilterValue, 5, 216, 30, 0, // Skip to: 18994 +/* 11098 */ MCD_OPC_CheckPredicate, 60, 211, 30, 0, // Skip to: 18994 +/* 11103 */ MCD_OPC_Decode, 164, 93, 82, // Opcode: FLTQ_H +/* 11107 */ MCD_OPC_FilterValue, 89, 16, 0, 0, // Skip to: 11128 +/* 11112 */ MCD_OPC_CheckPredicate, 64, 197, 30, 0, // Skip to: 18994 +/* 11117 */ MCD_OPC_CheckField, 12, 3, 0, 190, 30, 0, // Skip to: 18994 +/* 11124 */ MCD_OPC_Decode, 216, 93, 83, // Opcode: FMVP_D_X +/* 11128 */ MCD_OPC_FilterValue, 96, 59, 0, 0, // Skip to: 11192 +/* 11133 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 11136 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 11150 +/* 11141 */ MCD_OPC_CheckPredicate, 12, 168, 30, 0, // Skip to: 18994 +/* 11146 */ MCD_OPC_Decode, 129, 93, 84, // Opcode: FCVT_W_S +/* 11150 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 11164 +/* 11155 */ MCD_OPC_CheckPredicate, 12, 154, 30, 0, // Skip to: 18994 +/* 11160 */ MCD_OPC_Decode, 250, 92, 84, // Opcode: FCVT_WU_S +/* 11164 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 11178 +/* 11169 */ MCD_OPC_CheckPredicate, 65, 140, 30, 0, // Skip to: 18994 +/* 11174 */ MCD_OPC_Decode, 229, 92, 84, // Opcode: FCVT_L_S +/* 11178 */ MCD_OPC_FilterValue, 3, 131, 30, 0, // Skip to: 18994 +/* 11183 */ MCD_OPC_CheckPredicate, 65, 126, 30, 0, // Skip to: 18994 +/* 11188 */ MCD_OPC_Decode, 223, 92, 84, // Opcode: FCVT_LU_S +/* 11192 */ MCD_OPC_FilterValue, 97, 73, 0, 0, // Skip to: 11270 +/* 11197 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 11200 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 11214 +/* 11205 */ MCD_OPC_CheckPredicate, 13, 104, 30, 0, // Skip to: 18994 +/* 11210 */ MCD_OPC_Decode, 252, 92, 85, // Opcode: FCVT_W_D +/* 11214 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 11228 +/* 11219 */ MCD_OPC_CheckPredicate, 13, 90, 30, 0, // Skip to: 18994 +/* 11224 */ MCD_OPC_Decode, 245, 92, 85, // Opcode: FCVT_WU_D +/* 11228 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 11242 +/* 11233 */ MCD_OPC_CheckPredicate, 66, 76, 30, 0, // Skip to: 18994 +/* 11238 */ MCD_OPC_Decode, 225, 92, 85, // Opcode: FCVT_L_D +/* 11242 */ MCD_OPC_FilterValue, 3, 9, 0, 0, // Skip to: 11256 +/* 11247 */ MCD_OPC_CheckPredicate, 66, 62, 30, 0, // Skip to: 18994 +/* 11252 */ MCD_OPC_Decode, 219, 92, 85, // Opcode: FCVT_LU_D +/* 11256 */ MCD_OPC_FilterValue, 8, 53, 30, 0, // Skip to: 18994 +/* 11261 */ MCD_OPC_CheckPredicate, 59, 48, 30, 0, // Skip to: 18994 +/* 11266 */ MCD_OPC_Decode, 188, 92, 85, // Opcode: FCVTMOD_W_D +/* 11270 */ MCD_OPC_FilterValue, 98, 59, 0, 0, // Skip to: 11334 +/* 11275 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 11278 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 11292 +/* 11283 */ MCD_OPC_CheckPredicate, 57, 26, 30, 0, // Skip to: 18994 +/* 11288 */ MCD_OPC_Decode, 255, 92, 86, // Opcode: FCVT_W_H +/* 11292 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 11306 +/* 11297 */ MCD_OPC_CheckPredicate, 57, 12, 30, 0, // Skip to: 18994 +/* 11302 */ MCD_OPC_Decode, 248, 92, 86, // Opcode: FCVT_WU_H +/* 11306 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 11320 +/* 11311 */ MCD_OPC_CheckPredicate, 67, 254, 29, 0, // Skip to: 18994 +/* 11316 */ MCD_OPC_Decode, 227, 92, 86, // Opcode: FCVT_L_H +/* 11320 */ MCD_OPC_FilterValue, 3, 245, 29, 0, // Skip to: 18994 +/* 11325 */ MCD_OPC_CheckPredicate, 67, 240, 29, 0, // Skip to: 18994 +/* 11330 */ MCD_OPC_Decode, 221, 92, 86, // Opcode: FCVT_LU_H +/* 11334 */ MCD_OPC_FilterValue, 104, 59, 0, 0, // Skip to: 11398 +/* 11339 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 11342 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 11356 +/* 11347 */ MCD_OPC_CheckPredicate, 12, 218, 29, 0, // Skip to: 18994 +/* 11352 */ MCD_OPC_Decode, 241, 92, 87, // Opcode: FCVT_S_W +/* 11356 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 11370 +/* 11361 */ MCD_OPC_CheckPredicate, 12, 204, 29, 0, // Skip to: 18994 +/* 11366 */ MCD_OPC_Decode, 242, 92, 87, // Opcode: FCVT_S_WU +/* 11370 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 11384 +/* 11375 */ MCD_OPC_CheckPredicate, 65, 190, 29, 0, // Skip to: 18994 +/* 11380 */ MCD_OPC_Decode, 237, 92, 87, // Opcode: FCVT_S_L +/* 11384 */ MCD_OPC_FilterValue, 3, 181, 29, 0, // Skip to: 18994 +/* 11389 */ MCD_OPC_CheckPredicate, 65, 176, 29, 0, // Skip to: 18994 +/* 11394 */ MCD_OPC_Decode, 238, 92, 87, // Opcode: FCVT_S_LU +/* 11398 */ MCD_OPC_FilterValue, 105, 59, 0, 0, // Skip to: 11462 +/* 11403 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 11406 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 11420 +/* 11411 */ MCD_OPC_CheckPredicate, 13, 154, 29, 0, // Skip to: 18994 +/* 11416 */ MCD_OPC_Decode, 200, 92, 88, // Opcode: FCVT_D_W +/* 11420 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 11434 +/* 11425 */ MCD_OPC_CheckPredicate, 13, 140, 29, 0, // Skip to: 18994 +/* 11430 */ MCD_OPC_Decode, 201, 92, 88, // Opcode: FCVT_D_WU +/* 11434 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 11448 +/* 11439 */ MCD_OPC_CheckPredicate, 66, 126, 29, 0, // Skip to: 18994 +/* 11444 */ MCD_OPC_Decode, 193, 92, 88, // Opcode: FCVT_D_L +/* 11448 */ MCD_OPC_FilterValue, 3, 117, 29, 0, // Skip to: 18994 +/* 11453 */ MCD_OPC_CheckPredicate, 66, 112, 29, 0, // Skip to: 18994 +/* 11458 */ MCD_OPC_Decode, 194, 92, 88, // Opcode: FCVT_D_LU +/* 11462 */ MCD_OPC_FilterValue, 106, 59, 0, 0, // Skip to: 11526 +/* 11467 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 11470 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 11484 +/* 11475 */ MCD_OPC_CheckPredicate, 57, 90, 29, 0, // Skip to: 18994 +/* 11480 */ MCD_OPC_Decode, 215, 92, 89, // Opcode: FCVT_H_W +/* 11484 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 11498 +/* 11489 */ MCD_OPC_CheckPredicate, 57, 76, 29, 0, // Skip to: 18994 +/* 11494 */ MCD_OPC_Decode, 216, 92, 89, // Opcode: FCVT_H_WU +/* 11498 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 11512 +/* 11503 */ MCD_OPC_CheckPredicate, 67, 62, 29, 0, // Skip to: 18994 +/* 11508 */ MCD_OPC_Decode, 209, 92, 89, // Opcode: FCVT_H_L +/* 11512 */ MCD_OPC_FilterValue, 3, 53, 29, 0, // Skip to: 18994 +/* 11517 */ MCD_OPC_CheckPredicate, 67, 48, 29, 0, // Skip to: 18994 +/* 11522 */ MCD_OPC_Decode, 210, 92, 89, // Opcode: FCVT_H_LU +/* 11526 */ MCD_OPC_FilterValue, 112, 45, 0, 0, // Skip to: 11576 +/* 11531 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 11534 */ MCD_OPC_FilterValue, 0, 16, 0, 0, // Skip to: 11555 +/* 11539 */ MCD_OPC_CheckPredicate, 12, 26, 29, 0, // Skip to: 18994 +/* 11544 */ MCD_OPC_CheckField, 20, 5, 0, 19, 29, 0, // Skip to: 18994 +/* 11551 */ MCD_OPC_Decode, 222, 93, 90, // Opcode: FMV_X_W +/* 11555 */ MCD_OPC_FilterValue, 1, 10, 29, 0, // Skip to: 18994 +/* 11560 */ MCD_OPC_CheckPredicate, 12, 5, 29, 0, // Skip to: 18994 +/* 11565 */ MCD_OPC_CheckField, 20, 5, 0, 254, 28, 0, // Skip to: 18994 +/* 11572 */ MCD_OPC_Decode, 186, 92, 90, // Opcode: FCLASS_S +/* 11576 */ MCD_OPC_FilterValue, 113, 60, 0, 0, // Skip to: 11641 +/* 11581 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 11584 */ MCD_OPC_FilterValue, 0, 31, 0, 0, // Skip to: 11620 +/* 11589 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 11592 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 11606 +/* 11597 */ MCD_OPC_CheckPredicate, 66, 224, 28, 0, // Skip to: 18994 +/* 11602 */ MCD_OPC_Decode, 220, 93, 91, // Opcode: FMV_X_D +/* 11606 */ MCD_OPC_FilterValue, 1, 215, 28, 0, // Skip to: 18994 +/* 11611 */ MCD_OPC_CheckPredicate, 64, 210, 28, 0, // Skip to: 18994 +/* 11616 */ MCD_OPC_Decode, 215, 93, 91, // Opcode: FMVH_X_D +/* 11620 */ MCD_OPC_FilterValue, 1, 201, 28, 0, // Skip to: 18994 +/* 11625 */ MCD_OPC_CheckPredicate, 13, 196, 28, 0, // Skip to: 18994 +/* 11630 */ MCD_OPC_CheckField, 20, 5, 0, 189, 28, 0, // Skip to: 18994 +/* 11637 */ MCD_OPC_Decode, 181, 92, 91, // Opcode: FCLASS_D +/* 11641 */ MCD_OPC_FilterValue, 114, 45, 0, 0, // Skip to: 11691 +/* 11646 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 11649 */ MCD_OPC_FilterValue, 0, 16, 0, 0, // Skip to: 11670 +/* 11654 */ MCD_OPC_CheckPredicate, 11, 167, 28, 0, // Skip to: 18994 +/* 11659 */ MCD_OPC_CheckField, 20, 5, 0, 160, 28, 0, // Skip to: 18994 +/* 11666 */ MCD_OPC_Decode, 221, 93, 92, // Opcode: FMV_X_H +/* 11670 */ MCD_OPC_FilterValue, 1, 151, 28, 0, // Skip to: 18994 +/* 11675 */ MCD_OPC_CheckPredicate, 57, 146, 28, 0, // Skip to: 18994 +/* 11680 */ MCD_OPC_CheckField, 20, 5, 0, 139, 28, 0, // Skip to: 18994 +/* 11687 */ MCD_OPC_Decode, 184, 92, 92, // Opcode: FCLASS_H +/* 11691 */ MCD_OPC_FilterValue, 120, 45, 0, 0, // Skip to: 11741 +/* 11696 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 11699 */ MCD_OPC_FilterValue, 0, 16, 0, 0, // Skip to: 11720 +/* 11704 */ MCD_OPC_CheckPredicate, 12, 117, 28, 0, // Skip to: 18994 +/* 11709 */ MCD_OPC_CheckField, 12, 3, 0, 110, 28, 0, // Skip to: 18994 +/* 11716 */ MCD_OPC_Decode, 219, 93, 93, // Opcode: FMV_W_X +/* 11720 */ MCD_OPC_FilterValue, 1, 101, 28, 0, // Skip to: 18994 +/* 11725 */ MCD_OPC_CheckPredicate, 58, 96, 28, 0, // Skip to: 18994 +/* 11730 */ MCD_OPC_CheckField, 12, 3, 0, 89, 28, 0, // Skip to: 18994 +/* 11737 */ MCD_OPC_Decode, 162, 93, 94, // Opcode: FLI_S +/* 11741 */ MCD_OPC_FilterValue, 121, 45, 0, 0, // Skip to: 11791 +/* 11746 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 11749 */ MCD_OPC_FilterValue, 0, 16, 0, 0, // Skip to: 11770 +/* 11754 */ MCD_OPC_CheckPredicate, 66, 67, 28, 0, // Skip to: 18994 +/* 11759 */ MCD_OPC_CheckField, 12, 3, 0, 60, 28, 0, // Skip to: 18994 +/* 11766 */ MCD_OPC_Decode, 217, 93, 95, // Opcode: FMV_D_X +/* 11770 */ MCD_OPC_FilterValue, 1, 51, 28, 0, // Skip to: 18994 +/* 11775 */ MCD_OPC_CheckPredicate, 59, 46, 28, 0, // Skip to: 18994 +/* 11780 */ MCD_OPC_CheckField, 12, 3, 0, 39, 28, 0, // Skip to: 18994 +/* 11787 */ MCD_OPC_Decode, 160, 93, 96, // Opcode: FLI_D +/* 11791 */ MCD_OPC_FilterValue, 122, 30, 28, 0, // Skip to: 18994 +/* 11796 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 11799 */ MCD_OPC_FilterValue, 0, 16, 0, 0, // Skip to: 11820 +/* 11804 */ MCD_OPC_CheckPredicate, 11, 17, 28, 0, // Skip to: 18994 +/* 11809 */ MCD_OPC_CheckField, 12, 3, 0, 10, 28, 0, // Skip to: 18994 +/* 11816 */ MCD_OPC_Decode, 218, 93, 97, // Opcode: FMV_H_X +/* 11820 */ MCD_OPC_FilterValue, 1, 1, 28, 0, // Skip to: 18994 +/* 11825 */ MCD_OPC_CheckPredicate, 68, 252, 27, 0, // Skip to: 18994 +/* 11830 */ MCD_OPC_CheckField, 12, 3, 0, 245, 27, 0, // Skip to: 18994 +/* 11837 */ MCD_OPC_Decode, 161, 93, 98, // Opcode: FLI_H +/* 11841 */ MCD_OPC_FilterValue, 87, 167, 20, 0, // Skip to: 17133 +/* 11846 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 11849 */ MCD_OPC_FilterValue, 0, 166, 2, 0, // Skip to: 12532 +/* 11854 */ MCD_OPC_ExtractField, 26, 6, // Inst{31-26} ... +/* 11857 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 11871 +/* 11862 */ MCD_OPC_CheckPredicate, 10, 215, 27, 0, // Skip to: 18994 +/* 11867 */ MCD_OPC_Decode, 214, 96, 99, // Opcode: VADD_VV +/* 11871 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 11885 +/* 11876 */ MCD_OPC_CheckPredicate, 69, 201, 27, 0, // Skip to: 18994 +/* 11881 */ MCD_OPC_Decode, 227, 96, 99, // Opcode: VANDN_VV +/* 11885 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 11899 +/* 11890 */ MCD_OPC_CheckPredicate, 10, 187, 27, 0, // Skip to: 18994 +/* 11895 */ MCD_OPC_Decode, 203, 101, 99, // Opcode: VSUB_VV +/* 11899 */ MCD_OPC_FilterValue, 4, 9, 0, 0, // Skip to: 11913 +/* 11904 */ MCD_OPC_CheckPredicate, 10, 173, 27, 0, // Skip to: 18994 +/* 11909 */ MCD_OPC_Decode, 204, 99, 99, // Opcode: VMINU_VV +/* 11913 */ MCD_OPC_FilterValue, 5, 9, 0, 0, // Skip to: 11927 +/* 11918 */ MCD_OPC_CheckPredicate, 10, 159, 27, 0, // Skip to: 18994 +/* 11923 */ MCD_OPC_Decode, 206, 99, 99, // Opcode: VMIN_VV +/* 11927 */ MCD_OPC_FilterValue, 6, 9, 0, 0, // Skip to: 11941 +/* 11932 */ MCD_OPC_CheckPredicate, 10, 145, 27, 0, // Skip to: 18994 +/* 11937 */ MCD_OPC_Decode, 187, 99, 99, // Opcode: VMAXU_VV +/* 11941 */ MCD_OPC_FilterValue, 7, 9, 0, 0, // Skip to: 11955 +/* 11946 */ MCD_OPC_CheckPredicate, 10, 131, 27, 0, // Skip to: 18994 +/* 11951 */ MCD_OPC_Decode, 189, 99, 99, // Opcode: VMAX_VV +/* 11955 */ MCD_OPC_FilterValue, 9, 9, 0, 0, // Skip to: 11969 +/* 11960 */ MCD_OPC_CheckPredicate, 10, 117, 27, 0, // Skip to: 18994 +/* 11965 */ MCD_OPC_Decode, 230, 96, 99, // Opcode: VAND_VV +/* 11969 */ MCD_OPC_FilterValue, 10, 9, 0, 0, // Skip to: 11983 +/* 11974 */ MCD_OPC_CheckPredicate, 10, 103, 27, 0, // Skip to: 18994 +/* 11979 */ MCD_OPC_Decode, 147, 100, 99, // Opcode: VOR_VV +/* 11983 */ MCD_OPC_FilterValue, 11, 9, 0, 0, // Skip to: 11997 +/* 11988 */ MCD_OPC_CheckPredicate, 10, 89, 27, 0, // Skip to: 18994 +/* 11993 */ MCD_OPC_Decode, 146, 102, 99, // Opcode: VXOR_VV +/* 11997 */ MCD_OPC_FilterValue, 12, 9, 0, 0, // Skip to: 12011 +/* 12002 */ MCD_OPC_CheckPredicate, 10, 75, 27, 0, // Skip to: 18994 +/* 12007 */ MCD_OPC_Decode, 172, 100, 99, // Opcode: VRGATHER_VV +/* 12011 */ MCD_OPC_FilterValue, 14, 9, 0, 0, // Skip to: 12025 +/* 12016 */ MCD_OPC_CheckPredicate, 10, 61, 27, 0, // Skip to: 18994 +/* 12021 */ MCD_OPC_Decode, 170, 100, 99, // Opcode: VRGATHEREI16_VV +/* 12025 */ MCD_OPC_FilterValue, 16, 16, 0, 0, // Skip to: 12046 +/* 12030 */ MCD_OPC_CheckPredicate, 10, 47, 27, 0, // Skip to: 18994 +/* 12035 */ MCD_OPC_CheckField, 25, 1, 0, 40, 27, 0, // Skip to: 18994 +/* 12042 */ MCD_OPC_Decode, 211, 96, 100, // Opcode: VADC_VVM +/* 12046 */ MCD_OPC_FilterValue, 17, 31, 0, 0, // Skip to: 12082 +/* 12051 */ MCD_OPC_ExtractField, 25, 1, // Inst{25} ... +/* 12054 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 12068 +/* 12059 */ MCD_OPC_CheckPredicate, 10, 18, 27, 0, // Skip to: 18994 +/* 12064 */ MCD_OPC_Decode, 180, 99, 100, // Opcode: VMADC_VVM +/* 12068 */ MCD_OPC_FilterValue, 1, 9, 27, 0, // Skip to: 18994 +/* 12073 */ MCD_OPC_CheckPredicate, 10, 4, 27, 0, // Skip to: 18994 +/* 12078 */ MCD_OPC_Decode, 179, 99, 100, // Opcode: VMADC_VV +/* 12082 */ MCD_OPC_FilterValue, 18, 16, 0, 0, // Skip to: 12103 +/* 12087 */ MCD_OPC_CheckPredicate, 10, 246, 26, 0, // Skip to: 18994 +/* 12092 */ MCD_OPC_CheckField, 25, 1, 0, 239, 26, 0, // Skip to: 18994 +/* 12099 */ MCD_OPC_Decode, 191, 100, 100, // Opcode: VSBC_VVM +/* 12103 */ MCD_OPC_FilterValue, 19, 31, 0, 0, // Skip to: 12139 +/* 12108 */ MCD_OPC_ExtractField, 25, 1, // Inst{25} ... +/* 12111 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 12125 +/* 12116 */ MCD_OPC_CheckPredicate, 10, 217, 26, 0, // Skip to: 18994 +/* 12121 */ MCD_OPC_Decode, 213, 99, 100, // Opcode: VMSBC_VVM +/* 12125 */ MCD_OPC_FilterValue, 1, 208, 26, 0, // Skip to: 18994 +/* 12130 */ MCD_OPC_CheckPredicate, 10, 203, 26, 0, // Skip to: 18994 +/* 12135 */ MCD_OPC_Decode, 212, 99, 100, // Opcode: VMSBC_VV +/* 12139 */ MCD_OPC_FilterValue, 20, 9, 0, 0, // Skip to: 12153 +/* 12144 */ MCD_OPC_CheckPredicate, 69, 189, 26, 0, // Skip to: 18994 +/* 12149 */ MCD_OPC_Decode, 177, 100, 99, // Opcode: VROR_VV +/* 12153 */ MCD_OPC_FilterValue, 21, 9, 0, 0, // Skip to: 12167 +/* 12158 */ MCD_OPC_CheckPredicate, 69, 175, 26, 0, // Skip to: 18994 +/* 12163 */ MCD_OPC_Decode, 174, 100, 99, // Opcode: VROL_VV +/* 12167 */ MCD_OPC_FilterValue, 23, 38, 0, 0, // Skip to: 12210 +/* 12172 */ MCD_OPC_ExtractField, 25, 1, // Inst{25} ... +/* 12175 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 12189 +/* 12180 */ MCD_OPC_CheckPredicate, 10, 153, 26, 0, // Skip to: 18994 +/* 12185 */ MCD_OPC_Decode, 192, 99, 100, // Opcode: VMERGE_VVM +/* 12189 */ MCD_OPC_FilterValue, 1, 144, 26, 0, // Skip to: 18994 +/* 12194 */ MCD_OPC_CheckPredicate, 10, 139, 26, 0, // Skip to: 18994 +/* 12199 */ MCD_OPC_CheckField, 20, 5, 0, 132, 26, 0, // Skip to: 18994 +/* 12206 */ MCD_OPC_Decode, 253, 99, 101, // Opcode: VMV_V_V +/* 12210 */ MCD_OPC_FilterValue, 24, 9, 0, 0, // Skip to: 12224 +/* 12215 */ MCD_OPC_CheckPredicate, 10, 118, 26, 0, // Skip to: 18994 +/* 12220 */ MCD_OPC_Decode, 218, 99, 99, // Opcode: VMSEQ_VV +/* 12224 */ MCD_OPC_FilterValue, 25, 9, 0, 0, // Skip to: 12238 +/* 12229 */ MCD_OPC_CheckPredicate, 10, 104, 26, 0, // Skip to: 18994 +/* 12234 */ MCD_OPC_Decode, 236, 99, 99, // Opcode: VMSNE_VV +/* 12238 */ MCD_OPC_FilterValue, 26, 9, 0, 0, // Skip to: 12252 +/* 12243 */ MCD_OPC_CheckPredicate, 10, 90, 26, 0, // Skip to: 18994 +/* 12248 */ MCD_OPC_Decode, 231, 99, 99, // Opcode: VMSLTU_VV +/* 12252 */ MCD_OPC_FilterValue, 27, 9, 0, 0, // Skip to: 12266 +/* 12257 */ MCD_OPC_CheckPredicate, 10, 76, 26, 0, // Skip to: 18994 +/* 12262 */ MCD_OPC_Decode, 233, 99, 99, // Opcode: VMSLT_VV +/* 12266 */ MCD_OPC_FilterValue, 28, 9, 0, 0, // Skip to: 12280 +/* 12271 */ MCD_OPC_CheckPredicate, 10, 62, 26, 0, // Skip to: 18994 +/* 12276 */ MCD_OPC_Decode, 226, 99, 99, // Opcode: VMSLEU_VV +/* 12280 */ MCD_OPC_FilterValue, 29, 9, 0, 0, // Skip to: 12294 +/* 12285 */ MCD_OPC_CheckPredicate, 10, 48, 26, 0, // Skip to: 18994 +/* 12290 */ MCD_OPC_Decode, 229, 99, 99, // Opcode: VMSLE_VV +/* 12294 */ MCD_OPC_FilterValue, 32, 9, 0, 0, // Skip to: 12308 +/* 12299 */ MCD_OPC_CheckPredicate, 10, 34, 26, 0, // Skip to: 18994 +/* 12304 */ MCD_OPC_Decode, 186, 100, 99, // Opcode: VSADDU_VV +/* 12308 */ MCD_OPC_FilterValue, 33, 9, 0, 0, // Skip to: 12322 +/* 12313 */ MCD_OPC_CheckPredicate, 10, 20, 26, 0, // Skip to: 18994 +/* 12318 */ MCD_OPC_Decode, 189, 100, 99, // Opcode: VSADD_VV +/* 12322 */ MCD_OPC_FilterValue, 34, 9, 0, 0, // Skip to: 12336 +/* 12327 */ MCD_OPC_CheckPredicate, 10, 6, 26, 0, // Skip to: 18994 +/* 12332 */ MCD_OPC_Decode, 199, 101, 99, // Opcode: VSSUBU_VV +/* 12336 */ MCD_OPC_FilterValue, 35, 9, 0, 0, // Skip to: 12350 +/* 12341 */ MCD_OPC_CheckPredicate, 10, 248, 25, 0, // Skip to: 18994 +/* 12346 */ MCD_OPC_Decode, 201, 101, 99, // Opcode: VSSUB_VV +/* 12350 */ MCD_OPC_FilterValue, 37, 9, 0, 0, // Skip to: 12364 +/* 12355 */ MCD_OPC_CheckPredicate, 10, 234, 25, 0, // Skip to: 18994 +/* 12360 */ MCD_OPC_Decode, 213, 100, 99, // Opcode: VSLL_VV +/* 12364 */ MCD_OPC_FilterValue, 39, 9, 0, 0, // Skip to: 12378 +/* 12369 */ MCD_OPC_CheckPredicate, 10, 220, 25, 0, // Skip to: 18994 +/* 12374 */ MCD_OPC_Decode, 220, 100, 99, // Opcode: VSMUL_VV +/* 12378 */ MCD_OPC_FilterValue, 40, 9, 0, 0, // Skip to: 12392 +/* 12383 */ MCD_OPC_CheckPredicate, 10, 206, 25, 0, // Skip to: 18994 +/* 12388 */ MCD_OPC_Decode, 131, 101, 99, // Opcode: VSRL_VV +/* 12392 */ MCD_OPC_FilterValue, 41, 9, 0, 0, // Skip to: 12406 +/* 12397 */ MCD_OPC_CheckPredicate, 10, 192, 25, 0, // Skip to: 18994 +/* 12402 */ MCD_OPC_Decode, 128, 101, 99, // Opcode: VSRA_VV +/* 12406 */ MCD_OPC_FilterValue, 42, 9, 0, 0, // Skip to: 12420 +/* 12411 */ MCD_OPC_CheckPredicate, 10, 178, 25, 0, // Skip to: 18994 +/* 12416 */ MCD_OPC_Decode, 169, 101, 99, // Opcode: VSSRL_VV +/* 12420 */ MCD_OPC_FilterValue, 43, 9, 0, 0, // Skip to: 12434 +/* 12425 */ MCD_OPC_CheckPredicate, 10, 164, 25, 0, // Skip to: 18994 +/* 12430 */ MCD_OPC_Decode, 166, 101, 99, // Opcode: VSSRA_VV +/* 12434 */ MCD_OPC_FilterValue, 44, 9, 0, 0, // Skip to: 12448 +/* 12439 */ MCD_OPC_CheckPredicate, 10, 150, 25, 0, // Skip to: 18994 +/* 12444 */ MCD_OPC_Decode, 144, 100, 99, // Opcode: VNSRL_WV +/* 12448 */ MCD_OPC_FilterValue, 45, 9, 0, 0, // Skip to: 12462 +/* 12453 */ MCD_OPC_CheckPredicate, 10, 136, 25, 0, // Skip to: 18994 +/* 12458 */ MCD_OPC_Decode, 141, 100, 99, // Opcode: VNSRA_WV +/* 12462 */ MCD_OPC_FilterValue, 46, 9, 0, 0, // Skip to: 12476 +/* 12467 */ MCD_OPC_CheckPredicate, 10, 122, 25, 0, // Skip to: 18994 +/* 12472 */ MCD_OPC_Decode, 131, 100, 99, // Opcode: VNCLIPU_WV +/* 12476 */ MCD_OPC_FilterValue, 47, 9, 0, 0, // Skip to: 12490 +/* 12481 */ MCD_OPC_CheckPredicate, 10, 108, 25, 0, // Skip to: 18994 +/* 12486 */ MCD_OPC_Decode, 134, 100, 99, // Opcode: VNCLIP_WV +/* 12490 */ MCD_OPC_FilterValue, 48, 9, 0, 0, // Skip to: 12504 +/* 12495 */ MCD_OPC_CheckPredicate, 10, 94, 25, 0, // Skip to: 18994 +/* 12500 */ MCD_OPC_Decode, 132, 102, 99, // Opcode: VWREDSUMU_VS +/* 12504 */ MCD_OPC_FilterValue, 49, 9, 0, 0, // Skip to: 12518 +/* 12509 */ MCD_OPC_CheckPredicate, 10, 80, 25, 0, // Skip to: 18994 +/* 12514 */ MCD_OPC_Decode, 133, 102, 99, // Opcode: VWREDSUM_VS +/* 12518 */ MCD_OPC_FilterValue, 53, 71, 25, 0, // Skip to: 18994 +/* 12523 */ MCD_OPC_CheckPredicate, 70, 66, 25, 0, // Skip to: 18994 +/* 12528 */ MCD_OPC_Decode, 135, 102, 99, // Opcode: VWSLL_VV +/* 12532 */ MCD_OPC_FilterValue, 1, 175, 3, 0, // Skip to: 13480 +/* 12537 */ MCD_OPC_ExtractField, 26, 6, // Inst{31-26} ... +/* 12540 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 12554 +/* 12545 */ MCD_OPC_CheckPredicate, 71, 44, 25, 0, // Skip to: 18994 +/* 12550 */ MCD_OPC_Decode, 152, 97, 99, // Opcode: VFADD_VV +/* 12554 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 12568 +/* 12559 */ MCD_OPC_CheckPredicate, 71, 30, 25, 0, // Skip to: 18994 +/* 12564 */ MCD_OPC_Decode, 205, 97, 99, // Opcode: VFREDUSUM_VS +/* 12568 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 12582 +/* 12573 */ MCD_OPC_CheckPredicate, 71, 16, 25, 0, // Skip to: 18994 +/* 12578 */ MCD_OPC_Decode, 218, 97, 99, // Opcode: VFSUB_VV +/* 12582 */ MCD_OPC_FilterValue, 3, 9, 0, 0, // Skip to: 12596 +/* 12587 */ MCD_OPC_CheckPredicate, 71, 2, 25, 0, // Skip to: 18994 +/* 12592 */ MCD_OPC_Decode, 204, 97, 99, // Opcode: VFREDOSUM_VS +/* 12596 */ MCD_OPC_FilterValue, 4, 9, 0, 0, // Skip to: 12610 +/* 12601 */ MCD_OPC_CheckPredicate, 71, 244, 24, 0, // Skip to: 18994 +/* 12606 */ MCD_OPC_Decode, 171, 97, 99, // Opcode: VFMIN_VV +/* 12610 */ MCD_OPC_FilterValue, 5, 9, 0, 0, // Skip to: 12624 +/* 12615 */ MCD_OPC_CheckPredicate, 71, 230, 24, 0, // Skip to: 18994 +/* 12620 */ MCD_OPC_Decode, 203, 97, 99, // Opcode: VFREDMIN_VS +/* 12624 */ MCD_OPC_FilterValue, 6, 9, 0, 0, // Skip to: 12638 +/* 12629 */ MCD_OPC_CheckPredicate, 71, 216, 24, 0, // Skip to: 18994 +/* 12634 */ MCD_OPC_Decode, 168, 97, 99, // Opcode: VFMAX_VV +/* 12638 */ MCD_OPC_FilterValue, 7, 9, 0, 0, // Skip to: 12652 +/* 12643 */ MCD_OPC_CheckPredicate, 71, 202, 24, 0, // Skip to: 18994 +/* 12648 */ MCD_OPC_Decode, 202, 97, 99, // Opcode: VFREDMAX_VS +/* 12652 */ MCD_OPC_FilterValue, 8, 9, 0, 0, // Skip to: 12666 +/* 12657 */ MCD_OPC_CheckPredicate, 71, 188, 24, 0, // Skip to: 18994 +/* 12662 */ MCD_OPC_Decode, 213, 97, 99, // Opcode: VFSGNJ_VV +/* 12666 */ MCD_OPC_FilterValue, 9, 9, 0, 0, // Skip to: 12680 +/* 12671 */ MCD_OPC_CheckPredicate, 71, 174, 24, 0, // Skip to: 18994 +/* 12676 */ MCD_OPC_Decode, 209, 97, 99, // Opcode: VFSGNJN_VV +/* 12680 */ MCD_OPC_FilterValue, 10, 9, 0, 0, // Skip to: 12694 +/* 12685 */ MCD_OPC_CheckPredicate, 71, 160, 24, 0, // Skip to: 18994 +/* 12690 */ MCD_OPC_Decode, 211, 97, 99, // Opcode: VFSGNJX_VV +/* 12694 */ MCD_OPC_FilterValue, 16, 23, 0, 0, // Skip to: 12722 +/* 12699 */ MCD_OPC_CheckPredicate, 71, 146, 24, 0, // Skip to: 18994 +/* 12704 */ MCD_OPC_CheckField, 25, 1, 1, 139, 24, 0, // Skip to: 18994 +/* 12711 */ MCD_OPC_CheckField, 15, 5, 0, 132, 24, 0, // Skip to: 18994 +/* 12718 */ MCD_OPC_Decode, 178, 97, 102, // Opcode: VFMV_F_S +/* 12722 */ MCD_OPC_FilterValue, 18, 69, 1, 0, // Skip to: 13052 +/* 12727 */ MCD_OPC_ExtractField, 15, 5, // Inst{19-15} ... +/* 12730 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 12744 +/* 12735 */ MCD_OPC_CheckPredicate, 71, 110, 24, 0, // Skip to: 18994 +/* 12740 */ MCD_OPC_Decode, 158, 97, 103, // Opcode: VFCVT_XU_F_V +/* 12744 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 12758 +/* 12749 */ MCD_OPC_CheckPredicate, 71, 96, 24, 0, // Skip to: 18994 +/* 12754 */ MCD_OPC_Decode, 159, 97, 103, // Opcode: VFCVT_X_F_V +/* 12758 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 12772 +/* 12763 */ MCD_OPC_CheckPredicate, 71, 82, 24, 0, // Skip to: 18994 +/* 12768 */ MCD_OPC_Decode, 154, 97, 103, // Opcode: VFCVT_F_XU_V +/* 12772 */ MCD_OPC_FilterValue, 3, 9, 0, 0, // Skip to: 12786 +/* 12777 */ MCD_OPC_CheckPredicate, 71, 68, 24, 0, // Skip to: 18994 +/* 12782 */ MCD_OPC_Decode, 155, 97, 103, // Opcode: VFCVT_F_X_V +/* 12786 */ MCD_OPC_FilterValue, 6, 9, 0, 0, // Skip to: 12800 +/* 12791 */ MCD_OPC_CheckPredicate, 71, 54, 24, 0, // Skip to: 18994 +/* 12796 */ MCD_OPC_Decode, 156, 97, 103, // Opcode: VFCVT_RTZ_XU_F_V +/* 12800 */ MCD_OPC_FilterValue, 7, 9, 0, 0, // Skip to: 12814 +/* 12805 */ MCD_OPC_CheckPredicate, 71, 40, 24, 0, // Skip to: 18994 +/* 12810 */ MCD_OPC_Decode, 157, 97, 103, // Opcode: VFCVT_RTZ_X_F_V +/* 12814 */ MCD_OPC_FilterValue, 8, 9, 0, 0, // Skip to: 12828 +/* 12819 */ MCD_OPC_CheckPredicate, 71, 26, 24, 0, // Skip to: 18994 +/* 12824 */ MCD_OPC_Decode, 229, 97, 103, // Opcode: VFWCVT_XU_F_V +/* 12828 */ MCD_OPC_FilterValue, 9, 9, 0, 0, // Skip to: 12842 +/* 12833 */ MCD_OPC_CheckPredicate, 71, 12, 24, 0, // Skip to: 18994 +/* 12838 */ MCD_OPC_Decode, 230, 97, 103, // Opcode: VFWCVT_X_F_V +/* 12842 */ MCD_OPC_FilterValue, 10, 9, 0, 0, // Skip to: 12856 +/* 12847 */ MCD_OPC_CheckPredicate, 71, 254, 23, 0, // Skip to: 18994 +/* 12852 */ MCD_OPC_Decode, 225, 97, 103, // Opcode: VFWCVT_F_XU_V +/* 12856 */ MCD_OPC_FilterValue, 11, 9, 0, 0, // Skip to: 12870 +/* 12861 */ MCD_OPC_CheckPredicate, 71, 240, 23, 0, // Skip to: 18994 +/* 12866 */ MCD_OPC_Decode, 226, 97, 103, // Opcode: VFWCVT_F_X_V +/* 12870 */ MCD_OPC_FilterValue, 12, 9, 0, 0, // Skip to: 12884 +/* 12875 */ MCD_OPC_CheckPredicate, 71, 226, 23, 0, // Skip to: 18994 +/* 12880 */ MCD_OPC_Decode, 224, 97, 103, // Opcode: VFWCVT_F_F_V +/* 12884 */ MCD_OPC_FilterValue, 13, 9, 0, 0, // Skip to: 12898 +/* 12889 */ MCD_OPC_CheckPredicate, 72, 212, 23, 0, // Skip to: 18994 +/* 12894 */ MCD_OPC_Decode, 223, 97, 103, // Opcode: VFWCVTBF16_F_F_V +/* 12898 */ MCD_OPC_FilterValue, 14, 9, 0, 0, // Skip to: 12912 +/* 12903 */ MCD_OPC_CheckPredicate, 71, 198, 23, 0, // Skip to: 18994 +/* 12908 */ MCD_OPC_Decode, 227, 97, 103, // Opcode: VFWCVT_RTZ_XU_F_V +/* 12912 */ MCD_OPC_FilterValue, 15, 9, 0, 0, // Skip to: 12926 +/* 12917 */ MCD_OPC_CheckPredicate, 71, 184, 23, 0, // Skip to: 18994 +/* 12922 */ MCD_OPC_Decode, 228, 97, 103, // Opcode: VFWCVT_RTZ_X_F_V +/* 12926 */ MCD_OPC_FilterValue, 16, 9, 0, 0, // Skip to: 12940 +/* 12931 */ MCD_OPC_CheckPredicate, 71, 170, 23, 0, // Skip to: 18994 +/* 12936 */ MCD_OPC_Decode, 188, 97, 103, // Opcode: VFNCVT_XU_F_W +/* 12940 */ MCD_OPC_FilterValue, 17, 9, 0, 0, // Skip to: 12954 +/* 12945 */ MCD_OPC_CheckPredicate, 71, 156, 23, 0, // Skip to: 18994 +/* 12950 */ MCD_OPC_Decode, 189, 97, 103, // Opcode: VFNCVT_X_F_W +/* 12954 */ MCD_OPC_FilterValue, 18, 9, 0, 0, // Skip to: 12968 +/* 12959 */ MCD_OPC_CheckPredicate, 71, 142, 23, 0, // Skip to: 18994 +/* 12964 */ MCD_OPC_Decode, 183, 97, 103, // Opcode: VFNCVT_F_XU_W +/* 12968 */ MCD_OPC_FilterValue, 19, 9, 0, 0, // Skip to: 12982 +/* 12973 */ MCD_OPC_CheckPredicate, 71, 128, 23, 0, // Skip to: 18994 +/* 12978 */ MCD_OPC_Decode, 184, 97, 103, // Opcode: VFNCVT_F_X_W +/* 12982 */ MCD_OPC_FilterValue, 20, 9, 0, 0, // Skip to: 12996 +/* 12987 */ MCD_OPC_CheckPredicate, 71, 114, 23, 0, // Skip to: 18994 +/* 12992 */ MCD_OPC_Decode, 182, 97, 103, // Opcode: VFNCVT_F_F_W +/* 12996 */ MCD_OPC_FilterValue, 21, 9, 0, 0, // Skip to: 13010 +/* 13001 */ MCD_OPC_CheckPredicate, 71, 100, 23, 0, // Skip to: 18994 +/* 13006 */ MCD_OPC_Decode, 185, 97, 103, // Opcode: VFNCVT_ROD_F_F_W +/* 13010 */ MCD_OPC_FilterValue, 22, 9, 0, 0, // Skip to: 13024 +/* 13015 */ MCD_OPC_CheckPredicate, 71, 86, 23, 0, // Skip to: 18994 +/* 13020 */ MCD_OPC_Decode, 186, 97, 103, // Opcode: VFNCVT_RTZ_XU_F_W +/* 13024 */ MCD_OPC_FilterValue, 23, 9, 0, 0, // Skip to: 13038 +/* 13029 */ MCD_OPC_CheckPredicate, 71, 72, 23, 0, // Skip to: 18994 +/* 13034 */ MCD_OPC_Decode, 187, 97, 103, // Opcode: VFNCVT_RTZ_X_F_W +/* 13038 */ MCD_OPC_FilterValue, 29, 63, 23, 0, // Skip to: 18994 +/* 13043 */ MCD_OPC_CheckPredicate, 72, 58, 23, 0, // Skip to: 18994 +/* 13048 */ MCD_OPC_Decode, 181, 97, 103, // Opcode: VFNCVTBF16_F_F_W +/* 13052 */ MCD_OPC_FilterValue, 19, 59, 0, 0, // Skip to: 13116 +/* 13057 */ MCD_OPC_ExtractField, 15, 5, // Inst{19-15} ... +/* 13060 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 13074 +/* 13065 */ MCD_OPC_CheckPredicate, 71, 36, 23, 0, // Skip to: 18994 +/* 13070 */ MCD_OPC_Decode, 216, 97, 103, // Opcode: VFSQRT_V +/* 13074 */ MCD_OPC_FilterValue, 4, 9, 0, 0, // Skip to: 13088 +/* 13079 */ MCD_OPC_CheckPredicate, 71, 22, 23, 0, // Skip to: 18994 +/* 13084 */ MCD_OPC_Decode, 206, 97, 103, // Opcode: VFRSQRT7_V +/* 13088 */ MCD_OPC_FilterValue, 5, 9, 0, 0, // Skip to: 13102 +/* 13093 */ MCD_OPC_CheckPredicate, 71, 8, 23, 0, // Skip to: 18994 +/* 13098 */ MCD_OPC_Decode, 201, 97, 103, // Opcode: VFREC7_V +/* 13102 */ MCD_OPC_FilterValue, 16, 255, 22, 0, // Skip to: 18994 +/* 13107 */ MCD_OPC_CheckPredicate, 71, 250, 22, 0, // Skip to: 18994 +/* 13112 */ MCD_OPC_Decode, 153, 97, 103, // Opcode: VFCLASS_V +/* 13116 */ MCD_OPC_FilterValue, 24, 9, 0, 0, // Skip to: 13130 +/* 13121 */ MCD_OPC_CheckPredicate, 71, 236, 22, 0, // Skip to: 18994 +/* 13126 */ MCD_OPC_Decode, 195, 99, 99, // Opcode: VMFEQ_VV +/* 13130 */ MCD_OPC_FilterValue, 25, 9, 0, 0, // Skip to: 13144 +/* 13135 */ MCD_OPC_CheckPredicate, 71, 222, 22, 0, // Skip to: 18994 +/* 13140 */ MCD_OPC_Decode, 199, 99, 99, // Opcode: VMFLE_VV +/* 13144 */ MCD_OPC_FilterValue, 27, 9, 0, 0, // Skip to: 13158 +/* 13149 */ MCD_OPC_CheckPredicate, 71, 208, 22, 0, // Skip to: 18994 +/* 13154 */ MCD_OPC_Decode, 201, 99, 99, // Opcode: VMFLT_VV +/* 13158 */ MCD_OPC_FilterValue, 28, 9, 0, 0, // Skip to: 13172 +/* 13163 */ MCD_OPC_CheckPredicate, 71, 194, 22, 0, // Skip to: 18994 +/* 13168 */ MCD_OPC_Decode, 203, 99, 99, // Opcode: VMFNE_VV +/* 13172 */ MCD_OPC_FilterValue, 32, 9, 0, 0, // Skip to: 13186 +/* 13177 */ MCD_OPC_CheckPredicate, 71, 180, 22, 0, // Skip to: 18994 +/* 13182 */ MCD_OPC_Decode, 161, 97, 99, // Opcode: VFDIV_VV +/* 13186 */ MCD_OPC_FilterValue, 36, 9, 0, 0, // Skip to: 13200 +/* 13191 */ MCD_OPC_CheckPredicate, 71, 166, 22, 0, // Skip to: 18994 +/* 13196 */ MCD_OPC_Decode, 177, 97, 99, // Opcode: VFMUL_VV +/* 13200 */ MCD_OPC_FilterValue, 40, 9, 0, 0, // Skip to: 13214 +/* 13205 */ MCD_OPC_CheckPredicate, 71, 152, 22, 0, // Skip to: 18994 +/* 13210 */ MCD_OPC_Decode, 166, 97, 104, // Opcode: VFMADD_VV +/* 13214 */ MCD_OPC_FilterValue, 41, 9, 0, 0, // Skip to: 13228 +/* 13219 */ MCD_OPC_CheckPredicate, 71, 138, 22, 0, // Skip to: 18994 +/* 13224 */ MCD_OPC_Decode, 193, 97, 104, // Opcode: VFNMADD_VV +/* 13228 */ MCD_OPC_FilterValue, 42, 9, 0, 0, // Skip to: 13242 +/* 13233 */ MCD_OPC_CheckPredicate, 71, 124, 22, 0, // Skip to: 18994 +/* 13238 */ MCD_OPC_Decode, 175, 97, 104, // Opcode: VFMSUB_VV +/* 13242 */ MCD_OPC_FilterValue, 43, 9, 0, 0, // Skip to: 13256 +/* 13247 */ MCD_OPC_CheckPredicate, 71, 110, 22, 0, // Skip to: 18994 +/* 13252 */ MCD_OPC_Decode, 197, 97, 104, // Opcode: VFNMSUB_VV +/* 13256 */ MCD_OPC_FilterValue, 44, 9, 0, 0, // Skip to: 13270 +/* 13261 */ MCD_OPC_CheckPredicate, 71, 96, 22, 0, // Skip to: 18994 +/* 13266 */ MCD_OPC_Decode, 164, 97, 104, // Opcode: VFMACC_VV +/* 13270 */ MCD_OPC_FilterValue, 45, 9, 0, 0, // Skip to: 13284 +/* 13275 */ MCD_OPC_CheckPredicate, 71, 82, 22, 0, // Skip to: 18994 +/* 13280 */ MCD_OPC_Decode, 191, 97, 104, // Opcode: VFNMACC_VV +/* 13284 */ MCD_OPC_FilterValue, 46, 9, 0, 0, // Skip to: 13298 +/* 13289 */ MCD_OPC_CheckPredicate, 71, 68, 22, 0, // Skip to: 18994 +/* 13294 */ MCD_OPC_Decode, 173, 97, 104, // Opcode: VFMSAC_VV +/* 13298 */ MCD_OPC_FilterValue, 47, 9, 0, 0, // Skip to: 13312 +/* 13303 */ MCD_OPC_CheckPredicate, 71, 54, 22, 0, // Skip to: 18994 +/* 13308 */ MCD_OPC_Decode, 195, 97, 104, // Opcode: VFNMSAC_VV +/* 13312 */ MCD_OPC_FilterValue, 48, 9, 0, 0, // Skip to: 13326 +/* 13317 */ MCD_OPC_CheckPredicate, 71, 40, 22, 0, // Skip to: 18994 +/* 13322 */ MCD_OPC_Decode, 220, 97, 99, // Opcode: VFWADD_VV +/* 13326 */ MCD_OPC_FilterValue, 49, 9, 0, 0, // Skip to: 13340 +/* 13331 */ MCD_OPC_CheckPredicate, 71, 26, 22, 0, // Skip to: 18994 +/* 13336 */ MCD_OPC_Decode, 245, 97, 99, // Opcode: VFWREDUSUM_VS +/* 13340 */ MCD_OPC_FilterValue, 50, 9, 0, 0, // Skip to: 13354 +/* 13345 */ MCD_OPC_CheckPredicate, 71, 12, 22, 0, // Skip to: 18994 +/* 13350 */ MCD_OPC_Decode, 247, 97, 99, // Opcode: VFWSUB_VV +/* 13354 */ MCD_OPC_FilterValue, 51, 9, 0, 0, // Skip to: 13368 +/* 13359 */ MCD_OPC_CheckPredicate, 71, 254, 21, 0, // Skip to: 18994 +/* 13364 */ MCD_OPC_Decode, 244, 97, 99, // Opcode: VFWREDOSUM_VS +/* 13368 */ MCD_OPC_FilterValue, 52, 9, 0, 0, // Skip to: 13382 +/* 13373 */ MCD_OPC_CheckPredicate, 71, 240, 21, 0, // Skip to: 18994 +/* 13378 */ MCD_OPC_Decode, 222, 97, 99, // Opcode: VFWADD_WV +/* 13382 */ MCD_OPC_FilterValue, 54, 9, 0, 0, // Skip to: 13396 +/* 13387 */ MCD_OPC_CheckPredicate, 71, 226, 21, 0, // Skip to: 18994 +/* 13392 */ MCD_OPC_Decode, 249, 97, 99, // Opcode: VFWSUB_WV +/* 13396 */ MCD_OPC_FilterValue, 56, 9, 0, 0, // Skip to: 13410 +/* 13401 */ MCD_OPC_CheckPredicate, 71, 212, 21, 0, // Skip to: 18994 +/* 13406 */ MCD_OPC_Decode, 239, 97, 99, // Opcode: VFWMUL_VV +/* 13410 */ MCD_OPC_FilterValue, 59, 9, 0, 0, // Skip to: 13424 +/* 13415 */ MCD_OPC_CheckPredicate, 73, 198, 21, 0, // Skip to: 18994 +/* 13420 */ MCD_OPC_Decode, 232, 97, 104, // Opcode: VFWMACCBF16_VV +/* 13424 */ MCD_OPC_FilterValue, 60, 9, 0, 0, // Skip to: 13438 +/* 13429 */ MCD_OPC_CheckPredicate, 71, 184, 21, 0, // Skip to: 18994 +/* 13434 */ MCD_OPC_Decode, 235, 97, 104, // Opcode: VFWMACC_VV +/* 13438 */ MCD_OPC_FilterValue, 61, 9, 0, 0, // Skip to: 13452 +/* 13443 */ MCD_OPC_CheckPredicate, 71, 170, 21, 0, // Skip to: 18994 +/* 13448 */ MCD_OPC_Decode, 241, 97, 104, // Opcode: VFWNMACC_VV +/* 13452 */ MCD_OPC_FilterValue, 62, 9, 0, 0, // Skip to: 13466 +/* 13457 */ MCD_OPC_CheckPredicate, 71, 156, 21, 0, // Skip to: 18994 +/* 13462 */ MCD_OPC_Decode, 237, 97, 104, // Opcode: VFWMSAC_VV +/* 13466 */ MCD_OPC_FilterValue, 63, 147, 21, 0, // Skip to: 18994 +/* 13471 */ MCD_OPC_CheckPredicate, 71, 142, 21, 0, // Skip to: 18994 +/* 13476 */ MCD_OPC_Decode, 243, 97, 104, // Opcode: VFWNMSAC_VV +/* 13480 */ MCD_OPC_FilterValue, 2, 46, 4, 0, // Skip to: 14555 +/* 13485 */ MCD_OPC_ExtractField, 26, 6, // Inst{31-26} ... +/* 13488 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 13502 +/* 13493 */ MCD_OPC_CheckPredicate, 10, 120, 21, 0, // Skip to: 18994 +/* 13498 */ MCD_OPC_Decode, 163, 100, 99, // Opcode: VREDSUM_VS +/* 13502 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 13516 +/* 13507 */ MCD_OPC_CheckPredicate, 10, 106, 21, 0, // Skip to: 18994 +/* 13512 */ MCD_OPC_Decode, 157, 100, 99, // Opcode: VREDAND_VS +/* 13516 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 13530 +/* 13521 */ MCD_OPC_CheckPredicate, 10, 92, 21, 0, // Skip to: 18994 +/* 13526 */ MCD_OPC_Decode, 162, 100, 99, // Opcode: VREDOR_VS +/* 13530 */ MCD_OPC_FilterValue, 3, 9, 0, 0, // Skip to: 13544 +/* 13535 */ MCD_OPC_CheckPredicate, 10, 78, 21, 0, // Skip to: 18994 +/* 13540 */ MCD_OPC_Decode, 164, 100, 99, // Opcode: VREDXOR_VS +/* 13544 */ MCD_OPC_FilterValue, 4, 9, 0, 0, // Skip to: 13558 +/* 13549 */ MCD_OPC_CheckPredicate, 10, 64, 21, 0, // Skip to: 18994 +/* 13554 */ MCD_OPC_Decode, 160, 100, 99, // Opcode: VREDMINU_VS +/* 13558 */ MCD_OPC_FilterValue, 5, 9, 0, 0, // Skip to: 13572 +/* 13563 */ MCD_OPC_CheckPredicate, 10, 50, 21, 0, // Skip to: 18994 +/* 13568 */ MCD_OPC_Decode, 161, 100, 99, // Opcode: VREDMIN_VS +/* 13572 */ MCD_OPC_FilterValue, 6, 9, 0, 0, // Skip to: 13586 +/* 13577 */ MCD_OPC_CheckPredicate, 10, 36, 21, 0, // Skip to: 18994 +/* 13582 */ MCD_OPC_Decode, 158, 100, 99, // Opcode: VREDMAXU_VS +/* 13586 */ MCD_OPC_FilterValue, 7, 9, 0, 0, // Skip to: 13600 +/* 13591 */ MCD_OPC_CheckPredicate, 10, 22, 21, 0, // Skip to: 18994 +/* 13596 */ MCD_OPC_Decode, 159, 100, 99, // Opcode: VREDMAX_VS +/* 13600 */ MCD_OPC_FilterValue, 8, 9, 0, 0, // Skip to: 13614 +/* 13605 */ MCD_OPC_CheckPredicate, 10, 8, 21, 0, // Skip to: 18994 +/* 13610 */ MCD_OPC_Decode, 206, 96, 99, // Opcode: VAADDU_VV +/* 13614 */ MCD_OPC_FilterValue, 9, 9, 0, 0, // Skip to: 13628 +/* 13619 */ MCD_OPC_CheckPredicate, 10, 250, 20, 0, // Skip to: 18994 +/* 13624 */ MCD_OPC_Decode, 208, 96, 99, // Opcode: VAADD_VV +/* 13628 */ MCD_OPC_FilterValue, 10, 9, 0, 0, // Skip to: 13642 +/* 13633 */ MCD_OPC_CheckPredicate, 10, 236, 20, 0, // Skip to: 18994 +/* 13638 */ MCD_OPC_Decode, 232, 96, 99, // Opcode: VASUBU_VV +/* 13642 */ MCD_OPC_FilterValue, 11, 9, 0, 0, // Skip to: 13656 +/* 13647 */ MCD_OPC_CheckPredicate, 10, 222, 20, 0, // Skip to: 18994 +/* 13652 */ MCD_OPC_Decode, 234, 96, 99, // Opcode: VASUB_VV +/* 13656 */ MCD_OPC_FilterValue, 12, 9, 0, 0, // Skip to: 13670 +/* 13661 */ MCD_OPC_CheckPredicate, 74, 208, 20, 0, // Skip to: 18994 +/* 13666 */ MCD_OPC_Decode, 240, 96, 99, // Opcode: VCLMUL_VV +/* 13670 */ MCD_OPC_FilterValue, 13, 9, 0, 0, // Skip to: 13684 +/* 13675 */ MCD_OPC_CheckPredicate, 74, 194, 20, 0, // Skip to: 18994 +/* 13680 */ MCD_OPC_Decode, 238, 96, 99, // Opcode: VCLMULH_VV +/* 13684 */ MCD_OPC_FilterValue, 16, 52, 0, 0, // Skip to: 13741 +/* 13689 */ MCD_OPC_ExtractField, 15, 5, // Inst{19-15} ... +/* 13692 */ MCD_OPC_FilterValue, 0, 16, 0, 0, // Skip to: 13713 +/* 13697 */ MCD_OPC_CheckPredicate, 10, 172, 20, 0, // Skip to: 18994 +/* 13702 */ MCD_OPC_CheckField, 25, 1, 1, 165, 20, 0, // Skip to: 18994 +/* 13709 */ MCD_OPC_Decode, 255, 99, 105, // Opcode: VMV_X_S +/* 13713 */ MCD_OPC_FilterValue, 16, 9, 0, 0, // Skip to: 13727 +/* 13718 */ MCD_OPC_CheckPredicate, 10, 151, 20, 0, // Skip to: 18994 +/* 13723 */ MCD_OPC_Decode, 244, 96, 106, // Opcode: VCPOP_M +/* 13727 */ MCD_OPC_FilterValue, 17, 142, 20, 0, // Skip to: 18994 +/* 13732 */ MCD_OPC_CheckPredicate, 10, 137, 20, 0, // Skip to: 18994 +/* 13737 */ MCD_OPC_Decode, 162, 97, 106, // Opcode: VFIRST_M +/* 13741 */ MCD_OPC_FilterValue, 18, 171, 0, 0, // Skip to: 13917 +/* 13746 */ MCD_OPC_ExtractField, 15, 5, // Inst{19-15} ... +/* 13749 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 13763 +/* 13754 */ MCD_OPC_CheckPredicate, 10, 115, 20, 0, // Skip to: 18994 +/* 13759 */ MCD_OPC_Decode, 150, 102, 103, // Opcode: VZEXT_VF8 +/* 13763 */ MCD_OPC_FilterValue, 3, 9, 0, 0, // Skip to: 13777 +/* 13768 */ MCD_OPC_CheckPredicate, 10, 101, 20, 0, // Skip to: 18994 +/* 13773 */ MCD_OPC_Decode, 202, 100, 103, // Opcode: VSEXT_VF8 +/* 13777 */ MCD_OPC_FilterValue, 4, 9, 0, 0, // Skip to: 13791 +/* 13782 */ MCD_OPC_CheckPredicate, 10, 87, 20, 0, // Skip to: 18994 +/* 13787 */ MCD_OPC_Decode, 149, 102, 103, // Opcode: VZEXT_VF4 +/* 13791 */ MCD_OPC_FilterValue, 5, 9, 0, 0, // Skip to: 13805 +/* 13796 */ MCD_OPC_CheckPredicate, 10, 73, 20, 0, // Skip to: 18994 +/* 13801 */ MCD_OPC_Decode, 201, 100, 103, // Opcode: VSEXT_VF4 +/* 13805 */ MCD_OPC_FilterValue, 6, 9, 0, 0, // Skip to: 13819 +/* 13810 */ MCD_OPC_CheckPredicate, 10, 59, 20, 0, // Skip to: 18994 +/* 13815 */ MCD_OPC_Decode, 148, 102, 103, // Opcode: VZEXT_VF2 +/* 13819 */ MCD_OPC_FilterValue, 7, 9, 0, 0, // Skip to: 13833 +/* 13824 */ MCD_OPC_CheckPredicate, 10, 45, 20, 0, // Skip to: 18994 +/* 13829 */ MCD_OPC_Decode, 200, 100, 103, // Opcode: VSEXT_VF2 +/* 13833 */ MCD_OPC_FilterValue, 8, 9, 0, 0, // Skip to: 13847 +/* 13838 */ MCD_OPC_CheckPredicate, 69, 31, 20, 0, // Skip to: 18994 +/* 13843 */ MCD_OPC_Decode, 236, 96, 103, // Opcode: VBREV8_V +/* 13847 */ MCD_OPC_FilterValue, 9, 9, 0, 0, // Skip to: 13861 +/* 13852 */ MCD_OPC_CheckPredicate, 69, 17, 20, 0, // Skip to: 18994 +/* 13857 */ MCD_OPC_Decode, 169, 100, 103, // Opcode: VREV8_V +/* 13861 */ MCD_OPC_FilterValue, 10, 9, 0, 0, // Skip to: 13875 +/* 13866 */ MCD_OPC_CheckPredicate, 70, 3, 20, 0, // Skip to: 18994 +/* 13871 */ MCD_OPC_Decode, 237, 96, 103, // Opcode: VBREV_V +/* 13875 */ MCD_OPC_FilterValue, 12, 9, 0, 0, // Skip to: 13889 +/* 13880 */ MCD_OPC_CheckPredicate, 70, 245, 19, 0, // Skip to: 18994 +/* 13885 */ MCD_OPC_Decode, 242, 96, 103, // Opcode: VCLZ_V +/* 13889 */ MCD_OPC_FilterValue, 13, 9, 0, 0, // Skip to: 13903 +/* 13894 */ MCD_OPC_CheckPredicate, 70, 231, 19, 0, // Skip to: 18994 +/* 13899 */ MCD_OPC_Decode, 246, 96, 103, // Opcode: VCTZ_V +/* 13903 */ MCD_OPC_FilterValue, 14, 222, 19, 0, // Skip to: 18994 +/* 13908 */ MCD_OPC_CheckPredicate, 70, 217, 19, 0, // Skip to: 18994 +/* 13913 */ MCD_OPC_Decode, 245, 96, 103, // Opcode: VCPOP_V +/* 13917 */ MCD_OPC_FilterValue, 20, 80, 0, 0, // Skip to: 14002 +/* 13922 */ MCD_OPC_ExtractField, 15, 5, // Inst{19-15} ... +/* 13925 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 13939 +/* 13930 */ MCD_OPC_CheckPredicate, 10, 195, 19, 0, // Skip to: 18994 +/* 13935 */ MCD_OPC_Decode, 216, 99, 103, // Opcode: VMSBF_M +/* 13939 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 13953 +/* 13944 */ MCD_OPC_CheckPredicate, 10, 181, 19, 0, // Skip to: 18994 +/* 13949 */ MCD_OPC_Decode, 238, 99, 103, // Opcode: VMSOF_M +/* 13953 */ MCD_OPC_FilterValue, 3, 9, 0, 0, // Skip to: 13967 +/* 13958 */ MCD_OPC_CheckPredicate, 10, 167, 19, 0, // Skip to: 18994 +/* 13963 */ MCD_OPC_Decode, 224, 99, 103, // Opcode: VMSIF_M +/* 13967 */ MCD_OPC_FilterValue, 16, 9, 0, 0, // Skip to: 13981 +/* 13972 */ MCD_OPC_CheckPredicate, 10, 153, 19, 0, // Skip to: 18994 +/* 13977 */ MCD_OPC_Decode, 253, 97, 103, // Opcode: VIOTA_M +/* 13981 */ MCD_OPC_FilterValue, 17, 144, 19, 0, // Skip to: 18994 +/* 13986 */ MCD_OPC_CheckPredicate, 10, 139, 19, 0, // Skip to: 18994 +/* 13991 */ MCD_OPC_CheckField, 20, 5, 0, 132, 19, 0, // Skip to: 18994 +/* 13998 */ MCD_OPC_Decode, 252, 97, 107, // Opcode: VID_V +/* 14002 */ MCD_OPC_FilterValue, 23, 16, 0, 0, // Skip to: 14023 +/* 14007 */ MCD_OPC_CheckPredicate, 10, 118, 19, 0, // Skip to: 18994 +/* 14012 */ MCD_OPC_CheckField, 25, 1, 1, 111, 19, 0, // Skip to: 18994 +/* 14019 */ MCD_OPC_Decode, 243, 96, 100, // Opcode: VCOMPRESS_VM +/* 14023 */ MCD_OPC_FilterValue, 24, 16, 0, 0, // Skip to: 14044 +/* 14028 */ MCD_OPC_CheckPredicate, 10, 97, 19, 0, // Skip to: 18994 +/* 14033 */ MCD_OPC_CheckField, 25, 1, 1, 90, 19, 0, // Skip to: 18994 +/* 14040 */ MCD_OPC_Decode, 185, 99, 100, // Opcode: VMANDN_MM +/* 14044 */ MCD_OPC_FilterValue, 25, 16, 0, 0, // Skip to: 14065 +/* 14049 */ MCD_OPC_CheckPredicate, 10, 76, 19, 0, // Skip to: 18994 +/* 14054 */ MCD_OPC_CheckField, 25, 1, 1, 69, 19, 0, // Skip to: 18994 +/* 14061 */ MCD_OPC_Decode, 186, 99, 100, // Opcode: VMAND_MM +/* 14065 */ MCD_OPC_FilterValue, 26, 16, 0, 0, // Skip to: 14086 +/* 14070 */ MCD_OPC_CheckPredicate, 10, 55, 19, 0, // Skip to: 18994 +/* 14075 */ MCD_OPC_CheckField, 25, 1, 1, 48, 19, 0, // Skip to: 18994 +/* 14082 */ MCD_OPC_Decode, 211, 99, 100, // Opcode: VMOR_MM +/* 14086 */ MCD_OPC_FilterValue, 27, 16, 0, 0, // Skip to: 14107 +/* 14091 */ MCD_OPC_CheckPredicate, 10, 34, 19, 0, // Skip to: 18994 +/* 14096 */ MCD_OPC_CheckField, 25, 1, 1, 27, 19, 0, // Skip to: 18994 +/* 14103 */ MCD_OPC_Decode, 129, 100, 100, // Opcode: VMXOR_MM +/* 14107 */ MCD_OPC_FilterValue, 28, 16, 0, 0, // Skip to: 14128 +/* 14112 */ MCD_OPC_CheckPredicate, 10, 13, 19, 0, // Skip to: 18994 +/* 14117 */ MCD_OPC_CheckField, 25, 1, 1, 6, 19, 0, // Skip to: 18994 +/* 14124 */ MCD_OPC_Decode, 210, 99, 100, // Opcode: VMORN_MM +/* 14128 */ MCD_OPC_FilterValue, 29, 16, 0, 0, // Skip to: 14149 +/* 14133 */ MCD_OPC_CheckPredicate, 10, 248, 18, 0, // Skip to: 18994 +/* 14138 */ MCD_OPC_CheckField, 25, 1, 1, 241, 18, 0, // Skip to: 18994 +/* 14145 */ MCD_OPC_Decode, 208, 99, 100, // Opcode: VMNAND_MM +/* 14149 */ MCD_OPC_FilterValue, 30, 16, 0, 0, // Skip to: 14170 +/* 14154 */ MCD_OPC_CheckPredicate, 10, 227, 18, 0, // Skip to: 18994 +/* 14159 */ MCD_OPC_CheckField, 25, 1, 1, 220, 18, 0, // Skip to: 18994 +/* 14166 */ MCD_OPC_Decode, 209, 99, 100, // Opcode: VMNOR_MM +/* 14170 */ MCD_OPC_FilterValue, 31, 16, 0, 0, // Skip to: 14191 +/* 14175 */ MCD_OPC_CheckPredicate, 10, 206, 18, 0, // Skip to: 18994 +/* 14180 */ MCD_OPC_CheckField, 25, 1, 1, 199, 18, 0, // Skip to: 18994 +/* 14187 */ MCD_OPC_Decode, 128, 100, 100, // Opcode: VMXNOR_MM +/* 14191 */ MCD_OPC_FilterValue, 32, 9, 0, 0, // Skip to: 14205 +/* 14196 */ MCD_OPC_CheckPredicate, 10, 185, 18, 0, // Skip to: 18994 +/* 14201 */ MCD_OPC_Decode, 147, 97, 99, // Opcode: VDIVU_VV +/* 14205 */ MCD_OPC_FilterValue, 33, 9, 0, 0, // Skip to: 14219 +/* 14210 */ MCD_OPC_CheckPredicate, 10, 171, 18, 0, // Skip to: 18994 +/* 14215 */ MCD_OPC_Decode, 149, 97, 99, // Opcode: VDIV_VV +/* 14219 */ MCD_OPC_FilterValue, 34, 9, 0, 0, // Skip to: 14233 +/* 14224 */ MCD_OPC_CheckPredicate, 10, 157, 18, 0, // Skip to: 18994 +/* 14229 */ MCD_OPC_Decode, 165, 100, 99, // Opcode: VREMU_VV +/* 14233 */ MCD_OPC_FilterValue, 35, 9, 0, 0, // Skip to: 14247 +/* 14238 */ MCD_OPC_CheckPredicate, 10, 143, 18, 0, // Skip to: 18994 +/* 14243 */ MCD_OPC_Decode, 167, 100, 99, // Opcode: VREM_VV +/* 14247 */ MCD_OPC_FilterValue, 36, 9, 0, 0, // Skip to: 14261 +/* 14252 */ MCD_OPC_CheckPredicate, 10, 129, 18, 0, // Skip to: 18994 +/* 14257 */ MCD_OPC_Decode, 241, 99, 99, // Opcode: VMULHU_VV +/* 14261 */ MCD_OPC_FilterValue, 37, 9, 0, 0, // Skip to: 14275 +/* 14266 */ MCD_OPC_CheckPredicate, 10, 115, 18, 0, // Skip to: 18994 +/* 14271 */ MCD_OPC_Decode, 245, 99, 99, // Opcode: VMUL_VV +/* 14275 */ MCD_OPC_FilterValue, 38, 9, 0, 0, // Skip to: 14289 +/* 14280 */ MCD_OPC_CheckPredicate, 10, 101, 18, 0, // Skip to: 18994 +/* 14285 */ MCD_OPC_Decode, 239, 99, 99, // Opcode: VMULHSU_VV +/* 14289 */ MCD_OPC_FilterValue, 39, 9, 0, 0, // Skip to: 14303 +/* 14294 */ MCD_OPC_CheckPredicate, 10, 87, 18, 0, // Skip to: 18994 +/* 14299 */ MCD_OPC_Decode, 243, 99, 99, // Opcode: VMULH_VV +/* 14303 */ MCD_OPC_FilterValue, 41, 9, 0, 0, // Skip to: 14317 +/* 14308 */ MCD_OPC_CheckPredicate, 10, 73, 18, 0, // Skip to: 18994 +/* 14313 */ MCD_OPC_Decode, 183, 99, 104, // Opcode: VMADD_VV +/* 14317 */ MCD_OPC_FilterValue, 43, 9, 0, 0, // Skip to: 14331 +/* 14322 */ MCD_OPC_CheckPredicate, 10, 59, 18, 0, // Skip to: 18994 +/* 14327 */ MCD_OPC_Decode, 138, 100, 104, // Opcode: VNMSUB_VV +/* 14331 */ MCD_OPC_FilterValue, 45, 9, 0, 0, // Skip to: 14345 +/* 14336 */ MCD_OPC_CheckPredicate, 10, 45, 18, 0, // Skip to: 18994 +/* 14341 */ MCD_OPC_Decode, 175, 99, 104, // Opcode: VMACC_VV +/* 14345 */ MCD_OPC_FilterValue, 47, 9, 0, 0, // Skip to: 14359 +/* 14350 */ MCD_OPC_CheckPredicate, 10, 31, 18, 0, // Skip to: 18994 +/* 14355 */ MCD_OPC_Decode, 136, 100, 104, // Opcode: VNMSAC_VV +/* 14359 */ MCD_OPC_FilterValue, 48, 9, 0, 0, // Skip to: 14373 +/* 14364 */ MCD_OPC_CheckPredicate, 10, 17, 18, 0, // Skip to: 18994 +/* 14369 */ MCD_OPC_Decode, 239, 101, 99, // Opcode: VWADDU_VV +/* 14373 */ MCD_OPC_FilterValue, 49, 9, 0, 0, // Skip to: 14387 +/* 14378 */ MCD_OPC_CheckPredicate, 10, 3, 18, 0, // Skip to: 18994 +/* 14383 */ MCD_OPC_Decode, 243, 101, 99, // Opcode: VWADD_VV +/* 14387 */ MCD_OPC_FilterValue, 50, 9, 0, 0, // Skip to: 14401 +/* 14392 */ MCD_OPC_CheckPredicate, 10, 245, 17, 0, // Skip to: 18994 +/* 14397 */ MCD_OPC_Decode, 137, 102, 99, // Opcode: VWSUBU_VV +/* 14401 */ MCD_OPC_FilterValue, 51, 9, 0, 0, // Skip to: 14415 +/* 14406 */ MCD_OPC_CheckPredicate, 10, 231, 17, 0, // Skip to: 18994 +/* 14411 */ MCD_OPC_Decode, 141, 102, 99, // Opcode: VWSUB_VV +/* 14415 */ MCD_OPC_FilterValue, 52, 9, 0, 0, // Skip to: 14429 +/* 14420 */ MCD_OPC_CheckPredicate, 10, 217, 17, 0, // Skip to: 18994 +/* 14425 */ MCD_OPC_Decode, 241, 101, 99, // Opcode: VWADDU_WV +/* 14429 */ MCD_OPC_FilterValue, 53, 9, 0, 0, // Skip to: 14443 +/* 14434 */ MCD_OPC_CheckPredicate, 10, 203, 17, 0, // Skip to: 18994 +/* 14439 */ MCD_OPC_Decode, 245, 101, 99, // Opcode: VWADD_WV +/* 14443 */ MCD_OPC_FilterValue, 54, 9, 0, 0, // Skip to: 14457 +/* 14448 */ MCD_OPC_CheckPredicate, 10, 189, 17, 0, // Skip to: 18994 +/* 14453 */ MCD_OPC_Decode, 139, 102, 99, // Opcode: VWSUBU_WV +/* 14457 */ MCD_OPC_FilterValue, 55, 9, 0, 0, // Skip to: 14471 +/* 14462 */ MCD_OPC_CheckPredicate, 10, 175, 17, 0, // Skip to: 18994 +/* 14467 */ MCD_OPC_Decode, 143, 102, 99, // Opcode: VWSUB_WV +/* 14471 */ MCD_OPC_FilterValue, 56, 9, 0, 0, // Skip to: 14485 +/* 14476 */ MCD_OPC_CheckPredicate, 10, 161, 17, 0, // Skip to: 18994 +/* 14481 */ MCD_OPC_Decode, 128, 102, 99, // Opcode: VWMULU_VV +/* 14485 */ MCD_OPC_FilterValue, 58, 9, 0, 0, // Skip to: 14499 +/* 14490 */ MCD_OPC_CheckPredicate, 10, 147, 17, 0, // Skip to: 18994 +/* 14495 */ MCD_OPC_Decode, 254, 101, 99, // Opcode: VWMULSU_VV +/* 14499 */ MCD_OPC_FilterValue, 59, 9, 0, 0, // Skip to: 14513 +/* 14504 */ MCD_OPC_CheckPredicate, 10, 133, 17, 0, // Skip to: 18994 +/* 14509 */ MCD_OPC_Decode, 130, 102, 99, // Opcode: VWMUL_VV +/* 14513 */ MCD_OPC_FilterValue, 60, 9, 0, 0, // Skip to: 14527 +/* 14518 */ MCD_OPC_CheckPredicate, 10, 119, 17, 0, // Skip to: 18994 +/* 14523 */ MCD_OPC_Decode, 250, 101, 104, // Opcode: VWMACCU_VV +/* 14527 */ MCD_OPC_FilterValue, 61, 9, 0, 0, // Skip to: 14541 +/* 14532 */ MCD_OPC_CheckPredicate, 10, 105, 17, 0, // Skip to: 18994 +/* 14537 */ MCD_OPC_Decode, 252, 101, 104, // Opcode: VWMACC_VV +/* 14541 */ MCD_OPC_FilterValue, 63, 96, 17, 0, // Skip to: 18994 +/* 14546 */ MCD_OPC_CheckPredicate, 10, 91, 17, 0, // Skip to: 18994 +/* 14551 */ MCD_OPC_Decode, 247, 101, 104, // Opcode: VWMACCSU_VV +/* 14555 */ MCD_OPC_FilterValue, 3, 176, 2, 0, // Skip to: 15248 +/* 14560 */ MCD_OPC_ExtractField, 27, 5, // Inst{31-27} ... +/* 14563 */ MCD_OPC_FilterValue, 0, 16, 0, 0, // Skip to: 14584 +/* 14568 */ MCD_OPC_CheckPredicate, 10, 69, 17, 0, // Skip to: 18994 +/* 14573 */ MCD_OPC_CheckField, 26, 1, 0, 62, 17, 0, // Skip to: 18994 +/* 14580 */ MCD_OPC_Decode, 213, 96, 108, // Opcode: VADD_VI +/* 14584 */ MCD_OPC_FilterValue, 1, 16, 0, 0, // Skip to: 14605 +/* 14589 */ MCD_OPC_CheckPredicate, 10, 48, 17, 0, // Skip to: 18994 +/* 14594 */ MCD_OPC_CheckField, 26, 1, 1, 41, 17, 0, // Skip to: 18994 +/* 14601 */ MCD_OPC_Decode, 179, 100, 108, // Opcode: VRSUB_VI +/* 14605 */ MCD_OPC_FilterValue, 4, 16, 0, 0, // Skip to: 14626 +/* 14610 */ MCD_OPC_CheckPredicate, 10, 27, 17, 0, // Skip to: 18994 +/* 14615 */ MCD_OPC_CheckField, 26, 1, 1, 20, 17, 0, // Skip to: 18994 +/* 14622 */ MCD_OPC_Decode, 229, 96, 108, // Opcode: VAND_VI +/* 14626 */ MCD_OPC_FilterValue, 5, 31, 0, 0, // Skip to: 14662 +/* 14631 */ MCD_OPC_ExtractField, 26, 1, // Inst{26} ... +/* 14634 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 14648 +/* 14639 */ MCD_OPC_CheckPredicate, 10, 254, 16, 0, // Skip to: 18994 +/* 14644 */ MCD_OPC_Decode, 146, 100, 108, // Opcode: VOR_VI +/* 14648 */ MCD_OPC_FilterValue, 1, 245, 16, 0, // Skip to: 18994 +/* 14653 */ MCD_OPC_CheckPredicate, 10, 240, 16, 0, // Skip to: 18994 +/* 14658 */ MCD_OPC_Decode, 145, 102, 108, // Opcode: VXOR_VI +/* 14662 */ MCD_OPC_FilterValue, 6, 16, 0, 0, // Skip to: 14683 +/* 14667 */ MCD_OPC_CheckPredicate, 10, 226, 16, 0, // Skip to: 18994 +/* 14672 */ MCD_OPC_CheckField, 26, 1, 0, 219, 16, 0, // Skip to: 18994 +/* 14679 */ MCD_OPC_Decode, 171, 100, 109, // Opcode: VRGATHER_VI +/* 14683 */ MCD_OPC_FilterValue, 7, 31, 0, 0, // Skip to: 14719 +/* 14688 */ MCD_OPC_ExtractField, 26, 1, // Inst{26} ... +/* 14691 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 14705 +/* 14696 */ MCD_OPC_CheckPredicate, 10, 197, 16, 0, // Skip to: 18994 +/* 14701 */ MCD_OPC_Decode, 210, 100, 109, // Opcode: VSLIDEUP_VI +/* 14705 */ MCD_OPC_FilterValue, 1, 188, 16, 0, // Skip to: 18994 +/* 14710 */ MCD_OPC_CheckPredicate, 10, 183, 16, 0, // Skip to: 18994 +/* 14715 */ MCD_OPC_Decode, 208, 100, 109, // Opcode: VSLIDEDOWN_VI +/* 14719 */ MCD_OPC_FilterValue, 8, 45, 0, 0, // Skip to: 14769 +/* 14724 */ MCD_OPC_ExtractField, 25, 2, // Inst{26-25} ... +/* 14727 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 14741 +/* 14732 */ MCD_OPC_CheckPredicate, 10, 161, 16, 0, // Skip to: 18994 +/* 14737 */ MCD_OPC_Decode, 210, 96, 110, // Opcode: VADC_VIM +/* 14741 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 14755 +/* 14746 */ MCD_OPC_CheckPredicate, 10, 147, 16, 0, // Skip to: 18994 +/* 14751 */ MCD_OPC_Decode, 178, 99, 110, // Opcode: VMADC_VIM +/* 14755 */ MCD_OPC_FilterValue, 3, 138, 16, 0, // Skip to: 18994 +/* 14760 */ MCD_OPC_CheckPredicate, 10, 133, 16, 0, // Skip to: 18994 +/* 14765 */ MCD_OPC_Decode, 177, 99, 110, // Opcode: VMADC_VI +/* 14769 */ MCD_OPC_FilterValue, 10, 9, 0, 0, // Skip to: 14783 +/* 14774 */ MCD_OPC_CheckPredicate, 69, 119, 16, 0, // Skip to: 18994 +/* 14779 */ MCD_OPC_Decode, 176, 100, 111, // Opcode: VROR_VI +/* 14783 */ MCD_OPC_FilterValue, 11, 38, 0, 0, // Skip to: 14826 +/* 14788 */ MCD_OPC_ExtractField, 25, 2, // Inst{26-25} ... +/* 14791 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 14805 +/* 14796 */ MCD_OPC_CheckPredicate, 10, 97, 16, 0, // Skip to: 18994 +/* 14801 */ MCD_OPC_Decode, 191, 99, 110, // Opcode: VMERGE_VIM +/* 14805 */ MCD_OPC_FilterValue, 3, 88, 16, 0, // Skip to: 18994 +/* 14810 */ MCD_OPC_CheckPredicate, 10, 83, 16, 0, // Skip to: 18994 +/* 14815 */ MCD_OPC_CheckField, 20, 5, 0, 76, 16, 0, // Skip to: 18994 +/* 14822 */ MCD_OPC_Decode, 252, 99, 112, // Opcode: VMV_V_I +/* 14826 */ MCD_OPC_FilterValue, 12, 31, 0, 0, // Skip to: 14862 +/* 14831 */ MCD_OPC_ExtractField, 26, 1, // Inst{26} ... +/* 14834 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 14848 +/* 14839 */ MCD_OPC_CheckPredicate, 10, 54, 16, 0, // Skip to: 18994 +/* 14844 */ MCD_OPC_Decode, 217, 99, 108, // Opcode: VMSEQ_VI +/* 14848 */ MCD_OPC_FilterValue, 1, 45, 16, 0, // Skip to: 18994 +/* 14853 */ MCD_OPC_CheckPredicate, 10, 40, 16, 0, // Skip to: 18994 +/* 14858 */ MCD_OPC_Decode, 235, 99, 108, // Opcode: VMSNE_VI +/* 14862 */ MCD_OPC_FilterValue, 14, 31, 0, 0, // Skip to: 14898 +/* 14867 */ MCD_OPC_ExtractField, 26, 1, // Inst{26} ... +/* 14870 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 14884 +/* 14875 */ MCD_OPC_CheckPredicate, 10, 18, 16, 0, // Skip to: 18994 +/* 14880 */ MCD_OPC_Decode, 225, 99, 108, // Opcode: VMSLEU_VI +/* 14884 */ MCD_OPC_FilterValue, 1, 9, 16, 0, // Skip to: 18994 +/* 14889 */ MCD_OPC_CheckPredicate, 10, 4, 16, 0, // Skip to: 18994 +/* 14894 */ MCD_OPC_Decode, 228, 99, 108, // Opcode: VMSLE_VI +/* 14898 */ MCD_OPC_FilterValue, 15, 31, 0, 0, // Skip to: 14934 +/* 14903 */ MCD_OPC_ExtractField, 26, 1, // Inst{26} ... +/* 14906 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 14920 +/* 14911 */ MCD_OPC_CheckPredicate, 10, 238, 15, 0, // Skip to: 18994 +/* 14916 */ MCD_OPC_Decode, 220, 99, 108, // Opcode: VMSGTU_VI +/* 14920 */ MCD_OPC_FilterValue, 1, 229, 15, 0, // Skip to: 18994 +/* 14925 */ MCD_OPC_CheckPredicate, 10, 224, 15, 0, // Skip to: 18994 +/* 14930 */ MCD_OPC_Decode, 222, 99, 108, // Opcode: VMSGT_VI +/* 14934 */ MCD_OPC_FilterValue, 16, 31, 0, 0, // Skip to: 14970 +/* 14939 */ MCD_OPC_ExtractField, 26, 1, // Inst{26} ... +/* 14942 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 14956 +/* 14947 */ MCD_OPC_CheckPredicate, 10, 202, 15, 0, // Skip to: 18994 +/* 14952 */ MCD_OPC_Decode, 185, 100, 108, // Opcode: VSADDU_VI +/* 14956 */ MCD_OPC_FilterValue, 1, 193, 15, 0, // Skip to: 18994 +/* 14961 */ MCD_OPC_CheckPredicate, 10, 188, 15, 0, // Skip to: 18994 +/* 14966 */ MCD_OPC_Decode, 188, 100, 108, // Opcode: VSADD_VI +/* 14970 */ MCD_OPC_FilterValue, 18, 16, 0, 0, // Skip to: 14991 +/* 14975 */ MCD_OPC_CheckPredicate, 10, 174, 15, 0, // Skip to: 18994 +/* 14980 */ MCD_OPC_CheckField, 26, 1, 1, 167, 15, 0, // Skip to: 18994 +/* 14987 */ MCD_OPC_Decode, 212, 100, 109, // Opcode: VSLL_VI +/* 14991 */ MCD_OPC_FilterValue, 19, 87, 0, 0, // Skip to: 15083 +/* 14996 */ MCD_OPC_ExtractField, 15, 5, // Inst{19-15} ... +/* 14999 */ MCD_OPC_FilterValue, 0, 16, 0, 0, // Skip to: 15020 +/* 15004 */ MCD_OPC_CheckPredicate, 10, 145, 15, 0, // Skip to: 18994 +/* 15009 */ MCD_OPC_CheckField, 25, 2, 3, 138, 15, 0, // Skip to: 18994 +/* 15016 */ MCD_OPC_Decode, 247, 99, 113, // Opcode: VMV1R_V +/* 15020 */ MCD_OPC_FilterValue, 1, 16, 0, 0, // Skip to: 15041 +/* 15025 */ MCD_OPC_CheckPredicate, 10, 124, 15, 0, // Skip to: 18994 +/* 15030 */ MCD_OPC_CheckField, 25, 2, 3, 117, 15, 0, // Skip to: 18994 +/* 15037 */ MCD_OPC_Decode, 248, 99, 114, // Opcode: VMV2R_V +/* 15041 */ MCD_OPC_FilterValue, 3, 16, 0, 0, // Skip to: 15062 +/* 15046 */ MCD_OPC_CheckPredicate, 10, 103, 15, 0, // Skip to: 18994 +/* 15051 */ MCD_OPC_CheckField, 25, 2, 3, 96, 15, 0, // Skip to: 18994 +/* 15058 */ MCD_OPC_Decode, 249, 99, 115, // Opcode: VMV4R_V +/* 15062 */ MCD_OPC_FilterValue, 7, 87, 15, 0, // Skip to: 18994 +/* 15067 */ MCD_OPC_CheckPredicate, 10, 82, 15, 0, // Skip to: 18994 +/* 15072 */ MCD_OPC_CheckField, 25, 2, 3, 75, 15, 0, // Skip to: 18994 +/* 15079 */ MCD_OPC_Decode, 250, 99, 116, // Opcode: VMV8R_V +/* 15083 */ MCD_OPC_FilterValue, 20, 31, 0, 0, // Skip to: 15119 +/* 15088 */ MCD_OPC_ExtractField, 26, 1, // Inst{26} ... +/* 15091 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 15105 +/* 15096 */ MCD_OPC_CheckPredicate, 10, 53, 15, 0, // Skip to: 18994 +/* 15101 */ MCD_OPC_Decode, 130, 101, 109, // Opcode: VSRL_VI +/* 15105 */ MCD_OPC_FilterValue, 1, 44, 15, 0, // Skip to: 18994 +/* 15110 */ MCD_OPC_CheckPredicate, 10, 39, 15, 0, // Skip to: 18994 +/* 15115 */ MCD_OPC_Decode, 255, 100, 109, // Opcode: VSRA_VI +/* 15119 */ MCD_OPC_FilterValue, 21, 31, 0, 0, // Skip to: 15155 +/* 15124 */ MCD_OPC_ExtractField, 26, 1, // Inst{26} ... +/* 15127 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 15141 +/* 15132 */ MCD_OPC_CheckPredicate, 10, 17, 15, 0, // Skip to: 18994 +/* 15137 */ MCD_OPC_Decode, 168, 101, 109, // Opcode: VSSRL_VI +/* 15141 */ MCD_OPC_FilterValue, 1, 8, 15, 0, // Skip to: 18994 +/* 15146 */ MCD_OPC_CheckPredicate, 10, 3, 15, 0, // Skip to: 18994 +/* 15151 */ MCD_OPC_Decode, 165, 101, 109, // Opcode: VSSRA_VI +/* 15155 */ MCD_OPC_FilterValue, 22, 31, 0, 0, // Skip to: 15191 +/* 15160 */ MCD_OPC_ExtractField, 26, 1, // Inst{26} ... +/* 15163 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 15177 +/* 15168 */ MCD_OPC_CheckPredicate, 10, 237, 14, 0, // Skip to: 18994 +/* 15173 */ MCD_OPC_Decode, 143, 100, 109, // Opcode: VNSRL_WI +/* 15177 */ MCD_OPC_FilterValue, 1, 228, 14, 0, // Skip to: 18994 +/* 15182 */ MCD_OPC_CheckPredicate, 10, 223, 14, 0, // Skip to: 18994 +/* 15187 */ MCD_OPC_Decode, 140, 100, 109, // Opcode: VNSRA_WI +/* 15191 */ MCD_OPC_FilterValue, 23, 31, 0, 0, // Skip to: 15227 +/* 15196 */ MCD_OPC_ExtractField, 26, 1, // Inst{26} ... +/* 15199 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 15213 +/* 15204 */ MCD_OPC_CheckPredicate, 10, 201, 14, 0, // Skip to: 18994 +/* 15209 */ MCD_OPC_Decode, 130, 100, 109, // Opcode: VNCLIPU_WI +/* 15213 */ MCD_OPC_FilterValue, 1, 192, 14, 0, // Skip to: 18994 +/* 15218 */ MCD_OPC_CheckPredicate, 10, 187, 14, 0, // Skip to: 18994 +/* 15223 */ MCD_OPC_Decode, 133, 100, 109, // Opcode: VNCLIP_WI +/* 15227 */ MCD_OPC_FilterValue, 26, 178, 14, 0, // Skip to: 18994 +/* 15232 */ MCD_OPC_CheckPredicate, 70, 173, 14, 0, // Skip to: 18994 +/* 15237 */ MCD_OPC_CheckField, 26, 1, 1, 166, 14, 0, // Skip to: 18994 +/* 15244 */ MCD_OPC_Decode, 134, 102, 109, // Opcode: VWSLL_VI +/* 15248 */ MCD_OPC_FilterValue, 4, 194, 2, 0, // Skip to: 15959 +/* 15253 */ MCD_OPC_ExtractField, 26, 6, // Inst{31-26} ... +/* 15256 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 15270 +/* 15261 */ MCD_OPC_CheckPredicate, 10, 144, 14, 0, // Skip to: 18994 +/* 15266 */ MCD_OPC_Decode, 215, 96, 117, // Opcode: VADD_VX +/* 15270 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 15284 +/* 15275 */ MCD_OPC_CheckPredicate, 69, 130, 14, 0, // Skip to: 18994 +/* 15280 */ MCD_OPC_Decode, 228, 96, 117, // Opcode: VANDN_VX +/* 15284 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 15298 +/* 15289 */ MCD_OPC_CheckPredicate, 10, 116, 14, 0, // Skip to: 18994 +/* 15294 */ MCD_OPC_Decode, 204, 101, 117, // Opcode: VSUB_VX +/* 15298 */ MCD_OPC_FilterValue, 3, 9, 0, 0, // Skip to: 15312 +/* 15303 */ MCD_OPC_CheckPredicate, 10, 102, 14, 0, // Skip to: 18994 +/* 15308 */ MCD_OPC_Decode, 180, 100, 117, // Opcode: VRSUB_VX +/* 15312 */ MCD_OPC_FilterValue, 4, 9, 0, 0, // Skip to: 15326 +/* 15317 */ MCD_OPC_CheckPredicate, 10, 88, 14, 0, // Skip to: 18994 +/* 15322 */ MCD_OPC_Decode, 205, 99, 117, // Opcode: VMINU_VX +/* 15326 */ MCD_OPC_FilterValue, 5, 9, 0, 0, // Skip to: 15340 +/* 15331 */ MCD_OPC_CheckPredicate, 10, 74, 14, 0, // Skip to: 18994 +/* 15336 */ MCD_OPC_Decode, 207, 99, 117, // Opcode: VMIN_VX +/* 15340 */ MCD_OPC_FilterValue, 6, 9, 0, 0, // Skip to: 15354 +/* 15345 */ MCD_OPC_CheckPredicate, 10, 60, 14, 0, // Skip to: 18994 +/* 15350 */ MCD_OPC_Decode, 188, 99, 117, // Opcode: VMAXU_VX +/* 15354 */ MCD_OPC_FilterValue, 7, 9, 0, 0, // Skip to: 15368 +/* 15359 */ MCD_OPC_CheckPredicate, 10, 46, 14, 0, // Skip to: 18994 +/* 15364 */ MCD_OPC_Decode, 190, 99, 117, // Opcode: VMAX_VX +/* 15368 */ MCD_OPC_FilterValue, 9, 9, 0, 0, // Skip to: 15382 +/* 15373 */ MCD_OPC_CheckPredicate, 10, 32, 14, 0, // Skip to: 18994 +/* 15378 */ MCD_OPC_Decode, 231, 96, 117, // Opcode: VAND_VX +/* 15382 */ MCD_OPC_FilterValue, 10, 9, 0, 0, // Skip to: 15396 +/* 15387 */ MCD_OPC_CheckPredicate, 10, 18, 14, 0, // Skip to: 18994 +/* 15392 */ MCD_OPC_Decode, 148, 100, 117, // Opcode: VOR_VX +/* 15396 */ MCD_OPC_FilterValue, 11, 9, 0, 0, // Skip to: 15410 +/* 15401 */ MCD_OPC_CheckPredicate, 10, 4, 14, 0, // Skip to: 18994 +/* 15406 */ MCD_OPC_Decode, 147, 102, 117, // Opcode: VXOR_VX +/* 15410 */ MCD_OPC_FilterValue, 12, 9, 0, 0, // Skip to: 15424 +/* 15415 */ MCD_OPC_CheckPredicate, 10, 246, 13, 0, // Skip to: 18994 +/* 15420 */ MCD_OPC_Decode, 173, 100, 117, // Opcode: VRGATHER_VX +/* 15424 */ MCD_OPC_FilterValue, 14, 9, 0, 0, // Skip to: 15438 +/* 15429 */ MCD_OPC_CheckPredicate, 10, 232, 13, 0, // Skip to: 18994 +/* 15434 */ MCD_OPC_Decode, 211, 100, 117, // Opcode: VSLIDEUP_VX +/* 15438 */ MCD_OPC_FilterValue, 15, 9, 0, 0, // Skip to: 15452 +/* 15443 */ MCD_OPC_CheckPredicate, 10, 218, 13, 0, // Skip to: 18994 +/* 15448 */ MCD_OPC_Decode, 209, 100, 117, // Opcode: VSLIDEDOWN_VX +/* 15452 */ MCD_OPC_FilterValue, 16, 16, 0, 0, // Skip to: 15473 +/* 15457 */ MCD_OPC_CheckPredicate, 10, 204, 13, 0, // Skip to: 18994 +/* 15462 */ MCD_OPC_CheckField, 25, 1, 0, 197, 13, 0, // Skip to: 18994 +/* 15469 */ MCD_OPC_Decode, 212, 96, 118, // Opcode: VADC_VXM +/* 15473 */ MCD_OPC_FilterValue, 17, 31, 0, 0, // Skip to: 15509 +/* 15478 */ MCD_OPC_ExtractField, 25, 1, // Inst{25} ... +/* 15481 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 15495 +/* 15486 */ MCD_OPC_CheckPredicate, 10, 175, 13, 0, // Skip to: 18994 +/* 15491 */ MCD_OPC_Decode, 182, 99, 118, // Opcode: VMADC_VXM +/* 15495 */ MCD_OPC_FilterValue, 1, 166, 13, 0, // Skip to: 18994 +/* 15500 */ MCD_OPC_CheckPredicate, 10, 161, 13, 0, // Skip to: 18994 +/* 15505 */ MCD_OPC_Decode, 181, 99, 118, // Opcode: VMADC_VX +/* 15509 */ MCD_OPC_FilterValue, 18, 16, 0, 0, // Skip to: 15530 +/* 15514 */ MCD_OPC_CheckPredicate, 10, 147, 13, 0, // Skip to: 18994 +/* 15519 */ MCD_OPC_CheckField, 25, 1, 0, 140, 13, 0, // Skip to: 18994 +/* 15526 */ MCD_OPC_Decode, 192, 100, 118, // Opcode: VSBC_VXM +/* 15530 */ MCD_OPC_FilterValue, 19, 31, 0, 0, // Skip to: 15566 +/* 15535 */ MCD_OPC_ExtractField, 25, 1, // Inst{25} ... +/* 15538 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 15552 +/* 15543 */ MCD_OPC_CheckPredicate, 10, 118, 13, 0, // Skip to: 18994 +/* 15548 */ MCD_OPC_Decode, 215, 99, 118, // Opcode: VMSBC_VXM +/* 15552 */ MCD_OPC_FilterValue, 1, 109, 13, 0, // Skip to: 18994 +/* 15557 */ MCD_OPC_CheckPredicate, 10, 104, 13, 0, // Skip to: 18994 +/* 15562 */ MCD_OPC_Decode, 214, 99, 118, // Opcode: VMSBC_VX +/* 15566 */ MCD_OPC_FilterValue, 20, 9, 0, 0, // Skip to: 15580 +/* 15571 */ MCD_OPC_CheckPredicate, 69, 90, 13, 0, // Skip to: 18994 +/* 15576 */ MCD_OPC_Decode, 178, 100, 117, // Opcode: VROR_VX +/* 15580 */ MCD_OPC_FilterValue, 21, 9, 0, 0, // Skip to: 15594 +/* 15585 */ MCD_OPC_CheckPredicate, 69, 76, 13, 0, // Skip to: 18994 +/* 15590 */ MCD_OPC_Decode, 175, 100, 117, // Opcode: VROL_VX +/* 15594 */ MCD_OPC_FilterValue, 23, 38, 0, 0, // Skip to: 15637 +/* 15599 */ MCD_OPC_ExtractField, 25, 1, // Inst{25} ... +/* 15602 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 15616 +/* 15607 */ MCD_OPC_CheckPredicate, 10, 54, 13, 0, // Skip to: 18994 +/* 15612 */ MCD_OPC_Decode, 193, 99, 118, // Opcode: VMERGE_VXM +/* 15616 */ MCD_OPC_FilterValue, 1, 45, 13, 0, // Skip to: 18994 +/* 15621 */ MCD_OPC_CheckPredicate, 10, 40, 13, 0, // Skip to: 18994 +/* 15626 */ MCD_OPC_CheckField, 20, 5, 0, 33, 13, 0, // Skip to: 18994 +/* 15633 */ MCD_OPC_Decode, 254, 99, 37, // Opcode: VMV_V_X +/* 15637 */ MCD_OPC_FilterValue, 24, 9, 0, 0, // Skip to: 15651 +/* 15642 */ MCD_OPC_CheckPredicate, 10, 19, 13, 0, // Skip to: 18994 +/* 15647 */ MCD_OPC_Decode, 219, 99, 117, // Opcode: VMSEQ_VX +/* 15651 */ MCD_OPC_FilterValue, 25, 9, 0, 0, // Skip to: 15665 +/* 15656 */ MCD_OPC_CheckPredicate, 10, 5, 13, 0, // Skip to: 18994 +/* 15661 */ MCD_OPC_Decode, 237, 99, 117, // Opcode: VMSNE_VX +/* 15665 */ MCD_OPC_FilterValue, 26, 9, 0, 0, // Skip to: 15679 +/* 15670 */ MCD_OPC_CheckPredicate, 10, 247, 12, 0, // Skip to: 18994 +/* 15675 */ MCD_OPC_Decode, 232, 99, 117, // Opcode: VMSLTU_VX +/* 15679 */ MCD_OPC_FilterValue, 27, 9, 0, 0, // Skip to: 15693 +/* 15684 */ MCD_OPC_CheckPredicate, 10, 233, 12, 0, // Skip to: 18994 +/* 15689 */ MCD_OPC_Decode, 234, 99, 117, // Opcode: VMSLT_VX +/* 15693 */ MCD_OPC_FilterValue, 28, 9, 0, 0, // Skip to: 15707 +/* 15698 */ MCD_OPC_CheckPredicate, 10, 219, 12, 0, // Skip to: 18994 +/* 15703 */ MCD_OPC_Decode, 227, 99, 117, // Opcode: VMSLEU_VX +/* 15707 */ MCD_OPC_FilterValue, 29, 9, 0, 0, // Skip to: 15721 +/* 15712 */ MCD_OPC_CheckPredicate, 10, 205, 12, 0, // Skip to: 18994 +/* 15717 */ MCD_OPC_Decode, 230, 99, 117, // Opcode: VMSLE_VX +/* 15721 */ MCD_OPC_FilterValue, 30, 9, 0, 0, // Skip to: 15735 +/* 15726 */ MCD_OPC_CheckPredicate, 10, 191, 12, 0, // Skip to: 18994 +/* 15731 */ MCD_OPC_Decode, 221, 99, 117, // Opcode: VMSGTU_VX +/* 15735 */ MCD_OPC_FilterValue, 31, 9, 0, 0, // Skip to: 15749 +/* 15740 */ MCD_OPC_CheckPredicate, 10, 177, 12, 0, // Skip to: 18994 +/* 15745 */ MCD_OPC_Decode, 223, 99, 117, // Opcode: VMSGT_VX +/* 15749 */ MCD_OPC_FilterValue, 32, 9, 0, 0, // Skip to: 15763 +/* 15754 */ MCD_OPC_CheckPredicate, 10, 163, 12, 0, // Skip to: 18994 +/* 15759 */ MCD_OPC_Decode, 187, 100, 117, // Opcode: VSADDU_VX +/* 15763 */ MCD_OPC_FilterValue, 33, 9, 0, 0, // Skip to: 15777 +/* 15768 */ MCD_OPC_CheckPredicate, 10, 149, 12, 0, // Skip to: 18994 +/* 15773 */ MCD_OPC_Decode, 190, 100, 117, // Opcode: VSADD_VX +/* 15777 */ MCD_OPC_FilterValue, 34, 9, 0, 0, // Skip to: 15791 +/* 15782 */ MCD_OPC_CheckPredicate, 10, 135, 12, 0, // Skip to: 18994 +/* 15787 */ MCD_OPC_Decode, 200, 101, 117, // Opcode: VSSUBU_VX +/* 15791 */ MCD_OPC_FilterValue, 35, 9, 0, 0, // Skip to: 15805 +/* 15796 */ MCD_OPC_CheckPredicate, 10, 121, 12, 0, // Skip to: 18994 +/* 15801 */ MCD_OPC_Decode, 202, 101, 117, // Opcode: VSSUB_VX +/* 15805 */ MCD_OPC_FilterValue, 37, 9, 0, 0, // Skip to: 15819 +/* 15810 */ MCD_OPC_CheckPredicate, 10, 107, 12, 0, // Skip to: 18994 +/* 15815 */ MCD_OPC_Decode, 214, 100, 117, // Opcode: VSLL_VX +/* 15819 */ MCD_OPC_FilterValue, 39, 9, 0, 0, // Skip to: 15833 +/* 15824 */ MCD_OPC_CheckPredicate, 10, 93, 12, 0, // Skip to: 18994 +/* 15829 */ MCD_OPC_Decode, 221, 100, 117, // Opcode: VSMUL_VX +/* 15833 */ MCD_OPC_FilterValue, 40, 9, 0, 0, // Skip to: 15847 +/* 15838 */ MCD_OPC_CheckPredicate, 10, 79, 12, 0, // Skip to: 18994 +/* 15843 */ MCD_OPC_Decode, 132, 101, 117, // Opcode: VSRL_VX +/* 15847 */ MCD_OPC_FilterValue, 41, 9, 0, 0, // Skip to: 15861 +/* 15852 */ MCD_OPC_CheckPredicate, 10, 65, 12, 0, // Skip to: 18994 +/* 15857 */ MCD_OPC_Decode, 129, 101, 117, // Opcode: VSRA_VX +/* 15861 */ MCD_OPC_FilterValue, 42, 9, 0, 0, // Skip to: 15875 +/* 15866 */ MCD_OPC_CheckPredicate, 10, 51, 12, 0, // Skip to: 18994 +/* 15871 */ MCD_OPC_Decode, 170, 101, 117, // Opcode: VSSRL_VX +/* 15875 */ MCD_OPC_FilterValue, 43, 9, 0, 0, // Skip to: 15889 +/* 15880 */ MCD_OPC_CheckPredicate, 10, 37, 12, 0, // Skip to: 18994 +/* 15885 */ MCD_OPC_Decode, 167, 101, 117, // Opcode: VSSRA_VX +/* 15889 */ MCD_OPC_FilterValue, 44, 9, 0, 0, // Skip to: 15903 +/* 15894 */ MCD_OPC_CheckPredicate, 10, 23, 12, 0, // Skip to: 18994 +/* 15899 */ MCD_OPC_Decode, 145, 100, 117, // Opcode: VNSRL_WX +/* 15903 */ MCD_OPC_FilterValue, 45, 9, 0, 0, // Skip to: 15917 +/* 15908 */ MCD_OPC_CheckPredicate, 10, 9, 12, 0, // Skip to: 18994 +/* 15913 */ MCD_OPC_Decode, 142, 100, 117, // Opcode: VNSRA_WX +/* 15917 */ MCD_OPC_FilterValue, 46, 9, 0, 0, // Skip to: 15931 +/* 15922 */ MCD_OPC_CheckPredicate, 10, 251, 11, 0, // Skip to: 18994 +/* 15927 */ MCD_OPC_Decode, 132, 100, 117, // Opcode: VNCLIPU_WX +/* 15931 */ MCD_OPC_FilterValue, 47, 9, 0, 0, // Skip to: 15945 +/* 15936 */ MCD_OPC_CheckPredicate, 10, 237, 11, 0, // Skip to: 18994 +/* 15941 */ MCD_OPC_Decode, 135, 100, 117, // Opcode: VNCLIP_WX +/* 15945 */ MCD_OPC_FilterValue, 53, 228, 11, 0, // Skip to: 18994 +/* 15950 */ MCD_OPC_CheckPredicate, 70, 223, 11, 0, // Skip to: 18994 +/* 15955 */ MCD_OPC_Decode, 136, 102, 117, // Opcode: VWSLL_VX +/* 15959 */ MCD_OPC_FilterValue, 5, 73, 2, 0, // Skip to: 16549 +/* 15964 */ MCD_OPC_ExtractField, 26, 6, // Inst{31-26} ... +/* 15967 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 15981 +/* 15972 */ MCD_OPC_CheckPredicate, 71, 201, 11, 0, // Skip to: 18994 +/* 15977 */ MCD_OPC_Decode, 151, 97, 119, // Opcode: VFADD_VF +/* 15981 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 15995 +/* 15986 */ MCD_OPC_CheckPredicate, 71, 187, 11, 0, // Skip to: 18994 +/* 15991 */ MCD_OPC_Decode, 217, 97, 119, // Opcode: VFSUB_VF +/* 15995 */ MCD_OPC_FilterValue, 4, 9, 0, 0, // Skip to: 16009 +/* 16000 */ MCD_OPC_CheckPredicate, 71, 173, 11, 0, // Skip to: 18994 +/* 16005 */ MCD_OPC_Decode, 170, 97, 119, // Opcode: VFMIN_VF +/* 16009 */ MCD_OPC_FilterValue, 6, 9, 0, 0, // Skip to: 16023 +/* 16014 */ MCD_OPC_CheckPredicate, 71, 159, 11, 0, // Skip to: 18994 +/* 16019 */ MCD_OPC_Decode, 167, 97, 119, // Opcode: VFMAX_VF +/* 16023 */ MCD_OPC_FilterValue, 8, 9, 0, 0, // Skip to: 16037 +/* 16028 */ MCD_OPC_CheckPredicate, 71, 145, 11, 0, // Skip to: 18994 +/* 16033 */ MCD_OPC_Decode, 212, 97, 119, // Opcode: VFSGNJ_VF +/* 16037 */ MCD_OPC_FilterValue, 9, 9, 0, 0, // Skip to: 16051 +/* 16042 */ MCD_OPC_CheckPredicate, 71, 131, 11, 0, // Skip to: 18994 +/* 16047 */ MCD_OPC_Decode, 208, 97, 119, // Opcode: VFSGNJN_VF +/* 16051 */ MCD_OPC_FilterValue, 10, 9, 0, 0, // Skip to: 16065 +/* 16056 */ MCD_OPC_CheckPredicate, 71, 117, 11, 0, // Skip to: 18994 +/* 16061 */ MCD_OPC_Decode, 210, 97, 119, // Opcode: VFSGNJX_VF +/* 16065 */ MCD_OPC_FilterValue, 14, 9, 0, 0, // Skip to: 16079 +/* 16070 */ MCD_OPC_CheckPredicate, 71, 103, 11, 0, // Skip to: 18994 +/* 16075 */ MCD_OPC_Decode, 215, 97, 119, // Opcode: VFSLIDE1UP_VF +/* 16079 */ MCD_OPC_FilterValue, 15, 9, 0, 0, // Skip to: 16093 +/* 16084 */ MCD_OPC_CheckPredicate, 71, 89, 11, 0, // Skip to: 18994 +/* 16089 */ MCD_OPC_Decode, 214, 97, 119, // Opcode: VFSLIDE1DOWN_VF +/* 16093 */ MCD_OPC_FilterValue, 16, 16, 0, 0, // Skip to: 16114 +/* 16098 */ MCD_OPC_CheckPredicate, 71, 75, 11, 0, // Skip to: 18994 +/* 16103 */ MCD_OPC_CheckField, 20, 6, 32, 68, 11, 0, // Skip to: 18994 +/* 16110 */ MCD_OPC_Decode, 179, 97, 120, // Opcode: VFMV_S_F +/* 16114 */ MCD_OPC_FilterValue, 23, 38, 0, 0, // Skip to: 16157 +/* 16119 */ MCD_OPC_ExtractField, 25, 1, // Inst{25} ... +/* 16122 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 16136 +/* 16127 */ MCD_OPC_CheckPredicate, 71, 46, 11, 0, // Skip to: 18994 +/* 16132 */ MCD_OPC_Decode, 169, 97, 121, // Opcode: VFMERGE_VFM +/* 16136 */ MCD_OPC_FilterValue, 1, 37, 11, 0, // Skip to: 18994 +/* 16141 */ MCD_OPC_CheckPredicate, 71, 32, 11, 0, // Skip to: 18994 +/* 16146 */ MCD_OPC_CheckField, 20, 5, 0, 25, 11, 0, // Skip to: 18994 +/* 16153 */ MCD_OPC_Decode, 180, 97, 122, // Opcode: VFMV_V_F +/* 16157 */ MCD_OPC_FilterValue, 24, 9, 0, 0, // Skip to: 16171 +/* 16162 */ MCD_OPC_CheckPredicate, 71, 11, 11, 0, // Skip to: 18994 +/* 16167 */ MCD_OPC_Decode, 194, 99, 119, // Opcode: VMFEQ_VF +/* 16171 */ MCD_OPC_FilterValue, 25, 9, 0, 0, // Skip to: 16185 +/* 16176 */ MCD_OPC_CheckPredicate, 71, 253, 10, 0, // Skip to: 18994 +/* 16181 */ MCD_OPC_Decode, 198, 99, 119, // Opcode: VMFLE_VF +/* 16185 */ MCD_OPC_FilterValue, 27, 9, 0, 0, // Skip to: 16199 +/* 16190 */ MCD_OPC_CheckPredicate, 71, 239, 10, 0, // Skip to: 18994 +/* 16195 */ MCD_OPC_Decode, 200, 99, 119, // Opcode: VMFLT_VF +/* 16199 */ MCD_OPC_FilterValue, 28, 9, 0, 0, // Skip to: 16213 +/* 16204 */ MCD_OPC_CheckPredicate, 71, 225, 10, 0, // Skip to: 18994 +/* 16209 */ MCD_OPC_Decode, 202, 99, 119, // Opcode: VMFNE_VF +/* 16213 */ MCD_OPC_FilterValue, 29, 9, 0, 0, // Skip to: 16227 +/* 16218 */ MCD_OPC_CheckPredicate, 71, 211, 10, 0, // Skip to: 18994 +/* 16223 */ MCD_OPC_Decode, 197, 99, 119, // Opcode: VMFGT_VF +/* 16227 */ MCD_OPC_FilterValue, 31, 9, 0, 0, // Skip to: 16241 +/* 16232 */ MCD_OPC_CheckPredicate, 71, 197, 10, 0, // Skip to: 18994 +/* 16237 */ MCD_OPC_Decode, 196, 99, 119, // Opcode: VMFGE_VF +/* 16241 */ MCD_OPC_FilterValue, 32, 9, 0, 0, // Skip to: 16255 +/* 16246 */ MCD_OPC_CheckPredicate, 71, 183, 10, 0, // Skip to: 18994 +/* 16251 */ MCD_OPC_Decode, 160, 97, 119, // Opcode: VFDIV_VF +/* 16255 */ MCD_OPC_FilterValue, 33, 9, 0, 0, // Skip to: 16269 +/* 16260 */ MCD_OPC_CheckPredicate, 71, 169, 10, 0, // Skip to: 18994 +/* 16265 */ MCD_OPC_Decode, 200, 97, 119, // Opcode: VFRDIV_VF +/* 16269 */ MCD_OPC_FilterValue, 36, 9, 0, 0, // Skip to: 16283 +/* 16274 */ MCD_OPC_CheckPredicate, 71, 155, 10, 0, // Skip to: 18994 +/* 16279 */ MCD_OPC_Decode, 176, 97, 119, // Opcode: VFMUL_VF +/* 16283 */ MCD_OPC_FilterValue, 39, 9, 0, 0, // Skip to: 16297 +/* 16288 */ MCD_OPC_CheckPredicate, 71, 141, 10, 0, // Skip to: 18994 +/* 16293 */ MCD_OPC_Decode, 207, 97, 119, // Opcode: VFRSUB_VF +/* 16297 */ MCD_OPC_FilterValue, 40, 9, 0, 0, // Skip to: 16311 +/* 16302 */ MCD_OPC_CheckPredicate, 71, 127, 10, 0, // Skip to: 18994 +/* 16307 */ MCD_OPC_Decode, 165, 97, 123, // Opcode: VFMADD_VF +/* 16311 */ MCD_OPC_FilterValue, 41, 9, 0, 0, // Skip to: 16325 +/* 16316 */ MCD_OPC_CheckPredicate, 71, 113, 10, 0, // Skip to: 18994 +/* 16321 */ MCD_OPC_Decode, 192, 97, 123, // Opcode: VFNMADD_VF +/* 16325 */ MCD_OPC_FilterValue, 42, 9, 0, 0, // Skip to: 16339 +/* 16330 */ MCD_OPC_CheckPredicate, 71, 99, 10, 0, // Skip to: 18994 +/* 16335 */ MCD_OPC_Decode, 174, 97, 123, // Opcode: VFMSUB_VF +/* 16339 */ MCD_OPC_FilterValue, 43, 9, 0, 0, // Skip to: 16353 +/* 16344 */ MCD_OPC_CheckPredicate, 71, 85, 10, 0, // Skip to: 18994 +/* 16349 */ MCD_OPC_Decode, 196, 97, 123, // Opcode: VFNMSUB_VF +/* 16353 */ MCD_OPC_FilterValue, 44, 9, 0, 0, // Skip to: 16367 +/* 16358 */ MCD_OPC_CheckPredicate, 71, 71, 10, 0, // Skip to: 18994 +/* 16363 */ MCD_OPC_Decode, 163, 97, 123, // Opcode: VFMACC_VF +/* 16367 */ MCD_OPC_FilterValue, 45, 9, 0, 0, // Skip to: 16381 +/* 16372 */ MCD_OPC_CheckPredicate, 71, 57, 10, 0, // Skip to: 18994 +/* 16377 */ MCD_OPC_Decode, 190, 97, 123, // Opcode: VFNMACC_VF +/* 16381 */ MCD_OPC_FilterValue, 46, 9, 0, 0, // Skip to: 16395 +/* 16386 */ MCD_OPC_CheckPredicate, 71, 43, 10, 0, // Skip to: 18994 +/* 16391 */ MCD_OPC_Decode, 172, 97, 123, // Opcode: VFMSAC_VF +/* 16395 */ MCD_OPC_FilterValue, 47, 9, 0, 0, // Skip to: 16409 +/* 16400 */ MCD_OPC_CheckPredicate, 71, 29, 10, 0, // Skip to: 18994 +/* 16405 */ MCD_OPC_Decode, 194, 97, 123, // Opcode: VFNMSAC_VF +/* 16409 */ MCD_OPC_FilterValue, 48, 9, 0, 0, // Skip to: 16423 +/* 16414 */ MCD_OPC_CheckPredicate, 71, 15, 10, 0, // Skip to: 18994 +/* 16419 */ MCD_OPC_Decode, 219, 97, 119, // Opcode: VFWADD_VF +/* 16423 */ MCD_OPC_FilterValue, 50, 9, 0, 0, // Skip to: 16437 +/* 16428 */ MCD_OPC_CheckPredicate, 71, 1, 10, 0, // Skip to: 18994 +/* 16433 */ MCD_OPC_Decode, 246, 97, 119, // Opcode: VFWSUB_VF +/* 16437 */ MCD_OPC_FilterValue, 52, 9, 0, 0, // Skip to: 16451 +/* 16442 */ MCD_OPC_CheckPredicate, 71, 243, 9, 0, // Skip to: 18994 +/* 16447 */ MCD_OPC_Decode, 221, 97, 119, // Opcode: VFWADD_WF +/* 16451 */ MCD_OPC_FilterValue, 54, 9, 0, 0, // Skip to: 16465 +/* 16456 */ MCD_OPC_CheckPredicate, 71, 229, 9, 0, // Skip to: 18994 +/* 16461 */ MCD_OPC_Decode, 248, 97, 119, // Opcode: VFWSUB_WF +/* 16465 */ MCD_OPC_FilterValue, 56, 9, 0, 0, // Skip to: 16479 +/* 16470 */ MCD_OPC_CheckPredicate, 71, 215, 9, 0, // Skip to: 18994 +/* 16475 */ MCD_OPC_Decode, 238, 97, 119, // Opcode: VFWMUL_VF +/* 16479 */ MCD_OPC_FilterValue, 59, 9, 0, 0, // Skip to: 16493 +/* 16484 */ MCD_OPC_CheckPredicate, 73, 201, 9, 0, // Skip to: 18994 +/* 16489 */ MCD_OPC_Decode, 231, 97, 123, // Opcode: VFWMACCBF16_VF +/* 16493 */ MCD_OPC_FilterValue, 60, 9, 0, 0, // Skip to: 16507 +/* 16498 */ MCD_OPC_CheckPredicate, 71, 187, 9, 0, // Skip to: 18994 +/* 16503 */ MCD_OPC_Decode, 234, 97, 123, // Opcode: VFWMACC_VF +/* 16507 */ MCD_OPC_FilterValue, 61, 9, 0, 0, // Skip to: 16521 +/* 16512 */ MCD_OPC_CheckPredicate, 71, 173, 9, 0, // Skip to: 18994 +/* 16517 */ MCD_OPC_Decode, 240, 97, 123, // Opcode: VFWNMACC_VF +/* 16521 */ MCD_OPC_FilterValue, 62, 9, 0, 0, // Skip to: 16535 +/* 16526 */ MCD_OPC_CheckPredicate, 71, 159, 9, 0, // Skip to: 18994 +/* 16531 */ MCD_OPC_Decode, 236, 97, 123, // Opcode: VFWMSAC_VF +/* 16535 */ MCD_OPC_FilterValue, 63, 150, 9, 0, // Skip to: 18994 +/* 16540 */ MCD_OPC_CheckPredicate, 71, 145, 9, 0, // Skip to: 18994 +/* 16545 */ MCD_OPC_Decode, 242, 97, 123, // Opcode: VFWNMSAC_VF +/* 16549 */ MCD_OPC_FilterValue, 6, 2, 2, 0, // Skip to: 17068 +/* 16554 */ MCD_OPC_ExtractField, 26, 6, // Inst{31-26} ... +/* 16557 */ MCD_OPC_FilterValue, 8, 9, 0, 0, // Skip to: 16571 +/* 16562 */ MCD_OPC_CheckPredicate, 10, 123, 9, 0, // Skip to: 18994 +/* 16567 */ MCD_OPC_Decode, 207, 96, 117, // Opcode: VAADDU_VX +/* 16571 */ MCD_OPC_FilterValue, 9, 9, 0, 0, // Skip to: 16585 +/* 16576 */ MCD_OPC_CheckPredicate, 10, 109, 9, 0, // Skip to: 18994 +/* 16581 */ MCD_OPC_Decode, 209, 96, 117, // Opcode: VAADD_VX +/* 16585 */ MCD_OPC_FilterValue, 10, 9, 0, 0, // Skip to: 16599 +/* 16590 */ MCD_OPC_CheckPredicate, 10, 95, 9, 0, // Skip to: 18994 +/* 16595 */ MCD_OPC_Decode, 233, 96, 117, // Opcode: VASUBU_VX +/* 16599 */ MCD_OPC_FilterValue, 11, 9, 0, 0, // Skip to: 16613 +/* 16604 */ MCD_OPC_CheckPredicate, 10, 81, 9, 0, // Skip to: 18994 +/* 16609 */ MCD_OPC_Decode, 235, 96, 117, // Opcode: VASUB_VX +/* 16613 */ MCD_OPC_FilterValue, 12, 9, 0, 0, // Skip to: 16627 +/* 16618 */ MCD_OPC_CheckPredicate, 74, 67, 9, 0, // Skip to: 18994 +/* 16623 */ MCD_OPC_Decode, 241, 96, 117, // Opcode: VCLMUL_VX +/* 16627 */ MCD_OPC_FilterValue, 13, 9, 0, 0, // Skip to: 16641 +/* 16632 */ MCD_OPC_CheckPredicate, 74, 53, 9, 0, // Skip to: 18994 +/* 16637 */ MCD_OPC_Decode, 239, 96, 117, // Opcode: VCLMULH_VX +/* 16641 */ MCD_OPC_FilterValue, 14, 9, 0, 0, // Skip to: 16655 +/* 16646 */ MCD_OPC_CheckPredicate, 10, 39, 9, 0, // Skip to: 18994 +/* 16651 */ MCD_OPC_Decode, 207, 100, 117, // Opcode: VSLIDE1UP_VX +/* 16655 */ MCD_OPC_FilterValue, 15, 9, 0, 0, // Skip to: 16669 +/* 16660 */ MCD_OPC_CheckPredicate, 10, 25, 9, 0, // Skip to: 18994 +/* 16665 */ MCD_OPC_Decode, 206, 100, 117, // Opcode: VSLIDE1DOWN_VX +/* 16669 */ MCD_OPC_FilterValue, 16, 16, 0, 0, // Skip to: 16690 +/* 16674 */ MCD_OPC_CheckPredicate, 10, 11, 9, 0, // Skip to: 18994 +/* 16679 */ MCD_OPC_CheckField, 20, 6, 32, 4, 9, 0, // Skip to: 18994 +/* 16686 */ MCD_OPC_Decode, 251, 99, 124, // Opcode: VMV_S_X +/* 16690 */ MCD_OPC_FilterValue, 32, 9, 0, 0, // Skip to: 16704 +/* 16695 */ MCD_OPC_CheckPredicate, 10, 246, 8, 0, // Skip to: 18994 +/* 16700 */ MCD_OPC_Decode, 148, 97, 117, // Opcode: VDIVU_VX +/* 16704 */ MCD_OPC_FilterValue, 33, 9, 0, 0, // Skip to: 16718 +/* 16709 */ MCD_OPC_CheckPredicate, 10, 232, 8, 0, // Skip to: 18994 +/* 16714 */ MCD_OPC_Decode, 150, 97, 117, // Opcode: VDIV_VX +/* 16718 */ MCD_OPC_FilterValue, 34, 9, 0, 0, // Skip to: 16732 +/* 16723 */ MCD_OPC_CheckPredicate, 10, 218, 8, 0, // Skip to: 18994 +/* 16728 */ MCD_OPC_Decode, 166, 100, 117, // Opcode: VREMU_VX +/* 16732 */ MCD_OPC_FilterValue, 35, 9, 0, 0, // Skip to: 16746 +/* 16737 */ MCD_OPC_CheckPredicate, 10, 204, 8, 0, // Skip to: 18994 +/* 16742 */ MCD_OPC_Decode, 168, 100, 117, // Opcode: VREM_VX +/* 16746 */ MCD_OPC_FilterValue, 36, 9, 0, 0, // Skip to: 16760 +/* 16751 */ MCD_OPC_CheckPredicate, 10, 190, 8, 0, // Skip to: 18994 +/* 16756 */ MCD_OPC_Decode, 242, 99, 117, // Opcode: VMULHU_VX +/* 16760 */ MCD_OPC_FilterValue, 37, 9, 0, 0, // Skip to: 16774 +/* 16765 */ MCD_OPC_CheckPredicate, 10, 176, 8, 0, // Skip to: 18994 +/* 16770 */ MCD_OPC_Decode, 246, 99, 117, // Opcode: VMUL_VX +/* 16774 */ MCD_OPC_FilterValue, 38, 9, 0, 0, // Skip to: 16788 +/* 16779 */ MCD_OPC_CheckPredicate, 10, 162, 8, 0, // Skip to: 18994 +/* 16784 */ MCD_OPC_Decode, 240, 99, 117, // Opcode: VMULHSU_VX +/* 16788 */ MCD_OPC_FilterValue, 39, 9, 0, 0, // Skip to: 16802 +/* 16793 */ MCD_OPC_CheckPredicate, 10, 148, 8, 0, // Skip to: 18994 +/* 16798 */ MCD_OPC_Decode, 244, 99, 117, // Opcode: VMULH_VX +/* 16802 */ MCD_OPC_FilterValue, 41, 9, 0, 0, // Skip to: 16816 +/* 16807 */ MCD_OPC_CheckPredicate, 10, 134, 8, 0, // Skip to: 18994 +/* 16812 */ MCD_OPC_Decode, 184, 99, 125, // Opcode: VMADD_VX +/* 16816 */ MCD_OPC_FilterValue, 43, 9, 0, 0, // Skip to: 16830 +/* 16821 */ MCD_OPC_CheckPredicate, 10, 120, 8, 0, // Skip to: 18994 +/* 16826 */ MCD_OPC_Decode, 139, 100, 125, // Opcode: VNMSUB_VX +/* 16830 */ MCD_OPC_FilterValue, 45, 9, 0, 0, // Skip to: 16844 +/* 16835 */ MCD_OPC_CheckPredicate, 10, 106, 8, 0, // Skip to: 18994 +/* 16840 */ MCD_OPC_Decode, 176, 99, 125, // Opcode: VMACC_VX +/* 16844 */ MCD_OPC_FilterValue, 47, 9, 0, 0, // Skip to: 16858 +/* 16849 */ MCD_OPC_CheckPredicate, 10, 92, 8, 0, // Skip to: 18994 +/* 16854 */ MCD_OPC_Decode, 137, 100, 125, // Opcode: VNMSAC_VX +/* 16858 */ MCD_OPC_FilterValue, 48, 9, 0, 0, // Skip to: 16872 +/* 16863 */ MCD_OPC_CheckPredicate, 10, 78, 8, 0, // Skip to: 18994 +/* 16868 */ MCD_OPC_Decode, 240, 101, 117, // Opcode: VWADDU_VX +/* 16872 */ MCD_OPC_FilterValue, 49, 9, 0, 0, // Skip to: 16886 +/* 16877 */ MCD_OPC_CheckPredicate, 10, 64, 8, 0, // Skip to: 18994 +/* 16882 */ MCD_OPC_Decode, 244, 101, 117, // Opcode: VWADD_VX +/* 16886 */ MCD_OPC_FilterValue, 50, 9, 0, 0, // Skip to: 16900 +/* 16891 */ MCD_OPC_CheckPredicate, 10, 50, 8, 0, // Skip to: 18994 +/* 16896 */ MCD_OPC_Decode, 138, 102, 117, // Opcode: VWSUBU_VX +/* 16900 */ MCD_OPC_FilterValue, 51, 9, 0, 0, // Skip to: 16914 +/* 16905 */ MCD_OPC_CheckPredicate, 10, 36, 8, 0, // Skip to: 18994 +/* 16910 */ MCD_OPC_Decode, 142, 102, 117, // Opcode: VWSUB_VX +/* 16914 */ MCD_OPC_FilterValue, 52, 9, 0, 0, // Skip to: 16928 +/* 16919 */ MCD_OPC_CheckPredicate, 10, 22, 8, 0, // Skip to: 18994 +/* 16924 */ MCD_OPC_Decode, 242, 101, 117, // Opcode: VWADDU_WX +/* 16928 */ MCD_OPC_FilterValue, 53, 9, 0, 0, // Skip to: 16942 +/* 16933 */ MCD_OPC_CheckPredicate, 10, 8, 8, 0, // Skip to: 18994 +/* 16938 */ MCD_OPC_Decode, 246, 101, 117, // Opcode: VWADD_WX +/* 16942 */ MCD_OPC_FilterValue, 54, 9, 0, 0, // Skip to: 16956 +/* 16947 */ MCD_OPC_CheckPredicate, 10, 250, 7, 0, // Skip to: 18994 +/* 16952 */ MCD_OPC_Decode, 140, 102, 117, // Opcode: VWSUBU_WX +/* 16956 */ MCD_OPC_FilterValue, 55, 9, 0, 0, // Skip to: 16970 +/* 16961 */ MCD_OPC_CheckPredicate, 10, 236, 7, 0, // Skip to: 18994 +/* 16966 */ MCD_OPC_Decode, 144, 102, 117, // Opcode: VWSUB_WX +/* 16970 */ MCD_OPC_FilterValue, 56, 9, 0, 0, // Skip to: 16984 +/* 16975 */ MCD_OPC_CheckPredicate, 10, 222, 7, 0, // Skip to: 18994 +/* 16980 */ MCD_OPC_Decode, 129, 102, 117, // Opcode: VWMULU_VX +/* 16984 */ MCD_OPC_FilterValue, 58, 9, 0, 0, // Skip to: 16998 +/* 16989 */ MCD_OPC_CheckPredicate, 10, 208, 7, 0, // Skip to: 18994 +/* 16994 */ MCD_OPC_Decode, 255, 101, 117, // Opcode: VWMULSU_VX +/* 16998 */ MCD_OPC_FilterValue, 59, 9, 0, 0, // Skip to: 17012 +/* 17003 */ MCD_OPC_CheckPredicate, 10, 194, 7, 0, // Skip to: 18994 +/* 17008 */ MCD_OPC_Decode, 131, 102, 117, // Opcode: VWMUL_VX +/* 17012 */ MCD_OPC_FilterValue, 60, 9, 0, 0, // Skip to: 17026 +/* 17017 */ MCD_OPC_CheckPredicate, 10, 180, 7, 0, // Skip to: 18994 +/* 17022 */ MCD_OPC_Decode, 251, 101, 125, // Opcode: VWMACCU_VX +/* 17026 */ MCD_OPC_FilterValue, 61, 9, 0, 0, // Skip to: 17040 +/* 17031 */ MCD_OPC_CheckPredicate, 10, 166, 7, 0, // Skip to: 18994 +/* 17036 */ MCD_OPC_Decode, 253, 101, 125, // Opcode: VWMACC_VX +/* 17040 */ MCD_OPC_FilterValue, 62, 9, 0, 0, // Skip to: 17054 +/* 17045 */ MCD_OPC_CheckPredicate, 10, 152, 7, 0, // Skip to: 18994 +/* 17050 */ MCD_OPC_Decode, 249, 101, 125, // Opcode: VWMACCUS_VX +/* 17054 */ MCD_OPC_FilterValue, 63, 143, 7, 0, // Skip to: 18994 +/* 17059 */ MCD_OPC_CheckPredicate, 10, 138, 7, 0, // Skip to: 18994 +/* 17064 */ MCD_OPC_Decode, 248, 101, 125, // Opcode: VWMACCSU_VX +/* 17068 */ MCD_OPC_FilterValue, 7, 129, 7, 0, // Skip to: 18994 +/* 17073 */ MCD_OPC_ExtractField, 31, 1, // Inst{31} ... +/* 17076 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 17090 +/* 17081 */ MCD_OPC_CheckPredicate, 10, 116, 7, 0, // Skip to: 18994 +/* 17086 */ MCD_OPC_Decode, 199, 100, 126, // Opcode: VSETVLI +/* 17090 */ MCD_OPC_FilterValue, 1, 107, 7, 0, // Skip to: 18994 +/* 17095 */ MCD_OPC_ExtractField, 30, 1, // Inst{30} ... +/* 17098 */ MCD_OPC_FilterValue, 0, 16, 0, 0, // Skip to: 17119 +/* 17103 */ MCD_OPC_CheckPredicate, 10, 94, 7, 0, // Skip to: 18994 +/* 17108 */ MCD_OPC_CheckField, 25, 5, 0, 87, 7, 0, // Skip to: 18994 +/* 17115 */ MCD_OPC_Decode, 198, 100, 59, // Opcode: VSETVL +/* 17119 */ MCD_OPC_FilterValue, 1, 78, 7, 0, // Skip to: 18994 +/* 17124 */ MCD_OPC_CheckPredicate, 10, 73, 7, 0, // Skip to: 18994 +/* 17129 */ MCD_OPC_Decode, 197, 100, 127, // Opcode: VSETIVLI +/* 17133 */ MCD_OPC_FilterValue, 99, 63, 0, 0, // Skip to: 17201 +/* 17138 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 17141 */ MCD_OPC_FilterValue, 0, 5, 0, 0, // Skip to: 17151 +/* 17146 */ MCD_OPC_Decode, 249, 88, 128, 1, // Opcode: BEQ +/* 17151 */ MCD_OPC_FilterValue, 1, 5, 0, 0, // Skip to: 17161 +/* 17156 */ MCD_OPC_Decode, 130, 89, 128, 1, // Opcode: BNE +/* 17161 */ MCD_OPC_FilterValue, 4, 5, 0, 0, // Skip to: 17171 +/* 17166 */ MCD_OPC_Decode, 128, 89, 128, 1, // Opcode: BLT +/* 17171 */ MCD_OPC_FilterValue, 5, 5, 0, 0, // Skip to: 17181 +/* 17176 */ MCD_OPC_Decode, 252, 88, 128, 1, // Opcode: BGE +/* 17181 */ MCD_OPC_FilterValue, 6, 5, 0, 0, // Skip to: 17191 +/* 17186 */ MCD_OPC_Decode, 129, 89, 128, 1, // Opcode: BLTU +/* 17191 */ MCD_OPC_FilterValue, 7, 6, 7, 0, // Skip to: 18994 +/* 17196 */ MCD_OPC_Decode, 253, 88, 128, 1, // Opcode: BGEU +/* 17201 */ MCD_OPC_FilterValue, 103, 11, 0, 0, // Skip to: 17217 +/* 17206 */ MCD_OPC_CheckField, 12, 3, 0, 245, 6, 0, // Skip to: 18994 +/* 17213 */ MCD_OPC_Decode, 189, 94, 35, // Opcode: JALR +/* 17217 */ MCD_OPC_FilterValue, 111, 5, 0, 0, // Skip to: 17227 +/* 17222 */ MCD_OPC_Decode, 188, 94, 129, 1, // Opcode: JAL +/* 17227 */ MCD_OPC_FilterValue, 115, 94, 5, 0, // Skip to: 18606 +/* 17232 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 17235 */ MCD_OPC_FilterValue, 0, 96, 1, 0, // Skip to: 17592 +/* 17240 */ MCD_OPC_ExtractField, 25, 7, // Inst{31-25} ... +/* 17243 */ MCD_OPC_FilterValue, 0, 79, 0, 0, // Skip to: 17327 +/* 17248 */ MCD_OPC_ExtractField, 15, 10, // Inst{24-15} ... +/* 17251 */ MCD_OPC_FilterValue, 0, 11, 0, 0, // Skip to: 17267 +/* 17256 */ MCD_OPC_CheckField, 7, 5, 0, 195, 6, 0, // Skip to: 18994 +/* 17263 */ MCD_OPC_Decode, 173, 92, 0, // Opcode: ECALL +/* 17267 */ MCD_OPC_FilterValue, 32, 11, 0, 0, // Skip to: 17283 +/* 17272 */ MCD_OPC_CheckField, 7, 5, 0, 179, 6, 0, // Skip to: 18994 +/* 17279 */ MCD_OPC_Decode, 172, 92, 0, // Opcode: EBREAK +/* 17283 */ MCD_OPC_FilterValue, 160, 3, 16, 0, 0, // Skip to: 17305 +/* 17289 */ MCD_OPC_CheckPredicate, 75, 164, 6, 0, // Skip to: 18994 +/* 17294 */ MCD_OPC_CheckField, 7, 5, 0, 157, 6, 0, // Skip to: 18994 +/* 17301 */ MCD_OPC_Decode, 152, 102, 0, // Opcode: WRS_NTO +/* 17305 */ MCD_OPC_FilterValue, 160, 7, 147, 6, 0, // Skip to: 18994 +/* 17311 */ MCD_OPC_CheckPredicate, 75, 142, 6, 0, // Skip to: 18994 +/* 17316 */ MCD_OPC_CheckField, 7, 5, 0, 135, 6, 0, // Skip to: 18994 +/* 17323 */ MCD_OPC_Decode, 153, 102, 0, // Opcode: WRS_STO +/* 17327 */ MCD_OPC_FilterValue, 8, 36, 0, 0, // Skip to: 17368 +/* 17332 */ MCD_OPC_ExtractField, 15, 10, // Inst{24-15} ... +/* 17335 */ MCD_OPC_FilterValue, 64, 11, 0, 0, // Skip to: 17351 +/* 17340 */ MCD_OPC_CheckField, 7, 5, 0, 111, 6, 0, // Skip to: 18994 +/* 17347 */ MCD_OPC_Decode, 204, 95, 0, // Opcode: SRET +/* 17351 */ MCD_OPC_FilterValue, 160, 1, 101, 6, 0, // Skip to: 18994 +/* 17357 */ MCD_OPC_CheckField, 7, 5, 0, 94, 6, 0, // Skip to: 18994 +/* 17364 */ MCD_OPC_Decode, 151, 102, 0, // Opcode: WFI +/* 17368 */ MCD_OPC_FilterValue, 9, 12, 0, 0, // Skip to: 17385 +/* 17373 */ MCD_OPC_CheckField, 7, 5, 0, 78, 6, 0, // Skip to: 18994 +/* 17380 */ MCD_OPC_Decode, 163, 95, 130, 1, // Opcode: SFENCE_VMA +/* 17385 */ MCD_OPC_FilterValue, 11, 17, 0, 0, // Skip to: 17407 +/* 17390 */ MCD_OPC_CheckPredicate, 76, 63, 6, 0, // Skip to: 18994 +/* 17395 */ MCD_OPC_CheckField, 7, 5, 0, 56, 6, 0, // Skip to: 18994 +/* 17402 */ MCD_OPC_Decode, 186, 95, 130, 1, // Opcode: SINVAL_VMA +/* 17407 */ MCD_OPC_FilterValue, 12, 45, 0, 0, // Skip to: 17457 +/* 17412 */ MCD_OPC_ExtractField, 15, 10, // Inst{24-15} ... +/* 17415 */ MCD_OPC_FilterValue, 0, 16, 0, 0, // Skip to: 17436 +/* 17420 */ MCD_OPC_CheckPredicate, 76, 33, 6, 0, // Skip to: 18994 +/* 17425 */ MCD_OPC_CheckField, 7, 5, 0, 26, 6, 0, // Skip to: 18994 +/* 17432 */ MCD_OPC_Decode, 164, 95, 0, // Opcode: SFENCE_W_INVAL +/* 17436 */ MCD_OPC_FilterValue, 32, 17, 6, 0, // Skip to: 18994 +/* 17441 */ MCD_OPC_CheckPredicate, 76, 12, 6, 0, // Skip to: 18994 +/* 17446 */ MCD_OPC_CheckField, 7, 5, 0, 5, 6, 0, // Skip to: 18994 +/* 17453 */ MCD_OPC_Decode, 162, 95, 0, // Opcode: SFENCE_INVAL_IR +/* 17457 */ MCD_OPC_FilterValue, 17, 17, 0, 0, // Skip to: 17479 +/* 17462 */ MCD_OPC_CheckPredicate, 77, 247, 5, 0, // Skip to: 18994 +/* 17467 */ MCD_OPC_CheckField, 7, 5, 0, 240, 5, 0, // Skip to: 18994 +/* 17474 */ MCD_OPC_Decode, 155, 94, 130, 1, // Opcode: HFENCE_VVMA +/* 17479 */ MCD_OPC_FilterValue, 19, 17, 0, 0, // Skip to: 17501 +/* 17484 */ MCD_OPC_CheckPredicate, 76, 225, 5, 0, // Skip to: 18994 +/* 17489 */ MCD_OPC_CheckField, 7, 5, 0, 218, 5, 0, // Skip to: 18994 +/* 17496 */ MCD_OPC_Decode, 157, 94, 130, 1, // Opcode: HINVAL_VVMA +/* 17501 */ MCD_OPC_FilterValue, 24, 18, 0, 0, // Skip to: 17524 +/* 17506 */ MCD_OPC_CheckField, 15, 10, 64, 201, 5, 0, // Skip to: 18994 +/* 17513 */ MCD_OPC_CheckField, 7, 5, 0, 194, 5, 0, // Skip to: 18994 +/* 17520 */ MCD_OPC_Decode, 250, 94, 0, // Opcode: MRET +/* 17524 */ MCD_OPC_FilterValue, 49, 17, 0, 0, // Skip to: 17546 +/* 17529 */ MCD_OPC_CheckPredicate, 77, 180, 5, 0, // Skip to: 18994 +/* 17534 */ MCD_OPC_CheckField, 7, 5, 0, 173, 5, 0, // Skip to: 18994 +/* 17541 */ MCD_OPC_Decode, 154, 94, 130, 1, // Opcode: HFENCE_GVMA +/* 17546 */ MCD_OPC_FilterValue, 51, 17, 0, 0, // Skip to: 17568 +/* 17551 */ MCD_OPC_CheckPredicate, 76, 158, 5, 0, // Skip to: 18994 +/* 17556 */ MCD_OPC_CheckField, 7, 5, 0, 151, 5, 0, // Skip to: 18994 +/* 17563 */ MCD_OPC_Decode, 156, 94, 130, 1, // Opcode: HINVAL_GVMA +/* 17568 */ MCD_OPC_FilterValue, 61, 141, 5, 0, // Skip to: 18994 +/* 17573 */ MCD_OPC_CheckField, 15, 10, 192, 4, 133, 5, 0, // Skip to: 18994 +/* 17581 */ MCD_OPC_CheckField, 7, 5, 0, 126, 5, 0, // Skip to: 18994 +/* 17588 */ MCD_OPC_Decode, 171, 92, 0, // Opcode: DRET +/* 17592 */ MCD_OPC_FilterValue, 1, 25, 0, 0, // Skip to: 17622 +/* 17597 */ MCD_OPC_CheckField, 15, 17, 128, 128, 6, 11, 0, 0, // Skip to: 17617 +/* 17606 */ MCD_OPC_CheckField, 7, 5, 0, 4, 0, 0, // Skip to: 17617 +/* 17613 */ MCD_OPC_Decode, 204, 96, 0, // Opcode: UNIMP +/* 17617 */ MCD_OPC_Decode, 165, 89, 131, 1, // Opcode: CSRRW +/* 17622 */ MCD_OPC_FilterValue, 2, 5, 0, 0, // Skip to: 17632 +/* 17627 */ MCD_OPC_Decode, 163, 89, 131, 1, // Opcode: CSRRS +/* 17632 */ MCD_OPC_FilterValue, 3, 5, 0, 0, // Skip to: 17642 +/* 17637 */ MCD_OPC_Decode, 161, 89, 131, 1, // Opcode: CSRRC +/* 17642 */ MCD_OPC_FilterValue, 4, 161, 3, 0, // Skip to: 18576 +/* 17647 */ MCD_OPC_ExtractField, 25, 7, // Inst{31-25} ... +/* 17650 */ MCD_OPC_FilterValue, 48, 31, 0, 0, // Skip to: 17686 +/* 17655 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 17658 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 17672 +/* 17663 */ MCD_OPC_CheckPredicate, 77, 46, 5, 0, // Skip to: 18994 +/* 17668 */ MCD_OPC_Decode, 160, 94, 49, // Opcode: HLV_B +/* 17672 */ MCD_OPC_FilterValue, 1, 37, 5, 0, // Skip to: 18994 +/* 17677 */ MCD_OPC_CheckPredicate, 77, 32, 5, 0, // Skip to: 18994 +/* 17682 */ MCD_OPC_Decode, 161, 94, 49, // Opcode: HLV_BU +/* 17686 */ MCD_OPC_FilterValue, 49, 17, 0, 0, // Skip to: 17708 +/* 17691 */ MCD_OPC_CheckPredicate, 77, 18, 5, 0, // Skip to: 18994 +/* 17696 */ MCD_OPC_CheckField, 7, 5, 0, 11, 5, 0, // Skip to: 18994 +/* 17703 */ MCD_OPC_Decode, 167, 94, 132, 1, // Opcode: HSV_B +/* 17708 */ MCD_OPC_FilterValue, 50, 45, 0, 0, // Skip to: 17758 +/* 17713 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 17716 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 17730 +/* 17721 */ MCD_OPC_CheckPredicate, 77, 244, 4, 0, // Skip to: 18994 +/* 17726 */ MCD_OPC_Decode, 163, 94, 49, // Opcode: HLV_H +/* 17730 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 17744 +/* 17735 */ MCD_OPC_CheckPredicate, 77, 230, 4, 0, // Skip to: 18994 +/* 17740 */ MCD_OPC_Decode, 164, 94, 49, // Opcode: HLV_HU +/* 17744 */ MCD_OPC_FilterValue, 3, 221, 4, 0, // Skip to: 18994 +/* 17749 */ MCD_OPC_CheckPredicate, 77, 216, 4, 0, // Skip to: 18994 +/* 17754 */ MCD_OPC_Decode, 158, 94, 49, // Opcode: HLVX_HU +/* 17758 */ MCD_OPC_FilterValue, 51, 17, 0, 0, // Skip to: 17780 +/* 17763 */ MCD_OPC_CheckPredicate, 77, 202, 4, 0, // Skip to: 18994 +/* 17768 */ MCD_OPC_CheckField, 7, 5, 0, 195, 4, 0, // Skip to: 18994 +/* 17775 */ MCD_OPC_Decode, 169, 94, 132, 1, // Opcode: HSV_H +/* 17780 */ MCD_OPC_FilterValue, 52, 45, 0, 0, // Skip to: 17830 +/* 17785 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 17788 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 17802 +/* 17793 */ MCD_OPC_CheckPredicate, 77, 172, 4, 0, // Skip to: 18994 +/* 17798 */ MCD_OPC_Decode, 165, 94, 49, // Opcode: HLV_W +/* 17802 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 17816 +/* 17807 */ MCD_OPC_CheckPredicate, 78, 158, 4, 0, // Skip to: 18994 +/* 17812 */ MCD_OPC_Decode, 166, 94, 49, // Opcode: HLV_WU +/* 17816 */ MCD_OPC_FilterValue, 3, 149, 4, 0, // Skip to: 18994 +/* 17821 */ MCD_OPC_CheckPredicate, 77, 144, 4, 0, // Skip to: 18994 +/* 17826 */ MCD_OPC_Decode, 159, 94, 49, // Opcode: HLVX_WU +/* 17830 */ MCD_OPC_FilterValue, 53, 17, 0, 0, // Skip to: 17852 +/* 17835 */ MCD_OPC_CheckPredicate, 77, 130, 4, 0, // Skip to: 18994 +/* 17840 */ MCD_OPC_CheckField, 7, 5, 0, 123, 4, 0, // Skip to: 18994 +/* 17847 */ MCD_OPC_Decode, 170, 94, 132, 1, // Opcode: HSV_W +/* 17852 */ MCD_OPC_FilterValue, 54, 16, 0, 0, // Skip to: 17873 +/* 17857 */ MCD_OPC_CheckPredicate, 78, 108, 4, 0, // Skip to: 18994 +/* 17862 */ MCD_OPC_CheckField, 20, 5, 0, 101, 4, 0, // Skip to: 18994 +/* 17869 */ MCD_OPC_Decode, 162, 94, 49, // Opcode: HLV_D +/* 17873 */ MCD_OPC_FilterValue, 55, 17, 0, 0, // Skip to: 17895 +/* 17878 */ MCD_OPC_CheckPredicate, 78, 87, 4, 0, // Skip to: 18994 +/* 17883 */ MCD_OPC_CheckField, 7, 5, 0, 80, 4, 0, // Skip to: 18994 +/* 17890 */ MCD_OPC_Decode, 168, 94, 132, 1, // Opcode: HSV_D +/* 17895 */ MCD_OPC_FilterValue, 64, 59, 0, 0, // Skip to: 17959 +/* 17900 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 17903 */ MCD_OPC_FilterValue, 28, 9, 0, 0, // Skip to: 17917 +/* 17908 */ MCD_OPC_CheckPredicate, 79, 57, 4, 0, // Skip to: 18994 +/* 17913 */ MCD_OPC_Decode, 210, 94, 49, // Opcode: MOPR0 +/* 17917 */ MCD_OPC_FilterValue, 29, 9, 0, 0, // Skip to: 17931 +/* 17922 */ MCD_OPC_CheckPredicate, 79, 43, 4, 0, // Skip to: 18994 +/* 17927 */ MCD_OPC_Decode, 211, 94, 49, // Opcode: MOPR1 +/* 17931 */ MCD_OPC_FilterValue, 30, 9, 0, 0, // Skip to: 17945 +/* 17936 */ MCD_OPC_CheckPredicate, 79, 29, 4, 0, // Skip to: 18994 +/* 17941 */ MCD_OPC_Decode, 222, 94, 49, // Opcode: MOPR2 +/* 17945 */ MCD_OPC_FilterValue, 31, 20, 4, 0, // Skip to: 18994 +/* 17950 */ MCD_OPC_CheckPredicate, 79, 15, 4, 0, // Skip to: 18994 +/* 17955 */ MCD_OPC_Decode, 233, 94, 49, // Opcode: MOPR3 +/* 17959 */ MCD_OPC_FilterValue, 65, 9, 0, 0, // Skip to: 17973 +/* 17964 */ MCD_OPC_CheckPredicate, 79, 1, 4, 0, // Skip to: 18994 +/* 17969 */ MCD_OPC_Decode, 242, 94, 59, // Opcode: MOPRR0 +/* 17973 */ MCD_OPC_FilterValue, 66, 59, 0, 0, // Skip to: 18037 +/* 17978 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 17981 */ MCD_OPC_FilterValue, 28, 9, 0, 0, // Skip to: 17995 +/* 17986 */ MCD_OPC_CheckPredicate, 79, 235, 3, 0, // Skip to: 18994 +/* 17991 */ MCD_OPC_Decode, 236, 94, 49, // Opcode: MOPR4 +/* 17995 */ MCD_OPC_FilterValue, 29, 9, 0, 0, // Skip to: 18009 +/* 18000 */ MCD_OPC_CheckPredicate, 79, 221, 3, 0, // Skip to: 18994 +/* 18005 */ MCD_OPC_Decode, 237, 94, 49, // Opcode: MOPR5 +/* 18009 */ MCD_OPC_FilterValue, 30, 9, 0, 0, // Skip to: 18023 +/* 18014 */ MCD_OPC_CheckPredicate, 79, 207, 3, 0, // Skip to: 18994 +/* 18019 */ MCD_OPC_Decode, 238, 94, 49, // Opcode: MOPR6 +/* 18023 */ MCD_OPC_FilterValue, 31, 198, 3, 0, // Skip to: 18994 +/* 18028 */ MCD_OPC_CheckPredicate, 79, 193, 3, 0, // Skip to: 18994 +/* 18033 */ MCD_OPC_Decode, 239, 94, 49, // Opcode: MOPR7 +/* 18037 */ MCD_OPC_FilterValue, 67, 9, 0, 0, // Skip to: 18051 +/* 18042 */ MCD_OPC_CheckPredicate, 79, 179, 3, 0, // Skip to: 18994 +/* 18047 */ MCD_OPC_Decode, 243, 94, 59, // Opcode: MOPRR1 +/* 18051 */ MCD_OPC_FilterValue, 68, 59, 0, 0, // Skip to: 18115 +/* 18056 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 18059 */ MCD_OPC_FilterValue, 28, 9, 0, 0, // Skip to: 18073 +/* 18064 */ MCD_OPC_CheckPredicate, 79, 157, 3, 0, // Skip to: 18994 +/* 18069 */ MCD_OPC_Decode, 240, 94, 49, // Opcode: MOPR8 +/* 18073 */ MCD_OPC_FilterValue, 29, 9, 0, 0, // Skip to: 18087 +/* 18078 */ MCD_OPC_CheckPredicate, 79, 143, 3, 0, // Skip to: 18994 +/* 18083 */ MCD_OPC_Decode, 241, 94, 49, // Opcode: MOPR9 +/* 18087 */ MCD_OPC_FilterValue, 30, 9, 0, 0, // Skip to: 18101 +/* 18092 */ MCD_OPC_CheckPredicate, 79, 129, 3, 0, // Skip to: 18994 +/* 18097 */ MCD_OPC_Decode, 212, 94, 49, // Opcode: MOPR10 +/* 18101 */ MCD_OPC_FilterValue, 31, 120, 3, 0, // Skip to: 18994 +/* 18106 */ MCD_OPC_CheckPredicate, 79, 115, 3, 0, // Skip to: 18994 +/* 18111 */ MCD_OPC_Decode, 213, 94, 49, // Opcode: MOPR11 +/* 18115 */ MCD_OPC_FilterValue, 69, 9, 0, 0, // Skip to: 18129 +/* 18120 */ MCD_OPC_CheckPredicate, 79, 101, 3, 0, // Skip to: 18994 +/* 18125 */ MCD_OPC_Decode, 244, 94, 59, // Opcode: MOPRR2 +/* 18129 */ MCD_OPC_FilterValue, 70, 59, 0, 0, // Skip to: 18193 +/* 18134 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 18137 */ MCD_OPC_FilterValue, 28, 9, 0, 0, // Skip to: 18151 +/* 18142 */ MCD_OPC_CheckPredicate, 79, 79, 3, 0, // Skip to: 18994 +/* 18147 */ MCD_OPC_Decode, 214, 94, 49, // Opcode: MOPR12 +/* 18151 */ MCD_OPC_FilterValue, 29, 9, 0, 0, // Skip to: 18165 +/* 18156 */ MCD_OPC_CheckPredicate, 79, 65, 3, 0, // Skip to: 18994 +/* 18161 */ MCD_OPC_Decode, 215, 94, 49, // Opcode: MOPR13 +/* 18165 */ MCD_OPC_FilterValue, 30, 9, 0, 0, // Skip to: 18179 +/* 18170 */ MCD_OPC_CheckPredicate, 79, 51, 3, 0, // Skip to: 18994 +/* 18175 */ MCD_OPC_Decode, 216, 94, 49, // Opcode: MOPR14 +/* 18179 */ MCD_OPC_FilterValue, 31, 42, 3, 0, // Skip to: 18994 +/* 18184 */ MCD_OPC_CheckPredicate, 79, 37, 3, 0, // Skip to: 18994 +/* 18189 */ MCD_OPC_Decode, 217, 94, 49, // Opcode: MOPR15 +/* 18193 */ MCD_OPC_FilterValue, 71, 9, 0, 0, // Skip to: 18207 +/* 18198 */ MCD_OPC_CheckPredicate, 79, 23, 3, 0, // Skip to: 18994 +/* 18203 */ MCD_OPC_Decode, 245, 94, 59, // Opcode: MOPRR3 +/* 18207 */ MCD_OPC_FilterValue, 96, 59, 0, 0, // Skip to: 18271 +/* 18212 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 18215 */ MCD_OPC_FilterValue, 28, 9, 0, 0, // Skip to: 18229 +/* 18220 */ MCD_OPC_CheckPredicate, 79, 1, 3, 0, // Skip to: 18994 +/* 18225 */ MCD_OPC_Decode, 218, 94, 49, // Opcode: MOPR16 +/* 18229 */ MCD_OPC_FilterValue, 29, 9, 0, 0, // Skip to: 18243 +/* 18234 */ MCD_OPC_CheckPredicate, 79, 243, 2, 0, // Skip to: 18994 +/* 18239 */ MCD_OPC_Decode, 219, 94, 49, // Opcode: MOPR17 +/* 18243 */ MCD_OPC_FilterValue, 30, 9, 0, 0, // Skip to: 18257 +/* 18248 */ MCD_OPC_CheckPredicate, 79, 229, 2, 0, // Skip to: 18994 +/* 18253 */ MCD_OPC_Decode, 220, 94, 49, // Opcode: MOPR18 +/* 18257 */ MCD_OPC_FilterValue, 31, 220, 2, 0, // Skip to: 18994 +/* 18262 */ MCD_OPC_CheckPredicate, 79, 215, 2, 0, // Skip to: 18994 +/* 18267 */ MCD_OPC_Decode, 221, 94, 49, // Opcode: MOPR19 +/* 18271 */ MCD_OPC_FilterValue, 97, 9, 0, 0, // Skip to: 18285 +/* 18276 */ MCD_OPC_CheckPredicate, 79, 201, 2, 0, // Skip to: 18994 +/* 18281 */ MCD_OPC_Decode, 246, 94, 59, // Opcode: MOPRR4 +/* 18285 */ MCD_OPC_FilterValue, 98, 59, 0, 0, // Skip to: 18349 +/* 18290 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 18293 */ MCD_OPC_FilterValue, 28, 9, 0, 0, // Skip to: 18307 +/* 18298 */ MCD_OPC_CheckPredicate, 79, 179, 2, 0, // Skip to: 18994 +/* 18303 */ MCD_OPC_Decode, 223, 94, 49, // Opcode: MOPR20 +/* 18307 */ MCD_OPC_FilterValue, 29, 9, 0, 0, // Skip to: 18321 +/* 18312 */ MCD_OPC_CheckPredicate, 79, 165, 2, 0, // Skip to: 18994 +/* 18317 */ MCD_OPC_Decode, 224, 94, 49, // Opcode: MOPR21 +/* 18321 */ MCD_OPC_FilterValue, 30, 9, 0, 0, // Skip to: 18335 +/* 18326 */ MCD_OPC_CheckPredicate, 79, 151, 2, 0, // Skip to: 18994 +/* 18331 */ MCD_OPC_Decode, 225, 94, 49, // Opcode: MOPR22 +/* 18335 */ MCD_OPC_FilterValue, 31, 142, 2, 0, // Skip to: 18994 +/* 18340 */ MCD_OPC_CheckPredicate, 79, 137, 2, 0, // Skip to: 18994 +/* 18345 */ MCD_OPC_Decode, 226, 94, 49, // Opcode: MOPR23 +/* 18349 */ MCD_OPC_FilterValue, 99, 9, 0, 0, // Skip to: 18363 +/* 18354 */ MCD_OPC_CheckPredicate, 79, 123, 2, 0, // Skip to: 18994 +/* 18359 */ MCD_OPC_Decode, 247, 94, 59, // Opcode: MOPRR5 +/* 18363 */ MCD_OPC_FilterValue, 100, 59, 0, 0, // Skip to: 18427 +/* 18368 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 18371 */ MCD_OPC_FilterValue, 28, 9, 0, 0, // Skip to: 18385 +/* 18376 */ MCD_OPC_CheckPredicate, 79, 101, 2, 0, // Skip to: 18994 +/* 18381 */ MCD_OPC_Decode, 227, 94, 49, // Opcode: MOPR24 +/* 18385 */ MCD_OPC_FilterValue, 29, 9, 0, 0, // Skip to: 18399 +/* 18390 */ MCD_OPC_CheckPredicate, 79, 87, 2, 0, // Skip to: 18994 +/* 18395 */ MCD_OPC_Decode, 228, 94, 49, // Opcode: MOPR25 +/* 18399 */ MCD_OPC_FilterValue, 30, 9, 0, 0, // Skip to: 18413 +/* 18404 */ MCD_OPC_CheckPredicate, 79, 73, 2, 0, // Skip to: 18994 +/* 18409 */ MCD_OPC_Decode, 229, 94, 49, // Opcode: MOPR26 +/* 18413 */ MCD_OPC_FilterValue, 31, 64, 2, 0, // Skip to: 18994 +/* 18418 */ MCD_OPC_CheckPredicate, 79, 59, 2, 0, // Skip to: 18994 +/* 18423 */ MCD_OPC_Decode, 230, 94, 49, // Opcode: MOPR27 +/* 18427 */ MCD_OPC_FilterValue, 101, 9, 0, 0, // Skip to: 18441 +/* 18432 */ MCD_OPC_CheckPredicate, 79, 45, 2, 0, // Skip to: 18994 +/* 18437 */ MCD_OPC_Decode, 248, 94, 59, // Opcode: MOPRR6 +/* 18441 */ MCD_OPC_FilterValue, 102, 92, 0, 0, // Skip to: 18538 +/* 18446 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 18449 */ MCD_OPC_FilterValue, 28, 42, 0, 0, // Skip to: 18496 +/* 18454 */ MCD_OPC_CheckPredicate, 39, 12, 0, 0, // Skip to: 18471 +/* 18459 */ MCD_OPC_CheckField, 7, 5, 0, 5, 0, 0, // Skip to: 18471 +/* 18466 */ MCD_OPC_Decode, 217, 95, 133, 1, // Opcode: SSPOPCHK +/* 18471 */ MCD_OPC_CheckPredicate, 39, 11, 0, 0, // Skip to: 18487 +/* 18476 */ MCD_OPC_CheckField, 15, 5, 0, 4, 0, 0, // Skip to: 18487 +/* 18483 */ MCD_OPC_Decode, 219, 95, 25, // Opcode: SSRDP +/* 18487 */ MCD_OPC_CheckPredicate, 79, 246, 1, 0, // Skip to: 18994 +/* 18492 */ MCD_OPC_Decode, 231, 94, 49, // Opcode: MOPR28 +/* 18496 */ MCD_OPC_FilterValue, 29, 9, 0, 0, // Skip to: 18510 +/* 18501 */ MCD_OPC_CheckPredicate, 79, 232, 1, 0, // Skip to: 18994 +/* 18506 */ MCD_OPC_Decode, 232, 94, 49, // Opcode: MOPR29 +/* 18510 */ MCD_OPC_FilterValue, 30, 9, 0, 0, // Skip to: 18524 +/* 18515 */ MCD_OPC_CheckPredicate, 79, 218, 1, 0, // Skip to: 18994 +/* 18520 */ MCD_OPC_Decode, 234, 94, 49, // Opcode: MOPR30 +/* 18524 */ MCD_OPC_FilterValue, 31, 209, 1, 0, // Skip to: 18994 +/* 18529 */ MCD_OPC_CheckPredicate, 79, 204, 1, 0, // Skip to: 18994 +/* 18534 */ MCD_OPC_Decode, 235, 94, 49, // Opcode: MOPR31 +/* 18538 */ MCD_OPC_FilterValue, 103, 195, 1, 0, // Skip to: 18994 +/* 18543 */ MCD_OPC_CheckPredicate, 39, 19, 0, 0, // Skip to: 18567 +/* 18548 */ MCD_OPC_CheckField, 15, 5, 0, 12, 0, 0, // Skip to: 18567 +/* 18555 */ MCD_OPC_CheckField, 7, 5, 0, 5, 0, 0, // Skip to: 18567 +/* 18562 */ MCD_OPC_Decode, 218, 95, 134, 1, // Opcode: SSPUSH +/* 18567 */ MCD_OPC_CheckPredicate, 79, 166, 1, 0, // Skip to: 18994 +/* 18572 */ MCD_OPC_Decode, 249, 94, 59, // Opcode: MOPRR7 +/* 18576 */ MCD_OPC_FilterValue, 5, 5, 0, 0, // Skip to: 18586 +/* 18581 */ MCD_OPC_Decode, 166, 89, 135, 1, // Opcode: CSRRWI +/* 18586 */ MCD_OPC_FilterValue, 6, 5, 0, 0, // Skip to: 18596 +/* 18591 */ MCD_OPC_Decode, 164, 89, 135, 1, // Opcode: CSRRSI +/* 18596 */ MCD_OPC_FilterValue, 7, 137, 1, 0, // Skip to: 18994 +/* 18601 */ MCD_OPC_Decode, 162, 89, 135, 1, // Opcode: CSRRCI +/* 18606 */ MCD_OPC_FilterValue, 119, 127, 1, 0, // Skip to: 18994 +/* 18611 */ MCD_OPC_ExtractField, 25, 7, // Inst{31-25} ... +/* 18614 */ MCD_OPC_FilterValue, 65, 16, 0, 0, // Skip to: 18635 +/* 18619 */ MCD_OPC_CheckPredicate, 80, 114, 1, 0, // Skip to: 18994 +/* 18624 */ MCD_OPC_CheckField, 12, 3, 2, 107, 1, 0, // Skip to: 18994 +/* 18631 */ MCD_OPC_Decode, 216, 100, 100, // Opcode: VSM3ME_VV +/* 18635 */ MCD_OPC_FilterValue, 67, 17, 0, 0, // Skip to: 18657 +/* 18640 */ MCD_OPC_CheckPredicate, 81, 93, 1, 0, // Skip to: 18994 +/* 18645 */ MCD_OPC_CheckField, 12, 3, 2, 86, 1, 0, // Skip to: 18994 +/* 18652 */ MCD_OPC_Decode, 217, 100, 136, 1, // Opcode: VSM4K_VI +/* 18657 */ MCD_OPC_FilterValue, 69, 17, 0, 0, // Skip to: 18679 +/* 18662 */ MCD_OPC_CheckPredicate, 82, 71, 1, 0, // Skip to: 18994 +/* 18667 */ MCD_OPC_CheckField, 12, 3, 2, 64, 1, 0, // Skip to: 18994 +/* 18674 */ MCD_OPC_Decode, 224, 96, 136, 1, // Opcode: VAESKF1_VI +/* 18679 */ MCD_OPC_FilterValue, 81, 89, 0, 0, // Skip to: 18773 +/* 18684 */ MCD_OPC_ExtractField, 12, 8, // Inst{19-12} ... +/* 18687 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 18701 +/* 18692 */ MCD_OPC_CheckPredicate, 82, 41, 1, 0, // Skip to: 18994 +/* 18697 */ MCD_OPC_Decode, 219, 96, 113, // Opcode: VAESDM_VV +/* 18701 */ MCD_OPC_FilterValue, 10, 9, 0, 0, // Skip to: 18715 +/* 18706 */ MCD_OPC_CheckPredicate, 82, 27, 1, 0, // Skip to: 18994 +/* 18711 */ MCD_OPC_Decode, 217, 96, 113, // Opcode: VAESDF_VV +/* 18715 */ MCD_OPC_FilterValue, 18, 9, 0, 0, // Skip to: 18729 +/* 18720 */ MCD_OPC_CheckPredicate, 82, 13, 1, 0, // Skip to: 18994 +/* 18725 */ MCD_OPC_Decode, 223, 96, 113, // Opcode: VAESEM_VV +/* 18729 */ MCD_OPC_FilterValue, 26, 9, 0, 0, // Skip to: 18743 +/* 18734 */ MCD_OPC_CheckPredicate, 82, 255, 0, 0, // Skip to: 18994 +/* 18739 */ MCD_OPC_Decode, 221, 96, 113, // Opcode: VAESEF_VV +/* 18743 */ MCD_OPC_FilterValue, 130, 1, 9, 0, 0, // Skip to: 18758 +/* 18749 */ MCD_OPC_CheckPredicate, 81, 240, 0, 0, // Skip to: 18994 +/* 18754 */ MCD_OPC_Decode, 219, 100, 113, // Opcode: VSM4R_VV +/* 18758 */ MCD_OPC_FilterValue, 138, 1, 230, 0, 0, // Skip to: 18994 +/* 18764 */ MCD_OPC_CheckPredicate, 83, 225, 0, 0, // Skip to: 18994 +/* 18769 */ MCD_OPC_Decode, 251, 97, 113, // Opcode: VGMUL_VV +/* 18773 */ MCD_OPC_FilterValue, 83, 88, 0, 0, // Skip to: 18866 +/* 18778 */ MCD_OPC_ExtractField, 12, 8, // Inst{19-12} ... +/* 18781 */ MCD_OPC_FilterValue, 2, 9, 0, 0, // Skip to: 18795 +/* 18786 */ MCD_OPC_CheckPredicate, 82, 203, 0, 0, // Skip to: 18994 +/* 18791 */ MCD_OPC_Decode, 218, 96, 113, // Opcode: VAESDM_VS +/* 18795 */ MCD_OPC_FilterValue, 10, 9, 0, 0, // Skip to: 18809 +/* 18800 */ MCD_OPC_CheckPredicate, 82, 189, 0, 0, // Skip to: 18994 +/* 18805 */ MCD_OPC_Decode, 216, 96, 113, // Opcode: VAESDF_VS +/* 18809 */ MCD_OPC_FilterValue, 18, 9, 0, 0, // Skip to: 18823 +/* 18814 */ MCD_OPC_CheckPredicate, 82, 175, 0, 0, // Skip to: 18994 +/* 18819 */ MCD_OPC_Decode, 222, 96, 113, // Opcode: VAESEM_VS +/* 18823 */ MCD_OPC_FilterValue, 26, 9, 0, 0, // Skip to: 18837 +/* 18828 */ MCD_OPC_CheckPredicate, 82, 161, 0, 0, // Skip to: 18994 +/* 18833 */ MCD_OPC_Decode, 220, 96, 113, // Opcode: VAESEF_VS +/* 18837 */ MCD_OPC_FilterValue, 58, 9, 0, 0, // Skip to: 18851 +/* 18842 */ MCD_OPC_CheckPredicate, 82, 147, 0, 0, // Skip to: 18994 +/* 18847 */ MCD_OPC_Decode, 226, 96, 113, // Opcode: VAESZ_VS +/* 18851 */ MCD_OPC_FilterValue, 130, 1, 137, 0, 0, // Skip to: 18994 +/* 18857 */ MCD_OPC_CheckPredicate, 81, 132, 0, 0, // Skip to: 18994 +/* 18862 */ MCD_OPC_Decode, 218, 100, 113, // Opcode: VSM4R_VS +/* 18866 */ MCD_OPC_FilterValue, 85, 17, 0, 0, // Skip to: 18888 +/* 18871 */ MCD_OPC_CheckPredicate, 82, 118, 0, 0, // Skip to: 18994 +/* 18876 */ MCD_OPC_CheckField, 12, 3, 2, 111, 0, 0, // Skip to: 18994 +/* 18883 */ MCD_OPC_Decode, 225, 96, 136, 1, // Opcode: VAESKF2_VI +/* 18888 */ MCD_OPC_FilterValue, 87, 17, 0, 0, // Skip to: 18910 +/* 18893 */ MCD_OPC_CheckPredicate, 80, 96, 0, 0, // Skip to: 18994 +/* 18898 */ MCD_OPC_CheckField, 12, 3, 2, 89, 0, 0, // Skip to: 18994 +/* 18905 */ MCD_OPC_Decode, 215, 100, 136, 1, // Opcode: VSM3C_VI +/* 18910 */ MCD_OPC_FilterValue, 89, 16, 0, 0, // Skip to: 18931 +/* 18915 */ MCD_OPC_CheckPredicate, 83, 74, 0, 0, // Skip to: 18994 +/* 18920 */ MCD_OPC_CheckField, 12, 3, 2, 67, 0, 0, // Skip to: 18994 +/* 18927 */ MCD_OPC_Decode, 250, 97, 100, // Opcode: VGHSH_VV +/* 18931 */ MCD_OPC_FilterValue, 91, 16, 0, 0, // Skip to: 18952 +/* 18936 */ MCD_OPC_CheckPredicate, 84, 53, 0, 0, // Skip to: 18994 +/* 18941 */ MCD_OPC_CheckField, 12, 3, 2, 46, 0, 0, // Skip to: 18994 +/* 18948 */ MCD_OPC_Decode, 205, 100, 100, // Opcode: VSHA2MS_VV +/* 18952 */ MCD_OPC_FilterValue, 93, 16, 0, 0, // Skip to: 18973 +/* 18957 */ MCD_OPC_CheckPredicate, 84, 32, 0, 0, // Skip to: 18994 +/* 18962 */ MCD_OPC_CheckField, 12, 3, 2, 25, 0, 0, // Skip to: 18994 +/* 18969 */ MCD_OPC_Decode, 203, 100, 100, // Opcode: VSHA2CH_VV +/* 18973 */ MCD_OPC_FilterValue, 95, 16, 0, 0, // Skip to: 18994 +/* 18978 */ MCD_OPC_CheckPredicate, 84, 11, 0, 0, // Skip to: 18994 +/* 18983 */ MCD_OPC_CheckField, 12, 3, 2, 4, 0, 0, // Skip to: 18994 +/* 18990 */ MCD_OPC_Decode, 204, 100, 100, // Opcode: VSHA2CL_VV +/* 18994 */ MCD_OPC_Fail, 0 }; static const uint8_t DecoderTableRISCV32Only_16[] = { /* 0 */ MCD_OPC_ExtractField, 0, 2, // Inst{1-0} ... -/* 3 */ MCD_OPC_FilterValue, 0, 31, 0, 0, // Skip to: 39 +/* 3 */ MCD_OPC_FilterValue, 0, 33, 0, 0, // Skip to: 41 /* 8 */ MCD_OPC_ExtractField, 13, 3, // Inst{15-13} ... -/* 11 */ MCD_OPC_FilterValue, 3, 9, 0, 0, // Skip to: 25 -/* 16 */ MCD_OPC_CheckPredicate, 12, 75, 0, 0, // Skip to: 96 -/* 21 */ MCD_OPC_Decode, 154, 2, 61, // Opcode: C_FLW -/* 25 */ MCD_OPC_FilterValue, 7, 66, 0, 0, // Skip to: 96 -/* 30 */ MCD_OPC_CheckPredicate, 12, 61, 0, 0, // Skip to: 96 -/* 35 */ MCD_OPC_Decode, 158, 2, 61, // Opcode: C_FSW -/* 39 */ MCD_OPC_FilterValue, 1, 16, 0, 0, // Skip to: 60 -/* 44 */ MCD_OPC_CheckPredicate, 13, 47, 0, 0, // Skip to: 96 -/* 49 */ MCD_OPC_CheckField, 13, 3, 1, 40, 0, 0, // Skip to: 96 -/* 56 */ MCD_OPC_Decode, 161, 2, 19, // Opcode: C_JAL -/* 60 */ MCD_OPC_FilterValue, 2, 31, 0, 0, // Skip to: 96 -/* 65 */ MCD_OPC_ExtractField, 13, 3, // Inst{15-13} ... -/* 68 */ MCD_OPC_FilterValue, 3, 9, 0, 0, // Skip to: 82 -/* 73 */ MCD_OPC_CheckPredicate, 12, 18, 0, 0, // Skip to: 96 -/* 78 */ MCD_OPC_Decode, 155, 2, 62, // Opcode: C_FLWSP -/* 82 */ MCD_OPC_FilterValue, 7, 9, 0, 0, // Skip to: 96 -/* 87 */ MCD_OPC_CheckPredicate, 12, 4, 0, 0, // Skip to: 96 -/* 92 */ MCD_OPC_Decode, 159, 2, 63, // Opcode: C_FSWSP -/* 96 */ MCD_OPC_Fail, +/* 11 */ MCD_OPC_FilterValue, 3, 10, 0, 0, // Skip to: 26 +/* 16 */ MCD_OPC_CheckPredicate, 85, 79, 0, 0, // Skip to: 100 +/* 21 */ MCD_OPC_Decode, 243, 91, 137, 1, // Opcode: C_FLW +/* 26 */ MCD_OPC_FilterValue, 7, 69, 0, 0, // Skip to: 100 +/* 31 */ MCD_OPC_CheckPredicate, 85, 64, 0, 0, // Skip to: 100 +/* 36 */ MCD_OPC_Decode, 247, 91, 137, 1, // Opcode: C_FSW +/* 41 */ MCD_OPC_FilterValue, 1, 16, 0, 0, // Skip to: 62 +/* 46 */ MCD_OPC_CheckPredicate, 86, 49, 0, 0, // Skip to: 100 +/* 51 */ MCD_OPC_CheckField, 13, 3, 1, 42, 0, 0, // Skip to: 100 +/* 58 */ MCD_OPC_Decode, 250, 91, 30, // Opcode: C_JAL +/* 62 */ MCD_OPC_FilterValue, 2, 33, 0, 0, // Skip to: 100 +/* 67 */ MCD_OPC_ExtractField, 13, 3, // Inst{15-13} ... +/* 70 */ MCD_OPC_FilterValue, 3, 10, 0, 0, // Skip to: 85 +/* 75 */ MCD_OPC_CheckPredicate, 85, 20, 0, 0, // Skip to: 100 +/* 80 */ MCD_OPC_Decode, 244, 91, 138, 1, // Opcode: C_FLWSP +/* 85 */ MCD_OPC_FilterValue, 7, 10, 0, 0, // Skip to: 100 +/* 90 */ MCD_OPC_CheckPredicate, 85, 5, 0, 0, // Skip to: 100 +/* 95 */ MCD_OPC_Decode, 248, 91, 139, 1, // Opcode: C_FSWSP +/* 100 */ MCD_OPC_Fail, + 0 +}; + +static const uint8_t DecoderTableRV32Zacas32[] = { +/* 0 */ MCD_OPC_ExtractField, 25, 7, // Inst{31-25} ... +/* 3 */ MCD_OPC_FilterValue, 20, 23, 0, 0, // Skip to: 31 +/* 8 */ MCD_OPC_CheckPredicate, 87, 102, 0, 0, // Skip to: 115 +/* 13 */ MCD_OPC_CheckField, 12, 3, 3, 95, 0, 0, // Skip to: 115 +/* 20 */ MCD_OPC_CheckField, 0, 7, 47, 88, 0, 0, // Skip to: 115 +/* 27 */ MCD_OPC_Decode, 171, 88, 60, // Opcode: AMOCAS_D_RV32 +/* 31 */ MCD_OPC_FilterValue, 21, 23, 0, 0, // Skip to: 59 +/* 36 */ MCD_OPC_CheckPredicate, 87, 74, 0, 0, // Skip to: 115 +/* 41 */ MCD_OPC_CheckField, 12, 3, 3, 67, 0, 0, // Skip to: 115 +/* 48 */ MCD_OPC_CheckField, 0, 7, 47, 60, 0, 0, // Skip to: 115 +/* 55 */ MCD_OPC_Decode, 174, 88, 60, // Opcode: AMOCAS_D_RV32_RL +/* 59 */ MCD_OPC_FilterValue, 22, 23, 0, 0, // Skip to: 87 +/* 64 */ MCD_OPC_CheckPredicate, 87, 46, 0, 0, // Skip to: 115 +/* 69 */ MCD_OPC_CheckField, 12, 3, 3, 39, 0, 0, // Skip to: 115 +/* 76 */ MCD_OPC_CheckField, 0, 7, 47, 32, 0, 0, // Skip to: 115 +/* 83 */ MCD_OPC_Decode, 172, 88, 60, // Opcode: AMOCAS_D_RV32_AQ +/* 87 */ MCD_OPC_FilterValue, 23, 23, 0, 0, // Skip to: 115 +/* 92 */ MCD_OPC_CheckPredicate, 87, 18, 0, 0, // Skip to: 115 +/* 97 */ MCD_OPC_CheckField, 12, 3, 3, 11, 0, 0, // Skip to: 115 +/* 104 */ MCD_OPC_CheckField, 0, 7, 47, 4, 0, 0, // Skip to: 115 +/* 111 */ MCD_OPC_Decode, 173, 88, 60, // Opcode: AMOCAS_D_RV32_AQ_RL +/* 115 */ MCD_OPC_Fail, + 0 +}; + +static const uint8_t DecoderTableRV32Zdinx32[] = { +/* 0 */ MCD_OPC_ExtractField, 0, 7, // Inst{6-0} ... +/* 3 */ MCD_OPC_FilterValue, 67, 17, 0, 0, // Skip to: 25 +/* 8 */ MCD_OPC_CheckPredicate, 88, 243, 1, 0, // Skip to: 512 +/* 13 */ MCD_OPC_CheckField, 25, 2, 1, 236, 1, 0, // Skip to: 512 +/* 20 */ MCD_OPC_Decode, 175, 93, 140, 1, // Opcode: FMADD_D_IN32X +/* 25 */ MCD_OPC_FilterValue, 71, 17, 0, 0, // Skip to: 47 +/* 30 */ MCD_OPC_CheckPredicate, 88, 221, 1, 0, // Skip to: 512 +/* 35 */ MCD_OPC_CheckField, 25, 2, 1, 214, 1, 0, // Skip to: 512 +/* 42 */ MCD_OPC_Decode, 202, 93, 140, 1, // Opcode: FMSUB_D_IN32X +/* 47 */ MCD_OPC_FilterValue, 75, 17, 0, 0, // Skip to: 69 +/* 52 */ MCD_OPC_CheckPredicate, 88, 199, 1, 0, // Skip to: 512 +/* 57 */ MCD_OPC_CheckField, 25, 2, 1, 192, 1, 0, // Skip to: 512 +/* 64 */ MCD_OPC_Decode, 232, 93, 140, 1, // Opcode: FNMSUB_D_IN32X +/* 69 */ MCD_OPC_FilterValue, 79, 17, 0, 0, // Skip to: 91 +/* 74 */ MCD_OPC_CheckPredicate, 88, 177, 1, 0, // Skip to: 512 +/* 79 */ MCD_OPC_CheckField, 25, 2, 1, 170, 1, 0, // Skip to: 512 +/* 86 */ MCD_OPC_Decode, 225, 93, 140, 1, // Opcode: FNMADD_D_IN32X +/* 91 */ MCD_OPC_FilterValue, 83, 160, 1, 0, // Skip to: 512 +/* 96 */ MCD_OPC_ExtractField, 25, 7, // Inst{31-25} ... +/* 99 */ MCD_OPC_FilterValue, 1, 10, 0, 0, // Skip to: 114 +/* 104 */ MCD_OPC_CheckPredicate, 88, 147, 1, 0, // Skip to: 512 +/* 109 */ MCD_OPC_Decode, 175, 92, 141, 1, // Opcode: FADD_D_IN32X +/* 114 */ MCD_OPC_FilterValue, 5, 10, 0, 0, // Skip to: 129 +/* 119 */ MCD_OPC_CheckPredicate, 88, 132, 1, 0, // Skip to: 512 +/* 124 */ MCD_OPC_Decode, 147, 94, 141, 1, // Opcode: FSUB_D_IN32X +/* 129 */ MCD_OPC_FilterValue, 9, 10, 0, 0, // Skip to: 144 +/* 134 */ MCD_OPC_CheckPredicate, 88, 117, 1, 0, // Skip to: 512 +/* 139 */ MCD_OPC_Decode, 209, 93, 141, 1, // Opcode: FMUL_D_IN32X +/* 144 */ MCD_OPC_FilterValue, 13, 10, 0, 0, // Skip to: 159 +/* 149 */ MCD_OPC_CheckPredicate, 88, 102, 1, 0, // Skip to: 512 +/* 154 */ MCD_OPC_Decode, 132, 93, 141, 1, // Opcode: FDIV_D_IN32X +/* 159 */ MCD_OPC_FilterValue, 17, 48, 0, 0, // Skip to: 212 +/* 164 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 167 */ MCD_OPC_FilterValue, 0, 10, 0, 0, // Skip to: 182 +/* 172 */ MCD_OPC_CheckPredicate, 88, 79, 1, 0, // Skip to: 512 +/* 177 */ MCD_OPC_Decode, 132, 94, 142, 1, // Opcode: FSGNJ_D_IN32X +/* 182 */ MCD_OPC_FilterValue, 1, 10, 0, 0, // Skip to: 197 +/* 187 */ MCD_OPC_CheckPredicate, 88, 64, 1, 0, // Skip to: 512 +/* 192 */ MCD_OPC_Decode, 246, 93, 142, 1, // Opcode: FSGNJN_D_IN32X +/* 197 */ MCD_OPC_FilterValue, 2, 54, 1, 0, // Skip to: 512 +/* 202 */ MCD_OPC_CheckPredicate, 88, 49, 1, 0, // Skip to: 512 +/* 207 */ MCD_OPC_Decode, 253, 93, 142, 1, // Opcode: FSGNJX_D_IN32X +/* 212 */ MCD_OPC_FilterValue, 21, 33, 0, 0, // Skip to: 250 +/* 217 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 220 */ MCD_OPC_FilterValue, 0, 10, 0, 0, // Skip to: 235 +/* 225 */ MCD_OPC_CheckPredicate, 88, 26, 1, 0, // Skip to: 512 +/* 230 */ MCD_OPC_Decode, 195, 93, 142, 1, // Opcode: FMIN_D_IN32X +/* 235 */ MCD_OPC_FilterValue, 1, 16, 1, 0, // Skip to: 512 +/* 240 */ MCD_OPC_CheckPredicate, 88, 11, 1, 0, // Skip to: 512 +/* 245 */ MCD_OPC_Decode, 185, 93, 142, 1, // Opcode: FMAX_D_IN32X +/* 250 */ MCD_OPC_FilterValue, 32, 17, 0, 0, // Skip to: 272 +/* 255 */ MCD_OPC_CheckPredicate, 88, 252, 0, 0, // Skip to: 512 +/* 260 */ MCD_OPC_CheckField, 20, 5, 1, 245, 0, 0, // Skip to: 512 +/* 267 */ MCD_OPC_Decode, 233, 92, 143, 1, // Opcode: FCVT_S_D_IN32X +/* 272 */ MCD_OPC_FilterValue, 33, 33, 0, 0, // Skip to: 310 +/* 277 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 280 */ MCD_OPC_FilterValue, 0, 10, 0, 0, // Skip to: 295 +/* 285 */ MCD_OPC_CheckPredicate, 88, 222, 0, 0, // Skip to: 512 +/* 290 */ MCD_OPC_Decode, 198, 92, 144, 1, // Opcode: FCVT_D_S_IN32X +/* 295 */ MCD_OPC_FilterValue, 2, 212, 0, 0, // Skip to: 512 +/* 300 */ MCD_OPC_CheckPredicate, 89, 207, 0, 0, // Skip to: 512 +/* 305 */ MCD_OPC_Decode, 191, 92, 144, 1, // Opcode: FCVT_D_H_IN32X +/* 310 */ MCD_OPC_FilterValue, 34, 17, 0, 0, // Skip to: 332 +/* 315 */ MCD_OPC_CheckPredicate, 89, 192, 0, 0, // Skip to: 512 +/* 320 */ MCD_OPC_CheckField, 20, 5, 1, 185, 0, 0, // Skip to: 512 +/* 327 */ MCD_OPC_Decode, 207, 92, 143, 1, // Opcode: FCVT_H_D_IN32X +/* 332 */ MCD_OPC_FilterValue, 45, 17, 0, 0, // Skip to: 354 +/* 337 */ MCD_OPC_CheckPredicate, 88, 170, 0, 0, // Skip to: 512 +/* 342 */ MCD_OPC_CheckField, 20, 5, 0, 163, 0, 0, // Skip to: 512 +/* 349 */ MCD_OPC_Decode, 140, 94, 145, 1, // Opcode: FSQRT_D_IN32X +/* 354 */ MCD_OPC_FilterValue, 81, 48, 0, 0, // Skip to: 407 +/* 359 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 362 */ MCD_OPC_FilterValue, 0, 10, 0, 0, // Skip to: 377 +/* 367 */ MCD_OPC_CheckPredicate, 88, 140, 0, 0, // Skip to: 512 +/* 372 */ MCD_OPC_Decode, 153, 93, 146, 1, // Opcode: FLE_D_IN32X +/* 377 */ MCD_OPC_FilterValue, 1, 10, 0, 0, // Skip to: 392 +/* 382 */ MCD_OPC_CheckPredicate, 88, 125, 0, 0, // Skip to: 512 +/* 387 */ MCD_OPC_Decode, 167, 93, 146, 1, // Opcode: FLT_D_IN32X +/* 392 */ MCD_OPC_FilterValue, 2, 115, 0, 0, // Skip to: 512 +/* 397 */ MCD_OPC_CheckPredicate, 88, 110, 0, 0, // Skip to: 512 +/* 402 */ MCD_OPC_Decode, 142, 93, 146, 1, // Opcode: FEQ_D_IN32X +/* 407 */ MCD_OPC_FilterValue, 97, 33, 0, 0, // Skip to: 445 +/* 412 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 415 */ MCD_OPC_FilterValue, 0, 10, 0, 0, // Skip to: 430 +/* 420 */ MCD_OPC_CheckPredicate, 88, 87, 0, 0, // Skip to: 512 +/* 425 */ MCD_OPC_Decode, 253, 92, 143, 1, // Opcode: FCVT_W_D_IN32X +/* 430 */ MCD_OPC_FilterValue, 1, 77, 0, 0, // Skip to: 512 +/* 435 */ MCD_OPC_CheckPredicate, 88, 72, 0, 0, // Skip to: 512 +/* 440 */ MCD_OPC_Decode, 246, 92, 143, 1, // Opcode: FCVT_WU_D_IN32X +/* 445 */ MCD_OPC_FilterValue, 105, 33, 0, 0, // Skip to: 483 +/* 450 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 453 */ MCD_OPC_FilterValue, 0, 10, 0, 0, // Skip to: 468 +/* 458 */ MCD_OPC_CheckPredicate, 88, 49, 0, 0, // Skip to: 512 +/* 463 */ MCD_OPC_Decode, 204, 92, 144, 1, // Opcode: FCVT_D_W_IN32X +/* 468 */ MCD_OPC_FilterValue, 1, 39, 0, 0, // Skip to: 512 +/* 473 */ MCD_OPC_CheckPredicate, 88, 34, 0, 0, // Skip to: 512 +/* 478 */ MCD_OPC_Decode, 202, 92, 144, 1, // Opcode: FCVT_D_WU_IN32X +/* 483 */ MCD_OPC_FilterValue, 113, 24, 0, 0, // Skip to: 512 +/* 488 */ MCD_OPC_CheckPredicate, 88, 19, 0, 0, // Skip to: 512 +/* 493 */ MCD_OPC_CheckField, 20, 5, 0, 12, 0, 0, // Skip to: 512 +/* 500 */ MCD_OPC_CheckField, 12, 3, 1, 5, 0, 0, // Skip to: 512 +/* 507 */ MCD_OPC_Decode, 182, 92, 147, 1, // Opcode: FCLASS_D_IN32X +/* 512 */ MCD_OPC_Fail, + 0 +}; + +static const uint8_t DecoderTableRVZcmp16[] = { +/* 0 */ MCD_OPC_ExtractField, 10, 6, // Inst{15-10} ... +/* 3 */ MCD_OPC_FilterValue, 43, 47, 0, 0, // Skip to: 55 +/* 8 */ MCD_OPC_ExtractField, 5, 2, // Inst{6-5} ... +/* 11 */ MCD_OPC_FilterValue, 1, 17, 0, 0, // Skip to: 33 +/* 16 */ MCD_OPC_CheckPredicate, 90, 138, 0, 0, // Skip to: 159 +/* 21 */ MCD_OPC_CheckField, 0, 2, 2, 131, 0, 0, // Skip to: 159 +/* 28 */ MCD_OPC_Decode, 154, 89, 148, 1, // Opcode: CM_MVSA01 +/* 33 */ MCD_OPC_FilterValue, 3, 121, 0, 0, // Skip to: 159 +/* 38 */ MCD_OPC_CheckPredicate, 90, 116, 0, 0, // Skip to: 159 +/* 43 */ MCD_OPC_CheckField, 0, 2, 2, 109, 0, 0, // Skip to: 159 +/* 50 */ MCD_OPC_Decode, 153, 89, 148, 1, // Opcode: CM_MVA01S +/* 55 */ MCD_OPC_FilterValue, 46, 47, 0, 0, // Skip to: 107 +/* 60 */ MCD_OPC_ExtractField, 8, 2, // Inst{9-8} ... +/* 63 */ MCD_OPC_FilterValue, 0, 17, 0, 0, // Skip to: 85 +/* 68 */ MCD_OPC_CheckPredicate, 90, 86, 0, 0, // Skip to: 159 +/* 73 */ MCD_OPC_CheckField, 0, 2, 2, 79, 0, 0, // Skip to: 159 +/* 80 */ MCD_OPC_Decode, 158, 89, 149, 1, // Opcode: CM_PUSH +/* 85 */ MCD_OPC_FilterValue, 2, 69, 0, 0, // Skip to: 159 +/* 90 */ MCD_OPC_CheckPredicate, 90, 64, 0, 0, // Skip to: 159 +/* 95 */ MCD_OPC_CheckField, 0, 2, 2, 57, 0, 0, // Skip to: 159 +/* 102 */ MCD_OPC_Decode, 155, 89, 149, 1, // Opcode: CM_POP +/* 107 */ MCD_OPC_FilterValue, 47, 47, 0, 0, // Skip to: 159 +/* 112 */ MCD_OPC_ExtractField, 8, 2, // Inst{9-8} ... +/* 115 */ MCD_OPC_FilterValue, 0, 17, 0, 0, // Skip to: 137 +/* 120 */ MCD_OPC_CheckPredicate, 90, 34, 0, 0, // Skip to: 159 +/* 125 */ MCD_OPC_CheckField, 0, 2, 2, 27, 0, 0, // Skip to: 159 +/* 132 */ MCD_OPC_Decode, 157, 89, 149, 1, // Opcode: CM_POPRETZ +/* 137 */ MCD_OPC_FilterValue, 2, 17, 0, 0, // Skip to: 159 +/* 142 */ MCD_OPC_CheckPredicate, 90, 12, 0, 0, // Skip to: 159 +/* 147 */ MCD_OPC_CheckField, 0, 2, 2, 5, 0, 0, // Skip to: 159 +/* 154 */ MCD_OPC_Decode, 156, 89, 149, 1, // Opcode: CM_POPRET +/* 159 */ MCD_OPC_Fail, + 0 +}; + +static const uint8_t DecoderTableRVZcmt16[] = { +/* 0 */ MCD_OPC_ExtractField, 0, 2, // Inst{1-0} ... +/* 3 */ MCD_OPC_FilterValue, 2, 35, 0, 0, // Skip to: 43 +/* 8 */ MCD_OPC_ExtractField, 10, 6, // Inst{15-10} ... +/* 11 */ MCD_OPC_FilterValue, 40, 27, 0, 0, // Skip to: 43 +/* 16 */ MCD_OPC_CheckPredicate, 91, 12, 0, 0, // Skip to: 33 +/* 21 */ MCD_OPC_CheckField, 7, 3, 0, 5, 0, 0, // Skip to: 33 +/* 28 */ MCD_OPC_Decode, 152, 89, 150, 1, // Opcode: CM_JT +/* 33 */ MCD_OPC_CheckPredicate, 91, 5, 0, 0, // Skip to: 43 +/* 38 */ MCD_OPC_Decode, 151, 89, 151, 1, // Opcode: CM_JALT +/* 43 */ MCD_OPC_Fail, + 0 +}; + +static const uint8_t DecoderTableRVZfinx32[] = { +/* 0 */ MCD_OPC_ExtractField, 0, 7, // Inst{6-0} ... +/* 3 */ MCD_OPC_FilterValue, 67, 48, 0, 0, // Skip to: 56 +/* 8 */ MCD_OPC_ExtractField, 25, 2, // Inst{26-25} ... +/* 11 */ MCD_OPC_FilterValue, 0, 10, 0, 0, // Skip to: 26 +/* 16 */ MCD_OPC_CheckPredicate, 92, 182, 5, 0, // Skip to: 1483 +/* 21 */ MCD_OPC_Decode, 180, 93, 152, 1, // Opcode: FMADD_S_INX +/* 26 */ MCD_OPC_FilterValue, 1, 10, 0, 0, // Skip to: 41 +/* 31 */ MCD_OPC_CheckPredicate, 93, 167, 5, 0, // Skip to: 1483 +/* 36 */ MCD_OPC_Decode, 176, 93, 152, 1, // Opcode: FMADD_D_INX +/* 41 */ MCD_OPC_FilterValue, 2, 157, 5, 0, // Skip to: 1483 +/* 46 */ MCD_OPC_CheckPredicate, 94, 152, 5, 0, // Skip to: 1483 +/* 51 */ MCD_OPC_Decode, 178, 93, 152, 1, // Opcode: FMADD_H_INX +/* 56 */ MCD_OPC_FilterValue, 71, 48, 0, 0, // Skip to: 109 +/* 61 */ MCD_OPC_ExtractField, 25, 2, // Inst{26-25} ... +/* 64 */ MCD_OPC_FilterValue, 0, 10, 0, 0, // Skip to: 79 +/* 69 */ MCD_OPC_CheckPredicate, 92, 129, 5, 0, // Skip to: 1483 +/* 74 */ MCD_OPC_Decode, 207, 93, 152, 1, // Opcode: FMSUB_S_INX +/* 79 */ MCD_OPC_FilterValue, 1, 10, 0, 0, // Skip to: 94 +/* 84 */ MCD_OPC_CheckPredicate, 93, 114, 5, 0, // Skip to: 1483 +/* 89 */ MCD_OPC_Decode, 203, 93, 152, 1, // Opcode: FMSUB_D_INX +/* 94 */ MCD_OPC_FilterValue, 2, 104, 5, 0, // Skip to: 1483 +/* 99 */ MCD_OPC_CheckPredicate, 94, 99, 5, 0, // Skip to: 1483 +/* 104 */ MCD_OPC_Decode, 205, 93, 152, 1, // Opcode: FMSUB_H_INX +/* 109 */ MCD_OPC_FilterValue, 75, 48, 0, 0, // Skip to: 162 +/* 114 */ MCD_OPC_ExtractField, 25, 2, // Inst{26-25} ... +/* 117 */ MCD_OPC_FilterValue, 0, 10, 0, 0, // Skip to: 132 +/* 122 */ MCD_OPC_CheckPredicate, 92, 76, 5, 0, // Skip to: 1483 +/* 127 */ MCD_OPC_Decode, 237, 93, 152, 1, // Opcode: FNMSUB_S_INX +/* 132 */ MCD_OPC_FilterValue, 1, 10, 0, 0, // Skip to: 147 +/* 137 */ MCD_OPC_CheckPredicate, 93, 61, 5, 0, // Skip to: 1483 +/* 142 */ MCD_OPC_Decode, 233, 93, 152, 1, // Opcode: FNMSUB_D_INX +/* 147 */ MCD_OPC_FilterValue, 2, 51, 5, 0, // Skip to: 1483 +/* 152 */ MCD_OPC_CheckPredicate, 94, 46, 5, 0, // Skip to: 1483 +/* 157 */ MCD_OPC_Decode, 235, 93, 152, 1, // Opcode: FNMSUB_H_INX +/* 162 */ MCD_OPC_FilterValue, 79, 48, 0, 0, // Skip to: 215 +/* 167 */ MCD_OPC_ExtractField, 25, 2, // Inst{26-25} ... +/* 170 */ MCD_OPC_FilterValue, 0, 10, 0, 0, // Skip to: 185 +/* 175 */ MCD_OPC_CheckPredicate, 92, 23, 5, 0, // Skip to: 1483 +/* 180 */ MCD_OPC_Decode, 230, 93, 152, 1, // Opcode: FNMADD_S_INX +/* 185 */ MCD_OPC_FilterValue, 1, 10, 0, 0, // Skip to: 200 +/* 190 */ MCD_OPC_CheckPredicate, 93, 8, 5, 0, // Skip to: 1483 +/* 195 */ MCD_OPC_Decode, 226, 93, 152, 1, // Opcode: FNMADD_D_INX +/* 200 */ MCD_OPC_FilterValue, 2, 254, 4, 0, // Skip to: 1483 +/* 205 */ MCD_OPC_CheckPredicate, 94, 249, 4, 0, // Skip to: 1483 +/* 210 */ MCD_OPC_Decode, 228, 93, 152, 1, // Opcode: FNMADD_H_INX +/* 215 */ MCD_OPC_FilterValue, 83, 239, 4, 0, // Skip to: 1483 +/* 220 */ MCD_OPC_ExtractField, 25, 7, // Inst{31-25} ... +/* 223 */ MCD_OPC_FilterValue, 0, 10, 0, 0, // Skip to: 238 +/* 228 */ MCD_OPC_CheckPredicate, 92, 226, 4, 0, // Skip to: 1483 +/* 233 */ MCD_OPC_Decode, 180, 92, 153, 1, // Opcode: FADD_S_INX +/* 238 */ MCD_OPC_FilterValue, 1, 10, 0, 0, // Skip to: 253 +/* 243 */ MCD_OPC_CheckPredicate, 93, 211, 4, 0, // Skip to: 1483 +/* 248 */ MCD_OPC_Decode, 176, 92, 153, 1, // Opcode: FADD_D_INX +/* 253 */ MCD_OPC_FilterValue, 2, 10, 0, 0, // Skip to: 268 +/* 258 */ MCD_OPC_CheckPredicate, 94, 196, 4, 0, // Skip to: 1483 +/* 263 */ MCD_OPC_Decode, 178, 92, 153, 1, // Opcode: FADD_H_INX +/* 268 */ MCD_OPC_FilterValue, 4, 10, 0, 0, // Skip to: 283 +/* 273 */ MCD_OPC_CheckPredicate, 92, 181, 4, 0, // Skip to: 1483 +/* 278 */ MCD_OPC_Decode, 152, 94, 153, 1, // Opcode: FSUB_S_INX +/* 283 */ MCD_OPC_FilterValue, 5, 10, 0, 0, // Skip to: 298 +/* 288 */ MCD_OPC_CheckPredicate, 93, 166, 4, 0, // Skip to: 1483 +/* 293 */ MCD_OPC_Decode, 148, 94, 153, 1, // Opcode: FSUB_D_INX +/* 298 */ MCD_OPC_FilterValue, 6, 10, 0, 0, // Skip to: 313 +/* 303 */ MCD_OPC_CheckPredicate, 94, 151, 4, 0, // Skip to: 1483 +/* 308 */ MCD_OPC_Decode, 150, 94, 153, 1, // Opcode: FSUB_H_INX +/* 313 */ MCD_OPC_FilterValue, 8, 10, 0, 0, // Skip to: 328 +/* 318 */ MCD_OPC_CheckPredicate, 92, 136, 4, 0, // Skip to: 1483 +/* 323 */ MCD_OPC_Decode, 214, 93, 153, 1, // Opcode: FMUL_S_INX +/* 328 */ MCD_OPC_FilterValue, 9, 10, 0, 0, // Skip to: 343 +/* 333 */ MCD_OPC_CheckPredicate, 93, 121, 4, 0, // Skip to: 1483 +/* 338 */ MCD_OPC_Decode, 210, 93, 153, 1, // Opcode: FMUL_D_INX +/* 343 */ MCD_OPC_FilterValue, 10, 10, 0, 0, // Skip to: 358 +/* 348 */ MCD_OPC_CheckPredicate, 94, 106, 4, 0, // Skip to: 1483 +/* 353 */ MCD_OPC_Decode, 212, 93, 153, 1, // Opcode: FMUL_H_INX +/* 358 */ MCD_OPC_FilterValue, 12, 10, 0, 0, // Skip to: 373 +/* 363 */ MCD_OPC_CheckPredicate, 92, 91, 4, 0, // Skip to: 1483 +/* 368 */ MCD_OPC_Decode, 137, 93, 153, 1, // Opcode: FDIV_S_INX +/* 373 */ MCD_OPC_FilterValue, 13, 10, 0, 0, // Skip to: 388 +/* 378 */ MCD_OPC_CheckPredicate, 93, 76, 4, 0, // Skip to: 1483 +/* 383 */ MCD_OPC_Decode, 133, 93, 153, 1, // Opcode: FDIV_D_INX +/* 388 */ MCD_OPC_FilterValue, 14, 10, 0, 0, // Skip to: 403 +/* 393 */ MCD_OPC_CheckPredicate, 94, 61, 4, 0, // Skip to: 1483 +/* 398 */ MCD_OPC_Decode, 135, 93, 153, 1, // Opcode: FDIV_H_INX +/* 403 */ MCD_OPC_FilterValue, 16, 45, 0, 0, // Skip to: 453 +/* 408 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 411 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 425 +/* 416 */ MCD_OPC_CheckPredicate, 92, 38, 4, 0, // Skip to: 1483 +/* 421 */ MCD_OPC_Decode, 137, 94, 59, // Opcode: FSGNJ_S_INX +/* 425 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 439 +/* 430 */ MCD_OPC_CheckPredicate, 92, 24, 4, 0, // Skip to: 1483 +/* 435 */ MCD_OPC_Decode, 251, 93, 59, // Opcode: FSGNJN_S_INX +/* 439 */ MCD_OPC_FilterValue, 2, 15, 4, 0, // Skip to: 1483 +/* 444 */ MCD_OPC_CheckPredicate, 92, 10, 4, 0, // Skip to: 1483 +/* 449 */ MCD_OPC_Decode, 130, 94, 59, // Opcode: FSGNJX_S_INX +/* 453 */ MCD_OPC_FilterValue, 17, 45, 0, 0, // Skip to: 503 +/* 458 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 461 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 475 +/* 466 */ MCD_OPC_CheckPredicate, 93, 244, 3, 0, // Skip to: 1483 +/* 471 */ MCD_OPC_Decode, 133, 94, 59, // Opcode: FSGNJ_D_INX +/* 475 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 489 +/* 480 */ MCD_OPC_CheckPredicate, 93, 230, 3, 0, // Skip to: 1483 +/* 485 */ MCD_OPC_Decode, 247, 93, 59, // Opcode: FSGNJN_D_INX +/* 489 */ MCD_OPC_FilterValue, 2, 221, 3, 0, // Skip to: 1483 +/* 494 */ MCD_OPC_CheckPredicate, 93, 216, 3, 0, // Skip to: 1483 +/* 499 */ MCD_OPC_Decode, 254, 93, 59, // Opcode: FSGNJX_D_INX +/* 503 */ MCD_OPC_FilterValue, 18, 45, 0, 0, // Skip to: 553 +/* 508 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 511 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 525 +/* 516 */ MCD_OPC_CheckPredicate, 94, 194, 3, 0, // Skip to: 1483 +/* 521 */ MCD_OPC_Decode, 135, 94, 59, // Opcode: FSGNJ_H_INX +/* 525 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 539 +/* 530 */ MCD_OPC_CheckPredicate, 94, 180, 3, 0, // Skip to: 1483 +/* 535 */ MCD_OPC_Decode, 249, 93, 59, // Opcode: FSGNJN_H_INX +/* 539 */ MCD_OPC_FilterValue, 2, 171, 3, 0, // Skip to: 1483 +/* 544 */ MCD_OPC_CheckPredicate, 94, 166, 3, 0, // Skip to: 1483 +/* 549 */ MCD_OPC_Decode, 128, 94, 59, // Opcode: FSGNJX_H_INX +/* 553 */ MCD_OPC_FilterValue, 20, 31, 0, 0, // Skip to: 589 +/* 558 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 561 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 575 +/* 566 */ MCD_OPC_CheckPredicate, 92, 144, 3, 0, // Skip to: 1483 +/* 571 */ MCD_OPC_Decode, 200, 93, 59, // Opcode: FMIN_S_INX +/* 575 */ MCD_OPC_FilterValue, 1, 135, 3, 0, // Skip to: 1483 +/* 580 */ MCD_OPC_CheckPredicate, 92, 130, 3, 0, // Skip to: 1483 +/* 585 */ MCD_OPC_Decode, 190, 93, 59, // Opcode: FMAX_S_INX +/* 589 */ MCD_OPC_FilterValue, 21, 31, 0, 0, // Skip to: 625 +/* 594 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 597 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 611 +/* 602 */ MCD_OPC_CheckPredicate, 93, 108, 3, 0, // Skip to: 1483 +/* 607 */ MCD_OPC_Decode, 196, 93, 59, // Opcode: FMIN_D_INX +/* 611 */ MCD_OPC_FilterValue, 1, 99, 3, 0, // Skip to: 1483 +/* 616 */ MCD_OPC_CheckPredicate, 93, 94, 3, 0, // Skip to: 1483 +/* 621 */ MCD_OPC_Decode, 186, 93, 59, // Opcode: FMAX_D_INX +/* 625 */ MCD_OPC_FilterValue, 22, 31, 0, 0, // Skip to: 661 +/* 630 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 633 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 647 +/* 638 */ MCD_OPC_CheckPredicate, 94, 72, 3, 0, // Skip to: 1483 +/* 643 */ MCD_OPC_Decode, 198, 93, 59, // Opcode: FMIN_H_INX +/* 647 */ MCD_OPC_FilterValue, 1, 63, 3, 0, // Skip to: 1483 +/* 652 */ MCD_OPC_CheckPredicate, 94, 58, 3, 0, // Skip to: 1483 +/* 657 */ MCD_OPC_Decode, 188, 93, 59, // Opcode: FMAX_H_INX +/* 661 */ MCD_OPC_FilterValue, 32, 33, 0, 0, // Skip to: 699 +/* 666 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 669 */ MCD_OPC_FilterValue, 1, 10, 0, 0, // Skip to: 684 +/* 674 */ MCD_OPC_CheckPredicate, 93, 36, 3, 0, // Skip to: 1483 +/* 679 */ MCD_OPC_Decode, 234, 92, 154, 1, // Opcode: FCVT_S_D_INX +/* 684 */ MCD_OPC_FilterValue, 2, 26, 3, 0, // Skip to: 1483 +/* 689 */ MCD_OPC_CheckPredicate, 95, 21, 3, 0, // Skip to: 1483 +/* 694 */ MCD_OPC_Decode, 236, 92, 154, 1, // Opcode: FCVT_S_H_INX +/* 699 */ MCD_OPC_FilterValue, 33, 33, 0, 0, // Skip to: 737 +/* 704 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 707 */ MCD_OPC_FilterValue, 0, 10, 0, 0, // Skip to: 722 +/* 712 */ MCD_OPC_CheckPredicate, 93, 254, 2, 0, // Skip to: 1483 +/* 717 */ MCD_OPC_Decode, 199, 92, 154, 1, // Opcode: FCVT_D_S_INX +/* 722 */ MCD_OPC_FilterValue, 2, 244, 2, 0, // Skip to: 1483 +/* 727 */ MCD_OPC_CheckPredicate, 96, 239, 2, 0, // Skip to: 1483 +/* 732 */ MCD_OPC_Decode, 192, 92, 154, 1, // Opcode: FCVT_D_H_INX +/* 737 */ MCD_OPC_FilterValue, 34, 33, 0, 0, // Skip to: 775 +/* 742 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 745 */ MCD_OPC_FilterValue, 0, 10, 0, 0, // Skip to: 760 +/* 750 */ MCD_OPC_CheckPredicate, 95, 216, 2, 0, // Skip to: 1483 +/* 755 */ MCD_OPC_Decode, 214, 92, 154, 1, // Opcode: FCVT_H_S_INX +/* 760 */ MCD_OPC_FilterValue, 1, 206, 2, 0, // Skip to: 1483 +/* 765 */ MCD_OPC_CheckPredicate, 96, 201, 2, 0, // Skip to: 1483 +/* 770 */ MCD_OPC_Decode, 208, 92, 154, 1, // Opcode: FCVT_H_D_INX +/* 775 */ MCD_OPC_FilterValue, 44, 17, 0, 0, // Skip to: 797 +/* 780 */ MCD_OPC_CheckPredicate, 92, 186, 2, 0, // Skip to: 1483 +/* 785 */ MCD_OPC_CheckField, 20, 5, 0, 179, 2, 0, // Skip to: 1483 +/* 792 */ MCD_OPC_Decode, 145, 94, 154, 1, // Opcode: FSQRT_S_INX +/* 797 */ MCD_OPC_FilterValue, 45, 17, 0, 0, // Skip to: 819 +/* 802 */ MCD_OPC_CheckPredicate, 93, 164, 2, 0, // Skip to: 1483 +/* 807 */ MCD_OPC_CheckField, 20, 5, 0, 157, 2, 0, // Skip to: 1483 +/* 814 */ MCD_OPC_Decode, 141, 94, 154, 1, // Opcode: FSQRT_D_INX +/* 819 */ MCD_OPC_FilterValue, 46, 17, 0, 0, // Skip to: 841 +/* 824 */ MCD_OPC_CheckPredicate, 94, 142, 2, 0, // Skip to: 1483 +/* 829 */ MCD_OPC_CheckField, 20, 5, 0, 135, 2, 0, // Skip to: 1483 +/* 836 */ MCD_OPC_Decode, 143, 94, 154, 1, // Opcode: FSQRT_H_INX +/* 841 */ MCD_OPC_FilterValue, 80, 45, 0, 0, // Skip to: 891 +/* 846 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 849 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 863 +/* 854 */ MCD_OPC_CheckPredicate, 92, 112, 2, 0, // Skip to: 1483 +/* 859 */ MCD_OPC_Decode, 158, 93, 59, // Opcode: FLE_S_INX +/* 863 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 877 +/* 868 */ MCD_OPC_CheckPredicate, 92, 98, 2, 0, // Skip to: 1483 +/* 873 */ MCD_OPC_Decode, 172, 93, 59, // Opcode: FLT_S_INX +/* 877 */ MCD_OPC_FilterValue, 2, 89, 2, 0, // Skip to: 1483 +/* 882 */ MCD_OPC_CheckPredicate, 92, 84, 2, 0, // Skip to: 1483 +/* 887 */ MCD_OPC_Decode, 147, 93, 59, // Opcode: FEQ_S_INX +/* 891 */ MCD_OPC_FilterValue, 81, 45, 0, 0, // Skip to: 941 +/* 896 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 899 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 913 +/* 904 */ MCD_OPC_CheckPredicate, 93, 62, 2, 0, // Skip to: 1483 +/* 909 */ MCD_OPC_Decode, 154, 93, 59, // Opcode: FLE_D_INX +/* 913 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 927 +/* 918 */ MCD_OPC_CheckPredicate, 93, 48, 2, 0, // Skip to: 1483 +/* 923 */ MCD_OPC_Decode, 168, 93, 59, // Opcode: FLT_D_INX +/* 927 */ MCD_OPC_FilterValue, 2, 39, 2, 0, // Skip to: 1483 +/* 932 */ MCD_OPC_CheckPredicate, 93, 34, 2, 0, // Skip to: 1483 +/* 937 */ MCD_OPC_Decode, 143, 93, 59, // Opcode: FEQ_D_INX +/* 941 */ MCD_OPC_FilterValue, 82, 45, 0, 0, // Skip to: 991 +/* 946 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 949 */ MCD_OPC_FilterValue, 0, 9, 0, 0, // Skip to: 963 +/* 954 */ MCD_OPC_CheckPredicate, 94, 12, 2, 0, // Skip to: 1483 +/* 959 */ MCD_OPC_Decode, 156, 93, 59, // Opcode: FLE_H_INX +/* 963 */ MCD_OPC_FilterValue, 1, 9, 0, 0, // Skip to: 977 +/* 968 */ MCD_OPC_CheckPredicate, 94, 254, 1, 0, // Skip to: 1483 +/* 973 */ MCD_OPC_Decode, 170, 93, 59, // Opcode: FLT_H_INX +/* 977 */ MCD_OPC_FilterValue, 2, 245, 1, 0, // Skip to: 1483 +/* 982 */ MCD_OPC_CheckPredicate, 94, 240, 1, 0, // Skip to: 1483 +/* 987 */ MCD_OPC_Decode, 145, 93, 59, // Opcode: FEQ_H_INX +/* 991 */ MCD_OPC_FilterValue, 96, 63, 0, 0, // Skip to: 1059 +/* 996 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 999 */ MCD_OPC_FilterValue, 0, 10, 0, 0, // Skip to: 1014 +/* 1004 */ MCD_OPC_CheckPredicate, 92, 218, 1, 0, // Skip to: 1483 +/* 1009 */ MCD_OPC_Decode, 130, 93, 154, 1, // Opcode: FCVT_W_S_INX +/* 1014 */ MCD_OPC_FilterValue, 1, 10, 0, 0, // Skip to: 1029 +/* 1019 */ MCD_OPC_CheckPredicate, 92, 203, 1, 0, // Skip to: 1483 +/* 1024 */ MCD_OPC_Decode, 251, 92, 154, 1, // Opcode: FCVT_WU_S_INX +/* 1029 */ MCD_OPC_FilterValue, 2, 10, 0, 0, // Skip to: 1044 +/* 1034 */ MCD_OPC_CheckPredicate, 97, 188, 1, 0, // Skip to: 1483 +/* 1039 */ MCD_OPC_Decode, 230, 92, 154, 1, // Opcode: FCVT_L_S_INX +/* 1044 */ MCD_OPC_FilterValue, 3, 178, 1, 0, // Skip to: 1483 +/* 1049 */ MCD_OPC_CheckPredicate, 97, 173, 1, 0, // Skip to: 1483 +/* 1054 */ MCD_OPC_Decode, 224, 92, 154, 1, // Opcode: FCVT_LU_S_INX +/* 1059 */ MCD_OPC_FilterValue, 97, 63, 0, 0, // Skip to: 1127 +/* 1064 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 1067 */ MCD_OPC_FilterValue, 0, 10, 0, 0, // Skip to: 1082 +/* 1072 */ MCD_OPC_CheckPredicate, 93, 150, 1, 0, // Skip to: 1483 +/* 1077 */ MCD_OPC_Decode, 254, 92, 154, 1, // Opcode: FCVT_W_D_INX +/* 1082 */ MCD_OPC_FilterValue, 1, 10, 0, 0, // Skip to: 1097 +/* 1087 */ MCD_OPC_CheckPredicate, 93, 135, 1, 0, // Skip to: 1483 +/* 1092 */ MCD_OPC_Decode, 247, 92, 154, 1, // Opcode: FCVT_WU_D_INX +/* 1097 */ MCD_OPC_FilterValue, 2, 10, 0, 0, // Skip to: 1112 +/* 1102 */ MCD_OPC_CheckPredicate, 98, 120, 1, 0, // Skip to: 1483 +/* 1107 */ MCD_OPC_Decode, 226, 92, 154, 1, // Opcode: FCVT_L_D_INX +/* 1112 */ MCD_OPC_FilterValue, 3, 110, 1, 0, // Skip to: 1483 +/* 1117 */ MCD_OPC_CheckPredicate, 98, 105, 1, 0, // Skip to: 1483 +/* 1122 */ MCD_OPC_Decode, 220, 92, 154, 1, // Opcode: FCVT_LU_D_INX +/* 1127 */ MCD_OPC_FilterValue, 98, 63, 0, 0, // Skip to: 1195 +/* 1132 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 1135 */ MCD_OPC_FilterValue, 0, 10, 0, 0, // Skip to: 1150 +/* 1140 */ MCD_OPC_CheckPredicate, 94, 82, 1, 0, // Skip to: 1483 +/* 1145 */ MCD_OPC_Decode, 128, 93, 154, 1, // Opcode: FCVT_W_H_INX +/* 1150 */ MCD_OPC_FilterValue, 1, 10, 0, 0, // Skip to: 1165 +/* 1155 */ MCD_OPC_CheckPredicate, 94, 67, 1, 0, // Skip to: 1483 +/* 1160 */ MCD_OPC_Decode, 249, 92, 154, 1, // Opcode: FCVT_WU_H_INX +/* 1165 */ MCD_OPC_FilterValue, 2, 10, 0, 0, // Skip to: 1180 +/* 1170 */ MCD_OPC_CheckPredicate, 99, 52, 1, 0, // Skip to: 1483 +/* 1175 */ MCD_OPC_Decode, 228, 92, 154, 1, // Opcode: FCVT_L_H_INX +/* 1180 */ MCD_OPC_FilterValue, 3, 42, 1, 0, // Skip to: 1483 +/* 1185 */ MCD_OPC_CheckPredicate, 99, 37, 1, 0, // Skip to: 1483 +/* 1190 */ MCD_OPC_Decode, 222, 92, 154, 1, // Opcode: FCVT_LU_H_INX +/* 1195 */ MCD_OPC_FilterValue, 104, 63, 0, 0, // Skip to: 1263 +/* 1200 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 1203 */ MCD_OPC_FilterValue, 0, 10, 0, 0, // Skip to: 1218 +/* 1208 */ MCD_OPC_CheckPredicate, 92, 14, 1, 0, // Skip to: 1483 +/* 1213 */ MCD_OPC_Decode, 244, 92, 154, 1, // Opcode: FCVT_S_W_INX +/* 1218 */ MCD_OPC_FilterValue, 1, 10, 0, 0, // Skip to: 1233 +/* 1223 */ MCD_OPC_CheckPredicate, 92, 255, 0, 0, // Skip to: 1483 +/* 1228 */ MCD_OPC_Decode, 243, 92, 154, 1, // Opcode: FCVT_S_WU_INX +/* 1233 */ MCD_OPC_FilterValue, 2, 10, 0, 0, // Skip to: 1248 +/* 1238 */ MCD_OPC_CheckPredicate, 97, 240, 0, 0, // Skip to: 1483 +/* 1243 */ MCD_OPC_Decode, 240, 92, 154, 1, // Opcode: FCVT_S_L_INX +/* 1248 */ MCD_OPC_FilterValue, 3, 230, 0, 0, // Skip to: 1483 +/* 1253 */ MCD_OPC_CheckPredicate, 97, 225, 0, 0, // Skip to: 1483 +/* 1258 */ MCD_OPC_Decode, 239, 92, 154, 1, // Opcode: FCVT_S_LU_INX +/* 1263 */ MCD_OPC_FilterValue, 105, 63, 0, 0, // Skip to: 1331 +/* 1268 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 1271 */ MCD_OPC_FilterValue, 0, 10, 0, 0, // Skip to: 1286 +/* 1276 */ MCD_OPC_CheckPredicate, 93, 202, 0, 0, // Skip to: 1483 +/* 1281 */ MCD_OPC_Decode, 205, 92, 154, 1, // Opcode: FCVT_D_W_INX +/* 1286 */ MCD_OPC_FilterValue, 1, 10, 0, 0, // Skip to: 1301 +/* 1291 */ MCD_OPC_CheckPredicate, 93, 187, 0, 0, // Skip to: 1483 +/* 1296 */ MCD_OPC_Decode, 203, 92, 154, 1, // Opcode: FCVT_D_WU_INX +/* 1301 */ MCD_OPC_FilterValue, 2, 10, 0, 0, // Skip to: 1316 +/* 1306 */ MCD_OPC_CheckPredicate, 98, 172, 0, 0, // Skip to: 1483 +/* 1311 */ MCD_OPC_Decode, 196, 92, 154, 1, // Opcode: FCVT_D_L_INX +/* 1316 */ MCD_OPC_FilterValue, 3, 162, 0, 0, // Skip to: 1483 +/* 1321 */ MCD_OPC_CheckPredicate, 98, 157, 0, 0, // Skip to: 1483 +/* 1326 */ MCD_OPC_Decode, 195, 92, 154, 1, // Opcode: FCVT_D_LU_INX +/* 1331 */ MCD_OPC_FilterValue, 106, 63, 0, 0, // Skip to: 1399 +/* 1336 */ MCD_OPC_ExtractField, 20, 5, // Inst{24-20} ... +/* 1339 */ MCD_OPC_FilterValue, 0, 10, 0, 0, // Skip to: 1354 +/* 1344 */ MCD_OPC_CheckPredicate, 94, 134, 0, 0, // Skip to: 1483 +/* 1349 */ MCD_OPC_Decode, 218, 92, 154, 1, // Opcode: FCVT_H_W_INX +/* 1354 */ MCD_OPC_FilterValue, 1, 10, 0, 0, // Skip to: 1369 +/* 1359 */ MCD_OPC_CheckPredicate, 94, 119, 0, 0, // Skip to: 1483 +/* 1364 */ MCD_OPC_Decode, 217, 92, 154, 1, // Opcode: FCVT_H_WU_INX +/* 1369 */ MCD_OPC_FilterValue, 2, 10, 0, 0, // Skip to: 1384 +/* 1374 */ MCD_OPC_CheckPredicate, 99, 104, 0, 0, // Skip to: 1483 +/* 1379 */ MCD_OPC_Decode, 212, 92, 154, 1, // Opcode: FCVT_H_L_INX +/* 1384 */ MCD_OPC_FilterValue, 3, 94, 0, 0, // Skip to: 1483 +/* 1389 */ MCD_OPC_CheckPredicate, 99, 89, 0, 0, // Skip to: 1483 +/* 1394 */ MCD_OPC_Decode, 211, 92, 154, 1, // Opcode: FCVT_H_LU_INX +/* 1399 */ MCD_OPC_FilterValue, 112, 23, 0, 0, // Skip to: 1427 +/* 1404 */ MCD_OPC_CheckPredicate, 92, 74, 0, 0, // Skip to: 1483 +/* 1409 */ MCD_OPC_CheckField, 20, 5, 0, 67, 0, 0, // Skip to: 1483 +/* 1416 */ MCD_OPC_CheckField, 12, 3, 1, 60, 0, 0, // Skip to: 1483 +/* 1423 */ MCD_OPC_Decode, 187, 92, 49, // Opcode: FCLASS_S_INX +/* 1427 */ MCD_OPC_FilterValue, 113, 23, 0, 0, // Skip to: 1455 +/* 1432 */ MCD_OPC_CheckPredicate, 93, 46, 0, 0, // Skip to: 1483 +/* 1437 */ MCD_OPC_CheckField, 20, 5, 0, 39, 0, 0, // Skip to: 1483 +/* 1444 */ MCD_OPC_CheckField, 12, 3, 1, 32, 0, 0, // Skip to: 1483 +/* 1451 */ MCD_OPC_Decode, 183, 92, 49, // Opcode: FCLASS_D_INX +/* 1455 */ MCD_OPC_FilterValue, 114, 23, 0, 0, // Skip to: 1483 +/* 1460 */ MCD_OPC_CheckPredicate, 94, 18, 0, 0, // Skip to: 1483 +/* 1465 */ MCD_OPC_CheckField, 20, 5, 0, 11, 0, 0, // Skip to: 1483 +/* 1472 */ MCD_OPC_CheckField, 12, 3, 1, 4, 0, 0, // Skip to: 1483 +/* 1479 */ MCD_OPC_Decode, 185, 92, 49, // Opcode: FCLASS_H_INX +/* 1483 */ MCD_OPC_Fail, + 0 +}; + +static const uint8_t DecoderTableXCValu32[] = { +/* 0 */ MCD_OPC_ExtractField, 30, 2, // Inst{31-30} ... +/* 3 */ MCD_OPC_FilterValue, 0, 47, 0, 0, // Skip to: 55 +/* 8 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 11 */ MCD_OPC_FilterValue, 2, 17, 0, 0, // Skip to: 33 +/* 16 */ MCD_OPC_CheckPredicate, 100, 200, 2, 0, // Skip to: 733 +/* 21 */ MCD_OPC_CheckField, 0, 7, 91, 193, 2, 0, // Skip to: 733 +/* 28 */ MCD_OPC_Decode, 172, 89, 155, 1, // Opcode: CV_ADDN +/* 33 */ MCD_OPC_FilterValue, 3, 183, 2, 0, // Skip to: 733 +/* 38 */ MCD_OPC_CheckPredicate, 100, 178, 2, 0, // Skip to: 733 +/* 43 */ MCD_OPC_CheckField, 0, 7, 91, 171, 2, 0, // Skip to: 733 +/* 50 */ MCD_OPC_Decode, 195, 91, 155, 1, // Opcode: CV_SUBN +/* 55 */ MCD_OPC_FilterValue, 1, 143, 1, 0, // Skip to: 459 +/* 60 */ MCD_OPC_ExtractField, 0, 7, // Inst{6-0} ... +/* 63 */ MCD_OPC_FilterValue, 43, 97, 1, 0, // Skip to: 421 +/* 68 */ MCD_OPC_ExtractField, 25, 5, // Inst{29-25} ... +/* 71 */ MCD_OPC_FilterValue, 8, 23, 0, 0, // Skip to: 99 +/* 76 */ MCD_OPC_CheckPredicate, 100, 140, 2, 0, // Skip to: 733 +/* 81 */ MCD_OPC_CheckField, 20, 5, 0, 133, 2, 0, // Skip to: 733 +/* 88 */ MCD_OPC_CheckField, 12, 3, 3, 126, 2, 0, // Skip to: 733 +/* 95 */ MCD_OPC_Decode, 169, 89, 49, // Opcode: CV_ABS +/* 99 */ MCD_OPC_FilterValue, 9, 16, 0, 0, // Skip to: 120 +/* 104 */ MCD_OPC_CheckPredicate, 100, 112, 2, 0, // Skip to: 733 +/* 109 */ MCD_OPC_CheckField, 12, 3, 3, 105, 2, 0, // Skip to: 733 +/* 116 */ MCD_OPC_Decode, 175, 91, 59, // Opcode: CV_SLET +/* 120 */ MCD_OPC_FilterValue, 10, 16, 0, 0, // Skip to: 141 +/* 125 */ MCD_OPC_CheckPredicate, 100, 91, 2, 0, // Skip to: 733 +/* 130 */ MCD_OPC_CheckField, 12, 3, 3, 84, 2, 0, // Skip to: 733 +/* 137 */ MCD_OPC_Decode, 176, 91, 59, // Opcode: CV_SLETU +/* 141 */ MCD_OPC_FilterValue, 11, 16, 0, 0, // Skip to: 162 +/* 146 */ MCD_OPC_CheckPredicate, 100, 70, 2, 0, // Skip to: 733 +/* 151 */ MCD_OPC_CheckField, 12, 3, 3, 63, 2, 0, // Skip to: 733 +/* 158 */ MCD_OPC_Decode, 236, 90, 59, // Opcode: CV_MIN +/* 162 */ MCD_OPC_FilterValue, 12, 16, 0, 0, // Skip to: 183 +/* 167 */ MCD_OPC_CheckPredicate, 100, 49, 2, 0, // Skip to: 733 +/* 172 */ MCD_OPC_CheckField, 12, 3, 3, 42, 2, 0, // Skip to: 733 +/* 179 */ MCD_OPC_Decode, 237, 90, 59, // Opcode: CV_MINU +/* 183 */ MCD_OPC_FilterValue, 13, 16, 0, 0, // Skip to: 204 +/* 188 */ MCD_OPC_CheckPredicate, 100, 28, 2, 0, // Skip to: 733 +/* 193 */ MCD_OPC_CheckField, 12, 3, 3, 21, 2, 0, // Skip to: 733 +/* 200 */ MCD_OPC_Decode, 222, 90, 59, // Opcode: CV_MAX +/* 204 */ MCD_OPC_FilterValue, 14, 16, 0, 0, // Skip to: 225 +/* 209 */ MCD_OPC_CheckPredicate, 100, 7, 2, 0, // Skip to: 733 +/* 214 */ MCD_OPC_CheckField, 12, 3, 3, 0, 2, 0, // Skip to: 733 +/* 221 */ MCD_OPC_Decode, 223, 90, 59, // Opcode: CV_MAXU +/* 225 */ MCD_OPC_FilterValue, 16, 23, 0, 0, // Skip to: 253 +/* 230 */ MCD_OPC_CheckPredicate, 100, 242, 1, 0, // Skip to: 733 +/* 235 */ MCD_OPC_CheckField, 20, 5, 0, 235, 1, 0, // Skip to: 733 +/* 242 */ MCD_OPC_CheckField, 12, 3, 3, 228, 1, 0, // Skip to: 733 +/* 249 */ MCD_OPC_Decode, 182, 90, 49, // Opcode: CV_EXTHS +/* 253 */ MCD_OPC_FilterValue, 17, 23, 0, 0, // Skip to: 281 +/* 258 */ MCD_OPC_CheckPredicate, 100, 214, 1, 0, // Skip to: 733 +/* 263 */ MCD_OPC_CheckField, 20, 5, 0, 207, 1, 0, // Skip to: 733 +/* 270 */ MCD_OPC_CheckField, 12, 3, 3, 200, 1, 0, // Skip to: 733 +/* 277 */ MCD_OPC_Decode, 183, 90, 49, // Opcode: CV_EXTHZ +/* 281 */ MCD_OPC_FilterValue, 18, 23, 0, 0, // Skip to: 309 +/* 286 */ MCD_OPC_CheckPredicate, 100, 186, 1, 0, // Skip to: 733 +/* 291 */ MCD_OPC_CheckField, 20, 5, 0, 179, 1, 0, // Skip to: 733 +/* 298 */ MCD_OPC_CheckField, 12, 3, 3, 172, 1, 0, // Skip to: 733 +/* 305 */ MCD_OPC_Decode, 180, 90, 49, // Opcode: CV_EXTBS +/* 309 */ MCD_OPC_FilterValue, 19, 23, 0, 0, // Skip to: 337 +/* 314 */ MCD_OPC_CheckPredicate, 100, 158, 1, 0, // Skip to: 733 +/* 319 */ MCD_OPC_CheckField, 20, 5, 0, 151, 1, 0, // Skip to: 733 +/* 326 */ MCD_OPC_CheckField, 12, 3, 3, 144, 1, 0, // Skip to: 733 +/* 333 */ MCD_OPC_Decode, 181, 90, 49, // Opcode: CV_EXTBZ +/* 337 */ MCD_OPC_FilterValue, 24, 16, 0, 0, // Skip to: 358 +/* 342 */ MCD_OPC_CheckPredicate, 100, 130, 1, 0, // Skip to: 733 +/* 347 */ MCD_OPC_CheckField, 12, 3, 3, 123, 1, 0, // Skip to: 733 +/* 354 */ MCD_OPC_Decode, 215, 89, 53, // Opcode: CV_CLIP +/* 358 */ MCD_OPC_FilterValue, 25, 16, 0, 0, // Skip to: 379 +/* 363 */ MCD_OPC_CheckPredicate, 100, 109, 1, 0, // Skip to: 733 +/* 368 */ MCD_OPC_CheckField, 12, 3, 3, 102, 1, 0, // Skip to: 733 +/* 375 */ MCD_OPC_Decode, 217, 89, 53, // Opcode: CV_CLIPU +/* 379 */ MCD_OPC_FilterValue, 26, 16, 0, 0, // Skip to: 400 +/* 384 */ MCD_OPC_CheckPredicate, 100, 88, 1, 0, // Skip to: 733 +/* 389 */ MCD_OPC_CheckField, 12, 3, 3, 81, 1, 0, // Skip to: 733 +/* 396 */ MCD_OPC_Decode, 216, 89, 59, // Opcode: CV_CLIPR +/* 400 */ MCD_OPC_FilterValue, 27, 72, 1, 0, // Skip to: 733 +/* 405 */ MCD_OPC_CheckPredicate, 100, 67, 1, 0, // Skip to: 733 +/* 410 */ MCD_OPC_CheckField, 12, 3, 3, 60, 1, 0, // Skip to: 733 +/* 417 */ MCD_OPC_Decode, 218, 89, 59, // Opcode: CV_CLIPUR +/* 421 */ MCD_OPC_FilterValue, 91, 51, 1, 0, // Skip to: 733 +/* 426 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 429 */ MCD_OPC_FilterValue, 2, 10, 0, 0, // Skip to: 444 +/* 434 */ MCD_OPC_CheckPredicate, 100, 38, 1, 0, // Skip to: 733 +/* 439 */ MCD_OPC_Decode, 176, 89, 155, 1, // Opcode: CV_ADDUN +/* 444 */ MCD_OPC_FilterValue, 3, 28, 1, 0, // Skip to: 733 +/* 449 */ MCD_OPC_CheckPredicate, 100, 23, 1, 0, // Skip to: 733 +/* 454 */ MCD_OPC_Decode, 203, 91, 155, 1, // Opcode: CV_SUBUN +/* 459 */ MCD_OPC_FilterValue, 2, 217, 0, 0, // Skip to: 681 +/* 464 */ MCD_OPC_ExtractField, 0, 7, // Inst{6-0} ... +/* 467 */ MCD_OPC_FilterValue, 43, 171, 0, 0, // Skip to: 643 +/* 472 */ MCD_OPC_ExtractField, 25, 5, // Inst{29-25} ... +/* 475 */ MCD_OPC_FilterValue, 0, 16, 0, 0, // Skip to: 496 +/* 480 */ MCD_OPC_CheckPredicate, 100, 248, 0, 0, // Skip to: 733 +/* 485 */ MCD_OPC_CheckField, 12, 3, 3, 241, 0, 0, // Skip to: 733 +/* 492 */ MCD_OPC_Decode, 173, 89, 58, // Opcode: CV_ADDNR +/* 496 */ MCD_OPC_FilterValue, 1, 16, 0, 0, // Skip to: 517 +/* 501 */ MCD_OPC_CheckPredicate, 100, 227, 0, 0, // Skip to: 733 +/* 506 */ MCD_OPC_CheckField, 12, 3, 3, 220, 0, 0, // Skip to: 733 +/* 513 */ MCD_OPC_Decode, 177, 89, 58, // Opcode: CV_ADDUNR +/* 517 */ MCD_OPC_FilterValue, 2, 16, 0, 0, // Skip to: 538 +/* 522 */ MCD_OPC_CheckPredicate, 100, 206, 0, 0, // Skip to: 733 +/* 527 */ MCD_OPC_CheckField, 12, 3, 3, 199, 0, 0, // Skip to: 733 +/* 534 */ MCD_OPC_Decode, 175, 89, 58, // Opcode: CV_ADDRNR +/* 538 */ MCD_OPC_FilterValue, 3, 16, 0, 0, // Skip to: 559 +/* 543 */ MCD_OPC_CheckPredicate, 100, 185, 0, 0, // Skip to: 733 +/* 548 */ MCD_OPC_CheckField, 12, 3, 3, 178, 0, 0, // Skip to: 733 +/* 555 */ MCD_OPC_Decode, 179, 89, 58, // Opcode: CV_ADDURNR +/* 559 */ MCD_OPC_FilterValue, 4, 16, 0, 0, // Skip to: 580 +/* 564 */ MCD_OPC_CheckPredicate, 100, 164, 0, 0, // Skip to: 733 +/* 569 */ MCD_OPC_CheckField, 12, 3, 3, 157, 0, 0, // Skip to: 733 +/* 576 */ MCD_OPC_Decode, 196, 91, 58, // Opcode: CV_SUBNR +/* 580 */ MCD_OPC_FilterValue, 5, 16, 0, 0, // Skip to: 601 +/* 585 */ MCD_OPC_CheckPredicate, 100, 143, 0, 0, // Skip to: 733 +/* 590 */ MCD_OPC_CheckField, 12, 3, 3, 136, 0, 0, // Skip to: 733 +/* 597 */ MCD_OPC_Decode, 204, 91, 58, // Opcode: CV_SUBUNR +/* 601 */ MCD_OPC_FilterValue, 6, 16, 0, 0, // Skip to: 622 +/* 606 */ MCD_OPC_CheckPredicate, 100, 122, 0, 0, // Skip to: 733 +/* 611 */ MCD_OPC_CheckField, 12, 3, 3, 115, 0, 0, // Skip to: 733 +/* 618 */ MCD_OPC_Decode, 198, 91, 58, // Opcode: CV_SUBRNR +/* 622 */ MCD_OPC_FilterValue, 7, 106, 0, 0, // Skip to: 733 +/* 627 */ MCD_OPC_CheckPredicate, 100, 101, 0, 0, // Skip to: 733 +/* 632 */ MCD_OPC_CheckField, 12, 3, 3, 94, 0, 0, // Skip to: 733 +/* 639 */ MCD_OPC_Decode, 206, 91, 58, // Opcode: CV_SUBURNR +/* 643 */ MCD_OPC_FilterValue, 91, 85, 0, 0, // Skip to: 733 +/* 648 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 651 */ MCD_OPC_FilterValue, 2, 10, 0, 0, // Skip to: 666 +/* 656 */ MCD_OPC_CheckPredicate, 100, 72, 0, 0, // Skip to: 733 +/* 661 */ MCD_OPC_Decode, 174, 89, 155, 1, // Opcode: CV_ADDRN +/* 666 */ MCD_OPC_FilterValue, 3, 62, 0, 0, // Skip to: 733 +/* 671 */ MCD_OPC_CheckPredicate, 100, 57, 0, 0, // Skip to: 733 +/* 676 */ MCD_OPC_Decode, 197, 91, 155, 1, // Opcode: CV_SUBRN +/* 681 */ MCD_OPC_FilterValue, 3, 47, 0, 0, // Skip to: 733 +/* 686 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 689 */ MCD_OPC_FilterValue, 2, 17, 0, 0, // Skip to: 711 +/* 694 */ MCD_OPC_CheckPredicate, 100, 34, 0, 0, // Skip to: 733 +/* 699 */ MCD_OPC_CheckField, 0, 7, 91, 27, 0, 0, // Skip to: 733 +/* 706 */ MCD_OPC_Decode, 178, 89, 155, 1, // Opcode: CV_ADDURN +/* 711 */ MCD_OPC_FilterValue, 3, 17, 0, 0, // Skip to: 733 +/* 716 */ MCD_OPC_CheckPredicate, 100, 12, 0, 0, // Skip to: 733 +/* 721 */ MCD_OPC_CheckField, 0, 7, 91, 5, 0, 0, // Skip to: 733 +/* 728 */ MCD_OPC_Decode, 205, 91, 155, 1, // Opcode: CV_SUBURN +/* 733 */ MCD_OPC_Fail, + 0 +}; + +static const uint8_t DecoderTableXCVbi32[] = { +/* 0 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 3 */ MCD_OPC_FilterValue, 6, 17, 0, 0, // Skip to: 25 +/* 8 */ MCD_OPC_CheckPredicate, 101, 34, 0, 0, // Skip to: 47 +/* 13 */ MCD_OPC_CheckField, 0, 7, 11, 27, 0, 0, // Skip to: 47 +/* 20 */ MCD_OPC_Decode, 209, 89, 156, 1, // Opcode: CV_BEQIMM +/* 25 */ MCD_OPC_FilterValue, 7, 17, 0, 0, // Skip to: 47 +/* 30 */ MCD_OPC_CheckPredicate, 101, 12, 0, 0, // Skip to: 47 +/* 35 */ MCD_OPC_CheckField, 0, 7, 11, 5, 0, 0, // Skip to: 47 +/* 42 */ MCD_OPC_Decode, 211, 89, 156, 1, // Opcode: CV_BNEIMM +/* 47 */ MCD_OPC_Fail, + 0 +}; + +static const uint8_t DecoderTableXCVbitmanip32[] = { +/* 0 */ MCD_OPC_ExtractField, 30, 2, // Inst{31-30} ... +/* 3 */ MCD_OPC_FilterValue, 0, 139, 0, 0, // Skip to: 147 +/* 8 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 11 */ MCD_OPC_FilterValue, 0, 17, 0, 0, // Skip to: 33 +/* 16 */ MCD_OPC_CheckPredicate, 34, 121, 1, 0, // Skip to: 398 +/* 21 */ MCD_OPC_CheckField, 0, 7, 91, 114, 1, 0, // Skip to: 398 +/* 28 */ MCD_OPC_Decode, 184, 90, 157, 1, // Opcode: CV_EXTRACT +/* 33 */ MCD_OPC_FilterValue, 1, 17, 0, 0, // Skip to: 55 +/* 38 */ MCD_OPC_CheckPredicate, 34, 99, 1, 0, // Skip to: 398 +/* 43 */ MCD_OPC_CheckField, 0, 7, 91, 92, 1, 0, // Skip to: 398 +/* 50 */ MCD_OPC_Decode, 207, 89, 157, 1, // Opcode: CV_BCLR +/* 55 */ MCD_OPC_FilterValue, 3, 82, 1, 0, // Skip to: 398 +/* 60 */ MCD_OPC_ExtractField, 25, 5, // Inst{29-25} ... +/* 63 */ MCD_OPC_FilterValue, 24, 16, 0, 0, // Skip to: 84 +/* 68 */ MCD_OPC_CheckPredicate, 34, 69, 1, 0, // Skip to: 398 +/* 73 */ MCD_OPC_CheckField, 0, 7, 43, 62, 1, 0, // Skip to: 398 +/* 80 */ MCD_OPC_Decode, 185, 90, 59, // Opcode: CV_EXTRACTR +/* 84 */ MCD_OPC_FilterValue, 25, 16, 0, 0, // Skip to: 105 +/* 89 */ MCD_OPC_CheckPredicate, 34, 48, 1, 0, // Skip to: 398 +/* 94 */ MCD_OPC_CheckField, 0, 7, 43, 41, 1, 0, // Skip to: 398 +/* 101 */ MCD_OPC_Decode, 187, 90, 59, // Opcode: CV_EXTRACTUR +/* 105 */ MCD_OPC_FilterValue, 28, 16, 0, 0, // Skip to: 126 +/* 110 */ MCD_OPC_CheckPredicate, 34, 27, 1, 0, // Skip to: 398 +/* 115 */ MCD_OPC_CheckField, 0, 7, 43, 20, 1, 0, // Skip to: 398 +/* 122 */ MCD_OPC_Decode, 208, 89, 59, // Opcode: CV_BCLRR +/* 126 */ MCD_OPC_FilterValue, 29, 11, 1, 0, // Skip to: 398 +/* 131 */ MCD_OPC_CheckPredicate, 34, 6, 1, 0, // Skip to: 398 +/* 136 */ MCD_OPC_CheckField, 0, 7, 43, 255, 0, 0, // Skip to: 398 +/* 143 */ MCD_OPC_Decode, 213, 89, 59, // Opcode: CV_BSETR +/* 147 */ MCD_OPC_FilterValue, 1, 188, 0, 0, // Skip to: 340 +/* 152 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 155 */ MCD_OPC_FilterValue, 0, 17, 0, 0, // Skip to: 177 +/* 160 */ MCD_OPC_CheckPredicate, 34, 233, 0, 0, // Skip to: 398 +/* 165 */ MCD_OPC_CheckField, 0, 7, 91, 226, 0, 0, // Skip to: 398 +/* 172 */ MCD_OPC_Decode, 186, 90, 157, 1, // Opcode: CV_EXTRACTU +/* 177 */ MCD_OPC_FilterValue, 1, 17, 0, 0, // Skip to: 199 +/* 182 */ MCD_OPC_CheckPredicate, 34, 211, 0, 0, // Skip to: 398 +/* 187 */ MCD_OPC_CheckField, 0, 7, 91, 204, 0, 0, // Skip to: 398 +/* 194 */ MCD_OPC_Decode, 212, 89, 157, 1, // Opcode: CV_BSET +/* 199 */ MCD_OPC_FilterValue, 3, 194, 0, 0, // Skip to: 398 +/* 204 */ MCD_OPC_ExtractField, 25, 5, // Inst{29-25} ... +/* 207 */ MCD_OPC_FilterValue, 0, 16, 0, 0, // Skip to: 228 +/* 212 */ MCD_OPC_CheckPredicate, 34, 181, 0, 0, // Skip to: 398 +/* 217 */ MCD_OPC_CheckField, 0, 7, 43, 174, 0, 0, // Skip to: 398 +/* 224 */ MCD_OPC_Decode, 141, 91, 59, // Opcode: CV_ROR +/* 228 */ MCD_OPC_FilterValue, 1, 23, 0, 0, // Skip to: 256 +/* 233 */ MCD_OPC_CheckPredicate, 34, 160, 0, 0, // Skip to: 398 +/* 238 */ MCD_OPC_CheckField, 20, 5, 0, 153, 0, 0, // Skip to: 398 +/* 245 */ MCD_OPC_CheckField, 0, 7, 43, 146, 0, 0, // Skip to: 398 +/* 252 */ MCD_OPC_Decode, 192, 90, 49, // Opcode: CV_FF1 +/* 256 */ MCD_OPC_FilterValue, 2, 23, 0, 0, // Skip to: 284 +/* 261 */ MCD_OPC_CheckPredicate, 34, 132, 0, 0, // Skip to: 398 +/* 266 */ MCD_OPC_CheckField, 20, 5, 0, 125, 0, 0, // Skip to: 398 +/* 273 */ MCD_OPC_CheckField, 0, 7, 43, 118, 0, 0, // Skip to: 398 +/* 280 */ MCD_OPC_Decode, 193, 90, 49, // Opcode: CV_FL1 +/* 284 */ MCD_OPC_FilterValue, 3, 23, 0, 0, // Skip to: 312 +/* 289 */ MCD_OPC_CheckPredicate, 34, 104, 0, 0, // Skip to: 398 +/* 294 */ MCD_OPC_CheckField, 20, 5, 0, 97, 0, 0, // Skip to: 398 +/* 301 */ MCD_OPC_CheckField, 0, 7, 43, 90, 0, 0, // Skip to: 398 +/* 308 */ MCD_OPC_Decode, 214, 89, 49, // Opcode: CV_CLB +/* 312 */ MCD_OPC_FilterValue, 4, 81, 0, 0, // Skip to: 398 +/* 317 */ MCD_OPC_CheckPredicate, 34, 76, 0, 0, // Skip to: 398 +/* 322 */ MCD_OPC_CheckField, 20, 5, 0, 69, 0, 0, // Skip to: 398 +/* 329 */ MCD_OPC_CheckField, 0, 7, 43, 62, 0, 0, // Skip to: 398 +/* 336 */ MCD_OPC_Decode, 151, 90, 49, // Opcode: CV_CNT +/* 340 */ MCD_OPC_FilterValue, 2, 24, 0, 0, // Skip to: 369 +/* 345 */ MCD_OPC_CheckPredicate, 34, 48, 0, 0, // Skip to: 398 +/* 350 */ MCD_OPC_CheckField, 12, 3, 0, 41, 0, 0, // Skip to: 398 +/* 357 */ MCD_OPC_CheckField, 0, 7, 91, 34, 0, 0, // Skip to: 398 +/* 364 */ MCD_OPC_Decode, 194, 90, 158, 1, // Opcode: CV_INSERT +/* 369 */ MCD_OPC_FilterValue, 3, 24, 0, 0, // Skip to: 398 +/* 374 */ MCD_OPC_CheckPredicate, 34, 19, 0, 0, // Skip to: 398 +/* 379 */ MCD_OPC_CheckField, 12, 3, 1, 12, 0, 0, // Skip to: 398 +/* 386 */ MCD_OPC_CheckField, 0, 7, 91, 5, 0, 0, // Skip to: 398 +/* 393 */ MCD_OPC_Decode, 210, 89, 159, 1, // Opcode: CV_BITREV +/* 398 */ MCD_OPC_Fail, + 0 +}; + +static const uint8_t DecoderTableXCVelw32[] = { +/* 0 */ MCD_OPC_CheckPredicate, 102, 18, 0, 0, // Skip to: 23 +/* 5 */ MCD_OPC_CheckField, 12, 3, 3, 11, 0, 0, // Skip to: 23 +/* 12 */ MCD_OPC_CheckField, 0, 7, 11, 4, 0, 0, // Skip to: 23 +/* 19 */ MCD_OPC_Decode, 179, 90, 35, // Opcode: CV_ELW +/* 23 */ MCD_OPC_Fail, + 0 +}; + +static const uint8_t DecoderTableXCVmac32[] = { +/* 0 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 3 */ MCD_OPC_FilterValue, 3, 45, 0, 0, // Skip to: 53 +/* 8 */ MCD_OPC_ExtractField, 25, 7, // Inst{31-25} ... +/* 11 */ MCD_OPC_FilterValue, 72, 16, 0, 0, // Skip to: 32 +/* 16 */ MCD_OPC_CheckPredicate, 103, 160, 1, 0, // Skip to: 437 +/* 21 */ MCD_OPC_CheckField, 0, 7, 43, 153, 1, 0, // Skip to: 437 +/* 28 */ MCD_OPC_Decode, 213, 90, 58, // Opcode: CV_MAC +/* 32 */ MCD_OPC_FilterValue, 73, 144, 1, 0, // Skip to: 437 +/* 37 */ MCD_OPC_CheckPredicate, 103, 139, 1, 0, // Skip to: 437 +/* 42 */ MCD_OPC_CheckField, 0, 7, 43, 132, 1, 0, // Skip to: 437 +/* 49 */ MCD_OPC_Decode, 250, 90, 58, // Opcode: CV_MSU +/* 53 */ MCD_OPC_FilterValue, 4, 91, 0, 0, // Skip to: 149 +/* 58 */ MCD_OPC_ExtractField, 30, 2, // Inst{31-30} ... +/* 61 */ MCD_OPC_FilterValue, 0, 17, 0, 0, // Skip to: 83 +/* 66 */ MCD_OPC_CheckPredicate, 103, 110, 1, 0, // Skip to: 437 +/* 71 */ MCD_OPC_CheckField, 0, 7, 91, 103, 1, 0, // Skip to: 437 +/* 78 */ MCD_OPC_Decode, 255, 90, 155, 1, // Opcode: CV_MULSN +/* 83 */ MCD_OPC_FilterValue, 1, 17, 0, 0, // Skip to: 105 +/* 88 */ MCD_OPC_CheckPredicate, 103, 88, 1, 0, // Skip to: 437 +/* 93 */ MCD_OPC_CheckField, 0, 7, 91, 81, 1, 0, // Skip to: 437 +/* 100 */ MCD_OPC_Decode, 251, 90, 155, 1, // Opcode: CV_MULHHSN +/* 105 */ MCD_OPC_FilterValue, 2, 17, 0, 0, // Skip to: 127 +/* 110 */ MCD_OPC_CheckPredicate, 103, 66, 1, 0, // Skip to: 437 +/* 115 */ MCD_OPC_CheckField, 0, 7, 91, 59, 1, 0, // Skip to: 437 +/* 122 */ MCD_OPC_Decode, 128, 91, 155, 1, // Opcode: CV_MULSRN +/* 127 */ MCD_OPC_FilterValue, 3, 49, 1, 0, // Skip to: 437 +/* 132 */ MCD_OPC_CheckPredicate, 103, 44, 1, 0, // Skip to: 437 +/* 137 */ MCD_OPC_CheckField, 0, 7, 91, 37, 1, 0, // Skip to: 437 +/* 144 */ MCD_OPC_Decode, 252, 90, 155, 1, // Opcode: CV_MULHHSRN +/* 149 */ MCD_OPC_FilterValue, 5, 91, 0, 0, // Skip to: 245 +/* 154 */ MCD_OPC_ExtractField, 30, 2, // Inst{31-30} ... +/* 157 */ MCD_OPC_FilterValue, 0, 17, 0, 0, // Skip to: 179 +/* 162 */ MCD_OPC_CheckPredicate, 103, 14, 1, 0, // Skip to: 437 +/* 167 */ MCD_OPC_CheckField, 0, 7, 91, 7, 1, 0, // Skip to: 437 +/* 174 */ MCD_OPC_Decode, 129, 91, 155, 1, // Opcode: CV_MULUN +/* 179 */ MCD_OPC_FilterValue, 1, 17, 0, 0, // Skip to: 201 +/* 184 */ MCD_OPC_CheckPredicate, 103, 248, 0, 0, // Skip to: 437 +/* 189 */ MCD_OPC_CheckField, 0, 7, 91, 241, 0, 0, // Skip to: 437 +/* 196 */ MCD_OPC_Decode, 253, 90, 155, 1, // Opcode: CV_MULHHUN +/* 201 */ MCD_OPC_FilterValue, 2, 17, 0, 0, // Skip to: 223 +/* 206 */ MCD_OPC_CheckPredicate, 103, 226, 0, 0, // Skip to: 437 +/* 211 */ MCD_OPC_CheckField, 0, 7, 91, 219, 0, 0, // Skip to: 437 +/* 218 */ MCD_OPC_Decode, 130, 91, 155, 1, // Opcode: CV_MULURN +/* 223 */ MCD_OPC_FilterValue, 3, 209, 0, 0, // Skip to: 437 +/* 228 */ MCD_OPC_CheckPredicate, 103, 204, 0, 0, // Skip to: 437 +/* 233 */ MCD_OPC_CheckField, 0, 7, 91, 197, 0, 0, // Skip to: 437 +/* 240 */ MCD_OPC_Decode, 254, 90, 155, 1, // Opcode: CV_MULHHURN +/* 245 */ MCD_OPC_FilterValue, 6, 91, 0, 0, // Skip to: 341 +/* 250 */ MCD_OPC_ExtractField, 30, 2, // Inst{31-30} ... +/* 253 */ MCD_OPC_FilterValue, 0, 17, 0, 0, // Skip to: 275 +/* 258 */ MCD_OPC_CheckPredicate, 103, 174, 0, 0, // Skip to: 437 +/* 263 */ MCD_OPC_CheckField, 0, 7, 91, 167, 0, 0, // Skip to: 437 +/* 270 */ MCD_OPC_Decode, 218, 90, 160, 1, // Opcode: CV_MACSN +/* 275 */ MCD_OPC_FilterValue, 1, 17, 0, 0, // Skip to: 297 +/* 280 */ MCD_OPC_CheckPredicate, 103, 152, 0, 0, // Skip to: 437 +/* 285 */ MCD_OPC_CheckField, 0, 7, 91, 145, 0, 0, // Skip to: 437 +/* 292 */ MCD_OPC_Decode, 214, 90, 160, 1, // Opcode: CV_MACHHSN +/* 297 */ MCD_OPC_FilterValue, 2, 17, 0, 0, // Skip to: 319 +/* 302 */ MCD_OPC_CheckPredicate, 103, 130, 0, 0, // Skip to: 437 +/* 307 */ MCD_OPC_CheckField, 0, 7, 91, 123, 0, 0, // Skip to: 437 +/* 314 */ MCD_OPC_Decode, 219, 90, 160, 1, // Opcode: CV_MACSRN +/* 319 */ MCD_OPC_FilterValue, 3, 113, 0, 0, // Skip to: 437 +/* 324 */ MCD_OPC_CheckPredicate, 103, 108, 0, 0, // Skip to: 437 +/* 329 */ MCD_OPC_CheckField, 0, 7, 91, 101, 0, 0, // Skip to: 437 +/* 336 */ MCD_OPC_Decode, 215, 90, 160, 1, // Opcode: CV_MACHHSRN +/* 341 */ MCD_OPC_FilterValue, 7, 91, 0, 0, // Skip to: 437 +/* 346 */ MCD_OPC_ExtractField, 30, 2, // Inst{31-30} ... +/* 349 */ MCD_OPC_FilterValue, 0, 17, 0, 0, // Skip to: 371 +/* 354 */ MCD_OPC_CheckPredicate, 103, 78, 0, 0, // Skip to: 437 +/* 359 */ MCD_OPC_CheckField, 0, 7, 91, 71, 0, 0, // Skip to: 437 +/* 366 */ MCD_OPC_Decode, 220, 90, 160, 1, // Opcode: CV_MACUN +/* 371 */ MCD_OPC_FilterValue, 1, 17, 0, 0, // Skip to: 393 +/* 376 */ MCD_OPC_CheckPredicate, 103, 56, 0, 0, // Skip to: 437 +/* 381 */ MCD_OPC_CheckField, 0, 7, 91, 49, 0, 0, // Skip to: 437 +/* 388 */ MCD_OPC_Decode, 216, 90, 160, 1, // Opcode: CV_MACHHUN +/* 393 */ MCD_OPC_FilterValue, 2, 17, 0, 0, // Skip to: 415 +/* 398 */ MCD_OPC_CheckPredicate, 103, 34, 0, 0, // Skip to: 437 +/* 403 */ MCD_OPC_CheckField, 0, 7, 91, 27, 0, 0, // Skip to: 437 +/* 410 */ MCD_OPC_Decode, 221, 90, 160, 1, // Opcode: CV_MACURN +/* 415 */ MCD_OPC_FilterValue, 3, 17, 0, 0, // Skip to: 437 +/* 420 */ MCD_OPC_CheckPredicate, 103, 12, 0, 0, // Skip to: 437 +/* 425 */ MCD_OPC_CheckField, 0, 7, 91, 5, 0, 0, // Skip to: 437 +/* 432 */ MCD_OPC_Decode, 217, 90, 160, 1, // Opcode: CV_MACHHURN +/* 437 */ MCD_OPC_Fail, + 0 +}; + +static const uint8_t DecoderTableXCVmem32[] = { +/* 0 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 3 */ MCD_OPC_FilterValue, 0, 33, 0, 0, // Skip to: 41 +/* 8 */ MCD_OPC_ExtractField, 0, 7, // Inst{6-0} ... +/* 11 */ MCD_OPC_FilterValue, 11, 10, 0, 0, // Skip to: 26 +/* 16 */ MCD_OPC_CheckPredicate, 104, 244, 1, 0, // Skip to: 521 +/* 21 */ MCD_OPC_Decode, 201, 90, 161, 1, // Opcode: CV_LB_ri_inc +/* 26 */ MCD_OPC_FilterValue, 43, 234, 1, 0, // Skip to: 521 +/* 31 */ MCD_OPC_CheckPredicate, 104, 229, 1, 0, // Skip to: 521 +/* 36 */ MCD_OPC_Decode, 142, 91, 162, 1, // Opcode: CV_SB_ri_inc +/* 41 */ MCD_OPC_FilterValue, 1, 33, 0, 0, // Skip to: 79 +/* 46 */ MCD_OPC_ExtractField, 0, 7, // Inst{6-0} ... +/* 49 */ MCD_OPC_FilterValue, 11, 10, 0, 0, // Skip to: 64 +/* 54 */ MCD_OPC_CheckPredicate, 104, 206, 1, 0, // Skip to: 521 +/* 59 */ MCD_OPC_Decode, 207, 90, 161, 1, // Opcode: CV_LH_ri_inc +/* 64 */ MCD_OPC_FilterValue, 43, 196, 1, 0, // Skip to: 521 +/* 69 */ MCD_OPC_CheckPredicate, 104, 191, 1, 0, // Skip to: 521 +/* 74 */ MCD_OPC_Decode, 172, 91, 162, 1, // Opcode: CV_SH_ri_inc +/* 79 */ MCD_OPC_FilterValue, 2, 33, 0, 0, // Skip to: 117 +/* 84 */ MCD_OPC_ExtractField, 0, 7, // Inst{6-0} ... +/* 87 */ MCD_OPC_FilterValue, 11, 10, 0, 0, // Skip to: 102 +/* 92 */ MCD_OPC_CheckPredicate, 104, 168, 1, 0, // Skip to: 521 +/* 97 */ MCD_OPC_Decode, 210, 90, 161, 1, // Opcode: CV_LW_ri_inc +/* 102 */ MCD_OPC_FilterValue, 43, 158, 1, 0, // Skip to: 521 +/* 107 */ MCD_OPC_CheckPredicate, 104, 153, 1, 0, // Skip to: 521 +/* 112 */ MCD_OPC_Decode, 216, 91, 162, 1, // Opcode: CV_SW_ri_inc +/* 117 */ MCD_OPC_FilterValue, 3, 99, 1, 0, // Skip to: 477 +/* 122 */ MCD_OPC_ExtractField, 25, 7, // Inst{31-25} ... +/* 125 */ MCD_OPC_FilterValue, 0, 17, 0, 0, // Skip to: 147 +/* 130 */ MCD_OPC_CheckPredicate, 104, 130, 1, 0, // Skip to: 521 +/* 135 */ MCD_OPC_CheckField, 0, 7, 43, 123, 1, 0, // Skip to: 521 +/* 142 */ MCD_OPC_Decode, 203, 90, 163, 1, // Opcode: CV_LB_rr_inc +/* 147 */ MCD_OPC_FilterValue, 1, 17, 0, 0, // Skip to: 169 +/* 152 */ MCD_OPC_CheckPredicate, 104, 108, 1, 0, // Skip to: 521 +/* 157 */ MCD_OPC_CheckField, 0, 7, 43, 101, 1, 0, // Skip to: 521 +/* 164 */ MCD_OPC_Decode, 209, 90, 163, 1, // Opcode: CV_LH_rr_inc +/* 169 */ MCD_OPC_FilterValue, 2, 17, 0, 0, // Skip to: 191 +/* 174 */ MCD_OPC_CheckPredicate, 104, 86, 1, 0, // Skip to: 521 +/* 179 */ MCD_OPC_CheckField, 0, 7, 43, 79, 1, 0, // Skip to: 521 +/* 186 */ MCD_OPC_Decode, 212, 90, 163, 1, // Opcode: CV_LW_rr_inc +/* 191 */ MCD_OPC_FilterValue, 4, 17, 0, 0, // Skip to: 213 +/* 196 */ MCD_OPC_CheckPredicate, 104, 64, 1, 0, // Skip to: 521 +/* 201 */ MCD_OPC_CheckField, 0, 7, 43, 57, 1, 0, // Skip to: 521 +/* 208 */ MCD_OPC_Decode, 202, 90, 164, 1, // Opcode: CV_LB_rr +/* 213 */ MCD_OPC_FilterValue, 5, 17, 0, 0, // Skip to: 235 +/* 218 */ MCD_OPC_CheckPredicate, 104, 42, 1, 0, // Skip to: 521 +/* 223 */ MCD_OPC_CheckField, 0, 7, 43, 35, 1, 0, // Skip to: 521 +/* 230 */ MCD_OPC_Decode, 208, 90, 164, 1, // Opcode: CV_LH_rr +/* 235 */ MCD_OPC_FilterValue, 6, 17, 0, 0, // Skip to: 257 +/* 240 */ MCD_OPC_CheckPredicate, 104, 20, 1, 0, // Skip to: 521 +/* 245 */ MCD_OPC_CheckField, 0, 7, 43, 13, 1, 0, // Skip to: 521 +/* 252 */ MCD_OPC_Decode, 211, 90, 164, 1, // Opcode: CV_LW_rr +/* 257 */ MCD_OPC_FilterValue, 8, 17, 0, 0, // Skip to: 279 +/* 262 */ MCD_OPC_CheckPredicate, 104, 254, 0, 0, // Skip to: 521 +/* 267 */ MCD_OPC_CheckField, 0, 7, 43, 247, 0, 0, // Skip to: 521 +/* 274 */ MCD_OPC_Decode, 200, 90, 163, 1, // Opcode: CV_LBU_rr_inc +/* 279 */ MCD_OPC_FilterValue, 9, 17, 0, 0, // Skip to: 301 +/* 284 */ MCD_OPC_CheckPredicate, 104, 232, 0, 0, // Skip to: 521 +/* 289 */ MCD_OPC_CheckField, 0, 7, 43, 225, 0, 0, // Skip to: 521 +/* 296 */ MCD_OPC_Decode, 206, 90, 163, 1, // Opcode: CV_LHU_rr_inc +/* 301 */ MCD_OPC_FilterValue, 12, 17, 0, 0, // Skip to: 323 +/* 306 */ MCD_OPC_CheckPredicate, 104, 210, 0, 0, // Skip to: 521 +/* 311 */ MCD_OPC_CheckField, 0, 7, 43, 203, 0, 0, // Skip to: 521 +/* 318 */ MCD_OPC_Decode, 199, 90, 164, 1, // Opcode: CV_LBU_rr +/* 323 */ MCD_OPC_FilterValue, 13, 17, 0, 0, // Skip to: 345 +/* 328 */ MCD_OPC_CheckPredicate, 104, 188, 0, 0, // Skip to: 521 +/* 333 */ MCD_OPC_CheckField, 0, 7, 43, 181, 0, 0, // Skip to: 521 +/* 340 */ MCD_OPC_Decode, 205, 90, 164, 1, // Opcode: CV_LHU_rr +/* 345 */ MCD_OPC_FilterValue, 16, 17, 0, 0, // Skip to: 367 +/* 350 */ MCD_OPC_CheckPredicate, 104, 166, 0, 0, // Skip to: 521 +/* 355 */ MCD_OPC_CheckField, 0, 7, 43, 159, 0, 0, // Skip to: 521 +/* 362 */ MCD_OPC_Decode, 144, 91, 165, 1, // Opcode: CV_SB_rr_inc +/* 367 */ MCD_OPC_FilterValue, 17, 17, 0, 0, // Skip to: 389 +/* 372 */ MCD_OPC_CheckPredicate, 104, 144, 0, 0, // Skip to: 521 +/* 377 */ MCD_OPC_CheckField, 0, 7, 43, 137, 0, 0, // Skip to: 521 +/* 384 */ MCD_OPC_Decode, 174, 91, 165, 1, // Opcode: CV_SH_rr_inc +/* 389 */ MCD_OPC_FilterValue, 18, 17, 0, 0, // Skip to: 411 +/* 394 */ MCD_OPC_CheckPredicate, 104, 122, 0, 0, // Skip to: 521 +/* 399 */ MCD_OPC_CheckField, 0, 7, 43, 115, 0, 0, // Skip to: 521 +/* 406 */ MCD_OPC_Decode, 218, 91, 165, 1, // Opcode: CV_SW_rr_inc +/* 411 */ MCD_OPC_FilterValue, 20, 17, 0, 0, // Skip to: 433 +/* 416 */ MCD_OPC_CheckPredicate, 104, 100, 0, 0, // Skip to: 521 +/* 421 */ MCD_OPC_CheckField, 0, 7, 43, 93, 0, 0, // Skip to: 521 +/* 428 */ MCD_OPC_Decode, 143, 91, 166, 1, // Opcode: CV_SB_rr +/* 433 */ MCD_OPC_FilterValue, 21, 17, 0, 0, // Skip to: 455 +/* 438 */ MCD_OPC_CheckPredicate, 104, 78, 0, 0, // Skip to: 521 +/* 443 */ MCD_OPC_CheckField, 0, 7, 43, 71, 0, 0, // Skip to: 521 +/* 450 */ MCD_OPC_Decode, 173, 91, 166, 1, // Opcode: CV_SH_rr +/* 455 */ MCD_OPC_FilterValue, 22, 61, 0, 0, // Skip to: 521 +/* 460 */ MCD_OPC_CheckPredicate, 104, 56, 0, 0, // Skip to: 521 +/* 465 */ MCD_OPC_CheckField, 0, 7, 43, 49, 0, 0, // Skip to: 521 +/* 472 */ MCD_OPC_Decode, 217, 91, 166, 1, // Opcode: CV_SW_rr +/* 477 */ MCD_OPC_FilterValue, 4, 17, 0, 0, // Skip to: 499 +/* 482 */ MCD_OPC_CheckPredicate, 104, 34, 0, 0, // Skip to: 521 +/* 487 */ MCD_OPC_CheckField, 0, 7, 11, 27, 0, 0, // Skip to: 521 +/* 494 */ MCD_OPC_Decode, 198, 90, 161, 1, // Opcode: CV_LBU_ri_inc +/* 499 */ MCD_OPC_FilterValue, 5, 17, 0, 0, // Skip to: 521 +/* 504 */ MCD_OPC_CheckPredicate, 104, 12, 0, 0, // Skip to: 521 +/* 509 */ MCD_OPC_CheckField, 0, 7, 11, 5, 0, 0, // Skip to: 521 +/* 516 */ MCD_OPC_Decode, 204, 90, 161, 1, // Opcode: CV_LHU_ri_inc +/* 521 */ MCD_OPC_Fail, + 0 +}; + +static const uint8_t DecoderTableXCVsimd32[] = { +/* 0 */ MCD_OPC_ExtractField, 26, 6, // Inst{31-26} ... +/* 3 */ MCD_OPC_FilterValue, 0, 159, 0, 0, // Skip to: 167 +/* 8 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 11 */ MCD_OPC_FilterValue, 0, 23, 0, 0, // Skip to: 39 +/* 16 */ MCD_OPC_CheckPredicate, 105, 152, 23, 0, // Skip to: 6061 +/* 21 */ MCD_OPC_CheckField, 25, 1, 0, 145, 23, 0, // Skip to: 6061 +/* 28 */ MCD_OPC_CheckField, 0, 7, 123, 138, 23, 0, // Skip to: 6061 +/* 35 */ MCD_OPC_Decode, 184, 89, 59, // Opcode: CV_ADD_H +/* 39 */ MCD_OPC_FilterValue, 1, 23, 0, 0, // Skip to: 67 +/* 44 */ MCD_OPC_CheckPredicate, 105, 124, 23, 0, // Skip to: 6061 +/* 49 */ MCD_OPC_CheckField, 25, 1, 0, 117, 23, 0, // Skip to: 6061 +/* 56 */ MCD_OPC_CheckField, 0, 7, 123, 110, 23, 0, // Skip to: 6061 +/* 63 */ MCD_OPC_Decode, 180, 89, 59, // Opcode: CV_ADD_B +/* 67 */ MCD_OPC_FilterValue, 4, 23, 0, 0, // Skip to: 95 +/* 72 */ MCD_OPC_CheckPredicate, 105, 96, 23, 0, // Skip to: 6061 +/* 77 */ MCD_OPC_CheckField, 25, 1, 0, 89, 23, 0, // Skip to: 6061 +/* 84 */ MCD_OPC_CheckField, 0, 7, 123, 82, 23, 0, // Skip to: 6061 +/* 91 */ MCD_OPC_Decode, 188, 89, 59, // Opcode: CV_ADD_SC_H +/* 95 */ MCD_OPC_FilterValue, 5, 23, 0, 0, // Skip to: 123 +/* 100 */ MCD_OPC_CheckPredicate, 105, 68, 23, 0, // Skip to: 6061 +/* 105 */ MCD_OPC_CheckField, 25, 1, 0, 61, 23, 0, // Skip to: 6061 +/* 112 */ MCD_OPC_CheckField, 0, 7, 123, 54, 23, 0, // Skip to: 6061 +/* 119 */ MCD_OPC_Decode, 187, 89, 59, // Opcode: CV_ADD_SC_B +/* 123 */ MCD_OPC_FilterValue, 6, 17, 0, 0, // Skip to: 145 +/* 128 */ MCD_OPC_CheckPredicate, 105, 40, 23, 0, // Skip to: 6061 +/* 133 */ MCD_OPC_CheckField, 0, 7, 123, 33, 23, 0, // Skip to: 6061 +/* 140 */ MCD_OPC_Decode, 186, 89, 167, 1, // Opcode: CV_ADD_SCI_H +/* 145 */ MCD_OPC_FilterValue, 7, 23, 23, 0, // Skip to: 6061 +/* 150 */ MCD_OPC_CheckPredicate, 105, 18, 23, 0, // Skip to: 6061 +/* 155 */ MCD_OPC_CheckField, 0, 7, 123, 11, 23, 0, // Skip to: 6061 +/* 162 */ MCD_OPC_Decode, 185, 89, 167, 1, // Opcode: CV_ADD_SCI_B +/* 167 */ MCD_OPC_FilterValue, 1, 159, 0, 0, // Skip to: 331 +/* 172 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 175 */ MCD_OPC_FilterValue, 0, 23, 0, 0, // Skip to: 203 +/* 180 */ MCD_OPC_CheckPredicate, 105, 244, 22, 0, // Skip to: 6061 +/* 185 */ MCD_OPC_CheckField, 25, 1, 0, 237, 22, 0, // Skip to: 6061 +/* 192 */ MCD_OPC_CheckField, 0, 7, 123, 230, 22, 0, // Skip to: 6061 +/* 199 */ MCD_OPC_Decode, 220, 89, 59, // Opcode: CV_CMPEQ_H +/* 203 */ MCD_OPC_FilterValue, 1, 23, 0, 0, // Skip to: 231 +/* 208 */ MCD_OPC_CheckPredicate, 105, 216, 22, 0, // Skip to: 6061 +/* 213 */ MCD_OPC_CheckField, 25, 1, 0, 209, 22, 0, // Skip to: 6061 +/* 220 */ MCD_OPC_CheckField, 0, 7, 123, 202, 22, 0, // Skip to: 6061 +/* 227 */ MCD_OPC_Decode, 219, 89, 59, // Opcode: CV_CMPEQ_B +/* 231 */ MCD_OPC_FilterValue, 4, 23, 0, 0, // Skip to: 259 +/* 236 */ MCD_OPC_CheckPredicate, 105, 188, 22, 0, // Skip to: 6061 +/* 241 */ MCD_OPC_CheckField, 25, 1, 0, 181, 22, 0, // Skip to: 6061 +/* 248 */ MCD_OPC_CheckField, 0, 7, 123, 174, 22, 0, // Skip to: 6061 +/* 255 */ MCD_OPC_Decode, 224, 89, 59, // Opcode: CV_CMPEQ_SC_H +/* 259 */ MCD_OPC_FilterValue, 5, 23, 0, 0, // Skip to: 287 +/* 264 */ MCD_OPC_CheckPredicate, 105, 160, 22, 0, // Skip to: 6061 +/* 269 */ MCD_OPC_CheckField, 25, 1, 0, 153, 22, 0, // Skip to: 6061 +/* 276 */ MCD_OPC_CheckField, 0, 7, 123, 146, 22, 0, // Skip to: 6061 +/* 283 */ MCD_OPC_Decode, 223, 89, 59, // Opcode: CV_CMPEQ_SC_B +/* 287 */ MCD_OPC_FilterValue, 6, 17, 0, 0, // Skip to: 309 +/* 292 */ MCD_OPC_CheckPredicate, 105, 132, 22, 0, // Skip to: 6061 +/* 297 */ MCD_OPC_CheckField, 0, 7, 123, 125, 22, 0, // Skip to: 6061 +/* 304 */ MCD_OPC_Decode, 222, 89, 167, 1, // Opcode: CV_CMPEQ_SCI_H +/* 309 */ MCD_OPC_FilterValue, 7, 115, 22, 0, // Skip to: 6061 +/* 314 */ MCD_OPC_CheckPredicate, 105, 110, 22, 0, // Skip to: 6061 +/* 319 */ MCD_OPC_CheckField, 0, 7, 123, 103, 22, 0, // Skip to: 6061 +/* 326 */ MCD_OPC_Decode, 221, 89, 167, 1, // Opcode: CV_CMPEQ_SCI_B +/* 331 */ MCD_OPC_FilterValue, 2, 159, 0, 0, // Skip to: 495 +/* 336 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 339 */ MCD_OPC_FilterValue, 0, 23, 0, 0, // Skip to: 367 +/* 344 */ MCD_OPC_CheckPredicate, 105, 80, 22, 0, // Skip to: 6061 +/* 349 */ MCD_OPC_CheckField, 25, 1, 0, 73, 22, 0, // Skip to: 6061 +/* 356 */ MCD_OPC_CheckField, 0, 7, 123, 66, 22, 0, // Skip to: 6061 +/* 363 */ MCD_OPC_Decode, 211, 91, 59, // Opcode: CV_SUB_H +/* 367 */ MCD_OPC_FilterValue, 1, 23, 0, 0, // Skip to: 395 +/* 372 */ MCD_OPC_CheckPredicate, 105, 52, 22, 0, // Skip to: 6061 +/* 377 */ MCD_OPC_CheckField, 25, 1, 0, 45, 22, 0, // Skip to: 6061 +/* 384 */ MCD_OPC_CheckField, 0, 7, 123, 38, 22, 0, // Skip to: 6061 +/* 391 */ MCD_OPC_Decode, 207, 91, 59, // Opcode: CV_SUB_B +/* 395 */ MCD_OPC_FilterValue, 4, 23, 0, 0, // Skip to: 423 +/* 400 */ MCD_OPC_CheckPredicate, 105, 24, 22, 0, // Skip to: 6061 +/* 405 */ MCD_OPC_CheckField, 25, 1, 0, 17, 22, 0, // Skip to: 6061 +/* 412 */ MCD_OPC_CheckField, 0, 7, 123, 10, 22, 0, // Skip to: 6061 +/* 419 */ MCD_OPC_Decode, 215, 91, 59, // Opcode: CV_SUB_SC_H +/* 423 */ MCD_OPC_FilterValue, 5, 23, 0, 0, // Skip to: 451 +/* 428 */ MCD_OPC_CheckPredicate, 105, 252, 21, 0, // Skip to: 6061 +/* 433 */ MCD_OPC_CheckField, 25, 1, 0, 245, 21, 0, // Skip to: 6061 +/* 440 */ MCD_OPC_CheckField, 0, 7, 123, 238, 21, 0, // Skip to: 6061 +/* 447 */ MCD_OPC_Decode, 214, 91, 59, // Opcode: CV_SUB_SC_B +/* 451 */ MCD_OPC_FilterValue, 6, 17, 0, 0, // Skip to: 473 +/* 456 */ MCD_OPC_CheckPredicate, 105, 224, 21, 0, // Skip to: 6061 +/* 461 */ MCD_OPC_CheckField, 0, 7, 123, 217, 21, 0, // Skip to: 6061 +/* 468 */ MCD_OPC_Decode, 213, 91, 167, 1, // Opcode: CV_SUB_SCI_H +/* 473 */ MCD_OPC_FilterValue, 7, 207, 21, 0, // Skip to: 6061 +/* 478 */ MCD_OPC_CheckPredicate, 105, 202, 21, 0, // Skip to: 6061 +/* 483 */ MCD_OPC_CheckField, 0, 7, 123, 195, 21, 0, // Skip to: 6061 +/* 490 */ MCD_OPC_Decode, 212, 91, 167, 1, // Opcode: CV_SUB_SCI_B +/* 495 */ MCD_OPC_FilterValue, 3, 159, 0, 0, // Skip to: 659 +/* 500 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 503 */ MCD_OPC_FilterValue, 0, 23, 0, 0, // Skip to: 531 +/* 508 */ MCD_OPC_CheckPredicate, 105, 172, 21, 0, // Skip to: 6061 +/* 513 */ MCD_OPC_CheckField, 25, 1, 0, 165, 21, 0, // Skip to: 6061 +/* 520 */ MCD_OPC_CheckField, 0, 7, 123, 158, 21, 0, // Skip to: 6061 +/* 527 */ MCD_OPC_Decode, 146, 90, 59, // Opcode: CV_CMPNE_H +/* 531 */ MCD_OPC_FilterValue, 1, 23, 0, 0, // Skip to: 559 +/* 536 */ MCD_OPC_CheckPredicate, 105, 144, 21, 0, // Skip to: 6061 +/* 541 */ MCD_OPC_CheckField, 25, 1, 0, 137, 21, 0, // Skip to: 6061 +/* 548 */ MCD_OPC_CheckField, 0, 7, 123, 130, 21, 0, // Skip to: 6061 +/* 555 */ MCD_OPC_Decode, 145, 90, 59, // Opcode: CV_CMPNE_B +/* 559 */ MCD_OPC_FilterValue, 4, 23, 0, 0, // Skip to: 587 +/* 564 */ MCD_OPC_CheckPredicate, 105, 116, 21, 0, // Skip to: 6061 +/* 569 */ MCD_OPC_CheckField, 25, 1, 0, 109, 21, 0, // Skip to: 6061 +/* 576 */ MCD_OPC_CheckField, 0, 7, 123, 102, 21, 0, // Skip to: 6061 +/* 583 */ MCD_OPC_Decode, 150, 90, 59, // Opcode: CV_CMPNE_SC_H +/* 587 */ MCD_OPC_FilterValue, 5, 23, 0, 0, // Skip to: 615 +/* 592 */ MCD_OPC_CheckPredicate, 105, 88, 21, 0, // Skip to: 6061 +/* 597 */ MCD_OPC_CheckField, 25, 1, 0, 81, 21, 0, // Skip to: 6061 +/* 604 */ MCD_OPC_CheckField, 0, 7, 123, 74, 21, 0, // Skip to: 6061 +/* 611 */ MCD_OPC_Decode, 149, 90, 59, // Opcode: CV_CMPNE_SC_B +/* 615 */ MCD_OPC_FilterValue, 6, 17, 0, 0, // Skip to: 637 +/* 620 */ MCD_OPC_CheckPredicate, 105, 60, 21, 0, // Skip to: 6061 +/* 625 */ MCD_OPC_CheckField, 0, 7, 123, 53, 21, 0, // Skip to: 6061 +/* 632 */ MCD_OPC_Decode, 148, 90, 167, 1, // Opcode: CV_CMPNE_SCI_H +/* 637 */ MCD_OPC_FilterValue, 7, 43, 21, 0, // Skip to: 6061 +/* 642 */ MCD_OPC_CheckPredicate, 105, 38, 21, 0, // Skip to: 6061 +/* 647 */ MCD_OPC_CheckField, 0, 7, 123, 31, 21, 0, // Skip to: 6061 +/* 654 */ MCD_OPC_Decode, 147, 90, 167, 1, // Opcode: CV_CMPNE_SCI_B +/* 659 */ MCD_OPC_FilterValue, 4, 159, 0, 0, // Skip to: 823 +/* 664 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 667 */ MCD_OPC_FilterValue, 0, 23, 0, 0, // Skip to: 695 +/* 672 */ MCD_OPC_CheckPredicate, 105, 8, 21, 0, // Skip to: 6061 +/* 677 */ MCD_OPC_CheckField, 25, 1, 0, 1, 21, 0, // Skip to: 6061 +/* 684 */ MCD_OPC_CheckField, 0, 7, 123, 250, 20, 0, // Skip to: 6061 +/* 691 */ MCD_OPC_Decode, 202, 89, 59, // Opcode: CV_AVG_H +/* 695 */ MCD_OPC_FilterValue, 1, 23, 0, 0, // Skip to: 723 +/* 700 */ MCD_OPC_CheckPredicate, 105, 236, 20, 0, // Skip to: 6061 +/* 705 */ MCD_OPC_CheckField, 25, 1, 0, 229, 20, 0, // Skip to: 6061 +/* 712 */ MCD_OPC_CheckField, 0, 7, 123, 222, 20, 0, // Skip to: 6061 +/* 719 */ MCD_OPC_Decode, 201, 89, 59, // Opcode: CV_AVG_B +/* 723 */ MCD_OPC_FilterValue, 4, 23, 0, 0, // Skip to: 751 +/* 728 */ MCD_OPC_CheckPredicate, 105, 208, 20, 0, // Skip to: 6061 +/* 733 */ MCD_OPC_CheckField, 25, 1, 0, 201, 20, 0, // Skip to: 6061 +/* 740 */ MCD_OPC_CheckField, 0, 7, 123, 194, 20, 0, // Skip to: 6061 +/* 747 */ MCD_OPC_Decode, 206, 89, 59, // Opcode: CV_AVG_SC_H +/* 751 */ MCD_OPC_FilterValue, 5, 23, 0, 0, // Skip to: 779 +/* 756 */ MCD_OPC_CheckPredicate, 105, 180, 20, 0, // Skip to: 6061 +/* 761 */ MCD_OPC_CheckField, 25, 1, 0, 173, 20, 0, // Skip to: 6061 +/* 768 */ MCD_OPC_CheckField, 0, 7, 123, 166, 20, 0, // Skip to: 6061 +/* 775 */ MCD_OPC_Decode, 205, 89, 59, // Opcode: CV_AVG_SC_B +/* 779 */ MCD_OPC_FilterValue, 6, 17, 0, 0, // Skip to: 801 +/* 784 */ MCD_OPC_CheckPredicate, 105, 152, 20, 0, // Skip to: 6061 +/* 789 */ MCD_OPC_CheckField, 0, 7, 123, 145, 20, 0, // Skip to: 6061 +/* 796 */ MCD_OPC_Decode, 204, 89, 167, 1, // Opcode: CV_AVG_SCI_H +/* 801 */ MCD_OPC_FilterValue, 7, 135, 20, 0, // Skip to: 6061 +/* 806 */ MCD_OPC_CheckPredicate, 105, 130, 20, 0, // Skip to: 6061 +/* 811 */ MCD_OPC_CheckField, 0, 7, 123, 123, 20, 0, // Skip to: 6061 +/* 818 */ MCD_OPC_Decode, 203, 89, 167, 1, // Opcode: CV_AVG_SCI_B +/* 823 */ MCD_OPC_FilterValue, 5, 159, 0, 0, // Skip to: 987 +/* 828 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 831 */ MCD_OPC_FilterValue, 0, 23, 0, 0, // Skip to: 859 +/* 836 */ MCD_OPC_CheckPredicate, 105, 100, 20, 0, // Skip to: 6061 +/* 841 */ MCD_OPC_CheckField, 25, 1, 0, 93, 20, 0, // Skip to: 6061 +/* 848 */ MCD_OPC_CheckField, 0, 7, 123, 86, 20, 0, // Skip to: 6061 +/* 855 */ MCD_OPC_Decode, 244, 89, 59, // Opcode: CV_CMPGT_H +/* 859 */ MCD_OPC_FilterValue, 1, 23, 0, 0, // Skip to: 887 +/* 864 */ MCD_OPC_CheckPredicate, 105, 72, 20, 0, // Skip to: 6061 +/* 869 */ MCD_OPC_CheckField, 25, 1, 0, 65, 20, 0, // Skip to: 6061 +/* 876 */ MCD_OPC_CheckField, 0, 7, 123, 58, 20, 0, // Skip to: 6061 +/* 883 */ MCD_OPC_Decode, 243, 89, 59, // Opcode: CV_CMPGT_B +/* 887 */ MCD_OPC_FilterValue, 4, 23, 0, 0, // Skip to: 915 +/* 892 */ MCD_OPC_CheckPredicate, 105, 44, 20, 0, // Skip to: 6061 +/* 897 */ MCD_OPC_CheckField, 25, 1, 0, 37, 20, 0, // Skip to: 6061 +/* 904 */ MCD_OPC_CheckField, 0, 7, 123, 30, 20, 0, // Skip to: 6061 +/* 911 */ MCD_OPC_Decode, 248, 89, 59, // Opcode: CV_CMPGT_SC_H +/* 915 */ MCD_OPC_FilterValue, 5, 23, 0, 0, // Skip to: 943 +/* 920 */ MCD_OPC_CheckPredicate, 105, 16, 20, 0, // Skip to: 6061 +/* 925 */ MCD_OPC_CheckField, 25, 1, 0, 9, 20, 0, // Skip to: 6061 +/* 932 */ MCD_OPC_CheckField, 0, 7, 123, 2, 20, 0, // Skip to: 6061 +/* 939 */ MCD_OPC_Decode, 247, 89, 59, // Opcode: CV_CMPGT_SC_B +/* 943 */ MCD_OPC_FilterValue, 6, 17, 0, 0, // Skip to: 965 +/* 948 */ MCD_OPC_CheckPredicate, 105, 244, 19, 0, // Skip to: 6061 +/* 953 */ MCD_OPC_CheckField, 0, 7, 123, 237, 19, 0, // Skip to: 6061 +/* 960 */ MCD_OPC_Decode, 246, 89, 167, 1, // Opcode: CV_CMPGT_SCI_H +/* 965 */ MCD_OPC_FilterValue, 7, 227, 19, 0, // Skip to: 6061 +/* 970 */ MCD_OPC_CheckPredicate, 105, 222, 19, 0, // Skip to: 6061 +/* 975 */ MCD_OPC_CheckField, 0, 7, 123, 215, 19, 0, // Skip to: 6061 +/* 982 */ MCD_OPC_Decode, 245, 89, 167, 1, // Opcode: CV_CMPGT_SCI_B +/* 987 */ MCD_OPC_FilterValue, 6, 159, 0, 0, // Skip to: 1151 +/* 992 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 995 */ MCD_OPC_FilterValue, 0, 23, 0, 0, // Skip to: 1023 +/* 1000 */ MCD_OPC_CheckPredicate, 105, 192, 19, 0, // Skip to: 6061 +/* 1005 */ MCD_OPC_CheckField, 25, 1, 0, 185, 19, 0, // Skip to: 6061 +/* 1012 */ MCD_OPC_CheckField, 0, 7, 123, 178, 19, 0, // Skip to: 6061 +/* 1019 */ MCD_OPC_Decode, 196, 89, 59, // Opcode: CV_AVGU_H +/* 1023 */ MCD_OPC_FilterValue, 1, 23, 0, 0, // Skip to: 1051 +/* 1028 */ MCD_OPC_CheckPredicate, 105, 164, 19, 0, // Skip to: 6061 +/* 1033 */ MCD_OPC_CheckField, 25, 1, 0, 157, 19, 0, // Skip to: 6061 +/* 1040 */ MCD_OPC_CheckField, 0, 7, 123, 150, 19, 0, // Skip to: 6061 +/* 1047 */ MCD_OPC_Decode, 195, 89, 59, // Opcode: CV_AVGU_B +/* 1051 */ MCD_OPC_FilterValue, 4, 23, 0, 0, // Skip to: 1079 +/* 1056 */ MCD_OPC_CheckPredicate, 105, 136, 19, 0, // Skip to: 6061 +/* 1061 */ MCD_OPC_CheckField, 25, 1, 0, 129, 19, 0, // Skip to: 6061 +/* 1068 */ MCD_OPC_CheckField, 0, 7, 123, 122, 19, 0, // Skip to: 6061 +/* 1075 */ MCD_OPC_Decode, 200, 89, 59, // Opcode: CV_AVGU_SC_H +/* 1079 */ MCD_OPC_FilterValue, 5, 23, 0, 0, // Skip to: 1107 +/* 1084 */ MCD_OPC_CheckPredicate, 105, 108, 19, 0, // Skip to: 6061 +/* 1089 */ MCD_OPC_CheckField, 25, 1, 0, 101, 19, 0, // Skip to: 6061 +/* 1096 */ MCD_OPC_CheckField, 0, 7, 123, 94, 19, 0, // Skip to: 6061 +/* 1103 */ MCD_OPC_Decode, 199, 89, 59, // Opcode: CV_AVGU_SC_B +/* 1107 */ MCD_OPC_FilterValue, 6, 17, 0, 0, // Skip to: 1129 +/* 1112 */ MCD_OPC_CheckPredicate, 105, 80, 19, 0, // Skip to: 6061 +/* 1117 */ MCD_OPC_CheckField, 0, 7, 123, 73, 19, 0, // Skip to: 6061 +/* 1124 */ MCD_OPC_Decode, 198, 89, 168, 1, // Opcode: CV_AVGU_SCI_H +/* 1129 */ MCD_OPC_FilterValue, 7, 63, 19, 0, // Skip to: 6061 +/* 1134 */ MCD_OPC_CheckPredicate, 105, 58, 19, 0, // Skip to: 6061 +/* 1139 */ MCD_OPC_CheckField, 0, 7, 123, 51, 19, 0, // Skip to: 6061 +/* 1146 */ MCD_OPC_Decode, 197, 89, 168, 1, // Opcode: CV_AVGU_SCI_B +/* 1151 */ MCD_OPC_FilterValue, 7, 159, 0, 0, // Skip to: 1315 +/* 1156 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 1159 */ MCD_OPC_FilterValue, 0, 23, 0, 0, // Skip to: 1187 +/* 1164 */ MCD_OPC_CheckPredicate, 105, 28, 19, 0, // Skip to: 6061 +/* 1169 */ MCD_OPC_CheckField, 25, 1, 0, 21, 19, 0, // Skip to: 6061 +/* 1176 */ MCD_OPC_CheckField, 0, 7, 123, 14, 19, 0, // Skip to: 6061 +/* 1183 */ MCD_OPC_Decode, 232, 89, 59, // Opcode: CV_CMPGE_H +/* 1187 */ MCD_OPC_FilterValue, 1, 23, 0, 0, // Skip to: 1215 +/* 1192 */ MCD_OPC_CheckPredicate, 105, 0, 19, 0, // Skip to: 6061 +/* 1197 */ MCD_OPC_CheckField, 25, 1, 0, 249, 18, 0, // Skip to: 6061 +/* 1204 */ MCD_OPC_CheckField, 0, 7, 123, 242, 18, 0, // Skip to: 6061 +/* 1211 */ MCD_OPC_Decode, 231, 89, 59, // Opcode: CV_CMPGE_B +/* 1215 */ MCD_OPC_FilterValue, 4, 23, 0, 0, // Skip to: 1243 +/* 1220 */ MCD_OPC_CheckPredicate, 105, 228, 18, 0, // Skip to: 6061 +/* 1225 */ MCD_OPC_CheckField, 25, 1, 0, 221, 18, 0, // Skip to: 6061 +/* 1232 */ MCD_OPC_CheckField, 0, 7, 123, 214, 18, 0, // Skip to: 6061 +/* 1239 */ MCD_OPC_Decode, 236, 89, 59, // Opcode: CV_CMPGE_SC_H +/* 1243 */ MCD_OPC_FilterValue, 5, 23, 0, 0, // Skip to: 1271 +/* 1248 */ MCD_OPC_CheckPredicate, 105, 200, 18, 0, // Skip to: 6061 +/* 1253 */ MCD_OPC_CheckField, 25, 1, 0, 193, 18, 0, // Skip to: 6061 +/* 1260 */ MCD_OPC_CheckField, 0, 7, 123, 186, 18, 0, // Skip to: 6061 +/* 1267 */ MCD_OPC_Decode, 235, 89, 59, // Opcode: CV_CMPGE_SC_B +/* 1271 */ MCD_OPC_FilterValue, 6, 17, 0, 0, // Skip to: 1293 +/* 1276 */ MCD_OPC_CheckPredicate, 105, 172, 18, 0, // Skip to: 6061 +/* 1281 */ MCD_OPC_CheckField, 0, 7, 123, 165, 18, 0, // Skip to: 6061 +/* 1288 */ MCD_OPC_Decode, 234, 89, 167, 1, // Opcode: CV_CMPGE_SCI_H +/* 1293 */ MCD_OPC_FilterValue, 7, 155, 18, 0, // Skip to: 6061 +/* 1298 */ MCD_OPC_CheckPredicate, 105, 150, 18, 0, // Skip to: 6061 +/* 1303 */ MCD_OPC_CheckField, 0, 7, 123, 143, 18, 0, // Skip to: 6061 +/* 1310 */ MCD_OPC_Decode, 233, 89, 167, 1, // Opcode: CV_CMPGE_SCI_B +/* 1315 */ MCD_OPC_FilterValue, 8, 159, 0, 0, // Skip to: 1479 +/* 1320 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 1323 */ MCD_OPC_FilterValue, 0, 23, 0, 0, // Skip to: 1351 +/* 1328 */ MCD_OPC_CheckPredicate, 105, 120, 18, 0, // Skip to: 6061 +/* 1333 */ MCD_OPC_CheckField, 25, 1, 0, 113, 18, 0, // Skip to: 6061 +/* 1340 */ MCD_OPC_CheckField, 0, 7, 123, 106, 18, 0, // Skip to: 6061 +/* 1347 */ MCD_OPC_Decode, 245, 90, 59, // Opcode: CV_MIN_H +/* 1351 */ MCD_OPC_FilterValue, 1, 23, 0, 0, // Skip to: 1379 +/* 1356 */ MCD_OPC_CheckPredicate, 105, 92, 18, 0, // Skip to: 6061 +/* 1361 */ MCD_OPC_CheckField, 25, 1, 0, 85, 18, 0, // Skip to: 6061 +/* 1368 */ MCD_OPC_CheckField, 0, 7, 123, 78, 18, 0, // Skip to: 6061 +/* 1375 */ MCD_OPC_Decode, 244, 90, 59, // Opcode: CV_MIN_B +/* 1379 */ MCD_OPC_FilterValue, 4, 23, 0, 0, // Skip to: 1407 +/* 1384 */ MCD_OPC_CheckPredicate, 105, 64, 18, 0, // Skip to: 6061 +/* 1389 */ MCD_OPC_CheckField, 25, 1, 0, 57, 18, 0, // Skip to: 6061 +/* 1396 */ MCD_OPC_CheckField, 0, 7, 123, 50, 18, 0, // Skip to: 6061 +/* 1403 */ MCD_OPC_Decode, 249, 90, 59, // Opcode: CV_MIN_SC_H +/* 1407 */ MCD_OPC_FilterValue, 5, 23, 0, 0, // Skip to: 1435 +/* 1412 */ MCD_OPC_CheckPredicate, 105, 36, 18, 0, // Skip to: 6061 +/* 1417 */ MCD_OPC_CheckField, 25, 1, 0, 29, 18, 0, // Skip to: 6061 +/* 1424 */ MCD_OPC_CheckField, 0, 7, 123, 22, 18, 0, // Skip to: 6061 +/* 1431 */ MCD_OPC_Decode, 248, 90, 59, // Opcode: CV_MIN_SC_B +/* 1435 */ MCD_OPC_FilterValue, 6, 17, 0, 0, // Skip to: 1457 +/* 1440 */ MCD_OPC_CheckPredicate, 105, 8, 18, 0, // Skip to: 6061 +/* 1445 */ MCD_OPC_CheckField, 0, 7, 123, 1, 18, 0, // Skip to: 6061 +/* 1452 */ MCD_OPC_Decode, 247, 90, 167, 1, // Opcode: CV_MIN_SCI_H +/* 1457 */ MCD_OPC_FilterValue, 7, 247, 17, 0, // Skip to: 6061 +/* 1462 */ MCD_OPC_CheckPredicate, 105, 242, 17, 0, // Skip to: 6061 +/* 1467 */ MCD_OPC_CheckField, 0, 7, 123, 235, 17, 0, // Skip to: 6061 +/* 1474 */ MCD_OPC_Decode, 246, 90, 167, 1, // Opcode: CV_MIN_SCI_B +/* 1479 */ MCD_OPC_FilterValue, 9, 159, 0, 0, // Skip to: 1643 +/* 1484 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 1487 */ MCD_OPC_FilterValue, 0, 23, 0, 0, // Skip to: 1515 +/* 1492 */ MCD_OPC_CheckPredicate, 105, 212, 17, 0, // Skip to: 6061 +/* 1497 */ MCD_OPC_CheckField, 25, 1, 0, 205, 17, 0, // Skip to: 6061 +/* 1504 */ MCD_OPC_CheckField, 0, 7, 123, 198, 17, 0, // Skip to: 6061 +/* 1511 */ MCD_OPC_Decode, 140, 90, 59, // Opcode: CV_CMPLT_H +/* 1515 */ MCD_OPC_FilterValue, 1, 23, 0, 0, // Skip to: 1543 +/* 1520 */ MCD_OPC_CheckPredicate, 105, 184, 17, 0, // Skip to: 6061 +/* 1525 */ MCD_OPC_CheckField, 25, 1, 0, 177, 17, 0, // Skip to: 6061 +/* 1532 */ MCD_OPC_CheckField, 0, 7, 123, 170, 17, 0, // Skip to: 6061 +/* 1539 */ MCD_OPC_Decode, 139, 90, 59, // Opcode: CV_CMPLT_B +/* 1543 */ MCD_OPC_FilterValue, 4, 23, 0, 0, // Skip to: 1571 +/* 1548 */ MCD_OPC_CheckPredicate, 105, 156, 17, 0, // Skip to: 6061 +/* 1553 */ MCD_OPC_CheckField, 25, 1, 0, 149, 17, 0, // Skip to: 6061 +/* 1560 */ MCD_OPC_CheckField, 0, 7, 123, 142, 17, 0, // Skip to: 6061 +/* 1567 */ MCD_OPC_Decode, 144, 90, 59, // Opcode: CV_CMPLT_SC_H +/* 1571 */ MCD_OPC_FilterValue, 5, 23, 0, 0, // Skip to: 1599 +/* 1576 */ MCD_OPC_CheckPredicate, 105, 128, 17, 0, // Skip to: 6061 +/* 1581 */ MCD_OPC_CheckField, 25, 1, 0, 121, 17, 0, // Skip to: 6061 +/* 1588 */ MCD_OPC_CheckField, 0, 7, 123, 114, 17, 0, // Skip to: 6061 +/* 1595 */ MCD_OPC_Decode, 143, 90, 59, // Opcode: CV_CMPLT_SC_B +/* 1599 */ MCD_OPC_FilterValue, 6, 17, 0, 0, // Skip to: 1621 +/* 1604 */ MCD_OPC_CheckPredicate, 105, 100, 17, 0, // Skip to: 6061 +/* 1609 */ MCD_OPC_CheckField, 0, 7, 123, 93, 17, 0, // Skip to: 6061 +/* 1616 */ MCD_OPC_Decode, 142, 90, 167, 1, // Opcode: CV_CMPLT_SCI_H +/* 1621 */ MCD_OPC_FilterValue, 7, 83, 17, 0, // Skip to: 6061 +/* 1626 */ MCD_OPC_CheckPredicate, 105, 78, 17, 0, // Skip to: 6061 +/* 1631 */ MCD_OPC_CheckField, 0, 7, 123, 71, 17, 0, // Skip to: 6061 +/* 1638 */ MCD_OPC_Decode, 141, 90, 167, 1, // Opcode: CV_CMPLT_SCI_B +/* 1643 */ MCD_OPC_FilterValue, 10, 159, 0, 0, // Skip to: 1807 +/* 1648 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 1651 */ MCD_OPC_FilterValue, 0, 23, 0, 0, // Skip to: 1679 +/* 1656 */ MCD_OPC_CheckPredicate, 105, 48, 17, 0, // Skip to: 6061 +/* 1661 */ MCD_OPC_CheckField, 25, 1, 0, 41, 17, 0, // Skip to: 6061 +/* 1668 */ MCD_OPC_CheckField, 0, 7, 123, 34, 17, 0, // Skip to: 6061 +/* 1675 */ MCD_OPC_Decode, 239, 90, 59, // Opcode: CV_MINU_H +/* 1679 */ MCD_OPC_FilterValue, 1, 23, 0, 0, // Skip to: 1707 +/* 1684 */ MCD_OPC_CheckPredicate, 105, 20, 17, 0, // Skip to: 6061 +/* 1689 */ MCD_OPC_CheckField, 25, 1, 0, 13, 17, 0, // Skip to: 6061 +/* 1696 */ MCD_OPC_CheckField, 0, 7, 123, 6, 17, 0, // Skip to: 6061 +/* 1703 */ MCD_OPC_Decode, 238, 90, 59, // Opcode: CV_MINU_B +/* 1707 */ MCD_OPC_FilterValue, 4, 23, 0, 0, // Skip to: 1735 +/* 1712 */ MCD_OPC_CheckPredicate, 105, 248, 16, 0, // Skip to: 6061 +/* 1717 */ MCD_OPC_CheckField, 25, 1, 0, 241, 16, 0, // Skip to: 6061 +/* 1724 */ MCD_OPC_CheckField, 0, 7, 123, 234, 16, 0, // Skip to: 6061 +/* 1731 */ MCD_OPC_Decode, 243, 90, 59, // Opcode: CV_MINU_SC_H +/* 1735 */ MCD_OPC_FilterValue, 5, 23, 0, 0, // Skip to: 1763 +/* 1740 */ MCD_OPC_CheckPredicate, 105, 220, 16, 0, // Skip to: 6061 +/* 1745 */ MCD_OPC_CheckField, 25, 1, 0, 213, 16, 0, // Skip to: 6061 +/* 1752 */ MCD_OPC_CheckField, 0, 7, 123, 206, 16, 0, // Skip to: 6061 +/* 1759 */ MCD_OPC_Decode, 242, 90, 59, // Opcode: CV_MINU_SC_B +/* 1763 */ MCD_OPC_FilterValue, 6, 17, 0, 0, // Skip to: 1785 +/* 1768 */ MCD_OPC_CheckPredicate, 105, 192, 16, 0, // Skip to: 6061 +/* 1773 */ MCD_OPC_CheckField, 0, 7, 123, 185, 16, 0, // Skip to: 6061 +/* 1780 */ MCD_OPC_Decode, 241, 90, 168, 1, // Opcode: CV_MINU_SCI_H +/* 1785 */ MCD_OPC_FilterValue, 7, 175, 16, 0, // Skip to: 6061 +/* 1790 */ MCD_OPC_CheckPredicate, 105, 170, 16, 0, // Skip to: 6061 +/* 1795 */ MCD_OPC_CheckField, 0, 7, 123, 163, 16, 0, // Skip to: 6061 +/* 1802 */ MCD_OPC_Decode, 240, 90, 168, 1, // Opcode: CV_MINU_SCI_B +/* 1807 */ MCD_OPC_FilterValue, 11, 159, 0, 0, // Skip to: 1971 +/* 1812 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 1815 */ MCD_OPC_FilterValue, 0, 23, 0, 0, // Skip to: 1843 +/* 1820 */ MCD_OPC_CheckPredicate, 105, 140, 16, 0, // Skip to: 6061 +/* 1825 */ MCD_OPC_CheckField, 25, 1, 0, 133, 16, 0, // Skip to: 6061 +/* 1832 */ MCD_OPC_CheckField, 0, 7, 123, 126, 16, 0, // Skip to: 6061 +/* 1839 */ MCD_OPC_Decode, 128, 90, 59, // Opcode: CV_CMPLE_H +/* 1843 */ MCD_OPC_FilterValue, 1, 23, 0, 0, // Skip to: 1871 +/* 1848 */ MCD_OPC_CheckPredicate, 105, 112, 16, 0, // Skip to: 6061 +/* 1853 */ MCD_OPC_CheckField, 25, 1, 0, 105, 16, 0, // Skip to: 6061 +/* 1860 */ MCD_OPC_CheckField, 0, 7, 123, 98, 16, 0, // Skip to: 6061 +/* 1867 */ MCD_OPC_Decode, 255, 89, 59, // Opcode: CV_CMPLE_B +/* 1871 */ MCD_OPC_FilterValue, 4, 23, 0, 0, // Skip to: 1899 +/* 1876 */ MCD_OPC_CheckPredicate, 105, 84, 16, 0, // Skip to: 6061 +/* 1881 */ MCD_OPC_CheckField, 25, 1, 0, 77, 16, 0, // Skip to: 6061 +/* 1888 */ MCD_OPC_CheckField, 0, 7, 123, 70, 16, 0, // Skip to: 6061 +/* 1895 */ MCD_OPC_Decode, 132, 90, 59, // Opcode: CV_CMPLE_SC_H +/* 1899 */ MCD_OPC_FilterValue, 5, 23, 0, 0, // Skip to: 1927 +/* 1904 */ MCD_OPC_CheckPredicate, 105, 56, 16, 0, // Skip to: 6061 +/* 1909 */ MCD_OPC_CheckField, 25, 1, 0, 49, 16, 0, // Skip to: 6061 +/* 1916 */ MCD_OPC_CheckField, 0, 7, 123, 42, 16, 0, // Skip to: 6061 +/* 1923 */ MCD_OPC_Decode, 131, 90, 59, // Opcode: CV_CMPLE_SC_B +/* 1927 */ MCD_OPC_FilterValue, 6, 17, 0, 0, // Skip to: 1949 +/* 1932 */ MCD_OPC_CheckPredicate, 105, 28, 16, 0, // Skip to: 6061 +/* 1937 */ MCD_OPC_CheckField, 0, 7, 123, 21, 16, 0, // Skip to: 6061 +/* 1944 */ MCD_OPC_Decode, 130, 90, 167, 1, // Opcode: CV_CMPLE_SCI_H +/* 1949 */ MCD_OPC_FilterValue, 7, 11, 16, 0, // Skip to: 6061 +/* 1954 */ MCD_OPC_CheckPredicate, 105, 6, 16, 0, // Skip to: 6061 +/* 1959 */ MCD_OPC_CheckField, 0, 7, 123, 255, 15, 0, // Skip to: 6061 +/* 1966 */ MCD_OPC_Decode, 129, 90, 167, 1, // Opcode: CV_CMPLE_SCI_B +/* 1971 */ MCD_OPC_FilterValue, 12, 159, 0, 0, // Skip to: 2135 +/* 1976 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 1979 */ MCD_OPC_FilterValue, 0, 23, 0, 0, // Skip to: 2007 +/* 1984 */ MCD_OPC_CheckPredicate, 105, 232, 15, 0, // Skip to: 6061 +/* 1989 */ MCD_OPC_CheckField, 25, 1, 0, 225, 15, 0, // Skip to: 6061 +/* 1996 */ MCD_OPC_CheckField, 0, 7, 123, 218, 15, 0, // Skip to: 6061 +/* 2003 */ MCD_OPC_Decode, 231, 90, 59, // Opcode: CV_MAX_H +/* 2007 */ MCD_OPC_FilterValue, 1, 23, 0, 0, // Skip to: 2035 +/* 2012 */ MCD_OPC_CheckPredicate, 105, 204, 15, 0, // Skip to: 6061 +/* 2017 */ MCD_OPC_CheckField, 25, 1, 0, 197, 15, 0, // Skip to: 6061 +/* 2024 */ MCD_OPC_CheckField, 0, 7, 123, 190, 15, 0, // Skip to: 6061 +/* 2031 */ MCD_OPC_Decode, 230, 90, 59, // Opcode: CV_MAX_B +/* 2035 */ MCD_OPC_FilterValue, 4, 23, 0, 0, // Skip to: 2063 +/* 2040 */ MCD_OPC_CheckPredicate, 105, 176, 15, 0, // Skip to: 6061 +/* 2045 */ MCD_OPC_CheckField, 25, 1, 0, 169, 15, 0, // Skip to: 6061 +/* 2052 */ MCD_OPC_CheckField, 0, 7, 123, 162, 15, 0, // Skip to: 6061 +/* 2059 */ MCD_OPC_Decode, 235, 90, 59, // Opcode: CV_MAX_SC_H +/* 2063 */ MCD_OPC_FilterValue, 5, 23, 0, 0, // Skip to: 2091 +/* 2068 */ MCD_OPC_CheckPredicate, 105, 148, 15, 0, // Skip to: 6061 +/* 2073 */ MCD_OPC_CheckField, 25, 1, 0, 141, 15, 0, // Skip to: 6061 +/* 2080 */ MCD_OPC_CheckField, 0, 7, 123, 134, 15, 0, // Skip to: 6061 +/* 2087 */ MCD_OPC_Decode, 234, 90, 59, // Opcode: CV_MAX_SC_B +/* 2091 */ MCD_OPC_FilterValue, 6, 17, 0, 0, // Skip to: 2113 +/* 2096 */ MCD_OPC_CheckPredicate, 105, 120, 15, 0, // Skip to: 6061 +/* 2101 */ MCD_OPC_CheckField, 0, 7, 123, 113, 15, 0, // Skip to: 6061 +/* 2108 */ MCD_OPC_Decode, 233, 90, 167, 1, // Opcode: CV_MAX_SCI_H +/* 2113 */ MCD_OPC_FilterValue, 7, 103, 15, 0, // Skip to: 6061 +/* 2118 */ MCD_OPC_CheckPredicate, 105, 98, 15, 0, // Skip to: 6061 +/* 2123 */ MCD_OPC_CheckField, 0, 7, 123, 91, 15, 0, // Skip to: 6061 +/* 2130 */ MCD_OPC_Decode, 232, 90, 167, 1, // Opcode: CV_MAX_SCI_B +/* 2135 */ MCD_OPC_FilterValue, 13, 159, 0, 0, // Skip to: 2299 +/* 2140 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 2143 */ MCD_OPC_FilterValue, 0, 23, 0, 0, // Skip to: 2171 +/* 2148 */ MCD_OPC_CheckPredicate, 105, 68, 15, 0, // Skip to: 6061 +/* 2153 */ MCD_OPC_CheckField, 25, 1, 0, 61, 15, 0, // Skip to: 6061 +/* 2160 */ MCD_OPC_CheckField, 0, 7, 123, 54, 15, 0, // Skip to: 6061 +/* 2167 */ MCD_OPC_Decode, 238, 89, 59, // Opcode: CV_CMPGTU_H +/* 2171 */ MCD_OPC_FilterValue, 1, 23, 0, 0, // Skip to: 2199 +/* 2176 */ MCD_OPC_CheckPredicate, 105, 40, 15, 0, // Skip to: 6061 +/* 2181 */ MCD_OPC_CheckField, 25, 1, 0, 33, 15, 0, // Skip to: 6061 +/* 2188 */ MCD_OPC_CheckField, 0, 7, 123, 26, 15, 0, // Skip to: 6061 +/* 2195 */ MCD_OPC_Decode, 237, 89, 59, // Opcode: CV_CMPGTU_B +/* 2199 */ MCD_OPC_FilterValue, 4, 23, 0, 0, // Skip to: 2227 +/* 2204 */ MCD_OPC_CheckPredicate, 105, 12, 15, 0, // Skip to: 6061 +/* 2209 */ MCD_OPC_CheckField, 25, 1, 0, 5, 15, 0, // Skip to: 6061 +/* 2216 */ MCD_OPC_CheckField, 0, 7, 123, 254, 14, 0, // Skip to: 6061 +/* 2223 */ MCD_OPC_Decode, 242, 89, 59, // Opcode: CV_CMPGTU_SC_H +/* 2227 */ MCD_OPC_FilterValue, 5, 23, 0, 0, // Skip to: 2255 +/* 2232 */ MCD_OPC_CheckPredicate, 105, 240, 14, 0, // Skip to: 6061 +/* 2237 */ MCD_OPC_CheckField, 25, 1, 0, 233, 14, 0, // Skip to: 6061 +/* 2244 */ MCD_OPC_CheckField, 0, 7, 123, 226, 14, 0, // Skip to: 6061 +/* 2251 */ MCD_OPC_Decode, 241, 89, 59, // Opcode: CV_CMPGTU_SC_B +/* 2255 */ MCD_OPC_FilterValue, 6, 17, 0, 0, // Skip to: 2277 +/* 2260 */ MCD_OPC_CheckPredicate, 105, 212, 14, 0, // Skip to: 6061 +/* 2265 */ MCD_OPC_CheckField, 0, 7, 123, 205, 14, 0, // Skip to: 6061 +/* 2272 */ MCD_OPC_Decode, 240, 89, 168, 1, // Opcode: CV_CMPGTU_SCI_H +/* 2277 */ MCD_OPC_FilterValue, 7, 195, 14, 0, // Skip to: 6061 +/* 2282 */ MCD_OPC_CheckPredicate, 105, 190, 14, 0, // Skip to: 6061 +/* 2287 */ MCD_OPC_CheckField, 0, 7, 123, 183, 14, 0, // Skip to: 6061 +/* 2294 */ MCD_OPC_Decode, 239, 89, 168, 1, // Opcode: CV_CMPGTU_SCI_B +/* 2299 */ MCD_OPC_FilterValue, 14, 159, 0, 0, // Skip to: 2463 +/* 2304 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 2307 */ MCD_OPC_FilterValue, 0, 23, 0, 0, // Skip to: 2335 +/* 2312 */ MCD_OPC_CheckPredicate, 105, 160, 14, 0, // Skip to: 6061 +/* 2317 */ MCD_OPC_CheckField, 25, 1, 0, 153, 14, 0, // Skip to: 6061 +/* 2324 */ MCD_OPC_CheckField, 0, 7, 123, 146, 14, 0, // Skip to: 6061 +/* 2331 */ MCD_OPC_Decode, 225, 90, 59, // Opcode: CV_MAXU_H +/* 2335 */ MCD_OPC_FilterValue, 1, 23, 0, 0, // Skip to: 2363 +/* 2340 */ MCD_OPC_CheckPredicate, 105, 132, 14, 0, // Skip to: 6061 +/* 2345 */ MCD_OPC_CheckField, 25, 1, 0, 125, 14, 0, // Skip to: 6061 +/* 2352 */ MCD_OPC_CheckField, 0, 7, 123, 118, 14, 0, // Skip to: 6061 +/* 2359 */ MCD_OPC_Decode, 224, 90, 59, // Opcode: CV_MAXU_B +/* 2363 */ MCD_OPC_FilterValue, 4, 23, 0, 0, // Skip to: 2391 +/* 2368 */ MCD_OPC_CheckPredicate, 105, 104, 14, 0, // Skip to: 6061 +/* 2373 */ MCD_OPC_CheckField, 25, 1, 0, 97, 14, 0, // Skip to: 6061 +/* 2380 */ MCD_OPC_CheckField, 0, 7, 123, 90, 14, 0, // Skip to: 6061 +/* 2387 */ MCD_OPC_Decode, 229, 90, 59, // Opcode: CV_MAXU_SC_H +/* 2391 */ MCD_OPC_FilterValue, 5, 23, 0, 0, // Skip to: 2419 +/* 2396 */ MCD_OPC_CheckPredicate, 105, 76, 14, 0, // Skip to: 6061 +/* 2401 */ MCD_OPC_CheckField, 25, 1, 0, 69, 14, 0, // Skip to: 6061 +/* 2408 */ MCD_OPC_CheckField, 0, 7, 123, 62, 14, 0, // Skip to: 6061 +/* 2415 */ MCD_OPC_Decode, 228, 90, 59, // Opcode: CV_MAXU_SC_B +/* 2419 */ MCD_OPC_FilterValue, 6, 17, 0, 0, // Skip to: 2441 +/* 2424 */ MCD_OPC_CheckPredicate, 105, 48, 14, 0, // Skip to: 6061 +/* 2429 */ MCD_OPC_CheckField, 0, 7, 123, 41, 14, 0, // Skip to: 6061 +/* 2436 */ MCD_OPC_Decode, 227, 90, 168, 1, // Opcode: CV_MAXU_SCI_H +/* 2441 */ MCD_OPC_FilterValue, 7, 31, 14, 0, // Skip to: 6061 +/* 2446 */ MCD_OPC_CheckPredicate, 105, 26, 14, 0, // Skip to: 6061 +/* 2451 */ MCD_OPC_CheckField, 0, 7, 123, 19, 14, 0, // Skip to: 6061 +/* 2458 */ MCD_OPC_Decode, 226, 90, 168, 1, // Opcode: CV_MAXU_SCI_B +/* 2463 */ MCD_OPC_FilterValue, 15, 159, 0, 0, // Skip to: 2627 +/* 2468 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 2471 */ MCD_OPC_FilterValue, 0, 23, 0, 0, // Skip to: 2499 +/* 2476 */ MCD_OPC_CheckPredicate, 105, 252, 13, 0, // Skip to: 6061 +/* 2481 */ MCD_OPC_CheckField, 25, 1, 0, 245, 13, 0, // Skip to: 6061 +/* 2488 */ MCD_OPC_CheckField, 0, 7, 123, 238, 13, 0, // Skip to: 6061 +/* 2495 */ MCD_OPC_Decode, 226, 89, 59, // Opcode: CV_CMPGEU_H +/* 2499 */ MCD_OPC_FilterValue, 1, 23, 0, 0, // Skip to: 2527 +/* 2504 */ MCD_OPC_CheckPredicate, 105, 224, 13, 0, // Skip to: 6061 +/* 2509 */ MCD_OPC_CheckField, 25, 1, 0, 217, 13, 0, // Skip to: 6061 +/* 2516 */ MCD_OPC_CheckField, 0, 7, 123, 210, 13, 0, // Skip to: 6061 +/* 2523 */ MCD_OPC_Decode, 225, 89, 59, // Opcode: CV_CMPGEU_B +/* 2527 */ MCD_OPC_FilterValue, 4, 23, 0, 0, // Skip to: 2555 +/* 2532 */ MCD_OPC_CheckPredicate, 105, 196, 13, 0, // Skip to: 6061 +/* 2537 */ MCD_OPC_CheckField, 25, 1, 0, 189, 13, 0, // Skip to: 6061 +/* 2544 */ MCD_OPC_CheckField, 0, 7, 123, 182, 13, 0, // Skip to: 6061 +/* 2551 */ MCD_OPC_Decode, 230, 89, 59, // Opcode: CV_CMPGEU_SC_H +/* 2555 */ MCD_OPC_FilterValue, 5, 23, 0, 0, // Skip to: 2583 +/* 2560 */ MCD_OPC_CheckPredicate, 105, 168, 13, 0, // Skip to: 6061 +/* 2565 */ MCD_OPC_CheckField, 25, 1, 0, 161, 13, 0, // Skip to: 6061 +/* 2572 */ MCD_OPC_CheckField, 0, 7, 123, 154, 13, 0, // Skip to: 6061 +/* 2579 */ MCD_OPC_Decode, 229, 89, 59, // Opcode: CV_CMPGEU_SC_B +/* 2583 */ MCD_OPC_FilterValue, 6, 17, 0, 0, // Skip to: 2605 +/* 2588 */ MCD_OPC_CheckPredicate, 105, 140, 13, 0, // Skip to: 6061 +/* 2593 */ MCD_OPC_CheckField, 0, 7, 123, 133, 13, 0, // Skip to: 6061 +/* 2600 */ MCD_OPC_Decode, 228, 89, 168, 1, // Opcode: CV_CMPGEU_SCI_H +/* 2605 */ MCD_OPC_FilterValue, 7, 123, 13, 0, // Skip to: 6061 +/* 2610 */ MCD_OPC_CheckPredicate, 105, 118, 13, 0, // Skip to: 6061 +/* 2615 */ MCD_OPC_CheckField, 0, 7, 123, 111, 13, 0, // Skip to: 6061 +/* 2622 */ MCD_OPC_Decode, 227, 89, 168, 1, // Opcode: CV_CMPGEU_SCI_B +/* 2627 */ MCD_OPC_FilterValue, 16, 159, 0, 0, // Skip to: 2791 +/* 2632 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 2635 */ MCD_OPC_FilterValue, 0, 23, 0, 0, // Skip to: 2663 +/* 2640 */ MCD_OPC_CheckPredicate, 105, 88, 13, 0, // Skip to: 6061 +/* 2645 */ MCD_OPC_CheckField, 25, 1, 0, 81, 13, 0, // Skip to: 6061 +/* 2652 */ MCD_OPC_CheckField, 0, 7, 123, 74, 13, 0, // Skip to: 6061 +/* 2659 */ MCD_OPC_Decode, 190, 91, 59, // Opcode: CV_SRL_H +/* 2663 */ MCD_OPC_FilterValue, 1, 23, 0, 0, // Skip to: 2691 +/* 2668 */ MCD_OPC_CheckPredicate, 105, 60, 13, 0, // Skip to: 6061 +/* 2673 */ MCD_OPC_CheckField, 25, 1, 0, 53, 13, 0, // Skip to: 6061 +/* 2680 */ MCD_OPC_CheckField, 0, 7, 123, 46, 13, 0, // Skip to: 6061 +/* 2687 */ MCD_OPC_Decode, 189, 91, 59, // Opcode: CV_SRL_B +/* 2691 */ MCD_OPC_FilterValue, 4, 23, 0, 0, // Skip to: 2719 +/* 2696 */ MCD_OPC_CheckPredicate, 105, 32, 13, 0, // Skip to: 6061 +/* 2701 */ MCD_OPC_CheckField, 25, 1, 0, 25, 13, 0, // Skip to: 6061 +/* 2708 */ MCD_OPC_CheckField, 0, 7, 123, 18, 13, 0, // Skip to: 6061 +/* 2715 */ MCD_OPC_Decode, 194, 91, 59, // Opcode: CV_SRL_SC_H +/* 2719 */ MCD_OPC_FilterValue, 5, 23, 0, 0, // Skip to: 2747 +/* 2724 */ MCD_OPC_CheckPredicate, 105, 4, 13, 0, // Skip to: 6061 +/* 2729 */ MCD_OPC_CheckField, 25, 1, 0, 253, 12, 0, // Skip to: 6061 +/* 2736 */ MCD_OPC_CheckField, 0, 7, 123, 246, 12, 0, // Skip to: 6061 +/* 2743 */ MCD_OPC_Decode, 193, 91, 59, // Opcode: CV_SRL_SC_B +/* 2747 */ MCD_OPC_FilterValue, 6, 17, 0, 0, // Skip to: 2769 +/* 2752 */ MCD_OPC_CheckPredicate, 105, 232, 12, 0, // Skip to: 6061 +/* 2757 */ MCD_OPC_CheckField, 0, 7, 123, 225, 12, 0, // Skip to: 6061 +/* 2764 */ MCD_OPC_Decode, 192, 91, 169, 1, // Opcode: CV_SRL_SCI_H +/* 2769 */ MCD_OPC_FilterValue, 7, 215, 12, 0, // Skip to: 6061 +/* 2774 */ MCD_OPC_CheckPredicate, 105, 210, 12, 0, // Skip to: 6061 +/* 2779 */ MCD_OPC_CheckField, 0, 7, 123, 203, 12, 0, // Skip to: 6061 +/* 2786 */ MCD_OPC_Decode, 191, 91, 170, 1, // Opcode: CV_SRL_SCI_B +/* 2791 */ MCD_OPC_FilterValue, 17, 159, 0, 0, // Skip to: 2955 +/* 2796 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 2799 */ MCD_OPC_FilterValue, 0, 23, 0, 0, // Skip to: 2827 +/* 2804 */ MCD_OPC_CheckPredicate, 105, 180, 12, 0, // Skip to: 6061 +/* 2809 */ MCD_OPC_CheckField, 25, 1, 0, 173, 12, 0, // Skip to: 6061 +/* 2816 */ MCD_OPC_CheckField, 0, 7, 123, 166, 12, 0, // Skip to: 6061 +/* 2823 */ MCD_OPC_Decode, 134, 90, 59, // Opcode: CV_CMPLTU_H +/* 2827 */ MCD_OPC_FilterValue, 1, 23, 0, 0, // Skip to: 2855 +/* 2832 */ MCD_OPC_CheckPredicate, 105, 152, 12, 0, // Skip to: 6061 +/* 2837 */ MCD_OPC_CheckField, 25, 1, 0, 145, 12, 0, // Skip to: 6061 +/* 2844 */ MCD_OPC_CheckField, 0, 7, 123, 138, 12, 0, // Skip to: 6061 +/* 2851 */ MCD_OPC_Decode, 133, 90, 59, // Opcode: CV_CMPLTU_B +/* 2855 */ MCD_OPC_FilterValue, 4, 23, 0, 0, // Skip to: 2883 +/* 2860 */ MCD_OPC_CheckPredicate, 105, 124, 12, 0, // Skip to: 6061 +/* 2865 */ MCD_OPC_CheckField, 25, 1, 0, 117, 12, 0, // Skip to: 6061 +/* 2872 */ MCD_OPC_CheckField, 0, 7, 123, 110, 12, 0, // Skip to: 6061 +/* 2879 */ MCD_OPC_Decode, 138, 90, 59, // Opcode: CV_CMPLTU_SC_H +/* 2883 */ MCD_OPC_FilterValue, 5, 23, 0, 0, // Skip to: 2911 +/* 2888 */ MCD_OPC_CheckPredicate, 105, 96, 12, 0, // Skip to: 6061 +/* 2893 */ MCD_OPC_CheckField, 25, 1, 0, 89, 12, 0, // Skip to: 6061 +/* 2900 */ MCD_OPC_CheckField, 0, 7, 123, 82, 12, 0, // Skip to: 6061 +/* 2907 */ MCD_OPC_Decode, 137, 90, 59, // Opcode: CV_CMPLTU_SC_B +/* 2911 */ MCD_OPC_FilterValue, 6, 17, 0, 0, // Skip to: 2933 +/* 2916 */ MCD_OPC_CheckPredicate, 105, 68, 12, 0, // Skip to: 6061 +/* 2921 */ MCD_OPC_CheckField, 0, 7, 123, 61, 12, 0, // Skip to: 6061 +/* 2928 */ MCD_OPC_Decode, 136, 90, 168, 1, // Opcode: CV_CMPLTU_SCI_H +/* 2933 */ MCD_OPC_FilterValue, 7, 51, 12, 0, // Skip to: 6061 +/* 2938 */ MCD_OPC_CheckPredicate, 105, 46, 12, 0, // Skip to: 6061 +/* 2943 */ MCD_OPC_CheckField, 0, 7, 123, 39, 12, 0, // Skip to: 6061 +/* 2950 */ MCD_OPC_Decode, 135, 90, 168, 1, // Opcode: CV_CMPLTU_SCI_B +/* 2955 */ MCD_OPC_FilterValue, 18, 159, 0, 0, // Skip to: 3119 +/* 2960 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 2963 */ MCD_OPC_FilterValue, 0, 23, 0, 0, // Skip to: 2991 +/* 2968 */ MCD_OPC_CheckPredicate, 105, 16, 12, 0, // Skip to: 6061 +/* 2973 */ MCD_OPC_CheckField, 25, 1, 0, 9, 12, 0, // Skip to: 6061 +/* 2980 */ MCD_OPC_CheckField, 0, 7, 123, 2, 12, 0, // Skip to: 6061 +/* 2987 */ MCD_OPC_Decode, 184, 91, 59, // Opcode: CV_SRA_H +/* 2991 */ MCD_OPC_FilterValue, 1, 23, 0, 0, // Skip to: 3019 +/* 2996 */ MCD_OPC_CheckPredicate, 105, 244, 11, 0, // Skip to: 6061 +/* 3001 */ MCD_OPC_CheckField, 25, 1, 0, 237, 11, 0, // Skip to: 6061 +/* 3008 */ MCD_OPC_CheckField, 0, 7, 123, 230, 11, 0, // Skip to: 6061 +/* 3015 */ MCD_OPC_Decode, 183, 91, 59, // Opcode: CV_SRA_B +/* 3019 */ MCD_OPC_FilterValue, 4, 23, 0, 0, // Skip to: 3047 +/* 3024 */ MCD_OPC_CheckPredicate, 105, 216, 11, 0, // Skip to: 6061 +/* 3029 */ MCD_OPC_CheckField, 25, 1, 0, 209, 11, 0, // Skip to: 6061 +/* 3036 */ MCD_OPC_CheckField, 0, 7, 123, 202, 11, 0, // Skip to: 6061 +/* 3043 */ MCD_OPC_Decode, 188, 91, 59, // Opcode: CV_SRA_SC_H +/* 3047 */ MCD_OPC_FilterValue, 5, 23, 0, 0, // Skip to: 3075 +/* 3052 */ MCD_OPC_CheckPredicate, 105, 188, 11, 0, // Skip to: 6061 +/* 3057 */ MCD_OPC_CheckField, 25, 1, 0, 181, 11, 0, // Skip to: 6061 +/* 3064 */ MCD_OPC_CheckField, 0, 7, 123, 174, 11, 0, // Skip to: 6061 +/* 3071 */ MCD_OPC_Decode, 187, 91, 59, // Opcode: CV_SRA_SC_B +/* 3075 */ MCD_OPC_FilterValue, 6, 17, 0, 0, // Skip to: 3097 +/* 3080 */ MCD_OPC_CheckPredicate, 105, 160, 11, 0, // Skip to: 6061 +/* 3085 */ MCD_OPC_CheckField, 0, 7, 123, 153, 11, 0, // Skip to: 6061 +/* 3092 */ MCD_OPC_Decode, 186, 91, 169, 1, // Opcode: CV_SRA_SCI_H +/* 3097 */ MCD_OPC_FilterValue, 7, 143, 11, 0, // Skip to: 6061 +/* 3102 */ MCD_OPC_CheckPredicate, 105, 138, 11, 0, // Skip to: 6061 +/* 3107 */ MCD_OPC_CheckField, 0, 7, 123, 131, 11, 0, // Skip to: 6061 +/* 3114 */ MCD_OPC_Decode, 185, 91, 170, 1, // Opcode: CV_SRA_SCI_B +/* 3119 */ MCD_OPC_FilterValue, 19, 159, 0, 0, // Skip to: 3283 +/* 3124 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 3127 */ MCD_OPC_FilterValue, 0, 23, 0, 0, // Skip to: 3155 +/* 3132 */ MCD_OPC_CheckPredicate, 105, 108, 11, 0, // Skip to: 6061 +/* 3137 */ MCD_OPC_CheckField, 25, 1, 0, 101, 11, 0, // Skip to: 6061 +/* 3144 */ MCD_OPC_CheckField, 0, 7, 123, 94, 11, 0, // Skip to: 6061 +/* 3151 */ MCD_OPC_Decode, 250, 89, 59, // Opcode: CV_CMPLEU_H +/* 3155 */ MCD_OPC_FilterValue, 1, 23, 0, 0, // Skip to: 3183 +/* 3160 */ MCD_OPC_CheckPredicate, 105, 80, 11, 0, // Skip to: 6061 +/* 3165 */ MCD_OPC_CheckField, 25, 1, 0, 73, 11, 0, // Skip to: 6061 +/* 3172 */ MCD_OPC_CheckField, 0, 7, 123, 66, 11, 0, // Skip to: 6061 +/* 3179 */ MCD_OPC_Decode, 249, 89, 59, // Opcode: CV_CMPLEU_B +/* 3183 */ MCD_OPC_FilterValue, 4, 23, 0, 0, // Skip to: 3211 +/* 3188 */ MCD_OPC_CheckPredicate, 105, 52, 11, 0, // Skip to: 6061 +/* 3193 */ MCD_OPC_CheckField, 25, 1, 0, 45, 11, 0, // Skip to: 6061 +/* 3200 */ MCD_OPC_CheckField, 0, 7, 123, 38, 11, 0, // Skip to: 6061 +/* 3207 */ MCD_OPC_Decode, 254, 89, 59, // Opcode: CV_CMPLEU_SC_H +/* 3211 */ MCD_OPC_FilterValue, 5, 23, 0, 0, // Skip to: 3239 +/* 3216 */ MCD_OPC_CheckPredicate, 105, 24, 11, 0, // Skip to: 6061 +/* 3221 */ MCD_OPC_CheckField, 25, 1, 0, 17, 11, 0, // Skip to: 6061 +/* 3228 */ MCD_OPC_CheckField, 0, 7, 123, 10, 11, 0, // Skip to: 6061 +/* 3235 */ MCD_OPC_Decode, 253, 89, 59, // Opcode: CV_CMPLEU_SC_B +/* 3239 */ MCD_OPC_FilterValue, 6, 17, 0, 0, // Skip to: 3261 +/* 3244 */ MCD_OPC_CheckPredicate, 105, 252, 10, 0, // Skip to: 6061 +/* 3249 */ MCD_OPC_CheckField, 0, 7, 123, 245, 10, 0, // Skip to: 6061 +/* 3256 */ MCD_OPC_Decode, 252, 89, 168, 1, // Opcode: CV_CMPLEU_SCI_H +/* 3261 */ MCD_OPC_FilterValue, 7, 235, 10, 0, // Skip to: 6061 +/* 3266 */ MCD_OPC_CheckPredicate, 105, 230, 10, 0, // Skip to: 6061 +/* 3271 */ MCD_OPC_CheckField, 0, 7, 123, 223, 10, 0, // Skip to: 6061 +/* 3278 */ MCD_OPC_Decode, 251, 89, 168, 1, // Opcode: CV_CMPLEU_SCI_B +/* 3283 */ MCD_OPC_FilterValue, 20, 159, 0, 0, // Skip to: 3447 +/* 3288 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 3291 */ MCD_OPC_FilterValue, 0, 23, 0, 0, // Skip to: 3319 +/* 3296 */ MCD_OPC_CheckPredicate, 105, 200, 10, 0, // Skip to: 6061 +/* 3301 */ MCD_OPC_CheckField, 25, 1, 0, 193, 10, 0, // Skip to: 6061 +/* 3308 */ MCD_OPC_CheckField, 0, 7, 123, 186, 10, 0, // Skip to: 6061 +/* 3315 */ MCD_OPC_Decode, 178, 91, 59, // Opcode: CV_SLL_H +/* 3319 */ MCD_OPC_FilterValue, 1, 23, 0, 0, // Skip to: 3347 +/* 3324 */ MCD_OPC_CheckPredicate, 105, 172, 10, 0, // Skip to: 6061 +/* 3329 */ MCD_OPC_CheckField, 25, 1, 0, 165, 10, 0, // Skip to: 6061 +/* 3336 */ MCD_OPC_CheckField, 0, 7, 123, 158, 10, 0, // Skip to: 6061 +/* 3343 */ MCD_OPC_Decode, 177, 91, 59, // Opcode: CV_SLL_B +/* 3347 */ MCD_OPC_FilterValue, 4, 23, 0, 0, // Skip to: 3375 +/* 3352 */ MCD_OPC_CheckPredicate, 105, 144, 10, 0, // Skip to: 6061 +/* 3357 */ MCD_OPC_CheckField, 25, 1, 0, 137, 10, 0, // Skip to: 6061 +/* 3364 */ MCD_OPC_CheckField, 0, 7, 123, 130, 10, 0, // Skip to: 6061 +/* 3371 */ MCD_OPC_Decode, 182, 91, 59, // Opcode: CV_SLL_SC_H +/* 3375 */ MCD_OPC_FilterValue, 5, 23, 0, 0, // Skip to: 3403 +/* 3380 */ MCD_OPC_CheckPredicate, 105, 116, 10, 0, // Skip to: 6061 +/* 3385 */ MCD_OPC_CheckField, 25, 1, 0, 109, 10, 0, // Skip to: 6061 +/* 3392 */ MCD_OPC_CheckField, 0, 7, 123, 102, 10, 0, // Skip to: 6061 +/* 3399 */ MCD_OPC_Decode, 181, 91, 59, // Opcode: CV_SLL_SC_B +/* 3403 */ MCD_OPC_FilterValue, 6, 17, 0, 0, // Skip to: 3425 +/* 3408 */ MCD_OPC_CheckPredicate, 105, 88, 10, 0, // Skip to: 6061 +/* 3413 */ MCD_OPC_CheckField, 0, 7, 123, 81, 10, 0, // Skip to: 6061 +/* 3420 */ MCD_OPC_Decode, 180, 91, 169, 1, // Opcode: CV_SLL_SCI_H +/* 3425 */ MCD_OPC_FilterValue, 7, 71, 10, 0, // Skip to: 6061 +/* 3430 */ MCD_OPC_CheckPredicate, 105, 66, 10, 0, // Skip to: 6061 +/* 3435 */ MCD_OPC_CheckField, 0, 7, 123, 59, 10, 0, // Skip to: 6061 +/* 3442 */ MCD_OPC_Decode, 179, 91, 170, 1, // Opcode: CV_SLL_SCI_B +/* 3447 */ MCD_OPC_FilterValue, 21, 203, 0, 0, // Skip to: 3655 +/* 3452 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 3455 */ MCD_OPC_FilterValue, 0, 45, 0, 0, // Skip to: 3505 +/* 3460 */ MCD_OPC_ExtractField, 25, 1, // Inst{25} ... +/* 3463 */ MCD_OPC_FilterValue, 0, 16, 0, 0, // Skip to: 3484 +/* 3468 */ MCD_OPC_CheckPredicate, 105, 28, 10, 0, // Skip to: 6061 +/* 3473 */ MCD_OPC_CheckField, 0, 7, 123, 21, 10, 0, // Skip to: 6061 +/* 3480 */ MCD_OPC_Decode, 157, 90, 58, // Opcode: CV_CPLXMUL_R +/* 3484 */ MCD_OPC_FilterValue, 1, 12, 10, 0, // Skip to: 6061 +/* 3489 */ MCD_OPC_CheckPredicate, 105, 7, 10, 0, // Skip to: 6061 +/* 3494 */ MCD_OPC_CheckField, 0, 7, 123, 0, 10, 0, // Skip to: 6061 +/* 3501 */ MCD_OPC_Decode, 153, 90, 58, // Opcode: CV_CPLXMUL_I +/* 3505 */ MCD_OPC_FilterValue, 2, 45, 0, 0, // Skip to: 3555 +/* 3510 */ MCD_OPC_ExtractField, 25, 1, // Inst{25} ... +/* 3513 */ MCD_OPC_FilterValue, 0, 16, 0, 0, // Skip to: 3534 +/* 3518 */ MCD_OPC_CheckPredicate, 105, 234, 9, 0, // Skip to: 6061 +/* 3523 */ MCD_OPC_CheckField, 0, 7, 123, 227, 9, 0, // Skip to: 6061 +/* 3530 */ MCD_OPC_Decode, 158, 90, 58, // Opcode: CV_CPLXMUL_R_DIV2 +/* 3534 */ MCD_OPC_FilterValue, 1, 218, 9, 0, // Skip to: 6061 +/* 3539 */ MCD_OPC_CheckPredicate, 105, 213, 9, 0, // Skip to: 6061 +/* 3544 */ MCD_OPC_CheckField, 0, 7, 123, 206, 9, 0, // Skip to: 6061 +/* 3551 */ MCD_OPC_Decode, 154, 90, 58, // Opcode: CV_CPLXMUL_I_DIV2 +/* 3555 */ MCD_OPC_FilterValue, 4, 45, 0, 0, // Skip to: 3605 +/* 3560 */ MCD_OPC_ExtractField, 25, 1, // Inst{25} ... +/* 3563 */ MCD_OPC_FilterValue, 0, 16, 0, 0, // Skip to: 3584 +/* 3568 */ MCD_OPC_CheckPredicate, 105, 184, 9, 0, // Skip to: 6061 +/* 3573 */ MCD_OPC_CheckField, 0, 7, 123, 177, 9, 0, // Skip to: 6061 +/* 3580 */ MCD_OPC_Decode, 159, 90, 58, // Opcode: CV_CPLXMUL_R_DIV4 +/* 3584 */ MCD_OPC_FilterValue, 1, 168, 9, 0, // Skip to: 6061 +/* 3589 */ MCD_OPC_CheckPredicate, 105, 163, 9, 0, // Skip to: 6061 +/* 3594 */ MCD_OPC_CheckField, 0, 7, 123, 156, 9, 0, // Skip to: 6061 +/* 3601 */ MCD_OPC_Decode, 155, 90, 58, // Opcode: CV_CPLXMUL_I_DIV4 +/* 3605 */ MCD_OPC_FilterValue, 6, 147, 9, 0, // Skip to: 6061 +/* 3610 */ MCD_OPC_ExtractField, 25, 1, // Inst{25} ... +/* 3613 */ MCD_OPC_FilterValue, 0, 16, 0, 0, // Skip to: 3634 +/* 3618 */ MCD_OPC_CheckPredicate, 105, 134, 9, 0, // Skip to: 6061 +/* 3623 */ MCD_OPC_CheckField, 0, 7, 123, 127, 9, 0, // Skip to: 6061 +/* 3630 */ MCD_OPC_Decode, 160, 90, 58, // Opcode: CV_CPLXMUL_R_DIV8 +/* 3634 */ MCD_OPC_FilterValue, 1, 118, 9, 0, // Skip to: 6061 +/* 3639 */ MCD_OPC_CheckPredicate, 105, 113, 9, 0, // Skip to: 6061 +/* 3644 */ MCD_OPC_CheckField, 0, 7, 123, 106, 9, 0, // Skip to: 6061 +/* 3651 */ MCD_OPC_Decode, 156, 90, 58, // Opcode: CV_CPLXMUL_I_DIV8 +/* 3655 */ MCD_OPC_FilterValue, 22, 159, 0, 0, // Skip to: 3819 +/* 3660 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 3663 */ MCD_OPC_FilterValue, 0, 23, 0, 0, // Skip to: 3691 +/* 3668 */ MCD_OPC_CheckPredicate, 105, 84, 9, 0, // Skip to: 6061 +/* 3673 */ MCD_OPC_CheckField, 25, 1, 0, 77, 9, 0, // Skip to: 6061 +/* 3680 */ MCD_OPC_CheckField, 0, 7, 123, 70, 9, 0, // Skip to: 6061 +/* 3687 */ MCD_OPC_Decode, 132, 91, 59, // Opcode: CV_OR_H +/* 3691 */ MCD_OPC_FilterValue, 1, 23, 0, 0, // Skip to: 3719 +/* 3696 */ MCD_OPC_CheckPredicate, 105, 56, 9, 0, // Skip to: 6061 +/* 3701 */ MCD_OPC_CheckField, 25, 1, 0, 49, 9, 0, // Skip to: 6061 +/* 3708 */ MCD_OPC_CheckField, 0, 7, 123, 42, 9, 0, // Skip to: 6061 +/* 3715 */ MCD_OPC_Decode, 131, 91, 59, // Opcode: CV_OR_B +/* 3719 */ MCD_OPC_FilterValue, 4, 23, 0, 0, // Skip to: 3747 +/* 3724 */ MCD_OPC_CheckPredicate, 105, 28, 9, 0, // Skip to: 6061 +/* 3729 */ MCD_OPC_CheckField, 25, 1, 0, 21, 9, 0, // Skip to: 6061 +/* 3736 */ MCD_OPC_CheckField, 0, 7, 123, 14, 9, 0, // Skip to: 6061 +/* 3743 */ MCD_OPC_Decode, 136, 91, 59, // Opcode: CV_OR_SC_H +/* 3747 */ MCD_OPC_FilterValue, 5, 23, 0, 0, // Skip to: 3775 +/* 3752 */ MCD_OPC_CheckPredicate, 105, 0, 9, 0, // Skip to: 6061 +/* 3757 */ MCD_OPC_CheckField, 25, 1, 0, 249, 8, 0, // Skip to: 6061 +/* 3764 */ MCD_OPC_CheckField, 0, 7, 123, 242, 8, 0, // Skip to: 6061 +/* 3771 */ MCD_OPC_Decode, 135, 91, 59, // Opcode: CV_OR_SC_B +/* 3775 */ MCD_OPC_FilterValue, 6, 17, 0, 0, // Skip to: 3797 +/* 3780 */ MCD_OPC_CheckPredicate, 105, 228, 8, 0, // Skip to: 6061 +/* 3785 */ MCD_OPC_CheckField, 0, 7, 123, 221, 8, 0, // Skip to: 6061 +/* 3792 */ MCD_OPC_Decode, 134, 91, 167, 1, // Opcode: CV_OR_SCI_H +/* 3797 */ MCD_OPC_FilterValue, 7, 211, 8, 0, // Skip to: 6061 +/* 3802 */ MCD_OPC_CheckPredicate, 105, 206, 8, 0, // Skip to: 6061 +/* 3807 */ MCD_OPC_CheckField, 0, 7, 123, 199, 8, 0, // Skip to: 6061 +/* 3814 */ MCD_OPC_Decode, 133, 91, 167, 1, // Opcode: CV_OR_SCI_B +/* 3819 */ MCD_OPC_FilterValue, 23, 30, 0, 0, // Skip to: 3854 +/* 3824 */ MCD_OPC_CheckPredicate, 105, 184, 8, 0, // Skip to: 6061 +/* 3829 */ MCD_OPC_CheckField, 20, 6, 0, 177, 8, 0, // Skip to: 6061 +/* 3836 */ MCD_OPC_CheckField, 12, 3, 0, 170, 8, 0, // Skip to: 6061 +/* 3843 */ MCD_OPC_CheckField, 0, 7, 123, 163, 8, 0, // Skip to: 6061 +/* 3850 */ MCD_OPC_Decode, 152, 90, 49, // Opcode: CV_CPLXCONJ +/* 3854 */ MCD_OPC_FilterValue, 24, 159, 0, 0, // Skip to: 4018 +/* 3859 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 3862 */ MCD_OPC_FilterValue, 0, 23, 0, 0, // Skip to: 3890 +/* 3867 */ MCD_OPC_CheckPredicate, 105, 141, 8, 0, // Skip to: 6061 +/* 3872 */ MCD_OPC_CheckField, 25, 1, 0, 134, 8, 0, // Skip to: 6061 +/* 3879 */ MCD_OPC_CheckField, 0, 7, 123, 127, 8, 0, // Skip to: 6061 +/* 3886 */ MCD_OPC_Decode, 220, 91, 59, // Opcode: CV_XOR_H +/* 3890 */ MCD_OPC_FilterValue, 1, 23, 0, 0, // Skip to: 3918 +/* 3895 */ MCD_OPC_CheckPredicate, 105, 113, 8, 0, // Skip to: 6061 +/* 3900 */ MCD_OPC_CheckField, 25, 1, 0, 106, 8, 0, // Skip to: 6061 +/* 3907 */ MCD_OPC_CheckField, 0, 7, 123, 99, 8, 0, // Skip to: 6061 +/* 3914 */ MCD_OPC_Decode, 219, 91, 59, // Opcode: CV_XOR_B +/* 3918 */ MCD_OPC_FilterValue, 4, 23, 0, 0, // Skip to: 3946 +/* 3923 */ MCD_OPC_CheckPredicate, 105, 85, 8, 0, // Skip to: 6061 +/* 3928 */ MCD_OPC_CheckField, 25, 1, 0, 78, 8, 0, // Skip to: 6061 +/* 3935 */ MCD_OPC_CheckField, 0, 7, 123, 71, 8, 0, // Skip to: 6061 +/* 3942 */ MCD_OPC_Decode, 224, 91, 59, // Opcode: CV_XOR_SC_H +/* 3946 */ MCD_OPC_FilterValue, 5, 23, 0, 0, // Skip to: 3974 +/* 3951 */ MCD_OPC_CheckPredicate, 105, 57, 8, 0, // Skip to: 6061 +/* 3956 */ MCD_OPC_CheckField, 25, 1, 0, 50, 8, 0, // Skip to: 6061 +/* 3963 */ MCD_OPC_CheckField, 0, 7, 123, 43, 8, 0, // Skip to: 6061 +/* 3970 */ MCD_OPC_Decode, 223, 91, 59, // Opcode: CV_XOR_SC_B +/* 3974 */ MCD_OPC_FilterValue, 6, 17, 0, 0, // Skip to: 3996 +/* 3979 */ MCD_OPC_CheckPredicate, 105, 29, 8, 0, // Skip to: 6061 +/* 3984 */ MCD_OPC_CheckField, 0, 7, 123, 22, 8, 0, // Skip to: 6061 +/* 3991 */ MCD_OPC_Decode, 222, 91, 167, 1, // Opcode: CV_XOR_SCI_H +/* 3996 */ MCD_OPC_FilterValue, 7, 12, 8, 0, // Skip to: 6061 +/* 4001 */ MCD_OPC_CheckPredicate, 105, 7, 8, 0, // Skip to: 6061 +/* 4006 */ MCD_OPC_CheckField, 0, 7, 123, 0, 8, 0, // Skip to: 6061 +/* 4013 */ MCD_OPC_Decode, 221, 91, 167, 1, // Opcode: CV_XOR_SCI_B +/* 4018 */ MCD_OPC_FilterValue, 25, 115, 0, 0, // Skip to: 4138 +/* 4023 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 4026 */ MCD_OPC_FilterValue, 0, 23, 0, 0, // Skip to: 4054 +/* 4031 */ MCD_OPC_CheckPredicate, 105, 233, 7, 0, // Skip to: 6061 +/* 4036 */ MCD_OPC_CheckField, 25, 1, 0, 226, 7, 0, // Skip to: 6061 +/* 4043 */ MCD_OPC_CheckField, 0, 7, 123, 219, 7, 0, // Skip to: 6061 +/* 4050 */ MCD_OPC_Decode, 199, 91, 59, // Opcode: CV_SUBROTMJ +/* 4054 */ MCD_OPC_FilterValue, 2, 23, 0, 0, // Skip to: 4082 +/* 4059 */ MCD_OPC_CheckPredicate, 105, 205, 7, 0, // Skip to: 6061 +/* 4064 */ MCD_OPC_CheckField, 25, 1, 0, 198, 7, 0, // Skip to: 6061 +/* 4071 */ MCD_OPC_CheckField, 0, 7, 123, 191, 7, 0, // Skip to: 6061 +/* 4078 */ MCD_OPC_Decode, 200, 91, 59, // Opcode: CV_SUBROTMJ_DIV2 +/* 4082 */ MCD_OPC_FilterValue, 4, 23, 0, 0, // Skip to: 4110 +/* 4087 */ MCD_OPC_CheckPredicate, 105, 177, 7, 0, // Skip to: 6061 +/* 4092 */ MCD_OPC_CheckField, 25, 1, 0, 170, 7, 0, // Skip to: 6061 +/* 4099 */ MCD_OPC_CheckField, 0, 7, 123, 163, 7, 0, // Skip to: 6061 +/* 4106 */ MCD_OPC_Decode, 201, 91, 59, // Opcode: CV_SUBROTMJ_DIV4 +/* 4110 */ MCD_OPC_FilterValue, 6, 154, 7, 0, // Skip to: 6061 +/* 4115 */ MCD_OPC_CheckPredicate, 105, 149, 7, 0, // Skip to: 6061 +/* 4120 */ MCD_OPC_CheckField, 25, 1, 0, 142, 7, 0, // Skip to: 6061 +/* 4127 */ MCD_OPC_CheckField, 0, 7, 123, 135, 7, 0, // Skip to: 6061 +/* 4134 */ MCD_OPC_Decode, 202, 91, 59, // Opcode: CV_SUBROTMJ_DIV8 +/* 4138 */ MCD_OPC_FilterValue, 26, 159, 0, 0, // Skip to: 4302 +/* 4143 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 4146 */ MCD_OPC_FilterValue, 0, 23, 0, 0, // Skip to: 4174 +/* 4151 */ MCD_OPC_CheckPredicate, 105, 113, 7, 0, // Skip to: 6061 +/* 4156 */ MCD_OPC_CheckField, 25, 1, 0, 106, 7, 0, // Skip to: 6061 +/* 4163 */ MCD_OPC_CheckField, 0, 7, 123, 99, 7, 0, // Skip to: 6061 +/* 4170 */ MCD_OPC_Decode, 190, 89, 59, // Opcode: CV_AND_H +/* 4174 */ MCD_OPC_FilterValue, 1, 23, 0, 0, // Skip to: 4202 +/* 4179 */ MCD_OPC_CheckPredicate, 105, 85, 7, 0, // Skip to: 6061 +/* 4184 */ MCD_OPC_CheckField, 25, 1, 0, 78, 7, 0, // Skip to: 6061 +/* 4191 */ MCD_OPC_CheckField, 0, 7, 123, 71, 7, 0, // Skip to: 6061 +/* 4198 */ MCD_OPC_Decode, 189, 89, 59, // Opcode: CV_AND_B +/* 4202 */ MCD_OPC_FilterValue, 4, 23, 0, 0, // Skip to: 4230 +/* 4207 */ MCD_OPC_CheckPredicate, 105, 57, 7, 0, // Skip to: 6061 +/* 4212 */ MCD_OPC_CheckField, 25, 1, 0, 50, 7, 0, // Skip to: 6061 +/* 4219 */ MCD_OPC_CheckField, 0, 7, 123, 43, 7, 0, // Skip to: 6061 +/* 4226 */ MCD_OPC_Decode, 194, 89, 59, // Opcode: CV_AND_SC_H +/* 4230 */ MCD_OPC_FilterValue, 5, 23, 0, 0, // Skip to: 4258 +/* 4235 */ MCD_OPC_CheckPredicate, 105, 29, 7, 0, // Skip to: 6061 +/* 4240 */ MCD_OPC_CheckField, 25, 1, 0, 22, 7, 0, // Skip to: 6061 +/* 4247 */ MCD_OPC_CheckField, 0, 7, 123, 15, 7, 0, // Skip to: 6061 +/* 4254 */ MCD_OPC_Decode, 193, 89, 59, // Opcode: CV_AND_SC_B +/* 4258 */ MCD_OPC_FilterValue, 6, 17, 0, 0, // Skip to: 4280 +/* 4263 */ MCD_OPC_CheckPredicate, 105, 1, 7, 0, // Skip to: 6061 +/* 4268 */ MCD_OPC_CheckField, 0, 7, 123, 250, 6, 0, // Skip to: 6061 +/* 4275 */ MCD_OPC_Decode, 192, 89, 167, 1, // Opcode: CV_AND_SCI_H +/* 4280 */ MCD_OPC_FilterValue, 7, 240, 6, 0, // Skip to: 6061 +/* 4285 */ MCD_OPC_CheckPredicate, 105, 235, 6, 0, // Skip to: 6061 +/* 4290 */ MCD_OPC_CheckField, 0, 7, 123, 228, 6, 0, // Skip to: 6061 +/* 4297 */ MCD_OPC_Decode, 191, 89, 167, 1, // Opcode: CV_AND_SCI_B +/* 4302 */ MCD_OPC_FilterValue, 27, 87, 0, 0, // Skip to: 4394 +/* 4307 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 4310 */ MCD_OPC_FilterValue, 2, 23, 0, 0, // Skip to: 4338 +/* 4315 */ MCD_OPC_CheckPredicate, 105, 205, 6, 0, // Skip to: 6061 +/* 4320 */ MCD_OPC_CheckField, 25, 1, 0, 198, 6, 0, // Skip to: 6061 +/* 4327 */ MCD_OPC_CheckField, 0, 7, 123, 191, 6, 0, // Skip to: 6061 +/* 4334 */ MCD_OPC_Decode, 181, 89, 59, // Opcode: CV_ADD_DIV2 +/* 4338 */ MCD_OPC_FilterValue, 4, 23, 0, 0, // Skip to: 4366 +/* 4343 */ MCD_OPC_CheckPredicate, 105, 177, 6, 0, // Skip to: 6061 +/* 4348 */ MCD_OPC_CheckField, 25, 1, 0, 170, 6, 0, // Skip to: 6061 +/* 4355 */ MCD_OPC_CheckField, 0, 7, 123, 163, 6, 0, // Skip to: 6061 +/* 4362 */ MCD_OPC_Decode, 182, 89, 59, // Opcode: CV_ADD_DIV4 +/* 4366 */ MCD_OPC_FilterValue, 6, 154, 6, 0, // Skip to: 6061 +/* 4371 */ MCD_OPC_CheckPredicate, 105, 149, 6, 0, // Skip to: 6061 +/* 4376 */ MCD_OPC_CheckField, 25, 1, 0, 142, 6, 0, // Skip to: 6061 +/* 4383 */ MCD_OPC_CheckField, 0, 7, 123, 135, 6, 0, // Skip to: 6061 +/* 4390 */ MCD_OPC_Decode, 183, 89, 59, // Opcode: CV_ADD_DIV8 +/* 4394 */ MCD_OPC_FilterValue, 28, 59, 0, 0, // Skip to: 4458 +/* 4399 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 4402 */ MCD_OPC_FilterValue, 0, 23, 0, 0, // Skip to: 4430 +/* 4407 */ MCD_OPC_CheckPredicate, 105, 113, 6, 0, // Skip to: 6061 +/* 4412 */ MCD_OPC_CheckField, 20, 6, 0, 106, 6, 0, // Skip to: 6061 +/* 4419 */ MCD_OPC_CheckField, 0, 7, 123, 99, 6, 0, // Skip to: 6061 +/* 4426 */ MCD_OPC_Decode, 171, 89, 49, // Opcode: CV_ABS_H +/* 4430 */ MCD_OPC_FilterValue, 1, 90, 6, 0, // Skip to: 6061 +/* 4435 */ MCD_OPC_CheckPredicate, 105, 85, 6, 0, // Skip to: 6061 +/* 4440 */ MCD_OPC_CheckField, 20, 6, 0, 78, 6, 0, // Skip to: 6061 +/* 4447 */ MCD_OPC_CheckField, 0, 7, 123, 71, 6, 0, // Skip to: 6061 +/* 4454 */ MCD_OPC_Decode, 170, 89, 49, // Opcode: CV_ABS_B +/* 4458 */ MCD_OPC_FilterValue, 29, 87, 0, 0, // Skip to: 4550 +/* 4463 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 4466 */ MCD_OPC_FilterValue, 2, 23, 0, 0, // Skip to: 4494 +/* 4471 */ MCD_OPC_CheckPredicate, 105, 49, 6, 0, // Skip to: 6061 +/* 4476 */ MCD_OPC_CheckField, 25, 1, 0, 42, 6, 0, // Skip to: 6061 +/* 4483 */ MCD_OPC_CheckField, 0, 7, 123, 35, 6, 0, // Skip to: 6061 +/* 4490 */ MCD_OPC_Decode, 208, 91, 59, // Opcode: CV_SUB_DIV2 +/* 4494 */ MCD_OPC_FilterValue, 4, 23, 0, 0, // Skip to: 4522 +/* 4499 */ MCD_OPC_CheckPredicate, 105, 21, 6, 0, // Skip to: 6061 +/* 4504 */ MCD_OPC_CheckField, 25, 1, 0, 14, 6, 0, // Skip to: 6061 +/* 4511 */ MCD_OPC_CheckField, 0, 7, 123, 7, 6, 0, // Skip to: 6061 +/* 4518 */ MCD_OPC_Decode, 209, 91, 59, // Opcode: CV_SUB_DIV4 +/* 4522 */ MCD_OPC_FilterValue, 6, 254, 5, 0, // Skip to: 6061 +/* 4527 */ MCD_OPC_CheckPredicate, 105, 249, 5, 0, // Skip to: 6061 +/* 4532 */ MCD_OPC_CheckField, 25, 1, 0, 242, 5, 0, // Skip to: 6061 +/* 4539 */ MCD_OPC_CheckField, 0, 7, 123, 235, 5, 0, // Skip to: 6061 +/* 4546 */ MCD_OPC_Decode, 210, 91, 59, // Opcode: CV_SUB_DIV8 +/* 4550 */ MCD_OPC_FilterValue, 32, 159, 0, 0, // Skip to: 4714 +/* 4555 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 4558 */ MCD_OPC_FilterValue, 0, 23, 0, 0, // Skip to: 4586 +/* 4563 */ MCD_OPC_CheckPredicate, 105, 213, 5, 0, // Skip to: 6061 +/* 4568 */ MCD_OPC_CheckField, 25, 1, 0, 206, 5, 0, // Skip to: 6061 +/* 4575 */ MCD_OPC_CheckField, 0, 7, 123, 199, 5, 0, // Skip to: 6061 +/* 4582 */ MCD_OPC_Decode, 168, 90, 59, // Opcode: CV_DOTUP_H +/* 4586 */ MCD_OPC_FilterValue, 1, 23, 0, 0, // Skip to: 4614 +/* 4591 */ MCD_OPC_CheckPredicate, 105, 185, 5, 0, // Skip to: 6061 +/* 4596 */ MCD_OPC_CheckField, 25, 1, 0, 178, 5, 0, // Skip to: 6061 +/* 4603 */ MCD_OPC_CheckField, 0, 7, 123, 171, 5, 0, // Skip to: 6061 +/* 4610 */ MCD_OPC_Decode, 167, 90, 59, // Opcode: CV_DOTUP_B +/* 4614 */ MCD_OPC_FilterValue, 4, 23, 0, 0, // Skip to: 4642 +/* 4619 */ MCD_OPC_CheckPredicate, 105, 157, 5, 0, // Skip to: 6061 +/* 4624 */ MCD_OPC_CheckField, 25, 1, 0, 150, 5, 0, // Skip to: 6061 +/* 4631 */ MCD_OPC_CheckField, 0, 7, 123, 143, 5, 0, // Skip to: 6061 +/* 4638 */ MCD_OPC_Decode, 172, 90, 59, // Opcode: CV_DOTUP_SC_H +/* 4642 */ MCD_OPC_FilterValue, 5, 23, 0, 0, // Skip to: 4670 +/* 4647 */ MCD_OPC_CheckPredicate, 105, 129, 5, 0, // Skip to: 6061 +/* 4652 */ MCD_OPC_CheckField, 25, 1, 0, 122, 5, 0, // Skip to: 6061 +/* 4659 */ MCD_OPC_CheckField, 0, 7, 123, 115, 5, 0, // Skip to: 6061 +/* 4666 */ MCD_OPC_Decode, 171, 90, 59, // Opcode: CV_DOTUP_SC_B +/* 4670 */ MCD_OPC_FilterValue, 6, 17, 0, 0, // Skip to: 4692 +/* 4675 */ MCD_OPC_CheckPredicate, 105, 101, 5, 0, // Skip to: 6061 +/* 4680 */ MCD_OPC_CheckField, 0, 7, 123, 94, 5, 0, // Skip to: 6061 +/* 4687 */ MCD_OPC_Decode, 170, 90, 168, 1, // Opcode: CV_DOTUP_SCI_H +/* 4692 */ MCD_OPC_FilterValue, 7, 84, 5, 0, // Skip to: 6061 +/* 4697 */ MCD_OPC_CheckPredicate, 105, 79, 5, 0, // Skip to: 6061 +/* 4702 */ MCD_OPC_CheckField, 0, 7, 123, 72, 5, 0, // Skip to: 6061 +/* 4709 */ MCD_OPC_Decode, 169, 90, 168, 1, // Opcode: CV_DOTUP_SCI_B +/* 4714 */ MCD_OPC_FilterValue, 34, 159, 0, 0, // Skip to: 4878 +/* 4719 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 4722 */ MCD_OPC_FilterValue, 0, 23, 0, 0, // Skip to: 4750 +/* 4727 */ MCD_OPC_CheckPredicate, 105, 49, 5, 0, // Skip to: 6061 +/* 4732 */ MCD_OPC_CheckField, 25, 1, 0, 42, 5, 0, // Skip to: 6061 +/* 4739 */ MCD_OPC_CheckField, 0, 7, 123, 35, 5, 0, // Skip to: 6061 +/* 4746 */ MCD_OPC_Decode, 174, 90, 59, // Opcode: CV_DOTUSP_H +/* 4750 */ MCD_OPC_FilterValue, 1, 23, 0, 0, // Skip to: 4778 +/* 4755 */ MCD_OPC_CheckPredicate, 105, 21, 5, 0, // Skip to: 6061 +/* 4760 */ MCD_OPC_CheckField, 25, 1, 0, 14, 5, 0, // Skip to: 6061 +/* 4767 */ MCD_OPC_CheckField, 0, 7, 123, 7, 5, 0, // Skip to: 6061 +/* 4774 */ MCD_OPC_Decode, 173, 90, 59, // Opcode: CV_DOTUSP_B +/* 4778 */ MCD_OPC_FilterValue, 4, 23, 0, 0, // Skip to: 4806 +/* 4783 */ MCD_OPC_CheckPredicate, 105, 249, 4, 0, // Skip to: 6061 +/* 4788 */ MCD_OPC_CheckField, 25, 1, 0, 242, 4, 0, // Skip to: 6061 +/* 4795 */ MCD_OPC_CheckField, 0, 7, 123, 235, 4, 0, // Skip to: 6061 +/* 4802 */ MCD_OPC_Decode, 178, 90, 59, // Opcode: CV_DOTUSP_SC_H +/* 4806 */ MCD_OPC_FilterValue, 5, 23, 0, 0, // Skip to: 4834 +/* 4811 */ MCD_OPC_CheckPredicate, 105, 221, 4, 0, // Skip to: 6061 +/* 4816 */ MCD_OPC_CheckField, 25, 1, 0, 214, 4, 0, // Skip to: 6061 +/* 4823 */ MCD_OPC_CheckField, 0, 7, 123, 207, 4, 0, // Skip to: 6061 +/* 4830 */ MCD_OPC_Decode, 177, 90, 59, // Opcode: CV_DOTUSP_SC_B +/* 4834 */ MCD_OPC_FilterValue, 6, 17, 0, 0, // Skip to: 4856 +/* 4839 */ MCD_OPC_CheckPredicate, 105, 193, 4, 0, // Skip to: 6061 +/* 4844 */ MCD_OPC_CheckField, 0, 7, 123, 186, 4, 0, // Skip to: 6061 +/* 4851 */ MCD_OPC_Decode, 176, 90, 167, 1, // Opcode: CV_DOTUSP_SCI_H +/* 4856 */ MCD_OPC_FilterValue, 7, 176, 4, 0, // Skip to: 6061 +/* 4861 */ MCD_OPC_CheckPredicate, 105, 171, 4, 0, // Skip to: 6061 +/* 4866 */ MCD_OPC_CheckField, 0, 7, 123, 164, 4, 0, // Skip to: 6061 +/* 4873 */ MCD_OPC_Decode, 175, 90, 167, 1, // Opcode: CV_DOTUSP_SCI_B +/* 4878 */ MCD_OPC_FilterValue, 36, 159, 0, 0, // Skip to: 5042 +/* 4883 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 4886 */ MCD_OPC_FilterValue, 0, 23, 0, 0, // Skip to: 4914 +/* 4891 */ MCD_OPC_CheckPredicate, 105, 141, 4, 0, // Skip to: 6061 +/* 4896 */ MCD_OPC_CheckField, 25, 1, 0, 134, 4, 0, // Skip to: 6061 +/* 4903 */ MCD_OPC_CheckField, 0, 7, 123, 127, 4, 0, // Skip to: 6061 +/* 4910 */ MCD_OPC_Decode, 162, 90, 59, // Opcode: CV_DOTSP_H +/* 4914 */ MCD_OPC_FilterValue, 1, 23, 0, 0, // Skip to: 4942 +/* 4919 */ MCD_OPC_CheckPredicate, 105, 113, 4, 0, // Skip to: 6061 +/* 4924 */ MCD_OPC_CheckField, 25, 1, 0, 106, 4, 0, // Skip to: 6061 +/* 4931 */ MCD_OPC_CheckField, 0, 7, 123, 99, 4, 0, // Skip to: 6061 +/* 4938 */ MCD_OPC_Decode, 161, 90, 59, // Opcode: CV_DOTSP_B +/* 4942 */ MCD_OPC_FilterValue, 4, 23, 0, 0, // Skip to: 4970 +/* 4947 */ MCD_OPC_CheckPredicate, 105, 85, 4, 0, // Skip to: 6061 +/* 4952 */ MCD_OPC_CheckField, 25, 1, 0, 78, 4, 0, // Skip to: 6061 +/* 4959 */ MCD_OPC_CheckField, 0, 7, 123, 71, 4, 0, // Skip to: 6061 +/* 4966 */ MCD_OPC_Decode, 166, 90, 59, // Opcode: CV_DOTSP_SC_H +/* 4970 */ MCD_OPC_FilterValue, 5, 23, 0, 0, // Skip to: 4998 +/* 4975 */ MCD_OPC_CheckPredicate, 105, 57, 4, 0, // Skip to: 6061 +/* 4980 */ MCD_OPC_CheckField, 25, 1, 0, 50, 4, 0, // Skip to: 6061 +/* 4987 */ MCD_OPC_CheckField, 0, 7, 123, 43, 4, 0, // Skip to: 6061 +/* 4994 */ MCD_OPC_Decode, 165, 90, 59, // Opcode: CV_DOTSP_SC_B +/* 4998 */ MCD_OPC_FilterValue, 6, 17, 0, 0, // Skip to: 5020 +/* 5003 */ MCD_OPC_CheckPredicate, 105, 29, 4, 0, // Skip to: 6061 +/* 5008 */ MCD_OPC_CheckField, 0, 7, 123, 22, 4, 0, // Skip to: 6061 +/* 5015 */ MCD_OPC_Decode, 164, 90, 167, 1, // Opcode: CV_DOTSP_SCI_H +/* 5020 */ MCD_OPC_FilterValue, 7, 12, 4, 0, // Skip to: 6061 +/* 5025 */ MCD_OPC_CheckPredicate, 105, 7, 4, 0, // Skip to: 6061 +/* 5030 */ MCD_OPC_CheckField, 0, 7, 123, 0, 4, 0, // Skip to: 6061 +/* 5037 */ MCD_OPC_Decode, 163, 90, 167, 1, // Opcode: CV_DOTSP_SCI_B +/* 5042 */ MCD_OPC_FilterValue, 38, 159, 0, 0, // Skip to: 5206 +/* 5047 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 5050 */ MCD_OPC_FilterValue, 0, 23, 0, 0, // Skip to: 5078 +/* 5055 */ MCD_OPC_CheckPredicate, 105, 233, 3, 0, // Skip to: 6061 +/* 5060 */ MCD_OPC_CheckField, 25, 1, 0, 226, 3, 0, // Skip to: 6061 +/* 5067 */ MCD_OPC_CheckField, 0, 7, 123, 219, 3, 0, // Skip to: 6061 +/* 5074 */ MCD_OPC_Decode, 152, 91, 58, // Opcode: CV_SDOTUP_H +/* 5078 */ MCD_OPC_FilterValue, 1, 23, 0, 0, // Skip to: 5106 +/* 5083 */ MCD_OPC_CheckPredicate, 105, 205, 3, 0, // Skip to: 6061 +/* 5088 */ MCD_OPC_CheckField, 25, 1, 0, 198, 3, 0, // Skip to: 6061 +/* 5095 */ MCD_OPC_CheckField, 0, 7, 123, 191, 3, 0, // Skip to: 6061 +/* 5102 */ MCD_OPC_Decode, 151, 91, 58, // Opcode: CV_SDOTUP_B +/* 5106 */ MCD_OPC_FilterValue, 4, 23, 0, 0, // Skip to: 5134 +/* 5111 */ MCD_OPC_CheckPredicate, 105, 177, 3, 0, // Skip to: 6061 +/* 5116 */ MCD_OPC_CheckField, 25, 1, 0, 170, 3, 0, // Skip to: 6061 +/* 5123 */ MCD_OPC_CheckField, 0, 7, 123, 163, 3, 0, // Skip to: 6061 +/* 5130 */ MCD_OPC_Decode, 156, 91, 58, // Opcode: CV_SDOTUP_SC_H +/* 5134 */ MCD_OPC_FilterValue, 5, 23, 0, 0, // Skip to: 5162 +/* 5139 */ MCD_OPC_CheckPredicate, 105, 149, 3, 0, // Skip to: 6061 +/* 5144 */ MCD_OPC_CheckField, 25, 1, 0, 142, 3, 0, // Skip to: 6061 +/* 5151 */ MCD_OPC_CheckField, 0, 7, 123, 135, 3, 0, // Skip to: 6061 +/* 5158 */ MCD_OPC_Decode, 155, 91, 58, // Opcode: CV_SDOTUP_SC_B +/* 5162 */ MCD_OPC_FilterValue, 6, 17, 0, 0, // Skip to: 5184 +/* 5167 */ MCD_OPC_CheckPredicate, 105, 121, 3, 0, // Skip to: 6061 +/* 5172 */ MCD_OPC_CheckField, 0, 7, 123, 114, 3, 0, // Skip to: 6061 +/* 5179 */ MCD_OPC_Decode, 154, 91, 171, 1, // Opcode: CV_SDOTUP_SCI_H +/* 5184 */ MCD_OPC_FilterValue, 7, 104, 3, 0, // Skip to: 6061 +/* 5189 */ MCD_OPC_CheckPredicate, 105, 99, 3, 0, // Skip to: 6061 +/* 5194 */ MCD_OPC_CheckField, 0, 7, 123, 92, 3, 0, // Skip to: 6061 +/* 5201 */ MCD_OPC_Decode, 153, 91, 171, 1, // Opcode: CV_SDOTUP_SCI_B +/* 5206 */ MCD_OPC_FilterValue, 40, 159, 0, 0, // Skip to: 5370 +/* 5211 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 5214 */ MCD_OPC_FilterValue, 0, 23, 0, 0, // Skip to: 5242 +/* 5219 */ MCD_OPC_CheckPredicate, 105, 69, 3, 0, // Skip to: 6061 +/* 5224 */ MCD_OPC_CheckField, 25, 1, 0, 62, 3, 0, // Skip to: 6061 +/* 5231 */ MCD_OPC_CheckField, 0, 7, 123, 55, 3, 0, // Skip to: 6061 +/* 5238 */ MCD_OPC_Decode, 158, 91, 58, // Opcode: CV_SDOTUSP_H +/* 5242 */ MCD_OPC_FilterValue, 1, 23, 0, 0, // Skip to: 5270 +/* 5247 */ MCD_OPC_CheckPredicate, 105, 41, 3, 0, // Skip to: 6061 +/* 5252 */ MCD_OPC_CheckField, 25, 1, 0, 34, 3, 0, // Skip to: 6061 +/* 5259 */ MCD_OPC_CheckField, 0, 7, 123, 27, 3, 0, // Skip to: 6061 +/* 5266 */ MCD_OPC_Decode, 157, 91, 58, // Opcode: CV_SDOTUSP_B +/* 5270 */ MCD_OPC_FilterValue, 4, 23, 0, 0, // Skip to: 5298 +/* 5275 */ MCD_OPC_CheckPredicate, 105, 13, 3, 0, // Skip to: 6061 +/* 5280 */ MCD_OPC_CheckField, 25, 1, 0, 6, 3, 0, // Skip to: 6061 +/* 5287 */ MCD_OPC_CheckField, 0, 7, 123, 255, 2, 0, // Skip to: 6061 +/* 5294 */ MCD_OPC_Decode, 162, 91, 58, // Opcode: CV_SDOTUSP_SC_H +/* 5298 */ MCD_OPC_FilterValue, 5, 23, 0, 0, // Skip to: 5326 +/* 5303 */ MCD_OPC_CheckPredicate, 105, 241, 2, 0, // Skip to: 6061 +/* 5308 */ MCD_OPC_CheckField, 25, 1, 0, 234, 2, 0, // Skip to: 6061 +/* 5315 */ MCD_OPC_CheckField, 0, 7, 123, 227, 2, 0, // Skip to: 6061 +/* 5322 */ MCD_OPC_Decode, 161, 91, 58, // Opcode: CV_SDOTUSP_SC_B +/* 5326 */ MCD_OPC_FilterValue, 6, 17, 0, 0, // Skip to: 5348 +/* 5331 */ MCD_OPC_CheckPredicate, 105, 213, 2, 0, // Skip to: 6061 +/* 5336 */ MCD_OPC_CheckField, 0, 7, 123, 206, 2, 0, // Skip to: 6061 +/* 5343 */ MCD_OPC_Decode, 160, 91, 172, 1, // Opcode: CV_SDOTUSP_SCI_H +/* 5348 */ MCD_OPC_FilterValue, 7, 196, 2, 0, // Skip to: 6061 +/* 5353 */ MCD_OPC_CheckPredicate, 105, 191, 2, 0, // Skip to: 6061 +/* 5358 */ MCD_OPC_CheckField, 0, 7, 123, 184, 2, 0, // Skip to: 6061 +/* 5365 */ MCD_OPC_Decode, 159, 91, 172, 1, // Opcode: CV_SDOTUSP_SCI_B +/* 5370 */ MCD_OPC_FilterValue, 42, 159, 0, 0, // Skip to: 5534 +/* 5375 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 5378 */ MCD_OPC_FilterValue, 0, 23, 0, 0, // Skip to: 5406 +/* 5383 */ MCD_OPC_CheckPredicate, 105, 161, 2, 0, // Skip to: 6061 +/* 5388 */ MCD_OPC_CheckField, 25, 1, 0, 154, 2, 0, // Skip to: 6061 +/* 5395 */ MCD_OPC_CheckField, 0, 7, 123, 147, 2, 0, // Skip to: 6061 +/* 5402 */ MCD_OPC_Decode, 146, 91, 58, // Opcode: CV_SDOTSP_H +/* 5406 */ MCD_OPC_FilterValue, 1, 23, 0, 0, // Skip to: 5434 +/* 5411 */ MCD_OPC_CheckPredicate, 105, 133, 2, 0, // Skip to: 6061 +/* 5416 */ MCD_OPC_CheckField, 25, 1, 0, 126, 2, 0, // Skip to: 6061 +/* 5423 */ MCD_OPC_CheckField, 0, 7, 123, 119, 2, 0, // Skip to: 6061 +/* 5430 */ MCD_OPC_Decode, 145, 91, 58, // Opcode: CV_SDOTSP_B +/* 5434 */ MCD_OPC_FilterValue, 4, 23, 0, 0, // Skip to: 5462 +/* 5439 */ MCD_OPC_CheckPredicate, 105, 105, 2, 0, // Skip to: 6061 +/* 5444 */ MCD_OPC_CheckField, 25, 1, 0, 98, 2, 0, // Skip to: 6061 +/* 5451 */ MCD_OPC_CheckField, 0, 7, 123, 91, 2, 0, // Skip to: 6061 +/* 5458 */ MCD_OPC_Decode, 150, 91, 58, // Opcode: CV_SDOTSP_SC_H +/* 5462 */ MCD_OPC_FilterValue, 5, 23, 0, 0, // Skip to: 5490 +/* 5467 */ MCD_OPC_CheckPredicate, 105, 77, 2, 0, // Skip to: 6061 +/* 5472 */ MCD_OPC_CheckField, 25, 1, 0, 70, 2, 0, // Skip to: 6061 +/* 5479 */ MCD_OPC_CheckField, 0, 7, 123, 63, 2, 0, // Skip to: 6061 +/* 5486 */ MCD_OPC_Decode, 149, 91, 58, // Opcode: CV_SDOTSP_SC_B +/* 5490 */ MCD_OPC_FilterValue, 6, 17, 0, 0, // Skip to: 5512 +/* 5495 */ MCD_OPC_CheckPredicate, 105, 49, 2, 0, // Skip to: 6061 +/* 5500 */ MCD_OPC_CheckField, 0, 7, 123, 42, 2, 0, // Skip to: 6061 +/* 5507 */ MCD_OPC_Decode, 148, 91, 172, 1, // Opcode: CV_SDOTSP_SCI_H +/* 5512 */ MCD_OPC_FilterValue, 7, 32, 2, 0, // Skip to: 6061 +/* 5517 */ MCD_OPC_CheckPredicate, 105, 27, 2, 0, // Skip to: 6061 +/* 5522 */ MCD_OPC_CheckField, 0, 7, 123, 20, 2, 0, // Skip to: 6061 +/* 5529 */ MCD_OPC_Decode, 147, 91, 172, 1, // Opcode: CV_SDOTSP_SCI_B +/* 5534 */ MCD_OPC_FilterValue, 46, 135, 0, 0, // Skip to: 5674 +/* 5539 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 5542 */ MCD_OPC_FilterValue, 0, 17, 0, 0, // Skip to: 5564 +/* 5547 */ MCD_OPC_CheckPredicate, 105, 253, 1, 0, // Skip to: 6061 +/* 5552 */ MCD_OPC_CheckField, 0, 7, 123, 246, 1, 0, // Skip to: 6061 +/* 5559 */ MCD_OPC_Decode, 191, 90, 168, 1, // Opcode: CV_EXTRACT_H +/* 5564 */ MCD_OPC_FilterValue, 1, 17, 0, 0, // Skip to: 5586 +/* 5569 */ MCD_OPC_CheckPredicate, 105, 231, 1, 0, // Skip to: 6061 +/* 5574 */ MCD_OPC_CheckField, 0, 7, 123, 224, 1, 0, // Skip to: 6061 +/* 5581 */ MCD_OPC_Decode, 190, 90, 168, 1, // Opcode: CV_EXTRACT_B +/* 5586 */ MCD_OPC_FilterValue, 2, 17, 0, 0, // Skip to: 5608 +/* 5591 */ MCD_OPC_CheckPredicate, 105, 209, 1, 0, // Skip to: 6061 +/* 5596 */ MCD_OPC_CheckField, 0, 7, 123, 202, 1, 0, // Skip to: 6061 +/* 5603 */ MCD_OPC_Decode, 189, 90, 168, 1, // Opcode: CV_EXTRACTU_H +/* 5608 */ MCD_OPC_FilterValue, 3, 17, 0, 0, // Skip to: 5630 +/* 5613 */ MCD_OPC_CheckPredicate, 105, 187, 1, 0, // Skip to: 6061 +/* 5618 */ MCD_OPC_CheckField, 0, 7, 123, 180, 1, 0, // Skip to: 6061 +/* 5625 */ MCD_OPC_Decode, 188, 90, 168, 1, // Opcode: CV_EXTRACTU_B +/* 5630 */ MCD_OPC_FilterValue, 4, 17, 0, 0, // Skip to: 5652 +/* 5635 */ MCD_OPC_CheckPredicate, 105, 165, 1, 0, // Skip to: 6061 +/* 5640 */ MCD_OPC_CheckField, 0, 7, 123, 158, 1, 0, // Skip to: 6061 +/* 5647 */ MCD_OPC_Decode, 197, 90, 171, 1, // Opcode: CV_INSERT_H +/* 5652 */ MCD_OPC_FilterValue, 5, 148, 1, 0, // Skip to: 6061 +/* 5657 */ MCD_OPC_CheckPredicate, 105, 143, 1, 0, // Skip to: 6061 +/* 5662 */ MCD_OPC_CheckField, 0, 7, 123, 136, 1, 0, // Skip to: 6061 +/* 5669 */ MCD_OPC_Decode, 196, 90, 171, 1, // Opcode: CV_INSERT_B +/* 5674 */ MCD_OPC_FilterValue, 48, 103, 0, 0, // Skip to: 5782 +/* 5679 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 5682 */ MCD_OPC_FilterValue, 0, 23, 0, 0, // Skip to: 5710 +/* 5687 */ MCD_OPC_CheckPredicate, 105, 113, 1, 0, // Skip to: 6061 +/* 5692 */ MCD_OPC_CheckField, 25, 1, 0, 106, 1, 0, // Skip to: 6061 +/* 5699 */ MCD_OPC_CheckField, 0, 7, 123, 99, 1, 0, // Skip to: 6061 +/* 5706 */ MCD_OPC_Decode, 170, 91, 59, // Opcode: CV_SHUFFLE_H +/* 5710 */ MCD_OPC_FilterValue, 1, 23, 0, 0, // Skip to: 5738 +/* 5715 */ MCD_OPC_CheckPredicate, 105, 85, 1, 0, // Skip to: 6061 +/* 5720 */ MCD_OPC_CheckField, 25, 1, 0, 78, 1, 0, // Skip to: 6061 +/* 5727 */ MCD_OPC_CheckField, 0, 7, 123, 71, 1, 0, // Skip to: 6061 +/* 5734 */ MCD_OPC_Decode, 169, 91, 59, // Opcode: CV_SHUFFLE_B +/* 5738 */ MCD_OPC_FilterValue, 6, 17, 0, 0, // Skip to: 5760 +/* 5743 */ MCD_OPC_CheckPredicate, 105, 57, 1, 0, // Skip to: 6061 +/* 5748 */ MCD_OPC_CheckField, 0, 7, 123, 50, 1, 0, // Skip to: 6061 +/* 5755 */ MCD_OPC_Decode, 171, 91, 168, 1, // Opcode: CV_SHUFFLE_SCI_H +/* 5760 */ MCD_OPC_FilterValue, 7, 40, 1, 0, // Skip to: 6061 +/* 5765 */ MCD_OPC_CheckPredicate, 105, 35, 1, 0, // Skip to: 6061 +/* 5770 */ MCD_OPC_CheckField, 0, 7, 123, 28, 1, 0, // Skip to: 6061 +/* 5777 */ MCD_OPC_Decode, 165, 91, 168, 1, // Opcode: CV_SHUFFLEI0_SCI_B +/* 5782 */ MCD_OPC_FilterValue, 50, 24, 0, 0, // Skip to: 5811 +/* 5787 */ MCD_OPC_CheckPredicate, 105, 13, 1, 0, // Skip to: 6061 +/* 5792 */ MCD_OPC_CheckField, 12, 3, 7, 6, 1, 0, // Skip to: 6061 +/* 5799 */ MCD_OPC_CheckField, 0, 7, 123, 255, 0, 0, // Skip to: 6061 +/* 5806 */ MCD_OPC_Decode, 166, 91, 168, 1, // Opcode: CV_SHUFFLEI1_SCI_B +/* 5811 */ MCD_OPC_FilterValue, 52, 24, 0, 0, // Skip to: 5840 +/* 5816 */ MCD_OPC_CheckPredicate, 105, 240, 0, 0, // Skip to: 6061 +/* 5821 */ MCD_OPC_CheckField, 12, 3, 7, 233, 0, 0, // Skip to: 6061 +/* 5828 */ MCD_OPC_CheckField, 0, 7, 123, 226, 0, 0, // Skip to: 6061 +/* 5835 */ MCD_OPC_Decode, 167, 91, 168, 1, // Opcode: CV_SHUFFLEI2_SCI_B +/* 5840 */ MCD_OPC_FilterValue, 54, 24, 0, 0, // Skip to: 5869 +/* 5845 */ MCD_OPC_CheckPredicate, 105, 211, 0, 0, // Skip to: 6061 +/* 5850 */ MCD_OPC_CheckField, 12, 3, 7, 204, 0, 0, // Skip to: 6061 +/* 5857 */ MCD_OPC_CheckField, 0, 7, 123, 197, 0, 0, // Skip to: 6061 +/* 5864 */ MCD_OPC_Decode, 168, 91, 168, 1, // Opcode: CV_SHUFFLEI3_SCI_B +/* 5869 */ MCD_OPC_FilterValue, 56, 59, 0, 0, // Skip to: 5933 +/* 5874 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 5877 */ MCD_OPC_FilterValue, 0, 23, 0, 0, // Skip to: 5905 +/* 5882 */ MCD_OPC_CheckPredicate, 105, 174, 0, 0, // Skip to: 6061 +/* 5887 */ MCD_OPC_CheckField, 25, 1, 0, 167, 0, 0, // Skip to: 6061 +/* 5894 */ MCD_OPC_CheckField, 0, 7, 123, 160, 0, 0, // Skip to: 6061 +/* 5901 */ MCD_OPC_Decode, 164, 91, 58, // Opcode: CV_SHUFFLE2_H +/* 5905 */ MCD_OPC_FilterValue, 1, 151, 0, 0, // Skip to: 6061 +/* 5910 */ MCD_OPC_CheckPredicate, 105, 146, 0, 0, // Skip to: 6061 +/* 5915 */ MCD_OPC_CheckField, 25, 1, 0, 139, 0, 0, // Skip to: 6061 +/* 5922 */ MCD_OPC_CheckField, 0, 7, 123, 132, 0, 0, // Skip to: 6061 +/* 5929 */ MCD_OPC_Decode, 163, 91, 58, // Opcode: CV_SHUFFLE2_B +/* 5933 */ MCD_OPC_FilterValue, 60, 59, 0, 0, // Skip to: 5997 +/* 5938 */ MCD_OPC_ExtractField, 25, 1, // Inst{25} ... +/* 5941 */ MCD_OPC_FilterValue, 0, 23, 0, 0, // Skip to: 5969 +/* 5946 */ MCD_OPC_CheckPredicate, 105, 110, 0, 0, // Skip to: 6061 +/* 5951 */ MCD_OPC_CheckField, 12, 3, 0, 103, 0, 0, // Skip to: 6061 +/* 5958 */ MCD_OPC_CheckField, 0, 7, 123, 96, 0, 0, // Skip to: 6061 +/* 5965 */ MCD_OPC_Decode, 137, 91, 59, // Opcode: CV_PACK +/* 5969 */ MCD_OPC_FilterValue, 1, 87, 0, 0, // Skip to: 6061 +/* 5974 */ MCD_OPC_CheckPredicate, 105, 82, 0, 0, // Skip to: 6061 +/* 5979 */ MCD_OPC_CheckField, 12, 3, 0, 75, 0, 0, // Skip to: 6061 +/* 5986 */ MCD_OPC_CheckField, 0, 7, 123, 68, 0, 0, // Skip to: 6061 +/* 5993 */ MCD_OPC_Decode, 140, 91, 59, // Opcode: CV_PACK_H +/* 5997 */ MCD_OPC_FilterValue, 62, 59, 0, 0, // Skip to: 6061 +/* 6002 */ MCD_OPC_ExtractField, 25, 1, // Inst{25} ... +/* 6005 */ MCD_OPC_FilterValue, 0, 23, 0, 0, // Skip to: 6033 +/* 6010 */ MCD_OPC_CheckPredicate, 105, 46, 0, 0, // Skip to: 6061 +/* 6015 */ MCD_OPC_CheckField, 12, 3, 1, 39, 0, 0, // Skip to: 6061 +/* 6022 */ MCD_OPC_CheckField, 0, 7, 123, 32, 0, 0, // Skip to: 6061 +/* 6029 */ MCD_OPC_Decode, 139, 91, 58, // Opcode: CV_PACKLO_B +/* 6033 */ MCD_OPC_FilterValue, 1, 23, 0, 0, // Skip to: 6061 +/* 6038 */ MCD_OPC_CheckPredicate, 105, 18, 0, 0, // Skip to: 6061 +/* 6043 */ MCD_OPC_CheckField, 12, 3, 1, 11, 0, 0, // Skip to: 6061 +/* 6050 */ MCD_OPC_CheckField, 0, 7, 123, 4, 0, 0, // Skip to: 6061 +/* 6057 */ MCD_OPC_Decode, 138, 91, 58, // Opcode: CV_PACKHI_B +/* 6061 */ MCD_OPC_Fail, + 0 +}; + +static const uint8_t DecoderTableXSfvcp32[] = { +/* 0 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 3 */ MCD_OPC_FilterValue, 0, 159, 0, 0, // Skip to: 167 +/* 8 */ MCD_OPC_ExtractField, 28, 4, // Inst{31-28} ... +/* 11 */ MCD_OPC_FilterValue, 2, 47, 0, 0, // Skip to: 63 +/* 16 */ MCD_OPC_ExtractField, 25, 1, // Inst{25} ... +/* 19 */ MCD_OPC_FilterValue, 0, 17, 0, 0, // Skip to: 41 +/* 24 */ MCD_OPC_CheckPredicate, 106, 222, 2, 0, // Skip to: 763 +/* 29 */ MCD_OPC_CheckField, 0, 7, 91, 215, 2, 0, // Skip to: 763 +/* 36 */ MCD_OPC_Decode, 136, 97, 173, 1, // Opcode: VC_V_VV +/* 41 */ MCD_OPC_FilterValue, 1, 205, 2, 0, // Skip to: 763 +/* 46 */ MCD_OPC_CheckPredicate, 106, 200, 2, 0, // Skip to: 763 +/* 51 */ MCD_OPC_CheckField, 0, 7, 91, 193, 2, 0, // Skip to: 763 +/* 58 */ MCD_OPC_Decode, 254, 96, 174, 1, // Opcode: VC_VV +/* 63 */ MCD_OPC_FilterValue, 10, 47, 0, 0, // Skip to: 115 +/* 68 */ MCD_OPC_ExtractField, 25, 1, // Inst{25} ... +/* 71 */ MCD_OPC_FilterValue, 0, 17, 0, 0, // Skip to: 93 +/* 76 */ MCD_OPC_CheckPredicate, 106, 170, 2, 0, // Skip to: 763 +/* 81 */ MCD_OPC_CheckField, 0, 7, 91, 163, 2, 0, // Skip to: 763 +/* 88 */ MCD_OPC_Decode, 137, 97, 175, 1, // Opcode: VC_V_VVV +/* 93 */ MCD_OPC_FilterValue, 1, 153, 2, 0, // Skip to: 763 +/* 98 */ MCD_OPC_CheckPredicate, 106, 148, 2, 0, // Skip to: 763 +/* 103 */ MCD_OPC_CheckField, 0, 7, 91, 141, 2, 0, // Skip to: 763 +/* 110 */ MCD_OPC_Decode, 255, 96, 176, 1, // Opcode: VC_VVV +/* 115 */ MCD_OPC_FilterValue, 15, 131, 2, 0, // Skip to: 763 +/* 120 */ MCD_OPC_ExtractField, 25, 1, // Inst{25} ... +/* 123 */ MCD_OPC_FilterValue, 0, 17, 0, 0, // Skip to: 145 +/* 128 */ MCD_OPC_CheckPredicate, 106, 118, 2, 0, // Skip to: 763 +/* 133 */ MCD_OPC_CheckField, 0, 7, 91, 111, 2, 0, // Skip to: 763 +/* 140 */ MCD_OPC_Decode, 138, 97, 175, 1, // Opcode: VC_V_VVW +/* 145 */ MCD_OPC_FilterValue, 1, 101, 2, 0, // Skip to: 763 +/* 150 */ MCD_OPC_CheckPredicate, 106, 96, 2, 0, // Skip to: 763 +/* 155 */ MCD_OPC_CheckField, 0, 7, 91, 89, 2, 0, // Skip to: 763 +/* 162 */ MCD_OPC_Decode, 128, 97, 176, 1, // Opcode: VC_VVW +/* 167 */ MCD_OPC_FilterValue, 3, 211, 0, 0, // Skip to: 383 +/* 172 */ MCD_OPC_ExtractField, 28, 4, // Inst{31-28} ... +/* 175 */ MCD_OPC_FilterValue, 0, 47, 0, 0, // Skip to: 227 +/* 180 */ MCD_OPC_ExtractField, 25, 1, // Inst{25} ... +/* 183 */ MCD_OPC_FilterValue, 0, 17, 0, 0, // Skip to: 205 +/* 188 */ MCD_OPC_CheckPredicate, 106, 58, 2, 0, // Skip to: 763 +/* 193 */ MCD_OPC_CheckField, 0, 7, 91, 51, 2, 0, // Skip to: 763 +/* 200 */ MCD_OPC_Decode, 132, 97, 177, 1, // Opcode: VC_V_I +/* 205 */ MCD_OPC_FilterValue, 1, 41, 2, 0, // Skip to: 763 +/* 210 */ MCD_OPC_CheckPredicate, 106, 36, 2, 0, // Skip to: 763 +/* 215 */ MCD_OPC_CheckField, 0, 7, 91, 29, 2, 0, // Skip to: 763 +/* 222 */ MCD_OPC_Decode, 250, 96, 178, 1, // Opcode: VC_I +/* 227 */ MCD_OPC_FilterValue, 2, 47, 0, 0, // Skip to: 279 +/* 232 */ MCD_OPC_ExtractField, 25, 1, // Inst{25} ... +/* 235 */ MCD_OPC_FilterValue, 0, 17, 0, 0, // Skip to: 257 +/* 240 */ MCD_OPC_CheckPredicate, 106, 6, 2, 0, // Skip to: 763 +/* 245 */ MCD_OPC_CheckField, 0, 7, 91, 255, 1, 0, // Skip to: 763 +/* 252 */ MCD_OPC_Decode, 133, 97, 179, 1, // Opcode: VC_V_IV +/* 257 */ MCD_OPC_FilterValue, 1, 245, 1, 0, // Skip to: 763 +/* 262 */ MCD_OPC_CheckPredicate, 106, 240, 1, 0, // Skip to: 763 +/* 267 */ MCD_OPC_CheckField, 0, 7, 91, 233, 1, 0, // Skip to: 763 +/* 274 */ MCD_OPC_Decode, 251, 96, 180, 1, // Opcode: VC_IV +/* 279 */ MCD_OPC_FilterValue, 10, 47, 0, 0, // Skip to: 331 +/* 284 */ MCD_OPC_ExtractField, 25, 1, // Inst{25} ... +/* 287 */ MCD_OPC_FilterValue, 0, 17, 0, 0, // Skip to: 309 +/* 292 */ MCD_OPC_CheckPredicate, 106, 210, 1, 0, // Skip to: 763 +/* 297 */ MCD_OPC_CheckField, 0, 7, 91, 203, 1, 0, // Skip to: 763 +/* 304 */ MCD_OPC_Decode, 134, 97, 181, 1, // Opcode: VC_V_IVV +/* 309 */ MCD_OPC_FilterValue, 1, 193, 1, 0, // Skip to: 763 +/* 314 */ MCD_OPC_CheckPredicate, 106, 188, 1, 0, // Skip to: 763 +/* 319 */ MCD_OPC_CheckField, 0, 7, 91, 181, 1, 0, // Skip to: 763 +/* 326 */ MCD_OPC_Decode, 252, 96, 182, 1, // Opcode: VC_IVV +/* 331 */ MCD_OPC_FilterValue, 15, 171, 1, 0, // Skip to: 763 +/* 336 */ MCD_OPC_ExtractField, 25, 1, // Inst{25} ... +/* 339 */ MCD_OPC_FilterValue, 0, 17, 0, 0, // Skip to: 361 +/* 344 */ MCD_OPC_CheckPredicate, 106, 158, 1, 0, // Skip to: 763 +/* 349 */ MCD_OPC_CheckField, 0, 7, 91, 151, 1, 0, // Skip to: 763 +/* 356 */ MCD_OPC_Decode, 135, 97, 181, 1, // Opcode: VC_V_IVW +/* 361 */ MCD_OPC_FilterValue, 1, 141, 1, 0, // Skip to: 763 +/* 366 */ MCD_OPC_CheckPredicate, 106, 136, 1, 0, // Skip to: 763 +/* 371 */ MCD_OPC_CheckField, 0, 7, 91, 129, 1, 0, // Skip to: 763 +/* 378 */ MCD_OPC_Decode, 253, 96, 182, 1, // Opcode: VC_IVW +/* 383 */ MCD_OPC_FilterValue, 4, 211, 0, 0, // Skip to: 599 +/* 388 */ MCD_OPC_ExtractField, 28, 4, // Inst{31-28} ... +/* 391 */ MCD_OPC_FilterValue, 0, 47, 0, 0, // Skip to: 443 +/* 396 */ MCD_OPC_ExtractField, 25, 1, // Inst{25} ... +/* 399 */ MCD_OPC_FilterValue, 0, 17, 0, 0, // Skip to: 421 +/* 404 */ MCD_OPC_CheckPredicate, 106, 98, 1, 0, // Skip to: 763 +/* 409 */ MCD_OPC_CheckField, 0, 7, 91, 91, 1, 0, // Skip to: 763 +/* 416 */ MCD_OPC_Decode, 139, 97, 183, 1, // Opcode: VC_V_X +/* 421 */ MCD_OPC_FilterValue, 1, 81, 1, 0, // Skip to: 763 +/* 426 */ MCD_OPC_CheckPredicate, 106, 76, 1, 0, // Skip to: 763 +/* 431 */ MCD_OPC_CheckField, 0, 7, 91, 69, 1, 0, // Skip to: 763 +/* 438 */ MCD_OPC_Decode, 143, 97, 184, 1, // Opcode: VC_X +/* 443 */ MCD_OPC_FilterValue, 2, 47, 0, 0, // Skip to: 495 +/* 448 */ MCD_OPC_ExtractField, 25, 1, // Inst{25} ... +/* 451 */ MCD_OPC_FilterValue, 0, 17, 0, 0, // Skip to: 473 +/* 456 */ MCD_OPC_CheckPredicate, 106, 46, 1, 0, // Skip to: 763 +/* 461 */ MCD_OPC_CheckField, 0, 7, 91, 39, 1, 0, // Skip to: 763 +/* 468 */ MCD_OPC_Decode, 140, 97, 185, 1, // Opcode: VC_V_XV +/* 473 */ MCD_OPC_FilterValue, 1, 29, 1, 0, // Skip to: 763 +/* 478 */ MCD_OPC_CheckPredicate, 106, 24, 1, 0, // Skip to: 763 +/* 483 */ MCD_OPC_CheckField, 0, 7, 91, 17, 1, 0, // Skip to: 763 +/* 490 */ MCD_OPC_Decode, 144, 97, 186, 1, // Opcode: VC_XV +/* 495 */ MCD_OPC_FilterValue, 10, 47, 0, 0, // Skip to: 547 +/* 500 */ MCD_OPC_ExtractField, 25, 1, // Inst{25} ... +/* 503 */ MCD_OPC_FilterValue, 0, 17, 0, 0, // Skip to: 525 +/* 508 */ MCD_OPC_CheckPredicate, 106, 250, 0, 0, // Skip to: 763 +/* 513 */ MCD_OPC_CheckField, 0, 7, 91, 243, 0, 0, // Skip to: 763 +/* 520 */ MCD_OPC_Decode, 141, 97, 187, 1, // Opcode: VC_V_XVV +/* 525 */ MCD_OPC_FilterValue, 1, 233, 0, 0, // Skip to: 763 +/* 530 */ MCD_OPC_CheckPredicate, 106, 228, 0, 0, // Skip to: 763 +/* 535 */ MCD_OPC_CheckField, 0, 7, 91, 221, 0, 0, // Skip to: 763 +/* 542 */ MCD_OPC_Decode, 145, 97, 188, 1, // Opcode: VC_XVV +/* 547 */ MCD_OPC_FilterValue, 15, 211, 0, 0, // Skip to: 763 +/* 552 */ MCD_OPC_ExtractField, 25, 1, // Inst{25} ... +/* 555 */ MCD_OPC_FilterValue, 0, 17, 0, 0, // Skip to: 577 +/* 560 */ MCD_OPC_CheckPredicate, 106, 198, 0, 0, // Skip to: 763 +/* 565 */ MCD_OPC_CheckField, 0, 7, 91, 191, 0, 0, // Skip to: 763 +/* 572 */ MCD_OPC_Decode, 142, 97, 187, 1, // Opcode: VC_V_XVW +/* 577 */ MCD_OPC_FilterValue, 1, 181, 0, 0, // Skip to: 763 +/* 582 */ MCD_OPC_CheckPredicate, 106, 176, 0, 0, // Skip to: 763 +/* 587 */ MCD_OPC_CheckField, 0, 7, 91, 169, 0, 0, // Skip to: 763 +/* 594 */ MCD_OPC_Decode, 146, 97, 188, 1, // Opcode: VC_XVW +/* 599 */ MCD_OPC_FilterValue, 5, 159, 0, 0, // Skip to: 763 +/* 604 */ MCD_OPC_ExtractField, 27, 5, // Inst{31-27} ... +/* 607 */ MCD_OPC_FilterValue, 5, 47, 0, 0, // Skip to: 659 +/* 612 */ MCD_OPC_ExtractField, 25, 1, // Inst{25} ... +/* 615 */ MCD_OPC_FilterValue, 0, 17, 0, 0, // Skip to: 637 +/* 620 */ MCD_OPC_CheckPredicate, 106, 138, 0, 0, // Skip to: 763 +/* 625 */ MCD_OPC_CheckField, 0, 7, 91, 131, 0, 0, // Skip to: 763 +/* 632 */ MCD_OPC_Decode, 129, 97, 189, 1, // Opcode: VC_V_FV +/* 637 */ MCD_OPC_FilterValue, 1, 121, 0, 0, // Skip to: 763 +/* 642 */ MCD_OPC_CheckPredicate, 106, 116, 0, 0, // Skip to: 763 +/* 647 */ MCD_OPC_CheckField, 0, 7, 91, 109, 0, 0, // Skip to: 763 +/* 654 */ MCD_OPC_Decode, 247, 96, 190, 1, // Opcode: VC_FV +/* 659 */ MCD_OPC_FilterValue, 21, 47, 0, 0, // Skip to: 711 +/* 664 */ MCD_OPC_ExtractField, 25, 1, // Inst{25} ... +/* 667 */ MCD_OPC_FilterValue, 0, 17, 0, 0, // Skip to: 689 +/* 672 */ MCD_OPC_CheckPredicate, 106, 86, 0, 0, // Skip to: 763 +/* 677 */ MCD_OPC_CheckField, 0, 7, 91, 79, 0, 0, // Skip to: 763 +/* 684 */ MCD_OPC_Decode, 130, 97, 191, 1, // Opcode: VC_V_FVV +/* 689 */ MCD_OPC_FilterValue, 1, 69, 0, 0, // Skip to: 763 +/* 694 */ MCD_OPC_CheckPredicate, 106, 64, 0, 0, // Skip to: 763 +/* 699 */ MCD_OPC_CheckField, 0, 7, 91, 57, 0, 0, // Skip to: 763 +/* 706 */ MCD_OPC_Decode, 248, 96, 192, 1, // Opcode: VC_FVV +/* 711 */ MCD_OPC_FilterValue, 31, 47, 0, 0, // Skip to: 763 +/* 716 */ MCD_OPC_ExtractField, 25, 1, // Inst{25} ... +/* 719 */ MCD_OPC_FilterValue, 0, 17, 0, 0, // Skip to: 741 +/* 724 */ MCD_OPC_CheckPredicate, 106, 34, 0, 0, // Skip to: 763 +/* 729 */ MCD_OPC_CheckField, 0, 7, 91, 27, 0, 0, // Skip to: 763 +/* 736 */ MCD_OPC_Decode, 131, 97, 191, 1, // Opcode: VC_V_FVW +/* 741 */ MCD_OPC_FilterValue, 1, 17, 0, 0, // Skip to: 763 +/* 746 */ MCD_OPC_CheckPredicate, 106, 12, 0, 0, // Skip to: 763 +/* 751 */ MCD_OPC_CheckField, 0, 7, 91, 5, 0, 0, // Skip to: 763 +/* 758 */ MCD_OPC_Decode, 249, 96, 192, 1, // Opcode: VC_FVW +/* 763 */ MCD_OPC_Fail, + 0 +}; + +static const uint8_t DecoderTableXSfvfnrclipxfqf32[] = { +/* 0 */ MCD_OPC_ExtractField, 26, 6, // Inst{31-26} ... +/* 3 */ MCD_OPC_FilterValue, 34, 23, 0, 0, // Skip to: 31 +/* 8 */ MCD_OPC_CheckPredicate, 107, 46, 0, 0, // Skip to: 59 +/* 13 */ MCD_OPC_CheckField, 12, 3, 5, 39, 0, 0, // Skip to: 59 +/* 20 */ MCD_OPC_CheckField, 0, 7, 91, 32, 0, 0, // Skip to: 59 +/* 27 */ MCD_OPC_Decode, 198, 97, 119, // Opcode: VFNRCLIP_XU_F_QF +/* 31 */ MCD_OPC_FilterValue, 35, 23, 0, 0, // Skip to: 59 +/* 36 */ MCD_OPC_CheckPredicate, 107, 18, 0, 0, // Skip to: 59 +/* 41 */ MCD_OPC_CheckField, 12, 3, 5, 11, 0, 0, // Skip to: 59 +/* 48 */ MCD_OPC_CheckField, 0, 7, 91, 4, 0, 0, // Skip to: 59 +/* 55 */ MCD_OPC_Decode, 199, 97, 119, // Opcode: VFNRCLIP_X_F_QF +/* 59 */ MCD_OPC_Fail, + 0 +}; + +static const uint8_t DecoderTableXSfvfwmaccqqq32[] = { +/* 0 */ MCD_OPC_CheckPredicate, 108, 26, 0, 0, // Skip to: 31 +/* 5 */ MCD_OPC_CheckField, 25, 7, 121, 19, 0, 0, // Skip to: 31 +/* 12 */ MCD_OPC_CheckField, 12, 3, 1, 12, 0, 0, // Skip to: 31 +/* 19 */ MCD_OPC_CheckField, 0, 7, 91, 5, 0, 0, // Skip to: 31 +/* 26 */ MCD_OPC_Decode, 233, 97, 193, 1, // Opcode: VFWMACC_4x4x4 +/* 31 */ MCD_OPC_Fail, + 0 +}; + +static const uint8_t DecoderTableXSfvqmaccdod32[] = { +/* 0 */ MCD_OPC_ExtractField, 25, 7, // Inst{31-25} ... +/* 3 */ MCD_OPC_FilterValue, 89, 24, 0, 0, // Skip to: 32 +/* 8 */ MCD_OPC_CheckPredicate, 109, 106, 0, 0, // Skip to: 119 +/* 13 */ MCD_OPC_CheckField, 12, 3, 2, 99, 0, 0, // Skip to: 119 +/* 20 */ MCD_OPC_CheckField, 0, 7, 91, 92, 0, 0, // Skip to: 119 +/* 27 */ MCD_OPC_Decode, 153, 100, 193, 1, // Opcode: VQMACCU_2x8x2 +/* 32 */ MCD_OPC_FilterValue, 91, 24, 0, 0, // Skip to: 61 +/* 37 */ MCD_OPC_CheckPredicate, 109, 77, 0, 0, // Skip to: 119 +/* 42 */ MCD_OPC_CheckField, 12, 3, 2, 70, 0, 0, // Skip to: 119 +/* 49 */ MCD_OPC_CheckField, 0, 7, 91, 63, 0, 0, // Skip to: 119 +/* 56 */ MCD_OPC_Decode, 155, 100, 193, 1, // Opcode: VQMACC_2x8x2 +/* 61 */ MCD_OPC_FilterValue, 93, 24, 0, 0, // Skip to: 90 +/* 66 */ MCD_OPC_CheckPredicate, 109, 48, 0, 0, // Skip to: 119 +/* 71 */ MCD_OPC_CheckField, 12, 3, 2, 41, 0, 0, // Skip to: 119 +/* 78 */ MCD_OPC_CheckField, 0, 7, 91, 34, 0, 0, // Skip to: 119 +/* 85 */ MCD_OPC_Decode, 151, 100, 193, 1, // Opcode: VQMACCUS_2x8x2 +/* 90 */ MCD_OPC_FilterValue, 95, 24, 0, 0, // Skip to: 119 +/* 95 */ MCD_OPC_CheckPredicate, 109, 19, 0, 0, // Skip to: 119 +/* 100 */ MCD_OPC_CheckField, 12, 3, 2, 12, 0, 0, // Skip to: 119 +/* 107 */ MCD_OPC_CheckField, 0, 7, 91, 5, 0, 0, // Skip to: 119 +/* 114 */ MCD_OPC_Decode, 149, 100, 193, 1, // Opcode: VQMACCSU_2x8x2 +/* 119 */ MCD_OPC_Fail, + 0 +}; + +static const uint8_t DecoderTableXSfvqmaccqoq32[] = { +/* 0 */ MCD_OPC_ExtractField, 25, 7, // Inst{31-25} ... +/* 3 */ MCD_OPC_FilterValue, 121, 24, 0, 0, // Skip to: 32 +/* 8 */ MCD_OPC_CheckPredicate, 110, 106, 0, 0, // Skip to: 119 +/* 13 */ MCD_OPC_CheckField, 12, 3, 2, 99, 0, 0, // Skip to: 119 +/* 20 */ MCD_OPC_CheckField, 0, 7, 91, 92, 0, 0, // Skip to: 119 +/* 27 */ MCD_OPC_Decode, 154, 100, 193, 1, // Opcode: VQMACCU_4x8x4 +/* 32 */ MCD_OPC_FilterValue, 123, 24, 0, 0, // Skip to: 61 +/* 37 */ MCD_OPC_CheckPredicate, 110, 77, 0, 0, // Skip to: 119 +/* 42 */ MCD_OPC_CheckField, 12, 3, 2, 70, 0, 0, // Skip to: 119 +/* 49 */ MCD_OPC_CheckField, 0, 7, 91, 63, 0, 0, // Skip to: 119 +/* 56 */ MCD_OPC_Decode, 156, 100, 193, 1, // Opcode: VQMACC_4x8x4 +/* 61 */ MCD_OPC_FilterValue, 125, 24, 0, 0, // Skip to: 90 +/* 66 */ MCD_OPC_CheckPredicate, 110, 48, 0, 0, // Skip to: 119 +/* 71 */ MCD_OPC_CheckField, 12, 3, 2, 41, 0, 0, // Skip to: 119 +/* 78 */ MCD_OPC_CheckField, 0, 7, 91, 34, 0, 0, // Skip to: 119 +/* 85 */ MCD_OPC_Decode, 152, 100, 193, 1, // Opcode: VQMACCUS_4x8x4 +/* 90 */ MCD_OPC_FilterValue, 127, 24, 0, 0, // Skip to: 119 +/* 95 */ MCD_OPC_CheckPredicate, 110, 19, 0, 0, // Skip to: 119 +/* 100 */ MCD_OPC_CheckField, 12, 3, 2, 12, 0, 0, // Skip to: 119 +/* 107 */ MCD_OPC_CheckField, 0, 7, 91, 5, 0, 0, // Skip to: 119 +/* 114 */ MCD_OPC_Decode, 150, 100, 193, 1, // Opcode: VQMACCSU_4x8x4 +/* 119 */ MCD_OPC_Fail, + 0 +}; + +static const uint8_t DecoderTableXTHeadBa32[] = { +/* 0 */ MCD_OPC_CheckPredicate, 111, 26, 0, 0, // Skip to: 31 +/* 5 */ MCD_OPC_CheckField, 27, 5, 0, 19, 0, 0, // Skip to: 31 +/* 12 */ MCD_OPC_CheckField, 12, 3, 1, 12, 0, 0, // Skip to: 31 +/* 19 */ MCD_OPC_CheckField, 0, 7, 11, 5, 0, 0, // Skip to: 31 +/* 26 */ MCD_OPC_Decode, 230, 95, 194, 1, // Opcode: TH_ADDSL +/* 31 */ MCD_OPC_Fail, + 0 +}; + +static const uint8_t DecoderTableXTHeadBb32[] = { +/* 0 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 3 */ MCD_OPC_FilterValue, 1, 180, 0, 0, // Skip to: 188 +/* 8 */ MCD_OPC_ExtractField, 26, 6, // Inst{31-26} ... +/* 11 */ MCD_OPC_FilterValue, 4, 16, 0, 0, // Skip to: 32 +/* 16 */ MCD_OPC_CheckPredicate, 112, 211, 0, 0, // Skip to: 232 +/* 21 */ MCD_OPC_CheckField, 0, 7, 11, 204, 0, 0, // Skip to: 232 +/* 28 */ MCD_OPC_Decode, 188, 96, 48, // Opcode: TH_SRRI +/* 32 */ MCD_OPC_FilterValue, 5, 23, 0, 0, // Skip to: 60 +/* 37 */ MCD_OPC_CheckPredicate, 113, 190, 0, 0, // Skip to: 232 +/* 42 */ MCD_OPC_CheckField, 25, 1, 0, 183, 0, 0, // Skip to: 232 +/* 49 */ MCD_OPC_CheckField, 0, 7, 11, 176, 0, 0, // Skip to: 232 +/* 56 */ MCD_OPC_Decode, 189, 96, 53, // Opcode: TH_SRRIW +/* 60 */ MCD_OPC_FilterValue, 32, 45, 0, 0, // Skip to: 110 +/* 65 */ MCD_OPC_ExtractField, 20, 6, // Inst{25-20} ... +/* 68 */ MCD_OPC_FilterValue, 0, 16, 0, 0, // Skip to: 89 +/* 73 */ MCD_OPC_CheckPredicate, 112, 154, 0, 0, // Skip to: 232 +/* 78 */ MCD_OPC_CheckField, 0, 7, 11, 147, 0, 0, // Skip to: 232 +/* 85 */ MCD_OPC_Decode, 203, 96, 49, // Opcode: TH_TSTNBZ +/* 89 */ MCD_OPC_FilterValue, 32, 138, 0, 0, // Skip to: 232 +/* 94 */ MCD_OPC_CheckPredicate, 112, 133, 0, 0, // Skip to: 232 +/* 99 */ MCD_OPC_CheckField, 0, 7, 11, 126, 0, 0, // Skip to: 232 +/* 106 */ MCD_OPC_Decode, 175, 96, 49, // Opcode: TH_REV +/* 110 */ MCD_OPC_FilterValue, 33, 45, 0, 0, // Skip to: 160 +/* 115 */ MCD_OPC_ExtractField, 20, 6, // Inst{25-20} ... +/* 118 */ MCD_OPC_FilterValue, 0, 16, 0, 0, // Skip to: 139 +/* 123 */ MCD_OPC_CheckPredicate, 112, 104, 0, 0, // Skip to: 232 +/* 128 */ MCD_OPC_CheckField, 0, 7, 11, 97, 0, 0, // Skip to: 232 +/* 135 */ MCD_OPC_Decode, 247, 95, 49, // Opcode: TH_FF0 +/* 139 */ MCD_OPC_FilterValue, 32, 88, 0, 0, // Skip to: 232 +/* 144 */ MCD_OPC_CheckPredicate, 112, 83, 0, 0, // Skip to: 232 +/* 149 */ MCD_OPC_CheckField, 0, 7, 11, 76, 0, 0, // Skip to: 232 +/* 156 */ MCD_OPC_Decode, 248, 95, 49, // Opcode: TH_FF1 +/* 160 */ MCD_OPC_FilterValue, 36, 67, 0, 0, // Skip to: 232 +/* 165 */ MCD_OPC_CheckPredicate, 113, 62, 0, 0, // Skip to: 232 +/* 170 */ MCD_OPC_CheckField, 20, 6, 0, 55, 0, 0, // Skip to: 232 +/* 177 */ MCD_OPC_CheckField, 0, 7, 11, 48, 0, 0, // Skip to: 232 +/* 184 */ MCD_OPC_Decode, 176, 96, 49, // Opcode: TH_REVW +/* 188 */ MCD_OPC_FilterValue, 2, 17, 0, 0, // Skip to: 210 +/* 193 */ MCD_OPC_CheckPredicate, 112, 34, 0, 0, // Skip to: 232 +/* 198 */ MCD_OPC_CheckField, 0, 7, 11, 27, 0, 0, // Skip to: 232 +/* 205 */ MCD_OPC_Decode, 245, 95, 195, 1, // Opcode: TH_EXT +/* 210 */ MCD_OPC_FilterValue, 3, 17, 0, 0, // Skip to: 232 +/* 215 */ MCD_OPC_CheckPredicate, 112, 12, 0, 0, // Skip to: 232 +/* 220 */ MCD_OPC_CheckField, 0, 7, 11, 5, 0, 0, // Skip to: 232 +/* 227 */ MCD_OPC_Decode, 246, 95, 195, 1, // Opcode: TH_EXTU +/* 232 */ MCD_OPC_Fail, + 0 +}; + +static const uint8_t DecoderTableXTHeadBs32[] = { +/* 0 */ MCD_OPC_CheckPredicate, 114, 25, 0, 0, // Skip to: 30 +/* 5 */ MCD_OPC_CheckField, 26, 6, 34, 18, 0, 0, // Skip to: 30 +/* 12 */ MCD_OPC_CheckField, 12, 3, 1, 11, 0, 0, // Skip to: 30 +/* 19 */ MCD_OPC_CheckField, 0, 7, 11, 4, 0, 0, // Skip to: 30 +/* 26 */ MCD_OPC_Decode, 202, 96, 48, // Opcode: TH_TST +/* 30 */ MCD_OPC_Fail, + 0 +}; + +static const uint8_t DecoderTableXTHeadCmo32[] = { +/* 0 */ MCD_OPC_ExtractField, 20, 12, // Inst{31-20} ... +/* 3 */ MCD_OPC_FilterValue, 1, 16, 0, 0, // Skip to: 24 +/* 8 */ MCD_OPC_CheckPredicate, 115, 175, 1, 0, // Skip to: 444 +/* 13 */ MCD_OPC_CheckField, 0, 20, 11, 168, 1, 0, // Skip to: 444 +/* 20 */ MCD_OPC_Decode, 231, 95, 0, // Opcode: TH_DCACHE_CALL +/* 24 */ MCD_OPC_FilterValue, 2, 16, 0, 0, // Skip to: 45 +/* 29 */ MCD_OPC_CheckPredicate, 115, 154, 1, 0, // Skip to: 444 +/* 34 */ MCD_OPC_CheckField, 0, 20, 11, 147, 1, 0, // Skip to: 444 +/* 41 */ MCD_OPC_Decode, 241, 95, 0, // Opcode: TH_DCACHE_IALL +/* 45 */ MCD_OPC_FilterValue, 3, 16, 0, 0, // Skip to: 66 +/* 50 */ MCD_OPC_CheckPredicate, 115, 133, 1, 0, // Skip to: 444 +/* 55 */ MCD_OPC_CheckField, 0, 20, 11, 126, 1, 0, // Skip to: 444 +/* 62 */ MCD_OPC_Decode, 232, 95, 0, // Opcode: TH_DCACHE_CIALL +/* 66 */ MCD_OPC_FilterValue, 16, 16, 0, 0, // Skip to: 87 +/* 71 */ MCD_OPC_CheckPredicate, 115, 112, 1, 0, // Skip to: 444 +/* 76 */ MCD_OPC_CheckField, 0, 20, 11, 105, 1, 0, // Skip to: 444 +/* 83 */ MCD_OPC_Decode, 129, 96, 0, // Opcode: TH_ICACHE_IALL +/* 87 */ MCD_OPC_FilterValue, 17, 16, 0, 0, // Skip to: 108 +/* 92 */ MCD_OPC_CheckPredicate, 115, 91, 1, 0, // Skip to: 444 +/* 97 */ MCD_OPC_CheckField, 0, 20, 11, 84, 1, 0, // Skip to: 444 +/* 104 */ MCD_OPC_Decode, 130, 96, 0, // Opcode: TH_ICACHE_IALLS +/* 108 */ MCD_OPC_FilterValue, 21, 16, 0, 0, // Skip to: 129 +/* 113 */ MCD_OPC_CheckPredicate, 115, 70, 1, 0, // Skip to: 444 +/* 118 */ MCD_OPC_CheckField, 0, 20, 11, 63, 1, 0, // Skip to: 444 +/* 125 */ MCD_OPC_Decode, 133, 96, 0, // Opcode: TH_L2CACHE_CALL +/* 129 */ MCD_OPC_FilterValue, 22, 16, 0, 0, // Skip to: 150 +/* 134 */ MCD_OPC_CheckPredicate, 115, 49, 1, 0, // Skip to: 444 +/* 139 */ MCD_OPC_CheckField, 0, 20, 11, 42, 1, 0, // Skip to: 444 +/* 146 */ MCD_OPC_Decode, 135, 96, 0, // Opcode: TH_L2CACHE_IALL +/* 150 */ MCD_OPC_FilterValue, 23, 16, 0, 0, // Skip to: 171 +/* 155 */ MCD_OPC_CheckPredicate, 115, 28, 1, 0, // Skip to: 444 +/* 160 */ MCD_OPC_CheckField, 0, 20, 11, 21, 1, 0, // Skip to: 444 +/* 167 */ MCD_OPC_Decode, 134, 96, 0, // Opcode: TH_L2CACHE_CIALL +/* 171 */ MCD_OPC_FilterValue, 33, 16, 0, 0, // Skip to: 192 +/* 176 */ MCD_OPC_CheckPredicate, 115, 7, 1, 0, // Skip to: 444 +/* 181 */ MCD_OPC_CheckField, 0, 15, 11, 0, 1, 0, // Skip to: 444 +/* 188 */ MCD_OPC_Decode, 238, 95, 47, // Opcode: TH_DCACHE_CSW +/* 192 */ MCD_OPC_FilterValue, 34, 16, 0, 0, // Skip to: 213 +/* 197 */ MCD_OPC_CheckPredicate, 115, 242, 0, 0, // Skip to: 444 +/* 202 */ MCD_OPC_CheckField, 0, 15, 11, 235, 0, 0, // Skip to: 444 +/* 209 */ MCD_OPC_Decode, 243, 95, 47, // Opcode: TH_DCACHE_ISW +/* 213 */ MCD_OPC_FilterValue, 35, 16, 0, 0, // Skip to: 234 +/* 218 */ MCD_OPC_CheckPredicate, 115, 221, 0, 0, // Skip to: 444 +/* 223 */ MCD_OPC_CheckField, 0, 15, 11, 214, 0, 0, // Skip to: 444 +/* 230 */ MCD_OPC_Decode, 234, 95, 47, // Opcode: TH_DCACHE_CISW +/* 234 */ MCD_OPC_FilterValue, 36, 16, 0, 0, // Skip to: 255 +/* 239 */ MCD_OPC_CheckPredicate, 115, 200, 0, 0, // Skip to: 444 +/* 244 */ MCD_OPC_CheckField, 0, 15, 11, 193, 0, 0, // Skip to: 444 +/* 251 */ MCD_OPC_Decode, 240, 95, 47, // Opcode: TH_DCACHE_CVAL1 +/* 255 */ MCD_OPC_FilterValue, 37, 16, 0, 0, // Skip to: 276 +/* 260 */ MCD_OPC_CheckPredicate, 115, 179, 0, 0, // Skip to: 444 +/* 265 */ MCD_OPC_CheckField, 0, 15, 11, 172, 0, 0, // Skip to: 444 +/* 272 */ MCD_OPC_Decode, 239, 95, 47, // Opcode: TH_DCACHE_CVA +/* 276 */ MCD_OPC_FilterValue, 38, 16, 0, 0, // Skip to: 297 +/* 281 */ MCD_OPC_CheckPredicate, 115, 158, 0, 0, // Skip to: 444 +/* 286 */ MCD_OPC_CheckField, 0, 15, 11, 151, 0, 0, // Skip to: 444 +/* 293 */ MCD_OPC_Decode, 244, 95, 47, // Opcode: TH_DCACHE_IVA +/* 297 */ MCD_OPC_FilterValue, 39, 16, 0, 0, // Skip to: 318 +/* 302 */ MCD_OPC_CheckPredicate, 115, 137, 0, 0, // Skip to: 444 +/* 307 */ MCD_OPC_CheckField, 0, 15, 11, 130, 0, 0, // Skip to: 444 +/* 314 */ MCD_OPC_Decode, 235, 95, 47, // Opcode: TH_DCACHE_CIVA +/* 318 */ MCD_OPC_FilterValue, 40, 16, 0, 0, // Skip to: 339 +/* 323 */ MCD_OPC_CheckPredicate, 115, 116, 0, 0, // Skip to: 444 +/* 328 */ MCD_OPC_CheckField, 0, 15, 11, 109, 0, 0, // Skip to: 444 +/* 335 */ MCD_OPC_Decode, 237, 95, 47, // Opcode: TH_DCACHE_CPAL1 +/* 339 */ MCD_OPC_FilterValue, 41, 16, 0, 0, // Skip to: 360 +/* 344 */ MCD_OPC_CheckPredicate, 115, 95, 0, 0, // Skip to: 444 +/* 349 */ MCD_OPC_CheckField, 0, 15, 11, 88, 0, 0, // Skip to: 444 +/* 356 */ MCD_OPC_Decode, 236, 95, 47, // Opcode: TH_DCACHE_CPA +/* 360 */ MCD_OPC_FilterValue, 42, 16, 0, 0, // Skip to: 381 +/* 365 */ MCD_OPC_CheckPredicate, 115, 74, 0, 0, // Skip to: 444 +/* 370 */ MCD_OPC_CheckField, 0, 15, 11, 67, 0, 0, // Skip to: 444 +/* 377 */ MCD_OPC_Decode, 242, 95, 47, // Opcode: TH_DCACHE_IPA +/* 381 */ MCD_OPC_FilterValue, 43, 16, 0, 0, // Skip to: 402 +/* 386 */ MCD_OPC_CheckPredicate, 115, 53, 0, 0, // Skip to: 444 +/* 391 */ MCD_OPC_CheckField, 0, 15, 11, 46, 0, 0, // Skip to: 444 +/* 398 */ MCD_OPC_Decode, 233, 95, 47, // Opcode: TH_DCACHE_CIPA +/* 402 */ MCD_OPC_FilterValue, 48, 16, 0, 0, // Skip to: 423 +/* 407 */ MCD_OPC_CheckPredicate, 115, 32, 0, 0, // Skip to: 444 +/* 412 */ MCD_OPC_CheckField, 0, 15, 11, 25, 0, 0, // Skip to: 444 +/* 419 */ MCD_OPC_Decode, 132, 96, 47, // Opcode: TH_ICACHE_IVA +/* 423 */ MCD_OPC_FilterValue, 56, 16, 0, 0, // Skip to: 444 +/* 428 */ MCD_OPC_CheckPredicate, 115, 11, 0, 0, // Skip to: 444 +/* 433 */ MCD_OPC_CheckField, 0, 15, 11, 4, 0, 0, // Skip to: 444 +/* 440 */ MCD_OPC_Decode, 131, 96, 47, // Opcode: TH_ICACHE_IPA +/* 444 */ MCD_OPC_Fail, + 0 +}; + +static const uint8_t DecoderTableXTHeadCondMov32[] = { +/* 0 */ MCD_OPC_ExtractField, 25, 7, // Inst{31-25} ... +/* 3 */ MCD_OPC_FilterValue, 32, 23, 0, 0, // Skip to: 31 +/* 8 */ MCD_OPC_CheckPredicate, 116, 46, 0, 0, // Skip to: 59 +/* 13 */ MCD_OPC_CheckField, 12, 3, 1, 39, 0, 0, // Skip to: 59 +/* 20 */ MCD_OPC_CheckField, 0, 7, 11, 32, 0, 0, // Skip to: 59 +/* 27 */ MCD_OPC_Decode, 173, 96, 58, // Opcode: TH_MVEQZ +/* 31 */ MCD_OPC_FilterValue, 33, 23, 0, 0, // Skip to: 59 +/* 36 */ MCD_OPC_CheckPredicate, 116, 18, 0, 0, // Skip to: 59 +/* 41 */ MCD_OPC_CheckField, 12, 3, 1, 11, 0, 0, // Skip to: 59 +/* 48 */ MCD_OPC_CheckField, 0, 7, 11, 4, 0, 0, // Skip to: 59 +/* 55 */ MCD_OPC_Decode, 174, 96, 58, // Opcode: TH_MVNEZ +/* 59 */ MCD_OPC_Fail, + 0 +}; + +static const uint8_t DecoderTableXTHeadFMemIdx32[] = { +/* 0 */ MCD_OPC_ExtractField, 27, 5, // Inst{31-27} ... +/* 3 */ MCD_OPC_FilterValue, 8, 47, 0, 0, // Skip to: 55 +/* 8 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 11 */ MCD_OPC_FilterValue, 6, 17, 0, 0, // Skip to: 33 +/* 16 */ MCD_OPC_CheckPredicate, 117, 190, 0, 0, // Skip to: 211 +/* 21 */ MCD_OPC_CheckField, 0, 7, 11, 183, 0, 0, // Skip to: 211 +/* 28 */ MCD_OPC_Decode, 250, 95, 196, 1, // Opcode: TH_FLRW +/* 33 */ MCD_OPC_FilterValue, 7, 173, 0, 0, // Skip to: 211 +/* 38 */ MCD_OPC_CheckPredicate, 117, 168, 0, 0, // Skip to: 211 +/* 43 */ MCD_OPC_CheckField, 0, 7, 11, 161, 0, 0, // Skip to: 211 +/* 50 */ MCD_OPC_Decode, 254, 95, 196, 1, // Opcode: TH_FSRW +/* 55 */ MCD_OPC_FilterValue, 10, 47, 0, 0, // Skip to: 107 +/* 60 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 63 */ MCD_OPC_FilterValue, 6, 17, 0, 0, // Skip to: 85 +/* 68 */ MCD_OPC_CheckPredicate, 118, 138, 0, 0, // Skip to: 211 +/* 73 */ MCD_OPC_CheckField, 0, 7, 11, 131, 0, 0, // Skip to: 211 +/* 80 */ MCD_OPC_Decode, 252, 95, 196, 1, // Opcode: TH_FLURW +/* 85 */ MCD_OPC_FilterValue, 7, 121, 0, 0, // Skip to: 211 +/* 90 */ MCD_OPC_CheckPredicate, 118, 116, 0, 0, // Skip to: 211 +/* 95 */ MCD_OPC_CheckField, 0, 7, 11, 109, 0, 0, // Skip to: 211 +/* 102 */ MCD_OPC_Decode, 128, 96, 196, 1, // Opcode: TH_FSURW +/* 107 */ MCD_OPC_FilterValue, 12, 47, 0, 0, // Skip to: 159 +/* 112 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 115 */ MCD_OPC_FilterValue, 6, 17, 0, 0, // Skip to: 137 +/* 120 */ MCD_OPC_CheckPredicate, 119, 86, 0, 0, // Skip to: 211 +/* 125 */ MCD_OPC_CheckField, 0, 7, 11, 79, 0, 0, // Skip to: 211 +/* 132 */ MCD_OPC_Decode, 249, 95, 197, 1, // Opcode: TH_FLRD +/* 137 */ MCD_OPC_FilterValue, 7, 69, 0, 0, // Skip to: 211 +/* 142 */ MCD_OPC_CheckPredicate, 119, 64, 0, 0, // Skip to: 211 +/* 147 */ MCD_OPC_CheckField, 0, 7, 11, 57, 0, 0, // Skip to: 211 +/* 154 */ MCD_OPC_Decode, 253, 95, 197, 1, // Opcode: TH_FSRD +/* 159 */ MCD_OPC_FilterValue, 14, 47, 0, 0, // Skip to: 211 +/* 164 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 167 */ MCD_OPC_FilterValue, 6, 17, 0, 0, // Skip to: 189 +/* 172 */ MCD_OPC_CheckPredicate, 120, 34, 0, 0, // Skip to: 211 +/* 177 */ MCD_OPC_CheckField, 0, 7, 11, 27, 0, 0, // Skip to: 211 +/* 184 */ MCD_OPC_Decode, 251, 95, 197, 1, // Opcode: TH_FLURD +/* 189 */ MCD_OPC_FilterValue, 7, 17, 0, 0, // Skip to: 211 +/* 194 */ MCD_OPC_CheckPredicate, 120, 12, 0, 0, // Skip to: 211 +/* 199 */ MCD_OPC_CheckField, 0, 7, 11, 5, 0, 0, // Skip to: 211 +/* 206 */ MCD_OPC_Decode, 255, 95, 197, 1, // Opcode: TH_FSURD +/* 211 */ MCD_OPC_Fail, + 0 +}; + +static const uint8_t DecoderTableXTHeadMac32[] = { +/* 0 */ MCD_OPC_ExtractField, 25, 7, // Inst{31-25} ... +/* 3 */ MCD_OPC_FilterValue, 16, 23, 0, 0, // Skip to: 31 +/* 8 */ MCD_OPC_CheckPredicate, 121, 158, 0, 0, // Skip to: 171 +/* 13 */ MCD_OPC_CheckField, 12, 3, 1, 151, 0, 0, // Skip to: 171 +/* 20 */ MCD_OPC_CheckField, 0, 7, 11, 144, 0, 0, // Skip to: 171 +/* 27 */ MCD_OPC_Decode, 167, 96, 58, // Opcode: TH_MULA +/* 31 */ MCD_OPC_FilterValue, 17, 23, 0, 0, // Skip to: 59 +/* 36 */ MCD_OPC_CheckPredicate, 121, 130, 0, 0, // Skip to: 171 +/* 41 */ MCD_OPC_CheckField, 12, 3, 1, 123, 0, 0, // Skip to: 171 +/* 48 */ MCD_OPC_CheckField, 0, 7, 11, 116, 0, 0, // Skip to: 171 +/* 55 */ MCD_OPC_Decode, 170, 96, 58, // Opcode: TH_MULS +/* 59 */ MCD_OPC_FilterValue, 18, 23, 0, 0, // Skip to: 87 +/* 64 */ MCD_OPC_CheckPredicate, 122, 102, 0, 0, // Skip to: 171 +/* 69 */ MCD_OPC_CheckField, 12, 3, 1, 95, 0, 0, // Skip to: 171 +/* 76 */ MCD_OPC_CheckField, 0, 7, 11, 88, 0, 0, // Skip to: 171 +/* 83 */ MCD_OPC_Decode, 169, 96, 58, // Opcode: TH_MULAW +/* 87 */ MCD_OPC_FilterValue, 19, 23, 0, 0, // Skip to: 115 +/* 92 */ MCD_OPC_CheckPredicate, 122, 74, 0, 0, // Skip to: 171 +/* 97 */ MCD_OPC_CheckField, 12, 3, 1, 67, 0, 0, // Skip to: 171 +/* 104 */ MCD_OPC_CheckField, 0, 7, 11, 60, 0, 0, // Skip to: 171 +/* 111 */ MCD_OPC_Decode, 172, 96, 58, // Opcode: TH_MULSW +/* 115 */ MCD_OPC_FilterValue, 20, 23, 0, 0, // Skip to: 143 +/* 120 */ MCD_OPC_CheckPredicate, 121, 46, 0, 0, // Skip to: 171 +/* 125 */ MCD_OPC_CheckField, 12, 3, 1, 39, 0, 0, // Skip to: 171 +/* 132 */ MCD_OPC_CheckField, 0, 7, 11, 32, 0, 0, // Skip to: 171 +/* 139 */ MCD_OPC_Decode, 168, 96, 58, // Opcode: TH_MULAH +/* 143 */ MCD_OPC_FilterValue, 21, 23, 0, 0, // Skip to: 171 +/* 148 */ MCD_OPC_CheckPredicate, 121, 18, 0, 0, // Skip to: 171 +/* 153 */ MCD_OPC_CheckField, 12, 3, 1, 11, 0, 0, // Skip to: 171 +/* 160 */ MCD_OPC_CheckField, 0, 7, 11, 4, 0, 0, // Skip to: 171 +/* 167 */ MCD_OPC_Decode, 171, 96, 58, // Opcode: TH_MULSH +/* 171 */ MCD_OPC_Fail, + 0 +}; + +static const uint8_t DecoderTableXTHeadMemIdx32[] = { +/* 0 */ MCD_OPC_ExtractField, 27, 5, // Inst{31-27} ... +/* 3 */ MCD_OPC_FilterValue, 0, 47, 0, 0, // Skip to: 55 +/* 8 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 11 */ MCD_OPC_FilterValue, 4, 17, 0, 0, // Skip to: 33 +/* 16 */ MCD_OPC_CheckPredicate, 123, 138, 4, 0, // Skip to: 1183 +/* 21 */ MCD_OPC_CheckField, 0, 7, 11, 131, 4, 0, // Skip to: 1183 +/* 28 */ MCD_OPC_Decode, 147, 96, 194, 1, // Opcode: TH_LRB +/* 33 */ MCD_OPC_FilterValue, 5, 121, 4, 0, // Skip to: 1183 +/* 38 */ MCD_OPC_CheckPredicate, 123, 116, 4, 0, // Skip to: 1183 +/* 43 */ MCD_OPC_CheckField, 0, 7, 11, 109, 4, 0, // Skip to: 1183 +/* 50 */ MCD_OPC_Decode, 185, 96, 194, 1, // Opcode: TH_SRB +/* 55 */ MCD_OPC_FilterValue, 1, 47, 0, 0, // Skip to: 107 +/* 60 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 63 */ MCD_OPC_FilterValue, 4, 17, 0, 0, // Skip to: 85 +/* 68 */ MCD_OPC_CheckPredicate, 123, 86, 4, 0, // Skip to: 1183 +/* 73 */ MCD_OPC_CheckField, 0, 7, 11, 79, 4, 0, // Skip to: 1183 +/* 80 */ MCD_OPC_Decode, 137, 96, 198, 1, // Opcode: TH_LBIB +/* 85 */ MCD_OPC_FilterValue, 5, 69, 4, 0, // Skip to: 1183 +/* 90 */ MCD_OPC_CheckPredicate, 123, 64, 4, 0, // Skip to: 1183 +/* 95 */ MCD_OPC_CheckField, 0, 7, 11, 57, 4, 0, // Skip to: 1183 +/* 102 */ MCD_OPC_Decode, 178, 96, 199, 1, // Opcode: TH_SBIB +/* 107 */ MCD_OPC_FilterValue, 2, 47, 0, 0, // Skip to: 159 +/* 112 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 115 */ MCD_OPC_FilterValue, 4, 17, 0, 0, // Skip to: 137 +/* 120 */ MCD_OPC_CheckPredicate, 123, 34, 4, 0, // Skip to: 1183 +/* 125 */ MCD_OPC_CheckField, 0, 7, 11, 27, 4, 0, // Skip to: 1183 +/* 132 */ MCD_OPC_Decode, 154, 96, 194, 1, // Opcode: TH_LURB +/* 137 */ MCD_OPC_FilterValue, 5, 17, 4, 0, // Skip to: 1183 +/* 142 */ MCD_OPC_CheckPredicate, 123, 12, 4, 0, // Skip to: 1183 +/* 147 */ MCD_OPC_CheckField, 0, 7, 11, 5, 4, 0, // Skip to: 1183 +/* 154 */ MCD_OPC_Decode, 191, 96, 194, 1, // Opcode: TH_SURB +/* 159 */ MCD_OPC_FilterValue, 3, 47, 0, 0, // Skip to: 211 +/* 164 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 167 */ MCD_OPC_FilterValue, 4, 17, 0, 0, // Skip to: 189 +/* 172 */ MCD_OPC_CheckPredicate, 123, 238, 3, 0, // Skip to: 1183 +/* 177 */ MCD_OPC_CheckField, 0, 7, 11, 231, 3, 0, // Skip to: 1183 +/* 184 */ MCD_OPC_Decode, 136, 96, 198, 1, // Opcode: TH_LBIA +/* 189 */ MCD_OPC_FilterValue, 5, 221, 3, 0, // Skip to: 1183 +/* 194 */ MCD_OPC_CheckPredicate, 123, 216, 3, 0, // Skip to: 1183 +/* 199 */ MCD_OPC_CheckField, 0, 7, 11, 209, 3, 0, // Skip to: 1183 +/* 206 */ MCD_OPC_Decode, 177, 96, 199, 1, // Opcode: TH_SBIA +/* 211 */ MCD_OPC_FilterValue, 4, 47, 0, 0, // Skip to: 263 +/* 216 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 219 */ MCD_OPC_FilterValue, 4, 17, 0, 0, // Skip to: 241 +/* 224 */ MCD_OPC_CheckPredicate, 123, 186, 3, 0, // Skip to: 1183 +/* 229 */ MCD_OPC_CheckField, 0, 7, 11, 179, 3, 0, // Skip to: 1183 +/* 236 */ MCD_OPC_Decode, 150, 96, 194, 1, // Opcode: TH_LRH +/* 241 */ MCD_OPC_FilterValue, 5, 169, 3, 0, // Skip to: 1183 +/* 246 */ MCD_OPC_CheckPredicate, 123, 164, 3, 0, // Skip to: 1183 +/* 251 */ MCD_OPC_CheckField, 0, 7, 11, 157, 3, 0, // Skip to: 1183 +/* 258 */ MCD_OPC_Decode, 187, 96, 194, 1, // Opcode: TH_SRH +/* 263 */ MCD_OPC_FilterValue, 5, 47, 0, 0, // Skip to: 315 +/* 268 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 271 */ MCD_OPC_FilterValue, 4, 17, 0, 0, // Skip to: 293 +/* 276 */ MCD_OPC_CheckPredicate, 123, 134, 3, 0, // Skip to: 1183 +/* 281 */ MCD_OPC_CheckField, 0, 7, 11, 127, 3, 0, // Skip to: 1183 +/* 288 */ MCD_OPC_Decode, 144, 96, 198, 1, // Opcode: TH_LHIB +/* 293 */ MCD_OPC_FilterValue, 5, 117, 3, 0, // Skip to: 1183 +/* 298 */ MCD_OPC_CheckPredicate, 123, 112, 3, 0, // Skip to: 1183 +/* 303 */ MCD_OPC_CheckField, 0, 7, 11, 105, 3, 0, // Skip to: 1183 +/* 310 */ MCD_OPC_Decode, 184, 96, 199, 1, // Opcode: TH_SHIB +/* 315 */ MCD_OPC_FilterValue, 6, 47, 0, 0, // Skip to: 367 +/* 320 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 323 */ MCD_OPC_FilterValue, 4, 17, 0, 0, // Skip to: 345 +/* 328 */ MCD_OPC_CheckPredicate, 123, 82, 3, 0, // Skip to: 1183 +/* 333 */ MCD_OPC_CheckField, 0, 7, 11, 75, 3, 0, // Skip to: 1183 +/* 340 */ MCD_OPC_Decode, 157, 96, 194, 1, // Opcode: TH_LURH +/* 345 */ MCD_OPC_FilterValue, 5, 65, 3, 0, // Skip to: 1183 +/* 350 */ MCD_OPC_CheckPredicate, 123, 60, 3, 0, // Skip to: 1183 +/* 355 */ MCD_OPC_CheckField, 0, 7, 11, 53, 3, 0, // Skip to: 1183 +/* 362 */ MCD_OPC_Decode, 193, 96, 194, 1, // Opcode: TH_SURH +/* 367 */ MCD_OPC_FilterValue, 7, 47, 0, 0, // Skip to: 419 +/* 372 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 375 */ MCD_OPC_FilterValue, 4, 17, 0, 0, // Skip to: 397 +/* 380 */ MCD_OPC_CheckPredicate, 123, 30, 3, 0, // Skip to: 1183 +/* 385 */ MCD_OPC_CheckField, 0, 7, 11, 23, 3, 0, // Skip to: 1183 +/* 392 */ MCD_OPC_Decode, 143, 96, 198, 1, // Opcode: TH_LHIA +/* 397 */ MCD_OPC_FilterValue, 5, 13, 3, 0, // Skip to: 1183 +/* 402 */ MCD_OPC_CheckPredicate, 123, 8, 3, 0, // Skip to: 1183 +/* 407 */ MCD_OPC_CheckField, 0, 7, 11, 1, 3, 0, // Skip to: 1183 +/* 414 */ MCD_OPC_Decode, 183, 96, 199, 1, // Opcode: TH_SHIA +/* 419 */ MCD_OPC_FilterValue, 8, 47, 0, 0, // Skip to: 471 +/* 424 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 427 */ MCD_OPC_FilterValue, 4, 17, 0, 0, // Skip to: 449 +/* 432 */ MCD_OPC_CheckPredicate, 123, 234, 2, 0, // Skip to: 1183 +/* 437 */ MCD_OPC_CheckField, 0, 7, 11, 227, 2, 0, // Skip to: 1183 +/* 444 */ MCD_OPC_Decode, 152, 96, 194, 1, // Opcode: TH_LRW +/* 449 */ MCD_OPC_FilterValue, 5, 217, 2, 0, // Skip to: 1183 +/* 454 */ MCD_OPC_CheckPredicate, 123, 212, 2, 0, // Skip to: 1183 +/* 459 */ MCD_OPC_CheckField, 0, 7, 11, 205, 2, 0, // Skip to: 1183 +/* 466 */ MCD_OPC_Decode, 190, 96, 194, 1, // Opcode: TH_SRW +/* 471 */ MCD_OPC_FilterValue, 9, 47, 0, 0, // Skip to: 523 +/* 476 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 479 */ MCD_OPC_FilterValue, 4, 17, 0, 0, // Skip to: 501 +/* 484 */ MCD_OPC_CheckPredicate, 123, 182, 2, 0, // Skip to: 1183 +/* 489 */ MCD_OPC_CheckField, 0, 7, 11, 175, 2, 0, // Skip to: 1183 +/* 496 */ MCD_OPC_Decode, 163, 96, 198, 1, // Opcode: TH_LWIB +/* 501 */ MCD_OPC_FilterValue, 5, 165, 2, 0, // Skip to: 1183 +/* 506 */ MCD_OPC_CheckPredicate, 123, 160, 2, 0, // Skip to: 1183 +/* 511 */ MCD_OPC_CheckField, 0, 7, 11, 153, 2, 0, // Skip to: 1183 +/* 518 */ MCD_OPC_Decode, 197, 96, 199, 1, // Opcode: TH_SWIB +/* 523 */ MCD_OPC_FilterValue, 10, 47, 0, 0, // Skip to: 575 +/* 528 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 531 */ MCD_OPC_FilterValue, 4, 17, 0, 0, // Skip to: 553 +/* 536 */ MCD_OPC_CheckPredicate, 123, 130, 2, 0, // Skip to: 1183 +/* 541 */ MCD_OPC_CheckField, 0, 7, 11, 123, 2, 0, // Skip to: 1183 +/* 548 */ MCD_OPC_Decode, 159, 96, 194, 1, // Opcode: TH_LURW +/* 553 */ MCD_OPC_FilterValue, 5, 113, 2, 0, // Skip to: 1183 +/* 558 */ MCD_OPC_CheckPredicate, 123, 108, 2, 0, // Skip to: 1183 +/* 563 */ MCD_OPC_CheckField, 0, 7, 11, 101, 2, 0, // Skip to: 1183 +/* 570 */ MCD_OPC_Decode, 194, 96, 194, 1, // Opcode: TH_SURW +/* 575 */ MCD_OPC_FilterValue, 11, 47, 0, 0, // Skip to: 627 +/* 580 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 583 */ MCD_OPC_FilterValue, 4, 17, 0, 0, // Skip to: 605 +/* 588 */ MCD_OPC_CheckPredicate, 123, 78, 2, 0, // Skip to: 1183 +/* 593 */ MCD_OPC_CheckField, 0, 7, 11, 71, 2, 0, // Skip to: 1183 +/* 600 */ MCD_OPC_Decode, 162, 96, 198, 1, // Opcode: TH_LWIA +/* 605 */ MCD_OPC_FilterValue, 5, 61, 2, 0, // Skip to: 1183 +/* 610 */ MCD_OPC_CheckPredicate, 123, 56, 2, 0, // Skip to: 1183 +/* 615 */ MCD_OPC_CheckField, 0, 7, 11, 49, 2, 0, // Skip to: 1183 +/* 622 */ MCD_OPC_Decode, 196, 96, 199, 1, // Opcode: TH_SWIA +/* 627 */ MCD_OPC_FilterValue, 12, 47, 0, 0, // Skip to: 679 +/* 632 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 635 */ MCD_OPC_FilterValue, 4, 17, 0, 0, // Skip to: 657 +/* 640 */ MCD_OPC_CheckPredicate, 124, 26, 2, 0, // Skip to: 1183 +/* 645 */ MCD_OPC_CheckField, 0, 7, 11, 19, 2, 0, // Skip to: 1183 +/* 652 */ MCD_OPC_Decode, 149, 96, 194, 1, // Opcode: TH_LRD +/* 657 */ MCD_OPC_FilterValue, 5, 9, 2, 0, // Skip to: 1183 +/* 662 */ MCD_OPC_CheckPredicate, 124, 4, 2, 0, // Skip to: 1183 +/* 667 */ MCD_OPC_CheckField, 0, 7, 11, 253, 1, 0, // Skip to: 1183 +/* 674 */ MCD_OPC_Decode, 186, 96, 194, 1, // Opcode: TH_SRD +/* 679 */ MCD_OPC_FilterValue, 13, 47, 0, 0, // Skip to: 731 +/* 684 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 687 */ MCD_OPC_FilterValue, 4, 17, 0, 0, // Skip to: 709 +/* 692 */ MCD_OPC_CheckPredicate, 124, 230, 1, 0, // Skip to: 1183 +/* 697 */ MCD_OPC_CheckField, 0, 7, 11, 223, 1, 0, // Skip to: 1183 +/* 704 */ MCD_OPC_Decode, 142, 96, 198, 1, // Opcode: TH_LDIB +/* 709 */ MCD_OPC_FilterValue, 5, 213, 1, 0, // Skip to: 1183 +/* 714 */ MCD_OPC_CheckPredicate, 124, 208, 1, 0, // Skip to: 1183 +/* 719 */ MCD_OPC_CheckField, 0, 7, 11, 201, 1, 0, // Skip to: 1183 +/* 726 */ MCD_OPC_Decode, 181, 96, 199, 1, // Opcode: TH_SDIB +/* 731 */ MCD_OPC_FilterValue, 14, 47, 0, 0, // Skip to: 783 +/* 736 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 739 */ MCD_OPC_FilterValue, 4, 17, 0, 0, // Skip to: 761 +/* 744 */ MCD_OPC_CheckPredicate, 124, 178, 1, 0, // Skip to: 1183 +/* 749 */ MCD_OPC_CheckField, 0, 7, 11, 171, 1, 0, // Skip to: 1183 +/* 756 */ MCD_OPC_Decode, 156, 96, 194, 1, // Opcode: TH_LURD +/* 761 */ MCD_OPC_FilterValue, 5, 161, 1, 0, // Skip to: 1183 +/* 766 */ MCD_OPC_CheckPredicate, 124, 156, 1, 0, // Skip to: 1183 +/* 771 */ MCD_OPC_CheckField, 0, 7, 11, 149, 1, 0, // Skip to: 1183 +/* 778 */ MCD_OPC_Decode, 192, 96, 194, 1, // Opcode: TH_SURD +/* 783 */ MCD_OPC_FilterValue, 15, 47, 0, 0, // Skip to: 835 +/* 788 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 791 */ MCD_OPC_FilterValue, 4, 17, 0, 0, // Skip to: 813 +/* 796 */ MCD_OPC_CheckPredicate, 124, 126, 1, 0, // Skip to: 1183 +/* 801 */ MCD_OPC_CheckField, 0, 7, 11, 119, 1, 0, // Skip to: 1183 +/* 808 */ MCD_OPC_Decode, 141, 96, 198, 1, // Opcode: TH_LDIA +/* 813 */ MCD_OPC_FilterValue, 5, 109, 1, 0, // Skip to: 1183 +/* 818 */ MCD_OPC_CheckPredicate, 124, 104, 1, 0, // Skip to: 1183 +/* 823 */ MCD_OPC_CheckField, 0, 7, 11, 97, 1, 0, // Skip to: 1183 +/* 830 */ MCD_OPC_Decode, 180, 96, 199, 1, // Opcode: TH_SDIA +/* 835 */ MCD_OPC_FilterValue, 16, 24, 0, 0, // Skip to: 864 +/* 840 */ MCD_OPC_CheckPredicate, 123, 82, 1, 0, // Skip to: 1183 +/* 845 */ MCD_OPC_CheckField, 12, 3, 4, 75, 1, 0, // Skip to: 1183 +/* 852 */ MCD_OPC_CheckField, 0, 7, 11, 68, 1, 0, // Skip to: 1183 +/* 859 */ MCD_OPC_Decode, 148, 96, 194, 1, // Opcode: TH_LRBU +/* 864 */ MCD_OPC_FilterValue, 17, 24, 0, 0, // Skip to: 893 +/* 869 */ MCD_OPC_CheckPredicate, 123, 53, 1, 0, // Skip to: 1183 +/* 874 */ MCD_OPC_CheckField, 12, 3, 4, 46, 1, 0, // Skip to: 1183 +/* 881 */ MCD_OPC_CheckField, 0, 7, 11, 39, 1, 0, // Skip to: 1183 +/* 888 */ MCD_OPC_Decode, 139, 96, 198, 1, // Opcode: TH_LBUIB +/* 893 */ MCD_OPC_FilterValue, 18, 24, 0, 0, // Skip to: 922 +/* 898 */ MCD_OPC_CheckPredicate, 123, 24, 1, 0, // Skip to: 1183 +/* 903 */ MCD_OPC_CheckField, 12, 3, 4, 17, 1, 0, // Skip to: 1183 +/* 910 */ MCD_OPC_CheckField, 0, 7, 11, 10, 1, 0, // Skip to: 1183 +/* 917 */ MCD_OPC_Decode, 155, 96, 194, 1, // Opcode: TH_LURBU +/* 922 */ MCD_OPC_FilterValue, 19, 24, 0, 0, // Skip to: 951 +/* 927 */ MCD_OPC_CheckPredicate, 123, 251, 0, 0, // Skip to: 1183 +/* 932 */ MCD_OPC_CheckField, 12, 3, 4, 244, 0, 0, // Skip to: 1183 +/* 939 */ MCD_OPC_CheckField, 0, 7, 11, 237, 0, 0, // Skip to: 1183 +/* 946 */ MCD_OPC_Decode, 138, 96, 198, 1, // Opcode: TH_LBUIA +/* 951 */ MCD_OPC_FilterValue, 20, 24, 0, 0, // Skip to: 980 +/* 956 */ MCD_OPC_CheckPredicate, 123, 222, 0, 0, // Skip to: 1183 +/* 961 */ MCD_OPC_CheckField, 12, 3, 4, 215, 0, 0, // Skip to: 1183 +/* 968 */ MCD_OPC_CheckField, 0, 7, 11, 208, 0, 0, // Skip to: 1183 +/* 975 */ MCD_OPC_Decode, 151, 96, 194, 1, // Opcode: TH_LRHU +/* 980 */ MCD_OPC_FilterValue, 21, 24, 0, 0, // Skip to: 1009 +/* 985 */ MCD_OPC_CheckPredicate, 123, 193, 0, 0, // Skip to: 1183 +/* 990 */ MCD_OPC_CheckField, 12, 3, 4, 186, 0, 0, // Skip to: 1183 +/* 997 */ MCD_OPC_CheckField, 0, 7, 11, 179, 0, 0, // Skip to: 1183 +/* 1004 */ MCD_OPC_Decode, 146, 96, 198, 1, // Opcode: TH_LHUIB +/* 1009 */ MCD_OPC_FilterValue, 22, 24, 0, 0, // Skip to: 1038 +/* 1014 */ MCD_OPC_CheckPredicate, 123, 164, 0, 0, // Skip to: 1183 +/* 1019 */ MCD_OPC_CheckField, 12, 3, 4, 157, 0, 0, // Skip to: 1183 +/* 1026 */ MCD_OPC_CheckField, 0, 7, 11, 150, 0, 0, // Skip to: 1183 +/* 1033 */ MCD_OPC_Decode, 158, 96, 194, 1, // Opcode: TH_LURHU +/* 1038 */ MCD_OPC_FilterValue, 23, 24, 0, 0, // Skip to: 1067 +/* 1043 */ MCD_OPC_CheckPredicate, 123, 135, 0, 0, // Skip to: 1183 +/* 1048 */ MCD_OPC_CheckField, 12, 3, 4, 128, 0, 0, // Skip to: 1183 +/* 1055 */ MCD_OPC_CheckField, 0, 7, 11, 121, 0, 0, // Skip to: 1183 +/* 1062 */ MCD_OPC_Decode, 145, 96, 198, 1, // Opcode: TH_LHUIA +/* 1067 */ MCD_OPC_FilterValue, 24, 24, 0, 0, // Skip to: 1096 +/* 1072 */ MCD_OPC_CheckPredicate, 124, 106, 0, 0, // Skip to: 1183 +/* 1077 */ MCD_OPC_CheckField, 12, 3, 4, 99, 0, 0, // Skip to: 1183 +/* 1084 */ MCD_OPC_CheckField, 0, 7, 11, 92, 0, 0, // Skip to: 1183 +/* 1091 */ MCD_OPC_Decode, 153, 96, 194, 1, // Opcode: TH_LRWU +/* 1096 */ MCD_OPC_FilterValue, 25, 24, 0, 0, // Skip to: 1125 +/* 1101 */ MCD_OPC_CheckPredicate, 124, 77, 0, 0, // Skip to: 1183 +/* 1106 */ MCD_OPC_CheckField, 12, 3, 4, 70, 0, 0, // Skip to: 1183 +/* 1113 */ MCD_OPC_CheckField, 0, 7, 11, 63, 0, 0, // Skip to: 1183 +/* 1120 */ MCD_OPC_Decode, 166, 96, 198, 1, // Opcode: TH_LWUIB +/* 1125 */ MCD_OPC_FilterValue, 26, 24, 0, 0, // Skip to: 1154 +/* 1130 */ MCD_OPC_CheckPredicate, 124, 48, 0, 0, // Skip to: 1183 +/* 1135 */ MCD_OPC_CheckField, 12, 3, 4, 41, 0, 0, // Skip to: 1183 +/* 1142 */ MCD_OPC_CheckField, 0, 7, 11, 34, 0, 0, // Skip to: 1183 +/* 1149 */ MCD_OPC_Decode, 160, 96, 194, 1, // Opcode: TH_LURWU +/* 1154 */ MCD_OPC_FilterValue, 27, 24, 0, 0, // Skip to: 1183 +/* 1159 */ MCD_OPC_CheckPredicate, 124, 19, 0, 0, // Skip to: 1183 +/* 1164 */ MCD_OPC_CheckField, 12, 3, 4, 12, 0, 0, // Skip to: 1183 +/* 1171 */ MCD_OPC_CheckField, 0, 7, 11, 5, 0, 0, // Skip to: 1183 +/* 1178 */ MCD_OPC_Decode, 165, 96, 198, 1, // Opcode: TH_LWUIA +/* 1183 */ MCD_OPC_Fail, + 0 +}; + +static const uint8_t DecoderTableXTHeadMemPair32[] = { +/* 0 */ MCD_OPC_ExtractField, 27, 5, // Inst{31-27} ... +/* 3 */ MCD_OPC_FilterValue, 28, 47, 0, 0, // Skip to: 55 +/* 8 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 11 */ MCD_OPC_FilterValue, 4, 17, 0, 0, // Skip to: 33 +/* 16 */ MCD_OPC_CheckPredicate, 125, 115, 0, 0, // Skip to: 136 +/* 21 */ MCD_OPC_CheckField, 0, 7, 11, 108, 0, 0, // Skip to: 136 +/* 28 */ MCD_OPC_Decode, 161, 96, 200, 1, // Opcode: TH_LWD +/* 33 */ MCD_OPC_FilterValue, 5, 98, 0, 0, // Skip to: 136 +/* 38 */ MCD_OPC_CheckPredicate, 125, 93, 0, 0, // Skip to: 136 +/* 43 */ MCD_OPC_CheckField, 0, 7, 11, 86, 0, 0, // Skip to: 136 +/* 50 */ MCD_OPC_Decode, 195, 96, 200, 1, // Opcode: TH_SWD +/* 55 */ MCD_OPC_FilterValue, 30, 24, 0, 0, // Skip to: 84 +/* 60 */ MCD_OPC_CheckPredicate, 125, 71, 0, 0, // Skip to: 136 +/* 65 */ MCD_OPC_CheckField, 12, 3, 4, 64, 0, 0, // Skip to: 136 +/* 72 */ MCD_OPC_CheckField, 0, 7, 11, 57, 0, 0, // Skip to: 136 +/* 79 */ MCD_OPC_Decode, 164, 96, 200, 1, // Opcode: TH_LWUD +/* 84 */ MCD_OPC_FilterValue, 31, 47, 0, 0, // Skip to: 136 +/* 89 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 92 */ MCD_OPC_FilterValue, 4, 17, 0, 0, // Skip to: 114 +/* 97 */ MCD_OPC_CheckPredicate, 126, 34, 0, 0, // Skip to: 136 +/* 102 */ MCD_OPC_CheckField, 0, 7, 11, 27, 0, 0, // Skip to: 136 +/* 109 */ MCD_OPC_Decode, 140, 96, 200, 1, // Opcode: TH_LDD +/* 114 */ MCD_OPC_FilterValue, 5, 17, 0, 0, // Skip to: 136 +/* 119 */ MCD_OPC_CheckPredicate, 126, 12, 0, 0, // Skip to: 136 +/* 124 */ MCD_OPC_CheckField, 0, 7, 11, 5, 0, 0, // Skip to: 136 +/* 131 */ MCD_OPC_Decode, 179, 96, 200, 1, // Opcode: TH_SDD +/* 136 */ MCD_OPC_Fail, + 0 +}; + +static const uint8_t DecoderTableXTHeadSync32[] = { +/* 0 */ MCD_OPC_ExtractField, 25, 7, // Inst{31-25} ... +/* 3 */ MCD_OPC_FilterValue, 0, 71, 0, 0, // Skip to: 79 +/* 8 */ MCD_OPC_ExtractField, 0, 25, // Inst{24-0} ... +/* 11 */ MCD_OPC_FilterValue, 139, 128, 128, 12, 9, 0, 0, // Skip to: 28 +/* 19 */ MCD_OPC_CheckPredicate, 127, 77, 0, 0, // Skip to: 101 +/* 24 */ MCD_OPC_Decode, 198, 96, 0, // Opcode: TH_SYNC +/* 28 */ MCD_OPC_FilterValue, 139, 128, 192, 12, 9, 0, 0, // Skip to: 45 +/* 36 */ MCD_OPC_CheckPredicate, 127, 60, 0, 0, // Skip to: 101 +/* 41 */ MCD_OPC_Decode, 201, 96, 0, // Opcode: TH_SYNC_S +/* 45 */ MCD_OPC_FilterValue, 139, 128, 128, 13, 9, 0, 0, // Skip to: 62 +/* 53 */ MCD_OPC_CheckPredicate, 127, 43, 0, 0, // Skip to: 101 +/* 58 */ MCD_OPC_Decode, 199, 96, 0, // Opcode: TH_SYNC_I +/* 62 */ MCD_OPC_FilterValue, 139, 128, 192, 13, 31, 0, 0, // Skip to: 101 +/* 70 */ MCD_OPC_CheckPredicate, 127, 26, 0, 0, // Skip to: 101 +/* 75 */ MCD_OPC_Decode, 200, 96, 0, // Opcode: TH_SYNC_IS +/* 79 */ MCD_OPC_FilterValue, 2, 17, 0, 0, // Skip to: 101 +/* 84 */ MCD_OPC_CheckPredicate, 127, 12, 0, 0, // Skip to: 101 +/* 89 */ MCD_OPC_CheckField, 0, 15, 11, 5, 0, 0, // Skip to: 101 +/* 96 */ MCD_OPC_Decode, 182, 96, 130, 1, // Opcode: TH_SFENCE_VMAS +/* 101 */ MCD_OPC_Fail, + 0 +}; + +static const uint8_t DecoderTableXTHeadVdot32[] = { +/* 0 */ MCD_OPC_ExtractField, 26, 6, // Inst{31-26} ... +/* 3 */ MCD_OPC_FilterValue, 32, 24, 0, 0, // Skip to: 32 +/* 8 */ MCD_OPC_CheckPredicate, 128, 1, 192, 0, 0, // Skip to: 206 +/* 14 */ MCD_OPC_CheckField, 12, 3, 6, 185, 0, 0, // Skip to: 206 +/* 21 */ MCD_OPC_CheckField, 0, 7, 11, 178, 0, 0, // Skip to: 206 +/* 28 */ MCD_OPC_Decode, 228, 95, 104, // Opcode: THVdotVMAQA_VV +/* 32 */ MCD_OPC_FilterValue, 33, 24, 0, 0, // Skip to: 61 +/* 37 */ MCD_OPC_CheckPredicate, 128, 1, 163, 0, 0, // Skip to: 206 +/* 43 */ MCD_OPC_CheckField, 12, 3, 6, 156, 0, 0, // Skip to: 206 +/* 50 */ MCD_OPC_CheckField, 0, 7, 11, 149, 0, 0, // Skip to: 206 +/* 57 */ MCD_OPC_Decode, 229, 95, 125, // Opcode: THVdotVMAQA_VX +/* 61 */ MCD_OPC_FilterValue, 34, 24, 0, 0, // Skip to: 90 +/* 66 */ MCD_OPC_CheckPredicate, 128, 1, 134, 0, 0, // Skip to: 206 +/* 72 */ MCD_OPC_CheckField, 12, 3, 6, 127, 0, 0, // Skip to: 206 +/* 79 */ MCD_OPC_CheckField, 0, 7, 11, 120, 0, 0, // Skip to: 206 +/* 86 */ MCD_OPC_Decode, 226, 95, 104, // Opcode: THVdotVMAQAU_VV +/* 90 */ MCD_OPC_FilterValue, 35, 24, 0, 0, // Skip to: 119 +/* 95 */ MCD_OPC_CheckPredicate, 128, 1, 105, 0, 0, // Skip to: 206 +/* 101 */ MCD_OPC_CheckField, 12, 3, 6, 98, 0, 0, // Skip to: 206 +/* 108 */ MCD_OPC_CheckField, 0, 7, 11, 91, 0, 0, // Skip to: 206 +/* 115 */ MCD_OPC_Decode, 227, 95, 125, // Opcode: THVdotVMAQAU_VX +/* 119 */ MCD_OPC_FilterValue, 36, 24, 0, 0, // Skip to: 148 +/* 124 */ MCD_OPC_CheckPredicate, 128, 1, 76, 0, 0, // Skip to: 206 +/* 130 */ MCD_OPC_CheckField, 12, 3, 6, 69, 0, 0, // Skip to: 206 +/* 137 */ MCD_OPC_CheckField, 0, 7, 11, 62, 0, 0, // Skip to: 206 +/* 144 */ MCD_OPC_Decode, 223, 95, 104, // Opcode: THVdotVMAQASU_VV +/* 148 */ MCD_OPC_FilterValue, 37, 24, 0, 0, // Skip to: 177 +/* 153 */ MCD_OPC_CheckPredicate, 128, 1, 47, 0, 0, // Skip to: 206 +/* 159 */ MCD_OPC_CheckField, 12, 3, 6, 40, 0, 0, // Skip to: 206 +/* 166 */ MCD_OPC_CheckField, 0, 7, 11, 33, 0, 0, // Skip to: 206 +/* 173 */ MCD_OPC_Decode, 224, 95, 125, // Opcode: THVdotVMAQASU_VX +/* 177 */ MCD_OPC_FilterValue, 39, 24, 0, 0, // Skip to: 206 +/* 182 */ MCD_OPC_CheckPredicate, 128, 1, 18, 0, 0, // Skip to: 206 +/* 188 */ MCD_OPC_CheckField, 12, 3, 6, 11, 0, 0, // Skip to: 206 +/* 195 */ MCD_OPC_CheckField, 0, 7, 11, 4, 0, 0, // Skip to: 206 +/* 202 */ MCD_OPC_Decode, 225, 95, 125, // Opcode: THVdotVMAQAUS_VX +/* 206 */ MCD_OPC_Fail, + 0 +}; + +static const uint8_t DecoderTableXVentana32[] = { +/* 0 */ MCD_OPC_ExtractField, 12, 3, // Inst{14-12} ... +/* 3 */ MCD_OPC_FilterValue, 6, 24, 0, 0, // Skip to: 32 +/* 8 */ MCD_OPC_CheckPredicate, 129, 1, 47, 0, 0, // Skip to: 61 +/* 14 */ MCD_OPC_CheckField, 25, 7, 0, 40, 0, 0, // Skip to: 61 +/* 21 */ MCD_OPC_CheckField, 0, 7, 123, 33, 0, 0, // Skip to: 61 +/* 28 */ MCD_OPC_Decode, 237, 101, 59, // Opcode: VT_MASKC +/* 32 */ MCD_OPC_FilterValue, 7, 24, 0, 0, // Skip to: 61 +/* 37 */ MCD_OPC_CheckPredicate, 129, 1, 18, 0, 0, // Skip to: 61 +/* 43 */ MCD_OPC_CheckField, 25, 7, 0, 11, 0, 0, // Skip to: 61 +/* 50 */ MCD_OPC_CheckField, 0, 7, 123, 4, 0, 0, // Skip to: 61 +/* 57 */ MCD_OPC_Decode, 238, 101, 59, // Opcode: VT_MASKCN +/* 61 */ MCD_OPC_Fail, + 0 +}; + +static const uint8_t DecoderTableZicfiss16[] = { +/* 0 */ MCD_OPC_ExtractField, 0, 16, // Inst{15-0} ... +/* 3 */ MCD_OPC_FilterValue, 129, 193, 1, 11, 0, 0, // Skip to: 21 +/* 10 */ MCD_OPC_CheckPredicate, 130, 1, 23, 0, 0, // Skip to: 39 +/* 16 */ MCD_OPC_Decode, 157, 92, 201, 1, // Opcode: C_SSPUSH +/* 21 */ MCD_OPC_FilterValue, 129, 197, 1, 11, 0, 0, // Skip to: 39 +/* 28 */ MCD_OPC_CheckPredicate, 130, 1, 5, 0, 0, // Skip to: 39 +/* 34 */ MCD_OPC_Decode, 156, 92, 201, 1, // Opcode: C_SSPOPCHK +/* 39 */ MCD_OPC_Fail, 0 }; -static bool checkDecoderPredicate(unsigned Idx, uint64_t Bits) -{ +static bool checkDecoderPredicate(MCInst *Inst, unsigned Idx) { switch (Idx) { - default: CS_ASSERT(0 && "Invalid index!"); + default: CS_ASSERT_RET_VAL(0 && "Invalid index!", false); case 0: - return (Bits & RISCV_FeatureStdExtC); + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZca)); case 1: - return (Bits & RISCV_FeatureStdExtC) && (Bits & RISCV_FeatureStdExtD); + return ((RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZca)) && !RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureNoRVCHints)); case 2: - return (Bits & RISCV_FeatureStdExtC) && (Bits & RISCV_Feature64Bit); + return ((RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZcd)) && RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtD)); case 3: - return (Bits & RISCV_Feature64Bit); + return ((RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZca)) && RISCV_getFeatureBits(Inst->csh->mode, RISCV_Feature64Bit)); case 4: - return (Bits & RISCV_FeatureStdExtF); + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZcmop)); case 5: - return (Bits & RISCV_FeatureStdExtD); + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZcb)); case 6: - return (Bits & RISCV_FeatureStdExtA); + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZcb) && (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtM) || RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZmmul))); case 7: - return (Bits & RISCV_FeatureStdExtA) && (Bits & RISCV_Feature64Bit); + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZcb) && RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZbb)); case 8: - return (Bits & RISCV_FeatureStdExtM); + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZcb) && RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZba) && RISCV_getFeatureBits(Inst->csh->mode, RISCV_Feature64Bit)); case 9: - return (Bits & RISCV_FeatureStdExtM) && (Bits & RISCV_Feature64Bit); + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_Feature64Bit)); case 10: - return (Bits & RISCV_FeatureStdExtF) && (Bits & RISCV_Feature64Bit); + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZve32x)); case 11: - return (Bits & RISCV_FeatureStdExtD) && (Bits & RISCV_Feature64Bit); + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZfh) || RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZfhmin) || RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZfbfmin)); case 12: - return (Bits & RISCV_FeatureStdExtC) && (Bits & RISCV_FeatureStdExtF) && !(Bits & RISCV_Feature64Bit); + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtF)); case 13: - return (Bits & RISCV_FeatureStdExtC) && !(Bits & RISCV_Feature64Bit); + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtD)); + case 14: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZve64x)); + case 15: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_Feature64Bit) && RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZve64x)); + case 16: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZve64x) && RISCV_getFeatureBits(Inst->csh->mode, RISCV_Feature64Bit)); + case 17: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZicbom)); + case 18: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZicboz)); + case 19: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZbkb) && !RISCV_getFeatureBits(Inst->csh->mode, RISCV_Feature64Bit)); + case 20: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZknh)); + case 21: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZknh) && RISCV_getFeatureBits(Inst->csh->mode, RISCV_Feature64Bit)); + case 22: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZksh)); + case 23: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZbs)); + case 24: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZknd) && RISCV_getFeatureBits(Inst->csh->mode, RISCV_Feature64Bit)); + case 25: + return ((RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZknd) || RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZkne)) && RISCV_getFeatureBits(Inst->csh->mode, RISCV_Feature64Bit)); + case 26: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZbb)); + case 27: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZbb) || RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZbkb)); + case 28: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZbkb)); + case 29: + return ((RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZbb) || RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZbkb)) && !RISCV_getFeatureBits(Inst->csh->mode, RISCV_Feature64Bit)); + case 30: + return ((RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZbb) || RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZbkb)) && RISCV_getFeatureBits(Inst->csh->mode, RISCV_Feature64Bit)); + case 31: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZicbop)); + case 32: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZba) && RISCV_getFeatureBits(Inst->csh->mode, RISCV_Feature64Bit)); + case 33: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZbb) && RISCV_getFeatureBits(Inst->csh->mode, RISCV_Feature64Bit)); + case 34: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureVendorXCVbitmanip) && !RISCV_getFeatureBits(Inst->csh->mode, RISCV_Feature64Bit)); + case 35: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtA)); + case 36: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtA) && RISCV_getFeatureBits(Inst->csh->mode, RISCV_Feature64Bit)); + case 37: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZacas)); + case 38: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZacas) && RISCV_getFeatureBits(Inst->csh->mode, RISCV_Feature64Bit)); + case 39: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZicfiss)); + case 40: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZicfiss) && RISCV_getFeatureBits(Inst->csh->mode, RISCV_Feature64Bit)); + case 41: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtM) || RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZmmul)); + case 42: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtM)); + case 43: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZbb) && !RISCV_getFeatureBits(Inst->csh->mode, RISCV_Feature64Bit)); + case 44: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZbc) || RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZbkc)); + case 45: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZbc)); + case 46: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZicond)); + case 47: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZknh) && !RISCV_getFeatureBits(Inst->csh->mode, RISCV_Feature64Bit)); + case 48: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZba)); + case 49: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZkne) && !RISCV_getFeatureBits(Inst->csh->mode, RISCV_Feature64Bit)); + case 50: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZbkx)); + case 51: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZknd) && !RISCV_getFeatureBits(Inst->csh->mode, RISCV_Feature64Bit)); + case 52: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZksed)); + case 53: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZkne) && RISCV_getFeatureBits(Inst->csh->mode, RISCV_Feature64Bit)); + case 54: + return ((RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtM) || RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZmmul)) && RISCV_getFeatureBits(Inst->csh->mode, RISCV_Feature64Bit)); + case 55: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtM) && RISCV_getFeatureBits(Inst->csh->mode, RISCV_Feature64Bit)); + case 56: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZbkb) && RISCV_getFeatureBits(Inst->csh->mode, RISCV_Feature64Bit)); + case 57: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZfh)); + case 58: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZfa)); + case 59: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZfa) && RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtD)); + case 60: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZfa) && RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZfh)); + case 61: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZfhmin)); + case 62: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZfbfmin)); + case 63: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZfhmin) && RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtD)); + case 64: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZfa) && RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtD) && !RISCV_getFeatureBits(Inst->csh->mode, RISCV_Feature64Bit)); + case 65: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtF) && RISCV_getFeatureBits(Inst->csh->mode, RISCV_Feature64Bit)); + case 66: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtD) && RISCV_getFeatureBits(Inst->csh->mode, RISCV_Feature64Bit)); + case 67: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZfh) && RISCV_getFeatureBits(Inst->csh->mode, RISCV_Feature64Bit)); + case 68: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZfa) && (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZfh) || RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZvfh))); + case 69: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZvkb)); + case 70: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZvbb)); + case 71: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZve32f)); + case 72: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZvfbfmin)); + case 73: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZvfbfwma)); + case 74: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZvbc)); + case 75: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZawrs)); + case 76: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtSvinval)); + case 77: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtH)); + case 78: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_Feature64Bit) && RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtH)); + case 79: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZimop)); + case 80: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZvksh)); + case 81: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZvksed)); + case 82: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZvkned)); + case 83: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZvkg)); + case 84: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZvknha) || RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZvknhb)); + case 85: + return ((RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZcf) || RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZce)) && RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtF) && !RISCV_getFeatureBits(Inst->csh->mode, RISCV_Feature64Bit)); + case 86: + return ((RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtC) || RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZca)) && !RISCV_getFeatureBits(Inst->csh->mode, RISCV_Feature64Bit)); + case 87: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZacas) && !RISCV_getFeatureBits(Inst->csh->mode, RISCV_Feature64Bit)); + case 88: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZdinx) && !RISCV_getFeatureBits(Inst->csh->mode, RISCV_Feature64Bit)); + case 89: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZhinxmin) && RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZdinx) && !RISCV_getFeatureBits(Inst->csh->mode, RISCV_Feature64Bit)); + case 90: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZcmp)); + case 91: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZcmt)); + case 92: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZfinx)); + case 93: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZdinx) && RISCV_getFeatureBits(Inst->csh->mode, RISCV_Feature64Bit)); + case 94: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZhinx)); + case 95: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZhinxmin)); + case 96: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZhinxmin) && RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZdinx) && RISCV_getFeatureBits(Inst->csh->mode, RISCV_Feature64Bit)); + case 97: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZfinx) && RISCV_getFeatureBits(Inst->csh->mode, RISCV_Feature64Bit)); + case 98: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZdinx) && RISCV_getFeatureBits(Inst->csh->mode, RISCV_Feature64Bit) && RISCV_getFeatureBits(Inst->csh->mode, RISCV_Feature64Bit)); + case 99: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZhinx) && RISCV_getFeatureBits(Inst->csh->mode, RISCV_Feature64Bit)); + case 100: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureVendorXCValu)); + case 101: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureVendorXCVbi) && !RISCV_getFeatureBits(Inst->csh->mode, RISCV_Feature64Bit)); + case 102: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureVendorXCVelw) && !RISCV_getFeatureBits(Inst->csh->mode, RISCV_Feature64Bit)); + case 103: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureVendorXCVmac) && !RISCV_getFeatureBits(Inst->csh->mode, RISCV_Feature64Bit)); + case 104: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureVendorXCVmem) && !RISCV_getFeatureBits(Inst->csh->mode, RISCV_Feature64Bit)); + case 105: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureVendorXCVsimd) && !RISCV_getFeatureBits(Inst->csh->mode, RISCV_Feature64Bit)); + case 106: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureVendorXSfvcp)); + case 107: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureVendorXSfvfnrclipxfqf)); + case 108: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureVendorXSfvfwmaccqqq)); + case 109: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureVendorXSfvqmaccdod)); + case 110: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureVendorXSfvqmaccqoq)); + case 111: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureVendorXTHeadBa)); + case 112: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureVendorXTHeadBb)); + case 113: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureVendorXTHeadBb) && RISCV_getFeatureBits(Inst->csh->mode, RISCV_Feature64Bit)); + case 114: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureVendorXTHeadBs)); + case 115: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureVendorXTHeadCmo)); + case 116: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureVendorXTHeadCondMov)); + case 117: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureVendorXTHeadFMemIdx) && RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtF)); + case 118: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureVendorXTHeadFMemIdx) && RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtF) && RISCV_getFeatureBits(Inst->csh->mode, RISCV_Feature64Bit)); + case 119: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureVendorXTHeadFMemIdx) && RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtD)); + case 120: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureVendorXTHeadFMemIdx) && RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtD) && RISCV_getFeatureBits(Inst->csh->mode, RISCV_Feature64Bit)); + case 121: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureVendorXTHeadMac)); + case 122: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureVendorXTHeadMac) && RISCV_getFeatureBits(Inst->csh->mode, RISCV_Feature64Bit)); + case 123: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureVendorXTHeadMemIdx)); + case 124: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureVendorXTHeadMemIdx) && RISCV_getFeatureBits(Inst->csh->mode, RISCV_Feature64Bit)); + case 125: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureVendorXTHeadMemPair)); + case 126: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureVendorXTHeadMemPair) && RISCV_getFeatureBits(Inst->csh->mode, RISCV_Feature64Bit)); + case 127: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureVendorXTHeadSync)); + case 128: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureVendorXTHeadVdot)); + case 129: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_Feature64Bit) && RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureVendorXVentanaCondOps)); + case 130: + return (RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZicfiss) && RISCV_getFeatureBits(Inst->csh->mode, RISCV_FeatureStdExtZcmop)); } } #define DecodeToMCInst(fname, fieldname, InsnType) \ static DecodeStatus fname(DecodeStatus S, unsigned Idx, InsnType insn, MCInst *MI, \ - uint64_t Address, const void *Decoder,\ - bool *DecodeComplete) {\ - *DecodeComplete = true;\ + uint64_t Address, const void *Decoder, bool *DecodeComplete) \ +{ \ + *DecodeComplete = true; \ InsnType tmp; \ switch (Idx) { \ - default: CS_ASSERT(0 && "Invalid index!");\ + default: CS_ASSERT_RET_VAL(0 && "Invalid index!", MCDisassembler_Fail); \ case 0: \ return S; \ case 1: \ tmp = fieldname(insn, 2, 3); \ - if (DecodeGPRCRegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - tmp = 0; \ + if (!Check(&S, DecodeGPRCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = 0x0; \ tmp |= fieldname(insn, 5, 1) << 3; \ tmp |= fieldname(insn, 6, 1) << 2; \ tmp |= fieldname(insn, 7, 4) << 6; \ tmp |= fieldname(insn, 11, 2) << 4; \ - if (decodeUImmNonZeroOperand(MI, tmp, Address, Decoder, 10) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, decodeUImmNonZeroOperand_10(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ return S; \ case 2: \ + if (!Check(&S, decodeRVCInstrRdRs1ImmZero(MI, insn, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 3: \ + tmp = 0x0; \ + tmp |= fieldname(insn, 2, 5) << 0; \ + tmp |= fieldname(insn, 12, 1) << 5; \ + if (!Check(&S, decodeSImmNonZeroOperand_6(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 4: \ tmp = fieldname(insn, 7, 5); \ - if (DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ tmp = fieldname(insn, 7, 5); \ - if (DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - tmp = 0; \ + if (!Check(&S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = 0x0; \ tmp |= fieldname(insn, 2, 5) << 0; \ tmp |= fieldname(insn, 12, 1) << 5; \ - if (decodeSImmOperand(MI, tmp, Address, Decoder, 6) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, decodeSImmNonZeroOperand_6(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ return S; \ - case 3: \ + case 5: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 6: \ + if (!Check(&S, decodeRVCInstrRdRs1UImm(MI, insn, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 7: \ tmp = fieldname(insn, 7, 5); \ - if (DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ tmp = fieldname(insn, 7, 5); \ - if (DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - tmp = 0; \ + if (!Check(&S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = 0x0; \ tmp |= fieldname(insn, 2, 5) << 0; \ tmp |= fieldname(insn, 12, 1) << 5; \ - if (decodeUImmOperand(MI, tmp, Address, Decoder, 6) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, decodeUImmLog2XLenNonZeroOperand(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ return S; \ - case 4: \ + case 8: \ tmp = fieldname(insn, 2, 3); \ - if (DecodeFPR64CRegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeFPR64CRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ tmp = fieldname(insn, 7, 3); \ - if (DecodeGPRCRegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - tmp = 0; \ + if (!Check(&S, DecodeGPRCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = 0x0; \ tmp |= fieldname(insn, 5, 2) << 6; \ tmp |= fieldname(insn, 10, 3) << 3; \ - if (decodeUImmOperand(MI, tmp, Address, Decoder, 8) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, decodeUImmOperand_8(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ return S; \ - case 5: \ + case 9: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = 0x0; \ + tmp |= fieldname(insn, 2, 5) << 0; \ + tmp |= fieldname(insn, 12, 1) << 5; \ + if (!Check(&S, decodeSImmOperand_6(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 10: \ tmp = fieldname(insn, 7, 5); \ - if (DecodeFPR64RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - tmp = 0; \ + if (!Check(&S, DecodeFPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = 0x0; \ tmp |= fieldname(insn, 2, 3) << 6; \ tmp |= fieldname(insn, 5, 2) << 3; \ tmp |= fieldname(insn, 12, 1) << 5; \ - if (decodeUImmOperand(MI, tmp, Address, Decoder, 9) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, decodeUImmOperand_9(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ return S; \ - case 6: \ + case 11: \ tmp = fieldname(insn, 2, 3); \ - if (DecodeGPRCRegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeGPRCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ tmp = fieldname(insn, 7, 3); \ - if (DecodeGPRCRegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - tmp = 0; \ + if (!Check(&S, DecodeGPRCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = 0x0; \ tmp |= fieldname(insn, 5, 1) << 6; \ tmp |= fieldname(insn, 6, 1) << 2; \ tmp |= fieldname(insn, 10, 3) << 3; \ - if (decodeUImmOperand(MI, tmp, Address, Decoder, 7) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, decodeUImmOperand_7(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ return S; \ - case 7: \ + case 12: \ + if (!Check(&S, decodeRVCInstrRdSImm(MI, insn, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 13: \ tmp = fieldname(insn, 7, 5); \ - if (DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - tmp = 0; \ + if (!Check(&S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = 0x0; \ tmp |= fieldname(insn, 2, 5) << 0; \ tmp |= fieldname(insn, 12, 1) << 5; \ - if (decodeSImmOperand(MI, tmp, Address, Decoder, 6) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, decodeSImmOperand_6(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ return S; \ - case 8: \ + case 14: \ tmp = fieldname(insn, 7, 5); \ - if (DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - tmp = 0; \ + if (!Check(&S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = 0x0; \ tmp |= fieldname(insn, 2, 2) << 6; \ tmp |= fieldname(insn, 4, 3) << 2; \ tmp |= fieldname(insn, 12, 1) << 5; \ - if (decodeUImmOperand(MI, tmp, Address, Decoder, 8) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, decodeUImmOperand_8(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ return S; \ - case 9: \ + case 15: \ tmp = fieldname(insn, 2, 3); \ - if (DecodeGPRCRegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeGPRCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ tmp = fieldname(insn, 7, 3); \ - if (DecodeGPRCRegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - tmp = 0; \ + if (!Check(&S, DecodeGPRCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = 0x0; \ tmp |= fieldname(insn, 5, 2) << 6; \ tmp |= fieldname(insn, 10, 3) << 3; \ - if (decodeUImmOperand(MI, tmp, Address, Decoder, 8) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, decodeUImmOperand_8(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ return S; \ - case 10: \ - tmp = 0; \ + case 16: \ + tmp = 0x0; \ tmp |= fieldname(insn, 2, 1) << 5; \ tmp |= fieldname(insn, 3, 2) << 7; \ tmp |= fieldname(insn, 5, 1) << 6; \ tmp |= fieldname(insn, 6, 1) << 4; \ tmp |= fieldname(insn, 12, 1) << 9; \ - if (decodeSImmNonZeroOperand(MI, tmp, Address, Decoder, 10) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, decodeSImmNonZeroOperand_10(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ return S; \ - case 11: \ + case 17: \ tmp = fieldname(insn, 7, 5); \ - if (DecodeGPRNoX0X2RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - tmp = 0; \ + if (!Check(&S, DecodeGPRNoX0X2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = 0x0; \ tmp |= fieldname(insn, 2, 5) << 0; \ tmp |= fieldname(insn, 12, 1) << 5; \ - if (decodeCLUIImmOperand(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, decodeCLUIImmOperand(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ return S; \ - case 12: \ + case 18: \ tmp = fieldname(insn, 7, 5); \ - if (DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - tmp = 0; \ + if (!Check(&S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = 0x0; \ tmp |= fieldname(insn, 2, 3) << 6; \ tmp |= fieldname(insn, 5, 2) << 3; \ tmp |= fieldname(insn, 12, 1) << 5; \ - if (decodeUImmOperand(MI, tmp, Address, Decoder, 9) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, decodeUImmOperand_9(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ return S; \ - case 13: \ + case 19: \ + tmp = fieldname(insn, 2, 3); \ + if (!Check(&S, DecodeGPRCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 7, 3); \ + if (!Check(&S, DecodeGPRCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = 0x0; \ + tmp |= fieldname(insn, 5, 1) << 1; \ + tmp |= fieldname(insn, 6, 1) << 0; \ + if (!Check(&S, decodeUImmOperand_2(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 20: \ + tmp = fieldname(insn, 2, 3); \ + if (!Check(&S, DecodeGPRCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 7, 3); \ + if (!Check(&S, DecodeGPRCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 5, 1) << 1; \ + if (!Check(&S, decodeUImmOperand_2(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 21: \ + tmp = fieldname(insn, 7, 3); \ + if (!Check(&S, DecodeGPRCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 7, 3); \ + if (!Check(&S, DecodeGPRCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 22: \ tmp = fieldname(insn, 7, 3); \ - if (DecodeGPRCRegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeGPRCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ tmp = fieldname(insn, 7, 3); \ - if (DecodeGPRCRegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - tmp = 0; \ + if (!Check(&S, DecodeGPRCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = 0x0; \ tmp |= fieldname(insn, 2, 5) << 0; \ tmp |= fieldname(insn, 12, 1) << 5; \ - if (decodeUImmOperand(MI, tmp, Address, Decoder, 6) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, decodeUImmLog2XLenNonZeroOperand(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ return S; \ - case 14: \ + case 23: \ tmp = fieldname(insn, 7, 3); \ - if (DecodeGPRCRegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeGPRCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ tmp = fieldname(insn, 7, 3); \ - if (DecodeGPRCRegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - tmp = 0; \ + if (!Check(&S, DecodeGPRCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = 0x0; \ tmp |= fieldname(insn, 2, 5) << 0; \ tmp |= fieldname(insn, 12, 1) << 5; \ - if (decodeSImmOperand(MI, tmp, Address, Decoder, 6) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, decodeSImmOperand_6(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ return S; \ - case 15: \ + case 24: \ tmp = fieldname(insn, 7, 3); \ - if (DecodeGPRCRegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeGPRCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ tmp = fieldname(insn, 7, 3); \ - if (DecodeGPRCRegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeGPRCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ tmp = fieldname(insn, 2, 3); \ - if (DecodeGPRCRegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeGPRCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ return S; \ - case 16: \ + case 25: \ tmp = fieldname(insn, 7, 5); \ - if (DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ return S; \ - case 17: \ + case 26: \ + if (!Check(&S, decodeRVCInstrRdRs2(MI, insn, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 27: \ tmp = fieldname(insn, 7, 5); \ - if (DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ tmp = fieldname(insn, 2, 5); \ - if (DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ return S; \ - case 18: \ + case 28: \ + if (!Check(&S, decodeRVCInstrRdRs1Rs2(MI, insn, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 29: \ tmp = fieldname(insn, 7, 5); \ - if (DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ tmp = fieldname(insn, 7, 5); \ - if (DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ tmp = fieldname(insn, 2, 5); \ - if (DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ return S; \ - case 19: \ - tmp = 0; \ + case 30: \ + tmp = 0x0; \ tmp |= fieldname(insn, 2, 1) << 4; \ tmp |= fieldname(insn, 3, 3) << 0; \ tmp |= fieldname(insn, 6, 1) << 6; \ @@ -1284,496 +7742,1610 @@ static DecodeStatus fname(DecodeStatus S, unsigned Idx, InsnType insn, MCInst *M tmp |= fieldname(insn, 9, 2) << 7; \ tmp |= fieldname(insn, 11, 1) << 3; \ tmp |= fieldname(insn, 12, 1) << 10; \ - if (decodeSImmOperandAndLsl1(MI, tmp, Address, Decoder, 12) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, decodeSImmOperandAndLsl1_12(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ return S; \ - case 20: \ + case 31: \ tmp = fieldname(insn, 2, 5); \ - if (DecodeFPR64RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - tmp = 0; \ + if (!Check(&S, DecodeFPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = 0x0; \ tmp |= fieldname(insn, 7, 3) << 6; \ tmp |= fieldname(insn, 10, 3) << 3; \ - if (decodeUImmOperand(MI, tmp, Address, Decoder, 9) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, decodeUImmOperand_9(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ return S; \ - case 21: \ + case 32: \ tmp = fieldname(insn, 7, 3); \ - if (DecodeGPRCRegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - tmp = 0; \ + if (!Check(&S, DecodeGPRCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = 0x0; \ tmp |= fieldname(insn, 2, 1) << 4; \ tmp |= fieldname(insn, 3, 2) << 0; \ tmp |= fieldname(insn, 5, 2) << 5; \ tmp |= fieldname(insn, 10, 2) << 2; \ tmp |= fieldname(insn, 12, 1) << 7; \ - if (decodeSImmOperandAndLsl1(MI, tmp, Address, Decoder, 9) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, decodeSImmOperandAndLsl1_9(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ return S; \ - case 22: \ + case 33: \ tmp = fieldname(insn, 2, 5); \ - if (DecodeGPRRegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - tmp = 0; \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = 0x0; \ tmp |= fieldname(insn, 7, 2) << 6; \ tmp |= fieldname(insn, 9, 4) << 2; \ - if (decodeUImmOperand(MI, tmp, Address, Decoder, 8) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, decodeUImmOperand_8(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ return S; \ - case 23: \ + case 34: \ tmp = fieldname(insn, 2, 5); \ - if (DecodeGPRRegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - tmp = 0; \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = 0x0; \ tmp |= fieldname(insn, 7, 3) << 6; \ tmp |= fieldname(insn, 10, 3) << 3; \ - if (decodeUImmOperand(MI, tmp, Address, Decoder, 9) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - return S; \ - case 24: \ - tmp = fieldname(insn, 7, 5); \ - if (DecodeGPRRegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - tmp = fieldname(insn, 15, 5); \ - if (DecodeGPRRegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - tmp = fieldname(insn, 20, 12); \ - if (decodeSImmOperand(MI, tmp, Address, Decoder, 12) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - return S; \ - case 25: \ - tmp = fieldname(insn, 7, 5); \ - if (DecodeFPR32RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - tmp = fieldname(insn, 15, 5); \ - if (DecodeGPRRegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - tmp = fieldname(insn, 20, 12); \ - if (decodeSImmOperand(MI, tmp, Address, Decoder, 12) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - return S; \ - case 26: \ - tmp = fieldname(insn, 7, 5); \ - if (DecodeFPR64RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - tmp = fieldname(insn, 15, 5); \ - if (DecodeGPRRegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - tmp = fieldname(insn, 20, 12); \ - if (decodeSImmOperand(MI, tmp, Address, Decoder, 12) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - return S; \ - case 27: \ - tmp = fieldname(insn, 24, 4); \ - if (decodeUImmOperand(MI, tmp, Address, Decoder, 4) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - tmp = fieldname(insn, 20, 4); \ - if (decodeUImmOperand(MI, tmp, Address, Decoder, 4) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - return S; \ - case 28: \ - tmp = fieldname(insn, 7, 5); \ - if (DecodeGPRRegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - tmp = fieldname(insn, 15, 5); \ - if (DecodeGPRRegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - tmp = fieldname(insn, 20, 6); \ - if (decodeUImmOperand(MI, tmp, Address, Decoder, 6) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - return S; \ - case 29: \ - tmp = fieldname(insn, 7, 5); \ - if (DecodeGPRRegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - tmp = fieldname(insn, 12, 20); \ - if (decodeUImmOperand(MI, tmp, Address, Decoder, 20) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - return S; \ - case 30: \ - tmp = fieldname(insn, 7, 5); \ - if (DecodeGPRRegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - tmp = fieldname(insn, 15, 5); \ - if (DecodeGPRRegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - tmp = fieldname(insn, 20, 5); \ - if (decodeUImmOperand(MI, tmp, Address, Decoder, 5) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - return S; \ - case 31: \ - tmp = fieldname(insn, 20, 5); \ - if (DecodeGPRRegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - tmp = fieldname(insn, 15, 5); \ - if (DecodeGPRRegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - tmp = 0; \ - tmp |= fieldname(insn, 7, 5) << 0; \ - tmp |= fieldname(insn, 25, 7) << 5; \ - if (decodeSImmOperand(MI, tmp, Address, Decoder, 12) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - return S; \ - case 32: \ - tmp = fieldname(insn, 20, 5); \ - if (DecodeFPR32RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - tmp = fieldname(insn, 15, 5); \ - if (DecodeGPRRegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - tmp = 0; \ - tmp |= fieldname(insn, 7, 5) << 0; \ - tmp |= fieldname(insn, 25, 7) << 5; \ - if (decodeSImmOperand(MI, tmp, Address, Decoder, 12) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - return S; \ - case 33: \ - tmp = fieldname(insn, 20, 5); \ - if (DecodeFPR64RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - tmp = fieldname(insn, 15, 5); \ - if (DecodeGPRRegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - tmp = 0; \ - tmp |= fieldname(insn, 7, 5) << 0; \ - tmp |= fieldname(insn, 25, 7) << 5; \ - if (decodeSImmOperand(MI, tmp, Address, Decoder, 12) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - return S; \ - case 34: \ - tmp = fieldname(insn, 7, 5); \ - if (DecodeGPRRegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - tmp = fieldname(insn, 15, 5); \ - if (DecodeGPRRegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - tmp = fieldname(insn, 20, 5); \ - if (DecodeGPRRegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, decodeUImmOperand_9(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ return S; \ case 35: \ tmp = fieldname(insn, 7, 5); \ - if (DecodeGPRRegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ tmp = fieldname(insn, 15, 5); \ - if (DecodeGPRRegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 12); \ + if (!Check(&S, decodeSImmOperand_12(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ return S; \ case 36: \ tmp = fieldname(insn, 7, 5); \ - if (DecodeFPR32RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ tmp = fieldname(insn, 15, 5); \ - if (DecodeFPR32RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - tmp = fieldname(insn, 20, 5); \ - if (DecodeFPR32RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - tmp = fieldname(insn, 27, 5); \ - if (DecodeFPR32RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - tmp = fieldname(insn, 12, 3); \ - if (decodeFRMArg(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 25, 1); \ + if (!Check(&S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ return S; \ case 37: \ tmp = fieldname(insn, 7, 5); \ - if (DecodeFPR64RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ tmp = fieldname(insn, 15, 5); \ - if (DecodeFPR64RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - tmp = fieldname(insn, 20, 5); \ - if (DecodeFPR64RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - tmp = fieldname(insn, 27, 5); \ - if (DecodeFPR64RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - tmp = fieldname(insn, 12, 3); \ - if (decodeFRMArg(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ return S; \ case 38: \ tmp = fieldname(insn, 7, 5); \ - if (DecodeFPR32RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ tmp = fieldname(insn, 15, 5); \ - if (DecodeFPR32RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ tmp = fieldname(insn, 20, 5); \ - if (DecodeFPR32RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - tmp = fieldname(insn, 12, 3); \ - if (decodeFRMArg(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 25, 1); \ + if (!Check(&S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ return S; \ case 39: \ tmp = fieldname(insn, 7, 5); \ - if (DecodeFPR64RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ tmp = fieldname(insn, 15, 5); \ - if (DecodeFPR64RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ tmp = fieldname(insn, 20, 5); \ - if (DecodeFPR64RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - tmp = fieldname(insn, 12, 3); \ - if (decodeFRMArg(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 25, 1); \ + if (!Check(&S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ return S; \ case 40: \ tmp = fieldname(insn, 7, 5); \ - if (DecodeFPR32RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeVRM2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ tmp = fieldname(insn, 15, 5); \ - if (DecodeFPR32RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - tmp = fieldname(insn, 20, 5); \ - if (DecodeFPR32RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ return S; \ case 41: \ tmp = fieldname(insn, 7, 5); \ - if (DecodeFPR64RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeVRM4RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ tmp = fieldname(insn, 15, 5); \ - if (DecodeFPR64RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - tmp = fieldname(insn, 20, 5); \ - if (DecodeFPR64RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ return S; \ case 42: \ tmp = fieldname(insn, 7, 5); \ - if (DecodeFPR32RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeVRM8RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ tmp = fieldname(insn, 15, 5); \ - if (DecodeFPR64RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - tmp = fieldname(insn, 12, 3); \ - if (decodeFRMArg(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ return S; \ case 43: \ tmp = fieldname(insn, 7, 5); \ - if (DecodeFPR64RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeFPR16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ tmp = fieldname(insn, 15, 5); \ - if (DecodeFPR32RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 12); \ + if (!Check(&S, decodeSImmOperand_12(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ return S; \ case 44: \ tmp = fieldname(insn, 7, 5); \ - if (DecodeFPR32RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ tmp = fieldname(insn, 15, 5); \ - if (DecodeFPR32RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - tmp = fieldname(insn, 12, 3); \ - if (decodeFRMArg(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 12); \ + if (!Check(&S, decodeSImmOperand_12(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ return S; \ case 45: \ tmp = fieldname(insn, 7, 5); \ - if (DecodeFPR64RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeFPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ tmp = fieldname(insn, 15, 5); \ - if (DecodeFPR64RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 12); \ + if (!Check(&S, decodeSImmOperand_12(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 46: \ + tmp = fieldname(insn, 24, 4); \ + if (!Check(&S, decodeUImmOperand_4(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 4); \ + if (!Check(&S, decodeUImmOperand_4(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 47: \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 48: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 6); \ + if (!Check(&S, decodeUImmLog2XLenOperand(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 49: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 50: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 4); \ + if (!Check(&S, decodeUImmOperand_4(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 51: \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 25, 7) << 5; \ + if (!Check(&S, decodeSImmOperand_12(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 52: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 12, 20); \ + if (!Check(&S, decodeUImmOperand_20(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 53: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, decodeUImmOperand_5(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 54: \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = 0x0; \ + tmp |= fieldname(insn, 7, 5) << 0; \ + tmp |= fieldname(insn, 25, 7) << 5; \ + if (!Check(&S, decodeSImmOperand_12(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 55: \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeFPR16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = 0x0; \ + tmp |= fieldname(insn, 7, 5) << 0; \ + tmp |= fieldname(insn, 25, 7) << 5; \ + if (!Check(&S, decodeSImmOperand_12(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 56: \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = 0x0; \ + tmp |= fieldname(insn, 7, 5) << 0; \ + tmp |= fieldname(insn, 25, 7) << 5; \ + if (!Check(&S, decodeSImmOperand_12(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 57: \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeFPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = 0x0; \ + tmp |= fieldname(insn, 7, 5) << 0; \ + tmp |= fieldname(insn, 25, 7) << 5; \ + if (!Check(&S, decodeSImmOperand_12(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 58: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 59: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 60: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 61: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 30, 2); \ + if (!Check(&S, decodeUImmOperand_2(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 62: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 27, 5); \ + if (!Check(&S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 12, 3); \ + if (!Check(&S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 63: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeFPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeFPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeFPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 27, 5); \ + if (!Check(&S, DecodeFPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 12, 3); \ + if (!Check(&S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 64: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeFPR16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeFPR16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeFPR16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 27, 5); \ + if (!Check(&S, DecodeFPR16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 12, 3); \ + if (!Check(&S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 65: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 12, 3); \ + if (!Check(&S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 66: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeFPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeFPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeFPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 12, 3); \ + if (!Check(&S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 67: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeFPR16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeFPR16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeFPR16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 12, 3); \ + if (!Check(&S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 68: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 69: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeFPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeFPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeFPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 70: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeFPR16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeFPR16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeFPR16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 71: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeFPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 12, 3); \ + if (!Check(&S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 72: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeFPR16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 12, 3); \ + if (!Check(&S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 73: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 12, 3); \ + if (!Check(&S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 74: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeFPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 12, 3); \ + if (!Check(&S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 75: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeFPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeFPR16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 12, 3); \ + if (!Check(&S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 76: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeFPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeFPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 12, 3); \ + if (!Check(&S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 77: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeFPR16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 12, 3); \ + if (!Check(&S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 78: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeFPR16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeFPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 12, 3); \ + if (!Check(&S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 79: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeFPR16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeFPR16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 12, 3); \ + if (!Check(&S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 80: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 81: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeFPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeFPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 82: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeFPR16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeFPR16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 83: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeFPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 84: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 12, 3); \ + if (!Check(&S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 85: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeFPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 12, 3); \ + if (!Check(&S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 86: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeFPR16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 12, 3); \ + if (!Check(&S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 87: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 12, 3); \ + if (!Check(&S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 88: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeFPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 12, 3); \ + if (!Check(&S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 89: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeFPR16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 12, 3); \ + if (!Check(&S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 90: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 91: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeFPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 92: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeFPR16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 93: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 94: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + MCOperand_CreateImm0(MI, tmp); \ + return S; \ + case 95: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeFPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 96: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeFPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + MCOperand_CreateImm0(MI, tmp); \ + return S; \ + case 97: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeFPR16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 98: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeFPR16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + MCOperand_CreateImm0(MI, tmp); \ + return S; \ + case 99: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 25, 1); \ + if (!Check(&S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 100: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 101: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 102: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 103: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 25, 1); \ + if (!Check(&S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 104: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 25, 1); \ + if (!Check(&S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 105: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 106: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 25, 1); \ + if (!Check(&S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 107: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 25, 1); \ + if (!Check(&S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 108: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, decodeSImmOperand_5(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 25, 1); \ + if (!Check(&S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 109: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, decodeUImmOperand_5(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 25, 1); \ + if (!Check(&S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 110: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, decodeSImmOperand_5(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 111: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = 0x0; \ + tmp |= fieldname(insn, 15, 5) << 0; \ + tmp |= fieldname(insn, 26, 1) << 5; \ + if (!Check(&S, decodeUImmOperand_6(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 25, 1); \ + if (!Check(&S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 112: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, decodeSImmOperand_5(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 113: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 114: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeVRM2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeVRM2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 115: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeVRM4RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeVRM4RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 116: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeVRM8RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeVRM8RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 117: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 25, 1); \ + if (!Check(&S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 118: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 119: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 25, 1); \ + if (!Check(&S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 120: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 121: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 122: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 123: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 25, 1); \ + if (!Check(&S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 124: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 125: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 25, 1); \ + if (!Check(&S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 126: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 11); \ + if (!Check(&S, decodeUImmOperand_11(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 127: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, decodeUImmOperand_5(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 10); \ + if (!Check(&S, decodeUImmOperand_10(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 128: \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = 0x0; \ + tmp |= fieldname(insn, 7, 1) << 10; \ + tmp |= fieldname(insn, 8, 4) << 0; \ + tmp |= fieldname(insn, 25, 6) << 4; \ + tmp |= fieldname(insn, 31, 1) << 11; \ + if (!Check(&S, decodeSImmOperandAndLsl1_13(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 129: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = 0x0; \ + tmp |= fieldname(insn, 12, 8) << 11; \ + tmp |= fieldname(insn, 20, 1) << 10; \ + tmp |= fieldname(insn, 21, 10) << 0; \ + tmp |= fieldname(insn, 31, 1) << 19; \ + if (!Check(&S, decodeSImmOperandAndLsl1_21(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 130: \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 131: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 12); \ + if (!Check(&S, decodeUImmOperand_12(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 132: \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 133: \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRX1X5RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 134: \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeGPRX1X5RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 135: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 12); \ + if (!Check(&S, decodeUImmOperand_12(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, decodeUImmOperand_5(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 136: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, decodeUImmOperand_5(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 137: \ + tmp = fieldname(insn, 2, 3); \ + if (!Check(&S, DecodeFPR32CRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 7, 3); \ + if (!Check(&S, DecodeGPRCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = 0x0; \ + tmp |= fieldname(insn, 5, 1) << 6; \ + tmp |= fieldname(insn, 6, 1) << 2; \ + tmp |= fieldname(insn, 10, 3) << 3; \ + if (!Check(&S, decodeUImmOperand_7(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 138: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = 0x0; \ + tmp |= fieldname(insn, 2, 2) << 6; \ + tmp |= fieldname(insn, 4, 3) << 2; \ + tmp |= fieldname(insn, 12, 1) << 5; \ + if (!Check(&S, decodeUImmOperand_8(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 139: \ + tmp = fieldname(insn, 2, 5); \ + if (!Check(&S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = 0x0; \ + tmp |= fieldname(insn, 7, 2) << 6; \ + tmp |= fieldname(insn, 9, 4) << 2; \ + if (!Check(&S, decodeUImmOperand_8(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 140: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 27, 5); \ + if (!Check(&S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ tmp = fieldname(insn, 12, 3); \ - if (decodeFRMArg(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ return S; \ - case 46: \ + case 141: \ tmp = fieldname(insn, 7, 5); \ - if (DecodeGPRRegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ tmp = fieldname(insn, 15, 5); \ - if (DecodeFPR32RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ tmp = fieldname(insn, 20, 5); \ - if (DecodeFPR32RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 12, 3); \ + if (!Check(&S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ return S; \ - case 47: \ + case 142: \ tmp = fieldname(insn, 7, 5); \ - if (DecodeGPRRegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ tmp = fieldname(insn, 15, 5); \ - if (DecodeFPR64RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ tmp = fieldname(insn, 20, 5); \ - if (DecodeFPR64RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ return S; \ - case 48: \ + case 143: \ tmp = fieldname(insn, 7, 5); \ - if (DecodeGPRRegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ tmp = fieldname(insn, 15, 5); \ - if (DecodeFPR32RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ tmp = fieldname(insn, 12, 3); \ - if (decodeFRMArg(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ return S; \ - case 49: \ + case 144: \ tmp = fieldname(insn, 7, 5); \ - if (DecodeGPRRegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ tmp = fieldname(insn, 15, 5); \ - if (DecodeFPR64RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ tmp = fieldname(insn, 12, 3); \ - if (decodeFRMArg(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ return S; \ - case 50: \ + case 145: \ tmp = fieldname(insn, 7, 5); \ - if (DecodeFPR32RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ tmp = fieldname(insn, 15, 5); \ - if (DecodeGPRRegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ tmp = fieldname(insn, 12, 3); \ - if (decodeFRMArg(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ return S; \ - case 51: \ + case 146: \ tmp = fieldname(insn, 7, 5); \ - if (DecodeFPR64RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ tmp = fieldname(insn, 15, 5); \ - if (DecodeGPRRegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ return S; \ - case 52: \ + case 147: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 148: \ + tmp = fieldname(insn, 7, 3); \ + if (!Check(&S, DecodeSR07RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 2, 3); \ + if (!Check(&S, DecodeSR07RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 149: \ + tmp = fieldname(insn, 4, 4); \ + if (!Check(&S, decodeZcmpRlist(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 2, 2) << 4; \ + if (!Check(&S, decodeZcmpSpimm(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 150: \ + tmp = fieldname(insn, 2, 5); \ + if (!Check(&S, decodeUImmOperand_5(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 151: \ + tmp = fieldname(insn, 2, 8); \ + if (!Check(&S, decodeUImmOperand_8(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 152: \ tmp = fieldname(insn, 7, 5); \ - if (DecodeFPR64RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ tmp = fieldname(insn, 15, 5); \ - if (DecodeGPRRegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 27, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ tmp = fieldname(insn, 12, 3); \ - if (decodeFRMArg(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ return S; \ - case 53: \ + case 153: \ tmp = fieldname(insn, 7, 5); \ - if (DecodeGPRRegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ tmp = fieldname(insn, 15, 5); \ - if (DecodeFPR32RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 12, 3); \ + if (!Check(&S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ return S; \ - case 54: \ + case 154: \ tmp = fieldname(insn, 7, 5); \ - if (DecodeGPRRegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ tmp = fieldname(insn, 15, 5); \ - if (DecodeFPR64RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 12, 3); \ + if (!Check(&S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ return S; \ - case 55: \ + case 155: \ tmp = fieldname(insn, 7, 5); \ - if (DecodeFPR32RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ tmp = fieldname(insn, 15, 5); \ - if (DecodeGPRRegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 25, 5); \ + if (!Check(&S, decodeUImmOperand_5(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ return S; \ - case 56: \ + case 156: \ tmp = fieldname(insn, 15, 5); \ - if (DecodeGPRRegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ tmp = fieldname(insn, 20, 5); \ - if (DecodeGPRRegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - tmp = 0; \ + if (!Check(&S, decodeSImmOperand_5(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = 0x0; \ tmp |= fieldname(insn, 7, 1) << 10; \ tmp |= fieldname(insn, 8, 4) << 0; \ tmp |= fieldname(insn, 25, 6) << 4; \ tmp |= fieldname(insn, 31, 1) << 11; \ - if (decodeSImmOperandAndLsl1(MI, tmp, Address, Decoder, 13) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, decodeSImmOperandAndLsl1_13(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ return S; \ - case 57: \ + case 157: \ tmp = fieldname(insn, 7, 5); \ - if (DecodeGPRRegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - tmp = 0; \ - tmp |= fieldname(insn, 12, 8) << 11; \ - tmp |= fieldname(insn, 20, 1) << 10; \ - tmp |= fieldname(insn, 21, 10) << 0; \ - tmp |= fieldname(insn, 31, 1) << 19; \ - if (decodeSImmOperandAndLsl1(MI, tmp, Address, Decoder, 21) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 25, 5); \ + if (!Check(&S, decodeUImmOperand_5(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, decodeUImmOperand_5(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ return S; \ - case 58: \ + case 158: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ tmp = fieldname(insn, 15, 5); \ - if (DecodeGPRRegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 25, 5); \ + if (!Check(&S, decodeUImmOperand_5(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ tmp = fieldname(insn, 20, 5); \ - if (DecodeGPRRegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, decodeUImmOperand_5(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ return S; \ - case 59: \ + case 159: \ tmp = fieldname(insn, 7, 5); \ - if (DecodeGPRRegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - tmp = fieldname(insn, 20, 12); \ - if (decodeUImmOperand(MI, tmp, Address, Decoder, 12) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 25, 5); \ + if (!Check(&S, decodeUImmOperand_2(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, decodeUImmOperand_5(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 160: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ tmp = fieldname(insn, 15, 5); \ - if (DecodeGPRRegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 25, 5); \ + if (!Check(&S, decodeUImmOperand_5(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ return S; \ - case 60: \ + case 161: \ tmp = fieldname(insn, 7, 5); \ - if (DecodeGPRRegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ tmp = fieldname(insn, 20, 12); \ - if (decodeUImmOperand(MI, tmp, Address, Decoder, 12) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, decodeSImmOperand_12(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 162: \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ tmp = fieldname(insn, 15, 5); \ - if (decodeUImmOperand(MI, tmp, Address, Decoder, 5) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = 0x0; \ + tmp |= fieldname(insn, 7, 5) << 0; \ + tmp |= fieldname(insn, 25, 7) << 5; \ + if (!Check(&S, decodeSImmOperand_12(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ return S; \ - case 61: \ - tmp = fieldname(insn, 2, 3); \ - if (DecodeFPR32CRegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - tmp = fieldname(insn, 7, 3); \ - if (DecodeGPRCRegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - tmp = 0; \ - tmp |= fieldname(insn, 5, 1) << 6; \ - tmp |= fieldname(insn, 6, 1) << 2; \ - tmp |= fieldname(insn, 10, 3) << 3; \ - if (decodeUImmOperand(MI, tmp, Address, Decoder, 7) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + case 163: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ return S; \ - case 62: \ + case 164: \ tmp = fieldname(insn, 7, 5); \ - if (DecodeFPR32RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - tmp = 0; \ - tmp |= fieldname(insn, 2, 2) << 6; \ - tmp |= fieldname(insn, 4, 3) << 2; \ - tmp |= fieldname(insn, 12, 1) << 5; \ - if (decodeUImmOperand(MI, tmp, Address, Decoder, 8) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = 0x0; \ + tmp |= fieldname(insn, 15, 5) << 5; \ + tmp |= fieldname(insn, 20, 5) << 0; \ + if (!Check(&S, decodeRegReg(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ return S; \ - case 63: \ - tmp = fieldname(insn, 2, 5); \ - if (DecodeFPR32RegisterClass(MI, tmp, Address, Decoder) == MCDisassembler_Fail) return MCDisassembler_Fail; \ - tmp = 0; \ - tmp |= fieldname(insn, 7, 2) << 6; \ - tmp |= fieldname(insn, 9, 4) << 2; \ - if (decodeUImmOperand(MI, tmp, Address, Decoder, 8) == MCDisassembler_Fail) return MCDisassembler_Fail; \ + case 165: \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 166: \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = 0x0; \ + tmp |= fieldname(insn, 7, 5) << 0; \ + tmp |= fieldname(insn, 15, 5) << 5; \ + if (!Check(&S, decodeRegReg(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 167: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = 0x0; \ + tmp |= fieldname(insn, 20, 5) << 1; \ + tmp |= fieldname(insn, 25, 1) << 0; \ + if (!Check(&S, decodeSImmOperand_6(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 168: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = 0x0; \ + tmp |= fieldname(insn, 20, 5) << 1; \ + tmp |= fieldname(insn, 25, 1) << 0; \ + if (!Check(&S, decodeUImmOperand_6(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 169: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = 0x0; \ + tmp |= fieldname(insn, 20, 5) << 1; \ + tmp |= fieldname(insn, 25, 1) << 0; \ + if (!Check(&S, decodeUImmOperand_4(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 170: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = 0x0; \ + tmp |= fieldname(insn, 20, 5) << 1; \ + tmp |= fieldname(insn, 25, 1) << 0; \ + if (!Check(&S, decodeUImmOperand_3(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 171: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = 0x0; \ + tmp |= fieldname(insn, 20, 5) << 1; \ + tmp |= fieldname(insn, 25, 1) << 0; \ + if (!Check(&S, decodeUImmOperand_6(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 172: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = 0x0; \ + tmp |= fieldname(insn, 20, 5) << 1; \ + tmp |= fieldname(insn, 25, 1) << 0; \ + if (!Check(&S, decodeSImmOperand_6(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 173: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 26, 2); \ + if (!Check(&S, decodeUImmOperand_2(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 174: \ + tmp = fieldname(insn, 26, 2); \ + if (!Check(&S, decodeUImmOperand_2(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, decodeUImmOperand_5(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 175: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 26, 2); \ + if (!Check(&S, decodeUImmOperand_2(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 176: \ + tmp = fieldname(insn, 26, 2); \ + if (!Check(&S, decodeUImmOperand_2(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 177: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 26, 2); \ + if (!Check(&S, decodeUImmOperand_2(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, decodeUImmOperand_5(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, decodeSImmOperand_5(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 178: \ + tmp = fieldname(insn, 26, 2); \ + if (!Check(&S, decodeUImmOperand_2(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, decodeUImmOperand_5(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, decodeUImmOperand_5(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, decodeSImmOperand_5(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 179: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 26, 2); \ + if (!Check(&S, decodeUImmOperand_2(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, decodeSImmOperand_5(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 180: \ + tmp = fieldname(insn, 26, 2); \ + if (!Check(&S, decodeUImmOperand_2(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, decodeUImmOperand_5(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, decodeSImmOperand_5(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 181: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 26, 2); \ + if (!Check(&S, decodeUImmOperand_2(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, decodeSImmOperand_5(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 182: \ + tmp = fieldname(insn, 26, 2); \ + if (!Check(&S, decodeUImmOperand_2(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, decodeSImmOperand_5(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 183: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 26, 2); \ + if (!Check(&S, decodeUImmOperand_2(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, decodeUImmOperand_5(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 184: \ + tmp = fieldname(insn, 26, 2); \ + if (!Check(&S, decodeUImmOperand_2(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, decodeUImmOperand_5(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, decodeUImmOperand_5(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 185: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 26, 2); \ + if (!Check(&S, decodeUImmOperand_2(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 186: \ + tmp = fieldname(insn, 26, 2); \ + if (!Check(&S, decodeUImmOperand_2(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, decodeUImmOperand_5(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 187: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 26, 2); \ + if (!Check(&S, decodeUImmOperand_2(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 188: \ + tmp = fieldname(insn, 26, 2); \ + if (!Check(&S, decodeUImmOperand_2(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 189: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 26, 1); \ + if (!Check(&S, decodeUImmOperand_1(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 190: \ + tmp = fieldname(insn, 26, 1); \ + if (!Check(&S, decodeUImmOperand_1(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, decodeUImmOperand_5(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 191: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 26, 1); \ + if (!Check(&S, decodeUImmOperand_1(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 192: \ + tmp = fieldname(insn, 26, 1); \ + if (!Check(&S, decodeUImmOperand_1(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 193: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeVRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 194: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 25, 2); \ + if (!Check(&S, decodeUImmOperand_2(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 195: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 26, 6); \ + if (!Check(&S, decodeUImmLog2XLenOperand(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 6); \ + if (!Check(&S, decodeUImmLog2XLenOperand(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 196: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 25, 2); \ + if (!Check(&S, decodeUImmOperand_2(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 197: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeFPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 25, 2); \ + if (!Check(&S, decodeUImmOperand_2(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 198: \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, decodeSImmOperand_5(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 25, 2); \ + if (!Check(&S, decodeUImmOperand_2(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 199: \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 7, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 15, 5); \ + if (!Check(&S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 20, 5); \ + if (!Check(&S, decodeSImmOperand_5(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + tmp = fieldname(insn, 25, 2); \ + if (!Check(&S, decodeUImmOperand_2(MI, tmp, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 200: \ + if (!Check(&S, decodeXTHeadMemPair(MI, insn, Address, Decoder))) { return MCDisassembler_Fail; } \ + return S; \ + case 201: \ + if (!Check(&S, decodeCSSPushPopchk(MI, insn, Address, Decoder))) { return MCDisassembler_Fail; } \ return S; \ } \ } #define DecodeInstruction(fname, fieldname, decoder, InsnType) \ -static DecodeStatus fname(const uint8_t DecodeTable[], MCInst *MI,\ - InsnType insn, uint64_t Address,\ - const void *DisAsm, int feature) {\ - uint64_t Bits = getFeatureBits(feature);\ -\ - const uint8_t *Ptr = DecodeTable;\ - uint32_t CurFieldValue = 0;\ - DecodeStatus S = MCDisassembler_Success;\ - while (true) {\ - switch (*Ptr) {\ - default:\ - return MCDisassembler_Fail;\ - case MCD_OPC_ExtractField: {\ - unsigned Start = *++Ptr;\ - unsigned Len = *++Ptr;\ - ++Ptr;\ - CurFieldValue = fieldname(insn, Start, Len);\ - break;\ - }\ - case MCD_OPC_FilterValue: {\ - unsigned Len;\ - InsnType Val = decodeULEB128(++Ptr, &Len);\ - Ptr += Len;\ - unsigned NumToSkip = *Ptr++;\ - NumToSkip |= (*Ptr++) << 8;\ - NumToSkip |= (*Ptr++) << 16;\ -\ - if (Val != CurFieldValue)\ - Ptr += NumToSkip;\ - break;\ - }\ - case MCD_OPC_CheckField: {\ - unsigned Start = *++Ptr;\ - unsigned Len = *++Ptr;\ - InsnType FieldValue = fieldname(insn, Start, Len);\ - uint32_t ExpectedValue = decodeULEB128(++Ptr, &Len);\ - Ptr += Len;\ - unsigned NumToSkip = *Ptr++;\ - NumToSkip |= (*Ptr++) << 8;\ - NumToSkip |= (*Ptr++) << 16;\ -\ - if (ExpectedValue != FieldValue)\ - Ptr += NumToSkip;\ - break;\ - }\ - case MCD_OPC_CheckPredicate: {\ - unsigned Len;\ - unsigned PIdx = decodeULEB128(++Ptr, &Len);\ - Ptr += Len;\ - unsigned NumToSkip = *Ptr++;\ - NumToSkip |= (*Ptr++) << 8;\ - NumToSkip |= (*Ptr++) << 16;\ - bool Pred;\ - if (!(Pred = checkDecoderPredicate(PIdx, Bits)))\ - Ptr += NumToSkip;\ - (void)Pred;\ - break;\ - }\ - case MCD_OPC_Decode: {\ - unsigned Len;\ - unsigned Opc = decodeULEB128(++Ptr, &Len);\ - Ptr += Len;\ - unsigned DecodeIdx = decodeULEB128(Ptr, &Len);\ - Ptr += Len;\ -\ - MCInst_clear(MI);\ - MCInst_setOpcode(MI, Opc);\ - bool DecodeComplete = false;\ - S = decoder(S, DecodeIdx, insn, MI, Address, DisAsm, &DecodeComplete);\ - CS_ASSERT(DecodeComplete);\ -\ - return S;\ - }\ - case MCD_OPC_TryDecode: {\ - unsigned Len;\ - unsigned Opc = decodeULEB128(++Ptr, &Len);\ - Ptr += Len;\ - unsigned DecodeIdx = decodeULEB128(Ptr, &Len);\ - Ptr += Len;\ - unsigned NumToSkip = *Ptr++;\ - NumToSkip |= (*Ptr++) << 8;\ - NumToSkip |= (*Ptr++) << 16;\ -\ - MCInst TmpMI = { 0 }; \ - MCInst_Init(&TmpMI, CS_ARCH_RISCV); \ - MCInst_setOpcode(&TmpMI, Opc);\ - bool DecodeComplete = false;\ - S = decoder(S, DecodeIdx, insn, &TmpMI, Address, DisAsm, &DecodeComplete);\ -\ - if (DecodeComplete) {\ - *MI = TmpMI;\ - return S;\ - } else {\ - CS_ASSERT(S == MCDisassembler_Fail);\ - Ptr += NumToSkip;\ - S = MCDisassembler_Success;\ - }\ - break;\ - }\ - case MCD_OPC_SoftFail: {\ - unsigned Len;\ - InsnType PositiveMask = decodeULEB128(++Ptr, &Len);\ - Ptr += Len;\ - InsnType NegativeMask = decodeULEB128(Ptr, &Len);\ - Ptr += Len;\ - bool Fail = (insn & PositiveMask) || (~insn & NegativeMask);\ - if (Fail)\ - S = MCDisassembler_SoftFail;\ - break;\ - }\ - case MCD_OPC_Fail: {\ - return MCDisassembler_Fail;\ - }\ - }\ - }\ - CS_ASSERT(0 && "bogosity detected in disassembler state machine!");\ +static DecodeStatus fname(const uint8_t DecodeTable[], MCInst *MI, \ + InsnType insn, uint64_t Address, const void *Decoder) { \ + const uint8_t *Ptr = DecodeTable; \ + uint64_t CurFieldValue = 0; \ + DecodeStatus S = MCDisassembler_Success; \ + while (true) { \ + switch (*Ptr) { \ + default: \ + return MCDisassembler_Fail; \ + case MCD_OPC_ExtractField: { \ + unsigned Start = *++Ptr; \ + unsigned Len = *++Ptr; \ + ++Ptr; \ + CurFieldValue = fieldname(insn, Start, Len); \ + break; \ + } \ + case MCD_OPC_FilterValue: { \ + /* Decode the field value. */ \ + unsigned Len; \ + uint64_t Val = decodeULEB128(++Ptr, &Len); \ + Ptr += Len; \ + /* NumToSkip is a plain 24-bit integer. */ \ + unsigned NumToSkip = *Ptr++; \ + NumToSkip |= (*Ptr++) << 8; \ + NumToSkip |= (*Ptr++) << 16; \ + /* Perform the filter operation. */ \ + if (Val != CurFieldValue) \ + Ptr += NumToSkip; \ + break; \ + } \ + case MCD_OPC_CheckField: { \ + unsigned Start = *++Ptr; \ + unsigned Len = *++Ptr; \ + uint64_t FieldValue = fieldname(insn, Start, Len); \ + /* Decode the field value. */ \ + unsigned PtrLen = 0; \ + uint64_t ExpectedValue = decodeULEB128(++Ptr, &PtrLen); \ + Ptr += PtrLen; \ + /* NumToSkip is a plain 24-bit integer. */ \ + unsigned NumToSkip = *Ptr++; \ + NumToSkip |= (*Ptr++) << 8; \ + NumToSkip |= (*Ptr++) << 16; \ + /* If the actual and expected values don't match, skip. */ \ + if (ExpectedValue != FieldValue) \ + Ptr += NumToSkip; \ + break; \ + } \ + case MCD_OPC_CheckPredicate: { \ + unsigned Len; \ + /* Decode the Predicate Index value. */ \ + unsigned PIdx = decodeULEB128(++Ptr, &Len); \ + Ptr += Len; \ + /* NumToSkip is a plain 24-bit integer. */ \ + unsigned NumToSkip = *Ptr++; \ + NumToSkip |= (*Ptr++) << 8; \ + NumToSkip |= (*Ptr++) << 16; \ + /* Check the predicate. */ \ + bool Pred = checkDecoderPredicate(MI, PIdx); \ + if (!Pred) \ + Ptr += NumToSkip; \ + break; \ + } \ + case MCD_OPC_Decode: { \ + unsigned Len; \ + /* Decode the Opcode value. */ \ + unsigned Opc = decodeULEB128(++Ptr, &Len); \ + Ptr += Len; \ + unsigned DecodeIdx = decodeULEB128(Ptr, &Len); \ + Ptr += Len; \ + MCInst_clear(MI); \ + MCInst_setOpcode(MI, Opc); \ + bool DecodeComplete; \ + S = decoder(S, DecodeIdx, insn, MI, Address, Decoder, &DecodeComplete); \ + return S; \ + } \ + case MCD_OPC_TryDecode: { \ + unsigned Len; \ + /* Decode the Opcode value. */ \ + unsigned Opc = decodeULEB128(++Ptr, &Len); \ + Ptr += Len; \ + unsigned DecodeIdx = decodeULEB128(Ptr, &Len); \ + Ptr += Len; \ + /* NumToSkip is a plain 24-bit integer. */ \ + unsigned NumToSkip = *Ptr++; \ + NumToSkip |= (*Ptr++) << 8; \ + NumToSkip |= (*Ptr++) << 16; \ + /* Perform the decode operation. */ \ + MCInst_setOpcode(MI, Opc); \ + bool DecodeComplete; \ + S = decoder(S, DecodeIdx, insn, MI, Address, Decoder, &DecodeComplete); \ + if (DecodeComplete) { \ + /* Decoding complete. */ \ + return S; \ + } else { \ + /* LLVM uses a MCInst on the stack, but for our use case, */ \ + /* it is enough for now to reset the op counter. */ \ + MCInst_clear(MI); \ + /* If the decoding was incomplete, skip. */ \ + Ptr += NumToSkip; \ + /* Reset decode status. This also drops a SoftFail status that could be */ \ + /* set before the decode attempt. */ \ + S = MCDisassembler_Success; \ + } \ + break; \ + } \ + case MCD_OPC_SoftFail: { \ + /* Decode the mask values. */ \ + unsigned Len; \ + uint64_t PositiveMask = decodeULEB128(++Ptr, &Len); \ + Ptr += Len; \ + uint64_t NegativeMask = decodeULEB128(Ptr, &Len); \ + Ptr += Len; \ + bool Fail = (insn & PositiveMask) != 0 || (~insn & NegativeMask) != 0; \ + if (Fail) \ + S = MCDisassembler_SoftFail; \ + break; \ + } \ + case MCD_OPC_Fail: { \ + return MCDisassembler_Fail; \ + } \ + } \ + } \ + /* Bogisity detected in disassembler state machine! */ \ } -// For RISCV instruction is 32 bits. -FieldFromInstruction(fieldFromInstruction, uint32_t) -DecodeToMCInst(decodeToMCInst, fieldFromInstruction, uint32_t) -DecodeInstruction(decodeInstruction, fieldFromInstruction, decodeToMCInst, uint32_t) +FieldFromInstruction(fieldFromInstruction_2, uint16_t) +DecodeToMCInst(decodeToMCInst_2, fieldFromInstruction_2, uint16_t) +DecodeInstruction(decodeInstruction_2, fieldFromInstruction_2, decodeToMCInst_2, uint16_t) + +FieldFromInstruction(fieldFromInstruction_4, uint32_t) +DecodeToMCInst(decodeToMCInst_4, fieldFromInstruction_4, uint32_t) +DecodeInstruction(decodeInstruction_4, fieldFromInstruction_4, decodeToMCInst_4, uint32_t) diff --git a/arch/RISCV/RISCVGenInsnNameMaps.inc b/arch/RISCV/RISCVGenInsnNameMaps.inc deleted file mode 100644 index 17d42bf9cc..0000000000 --- a/arch/RISCV/RISCVGenInsnNameMaps.inc +++ /dev/null @@ -1,275 +0,0 @@ -// This is auto-gen data for Capstone engine (www.capstone-engine.org) -// By Nguyen Anh Quynh - - { RISCV_INS_ADD, "add" }, - { RISCV_INS_ADDI, "addi" }, - { RISCV_INS_ADDIW, "addiw" }, - { RISCV_INS_ADDW, "addw" }, - { RISCV_INS_AMOADD_D, "amoadd.d" }, - { RISCV_INS_AMOADD_D_AQ, "amoadd.d.aq" }, - { RISCV_INS_AMOADD_D_AQ_RL, "amoadd.d.aqrl" }, - { RISCV_INS_AMOADD_D_RL, "amoadd.d.rl" }, - { RISCV_INS_AMOADD_W, "amoadd.w" }, - { RISCV_INS_AMOADD_W_AQ, "amoadd.w.aq" }, - { RISCV_INS_AMOADD_W_AQ_RL, "amoadd.w.aqrl" }, - { RISCV_INS_AMOADD_W_RL, "amoadd.w.rl" }, - { RISCV_INS_AMOAND_D, "amoand.d" }, - { RISCV_INS_AMOAND_D_AQ, "amoand.d.aq" }, - { RISCV_INS_AMOAND_D_AQ_RL, "amoand.d.aqrl" }, - { RISCV_INS_AMOAND_D_RL, "amoand.d.rl" }, - { RISCV_INS_AMOAND_W, "amoand.w" }, - { RISCV_INS_AMOAND_W_AQ, "amoand.w.aq" }, - { RISCV_INS_AMOAND_W_AQ_RL, "amoand.w.aqrl" }, - { RISCV_INS_AMOAND_W_RL, "amoand.w.rl" }, - { RISCV_INS_AMOMAXU_D, "amomaxu.d" }, - { RISCV_INS_AMOMAXU_D_AQ, "amomaxu.d.aq" }, - { RISCV_INS_AMOMAXU_D_AQ_RL, "amomaxu.d.aqrl" }, - { RISCV_INS_AMOMAXU_D_RL, "amomaxu.d.rl" }, - { RISCV_INS_AMOMAXU_W, "amomaxu.w" }, - { RISCV_INS_AMOMAXU_W_AQ, "amomaxu.w.aq" }, - { RISCV_INS_AMOMAXU_W_AQ_RL, "amomaxu.w.aqrl" }, - { RISCV_INS_AMOMAXU_W_RL, "amomaxu.w.rl" }, - { RISCV_INS_AMOMAX_D, "amomax.d" }, - { RISCV_INS_AMOMAX_D_AQ, "amomax.d.aq" }, - { RISCV_INS_AMOMAX_D_AQ_RL, "amomax.d.aqrl" }, - { RISCV_INS_AMOMAX_D_RL, "amomax.d.rl" }, - { RISCV_INS_AMOMAX_W, "amomax.w" }, - { RISCV_INS_AMOMAX_W_AQ, "amomax.w.aq" }, - { RISCV_INS_AMOMAX_W_AQ_RL, "amomax.w.aqrl" }, - { RISCV_INS_AMOMAX_W_RL, "amomax.w.rl" }, - { RISCV_INS_AMOMINU_D, "amominu.d" }, - { RISCV_INS_AMOMINU_D_AQ, "amominu.d.aq" }, - { RISCV_INS_AMOMINU_D_AQ_RL, "amominu.d.aqrl" }, - { RISCV_INS_AMOMINU_D_RL, "amominu.d.rl" }, - { RISCV_INS_AMOMINU_W, "amominu.w" }, - { RISCV_INS_AMOMINU_W_AQ, "amominu.w.aq" }, - { RISCV_INS_AMOMINU_W_AQ_RL, "amominu.w.aqrl" }, - { RISCV_INS_AMOMINU_W_RL, "amominu.w.rl" }, - { RISCV_INS_AMOMIN_D, "amomin.d" }, - { RISCV_INS_AMOMIN_D_AQ, "amomin.d.aq" }, - { RISCV_INS_AMOMIN_D_AQ_RL, "amomin.d.aqrl" }, - { RISCV_INS_AMOMIN_D_RL, "amomin.d.rl" }, - { RISCV_INS_AMOMIN_W, "amomin.w" }, - { RISCV_INS_AMOMIN_W_AQ, "amomin.w.aq" }, - { RISCV_INS_AMOMIN_W_AQ_RL, "amomin.w.aqrl" }, - { RISCV_INS_AMOMIN_W_RL, "amomin.w.rl" }, - { RISCV_INS_AMOOR_D, "amoor.d" }, - { RISCV_INS_AMOOR_D_AQ, "amoor.d.aq" }, - { RISCV_INS_AMOOR_D_AQ_RL, "amoor.d.aqrl" }, - { RISCV_INS_AMOOR_D_RL, "amoor.d.rl" }, - { RISCV_INS_AMOOR_W, "amoor.w" }, - { RISCV_INS_AMOOR_W_AQ, "amoor.w.aq" }, - { RISCV_INS_AMOOR_W_AQ_RL, "amoor.w.aqrl" }, - { RISCV_INS_AMOOR_W_RL, "amoor.w.rl" }, - { RISCV_INS_AMOSWAP_D, "amoswap.d" }, - { RISCV_INS_AMOSWAP_D_AQ, "amoswap.d.aq" }, - { RISCV_INS_AMOSWAP_D_AQ_RL, "amoswap.d.aqrl" }, - { RISCV_INS_AMOSWAP_D_RL, "amoswap.d.rl" }, - { RISCV_INS_AMOSWAP_W, "amoswap.w" }, - { RISCV_INS_AMOSWAP_W_AQ, "amoswap.w.aq" }, - { RISCV_INS_AMOSWAP_W_AQ_RL, "amoswap.w.aqrl" }, - { RISCV_INS_AMOSWAP_W_RL, "amoswap.w.rl" }, - { RISCV_INS_AMOXOR_D, "amoxor.d" }, - { RISCV_INS_AMOXOR_D_AQ, "amoxor.d.aq" }, - { RISCV_INS_AMOXOR_D_AQ_RL, "amoxor.d.aqrl" }, - { RISCV_INS_AMOXOR_D_RL, "amoxor.d.rl" }, - { RISCV_INS_AMOXOR_W, "amoxor.w" }, - { RISCV_INS_AMOXOR_W_AQ, "amoxor.w.aq" }, - { RISCV_INS_AMOXOR_W_AQ_RL, "amoxor.w.aqrl" }, - { RISCV_INS_AMOXOR_W_RL, "amoxor.w.rl" }, - { RISCV_INS_AND, "and" }, - { RISCV_INS_ANDI, "andi" }, - { RISCV_INS_AUIPC, "auipc" }, - { RISCV_INS_BEQ, "beq" }, - { RISCV_INS_BGE, "bge" }, - { RISCV_INS_BGEU, "bgeu" }, - { RISCV_INS_BLT, "blt" }, - { RISCV_INS_BLTU, "bltu" }, - { RISCV_INS_BNE, "bne" }, - { RISCV_INS_CSRRC, "csrrc" }, - { RISCV_INS_CSRRCI, "csrrci" }, - { RISCV_INS_CSRRS, "csrrs" }, - { RISCV_INS_CSRRSI, "csrrsi" }, - { RISCV_INS_CSRRW, "csrrw" }, - { RISCV_INS_CSRRWI, "csrrwi" }, - { RISCV_INS_C_ADD, "c.add" }, - { RISCV_INS_C_ADDI, "c.addi" }, - { RISCV_INS_C_ADDI16SP, "c.addi16sp" }, - { RISCV_INS_C_ADDI4SPN, "c.addi4spn" }, - { RISCV_INS_C_ADDIW, "c.addiw" }, - { RISCV_INS_C_ADDW, "c.addw" }, - { RISCV_INS_C_AND, "c.and" }, - { RISCV_INS_C_ANDI, "c.andi" }, - { RISCV_INS_C_BEQZ, "c.beqz" }, - { RISCV_INS_C_BNEZ, "c.bnez" }, - { RISCV_INS_C_EBREAK, "c.ebreak" }, - { RISCV_INS_C_FLD, "c.fld" }, - { RISCV_INS_C_FLDSP, "c.fldsp" }, - { RISCV_INS_C_FLW, "c.flw" }, - { RISCV_INS_C_FLWSP, "c.flwsp" }, - { RISCV_INS_C_FSD, "c.fsd" }, - { RISCV_INS_C_FSDSP, "c.fsdsp" }, - { RISCV_INS_C_FSW, "c.fsw" }, - { RISCV_INS_C_FSWSP, "c.fswsp" }, - { RISCV_INS_C_J, "c.j" }, - { RISCV_INS_C_JAL, "c.jal" }, - { RISCV_INS_C_JALR, "c.jalr" }, - { RISCV_INS_C_JR, "c.jr" }, - { RISCV_INS_C_LD, "c.ld" }, - { RISCV_INS_C_LDSP, "c.ldsp" }, - { RISCV_INS_C_LI, "c.li" }, - { RISCV_INS_C_LUI, "c.lui" }, - { RISCV_INS_C_LW, "c.lw" }, - { RISCV_INS_C_LWSP, "c.lwsp" }, - { RISCV_INS_C_MV, "c.mv" }, - { RISCV_INS_C_NOP, "c.nop" }, - { RISCV_INS_C_OR, "c.or" }, - { RISCV_INS_C_SD, "c.sd" }, - { RISCV_INS_C_SDSP, "c.sdsp" }, - { RISCV_INS_C_SLLI, "c.slli" }, - { RISCV_INS_C_SRAI, "c.srai" }, - { RISCV_INS_C_SRLI, "c.srli" }, - { RISCV_INS_C_SUB, "c.sub" }, - { RISCV_INS_C_SUBW, "c.subw" }, - { RISCV_INS_C_SW, "c.sw" }, - { RISCV_INS_C_SWSP, "c.swsp" }, - { RISCV_INS_C_UNIMP, "c.unimp" }, - { RISCV_INS_C_XOR, "c.xor" }, - { RISCV_INS_DIV, "div" }, - { RISCV_INS_DIVU, "divu" }, - { RISCV_INS_DIVUW, "divuw" }, - { RISCV_INS_DIVW, "divw" }, - { RISCV_INS_EBREAK, "ebreak" }, - { RISCV_INS_ECALL, "ecall" }, - { RISCV_INS_FADD_D, "fadd.d" }, - { RISCV_INS_FADD_S, "fadd.s" }, - { RISCV_INS_FCLASS_D, "fclass.d" }, - { RISCV_INS_FCLASS_S, "fclass.s" }, - { RISCV_INS_FCVT_D_L, "fcvt.d.l" }, - { RISCV_INS_FCVT_D_LU, "fcvt.d.lu" }, - { RISCV_INS_FCVT_D_S, "fcvt.d.s" }, - { RISCV_INS_FCVT_D_W, "fcvt.d.w" }, - { RISCV_INS_FCVT_D_WU, "fcvt.d.wu" }, - { RISCV_INS_FCVT_LU_D, "fcvt.lu.d" }, - { RISCV_INS_FCVT_LU_S, "fcvt.lu.s" }, - { RISCV_INS_FCVT_L_D, "fcvt.l.d" }, - { RISCV_INS_FCVT_L_S, "fcvt.l.s" }, - { RISCV_INS_FCVT_S_D, "fcvt.s.d" }, - { RISCV_INS_FCVT_S_L, "fcvt.s.l" }, - { RISCV_INS_FCVT_S_LU, "fcvt.s.lu" }, - { RISCV_INS_FCVT_S_W, "fcvt.s.w" }, - { RISCV_INS_FCVT_S_WU, "fcvt.s.wu" }, - { RISCV_INS_FCVT_WU_D, "fcvt.wu.d" }, - { RISCV_INS_FCVT_WU_S, "fcvt.wu.s" }, - { RISCV_INS_FCVT_W_D, "fcvt.w.d" }, - { RISCV_INS_FCVT_W_S, "fcvt.w.s" }, - { RISCV_INS_FDIV_D, "fdiv.d" }, - { RISCV_INS_FDIV_S, "fdiv.s" }, - { RISCV_INS_FENCE, "fence" }, - { RISCV_INS_FENCE_I, "fence.i" }, - { RISCV_INS_FENCE_TSO, "fence.tso" }, - { RISCV_INS_FEQ_D, "feq.d" }, - { RISCV_INS_FEQ_S, "feq.s" }, - { RISCV_INS_FLD, "fld" }, - { RISCV_INS_FLE_D, "fle.d" }, - { RISCV_INS_FLE_S, "fle.s" }, - { RISCV_INS_FLT_D, "flt.d" }, - { RISCV_INS_FLT_S, "flt.s" }, - { RISCV_INS_FLW, "flw" }, - { RISCV_INS_FMADD_D, "fmadd.d" }, - { RISCV_INS_FMADD_S, "fmadd.s" }, - { RISCV_INS_FMAX_D, "fmax.d" }, - { RISCV_INS_FMAX_S, "fmax.s" }, - { RISCV_INS_FMIN_D, "fmin.d" }, - { RISCV_INS_FMIN_S, "fmin.s" }, - { RISCV_INS_FMSUB_D, "fmsub.d" }, - { RISCV_INS_FMSUB_S, "fmsub.s" }, - { RISCV_INS_FMUL_D, "fmul.d" }, - { RISCV_INS_FMUL_S, "fmul.s" }, - { RISCV_INS_FMV_D_X, "fmv.d.x" }, - { RISCV_INS_FMV_W_X, "fmv.w.x" }, - { RISCV_INS_FMV_X_D, "fmv.x.d" }, - { RISCV_INS_FMV_X_W, "fmv.x.w" }, - { RISCV_INS_FNMADD_D, "fnmadd.d" }, - { RISCV_INS_FNMADD_S, "fnmadd.s" }, - { RISCV_INS_FNMSUB_D, "fnmsub.d" }, - { RISCV_INS_FNMSUB_S, "fnmsub.s" }, - { RISCV_INS_FSD, "fsd" }, - { RISCV_INS_FSGNJN_D, "fsgnjn.d" }, - { RISCV_INS_FSGNJN_S, "fsgnjn.s" }, - { RISCV_INS_FSGNJX_D, "fsgnjx.d" }, - { RISCV_INS_FSGNJX_S, "fsgnjx.s" }, - { RISCV_INS_FSGNJ_D, "fsgnj.d" }, - { RISCV_INS_FSGNJ_S, "fsgnj.s" }, - { RISCV_INS_FSQRT_D, "fsqrt.d" }, - { RISCV_INS_FSQRT_S, "fsqrt.s" }, - { RISCV_INS_FSUB_D, "fsub.d" }, - { RISCV_INS_FSUB_S, "fsub.s" }, - { RISCV_INS_FSW, "fsw" }, - { RISCV_INS_JAL, "jal" }, - { RISCV_INS_JALR, "jalr" }, - { RISCV_INS_LB, "lb" }, - { RISCV_INS_LBU, "lbu" }, - { RISCV_INS_LD, "ld" }, - { RISCV_INS_LH, "lh" }, - { RISCV_INS_LHU, "lhu" }, - { RISCV_INS_LR_D, "lr.d" }, - { RISCV_INS_LR_D_AQ, "lr.d.aq" }, - { RISCV_INS_LR_D_AQ_RL, "lr.d.aqrl" }, - { RISCV_INS_LR_D_RL, "lr.d.rl" }, - { RISCV_INS_LR_W, "lr.w" }, - { RISCV_INS_LR_W_AQ, "lr.w.aq" }, - { RISCV_INS_LR_W_AQ_RL, "lr.w.aqrl" }, - { RISCV_INS_LR_W_RL, "lr.w.rl" }, - { RISCV_INS_LUI, "lui" }, - { RISCV_INS_LW, "lw" }, - { RISCV_INS_LWU, "lwu" }, - { RISCV_INS_MRET, "mret" }, - { RISCV_INS_MUL, "mul" }, - { RISCV_INS_MULH, "mulh" }, - { RISCV_INS_MULHSU, "mulhsu" }, - { RISCV_INS_MULHU, "mulhu" }, - { RISCV_INS_MULW, "mulw" }, - { RISCV_INS_OR, "or" }, - { RISCV_INS_ORI, "ori" }, - { RISCV_INS_REM, "rem" }, - { RISCV_INS_REMU, "remu" }, - { RISCV_INS_REMUW, "remuw" }, - { RISCV_INS_REMW, "remw" }, - { RISCV_INS_SB, "sb" }, - { RISCV_INS_SC_D, "sc.d" }, - { RISCV_INS_SC_D_AQ, "sc.d.aq" }, - { RISCV_INS_SC_D_AQ_RL, "sc.d.aqrl" }, - { RISCV_INS_SC_D_RL, "sc.d.rl" }, - { RISCV_INS_SC_W, "sc.w" }, - { RISCV_INS_SC_W_AQ, "sc.w.aq" }, - { RISCV_INS_SC_W_AQ_RL, "sc.w.aqrl" }, - { RISCV_INS_SC_W_RL, "sc.w.rl" }, - { RISCV_INS_SD, "sd" }, - { RISCV_INS_SFENCE_VMA, "sfence.vma" }, - { RISCV_INS_SH, "sh" }, - { RISCV_INS_SLL, "sll" }, - { RISCV_INS_SLLI, "slli" }, - { RISCV_INS_SLLIW, "slliw" }, - { RISCV_INS_SLLW, "sllw" }, - { RISCV_INS_SLT, "slt" }, - { RISCV_INS_SLTI, "slti" }, - { RISCV_INS_SLTIU, "sltiu" }, - { RISCV_INS_SLTU, "sltu" }, - { RISCV_INS_SRA, "sra" }, - { RISCV_INS_SRAI, "srai" }, - { RISCV_INS_SRAIW, "sraiw" }, - { RISCV_INS_SRAW, "sraw" }, - { RISCV_INS_SRET, "sret" }, - { RISCV_INS_SRL, "srl" }, - { RISCV_INS_SRLI, "srli" }, - { RISCV_INS_SRLIW, "srliw" }, - { RISCV_INS_SRLW, "srlw" }, - { RISCV_INS_SUB, "sub" }, - { RISCV_INS_SUBW, "subw" }, - { RISCV_INS_SW, "sw" }, - { RISCV_INS_UNIMP, "unimp" }, - { RISCV_INS_URET, "uret" }, - { RISCV_INS_WFI, "wfi" }, - { RISCV_INS_XOR, "xor" }, - { RISCV_INS_XORI, "xori" }, diff --git a/arch/RISCV/RISCVGenInstrInfo.inc b/arch/RISCV/RISCVGenInstrInfo.inc index 069892e176..9d1aec5c08 100644 --- a/arch/RISCV/RISCVGenInstrInfo.inc +++ b/arch/RISCV/RISCVGenInstrInfo.inc @@ -1,19 +1,20 @@ -/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\ -|* *| -|* Target Instruction Enum Values and Descriptors *| -|* *| -|* Automatically generated file, do not edit! *| -|* *| -\*===----------------------------------------------------------------------===*/ +/* Capstone Disassembly Engine, https://www.capstone-engine.org */ +/* By Nguyen Anh Quynh , 2013-2022, */ +/* Rot127 2022-2024 */ +/* Automatically generated file by Capstone's LLVM TableGen Disassembler Backend. */ -/* Capstone Disassembly Engine */ -/* By Nguyen Anh Quynh , 2013-2015 */ +/* LLVM-commit: */ +/* LLVM-tag: */ +/* Do not edit. */ + +/* Capstone's LLVM TableGen Backends: */ +/* https://github.com/capstone-engine/llvm-capstone */ #ifdef GET_INSTRINFO_ENUM #undef GET_INSTRINFO_ENUM -enum { + enum { RISCV_PHI = 0, RISCV_INLINEASM = 1, RISCV_INLINEASM_BR = 2, @@ -28,443 +29,27651 @@ enum { RISCV_SUBREG_TO_REG = 11, RISCV_COPY_TO_REGCLASS = 12, RISCV_DBG_VALUE = 13, - RISCV_DBG_LABEL = 14, - RISCV_REG_SEQUENCE = 15, - RISCV_COPY = 16, - RISCV_BUNDLE = 17, - RISCV_LIFETIME_START = 18, - RISCV_LIFETIME_END = 19, - RISCV_STACKMAP = 20, - RISCV_FENTRY_CALL = 21, - RISCV_PATCHPOINT = 22, - RISCV_LOAD_STACK_GUARD = 23, - RISCV_STATEPOINT = 24, - RISCV_LOCAL_ESCAPE = 25, - RISCV_FAULTING_OP = 26, - RISCV_PATCHABLE_OP = 27, - RISCV_PATCHABLE_FUNCTION_ENTER = 28, - RISCV_PATCHABLE_RET = 29, - RISCV_PATCHABLE_FUNCTION_EXIT = 30, - RISCV_PATCHABLE_TAIL_CALL = 31, - RISCV_PATCHABLE_EVENT_CALL = 32, - RISCV_PATCHABLE_TYPED_EVENT_CALL = 33, - RISCV_ICALL_BRANCH_FUNNEL = 34, - RISCV_G_ADD = 35, - RISCV_G_SUB = 36, - RISCV_G_MUL = 37, - RISCV_G_SDIV = 38, - RISCV_G_UDIV = 39, - RISCV_G_SREM = 40, - RISCV_G_UREM = 41, - RISCV_G_AND = 42, - RISCV_G_OR = 43, - RISCV_G_XOR = 44, - RISCV_G_IMPLICIT_DEF = 45, - RISCV_G_PHI = 46, - RISCV_G_FRAME_INDEX = 47, - RISCV_G_GLOBAL_VALUE = 48, - RISCV_G_EXTRACT = 49, - RISCV_G_UNMERGE_VALUES = 50, - RISCV_G_INSERT = 51, - RISCV_G_MERGE_VALUES = 52, - RISCV_G_BUILD_VECTOR = 53, - RISCV_G_BUILD_VECTOR_TRUNC = 54, - RISCV_G_CONCAT_VECTORS = 55, - RISCV_G_PTRTOINT = 56, - RISCV_G_INTTOPTR = 57, - RISCV_G_BITCAST = 58, - RISCV_G_INTRINSIC_TRUNC = 59, - RISCV_G_INTRINSIC_ROUND = 60, - RISCV_G_LOAD = 61, - RISCV_G_SEXTLOAD = 62, - RISCV_G_ZEXTLOAD = 63, - RISCV_G_STORE = 64, - RISCV_G_ATOMIC_CMPXCHG_WITH_SUCCESS = 65, - RISCV_G_ATOMIC_CMPXCHG = 66, - RISCV_G_ATOMICRMW_XCHG = 67, - RISCV_G_ATOMICRMW_ADD = 68, - RISCV_G_ATOMICRMW_SUB = 69, - RISCV_G_ATOMICRMW_AND = 70, - RISCV_G_ATOMICRMW_NAND = 71, - RISCV_G_ATOMICRMW_OR = 72, - RISCV_G_ATOMICRMW_XOR = 73, - RISCV_G_ATOMICRMW_MAX = 74, - RISCV_G_ATOMICRMW_MIN = 75, - RISCV_G_ATOMICRMW_UMAX = 76, - RISCV_G_ATOMICRMW_UMIN = 77, - RISCV_G_BRCOND = 78, - RISCV_G_BRINDIRECT = 79, - RISCV_G_INTRINSIC = 80, - RISCV_G_INTRINSIC_W_SIDE_EFFECTS = 81, - RISCV_G_ANYEXT = 82, - RISCV_G_TRUNC = 83, - RISCV_G_CONSTANT = 84, - RISCV_G_FCONSTANT = 85, - RISCV_G_VASTART = 86, - RISCV_G_VAARG = 87, - RISCV_G_SEXT = 88, - RISCV_G_ZEXT = 89, - RISCV_G_SHL = 90, - RISCV_G_LSHR = 91, - RISCV_G_ASHR = 92, - RISCV_G_ICMP = 93, - RISCV_G_FCMP = 94, - RISCV_G_SELECT = 95, - RISCV_G_UADDO = 96, - RISCV_G_UADDE = 97, - RISCV_G_USUBO = 98, - RISCV_G_USUBE = 99, - RISCV_G_SADDO = 100, - RISCV_G_SADDE = 101, - RISCV_G_SSUBO = 102, - RISCV_G_SSUBE = 103, - RISCV_G_UMULO = 104, - RISCV_G_SMULO = 105, - RISCV_G_UMULH = 106, - RISCV_G_SMULH = 107, - RISCV_G_FADD = 108, - RISCV_G_FSUB = 109, - RISCV_G_FMUL = 110, - RISCV_G_FMA = 111, - RISCV_G_FDIV = 112, - RISCV_G_FREM = 113, - RISCV_G_FPOW = 114, - RISCV_G_FEXP = 115, - RISCV_G_FEXP2 = 116, - RISCV_G_FLOG = 117, - RISCV_G_FLOG2 = 118, - RISCV_G_FLOG10 = 119, - RISCV_G_FNEG = 120, - RISCV_G_FPEXT = 121, - RISCV_G_FPTRUNC = 122, - RISCV_G_FPTOSI = 123, - RISCV_G_FPTOUI = 124, - RISCV_G_SITOFP = 125, - RISCV_G_UITOFP = 126, - RISCV_G_FABS = 127, - RISCV_G_FCANONICALIZE = 128, - RISCV_G_GEP = 129, - RISCV_G_PTR_MASK = 130, - RISCV_G_BR = 131, - RISCV_G_INSERT_VECTOR_ELT = 132, - RISCV_G_EXTRACT_VECTOR_ELT = 133, - RISCV_G_SHUFFLE_VECTOR = 134, - RISCV_G_CTTZ = 135, - RISCV_G_CTTZ_ZERO_UNDEF = 136, - RISCV_G_CTLZ = 137, - RISCV_G_CTLZ_ZERO_UNDEF = 138, - RISCV_G_CTPOP = 139, - RISCV_G_BSWAP = 140, - RISCV_G_FCEIL = 141, - RISCV_G_FCOS = 142, - RISCV_G_FSIN = 143, - RISCV_G_FSQRT = 144, - RISCV_G_FFLOOR = 145, - RISCV_G_ADDRSPACE_CAST = 146, - RISCV_G_BLOCK_ADDR = 147, - RISCV_ADJCALLSTACKDOWN = 148, - RISCV_ADJCALLSTACKUP = 149, - RISCV_BuildPairF64Pseudo = 150, - RISCV_PseudoAtomicLoadNand32 = 151, - RISCV_PseudoAtomicLoadNand64 = 152, - RISCV_PseudoBR = 153, - RISCV_PseudoBRIND = 154, - RISCV_PseudoCALL = 155, - RISCV_PseudoCALLIndirect = 156, - RISCV_PseudoCmpXchg32 = 157, - RISCV_PseudoCmpXchg64 = 158, - RISCV_PseudoLA = 159, - RISCV_PseudoLI = 160, - RISCV_PseudoLLA = 161, - RISCV_PseudoMaskedAtomicLoadAdd32 = 162, - RISCV_PseudoMaskedAtomicLoadMax32 = 163, - RISCV_PseudoMaskedAtomicLoadMin32 = 164, - RISCV_PseudoMaskedAtomicLoadNand32 = 165, - RISCV_PseudoMaskedAtomicLoadSub32 = 166, - RISCV_PseudoMaskedAtomicLoadUMax32 = 167, - RISCV_PseudoMaskedAtomicLoadUMin32 = 168, - RISCV_PseudoMaskedAtomicSwap32 = 169, - RISCV_PseudoMaskedCmpXchg32 = 170, - RISCV_PseudoRET = 171, - RISCV_PseudoTAIL = 172, - RISCV_PseudoTAILIndirect = 173, - RISCV_Select_FPR32_Using_CC_GPR = 174, - RISCV_Select_FPR64_Using_CC_GPR = 175, - RISCV_Select_GPR_Using_CC_GPR = 176, - RISCV_SplitF64Pseudo = 177, - RISCV_ADD = 178, - RISCV_ADDI = 179, - RISCV_ADDIW = 180, - RISCV_ADDW = 181, - RISCV_AMOADD_D = 182, - RISCV_AMOADD_D_AQ = 183, - RISCV_AMOADD_D_AQ_RL = 184, - RISCV_AMOADD_D_RL = 185, - RISCV_AMOADD_W = 186, - RISCV_AMOADD_W_AQ = 187, - RISCV_AMOADD_W_AQ_RL = 188, - RISCV_AMOADD_W_RL = 189, - RISCV_AMOAND_D = 190, - RISCV_AMOAND_D_AQ = 191, - RISCV_AMOAND_D_AQ_RL = 192, - RISCV_AMOAND_D_RL = 193, - RISCV_AMOAND_W = 194, - RISCV_AMOAND_W_AQ = 195, - RISCV_AMOAND_W_AQ_RL = 196, - RISCV_AMOAND_W_RL = 197, - RISCV_AMOMAXU_D = 198, - RISCV_AMOMAXU_D_AQ = 199, - RISCV_AMOMAXU_D_AQ_RL = 200, - RISCV_AMOMAXU_D_RL = 201, - RISCV_AMOMAXU_W = 202, - RISCV_AMOMAXU_W_AQ = 203, - RISCV_AMOMAXU_W_AQ_RL = 204, - RISCV_AMOMAXU_W_RL = 205, - RISCV_AMOMAX_D = 206, - RISCV_AMOMAX_D_AQ = 207, - RISCV_AMOMAX_D_AQ_RL = 208, - RISCV_AMOMAX_D_RL = 209, - RISCV_AMOMAX_W = 210, - RISCV_AMOMAX_W_AQ = 211, - RISCV_AMOMAX_W_AQ_RL = 212, - RISCV_AMOMAX_W_RL = 213, - RISCV_AMOMINU_D = 214, - RISCV_AMOMINU_D_AQ = 215, - RISCV_AMOMINU_D_AQ_RL = 216, - RISCV_AMOMINU_D_RL = 217, - RISCV_AMOMINU_W = 218, - RISCV_AMOMINU_W_AQ = 219, - RISCV_AMOMINU_W_AQ_RL = 220, - RISCV_AMOMINU_W_RL = 221, - RISCV_AMOMIN_D = 222, - RISCV_AMOMIN_D_AQ = 223, - RISCV_AMOMIN_D_AQ_RL = 224, - RISCV_AMOMIN_D_RL = 225, - RISCV_AMOMIN_W = 226, - RISCV_AMOMIN_W_AQ = 227, - RISCV_AMOMIN_W_AQ_RL = 228, - RISCV_AMOMIN_W_RL = 229, - RISCV_AMOOR_D = 230, - RISCV_AMOOR_D_AQ = 231, - RISCV_AMOOR_D_AQ_RL = 232, - RISCV_AMOOR_D_RL = 233, - RISCV_AMOOR_W = 234, - RISCV_AMOOR_W_AQ = 235, - RISCV_AMOOR_W_AQ_RL = 236, - RISCV_AMOOR_W_RL = 237, - RISCV_AMOSWAP_D = 238, - RISCV_AMOSWAP_D_AQ = 239, - RISCV_AMOSWAP_D_AQ_RL = 240, - RISCV_AMOSWAP_D_RL = 241, - RISCV_AMOSWAP_W = 242, - RISCV_AMOSWAP_W_AQ = 243, - RISCV_AMOSWAP_W_AQ_RL = 244, - RISCV_AMOSWAP_W_RL = 245, - RISCV_AMOXOR_D = 246, - RISCV_AMOXOR_D_AQ = 247, - RISCV_AMOXOR_D_AQ_RL = 248, - RISCV_AMOXOR_D_RL = 249, - RISCV_AMOXOR_W = 250, - RISCV_AMOXOR_W_AQ = 251, - RISCV_AMOXOR_W_AQ_RL = 252, - RISCV_AMOXOR_W_RL = 253, - RISCV_AND = 254, - RISCV_ANDI = 255, - RISCV_AUIPC = 256, - RISCV_BEQ = 257, - RISCV_BGE = 258, - RISCV_BGEU = 259, - RISCV_BLT = 260, - RISCV_BLTU = 261, - RISCV_BNE = 262, - RISCV_CSRRC = 263, - RISCV_CSRRCI = 264, - RISCV_CSRRS = 265, - RISCV_CSRRSI = 266, - RISCV_CSRRW = 267, - RISCV_CSRRWI = 268, - RISCV_C_ADD = 269, - RISCV_C_ADDI = 270, - RISCV_C_ADDI16SP = 271, - RISCV_C_ADDI4SPN = 272, - RISCV_C_ADDIW = 273, - RISCV_C_ADDW = 274, - RISCV_C_AND = 275, - RISCV_C_ANDI = 276, - RISCV_C_BEQZ = 277, - RISCV_C_BNEZ = 278, - RISCV_C_EBREAK = 279, - RISCV_C_FLD = 280, - RISCV_C_FLDSP = 281, - RISCV_C_FLW = 282, - RISCV_C_FLWSP = 283, - RISCV_C_FSD = 284, - RISCV_C_FSDSP = 285, - RISCV_C_FSW = 286, - RISCV_C_FSWSP = 287, - RISCV_C_J = 288, - RISCV_C_JAL = 289, - RISCV_C_JALR = 290, - RISCV_C_JR = 291, - RISCV_C_LD = 292, - RISCV_C_LDSP = 293, - RISCV_C_LI = 294, - RISCV_C_LUI = 295, - RISCV_C_LW = 296, - RISCV_C_LWSP = 297, - RISCV_C_MV = 298, - RISCV_C_NOP = 299, - RISCV_C_OR = 300, - RISCV_C_SD = 301, - RISCV_C_SDSP = 302, - RISCV_C_SLLI = 303, - RISCV_C_SRAI = 304, - RISCV_C_SRLI = 305, - RISCV_C_SUB = 306, - RISCV_C_SUBW = 307, - RISCV_C_SW = 308, - RISCV_C_SWSP = 309, - RISCV_C_UNIMP = 310, - RISCV_C_XOR = 311, - RISCV_DIV = 312, - RISCV_DIVU = 313, - RISCV_DIVUW = 314, - RISCV_DIVW = 315, - RISCV_EBREAK = 316, - RISCV_ECALL = 317, - RISCV_FADD_D = 318, - RISCV_FADD_S = 319, - RISCV_FCLASS_D = 320, - RISCV_FCLASS_S = 321, - RISCV_FCVT_D_L = 322, - RISCV_FCVT_D_LU = 323, - RISCV_FCVT_D_S = 324, - RISCV_FCVT_D_W = 325, - RISCV_FCVT_D_WU = 326, - RISCV_FCVT_LU_D = 327, - RISCV_FCVT_LU_S = 328, - RISCV_FCVT_L_D = 329, - RISCV_FCVT_L_S = 330, - RISCV_FCVT_S_D = 331, - RISCV_FCVT_S_L = 332, - RISCV_FCVT_S_LU = 333, - RISCV_FCVT_S_W = 334, - RISCV_FCVT_S_WU = 335, - RISCV_FCVT_WU_D = 336, - RISCV_FCVT_WU_S = 337, - RISCV_FCVT_W_D = 338, - RISCV_FCVT_W_S = 339, - RISCV_FDIV_D = 340, - RISCV_FDIV_S = 341, - RISCV_FENCE = 342, - RISCV_FENCE_I = 343, - RISCV_FENCE_TSO = 344, - RISCV_FEQ_D = 345, - RISCV_FEQ_S = 346, - RISCV_FLD = 347, - RISCV_FLE_D = 348, - RISCV_FLE_S = 349, - RISCV_FLT_D = 350, - RISCV_FLT_S = 351, - RISCV_FLW = 352, - RISCV_FMADD_D = 353, - RISCV_FMADD_S = 354, - RISCV_FMAX_D = 355, - RISCV_FMAX_S = 356, - RISCV_FMIN_D = 357, - RISCV_FMIN_S = 358, - RISCV_FMSUB_D = 359, - RISCV_FMSUB_S = 360, - RISCV_FMUL_D = 361, - RISCV_FMUL_S = 362, - RISCV_FMV_D_X = 363, - RISCV_FMV_W_X = 364, - RISCV_FMV_X_D = 365, - RISCV_FMV_X_W = 366, - RISCV_FNMADD_D = 367, - RISCV_FNMADD_S = 368, - RISCV_FNMSUB_D = 369, - RISCV_FNMSUB_S = 370, - RISCV_FSD = 371, - RISCV_FSGNJN_D = 372, - RISCV_FSGNJN_S = 373, - RISCV_FSGNJX_D = 374, - RISCV_FSGNJX_S = 375, - RISCV_FSGNJ_D = 376, - RISCV_FSGNJ_S = 377, - RISCV_FSQRT_D = 378, - RISCV_FSQRT_S = 379, - RISCV_FSUB_D = 380, - RISCV_FSUB_S = 381, - RISCV_FSW = 382, - RISCV_JAL = 383, - RISCV_JALR = 384, - RISCV_LB = 385, - RISCV_LBU = 386, - RISCV_LD = 387, - RISCV_LH = 388, - RISCV_LHU = 389, - RISCV_LR_D = 390, - RISCV_LR_D_AQ = 391, - RISCV_LR_D_AQ_RL = 392, - RISCV_LR_D_RL = 393, - RISCV_LR_W = 394, - RISCV_LR_W_AQ = 395, - RISCV_LR_W_AQ_RL = 396, - RISCV_LR_W_RL = 397, - RISCV_LUI = 398, - RISCV_LW = 399, - RISCV_LWU = 400, - RISCV_MRET = 401, - RISCV_MUL = 402, - RISCV_MULH = 403, - RISCV_MULHSU = 404, - RISCV_MULHU = 405, - RISCV_MULW = 406, - RISCV_OR = 407, - RISCV_ORI = 408, - RISCV_REM = 409, - RISCV_REMU = 410, - RISCV_REMUW = 411, - RISCV_REMW = 412, - RISCV_SB = 413, - RISCV_SC_D = 414, - RISCV_SC_D_AQ = 415, - RISCV_SC_D_AQ_RL = 416, - RISCV_SC_D_RL = 417, - RISCV_SC_W = 418, - RISCV_SC_W_AQ = 419, - RISCV_SC_W_AQ_RL = 420, - RISCV_SC_W_RL = 421, - RISCV_SD = 422, - RISCV_SFENCE_VMA = 423, - RISCV_SH = 424, - RISCV_SLL = 425, - RISCV_SLLI = 426, - RISCV_SLLIW = 427, - RISCV_SLLW = 428, - RISCV_SLT = 429, - RISCV_SLTI = 430, - RISCV_SLTIU = 431, - RISCV_SLTU = 432, - RISCV_SRA = 433, - RISCV_SRAI = 434, - RISCV_SRAIW = 435, - RISCV_SRAW = 436, - RISCV_SRET = 437, - RISCV_SRL = 438, - RISCV_SRLI = 439, - RISCV_SRLIW = 440, - RISCV_SRLW = 441, - RISCV_SUB = 442, - RISCV_SUBW = 443, - RISCV_SW = 444, - RISCV_UNIMP = 445, - RISCV_URET = 446, - RISCV_WFI = 447, - RISCV_XOR = 448, - RISCV_XORI = 449, - RISCV_INSTRUCTION_LIST_END = 450 + RISCV_DBG_VALUE_LIST = 14, + RISCV_DBG_INSTR_REF = 15, + RISCV_DBG_PHI = 16, + RISCV_DBG_LABEL = 17, + RISCV_REG_SEQUENCE = 18, + RISCV_COPY = 19, + RISCV_BUNDLE = 20, + RISCV_LIFETIME_START = 21, + RISCV_LIFETIME_END = 22, + RISCV_PSEUDO_PROBE = 23, + RISCV_ARITH_FENCE = 24, + RISCV_STACKMAP = 25, + RISCV_FENTRY_CALL = 26, + RISCV_PATCHPOINT = 27, + RISCV_LOAD_STACK_GUARD = 28, + RISCV_PREALLOCATED_SETUP = 29, + RISCV_PREALLOCATED_ARG = 30, + RISCV_STATEPOINT = 31, + RISCV_LOCAL_ESCAPE = 32, + RISCV_FAULTING_OP = 33, + RISCV_PATCHABLE_OP = 34, + RISCV_PATCHABLE_FUNCTION_ENTER = 35, + RISCV_PATCHABLE_RET = 36, + RISCV_PATCHABLE_FUNCTION_EXIT = 37, + RISCV_PATCHABLE_TAIL_CALL = 38, + RISCV_PATCHABLE_EVENT_CALL = 39, + RISCV_PATCHABLE_TYPED_EVENT_CALL = 40, + RISCV_ICALL_BRANCH_FUNNEL = 41, + RISCV_MEMBARRIER = 42, + RISCV_JUMP_TABLE_DEBUG_INFO = 43, + RISCV_G_ASSERT_SEXT = 44, + RISCV_G_ASSERT_ZEXT = 45, + RISCV_G_ASSERT_ALIGN = 46, + RISCV_G_ADD = 47, + RISCV_G_SUB = 48, + RISCV_G_MUL = 49, + RISCV_G_SDIV = 50, + RISCV_G_UDIV = 51, + RISCV_G_SREM = 52, + RISCV_G_UREM = 53, + RISCV_G_SDIVREM = 54, + RISCV_G_UDIVREM = 55, + RISCV_G_AND = 56, + RISCV_G_OR = 57, + RISCV_G_XOR = 58, + RISCV_G_IMPLICIT_DEF = 59, + RISCV_G_PHI = 60, + RISCV_G_FRAME_INDEX = 61, + RISCV_G_GLOBAL_VALUE = 62, + RISCV_G_CONSTANT_POOL = 63, + RISCV_G_EXTRACT = 64, + RISCV_G_UNMERGE_VALUES = 65, + RISCV_G_INSERT = 66, + RISCV_G_MERGE_VALUES = 67, + RISCV_G_BUILD_VECTOR = 68, + RISCV_G_BUILD_VECTOR_TRUNC = 69, + RISCV_G_CONCAT_VECTORS = 70, + RISCV_G_PTRTOINT = 71, + RISCV_G_INTTOPTR = 72, + RISCV_G_BITCAST = 73, + RISCV_G_FREEZE = 74, + RISCV_G_CONSTANT_FOLD_BARRIER = 75, + RISCV_G_INTRINSIC_FPTRUNC_ROUND = 76, + RISCV_G_INTRINSIC_TRUNC = 77, + RISCV_G_INTRINSIC_ROUND = 78, + RISCV_G_INTRINSIC_LRINT = 79, + RISCV_G_INTRINSIC_ROUNDEVEN = 80, + RISCV_G_READCYCLECOUNTER = 81, + RISCV_G_LOAD = 82, + RISCV_G_SEXTLOAD = 83, + RISCV_G_ZEXTLOAD = 84, + RISCV_G_INDEXED_LOAD = 85, + RISCV_G_INDEXED_SEXTLOAD = 86, + RISCV_G_INDEXED_ZEXTLOAD = 87, + RISCV_G_STORE = 88, + RISCV_G_INDEXED_STORE = 89, + RISCV_G_ATOMIC_CMPXCHG_WITH_SUCCESS = 90, + RISCV_G_ATOMIC_CMPXCHG = 91, + RISCV_G_ATOMICRMW_XCHG = 92, + RISCV_G_ATOMICRMW_ADD = 93, + RISCV_G_ATOMICRMW_SUB = 94, + RISCV_G_ATOMICRMW_AND = 95, + RISCV_G_ATOMICRMW_NAND = 96, + RISCV_G_ATOMICRMW_OR = 97, + RISCV_G_ATOMICRMW_XOR = 98, + RISCV_G_ATOMICRMW_MAX = 99, + RISCV_G_ATOMICRMW_MIN = 100, + RISCV_G_ATOMICRMW_UMAX = 101, + RISCV_G_ATOMICRMW_UMIN = 102, + RISCV_G_ATOMICRMW_FADD = 103, + RISCV_G_ATOMICRMW_FSUB = 104, + RISCV_G_ATOMICRMW_FMAX = 105, + RISCV_G_ATOMICRMW_FMIN = 106, + RISCV_G_ATOMICRMW_UINC_WRAP = 107, + RISCV_G_ATOMICRMW_UDEC_WRAP = 108, + RISCV_G_FENCE = 109, + RISCV_G_PREFETCH = 110, + RISCV_G_BRCOND = 111, + RISCV_G_BRINDIRECT = 112, + RISCV_G_INVOKE_REGION_START = 113, + RISCV_G_INTRINSIC = 114, + RISCV_G_INTRINSIC_W_SIDE_EFFECTS = 115, + RISCV_G_INTRINSIC_CONVERGENT = 116, + RISCV_G_INTRINSIC_CONVERGENT_W_SIDE_EFFECTS = 117, + RISCV_G_ANYEXT = 118, + RISCV_G_TRUNC = 119, + RISCV_G_CONSTANT = 120, + RISCV_G_FCONSTANT = 121, + RISCV_G_VASTART = 122, + RISCV_G_VAARG = 123, + RISCV_G_SEXT = 124, + RISCV_G_SEXT_INREG = 125, + RISCV_G_ZEXT = 126, + RISCV_G_SHL = 127, + RISCV_G_LSHR = 128, + RISCV_G_ASHR = 129, + RISCV_G_FSHL = 130, + RISCV_G_FSHR = 131, + RISCV_G_ROTR = 132, + RISCV_G_ROTL = 133, + RISCV_G_ICMP = 134, + RISCV_G_FCMP = 135, + RISCV_G_SELECT = 136, + RISCV_G_UADDO = 137, + RISCV_G_UADDE = 138, + RISCV_G_USUBO = 139, + RISCV_G_USUBE = 140, + RISCV_G_SADDO = 141, + RISCV_G_SADDE = 142, + RISCV_G_SSUBO = 143, + RISCV_G_SSUBE = 144, + RISCV_G_UMULO = 145, + RISCV_G_SMULO = 146, + RISCV_G_UMULH = 147, + RISCV_G_SMULH = 148, + RISCV_G_UADDSAT = 149, + RISCV_G_SADDSAT = 150, + RISCV_G_USUBSAT = 151, + RISCV_G_SSUBSAT = 152, + RISCV_G_USHLSAT = 153, + RISCV_G_SSHLSAT = 154, + RISCV_G_SMULFIX = 155, + RISCV_G_UMULFIX = 156, + RISCV_G_SMULFIXSAT = 157, + RISCV_G_UMULFIXSAT = 158, + RISCV_G_SDIVFIX = 159, + RISCV_G_UDIVFIX = 160, + RISCV_G_SDIVFIXSAT = 161, + RISCV_G_UDIVFIXSAT = 162, + RISCV_G_FADD = 163, + RISCV_G_FSUB = 164, + RISCV_G_FMUL = 165, + RISCV_G_FMA = 166, + RISCV_G_FMAD = 167, + RISCV_G_FDIV = 168, + RISCV_G_FREM = 169, + RISCV_G_FPOW = 170, + RISCV_G_FPOWI = 171, + RISCV_G_FEXP = 172, + RISCV_G_FEXP2 = 173, + RISCV_G_FEXP10 = 174, + RISCV_G_FLOG = 175, + RISCV_G_FLOG2 = 176, + RISCV_G_FLOG10 = 177, + RISCV_G_FLDEXP = 178, + RISCV_G_FFREXP = 179, + RISCV_G_FNEG = 180, + RISCV_G_FPEXT = 181, + RISCV_G_FPTRUNC = 182, + RISCV_G_FPTOSI = 183, + RISCV_G_FPTOUI = 184, + RISCV_G_SITOFP = 185, + RISCV_G_UITOFP = 186, + RISCV_G_FABS = 187, + RISCV_G_FCOPYSIGN = 188, + RISCV_G_IS_FPCLASS = 189, + RISCV_G_FCANONICALIZE = 190, + RISCV_G_FMINNUM = 191, + RISCV_G_FMAXNUM = 192, + RISCV_G_FMINNUM_IEEE = 193, + RISCV_G_FMAXNUM_IEEE = 194, + RISCV_G_FMINIMUM = 195, + RISCV_G_FMAXIMUM = 196, + RISCV_G_GET_FPENV = 197, + RISCV_G_SET_FPENV = 198, + RISCV_G_RESET_FPENV = 199, + RISCV_G_GET_FPMODE = 200, + RISCV_G_SET_FPMODE = 201, + RISCV_G_RESET_FPMODE = 202, + RISCV_G_PTR_ADD = 203, + RISCV_G_PTRMASK = 204, + RISCV_G_SMIN = 205, + RISCV_G_SMAX = 206, + RISCV_G_UMIN = 207, + RISCV_G_UMAX = 208, + RISCV_G_ABS = 209, + RISCV_G_LROUND = 210, + RISCV_G_LLROUND = 211, + RISCV_G_BR = 212, + RISCV_G_BRJT = 213, + RISCV_G_INSERT_VECTOR_ELT = 214, + RISCV_G_EXTRACT_VECTOR_ELT = 215, + RISCV_G_SHUFFLE_VECTOR = 216, + RISCV_G_CTTZ = 217, + RISCV_G_CTTZ_ZERO_UNDEF = 218, + RISCV_G_CTLZ = 219, + RISCV_G_CTLZ_ZERO_UNDEF = 220, + RISCV_G_CTPOP = 221, + RISCV_G_BSWAP = 222, + RISCV_G_BITREVERSE = 223, + RISCV_G_FCEIL = 224, + RISCV_G_FCOS = 225, + RISCV_G_FSIN = 226, + RISCV_G_FSQRT = 227, + RISCV_G_FFLOOR = 228, + RISCV_G_FRINT = 229, + RISCV_G_FNEARBYINT = 230, + RISCV_G_ADDRSPACE_CAST = 231, + RISCV_G_BLOCK_ADDR = 232, + RISCV_G_JUMP_TABLE = 233, + RISCV_G_DYN_STACKALLOC = 234, + RISCV_G_STACKSAVE = 235, + RISCV_G_STACKRESTORE = 236, + RISCV_G_STRICT_FADD = 237, + RISCV_G_STRICT_FSUB = 238, + RISCV_G_STRICT_FMUL = 239, + RISCV_G_STRICT_FDIV = 240, + RISCV_G_STRICT_FREM = 241, + RISCV_G_STRICT_FMA = 242, + RISCV_G_STRICT_FSQRT = 243, + RISCV_G_STRICT_FLDEXP = 244, + RISCV_G_READ_REGISTER = 245, + RISCV_G_WRITE_REGISTER = 246, + RISCV_G_MEMCPY = 247, + RISCV_G_MEMCPY_INLINE = 248, + RISCV_G_MEMMOVE = 249, + RISCV_G_MEMSET = 250, + RISCV_G_BZERO = 251, + RISCV_G_VECREDUCE_SEQ_FADD = 252, + RISCV_G_VECREDUCE_SEQ_FMUL = 253, + RISCV_G_VECREDUCE_FADD = 254, + RISCV_G_VECREDUCE_FMUL = 255, + RISCV_G_VECREDUCE_FMAX = 256, + RISCV_G_VECREDUCE_FMIN = 257, + RISCV_G_VECREDUCE_FMAXIMUM = 258, + RISCV_G_VECREDUCE_FMINIMUM = 259, + RISCV_G_VECREDUCE_ADD = 260, + RISCV_G_VECREDUCE_MUL = 261, + RISCV_G_VECREDUCE_AND = 262, + RISCV_G_VECREDUCE_OR = 263, + RISCV_G_VECREDUCE_XOR = 264, + RISCV_G_VECREDUCE_SMAX = 265, + RISCV_G_VECREDUCE_SMIN = 266, + RISCV_G_VECREDUCE_UMAX = 267, + RISCV_G_VECREDUCE_UMIN = 268, + RISCV_G_SBFX = 269, + RISCV_G_UBFX = 270, + RISCV_ADJCALLSTACKDOWN = 271, + RISCV_ADJCALLSTACKUP = 272, + RISCV_BuildPairF64Pseudo = 273, + RISCV_BuildPairF64Pseudo_INX = 274, + RISCV_G_FCLASS = 275, + RISCV_HWASAN_CHECK_MEMACCESS_SHORTGRANULES = 276, + RISCV_KCFI_CHECK = 277, + RISCV_PseudoAddTPRel = 278, + RISCV_PseudoAtomicLoadNand32 = 279, + RISCV_PseudoAtomicLoadNand64 = 280, + RISCV_PseudoBR = 281, + RISCV_PseudoBRIND = 282, + RISCV_PseudoCALL = 283, + RISCV_PseudoCALLIndirect = 284, + RISCV_PseudoCALLReg = 285, + RISCV_PseudoCCADD = 286, + RISCV_PseudoCCADDI = 287, + RISCV_PseudoCCADDIW = 288, + RISCV_PseudoCCADDW = 289, + RISCV_PseudoCCAND = 290, + RISCV_PseudoCCANDI = 291, + RISCV_PseudoCCANDN = 292, + RISCV_PseudoCCMOVGPR = 293, + RISCV_PseudoCCMOVGPRNoX0 = 294, + RISCV_PseudoCCOR = 295, + RISCV_PseudoCCORI = 296, + RISCV_PseudoCCORN = 297, + RISCV_PseudoCCSLL = 298, + RISCV_PseudoCCSLLI = 299, + RISCV_PseudoCCSLLIW = 300, + RISCV_PseudoCCSLLW = 301, + RISCV_PseudoCCSRA = 302, + RISCV_PseudoCCSRAI = 303, + RISCV_PseudoCCSRAIW = 304, + RISCV_PseudoCCSRAW = 305, + RISCV_PseudoCCSRL = 306, + RISCV_PseudoCCSRLI = 307, + RISCV_PseudoCCSRLIW = 308, + RISCV_PseudoCCSRLW = 309, + RISCV_PseudoCCSUB = 310, + RISCV_PseudoCCSUBW = 311, + RISCV_PseudoCCXNOR = 312, + RISCV_PseudoCCXOR = 313, + RISCV_PseudoCCXORI = 314, + RISCV_PseudoCmpXchg32 = 315, + RISCV_PseudoCmpXchg64 = 316, + RISCV_PseudoFLD = 317, + RISCV_PseudoFLH = 318, + RISCV_PseudoFLW = 319, + RISCV_PseudoFROUND_D = 320, + RISCV_PseudoFROUND_D_IN32X = 321, + RISCV_PseudoFROUND_D_INX = 322, + RISCV_PseudoFROUND_H = 323, + RISCV_PseudoFROUND_H_INX = 324, + RISCV_PseudoFROUND_S = 325, + RISCV_PseudoFROUND_S_INX = 326, + RISCV_PseudoFSD = 327, + RISCV_PseudoFSH = 328, + RISCV_PseudoFSW = 329, + RISCV_PseudoJump = 330, + RISCV_PseudoLA = 331, + RISCV_PseudoLAImm = 332, + RISCV_PseudoLA_TLSDESC = 333, + RISCV_PseudoLA_TLS_GD = 334, + RISCV_PseudoLA_TLS_IE = 335, + RISCV_PseudoLB = 336, + RISCV_PseudoLBU = 337, + RISCV_PseudoLD = 338, + RISCV_PseudoLGA = 339, + RISCV_PseudoLH = 340, + RISCV_PseudoLHU = 341, + RISCV_PseudoLI = 342, + RISCV_PseudoLLA = 343, + RISCV_PseudoLLAImm = 344, + RISCV_PseudoLW = 345, + RISCV_PseudoLWU = 346, + RISCV_PseudoLongBEQ = 347, + RISCV_PseudoLongBGE = 348, + RISCV_PseudoLongBGEU = 349, + RISCV_PseudoLongBLT = 350, + RISCV_PseudoLongBLTU = 351, + RISCV_PseudoLongBNE = 352, + RISCV_PseudoMaskedAtomicLoadAdd32 = 353, + RISCV_PseudoMaskedAtomicLoadMax32 = 354, + RISCV_PseudoMaskedAtomicLoadMin32 = 355, + RISCV_PseudoMaskedAtomicLoadNand32 = 356, + RISCV_PseudoMaskedAtomicLoadSub32 = 357, + RISCV_PseudoMaskedAtomicLoadUMax32 = 358, + RISCV_PseudoMaskedAtomicLoadUMin32 = 359, + RISCV_PseudoMaskedAtomicSwap32 = 360, + RISCV_PseudoMaskedCmpXchg32 = 361, + RISCV_PseudoMovImm = 362, + RISCV_PseudoQuietFLE_D = 363, + RISCV_PseudoQuietFLE_D_IN32X = 364, + RISCV_PseudoQuietFLE_D_INX = 365, + RISCV_PseudoQuietFLE_H = 366, + RISCV_PseudoQuietFLE_H_INX = 367, + RISCV_PseudoQuietFLE_S = 368, + RISCV_PseudoQuietFLE_S_INX = 369, + RISCV_PseudoQuietFLT_D = 370, + RISCV_PseudoQuietFLT_D_IN32X = 371, + RISCV_PseudoQuietFLT_D_INX = 372, + RISCV_PseudoQuietFLT_H = 373, + RISCV_PseudoQuietFLT_H_INX = 374, + RISCV_PseudoQuietFLT_S = 375, + RISCV_PseudoQuietFLT_S_INX = 376, + RISCV_PseudoRET = 377, + RISCV_PseudoRV32ZdinxLD = 378, + RISCV_PseudoRV32ZdinxSD = 379, + RISCV_PseudoRVVInitUndefM1 = 380, + RISCV_PseudoRVVInitUndefM2 = 381, + RISCV_PseudoRVVInitUndefM4 = 382, + RISCV_PseudoRVVInitUndefM8 = 383, + RISCV_PseudoReadVL = 384, + RISCV_PseudoReadVLENB = 385, + RISCV_PseudoSB = 386, + RISCV_PseudoSD = 387, + RISCV_PseudoSEXT_B = 388, + RISCV_PseudoSEXT_H = 389, + RISCV_PseudoSH = 390, + RISCV_PseudoSW = 391, + RISCV_PseudoTAIL = 392, + RISCV_PseudoTAILIndirect = 393, + RISCV_PseudoTHVdotVMAQASU_VV_M1 = 394, + RISCV_PseudoTHVdotVMAQASU_VV_M1_MASK = 395, + RISCV_PseudoTHVdotVMAQASU_VV_M2 = 396, + RISCV_PseudoTHVdotVMAQASU_VV_M2_MASK = 397, + RISCV_PseudoTHVdotVMAQASU_VV_M4 = 398, + RISCV_PseudoTHVdotVMAQASU_VV_M4_MASK = 399, + RISCV_PseudoTHVdotVMAQASU_VV_M8 = 400, + RISCV_PseudoTHVdotVMAQASU_VV_M8_MASK = 401, + RISCV_PseudoTHVdotVMAQASU_VV_MF2 = 402, + RISCV_PseudoTHVdotVMAQASU_VV_MF2_MASK = 403, + RISCV_PseudoTHVdotVMAQASU_VX_M1 = 404, + RISCV_PseudoTHVdotVMAQASU_VX_M1_MASK = 405, + RISCV_PseudoTHVdotVMAQASU_VX_M2 = 406, + RISCV_PseudoTHVdotVMAQASU_VX_M2_MASK = 407, + RISCV_PseudoTHVdotVMAQASU_VX_M4 = 408, + RISCV_PseudoTHVdotVMAQASU_VX_M4_MASK = 409, + RISCV_PseudoTHVdotVMAQASU_VX_M8 = 410, + RISCV_PseudoTHVdotVMAQASU_VX_M8_MASK = 411, + RISCV_PseudoTHVdotVMAQASU_VX_MF2 = 412, + RISCV_PseudoTHVdotVMAQASU_VX_MF2_MASK = 413, + RISCV_PseudoTHVdotVMAQAUS_VX_M1 = 414, + RISCV_PseudoTHVdotVMAQAUS_VX_M1_MASK = 415, + RISCV_PseudoTHVdotVMAQAUS_VX_M2 = 416, + RISCV_PseudoTHVdotVMAQAUS_VX_M2_MASK = 417, + RISCV_PseudoTHVdotVMAQAUS_VX_M4 = 418, + RISCV_PseudoTHVdotVMAQAUS_VX_M4_MASK = 419, + RISCV_PseudoTHVdotVMAQAUS_VX_M8 = 420, + RISCV_PseudoTHVdotVMAQAUS_VX_M8_MASK = 421, + RISCV_PseudoTHVdotVMAQAUS_VX_MF2 = 422, + RISCV_PseudoTHVdotVMAQAUS_VX_MF2_MASK = 423, + RISCV_PseudoTHVdotVMAQAU_VV_M1 = 424, + RISCV_PseudoTHVdotVMAQAU_VV_M1_MASK = 425, + RISCV_PseudoTHVdotVMAQAU_VV_M2 = 426, + RISCV_PseudoTHVdotVMAQAU_VV_M2_MASK = 427, + RISCV_PseudoTHVdotVMAQAU_VV_M4 = 428, + RISCV_PseudoTHVdotVMAQAU_VV_M4_MASK = 429, + RISCV_PseudoTHVdotVMAQAU_VV_M8 = 430, + RISCV_PseudoTHVdotVMAQAU_VV_M8_MASK = 431, + RISCV_PseudoTHVdotVMAQAU_VV_MF2 = 432, + RISCV_PseudoTHVdotVMAQAU_VV_MF2_MASK = 433, + RISCV_PseudoTHVdotVMAQAU_VX_M1 = 434, + RISCV_PseudoTHVdotVMAQAU_VX_M1_MASK = 435, + RISCV_PseudoTHVdotVMAQAU_VX_M2 = 436, + RISCV_PseudoTHVdotVMAQAU_VX_M2_MASK = 437, + RISCV_PseudoTHVdotVMAQAU_VX_M4 = 438, + RISCV_PseudoTHVdotVMAQAU_VX_M4_MASK = 439, + RISCV_PseudoTHVdotVMAQAU_VX_M8 = 440, + RISCV_PseudoTHVdotVMAQAU_VX_M8_MASK = 441, + RISCV_PseudoTHVdotVMAQAU_VX_MF2 = 442, + RISCV_PseudoTHVdotVMAQAU_VX_MF2_MASK = 443, + RISCV_PseudoTHVdotVMAQA_VV_M1 = 444, + RISCV_PseudoTHVdotVMAQA_VV_M1_MASK = 445, + RISCV_PseudoTHVdotVMAQA_VV_M2 = 446, + RISCV_PseudoTHVdotVMAQA_VV_M2_MASK = 447, + RISCV_PseudoTHVdotVMAQA_VV_M4 = 448, + RISCV_PseudoTHVdotVMAQA_VV_M4_MASK = 449, + RISCV_PseudoTHVdotVMAQA_VV_M8 = 450, + RISCV_PseudoTHVdotVMAQA_VV_M8_MASK = 451, + RISCV_PseudoTHVdotVMAQA_VV_MF2 = 452, + RISCV_PseudoTHVdotVMAQA_VV_MF2_MASK = 453, + RISCV_PseudoTHVdotVMAQA_VX_M1 = 454, + RISCV_PseudoTHVdotVMAQA_VX_M1_MASK = 455, + RISCV_PseudoTHVdotVMAQA_VX_M2 = 456, + RISCV_PseudoTHVdotVMAQA_VX_M2_MASK = 457, + RISCV_PseudoTHVdotVMAQA_VX_M4 = 458, + RISCV_PseudoTHVdotVMAQA_VX_M4_MASK = 459, + RISCV_PseudoTHVdotVMAQA_VX_M8 = 460, + RISCV_PseudoTHVdotVMAQA_VX_M8_MASK = 461, + RISCV_PseudoTHVdotVMAQA_VX_MF2 = 462, + RISCV_PseudoTHVdotVMAQA_VX_MF2_MASK = 463, + RISCV_PseudoTLSDESCCall = 464, + RISCV_PseudoVAADDU_VV_M1 = 465, + RISCV_PseudoVAADDU_VV_M1_MASK = 466, + RISCV_PseudoVAADDU_VV_M2 = 467, + RISCV_PseudoVAADDU_VV_M2_MASK = 468, + RISCV_PseudoVAADDU_VV_M4 = 469, + RISCV_PseudoVAADDU_VV_M4_MASK = 470, + RISCV_PseudoVAADDU_VV_M8 = 471, + RISCV_PseudoVAADDU_VV_M8_MASK = 472, + RISCV_PseudoVAADDU_VV_MF2 = 473, + RISCV_PseudoVAADDU_VV_MF2_MASK = 474, + RISCV_PseudoVAADDU_VV_MF4 = 475, + RISCV_PseudoVAADDU_VV_MF4_MASK = 476, + RISCV_PseudoVAADDU_VV_MF8 = 477, + RISCV_PseudoVAADDU_VV_MF8_MASK = 478, + RISCV_PseudoVAADDU_VX_M1 = 479, + RISCV_PseudoVAADDU_VX_M1_MASK = 480, + RISCV_PseudoVAADDU_VX_M2 = 481, + RISCV_PseudoVAADDU_VX_M2_MASK = 482, + RISCV_PseudoVAADDU_VX_M4 = 483, + RISCV_PseudoVAADDU_VX_M4_MASK = 484, + RISCV_PseudoVAADDU_VX_M8 = 485, + RISCV_PseudoVAADDU_VX_M8_MASK = 486, + RISCV_PseudoVAADDU_VX_MF2 = 487, + RISCV_PseudoVAADDU_VX_MF2_MASK = 488, + RISCV_PseudoVAADDU_VX_MF4 = 489, + RISCV_PseudoVAADDU_VX_MF4_MASK = 490, + RISCV_PseudoVAADDU_VX_MF8 = 491, + RISCV_PseudoVAADDU_VX_MF8_MASK = 492, + RISCV_PseudoVAADD_VV_M1 = 493, + RISCV_PseudoVAADD_VV_M1_MASK = 494, + RISCV_PseudoVAADD_VV_M2 = 495, + RISCV_PseudoVAADD_VV_M2_MASK = 496, + RISCV_PseudoVAADD_VV_M4 = 497, + RISCV_PseudoVAADD_VV_M4_MASK = 498, + RISCV_PseudoVAADD_VV_M8 = 499, + RISCV_PseudoVAADD_VV_M8_MASK = 500, + RISCV_PseudoVAADD_VV_MF2 = 501, + RISCV_PseudoVAADD_VV_MF2_MASK = 502, + RISCV_PseudoVAADD_VV_MF4 = 503, + RISCV_PseudoVAADD_VV_MF4_MASK = 504, + RISCV_PseudoVAADD_VV_MF8 = 505, + RISCV_PseudoVAADD_VV_MF8_MASK = 506, + RISCV_PseudoVAADD_VX_M1 = 507, + RISCV_PseudoVAADD_VX_M1_MASK = 508, + RISCV_PseudoVAADD_VX_M2 = 509, + RISCV_PseudoVAADD_VX_M2_MASK = 510, + RISCV_PseudoVAADD_VX_M4 = 511, + RISCV_PseudoVAADD_VX_M4_MASK = 512, + RISCV_PseudoVAADD_VX_M8 = 513, + RISCV_PseudoVAADD_VX_M8_MASK = 514, + RISCV_PseudoVAADD_VX_MF2 = 515, + RISCV_PseudoVAADD_VX_MF2_MASK = 516, + RISCV_PseudoVAADD_VX_MF4 = 517, + RISCV_PseudoVAADD_VX_MF4_MASK = 518, + RISCV_PseudoVAADD_VX_MF8 = 519, + RISCV_PseudoVAADD_VX_MF8_MASK = 520, + RISCV_PseudoVADC_VIM_M1 = 521, + RISCV_PseudoVADC_VIM_M2 = 522, + RISCV_PseudoVADC_VIM_M4 = 523, + RISCV_PseudoVADC_VIM_M8 = 524, + RISCV_PseudoVADC_VIM_MF2 = 525, + RISCV_PseudoVADC_VIM_MF4 = 526, + RISCV_PseudoVADC_VIM_MF8 = 527, + RISCV_PseudoVADC_VVM_M1 = 528, + RISCV_PseudoVADC_VVM_M2 = 529, + RISCV_PseudoVADC_VVM_M4 = 530, + RISCV_PseudoVADC_VVM_M8 = 531, + RISCV_PseudoVADC_VVM_MF2 = 532, + RISCV_PseudoVADC_VVM_MF4 = 533, + RISCV_PseudoVADC_VVM_MF8 = 534, + RISCV_PseudoVADC_VXM_M1 = 535, + RISCV_PseudoVADC_VXM_M2 = 536, + RISCV_PseudoVADC_VXM_M4 = 537, + RISCV_PseudoVADC_VXM_M8 = 538, + RISCV_PseudoVADC_VXM_MF2 = 539, + RISCV_PseudoVADC_VXM_MF4 = 540, + RISCV_PseudoVADC_VXM_MF8 = 541, + RISCV_PseudoVADD_VI_M1 = 542, + RISCV_PseudoVADD_VI_M1_MASK = 543, + RISCV_PseudoVADD_VI_M2 = 544, + RISCV_PseudoVADD_VI_M2_MASK = 545, + RISCV_PseudoVADD_VI_M4 = 546, + RISCV_PseudoVADD_VI_M4_MASK = 547, + RISCV_PseudoVADD_VI_M8 = 548, + RISCV_PseudoVADD_VI_M8_MASK = 549, + RISCV_PseudoVADD_VI_MF2 = 550, + RISCV_PseudoVADD_VI_MF2_MASK = 551, + RISCV_PseudoVADD_VI_MF4 = 552, + RISCV_PseudoVADD_VI_MF4_MASK = 553, + RISCV_PseudoVADD_VI_MF8 = 554, + RISCV_PseudoVADD_VI_MF8_MASK = 555, + RISCV_PseudoVADD_VV_M1 = 556, + RISCV_PseudoVADD_VV_M1_MASK = 557, + RISCV_PseudoVADD_VV_M2 = 558, + RISCV_PseudoVADD_VV_M2_MASK = 559, + RISCV_PseudoVADD_VV_M4 = 560, + RISCV_PseudoVADD_VV_M4_MASK = 561, + RISCV_PseudoVADD_VV_M8 = 562, + RISCV_PseudoVADD_VV_M8_MASK = 563, + RISCV_PseudoVADD_VV_MF2 = 564, + RISCV_PseudoVADD_VV_MF2_MASK = 565, + RISCV_PseudoVADD_VV_MF4 = 566, + RISCV_PseudoVADD_VV_MF4_MASK = 567, + RISCV_PseudoVADD_VV_MF8 = 568, + RISCV_PseudoVADD_VV_MF8_MASK = 569, + RISCV_PseudoVADD_VX_M1 = 570, + RISCV_PseudoVADD_VX_M1_MASK = 571, + RISCV_PseudoVADD_VX_M2 = 572, + RISCV_PseudoVADD_VX_M2_MASK = 573, + RISCV_PseudoVADD_VX_M4 = 574, + RISCV_PseudoVADD_VX_M4_MASK = 575, + RISCV_PseudoVADD_VX_M8 = 576, + RISCV_PseudoVADD_VX_M8_MASK = 577, + RISCV_PseudoVADD_VX_MF2 = 578, + RISCV_PseudoVADD_VX_MF2_MASK = 579, + RISCV_PseudoVADD_VX_MF4 = 580, + RISCV_PseudoVADD_VX_MF4_MASK = 581, + RISCV_PseudoVADD_VX_MF8 = 582, + RISCV_PseudoVADD_VX_MF8_MASK = 583, + RISCV_PseudoVAESDF_VS_M1_M1 = 584, + RISCV_PseudoVAESDF_VS_M1_MF2 = 585, + RISCV_PseudoVAESDF_VS_M1_MF4 = 586, + RISCV_PseudoVAESDF_VS_M1_MF8 = 587, + RISCV_PseudoVAESDF_VS_M2_M1 = 588, + RISCV_PseudoVAESDF_VS_M2_M2 = 589, + RISCV_PseudoVAESDF_VS_M2_MF2 = 590, + RISCV_PseudoVAESDF_VS_M2_MF4 = 591, + RISCV_PseudoVAESDF_VS_M2_MF8 = 592, + RISCV_PseudoVAESDF_VS_M4_M1 = 593, + RISCV_PseudoVAESDF_VS_M4_M2 = 594, + RISCV_PseudoVAESDF_VS_M4_M4 = 595, + RISCV_PseudoVAESDF_VS_M4_MF2 = 596, + RISCV_PseudoVAESDF_VS_M4_MF4 = 597, + RISCV_PseudoVAESDF_VS_M4_MF8 = 598, + RISCV_PseudoVAESDF_VS_M8_M1 = 599, + RISCV_PseudoVAESDF_VS_M8_M2 = 600, + RISCV_PseudoVAESDF_VS_M8_M4 = 601, + RISCV_PseudoVAESDF_VS_M8_MF2 = 602, + RISCV_PseudoVAESDF_VS_M8_MF4 = 603, + RISCV_PseudoVAESDF_VS_M8_MF8 = 604, + RISCV_PseudoVAESDF_VS_MF2_MF2 = 605, + RISCV_PseudoVAESDF_VS_MF2_MF4 = 606, + RISCV_PseudoVAESDF_VS_MF2_MF8 = 607, + RISCV_PseudoVAESDF_VV_M1 = 608, + RISCV_PseudoVAESDF_VV_M2 = 609, + RISCV_PseudoVAESDF_VV_M4 = 610, + RISCV_PseudoVAESDF_VV_M8 = 611, + RISCV_PseudoVAESDF_VV_MF2 = 612, + RISCV_PseudoVAESDM_VS_M1_M1 = 613, + RISCV_PseudoVAESDM_VS_M1_MF2 = 614, + RISCV_PseudoVAESDM_VS_M1_MF4 = 615, + RISCV_PseudoVAESDM_VS_M1_MF8 = 616, + RISCV_PseudoVAESDM_VS_M2_M1 = 617, + RISCV_PseudoVAESDM_VS_M2_M2 = 618, + RISCV_PseudoVAESDM_VS_M2_MF2 = 619, + RISCV_PseudoVAESDM_VS_M2_MF4 = 620, + RISCV_PseudoVAESDM_VS_M2_MF8 = 621, + RISCV_PseudoVAESDM_VS_M4_M1 = 622, + RISCV_PseudoVAESDM_VS_M4_M2 = 623, + RISCV_PseudoVAESDM_VS_M4_M4 = 624, + RISCV_PseudoVAESDM_VS_M4_MF2 = 625, + RISCV_PseudoVAESDM_VS_M4_MF4 = 626, + RISCV_PseudoVAESDM_VS_M4_MF8 = 627, + RISCV_PseudoVAESDM_VS_M8_M1 = 628, + RISCV_PseudoVAESDM_VS_M8_M2 = 629, + RISCV_PseudoVAESDM_VS_M8_M4 = 630, + RISCV_PseudoVAESDM_VS_M8_MF2 = 631, + RISCV_PseudoVAESDM_VS_M8_MF4 = 632, + RISCV_PseudoVAESDM_VS_M8_MF8 = 633, + RISCV_PseudoVAESDM_VS_MF2_MF2 = 634, + RISCV_PseudoVAESDM_VS_MF2_MF4 = 635, + RISCV_PseudoVAESDM_VS_MF2_MF8 = 636, + RISCV_PseudoVAESDM_VV_M1 = 637, + RISCV_PseudoVAESDM_VV_M2 = 638, + RISCV_PseudoVAESDM_VV_M4 = 639, + RISCV_PseudoVAESDM_VV_M8 = 640, + RISCV_PseudoVAESDM_VV_MF2 = 641, + RISCV_PseudoVAESEF_VS_M1_M1 = 642, + RISCV_PseudoVAESEF_VS_M1_MF2 = 643, + RISCV_PseudoVAESEF_VS_M1_MF4 = 644, + RISCV_PseudoVAESEF_VS_M1_MF8 = 645, + RISCV_PseudoVAESEF_VS_M2_M1 = 646, + RISCV_PseudoVAESEF_VS_M2_M2 = 647, + RISCV_PseudoVAESEF_VS_M2_MF2 = 648, + RISCV_PseudoVAESEF_VS_M2_MF4 = 649, + RISCV_PseudoVAESEF_VS_M2_MF8 = 650, + RISCV_PseudoVAESEF_VS_M4_M1 = 651, + RISCV_PseudoVAESEF_VS_M4_M2 = 652, + RISCV_PseudoVAESEF_VS_M4_M4 = 653, + RISCV_PseudoVAESEF_VS_M4_MF2 = 654, + RISCV_PseudoVAESEF_VS_M4_MF4 = 655, + RISCV_PseudoVAESEF_VS_M4_MF8 = 656, + RISCV_PseudoVAESEF_VS_M8_M1 = 657, + RISCV_PseudoVAESEF_VS_M8_M2 = 658, + RISCV_PseudoVAESEF_VS_M8_M4 = 659, + RISCV_PseudoVAESEF_VS_M8_MF2 = 660, + RISCV_PseudoVAESEF_VS_M8_MF4 = 661, + RISCV_PseudoVAESEF_VS_M8_MF8 = 662, + RISCV_PseudoVAESEF_VS_MF2_MF2 = 663, + RISCV_PseudoVAESEF_VS_MF2_MF4 = 664, + RISCV_PseudoVAESEF_VS_MF2_MF8 = 665, + RISCV_PseudoVAESEF_VV_M1 = 666, + RISCV_PseudoVAESEF_VV_M2 = 667, + RISCV_PseudoVAESEF_VV_M4 = 668, + RISCV_PseudoVAESEF_VV_M8 = 669, + RISCV_PseudoVAESEF_VV_MF2 = 670, + RISCV_PseudoVAESEM_VS_M1_M1 = 671, + RISCV_PseudoVAESEM_VS_M1_MF2 = 672, + RISCV_PseudoVAESEM_VS_M1_MF4 = 673, + RISCV_PseudoVAESEM_VS_M1_MF8 = 674, + RISCV_PseudoVAESEM_VS_M2_M1 = 675, + RISCV_PseudoVAESEM_VS_M2_M2 = 676, + RISCV_PseudoVAESEM_VS_M2_MF2 = 677, + RISCV_PseudoVAESEM_VS_M2_MF4 = 678, + RISCV_PseudoVAESEM_VS_M2_MF8 = 679, + RISCV_PseudoVAESEM_VS_M4_M1 = 680, + RISCV_PseudoVAESEM_VS_M4_M2 = 681, + RISCV_PseudoVAESEM_VS_M4_M4 = 682, + RISCV_PseudoVAESEM_VS_M4_MF2 = 683, + RISCV_PseudoVAESEM_VS_M4_MF4 = 684, + RISCV_PseudoVAESEM_VS_M4_MF8 = 685, + RISCV_PseudoVAESEM_VS_M8_M1 = 686, + RISCV_PseudoVAESEM_VS_M8_M2 = 687, + RISCV_PseudoVAESEM_VS_M8_M4 = 688, + RISCV_PseudoVAESEM_VS_M8_MF2 = 689, + RISCV_PseudoVAESEM_VS_M8_MF4 = 690, + RISCV_PseudoVAESEM_VS_M8_MF8 = 691, + RISCV_PseudoVAESEM_VS_MF2_MF2 = 692, + RISCV_PseudoVAESEM_VS_MF2_MF4 = 693, + RISCV_PseudoVAESEM_VS_MF2_MF8 = 694, + RISCV_PseudoVAESEM_VV_M1 = 695, + RISCV_PseudoVAESEM_VV_M2 = 696, + RISCV_PseudoVAESEM_VV_M4 = 697, + RISCV_PseudoVAESEM_VV_M8 = 698, + RISCV_PseudoVAESEM_VV_MF2 = 699, + RISCV_PseudoVAESKF1_VI_M1 = 700, + RISCV_PseudoVAESKF1_VI_M2 = 701, + RISCV_PseudoVAESKF1_VI_M4 = 702, + RISCV_PseudoVAESKF1_VI_M8 = 703, + RISCV_PseudoVAESKF1_VI_MF2 = 704, + RISCV_PseudoVAESKF2_VI_M1 = 705, + RISCV_PseudoVAESKF2_VI_M2 = 706, + RISCV_PseudoVAESKF2_VI_M4 = 707, + RISCV_PseudoVAESKF2_VI_M8 = 708, + RISCV_PseudoVAESKF2_VI_MF2 = 709, + RISCV_PseudoVAESZ_VS_M1_M1 = 710, + RISCV_PseudoVAESZ_VS_M1_MF2 = 711, + RISCV_PseudoVAESZ_VS_M1_MF4 = 712, + RISCV_PseudoVAESZ_VS_M1_MF8 = 713, + RISCV_PseudoVAESZ_VS_M2_M1 = 714, + RISCV_PseudoVAESZ_VS_M2_M2 = 715, + RISCV_PseudoVAESZ_VS_M2_MF2 = 716, + RISCV_PseudoVAESZ_VS_M2_MF4 = 717, + RISCV_PseudoVAESZ_VS_M2_MF8 = 718, + RISCV_PseudoVAESZ_VS_M4_M1 = 719, + RISCV_PseudoVAESZ_VS_M4_M2 = 720, + RISCV_PseudoVAESZ_VS_M4_M4 = 721, + RISCV_PseudoVAESZ_VS_M4_MF2 = 722, + RISCV_PseudoVAESZ_VS_M4_MF4 = 723, + RISCV_PseudoVAESZ_VS_M4_MF8 = 724, + RISCV_PseudoVAESZ_VS_M8_M1 = 725, + RISCV_PseudoVAESZ_VS_M8_M2 = 726, + RISCV_PseudoVAESZ_VS_M8_M4 = 727, + RISCV_PseudoVAESZ_VS_M8_MF2 = 728, + RISCV_PseudoVAESZ_VS_M8_MF4 = 729, + RISCV_PseudoVAESZ_VS_M8_MF8 = 730, + RISCV_PseudoVAESZ_VS_MF2_MF2 = 731, + RISCV_PseudoVAESZ_VS_MF2_MF4 = 732, + RISCV_PseudoVAESZ_VS_MF2_MF8 = 733, + RISCV_PseudoVANDN_VV_M1 = 734, + RISCV_PseudoVANDN_VV_M1_MASK = 735, + RISCV_PseudoVANDN_VV_M2 = 736, + RISCV_PseudoVANDN_VV_M2_MASK = 737, + RISCV_PseudoVANDN_VV_M4 = 738, + RISCV_PseudoVANDN_VV_M4_MASK = 739, + RISCV_PseudoVANDN_VV_M8 = 740, + RISCV_PseudoVANDN_VV_M8_MASK = 741, + RISCV_PseudoVANDN_VV_MF2 = 742, + RISCV_PseudoVANDN_VV_MF2_MASK = 743, + RISCV_PseudoVANDN_VV_MF4 = 744, + RISCV_PseudoVANDN_VV_MF4_MASK = 745, + RISCV_PseudoVANDN_VV_MF8 = 746, + RISCV_PseudoVANDN_VV_MF8_MASK = 747, + RISCV_PseudoVANDN_VX_M1 = 748, + RISCV_PseudoVANDN_VX_M1_MASK = 749, + RISCV_PseudoVANDN_VX_M2 = 750, + RISCV_PseudoVANDN_VX_M2_MASK = 751, + RISCV_PseudoVANDN_VX_M4 = 752, + RISCV_PseudoVANDN_VX_M4_MASK = 753, + RISCV_PseudoVANDN_VX_M8 = 754, + RISCV_PseudoVANDN_VX_M8_MASK = 755, + RISCV_PseudoVANDN_VX_MF2 = 756, + RISCV_PseudoVANDN_VX_MF2_MASK = 757, + RISCV_PseudoVANDN_VX_MF4 = 758, + RISCV_PseudoVANDN_VX_MF4_MASK = 759, + RISCV_PseudoVANDN_VX_MF8 = 760, + RISCV_PseudoVANDN_VX_MF8_MASK = 761, + RISCV_PseudoVAND_VI_M1 = 762, + RISCV_PseudoVAND_VI_M1_MASK = 763, + RISCV_PseudoVAND_VI_M2 = 764, + RISCV_PseudoVAND_VI_M2_MASK = 765, + RISCV_PseudoVAND_VI_M4 = 766, + RISCV_PseudoVAND_VI_M4_MASK = 767, + RISCV_PseudoVAND_VI_M8 = 768, + RISCV_PseudoVAND_VI_M8_MASK = 769, + RISCV_PseudoVAND_VI_MF2 = 770, + RISCV_PseudoVAND_VI_MF2_MASK = 771, + RISCV_PseudoVAND_VI_MF4 = 772, + RISCV_PseudoVAND_VI_MF4_MASK = 773, + RISCV_PseudoVAND_VI_MF8 = 774, + RISCV_PseudoVAND_VI_MF8_MASK = 775, + RISCV_PseudoVAND_VV_M1 = 776, + RISCV_PseudoVAND_VV_M1_MASK = 777, + RISCV_PseudoVAND_VV_M2 = 778, + RISCV_PseudoVAND_VV_M2_MASK = 779, + RISCV_PseudoVAND_VV_M4 = 780, + RISCV_PseudoVAND_VV_M4_MASK = 781, + RISCV_PseudoVAND_VV_M8 = 782, + RISCV_PseudoVAND_VV_M8_MASK = 783, + RISCV_PseudoVAND_VV_MF2 = 784, + RISCV_PseudoVAND_VV_MF2_MASK = 785, + RISCV_PseudoVAND_VV_MF4 = 786, + RISCV_PseudoVAND_VV_MF4_MASK = 787, + RISCV_PseudoVAND_VV_MF8 = 788, + RISCV_PseudoVAND_VV_MF8_MASK = 789, + RISCV_PseudoVAND_VX_M1 = 790, + RISCV_PseudoVAND_VX_M1_MASK = 791, + RISCV_PseudoVAND_VX_M2 = 792, + RISCV_PseudoVAND_VX_M2_MASK = 793, + RISCV_PseudoVAND_VX_M4 = 794, + RISCV_PseudoVAND_VX_M4_MASK = 795, + RISCV_PseudoVAND_VX_M8 = 796, + RISCV_PseudoVAND_VX_M8_MASK = 797, + RISCV_PseudoVAND_VX_MF2 = 798, + RISCV_PseudoVAND_VX_MF2_MASK = 799, + RISCV_PseudoVAND_VX_MF4 = 800, + RISCV_PseudoVAND_VX_MF4_MASK = 801, + RISCV_PseudoVAND_VX_MF8 = 802, + RISCV_PseudoVAND_VX_MF8_MASK = 803, + RISCV_PseudoVASUBU_VV_M1 = 804, + RISCV_PseudoVASUBU_VV_M1_MASK = 805, + RISCV_PseudoVASUBU_VV_M2 = 806, + RISCV_PseudoVASUBU_VV_M2_MASK = 807, + RISCV_PseudoVASUBU_VV_M4 = 808, + RISCV_PseudoVASUBU_VV_M4_MASK = 809, + RISCV_PseudoVASUBU_VV_M8 = 810, + RISCV_PseudoVASUBU_VV_M8_MASK = 811, + RISCV_PseudoVASUBU_VV_MF2 = 812, + RISCV_PseudoVASUBU_VV_MF2_MASK = 813, + RISCV_PseudoVASUBU_VV_MF4 = 814, + RISCV_PseudoVASUBU_VV_MF4_MASK = 815, + RISCV_PseudoVASUBU_VV_MF8 = 816, + RISCV_PseudoVASUBU_VV_MF8_MASK = 817, + RISCV_PseudoVASUBU_VX_M1 = 818, + RISCV_PseudoVASUBU_VX_M1_MASK = 819, + RISCV_PseudoVASUBU_VX_M2 = 820, + RISCV_PseudoVASUBU_VX_M2_MASK = 821, + RISCV_PseudoVASUBU_VX_M4 = 822, + RISCV_PseudoVASUBU_VX_M4_MASK = 823, + RISCV_PseudoVASUBU_VX_M8 = 824, + RISCV_PseudoVASUBU_VX_M8_MASK = 825, + RISCV_PseudoVASUBU_VX_MF2 = 826, + RISCV_PseudoVASUBU_VX_MF2_MASK = 827, + RISCV_PseudoVASUBU_VX_MF4 = 828, + RISCV_PseudoVASUBU_VX_MF4_MASK = 829, + RISCV_PseudoVASUBU_VX_MF8 = 830, + RISCV_PseudoVASUBU_VX_MF8_MASK = 831, + RISCV_PseudoVASUB_VV_M1 = 832, + RISCV_PseudoVASUB_VV_M1_MASK = 833, + RISCV_PseudoVASUB_VV_M2 = 834, + RISCV_PseudoVASUB_VV_M2_MASK = 835, + RISCV_PseudoVASUB_VV_M4 = 836, + RISCV_PseudoVASUB_VV_M4_MASK = 837, + RISCV_PseudoVASUB_VV_M8 = 838, + RISCV_PseudoVASUB_VV_M8_MASK = 839, + RISCV_PseudoVASUB_VV_MF2 = 840, + RISCV_PseudoVASUB_VV_MF2_MASK = 841, + RISCV_PseudoVASUB_VV_MF4 = 842, + RISCV_PseudoVASUB_VV_MF4_MASK = 843, + RISCV_PseudoVASUB_VV_MF8 = 844, + RISCV_PseudoVASUB_VV_MF8_MASK = 845, + RISCV_PseudoVASUB_VX_M1 = 846, + RISCV_PseudoVASUB_VX_M1_MASK = 847, + RISCV_PseudoVASUB_VX_M2 = 848, + RISCV_PseudoVASUB_VX_M2_MASK = 849, + RISCV_PseudoVASUB_VX_M4 = 850, + RISCV_PseudoVASUB_VX_M4_MASK = 851, + RISCV_PseudoVASUB_VX_M8 = 852, + RISCV_PseudoVASUB_VX_M8_MASK = 853, + RISCV_PseudoVASUB_VX_MF2 = 854, + RISCV_PseudoVASUB_VX_MF2_MASK = 855, + RISCV_PseudoVASUB_VX_MF4 = 856, + RISCV_PseudoVASUB_VX_MF4_MASK = 857, + RISCV_PseudoVASUB_VX_MF8 = 858, + RISCV_PseudoVASUB_VX_MF8_MASK = 859, + RISCV_PseudoVBREV8_V_M1 = 860, + RISCV_PseudoVBREV8_V_M1_MASK = 861, + RISCV_PseudoVBREV8_V_M2 = 862, + RISCV_PseudoVBREV8_V_M2_MASK = 863, + RISCV_PseudoVBREV8_V_M4 = 864, + RISCV_PseudoVBREV8_V_M4_MASK = 865, + RISCV_PseudoVBREV8_V_M8 = 866, + RISCV_PseudoVBREV8_V_M8_MASK = 867, + RISCV_PseudoVBREV8_V_MF2 = 868, + RISCV_PseudoVBREV8_V_MF2_MASK = 869, + RISCV_PseudoVBREV8_V_MF4 = 870, + RISCV_PseudoVBREV8_V_MF4_MASK = 871, + RISCV_PseudoVBREV8_V_MF8 = 872, + RISCV_PseudoVBREV8_V_MF8_MASK = 873, + RISCV_PseudoVBREV_V_M1 = 874, + RISCV_PseudoVBREV_V_M1_MASK = 875, + RISCV_PseudoVBREV_V_M2 = 876, + RISCV_PseudoVBREV_V_M2_MASK = 877, + RISCV_PseudoVBREV_V_M4 = 878, + RISCV_PseudoVBREV_V_M4_MASK = 879, + RISCV_PseudoVBREV_V_M8 = 880, + RISCV_PseudoVBREV_V_M8_MASK = 881, + RISCV_PseudoVBREV_V_MF2 = 882, + RISCV_PseudoVBREV_V_MF2_MASK = 883, + RISCV_PseudoVBREV_V_MF4 = 884, + RISCV_PseudoVBREV_V_MF4_MASK = 885, + RISCV_PseudoVBREV_V_MF8 = 886, + RISCV_PseudoVBREV_V_MF8_MASK = 887, + RISCV_PseudoVCLMULH_VV_M1 = 888, + RISCV_PseudoVCLMULH_VV_M1_MASK = 889, + RISCV_PseudoVCLMULH_VV_M2 = 890, + RISCV_PseudoVCLMULH_VV_M2_MASK = 891, + RISCV_PseudoVCLMULH_VV_M4 = 892, + RISCV_PseudoVCLMULH_VV_M4_MASK = 893, + RISCV_PseudoVCLMULH_VV_M8 = 894, + RISCV_PseudoVCLMULH_VV_M8_MASK = 895, + RISCV_PseudoVCLMULH_VV_MF2 = 896, + RISCV_PseudoVCLMULH_VV_MF2_MASK = 897, + RISCV_PseudoVCLMULH_VV_MF4 = 898, + RISCV_PseudoVCLMULH_VV_MF4_MASK = 899, + RISCV_PseudoVCLMULH_VV_MF8 = 900, + RISCV_PseudoVCLMULH_VV_MF8_MASK = 901, + RISCV_PseudoVCLMULH_VX_M1 = 902, + RISCV_PseudoVCLMULH_VX_M1_MASK = 903, + RISCV_PseudoVCLMULH_VX_M2 = 904, + RISCV_PseudoVCLMULH_VX_M2_MASK = 905, + RISCV_PseudoVCLMULH_VX_M4 = 906, + RISCV_PseudoVCLMULH_VX_M4_MASK = 907, + RISCV_PseudoVCLMULH_VX_M8 = 908, + RISCV_PseudoVCLMULH_VX_M8_MASK = 909, + RISCV_PseudoVCLMULH_VX_MF2 = 910, + RISCV_PseudoVCLMULH_VX_MF2_MASK = 911, + RISCV_PseudoVCLMULH_VX_MF4 = 912, + RISCV_PseudoVCLMULH_VX_MF4_MASK = 913, + RISCV_PseudoVCLMULH_VX_MF8 = 914, + RISCV_PseudoVCLMULH_VX_MF8_MASK = 915, + RISCV_PseudoVCLMUL_VV_M1 = 916, + RISCV_PseudoVCLMUL_VV_M1_MASK = 917, + RISCV_PseudoVCLMUL_VV_M2 = 918, + RISCV_PseudoVCLMUL_VV_M2_MASK = 919, + RISCV_PseudoVCLMUL_VV_M4 = 920, + RISCV_PseudoVCLMUL_VV_M4_MASK = 921, + RISCV_PseudoVCLMUL_VV_M8 = 922, + RISCV_PseudoVCLMUL_VV_M8_MASK = 923, + RISCV_PseudoVCLMUL_VV_MF2 = 924, + RISCV_PseudoVCLMUL_VV_MF2_MASK = 925, + RISCV_PseudoVCLMUL_VV_MF4 = 926, + RISCV_PseudoVCLMUL_VV_MF4_MASK = 927, + RISCV_PseudoVCLMUL_VV_MF8 = 928, + RISCV_PseudoVCLMUL_VV_MF8_MASK = 929, + RISCV_PseudoVCLMUL_VX_M1 = 930, + RISCV_PseudoVCLMUL_VX_M1_MASK = 931, + RISCV_PseudoVCLMUL_VX_M2 = 932, + RISCV_PseudoVCLMUL_VX_M2_MASK = 933, + RISCV_PseudoVCLMUL_VX_M4 = 934, + RISCV_PseudoVCLMUL_VX_M4_MASK = 935, + RISCV_PseudoVCLMUL_VX_M8 = 936, + RISCV_PseudoVCLMUL_VX_M8_MASK = 937, + RISCV_PseudoVCLMUL_VX_MF2 = 938, + RISCV_PseudoVCLMUL_VX_MF2_MASK = 939, + RISCV_PseudoVCLMUL_VX_MF4 = 940, + RISCV_PseudoVCLMUL_VX_MF4_MASK = 941, + RISCV_PseudoVCLMUL_VX_MF8 = 942, + RISCV_PseudoVCLMUL_VX_MF8_MASK = 943, + RISCV_PseudoVCLZ_V_M1 = 944, + RISCV_PseudoVCLZ_V_M1_MASK = 945, + RISCV_PseudoVCLZ_V_M2 = 946, + RISCV_PseudoVCLZ_V_M2_MASK = 947, + RISCV_PseudoVCLZ_V_M4 = 948, + RISCV_PseudoVCLZ_V_M4_MASK = 949, + RISCV_PseudoVCLZ_V_M8 = 950, + RISCV_PseudoVCLZ_V_M8_MASK = 951, + RISCV_PseudoVCLZ_V_MF2 = 952, + RISCV_PseudoVCLZ_V_MF2_MASK = 953, + RISCV_PseudoVCLZ_V_MF4 = 954, + RISCV_PseudoVCLZ_V_MF4_MASK = 955, + RISCV_PseudoVCLZ_V_MF8 = 956, + RISCV_PseudoVCLZ_V_MF8_MASK = 957, + RISCV_PseudoVCOMPRESS_VM_M1_E16 = 958, + RISCV_PseudoVCOMPRESS_VM_M1_E32 = 959, + RISCV_PseudoVCOMPRESS_VM_M1_E64 = 960, + RISCV_PseudoVCOMPRESS_VM_M1_E8 = 961, + RISCV_PseudoVCOMPRESS_VM_M2_E16 = 962, + RISCV_PseudoVCOMPRESS_VM_M2_E32 = 963, + RISCV_PseudoVCOMPRESS_VM_M2_E64 = 964, + RISCV_PseudoVCOMPRESS_VM_M2_E8 = 965, + RISCV_PseudoVCOMPRESS_VM_M4_E16 = 966, + RISCV_PseudoVCOMPRESS_VM_M4_E32 = 967, + RISCV_PseudoVCOMPRESS_VM_M4_E64 = 968, + RISCV_PseudoVCOMPRESS_VM_M4_E8 = 969, + RISCV_PseudoVCOMPRESS_VM_M8_E16 = 970, + RISCV_PseudoVCOMPRESS_VM_M8_E32 = 971, + RISCV_PseudoVCOMPRESS_VM_M8_E64 = 972, + RISCV_PseudoVCOMPRESS_VM_M8_E8 = 973, + RISCV_PseudoVCOMPRESS_VM_MF2_E16 = 974, + RISCV_PseudoVCOMPRESS_VM_MF2_E32 = 975, + RISCV_PseudoVCOMPRESS_VM_MF2_E8 = 976, + RISCV_PseudoVCOMPRESS_VM_MF4_E16 = 977, + RISCV_PseudoVCOMPRESS_VM_MF4_E8 = 978, + RISCV_PseudoVCOMPRESS_VM_MF8_E8 = 979, + RISCV_PseudoVCPOP_M_B1 = 980, + RISCV_PseudoVCPOP_M_B16 = 981, + RISCV_PseudoVCPOP_M_B16_MASK = 982, + RISCV_PseudoVCPOP_M_B1_MASK = 983, + RISCV_PseudoVCPOP_M_B2 = 984, + RISCV_PseudoVCPOP_M_B2_MASK = 985, + RISCV_PseudoVCPOP_M_B32 = 986, + RISCV_PseudoVCPOP_M_B32_MASK = 987, + RISCV_PseudoVCPOP_M_B4 = 988, + RISCV_PseudoVCPOP_M_B4_MASK = 989, + RISCV_PseudoVCPOP_M_B64 = 990, + RISCV_PseudoVCPOP_M_B64_MASK = 991, + RISCV_PseudoVCPOP_M_B8 = 992, + RISCV_PseudoVCPOP_M_B8_MASK = 993, + RISCV_PseudoVCPOP_V_M1 = 994, + RISCV_PseudoVCPOP_V_M1_MASK = 995, + RISCV_PseudoVCPOP_V_M2 = 996, + RISCV_PseudoVCPOP_V_M2_MASK = 997, + RISCV_PseudoVCPOP_V_M4 = 998, + RISCV_PseudoVCPOP_V_M4_MASK = 999, + RISCV_PseudoVCPOP_V_M8 = 1000, + RISCV_PseudoVCPOP_V_M8_MASK = 1001, + RISCV_PseudoVCPOP_V_MF2 = 1002, + RISCV_PseudoVCPOP_V_MF2_MASK = 1003, + RISCV_PseudoVCPOP_V_MF4 = 1004, + RISCV_PseudoVCPOP_V_MF4_MASK = 1005, + RISCV_PseudoVCPOP_V_MF8 = 1006, + RISCV_PseudoVCPOP_V_MF8_MASK = 1007, + RISCV_PseudoVCTZ_V_M1 = 1008, + RISCV_PseudoVCTZ_V_M1_MASK = 1009, + RISCV_PseudoVCTZ_V_M2 = 1010, + RISCV_PseudoVCTZ_V_M2_MASK = 1011, + RISCV_PseudoVCTZ_V_M4 = 1012, + RISCV_PseudoVCTZ_V_M4_MASK = 1013, + RISCV_PseudoVCTZ_V_M8 = 1014, + RISCV_PseudoVCTZ_V_M8_MASK = 1015, + RISCV_PseudoVCTZ_V_MF2 = 1016, + RISCV_PseudoVCTZ_V_MF2_MASK = 1017, + RISCV_PseudoVCTZ_V_MF4 = 1018, + RISCV_PseudoVCTZ_V_MF4_MASK = 1019, + RISCV_PseudoVCTZ_V_MF8 = 1020, + RISCV_PseudoVCTZ_V_MF8_MASK = 1021, + RISCV_PseudoVC_FPR16VV_SE_M1 = 1022, + RISCV_PseudoVC_FPR16VV_SE_M2 = 1023, + RISCV_PseudoVC_FPR16VV_SE_M4 = 1024, + RISCV_PseudoVC_FPR16VV_SE_M8 = 1025, + RISCV_PseudoVC_FPR16VV_SE_MF2 = 1026, + RISCV_PseudoVC_FPR16VV_SE_MF4 = 1027, + RISCV_PseudoVC_FPR16VW_SE_M1 = 1028, + RISCV_PseudoVC_FPR16VW_SE_M2 = 1029, + RISCV_PseudoVC_FPR16VW_SE_M4 = 1030, + RISCV_PseudoVC_FPR16VW_SE_M8 = 1031, + RISCV_PseudoVC_FPR16VW_SE_MF2 = 1032, + RISCV_PseudoVC_FPR16VW_SE_MF4 = 1033, + RISCV_PseudoVC_FPR16V_SE_M1 = 1034, + RISCV_PseudoVC_FPR16V_SE_M2 = 1035, + RISCV_PseudoVC_FPR16V_SE_M4 = 1036, + RISCV_PseudoVC_FPR16V_SE_M8 = 1037, + RISCV_PseudoVC_FPR16V_SE_MF2 = 1038, + RISCV_PseudoVC_FPR16V_SE_MF4 = 1039, + RISCV_PseudoVC_FPR32VV_SE_M1 = 1040, + RISCV_PseudoVC_FPR32VV_SE_M2 = 1041, + RISCV_PseudoVC_FPR32VV_SE_M4 = 1042, + RISCV_PseudoVC_FPR32VV_SE_M8 = 1043, + RISCV_PseudoVC_FPR32VV_SE_MF2 = 1044, + RISCV_PseudoVC_FPR32VW_SE_M1 = 1045, + RISCV_PseudoVC_FPR32VW_SE_M2 = 1046, + RISCV_PseudoVC_FPR32VW_SE_M4 = 1047, + RISCV_PseudoVC_FPR32VW_SE_M8 = 1048, + RISCV_PseudoVC_FPR32VW_SE_MF2 = 1049, + RISCV_PseudoVC_FPR32V_SE_M1 = 1050, + RISCV_PseudoVC_FPR32V_SE_M2 = 1051, + RISCV_PseudoVC_FPR32V_SE_M4 = 1052, + RISCV_PseudoVC_FPR32V_SE_M8 = 1053, + RISCV_PseudoVC_FPR32V_SE_MF2 = 1054, + RISCV_PseudoVC_FPR64VV_SE_M1 = 1055, + RISCV_PseudoVC_FPR64VV_SE_M2 = 1056, + RISCV_PseudoVC_FPR64VV_SE_M4 = 1057, + RISCV_PseudoVC_FPR64VV_SE_M8 = 1058, + RISCV_PseudoVC_FPR64V_SE_M1 = 1059, + RISCV_PseudoVC_FPR64V_SE_M2 = 1060, + RISCV_PseudoVC_FPR64V_SE_M4 = 1061, + RISCV_PseudoVC_FPR64V_SE_M8 = 1062, + RISCV_PseudoVC_IVV_SE_M1 = 1063, + RISCV_PseudoVC_IVV_SE_M2 = 1064, + RISCV_PseudoVC_IVV_SE_M4 = 1065, + RISCV_PseudoVC_IVV_SE_M8 = 1066, + RISCV_PseudoVC_IVV_SE_MF2 = 1067, + RISCV_PseudoVC_IVV_SE_MF4 = 1068, + RISCV_PseudoVC_IVV_SE_MF8 = 1069, + RISCV_PseudoVC_IVW_SE_M1 = 1070, + RISCV_PseudoVC_IVW_SE_M2 = 1071, + RISCV_PseudoVC_IVW_SE_M4 = 1072, + RISCV_PseudoVC_IVW_SE_MF2 = 1073, + RISCV_PseudoVC_IVW_SE_MF4 = 1074, + RISCV_PseudoVC_IVW_SE_MF8 = 1075, + RISCV_PseudoVC_IV_SE_M1 = 1076, + RISCV_PseudoVC_IV_SE_M2 = 1077, + RISCV_PseudoVC_IV_SE_M4 = 1078, + RISCV_PseudoVC_IV_SE_M8 = 1079, + RISCV_PseudoVC_IV_SE_MF2 = 1080, + RISCV_PseudoVC_IV_SE_MF4 = 1081, + RISCV_PseudoVC_IV_SE_MF8 = 1082, + RISCV_PseudoVC_I_SE_M1 = 1083, + RISCV_PseudoVC_I_SE_M2 = 1084, + RISCV_PseudoVC_I_SE_M4 = 1085, + RISCV_PseudoVC_I_SE_M8 = 1086, + RISCV_PseudoVC_I_SE_MF2 = 1087, + RISCV_PseudoVC_I_SE_MF4 = 1088, + RISCV_PseudoVC_I_SE_MF8 = 1089, + RISCV_PseudoVC_VVV_SE_M1 = 1090, + RISCV_PseudoVC_VVV_SE_M2 = 1091, + RISCV_PseudoVC_VVV_SE_M4 = 1092, + RISCV_PseudoVC_VVV_SE_M8 = 1093, + RISCV_PseudoVC_VVV_SE_MF2 = 1094, + RISCV_PseudoVC_VVV_SE_MF4 = 1095, + RISCV_PseudoVC_VVV_SE_MF8 = 1096, + RISCV_PseudoVC_VVW_SE_M1 = 1097, + RISCV_PseudoVC_VVW_SE_M2 = 1098, + RISCV_PseudoVC_VVW_SE_M4 = 1099, + RISCV_PseudoVC_VVW_SE_MF2 = 1100, + RISCV_PseudoVC_VVW_SE_MF4 = 1101, + RISCV_PseudoVC_VVW_SE_MF8 = 1102, + RISCV_PseudoVC_VV_SE_M1 = 1103, + RISCV_PseudoVC_VV_SE_M2 = 1104, + RISCV_PseudoVC_VV_SE_M4 = 1105, + RISCV_PseudoVC_VV_SE_M8 = 1106, + RISCV_PseudoVC_VV_SE_MF2 = 1107, + RISCV_PseudoVC_VV_SE_MF4 = 1108, + RISCV_PseudoVC_VV_SE_MF8 = 1109, + RISCV_PseudoVC_V_FPR16VV_M1 = 1110, + RISCV_PseudoVC_V_FPR16VV_M2 = 1111, + RISCV_PseudoVC_V_FPR16VV_M4 = 1112, + RISCV_PseudoVC_V_FPR16VV_M8 = 1113, + RISCV_PseudoVC_V_FPR16VV_MF2 = 1114, + RISCV_PseudoVC_V_FPR16VV_MF4 = 1115, + RISCV_PseudoVC_V_FPR16VV_SE_M1 = 1116, + RISCV_PseudoVC_V_FPR16VV_SE_M2 = 1117, + RISCV_PseudoVC_V_FPR16VV_SE_M4 = 1118, + RISCV_PseudoVC_V_FPR16VV_SE_M8 = 1119, + RISCV_PseudoVC_V_FPR16VV_SE_MF2 = 1120, + RISCV_PseudoVC_V_FPR16VV_SE_MF4 = 1121, + RISCV_PseudoVC_V_FPR16VW_M1 = 1122, + RISCV_PseudoVC_V_FPR16VW_M2 = 1123, + RISCV_PseudoVC_V_FPR16VW_M4 = 1124, + RISCV_PseudoVC_V_FPR16VW_M8 = 1125, + RISCV_PseudoVC_V_FPR16VW_MF2 = 1126, + RISCV_PseudoVC_V_FPR16VW_MF4 = 1127, + RISCV_PseudoVC_V_FPR16VW_SE_M1 = 1128, + RISCV_PseudoVC_V_FPR16VW_SE_M2 = 1129, + RISCV_PseudoVC_V_FPR16VW_SE_M4 = 1130, + RISCV_PseudoVC_V_FPR16VW_SE_M8 = 1131, + RISCV_PseudoVC_V_FPR16VW_SE_MF2 = 1132, + RISCV_PseudoVC_V_FPR16VW_SE_MF4 = 1133, + RISCV_PseudoVC_V_FPR16V_M1 = 1134, + RISCV_PseudoVC_V_FPR16V_M2 = 1135, + RISCV_PseudoVC_V_FPR16V_M4 = 1136, + RISCV_PseudoVC_V_FPR16V_M8 = 1137, + RISCV_PseudoVC_V_FPR16V_MF2 = 1138, + RISCV_PseudoVC_V_FPR16V_MF4 = 1139, + RISCV_PseudoVC_V_FPR16V_SE_M1 = 1140, + RISCV_PseudoVC_V_FPR16V_SE_M2 = 1141, + RISCV_PseudoVC_V_FPR16V_SE_M4 = 1142, + RISCV_PseudoVC_V_FPR16V_SE_M8 = 1143, + RISCV_PseudoVC_V_FPR16V_SE_MF2 = 1144, + RISCV_PseudoVC_V_FPR16V_SE_MF4 = 1145, + RISCV_PseudoVC_V_FPR32VV_M1 = 1146, + RISCV_PseudoVC_V_FPR32VV_M2 = 1147, + RISCV_PseudoVC_V_FPR32VV_M4 = 1148, + RISCV_PseudoVC_V_FPR32VV_M8 = 1149, + RISCV_PseudoVC_V_FPR32VV_MF2 = 1150, + RISCV_PseudoVC_V_FPR32VV_SE_M1 = 1151, + RISCV_PseudoVC_V_FPR32VV_SE_M2 = 1152, + RISCV_PseudoVC_V_FPR32VV_SE_M4 = 1153, + RISCV_PseudoVC_V_FPR32VV_SE_M8 = 1154, + RISCV_PseudoVC_V_FPR32VV_SE_MF2 = 1155, + RISCV_PseudoVC_V_FPR32VW_M1 = 1156, + RISCV_PseudoVC_V_FPR32VW_M2 = 1157, + RISCV_PseudoVC_V_FPR32VW_M4 = 1158, + RISCV_PseudoVC_V_FPR32VW_M8 = 1159, + RISCV_PseudoVC_V_FPR32VW_MF2 = 1160, + RISCV_PseudoVC_V_FPR32VW_SE_M1 = 1161, + RISCV_PseudoVC_V_FPR32VW_SE_M2 = 1162, + RISCV_PseudoVC_V_FPR32VW_SE_M4 = 1163, + RISCV_PseudoVC_V_FPR32VW_SE_M8 = 1164, + RISCV_PseudoVC_V_FPR32VW_SE_MF2 = 1165, + RISCV_PseudoVC_V_FPR32V_M1 = 1166, + RISCV_PseudoVC_V_FPR32V_M2 = 1167, + RISCV_PseudoVC_V_FPR32V_M4 = 1168, + RISCV_PseudoVC_V_FPR32V_M8 = 1169, + RISCV_PseudoVC_V_FPR32V_MF2 = 1170, + RISCV_PseudoVC_V_FPR32V_SE_M1 = 1171, + RISCV_PseudoVC_V_FPR32V_SE_M2 = 1172, + RISCV_PseudoVC_V_FPR32V_SE_M4 = 1173, + RISCV_PseudoVC_V_FPR32V_SE_M8 = 1174, + RISCV_PseudoVC_V_FPR32V_SE_MF2 = 1175, + RISCV_PseudoVC_V_FPR64VV_M1 = 1176, + RISCV_PseudoVC_V_FPR64VV_M2 = 1177, + RISCV_PseudoVC_V_FPR64VV_M4 = 1178, + RISCV_PseudoVC_V_FPR64VV_M8 = 1179, + RISCV_PseudoVC_V_FPR64VV_SE_M1 = 1180, + RISCV_PseudoVC_V_FPR64VV_SE_M2 = 1181, + RISCV_PseudoVC_V_FPR64VV_SE_M4 = 1182, + RISCV_PseudoVC_V_FPR64VV_SE_M8 = 1183, + RISCV_PseudoVC_V_FPR64V_M1 = 1184, + RISCV_PseudoVC_V_FPR64V_M2 = 1185, + RISCV_PseudoVC_V_FPR64V_M4 = 1186, + RISCV_PseudoVC_V_FPR64V_M8 = 1187, + RISCV_PseudoVC_V_FPR64V_SE_M1 = 1188, + RISCV_PseudoVC_V_FPR64V_SE_M2 = 1189, + RISCV_PseudoVC_V_FPR64V_SE_M4 = 1190, + RISCV_PseudoVC_V_FPR64V_SE_M8 = 1191, + RISCV_PseudoVC_V_IVV_M1 = 1192, + RISCV_PseudoVC_V_IVV_M2 = 1193, + RISCV_PseudoVC_V_IVV_M4 = 1194, + RISCV_PseudoVC_V_IVV_M8 = 1195, + RISCV_PseudoVC_V_IVV_MF2 = 1196, + RISCV_PseudoVC_V_IVV_MF4 = 1197, + RISCV_PseudoVC_V_IVV_MF8 = 1198, + RISCV_PseudoVC_V_IVV_SE_M1 = 1199, + RISCV_PseudoVC_V_IVV_SE_M2 = 1200, + RISCV_PseudoVC_V_IVV_SE_M4 = 1201, + RISCV_PseudoVC_V_IVV_SE_M8 = 1202, + RISCV_PseudoVC_V_IVV_SE_MF2 = 1203, + RISCV_PseudoVC_V_IVV_SE_MF4 = 1204, + RISCV_PseudoVC_V_IVV_SE_MF8 = 1205, + RISCV_PseudoVC_V_IVW_M1 = 1206, + RISCV_PseudoVC_V_IVW_M2 = 1207, + RISCV_PseudoVC_V_IVW_M4 = 1208, + RISCV_PseudoVC_V_IVW_MF2 = 1209, + RISCV_PseudoVC_V_IVW_MF4 = 1210, + RISCV_PseudoVC_V_IVW_MF8 = 1211, + RISCV_PseudoVC_V_IVW_SE_M1 = 1212, + RISCV_PseudoVC_V_IVW_SE_M2 = 1213, + RISCV_PseudoVC_V_IVW_SE_M4 = 1214, + RISCV_PseudoVC_V_IVW_SE_MF2 = 1215, + RISCV_PseudoVC_V_IVW_SE_MF4 = 1216, + RISCV_PseudoVC_V_IVW_SE_MF8 = 1217, + RISCV_PseudoVC_V_IV_M1 = 1218, + RISCV_PseudoVC_V_IV_M2 = 1219, + RISCV_PseudoVC_V_IV_M4 = 1220, + RISCV_PseudoVC_V_IV_M8 = 1221, + RISCV_PseudoVC_V_IV_MF2 = 1222, + RISCV_PseudoVC_V_IV_MF4 = 1223, + RISCV_PseudoVC_V_IV_MF8 = 1224, + RISCV_PseudoVC_V_IV_SE_M1 = 1225, + RISCV_PseudoVC_V_IV_SE_M2 = 1226, + RISCV_PseudoVC_V_IV_SE_M4 = 1227, + RISCV_PseudoVC_V_IV_SE_M8 = 1228, + RISCV_PseudoVC_V_IV_SE_MF2 = 1229, + RISCV_PseudoVC_V_IV_SE_MF4 = 1230, + RISCV_PseudoVC_V_IV_SE_MF8 = 1231, + RISCV_PseudoVC_V_I_M1 = 1232, + RISCV_PseudoVC_V_I_M2 = 1233, + RISCV_PseudoVC_V_I_M4 = 1234, + RISCV_PseudoVC_V_I_M8 = 1235, + RISCV_PseudoVC_V_I_MF2 = 1236, + RISCV_PseudoVC_V_I_MF4 = 1237, + RISCV_PseudoVC_V_I_MF8 = 1238, + RISCV_PseudoVC_V_I_SE_M1 = 1239, + RISCV_PseudoVC_V_I_SE_M2 = 1240, + RISCV_PseudoVC_V_I_SE_M4 = 1241, + RISCV_PseudoVC_V_I_SE_M8 = 1242, + RISCV_PseudoVC_V_I_SE_MF2 = 1243, + RISCV_PseudoVC_V_I_SE_MF4 = 1244, + RISCV_PseudoVC_V_I_SE_MF8 = 1245, + RISCV_PseudoVC_V_VVV_M1 = 1246, + RISCV_PseudoVC_V_VVV_M2 = 1247, + RISCV_PseudoVC_V_VVV_M4 = 1248, + RISCV_PseudoVC_V_VVV_M8 = 1249, + RISCV_PseudoVC_V_VVV_MF2 = 1250, + RISCV_PseudoVC_V_VVV_MF4 = 1251, + RISCV_PseudoVC_V_VVV_MF8 = 1252, + RISCV_PseudoVC_V_VVV_SE_M1 = 1253, + RISCV_PseudoVC_V_VVV_SE_M2 = 1254, + RISCV_PseudoVC_V_VVV_SE_M4 = 1255, + RISCV_PseudoVC_V_VVV_SE_M8 = 1256, + RISCV_PseudoVC_V_VVV_SE_MF2 = 1257, + RISCV_PseudoVC_V_VVV_SE_MF4 = 1258, + RISCV_PseudoVC_V_VVV_SE_MF8 = 1259, + RISCV_PseudoVC_V_VVW_M1 = 1260, + RISCV_PseudoVC_V_VVW_M2 = 1261, + RISCV_PseudoVC_V_VVW_M4 = 1262, + RISCV_PseudoVC_V_VVW_MF2 = 1263, + RISCV_PseudoVC_V_VVW_MF4 = 1264, + RISCV_PseudoVC_V_VVW_MF8 = 1265, + RISCV_PseudoVC_V_VVW_SE_M1 = 1266, + RISCV_PseudoVC_V_VVW_SE_M2 = 1267, + RISCV_PseudoVC_V_VVW_SE_M4 = 1268, + RISCV_PseudoVC_V_VVW_SE_MF2 = 1269, + RISCV_PseudoVC_V_VVW_SE_MF4 = 1270, + RISCV_PseudoVC_V_VVW_SE_MF8 = 1271, + RISCV_PseudoVC_V_VV_M1 = 1272, + RISCV_PseudoVC_V_VV_M2 = 1273, + RISCV_PseudoVC_V_VV_M4 = 1274, + RISCV_PseudoVC_V_VV_M8 = 1275, + RISCV_PseudoVC_V_VV_MF2 = 1276, + RISCV_PseudoVC_V_VV_MF4 = 1277, + RISCV_PseudoVC_V_VV_MF8 = 1278, + RISCV_PseudoVC_V_VV_SE_M1 = 1279, + RISCV_PseudoVC_V_VV_SE_M2 = 1280, + RISCV_PseudoVC_V_VV_SE_M4 = 1281, + RISCV_PseudoVC_V_VV_SE_M8 = 1282, + RISCV_PseudoVC_V_VV_SE_MF2 = 1283, + RISCV_PseudoVC_V_VV_SE_MF4 = 1284, + RISCV_PseudoVC_V_VV_SE_MF8 = 1285, + RISCV_PseudoVC_V_XVV_M1 = 1286, + RISCV_PseudoVC_V_XVV_M2 = 1287, + RISCV_PseudoVC_V_XVV_M4 = 1288, + RISCV_PseudoVC_V_XVV_M8 = 1289, + RISCV_PseudoVC_V_XVV_MF2 = 1290, + RISCV_PseudoVC_V_XVV_MF4 = 1291, + RISCV_PseudoVC_V_XVV_MF8 = 1292, + RISCV_PseudoVC_V_XVV_SE_M1 = 1293, + RISCV_PseudoVC_V_XVV_SE_M2 = 1294, + RISCV_PseudoVC_V_XVV_SE_M4 = 1295, + RISCV_PseudoVC_V_XVV_SE_M8 = 1296, + RISCV_PseudoVC_V_XVV_SE_MF2 = 1297, + RISCV_PseudoVC_V_XVV_SE_MF4 = 1298, + RISCV_PseudoVC_V_XVV_SE_MF8 = 1299, + RISCV_PseudoVC_V_XVW_M1 = 1300, + RISCV_PseudoVC_V_XVW_M2 = 1301, + RISCV_PseudoVC_V_XVW_M4 = 1302, + RISCV_PseudoVC_V_XVW_MF2 = 1303, + RISCV_PseudoVC_V_XVW_MF4 = 1304, + RISCV_PseudoVC_V_XVW_MF8 = 1305, + RISCV_PseudoVC_V_XVW_SE_M1 = 1306, + RISCV_PseudoVC_V_XVW_SE_M2 = 1307, + RISCV_PseudoVC_V_XVW_SE_M4 = 1308, + RISCV_PseudoVC_V_XVW_SE_MF2 = 1309, + RISCV_PseudoVC_V_XVW_SE_MF4 = 1310, + RISCV_PseudoVC_V_XVW_SE_MF8 = 1311, + RISCV_PseudoVC_V_XV_M1 = 1312, + RISCV_PseudoVC_V_XV_M2 = 1313, + RISCV_PseudoVC_V_XV_M4 = 1314, + RISCV_PseudoVC_V_XV_M8 = 1315, + RISCV_PseudoVC_V_XV_MF2 = 1316, + RISCV_PseudoVC_V_XV_MF4 = 1317, + RISCV_PseudoVC_V_XV_MF8 = 1318, + RISCV_PseudoVC_V_XV_SE_M1 = 1319, + RISCV_PseudoVC_V_XV_SE_M2 = 1320, + RISCV_PseudoVC_V_XV_SE_M4 = 1321, + RISCV_PseudoVC_V_XV_SE_M8 = 1322, + RISCV_PseudoVC_V_XV_SE_MF2 = 1323, + RISCV_PseudoVC_V_XV_SE_MF4 = 1324, + RISCV_PseudoVC_V_XV_SE_MF8 = 1325, + RISCV_PseudoVC_V_X_M1 = 1326, + RISCV_PseudoVC_V_X_M2 = 1327, + RISCV_PseudoVC_V_X_M4 = 1328, + RISCV_PseudoVC_V_X_M8 = 1329, + RISCV_PseudoVC_V_X_MF2 = 1330, + RISCV_PseudoVC_V_X_MF4 = 1331, + RISCV_PseudoVC_V_X_MF8 = 1332, + RISCV_PseudoVC_V_X_SE_M1 = 1333, + RISCV_PseudoVC_V_X_SE_M2 = 1334, + RISCV_PseudoVC_V_X_SE_M4 = 1335, + RISCV_PseudoVC_V_X_SE_M8 = 1336, + RISCV_PseudoVC_V_X_SE_MF2 = 1337, + RISCV_PseudoVC_V_X_SE_MF4 = 1338, + RISCV_PseudoVC_V_X_SE_MF8 = 1339, + RISCV_PseudoVC_XVV_SE_M1 = 1340, + RISCV_PseudoVC_XVV_SE_M2 = 1341, + RISCV_PseudoVC_XVV_SE_M4 = 1342, + RISCV_PseudoVC_XVV_SE_M8 = 1343, + RISCV_PseudoVC_XVV_SE_MF2 = 1344, + RISCV_PseudoVC_XVV_SE_MF4 = 1345, + RISCV_PseudoVC_XVV_SE_MF8 = 1346, + RISCV_PseudoVC_XVW_SE_M1 = 1347, + RISCV_PseudoVC_XVW_SE_M2 = 1348, + RISCV_PseudoVC_XVW_SE_M4 = 1349, + RISCV_PseudoVC_XVW_SE_MF2 = 1350, + RISCV_PseudoVC_XVW_SE_MF4 = 1351, + RISCV_PseudoVC_XVW_SE_MF8 = 1352, + RISCV_PseudoVC_XV_SE_M1 = 1353, + RISCV_PseudoVC_XV_SE_M2 = 1354, + RISCV_PseudoVC_XV_SE_M4 = 1355, + RISCV_PseudoVC_XV_SE_M8 = 1356, + RISCV_PseudoVC_XV_SE_MF2 = 1357, + RISCV_PseudoVC_XV_SE_MF4 = 1358, + RISCV_PseudoVC_XV_SE_MF8 = 1359, + RISCV_PseudoVC_X_SE_M1 = 1360, + RISCV_PseudoVC_X_SE_M2 = 1361, + RISCV_PseudoVC_X_SE_M4 = 1362, + RISCV_PseudoVC_X_SE_M8 = 1363, + RISCV_PseudoVC_X_SE_MF2 = 1364, + RISCV_PseudoVC_X_SE_MF4 = 1365, + RISCV_PseudoVC_X_SE_MF8 = 1366, + RISCV_PseudoVDIVU_VV_M1_E16 = 1367, + RISCV_PseudoVDIVU_VV_M1_E16_MASK = 1368, + RISCV_PseudoVDIVU_VV_M1_E32 = 1369, + RISCV_PseudoVDIVU_VV_M1_E32_MASK = 1370, + RISCV_PseudoVDIVU_VV_M1_E64 = 1371, + RISCV_PseudoVDIVU_VV_M1_E64_MASK = 1372, + RISCV_PseudoVDIVU_VV_M1_E8 = 1373, + RISCV_PseudoVDIVU_VV_M1_E8_MASK = 1374, + RISCV_PseudoVDIVU_VV_M2_E16 = 1375, + RISCV_PseudoVDIVU_VV_M2_E16_MASK = 1376, + RISCV_PseudoVDIVU_VV_M2_E32 = 1377, + RISCV_PseudoVDIVU_VV_M2_E32_MASK = 1378, + RISCV_PseudoVDIVU_VV_M2_E64 = 1379, + RISCV_PseudoVDIVU_VV_M2_E64_MASK = 1380, + RISCV_PseudoVDIVU_VV_M2_E8 = 1381, + RISCV_PseudoVDIVU_VV_M2_E8_MASK = 1382, + RISCV_PseudoVDIVU_VV_M4_E16 = 1383, + RISCV_PseudoVDIVU_VV_M4_E16_MASK = 1384, + RISCV_PseudoVDIVU_VV_M4_E32 = 1385, + RISCV_PseudoVDIVU_VV_M4_E32_MASK = 1386, + RISCV_PseudoVDIVU_VV_M4_E64 = 1387, + RISCV_PseudoVDIVU_VV_M4_E64_MASK = 1388, + RISCV_PseudoVDIVU_VV_M4_E8 = 1389, + RISCV_PseudoVDIVU_VV_M4_E8_MASK = 1390, + RISCV_PseudoVDIVU_VV_M8_E16 = 1391, + RISCV_PseudoVDIVU_VV_M8_E16_MASK = 1392, + RISCV_PseudoVDIVU_VV_M8_E32 = 1393, + RISCV_PseudoVDIVU_VV_M8_E32_MASK = 1394, + RISCV_PseudoVDIVU_VV_M8_E64 = 1395, + RISCV_PseudoVDIVU_VV_M8_E64_MASK = 1396, + RISCV_PseudoVDIVU_VV_M8_E8 = 1397, + RISCV_PseudoVDIVU_VV_M8_E8_MASK = 1398, + RISCV_PseudoVDIVU_VV_MF2_E16 = 1399, + RISCV_PseudoVDIVU_VV_MF2_E16_MASK = 1400, + RISCV_PseudoVDIVU_VV_MF2_E32 = 1401, + RISCV_PseudoVDIVU_VV_MF2_E32_MASK = 1402, + RISCV_PseudoVDIVU_VV_MF2_E8 = 1403, + RISCV_PseudoVDIVU_VV_MF2_E8_MASK = 1404, + RISCV_PseudoVDIVU_VV_MF4_E16 = 1405, + RISCV_PseudoVDIVU_VV_MF4_E16_MASK = 1406, + RISCV_PseudoVDIVU_VV_MF4_E8 = 1407, + RISCV_PseudoVDIVU_VV_MF4_E8_MASK = 1408, + RISCV_PseudoVDIVU_VV_MF8_E8 = 1409, + RISCV_PseudoVDIVU_VV_MF8_E8_MASK = 1410, + RISCV_PseudoVDIVU_VX_M1_E16 = 1411, + RISCV_PseudoVDIVU_VX_M1_E16_MASK = 1412, + RISCV_PseudoVDIVU_VX_M1_E32 = 1413, + RISCV_PseudoVDIVU_VX_M1_E32_MASK = 1414, + RISCV_PseudoVDIVU_VX_M1_E64 = 1415, + RISCV_PseudoVDIVU_VX_M1_E64_MASK = 1416, + RISCV_PseudoVDIVU_VX_M1_E8 = 1417, + RISCV_PseudoVDIVU_VX_M1_E8_MASK = 1418, + RISCV_PseudoVDIVU_VX_M2_E16 = 1419, + RISCV_PseudoVDIVU_VX_M2_E16_MASK = 1420, + RISCV_PseudoVDIVU_VX_M2_E32 = 1421, + RISCV_PseudoVDIVU_VX_M2_E32_MASK = 1422, + RISCV_PseudoVDIVU_VX_M2_E64 = 1423, + RISCV_PseudoVDIVU_VX_M2_E64_MASK = 1424, + RISCV_PseudoVDIVU_VX_M2_E8 = 1425, + RISCV_PseudoVDIVU_VX_M2_E8_MASK = 1426, + RISCV_PseudoVDIVU_VX_M4_E16 = 1427, + RISCV_PseudoVDIVU_VX_M4_E16_MASK = 1428, + RISCV_PseudoVDIVU_VX_M4_E32 = 1429, + RISCV_PseudoVDIVU_VX_M4_E32_MASK = 1430, + RISCV_PseudoVDIVU_VX_M4_E64 = 1431, + RISCV_PseudoVDIVU_VX_M4_E64_MASK = 1432, + RISCV_PseudoVDIVU_VX_M4_E8 = 1433, + RISCV_PseudoVDIVU_VX_M4_E8_MASK = 1434, + RISCV_PseudoVDIVU_VX_M8_E16 = 1435, + RISCV_PseudoVDIVU_VX_M8_E16_MASK = 1436, + RISCV_PseudoVDIVU_VX_M8_E32 = 1437, + RISCV_PseudoVDIVU_VX_M8_E32_MASK = 1438, + RISCV_PseudoVDIVU_VX_M8_E64 = 1439, + RISCV_PseudoVDIVU_VX_M8_E64_MASK = 1440, + RISCV_PseudoVDIVU_VX_M8_E8 = 1441, + RISCV_PseudoVDIVU_VX_M8_E8_MASK = 1442, + RISCV_PseudoVDIVU_VX_MF2_E16 = 1443, + RISCV_PseudoVDIVU_VX_MF2_E16_MASK = 1444, + RISCV_PseudoVDIVU_VX_MF2_E32 = 1445, + RISCV_PseudoVDIVU_VX_MF2_E32_MASK = 1446, + RISCV_PseudoVDIVU_VX_MF2_E8 = 1447, + RISCV_PseudoVDIVU_VX_MF2_E8_MASK = 1448, + RISCV_PseudoVDIVU_VX_MF4_E16 = 1449, + RISCV_PseudoVDIVU_VX_MF4_E16_MASK = 1450, + RISCV_PseudoVDIVU_VX_MF4_E8 = 1451, + RISCV_PseudoVDIVU_VX_MF4_E8_MASK = 1452, + RISCV_PseudoVDIVU_VX_MF8_E8 = 1453, + RISCV_PseudoVDIVU_VX_MF8_E8_MASK = 1454, + RISCV_PseudoVDIV_VV_M1_E16 = 1455, + RISCV_PseudoVDIV_VV_M1_E16_MASK = 1456, + RISCV_PseudoVDIV_VV_M1_E32 = 1457, + RISCV_PseudoVDIV_VV_M1_E32_MASK = 1458, + RISCV_PseudoVDIV_VV_M1_E64 = 1459, + RISCV_PseudoVDIV_VV_M1_E64_MASK = 1460, + RISCV_PseudoVDIV_VV_M1_E8 = 1461, + RISCV_PseudoVDIV_VV_M1_E8_MASK = 1462, + RISCV_PseudoVDIV_VV_M2_E16 = 1463, + RISCV_PseudoVDIV_VV_M2_E16_MASK = 1464, + RISCV_PseudoVDIV_VV_M2_E32 = 1465, + RISCV_PseudoVDIV_VV_M2_E32_MASK = 1466, + RISCV_PseudoVDIV_VV_M2_E64 = 1467, + RISCV_PseudoVDIV_VV_M2_E64_MASK = 1468, + RISCV_PseudoVDIV_VV_M2_E8 = 1469, + RISCV_PseudoVDIV_VV_M2_E8_MASK = 1470, + RISCV_PseudoVDIV_VV_M4_E16 = 1471, + RISCV_PseudoVDIV_VV_M4_E16_MASK = 1472, + RISCV_PseudoVDIV_VV_M4_E32 = 1473, + RISCV_PseudoVDIV_VV_M4_E32_MASK = 1474, + RISCV_PseudoVDIV_VV_M4_E64 = 1475, + RISCV_PseudoVDIV_VV_M4_E64_MASK = 1476, + RISCV_PseudoVDIV_VV_M4_E8 = 1477, + RISCV_PseudoVDIV_VV_M4_E8_MASK = 1478, + RISCV_PseudoVDIV_VV_M8_E16 = 1479, + RISCV_PseudoVDIV_VV_M8_E16_MASK = 1480, + RISCV_PseudoVDIV_VV_M8_E32 = 1481, + RISCV_PseudoVDIV_VV_M8_E32_MASK = 1482, + RISCV_PseudoVDIV_VV_M8_E64 = 1483, + RISCV_PseudoVDIV_VV_M8_E64_MASK = 1484, + RISCV_PseudoVDIV_VV_M8_E8 = 1485, + RISCV_PseudoVDIV_VV_M8_E8_MASK = 1486, + RISCV_PseudoVDIV_VV_MF2_E16 = 1487, + RISCV_PseudoVDIV_VV_MF2_E16_MASK = 1488, + RISCV_PseudoVDIV_VV_MF2_E32 = 1489, + RISCV_PseudoVDIV_VV_MF2_E32_MASK = 1490, + RISCV_PseudoVDIV_VV_MF2_E8 = 1491, + RISCV_PseudoVDIV_VV_MF2_E8_MASK = 1492, + RISCV_PseudoVDIV_VV_MF4_E16 = 1493, + RISCV_PseudoVDIV_VV_MF4_E16_MASK = 1494, + RISCV_PseudoVDIV_VV_MF4_E8 = 1495, + RISCV_PseudoVDIV_VV_MF4_E8_MASK = 1496, + RISCV_PseudoVDIV_VV_MF8_E8 = 1497, + RISCV_PseudoVDIV_VV_MF8_E8_MASK = 1498, + RISCV_PseudoVDIV_VX_M1_E16 = 1499, + RISCV_PseudoVDIV_VX_M1_E16_MASK = 1500, + RISCV_PseudoVDIV_VX_M1_E32 = 1501, + RISCV_PseudoVDIV_VX_M1_E32_MASK = 1502, + RISCV_PseudoVDIV_VX_M1_E64 = 1503, + RISCV_PseudoVDIV_VX_M1_E64_MASK = 1504, + RISCV_PseudoVDIV_VX_M1_E8 = 1505, + RISCV_PseudoVDIV_VX_M1_E8_MASK = 1506, + RISCV_PseudoVDIV_VX_M2_E16 = 1507, + RISCV_PseudoVDIV_VX_M2_E16_MASK = 1508, + RISCV_PseudoVDIV_VX_M2_E32 = 1509, + RISCV_PseudoVDIV_VX_M2_E32_MASK = 1510, + RISCV_PseudoVDIV_VX_M2_E64 = 1511, + RISCV_PseudoVDIV_VX_M2_E64_MASK = 1512, + RISCV_PseudoVDIV_VX_M2_E8 = 1513, + RISCV_PseudoVDIV_VX_M2_E8_MASK = 1514, + RISCV_PseudoVDIV_VX_M4_E16 = 1515, + RISCV_PseudoVDIV_VX_M4_E16_MASK = 1516, + RISCV_PseudoVDIV_VX_M4_E32 = 1517, + RISCV_PseudoVDIV_VX_M4_E32_MASK = 1518, + RISCV_PseudoVDIV_VX_M4_E64 = 1519, + RISCV_PseudoVDIV_VX_M4_E64_MASK = 1520, + RISCV_PseudoVDIV_VX_M4_E8 = 1521, + RISCV_PseudoVDIV_VX_M4_E8_MASK = 1522, + RISCV_PseudoVDIV_VX_M8_E16 = 1523, + RISCV_PseudoVDIV_VX_M8_E16_MASK = 1524, + RISCV_PseudoVDIV_VX_M8_E32 = 1525, + RISCV_PseudoVDIV_VX_M8_E32_MASK = 1526, + RISCV_PseudoVDIV_VX_M8_E64 = 1527, + RISCV_PseudoVDIV_VX_M8_E64_MASK = 1528, + RISCV_PseudoVDIV_VX_M8_E8 = 1529, + RISCV_PseudoVDIV_VX_M8_E8_MASK = 1530, + RISCV_PseudoVDIV_VX_MF2_E16 = 1531, + RISCV_PseudoVDIV_VX_MF2_E16_MASK = 1532, + RISCV_PseudoVDIV_VX_MF2_E32 = 1533, + RISCV_PseudoVDIV_VX_MF2_E32_MASK = 1534, + RISCV_PseudoVDIV_VX_MF2_E8 = 1535, + RISCV_PseudoVDIV_VX_MF2_E8_MASK = 1536, + RISCV_PseudoVDIV_VX_MF4_E16 = 1537, + RISCV_PseudoVDIV_VX_MF4_E16_MASK = 1538, + RISCV_PseudoVDIV_VX_MF4_E8 = 1539, + RISCV_PseudoVDIV_VX_MF4_E8_MASK = 1540, + RISCV_PseudoVDIV_VX_MF8_E8 = 1541, + RISCV_PseudoVDIV_VX_MF8_E8_MASK = 1542, + RISCV_PseudoVFADD_VFPR16_M1 = 1543, + RISCV_PseudoVFADD_VFPR16_M1_MASK = 1544, + RISCV_PseudoVFADD_VFPR16_M2 = 1545, + RISCV_PseudoVFADD_VFPR16_M2_MASK = 1546, + RISCV_PseudoVFADD_VFPR16_M4 = 1547, + RISCV_PseudoVFADD_VFPR16_M4_MASK = 1548, + RISCV_PseudoVFADD_VFPR16_M8 = 1549, + RISCV_PseudoVFADD_VFPR16_M8_MASK = 1550, + RISCV_PseudoVFADD_VFPR16_MF2 = 1551, + RISCV_PseudoVFADD_VFPR16_MF2_MASK = 1552, + RISCV_PseudoVFADD_VFPR16_MF4 = 1553, + RISCV_PseudoVFADD_VFPR16_MF4_MASK = 1554, + RISCV_PseudoVFADD_VFPR32_M1 = 1555, + RISCV_PseudoVFADD_VFPR32_M1_MASK = 1556, + RISCV_PseudoVFADD_VFPR32_M2 = 1557, + RISCV_PseudoVFADD_VFPR32_M2_MASK = 1558, + RISCV_PseudoVFADD_VFPR32_M4 = 1559, + RISCV_PseudoVFADD_VFPR32_M4_MASK = 1560, + RISCV_PseudoVFADD_VFPR32_M8 = 1561, + RISCV_PseudoVFADD_VFPR32_M8_MASK = 1562, + RISCV_PseudoVFADD_VFPR32_MF2 = 1563, + RISCV_PseudoVFADD_VFPR32_MF2_MASK = 1564, + RISCV_PseudoVFADD_VFPR64_M1 = 1565, + RISCV_PseudoVFADD_VFPR64_M1_MASK = 1566, + RISCV_PseudoVFADD_VFPR64_M2 = 1567, + RISCV_PseudoVFADD_VFPR64_M2_MASK = 1568, + RISCV_PseudoVFADD_VFPR64_M4 = 1569, + RISCV_PseudoVFADD_VFPR64_M4_MASK = 1570, + RISCV_PseudoVFADD_VFPR64_M8 = 1571, + RISCV_PseudoVFADD_VFPR64_M8_MASK = 1572, + RISCV_PseudoVFADD_VV_M1 = 1573, + RISCV_PseudoVFADD_VV_M1_MASK = 1574, + RISCV_PseudoVFADD_VV_M2 = 1575, + RISCV_PseudoVFADD_VV_M2_MASK = 1576, + RISCV_PseudoVFADD_VV_M4 = 1577, + RISCV_PseudoVFADD_VV_M4_MASK = 1578, + RISCV_PseudoVFADD_VV_M8 = 1579, + RISCV_PseudoVFADD_VV_M8_MASK = 1580, + RISCV_PseudoVFADD_VV_MF2 = 1581, + RISCV_PseudoVFADD_VV_MF2_MASK = 1582, + RISCV_PseudoVFADD_VV_MF4 = 1583, + RISCV_PseudoVFADD_VV_MF4_MASK = 1584, + RISCV_PseudoVFCLASS_V_M1 = 1585, + RISCV_PseudoVFCLASS_V_M1_MASK = 1586, + RISCV_PseudoVFCLASS_V_M2 = 1587, + RISCV_PseudoVFCLASS_V_M2_MASK = 1588, + RISCV_PseudoVFCLASS_V_M4 = 1589, + RISCV_PseudoVFCLASS_V_M4_MASK = 1590, + RISCV_PseudoVFCLASS_V_M8 = 1591, + RISCV_PseudoVFCLASS_V_M8_MASK = 1592, + RISCV_PseudoVFCLASS_V_MF2 = 1593, + RISCV_PseudoVFCLASS_V_MF2_MASK = 1594, + RISCV_PseudoVFCLASS_V_MF4 = 1595, + RISCV_PseudoVFCLASS_V_MF4_MASK = 1596, + RISCV_PseudoVFCVT_F_XU_V_M1 = 1597, + RISCV_PseudoVFCVT_F_XU_V_M1_MASK = 1598, + RISCV_PseudoVFCVT_F_XU_V_M2 = 1599, + RISCV_PseudoVFCVT_F_XU_V_M2_MASK = 1600, + RISCV_PseudoVFCVT_F_XU_V_M4 = 1601, + RISCV_PseudoVFCVT_F_XU_V_M4_MASK = 1602, + RISCV_PseudoVFCVT_F_XU_V_M8 = 1603, + RISCV_PseudoVFCVT_F_XU_V_M8_MASK = 1604, + RISCV_PseudoVFCVT_F_XU_V_MF2 = 1605, + RISCV_PseudoVFCVT_F_XU_V_MF2_MASK = 1606, + RISCV_PseudoVFCVT_F_XU_V_MF4 = 1607, + RISCV_PseudoVFCVT_F_XU_V_MF4_MASK = 1608, + RISCV_PseudoVFCVT_F_X_V_M1 = 1609, + RISCV_PseudoVFCVT_F_X_V_M1_MASK = 1610, + RISCV_PseudoVFCVT_F_X_V_M2 = 1611, + RISCV_PseudoVFCVT_F_X_V_M2_MASK = 1612, + RISCV_PseudoVFCVT_F_X_V_M4 = 1613, + RISCV_PseudoVFCVT_F_X_V_M4_MASK = 1614, + RISCV_PseudoVFCVT_F_X_V_M8 = 1615, + RISCV_PseudoVFCVT_F_X_V_M8_MASK = 1616, + RISCV_PseudoVFCVT_F_X_V_MF2 = 1617, + RISCV_PseudoVFCVT_F_X_V_MF2_MASK = 1618, + RISCV_PseudoVFCVT_F_X_V_MF4 = 1619, + RISCV_PseudoVFCVT_F_X_V_MF4_MASK = 1620, + RISCV_PseudoVFCVT_RM_F_XU_V_M1 = 1621, + RISCV_PseudoVFCVT_RM_F_XU_V_M1_MASK = 1622, + RISCV_PseudoVFCVT_RM_F_XU_V_M2 = 1623, + RISCV_PseudoVFCVT_RM_F_XU_V_M2_MASK = 1624, + RISCV_PseudoVFCVT_RM_F_XU_V_M4 = 1625, + RISCV_PseudoVFCVT_RM_F_XU_V_M4_MASK = 1626, + RISCV_PseudoVFCVT_RM_F_XU_V_M8 = 1627, + RISCV_PseudoVFCVT_RM_F_XU_V_M8_MASK = 1628, + RISCV_PseudoVFCVT_RM_F_XU_V_MF2 = 1629, + RISCV_PseudoVFCVT_RM_F_XU_V_MF2_MASK = 1630, + RISCV_PseudoVFCVT_RM_F_XU_V_MF4 = 1631, + RISCV_PseudoVFCVT_RM_F_XU_V_MF4_MASK = 1632, + RISCV_PseudoVFCVT_RM_F_X_V_M1 = 1633, + RISCV_PseudoVFCVT_RM_F_X_V_M1_MASK = 1634, + RISCV_PseudoVFCVT_RM_F_X_V_M2 = 1635, + RISCV_PseudoVFCVT_RM_F_X_V_M2_MASK = 1636, + RISCV_PseudoVFCVT_RM_F_X_V_M4 = 1637, + RISCV_PseudoVFCVT_RM_F_X_V_M4_MASK = 1638, + RISCV_PseudoVFCVT_RM_F_X_V_M8 = 1639, + RISCV_PseudoVFCVT_RM_F_X_V_M8_MASK = 1640, + RISCV_PseudoVFCVT_RM_F_X_V_MF2 = 1641, + RISCV_PseudoVFCVT_RM_F_X_V_MF2_MASK = 1642, + RISCV_PseudoVFCVT_RM_F_X_V_MF4 = 1643, + RISCV_PseudoVFCVT_RM_F_X_V_MF4_MASK = 1644, + RISCV_PseudoVFCVT_RM_XU_F_V_M1 = 1645, + RISCV_PseudoVFCVT_RM_XU_F_V_M1_MASK = 1646, + RISCV_PseudoVFCVT_RM_XU_F_V_M2 = 1647, + RISCV_PseudoVFCVT_RM_XU_F_V_M2_MASK = 1648, + RISCV_PseudoVFCVT_RM_XU_F_V_M4 = 1649, + RISCV_PseudoVFCVT_RM_XU_F_V_M4_MASK = 1650, + RISCV_PseudoVFCVT_RM_XU_F_V_M8 = 1651, + RISCV_PseudoVFCVT_RM_XU_F_V_M8_MASK = 1652, + RISCV_PseudoVFCVT_RM_XU_F_V_MF2 = 1653, + RISCV_PseudoVFCVT_RM_XU_F_V_MF2_MASK = 1654, + RISCV_PseudoVFCVT_RM_XU_F_V_MF4 = 1655, + RISCV_PseudoVFCVT_RM_XU_F_V_MF4_MASK = 1656, + RISCV_PseudoVFCVT_RM_X_F_V_M1 = 1657, + RISCV_PseudoVFCVT_RM_X_F_V_M1_MASK = 1658, + RISCV_PseudoVFCVT_RM_X_F_V_M2 = 1659, + RISCV_PseudoVFCVT_RM_X_F_V_M2_MASK = 1660, + RISCV_PseudoVFCVT_RM_X_F_V_M4 = 1661, + RISCV_PseudoVFCVT_RM_X_F_V_M4_MASK = 1662, + RISCV_PseudoVFCVT_RM_X_F_V_M8 = 1663, + RISCV_PseudoVFCVT_RM_X_F_V_M8_MASK = 1664, + RISCV_PseudoVFCVT_RM_X_F_V_MF2 = 1665, + RISCV_PseudoVFCVT_RM_X_F_V_MF2_MASK = 1666, + RISCV_PseudoVFCVT_RM_X_F_V_MF4 = 1667, + RISCV_PseudoVFCVT_RM_X_F_V_MF4_MASK = 1668, + RISCV_PseudoVFCVT_RTZ_XU_F_V_M1 = 1669, + RISCV_PseudoVFCVT_RTZ_XU_F_V_M1_MASK = 1670, + RISCV_PseudoVFCVT_RTZ_XU_F_V_M2 = 1671, + RISCV_PseudoVFCVT_RTZ_XU_F_V_M2_MASK = 1672, + RISCV_PseudoVFCVT_RTZ_XU_F_V_M4 = 1673, + RISCV_PseudoVFCVT_RTZ_XU_F_V_M4_MASK = 1674, + RISCV_PseudoVFCVT_RTZ_XU_F_V_M8 = 1675, + RISCV_PseudoVFCVT_RTZ_XU_F_V_M8_MASK = 1676, + RISCV_PseudoVFCVT_RTZ_XU_F_V_MF2 = 1677, + RISCV_PseudoVFCVT_RTZ_XU_F_V_MF2_MASK = 1678, + RISCV_PseudoVFCVT_RTZ_XU_F_V_MF4 = 1679, + RISCV_PseudoVFCVT_RTZ_XU_F_V_MF4_MASK = 1680, + RISCV_PseudoVFCVT_RTZ_X_F_V_M1 = 1681, + RISCV_PseudoVFCVT_RTZ_X_F_V_M1_MASK = 1682, + RISCV_PseudoVFCVT_RTZ_X_F_V_M2 = 1683, + RISCV_PseudoVFCVT_RTZ_X_F_V_M2_MASK = 1684, + RISCV_PseudoVFCVT_RTZ_X_F_V_M4 = 1685, + RISCV_PseudoVFCVT_RTZ_X_F_V_M4_MASK = 1686, + RISCV_PseudoVFCVT_RTZ_X_F_V_M8 = 1687, + RISCV_PseudoVFCVT_RTZ_X_F_V_M8_MASK = 1688, + RISCV_PseudoVFCVT_RTZ_X_F_V_MF2 = 1689, + RISCV_PseudoVFCVT_RTZ_X_F_V_MF2_MASK = 1690, + RISCV_PseudoVFCVT_RTZ_X_F_V_MF4 = 1691, + RISCV_PseudoVFCVT_RTZ_X_F_V_MF4_MASK = 1692, + RISCV_PseudoVFCVT_XU_F_V_M1 = 1693, + RISCV_PseudoVFCVT_XU_F_V_M1_MASK = 1694, + RISCV_PseudoVFCVT_XU_F_V_M2 = 1695, + RISCV_PseudoVFCVT_XU_F_V_M2_MASK = 1696, + RISCV_PseudoVFCVT_XU_F_V_M4 = 1697, + RISCV_PseudoVFCVT_XU_F_V_M4_MASK = 1698, + RISCV_PseudoVFCVT_XU_F_V_M8 = 1699, + RISCV_PseudoVFCVT_XU_F_V_M8_MASK = 1700, + RISCV_PseudoVFCVT_XU_F_V_MF2 = 1701, + RISCV_PseudoVFCVT_XU_F_V_MF2_MASK = 1702, + RISCV_PseudoVFCVT_XU_F_V_MF4 = 1703, + RISCV_PseudoVFCVT_XU_F_V_MF4_MASK = 1704, + RISCV_PseudoVFCVT_X_F_V_M1 = 1705, + RISCV_PseudoVFCVT_X_F_V_M1_MASK = 1706, + RISCV_PseudoVFCVT_X_F_V_M2 = 1707, + RISCV_PseudoVFCVT_X_F_V_M2_MASK = 1708, + RISCV_PseudoVFCVT_X_F_V_M4 = 1709, + RISCV_PseudoVFCVT_X_F_V_M4_MASK = 1710, + RISCV_PseudoVFCVT_X_F_V_M8 = 1711, + RISCV_PseudoVFCVT_X_F_V_M8_MASK = 1712, + RISCV_PseudoVFCVT_X_F_V_MF2 = 1713, + RISCV_PseudoVFCVT_X_F_V_MF2_MASK = 1714, + RISCV_PseudoVFCVT_X_F_V_MF4 = 1715, + RISCV_PseudoVFCVT_X_F_V_MF4_MASK = 1716, + RISCV_PseudoVFDIV_VFPR16_M1_E16 = 1717, + RISCV_PseudoVFDIV_VFPR16_M1_E16_MASK = 1718, + RISCV_PseudoVFDIV_VFPR16_M2_E16 = 1719, + RISCV_PseudoVFDIV_VFPR16_M2_E16_MASK = 1720, + RISCV_PseudoVFDIV_VFPR16_M4_E16 = 1721, + RISCV_PseudoVFDIV_VFPR16_M4_E16_MASK = 1722, + RISCV_PseudoVFDIV_VFPR16_M8_E16 = 1723, + RISCV_PseudoVFDIV_VFPR16_M8_E16_MASK = 1724, + RISCV_PseudoVFDIV_VFPR16_MF2_E16 = 1725, + RISCV_PseudoVFDIV_VFPR16_MF2_E16_MASK = 1726, + RISCV_PseudoVFDIV_VFPR16_MF4_E16 = 1727, + RISCV_PseudoVFDIV_VFPR16_MF4_E16_MASK = 1728, + RISCV_PseudoVFDIV_VFPR32_M1_E32 = 1729, + RISCV_PseudoVFDIV_VFPR32_M1_E32_MASK = 1730, + RISCV_PseudoVFDIV_VFPR32_M2_E32 = 1731, + RISCV_PseudoVFDIV_VFPR32_M2_E32_MASK = 1732, + RISCV_PseudoVFDIV_VFPR32_M4_E32 = 1733, + RISCV_PseudoVFDIV_VFPR32_M4_E32_MASK = 1734, + RISCV_PseudoVFDIV_VFPR32_M8_E32 = 1735, + RISCV_PseudoVFDIV_VFPR32_M8_E32_MASK = 1736, + RISCV_PseudoVFDIV_VFPR32_MF2_E32 = 1737, + RISCV_PseudoVFDIV_VFPR32_MF2_E32_MASK = 1738, + RISCV_PseudoVFDIV_VFPR64_M1_E64 = 1739, + RISCV_PseudoVFDIV_VFPR64_M1_E64_MASK = 1740, + RISCV_PseudoVFDIV_VFPR64_M2_E64 = 1741, + RISCV_PseudoVFDIV_VFPR64_M2_E64_MASK = 1742, + RISCV_PseudoVFDIV_VFPR64_M4_E64 = 1743, + RISCV_PseudoVFDIV_VFPR64_M4_E64_MASK = 1744, + RISCV_PseudoVFDIV_VFPR64_M8_E64 = 1745, + RISCV_PseudoVFDIV_VFPR64_M8_E64_MASK = 1746, + RISCV_PseudoVFDIV_VV_M1_E16 = 1747, + RISCV_PseudoVFDIV_VV_M1_E16_MASK = 1748, + RISCV_PseudoVFDIV_VV_M1_E32 = 1749, + RISCV_PseudoVFDIV_VV_M1_E32_MASK = 1750, + RISCV_PseudoVFDIV_VV_M1_E64 = 1751, + RISCV_PseudoVFDIV_VV_M1_E64_MASK = 1752, + RISCV_PseudoVFDIV_VV_M2_E16 = 1753, + RISCV_PseudoVFDIV_VV_M2_E16_MASK = 1754, + RISCV_PseudoVFDIV_VV_M2_E32 = 1755, + RISCV_PseudoVFDIV_VV_M2_E32_MASK = 1756, + RISCV_PseudoVFDIV_VV_M2_E64 = 1757, + RISCV_PseudoVFDIV_VV_M2_E64_MASK = 1758, + RISCV_PseudoVFDIV_VV_M4_E16 = 1759, + RISCV_PseudoVFDIV_VV_M4_E16_MASK = 1760, + RISCV_PseudoVFDIV_VV_M4_E32 = 1761, + RISCV_PseudoVFDIV_VV_M4_E32_MASK = 1762, + RISCV_PseudoVFDIV_VV_M4_E64 = 1763, + RISCV_PseudoVFDIV_VV_M4_E64_MASK = 1764, + RISCV_PseudoVFDIV_VV_M8_E16 = 1765, + RISCV_PseudoVFDIV_VV_M8_E16_MASK = 1766, + RISCV_PseudoVFDIV_VV_M8_E32 = 1767, + RISCV_PseudoVFDIV_VV_M8_E32_MASK = 1768, + RISCV_PseudoVFDIV_VV_M8_E64 = 1769, + RISCV_PseudoVFDIV_VV_M8_E64_MASK = 1770, + RISCV_PseudoVFDIV_VV_MF2_E16 = 1771, + RISCV_PseudoVFDIV_VV_MF2_E16_MASK = 1772, + RISCV_PseudoVFDIV_VV_MF2_E32 = 1773, + RISCV_PseudoVFDIV_VV_MF2_E32_MASK = 1774, + RISCV_PseudoVFDIV_VV_MF4_E16 = 1775, + RISCV_PseudoVFDIV_VV_MF4_E16_MASK = 1776, + RISCV_PseudoVFIRST_M_B1 = 1777, + RISCV_PseudoVFIRST_M_B16 = 1778, + RISCV_PseudoVFIRST_M_B16_MASK = 1779, + RISCV_PseudoVFIRST_M_B1_MASK = 1780, + RISCV_PseudoVFIRST_M_B2 = 1781, + RISCV_PseudoVFIRST_M_B2_MASK = 1782, + RISCV_PseudoVFIRST_M_B32 = 1783, + RISCV_PseudoVFIRST_M_B32_MASK = 1784, + RISCV_PseudoVFIRST_M_B4 = 1785, + RISCV_PseudoVFIRST_M_B4_MASK = 1786, + RISCV_PseudoVFIRST_M_B64 = 1787, + RISCV_PseudoVFIRST_M_B64_MASK = 1788, + RISCV_PseudoVFIRST_M_B8 = 1789, + RISCV_PseudoVFIRST_M_B8_MASK = 1790, + RISCV_PseudoVFMACC_VFPR16_M1 = 1791, + RISCV_PseudoVFMACC_VFPR16_M1_MASK = 1792, + RISCV_PseudoVFMACC_VFPR16_M2 = 1793, + RISCV_PseudoVFMACC_VFPR16_M2_MASK = 1794, + RISCV_PseudoVFMACC_VFPR16_M4 = 1795, + RISCV_PseudoVFMACC_VFPR16_M4_MASK = 1796, + RISCV_PseudoVFMACC_VFPR16_M8 = 1797, + RISCV_PseudoVFMACC_VFPR16_M8_MASK = 1798, + RISCV_PseudoVFMACC_VFPR16_MF2 = 1799, + RISCV_PseudoVFMACC_VFPR16_MF2_MASK = 1800, + RISCV_PseudoVFMACC_VFPR16_MF4 = 1801, + RISCV_PseudoVFMACC_VFPR16_MF4_MASK = 1802, + RISCV_PseudoVFMACC_VFPR32_M1 = 1803, + RISCV_PseudoVFMACC_VFPR32_M1_MASK = 1804, + RISCV_PseudoVFMACC_VFPR32_M2 = 1805, + RISCV_PseudoVFMACC_VFPR32_M2_MASK = 1806, + RISCV_PseudoVFMACC_VFPR32_M4 = 1807, + RISCV_PseudoVFMACC_VFPR32_M4_MASK = 1808, + RISCV_PseudoVFMACC_VFPR32_M8 = 1809, + RISCV_PseudoVFMACC_VFPR32_M8_MASK = 1810, + RISCV_PseudoVFMACC_VFPR32_MF2 = 1811, + RISCV_PseudoVFMACC_VFPR32_MF2_MASK = 1812, + RISCV_PseudoVFMACC_VFPR64_M1 = 1813, + RISCV_PseudoVFMACC_VFPR64_M1_MASK = 1814, + RISCV_PseudoVFMACC_VFPR64_M2 = 1815, + RISCV_PseudoVFMACC_VFPR64_M2_MASK = 1816, + RISCV_PseudoVFMACC_VFPR64_M4 = 1817, + RISCV_PseudoVFMACC_VFPR64_M4_MASK = 1818, + RISCV_PseudoVFMACC_VFPR64_M8 = 1819, + RISCV_PseudoVFMACC_VFPR64_M8_MASK = 1820, + RISCV_PseudoVFMACC_VV_M1 = 1821, + RISCV_PseudoVFMACC_VV_M1_MASK = 1822, + RISCV_PseudoVFMACC_VV_M2 = 1823, + RISCV_PseudoVFMACC_VV_M2_MASK = 1824, + RISCV_PseudoVFMACC_VV_M4 = 1825, + RISCV_PseudoVFMACC_VV_M4_MASK = 1826, + RISCV_PseudoVFMACC_VV_M8 = 1827, + RISCV_PseudoVFMACC_VV_M8_MASK = 1828, + RISCV_PseudoVFMACC_VV_MF2 = 1829, + RISCV_PseudoVFMACC_VV_MF2_MASK = 1830, + RISCV_PseudoVFMACC_VV_MF4 = 1831, + RISCV_PseudoVFMACC_VV_MF4_MASK = 1832, + RISCV_PseudoVFMADD_VFPR16_M1 = 1833, + RISCV_PseudoVFMADD_VFPR16_M1_MASK = 1834, + RISCV_PseudoVFMADD_VFPR16_M2 = 1835, + RISCV_PseudoVFMADD_VFPR16_M2_MASK = 1836, + RISCV_PseudoVFMADD_VFPR16_M4 = 1837, + RISCV_PseudoVFMADD_VFPR16_M4_MASK = 1838, + RISCV_PseudoVFMADD_VFPR16_M8 = 1839, + RISCV_PseudoVFMADD_VFPR16_M8_MASK = 1840, + RISCV_PseudoVFMADD_VFPR16_MF2 = 1841, + RISCV_PseudoVFMADD_VFPR16_MF2_MASK = 1842, + RISCV_PseudoVFMADD_VFPR16_MF4 = 1843, + RISCV_PseudoVFMADD_VFPR16_MF4_MASK = 1844, + RISCV_PseudoVFMADD_VFPR32_M1 = 1845, + RISCV_PseudoVFMADD_VFPR32_M1_MASK = 1846, + RISCV_PseudoVFMADD_VFPR32_M2 = 1847, + RISCV_PseudoVFMADD_VFPR32_M2_MASK = 1848, + RISCV_PseudoVFMADD_VFPR32_M4 = 1849, + RISCV_PseudoVFMADD_VFPR32_M4_MASK = 1850, + RISCV_PseudoVFMADD_VFPR32_M8 = 1851, + RISCV_PseudoVFMADD_VFPR32_M8_MASK = 1852, + RISCV_PseudoVFMADD_VFPR32_MF2 = 1853, + RISCV_PseudoVFMADD_VFPR32_MF2_MASK = 1854, + RISCV_PseudoVFMADD_VFPR64_M1 = 1855, + RISCV_PseudoVFMADD_VFPR64_M1_MASK = 1856, + RISCV_PseudoVFMADD_VFPR64_M2 = 1857, + RISCV_PseudoVFMADD_VFPR64_M2_MASK = 1858, + RISCV_PseudoVFMADD_VFPR64_M4 = 1859, + RISCV_PseudoVFMADD_VFPR64_M4_MASK = 1860, + RISCV_PseudoVFMADD_VFPR64_M8 = 1861, + RISCV_PseudoVFMADD_VFPR64_M8_MASK = 1862, + RISCV_PseudoVFMADD_VV_M1 = 1863, + RISCV_PseudoVFMADD_VV_M1_MASK = 1864, + RISCV_PseudoVFMADD_VV_M2 = 1865, + RISCV_PseudoVFMADD_VV_M2_MASK = 1866, + RISCV_PseudoVFMADD_VV_M4 = 1867, + RISCV_PseudoVFMADD_VV_M4_MASK = 1868, + RISCV_PseudoVFMADD_VV_M8 = 1869, + RISCV_PseudoVFMADD_VV_M8_MASK = 1870, + RISCV_PseudoVFMADD_VV_MF2 = 1871, + RISCV_PseudoVFMADD_VV_MF2_MASK = 1872, + RISCV_PseudoVFMADD_VV_MF4 = 1873, + RISCV_PseudoVFMADD_VV_MF4_MASK = 1874, + RISCV_PseudoVFMAX_VFPR16_M1 = 1875, + RISCV_PseudoVFMAX_VFPR16_M1_MASK = 1876, + RISCV_PseudoVFMAX_VFPR16_M2 = 1877, + RISCV_PseudoVFMAX_VFPR16_M2_MASK = 1878, + RISCV_PseudoVFMAX_VFPR16_M4 = 1879, + RISCV_PseudoVFMAX_VFPR16_M4_MASK = 1880, + RISCV_PseudoVFMAX_VFPR16_M8 = 1881, + RISCV_PseudoVFMAX_VFPR16_M8_MASK = 1882, + RISCV_PseudoVFMAX_VFPR16_MF2 = 1883, + RISCV_PseudoVFMAX_VFPR16_MF2_MASK = 1884, + RISCV_PseudoVFMAX_VFPR16_MF4 = 1885, + RISCV_PseudoVFMAX_VFPR16_MF4_MASK = 1886, + RISCV_PseudoVFMAX_VFPR32_M1 = 1887, + RISCV_PseudoVFMAX_VFPR32_M1_MASK = 1888, + RISCV_PseudoVFMAX_VFPR32_M2 = 1889, + RISCV_PseudoVFMAX_VFPR32_M2_MASK = 1890, + RISCV_PseudoVFMAX_VFPR32_M4 = 1891, + RISCV_PseudoVFMAX_VFPR32_M4_MASK = 1892, + RISCV_PseudoVFMAX_VFPR32_M8 = 1893, + RISCV_PseudoVFMAX_VFPR32_M8_MASK = 1894, + RISCV_PseudoVFMAX_VFPR32_MF2 = 1895, + RISCV_PseudoVFMAX_VFPR32_MF2_MASK = 1896, + RISCV_PseudoVFMAX_VFPR64_M1 = 1897, + RISCV_PseudoVFMAX_VFPR64_M1_MASK = 1898, + RISCV_PseudoVFMAX_VFPR64_M2 = 1899, + RISCV_PseudoVFMAX_VFPR64_M2_MASK = 1900, + RISCV_PseudoVFMAX_VFPR64_M4 = 1901, + RISCV_PseudoVFMAX_VFPR64_M4_MASK = 1902, + RISCV_PseudoVFMAX_VFPR64_M8 = 1903, + RISCV_PseudoVFMAX_VFPR64_M8_MASK = 1904, + RISCV_PseudoVFMAX_VV_M1 = 1905, + RISCV_PseudoVFMAX_VV_M1_MASK = 1906, + RISCV_PseudoVFMAX_VV_M2 = 1907, + RISCV_PseudoVFMAX_VV_M2_MASK = 1908, + RISCV_PseudoVFMAX_VV_M4 = 1909, + RISCV_PseudoVFMAX_VV_M4_MASK = 1910, + RISCV_PseudoVFMAX_VV_M8 = 1911, + RISCV_PseudoVFMAX_VV_M8_MASK = 1912, + RISCV_PseudoVFMAX_VV_MF2 = 1913, + RISCV_PseudoVFMAX_VV_MF2_MASK = 1914, + RISCV_PseudoVFMAX_VV_MF4 = 1915, + RISCV_PseudoVFMAX_VV_MF4_MASK = 1916, + RISCV_PseudoVFMERGE_VFPR16M_M1 = 1917, + RISCV_PseudoVFMERGE_VFPR16M_M2 = 1918, + RISCV_PseudoVFMERGE_VFPR16M_M4 = 1919, + RISCV_PseudoVFMERGE_VFPR16M_M8 = 1920, + RISCV_PseudoVFMERGE_VFPR16M_MF2 = 1921, + RISCV_PseudoVFMERGE_VFPR16M_MF4 = 1922, + RISCV_PseudoVFMERGE_VFPR32M_M1 = 1923, + RISCV_PseudoVFMERGE_VFPR32M_M2 = 1924, + RISCV_PseudoVFMERGE_VFPR32M_M4 = 1925, + RISCV_PseudoVFMERGE_VFPR32M_M8 = 1926, + RISCV_PseudoVFMERGE_VFPR32M_MF2 = 1927, + RISCV_PseudoVFMERGE_VFPR64M_M1 = 1928, + RISCV_PseudoVFMERGE_VFPR64M_M2 = 1929, + RISCV_PseudoVFMERGE_VFPR64M_M4 = 1930, + RISCV_PseudoVFMERGE_VFPR64M_M8 = 1931, + RISCV_PseudoVFMIN_VFPR16_M1 = 1932, + RISCV_PseudoVFMIN_VFPR16_M1_MASK = 1933, + RISCV_PseudoVFMIN_VFPR16_M2 = 1934, + RISCV_PseudoVFMIN_VFPR16_M2_MASK = 1935, + RISCV_PseudoVFMIN_VFPR16_M4 = 1936, + RISCV_PseudoVFMIN_VFPR16_M4_MASK = 1937, + RISCV_PseudoVFMIN_VFPR16_M8 = 1938, + RISCV_PseudoVFMIN_VFPR16_M8_MASK = 1939, + RISCV_PseudoVFMIN_VFPR16_MF2 = 1940, + RISCV_PseudoVFMIN_VFPR16_MF2_MASK = 1941, + RISCV_PseudoVFMIN_VFPR16_MF4 = 1942, + RISCV_PseudoVFMIN_VFPR16_MF4_MASK = 1943, + RISCV_PseudoVFMIN_VFPR32_M1 = 1944, + RISCV_PseudoVFMIN_VFPR32_M1_MASK = 1945, + RISCV_PseudoVFMIN_VFPR32_M2 = 1946, + RISCV_PseudoVFMIN_VFPR32_M2_MASK = 1947, + RISCV_PseudoVFMIN_VFPR32_M4 = 1948, + RISCV_PseudoVFMIN_VFPR32_M4_MASK = 1949, + RISCV_PseudoVFMIN_VFPR32_M8 = 1950, + RISCV_PseudoVFMIN_VFPR32_M8_MASK = 1951, + RISCV_PseudoVFMIN_VFPR32_MF2 = 1952, + RISCV_PseudoVFMIN_VFPR32_MF2_MASK = 1953, + RISCV_PseudoVFMIN_VFPR64_M1 = 1954, + RISCV_PseudoVFMIN_VFPR64_M1_MASK = 1955, + RISCV_PseudoVFMIN_VFPR64_M2 = 1956, + RISCV_PseudoVFMIN_VFPR64_M2_MASK = 1957, + RISCV_PseudoVFMIN_VFPR64_M4 = 1958, + RISCV_PseudoVFMIN_VFPR64_M4_MASK = 1959, + RISCV_PseudoVFMIN_VFPR64_M8 = 1960, + RISCV_PseudoVFMIN_VFPR64_M8_MASK = 1961, + RISCV_PseudoVFMIN_VV_M1 = 1962, + RISCV_PseudoVFMIN_VV_M1_MASK = 1963, + RISCV_PseudoVFMIN_VV_M2 = 1964, + RISCV_PseudoVFMIN_VV_M2_MASK = 1965, + RISCV_PseudoVFMIN_VV_M4 = 1966, + RISCV_PseudoVFMIN_VV_M4_MASK = 1967, + RISCV_PseudoVFMIN_VV_M8 = 1968, + RISCV_PseudoVFMIN_VV_M8_MASK = 1969, + RISCV_PseudoVFMIN_VV_MF2 = 1970, + RISCV_PseudoVFMIN_VV_MF2_MASK = 1971, + RISCV_PseudoVFMIN_VV_MF4 = 1972, + RISCV_PseudoVFMIN_VV_MF4_MASK = 1973, + RISCV_PseudoVFMSAC_VFPR16_M1 = 1974, + RISCV_PseudoVFMSAC_VFPR16_M1_MASK = 1975, + RISCV_PseudoVFMSAC_VFPR16_M2 = 1976, + RISCV_PseudoVFMSAC_VFPR16_M2_MASK = 1977, + RISCV_PseudoVFMSAC_VFPR16_M4 = 1978, + RISCV_PseudoVFMSAC_VFPR16_M4_MASK = 1979, + RISCV_PseudoVFMSAC_VFPR16_M8 = 1980, + RISCV_PseudoVFMSAC_VFPR16_M8_MASK = 1981, + RISCV_PseudoVFMSAC_VFPR16_MF2 = 1982, + RISCV_PseudoVFMSAC_VFPR16_MF2_MASK = 1983, + RISCV_PseudoVFMSAC_VFPR16_MF4 = 1984, + RISCV_PseudoVFMSAC_VFPR16_MF4_MASK = 1985, + RISCV_PseudoVFMSAC_VFPR32_M1 = 1986, + RISCV_PseudoVFMSAC_VFPR32_M1_MASK = 1987, + RISCV_PseudoVFMSAC_VFPR32_M2 = 1988, + RISCV_PseudoVFMSAC_VFPR32_M2_MASK = 1989, + RISCV_PseudoVFMSAC_VFPR32_M4 = 1990, + RISCV_PseudoVFMSAC_VFPR32_M4_MASK = 1991, + RISCV_PseudoVFMSAC_VFPR32_M8 = 1992, + RISCV_PseudoVFMSAC_VFPR32_M8_MASK = 1993, + RISCV_PseudoVFMSAC_VFPR32_MF2 = 1994, + RISCV_PseudoVFMSAC_VFPR32_MF2_MASK = 1995, + RISCV_PseudoVFMSAC_VFPR64_M1 = 1996, + RISCV_PseudoVFMSAC_VFPR64_M1_MASK = 1997, + RISCV_PseudoVFMSAC_VFPR64_M2 = 1998, + RISCV_PseudoVFMSAC_VFPR64_M2_MASK = 1999, + RISCV_PseudoVFMSAC_VFPR64_M4 = 2000, + RISCV_PseudoVFMSAC_VFPR64_M4_MASK = 2001, + RISCV_PseudoVFMSAC_VFPR64_M8 = 2002, + RISCV_PseudoVFMSAC_VFPR64_M8_MASK = 2003, + RISCV_PseudoVFMSAC_VV_M1 = 2004, + RISCV_PseudoVFMSAC_VV_M1_MASK = 2005, + RISCV_PseudoVFMSAC_VV_M2 = 2006, + RISCV_PseudoVFMSAC_VV_M2_MASK = 2007, + RISCV_PseudoVFMSAC_VV_M4 = 2008, + RISCV_PseudoVFMSAC_VV_M4_MASK = 2009, + RISCV_PseudoVFMSAC_VV_M8 = 2010, + RISCV_PseudoVFMSAC_VV_M8_MASK = 2011, + RISCV_PseudoVFMSAC_VV_MF2 = 2012, + RISCV_PseudoVFMSAC_VV_MF2_MASK = 2013, + RISCV_PseudoVFMSAC_VV_MF4 = 2014, + RISCV_PseudoVFMSAC_VV_MF4_MASK = 2015, + RISCV_PseudoVFMSUB_VFPR16_M1 = 2016, + RISCV_PseudoVFMSUB_VFPR16_M1_MASK = 2017, + RISCV_PseudoVFMSUB_VFPR16_M2 = 2018, + RISCV_PseudoVFMSUB_VFPR16_M2_MASK = 2019, + RISCV_PseudoVFMSUB_VFPR16_M4 = 2020, + RISCV_PseudoVFMSUB_VFPR16_M4_MASK = 2021, + RISCV_PseudoVFMSUB_VFPR16_M8 = 2022, + RISCV_PseudoVFMSUB_VFPR16_M8_MASK = 2023, + RISCV_PseudoVFMSUB_VFPR16_MF2 = 2024, + RISCV_PseudoVFMSUB_VFPR16_MF2_MASK = 2025, + RISCV_PseudoVFMSUB_VFPR16_MF4 = 2026, + RISCV_PseudoVFMSUB_VFPR16_MF4_MASK = 2027, + RISCV_PseudoVFMSUB_VFPR32_M1 = 2028, + RISCV_PseudoVFMSUB_VFPR32_M1_MASK = 2029, + RISCV_PseudoVFMSUB_VFPR32_M2 = 2030, + RISCV_PseudoVFMSUB_VFPR32_M2_MASK = 2031, + RISCV_PseudoVFMSUB_VFPR32_M4 = 2032, + RISCV_PseudoVFMSUB_VFPR32_M4_MASK = 2033, + RISCV_PseudoVFMSUB_VFPR32_M8 = 2034, + RISCV_PseudoVFMSUB_VFPR32_M8_MASK = 2035, + RISCV_PseudoVFMSUB_VFPR32_MF2 = 2036, + RISCV_PseudoVFMSUB_VFPR32_MF2_MASK = 2037, + RISCV_PseudoVFMSUB_VFPR64_M1 = 2038, + RISCV_PseudoVFMSUB_VFPR64_M1_MASK = 2039, + RISCV_PseudoVFMSUB_VFPR64_M2 = 2040, + RISCV_PseudoVFMSUB_VFPR64_M2_MASK = 2041, + RISCV_PseudoVFMSUB_VFPR64_M4 = 2042, + RISCV_PseudoVFMSUB_VFPR64_M4_MASK = 2043, + RISCV_PseudoVFMSUB_VFPR64_M8 = 2044, + RISCV_PseudoVFMSUB_VFPR64_M8_MASK = 2045, + RISCV_PseudoVFMSUB_VV_M1 = 2046, + RISCV_PseudoVFMSUB_VV_M1_MASK = 2047, + RISCV_PseudoVFMSUB_VV_M2 = 2048, + RISCV_PseudoVFMSUB_VV_M2_MASK = 2049, + RISCV_PseudoVFMSUB_VV_M4 = 2050, + RISCV_PseudoVFMSUB_VV_M4_MASK = 2051, + RISCV_PseudoVFMSUB_VV_M8 = 2052, + RISCV_PseudoVFMSUB_VV_M8_MASK = 2053, + RISCV_PseudoVFMSUB_VV_MF2 = 2054, + RISCV_PseudoVFMSUB_VV_MF2_MASK = 2055, + RISCV_PseudoVFMSUB_VV_MF4 = 2056, + RISCV_PseudoVFMSUB_VV_MF4_MASK = 2057, + RISCV_PseudoVFMUL_VFPR16_M1 = 2058, + RISCV_PseudoVFMUL_VFPR16_M1_MASK = 2059, + RISCV_PseudoVFMUL_VFPR16_M2 = 2060, + RISCV_PseudoVFMUL_VFPR16_M2_MASK = 2061, + RISCV_PseudoVFMUL_VFPR16_M4 = 2062, + RISCV_PseudoVFMUL_VFPR16_M4_MASK = 2063, + RISCV_PseudoVFMUL_VFPR16_M8 = 2064, + RISCV_PseudoVFMUL_VFPR16_M8_MASK = 2065, + RISCV_PseudoVFMUL_VFPR16_MF2 = 2066, + RISCV_PseudoVFMUL_VFPR16_MF2_MASK = 2067, + RISCV_PseudoVFMUL_VFPR16_MF4 = 2068, + RISCV_PseudoVFMUL_VFPR16_MF4_MASK = 2069, + RISCV_PseudoVFMUL_VFPR32_M1 = 2070, + RISCV_PseudoVFMUL_VFPR32_M1_MASK = 2071, + RISCV_PseudoVFMUL_VFPR32_M2 = 2072, + RISCV_PseudoVFMUL_VFPR32_M2_MASK = 2073, + RISCV_PseudoVFMUL_VFPR32_M4 = 2074, + RISCV_PseudoVFMUL_VFPR32_M4_MASK = 2075, + RISCV_PseudoVFMUL_VFPR32_M8 = 2076, + RISCV_PseudoVFMUL_VFPR32_M8_MASK = 2077, + RISCV_PseudoVFMUL_VFPR32_MF2 = 2078, + RISCV_PseudoVFMUL_VFPR32_MF2_MASK = 2079, + RISCV_PseudoVFMUL_VFPR64_M1 = 2080, + RISCV_PseudoVFMUL_VFPR64_M1_MASK = 2081, + RISCV_PseudoVFMUL_VFPR64_M2 = 2082, + RISCV_PseudoVFMUL_VFPR64_M2_MASK = 2083, + RISCV_PseudoVFMUL_VFPR64_M4 = 2084, + RISCV_PseudoVFMUL_VFPR64_M4_MASK = 2085, + RISCV_PseudoVFMUL_VFPR64_M8 = 2086, + RISCV_PseudoVFMUL_VFPR64_M8_MASK = 2087, + RISCV_PseudoVFMUL_VV_M1 = 2088, + RISCV_PseudoVFMUL_VV_M1_MASK = 2089, + RISCV_PseudoVFMUL_VV_M2 = 2090, + RISCV_PseudoVFMUL_VV_M2_MASK = 2091, + RISCV_PseudoVFMUL_VV_M4 = 2092, + RISCV_PseudoVFMUL_VV_M4_MASK = 2093, + RISCV_PseudoVFMUL_VV_M8 = 2094, + RISCV_PseudoVFMUL_VV_M8_MASK = 2095, + RISCV_PseudoVFMUL_VV_MF2 = 2096, + RISCV_PseudoVFMUL_VV_MF2_MASK = 2097, + RISCV_PseudoVFMUL_VV_MF4 = 2098, + RISCV_PseudoVFMUL_VV_MF4_MASK = 2099, + RISCV_PseudoVFMV_FPR16_S_M1 = 2100, + RISCV_PseudoVFMV_FPR16_S_M2 = 2101, + RISCV_PseudoVFMV_FPR16_S_M4 = 2102, + RISCV_PseudoVFMV_FPR16_S_M8 = 2103, + RISCV_PseudoVFMV_FPR16_S_MF2 = 2104, + RISCV_PseudoVFMV_FPR16_S_MF4 = 2105, + RISCV_PseudoVFMV_FPR32_S_M1 = 2106, + RISCV_PseudoVFMV_FPR32_S_M2 = 2107, + RISCV_PseudoVFMV_FPR32_S_M4 = 2108, + RISCV_PseudoVFMV_FPR32_S_M8 = 2109, + RISCV_PseudoVFMV_FPR32_S_MF2 = 2110, + RISCV_PseudoVFMV_FPR64_S_M1 = 2111, + RISCV_PseudoVFMV_FPR64_S_M2 = 2112, + RISCV_PseudoVFMV_FPR64_S_M4 = 2113, + RISCV_PseudoVFMV_FPR64_S_M8 = 2114, + RISCV_PseudoVFMV_S_FPR16_M1 = 2115, + RISCV_PseudoVFMV_S_FPR16_M2 = 2116, + RISCV_PseudoVFMV_S_FPR16_M4 = 2117, + RISCV_PseudoVFMV_S_FPR16_M8 = 2118, + RISCV_PseudoVFMV_S_FPR16_MF2 = 2119, + RISCV_PseudoVFMV_S_FPR16_MF4 = 2120, + RISCV_PseudoVFMV_S_FPR32_M1 = 2121, + RISCV_PseudoVFMV_S_FPR32_M2 = 2122, + RISCV_PseudoVFMV_S_FPR32_M4 = 2123, + RISCV_PseudoVFMV_S_FPR32_M8 = 2124, + RISCV_PseudoVFMV_S_FPR32_MF2 = 2125, + RISCV_PseudoVFMV_S_FPR64_M1 = 2126, + RISCV_PseudoVFMV_S_FPR64_M2 = 2127, + RISCV_PseudoVFMV_S_FPR64_M4 = 2128, + RISCV_PseudoVFMV_S_FPR64_M8 = 2129, + RISCV_PseudoVFMV_V_FPR16_M1 = 2130, + RISCV_PseudoVFMV_V_FPR16_M2 = 2131, + RISCV_PseudoVFMV_V_FPR16_M4 = 2132, + RISCV_PseudoVFMV_V_FPR16_M8 = 2133, + RISCV_PseudoVFMV_V_FPR16_MF2 = 2134, + RISCV_PseudoVFMV_V_FPR16_MF4 = 2135, + RISCV_PseudoVFMV_V_FPR32_M1 = 2136, + RISCV_PseudoVFMV_V_FPR32_M2 = 2137, + RISCV_PseudoVFMV_V_FPR32_M4 = 2138, + RISCV_PseudoVFMV_V_FPR32_M8 = 2139, + RISCV_PseudoVFMV_V_FPR32_MF2 = 2140, + RISCV_PseudoVFMV_V_FPR64_M1 = 2141, + RISCV_PseudoVFMV_V_FPR64_M2 = 2142, + RISCV_PseudoVFMV_V_FPR64_M4 = 2143, + RISCV_PseudoVFMV_V_FPR64_M8 = 2144, + RISCV_PseudoVFNCVTBF16_F_F_W_M1 = 2145, + RISCV_PseudoVFNCVTBF16_F_F_W_M1_MASK = 2146, + RISCV_PseudoVFNCVTBF16_F_F_W_M2 = 2147, + RISCV_PseudoVFNCVTBF16_F_F_W_M2_MASK = 2148, + RISCV_PseudoVFNCVTBF16_F_F_W_M4 = 2149, + RISCV_PseudoVFNCVTBF16_F_F_W_M4_MASK = 2150, + RISCV_PseudoVFNCVTBF16_F_F_W_MF2 = 2151, + RISCV_PseudoVFNCVTBF16_F_F_W_MF2_MASK = 2152, + RISCV_PseudoVFNCVTBF16_F_F_W_MF4 = 2153, + RISCV_PseudoVFNCVTBF16_F_F_W_MF4_MASK = 2154, + RISCV_PseudoVFNCVT_F_F_W_M1 = 2155, + RISCV_PseudoVFNCVT_F_F_W_M1_MASK = 2156, + RISCV_PseudoVFNCVT_F_F_W_M2 = 2157, + RISCV_PseudoVFNCVT_F_F_W_M2_MASK = 2158, + RISCV_PseudoVFNCVT_F_F_W_M4 = 2159, + RISCV_PseudoVFNCVT_F_F_W_M4_MASK = 2160, + RISCV_PseudoVFNCVT_F_F_W_MF2 = 2161, + RISCV_PseudoVFNCVT_F_F_W_MF2_MASK = 2162, + RISCV_PseudoVFNCVT_F_F_W_MF4 = 2163, + RISCV_PseudoVFNCVT_F_F_W_MF4_MASK = 2164, + RISCV_PseudoVFNCVT_F_XU_W_M1 = 2165, + RISCV_PseudoVFNCVT_F_XU_W_M1_MASK = 2166, + RISCV_PseudoVFNCVT_F_XU_W_M2 = 2167, + RISCV_PseudoVFNCVT_F_XU_W_M2_MASK = 2168, + RISCV_PseudoVFNCVT_F_XU_W_M4 = 2169, + RISCV_PseudoVFNCVT_F_XU_W_M4_MASK = 2170, + RISCV_PseudoVFNCVT_F_XU_W_MF2 = 2171, + RISCV_PseudoVFNCVT_F_XU_W_MF2_MASK = 2172, + RISCV_PseudoVFNCVT_F_XU_W_MF4 = 2173, + RISCV_PseudoVFNCVT_F_XU_W_MF4_MASK = 2174, + RISCV_PseudoVFNCVT_F_X_W_M1 = 2175, + RISCV_PseudoVFNCVT_F_X_W_M1_MASK = 2176, + RISCV_PseudoVFNCVT_F_X_W_M2 = 2177, + RISCV_PseudoVFNCVT_F_X_W_M2_MASK = 2178, + RISCV_PseudoVFNCVT_F_X_W_M4 = 2179, + RISCV_PseudoVFNCVT_F_X_W_M4_MASK = 2180, + RISCV_PseudoVFNCVT_F_X_W_MF2 = 2181, + RISCV_PseudoVFNCVT_F_X_W_MF2_MASK = 2182, + RISCV_PseudoVFNCVT_F_X_W_MF4 = 2183, + RISCV_PseudoVFNCVT_F_X_W_MF4_MASK = 2184, + RISCV_PseudoVFNCVT_RM_F_XU_W_M1 = 2185, + RISCV_PseudoVFNCVT_RM_F_XU_W_M1_MASK = 2186, + RISCV_PseudoVFNCVT_RM_F_XU_W_M2 = 2187, + RISCV_PseudoVFNCVT_RM_F_XU_W_M2_MASK = 2188, + RISCV_PseudoVFNCVT_RM_F_XU_W_M4 = 2189, + RISCV_PseudoVFNCVT_RM_F_XU_W_M4_MASK = 2190, + RISCV_PseudoVFNCVT_RM_F_XU_W_MF2 = 2191, + RISCV_PseudoVFNCVT_RM_F_XU_W_MF2_MASK = 2192, + RISCV_PseudoVFNCVT_RM_F_XU_W_MF4 = 2193, + RISCV_PseudoVFNCVT_RM_F_XU_W_MF4_MASK = 2194, + RISCV_PseudoVFNCVT_RM_F_X_W_M1 = 2195, + RISCV_PseudoVFNCVT_RM_F_X_W_M1_MASK = 2196, + RISCV_PseudoVFNCVT_RM_F_X_W_M2 = 2197, + RISCV_PseudoVFNCVT_RM_F_X_W_M2_MASK = 2198, + RISCV_PseudoVFNCVT_RM_F_X_W_M4 = 2199, + RISCV_PseudoVFNCVT_RM_F_X_W_M4_MASK = 2200, + RISCV_PseudoVFNCVT_RM_F_X_W_MF2 = 2201, + RISCV_PseudoVFNCVT_RM_F_X_W_MF2_MASK = 2202, + RISCV_PseudoVFNCVT_RM_F_X_W_MF4 = 2203, + RISCV_PseudoVFNCVT_RM_F_X_W_MF4_MASK = 2204, + RISCV_PseudoVFNCVT_RM_XU_F_W_M1 = 2205, + RISCV_PseudoVFNCVT_RM_XU_F_W_M1_MASK = 2206, + RISCV_PseudoVFNCVT_RM_XU_F_W_M2 = 2207, + RISCV_PseudoVFNCVT_RM_XU_F_W_M2_MASK = 2208, + RISCV_PseudoVFNCVT_RM_XU_F_W_M4 = 2209, + RISCV_PseudoVFNCVT_RM_XU_F_W_M4_MASK = 2210, + RISCV_PseudoVFNCVT_RM_XU_F_W_MF2 = 2211, + RISCV_PseudoVFNCVT_RM_XU_F_W_MF2_MASK = 2212, + RISCV_PseudoVFNCVT_RM_XU_F_W_MF4 = 2213, + RISCV_PseudoVFNCVT_RM_XU_F_W_MF4_MASK = 2214, + RISCV_PseudoVFNCVT_RM_XU_F_W_MF8 = 2215, + RISCV_PseudoVFNCVT_RM_XU_F_W_MF8_MASK = 2216, + RISCV_PseudoVFNCVT_RM_X_F_W_M1 = 2217, + RISCV_PseudoVFNCVT_RM_X_F_W_M1_MASK = 2218, + RISCV_PseudoVFNCVT_RM_X_F_W_M2 = 2219, + RISCV_PseudoVFNCVT_RM_X_F_W_M2_MASK = 2220, + RISCV_PseudoVFNCVT_RM_X_F_W_M4 = 2221, + RISCV_PseudoVFNCVT_RM_X_F_W_M4_MASK = 2222, + RISCV_PseudoVFNCVT_RM_X_F_W_MF2 = 2223, + RISCV_PseudoVFNCVT_RM_X_F_W_MF2_MASK = 2224, + RISCV_PseudoVFNCVT_RM_X_F_W_MF4 = 2225, + RISCV_PseudoVFNCVT_RM_X_F_W_MF4_MASK = 2226, + RISCV_PseudoVFNCVT_RM_X_F_W_MF8 = 2227, + RISCV_PseudoVFNCVT_RM_X_F_W_MF8_MASK = 2228, + RISCV_PseudoVFNCVT_ROD_F_F_W_M1 = 2229, + RISCV_PseudoVFNCVT_ROD_F_F_W_M1_MASK = 2230, + RISCV_PseudoVFNCVT_ROD_F_F_W_M2 = 2231, + RISCV_PseudoVFNCVT_ROD_F_F_W_M2_MASK = 2232, + RISCV_PseudoVFNCVT_ROD_F_F_W_M4 = 2233, + RISCV_PseudoVFNCVT_ROD_F_F_W_M4_MASK = 2234, + RISCV_PseudoVFNCVT_ROD_F_F_W_MF2 = 2235, + RISCV_PseudoVFNCVT_ROD_F_F_W_MF2_MASK = 2236, + RISCV_PseudoVFNCVT_ROD_F_F_W_MF4 = 2237, + RISCV_PseudoVFNCVT_ROD_F_F_W_MF4_MASK = 2238, + RISCV_PseudoVFNCVT_RTZ_XU_F_W_M1 = 2239, + RISCV_PseudoVFNCVT_RTZ_XU_F_W_M1_MASK = 2240, + RISCV_PseudoVFNCVT_RTZ_XU_F_W_M2 = 2241, + RISCV_PseudoVFNCVT_RTZ_XU_F_W_M2_MASK = 2242, + RISCV_PseudoVFNCVT_RTZ_XU_F_W_M4 = 2243, + RISCV_PseudoVFNCVT_RTZ_XU_F_W_M4_MASK = 2244, + RISCV_PseudoVFNCVT_RTZ_XU_F_W_MF2 = 2245, + RISCV_PseudoVFNCVT_RTZ_XU_F_W_MF2_MASK = 2246, + RISCV_PseudoVFNCVT_RTZ_XU_F_W_MF4 = 2247, + RISCV_PseudoVFNCVT_RTZ_XU_F_W_MF4_MASK = 2248, + RISCV_PseudoVFNCVT_RTZ_XU_F_W_MF8 = 2249, + RISCV_PseudoVFNCVT_RTZ_XU_F_W_MF8_MASK = 2250, + RISCV_PseudoVFNCVT_RTZ_X_F_W_M1 = 2251, + RISCV_PseudoVFNCVT_RTZ_X_F_W_M1_MASK = 2252, + RISCV_PseudoVFNCVT_RTZ_X_F_W_M2 = 2253, + RISCV_PseudoVFNCVT_RTZ_X_F_W_M2_MASK = 2254, + RISCV_PseudoVFNCVT_RTZ_X_F_W_M4 = 2255, + RISCV_PseudoVFNCVT_RTZ_X_F_W_M4_MASK = 2256, + RISCV_PseudoVFNCVT_RTZ_X_F_W_MF2 = 2257, + RISCV_PseudoVFNCVT_RTZ_X_F_W_MF2_MASK = 2258, + RISCV_PseudoVFNCVT_RTZ_X_F_W_MF4 = 2259, + RISCV_PseudoVFNCVT_RTZ_X_F_W_MF4_MASK = 2260, + RISCV_PseudoVFNCVT_RTZ_X_F_W_MF8 = 2261, + RISCV_PseudoVFNCVT_RTZ_X_F_W_MF8_MASK = 2262, + RISCV_PseudoVFNCVT_XU_F_W_M1 = 2263, + RISCV_PseudoVFNCVT_XU_F_W_M1_MASK = 2264, + RISCV_PseudoVFNCVT_XU_F_W_M2 = 2265, + RISCV_PseudoVFNCVT_XU_F_W_M2_MASK = 2266, + RISCV_PseudoVFNCVT_XU_F_W_M4 = 2267, + RISCV_PseudoVFNCVT_XU_F_W_M4_MASK = 2268, + RISCV_PseudoVFNCVT_XU_F_W_MF2 = 2269, + RISCV_PseudoVFNCVT_XU_F_W_MF2_MASK = 2270, + RISCV_PseudoVFNCVT_XU_F_W_MF4 = 2271, + RISCV_PseudoVFNCVT_XU_F_W_MF4_MASK = 2272, + RISCV_PseudoVFNCVT_XU_F_W_MF8 = 2273, + RISCV_PseudoVFNCVT_XU_F_W_MF8_MASK = 2274, + RISCV_PseudoVFNCVT_X_F_W_M1 = 2275, + RISCV_PseudoVFNCVT_X_F_W_M1_MASK = 2276, + RISCV_PseudoVFNCVT_X_F_W_M2 = 2277, + RISCV_PseudoVFNCVT_X_F_W_M2_MASK = 2278, + RISCV_PseudoVFNCVT_X_F_W_M4 = 2279, + RISCV_PseudoVFNCVT_X_F_W_M4_MASK = 2280, + RISCV_PseudoVFNCVT_X_F_W_MF2 = 2281, + RISCV_PseudoVFNCVT_X_F_W_MF2_MASK = 2282, + RISCV_PseudoVFNCVT_X_F_W_MF4 = 2283, + RISCV_PseudoVFNCVT_X_F_W_MF4_MASK = 2284, + RISCV_PseudoVFNCVT_X_F_W_MF8 = 2285, + RISCV_PseudoVFNCVT_X_F_W_MF8_MASK = 2286, + RISCV_PseudoVFNMACC_VFPR16_M1 = 2287, + RISCV_PseudoVFNMACC_VFPR16_M1_MASK = 2288, + RISCV_PseudoVFNMACC_VFPR16_M2 = 2289, + RISCV_PseudoVFNMACC_VFPR16_M2_MASK = 2290, + RISCV_PseudoVFNMACC_VFPR16_M4 = 2291, + RISCV_PseudoVFNMACC_VFPR16_M4_MASK = 2292, + RISCV_PseudoVFNMACC_VFPR16_M8 = 2293, + RISCV_PseudoVFNMACC_VFPR16_M8_MASK = 2294, + RISCV_PseudoVFNMACC_VFPR16_MF2 = 2295, + RISCV_PseudoVFNMACC_VFPR16_MF2_MASK = 2296, + RISCV_PseudoVFNMACC_VFPR16_MF4 = 2297, + RISCV_PseudoVFNMACC_VFPR16_MF4_MASK = 2298, + RISCV_PseudoVFNMACC_VFPR32_M1 = 2299, + RISCV_PseudoVFNMACC_VFPR32_M1_MASK = 2300, + RISCV_PseudoVFNMACC_VFPR32_M2 = 2301, + RISCV_PseudoVFNMACC_VFPR32_M2_MASK = 2302, + RISCV_PseudoVFNMACC_VFPR32_M4 = 2303, + RISCV_PseudoVFNMACC_VFPR32_M4_MASK = 2304, + RISCV_PseudoVFNMACC_VFPR32_M8 = 2305, + RISCV_PseudoVFNMACC_VFPR32_M8_MASK = 2306, + RISCV_PseudoVFNMACC_VFPR32_MF2 = 2307, + RISCV_PseudoVFNMACC_VFPR32_MF2_MASK = 2308, + RISCV_PseudoVFNMACC_VFPR64_M1 = 2309, + RISCV_PseudoVFNMACC_VFPR64_M1_MASK = 2310, + RISCV_PseudoVFNMACC_VFPR64_M2 = 2311, + RISCV_PseudoVFNMACC_VFPR64_M2_MASK = 2312, + RISCV_PseudoVFNMACC_VFPR64_M4 = 2313, + RISCV_PseudoVFNMACC_VFPR64_M4_MASK = 2314, + RISCV_PseudoVFNMACC_VFPR64_M8 = 2315, + RISCV_PseudoVFNMACC_VFPR64_M8_MASK = 2316, + RISCV_PseudoVFNMACC_VV_M1 = 2317, + RISCV_PseudoVFNMACC_VV_M1_MASK = 2318, + RISCV_PseudoVFNMACC_VV_M2 = 2319, + RISCV_PseudoVFNMACC_VV_M2_MASK = 2320, + RISCV_PseudoVFNMACC_VV_M4 = 2321, + RISCV_PseudoVFNMACC_VV_M4_MASK = 2322, + RISCV_PseudoVFNMACC_VV_M8 = 2323, + RISCV_PseudoVFNMACC_VV_M8_MASK = 2324, + RISCV_PseudoVFNMACC_VV_MF2 = 2325, + RISCV_PseudoVFNMACC_VV_MF2_MASK = 2326, + RISCV_PseudoVFNMACC_VV_MF4 = 2327, + RISCV_PseudoVFNMACC_VV_MF4_MASK = 2328, + RISCV_PseudoVFNMADD_VFPR16_M1 = 2329, + RISCV_PseudoVFNMADD_VFPR16_M1_MASK = 2330, + RISCV_PseudoVFNMADD_VFPR16_M2 = 2331, + RISCV_PseudoVFNMADD_VFPR16_M2_MASK = 2332, + RISCV_PseudoVFNMADD_VFPR16_M4 = 2333, + RISCV_PseudoVFNMADD_VFPR16_M4_MASK = 2334, + RISCV_PseudoVFNMADD_VFPR16_M8 = 2335, + RISCV_PseudoVFNMADD_VFPR16_M8_MASK = 2336, + RISCV_PseudoVFNMADD_VFPR16_MF2 = 2337, + RISCV_PseudoVFNMADD_VFPR16_MF2_MASK = 2338, + RISCV_PseudoVFNMADD_VFPR16_MF4 = 2339, + RISCV_PseudoVFNMADD_VFPR16_MF4_MASK = 2340, + RISCV_PseudoVFNMADD_VFPR32_M1 = 2341, + RISCV_PseudoVFNMADD_VFPR32_M1_MASK = 2342, + RISCV_PseudoVFNMADD_VFPR32_M2 = 2343, + RISCV_PseudoVFNMADD_VFPR32_M2_MASK = 2344, + RISCV_PseudoVFNMADD_VFPR32_M4 = 2345, + RISCV_PseudoVFNMADD_VFPR32_M4_MASK = 2346, + RISCV_PseudoVFNMADD_VFPR32_M8 = 2347, + RISCV_PseudoVFNMADD_VFPR32_M8_MASK = 2348, + RISCV_PseudoVFNMADD_VFPR32_MF2 = 2349, + RISCV_PseudoVFNMADD_VFPR32_MF2_MASK = 2350, + RISCV_PseudoVFNMADD_VFPR64_M1 = 2351, + RISCV_PseudoVFNMADD_VFPR64_M1_MASK = 2352, + RISCV_PseudoVFNMADD_VFPR64_M2 = 2353, + RISCV_PseudoVFNMADD_VFPR64_M2_MASK = 2354, + RISCV_PseudoVFNMADD_VFPR64_M4 = 2355, + RISCV_PseudoVFNMADD_VFPR64_M4_MASK = 2356, + RISCV_PseudoVFNMADD_VFPR64_M8 = 2357, + RISCV_PseudoVFNMADD_VFPR64_M8_MASK = 2358, + RISCV_PseudoVFNMADD_VV_M1 = 2359, + RISCV_PseudoVFNMADD_VV_M1_MASK = 2360, + RISCV_PseudoVFNMADD_VV_M2 = 2361, + RISCV_PseudoVFNMADD_VV_M2_MASK = 2362, + RISCV_PseudoVFNMADD_VV_M4 = 2363, + RISCV_PseudoVFNMADD_VV_M4_MASK = 2364, + RISCV_PseudoVFNMADD_VV_M8 = 2365, + RISCV_PseudoVFNMADD_VV_M8_MASK = 2366, + RISCV_PseudoVFNMADD_VV_MF2 = 2367, + RISCV_PseudoVFNMADD_VV_MF2_MASK = 2368, + RISCV_PseudoVFNMADD_VV_MF4 = 2369, + RISCV_PseudoVFNMADD_VV_MF4_MASK = 2370, + RISCV_PseudoVFNMSAC_VFPR16_M1 = 2371, + RISCV_PseudoVFNMSAC_VFPR16_M1_MASK = 2372, + RISCV_PseudoVFNMSAC_VFPR16_M2 = 2373, + RISCV_PseudoVFNMSAC_VFPR16_M2_MASK = 2374, + RISCV_PseudoVFNMSAC_VFPR16_M4 = 2375, + RISCV_PseudoVFNMSAC_VFPR16_M4_MASK = 2376, + RISCV_PseudoVFNMSAC_VFPR16_M8 = 2377, + RISCV_PseudoVFNMSAC_VFPR16_M8_MASK = 2378, + RISCV_PseudoVFNMSAC_VFPR16_MF2 = 2379, + RISCV_PseudoVFNMSAC_VFPR16_MF2_MASK = 2380, + RISCV_PseudoVFNMSAC_VFPR16_MF4 = 2381, + RISCV_PseudoVFNMSAC_VFPR16_MF4_MASK = 2382, + RISCV_PseudoVFNMSAC_VFPR32_M1 = 2383, + RISCV_PseudoVFNMSAC_VFPR32_M1_MASK = 2384, + RISCV_PseudoVFNMSAC_VFPR32_M2 = 2385, + RISCV_PseudoVFNMSAC_VFPR32_M2_MASK = 2386, + RISCV_PseudoVFNMSAC_VFPR32_M4 = 2387, + RISCV_PseudoVFNMSAC_VFPR32_M4_MASK = 2388, + RISCV_PseudoVFNMSAC_VFPR32_M8 = 2389, + RISCV_PseudoVFNMSAC_VFPR32_M8_MASK = 2390, + RISCV_PseudoVFNMSAC_VFPR32_MF2 = 2391, + RISCV_PseudoVFNMSAC_VFPR32_MF2_MASK = 2392, + RISCV_PseudoVFNMSAC_VFPR64_M1 = 2393, + RISCV_PseudoVFNMSAC_VFPR64_M1_MASK = 2394, + RISCV_PseudoVFNMSAC_VFPR64_M2 = 2395, + RISCV_PseudoVFNMSAC_VFPR64_M2_MASK = 2396, + RISCV_PseudoVFNMSAC_VFPR64_M4 = 2397, + RISCV_PseudoVFNMSAC_VFPR64_M4_MASK = 2398, + RISCV_PseudoVFNMSAC_VFPR64_M8 = 2399, + RISCV_PseudoVFNMSAC_VFPR64_M8_MASK = 2400, + RISCV_PseudoVFNMSAC_VV_M1 = 2401, + RISCV_PseudoVFNMSAC_VV_M1_MASK = 2402, + RISCV_PseudoVFNMSAC_VV_M2 = 2403, + RISCV_PseudoVFNMSAC_VV_M2_MASK = 2404, + RISCV_PseudoVFNMSAC_VV_M4 = 2405, + RISCV_PseudoVFNMSAC_VV_M4_MASK = 2406, + RISCV_PseudoVFNMSAC_VV_M8 = 2407, + RISCV_PseudoVFNMSAC_VV_M8_MASK = 2408, + RISCV_PseudoVFNMSAC_VV_MF2 = 2409, + RISCV_PseudoVFNMSAC_VV_MF2_MASK = 2410, + RISCV_PseudoVFNMSAC_VV_MF4 = 2411, + RISCV_PseudoVFNMSAC_VV_MF4_MASK = 2412, + RISCV_PseudoVFNMSUB_VFPR16_M1 = 2413, + RISCV_PseudoVFNMSUB_VFPR16_M1_MASK = 2414, + RISCV_PseudoVFNMSUB_VFPR16_M2 = 2415, + RISCV_PseudoVFNMSUB_VFPR16_M2_MASK = 2416, + RISCV_PseudoVFNMSUB_VFPR16_M4 = 2417, + RISCV_PseudoVFNMSUB_VFPR16_M4_MASK = 2418, + RISCV_PseudoVFNMSUB_VFPR16_M8 = 2419, + RISCV_PseudoVFNMSUB_VFPR16_M8_MASK = 2420, + RISCV_PseudoVFNMSUB_VFPR16_MF2 = 2421, + RISCV_PseudoVFNMSUB_VFPR16_MF2_MASK = 2422, + RISCV_PseudoVFNMSUB_VFPR16_MF4 = 2423, + RISCV_PseudoVFNMSUB_VFPR16_MF4_MASK = 2424, + RISCV_PseudoVFNMSUB_VFPR32_M1 = 2425, + RISCV_PseudoVFNMSUB_VFPR32_M1_MASK = 2426, + RISCV_PseudoVFNMSUB_VFPR32_M2 = 2427, + RISCV_PseudoVFNMSUB_VFPR32_M2_MASK = 2428, + RISCV_PseudoVFNMSUB_VFPR32_M4 = 2429, + RISCV_PseudoVFNMSUB_VFPR32_M4_MASK = 2430, + RISCV_PseudoVFNMSUB_VFPR32_M8 = 2431, + RISCV_PseudoVFNMSUB_VFPR32_M8_MASK = 2432, + RISCV_PseudoVFNMSUB_VFPR32_MF2 = 2433, + RISCV_PseudoVFNMSUB_VFPR32_MF2_MASK = 2434, + RISCV_PseudoVFNMSUB_VFPR64_M1 = 2435, + RISCV_PseudoVFNMSUB_VFPR64_M1_MASK = 2436, + RISCV_PseudoVFNMSUB_VFPR64_M2 = 2437, + RISCV_PseudoVFNMSUB_VFPR64_M2_MASK = 2438, + RISCV_PseudoVFNMSUB_VFPR64_M4 = 2439, + RISCV_PseudoVFNMSUB_VFPR64_M4_MASK = 2440, + RISCV_PseudoVFNMSUB_VFPR64_M8 = 2441, + RISCV_PseudoVFNMSUB_VFPR64_M8_MASK = 2442, + RISCV_PseudoVFNMSUB_VV_M1 = 2443, + RISCV_PseudoVFNMSUB_VV_M1_MASK = 2444, + RISCV_PseudoVFNMSUB_VV_M2 = 2445, + RISCV_PseudoVFNMSUB_VV_M2_MASK = 2446, + RISCV_PseudoVFNMSUB_VV_M4 = 2447, + RISCV_PseudoVFNMSUB_VV_M4_MASK = 2448, + RISCV_PseudoVFNMSUB_VV_M8 = 2449, + RISCV_PseudoVFNMSUB_VV_M8_MASK = 2450, + RISCV_PseudoVFNMSUB_VV_MF2 = 2451, + RISCV_PseudoVFNMSUB_VV_MF2_MASK = 2452, + RISCV_PseudoVFNMSUB_VV_MF4 = 2453, + RISCV_PseudoVFNMSUB_VV_MF4_MASK = 2454, + RISCV_PseudoVFNRCLIP_XU_F_QF_M1 = 2455, + RISCV_PseudoVFNRCLIP_XU_F_QF_M1_MASK = 2456, + RISCV_PseudoVFNRCLIP_XU_F_QF_M2 = 2457, + RISCV_PseudoVFNRCLIP_XU_F_QF_M2_MASK = 2458, + RISCV_PseudoVFNRCLIP_XU_F_QF_MF2 = 2459, + RISCV_PseudoVFNRCLIP_XU_F_QF_MF2_MASK = 2460, + RISCV_PseudoVFNRCLIP_XU_F_QF_MF4 = 2461, + RISCV_PseudoVFNRCLIP_XU_F_QF_MF4_MASK = 2462, + RISCV_PseudoVFNRCLIP_XU_F_QF_MF8 = 2463, + RISCV_PseudoVFNRCLIP_XU_F_QF_MF8_MASK = 2464, + RISCV_PseudoVFNRCLIP_X_F_QF_M1 = 2465, + RISCV_PseudoVFNRCLIP_X_F_QF_M1_MASK = 2466, + RISCV_PseudoVFNRCLIP_X_F_QF_M2 = 2467, + RISCV_PseudoVFNRCLIP_X_F_QF_M2_MASK = 2468, + RISCV_PseudoVFNRCLIP_X_F_QF_MF2 = 2469, + RISCV_PseudoVFNRCLIP_X_F_QF_MF2_MASK = 2470, + RISCV_PseudoVFNRCLIP_X_F_QF_MF4 = 2471, + RISCV_PseudoVFNRCLIP_X_F_QF_MF4_MASK = 2472, + RISCV_PseudoVFNRCLIP_X_F_QF_MF8 = 2473, + RISCV_PseudoVFNRCLIP_X_F_QF_MF8_MASK = 2474, + RISCV_PseudoVFRDIV_VFPR16_M1_E16 = 2475, + RISCV_PseudoVFRDIV_VFPR16_M1_E16_MASK = 2476, + RISCV_PseudoVFRDIV_VFPR16_M2_E16 = 2477, + RISCV_PseudoVFRDIV_VFPR16_M2_E16_MASK = 2478, + RISCV_PseudoVFRDIV_VFPR16_M4_E16 = 2479, + RISCV_PseudoVFRDIV_VFPR16_M4_E16_MASK = 2480, + RISCV_PseudoVFRDIV_VFPR16_M8_E16 = 2481, + RISCV_PseudoVFRDIV_VFPR16_M8_E16_MASK = 2482, + RISCV_PseudoVFRDIV_VFPR16_MF2_E16 = 2483, + RISCV_PseudoVFRDIV_VFPR16_MF2_E16_MASK = 2484, + RISCV_PseudoVFRDIV_VFPR16_MF4_E16 = 2485, + RISCV_PseudoVFRDIV_VFPR16_MF4_E16_MASK = 2486, + RISCV_PseudoVFRDIV_VFPR32_M1_E32 = 2487, + RISCV_PseudoVFRDIV_VFPR32_M1_E32_MASK = 2488, + RISCV_PseudoVFRDIV_VFPR32_M2_E32 = 2489, + RISCV_PseudoVFRDIV_VFPR32_M2_E32_MASK = 2490, + RISCV_PseudoVFRDIV_VFPR32_M4_E32 = 2491, + RISCV_PseudoVFRDIV_VFPR32_M4_E32_MASK = 2492, + RISCV_PseudoVFRDIV_VFPR32_M8_E32 = 2493, + RISCV_PseudoVFRDIV_VFPR32_M8_E32_MASK = 2494, + RISCV_PseudoVFRDIV_VFPR32_MF2_E32 = 2495, + RISCV_PseudoVFRDIV_VFPR32_MF2_E32_MASK = 2496, + RISCV_PseudoVFRDIV_VFPR64_M1_E64 = 2497, + RISCV_PseudoVFRDIV_VFPR64_M1_E64_MASK = 2498, + RISCV_PseudoVFRDIV_VFPR64_M2_E64 = 2499, + RISCV_PseudoVFRDIV_VFPR64_M2_E64_MASK = 2500, + RISCV_PseudoVFRDIV_VFPR64_M4_E64 = 2501, + RISCV_PseudoVFRDIV_VFPR64_M4_E64_MASK = 2502, + RISCV_PseudoVFRDIV_VFPR64_M8_E64 = 2503, + RISCV_PseudoVFRDIV_VFPR64_M8_E64_MASK = 2504, + RISCV_PseudoVFREC7_V_M1 = 2505, + RISCV_PseudoVFREC7_V_M1_MASK = 2506, + RISCV_PseudoVFREC7_V_M2 = 2507, + RISCV_PseudoVFREC7_V_M2_MASK = 2508, + RISCV_PseudoVFREC7_V_M4 = 2509, + RISCV_PseudoVFREC7_V_M4_MASK = 2510, + RISCV_PseudoVFREC7_V_M8 = 2511, + RISCV_PseudoVFREC7_V_M8_MASK = 2512, + RISCV_PseudoVFREC7_V_MF2 = 2513, + RISCV_PseudoVFREC7_V_MF2_MASK = 2514, + RISCV_PseudoVFREC7_V_MF4 = 2515, + RISCV_PseudoVFREC7_V_MF4_MASK = 2516, + RISCV_PseudoVFREDMAX_VS_M1_E16 = 2517, + RISCV_PseudoVFREDMAX_VS_M1_E16_MASK = 2518, + RISCV_PseudoVFREDMAX_VS_M1_E32 = 2519, + RISCV_PseudoVFREDMAX_VS_M1_E32_MASK = 2520, + RISCV_PseudoVFREDMAX_VS_M1_E64 = 2521, + RISCV_PseudoVFREDMAX_VS_M1_E64_MASK = 2522, + RISCV_PseudoVFREDMAX_VS_M2_E16 = 2523, + RISCV_PseudoVFREDMAX_VS_M2_E16_MASK = 2524, + RISCV_PseudoVFREDMAX_VS_M2_E32 = 2525, + RISCV_PseudoVFREDMAX_VS_M2_E32_MASK = 2526, + RISCV_PseudoVFREDMAX_VS_M2_E64 = 2527, + RISCV_PseudoVFREDMAX_VS_M2_E64_MASK = 2528, + RISCV_PseudoVFREDMAX_VS_M4_E16 = 2529, + RISCV_PseudoVFREDMAX_VS_M4_E16_MASK = 2530, + RISCV_PseudoVFREDMAX_VS_M4_E32 = 2531, + RISCV_PseudoVFREDMAX_VS_M4_E32_MASK = 2532, + RISCV_PseudoVFREDMAX_VS_M4_E64 = 2533, + RISCV_PseudoVFREDMAX_VS_M4_E64_MASK = 2534, + RISCV_PseudoVFREDMAX_VS_M8_E16 = 2535, + RISCV_PseudoVFREDMAX_VS_M8_E16_MASK = 2536, + RISCV_PseudoVFREDMAX_VS_M8_E32 = 2537, + RISCV_PseudoVFREDMAX_VS_M8_E32_MASK = 2538, + RISCV_PseudoVFREDMAX_VS_M8_E64 = 2539, + RISCV_PseudoVFREDMAX_VS_M8_E64_MASK = 2540, + RISCV_PseudoVFREDMAX_VS_MF2_E16 = 2541, + RISCV_PseudoVFREDMAX_VS_MF2_E16_MASK = 2542, + RISCV_PseudoVFREDMAX_VS_MF2_E32 = 2543, + RISCV_PseudoVFREDMAX_VS_MF2_E32_MASK = 2544, + RISCV_PseudoVFREDMAX_VS_MF4_E16 = 2545, + RISCV_PseudoVFREDMAX_VS_MF4_E16_MASK = 2546, + RISCV_PseudoVFREDMIN_VS_M1_E16 = 2547, + RISCV_PseudoVFREDMIN_VS_M1_E16_MASK = 2548, + RISCV_PseudoVFREDMIN_VS_M1_E32 = 2549, + RISCV_PseudoVFREDMIN_VS_M1_E32_MASK = 2550, + RISCV_PseudoVFREDMIN_VS_M1_E64 = 2551, + RISCV_PseudoVFREDMIN_VS_M1_E64_MASK = 2552, + RISCV_PseudoVFREDMIN_VS_M2_E16 = 2553, + RISCV_PseudoVFREDMIN_VS_M2_E16_MASK = 2554, + RISCV_PseudoVFREDMIN_VS_M2_E32 = 2555, + RISCV_PseudoVFREDMIN_VS_M2_E32_MASK = 2556, + RISCV_PseudoVFREDMIN_VS_M2_E64 = 2557, + RISCV_PseudoVFREDMIN_VS_M2_E64_MASK = 2558, + RISCV_PseudoVFREDMIN_VS_M4_E16 = 2559, + RISCV_PseudoVFREDMIN_VS_M4_E16_MASK = 2560, + RISCV_PseudoVFREDMIN_VS_M4_E32 = 2561, + RISCV_PseudoVFREDMIN_VS_M4_E32_MASK = 2562, + RISCV_PseudoVFREDMIN_VS_M4_E64 = 2563, + RISCV_PseudoVFREDMIN_VS_M4_E64_MASK = 2564, + RISCV_PseudoVFREDMIN_VS_M8_E16 = 2565, + RISCV_PseudoVFREDMIN_VS_M8_E16_MASK = 2566, + RISCV_PseudoVFREDMIN_VS_M8_E32 = 2567, + RISCV_PseudoVFREDMIN_VS_M8_E32_MASK = 2568, + RISCV_PseudoVFREDMIN_VS_M8_E64 = 2569, + RISCV_PseudoVFREDMIN_VS_M8_E64_MASK = 2570, + RISCV_PseudoVFREDMIN_VS_MF2_E16 = 2571, + RISCV_PseudoVFREDMIN_VS_MF2_E16_MASK = 2572, + RISCV_PseudoVFREDMIN_VS_MF2_E32 = 2573, + RISCV_PseudoVFREDMIN_VS_MF2_E32_MASK = 2574, + RISCV_PseudoVFREDMIN_VS_MF4_E16 = 2575, + RISCV_PseudoVFREDMIN_VS_MF4_E16_MASK = 2576, + RISCV_PseudoVFREDOSUM_VS_M1_E16 = 2577, + RISCV_PseudoVFREDOSUM_VS_M1_E16_MASK = 2578, + RISCV_PseudoVFREDOSUM_VS_M1_E32 = 2579, + RISCV_PseudoVFREDOSUM_VS_M1_E32_MASK = 2580, + RISCV_PseudoVFREDOSUM_VS_M1_E64 = 2581, + RISCV_PseudoVFREDOSUM_VS_M1_E64_MASK = 2582, + RISCV_PseudoVFREDOSUM_VS_M2_E16 = 2583, + RISCV_PseudoVFREDOSUM_VS_M2_E16_MASK = 2584, + RISCV_PseudoVFREDOSUM_VS_M2_E32 = 2585, + RISCV_PseudoVFREDOSUM_VS_M2_E32_MASK = 2586, + RISCV_PseudoVFREDOSUM_VS_M2_E64 = 2587, + RISCV_PseudoVFREDOSUM_VS_M2_E64_MASK = 2588, + RISCV_PseudoVFREDOSUM_VS_M4_E16 = 2589, + RISCV_PseudoVFREDOSUM_VS_M4_E16_MASK = 2590, + RISCV_PseudoVFREDOSUM_VS_M4_E32 = 2591, + RISCV_PseudoVFREDOSUM_VS_M4_E32_MASK = 2592, + RISCV_PseudoVFREDOSUM_VS_M4_E64 = 2593, + RISCV_PseudoVFREDOSUM_VS_M4_E64_MASK = 2594, + RISCV_PseudoVFREDOSUM_VS_M8_E16 = 2595, + RISCV_PseudoVFREDOSUM_VS_M8_E16_MASK = 2596, + RISCV_PseudoVFREDOSUM_VS_M8_E32 = 2597, + RISCV_PseudoVFREDOSUM_VS_M8_E32_MASK = 2598, + RISCV_PseudoVFREDOSUM_VS_M8_E64 = 2599, + RISCV_PseudoVFREDOSUM_VS_M8_E64_MASK = 2600, + RISCV_PseudoVFREDOSUM_VS_MF2_E16 = 2601, + RISCV_PseudoVFREDOSUM_VS_MF2_E16_MASK = 2602, + RISCV_PseudoVFREDOSUM_VS_MF2_E32 = 2603, + RISCV_PseudoVFREDOSUM_VS_MF2_E32_MASK = 2604, + RISCV_PseudoVFREDOSUM_VS_MF4_E16 = 2605, + RISCV_PseudoVFREDOSUM_VS_MF4_E16_MASK = 2606, + RISCV_PseudoVFREDUSUM_VS_M1_E16 = 2607, + RISCV_PseudoVFREDUSUM_VS_M1_E16_MASK = 2608, + RISCV_PseudoVFREDUSUM_VS_M1_E32 = 2609, + RISCV_PseudoVFREDUSUM_VS_M1_E32_MASK = 2610, + RISCV_PseudoVFREDUSUM_VS_M1_E64 = 2611, + RISCV_PseudoVFREDUSUM_VS_M1_E64_MASK = 2612, + RISCV_PseudoVFREDUSUM_VS_M2_E16 = 2613, + RISCV_PseudoVFREDUSUM_VS_M2_E16_MASK = 2614, + RISCV_PseudoVFREDUSUM_VS_M2_E32 = 2615, + RISCV_PseudoVFREDUSUM_VS_M2_E32_MASK = 2616, + RISCV_PseudoVFREDUSUM_VS_M2_E64 = 2617, + RISCV_PseudoVFREDUSUM_VS_M2_E64_MASK = 2618, + RISCV_PseudoVFREDUSUM_VS_M4_E16 = 2619, + RISCV_PseudoVFREDUSUM_VS_M4_E16_MASK = 2620, + RISCV_PseudoVFREDUSUM_VS_M4_E32 = 2621, + RISCV_PseudoVFREDUSUM_VS_M4_E32_MASK = 2622, + RISCV_PseudoVFREDUSUM_VS_M4_E64 = 2623, + RISCV_PseudoVFREDUSUM_VS_M4_E64_MASK = 2624, + RISCV_PseudoVFREDUSUM_VS_M8_E16 = 2625, + RISCV_PseudoVFREDUSUM_VS_M8_E16_MASK = 2626, + RISCV_PseudoVFREDUSUM_VS_M8_E32 = 2627, + RISCV_PseudoVFREDUSUM_VS_M8_E32_MASK = 2628, + RISCV_PseudoVFREDUSUM_VS_M8_E64 = 2629, + RISCV_PseudoVFREDUSUM_VS_M8_E64_MASK = 2630, + RISCV_PseudoVFREDUSUM_VS_MF2_E16 = 2631, + RISCV_PseudoVFREDUSUM_VS_MF2_E16_MASK = 2632, + RISCV_PseudoVFREDUSUM_VS_MF2_E32 = 2633, + RISCV_PseudoVFREDUSUM_VS_MF2_E32_MASK = 2634, + RISCV_PseudoVFREDUSUM_VS_MF4_E16 = 2635, + RISCV_PseudoVFREDUSUM_VS_MF4_E16_MASK = 2636, + RISCV_PseudoVFROUND_NOEXCEPT_V_M1_MASK = 2637, + RISCV_PseudoVFROUND_NOEXCEPT_V_M2_MASK = 2638, + RISCV_PseudoVFROUND_NOEXCEPT_V_M4_MASK = 2639, + RISCV_PseudoVFROUND_NOEXCEPT_V_M8_MASK = 2640, + RISCV_PseudoVFROUND_NOEXCEPT_V_MF2_MASK = 2641, + RISCV_PseudoVFROUND_NOEXCEPT_V_MF4_MASK = 2642, + RISCV_PseudoVFRSQRT7_V_M1 = 2643, + RISCV_PseudoVFRSQRT7_V_M1_MASK = 2644, + RISCV_PseudoVFRSQRT7_V_M2 = 2645, + RISCV_PseudoVFRSQRT7_V_M2_MASK = 2646, + RISCV_PseudoVFRSQRT7_V_M4 = 2647, + RISCV_PseudoVFRSQRT7_V_M4_MASK = 2648, + RISCV_PseudoVFRSQRT7_V_M8 = 2649, + RISCV_PseudoVFRSQRT7_V_M8_MASK = 2650, + RISCV_PseudoVFRSQRT7_V_MF2 = 2651, + RISCV_PseudoVFRSQRT7_V_MF2_MASK = 2652, + RISCV_PseudoVFRSQRT7_V_MF4 = 2653, + RISCV_PseudoVFRSQRT7_V_MF4_MASK = 2654, + RISCV_PseudoVFRSUB_VFPR16_M1 = 2655, + RISCV_PseudoVFRSUB_VFPR16_M1_MASK = 2656, + RISCV_PseudoVFRSUB_VFPR16_M2 = 2657, + RISCV_PseudoVFRSUB_VFPR16_M2_MASK = 2658, + RISCV_PseudoVFRSUB_VFPR16_M4 = 2659, + RISCV_PseudoVFRSUB_VFPR16_M4_MASK = 2660, + RISCV_PseudoVFRSUB_VFPR16_M8 = 2661, + RISCV_PseudoVFRSUB_VFPR16_M8_MASK = 2662, + RISCV_PseudoVFRSUB_VFPR16_MF2 = 2663, + RISCV_PseudoVFRSUB_VFPR16_MF2_MASK = 2664, + RISCV_PseudoVFRSUB_VFPR16_MF4 = 2665, + RISCV_PseudoVFRSUB_VFPR16_MF4_MASK = 2666, + RISCV_PseudoVFRSUB_VFPR32_M1 = 2667, + RISCV_PseudoVFRSUB_VFPR32_M1_MASK = 2668, + RISCV_PseudoVFRSUB_VFPR32_M2 = 2669, + RISCV_PseudoVFRSUB_VFPR32_M2_MASK = 2670, + RISCV_PseudoVFRSUB_VFPR32_M4 = 2671, + RISCV_PseudoVFRSUB_VFPR32_M4_MASK = 2672, + RISCV_PseudoVFRSUB_VFPR32_M8 = 2673, + RISCV_PseudoVFRSUB_VFPR32_M8_MASK = 2674, + RISCV_PseudoVFRSUB_VFPR32_MF2 = 2675, + RISCV_PseudoVFRSUB_VFPR32_MF2_MASK = 2676, + RISCV_PseudoVFRSUB_VFPR64_M1 = 2677, + RISCV_PseudoVFRSUB_VFPR64_M1_MASK = 2678, + RISCV_PseudoVFRSUB_VFPR64_M2 = 2679, + RISCV_PseudoVFRSUB_VFPR64_M2_MASK = 2680, + RISCV_PseudoVFRSUB_VFPR64_M4 = 2681, + RISCV_PseudoVFRSUB_VFPR64_M4_MASK = 2682, + RISCV_PseudoVFRSUB_VFPR64_M8 = 2683, + RISCV_PseudoVFRSUB_VFPR64_M8_MASK = 2684, + RISCV_PseudoVFSGNJN_VFPR16_M1 = 2685, + RISCV_PseudoVFSGNJN_VFPR16_M1_MASK = 2686, + RISCV_PseudoVFSGNJN_VFPR16_M2 = 2687, + RISCV_PseudoVFSGNJN_VFPR16_M2_MASK = 2688, + RISCV_PseudoVFSGNJN_VFPR16_M4 = 2689, + RISCV_PseudoVFSGNJN_VFPR16_M4_MASK = 2690, + RISCV_PseudoVFSGNJN_VFPR16_M8 = 2691, + RISCV_PseudoVFSGNJN_VFPR16_M8_MASK = 2692, + RISCV_PseudoVFSGNJN_VFPR16_MF2 = 2693, + RISCV_PseudoVFSGNJN_VFPR16_MF2_MASK = 2694, + RISCV_PseudoVFSGNJN_VFPR16_MF4 = 2695, + RISCV_PseudoVFSGNJN_VFPR16_MF4_MASK = 2696, + RISCV_PseudoVFSGNJN_VFPR32_M1 = 2697, + RISCV_PseudoVFSGNJN_VFPR32_M1_MASK = 2698, + RISCV_PseudoVFSGNJN_VFPR32_M2 = 2699, + RISCV_PseudoVFSGNJN_VFPR32_M2_MASK = 2700, + RISCV_PseudoVFSGNJN_VFPR32_M4 = 2701, + RISCV_PseudoVFSGNJN_VFPR32_M4_MASK = 2702, + RISCV_PseudoVFSGNJN_VFPR32_M8 = 2703, + RISCV_PseudoVFSGNJN_VFPR32_M8_MASK = 2704, + RISCV_PseudoVFSGNJN_VFPR32_MF2 = 2705, + RISCV_PseudoVFSGNJN_VFPR32_MF2_MASK = 2706, + RISCV_PseudoVFSGNJN_VFPR64_M1 = 2707, + RISCV_PseudoVFSGNJN_VFPR64_M1_MASK = 2708, + RISCV_PseudoVFSGNJN_VFPR64_M2 = 2709, + RISCV_PseudoVFSGNJN_VFPR64_M2_MASK = 2710, + RISCV_PseudoVFSGNJN_VFPR64_M4 = 2711, + RISCV_PseudoVFSGNJN_VFPR64_M4_MASK = 2712, + RISCV_PseudoVFSGNJN_VFPR64_M8 = 2713, + RISCV_PseudoVFSGNJN_VFPR64_M8_MASK = 2714, + RISCV_PseudoVFSGNJN_VV_M1 = 2715, + RISCV_PseudoVFSGNJN_VV_M1_MASK = 2716, + RISCV_PseudoVFSGNJN_VV_M2 = 2717, + RISCV_PseudoVFSGNJN_VV_M2_MASK = 2718, + RISCV_PseudoVFSGNJN_VV_M4 = 2719, + RISCV_PseudoVFSGNJN_VV_M4_MASK = 2720, + RISCV_PseudoVFSGNJN_VV_M8 = 2721, + RISCV_PseudoVFSGNJN_VV_M8_MASK = 2722, + RISCV_PseudoVFSGNJN_VV_MF2 = 2723, + RISCV_PseudoVFSGNJN_VV_MF2_MASK = 2724, + RISCV_PseudoVFSGNJN_VV_MF4 = 2725, + RISCV_PseudoVFSGNJN_VV_MF4_MASK = 2726, + RISCV_PseudoVFSGNJX_VFPR16_M1 = 2727, + RISCV_PseudoVFSGNJX_VFPR16_M1_MASK = 2728, + RISCV_PseudoVFSGNJX_VFPR16_M2 = 2729, + RISCV_PseudoVFSGNJX_VFPR16_M2_MASK = 2730, + RISCV_PseudoVFSGNJX_VFPR16_M4 = 2731, + RISCV_PseudoVFSGNJX_VFPR16_M4_MASK = 2732, + RISCV_PseudoVFSGNJX_VFPR16_M8 = 2733, + RISCV_PseudoVFSGNJX_VFPR16_M8_MASK = 2734, + RISCV_PseudoVFSGNJX_VFPR16_MF2 = 2735, + RISCV_PseudoVFSGNJX_VFPR16_MF2_MASK = 2736, + RISCV_PseudoVFSGNJX_VFPR16_MF4 = 2737, + RISCV_PseudoVFSGNJX_VFPR16_MF4_MASK = 2738, + RISCV_PseudoVFSGNJX_VFPR32_M1 = 2739, + RISCV_PseudoVFSGNJX_VFPR32_M1_MASK = 2740, + RISCV_PseudoVFSGNJX_VFPR32_M2 = 2741, + RISCV_PseudoVFSGNJX_VFPR32_M2_MASK = 2742, + RISCV_PseudoVFSGNJX_VFPR32_M4 = 2743, + RISCV_PseudoVFSGNJX_VFPR32_M4_MASK = 2744, + RISCV_PseudoVFSGNJX_VFPR32_M8 = 2745, + RISCV_PseudoVFSGNJX_VFPR32_M8_MASK = 2746, + RISCV_PseudoVFSGNJX_VFPR32_MF2 = 2747, + RISCV_PseudoVFSGNJX_VFPR32_MF2_MASK = 2748, + RISCV_PseudoVFSGNJX_VFPR64_M1 = 2749, + RISCV_PseudoVFSGNJX_VFPR64_M1_MASK = 2750, + RISCV_PseudoVFSGNJX_VFPR64_M2 = 2751, + RISCV_PseudoVFSGNJX_VFPR64_M2_MASK = 2752, + RISCV_PseudoVFSGNJX_VFPR64_M4 = 2753, + RISCV_PseudoVFSGNJX_VFPR64_M4_MASK = 2754, + RISCV_PseudoVFSGNJX_VFPR64_M8 = 2755, + RISCV_PseudoVFSGNJX_VFPR64_M8_MASK = 2756, + RISCV_PseudoVFSGNJX_VV_M1 = 2757, + RISCV_PseudoVFSGNJX_VV_M1_MASK = 2758, + RISCV_PseudoVFSGNJX_VV_M2 = 2759, + RISCV_PseudoVFSGNJX_VV_M2_MASK = 2760, + RISCV_PseudoVFSGNJX_VV_M4 = 2761, + RISCV_PseudoVFSGNJX_VV_M4_MASK = 2762, + RISCV_PseudoVFSGNJX_VV_M8 = 2763, + RISCV_PseudoVFSGNJX_VV_M8_MASK = 2764, + RISCV_PseudoVFSGNJX_VV_MF2 = 2765, + RISCV_PseudoVFSGNJX_VV_MF2_MASK = 2766, + RISCV_PseudoVFSGNJX_VV_MF4 = 2767, + RISCV_PseudoVFSGNJX_VV_MF4_MASK = 2768, + RISCV_PseudoVFSGNJ_VFPR16_M1 = 2769, + RISCV_PseudoVFSGNJ_VFPR16_M1_MASK = 2770, + RISCV_PseudoVFSGNJ_VFPR16_M2 = 2771, + RISCV_PseudoVFSGNJ_VFPR16_M2_MASK = 2772, + RISCV_PseudoVFSGNJ_VFPR16_M4 = 2773, + RISCV_PseudoVFSGNJ_VFPR16_M4_MASK = 2774, + RISCV_PseudoVFSGNJ_VFPR16_M8 = 2775, + RISCV_PseudoVFSGNJ_VFPR16_M8_MASK = 2776, + RISCV_PseudoVFSGNJ_VFPR16_MF2 = 2777, + RISCV_PseudoVFSGNJ_VFPR16_MF2_MASK = 2778, + RISCV_PseudoVFSGNJ_VFPR16_MF4 = 2779, + RISCV_PseudoVFSGNJ_VFPR16_MF4_MASK = 2780, + RISCV_PseudoVFSGNJ_VFPR32_M1 = 2781, + RISCV_PseudoVFSGNJ_VFPR32_M1_MASK = 2782, + RISCV_PseudoVFSGNJ_VFPR32_M2 = 2783, + RISCV_PseudoVFSGNJ_VFPR32_M2_MASK = 2784, + RISCV_PseudoVFSGNJ_VFPR32_M4 = 2785, + RISCV_PseudoVFSGNJ_VFPR32_M4_MASK = 2786, + RISCV_PseudoVFSGNJ_VFPR32_M8 = 2787, + RISCV_PseudoVFSGNJ_VFPR32_M8_MASK = 2788, + RISCV_PseudoVFSGNJ_VFPR32_MF2 = 2789, + RISCV_PseudoVFSGNJ_VFPR32_MF2_MASK = 2790, + RISCV_PseudoVFSGNJ_VFPR64_M1 = 2791, + RISCV_PseudoVFSGNJ_VFPR64_M1_MASK = 2792, + RISCV_PseudoVFSGNJ_VFPR64_M2 = 2793, + RISCV_PseudoVFSGNJ_VFPR64_M2_MASK = 2794, + RISCV_PseudoVFSGNJ_VFPR64_M4 = 2795, + RISCV_PseudoVFSGNJ_VFPR64_M4_MASK = 2796, + RISCV_PseudoVFSGNJ_VFPR64_M8 = 2797, + RISCV_PseudoVFSGNJ_VFPR64_M8_MASK = 2798, + RISCV_PseudoVFSGNJ_VV_M1 = 2799, + RISCV_PseudoVFSGNJ_VV_M1_MASK = 2800, + RISCV_PseudoVFSGNJ_VV_M2 = 2801, + RISCV_PseudoVFSGNJ_VV_M2_MASK = 2802, + RISCV_PseudoVFSGNJ_VV_M4 = 2803, + RISCV_PseudoVFSGNJ_VV_M4_MASK = 2804, + RISCV_PseudoVFSGNJ_VV_M8 = 2805, + RISCV_PseudoVFSGNJ_VV_M8_MASK = 2806, + RISCV_PseudoVFSGNJ_VV_MF2 = 2807, + RISCV_PseudoVFSGNJ_VV_MF2_MASK = 2808, + RISCV_PseudoVFSGNJ_VV_MF4 = 2809, + RISCV_PseudoVFSGNJ_VV_MF4_MASK = 2810, + RISCV_PseudoVFSLIDE1DOWN_VFPR16_M1 = 2811, + RISCV_PseudoVFSLIDE1DOWN_VFPR16_M1_MASK = 2812, + RISCV_PseudoVFSLIDE1DOWN_VFPR16_M2 = 2813, + RISCV_PseudoVFSLIDE1DOWN_VFPR16_M2_MASK = 2814, + RISCV_PseudoVFSLIDE1DOWN_VFPR16_M4 = 2815, + RISCV_PseudoVFSLIDE1DOWN_VFPR16_M4_MASK = 2816, + RISCV_PseudoVFSLIDE1DOWN_VFPR16_M8 = 2817, + RISCV_PseudoVFSLIDE1DOWN_VFPR16_M8_MASK = 2818, + RISCV_PseudoVFSLIDE1DOWN_VFPR16_MF2 = 2819, + RISCV_PseudoVFSLIDE1DOWN_VFPR16_MF2_MASK = 2820, + RISCV_PseudoVFSLIDE1DOWN_VFPR16_MF4 = 2821, + RISCV_PseudoVFSLIDE1DOWN_VFPR16_MF4_MASK = 2822, + RISCV_PseudoVFSLIDE1DOWN_VFPR32_M1 = 2823, + RISCV_PseudoVFSLIDE1DOWN_VFPR32_M1_MASK = 2824, + RISCV_PseudoVFSLIDE1DOWN_VFPR32_M2 = 2825, + RISCV_PseudoVFSLIDE1DOWN_VFPR32_M2_MASK = 2826, + RISCV_PseudoVFSLIDE1DOWN_VFPR32_M4 = 2827, + RISCV_PseudoVFSLIDE1DOWN_VFPR32_M4_MASK = 2828, + RISCV_PseudoVFSLIDE1DOWN_VFPR32_M8 = 2829, + RISCV_PseudoVFSLIDE1DOWN_VFPR32_M8_MASK = 2830, + RISCV_PseudoVFSLIDE1DOWN_VFPR32_MF2 = 2831, + RISCV_PseudoVFSLIDE1DOWN_VFPR32_MF2_MASK = 2832, + RISCV_PseudoVFSLIDE1DOWN_VFPR64_M1 = 2833, + RISCV_PseudoVFSLIDE1DOWN_VFPR64_M1_MASK = 2834, + RISCV_PseudoVFSLIDE1DOWN_VFPR64_M2 = 2835, + RISCV_PseudoVFSLIDE1DOWN_VFPR64_M2_MASK = 2836, + RISCV_PseudoVFSLIDE1DOWN_VFPR64_M4 = 2837, + RISCV_PseudoVFSLIDE1DOWN_VFPR64_M4_MASK = 2838, + RISCV_PseudoVFSLIDE1DOWN_VFPR64_M8 = 2839, + RISCV_PseudoVFSLIDE1DOWN_VFPR64_M8_MASK = 2840, + RISCV_PseudoVFSLIDE1UP_VFPR16_M1 = 2841, + RISCV_PseudoVFSLIDE1UP_VFPR16_M1_MASK = 2842, + RISCV_PseudoVFSLIDE1UP_VFPR16_M2 = 2843, + RISCV_PseudoVFSLIDE1UP_VFPR16_M2_MASK = 2844, + RISCV_PseudoVFSLIDE1UP_VFPR16_M4 = 2845, + RISCV_PseudoVFSLIDE1UP_VFPR16_M4_MASK = 2846, + RISCV_PseudoVFSLIDE1UP_VFPR16_M8 = 2847, + RISCV_PseudoVFSLIDE1UP_VFPR16_M8_MASK = 2848, + RISCV_PseudoVFSLIDE1UP_VFPR16_MF2 = 2849, + RISCV_PseudoVFSLIDE1UP_VFPR16_MF2_MASK = 2850, + RISCV_PseudoVFSLIDE1UP_VFPR16_MF4 = 2851, + RISCV_PseudoVFSLIDE1UP_VFPR16_MF4_MASK = 2852, + RISCV_PseudoVFSLIDE1UP_VFPR32_M1 = 2853, + RISCV_PseudoVFSLIDE1UP_VFPR32_M1_MASK = 2854, + RISCV_PseudoVFSLIDE1UP_VFPR32_M2 = 2855, + RISCV_PseudoVFSLIDE1UP_VFPR32_M2_MASK = 2856, + RISCV_PseudoVFSLIDE1UP_VFPR32_M4 = 2857, + RISCV_PseudoVFSLIDE1UP_VFPR32_M4_MASK = 2858, + RISCV_PseudoVFSLIDE1UP_VFPR32_M8 = 2859, + RISCV_PseudoVFSLIDE1UP_VFPR32_M8_MASK = 2860, + RISCV_PseudoVFSLIDE1UP_VFPR32_MF2 = 2861, + RISCV_PseudoVFSLIDE1UP_VFPR32_MF2_MASK = 2862, + RISCV_PseudoVFSLIDE1UP_VFPR64_M1 = 2863, + RISCV_PseudoVFSLIDE1UP_VFPR64_M1_MASK = 2864, + RISCV_PseudoVFSLIDE1UP_VFPR64_M2 = 2865, + RISCV_PseudoVFSLIDE1UP_VFPR64_M2_MASK = 2866, + RISCV_PseudoVFSLIDE1UP_VFPR64_M4 = 2867, + RISCV_PseudoVFSLIDE1UP_VFPR64_M4_MASK = 2868, + RISCV_PseudoVFSLIDE1UP_VFPR64_M8 = 2869, + RISCV_PseudoVFSLIDE1UP_VFPR64_M8_MASK = 2870, + RISCV_PseudoVFSQRT_V_M1_E16 = 2871, + RISCV_PseudoVFSQRT_V_M1_E16_MASK = 2872, + RISCV_PseudoVFSQRT_V_M1_E32 = 2873, + RISCV_PseudoVFSQRT_V_M1_E32_MASK = 2874, + RISCV_PseudoVFSQRT_V_M1_E64 = 2875, + RISCV_PseudoVFSQRT_V_M1_E64_MASK = 2876, + RISCV_PseudoVFSQRT_V_M2_E16 = 2877, + RISCV_PseudoVFSQRT_V_M2_E16_MASK = 2878, + RISCV_PseudoVFSQRT_V_M2_E32 = 2879, + RISCV_PseudoVFSQRT_V_M2_E32_MASK = 2880, + RISCV_PseudoVFSQRT_V_M2_E64 = 2881, + RISCV_PseudoVFSQRT_V_M2_E64_MASK = 2882, + RISCV_PseudoVFSQRT_V_M4_E16 = 2883, + RISCV_PseudoVFSQRT_V_M4_E16_MASK = 2884, + RISCV_PseudoVFSQRT_V_M4_E32 = 2885, + RISCV_PseudoVFSQRT_V_M4_E32_MASK = 2886, + RISCV_PseudoVFSQRT_V_M4_E64 = 2887, + RISCV_PseudoVFSQRT_V_M4_E64_MASK = 2888, + RISCV_PseudoVFSQRT_V_M8_E16 = 2889, + RISCV_PseudoVFSQRT_V_M8_E16_MASK = 2890, + RISCV_PseudoVFSQRT_V_M8_E32 = 2891, + RISCV_PseudoVFSQRT_V_M8_E32_MASK = 2892, + RISCV_PseudoVFSQRT_V_M8_E64 = 2893, + RISCV_PseudoVFSQRT_V_M8_E64_MASK = 2894, + RISCV_PseudoVFSQRT_V_MF2_E16 = 2895, + RISCV_PseudoVFSQRT_V_MF2_E16_MASK = 2896, + RISCV_PseudoVFSQRT_V_MF2_E32 = 2897, + RISCV_PseudoVFSQRT_V_MF2_E32_MASK = 2898, + RISCV_PseudoVFSQRT_V_MF4_E16 = 2899, + RISCV_PseudoVFSQRT_V_MF4_E16_MASK = 2900, + RISCV_PseudoVFSUB_VFPR16_M1 = 2901, + RISCV_PseudoVFSUB_VFPR16_M1_MASK = 2902, + RISCV_PseudoVFSUB_VFPR16_M2 = 2903, + RISCV_PseudoVFSUB_VFPR16_M2_MASK = 2904, + RISCV_PseudoVFSUB_VFPR16_M4 = 2905, + RISCV_PseudoVFSUB_VFPR16_M4_MASK = 2906, + RISCV_PseudoVFSUB_VFPR16_M8 = 2907, + RISCV_PseudoVFSUB_VFPR16_M8_MASK = 2908, + RISCV_PseudoVFSUB_VFPR16_MF2 = 2909, + RISCV_PseudoVFSUB_VFPR16_MF2_MASK = 2910, + RISCV_PseudoVFSUB_VFPR16_MF4 = 2911, + RISCV_PseudoVFSUB_VFPR16_MF4_MASK = 2912, + RISCV_PseudoVFSUB_VFPR32_M1 = 2913, + RISCV_PseudoVFSUB_VFPR32_M1_MASK = 2914, + RISCV_PseudoVFSUB_VFPR32_M2 = 2915, + RISCV_PseudoVFSUB_VFPR32_M2_MASK = 2916, + RISCV_PseudoVFSUB_VFPR32_M4 = 2917, + RISCV_PseudoVFSUB_VFPR32_M4_MASK = 2918, + RISCV_PseudoVFSUB_VFPR32_M8 = 2919, + RISCV_PseudoVFSUB_VFPR32_M8_MASK = 2920, + RISCV_PseudoVFSUB_VFPR32_MF2 = 2921, + RISCV_PseudoVFSUB_VFPR32_MF2_MASK = 2922, + RISCV_PseudoVFSUB_VFPR64_M1 = 2923, + RISCV_PseudoVFSUB_VFPR64_M1_MASK = 2924, + RISCV_PseudoVFSUB_VFPR64_M2 = 2925, + RISCV_PseudoVFSUB_VFPR64_M2_MASK = 2926, + RISCV_PseudoVFSUB_VFPR64_M4 = 2927, + RISCV_PseudoVFSUB_VFPR64_M4_MASK = 2928, + RISCV_PseudoVFSUB_VFPR64_M8 = 2929, + RISCV_PseudoVFSUB_VFPR64_M8_MASK = 2930, + RISCV_PseudoVFSUB_VV_M1 = 2931, + RISCV_PseudoVFSUB_VV_M1_MASK = 2932, + RISCV_PseudoVFSUB_VV_M2 = 2933, + RISCV_PseudoVFSUB_VV_M2_MASK = 2934, + RISCV_PseudoVFSUB_VV_M4 = 2935, + RISCV_PseudoVFSUB_VV_M4_MASK = 2936, + RISCV_PseudoVFSUB_VV_M8 = 2937, + RISCV_PseudoVFSUB_VV_M8_MASK = 2938, + RISCV_PseudoVFSUB_VV_MF2 = 2939, + RISCV_PseudoVFSUB_VV_MF2_MASK = 2940, + RISCV_PseudoVFSUB_VV_MF4 = 2941, + RISCV_PseudoVFSUB_VV_MF4_MASK = 2942, + RISCV_PseudoVFWADD_VFPR16_M1 = 2943, + RISCV_PseudoVFWADD_VFPR16_M1_MASK = 2944, + RISCV_PseudoVFWADD_VFPR16_M2 = 2945, + RISCV_PseudoVFWADD_VFPR16_M2_MASK = 2946, + RISCV_PseudoVFWADD_VFPR16_M4 = 2947, + RISCV_PseudoVFWADD_VFPR16_M4_MASK = 2948, + RISCV_PseudoVFWADD_VFPR16_MF2 = 2949, + RISCV_PseudoVFWADD_VFPR16_MF2_MASK = 2950, + RISCV_PseudoVFWADD_VFPR16_MF4 = 2951, + RISCV_PseudoVFWADD_VFPR16_MF4_MASK = 2952, + RISCV_PseudoVFWADD_VFPR32_M1 = 2953, + RISCV_PseudoVFWADD_VFPR32_M1_MASK = 2954, + RISCV_PseudoVFWADD_VFPR32_M2 = 2955, + RISCV_PseudoVFWADD_VFPR32_M2_MASK = 2956, + RISCV_PseudoVFWADD_VFPR32_M4 = 2957, + RISCV_PseudoVFWADD_VFPR32_M4_MASK = 2958, + RISCV_PseudoVFWADD_VFPR32_MF2 = 2959, + RISCV_PseudoVFWADD_VFPR32_MF2_MASK = 2960, + RISCV_PseudoVFWADD_VV_M1 = 2961, + RISCV_PseudoVFWADD_VV_M1_MASK = 2962, + RISCV_PseudoVFWADD_VV_M2 = 2963, + RISCV_PseudoVFWADD_VV_M2_MASK = 2964, + RISCV_PseudoVFWADD_VV_M4 = 2965, + RISCV_PseudoVFWADD_VV_M4_MASK = 2966, + RISCV_PseudoVFWADD_VV_MF2 = 2967, + RISCV_PseudoVFWADD_VV_MF2_MASK = 2968, + RISCV_PseudoVFWADD_VV_MF4 = 2969, + RISCV_PseudoVFWADD_VV_MF4_MASK = 2970, + RISCV_PseudoVFWADD_WFPR16_M1 = 2971, + RISCV_PseudoVFWADD_WFPR16_M1_MASK = 2972, + RISCV_PseudoVFWADD_WFPR16_M2 = 2973, + RISCV_PseudoVFWADD_WFPR16_M2_MASK = 2974, + RISCV_PseudoVFWADD_WFPR16_M4 = 2975, + RISCV_PseudoVFWADD_WFPR16_M4_MASK = 2976, + RISCV_PseudoVFWADD_WFPR16_MF2 = 2977, + RISCV_PseudoVFWADD_WFPR16_MF2_MASK = 2978, + RISCV_PseudoVFWADD_WFPR16_MF4 = 2979, + RISCV_PseudoVFWADD_WFPR16_MF4_MASK = 2980, + RISCV_PseudoVFWADD_WFPR32_M1 = 2981, + RISCV_PseudoVFWADD_WFPR32_M1_MASK = 2982, + RISCV_PseudoVFWADD_WFPR32_M2 = 2983, + RISCV_PseudoVFWADD_WFPR32_M2_MASK = 2984, + RISCV_PseudoVFWADD_WFPR32_M4 = 2985, + RISCV_PseudoVFWADD_WFPR32_M4_MASK = 2986, + RISCV_PseudoVFWADD_WFPR32_MF2 = 2987, + RISCV_PseudoVFWADD_WFPR32_MF2_MASK = 2988, + RISCV_PseudoVFWADD_WV_M1 = 2989, + RISCV_PseudoVFWADD_WV_M1_MASK = 2990, + RISCV_PseudoVFWADD_WV_M1_MASK_TIED = 2991, + RISCV_PseudoVFWADD_WV_M1_TIED = 2992, + RISCV_PseudoVFWADD_WV_M2 = 2993, + RISCV_PseudoVFWADD_WV_M2_MASK = 2994, + RISCV_PseudoVFWADD_WV_M2_MASK_TIED = 2995, + RISCV_PseudoVFWADD_WV_M2_TIED = 2996, + RISCV_PseudoVFWADD_WV_M4 = 2997, + RISCV_PseudoVFWADD_WV_M4_MASK = 2998, + RISCV_PseudoVFWADD_WV_M4_MASK_TIED = 2999, + RISCV_PseudoVFWADD_WV_M4_TIED = 3000, + RISCV_PseudoVFWADD_WV_MF2 = 3001, + RISCV_PseudoVFWADD_WV_MF2_MASK = 3002, + RISCV_PseudoVFWADD_WV_MF2_MASK_TIED = 3003, + RISCV_PseudoVFWADD_WV_MF2_TIED = 3004, + RISCV_PseudoVFWADD_WV_MF4 = 3005, + RISCV_PseudoVFWADD_WV_MF4_MASK = 3006, + RISCV_PseudoVFWADD_WV_MF4_MASK_TIED = 3007, + RISCV_PseudoVFWADD_WV_MF4_TIED = 3008, + RISCV_PseudoVFWCVTBF16_F_F_V_M1 = 3009, + RISCV_PseudoVFWCVTBF16_F_F_V_M1_MASK = 3010, + RISCV_PseudoVFWCVTBF16_F_F_V_M2 = 3011, + RISCV_PseudoVFWCVTBF16_F_F_V_M2_MASK = 3012, + RISCV_PseudoVFWCVTBF16_F_F_V_M4 = 3013, + RISCV_PseudoVFWCVTBF16_F_F_V_M4_MASK = 3014, + RISCV_PseudoVFWCVTBF16_F_F_V_MF2 = 3015, + RISCV_PseudoVFWCVTBF16_F_F_V_MF2_MASK = 3016, + RISCV_PseudoVFWCVTBF16_F_F_V_MF4 = 3017, + RISCV_PseudoVFWCVTBF16_F_F_V_MF4_MASK = 3018, + RISCV_PseudoVFWCVT_F_F_V_M1 = 3019, + RISCV_PseudoVFWCVT_F_F_V_M1_MASK = 3020, + RISCV_PseudoVFWCVT_F_F_V_M2 = 3021, + RISCV_PseudoVFWCVT_F_F_V_M2_MASK = 3022, + RISCV_PseudoVFWCVT_F_F_V_M4 = 3023, + RISCV_PseudoVFWCVT_F_F_V_M4_MASK = 3024, + RISCV_PseudoVFWCVT_F_F_V_MF2 = 3025, + RISCV_PseudoVFWCVT_F_F_V_MF2_MASK = 3026, + RISCV_PseudoVFWCVT_F_F_V_MF4 = 3027, + RISCV_PseudoVFWCVT_F_F_V_MF4_MASK = 3028, + RISCV_PseudoVFWCVT_F_XU_V_M1 = 3029, + RISCV_PseudoVFWCVT_F_XU_V_M1_MASK = 3030, + RISCV_PseudoVFWCVT_F_XU_V_M2 = 3031, + RISCV_PseudoVFWCVT_F_XU_V_M2_MASK = 3032, + RISCV_PseudoVFWCVT_F_XU_V_M4 = 3033, + RISCV_PseudoVFWCVT_F_XU_V_M4_MASK = 3034, + RISCV_PseudoVFWCVT_F_XU_V_MF2 = 3035, + RISCV_PseudoVFWCVT_F_XU_V_MF2_MASK = 3036, + RISCV_PseudoVFWCVT_F_XU_V_MF4 = 3037, + RISCV_PseudoVFWCVT_F_XU_V_MF4_MASK = 3038, + RISCV_PseudoVFWCVT_F_XU_V_MF8 = 3039, + RISCV_PseudoVFWCVT_F_XU_V_MF8_MASK = 3040, + RISCV_PseudoVFWCVT_F_X_V_M1 = 3041, + RISCV_PseudoVFWCVT_F_X_V_M1_MASK = 3042, + RISCV_PseudoVFWCVT_F_X_V_M2 = 3043, + RISCV_PseudoVFWCVT_F_X_V_M2_MASK = 3044, + RISCV_PseudoVFWCVT_F_X_V_M4 = 3045, + RISCV_PseudoVFWCVT_F_X_V_M4_MASK = 3046, + RISCV_PseudoVFWCVT_F_X_V_MF2 = 3047, + RISCV_PseudoVFWCVT_F_X_V_MF2_MASK = 3048, + RISCV_PseudoVFWCVT_F_X_V_MF4 = 3049, + RISCV_PseudoVFWCVT_F_X_V_MF4_MASK = 3050, + RISCV_PseudoVFWCVT_F_X_V_MF8 = 3051, + RISCV_PseudoVFWCVT_F_X_V_MF8_MASK = 3052, + RISCV_PseudoVFWCVT_RM_XU_F_V_M1 = 3053, + RISCV_PseudoVFWCVT_RM_XU_F_V_M1_MASK = 3054, + RISCV_PseudoVFWCVT_RM_XU_F_V_M2 = 3055, + RISCV_PseudoVFWCVT_RM_XU_F_V_M2_MASK = 3056, + RISCV_PseudoVFWCVT_RM_XU_F_V_M4 = 3057, + RISCV_PseudoVFWCVT_RM_XU_F_V_M4_MASK = 3058, + RISCV_PseudoVFWCVT_RM_XU_F_V_MF2 = 3059, + RISCV_PseudoVFWCVT_RM_XU_F_V_MF2_MASK = 3060, + RISCV_PseudoVFWCVT_RM_XU_F_V_MF4 = 3061, + RISCV_PseudoVFWCVT_RM_XU_F_V_MF4_MASK = 3062, + RISCV_PseudoVFWCVT_RM_X_F_V_M1 = 3063, + RISCV_PseudoVFWCVT_RM_X_F_V_M1_MASK = 3064, + RISCV_PseudoVFWCVT_RM_X_F_V_M2 = 3065, + RISCV_PseudoVFWCVT_RM_X_F_V_M2_MASK = 3066, + RISCV_PseudoVFWCVT_RM_X_F_V_M4 = 3067, + RISCV_PseudoVFWCVT_RM_X_F_V_M4_MASK = 3068, + RISCV_PseudoVFWCVT_RM_X_F_V_MF2 = 3069, + RISCV_PseudoVFWCVT_RM_X_F_V_MF2_MASK = 3070, + RISCV_PseudoVFWCVT_RM_X_F_V_MF4 = 3071, + RISCV_PseudoVFWCVT_RM_X_F_V_MF4_MASK = 3072, + RISCV_PseudoVFWCVT_RTZ_XU_F_V_M1 = 3073, + RISCV_PseudoVFWCVT_RTZ_XU_F_V_M1_MASK = 3074, + RISCV_PseudoVFWCVT_RTZ_XU_F_V_M2 = 3075, + RISCV_PseudoVFWCVT_RTZ_XU_F_V_M2_MASK = 3076, + RISCV_PseudoVFWCVT_RTZ_XU_F_V_M4 = 3077, + RISCV_PseudoVFWCVT_RTZ_XU_F_V_M4_MASK = 3078, + RISCV_PseudoVFWCVT_RTZ_XU_F_V_MF2 = 3079, + RISCV_PseudoVFWCVT_RTZ_XU_F_V_MF2_MASK = 3080, + RISCV_PseudoVFWCVT_RTZ_XU_F_V_MF4 = 3081, + RISCV_PseudoVFWCVT_RTZ_XU_F_V_MF4_MASK = 3082, + RISCV_PseudoVFWCVT_RTZ_X_F_V_M1 = 3083, + RISCV_PseudoVFWCVT_RTZ_X_F_V_M1_MASK = 3084, + RISCV_PseudoVFWCVT_RTZ_X_F_V_M2 = 3085, + RISCV_PseudoVFWCVT_RTZ_X_F_V_M2_MASK = 3086, + RISCV_PseudoVFWCVT_RTZ_X_F_V_M4 = 3087, + RISCV_PseudoVFWCVT_RTZ_X_F_V_M4_MASK = 3088, + RISCV_PseudoVFWCVT_RTZ_X_F_V_MF2 = 3089, + RISCV_PseudoVFWCVT_RTZ_X_F_V_MF2_MASK = 3090, + RISCV_PseudoVFWCVT_RTZ_X_F_V_MF4 = 3091, + RISCV_PseudoVFWCVT_RTZ_X_F_V_MF4_MASK = 3092, + RISCV_PseudoVFWCVT_XU_F_V_M1 = 3093, + RISCV_PseudoVFWCVT_XU_F_V_M1_MASK = 3094, + RISCV_PseudoVFWCVT_XU_F_V_M2 = 3095, + RISCV_PseudoVFWCVT_XU_F_V_M2_MASK = 3096, + RISCV_PseudoVFWCVT_XU_F_V_M4 = 3097, + RISCV_PseudoVFWCVT_XU_F_V_M4_MASK = 3098, + RISCV_PseudoVFWCVT_XU_F_V_MF2 = 3099, + RISCV_PseudoVFWCVT_XU_F_V_MF2_MASK = 3100, + RISCV_PseudoVFWCVT_XU_F_V_MF4 = 3101, + RISCV_PseudoVFWCVT_XU_F_V_MF4_MASK = 3102, + RISCV_PseudoVFWCVT_X_F_V_M1 = 3103, + RISCV_PseudoVFWCVT_X_F_V_M1_MASK = 3104, + RISCV_PseudoVFWCVT_X_F_V_M2 = 3105, + RISCV_PseudoVFWCVT_X_F_V_M2_MASK = 3106, + RISCV_PseudoVFWCVT_X_F_V_M4 = 3107, + RISCV_PseudoVFWCVT_X_F_V_M4_MASK = 3108, + RISCV_PseudoVFWCVT_X_F_V_MF2 = 3109, + RISCV_PseudoVFWCVT_X_F_V_MF2_MASK = 3110, + RISCV_PseudoVFWCVT_X_F_V_MF4 = 3111, + RISCV_PseudoVFWCVT_X_F_V_MF4_MASK = 3112, + RISCV_PseudoVFWMACCBF16_VFPR16_M1 = 3113, + RISCV_PseudoVFWMACCBF16_VFPR16_M1_MASK = 3114, + RISCV_PseudoVFWMACCBF16_VFPR16_M2 = 3115, + RISCV_PseudoVFWMACCBF16_VFPR16_M2_MASK = 3116, + RISCV_PseudoVFWMACCBF16_VFPR16_M4 = 3117, + RISCV_PseudoVFWMACCBF16_VFPR16_M4_MASK = 3118, + RISCV_PseudoVFWMACCBF16_VFPR16_MF2 = 3119, + RISCV_PseudoVFWMACCBF16_VFPR16_MF2_MASK = 3120, + RISCV_PseudoVFWMACCBF16_VFPR16_MF4 = 3121, + RISCV_PseudoVFWMACCBF16_VFPR16_MF4_MASK = 3122, + RISCV_PseudoVFWMACCBF16_VV_M1 = 3123, + RISCV_PseudoVFWMACCBF16_VV_M1_MASK = 3124, + RISCV_PseudoVFWMACCBF16_VV_M2 = 3125, + RISCV_PseudoVFWMACCBF16_VV_M2_MASK = 3126, + RISCV_PseudoVFWMACCBF16_VV_M4 = 3127, + RISCV_PseudoVFWMACCBF16_VV_M4_MASK = 3128, + RISCV_PseudoVFWMACCBF16_VV_MF2 = 3129, + RISCV_PseudoVFWMACCBF16_VV_MF2_MASK = 3130, + RISCV_PseudoVFWMACCBF16_VV_MF4 = 3131, + RISCV_PseudoVFWMACCBF16_VV_MF4_MASK = 3132, + RISCV_PseudoVFWMACC_4x4x4_M1 = 3133, + RISCV_PseudoVFWMACC_4x4x4_M2 = 3134, + RISCV_PseudoVFWMACC_4x4x4_M4 = 3135, + RISCV_PseudoVFWMACC_4x4x4_M8 = 3136, + RISCV_PseudoVFWMACC_4x4x4_MF2 = 3137, + RISCV_PseudoVFWMACC_4x4x4_MF4 = 3138, + RISCV_PseudoVFWMACC_VFPR16_M1 = 3139, + RISCV_PseudoVFWMACC_VFPR16_M1_MASK = 3140, + RISCV_PseudoVFWMACC_VFPR16_M2 = 3141, + RISCV_PseudoVFWMACC_VFPR16_M2_MASK = 3142, + RISCV_PseudoVFWMACC_VFPR16_M4 = 3143, + RISCV_PseudoVFWMACC_VFPR16_M4_MASK = 3144, + RISCV_PseudoVFWMACC_VFPR16_MF2 = 3145, + RISCV_PseudoVFWMACC_VFPR16_MF2_MASK = 3146, + RISCV_PseudoVFWMACC_VFPR16_MF4 = 3147, + RISCV_PseudoVFWMACC_VFPR16_MF4_MASK = 3148, + RISCV_PseudoVFWMACC_VFPR32_M1 = 3149, + RISCV_PseudoVFWMACC_VFPR32_M1_MASK = 3150, + RISCV_PseudoVFWMACC_VFPR32_M2 = 3151, + RISCV_PseudoVFWMACC_VFPR32_M2_MASK = 3152, + RISCV_PseudoVFWMACC_VFPR32_M4 = 3153, + RISCV_PseudoVFWMACC_VFPR32_M4_MASK = 3154, + RISCV_PseudoVFWMACC_VFPR32_MF2 = 3155, + RISCV_PseudoVFWMACC_VFPR32_MF2_MASK = 3156, + RISCV_PseudoVFWMACC_VV_M1 = 3157, + RISCV_PseudoVFWMACC_VV_M1_MASK = 3158, + RISCV_PseudoVFWMACC_VV_M2 = 3159, + RISCV_PseudoVFWMACC_VV_M2_MASK = 3160, + RISCV_PseudoVFWMACC_VV_M4 = 3161, + RISCV_PseudoVFWMACC_VV_M4_MASK = 3162, + RISCV_PseudoVFWMACC_VV_MF2 = 3163, + RISCV_PseudoVFWMACC_VV_MF2_MASK = 3164, + RISCV_PseudoVFWMACC_VV_MF4 = 3165, + RISCV_PseudoVFWMACC_VV_MF4_MASK = 3166, + RISCV_PseudoVFWMSAC_VFPR16_M1 = 3167, + RISCV_PseudoVFWMSAC_VFPR16_M1_MASK = 3168, + RISCV_PseudoVFWMSAC_VFPR16_M2 = 3169, + RISCV_PseudoVFWMSAC_VFPR16_M2_MASK = 3170, + RISCV_PseudoVFWMSAC_VFPR16_M4 = 3171, + RISCV_PseudoVFWMSAC_VFPR16_M4_MASK = 3172, + RISCV_PseudoVFWMSAC_VFPR16_MF2 = 3173, + RISCV_PseudoVFWMSAC_VFPR16_MF2_MASK = 3174, + RISCV_PseudoVFWMSAC_VFPR16_MF4 = 3175, + RISCV_PseudoVFWMSAC_VFPR16_MF4_MASK = 3176, + RISCV_PseudoVFWMSAC_VFPR32_M1 = 3177, + RISCV_PseudoVFWMSAC_VFPR32_M1_MASK = 3178, + RISCV_PseudoVFWMSAC_VFPR32_M2 = 3179, + RISCV_PseudoVFWMSAC_VFPR32_M2_MASK = 3180, + RISCV_PseudoVFWMSAC_VFPR32_M4 = 3181, + RISCV_PseudoVFWMSAC_VFPR32_M4_MASK = 3182, + RISCV_PseudoVFWMSAC_VFPR32_MF2 = 3183, + RISCV_PseudoVFWMSAC_VFPR32_MF2_MASK = 3184, + RISCV_PseudoVFWMSAC_VV_M1 = 3185, + RISCV_PseudoVFWMSAC_VV_M1_MASK = 3186, + RISCV_PseudoVFWMSAC_VV_M2 = 3187, + RISCV_PseudoVFWMSAC_VV_M2_MASK = 3188, + RISCV_PseudoVFWMSAC_VV_M4 = 3189, + RISCV_PseudoVFWMSAC_VV_M4_MASK = 3190, + RISCV_PseudoVFWMSAC_VV_MF2 = 3191, + RISCV_PseudoVFWMSAC_VV_MF2_MASK = 3192, + RISCV_PseudoVFWMSAC_VV_MF4 = 3193, + RISCV_PseudoVFWMSAC_VV_MF4_MASK = 3194, + RISCV_PseudoVFWMUL_VFPR16_M1 = 3195, + RISCV_PseudoVFWMUL_VFPR16_M1_MASK = 3196, + RISCV_PseudoVFWMUL_VFPR16_M2 = 3197, + RISCV_PseudoVFWMUL_VFPR16_M2_MASK = 3198, + RISCV_PseudoVFWMUL_VFPR16_M4 = 3199, + RISCV_PseudoVFWMUL_VFPR16_M4_MASK = 3200, + RISCV_PseudoVFWMUL_VFPR16_MF2 = 3201, + RISCV_PseudoVFWMUL_VFPR16_MF2_MASK = 3202, + RISCV_PseudoVFWMUL_VFPR16_MF4 = 3203, + RISCV_PseudoVFWMUL_VFPR16_MF4_MASK = 3204, + RISCV_PseudoVFWMUL_VFPR32_M1 = 3205, + RISCV_PseudoVFWMUL_VFPR32_M1_MASK = 3206, + RISCV_PseudoVFWMUL_VFPR32_M2 = 3207, + RISCV_PseudoVFWMUL_VFPR32_M2_MASK = 3208, + RISCV_PseudoVFWMUL_VFPR32_M4 = 3209, + RISCV_PseudoVFWMUL_VFPR32_M4_MASK = 3210, + RISCV_PseudoVFWMUL_VFPR32_MF2 = 3211, + RISCV_PseudoVFWMUL_VFPR32_MF2_MASK = 3212, + RISCV_PseudoVFWMUL_VV_M1 = 3213, + RISCV_PseudoVFWMUL_VV_M1_MASK = 3214, + RISCV_PseudoVFWMUL_VV_M2 = 3215, + RISCV_PseudoVFWMUL_VV_M2_MASK = 3216, + RISCV_PseudoVFWMUL_VV_M4 = 3217, + RISCV_PseudoVFWMUL_VV_M4_MASK = 3218, + RISCV_PseudoVFWMUL_VV_MF2 = 3219, + RISCV_PseudoVFWMUL_VV_MF2_MASK = 3220, + RISCV_PseudoVFWMUL_VV_MF4 = 3221, + RISCV_PseudoVFWMUL_VV_MF4_MASK = 3222, + RISCV_PseudoVFWNMACC_VFPR16_M1 = 3223, + RISCV_PseudoVFWNMACC_VFPR16_M1_MASK = 3224, + RISCV_PseudoVFWNMACC_VFPR16_M2 = 3225, + RISCV_PseudoVFWNMACC_VFPR16_M2_MASK = 3226, + RISCV_PseudoVFWNMACC_VFPR16_M4 = 3227, + RISCV_PseudoVFWNMACC_VFPR16_M4_MASK = 3228, + RISCV_PseudoVFWNMACC_VFPR16_MF2 = 3229, + RISCV_PseudoVFWNMACC_VFPR16_MF2_MASK = 3230, + RISCV_PseudoVFWNMACC_VFPR16_MF4 = 3231, + RISCV_PseudoVFWNMACC_VFPR16_MF4_MASK = 3232, + RISCV_PseudoVFWNMACC_VFPR32_M1 = 3233, + RISCV_PseudoVFWNMACC_VFPR32_M1_MASK = 3234, + RISCV_PseudoVFWNMACC_VFPR32_M2 = 3235, + RISCV_PseudoVFWNMACC_VFPR32_M2_MASK = 3236, + RISCV_PseudoVFWNMACC_VFPR32_M4 = 3237, + RISCV_PseudoVFWNMACC_VFPR32_M4_MASK = 3238, + RISCV_PseudoVFWNMACC_VFPR32_MF2 = 3239, + RISCV_PseudoVFWNMACC_VFPR32_MF2_MASK = 3240, + RISCV_PseudoVFWNMACC_VV_M1 = 3241, + RISCV_PseudoVFWNMACC_VV_M1_MASK = 3242, + RISCV_PseudoVFWNMACC_VV_M2 = 3243, + RISCV_PseudoVFWNMACC_VV_M2_MASK = 3244, + RISCV_PseudoVFWNMACC_VV_M4 = 3245, + RISCV_PseudoVFWNMACC_VV_M4_MASK = 3246, + RISCV_PseudoVFWNMACC_VV_MF2 = 3247, + RISCV_PseudoVFWNMACC_VV_MF2_MASK = 3248, + RISCV_PseudoVFWNMACC_VV_MF4 = 3249, + RISCV_PseudoVFWNMACC_VV_MF4_MASK = 3250, + RISCV_PseudoVFWNMSAC_VFPR16_M1 = 3251, + RISCV_PseudoVFWNMSAC_VFPR16_M1_MASK = 3252, + RISCV_PseudoVFWNMSAC_VFPR16_M2 = 3253, + RISCV_PseudoVFWNMSAC_VFPR16_M2_MASK = 3254, + RISCV_PseudoVFWNMSAC_VFPR16_M4 = 3255, + RISCV_PseudoVFWNMSAC_VFPR16_M4_MASK = 3256, + RISCV_PseudoVFWNMSAC_VFPR16_MF2 = 3257, + RISCV_PseudoVFWNMSAC_VFPR16_MF2_MASK = 3258, + RISCV_PseudoVFWNMSAC_VFPR16_MF4 = 3259, + RISCV_PseudoVFWNMSAC_VFPR16_MF4_MASK = 3260, + RISCV_PseudoVFWNMSAC_VFPR32_M1 = 3261, + RISCV_PseudoVFWNMSAC_VFPR32_M1_MASK = 3262, + RISCV_PseudoVFWNMSAC_VFPR32_M2 = 3263, + RISCV_PseudoVFWNMSAC_VFPR32_M2_MASK = 3264, + RISCV_PseudoVFWNMSAC_VFPR32_M4 = 3265, + RISCV_PseudoVFWNMSAC_VFPR32_M4_MASK = 3266, + RISCV_PseudoVFWNMSAC_VFPR32_MF2 = 3267, + RISCV_PseudoVFWNMSAC_VFPR32_MF2_MASK = 3268, + RISCV_PseudoVFWNMSAC_VV_M1 = 3269, + RISCV_PseudoVFWNMSAC_VV_M1_MASK = 3270, + RISCV_PseudoVFWNMSAC_VV_M2 = 3271, + RISCV_PseudoVFWNMSAC_VV_M2_MASK = 3272, + RISCV_PseudoVFWNMSAC_VV_M4 = 3273, + RISCV_PseudoVFWNMSAC_VV_M4_MASK = 3274, + RISCV_PseudoVFWNMSAC_VV_MF2 = 3275, + RISCV_PseudoVFWNMSAC_VV_MF2_MASK = 3276, + RISCV_PseudoVFWNMSAC_VV_MF4 = 3277, + RISCV_PseudoVFWNMSAC_VV_MF4_MASK = 3278, + RISCV_PseudoVFWREDOSUM_VS_M1_E16 = 3279, + RISCV_PseudoVFWREDOSUM_VS_M1_E16_MASK = 3280, + RISCV_PseudoVFWREDOSUM_VS_M1_E32 = 3281, + RISCV_PseudoVFWREDOSUM_VS_M1_E32_MASK = 3282, + RISCV_PseudoVFWREDOSUM_VS_M2_E16 = 3283, + RISCV_PseudoVFWREDOSUM_VS_M2_E16_MASK = 3284, + RISCV_PseudoVFWREDOSUM_VS_M2_E32 = 3285, + RISCV_PseudoVFWREDOSUM_VS_M2_E32_MASK = 3286, + RISCV_PseudoVFWREDOSUM_VS_M4_E16 = 3287, + RISCV_PseudoVFWREDOSUM_VS_M4_E16_MASK = 3288, + RISCV_PseudoVFWREDOSUM_VS_M4_E32 = 3289, + RISCV_PseudoVFWREDOSUM_VS_M4_E32_MASK = 3290, + RISCV_PseudoVFWREDOSUM_VS_M8_E16 = 3291, + RISCV_PseudoVFWREDOSUM_VS_M8_E16_MASK = 3292, + RISCV_PseudoVFWREDOSUM_VS_M8_E32 = 3293, + RISCV_PseudoVFWREDOSUM_VS_M8_E32_MASK = 3294, + RISCV_PseudoVFWREDOSUM_VS_MF2_E16 = 3295, + RISCV_PseudoVFWREDOSUM_VS_MF2_E16_MASK = 3296, + RISCV_PseudoVFWREDOSUM_VS_MF2_E32 = 3297, + RISCV_PseudoVFWREDOSUM_VS_MF2_E32_MASK = 3298, + RISCV_PseudoVFWREDOSUM_VS_MF4_E16 = 3299, + RISCV_PseudoVFWREDOSUM_VS_MF4_E16_MASK = 3300, + RISCV_PseudoVFWREDUSUM_VS_M1_E16 = 3301, + RISCV_PseudoVFWREDUSUM_VS_M1_E16_MASK = 3302, + RISCV_PseudoVFWREDUSUM_VS_M1_E32 = 3303, + RISCV_PseudoVFWREDUSUM_VS_M1_E32_MASK = 3304, + RISCV_PseudoVFWREDUSUM_VS_M2_E16 = 3305, + RISCV_PseudoVFWREDUSUM_VS_M2_E16_MASK = 3306, + RISCV_PseudoVFWREDUSUM_VS_M2_E32 = 3307, + RISCV_PseudoVFWREDUSUM_VS_M2_E32_MASK = 3308, + RISCV_PseudoVFWREDUSUM_VS_M4_E16 = 3309, + RISCV_PseudoVFWREDUSUM_VS_M4_E16_MASK = 3310, + RISCV_PseudoVFWREDUSUM_VS_M4_E32 = 3311, + RISCV_PseudoVFWREDUSUM_VS_M4_E32_MASK = 3312, + RISCV_PseudoVFWREDUSUM_VS_M8_E16 = 3313, + RISCV_PseudoVFWREDUSUM_VS_M8_E16_MASK = 3314, + RISCV_PseudoVFWREDUSUM_VS_M8_E32 = 3315, + RISCV_PseudoVFWREDUSUM_VS_M8_E32_MASK = 3316, + RISCV_PseudoVFWREDUSUM_VS_MF2_E16 = 3317, + RISCV_PseudoVFWREDUSUM_VS_MF2_E16_MASK = 3318, + RISCV_PseudoVFWREDUSUM_VS_MF2_E32 = 3319, + RISCV_PseudoVFWREDUSUM_VS_MF2_E32_MASK = 3320, + RISCV_PseudoVFWREDUSUM_VS_MF4_E16 = 3321, + RISCV_PseudoVFWREDUSUM_VS_MF4_E16_MASK = 3322, + RISCV_PseudoVFWSUB_VFPR16_M1 = 3323, + RISCV_PseudoVFWSUB_VFPR16_M1_MASK = 3324, + RISCV_PseudoVFWSUB_VFPR16_M2 = 3325, + RISCV_PseudoVFWSUB_VFPR16_M2_MASK = 3326, + RISCV_PseudoVFWSUB_VFPR16_M4 = 3327, + RISCV_PseudoVFWSUB_VFPR16_M4_MASK = 3328, + RISCV_PseudoVFWSUB_VFPR16_MF2 = 3329, + RISCV_PseudoVFWSUB_VFPR16_MF2_MASK = 3330, + RISCV_PseudoVFWSUB_VFPR16_MF4 = 3331, + RISCV_PseudoVFWSUB_VFPR16_MF4_MASK = 3332, + RISCV_PseudoVFWSUB_VFPR32_M1 = 3333, + RISCV_PseudoVFWSUB_VFPR32_M1_MASK = 3334, + RISCV_PseudoVFWSUB_VFPR32_M2 = 3335, + RISCV_PseudoVFWSUB_VFPR32_M2_MASK = 3336, + RISCV_PseudoVFWSUB_VFPR32_M4 = 3337, + RISCV_PseudoVFWSUB_VFPR32_M4_MASK = 3338, + RISCV_PseudoVFWSUB_VFPR32_MF2 = 3339, + RISCV_PseudoVFWSUB_VFPR32_MF2_MASK = 3340, + RISCV_PseudoVFWSUB_VV_M1 = 3341, + RISCV_PseudoVFWSUB_VV_M1_MASK = 3342, + RISCV_PseudoVFWSUB_VV_M2 = 3343, + RISCV_PseudoVFWSUB_VV_M2_MASK = 3344, + RISCV_PseudoVFWSUB_VV_M4 = 3345, + RISCV_PseudoVFWSUB_VV_M4_MASK = 3346, + RISCV_PseudoVFWSUB_VV_MF2 = 3347, + RISCV_PseudoVFWSUB_VV_MF2_MASK = 3348, + RISCV_PseudoVFWSUB_VV_MF4 = 3349, + RISCV_PseudoVFWSUB_VV_MF4_MASK = 3350, + RISCV_PseudoVFWSUB_WFPR16_M1 = 3351, + RISCV_PseudoVFWSUB_WFPR16_M1_MASK = 3352, + RISCV_PseudoVFWSUB_WFPR16_M2 = 3353, + RISCV_PseudoVFWSUB_WFPR16_M2_MASK = 3354, + RISCV_PseudoVFWSUB_WFPR16_M4 = 3355, + RISCV_PseudoVFWSUB_WFPR16_M4_MASK = 3356, + RISCV_PseudoVFWSUB_WFPR16_MF2 = 3357, + RISCV_PseudoVFWSUB_WFPR16_MF2_MASK = 3358, + RISCV_PseudoVFWSUB_WFPR16_MF4 = 3359, + RISCV_PseudoVFWSUB_WFPR16_MF4_MASK = 3360, + RISCV_PseudoVFWSUB_WFPR32_M1 = 3361, + RISCV_PseudoVFWSUB_WFPR32_M1_MASK = 3362, + RISCV_PseudoVFWSUB_WFPR32_M2 = 3363, + RISCV_PseudoVFWSUB_WFPR32_M2_MASK = 3364, + RISCV_PseudoVFWSUB_WFPR32_M4 = 3365, + RISCV_PseudoVFWSUB_WFPR32_M4_MASK = 3366, + RISCV_PseudoVFWSUB_WFPR32_MF2 = 3367, + RISCV_PseudoVFWSUB_WFPR32_MF2_MASK = 3368, + RISCV_PseudoVFWSUB_WV_M1 = 3369, + RISCV_PseudoVFWSUB_WV_M1_MASK = 3370, + RISCV_PseudoVFWSUB_WV_M1_MASK_TIED = 3371, + RISCV_PseudoVFWSUB_WV_M1_TIED = 3372, + RISCV_PseudoVFWSUB_WV_M2 = 3373, + RISCV_PseudoVFWSUB_WV_M2_MASK = 3374, + RISCV_PseudoVFWSUB_WV_M2_MASK_TIED = 3375, + RISCV_PseudoVFWSUB_WV_M2_TIED = 3376, + RISCV_PseudoVFWSUB_WV_M4 = 3377, + RISCV_PseudoVFWSUB_WV_M4_MASK = 3378, + RISCV_PseudoVFWSUB_WV_M4_MASK_TIED = 3379, + RISCV_PseudoVFWSUB_WV_M4_TIED = 3380, + RISCV_PseudoVFWSUB_WV_MF2 = 3381, + RISCV_PseudoVFWSUB_WV_MF2_MASK = 3382, + RISCV_PseudoVFWSUB_WV_MF2_MASK_TIED = 3383, + RISCV_PseudoVFWSUB_WV_MF2_TIED = 3384, + RISCV_PseudoVFWSUB_WV_MF4 = 3385, + RISCV_PseudoVFWSUB_WV_MF4_MASK = 3386, + RISCV_PseudoVFWSUB_WV_MF4_MASK_TIED = 3387, + RISCV_PseudoVFWSUB_WV_MF4_TIED = 3388, + RISCV_PseudoVGHSH_VV_M1 = 3389, + RISCV_PseudoVGHSH_VV_M2 = 3390, + RISCV_PseudoVGHSH_VV_M4 = 3391, + RISCV_PseudoVGHSH_VV_M8 = 3392, + RISCV_PseudoVGHSH_VV_MF2 = 3393, + RISCV_PseudoVGMUL_VV_M1 = 3394, + RISCV_PseudoVGMUL_VV_M2 = 3395, + RISCV_PseudoVGMUL_VV_M4 = 3396, + RISCV_PseudoVGMUL_VV_M8 = 3397, + RISCV_PseudoVGMUL_VV_MF2 = 3398, + RISCV_PseudoVID_V_M1 = 3399, + RISCV_PseudoVID_V_M1_MASK = 3400, + RISCV_PseudoVID_V_M2 = 3401, + RISCV_PseudoVID_V_M2_MASK = 3402, + RISCV_PseudoVID_V_M4 = 3403, + RISCV_PseudoVID_V_M4_MASK = 3404, + RISCV_PseudoVID_V_M8 = 3405, + RISCV_PseudoVID_V_M8_MASK = 3406, + RISCV_PseudoVID_V_MF2 = 3407, + RISCV_PseudoVID_V_MF2_MASK = 3408, + RISCV_PseudoVID_V_MF4 = 3409, + RISCV_PseudoVID_V_MF4_MASK = 3410, + RISCV_PseudoVID_V_MF8 = 3411, + RISCV_PseudoVID_V_MF8_MASK = 3412, + RISCV_PseudoVIOTA_M_M1 = 3413, + RISCV_PseudoVIOTA_M_M1_MASK = 3414, + RISCV_PseudoVIOTA_M_M2 = 3415, + RISCV_PseudoVIOTA_M_M2_MASK = 3416, + RISCV_PseudoVIOTA_M_M4 = 3417, + RISCV_PseudoVIOTA_M_M4_MASK = 3418, + RISCV_PseudoVIOTA_M_M8 = 3419, + RISCV_PseudoVIOTA_M_M8_MASK = 3420, + RISCV_PseudoVIOTA_M_MF2 = 3421, + RISCV_PseudoVIOTA_M_MF2_MASK = 3422, + RISCV_PseudoVIOTA_M_MF4 = 3423, + RISCV_PseudoVIOTA_M_MF4_MASK = 3424, + RISCV_PseudoVIOTA_M_MF8 = 3425, + RISCV_PseudoVIOTA_M_MF8_MASK = 3426, + RISCV_PseudoVLE16FF_V_M1 = 3427, + RISCV_PseudoVLE16FF_V_M1_MASK = 3428, + RISCV_PseudoVLE16FF_V_M2 = 3429, + RISCV_PseudoVLE16FF_V_M2_MASK = 3430, + RISCV_PseudoVLE16FF_V_M4 = 3431, + RISCV_PseudoVLE16FF_V_M4_MASK = 3432, + RISCV_PseudoVLE16FF_V_M8 = 3433, + RISCV_PseudoVLE16FF_V_M8_MASK = 3434, + RISCV_PseudoVLE16FF_V_MF2 = 3435, + RISCV_PseudoVLE16FF_V_MF2_MASK = 3436, + RISCV_PseudoVLE16FF_V_MF4 = 3437, + RISCV_PseudoVLE16FF_V_MF4_MASK = 3438, + RISCV_PseudoVLE16_V_M1 = 3439, + RISCV_PseudoVLE16_V_M1_MASK = 3440, + RISCV_PseudoVLE16_V_M2 = 3441, + RISCV_PseudoVLE16_V_M2_MASK = 3442, + RISCV_PseudoVLE16_V_M4 = 3443, + RISCV_PseudoVLE16_V_M4_MASK = 3444, + RISCV_PseudoVLE16_V_M8 = 3445, + RISCV_PseudoVLE16_V_M8_MASK = 3446, + RISCV_PseudoVLE16_V_MF2 = 3447, + RISCV_PseudoVLE16_V_MF2_MASK = 3448, + RISCV_PseudoVLE16_V_MF4 = 3449, + RISCV_PseudoVLE16_V_MF4_MASK = 3450, + RISCV_PseudoVLE32FF_V_M1 = 3451, + RISCV_PseudoVLE32FF_V_M1_MASK = 3452, + RISCV_PseudoVLE32FF_V_M2 = 3453, + RISCV_PseudoVLE32FF_V_M2_MASK = 3454, + RISCV_PseudoVLE32FF_V_M4 = 3455, + RISCV_PseudoVLE32FF_V_M4_MASK = 3456, + RISCV_PseudoVLE32FF_V_M8 = 3457, + RISCV_PseudoVLE32FF_V_M8_MASK = 3458, + RISCV_PseudoVLE32FF_V_MF2 = 3459, + RISCV_PseudoVLE32FF_V_MF2_MASK = 3460, + RISCV_PseudoVLE32_V_M1 = 3461, + RISCV_PseudoVLE32_V_M1_MASK = 3462, + RISCV_PseudoVLE32_V_M2 = 3463, + RISCV_PseudoVLE32_V_M2_MASK = 3464, + RISCV_PseudoVLE32_V_M4 = 3465, + RISCV_PseudoVLE32_V_M4_MASK = 3466, + RISCV_PseudoVLE32_V_M8 = 3467, + RISCV_PseudoVLE32_V_M8_MASK = 3468, + RISCV_PseudoVLE32_V_MF2 = 3469, + RISCV_PseudoVLE32_V_MF2_MASK = 3470, + RISCV_PseudoVLE64FF_V_M1 = 3471, + RISCV_PseudoVLE64FF_V_M1_MASK = 3472, + RISCV_PseudoVLE64FF_V_M2 = 3473, + RISCV_PseudoVLE64FF_V_M2_MASK = 3474, + RISCV_PseudoVLE64FF_V_M4 = 3475, + RISCV_PseudoVLE64FF_V_M4_MASK = 3476, + RISCV_PseudoVLE64FF_V_M8 = 3477, + RISCV_PseudoVLE64FF_V_M8_MASK = 3478, + RISCV_PseudoVLE64_V_M1 = 3479, + RISCV_PseudoVLE64_V_M1_MASK = 3480, + RISCV_PseudoVLE64_V_M2 = 3481, + RISCV_PseudoVLE64_V_M2_MASK = 3482, + RISCV_PseudoVLE64_V_M4 = 3483, + RISCV_PseudoVLE64_V_M4_MASK = 3484, + RISCV_PseudoVLE64_V_M8 = 3485, + RISCV_PseudoVLE64_V_M8_MASK = 3486, + RISCV_PseudoVLE8FF_V_M1 = 3487, + RISCV_PseudoVLE8FF_V_M1_MASK = 3488, + RISCV_PseudoVLE8FF_V_M2 = 3489, + RISCV_PseudoVLE8FF_V_M2_MASK = 3490, + RISCV_PseudoVLE8FF_V_M4 = 3491, + RISCV_PseudoVLE8FF_V_M4_MASK = 3492, + RISCV_PseudoVLE8FF_V_M8 = 3493, + RISCV_PseudoVLE8FF_V_M8_MASK = 3494, + RISCV_PseudoVLE8FF_V_MF2 = 3495, + RISCV_PseudoVLE8FF_V_MF2_MASK = 3496, + RISCV_PseudoVLE8FF_V_MF4 = 3497, + RISCV_PseudoVLE8FF_V_MF4_MASK = 3498, + RISCV_PseudoVLE8FF_V_MF8 = 3499, + RISCV_PseudoVLE8FF_V_MF8_MASK = 3500, + RISCV_PseudoVLE8_V_M1 = 3501, + RISCV_PseudoVLE8_V_M1_MASK = 3502, + RISCV_PseudoVLE8_V_M2 = 3503, + RISCV_PseudoVLE8_V_M2_MASK = 3504, + RISCV_PseudoVLE8_V_M4 = 3505, + RISCV_PseudoVLE8_V_M4_MASK = 3506, + RISCV_PseudoVLE8_V_M8 = 3507, + RISCV_PseudoVLE8_V_M8_MASK = 3508, + RISCV_PseudoVLE8_V_MF2 = 3509, + RISCV_PseudoVLE8_V_MF2_MASK = 3510, + RISCV_PseudoVLE8_V_MF4 = 3511, + RISCV_PseudoVLE8_V_MF4_MASK = 3512, + RISCV_PseudoVLE8_V_MF8 = 3513, + RISCV_PseudoVLE8_V_MF8_MASK = 3514, + RISCV_PseudoVLM_V_B1 = 3515, + RISCV_PseudoVLM_V_B16 = 3516, + RISCV_PseudoVLM_V_B2 = 3517, + RISCV_PseudoVLM_V_B32 = 3518, + RISCV_PseudoVLM_V_B4 = 3519, + RISCV_PseudoVLM_V_B64 = 3520, + RISCV_PseudoVLM_V_B8 = 3521, + RISCV_PseudoVLOXEI16_V_M1_M1 = 3522, + RISCV_PseudoVLOXEI16_V_M1_M1_MASK = 3523, + RISCV_PseudoVLOXEI16_V_M1_M2 = 3524, + RISCV_PseudoVLOXEI16_V_M1_M2_MASK = 3525, + RISCV_PseudoVLOXEI16_V_M1_M4 = 3526, + RISCV_PseudoVLOXEI16_V_M1_M4_MASK = 3527, + RISCV_PseudoVLOXEI16_V_M1_MF2 = 3528, + RISCV_PseudoVLOXEI16_V_M1_MF2_MASK = 3529, + RISCV_PseudoVLOXEI16_V_M2_M1 = 3530, + RISCV_PseudoVLOXEI16_V_M2_M1_MASK = 3531, + RISCV_PseudoVLOXEI16_V_M2_M2 = 3532, + RISCV_PseudoVLOXEI16_V_M2_M2_MASK = 3533, + RISCV_PseudoVLOXEI16_V_M2_M4 = 3534, + RISCV_PseudoVLOXEI16_V_M2_M4_MASK = 3535, + RISCV_PseudoVLOXEI16_V_M2_M8 = 3536, + RISCV_PseudoVLOXEI16_V_M2_M8_MASK = 3537, + RISCV_PseudoVLOXEI16_V_M4_M2 = 3538, + RISCV_PseudoVLOXEI16_V_M4_M2_MASK = 3539, + RISCV_PseudoVLOXEI16_V_M4_M4 = 3540, + RISCV_PseudoVLOXEI16_V_M4_M4_MASK = 3541, + RISCV_PseudoVLOXEI16_V_M4_M8 = 3542, + RISCV_PseudoVLOXEI16_V_M4_M8_MASK = 3543, + RISCV_PseudoVLOXEI16_V_M8_M4 = 3544, + RISCV_PseudoVLOXEI16_V_M8_M4_MASK = 3545, + RISCV_PseudoVLOXEI16_V_M8_M8 = 3546, + RISCV_PseudoVLOXEI16_V_M8_M8_MASK = 3547, + RISCV_PseudoVLOXEI16_V_MF2_M1 = 3548, + RISCV_PseudoVLOXEI16_V_MF2_M1_MASK = 3549, + RISCV_PseudoVLOXEI16_V_MF2_M2 = 3550, + RISCV_PseudoVLOXEI16_V_MF2_M2_MASK = 3551, + RISCV_PseudoVLOXEI16_V_MF2_MF2 = 3552, + RISCV_PseudoVLOXEI16_V_MF2_MF2_MASK = 3553, + RISCV_PseudoVLOXEI16_V_MF2_MF4 = 3554, + RISCV_PseudoVLOXEI16_V_MF2_MF4_MASK = 3555, + RISCV_PseudoVLOXEI16_V_MF4_M1 = 3556, + RISCV_PseudoVLOXEI16_V_MF4_M1_MASK = 3557, + RISCV_PseudoVLOXEI16_V_MF4_MF2 = 3558, + RISCV_PseudoVLOXEI16_V_MF4_MF2_MASK = 3559, + RISCV_PseudoVLOXEI16_V_MF4_MF4 = 3560, + RISCV_PseudoVLOXEI16_V_MF4_MF4_MASK = 3561, + RISCV_PseudoVLOXEI16_V_MF4_MF8 = 3562, + RISCV_PseudoVLOXEI16_V_MF4_MF8_MASK = 3563, + RISCV_PseudoVLOXEI32_V_M1_M1 = 3564, + RISCV_PseudoVLOXEI32_V_M1_M1_MASK = 3565, + RISCV_PseudoVLOXEI32_V_M1_M2 = 3566, + RISCV_PseudoVLOXEI32_V_M1_M2_MASK = 3567, + RISCV_PseudoVLOXEI32_V_M1_MF2 = 3568, + RISCV_PseudoVLOXEI32_V_M1_MF2_MASK = 3569, + RISCV_PseudoVLOXEI32_V_M1_MF4 = 3570, + RISCV_PseudoVLOXEI32_V_M1_MF4_MASK = 3571, + RISCV_PseudoVLOXEI32_V_M2_M1 = 3572, + RISCV_PseudoVLOXEI32_V_M2_M1_MASK = 3573, + RISCV_PseudoVLOXEI32_V_M2_M2 = 3574, + RISCV_PseudoVLOXEI32_V_M2_M2_MASK = 3575, + RISCV_PseudoVLOXEI32_V_M2_M4 = 3576, + RISCV_PseudoVLOXEI32_V_M2_M4_MASK = 3577, + RISCV_PseudoVLOXEI32_V_M2_MF2 = 3578, + RISCV_PseudoVLOXEI32_V_M2_MF2_MASK = 3579, + RISCV_PseudoVLOXEI32_V_M4_M1 = 3580, + RISCV_PseudoVLOXEI32_V_M4_M1_MASK = 3581, + RISCV_PseudoVLOXEI32_V_M4_M2 = 3582, + RISCV_PseudoVLOXEI32_V_M4_M2_MASK = 3583, + RISCV_PseudoVLOXEI32_V_M4_M4 = 3584, + RISCV_PseudoVLOXEI32_V_M4_M4_MASK = 3585, + RISCV_PseudoVLOXEI32_V_M4_M8 = 3586, + RISCV_PseudoVLOXEI32_V_M4_M8_MASK = 3587, + RISCV_PseudoVLOXEI32_V_M8_M2 = 3588, + RISCV_PseudoVLOXEI32_V_M8_M2_MASK = 3589, + RISCV_PseudoVLOXEI32_V_M8_M4 = 3590, + RISCV_PseudoVLOXEI32_V_M8_M4_MASK = 3591, + RISCV_PseudoVLOXEI32_V_M8_M8 = 3592, + RISCV_PseudoVLOXEI32_V_M8_M8_MASK = 3593, + RISCV_PseudoVLOXEI32_V_MF2_M1 = 3594, + RISCV_PseudoVLOXEI32_V_MF2_M1_MASK = 3595, + RISCV_PseudoVLOXEI32_V_MF2_MF2 = 3596, + RISCV_PseudoVLOXEI32_V_MF2_MF2_MASK = 3597, + RISCV_PseudoVLOXEI32_V_MF2_MF4 = 3598, + RISCV_PseudoVLOXEI32_V_MF2_MF4_MASK = 3599, + RISCV_PseudoVLOXEI32_V_MF2_MF8 = 3600, + RISCV_PseudoVLOXEI32_V_MF2_MF8_MASK = 3601, + RISCV_PseudoVLOXEI64_V_M1_M1 = 3602, + RISCV_PseudoVLOXEI64_V_M1_M1_MASK = 3603, + RISCV_PseudoVLOXEI64_V_M1_MF2 = 3604, + RISCV_PseudoVLOXEI64_V_M1_MF2_MASK = 3605, + RISCV_PseudoVLOXEI64_V_M1_MF4 = 3606, + RISCV_PseudoVLOXEI64_V_M1_MF4_MASK = 3607, + RISCV_PseudoVLOXEI64_V_M1_MF8 = 3608, + RISCV_PseudoVLOXEI64_V_M1_MF8_MASK = 3609, + RISCV_PseudoVLOXEI64_V_M2_M1 = 3610, + RISCV_PseudoVLOXEI64_V_M2_M1_MASK = 3611, + RISCV_PseudoVLOXEI64_V_M2_M2 = 3612, + RISCV_PseudoVLOXEI64_V_M2_M2_MASK = 3613, + RISCV_PseudoVLOXEI64_V_M2_MF2 = 3614, + RISCV_PseudoVLOXEI64_V_M2_MF2_MASK = 3615, + RISCV_PseudoVLOXEI64_V_M2_MF4 = 3616, + RISCV_PseudoVLOXEI64_V_M2_MF4_MASK = 3617, + RISCV_PseudoVLOXEI64_V_M4_M1 = 3618, + RISCV_PseudoVLOXEI64_V_M4_M1_MASK = 3619, + RISCV_PseudoVLOXEI64_V_M4_M2 = 3620, + RISCV_PseudoVLOXEI64_V_M4_M2_MASK = 3621, + RISCV_PseudoVLOXEI64_V_M4_M4 = 3622, + RISCV_PseudoVLOXEI64_V_M4_M4_MASK = 3623, + RISCV_PseudoVLOXEI64_V_M4_MF2 = 3624, + RISCV_PseudoVLOXEI64_V_M4_MF2_MASK = 3625, + RISCV_PseudoVLOXEI64_V_M8_M1 = 3626, + RISCV_PseudoVLOXEI64_V_M8_M1_MASK = 3627, + RISCV_PseudoVLOXEI64_V_M8_M2 = 3628, + RISCV_PseudoVLOXEI64_V_M8_M2_MASK = 3629, + RISCV_PseudoVLOXEI64_V_M8_M4 = 3630, + RISCV_PseudoVLOXEI64_V_M8_M4_MASK = 3631, + RISCV_PseudoVLOXEI64_V_M8_M8 = 3632, + RISCV_PseudoVLOXEI64_V_M8_M8_MASK = 3633, + RISCV_PseudoVLOXEI8_V_M1_M1 = 3634, + RISCV_PseudoVLOXEI8_V_M1_M1_MASK = 3635, + RISCV_PseudoVLOXEI8_V_M1_M2 = 3636, + RISCV_PseudoVLOXEI8_V_M1_M2_MASK = 3637, + RISCV_PseudoVLOXEI8_V_M1_M4 = 3638, + RISCV_PseudoVLOXEI8_V_M1_M4_MASK = 3639, + RISCV_PseudoVLOXEI8_V_M1_M8 = 3640, + RISCV_PseudoVLOXEI8_V_M1_M8_MASK = 3641, + RISCV_PseudoVLOXEI8_V_M2_M2 = 3642, + RISCV_PseudoVLOXEI8_V_M2_M2_MASK = 3643, + RISCV_PseudoVLOXEI8_V_M2_M4 = 3644, + RISCV_PseudoVLOXEI8_V_M2_M4_MASK = 3645, + RISCV_PseudoVLOXEI8_V_M2_M8 = 3646, + RISCV_PseudoVLOXEI8_V_M2_M8_MASK = 3647, + RISCV_PseudoVLOXEI8_V_M4_M4 = 3648, + RISCV_PseudoVLOXEI8_V_M4_M4_MASK = 3649, + RISCV_PseudoVLOXEI8_V_M4_M8 = 3650, + RISCV_PseudoVLOXEI8_V_M4_M8_MASK = 3651, + RISCV_PseudoVLOXEI8_V_M8_M8 = 3652, + RISCV_PseudoVLOXEI8_V_M8_M8_MASK = 3653, + RISCV_PseudoVLOXEI8_V_MF2_M1 = 3654, + RISCV_PseudoVLOXEI8_V_MF2_M1_MASK = 3655, + RISCV_PseudoVLOXEI8_V_MF2_M2 = 3656, + RISCV_PseudoVLOXEI8_V_MF2_M2_MASK = 3657, + RISCV_PseudoVLOXEI8_V_MF2_M4 = 3658, + RISCV_PseudoVLOXEI8_V_MF2_M4_MASK = 3659, + RISCV_PseudoVLOXEI8_V_MF2_MF2 = 3660, + RISCV_PseudoVLOXEI8_V_MF2_MF2_MASK = 3661, + RISCV_PseudoVLOXEI8_V_MF4_M1 = 3662, + RISCV_PseudoVLOXEI8_V_MF4_M1_MASK = 3663, + RISCV_PseudoVLOXEI8_V_MF4_M2 = 3664, + RISCV_PseudoVLOXEI8_V_MF4_M2_MASK = 3665, + RISCV_PseudoVLOXEI8_V_MF4_MF2 = 3666, + RISCV_PseudoVLOXEI8_V_MF4_MF2_MASK = 3667, + RISCV_PseudoVLOXEI8_V_MF4_MF4 = 3668, + RISCV_PseudoVLOXEI8_V_MF4_MF4_MASK = 3669, + RISCV_PseudoVLOXEI8_V_MF8_M1 = 3670, + RISCV_PseudoVLOXEI8_V_MF8_M1_MASK = 3671, + RISCV_PseudoVLOXEI8_V_MF8_MF2 = 3672, + RISCV_PseudoVLOXEI8_V_MF8_MF2_MASK = 3673, + RISCV_PseudoVLOXEI8_V_MF8_MF4 = 3674, + RISCV_PseudoVLOXEI8_V_MF8_MF4_MASK = 3675, + RISCV_PseudoVLOXEI8_V_MF8_MF8 = 3676, + RISCV_PseudoVLOXEI8_V_MF8_MF8_MASK = 3677, + RISCV_PseudoVLOXSEG2EI16_V_M1_M1 = 3678, + RISCV_PseudoVLOXSEG2EI16_V_M1_M1_MASK = 3679, + RISCV_PseudoVLOXSEG2EI16_V_M1_M2 = 3680, + RISCV_PseudoVLOXSEG2EI16_V_M1_M2_MASK = 3681, + RISCV_PseudoVLOXSEG2EI16_V_M1_M4 = 3682, + RISCV_PseudoVLOXSEG2EI16_V_M1_M4_MASK = 3683, + RISCV_PseudoVLOXSEG2EI16_V_M1_MF2 = 3684, + RISCV_PseudoVLOXSEG2EI16_V_M1_MF2_MASK = 3685, + RISCV_PseudoVLOXSEG2EI16_V_M2_M1 = 3686, + RISCV_PseudoVLOXSEG2EI16_V_M2_M1_MASK = 3687, + RISCV_PseudoVLOXSEG2EI16_V_M2_M2 = 3688, + RISCV_PseudoVLOXSEG2EI16_V_M2_M2_MASK = 3689, + RISCV_PseudoVLOXSEG2EI16_V_M2_M4 = 3690, + RISCV_PseudoVLOXSEG2EI16_V_M2_M4_MASK = 3691, + RISCV_PseudoVLOXSEG2EI16_V_M4_M2 = 3692, + RISCV_PseudoVLOXSEG2EI16_V_M4_M2_MASK = 3693, + RISCV_PseudoVLOXSEG2EI16_V_M4_M4 = 3694, + RISCV_PseudoVLOXSEG2EI16_V_M4_M4_MASK = 3695, + RISCV_PseudoVLOXSEG2EI16_V_M8_M4 = 3696, + RISCV_PseudoVLOXSEG2EI16_V_M8_M4_MASK = 3697, + RISCV_PseudoVLOXSEG2EI16_V_MF2_M1 = 3698, + RISCV_PseudoVLOXSEG2EI16_V_MF2_M1_MASK = 3699, + RISCV_PseudoVLOXSEG2EI16_V_MF2_M2 = 3700, + RISCV_PseudoVLOXSEG2EI16_V_MF2_M2_MASK = 3701, + RISCV_PseudoVLOXSEG2EI16_V_MF2_MF2 = 3702, + RISCV_PseudoVLOXSEG2EI16_V_MF2_MF2_MASK = 3703, + RISCV_PseudoVLOXSEG2EI16_V_MF2_MF4 = 3704, + RISCV_PseudoVLOXSEG2EI16_V_MF2_MF4_MASK = 3705, + RISCV_PseudoVLOXSEG2EI16_V_MF4_M1 = 3706, + RISCV_PseudoVLOXSEG2EI16_V_MF4_M1_MASK = 3707, + RISCV_PseudoVLOXSEG2EI16_V_MF4_MF2 = 3708, + RISCV_PseudoVLOXSEG2EI16_V_MF4_MF2_MASK = 3709, + RISCV_PseudoVLOXSEG2EI16_V_MF4_MF4 = 3710, + RISCV_PseudoVLOXSEG2EI16_V_MF4_MF4_MASK = 3711, + RISCV_PseudoVLOXSEG2EI16_V_MF4_MF8 = 3712, + RISCV_PseudoVLOXSEG2EI16_V_MF4_MF8_MASK = 3713, + RISCV_PseudoVLOXSEG2EI32_V_M1_M1 = 3714, + RISCV_PseudoVLOXSEG2EI32_V_M1_M1_MASK = 3715, + RISCV_PseudoVLOXSEG2EI32_V_M1_M2 = 3716, + RISCV_PseudoVLOXSEG2EI32_V_M1_M2_MASK = 3717, + RISCV_PseudoVLOXSEG2EI32_V_M1_MF2 = 3718, + RISCV_PseudoVLOXSEG2EI32_V_M1_MF2_MASK = 3719, + RISCV_PseudoVLOXSEG2EI32_V_M1_MF4 = 3720, + RISCV_PseudoVLOXSEG2EI32_V_M1_MF4_MASK = 3721, + RISCV_PseudoVLOXSEG2EI32_V_M2_M1 = 3722, + RISCV_PseudoVLOXSEG2EI32_V_M2_M1_MASK = 3723, + RISCV_PseudoVLOXSEG2EI32_V_M2_M2 = 3724, + RISCV_PseudoVLOXSEG2EI32_V_M2_M2_MASK = 3725, + RISCV_PseudoVLOXSEG2EI32_V_M2_M4 = 3726, + RISCV_PseudoVLOXSEG2EI32_V_M2_M4_MASK = 3727, + RISCV_PseudoVLOXSEG2EI32_V_M2_MF2 = 3728, + RISCV_PseudoVLOXSEG2EI32_V_M2_MF2_MASK = 3729, + RISCV_PseudoVLOXSEG2EI32_V_M4_M1 = 3730, + RISCV_PseudoVLOXSEG2EI32_V_M4_M1_MASK = 3731, + RISCV_PseudoVLOXSEG2EI32_V_M4_M2 = 3732, + RISCV_PseudoVLOXSEG2EI32_V_M4_M2_MASK = 3733, + RISCV_PseudoVLOXSEG2EI32_V_M4_M4 = 3734, + RISCV_PseudoVLOXSEG2EI32_V_M4_M4_MASK = 3735, + RISCV_PseudoVLOXSEG2EI32_V_M8_M2 = 3736, + RISCV_PseudoVLOXSEG2EI32_V_M8_M2_MASK = 3737, + RISCV_PseudoVLOXSEG2EI32_V_M8_M4 = 3738, + RISCV_PseudoVLOXSEG2EI32_V_M8_M4_MASK = 3739, + RISCV_PseudoVLOXSEG2EI32_V_MF2_M1 = 3740, + RISCV_PseudoVLOXSEG2EI32_V_MF2_M1_MASK = 3741, + RISCV_PseudoVLOXSEG2EI32_V_MF2_MF2 = 3742, + RISCV_PseudoVLOXSEG2EI32_V_MF2_MF2_MASK = 3743, + RISCV_PseudoVLOXSEG2EI32_V_MF2_MF4 = 3744, + RISCV_PseudoVLOXSEG2EI32_V_MF2_MF4_MASK = 3745, + RISCV_PseudoVLOXSEG2EI32_V_MF2_MF8 = 3746, + RISCV_PseudoVLOXSEG2EI32_V_MF2_MF8_MASK = 3747, + RISCV_PseudoVLOXSEG2EI64_V_M1_M1 = 3748, + RISCV_PseudoVLOXSEG2EI64_V_M1_M1_MASK = 3749, + RISCV_PseudoVLOXSEG2EI64_V_M1_MF2 = 3750, + RISCV_PseudoVLOXSEG2EI64_V_M1_MF2_MASK = 3751, + RISCV_PseudoVLOXSEG2EI64_V_M1_MF4 = 3752, + RISCV_PseudoVLOXSEG2EI64_V_M1_MF4_MASK = 3753, + RISCV_PseudoVLOXSEG2EI64_V_M1_MF8 = 3754, + RISCV_PseudoVLOXSEG2EI64_V_M1_MF8_MASK = 3755, + RISCV_PseudoVLOXSEG2EI64_V_M2_M1 = 3756, + RISCV_PseudoVLOXSEG2EI64_V_M2_M1_MASK = 3757, + RISCV_PseudoVLOXSEG2EI64_V_M2_M2 = 3758, + RISCV_PseudoVLOXSEG2EI64_V_M2_M2_MASK = 3759, + RISCV_PseudoVLOXSEG2EI64_V_M2_MF2 = 3760, + RISCV_PseudoVLOXSEG2EI64_V_M2_MF2_MASK = 3761, + RISCV_PseudoVLOXSEG2EI64_V_M2_MF4 = 3762, + RISCV_PseudoVLOXSEG2EI64_V_M2_MF4_MASK = 3763, + RISCV_PseudoVLOXSEG2EI64_V_M4_M1 = 3764, + RISCV_PseudoVLOXSEG2EI64_V_M4_M1_MASK = 3765, + RISCV_PseudoVLOXSEG2EI64_V_M4_M2 = 3766, + RISCV_PseudoVLOXSEG2EI64_V_M4_M2_MASK = 3767, + RISCV_PseudoVLOXSEG2EI64_V_M4_M4 = 3768, + RISCV_PseudoVLOXSEG2EI64_V_M4_M4_MASK = 3769, + RISCV_PseudoVLOXSEG2EI64_V_M4_MF2 = 3770, + RISCV_PseudoVLOXSEG2EI64_V_M4_MF2_MASK = 3771, + RISCV_PseudoVLOXSEG2EI64_V_M8_M1 = 3772, + RISCV_PseudoVLOXSEG2EI64_V_M8_M1_MASK = 3773, + RISCV_PseudoVLOXSEG2EI64_V_M8_M2 = 3774, + RISCV_PseudoVLOXSEG2EI64_V_M8_M2_MASK = 3775, + RISCV_PseudoVLOXSEG2EI64_V_M8_M4 = 3776, + RISCV_PseudoVLOXSEG2EI64_V_M8_M4_MASK = 3777, + RISCV_PseudoVLOXSEG2EI8_V_M1_M1 = 3778, + RISCV_PseudoVLOXSEG2EI8_V_M1_M1_MASK = 3779, + RISCV_PseudoVLOXSEG2EI8_V_M1_M2 = 3780, + RISCV_PseudoVLOXSEG2EI8_V_M1_M2_MASK = 3781, + RISCV_PseudoVLOXSEG2EI8_V_M1_M4 = 3782, + RISCV_PseudoVLOXSEG2EI8_V_M1_M4_MASK = 3783, + RISCV_PseudoVLOXSEG2EI8_V_M2_M2 = 3784, + RISCV_PseudoVLOXSEG2EI8_V_M2_M2_MASK = 3785, + RISCV_PseudoVLOXSEG2EI8_V_M2_M4 = 3786, + RISCV_PseudoVLOXSEG2EI8_V_M2_M4_MASK = 3787, + RISCV_PseudoVLOXSEG2EI8_V_M4_M4 = 3788, + RISCV_PseudoVLOXSEG2EI8_V_M4_M4_MASK = 3789, + RISCV_PseudoVLOXSEG2EI8_V_MF2_M1 = 3790, + RISCV_PseudoVLOXSEG2EI8_V_MF2_M1_MASK = 3791, + RISCV_PseudoVLOXSEG2EI8_V_MF2_M2 = 3792, + RISCV_PseudoVLOXSEG2EI8_V_MF2_M2_MASK = 3793, + RISCV_PseudoVLOXSEG2EI8_V_MF2_M4 = 3794, + RISCV_PseudoVLOXSEG2EI8_V_MF2_M4_MASK = 3795, + RISCV_PseudoVLOXSEG2EI8_V_MF2_MF2 = 3796, + RISCV_PseudoVLOXSEG2EI8_V_MF2_MF2_MASK = 3797, + RISCV_PseudoVLOXSEG2EI8_V_MF4_M1 = 3798, + RISCV_PseudoVLOXSEG2EI8_V_MF4_M1_MASK = 3799, + RISCV_PseudoVLOXSEG2EI8_V_MF4_M2 = 3800, + RISCV_PseudoVLOXSEG2EI8_V_MF4_M2_MASK = 3801, + RISCV_PseudoVLOXSEG2EI8_V_MF4_MF2 = 3802, + RISCV_PseudoVLOXSEG2EI8_V_MF4_MF2_MASK = 3803, + RISCV_PseudoVLOXSEG2EI8_V_MF4_MF4 = 3804, + RISCV_PseudoVLOXSEG2EI8_V_MF4_MF4_MASK = 3805, + RISCV_PseudoVLOXSEG2EI8_V_MF8_M1 = 3806, + RISCV_PseudoVLOXSEG2EI8_V_MF8_M1_MASK = 3807, + RISCV_PseudoVLOXSEG2EI8_V_MF8_MF2 = 3808, + RISCV_PseudoVLOXSEG2EI8_V_MF8_MF2_MASK = 3809, + RISCV_PseudoVLOXSEG2EI8_V_MF8_MF4 = 3810, + RISCV_PseudoVLOXSEG2EI8_V_MF8_MF4_MASK = 3811, + RISCV_PseudoVLOXSEG2EI8_V_MF8_MF8 = 3812, + RISCV_PseudoVLOXSEG2EI8_V_MF8_MF8_MASK = 3813, + RISCV_PseudoVLOXSEG3EI16_V_M1_M1 = 3814, + RISCV_PseudoVLOXSEG3EI16_V_M1_M1_MASK = 3815, + RISCV_PseudoVLOXSEG3EI16_V_M1_M2 = 3816, + RISCV_PseudoVLOXSEG3EI16_V_M1_M2_MASK = 3817, + RISCV_PseudoVLOXSEG3EI16_V_M1_MF2 = 3818, + RISCV_PseudoVLOXSEG3EI16_V_M1_MF2_MASK = 3819, + RISCV_PseudoVLOXSEG3EI16_V_M2_M1 = 3820, + RISCV_PseudoVLOXSEG3EI16_V_M2_M1_MASK = 3821, + RISCV_PseudoVLOXSEG3EI16_V_M2_M2 = 3822, + RISCV_PseudoVLOXSEG3EI16_V_M2_M2_MASK = 3823, + RISCV_PseudoVLOXSEG3EI16_V_M4_M2 = 3824, + RISCV_PseudoVLOXSEG3EI16_V_M4_M2_MASK = 3825, + RISCV_PseudoVLOXSEG3EI16_V_MF2_M1 = 3826, + RISCV_PseudoVLOXSEG3EI16_V_MF2_M1_MASK = 3827, + RISCV_PseudoVLOXSEG3EI16_V_MF2_M2 = 3828, + RISCV_PseudoVLOXSEG3EI16_V_MF2_M2_MASK = 3829, + RISCV_PseudoVLOXSEG3EI16_V_MF2_MF2 = 3830, + RISCV_PseudoVLOXSEG3EI16_V_MF2_MF2_MASK = 3831, + RISCV_PseudoVLOXSEG3EI16_V_MF2_MF4 = 3832, + RISCV_PseudoVLOXSEG3EI16_V_MF2_MF4_MASK = 3833, + RISCV_PseudoVLOXSEG3EI16_V_MF4_M1 = 3834, + RISCV_PseudoVLOXSEG3EI16_V_MF4_M1_MASK = 3835, + RISCV_PseudoVLOXSEG3EI16_V_MF4_MF2 = 3836, + RISCV_PseudoVLOXSEG3EI16_V_MF4_MF2_MASK = 3837, + RISCV_PseudoVLOXSEG3EI16_V_MF4_MF4 = 3838, + RISCV_PseudoVLOXSEG3EI16_V_MF4_MF4_MASK = 3839, + RISCV_PseudoVLOXSEG3EI16_V_MF4_MF8 = 3840, + RISCV_PseudoVLOXSEG3EI16_V_MF4_MF8_MASK = 3841, + RISCV_PseudoVLOXSEG3EI32_V_M1_M1 = 3842, + RISCV_PseudoVLOXSEG3EI32_V_M1_M1_MASK = 3843, + RISCV_PseudoVLOXSEG3EI32_V_M1_M2 = 3844, + RISCV_PseudoVLOXSEG3EI32_V_M1_M2_MASK = 3845, + RISCV_PseudoVLOXSEG3EI32_V_M1_MF2 = 3846, + RISCV_PseudoVLOXSEG3EI32_V_M1_MF2_MASK = 3847, + RISCV_PseudoVLOXSEG3EI32_V_M1_MF4 = 3848, + RISCV_PseudoVLOXSEG3EI32_V_M1_MF4_MASK = 3849, + RISCV_PseudoVLOXSEG3EI32_V_M2_M1 = 3850, + RISCV_PseudoVLOXSEG3EI32_V_M2_M1_MASK = 3851, + RISCV_PseudoVLOXSEG3EI32_V_M2_M2 = 3852, + RISCV_PseudoVLOXSEG3EI32_V_M2_M2_MASK = 3853, + RISCV_PseudoVLOXSEG3EI32_V_M2_MF2 = 3854, + RISCV_PseudoVLOXSEG3EI32_V_M2_MF2_MASK = 3855, + RISCV_PseudoVLOXSEG3EI32_V_M4_M1 = 3856, + RISCV_PseudoVLOXSEG3EI32_V_M4_M1_MASK = 3857, + RISCV_PseudoVLOXSEG3EI32_V_M4_M2 = 3858, + RISCV_PseudoVLOXSEG3EI32_V_M4_M2_MASK = 3859, + RISCV_PseudoVLOXSEG3EI32_V_M8_M2 = 3860, + RISCV_PseudoVLOXSEG3EI32_V_M8_M2_MASK = 3861, + RISCV_PseudoVLOXSEG3EI32_V_MF2_M1 = 3862, + RISCV_PseudoVLOXSEG3EI32_V_MF2_M1_MASK = 3863, + RISCV_PseudoVLOXSEG3EI32_V_MF2_MF2 = 3864, + RISCV_PseudoVLOXSEG3EI32_V_MF2_MF2_MASK = 3865, + RISCV_PseudoVLOXSEG3EI32_V_MF2_MF4 = 3866, + RISCV_PseudoVLOXSEG3EI32_V_MF2_MF4_MASK = 3867, + RISCV_PseudoVLOXSEG3EI32_V_MF2_MF8 = 3868, + RISCV_PseudoVLOXSEG3EI32_V_MF2_MF8_MASK = 3869, + RISCV_PseudoVLOXSEG3EI64_V_M1_M1 = 3870, + RISCV_PseudoVLOXSEG3EI64_V_M1_M1_MASK = 3871, + RISCV_PseudoVLOXSEG3EI64_V_M1_MF2 = 3872, + RISCV_PseudoVLOXSEG3EI64_V_M1_MF2_MASK = 3873, + RISCV_PseudoVLOXSEG3EI64_V_M1_MF4 = 3874, + RISCV_PseudoVLOXSEG3EI64_V_M1_MF4_MASK = 3875, + RISCV_PseudoVLOXSEG3EI64_V_M1_MF8 = 3876, + RISCV_PseudoVLOXSEG3EI64_V_M1_MF8_MASK = 3877, + RISCV_PseudoVLOXSEG3EI64_V_M2_M1 = 3878, + RISCV_PseudoVLOXSEG3EI64_V_M2_M1_MASK = 3879, + RISCV_PseudoVLOXSEG3EI64_V_M2_M2 = 3880, + RISCV_PseudoVLOXSEG3EI64_V_M2_M2_MASK = 3881, + RISCV_PseudoVLOXSEG3EI64_V_M2_MF2 = 3882, + RISCV_PseudoVLOXSEG3EI64_V_M2_MF2_MASK = 3883, + RISCV_PseudoVLOXSEG3EI64_V_M2_MF4 = 3884, + RISCV_PseudoVLOXSEG3EI64_V_M2_MF4_MASK = 3885, + RISCV_PseudoVLOXSEG3EI64_V_M4_M1 = 3886, + RISCV_PseudoVLOXSEG3EI64_V_M4_M1_MASK = 3887, + RISCV_PseudoVLOXSEG3EI64_V_M4_M2 = 3888, + RISCV_PseudoVLOXSEG3EI64_V_M4_M2_MASK = 3889, + RISCV_PseudoVLOXSEG3EI64_V_M4_MF2 = 3890, + RISCV_PseudoVLOXSEG3EI64_V_M4_MF2_MASK = 3891, + RISCV_PseudoVLOXSEG3EI64_V_M8_M1 = 3892, + RISCV_PseudoVLOXSEG3EI64_V_M8_M1_MASK = 3893, + RISCV_PseudoVLOXSEG3EI64_V_M8_M2 = 3894, + RISCV_PseudoVLOXSEG3EI64_V_M8_M2_MASK = 3895, + RISCV_PseudoVLOXSEG3EI8_V_M1_M1 = 3896, + RISCV_PseudoVLOXSEG3EI8_V_M1_M1_MASK = 3897, + RISCV_PseudoVLOXSEG3EI8_V_M1_M2 = 3898, + RISCV_PseudoVLOXSEG3EI8_V_M1_M2_MASK = 3899, + RISCV_PseudoVLOXSEG3EI8_V_M2_M2 = 3900, + RISCV_PseudoVLOXSEG3EI8_V_M2_M2_MASK = 3901, + RISCV_PseudoVLOXSEG3EI8_V_MF2_M1 = 3902, + RISCV_PseudoVLOXSEG3EI8_V_MF2_M1_MASK = 3903, + RISCV_PseudoVLOXSEG3EI8_V_MF2_M2 = 3904, + RISCV_PseudoVLOXSEG3EI8_V_MF2_M2_MASK = 3905, + RISCV_PseudoVLOXSEG3EI8_V_MF2_MF2 = 3906, + RISCV_PseudoVLOXSEG3EI8_V_MF2_MF2_MASK = 3907, + RISCV_PseudoVLOXSEG3EI8_V_MF4_M1 = 3908, + RISCV_PseudoVLOXSEG3EI8_V_MF4_M1_MASK = 3909, + RISCV_PseudoVLOXSEG3EI8_V_MF4_M2 = 3910, + RISCV_PseudoVLOXSEG3EI8_V_MF4_M2_MASK = 3911, + RISCV_PseudoVLOXSEG3EI8_V_MF4_MF2 = 3912, + RISCV_PseudoVLOXSEG3EI8_V_MF4_MF2_MASK = 3913, + RISCV_PseudoVLOXSEG3EI8_V_MF4_MF4 = 3914, + RISCV_PseudoVLOXSEG3EI8_V_MF4_MF4_MASK = 3915, + RISCV_PseudoVLOXSEG3EI8_V_MF8_M1 = 3916, + RISCV_PseudoVLOXSEG3EI8_V_MF8_M1_MASK = 3917, + RISCV_PseudoVLOXSEG3EI8_V_MF8_MF2 = 3918, + RISCV_PseudoVLOXSEG3EI8_V_MF8_MF2_MASK = 3919, + RISCV_PseudoVLOXSEG3EI8_V_MF8_MF4 = 3920, + RISCV_PseudoVLOXSEG3EI8_V_MF8_MF4_MASK = 3921, + RISCV_PseudoVLOXSEG3EI8_V_MF8_MF8 = 3922, + RISCV_PseudoVLOXSEG3EI8_V_MF8_MF8_MASK = 3923, + RISCV_PseudoVLOXSEG4EI16_V_M1_M1 = 3924, + RISCV_PseudoVLOXSEG4EI16_V_M1_M1_MASK = 3925, + RISCV_PseudoVLOXSEG4EI16_V_M1_M2 = 3926, + RISCV_PseudoVLOXSEG4EI16_V_M1_M2_MASK = 3927, + RISCV_PseudoVLOXSEG4EI16_V_M1_MF2 = 3928, + RISCV_PseudoVLOXSEG4EI16_V_M1_MF2_MASK = 3929, + RISCV_PseudoVLOXSEG4EI16_V_M2_M1 = 3930, + RISCV_PseudoVLOXSEG4EI16_V_M2_M1_MASK = 3931, + RISCV_PseudoVLOXSEG4EI16_V_M2_M2 = 3932, + RISCV_PseudoVLOXSEG4EI16_V_M2_M2_MASK = 3933, + RISCV_PseudoVLOXSEG4EI16_V_M4_M2 = 3934, + RISCV_PseudoVLOXSEG4EI16_V_M4_M2_MASK = 3935, + RISCV_PseudoVLOXSEG4EI16_V_MF2_M1 = 3936, + RISCV_PseudoVLOXSEG4EI16_V_MF2_M1_MASK = 3937, + RISCV_PseudoVLOXSEG4EI16_V_MF2_M2 = 3938, + RISCV_PseudoVLOXSEG4EI16_V_MF2_M2_MASK = 3939, + RISCV_PseudoVLOXSEG4EI16_V_MF2_MF2 = 3940, + RISCV_PseudoVLOXSEG4EI16_V_MF2_MF2_MASK = 3941, + RISCV_PseudoVLOXSEG4EI16_V_MF2_MF4 = 3942, + RISCV_PseudoVLOXSEG4EI16_V_MF2_MF4_MASK = 3943, + RISCV_PseudoVLOXSEG4EI16_V_MF4_M1 = 3944, + RISCV_PseudoVLOXSEG4EI16_V_MF4_M1_MASK = 3945, + RISCV_PseudoVLOXSEG4EI16_V_MF4_MF2 = 3946, + RISCV_PseudoVLOXSEG4EI16_V_MF4_MF2_MASK = 3947, + RISCV_PseudoVLOXSEG4EI16_V_MF4_MF4 = 3948, + RISCV_PseudoVLOXSEG4EI16_V_MF4_MF4_MASK = 3949, + RISCV_PseudoVLOXSEG4EI16_V_MF4_MF8 = 3950, + RISCV_PseudoVLOXSEG4EI16_V_MF4_MF8_MASK = 3951, + RISCV_PseudoVLOXSEG4EI32_V_M1_M1 = 3952, + RISCV_PseudoVLOXSEG4EI32_V_M1_M1_MASK = 3953, + RISCV_PseudoVLOXSEG4EI32_V_M1_M2 = 3954, + RISCV_PseudoVLOXSEG4EI32_V_M1_M2_MASK = 3955, + RISCV_PseudoVLOXSEG4EI32_V_M1_MF2 = 3956, + RISCV_PseudoVLOXSEG4EI32_V_M1_MF2_MASK = 3957, + RISCV_PseudoVLOXSEG4EI32_V_M1_MF4 = 3958, + RISCV_PseudoVLOXSEG4EI32_V_M1_MF4_MASK = 3959, + RISCV_PseudoVLOXSEG4EI32_V_M2_M1 = 3960, + RISCV_PseudoVLOXSEG4EI32_V_M2_M1_MASK = 3961, + RISCV_PseudoVLOXSEG4EI32_V_M2_M2 = 3962, + RISCV_PseudoVLOXSEG4EI32_V_M2_M2_MASK = 3963, + RISCV_PseudoVLOXSEG4EI32_V_M2_MF2 = 3964, + RISCV_PseudoVLOXSEG4EI32_V_M2_MF2_MASK = 3965, + RISCV_PseudoVLOXSEG4EI32_V_M4_M1 = 3966, + RISCV_PseudoVLOXSEG4EI32_V_M4_M1_MASK = 3967, + RISCV_PseudoVLOXSEG4EI32_V_M4_M2 = 3968, + RISCV_PseudoVLOXSEG4EI32_V_M4_M2_MASK = 3969, + RISCV_PseudoVLOXSEG4EI32_V_M8_M2 = 3970, + RISCV_PseudoVLOXSEG4EI32_V_M8_M2_MASK = 3971, + RISCV_PseudoVLOXSEG4EI32_V_MF2_M1 = 3972, + RISCV_PseudoVLOXSEG4EI32_V_MF2_M1_MASK = 3973, + RISCV_PseudoVLOXSEG4EI32_V_MF2_MF2 = 3974, + RISCV_PseudoVLOXSEG4EI32_V_MF2_MF2_MASK = 3975, + RISCV_PseudoVLOXSEG4EI32_V_MF2_MF4 = 3976, + RISCV_PseudoVLOXSEG4EI32_V_MF2_MF4_MASK = 3977, + RISCV_PseudoVLOXSEG4EI32_V_MF2_MF8 = 3978, + RISCV_PseudoVLOXSEG4EI32_V_MF2_MF8_MASK = 3979, + RISCV_PseudoVLOXSEG4EI64_V_M1_M1 = 3980, + RISCV_PseudoVLOXSEG4EI64_V_M1_M1_MASK = 3981, + RISCV_PseudoVLOXSEG4EI64_V_M1_MF2 = 3982, + RISCV_PseudoVLOXSEG4EI64_V_M1_MF2_MASK = 3983, + RISCV_PseudoVLOXSEG4EI64_V_M1_MF4 = 3984, + RISCV_PseudoVLOXSEG4EI64_V_M1_MF4_MASK = 3985, + RISCV_PseudoVLOXSEG4EI64_V_M1_MF8 = 3986, + RISCV_PseudoVLOXSEG4EI64_V_M1_MF8_MASK = 3987, + RISCV_PseudoVLOXSEG4EI64_V_M2_M1 = 3988, + RISCV_PseudoVLOXSEG4EI64_V_M2_M1_MASK = 3989, + RISCV_PseudoVLOXSEG4EI64_V_M2_M2 = 3990, + RISCV_PseudoVLOXSEG4EI64_V_M2_M2_MASK = 3991, + RISCV_PseudoVLOXSEG4EI64_V_M2_MF2 = 3992, + RISCV_PseudoVLOXSEG4EI64_V_M2_MF2_MASK = 3993, + RISCV_PseudoVLOXSEG4EI64_V_M2_MF4 = 3994, + RISCV_PseudoVLOXSEG4EI64_V_M2_MF4_MASK = 3995, + RISCV_PseudoVLOXSEG4EI64_V_M4_M1 = 3996, + RISCV_PseudoVLOXSEG4EI64_V_M4_M1_MASK = 3997, + RISCV_PseudoVLOXSEG4EI64_V_M4_M2 = 3998, + RISCV_PseudoVLOXSEG4EI64_V_M4_M2_MASK = 3999, + RISCV_PseudoVLOXSEG4EI64_V_M4_MF2 = 4000, + RISCV_PseudoVLOXSEG4EI64_V_M4_MF2_MASK = 4001, + RISCV_PseudoVLOXSEG4EI64_V_M8_M1 = 4002, + RISCV_PseudoVLOXSEG4EI64_V_M8_M1_MASK = 4003, + RISCV_PseudoVLOXSEG4EI64_V_M8_M2 = 4004, + RISCV_PseudoVLOXSEG4EI64_V_M8_M2_MASK = 4005, + RISCV_PseudoVLOXSEG4EI8_V_M1_M1 = 4006, + RISCV_PseudoVLOXSEG4EI8_V_M1_M1_MASK = 4007, + RISCV_PseudoVLOXSEG4EI8_V_M1_M2 = 4008, + RISCV_PseudoVLOXSEG4EI8_V_M1_M2_MASK = 4009, + RISCV_PseudoVLOXSEG4EI8_V_M2_M2 = 4010, + RISCV_PseudoVLOXSEG4EI8_V_M2_M2_MASK = 4011, + RISCV_PseudoVLOXSEG4EI8_V_MF2_M1 = 4012, + RISCV_PseudoVLOXSEG4EI8_V_MF2_M1_MASK = 4013, + RISCV_PseudoVLOXSEG4EI8_V_MF2_M2 = 4014, + RISCV_PseudoVLOXSEG4EI8_V_MF2_M2_MASK = 4015, + RISCV_PseudoVLOXSEG4EI8_V_MF2_MF2 = 4016, + RISCV_PseudoVLOXSEG4EI8_V_MF2_MF2_MASK = 4017, + RISCV_PseudoVLOXSEG4EI8_V_MF4_M1 = 4018, + RISCV_PseudoVLOXSEG4EI8_V_MF4_M1_MASK = 4019, + RISCV_PseudoVLOXSEG4EI8_V_MF4_M2 = 4020, + RISCV_PseudoVLOXSEG4EI8_V_MF4_M2_MASK = 4021, + RISCV_PseudoVLOXSEG4EI8_V_MF4_MF2 = 4022, + RISCV_PseudoVLOXSEG4EI8_V_MF4_MF2_MASK = 4023, + RISCV_PseudoVLOXSEG4EI8_V_MF4_MF4 = 4024, + RISCV_PseudoVLOXSEG4EI8_V_MF4_MF4_MASK = 4025, + RISCV_PseudoVLOXSEG4EI8_V_MF8_M1 = 4026, + RISCV_PseudoVLOXSEG4EI8_V_MF8_M1_MASK = 4027, + RISCV_PseudoVLOXSEG4EI8_V_MF8_MF2 = 4028, + RISCV_PseudoVLOXSEG4EI8_V_MF8_MF2_MASK = 4029, + RISCV_PseudoVLOXSEG4EI8_V_MF8_MF4 = 4030, + RISCV_PseudoVLOXSEG4EI8_V_MF8_MF4_MASK = 4031, + RISCV_PseudoVLOXSEG4EI8_V_MF8_MF8 = 4032, + RISCV_PseudoVLOXSEG4EI8_V_MF8_MF8_MASK = 4033, + RISCV_PseudoVLOXSEG5EI16_V_M1_M1 = 4034, + RISCV_PseudoVLOXSEG5EI16_V_M1_M1_MASK = 4035, + RISCV_PseudoVLOXSEG5EI16_V_M1_MF2 = 4036, + RISCV_PseudoVLOXSEG5EI16_V_M1_MF2_MASK = 4037, + RISCV_PseudoVLOXSEG5EI16_V_M2_M1 = 4038, + RISCV_PseudoVLOXSEG5EI16_V_M2_M1_MASK = 4039, + RISCV_PseudoVLOXSEG5EI16_V_MF2_M1 = 4040, + RISCV_PseudoVLOXSEG5EI16_V_MF2_M1_MASK = 4041, + RISCV_PseudoVLOXSEG5EI16_V_MF2_MF2 = 4042, + RISCV_PseudoVLOXSEG5EI16_V_MF2_MF2_MASK = 4043, + RISCV_PseudoVLOXSEG5EI16_V_MF2_MF4 = 4044, + RISCV_PseudoVLOXSEG5EI16_V_MF2_MF4_MASK = 4045, + RISCV_PseudoVLOXSEG5EI16_V_MF4_M1 = 4046, + RISCV_PseudoVLOXSEG5EI16_V_MF4_M1_MASK = 4047, + RISCV_PseudoVLOXSEG5EI16_V_MF4_MF2 = 4048, + RISCV_PseudoVLOXSEG5EI16_V_MF4_MF2_MASK = 4049, + RISCV_PseudoVLOXSEG5EI16_V_MF4_MF4 = 4050, + RISCV_PseudoVLOXSEG5EI16_V_MF4_MF4_MASK = 4051, + RISCV_PseudoVLOXSEG5EI16_V_MF4_MF8 = 4052, + RISCV_PseudoVLOXSEG5EI16_V_MF4_MF8_MASK = 4053, + RISCV_PseudoVLOXSEG5EI32_V_M1_M1 = 4054, + RISCV_PseudoVLOXSEG5EI32_V_M1_M1_MASK = 4055, + RISCV_PseudoVLOXSEG5EI32_V_M1_MF2 = 4056, + RISCV_PseudoVLOXSEG5EI32_V_M1_MF2_MASK = 4057, + RISCV_PseudoVLOXSEG5EI32_V_M1_MF4 = 4058, + RISCV_PseudoVLOXSEG5EI32_V_M1_MF4_MASK = 4059, + RISCV_PseudoVLOXSEG5EI32_V_M2_M1 = 4060, + RISCV_PseudoVLOXSEG5EI32_V_M2_M1_MASK = 4061, + RISCV_PseudoVLOXSEG5EI32_V_M2_MF2 = 4062, + RISCV_PseudoVLOXSEG5EI32_V_M2_MF2_MASK = 4063, + RISCV_PseudoVLOXSEG5EI32_V_M4_M1 = 4064, + RISCV_PseudoVLOXSEG5EI32_V_M4_M1_MASK = 4065, + RISCV_PseudoVLOXSEG5EI32_V_MF2_M1 = 4066, + RISCV_PseudoVLOXSEG5EI32_V_MF2_M1_MASK = 4067, + RISCV_PseudoVLOXSEG5EI32_V_MF2_MF2 = 4068, + RISCV_PseudoVLOXSEG5EI32_V_MF2_MF2_MASK = 4069, + RISCV_PseudoVLOXSEG5EI32_V_MF2_MF4 = 4070, + RISCV_PseudoVLOXSEG5EI32_V_MF2_MF4_MASK = 4071, + RISCV_PseudoVLOXSEG5EI32_V_MF2_MF8 = 4072, + RISCV_PseudoVLOXSEG5EI32_V_MF2_MF8_MASK = 4073, + RISCV_PseudoVLOXSEG5EI64_V_M1_M1 = 4074, + RISCV_PseudoVLOXSEG5EI64_V_M1_M1_MASK = 4075, + RISCV_PseudoVLOXSEG5EI64_V_M1_MF2 = 4076, + RISCV_PseudoVLOXSEG5EI64_V_M1_MF2_MASK = 4077, + RISCV_PseudoVLOXSEG5EI64_V_M1_MF4 = 4078, + RISCV_PseudoVLOXSEG5EI64_V_M1_MF4_MASK = 4079, + RISCV_PseudoVLOXSEG5EI64_V_M1_MF8 = 4080, + RISCV_PseudoVLOXSEG5EI64_V_M1_MF8_MASK = 4081, + RISCV_PseudoVLOXSEG5EI64_V_M2_M1 = 4082, + RISCV_PseudoVLOXSEG5EI64_V_M2_M1_MASK = 4083, + RISCV_PseudoVLOXSEG5EI64_V_M2_MF2 = 4084, + RISCV_PseudoVLOXSEG5EI64_V_M2_MF2_MASK = 4085, + RISCV_PseudoVLOXSEG5EI64_V_M2_MF4 = 4086, + RISCV_PseudoVLOXSEG5EI64_V_M2_MF4_MASK = 4087, + RISCV_PseudoVLOXSEG5EI64_V_M4_M1 = 4088, + RISCV_PseudoVLOXSEG5EI64_V_M4_M1_MASK = 4089, + RISCV_PseudoVLOXSEG5EI64_V_M4_MF2 = 4090, + RISCV_PseudoVLOXSEG5EI64_V_M4_MF2_MASK = 4091, + RISCV_PseudoVLOXSEG5EI64_V_M8_M1 = 4092, + RISCV_PseudoVLOXSEG5EI64_V_M8_M1_MASK = 4093, + RISCV_PseudoVLOXSEG5EI8_V_M1_M1 = 4094, + RISCV_PseudoVLOXSEG5EI8_V_M1_M1_MASK = 4095, + RISCV_PseudoVLOXSEG5EI8_V_MF2_M1 = 4096, + RISCV_PseudoVLOXSEG5EI8_V_MF2_M1_MASK = 4097, + RISCV_PseudoVLOXSEG5EI8_V_MF2_MF2 = 4098, + RISCV_PseudoVLOXSEG5EI8_V_MF2_MF2_MASK = 4099, + RISCV_PseudoVLOXSEG5EI8_V_MF4_M1 = 4100, + RISCV_PseudoVLOXSEG5EI8_V_MF4_M1_MASK = 4101, + RISCV_PseudoVLOXSEG5EI8_V_MF4_MF2 = 4102, + RISCV_PseudoVLOXSEG5EI8_V_MF4_MF2_MASK = 4103, + RISCV_PseudoVLOXSEG5EI8_V_MF4_MF4 = 4104, + RISCV_PseudoVLOXSEG5EI8_V_MF4_MF4_MASK = 4105, + RISCV_PseudoVLOXSEG5EI8_V_MF8_M1 = 4106, + RISCV_PseudoVLOXSEG5EI8_V_MF8_M1_MASK = 4107, + RISCV_PseudoVLOXSEG5EI8_V_MF8_MF2 = 4108, + RISCV_PseudoVLOXSEG5EI8_V_MF8_MF2_MASK = 4109, + RISCV_PseudoVLOXSEG5EI8_V_MF8_MF4 = 4110, + RISCV_PseudoVLOXSEG5EI8_V_MF8_MF4_MASK = 4111, + RISCV_PseudoVLOXSEG5EI8_V_MF8_MF8 = 4112, + RISCV_PseudoVLOXSEG5EI8_V_MF8_MF8_MASK = 4113, + RISCV_PseudoVLOXSEG6EI16_V_M1_M1 = 4114, + RISCV_PseudoVLOXSEG6EI16_V_M1_M1_MASK = 4115, + RISCV_PseudoVLOXSEG6EI16_V_M1_MF2 = 4116, + RISCV_PseudoVLOXSEG6EI16_V_M1_MF2_MASK = 4117, + RISCV_PseudoVLOXSEG6EI16_V_M2_M1 = 4118, + RISCV_PseudoVLOXSEG6EI16_V_M2_M1_MASK = 4119, + RISCV_PseudoVLOXSEG6EI16_V_MF2_M1 = 4120, + RISCV_PseudoVLOXSEG6EI16_V_MF2_M1_MASK = 4121, + RISCV_PseudoVLOXSEG6EI16_V_MF2_MF2 = 4122, + RISCV_PseudoVLOXSEG6EI16_V_MF2_MF2_MASK = 4123, + RISCV_PseudoVLOXSEG6EI16_V_MF2_MF4 = 4124, + RISCV_PseudoVLOXSEG6EI16_V_MF2_MF4_MASK = 4125, + RISCV_PseudoVLOXSEG6EI16_V_MF4_M1 = 4126, + RISCV_PseudoVLOXSEG6EI16_V_MF4_M1_MASK = 4127, + RISCV_PseudoVLOXSEG6EI16_V_MF4_MF2 = 4128, + RISCV_PseudoVLOXSEG6EI16_V_MF4_MF2_MASK = 4129, + RISCV_PseudoVLOXSEG6EI16_V_MF4_MF4 = 4130, + RISCV_PseudoVLOXSEG6EI16_V_MF4_MF4_MASK = 4131, + RISCV_PseudoVLOXSEG6EI16_V_MF4_MF8 = 4132, + RISCV_PseudoVLOXSEG6EI16_V_MF4_MF8_MASK = 4133, + RISCV_PseudoVLOXSEG6EI32_V_M1_M1 = 4134, + RISCV_PseudoVLOXSEG6EI32_V_M1_M1_MASK = 4135, + RISCV_PseudoVLOXSEG6EI32_V_M1_MF2 = 4136, + RISCV_PseudoVLOXSEG6EI32_V_M1_MF2_MASK = 4137, + RISCV_PseudoVLOXSEG6EI32_V_M1_MF4 = 4138, + RISCV_PseudoVLOXSEG6EI32_V_M1_MF4_MASK = 4139, + RISCV_PseudoVLOXSEG6EI32_V_M2_M1 = 4140, + RISCV_PseudoVLOXSEG6EI32_V_M2_M1_MASK = 4141, + RISCV_PseudoVLOXSEG6EI32_V_M2_MF2 = 4142, + RISCV_PseudoVLOXSEG6EI32_V_M2_MF2_MASK = 4143, + RISCV_PseudoVLOXSEG6EI32_V_M4_M1 = 4144, + RISCV_PseudoVLOXSEG6EI32_V_M4_M1_MASK = 4145, + RISCV_PseudoVLOXSEG6EI32_V_MF2_M1 = 4146, + RISCV_PseudoVLOXSEG6EI32_V_MF2_M1_MASK = 4147, + RISCV_PseudoVLOXSEG6EI32_V_MF2_MF2 = 4148, + RISCV_PseudoVLOXSEG6EI32_V_MF2_MF2_MASK = 4149, + RISCV_PseudoVLOXSEG6EI32_V_MF2_MF4 = 4150, + RISCV_PseudoVLOXSEG6EI32_V_MF2_MF4_MASK = 4151, + RISCV_PseudoVLOXSEG6EI32_V_MF2_MF8 = 4152, + RISCV_PseudoVLOXSEG6EI32_V_MF2_MF8_MASK = 4153, + RISCV_PseudoVLOXSEG6EI64_V_M1_M1 = 4154, + RISCV_PseudoVLOXSEG6EI64_V_M1_M1_MASK = 4155, + RISCV_PseudoVLOXSEG6EI64_V_M1_MF2 = 4156, + RISCV_PseudoVLOXSEG6EI64_V_M1_MF2_MASK = 4157, + RISCV_PseudoVLOXSEG6EI64_V_M1_MF4 = 4158, + RISCV_PseudoVLOXSEG6EI64_V_M1_MF4_MASK = 4159, + RISCV_PseudoVLOXSEG6EI64_V_M1_MF8 = 4160, + RISCV_PseudoVLOXSEG6EI64_V_M1_MF8_MASK = 4161, + RISCV_PseudoVLOXSEG6EI64_V_M2_M1 = 4162, + RISCV_PseudoVLOXSEG6EI64_V_M2_M1_MASK = 4163, + RISCV_PseudoVLOXSEG6EI64_V_M2_MF2 = 4164, + RISCV_PseudoVLOXSEG6EI64_V_M2_MF2_MASK = 4165, + RISCV_PseudoVLOXSEG6EI64_V_M2_MF4 = 4166, + RISCV_PseudoVLOXSEG6EI64_V_M2_MF4_MASK = 4167, + RISCV_PseudoVLOXSEG6EI64_V_M4_M1 = 4168, + RISCV_PseudoVLOXSEG6EI64_V_M4_M1_MASK = 4169, + RISCV_PseudoVLOXSEG6EI64_V_M4_MF2 = 4170, + RISCV_PseudoVLOXSEG6EI64_V_M4_MF2_MASK = 4171, + RISCV_PseudoVLOXSEG6EI64_V_M8_M1 = 4172, + RISCV_PseudoVLOXSEG6EI64_V_M8_M1_MASK = 4173, + RISCV_PseudoVLOXSEG6EI8_V_M1_M1 = 4174, + RISCV_PseudoVLOXSEG6EI8_V_M1_M1_MASK = 4175, + RISCV_PseudoVLOXSEG6EI8_V_MF2_M1 = 4176, + RISCV_PseudoVLOXSEG6EI8_V_MF2_M1_MASK = 4177, + RISCV_PseudoVLOXSEG6EI8_V_MF2_MF2 = 4178, + RISCV_PseudoVLOXSEG6EI8_V_MF2_MF2_MASK = 4179, + RISCV_PseudoVLOXSEG6EI8_V_MF4_M1 = 4180, + RISCV_PseudoVLOXSEG6EI8_V_MF4_M1_MASK = 4181, + RISCV_PseudoVLOXSEG6EI8_V_MF4_MF2 = 4182, + RISCV_PseudoVLOXSEG6EI8_V_MF4_MF2_MASK = 4183, + RISCV_PseudoVLOXSEG6EI8_V_MF4_MF4 = 4184, + RISCV_PseudoVLOXSEG6EI8_V_MF4_MF4_MASK = 4185, + RISCV_PseudoVLOXSEG6EI8_V_MF8_M1 = 4186, + RISCV_PseudoVLOXSEG6EI8_V_MF8_M1_MASK = 4187, + RISCV_PseudoVLOXSEG6EI8_V_MF8_MF2 = 4188, + RISCV_PseudoVLOXSEG6EI8_V_MF8_MF2_MASK = 4189, + RISCV_PseudoVLOXSEG6EI8_V_MF8_MF4 = 4190, + RISCV_PseudoVLOXSEG6EI8_V_MF8_MF4_MASK = 4191, + RISCV_PseudoVLOXSEG6EI8_V_MF8_MF8 = 4192, + RISCV_PseudoVLOXSEG6EI8_V_MF8_MF8_MASK = 4193, + RISCV_PseudoVLOXSEG7EI16_V_M1_M1 = 4194, + RISCV_PseudoVLOXSEG7EI16_V_M1_M1_MASK = 4195, + RISCV_PseudoVLOXSEG7EI16_V_M1_MF2 = 4196, + RISCV_PseudoVLOXSEG7EI16_V_M1_MF2_MASK = 4197, + RISCV_PseudoVLOXSEG7EI16_V_M2_M1 = 4198, + RISCV_PseudoVLOXSEG7EI16_V_M2_M1_MASK = 4199, + RISCV_PseudoVLOXSEG7EI16_V_MF2_M1 = 4200, + RISCV_PseudoVLOXSEG7EI16_V_MF2_M1_MASK = 4201, + RISCV_PseudoVLOXSEG7EI16_V_MF2_MF2 = 4202, + RISCV_PseudoVLOXSEG7EI16_V_MF2_MF2_MASK = 4203, + RISCV_PseudoVLOXSEG7EI16_V_MF2_MF4 = 4204, + RISCV_PseudoVLOXSEG7EI16_V_MF2_MF4_MASK = 4205, + RISCV_PseudoVLOXSEG7EI16_V_MF4_M1 = 4206, + RISCV_PseudoVLOXSEG7EI16_V_MF4_M1_MASK = 4207, + RISCV_PseudoVLOXSEG7EI16_V_MF4_MF2 = 4208, + RISCV_PseudoVLOXSEG7EI16_V_MF4_MF2_MASK = 4209, + RISCV_PseudoVLOXSEG7EI16_V_MF4_MF4 = 4210, + RISCV_PseudoVLOXSEG7EI16_V_MF4_MF4_MASK = 4211, + RISCV_PseudoVLOXSEG7EI16_V_MF4_MF8 = 4212, + RISCV_PseudoVLOXSEG7EI16_V_MF4_MF8_MASK = 4213, + RISCV_PseudoVLOXSEG7EI32_V_M1_M1 = 4214, + RISCV_PseudoVLOXSEG7EI32_V_M1_M1_MASK = 4215, + RISCV_PseudoVLOXSEG7EI32_V_M1_MF2 = 4216, + RISCV_PseudoVLOXSEG7EI32_V_M1_MF2_MASK = 4217, + RISCV_PseudoVLOXSEG7EI32_V_M1_MF4 = 4218, + RISCV_PseudoVLOXSEG7EI32_V_M1_MF4_MASK = 4219, + RISCV_PseudoVLOXSEG7EI32_V_M2_M1 = 4220, + RISCV_PseudoVLOXSEG7EI32_V_M2_M1_MASK = 4221, + RISCV_PseudoVLOXSEG7EI32_V_M2_MF2 = 4222, + RISCV_PseudoVLOXSEG7EI32_V_M2_MF2_MASK = 4223, + RISCV_PseudoVLOXSEG7EI32_V_M4_M1 = 4224, + RISCV_PseudoVLOXSEG7EI32_V_M4_M1_MASK = 4225, + RISCV_PseudoVLOXSEG7EI32_V_MF2_M1 = 4226, + RISCV_PseudoVLOXSEG7EI32_V_MF2_M1_MASK = 4227, + RISCV_PseudoVLOXSEG7EI32_V_MF2_MF2 = 4228, + RISCV_PseudoVLOXSEG7EI32_V_MF2_MF2_MASK = 4229, + RISCV_PseudoVLOXSEG7EI32_V_MF2_MF4 = 4230, + RISCV_PseudoVLOXSEG7EI32_V_MF2_MF4_MASK = 4231, + RISCV_PseudoVLOXSEG7EI32_V_MF2_MF8 = 4232, + RISCV_PseudoVLOXSEG7EI32_V_MF2_MF8_MASK = 4233, + RISCV_PseudoVLOXSEG7EI64_V_M1_M1 = 4234, + RISCV_PseudoVLOXSEG7EI64_V_M1_M1_MASK = 4235, + RISCV_PseudoVLOXSEG7EI64_V_M1_MF2 = 4236, + RISCV_PseudoVLOXSEG7EI64_V_M1_MF2_MASK = 4237, + RISCV_PseudoVLOXSEG7EI64_V_M1_MF4 = 4238, + RISCV_PseudoVLOXSEG7EI64_V_M1_MF4_MASK = 4239, + RISCV_PseudoVLOXSEG7EI64_V_M1_MF8 = 4240, + RISCV_PseudoVLOXSEG7EI64_V_M1_MF8_MASK = 4241, + RISCV_PseudoVLOXSEG7EI64_V_M2_M1 = 4242, + RISCV_PseudoVLOXSEG7EI64_V_M2_M1_MASK = 4243, + RISCV_PseudoVLOXSEG7EI64_V_M2_MF2 = 4244, + RISCV_PseudoVLOXSEG7EI64_V_M2_MF2_MASK = 4245, + RISCV_PseudoVLOXSEG7EI64_V_M2_MF4 = 4246, + RISCV_PseudoVLOXSEG7EI64_V_M2_MF4_MASK = 4247, + RISCV_PseudoVLOXSEG7EI64_V_M4_M1 = 4248, + RISCV_PseudoVLOXSEG7EI64_V_M4_M1_MASK = 4249, + RISCV_PseudoVLOXSEG7EI64_V_M4_MF2 = 4250, + RISCV_PseudoVLOXSEG7EI64_V_M4_MF2_MASK = 4251, + RISCV_PseudoVLOXSEG7EI64_V_M8_M1 = 4252, + RISCV_PseudoVLOXSEG7EI64_V_M8_M1_MASK = 4253, + RISCV_PseudoVLOXSEG7EI8_V_M1_M1 = 4254, + RISCV_PseudoVLOXSEG7EI8_V_M1_M1_MASK = 4255, + RISCV_PseudoVLOXSEG7EI8_V_MF2_M1 = 4256, + RISCV_PseudoVLOXSEG7EI8_V_MF2_M1_MASK = 4257, + RISCV_PseudoVLOXSEG7EI8_V_MF2_MF2 = 4258, + RISCV_PseudoVLOXSEG7EI8_V_MF2_MF2_MASK = 4259, + RISCV_PseudoVLOXSEG7EI8_V_MF4_M1 = 4260, + RISCV_PseudoVLOXSEG7EI8_V_MF4_M1_MASK = 4261, + RISCV_PseudoVLOXSEG7EI8_V_MF4_MF2 = 4262, + RISCV_PseudoVLOXSEG7EI8_V_MF4_MF2_MASK = 4263, + RISCV_PseudoVLOXSEG7EI8_V_MF4_MF4 = 4264, + RISCV_PseudoVLOXSEG7EI8_V_MF4_MF4_MASK = 4265, + RISCV_PseudoVLOXSEG7EI8_V_MF8_M1 = 4266, + RISCV_PseudoVLOXSEG7EI8_V_MF8_M1_MASK = 4267, + RISCV_PseudoVLOXSEG7EI8_V_MF8_MF2 = 4268, + RISCV_PseudoVLOXSEG7EI8_V_MF8_MF2_MASK = 4269, + RISCV_PseudoVLOXSEG7EI8_V_MF8_MF4 = 4270, + RISCV_PseudoVLOXSEG7EI8_V_MF8_MF4_MASK = 4271, + RISCV_PseudoVLOXSEG7EI8_V_MF8_MF8 = 4272, + RISCV_PseudoVLOXSEG7EI8_V_MF8_MF8_MASK = 4273, + RISCV_PseudoVLOXSEG8EI16_V_M1_M1 = 4274, + RISCV_PseudoVLOXSEG8EI16_V_M1_M1_MASK = 4275, + RISCV_PseudoVLOXSEG8EI16_V_M1_MF2 = 4276, + RISCV_PseudoVLOXSEG8EI16_V_M1_MF2_MASK = 4277, + RISCV_PseudoVLOXSEG8EI16_V_M2_M1 = 4278, + RISCV_PseudoVLOXSEG8EI16_V_M2_M1_MASK = 4279, + RISCV_PseudoVLOXSEG8EI16_V_MF2_M1 = 4280, + RISCV_PseudoVLOXSEG8EI16_V_MF2_M1_MASK = 4281, + RISCV_PseudoVLOXSEG8EI16_V_MF2_MF2 = 4282, + RISCV_PseudoVLOXSEG8EI16_V_MF2_MF2_MASK = 4283, + RISCV_PseudoVLOXSEG8EI16_V_MF2_MF4 = 4284, + RISCV_PseudoVLOXSEG8EI16_V_MF2_MF4_MASK = 4285, + RISCV_PseudoVLOXSEG8EI16_V_MF4_M1 = 4286, + RISCV_PseudoVLOXSEG8EI16_V_MF4_M1_MASK = 4287, + RISCV_PseudoVLOXSEG8EI16_V_MF4_MF2 = 4288, + RISCV_PseudoVLOXSEG8EI16_V_MF4_MF2_MASK = 4289, + RISCV_PseudoVLOXSEG8EI16_V_MF4_MF4 = 4290, + RISCV_PseudoVLOXSEG8EI16_V_MF4_MF4_MASK = 4291, + RISCV_PseudoVLOXSEG8EI16_V_MF4_MF8 = 4292, + RISCV_PseudoVLOXSEG8EI16_V_MF4_MF8_MASK = 4293, + RISCV_PseudoVLOXSEG8EI32_V_M1_M1 = 4294, + RISCV_PseudoVLOXSEG8EI32_V_M1_M1_MASK = 4295, + RISCV_PseudoVLOXSEG8EI32_V_M1_MF2 = 4296, + RISCV_PseudoVLOXSEG8EI32_V_M1_MF2_MASK = 4297, + RISCV_PseudoVLOXSEG8EI32_V_M1_MF4 = 4298, + RISCV_PseudoVLOXSEG8EI32_V_M1_MF4_MASK = 4299, + RISCV_PseudoVLOXSEG8EI32_V_M2_M1 = 4300, + RISCV_PseudoVLOXSEG8EI32_V_M2_M1_MASK = 4301, + RISCV_PseudoVLOXSEG8EI32_V_M2_MF2 = 4302, + RISCV_PseudoVLOXSEG8EI32_V_M2_MF2_MASK = 4303, + RISCV_PseudoVLOXSEG8EI32_V_M4_M1 = 4304, + RISCV_PseudoVLOXSEG8EI32_V_M4_M1_MASK = 4305, + RISCV_PseudoVLOXSEG8EI32_V_MF2_M1 = 4306, + RISCV_PseudoVLOXSEG8EI32_V_MF2_M1_MASK = 4307, + RISCV_PseudoVLOXSEG8EI32_V_MF2_MF2 = 4308, + RISCV_PseudoVLOXSEG8EI32_V_MF2_MF2_MASK = 4309, + RISCV_PseudoVLOXSEG8EI32_V_MF2_MF4 = 4310, + RISCV_PseudoVLOXSEG8EI32_V_MF2_MF4_MASK = 4311, + RISCV_PseudoVLOXSEG8EI32_V_MF2_MF8 = 4312, + RISCV_PseudoVLOXSEG8EI32_V_MF2_MF8_MASK = 4313, + RISCV_PseudoVLOXSEG8EI64_V_M1_M1 = 4314, + RISCV_PseudoVLOXSEG8EI64_V_M1_M1_MASK = 4315, + RISCV_PseudoVLOXSEG8EI64_V_M1_MF2 = 4316, + RISCV_PseudoVLOXSEG8EI64_V_M1_MF2_MASK = 4317, + RISCV_PseudoVLOXSEG8EI64_V_M1_MF4 = 4318, + RISCV_PseudoVLOXSEG8EI64_V_M1_MF4_MASK = 4319, + RISCV_PseudoVLOXSEG8EI64_V_M1_MF8 = 4320, + RISCV_PseudoVLOXSEG8EI64_V_M1_MF8_MASK = 4321, + RISCV_PseudoVLOXSEG8EI64_V_M2_M1 = 4322, + RISCV_PseudoVLOXSEG8EI64_V_M2_M1_MASK = 4323, + RISCV_PseudoVLOXSEG8EI64_V_M2_MF2 = 4324, + RISCV_PseudoVLOXSEG8EI64_V_M2_MF2_MASK = 4325, + RISCV_PseudoVLOXSEG8EI64_V_M2_MF4 = 4326, + RISCV_PseudoVLOXSEG8EI64_V_M2_MF4_MASK = 4327, + RISCV_PseudoVLOXSEG8EI64_V_M4_M1 = 4328, + RISCV_PseudoVLOXSEG8EI64_V_M4_M1_MASK = 4329, + RISCV_PseudoVLOXSEG8EI64_V_M4_MF2 = 4330, + RISCV_PseudoVLOXSEG8EI64_V_M4_MF2_MASK = 4331, + RISCV_PseudoVLOXSEG8EI64_V_M8_M1 = 4332, + RISCV_PseudoVLOXSEG8EI64_V_M8_M1_MASK = 4333, + RISCV_PseudoVLOXSEG8EI8_V_M1_M1 = 4334, + RISCV_PseudoVLOXSEG8EI8_V_M1_M1_MASK = 4335, + RISCV_PseudoVLOXSEG8EI8_V_MF2_M1 = 4336, + RISCV_PseudoVLOXSEG8EI8_V_MF2_M1_MASK = 4337, + RISCV_PseudoVLOXSEG8EI8_V_MF2_MF2 = 4338, + RISCV_PseudoVLOXSEG8EI8_V_MF2_MF2_MASK = 4339, + RISCV_PseudoVLOXSEG8EI8_V_MF4_M1 = 4340, + RISCV_PseudoVLOXSEG8EI8_V_MF4_M1_MASK = 4341, + RISCV_PseudoVLOXSEG8EI8_V_MF4_MF2 = 4342, + RISCV_PseudoVLOXSEG8EI8_V_MF4_MF2_MASK = 4343, + RISCV_PseudoVLOXSEG8EI8_V_MF4_MF4 = 4344, + RISCV_PseudoVLOXSEG8EI8_V_MF4_MF4_MASK = 4345, + RISCV_PseudoVLOXSEG8EI8_V_MF8_M1 = 4346, + RISCV_PseudoVLOXSEG8EI8_V_MF8_M1_MASK = 4347, + RISCV_PseudoVLOXSEG8EI8_V_MF8_MF2 = 4348, + RISCV_PseudoVLOXSEG8EI8_V_MF8_MF2_MASK = 4349, + RISCV_PseudoVLOXSEG8EI8_V_MF8_MF4 = 4350, + RISCV_PseudoVLOXSEG8EI8_V_MF8_MF4_MASK = 4351, + RISCV_PseudoVLOXSEG8EI8_V_MF8_MF8 = 4352, + RISCV_PseudoVLOXSEG8EI8_V_MF8_MF8_MASK = 4353, + RISCV_PseudoVLSE16_V_M1 = 4354, + RISCV_PseudoVLSE16_V_M1_MASK = 4355, + RISCV_PseudoVLSE16_V_M2 = 4356, + RISCV_PseudoVLSE16_V_M2_MASK = 4357, + RISCV_PseudoVLSE16_V_M4 = 4358, + RISCV_PseudoVLSE16_V_M4_MASK = 4359, + RISCV_PseudoVLSE16_V_M8 = 4360, + RISCV_PseudoVLSE16_V_M8_MASK = 4361, + RISCV_PseudoVLSE16_V_MF2 = 4362, + RISCV_PseudoVLSE16_V_MF2_MASK = 4363, + RISCV_PseudoVLSE16_V_MF4 = 4364, + RISCV_PseudoVLSE16_V_MF4_MASK = 4365, + RISCV_PseudoVLSE32_V_M1 = 4366, + RISCV_PseudoVLSE32_V_M1_MASK = 4367, + RISCV_PseudoVLSE32_V_M2 = 4368, + RISCV_PseudoVLSE32_V_M2_MASK = 4369, + RISCV_PseudoVLSE32_V_M4 = 4370, + RISCV_PseudoVLSE32_V_M4_MASK = 4371, + RISCV_PseudoVLSE32_V_M8 = 4372, + RISCV_PseudoVLSE32_V_M8_MASK = 4373, + RISCV_PseudoVLSE32_V_MF2 = 4374, + RISCV_PseudoVLSE32_V_MF2_MASK = 4375, + RISCV_PseudoVLSE64_V_M1 = 4376, + RISCV_PseudoVLSE64_V_M1_MASK = 4377, + RISCV_PseudoVLSE64_V_M2 = 4378, + RISCV_PseudoVLSE64_V_M2_MASK = 4379, + RISCV_PseudoVLSE64_V_M4 = 4380, + RISCV_PseudoVLSE64_V_M4_MASK = 4381, + RISCV_PseudoVLSE64_V_M8 = 4382, + RISCV_PseudoVLSE64_V_M8_MASK = 4383, + RISCV_PseudoVLSE8_V_M1 = 4384, + RISCV_PseudoVLSE8_V_M1_MASK = 4385, + RISCV_PseudoVLSE8_V_M2 = 4386, + RISCV_PseudoVLSE8_V_M2_MASK = 4387, + RISCV_PseudoVLSE8_V_M4 = 4388, + RISCV_PseudoVLSE8_V_M4_MASK = 4389, + RISCV_PseudoVLSE8_V_M8 = 4390, + RISCV_PseudoVLSE8_V_M8_MASK = 4391, + RISCV_PseudoVLSE8_V_MF2 = 4392, + RISCV_PseudoVLSE8_V_MF2_MASK = 4393, + RISCV_PseudoVLSE8_V_MF4 = 4394, + RISCV_PseudoVLSE8_V_MF4_MASK = 4395, + RISCV_PseudoVLSE8_V_MF8 = 4396, + RISCV_PseudoVLSE8_V_MF8_MASK = 4397, + RISCV_PseudoVLSEG2E16FF_V_M1 = 4398, + RISCV_PseudoVLSEG2E16FF_V_M1_MASK = 4399, + RISCV_PseudoVLSEG2E16FF_V_M2 = 4400, + RISCV_PseudoVLSEG2E16FF_V_M2_MASK = 4401, + RISCV_PseudoVLSEG2E16FF_V_M4 = 4402, + RISCV_PseudoVLSEG2E16FF_V_M4_MASK = 4403, + RISCV_PseudoVLSEG2E16FF_V_MF2 = 4404, + RISCV_PseudoVLSEG2E16FF_V_MF2_MASK = 4405, + RISCV_PseudoVLSEG2E16FF_V_MF4 = 4406, + RISCV_PseudoVLSEG2E16FF_V_MF4_MASK = 4407, + RISCV_PseudoVLSEG2E16_V_M1 = 4408, + RISCV_PseudoVLSEG2E16_V_M1_MASK = 4409, + RISCV_PseudoVLSEG2E16_V_M2 = 4410, + RISCV_PseudoVLSEG2E16_V_M2_MASK = 4411, + RISCV_PseudoVLSEG2E16_V_M4 = 4412, + RISCV_PseudoVLSEG2E16_V_M4_MASK = 4413, + RISCV_PseudoVLSEG2E16_V_MF2 = 4414, + RISCV_PseudoVLSEG2E16_V_MF2_MASK = 4415, + RISCV_PseudoVLSEG2E16_V_MF4 = 4416, + RISCV_PseudoVLSEG2E16_V_MF4_MASK = 4417, + RISCV_PseudoVLSEG2E32FF_V_M1 = 4418, + RISCV_PseudoVLSEG2E32FF_V_M1_MASK = 4419, + RISCV_PseudoVLSEG2E32FF_V_M2 = 4420, + RISCV_PseudoVLSEG2E32FF_V_M2_MASK = 4421, + RISCV_PseudoVLSEG2E32FF_V_M4 = 4422, + RISCV_PseudoVLSEG2E32FF_V_M4_MASK = 4423, + RISCV_PseudoVLSEG2E32FF_V_MF2 = 4424, + RISCV_PseudoVLSEG2E32FF_V_MF2_MASK = 4425, + RISCV_PseudoVLSEG2E32_V_M1 = 4426, + RISCV_PseudoVLSEG2E32_V_M1_MASK = 4427, + RISCV_PseudoVLSEG2E32_V_M2 = 4428, + RISCV_PseudoVLSEG2E32_V_M2_MASK = 4429, + RISCV_PseudoVLSEG2E32_V_M4 = 4430, + RISCV_PseudoVLSEG2E32_V_M4_MASK = 4431, + RISCV_PseudoVLSEG2E32_V_MF2 = 4432, + RISCV_PseudoVLSEG2E32_V_MF2_MASK = 4433, + RISCV_PseudoVLSEG2E64FF_V_M1 = 4434, + RISCV_PseudoVLSEG2E64FF_V_M1_MASK = 4435, + RISCV_PseudoVLSEG2E64FF_V_M2 = 4436, + RISCV_PseudoVLSEG2E64FF_V_M2_MASK = 4437, + RISCV_PseudoVLSEG2E64FF_V_M4 = 4438, + RISCV_PseudoVLSEG2E64FF_V_M4_MASK = 4439, + RISCV_PseudoVLSEG2E64_V_M1 = 4440, + RISCV_PseudoVLSEG2E64_V_M1_MASK = 4441, + RISCV_PseudoVLSEG2E64_V_M2 = 4442, + RISCV_PseudoVLSEG2E64_V_M2_MASK = 4443, + RISCV_PseudoVLSEG2E64_V_M4 = 4444, + RISCV_PseudoVLSEG2E64_V_M4_MASK = 4445, + RISCV_PseudoVLSEG2E8FF_V_M1 = 4446, + RISCV_PseudoVLSEG2E8FF_V_M1_MASK = 4447, + RISCV_PseudoVLSEG2E8FF_V_M2 = 4448, + RISCV_PseudoVLSEG2E8FF_V_M2_MASK = 4449, + RISCV_PseudoVLSEG2E8FF_V_M4 = 4450, + RISCV_PseudoVLSEG2E8FF_V_M4_MASK = 4451, + RISCV_PseudoVLSEG2E8FF_V_MF2 = 4452, + RISCV_PseudoVLSEG2E8FF_V_MF2_MASK = 4453, + RISCV_PseudoVLSEG2E8FF_V_MF4 = 4454, + RISCV_PseudoVLSEG2E8FF_V_MF4_MASK = 4455, + RISCV_PseudoVLSEG2E8FF_V_MF8 = 4456, + RISCV_PseudoVLSEG2E8FF_V_MF8_MASK = 4457, + RISCV_PseudoVLSEG2E8_V_M1 = 4458, + RISCV_PseudoVLSEG2E8_V_M1_MASK = 4459, + RISCV_PseudoVLSEG2E8_V_M2 = 4460, + RISCV_PseudoVLSEG2E8_V_M2_MASK = 4461, + RISCV_PseudoVLSEG2E8_V_M4 = 4462, + RISCV_PseudoVLSEG2E8_V_M4_MASK = 4463, + RISCV_PseudoVLSEG2E8_V_MF2 = 4464, + RISCV_PseudoVLSEG2E8_V_MF2_MASK = 4465, + RISCV_PseudoVLSEG2E8_V_MF4 = 4466, + RISCV_PseudoVLSEG2E8_V_MF4_MASK = 4467, + RISCV_PseudoVLSEG2E8_V_MF8 = 4468, + RISCV_PseudoVLSEG2E8_V_MF8_MASK = 4469, + RISCV_PseudoVLSEG3E16FF_V_M1 = 4470, + RISCV_PseudoVLSEG3E16FF_V_M1_MASK = 4471, + RISCV_PseudoVLSEG3E16FF_V_M2 = 4472, + RISCV_PseudoVLSEG3E16FF_V_M2_MASK = 4473, + RISCV_PseudoVLSEG3E16FF_V_MF2 = 4474, + RISCV_PseudoVLSEG3E16FF_V_MF2_MASK = 4475, + RISCV_PseudoVLSEG3E16FF_V_MF4 = 4476, + RISCV_PseudoVLSEG3E16FF_V_MF4_MASK = 4477, + RISCV_PseudoVLSEG3E16_V_M1 = 4478, + RISCV_PseudoVLSEG3E16_V_M1_MASK = 4479, + RISCV_PseudoVLSEG3E16_V_M2 = 4480, + RISCV_PseudoVLSEG3E16_V_M2_MASK = 4481, + RISCV_PseudoVLSEG3E16_V_MF2 = 4482, + RISCV_PseudoVLSEG3E16_V_MF2_MASK = 4483, + RISCV_PseudoVLSEG3E16_V_MF4 = 4484, + RISCV_PseudoVLSEG3E16_V_MF4_MASK = 4485, + RISCV_PseudoVLSEG3E32FF_V_M1 = 4486, + RISCV_PseudoVLSEG3E32FF_V_M1_MASK = 4487, + RISCV_PseudoVLSEG3E32FF_V_M2 = 4488, + RISCV_PseudoVLSEG3E32FF_V_M2_MASK = 4489, + RISCV_PseudoVLSEG3E32FF_V_MF2 = 4490, + RISCV_PseudoVLSEG3E32FF_V_MF2_MASK = 4491, + RISCV_PseudoVLSEG3E32_V_M1 = 4492, + RISCV_PseudoVLSEG3E32_V_M1_MASK = 4493, + RISCV_PseudoVLSEG3E32_V_M2 = 4494, + RISCV_PseudoVLSEG3E32_V_M2_MASK = 4495, + RISCV_PseudoVLSEG3E32_V_MF2 = 4496, + RISCV_PseudoVLSEG3E32_V_MF2_MASK = 4497, + RISCV_PseudoVLSEG3E64FF_V_M1 = 4498, + RISCV_PseudoVLSEG3E64FF_V_M1_MASK = 4499, + RISCV_PseudoVLSEG3E64FF_V_M2 = 4500, + RISCV_PseudoVLSEG3E64FF_V_M2_MASK = 4501, + RISCV_PseudoVLSEG3E64_V_M1 = 4502, + RISCV_PseudoVLSEG3E64_V_M1_MASK = 4503, + RISCV_PseudoVLSEG3E64_V_M2 = 4504, + RISCV_PseudoVLSEG3E64_V_M2_MASK = 4505, + RISCV_PseudoVLSEG3E8FF_V_M1 = 4506, + RISCV_PseudoVLSEG3E8FF_V_M1_MASK = 4507, + RISCV_PseudoVLSEG3E8FF_V_M2 = 4508, + RISCV_PseudoVLSEG3E8FF_V_M2_MASK = 4509, + RISCV_PseudoVLSEG3E8FF_V_MF2 = 4510, + RISCV_PseudoVLSEG3E8FF_V_MF2_MASK = 4511, + RISCV_PseudoVLSEG3E8FF_V_MF4 = 4512, + RISCV_PseudoVLSEG3E8FF_V_MF4_MASK = 4513, + RISCV_PseudoVLSEG3E8FF_V_MF8 = 4514, + RISCV_PseudoVLSEG3E8FF_V_MF8_MASK = 4515, + RISCV_PseudoVLSEG3E8_V_M1 = 4516, + RISCV_PseudoVLSEG3E8_V_M1_MASK = 4517, + RISCV_PseudoVLSEG3E8_V_M2 = 4518, + RISCV_PseudoVLSEG3E8_V_M2_MASK = 4519, + RISCV_PseudoVLSEG3E8_V_MF2 = 4520, + RISCV_PseudoVLSEG3E8_V_MF2_MASK = 4521, + RISCV_PseudoVLSEG3E8_V_MF4 = 4522, + RISCV_PseudoVLSEG3E8_V_MF4_MASK = 4523, + RISCV_PseudoVLSEG3E8_V_MF8 = 4524, + RISCV_PseudoVLSEG3E8_V_MF8_MASK = 4525, + RISCV_PseudoVLSEG4E16FF_V_M1 = 4526, + RISCV_PseudoVLSEG4E16FF_V_M1_MASK = 4527, + RISCV_PseudoVLSEG4E16FF_V_M2 = 4528, + RISCV_PseudoVLSEG4E16FF_V_M2_MASK = 4529, + RISCV_PseudoVLSEG4E16FF_V_MF2 = 4530, + RISCV_PseudoVLSEG4E16FF_V_MF2_MASK = 4531, + RISCV_PseudoVLSEG4E16FF_V_MF4 = 4532, + RISCV_PseudoVLSEG4E16FF_V_MF4_MASK = 4533, + RISCV_PseudoVLSEG4E16_V_M1 = 4534, + RISCV_PseudoVLSEG4E16_V_M1_MASK = 4535, + RISCV_PseudoVLSEG4E16_V_M2 = 4536, + RISCV_PseudoVLSEG4E16_V_M2_MASK = 4537, + RISCV_PseudoVLSEG4E16_V_MF2 = 4538, + RISCV_PseudoVLSEG4E16_V_MF2_MASK = 4539, + RISCV_PseudoVLSEG4E16_V_MF4 = 4540, + RISCV_PseudoVLSEG4E16_V_MF4_MASK = 4541, + RISCV_PseudoVLSEG4E32FF_V_M1 = 4542, + RISCV_PseudoVLSEG4E32FF_V_M1_MASK = 4543, + RISCV_PseudoVLSEG4E32FF_V_M2 = 4544, + RISCV_PseudoVLSEG4E32FF_V_M2_MASK = 4545, + RISCV_PseudoVLSEG4E32FF_V_MF2 = 4546, + RISCV_PseudoVLSEG4E32FF_V_MF2_MASK = 4547, + RISCV_PseudoVLSEG4E32_V_M1 = 4548, + RISCV_PseudoVLSEG4E32_V_M1_MASK = 4549, + RISCV_PseudoVLSEG4E32_V_M2 = 4550, + RISCV_PseudoVLSEG4E32_V_M2_MASK = 4551, + RISCV_PseudoVLSEG4E32_V_MF2 = 4552, + RISCV_PseudoVLSEG4E32_V_MF2_MASK = 4553, + RISCV_PseudoVLSEG4E64FF_V_M1 = 4554, + RISCV_PseudoVLSEG4E64FF_V_M1_MASK = 4555, + RISCV_PseudoVLSEG4E64FF_V_M2 = 4556, + RISCV_PseudoVLSEG4E64FF_V_M2_MASK = 4557, + RISCV_PseudoVLSEG4E64_V_M1 = 4558, + RISCV_PseudoVLSEG4E64_V_M1_MASK = 4559, + RISCV_PseudoVLSEG4E64_V_M2 = 4560, + RISCV_PseudoVLSEG4E64_V_M2_MASK = 4561, + RISCV_PseudoVLSEG4E8FF_V_M1 = 4562, + RISCV_PseudoVLSEG4E8FF_V_M1_MASK = 4563, + RISCV_PseudoVLSEG4E8FF_V_M2 = 4564, + RISCV_PseudoVLSEG4E8FF_V_M2_MASK = 4565, + RISCV_PseudoVLSEG4E8FF_V_MF2 = 4566, + RISCV_PseudoVLSEG4E8FF_V_MF2_MASK = 4567, + RISCV_PseudoVLSEG4E8FF_V_MF4 = 4568, + RISCV_PseudoVLSEG4E8FF_V_MF4_MASK = 4569, + RISCV_PseudoVLSEG4E8FF_V_MF8 = 4570, + RISCV_PseudoVLSEG4E8FF_V_MF8_MASK = 4571, + RISCV_PseudoVLSEG4E8_V_M1 = 4572, + RISCV_PseudoVLSEG4E8_V_M1_MASK = 4573, + RISCV_PseudoVLSEG4E8_V_M2 = 4574, + RISCV_PseudoVLSEG4E8_V_M2_MASK = 4575, + RISCV_PseudoVLSEG4E8_V_MF2 = 4576, + RISCV_PseudoVLSEG4E8_V_MF2_MASK = 4577, + RISCV_PseudoVLSEG4E8_V_MF4 = 4578, + RISCV_PseudoVLSEG4E8_V_MF4_MASK = 4579, + RISCV_PseudoVLSEG4E8_V_MF8 = 4580, + RISCV_PseudoVLSEG4E8_V_MF8_MASK = 4581, + RISCV_PseudoVLSEG5E16FF_V_M1 = 4582, + RISCV_PseudoVLSEG5E16FF_V_M1_MASK = 4583, + RISCV_PseudoVLSEG5E16FF_V_MF2 = 4584, + RISCV_PseudoVLSEG5E16FF_V_MF2_MASK = 4585, + RISCV_PseudoVLSEG5E16FF_V_MF4 = 4586, + RISCV_PseudoVLSEG5E16FF_V_MF4_MASK = 4587, + RISCV_PseudoVLSEG5E16_V_M1 = 4588, + RISCV_PseudoVLSEG5E16_V_M1_MASK = 4589, + RISCV_PseudoVLSEG5E16_V_MF2 = 4590, + RISCV_PseudoVLSEG5E16_V_MF2_MASK = 4591, + RISCV_PseudoVLSEG5E16_V_MF4 = 4592, + RISCV_PseudoVLSEG5E16_V_MF4_MASK = 4593, + RISCV_PseudoVLSEG5E32FF_V_M1 = 4594, + RISCV_PseudoVLSEG5E32FF_V_M1_MASK = 4595, + RISCV_PseudoVLSEG5E32FF_V_MF2 = 4596, + RISCV_PseudoVLSEG5E32FF_V_MF2_MASK = 4597, + RISCV_PseudoVLSEG5E32_V_M1 = 4598, + RISCV_PseudoVLSEG5E32_V_M1_MASK = 4599, + RISCV_PseudoVLSEG5E32_V_MF2 = 4600, + RISCV_PseudoVLSEG5E32_V_MF2_MASK = 4601, + RISCV_PseudoVLSEG5E64FF_V_M1 = 4602, + RISCV_PseudoVLSEG5E64FF_V_M1_MASK = 4603, + RISCV_PseudoVLSEG5E64_V_M1 = 4604, + RISCV_PseudoVLSEG5E64_V_M1_MASK = 4605, + RISCV_PseudoVLSEG5E8FF_V_M1 = 4606, + RISCV_PseudoVLSEG5E8FF_V_M1_MASK = 4607, + RISCV_PseudoVLSEG5E8FF_V_MF2 = 4608, + RISCV_PseudoVLSEG5E8FF_V_MF2_MASK = 4609, + RISCV_PseudoVLSEG5E8FF_V_MF4 = 4610, + RISCV_PseudoVLSEG5E8FF_V_MF4_MASK = 4611, + RISCV_PseudoVLSEG5E8FF_V_MF8 = 4612, + RISCV_PseudoVLSEG5E8FF_V_MF8_MASK = 4613, + RISCV_PseudoVLSEG5E8_V_M1 = 4614, + RISCV_PseudoVLSEG5E8_V_M1_MASK = 4615, + RISCV_PseudoVLSEG5E8_V_MF2 = 4616, + RISCV_PseudoVLSEG5E8_V_MF2_MASK = 4617, + RISCV_PseudoVLSEG5E8_V_MF4 = 4618, + RISCV_PseudoVLSEG5E8_V_MF4_MASK = 4619, + RISCV_PseudoVLSEG5E8_V_MF8 = 4620, + RISCV_PseudoVLSEG5E8_V_MF8_MASK = 4621, + RISCV_PseudoVLSEG6E16FF_V_M1 = 4622, + RISCV_PseudoVLSEG6E16FF_V_M1_MASK = 4623, + RISCV_PseudoVLSEG6E16FF_V_MF2 = 4624, + RISCV_PseudoVLSEG6E16FF_V_MF2_MASK = 4625, + RISCV_PseudoVLSEG6E16FF_V_MF4 = 4626, + RISCV_PseudoVLSEG6E16FF_V_MF4_MASK = 4627, + RISCV_PseudoVLSEG6E16_V_M1 = 4628, + RISCV_PseudoVLSEG6E16_V_M1_MASK = 4629, + RISCV_PseudoVLSEG6E16_V_MF2 = 4630, + RISCV_PseudoVLSEG6E16_V_MF2_MASK = 4631, + RISCV_PseudoVLSEG6E16_V_MF4 = 4632, + RISCV_PseudoVLSEG6E16_V_MF4_MASK = 4633, + RISCV_PseudoVLSEG6E32FF_V_M1 = 4634, + RISCV_PseudoVLSEG6E32FF_V_M1_MASK = 4635, + RISCV_PseudoVLSEG6E32FF_V_MF2 = 4636, + RISCV_PseudoVLSEG6E32FF_V_MF2_MASK = 4637, + RISCV_PseudoVLSEG6E32_V_M1 = 4638, + RISCV_PseudoVLSEG6E32_V_M1_MASK = 4639, + RISCV_PseudoVLSEG6E32_V_MF2 = 4640, + RISCV_PseudoVLSEG6E32_V_MF2_MASK = 4641, + RISCV_PseudoVLSEG6E64FF_V_M1 = 4642, + RISCV_PseudoVLSEG6E64FF_V_M1_MASK = 4643, + RISCV_PseudoVLSEG6E64_V_M1 = 4644, + RISCV_PseudoVLSEG6E64_V_M1_MASK = 4645, + RISCV_PseudoVLSEG6E8FF_V_M1 = 4646, + RISCV_PseudoVLSEG6E8FF_V_M1_MASK = 4647, + RISCV_PseudoVLSEG6E8FF_V_MF2 = 4648, + RISCV_PseudoVLSEG6E8FF_V_MF2_MASK = 4649, + RISCV_PseudoVLSEG6E8FF_V_MF4 = 4650, + RISCV_PseudoVLSEG6E8FF_V_MF4_MASK = 4651, + RISCV_PseudoVLSEG6E8FF_V_MF8 = 4652, + RISCV_PseudoVLSEG6E8FF_V_MF8_MASK = 4653, + RISCV_PseudoVLSEG6E8_V_M1 = 4654, + RISCV_PseudoVLSEG6E8_V_M1_MASK = 4655, + RISCV_PseudoVLSEG6E8_V_MF2 = 4656, + RISCV_PseudoVLSEG6E8_V_MF2_MASK = 4657, + RISCV_PseudoVLSEG6E8_V_MF4 = 4658, + RISCV_PseudoVLSEG6E8_V_MF4_MASK = 4659, + RISCV_PseudoVLSEG6E8_V_MF8 = 4660, + RISCV_PseudoVLSEG6E8_V_MF8_MASK = 4661, + RISCV_PseudoVLSEG7E16FF_V_M1 = 4662, + RISCV_PseudoVLSEG7E16FF_V_M1_MASK = 4663, + RISCV_PseudoVLSEG7E16FF_V_MF2 = 4664, + RISCV_PseudoVLSEG7E16FF_V_MF2_MASK = 4665, + RISCV_PseudoVLSEG7E16FF_V_MF4 = 4666, + RISCV_PseudoVLSEG7E16FF_V_MF4_MASK = 4667, + RISCV_PseudoVLSEG7E16_V_M1 = 4668, + RISCV_PseudoVLSEG7E16_V_M1_MASK = 4669, + RISCV_PseudoVLSEG7E16_V_MF2 = 4670, + RISCV_PseudoVLSEG7E16_V_MF2_MASK = 4671, + RISCV_PseudoVLSEG7E16_V_MF4 = 4672, + RISCV_PseudoVLSEG7E16_V_MF4_MASK = 4673, + RISCV_PseudoVLSEG7E32FF_V_M1 = 4674, + RISCV_PseudoVLSEG7E32FF_V_M1_MASK = 4675, + RISCV_PseudoVLSEG7E32FF_V_MF2 = 4676, + RISCV_PseudoVLSEG7E32FF_V_MF2_MASK = 4677, + RISCV_PseudoVLSEG7E32_V_M1 = 4678, + RISCV_PseudoVLSEG7E32_V_M1_MASK = 4679, + RISCV_PseudoVLSEG7E32_V_MF2 = 4680, + RISCV_PseudoVLSEG7E32_V_MF2_MASK = 4681, + RISCV_PseudoVLSEG7E64FF_V_M1 = 4682, + RISCV_PseudoVLSEG7E64FF_V_M1_MASK = 4683, + RISCV_PseudoVLSEG7E64_V_M1 = 4684, + RISCV_PseudoVLSEG7E64_V_M1_MASK = 4685, + RISCV_PseudoVLSEG7E8FF_V_M1 = 4686, + RISCV_PseudoVLSEG7E8FF_V_M1_MASK = 4687, + RISCV_PseudoVLSEG7E8FF_V_MF2 = 4688, + RISCV_PseudoVLSEG7E8FF_V_MF2_MASK = 4689, + RISCV_PseudoVLSEG7E8FF_V_MF4 = 4690, + RISCV_PseudoVLSEG7E8FF_V_MF4_MASK = 4691, + RISCV_PseudoVLSEG7E8FF_V_MF8 = 4692, + RISCV_PseudoVLSEG7E8FF_V_MF8_MASK = 4693, + RISCV_PseudoVLSEG7E8_V_M1 = 4694, + RISCV_PseudoVLSEG7E8_V_M1_MASK = 4695, + RISCV_PseudoVLSEG7E8_V_MF2 = 4696, + RISCV_PseudoVLSEG7E8_V_MF2_MASK = 4697, + RISCV_PseudoVLSEG7E8_V_MF4 = 4698, + RISCV_PseudoVLSEG7E8_V_MF4_MASK = 4699, + RISCV_PseudoVLSEG7E8_V_MF8 = 4700, + RISCV_PseudoVLSEG7E8_V_MF8_MASK = 4701, + RISCV_PseudoVLSEG8E16FF_V_M1 = 4702, + RISCV_PseudoVLSEG8E16FF_V_M1_MASK = 4703, + RISCV_PseudoVLSEG8E16FF_V_MF2 = 4704, + RISCV_PseudoVLSEG8E16FF_V_MF2_MASK = 4705, + RISCV_PseudoVLSEG8E16FF_V_MF4 = 4706, + RISCV_PseudoVLSEG8E16FF_V_MF4_MASK = 4707, + RISCV_PseudoVLSEG8E16_V_M1 = 4708, + RISCV_PseudoVLSEG8E16_V_M1_MASK = 4709, + RISCV_PseudoVLSEG8E16_V_MF2 = 4710, + RISCV_PseudoVLSEG8E16_V_MF2_MASK = 4711, + RISCV_PseudoVLSEG8E16_V_MF4 = 4712, + RISCV_PseudoVLSEG8E16_V_MF4_MASK = 4713, + RISCV_PseudoVLSEG8E32FF_V_M1 = 4714, + RISCV_PseudoVLSEG8E32FF_V_M1_MASK = 4715, + RISCV_PseudoVLSEG8E32FF_V_MF2 = 4716, + RISCV_PseudoVLSEG8E32FF_V_MF2_MASK = 4717, + RISCV_PseudoVLSEG8E32_V_M1 = 4718, + RISCV_PseudoVLSEG8E32_V_M1_MASK = 4719, + RISCV_PseudoVLSEG8E32_V_MF2 = 4720, + RISCV_PseudoVLSEG8E32_V_MF2_MASK = 4721, + RISCV_PseudoVLSEG8E64FF_V_M1 = 4722, + RISCV_PseudoVLSEG8E64FF_V_M1_MASK = 4723, + RISCV_PseudoVLSEG8E64_V_M1 = 4724, + RISCV_PseudoVLSEG8E64_V_M1_MASK = 4725, + RISCV_PseudoVLSEG8E8FF_V_M1 = 4726, + RISCV_PseudoVLSEG8E8FF_V_M1_MASK = 4727, + RISCV_PseudoVLSEG8E8FF_V_MF2 = 4728, + RISCV_PseudoVLSEG8E8FF_V_MF2_MASK = 4729, + RISCV_PseudoVLSEG8E8FF_V_MF4 = 4730, + RISCV_PseudoVLSEG8E8FF_V_MF4_MASK = 4731, + RISCV_PseudoVLSEG8E8FF_V_MF8 = 4732, + RISCV_PseudoVLSEG8E8FF_V_MF8_MASK = 4733, + RISCV_PseudoVLSEG8E8_V_M1 = 4734, + RISCV_PseudoVLSEG8E8_V_M1_MASK = 4735, + RISCV_PseudoVLSEG8E8_V_MF2 = 4736, + RISCV_PseudoVLSEG8E8_V_MF2_MASK = 4737, + RISCV_PseudoVLSEG8E8_V_MF4 = 4738, + RISCV_PseudoVLSEG8E8_V_MF4_MASK = 4739, + RISCV_PseudoVLSEG8E8_V_MF8 = 4740, + RISCV_PseudoVLSEG8E8_V_MF8_MASK = 4741, + RISCV_PseudoVLSSEG2E16_V_M1 = 4742, + RISCV_PseudoVLSSEG2E16_V_M1_MASK = 4743, + RISCV_PseudoVLSSEG2E16_V_M2 = 4744, + RISCV_PseudoVLSSEG2E16_V_M2_MASK = 4745, + RISCV_PseudoVLSSEG2E16_V_M4 = 4746, + RISCV_PseudoVLSSEG2E16_V_M4_MASK = 4747, + RISCV_PseudoVLSSEG2E16_V_MF2 = 4748, + RISCV_PseudoVLSSEG2E16_V_MF2_MASK = 4749, + RISCV_PseudoVLSSEG2E16_V_MF4 = 4750, + RISCV_PseudoVLSSEG2E16_V_MF4_MASK = 4751, + RISCV_PseudoVLSSEG2E32_V_M1 = 4752, + RISCV_PseudoVLSSEG2E32_V_M1_MASK = 4753, + RISCV_PseudoVLSSEG2E32_V_M2 = 4754, + RISCV_PseudoVLSSEG2E32_V_M2_MASK = 4755, + RISCV_PseudoVLSSEG2E32_V_M4 = 4756, + RISCV_PseudoVLSSEG2E32_V_M4_MASK = 4757, + RISCV_PseudoVLSSEG2E32_V_MF2 = 4758, + RISCV_PseudoVLSSEG2E32_V_MF2_MASK = 4759, + RISCV_PseudoVLSSEG2E64_V_M1 = 4760, + RISCV_PseudoVLSSEG2E64_V_M1_MASK = 4761, + RISCV_PseudoVLSSEG2E64_V_M2 = 4762, + RISCV_PseudoVLSSEG2E64_V_M2_MASK = 4763, + RISCV_PseudoVLSSEG2E64_V_M4 = 4764, + RISCV_PseudoVLSSEG2E64_V_M4_MASK = 4765, + RISCV_PseudoVLSSEG2E8_V_M1 = 4766, + RISCV_PseudoVLSSEG2E8_V_M1_MASK = 4767, + RISCV_PseudoVLSSEG2E8_V_M2 = 4768, + RISCV_PseudoVLSSEG2E8_V_M2_MASK = 4769, + RISCV_PseudoVLSSEG2E8_V_M4 = 4770, + RISCV_PseudoVLSSEG2E8_V_M4_MASK = 4771, + RISCV_PseudoVLSSEG2E8_V_MF2 = 4772, + RISCV_PseudoVLSSEG2E8_V_MF2_MASK = 4773, + RISCV_PseudoVLSSEG2E8_V_MF4 = 4774, + RISCV_PseudoVLSSEG2E8_V_MF4_MASK = 4775, + RISCV_PseudoVLSSEG2E8_V_MF8 = 4776, + RISCV_PseudoVLSSEG2E8_V_MF8_MASK = 4777, + RISCV_PseudoVLSSEG3E16_V_M1 = 4778, + RISCV_PseudoVLSSEG3E16_V_M1_MASK = 4779, + RISCV_PseudoVLSSEG3E16_V_M2 = 4780, + RISCV_PseudoVLSSEG3E16_V_M2_MASK = 4781, + RISCV_PseudoVLSSEG3E16_V_MF2 = 4782, + RISCV_PseudoVLSSEG3E16_V_MF2_MASK = 4783, + RISCV_PseudoVLSSEG3E16_V_MF4 = 4784, + RISCV_PseudoVLSSEG3E16_V_MF4_MASK = 4785, + RISCV_PseudoVLSSEG3E32_V_M1 = 4786, + RISCV_PseudoVLSSEG3E32_V_M1_MASK = 4787, + RISCV_PseudoVLSSEG3E32_V_M2 = 4788, + RISCV_PseudoVLSSEG3E32_V_M2_MASK = 4789, + RISCV_PseudoVLSSEG3E32_V_MF2 = 4790, + RISCV_PseudoVLSSEG3E32_V_MF2_MASK = 4791, + RISCV_PseudoVLSSEG3E64_V_M1 = 4792, + RISCV_PseudoVLSSEG3E64_V_M1_MASK = 4793, + RISCV_PseudoVLSSEG3E64_V_M2 = 4794, + RISCV_PseudoVLSSEG3E64_V_M2_MASK = 4795, + RISCV_PseudoVLSSEG3E8_V_M1 = 4796, + RISCV_PseudoVLSSEG3E8_V_M1_MASK = 4797, + RISCV_PseudoVLSSEG3E8_V_M2 = 4798, + RISCV_PseudoVLSSEG3E8_V_M2_MASK = 4799, + RISCV_PseudoVLSSEG3E8_V_MF2 = 4800, + RISCV_PseudoVLSSEG3E8_V_MF2_MASK = 4801, + RISCV_PseudoVLSSEG3E8_V_MF4 = 4802, + RISCV_PseudoVLSSEG3E8_V_MF4_MASK = 4803, + RISCV_PseudoVLSSEG3E8_V_MF8 = 4804, + RISCV_PseudoVLSSEG3E8_V_MF8_MASK = 4805, + RISCV_PseudoVLSSEG4E16_V_M1 = 4806, + RISCV_PseudoVLSSEG4E16_V_M1_MASK = 4807, + RISCV_PseudoVLSSEG4E16_V_M2 = 4808, + RISCV_PseudoVLSSEG4E16_V_M2_MASK = 4809, + RISCV_PseudoVLSSEG4E16_V_MF2 = 4810, + RISCV_PseudoVLSSEG4E16_V_MF2_MASK = 4811, + RISCV_PseudoVLSSEG4E16_V_MF4 = 4812, + RISCV_PseudoVLSSEG4E16_V_MF4_MASK = 4813, + RISCV_PseudoVLSSEG4E32_V_M1 = 4814, + RISCV_PseudoVLSSEG4E32_V_M1_MASK = 4815, + RISCV_PseudoVLSSEG4E32_V_M2 = 4816, + RISCV_PseudoVLSSEG4E32_V_M2_MASK = 4817, + RISCV_PseudoVLSSEG4E32_V_MF2 = 4818, + RISCV_PseudoVLSSEG4E32_V_MF2_MASK = 4819, + RISCV_PseudoVLSSEG4E64_V_M1 = 4820, + RISCV_PseudoVLSSEG4E64_V_M1_MASK = 4821, + RISCV_PseudoVLSSEG4E64_V_M2 = 4822, + RISCV_PseudoVLSSEG4E64_V_M2_MASK = 4823, + RISCV_PseudoVLSSEG4E8_V_M1 = 4824, + RISCV_PseudoVLSSEG4E8_V_M1_MASK = 4825, + RISCV_PseudoVLSSEG4E8_V_M2 = 4826, + RISCV_PseudoVLSSEG4E8_V_M2_MASK = 4827, + RISCV_PseudoVLSSEG4E8_V_MF2 = 4828, + RISCV_PseudoVLSSEG4E8_V_MF2_MASK = 4829, + RISCV_PseudoVLSSEG4E8_V_MF4 = 4830, + RISCV_PseudoVLSSEG4E8_V_MF4_MASK = 4831, + RISCV_PseudoVLSSEG4E8_V_MF8 = 4832, + RISCV_PseudoVLSSEG4E8_V_MF8_MASK = 4833, + RISCV_PseudoVLSSEG5E16_V_M1 = 4834, + RISCV_PseudoVLSSEG5E16_V_M1_MASK = 4835, + RISCV_PseudoVLSSEG5E16_V_MF2 = 4836, + RISCV_PseudoVLSSEG5E16_V_MF2_MASK = 4837, + RISCV_PseudoVLSSEG5E16_V_MF4 = 4838, + RISCV_PseudoVLSSEG5E16_V_MF4_MASK = 4839, + RISCV_PseudoVLSSEG5E32_V_M1 = 4840, + RISCV_PseudoVLSSEG5E32_V_M1_MASK = 4841, + RISCV_PseudoVLSSEG5E32_V_MF2 = 4842, + RISCV_PseudoVLSSEG5E32_V_MF2_MASK = 4843, + RISCV_PseudoVLSSEG5E64_V_M1 = 4844, + RISCV_PseudoVLSSEG5E64_V_M1_MASK = 4845, + RISCV_PseudoVLSSEG5E8_V_M1 = 4846, + RISCV_PseudoVLSSEG5E8_V_M1_MASK = 4847, + RISCV_PseudoVLSSEG5E8_V_MF2 = 4848, + RISCV_PseudoVLSSEG5E8_V_MF2_MASK = 4849, + RISCV_PseudoVLSSEG5E8_V_MF4 = 4850, + RISCV_PseudoVLSSEG5E8_V_MF4_MASK = 4851, + RISCV_PseudoVLSSEG5E8_V_MF8 = 4852, + RISCV_PseudoVLSSEG5E8_V_MF8_MASK = 4853, + RISCV_PseudoVLSSEG6E16_V_M1 = 4854, + RISCV_PseudoVLSSEG6E16_V_M1_MASK = 4855, + RISCV_PseudoVLSSEG6E16_V_MF2 = 4856, + RISCV_PseudoVLSSEG6E16_V_MF2_MASK = 4857, + RISCV_PseudoVLSSEG6E16_V_MF4 = 4858, + RISCV_PseudoVLSSEG6E16_V_MF4_MASK = 4859, + RISCV_PseudoVLSSEG6E32_V_M1 = 4860, + RISCV_PseudoVLSSEG6E32_V_M1_MASK = 4861, + RISCV_PseudoVLSSEG6E32_V_MF2 = 4862, + RISCV_PseudoVLSSEG6E32_V_MF2_MASK = 4863, + RISCV_PseudoVLSSEG6E64_V_M1 = 4864, + RISCV_PseudoVLSSEG6E64_V_M1_MASK = 4865, + RISCV_PseudoVLSSEG6E8_V_M1 = 4866, + RISCV_PseudoVLSSEG6E8_V_M1_MASK = 4867, + RISCV_PseudoVLSSEG6E8_V_MF2 = 4868, + RISCV_PseudoVLSSEG6E8_V_MF2_MASK = 4869, + RISCV_PseudoVLSSEG6E8_V_MF4 = 4870, + RISCV_PseudoVLSSEG6E8_V_MF4_MASK = 4871, + RISCV_PseudoVLSSEG6E8_V_MF8 = 4872, + RISCV_PseudoVLSSEG6E8_V_MF8_MASK = 4873, + RISCV_PseudoVLSSEG7E16_V_M1 = 4874, + RISCV_PseudoVLSSEG7E16_V_M1_MASK = 4875, + RISCV_PseudoVLSSEG7E16_V_MF2 = 4876, + RISCV_PseudoVLSSEG7E16_V_MF2_MASK = 4877, + RISCV_PseudoVLSSEG7E16_V_MF4 = 4878, + RISCV_PseudoVLSSEG7E16_V_MF4_MASK = 4879, + RISCV_PseudoVLSSEG7E32_V_M1 = 4880, + RISCV_PseudoVLSSEG7E32_V_M1_MASK = 4881, + RISCV_PseudoVLSSEG7E32_V_MF2 = 4882, + RISCV_PseudoVLSSEG7E32_V_MF2_MASK = 4883, + RISCV_PseudoVLSSEG7E64_V_M1 = 4884, + RISCV_PseudoVLSSEG7E64_V_M1_MASK = 4885, + RISCV_PseudoVLSSEG7E8_V_M1 = 4886, + RISCV_PseudoVLSSEG7E8_V_M1_MASK = 4887, + RISCV_PseudoVLSSEG7E8_V_MF2 = 4888, + RISCV_PseudoVLSSEG7E8_V_MF2_MASK = 4889, + RISCV_PseudoVLSSEG7E8_V_MF4 = 4890, + RISCV_PseudoVLSSEG7E8_V_MF4_MASK = 4891, + RISCV_PseudoVLSSEG7E8_V_MF8 = 4892, + RISCV_PseudoVLSSEG7E8_V_MF8_MASK = 4893, + RISCV_PseudoVLSSEG8E16_V_M1 = 4894, + RISCV_PseudoVLSSEG8E16_V_M1_MASK = 4895, + RISCV_PseudoVLSSEG8E16_V_MF2 = 4896, + RISCV_PseudoVLSSEG8E16_V_MF2_MASK = 4897, + RISCV_PseudoVLSSEG8E16_V_MF4 = 4898, + RISCV_PseudoVLSSEG8E16_V_MF4_MASK = 4899, + RISCV_PseudoVLSSEG8E32_V_M1 = 4900, + RISCV_PseudoVLSSEG8E32_V_M1_MASK = 4901, + RISCV_PseudoVLSSEG8E32_V_MF2 = 4902, + RISCV_PseudoVLSSEG8E32_V_MF2_MASK = 4903, + RISCV_PseudoVLSSEG8E64_V_M1 = 4904, + RISCV_PseudoVLSSEG8E64_V_M1_MASK = 4905, + RISCV_PseudoVLSSEG8E8_V_M1 = 4906, + RISCV_PseudoVLSSEG8E8_V_M1_MASK = 4907, + RISCV_PseudoVLSSEG8E8_V_MF2 = 4908, + RISCV_PseudoVLSSEG8E8_V_MF2_MASK = 4909, + RISCV_PseudoVLSSEG8E8_V_MF4 = 4910, + RISCV_PseudoVLSSEG8E8_V_MF4_MASK = 4911, + RISCV_PseudoVLSSEG8E8_V_MF8 = 4912, + RISCV_PseudoVLSSEG8E8_V_MF8_MASK = 4913, + RISCV_PseudoVLUXEI16_V_M1_M1 = 4914, + RISCV_PseudoVLUXEI16_V_M1_M1_MASK = 4915, + RISCV_PseudoVLUXEI16_V_M1_M2 = 4916, + RISCV_PseudoVLUXEI16_V_M1_M2_MASK = 4917, + RISCV_PseudoVLUXEI16_V_M1_M4 = 4918, + RISCV_PseudoVLUXEI16_V_M1_M4_MASK = 4919, + RISCV_PseudoVLUXEI16_V_M1_MF2 = 4920, + RISCV_PseudoVLUXEI16_V_M1_MF2_MASK = 4921, + RISCV_PseudoVLUXEI16_V_M2_M1 = 4922, + RISCV_PseudoVLUXEI16_V_M2_M1_MASK = 4923, + RISCV_PseudoVLUXEI16_V_M2_M2 = 4924, + RISCV_PseudoVLUXEI16_V_M2_M2_MASK = 4925, + RISCV_PseudoVLUXEI16_V_M2_M4 = 4926, + RISCV_PseudoVLUXEI16_V_M2_M4_MASK = 4927, + RISCV_PseudoVLUXEI16_V_M2_M8 = 4928, + RISCV_PseudoVLUXEI16_V_M2_M8_MASK = 4929, + RISCV_PseudoVLUXEI16_V_M4_M2 = 4930, + RISCV_PseudoVLUXEI16_V_M4_M2_MASK = 4931, + RISCV_PseudoVLUXEI16_V_M4_M4 = 4932, + RISCV_PseudoVLUXEI16_V_M4_M4_MASK = 4933, + RISCV_PseudoVLUXEI16_V_M4_M8 = 4934, + RISCV_PseudoVLUXEI16_V_M4_M8_MASK = 4935, + RISCV_PseudoVLUXEI16_V_M8_M4 = 4936, + RISCV_PseudoVLUXEI16_V_M8_M4_MASK = 4937, + RISCV_PseudoVLUXEI16_V_M8_M8 = 4938, + RISCV_PseudoVLUXEI16_V_M8_M8_MASK = 4939, + RISCV_PseudoVLUXEI16_V_MF2_M1 = 4940, + RISCV_PseudoVLUXEI16_V_MF2_M1_MASK = 4941, + RISCV_PseudoVLUXEI16_V_MF2_M2 = 4942, + RISCV_PseudoVLUXEI16_V_MF2_M2_MASK = 4943, + RISCV_PseudoVLUXEI16_V_MF2_MF2 = 4944, + RISCV_PseudoVLUXEI16_V_MF2_MF2_MASK = 4945, + RISCV_PseudoVLUXEI16_V_MF2_MF4 = 4946, + RISCV_PseudoVLUXEI16_V_MF2_MF4_MASK = 4947, + RISCV_PseudoVLUXEI16_V_MF4_M1 = 4948, + RISCV_PseudoVLUXEI16_V_MF4_M1_MASK = 4949, + RISCV_PseudoVLUXEI16_V_MF4_MF2 = 4950, + RISCV_PseudoVLUXEI16_V_MF4_MF2_MASK = 4951, + RISCV_PseudoVLUXEI16_V_MF4_MF4 = 4952, + RISCV_PseudoVLUXEI16_V_MF4_MF4_MASK = 4953, + RISCV_PseudoVLUXEI16_V_MF4_MF8 = 4954, + RISCV_PseudoVLUXEI16_V_MF4_MF8_MASK = 4955, + RISCV_PseudoVLUXEI32_V_M1_M1 = 4956, + RISCV_PseudoVLUXEI32_V_M1_M1_MASK = 4957, + RISCV_PseudoVLUXEI32_V_M1_M2 = 4958, + RISCV_PseudoVLUXEI32_V_M1_M2_MASK = 4959, + RISCV_PseudoVLUXEI32_V_M1_MF2 = 4960, + RISCV_PseudoVLUXEI32_V_M1_MF2_MASK = 4961, + RISCV_PseudoVLUXEI32_V_M1_MF4 = 4962, + RISCV_PseudoVLUXEI32_V_M1_MF4_MASK = 4963, + RISCV_PseudoVLUXEI32_V_M2_M1 = 4964, + RISCV_PseudoVLUXEI32_V_M2_M1_MASK = 4965, + RISCV_PseudoVLUXEI32_V_M2_M2 = 4966, + RISCV_PseudoVLUXEI32_V_M2_M2_MASK = 4967, + RISCV_PseudoVLUXEI32_V_M2_M4 = 4968, + RISCV_PseudoVLUXEI32_V_M2_M4_MASK = 4969, + RISCV_PseudoVLUXEI32_V_M2_MF2 = 4970, + RISCV_PseudoVLUXEI32_V_M2_MF2_MASK = 4971, + RISCV_PseudoVLUXEI32_V_M4_M1 = 4972, + RISCV_PseudoVLUXEI32_V_M4_M1_MASK = 4973, + RISCV_PseudoVLUXEI32_V_M4_M2 = 4974, + RISCV_PseudoVLUXEI32_V_M4_M2_MASK = 4975, + RISCV_PseudoVLUXEI32_V_M4_M4 = 4976, + RISCV_PseudoVLUXEI32_V_M4_M4_MASK = 4977, + RISCV_PseudoVLUXEI32_V_M4_M8 = 4978, + RISCV_PseudoVLUXEI32_V_M4_M8_MASK = 4979, + RISCV_PseudoVLUXEI32_V_M8_M2 = 4980, + RISCV_PseudoVLUXEI32_V_M8_M2_MASK = 4981, + RISCV_PseudoVLUXEI32_V_M8_M4 = 4982, + RISCV_PseudoVLUXEI32_V_M8_M4_MASK = 4983, + RISCV_PseudoVLUXEI32_V_M8_M8 = 4984, + RISCV_PseudoVLUXEI32_V_M8_M8_MASK = 4985, + RISCV_PseudoVLUXEI32_V_MF2_M1 = 4986, + RISCV_PseudoVLUXEI32_V_MF2_M1_MASK = 4987, + RISCV_PseudoVLUXEI32_V_MF2_MF2 = 4988, + RISCV_PseudoVLUXEI32_V_MF2_MF2_MASK = 4989, + RISCV_PseudoVLUXEI32_V_MF2_MF4 = 4990, + RISCV_PseudoVLUXEI32_V_MF2_MF4_MASK = 4991, + RISCV_PseudoVLUXEI32_V_MF2_MF8 = 4992, + RISCV_PseudoVLUXEI32_V_MF2_MF8_MASK = 4993, + RISCV_PseudoVLUXEI64_V_M1_M1 = 4994, + RISCV_PseudoVLUXEI64_V_M1_M1_MASK = 4995, + RISCV_PseudoVLUXEI64_V_M1_MF2 = 4996, + RISCV_PseudoVLUXEI64_V_M1_MF2_MASK = 4997, + RISCV_PseudoVLUXEI64_V_M1_MF4 = 4998, + RISCV_PseudoVLUXEI64_V_M1_MF4_MASK = 4999, + RISCV_PseudoVLUXEI64_V_M1_MF8 = 5000, + RISCV_PseudoVLUXEI64_V_M1_MF8_MASK = 5001, + RISCV_PseudoVLUXEI64_V_M2_M1 = 5002, + RISCV_PseudoVLUXEI64_V_M2_M1_MASK = 5003, + RISCV_PseudoVLUXEI64_V_M2_M2 = 5004, + RISCV_PseudoVLUXEI64_V_M2_M2_MASK = 5005, + RISCV_PseudoVLUXEI64_V_M2_MF2 = 5006, + RISCV_PseudoVLUXEI64_V_M2_MF2_MASK = 5007, + RISCV_PseudoVLUXEI64_V_M2_MF4 = 5008, + RISCV_PseudoVLUXEI64_V_M2_MF4_MASK = 5009, + RISCV_PseudoVLUXEI64_V_M4_M1 = 5010, + RISCV_PseudoVLUXEI64_V_M4_M1_MASK = 5011, + RISCV_PseudoVLUXEI64_V_M4_M2 = 5012, + RISCV_PseudoVLUXEI64_V_M4_M2_MASK = 5013, + RISCV_PseudoVLUXEI64_V_M4_M4 = 5014, + RISCV_PseudoVLUXEI64_V_M4_M4_MASK = 5015, + RISCV_PseudoVLUXEI64_V_M4_MF2 = 5016, + RISCV_PseudoVLUXEI64_V_M4_MF2_MASK = 5017, + RISCV_PseudoVLUXEI64_V_M8_M1 = 5018, + RISCV_PseudoVLUXEI64_V_M8_M1_MASK = 5019, + RISCV_PseudoVLUXEI64_V_M8_M2 = 5020, + RISCV_PseudoVLUXEI64_V_M8_M2_MASK = 5021, + RISCV_PseudoVLUXEI64_V_M8_M4 = 5022, + RISCV_PseudoVLUXEI64_V_M8_M4_MASK = 5023, + RISCV_PseudoVLUXEI64_V_M8_M8 = 5024, + RISCV_PseudoVLUXEI64_V_M8_M8_MASK = 5025, + RISCV_PseudoVLUXEI8_V_M1_M1 = 5026, + RISCV_PseudoVLUXEI8_V_M1_M1_MASK = 5027, + RISCV_PseudoVLUXEI8_V_M1_M2 = 5028, + RISCV_PseudoVLUXEI8_V_M1_M2_MASK = 5029, + RISCV_PseudoVLUXEI8_V_M1_M4 = 5030, + RISCV_PseudoVLUXEI8_V_M1_M4_MASK = 5031, + RISCV_PseudoVLUXEI8_V_M1_M8 = 5032, + RISCV_PseudoVLUXEI8_V_M1_M8_MASK = 5033, + RISCV_PseudoVLUXEI8_V_M2_M2 = 5034, + RISCV_PseudoVLUXEI8_V_M2_M2_MASK = 5035, + RISCV_PseudoVLUXEI8_V_M2_M4 = 5036, + RISCV_PseudoVLUXEI8_V_M2_M4_MASK = 5037, + RISCV_PseudoVLUXEI8_V_M2_M8 = 5038, + RISCV_PseudoVLUXEI8_V_M2_M8_MASK = 5039, + RISCV_PseudoVLUXEI8_V_M4_M4 = 5040, + RISCV_PseudoVLUXEI8_V_M4_M4_MASK = 5041, + RISCV_PseudoVLUXEI8_V_M4_M8 = 5042, + RISCV_PseudoVLUXEI8_V_M4_M8_MASK = 5043, + RISCV_PseudoVLUXEI8_V_M8_M8 = 5044, + RISCV_PseudoVLUXEI8_V_M8_M8_MASK = 5045, + RISCV_PseudoVLUXEI8_V_MF2_M1 = 5046, + RISCV_PseudoVLUXEI8_V_MF2_M1_MASK = 5047, + RISCV_PseudoVLUXEI8_V_MF2_M2 = 5048, + RISCV_PseudoVLUXEI8_V_MF2_M2_MASK = 5049, + RISCV_PseudoVLUXEI8_V_MF2_M4 = 5050, + RISCV_PseudoVLUXEI8_V_MF2_M4_MASK = 5051, + RISCV_PseudoVLUXEI8_V_MF2_MF2 = 5052, + RISCV_PseudoVLUXEI8_V_MF2_MF2_MASK = 5053, + RISCV_PseudoVLUXEI8_V_MF4_M1 = 5054, + RISCV_PseudoVLUXEI8_V_MF4_M1_MASK = 5055, + RISCV_PseudoVLUXEI8_V_MF4_M2 = 5056, + RISCV_PseudoVLUXEI8_V_MF4_M2_MASK = 5057, + RISCV_PseudoVLUXEI8_V_MF4_MF2 = 5058, + RISCV_PseudoVLUXEI8_V_MF4_MF2_MASK = 5059, + RISCV_PseudoVLUXEI8_V_MF4_MF4 = 5060, + RISCV_PseudoVLUXEI8_V_MF4_MF4_MASK = 5061, + RISCV_PseudoVLUXEI8_V_MF8_M1 = 5062, + RISCV_PseudoVLUXEI8_V_MF8_M1_MASK = 5063, + RISCV_PseudoVLUXEI8_V_MF8_MF2 = 5064, + RISCV_PseudoVLUXEI8_V_MF8_MF2_MASK = 5065, + RISCV_PseudoVLUXEI8_V_MF8_MF4 = 5066, + RISCV_PseudoVLUXEI8_V_MF8_MF4_MASK = 5067, + RISCV_PseudoVLUXEI8_V_MF8_MF8 = 5068, + RISCV_PseudoVLUXEI8_V_MF8_MF8_MASK = 5069, + RISCV_PseudoVLUXSEG2EI16_V_M1_M1 = 5070, + RISCV_PseudoVLUXSEG2EI16_V_M1_M1_MASK = 5071, + RISCV_PseudoVLUXSEG2EI16_V_M1_M2 = 5072, + RISCV_PseudoVLUXSEG2EI16_V_M1_M2_MASK = 5073, + RISCV_PseudoVLUXSEG2EI16_V_M1_M4 = 5074, + RISCV_PseudoVLUXSEG2EI16_V_M1_M4_MASK = 5075, + RISCV_PseudoVLUXSEG2EI16_V_M1_MF2 = 5076, + RISCV_PseudoVLUXSEG2EI16_V_M1_MF2_MASK = 5077, + RISCV_PseudoVLUXSEG2EI16_V_M2_M1 = 5078, + RISCV_PseudoVLUXSEG2EI16_V_M2_M1_MASK = 5079, + RISCV_PseudoVLUXSEG2EI16_V_M2_M2 = 5080, + RISCV_PseudoVLUXSEG2EI16_V_M2_M2_MASK = 5081, + RISCV_PseudoVLUXSEG2EI16_V_M2_M4 = 5082, + RISCV_PseudoVLUXSEG2EI16_V_M2_M4_MASK = 5083, + RISCV_PseudoVLUXSEG2EI16_V_M4_M2 = 5084, + RISCV_PseudoVLUXSEG2EI16_V_M4_M2_MASK = 5085, + RISCV_PseudoVLUXSEG2EI16_V_M4_M4 = 5086, + RISCV_PseudoVLUXSEG2EI16_V_M4_M4_MASK = 5087, + RISCV_PseudoVLUXSEG2EI16_V_M8_M4 = 5088, + RISCV_PseudoVLUXSEG2EI16_V_M8_M4_MASK = 5089, + RISCV_PseudoVLUXSEG2EI16_V_MF2_M1 = 5090, + RISCV_PseudoVLUXSEG2EI16_V_MF2_M1_MASK = 5091, + RISCV_PseudoVLUXSEG2EI16_V_MF2_M2 = 5092, + RISCV_PseudoVLUXSEG2EI16_V_MF2_M2_MASK = 5093, + RISCV_PseudoVLUXSEG2EI16_V_MF2_MF2 = 5094, + RISCV_PseudoVLUXSEG2EI16_V_MF2_MF2_MASK = 5095, + RISCV_PseudoVLUXSEG2EI16_V_MF2_MF4 = 5096, + RISCV_PseudoVLUXSEG2EI16_V_MF2_MF4_MASK = 5097, + RISCV_PseudoVLUXSEG2EI16_V_MF4_M1 = 5098, + RISCV_PseudoVLUXSEG2EI16_V_MF4_M1_MASK = 5099, + RISCV_PseudoVLUXSEG2EI16_V_MF4_MF2 = 5100, + RISCV_PseudoVLUXSEG2EI16_V_MF4_MF2_MASK = 5101, + RISCV_PseudoVLUXSEG2EI16_V_MF4_MF4 = 5102, + RISCV_PseudoVLUXSEG2EI16_V_MF4_MF4_MASK = 5103, + RISCV_PseudoVLUXSEG2EI16_V_MF4_MF8 = 5104, + RISCV_PseudoVLUXSEG2EI16_V_MF4_MF8_MASK = 5105, + RISCV_PseudoVLUXSEG2EI32_V_M1_M1 = 5106, + RISCV_PseudoVLUXSEG2EI32_V_M1_M1_MASK = 5107, + RISCV_PseudoVLUXSEG2EI32_V_M1_M2 = 5108, + RISCV_PseudoVLUXSEG2EI32_V_M1_M2_MASK = 5109, + RISCV_PseudoVLUXSEG2EI32_V_M1_MF2 = 5110, + RISCV_PseudoVLUXSEG2EI32_V_M1_MF2_MASK = 5111, + RISCV_PseudoVLUXSEG2EI32_V_M1_MF4 = 5112, + RISCV_PseudoVLUXSEG2EI32_V_M1_MF4_MASK = 5113, + RISCV_PseudoVLUXSEG2EI32_V_M2_M1 = 5114, + RISCV_PseudoVLUXSEG2EI32_V_M2_M1_MASK = 5115, + RISCV_PseudoVLUXSEG2EI32_V_M2_M2 = 5116, + RISCV_PseudoVLUXSEG2EI32_V_M2_M2_MASK = 5117, + RISCV_PseudoVLUXSEG2EI32_V_M2_M4 = 5118, + RISCV_PseudoVLUXSEG2EI32_V_M2_M4_MASK = 5119, + RISCV_PseudoVLUXSEG2EI32_V_M2_MF2 = 5120, + RISCV_PseudoVLUXSEG2EI32_V_M2_MF2_MASK = 5121, + RISCV_PseudoVLUXSEG2EI32_V_M4_M1 = 5122, + RISCV_PseudoVLUXSEG2EI32_V_M4_M1_MASK = 5123, + RISCV_PseudoVLUXSEG2EI32_V_M4_M2 = 5124, + RISCV_PseudoVLUXSEG2EI32_V_M4_M2_MASK = 5125, + RISCV_PseudoVLUXSEG2EI32_V_M4_M4 = 5126, + RISCV_PseudoVLUXSEG2EI32_V_M4_M4_MASK = 5127, + RISCV_PseudoVLUXSEG2EI32_V_M8_M2 = 5128, + RISCV_PseudoVLUXSEG2EI32_V_M8_M2_MASK = 5129, + RISCV_PseudoVLUXSEG2EI32_V_M8_M4 = 5130, + RISCV_PseudoVLUXSEG2EI32_V_M8_M4_MASK = 5131, + RISCV_PseudoVLUXSEG2EI32_V_MF2_M1 = 5132, + RISCV_PseudoVLUXSEG2EI32_V_MF2_M1_MASK = 5133, + RISCV_PseudoVLUXSEG2EI32_V_MF2_MF2 = 5134, + RISCV_PseudoVLUXSEG2EI32_V_MF2_MF2_MASK = 5135, + RISCV_PseudoVLUXSEG2EI32_V_MF2_MF4 = 5136, + RISCV_PseudoVLUXSEG2EI32_V_MF2_MF4_MASK = 5137, + RISCV_PseudoVLUXSEG2EI32_V_MF2_MF8 = 5138, + RISCV_PseudoVLUXSEG2EI32_V_MF2_MF8_MASK = 5139, + RISCV_PseudoVLUXSEG2EI64_V_M1_M1 = 5140, + RISCV_PseudoVLUXSEG2EI64_V_M1_M1_MASK = 5141, + RISCV_PseudoVLUXSEG2EI64_V_M1_MF2 = 5142, + RISCV_PseudoVLUXSEG2EI64_V_M1_MF2_MASK = 5143, + RISCV_PseudoVLUXSEG2EI64_V_M1_MF4 = 5144, + RISCV_PseudoVLUXSEG2EI64_V_M1_MF4_MASK = 5145, + RISCV_PseudoVLUXSEG2EI64_V_M1_MF8 = 5146, + RISCV_PseudoVLUXSEG2EI64_V_M1_MF8_MASK = 5147, + RISCV_PseudoVLUXSEG2EI64_V_M2_M1 = 5148, + RISCV_PseudoVLUXSEG2EI64_V_M2_M1_MASK = 5149, + RISCV_PseudoVLUXSEG2EI64_V_M2_M2 = 5150, + RISCV_PseudoVLUXSEG2EI64_V_M2_M2_MASK = 5151, + RISCV_PseudoVLUXSEG2EI64_V_M2_MF2 = 5152, + RISCV_PseudoVLUXSEG2EI64_V_M2_MF2_MASK = 5153, + RISCV_PseudoVLUXSEG2EI64_V_M2_MF4 = 5154, + RISCV_PseudoVLUXSEG2EI64_V_M2_MF4_MASK = 5155, + RISCV_PseudoVLUXSEG2EI64_V_M4_M1 = 5156, + RISCV_PseudoVLUXSEG2EI64_V_M4_M1_MASK = 5157, + RISCV_PseudoVLUXSEG2EI64_V_M4_M2 = 5158, + RISCV_PseudoVLUXSEG2EI64_V_M4_M2_MASK = 5159, + RISCV_PseudoVLUXSEG2EI64_V_M4_M4 = 5160, + RISCV_PseudoVLUXSEG2EI64_V_M4_M4_MASK = 5161, + RISCV_PseudoVLUXSEG2EI64_V_M4_MF2 = 5162, + RISCV_PseudoVLUXSEG2EI64_V_M4_MF2_MASK = 5163, + RISCV_PseudoVLUXSEG2EI64_V_M8_M1 = 5164, + RISCV_PseudoVLUXSEG2EI64_V_M8_M1_MASK = 5165, + RISCV_PseudoVLUXSEG2EI64_V_M8_M2 = 5166, + RISCV_PseudoVLUXSEG2EI64_V_M8_M2_MASK = 5167, + RISCV_PseudoVLUXSEG2EI64_V_M8_M4 = 5168, + RISCV_PseudoVLUXSEG2EI64_V_M8_M4_MASK = 5169, + RISCV_PseudoVLUXSEG2EI8_V_M1_M1 = 5170, + RISCV_PseudoVLUXSEG2EI8_V_M1_M1_MASK = 5171, + RISCV_PseudoVLUXSEG2EI8_V_M1_M2 = 5172, + RISCV_PseudoVLUXSEG2EI8_V_M1_M2_MASK = 5173, + RISCV_PseudoVLUXSEG2EI8_V_M1_M4 = 5174, + RISCV_PseudoVLUXSEG2EI8_V_M1_M4_MASK = 5175, + RISCV_PseudoVLUXSEG2EI8_V_M2_M2 = 5176, + RISCV_PseudoVLUXSEG2EI8_V_M2_M2_MASK = 5177, + RISCV_PseudoVLUXSEG2EI8_V_M2_M4 = 5178, + RISCV_PseudoVLUXSEG2EI8_V_M2_M4_MASK = 5179, + RISCV_PseudoVLUXSEG2EI8_V_M4_M4 = 5180, + RISCV_PseudoVLUXSEG2EI8_V_M4_M4_MASK = 5181, + RISCV_PseudoVLUXSEG2EI8_V_MF2_M1 = 5182, + RISCV_PseudoVLUXSEG2EI8_V_MF2_M1_MASK = 5183, + RISCV_PseudoVLUXSEG2EI8_V_MF2_M2 = 5184, + RISCV_PseudoVLUXSEG2EI8_V_MF2_M2_MASK = 5185, + RISCV_PseudoVLUXSEG2EI8_V_MF2_M4 = 5186, + RISCV_PseudoVLUXSEG2EI8_V_MF2_M4_MASK = 5187, + RISCV_PseudoVLUXSEG2EI8_V_MF2_MF2 = 5188, + RISCV_PseudoVLUXSEG2EI8_V_MF2_MF2_MASK = 5189, + RISCV_PseudoVLUXSEG2EI8_V_MF4_M1 = 5190, + RISCV_PseudoVLUXSEG2EI8_V_MF4_M1_MASK = 5191, + RISCV_PseudoVLUXSEG2EI8_V_MF4_M2 = 5192, + RISCV_PseudoVLUXSEG2EI8_V_MF4_M2_MASK = 5193, + RISCV_PseudoVLUXSEG2EI8_V_MF4_MF2 = 5194, + RISCV_PseudoVLUXSEG2EI8_V_MF4_MF2_MASK = 5195, + RISCV_PseudoVLUXSEG2EI8_V_MF4_MF4 = 5196, + RISCV_PseudoVLUXSEG2EI8_V_MF4_MF4_MASK = 5197, + RISCV_PseudoVLUXSEG2EI8_V_MF8_M1 = 5198, + RISCV_PseudoVLUXSEG2EI8_V_MF8_M1_MASK = 5199, + RISCV_PseudoVLUXSEG2EI8_V_MF8_MF2 = 5200, + RISCV_PseudoVLUXSEG2EI8_V_MF8_MF2_MASK = 5201, + RISCV_PseudoVLUXSEG2EI8_V_MF8_MF4 = 5202, + RISCV_PseudoVLUXSEG2EI8_V_MF8_MF4_MASK = 5203, + RISCV_PseudoVLUXSEG2EI8_V_MF8_MF8 = 5204, + RISCV_PseudoVLUXSEG2EI8_V_MF8_MF8_MASK = 5205, + RISCV_PseudoVLUXSEG3EI16_V_M1_M1 = 5206, + RISCV_PseudoVLUXSEG3EI16_V_M1_M1_MASK = 5207, + RISCV_PseudoVLUXSEG3EI16_V_M1_M2 = 5208, + RISCV_PseudoVLUXSEG3EI16_V_M1_M2_MASK = 5209, + RISCV_PseudoVLUXSEG3EI16_V_M1_MF2 = 5210, + RISCV_PseudoVLUXSEG3EI16_V_M1_MF2_MASK = 5211, + RISCV_PseudoVLUXSEG3EI16_V_M2_M1 = 5212, + RISCV_PseudoVLUXSEG3EI16_V_M2_M1_MASK = 5213, + RISCV_PseudoVLUXSEG3EI16_V_M2_M2 = 5214, + RISCV_PseudoVLUXSEG3EI16_V_M2_M2_MASK = 5215, + RISCV_PseudoVLUXSEG3EI16_V_M4_M2 = 5216, + RISCV_PseudoVLUXSEG3EI16_V_M4_M2_MASK = 5217, + RISCV_PseudoVLUXSEG3EI16_V_MF2_M1 = 5218, + RISCV_PseudoVLUXSEG3EI16_V_MF2_M1_MASK = 5219, + RISCV_PseudoVLUXSEG3EI16_V_MF2_M2 = 5220, + RISCV_PseudoVLUXSEG3EI16_V_MF2_M2_MASK = 5221, + RISCV_PseudoVLUXSEG3EI16_V_MF2_MF2 = 5222, + RISCV_PseudoVLUXSEG3EI16_V_MF2_MF2_MASK = 5223, + RISCV_PseudoVLUXSEG3EI16_V_MF2_MF4 = 5224, + RISCV_PseudoVLUXSEG3EI16_V_MF2_MF4_MASK = 5225, + RISCV_PseudoVLUXSEG3EI16_V_MF4_M1 = 5226, + RISCV_PseudoVLUXSEG3EI16_V_MF4_M1_MASK = 5227, + RISCV_PseudoVLUXSEG3EI16_V_MF4_MF2 = 5228, + RISCV_PseudoVLUXSEG3EI16_V_MF4_MF2_MASK = 5229, + RISCV_PseudoVLUXSEG3EI16_V_MF4_MF4 = 5230, + RISCV_PseudoVLUXSEG3EI16_V_MF4_MF4_MASK = 5231, + RISCV_PseudoVLUXSEG3EI16_V_MF4_MF8 = 5232, + RISCV_PseudoVLUXSEG3EI16_V_MF4_MF8_MASK = 5233, + RISCV_PseudoVLUXSEG3EI32_V_M1_M1 = 5234, + RISCV_PseudoVLUXSEG3EI32_V_M1_M1_MASK = 5235, + RISCV_PseudoVLUXSEG3EI32_V_M1_M2 = 5236, + RISCV_PseudoVLUXSEG3EI32_V_M1_M2_MASK = 5237, + RISCV_PseudoVLUXSEG3EI32_V_M1_MF2 = 5238, + RISCV_PseudoVLUXSEG3EI32_V_M1_MF2_MASK = 5239, + RISCV_PseudoVLUXSEG3EI32_V_M1_MF4 = 5240, + RISCV_PseudoVLUXSEG3EI32_V_M1_MF4_MASK = 5241, + RISCV_PseudoVLUXSEG3EI32_V_M2_M1 = 5242, + RISCV_PseudoVLUXSEG3EI32_V_M2_M1_MASK = 5243, + RISCV_PseudoVLUXSEG3EI32_V_M2_M2 = 5244, + RISCV_PseudoVLUXSEG3EI32_V_M2_M2_MASK = 5245, + RISCV_PseudoVLUXSEG3EI32_V_M2_MF2 = 5246, + RISCV_PseudoVLUXSEG3EI32_V_M2_MF2_MASK = 5247, + RISCV_PseudoVLUXSEG3EI32_V_M4_M1 = 5248, + RISCV_PseudoVLUXSEG3EI32_V_M4_M1_MASK = 5249, + RISCV_PseudoVLUXSEG3EI32_V_M4_M2 = 5250, + RISCV_PseudoVLUXSEG3EI32_V_M4_M2_MASK = 5251, + RISCV_PseudoVLUXSEG3EI32_V_M8_M2 = 5252, + RISCV_PseudoVLUXSEG3EI32_V_M8_M2_MASK = 5253, + RISCV_PseudoVLUXSEG3EI32_V_MF2_M1 = 5254, + RISCV_PseudoVLUXSEG3EI32_V_MF2_M1_MASK = 5255, + RISCV_PseudoVLUXSEG3EI32_V_MF2_MF2 = 5256, + RISCV_PseudoVLUXSEG3EI32_V_MF2_MF2_MASK = 5257, + RISCV_PseudoVLUXSEG3EI32_V_MF2_MF4 = 5258, + RISCV_PseudoVLUXSEG3EI32_V_MF2_MF4_MASK = 5259, + RISCV_PseudoVLUXSEG3EI32_V_MF2_MF8 = 5260, + RISCV_PseudoVLUXSEG3EI32_V_MF2_MF8_MASK = 5261, + RISCV_PseudoVLUXSEG3EI64_V_M1_M1 = 5262, + RISCV_PseudoVLUXSEG3EI64_V_M1_M1_MASK = 5263, + RISCV_PseudoVLUXSEG3EI64_V_M1_MF2 = 5264, + RISCV_PseudoVLUXSEG3EI64_V_M1_MF2_MASK = 5265, + RISCV_PseudoVLUXSEG3EI64_V_M1_MF4 = 5266, + RISCV_PseudoVLUXSEG3EI64_V_M1_MF4_MASK = 5267, + RISCV_PseudoVLUXSEG3EI64_V_M1_MF8 = 5268, + RISCV_PseudoVLUXSEG3EI64_V_M1_MF8_MASK = 5269, + RISCV_PseudoVLUXSEG3EI64_V_M2_M1 = 5270, + RISCV_PseudoVLUXSEG3EI64_V_M2_M1_MASK = 5271, + RISCV_PseudoVLUXSEG3EI64_V_M2_M2 = 5272, + RISCV_PseudoVLUXSEG3EI64_V_M2_M2_MASK = 5273, + RISCV_PseudoVLUXSEG3EI64_V_M2_MF2 = 5274, + RISCV_PseudoVLUXSEG3EI64_V_M2_MF2_MASK = 5275, + RISCV_PseudoVLUXSEG3EI64_V_M2_MF4 = 5276, + RISCV_PseudoVLUXSEG3EI64_V_M2_MF4_MASK = 5277, + RISCV_PseudoVLUXSEG3EI64_V_M4_M1 = 5278, + RISCV_PseudoVLUXSEG3EI64_V_M4_M1_MASK = 5279, + RISCV_PseudoVLUXSEG3EI64_V_M4_M2 = 5280, + RISCV_PseudoVLUXSEG3EI64_V_M4_M2_MASK = 5281, + RISCV_PseudoVLUXSEG3EI64_V_M4_MF2 = 5282, + RISCV_PseudoVLUXSEG3EI64_V_M4_MF2_MASK = 5283, + RISCV_PseudoVLUXSEG3EI64_V_M8_M1 = 5284, + RISCV_PseudoVLUXSEG3EI64_V_M8_M1_MASK = 5285, + RISCV_PseudoVLUXSEG3EI64_V_M8_M2 = 5286, + RISCV_PseudoVLUXSEG3EI64_V_M8_M2_MASK = 5287, + RISCV_PseudoVLUXSEG3EI8_V_M1_M1 = 5288, + RISCV_PseudoVLUXSEG3EI8_V_M1_M1_MASK = 5289, + RISCV_PseudoVLUXSEG3EI8_V_M1_M2 = 5290, + RISCV_PseudoVLUXSEG3EI8_V_M1_M2_MASK = 5291, + RISCV_PseudoVLUXSEG3EI8_V_M2_M2 = 5292, + RISCV_PseudoVLUXSEG3EI8_V_M2_M2_MASK = 5293, + RISCV_PseudoVLUXSEG3EI8_V_MF2_M1 = 5294, + RISCV_PseudoVLUXSEG3EI8_V_MF2_M1_MASK = 5295, + RISCV_PseudoVLUXSEG3EI8_V_MF2_M2 = 5296, + RISCV_PseudoVLUXSEG3EI8_V_MF2_M2_MASK = 5297, + RISCV_PseudoVLUXSEG3EI8_V_MF2_MF2 = 5298, + RISCV_PseudoVLUXSEG3EI8_V_MF2_MF2_MASK = 5299, + RISCV_PseudoVLUXSEG3EI8_V_MF4_M1 = 5300, + RISCV_PseudoVLUXSEG3EI8_V_MF4_M1_MASK = 5301, + RISCV_PseudoVLUXSEG3EI8_V_MF4_M2 = 5302, + RISCV_PseudoVLUXSEG3EI8_V_MF4_M2_MASK = 5303, + RISCV_PseudoVLUXSEG3EI8_V_MF4_MF2 = 5304, + RISCV_PseudoVLUXSEG3EI8_V_MF4_MF2_MASK = 5305, + RISCV_PseudoVLUXSEG3EI8_V_MF4_MF4 = 5306, + RISCV_PseudoVLUXSEG3EI8_V_MF4_MF4_MASK = 5307, + RISCV_PseudoVLUXSEG3EI8_V_MF8_M1 = 5308, + RISCV_PseudoVLUXSEG3EI8_V_MF8_M1_MASK = 5309, + RISCV_PseudoVLUXSEG3EI8_V_MF8_MF2 = 5310, + RISCV_PseudoVLUXSEG3EI8_V_MF8_MF2_MASK = 5311, + RISCV_PseudoVLUXSEG3EI8_V_MF8_MF4 = 5312, + RISCV_PseudoVLUXSEG3EI8_V_MF8_MF4_MASK = 5313, + RISCV_PseudoVLUXSEG3EI8_V_MF8_MF8 = 5314, + RISCV_PseudoVLUXSEG3EI8_V_MF8_MF8_MASK = 5315, + RISCV_PseudoVLUXSEG4EI16_V_M1_M1 = 5316, + RISCV_PseudoVLUXSEG4EI16_V_M1_M1_MASK = 5317, + RISCV_PseudoVLUXSEG4EI16_V_M1_M2 = 5318, + RISCV_PseudoVLUXSEG4EI16_V_M1_M2_MASK = 5319, + RISCV_PseudoVLUXSEG4EI16_V_M1_MF2 = 5320, + RISCV_PseudoVLUXSEG4EI16_V_M1_MF2_MASK = 5321, + RISCV_PseudoVLUXSEG4EI16_V_M2_M1 = 5322, + RISCV_PseudoVLUXSEG4EI16_V_M2_M1_MASK = 5323, + RISCV_PseudoVLUXSEG4EI16_V_M2_M2 = 5324, + RISCV_PseudoVLUXSEG4EI16_V_M2_M2_MASK = 5325, + RISCV_PseudoVLUXSEG4EI16_V_M4_M2 = 5326, + RISCV_PseudoVLUXSEG4EI16_V_M4_M2_MASK = 5327, + RISCV_PseudoVLUXSEG4EI16_V_MF2_M1 = 5328, + RISCV_PseudoVLUXSEG4EI16_V_MF2_M1_MASK = 5329, + RISCV_PseudoVLUXSEG4EI16_V_MF2_M2 = 5330, + RISCV_PseudoVLUXSEG4EI16_V_MF2_M2_MASK = 5331, + RISCV_PseudoVLUXSEG4EI16_V_MF2_MF2 = 5332, + RISCV_PseudoVLUXSEG4EI16_V_MF2_MF2_MASK = 5333, + RISCV_PseudoVLUXSEG4EI16_V_MF2_MF4 = 5334, + RISCV_PseudoVLUXSEG4EI16_V_MF2_MF4_MASK = 5335, + RISCV_PseudoVLUXSEG4EI16_V_MF4_M1 = 5336, + RISCV_PseudoVLUXSEG4EI16_V_MF4_M1_MASK = 5337, + RISCV_PseudoVLUXSEG4EI16_V_MF4_MF2 = 5338, + RISCV_PseudoVLUXSEG4EI16_V_MF4_MF2_MASK = 5339, + RISCV_PseudoVLUXSEG4EI16_V_MF4_MF4 = 5340, + RISCV_PseudoVLUXSEG4EI16_V_MF4_MF4_MASK = 5341, + RISCV_PseudoVLUXSEG4EI16_V_MF4_MF8 = 5342, + RISCV_PseudoVLUXSEG4EI16_V_MF4_MF8_MASK = 5343, + RISCV_PseudoVLUXSEG4EI32_V_M1_M1 = 5344, + RISCV_PseudoVLUXSEG4EI32_V_M1_M1_MASK = 5345, + RISCV_PseudoVLUXSEG4EI32_V_M1_M2 = 5346, + RISCV_PseudoVLUXSEG4EI32_V_M1_M2_MASK = 5347, + RISCV_PseudoVLUXSEG4EI32_V_M1_MF2 = 5348, + RISCV_PseudoVLUXSEG4EI32_V_M1_MF2_MASK = 5349, + RISCV_PseudoVLUXSEG4EI32_V_M1_MF4 = 5350, + RISCV_PseudoVLUXSEG4EI32_V_M1_MF4_MASK = 5351, + RISCV_PseudoVLUXSEG4EI32_V_M2_M1 = 5352, + RISCV_PseudoVLUXSEG4EI32_V_M2_M1_MASK = 5353, + RISCV_PseudoVLUXSEG4EI32_V_M2_M2 = 5354, + RISCV_PseudoVLUXSEG4EI32_V_M2_M2_MASK = 5355, + RISCV_PseudoVLUXSEG4EI32_V_M2_MF2 = 5356, + RISCV_PseudoVLUXSEG4EI32_V_M2_MF2_MASK = 5357, + RISCV_PseudoVLUXSEG4EI32_V_M4_M1 = 5358, + RISCV_PseudoVLUXSEG4EI32_V_M4_M1_MASK = 5359, + RISCV_PseudoVLUXSEG4EI32_V_M4_M2 = 5360, + RISCV_PseudoVLUXSEG4EI32_V_M4_M2_MASK = 5361, + RISCV_PseudoVLUXSEG4EI32_V_M8_M2 = 5362, + RISCV_PseudoVLUXSEG4EI32_V_M8_M2_MASK = 5363, + RISCV_PseudoVLUXSEG4EI32_V_MF2_M1 = 5364, + RISCV_PseudoVLUXSEG4EI32_V_MF2_M1_MASK = 5365, + RISCV_PseudoVLUXSEG4EI32_V_MF2_MF2 = 5366, + RISCV_PseudoVLUXSEG4EI32_V_MF2_MF2_MASK = 5367, + RISCV_PseudoVLUXSEG4EI32_V_MF2_MF4 = 5368, + RISCV_PseudoVLUXSEG4EI32_V_MF2_MF4_MASK = 5369, + RISCV_PseudoVLUXSEG4EI32_V_MF2_MF8 = 5370, + RISCV_PseudoVLUXSEG4EI32_V_MF2_MF8_MASK = 5371, + RISCV_PseudoVLUXSEG4EI64_V_M1_M1 = 5372, + RISCV_PseudoVLUXSEG4EI64_V_M1_M1_MASK = 5373, + RISCV_PseudoVLUXSEG4EI64_V_M1_MF2 = 5374, + RISCV_PseudoVLUXSEG4EI64_V_M1_MF2_MASK = 5375, + RISCV_PseudoVLUXSEG4EI64_V_M1_MF4 = 5376, + RISCV_PseudoVLUXSEG4EI64_V_M1_MF4_MASK = 5377, + RISCV_PseudoVLUXSEG4EI64_V_M1_MF8 = 5378, + RISCV_PseudoVLUXSEG4EI64_V_M1_MF8_MASK = 5379, + RISCV_PseudoVLUXSEG4EI64_V_M2_M1 = 5380, + RISCV_PseudoVLUXSEG4EI64_V_M2_M1_MASK = 5381, + RISCV_PseudoVLUXSEG4EI64_V_M2_M2 = 5382, + RISCV_PseudoVLUXSEG4EI64_V_M2_M2_MASK = 5383, + RISCV_PseudoVLUXSEG4EI64_V_M2_MF2 = 5384, + RISCV_PseudoVLUXSEG4EI64_V_M2_MF2_MASK = 5385, + RISCV_PseudoVLUXSEG4EI64_V_M2_MF4 = 5386, + RISCV_PseudoVLUXSEG4EI64_V_M2_MF4_MASK = 5387, + RISCV_PseudoVLUXSEG4EI64_V_M4_M1 = 5388, + RISCV_PseudoVLUXSEG4EI64_V_M4_M1_MASK = 5389, + RISCV_PseudoVLUXSEG4EI64_V_M4_M2 = 5390, + RISCV_PseudoVLUXSEG4EI64_V_M4_M2_MASK = 5391, + RISCV_PseudoVLUXSEG4EI64_V_M4_MF2 = 5392, + RISCV_PseudoVLUXSEG4EI64_V_M4_MF2_MASK = 5393, + RISCV_PseudoVLUXSEG4EI64_V_M8_M1 = 5394, + RISCV_PseudoVLUXSEG4EI64_V_M8_M1_MASK = 5395, + RISCV_PseudoVLUXSEG4EI64_V_M8_M2 = 5396, + RISCV_PseudoVLUXSEG4EI64_V_M8_M2_MASK = 5397, + RISCV_PseudoVLUXSEG4EI8_V_M1_M1 = 5398, + RISCV_PseudoVLUXSEG4EI8_V_M1_M1_MASK = 5399, + RISCV_PseudoVLUXSEG4EI8_V_M1_M2 = 5400, + RISCV_PseudoVLUXSEG4EI8_V_M1_M2_MASK = 5401, + RISCV_PseudoVLUXSEG4EI8_V_M2_M2 = 5402, + RISCV_PseudoVLUXSEG4EI8_V_M2_M2_MASK = 5403, + RISCV_PseudoVLUXSEG4EI8_V_MF2_M1 = 5404, + RISCV_PseudoVLUXSEG4EI8_V_MF2_M1_MASK = 5405, + RISCV_PseudoVLUXSEG4EI8_V_MF2_M2 = 5406, + RISCV_PseudoVLUXSEG4EI8_V_MF2_M2_MASK = 5407, + RISCV_PseudoVLUXSEG4EI8_V_MF2_MF2 = 5408, + RISCV_PseudoVLUXSEG4EI8_V_MF2_MF2_MASK = 5409, + RISCV_PseudoVLUXSEG4EI8_V_MF4_M1 = 5410, + RISCV_PseudoVLUXSEG4EI8_V_MF4_M1_MASK = 5411, + RISCV_PseudoVLUXSEG4EI8_V_MF4_M2 = 5412, + RISCV_PseudoVLUXSEG4EI8_V_MF4_M2_MASK = 5413, + RISCV_PseudoVLUXSEG4EI8_V_MF4_MF2 = 5414, + RISCV_PseudoVLUXSEG4EI8_V_MF4_MF2_MASK = 5415, + RISCV_PseudoVLUXSEG4EI8_V_MF4_MF4 = 5416, + RISCV_PseudoVLUXSEG4EI8_V_MF4_MF4_MASK = 5417, + RISCV_PseudoVLUXSEG4EI8_V_MF8_M1 = 5418, + RISCV_PseudoVLUXSEG4EI8_V_MF8_M1_MASK = 5419, + RISCV_PseudoVLUXSEG4EI8_V_MF8_MF2 = 5420, + RISCV_PseudoVLUXSEG4EI8_V_MF8_MF2_MASK = 5421, + RISCV_PseudoVLUXSEG4EI8_V_MF8_MF4 = 5422, + RISCV_PseudoVLUXSEG4EI8_V_MF8_MF4_MASK = 5423, + RISCV_PseudoVLUXSEG4EI8_V_MF8_MF8 = 5424, + RISCV_PseudoVLUXSEG4EI8_V_MF8_MF8_MASK = 5425, + RISCV_PseudoVLUXSEG5EI16_V_M1_M1 = 5426, + RISCV_PseudoVLUXSEG5EI16_V_M1_M1_MASK = 5427, + RISCV_PseudoVLUXSEG5EI16_V_M1_MF2 = 5428, + RISCV_PseudoVLUXSEG5EI16_V_M1_MF2_MASK = 5429, + RISCV_PseudoVLUXSEG5EI16_V_M2_M1 = 5430, + RISCV_PseudoVLUXSEG5EI16_V_M2_M1_MASK = 5431, + RISCV_PseudoVLUXSEG5EI16_V_MF2_M1 = 5432, + RISCV_PseudoVLUXSEG5EI16_V_MF2_M1_MASK = 5433, + RISCV_PseudoVLUXSEG5EI16_V_MF2_MF2 = 5434, + RISCV_PseudoVLUXSEG5EI16_V_MF2_MF2_MASK = 5435, + RISCV_PseudoVLUXSEG5EI16_V_MF2_MF4 = 5436, + RISCV_PseudoVLUXSEG5EI16_V_MF2_MF4_MASK = 5437, + RISCV_PseudoVLUXSEG5EI16_V_MF4_M1 = 5438, + RISCV_PseudoVLUXSEG5EI16_V_MF4_M1_MASK = 5439, + RISCV_PseudoVLUXSEG5EI16_V_MF4_MF2 = 5440, + RISCV_PseudoVLUXSEG5EI16_V_MF4_MF2_MASK = 5441, + RISCV_PseudoVLUXSEG5EI16_V_MF4_MF4 = 5442, + RISCV_PseudoVLUXSEG5EI16_V_MF4_MF4_MASK = 5443, + RISCV_PseudoVLUXSEG5EI16_V_MF4_MF8 = 5444, + RISCV_PseudoVLUXSEG5EI16_V_MF4_MF8_MASK = 5445, + RISCV_PseudoVLUXSEG5EI32_V_M1_M1 = 5446, + RISCV_PseudoVLUXSEG5EI32_V_M1_M1_MASK = 5447, + RISCV_PseudoVLUXSEG5EI32_V_M1_MF2 = 5448, + RISCV_PseudoVLUXSEG5EI32_V_M1_MF2_MASK = 5449, + RISCV_PseudoVLUXSEG5EI32_V_M1_MF4 = 5450, + RISCV_PseudoVLUXSEG5EI32_V_M1_MF4_MASK = 5451, + RISCV_PseudoVLUXSEG5EI32_V_M2_M1 = 5452, + RISCV_PseudoVLUXSEG5EI32_V_M2_M1_MASK = 5453, + RISCV_PseudoVLUXSEG5EI32_V_M2_MF2 = 5454, + RISCV_PseudoVLUXSEG5EI32_V_M2_MF2_MASK = 5455, + RISCV_PseudoVLUXSEG5EI32_V_M4_M1 = 5456, + RISCV_PseudoVLUXSEG5EI32_V_M4_M1_MASK = 5457, + RISCV_PseudoVLUXSEG5EI32_V_MF2_M1 = 5458, + RISCV_PseudoVLUXSEG5EI32_V_MF2_M1_MASK = 5459, + RISCV_PseudoVLUXSEG5EI32_V_MF2_MF2 = 5460, + RISCV_PseudoVLUXSEG5EI32_V_MF2_MF2_MASK = 5461, + RISCV_PseudoVLUXSEG5EI32_V_MF2_MF4 = 5462, + RISCV_PseudoVLUXSEG5EI32_V_MF2_MF4_MASK = 5463, + RISCV_PseudoVLUXSEG5EI32_V_MF2_MF8 = 5464, + RISCV_PseudoVLUXSEG5EI32_V_MF2_MF8_MASK = 5465, + RISCV_PseudoVLUXSEG5EI64_V_M1_M1 = 5466, + RISCV_PseudoVLUXSEG5EI64_V_M1_M1_MASK = 5467, + RISCV_PseudoVLUXSEG5EI64_V_M1_MF2 = 5468, + RISCV_PseudoVLUXSEG5EI64_V_M1_MF2_MASK = 5469, + RISCV_PseudoVLUXSEG5EI64_V_M1_MF4 = 5470, + RISCV_PseudoVLUXSEG5EI64_V_M1_MF4_MASK = 5471, + RISCV_PseudoVLUXSEG5EI64_V_M1_MF8 = 5472, + RISCV_PseudoVLUXSEG5EI64_V_M1_MF8_MASK = 5473, + RISCV_PseudoVLUXSEG5EI64_V_M2_M1 = 5474, + RISCV_PseudoVLUXSEG5EI64_V_M2_M1_MASK = 5475, + RISCV_PseudoVLUXSEG5EI64_V_M2_MF2 = 5476, + RISCV_PseudoVLUXSEG5EI64_V_M2_MF2_MASK = 5477, + RISCV_PseudoVLUXSEG5EI64_V_M2_MF4 = 5478, + RISCV_PseudoVLUXSEG5EI64_V_M2_MF4_MASK = 5479, + RISCV_PseudoVLUXSEG5EI64_V_M4_M1 = 5480, + RISCV_PseudoVLUXSEG5EI64_V_M4_M1_MASK = 5481, + RISCV_PseudoVLUXSEG5EI64_V_M4_MF2 = 5482, + RISCV_PseudoVLUXSEG5EI64_V_M4_MF2_MASK = 5483, + RISCV_PseudoVLUXSEG5EI64_V_M8_M1 = 5484, + RISCV_PseudoVLUXSEG5EI64_V_M8_M1_MASK = 5485, + RISCV_PseudoVLUXSEG5EI8_V_M1_M1 = 5486, + RISCV_PseudoVLUXSEG5EI8_V_M1_M1_MASK = 5487, + RISCV_PseudoVLUXSEG5EI8_V_MF2_M1 = 5488, + RISCV_PseudoVLUXSEG5EI8_V_MF2_M1_MASK = 5489, + RISCV_PseudoVLUXSEG5EI8_V_MF2_MF2 = 5490, + RISCV_PseudoVLUXSEG5EI8_V_MF2_MF2_MASK = 5491, + RISCV_PseudoVLUXSEG5EI8_V_MF4_M1 = 5492, + RISCV_PseudoVLUXSEG5EI8_V_MF4_M1_MASK = 5493, + RISCV_PseudoVLUXSEG5EI8_V_MF4_MF2 = 5494, + RISCV_PseudoVLUXSEG5EI8_V_MF4_MF2_MASK = 5495, + RISCV_PseudoVLUXSEG5EI8_V_MF4_MF4 = 5496, + RISCV_PseudoVLUXSEG5EI8_V_MF4_MF4_MASK = 5497, + RISCV_PseudoVLUXSEG5EI8_V_MF8_M1 = 5498, + RISCV_PseudoVLUXSEG5EI8_V_MF8_M1_MASK = 5499, + RISCV_PseudoVLUXSEG5EI8_V_MF8_MF2 = 5500, + RISCV_PseudoVLUXSEG5EI8_V_MF8_MF2_MASK = 5501, + RISCV_PseudoVLUXSEG5EI8_V_MF8_MF4 = 5502, + RISCV_PseudoVLUXSEG5EI8_V_MF8_MF4_MASK = 5503, + RISCV_PseudoVLUXSEG5EI8_V_MF8_MF8 = 5504, + RISCV_PseudoVLUXSEG5EI8_V_MF8_MF8_MASK = 5505, + RISCV_PseudoVLUXSEG6EI16_V_M1_M1 = 5506, + RISCV_PseudoVLUXSEG6EI16_V_M1_M1_MASK = 5507, + RISCV_PseudoVLUXSEG6EI16_V_M1_MF2 = 5508, + RISCV_PseudoVLUXSEG6EI16_V_M1_MF2_MASK = 5509, + RISCV_PseudoVLUXSEG6EI16_V_M2_M1 = 5510, + RISCV_PseudoVLUXSEG6EI16_V_M2_M1_MASK = 5511, + RISCV_PseudoVLUXSEG6EI16_V_MF2_M1 = 5512, + RISCV_PseudoVLUXSEG6EI16_V_MF2_M1_MASK = 5513, + RISCV_PseudoVLUXSEG6EI16_V_MF2_MF2 = 5514, + RISCV_PseudoVLUXSEG6EI16_V_MF2_MF2_MASK = 5515, + RISCV_PseudoVLUXSEG6EI16_V_MF2_MF4 = 5516, + RISCV_PseudoVLUXSEG6EI16_V_MF2_MF4_MASK = 5517, + RISCV_PseudoVLUXSEG6EI16_V_MF4_M1 = 5518, + RISCV_PseudoVLUXSEG6EI16_V_MF4_M1_MASK = 5519, + RISCV_PseudoVLUXSEG6EI16_V_MF4_MF2 = 5520, + RISCV_PseudoVLUXSEG6EI16_V_MF4_MF2_MASK = 5521, + RISCV_PseudoVLUXSEG6EI16_V_MF4_MF4 = 5522, + RISCV_PseudoVLUXSEG6EI16_V_MF4_MF4_MASK = 5523, + RISCV_PseudoVLUXSEG6EI16_V_MF4_MF8 = 5524, + RISCV_PseudoVLUXSEG6EI16_V_MF4_MF8_MASK = 5525, + RISCV_PseudoVLUXSEG6EI32_V_M1_M1 = 5526, + RISCV_PseudoVLUXSEG6EI32_V_M1_M1_MASK = 5527, + RISCV_PseudoVLUXSEG6EI32_V_M1_MF2 = 5528, + RISCV_PseudoVLUXSEG6EI32_V_M1_MF2_MASK = 5529, + RISCV_PseudoVLUXSEG6EI32_V_M1_MF4 = 5530, + RISCV_PseudoVLUXSEG6EI32_V_M1_MF4_MASK = 5531, + RISCV_PseudoVLUXSEG6EI32_V_M2_M1 = 5532, + RISCV_PseudoVLUXSEG6EI32_V_M2_M1_MASK = 5533, + RISCV_PseudoVLUXSEG6EI32_V_M2_MF2 = 5534, + RISCV_PseudoVLUXSEG6EI32_V_M2_MF2_MASK = 5535, + RISCV_PseudoVLUXSEG6EI32_V_M4_M1 = 5536, + RISCV_PseudoVLUXSEG6EI32_V_M4_M1_MASK = 5537, + RISCV_PseudoVLUXSEG6EI32_V_MF2_M1 = 5538, + RISCV_PseudoVLUXSEG6EI32_V_MF2_M1_MASK = 5539, + RISCV_PseudoVLUXSEG6EI32_V_MF2_MF2 = 5540, + RISCV_PseudoVLUXSEG6EI32_V_MF2_MF2_MASK = 5541, + RISCV_PseudoVLUXSEG6EI32_V_MF2_MF4 = 5542, + RISCV_PseudoVLUXSEG6EI32_V_MF2_MF4_MASK = 5543, + RISCV_PseudoVLUXSEG6EI32_V_MF2_MF8 = 5544, + RISCV_PseudoVLUXSEG6EI32_V_MF2_MF8_MASK = 5545, + RISCV_PseudoVLUXSEG6EI64_V_M1_M1 = 5546, + RISCV_PseudoVLUXSEG6EI64_V_M1_M1_MASK = 5547, + RISCV_PseudoVLUXSEG6EI64_V_M1_MF2 = 5548, + RISCV_PseudoVLUXSEG6EI64_V_M1_MF2_MASK = 5549, + RISCV_PseudoVLUXSEG6EI64_V_M1_MF4 = 5550, + RISCV_PseudoVLUXSEG6EI64_V_M1_MF4_MASK = 5551, + RISCV_PseudoVLUXSEG6EI64_V_M1_MF8 = 5552, + RISCV_PseudoVLUXSEG6EI64_V_M1_MF8_MASK = 5553, + RISCV_PseudoVLUXSEG6EI64_V_M2_M1 = 5554, + RISCV_PseudoVLUXSEG6EI64_V_M2_M1_MASK = 5555, + RISCV_PseudoVLUXSEG6EI64_V_M2_MF2 = 5556, + RISCV_PseudoVLUXSEG6EI64_V_M2_MF2_MASK = 5557, + RISCV_PseudoVLUXSEG6EI64_V_M2_MF4 = 5558, + RISCV_PseudoVLUXSEG6EI64_V_M2_MF4_MASK = 5559, + RISCV_PseudoVLUXSEG6EI64_V_M4_M1 = 5560, + RISCV_PseudoVLUXSEG6EI64_V_M4_M1_MASK = 5561, + RISCV_PseudoVLUXSEG6EI64_V_M4_MF2 = 5562, + RISCV_PseudoVLUXSEG6EI64_V_M4_MF2_MASK = 5563, + RISCV_PseudoVLUXSEG6EI64_V_M8_M1 = 5564, + RISCV_PseudoVLUXSEG6EI64_V_M8_M1_MASK = 5565, + RISCV_PseudoVLUXSEG6EI8_V_M1_M1 = 5566, + RISCV_PseudoVLUXSEG6EI8_V_M1_M1_MASK = 5567, + RISCV_PseudoVLUXSEG6EI8_V_MF2_M1 = 5568, + RISCV_PseudoVLUXSEG6EI8_V_MF2_M1_MASK = 5569, + RISCV_PseudoVLUXSEG6EI8_V_MF2_MF2 = 5570, + RISCV_PseudoVLUXSEG6EI8_V_MF2_MF2_MASK = 5571, + RISCV_PseudoVLUXSEG6EI8_V_MF4_M1 = 5572, + RISCV_PseudoVLUXSEG6EI8_V_MF4_M1_MASK = 5573, + RISCV_PseudoVLUXSEG6EI8_V_MF4_MF2 = 5574, + RISCV_PseudoVLUXSEG6EI8_V_MF4_MF2_MASK = 5575, + RISCV_PseudoVLUXSEG6EI8_V_MF4_MF4 = 5576, + RISCV_PseudoVLUXSEG6EI8_V_MF4_MF4_MASK = 5577, + RISCV_PseudoVLUXSEG6EI8_V_MF8_M1 = 5578, + RISCV_PseudoVLUXSEG6EI8_V_MF8_M1_MASK = 5579, + RISCV_PseudoVLUXSEG6EI8_V_MF8_MF2 = 5580, + RISCV_PseudoVLUXSEG6EI8_V_MF8_MF2_MASK = 5581, + RISCV_PseudoVLUXSEG6EI8_V_MF8_MF4 = 5582, + RISCV_PseudoVLUXSEG6EI8_V_MF8_MF4_MASK = 5583, + RISCV_PseudoVLUXSEG6EI8_V_MF8_MF8 = 5584, + RISCV_PseudoVLUXSEG6EI8_V_MF8_MF8_MASK = 5585, + RISCV_PseudoVLUXSEG7EI16_V_M1_M1 = 5586, + RISCV_PseudoVLUXSEG7EI16_V_M1_M1_MASK = 5587, + RISCV_PseudoVLUXSEG7EI16_V_M1_MF2 = 5588, + RISCV_PseudoVLUXSEG7EI16_V_M1_MF2_MASK = 5589, + RISCV_PseudoVLUXSEG7EI16_V_M2_M1 = 5590, + RISCV_PseudoVLUXSEG7EI16_V_M2_M1_MASK = 5591, + RISCV_PseudoVLUXSEG7EI16_V_MF2_M1 = 5592, + RISCV_PseudoVLUXSEG7EI16_V_MF2_M1_MASK = 5593, + RISCV_PseudoVLUXSEG7EI16_V_MF2_MF2 = 5594, + RISCV_PseudoVLUXSEG7EI16_V_MF2_MF2_MASK = 5595, + RISCV_PseudoVLUXSEG7EI16_V_MF2_MF4 = 5596, + RISCV_PseudoVLUXSEG7EI16_V_MF2_MF4_MASK = 5597, + RISCV_PseudoVLUXSEG7EI16_V_MF4_M1 = 5598, + RISCV_PseudoVLUXSEG7EI16_V_MF4_M1_MASK = 5599, + RISCV_PseudoVLUXSEG7EI16_V_MF4_MF2 = 5600, + RISCV_PseudoVLUXSEG7EI16_V_MF4_MF2_MASK = 5601, + RISCV_PseudoVLUXSEG7EI16_V_MF4_MF4 = 5602, + RISCV_PseudoVLUXSEG7EI16_V_MF4_MF4_MASK = 5603, + RISCV_PseudoVLUXSEG7EI16_V_MF4_MF8 = 5604, + RISCV_PseudoVLUXSEG7EI16_V_MF4_MF8_MASK = 5605, + RISCV_PseudoVLUXSEG7EI32_V_M1_M1 = 5606, + RISCV_PseudoVLUXSEG7EI32_V_M1_M1_MASK = 5607, + RISCV_PseudoVLUXSEG7EI32_V_M1_MF2 = 5608, + RISCV_PseudoVLUXSEG7EI32_V_M1_MF2_MASK = 5609, + RISCV_PseudoVLUXSEG7EI32_V_M1_MF4 = 5610, + RISCV_PseudoVLUXSEG7EI32_V_M1_MF4_MASK = 5611, + RISCV_PseudoVLUXSEG7EI32_V_M2_M1 = 5612, + RISCV_PseudoVLUXSEG7EI32_V_M2_M1_MASK = 5613, + RISCV_PseudoVLUXSEG7EI32_V_M2_MF2 = 5614, + RISCV_PseudoVLUXSEG7EI32_V_M2_MF2_MASK = 5615, + RISCV_PseudoVLUXSEG7EI32_V_M4_M1 = 5616, + RISCV_PseudoVLUXSEG7EI32_V_M4_M1_MASK = 5617, + RISCV_PseudoVLUXSEG7EI32_V_MF2_M1 = 5618, + RISCV_PseudoVLUXSEG7EI32_V_MF2_M1_MASK = 5619, + RISCV_PseudoVLUXSEG7EI32_V_MF2_MF2 = 5620, + RISCV_PseudoVLUXSEG7EI32_V_MF2_MF2_MASK = 5621, + RISCV_PseudoVLUXSEG7EI32_V_MF2_MF4 = 5622, + RISCV_PseudoVLUXSEG7EI32_V_MF2_MF4_MASK = 5623, + RISCV_PseudoVLUXSEG7EI32_V_MF2_MF8 = 5624, + RISCV_PseudoVLUXSEG7EI32_V_MF2_MF8_MASK = 5625, + RISCV_PseudoVLUXSEG7EI64_V_M1_M1 = 5626, + RISCV_PseudoVLUXSEG7EI64_V_M1_M1_MASK = 5627, + RISCV_PseudoVLUXSEG7EI64_V_M1_MF2 = 5628, + RISCV_PseudoVLUXSEG7EI64_V_M1_MF2_MASK = 5629, + RISCV_PseudoVLUXSEG7EI64_V_M1_MF4 = 5630, + RISCV_PseudoVLUXSEG7EI64_V_M1_MF4_MASK = 5631, + RISCV_PseudoVLUXSEG7EI64_V_M1_MF8 = 5632, + RISCV_PseudoVLUXSEG7EI64_V_M1_MF8_MASK = 5633, + RISCV_PseudoVLUXSEG7EI64_V_M2_M1 = 5634, + RISCV_PseudoVLUXSEG7EI64_V_M2_M1_MASK = 5635, + RISCV_PseudoVLUXSEG7EI64_V_M2_MF2 = 5636, + RISCV_PseudoVLUXSEG7EI64_V_M2_MF2_MASK = 5637, + RISCV_PseudoVLUXSEG7EI64_V_M2_MF4 = 5638, + RISCV_PseudoVLUXSEG7EI64_V_M2_MF4_MASK = 5639, + RISCV_PseudoVLUXSEG7EI64_V_M4_M1 = 5640, + RISCV_PseudoVLUXSEG7EI64_V_M4_M1_MASK = 5641, + RISCV_PseudoVLUXSEG7EI64_V_M4_MF2 = 5642, + RISCV_PseudoVLUXSEG7EI64_V_M4_MF2_MASK = 5643, + RISCV_PseudoVLUXSEG7EI64_V_M8_M1 = 5644, + RISCV_PseudoVLUXSEG7EI64_V_M8_M1_MASK = 5645, + RISCV_PseudoVLUXSEG7EI8_V_M1_M1 = 5646, + RISCV_PseudoVLUXSEG7EI8_V_M1_M1_MASK = 5647, + RISCV_PseudoVLUXSEG7EI8_V_MF2_M1 = 5648, + RISCV_PseudoVLUXSEG7EI8_V_MF2_M1_MASK = 5649, + RISCV_PseudoVLUXSEG7EI8_V_MF2_MF2 = 5650, + RISCV_PseudoVLUXSEG7EI8_V_MF2_MF2_MASK = 5651, + RISCV_PseudoVLUXSEG7EI8_V_MF4_M1 = 5652, + RISCV_PseudoVLUXSEG7EI8_V_MF4_M1_MASK = 5653, + RISCV_PseudoVLUXSEG7EI8_V_MF4_MF2 = 5654, + RISCV_PseudoVLUXSEG7EI8_V_MF4_MF2_MASK = 5655, + RISCV_PseudoVLUXSEG7EI8_V_MF4_MF4 = 5656, + RISCV_PseudoVLUXSEG7EI8_V_MF4_MF4_MASK = 5657, + RISCV_PseudoVLUXSEG7EI8_V_MF8_M1 = 5658, + RISCV_PseudoVLUXSEG7EI8_V_MF8_M1_MASK = 5659, + RISCV_PseudoVLUXSEG7EI8_V_MF8_MF2 = 5660, + RISCV_PseudoVLUXSEG7EI8_V_MF8_MF2_MASK = 5661, + RISCV_PseudoVLUXSEG7EI8_V_MF8_MF4 = 5662, + RISCV_PseudoVLUXSEG7EI8_V_MF8_MF4_MASK = 5663, + RISCV_PseudoVLUXSEG7EI8_V_MF8_MF8 = 5664, + RISCV_PseudoVLUXSEG7EI8_V_MF8_MF8_MASK = 5665, + RISCV_PseudoVLUXSEG8EI16_V_M1_M1 = 5666, + RISCV_PseudoVLUXSEG8EI16_V_M1_M1_MASK = 5667, + RISCV_PseudoVLUXSEG8EI16_V_M1_MF2 = 5668, + RISCV_PseudoVLUXSEG8EI16_V_M1_MF2_MASK = 5669, + RISCV_PseudoVLUXSEG8EI16_V_M2_M1 = 5670, + RISCV_PseudoVLUXSEG8EI16_V_M2_M1_MASK = 5671, + RISCV_PseudoVLUXSEG8EI16_V_MF2_M1 = 5672, + RISCV_PseudoVLUXSEG8EI16_V_MF2_M1_MASK = 5673, + RISCV_PseudoVLUXSEG8EI16_V_MF2_MF2 = 5674, + RISCV_PseudoVLUXSEG8EI16_V_MF2_MF2_MASK = 5675, + RISCV_PseudoVLUXSEG8EI16_V_MF2_MF4 = 5676, + RISCV_PseudoVLUXSEG8EI16_V_MF2_MF4_MASK = 5677, + RISCV_PseudoVLUXSEG8EI16_V_MF4_M1 = 5678, + RISCV_PseudoVLUXSEG8EI16_V_MF4_M1_MASK = 5679, + RISCV_PseudoVLUXSEG8EI16_V_MF4_MF2 = 5680, + RISCV_PseudoVLUXSEG8EI16_V_MF4_MF2_MASK = 5681, + RISCV_PseudoVLUXSEG8EI16_V_MF4_MF4 = 5682, + RISCV_PseudoVLUXSEG8EI16_V_MF4_MF4_MASK = 5683, + RISCV_PseudoVLUXSEG8EI16_V_MF4_MF8 = 5684, + RISCV_PseudoVLUXSEG8EI16_V_MF4_MF8_MASK = 5685, + RISCV_PseudoVLUXSEG8EI32_V_M1_M1 = 5686, + RISCV_PseudoVLUXSEG8EI32_V_M1_M1_MASK = 5687, + RISCV_PseudoVLUXSEG8EI32_V_M1_MF2 = 5688, + RISCV_PseudoVLUXSEG8EI32_V_M1_MF2_MASK = 5689, + RISCV_PseudoVLUXSEG8EI32_V_M1_MF4 = 5690, + RISCV_PseudoVLUXSEG8EI32_V_M1_MF4_MASK = 5691, + RISCV_PseudoVLUXSEG8EI32_V_M2_M1 = 5692, + RISCV_PseudoVLUXSEG8EI32_V_M2_M1_MASK = 5693, + RISCV_PseudoVLUXSEG8EI32_V_M2_MF2 = 5694, + RISCV_PseudoVLUXSEG8EI32_V_M2_MF2_MASK = 5695, + RISCV_PseudoVLUXSEG8EI32_V_M4_M1 = 5696, + RISCV_PseudoVLUXSEG8EI32_V_M4_M1_MASK = 5697, + RISCV_PseudoVLUXSEG8EI32_V_MF2_M1 = 5698, + RISCV_PseudoVLUXSEG8EI32_V_MF2_M1_MASK = 5699, + RISCV_PseudoVLUXSEG8EI32_V_MF2_MF2 = 5700, + RISCV_PseudoVLUXSEG8EI32_V_MF2_MF2_MASK = 5701, + RISCV_PseudoVLUXSEG8EI32_V_MF2_MF4 = 5702, + RISCV_PseudoVLUXSEG8EI32_V_MF2_MF4_MASK = 5703, + RISCV_PseudoVLUXSEG8EI32_V_MF2_MF8 = 5704, + RISCV_PseudoVLUXSEG8EI32_V_MF2_MF8_MASK = 5705, + RISCV_PseudoVLUXSEG8EI64_V_M1_M1 = 5706, + RISCV_PseudoVLUXSEG8EI64_V_M1_M1_MASK = 5707, + RISCV_PseudoVLUXSEG8EI64_V_M1_MF2 = 5708, + RISCV_PseudoVLUXSEG8EI64_V_M1_MF2_MASK = 5709, + RISCV_PseudoVLUXSEG8EI64_V_M1_MF4 = 5710, + RISCV_PseudoVLUXSEG8EI64_V_M1_MF4_MASK = 5711, + RISCV_PseudoVLUXSEG8EI64_V_M1_MF8 = 5712, + RISCV_PseudoVLUXSEG8EI64_V_M1_MF8_MASK = 5713, + RISCV_PseudoVLUXSEG8EI64_V_M2_M1 = 5714, + RISCV_PseudoVLUXSEG8EI64_V_M2_M1_MASK = 5715, + RISCV_PseudoVLUXSEG8EI64_V_M2_MF2 = 5716, + RISCV_PseudoVLUXSEG8EI64_V_M2_MF2_MASK = 5717, + RISCV_PseudoVLUXSEG8EI64_V_M2_MF4 = 5718, + RISCV_PseudoVLUXSEG8EI64_V_M2_MF4_MASK = 5719, + RISCV_PseudoVLUXSEG8EI64_V_M4_M1 = 5720, + RISCV_PseudoVLUXSEG8EI64_V_M4_M1_MASK = 5721, + RISCV_PseudoVLUXSEG8EI64_V_M4_MF2 = 5722, + RISCV_PseudoVLUXSEG8EI64_V_M4_MF2_MASK = 5723, + RISCV_PseudoVLUXSEG8EI64_V_M8_M1 = 5724, + RISCV_PseudoVLUXSEG8EI64_V_M8_M1_MASK = 5725, + RISCV_PseudoVLUXSEG8EI8_V_M1_M1 = 5726, + RISCV_PseudoVLUXSEG8EI8_V_M1_M1_MASK = 5727, + RISCV_PseudoVLUXSEG8EI8_V_MF2_M1 = 5728, + RISCV_PseudoVLUXSEG8EI8_V_MF2_M1_MASK = 5729, + RISCV_PseudoVLUXSEG8EI8_V_MF2_MF2 = 5730, + RISCV_PseudoVLUXSEG8EI8_V_MF2_MF2_MASK = 5731, + RISCV_PseudoVLUXSEG8EI8_V_MF4_M1 = 5732, + RISCV_PseudoVLUXSEG8EI8_V_MF4_M1_MASK = 5733, + RISCV_PseudoVLUXSEG8EI8_V_MF4_MF2 = 5734, + RISCV_PseudoVLUXSEG8EI8_V_MF4_MF2_MASK = 5735, + RISCV_PseudoVLUXSEG8EI8_V_MF4_MF4 = 5736, + RISCV_PseudoVLUXSEG8EI8_V_MF4_MF4_MASK = 5737, + RISCV_PseudoVLUXSEG8EI8_V_MF8_M1 = 5738, + RISCV_PseudoVLUXSEG8EI8_V_MF8_M1_MASK = 5739, + RISCV_PseudoVLUXSEG8EI8_V_MF8_MF2 = 5740, + RISCV_PseudoVLUXSEG8EI8_V_MF8_MF2_MASK = 5741, + RISCV_PseudoVLUXSEG8EI8_V_MF8_MF4 = 5742, + RISCV_PseudoVLUXSEG8EI8_V_MF8_MF4_MASK = 5743, + RISCV_PseudoVLUXSEG8EI8_V_MF8_MF8 = 5744, + RISCV_PseudoVLUXSEG8EI8_V_MF8_MF8_MASK = 5745, + RISCV_PseudoVMACC_VV_M1 = 5746, + RISCV_PseudoVMACC_VV_M1_MASK = 5747, + RISCV_PseudoVMACC_VV_M2 = 5748, + RISCV_PseudoVMACC_VV_M2_MASK = 5749, + RISCV_PseudoVMACC_VV_M4 = 5750, + RISCV_PseudoVMACC_VV_M4_MASK = 5751, + RISCV_PseudoVMACC_VV_M8 = 5752, + RISCV_PseudoVMACC_VV_M8_MASK = 5753, + RISCV_PseudoVMACC_VV_MF2 = 5754, + RISCV_PseudoVMACC_VV_MF2_MASK = 5755, + RISCV_PseudoVMACC_VV_MF4 = 5756, + RISCV_PseudoVMACC_VV_MF4_MASK = 5757, + RISCV_PseudoVMACC_VV_MF8 = 5758, + RISCV_PseudoVMACC_VV_MF8_MASK = 5759, + RISCV_PseudoVMACC_VX_M1 = 5760, + RISCV_PseudoVMACC_VX_M1_MASK = 5761, + RISCV_PseudoVMACC_VX_M2 = 5762, + RISCV_PseudoVMACC_VX_M2_MASK = 5763, + RISCV_PseudoVMACC_VX_M4 = 5764, + RISCV_PseudoVMACC_VX_M4_MASK = 5765, + RISCV_PseudoVMACC_VX_M8 = 5766, + RISCV_PseudoVMACC_VX_M8_MASK = 5767, + RISCV_PseudoVMACC_VX_MF2 = 5768, + RISCV_PseudoVMACC_VX_MF2_MASK = 5769, + RISCV_PseudoVMACC_VX_MF4 = 5770, + RISCV_PseudoVMACC_VX_MF4_MASK = 5771, + RISCV_PseudoVMACC_VX_MF8 = 5772, + RISCV_PseudoVMACC_VX_MF8_MASK = 5773, + RISCV_PseudoVMADC_VIM_M1 = 5774, + RISCV_PseudoVMADC_VIM_M2 = 5775, + RISCV_PseudoVMADC_VIM_M4 = 5776, + RISCV_PseudoVMADC_VIM_M8 = 5777, + RISCV_PseudoVMADC_VIM_MF2 = 5778, + RISCV_PseudoVMADC_VIM_MF4 = 5779, + RISCV_PseudoVMADC_VIM_MF8 = 5780, + RISCV_PseudoVMADC_VI_M1 = 5781, + RISCV_PseudoVMADC_VI_M2 = 5782, + RISCV_PseudoVMADC_VI_M4 = 5783, + RISCV_PseudoVMADC_VI_M8 = 5784, + RISCV_PseudoVMADC_VI_MF2 = 5785, + RISCV_PseudoVMADC_VI_MF4 = 5786, + RISCV_PseudoVMADC_VI_MF8 = 5787, + RISCV_PseudoVMADC_VVM_M1 = 5788, + RISCV_PseudoVMADC_VVM_M2 = 5789, + RISCV_PseudoVMADC_VVM_M4 = 5790, + RISCV_PseudoVMADC_VVM_M8 = 5791, + RISCV_PseudoVMADC_VVM_MF2 = 5792, + RISCV_PseudoVMADC_VVM_MF4 = 5793, + RISCV_PseudoVMADC_VVM_MF8 = 5794, + RISCV_PseudoVMADC_VV_M1 = 5795, + RISCV_PseudoVMADC_VV_M2 = 5796, + RISCV_PseudoVMADC_VV_M4 = 5797, + RISCV_PseudoVMADC_VV_M8 = 5798, + RISCV_PseudoVMADC_VV_MF2 = 5799, + RISCV_PseudoVMADC_VV_MF4 = 5800, + RISCV_PseudoVMADC_VV_MF8 = 5801, + RISCV_PseudoVMADC_VXM_M1 = 5802, + RISCV_PseudoVMADC_VXM_M2 = 5803, + RISCV_PseudoVMADC_VXM_M4 = 5804, + RISCV_PseudoVMADC_VXM_M8 = 5805, + RISCV_PseudoVMADC_VXM_MF2 = 5806, + RISCV_PseudoVMADC_VXM_MF4 = 5807, + RISCV_PseudoVMADC_VXM_MF8 = 5808, + RISCV_PseudoVMADC_VX_M1 = 5809, + RISCV_PseudoVMADC_VX_M2 = 5810, + RISCV_PseudoVMADC_VX_M4 = 5811, + RISCV_PseudoVMADC_VX_M8 = 5812, + RISCV_PseudoVMADC_VX_MF2 = 5813, + RISCV_PseudoVMADC_VX_MF4 = 5814, + RISCV_PseudoVMADC_VX_MF8 = 5815, + RISCV_PseudoVMADD_VV_M1 = 5816, + RISCV_PseudoVMADD_VV_M1_MASK = 5817, + RISCV_PseudoVMADD_VV_M2 = 5818, + RISCV_PseudoVMADD_VV_M2_MASK = 5819, + RISCV_PseudoVMADD_VV_M4 = 5820, + RISCV_PseudoVMADD_VV_M4_MASK = 5821, + RISCV_PseudoVMADD_VV_M8 = 5822, + RISCV_PseudoVMADD_VV_M8_MASK = 5823, + RISCV_PseudoVMADD_VV_MF2 = 5824, + RISCV_PseudoVMADD_VV_MF2_MASK = 5825, + RISCV_PseudoVMADD_VV_MF4 = 5826, + RISCV_PseudoVMADD_VV_MF4_MASK = 5827, + RISCV_PseudoVMADD_VV_MF8 = 5828, + RISCV_PseudoVMADD_VV_MF8_MASK = 5829, + RISCV_PseudoVMADD_VX_M1 = 5830, + RISCV_PseudoVMADD_VX_M1_MASK = 5831, + RISCV_PseudoVMADD_VX_M2 = 5832, + RISCV_PseudoVMADD_VX_M2_MASK = 5833, + RISCV_PseudoVMADD_VX_M4 = 5834, + RISCV_PseudoVMADD_VX_M4_MASK = 5835, + RISCV_PseudoVMADD_VX_M8 = 5836, + RISCV_PseudoVMADD_VX_M8_MASK = 5837, + RISCV_PseudoVMADD_VX_MF2 = 5838, + RISCV_PseudoVMADD_VX_MF2_MASK = 5839, + RISCV_PseudoVMADD_VX_MF4 = 5840, + RISCV_PseudoVMADD_VX_MF4_MASK = 5841, + RISCV_PseudoVMADD_VX_MF8 = 5842, + RISCV_PseudoVMADD_VX_MF8_MASK = 5843, + RISCV_PseudoVMANDN_MM_M1 = 5844, + RISCV_PseudoVMANDN_MM_M2 = 5845, + RISCV_PseudoVMANDN_MM_M4 = 5846, + RISCV_PseudoVMANDN_MM_M8 = 5847, + RISCV_PseudoVMANDN_MM_MF2 = 5848, + RISCV_PseudoVMANDN_MM_MF4 = 5849, + RISCV_PseudoVMANDN_MM_MF8 = 5850, + RISCV_PseudoVMAND_MM_M1 = 5851, + RISCV_PseudoVMAND_MM_M2 = 5852, + RISCV_PseudoVMAND_MM_M4 = 5853, + RISCV_PseudoVMAND_MM_M8 = 5854, + RISCV_PseudoVMAND_MM_MF2 = 5855, + RISCV_PseudoVMAND_MM_MF4 = 5856, + RISCV_PseudoVMAND_MM_MF8 = 5857, + RISCV_PseudoVMAXU_VV_M1 = 5858, + RISCV_PseudoVMAXU_VV_M1_MASK = 5859, + RISCV_PseudoVMAXU_VV_M2 = 5860, + RISCV_PseudoVMAXU_VV_M2_MASK = 5861, + RISCV_PseudoVMAXU_VV_M4 = 5862, + RISCV_PseudoVMAXU_VV_M4_MASK = 5863, + RISCV_PseudoVMAXU_VV_M8 = 5864, + RISCV_PseudoVMAXU_VV_M8_MASK = 5865, + RISCV_PseudoVMAXU_VV_MF2 = 5866, + RISCV_PseudoVMAXU_VV_MF2_MASK = 5867, + RISCV_PseudoVMAXU_VV_MF4 = 5868, + RISCV_PseudoVMAXU_VV_MF4_MASK = 5869, + RISCV_PseudoVMAXU_VV_MF8 = 5870, + RISCV_PseudoVMAXU_VV_MF8_MASK = 5871, + RISCV_PseudoVMAXU_VX_M1 = 5872, + RISCV_PseudoVMAXU_VX_M1_MASK = 5873, + RISCV_PseudoVMAXU_VX_M2 = 5874, + RISCV_PseudoVMAXU_VX_M2_MASK = 5875, + RISCV_PseudoVMAXU_VX_M4 = 5876, + RISCV_PseudoVMAXU_VX_M4_MASK = 5877, + RISCV_PseudoVMAXU_VX_M8 = 5878, + RISCV_PseudoVMAXU_VX_M8_MASK = 5879, + RISCV_PseudoVMAXU_VX_MF2 = 5880, + RISCV_PseudoVMAXU_VX_MF2_MASK = 5881, + RISCV_PseudoVMAXU_VX_MF4 = 5882, + RISCV_PseudoVMAXU_VX_MF4_MASK = 5883, + RISCV_PseudoVMAXU_VX_MF8 = 5884, + RISCV_PseudoVMAXU_VX_MF8_MASK = 5885, + RISCV_PseudoVMAX_VV_M1 = 5886, + RISCV_PseudoVMAX_VV_M1_MASK = 5887, + RISCV_PseudoVMAX_VV_M2 = 5888, + RISCV_PseudoVMAX_VV_M2_MASK = 5889, + RISCV_PseudoVMAX_VV_M4 = 5890, + RISCV_PseudoVMAX_VV_M4_MASK = 5891, + RISCV_PseudoVMAX_VV_M8 = 5892, + RISCV_PseudoVMAX_VV_M8_MASK = 5893, + RISCV_PseudoVMAX_VV_MF2 = 5894, + RISCV_PseudoVMAX_VV_MF2_MASK = 5895, + RISCV_PseudoVMAX_VV_MF4 = 5896, + RISCV_PseudoVMAX_VV_MF4_MASK = 5897, + RISCV_PseudoVMAX_VV_MF8 = 5898, + RISCV_PseudoVMAX_VV_MF8_MASK = 5899, + RISCV_PseudoVMAX_VX_M1 = 5900, + RISCV_PseudoVMAX_VX_M1_MASK = 5901, + RISCV_PseudoVMAX_VX_M2 = 5902, + RISCV_PseudoVMAX_VX_M2_MASK = 5903, + RISCV_PseudoVMAX_VX_M4 = 5904, + RISCV_PseudoVMAX_VX_M4_MASK = 5905, + RISCV_PseudoVMAX_VX_M8 = 5906, + RISCV_PseudoVMAX_VX_M8_MASK = 5907, + RISCV_PseudoVMAX_VX_MF2 = 5908, + RISCV_PseudoVMAX_VX_MF2_MASK = 5909, + RISCV_PseudoVMAX_VX_MF4 = 5910, + RISCV_PseudoVMAX_VX_MF4_MASK = 5911, + RISCV_PseudoVMAX_VX_MF8 = 5912, + RISCV_PseudoVMAX_VX_MF8_MASK = 5913, + RISCV_PseudoVMCLR_M_B1 = 5914, + RISCV_PseudoVMCLR_M_B16 = 5915, + RISCV_PseudoVMCLR_M_B2 = 5916, + RISCV_PseudoVMCLR_M_B32 = 5917, + RISCV_PseudoVMCLR_M_B4 = 5918, + RISCV_PseudoVMCLR_M_B64 = 5919, + RISCV_PseudoVMCLR_M_B8 = 5920, + RISCV_PseudoVMERGE_VIM_M1 = 5921, + RISCV_PseudoVMERGE_VIM_M2 = 5922, + RISCV_PseudoVMERGE_VIM_M4 = 5923, + RISCV_PseudoVMERGE_VIM_M8 = 5924, + RISCV_PseudoVMERGE_VIM_MF2 = 5925, + RISCV_PseudoVMERGE_VIM_MF4 = 5926, + RISCV_PseudoVMERGE_VIM_MF8 = 5927, + RISCV_PseudoVMERGE_VVM_M1 = 5928, + RISCV_PseudoVMERGE_VVM_M2 = 5929, + RISCV_PseudoVMERGE_VVM_M4 = 5930, + RISCV_PseudoVMERGE_VVM_M8 = 5931, + RISCV_PseudoVMERGE_VVM_MF2 = 5932, + RISCV_PseudoVMERGE_VVM_MF4 = 5933, + RISCV_PseudoVMERGE_VVM_MF8 = 5934, + RISCV_PseudoVMERGE_VXM_M1 = 5935, + RISCV_PseudoVMERGE_VXM_M2 = 5936, + RISCV_PseudoVMERGE_VXM_M4 = 5937, + RISCV_PseudoVMERGE_VXM_M8 = 5938, + RISCV_PseudoVMERGE_VXM_MF2 = 5939, + RISCV_PseudoVMERGE_VXM_MF4 = 5940, + RISCV_PseudoVMERGE_VXM_MF8 = 5941, + RISCV_PseudoVMFEQ_VFPR16_M1 = 5942, + RISCV_PseudoVMFEQ_VFPR16_M1_MASK = 5943, + RISCV_PseudoVMFEQ_VFPR16_M2 = 5944, + RISCV_PseudoVMFEQ_VFPR16_M2_MASK = 5945, + RISCV_PseudoVMFEQ_VFPR16_M4 = 5946, + RISCV_PseudoVMFEQ_VFPR16_M4_MASK = 5947, + RISCV_PseudoVMFEQ_VFPR16_M8 = 5948, + RISCV_PseudoVMFEQ_VFPR16_M8_MASK = 5949, + RISCV_PseudoVMFEQ_VFPR16_MF2 = 5950, + RISCV_PseudoVMFEQ_VFPR16_MF2_MASK = 5951, + RISCV_PseudoVMFEQ_VFPR16_MF4 = 5952, + RISCV_PseudoVMFEQ_VFPR16_MF4_MASK = 5953, + RISCV_PseudoVMFEQ_VFPR32_M1 = 5954, + RISCV_PseudoVMFEQ_VFPR32_M1_MASK = 5955, + RISCV_PseudoVMFEQ_VFPR32_M2 = 5956, + RISCV_PseudoVMFEQ_VFPR32_M2_MASK = 5957, + RISCV_PseudoVMFEQ_VFPR32_M4 = 5958, + RISCV_PseudoVMFEQ_VFPR32_M4_MASK = 5959, + RISCV_PseudoVMFEQ_VFPR32_M8 = 5960, + RISCV_PseudoVMFEQ_VFPR32_M8_MASK = 5961, + RISCV_PseudoVMFEQ_VFPR32_MF2 = 5962, + RISCV_PseudoVMFEQ_VFPR32_MF2_MASK = 5963, + RISCV_PseudoVMFEQ_VFPR64_M1 = 5964, + RISCV_PseudoVMFEQ_VFPR64_M1_MASK = 5965, + RISCV_PseudoVMFEQ_VFPR64_M2 = 5966, + RISCV_PseudoVMFEQ_VFPR64_M2_MASK = 5967, + RISCV_PseudoVMFEQ_VFPR64_M4 = 5968, + RISCV_PseudoVMFEQ_VFPR64_M4_MASK = 5969, + RISCV_PseudoVMFEQ_VFPR64_M8 = 5970, + RISCV_PseudoVMFEQ_VFPR64_M8_MASK = 5971, + RISCV_PseudoVMFEQ_VV_M1 = 5972, + RISCV_PseudoVMFEQ_VV_M1_MASK = 5973, + RISCV_PseudoVMFEQ_VV_M2 = 5974, + RISCV_PseudoVMFEQ_VV_M2_MASK = 5975, + RISCV_PseudoVMFEQ_VV_M4 = 5976, + RISCV_PseudoVMFEQ_VV_M4_MASK = 5977, + RISCV_PseudoVMFEQ_VV_M8 = 5978, + RISCV_PseudoVMFEQ_VV_M8_MASK = 5979, + RISCV_PseudoVMFEQ_VV_MF2 = 5980, + RISCV_PseudoVMFEQ_VV_MF2_MASK = 5981, + RISCV_PseudoVMFEQ_VV_MF4 = 5982, + RISCV_PseudoVMFEQ_VV_MF4_MASK = 5983, + RISCV_PseudoVMFGE_VFPR16_M1 = 5984, + RISCV_PseudoVMFGE_VFPR16_M1_MASK = 5985, + RISCV_PseudoVMFGE_VFPR16_M2 = 5986, + RISCV_PseudoVMFGE_VFPR16_M2_MASK = 5987, + RISCV_PseudoVMFGE_VFPR16_M4 = 5988, + RISCV_PseudoVMFGE_VFPR16_M4_MASK = 5989, + RISCV_PseudoVMFGE_VFPR16_M8 = 5990, + RISCV_PseudoVMFGE_VFPR16_M8_MASK = 5991, + RISCV_PseudoVMFGE_VFPR16_MF2 = 5992, + RISCV_PseudoVMFGE_VFPR16_MF2_MASK = 5993, + RISCV_PseudoVMFGE_VFPR16_MF4 = 5994, + RISCV_PseudoVMFGE_VFPR16_MF4_MASK = 5995, + RISCV_PseudoVMFGE_VFPR32_M1 = 5996, + RISCV_PseudoVMFGE_VFPR32_M1_MASK = 5997, + RISCV_PseudoVMFGE_VFPR32_M2 = 5998, + RISCV_PseudoVMFGE_VFPR32_M2_MASK = 5999, + RISCV_PseudoVMFGE_VFPR32_M4 = 6000, + RISCV_PseudoVMFGE_VFPR32_M4_MASK = 6001, + RISCV_PseudoVMFGE_VFPR32_M8 = 6002, + RISCV_PseudoVMFGE_VFPR32_M8_MASK = 6003, + RISCV_PseudoVMFGE_VFPR32_MF2 = 6004, + RISCV_PseudoVMFGE_VFPR32_MF2_MASK = 6005, + RISCV_PseudoVMFGE_VFPR64_M1 = 6006, + RISCV_PseudoVMFGE_VFPR64_M1_MASK = 6007, + RISCV_PseudoVMFGE_VFPR64_M2 = 6008, + RISCV_PseudoVMFGE_VFPR64_M2_MASK = 6009, + RISCV_PseudoVMFGE_VFPR64_M4 = 6010, + RISCV_PseudoVMFGE_VFPR64_M4_MASK = 6011, + RISCV_PseudoVMFGE_VFPR64_M8 = 6012, + RISCV_PseudoVMFGE_VFPR64_M8_MASK = 6013, + RISCV_PseudoVMFGT_VFPR16_M1 = 6014, + RISCV_PseudoVMFGT_VFPR16_M1_MASK = 6015, + RISCV_PseudoVMFGT_VFPR16_M2 = 6016, + RISCV_PseudoVMFGT_VFPR16_M2_MASK = 6017, + RISCV_PseudoVMFGT_VFPR16_M4 = 6018, + RISCV_PseudoVMFGT_VFPR16_M4_MASK = 6019, + RISCV_PseudoVMFGT_VFPR16_M8 = 6020, + RISCV_PseudoVMFGT_VFPR16_M8_MASK = 6021, + RISCV_PseudoVMFGT_VFPR16_MF2 = 6022, + RISCV_PseudoVMFGT_VFPR16_MF2_MASK = 6023, + RISCV_PseudoVMFGT_VFPR16_MF4 = 6024, + RISCV_PseudoVMFGT_VFPR16_MF4_MASK = 6025, + RISCV_PseudoVMFGT_VFPR32_M1 = 6026, + RISCV_PseudoVMFGT_VFPR32_M1_MASK = 6027, + RISCV_PseudoVMFGT_VFPR32_M2 = 6028, + RISCV_PseudoVMFGT_VFPR32_M2_MASK = 6029, + RISCV_PseudoVMFGT_VFPR32_M4 = 6030, + RISCV_PseudoVMFGT_VFPR32_M4_MASK = 6031, + RISCV_PseudoVMFGT_VFPR32_M8 = 6032, + RISCV_PseudoVMFGT_VFPR32_M8_MASK = 6033, + RISCV_PseudoVMFGT_VFPR32_MF2 = 6034, + RISCV_PseudoVMFGT_VFPR32_MF2_MASK = 6035, + RISCV_PseudoVMFGT_VFPR64_M1 = 6036, + RISCV_PseudoVMFGT_VFPR64_M1_MASK = 6037, + RISCV_PseudoVMFGT_VFPR64_M2 = 6038, + RISCV_PseudoVMFGT_VFPR64_M2_MASK = 6039, + RISCV_PseudoVMFGT_VFPR64_M4 = 6040, + RISCV_PseudoVMFGT_VFPR64_M4_MASK = 6041, + RISCV_PseudoVMFGT_VFPR64_M8 = 6042, + RISCV_PseudoVMFGT_VFPR64_M8_MASK = 6043, + RISCV_PseudoVMFLE_VFPR16_M1 = 6044, + RISCV_PseudoVMFLE_VFPR16_M1_MASK = 6045, + RISCV_PseudoVMFLE_VFPR16_M2 = 6046, + RISCV_PseudoVMFLE_VFPR16_M2_MASK = 6047, + RISCV_PseudoVMFLE_VFPR16_M4 = 6048, + RISCV_PseudoVMFLE_VFPR16_M4_MASK = 6049, + RISCV_PseudoVMFLE_VFPR16_M8 = 6050, + RISCV_PseudoVMFLE_VFPR16_M8_MASK = 6051, + RISCV_PseudoVMFLE_VFPR16_MF2 = 6052, + RISCV_PseudoVMFLE_VFPR16_MF2_MASK = 6053, + RISCV_PseudoVMFLE_VFPR16_MF4 = 6054, + RISCV_PseudoVMFLE_VFPR16_MF4_MASK = 6055, + RISCV_PseudoVMFLE_VFPR32_M1 = 6056, + RISCV_PseudoVMFLE_VFPR32_M1_MASK = 6057, + RISCV_PseudoVMFLE_VFPR32_M2 = 6058, + RISCV_PseudoVMFLE_VFPR32_M2_MASK = 6059, + RISCV_PseudoVMFLE_VFPR32_M4 = 6060, + RISCV_PseudoVMFLE_VFPR32_M4_MASK = 6061, + RISCV_PseudoVMFLE_VFPR32_M8 = 6062, + RISCV_PseudoVMFLE_VFPR32_M8_MASK = 6063, + RISCV_PseudoVMFLE_VFPR32_MF2 = 6064, + RISCV_PseudoVMFLE_VFPR32_MF2_MASK = 6065, + RISCV_PseudoVMFLE_VFPR64_M1 = 6066, + RISCV_PseudoVMFLE_VFPR64_M1_MASK = 6067, + RISCV_PseudoVMFLE_VFPR64_M2 = 6068, + RISCV_PseudoVMFLE_VFPR64_M2_MASK = 6069, + RISCV_PseudoVMFLE_VFPR64_M4 = 6070, + RISCV_PseudoVMFLE_VFPR64_M4_MASK = 6071, + RISCV_PseudoVMFLE_VFPR64_M8 = 6072, + RISCV_PseudoVMFLE_VFPR64_M8_MASK = 6073, + RISCV_PseudoVMFLE_VV_M1 = 6074, + RISCV_PseudoVMFLE_VV_M1_MASK = 6075, + RISCV_PseudoVMFLE_VV_M2 = 6076, + RISCV_PseudoVMFLE_VV_M2_MASK = 6077, + RISCV_PseudoVMFLE_VV_M4 = 6078, + RISCV_PseudoVMFLE_VV_M4_MASK = 6079, + RISCV_PseudoVMFLE_VV_M8 = 6080, + RISCV_PseudoVMFLE_VV_M8_MASK = 6081, + RISCV_PseudoVMFLE_VV_MF2 = 6082, + RISCV_PseudoVMFLE_VV_MF2_MASK = 6083, + RISCV_PseudoVMFLE_VV_MF4 = 6084, + RISCV_PseudoVMFLE_VV_MF4_MASK = 6085, + RISCV_PseudoVMFLT_VFPR16_M1 = 6086, + RISCV_PseudoVMFLT_VFPR16_M1_MASK = 6087, + RISCV_PseudoVMFLT_VFPR16_M2 = 6088, + RISCV_PseudoVMFLT_VFPR16_M2_MASK = 6089, + RISCV_PseudoVMFLT_VFPR16_M4 = 6090, + RISCV_PseudoVMFLT_VFPR16_M4_MASK = 6091, + RISCV_PseudoVMFLT_VFPR16_M8 = 6092, + RISCV_PseudoVMFLT_VFPR16_M8_MASK = 6093, + RISCV_PseudoVMFLT_VFPR16_MF2 = 6094, + RISCV_PseudoVMFLT_VFPR16_MF2_MASK = 6095, + RISCV_PseudoVMFLT_VFPR16_MF4 = 6096, + RISCV_PseudoVMFLT_VFPR16_MF4_MASK = 6097, + RISCV_PseudoVMFLT_VFPR32_M1 = 6098, + RISCV_PseudoVMFLT_VFPR32_M1_MASK = 6099, + RISCV_PseudoVMFLT_VFPR32_M2 = 6100, + RISCV_PseudoVMFLT_VFPR32_M2_MASK = 6101, + RISCV_PseudoVMFLT_VFPR32_M4 = 6102, + RISCV_PseudoVMFLT_VFPR32_M4_MASK = 6103, + RISCV_PseudoVMFLT_VFPR32_M8 = 6104, + RISCV_PseudoVMFLT_VFPR32_M8_MASK = 6105, + RISCV_PseudoVMFLT_VFPR32_MF2 = 6106, + RISCV_PseudoVMFLT_VFPR32_MF2_MASK = 6107, + RISCV_PseudoVMFLT_VFPR64_M1 = 6108, + RISCV_PseudoVMFLT_VFPR64_M1_MASK = 6109, + RISCV_PseudoVMFLT_VFPR64_M2 = 6110, + RISCV_PseudoVMFLT_VFPR64_M2_MASK = 6111, + RISCV_PseudoVMFLT_VFPR64_M4 = 6112, + RISCV_PseudoVMFLT_VFPR64_M4_MASK = 6113, + RISCV_PseudoVMFLT_VFPR64_M8 = 6114, + RISCV_PseudoVMFLT_VFPR64_M8_MASK = 6115, + RISCV_PseudoVMFLT_VV_M1 = 6116, + RISCV_PseudoVMFLT_VV_M1_MASK = 6117, + RISCV_PseudoVMFLT_VV_M2 = 6118, + RISCV_PseudoVMFLT_VV_M2_MASK = 6119, + RISCV_PseudoVMFLT_VV_M4 = 6120, + RISCV_PseudoVMFLT_VV_M4_MASK = 6121, + RISCV_PseudoVMFLT_VV_M8 = 6122, + RISCV_PseudoVMFLT_VV_M8_MASK = 6123, + RISCV_PseudoVMFLT_VV_MF2 = 6124, + RISCV_PseudoVMFLT_VV_MF2_MASK = 6125, + RISCV_PseudoVMFLT_VV_MF4 = 6126, + RISCV_PseudoVMFLT_VV_MF4_MASK = 6127, + RISCV_PseudoVMFNE_VFPR16_M1 = 6128, + RISCV_PseudoVMFNE_VFPR16_M1_MASK = 6129, + RISCV_PseudoVMFNE_VFPR16_M2 = 6130, + RISCV_PseudoVMFNE_VFPR16_M2_MASK = 6131, + RISCV_PseudoVMFNE_VFPR16_M4 = 6132, + RISCV_PseudoVMFNE_VFPR16_M4_MASK = 6133, + RISCV_PseudoVMFNE_VFPR16_M8 = 6134, + RISCV_PseudoVMFNE_VFPR16_M8_MASK = 6135, + RISCV_PseudoVMFNE_VFPR16_MF2 = 6136, + RISCV_PseudoVMFNE_VFPR16_MF2_MASK = 6137, + RISCV_PseudoVMFNE_VFPR16_MF4 = 6138, + RISCV_PseudoVMFNE_VFPR16_MF4_MASK = 6139, + RISCV_PseudoVMFNE_VFPR32_M1 = 6140, + RISCV_PseudoVMFNE_VFPR32_M1_MASK = 6141, + RISCV_PseudoVMFNE_VFPR32_M2 = 6142, + RISCV_PseudoVMFNE_VFPR32_M2_MASK = 6143, + RISCV_PseudoVMFNE_VFPR32_M4 = 6144, + RISCV_PseudoVMFNE_VFPR32_M4_MASK = 6145, + RISCV_PseudoVMFNE_VFPR32_M8 = 6146, + RISCV_PseudoVMFNE_VFPR32_M8_MASK = 6147, + RISCV_PseudoVMFNE_VFPR32_MF2 = 6148, + RISCV_PseudoVMFNE_VFPR32_MF2_MASK = 6149, + RISCV_PseudoVMFNE_VFPR64_M1 = 6150, + RISCV_PseudoVMFNE_VFPR64_M1_MASK = 6151, + RISCV_PseudoVMFNE_VFPR64_M2 = 6152, + RISCV_PseudoVMFNE_VFPR64_M2_MASK = 6153, + RISCV_PseudoVMFNE_VFPR64_M4 = 6154, + RISCV_PseudoVMFNE_VFPR64_M4_MASK = 6155, + RISCV_PseudoVMFNE_VFPR64_M8 = 6156, + RISCV_PseudoVMFNE_VFPR64_M8_MASK = 6157, + RISCV_PseudoVMFNE_VV_M1 = 6158, + RISCV_PseudoVMFNE_VV_M1_MASK = 6159, + RISCV_PseudoVMFNE_VV_M2 = 6160, + RISCV_PseudoVMFNE_VV_M2_MASK = 6161, + RISCV_PseudoVMFNE_VV_M4 = 6162, + RISCV_PseudoVMFNE_VV_M4_MASK = 6163, + RISCV_PseudoVMFNE_VV_M8 = 6164, + RISCV_PseudoVMFNE_VV_M8_MASK = 6165, + RISCV_PseudoVMFNE_VV_MF2 = 6166, + RISCV_PseudoVMFNE_VV_MF2_MASK = 6167, + RISCV_PseudoVMFNE_VV_MF4 = 6168, + RISCV_PseudoVMFNE_VV_MF4_MASK = 6169, + RISCV_PseudoVMINU_VV_M1 = 6170, + RISCV_PseudoVMINU_VV_M1_MASK = 6171, + RISCV_PseudoVMINU_VV_M2 = 6172, + RISCV_PseudoVMINU_VV_M2_MASK = 6173, + RISCV_PseudoVMINU_VV_M4 = 6174, + RISCV_PseudoVMINU_VV_M4_MASK = 6175, + RISCV_PseudoVMINU_VV_M8 = 6176, + RISCV_PseudoVMINU_VV_M8_MASK = 6177, + RISCV_PseudoVMINU_VV_MF2 = 6178, + RISCV_PseudoVMINU_VV_MF2_MASK = 6179, + RISCV_PseudoVMINU_VV_MF4 = 6180, + RISCV_PseudoVMINU_VV_MF4_MASK = 6181, + RISCV_PseudoVMINU_VV_MF8 = 6182, + RISCV_PseudoVMINU_VV_MF8_MASK = 6183, + RISCV_PseudoVMINU_VX_M1 = 6184, + RISCV_PseudoVMINU_VX_M1_MASK = 6185, + RISCV_PseudoVMINU_VX_M2 = 6186, + RISCV_PseudoVMINU_VX_M2_MASK = 6187, + RISCV_PseudoVMINU_VX_M4 = 6188, + RISCV_PseudoVMINU_VX_M4_MASK = 6189, + RISCV_PseudoVMINU_VX_M8 = 6190, + RISCV_PseudoVMINU_VX_M8_MASK = 6191, + RISCV_PseudoVMINU_VX_MF2 = 6192, + RISCV_PseudoVMINU_VX_MF2_MASK = 6193, + RISCV_PseudoVMINU_VX_MF4 = 6194, + RISCV_PseudoVMINU_VX_MF4_MASK = 6195, + RISCV_PseudoVMINU_VX_MF8 = 6196, + RISCV_PseudoVMINU_VX_MF8_MASK = 6197, + RISCV_PseudoVMIN_VV_M1 = 6198, + RISCV_PseudoVMIN_VV_M1_MASK = 6199, + RISCV_PseudoVMIN_VV_M2 = 6200, + RISCV_PseudoVMIN_VV_M2_MASK = 6201, + RISCV_PseudoVMIN_VV_M4 = 6202, + RISCV_PseudoVMIN_VV_M4_MASK = 6203, + RISCV_PseudoVMIN_VV_M8 = 6204, + RISCV_PseudoVMIN_VV_M8_MASK = 6205, + RISCV_PseudoVMIN_VV_MF2 = 6206, + RISCV_PseudoVMIN_VV_MF2_MASK = 6207, + RISCV_PseudoVMIN_VV_MF4 = 6208, + RISCV_PseudoVMIN_VV_MF4_MASK = 6209, + RISCV_PseudoVMIN_VV_MF8 = 6210, + RISCV_PseudoVMIN_VV_MF8_MASK = 6211, + RISCV_PseudoVMIN_VX_M1 = 6212, + RISCV_PseudoVMIN_VX_M1_MASK = 6213, + RISCV_PseudoVMIN_VX_M2 = 6214, + RISCV_PseudoVMIN_VX_M2_MASK = 6215, + RISCV_PseudoVMIN_VX_M4 = 6216, + RISCV_PseudoVMIN_VX_M4_MASK = 6217, + RISCV_PseudoVMIN_VX_M8 = 6218, + RISCV_PseudoVMIN_VX_M8_MASK = 6219, + RISCV_PseudoVMIN_VX_MF2 = 6220, + RISCV_PseudoVMIN_VX_MF2_MASK = 6221, + RISCV_PseudoVMIN_VX_MF4 = 6222, + RISCV_PseudoVMIN_VX_MF4_MASK = 6223, + RISCV_PseudoVMIN_VX_MF8 = 6224, + RISCV_PseudoVMIN_VX_MF8_MASK = 6225, + RISCV_PseudoVMNAND_MM_M1 = 6226, + RISCV_PseudoVMNAND_MM_M2 = 6227, + RISCV_PseudoVMNAND_MM_M4 = 6228, + RISCV_PseudoVMNAND_MM_M8 = 6229, + RISCV_PseudoVMNAND_MM_MF2 = 6230, + RISCV_PseudoVMNAND_MM_MF4 = 6231, + RISCV_PseudoVMNAND_MM_MF8 = 6232, + RISCV_PseudoVMNOR_MM_M1 = 6233, + RISCV_PseudoVMNOR_MM_M2 = 6234, + RISCV_PseudoVMNOR_MM_M4 = 6235, + RISCV_PseudoVMNOR_MM_M8 = 6236, + RISCV_PseudoVMNOR_MM_MF2 = 6237, + RISCV_PseudoVMNOR_MM_MF4 = 6238, + RISCV_PseudoVMNOR_MM_MF8 = 6239, + RISCV_PseudoVMORN_MM_M1 = 6240, + RISCV_PseudoVMORN_MM_M2 = 6241, + RISCV_PseudoVMORN_MM_M4 = 6242, + RISCV_PseudoVMORN_MM_M8 = 6243, + RISCV_PseudoVMORN_MM_MF2 = 6244, + RISCV_PseudoVMORN_MM_MF4 = 6245, + RISCV_PseudoVMORN_MM_MF8 = 6246, + RISCV_PseudoVMOR_MM_M1 = 6247, + RISCV_PseudoVMOR_MM_M2 = 6248, + RISCV_PseudoVMOR_MM_M4 = 6249, + RISCV_PseudoVMOR_MM_M8 = 6250, + RISCV_PseudoVMOR_MM_MF2 = 6251, + RISCV_PseudoVMOR_MM_MF4 = 6252, + RISCV_PseudoVMOR_MM_MF8 = 6253, + RISCV_PseudoVMSBC_VVM_M1 = 6254, + RISCV_PseudoVMSBC_VVM_M2 = 6255, + RISCV_PseudoVMSBC_VVM_M4 = 6256, + RISCV_PseudoVMSBC_VVM_M8 = 6257, + RISCV_PseudoVMSBC_VVM_MF2 = 6258, + RISCV_PseudoVMSBC_VVM_MF4 = 6259, + RISCV_PseudoVMSBC_VVM_MF8 = 6260, + RISCV_PseudoVMSBC_VV_M1 = 6261, + RISCV_PseudoVMSBC_VV_M2 = 6262, + RISCV_PseudoVMSBC_VV_M4 = 6263, + RISCV_PseudoVMSBC_VV_M8 = 6264, + RISCV_PseudoVMSBC_VV_MF2 = 6265, + RISCV_PseudoVMSBC_VV_MF4 = 6266, + RISCV_PseudoVMSBC_VV_MF8 = 6267, + RISCV_PseudoVMSBC_VXM_M1 = 6268, + RISCV_PseudoVMSBC_VXM_M2 = 6269, + RISCV_PseudoVMSBC_VXM_M4 = 6270, + RISCV_PseudoVMSBC_VXM_M8 = 6271, + RISCV_PseudoVMSBC_VXM_MF2 = 6272, + RISCV_PseudoVMSBC_VXM_MF4 = 6273, + RISCV_PseudoVMSBC_VXM_MF8 = 6274, + RISCV_PseudoVMSBC_VX_M1 = 6275, + RISCV_PseudoVMSBC_VX_M2 = 6276, + RISCV_PseudoVMSBC_VX_M4 = 6277, + RISCV_PseudoVMSBC_VX_M8 = 6278, + RISCV_PseudoVMSBC_VX_MF2 = 6279, + RISCV_PseudoVMSBC_VX_MF4 = 6280, + RISCV_PseudoVMSBC_VX_MF8 = 6281, + RISCV_PseudoVMSBF_M_B1 = 6282, + RISCV_PseudoVMSBF_M_B16 = 6283, + RISCV_PseudoVMSBF_M_B16_MASK = 6284, + RISCV_PseudoVMSBF_M_B1_MASK = 6285, + RISCV_PseudoVMSBF_M_B2 = 6286, + RISCV_PseudoVMSBF_M_B2_MASK = 6287, + RISCV_PseudoVMSBF_M_B32 = 6288, + RISCV_PseudoVMSBF_M_B32_MASK = 6289, + RISCV_PseudoVMSBF_M_B4 = 6290, + RISCV_PseudoVMSBF_M_B4_MASK = 6291, + RISCV_PseudoVMSBF_M_B64 = 6292, + RISCV_PseudoVMSBF_M_B64_MASK = 6293, + RISCV_PseudoVMSBF_M_B8 = 6294, + RISCV_PseudoVMSBF_M_B8_MASK = 6295, + RISCV_PseudoVMSEQ_VI_M1 = 6296, + RISCV_PseudoVMSEQ_VI_M1_MASK = 6297, + RISCV_PseudoVMSEQ_VI_M2 = 6298, + RISCV_PseudoVMSEQ_VI_M2_MASK = 6299, + RISCV_PseudoVMSEQ_VI_M4 = 6300, + RISCV_PseudoVMSEQ_VI_M4_MASK = 6301, + RISCV_PseudoVMSEQ_VI_M8 = 6302, + RISCV_PseudoVMSEQ_VI_M8_MASK = 6303, + RISCV_PseudoVMSEQ_VI_MF2 = 6304, + RISCV_PseudoVMSEQ_VI_MF2_MASK = 6305, + RISCV_PseudoVMSEQ_VI_MF4 = 6306, + RISCV_PseudoVMSEQ_VI_MF4_MASK = 6307, + RISCV_PseudoVMSEQ_VI_MF8 = 6308, + RISCV_PseudoVMSEQ_VI_MF8_MASK = 6309, + RISCV_PseudoVMSEQ_VV_M1 = 6310, + RISCV_PseudoVMSEQ_VV_M1_MASK = 6311, + RISCV_PseudoVMSEQ_VV_M2 = 6312, + RISCV_PseudoVMSEQ_VV_M2_MASK = 6313, + RISCV_PseudoVMSEQ_VV_M4 = 6314, + RISCV_PseudoVMSEQ_VV_M4_MASK = 6315, + RISCV_PseudoVMSEQ_VV_M8 = 6316, + RISCV_PseudoVMSEQ_VV_M8_MASK = 6317, + RISCV_PseudoVMSEQ_VV_MF2 = 6318, + RISCV_PseudoVMSEQ_VV_MF2_MASK = 6319, + RISCV_PseudoVMSEQ_VV_MF4 = 6320, + RISCV_PseudoVMSEQ_VV_MF4_MASK = 6321, + RISCV_PseudoVMSEQ_VV_MF8 = 6322, + RISCV_PseudoVMSEQ_VV_MF8_MASK = 6323, + RISCV_PseudoVMSEQ_VX_M1 = 6324, + RISCV_PseudoVMSEQ_VX_M1_MASK = 6325, + RISCV_PseudoVMSEQ_VX_M2 = 6326, + RISCV_PseudoVMSEQ_VX_M2_MASK = 6327, + RISCV_PseudoVMSEQ_VX_M4 = 6328, + RISCV_PseudoVMSEQ_VX_M4_MASK = 6329, + RISCV_PseudoVMSEQ_VX_M8 = 6330, + RISCV_PseudoVMSEQ_VX_M8_MASK = 6331, + RISCV_PseudoVMSEQ_VX_MF2 = 6332, + RISCV_PseudoVMSEQ_VX_MF2_MASK = 6333, + RISCV_PseudoVMSEQ_VX_MF4 = 6334, + RISCV_PseudoVMSEQ_VX_MF4_MASK = 6335, + RISCV_PseudoVMSEQ_VX_MF8 = 6336, + RISCV_PseudoVMSEQ_VX_MF8_MASK = 6337, + RISCV_PseudoVMSET_M_B1 = 6338, + RISCV_PseudoVMSET_M_B16 = 6339, + RISCV_PseudoVMSET_M_B2 = 6340, + RISCV_PseudoVMSET_M_B32 = 6341, + RISCV_PseudoVMSET_M_B4 = 6342, + RISCV_PseudoVMSET_M_B64 = 6343, + RISCV_PseudoVMSET_M_B8 = 6344, + RISCV_PseudoVMSGEU_VI = 6345, + RISCV_PseudoVMSGEU_VX = 6346, + RISCV_PseudoVMSGEU_VX_M = 6347, + RISCV_PseudoVMSGEU_VX_M_T = 6348, + RISCV_PseudoVMSGE_VI = 6349, + RISCV_PseudoVMSGE_VX = 6350, + RISCV_PseudoVMSGE_VX_M = 6351, + RISCV_PseudoVMSGE_VX_M_T = 6352, + RISCV_PseudoVMSGTU_VI_M1 = 6353, + RISCV_PseudoVMSGTU_VI_M1_MASK = 6354, + RISCV_PseudoVMSGTU_VI_M2 = 6355, + RISCV_PseudoVMSGTU_VI_M2_MASK = 6356, + RISCV_PseudoVMSGTU_VI_M4 = 6357, + RISCV_PseudoVMSGTU_VI_M4_MASK = 6358, + RISCV_PseudoVMSGTU_VI_M8 = 6359, + RISCV_PseudoVMSGTU_VI_M8_MASK = 6360, + RISCV_PseudoVMSGTU_VI_MF2 = 6361, + RISCV_PseudoVMSGTU_VI_MF2_MASK = 6362, + RISCV_PseudoVMSGTU_VI_MF4 = 6363, + RISCV_PseudoVMSGTU_VI_MF4_MASK = 6364, + RISCV_PseudoVMSGTU_VI_MF8 = 6365, + RISCV_PseudoVMSGTU_VI_MF8_MASK = 6366, + RISCV_PseudoVMSGTU_VX_M1 = 6367, + RISCV_PseudoVMSGTU_VX_M1_MASK = 6368, + RISCV_PseudoVMSGTU_VX_M2 = 6369, + RISCV_PseudoVMSGTU_VX_M2_MASK = 6370, + RISCV_PseudoVMSGTU_VX_M4 = 6371, + RISCV_PseudoVMSGTU_VX_M4_MASK = 6372, + RISCV_PseudoVMSGTU_VX_M8 = 6373, + RISCV_PseudoVMSGTU_VX_M8_MASK = 6374, + RISCV_PseudoVMSGTU_VX_MF2 = 6375, + RISCV_PseudoVMSGTU_VX_MF2_MASK = 6376, + RISCV_PseudoVMSGTU_VX_MF4 = 6377, + RISCV_PseudoVMSGTU_VX_MF4_MASK = 6378, + RISCV_PseudoVMSGTU_VX_MF8 = 6379, + RISCV_PseudoVMSGTU_VX_MF8_MASK = 6380, + RISCV_PseudoVMSGT_VI_M1 = 6381, + RISCV_PseudoVMSGT_VI_M1_MASK = 6382, + RISCV_PseudoVMSGT_VI_M2 = 6383, + RISCV_PseudoVMSGT_VI_M2_MASK = 6384, + RISCV_PseudoVMSGT_VI_M4 = 6385, + RISCV_PseudoVMSGT_VI_M4_MASK = 6386, + RISCV_PseudoVMSGT_VI_M8 = 6387, + RISCV_PseudoVMSGT_VI_M8_MASK = 6388, + RISCV_PseudoVMSGT_VI_MF2 = 6389, + RISCV_PseudoVMSGT_VI_MF2_MASK = 6390, + RISCV_PseudoVMSGT_VI_MF4 = 6391, + RISCV_PseudoVMSGT_VI_MF4_MASK = 6392, + RISCV_PseudoVMSGT_VI_MF8 = 6393, + RISCV_PseudoVMSGT_VI_MF8_MASK = 6394, + RISCV_PseudoVMSGT_VX_M1 = 6395, + RISCV_PseudoVMSGT_VX_M1_MASK = 6396, + RISCV_PseudoVMSGT_VX_M2 = 6397, + RISCV_PseudoVMSGT_VX_M2_MASK = 6398, + RISCV_PseudoVMSGT_VX_M4 = 6399, + RISCV_PseudoVMSGT_VX_M4_MASK = 6400, + RISCV_PseudoVMSGT_VX_M8 = 6401, + RISCV_PseudoVMSGT_VX_M8_MASK = 6402, + RISCV_PseudoVMSGT_VX_MF2 = 6403, + RISCV_PseudoVMSGT_VX_MF2_MASK = 6404, + RISCV_PseudoVMSGT_VX_MF4 = 6405, + RISCV_PseudoVMSGT_VX_MF4_MASK = 6406, + RISCV_PseudoVMSGT_VX_MF8 = 6407, + RISCV_PseudoVMSGT_VX_MF8_MASK = 6408, + RISCV_PseudoVMSIF_M_B1 = 6409, + RISCV_PseudoVMSIF_M_B16 = 6410, + RISCV_PseudoVMSIF_M_B16_MASK = 6411, + RISCV_PseudoVMSIF_M_B1_MASK = 6412, + RISCV_PseudoVMSIF_M_B2 = 6413, + RISCV_PseudoVMSIF_M_B2_MASK = 6414, + RISCV_PseudoVMSIF_M_B32 = 6415, + RISCV_PseudoVMSIF_M_B32_MASK = 6416, + RISCV_PseudoVMSIF_M_B4 = 6417, + RISCV_PseudoVMSIF_M_B4_MASK = 6418, + RISCV_PseudoVMSIF_M_B64 = 6419, + RISCV_PseudoVMSIF_M_B64_MASK = 6420, + RISCV_PseudoVMSIF_M_B8 = 6421, + RISCV_PseudoVMSIF_M_B8_MASK = 6422, + RISCV_PseudoVMSLEU_VI_M1 = 6423, + RISCV_PseudoVMSLEU_VI_M1_MASK = 6424, + RISCV_PseudoVMSLEU_VI_M2 = 6425, + RISCV_PseudoVMSLEU_VI_M2_MASK = 6426, + RISCV_PseudoVMSLEU_VI_M4 = 6427, + RISCV_PseudoVMSLEU_VI_M4_MASK = 6428, + RISCV_PseudoVMSLEU_VI_M8 = 6429, + RISCV_PseudoVMSLEU_VI_M8_MASK = 6430, + RISCV_PseudoVMSLEU_VI_MF2 = 6431, + RISCV_PseudoVMSLEU_VI_MF2_MASK = 6432, + RISCV_PseudoVMSLEU_VI_MF4 = 6433, + RISCV_PseudoVMSLEU_VI_MF4_MASK = 6434, + RISCV_PseudoVMSLEU_VI_MF8 = 6435, + RISCV_PseudoVMSLEU_VI_MF8_MASK = 6436, + RISCV_PseudoVMSLEU_VV_M1 = 6437, + RISCV_PseudoVMSLEU_VV_M1_MASK = 6438, + RISCV_PseudoVMSLEU_VV_M2 = 6439, + RISCV_PseudoVMSLEU_VV_M2_MASK = 6440, + RISCV_PseudoVMSLEU_VV_M4 = 6441, + RISCV_PseudoVMSLEU_VV_M4_MASK = 6442, + RISCV_PseudoVMSLEU_VV_M8 = 6443, + RISCV_PseudoVMSLEU_VV_M8_MASK = 6444, + RISCV_PseudoVMSLEU_VV_MF2 = 6445, + RISCV_PseudoVMSLEU_VV_MF2_MASK = 6446, + RISCV_PseudoVMSLEU_VV_MF4 = 6447, + RISCV_PseudoVMSLEU_VV_MF4_MASK = 6448, + RISCV_PseudoVMSLEU_VV_MF8 = 6449, + RISCV_PseudoVMSLEU_VV_MF8_MASK = 6450, + RISCV_PseudoVMSLEU_VX_M1 = 6451, + RISCV_PseudoVMSLEU_VX_M1_MASK = 6452, + RISCV_PseudoVMSLEU_VX_M2 = 6453, + RISCV_PseudoVMSLEU_VX_M2_MASK = 6454, + RISCV_PseudoVMSLEU_VX_M4 = 6455, + RISCV_PseudoVMSLEU_VX_M4_MASK = 6456, + RISCV_PseudoVMSLEU_VX_M8 = 6457, + RISCV_PseudoVMSLEU_VX_M8_MASK = 6458, + RISCV_PseudoVMSLEU_VX_MF2 = 6459, + RISCV_PseudoVMSLEU_VX_MF2_MASK = 6460, + RISCV_PseudoVMSLEU_VX_MF4 = 6461, + RISCV_PseudoVMSLEU_VX_MF4_MASK = 6462, + RISCV_PseudoVMSLEU_VX_MF8 = 6463, + RISCV_PseudoVMSLEU_VX_MF8_MASK = 6464, + RISCV_PseudoVMSLE_VI_M1 = 6465, + RISCV_PseudoVMSLE_VI_M1_MASK = 6466, + RISCV_PseudoVMSLE_VI_M2 = 6467, + RISCV_PseudoVMSLE_VI_M2_MASK = 6468, + RISCV_PseudoVMSLE_VI_M4 = 6469, + RISCV_PseudoVMSLE_VI_M4_MASK = 6470, + RISCV_PseudoVMSLE_VI_M8 = 6471, + RISCV_PseudoVMSLE_VI_M8_MASK = 6472, + RISCV_PseudoVMSLE_VI_MF2 = 6473, + RISCV_PseudoVMSLE_VI_MF2_MASK = 6474, + RISCV_PseudoVMSLE_VI_MF4 = 6475, + RISCV_PseudoVMSLE_VI_MF4_MASK = 6476, + RISCV_PseudoVMSLE_VI_MF8 = 6477, + RISCV_PseudoVMSLE_VI_MF8_MASK = 6478, + RISCV_PseudoVMSLE_VV_M1 = 6479, + RISCV_PseudoVMSLE_VV_M1_MASK = 6480, + RISCV_PseudoVMSLE_VV_M2 = 6481, + RISCV_PseudoVMSLE_VV_M2_MASK = 6482, + RISCV_PseudoVMSLE_VV_M4 = 6483, + RISCV_PseudoVMSLE_VV_M4_MASK = 6484, + RISCV_PseudoVMSLE_VV_M8 = 6485, + RISCV_PseudoVMSLE_VV_M8_MASK = 6486, + RISCV_PseudoVMSLE_VV_MF2 = 6487, + RISCV_PseudoVMSLE_VV_MF2_MASK = 6488, + RISCV_PseudoVMSLE_VV_MF4 = 6489, + RISCV_PseudoVMSLE_VV_MF4_MASK = 6490, + RISCV_PseudoVMSLE_VV_MF8 = 6491, + RISCV_PseudoVMSLE_VV_MF8_MASK = 6492, + RISCV_PseudoVMSLE_VX_M1 = 6493, + RISCV_PseudoVMSLE_VX_M1_MASK = 6494, + RISCV_PseudoVMSLE_VX_M2 = 6495, + RISCV_PseudoVMSLE_VX_M2_MASK = 6496, + RISCV_PseudoVMSLE_VX_M4 = 6497, + RISCV_PseudoVMSLE_VX_M4_MASK = 6498, + RISCV_PseudoVMSLE_VX_M8 = 6499, + RISCV_PseudoVMSLE_VX_M8_MASK = 6500, + RISCV_PseudoVMSLE_VX_MF2 = 6501, + RISCV_PseudoVMSLE_VX_MF2_MASK = 6502, + RISCV_PseudoVMSLE_VX_MF4 = 6503, + RISCV_PseudoVMSLE_VX_MF4_MASK = 6504, + RISCV_PseudoVMSLE_VX_MF8 = 6505, + RISCV_PseudoVMSLE_VX_MF8_MASK = 6506, + RISCV_PseudoVMSLTU_VI = 6507, + RISCV_PseudoVMSLTU_VV_M1 = 6508, + RISCV_PseudoVMSLTU_VV_M1_MASK = 6509, + RISCV_PseudoVMSLTU_VV_M2 = 6510, + RISCV_PseudoVMSLTU_VV_M2_MASK = 6511, + RISCV_PseudoVMSLTU_VV_M4 = 6512, + RISCV_PseudoVMSLTU_VV_M4_MASK = 6513, + RISCV_PseudoVMSLTU_VV_M8 = 6514, + RISCV_PseudoVMSLTU_VV_M8_MASK = 6515, + RISCV_PseudoVMSLTU_VV_MF2 = 6516, + RISCV_PseudoVMSLTU_VV_MF2_MASK = 6517, + RISCV_PseudoVMSLTU_VV_MF4 = 6518, + RISCV_PseudoVMSLTU_VV_MF4_MASK = 6519, + RISCV_PseudoVMSLTU_VV_MF8 = 6520, + RISCV_PseudoVMSLTU_VV_MF8_MASK = 6521, + RISCV_PseudoVMSLTU_VX_M1 = 6522, + RISCV_PseudoVMSLTU_VX_M1_MASK = 6523, + RISCV_PseudoVMSLTU_VX_M2 = 6524, + RISCV_PseudoVMSLTU_VX_M2_MASK = 6525, + RISCV_PseudoVMSLTU_VX_M4 = 6526, + RISCV_PseudoVMSLTU_VX_M4_MASK = 6527, + RISCV_PseudoVMSLTU_VX_M8 = 6528, + RISCV_PseudoVMSLTU_VX_M8_MASK = 6529, + RISCV_PseudoVMSLTU_VX_MF2 = 6530, + RISCV_PseudoVMSLTU_VX_MF2_MASK = 6531, + RISCV_PseudoVMSLTU_VX_MF4 = 6532, + RISCV_PseudoVMSLTU_VX_MF4_MASK = 6533, + RISCV_PseudoVMSLTU_VX_MF8 = 6534, + RISCV_PseudoVMSLTU_VX_MF8_MASK = 6535, + RISCV_PseudoVMSLT_VI = 6536, + RISCV_PseudoVMSLT_VV_M1 = 6537, + RISCV_PseudoVMSLT_VV_M1_MASK = 6538, + RISCV_PseudoVMSLT_VV_M2 = 6539, + RISCV_PseudoVMSLT_VV_M2_MASK = 6540, + RISCV_PseudoVMSLT_VV_M4 = 6541, + RISCV_PseudoVMSLT_VV_M4_MASK = 6542, + RISCV_PseudoVMSLT_VV_M8 = 6543, + RISCV_PseudoVMSLT_VV_M8_MASK = 6544, + RISCV_PseudoVMSLT_VV_MF2 = 6545, + RISCV_PseudoVMSLT_VV_MF2_MASK = 6546, + RISCV_PseudoVMSLT_VV_MF4 = 6547, + RISCV_PseudoVMSLT_VV_MF4_MASK = 6548, + RISCV_PseudoVMSLT_VV_MF8 = 6549, + RISCV_PseudoVMSLT_VV_MF8_MASK = 6550, + RISCV_PseudoVMSLT_VX_M1 = 6551, + RISCV_PseudoVMSLT_VX_M1_MASK = 6552, + RISCV_PseudoVMSLT_VX_M2 = 6553, + RISCV_PseudoVMSLT_VX_M2_MASK = 6554, + RISCV_PseudoVMSLT_VX_M4 = 6555, + RISCV_PseudoVMSLT_VX_M4_MASK = 6556, + RISCV_PseudoVMSLT_VX_M8 = 6557, + RISCV_PseudoVMSLT_VX_M8_MASK = 6558, + RISCV_PseudoVMSLT_VX_MF2 = 6559, + RISCV_PseudoVMSLT_VX_MF2_MASK = 6560, + RISCV_PseudoVMSLT_VX_MF4 = 6561, + RISCV_PseudoVMSLT_VX_MF4_MASK = 6562, + RISCV_PseudoVMSLT_VX_MF8 = 6563, + RISCV_PseudoVMSLT_VX_MF8_MASK = 6564, + RISCV_PseudoVMSNE_VI_M1 = 6565, + RISCV_PseudoVMSNE_VI_M1_MASK = 6566, + RISCV_PseudoVMSNE_VI_M2 = 6567, + RISCV_PseudoVMSNE_VI_M2_MASK = 6568, + RISCV_PseudoVMSNE_VI_M4 = 6569, + RISCV_PseudoVMSNE_VI_M4_MASK = 6570, + RISCV_PseudoVMSNE_VI_M8 = 6571, + RISCV_PseudoVMSNE_VI_M8_MASK = 6572, + RISCV_PseudoVMSNE_VI_MF2 = 6573, + RISCV_PseudoVMSNE_VI_MF2_MASK = 6574, + RISCV_PseudoVMSNE_VI_MF4 = 6575, + RISCV_PseudoVMSNE_VI_MF4_MASK = 6576, + RISCV_PseudoVMSNE_VI_MF8 = 6577, + RISCV_PseudoVMSNE_VI_MF8_MASK = 6578, + RISCV_PseudoVMSNE_VV_M1 = 6579, + RISCV_PseudoVMSNE_VV_M1_MASK = 6580, + RISCV_PseudoVMSNE_VV_M2 = 6581, + RISCV_PseudoVMSNE_VV_M2_MASK = 6582, + RISCV_PseudoVMSNE_VV_M4 = 6583, + RISCV_PseudoVMSNE_VV_M4_MASK = 6584, + RISCV_PseudoVMSNE_VV_M8 = 6585, + RISCV_PseudoVMSNE_VV_M8_MASK = 6586, + RISCV_PseudoVMSNE_VV_MF2 = 6587, + RISCV_PseudoVMSNE_VV_MF2_MASK = 6588, + RISCV_PseudoVMSNE_VV_MF4 = 6589, + RISCV_PseudoVMSNE_VV_MF4_MASK = 6590, + RISCV_PseudoVMSNE_VV_MF8 = 6591, + RISCV_PseudoVMSNE_VV_MF8_MASK = 6592, + RISCV_PseudoVMSNE_VX_M1 = 6593, + RISCV_PseudoVMSNE_VX_M1_MASK = 6594, + RISCV_PseudoVMSNE_VX_M2 = 6595, + RISCV_PseudoVMSNE_VX_M2_MASK = 6596, + RISCV_PseudoVMSNE_VX_M4 = 6597, + RISCV_PseudoVMSNE_VX_M4_MASK = 6598, + RISCV_PseudoVMSNE_VX_M8 = 6599, + RISCV_PseudoVMSNE_VX_M8_MASK = 6600, + RISCV_PseudoVMSNE_VX_MF2 = 6601, + RISCV_PseudoVMSNE_VX_MF2_MASK = 6602, + RISCV_PseudoVMSNE_VX_MF4 = 6603, + RISCV_PseudoVMSNE_VX_MF4_MASK = 6604, + RISCV_PseudoVMSNE_VX_MF8 = 6605, + RISCV_PseudoVMSNE_VX_MF8_MASK = 6606, + RISCV_PseudoVMSOF_M_B1 = 6607, + RISCV_PseudoVMSOF_M_B16 = 6608, + RISCV_PseudoVMSOF_M_B16_MASK = 6609, + RISCV_PseudoVMSOF_M_B1_MASK = 6610, + RISCV_PseudoVMSOF_M_B2 = 6611, + RISCV_PseudoVMSOF_M_B2_MASK = 6612, + RISCV_PseudoVMSOF_M_B32 = 6613, + RISCV_PseudoVMSOF_M_B32_MASK = 6614, + RISCV_PseudoVMSOF_M_B4 = 6615, + RISCV_PseudoVMSOF_M_B4_MASK = 6616, + RISCV_PseudoVMSOF_M_B64 = 6617, + RISCV_PseudoVMSOF_M_B64_MASK = 6618, + RISCV_PseudoVMSOF_M_B8 = 6619, + RISCV_PseudoVMSOF_M_B8_MASK = 6620, + RISCV_PseudoVMULHSU_VV_M1 = 6621, + RISCV_PseudoVMULHSU_VV_M1_MASK = 6622, + RISCV_PseudoVMULHSU_VV_M2 = 6623, + RISCV_PseudoVMULHSU_VV_M2_MASK = 6624, + RISCV_PseudoVMULHSU_VV_M4 = 6625, + RISCV_PseudoVMULHSU_VV_M4_MASK = 6626, + RISCV_PseudoVMULHSU_VV_M8 = 6627, + RISCV_PseudoVMULHSU_VV_M8_MASK = 6628, + RISCV_PseudoVMULHSU_VV_MF2 = 6629, + RISCV_PseudoVMULHSU_VV_MF2_MASK = 6630, + RISCV_PseudoVMULHSU_VV_MF4 = 6631, + RISCV_PseudoVMULHSU_VV_MF4_MASK = 6632, + RISCV_PseudoVMULHSU_VV_MF8 = 6633, + RISCV_PseudoVMULHSU_VV_MF8_MASK = 6634, + RISCV_PseudoVMULHSU_VX_M1 = 6635, + RISCV_PseudoVMULHSU_VX_M1_MASK = 6636, + RISCV_PseudoVMULHSU_VX_M2 = 6637, + RISCV_PseudoVMULHSU_VX_M2_MASK = 6638, + RISCV_PseudoVMULHSU_VX_M4 = 6639, + RISCV_PseudoVMULHSU_VX_M4_MASK = 6640, + RISCV_PseudoVMULHSU_VX_M8 = 6641, + RISCV_PseudoVMULHSU_VX_M8_MASK = 6642, + RISCV_PseudoVMULHSU_VX_MF2 = 6643, + RISCV_PseudoVMULHSU_VX_MF2_MASK = 6644, + RISCV_PseudoVMULHSU_VX_MF4 = 6645, + RISCV_PseudoVMULHSU_VX_MF4_MASK = 6646, + RISCV_PseudoVMULHSU_VX_MF8 = 6647, + RISCV_PseudoVMULHSU_VX_MF8_MASK = 6648, + RISCV_PseudoVMULHU_VV_M1 = 6649, + RISCV_PseudoVMULHU_VV_M1_MASK = 6650, + RISCV_PseudoVMULHU_VV_M2 = 6651, + RISCV_PseudoVMULHU_VV_M2_MASK = 6652, + RISCV_PseudoVMULHU_VV_M4 = 6653, + RISCV_PseudoVMULHU_VV_M4_MASK = 6654, + RISCV_PseudoVMULHU_VV_M8 = 6655, + RISCV_PseudoVMULHU_VV_M8_MASK = 6656, + RISCV_PseudoVMULHU_VV_MF2 = 6657, + RISCV_PseudoVMULHU_VV_MF2_MASK = 6658, + RISCV_PseudoVMULHU_VV_MF4 = 6659, + RISCV_PseudoVMULHU_VV_MF4_MASK = 6660, + RISCV_PseudoVMULHU_VV_MF8 = 6661, + RISCV_PseudoVMULHU_VV_MF8_MASK = 6662, + RISCV_PseudoVMULHU_VX_M1 = 6663, + RISCV_PseudoVMULHU_VX_M1_MASK = 6664, + RISCV_PseudoVMULHU_VX_M2 = 6665, + RISCV_PseudoVMULHU_VX_M2_MASK = 6666, + RISCV_PseudoVMULHU_VX_M4 = 6667, + RISCV_PseudoVMULHU_VX_M4_MASK = 6668, + RISCV_PseudoVMULHU_VX_M8 = 6669, + RISCV_PseudoVMULHU_VX_M8_MASK = 6670, + RISCV_PseudoVMULHU_VX_MF2 = 6671, + RISCV_PseudoVMULHU_VX_MF2_MASK = 6672, + RISCV_PseudoVMULHU_VX_MF4 = 6673, + RISCV_PseudoVMULHU_VX_MF4_MASK = 6674, + RISCV_PseudoVMULHU_VX_MF8 = 6675, + RISCV_PseudoVMULHU_VX_MF8_MASK = 6676, + RISCV_PseudoVMULH_VV_M1 = 6677, + RISCV_PseudoVMULH_VV_M1_MASK = 6678, + RISCV_PseudoVMULH_VV_M2 = 6679, + RISCV_PseudoVMULH_VV_M2_MASK = 6680, + RISCV_PseudoVMULH_VV_M4 = 6681, + RISCV_PseudoVMULH_VV_M4_MASK = 6682, + RISCV_PseudoVMULH_VV_M8 = 6683, + RISCV_PseudoVMULH_VV_M8_MASK = 6684, + RISCV_PseudoVMULH_VV_MF2 = 6685, + RISCV_PseudoVMULH_VV_MF2_MASK = 6686, + RISCV_PseudoVMULH_VV_MF4 = 6687, + RISCV_PseudoVMULH_VV_MF4_MASK = 6688, + RISCV_PseudoVMULH_VV_MF8 = 6689, + RISCV_PseudoVMULH_VV_MF8_MASK = 6690, + RISCV_PseudoVMULH_VX_M1 = 6691, + RISCV_PseudoVMULH_VX_M1_MASK = 6692, + RISCV_PseudoVMULH_VX_M2 = 6693, + RISCV_PseudoVMULH_VX_M2_MASK = 6694, + RISCV_PseudoVMULH_VX_M4 = 6695, + RISCV_PseudoVMULH_VX_M4_MASK = 6696, + RISCV_PseudoVMULH_VX_M8 = 6697, + RISCV_PseudoVMULH_VX_M8_MASK = 6698, + RISCV_PseudoVMULH_VX_MF2 = 6699, + RISCV_PseudoVMULH_VX_MF2_MASK = 6700, + RISCV_PseudoVMULH_VX_MF4 = 6701, + RISCV_PseudoVMULH_VX_MF4_MASK = 6702, + RISCV_PseudoVMULH_VX_MF8 = 6703, + RISCV_PseudoVMULH_VX_MF8_MASK = 6704, + RISCV_PseudoVMUL_VV_M1 = 6705, + RISCV_PseudoVMUL_VV_M1_MASK = 6706, + RISCV_PseudoVMUL_VV_M2 = 6707, + RISCV_PseudoVMUL_VV_M2_MASK = 6708, + RISCV_PseudoVMUL_VV_M4 = 6709, + RISCV_PseudoVMUL_VV_M4_MASK = 6710, + RISCV_PseudoVMUL_VV_M8 = 6711, + RISCV_PseudoVMUL_VV_M8_MASK = 6712, + RISCV_PseudoVMUL_VV_MF2 = 6713, + RISCV_PseudoVMUL_VV_MF2_MASK = 6714, + RISCV_PseudoVMUL_VV_MF4 = 6715, + RISCV_PseudoVMUL_VV_MF4_MASK = 6716, + RISCV_PseudoVMUL_VV_MF8 = 6717, + RISCV_PseudoVMUL_VV_MF8_MASK = 6718, + RISCV_PseudoVMUL_VX_M1 = 6719, + RISCV_PseudoVMUL_VX_M1_MASK = 6720, + RISCV_PseudoVMUL_VX_M2 = 6721, + RISCV_PseudoVMUL_VX_M2_MASK = 6722, + RISCV_PseudoVMUL_VX_M4 = 6723, + RISCV_PseudoVMUL_VX_M4_MASK = 6724, + RISCV_PseudoVMUL_VX_M8 = 6725, + RISCV_PseudoVMUL_VX_M8_MASK = 6726, + RISCV_PseudoVMUL_VX_MF2 = 6727, + RISCV_PseudoVMUL_VX_MF2_MASK = 6728, + RISCV_PseudoVMUL_VX_MF4 = 6729, + RISCV_PseudoVMUL_VX_MF4_MASK = 6730, + RISCV_PseudoVMUL_VX_MF8 = 6731, + RISCV_PseudoVMUL_VX_MF8_MASK = 6732, + RISCV_PseudoVMV_S_X = 6733, + RISCV_PseudoVMV_V_I_M1 = 6734, + RISCV_PseudoVMV_V_I_M2 = 6735, + RISCV_PseudoVMV_V_I_M4 = 6736, + RISCV_PseudoVMV_V_I_M8 = 6737, + RISCV_PseudoVMV_V_I_MF2 = 6738, + RISCV_PseudoVMV_V_I_MF4 = 6739, + RISCV_PseudoVMV_V_I_MF8 = 6740, + RISCV_PseudoVMV_V_V_M1 = 6741, + RISCV_PseudoVMV_V_V_M2 = 6742, + RISCV_PseudoVMV_V_V_M4 = 6743, + RISCV_PseudoVMV_V_V_M8 = 6744, + RISCV_PseudoVMV_V_V_MF2 = 6745, + RISCV_PseudoVMV_V_V_MF4 = 6746, + RISCV_PseudoVMV_V_V_MF8 = 6747, + RISCV_PseudoVMV_V_X_M1 = 6748, + RISCV_PseudoVMV_V_X_M2 = 6749, + RISCV_PseudoVMV_V_X_M4 = 6750, + RISCV_PseudoVMV_V_X_M8 = 6751, + RISCV_PseudoVMV_V_X_MF2 = 6752, + RISCV_PseudoVMV_V_X_MF4 = 6753, + RISCV_PseudoVMV_V_X_MF8 = 6754, + RISCV_PseudoVMV_X_S = 6755, + RISCV_PseudoVMXNOR_MM_M1 = 6756, + RISCV_PseudoVMXNOR_MM_M2 = 6757, + RISCV_PseudoVMXNOR_MM_M4 = 6758, + RISCV_PseudoVMXNOR_MM_M8 = 6759, + RISCV_PseudoVMXNOR_MM_MF2 = 6760, + RISCV_PseudoVMXNOR_MM_MF4 = 6761, + RISCV_PseudoVMXNOR_MM_MF8 = 6762, + RISCV_PseudoVMXOR_MM_M1 = 6763, + RISCV_PseudoVMXOR_MM_M2 = 6764, + RISCV_PseudoVMXOR_MM_M4 = 6765, + RISCV_PseudoVMXOR_MM_M8 = 6766, + RISCV_PseudoVMXOR_MM_MF2 = 6767, + RISCV_PseudoVMXOR_MM_MF4 = 6768, + RISCV_PseudoVMXOR_MM_MF8 = 6769, + RISCV_PseudoVNCLIPU_WI_M1 = 6770, + RISCV_PseudoVNCLIPU_WI_M1_MASK = 6771, + RISCV_PseudoVNCLIPU_WI_M2 = 6772, + RISCV_PseudoVNCLIPU_WI_M2_MASK = 6773, + RISCV_PseudoVNCLIPU_WI_M4 = 6774, + RISCV_PseudoVNCLIPU_WI_M4_MASK = 6775, + RISCV_PseudoVNCLIPU_WI_MF2 = 6776, + RISCV_PseudoVNCLIPU_WI_MF2_MASK = 6777, + RISCV_PseudoVNCLIPU_WI_MF4 = 6778, + RISCV_PseudoVNCLIPU_WI_MF4_MASK = 6779, + RISCV_PseudoVNCLIPU_WI_MF8 = 6780, + RISCV_PseudoVNCLIPU_WI_MF8_MASK = 6781, + RISCV_PseudoVNCLIPU_WV_M1 = 6782, + RISCV_PseudoVNCLIPU_WV_M1_MASK = 6783, + RISCV_PseudoVNCLIPU_WV_M2 = 6784, + RISCV_PseudoVNCLIPU_WV_M2_MASK = 6785, + RISCV_PseudoVNCLIPU_WV_M4 = 6786, + RISCV_PseudoVNCLIPU_WV_M4_MASK = 6787, + RISCV_PseudoVNCLIPU_WV_MF2 = 6788, + RISCV_PseudoVNCLIPU_WV_MF2_MASK = 6789, + RISCV_PseudoVNCLIPU_WV_MF4 = 6790, + RISCV_PseudoVNCLIPU_WV_MF4_MASK = 6791, + RISCV_PseudoVNCLIPU_WV_MF8 = 6792, + RISCV_PseudoVNCLIPU_WV_MF8_MASK = 6793, + RISCV_PseudoVNCLIPU_WX_M1 = 6794, + RISCV_PseudoVNCLIPU_WX_M1_MASK = 6795, + RISCV_PseudoVNCLIPU_WX_M2 = 6796, + RISCV_PseudoVNCLIPU_WX_M2_MASK = 6797, + RISCV_PseudoVNCLIPU_WX_M4 = 6798, + RISCV_PseudoVNCLIPU_WX_M4_MASK = 6799, + RISCV_PseudoVNCLIPU_WX_MF2 = 6800, + RISCV_PseudoVNCLIPU_WX_MF2_MASK = 6801, + RISCV_PseudoVNCLIPU_WX_MF4 = 6802, + RISCV_PseudoVNCLIPU_WX_MF4_MASK = 6803, + RISCV_PseudoVNCLIPU_WX_MF8 = 6804, + RISCV_PseudoVNCLIPU_WX_MF8_MASK = 6805, + RISCV_PseudoVNCLIP_WI_M1 = 6806, + RISCV_PseudoVNCLIP_WI_M1_MASK = 6807, + RISCV_PseudoVNCLIP_WI_M2 = 6808, + RISCV_PseudoVNCLIP_WI_M2_MASK = 6809, + RISCV_PseudoVNCLIP_WI_M4 = 6810, + RISCV_PseudoVNCLIP_WI_M4_MASK = 6811, + RISCV_PseudoVNCLIP_WI_MF2 = 6812, + RISCV_PseudoVNCLIP_WI_MF2_MASK = 6813, + RISCV_PseudoVNCLIP_WI_MF4 = 6814, + RISCV_PseudoVNCLIP_WI_MF4_MASK = 6815, + RISCV_PseudoVNCLIP_WI_MF8 = 6816, + RISCV_PseudoVNCLIP_WI_MF8_MASK = 6817, + RISCV_PseudoVNCLIP_WV_M1 = 6818, + RISCV_PseudoVNCLIP_WV_M1_MASK = 6819, + RISCV_PseudoVNCLIP_WV_M2 = 6820, + RISCV_PseudoVNCLIP_WV_M2_MASK = 6821, + RISCV_PseudoVNCLIP_WV_M4 = 6822, + RISCV_PseudoVNCLIP_WV_M4_MASK = 6823, + RISCV_PseudoVNCLIP_WV_MF2 = 6824, + RISCV_PseudoVNCLIP_WV_MF2_MASK = 6825, + RISCV_PseudoVNCLIP_WV_MF4 = 6826, + RISCV_PseudoVNCLIP_WV_MF4_MASK = 6827, + RISCV_PseudoVNCLIP_WV_MF8 = 6828, + RISCV_PseudoVNCLIP_WV_MF8_MASK = 6829, + RISCV_PseudoVNCLIP_WX_M1 = 6830, + RISCV_PseudoVNCLIP_WX_M1_MASK = 6831, + RISCV_PseudoVNCLIP_WX_M2 = 6832, + RISCV_PseudoVNCLIP_WX_M2_MASK = 6833, + RISCV_PseudoVNCLIP_WX_M4 = 6834, + RISCV_PseudoVNCLIP_WX_M4_MASK = 6835, + RISCV_PseudoVNCLIP_WX_MF2 = 6836, + RISCV_PseudoVNCLIP_WX_MF2_MASK = 6837, + RISCV_PseudoVNCLIP_WX_MF4 = 6838, + RISCV_PseudoVNCLIP_WX_MF4_MASK = 6839, + RISCV_PseudoVNCLIP_WX_MF8 = 6840, + RISCV_PseudoVNCLIP_WX_MF8_MASK = 6841, + RISCV_PseudoVNMSAC_VV_M1 = 6842, + RISCV_PseudoVNMSAC_VV_M1_MASK = 6843, + RISCV_PseudoVNMSAC_VV_M2 = 6844, + RISCV_PseudoVNMSAC_VV_M2_MASK = 6845, + RISCV_PseudoVNMSAC_VV_M4 = 6846, + RISCV_PseudoVNMSAC_VV_M4_MASK = 6847, + RISCV_PseudoVNMSAC_VV_M8 = 6848, + RISCV_PseudoVNMSAC_VV_M8_MASK = 6849, + RISCV_PseudoVNMSAC_VV_MF2 = 6850, + RISCV_PseudoVNMSAC_VV_MF2_MASK = 6851, + RISCV_PseudoVNMSAC_VV_MF4 = 6852, + RISCV_PseudoVNMSAC_VV_MF4_MASK = 6853, + RISCV_PseudoVNMSAC_VV_MF8 = 6854, + RISCV_PseudoVNMSAC_VV_MF8_MASK = 6855, + RISCV_PseudoVNMSAC_VX_M1 = 6856, + RISCV_PseudoVNMSAC_VX_M1_MASK = 6857, + RISCV_PseudoVNMSAC_VX_M2 = 6858, + RISCV_PseudoVNMSAC_VX_M2_MASK = 6859, + RISCV_PseudoVNMSAC_VX_M4 = 6860, + RISCV_PseudoVNMSAC_VX_M4_MASK = 6861, + RISCV_PseudoVNMSAC_VX_M8 = 6862, + RISCV_PseudoVNMSAC_VX_M8_MASK = 6863, + RISCV_PseudoVNMSAC_VX_MF2 = 6864, + RISCV_PseudoVNMSAC_VX_MF2_MASK = 6865, + RISCV_PseudoVNMSAC_VX_MF4 = 6866, + RISCV_PseudoVNMSAC_VX_MF4_MASK = 6867, + RISCV_PseudoVNMSAC_VX_MF8 = 6868, + RISCV_PseudoVNMSAC_VX_MF8_MASK = 6869, + RISCV_PseudoVNMSUB_VV_M1 = 6870, + RISCV_PseudoVNMSUB_VV_M1_MASK = 6871, + RISCV_PseudoVNMSUB_VV_M2 = 6872, + RISCV_PseudoVNMSUB_VV_M2_MASK = 6873, + RISCV_PseudoVNMSUB_VV_M4 = 6874, + RISCV_PseudoVNMSUB_VV_M4_MASK = 6875, + RISCV_PseudoVNMSUB_VV_M8 = 6876, + RISCV_PseudoVNMSUB_VV_M8_MASK = 6877, + RISCV_PseudoVNMSUB_VV_MF2 = 6878, + RISCV_PseudoVNMSUB_VV_MF2_MASK = 6879, + RISCV_PseudoVNMSUB_VV_MF4 = 6880, + RISCV_PseudoVNMSUB_VV_MF4_MASK = 6881, + RISCV_PseudoVNMSUB_VV_MF8 = 6882, + RISCV_PseudoVNMSUB_VV_MF8_MASK = 6883, + RISCV_PseudoVNMSUB_VX_M1 = 6884, + RISCV_PseudoVNMSUB_VX_M1_MASK = 6885, + RISCV_PseudoVNMSUB_VX_M2 = 6886, + RISCV_PseudoVNMSUB_VX_M2_MASK = 6887, + RISCV_PseudoVNMSUB_VX_M4 = 6888, + RISCV_PseudoVNMSUB_VX_M4_MASK = 6889, + RISCV_PseudoVNMSUB_VX_M8 = 6890, + RISCV_PseudoVNMSUB_VX_M8_MASK = 6891, + RISCV_PseudoVNMSUB_VX_MF2 = 6892, + RISCV_PseudoVNMSUB_VX_MF2_MASK = 6893, + RISCV_PseudoVNMSUB_VX_MF4 = 6894, + RISCV_PseudoVNMSUB_VX_MF4_MASK = 6895, + RISCV_PseudoVNMSUB_VX_MF8 = 6896, + RISCV_PseudoVNMSUB_VX_MF8_MASK = 6897, + RISCV_PseudoVNSRA_WI_M1 = 6898, + RISCV_PseudoVNSRA_WI_M1_MASK = 6899, + RISCV_PseudoVNSRA_WI_M2 = 6900, + RISCV_PseudoVNSRA_WI_M2_MASK = 6901, + RISCV_PseudoVNSRA_WI_M4 = 6902, + RISCV_PseudoVNSRA_WI_M4_MASK = 6903, + RISCV_PseudoVNSRA_WI_MF2 = 6904, + RISCV_PseudoVNSRA_WI_MF2_MASK = 6905, + RISCV_PseudoVNSRA_WI_MF4 = 6906, + RISCV_PseudoVNSRA_WI_MF4_MASK = 6907, + RISCV_PseudoVNSRA_WI_MF8 = 6908, + RISCV_PseudoVNSRA_WI_MF8_MASK = 6909, + RISCV_PseudoVNSRA_WV_M1 = 6910, + RISCV_PseudoVNSRA_WV_M1_MASK = 6911, + RISCV_PseudoVNSRA_WV_M2 = 6912, + RISCV_PseudoVNSRA_WV_M2_MASK = 6913, + RISCV_PseudoVNSRA_WV_M4 = 6914, + RISCV_PseudoVNSRA_WV_M4_MASK = 6915, + RISCV_PseudoVNSRA_WV_MF2 = 6916, + RISCV_PseudoVNSRA_WV_MF2_MASK = 6917, + RISCV_PseudoVNSRA_WV_MF4 = 6918, + RISCV_PseudoVNSRA_WV_MF4_MASK = 6919, + RISCV_PseudoVNSRA_WV_MF8 = 6920, + RISCV_PseudoVNSRA_WV_MF8_MASK = 6921, + RISCV_PseudoVNSRA_WX_M1 = 6922, + RISCV_PseudoVNSRA_WX_M1_MASK = 6923, + RISCV_PseudoVNSRA_WX_M2 = 6924, + RISCV_PseudoVNSRA_WX_M2_MASK = 6925, + RISCV_PseudoVNSRA_WX_M4 = 6926, + RISCV_PseudoVNSRA_WX_M4_MASK = 6927, + RISCV_PseudoVNSRA_WX_MF2 = 6928, + RISCV_PseudoVNSRA_WX_MF2_MASK = 6929, + RISCV_PseudoVNSRA_WX_MF4 = 6930, + RISCV_PseudoVNSRA_WX_MF4_MASK = 6931, + RISCV_PseudoVNSRA_WX_MF8 = 6932, + RISCV_PseudoVNSRA_WX_MF8_MASK = 6933, + RISCV_PseudoVNSRL_WI_M1 = 6934, + RISCV_PseudoVNSRL_WI_M1_MASK = 6935, + RISCV_PseudoVNSRL_WI_M2 = 6936, + RISCV_PseudoVNSRL_WI_M2_MASK = 6937, + RISCV_PseudoVNSRL_WI_M4 = 6938, + RISCV_PseudoVNSRL_WI_M4_MASK = 6939, + RISCV_PseudoVNSRL_WI_MF2 = 6940, + RISCV_PseudoVNSRL_WI_MF2_MASK = 6941, + RISCV_PseudoVNSRL_WI_MF4 = 6942, + RISCV_PseudoVNSRL_WI_MF4_MASK = 6943, + RISCV_PseudoVNSRL_WI_MF8 = 6944, + RISCV_PseudoVNSRL_WI_MF8_MASK = 6945, + RISCV_PseudoVNSRL_WV_M1 = 6946, + RISCV_PseudoVNSRL_WV_M1_MASK = 6947, + RISCV_PseudoVNSRL_WV_M2 = 6948, + RISCV_PseudoVNSRL_WV_M2_MASK = 6949, + RISCV_PseudoVNSRL_WV_M4 = 6950, + RISCV_PseudoVNSRL_WV_M4_MASK = 6951, + RISCV_PseudoVNSRL_WV_MF2 = 6952, + RISCV_PseudoVNSRL_WV_MF2_MASK = 6953, + RISCV_PseudoVNSRL_WV_MF4 = 6954, + RISCV_PseudoVNSRL_WV_MF4_MASK = 6955, + RISCV_PseudoVNSRL_WV_MF8 = 6956, + RISCV_PseudoVNSRL_WV_MF8_MASK = 6957, + RISCV_PseudoVNSRL_WX_M1 = 6958, + RISCV_PseudoVNSRL_WX_M1_MASK = 6959, + RISCV_PseudoVNSRL_WX_M2 = 6960, + RISCV_PseudoVNSRL_WX_M2_MASK = 6961, + RISCV_PseudoVNSRL_WX_M4 = 6962, + RISCV_PseudoVNSRL_WX_M4_MASK = 6963, + RISCV_PseudoVNSRL_WX_MF2 = 6964, + RISCV_PseudoVNSRL_WX_MF2_MASK = 6965, + RISCV_PseudoVNSRL_WX_MF4 = 6966, + RISCV_PseudoVNSRL_WX_MF4_MASK = 6967, + RISCV_PseudoVNSRL_WX_MF8 = 6968, + RISCV_PseudoVNSRL_WX_MF8_MASK = 6969, + RISCV_PseudoVOR_VI_M1 = 6970, + RISCV_PseudoVOR_VI_M1_MASK = 6971, + RISCV_PseudoVOR_VI_M2 = 6972, + RISCV_PseudoVOR_VI_M2_MASK = 6973, + RISCV_PseudoVOR_VI_M4 = 6974, + RISCV_PseudoVOR_VI_M4_MASK = 6975, + RISCV_PseudoVOR_VI_M8 = 6976, + RISCV_PseudoVOR_VI_M8_MASK = 6977, + RISCV_PseudoVOR_VI_MF2 = 6978, + RISCV_PseudoVOR_VI_MF2_MASK = 6979, + RISCV_PseudoVOR_VI_MF4 = 6980, + RISCV_PseudoVOR_VI_MF4_MASK = 6981, + RISCV_PseudoVOR_VI_MF8 = 6982, + RISCV_PseudoVOR_VI_MF8_MASK = 6983, + RISCV_PseudoVOR_VV_M1 = 6984, + RISCV_PseudoVOR_VV_M1_MASK = 6985, + RISCV_PseudoVOR_VV_M2 = 6986, + RISCV_PseudoVOR_VV_M2_MASK = 6987, + RISCV_PseudoVOR_VV_M4 = 6988, + RISCV_PseudoVOR_VV_M4_MASK = 6989, + RISCV_PseudoVOR_VV_M8 = 6990, + RISCV_PseudoVOR_VV_M8_MASK = 6991, + RISCV_PseudoVOR_VV_MF2 = 6992, + RISCV_PseudoVOR_VV_MF2_MASK = 6993, + RISCV_PseudoVOR_VV_MF4 = 6994, + RISCV_PseudoVOR_VV_MF4_MASK = 6995, + RISCV_PseudoVOR_VV_MF8 = 6996, + RISCV_PseudoVOR_VV_MF8_MASK = 6997, + RISCV_PseudoVOR_VX_M1 = 6998, + RISCV_PseudoVOR_VX_M1_MASK = 6999, + RISCV_PseudoVOR_VX_M2 = 7000, + RISCV_PseudoVOR_VX_M2_MASK = 7001, + RISCV_PseudoVOR_VX_M4 = 7002, + RISCV_PseudoVOR_VX_M4_MASK = 7003, + RISCV_PseudoVOR_VX_M8 = 7004, + RISCV_PseudoVOR_VX_M8_MASK = 7005, + RISCV_PseudoVOR_VX_MF2 = 7006, + RISCV_PseudoVOR_VX_MF2_MASK = 7007, + RISCV_PseudoVOR_VX_MF4 = 7008, + RISCV_PseudoVOR_VX_MF4_MASK = 7009, + RISCV_PseudoVOR_VX_MF8 = 7010, + RISCV_PseudoVOR_VX_MF8_MASK = 7011, + RISCV_PseudoVQMACCSU_2x8x2_M1 = 7012, + RISCV_PseudoVQMACCSU_2x8x2_M2 = 7013, + RISCV_PseudoVQMACCSU_2x8x2_M4 = 7014, + RISCV_PseudoVQMACCSU_2x8x2_M8 = 7015, + RISCV_PseudoVQMACCSU_4x8x4_M1 = 7016, + RISCV_PseudoVQMACCSU_4x8x4_M2 = 7017, + RISCV_PseudoVQMACCSU_4x8x4_M4 = 7018, + RISCV_PseudoVQMACCSU_4x8x4_MF2 = 7019, + RISCV_PseudoVQMACCUS_2x8x2_M1 = 7020, + RISCV_PseudoVQMACCUS_2x8x2_M2 = 7021, + RISCV_PseudoVQMACCUS_2x8x2_M4 = 7022, + RISCV_PseudoVQMACCUS_2x8x2_M8 = 7023, + RISCV_PseudoVQMACCUS_4x8x4_M1 = 7024, + RISCV_PseudoVQMACCUS_4x8x4_M2 = 7025, + RISCV_PseudoVQMACCUS_4x8x4_M4 = 7026, + RISCV_PseudoVQMACCUS_4x8x4_MF2 = 7027, + RISCV_PseudoVQMACCU_2x8x2_M1 = 7028, + RISCV_PseudoVQMACCU_2x8x2_M2 = 7029, + RISCV_PseudoVQMACCU_2x8x2_M4 = 7030, + RISCV_PseudoVQMACCU_2x8x2_M8 = 7031, + RISCV_PseudoVQMACCU_4x8x4_M1 = 7032, + RISCV_PseudoVQMACCU_4x8x4_M2 = 7033, + RISCV_PseudoVQMACCU_4x8x4_M4 = 7034, + RISCV_PseudoVQMACCU_4x8x4_MF2 = 7035, + RISCV_PseudoVQMACC_2x8x2_M1 = 7036, + RISCV_PseudoVQMACC_2x8x2_M2 = 7037, + RISCV_PseudoVQMACC_2x8x2_M4 = 7038, + RISCV_PseudoVQMACC_2x8x2_M8 = 7039, + RISCV_PseudoVQMACC_4x8x4_M1 = 7040, + RISCV_PseudoVQMACC_4x8x4_M2 = 7041, + RISCV_PseudoVQMACC_4x8x4_M4 = 7042, + RISCV_PseudoVQMACC_4x8x4_MF2 = 7043, + RISCV_PseudoVREDAND_VS_M1_E16 = 7044, + RISCV_PseudoVREDAND_VS_M1_E16_MASK = 7045, + RISCV_PseudoVREDAND_VS_M1_E32 = 7046, + RISCV_PseudoVREDAND_VS_M1_E32_MASK = 7047, + RISCV_PseudoVREDAND_VS_M1_E64 = 7048, + RISCV_PseudoVREDAND_VS_M1_E64_MASK = 7049, + RISCV_PseudoVREDAND_VS_M1_E8 = 7050, + RISCV_PseudoVREDAND_VS_M1_E8_MASK = 7051, + RISCV_PseudoVREDAND_VS_M2_E16 = 7052, + RISCV_PseudoVREDAND_VS_M2_E16_MASK = 7053, + RISCV_PseudoVREDAND_VS_M2_E32 = 7054, + RISCV_PseudoVREDAND_VS_M2_E32_MASK = 7055, + RISCV_PseudoVREDAND_VS_M2_E64 = 7056, + RISCV_PseudoVREDAND_VS_M2_E64_MASK = 7057, + RISCV_PseudoVREDAND_VS_M2_E8 = 7058, + RISCV_PseudoVREDAND_VS_M2_E8_MASK = 7059, + RISCV_PseudoVREDAND_VS_M4_E16 = 7060, + RISCV_PseudoVREDAND_VS_M4_E16_MASK = 7061, + RISCV_PseudoVREDAND_VS_M4_E32 = 7062, + RISCV_PseudoVREDAND_VS_M4_E32_MASK = 7063, + RISCV_PseudoVREDAND_VS_M4_E64 = 7064, + RISCV_PseudoVREDAND_VS_M4_E64_MASK = 7065, + RISCV_PseudoVREDAND_VS_M4_E8 = 7066, + RISCV_PseudoVREDAND_VS_M4_E8_MASK = 7067, + RISCV_PseudoVREDAND_VS_M8_E16 = 7068, + RISCV_PseudoVREDAND_VS_M8_E16_MASK = 7069, + RISCV_PseudoVREDAND_VS_M8_E32 = 7070, + RISCV_PseudoVREDAND_VS_M8_E32_MASK = 7071, + RISCV_PseudoVREDAND_VS_M8_E64 = 7072, + RISCV_PseudoVREDAND_VS_M8_E64_MASK = 7073, + RISCV_PseudoVREDAND_VS_M8_E8 = 7074, + RISCV_PseudoVREDAND_VS_M8_E8_MASK = 7075, + RISCV_PseudoVREDAND_VS_MF2_E16 = 7076, + RISCV_PseudoVREDAND_VS_MF2_E16_MASK = 7077, + RISCV_PseudoVREDAND_VS_MF2_E32 = 7078, + RISCV_PseudoVREDAND_VS_MF2_E32_MASK = 7079, + RISCV_PseudoVREDAND_VS_MF2_E8 = 7080, + RISCV_PseudoVREDAND_VS_MF2_E8_MASK = 7081, + RISCV_PseudoVREDAND_VS_MF4_E16 = 7082, + RISCV_PseudoVREDAND_VS_MF4_E16_MASK = 7083, + RISCV_PseudoVREDAND_VS_MF4_E8 = 7084, + RISCV_PseudoVREDAND_VS_MF4_E8_MASK = 7085, + RISCV_PseudoVREDAND_VS_MF8_E8 = 7086, + RISCV_PseudoVREDAND_VS_MF8_E8_MASK = 7087, + RISCV_PseudoVREDMAXU_VS_M1_E16 = 7088, + RISCV_PseudoVREDMAXU_VS_M1_E16_MASK = 7089, + RISCV_PseudoVREDMAXU_VS_M1_E32 = 7090, + RISCV_PseudoVREDMAXU_VS_M1_E32_MASK = 7091, + RISCV_PseudoVREDMAXU_VS_M1_E64 = 7092, + RISCV_PseudoVREDMAXU_VS_M1_E64_MASK = 7093, + RISCV_PseudoVREDMAXU_VS_M1_E8 = 7094, + RISCV_PseudoVREDMAXU_VS_M1_E8_MASK = 7095, + RISCV_PseudoVREDMAXU_VS_M2_E16 = 7096, + RISCV_PseudoVREDMAXU_VS_M2_E16_MASK = 7097, + RISCV_PseudoVREDMAXU_VS_M2_E32 = 7098, + RISCV_PseudoVREDMAXU_VS_M2_E32_MASK = 7099, + RISCV_PseudoVREDMAXU_VS_M2_E64 = 7100, + RISCV_PseudoVREDMAXU_VS_M2_E64_MASK = 7101, + RISCV_PseudoVREDMAXU_VS_M2_E8 = 7102, + RISCV_PseudoVREDMAXU_VS_M2_E8_MASK = 7103, + RISCV_PseudoVREDMAXU_VS_M4_E16 = 7104, + RISCV_PseudoVREDMAXU_VS_M4_E16_MASK = 7105, + RISCV_PseudoVREDMAXU_VS_M4_E32 = 7106, + RISCV_PseudoVREDMAXU_VS_M4_E32_MASK = 7107, + RISCV_PseudoVREDMAXU_VS_M4_E64 = 7108, + RISCV_PseudoVREDMAXU_VS_M4_E64_MASK = 7109, + RISCV_PseudoVREDMAXU_VS_M4_E8 = 7110, + RISCV_PseudoVREDMAXU_VS_M4_E8_MASK = 7111, + RISCV_PseudoVREDMAXU_VS_M8_E16 = 7112, + RISCV_PseudoVREDMAXU_VS_M8_E16_MASK = 7113, + RISCV_PseudoVREDMAXU_VS_M8_E32 = 7114, + RISCV_PseudoVREDMAXU_VS_M8_E32_MASK = 7115, + RISCV_PseudoVREDMAXU_VS_M8_E64 = 7116, + RISCV_PseudoVREDMAXU_VS_M8_E64_MASK = 7117, + RISCV_PseudoVREDMAXU_VS_M8_E8 = 7118, + RISCV_PseudoVREDMAXU_VS_M8_E8_MASK = 7119, + RISCV_PseudoVREDMAXU_VS_MF2_E16 = 7120, + RISCV_PseudoVREDMAXU_VS_MF2_E16_MASK = 7121, + RISCV_PseudoVREDMAXU_VS_MF2_E32 = 7122, + RISCV_PseudoVREDMAXU_VS_MF2_E32_MASK = 7123, + RISCV_PseudoVREDMAXU_VS_MF2_E8 = 7124, + RISCV_PseudoVREDMAXU_VS_MF2_E8_MASK = 7125, + RISCV_PseudoVREDMAXU_VS_MF4_E16 = 7126, + RISCV_PseudoVREDMAXU_VS_MF4_E16_MASK = 7127, + RISCV_PseudoVREDMAXU_VS_MF4_E8 = 7128, + RISCV_PseudoVREDMAXU_VS_MF4_E8_MASK = 7129, + RISCV_PseudoVREDMAXU_VS_MF8_E8 = 7130, + RISCV_PseudoVREDMAXU_VS_MF8_E8_MASK = 7131, + RISCV_PseudoVREDMAX_VS_M1_E16 = 7132, + RISCV_PseudoVREDMAX_VS_M1_E16_MASK = 7133, + RISCV_PseudoVREDMAX_VS_M1_E32 = 7134, + RISCV_PseudoVREDMAX_VS_M1_E32_MASK = 7135, + RISCV_PseudoVREDMAX_VS_M1_E64 = 7136, + RISCV_PseudoVREDMAX_VS_M1_E64_MASK = 7137, + RISCV_PseudoVREDMAX_VS_M1_E8 = 7138, + RISCV_PseudoVREDMAX_VS_M1_E8_MASK = 7139, + RISCV_PseudoVREDMAX_VS_M2_E16 = 7140, + RISCV_PseudoVREDMAX_VS_M2_E16_MASK = 7141, + RISCV_PseudoVREDMAX_VS_M2_E32 = 7142, + RISCV_PseudoVREDMAX_VS_M2_E32_MASK = 7143, + RISCV_PseudoVREDMAX_VS_M2_E64 = 7144, + RISCV_PseudoVREDMAX_VS_M2_E64_MASK = 7145, + RISCV_PseudoVREDMAX_VS_M2_E8 = 7146, + RISCV_PseudoVREDMAX_VS_M2_E8_MASK = 7147, + RISCV_PseudoVREDMAX_VS_M4_E16 = 7148, + RISCV_PseudoVREDMAX_VS_M4_E16_MASK = 7149, + RISCV_PseudoVREDMAX_VS_M4_E32 = 7150, + RISCV_PseudoVREDMAX_VS_M4_E32_MASK = 7151, + RISCV_PseudoVREDMAX_VS_M4_E64 = 7152, + RISCV_PseudoVREDMAX_VS_M4_E64_MASK = 7153, + RISCV_PseudoVREDMAX_VS_M4_E8 = 7154, + RISCV_PseudoVREDMAX_VS_M4_E8_MASK = 7155, + RISCV_PseudoVREDMAX_VS_M8_E16 = 7156, + RISCV_PseudoVREDMAX_VS_M8_E16_MASK = 7157, + RISCV_PseudoVREDMAX_VS_M8_E32 = 7158, + RISCV_PseudoVREDMAX_VS_M8_E32_MASK = 7159, + RISCV_PseudoVREDMAX_VS_M8_E64 = 7160, + RISCV_PseudoVREDMAX_VS_M8_E64_MASK = 7161, + RISCV_PseudoVREDMAX_VS_M8_E8 = 7162, + RISCV_PseudoVREDMAX_VS_M8_E8_MASK = 7163, + RISCV_PseudoVREDMAX_VS_MF2_E16 = 7164, + RISCV_PseudoVREDMAX_VS_MF2_E16_MASK = 7165, + RISCV_PseudoVREDMAX_VS_MF2_E32 = 7166, + RISCV_PseudoVREDMAX_VS_MF2_E32_MASK = 7167, + RISCV_PseudoVREDMAX_VS_MF2_E8 = 7168, + RISCV_PseudoVREDMAX_VS_MF2_E8_MASK = 7169, + RISCV_PseudoVREDMAX_VS_MF4_E16 = 7170, + RISCV_PseudoVREDMAX_VS_MF4_E16_MASK = 7171, + RISCV_PseudoVREDMAX_VS_MF4_E8 = 7172, + RISCV_PseudoVREDMAX_VS_MF4_E8_MASK = 7173, + RISCV_PseudoVREDMAX_VS_MF8_E8 = 7174, + RISCV_PseudoVREDMAX_VS_MF8_E8_MASK = 7175, + RISCV_PseudoVREDMINU_VS_M1_E16 = 7176, + RISCV_PseudoVREDMINU_VS_M1_E16_MASK = 7177, + RISCV_PseudoVREDMINU_VS_M1_E32 = 7178, + RISCV_PseudoVREDMINU_VS_M1_E32_MASK = 7179, + RISCV_PseudoVREDMINU_VS_M1_E64 = 7180, + RISCV_PseudoVREDMINU_VS_M1_E64_MASK = 7181, + RISCV_PseudoVREDMINU_VS_M1_E8 = 7182, + RISCV_PseudoVREDMINU_VS_M1_E8_MASK = 7183, + RISCV_PseudoVREDMINU_VS_M2_E16 = 7184, + RISCV_PseudoVREDMINU_VS_M2_E16_MASK = 7185, + RISCV_PseudoVREDMINU_VS_M2_E32 = 7186, + RISCV_PseudoVREDMINU_VS_M2_E32_MASK = 7187, + RISCV_PseudoVREDMINU_VS_M2_E64 = 7188, + RISCV_PseudoVREDMINU_VS_M2_E64_MASK = 7189, + RISCV_PseudoVREDMINU_VS_M2_E8 = 7190, + RISCV_PseudoVREDMINU_VS_M2_E8_MASK = 7191, + RISCV_PseudoVREDMINU_VS_M4_E16 = 7192, + RISCV_PseudoVREDMINU_VS_M4_E16_MASK = 7193, + RISCV_PseudoVREDMINU_VS_M4_E32 = 7194, + RISCV_PseudoVREDMINU_VS_M4_E32_MASK = 7195, + RISCV_PseudoVREDMINU_VS_M4_E64 = 7196, + RISCV_PseudoVREDMINU_VS_M4_E64_MASK = 7197, + RISCV_PseudoVREDMINU_VS_M4_E8 = 7198, + RISCV_PseudoVREDMINU_VS_M4_E8_MASK = 7199, + RISCV_PseudoVREDMINU_VS_M8_E16 = 7200, + RISCV_PseudoVREDMINU_VS_M8_E16_MASK = 7201, + RISCV_PseudoVREDMINU_VS_M8_E32 = 7202, + RISCV_PseudoVREDMINU_VS_M8_E32_MASK = 7203, + RISCV_PseudoVREDMINU_VS_M8_E64 = 7204, + RISCV_PseudoVREDMINU_VS_M8_E64_MASK = 7205, + RISCV_PseudoVREDMINU_VS_M8_E8 = 7206, + RISCV_PseudoVREDMINU_VS_M8_E8_MASK = 7207, + RISCV_PseudoVREDMINU_VS_MF2_E16 = 7208, + RISCV_PseudoVREDMINU_VS_MF2_E16_MASK = 7209, + RISCV_PseudoVREDMINU_VS_MF2_E32 = 7210, + RISCV_PseudoVREDMINU_VS_MF2_E32_MASK = 7211, + RISCV_PseudoVREDMINU_VS_MF2_E8 = 7212, + RISCV_PseudoVREDMINU_VS_MF2_E8_MASK = 7213, + RISCV_PseudoVREDMINU_VS_MF4_E16 = 7214, + RISCV_PseudoVREDMINU_VS_MF4_E16_MASK = 7215, + RISCV_PseudoVREDMINU_VS_MF4_E8 = 7216, + RISCV_PseudoVREDMINU_VS_MF4_E8_MASK = 7217, + RISCV_PseudoVREDMINU_VS_MF8_E8 = 7218, + RISCV_PseudoVREDMINU_VS_MF8_E8_MASK = 7219, + RISCV_PseudoVREDMIN_VS_M1_E16 = 7220, + RISCV_PseudoVREDMIN_VS_M1_E16_MASK = 7221, + RISCV_PseudoVREDMIN_VS_M1_E32 = 7222, + RISCV_PseudoVREDMIN_VS_M1_E32_MASK = 7223, + RISCV_PseudoVREDMIN_VS_M1_E64 = 7224, + RISCV_PseudoVREDMIN_VS_M1_E64_MASK = 7225, + RISCV_PseudoVREDMIN_VS_M1_E8 = 7226, + RISCV_PseudoVREDMIN_VS_M1_E8_MASK = 7227, + RISCV_PseudoVREDMIN_VS_M2_E16 = 7228, + RISCV_PseudoVREDMIN_VS_M2_E16_MASK = 7229, + RISCV_PseudoVREDMIN_VS_M2_E32 = 7230, + RISCV_PseudoVREDMIN_VS_M2_E32_MASK = 7231, + RISCV_PseudoVREDMIN_VS_M2_E64 = 7232, + RISCV_PseudoVREDMIN_VS_M2_E64_MASK = 7233, + RISCV_PseudoVREDMIN_VS_M2_E8 = 7234, + RISCV_PseudoVREDMIN_VS_M2_E8_MASK = 7235, + RISCV_PseudoVREDMIN_VS_M4_E16 = 7236, + RISCV_PseudoVREDMIN_VS_M4_E16_MASK = 7237, + RISCV_PseudoVREDMIN_VS_M4_E32 = 7238, + RISCV_PseudoVREDMIN_VS_M4_E32_MASK = 7239, + RISCV_PseudoVREDMIN_VS_M4_E64 = 7240, + RISCV_PseudoVREDMIN_VS_M4_E64_MASK = 7241, + RISCV_PseudoVREDMIN_VS_M4_E8 = 7242, + RISCV_PseudoVREDMIN_VS_M4_E8_MASK = 7243, + RISCV_PseudoVREDMIN_VS_M8_E16 = 7244, + RISCV_PseudoVREDMIN_VS_M8_E16_MASK = 7245, + RISCV_PseudoVREDMIN_VS_M8_E32 = 7246, + RISCV_PseudoVREDMIN_VS_M8_E32_MASK = 7247, + RISCV_PseudoVREDMIN_VS_M8_E64 = 7248, + RISCV_PseudoVREDMIN_VS_M8_E64_MASK = 7249, + RISCV_PseudoVREDMIN_VS_M8_E8 = 7250, + RISCV_PseudoVREDMIN_VS_M8_E8_MASK = 7251, + RISCV_PseudoVREDMIN_VS_MF2_E16 = 7252, + RISCV_PseudoVREDMIN_VS_MF2_E16_MASK = 7253, + RISCV_PseudoVREDMIN_VS_MF2_E32 = 7254, + RISCV_PseudoVREDMIN_VS_MF2_E32_MASK = 7255, + RISCV_PseudoVREDMIN_VS_MF2_E8 = 7256, + RISCV_PseudoVREDMIN_VS_MF2_E8_MASK = 7257, + RISCV_PseudoVREDMIN_VS_MF4_E16 = 7258, + RISCV_PseudoVREDMIN_VS_MF4_E16_MASK = 7259, + RISCV_PseudoVREDMIN_VS_MF4_E8 = 7260, + RISCV_PseudoVREDMIN_VS_MF4_E8_MASK = 7261, + RISCV_PseudoVREDMIN_VS_MF8_E8 = 7262, + RISCV_PseudoVREDMIN_VS_MF8_E8_MASK = 7263, + RISCV_PseudoVREDOR_VS_M1_E16 = 7264, + RISCV_PseudoVREDOR_VS_M1_E16_MASK = 7265, + RISCV_PseudoVREDOR_VS_M1_E32 = 7266, + RISCV_PseudoVREDOR_VS_M1_E32_MASK = 7267, + RISCV_PseudoVREDOR_VS_M1_E64 = 7268, + RISCV_PseudoVREDOR_VS_M1_E64_MASK = 7269, + RISCV_PseudoVREDOR_VS_M1_E8 = 7270, + RISCV_PseudoVREDOR_VS_M1_E8_MASK = 7271, + RISCV_PseudoVREDOR_VS_M2_E16 = 7272, + RISCV_PseudoVREDOR_VS_M2_E16_MASK = 7273, + RISCV_PseudoVREDOR_VS_M2_E32 = 7274, + RISCV_PseudoVREDOR_VS_M2_E32_MASK = 7275, + RISCV_PseudoVREDOR_VS_M2_E64 = 7276, + RISCV_PseudoVREDOR_VS_M2_E64_MASK = 7277, + RISCV_PseudoVREDOR_VS_M2_E8 = 7278, + RISCV_PseudoVREDOR_VS_M2_E8_MASK = 7279, + RISCV_PseudoVREDOR_VS_M4_E16 = 7280, + RISCV_PseudoVREDOR_VS_M4_E16_MASK = 7281, + RISCV_PseudoVREDOR_VS_M4_E32 = 7282, + RISCV_PseudoVREDOR_VS_M4_E32_MASK = 7283, + RISCV_PseudoVREDOR_VS_M4_E64 = 7284, + RISCV_PseudoVREDOR_VS_M4_E64_MASK = 7285, + RISCV_PseudoVREDOR_VS_M4_E8 = 7286, + RISCV_PseudoVREDOR_VS_M4_E8_MASK = 7287, + RISCV_PseudoVREDOR_VS_M8_E16 = 7288, + RISCV_PseudoVREDOR_VS_M8_E16_MASK = 7289, + RISCV_PseudoVREDOR_VS_M8_E32 = 7290, + RISCV_PseudoVREDOR_VS_M8_E32_MASK = 7291, + RISCV_PseudoVREDOR_VS_M8_E64 = 7292, + RISCV_PseudoVREDOR_VS_M8_E64_MASK = 7293, + RISCV_PseudoVREDOR_VS_M8_E8 = 7294, + RISCV_PseudoVREDOR_VS_M8_E8_MASK = 7295, + RISCV_PseudoVREDOR_VS_MF2_E16 = 7296, + RISCV_PseudoVREDOR_VS_MF2_E16_MASK = 7297, + RISCV_PseudoVREDOR_VS_MF2_E32 = 7298, + RISCV_PseudoVREDOR_VS_MF2_E32_MASK = 7299, + RISCV_PseudoVREDOR_VS_MF2_E8 = 7300, + RISCV_PseudoVREDOR_VS_MF2_E8_MASK = 7301, + RISCV_PseudoVREDOR_VS_MF4_E16 = 7302, + RISCV_PseudoVREDOR_VS_MF4_E16_MASK = 7303, + RISCV_PseudoVREDOR_VS_MF4_E8 = 7304, + RISCV_PseudoVREDOR_VS_MF4_E8_MASK = 7305, + RISCV_PseudoVREDOR_VS_MF8_E8 = 7306, + RISCV_PseudoVREDOR_VS_MF8_E8_MASK = 7307, + RISCV_PseudoVREDSUM_VS_M1_E16 = 7308, + RISCV_PseudoVREDSUM_VS_M1_E16_MASK = 7309, + RISCV_PseudoVREDSUM_VS_M1_E32 = 7310, + RISCV_PseudoVREDSUM_VS_M1_E32_MASK = 7311, + RISCV_PseudoVREDSUM_VS_M1_E64 = 7312, + RISCV_PseudoVREDSUM_VS_M1_E64_MASK = 7313, + RISCV_PseudoVREDSUM_VS_M1_E8 = 7314, + RISCV_PseudoVREDSUM_VS_M1_E8_MASK = 7315, + RISCV_PseudoVREDSUM_VS_M2_E16 = 7316, + RISCV_PseudoVREDSUM_VS_M2_E16_MASK = 7317, + RISCV_PseudoVREDSUM_VS_M2_E32 = 7318, + RISCV_PseudoVREDSUM_VS_M2_E32_MASK = 7319, + RISCV_PseudoVREDSUM_VS_M2_E64 = 7320, + RISCV_PseudoVREDSUM_VS_M2_E64_MASK = 7321, + RISCV_PseudoVREDSUM_VS_M2_E8 = 7322, + RISCV_PseudoVREDSUM_VS_M2_E8_MASK = 7323, + RISCV_PseudoVREDSUM_VS_M4_E16 = 7324, + RISCV_PseudoVREDSUM_VS_M4_E16_MASK = 7325, + RISCV_PseudoVREDSUM_VS_M4_E32 = 7326, + RISCV_PseudoVREDSUM_VS_M4_E32_MASK = 7327, + RISCV_PseudoVREDSUM_VS_M4_E64 = 7328, + RISCV_PseudoVREDSUM_VS_M4_E64_MASK = 7329, + RISCV_PseudoVREDSUM_VS_M4_E8 = 7330, + RISCV_PseudoVREDSUM_VS_M4_E8_MASK = 7331, + RISCV_PseudoVREDSUM_VS_M8_E16 = 7332, + RISCV_PseudoVREDSUM_VS_M8_E16_MASK = 7333, + RISCV_PseudoVREDSUM_VS_M8_E32 = 7334, + RISCV_PseudoVREDSUM_VS_M8_E32_MASK = 7335, + RISCV_PseudoVREDSUM_VS_M8_E64 = 7336, + RISCV_PseudoVREDSUM_VS_M8_E64_MASK = 7337, + RISCV_PseudoVREDSUM_VS_M8_E8 = 7338, + RISCV_PseudoVREDSUM_VS_M8_E8_MASK = 7339, + RISCV_PseudoVREDSUM_VS_MF2_E16 = 7340, + RISCV_PseudoVREDSUM_VS_MF2_E16_MASK = 7341, + RISCV_PseudoVREDSUM_VS_MF2_E32 = 7342, + RISCV_PseudoVREDSUM_VS_MF2_E32_MASK = 7343, + RISCV_PseudoVREDSUM_VS_MF2_E8 = 7344, + RISCV_PseudoVREDSUM_VS_MF2_E8_MASK = 7345, + RISCV_PseudoVREDSUM_VS_MF4_E16 = 7346, + RISCV_PseudoVREDSUM_VS_MF4_E16_MASK = 7347, + RISCV_PseudoVREDSUM_VS_MF4_E8 = 7348, + RISCV_PseudoVREDSUM_VS_MF4_E8_MASK = 7349, + RISCV_PseudoVREDSUM_VS_MF8_E8 = 7350, + RISCV_PseudoVREDSUM_VS_MF8_E8_MASK = 7351, + RISCV_PseudoVREDXOR_VS_M1_E16 = 7352, + RISCV_PseudoVREDXOR_VS_M1_E16_MASK = 7353, + RISCV_PseudoVREDXOR_VS_M1_E32 = 7354, + RISCV_PseudoVREDXOR_VS_M1_E32_MASK = 7355, + RISCV_PseudoVREDXOR_VS_M1_E64 = 7356, + RISCV_PseudoVREDXOR_VS_M1_E64_MASK = 7357, + RISCV_PseudoVREDXOR_VS_M1_E8 = 7358, + RISCV_PseudoVREDXOR_VS_M1_E8_MASK = 7359, + RISCV_PseudoVREDXOR_VS_M2_E16 = 7360, + RISCV_PseudoVREDXOR_VS_M2_E16_MASK = 7361, + RISCV_PseudoVREDXOR_VS_M2_E32 = 7362, + RISCV_PseudoVREDXOR_VS_M2_E32_MASK = 7363, + RISCV_PseudoVREDXOR_VS_M2_E64 = 7364, + RISCV_PseudoVREDXOR_VS_M2_E64_MASK = 7365, + RISCV_PseudoVREDXOR_VS_M2_E8 = 7366, + RISCV_PseudoVREDXOR_VS_M2_E8_MASK = 7367, + RISCV_PseudoVREDXOR_VS_M4_E16 = 7368, + RISCV_PseudoVREDXOR_VS_M4_E16_MASK = 7369, + RISCV_PseudoVREDXOR_VS_M4_E32 = 7370, + RISCV_PseudoVREDXOR_VS_M4_E32_MASK = 7371, + RISCV_PseudoVREDXOR_VS_M4_E64 = 7372, + RISCV_PseudoVREDXOR_VS_M4_E64_MASK = 7373, + RISCV_PseudoVREDXOR_VS_M4_E8 = 7374, + RISCV_PseudoVREDXOR_VS_M4_E8_MASK = 7375, + RISCV_PseudoVREDXOR_VS_M8_E16 = 7376, + RISCV_PseudoVREDXOR_VS_M8_E16_MASK = 7377, + RISCV_PseudoVREDXOR_VS_M8_E32 = 7378, + RISCV_PseudoVREDXOR_VS_M8_E32_MASK = 7379, + RISCV_PseudoVREDXOR_VS_M8_E64 = 7380, + RISCV_PseudoVREDXOR_VS_M8_E64_MASK = 7381, + RISCV_PseudoVREDXOR_VS_M8_E8 = 7382, + RISCV_PseudoVREDXOR_VS_M8_E8_MASK = 7383, + RISCV_PseudoVREDXOR_VS_MF2_E16 = 7384, + RISCV_PseudoVREDXOR_VS_MF2_E16_MASK = 7385, + RISCV_PseudoVREDXOR_VS_MF2_E32 = 7386, + RISCV_PseudoVREDXOR_VS_MF2_E32_MASK = 7387, + RISCV_PseudoVREDXOR_VS_MF2_E8 = 7388, + RISCV_PseudoVREDXOR_VS_MF2_E8_MASK = 7389, + RISCV_PseudoVREDXOR_VS_MF4_E16 = 7390, + RISCV_PseudoVREDXOR_VS_MF4_E16_MASK = 7391, + RISCV_PseudoVREDXOR_VS_MF4_E8 = 7392, + RISCV_PseudoVREDXOR_VS_MF4_E8_MASK = 7393, + RISCV_PseudoVREDXOR_VS_MF8_E8 = 7394, + RISCV_PseudoVREDXOR_VS_MF8_E8_MASK = 7395, + RISCV_PseudoVRELOAD2_M1 = 7396, + RISCV_PseudoVRELOAD2_M2 = 7397, + RISCV_PseudoVRELOAD2_M4 = 7398, + RISCV_PseudoVRELOAD2_MF2 = 7399, + RISCV_PseudoVRELOAD2_MF4 = 7400, + RISCV_PseudoVRELOAD2_MF8 = 7401, + RISCV_PseudoVRELOAD3_M1 = 7402, + RISCV_PseudoVRELOAD3_M2 = 7403, + RISCV_PseudoVRELOAD3_MF2 = 7404, + RISCV_PseudoVRELOAD3_MF4 = 7405, + RISCV_PseudoVRELOAD3_MF8 = 7406, + RISCV_PseudoVRELOAD4_M1 = 7407, + RISCV_PseudoVRELOAD4_M2 = 7408, + RISCV_PseudoVRELOAD4_MF2 = 7409, + RISCV_PseudoVRELOAD4_MF4 = 7410, + RISCV_PseudoVRELOAD4_MF8 = 7411, + RISCV_PseudoVRELOAD5_M1 = 7412, + RISCV_PseudoVRELOAD5_MF2 = 7413, + RISCV_PseudoVRELOAD5_MF4 = 7414, + RISCV_PseudoVRELOAD5_MF8 = 7415, + RISCV_PseudoVRELOAD6_M1 = 7416, + RISCV_PseudoVRELOAD6_MF2 = 7417, + RISCV_PseudoVRELOAD6_MF4 = 7418, + RISCV_PseudoVRELOAD6_MF8 = 7419, + RISCV_PseudoVRELOAD7_M1 = 7420, + RISCV_PseudoVRELOAD7_MF2 = 7421, + RISCV_PseudoVRELOAD7_MF4 = 7422, + RISCV_PseudoVRELOAD7_MF8 = 7423, + RISCV_PseudoVRELOAD8_M1 = 7424, + RISCV_PseudoVRELOAD8_MF2 = 7425, + RISCV_PseudoVRELOAD8_MF4 = 7426, + RISCV_PseudoVRELOAD8_MF8 = 7427, + RISCV_PseudoVREMU_VV_M1_E16 = 7428, + RISCV_PseudoVREMU_VV_M1_E16_MASK = 7429, + RISCV_PseudoVREMU_VV_M1_E32 = 7430, + RISCV_PseudoVREMU_VV_M1_E32_MASK = 7431, + RISCV_PseudoVREMU_VV_M1_E64 = 7432, + RISCV_PseudoVREMU_VV_M1_E64_MASK = 7433, + RISCV_PseudoVREMU_VV_M1_E8 = 7434, + RISCV_PseudoVREMU_VV_M1_E8_MASK = 7435, + RISCV_PseudoVREMU_VV_M2_E16 = 7436, + RISCV_PseudoVREMU_VV_M2_E16_MASK = 7437, + RISCV_PseudoVREMU_VV_M2_E32 = 7438, + RISCV_PseudoVREMU_VV_M2_E32_MASK = 7439, + RISCV_PseudoVREMU_VV_M2_E64 = 7440, + RISCV_PseudoVREMU_VV_M2_E64_MASK = 7441, + RISCV_PseudoVREMU_VV_M2_E8 = 7442, + RISCV_PseudoVREMU_VV_M2_E8_MASK = 7443, + RISCV_PseudoVREMU_VV_M4_E16 = 7444, + RISCV_PseudoVREMU_VV_M4_E16_MASK = 7445, + RISCV_PseudoVREMU_VV_M4_E32 = 7446, + RISCV_PseudoVREMU_VV_M4_E32_MASK = 7447, + RISCV_PseudoVREMU_VV_M4_E64 = 7448, + RISCV_PseudoVREMU_VV_M4_E64_MASK = 7449, + RISCV_PseudoVREMU_VV_M4_E8 = 7450, + RISCV_PseudoVREMU_VV_M4_E8_MASK = 7451, + RISCV_PseudoVREMU_VV_M8_E16 = 7452, + RISCV_PseudoVREMU_VV_M8_E16_MASK = 7453, + RISCV_PseudoVREMU_VV_M8_E32 = 7454, + RISCV_PseudoVREMU_VV_M8_E32_MASK = 7455, + RISCV_PseudoVREMU_VV_M8_E64 = 7456, + RISCV_PseudoVREMU_VV_M8_E64_MASK = 7457, + RISCV_PseudoVREMU_VV_M8_E8 = 7458, + RISCV_PseudoVREMU_VV_M8_E8_MASK = 7459, + RISCV_PseudoVREMU_VV_MF2_E16 = 7460, + RISCV_PseudoVREMU_VV_MF2_E16_MASK = 7461, + RISCV_PseudoVREMU_VV_MF2_E32 = 7462, + RISCV_PseudoVREMU_VV_MF2_E32_MASK = 7463, + RISCV_PseudoVREMU_VV_MF2_E8 = 7464, + RISCV_PseudoVREMU_VV_MF2_E8_MASK = 7465, + RISCV_PseudoVREMU_VV_MF4_E16 = 7466, + RISCV_PseudoVREMU_VV_MF4_E16_MASK = 7467, + RISCV_PseudoVREMU_VV_MF4_E8 = 7468, + RISCV_PseudoVREMU_VV_MF4_E8_MASK = 7469, + RISCV_PseudoVREMU_VV_MF8_E8 = 7470, + RISCV_PseudoVREMU_VV_MF8_E8_MASK = 7471, + RISCV_PseudoVREMU_VX_M1_E16 = 7472, + RISCV_PseudoVREMU_VX_M1_E16_MASK = 7473, + RISCV_PseudoVREMU_VX_M1_E32 = 7474, + RISCV_PseudoVREMU_VX_M1_E32_MASK = 7475, + RISCV_PseudoVREMU_VX_M1_E64 = 7476, + RISCV_PseudoVREMU_VX_M1_E64_MASK = 7477, + RISCV_PseudoVREMU_VX_M1_E8 = 7478, + RISCV_PseudoVREMU_VX_M1_E8_MASK = 7479, + RISCV_PseudoVREMU_VX_M2_E16 = 7480, + RISCV_PseudoVREMU_VX_M2_E16_MASK = 7481, + RISCV_PseudoVREMU_VX_M2_E32 = 7482, + RISCV_PseudoVREMU_VX_M2_E32_MASK = 7483, + RISCV_PseudoVREMU_VX_M2_E64 = 7484, + RISCV_PseudoVREMU_VX_M2_E64_MASK = 7485, + RISCV_PseudoVREMU_VX_M2_E8 = 7486, + RISCV_PseudoVREMU_VX_M2_E8_MASK = 7487, + RISCV_PseudoVREMU_VX_M4_E16 = 7488, + RISCV_PseudoVREMU_VX_M4_E16_MASK = 7489, + RISCV_PseudoVREMU_VX_M4_E32 = 7490, + RISCV_PseudoVREMU_VX_M4_E32_MASK = 7491, + RISCV_PseudoVREMU_VX_M4_E64 = 7492, + RISCV_PseudoVREMU_VX_M4_E64_MASK = 7493, + RISCV_PseudoVREMU_VX_M4_E8 = 7494, + RISCV_PseudoVREMU_VX_M4_E8_MASK = 7495, + RISCV_PseudoVREMU_VX_M8_E16 = 7496, + RISCV_PseudoVREMU_VX_M8_E16_MASK = 7497, + RISCV_PseudoVREMU_VX_M8_E32 = 7498, + RISCV_PseudoVREMU_VX_M8_E32_MASK = 7499, + RISCV_PseudoVREMU_VX_M8_E64 = 7500, + RISCV_PseudoVREMU_VX_M8_E64_MASK = 7501, + RISCV_PseudoVREMU_VX_M8_E8 = 7502, + RISCV_PseudoVREMU_VX_M8_E8_MASK = 7503, + RISCV_PseudoVREMU_VX_MF2_E16 = 7504, + RISCV_PseudoVREMU_VX_MF2_E16_MASK = 7505, + RISCV_PseudoVREMU_VX_MF2_E32 = 7506, + RISCV_PseudoVREMU_VX_MF2_E32_MASK = 7507, + RISCV_PseudoVREMU_VX_MF2_E8 = 7508, + RISCV_PseudoVREMU_VX_MF2_E8_MASK = 7509, + RISCV_PseudoVREMU_VX_MF4_E16 = 7510, + RISCV_PseudoVREMU_VX_MF4_E16_MASK = 7511, + RISCV_PseudoVREMU_VX_MF4_E8 = 7512, + RISCV_PseudoVREMU_VX_MF4_E8_MASK = 7513, + RISCV_PseudoVREMU_VX_MF8_E8 = 7514, + RISCV_PseudoVREMU_VX_MF8_E8_MASK = 7515, + RISCV_PseudoVREM_VV_M1_E16 = 7516, + RISCV_PseudoVREM_VV_M1_E16_MASK = 7517, + RISCV_PseudoVREM_VV_M1_E32 = 7518, + RISCV_PseudoVREM_VV_M1_E32_MASK = 7519, + RISCV_PseudoVREM_VV_M1_E64 = 7520, + RISCV_PseudoVREM_VV_M1_E64_MASK = 7521, + RISCV_PseudoVREM_VV_M1_E8 = 7522, + RISCV_PseudoVREM_VV_M1_E8_MASK = 7523, + RISCV_PseudoVREM_VV_M2_E16 = 7524, + RISCV_PseudoVREM_VV_M2_E16_MASK = 7525, + RISCV_PseudoVREM_VV_M2_E32 = 7526, + RISCV_PseudoVREM_VV_M2_E32_MASK = 7527, + RISCV_PseudoVREM_VV_M2_E64 = 7528, + RISCV_PseudoVREM_VV_M2_E64_MASK = 7529, + RISCV_PseudoVREM_VV_M2_E8 = 7530, + RISCV_PseudoVREM_VV_M2_E8_MASK = 7531, + RISCV_PseudoVREM_VV_M4_E16 = 7532, + RISCV_PseudoVREM_VV_M4_E16_MASK = 7533, + RISCV_PseudoVREM_VV_M4_E32 = 7534, + RISCV_PseudoVREM_VV_M4_E32_MASK = 7535, + RISCV_PseudoVREM_VV_M4_E64 = 7536, + RISCV_PseudoVREM_VV_M4_E64_MASK = 7537, + RISCV_PseudoVREM_VV_M4_E8 = 7538, + RISCV_PseudoVREM_VV_M4_E8_MASK = 7539, + RISCV_PseudoVREM_VV_M8_E16 = 7540, + RISCV_PseudoVREM_VV_M8_E16_MASK = 7541, + RISCV_PseudoVREM_VV_M8_E32 = 7542, + RISCV_PseudoVREM_VV_M8_E32_MASK = 7543, + RISCV_PseudoVREM_VV_M8_E64 = 7544, + RISCV_PseudoVREM_VV_M8_E64_MASK = 7545, + RISCV_PseudoVREM_VV_M8_E8 = 7546, + RISCV_PseudoVREM_VV_M8_E8_MASK = 7547, + RISCV_PseudoVREM_VV_MF2_E16 = 7548, + RISCV_PseudoVREM_VV_MF2_E16_MASK = 7549, + RISCV_PseudoVREM_VV_MF2_E32 = 7550, + RISCV_PseudoVREM_VV_MF2_E32_MASK = 7551, + RISCV_PseudoVREM_VV_MF2_E8 = 7552, + RISCV_PseudoVREM_VV_MF2_E8_MASK = 7553, + RISCV_PseudoVREM_VV_MF4_E16 = 7554, + RISCV_PseudoVREM_VV_MF4_E16_MASK = 7555, + RISCV_PseudoVREM_VV_MF4_E8 = 7556, + RISCV_PseudoVREM_VV_MF4_E8_MASK = 7557, + RISCV_PseudoVREM_VV_MF8_E8 = 7558, + RISCV_PseudoVREM_VV_MF8_E8_MASK = 7559, + RISCV_PseudoVREM_VX_M1_E16 = 7560, + RISCV_PseudoVREM_VX_M1_E16_MASK = 7561, + RISCV_PseudoVREM_VX_M1_E32 = 7562, + RISCV_PseudoVREM_VX_M1_E32_MASK = 7563, + RISCV_PseudoVREM_VX_M1_E64 = 7564, + RISCV_PseudoVREM_VX_M1_E64_MASK = 7565, + RISCV_PseudoVREM_VX_M1_E8 = 7566, + RISCV_PseudoVREM_VX_M1_E8_MASK = 7567, + RISCV_PseudoVREM_VX_M2_E16 = 7568, + RISCV_PseudoVREM_VX_M2_E16_MASK = 7569, + RISCV_PseudoVREM_VX_M2_E32 = 7570, + RISCV_PseudoVREM_VX_M2_E32_MASK = 7571, + RISCV_PseudoVREM_VX_M2_E64 = 7572, + RISCV_PseudoVREM_VX_M2_E64_MASK = 7573, + RISCV_PseudoVREM_VX_M2_E8 = 7574, + RISCV_PseudoVREM_VX_M2_E8_MASK = 7575, + RISCV_PseudoVREM_VX_M4_E16 = 7576, + RISCV_PseudoVREM_VX_M4_E16_MASK = 7577, + RISCV_PseudoVREM_VX_M4_E32 = 7578, + RISCV_PseudoVREM_VX_M4_E32_MASK = 7579, + RISCV_PseudoVREM_VX_M4_E64 = 7580, + RISCV_PseudoVREM_VX_M4_E64_MASK = 7581, + RISCV_PseudoVREM_VX_M4_E8 = 7582, + RISCV_PseudoVREM_VX_M4_E8_MASK = 7583, + RISCV_PseudoVREM_VX_M8_E16 = 7584, + RISCV_PseudoVREM_VX_M8_E16_MASK = 7585, + RISCV_PseudoVREM_VX_M8_E32 = 7586, + RISCV_PseudoVREM_VX_M8_E32_MASK = 7587, + RISCV_PseudoVREM_VX_M8_E64 = 7588, + RISCV_PseudoVREM_VX_M8_E64_MASK = 7589, + RISCV_PseudoVREM_VX_M8_E8 = 7590, + RISCV_PseudoVREM_VX_M8_E8_MASK = 7591, + RISCV_PseudoVREM_VX_MF2_E16 = 7592, + RISCV_PseudoVREM_VX_MF2_E16_MASK = 7593, + RISCV_PseudoVREM_VX_MF2_E32 = 7594, + RISCV_PseudoVREM_VX_MF2_E32_MASK = 7595, + RISCV_PseudoVREM_VX_MF2_E8 = 7596, + RISCV_PseudoVREM_VX_MF2_E8_MASK = 7597, + RISCV_PseudoVREM_VX_MF4_E16 = 7598, + RISCV_PseudoVREM_VX_MF4_E16_MASK = 7599, + RISCV_PseudoVREM_VX_MF4_E8 = 7600, + RISCV_PseudoVREM_VX_MF4_E8_MASK = 7601, + RISCV_PseudoVREM_VX_MF8_E8 = 7602, + RISCV_PseudoVREM_VX_MF8_E8_MASK = 7603, + RISCV_PseudoVREV8_V_M1 = 7604, + RISCV_PseudoVREV8_V_M1_MASK = 7605, + RISCV_PseudoVREV8_V_M2 = 7606, + RISCV_PseudoVREV8_V_M2_MASK = 7607, + RISCV_PseudoVREV8_V_M4 = 7608, + RISCV_PseudoVREV8_V_M4_MASK = 7609, + RISCV_PseudoVREV8_V_M8 = 7610, + RISCV_PseudoVREV8_V_M8_MASK = 7611, + RISCV_PseudoVREV8_V_MF2 = 7612, + RISCV_PseudoVREV8_V_MF2_MASK = 7613, + RISCV_PseudoVREV8_V_MF4 = 7614, + RISCV_PseudoVREV8_V_MF4_MASK = 7615, + RISCV_PseudoVREV8_V_MF8 = 7616, + RISCV_PseudoVREV8_V_MF8_MASK = 7617, + RISCV_PseudoVRGATHEREI16_VV_M1_E16_M1 = 7618, + RISCV_PseudoVRGATHEREI16_VV_M1_E16_M1_MASK = 7619, + RISCV_PseudoVRGATHEREI16_VV_M1_E16_M2 = 7620, + RISCV_PseudoVRGATHEREI16_VV_M1_E16_M2_MASK = 7621, + RISCV_PseudoVRGATHEREI16_VV_M1_E16_MF2 = 7622, + RISCV_PseudoVRGATHEREI16_VV_M1_E16_MF2_MASK = 7623, + RISCV_PseudoVRGATHEREI16_VV_M1_E16_MF4 = 7624, + RISCV_PseudoVRGATHEREI16_VV_M1_E16_MF4_MASK = 7625, + RISCV_PseudoVRGATHEREI16_VV_M1_E32_M1 = 7626, + RISCV_PseudoVRGATHEREI16_VV_M1_E32_M1_MASK = 7627, + RISCV_PseudoVRGATHEREI16_VV_M1_E32_M2 = 7628, + RISCV_PseudoVRGATHEREI16_VV_M1_E32_M2_MASK = 7629, + RISCV_PseudoVRGATHEREI16_VV_M1_E32_MF2 = 7630, + RISCV_PseudoVRGATHEREI16_VV_M1_E32_MF2_MASK = 7631, + RISCV_PseudoVRGATHEREI16_VV_M1_E32_MF4 = 7632, + RISCV_PseudoVRGATHEREI16_VV_M1_E32_MF4_MASK = 7633, + RISCV_PseudoVRGATHEREI16_VV_M1_E64_M1 = 7634, + RISCV_PseudoVRGATHEREI16_VV_M1_E64_M1_MASK = 7635, + RISCV_PseudoVRGATHEREI16_VV_M1_E64_M2 = 7636, + RISCV_PseudoVRGATHEREI16_VV_M1_E64_M2_MASK = 7637, + RISCV_PseudoVRGATHEREI16_VV_M1_E64_MF2 = 7638, + RISCV_PseudoVRGATHEREI16_VV_M1_E64_MF2_MASK = 7639, + RISCV_PseudoVRGATHEREI16_VV_M1_E64_MF4 = 7640, + RISCV_PseudoVRGATHEREI16_VV_M1_E64_MF4_MASK = 7641, + RISCV_PseudoVRGATHEREI16_VV_M1_E8_M1 = 7642, + RISCV_PseudoVRGATHEREI16_VV_M1_E8_M1_MASK = 7643, + RISCV_PseudoVRGATHEREI16_VV_M1_E8_M2 = 7644, + RISCV_PseudoVRGATHEREI16_VV_M1_E8_M2_MASK = 7645, + RISCV_PseudoVRGATHEREI16_VV_M1_E8_MF2 = 7646, + RISCV_PseudoVRGATHEREI16_VV_M1_E8_MF2_MASK = 7647, + RISCV_PseudoVRGATHEREI16_VV_M1_E8_MF4 = 7648, + RISCV_PseudoVRGATHEREI16_VV_M1_E8_MF4_MASK = 7649, + RISCV_PseudoVRGATHEREI16_VV_M2_E16_M1 = 7650, + RISCV_PseudoVRGATHEREI16_VV_M2_E16_M1_MASK = 7651, + RISCV_PseudoVRGATHEREI16_VV_M2_E16_M2 = 7652, + RISCV_PseudoVRGATHEREI16_VV_M2_E16_M2_MASK = 7653, + RISCV_PseudoVRGATHEREI16_VV_M2_E16_M4 = 7654, + RISCV_PseudoVRGATHEREI16_VV_M2_E16_M4_MASK = 7655, + RISCV_PseudoVRGATHEREI16_VV_M2_E16_MF2 = 7656, + RISCV_PseudoVRGATHEREI16_VV_M2_E16_MF2_MASK = 7657, + RISCV_PseudoVRGATHEREI16_VV_M2_E32_M1 = 7658, + RISCV_PseudoVRGATHEREI16_VV_M2_E32_M1_MASK = 7659, + RISCV_PseudoVRGATHEREI16_VV_M2_E32_M2 = 7660, + RISCV_PseudoVRGATHEREI16_VV_M2_E32_M2_MASK = 7661, + RISCV_PseudoVRGATHEREI16_VV_M2_E32_M4 = 7662, + RISCV_PseudoVRGATHEREI16_VV_M2_E32_M4_MASK = 7663, + RISCV_PseudoVRGATHEREI16_VV_M2_E32_MF2 = 7664, + RISCV_PseudoVRGATHEREI16_VV_M2_E32_MF2_MASK = 7665, + RISCV_PseudoVRGATHEREI16_VV_M2_E64_M1 = 7666, + RISCV_PseudoVRGATHEREI16_VV_M2_E64_M1_MASK = 7667, + RISCV_PseudoVRGATHEREI16_VV_M2_E64_M2 = 7668, + RISCV_PseudoVRGATHEREI16_VV_M2_E64_M2_MASK = 7669, + RISCV_PseudoVRGATHEREI16_VV_M2_E64_M4 = 7670, + RISCV_PseudoVRGATHEREI16_VV_M2_E64_M4_MASK = 7671, + RISCV_PseudoVRGATHEREI16_VV_M2_E64_MF2 = 7672, + RISCV_PseudoVRGATHEREI16_VV_M2_E64_MF2_MASK = 7673, + RISCV_PseudoVRGATHEREI16_VV_M2_E8_M1 = 7674, + RISCV_PseudoVRGATHEREI16_VV_M2_E8_M1_MASK = 7675, + RISCV_PseudoVRGATHEREI16_VV_M2_E8_M2 = 7676, + RISCV_PseudoVRGATHEREI16_VV_M2_E8_M2_MASK = 7677, + RISCV_PseudoVRGATHEREI16_VV_M2_E8_M4 = 7678, + RISCV_PseudoVRGATHEREI16_VV_M2_E8_M4_MASK = 7679, + RISCV_PseudoVRGATHEREI16_VV_M2_E8_MF2 = 7680, + RISCV_PseudoVRGATHEREI16_VV_M2_E8_MF2_MASK = 7681, + RISCV_PseudoVRGATHEREI16_VV_M4_E16_M1 = 7682, + RISCV_PseudoVRGATHEREI16_VV_M4_E16_M1_MASK = 7683, + RISCV_PseudoVRGATHEREI16_VV_M4_E16_M2 = 7684, + RISCV_PseudoVRGATHEREI16_VV_M4_E16_M2_MASK = 7685, + RISCV_PseudoVRGATHEREI16_VV_M4_E16_M4 = 7686, + RISCV_PseudoVRGATHEREI16_VV_M4_E16_M4_MASK = 7687, + RISCV_PseudoVRGATHEREI16_VV_M4_E16_M8 = 7688, + RISCV_PseudoVRGATHEREI16_VV_M4_E16_M8_MASK = 7689, + RISCV_PseudoVRGATHEREI16_VV_M4_E32_M1 = 7690, + RISCV_PseudoVRGATHEREI16_VV_M4_E32_M1_MASK = 7691, + RISCV_PseudoVRGATHEREI16_VV_M4_E32_M2 = 7692, + RISCV_PseudoVRGATHEREI16_VV_M4_E32_M2_MASK = 7693, + RISCV_PseudoVRGATHEREI16_VV_M4_E32_M4 = 7694, + RISCV_PseudoVRGATHEREI16_VV_M4_E32_M4_MASK = 7695, + RISCV_PseudoVRGATHEREI16_VV_M4_E32_M8 = 7696, + RISCV_PseudoVRGATHEREI16_VV_M4_E32_M8_MASK = 7697, + RISCV_PseudoVRGATHEREI16_VV_M4_E64_M1 = 7698, + RISCV_PseudoVRGATHEREI16_VV_M4_E64_M1_MASK = 7699, + RISCV_PseudoVRGATHEREI16_VV_M4_E64_M2 = 7700, + RISCV_PseudoVRGATHEREI16_VV_M4_E64_M2_MASK = 7701, + RISCV_PseudoVRGATHEREI16_VV_M4_E64_M4 = 7702, + RISCV_PseudoVRGATHEREI16_VV_M4_E64_M4_MASK = 7703, + RISCV_PseudoVRGATHEREI16_VV_M4_E64_M8 = 7704, + RISCV_PseudoVRGATHEREI16_VV_M4_E64_M8_MASK = 7705, + RISCV_PseudoVRGATHEREI16_VV_M4_E8_M1 = 7706, + RISCV_PseudoVRGATHEREI16_VV_M4_E8_M1_MASK = 7707, + RISCV_PseudoVRGATHEREI16_VV_M4_E8_M2 = 7708, + RISCV_PseudoVRGATHEREI16_VV_M4_E8_M2_MASK = 7709, + RISCV_PseudoVRGATHEREI16_VV_M4_E8_M4 = 7710, + RISCV_PseudoVRGATHEREI16_VV_M4_E8_M4_MASK = 7711, + RISCV_PseudoVRGATHEREI16_VV_M4_E8_M8 = 7712, + RISCV_PseudoVRGATHEREI16_VV_M4_E8_M8_MASK = 7713, + RISCV_PseudoVRGATHEREI16_VV_M8_E16_M2 = 7714, + RISCV_PseudoVRGATHEREI16_VV_M8_E16_M2_MASK = 7715, + RISCV_PseudoVRGATHEREI16_VV_M8_E16_M4 = 7716, + RISCV_PseudoVRGATHEREI16_VV_M8_E16_M4_MASK = 7717, + RISCV_PseudoVRGATHEREI16_VV_M8_E16_M8 = 7718, + RISCV_PseudoVRGATHEREI16_VV_M8_E16_M8_MASK = 7719, + RISCV_PseudoVRGATHEREI16_VV_M8_E32_M2 = 7720, + RISCV_PseudoVRGATHEREI16_VV_M8_E32_M2_MASK = 7721, + RISCV_PseudoVRGATHEREI16_VV_M8_E32_M4 = 7722, + RISCV_PseudoVRGATHEREI16_VV_M8_E32_M4_MASK = 7723, + RISCV_PseudoVRGATHEREI16_VV_M8_E32_M8 = 7724, + RISCV_PseudoVRGATHEREI16_VV_M8_E32_M8_MASK = 7725, + RISCV_PseudoVRGATHEREI16_VV_M8_E64_M2 = 7726, + RISCV_PseudoVRGATHEREI16_VV_M8_E64_M2_MASK = 7727, + RISCV_PseudoVRGATHEREI16_VV_M8_E64_M4 = 7728, + RISCV_PseudoVRGATHEREI16_VV_M8_E64_M4_MASK = 7729, + RISCV_PseudoVRGATHEREI16_VV_M8_E64_M8 = 7730, + RISCV_PseudoVRGATHEREI16_VV_M8_E64_M8_MASK = 7731, + RISCV_PseudoVRGATHEREI16_VV_M8_E8_M2 = 7732, + RISCV_PseudoVRGATHEREI16_VV_M8_E8_M2_MASK = 7733, + RISCV_PseudoVRGATHEREI16_VV_M8_E8_M4 = 7734, + RISCV_PseudoVRGATHEREI16_VV_M8_E8_M4_MASK = 7735, + RISCV_PseudoVRGATHEREI16_VV_M8_E8_M8 = 7736, + RISCV_PseudoVRGATHEREI16_VV_M8_E8_M8_MASK = 7737, + RISCV_PseudoVRGATHEREI16_VV_MF2_E16_M1 = 7738, + RISCV_PseudoVRGATHEREI16_VV_MF2_E16_M1_MASK = 7739, + RISCV_PseudoVRGATHEREI16_VV_MF2_E16_MF2 = 7740, + RISCV_PseudoVRGATHEREI16_VV_MF2_E16_MF2_MASK = 7741, + RISCV_PseudoVRGATHEREI16_VV_MF2_E16_MF4 = 7742, + RISCV_PseudoVRGATHEREI16_VV_MF2_E16_MF4_MASK = 7743, + RISCV_PseudoVRGATHEREI16_VV_MF2_E16_MF8 = 7744, + RISCV_PseudoVRGATHEREI16_VV_MF2_E16_MF8_MASK = 7745, + RISCV_PseudoVRGATHEREI16_VV_MF2_E32_M1 = 7746, + RISCV_PseudoVRGATHEREI16_VV_MF2_E32_M1_MASK = 7747, + RISCV_PseudoVRGATHEREI16_VV_MF2_E32_MF2 = 7748, + RISCV_PseudoVRGATHEREI16_VV_MF2_E32_MF2_MASK = 7749, + RISCV_PseudoVRGATHEREI16_VV_MF2_E32_MF4 = 7750, + RISCV_PseudoVRGATHEREI16_VV_MF2_E32_MF4_MASK = 7751, + RISCV_PseudoVRGATHEREI16_VV_MF2_E32_MF8 = 7752, + RISCV_PseudoVRGATHEREI16_VV_MF2_E32_MF8_MASK = 7753, + RISCV_PseudoVRGATHEREI16_VV_MF2_E8_M1 = 7754, + RISCV_PseudoVRGATHEREI16_VV_MF2_E8_M1_MASK = 7755, + RISCV_PseudoVRGATHEREI16_VV_MF2_E8_MF2 = 7756, + RISCV_PseudoVRGATHEREI16_VV_MF2_E8_MF2_MASK = 7757, + RISCV_PseudoVRGATHEREI16_VV_MF2_E8_MF4 = 7758, + RISCV_PseudoVRGATHEREI16_VV_MF2_E8_MF4_MASK = 7759, + RISCV_PseudoVRGATHEREI16_VV_MF2_E8_MF8 = 7760, + RISCV_PseudoVRGATHEREI16_VV_MF2_E8_MF8_MASK = 7761, + RISCV_PseudoVRGATHEREI16_VV_MF4_E16_MF2 = 7762, + RISCV_PseudoVRGATHEREI16_VV_MF4_E16_MF2_MASK = 7763, + RISCV_PseudoVRGATHEREI16_VV_MF4_E16_MF4 = 7764, + RISCV_PseudoVRGATHEREI16_VV_MF4_E16_MF4_MASK = 7765, + RISCV_PseudoVRGATHEREI16_VV_MF4_E16_MF8 = 7766, + RISCV_PseudoVRGATHEREI16_VV_MF4_E16_MF8_MASK = 7767, + RISCV_PseudoVRGATHEREI16_VV_MF4_E8_MF2 = 7768, + RISCV_PseudoVRGATHEREI16_VV_MF4_E8_MF2_MASK = 7769, + RISCV_PseudoVRGATHEREI16_VV_MF4_E8_MF4 = 7770, + RISCV_PseudoVRGATHEREI16_VV_MF4_E8_MF4_MASK = 7771, + RISCV_PseudoVRGATHEREI16_VV_MF4_E8_MF8 = 7772, + RISCV_PseudoVRGATHEREI16_VV_MF4_E8_MF8_MASK = 7773, + RISCV_PseudoVRGATHEREI16_VV_MF8_E8_MF4 = 7774, + RISCV_PseudoVRGATHEREI16_VV_MF8_E8_MF4_MASK = 7775, + RISCV_PseudoVRGATHEREI16_VV_MF8_E8_MF8 = 7776, + RISCV_PseudoVRGATHEREI16_VV_MF8_E8_MF8_MASK = 7777, + RISCV_PseudoVRGATHER_VI_M1 = 7778, + RISCV_PseudoVRGATHER_VI_M1_MASK = 7779, + RISCV_PseudoVRGATHER_VI_M2 = 7780, + RISCV_PseudoVRGATHER_VI_M2_MASK = 7781, + RISCV_PseudoVRGATHER_VI_M4 = 7782, + RISCV_PseudoVRGATHER_VI_M4_MASK = 7783, + RISCV_PseudoVRGATHER_VI_M8 = 7784, + RISCV_PseudoVRGATHER_VI_M8_MASK = 7785, + RISCV_PseudoVRGATHER_VI_MF2 = 7786, + RISCV_PseudoVRGATHER_VI_MF2_MASK = 7787, + RISCV_PseudoVRGATHER_VI_MF4 = 7788, + RISCV_PseudoVRGATHER_VI_MF4_MASK = 7789, + RISCV_PseudoVRGATHER_VI_MF8 = 7790, + RISCV_PseudoVRGATHER_VI_MF8_MASK = 7791, + RISCV_PseudoVRGATHER_VV_M1_E16 = 7792, + RISCV_PseudoVRGATHER_VV_M1_E16_MASK = 7793, + RISCV_PseudoVRGATHER_VV_M1_E32 = 7794, + RISCV_PseudoVRGATHER_VV_M1_E32_MASK = 7795, + RISCV_PseudoVRGATHER_VV_M1_E64 = 7796, + RISCV_PseudoVRGATHER_VV_M1_E64_MASK = 7797, + RISCV_PseudoVRGATHER_VV_M1_E8 = 7798, + RISCV_PseudoVRGATHER_VV_M1_E8_MASK = 7799, + RISCV_PseudoVRGATHER_VV_M2_E16 = 7800, + RISCV_PseudoVRGATHER_VV_M2_E16_MASK = 7801, + RISCV_PseudoVRGATHER_VV_M2_E32 = 7802, + RISCV_PseudoVRGATHER_VV_M2_E32_MASK = 7803, + RISCV_PseudoVRGATHER_VV_M2_E64 = 7804, + RISCV_PseudoVRGATHER_VV_M2_E64_MASK = 7805, + RISCV_PseudoVRGATHER_VV_M2_E8 = 7806, + RISCV_PseudoVRGATHER_VV_M2_E8_MASK = 7807, + RISCV_PseudoVRGATHER_VV_M4_E16 = 7808, + RISCV_PseudoVRGATHER_VV_M4_E16_MASK = 7809, + RISCV_PseudoVRGATHER_VV_M4_E32 = 7810, + RISCV_PseudoVRGATHER_VV_M4_E32_MASK = 7811, + RISCV_PseudoVRGATHER_VV_M4_E64 = 7812, + RISCV_PseudoVRGATHER_VV_M4_E64_MASK = 7813, + RISCV_PseudoVRGATHER_VV_M4_E8 = 7814, + RISCV_PseudoVRGATHER_VV_M4_E8_MASK = 7815, + RISCV_PseudoVRGATHER_VV_M8_E16 = 7816, + RISCV_PseudoVRGATHER_VV_M8_E16_MASK = 7817, + RISCV_PseudoVRGATHER_VV_M8_E32 = 7818, + RISCV_PseudoVRGATHER_VV_M8_E32_MASK = 7819, + RISCV_PseudoVRGATHER_VV_M8_E64 = 7820, + RISCV_PseudoVRGATHER_VV_M8_E64_MASK = 7821, + RISCV_PseudoVRGATHER_VV_M8_E8 = 7822, + RISCV_PseudoVRGATHER_VV_M8_E8_MASK = 7823, + RISCV_PseudoVRGATHER_VV_MF2_E16 = 7824, + RISCV_PseudoVRGATHER_VV_MF2_E16_MASK = 7825, + RISCV_PseudoVRGATHER_VV_MF2_E32 = 7826, + RISCV_PseudoVRGATHER_VV_MF2_E32_MASK = 7827, + RISCV_PseudoVRGATHER_VV_MF2_E8 = 7828, + RISCV_PseudoVRGATHER_VV_MF2_E8_MASK = 7829, + RISCV_PseudoVRGATHER_VV_MF4_E16 = 7830, + RISCV_PseudoVRGATHER_VV_MF4_E16_MASK = 7831, + RISCV_PseudoVRGATHER_VV_MF4_E8 = 7832, + RISCV_PseudoVRGATHER_VV_MF4_E8_MASK = 7833, + RISCV_PseudoVRGATHER_VV_MF8_E8 = 7834, + RISCV_PseudoVRGATHER_VV_MF8_E8_MASK = 7835, + RISCV_PseudoVRGATHER_VX_M1 = 7836, + RISCV_PseudoVRGATHER_VX_M1_MASK = 7837, + RISCV_PseudoVRGATHER_VX_M2 = 7838, + RISCV_PseudoVRGATHER_VX_M2_MASK = 7839, + RISCV_PseudoVRGATHER_VX_M4 = 7840, + RISCV_PseudoVRGATHER_VX_M4_MASK = 7841, + RISCV_PseudoVRGATHER_VX_M8 = 7842, + RISCV_PseudoVRGATHER_VX_M8_MASK = 7843, + RISCV_PseudoVRGATHER_VX_MF2 = 7844, + RISCV_PseudoVRGATHER_VX_MF2_MASK = 7845, + RISCV_PseudoVRGATHER_VX_MF4 = 7846, + RISCV_PseudoVRGATHER_VX_MF4_MASK = 7847, + RISCV_PseudoVRGATHER_VX_MF8 = 7848, + RISCV_PseudoVRGATHER_VX_MF8_MASK = 7849, + RISCV_PseudoVROL_VV_M1 = 7850, + RISCV_PseudoVROL_VV_M1_MASK = 7851, + RISCV_PseudoVROL_VV_M2 = 7852, + RISCV_PseudoVROL_VV_M2_MASK = 7853, + RISCV_PseudoVROL_VV_M4 = 7854, + RISCV_PseudoVROL_VV_M4_MASK = 7855, + RISCV_PseudoVROL_VV_M8 = 7856, + RISCV_PseudoVROL_VV_M8_MASK = 7857, + RISCV_PseudoVROL_VV_MF2 = 7858, + RISCV_PseudoVROL_VV_MF2_MASK = 7859, + RISCV_PseudoVROL_VV_MF4 = 7860, + RISCV_PseudoVROL_VV_MF4_MASK = 7861, + RISCV_PseudoVROL_VV_MF8 = 7862, + RISCV_PseudoVROL_VV_MF8_MASK = 7863, + RISCV_PseudoVROL_VX_M1 = 7864, + RISCV_PseudoVROL_VX_M1_MASK = 7865, + RISCV_PseudoVROL_VX_M2 = 7866, + RISCV_PseudoVROL_VX_M2_MASK = 7867, + RISCV_PseudoVROL_VX_M4 = 7868, + RISCV_PseudoVROL_VX_M4_MASK = 7869, + RISCV_PseudoVROL_VX_M8 = 7870, + RISCV_PseudoVROL_VX_M8_MASK = 7871, + RISCV_PseudoVROL_VX_MF2 = 7872, + RISCV_PseudoVROL_VX_MF2_MASK = 7873, + RISCV_PseudoVROL_VX_MF4 = 7874, + RISCV_PseudoVROL_VX_MF4_MASK = 7875, + RISCV_PseudoVROL_VX_MF8 = 7876, + RISCV_PseudoVROL_VX_MF8_MASK = 7877, + RISCV_PseudoVROR_VI_M1 = 7878, + RISCV_PseudoVROR_VI_M1_MASK = 7879, + RISCV_PseudoVROR_VI_M2 = 7880, + RISCV_PseudoVROR_VI_M2_MASK = 7881, + RISCV_PseudoVROR_VI_M4 = 7882, + RISCV_PseudoVROR_VI_M4_MASK = 7883, + RISCV_PseudoVROR_VI_M8 = 7884, + RISCV_PseudoVROR_VI_M8_MASK = 7885, + RISCV_PseudoVROR_VI_MF2 = 7886, + RISCV_PseudoVROR_VI_MF2_MASK = 7887, + RISCV_PseudoVROR_VI_MF4 = 7888, + RISCV_PseudoVROR_VI_MF4_MASK = 7889, + RISCV_PseudoVROR_VI_MF8 = 7890, + RISCV_PseudoVROR_VI_MF8_MASK = 7891, + RISCV_PseudoVROR_VV_M1 = 7892, + RISCV_PseudoVROR_VV_M1_MASK = 7893, + RISCV_PseudoVROR_VV_M2 = 7894, + RISCV_PseudoVROR_VV_M2_MASK = 7895, + RISCV_PseudoVROR_VV_M4 = 7896, + RISCV_PseudoVROR_VV_M4_MASK = 7897, + RISCV_PseudoVROR_VV_M8 = 7898, + RISCV_PseudoVROR_VV_M8_MASK = 7899, + RISCV_PseudoVROR_VV_MF2 = 7900, + RISCV_PseudoVROR_VV_MF2_MASK = 7901, + RISCV_PseudoVROR_VV_MF4 = 7902, + RISCV_PseudoVROR_VV_MF4_MASK = 7903, + RISCV_PseudoVROR_VV_MF8 = 7904, + RISCV_PseudoVROR_VV_MF8_MASK = 7905, + RISCV_PseudoVROR_VX_M1 = 7906, + RISCV_PseudoVROR_VX_M1_MASK = 7907, + RISCV_PseudoVROR_VX_M2 = 7908, + RISCV_PseudoVROR_VX_M2_MASK = 7909, + RISCV_PseudoVROR_VX_M4 = 7910, + RISCV_PseudoVROR_VX_M4_MASK = 7911, + RISCV_PseudoVROR_VX_M8 = 7912, + RISCV_PseudoVROR_VX_M8_MASK = 7913, + RISCV_PseudoVROR_VX_MF2 = 7914, + RISCV_PseudoVROR_VX_MF2_MASK = 7915, + RISCV_PseudoVROR_VX_MF4 = 7916, + RISCV_PseudoVROR_VX_MF4_MASK = 7917, + RISCV_PseudoVROR_VX_MF8 = 7918, + RISCV_PseudoVROR_VX_MF8_MASK = 7919, + RISCV_PseudoVRSUB_VI_M1 = 7920, + RISCV_PseudoVRSUB_VI_M1_MASK = 7921, + RISCV_PseudoVRSUB_VI_M2 = 7922, + RISCV_PseudoVRSUB_VI_M2_MASK = 7923, + RISCV_PseudoVRSUB_VI_M4 = 7924, + RISCV_PseudoVRSUB_VI_M4_MASK = 7925, + RISCV_PseudoVRSUB_VI_M8 = 7926, + RISCV_PseudoVRSUB_VI_M8_MASK = 7927, + RISCV_PseudoVRSUB_VI_MF2 = 7928, + RISCV_PseudoVRSUB_VI_MF2_MASK = 7929, + RISCV_PseudoVRSUB_VI_MF4 = 7930, + RISCV_PseudoVRSUB_VI_MF4_MASK = 7931, + RISCV_PseudoVRSUB_VI_MF8 = 7932, + RISCV_PseudoVRSUB_VI_MF8_MASK = 7933, + RISCV_PseudoVRSUB_VX_M1 = 7934, + RISCV_PseudoVRSUB_VX_M1_MASK = 7935, + RISCV_PseudoVRSUB_VX_M2 = 7936, + RISCV_PseudoVRSUB_VX_M2_MASK = 7937, + RISCV_PseudoVRSUB_VX_M4 = 7938, + RISCV_PseudoVRSUB_VX_M4_MASK = 7939, + RISCV_PseudoVRSUB_VX_M8 = 7940, + RISCV_PseudoVRSUB_VX_M8_MASK = 7941, + RISCV_PseudoVRSUB_VX_MF2 = 7942, + RISCV_PseudoVRSUB_VX_MF2_MASK = 7943, + RISCV_PseudoVRSUB_VX_MF4 = 7944, + RISCV_PseudoVRSUB_VX_MF4_MASK = 7945, + RISCV_PseudoVRSUB_VX_MF8 = 7946, + RISCV_PseudoVRSUB_VX_MF8_MASK = 7947, + RISCV_PseudoVSADDU_VI_M1 = 7948, + RISCV_PseudoVSADDU_VI_M1_MASK = 7949, + RISCV_PseudoVSADDU_VI_M2 = 7950, + RISCV_PseudoVSADDU_VI_M2_MASK = 7951, + RISCV_PseudoVSADDU_VI_M4 = 7952, + RISCV_PseudoVSADDU_VI_M4_MASK = 7953, + RISCV_PseudoVSADDU_VI_M8 = 7954, + RISCV_PseudoVSADDU_VI_M8_MASK = 7955, + RISCV_PseudoVSADDU_VI_MF2 = 7956, + RISCV_PseudoVSADDU_VI_MF2_MASK = 7957, + RISCV_PseudoVSADDU_VI_MF4 = 7958, + RISCV_PseudoVSADDU_VI_MF4_MASK = 7959, + RISCV_PseudoVSADDU_VI_MF8 = 7960, + RISCV_PseudoVSADDU_VI_MF8_MASK = 7961, + RISCV_PseudoVSADDU_VV_M1 = 7962, + RISCV_PseudoVSADDU_VV_M1_MASK = 7963, + RISCV_PseudoVSADDU_VV_M2 = 7964, + RISCV_PseudoVSADDU_VV_M2_MASK = 7965, + RISCV_PseudoVSADDU_VV_M4 = 7966, + RISCV_PseudoVSADDU_VV_M4_MASK = 7967, + RISCV_PseudoVSADDU_VV_M8 = 7968, + RISCV_PseudoVSADDU_VV_M8_MASK = 7969, + RISCV_PseudoVSADDU_VV_MF2 = 7970, + RISCV_PseudoVSADDU_VV_MF2_MASK = 7971, + RISCV_PseudoVSADDU_VV_MF4 = 7972, + RISCV_PseudoVSADDU_VV_MF4_MASK = 7973, + RISCV_PseudoVSADDU_VV_MF8 = 7974, + RISCV_PseudoVSADDU_VV_MF8_MASK = 7975, + RISCV_PseudoVSADDU_VX_M1 = 7976, + RISCV_PseudoVSADDU_VX_M1_MASK = 7977, + RISCV_PseudoVSADDU_VX_M2 = 7978, + RISCV_PseudoVSADDU_VX_M2_MASK = 7979, + RISCV_PseudoVSADDU_VX_M4 = 7980, + RISCV_PseudoVSADDU_VX_M4_MASK = 7981, + RISCV_PseudoVSADDU_VX_M8 = 7982, + RISCV_PseudoVSADDU_VX_M8_MASK = 7983, + RISCV_PseudoVSADDU_VX_MF2 = 7984, + RISCV_PseudoVSADDU_VX_MF2_MASK = 7985, + RISCV_PseudoVSADDU_VX_MF4 = 7986, + RISCV_PseudoVSADDU_VX_MF4_MASK = 7987, + RISCV_PseudoVSADDU_VX_MF8 = 7988, + RISCV_PseudoVSADDU_VX_MF8_MASK = 7989, + RISCV_PseudoVSADD_VI_M1 = 7990, + RISCV_PseudoVSADD_VI_M1_MASK = 7991, + RISCV_PseudoVSADD_VI_M2 = 7992, + RISCV_PseudoVSADD_VI_M2_MASK = 7993, + RISCV_PseudoVSADD_VI_M4 = 7994, + RISCV_PseudoVSADD_VI_M4_MASK = 7995, + RISCV_PseudoVSADD_VI_M8 = 7996, + RISCV_PseudoVSADD_VI_M8_MASK = 7997, + RISCV_PseudoVSADD_VI_MF2 = 7998, + RISCV_PseudoVSADD_VI_MF2_MASK = 7999, + RISCV_PseudoVSADD_VI_MF4 = 8000, + RISCV_PseudoVSADD_VI_MF4_MASK = 8001, + RISCV_PseudoVSADD_VI_MF8 = 8002, + RISCV_PseudoVSADD_VI_MF8_MASK = 8003, + RISCV_PseudoVSADD_VV_M1 = 8004, + RISCV_PseudoVSADD_VV_M1_MASK = 8005, + RISCV_PseudoVSADD_VV_M2 = 8006, + RISCV_PseudoVSADD_VV_M2_MASK = 8007, + RISCV_PseudoVSADD_VV_M4 = 8008, + RISCV_PseudoVSADD_VV_M4_MASK = 8009, + RISCV_PseudoVSADD_VV_M8 = 8010, + RISCV_PseudoVSADD_VV_M8_MASK = 8011, + RISCV_PseudoVSADD_VV_MF2 = 8012, + RISCV_PseudoVSADD_VV_MF2_MASK = 8013, + RISCV_PseudoVSADD_VV_MF4 = 8014, + RISCV_PseudoVSADD_VV_MF4_MASK = 8015, + RISCV_PseudoVSADD_VV_MF8 = 8016, + RISCV_PseudoVSADD_VV_MF8_MASK = 8017, + RISCV_PseudoVSADD_VX_M1 = 8018, + RISCV_PseudoVSADD_VX_M1_MASK = 8019, + RISCV_PseudoVSADD_VX_M2 = 8020, + RISCV_PseudoVSADD_VX_M2_MASK = 8021, + RISCV_PseudoVSADD_VX_M4 = 8022, + RISCV_PseudoVSADD_VX_M4_MASK = 8023, + RISCV_PseudoVSADD_VX_M8 = 8024, + RISCV_PseudoVSADD_VX_M8_MASK = 8025, + RISCV_PseudoVSADD_VX_MF2 = 8026, + RISCV_PseudoVSADD_VX_MF2_MASK = 8027, + RISCV_PseudoVSADD_VX_MF4 = 8028, + RISCV_PseudoVSADD_VX_MF4_MASK = 8029, + RISCV_PseudoVSADD_VX_MF8 = 8030, + RISCV_PseudoVSADD_VX_MF8_MASK = 8031, + RISCV_PseudoVSBC_VVM_M1 = 8032, + RISCV_PseudoVSBC_VVM_M2 = 8033, + RISCV_PseudoVSBC_VVM_M4 = 8034, + RISCV_PseudoVSBC_VVM_M8 = 8035, + RISCV_PseudoVSBC_VVM_MF2 = 8036, + RISCV_PseudoVSBC_VVM_MF4 = 8037, + RISCV_PseudoVSBC_VVM_MF8 = 8038, + RISCV_PseudoVSBC_VXM_M1 = 8039, + RISCV_PseudoVSBC_VXM_M2 = 8040, + RISCV_PseudoVSBC_VXM_M4 = 8041, + RISCV_PseudoVSBC_VXM_M8 = 8042, + RISCV_PseudoVSBC_VXM_MF2 = 8043, + RISCV_PseudoVSBC_VXM_MF4 = 8044, + RISCV_PseudoVSBC_VXM_MF8 = 8045, + RISCV_PseudoVSE16_V_M1 = 8046, + RISCV_PseudoVSE16_V_M1_MASK = 8047, + RISCV_PseudoVSE16_V_M2 = 8048, + RISCV_PseudoVSE16_V_M2_MASK = 8049, + RISCV_PseudoVSE16_V_M4 = 8050, + RISCV_PseudoVSE16_V_M4_MASK = 8051, + RISCV_PseudoVSE16_V_M8 = 8052, + RISCV_PseudoVSE16_V_M8_MASK = 8053, + RISCV_PseudoVSE16_V_MF2 = 8054, + RISCV_PseudoVSE16_V_MF2_MASK = 8055, + RISCV_PseudoVSE16_V_MF4 = 8056, + RISCV_PseudoVSE16_V_MF4_MASK = 8057, + RISCV_PseudoVSE32_V_M1 = 8058, + RISCV_PseudoVSE32_V_M1_MASK = 8059, + RISCV_PseudoVSE32_V_M2 = 8060, + RISCV_PseudoVSE32_V_M2_MASK = 8061, + RISCV_PseudoVSE32_V_M4 = 8062, + RISCV_PseudoVSE32_V_M4_MASK = 8063, + RISCV_PseudoVSE32_V_M8 = 8064, + RISCV_PseudoVSE32_V_M8_MASK = 8065, + RISCV_PseudoVSE32_V_MF2 = 8066, + RISCV_PseudoVSE32_V_MF2_MASK = 8067, + RISCV_PseudoVSE64_V_M1 = 8068, + RISCV_PseudoVSE64_V_M1_MASK = 8069, + RISCV_PseudoVSE64_V_M2 = 8070, + RISCV_PseudoVSE64_V_M2_MASK = 8071, + RISCV_PseudoVSE64_V_M4 = 8072, + RISCV_PseudoVSE64_V_M4_MASK = 8073, + RISCV_PseudoVSE64_V_M8 = 8074, + RISCV_PseudoVSE64_V_M8_MASK = 8075, + RISCV_PseudoVSE8_V_M1 = 8076, + RISCV_PseudoVSE8_V_M1_MASK = 8077, + RISCV_PseudoVSE8_V_M2 = 8078, + RISCV_PseudoVSE8_V_M2_MASK = 8079, + RISCV_PseudoVSE8_V_M4 = 8080, + RISCV_PseudoVSE8_V_M4_MASK = 8081, + RISCV_PseudoVSE8_V_M8 = 8082, + RISCV_PseudoVSE8_V_M8_MASK = 8083, + RISCV_PseudoVSE8_V_MF2 = 8084, + RISCV_PseudoVSE8_V_MF2_MASK = 8085, + RISCV_PseudoVSE8_V_MF4 = 8086, + RISCV_PseudoVSE8_V_MF4_MASK = 8087, + RISCV_PseudoVSE8_V_MF8 = 8088, + RISCV_PseudoVSE8_V_MF8_MASK = 8089, + RISCV_PseudoVSETIVLI = 8090, + RISCV_PseudoVSETVLI = 8091, + RISCV_PseudoVSETVLIX0 = 8092, + RISCV_PseudoVSEXT_VF2_M1 = 8093, + RISCV_PseudoVSEXT_VF2_M1_MASK = 8094, + RISCV_PseudoVSEXT_VF2_M2 = 8095, + RISCV_PseudoVSEXT_VF2_M2_MASK = 8096, + RISCV_PseudoVSEXT_VF2_M4 = 8097, + RISCV_PseudoVSEXT_VF2_M4_MASK = 8098, + RISCV_PseudoVSEXT_VF2_M8 = 8099, + RISCV_PseudoVSEXT_VF2_M8_MASK = 8100, + RISCV_PseudoVSEXT_VF2_MF2 = 8101, + RISCV_PseudoVSEXT_VF2_MF2_MASK = 8102, + RISCV_PseudoVSEXT_VF2_MF4 = 8103, + RISCV_PseudoVSEXT_VF2_MF4_MASK = 8104, + RISCV_PseudoVSEXT_VF4_M1 = 8105, + RISCV_PseudoVSEXT_VF4_M1_MASK = 8106, + RISCV_PseudoVSEXT_VF4_M2 = 8107, + RISCV_PseudoVSEXT_VF4_M2_MASK = 8108, + RISCV_PseudoVSEXT_VF4_M4 = 8109, + RISCV_PseudoVSEXT_VF4_M4_MASK = 8110, + RISCV_PseudoVSEXT_VF4_M8 = 8111, + RISCV_PseudoVSEXT_VF4_M8_MASK = 8112, + RISCV_PseudoVSEXT_VF4_MF2 = 8113, + RISCV_PseudoVSEXT_VF4_MF2_MASK = 8114, + RISCV_PseudoVSEXT_VF8_M1 = 8115, + RISCV_PseudoVSEXT_VF8_M1_MASK = 8116, + RISCV_PseudoVSEXT_VF8_M2 = 8117, + RISCV_PseudoVSEXT_VF8_M2_MASK = 8118, + RISCV_PseudoVSEXT_VF8_M4 = 8119, + RISCV_PseudoVSEXT_VF8_M4_MASK = 8120, + RISCV_PseudoVSEXT_VF8_M8 = 8121, + RISCV_PseudoVSEXT_VF8_M8_MASK = 8122, + RISCV_PseudoVSHA2CH_VV_M1 = 8123, + RISCV_PseudoVSHA2CH_VV_M2 = 8124, + RISCV_PseudoVSHA2CH_VV_M4 = 8125, + RISCV_PseudoVSHA2CH_VV_M8 = 8126, + RISCV_PseudoVSHA2CH_VV_MF2 = 8127, + RISCV_PseudoVSHA2CL_VV_M1 = 8128, + RISCV_PseudoVSHA2CL_VV_M2 = 8129, + RISCV_PseudoVSHA2CL_VV_M4 = 8130, + RISCV_PseudoVSHA2CL_VV_M8 = 8131, + RISCV_PseudoVSHA2CL_VV_MF2 = 8132, + RISCV_PseudoVSHA2MS_VV_M1 = 8133, + RISCV_PseudoVSHA2MS_VV_M2 = 8134, + RISCV_PseudoVSHA2MS_VV_M4 = 8135, + RISCV_PseudoVSHA2MS_VV_M8 = 8136, + RISCV_PseudoVSHA2MS_VV_MF2 = 8137, + RISCV_PseudoVSLIDE1DOWN_VX_M1 = 8138, + RISCV_PseudoVSLIDE1DOWN_VX_M1_MASK = 8139, + RISCV_PseudoVSLIDE1DOWN_VX_M2 = 8140, + RISCV_PseudoVSLIDE1DOWN_VX_M2_MASK = 8141, + RISCV_PseudoVSLIDE1DOWN_VX_M4 = 8142, + RISCV_PseudoVSLIDE1DOWN_VX_M4_MASK = 8143, + RISCV_PseudoVSLIDE1DOWN_VX_M8 = 8144, + RISCV_PseudoVSLIDE1DOWN_VX_M8_MASK = 8145, + RISCV_PseudoVSLIDE1DOWN_VX_MF2 = 8146, + RISCV_PseudoVSLIDE1DOWN_VX_MF2_MASK = 8147, + RISCV_PseudoVSLIDE1DOWN_VX_MF4 = 8148, + RISCV_PseudoVSLIDE1DOWN_VX_MF4_MASK = 8149, + RISCV_PseudoVSLIDE1DOWN_VX_MF8 = 8150, + RISCV_PseudoVSLIDE1DOWN_VX_MF8_MASK = 8151, + RISCV_PseudoVSLIDE1UP_VX_M1 = 8152, + RISCV_PseudoVSLIDE1UP_VX_M1_MASK = 8153, + RISCV_PseudoVSLIDE1UP_VX_M2 = 8154, + RISCV_PseudoVSLIDE1UP_VX_M2_MASK = 8155, + RISCV_PseudoVSLIDE1UP_VX_M4 = 8156, + RISCV_PseudoVSLIDE1UP_VX_M4_MASK = 8157, + RISCV_PseudoVSLIDE1UP_VX_M8 = 8158, + RISCV_PseudoVSLIDE1UP_VX_M8_MASK = 8159, + RISCV_PseudoVSLIDE1UP_VX_MF2 = 8160, + RISCV_PseudoVSLIDE1UP_VX_MF2_MASK = 8161, + RISCV_PseudoVSLIDE1UP_VX_MF4 = 8162, + RISCV_PseudoVSLIDE1UP_VX_MF4_MASK = 8163, + RISCV_PseudoVSLIDE1UP_VX_MF8 = 8164, + RISCV_PseudoVSLIDE1UP_VX_MF8_MASK = 8165, + RISCV_PseudoVSLIDEDOWN_VI_M1 = 8166, + RISCV_PseudoVSLIDEDOWN_VI_M1_MASK = 8167, + RISCV_PseudoVSLIDEDOWN_VI_M2 = 8168, + RISCV_PseudoVSLIDEDOWN_VI_M2_MASK = 8169, + RISCV_PseudoVSLIDEDOWN_VI_M4 = 8170, + RISCV_PseudoVSLIDEDOWN_VI_M4_MASK = 8171, + RISCV_PseudoVSLIDEDOWN_VI_M8 = 8172, + RISCV_PseudoVSLIDEDOWN_VI_M8_MASK = 8173, + RISCV_PseudoVSLIDEDOWN_VI_MF2 = 8174, + RISCV_PseudoVSLIDEDOWN_VI_MF2_MASK = 8175, + RISCV_PseudoVSLIDEDOWN_VI_MF4 = 8176, + RISCV_PseudoVSLIDEDOWN_VI_MF4_MASK = 8177, + RISCV_PseudoVSLIDEDOWN_VI_MF8 = 8178, + RISCV_PseudoVSLIDEDOWN_VI_MF8_MASK = 8179, + RISCV_PseudoVSLIDEDOWN_VX_M1 = 8180, + RISCV_PseudoVSLIDEDOWN_VX_M1_MASK = 8181, + RISCV_PseudoVSLIDEDOWN_VX_M2 = 8182, + RISCV_PseudoVSLIDEDOWN_VX_M2_MASK = 8183, + RISCV_PseudoVSLIDEDOWN_VX_M4 = 8184, + RISCV_PseudoVSLIDEDOWN_VX_M4_MASK = 8185, + RISCV_PseudoVSLIDEDOWN_VX_M8 = 8186, + RISCV_PseudoVSLIDEDOWN_VX_M8_MASK = 8187, + RISCV_PseudoVSLIDEDOWN_VX_MF2 = 8188, + RISCV_PseudoVSLIDEDOWN_VX_MF2_MASK = 8189, + RISCV_PseudoVSLIDEDOWN_VX_MF4 = 8190, + RISCV_PseudoVSLIDEDOWN_VX_MF4_MASK = 8191, + RISCV_PseudoVSLIDEDOWN_VX_MF8 = 8192, + RISCV_PseudoVSLIDEDOWN_VX_MF8_MASK = 8193, + RISCV_PseudoVSLIDEUP_VI_M1 = 8194, + RISCV_PseudoVSLIDEUP_VI_M1_MASK = 8195, + RISCV_PseudoVSLIDEUP_VI_M2 = 8196, + RISCV_PseudoVSLIDEUP_VI_M2_MASK = 8197, + RISCV_PseudoVSLIDEUP_VI_M4 = 8198, + RISCV_PseudoVSLIDEUP_VI_M4_MASK = 8199, + RISCV_PseudoVSLIDEUP_VI_M8 = 8200, + RISCV_PseudoVSLIDEUP_VI_M8_MASK = 8201, + RISCV_PseudoVSLIDEUP_VI_MF2 = 8202, + RISCV_PseudoVSLIDEUP_VI_MF2_MASK = 8203, + RISCV_PseudoVSLIDEUP_VI_MF4 = 8204, + RISCV_PseudoVSLIDEUP_VI_MF4_MASK = 8205, + RISCV_PseudoVSLIDEUP_VI_MF8 = 8206, + RISCV_PseudoVSLIDEUP_VI_MF8_MASK = 8207, + RISCV_PseudoVSLIDEUP_VX_M1 = 8208, + RISCV_PseudoVSLIDEUP_VX_M1_MASK = 8209, + RISCV_PseudoVSLIDEUP_VX_M2 = 8210, + RISCV_PseudoVSLIDEUP_VX_M2_MASK = 8211, + RISCV_PseudoVSLIDEUP_VX_M4 = 8212, + RISCV_PseudoVSLIDEUP_VX_M4_MASK = 8213, + RISCV_PseudoVSLIDEUP_VX_M8 = 8214, + RISCV_PseudoVSLIDEUP_VX_M8_MASK = 8215, + RISCV_PseudoVSLIDEUP_VX_MF2 = 8216, + RISCV_PseudoVSLIDEUP_VX_MF2_MASK = 8217, + RISCV_PseudoVSLIDEUP_VX_MF4 = 8218, + RISCV_PseudoVSLIDEUP_VX_MF4_MASK = 8219, + RISCV_PseudoVSLIDEUP_VX_MF8 = 8220, + RISCV_PseudoVSLIDEUP_VX_MF8_MASK = 8221, + RISCV_PseudoVSLL_VI_M1 = 8222, + RISCV_PseudoVSLL_VI_M1_MASK = 8223, + RISCV_PseudoVSLL_VI_M2 = 8224, + RISCV_PseudoVSLL_VI_M2_MASK = 8225, + RISCV_PseudoVSLL_VI_M4 = 8226, + RISCV_PseudoVSLL_VI_M4_MASK = 8227, + RISCV_PseudoVSLL_VI_M8 = 8228, + RISCV_PseudoVSLL_VI_M8_MASK = 8229, + RISCV_PseudoVSLL_VI_MF2 = 8230, + RISCV_PseudoVSLL_VI_MF2_MASK = 8231, + RISCV_PseudoVSLL_VI_MF4 = 8232, + RISCV_PseudoVSLL_VI_MF4_MASK = 8233, + RISCV_PseudoVSLL_VI_MF8 = 8234, + RISCV_PseudoVSLL_VI_MF8_MASK = 8235, + RISCV_PseudoVSLL_VV_M1 = 8236, + RISCV_PseudoVSLL_VV_M1_MASK = 8237, + RISCV_PseudoVSLL_VV_M2 = 8238, + RISCV_PseudoVSLL_VV_M2_MASK = 8239, + RISCV_PseudoVSLL_VV_M4 = 8240, + RISCV_PseudoVSLL_VV_M4_MASK = 8241, + RISCV_PseudoVSLL_VV_M8 = 8242, + RISCV_PseudoVSLL_VV_M8_MASK = 8243, + RISCV_PseudoVSLL_VV_MF2 = 8244, + RISCV_PseudoVSLL_VV_MF2_MASK = 8245, + RISCV_PseudoVSLL_VV_MF4 = 8246, + RISCV_PseudoVSLL_VV_MF4_MASK = 8247, + RISCV_PseudoVSLL_VV_MF8 = 8248, + RISCV_PseudoVSLL_VV_MF8_MASK = 8249, + RISCV_PseudoVSLL_VX_M1 = 8250, + RISCV_PseudoVSLL_VX_M1_MASK = 8251, + RISCV_PseudoVSLL_VX_M2 = 8252, + RISCV_PseudoVSLL_VX_M2_MASK = 8253, + RISCV_PseudoVSLL_VX_M4 = 8254, + RISCV_PseudoVSLL_VX_M4_MASK = 8255, + RISCV_PseudoVSLL_VX_M8 = 8256, + RISCV_PseudoVSLL_VX_M8_MASK = 8257, + RISCV_PseudoVSLL_VX_MF2 = 8258, + RISCV_PseudoVSLL_VX_MF2_MASK = 8259, + RISCV_PseudoVSLL_VX_MF4 = 8260, + RISCV_PseudoVSLL_VX_MF4_MASK = 8261, + RISCV_PseudoVSLL_VX_MF8 = 8262, + RISCV_PseudoVSLL_VX_MF8_MASK = 8263, + RISCV_PseudoVSM3C_VI_M1 = 8264, + RISCV_PseudoVSM3C_VI_M2 = 8265, + RISCV_PseudoVSM3C_VI_M4 = 8266, + RISCV_PseudoVSM3C_VI_M8 = 8267, + RISCV_PseudoVSM3C_VI_MF2 = 8268, + RISCV_PseudoVSM3ME_VV_M1 = 8269, + RISCV_PseudoVSM3ME_VV_M2 = 8270, + RISCV_PseudoVSM3ME_VV_M4 = 8271, + RISCV_PseudoVSM3ME_VV_M8 = 8272, + RISCV_PseudoVSM3ME_VV_MF2 = 8273, + RISCV_PseudoVSM4K_VI_M1 = 8274, + RISCV_PseudoVSM4K_VI_M2 = 8275, + RISCV_PseudoVSM4K_VI_M4 = 8276, + RISCV_PseudoVSM4K_VI_M8 = 8277, + RISCV_PseudoVSM4K_VI_MF2 = 8278, + RISCV_PseudoVSM4R_VS_M1_M1 = 8279, + RISCV_PseudoVSM4R_VS_M1_MF2 = 8280, + RISCV_PseudoVSM4R_VS_M1_MF4 = 8281, + RISCV_PseudoVSM4R_VS_M1_MF8 = 8282, + RISCV_PseudoVSM4R_VS_M2_M1 = 8283, + RISCV_PseudoVSM4R_VS_M2_M2 = 8284, + RISCV_PseudoVSM4R_VS_M2_MF2 = 8285, + RISCV_PseudoVSM4R_VS_M2_MF4 = 8286, + RISCV_PseudoVSM4R_VS_M2_MF8 = 8287, + RISCV_PseudoVSM4R_VS_M4_M1 = 8288, + RISCV_PseudoVSM4R_VS_M4_M2 = 8289, + RISCV_PseudoVSM4R_VS_M4_M4 = 8290, + RISCV_PseudoVSM4R_VS_M4_MF2 = 8291, + RISCV_PseudoVSM4R_VS_M4_MF4 = 8292, + RISCV_PseudoVSM4R_VS_M4_MF8 = 8293, + RISCV_PseudoVSM4R_VS_M8_M1 = 8294, + RISCV_PseudoVSM4R_VS_M8_M2 = 8295, + RISCV_PseudoVSM4R_VS_M8_M4 = 8296, + RISCV_PseudoVSM4R_VS_M8_MF2 = 8297, + RISCV_PseudoVSM4R_VS_M8_MF4 = 8298, + RISCV_PseudoVSM4R_VS_M8_MF8 = 8299, + RISCV_PseudoVSM4R_VS_MF2_MF2 = 8300, + RISCV_PseudoVSM4R_VS_MF2_MF4 = 8301, + RISCV_PseudoVSM4R_VS_MF2_MF8 = 8302, + RISCV_PseudoVSM4R_VV_M1 = 8303, + RISCV_PseudoVSM4R_VV_M2 = 8304, + RISCV_PseudoVSM4R_VV_M4 = 8305, + RISCV_PseudoVSM4R_VV_M8 = 8306, + RISCV_PseudoVSM4R_VV_MF2 = 8307, + RISCV_PseudoVSMUL_VV_M1 = 8308, + RISCV_PseudoVSMUL_VV_M1_MASK = 8309, + RISCV_PseudoVSMUL_VV_M2 = 8310, + RISCV_PseudoVSMUL_VV_M2_MASK = 8311, + RISCV_PseudoVSMUL_VV_M4 = 8312, + RISCV_PseudoVSMUL_VV_M4_MASK = 8313, + RISCV_PseudoVSMUL_VV_M8 = 8314, + RISCV_PseudoVSMUL_VV_M8_MASK = 8315, + RISCV_PseudoVSMUL_VV_MF2 = 8316, + RISCV_PseudoVSMUL_VV_MF2_MASK = 8317, + RISCV_PseudoVSMUL_VV_MF4 = 8318, + RISCV_PseudoVSMUL_VV_MF4_MASK = 8319, + RISCV_PseudoVSMUL_VV_MF8 = 8320, + RISCV_PseudoVSMUL_VV_MF8_MASK = 8321, + RISCV_PseudoVSMUL_VX_M1 = 8322, + RISCV_PseudoVSMUL_VX_M1_MASK = 8323, + RISCV_PseudoVSMUL_VX_M2 = 8324, + RISCV_PseudoVSMUL_VX_M2_MASK = 8325, + RISCV_PseudoVSMUL_VX_M4 = 8326, + RISCV_PseudoVSMUL_VX_M4_MASK = 8327, + RISCV_PseudoVSMUL_VX_M8 = 8328, + RISCV_PseudoVSMUL_VX_M8_MASK = 8329, + RISCV_PseudoVSMUL_VX_MF2 = 8330, + RISCV_PseudoVSMUL_VX_MF2_MASK = 8331, + RISCV_PseudoVSMUL_VX_MF4 = 8332, + RISCV_PseudoVSMUL_VX_MF4_MASK = 8333, + RISCV_PseudoVSMUL_VX_MF8 = 8334, + RISCV_PseudoVSMUL_VX_MF8_MASK = 8335, + RISCV_PseudoVSM_V_B1 = 8336, + RISCV_PseudoVSM_V_B16 = 8337, + RISCV_PseudoVSM_V_B2 = 8338, + RISCV_PseudoVSM_V_B32 = 8339, + RISCV_PseudoVSM_V_B4 = 8340, + RISCV_PseudoVSM_V_B64 = 8341, + RISCV_PseudoVSM_V_B8 = 8342, + RISCV_PseudoVSOXEI16_V_M1_M1 = 8343, + RISCV_PseudoVSOXEI16_V_M1_M1_MASK = 8344, + RISCV_PseudoVSOXEI16_V_M1_M2 = 8345, + RISCV_PseudoVSOXEI16_V_M1_M2_MASK = 8346, + RISCV_PseudoVSOXEI16_V_M1_M4 = 8347, + RISCV_PseudoVSOXEI16_V_M1_M4_MASK = 8348, + RISCV_PseudoVSOXEI16_V_M1_MF2 = 8349, + RISCV_PseudoVSOXEI16_V_M1_MF2_MASK = 8350, + RISCV_PseudoVSOXEI16_V_M2_M1 = 8351, + RISCV_PseudoVSOXEI16_V_M2_M1_MASK = 8352, + RISCV_PseudoVSOXEI16_V_M2_M2 = 8353, + RISCV_PseudoVSOXEI16_V_M2_M2_MASK = 8354, + RISCV_PseudoVSOXEI16_V_M2_M4 = 8355, + RISCV_PseudoVSOXEI16_V_M2_M4_MASK = 8356, + RISCV_PseudoVSOXEI16_V_M2_M8 = 8357, + RISCV_PseudoVSOXEI16_V_M2_M8_MASK = 8358, + RISCV_PseudoVSOXEI16_V_M4_M2 = 8359, + RISCV_PseudoVSOXEI16_V_M4_M2_MASK = 8360, + RISCV_PseudoVSOXEI16_V_M4_M4 = 8361, + RISCV_PseudoVSOXEI16_V_M4_M4_MASK = 8362, + RISCV_PseudoVSOXEI16_V_M4_M8 = 8363, + RISCV_PseudoVSOXEI16_V_M4_M8_MASK = 8364, + RISCV_PseudoVSOXEI16_V_M8_M4 = 8365, + RISCV_PseudoVSOXEI16_V_M8_M4_MASK = 8366, + RISCV_PseudoVSOXEI16_V_M8_M8 = 8367, + RISCV_PseudoVSOXEI16_V_M8_M8_MASK = 8368, + RISCV_PseudoVSOXEI16_V_MF2_M1 = 8369, + RISCV_PseudoVSOXEI16_V_MF2_M1_MASK = 8370, + RISCV_PseudoVSOXEI16_V_MF2_M2 = 8371, + RISCV_PseudoVSOXEI16_V_MF2_M2_MASK = 8372, + RISCV_PseudoVSOXEI16_V_MF2_MF2 = 8373, + RISCV_PseudoVSOXEI16_V_MF2_MF2_MASK = 8374, + RISCV_PseudoVSOXEI16_V_MF2_MF4 = 8375, + RISCV_PseudoVSOXEI16_V_MF2_MF4_MASK = 8376, + RISCV_PseudoVSOXEI16_V_MF4_M1 = 8377, + RISCV_PseudoVSOXEI16_V_MF4_M1_MASK = 8378, + RISCV_PseudoVSOXEI16_V_MF4_MF2 = 8379, + RISCV_PseudoVSOXEI16_V_MF4_MF2_MASK = 8380, + RISCV_PseudoVSOXEI16_V_MF4_MF4 = 8381, + RISCV_PseudoVSOXEI16_V_MF4_MF4_MASK = 8382, + RISCV_PseudoVSOXEI16_V_MF4_MF8 = 8383, + RISCV_PseudoVSOXEI16_V_MF4_MF8_MASK = 8384, + RISCV_PseudoVSOXEI32_V_M1_M1 = 8385, + RISCV_PseudoVSOXEI32_V_M1_M1_MASK = 8386, + RISCV_PseudoVSOXEI32_V_M1_M2 = 8387, + RISCV_PseudoVSOXEI32_V_M1_M2_MASK = 8388, + RISCV_PseudoVSOXEI32_V_M1_MF2 = 8389, + RISCV_PseudoVSOXEI32_V_M1_MF2_MASK = 8390, + RISCV_PseudoVSOXEI32_V_M1_MF4 = 8391, + RISCV_PseudoVSOXEI32_V_M1_MF4_MASK = 8392, + RISCV_PseudoVSOXEI32_V_M2_M1 = 8393, + RISCV_PseudoVSOXEI32_V_M2_M1_MASK = 8394, + RISCV_PseudoVSOXEI32_V_M2_M2 = 8395, + RISCV_PseudoVSOXEI32_V_M2_M2_MASK = 8396, + RISCV_PseudoVSOXEI32_V_M2_M4 = 8397, + RISCV_PseudoVSOXEI32_V_M2_M4_MASK = 8398, + RISCV_PseudoVSOXEI32_V_M2_MF2 = 8399, + RISCV_PseudoVSOXEI32_V_M2_MF2_MASK = 8400, + RISCV_PseudoVSOXEI32_V_M4_M1 = 8401, + RISCV_PseudoVSOXEI32_V_M4_M1_MASK = 8402, + RISCV_PseudoVSOXEI32_V_M4_M2 = 8403, + RISCV_PseudoVSOXEI32_V_M4_M2_MASK = 8404, + RISCV_PseudoVSOXEI32_V_M4_M4 = 8405, + RISCV_PseudoVSOXEI32_V_M4_M4_MASK = 8406, + RISCV_PseudoVSOXEI32_V_M4_M8 = 8407, + RISCV_PseudoVSOXEI32_V_M4_M8_MASK = 8408, + RISCV_PseudoVSOXEI32_V_M8_M2 = 8409, + RISCV_PseudoVSOXEI32_V_M8_M2_MASK = 8410, + RISCV_PseudoVSOXEI32_V_M8_M4 = 8411, + RISCV_PseudoVSOXEI32_V_M8_M4_MASK = 8412, + RISCV_PseudoVSOXEI32_V_M8_M8 = 8413, + RISCV_PseudoVSOXEI32_V_M8_M8_MASK = 8414, + RISCV_PseudoVSOXEI32_V_MF2_M1 = 8415, + RISCV_PseudoVSOXEI32_V_MF2_M1_MASK = 8416, + RISCV_PseudoVSOXEI32_V_MF2_MF2 = 8417, + RISCV_PseudoVSOXEI32_V_MF2_MF2_MASK = 8418, + RISCV_PseudoVSOXEI32_V_MF2_MF4 = 8419, + RISCV_PseudoVSOXEI32_V_MF2_MF4_MASK = 8420, + RISCV_PseudoVSOXEI32_V_MF2_MF8 = 8421, + RISCV_PseudoVSOXEI32_V_MF2_MF8_MASK = 8422, + RISCV_PseudoVSOXEI64_V_M1_M1 = 8423, + RISCV_PseudoVSOXEI64_V_M1_M1_MASK = 8424, + RISCV_PseudoVSOXEI64_V_M1_MF2 = 8425, + RISCV_PseudoVSOXEI64_V_M1_MF2_MASK = 8426, + RISCV_PseudoVSOXEI64_V_M1_MF4 = 8427, + RISCV_PseudoVSOXEI64_V_M1_MF4_MASK = 8428, + RISCV_PseudoVSOXEI64_V_M1_MF8 = 8429, + RISCV_PseudoVSOXEI64_V_M1_MF8_MASK = 8430, + RISCV_PseudoVSOXEI64_V_M2_M1 = 8431, + RISCV_PseudoVSOXEI64_V_M2_M1_MASK = 8432, + RISCV_PseudoVSOXEI64_V_M2_M2 = 8433, + RISCV_PseudoVSOXEI64_V_M2_M2_MASK = 8434, + RISCV_PseudoVSOXEI64_V_M2_MF2 = 8435, + RISCV_PseudoVSOXEI64_V_M2_MF2_MASK = 8436, + RISCV_PseudoVSOXEI64_V_M2_MF4 = 8437, + RISCV_PseudoVSOXEI64_V_M2_MF4_MASK = 8438, + RISCV_PseudoVSOXEI64_V_M4_M1 = 8439, + RISCV_PseudoVSOXEI64_V_M4_M1_MASK = 8440, + RISCV_PseudoVSOXEI64_V_M4_M2 = 8441, + RISCV_PseudoVSOXEI64_V_M4_M2_MASK = 8442, + RISCV_PseudoVSOXEI64_V_M4_M4 = 8443, + RISCV_PseudoVSOXEI64_V_M4_M4_MASK = 8444, + RISCV_PseudoVSOXEI64_V_M4_MF2 = 8445, + RISCV_PseudoVSOXEI64_V_M4_MF2_MASK = 8446, + RISCV_PseudoVSOXEI64_V_M8_M1 = 8447, + RISCV_PseudoVSOXEI64_V_M8_M1_MASK = 8448, + RISCV_PseudoVSOXEI64_V_M8_M2 = 8449, + RISCV_PseudoVSOXEI64_V_M8_M2_MASK = 8450, + RISCV_PseudoVSOXEI64_V_M8_M4 = 8451, + RISCV_PseudoVSOXEI64_V_M8_M4_MASK = 8452, + RISCV_PseudoVSOXEI64_V_M8_M8 = 8453, + RISCV_PseudoVSOXEI64_V_M8_M8_MASK = 8454, + RISCV_PseudoVSOXEI8_V_M1_M1 = 8455, + RISCV_PseudoVSOXEI8_V_M1_M1_MASK = 8456, + RISCV_PseudoVSOXEI8_V_M1_M2 = 8457, + RISCV_PseudoVSOXEI8_V_M1_M2_MASK = 8458, + RISCV_PseudoVSOXEI8_V_M1_M4 = 8459, + RISCV_PseudoVSOXEI8_V_M1_M4_MASK = 8460, + RISCV_PseudoVSOXEI8_V_M1_M8 = 8461, + RISCV_PseudoVSOXEI8_V_M1_M8_MASK = 8462, + RISCV_PseudoVSOXEI8_V_M2_M2 = 8463, + RISCV_PseudoVSOXEI8_V_M2_M2_MASK = 8464, + RISCV_PseudoVSOXEI8_V_M2_M4 = 8465, + RISCV_PseudoVSOXEI8_V_M2_M4_MASK = 8466, + RISCV_PseudoVSOXEI8_V_M2_M8 = 8467, + RISCV_PseudoVSOXEI8_V_M2_M8_MASK = 8468, + RISCV_PseudoVSOXEI8_V_M4_M4 = 8469, + RISCV_PseudoVSOXEI8_V_M4_M4_MASK = 8470, + RISCV_PseudoVSOXEI8_V_M4_M8 = 8471, + RISCV_PseudoVSOXEI8_V_M4_M8_MASK = 8472, + RISCV_PseudoVSOXEI8_V_M8_M8 = 8473, + RISCV_PseudoVSOXEI8_V_M8_M8_MASK = 8474, + RISCV_PseudoVSOXEI8_V_MF2_M1 = 8475, + RISCV_PseudoVSOXEI8_V_MF2_M1_MASK = 8476, + RISCV_PseudoVSOXEI8_V_MF2_M2 = 8477, + RISCV_PseudoVSOXEI8_V_MF2_M2_MASK = 8478, + RISCV_PseudoVSOXEI8_V_MF2_M4 = 8479, + RISCV_PseudoVSOXEI8_V_MF2_M4_MASK = 8480, + RISCV_PseudoVSOXEI8_V_MF2_MF2 = 8481, + RISCV_PseudoVSOXEI8_V_MF2_MF2_MASK = 8482, + RISCV_PseudoVSOXEI8_V_MF4_M1 = 8483, + RISCV_PseudoVSOXEI8_V_MF4_M1_MASK = 8484, + RISCV_PseudoVSOXEI8_V_MF4_M2 = 8485, + RISCV_PseudoVSOXEI8_V_MF4_M2_MASK = 8486, + RISCV_PseudoVSOXEI8_V_MF4_MF2 = 8487, + RISCV_PseudoVSOXEI8_V_MF4_MF2_MASK = 8488, + RISCV_PseudoVSOXEI8_V_MF4_MF4 = 8489, + RISCV_PseudoVSOXEI8_V_MF4_MF4_MASK = 8490, + RISCV_PseudoVSOXEI8_V_MF8_M1 = 8491, + RISCV_PseudoVSOXEI8_V_MF8_M1_MASK = 8492, + RISCV_PseudoVSOXEI8_V_MF8_MF2 = 8493, + RISCV_PseudoVSOXEI8_V_MF8_MF2_MASK = 8494, + RISCV_PseudoVSOXEI8_V_MF8_MF4 = 8495, + RISCV_PseudoVSOXEI8_V_MF8_MF4_MASK = 8496, + RISCV_PseudoVSOXEI8_V_MF8_MF8 = 8497, + RISCV_PseudoVSOXEI8_V_MF8_MF8_MASK = 8498, + RISCV_PseudoVSOXSEG2EI16_V_M1_M1 = 8499, + RISCV_PseudoVSOXSEG2EI16_V_M1_M1_MASK = 8500, + RISCV_PseudoVSOXSEG2EI16_V_M1_M2 = 8501, + RISCV_PseudoVSOXSEG2EI16_V_M1_M2_MASK = 8502, + RISCV_PseudoVSOXSEG2EI16_V_M1_M4 = 8503, + RISCV_PseudoVSOXSEG2EI16_V_M1_M4_MASK = 8504, + RISCV_PseudoVSOXSEG2EI16_V_M1_MF2 = 8505, + RISCV_PseudoVSOXSEG2EI16_V_M1_MF2_MASK = 8506, + RISCV_PseudoVSOXSEG2EI16_V_M2_M1 = 8507, + RISCV_PseudoVSOXSEG2EI16_V_M2_M1_MASK = 8508, + RISCV_PseudoVSOXSEG2EI16_V_M2_M2 = 8509, + RISCV_PseudoVSOXSEG2EI16_V_M2_M2_MASK = 8510, + RISCV_PseudoVSOXSEG2EI16_V_M2_M4 = 8511, + RISCV_PseudoVSOXSEG2EI16_V_M2_M4_MASK = 8512, + RISCV_PseudoVSOXSEG2EI16_V_M4_M2 = 8513, + RISCV_PseudoVSOXSEG2EI16_V_M4_M2_MASK = 8514, + RISCV_PseudoVSOXSEG2EI16_V_M4_M4 = 8515, + RISCV_PseudoVSOXSEG2EI16_V_M4_M4_MASK = 8516, + RISCV_PseudoVSOXSEG2EI16_V_M8_M4 = 8517, + RISCV_PseudoVSOXSEG2EI16_V_M8_M4_MASK = 8518, + RISCV_PseudoVSOXSEG2EI16_V_MF2_M1 = 8519, + RISCV_PseudoVSOXSEG2EI16_V_MF2_M1_MASK = 8520, + RISCV_PseudoVSOXSEG2EI16_V_MF2_M2 = 8521, + RISCV_PseudoVSOXSEG2EI16_V_MF2_M2_MASK = 8522, + RISCV_PseudoVSOXSEG2EI16_V_MF2_MF2 = 8523, + RISCV_PseudoVSOXSEG2EI16_V_MF2_MF2_MASK = 8524, + RISCV_PseudoVSOXSEG2EI16_V_MF2_MF4 = 8525, + RISCV_PseudoVSOXSEG2EI16_V_MF2_MF4_MASK = 8526, + RISCV_PseudoVSOXSEG2EI16_V_MF4_M1 = 8527, + RISCV_PseudoVSOXSEG2EI16_V_MF4_M1_MASK = 8528, + RISCV_PseudoVSOXSEG2EI16_V_MF4_MF2 = 8529, + RISCV_PseudoVSOXSEG2EI16_V_MF4_MF2_MASK = 8530, + RISCV_PseudoVSOXSEG2EI16_V_MF4_MF4 = 8531, + RISCV_PseudoVSOXSEG2EI16_V_MF4_MF4_MASK = 8532, + RISCV_PseudoVSOXSEG2EI16_V_MF4_MF8 = 8533, + RISCV_PseudoVSOXSEG2EI16_V_MF4_MF8_MASK = 8534, + RISCV_PseudoVSOXSEG2EI32_V_M1_M1 = 8535, + RISCV_PseudoVSOXSEG2EI32_V_M1_M1_MASK = 8536, + RISCV_PseudoVSOXSEG2EI32_V_M1_M2 = 8537, + RISCV_PseudoVSOXSEG2EI32_V_M1_M2_MASK = 8538, + RISCV_PseudoVSOXSEG2EI32_V_M1_MF2 = 8539, + RISCV_PseudoVSOXSEG2EI32_V_M1_MF2_MASK = 8540, + RISCV_PseudoVSOXSEG2EI32_V_M1_MF4 = 8541, + RISCV_PseudoVSOXSEG2EI32_V_M1_MF4_MASK = 8542, + RISCV_PseudoVSOXSEG2EI32_V_M2_M1 = 8543, + RISCV_PseudoVSOXSEG2EI32_V_M2_M1_MASK = 8544, + RISCV_PseudoVSOXSEG2EI32_V_M2_M2 = 8545, + RISCV_PseudoVSOXSEG2EI32_V_M2_M2_MASK = 8546, + RISCV_PseudoVSOXSEG2EI32_V_M2_M4 = 8547, + RISCV_PseudoVSOXSEG2EI32_V_M2_M4_MASK = 8548, + RISCV_PseudoVSOXSEG2EI32_V_M2_MF2 = 8549, + RISCV_PseudoVSOXSEG2EI32_V_M2_MF2_MASK = 8550, + RISCV_PseudoVSOXSEG2EI32_V_M4_M1 = 8551, + RISCV_PseudoVSOXSEG2EI32_V_M4_M1_MASK = 8552, + RISCV_PseudoVSOXSEG2EI32_V_M4_M2 = 8553, + RISCV_PseudoVSOXSEG2EI32_V_M4_M2_MASK = 8554, + RISCV_PseudoVSOXSEG2EI32_V_M4_M4 = 8555, + RISCV_PseudoVSOXSEG2EI32_V_M4_M4_MASK = 8556, + RISCV_PseudoVSOXSEG2EI32_V_M8_M2 = 8557, + RISCV_PseudoVSOXSEG2EI32_V_M8_M2_MASK = 8558, + RISCV_PseudoVSOXSEG2EI32_V_M8_M4 = 8559, + RISCV_PseudoVSOXSEG2EI32_V_M8_M4_MASK = 8560, + RISCV_PseudoVSOXSEG2EI32_V_MF2_M1 = 8561, + RISCV_PseudoVSOXSEG2EI32_V_MF2_M1_MASK = 8562, + RISCV_PseudoVSOXSEG2EI32_V_MF2_MF2 = 8563, + RISCV_PseudoVSOXSEG2EI32_V_MF2_MF2_MASK = 8564, + RISCV_PseudoVSOXSEG2EI32_V_MF2_MF4 = 8565, + RISCV_PseudoVSOXSEG2EI32_V_MF2_MF4_MASK = 8566, + RISCV_PseudoVSOXSEG2EI32_V_MF2_MF8 = 8567, + RISCV_PseudoVSOXSEG2EI32_V_MF2_MF8_MASK = 8568, + RISCV_PseudoVSOXSEG2EI64_V_M1_M1 = 8569, + RISCV_PseudoVSOXSEG2EI64_V_M1_M1_MASK = 8570, + RISCV_PseudoVSOXSEG2EI64_V_M1_MF2 = 8571, + RISCV_PseudoVSOXSEG2EI64_V_M1_MF2_MASK = 8572, + RISCV_PseudoVSOXSEG2EI64_V_M1_MF4 = 8573, + RISCV_PseudoVSOXSEG2EI64_V_M1_MF4_MASK = 8574, + RISCV_PseudoVSOXSEG2EI64_V_M1_MF8 = 8575, + RISCV_PseudoVSOXSEG2EI64_V_M1_MF8_MASK = 8576, + RISCV_PseudoVSOXSEG2EI64_V_M2_M1 = 8577, + RISCV_PseudoVSOXSEG2EI64_V_M2_M1_MASK = 8578, + RISCV_PseudoVSOXSEG2EI64_V_M2_M2 = 8579, + RISCV_PseudoVSOXSEG2EI64_V_M2_M2_MASK = 8580, + RISCV_PseudoVSOXSEG2EI64_V_M2_MF2 = 8581, + RISCV_PseudoVSOXSEG2EI64_V_M2_MF2_MASK = 8582, + RISCV_PseudoVSOXSEG2EI64_V_M2_MF4 = 8583, + RISCV_PseudoVSOXSEG2EI64_V_M2_MF4_MASK = 8584, + RISCV_PseudoVSOXSEG2EI64_V_M4_M1 = 8585, + RISCV_PseudoVSOXSEG2EI64_V_M4_M1_MASK = 8586, + RISCV_PseudoVSOXSEG2EI64_V_M4_M2 = 8587, + RISCV_PseudoVSOXSEG2EI64_V_M4_M2_MASK = 8588, + RISCV_PseudoVSOXSEG2EI64_V_M4_M4 = 8589, + RISCV_PseudoVSOXSEG2EI64_V_M4_M4_MASK = 8590, + RISCV_PseudoVSOXSEG2EI64_V_M4_MF2 = 8591, + RISCV_PseudoVSOXSEG2EI64_V_M4_MF2_MASK = 8592, + RISCV_PseudoVSOXSEG2EI64_V_M8_M1 = 8593, + RISCV_PseudoVSOXSEG2EI64_V_M8_M1_MASK = 8594, + RISCV_PseudoVSOXSEG2EI64_V_M8_M2 = 8595, + RISCV_PseudoVSOXSEG2EI64_V_M8_M2_MASK = 8596, + RISCV_PseudoVSOXSEG2EI64_V_M8_M4 = 8597, + RISCV_PseudoVSOXSEG2EI64_V_M8_M4_MASK = 8598, + RISCV_PseudoVSOXSEG2EI8_V_M1_M1 = 8599, + RISCV_PseudoVSOXSEG2EI8_V_M1_M1_MASK = 8600, + RISCV_PseudoVSOXSEG2EI8_V_M1_M2 = 8601, + RISCV_PseudoVSOXSEG2EI8_V_M1_M2_MASK = 8602, + RISCV_PseudoVSOXSEG2EI8_V_M1_M4 = 8603, + RISCV_PseudoVSOXSEG2EI8_V_M1_M4_MASK = 8604, + RISCV_PseudoVSOXSEG2EI8_V_M2_M2 = 8605, + RISCV_PseudoVSOXSEG2EI8_V_M2_M2_MASK = 8606, + RISCV_PseudoVSOXSEG2EI8_V_M2_M4 = 8607, + RISCV_PseudoVSOXSEG2EI8_V_M2_M4_MASK = 8608, + RISCV_PseudoVSOXSEG2EI8_V_M4_M4 = 8609, + RISCV_PseudoVSOXSEG2EI8_V_M4_M4_MASK = 8610, + RISCV_PseudoVSOXSEG2EI8_V_MF2_M1 = 8611, + RISCV_PseudoVSOXSEG2EI8_V_MF2_M1_MASK = 8612, + RISCV_PseudoVSOXSEG2EI8_V_MF2_M2 = 8613, + RISCV_PseudoVSOXSEG2EI8_V_MF2_M2_MASK = 8614, + RISCV_PseudoVSOXSEG2EI8_V_MF2_M4 = 8615, + RISCV_PseudoVSOXSEG2EI8_V_MF2_M4_MASK = 8616, + RISCV_PseudoVSOXSEG2EI8_V_MF2_MF2 = 8617, + RISCV_PseudoVSOXSEG2EI8_V_MF2_MF2_MASK = 8618, + RISCV_PseudoVSOXSEG2EI8_V_MF4_M1 = 8619, + RISCV_PseudoVSOXSEG2EI8_V_MF4_M1_MASK = 8620, + RISCV_PseudoVSOXSEG2EI8_V_MF4_M2 = 8621, + RISCV_PseudoVSOXSEG2EI8_V_MF4_M2_MASK = 8622, + RISCV_PseudoVSOXSEG2EI8_V_MF4_MF2 = 8623, + RISCV_PseudoVSOXSEG2EI8_V_MF4_MF2_MASK = 8624, + RISCV_PseudoVSOXSEG2EI8_V_MF4_MF4 = 8625, + RISCV_PseudoVSOXSEG2EI8_V_MF4_MF4_MASK = 8626, + RISCV_PseudoVSOXSEG2EI8_V_MF8_M1 = 8627, + RISCV_PseudoVSOXSEG2EI8_V_MF8_M1_MASK = 8628, + RISCV_PseudoVSOXSEG2EI8_V_MF8_MF2 = 8629, + RISCV_PseudoVSOXSEG2EI8_V_MF8_MF2_MASK = 8630, + RISCV_PseudoVSOXSEG2EI8_V_MF8_MF4 = 8631, + RISCV_PseudoVSOXSEG2EI8_V_MF8_MF4_MASK = 8632, + RISCV_PseudoVSOXSEG2EI8_V_MF8_MF8 = 8633, + RISCV_PseudoVSOXSEG2EI8_V_MF8_MF8_MASK = 8634, + RISCV_PseudoVSOXSEG3EI16_V_M1_M1 = 8635, + RISCV_PseudoVSOXSEG3EI16_V_M1_M1_MASK = 8636, + RISCV_PseudoVSOXSEG3EI16_V_M1_M2 = 8637, + RISCV_PseudoVSOXSEG3EI16_V_M1_M2_MASK = 8638, + RISCV_PseudoVSOXSEG3EI16_V_M1_MF2 = 8639, + RISCV_PseudoVSOXSEG3EI16_V_M1_MF2_MASK = 8640, + RISCV_PseudoVSOXSEG3EI16_V_M2_M1 = 8641, + RISCV_PseudoVSOXSEG3EI16_V_M2_M1_MASK = 8642, + RISCV_PseudoVSOXSEG3EI16_V_M2_M2 = 8643, + RISCV_PseudoVSOXSEG3EI16_V_M2_M2_MASK = 8644, + RISCV_PseudoVSOXSEG3EI16_V_M4_M2 = 8645, + RISCV_PseudoVSOXSEG3EI16_V_M4_M2_MASK = 8646, + RISCV_PseudoVSOXSEG3EI16_V_MF2_M1 = 8647, + RISCV_PseudoVSOXSEG3EI16_V_MF2_M1_MASK = 8648, + RISCV_PseudoVSOXSEG3EI16_V_MF2_M2 = 8649, + RISCV_PseudoVSOXSEG3EI16_V_MF2_M2_MASK = 8650, + RISCV_PseudoVSOXSEG3EI16_V_MF2_MF2 = 8651, + RISCV_PseudoVSOXSEG3EI16_V_MF2_MF2_MASK = 8652, + RISCV_PseudoVSOXSEG3EI16_V_MF2_MF4 = 8653, + RISCV_PseudoVSOXSEG3EI16_V_MF2_MF4_MASK = 8654, + RISCV_PseudoVSOXSEG3EI16_V_MF4_M1 = 8655, + RISCV_PseudoVSOXSEG3EI16_V_MF4_M1_MASK = 8656, + RISCV_PseudoVSOXSEG3EI16_V_MF4_MF2 = 8657, + RISCV_PseudoVSOXSEG3EI16_V_MF4_MF2_MASK = 8658, + RISCV_PseudoVSOXSEG3EI16_V_MF4_MF4 = 8659, + RISCV_PseudoVSOXSEG3EI16_V_MF4_MF4_MASK = 8660, + RISCV_PseudoVSOXSEG3EI16_V_MF4_MF8 = 8661, + RISCV_PseudoVSOXSEG3EI16_V_MF4_MF8_MASK = 8662, + RISCV_PseudoVSOXSEG3EI32_V_M1_M1 = 8663, + RISCV_PseudoVSOXSEG3EI32_V_M1_M1_MASK = 8664, + RISCV_PseudoVSOXSEG3EI32_V_M1_M2 = 8665, + RISCV_PseudoVSOXSEG3EI32_V_M1_M2_MASK = 8666, + RISCV_PseudoVSOXSEG3EI32_V_M1_MF2 = 8667, + RISCV_PseudoVSOXSEG3EI32_V_M1_MF2_MASK = 8668, + RISCV_PseudoVSOXSEG3EI32_V_M1_MF4 = 8669, + RISCV_PseudoVSOXSEG3EI32_V_M1_MF4_MASK = 8670, + RISCV_PseudoVSOXSEG3EI32_V_M2_M1 = 8671, + RISCV_PseudoVSOXSEG3EI32_V_M2_M1_MASK = 8672, + RISCV_PseudoVSOXSEG3EI32_V_M2_M2 = 8673, + RISCV_PseudoVSOXSEG3EI32_V_M2_M2_MASK = 8674, + RISCV_PseudoVSOXSEG3EI32_V_M2_MF2 = 8675, + RISCV_PseudoVSOXSEG3EI32_V_M2_MF2_MASK = 8676, + RISCV_PseudoVSOXSEG3EI32_V_M4_M1 = 8677, + RISCV_PseudoVSOXSEG3EI32_V_M4_M1_MASK = 8678, + RISCV_PseudoVSOXSEG3EI32_V_M4_M2 = 8679, + RISCV_PseudoVSOXSEG3EI32_V_M4_M2_MASK = 8680, + RISCV_PseudoVSOXSEG3EI32_V_M8_M2 = 8681, + RISCV_PseudoVSOXSEG3EI32_V_M8_M2_MASK = 8682, + RISCV_PseudoVSOXSEG3EI32_V_MF2_M1 = 8683, + RISCV_PseudoVSOXSEG3EI32_V_MF2_M1_MASK = 8684, + RISCV_PseudoVSOXSEG3EI32_V_MF2_MF2 = 8685, + RISCV_PseudoVSOXSEG3EI32_V_MF2_MF2_MASK = 8686, + RISCV_PseudoVSOXSEG3EI32_V_MF2_MF4 = 8687, + RISCV_PseudoVSOXSEG3EI32_V_MF2_MF4_MASK = 8688, + RISCV_PseudoVSOXSEG3EI32_V_MF2_MF8 = 8689, + RISCV_PseudoVSOXSEG3EI32_V_MF2_MF8_MASK = 8690, + RISCV_PseudoVSOXSEG3EI64_V_M1_M1 = 8691, + RISCV_PseudoVSOXSEG3EI64_V_M1_M1_MASK = 8692, + RISCV_PseudoVSOXSEG3EI64_V_M1_MF2 = 8693, + RISCV_PseudoVSOXSEG3EI64_V_M1_MF2_MASK = 8694, + RISCV_PseudoVSOXSEG3EI64_V_M1_MF4 = 8695, + RISCV_PseudoVSOXSEG3EI64_V_M1_MF4_MASK = 8696, + RISCV_PseudoVSOXSEG3EI64_V_M1_MF8 = 8697, + RISCV_PseudoVSOXSEG3EI64_V_M1_MF8_MASK = 8698, + RISCV_PseudoVSOXSEG3EI64_V_M2_M1 = 8699, + RISCV_PseudoVSOXSEG3EI64_V_M2_M1_MASK = 8700, + RISCV_PseudoVSOXSEG3EI64_V_M2_M2 = 8701, + RISCV_PseudoVSOXSEG3EI64_V_M2_M2_MASK = 8702, + RISCV_PseudoVSOXSEG3EI64_V_M2_MF2 = 8703, + RISCV_PseudoVSOXSEG3EI64_V_M2_MF2_MASK = 8704, + RISCV_PseudoVSOXSEG3EI64_V_M2_MF4 = 8705, + RISCV_PseudoVSOXSEG3EI64_V_M2_MF4_MASK = 8706, + RISCV_PseudoVSOXSEG3EI64_V_M4_M1 = 8707, + RISCV_PseudoVSOXSEG3EI64_V_M4_M1_MASK = 8708, + RISCV_PseudoVSOXSEG3EI64_V_M4_M2 = 8709, + RISCV_PseudoVSOXSEG3EI64_V_M4_M2_MASK = 8710, + RISCV_PseudoVSOXSEG3EI64_V_M4_MF2 = 8711, + RISCV_PseudoVSOXSEG3EI64_V_M4_MF2_MASK = 8712, + RISCV_PseudoVSOXSEG3EI64_V_M8_M1 = 8713, + RISCV_PseudoVSOXSEG3EI64_V_M8_M1_MASK = 8714, + RISCV_PseudoVSOXSEG3EI64_V_M8_M2 = 8715, + RISCV_PseudoVSOXSEG3EI64_V_M8_M2_MASK = 8716, + RISCV_PseudoVSOXSEG3EI8_V_M1_M1 = 8717, + RISCV_PseudoVSOXSEG3EI8_V_M1_M1_MASK = 8718, + RISCV_PseudoVSOXSEG3EI8_V_M1_M2 = 8719, + RISCV_PseudoVSOXSEG3EI8_V_M1_M2_MASK = 8720, + RISCV_PseudoVSOXSEG3EI8_V_M2_M2 = 8721, + RISCV_PseudoVSOXSEG3EI8_V_M2_M2_MASK = 8722, + RISCV_PseudoVSOXSEG3EI8_V_MF2_M1 = 8723, + RISCV_PseudoVSOXSEG3EI8_V_MF2_M1_MASK = 8724, + RISCV_PseudoVSOXSEG3EI8_V_MF2_M2 = 8725, + RISCV_PseudoVSOXSEG3EI8_V_MF2_M2_MASK = 8726, + RISCV_PseudoVSOXSEG3EI8_V_MF2_MF2 = 8727, + RISCV_PseudoVSOXSEG3EI8_V_MF2_MF2_MASK = 8728, + RISCV_PseudoVSOXSEG3EI8_V_MF4_M1 = 8729, + RISCV_PseudoVSOXSEG3EI8_V_MF4_M1_MASK = 8730, + RISCV_PseudoVSOXSEG3EI8_V_MF4_M2 = 8731, + RISCV_PseudoVSOXSEG3EI8_V_MF4_M2_MASK = 8732, + RISCV_PseudoVSOXSEG3EI8_V_MF4_MF2 = 8733, + RISCV_PseudoVSOXSEG3EI8_V_MF4_MF2_MASK = 8734, + RISCV_PseudoVSOXSEG3EI8_V_MF4_MF4 = 8735, + RISCV_PseudoVSOXSEG3EI8_V_MF4_MF4_MASK = 8736, + RISCV_PseudoVSOXSEG3EI8_V_MF8_M1 = 8737, + RISCV_PseudoVSOXSEG3EI8_V_MF8_M1_MASK = 8738, + RISCV_PseudoVSOXSEG3EI8_V_MF8_MF2 = 8739, + RISCV_PseudoVSOXSEG3EI8_V_MF8_MF2_MASK = 8740, + RISCV_PseudoVSOXSEG3EI8_V_MF8_MF4 = 8741, + RISCV_PseudoVSOXSEG3EI8_V_MF8_MF4_MASK = 8742, + RISCV_PseudoVSOXSEG3EI8_V_MF8_MF8 = 8743, + RISCV_PseudoVSOXSEG3EI8_V_MF8_MF8_MASK = 8744, + RISCV_PseudoVSOXSEG4EI16_V_M1_M1 = 8745, + RISCV_PseudoVSOXSEG4EI16_V_M1_M1_MASK = 8746, + RISCV_PseudoVSOXSEG4EI16_V_M1_M2 = 8747, + RISCV_PseudoVSOXSEG4EI16_V_M1_M2_MASK = 8748, + RISCV_PseudoVSOXSEG4EI16_V_M1_MF2 = 8749, + RISCV_PseudoVSOXSEG4EI16_V_M1_MF2_MASK = 8750, + RISCV_PseudoVSOXSEG4EI16_V_M2_M1 = 8751, + RISCV_PseudoVSOXSEG4EI16_V_M2_M1_MASK = 8752, + RISCV_PseudoVSOXSEG4EI16_V_M2_M2 = 8753, + RISCV_PseudoVSOXSEG4EI16_V_M2_M2_MASK = 8754, + RISCV_PseudoVSOXSEG4EI16_V_M4_M2 = 8755, + RISCV_PseudoVSOXSEG4EI16_V_M4_M2_MASK = 8756, + RISCV_PseudoVSOXSEG4EI16_V_MF2_M1 = 8757, + RISCV_PseudoVSOXSEG4EI16_V_MF2_M1_MASK = 8758, + RISCV_PseudoVSOXSEG4EI16_V_MF2_M2 = 8759, + RISCV_PseudoVSOXSEG4EI16_V_MF2_M2_MASK = 8760, + RISCV_PseudoVSOXSEG4EI16_V_MF2_MF2 = 8761, + RISCV_PseudoVSOXSEG4EI16_V_MF2_MF2_MASK = 8762, + RISCV_PseudoVSOXSEG4EI16_V_MF2_MF4 = 8763, + RISCV_PseudoVSOXSEG4EI16_V_MF2_MF4_MASK = 8764, + RISCV_PseudoVSOXSEG4EI16_V_MF4_M1 = 8765, + RISCV_PseudoVSOXSEG4EI16_V_MF4_M1_MASK = 8766, + RISCV_PseudoVSOXSEG4EI16_V_MF4_MF2 = 8767, + RISCV_PseudoVSOXSEG4EI16_V_MF4_MF2_MASK = 8768, + RISCV_PseudoVSOXSEG4EI16_V_MF4_MF4 = 8769, + RISCV_PseudoVSOXSEG4EI16_V_MF4_MF4_MASK = 8770, + RISCV_PseudoVSOXSEG4EI16_V_MF4_MF8 = 8771, + RISCV_PseudoVSOXSEG4EI16_V_MF4_MF8_MASK = 8772, + RISCV_PseudoVSOXSEG4EI32_V_M1_M1 = 8773, + RISCV_PseudoVSOXSEG4EI32_V_M1_M1_MASK = 8774, + RISCV_PseudoVSOXSEG4EI32_V_M1_M2 = 8775, + RISCV_PseudoVSOXSEG4EI32_V_M1_M2_MASK = 8776, + RISCV_PseudoVSOXSEG4EI32_V_M1_MF2 = 8777, + RISCV_PseudoVSOXSEG4EI32_V_M1_MF2_MASK = 8778, + RISCV_PseudoVSOXSEG4EI32_V_M1_MF4 = 8779, + RISCV_PseudoVSOXSEG4EI32_V_M1_MF4_MASK = 8780, + RISCV_PseudoVSOXSEG4EI32_V_M2_M1 = 8781, + RISCV_PseudoVSOXSEG4EI32_V_M2_M1_MASK = 8782, + RISCV_PseudoVSOXSEG4EI32_V_M2_M2 = 8783, + RISCV_PseudoVSOXSEG4EI32_V_M2_M2_MASK = 8784, + RISCV_PseudoVSOXSEG4EI32_V_M2_MF2 = 8785, + RISCV_PseudoVSOXSEG4EI32_V_M2_MF2_MASK = 8786, + RISCV_PseudoVSOXSEG4EI32_V_M4_M1 = 8787, + RISCV_PseudoVSOXSEG4EI32_V_M4_M1_MASK = 8788, + RISCV_PseudoVSOXSEG4EI32_V_M4_M2 = 8789, + RISCV_PseudoVSOXSEG4EI32_V_M4_M2_MASK = 8790, + RISCV_PseudoVSOXSEG4EI32_V_M8_M2 = 8791, + RISCV_PseudoVSOXSEG4EI32_V_M8_M2_MASK = 8792, + RISCV_PseudoVSOXSEG4EI32_V_MF2_M1 = 8793, + RISCV_PseudoVSOXSEG4EI32_V_MF2_M1_MASK = 8794, + RISCV_PseudoVSOXSEG4EI32_V_MF2_MF2 = 8795, + RISCV_PseudoVSOXSEG4EI32_V_MF2_MF2_MASK = 8796, + RISCV_PseudoVSOXSEG4EI32_V_MF2_MF4 = 8797, + RISCV_PseudoVSOXSEG4EI32_V_MF2_MF4_MASK = 8798, + RISCV_PseudoVSOXSEG4EI32_V_MF2_MF8 = 8799, + RISCV_PseudoVSOXSEG4EI32_V_MF2_MF8_MASK = 8800, + RISCV_PseudoVSOXSEG4EI64_V_M1_M1 = 8801, + RISCV_PseudoVSOXSEG4EI64_V_M1_M1_MASK = 8802, + RISCV_PseudoVSOXSEG4EI64_V_M1_MF2 = 8803, + RISCV_PseudoVSOXSEG4EI64_V_M1_MF2_MASK = 8804, + RISCV_PseudoVSOXSEG4EI64_V_M1_MF4 = 8805, + RISCV_PseudoVSOXSEG4EI64_V_M1_MF4_MASK = 8806, + RISCV_PseudoVSOXSEG4EI64_V_M1_MF8 = 8807, + RISCV_PseudoVSOXSEG4EI64_V_M1_MF8_MASK = 8808, + RISCV_PseudoVSOXSEG4EI64_V_M2_M1 = 8809, + RISCV_PseudoVSOXSEG4EI64_V_M2_M1_MASK = 8810, + RISCV_PseudoVSOXSEG4EI64_V_M2_M2 = 8811, + RISCV_PseudoVSOXSEG4EI64_V_M2_M2_MASK = 8812, + RISCV_PseudoVSOXSEG4EI64_V_M2_MF2 = 8813, + RISCV_PseudoVSOXSEG4EI64_V_M2_MF2_MASK = 8814, + RISCV_PseudoVSOXSEG4EI64_V_M2_MF4 = 8815, + RISCV_PseudoVSOXSEG4EI64_V_M2_MF4_MASK = 8816, + RISCV_PseudoVSOXSEG4EI64_V_M4_M1 = 8817, + RISCV_PseudoVSOXSEG4EI64_V_M4_M1_MASK = 8818, + RISCV_PseudoVSOXSEG4EI64_V_M4_M2 = 8819, + RISCV_PseudoVSOXSEG4EI64_V_M4_M2_MASK = 8820, + RISCV_PseudoVSOXSEG4EI64_V_M4_MF2 = 8821, + RISCV_PseudoVSOXSEG4EI64_V_M4_MF2_MASK = 8822, + RISCV_PseudoVSOXSEG4EI64_V_M8_M1 = 8823, + RISCV_PseudoVSOXSEG4EI64_V_M8_M1_MASK = 8824, + RISCV_PseudoVSOXSEG4EI64_V_M8_M2 = 8825, + RISCV_PseudoVSOXSEG4EI64_V_M8_M2_MASK = 8826, + RISCV_PseudoVSOXSEG4EI8_V_M1_M1 = 8827, + RISCV_PseudoVSOXSEG4EI8_V_M1_M1_MASK = 8828, + RISCV_PseudoVSOXSEG4EI8_V_M1_M2 = 8829, + RISCV_PseudoVSOXSEG4EI8_V_M1_M2_MASK = 8830, + RISCV_PseudoVSOXSEG4EI8_V_M2_M2 = 8831, + RISCV_PseudoVSOXSEG4EI8_V_M2_M2_MASK = 8832, + RISCV_PseudoVSOXSEG4EI8_V_MF2_M1 = 8833, + RISCV_PseudoVSOXSEG4EI8_V_MF2_M1_MASK = 8834, + RISCV_PseudoVSOXSEG4EI8_V_MF2_M2 = 8835, + RISCV_PseudoVSOXSEG4EI8_V_MF2_M2_MASK = 8836, + RISCV_PseudoVSOXSEG4EI8_V_MF2_MF2 = 8837, + RISCV_PseudoVSOXSEG4EI8_V_MF2_MF2_MASK = 8838, + RISCV_PseudoVSOXSEG4EI8_V_MF4_M1 = 8839, + RISCV_PseudoVSOXSEG4EI8_V_MF4_M1_MASK = 8840, + RISCV_PseudoVSOXSEG4EI8_V_MF4_M2 = 8841, + RISCV_PseudoVSOXSEG4EI8_V_MF4_M2_MASK = 8842, + RISCV_PseudoVSOXSEG4EI8_V_MF4_MF2 = 8843, + RISCV_PseudoVSOXSEG4EI8_V_MF4_MF2_MASK = 8844, + RISCV_PseudoVSOXSEG4EI8_V_MF4_MF4 = 8845, + RISCV_PseudoVSOXSEG4EI8_V_MF4_MF4_MASK = 8846, + RISCV_PseudoVSOXSEG4EI8_V_MF8_M1 = 8847, + RISCV_PseudoVSOXSEG4EI8_V_MF8_M1_MASK = 8848, + RISCV_PseudoVSOXSEG4EI8_V_MF8_MF2 = 8849, + RISCV_PseudoVSOXSEG4EI8_V_MF8_MF2_MASK = 8850, + RISCV_PseudoVSOXSEG4EI8_V_MF8_MF4 = 8851, + RISCV_PseudoVSOXSEG4EI8_V_MF8_MF4_MASK = 8852, + RISCV_PseudoVSOXSEG4EI8_V_MF8_MF8 = 8853, + RISCV_PseudoVSOXSEG4EI8_V_MF8_MF8_MASK = 8854, + RISCV_PseudoVSOXSEG5EI16_V_M1_M1 = 8855, + RISCV_PseudoVSOXSEG5EI16_V_M1_M1_MASK = 8856, + RISCV_PseudoVSOXSEG5EI16_V_M1_MF2 = 8857, + RISCV_PseudoVSOXSEG5EI16_V_M1_MF2_MASK = 8858, + RISCV_PseudoVSOXSEG5EI16_V_M2_M1 = 8859, + RISCV_PseudoVSOXSEG5EI16_V_M2_M1_MASK = 8860, + RISCV_PseudoVSOXSEG5EI16_V_MF2_M1 = 8861, + RISCV_PseudoVSOXSEG5EI16_V_MF2_M1_MASK = 8862, + RISCV_PseudoVSOXSEG5EI16_V_MF2_MF2 = 8863, + RISCV_PseudoVSOXSEG5EI16_V_MF2_MF2_MASK = 8864, + RISCV_PseudoVSOXSEG5EI16_V_MF2_MF4 = 8865, + RISCV_PseudoVSOXSEG5EI16_V_MF2_MF4_MASK = 8866, + RISCV_PseudoVSOXSEG5EI16_V_MF4_M1 = 8867, + RISCV_PseudoVSOXSEG5EI16_V_MF4_M1_MASK = 8868, + RISCV_PseudoVSOXSEG5EI16_V_MF4_MF2 = 8869, + RISCV_PseudoVSOXSEG5EI16_V_MF4_MF2_MASK = 8870, + RISCV_PseudoVSOXSEG5EI16_V_MF4_MF4 = 8871, + RISCV_PseudoVSOXSEG5EI16_V_MF4_MF4_MASK = 8872, + RISCV_PseudoVSOXSEG5EI16_V_MF4_MF8 = 8873, + RISCV_PseudoVSOXSEG5EI16_V_MF4_MF8_MASK = 8874, + RISCV_PseudoVSOXSEG5EI32_V_M1_M1 = 8875, + RISCV_PseudoVSOXSEG5EI32_V_M1_M1_MASK = 8876, + RISCV_PseudoVSOXSEG5EI32_V_M1_MF2 = 8877, + RISCV_PseudoVSOXSEG5EI32_V_M1_MF2_MASK = 8878, + RISCV_PseudoVSOXSEG5EI32_V_M1_MF4 = 8879, + RISCV_PseudoVSOXSEG5EI32_V_M1_MF4_MASK = 8880, + RISCV_PseudoVSOXSEG5EI32_V_M2_M1 = 8881, + RISCV_PseudoVSOXSEG5EI32_V_M2_M1_MASK = 8882, + RISCV_PseudoVSOXSEG5EI32_V_M2_MF2 = 8883, + RISCV_PseudoVSOXSEG5EI32_V_M2_MF2_MASK = 8884, + RISCV_PseudoVSOXSEG5EI32_V_M4_M1 = 8885, + RISCV_PseudoVSOXSEG5EI32_V_M4_M1_MASK = 8886, + RISCV_PseudoVSOXSEG5EI32_V_MF2_M1 = 8887, + RISCV_PseudoVSOXSEG5EI32_V_MF2_M1_MASK = 8888, + RISCV_PseudoVSOXSEG5EI32_V_MF2_MF2 = 8889, + RISCV_PseudoVSOXSEG5EI32_V_MF2_MF2_MASK = 8890, + RISCV_PseudoVSOXSEG5EI32_V_MF2_MF4 = 8891, + RISCV_PseudoVSOXSEG5EI32_V_MF2_MF4_MASK = 8892, + RISCV_PseudoVSOXSEG5EI32_V_MF2_MF8 = 8893, + RISCV_PseudoVSOXSEG5EI32_V_MF2_MF8_MASK = 8894, + RISCV_PseudoVSOXSEG5EI64_V_M1_M1 = 8895, + RISCV_PseudoVSOXSEG5EI64_V_M1_M1_MASK = 8896, + RISCV_PseudoVSOXSEG5EI64_V_M1_MF2 = 8897, + RISCV_PseudoVSOXSEG5EI64_V_M1_MF2_MASK = 8898, + RISCV_PseudoVSOXSEG5EI64_V_M1_MF4 = 8899, + RISCV_PseudoVSOXSEG5EI64_V_M1_MF4_MASK = 8900, + RISCV_PseudoVSOXSEG5EI64_V_M1_MF8 = 8901, + RISCV_PseudoVSOXSEG5EI64_V_M1_MF8_MASK = 8902, + RISCV_PseudoVSOXSEG5EI64_V_M2_M1 = 8903, + RISCV_PseudoVSOXSEG5EI64_V_M2_M1_MASK = 8904, + RISCV_PseudoVSOXSEG5EI64_V_M2_MF2 = 8905, + RISCV_PseudoVSOXSEG5EI64_V_M2_MF2_MASK = 8906, + RISCV_PseudoVSOXSEG5EI64_V_M2_MF4 = 8907, + RISCV_PseudoVSOXSEG5EI64_V_M2_MF4_MASK = 8908, + RISCV_PseudoVSOXSEG5EI64_V_M4_M1 = 8909, + RISCV_PseudoVSOXSEG5EI64_V_M4_M1_MASK = 8910, + RISCV_PseudoVSOXSEG5EI64_V_M4_MF2 = 8911, + RISCV_PseudoVSOXSEG5EI64_V_M4_MF2_MASK = 8912, + RISCV_PseudoVSOXSEG5EI64_V_M8_M1 = 8913, + RISCV_PseudoVSOXSEG5EI64_V_M8_M1_MASK = 8914, + RISCV_PseudoVSOXSEG5EI8_V_M1_M1 = 8915, + RISCV_PseudoVSOXSEG5EI8_V_M1_M1_MASK = 8916, + RISCV_PseudoVSOXSEG5EI8_V_MF2_M1 = 8917, + RISCV_PseudoVSOXSEG5EI8_V_MF2_M1_MASK = 8918, + RISCV_PseudoVSOXSEG5EI8_V_MF2_MF2 = 8919, + RISCV_PseudoVSOXSEG5EI8_V_MF2_MF2_MASK = 8920, + RISCV_PseudoVSOXSEG5EI8_V_MF4_M1 = 8921, + RISCV_PseudoVSOXSEG5EI8_V_MF4_M1_MASK = 8922, + RISCV_PseudoVSOXSEG5EI8_V_MF4_MF2 = 8923, + RISCV_PseudoVSOXSEG5EI8_V_MF4_MF2_MASK = 8924, + RISCV_PseudoVSOXSEG5EI8_V_MF4_MF4 = 8925, + RISCV_PseudoVSOXSEG5EI8_V_MF4_MF4_MASK = 8926, + RISCV_PseudoVSOXSEG5EI8_V_MF8_M1 = 8927, + RISCV_PseudoVSOXSEG5EI8_V_MF8_M1_MASK = 8928, + RISCV_PseudoVSOXSEG5EI8_V_MF8_MF2 = 8929, + RISCV_PseudoVSOXSEG5EI8_V_MF8_MF2_MASK = 8930, + RISCV_PseudoVSOXSEG5EI8_V_MF8_MF4 = 8931, + RISCV_PseudoVSOXSEG5EI8_V_MF8_MF4_MASK = 8932, + RISCV_PseudoVSOXSEG5EI8_V_MF8_MF8 = 8933, + RISCV_PseudoVSOXSEG5EI8_V_MF8_MF8_MASK = 8934, + RISCV_PseudoVSOXSEG6EI16_V_M1_M1 = 8935, + RISCV_PseudoVSOXSEG6EI16_V_M1_M1_MASK = 8936, + RISCV_PseudoVSOXSEG6EI16_V_M1_MF2 = 8937, + RISCV_PseudoVSOXSEG6EI16_V_M1_MF2_MASK = 8938, + RISCV_PseudoVSOXSEG6EI16_V_M2_M1 = 8939, + RISCV_PseudoVSOXSEG6EI16_V_M2_M1_MASK = 8940, + RISCV_PseudoVSOXSEG6EI16_V_MF2_M1 = 8941, + RISCV_PseudoVSOXSEG6EI16_V_MF2_M1_MASK = 8942, + RISCV_PseudoVSOXSEG6EI16_V_MF2_MF2 = 8943, + RISCV_PseudoVSOXSEG6EI16_V_MF2_MF2_MASK = 8944, + RISCV_PseudoVSOXSEG6EI16_V_MF2_MF4 = 8945, + RISCV_PseudoVSOXSEG6EI16_V_MF2_MF4_MASK = 8946, + RISCV_PseudoVSOXSEG6EI16_V_MF4_M1 = 8947, + RISCV_PseudoVSOXSEG6EI16_V_MF4_M1_MASK = 8948, + RISCV_PseudoVSOXSEG6EI16_V_MF4_MF2 = 8949, + RISCV_PseudoVSOXSEG6EI16_V_MF4_MF2_MASK = 8950, + RISCV_PseudoVSOXSEG6EI16_V_MF4_MF4 = 8951, + RISCV_PseudoVSOXSEG6EI16_V_MF4_MF4_MASK = 8952, + RISCV_PseudoVSOXSEG6EI16_V_MF4_MF8 = 8953, + RISCV_PseudoVSOXSEG6EI16_V_MF4_MF8_MASK = 8954, + RISCV_PseudoVSOXSEG6EI32_V_M1_M1 = 8955, + RISCV_PseudoVSOXSEG6EI32_V_M1_M1_MASK = 8956, + RISCV_PseudoVSOXSEG6EI32_V_M1_MF2 = 8957, + RISCV_PseudoVSOXSEG6EI32_V_M1_MF2_MASK = 8958, + RISCV_PseudoVSOXSEG6EI32_V_M1_MF4 = 8959, + RISCV_PseudoVSOXSEG6EI32_V_M1_MF4_MASK = 8960, + RISCV_PseudoVSOXSEG6EI32_V_M2_M1 = 8961, + RISCV_PseudoVSOXSEG6EI32_V_M2_M1_MASK = 8962, + RISCV_PseudoVSOXSEG6EI32_V_M2_MF2 = 8963, + RISCV_PseudoVSOXSEG6EI32_V_M2_MF2_MASK = 8964, + RISCV_PseudoVSOXSEG6EI32_V_M4_M1 = 8965, + RISCV_PseudoVSOXSEG6EI32_V_M4_M1_MASK = 8966, + RISCV_PseudoVSOXSEG6EI32_V_MF2_M1 = 8967, + RISCV_PseudoVSOXSEG6EI32_V_MF2_M1_MASK = 8968, + RISCV_PseudoVSOXSEG6EI32_V_MF2_MF2 = 8969, + RISCV_PseudoVSOXSEG6EI32_V_MF2_MF2_MASK = 8970, + RISCV_PseudoVSOXSEG6EI32_V_MF2_MF4 = 8971, + RISCV_PseudoVSOXSEG6EI32_V_MF2_MF4_MASK = 8972, + RISCV_PseudoVSOXSEG6EI32_V_MF2_MF8 = 8973, + RISCV_PseudoVSOXSEG6EI32_V_MF2_MF8_MASK = 8974, + RISCV_PseudoVSOXSEG6EI64_V_M1_M1 = 8975, + RISCV_PseudoVSOXSEG6EI64_V_M1_M1_MASK = 8976, + RISCV_PseudoVSOXSEG6EI64_V_M1_MF2 = 8977, + RISCV_PseudoVSOXSEG6EI64_V_M1_MF2_MASK = 8978, + RISCV_PseudoVSOXSEG6EI64_V_M1_MF4 = 8979, + RISCV_PseudoVSOXSEG6EI64_V_M1_MF4_MASK = 8980, + RISCV_PseudoVSOXSEG6EI64_V_M1_MF8 = 8981, + RISCV_PseudoVSOXSEG6EI64_V_M1_MF8_MASK = 8982, + RISCV_PseudoVSOXSEG6EI64_V_M2_M1 = 8983, + RISCV_PseudoVSOXSEG6EI64_V_M2_M1_MASK = 8984, + RISCV_PseudoVSOXSEG6EI64_V_M2_MF2 = 8985, + RISCV_PseudoVSOXSEG6EI64_V_M2_MF2_MASK = 8986, + RISCV_PseudoVSOXSEG6EI64_V_M2_MF4 = 8987, + RISCV_PseudoVSOXSEG6EI64_V_M2_MF4_MASK = 8988, + RISCV_PseudoVSOXSEG6EI64_V_M4_M1 = 8989, + RISCV_PseudoVSOXSEG6EI64_V_M4_M1_MASK = 8990, + RISCV_PseudoVSOXSEG6EI64_V_M4_MF2 = 8991, + RISCV_PseudoVSOXSEG6EI64_V_M4_MF2_MASK = 8992, + RISCV_PseudoVSOXSEG6EI64_V_M8_M1 = 8993, + RISCV_PseudoVSOXSEG6EI64_V_M8_M1_MASK = 8994, + RISCV_PseudoVSOXSEG6EI8_V_M1_M1 = 8995, + RISCV_PseudoVSOXSEG6EI8_V_M1_M1_MASK = 8996, + RISCV_PseudoVSOXSEG6EI8_V_MF2_M1 = 8997, + RISCV_PseudoVSOXSEG6EI8_V_MF2_M1_MASK = 8998, + RISCV_PseudoVSOXSEG6EI8_V_MF2_MF2 = 8999, + RISCV_PseudoVSOXSEG6EI8_V_MF2_MF2_MASK = 9000, + RISCV_PseudoVSOXSEG6EI8_V_MF4_M1 = 9001, + RISCV_PseudoVSOXSEG6EI8_V_MF4_M1_MASK = 9002, + RISCV_PseudoVSOXSEG6EI8_V_MF4_MF2 = 9003, + RISCV_PseudoVSOXSEG6EI8_V_MF4_MF2_MASK = 9004, + RISCV_PseudoVSOXSEG6EI8_V_MF4_MF4 = 9005, + RISCV_PseudoVSOXSEG6EI8_V_MF4_MF4_MASK = 9006, + RISCV_PseudoVSOXSEG6EI8_V_MF8_M1 = 9007, + RISCV_PseudoVSOXSEG6EI8_V_MF8_M1_MASK = 9008, + RISCV_PseudoVSOXSEG6EI8_V_MF8_MF2 = 9009, + RISCV_PseudoVSOXSEG6EI8_V_MF8_MF2_MASK = 9010, + RISCV_PseudoVSOXSEG6EI8_V_MF8_MF4 = 9011, + RISCV_PseudoVSOXSEG6EI8_V_MF8_MF4_MASK = 9012, + RISCV_PseudoVSOXSEG6EI8_V_MF8_MF8 = 9013, + RISCV_PseudoVSOXSEG6EI8_V_MF8_MF8_MASK = 9014, + RISCV_PseudoVSOXSEG7EI16_V_M1_M1 = 9015, + RISCV_PseudoVSOXSEG7EI16_V_M1_M1_MASK = 9016, + RISCV_PseudoVSOXSEG7EI16_V_M1_MF2 = 9017, + RISCV_PseudoVSOXSEG7EI16_V_M1_MF2_MASK = 9018, + RISCV_PseudoVSOXSEG7EI16_V_M2_M1 = 9019, + RISCV_PseudoVSOXSEG7EI16_V_M2_M1_MASK = 9020, + RISCV_PseudoVSOXSEG7EI16_V_MF2_M1 = 9021, + RISCV_PseudoVSOXSEG7EI16_V_MF2_M1_MASK = 9022, + RISCV_PseudoVSOXSEG7EI16_V_MF2_MF2 = 9023, + RISCV_PseudoVSOXSEG7EI16_V_MF2_MF2_MASK = 9024, + RISCV_PseudoVSOXSEG7EI16_V_MF2_MF4 = 9025, + RISCV_PseudoVSOXSEG7EI16_V_MF2_MF4_MASK = 9026, + RISCV_PseudoVSOXSEG7EI16_V_MF4_M1 = 9027, + RISCV_PseudoVSOXSEG7EI16_V_MF4_M1_MASK = 9028, + RISCV_PseudoVSOXSEG7EI16_V_MF4_MF2 = 9029, + RISCV_PseudoVSOXSEG7EI16_V_MF4_MF2_MASK = 9030, + RISCV_PseudoVSOXSEG7EI16_V_MF4_MF4 = 9031, + RISCV_PseudoVSOXSEG7EI16_V_MF4_MF4_MASK = 9032, + RISCV_PseudoVSOXSEG7EI16_V_MF4_MF8 = 9033, + RISCV_PseudoVSOXSEG7EI16_V_MF4_MF8_MASK = 9034, + RISCV_PseudoVSOXSEG7EI32_V_M1_M1 = 9035, + RISCV_PseudoVSOXSEG7EI32_V_M1_M1_MASK = 9036, + RISCV_PseudoVSOXSEG7EI32_V_M1_MF2 = 9037, + RISCV_PseudoVSOXSEG7EI32_V_M1_MF2_MASK = 9038, + RISCV_PseudoVSOXSEG7EI32_V_M1_MF4 = 9039, + RISCV_PseudoVSOXSEG7EI32_V_M1_MF4_MASK = 9040, + RISCV_PseudoVSOXSEG7EI32_V_M2_M1 = 9041, + RISCV_PseudoVSOXSEG7EI32_V_M2_M1_MASK = 9042, + RISCV_PseudoVSOXSEG7EI32_V_M2_MF2 = 9043, + RISCV_PseudoVSOXSEG7EI32_V_M2_MF2_MASK = 9044, + RISCV_PseudoVSOXSEG7EI32_V_M4_M1 = 9045, + RISCV_PseudoVSOXSEG7EI32_V_M4_M1_MASK = 9046, + RISCV_PseudoVSOXSEG7EI32_V_MF2_M1 = 9047, + RISCV_PseudoVSOXSEG7EI32_V_MF2_M1_MASK = 9048, + RISCV_PseudoVSOXSEG7EI32_V_MF2_MF2 = 9049, + RISCV_PseudoVSOXSEG7EI32_V_MF2_MF2_MASK = 9050, + RISCV_PseudoVSOXSEG7EI32_V_MF2_MF4 = 9051, + RISCV_PseudoVSOXSEG7EI32_V_MF2_MF4_MASK = 9052, + RISCV_PseudoVSOXSEG7EI32_V_MF2_MF8 = 9053, + RISCV_PseudoVSOXSEG7EI32_V_MF2_MF8_MASK = 9054, + RISCV_PseudoVSOXSEG7EI64_V_M1_M1 = 9055, + RISCV_PseudoVSOXSEG7EI64_V_M1_M1_MASK = 9056, + RISCV_PseudoVSOXSEG7EI64_V_M1_MF2 = 9057, + RISCV_PseudoVSOXSEG7EI64_V_M1_MF2_MASK = 9058, + RISCV_PseudoVSOXSEG7EI64_V_M1_MF4 = 9059, + RISCV_PseudoVSOXSEG7EI64_V_M1_MF4_MASK = 9060, + RISCV_PseudoVSOXSEG7EI64_V_M1_MF8 = 9061, + RISCV_PseudoVSOXSEG7EI64_V_M1_MF8_MASK = 9062, + RISCV_PseudoVSOXSEG7EI64_V_M2_M1 = 9063, + RISCV_PseudoVSOXSEG7EI64_V_M2_M1_MASK = 9064, + RISCV_PseudoVSOXSEG7EI64_V_M2_MF2 = 9065, + RISCV_PseudoVSOXSEG7EI64_V_M2_MF2_MASK = 9066, + RISCV_PseudoVSOXSEG7EI64_V_M2_MF4 = 9067, + RISCV_PseudoVSOXSEG7EI64_V_M2_MF4_MASK = 9068, + RISCV_PseudoVSOXSEG7EI64_V_M4_M1 = 9069, + RISCV_PseudoVSOXSEG7EI64_V_M4_M1_MASK = 9070, + RISCV_PseudoVSOXSEG7EI64_V_M4_MF2 = 9071, + RISCV_PseudoVSOXSEG7EI64_V_M4_MF2_MASK = 9072, + RISCV_PseudoVSOXSEG7EI64_V_M8_M1 = 9073, + RISCV_PseudoVSOXSEG7EI64_V_M8_M1_MASK = 9074, + RISCV_PseudoVSOXSEG7EI8_V_M1_M1 = 9075, + RISCV_PseudoVSOXSEG7EI8_V_M1_M1_MASK = 9076, + RISCV_PseudoVSOXSEG7EI8_V_MF2_M1 = 9077, + RISCV_PseudoVSOXSEG7EI8_V_MF2_M1_MASK = 9078, + RISCV_PseudoVSOXSEG7EI8_V_MF2_MF2 = 9079, + RISCV_PseudoVSOXSEG7EI8_V_MF2_MF2_MASK = 9080, + RISCV_PseudoVSOXSEG7EI8_V_MF4_M1 = 9081, + RISCV_PseudoVSOXSEG7EI8_V_MF4_M1_MASK = 9082, + RISCV_PseudoVSOXSEG7EI8_V_MF4_MF2 = 9083, + RISCV_PseudoVSOXSEG7EI8_V_MF4_MF2_MASK = 9084, + RISCV_PseudoVSOXSEG7EI8_V_MF4_MF4 = 9085, + RISCV_PseudoVSOXSEG7EI8_V_MF4_MF4_MASK = 9086, + RISCV_PseudoVSOXSEG7EI8_V_MF8_M1 = 9087, + RISCV_PseudoVSOXSEG7EI8_V_MF8_M1_MASK = 9088, + RISCV_PseudoVSOXSEG7EI8_V_MF8_MF2 = 9089, + RISCV_PseudoVSOXSEG7EI8_V_MF8_MF2_MASK = 9090, + RISCV_PseudoVSOXSEG7EI8_V_MF8_MF4 = 9091, + RISCV_PseudoVSOXSEG7EI8_V_MF8_MF4_MASK = 9092, + RISCV_PseudoVSOXSEG7EI8_V_MF8_MF8 = 9093, + RISCV_PseudoVSOXSEG7EI8_V_MF8_MF8_MASK = 9094, + RISCV_PseudoVSOXSEG8EI16_V_M1_M1 = 9095, + RISCV_PseudoVSOXSEG8EI16_V_M1_M1_MASK = 9096, + RISCV_PseudoVSOXSEG8EI16_V_M1_MF2 = 9097, + RISCV_PseudoVSOXSEG8EI16_V_M1_MF2_MASK = 9098, + RISCV_PseudoVSOXSEG8EI16_V_M2_M1 = 9099, + RISCV_PseudoVSOXSEG8EI16_V_M2_M1_MASK = 9100, + RISCV_PseudoVSOXSEG8EI16_V_MF2_M1 = 9101, + RISCV_PseudoVSOXSEG8EI16_V_MF2_M1_MASK = 9102, + RISCV_PseudoVSOXSEG8EI16_V_MF2_MF2 = 9103, + RISCV_PseudoVSOXSEG8EI16_V_MF2_MF2_MASK = 9104, + RISCV_PseudoVSOXSEG8EI16_V_MF2_MF4 = 9105, + RISCV_PseudoVSOXSEG8EI16_V_MF2_MF4_MASK = 9106, + RISCV_PseudoVSOXSEG8EI16_V_MF4_M1 = 9107, + RISCV_PseudoVSOXSEG8EI16_V_MF4_M1_MASK = 9108, + RISCV_PseudoVSOXSEG8EI16_V_MF4_MF2 = 9109, + RISCV_PseudoVSOXSEG8EI16_V_MF4_MF2_MASK = 9110, + RISCV_PseudoVSOXSEG8EI16_V_MF4_MF4 = 9111, + RISCV_PseudoVSOXSEG8EI16_V_MF4_MF4_MASK = 9112, + RISCV_PseudoVSOXSEG8EI16_V_MF4_MF8 = 9113, + RISCV_PseudoVSOXSEG8EI16_V_MF4_MF8_MASK = 9114, + RISCV_PseudoVSOXSEG8EI32_V_M1_M1 = 9115, + RISCV_PseudoVSOXSEG8EI32_V_M1_M1_MASK = 9116, + RISCV_PseudoVSOXSEG8EI32_V_M1_MF2 = 9117, + RISCV_PseudoVSOXSEG8EI32_V_M1_MF2_MASK = 9118, + RISCV_PseudoVSOXSEG8EI32_V_M1_MF4 = 9119, + RISCV_PseudoVSOXSEG8EI32_V_M1_MF4_MASK = 9120, + RISCV_PseudoVSOXSEG8EI32_V_M2_M1 = 9121, + RISCV_PseudoVSOXSEG8EI32_V_M2_M1_MASK = 9122, + RISCV_PseudoVSOXSEG8EI32_V_M2_MF2 = 9123, + RISCV_PseudoVSOXSEG8EI32_V_M2_MF2_MASK = 9124, + RISCV_PseudoVSOXSEG8EI32_V_M4_M1 = 9125, + RISCV_PseudoVSOXSEG8EI32_V_M4_M1_MASK = 9126, + RISCV_PseudoVSOXSEG8EI32_V_MF2_M1 = 9127, + RISCV_PseudoVSOXSEG8EI32_V_MF2_M1_MASK = 9128, + RISCV_PseudoVSOXSEG8EI32_V_MF2_MF2 = 9129, + RISCV_PseudoVSOXSEG8EI32_V_MF2_MF2_MASK = 9130, + RISCV_PseudoVSOXSEG8EI32_V_MF2_MF4 = 9131, + RISCV_PseudoVSOXSEG8EI32_V_MF2_MF4_MASK = 9132, + RISCV_PseudoVSOXSEG8EI32_V_MF2_MF8 = 9133, + RISCV_PseudoVSOXSEG8EI32_V_MF2_MF8_MASK = 9134, + RISCV_PseudoVSOXSEG8EI64_V_M1_M1 = 9135, + RISCV_PseudoVSOXSEG8EI64_V_M1_M1_MASK = 9136, + RISCV_PseudoVSOXSEG8EI64_V_M1_MF2 = 9137, + RISCV_PseudoVSOXSEG8EI64_V_M1_MF2_MASK = 9138, + RISCV_PseudoVSOXSEG8EI64_V_M1_MF4 = 9139, + RISCV_PseudoVSOXSEG8EI64_V_M1_MF4_MASK = 9140, + RISCV_PseudoVSOXSEG8EI64_V_M1_MF8 = 9141, + RISCV_PseudoVSOXSEG8EI64_V_M1_MF8_MASK = 9142, + RISCV_PseudoVSOXSEG8EI64_V_M2_M1 = 9143, + RISCV_PseudoVSOXSEG8EI64_V_M2_M1_MASK = 9144, + RISCV_PseudoVSOXSEG8EI64_V_M2_MF2 = 9145, + RISCV_PseudoVSOXSEG8EI64_V_M2_MF2_MASK = 9146, + RISCV_PseudoVSOXSEG8EI64_V_M2_MF4 = 9147, + RISCV_PseudoVSOXSEG8EI64_V_M2_MF4_MASK = 9148, + RISCV_PseudoVSOXSEG8EI64_V_M4_M1 = 9149, + RISCV_PseudoVSOXSEG8EI64_V_M4_M1_MASK = 9150, + RISCV_PseudoVSOXSEG8EI64_V_M4_MF2 = 9151, + RISCV_PseudoVSOXSEG8EI64_V_M4_MF2_MASK = 9152, + RISCV_PseudoVSOXSEG8EI64_V_M8_M1 = 9153, + RISCV_PseudoVSOXSEG8EI64_V_M8_M1_MASK = 9154, + RISCV_PseudoVSOXSEG8EI8_V_M1_M1 = 9155, + RISCV_PseudoVSOXSEG8EI8_V_M1_M1_MASK = 9156, + RISCV_PseudoVSOXSEG8EI8_V_MF2_M1 = 9157, + RISCV_PseudoVSOXSEG8EI8_V_MF2_M1_MASK = 9158, + RISCV_PseudoVSOXSEG8EI8_V_MF2_MF2 = 9159, + RISCV_PseudoVSOXSEG8EI8_V_MF2_MF2_MASK = 9160, + RISCV_PseudoVSOXSEG8EI8_V_MF4_M1 = 9161, + RISCV_PseudoVSOXSEG8EI8_V_MF4_M1_MASK = 9162, + RISCV_PseudoVSOXSEG8EI8_V_MF4_MF2 = 9163, + RISCV_PseudoVSOXSEG8EI8_V_MF4_MF2_MASK = 9164, + RISCV_PseudoVSOXSEG8EI8_V_MF4_MF4 = 9165, + RISCV_PseudoVSOXSEG8EI8_V_MF4_MF4_MASK = 9166, + RISCV_PseudoVSOXSEG8EI8_V_MF8_M1 = 9167, + RISCV_PseudoVSOXSEG8EI8_V_MF8_M1_MASK = 9168, + RISCV_PseudoVSOXSEG8EI8_V_MF8_MF2 = 9169, + RISCV_PseudoVSOXSEG8EI8_V_MF8_MF2_MASK = 9170, + RISCV_PseudoVSOXSEG8EI8_V_MF8_MF4 = 9171, + RISCV_PseudoVSOXSEG8EI8_V_MF8_MF4_MASK = 9172, + RISCV_PseudoVSOXSEG8EI8_V_MF8_MF8 = 9173, + RISCV_PseudoVSOXSEG8EI8_V_MF8_MF8_MASK = 9174, + RISCV_PseudoVSPILL2_M1 = 9175, + RISCV_PseudoVSPILL2_M2 = 9176, + RISCV_PseudoVSPILL2_M4 = 9177, + RISCV_PseudoVSPILL2_MF2 = 9178, + RISCV_PseudoVSPILL2_MF4 = 9179, + RISCV_PseudoVSPILL2_MF8 = 9180, + RISCV_PseudoVSPILL3_M1 = 9181, + RISCV_PseudoVSPILL3_M2 = 9182, + RISCV_PseudoVSPILL3_MF2 = 9183, + RISCV_PseudoVSPILL3_MF4 = 9184, + RISCV_PseudoVSPILL3_MF8 = 9185, + RISCV_PseudoVSPILL4_M1 = 9186, + RISCV_PseudoVSPILL4_M2 = 9187, + RISCV_PseudoVSPILL4_MF2 = 9188, + RISCV_PseudoVSPILL4_MF4 = 9189, + RISCV_PseudoVSPILL4_MF8 = 9190, + RISCV_PseudoVSPILL5_M1 = 9191, + RISCV_PseudoVSPILL5_MF2 = 9192, + RISCV_PseudoVSPILL5_MF4 = 9193, + RISCV_PseudoVSPILL5_MF8 = 9194, + RISCV_PseudoVSPILL6_M1 = 9195, + RISCV_PseudoVSPILL6_MF2 = 9196, + RISCV_PseudoVSPILL6_MF4 = 9197, + RISCV_PseudoVSPILL6_MF8 = 9198, + RISCV_PseudoVSPILL7_M1 = 9199, + RISCV_PseudoVSPILL7_MF2 = 9200, + RISCV_PseudoVSPILL7_MF4 = 9201, + RISCV_PseudoVSPILL7_MF8 = 9202, + RISCV_PseudoVSPILL8_M1 = 9203, + RISCV_PseudoVSPILL8_MF2 = 9204, + RISCV_PseudoVSPILL8_MF4 = 9205, + RISCV_PseudoVSPILL8_MF8 = 9206, + RISCV_PseudoVSRA_VI_M1 = 9207, + RISCV_PseudoVSRA_VI_M1_MASK = 9208, + RISCV_PseudoVSRA_VI_M2 = 9209, + RISCV_PseudoVSRA_VI_M2_MASK = 9210, + RISCV_PseudoVSRA_VI_M4 = 9211, + RISCV_PseudoVSRA_VI_M4_MASK = 9212, + RISCV_PseudoVSRA_VI_M8 = 9213, + RISCV_PseudoVSRA_VI_M8_MASK = 9214, + RISCV_PseudoVSRA_VI_MF2 = 9215, + RISCV_PseudoVSRA_VI_MF2_MASK = 9216, + RISCV_PseudoVSRA_VI_MF4 = 9217, + RISCV_PseudoVSRA_VI_MF4_MASK = 9218, + RISCV_PseudoVSRA_VI_MF8 = 9219, + RISCV_PseudoVSRA_VI_MF8_MASK = 9220, + RISCV_PseudoVSRA_VV_M1 = 9221, + RISCV_PseudoVSRA_VV_M1_MASK = 9222, + RISCV_PseudoVSRA_VV_M2 = 9223, + RISCV_PseudoVSRA_VV_M2_MASK = 9224, + RISCV_PseudoVSRA_VV_M4 = 9225, + RISCV_PseudoVSRA_VV_M4_MASK = 9226, + RISCV_PseudoVSRA_VV_M8 = 9227, + RISCV_PseudoVSRA_VV_M8_MASK = 9228, + RISCV_PseudoVSRA_VV_MF2 = 9229, + RISCV_PseudoVSRA_VV_MF2_MASK = 9230, + RISCV_PseudoVSRA_VV_MF4 = 9231, + RISCV_PseudoVSRA_VV_MF4_MASK = 9232, + RISCV_PseudoVSRA_VV_MF8 = 9233, + RISCV_PseudoVSRA_VV_MF8_MASK = 9234, + RISCV_PseudoVSRA_VX_M1 = 9235, + RISCV_PseudoVSRA_VX_M1_MASK = 9236, + RISCV_PseudoVSRA_VX_M2 = 9237, + RISCV_PseudoVSRA_VX_M2_MASK = 9238, + RISCV_PseudoVSRA_VX_M4 = 9239, + RISCV_PseudoVSRA_VX_M4_MASK = 9240, + RISCV_PseudoVSRA_VX_M8 = 9241, + RISCV_PseudoVSRA_VX_M8_MASK = 9242, + RISCV_PseudoVSRA_VX_MF2 = 9243, + RISCV_PseudoVSRA_VX_MF2_MASK = 9244, + RISCV_PseudoVSRA_VX_MF4 = 9245, + RISCV_PseudoVSRA_VX_MF4_MASK = 9246, + RISCV_PseudoVSRA_VX_MF8 = 9247, + RISCV_PseudoVSRA_VX_MF8_MASK = 9248, + RISCV_PseudoVSRL_VI_M1 = 9249, + RISCV_PseudoVSRL_VI_M1_MASK = 9250, + RISCV_PseudoVSRL_VI_M2 = 9251, + RISCV_PseudoVSRL_VI_M2_MASK = 9252, + RISCV_PseudoVSRL_VI_M4 = 9253, + RISCV_PseudoVSRL_VI_M4_MASK = 9254, + RISCV_PseudoVSRL_VI_M8 = 9255, + RISCV_PseudoVSRL_VI_M8_MASK = 9256, + RISCV_PseudoVSRL_VI_MF2 = 9257, + RISCV_PseudoVSRL_VI_MF2_MASK = 9258, + RISCV_PseudoVSRL_VI_MF4 = 9259, + RISCV_PseudoVSRL_VI_MF4_MASK = 9260, + RISCV_PseudoVSRL_VI_MF8 = 9261, + RISCV_PseudoVSRL_VI_MF8_MASK = 9262, + RISCV_PseudoVSRL_VV_M1 = 9263, + RISCV_PseudoVSRL_VV_M1_MASK = 9264, + RISCV_PseudoVSRL_VV_M2 = 9265, + RISCV_PseudoVSRL_VV_M2_MASK = 9266, + RISCV_PseudoVSRL_VV_M4 = 9267, + RISCV_PseudoVSRL_VV_M4_MASK = 9268, + RISCV_PseudoVSRL_VV_M8 = 9269, + RISCV_PseudoVSRL_VV_M8_MASK = 9270, + RISCV_PseudoVSRL_VV_MF2 = 9271, + RISCV_PseudoVSRL_VV_MF2_MASK = 9272, + RISCV_PseudoVSRL_VV_MF4 = 9273, + RISCV_PseudoVSRL_VV_MF4_MASK = 9274, + RISCV_PseudoVSRL_VV_MF8 = 9275, + RISCV_PseudoVSRL_VV_MF8_MASK = 9276, + RISCV_PseudoVSRL_VX_M1 = 9277, + RISCV_PseudoVSRL_VX_M1_MASK = 9278, + RISCV_PseudoVSRL_VX_M2 = 9279, + RISCV_PseudoVSRL_VX_M2_MASK = 9280, + RISCV_PseudoVSRL_VX_M4 = 9281, + RISCV_PseudoVSRL_VX_M4_MASK = 9282, + RISCV_PseudoVSRL_VX_M8 = 9283, + RISCV_PseudoVSRL_VX_M8_MASK = 9284, + RISCV_PseudoVSRL_VX_MF2 = 9285, + RISCV_PseudoVSRL_VX_MF2_MASK = 9286, + RISCV_PseudoVSRL_VX_MF4 = 9287, + RISCV_PseudoVSRL_VX_MF4_MASK = 9288, + RISCV_PseudoVSRL_VX_MF8 = 9289, + RISCV_PseudoVSRL_VX_MF8_MASK = 9290, + RISCV_PseudoVSSE16_V_M1 = 9291, + RISCV_PseudoVSSE16_V_M1_MASK = 9292, + RISCV_PseudoVSSE16_V_M2 = 9293, + RISCV_PseudoVSSE16_V_M2_MASK = 9294, + RISCV_PseudoVSSE16_V_M4 = 9295, + RISCV_PseudoVSSE16_V_M4_MASK = 9296, + RISCV_PseudoVSSE16_V_M8 = 9297, + RISCV_PseudoVSSE16_V_M8_MASK = 9298, + RISCV_PseudoVSSE16_V_MF2 = 9299, + RISCV_PseudoVSSE16_V_MF2_MASK = 9300, + RISCV_PseudoVSSE16_V_MF4 = 9301, + RISCV_PseudoVSSE16_V_MF4_MASK = 9302, + RISCV_PseudoVSSE32_V_M1 = 9303, + RISCV_PseudoVSSE32_V_M1_MASK = 9304, + RISCV_PseudoVSSE32_V_M2 = 9305, + RISCV_PseudoVSSE32_V_M2_MASK = 9306, + RISCV_PseudoVSSE32_V_M4 = 9307, + RISCV_PseudoVSSE32_V_M4_MASK = 9308, + RISCV_PseudoVSSE32_V_M8 = 9309, + RISCV_PseudoVSSE32_V_M8_MASK = 9310, + RISCV_PseudoVSSE32_V_MF2 = 9311, + RISCV_PseudoVSSE32_V_MF2_MASK = 9312, + RISCV_PseudoVSSE64_V_M1 = 9313, + RISCV_PseudoVSSE64_V_M1_MASK = 9314, + RISCV_PseudoVSSE64_V_M2 = 9315, + RISCV_PseudoVSSE64_V_M2_MASK = 9316, + RISCV_PseudoVSSE64_V_M4 = 9317, + RISCV_PseudoVSSE64_V_M4_MASK = 9318, + RISCV_PseudoVSSE64_V_M8 = 9319, + RISCV_PseudoVSSE64_V_M8_MASK = 9320, + RISCV_PseudoVSSE8_V_M1 = 9321, + RISCV_PseudoVSSE8_V_M1_MASK = 9322, + RISCV_PseudoVSSE8_V_M2 = 9323, + RISCV_PseudoVSSE8_V_M2_MASK = 9324, + RISCV_PseudoVSSE8_V_M4 = 9325, + RISCV_PseudoVSSE8_V_M4_MASK = 9326, + RISCV_PseudoVSSE8_V_M8 = 9327, + RISCV_PseudoVSSE8_V_M8_MASK = 9328, + RISCV_PseudoVSSE8_V_MF2 = 9329, + RISCV_PseudoVSSE8_V_MF2_MASK = 9330, + RISCV_PseudoVSSE8_V_MF4 = 9331, + RISCV_PseudoVSSE8_V_MF4_MASK = 9332, + RISCV_PseudoVSSE8_V_MF8 = 9333, + RISCV_PseudoVSSE8_V_MF8_MASK = 9334, + RISCV_PseudoVSSEG2E16_V_M1 = 9335, + RISCV_PseudoVSSEG2E16_V_M1_MASK = 9336, + RISCV_PseudoVSSEG2E16_V_M2 = 9337, + RISCV_PseudoVSSEG2E16_V_M2_MASK = 9338, + RISCV_PseudoVSSEG2E16_V_M4 = 9339, + RISCV_PseudoVSSEG2E16_V_M4_MASK = 9340, + RISCV_PseudoVSSEG2E16_V_MF2 = 9341, + RISCV_PseudoVSSEG2E16_V_MF2_MASK = 9342, + RISCV_PseudoVSSEG2E16_V_MF4 = 9343, + RISCV_PseudoVSSEG2E16_V_MF4_MASK = 9344, + RISCV_PseudoVSSEG2E32_V_M1 = 9345, + RISCV_PseudoVSSEG2E32_V_M1_MASK = 9346, + RISCV_PseudoVSSEG2E32_V_M2 = 9347, + RISCV_PseudoVSSEG2E32_V_M2_MASK = 9348, + RISCV_PseudoVSSEG2E32_V_M4 = 9349, + RISCV_PseudoVSSEG2E32_V_M4_MASK = 9350, + RISCV_PseudoVSSEG2E32_V_MF2 = 9351, + RISCV_PseudoVSSEG2E32_V_MF2_MASK = 9352, + RISCV_PseudoVSSEG2E64_V_M1 = 9353, + RISCV_PseudoVSSEG2E64_V_M1_MASK = 9354, + RISCV_PseudoVSSEG2E64_V_M2 = 9355, + RISCV_PseudoVSSEG2E64_V_M2_MASK = 9356, + RISCV_PseudoVSSEG2E64_V_M4 = 9357, + RISCV_PseudoVSSEG2E64_V_M4_MASK = 9358, + RISCV_PseudoVSSEG2E8_V_M1 = 9359, + RISCV_PseudoVSSEG2E8_V_M1_MASK = 9360, + RISCV_PseudoVSSEG2E8_V_M2 = 9361, + RISCV_PseudoVSSEG2E8_V_M2_MASK = 9362, + RISCV_PseudoVSSEG2E8_V_M4 = 9363, + RISCV_PseudoVSSEG2E8_V_M4_MASK = 9364, + RISCV_PseudoVSSEG2E8_V_MF2 = 9365, + RISCV_PseudoVSSEG2E8_V_MF2_MASK = 9366, + RISCV_PseudoVSSEG2E8_V_MF4 = 9367, + RISCV_PseudoVSSEG2E8_V_MF4_MASK = 9368, + RISCV_PseudoVSSEG2E8_V_MF8 = 9369, + RISCV_PseudoVSSEG2E8_V_MF8_MASK = 9370, + RISCV_PseudoVSSEG3E16_V_M1 = 9371, + RISCV_PseudoVSSEG3E16_V_M1_MASK = 9372, + RISCV_PseudoVSSEG3E16_V_M2 = 9373, + RISCV_PseudoVSSEG3E16_V_M2_MASK = 9374, + RISCV_PseudoVSSEG3E16_V_MF2 = 9375, + RISCV_PseudoVSSEG3E16_V_MF2_MASK = 9376, + RISCV_PseudoVSSEG3E16_V_MF4 = 9377, + RISCV_PseudoVSSEG3E16_V_MF4_MASK = 9378, + RISCV_PseudoVSSEG3E32_V_M1 = 9379, + RISCV_PseudoVSSEG3E32_V_M1_MASK = 9380, + RISCV_PseudoVSSEG3E32_V_M2 = 9381, + RISCV_PseudoVSSEG3E32_V_M2_MASK = 9382, + RISCV_PseudoVSSEG3E32_V_MF2 = 9383, + RISCV_PseudoVSSEG3E32_V_MF2_MASK = 9384, + RISCV_PseudoVSSEG3E64_V_M1 = 9385, + RISCV_PseudoVSSEG3E64_V_M1_MASK = 9386, + RISCV_PseudoVSSEG3E64_V_M2 = 9387, + RISCV_PseudoVSSEG3E64_V_M2_MASK = 9388, + RISCV_PseudoVSSEG3E8_V_M1 = 9389, + RISCV_PseudoVSSEG3E8_V_M1_MASK = 9390, + RISCV_PseudoVSSEG3E8_V_M2 = 9391, + RISCV_PseudoVSSEG3E8_V_M2_MASK = 9392, + RISCV_PseudoVSSEG3E8_V_MF2 = 9393, + RISCV_PseudoVSSEG3E8_V_MF2_MASK = 9394, + RISCV_PseudoVSSEG3E8_V_MF4 = 9395, + RISCV_PseudoVSSEG3E8_V_MF4_MASK = 9396, + RISCV_PseudoVSSEG3E8_V_MF8 = 9397, + RISCV_PseudoVSSEG3E8_V_MF8_MASK = 9398, + RISCV_PseudoVSSEG4E16_V_M1 = 9399, + RISCV_PseudoVSSEG4E16_V_M1_MASK = 9400, + RISCV_PseudoVSSEG4E16_V_M2 = 9401, + RISCV_PseudoVSSEG4E16_V_M2_MASK = 9402, + RISCV_PseudoVSSEG4E16_V_MF2 = 9403, + RISCV_PseudoVSSEG4E16_V_MF2_MASK = 9404, + RISCV_PseudoVSSEG4E16_V_MF4 = 9405, + RISCV_PseudoVSSEG4E16_V_MF4_MASK = 9406, + RISCV_PseudoVSSEG4E32_V_M1 = 9407, + RISCV_PseudoVSSEG4E32_V_M1_MASK = 9408, + RISCV_PseudoVSSEG4E32_V_M2 = 9409, + RISCV_PseudoVSSEG4E32_V_M2_MASK = 9410, + RISCV_PseudoVSSEG4E32_V_MF2 = 9411, + RISCV_PseudoVSSEG4E32_V_MF2_MASK = 9412, + RISCV_PseudoVSSEG4E64_V_M1 = 9413, + RISCV_PseudoVSSEG4E64_V_M1_MASK = 9414, + RISCV_PseudoVSSEG4E64_V_M2 = 9415, + RISCV_PseudoVSSEG4E64_V_M2_MASK = 9416, + RISCV_PseudoVSSEG4E8_V_M1 = 9417, + RISCV_PseudoVSSEG4E8_V_M1_MASK = 9418, + RISCV_PseudoVSSEG4E8_V_M2 = 9419, + RISCV_PseudoVSSEG4E8_V_M2_MASK = 9420, + RISCV_PseudoVSSEG4E8_V_MF2 = 9421, + RISCV_PseudoVSSEG4E8_V_MF2_MASK = 9422, + RISCV_PseudoVSSEG4E8_V_MF4 = 9423, + RISCV_PseudoVSSEG4E8_V_MF4_MASK = 9424, + RISCV_PseudoVSSEG4E8_V_MF8 = 9425, + RISCV_PseudoVSSEG4E8_V_MF8_MASK = 9426, + RISCV_PseudoVSSEG5E16_V_M1 = 9427, + RISCV_PseudoVSSEG5E16_V_M1_MASK = 9428, + RISCV_PseudoVSSEG5E16_V_MF2 = 9429, + RISCV_PseudoVSSEG5E16_V_MF2_MASK = 9430, + RISCV_PseudoVSSEG5E16_V_MF4 = 9431, + RISCV_PseudoVSSEG5E16_V_MF4_MASK = 9432, + RISCV_PseudoVSSEG5E32_V_M1 = 9433, + RISCV_PseudoVSSEG5E32_V_M1_MASK = 9434, + RISCV_PseudoVSSEG5E32_V_MF2 = 9435, + RISCV_PseudoVSSEG5E32_V_MF2_MASK = 9436, + RISCV_PseudoVSSEG5E64_V_M1 = 9437, + RISCV_PseudoVSSEG5E64_V_M1_MASK = 9438, + RISCV_PseudoVSSEG5E8_V_M1 = 9439, + RISCV_PseudoVSSEG5E8_V_M1_MASK = 9440, + RISCV_PseudoVSSEG5E8_V_MF2 = 9441, + RISCV_PseudoVSSEG5E8_V_MF2_MASK = 9442, + RISCV_PseudoVSSEG5E8_V_MF4 = 9443, + RISCV_PseudoVSSEG5E8_V_MF4_MASK = 9444, + RISCV_PseudoVSSEG5E8_V_MF8 = 9445, + RISCV_PseudoVSSEG5E8_V_MF8_MASK = 9446, + RISCV_PseudoVSSEG6E16_V_M1 = 9447, + RISCV_PseudoVSSEG6E16_V_M1_MASK = 9448, + RISCV_PseudoVSSEG6E16_V_MF2 = 9449, + RISCV_PseudoVSSEG6E16_V_MF2_MASK = 9450, + RISCV_PseudoVSSEG6E16_V_MF4 = 9451, + RISCV_PseudoVSSEG6E16_V_MF4_MASK = 9452, + RISCV_PseudoVSSEG6E32_V_M1 = 9453, + RISCV_PseudoVSSEG6E32_V_M1_MASK = 9454, + RISCV_PseudoVSSEG6E32_V_MF2 = 9455, + RISCV_PseudoVSSEG6E32_V_MF2_MASK = 9456, + RISCV_PseudoVSSEG6E64_V_M1 = 9457, + RISCV_PseudoVSSEG6E64_V_M1_MASK = 9458, + RISCV_PseudoVSSEG6E8_V_M1 = 9459, + RISCV_PseudoVSSEG6E8_V_M1_MASK = 9460, + RISCV_PseudoVSSEG6E8_V_MF2 = 9461, + RISCV_PseudoVSSEG6E8_V_MF2_MASK = 9462, + RISCV_PseudoVSSEG6E8_V_MF4 = 9463, + RISCV_PseudoVSSEG6E8_V_MF4_MASK = 9464, + RISCV_PseudoVSSEG6E8_V_MF8 = 9465, + RISCV_PseudoVSSEG6E8_V_MF8_MASK = 9466, + RISCV_PseudoVSSEG7E16_V_M1 = 9467, + RISCV_PseudoVSSEG7E16_V_M1_MASK = 9468, + RISCV_PseudoVSSEG7E16_V_MF2 = 9469, + RISCV_PseudoVSSEG7E16_V_MF2_MASK = 9470, + RISCV_PseudoVSSEG7E16_V_MF4 = 9471, + RISCV_PseudoVSSEG7E16_V_MF4_MASK = 9472, + RISCV_PseudoVSSEG7E32_V_M1 = 9473, + RISCV_PseudoVSSEG7E32_V_M1_MASK = 9474, + RISCV_PseudoVSSEG7E32_V_MF2 = 9475, + RISCV_PseudoVSSEG7E32_V_MF2_MASK = 9476, + RISCV_PseudoVSSEG7E64_V_M1 = 9477, + RISCV_PseudoVSSEG7E64_V_M1_MASK = 9478, + RISCV_PseudoVSSEG7E8_V_M1 = 9479, + RISCV_PseudoVSSEG7E8_V_M1_MASK = 9480, + RISCV_PseudoVSSEG7E8_V_MF2 = 9481, + RISCV_PseudoVSSEG7E8_V_MF2_MASK = 9482, + RISCV_PseudoVSSEG7E8_V_MF4 = 9483, + RISCV_PseudoVSSEG7E8_V_MF4_MASK = 9484, + RISCV_PseudoVSSEG7E8_V_MF8 = 9485, + RISCV_PseudoVSSEG7E8_V_MF8_MASK = 9486, + RISCV_PseudoVSSEG8E16_V_M1 = 9487, + RISCV_PseudoVSSEG8E16_V_M1_MASK = 9488, + RISCV_PseudoVSSEG8E16_V_MF2 = 9489, + RISCV_PseudoVSSEG8E16_V_MF2_MASK = 9490, + RISCV_PseudoVSSEG8E16_V_MF4 = 9491, + RISCV_PseudoVSSEG8E16_V_MF4_MASK = 9492, + RISCV_PseudoVSSEG8E32_V_M1 = 9493, + RISCV_PseudoVSSEG8E32_V_M1_MASK = 9494, + RISCV_PseudoVSSEG8E32_V_MF2 = 9495, + RISCV_PseudoVSSEG8E32_V_MF2_MASK = 9496, + RISCV_PseudoVSSEG8E64_V_M1 = 9497, + RISCV_PseudoVSSEG8E64_V_M1_MASK = 9498, + RISCV_PseudoVSSEG8E8_V_M1 = 9499, + RISCV_PseudoVSSEG8E8_V_M1_MASK = 9500, + RISCV_PseudoVSSEG8E8_V_MF2 = 9501, + RISCV_PseudoVSSEG8E8_V_MF2_MASK = 9502, + RISCV_PseudoVSSEG8E8_V_MF4 = 9503, + RISCV_PseudoVSSEG8E8_V_MF4_MASK = 9504, + RISCV_PseudoVSSEG8E8_V_MF8 = 9505, + RISCV_PseudoVSSEG8E8_V_MF8_MASK = 9506, + RISCV_PseudoVSSRA_VI_M1 = 9507, + RISCV_PseudoVSSRA_VI_M1_MASK = 9508, + RISCV_PseudoVSSRA_VI_M2 = 9509, + RISCV_PseudoVSSRA_VI_M2_MASK = 9510, + RISCV_PseudoVSSRA_VI_M4 = 9511, + RISCV_PseudoVSSRA_VI_M4_MASK = 9512, + RISCV_PseudoVSSRA_VI_M8 = 9513, + RISCV_PseudoVSSRA_VI_M8_MASK = 9514, + RISCV_PseudoVSSRA_VI_MF2 = 9515, + RISCV_PseudoVSSRA_VI_MF2_MASK = 9516, + RISCV_PseudoVSSRA_VI_MF4 = 9517, + RISCV_PseudoVSSRA_VI_MF4_MASK = 9518, + RISCV_PseudoVSSRA_VI_MF8 = 9519, + RISCV_PseudoVSSRA_VI_MF8_MASK = 9520, + RISCV_PseudoVSSRA_VV_M1 = 9521, + RISCV_PseudoVSSRA_VV_M1_MASK = 9522, + RISCV_PseudoVSSRA_VV_M2 = 9523, + RISCV_PseudoVSSRA_VV_M2_MASK = 9524, + RISCV_PseudoVSSRA_VV_M4 = 9525, + RISCV_PseudoVSSRA_VV_M4_MASK = 9526, + RISCV_PseudoVSSRA_VV_M8 = 9527, + RISCV_PseudoVSSRA_VV_M8_MASK = 9528, + RISCV_PseudoVSSRA_VV_MF2 = 9529, + RISCV_PseudoVSSRA_VV_MF2_MASK = 9530, + RISCV_PseudoVSSRA_VV_MF4 = 9531, + RISCV_PseudoVSSRA_VV_MF4_MASK = 9532, + RISCV_PseudoVSSRA_VV_MF8 = 9533, + RISCV_PseudoVSSRA_VV_MF8_MASK = 9534, + RISCV_PseudoVSSRA_VX_M1 = 9535, + RISCV_PseudoVSSRA_VX_M1_MASK = 9536, + RISCV_PseudoVSSRA_VX_M2 = 9537, + RISCV_PseudoVSSRA_VX_M2_MASK = 9538, + RISCV_PseudoVSSRA_VX_M4 = 9539, + RISCV_PseudoVSSRA_VX_M4_MASK = 9540, + RISCV_PseudoVSSRA_VX_M8 = 9541, + RISCV_PseudoVSSRA_VX_M8_MASK = 9542, + RISCV_PseudoVSSRA_VX_MF2 = 9543, + RISCV_PseudoVSSRA_VX_MF2_MASK = 9544, + RISCV_PseudoVSSRA_VX_MF4 = 9545, + RISCV_PseudoVSSRA_VX_MF4_MASK = 9546, + RISCV_PseudoVSSRA_VX_MF8 = 9547, + RISCV_PseudoVSSRA_VX_MF8_MASK = 9548, + RISCV_PseudoVSSRL_VI_M1 = 9549, + RISCV_PseudoVSSRL_VI_M1_MASK = 9550, + RISCV_PseudoVSSRL_VI_M2 = 9551, + RISCV_PseudoVSSRL_VI_M2_MASK = 9552, + RISCV_PseudoVSSRL_VI_M4 = 9553, + RISCV_PseudoVSSRL_VI_M4_MASK = 9554, + RISCV_PseudoVSSRL_VI_M8 = 9555, + RISCV_PseudoVSSRL_VI_M8_MASK = 9556, + RISCV_PseudoVSSRL_VI_MF2 = 9557, + RISCV_PseudoVSSRL_VI_MF2_MASK = 9558, + RISCV_PseudoVSSRL_VI_MF4 = 9559, + RISCV_PseudoVSSRL_VI_MF4_MASK = 9560, + RISCV_PseudoVSSRL_VI_MF8 = 9561, + RISCV_PseudoVSSRL_VI_MF8_MASK = 9562, + RISCV_PseudoVSSRL_VV_M1 = 9563, + RISCV_PseudoVSSRL_VV_M1_MASK = 9564, + RISCV_PseudoVSSRL_VV_M2 = 9565, + RISCV_PseudoVSSRL_VV_M2_MASK = 9566, + RISCV_PseudoVSSRL_VV_M4 = 9567, + RISCV_PseudoVSSRL_VV_M4_MASK = 9568, + RISCV_PseudoVSSRL_VV_M8 = 9569, + RISCV_PseudoVSSRL_VV_M8_MASK = 9570, + RISCV_PseudoVSSRL_VV_MF2 = 9571, + RISCV_PseudoVSSRL_VV_MF2_MASK = 9572, + RISCV_PseudoVSSRL_VV_MF4 = 9573, + RISCV_PseudoVSSRL_VV_MF4_MASK = 9574, + RISCV_PseudoVSSRL_VV_MF8 = 9575, + RISCV_PseudoVSSRL_VV_MF8_MASK = 9576, + RISCV_PseudoVSSRL_VX_M1 = 9577, + RISCV_PseudoVSSRL_VX_M1_MASK = 9578, + RISCV_PseudoVSSRL_VX_M2 = 9579, + RISCV_PseudoVSSRL_VX_M2_MASK = 9580, + RISCV_PseudoVSSRL_VX_M4 = 9581, + RISCV_PseudoVSSRL_VX_M4_MASK = 9582, + RISCV_PseudoVSSRL_VX_M8 = 9583, + RISCV_PseudoVSSRL_VX_M8_MASK = 9584, + RISCV_PseudoVSSRL_VX_MF2 = 9585, + RISCV_PseudoVSSRL_VX_MF2_MASK = 9586, + RISCV_PseudoVSSRL_VX_MF4 = 9587, + RISCV_PseudoVSSRL_VX_MF4_MASK = 9588, + RISCV_PseudoVSSRL_VX_MF8 = 9589, + RISCV_PseudoVSSRL_VX_MF8_MASK = 9590, + RISCV_PseudoVSSSEG2E16_V_M1 = 9591, + RISCV_PseudoVSSSEG2E16_V_M1_MASK = 9592, + RISCV_PseudoVSSSEG2E16_V_M2 = 9593, + RISCV_PseudoVSSSEG2E16_V_M2_MASK = 9594, + RISCV_PseudoVSSSEG2E16_V_M4 = 9595, + RISCV_PseudoVSSSEG2E16_V_M4_MASK = 9596, + RISCV_PseudoVSSSEG2E16_V_MF2 = 9597, + RISCV_PseudoVSSSEG2E16_V_MF2_MASK = 9598, + RISCV_PseudoVSSSEG2E16_V_MF4 = 9599, + RISCV_PseudoVSSSEG2E16_V_MF4_MASK = 9600, + RISCV_PseudoVSSSEG2E32_V_M1 = 9601, + RISCV_PseudoVSSSEG2E32_V_M1_MASK = 9602, + RISCV_PseudoVSSSEG2E32_V_M2 = 9603, + RISCV_PseudoVSSSEG2E32_V_M2_MASK = 9604, + RISCV_PseudoVSSSEG2E32_V_M4 = 9605, + RISCV_PseudoVSSSEG2E32_V_M4_MASK = 9606, + RISCV_PseudoVSSSEG2E32_V_MF2 = 9607, + RISCV_PseudoVSSSEG2E32_V_MF2_MASK = 9608, + RISCV_PseudoVSSSEG2E64_V_M1 = 9609, + RISCV_PseudoVSSSEG2E64_V_M1_MASK = 9610, + RISCV_PseudoVSSSEG2E64_V_M2 = 9611, + RISCV_PseudoVSSSEG2E64_V_M2_MASK = 9612, + RISCV_PseudoVSSSEG2E64_V_M4 = 9613, + RISCV_PseudoVSSSEG2E64_V_M4_MASK = 9614, + RISCV_PseudoVSSSEG2E8_V_M1 = 9615, + RISCV_PseudoVSSSEG2E8_V_M1_MASK = 9616, + RISCV_PseudoVSSSEG2E8_V_M2 = 9617, + RISCV_PseudoVSSSEG2E8_V_M2_MASK = 9618, + RISCV_PseudoVSSSEG2E8_V_M4 = 9619, + RISCV_PseudoVSSSEG2E8_V_M4_MASK = 9620, + RISCV_PseudoVSSSEG2E8_V_MF2 = 9621, + RISCV_PseudoVSSSEG2E8_V_MF2_MASK = 9622, + RISCV_PseudoVSSSEG2E8_V_MF4 = 9623, + RISCV_PseudoVSSSEG2E8_V_MF4_MASK = 9624, + RISCV_PseudoVSSSEG2E8_V_MF8 = 9625, + RISCV_PseudoVSSSEG2E8_V_MF8_MASK = 9626, + RISCV_PseudoVSSSEG3E16_V_M1 = 9627, + RISCV_PseudoVSSSEG3E16_V_M1_MASK = 9628, + RISCV_PseudoVSSSEG3E16_V_M2 = 9629, + RISCV_PseudoVSSSEG3E16_V_M2_MASK = 9630, + RISCV_PseudoVSSSEG3E16_V_MF2 = 9631, + RISCV_PseudoVSSSEG3E16_V_MF2_MASK = 9632, + RISCV_PseudoVSSSEG3E16_V_MF4 = 9633, + RISCV_PseudoVSSSEG3E16_V_MF4_MASK = 9634, + RISCV_PseudoVSSSEG3E32_V_M1 = 9635, + RISCV_PseudoVSSSEG3E32_V_M1_MASK = 9636, + RISCV_PseudoVSSSEG3E32_V_M2 = 9637, + RISCV_PseudoVSSSEG3E32_V_M2_MASK = 9638, + RISCV_PseudoVSSSEG3E32_V_MF2 = 9639, + RISCV_PseudoVSSSEG3E32_V_MF2_MASK = 9640, + RISCV_PseudoVSSSEG3E64_V_M1 = 9641, + RISCV_PseudoVSSSEG3E64_V_M1_MASK = 9642, + RISCV_PseudoVSSSEG3E64_V_M2 = 9643, + RISCV_PseudoVSSSEG3E64_V_M2_MASK = 9644, + RISCV_PseudoVSSSEG3E8_V_M1 = 9645, + RISCV_PseudoVSSSEG3E8_V_M1_MASK = 9646, + RISCV_PseudoVSSSEG3E8_V_M2 = 9647, + RISCV_PseudoVSSSEG3E8_V_M2_MASK = 9648, + RISCV_PseudoVSSSEG3E8_V_MF2 = 9649, + RISCV_PseudoVSSSEG3E8_V_MF2_MASK = 9650, + RISCV_PseudoVSSSEG3E8_V_MF4 = 9651, + RISCV_PseudoVSSSEG3E8_V_MF4_MASK = 9652, + RISCV_PseudoVSSSEG3E8_V_MF8 = 9653, + RISCV_PseudoVSSSEG3E8_V_MF8_MASK = 9654, + RISCV_PseudoVSSSEG4E16_V_M1 = 9655, + RISCV_PseudoVSSSEG4E16_V_M1_MASK = 9656, + RISCV_PseudoVSSSEG4E16_V_M2 = 9657, + RISCV_PseudoVSSSEG4E16_V_M2_MASK = 9658, + RISCV_PseudoVSSSEG4E16_V_MF2 = 9659, + RISCV_PseudoVSSSEG4E16_V_MF2_MASK = 9660, + RISCV_PseudoVSSSEG4E16_V_MF4 = 9661, + RISCV_PseudoVSSSEG4E16_V_MF4_MASK = 9662, + RISCV_PseudoVSSSEG4E32_V_M1 = 9663, + RISCV_PseudoVSSSEG4E32_V_M1_MASK = 9664, + RISCV_PseudoVSSSEG4E32_V_M2 = 9665, + RISCV_PseudoVSSSEG4E32_V_M2_MASK = 9666, + RISCV_PseudoVSSSEG4E32_V_MF2 = 9667, + RISCV_PseudoVSSSEG4E32_V_MF2_MASK = 9668, + RISCV_PseudoVSSSEG4E64_V_M1 = 9669, + RISCV_PseudoVSSSEG4E64_V_M1_MASK = 9670, + RISCV_PseudoVSSSEG4E64_V_M2 = 9671, + RISCV_PseudoVSSSEG4E64_V_M2_MASK = 9672, + RISCV_PseudoVSSSEG4E8_V_M1 = 9673, + RISCV_PseudoVSSSEG4E8_V_M1_MASK = 9674, + RISCV_PseudoVSSSEG4E8_V_M2 = 9675, + RISCV_PseudoVSSSEG4E8_V_M2_MASK = 9676, + RISCV_PseudoVSSSEG4E8_V_MF2 = 9677, + RISCV_PseudoVSSSEG4E8_V_MF2_MASK = 9678, + RISCV_PseudoVSSSEG4E8_V_MF4 = 9679, + RISCV_PseudoVSSSEG4E8_V_MF4_MASK = 9680, + RISCV_PseudoVSSSEG4E8_V_MF8 = 9681, + RISCV_PseudoVSSSEG4E8_V_MF8_MASK = 9682, + RISCV_PseudoVSSSEG5E16_V_M1 = 9683, + RISCV_PseudoVSSSEG5E16_V_M1_MASK = 9684, + RISCV_PseudoVSSSEG5E16_V_MF2 = 9685, + RISCV_PseudoVSSSEG5E16_V_MF2_MASK = 9686, + RISCV_PseudoVSSSEG5E16_V_MF4 = 9687, + RISCV_PseudoVSSSEG5E16_V_MF4_MASK = 9688, + RISCV_PseudoVSSSEG5E32_V_M1 = 9689, + RISCV_PseudoVSSSEG5E32_V_M1_MASK = 9690, + RISCV_PseudoVSSSEG5E32_V_MF2 = 9691, + RISCV_PseudoVSSSEG5E32_V_MF2_MASK = 9692, + RISCV_PseudoVSSSEG5E64_V_M1 = 9693, + RISCV_PseudoVSSSEG5E64_V_M1_MASK = 9694, + RISCV_PseudoVSSSEG5E8_V_M1 = 9695, + RISCV_PseudoVSSSEG5E8_V_M1_MASK = 9696, + RISCV_PseudoVSSSEG5E8_V_MF2 = 9697, + RISCV_PseudoVSSSEG5E8_V_MF2_MASK = 9698, + RISCV_PseudoVSSSEG5E8_V_MF4 = 9699, + RISCV_PseudoVSSSEG5E8_V_MF4_MASK = 9700, + RISCV_PseudoVSSSEG5E8_V_MF8 = 9701, + RISCV_PseudoVSSSEG5E8_V_MF8_MASK = 9702, + RISCV_PseudoVSSSEG6E16_V_M1 = 9703, + RISCV_PseudoVSSSEG6E16_V_M1_MASK = 9704, + RISCV_PseudoVSSSEG6E16_V_MF2 = 9705, + RISCV_PseudoVSSSEG6E16_V_MF2_MASK = 9706, + RISCV_PseudoVSSSEG6E16_V_MF4 = 9707, + RISCV_PseudoVSSSEG6E16_V_MF4_MASK = 9708, + RISCV_PseudoVSSSEG6E32_V_M1 = 9709, + RISCV_PseudoVSSSEG6E32_V_M1_MASK = 9710, + RISCV_PseudoVSSSEG6E32_V_MF2 = 9711, + RISCV_PseudoVSSSEG6E32_V_MF2_MASK = 9712, + RISCV_PseudoVSSSEG6E64_V_M1 = 9713, + RISCV_PseudoVSSSEG6E64_V_M1_MASK = 9714, + RISCV_PseudoVSSSEG6E8_V_M1 = 9715, + RISCV_PseudoVSSSEG6E8_V_M1_MASK = 9716, + RISCV_PseudoVSSSEG6E8_V_MF2 = 9717, + RISCV_PseudoVSSSEG6E8_V_MF2_MASK = 9718, + RISCV_PseudoVSSSEG6E8_V_MF4 = 9719, + RISCV_PseudoVSSSEG6E8_V_MF4_MASK = 9720, + RISCV_PseudoVSSSEG6E8_V_MF8 = 9721, + RISCV_PseudoVSSSEG6E8_V_MF8_MASK = 9722, + RISCV_PseudoVSSSEG7E16_V_M1 = 9723, + RISCV_PseudoVSSSEG7E16_V_M1_MASK = 9724, + RISCV_PseudoVSSSEG7E16_V_MF2 = 9725, + RISCV_PseudoVSSSEG7E16_V_MF2_MASK = 9726, + RISCV_PseudoVSSSEG7E16_V_MF4 = 9727, + RISCV_PseudoVSSSEG7E16_V_MF4_MASK = 9728, + RISCV_PseudoVSSSEG7E32_V_M1 = 9729, + RISCV_PseudoVSSSEG7E32_V_M1_MASK = 9730, + RISCV_PseudoVSSSEG7E32_V_MF2 = 9731, + RISCV_PseudoVSSSEG7E32_V_MF2_MASK = 9732, + RISCV_PseudoVSSSEG7E64_V_M1 = 9733, + RISCV_PseudoVSSSEG7E64_V_M1_MASK = 9734, + RISCV_PseudoVSSSEG7E8_V_M1 = 9735, + RISCV_PseudoVSSSEG7E8_V_M1_MASK = 9736, + RISCV_PseudoVSSSEG7E8_V_MF2 = 9737, + RISCV_PseudoVSSSEG7E8_V_MF2_MASK = 9738, + RISCV_PseudoVSSSEG7E8_V_MF4 = 9739, + RISCV_PseudoVSSSEG7E8_V_MF4_MASK = 9740, + RISCV_PseudoVSSSEG7E8_V_MF8 = 9741, + RISCV_PseudoVSSSEG7E8_V_MF8_MASK = 9742, + RISCV_PseudoVSSSEG8E16_V_M1 = 9743, + RISCV_PseudoVSSSEG8E16_V_M1_MASK = 9744, + RISCV_PseudoVSSSEG8E16_V_MF2 = 9745, + RISCV_PseudoVSSSEG8E16_V_MF2_MASK = 9746, + RISCV_PseudoVSSSEG8E16_V_MF4 = 9747, + RISCV_PseudoVSSSEG8E16_V_MF4_MASK = 9748, + RISCV_PseudoVSSSEG8E32_V_M1 = 9749, + RISCV_PseudoVSSSEG8E32_V_M1_MASK = 9750, + RISCV_PseudoVSSSEG8E32_V_MF2 = 9751, + RISCV_PseudoVSSSEG8E32_V_MF2_MASK = 9752, + RISCV_PseudoVSSSEG8E64_V_M1 = 9753, + RISCV_PseudoVSSSEG8E64_V_M1_MASK = 9754, + RISCV_PseudoVSSSEG8E8_V_M1 = 9755, + RISCV_PseudoVSSSEG8E8_V_M1_MASK = 9756, + RISCV_PseudoVSSSEG8E8_V_MF2 = 9757, + RISCV_PseudoVSSSEG8E8_V_MF2_MASK = 9758, + RISCV_PseudoVSSSEG8E8_V_MF4 = 9759, + RISCV_PseudoVSSSEG8E8_V_MF4_MASK = 9760, + RISCV_PseudoVSSSEG8E8_V_MF8 = 9761, + RISCV_PseudoVSSSEG8E8_V_MF8_MASK = 9762, + RISCV_PseudoVSSUBU_VV_M1 = 9763, + RISCV_PseudoVSSUBU_VV_M1_MASK = 9764, + RISCV_PseudoVSSUBU_VV_M2 = 9765, + RISCV_PseudoVSSUBU_VV_M2_MASK = 9766, + RISCV_PseudoVSSUBU_VV_M4 = 9767, + RISCV_PseudoVSSUBU_VV_M4_MASK = 9768, + RISCV_PseudoVSSUBU_VV_M8 = 9769, + RISCV_PseudoVSSUBU_VV_M8_MASK = 9770, + RISCV_PseudoVSSUBU_VV_MF2 = 9771, + RISCV_PseudoVSSUBU_VV_MF2_MASK = 9772, + RISCV_PseudoVSSUBU_VV_MF4 = 9773, + RISCV_PseudoVSSUBU_VV_MF4_MASK = 9774, + RISCV_PseudoVSSUBU_VV_MF8 = 9775, + RISCV_PseudoVSSUBU_VV_MF8_MASK = 9776, + RISCV_PseudoVSSUBU_VX_M1 = 9777, + RISCV_PseudoVSSUBU_VX_M1_MASK = 9778, + RISCV_PseudoVSSUBU_VX_M2 = 9779, + RISCV_PseudoVSSUBU_VX_M2_MASK = 9780, + RISCV_PseudoVSSUBU_VX_M4 = 9781, + RISCV_PseudoVSSUBU_VX_M4_MASK = 9782, + RISCV_PseudoVSSUBU_VX_M8 = 9783, + RISCV_PseudoVSSUBU_VX_M8_MASK = 9784, + RISCV_PseudoVSSUBU_VX_MF2 = 9785, + RISCV_PseudoVSSUBU_VX_MF2_MASK = 9786, + RISCV_PseudoVSSUBU_VX_MF4 = 9787, + RISCV_PseudoVSSUBU_VX_MF4_MASK = 9788, + RISCV_PseudoVSSUBU_VX_MF8 = 9789, + RISCV_PseudoVSSUBU_VX_MF8_MASK = 9790, + RISCV_PseudoVSSUB_VV_M1 = 9791, + RISCV_PseudoVSSUB_VV_M1_MASK = 9792, + RISCV_PseudoVSSUB_VV_M2 = 9793, + RISCV_PseudoVSSUB_VV_M2_MASK = 9794, + RISCV_PseudoVSSUB_VV_M4 = 9795, + RISCV_PseudoVSSUB_VV_M4_MASK = 9796, + RISCV_PseudoVSSUB_VV_M8 = 9797, + RISCV_PseudoVSSUB_VV_M8_MASK = 9798, + RISCV_PseudoVSSUB_VV_MF2 = 9799, + RISCV_PseudoVSSUB_VV_MF2_MASK = 9800, + RISCV_PseudoVSSUB_VV_MF4 = 9801, + RISCV_PseudoVSSUB_VV_MF4_MASK = 9802, + RISCV_PseudoVSSUB_VV_MF8 = 9803, + RISCV_PseudoVSSUB_VV_MF8_MASK = 9804, + RISCV_PseudoVSSUB_VX_M1 = 9805, + RISCV_PseudoVSSUB_VX_M1_MASK = 9806, + RISCV_PseudoVSSUB_VX_M2 = 9807, + RISCV_PseudoVSSUB_VX_M2_MASK = 9808, + RISCV_PseudoVSSUB_VX_M4 = 9809, + RISCV_PseudoVSSUB_VX_M4_MASK = 9810, + RISCV_PseudoVSSUB_VX_M8 = 9811, + RISCV_PseudoVSSUB_VX_M8_MASK = 9812, + RISCV_PseudoVSSUB_VX_MF2 = 9813, + RISCV_PseudoVSSUB_VX_MF2_MASK = 9814, + RISCV_PseudoVSSUB_VX_MF4 = 9815, + RISCV_PseudoVSSUB_VX_MF4_MASK = 9816, + RISCV_PseudoVSSUB_VX_MF8 = 9817, + RISCV_PseudoVSSUB_VX_MF8_MASK = 9818, + RISCV_PseudoVSUB_VV_M1 = 9819, + RISCV_PseudoVSUB_VV_M1_MASK = 9820, + RISCV_PseudoVSUB_VV_M2 = 9821, + RISCV_PseudoVSUB_VV_M2_MASK = 9822, + RISCV_PseudoVSUB_VV_M4 = 9823, + RISCV_PseudoVSUB_VV_M4_MASK = 9824, + RISCV_PseudoVSUB_VV_M8 = 9825, + RISCV_PseudoVSUB_VV_M8_MASK = 9826, + RISCV_PseudoVSUB_VV_MF2 = 9827, + RISCV_PseudoVSUB_VV_MF2_MASK = 9828, + RISCV_PseudoVSUB_VV_MF4 = 9829, + RISCV_PseudoVSUB_VV_MF4_MASK = 9830, + RISCV_PseudoVSUB_VV_MF8 = 9831, + RISCV_PseudoVSUB_VV_MF8_MASK = 9832, + RISCV_PseudoVSUB_VX_M1 = 9833, + RISCV_PseudoVSUB_VX_M1_MASK = 9834, + RISCV_PseudoVSUB_VX_M2 = 9835, + RISCV_PseudoVSUB_VX_M2_MASK = 9836, + RISCV_PseudoVSUB_VX_M4 = 9837, + RISCV_PseudoVSUB_VX_M4_MASK = 9838, + RISCV_PseudoVSUB_VX_M8 = 9839, + RISCV_PseudoVSUB_VX_M8_MASK = 9840, + RISCV_PseudoVSUB_VX_MF2 = 9841, + RISCV_PseudoVSUB_VX_MF2_MASK = 9842, + RISCV_PseudoVSUB_VX_MF4 = 9843, + RISCV_PseudoVSUB_VX_MF4_MASK = 9844, + RISCV_PseudoVSUB_VX_MF8 = 9845, + RISCV_PseudoVSUB_VX_MF8_MASK = 9846, + RISCV_PseudoVSUXEI16_V_M1_M1 = 9847, + RISCV_PseudoVSUXEI16_V_M1_M1_MASK = 9848, + RISCV_PseudoVSUXEI16_V_M1_M2 = 9849, + RISCV_PseudoVSUXEI16_V_M1_M2_MASK = 9850, + RISCV_PseudoVSUXEI16_V_M1_M4 = 9851, + RISCV_PseudoVSUXEI16_V_M1_M4_MASK = 9852, + RISCV_PseudoVSUXEI16_V_M1_MF2 = 9853, + RISCV_PseudoVSUXEI16_V_M1_MF2_MASK = 9854, + RISCV_PseudoVSUXEI16_V_M2_M1 = 9855, + RISCV_PseudoVSUXEI16_V_M2_M1_MASK = 9856, + RISCV_PseudoVSUXEI16_V_M2_M2 = 9857, + RISCV_PseudoVSUXEI16_V_M2_M2_MASK = 9858, + RISCV_PseudoVSUXEI16_V_M2_M4 = 9859, + RISCV_PseudoVSUXEI16_V_M2_M4_MASK = 9860, + RISCV_PseudoVSUXEI16_V_M2_M8 = 9861, + RISCV_PseudoVSUXEI16_V_M2_M8_MASK = 9862, + RISCV_PseudoVSUXEI16_V_M4_M2 = 9863, + RISCV_PseudoVSUXEI16_V_M4_M2_MASK = 9864, + RISCV_PseudoVSUXEI16_V_M4_M4 = 9865, + RISCV_PseudoVSUXEI16_V_M4_M4_MASK = 9866, + RISCV_PseudoVSUXEI16_V_M4_M8 = 9867, + RISCV_PseudoVSUXEI16_V_M4_M8_MASK = 9868, + RISCV_PseudoVSUXEI16_V_M8_M4 = 9869, + RISCV_PseudoVSUXEI16_V_M8_M4_MASK = 9870, + RISCV_PseudoVSUXEI16_V_M8_M8 = 9871, + RISCV_PseudoVSUXEI16_V_M8_M8_MASK = 9872, + RISCV_PseudoVSUXEI16_V_MF2_M1 = 9873, + RISCV_PseudoVSUXEI16_V_MF2_M1_MASK = 9874, + RISCV_PseudoVSUXEI16_V_MF2_M2 = 9875, + RISCV_PseudoVSUXEI16_V_MF2_M2_MASK = 9876, + RISCV_PseudoVSUXEI16_V_MF2_MF2 = 9877, + RISCV_PseudoVSUXEI16_V_MF2_MF2_MASK = 9878, + RISCV_PseudoVSUXEI16_V_MF2_MF4 = 9879, + RISCV_PseudoVSUXEI16_V_MF2_MF4_MASK = 9880, + RISCV_PseudoVSUXEI16_V_MF4_M1 = 9881, + RISCV_PseudoVSUXEI16_V_MF4_M1_MASK = 9882, + RISCV_PseudoVSUXEI16_V_MF4_MF2 = 9883, + RISCV_PseudoVSUXEI16_V_MF4_MF2_MASK = 9884, + RISCV_PseudoVSUXEI16_V_MF4_MF4 = 9885, + RISCV_PseudoVSUXEI16_V_MF4_MF4_MASK = 9886, + RISCV_PseudoVSUXEI16_V_MF4_MF8 = 9887, + RISCV_PseudoVSUXEI16_V_MF4_MF8_MASK = 9888, + RISCV_PseudoVSUXEI32_V_M1_M1 = 9889, + RISCV_PseudoVSUXEI32_V_M1_M1_MASK = 9890, + RISCV_PseudoVSUXEI32_V_M1_M2 = 9891, + RISCV_PseudoVSUXEI32_V_M1_M2_MASK = 9892, + RISCV_PseudoVSUXEI32_V_M1_MF2 = 9893, + RISCV_PseudoVSUXEI32_V_M1_MF2_MASK = 9894, + RISCV_PseudoVSUXEI32_V_M1_MF4 = 9895, + RISCV_PseudoVSUXEI32_V_M1_MF4_MASK = 9896, + RISCV_PseudoVSUXEI32_V_M2_M1 = 9897, + RISCV_PseudoVSUXEI32_V_M2_M1_MASK = 9898, + RISCV_PseudoVSUXEI32_V_M2_M2 = 9899, + RISCV_PseudoVSUXEI32_V_M2_M2_MASK = 9900, + RISCV_PseudoVSUXEI32_V_M2_M4 = 9901, + RISCV_PseudoVSUXEI32_V_M2_M4_MASK = 9902, + RISCV_PseudoVSUXEI32_V_M2_MF2 = 9903, + RISCV_PseudoVSUXEI32_V_M2_MF2_MASK = 9904, + RISCV_PseudoVSUXEI32_V_M4_M1 = 9905, + RISCV_PseudoVSUXEI32_V_M4_M1_MASK = 9906, + RISCV_PseudoVSUXEI32_V_M4_M2 = 9907, + RISCV_PseudoVSUXEI32_V_M4_M2_MASK = 9908, + RISCV_PseudoVSUXEI32_V_M4_M4 = 9909, + RISCV_PseudoVSUXEI32_V_M4_M4_MASK = 9910, + RISCV_PseudoVSUXEI32_V_M4_M8 = 9911, + RISCV_PseudoVSUXEI32_V_M4_M8_MASK = 9912, + RISCV_PseudoVSUXEI32_V_M8_M2 = 9913, + RISCV_PseudoVSUXEI32_V_M8_M2_MASK = 9914, + RISCV_PseudoVSUXEI32_V_M8_M4 = 9915, + RISCV_PseudoVSUXEI32_V_M8_M4_MASK = 9916, + RISCV_PseudoVSUXEI32_V_M8_M8 = 9917, + RISCV_PseudoVSUXEI32_V_M8_M8_MASK = 9918, + RISCV_PseudoVSUXEI32_V_MF2_M1 = 9919, + RISCV_PseudoVSUXEI32_V_MF2_M1_MASK = 9920, + RISCV_PseudoVSUXEI32_V_MF2_MF2 = 9921, + RISCV_PseudoVSUXEI32_V_MF2_MF2_MASK = 9922, + RISCV_PseudoVSUXEI32_V_MF2_MF4 = 9923, + RISCV_PseudoVSUXEI32_V_MF2_MF4_MASK = 9924, + RISCV_PseudoVSUXEI32_V_MF2_MF8 = 9925, + RISCV_PseudoVSUXEI32_V_MF2_MF8_MASK = 9926, + RISCV_PseudoVSUXEI64_V_M1_M1 = 9927, + RISCV_PseudoVSUXEI64_V_M1_M1_MASK = 9928, + RISCV_PseudoVSUXEI64_V_M1_MF2 = 9929, + RISCV_PseudoVSUXEI64_V_M1_MF2_MASK = 9930, + RISCV_PseudoVSUXEI64_V_M1_MF4 = 9931, + RISCV_PseudoVSUXEI64_V_M1_MF4_MASK = 9932, + RISCV_PseudoVSUXEI64_V_M1_MF8 = 9933, + RISCV_PseudoVSUXEI64_V_M1_MF8_MASK = 9934, + RISCV_PseudoVSUXEI64_V_M2_M1 = 9935, + RISCV_PseudoVSUXEI64_V_M2_M1_MASK = 9936, + RISCV_PseudoVSUXEI64_V_M2_M2 = 9937, + RISCV_PseudoVSUXEI64_V_M2_M2_MASK = 9938, + RISCV_PseudoVSUXEI64_V_M2_MF2 = 9939, + RISCV_PseudoVSUXEI64_V_M2_MF2_MASK = 9940, + RISCV_PseudoVSUXEI64_V_M2_MF4 = 9941, + RISCV_PseudoVSUXEI64_V_M2_MF4_MASK = 9942, + RISCV_PseudoVSUXEI64_V_M4_M1 = 9943, + RISCV_PseudoVSUXEI64_V_M4_M1_MASK = 9944, + RISCV_PseudoVSUXEI64_V_M4_M2 = 9945, + RISCV_PseudoVSUXEI64_V_M4_M2_MASK = 9946, + RISCV_PseudoVSUXEI64_V_M4_M4 = 9947, + RISCV_PseudoVSUXEI64_V_M4_M4_MASK = 9948, + RISCV_PseudoVSUXEI64_V_M4_MF2 = 9949, + RISCV_PseudoVSUXEI64_V_M4_MF2_MASK = 9950, + RISCV_PseudoVSUXEI64_V_M8_M1 = 9951, + RISCV_PseudoVSUXEI64_V_M8_M1_MASK = 9952, + RISCV_PseudoVSUXEI64_V_M8_M2 = 9953, + RISCV_PseudoVSUXEI64_V_M8_M2_MASK = 9954, + RISCV_PseudoVSUXEI64_V_M8_M4 = 9955, + RISCV_PseudoVSUXEI64_V_M8_M4_MASK = 9956, + RISCV_PseudoVSUXEI64_V_M8_M8 = 9957, + RISCV_PseudoVSUXEI64_V_M8_M8_MASK = 9958, + RISCV_PseudoVSUXEI8_V_M1_M1 = 9959, + RISCV_PseudoVSUXEI8_V_M1_M1_MASK = 9960, + RISCV_PseudoVSUXEI8_V_M1_M2 = 9961, + RISCV_PseudoVSUXEI8_V_M1_M2_MASK = 9962, + RISCV_PseudoVSUXEI8_V_M1_M4 = 9963, + RISCV_PseudoVSUXEI8_V_M1_M4_MASK = 9964, + RISCV_PseudoVSUXEI8_V_M1_M8 = 9965, + RISCV_PseudoVSUXEI8_V_M1_M8_MASK = 9966, + RISCV_PseudoVSUXEI8_V_M2_M2 = 9967, + RISCV_PseudoVSUXEI8_V_M2_M2_MASK = 9968, + RISCV_PseudoVSUXEI8_V_M2_M4 = 9969, + RISCV_PseudoVSUXEI8_V_M2_M4_MASK = 9970, + RISCV_PseudoVSUXEI8_V_M2_M8 = 9971, + RISCV_PseudoVSUXEI8_V_M2_M8_MASK = 9972, + RISCV_PseudoVSUXEI8_V_M4_M4 = 9973, + RISCV_PseudoVSUXEI8_V_M4_M4_MASK = 9974, + RISCV_PseudoVSUXEI8_V_M4_M8 = 9975, + RISCV_PseudoVSUXEI8_V_M4_M8_MASK = 9976, + RISCV_PseudoVSUXEI8_V_M8_M8 = 9977, + RISCV_PseudoVSUXEI8_V_M8_M8_MASK = 9978, + RISCV_PseudoVSUXEI8_V_MF2_M1 = 9979, + RISCV_PseudoVSUXEI8_V_MF2_M1_MASK = 9980, + RISCV_PseudoVSUXEI8_V_MF2_M2 = 9981, + RISCV_PseudoVSUXEI8_V_MF2_M2_MASK = 9982, + RISCV_PseudoVSUXEI8_V_MF2_M4 = 9983, + RISCV_PseudoVSUXEI8_V_MF2_M4_MASK = 9984, + RISCV_PseudoVSUXEI8_V_MF2_MF2 = 9985, + RISCV_PseudoVSUXEI8_V_MF2_MF2_MASK = 9986, + RISCV_PseudoVSUXEI8_V_MF4_M1 = 9987, + RISCV_PseudoVSUXEI8_V_MF4_M1_MASK = 9988, + RISCV_PseudoVSUXEI8_V_MF4_M2 = 9989, + RISCV_PseudoVSUXEI8_V_MF4_M2_MASK = 9990, + RISCV_PseudoVSUXEI8_V_MF4_MF2 = 9991, + RISCV_PseudoVSUXEI8_V_MF4_MF2_MASK = 9992, + RISCV_PseudoVSUXEI8_V_MF4_MF4 = 9993, + RISCV_PseudoVSUXEI8_V_MF4_MF4_MASK = 9994, + RISCV_PseudoVSUXEI8_V_MF8_M1 = 9995, + RISCV_PseudoVSUXEI8_V_MF8_M1_MASK = 9996, + RISCV_PseudoVSUXEI8_V_MF8_MF2 = 9997, + RISCV_PseudoVSUXEI8_V_MF8_MF2_MASK = 9998, + RISCV_PseudoVSUXEI8_V_MF8_MF4 = 9999, + RISCV_PseudoVSUXEI8_V_MF8_MF4_MASK = 10000, + RISCV_PseudoVSUXEI8_V_MF8_MF8 = 10001, + RISCV_PseudoVSUXEI8_V_MF8_MF8_MASK = 10002, + RISCV_PseudoVSUXSEG2EI16_V_M1_M1 = 10003, + RISCV_PseudoVSUXSEG2EI16_V_M1_M1_MASK = 10004, + RISCV_PseudoVSUXSEG2EI16_V_M1_M2 = 10005, + RISCV_PseudoVSUXSEG2EI16_V_M1_M2_MASK = 10006, + RISCV_PseudoVSUXSEG2EI16_V_M1_M4 = 10007, + RISCV_PseudoVSUXSEG2EI16_V_M1_M4_MASK = 10008, + RISCV_PseudoVSUXSEG2EI16_V_M1_MF2 = 10009, + RISCV_PseudoVSUXSEG2EI16_V_M1_MF2_MASK = 10010, + RISCV_PseudoVSUXSEG2EI16_V_M2_M1 = 10011, + RISCV_PseudoVSUXSEG2EI16_V_M2_M1_MASK = 10012, + RISCV_PseudoVSUXSEG2EI16_V_M2_M2 = 10013, + RISCV_PseudoVSUXSEG2EI16_V_M2_M2_MASK = 10014, + RISCV_PseudoVSUXSEG2EI16_V_M2_M4 = 10015, + RISCV_PseudoVSUXSEG2EI16_V_M2_M4_MASK = 10016, + RISCV_PseudoVSUXSEG2EI16_V_M4_M2 = 10017, + RISCV_PseudoVSUXSEG2EI16_V_M4_M2_MASK = 10018, + RISCV_PseudoVSUXSEG2EI16_V_M4_M4 = 10019, + RISCV_PseudoVSUXSEG2EI16_V_M4_M4_MASK = 10020, + RISCV_PseudoVSUXSEG2EI16_V_M8_M4 = 10021, + RISCV_PseudoVSUXSEG2EI16_V_M8_M4_MASK = 10022, + RISCV_PseudoVSUXSEG2EI16_V_MF2_M1 = 10023, + RISCV_PseudoVSUXSEG2EI16_V_MF2_M1_MASK = 10024, + RISCV_PseudoVSUXSEG2EI16_V_MF2_M2 = 10025, + RISCV_PseudoVSUXSEG2EI16_V_MF2_M2_MASK = 10026, + RISCV_PseudoVSUXSEG2EI16_V_MF2_MF2 = 10027, + RISCV_PseudoVSUXSEG2EI16_V_MF2_MF2_MASK = 10028, + RISCV_PseudoVSUXSEG2EI16_V_MF2_MF4 = 10029, + RISCV_PseudoVSUXSEG2EI16_V_MF2_MF4_MASK = 10030, + RISCV_PseudoVSUXSEG2EI16_V_MF4_M1 = 10031, + RISCV_PseudoVSUXSEG2EI16_V_MF4_M1_MASK = 10032, + RISCV_PseudoVSUXSEG2EI16_V_MF4_MF2 = 10033, + RISCV_PseudoVSUXSEG2EI16_V_MF4_MF2_MASK = 10034, + RISCV_PseudoVSUXSEG2EI16_V_MF4_MF4 = 10035, + RISCV_PseudoVSUXSEG2EI16_V_MF4_MF4_MASK = 10036, + RISCV_PseudoVSUXSEG2EI16_V_MF4_MF8 = 10037, + RISCV_PseudoVSUXSEG2EI16_V_MF4_MF8_MASK = 10038, + RISCV_PseudoVSUXSEG2EI32_V_M1_M1 = 10039, + RISCV_PseudoVSUXSEG2EI32_V_M1_M1_MASK = 10040, + RISCV_PseudoVSUXSEG2EI32_V_M1_M2 = 10041, + RISCV_PseudoVSUXSEG2EI32_V_M1_M2_MASK = 10042, + RISCV_PseudoVSUXSEG2EI32_V_M1_MF2 = 10043, + RISCV_PseudoVSUXSEG2EI32_V_M1_MF2_MASK = 10044, + RISCV_PseudoVSUXSEG2EI32_V_M1_MF4 = 10045, + RISCV_PseudoVSUXSEG2EI32_V_M1_MF4_MASK = 10046, + RISCV_PseudoVSUXSEG2EI32_V_M2_M1 = 10047, + RISCV_PseudoVSUXSEG2EI32_V_M2_M1_MASK = 10048, + RISCV_PseudoVSUXSEG2EI32_V_M2_M2 = 10049, + RISCV_PseudoVSUXSEG2EI32_V_M2_M2_MASK = 10050, + RISCV_PseudoVSUXSEG2EI32_V_M2_M4 = 10051, + RISCV_PseudoVSUXSEG2EI32_V_M2_M4_MASK = 10052, + RISCV_PseudoVSUXSEG2EI32_V_M2_MF2 = 10053, + RISCV_PseudoVSUXSEG2EI32_V_M2_MF2_MASK = 10054, + RISCV_PseudoVSUXSEG2EI32_V_M4_M1 = 10055, + RISCV_PseudoVSUXSEG2EI32_V_M4_M1_MASK = 10056, + RISCV_PseudoVSUXSEG2EI32_V_M4_M2 = 10057, + RISCV_PseudoVSUXSEG2EI32_V_M4_M2_MASK = 10058, + RISCV_PseudoVSUXSEG2EI32_V_M4_M4 = 10059, + RISCV_PseudoVSUXSEG2EI32_V_M4_M4_MASK = 10060, + RISCV_PseudoVSUXSEG2EI32_V_M8_M2 = 10061, + RISCV_PseudoVSUXSEG2EI32_V_M8_M2_MASK = 10062, + RISCV_PseudoVSUXSEG2EI32_V_M8_M4 = 10063, + RISCV_PseudoVSUXSEG2EI32_V_M8_M4_MASK = 10064, + RISCV_PseudoVSUXSEG2EI32_V_MF2_M1 = 10065, + RISCV_PseudoVSUXSEG2EI32_V_MF2_M1_MASK = 10066, + RISCV_PseudoVSUXSEG2EI32_V_MF2_MF2 = 10067, + RISCV_PseudoVSUXSEG2EI32_V_MF2_MF2_MASK = 10068, + RISCV_PseudoVSUXSEG2EI32_V_MF2_MF4 = 10069, + RISCV_PseudoVSUXSEG2EI32_V_MF2_MF4_MASK = 10070, + RISCV_PseudoVSUXSEG2EI32_V_MF2_MF8 = 10071, + RISCV_PseudoVSUXSEG2EI32_V_MF2_MF8_MASK = 10072, + RISCV_PseudoVSUXSEG2EI64_V_M1_M1 = 10073, + RISCV_PseudoVSUXSEG2EI64_V_M1_M1_MASK = 10074, + RISCV_PseudoVSUXSEG2EI64_V_M1_MF2 = 10075, + RISCV_PseudoVSUXSEG2EI64_V_M1_MF2_MASK = 10076, + RISCV_PseudoVSUXSEG2EI64_V_M1_MF4 = 10077, + RISCV_PseudoVSUXSEG2EI64_V_M1_MF4_MASK = 10078, + RISCV_PseudoVSUXSEG2EI64_V_M1_MF8 = 10079, + RISCV_PseudoVSUXSEG2EI64_V_M1_MF8_MASK = 10080, + RISCV_PseudoVSUXSEG2EI64_V_M2_M1 = 10081, + RISCV_PseudoVSUXSEG2EI64_V_M2_M1_MASK = 10082, + RISCV_PseudoVSUXSEG2EI64_V_M2_M2 = 10083, + RISCV_PseudoVSUXSEG2EI64_V_M2_M2_MASK = 10084, + RISCV_PseudoVSUXSEG2EI64_V_M2_MF2 = 10085, + RISCV_PseudoVSUXSEG2EI64_V_M2_MF2_MASK = 10086, + RISCV_PseudoVSUXSEG2EI64_V_M2_MF4 = 10087, + RISCV_PseudoVSUXSEG2EI64_V_M2_MF4_MASK = 10088, + RISCV_PseudoVSUXSEG2EI64_V_M4_M1 = 10089, + RISCV_PseudoVSUXSEG2EI64_V_M4_M1_MASK = 10090, + RISCV_PseudoVSUXSEG2EI64_V_M4_M2 = 10091, + RISCV_PseudoVSUXSEG2EI64_V_M4_M2_MASK = 10092, + RISCV_PseudoVSUXSEG2EI64_V_M4_M4 = 10093, + RISCV_PseudoVSUXSEG2EI64_V_M4_M4_MASK = 10094, + RISCV_PseudoVSUXSEG2EI64_V_M4_MF2 = 10095, + RISCV_PseudoVSUXSEG2EI64_V_M4_MF2_MASK = 10096, + RISCV_PseudoVSUXSEG2EI64_V_M8_M1 = 10097, + RISCV_PseudoVSUXSEG2EI64_V_M8_M1_MASK = 10098, + RISCV_PseudoVSUXSEG2EI64_V_M8_M2 = 10099, + RISCV_PseudoVSUXSEG2EI64_V_M8_M2_MASK = 10100, + RISCV_PseudoVSUXSEG2EI64_V_M8_M4 = 10101, + RISCV_PseudoVSUXSEG2EI64_V_M8_M4_MASK = 10102, + RISCV_PseudoVSUXSEG2EI8_V_M1_M1 = 10103, + RISCV_PseudoVSUXSEG2EI8_V_M1_M1_MASK = 10104, + RISCV_PseudoVSUXSEG2EI8_V_M1_M2 = 10105, + RISCV_PseudoVSUXSEG2EI8_V_M1_M2_MASK = 10106, + RISCV_PseudoVSUXSEG2EI8_V_M1_M4 = 10107, + RISCV_PseudoVSUXSEG2EI8_V_M1_M4_MASK = 10108, + RISCV_PseudoVSUXSEG2EI8_V_M2_M2 = 10109, + RISCV_PseudoVSUXSEG2EI8_V_M2_M2_MASK = 10110, + RISCV_PseudoVSUXSEG2EI8_V_M2_M4 = 10111, + RISCV_PseudoVSUXSEG2EI8_V_M2_M4_MASK = 10112, + RISCV_PseudoVSUXSEG2EI8_V_M4_M4 = 10113, + RISCV_PseudoVSUXSEG2EI8_V_M4_M4_MASK = 10114, + RISCV_PseudoVSUXSEG2EI8_V_MF2_M1 = 10115, + RISCV_PseudoVSUXSEG2EI8_V_MF2_M1_MASK = 10116, + RISCV_PseudoVSUXSEG2EI8_V_MF2_M2 = 10117, + RISCV_PseudoVSUXSEG2EI8_V_MF2_M2_MASK = 10118, + RISCV_PseudoVSUXSEG2EI8_V_MF2_M4 = 10119, + RISCV_PseudoVSUXSEG2EI8_V_MF2_M4_MASK = 10120, + RISCV_PseudoVSUXSEG2EI8_V_MF2_MF2 = 10121, + RISCV_PseudoVSUXSEG2EI8_V_MF2_MF2_MASK = 10122, + RISCV_PseudoVSUXSEG2EI8_V_MF4_M1 = 10123, + RISCV_PseudoVSUXSEG2EI8_V_MF4_M1_MASK = 10124, + RISCV_PseudoVSUXSEG2EI8_V_MF4_M2 = 10125, + RISCV_PseudoVSUXSEG2EI8_V_MF4_M2_MASK = 10126, + RISCV_PseudoVSUXSEG2EI8_V_MF4_MF2 = 10127, + RISCV_PseudoVSUXSEG2EI8_V_MF4_MF2_MASK = 10128, + RISCV_PseudoVSUXSEG2EI8_V_MF4_MF4 = 10129, + RISCV_PseudoVSUXSEG2EI8_V_MF4_MF4_MASK = 10130, + RISCV_PseudoVSUXSEG2EI8_V_MF8_M1 = 10131, + RISCV_PseudoVSUXSEG2EI8_V_MF8_M1_MASK = 10132, + RISCV_PseudoVSUXSEG2EI8_V_MF8_MF2 = 10133, + RISCV_PseudoVSUXSEG2EI8_V_MF8_MF2_MASK = 10134, + RISCV_PseudoVSUXSEG2EI8_V_MF8_MF4 = 10135, + RISCV_PseudoVSUXSEG2EI8_V_MF8_MF4_MASK = 10136, + RISCV_PseudoVSUXSEG2EI8_V_MF8_MF8 = 10137, + RISCV_PseudoVSUXSEG2EI8_V_MF8_MF8_MASK = 10138, + RISCV_PseudoVSUXSEG3EI16_V_M1_M1 = 10139, + RISCV_PseudoVSUXSEG3EI16_V_M1_M1_MASK = 10140, + RISCV_PseudoVSUXSEG3EI16_V_M1_M2 = 10141, + RISCV_PseudoVSUXSEG3EI16_V_M1_M2_MASK = 10142, + RISCV_PseudoVSUXSEG3EI16_V_M1_MF2 = 10143, + RISCV_PseudoVSUXSEG3EI16_V_M1_MF2_MASK = 10144, + RISCV_PseudoVSUXSEG3EI16_V_M2_M1 = 10145, + RISCV_PseudoVSUXSEG3EI16_V_M2_M1_MASK = 10146, + RISCV_PseudoVSUXSEG3EI16_V_M2_M2 = 10147, + RISCV_PseudoVSUXSEG3EI16_V_M2_M2_MASK = 10148, + RISCV_PseudoVSUXSEG3EI16_V_M4_M2 = 10149, + RISCV_PseudoVSUXSEG3EI16_V_M4_M2_MASK = 10150, + RISCV_PseudoVSUXSEG3EI16_V_MF2_M1 = 10151, + RISCV_PseudoVSUXSEG3EI16_V_MF2_M1_MASK = 10152, + RISCV_PseudoVSUXSEG3EI16_V_MF2_M2 = 10153, + RISCV_PseudoVSUXSEG3EI16_V_MF2_M2_MASK = 10154, + RISCV_PseudoVSUXSEG3EI16_V_MF2_MF2 = 10155, + RISCV_PseudoVSUXSEG3EI16_V_MF2_MF2_MASK = 10156, + RISCV_PseudoVSUXSEG3EI16_V_MF2_MF4 = 10157, + RISCV_PseudoVSUXSEG3EI16_V_MF2_MF4_MASK = 10158, + RISCV_PseudoVSUXSEG3EI16_V_MF4_M1 = 10159, + RISCV_PseudoVSUXSEG3EI16_V_MF4_M1_MASK = 10160, + RISCV_PseudoVSUXSEG3EI16_V_MF4_MF2 = 10161, + RISCV_PseudoVSUXSEG3EI16_V_MF4_MF2_MASK = 10162, + RISCV_PseudoVSUXSEG3EI16_V_MF4_MF4 = 10163, + RISCV_PseudoVSUXSEG3EI16_V_MF4_MF4_MASK = 10164, + RISCV_PseudoVSUXSEG3EI16_V_MF4_MF8 = 10165, + RISCV_PseudoVSUXSEG3EI16_V_MF4_MF8_MASK = 10166, + RISCV_PseudoVSUXSEG3EI32_V_M1_M1 = 10167, + RISCV_PseudoVSUXSEG3EI32_V_M1_M1_MASK = 10168, + RISCV_PseudoVSUXSEG3EI32_V_M1_M2 = 10169, + RISCV_PseudoVSUXSEG3EI32_V_M1_M2_MASK = 10170, + RISCV_PseudoVSUXSEG3EI32_V_M1_MF2 = 10171, + RISCV_PseudoVSUXSEG3EI32_V_M1_MF2_MASK = 10172, + RISCV_PseudoVSUXSEG3EI32_V_M1_MF4 = 10173, + RISCV_PseudoVSUXSEG3EI32_V_M1_MF4_MASK = 10174, + RISCV_PseudoVSUXSEG3EI32_V_M2_M1 = 10175, + RISCV_PseudoVSUXSEG3EI32_V_M2_M1_MASK = 10176, + RISCV_PseudoVSUXSEG3EI32_V_M2_M2 = 10177, + RISCV_PseudoVSUXSEG3EI32_V_M2_M2_MASK = 10178, + RISCV_PseudoVSUXSEG3EI32_V_M2_MF2 = 10179, + RISCV_PseudoVSUXSEG3EI32_V_M2_MF2_MASK = 10180, + RISCV_PseudoVSUXSEG3EI32_V_M4_M1 = 10181, + RISCV_PseudoVSUXSEG3EI32_V_M4_M1_MASK = 10182, + RISCV_PseudoVSUXSEG3EI32_V_M4_M2 = 10183, + RISCV_PseudoVSUXSEG3EI32_V_M4_M2_MASK = 10184, + RISCV_PseudoVSUXSEG3EI32_V_M8_M2 = 10185, + RISCV_PseudoVSUXSEG3EI32_V_M8_M2_MASK = 10186, + RISCV_PseudoVSUXSEG3EI32_V_MF2_M1 = 10187, + RISCV_PseudoVSUXSEG3EI32_V_MF2_M1_MASK = 10188, + RISCV_PseudoVSUXSEG3EI32_V_MF2_MF2 = 10189, + RISCV_PseudoVSUXSEG3EI32_V_MF2_MF2_MASK = 10190, + RISCV_PseudoVSUXSEG3EI32_V_MF2_MF4 = 10191, + RISCV_PseudoVSUXSEG3EI32_V_MF2_MF4_MASK = 10192, + RISCV_PseudoVSUXSEG3EI32_V_MF2_MF8 = 10193, + RISCV_PseudoVSUXSEG3EI32_V_MF2_MF8_MASK = 10194, + RISCV_PseudoVSUXSEG3EI64_V_M1_M1 = 10195, + RISCV_PseudoVSUXSEG3EI64_V_M1_M1_MASK = 10196, + RISCV_PseudoVSUXSEG3EI64_V_M1_MF2 = 10197, + RISCV_PseudoVSUXSEG3EI64_V_M1_MF2_MASK = 10198, + RISCV_PseudoVSUXSEG3EI64_V_M1_MF4 = 10199, + RISCV_PseudoVSUXSEG3EI64_V_M1_MF4_MASK = 10200, + RISCV_PseudoVSUXSEG3EI64_V_M1_MF8 = 10201, + RISCV_PseudoVSUXSEG3EI64_V_M1_MF8_MASK = 10202, + RISCV_PseudoVSUXSEG3EI64_V_M2_M1 = 10203, + RISCV_PseudoVSUXSEG3EI64_V_M2_M1_MASK = 10204, + RISCV_PseudoVSUXSEG3EI64_V_M2_M2 = 10205, + RISCV_PseudoVSUXSEG3EI64_V_M2_M2_MASK = 10206, + RISCV_PseudoVSUXSEG3EI64_V_M2_MF2 = 10207, + RISCV_PseudoVSUXSEG3EI64_V_M2_MF2_MASK = 10208, + RISCV_PseudoVSUXSEG3EI64_V_M2_MF4 = 10209, + RISCV_PseudoVSUXSEG3EI64_V_M2_MF4_MASK = 10210, + RISCV_PseudoVSUXSEG3EI64_V_M4_M1 = 10211, + RISCV_PseudoVSUXSEG3EI64_V_M4_M1_MASK = 10212, + RISCV_PseudoVSUXSEG3EI64_V_M4_M2 = 10213, + RISCV_PseudoVSUXSEG3EI64_V_M4_M2_MASK = 10214, + RISCV_PseudoVSUXSEG3EI64_V_M4_MF2 = 10215, + RISCV_PseudoVSUXSEG3EI64_V_M4_MF2_MASK = 10216, + RISCV_PseudoVSUXSEG3EI64_V_M8_M1 = 10217, + RISCV_PseudoVSUXSEG3EI64_V_M8_M1_MASK = 10218, + RISCV_PseudoVSUXSEG3EI64_V_M8_M2 = 10219, + RISCV_PseudoVSUXSEG3EI64_V_M8_M2_MASK = 10220, + RISCV_PseudoVSUXSEG3EI8_V_M1_M1 = 10221, + RISCV_PseudoVSUXSEG3EI8_V_M1_M1_MASK = 10222, + RISCV_PseudoVSUXSEG3EI8_V_M1_M2 = 10223, + RISCV_PseudoVSUXSEG3EI8_V_M1_M2_MASK = 10224, + RISCV_PseudoVSUXSEG3EI8_V_M2_M2 = 10225, + RISCV_PseudoVSUXSEG3EI8_V_M2_M2_MASK = 10226, + RISCV_PseudoVSUXSEG3EI8_V_MF2_M1 = 10227, + RISCV_PseudoVSUXSEG3EI8_V_MF2_M1_MASK = 10228, + RISCV_PseudoVSUXSEG3EI8_V_MF2_M2 = 10229, + RISCV_PseudoVSUXSEG3EI8_V_MF2_M2_MASK = 10230, + RISCV_PseudoVSUXSEG3EI8_V_MF2_MF2 = 10231, + RISCV_PseudoVSUXSEG3EI8_V_MF2_MF2_MASK = 10232, + RISCV_PseudoVSUXSEG3EI8_V_MF4_M1 = 10233, + RISCV_PseudoVSUXSEG3EI8_V_MF4_M1_MASK = 10234, + RISCV_PseudoVSUXSEG3EI8_V_MF4_M2 = 10235, + RISCV_PseudoVSUXSEG3EI8_V_MF4_M2_MASK = 10236, + RISCV_PseudoVSUXSEG3EI8_V_MF4_MF2 = 10237, + RISCV_PseudoVSUXSEG3EI8_V_MF4_MF2_MASK = 10238, + RISCV_PseudoVSUXSEG3EI8_V_MF4_MF4 = 10239, + RISCV_PseudoVSUXSEG3EI8_V_MF4_MF4_MASK = 10240, + RISCV_PseudoVSUXSEG3EI8_V_MF8_M1 = 10241, + RISCV_PseudoVSUXSEG3EI8_V_MF8_M1_MASK = 10242, + RISCV_PseudoVSUXSEG3EI8_V_MF8_MF2 = 10243, + RISCV_PseudoVSUXSEG3EI8_V_MF8_MF2_MASK = 10244, + RISCV_PseudoVSUXSEG3EI8_V_MF8_MF4 = 10245, + RISCV_PseudoVSUXSEG3EI8_V_MF8_MF4_MASK = 10246, + RISCV_PseudoVSUXSEG3EI8_V_MF8_MF8 = 10247, + RISCV_PseudoVSUXSEG3EI8_V_MF8_MF8_MASK = 10248, + RISCV_PseudoVSUXSEG4EI16_V_M1_M1 = 10249, + RISCV_PseudoVSUXSEG4EI16_V_M1_M1_MASK = 10250, + RISCV_PseudoVSUXSEG4EI16_V_M1_M2 = 10251, + RISCV_PseudoVSUXSEG4EI16_V_M1_M2_MASK = 10252, + RISCV_PseudoVSUXSEG4EI16_V_M1_MF2 = 10253, + RISCV_PseudoVSUXSEG4EI16_V_M1_MF2_MASK = 10254, + RISCV_PseudoVSUXSEG4EI16_V_M2_M1 = 10255, + RISCV_PseudoVSUXSEG4EI16_V_M2_M1_MASK = 10256, + RISCV_PseudoVSUXSEG4EI16_V_M2_M2 = 10257, + RISCV_PseudoVSUXSEG4EI16_V_M2_M2_MASK = 10258, + RISCV_PseudoVSUXSEG4EI16_V_M4_M2 = 10259, + RISCV_PseudoVSUXSEG4EI16_V_M4_M2_MASK = 10260, + RISCV_PseudoVSUXSEG4EI16_V_MF2_M1 = 10261, + RISCV_PseudoVSUXSEG4EI16_V_MF2_M1_MASK = 10262, + RISCV_PseudoVSUXSEG4EI16_V_MF2_M2 = 10263, + RISCV_PseudoVSUXSEG4EI16_V_MF2_M2_MASK = 10264, + RISCV_PseudoVSUXSEG4EI16_V_MF2_MF2 = 10265, + RISCV_PseudoVSUXSEG4EI16_V_MF2_MF2_MASK = 10266, + RISCV_PseudoVSUXSEG4EI16_V_MF2_MF4 = 10267, + RISCV_PseudoVSUXSEG4EI16_V_MF2_MF4_MASK = 10268, + RISCV_PseudoVSUXSEG4EI16_V_MF4_M1 = 10269, + RISCV_PseudoVSUXSEG4EI16_V_MF4_M1_MASK = 10270, + RISCV_PseudoVSUXSEG4EI16_V_MF4_MF2 = 10271, + RISCV_PseudoVSUXSEG4EI16_V_MF4_MF2_MASK = 10272, + RISCV_PseudoVSUXSEG4EI16_V_MF4_MF4 = 10273, + RISCV_PseudoVSUXSEG4EI16_V_MF4_MF4_MASK = 10274, + RISCV_PseudoVSUXSEG4EI16_V_MF4_MF8 = 10275, + RISCV_PseudoVSUXSEG4EI16_V_MF4_MF8_MASK = 10276, + RISCV_PseudoVSUXSEG4EI32_V_M1_M1 = 10277, + RISCV_PseudoVSUXSEG4EI32_V_M1_M1_MASK = 10278, + RISCV_PseudoVSUXSEG4EI32_V_M1_M2 = 10279, + RISCV_PseudoVSUXSEG4EI32_V_M1_M2_MASK = 10280, + RISCV_PseudoVSUXSEG4EI32_V_M1_MF2 = 10281, + RISCV_PseudoVSUXSEG4EI32_V_M1_MF2_MASK = 10282, + RISCV_PseudoVSUXSEG4EI32_V_M1_MF4 = 10283, + RISCV_PseudoVSUXSEG4EI32_V_M1_MF4_MASK = 10284, + RISCV_PseudoVSUXSEG4EI32_V_M2_M1 = 10285, + RISCV_PseudoVSUXSEG4EI32_V_M2_M1_MASK = 10286, + RISCV_PseudoVSUXSEG4EI32_V_M2_M2 = 10287, + RISCV_PseudoVSUXSEG4EI32_V_M2_M2_MASK = 10288, + RISCV_PseudoVSUXSEG4EI32_V_M2_MF2 = 10289, + RISCV_PseudoVSUXSEG4EI32_V_M2_MF2_MASK = 10290, + RISCV_PseudoVSUXSEG4EI32_V_M4_M1 = 10291, + RISCV_PseudoVSUXSEG4EI32_V_M4_M1_MASK = 10292, + RISCV_PseudoVSUXSEG4EI32_V_M4_M2 = 10293, + RISCV_PseudoVSUXSEG4EI32_V_M4_M2_MASK = 10294, + RISCV_PseudoVSUXSEG4EI32_V_M8_M2 = 10295, + RISCV_PseudoVSUXSEG4EI32_V_M8_M2_MASK = 10296, + RISCV_PseudoVSUXSEG4EI32_V_MF2_M1 = 10297, + RISCV_PseudoVSUXSEG4EI32_V_MF2_M1_MASK = 10298, + RISCV_PseudoVSUXSEG4EI32_V_MF2_MF2 = 10299, + RISCV_PseudoVSUXSEG4EI32_V_MF2_MF2_MASK = 10300, + RISCV_PseudoVSUXSEG4EI32_V_MF2_MF4 = 10301, + RISCV_PseudoVSUXSEG4EI32_V_MF2_MF4_MASK = 10302, + RISCV_PseudoVSUXSEG4EI32_V_MF2_MF8 = 10303, + RISCV_PseudoVSUXSEG4EI32_V_MF2_MF8_MASK = 10304, + RISCV_PseudoVSUXSEG4EI64_V_M1_M1 = 10305, + RISCV_PseudoVSUXSEG4EI64_V_M1_M1_MASK = 10306, + RISCV_PseudoVSUXSEG4EI64_V_M1_MF2 = 10307, + RISCV_PseudoVSUXSEG4EI64_V_M1_MF2_MASK = 10308, + RISCV_PseudoVSUXSEG4EI64_V_M1_MF4 = 10309, + RISCV_PseudoVSUXSEG4EI64_V_M1_MF4_MASK = 10310, + RISCV_PseudoVSUXSEG4EI64_V_M1_MF8 = 10311, + RISCV_PseudoVSUXSEG4EI64_V_M1_MF8_MASK = 10312, + RISCV_PseudoVSUXSEG4EI64_V_M2_M1 = 10313, + RISCV_PseudoVSUXSEG4EI64_V_M2_M1_MASK = 10314, + RISCV_PseudoVSUXSEG4EI64_V_M2_M2 = 10315, + RISCV_PseudoVSUXSEG4EI64_V_M2_M2_MASK = 10316, + RISCV_PseudoVSUXSEG4EI64_V_M2_MF2 = 10317, + RISCV_PseudoVSUXSEG4EI64_V_M2_MF2_MASK = 10318, + RISCV_PseudoVSUXSEG4EI64_V_M2_MF4 = 10319, + RISCV_PseudoVSUXSEG4EI64_V_M2_MF4_MASK = 10320, + RISCV_PseudoVSUXSEG4EI64_V_M4_M1 = 10321, + RISCV_PseudoVSUXSEG4EI64_V_M4_M1_MASK = 10322, + RISCV_PseudoVSUXSEG4EI64_V_M4_M2 = 10323, + RISCV_PseudoVSUXSEG4EI64_V_M4_M2_MASK = 10324, + RISCV_PseudoVSUXSEG4EI64_V_M4_MF2 = 10325, + RISCV_PseudoVSUXSEG4EI64_V_M4_MF2_MASK = 10326, + RISCV_PseudoVSUXSEG4EI64_V_M8_M1 = 10327, + RISCV_PseudoVSUXSEG4EI64_V_M8_M1_MASK = 10328, + RISCV_PseudoVSUXSEG4EI64_V_M8_M2 = 10329, + RISCV_PseudoVSUXSEG4EI64_V_M8_M2_MASK = 10330, + RISCV_PseudoVSUXSEG4EI8_V_M1_M1 = 10331, + RISCV_PseudoVSUXSEG4EI8_V_M1_M1_MASK = 10332, + RISCV_PseudoVSUXSEG4EI8_V_M1_M2 = 10333, + RISCV_PseudoVSUXSEG4EI8_V_M1_M2_MASK = 10334, + RISCV_PseudoVSUXSEG4EI8_V_M2_M2 = 10335, + RISCV_PseudoVSUXSEG4EI8_V_M2_M2_MASK = 10336, + RISCV_PseudoVSUXSEG4EI8_V_MF2_M1 = 10337, + RISCV_PseudoVSUXSEG4EI8_V_MF2_M1_MASK = 10338, + RISCV_PseudoVSUXSEG4EI8_V_MF2_M2 = 10339, + RISCV_PseudoVSUXSEG4EI8_V_MF2_M2_MASK = 10340, + RISCV_PseudoVSUXSEG4EI8_V_MF2_MF2 = 10341, + RISCV_PseudoVSUXSEG4EI8_V_MF2_MF2_MASK = 10342, + RISCV_PseudoVSUXSEG4EI8_V_MF4_M1 = 10343, + RISCV_PseudoVSUXSEG4EI8_V_MF4_M1_MASK = 10344, + RISCV_PseudoVSUXSEG4EI8_V_MF4_M2 = 10345, + RISCV_PseudoVSUXSEG4EI8_V_MF4_M2_MASK = 10346, + RISCV_PseudoVSUXSEG4EI8_V_MF4_MF2 = 10347, + RISCV_PseudoVSUXSEG4EI8_V_MF4_MF2_MASK = 10348, + RISCV_PseudoVSUXSEG4EI8_V_MF4_MF4 = 10349, + RISCV_PseudoVSUXSEG4EI8_V_MF4_MF4_MASK = 10350, + RISCV_PseudoVSUXSEG4EI8_V_MF8_M1 = 10351, + RISCV_PseudoVSUXSEG4EI8_V_MF8_M1_MASK = 10352, + RISCV_PseudoVSUXSEG4EI8_V_MF8_MF2 = 10353, + RISCV_PseudoVSUXSEG4EI8_V_MF8_MF2_MASK = 10354, + RISCV_PseudoVSUXSEG4EI8_V_MF8_MF4 = 10355, + RISCV_PseudoVSUXSEG4EI8_V_MF8_MF4_MASK = 10356, + RISCV_PseudoVSUXSEG4EI8_V_MF8_MF8 = 10357, + RISCV_PseudoVSUXSEG4EI8_V_MF8_MF8_MASK = 10358, + RISCV_PseudoVSUXSEG5EI16_V_M1_M1 = 10359, + RISCV_PseudoVSUXSEG5EI16_V_M1_M1_MASK = 10360, + RISCV_PseudoVSUXSEG5EI16_V_M1_MF2 = 10361, + RISCV_PseudoVSUXSEG5EI16_V_M1_MF2_MASK = 10362, + RISCV_PseudoVSUXSEG5EI16_V_M2_M1 = 10363, + RISCV_PseudoVSUXSEG5EI16_V_M2_M1_MASK = 10364, + RISCV_PseudoVSUXSEG5EI16_V_MF2_M1 = 10365, + RISCV_PseudoVSUXSEG5EI16_V_MF2_M1_MASK = 10366, + RISCV_PseudoVSUXSEG5EI16_V_MF2_MF2 = 10367, + RISCV_PseudoVSUXSEG5EI16_V_MF2_MF2_MASK = 10368, + RISCV_PseudoVSUXSEG5EI16_V_MF2_MF4 = 10369, + RISCV_PseudoVSUXSEG5EI16_V_MF2_MF4_MASK = 10370, + RISCV_PseudoVSUXSEG5EI16_V_MF4_M1 = 10371, + RISCV_PseudoVSUXSEG5EI16_V_MF4_M1_MASK = 10372, + RISCV_PseudoVSUXSEG5EI16_V_MF4_MF2 = 10373, + RISCV_PseudoVSUXSEG5EI16_V_MF4_MF2_MASK = 10374, + RISCV_PseudoVSUXSEG5EI16_V_MF4_MF4 = 10375, + RISCV_PseudoVSUXSEG5EI16_V_MF4_MF4_MASK = 10376, + RISCV_PseudoVSUXSEG5EI16_V_MF4_MF8 = 10377, + RISCV_PseudoVSUXSEG5EI16_V_MF4_MF8_MASK = 10378, + RISCV_PseudoVSUXSEG5EI32_V_M1_M1 = 10379, + RISCV_PseudoVSUXSEG5EI32_V_M1_M1_MASK = 10380, + RISCV_PseudoVSUXSEG5EI32_V_M1_MF2 = 10381, + RISCV_PseudoVSUXSEG5EI32_V_M1_MF2_MASK = 10382, + RISCV_PseudoVSUXSEG5EI32_V_M1_MF4 = 10383, + RISCV_PseudoVSUXSEG5EI32_V_M1_MF4_MASK = 10384, + RISCV_PseudoVSUXSEG5EI32_V_M2_M1 = 10385, + RISCV_PseudoVSUXSEG5EI32_V_M2_M1_MASK = 10386, + RISCV_PseudoVSUXSEG5EI32_V_M2_MF2 = 10387, + RISCV_PseudoVSUXSEG5EI32_V_M2_MF2_MASK = 10388, + RISCV_PseudoVSUXSEG5EI32_V_M4_M1 = 10389, + RISCV_PseudoVSUXSEG5EI32_V_M4_M1_MASK = 10390, + RISCV_PseudoVSUXSEG5EI32_V_MF2_M1 = 10391, + RISCV_PseudoVSUXSEG5EI32_V_MF2_M1_MASK = 10392, + RISCV_PseudoVSUXSEG5EI32_V_MF2_MF2 = 10393, + RISCV_PseudoVSUXSEG5EI32_V_MF2_MF2_MASK = 10394, + RISCV_PseudoVSUXSEG5EI32_V_MF2_MF4 = 10395, + RISCV_PseudoVSUXSEG5EI32_V_MF2_MF4_MASK = 10396, + RISCV_PseudoVSUXSEG5EI32_V_MF2_MF8 = 10397, + RISCV_PseudoVSUXSEG5EI32_V_MF2_MF8_MASK = 10398, + RISCV_PseudoVSUXSEG5EI64_V_M1_M1 = 10399, + RISCV_PseudoVSUXSEG5EI64_V_M1_M1_MASK = 10400, + RISCV_PseudoVSUXSEG5EI64_V_M1_MF2 = 10401, + RISCV_PseudoVSUXSEG5EI64_V_M1_MF2_MASK = 10402, + RISCV_PseudoVSUXSEG5EI64_V_M1_MF4 = 10403, + RISCV_PseudoVSUXSEG5EI64_V_M1_MF4_MASK = 10404, + RISCV_PseudoVSUXSEG5EI64_V_M1_MF8 = 10405, + RISCV_PseudoVSUXSEG5EI64_V_M1_MF8_MASK = 10406, + RISCV_PseudoVSUXSEG5EI64_V_M2_M1 = 10407, + RISCV_PseudoVSUXSEG5EI64_V_M2_M1_MASK = 10408, + RISCV_PseudoVSUXSEG5EI64_V_M2_MF2 = 10409, + RISCV_PseudoVSUXSEG5EI64_V_M2_MF2_MASK = 10410, + RISCV_PseudoVSUXSEG5EI64_V_M2_MF4 = 10411, + RISCV_PseudoVSUXSEG5EI64_V_M2_MF4_MASK = 10412, + RISCV_PseudoVSUXSEG5EI64_V_M4_M1 = 10413, + RISCV_PseudoVSUXSEG5EI64_V_M4_M1_MASK = 10414, + RISCV_PseudoVSUXSEG5EI64_V_M4_MF2 = 10415, + RISCV_PseudoVSUXSEG5EI64_V_M4_MF2_MASK = 10416, + RISCV_PseudoVSUXSEG5EI64_V_M8_M1 = 10417, + RISCV_PseudoVSUXSEG5EI64_V_M8_M1_MASK = 10418, + RISCV_PseudoVSUXSEG5EI8_V_M1_M1 = 10419, + RISCV_PseudoVSUXSEG5EI8_V_M1_M1_MASK = 10420, + RISCV_PseudoVSUXSEG5EI8_V_MF2_M1 = 10421, + RISCV_PseudoVSUXSEG5EI8_V_MF2_M1_MASK = 10422, + RISCV_PseudoVSUXSEG5EI8_V_MF2_MF2 = 10423, + RISCV_PseudoVSUXSEG5EI8_V_MF2_MF2_MASK = 10424, + RISCV_PseudoVSUXSEG5EI8_V_MF4_M1 = 10425, + RISCV_PseudoVSUXSEG5EI8_V_MF4_M1_MASK = 10426, + RISCV_PseudoVSUXSEG5EI8_V_MF4_MF2 = 10427, + RISCV_PseudoVSUXSEG5EI8_V_MF4_MF2_MASK = 10428, + RISCV_PseudoVSUXSEG5EI8_V_MF4_MF4 = 10429, + RISCV_PseudoVSUXSEG5EI8_V_MF4_MF4_MASK = 10430, + RISCV_PseudoVSUXSEG5EI8_V_MF8_M1 = 10431, + RISCV_PseudoVSUXSEG5EI8_V_MF8_M1_MASK = 10432, + RISCV_PseudoVSUXSEG5EI8_V_MF8_MF2 = 10433, + RISCV_PseudoVSUXSEG5EI8_V_MF8_MF2_MASK = 10434, + RISCV_PseudoVSUXSEG5EI8_V_MF8_MF4 = 10435, + RISCV_PseudoVSUXSEG5EI8_V_MF8_MF4_MASK = 10436, + RISCV_PseudoVSUXSEG5EI8_V_MF8_MF8 = 10437, + RISCV_PseudoVSUXSEG5EI8_V_MF8_MF8_MASK = 10438, + RISCV_PseudoVSUXSEG6EI16_V_M1_M1 = 10439, + RISCV_PseudoVSUXSEG6EI16_V_M1_M1_MASK = 10440, + RISCV_PseudoVSUXSEG6EI16_V_M1_MF2 = 10441, + RISCV_PseudoVSUXSEG6EI16_V_M1_MF2_MASK = 10442, + RISCV_PseudoVSUXSEG6EI16_V_M2_M1 = 10443, + RISCV_PseudoVSUXSEG6EI16_V_M2_M1_MASK = 10444, + RISCV_PseudoVSUXSEG6EI16_V_MF2_M1 = 10445, + RISCV_PseudoVSUXSEG6EI16_V_MF2_M1_MASK = 10446, + RISCV_PseudoVSUXSEG6EI16_V_MF2_MF2 = 10447, + RISCV_PseudoVSUXSEG6EI16_V_MF2_MF2_MASK = 10448, + RISCV_PseudoVSUXSEG6EI16_V_MF2_MF4 = 10449, + RISCV_PseudoVSUXSEG6EI16_V_MF2_MF4_MASK = 10450, + RISCV_PseudoVSUXSEG6EI16_V_MF4_M1 = 10451, + RISCV_PseudoVSUXSEG6EI16_V_MF4_M1_MASK = 10452, + RISCV_PseudoVSUXSEG6EI16_V_MF4_MF2 = 10453, + RISCV_PseudoVSUXSEG6EI16_V_MF4_MF2_MASK = 10454, + RISCV_PseudoVSUXSEG6EI16_V_MF4_MF4 = 10455, + RISCV_PseudoVSUXSEG6EI16_V_MF4_MF4_MASK = 10456, + RISCV_PseudoVSUXSEG6EI16_V_MF4_MF8 = 10457, + RISCV_PseudoVSUXSEG6EI16_V_MF4_MF8_MASK = 10458, + RISCV_PseudoVSUXSEG6EI32_V_M1_M1 = 10459, + RISCV_PseudoVSUXSEG6EI32_V_M1_M1_MASK = 10460, + RISCV_PseudoVSUXSEG6EI32_V_M1_MF2 = 10461, + RISCV_PseudoVSUXSEG6EI32_V_M1_MF2_MASK = 10462, + RISCV_PseudoVSUXSEG6EI32_V_M1_MF4 = 10463, + RISCV_PseudoVSUXSEG6EI32_V_M1_MF4_MASK = 10464, + RISCV_PseudoVSUXSEG6EI32_V_M2_M1 = 10465, + RISCV_PseudoVSUXSEG6EI32_V_M2_M1_MASK = 10466, + RISCV_PseudoVSUXSEG6EI32_V_M2_MF2 = 10467, + RISCV_PseudoVSUXSEG6EI32_V_M2_MF2_MASK = 10468, + RISCV_PseudoVSUXSEG6EI32_V_M4_M1 = 10469, + RISCV_PseudoVSUXSEG6EI32_V_M4_M1_MASK = 10470, + RISCV_PseudoVSUXSEG6EI32_V_MF2_M1 = 10471, + RISCV_PseudoVSUXSEG6EI32_V_MF2_M1_MASK = 10472, + RISCV_PseudoVSUXSEG6EI32_V_MF2_MF2 = 10473, + RISCV_PseudoVSUXSEG6EI32_V_MF2_MF2_MASK = 10474, + RISCV_PseudoVSUXSEG6EI32_V_MF2_MF4 = 10475, + RISCV_PseudoVSUXSEG6EI32_V_MF2_MF4_MASK = 10476, + RISCV_PseudoVSUXSEG6EI32_V_MF2_MF8 = 10477, + RISCV_PseudoVSUXSEG6EI32_V_MF2_MF8_MASK = 10478, + RISCV_PseudoVSUXSEG6EI64_V_M1_M1 = 10479, + RISCV_PseudoVSUXSEG6EI64_V_M1_M1_MASK = 10480, + RISCV_PseudoVSUXSEG6EI64_V_M1_MF2 = 10481, + RISCV_PseudoVSUXSEG6EI64_V_M1_MF2_MASK = 10482, + RISCV_PseudoVSUXSEG6EI64_V_M1_MF4 = 10483, + RISCV_PseudoVSUXSEG6EI64_V_M1_MF4_MASK = 10484, + RISCV_PseudoVSUXSEG6EI64_V_M1_MF8 = 10485, + RISCV_PseudoVSUXSEG6EI64_V_M1_MF8_MASK = 10486, + RISCV_PseudoVSUXSEG6EI64_V_M2_M1 = 10487, + RISCV_PseudoVSUXSEG6EI64_V_M2_M1_MASK = 10488, + RISCV_PseudoVSUXSEG6EI64_V_M2_MF2 = 10489, + RISCV_PseudoVSUXSEG6EI64_V_M2_MF2_MASK = 10490, + RISCV_PseudoVSUXSEG6EI64_V_M2_MF4 = 10491, + RISCV_PseudoVSUXSEG6EI64_V_M2_MF4_MASK = 10492, + RISCV_PseudoVSUXSEG6EI64_V_M4_M1 = 10493, + RISCV_PseudoVSUXSEG6EI64_V_M4_M1_MASK = 10494, + RISCV_PseudoVSUXSEG6EI64_V_M4_MF2 = 10495, + RISCV_PseudoVSUXSEG6EI64_V_M4_MF2_MASK = 10496, + RISCV_PseudoVSUXSEG6EI64_V_M8_M1 = 10497, + RISCV_PseudoVSUXSEG6EI64_V_M8_M1_MASK = 10498, + RISCV_PseudoVSUXSEG6EI8_V_M1_M1 = 10499, + RISCV_PseudoVSUXSEG6EI8_V_M1_M1_MASK = 10500, + RISCV_PseudoVSUXSEG6EI8_V_MF2_M1 = 10501, + RISCV_PseudoVSUXSEG6EI8_V_MF2_M1_MASK = 10502, + RISCV_PseudoVSUXSEG6EI8_V_MF2_MF2 = 10503, + RISCV_PseudoVSUXSEG6EI8_V_MF2_MF2_MASK = 10504, + RISCV_PseudoVSUXSEG6EI8_V_MF4_M1 = 10505, + RISCV_PseudoVSUXSEG6EI8_V_MF4_M1_MASK = 10506, + RISCV_PseudoVSUXSEG6EI8_V_MF4_MF2 = 10507, + RISCV_PseudoVSUXSEG6EI8_V_MF4_MF2_MASK = 10508, + RISCV_PseudoVSUXSEG6EI8_V_MF4_MF4 = 10509, + RISCV_PseudoVSUXSEG6EI8_V_MF4_MF4_MASK = 10510, + RISCV_PseudoVSUXSEG6EI8_V_MF8_M1 = 10511, + RISCV_PseudoVSUXSEG6EI8_V_MF8_M1_MASK = 10512, + RISCV_PseudoVSUXSEG6EI8_V_MF8_MF2 = 10513, + RISCV_PseudoVSUXSEG6EI8_V_MF8_MF2_MASK = 10514, + RISCV_PseudoVSUXSEG6EI8_V_MF8_MF4 = 10515, + RISCV_PseudoVSUXSEG6EI8_V_MF8_MF4_MASK = 10516, + RISCV_PseudoVSUXSEG6EI8_V_MF8_MF8 = 10517, + RISCV_PseudoVSUXSEG6EI8_V_MF8_MF8_MASK = 10518, + RISCV_PseudoVSUXSEG7EI16_V_M1_M1 = 10519, + RISCV_PseudoVSUXSEG7EI16_V_M1_M1_MASK = 10520, + RISCV_PseudoVSUXSEG7EI16_V_M1_MF2 = 10521, + RISCV_PseudoVSUXSEG7EI16_V_M1_MF2_MASK = 10522, + RISCV_PseudoVSUXSEG7EI16_V_M2_M1 = 10523, + RISCV_PseudoVSUXSEG7EI16_V_M2_M1_MASK = 10524, + RISCV_PseudoVSUXSEG7EI16_V_MF2_M1 = 10525, + RISCV_PseudoVSUXSEG7EI16_V_MF2_M1_MASK = 10526, + RISCV_PseudoVSUXSEG7EI16_V_MF2_MF2 = 10527, + RISCV_PseudoVSUXSEG7EI16_V_MF2_MF2_MASK = 10528, + RISCV_PseudoVSUXSEG7EI16_V_MF2_MF4 = 10529, + RISCV_PseudoVSUXSEG7EI16_V_MF2_MF4_MASK = 10530, + RISCV_PseudoVSUXSEG7EI16_V_MF4_M1 = 10531, + RISCV_PseudoVSUXSEG7EI16_V_MF4_M1_MASK = 10532, + RISCV_PseudoVSUXSEG7EI16_V_MF4_MF2 = 10533, + RISCV_PseudoVSUXSEG7EI16_V_MF4_MF2_MASK = 10534, + RISCV_PseudoVSUXSEG7EI16_V_MF4_MF4 = 10535, + RISCV_PseudoVSUXSEG7EI16_V_MF4_MF4_MASK = 10536, + RISCV_PseudoVSUXSEG7EI16_V_MF4_MF8 = 10537, + RISCV_PseudoVSUXSEG7EI16_V_MF4_MF8_MASK = 10538, + RISCV_PseudoVSUXSEG7EI32_V_M1_M1 = 10539, + RISCV_PseudoVSUXSEG7EI32_V_M1_M1_MASK = 10540, + RISCV_PseudoVSUXSEG7EI32_V_M1_MF2 = 10541, + RISCV_PseudoVSUXSEG7EI32_V_M1_MF2_MASK = 10542, + RISCV_PseudoVSUXSEG7EI32_V_M1_MF4 = 10543, + RISCV_PseudoVSUXSEG7EI32_V_M1_MF4_MASK = 10544, + RISCV_PseudoVSUXSEG7EI32_V_M2_M1 = 10545, + RISCV_PseudoVSUXSEG7EI32_V_M2_M1_MASK = 10546, + RISCV_PseudoVSUXSEG7EI32_V_M2_MF2 = 10547, + RISCV_PseudoVSUXSEG7EI32_V_M2_MF2_MASK = 10548, + RISCV_PseudoVSUXSEG7EI32_V_M4_M1 = 10549, + RISCV_PseudoVSUXSEG7EI32_V_M4_M1_MASK = 10550, + RISCV_PseudoVSUXSEG7EI32_V_MF2_M1 = 10551, + RISCV_PseudoVSUXSEG7EI32_V_MF2_M1_MASK = 10552, + RISCV_PseudoVSUXSEG7EI32_V_MF2_MF2 = 10553, + RISCV_PseudoVSUXSEG7EI32_V_MF2_MF2_MASK = 10554, + RISCV_PseudoVSUXSEG7EI32_V_MF2_MF4 = 10555, + RISCV_PseudoVSUXSEG7EI32_V_MF2_MF4_MASK = 10556, + RISCV_PseudoVSUXSEG7EI32_V_MF2_MF8 = 10557, + RISCV_PseudoVSUXSEG7EI32_V_MF2_MF8_MASK = 10558, + RISCV_PseudoVSUXSEG7EI64_V_M1_M1 = 10559, + RISCV_PseudoVSUXSEG7EI64_V_M1_M1_MASK = 10560, + RISCV_PseudoVSUXSEG7EI64_V_M1_MF2 = 10561, + RISCV_PseudoVSUXSEG7EI64_V_M1_MF2_MASK = 10562, + RISCV_PseudoVSUXSEG7EI64_V_M1_MF4 = 10563, + RISCV_PseudoVSUXSEG7EI64_V_M1_MF4_MASK = 10564, + RISCV_PseudoVSUXSEG7EI64_V_M1_MF8 = 10565, + RISCV_PseudoVSUXSEG7EI64_V_M1_MF8_MASK = 10566, + RISCV_PseudoVSUXSEG7EI64_V_M2_M1 = 10567, + RISCV_PseudoVSUXSEG7EI64_V_M2_M1_MASK = 10568, + RISCV_PseudoVSUXSEG7EI64_V_M2_MF2 = 10569, + RISCV_PseudoVSUXSEG7EI64_V_M2_MF2_MASK = 10570, + RISCV_PseudoVSUXSEG7EI64_V_M2_MF4 = 10571, + RISCV_PseudoVSUXSEG7EI64_V_M2_MF4_MASK = 10572, + RISCV_PseudoVSUXSEG7EI64_V_M4_M1 = 10573, + RISCV_PseudoVSUXSEG7EI64_V_M4_M1_MASK = 10574, + RISCV_PseudoVSUXSEG7EI64_V_M4_MF2 = 10575, + RISCV_PseudoVSUXSEG7EI64_V_M4_MF2_MASK = 10576, + RISCV_PseudoVSUXSEG7EI64_V_M8_M1 = 10577, + RISCV_PseudoVSUXSEG7EI64_V_M8_M1_MASK = 10578, + RISCV_PseudoVSUXSEG7EI8_V_M1_M1 = 10579, + RISCV_PseudoVSUXSEG7EI8_V_M1_M1_MASK = 10580, + RISCV_PseudoVSUXSEG7EI8_V_MF2_M1 = 10581, + RISCV_PseudoVSUXSEG7EI8_V_MF2_M1_MASK = 10582, + RISCV_PseudoVSUXSEG7EI8_V_MF2_MF2 = 10583, + RISCV_PseudoVSUXSEG7EI8_V_MF2_MF2_MASK = 10584, + RISCV_PseudoVSUXSEG7EI8_V_MF4_M1 = 10585, + RISCV_PseudoVSUXSEG7EI8_V_MF4_M1_MASK = 10586, + RISCV_PseudoVSUXSEG7EI8_V_MF4_MF2 = 10587, + RISCV_PseudoVSUXSEG7EI8_V_MF4_MF2_MASK = 10588, + RISCV_PseudoVSUXSEG7EI8_V_MF4_MF4 = 10589, + RISCV_PseudoVSUXSEG7EI8_V_MF4_MF4_MASK = 10590, + RISCV_PseudoVSUXSEG7EI8_V_MF8_M1 = 10591, + RISCV_PseudoVSUXSEG7EI8_V_MF8_M1_MASK = 10592, + RISCV_PseudoVSUXSEG7EI8_V_MF8_MF2 = 10593, + RISCV_PseudoVSUXSEG7EI8_V_MF8_MF2_MASK = 10594, + RISCV_PseudoVSUXSEG7EI8_V_MF8_MF4 = 10595, + RISCV_PseudoVSUXSEG7EI8_V_MF8_MF4_MASK = 10596, + RISCV_PseudoVSUXSEG7EI8_V_MF8_MF8 = 10597, + RISCV_PseudoVSUXSEG7EI8_V_MF8_MF8_MASK = 10598, + RISCV_PseudoVSUXSEG8EI16_V_M1_M1 = 10599, + RISCV_PseudoVSUXSEG8EI16_V_M1_M1_MASK = 10600, + RISCV_PseudoVSUXSEG8EI16_V_M1_MF2 = 10601, + RISCV_PseudoVSUXSEG8EI16_V_M1_MF2_MASK = 10602, + RISCV_PseudoVSUXSEG8EI16_V_M2_M1 = 10603, + RISCV_PseudoVSUXSEG8EI16_V_M2_M1_MASK = 10604, + RISCV_PseudoVSUXSEG8EI16_V_MF2_M1 = 10605, + RISCV_PseudoVSUXSEG8EI16_V_MF2_M1_MASK = 10606, + RISCV_PseudoVSUXSEG8EI16_V_MF2_MF2 = 10607, + RISCV_PseudoVSUXSEG8EI16_V_MF2_MF2_MASK = 10608, + RISCV_PseudoVSUXSEG8EI16_V_MF2_MF4 = 10609, + RISCV_PseudoVSUXSEG8EI16_V_MF2_MF4_MASK = 10610, + RISCV_PseudoVSUXSEG8EI16_V_MF4_M1 = 10611, + RISCV_PseudoVSUXSEG8EI16_V_MF4_M1_MASK = 10612, + RISCV_PseudoVSUXSEG8EI16_V_MF4_MF2 = 10613, + RISCV_PseudoVSUXSEG8EI16_V_MF4_MF2_MASK = 10614, + RISCV_PseudoVSUXSEG8EI16_V_MF4_MF4 = 10615, + RISCV_PseudoVSUXSEG8EI16_V_MF4_MF4_MASK = 10616, + RISCV_PseudoVSUXSEG8EI16_V_MF4_MF8 = 10617, + RISCV_PseudoVSUXSEG8EI16_V_MF4_MF8_MASK = 10618, + RISCV_PseudoVSUXSEG8EI32_V_M1_M1 = 10619, + RISCV_PseudoVSUXSEG8EI32_V_M1_M1_MASK = 10620, + RISCV_PseudoVSUXSEG8EI32_V_M1_MF2 = 10621, + RISCV_PseudoVSUXSEG8EI32_V_M1_MF2_MASK = 10622, + RISCV_PseudoVSUXSEG8EI32_V_M1_MF4 = 10623, + RISCV_PseudoVSUXSEG8EI32_V_M1_MF4_MASK = 10624, + RISCV_PseudoVSUXSEG8EI32_V_M2_M1 = 10625, + RISCV_PseudoVSUXSEG8EI32_V_M2_M1_MASK = 10626, + RISCV_PseudoVSUXSEG8EI32_V_M2_MF2 = 10627, + RISCV_PseudoVSUXSEG8EI32_V_M2_MF2_MASK = 10628, + RISCV_PseudoVSUXSEG8EI32_V_M4_M1 = 10629, + RISCV_PseudoVSUXSEG8EI32_V_M4_M1_MASK = 10630, + RISCV_PseudoVSUXSEG8EI32_V_MF2_M1 = 10631, + RISCV_PseudoVSUXSEG8EI32_V_MF2_M1_MASK = 10632, + RISCV_PseudoVSUXSEG8EI32_V_MF2_MF2 = 10633, + RISCV_PseudoVSUXSEG8EI32_V_MF2_MF2_MASK = 10634, + RISCV_PseudoVSUXSEG8EI32_V_MF2_MF4 = 10635, + RISCV_PseudoVSUXSEG8EI32_V_MF2_MF4_MASK = 10636, + RISCV_PseudoVSUXSEG8EI32_V_MF2_MF8 = 10637, + RISCV_PseudoVSUXSEG8EI32_V_MF2_MF8_MASK = 10638, + RISCV_PseudoVSUXSEG8EI64_V_M1_M1 = 10639, + RISCV_PseudoVSUXSEG8EI64_V_M1_M1_MASK = 10640, + RISCV_PseudoVSUXSEG8EI64_V_M1_MF2 = 10641, + RISCV_PseudoVSUXSEG8EI64_V_M1_MF2_MASK = 10642, + RISCV_PseudoVSUXSEG8EI64_V_M1_MF4 = 10643, + RISCV_PseudoVSUXSEG8EI64_V_M1_MF4_MASK = 10644, + RISCV_PseudoVSUXSEG8EI64_V_M1_MF8 = 10645, + RISCV_PseudoVSUXSEG8EI64_V_M1_MF8_MASK = 10646, + RISCV_PseudoVSUXSEG8EI64_V_M2_M1 = 10647, + RISCV_PseudoVSUXSEG8EI64_V_M2_M1_MASK = 10648, + RISCV_PseudoVSUXSEG8EI64_V_M2_MF2 = 10649, + RISCV_PseudoVSUXSEG8EI64_V_M2_MF2_MASK = 10650, + RISCV_PseudoVSUXSEG8EI64_V_M2_MF4 = 10651, + RISCV_PseudoVSUXSEG8EI64_V_M2_MF4_MASK = 10652, + RISCV_PseudoVSUXSEG8EI64_V_M4_M1 = 10653, + RISCV_PseudoVSUXSEG8EI64_V_M4_M1_MASK = 10654, + RISCV_PseudoVSUXSEG8EI64_V_M4_MF2 = 10655, + RISCV_PseudoVSUXSEG8EI64_V_M4_MF2_MASK = 10656, + RISCV_PseudoVSUXSEG8EI64_V_M8_M1 = 10657, + RISCV_PseudoVSUXSEG8EI64_V_M8_M1_MASK = 10658, + RISCV_PseudoVSUXSEG8EI8_V_M1_M1 = 10659, + RISCV_PseudoVSUXSEG8EI8_V_M1_M1_MASK = 10660, + RISCV_PseudoVSUXSEG8EI8_V_MF2_M1 = 10661, + RISCV_PseudoVSUXSEG8EI8_V_MF2_M1_MASK = 10662, + RISCV_PseudoVSUXSEG8EI8_V_MF2_MF2 = 10663, + RISCV_PseudoVSUXSEG8EI8_V_MF2_MF2_MASK = 10664, + RISCV_PseudoVSUXSEG8EI8_V_MF4_M1 = 10665, + RISCV_PseudoVSUXSEG8EI8_V_MF4_M1_MASK = 10666, + RISCV_PseudoVSUXSEG8EI8_V_MF4_MF2 = 10667, + RISCV_PseudoVSUXSEG8EI8_V_MF4_MF2_MASK = 10668, + RISCV_PseudoVSUXSEG8EI8_V_MF4_MF4 = 10669, + RISCV_PseudoVSUXSEG8EI8_V_MF4_MF4_MASK = 10670, + RISCV_PseudoVSUXSEG8EI8_V_MF8_M1 = 10671, + RISCV_PseudoVSUXSEG8EI8_V_MF8_M1_MASK = 10672, + RISCV_PseudoVSUXSEG8EI8_V_MF8_MF2 = 10673, + RISCV_PseudoVSUXSEG8EI8_V_MF8_MF2_MASK = 10674, + RISCV_PseudoVSUXSEG8EI8_V_MF8_MF4 = 10675, + RISCV_PseudoVSUXSEG8EI8_V_MF8_MF4_MASK = 10676, + RISCV_PseudoVSUXSEG8EI8_V_MF8_MF8 = 10677, + RISCV_PseudoVSUXSEG8EI8_V_MF8_MF8_MASK = 10678, + RISCV_PseudoVWADDU_VV_M1 = 10679, + RISCV_PseudoVWADDU_VV_M1_MASK = 10680, + RISCV_PseudoVWADDU_VV_M2 = 10681, + RISCV_PseudoVWADDU_VV_M2_MASK = 10682, + RISCV_PseudoVWADDU_VV_M4 = 10683, + RISCV_PseudoVWADDU_VV_M4_MASK = 10684, + RISCV_PseudoVWADDU_VV_MF2 = 10685, + RISCV_PseudoVWADDU_VV_MF2_MASK = 10686, + RISCV_PseudoVWADDU_VV_MF4 = 10687, + RISCV_PseudoVWADDU_VV_MF4_MASK = 10688, + RISCV_PseudoVWADDU_VV_MF8 = 10689, + RISCV_PseudoVWADDU_VV_MF8_MASK = 10690, + RISCV_PseudoVWADDU_VX_M1 = 10691, + RISCV_PseudoVWADDU_VX_M1_MASK = 10692, + RISCV_PseudoVWADDU_VX_M2 = 10693, + RISCV_PseudoVWADDU_VX_M2_MASK = 10694, + RISCV_PseudoVWADDU_VX_M4 = 10695, + RISCV_PseudoVWADDU_VX_M4_MASK = 10696, + RISCV_PseudoVWADDU_VX_MF2 = 10697, + RISCV_PseudoVWADDU_VX_MF2_MASK = 10698, + RISCV_PseudoVWADDU_VX_MF4 = 10699, + RISCV_PseudoVWADDU_VX_MF4_MASK = 10700, + RISCV_PseudoVWADDU_VX_MF8 = 10701, + RISCV_PseudoVWADDU_VX_MF8_MASK = 10702, + RISCV_PseudoVWADDU_WV_M1 = 10703, + RISCV_PseudoVWADDU_WV_M1_MASK = 10704, + RISCV_PseudoVWADDU_WV_M1_MASK_TIED = 10705, + RISCV_PseudoVWADDU_WV_M1_TIED = 10706, + RISCV_PseudoVWADDU_WV_M2 = 10707, + RISCV_PseudoVWADDU_WV_M2_MASK = 10708, + RISCV_PseudoVWADDU_WV_M2_MASK_TIED = 10709, + RISCV_PseudoVWADDU_WV_M2_TIED = 10710, + RISCV_PseudoVWADDU_WV_M4 = 10711, + RISCV_PseudoVWADDU_WV_M4_MASK = 10712, + RISCV_PseudoVWADDU_WV_M4_MASK_TIED = 10713, + RISCV_PseudoVWADDU_WV_M4_TIED = 10714, + RISCV_PseudoVWADDU_WV_MF2 = 10715, + RISCV_PseudoVWADDU_WV_MF2_MASK = 10716, + RISCV_PseudoVWADDU_WV_MF2_MASK_TIED = 10717, + RISCV_PseudoVWADDU_WV_MF2_TIED = 10718, + RISCV_PseudoVWADDU_WV_MF4 = 10719, + RISCV_PseudoVWADDU_WV_MF4_MASK = 10720, + RISCV_PseudoVWADDU_WV_MF4_MASK_TIED = 10721, + RISCV_PseudoVWADDU_WV_MF4_TIED = 10722, + RISCV_PseudoVWADDU_WV_MF8 = 10723, + RISCV_PseudoVWADDU_WV_MF8_MASK = 10724, + RISCV_PseudoVWADDU_WV_MF8_MASK_TIED = 10725, + RISCV_PseudoVWADDU_WV_MF8_TIED = 10726, + RISCV_PseudoVWADDU_WX_M1 = 10727, + RISCV_PseudoVWADDU_WX_M1_MASK = 10728, + RISCV_PseudoVWADDU_WX_M2 = 10729, + RISCV_PseudoVWADDU_WX_M2_MASK = 10730, + RISCV_PseudoVWADDU_WX_M4 = 10731, + RISCV_PseudoVWADDU_WX_M4_MASK = 10732, + RISCV_PseudoVWADDU_WX_MF2 = 10733, + RISCV_PseudoVWADDU_WX_MF2_MASK = 10734, + RISCV_PseudoVWADDU_WX_MF4 = 10735, + RISCV_PseudoVWADDU_WX_MF4_MASK = 10736, + RISCV_PseudoVWADDU_WX_MF8 = 10737, + RISCV_PseudoVWADDU_WX_MF8_MASK = 10738, + RISCV_PseudoVWADD_VV_M1 = 10739, + RISCV_PseudoVWADD_VV_M1_MASK = 10740, + RISCV_PseudoVWADD_VV_M2 = 10741, + RISCV_PseudoVWADD_VV_M2_MASK = 10742, + RISCV_PseudoVWADD_VV_M4 = 10743, + RISCV_PseudoVWADD_VV_M4_MASK = 10744, + RISCV_PseudoVWADD_VV_MF2 = 10745, + RISCV_PseudoVWADD_VV_MF2_MASK = 10746, + RISCV_PseudoVWADD_VV_MF4 = 10747, + RISCV_PseudoVWADD_VV_MF4_MASK = 10748, + RISCV_PseudoVWADD_VV_MF8 = 10749, + RISCV_PseudoVWADD_VV_MF8_MASK = 10750, + RISCV_PseudoVWADD_VX_M1 = 10751, + RISCV_PseudoVWADD_VX_M1_MASK = 10752, + RISCV_PseudoVWADD_VX_M2 = 10753, + RISCV_PseudoVWADD_VX_M2_MASK = 10754, + RISCV_PseudoVWADD_VX_M4 = 10755, + RISCV_PseudoVWADD_VX_M4_MASK = 10756, + RISCV_PseudoVWADD_VX_MF2 = 10757, + RISCV_PseudoVWADD_VX_MF2_MASK = 10758, + RISCV_PseudoVWADD_VX_MF4 = 10759, + RISCV_PseudoVWADD_VX_MF4_MASK = 10760, + RISCV_PseudoVWADD_VX_MF8 = 10761, + RISCV_PseudoVWADD_VX_MF8_MASK = 10762, + RISCV_PseudoVWADD_WV_M1 = 10763, + RISCV_PseudoVWADD_WV_M1_MASK = 10764, + RISCV_PseudoVWADD_WV_M1_MASK_TIED = 10765, + RISCV_PseudoVWADD_WV_M1_TIED = 10766, + RISCV_PseudoVWADD_WV_M2 = 10767, + RISCV_PseudoVWADD_WV_M2_MASK = 10768, + RISCV_PseudoVWADD_WV_M2_MASK_TIED = 10769, + RISCV_PseudoVWADD_WV_M2_TIED = 10770, + RISCV_PseudoVWADD_WV_M4 = 10771, + RISCV_PseudoVWADD_WV_M4_MASK = 10772, + RISCV_PseudoVWADD_WV_M4_MASK_TIED = 10773, + RISCV_PseudoVWADD_WV_M4_TIED = 10774, + RISCV_PseudoVWADD_WV_MF2 = 10775, + RISCV_PseudoVWADD_WV_MF2_MASK = 10776, + RISCV_PseudoVWADD_WV_MF2_MASK_TIED = 10777, + RISCV_PseudoVWADD_WV_MF2_TIED = 10778, + RISCV_PseudoVWADD_WV_MF4 = 10779, + RISCV_PseudoVWADD_WV_MF4_MASK = 10780, + RISCV_PseudoVWADD_WV_MF4_MASK_TIED = 10781, + RISCV_PseudoVWADD_WV_MF4_TIED = 10782, + RISCV_PseudoVWADD_WV_MF8 = 10783, + RISCV_PseudoVWADD_WV_MF8_MASK = 10784, + RISCV_PseudoVWADD_WV_MF8_MASK_TIED = 10785, + RISCV_PseudoVWADD_WV_MF8_TIED = 10786, + RISCV_PseudoVWADD_WX_M1 = 10787, + RISCV_PseudoVWADD_WX_M1_MASK = 10788, + RISCV_PseudoVWADD_WX_M2 = 10789, + RISCV_PseudoVWADD_WX_M2_MASK = 10790, + RISCV_PseudoVWADD_WX_M4 = 10791, + RISCV_PseudoVWADD_WX_M4_MASK = 10792, + RISCV_PseudoVWADD_WX_MF2 = 10793, + RISCV_PseudoVWADD_WX_MF2_MASK = 10794, + RISCV_PseudoVWADD_WX_MF4 = 10795, + RISCV_PseudoVWADD_WX_MF4_MASK = 10796, + RISCV_PseudoVWADD_WX_MF8 = 10797, + RISCV_PseudoVWADD_WX_MF8_MASK = 10798, + RISCV_PseudoVWMACCSU_VV_M1 = 10799, + RISCV_PseudoVWMACCSU_VV_M1_MASK = 10800, + RISCV_PseudoVWMACCSU_VV_M2 = 10801, + RISCV_PseudoVWMACCSU_VV_M2_MASK = 10802, + RISCV_PseudoVWMACCSU_VV_M4 = 10803, + RISCV_PseudoVWMACCSU_VV_M4_MASK = 10804, + RISCV_PseudoVWMACCSU_VV_MF2 = 10805, + RISCV_PseudoVWMACCSU_VV_MF2_MASK = 10806, + RISCV_PseudoVWMACCSU_VV_MF4 = 10807, + RISCV_PseudoVWMACCSU_VV_MF4_MASK = 10808, + RISCV_PseudoVWMACCSU_VV_MF8 = 10809, + RISCV_PseudoVWMACCSU_VV_MF8_MASK = 10810, + RISCV_PseudoVWMACCSU_VX_M1 = 10811, + RISCV_PseudoVWMACCSU_VX_M1_MASK = 10812, + RISCV_PseudoVWMACCSU_VX_M2 = 10813, + RISCV_PseudoVWMACCSU_VX_M2_MASK = 10814, + RISCV_PseudoVWMACCSU_VX_M4 = 10815, + RISCV_PseudoVWMACCSU_VX_M4_MASK = 10816, + RISCV_PseudoVWMACCSU_VX_MF2 = 10817, + RISCV_PseudoVWMACCSU_VX_MF2_MASK = 10818, + RISCV_PseudoVWMACCSU_VX_MF4 = 10819, + RISCV_PseudoVWMACCSU_VX_MF4_MASK = 10820, + RISCV_PseudoVWMACCSU_VX_MF8 = 10821, + RISCV_PseudoVWMACCSU_VX_MF8_MASK = 10822, + RISCV_PseudoVWMACCUS_VX_M1 = 10823, + RISCV_PseudoVWMACCUS_VX_M1_MASK = 10824, + RISCV_PseudoVWMACCUS_VX_M2 = 10825, + RISCV_PseudoVWMACCUS_VX_M2_MASK = 10826, + RISCV_PseudoVWMACCUS_VX_M4 = 10827, + RISCV_PseudoVWMACCUS_VX_M4_MASK = 10828, + RISCV_PseudoVWMACCUS_VX_MF2 = 10829, + RISCV_PseudoVWMACCUS_VX_MF2_MASK = 10830, + RISCV_PseudoVWMACCUS_VX_MF4 = 10831, + RISCV_PseudoVWMACCUS_VX_MF4_MASK = 10832, + RISCV_PseudoVWMACCUS_VX_MF8 = 10833, + RISCV_PseudoVWMACCUS_VX_MF8_MASK = 10834, + RISCV_PseudoVWMACCU_VV_M1 = 10835, + RISCV_PseudoVWMACCU_VV_M1_MASK = 10836, + RISCV_PseudoVWMACCU_VV_M2 = 10837, + RISCV_PseudoVWMACCU_VV_M2_MASK = 10838, + RISCV_PseudoVWMACCU_VV_M4 = 10839, + RISCV_PseudoVWMACCU_VV_M4_MASK = 10840, + RISCV_PseudoVWMACCU_VV_MF2 = 10841, + RISCV_PseudoVWMACCU_VV_MF2_MASK = 10842, + RISCV_PseudoVWMACCU_VV_MF4 = 10843, + RISCV_PseudoVWMACCU_VV_MF4_MASK = 10844, + RISCV_PseudoVWMACCU_VV_MF8 = 10845, + RISCV_PseudoVWMACCU_VV_MF8_MASK = 10846, + RISCV_PseudoVWMACCU_VX_M1 = 10847, + RISCV_PseudoVWMACCU_VX_M1_MASK = 10848, + RISCV_PseudoVWMACCU_VX_M2 = 10849, + RISCV_PseudoVWMACCU_VX_M2_MASK = 10850, + RISCV_PseudoVWMACCU_VX_M4 = 10851, + RISCV_PseudoVWMACCU_VX_M4_MASK = 10852, + RISCV_PseudoVWMACCU_VX_MF2 = 10853, + RISCV_PseudoVWMACCU_VX_MF2_MASK = 10854, + RISCV_PseudoVWMACCU_VX_MF4 = 10855, + RISCV_PseudoVWMACCU_VX_MF4_MASK = 10856, + RISCV_PseudoVWMACCU_VX_MF8 = 10857, + RISCV_PseudoVWMACCU_VX_MF8_MASK = 10858, + RISCV_PseudoVWMACC_VV_M1 = 10859, + RISCV_PseudoVWMACC_VV_M1_MASK = 10860, + RISCV_PseudoVWMACC_VV_M2 = 10861, + RISCV_PseudoVWMACC_VV_M2_MASK = 10862, + RISCV_PseudoVWMACC_VV_M4 = 10863, + RISCV_PseudoVWMACC_VV_M4_MASK = 10864, + RISCV_PseudoVWMACC_VV_MF2 = 10865, + RISCV_PseudoVWMACC_VV_MF2_MASK = 10866, + RISCV_PseudoVWMACC_VV_MF4 = 10867, + RISCV_PseudoVWMACC_VV_MF4_MASK = 10868, + RISCV_PseudoVWMACC_VV_MF8 = 10869, + RISCV_PseudoVWMACC_VV_MF8_MASK = 10870, + RISCV_PseudoVWMACC_VX_M1 = 10871, + RISCV_PseudoVWMACC_VX_M1_MASK = 10872, + RISCV_PseudoVWMACC_VX_M2 = 10873, + RISCV_PseudoVWMACC_VX_M2_MASK = 10874, + RISCV_PseudoVWMACC_VX_M4 = 10875, + RISCV_PseudoVWMACC_VX_M4_MASK = 10876, + RISCV_PseudoVWMACC_VX_MF2 = 10877, + RISCV_PseudoVWMACC_VX_MF2_MASK = 10878, + RISCV_PseudoVWMACC_VX_MF4 = 10879, + RISCV_PseudoVWMACC_VX_MF4_MASK = 10880, + RISCV_PseudoVWMACC_VX_MF8 = 10881, + RISCV_PseudoVWMACC_VX_MF8_MASK = 10882, + RISCV_PseudoVWMULSU_VV_M1 = 10883, + RISCV_PseudoVWMULSU_VV_M1_MASK = 10884, + RISCV_PseudoVWMULSU_VV_M2 = 10885, + RISCV_PseudoVWMULSU_VV_M2_MASK = 10886, + RISCV_PseudoVWMULSU_VV_M4 = 10887, + RISCV_PseudoVWMULSU_VV_M4_MASK = 10888, + RISCV_PseudoVWMULSU_VV_MF2 = 10889, + RISCV_PseudoVWMULSU_VV_MF2_MASK = 10890, + RISCV_PseudoVWMULSU_VV_MF4 = 10891, + RISCV_PseudoVWMULSU_VV_MF4_MASK = 10892, + RISCV_PseudoVWMULSU_VV_MF8 = 10893, + RISCV_PseudoVWMULSU_VV_MF8_MASK = 10894, + RISCV_PseudoVWMULSU_VX_M1 = 10895, + RISCV_PseudoVWMULSU_VX_M1_MASK = 10896, + RISCV_PseudoVWMULSU_VX_M2 = 10897, + RISCV_PseudoVWMULSU_VX_M2_MASK = 10898, + RISCV_PseudoVWMULSU_VX_M4 = 10899, + RISCV_PseudoVWMULSU_VX_M4_MASK = 10900, + RISCV_PseudoVWMULSU_VX_MF2 = 10901, + RISCV_PseudoVWMULSU_VX_MF2_MASK = 10902, + RISCV_PseudoVWMULSU_VX_MF4 = 10903, + RISCV_PseudoVWMULSU_VX_MF4_MASK = 10904, + RISCV_PseudoVWMULSU_VX_MF8 = 10905, + RISCV_PseudoVWMULSU_VX_MF8_MASK = 10906, + RISCV_PseudoVWMULU_VV_M1 = 10907, + RISCV_PseudoVWMULU_VV_M1_MASK = 10908, + RISCV_PseudoVWMULU_VV_M2 = 10909, + RISCV_PseudoVWMULU_VV_M2_MASK = 10910, + RISCV_PseudoVWMULU_VV_M4 = 10911, + RISCV_PseudoVWMULU_VV_M4_MASK = 10912, + RISCV_PseudoVWMULU_VV_MF2 = 10913, + RISCV_PseudoVWMULU_VV_MF2_MASK = 10914, + RISCV_PseudoVWMULU_VV_MF4 = 10915, + RISCV_PseudoVWMULU_VV_MF4_MASK = 10916, + RISCV_PseudoVWMULU_VV_MF8 = 10917, + RISCV_PseudoVWMULU_VV_MF8_MASK = 10918, + RISCV_PseudoVWMULU_VX_M1 = 10919, + RISCV_PseudoVWMULU_VX_M1_MASK = 10920, + RISCV_PseudoVWMULU_VX_M2 = 10921, + RISCV_PseudoVWMULU_VX_M2_MASK = 10922, + RISCV_PseudoVWMULU_VX_M4 = 10923, + RISCV_PseudoVWMULU_VX_M4_MASK = 10924, + RISCV_PseudoVWMULU_VX_MF2 = 10925, + RISCV_PseudoVWMULU_VX_MF2_MASK = 10926, + RISCV_PseudoVWMULU_VX_MF4 = 10927, + RISCV_PseudoVWMULU_VX_MF4_MASK = 10928, + RISCV_PseudoVWMULU_VX_MF8 = 10929, + RISCV_PseudoVWMULU_VX_MF8_MASK = 10930, + RISCV_PseudoVWMUL_VV_M1 = 10931, + RISCV_PseudoVWMUL_VV_M1_MASK = 10932, + RISCV_PseudoVWMUL_VV_M2 = 10933, + RISCV_PseudoVWMUL_VV_M2_MASK = 10934, + RISCV_PseudoVWMUL_VV_M4 = 10935, + RISCV_PseudoVWMUL_VV_M4_MASK = 10936, + RISCV_PseudoVWMUL_VV_MF2 = 10937, + RISCV_PseudoVWMUL_VV_MF2_MASK = 10938, + RISCV_PseudoVWMUL_VV_MF4 = 10939, + RISCV_PseudoVWMUL_VV_MF4_MASK = 10940, + RISCV_PseudoVWMUL_VV_MF8 = 10941, + RISCV_PseudoVWMUL_VV_MF8_MASK = 10942, + RISCV_PseudoVWMUL_VX_M1 = 10943, + RISCV_PseudoVWMUL_VX_M1_MASK = 10944, + RISCV_PseudoVWMUL_VX_M2 = 10945, + RISCV_PseudoVWMUL_VX_M2_MASK = 10946, + RISCV_PseudoVWMUL_VX_M4 = 10947, + RISCV_PseudoVWMUL_VX_M4_MASK = 10948, + RISCV_PseudoVWMUL_VX_MF2 = 10949, + RISCV_PseudoVWMUL_VX_MF2_MASK = 10950, + RISCV_PseudoVWMUL_VX_MF4 = 10951, + RISCV_PseudoVWMUL_VX_MF4_MASK = 10952, + RISCV_PseudoVWMUL_VX_MF8 = 10953, + RISCV_PseudoVWMUL_VX_MF8_MASK = 10954, + RISCV_PseudoVWREDSUMU_VS_M1_E16 = 10955, + RISCV_PseudoVWREDSUMU_VS_M1_E16_MASK = 10956, + RISCV_PseudoVWREDSUMU_VS_M1_E32 = 10957, + RISCV_PseudoVWREDSUMU_VS_M1_E32_MASK = 10958, + RISCV_PseudoVWREDSUMU_VS_M1_E8 = 10959, + RISCV_PseudoVWREDSUMU_VS_M1_E8_MASK = 10960, + RISCV_PseudoVWREDSUMU_VS_M2_E16 = 10961, + RISCV_PseudoVWREDSUMU_VS_M2_E16_MASK = 10962, + RISCV_PseudoVWREDSUMU_VS_M2_E32 = 10963, + RISCV_PseudoVWREDSUMU_VS_M2_E32_MASK = 10964, + RISCV_PseudoVWREDSUMU_VS_M2_E8 = 10965, + RISCV_PseudoVWREDSUMU_VS_M2_E8_MASK = 10966, + RISCV_PseudoVWREDSUMU_VS_M4_E16 = 10967, + RISCV_PseudoVWREDSUMU_VS_M4_E16_MASK = 10968, + RISCV_PseudoVWREDSUMU_VS_M4_E32 = 10969, + RISCV_PseudoVWREDSUMU_VS_M4_E32_MASK = 10970, + RISCV_PseudoVWREDSUMU_VS_M4_E8 = 10971, + RISCV_PseudoVWREDSUMU_VS_M4_E8_MASK = 10972, + RISCV_PseudoVWREDSUMU_VS_M8_E16 = 10973, + RISCV_PseudoVWREDSUMU_VS_M8_E16_MASK = 10974, + RISCV_PseudoVWREDSUMU_VS_M8_E32 = 10975, + RISCV_PseudoVWREDSUMU_VS_M8_E32_MASK = 10976, + RISCV_PseudoVWREDSUMU_VS_M8_E8 = 10977, + RISCV_PseudoVWREDSUMU_VS_M8_E8_MASK = 10978, + RISCV_PseudoVWREDSUMU_VS_MF2_E16 = 10979, + RISCV_PseudoVWREDSUMU_VS_MF2_E16_MASK = 10980, + RISCV_PseudoVWREDSUMU_VS_MF2_E32 = 10981, + RISCV_PseudoVWREDSUMU_VS_MF2_E32_MASK = 10982, + RISCV_PseudoVWREDSUMU_VS_MF2_E8 = 10983, + RISCV_PseudoVWREDSUMU_VS_MF2_E8_MASK = 10984, + RISCV_PseudoVWREDSUMU_VS_MF4_E16 = 10985, + RISCV_PseudoVWREDSUMU_VS_MF4_E16_MASK = 10986, + RISCV_PseudoVWREDSUMU_VS_MF4_E8 = 10987, + RISCV_PseudoVWREDSUMU_VS_MF4_E8_MASK = 10988, + RISCV_PseudoVWREDSUMU_VS_MF8_E8 = 10989, + RISCV_PseudoVWREDSUMU_VS_MF8_E8_MASK = 10990, + RISCV_PseudoVWREDSUM_VS_M1_E16 = 10991, + RISCV_PseudoVWREDSUM_VS_M1_E16_MASK = 10992, + RISCV_PseudoVWREDSUM_VS_M1_E32 = 10993, + RISCV_PseudoVWREDSUM_VS_M1_E32_MASK = 10994, + RISCV_PseudoVWREDSUM_VS_M1_E8 = 10995, + RISCV_PseudoVWREDSUM_VS_M1_E8_MASK = 10996, + RISCV_PseudoVWREDSUM_VS_M2_E16 = 10997, + RISCV_PseudoVWREDSUM_VS_M2_E16_MASK = 10998, + RISCV_PseudoVWREDSUM_VS_M2_E32 = 10999, + RISCV_PseudoVWREDSUM_VS_M2_E32_MASK = 11000, + RISCV_PseudoVWREDSUM_VS_M2_E8 = 11001, + RISCV_PseudoVWREDSUM_VS_M2_E8_MASK = 11002, + RISCV_PseudoVWREDSUM_VS_M4_E16 = 11003, + RISCV_PseudoVWREDSUM_VS_M4_E16_MASK = 11004, + RISCV_PseudoVWREDSUM_VS_M4_E32 = 11005, + RISCV_PseudoVWREDSUM_VS_M4_E32_MASK = 11006, + RISCV_PseudoVWREDSUM_VS_M4_E8 = 11007, + RISCV_PseudoVWREDSUM_VS_M4_E8_MASK = 11008, + RISCV_PseudoVWREDSUM_VS_M8_E16 = 11009, + RISCV_PseudoVWREDSUM_VS_M8_E16_MASK = 11010, + RISCV_PseudoVWREDSUM_VS_M8_E32 = 11011, + RISCV_PseudoVWREDSUM_VS_M8_E32_MASK = 11012, + RISCV_PseudoVWREDSUM_VS_M8_E8 = 11013, + RISCV_PseudoVWREDSUM_VS_M8_E8_MASK = 11014, + RISCV_PseudoVWREDSUM_VS_MF2_E16 = 11015, + RISCV_PseudoVWREDSUM_VS_MF2_E16_MASK = 11016, + RISCV_PseudoVWREDSUM_VS_MF2_E32 = 11017, + RISCV_PseudoVWREDSUM_VS_MF2_E32_MASK = 11018, + RISCV_PseudoVWREDSUM_VS_MF2_E8 = 11019, + RISCV_PseudoVWREDSUM_VS_MF2_E8_MASK = 11020, + RISCV_PseudoVWREDSUM_VS_MF4_E16 = 11021, + RISCV_PseudoVWREDSUM_VS_MF4_E16_MASK = 11022, + RISCV_PseudoVWREDSUM_VS_MF4_E8 = 11023, + RISCV_PseudoVWREDSUM_VS_MF4_E8_MASK = 11024, + RISCV_PseudoVWREDSUM_VS_MF8_E8 = 11025, + RISCV_PseudoVWREDSUM_VS_MF8_E8_MASK = 11026, + RISCV_PseudoVWSLL_VI_M1 = 11027, + RISCV_PseudoVWSLL_VI_M1_MASK = 11028, + RISCV_PseudoVWSLL_VI_M2 = 11029, + RISCV_PseudoVWSLL_VI_M2_MASK = 11030, + RISCV_PseudoVWSLL_VI_M4 = 11031, + RISCV_PseudoVWSLL_VI_M4_MASK = 11032, + RISCV_PseudoVWSLL_VI_MF2 = 11033, + RISCV_PseudoVWSLL_VI_MF2_MASK = 11034, + RISCV_PseudoVWSLL_VI_MF4 = 11035, + RISCV_PseudoVWSLL_VI_MF4_MASK = 11036, + RISCV_PseudoVWSLL_VI_MF8 = 11037, + RISCV_PseudoVWSLL_VI_MF8_MASK = 11038, + RISCV_PseudoVWSLL_VV_M1 = 11039, + RISCV_PseudoVWSLL_VV_M1_MASK = 11040, + RISCV_PseudoVWSLL_VV_M2 = 11041, + RISCV_PseudoVWSLL_VV_M2_MASK = 11042, + RISCV_PseudoVWSLL_VV_M4 = 11043, + RISCV_PseudoVWSLL_VV_M4_MASK = 11044, + RISCV_PseudoVWSLL_VV_MF2 = 11045, + RISCV_PseudoVWSLL_VV_MF2_MASK = 11046, + RISCV_PseudoVWSLL_VV_MF4 = 11047, + RISCV_PseudoVWSLL_VV_MF4_MASK = 11048, + RISCV_PseudoVWSLL_VV_MF8 = 11049, + RISCV_PseudoVWSLL_VV_MF8_MASK = 11050, + RISCV_PseudoVWSLL_VX_M1 = 11051, + RISCV_PseudoVWSLL_VX_M1_MASK = 11052, + RISCV_PseudoVWSLL_VX_M2 = 11053, + RISCV_PseudoVWSLL_VX_M2_MASK = 11054, + RISCV_PseudoVWSLL_VX_M4 = 11055, + RISCV_PseudoVWSLL_VX_M4_MASK = 11056, + RISCV_PseudoVWSLL_VX_MF2 = 11057, + RISCV_PseudoVWSLL_VX_MF2_MASK = 11058, + RISCV_PseudoVWSLL_VX_MF4 = 11059, + RISCV_PseudoVWSLL_VX_MF4_MASK = 11060, + RISCV_PseudoVWSLL_VX_MF8 = 11061, + RISCV_PseudoVWSLL_VX_MF8_MASK = 11062, + RISCV_PseudoVWSUBU_VV_M1 = 11063, + RISCV_PseudoVWSUBU_VV_M1_MASK = 11064, + RISCV_PseudoVWSUBU_VV_M2 = 11065, + RISCV_PseudoVWSUBU_VV_M2_MASK = 11066, + RISCV_PseudoVWSUBU_VV_M4 = 11067, + RISCV_PseudoVWSUBU_VV_M4_MASK = 11068, + RISCV_PseudoVWSUBU_VV_MF2 = 11069, + RISCV_PseudoVWSUBU_VV_MF2_MASK = 11070, + RISCV_PseudoVWSUBU_VV_MF4 = 11071, + RISCV_PseudoVWSUBU_VV_MF4_MASK = 11072, + RISCV_PseudoVWSUBU_VV_MF8 = 11073, + RISCV_PseudoVWSUBU_VV_MF8_MASK = 11074, + RISCV_PseudoVWSUBU_VX_M1 = 11075, + RISCV_PseudoVWSUBU_VX_M1_MASK = 11076, + RISCV_PseudoVWSUBU_VX_M2 = 11077, + RISCV_PseudoVWSUBU_VX_M2_MASK = 11078, + RISCV_PseudoVWSUBU_VX_M4 = 11079, + RISCV_PseudoVWSUBU_VX_M4_MASK = 11080, + RISCV_PseudoVWSUBU_VX_MF2 = 11081, + RISCV_PseudoVWSUBU_VX_MF2_MASK = 11082, + RISCV_PseudoVWSUBU_VX_MF4 = 11083, + RISCV_PseudoVWSUBU_VX_MF4_MASK = 11084, + RISCV_PseudoVWSUBU_VX_MF8 = 11085, + RISCV_PseudoVWSUBU_VX_MF8_MASK = 11086, + RISCV_PseudoVWSUBU_WV_M1 = 11087, + RISCV_PseudoVWSUBU_WV_M1_MASK = 11088, + RISCV_PseudoVWSUBU_WV_M1_MASK_TIED = 11089, + RISCV_PseudoVWSUBU_WV_M1_TIED = 11090, + RISCV_PseudoVWSUBU_WV_M2 = 11091, + RISCV_PseudoVWSUBU_WV_M2_MASK = 11092, + RISCV_PseudoVWSUBU_WV_M2_MASK_TIED = 11093, + RISCV_PseudoVWSUBU_WV_M2_TIED = 11094, + RISCV_PseudoVWSUBU_WV_M4 = 11095, + RISCV_PseudoVWSUBU_WV_M4_MASK = 11096, + RISCV_PseudoVWSUBU_WV_M4_MASK_TIED = 11097, + RISCV_PseudoVWSUBU_WV_M4_TIED = 11098, + RISCV_PseudoVWSUBU_WV_MF2 = 11099, + RISCV_PseudoVWSUBU_WV_MF2_MASK = 11100, + RISCV_PseudoVWSUBU_WV_MF2_MASK_TIED = 11101, + RISCV_PseudoVWSUBU_WV_MF2_TIED = 11102, + RISCV_PseudoVWSUBU_WV_MF4 = 11103, + RISCV_PseudoVWSUBU_WV_MF4_MASK = 11104, + RISCV_PseudoVWSUBU_WV_MF4_MASK_TIED = 11105, + RISCV_PseudoVWSUBU_WV_MF4_TIED = 11106, + RISCV_PseudoVWSUBU_WV_MF8 = 11107, + RISCV_PseudoVWSUBU_WV_MF8_MASK = 11108, + RISCV_PseudoVWSUBU_WV_MF8_MASK_TIED = 11109, + RISCV_PseudoVWSUBU_WV_MF8_TIED = 11110, + RISCV_PseudoVWSUBU_WX_M1 = 11111, + RISCV_PseudoVWSUBU_WX_M1_MASK = 11112, + RISCV_PseudoVWSUBU_WX_M2 = 11113, + RISCV_PseudoVWSUBU_WX_M2_MASK = 11114, + RISCV_PseudoVWSUBU_WX_M4 = 11115, + RISCV_PseudoVWSUBU_WX_M4_MASK = 11116, + RISCV_PseudoVWSUBU_WX_MF2 = 11117, + RISCV_PseudoVWSUBU_WX_MF2_MASK = 11118, + RISCV_PseudoVWSUBU_WX_MF4 = 11119, + RISCV_PseudoVWSUBU_WX_MF4_MASK = 11120, + RISCV_PseudoVWSUBU_WX_MF8 = 11121, + RISCV_PseudoVWSUBU_WX_MF8_MASK = 11122, + RISCV_PseudoVWSUB_VV_M1 = 11123, + RISCV_PseudoVWSUB_VV_M1_MASK = 11124, + RISCV_PseudoVWSUB_VV_M2 = 11125, + RISCV_PseudoVWSUB_VV_M2_MASK = 11126, + RISCV_PseudoVWSUB_VV_M4 = 11127, + RISCV_PseudoVWSUB_VV_M4_MASK = 11128, + RISCV_PseudoVWSUB_VV_MF2 = 11129, + RISCV_PseudoVWSUB_VV_MF2_MASK = 11130, + RISCV_PseudoVWSUB_VV_MF4 = 11131, + RISCV_PseudoVWSUB_VV_MF4_MASK = 11132, + RISCV_PseudoVWSUB_VV_MF8 = 11133, + RISCV_PseudoVWSUB_VV_MF8_MASK = 11134, + RISCV_PseudoVWSUB_VX_M1 = 11135, + RISCV_PseudoVWSUB_VX_M1_MASK = 11136, + RISCV_PseudoVWSUB_VX_M2 = 11137, + RISCV_PseudoVWSUB_VX_M2_MASK = 11138, + RISCV_PseudoVWSUB_VX_M4 = 11139, + RISCV_PseudoVWSUB_VX_M4_MASK = 11140, + RISCV_PseudoVWSUB_VX_MF2 = 11141, + RISCV_PseudoVWSUB_VX_MF2_MASK = 11142, + RISCV_PseudoVWSUB_VX_MF4 = 11143, + RISCV_PseudoVWSUB_VX_MF4_MASK = 11144, + RISCV_PseudoVWSUB_VX_MF8 = 11145, + RISCV_PseudoVWSUB_VX_MF8_MASK = 11146, + RISCV_PseudoVWSUB_WV_M1 = 11147, + RISCV_PseudoVWSUB_WV_M1_MASK = 11148, + RISCV_PseudoVWSUB_WV_M1_MASK_TIED = 11149, + RISCV_PseudoVWSUB_WV_M1_TIED = 11150, + RISCV_PseudoVWSUB_WV_M2 = 11151, + RISCV_PseudoVWSUB_WV_M2_MASK = 11152, + RISCV_PseudoVWSUB_WV_M2_MASK_TIED = 11153, + RISCV_PseudoVWSUB_WV_M2_TIED = 11154, + RISCV_PseudoVWSUB_WV_M4 = 11155, + RISCV_PseudoVWSUB_WV_M4_MASK = 11156, + RISCV_PseudoVWSUB_WV_M4_MASK_TIED = 11157, + RISCV_PseudoVWSUB_WV_M4_TIED = 11158, + RISCV_PseudoVWSUB_WV_MF2 = 11159, + RISCV_PseudoVWSUB_WV_MF2_MASK = 11160, + RISCV_PseudoVWSUB_WV_MF2_MASK_TIED = 11161, + RISCV_PseudoVWSUB_WV_MF2_TIED = 11162, + RISCV_PseudoVWSUB_WV_MF4 = 11163, + RISCV_PseudoVWSUB_WV_MF4_MASK = 11164, + RISCV_PseudoVWSUB_WV_MF4_MASK_TIED = 11165, + RISCV_PseudoVWSUB_WV_MF4_TIED = 11166, + RISCV_PseudoVWSUB_WV_MF8 = 11167, + RISCV_PseudoVWSUB_WV_MF8_MASK = 11168, + RISCV_PseudoVWSUB_WV_MF8_MASK_TIED = 11169, + RISCV_PseudoVWSUB_WV_MF8_TIED = 11170, + RISCV_PseudoVWSUB_WX_M1 = 11171, + RISCV_PseudoVWSUB_WX_M1_MASK = 11172, + RISCV_PseudoVWSUB_WX_M2 = 11173, + RISCV_PseudoVWSUB_WX_M2_MASK = 11174, + RISCV_PseudoVWSUB_WX_M4 = 11175, + RISCV_PseudoVWSUB_WX_M4_MASK = 11176, + RISCV_PseudoVWSUB_WX_MF2 = 11177, + RISCV_PseudoVWSUB_WX_MF2_MASK = 11178, + RISCV_PseudoVWSUB_WX_MF4 = 11179, + RISCV_PseudoVWSUB_WX_MF4_MASK = 11180, + RISCV_PseudoVWSUB_WX_MF8 = 11181, + RISCV_PseudoVWSUB_WX_MF8_MASK = 11182, + RISCV_PseudoVXOR_VI_M1 = 11183, + RISCV_PseudoVXOR_VI_M1_MASK = 11184, + RISCV_PseudoVXOR_VI_M2 = 11185, + RISCV_PseudoVXOR_VI_M2_MASK = 11186, + RISCV_PseudoVXOR_VI_M4 = 11187, + RISCV_PseudoVXOR_VI_M4_MASK = 11188, + RISCV_PseudoVXOR_VI_M8 = 11189, + RISCV_PseudoVXOR_VI_M8_MASK = 11190, + RISCV_PseudoVXOR_VI_MF2 = 11191, + RISCV_PseudoVXOR_VI_MF2_MASK = 11192, + RISCV_PseudoVXOR_VI_MF4 = 11193, + RISCV_PseudoVXOR_VI_MF4_MASK = 11194, + RISCV_PseudoVXOR_VI_MF8 = 11195, + RISCV_PseudoVXOR_VI_MF8_MASK = 11196, + RISCV_PseudoVXOR_VV_M1 = 11197, + RISCV_PseudoVXOR_VV_M1_MASK = 11198, + RISCV_PseudoVXOR_VV_M2 = 11199, + RISCV_PseudoVXOR_VV_M2_MASK = 11200, + RISCV_PseudoVXOR_VV_M4 = 11201, + RISCV_PseudoVXOR_VV_M4_MASK = 11202, + RISCV_PseudoVXOR_VV_M8 = 11203, + RISCV_PseudoVXOR_VV_M8_MASK = 11204, + RISCV_PseudoVXOR_VV_MF2 = 11205, + RISCV_PseudoVXOR_VV_MF2_MASK = 11206, + RISCV_PseudoVXOR_VV_MF4 = 11207, + RISCV_PseudoVXOR_VV_MF4_MASK = 11208, + RISCV_PseudoVXOR_VV_MF8 = 11209, + RISCV_PseudoVXOR_VV_MF8_MASK = 11210, + RISCV_PseudoVXOR_VX_M1 = 11211, + RISCV_PseudoVXOR_VX_M1_MASK = 11212, + RISCV_PseudoVXOR_VX_M2 = 11213, + RISCV_PseudoVXOR_VX_M2_MASK = 11214, + RISCV_PseudoVXOR_VX_M4 = 11215, + RISCV_PseudoVXOR_VX_M4_MASK = 11216, + RISCV_PseudoVXOR_VX_M8 = 11217, + RISCV_PseudoVXOR_VX_M8_MASK = 11218, + RISCV_PseudoVXOR_VX_MF2 = 11219, + RISCV_PseudoVXOR_VX_MF2_MASK = 11220, + RISCV_PseudoVXOR_VX_MF4 = 11221, + RISCV_PseudoVXOR_VX_MF4_MASK = 11222, + RISCV_PseudoVXOR_VX_MF8 = 11223, + RISCV_PseudoVXOR_VX_MF8_MASK = 11224, + RISCV_PseudoVZEXT_VF2_M1 = 11225, + RISCV_PseudoVZEXT_VF2_M1_MASK = 11226, + RISCV_PseudoVZEXT_VF2_M2 = 11227, + RISCV_PseudoVZEXT_VF2_M2_MASK = 11228, + RISCV_PseudoVZEXT_VF2_M4 = 11229, + RISCV_PseudoVZEXT_VF2_M4_MASK = 11230, + RISCV_PseudoVZEXT_VF2_M8 = 11231, + RISCV_PseudoVZEXT_VF2_M8_MASK = 11232, + RISCV_PseudoVZEXT_VF2_MF2 = 11233, + RISCV_PseudoVZEXT_VF2_MF2_MASK = 11234, + RISCV_PseudoVZEXT_VF2_MF4 = 11235, + RISCV_PseudoVZEXT_VF2_MF4_MASK = 11236, + RISCV_PseudoVZEXT_VF4_M1 = 11237, + RISCV_PseudoVZEXT_VF4_M1_MASK = 11238, + RISCV_PseudoVZEXT_VF4_M2 = 11239, + RISCV_PseudoVZEXT_VF4_M2_MASK = 11240, + RISCV_PseudoVZEXT_VF4_M4 = 11241, + RISCV_PseudoVZEXT_VF4_M4_MASK = 11242, + RISCV_PseudoVZEXT_VF4_M8 = 11243, + RISCV_PseudoVZEXT_VF4_M8_MASK = 11244, + RISCV_PseudoVZEXT_VF4_MF2 = 11245, + RISCV_PseudoVZEXT_VF4_MF2_MASK = 11246, + RISCV_PseudoVZEXT_VF8_M1 = 11247, + RISCV_PseudoVZEXT_VF8_M1_MASK = 11248, + RISCV_PseudoVZEXT_VF8_M2 = 11249, + RISCV_PseudoVZEXT_VF8_M2_MASK = 11250, + RISCV_PseudoVZEXT_VF8_M4 = 11251, + RISCV_PseudoVZEXT_VF8_M4_MASK = 11252, + RISCV_PseudoVZEXT_VF8_M8 = 11253, + RISCV_PseudoVZEXT_VF8_M8_MASK = 11254, + RISCV_PseudoZEXT_H = 11255, + RISCV_PseudoZEXT_W = 11256, + RISCV_ReadCycleWide = 11257, + RISCV_ReadFFLAGS = 11258, + RISCV_ReadFRM = 11259, + RISCV_Select_FPR16INX_Using_CC_GPR = 11260, + RISCV_Select_FPR16_Using_CC_GPR = 11261, + RISCV_Select_FPR32INX_Using_CC_GPR = 11262, + RISCV_Select_FPR32_Using_CC_GPR = 11263, + RISCV_Select_FPR64IN32X_Using_CC_GPR = 11264, + RISCV_Select_FPR64INX_Using_CC_GPR = 11265, + RISCV_Select_FPR64_Using_CC_GPR = 11266, + RISCV_Select_GPR_Using_CC_GPR = 11267, + RISCV_SplitF64Pseudo = 11268, + RISCV_SplitF64Pseudo_INX = 11269, + RISCV_SwapFRMImm = 11270, + RISCV_WriteFFLAGS = 11271, + RISCV_WriteFRM = 11272, + RISCV_WriteFRMImm = 11273, + RISCV_WriteVXRMImm = 11274, + RISCV_ADD = 11275, + RISCV_ADDI = 11276, + RISCV_ADDIW = 11277, + RISCV_ADDW = 11278, + RISCV_ADD_UW = 11279, + RISCV_AES32DSI = 11280, + RISCV_AES32DSMI = 11281, + RISCV_AES32ESI = 11282, + RISCV_AES32ESMI = 11283, + RISCV_AES64DS = 11284, + RISCV_AES64DSM = 11285, + RISCV_AES64ES = 11286, + RISCV_AES64ESM = 11287, + RISCV_AES64IM = 11288, + RISCV_AES64KS1I = 11289, + RISCV_AES64KS2 = 11290, + RISCV_AMOADD_D = 11291, + RISCV_AMOADD_D_AQ = 11292, + RISCV_AMOADD_D_AQ_RL = 11293, + RISCV_AMOADD_D_RL = 11294, + RISCV_AMOADD_W = 11295, + RISCV_AMOADD_W_AQ = 11296, + RISCV_AMOADD_W_AQ_RL = 11297, + RISCV_AMOADD_W_RL = 11298, + RISCV_AMOAND_D = 11299, + RISCV_AMOAND_D_AQ = 11300, + RISCV_AMOAND_D_AQ_RL = 11301, + RISCV_AMOAND_D_RL = 11302, + RISCV_AMOAND_W = 11303, + RISCV_AMOAND_W_AQ = 11304, + RISCV_AMOAND_W_AQ_RL = 11305, + RISCV_AMOAND_W_RL = 11306, + RISCV_AMOCAS_D_RV32 = 11307, + RISCV_AMOCAS_D_RV32_AQ = 11308, + RISCV_AMOCAS_D_RV32_AQ_RL = 11309, + RISCV_AMOCAS_D_RV32_RL = 11310, + RISCV_AMOCAS_D_RV64 = 11311, + RISCV_AMOCAS_D_RV64_AQ = 11312, + RISCV_AMOCAS_D_RV64_AQ_RL = 11313, + RISCV_AMOCAS_D_RV64_RL = 11314, + RISCV_AMOCAS_Q = 11315, + RISCV_AMOCAS_Q_AQ = 11316, + RISCV_AMOCAS_Q_AQ_RL = 11317, + RISCV_AMOCAS_Q_RL = 11318, + RISCV_AMOCAS_W = 11319, + RISCV_AMOCAS_W_AQ = 11320, + RISCV_AMOCAS_W_AQ_RL = 11321, + RISCV_AMOCAS_W_RL = 11322, + RISCV_AMOMAXU_D = 11323, + RISCV_AMOMAXU_D_AQ = 11324, + RISCV_AMOMAXU_D_AQ_RL = 11325, + RISCV_AMOMAXU_D_RL = 11326, + RISCV_AMOMAXU_W = 11327, + RISCV_AMOMAXU_W_AQ = 11328, + RISCV_AMOMAXU_W_AQ_RL = 11329, + RISCV_AMOMAXU_W_RL = 11330, + RISCV_AMOMAX_D = 11331, + RISCV_AMOMAX_D_AQ = 11332, + RISCV_AMOMAX_D_AQ_RL = 11333, + RISCV_AMOMAX_D_RL = 11334, + RISCV_AMOMAX_W = 11335, + RISCV_AMOMAX_W_AQ = 11336, + RISCV_AMOMAX_W_AQ_RL = 11337, + RISCV_AMOMAX_W_RL = 11338, + RISCV_AMOMINU_D = 11339, + RISCV_AMOMINU_D_AQ = 11340, + RISCV_AMOMINU_D_AQ_RL = 11341, + RISCV_AMOMINU_D_RL = 11342, + RISCV_AMOMINU_W = 11343, + RISCV_AMOMINU_W_AQ = 11344, + RISCV_AMOMINU_W_AQ_RL = 11345, + RISCV_AMOMINU_W_RL = 11346, + RISCV_AMOMIN_D = 11347, + RISCV_AMOMIN_D_AQ = 11348, + RISCV_AMOMIN_D_AQ_RL = 11349, + RISCV_AMOMIN_D_RL = 11350, + RISCV_AMOMIN_W = 11351, + RISCV_AMOMIN_W_AQ = 11352, + RISCV_AMOMIN_W_AQ_RL = 11353, + RISCV_AMOMIN_W_RL = 11354, + RISCV_AMOOR_D = 11355, + RISCV_AMOOR_D_AQ = 11356, + RISCV_AMOOR_D_AQ_RL = 11357, + RISCV_AMOOR_D_RL = 11358, + RISCV_AMOOR_W = 11359, + RISCV_AMOOR_W_AQ = 11360, + RISCV_AMOOR_W_AQ_RL = 11361, + RISCV_AMOOR_W_RL = 11362, + RISCV_AMOSWAP_D = 11363, + RISCV_AMOSWAP_D_AQ = 11364, + RISCV_AMOSWAP_D_AQ_RL = 11365, + RISCV_AMOSWAP_D_RL = 11366, + RISCV_AMOSWAP_W = 11367, + RISCV_AMOSWAP_W_AQ = 11368, + RISCV_AMOSWAP_W_AQ_RL = 11369, + RISCV_AMOSWAP_W_RL = 11370, + RISCV_AMOXOR_D = 11371, + RISCV_AMOXOR_D_AQ = 11372, + RISCV_AMOXOR_D_AQ_RL = 11373, + RISCV_AMOXOR_D_RL = 11374, + RISCV_AMOXOR_W = 11375, + RISCV_AMOXOR_W_AQ = 11376, + RISCV_AMOXOR_W_AQ_RL = 11377, + RISCV_AMOXOR_W_RL = 11378, + RISCV_AND = 11379, + RISCV_ANDI = 11380, + RISCV_ANDN = 11381, + RISCV_AUIPC = 11382, + RISCV_BCLR = 11383, + RISCV_BCLRI = 11384, + RISCV_BEQ = 11385, + RISCV_BEXT = 11386, + RISCV_BEXTI = 11387, + RISCV_BGE = 11388, + RISCV_BGEU = 11389, + RISCV_BINV = 11390, + RISCV_BINVI = 11391, + RISCV_BLT = 11392, + RISCV_BLTU = 11393, + RISCV_BNE = 11394, + RISCV_BREV8 = 11395, + RISCV_BSET = 11396, + RISCV_BSETI = 11397, + RISCV_CBO_CLEAN = 11398, + RISCV_CBO_FLUSH = 11399, + RISCV_CBO_INVAL = 11400, + RISCV_CBO_ZERO = 11401, + RISCV_CLMUL = 11402, + RISCV_CLMULH = 11403, + RISCV_CLMULR = 11404, + RISCV_CLZ = 11405, + RISCV_CLZW = 11406, + RISCV_CMOP1 = 11407, + RISCV_CMOP11 = 11408, + RISCV_CMOP13 = 11409, + RISCV_CMOP15 = 11410, + RISCV_CMOP3 = 11411, + RISCV_CMOP5 = 11412, + RISCV_CMOP7 = 11413, + RISCV_CMOP9 = 11414, + RISCV_CM_JALT = 11415, + RISCV_CM_JT = 11416, + RISCV_CM_MVA01S = 11417, + RISCV_CM_MVSA01 = 11418, + RISCV_CM_POP = 11419, + RISCV_CM_POPRET = 11420, + RISCV_CM_POPRETZ = 11421, + RISCV_CM_PUSH = 11422, + RISCV_CPOP = 11423, + RISCV_CPOPW = 11424, + RISCV_CSRRC = 11425, + RISCV_CSRRCI = 11426, + RISCV_CSRRS = 11427, + RISCV_CSRRSI = 11428, + RISCV_CSRRW = 11429, + RISCV_CSRRWI = 11430, + RISCV_CTZ = 11431, + RISCV_CTZW = 11432, + RISCV_CV_ABS = 11433, + RISCV_CV_ABS_B = 11434, + RISCV_CV_ABS_H = 11435, + RISCV_CV_ADDN = 11436, + RISCV_CV_ADDNR = 11437, + RISCV_CV_ADDRN = 11438, + RISCV_CV_ADDRNR = 11439, + RISCV_CV_ADDUN = 11440, + RISCV_CV_ADDUNR = 11441, + RISCV_CV_ADDURN = 11442, + RISCV_CV_ADDURNR = 11443, + RISCV_CV_ADD_B = 11444, + RISCV_CV_ADD_DIV2 = 11445, + RISCV_CV_ADD_DIV4 = 11446, + RISCV_CV_ADD_DIV8 = 11447, + RISCV_CV_ADD_H = 11448, + RISCV_CV_ADD_SCI_B = 11449, + RISCV_CV_ADD_SCI_H = 11450, + RISCV_CV_ADD_SC_B = 11451, + RISCV_CV_ADD_SC_H = 11452, + RISCV_CV_AND_B = 11453, + RISCV_CV_AND_H = 11454, + RISCV_CV_AND_SCI_B = 11455, + RISCV_CV_AND_SCI_H = 11456, + RISCV_CV_AND_SC_B = 11457, + RISCV_CV_AND_SC_H = 11458, + RISCV_CV_AVGU_B = 11459, + RISCV_CV_AVGU_H = 11460, + RISCV_CV_AVGU_SCI_B = 11461, + RISCV_CV_AVGU_SCI_H = 11462, + RISCV_CV_AVGU_SC_B = 11463, + RISCV_CV_AVGU_SC_H = 11464, + RISCV_CV_AVG_B = 11465, + RISCV_CV_AVG_H = 11466, + RISCV_CV_AVG_SCI_B = 11467, + RISCV_CV_AVG_SCI_H = 11468, + RISCV_CV_AVG_SC_B = 11469, + RISCV_CV_AVG_SC_H = 11470, + RISCV_CV_BCLR = 11471, + RISCV_CV_BCLRR = 11472, + RISCV_CV_BEQIMM = 11473, + RISCV_CV_BITREV = 11474, + RISCV_CV_BNEIMM = 11475, + RISCV_CV_BSET = 11476, + RISCV_CV_BSETR = 11477, + RISCV_CV_CLB = 11478, + RISCV_CV_CLIP = 11479, + RISCV_CV_CLIPR = 11480, + RISCV_CV_CLIPU = 11481, + RISCV_CV_CLIPUR = 11482, + RISCV_CV_CMPEQ_B = 11483, + RISCV_CV_CMPEQ_H = 11484, + RISCV_CV_CMPEQ_SCI_B = 11485, + RISCV_CV_CMPEQ_SCI_H = 11486, + RISCV_CV_CMPEQ_SC_B = 11487, + RISCV_CV_CMPEQ_SC_H = 11488, + RISCV_CV_CMPGEU_B = 11489, + RISCV_CV_CMPGEU_H = 11490, + RISCV_CV_CMPGEU_SCI_B = 11491, + RISCV_CV_CMPGEU_SCI_H = 11492, + RISCV_CV_CMPGEU_SC_B = 11493, + RISCV_CV_CMPGEU_SC_H = 11494, + RISCV_CV_CMPGE_B = 11495, + RISCV_CV_CMPGE_H = 11496, + RISCV_CV_CMPGE_SCI_B = 11497, + RISCV_CV_CMPGE_SCI_H = 11498, + RISCV_CV_CMPGE_SC_B = 11499, + RISCV_CV_CMPGE_SC_H = 11500, + RISCV_CV_CMPGTU_B = 11501, + RISCV_CV_CMPGTU_H = 11502, + RISCV_CV_CMPGTU_SCI_B = 11503, + RISCV_CV_CMPGTU_SCI_H = 11504, + RISCV_CV_CMPGTU_SC_B = 11505, + RISCV_CV_CMPGTU_SC_H = 11506, + RISCV_CV_CMPGT_B = 11507, + RISCV_CV_CMPGT_H = 11508, + RISCV_CV_CMPGT_SCI_B = 11509, + RISCV_CV_CMPGT_SCI_H = 11510, + RISCV_CV_CMPGT_SC_B = 11511, + RISCV_CV_CMPGT_SC_H = 11512, + RISCV_CV_CMPLEU_B = 11513, + RISCV_CV_CMPLEU_H = 11514, + RISCV_CV_CMPLEU_SCI_B = 11515, + RISCV_CV_CMPLEU_SCI_H = 11516, + RISCV_CV_CMPLEU_SC_B = 11517, + RISCV_CV_CMPLEU_SC_H = 11518, + RISCV_CV_CMPLE_B = 11519, + RISCV_CV_CMPLE_H = 11520, + RISCV_CV_CMPLE_SCI_B = 11521, + RISCV_CV_CMPLE_SCI_H = 11522, + RISCV_CV_CMPLE_SC_B = 11523, + RISCV_CV_CMPLE_SC_H = 11524, + RISCV_CV_CMPLTU_B = 11525, + RISCV_CV_CMPLTU_H = 11526, + RISCV_CV_CMPLTU_SCI_B = 11527, + RISCV_CV_CMPLTU_SCI_H = 11528, + RISCV_CV_CMPLTU_SC_B = 11529, + RISCV_CV_CMPLTU_SC_H = 11530, + RISCV_CV_CMPLT_B = 11531, + RISCV_CV_CMPLT_H = 11532, + RISCV_CV_CMPLT_SCI_B = 11533, + RISCV_CV_CMPLT_SCI_H = 11534, + RISCV_CV_CMPLT_SC_B = 11535, + RISCV_CV_CMPLT_SC_H = 11536, + RISCV_CV_CMPNE_B = 11537, + RISCV_CV_CMPNE_H = 11538, + RISCV_CV_CMPNE_SCI_B = 11539, + RISCV_CV_CMPNE_SCI_H = 11540, + RISCV_CV_CMPNE_SC_B = 11541, + RISCV_CV_CMPNE_SC_H = 11542, + RISCV_CV_CNT = 11543, + RISCV_CV_CPLXCONJ = 11544, + RISCV_CV_CPLXMUL_I = 11545, + RISCV_CV_CPLXMUL_I_DIV2 = 11546, + RISCV_CV_CPLXMUL_I_DIV4 = 11547, + RISCV_CV_CPLXMUL_I_DIV8 = 11548, + RISCV_CV_CPLXMUL_R = 11549, + RISCV_CV_CPLXMUL_R_DIV2 = 11550, + RISCV_CV_CPLXMUL_R_DIV4 = 11551, + RISCV_CV_CPLXMUL_R_DIV8 = 11552, + RISCV_CV_DOTSP_B = 11553, + RISCV_CV_DOTSP_H = 11554, + RISCV_CV_DOTSP_SCI_B = 11555, + RISCV_CV_DOTSP_SCI_H = 11556, + RISCV_CV_DOTSP_SC_B = 11557, + RISCV_CV_DOTSP_SC_H = 11558, + RISCV_CV_DOTUP_B = 11559, + RISCV_CV_DOTUP_H = 11560, + RISCV_CV_DOTUP_SCI_B = 11561, + RISCV_CV_DOTUP_SCI_H = 11562, + RISCV_CV_DOTUP_SC_B = 11563, + RISCV_CV_DOTUP_SC_H = 11564, + RISCV_CV_DOTUSP_B = 11565, + RISCV_CV_DOTUSP_H = 11566, + RISCV_CV_DOTUSP_SCI_B = 11567, + RISCV_CV_DOTUSP_SCI_H = 11568, + RISCV_CV_DOTUSP_SC_B = 11569, + RISCV_CV_DOTUSP_SC_H = 11570, + RISCV_CV_ELW = 11571, + RISCV_CV_EXTBS = 11572, + RISCV_CV_EXTBZ = 11573, + RISCV_CV_EXTHS = 11574, + RISCV_CV_EXTHZ = 11575, + RISCV_CV_EXTRACT = 11576, + RISCV_CV_EXTRACTR = 11577, + RISCV_CV_EXTRACTU = 11578, + RISCV_CV_EXTRACTUR = 11579, + RISCV_CV_EXTRACTU_B = 11580, + RISCV_CV_EXTRACTU_H = 11581, + RISCV_CV_EXTRACT_B = 11582, + RISCV_CV_EXTRACT_H = 11583, + RISCV_CV_FF1 = 11584, + RISCV_CV_FL1 = 11585, + RISCV_CV_INSERT = 11586, + RISCV_CV_INSERTR = 11587, + RISCV_CV_INSERT_B = 11588, + RISCV_CV_INSERT_H = 11589, + RISCV_CV_LBU_ri_inc = 11590, + RISCV_CV_LBU_rr = 11591, + RISCV_CV_LBU_rr_inc = 11592, + RISCV_CV_LB_ri_inc = 11593, + RISCV_CV_LB_rr = 11594, + RISCV_CV_LB_rr_inc = 11595, + RISCV_CV_LHU_ri_inc = 11596, + RISCV_CV_LHU_rr = 11597, + RISCV_CV_LHU_rr_inc = 11598, + RISCV_CV_LH_ri_inc = 11599, + RISCV_CV_LH_rr = 11600, + RISCV_CV_LH_rr_inc = 11601, + RISCV_CV_LW_ri_inc = 11602, + RISCV_CV_LW_rr = 11603, + RISCV_CV_LW_rr_inc = 11604, + RISCV_CV_MAC = 11605, + RISCV_CV_MACHHSN = 11606, + RISCV_CV_MACHHSRN = 11607, + RISCV_CV_MACHHUN = 11608, + RISCV_CV_MACHHURN = 11609, + RISCV_CV_MACSN = 11610, + RISCV_CV_MACSRN = 11611, + RISCV_CV_MACUN = 11612, + RISCV_CV_MACURN = 11613, + RISCV_CV_MAX = 11614, + RISCV_CV_MAXU = 11615, + RISCV_CV_MAXU_B = 11616, + RISCV_CV_MAXU_H = 11617, + RISCV_CV_MAXU_SCI_B = 11618, + RISCV_CV_MAXU_SCI_H = 11619, + RISCV_CV_MAXU_SC_B = 11620, + RISCV_CV_MAXU_SC_H = 11621, + RISCV_CV_MAX_B = 11622, + RISCV_CV_MAX_H = 11623, + RISCV_CV_MAX_SCI_B = 11624, + RISCV_CV_MAX_SCI_H = 11625, + RISCV_CV_MAX_SC_B = 11626, + RISCV_CV_MAX_SC_H = 11627, + RISCV_CV_MIN = 11628, + RISCV_CV_MINU = 11629, + RISCV_CV_MINU_B = 11630, + RISCV_CV_MINU_H = 11631, + RISCV_CV_MINU_SCI_B = 11632, + RISCV_CV_MINU_SCI_H = 11633, + RISCV_CV_MINU_SC_B = 11634, + RISCV_CV_MINU_SC_H = 11635, + RISCV_CV_MIN_B = 11636, + RISCV_CV_MIN_H = 11637, + RISCV_CV_MIN_SCI_B = 11638, + RISCV_CV_MIN_SCI_H = 11639, + RISCV_CV_MIN_SC_B = 11640, + RISCV_CV_MIN_SC_H = 11641, + RISCV_CV_MSU = 11642, + RISCV_CV_MULHHSN = 11643, + RISCV_CV_MULHHSRN = 11644, + RISCV_CV_MULHHUN = 11645, + RISCV_CV_MULHHURN = 11646, + RISCV_CV_MULSN = 11647, + RISCV_CV_MULSRN = 11648, + RISCV_CV_MULUN = 11649, + RISCV_CV_MULURN = 11650, + RISCV_CV_OR_B = 11651, + RISCV_CV_OR_H = 11652, + RISCV_CV_OR_SCI_B = 11653, + RISCV_CV_OR_SCI_H = 11654, + RISCV_CV_OR_SC_B = 11655, + RISCV_CV_OR_SC_H = 11656, + RISCV_CV_PACK = 11657, + RISCV_CV_PACKHI_B = 11658, + RISCV_CV_PACKLO_B = 11659, + RISCV_CV_PACK_H = 11660, + RISCV_CV_ROR = 11661, + RISCV_CV_SB_ri_inc = 11662, + RISCV_CV_SB_rr = 11663, + RISCV_CV_SB_rr_inc = 11664, + RISCV_CV_SDOTSP_B = 11665, + RISCV_CV_SDOTSP_H = 11666, + RISCV_CV_SDOTSP_SCI_B = 11667, + RISCV_CV_SDOTSP_SCI_H = 11668, + RISCV_CV_SDOTSP_SC_B = 11669, + RISCV_CV_SDOTSP_SC_H = 11670, + RISCV_CV_SDOTUP_B = 11671, + RISCV_CV_SDOTUP_H = 11672, + RISCV_CV_SDOTUP_SCI_B = 11673, + RISCV_CV_SDOTUP_SCI_H = 11674, + RISCV_CV_SDOTUP_SC_B = 11675, + RISCV_CV_SDOTUP_SC_H = 11676, + RISCV_CV_SDOTUSP_B = 11677, + RISCV_CV_SDOTUSP_H = 11678, + RISCV_CV_SDOTUSP_SCI_B = 11679, + RISCV_CV_SDOTUSP_SCI_H = 11680, + RISCV_CV_SDOTUSP_SC_B = 11681, + RISCV_CV_SDOTUSP_SC_H = 11682, + RISCV_CV_SHUFFLE2_B = 11683, + RISCV_CV_SHUFFLE2_H = 11684, + RISCV_CV_SHUFFLEI0_SCI_B = 11685, + RISCV_CV_SHUFFLEI1_SCI_B = 11686, + RISCV_CV_SHUFFLEI2_SCI_B = 11687, + RISCV_CV_SHUFFLEI3_SCI_B = 11688, + RISCV_CV_SHUFFLE_B = 11689, + RISCV_CV_SHUFFLE_H = 11690, + RISCV_CV_SHUFFLE_SCI_H = 11691, + RISCV_CV_SH_ri_inc = 11692, + RISCV_CV_SH_rr = 11693, + RISCV_CV_SH_rr_inc = 11694, + RISCV_CV_SLET = 11695, + RISCV_CV_SLETU = 11696, + RISCV_CV_SLL_B = 11697, + RISCV_CV_SLL_H = 11698, + RISCV_CV_SLL_SCI_B = 11699, + RISCV_CV_SLL_SCI_H = 11700, + RISCV_CV_SLL_SC_B = 11701, + RISCV_CV_SLL_SC_H = 11702, + RISCV_CV_SRA_B = 11703, + RISCV_CV_SRA_H = 11704, + RISCV_CV_SRA_SCI_B = 11705, + RISCV_CV_SRA_SCI_H = 11706, + RISCV_CV_SRA_SC_B = 11707, + RISCV_CV_SRA_SC_H = 11708, + RISCV_CV_SRL_B = 11709, + RISCV_CV_SRL_H = 11710, + RISCV_CV_SRL_SCI_B = 11711, + RISCV_CV_SRL_SCI_H = 11712, + RISCV_CV_SRL_SC_B = 11713, + RISCV_CV_SRL_SC_H = 11714, + RISCV_CV_SUBN = 11715, + RISCV_CV_SUBNR = 11716, + RISCV_CV_SUBRN = 11717, + RISCV_CV_SUBRNR = 11718, + RISCV_CV_SUBROTMJ = 11719, + RISCV_CV_SUBROTMJ_DIV2 = 11720, + RISCV_CV_SUBROTMJ_DIV4 = 11721, + RISCV_CV_SUBROTMJ_DIV8 = 11722, + RISCV_CV_SUBUN = 11723, + RISCV_CV_SUBUNR = 11724, + RISCV_CV_SUBURN = 11725, + RISCV_CV_SUBURNR = 11726, + RISCV_CV_SUB_B = 11727, + RISCV_CV_SUB_DIV2 = 11728, + RISCV_CV_SUB_DIV4 = 11729, + RISCV_CV_SUB_DIV8 = 11730, + RISCV_CV_SUB_H = 11731, + RISCV_CV_SUB_SCI_B = 11732, + RISCV_CV_SUB_SCI_H = 11733, + RISCV_CV_SUB_SC_B = 11734, + RISCV_CV_SUB_SC_H = 11735, + RISCV_CV_SW_ri_inc = 11736, + RISCV_CV_SW_rr = 11737, + RISCV_CV_SW_rr_inc = 11738, + RISCV_CV_XOR_B = 11739, + RISCV_CV_XOR_H = 11740, + RISCV_CV_XOR_SCI_B = 11741, + RISCV_CV_XOR_SCI_H = 11742, + RISCV_CV_XOR_SC_B = 11743, + RISCV_CV_XOR_SC_H = 11744, + RISCV_CZERO_EQZ = 11745, + RISCV_CZERO_NEZ = 11746, + RISCV_C_ADD = 11747, + RISCV_C_ADDI = 11748, + RISCV_C_ADDI16SP = 11749, + RISCV_C_ADDI4SPN = 11750, + RISCV_C_ADDIW = 11751, + RISCV_C_ADDI_HINT_IMM_ZERO = 11752, + RISCV_C_ADDI_NOP = 11753, + RISCV_C_ADDW = 11754, + RISCV_C_ADD_HINT = 11755, + RISCV_C_AND = 11756, + RISCV_C_ANDI = 11757, + RISCV_C_BEQZ = 11758, + RISCV_C_BNEZ = 11759, + RISCV_C_EBREAK = 11760, + RISCV_C_FLD = 11761, + RISCV_C_FLDSP = 11762, + RISCV_C_FLW = 11763, + RISCV_C_FLWSP = 11764, + RISCV_C_FSD = 11765, + RISCV_C_FSDSP = 11766, + RISCV_C_FSW = 11767, + RISCV_C_FSWSP = 11768, + RISCV_C_J = 11769, + RISCV_C_JAL = 11770, + RISCV_C_JALR = 11771, + RISCV_C_JR = 11772, + RISCV_C_LBU = 11773, + RISCV_C_LD = 11774, + RISCV_C_LDSP = 11775, + RISCV_C_LH = 11776, + RISCV_C_LHU = 11777, + RISCV_C_LI = 11778, + RISCV_C_LI_HINT = 11779, + RISCV_C_LUI = 11780, + RISCV_C_LUI_HINT = 11781, + RISCV_C_LW = 11782, + RISCV_C_LWSP = 11783, + RISCV_C_MUL = 11784, + RISCV_C_MV = 11785, + RISCV_C_MV_HINT = 11786, + RISCV_C_NOP = 11787, + RISCV_C_NOP_HINT = 11788, + RISCV_C_NOT = 11789, + RISCV_C_OR = 11790, + RISCV_C_SB = 11791, + RISCV_C_SD = 11792, + RISCV_C_SDSP = 11793, + RISCV_C_SEXT_B = 11794, + RISCV_C_SEXT_H = 11795, + RISCV_C_SH = 11796, + RISCV_C_SLLI = 11797, + RISCV_C_SLLI64_HINT = 11798, + RISCV_C_SLLI_HINT = 11799, + RISCV_C_SRAI = 11800, + RISCV_C_SRAI64_HINT = 11801, + RISCV_C_SRLI = 11802, + RISCV_C_SRLI64_HINT = 11803, + RISCV_C_SSPOPCHK = 11804, + RISCV_C_SSPUSH = 11805, + RISCV_C_SUB = 11806, + RISCV_C_SUBW = 11807, + RISCV_C_SW = 11808, + RISCV_C_SWSP = 11809, + RISCV_C_UNIMP = 11810, + RISCV_C_XOR = 11811, + RISCV_C_ZEXT_B = 11812, + RISCV_C_ZEXT_H = 11813, + RISCV_C_ZEXT_W = 11814, + RISCV_DIV = 11815, + RISCV_DIVU = 11816, + RISCV_DIVUW = 11817, + RISCV_DIVW = 11818, + RISCV_DRET = 11819, + RISCV_EBREAK = 11820, + RISCV_ECALL = 11821, + RISCV_FADD_D = 11822, + RISCV_FADD_D_IN32X = 11823, + RISCV_FADD_D_INX = 11824, + RISCV_FADD_H = 11825, + RISCV_FADD_H_INX = 11826, + RISCV_FADD_S = 11827, + RISCV_FADD_S_INX = 11828, + RISCV_FCLASS_D = 11829, + RISCV_FCLASS_D_IN32X = 11830, + RISCV_FCLASS_D_INX = 11831, + RISCV_FCLASS_H = 11832, + RISCV_FCLASS_H_INX = 11833, + RISCV_FCLASS_S = 11834, + RISCV_FCLASS_S_INX = 11835, + RISCV_FCVTMOD_W_D = 11836, + RISCV_FCVT_BF16_S = 11837, + RISCV_FCVT_D_H = 11838, + RISCV_FCVT_D_H_IN32X = 11839, + RISCV_FCVT_D_H_INX = 11840, + RISCV_FCVT_D_L = 11841, + RISCV_FCVT_D_LU = 11842, + RISCV_FCVT_D_LU_INX = 11843, + RISCV_FCVT_D_L_INX = 11844, + RISCV_FCVT_D_S = 11845, + RISCV_FCVT_D_S_IN32X = 11846, + RISCV_FCVT_D_S_INX = 11847, + RISCV_FCVT_D_W = 11848, + RISCV_FCVT_D_WU = 11849, + RISCV_FCVT_D_WU_IN32X = 11850, + RISCV_FCVT_D_WU_INX = 11851, + RISCV_FCVT_D_W_IN32X = 11852, + RISCV_FCVT_D_W_INX = 11853, + RISCV_FCVT_H_D = 11854, + RISCV_FCVT_H_D_IN32X = 11855, + RISCV_FCVT_H_D_INX = 11856, + RISCV_FCVT_H_L = 11857, + RISCV_FCVT_H_LU = 11858, + RISCV_FCVT_H_LU_INX = 11859, + RISCV_FCVT_H_L_INX = 11860, + RISCV_FCVT_H_S = 11861, + RISCV_FCVT_H_S_INX = 11862, + RISCV_FCVT_H_W = 11863, + RISCV_FCVT_H_WU = 11864, + RISCV_FCVT_H_WU_INX = 11865, + RISCV_FCVT_H_W_INX = 11866, + RISCV_FCVT_LU_D = 11867, + RISCV_FCVT_LU_D_INX = 11868, + RISCV_FCVT_LU_H = 11869, + RISCV_FCVT_LU_H_INX = 11870, + RISCV_FCVT_LU_S = 11871, + RISCV_FCVT_LU_S_INX = 11872, + RISCV_FCVT_L_D = 11873, + RISCV_FCVT_L_D_INX = 11874, + RISCV_FCVT_L_H = 11875, + RISCV_FCVT_L_H_INX = 11876, + RISCV_FCVT_L_S = 11877, + RISCV_FCVT_L_S_INX = 11878, + RISCV_FCVT_S_BF16 = 11879, + RISCV_FCVT_S_D = 11880, + RISCV_FCVT_S_D_IN32X = 11881, + RISCV_FCVT_S_D_INX = 11882, + RISCV_FCVT_S_H = 11883, + RISCV_FCVT_S_H_INX = 11884, + RISCV_FCVT_S_L = 11885, + RISCV_FCVT_S_LU = 11886, + RISCV_FCVT_S_LU_INX = 11887, + RISCV_FCVT_S_L_INX = 11888, + RISCV_FCVT_S_W = 11889, + RISCV_FCVT_S_WU = 11890, + RISCV_FCVT_S_WU_INX = 11891, + RISCV_FCVT_S_W_INX = 11892, + RISCV_FCVT_WU_D = 11893, + RISCV_FCVT_WU_D_IN32X = 11894, + RISCV_FCVT_WU_D_INX = 11895, + RISCV_FCVT_WU_H = 11896, + RISCV_FCVT_WU_H_INX = 11897, + RISCV_FCVT_WU_S = 11898, + RISCV_FCVT_WU_S_INX = 11899, + RISCV_FCVT_W_D = 11900, + RISCV_FCVT_W_D_IN32X = 11901, + RISCV_FCVT_W_D_INX = 11902, + RISCV_FCVT_W_H = 11903, + RISCV_FCVT_W_H_INX = 11904, + RISCV_FCVT_W_S = 11905, + RISCV_FCVT_W_S_INX = 11906, + RISCV_FDIV_D = 11907, + RISCV_FDIV_D_IN32X = 11908, + RISCV_FDIV_D_INX = 11909, + RISCV_FDIV_H = 11910, + RISCV_FDIV_H_INX = 11911, + RISCV_FDIV_S = 11912, + RISCV_FDIV_S_INX = 11913, + RISCV_FENCE = 11914, + RISCV_FENCE_I = 11915, + RISCV_FENCE_TSO = 11916, + RISCV_FEQ_D = 11917, + RISCV_FEQ_D_IN32X = 11918, + RISCV_FEQ_D_INX = 11919, + RISCV_FEQ_H = 11920, + RISCV_FEQ_H_INX = 11921, + RISCV_FEQ_S = 11922, + RISCV_FEQ_S_INX = 11923, + RISCV_FLD = 11924, + RISCV_FLEQ_D = 11925, + RISCV_FLEQ_H = 11926, + RISCV_FLEQ_S = 11927, + RISCV_FLE_D = 11928, + RISCV_FLE_D_IN32X = 11929, + RISCV_FLE_D_INX = 11930, + RISCV_FLE_H = 11931, + RISCV_FLE_H_INX = 11932, + RISCV_FLE_S = 11933, + RISCV_FLE_S_INX = 11934, + RISCV_FLH = 11935, + RISCV_FLI_D = 11936, + RISCV_FLI_H = 11937, + RISCV_FLI_S = 11938, + RISCV_FLTQ_D = 11939, + RISCV_FLTQ_H = 11940, + RISCV_FLTQ_S = 11941, + RISCV_FLT_D = 11942, + RISCV_FLT_D_IN32X = 11943, + RISCV_FLT_D_INX = 11944, + RISCV_FLT_H = 11945, + RISCV_FLT_H_INX = 11946, + RISCV_FLT_S = 11947, + RISCV_FLT_S_INX = 11948, + RISCV_FLW = 11949, + RISCV_FMADD_D = 11950, + RISCV_FMADD_D_IN32X = 11951, + RISCV_FMADD_D_INX = 11952, + RISCV_FMADD_H = 11953, + RISCV_FMADD_H_INX = 11954, + RISCV_FMADD_S = 11955, + RISCV_FMADD_S_INX = 11956, + RISCV_FMAXM_D = 11957, + RISCV_FMAXM_H = 11958, + RISCV_FMAXM_S = 11959, + RISCV_FMAX_D = 11960, + RISCV_FMAX_D_IN32X = 11961, + RISCV_FMAX_D_INX = 11962, + RISCV_FMAX_H = 11963, + RISCV_FMAX_H_INX = 11964, + RISCV_FMAX_S = 11965, + RISCV_FMAX_S_INX = 11966, + RISCV_FMINM_D = 11967, + RISCV_FMINM_H = 11968, + RISCV_FMINM_S = 11969, + RISCV_FMIN_D = 11970, + RISCV_FMIN_D_IN32X = 11971, + RISCV_FMIN_D_INX = 11972, + RISCV_FMIN_H = 11973, + RISCV_FMIN_H_INX = 11974, + RISCV_FMIN_S = 11975, + RISCV_FMIN_S_INX = 11976, + RISCV_FMSUB_D = 11977, + RISCV_FMSUB_D_IN32X = 11978, + RISCV_FMSUB_D_INX = 11979, + RISCV_FMSUB_H = 11980, + RISCV_FMSUB_H_INX = 11981, + RISCV_FMSUB_S = 11982, + RISCV_FMSUB_S_INX = 11983, + RISCV_FMUL_D = 11984, + RISCV_FMUL_D_IN32X = 11985, + RISCV_FMUL_D_INX = 11986, + RISCV_FMUL_H = 11987, + RISCV_FMUL_H_INX = 11988, + RISCV_FMUL_S = 11989, + RISCV_FMUL_S_INX = 11990, + RISCV_FMVH_X_D = 11991, + RISCV_FMVP_D_X = 11992, + RISCV_FMV_D_X = 11993, + RISCV_FMV_H_X = 11994, + RISCV_FMV_W_X = 11995, + RISCV_FMV_X_D = 11996, + RISCV_FMV_X_H = 11997, + RISCV_FMV_X_W = 11998, + RISCV_FMV_X_W_FPR64 = 11999, + RISCV_FNMADD_D = 12000, + RISCV_FNMADD_D_IN32X = 12001, + RISCV_FNMADD_D_INX = 12002, + RISCV_FNMADD_H = 12003, + RISCV_FNMADD_H_INX = 12004, + RISCV_FNMADD_S = 12005, + RISCV_FNMADD_S_INX = 12006, + RISCV_FNMSUB_D = 12007, + RISCV_FNMSUB_D_IN32X = 12008, + RISCV_FNMSUB_D_INX = 12009, + RISCV_FNMSUB_H = 12010, + RISCV_FNMSUB_H_INX = 12011, + RISCV_FNMSUB_S = 12012, + RISCV_FNMSUB_S_INX = 12013, + RISCV_FROUNDNX_D = 12014, + RISCV_FROUNDNX_H = 12015, + RISCV_FROUNDNX_S = 12016, + RISCV_FROUND_D = 12017, + RISCV_FROUND_H = 12018, + RISCV_FROUND_S = 12019, + RISCV_FSD = 12020, + RISCV_FSGNJN_D = 12021, + RISCV_FSGNJN_D_IN32X = 12022, + RISCV_FSGNJN_D_INX = 12023, + RISCV_FSGNJN_H = 12024, + RISCV_FSGNJN_H_INX = 12025, + RISCV_FSGNJN_S = 12026, + RISCV_FSGNJN_S_INX = 12027, + RISCV_FSGNJX_D = 12028, + RISCV_FSGNJX_D_IN32X = 12029, + RISCV_FSGNJX_D_INX = 12030, + RISCV_FSGNJX_H = 12031, + RISCV_FSGNJX_H_INX = 12032, + RISCV_FSGNJX_S = 12033, + RISCV_FSGNJX_S_INX = 12034, + RISCV_FSGNJ_D = 12035, + RISCV_FSGNJ_D_IN32X = 12036, + RISCV_FSGNJ_D_INX = 12037, + RISCV_FSGNJ_H = 12038, + RISCV_FSGNJ_H_INX = 12039, + RISCV_FSGNJ_S = 12040, + RISCV_FSGNJ_S_INX = 12041, + RISCV_FSH = 12042, + RISCV_FSQRT_D = 12043, + RISCV_FSQRT_D_IN32X = 12044, + RISCV_FSQRT_D_INX = 12045, + RISCV_FSQRT_H = 12046, + RISCV_FSQRT_H_INX = 12047, + RISCV_FSQRT_S = 12048, + RISCV_FSQRT_S_INX = 12049, + RISCV_FSUB_D = 12050, + RISCV_FSUB_D_IN32X = 12051, + RISCV_FSUB_D_INX = 12052, + RISCV_FSUB_H = 12053, + RISCV_FSUB_H_INX = 12054, + RISCV_FSUB_S = 12055, + RISCV_FSUB_S_INX = 12056, + RISCV_FSW = 12057, + RISCV_HFENCE_GVMA = 12058, + RISCV_HFENCE_VVMA = 12059, + RISCV_HINVAL_GVMA = 12060, + RISCV_HINVAL_VVMA = 12061, + RISCV_HLVX_HU = 12062, + RISCV_HLVX_WU = 12063, + RISCV_HLV_B = 12064, + RISCV_HLV_BU = 12065, + RISCV_HLV_D = 12066, + RISCV_HLV_H = 12067, + RISCV_HLV_HU = 12068, + RISCV_HLV_W = 12069, + RISCV_HLV_WU = 12070, + RISCV_HSV_B = 12071, + RISCV_HSV_D = 12072, + RISCV_HSV_H = 12073, + RISCV_HSV_W = 12074, + RISCV_InsnB = 12075, + RISCV_InsnCA = 12076, + RISCV_InsnCB = 12077, + RISCV_InsnCI = 12078, + RISCV_InsnCIW = 12079, + RISCV_InsnCJ = 12080, + RISCV_InsnCL = 12081, + RISCV_InsnCR = 12082, + RISCV_InsnCS = 12083, + RISCV_InsnCSS = 12084, + RISCV_InsnI = 12085, + RISCV_InsnI_Mem = 12086, + RISCV_InsnJ = 12087, + RISCV_InsnR = 12088, + RISCV_InsnR4 = 12089, + RISCV_InsnS = 12090, + RISCV_InsnU = 12091, + RISCV_JAL = 12092, + RISCV_JALR = 12093, + RISCV_LB = 12094, + RISCV_LBU = 12095, + RISCV_LD = 12096, + RISCV_LH = 12097, + RISCV_LHU = 12098, + RISCV_LR_D = 12099, + RISCV_LR_D_AQ = 12100, + RISCV_LR_D_AQ_RL = 12101, + RISCV_LR_D_RL = 12102, + RISCV_LR_W = 12103, + RISCV_LR_W_AQ = 12104, + RISCV_LR_W_AQ_RL = 12105, + RISCV_LR_W_RL = 12106, + RISCV_LUI = 12107, + RISCV_LW = 12108, + RISCV_LWU = 12109, + RISCV_MAX = 12110, + RISCV_MAXU = 12111, + RISCV_MIN = 12112, + RISCV_MINU = 12113, + RISCV_MOPR0 = 12114, + RISCV_MOPR1 = 12115, + RISCV_MOPR10 = 12116, + RISCV_MOPR11 = 12117, + RISCV_MOPR12 = 12118, + RISCV_MOPR13 = 12119, + RISCV_MOPR14 = 12120, + RISCV_MOPR15 = 12121, + RISCV_MOPR16 = 12122, + RISCV_MOPR17 = 12123, + RISCV_MOPR18 = 12124, + RISCV_MOPR19 = 12125, + RISCV_MOPR2 = 12126, + RISCV_MOPR20 = 12127, + RISCV_MOPR21 = 12128, + RISCV_MOPR22 = 12129, + RISCV_MOPR23 = 12130, + RISCV_MOPR24 = 12131, + RISCV_MOPR25 = 12132, + RISCV_MOPR26 = 12133, + RISCV_MOPR27 = 12134, + RISCV_MOPR28 = 12135, + RISCV_MOPR29 = 12136, + RISCV_MOPR3 = 12137, + RISCV_MOPR30 = 12138, + RISCV_MOPR31 = 12139, + RISCV_MOPR4 = 12140, + RISCV_MOPR5 = 12141, + RISCV_MOPR6 = 12142, + RISCV_MOPR7 = 12143, + RISCV_MOPR8 = 12144, + RISCV_MOPR9 = 12145, + RISCV_MOPRR0 = 12146, + RISCV_MOPRR1 = 12147, + RISCV_MOPRR2 = 12148, + RISCV_MOPRR3 = 12149, + RISCV_MOPRR4 = 12150, + RISCV_MOPRR5 = 12151, + RISCV_MOPRR6 = 12152, + RISCV_MOPRR7 = 12153, + RISCV_MRET = 12154, + RISCV_MUL = 12155, + RISCV_MULH = 12156, + RISCV_MULHSU = 12157, + RISCV_MULHU = 12158, + RISCV_MULW = 12159, + RISCV_OR = 12160, + RISCV_ORC_B = 12161, + RISCV_ORI = 12162, + RISCV_ORN = 12163, + RISCV_PACK = 12164, + RISCV_PACKH = 12165, + RISCV_PACKW = 12166, + RISCV_PREFETCH_I = 12167, + RISCV_PREFETCH_R = 12168, + RISCV_PREFETCH_W = 12169, + RISCV_REM = 12170, + RISCV_REMU = 12171, + RISCV_REMUW = 12172, + RISCV_REMW = 12173, + RISCV_REV8_RV32 = 12174, + RISCV_REV8_RV64 = 12175, + RISCV_ROL = 12176, + RISCV_ROLW = 12177, + RISCV_ROR = 12178, + RISCV_RORI = 12179, + RISCV_RORIW = 12180, + RISCV_RORW = 12181, + RISCV_SB = 12182, + RISCV_SC_D = 12183, + RISCV_SC_D_AQ = 12184, + RISCV_SC_D_AQ_RL = 12185, + RISCV_SC_D_RL = 12186, + RISCV_SC_W = 12187, + RISCV_SC_W_AQ = 12188, + RISCV_SC_W_AQ_RL = 12189, + RISCV_SC_W_RL = 12190, + RISCV_SD = 12191, + RISCV_SEXT_B = 12192, + RISCV_SEXT_H = 12193, + RISCV_SFENCE_INVAL_IR = 12194, + RISCV_SFENCE_VMA = 12195, + RISCV_SFENCE_W_INVAL = 12196, + RISCV_SH = 12197, + RISCV_SH1ADD = 12198, + RISCV_SH1ADD_UW = 12199, + RISCV_SH2ADD = 12200, + RISCV_SH2ADD_UW = 12201, + RISCV_SH3ADD = 12202, + RISCV_SH3ADD_UW = 12203, + RISCV_SHA256SIG0 = 12204, + RISCV_SHA256SIG1 = 12205, + RISCV_SHA256SUM0 = 12206, + RISCV_SHA256SUM1 = 12207, + RISCV_SHA512SIG0 = 12208, + RISCV_SHA512SIG0H = 12209, + RISCV_SHA512SIG0L = 12210, + RISCV_SHA512SIG1 = 12211, + RISCV_SHA512SIG1H = 12212, + RISCV_SHA512SIG1L = 12213, + RISCV_SHA512SUM0 = 12214, + RISCV_SHA512SUM0R = 12215, + RISCV_SHA512SUM1 = 12216, + RISCV_SHA512SUM1R = 12217, + RISCV_SINVAL_VMA = 12218, + RISCV_SLL = 12219, + RISCV_SLLI = 12220, + RISCV_SLLIW = 12221, + RISCV_SLLI_UW = 12222, + RISCV_SLLW = 12223, + RISCV_SLT = 12224, + RISCV_SLTI = 12225, + RISCV_SLTIU = 12226, + RISCV_SLTU = 12227, + RISCV_SM3P0 = 12228, + RISCV_SM3P1 = 12229, + RISCV_SM4ED = 12230, + RISCV_SM4KS = 12231, + RISCV_SRA = 12232, + RISCV_SRAI = 12233, + RISCV_SRAIW = 12234, + RISCV_SRAW = 12235, + RISCV_SRET = 12236, + RISCV_SRL = 12237, + RISCV_SRLI = 12238, + RISCV_SRLIW = 12239, + RISCV_SRLW = 12240, + RISCV_SSAMOSWAP_D = 12241, + RISCV_SSAMOSWAP_D_AQ = 12242, + RISCV_SSAMOSWAP_D_AQ_RL = 12243, + RISCV_SSAMOSWAP_D_RL = 12244, + RISCV_SSAMOSWAP_W = 12245, + RISCV_SSAMOSWAP_W_AQ = 12246, + RISCV_SSAMOSWAP_W_AQ_RL = 12247, + RISCV_SSAMOSWAP_W_RL = 12248, + RISCV_SSPOPCHK = 12249, + RISCV_SSPUSH = 12250, + RISCV_SSRDP = 12251, + RISCV_SUB = 12252, + RISCV_SUBW = 12253, + RISCV_SW = 12254, + RISCV_THVdotVMAQASU_VV = 12255, + RISCV_THVdotVMAQASU_VX = 12256, + RISCV_THVdotVMAQAUS_VX = 12257, + RISCV_THVdotVMAQAU_VV = 12258, + RISCV_THVdotVMAQAU_VX = 12259, + RISCV_THVdotVMAQA_VV = 12260, + RISCV_THVdotVMAQA_VX = 12261, + RISCV_TH_ADDSL = 12262, + RISCV_TH_DCACHE_CALL = 12263, + RISCV_TH_DCACHE_CIALL = 12264, + RISCV_TH_DCACHE_CIPA = 12265, + RISCV_TH_DCACHE_CISW = 12266, + RISCV_TH_DCACHE_CIVA = 12267, + RISCV_TH_DCACHE_CPA = 12268, + RISCV_TH_DCACHE_CPAL1 = 12269, + RISCV_TH_DCACHE_CSW = 12270, + RISCV_TH_DCACHE_CVA = 12271, + RISCV_TH_DCACHE_CVAL1 = 12272, + RISCV_TH_DCACHE_IALL = 12273, + RISCV_TH_DCACHE_IPA = 12274, + RISCV_TH_DCACHE_ISW = 12275, + RISCV_TH_DCACHE_IVA = 12276, + RISCV_TH_EXT = 12277, + RISCV_TH_EXTU = 12278, + RISCV_TH_FF0 = 12279, + RISCV_TH_FF1 = 12280, + RISCV_TH_FLRD = 12281, + RISCV_TH_FLRW = 12282, + RISCV_TH_FLURD = 12283, + RISCV_TH_FLURW = 12284, + RISCV_TH_FSRD = 12285, + RISCV_TH_FSRW = 12286, + RISCV_TH_FSURD = 12287, + RISCV_TH_FSURW = 12288, + RISCV_TH_ICACHE_IALL = 12289, + RISCV_TH_ICACHE_IALLS = 12290, + RISCV_TH_ICACHE_IPA = 12291, + RISCV_TH_ICACHE_IVA = 12292, + RISCV_TH_L2CACHE_CALL = 12293, + RISCV_TH_L2CACHE_CIALL = 12294, + RISCV_TH_L2CACHE_IALL = 12295, + RISCV_TH_LBIA = 12296, + RISCV_TH_LBIB = 12297, + RISCV_TH_LBUIA = 12298, + RISCV_TH_LBUIB = 12299, + RISCV_TH_LDD = 12300, + RISCV_TH_LDIA = 12301, + RISCV_TH_LDIB = 12302, + RISCV_TH_LHIA = 12303, + RISCV_TH_LHIB = 12304, + RISCV_TH_LHUIA = 12305, + RISCV_TH_LHUIB = 12306, + RISCV_TH_LRB = 12307, + RISCV_TH_LRBU = 12308, + RISCV_TH_LRD = 12309, + RISCV_TH_LRH = 12310, + RISCV_TH_LRHU = 12311, + RISCV_TH_LRW = 12312, + RISCV_TH_LRWU = 12313, + RISCV_TH_LURB = 12314, + RISCV_TH_LURBU = 12315, + RISCV_TH_LURD = 12316, + RISCV_TH_LURH = 12317, + RISCV_TH_LURHU = 12318, + RISCV_TH_LURW = 12319, + RISCV_TH_LURWU = 12320, + RISCV_TH_LWD = 12321, + RISCV_TH_LWIA = 12322, + RISCV_TH_LWIB = 12323, + RISCV_TH_LWUD = 12324, + RISCV_TH_LWUIA = 12325, + RISCV_TH_LWUIB = 12326, + RISCV_TH_MULA = 12327, + RISCV_TH_MULAH = 12328, + RISCV_TH_MULAW = 12329, + RISCV_TH_MULS = 12330, + RISCV_TH_MULSH = 12331, + RISCV_TH_MULSW = 12332, + RISCV_TH_MVEQZ = 12333, + RISCV_TH_MVNEZ = 12334, + RISCV_TH_REV = 12335, + RISCV_TH_REVW = 12336, + RISCV_TH_SBIA = 12337, + RISCV_TH_SBIB = 12338, + RISCV_TH_SDD = 12339, + RISCV_TH_SDIA = 12340, + RISCV_TH_SDIB = 12341, + RISCV_TH_SFENCE_VMAS = 12342, + RISCV_TH_SHIA = 12343, + RISCV_TH_SHIB = 12344, + RISCV_TH_SRB = 12345, + RISCV_TH_SRD = 12346, + RISCV_TH_SRH = 12347, + RISCV_TH_SRRI = 12348, + RISCV_TH_SRRIW = 12349, + RISCV_TH_SRW = 12350, + RISCV_TH_SURB = 12351, + RISCV_TH_SURD = 12352, + RISCV_TH_SURH = 12353, + RISCV_TH_SURW = 12354, + RISCV_TH_SWD = 12355, + RISCV_TH_SWIA = 12356, + RISCV_TH_SWIB = 12357, + RISCV_TH_SYNC = 12358, + RISCV_TH_SYNC_I = 12359, + RISCV_TH_SYNC_IS = 12360, + RISCV_TH_SYNC_S = 12361, + RISCV_TH_TST = 12362, + RISCV_TH_TSTNBZ = 12363, + RISCV_UNIMP = 12364, + RISCV_UNZIP_RV32 = 12365, + RISCV_VAADDU_VV = 12366, + RISCV_VAADDU_VX = 12367, + RISCV_VAADD_VV = 12368, + RISCV_VAADD_VX = 12369, + RISCV_VADC_VIM = 12370, + RISCV_VADC_VVM = 12371, + RISCV_VADC_VXM = 12372, + RISCV_VADD_VI = 12373, + RISCV_VADD_VV = 12374, + RISCV_VADD_VX = 12375, + RISCV_VAESDF_VS = 12376, + RISCV_VAESDF_VV = 12377, + RISCV_VAESDM_VS = 12378, + RISCV_VAESDM_VV = 12379, + RISCV_VAESEF_VS = 12380, + RISCV_VAESEF_VV = 12381, + RISCV_VAESEM_VS = 12382, + RISCV_VAESEM_VV = 12383, + RISCV_VAESKF1_VI = 12384, + RISCV_VAESKF2_VI = 12385, + RISCV_VAESZ_VS = 12386, + RISCV_VANDN_VV = 12387, + RISCV_VANDN_VX = 12388, + RISCV_VAND_VI = 12389, + RISCV_VAND_VV = 12390, + RISCV_VAND_VX = 12391, + RISCV_VASUBU_VV = 12392, + RISCV_VASUBU_VX = 12393, + RISCV_VASUB_VV = 12394, + RISCV_VASUB_VX = 12395, + RISCV_VBREV8_V = 12396, + RISCV_VBREV_V = 12397, + RISCV_VCLMULH_VV = 12398, + RISCV_VCLMULH_VX = 12399, + RISCV_VCLMUL_VV = 12400, + RISCV_VCLMUL_VX = 12401, + RISCV_VCLZ_V = 12402, + RISCV_VCOMPRESS_VM = 12403, + RISCV_VCPOP_M = 12404, + RISCV_VCPOP_V = 12405, + RISCV_VCTZ_V = 12406, + RISCV_VC_FV = 12407, + RISCV_VC_FVV = 12408, + RISCV_VC_FVW = 12409, + RISCV_VC_I = 12410, + RISCV_VC_IV = 12411, + RISCV_VC_IVV = 12412, + RISCV_VC_IVW = 12413, + RISCV_VC_VV = 12414, + RISCV_VC_VVV = 12415, + RISCV_VC_VVW = 12416, + RISCV_VC_V_FV = 12417, + RISCV_VC_V_FVV = 12418, + RISCV_VC_V_FVW = 12419, + RISCV_VC_V_I = 12420, + RISCV_VC_V_IV = 12421, + RISCV_VC_V_IVV = 12422, + RISCV_VC_V_IVW = 12423, + RISCV_VC_V_VV = 12424, + RISCV_VC_V_VVV = 12425, + RISCV_VC_V_VVW = 12426, + RISCV_VC_V_X = 12427, + RISCV_VC_V_XV = 12428, + RISCV_VC_V_XVV = 12429, + RISCV_VC_V_XVW = 12430, + RISCV_VC_X = 12431, + RISCV_VC_XV = 12432, + RISCV_VC_XVV = 12433, + RISCV_VC_XVW = 12434, + RISCV_VDIVU_VV = 12435, + RISCV_VDIVU_VX = 12436, + RISCV_VDIV_VV = 12437, + RISCV_VDIV_VX = 12438, + RISCV_VFADD_VF = 12439, + RISCV_VFADD_VV = 12440, + RISCV_VFCLASS_V = 12441, + RISCV_VFCVT_F_XU_V = 12442, + RISCV_VFCVT_F_X_V = 12443, + RISCV_VFCVT_RTZ_XU_F_V = 12444, + RISCV_VFCVT_RTZ_X_F_V = 12445, + RISCV_VFCVT_XU_F_V = 12446, + RISCV_VFCVT_X_F_V = 12447, + RISCV_VFDIV_VF = 12448, + RISCV_VFDIV_VV = 12449, + RISCV_VFIRST_M = 12450, + RISCV_VFMACC_VF = 12451, + RISCV_VFMACC_VV = 12452, + RISCV_VFMADD_VF = 12453, + RISCV_VFMADD_VV = 12454, + RISCV_VFMAX_VF = 12455, + RISCV_VFMAX_VV = 12456, + RISCV_VFMERGE_VFM = 12457, + RISCV_VFMIN_VF = 12458, + RISCV_VFMIN_VV = 12459, + RISCV_VFMSAC_VF = 12460, + RISCV_VFMSAC_VV = 12461, + RISCV_VFMSUB_VF = 12462, + RISCV_VFMSUB_VV = 12463, + RISCV_VFMUL_VF = 12464, + RISCV_VFMUL_VV = 12465, + RISCV_VFMV_F_S = 12466, + RISCV_VFMV_S_F = 12467, + RISCV_VFMV_V_F = 12468, + RISCV_VFNCVTBF16_F_F_W = 12469, + RISCV_VFNCVT_F_F_W = 12470, + RISCV_VFNCVT_F_XU_W = 12471, + RISCV_VFNCVT_F_X_W = 12472, + RISCV_VFNCVT_ROD_F_F_W = 12473, + RISCV_VFNCVT_RTZ_XU_F_W = 12474, + RISCV_VFNCVT_RTZ_X_F_W = 12475, + RISCV_VFNCVT_XU_F_W = 12476, + RISCV_VFNCVT_X_F_W = 12477, + RISCV_VFNMACC_VF = 12478, + RISCV_VFNMACC_VV = 12479, + RISCV_VFNMADD_VF = 12480, + RISCV_VFNMADD_VV = 12481, + RISCV_VFNMSAC_VF = 12482, + RISCV_VFNMSAC_VV = 12483, + RISCV_VFNMSUB_VF = 12484, + RISCV_VFNMSUB_VV = 12485, + RISCV_VFNRCLIP_XU_F_QF = 12486, + RISCV_VFNRCLIP_X_F_QF = 12487, + RISCV_VFRDIV_VF = 12488, + RISCV_VFREC7_V = 12489, + RISCV_VFREDMAX_VS = 12490, + RISCV_VFREDMIN_VS = 12491, + RISCV_VFREDOSUM_VS = 12492, + RISCV_VFREDUSUM_VS = 12493, + RISCV_VFRSQRT7_V = 12494, + RISCV_VFRSUB_VF = 12495, + RISCV_VFSGNJN_VF = 12496, + RISCV_VFSGNJN_VV = 12497, + RISCV_VFSGNJX_VF = 12498, + RISCV_VFSGNJX_VV = 12499, + RISCV_VFSGNJ_VF = 12500, + RISCV_VFSGNJ_VV = 12501, + RISCV_VFSLIDE1DOWN_VF = 12502, + RISCV_VFSLIDE1UP_VF = 12503, + RISCV_VFSQRT_V = 12504, + RISCV_VFSUB_VF = 12505, + RISCV_VFSUB_VV = 12506, + RISCV_VFWADD_VF = 12507, + RISCV_VFWADD_VV = 12508, + RISCV_VFWADD_WF = 12509, + RISCV_VFWADD_WV = 12510, + RISCV_VFWCVTBF16_F_F_V = 12511, + RISCV_VFWCVT_F_F_V = 12512, + RISCV_VFWCVT_F_XU_V = 12513, + RISCV_VFWCVT_F_X_V = 12514, + RISCV_VFWCVT_RTZ_XU_F_V = 12515, + RISCV_VFWCVT_RTZ_X_F_V = 12516, + RISCV_VFWCVT_XU_F_V = 12517, + RISCV_VFWCVT_X_F_V = 12518, + RISCV_VFWMACCBF16_VF = 12519, + RISCV_VFWMACCBF16_VV = 12520, + RISCV_VFWMACC_4x4x4 = 12521, + RISCV_VFWMACC_VF = 12522, + RISCV_VFWMACC_VV = 12523, + RISCV_VFWMSAC_VF = 12524, + RISCV_VFWMSAC_VV = 12525, + RISCV_VFWMUL_VF = 12526, + RISCV_VFWMUL_VV = 12527, + RISCV_VFWNMACC_VF = 12528, + RISCV_VFWNMACC_VV = 12529, + RISCV_VFWNMSAC_VF = 12530, + RISCV_VFWNMSAC_VV = 12531, + RISCV_VFWREDOSUM_VS = 12532, + RISCV_VFWREDUSUM_VS = 12533, + RISCV_VFWSUB_VF = 12534, + RISCV_VFWSUB_VV = 12535, + RISCV_VFWSUB_WF = 12536, + RISCV_VFWSUB_WV = 12537, + RISCV_VGHSH_VV = 12538, + RISCV_VGMUL_VV = 12539, + RISCV_VID_V = 12540, + RISCV_VIOTA_M = 12541, + RISCV_VL1RE16_V = 12542, + RISCV_VL1RE32_V = 12543, + RISCV_VL1RE64_V = 12544, + RISCV_VL1RE8_V = 12545, + RISCV_VL2RE16_V = 12546, + RISCV_VL2RE32_V = 12547, + RISCV_VL2RE64_V = 12548, + RISCV_VL2RE8_V = 12549, + RISCV_VL4RE16_V = 12550, + RISCV_VL4RE32_V = 12551, + RISCV_VL4RE64_V = 12552, + RISCV_VL4RE8_V = 12553, + RISCV_VL8RE16_V = 12554, + RISCV_VL8RE32_V = 12555, + RISCV_VL8RE64_V = 12556, + RISCV_VL8RE8_V = 12557, + RISCV_VLE16FF_V = 12558, + RISCV_VLE16_V = 12559, + RISCV_VLE32FF_V = 12560, + RISCV_VLE32_V = 12561, + RISCV_VLE64FF_V = 12562, + RISCV_VLE64_V = 12563, + RISCV_VLE8FF_V = 12564, + RISCV_VLE8_V = 12565, + RISCV_VLM_V = 12566, + RISCV_VLOXEI16_V = 12567, + RISCV_VLOXEI32_V = 12568, + RISCV_VLOXEI64_V = 12569, + RISCV_VLOXEI8_V = 12570, + RISCV_VLOXSEG2EI16_V = 12571, + RISCV_VLOXSEG2EI32_V = 12572, + RISCV_VLOXSEG2EI64_V = 12573, + RISCV_VLOXSEG2EI8_V = 12574, + RISCV_VLOXSEG3EI16_V = 12575, + RISCV_VLOXSEG3EI32_V = 12576, + RISCV_VLOXSEG3EI64_V = 12577, + RISCV_VLOXSEG3EI8_V = 12578, + RISCV_VLOXSEG4EI16_V = 12579, + RISCV_VLOXSEG4EI32_V = 12580, + RISCV_VLOXSEG4EI64_V = 12581, + RISCV_VLOXSEG4EI8_V = 12582, + RISCV_VLOXSEG5EI16_V = 12583, + RISCV_VLOXSEG5EI32_V = 12584, + RISCV_VLOXSEG5EI64_V = 12585, + RISCV_VLOXSEG5EI8_V = 12586, + RISCV_VLOXSEG6EI16_V = 12587, + RISCV_VLOXSEG6EI32_V = 12588, + RISCV_VLOXSEG6EI64_V = 12589, + RISCV_VLOXSEG6EI8_V = 12590, + RISCV_VLOXSEG7EI16_V = 12591, + RISCV_VLOXSEG7EI32_V = 12592, + RISCV_VLOXSEG7EI64_V = 12593, + RISCV_VLOXSEG7EI8_V = 12594, + RISCV_VLOXSEG8EI16_V = 12595, + RISCV_VLOXSEG8EI32_V = 12596, + RISCV_VLOXSEG8EI64_V = 12597, + RISCV_VLOXSEG8EI8_V = 12598, + RISCV_VLSE16_V = 12599, + RISCV_VLSE32_V = 12600, + RISCV_VLSE64_V = 12601, + RISCV_VLSE8_V = 12602, + RISCV_VLSEG2E16FF_V = 12603, + RISCV_VLSEG2E16_V = 12604, + RISCV_VLSEG2E32FF_V = 12605, + RISCV_VLSEG2E32_V = 12606, + RISCV_VLSEG2E64FF_V = 12607, + RISCV_VLSEG2E64_V = 12608, + RISCV_VLSEG2E8FF_V = 12609, + RISCV_VLSEG2E8_V = 12610, + RISCV_VLSEG3E16FF_V = 12611, + RISCV_VLSEG3E16_V = 12612, + RISCV_VLSEG3E32FF_V = 12613, + RISCV_VLSEG3E32_V = 12614, + RISCV_VLSEG3E64FF_V = 12615, + RISCV_VLSEG3E64_V = 12616, + RISCV_VLSEG3E8FF_V = 12617, + RISCV_VLSEG3E8_V = 12618, + RISCV_VLSEG4E16FF_V = 12619, + RISCV_VLSEG4E16_V = 12620, + RISCV_VLSEG4E32FF_V = 12621, + RISCV_VLSEG4E32_V = 12622, + RISCV_VLSEG4E64FF_V = 12623, + RISCV_VLSEG4E64_V = 12624, + RISCV_VLSEG4E8FF_V = 12625, + RISCV_VLSEG4E8_V = 12626, + RISCV_VLSEG5E16FF_V = 12627, + RISCV_VLSEG5E16_V = 12628, + RISCV_VLSEG5E32FF_V = 12629, + RISCV_VLSEG5E32_V = 12630, + RISCV_VLSEG5E64FF_V = 12631, + RISCV_VLSEG5E64_V = 12632, + RISCV_VLSEG5E8FF_V = 12633, + RISCV_VLSEG5E8_V = 12634, + RISCV_VLSEG6E16FF_V = 12635, + RISCV_VLSEG6E16_V = 12636, + RISCV_VLSEG6E32FF_V = 12637, + RISCV_VLSEG6E32_V = 12638, + RISCV_VLSEG6E64FF_V = 12639, + RISCV_VLSEG6E64_V = 12640, + RISCV_VLSEG6E8FF_V = 12641, + RISCV_VLSEG6E8_V = 12642, + RISCV_VLSEG7E16FF_V = 12643, + RISCV_VLSEG7E16_V = 12644, + RISCV_VLSEG7E32FF_V = 12645, + RISCV_VLSEG7E32_V = 12646, + RISCV_VLSEG7E64FF_V = 12647, + RISCV_VLSEG7E64_V = 12648, + RISCV_VLSEG7E8FF_V = 12649, + RISCV_VLSEG7E8_V = 12650, + RISCV_VLSEG8E16FF_V = 12651, + RISCV_VLSEG8E16_V = 12652, + RISCV_VLSEG8E32FF_V = 12653, + RISCV_VLSEG8E32_V = 12654, + RISCV_VLSEG8E64FF_V = 12655, + RISCV_VLSEG8E64_V = 12656, + RISCV_VLSEG8E8FF_V = 12657, + RISCV_VLSEG8E8_V = 12658, + RISCV_VLSSEG2E16_V = 12659, + RISCV_VLSSEG2E32_V = 12660, + RISCV_VLSSEG2E64_V = 12661, + RISCV_VLSSEG2E8_V = 12662, + RISCV_VLSSEG3E16_V = 12663, + RISCV_VLSSEG3E32_V = 12664, + RISCV_VLSSEG3E64_V = 12665, + RISCV_VLSSEG3E8_V = 12666, + RISCV_VLSSEG4E16_V = 12667, + RISCV_VLSSEG4E32_V = 12668, + RISCV_VLSSEG4E64_V = 12669, + RISCV_VLSSEG4E8_V = 12670, + RISCV_VLSSEG5E16_V = 12671, + RISCV_VLSSEG5E32_V = 12672, + RISCV_VLSSEG5E64_V = 12673, + RISCV_VLSSEG5E8_V = 12674, + RISCV_VLSSEG6E16_V = 12675, + RISCV_VLSSEG6E32_V = 12676, + RISCV_VLSSEG6E64_V = 12677, + RISCV_VLSSEG6E8_V = 12678, + RISCV_VLSSEG7E16_V = 12679, + RISCV_VLSSEG7E32_V = 12680, + RISCV_VLSSEG7E64_V = 12681, + RISCV_VLSSEG7E8_V = 12682, + RISCV_VLSSEG8E16_V = 12683, + RISCV_VLSSEG8E32_V = 12684, + RISCV_VLSSEG8E64_V = 12685, + RISCV_VLSSEG8E8_V = 12686, + RISCV_VLUXEI16_V = 12687, + RISCV_VLUXEI32_V = 12688, + RISCV_VLUXEI64_V = 12689, + RISCV_VLUXEI8_V = 12690, + RISCV_VLUXSEG2EI16_V = 12691, + RISCV_VLUXSEG2EI32_V = 12692, + RISCV_VLUXSEG2EI64_V = 12693, + RISCV_VLUXSEG2EI8_V = 12694, + RISCV_VLUXSEG3EI16_V = 12695, + RISCV_VLUXSEG3EI32_V = 12696, + RISCV_VLUXSEG3EI64_V = 12697, + RISCV_VLUXSEG3EI8_V = 12698, + RISCV_VLUXSEG4EI16_V = 12699, + RISCV_VLUXSEG4EI32_V = 12700, + RISCV_VLUXSEG4EI64_V = 12701, + RISCV_VLUXSEG4EI8_V = 12702, + RISCV_VLUXSEG5EI16_V = 12703, + RISCV_VLUXSEG5EI32_V = 12704, + RISCV_VLUXSEG5EI64_V = 12705, + RISCV_VLUXSEG5EI8_V = 12706, + RISCV_VLUXSEG6EI16_V = 12707, + RISCV_VLUXSEG6EI32_V = 12708, + RISCV_VLUXSEG6EI64_V = 12709, + RISCV_VLUXSEG6EI8_V = 12710, + RISCV_VLUXSEG7EI16_V = 12711, + RISCV_VLUXSEG7EI32_V = 12712, + RISCV_VLUXSEG7EI64_V = 12713, + RISCV_VLUXSEG7EI8_V = 12714, + RISCV_VLUXSEG8EI16_V = 12715, + RISCV_VLUXSEG8EI32_V = 12716, + RISCV_VLUXSEG8EI64_V = 12717, + RISCV_VLUXSEG8EI8_V = 12718, + RISCV_VMACC_VV = 12719, + RISCV_VMACC_VX = 12720, + RISCV_VMADC_VI = 12721, + RISCV_VMADC_VIM = 12722, + RISCV_VMADC_VV = 12723, + RISCV_VMADC_VVM = 12724, + RISCV_VMADC_VX = 12725, + RISCV_VMADC_VXM = 12726, + RISCV_VMADD_VV = 12727, + RISCV_VMADD_VX = 12728, + RISCV_VMANDN_MM = 12729, + RISCV_VMAND_MM = 12730, + RISCV_VMAXU_VV = 12731, + RISCV_VMAXU_VX = 12732, + RISCV_VMAX_VV = 12733, + RISCV_VMAX_VX = 12734, + RISCV_VMERGE_VIM = 12735, + RISCV_VMERGE_VVM = 12736, + RISCV_VMERGE_VXM = 12737, + RISCV_VMFEQ_VF = 12738, + RISCV_VMFEQ_VV = 12739, + RISCV_VMFGE_VF = 12740, + RISCV_VMFGT_VF = 12741, + RISCV_VMFLE_VF = 12742, + RISCV_VMFLE_VV = 12743, + RISCV_VMFLT_VF = 12744, + RISCV_VMFLT_VV = 12745, + RISCV_VMFNE_VF = 12746, + RISCV_VMFNE_VV = 12747, + RISCV_VMINU_VV = 12748, + RISCV_VMINU_VX = 12749, + RISCV_VMIN_VV = 12750, + RISCV_VMIN_VX = 12751, + RISCV_VMNAND_MM = 12752, + RISCV_VMNOR_MM = 12753, + RISCV_VMORN_MM = 12754, + RISCV_VMOR_MM = 12755, + RISCV_VMSBC_VV = 12756, + RISCV_VMSBC_VVM = 12757, + RISCV_VMSBC_VX = 12758, + RISCV_VMSBC_VXM = 12759, + RISCV_VMSBF_M = 12760, + RISCV_VMSEQ_VI = 12761, + RISCV_VMSEQ_VV = 12762, + RISCV_VMSEQ_VX = 12763, + RISCV_VMSGTU_VI = 12764, + RISCV_VMSGTU_VX = 12765, + RISCV_VMSGT_VI = 12766, + RISCV_VMSGT_VX = 12767, + RISCV_VMSIF_M = 12768, + RISCV_VMSLEU_VI = 12769, + RISCV_VMSLEU_VV = 12770, + RISCV_VMSLEU_VX = 12771, + RISCV_VMSLE_VI = 12772, + RISCV_VMSLE_VV = 12773, + RISCV_VMSLE_VX = 12774, + RISCV_VMSLTU_VV = 12775, + RISCV_VMSLTU_VX = 12776, + RISCV_VMSLT_VV = 12777, + RISCV_VMSLT_VX = 12778, + RISCV_VMSNE_VI = 12779, + RISCV_VMSNE_VV = 12780, + RISCV_VMSNE_VX = 12781, + RISCV_VMSOF_M = 12782, + RISCV_VMULHSU_VV = 12783, + RISCV_VMULHSU_VX = 12784, + RISCV_VMULHU_VV = 12785, + RISCV_VMULHU_VX = 12786, + RISCV_VMULH_VV = 12787, + RISCV_VMULH_VX = 12788, + RISCV_VMUL_VV = 12789, + RISCV_VMUL_VX = 12790, + RISCV_VMV1R_V = 12791, + RISCV_VMV2R_V = 12792, + RISCV_VMV4R_V = 12793, + RISCV_VMV8R_V = 12794, + RISCV_VMV_S_X = 12795, + RISCV_VMV_V_I = 12796, + RISCV_VMV_V_V = 12797, + RISCV_VMV_V_X = 12798, + RISCV_VMV_X_S = 12799, + RISCV_VMXNOR_MM = 12800, + RISCV_VMXOR_MM = 12801, + RISCV_VNCLIPU_WI = 12802, + RISCV_VNCLIPU_WV = 12803, + RISCV_VNCLIPU_WX = 12804, + RISCV_VNCLIP_WI = 12805, + RISCV_VNCLIP_WV = 12806, + RISCV_VNCLIP_WX = 12807, + RISCV_VNMSAC_VV = 12808, + RISCV_VNMSAC_VX = 12809, + RISCV_VNMSUB_VV = 12810, + RISCV_VNMSUB_VX = 12811, + RISCV_VNSRA_WI = 12812, + RISCV_VNSRA_WV = 12813, + RISCV_VNSRA_WX = 12814, + RISCV_VNSRL_WI = 12815, + RISCV_VNSRL_WV = 12816, + RISCV_VNSRL_WX = 12817, + RISCV_VOR_VI = 12818, + RISCV_VOR_VV = 12819, + RISCV_VOR_VX = 12820, + RISCV_VQMACCSU_2x8x2 = 12821, + RISCV_VQMACCSU_4x8x4 = 12822, + RISCV_VQMACCUS_2x8x2 = 12823, + RISCV_VQMACCUS_4x8x4 = 12824, + RISCV_VQMACCU_2x8x2 = 12825, + RISCV_VQMACCU_4x8x4 = 12826, + RISCV_VQMACC_2x8x2 = 12827, + RISCV_VQMACC_4x8x4 = 12828, + RISCV_VREDAND_VS = 12829, + RISCV_VREDMAXU_VS = 12830, + RISCV_VREDMAX_VS = 12831, + RISCV_VREDMINU_VS = 12832, + RISCV_VREDMIN_VS = 12833, + RISCV_VREDOR_VS = 12834, + RISCV_VREDSUM_VS = 12835, + RISCV_VREDXOR_VS = 12836, + RISCV_VREMU_VV = 12837, + RISCV_VREMU_VX = 12838, + RISCV_VREM_VV = 12839, + RISCV_VREM_VX = 12840, + RISCV_VREV8_V = 12841, + RISCV_VRGATHEREI16_VV = 12842, + RISCV_VRGATHER_VI = 12843, + RISCV_VRGATHER_VV = 12844, + RISCV_VRGATHER_VX = 12845, + RISCV_VROL_VV = 12846, + RISCV_VROL_VX = 12847, + RISCV_VROR_VI = 12848, + RISCV_VROR_VV = 12849, + RISCV_VROR_VX = 12850, + RISCV_VRSUB_VI = 12851, + RISCV_VRSUB_VX = 12852, + RISCV_VS1R_V = 12853, + RISCV_VS2R_V = 12854, + RISCV_VS4R_V = 12855, + RISCV_VS8R_V = 12856, + RISCV_VSADDU_VI = 12857, + RISCV_VSADDU_VV = 12858, + RISCV_VSADDU_VX = 12859, + RISCV_VSADD_VI = 12860, + RISCV_VSADD_VV = 12861, + RISCV_VSADD_VX = 12862, + RISCV_VSBC_VVM = 12863, + RISCV_VSBC_VXM = 12864, + RISCV_VSE16_V = 12865, + RISCV_VSE32_V = 12866, + RISCV_VSE64_V = 12867, + RISCV_VSE8_V = 12868, + RISCV_VSETIVLI = 12869, + RISCV_VSETVL = 12870, + RISCV_VSETVLI = 12871, + RISCV_VSEXT_VF2 = 12872, + RISCV_VSEXT_VF4 = 12873, + RISCV_VSEXT_VF8 = 12874, + RISCV_VSHA2CH_VV = 12875, + RISCV_VSHA2CL_VV = 12876, + RISCV_VSHA2MS_VV = 12877, + RISCV_VSLIDE1DOWN_VX = 12878, + RISCV_VSLIDE1UP_VX = 12879, + RISCV_VSLIDEDOWN_VI = 12880, + RISCV_VSLIDEDOWN_VX = 12881, + RISCV_VSLIDEUP_VI = 12882, + RISCV_VSLIDEUP_VX = 12883, + RISCV_VSLL_VI = 12884, + RISCV_VSLL_VV = 12885, + RISCV_VSLL_VX = 12886, + RISCV_VSM3C_VI = 12887, + RISCV_VSM3ME_VV = 12888, + RISCV_VSM4K_VI = 12889, + RISCV_VSM4R_VS = 12890, + RISCV_VSM4R_VV = 12891, + RISCV_VSMUL_VV = 12892, + RISCV_VSMUL_VX = 12893, + RISCV_VSM_V = 12894, + RISCV_VSOXEI16_V = 12895, + RISCV_VSOXEI32_V = 12896, + RISCV_VSOXEI64_V = 12897, + RISCV_VSOXEI8_V = 12898, + RISCV_VSOXSEG2EI16_V = 12899, + RISCV_VSOXSEG2EI32_V = 12900, + RISCV_VSOXSEG2EI64_V = 12901, + RISCV_VSOXSEG2EI8_V = 12902, + RISCV_VSOXSEG3EI16_V = 12903, + RISCV_VSOXSEG3EI32_V = 12904, + RISCV_VSOXSEG3EI64_V = 12905, + RISCV_VSOXSEG3EI8_V = 12906, + RISCV_VSOXSEG4EI16_V = 12907, + RISCV_VSOXSEG4EI32_V = 12908, + RISCV_VSOXSEG4EI64_V = 12909, + RISCV_VSOXSEG4EI8_V = 12910, + RISCV_VSOXSEG5EI16_V = 12911, + RISCV_VSOXSEG5EI32_V = 12912, + RISCV_VSOXSEG5EI64_V = 12913, + RISCV_VSOXSEG5EI8_V = 12914, + RISCV_VSOXSEG6EI16_V = 12915, + RISCV_VSOXSEG6EI32_V = 12916, + RISCV_VSOXSEG6EI64_V = 12917, + RISCV_VSOXSEG6EI8_V = 12918, + RISCV_VSOXSEG7EI16_V = 12919, + RISCV_VSOXSEG7EI32_V = 12920, + RISCV_VSOXSEG7EI64_V = 12921, + RISCV_VSOXSEG7EI8_V = 12922, + RISCV_VSOXSEG8EI16_V = 12923, + RISCV_VSOXSEG8EI32_V = 12924, + RISCV_VSOXSEG8EI64_V = 12925, + RISCV_VSOXSEG8EI8_V = 12926, + RISCV_VSRA_VI = 12927, + RISCV_VSRA_VV = 12928, + RISCV_VSRA_VX = 12929, + RISCV_VSRL_VI = 12930, + RISCV_VSRL_VV = 12931, + RISCV_VSRL_VX = 12932, + RISCV_VSSE16_V = 12933, + RISCV_VSSE32_V = 12934, + RISCV_VSSE64_V = 12935, + RISCV_VSSE8_V = 12936, + RISCV_VSSEG2E16_V = 12937, + RISCV_VSSEG2E32_V = 12938, + RISCV_VSSEG2E64_V = 12939, + RISCV_VSSEG2E8_V = 12940, + RISCV_VSSEG3E16_V = 12941, + RISCV_VSSEG3E32_V = 12942, + RISCV_VSSEG3E64_V = 12943, + RISCV_VSSEG3E8_V = 12944, + RISCV_VSSEG4E16_V = 12945, + RISCV_VSSEG4E32_V = 12946, + RISCV_VSSEG4E64_V = 12947, + RISCV_VSSEG4E8_V = 12948, + RISCV_VSSEG5E16_V = 12949, + RISCV_VSSEG5E32_V = 12950, + RISCV_VSSEG5E64_V = 12951, + RISCV_VSSEG5E8_V = 12952, + RISCV_VSSEG6E16_V = 12953, + RISCV_VSSEG6E32_V = 12954, + RISCV_VSSEG6E64_V = 12955, + RISCV_VSSEG6E8_V = 12956, + RISCV_VSSEG7E16_V = 12957, + RISCV_VSSEG7E32_V = 12958, + RISCV_VSSEG7E64_V = 12959, + RISCV_VSSEG7E8_V = 12960, + RISCV_VSSEG8E16_V = 12961, + RISCV_VSSEG8E32_V = 12962, + RISCV_VSSEG8E64_V = 12963, + RISCV_VSSEG8E8_V = 12964, + RISCV_VSSRA_VI = 12965, + RISCV_VSSRA_VV = 12966, + RISCV_VSSRA_VX = 12967, + RISCV_VSSRL_VI = 12968, + RISCV_VSSRL_VV = 12969, + RISCV_VSSRL_VX = 12970, + RISCV_VSSSEG2E16_V = 12971, + RISCV_VSSSEG2E32_V = 12972, + RISCV_VSSSEG2E64_V = 12973, + RISCV_VSSSEG2E8_V = 12974, + RISCV_VSSSEG3E16_V = 12975, + RISCV_VSSSEG3E32_V = 12976, + RISCV_VSSSEG3E64_V = 12977, + RISCV_VSSSEG3E8_V = 12978, + RISCV_VSSSEG4E16_V = 12979, + RISCV_VSSSEG4E32_V = 12980, + RISCV_VSSSEG4E64_V = 12981, + RISCV_VSSSEG4E8_V = 12982, + RISCV_VSSSEG5E16_V = 12983, + RISCV_VSSSEG5E32_V = 12984, + RISCV_VSSSEG5E64_V = 12985, + RISCV_VSSSEG5E8_V = 12986, + RISCV_VSSSEG6E16_V = 12987, + RISCV_VSSSEG6E32_V = 12988, + RISCV_VSSSEG6E64_V = 12989, + RISCV_VSSSEG6E8_V = 12990, + RISCV_VSSSEG7E16_V = 12991, + RISCV_VSSSEG7E32_V = 12992, + RISCV_VSSSEG7E64_V = 12993, + RISCV_VSSSEG7E8_V = 12994, + RISCV_VSSSEG8E16_V = 12995, + RISCV_VSSSEG8E32_V = 12996, + RISCV_VSSSEG8E64_V = 12997, + RISCV_VSSSEG8E8_V = 12998, + RISCV_VSSUBU_VV = 12999, + RISCV_VSSUBU_VX = 13000, + RISCV_VSSUB_VV = 13001, + RISCV_VSSUB_VX = 13002, + RISCV_VSUB_VV = 13003, + RISCV_VSUB_VX = 13004, + RISCV_VSUXEI16_V = 13005, + RISCV_VSUXEI32_V = 13006, + RISCV_VSUXEI64_V = 13007, + RISCV_VSUXEI8_V = 13008, + RISCV_VSUXSEG2EI16_V = 13009, + RISCV_VSUXSEG2EI32_V = 13010, + RISCV_VSUXSEG2EI64_V = 13011, + RISCV_VSUXSEG2EI8_V = 13012, + RISCV_VSUXSEG3EI16_V = 13013, + RISCV_VSUXSEG3EI32_V = 13014, + RISCV_VSUXSEG3EI64_V = 13015, + RISCV_VSUXSEG3EI8_V = 13016, + RISCV_VSUXSEG4EI16_V = 13017, + RISCV_VSUXSEG4EI32_V = 13018, + RISCV_VSUXSEG4EI64_V = 13019, + RISCV_VSUXSEG4EI8_V = 13020, + RISCV_VSUXSEG5EI16_V = 13021, + RISCV_VSUXSEG5EI32_V = 13022, + RISCV_VSUXSEG5EI64_V = 13023, + RISCV_VSUXSEG5EI8_V = 13024, + RISCV_VSUXSEG6EI16_V = 13025, + RISCV_VSUXSEG6EI32_V = 13026, + RISCV_VSUXSEG6EI64_V = 13027, + RISCV_VSUXSEG6EI8_V = 13028, + RISCV_VSUXSEG7EI16_V = 13029, + RISCV_VSUXSEG7EI32_V = 13030, + RISCV_VSUXSEG7EI64_V = 13031, + RISCV_VSUXSEG7EI8_V = 13032, + RISCV_VSUXSEG8EI16_V = 13033, + RISCV_VSUXSEG8EI32_V = 13034, + RISCV_VSUXSEG8EI64_V = 13035, + RISCV_VSUXSEG8EI8_V = 13036, + RISCV_VT_MASKC = 13037, + RISCV_VT_MASKCN = 13038, + RISCV_VWADDU_VV = 13039, + RISCV_VWADDU_VX = 13040, + RISCV_VWADDU_WV = 13041, + RISCV_VWADDU_WX = 13042, + RISCV_VWADD_VV = 13043, + RISCV_VWADD_VX = 13044, + RISCV_VWADD_WV = 13045, + RISCV_VWADD_WX = 13046, + RISCV_VWMACCSU_VV = 13047, + RISCV_VWMACCSU_VX = 13048, + RISCV_VWMACCUS_VX = 13049, + RISCV_VWMACCU_VV = 13050, + RISCV_VWMACCU_VX = 13051, + RISCV_VWMACC_VV = 13052, + RISCV_VWMACC_VX = 13053, + RISCV_VWMULSU_VV = 13054, + RISCV_VWMULSU_VX = 13055, + RISCV_VWMULU_VV = 13056, + RISCV_VWMULU_VX = 13057, + RISCV_VWMUL_VV = 13058, + RISCV_VWMUL_VX = 13059, + RISCV_VWREDSUMU_VS = 13060, + RISCV_VWREDSUM_VS = 13061, + RISCV_VWSLL_VI = 13062, + RISCV_VWSLL_VV = 13063, + RISCV_VWSLL_VX = 13064, + RISCV_VWSUBU_VV = 13065, + RISCV_VWSUBU_VX = 13066, + RISCV_VWSUBU_WV = 13067, + RISCV_VWSUBU_WX = 13068, + RISCV_VWSUB_VV = 13069, + RISCV_VWSUB_VX = 13070, + RISCV_VWSUB_WV = 13071, + RISCV_VWSUB_WX = 13072, + RISCV_VXOR_VI = 13073, + RISCV_VXOR_VV = 13074, + RISCV_VXOR_VX = 13075, + RISCV_VZEXT_VF2 = 13076, + RISCV_VZEXT_VF4 = 13077, + RISCV_VZEXT_VF8 = 13078, + RISCV_WFI = 13079, + RISCV_WRS_NTO = 13080, + RISCV_WRS_STO = 13081, + RISCV_XNOR = 13082, + RISCV_XOR = 13083, + RISCV_XORI = 13084, + RISCV_XPERM4 = 13085, + RISCV_XPERM8 = 13086, + RISCV_ZEXT_H_RV32 = 13087, + RISCV_ZEXT_H_RV64 = 13088, + RISCV_ZIP_RV32 = 13089, + INSTRUCTION_LIST_END = 13090 }; #endif // GET_INSTRINFO_ENUM + +#if defined(GET_INSTRINFO_MC_DESC) || defined(GET_INSTRINFO_CTOR_DTOR) +typedef struct RISCVInstrTable { + MCInstrDesc Insts[13090]; + MCOperandInfo OperandInfo[8522]; + MCPhysReg ImplicitOps[36]; +} RISCVInstrTable; + +#endif // defined(GET_INSTRINFO_MC_DESC) || defined(GET_INSTRINFO_CTOR_DTOR) + +#ifdef GET_INSTRINFO_MC_DESC +#undef GET_INSTRINFO_MC_DESC + +static const unsigned RISCVImpOpBase = sizeof(MCOperandInfo) / (sizeof(MCPhysReg)); + +static const RISCVInstrTable RISCVDescs = { + { + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #13089 = ZIP_RV32 + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #13088 = ZEXT_H_RV64 + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #13087 = ZEXT_H_RV32 + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #13086 = XPERM8 + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #13085 = XPERM4 + { 3, &RISCVDescs.OperandInfo[7808] }, // Inst #13084 = XORI + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #13083 = XOR + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #13082 = XNOR + { 0, &RISCVDescs.OperandInfo[1] }, // Inst #13081 = WRS_STO + { 0, &RISCVDescs.OperandInfo[1] }, // Inst #13080 = WRS_NTO + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #13079 = WFI + { 3, &RISCVDescs.OperandInfo[8319] }, // Inst #13078 = VZEXT_VF8 + { 3, &RISCVDescs.OperandInfo[8319] }, // Inst #13077 = VZEXT_VF4 + { 3, &RISCVDescs.OperandInfo[8319] }, // Inst #13076 = VZEXT_VF2 + { 4, &RISCVDescs.OperandInfo[8306] }, // Inst #13075 = VXOR_VX + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #13074 = VXOR_VV + { 4, &RISCVDescs.OperandInfo[8310] }, // Inst #13073 = VXOR_VI + { 4, &RISCVDescs.OperandInfo[8488] }, // Inst #13072 = VWSUB_WX + { 4, &RISCVDescs.OperandInfo[8440] }, // Inst #13071 = VWSUB_WV + { 4, &RISCVDescs.OperandInfo[8488] }, // Inst #13070 = VWSUB_VX + { 4, &RISCVDescs.OperandInfo[8440] }, // Inst #13069 = VWSUB_VV + { 4, &RISCVDescs.OperandInfo[8488] }, // Inst #13068 = VWSUBU_WX + { 4, &RISCVDescs.OperandInfo[8440] }, // Inst #13067 = VWSUBU_WV + { 4, &RISCVDescs.OperandInfo[8488] }, // Inst #13066 = VWSUBU_VX + { 4, &RISCVDescs.OperandInfo[8440] }, // Inst #13065 = VWSUBU_VV + { 4, &RISCVDescs.OperandInfo[8488] }, // Inst #13064 = VWSLL_VX + { 4, &RISCVDescs.OperandInfo[8440] }, // Inst #13063 = VWSLL_VV + { 4, &RISCVDescs.OperandInfo[8507] }, // Inst #13062 = VWSLL_VI + { 4, &RISCVDescs.OperandInfo[8440] }, // Inst #13061 = VWREDSUM_VS + { 4, &RISCVDescs.OperandInfo[8440] }, // Inst #13060 = VWREDSUMU_VS + { 4, &RISCVDescs.OperandInfo[8488] }, // Inst #13059 = VWMUL_VX + { 4, &RISCVDescs.OperandInfo[8440] }, // Inst #13058 = VWMUL_VV + { 4, &RISCVDescs.OperandInfo[8488] }, // Inst #13057 = VWMULU_VX + { 4, &RISCVDescs.OperandInfo[8440] }, // Inst #13056 = VWMULU_VV + { 4, &RISCVDescs.OperandInfo[8488] }, // Inst #13055 = VWMULSU_VX + { 4, &RISCVDescs.OperandInfo[8440] }, // Inst #13054 = VWMULSU_VV + { 5, &RISCVDescs.OperandInfo[8473] }, // Inst #13053 = VWMACC_VX + { 5, &RISCVDescs.OperandInfo[8260] }, // Inst #13052 = VWMACC_VV + { 5, &RISCVDescs.OperandInfo[8473] }, // Inst #13051 = VWMACCU_VX + { 5, &RISCVDescs.OperandInfo[8260] }, // Inst #13050 = VWMACCU_VV + { 5, &RISCVDescs.OperandInfo[8473] }, // Inst #13049 = VWMACCUS_VX + { 5, &RISCVDescs.OperandInfo[8473] }, // Inst #13048 = VWMACCSU_VX + { 5, &RISCVDescs.OperandInfo[8260] }, // Inst #13047 = VWMACCSU_VV + { 4, &RISCVDescs.OperandInfo[8488] }, // Inst #13046 = VWADD_WX + { 4, &RISCVDescs.OperandInfo[8440] }, // Inst #13045 = VWADD_WV + { 4, &RISCVDescs.OperandInfo[8488] }, // Inst #13044 = VWADD_VX + { 4, &RISCVDescs.OperandInfo[8440] }, // Inst #13043 = VWADD_VV + { 4, &RISCVDescs.OperandInfo[8488] }, // Inst #13042 = VWADDU_WX + { 4, &RISCVDescs.OperandInfo[8440] }, // Inst #13041 = VWADDU_WV + { 4, &RISCVDescs.OperandInfo[8488] }, // Inst #13040 = VWADDU_VX + { 4, &RISCVDescs.OperandInfo[8440] }, // Inst #13039 = VWADDU_VV + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #13038 = VT_MASKCN + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #13037 = VT_MASKC + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #13036 = VSUXSEG8EI8_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #13035 = VSUXSEG8EI64_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #13034 = VSUXSEG8EI32_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #13033 = VSUXSEG8EI16_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #13032 = VSUXSEG7EI8_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #13031 = VSUXSEG7EI64_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #13030 = VSUXSEG7EI32_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #13029 = VSUXSEG7EI16_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #13028 = VSUXSEG6EI8_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #13027 = VSUXSEG6EI64_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #13026 = VSUXSEG6EI32_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #13025 = VSUXSEG6EI16_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #13024 = VSUXSEG5EI8_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #13023 = VSUXSEG5EI64_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #13022 = VSUXSEG5EI32_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #13021 = VSUXSEG5EI16_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #13020 = VSUXSEG4EI8_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #13019 = VSUXSEG4EI64_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #13018 = VSUXSEG4EI32_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #13017 = VSUXSEG4EI16_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #13016 = VSUXSEG3EI8_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #13015 = VSUXSEG3EI64_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #13014 = VSUXSEG3EI32_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #13013 = VSUXSEG3EI16_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #13012 = VSUXSEG2EI8_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #13011 = VSUXSEG2EI64_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #13010 = VSUXSEG2EI32_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #13009 = VSUXSEG2EI16_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #13008 = VSUXEI8_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #13007 = VSUXEI64_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #13006 = VSUXEI32_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #13005 = VSUXEI16_V + { 4, &RISCVDescs.OperandInfo[8306] }, // Inst #13004 = VSUB_VX + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #13003 = VSUB_VV + { 4, &RISCVDescs.OperandInfo[8306] }, // Inst #13002 = VSSUB_VX + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #13001 = VSSUB_VV + { 4, &RISCVDescs.OperandInfo[8306] }, // Inst #13000 = VSSUBU_VX + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12999 = VSSUBU_VV + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12998 = VSSSEG8E8_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12997 = VSSSEG8E64_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12996 = VSSSEG8E32_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12995 = VSSSEG8E16_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12994 = VSSSEG7E8_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12993 = VSSSEG7E64_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12992 = VSSSEG7E32_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12991 = VSSSEG7E16_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12990 = VSSSEG6E8_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12989 = VSSSEG6E64_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12988 = VSSSEG6E32_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12987 = VSSSEG6E16_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12986 = VSSSEG5E8_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12985 = VSSSEG5E64_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12984 = VSSSEG5E32_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12983 = VSSSEG5E16_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12982 = VSSSEG4E8_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12981 = VSSSEG4E64_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12980 = VSSSEG4E32_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12979 = VSSSEG4E16_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12978 = VSSSEG3E8_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12977 = VSSSEG3E64_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12976 = VSSSEG3E32_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12975 = VSSSEG3E16_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12974 = VSSSEG2E8_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12973 = VSSSEG2E64_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12972 = VSSSEG2E32_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12971 = VSSSEG2E16_V + { 4, &RISCVDescs.OperandInfo[8306] }, // Inst #12970 = VSSRL_VX + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12969 = VSSRL_VV + { 4, &RISCVDescs.OperandInfo[8518] }, // Inst #12968 = VSSRL_VI + { 4, &RISCVDescs.OperandInfo[8306] }, // Inst #12967 = VSSRA_VX + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12966 = VSSRA_VV + { 4, &RISCVDescs.OperandInfo[8518] }, // Inst #12965 = VSSRA_VI + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12964 = VSSEG8E8_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12963 = VSSEG8E64_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12962 = VSSEG8E32_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12961 = VSSEG8E16_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12960 = VSSEG7E8_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12959 = VSSEG7E64_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12958 = VSSEG7E32_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12957 = VSSEG7E16_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12956 = VSSEG6E8_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12955 = VSSEG6E64_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12954 = VSSEG6E32_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12953 = VSSEG6E16_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12952 = VSSEG5E8_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12951 = VSSEG5E64_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12950 = VSSEG5E32_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12949 = VSSEG5E16_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12948 = VSSEG4E8_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12947 = VSSEG4E64_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12946 = VSSEG4E32_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12945 = VSSEG4E16_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12944 = VSSEG3E8_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12943 = VSSEG3E64_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12942 = VSSEG3E32_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12941 = VSSEG3E16_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12940 = VSSEG2E8_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12939 = VSSEG2E64_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12938 = VSSEG2E32_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12937 = VSSEG2E16_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12936 = VSSE8_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12935 = VSSE64_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12934 = VSSE32_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12933 = VSSE16_V + { 4, &RISCVDescs.OperandInfo[8306] }, // Inst #12932 = VSRL_VX + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12931 = VSRL_VV + { 4, &RISCVDescs.OperandInfo[8518] }, // Inst #12930 = VSRL_VI + { 4, &RISCVDescs.OperandInfo[8306] }, // Inst #12929 = VSRA_VX + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12928 = VSRA_VV + { 4, &RISCVDescs.OperandInfo[8518] }, // Inst #12927 = VSRA_VI + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12926 = VSOXSEG8EI8_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12925 = VSOXSEG8EI64_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12924 = VSOXSEG8EI32_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12923 = VSOXSEG8EI16_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12922 = VSOXSEG7EI8_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12921 = VSOXSEG7EI64_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12920 = VSOXSEG7EI32_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12919 = VSOXSEG7EI16_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12918 = VSOXSEG6EI8_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12917 = VSOXSEG6EI64_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12916 = VSOXSEG6EI32_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12915 = VSOXSEG6EI16_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12914 = VSOXSEG5EI8_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12913 = VSOXSEG5EI64_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12912 = VSOXSEG5EI32_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12911 = VSOXSEG5EI16_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12910 = VSOXSEG4EI8_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12909 = VSOXSEG4EI64_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12908 = VSOXSEG4EI32_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12907 = VSOXSEG4EI16_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12906 = VSOXSEG3EI8_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12905 = VSOXSEG3EI64_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12904 = VSOXSEG3EI32_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12903 = VSOXSEG3EI16_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12902 = VSOXSEG2EI8_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12901 = VSOXSEG2EI64_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12900 = VSOXSEG2EI32_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12899 = VSOXSEG2EI16_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12898 = VSOXEI8_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12897 = VSOXEI64_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12896 = VSOXEI32_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12895 = VSOXEI16_V + { 2, &RISCVDescs.OperandInfo[8454] }, // Inst #12894 = VSM_V + { 4, &RISCVDescs.OperandInfo[8306] }, // Inst #12893 = VSMUL_VX + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12892 = VSMUL_VV + { 2, &RISCVDescs.OperandInfo[8314] }, // Inst #12891 = VSM4R_VV + { 2, &RISCVDescs.OperandInfo[8314] }, // Inst #12890 = VSM4R_VS + { 3, &RISCVDescs.OperandInfo[8316] }, // Inst #12889 = VSM4K_VI + { 3, &RISCVDescs.OperandInfo[8449] }, // Inst #12888 = VSM3ME_VV + { 3, &RISCVDescs.OperandInfo[8316] }, // Inst #12887 = VSM3C_VI + { 4, &RISCVDescs.OperandInfo[8306] }, // Inst #12886 = VSLL_VX + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12885 = VSLL_VV + { 4, &RISCVDescs.OperandInfo[8518] }, // Inst #12884 = VSLL_VI + { 4, &RISCVDescs.OperandInfo[8488] }, // Inst #12883 = VSLIDEUP_VX + { 4, &RISCVDescs.OperandInfo[8507] }, // Inst #12882 = VSLIDEUP_VI + { 4, &RISCVDescs.OperandInfo[8306] }, // Inst #12881 = VSLIDEDOWN_VX + { 4, &RISCVDescs.OperandInfo[8518] }, // Inst #12880 = VSLIDEDOWN_VI + { 4, &RISCVDescs.OperandInfo[8488] }, // Inst #12879 = VSLIDE1UP_VX + { 4, &RISCVDescs.OperandInfo[8306] }, // Inst #12878 = VSLIDE1DOWN_VX + { 3, &RISCVDescs.OperandInfo[8449] }, // Inst #12877 = VSHA2MS_VV + { 3, &RISCVDescs.OperandInfo[8449] }, // Inst #12876 = VSHA2CL_VV + { 3, &RISCVDescs.OperandInfo[8449] }, // Inst #12875 = VSHA2CH_VV + { 3, &RISCVDescs.OperandInfo[8319] }, // Inst #12874 = VSEXT_VF8 + { 3, &RISCVDescs.OperandInfo[8319] }, // Inst #12873 = VSEXT_VF4 + { 3, &RISCVDescs.OperandInfo[8319] }, // Inst #12872 = VSEXT_VF2 + { 3, &RISCVDescs.OperandInfo[8515] }, // Inst #12871 = VSETVLI + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #12870 = VSETVL + { 3, &RISCVDescs.OperandInfo[6556] }, // Inst #12869 = VSETIVLI + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12868 = VSE8_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12867 = VSE64_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12866 = VSE32_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12865 = VSE16_V + { 4, &RISCVDescs.OperandInfo[8306] }, // Inst #12864 = VSBC_VXM + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12863 = VSBC_VVM + { 4, &RISCVDescs.OperandInfo[8306] }, // Inst #12862 = VSADD_VX + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12861 = VSADD_VV + { 4, &RISCVDescs.OperandInfo[8310] }, // Inst #12860 = VSADD_VI + { 4, &RISCVDescs.OperandInfo[8306] }, // Inst #12859 = VSADDU_VX + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12858 = VSADDU_VV + { 4, &RISCVDescs.OperandInfo[8310] }, // Inst #12857 = VSADDU_VI + { 2, &RISCVDescs.OperandInfo[8460] }, // Inst #12856 = VS8R_V + { 2, &RISCVDescs.OperandInfo[8458] }, // Inst #12855 = VS4R_V + { 2, &RISCVDescs.OperandInfo[8456] }, // Inst #12854 = VS2R_V + { 2, &RISCVDescs.OperandInfo[8454] }, // Inst #12853 = VS1R_V + { 4, &RISCVDescs.OperandInfo[8306] }, // Inst #12852 = VRSUB_VX + { 4, &RISCVDescs.OperandInfo[8310] }, // Inst #12851 = VRSUB_VI + { 4, &RISCVDescs.OperandInfo[8306] }, // Inst #12850 = VROR_VX + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12849 = VROR_VV + { 4, &RISCVDescs.OperandInfo[8511] }, // Inst #12848 = VROR_VI + { 4, &RISCVDescs.OperandInfo[8306] }, // Inst #12847 = VROL_VX + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12846 = VROL_VV + { 4, &RISCVDescs.OperandInfo[8488] }, // Inst #12845 = VRGATHER_VX + { 4, &RISCVDescs.OperandInfo[8440] }, // Inst #12844 = VRGATHER_VV + { 4, &RISCVDescs.OperandInfo[8507] }, // Inst #12843 = VRGATHER_VI + { 4, &RISCVDescs.OperandInfo[8440] }, // Inst #12842 = VRGATHEREI16_VV + { 3, &RISCVDescs.OperandInfo[8319] }, // Inst #12841 = VREV8_V + { 4, &RISCVDescs.OperandInfo[8306] }, // Inst #12840 = VREM_VX + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12839 = VREM_VV + { 4, &RISCVDescs.OperandInfo[8306] }, // Inst #12838 = VREMU_VX + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12837 = VREMU_VV + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12836 = VREDXOR_VS + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12835 = VREDSUM_VS + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12834 = VREDOR_VS + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12833 = VREDMIN_VS + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12832 = VREDMINU_VS + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12831 = VREDMAX_VS + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12830 = VREDMAXU_VS + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12829 = VREDAND_VS + { 3, &RISCVDescs.OperandInfo[8449] }, // Inst #12828 = VQMACC_4x8x4 + { 3, &RISCVDescs.OperandInfo[8449] }, // Inst #12827 = VQMACC_2x8x2 + { 3, &RISCVDescs.OperandInfo[8449] }, // Inst #12826 = VQMACCU_4x8x4 + { 3, &RISCVDescs.OperandInfo[8449] }, // Inst #12825 = VQMACCU_2x8x2 + { 3, &RISCVDescs.OperandInfo[8449] }, // Inst #12824 = VQMACCUS_4x8x4 + { 3, &RISCVDescs.OperandInfo[8449] }, // Inst #12823 = VQMACCUS_2x8x2 + { 3, &RISCVDescs.OperandInfo[8449] }, // Inst #12822 = VQMACCSU_4x8x4 + { 3, &RISCVDescs.OperandInfo[8449] }, // Inst #12821 = VQMACCSU_2x8x2 + { 4, &RISCVDescs.OperandInfo[8306] }, // Inst #12820 = VOR_VX + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12819 = VOR_VV + { 4, &RISCVDescs.OperandInfo[8310] }, // Inst #12818 = VOR_VI + { 4, &RISCVDescs.OperandInfo[8488] }, // Inst #12817 = VNSRL_WX + { 4, &RISCVDescs.OperandInfo[8440] }, // Inst #12816 = VNSRL_WV + { 4, &RISCVDescs.OperandInfo[8507] }, // Inst #12815 = VNSRL_WI + { 4, &RISCVDescs.OperandInfo[8488] }, // Inst #12814 = VNSRA_WX + { 4, &RISCVDescs.OperandInfo[8440] }, // Inst #12813 = VNSRA_WV + { 4, &RISCVDescs.OperandInfo[8507] }, // Inst #12812 = VNSRA_WI + { 5, &RISCVDescs.OperandInfo[8473] }, // Inst #12811 = VNMSUB_VX + { 5, &RISCVDescs.OperandInfo[8421] }, // Inst #12810 = VNMSUB_VV + { 5, &RISCVDescs.OperandInfo[8473] }, // Inst #12809 = VNMSAC_VX + { 5, &RISCVDescs.OperandInfo[8421] }, // Inst #12808 = VNMSAC_VV + { 4, &RISCVDescs.OperandInfo[8488] }, // Inst #12807 = VNCLIP_WX + { 4, &RISCVDescs.OperandInfo[8440] }, // Inst #12806 = VNCLIP_WV + { 4, &RISCVDescs.OperandInfo[8507] }, // Inst #12805 = VNCLIP_WI + { 4, &RISCVDescs.OperandInfo[8488] }, // Inst #12804 = VNCLIPU_WX + { 4, &RISCVDescs.OperandInfo[8440] }, // Inst #12803 = VNCLIPU_WV + { 4, &RISCVDescs.OperandInfo[8507] }, // Inst #12802 = VNCLIPU_WI + { 3, &RISCVDescs.OperandInfo[8449] }, // Inst #12801 = VMXOR_MM + { 3, &RISCVDescs.OperandInfo[8449] }, // Inst #12800 = VMXNOR_MM + { 2, &RISCVDescs.OperandInfo[8505] }, // Inst #12799 = VMV_X_S + { 2, &RISCVDescs.OperandInfo[8503] }, // Inst #12798 = VMV_V_X + { 2, &RISCVDescs.OperandInfo[8314] }, // Inst #12797 = VMV_V_V + { 2, &RISCVDescs.OperandInfo[8501] }, // Inst #12796 = VMV_V_I + { 3, &RISCVDescs.OperandInfo[8498] }, // Inst #12795 = VMV_S_X + { 2, &RISCVDescs.OperandInfo[8496] }, // Inst #12794 = VMV8R_V + { 2, &RISCVDescs.OperandInfo[8494] }, // Inst #12793 = VMV4R_V + { 2, &RISCVDescs.OperandInfo[8492] }, // Inst #12792 = VMV2R_V + { 2, &RISCVDescs.OperandInfo[8314] }, // Inst #12791 = VMV1R_V + { 4, &RISCVDescs.OperandInfo[8306] }, // Inst #12790 = VMUL_VX + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12789 = VMUL_VV + { 4, &RISCVDescs.OperandInfo[8306] }, // Inst #12788 = VMULH_VX + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12787 = VMULH_VV + { 4, &RISCVDescs.OperandInfo[8306] }, // Inst #12786 = VMULHU_VX + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12785 = VMULHU_VV + { 4, &RISCVDescs.OperandInfo[8306] }, // Inst #12784 = VMULHSU_VX + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12783 = VMULHSU_VV + { 3, &RISCVDescs.OperandInfo[8433] }, // Inst #12782 = VMSOF_M + { 4, &RISCVDescs.OperandInfo[8306] }, // Inst #12781 = VMSNE_VX + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12780 = VMSNE_VV + { 4, &RISCVDescs.OperandInfo[8310] }, // Inst #12779 = VMSNE_VI + { 4, &RISCVDescs.OperandInfo[8306] }, // Inst #12778 = VMSLT_VX + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12777 = VMSLT_VV + { 4, &RISCVDescs.OperandInfo[8306] }, // Inst #12776 = VMSLTU_VX + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12775 = VMSLTU_VV + { 4, &RISCVDescs.OperandInfo[8306] }, // Inst #12774 = VMSLE_VX + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12773 = VMSLE_VV + { 4, &RISCVDescs.OperandInfo[8310] }, // Inst #12772 = VMSLE_VI + { 4, &RISCVDescs.OperandInfo[8306] }, // Inst #12771 = VMSLEU_VX + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12770 = VMSLEU_VV + { 4, &RISCVDescs.OperandInfo[8310] }, // Inst #12769 = VMSLEU_VI + { 3, &RISCVDescs.OperandInfo[8433] }, // Inst #12768 = VMSIF_M + { 4, &RISCVDescs.OperandInfo[8306] }, // Inst #12767 = VMSGT_VX + { 4, &RISCVDescs.OperandInfo[8310] }, // Inst #12766 = VMSGT_VI + { 4, &RISCVDescs.OperandInfo[8306] }, // Inst #12765 = VMSGTU_VX + { 4, &RISCVDescs.OperandInfo[8310] }, // Inst #12764 = VMSGTU_VI + { 4, &RISCVDescs.OperandInfo[8306] }, // Inst #12763 = VMSEQ_VX + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12762 = VMSEQ_VV + { 4, &RISCVDescs.OperandInfo[8310] }, // Inst #12761 = VMSEQ_VI + { 3, &RISCVDescs.OperandInfo[8433] }, // Inst #12760 = VMSBF_M + { 4, &RISCVDescs.OperandInfo[8488] }, // Inst #12759 = VMSBC_VXM + { 3, &RISCVDescs.OperandInfo[8485] }, // Inst #12758 = VMSBC_VX + { 4, &RISCVDescs.OperandInfo[8440] }, // Inst #12757 = VMSBC_VVM + { 3, &RISCVDescs.OperandInfo[8322] }, // Inst #12756 = VMSBC_VV + { 3, &RISCVDescs.OperandInfo[8449] }, // Inst #12755 = VMOR_MM + { 3, &RISCVDescs.OperandInfo[8449] }, // Inst #12754 = VMORN_MM + { 3, &RISCVDescs.OperandInfo[8449] }, // Inst #12753 = VMNOR_MM + { 3, &RISCVDescs.OperandInfo[8449] }, // Inst #12752 = VMNAND_MM + { 4, &RISCVDescs.OperandInfo[8306] }, // Inst #12751 = VMIN_VX + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12750 = VMIN_VV + { 4, &RISCVDescs.OperandInfo[8306] }, // Inst #12749 = VMINU_VX + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12748 = VMINU_VV + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12747 = VMFNE_VV + { 4, &RISCVDescs.OperandInfo[8412] }, // Inst #12746 = VMFNE_VF + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12745 = VMFLT_VV + { 4, &RISCVDescs.OperandInfo[8412] }, // Inst #12744 = VMFLT_VF + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12743 = VMFLE_VV + { 4, &RISCVDescs.OperandInfo[8412] }, // Inst #12742 = VMFLE_VF + { 4, &RISCVDescs.OperandInfo[8412] }, // Inst #12741 = VMFGT_VF + { 4, &RISCVDescs.OperandInfo[8412] }, // Inst #12740 = VMFGE_VF + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12739 = VMFEQ_VV + { 4, &RISCVDescs.OperandInfo[8412] }, // Inst #12738 = VMFEQ_VF + { 4, &RISCVDescs.OperandInfo[8306] }, // Inst #12737 = VMERGE_VXM + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12736 = VMERGE_VVM + { 4, &RISCVDescs.OperandInfo[8310] }, // Inst #12735 = VMERGE_VIM + { 4, &RISCVDescs.OperandInfo[8306] }, // Inst #12734 = VMAX_VX + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12733 = VMAX_VV + { 4, &RISCVDescs.OperandInfo[8306] }, // Inst #12732 = VMAXU_VX + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12731 = VMAXU_VV + { 3, &RISCVDescs.OperandInfo[8449] }, // Inst #12730 = VMAND_MM + { 3, &RISCVDescs.OperandInfo[8449] }, // Inst #12729 = VMANDN_MM + { 5, &RISCVDescs.OperandInfo[8473] }, // Inst #12728 = VMADD_VX + { 5, &RISCVDescs.OperandInfo[8421] }, // Inst #12727 = VMADD_VV + { 4, &RISCVDescs.OperandInfo[8488] }, // Inst #12726 = VMADC_VXM + { 3, &RISCVDescs.OperandInfo[8485] }, // Inst #12725 = VMADC_VX + { 4, &RISCVDescs.OperandInfo[8440] }, // Inst #12724 = VMADC_VVM + { 3, &RISCVDescs.OperandInfo[8322] }, // Inst #12723 = VMADC_VV + { 4, &RISCVDescs.OperandInfo[8481] }, // Inst #12722 = VMADC_VIM + { 3, &RISCVDescs.OperandInfo[8478] }, // Inst #12721 = VMADC_VI + { 5, &RISCVDescs.OperandInfo[8473] }, // Inst #12720 = VMACC_VX + { 5, &RISCVDescs.OperandInfo[8421] }, // Inst #12719 = VMACC_VV + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12718 = VLUXSEG8EI8_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12717 = VLUXSEG8EI64_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12716 = VLUXSEG8EI32_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12715 = VLUXSEG8EI16_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12714 = VLUXSEG7EI8_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12713 = VLUXSEG7EI64_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12712 = VLUXSEG7EI32_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12711 = VLUXSEG7EI16_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12710 = VLUXSEG6EI8_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12709 = VLUXSEG6EI64_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12708 = VLUXSEG6EI32_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12707 = VLUXSEG6EI16_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12706 = VLUXSEG5EI8_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12705 = VLUXSEG5EI64_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12704 = VLUXSEG5EI32_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12703 = VLUXSEG5EI16_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12702 = VLUXSEG4EI8_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12701 = VLUXSEG4EI64_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12700 = VLUXSEG4EI32_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12699 = VLUXSEG4EI16_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12698 = VLUXSEG3EI8_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12697 = VLUXSEG3EI64_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12696 = VLUXSEG3EI32_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12695 = VLUXSEG3EI16_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12694 = VLUXSEG2EI8_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12693 = VLUXSEG2EI64_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12692 = VLUXSEG2EI32_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12691 = VLUXSEG2EI16_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12690 = VLUXEI8_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12689 = VLUXEI64_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12688 = VLUXEI32_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12687 = VLUXEI16_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12686 = VLSSEG8E8_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12685 = VLSSEG8E64_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12684 = VLSSEG8E32_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12683 = VLSSEG8E16_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12682 = VLSSEG7E8_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12681 = VLSSEG7E64_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12680 = VLSSEG7E32_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12679 = VLSSEG7E16_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12678 = VLSSEG6E8_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12677 = VLSSEG6E64_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12676 = VLSSEG6E32_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12675 = VLSSEG6E16_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12674 = VLSSEG5E8_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12673 = VLSSEG5E64_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12672 = VLSSEG5E32_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12671 = VLSSEG5E16_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12670 = VLSSEG4E8_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12669 = VLSSEG4E64_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12668 = VLSSEG4E32_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12667 = VLSSEG4E16_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12666 = VLSSEG3E8_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12665 = VLSSEG3E64_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12664 = VLSSEG3E32_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12663 = VLSSEG3E16_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12662 = VLSSEG2E8_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12661 = VLSSEG2E64_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12660 = VLSSEG2E32_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12659 = VLSSEG2E16_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12658 = VLSEG8E8_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12657 = VLSEG8E8FF_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12656 = VLSEG8E64_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12655 = VLSEG8E64FF_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12654 = VLSEG8E32_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12653 = VLSEG8E32FF_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12652 = VLSEG8E16_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12651 = VLSEG8E16FF_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12650 = VLSEG7E8_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12649 = VLSEG7E8FF_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12648 = VLSEG7E64_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12647 = VLSEG7E64FF_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12646 = VLSEG7E32_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12645 = VLSEG7E32FF_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12644 = VLSEG7E16_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12643 = VLSEG7E16FF_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12642 = VLSEG6E8_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12641 = VLSEG6E8FF_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12640 = VLSEG6E64_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12639 = VLSEG6E64FF_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12638 = VLSEG6E32_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12637 = VLSEG6E32FF_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12636 = VLSEG6E16_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12635 = VLSEG6E16FF_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12634 = VLSEG5E8_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12633 = VLSEG5E8FF_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12632 = VLSEG5E64_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12631 = VLSEG5E64FF_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12630 = VLSEG5E32_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12629 = VLSEG5E32FF_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12628 = VLSEG5E16_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12627 = VLSEG5E16FF_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12626 = VLSEG4E8_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12625 = VLSEG4E8FF_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12624 = VLSEG4E64_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12623 = VLSEG4E64FF_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12622 = VLSEG4E32_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12621 = VLSEG4E32FF_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12620 = VLSEG4E16_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12619 = VLSEG4E16FF_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12618 = VLSEG3E8_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12617 = VLSEG3E8FF_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12616 = VLSEG3E64_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12615 = VLSEG3E64FF_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12614 = VLSEG3E32_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12613 = VLSEG3E32FF_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12612 = VLSEG3E16_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12611 = VLSEG3E16FF_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12610 = VLSEG2E8_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12609 = VLSEG2E8FF_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12608 = VLSEG2E64_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12607 = VLSEG2E64FF_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12606 = VLSEG2E32_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12605 = VLSEG2E32FF_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12604 = VLSEG2E16_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12603 = VLSEG2E16FF_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12602 = VLSE8_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12601 = VLSE64_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12600 = VLSE32_V + { 4, &RISCVDescs.OperandInfo[8469] }, // Inst #12599 = VLSE16_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12598 = VLOXSEG8EI8_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12597 = VLOXSEG8EI64_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12596 = VLOXSEG8EI32_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12595 = VLOXSEG8EI16_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12594 = VLOXSEG7EI8_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12593 = VLOXSEG7EI64_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12592 = VLOXSEG7EI32_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12591 = VLOXSEG7EI16_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12590 = VLOXSEG6EI8_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12589 = VLOXSEG6EI64_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12588 = VLOXSEG6EI32_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12587 = VLOXSEG6EI16_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12586 = VLOXSEG5EI8_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12585 = VLOXSEG5EI64_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12584 = VLOXSEG5EI32_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12583 = VLOXSEG5EI16_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12582 = VLOXSEG4EI8_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12581 = VLOXSEG4EI64_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12580 = VLOXSEG4EI32_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12579 = VLOXSEG4EI16_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12578 = VLOXSEG3EI8_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12577 = VLOXSEG3EI64_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12576 = VLOXSEG3EI32_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12575 = VLOXSEG3EI16_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12574 = VLOXSEG2EI8_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12573 = VLOXSEG2EI64_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12572 = VLOXSEG2EI32_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12571 = VLOXSEG2EI16_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12570 = VLOXEI8_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12569 = VLOXEI64_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12568 = VLOXEI32_V + { 4, &RISCVDescs.OperandInfo[8465] }, // Inst #12567 = VLOXEI16_V + { 2, &RISCVDescs.OperandInfo[8454] }, // Inst #12566 = VLM_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12565 = VLE8_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12564 = VLE8FF_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12563 = VLE64_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12562 = VLE64FF_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12561 = VLE32_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12560 = VLE32FF_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12559 = VLE16_V + { 3, &RISCVDescs.OperandInfo[8462] }, // Inst #12558 = VLE16FF_V + { 2, &RISCVDescs.OperandInfo[8460] }, // Inst #12557 = VL8RE8_V + { 2, &RISCVDescs.OperandInfo[8460] }, // Inst #12556 = VL8RE64_V + { 2, &RISCVDescs.OperandInfo[8460] }, // Inst #12555 = VL8RE32_V + { 2, &RISCVDescs.OperandInfo[8460] }, // Inst #12554 = VL8RE16_V + { 2, &RISCVDescs.OperandInfo[8458] }, // Inst #12553 = VL4RE8_V + { 2, &RISCVDescs.OperandInfo[8458] }, // Inst #12552 = VL4RE64_V + { 2, &RISCVDescs.OperandInfo[8458] }, // Inst #12551 = VL4RE32_V + { 2, &RISCVDescs.OperandInfo[8458] }, // Inst #12550 = VL4RE16_V + { 2, &RISCVDescs.OperandInfo[8456] }, // Inst #12549 = VL2RE8_V + { 2, &RISCVDescs.OperandInfo[8456] }, // Inst #12548 = VL2RE64_V + { 2, &RISCVDescs.OperandInfo[8456] }, // Inst #12547 = VL2RE32_V + { 2, &RISCVDescs.OperandInfo[8456] }, // Inst #12546 = VL2RE16_V + { 2, &RISCVDescs.OperandInfo[8454] }, // Inst #12545 = VL1RE8_V + { 2, &RISCVDescs.OperandInfo[8454] }, // Inst #12544 = VL1RE64_V + { 2, &RISCVDescs.OperandInfo[8454] }, // Inst #12543 = VL1RE32_V + { 2, &RISCVDescs.OperandInfo[8454] }, // Inst #12542 = VL1RE16_V + { 3, &RISCVDescs.OperandInfo[8433] }, // Inst #12541 = VIOTA_M + { 2, &RISCVDescs.OperandInfo[8452] }, // Inst #12540 = VID_V + { 2, &RISCVDescs.OperandInfo[8314] }, // Inst #12539 = VGMUL_VV + { 3, &RISCVDescs.OperandInfo[8449] }, // Inst #12538 = VGHSH_VV + { 4, &RISCVDescs.OperandInfo[8440] }, // Inst #12537 = VFWSUB_WV + { 4, &RISCVDescs.OperandInfo[8436] }, // Inst #12536 = VFWSUB_WF + { 4, &RISCVDescs.OperandInfo[8440] }, // Inst #12535 = VFWSUB_VV + { 4, &RISCVDescs.OperandInfo[8436] }, // Inst #12534 = VFWSUB_VF + { 4, &RISCVDescs.OperandInfo[8440] }, // Inst #12533 = VFWREDUSUM_VS + { 4, &RISCVDescs.OperandInfo[8440] }, // Inst #12532 = VFWREDOSUM_VS + { 5, &RISCVDescs.OperandInfo[8260] }, // Inst #12531 = VFWNMSAC_VV + { 5, &RISCVDescs.OperandInfo[8444] }, // Inst #12530 = VFWNMSAC_VF + { 5, &RISCVDescs.OperandInfo[8260] }, // Inst #12529 = VFWNMACC_VV + { 5, &RISCVDescs.OperandInfo[8444] }, // Inst #12528 = VFWNMACC_VF + { 4, &RISCVDescs.OperandInfo[8440] }, // Inst #12527 = VFWMUL_VV + { 4, &RISCVDescs.OperandInfo[8436] }, // Inst #12526 = VFWMUL_VF + { 5, &RISCVDescs.OperandInfo[8260] }, // Inst #12525 = VFWMSAC_VV + { 5, &RISCVDescs.OperandInfo[8444] }, // Inst #12524 = VFWMSAC_VF + { 5, &RISCVDescs.OperandInfo[8260] }, // Inst #12523 = VFWMACC_VV + { 5, &RISCVDescs.OperandInfo[8444] }, // Inst #12522 = VFWMACC_VF + { 3, &RISCVDescs.OperandInfo[8449] }, // Inst #12521 = VFWMACC_4x4x4 + { 5, &RISCVDescs.OperandInfo[8260] }, // Inst #12520 = VFWMACCBF16_VV + { 5, &RISCVDescs.OperandInfo[8444] }, // Inst #12519 = VFWMACCBF16_VF + { 3, &RISCVDescs.OperandInfo[8433] }, // Inst #12518 = VFWCVT_X_F_V + { 3, &RISCVDescs.OperandInfo[8433] }, // Inst #12517 = VFWCVT_XU_F_V + { 3, &RISCVDescs.OperandInfo[8433] }, // Inst #12516 = VFWCVT_RTZ_X_F_V + { 3, &RISCVDescs.OperandInfo[8433] }, // Inst #12515 = VFWCVT_RTZ_XU_F_V + { 3, &RISCVDescs.OperandInfo[8433] }, // Inst #12514 = VFWCVT_F_X_V + { 3, &RISCVDescs.OperandInfo[8433] }, // Inst #12513 = VFWCVT_F_XU_V + { 3, &RISCVDescs.OperandInfo[8433] }, // Inst #12512 = VFWCVT_F_F_V + { 3, &RISCVDescs.OperandInfo[8433] }, // Inst #12511 = VFWCVTBF16_F_F_V + { 4, &RISCVDescs.OperandInfo[8440] }, // Inst #12510 = VFWADD_WV + { 4, &RISCVDescs.OperandInfo[8436] }, // Inst #12509 = VFWADD_WF + { 4, &RISCVDescs.OperandInfo[8440] }, // Inst #12508 = VFWADD_VV + { 4, &RISCVDescs.OperandInfo[8436] }, // Inst #12507 = VFWADD_VF + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12506 = VFSUB_VV + { 4, &RISCVDescs.OperandInfo[8412] }, // Inst #12505 = VFSUB_VF + { 3, &RISCVDescs.OperandInfo[8319] }, // Inst #12504 = VFSQRT_V + { 4, &RISCVDescs.OperandInfo[8436] }, // Inst #12503 = VFSLIDE1UP_VF + { 4, &RISCVDescs.OperandInfo[8412] }, // Inst #12502 = VFSLIDE1DOWN_VF + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12501 = VFSGNJ_VV + { 4, &RISCVDescs.OperandInfo[8412] }, // Inst #12500 = VFSGNJ_VF + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12499 = VFSGNJX_VV + { 4, &RISCVDescs.OperandInfo[8412] }, // Inst #12498 = VFSGNJX_VF + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12497 = VFSGNJN_VV + { 4, &RISCVDescs.OperandInfo[8412] }, // Inst #12496 = VFSGNJN_VF + { 4, &RISCVDescs.OperandInfo[8412] }, // Inst #12495 = VFRSUB_VF + { 3, &RISCVDescs.OperandInfo[8319] }, // Inst #12494 = VFRSQRT7_V + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12493 = VFREDUSUM_VS + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12492 = VFREDOSUM_VS + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12491 = VFREDMIN_VS + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12490 = VFREDMAX_VS + { 3, &RISCVDescs.OperandInfo[8319] }, // Inst #12489 = VFREC7_V + { 4, &RISCVDescs.OperandInfo[8412] }, // Inst #12488 = VFRDIV_VF + { 4, &RISCVDescs.OperandInfo[8412] }, // Inst #12487 = VFNRCLIP_X_F_QF + { 4, &RISCVDescs.OperandInfo[8412] }, // Inst #12486 = VFNRCLIP_XU_F_QF + { 5, &RISCVDescs.OperandInfo[8421] }, // Inst #12485 = VFNMSUB_VV + { 5, &RISCVDescs.OperandInfo[8416] }, // Inst #12484 = VFNMSUB_VF + { 5, &RISCVDescs.OperandInfo[8421] }, // Inst #12483 = VFNMSAC_VV + { 5, &RISCVDescs.OperandInfo[8416] }, // Inst #12482 = VFNMSAC_VF + { 5, &RISCVDescs.OperandInfo[8421] }, // Inst #12481 = VFNMADD_VV + { 5, &RISCVDescs.OperandInfo[8416] }, // Inst #12480 = VFNMADD_VF + { 5, &RISCVDescs.OperandInfo[8421] }, // Inst #12479 = VFNMACC_VV + { 5, &RISCVDescs.OperandInfo[8416] }, // Inst #12478 = VFNMACC_VF + { 3, &RISCVDescs.OperandInfo[8433] }, // Inst #12477 = VFNCVT_X_F_W + { 3, &RISCVDescs.OperandInfo[8433] }, // Inst #12476 = VFNCVT_XU_F_W + { 3, &RISCVDescs.OperandInfo[8433] }, // Inst #12475 = VFNCVT_RTZ_X_F_W + { 3, &RISCVDescs.OperandInfo[8433] }, // Inst #12474 = VFNCVT_RTZ_XU_F_W + { 3, &RISCVDescs.OperandInfo[8433] }, // Inst #12473 = VFNCVT_ROD_F_F_W + { 3, &RISCVDescs.OperandInfo[8433] }, // Inst #12472 = VFNCVT_F_X_W + { 3, &RISCVDescs.OperandInfo[8433] }, // Inst #12471 = VFNCVT_F_XU_W + { 3, &RISCVDescs.OperandInfo[8433] }, // Inst #12470 = VFNCVT_F_F_W + { 3, &RISCVDescs.OperandInfo[8433] }, // Inst #12469 = VFNCVTBF16_F_F_W + { 2, &RISCVDescs.OperandInfo[8431] }, // Inst #12468 = VFMV_V_F + { 3, &RISCVDescs.OperandInfo[8428] }, // Inst #12467 = VFMV_S_F + { 2, &RISCVDescs.OperandInfo[8426] }, // Inst #12466 = VFMV_F_S + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12465 = VFMUL_VV + { 4, &RISCVDescs.OperandInfo[8412] }, // Inst #12464 = VFMUL_VF + { 5, &RISCVDescs.OperandInfo[8421] }, // Inst #12463 = VFMSUB_VV + { 5, &RISCVDescs.OperandInfo[8416] }, // Inst #12462 = VFMSUB_VF + { 5, &RISCVDescs.OperandInfo[8421] }, // Inst #12461 = VFMSAC_VV + { 5, &RISCVDescs.OperandInfo[8416] }, // Inst #12460 = VFMSAC_VF + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12459 = VFMIN_VV + { 4, &RISCVDescs.OperandInfo[8412] }, // Inst #12458 = VFMIN_VF + { 4, &RISCVDescs.OperandInfo[8412] }, // Inst #12457 = VFMERGE_VFM + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12456 = VFMAX_VV + { 4, &RISCVDescs.OperandInfo[8412] }, // Inst #12455 = VFMAX_VF + { 5, &RISCVDescs.OperandInfo[8421] }, // Inst #12454 = VFMADD_VV + { 5, &RISCVDescs.OperandInfo[8416] }, // Inst #12453 = VFMADD_VF + { 5, &RISCVDescs.OperandInfo[8421] }, // Inst #12452 = VFMACC_VV + { 5, &RISCVDescs.OperandInfo[8416] }, // Inst #12451 = VFMACC_VF + { 3, &RISCVDescs.OperandInfo[8325] }, // Inst #12450 = VFIRST_M + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12449 = VFDIV_VV + { 4, &RISCVDescs.OperandInfo[8412] }, // Inst #12448 = VFDIV_VF + { 3, &RISCVDescs.OperandInfo[8319] }, // Inst #12447 = VFCVT_X_F_V + { 3, &RISCVDescs.OperandInfo[8319] }, // Inst #12446 = VFCVT_XU_F_V + { 3, &RISCVDescs.OperandInfo[8319] }, // Inst #12445 = VFCVT_RTZ_X_F_V + { 3, &RISCVDescs.OperandInfo[8319] }, // Inst #12444 = VFCVT_RTZ_XU_F_V + { 3, &RISCVDescs.OperandInfo[8319] }, // Inst #12443 = VFCVT_F_X_V + { 3, &RISCVDescs.OperandInfo[8319] }, // Inst #12442 = VFCVT_F_XU_V + { 3, &RISCVDescs.OperandInfo[8319] }, // Inst #12441 = VFCLASS_V + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12440 = VFADD_VV + { 4, &RISCVDescs.OperandInfo[8412] }, // Inst #12439 = VFADD_VF + { 4, &RISCVDescs.OperandInfo[8306] }, // Inst #12438 = VDIV_VX + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12437 = VDIV_VV + { 4, &RISCVDescs.OperandInfo[8306] }, // Inst #12436 = VDIVU_VX + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12435 = VDIVU_VV + { 4, &RISCVDescs.OperandInfo[8408] }, // Inst #12434 = VC_XVW + { 4, &RISCVDescs.OperandInfo[8408] }, // Inst #12433 = VC_XVV + { 4, &RISCVDescs.OperandInfo[8404] }, // Inst #12432 = VC_XV + { 4, &RISCVDescs.OperandInfo[8400] }, // Inst #12431 = VC_X + { 5, &RISCVDescs.OperandInfo[8395] }, // Inst #12430 = VC_V_XVW + { 5, &RISCVDescs.OperandInfo[8395] }, // Inst #12429 = VC_V_XVV + { 4, &RISCVDescs.OperandInfo[8391] }, // Inst #12428 = VC_V_XV + { 4, &RISCVDescs.OperandInfo[8387] }, // Inst #12427 = VC_V_X + { 5, &RISCVDescs.OperandInfo[8382] }, // Inst #12426 = VC_V_VVW + { 5, &RISCVDescs.OperandInfo[8382] }, // Inst #12425 = VC_V_VVV + { 4, &RISCVDescs.OperandInfo[8378] }, // Inst #12424 = VC_V_VV + { 5, &RISCVDescs.OperandInfo[8373] }, // Inst #12423 = VC_V_IVW + { 5, &RISCVDescs.OperandInfo[8373] }, // Inst #12422 = VC_V_IVV + { 4, &RISCVDescs.OperandInfo[8369] }, // Inst #12421 = VC_V_IV + { 4, &RISCVDescs.OperandInfo[8365] }, // Inst #12420 = VC_V_I + { 5, &RISCVDescs.OperandInfo[8360] }, // Inst #12419 = VC_V_FVW + { 5, &RISCVDescs.OperandInfo[8360] }, // Inst #12418 = VC_V_FVV + { 4, &RISCVDescs.OperandInfo[8356] }, // Inst #12417 = VC_V_FV + { 4, &RISCVDescs.OperandInfo[8352] }, // Inst #12416 = VC_VVW + { 4, &RISCVDescs.OperandInfo[8352] }, // Inst #12415 = VC_VVV + { 4, &RISCVDescs.OperandInfo[8348] }, // Inst #12414 = VC_VV + { 4, &RISCVDescs.OperandInfo[8344] }, // Inst #12413 = VC_IVW + { 4, &RISCVDescs.OperandInfo[8344] }, // Inst #12412 = VC_IVV + { 4, &RISCVDescs.OperandInfo[8340] }, // Inst #12411 = VC_IV + { 4, &RISCVDescs.OperandInfo[8336] }, // Inst #12410 = VC_I + { 4, &RISCVDescs.OperandInfo[8332] }, // Inst #12409 = VC_FVW + { 4, &RISCVDescs.OperandInfo[8332] }, // Inst #12408 = VC_FVV + { 4, &RISCVDescs.OperandInfo[8328] }, // Inst #12407 = VC_FV + { 3, &RISCVDescs.OperandInfo[8319] }, // Inst #12406 = VCTZ_V + { 3, &RISCVDescs.OperandInfo[8319] }, // Inst #12405 = VCPOP_V + { 3, &RISCVDescs.OperandInfo[8325] }, // Inst #12404 = VCPOP_M + { 3, &RISCVDescs.OperandInfo[8322] }, // Inst #12403 = VCOMPRESS_VM + { 3, &RISCVDescs.OperandInfo[8319] }, // Inst #12402 = VCLZ_V + { 4, &RISCVDescs.OperandInfo[8306] }, // Inst #12401 = VCLMUL_VX + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12400 = VCLMUL_VV + { 4, &RISCVDescs.OperandInfo[8306] }, // Inst #12399 = VCLMULH_VX + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12398 = VCLMULH_VV + { 3, &RISCVDescs.OperandInfo[8319] }, // Inst #12397 = VBREV_V + { 3, &RISCVDescs.OperandInfo[8319] }, // Inst #12396 = VBREV8_V + { 4, &RISCVDescs.OperandInfo[8306] }, // Inst #12395 = VASUB_VX + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12394 = VASUB_VV + { 4, &RISCVDescs.OperandInfo[8306] }, // Inst #12393 = VASUBU_VX + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12392 = VASUBU_VV + { 4, &RISCVDescs.OperandInfo[8306] }, // Inst #12391 = VAND_VX + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12390 = VAND_VV + { 4, &RISCVDescs.OperandInfo[8310] }, // Inst #12389 = VAND_VI + { 4, &RISCVDescs.OperandInfo[8306] }, // Inst #12388 = VANDN_VX + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12387 = VANDN_VV + { 2, &RISCVDescs.OperandInfo[8314] }, // Inst #12386 = VAESZ_VS + { 3, &RISCVDescs.OperandInfo[8316] }, // Inst #12385 = VAESKF2_VI + { 3, &RISCVDescs.OperandInfo[8316] }, // Inst #12384 = VAESKF1_VI + { 2, &RISCVDescs.OperandInfo[8314] }, // Inst #12383 = VAESEM_VV + { 2, &RISCVDescs.OperandInfo[8314] }, // Inst #12382 = VAESEM_VS + { 2, &RISCVDescs.OperandInfo[8314] }, // Inst #12381 = VAESEF_VV + { 2, &RISCVDescs.OperandInfo[8314] }, // Inst #12380 = VAESEF_VS + { 2, &RISCVDescs.OperandInfo[8314] }, // Inst #12379 = VAESDM_VV + { 2, &RISCVDescs.OperandInfo[8314] }, // Inst #12378 = VAESDM_VS + { 2, &RISCVDescs.OperandInfo[8314] }, // Inst #12377 = VAESDF_VV + { 2, &RISCVDescs.OperandInfo[8314] }, // Inst #12376 = VAESDF_VS + { 4, &RISCVDescs.OperandInfo[8306] }, // Inst #12375 = VADD_VX + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12374 = VADD_VV + { 4, &RISCVDescs.OperandInfo[8310] }, // Inst #12373 = VADD_VI + { 4, &RISCVDescs.OperandInfo[8306] }, // Inst #12372 = VADC_VXM + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12371 = VADC_VVM + { 4, &RISCVDescs.OperandInfo[8310] }, // Inst #12370 = VADC_VIM + { 4, &RISCVDescs.OperandInfo[8306] }, // Inst #12369 = VAADD_VX + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12368 = VAADD_VV + { 4, &RISCVDescs.OperandInfo[8306] }, // Inst #12367 = VAADDU_VX + { 4, &RISCVDescs.OperandInfo[8302] }, // Inst #12366 = VAADDU_VV + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12365 = UNZIP_RV32 + { 0, &RISCVDescs.OperandInfo[1] }, // Inst #12364 = UNIMP + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12363 = TH_TSTNBZ + { 3, &RISCVDescs.OperandInfo[7831] }, // Inst #12362 = TH_TST + { 0, &RISCVDescs.OperandInfo[1] }, // Inst #12361 = TH_SYNC_S + { 0, &RISCVDescs.OperandInfo[1] }, // Inst #12360 = TH_SYNC_IS + { 0, &RISCVDescs.OperandInfo[1] }, // Inst #12359 = TH_SYNC_I + { 0, &RISCVDescs.OperandInfo[1] }, // Inst #12358 = TH_SYNC + { 5, &RISCVDescs.OperandInfo[8292] }, // Inst #12357 = TH_SWIB + { 5, &RISCVDescs.OperandInfo[8292] }, // Inst #12356 = TH_SWIA + { 5, &RISCVDescs.OperandInfo[8297] }, // Inst #12355 = TH_SWD + { 4, &RISCVDescs.OperandInfo[7811] }, // Inst #12354 = TH_SURW + { 4, &RISCVDescs.OperandInfo[7811] }, // Inst #12353 = TH_SURH + { 4, &RISCVDescs.OperandInfo[7811] }, // Inst #12352 = TH_SURD + { 4, &RISCVDescs.OperandInfo[7811] }, // Inst #12351 = TH_SURB + { 4, &RISCVDescs.OperandInfo[7811] }, // Inst #12350 = TH_SRW + { 3, &RISCVDescs.OperandInfo[7869] }, // Inst #12349 = TH_SRRIW + { 3, &RISCVDescs.OperandInfo[7831] }, // Inst #12348 = TH_SRRI + { 4, &RISCVDescs.OperandInfo[7811] }, // Inst #12347 = TH_SRH + { 4, &RISCVDescs.OperandInfo[7811] }, // Inst #12346 = TH_SRD + { 4, &RISCVDescs.OperandInfo[7811] }, // Inst #12345 = TH_SRB + { 5, &RISCVDescs.OperandInfo[8292] }, // Inst #12344 = TH_SHIB + { 5, &RISCVDescs.OperandInfo[8292] }, // Inst #12343 = TH_SHIA + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12342 = TH_SFENCE_VMAS + { 5, &RISCVDescs.OperandInfo[8292] }, // Inst #12341 = TH_SDIB + { 5, &RISCVDescs.OperandInfo[8292] }, // Inst #12340 = TH_SDIA + { 5, &RISCVDescs.OperandInfo[8297] }, // Inst #12339 = TH_SDD + { 5, &RISCVDescs.OperandInfo[8292] }, // Inst #12338 = TH_SBIB + { 5, &RISCVDescs.OperandInfo[8292] }, // Inst #12337 = TH_SBIA + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12336 = TH_REVW + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12335 = TH_REV + { 4, &RISCVDescs.OperandInfo[7848] }, // Inst #12334 = TH_MVNEZ + { 4, &RISCVDescs.OperandInfo[7848] }, // Inst #12333 = TH_MVEQZ + { 4, &RISCVDescs.OperandInfo[7848] }, // Inst #12332 = TH_MULSW + { 4, &RISCVDescs.OperandInfo[7848] }, // Inst #12331 = TH_MULSH + { 4, &RISCVDescs.OperandInfo[7848] }, // Inst #12330 = TH_MULS + { 4, &RISCVDescs.OperandInfo[7848] }, // Inst #12329 = TH_MULAW + { 4, &RISCVDescs.OperandInfo[7848] }, // Inst #12328 = TH_MULAH + { 4, &RISCVDescs.OperandInfo[7848] }, // Inst #12327 = TH_MULA + { 5, &RISCVDescs.OperandInfo[8282] }, // Inst #12326 = TH_LWUIB + { 5, &RISCVDescs.OperandInfo[8282] }, // Inst #12325 = TH_LWUIA + { 5, &RISCVDescs.OperandInfo[8287] }, // Inst #12324 = TH_LWUD + { 5, &RISCVDescs.OperandInfo[8282] }, // Inst #12323 = TH_LWIB + { 5, &RISCVDescs.OperandInfo[8282] }, // Inst #12322 = TH_LWIA + { 5, &RISCVDescs.OperandInfo[8287] }, // Inst #12321 = TH_LWD + { 4, &RISCVDescs.OperandInfo[7811] }, // Inst #12320 = TH_LURWU + { 4, &RISCVDescs.OperandInfo[7811] }, // Inst #12319 = TH_LURW + { 4, &RISCVDescs.OperandInfo[7811] }, // Inst #12318 = TH_LURHU + { 4, &RISCVDescs.OperandInfo[7811] }, // Inst #12317 = TH_LURH + { 4, &RISCVDescs.OperandInfo[7811] }, // Inst #12316 = TH_LURD + { 4, &RISCVDescs.OperandInfo[7811] }, // Inst #12315 = TH_LURBU + { 4, &RISCVDescs.OperandInfo[7811] }, // Inst #12314 = TH_LURB + { 4, &RISCVDescs.OperandInfo[7811] }, // Inst #12313 = TH_LRWU + { 4, &RISCVDescs.OperandInfo[7811] }, // Inst #12312 = TH_LRW + { 4, &RISCVDescs.OperandInfo[7811] }, // Inst #12311 = TH_LRHU + { 4, &RISCVDescs.OperandInfo[7811] }, // Inst #12310 = TH_LRH + { 4, &RISCVDescs.OperandInfo[7811] }, // Inst #12309 = TH_LRD + { 4, &RISCVDescs.OperandInfo[7811] }, // Inst #12308 = TH_LRBU + { 4, &RISCVDescs.OperandInfo[7811] }, // Inst #12307 = TH_LRB + { 5, &RISCVDescs.OperandInfo[8282] }, // Inst #12306 = TH_LHUIB + { 5, &RISCVDescs.OperandInfo[8282] }, // Inst #12305 = TH_LHUIA + { 5, &RISCVDescs.OperandInfo[8282] }, // Inst #12304 = TH_LHIB + { 5, &RISCVDescs.OperandInfo[8282] }, // Inst #12303 = TH_LHIA + { 5, &RISCVDescs.OperandInfo[8282] }, // Inst #12302 = TH_LDIB + { 5, &RISCVDescs.OperandInfo[8282] }, // Inst #12301 = TH_LDIA + { 5, &RISCVDescs.OperandInfo[8287] }, // Inst #12300 = TH_LDD + { 5, &RISCVDescs.OperandInfo[8282] }, // Inst #12299 = TH_LBUIB + { 5, &RISCVDescs.OperandInfo[8282] }, // Inst #12298 = TH_LBUIA + { 5, &RISCVDescs.OperandInfo[8282] }, // Inst #12297 = TH_LBIB + { 5, &RISCVDescs.OperandInfo[8282] }, // Inst #12296 = TH_LBIA + { 0, &RISCVDescs.OperandInfo[1] }, // Inst #12295 = TH_L2CACHE_IALL + { 0, &RISCVDescs.OperandInfo[1] }, // Inst #12294 = TH_L2CACHE_CIALL + { 0, &RISCVDescs.OperandInfo[1] }, // Inst #12293 = TH_L2CACHE_CALL + { 1, &RISCVDescs.OperandInfo[286] }, // Inst #12292 = TH_ICACHE_IVA + { 1, &RISCVDescs.OperandInfo[286] }, // Inst #12291 = TH_ICACHE_IPA + { 0, &RISCVDescs.OperandInfo[1] }, // Inst #12290 = TH_ICACHE_IALLS + { 0, &RISCVDescs.OperandInfo[1] }, // Inst #12289 = TH_ICACHE_IALL + { 4, &RISCVDescs.OperandInfo[8278] }, // Inst #12288 = TH_FSURW + { 4, &RISCVDescs.OperandInfo[8274] }, // Inst #12287 = TH_FSURD + { 4, &RISCVDescs.OperandInfo[8278] }, // Inst #12286 = TH_FSRW + { 4, &RISCVDescs.OperandInfo[8274] }, // Inst #12285 = TH_FSRD + { 4, &RISCVDescs.OperandInfo[8278] }, // Inst #12284 = TH_FLURW + { 4, &RISCVDescs.OperandInfo[8274] }, // Inst #12283 = TH_FLURD + { 4, &RISCVDescs.OperandInfo[8278] }, // Inst #12282 = TH_FLRW + { 4, &RISCVDescs.OperandInfo[8274] }, // Inst #12281 = TH_FLRD + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12280 = TH_FF1 + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12279 = TH_FF0 + { 4, &RISCVDescs.OperandInfo[8270] }, // Inst #12278 = TH_EXTU + { 4, &RISCVDescs.OperandInfo[8270] }, // Inst #12277 = TH_EXT + { 1, &RISCVDescs.OperandInfo[286] }, // Inst #12276 = TH_DCACHE_IVA + { 1, &RISCVDescs.OperandInfo[286] }, // Inst #12275 = TH_DCACHE_ISW + { 1, &RISCVDescs.OperandInfo[286] }, // Inst #12274 = TH_DCACHE_IPA + { 0, &RISCVDescs.OperandInfo[1] }, // Inst #12273 = TH_DCACHE_IALL + { 1, &RISCVDescs.OperandInfo[286] }, // Inst #12272 = TH_DCACHE_CVAL1 + { 1, &RISCVDescs.OperandInfo[286] }, // Inst #12271 = TH_DCACHE_CVA + { 1, &RISCVDescs.OperandInfo[286] }, // Inst #12270 = TH_DCACHE_CSW + { 1, &RISCVDescs.OperandInfo[286] }, // Inst #12269 = TH_DCACHE_CPAL1 + { 1, &RISCVDescs.OperandInfo[286] }, // Inst #12268 = TH_DCACHE_CPA + { 1, &RISCVDescs.OperandInfo[286] }, // Inst #12267 = TH_DCACHE_CIVA + { 1, &RISCVDescs.OperandInfo[286] }, // Inst #12266 = TH_DCACHE_CISW + { 1, &RISCVDescs.OperandInfo[286] }, // Inst #12265 = TH_DCACHE_CIPA + { 0, &RISCVDescs.OperandInfo[1] }, // Inst #12264 = TH_DCACHE_CIALL + { 0, &RISCVDescs.OperandInfo[1] }, // Inst #12263 = TH_DCACHE_CALL + { 4, &RISCVDescs.OperandInfo[7811] }, // Inst #12262 = TH_ADDSL + { 5, &RISCVDescs.OperandInfo[8265] }, // Inst #12261 = THVdotVMAQA_VX + { 5, &RISCVDescs.OperandInfo[8260] }, // Inst #12260 = THVdotVMAQA_VV + { 5, &RISCVDescs.OperandInfo[8265] }, // Inst #12259 = THVdotVMAQAU_VX + { 5, &RISCVDescs.OperandInfo[8260] }, // Inst #12258 = THVdotVMAQAU_VV + { 5, &RISCVDescs.OperandInfo[8265] }, // Inst #12257 = THVdotVMAQAUS_VX + { 5, &RISCVDescs.OperandInfo[8265] }, // Inst #12256 = THVdotVMAQASU_VX + { 5, &RISCVDescs.OperandInfo[8260] }, // Inst #12255 = THVdotVMAQASU_VV + { 3, &RISCVDescs.OperandInfo[7872] }, // Inst #12254 = SW + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #12253 = SUBW + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #12252 = SUB + { 1, &RISCVDescs.OperandInfo[7959] }, // Inst #12251 = SSRDP + { 1, &RISCVDescs.OperandInfo[8259] }, // Inst #12250 = SSPUSH + { 1, &RISCVDescs.OperandInfo[8259] }, // Inst #12249 = SSPOPCHK + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #12248 = SSAMOSWAP_W_RL + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #12247 = SSAMOSWAP_W_AQ_RL + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #12246 = SSAMOSWAP_W_AQ + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #12245 = SSAMOSWAP_W + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #12244 = SSAMOSWAP_D_RL + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #12243 = SSAMOSWAP_D_AQ_RL + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #12242 = SSAMOSWAP_D_AQ + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #12241 = SSAMOSWAP_D + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #12240 = SRLW + { 3, &RISCVDescs.OperandInfo[7869] }, // Inst #12239 = SRLIW + { 3, &RISCVDescs.OperandInfo[7831] }, // Inst #12238 = SRLI + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #12237 = SRL + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12236 = SRET + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #12235 = SRAW + { 3, &RISCVDescs.OperandInfo[7869] }, // Inst #12234 = SRAIW + { 3, &RISCVDescs.OperandInfo[7831] }, // Inst #12233 = SRAI + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #12232 = SRA + { 4, &RISCVDescs.OperandInfo[7811] }, // Inst #12231 = SM4KS + { 4, &RISCVDescs.OperandInfo[7811] }, // Inst #12230 = SM4ED + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12229 = SM3P1 + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12228 = SM3P0 + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #12227 = SLTU + { 3, &RISCVDescs.OperandInfo[7808] }, // Inst #12226 = SLTIU + { 3, &RISCVDescs.OperandInfo[7808] }, // Inst #12225 = SLTI + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #12224 = SLT + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #12223 = SLLW + { 3, &RISCVDescs.OperandInfo[7831] }, // Inst #12222 = SLLI_UW + { 3, &RISCVDescs.OperandInfo[7869] }, // Inst #12221 = SLLIW + { 3, &RISCVDescs.OperandInfo[7831] }, // Inst #12220 = SLLI + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #12219 = SLL + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12218 = SINVAL_VMA + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #12217 = SHA512SUM1R + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12216 = SHA512SUM1 + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #12215 = SHA512SUM0R + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12214 = SHA512SUM0 + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #12213 = SHA512SIG1L + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #12212 = SHA512SIG1H + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12211 = SHA512SIG1 + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #12210 = SHA512SIG0L + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #12209 = SHA512SIG0H + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12208 = SHA512SIG0 + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12207 = SHA256SUM1 + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12206 = SHA256SUM0 + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12205 = SHA256SIG1 + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12204 = SHA256SIG0 + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #12203 = SH3ADD_UW + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #12202 = SH3ADD + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #12201 = SH2ADD_UW + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #12200 = SH2ADD + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #12199 = SH1ADD_UW + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #12198 = SH1ADD + { 3, &RISCVDescs.OperandInfo[7872] }, // Inst #12197 = SH + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12196 = SFENCE_W_INVAL + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12195 = SFENCE_VMA + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12194 = SFENCE_INVAL_IR + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12193 = SEXT_H + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12192 = SEXT_B + { 3, &RISCVDescs.OperandInfo[7872] }, // Inst #12191 = SD + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #12190 = SC_W_RL + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #12189 = SC_W_AQ_RL + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #12188 = SC_W_AQ + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #12187 = SC_W + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #12186 = SC_D_RL + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #12185 = SC_D_AQ_RL + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #12184 = SC_D_AQ + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #12183 = SC_D + { 3, &RISCVDescs.OperandInfo[7872] }, // Inst #12182 = SB + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #12181 = RORW + { 3, &RISCVDescs.OperandInfo[7869] }, // Inst #12180 = RORIW + { 3, &RISCVDescs.OperandInfo[7831] }, // Inst #12179 = RORI + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #12178 = ROR + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #12177 = ROLW + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #12176 = ROL + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12175 = REV8_RV64 + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12174 = REV8_RV32 + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #12173 = REMW + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #12172 = REMUW + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #12171 = REMU + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #12170 = REM + { 2, &RISCVDescs.OperandInfo[8257] }, // Inst #12169 = PREFETCH_W + { 2, &RISCVDescs.OperandInfo[8257] }, // Inst #12168 = PREFETCH_R + { 2, &RISCVDescs.OperandInfo[8257] }, // Inst #12167 = PREFETCH_I + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #12166 = PACKW + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #12165 = PACKH + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #12164 = PACK + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #12163 = ORN + { 3, &RISCVDescs.OperandInfo[7808] }, // Inst #12162 = ORI + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12161 = ORC_B + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #12160 = OR + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #12159 = MULW + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #12158 = MULHU + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #12157 = MULHSU + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #12156 = MULH + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #12155 = MUL + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12154 = MRET + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #12153 = MOPRR7 + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #12152 = MOPRR6 + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #12151 = MOPRR5 + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #12150 = MOPRR4 + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #12149 = MOPRR3 + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #12148 = MOPRR2 + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #12147 = MOPRR1 + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #12146 = MOPRR0 + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12145 = MOPR9 + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12144 = MOPR8 + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12143 = MOPR7 + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12142 = MOPR6 + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12141 = MOPR5 + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12140 = MOPR4 + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12139 = MOPR31 + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12138 = MOPR30 + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12137 = MOPR3 + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12136 = MOPR29 + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12135 = MOPR28 + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12134 = MOPR27 + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12133 = MOPR26 + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12132 = MOPR25 + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12131 = MOPR24 + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12130 = MOPR23 + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12129 = MOPR22 + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12128 = MOPR21 + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12127 = MOPR20 + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12126 = MOPR2 + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12125 = MOPR19 + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12124 = MOPR18 + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12123 = MOPR17 + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12122 = MOPR16 + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12121 = MOPR15 + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12120 = MOPR14 + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12119 = MOPR13 + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12118 = MOPR12 + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12117 = MOPR11 + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12116 = MOPR10 + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12115 = MOPR1 + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12114 = MOPR0 + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #12113 = MINU + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #12112 = MIN + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #12111 = MAXU + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #12110 = MAX + { 3, &RISCVDescs.OperandInfo[7872] }, // Inst #12109 = LWU + { 3, &RISCVDescs.OperandInfo[7872] }, // Inst #12108 = LW + { 2, &RISCVDescs.OperandInfo[7829] }, // Inst #12107 = LUI + { 2, &RISCVDescs.OperandInfo[8181] }, // Inst #12106 = LR_W_RL + { 2, &RISCVDescs.OperandInfo[8181] }, // Inst #12105 = LR_W_AQ_RL + { 2, &RISCVDescs.OperandInfo[8181] }, // Inst #12104 = LR_W_AQ + { 2, &RISCVDescs.OperandInfo[8181] }, // Inst #12103 = LR_W + { 2, &RISCVDescs.OperandInfo[8181] }, // Inst #12102 = LR_D_RL + { 2, &RISCVDescs.OperandInfo[8181] }, // Inst #12101 = LR_D_AQ_RL + { 2, &RISCVDescs.OperandInfo[8181] }, // Inst #12100 = LR_D_AQ + { 2, &RISCVDescs.OperandInfo[8181] }, // Inst #12099 = LR_D + { 3, &RISCVDescs.OperandInfo[7872] }, // Inst #12098 = LHU + { 3, &RISCVDescs.OperandInfo[7872] }, // Inst #12097 = LH + { 3, &RISCVDescs.OperandInfo[7872] }, // Inst #12096 = LD + { 3, &RISCVDescs.OperandInfo[7872] }, // Inst #12095 = LBU + { 3, &RISCVDescs.OperandInfo[7872] }, // Inst #12094 = LB + { 3, &RISCVDescs.OperandInfo[7808] }, // Inst #12093 = JALR + { 2, &RISCVDescs.OperandInfo[8255] }, // Inst #12092 = JAL + { 3, &RISCVDescs.OperandInfo[8252] }, // Inst #12091 = InsnU + { 5, &RISCVDescs.OperandInfo[8247] }, // Inst #12090 = InsnS + { 7, &RISCVDescs.OperandInfo[8240] }, // Inst #12089 = InsnR4 + { 6, &RISCVDescs.OperandInfo[8234] }, // Inst #12088 = InsnR + { 3, &RISCVDescs.OperandInfo[8231] }, // Inst #12087 = InsnJ + { 5, &RISCVDescs.OperandInfo[8226] }, // Inst #12086 = InsnI_Mem + { 5, &RISCVDescs.OperandInfo[8226] }, // Inst #12085 = InsnI + { 4, &RISCVDescs.OperandInfo[8222] }, // Inst #12084 = InsnCSS + { 5, &RISCVDescs.OperandInfo[8217] }, // Inst #12083 = InsnCS + { 4, &RISCVDescs.OperandInfo[8213] }, // Inst #12082 = InsnCR + { 5, &RISCVDescs.OperandInfo[8208] }, // Inst #12081 = InsnCL + { 3, &RISCVDescs.OperandInfo[8205] }, // Inst #12080 = InsnCJ + { 4, &RISCVDescs.OperandInfo[8201] }, // Inst #12079 = InsnCIW + { 4, &RISCVDescs.OperandInfo[8197] }, // Inst #12078 = InsnCI + { 4, &RISCVDescs.OperandInfo[8193] }, // Inst #12077 = InsnCB + { 5, &RISCVDescs.OperandInfo[8188] }, // Inst #12076 = InsnCA + { 5, &RISCVDescs.OperandInfo[8183] }, // Inst #12075 = InsnB + { 2, &RISCVDescs.OperandInfo[8181] }, // Inst #12074 = HSV_W + { 2, &RISCVDescs.OperandInfo[8181] }, // Inst #12073 = HSV_H + { 2, &RISCVDescs.OperandInfo[8181] }, // Inst #12072 = HSV_D + { 2, &RISCVDescs.OperandInfo[8181] }, // Inst #12071 = HSV_B + { 2, &RISCVDescs.OperandInfo[8181] }, // Inst #12070 = HLV_WU + { 2, &RISCVDescs.OperandInfo[8181] }, // Inst #12069 = HLV_W + { 2, &RISCVDescs.OperandInfo[8181] }, // Inst #12068 = HLV_HU + { 2, &RISCVDescs.OperandInfo[8181] }, // Inst #12067 = HLV_H + { 2, &RISCVDescs.OperandInfo[8181] }, // Inst #12066 = HLV_D + { 2, &RISCVDescs.OperandInfo[8181] }, // Inst #12065 = HLV_BU + { 2, &RISCVDescs.OperandInfo[8181] }, // Inst #12064 = HLV_B + { 2, &RISCVDescs.OperandInfo[8181] }, // Inst #12063 = HLVX_WU + { 2, &RISCVDescs.OperandInfo[8181] }, // Inst #12062 = HLVX_HU + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12061 = HINVAL_VVMA + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12060 = HINVAL_GVMA + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12059 = HFENCE_VVMA + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #12058 = HFENCE_GVMA + { 3, &RISCVDescs.OperandInfo[8101] }, // Inst #12057 = FSW + { 4, &RISCVDescs.OperandInfo[224] }, // Inst #12056 = FSUB_S_INX + { 4, &RISCVDescs.OperandInfo[220] }, // Inst #12055 = FSUB_S + { 4, &RISCVDescs.OperandInfo[216] }, // Inst #12054 = FSUB_H_INX + { 4, &RISCVDescs.OperandInfo[212] }, // Inst #12053 = FSUB_H + { 4, &RISCVDescs.OperandInfo[148] }, // Inst #12052 = FSUB_D_INX + { 4, &RISCVDescs.OperandInfo[208] }, // Inst #12051 = FSUB_D_IN32X + { 4, &RISCVDescs.OperandInfo[204] }, // Inst #12050 = FSUB_D + { 3, &RISCVDescs.OperandInfo[8178] }, // Inst #12049 = FSQRT_S_INX + { 3, &RISCVDescs.OperandInfo[8169] }, // Inst #12048 = FSQRT_S + { 3, &RISCVDescs.OperandInfo[8175] }, // Inst #12047 = FSQRT_H_INX + { 3, &RISCVDescs.OperandInfo[8166] }, // Inst #12046 = FSQRT_H + { 3, &RISCVDescs.OperandInfo[287] }, // Inst #12045 = FSQRT_D_INX + { 3, &RISCVDescs.OperandInfo[8172] }, // Inst #12044 = FSQRT_D_IN32X + { 3, &RISCVDescs.OperandInfo[8163] }, // Inst #12043 = FSQRT_D + { 3, &RISCVDescs.OperandInfo[8092] }, // Inst #12042 = FSH + { 3, &RISCVDescs.OperandInfo[8154] }, // Inst #12041 = FSGNJ_S_INX + { 3, &RISCVDescs.OperandInfo[8145] }, // Inst #12040 = FSGNJ_S + { 3, &RISCVDescs.OperandInfo[8151] }, // Inst #12039 = FSGNJ_H_INX + { 3, &RISCVDescs.OperandInfo[8142] }, // Inst #12038 = FSGNJ_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #12037 = FSGNJ_D_INX + { 3, &RISCVDescs.OperandInfo[8148] }, // Inst #12036 = FSGNJ_D_IN32X + { 3, &RISCVDescs.OperandInfo[8139] }, // Inst #12035 = FSGNJ_D + { 3, &RISCVDescs.OperandInfo[8154] }, // Inst #12034 = FSGNJX_S_INX + { 3, &RISCVDescs.OperandInfo[8145] }, // Inst #12033 = FSGNJX_S + { 3, &RISCVDescs.OperandInfo[8151] }, // Inst #12032 = FSGNJX_H_INX + { 3, &RISCVDescs.OperandInfo[8142] }, // Inst #12031 = FSGNJX_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #12030 = FSGNJX_D_INX + { 3, &RISCVDescs.OperandInfo[8148] }, // Inst #12029 = FSGNJX_D_IN32X + { 3, &RISCVDescs.OperandInfo[8139] }, // Inst #12028 = FSGNJX_D + { 3, &RISCVDescs.OperandInfo[8154] }, // Inst #12027 = FSGNJN_S_INX + { 3, &RISCVDescs.OperandInfo[8145] }, // Inst #12026 = FSGNJN_S + { 3, &RISCVDescs.OperandInfo[8151] }, // Inst #12025 = FSGNJN_H_INX + { 3, &RISCVDescs.OperandInfo[8142] }, // Inst #12024 = FSGNJN_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #12023 = FSGNJN_D_INX + { 3, &RISCVDescs.OperandInfo[8148] }, // Inst #12022 = FSGNJN_D_IN32X + { 3, &RISCVDescs.OperandInfo[8139] }, // Inst #12021 = FSGNJN_D + { 3, &RISCVDescs.OperandInfo[8089] }, // Inst #12020 = FSD + { 3, &RISCVDescs.OperandInfo[8169] }, // Inst #12019 = FROUND_S + { 3, &RISCVDescs.OperandInfo[8166] }, // Inst #12018 = FROUND_H + { 3, &RISCVDescs.OperandInfo[8163] }, // Inst #12017 = FROUND_D + { 3, &RISCVDescs.OperandInfo[8169] }, // Inst #12016 = FROUNDNX_S + { 3, &RISCVDescs.OperandInfo[8166] }, // Inst #12015 = FROUNDNX_H + { 3, &RISCVDescs.OperandInfo[8163] }, // Inst #12014 = FROUNDNX_D + { 5, &RISCVDescs.OperandInfo[8134] }, // Inst #12013 = FNMSUB_S_INX + { 5, &RISCVDescs.OperandInfo[8129] }, // Inst #12012 = FNMSUB_S + { 5, &RISCVDescs.OperandInfo[8124] }, // Inst #12011 = FNMSUB_H_INX + { 5, &RISCVDescs.OperandInfo[8119] }, // Inst #12010 = FNMSUB_H + { 5, &RISCVDescs.OperandInfo[8114] }, // Inst #12009 = FNMSUB_D_INX + { 5, &RISCVDescs.OperandInfo[8109] }, // Inst #12008 = FNMSUB_D_IN32X + { 5, &RISCVDescs.OperandInfo[8104] }, // Inst #12007 = FNMSUB_D + { 5, &RISCVDescs.OperandInfo[8134] }, // Inst #12006 = FNMADD_S_INX + { 5, &RISCVDescs.OperandInfo[8129] }, // Inst #12005 = FNMADD_S + { 5, &RISCVDescs.OperandInfo[8124] }, // Inst #12004 = FNMADD_H_INX + { 5, &RISCVDescs.OperandInfo[8119] }, // Inst #12003 = FNMADD_H + { 5, &RISCVDescs.OperandInfo[8114] }, // Inst #12002 = FNMADD_D_INX + { 5, &RISCVDescs.OperandInfo[8109] }, // Inst #12001 = FNMADD_D_IN32X + { 5, &RISCVDescs.OperandInfo[8104] }, // Inst #12000 = FNMADD_D + { 2, &RISCVDescs.OperandInfo[8012] }, // Inst #11999 = FMV_X_W_FPR64 + { 2, &RISCVDescs.OperandInfo[8020] }, // Inst #11998 = FMV_X_W + { 2, &RISCVDescs.OperandInfo[8016] }, // Inst #11997 = FMV_X_H + { 2, &RISCVDescs.OperandInfo[8012] }, // Inst #11996 = FMV_X_D + { 2, &RISCVDescs.OperandInfo[8161] }, // Inst #11995 = FMV_W_X + { 2, &RISCVDescs.OperandInfo[8159] }, // Inst #11994 = FMV_H_X + { 2, &RISCVDescs.OperandInfo[8157] }, // Inst #11993 = FMV_D_X + { 3, &RISCVDescs.OperandInfo[140] }, // Inst #11992 = FMVP_D_X + { 2, &RISCVDescs.OperandInfo[8012] }, // Inst #11991 = FMVH_X_D + { 4, &RISCVDescs.OperandInfo[224] }, // Inst #11990 = FMUL_S_INX + { 4, &RISCVDescs.OperandInfo[220] }, // Inst #11989 = FMUL_S + { 4, &RISCVDescs.OperandInfo[216] }, // Inst #11988 = FMUL_H_INX + { 4, &RISCVDescs.OperandInfo[212] }, // Inst #11987 = FMUL_H + { 4, &RISCVDescs.OperandInfo[148] }, // Inst #11986 = FMUL_D_INX + { 4, &RISCVDescs.OperandInfo[208] }, // Inst #11985 = FMUL_D_IN32X + { 4, &RISCVDescs.OperandInfo[204] }, // Inst #11984 = FMUL_D + { 5, &RISCVDescs.OperandInfo[8134] }, // Inst #11983 = FMSUB_S_INX + { 5, &RISCVDescs.OperandInfo[8129] }, // Inst #11982 = FMSUB_S + { 5, &RISCVDescs.OperandInfo[8124] }, // Inst #11981 = FMSUB_H_INX + { 5, &RISCVDescs.OperandInfo[8119] }, // Inst #11980 = FMSUB_H + { 5, &RISCVDescs.OperandInfo[8114] }, // Inst #11979 = FMSUB_D_INX + { 5, &RISCVDescs.OperandInfo[8109] }, // Inst #11978 = FMSUB_D_IN32X + { 5, &RISCVDescs.OperandInfo[8104] }, // Inst #11977 = FMSUB_D + { 3, &RISCVDescs.OperandInfo[8154] }, // Inst #11976 = FMIN_S_INX + { 3, &RISCVDescs.OperandInfo[8145] }, // Inst #11975 = FMIN_S + { 3, &RISCVDescs.OperandInfo[8151] }, // Inst #11974 = FMIN_H_INX + { 3, &RISCVDescs.OperandInfo[8142] }, // Inst #11973 = FMIN_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11972 = FMIN_D_INX + { 3, &RISCVDescs.OperandInfo[8148] }, // Inst #11971 = FMIN_D_IN32X + { 3, &RISCVDescs.OperandInfo[8139] }, // Inst #11970 = FMIN_D + { 3, &RISCVDescs.OperandInfo[8145] }, // Inst #11969 = FMINM_S + { 3, &RISCVDescs.OperandInfo[8142] }, // Inst #11968 = FMINM_H + { 3, &RISCVDescs.OperandInfo[8139] }, // Inst #11967 = FMINM_D + { 3, &RISCVDescs.OperandInfo[8154] }, // Inst #11966 = FMAX_S_INX + { 3, &RISCVDescs.OperandInfo[8145] }, // Inst #11965 = FMAX_S + { 3, &RISCVDescs.OperandInfo[8151] }, // Inst #11964 = FMAX_H_INX + { 3, &RISCVDescs.OperandInfo[8142] }, // Inst #11963 = FMAX_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11962 = FMAX_D_INX + { 3, &RISCVDescs.OperandInfo[8148] }, // Inst #11961 = FMAX_D_IN32X + { 3, &RISCVDescs.OperandInfo[8139] }, // Inst #11960 = FMAX_D + { 3, &RISCVDescs.OperandInfo[8145] }, // Inst #11959 = FMAXM_S + { 3, &RISCVDescs.OperandInfo[8142] }, // Inst #11958 = FMAXM_H + { 3, &RISCVDescs.OperandInfo[8139] }, // Inst #11957 = FMAXM_D + { 5, &RISCVDescs.OperandInfo[8134] }, // Inst #11956 = FMADD_S_INX + { 5, &RISCVDescs.OperandInfo[8129] }, // Inst #11955 = FMADD_S + { 5, &RISCVDescs.OperandInfo[8124] }, // Inst #11954 = FMADD_H_INX + { 5, &RISCVDescs.OperandInfo[8119] }, // Inst #11953 = FMADD_H + { 5, &RISCVDescs.OperandInfo[8114] }, // Inst #11952 = FMADD_D_INX + { 5, &RISCVDescs.OperandInfo[8109] }, // Inst #11951 = FMADD_D_IN32X + { 5, &RISCVDescs.OperandInfo[8104] }, // Inst #11950 = FMADD_D + { 3, &RISCVDescs.OperandInfo[8101] }, // Inst #11949 = FLW + { 3, &RISCVDescs.OperandInfo[273] }, // Inst #11948 = FLT_S_INX + { 3, &RISCVDescs.OperandInfo[270] }, // Inst #11947 = FLT_S + { 3, &RISCVDescs.OperandInfo[267] }, // Inst #11946 = FLT_H_INX + { 3, &RISCVDescs.OperandInfo[264] }, // Inst #11945 = FLT_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11944 = FLT_D_INX + { 3, &RISCVDescs.OperandInfo[258] }, // Inst #11943 = FLT_D_IN32X + { 3, &RISCVDescs.OperandInfo[255] }, // Inst #11942 = FLT_D + { 3, &RISCVDescs.OperandInfo[270] }, // Inst #11941 = FLTQ_S + { 3, &RISCVDescs.OperandInfo[264] }, // Inst #11940 = FLTQ_H + { 3, &RISCVDescs.OperandInfo[255] }, // Inst #11939 = FLTQ_D + { 2, &RISCVDescs.OperandInfo[8099] }, // Inst #11938 = FLI_S + { 2, &RISCVDescs.OperandInfo[8097] }, // Inst #11937 = FLI_H + { 2, &RISCVDescs.OperandInfo[8095] }, // Inst #11936 = FLI_D + { 3, &RISCVDescs.OperandInfo[8092] }, // Inst #11935 = FLH + { 3, &RISCVDescs.OperandInfo[273] }, // Inst #11934 = FLE_S_INX + { 3, &RISCVDescs.OperandInfo[270] }, // Inst #11933 = FLE_S + { 3, &RISCVDescs.OperandInfo[267] }, // Inst #11932 = FLE_H_INX + { 3, &RISCVDescs.OperandInfo[264] }, // Inst #11931 = FLE_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11930 = FLE_D_INX + { 3, &RISCVDescs.OperandInfo[258] }, // Inst #11929 = FLE_D_IN32X + { 3, &RISCVDescs.OperandInfo[255] }, // Inst #11928 = FLE_D + { 3, &RISCVDescs.OperandInfo[270] }, // Inst #11927 = FLEQ_S + { 3, &RISCVDescs.OperandInfo[264] }, // Inst #11926 = FLEQ_H + { 3, &RISCVDescs.OperandInfo[255] }, // Inst #11925 = FLEQ_D + { 3, &RISCVDescs.OperandInfo[8089] }, // Inst #11924 = FLD + { 3, &RISCVDescs.OperandInfo[273] }, // Inst #11923 = FEQ_S_INX + { 3, &RISCVDescs.OperandInfo[270] }, // Inst #11922 = FEQ_S + { 3, &RISCVDescs.OperandInfo[267] }, // Inst #11921 = FEQ_H_INX + { 3, &RISCVDescs.OperandInfo[264] }, // Inst #11920 = FEQ_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11919 = FEQ_D_INX + { 3, &RISCVDescs.OperandInfo[258] }, // Inst #11918 = FEQ_D_IN32X + { 3, &RISCVDescs.OperandInfo[255] }, // Inst #11917 = FEQ_D + { 0, &RISCVDescs.OperandInfo[1] }, // Inst #11916 = FENCE_TSO + { 0, &RISCVDescs.OperandInfo[1] }, // Inst #11915 = FENCE_I + { 2, &RISCVDescs.OperandInfo[8087] }, // Inst #11914 = FENCE + { 4, &RISCVDescs.OperandInfo[224] }, // Inst #11913 = FDIV_S_INX + { 4, &RISCVDescs.OperandInfo[220] }, // Inst #11912 = FDIV_S + { 4, &RISCVDescs.OperandInfo[216] }, // Inst #11911 = FDIV_H_INX + { 4, &RISCVDescs.OperandInfo[212] }, // Inst #11910 = FDIV_H + { 4, &RISCVDescs.OperandInfo[148] }, // Inst #11909 = FDIV_D_INX + { 4, &RISCVDescs.OperandInfo[208] }, // Inst #11908 = FDIV_D_IN32X + { 4, &RISCVDescs.OperandInfo[204] }, // Inst #11907 = FDIV_D + { 3, &RISCVDescs.OperandInfo[8045] }, // Inst #11906 = FCVT_W_S_INX + { 3, &RISCVDescs.OperandInfo[201] }, // Inst #11905 = FCVT_W_S + { 3, &RISCVDescs.OperandInfo[8033] }, // Inst #11904 = FCVT_W_H_INX + { 3, &RISCVDescs.OperandInfo[198] }, // Inst #11903 = FCVT_W_H + { 3, &RISCVDescs.OperandInfo[287] }, // Inst #11902 = FCVT_W_D_INX + { 3, &RISCVDescs.OperandInfo[8084] }, // Inst #11901 = FCVT_W_D_IN32X + { 3, &RISCVDescs.OperandInfo[195] }, // Inst #11900 = FCVT_W_D + { 3, &RISCVDescs.OperandInfo[8045] }, // Inst #11899 = FCVT_WU_S_INX + { 3, &RISCVDescs.OperandInfo[201] }, // Inst #11898 = FCVT_WU_S + { 3, &RISCVDescs.OperandInfo[8033] }, // Inst #11897 = FCVT_WU_H_INX + { 3, &RISCVDescs.OperandInfo[198] }, // Inst #11896 = FCVT_WU_H + { 3, &RISCVDescs.OperandInfo[287] }, // Inst #11895 = FCVT_WU_D_INX + { 3, &RISCVDescs.OperandInfo[8084] }, // Inst #11894 = FCVT_WU_D_IN32X + { 3, &RISCVDescs.OperandInfo[195] }, // Inst #11893 = FCVT_WU_D + { 3, &RISCVDescs.OperandInfo[8075] }, // Inst #11892 = FCVT_S_W_INX + { 3, &RISCVDescs.OperandInfo[8075] }, // Inst #11891 = FCVT_S_WU_INX + { 3, &RISCVDescs.OperandInfo[8081] }, // Inst #11890 = FCVT_S_WU + { 3, &RISCVDescs.OperandInfo[8081] }, // Inst #11889 = FCVT_S_W + { 3, &RISCVDescs.OperandInfo[8075] }, // Inst #11888 = FCVT_S_L_INX + { 3, &RISCVDescs.OperandInfo[8075] }, // Inst #11887 = FCVT_S_LU_INX + { 3, &RISCVDescs.OperandInfo[8081] }, // Inst #11886 = FCVT_S_LU + { 3, &RISCVDescs.OperandInfo[8081] }, // Inst #11885 = FCVT_S_L + { 3, &RISCVDescs.OperandInfo[8078] }, // Inst #11884 = FCVT_S_H_INX + { 3, &RISCVDescs.OperandInfo[8066] }, // Inst #11883 = FCVT_S_H + { 3, &RISCVDescs.OperandInfo[8075] }, // Inst #11882 = FCVT_S_D_INX + { 3, &RISCVDescs.OperandInfo[8072] }, // Inst #11881 = FCVT_S_D_IN32X + { 3, &RISCVDescs.OperandInfo[8069] }, // Inst #11880 = FCVT_S_D + { 3, &RISCVDescs.OperandInfo[8066] }, // Inst #11879 = FCVT_S_BF16 + { 3, &RISCVDescs.OperandInfo[8045] }, // Inst #11878 = FCVT_L_S_INX + { 3, &RISCVDescs.OperandInfo[201] }, // Inst #11877 = FCVT_L_S + { 3, &RISCVDescs.OperandInfo[8033] }, // Inst #11876 = FCVT_L_H_INX + { 3, &RISCVDescs.OperandInfo[198] }, // Inst #11875 = FCVT_L_H + { 3, &RISCVDescs.OperandInfo[287] }, // Inst #11874 = FCVT_L_D_INX + { 3, &RISCVDescs.OperandInfo[195] }, // Inst #11873 = FCVT_L_D + { 3, &RISCVDescs.OperandInfo[8045] }, // Inst #11872 = FCVT_LU_S_INX + { 3, &RISCVDescs.OperandInfo[201] }, // Inst #11871 = FCVT_LU_S + { 3, &RISCVDescs.OperandInfo[8033] }, // Inst #11870 = FCVT_LU_H_INX + { 3, &RISCVDescs.OperandInfo[198] }, // Inst #11869 = FCVT_LU_H + { 3, &RISCVDescs.OperandInfo[287] }, // Inst #11868 = FCVT_LU_D_INX + { 3, &RISCVDescs.OperandInfo[195] }, // Inst #11867 = FCVT_LU_D + { 3, &RISCVDescs.OperandInfo[8057] }, // Inst #11866 = FCVT_H_W_INX + { 3, &RISCVDescs.OperandInfo[8057] }, // Inst #11865 = FCVT_H_WU_INX + { 3, &RISCVDescs.OperandInfo[8060] }, // Inst #11864 = FCVT_H_WU + { 3, &RISCVDescs.OperandInfo[8060] }, // Inst #11863 = FCVT_H_W + { 3, &RISCVDescs.OperandInfo[8063] }, // Inst #11862 = FCVT_H_S_INX + { 3, &RISCVDescs.OperandInfo[8024] }, // Inst #11861 = FCVT_H_S + { 3, &RISCVDescs.OperandInfo[8057] }, // Inst #11860 = FCVT_H_L_INX + { 3, &RISCVDescs.OperandInfo[8057] }, // Inst #11859 = FCVT_H_LU_INX + { 3, &RISCVDescs.OperandInfo[8060] }, // Inst #11858 = FCVT_H_LU + { 3, &RISCVDescs.OperandInfo[8060] }, // Inst #11857 = FCVT_H_L + { 3, &RISCVDescs.OperandInfo[8057] }, // Inst #11856 = FCVT_H_D_INX + { 3, &RISCVDescs.OperandInfo[8054] }, // Inst #11855 = FCVT_H_D_IN32X + { 3, &RISCVDescs.OperandInfo[8051] }, // Inst #11854 = FCVT_H_D + { 3, &RISCVDescs.OperandInfo[287] }, // Inst #11853 = FCVT_D_W_INX + { 3, &RISCVDescs.OperandInfo[8048] }, // Inst #11852 = FCVT_D_W_IN32X + { 3, &RISCVDescs.OperandInfo[287] }, // Inst #11851 = FCVT_D_WU_INX + { 3, &RISCVDescs.OperandInfo[8048] }, // Inst #11850 = FCVT_D_WU_IN32X + { 3, &RISCVDescs.OperandInfo[8036] }, // Inst #11849 = FCVT_D_WU + { 3, &RISCVDescs.OperandInfo[8036] }, // Inst #11848 = FCVT_D_W + { 3, &RISCVDescs.OperandInfo[8045] }, // Inst #11847 = FCVT_D_S_INX + { 3, &RISCVDescs.OperandInfo[8042] }, // Inst #11846 = FCVT_D_S_IN32X + { 3, &RISCVDescs.OperandInfo[8039] }, // Inst #11845 = FCVT_D_S + { 3, &RISCVDescs.OperandInfo[287] }, // Inst #11844 = FCVT_D_L_INX + { 3, &RISCVDescs.OperandInfo[287] }, // Inst #11843 = FCVT_D_LU_INX + { 3, &RISCVDescs.OperandInfo[8036] }, // Inst #11842 = FCVT_D_LU + { 3, &RISCVDescs.OperandInfo[8036] }, // Inst #11841 = FCVT_D_L + { 3, &RISCVDescs.OperandInfo[8033] }, // Inst #11840 = FCVT_D_H_INX + { 3, &RISCVDescs.OperandInfo[8030] }, // Inst #11839 = FCVT_D_H_IN32X + { 3, &RISCVDescs.OperandInfo[8027] }, // Inst #11838 = FCVT_D_H + { 3, &RISCVDescs.OperandInfo[8024] }, // Inst #11837 = FCVT_BF16_S + { 3, &RISCVDescs.OperandInfo[195] }, // Inst #11836 = FCVTMOD_W_D + { 2, &RISCVDescs.OperandInfo[8022] }, // Inst #11835 = FCLASS_S_INX + { 2, &RISCVDescs.OperandInfo[8020] }, // Inst #11834 = FCLASS_S + { 2, &RISCVDescs.OperandInfo[8018] }, // Inst #11833 = FCLASS_H_INX + { 2, &RISCVDescs.OperandInfo[8016] }, // Inst #11832 = FCLASS_H + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #11831 = FCLASS_D_INX + { 2, &RISCVDescs.OperandInfo[8014] }, // Inst #11830 = FCLASS_D_IN32X + { 2, &RISCVDescs.OperandInfo[8012] }, // Inst #11829 = FCLASS_D + { 4, &RISCVDescs.OperandInfo[224] }, // Inst #11828 = FADD_S_INX + { 4, &RISCVDescs.OperandInfo[220] }, // Inst #11827 = FADD_S + { 4, &RISCVDescs.OperandInfo[216] }, // Inst #11826 = FADD_H_INX + { 4, &RISCVDescs.OperandInfo[212] }, // Inst #11825 = FADD_H + { 4, &RISCVDescs.OperandInfo[148] }, // Inst #11824 = FADD_D_INX + { 4, &RISCVDescs.OperandInfo[208] }, // Inst #11823 = FADD_D_IN32X + { 4, &RISCVDescs.OperandInfo[204] }, // Inst #11822 = FADD_D + { 0, &RISCVDescs.OperandInfo[1] }, // Inst #11821 = ECALL + { 0, &RISCVDescs.OperandInfo[1] }, // Inst #11820 = EBREAK + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #11819 = DRET + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11818 = DIVW + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11817 = DIVUW + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11816 = DIVU + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11815 = DIV + { 2, &RISCVDescs.OperandInfo[7991] }, // Inst #11814 = C_ZEXT_W + { 2, &RISCVDescs.OperandInfo[7991] }, // Inst #11813 = C_ZEXT_H + { 2, &RISCVDescs.OperandInfo[7991] }, // Inst #11812 = C_ZEXT_B + { 3, &RISCVDescs.OperandInfo[7936] }, // Inst #11811 = C_XOR + { 0, &RISCVDescs.OperandInfo[1] }, // Inst #11810 = C_UNIMP + { 3, &RISCVDescs.OperandInfo[8009] }, // Inst #11809 = C_SWSP + { 3, &RISCVDescs.OperandInfo[7980] }, // Inst #11808 = C_SW + { 3, &RISCVDescs.OperandInfo[7936] }, // Inst #11807 = C_SUBW + { 3, &RISCVDescs.OperandInfo[7936] }, // Inst #11806 = C_SUB + { 1, &RISCVDescs.OperandInfo[8008] }, // Inst #11805 = C_SSPUSH + { 1, &RISCVDescs.OperandInfo[8007] }, // Inst #11804 = C_SSPOPCHK + { 2, &RISCVDescs.OperandInfo[7991] }, // Inst #11803 = C_SRLI64_HINT + { 3, &RISCVDescs.OperandInfo[8004] }, // Inst #11802 = C_SRLI + { 2, &RISCVDescs.OperandInfo[7991] }, // Inst #11801 = C_SRAI64_HINT + { 3, &RISCVDescs.OperandInfo[8004] }, // Inst #11800 = C_SRAI + { 3, &RISCVDescs.OperandInfo[8001] }, // Inst #11799 = C_SLLI_HINT + { 2, &RISCVDescs.OperandInfo[7999] }, // Inst #11798 = C_SLLI64_HINT + { 3, &RISCVDescs.OperandInfo[7996] }, // Inst #11797 = C_SLLI + { 3, &RISCVDescs.OperandInfo[7969] }, // Inst #11796 = C_SH + { 2, &RISCVDescs.OperandInfo[7991] }, // Inst #11795 = C_SEXT_H + { 2, &RISCVDescs.OperandInfo[7991] }, // Inst #11794 = C_SEXT_B + { 3, &RISCVDescs.OperandInfo[7993] }, // Inst #11793 = C_SDSP + { 3, &RISCVDescs.OperandInfo[7963] }, // Inst #11792 = C_SD + { 3, &RISCVDescs.OperandInfo[7960] }, // Inst #11791 = C_SB + { 3, &RISCVDescs.OperandInfo[7936] }, // Inst #11790 = C_OR + { 2, &RISCVDescs.OperandInfo[7991] }, // Inst #11789 = C_NOT + { 1, &RISCVDescs.OperandInfo[7990] }, // Inst #11788 = C_NOP_HINT + { 0, &RISCVDescs.OperandInfo[1] }, // Inst #11787 = C_NOP + { 2, &RISCVDescs.OperandInfo[7988] }, // Inst #11786 = C_MV_HINT + { 2, &RISCVDescs.OperandInfo[7986] }, // Inst #11785 = C_MV + { 3, &RISCVDescs.OperandInfo[7936] }, // Inst #11784 = C_MUL + { 3, &RISCVDescs.OperandInfo[7983] }, // Inst #11783 = C_LWSP + { 3, &RISCVDescs.OperandInfo[7980] }, // Inst #11782 = C_LW + { 2, &RISCVDescs.OperandInfo[7978] }, // Inst #11781 = C_LUI_HINT + { 2, &RISCVDescs.OperandInfo[7976] }, // Inst #11780 = C_LUI + { 2, &RISCVDescs.OperandInfo[7974] }, // Inst #11779 = C_LI_HINT + { 2, &RISCVDescs.OperandInfo[7972] }, // Inst #11778 = C_LI + { 3, &RISCVDescs.OperandInfo[7969] }, // Inst #11777 = C_LHU + { 3, &RISCVDescs.OperandInfo[7969] }, // Inst #11776 = C_LH + { 3, &RISCVDescs.OperandInfo[7966] }, // Inst #11775 = C_LDSP + { 3, &RISCVDescs.OperandInfo[7963] }, // Inst #11774 = C_LD + { 3, &RISCVDescs.OperandInfo[7960] }, // Inst #11773 = C_LBU + { 1, &RISCVDescs.OperandInfo[7959] }, // Inst #11772 = C_JR + { 1, &RISCVDescs.OperandInfo[7959] }, // Inst #11771 = C_JALR + { 1, &RISCVDescs.OperandInfo[157] }, // Inst #11770 = C_JAL + { 1, &RISCVDescs.OperandInfo[157] }, // Inst #11769 = C_J + { 3, &RISCVDescs.OperandInfo[7956] }, // Inst #11768 = C_FSWSP + { 3, &RISCVDescs.OperandInfo[7953] }, // Inst #11767 = C_FSW + { 3, &RISCVDescs.OperandInfo[7950] }, // Inst #11766 = C_FSDSP + { 3, &RISCVDescs.OperandInfo[7947] }, // Inst #11765 = C_FSD + { 3, &RISCVDescs.OperandInfo[7956] }, // Inst #11764 = C_FLWSP + { 3, &RISCVDescs.OperandInfo[7953] }, // Inst #11763 = C_FLW + { 3, &RISCVDescs.OperandInfo[7950] }, // Inst #11762 = C_FLDSP + { 3, &RISCVDescs.OperandInfo[7947] }, // Inst #11761 = C_FLD + { 0, &RISCVDescs.OperandInfo[1] }, // Inst #11760 = C_EBREAK + { 2, &RISCVDescs.OperandInfo[7945] }, // Inst #11759 = C_BNEZ + { 2, &RISCVDescs.OperandInfo[7945] }, // Inst #11758 = C_BEQZ + { 3, &RISCVDescs.OperandInfo[7942] }, // Inst #11757 = C_ANDI + { 3, &RISCVDescs.OperandInfo[7936] }, // Inst #11756 = C_AND + { 3, &RISCVDescs.OperandInfo[7939] }, // Inst #11755 = C_ADD_HINT + { 3, &RISCVDescs.OperandInfo[7936] }, // Inst #11754 = C_ADDW + { 3, &RISCVDescs.OperandInfo[7933] }, // Inst #11753 = C_ADDI_NOP + { 3, &RISCVDescs.OperandInfo[7930] }, // Inst #11752 = C_ADDI_HINT_IMM_ZERO + { 3, &RISCVDescs.OperandInfo[7927] }, // Inst #11751 = C_ADDIW + { 3, &RISCVDescs.OperandInfo[7924] }, // Inst #11750 = C_ADDI4SPN + { 3, &RISCVDescs.OperandInfo[7921] }, // Inst #11749 = C_ADDI16SP + { 3, &RISCVDescs.OperandInfo[7918] }, // Inst #11748 = C_ADDI + { 3, &RISCVDescs.OperandInfo[7915] }, // Inst #11747 = C_ADD + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11746 = CZERO_NEZ + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11745 = CZERO_EQZ + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11744 = CV_XOR_SC_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11743 = CV_XOR_SC_B + { 3, &RISCVDescs.OperandInfo[7852] }, // Inst #11742 = CV_XOR_SCI_H + { 3, &RISCVDescs.OperandInfo[7852] }, // Inst #11741 = CV_XOR_SCI_B + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11740 = CV_XOR_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11739 = CV_XOR_B + { 4, &RISCVDescs.OperandInfo[7901] }, // Inst #11738 = CV_SW_rr_inc + { 2, &RISCVDescs.OperandInfo[161] }, // Inst #11737 = CV_SW_rr + { 4, &RISCVDescs.OperandInfo[7897] }, // Inst #11736 = CV_SW_ri_inc + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11735 = CV_SUB_SC_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11734 = CV_SUB_SC_B + { 3, &RISCVDescs.OperandInfo[7852] }, // Inst #11733 = CV_SUB_SCI_H + { 3, &RISCVDescs.OperandInfo[7852] }, // Inst #11732 = CV_SUB_SCI_B + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11731 = CV_SUB_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11730 = CV_SUB_DIV8 + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11729 = CV_SUB_DIV4 + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11728 = CV_SUB_DIV2 + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11727 = CV_SUB_B + { 4, &RISCVDescs.OperandInfo[7848] }, // Inst #11726 = CV_SUBURNR + { 4, &RISCVDescs.OperandInfo[7844] }, // Inst #11725 = CV_SUBURN + { 4, &RISCVDescs.OperandInfo[7848] }, // Inst #11724 = CV_SUBUNR + { 4, &RISCVDescs.OperandInfo[7844] }, // Inst #11723 = CV_SUBUN + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11722 = CV_SUBROTMJ_DIV8 + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11721 = CV_SUBROTMJ_DIV4 + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11720 = CV_SUBROTMJ_DIV2 + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11719 = CV_SUBROTMJ + { 4, &RISCVDescs.OperandInfo[7848] }, // Inst #11718 = CV_SUBRNR + { 4, &RISCVDescs.OperandInfo[7844] }, // Inst #11717 = CV_SUBRN + { 4, &RISCVDescs.OperandInfo[7848] }, // Inst #11716 = CV_SUBNR + { 4, &RISCVDescs.OperandInfo[7844] }, // Inst #11715 = CV_SUBN + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11714 = CV_SRL_SC_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11713 = CV_SRL_SC_B + { 3, &RISCVDescs.OperandInfo[7912] }, // Inst #11712 = CV_SRL_SCI_H + { 3, &RISCVDescs.OperandInfo[7909] }, // Inst #11711 = CV_SRL_SCI_B + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11710 = CV_SRL_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11709 = CV_SRL_B + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11708 = CV_SRA_SC_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11707 = CV_SRA_SC_B + { 3, &RISCVDescs.OperandInfo[7912] }, // Inst #11706 = CV_SRA_SCI_H + { 3, &RISCVDescs.OperandInfo[7909] }, // Inst #11705 = CV_SRA_SCI_B + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11704 = CV_SRA_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11703 = CV_SRA_B + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11702 = CV_SLL_SC_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11701 = CV_SLL_SC_B + { 3, &RISCVDescs.OperandInfo[7912] }, // Inst #11700 = CV_SLL_SCI_H + { 3, &RISCVDescs.OperandInfo[7909] }, // Inst #11699 = CV_SLL_SCI_B + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11698 = CV_SLL_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11697 = CV_SLL_B + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11696 = CV_SLETU + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11695 = CV_SLET + { 4, &RISCVDescs.OperandInfo[7901] }, // Inst #11694 = CV_SH_rr_inc + { 2, &RISCVDescs.OperandInfo[161] }, // Inst #11693 = CV_SH_rr + { 4, &RISCVDescs.OperandInfo[7897] }, // Inst #11692 = CV_SH_ri_inc + { 3, &RISCVDescs.OperandInfo[7855] }, // Inst #11691 = CV_SHUFFLE_SCI_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11690 = CV_SHUFFLE_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11689 = CV_SHUFFLE_B + { 3, &RISCVDescs.OperandInfo[7855] }, // Inst #11688 = CV_SHUFFLEI3_SCI_B + { 3, &RISCVDescs.OperandInfo[7855] }, // Inst #11687 = CV_SHUFFLEI2_SCI_B + { 3, &RISCVDescs.OperandInfo[7855] }, // Inst #11686 = CV_SHUFFLEI1_SCI_B + { 3, &RISCVDescs.OperandInfo[7855] }, // Inst #11685 = CV_SHUFFLEI0_SCI_B + { 4, &RISCVDescs.OperandInfo[7848] }, // Inst #11684 = CV_SHUFFLE2_H + { 4, &RISCVDescs.OperandInfo[7848] }, // Inst #11683 = CV_SHUFFLE2_B + { 4, &RISCVDescs.OperandInfo[7848] }, // Inst #11682 = CV_SDOTUSP_SC_H + { 4, &RISCVDescs.OperandInfo[7848] }, // Inst #11681 = CV_SDOTUSP_SC_B + { 4, &RISCVDescs.OperandInfo[7905] }, // Inst #11680 = CV_SDOTUSP_SCI_H + { 4, &RISCVDescs.OperandInfo[7905] }, // Inst #11679 = CV_SDOTUSP_SCI_B + { 4, &RISCVDescs.OperandInfo[7848] }, // Inst #11678 = CV_SDOTUSP_H + { 4, &RISCVDescs.OperandInfo[7848] }, // Inst #11677 = CV_SDOTUSP_B + { 4, &RISCVDescs.OperandInfo[7848] }, // Inst #11676 = CV_SDOTUP_SC_H + { 4, &RISCVDescs.OperandInfo[7848] }, // Inst #11675 = CV_SDOTUP_SC_B + { 4, &RISCVDescs.OperandInfo[7880] }, // Inst #11674 = CV_SDOTUP_SCI_H + { 4, &RISCVDescs.OperandInfo[7880] }, // Inst #11673 = CV_SDOTUP_SCI_B + { 4, &RISCVDescs.OperandInfo[7848] }, // Inst #11672 = CV_SDOTUP_H + { 4, &RISCVDescs.OperandInfo[7848] }, // Inst #11671 = CV_SDOTUP_B + { 4, &RISCVDescs.OperandInfo[7848] }, // Inst #11670 = CV_SDOTSP_SC_H + { 4, &RISCVDescs.OperandInfo[7848] }, // Inst #11669 = CV_SDOTSP_SC_B + { 4, &RISCVDescs.OperandInfo[7905] }, // Inst #11668 = CV_SDOTSP_SCI_H + { 4, &RISCVDescs.OperandInfo[7905] }, // Inst #11667 = CV_SDOTSP_SCI_B + { 4, &RISCVDescs.OperandInfo[7848] }, // Inst #11666 = CV_SDOTSP_H + { 4, &RISCVDescs.OperandInfo[7848] }, // Inst #11665 = CV_SDOTSP_B + { 4, &RISCVDescs.OperandInfo[7901] }, // Inst #11664 = CV_SB_rr_inc + { 2, &RISCVDescs.OperandInfo[161] }, // Inst #11663 = CV_SB_rr + { 4, &RISCVDescs.OperandInfo[7897] }, // Inst #11662 = CV_SB_ri_inc + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11661 = CV_ROR + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11660 = CV_PACK_H + { 4, &RISCVDescs.OperandInfo[7848] }, // Inst #11659 = CV_PACKLO_B + { 4, &RISCVDescs.OperandInfo[7848] }, // Inst #11658 = CV_PACKHI_B + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11657 = CV_PACK + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11656 = CV_OR_SC_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11655 = CV_OR_SC_B + { 3, &RISCVDescs.OperandInfo[7852] }, // Inst #11654 = CV_OR_SCI_H + { 3, &RISCVDescs.OperandInfo[7852] }, // Inst #11653 = CV_OR_SCI_B + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11652 = CV_OR_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11651 = CV_OR_B + { 4, &RISCVDescs.OperandInfo[7844] }, // Inst #11650 = CV_MULURN + { 4, &RISCVDescs.OperandInfo[7844] }, // Inst #11649 = CV_MULUN + { 4, &RISCVDescs.OperandInfo[7844] }, // Inst #11648 = CV_MULSRN + { 4, &RISCVDescs.OperandInfo[7844] }, // Inst #11647 = CV_MULSN + { 4, &RISCVDescs.OperandInfo[7844] }, // Inst #11646 = CV_MULHHURN + { 4, &RISCVDescs.OperandInfo[7844] }, // Inst #11645 = CV_MULHHUN + { 4, &RISCVDescs.OperandInfo[7844] }, // Inst #11644 = CV_MULHHSRN + { 4, &RISCVDescs.OperandInfo[7844] }, // Inst #11643 = CV_MULHHSN + { 4, &RISCVDescs.OperandInfo[7848] }, // Inst #11642 = CV_MSU + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11641 = CV_MIN_SC_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11640 = CV_MIN_SC_B + { 3, &RISCVDescs.OperandInfo[7852] }, // Inst #11639 = CV_MIN_SCI_H + { 3, &RISCVDescs.OperandInfo[7852] }, // Inst #11638 = CV_MIN_SCI_B + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11637 = CV_MIN_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11636 = CV_MIN_B + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11635 = CV_MINU_SC_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11634 = CV_MINU_SC_B + { 3, &RISCVDescs.OperandInfo[7855] }, // Inst #11633 = CV_MINU_SCI_H + { 3, &RISCVDescs.OperandInfo[7855] }, // Inst #11632 = CV_MINU_SCI_B + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11631 = CV_MINU_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11630 = CV_MINU_B + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11629 = CV_MINU + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11628 = CV_MIN + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11627 = CV_MAX_SC_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11626 = CV_MAX_SC_B + { 3, &RISCVDescs.OperandInfo[7852] }, // Inst #11625 = CV_MAX_SCI_H + { 3, &RISCVDescs.OperandInfo[7852] }, // Inst #11624 = CV_MAX_SCI_B + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11623 = CV_MAX_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11622 = CV_MAX_B + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11621 = CV_MAXU_SC_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11620 = CV_MAXU_SC_B + { 3, &RISCVDescs.OperandInfo[7855] }, // Inst #11619 = CV_MAXU_SCI_H + { 3, &RISCVDescs.OperandInfo[7855] }, // Inst #11618 = CV_MAXU_SCI_B + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11617 = CV_MAXU_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11616 = CV_MAXU_B + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11615 = CV_MAXU + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11614 = CV_MAX + { 5, &RISCVDescs.OperandInfo[7892] }, // Inst #11613 = CV_MACURN + { 5, &RISCVDescs.OperandInfo[7892] }, // Inst #11612 = CV_MACUN + { 5, &RISCVDescs.OperandInfo[7892] }, // Inst #11611 = CV_MACSRN + { 5, &RISCVDescs.OperandInfo[7892] }, // Inst #11610 = CV_MACSN + { 5, &RISCVDescs.OperandInfo[7892] }, // Inst #11609 = CV_MACHHURN + { 5, &RISCVDescs.OperandInfo[7892] }, // Inst #11608 = CV_MACHHUN + { 5, &RISCVDescs.OperandInfo[7892] }, // Inst #11607 = CV_MACHHSRN + { 5, &RISCVDescs.OperandInfo[7892] }, // Inst #11606 = CV_MACHHSN + { 4, &RISCVDescs.OperandInfo[7848] }, // Inst #11605 = CV_MAC + { 4, &RISCVDescs.OperandInfo[7888] }, // Inst #11604 = CV_LW_rr_inc + { 2, &RISCVDescs.OperandInfo[161] }, // Inst #11603 = CV_LW_rr + { 4, &RISCVDescs.OperandInfo[7884] }, // Inst #11602 = CV_LW_ri_inc + { 4, &RISCVDescs.OperandInfo[7888] }, // Inst #11601 = CV_LH_rr_inc + { 2, &RISCVDescs.OperandInfo[161] }, // Inst #11600 = CV_LH_rr + { 4, &RISCVDescs.OperandInfo[7884] }, // Inst #11599 = CV_LH_ri_inc + { 4, &RISCVDescs.OperandInfo[7888] }, // Inst #11598 = CV_LHU_rr_inc + { 2, &RISCVDescs.OperandInfo[161] }, // Inst #11597 = CV_LHU_rr + { 4, &RISCVDescs.OperandInfo[7884] }, // Inst #11596 = CV_LHU_ri_inc + { 4, &RISCVDescs.OperandInfo[7888] }, // Inst #11595 = CV_LB_rr_inc + { 2, &RISCVDescs.OperandInfo[161] }, // Inst #11594 = CV_LB_rr + { 4, &RISCVDescs.OperandInfo[7884] }, // Inst #11593 = CV_LB_ri_inc + { 4, &RISCVDescs.OperandInfo[7888] }, // Inst #11592 = CV_LBU_rr_inc + { 2, &RISCVDescs.OperandInfo[161] }, // Inst #11591 = CV_LBU_rr + { 4, &RISCVDescs.OperandInfo[7884] }, // Inst #11590 = CV_LBU_ri_inc + { 4, &RISCVDescs.OperandInfo[7880] }, // Inst #11589 = CV_INSERT_H + { 4, &RISCVDescs.OperandInfo[7880] }, // Inst #11588 = CV_INSERT_B + { 4, &RISCVDescs.OperandInfo[7848] }, // Inst #11587 = CV_INSERTR + { 5, &RISCVDescs.OperandInfo[7875] }, // Inst #11586 = CV_INSERT + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #11585 = CV_FL1 + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #11584 = CV_FF1 + { 3, &RISCVDescs.OperandInfo[7855] }, // Inst #11583 = CV_EXTRACT_H + { 3, &RISCVDescs.OperandInfo[7855] }, // Inst #11582 = CV_EXTRACT_B + { 3, &RISCVDescs.OperandInfo[7855] }, // Inst #11581 = CV_EXTRACTU_H + { 3, &RISCVDescs.OperandInfo[7855] }, // Inst #11580 = CV_EXTRACTU_B + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11579 = CV_EXTRACTUR + { 4, &RISCVDescs.OperandInfo[7858] }, // Inst #11578 = CV_EXTRACTU + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11577 = CV_EXTRACTR + { 4, &RISCVDescs.OperandInfo[7858] }, // Inst #11576 = CV_EXTRACT + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #11575 = CV_EXTHZ + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #11574 = CV_EXTHS + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #11573 = CV_EXTBZ + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #11572 = CV_EXTBS + { 3, &RISCVDescs.OperandInfo[7872] }, // Inst #11571 = CV_ELW + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11570 = CV_DOTUSP_SC_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11569 = CV_DOTUSP_SC_B + { 3, &RISCVDescs.OperandInfo[7852] }, // Inst #11568 = CV_DOTUSP_SCI_H + { 3, &RISCVDescs.OperandInfo[7852] }, // Inst #11567 = CV_DOTUSP_SCI_B + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11566 = CV_DOTUSP_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11565 = CV_DOTUSP_B + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11564 = CV_DOTUP_SC_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11563 = CV_DOTUP_SC_B + { 3, &RISCVDescs.OperandInfo[7855] }, // Inst #11562 = CV_DOTUP_SCI_H + { 3, &RISCVDescs.OperandInfo[7855] }, // Inst #11561 = CV_DOTUP_SCI_B + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11560 = CV_DOTUP_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11559 = CV_DOTUP_B + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11558 = CV_DOTSP_SC_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11557 = CV_DOTSP_SC_B + { 3, &RISCVDescs.OperandInfo[7852] }, // Inst #11556 = CV_DOTSP_SCI_H + { 3, &RISCVDescs.OperandInfo[7852] }, // Inst #11555 = CV_DOTSP_SCI_B + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11554 = CV_DOTSP_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11553 = CV_DOTSP_B + { 4, &RISCVDescs.OperandInfo[7848] }, // Inst #11552 = CV_CPLXMUL_R_DIV8 + { 4, &RISCVDescs.OperandInfo[7848] }, // Inst #11551 = CV_CPLXMUL_R_DIV4 + { 4, &RISCVDescs.OperandInfo[7848] }, // Inst #11550 = CV_CPLXMUL_R_DIV2 + { 4, &RISCVDescs.OperandInfo[7848] }, // Inst #11549 = CV_CPLXMUL_R + { 4, &RISCVDescs.OperandInfo[7848] }, // Inst #11548 = CV_CPLXMUL_I_DIV8 + { 4, &RISCVDescs.OperandInfo[7848] }, // Inst #11547 = CV_CPLXMUL_I_DIV4 + { 4, &RISCVDescs.OperandInfo[7848] }, // Inst #11546 = CV_CPLXMUL_I_DIV2 + { 4, &RISCVDescs.OperandInfo[7848] }, // Inst #11545 = CV_CPLXMUL_I + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #11544 = CV_CPLXCONJ + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #11543 = CV_CNT + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11542 = CV_CMPNE_SC_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11541 = CV_CMPNE_SC_B + { 3, &RISCVDescs.OperandInfo[7852] }, // Inst #11540 = CV_CMPNE_SCI_H + { 3, &RISCVDescs.OperandInfo[7852] }, // Inst #11539 = CV_CMPNE_SCI_B + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11538 = CV_CMPNE_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11537 = CV_CMPNE_B + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11536 = CV_CMPLT_SC_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11535 = CV_CMPLT_SC_B + { 3, &RISCVDescs.OperandInfo[7852] }, // Inst #11534 = CV_CMPLT_SCI_H + { 3, &RISCVDescs.OperandInfo[7852] }, // Inst #11533 = CV_CMPLT_SCI_B + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11532 = CV_CMPLT_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11531 = CV_CMPLT_B + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11530 = CV_CMPLTU_SC_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11529 = CV_CMPLTU_SC_B + { 3, &RISCVDescs.OperandInfo[7855] }, // Inst #11528 = CV_CMPLTU_SCI_H + { 3, &RISCVDescs.OperandInfo[7855] }, // Inst #11527 = CV_CMPLTU_SCI_B + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11526 = CV_CMPLTU_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11525 = CV_CMPLTU_B + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11524 = CV_CMPLE_SC_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11523 = CV_CMPLE_SC_B + { 3, &RISCVDescs.OperandInfo[7852] }, // Inst #11522 = CV_CMPLE_SCI_H + { 3, &RISCVDescs.OperandInfo[7852] }, // Inst #11521 = CV_CMPLE_SCI_B + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11520 = CV_CMPLE_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11519 = CV_CMPLE_B + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11518 = CV_CMPLEU_SC_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11517 = CV_CMPLEU_SC_B + { 3, &RISCVDescs.OperandInfo[7855] }, // Inst #11516 = CV_CMPLEU_SCI_H + { 3, &RISCVDescs.OperandInfo[7855] }, // Inst #11515 = CV_CMPLEU_SCI_B + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11514 = CV_CMPLEU_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11513 = CV_CMPLEU_B + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11512 = CV_CMPGT_SC_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11511 = CV_CMPGT_SC_B + { 3, &RISCVDescs.OperandInfo[7852] }, // Inst #11510 = CV_CMPGT_SCI_H + { 3, &RISCVDescs.OperandInfo[7852] }, // Inst #11509 = CV_CMPGT_SCI_B + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11508 = CV_CMPGT_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11507 = CV_CMPGT_B + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11506 = CV_CMPGTU_SC_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11505 = CV_CMPGTU_SC_B + { 3, &RISCVDescs.OperandInfo[7855] }, // Inst #11504 = CV_CMPGTU_SCI_H + { 3, &RISCVDescs.OperandInfo[7855] }, // Inst #11503 = CV_CMPGTU_SCI_B + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11502 = CV_CMPGTU_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11501 = CV_CMPGTU_B + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11500 = CV_CMPGE_SC_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11499 = CV_CMPGE_SC_B + { 3, &RISCVDescs.OperandInfo[7852] }, // Inst #11498 = CV_CMPGE_SCI_H + { 3, &RISCVDescs.OperandInfo[7852] }, // Inst #11497 = CV_CMPGE_SCI_B + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11496 = CV_CMPGE_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11495 = CV_CMPGE_B + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11494 = CV_CMPGEU_SC_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11493 = CV_CMPGEU_SC_B + { 3, &RISCVDescs.OperandInfo[7855] }, // Inst #11492 = CV_CMPGEU_SCI_H + { 3, &RISCVDescs.OperandInfo[7855] }, // Inst #11491 = CV_CMPGEU_SCI_B + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11490 = CV_CMPGEU_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11489 = CV_CMPGEU_B + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11488 = CV_CMPEQ_SC_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11487 = CV_CMPEQ_SC_B + { 3, &RISCVDescs.OperandInfo[7852] }, // Inst #11486 = CV_CMPEQ_SCI_H + { 3, &RISCVDescs.OperandInfo[7852] }, // Inst #11485 = CV_CMPEQ_SCI_B + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11484 = CV_CMPEQ_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11483 = CV_CMPEQ_B + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11482 = CV_CLIPUR + { 3, &RISCVDescs.OperandInfo[7869] }, // Inst #11481 = CV_CLIPU + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11480 = CV_CLIPR + { 3, &RISCVDescs.OperandInfo[7869] }, // Inst #11479 = CV_CLIP + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #11478 = CV_CLB + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11477 = CV_BSETR + { 4, &RISCVDescs.OperandInfo[7858] }, // Inst #11476 = CV_BSET + { 3, &RISCVDescs.OperandInfo[7862] }, // Inst #11475 = CV_BNEIMM + { 4, &RISCVDescs.OperandInfo[7865] }, // Inst #11474 = CV_BITREV + { 3, &RISCVDescs.OperandInfo[7862] }, // Inst #11473 = CV_BEQIMM + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11472 = CV_BCLRR + { 4, &RISCVDescs.OperandInfo[7858] }, // Inst #11471 = CV_BCLR + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11470 = CV_AVG_SC_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11469 = CV_AVG_SC_B + { 3, &RISCVDescs.OperandInfo[7852] }, // Inst #11468 = CV_AVG_SCI_H + { 3, &RISCVDescs.OperandInfo[7852] }, // Inst #11467 = CV_AVG_SCI_B + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11466 = CV_AVG_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11465 = CV_AVG_B + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11464 = CV_AVGU_SC_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11463 = CV_AVGU_SC_B + { 3, &RISCVDescs.OperandInfo[7855] }, // Inst #11462 = CV_AVGU_SCI_H + { 3, &RISCVDescs.OperandInfo[7855] }, // Inst #11461 = CV_AVGU_SCI_B + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11460 = CV_AVGU_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11459 = CV_AVGU_B + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11458 = CV_AND_SC_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11457 = CV_AND_SC_B + { 3, &RISCVDescs.OperandInfo[7852] }, // Inst #11456 = CV_AND_SCI_H + { 3, &RISCVDescs.OperandInfo[7852] }, // Inst #11455 = CV_AND_SCI_B + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11454 = CV_AND_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11453 = CV_AND_B + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11452 = CV_ADD_SC_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11451 = CV_ADD_SC_B + { 3, &RISCVDescs.OperandInfo[7852] }, // Inst #11450 = CV_ADD_SCI_H + { 3, &RISCVDescs.OperandInfo[7852] }, // Inst #11449 = CV_ADD_SCI_B + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11448 = CV_ADD_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11447 = CV_ADD_DIV8 + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11446 = CV_ADD_DIV4 + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11445 = CV_ADD_DIV2 + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11444 = CV_ADD_B + { 4, &RISCVDescs.OperandInfo[7848] }, // Inst #11443 = CV_ADDURNR + { 4, &RISCVDescs.OperandInfo[7844] }, // Inst #11442 = CV_ADDURN + { 4, &RISCVDescs.OperandInfo[7848] }, // Inst #11441 = CV_ADDUNR + { 4, &RISCVDescs.OperandInfo[7844] }, // Inst #11440 = CV_ADDUN + { 4, &RISCVDescs.OperandInfo[7848] }, // Inst #11439 = CV_ADDRNR + { 4, &RISCVDescs.OperandInfo[7844] }, // Inst #11438 = CV_ADDRN + { 4, &RISCVDescs.OperandInfo[7848] }, // Inst #11437 = CV_ADDNR + { 4, &RISCVDescs.OperandInfo[7844] }, // Inst #11436 = CV_ADDN + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #11435 = CV_ABS_H + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #11434 = CV_ABS_B + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #11433 = CV_ABS + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #11432 = CTZW + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #11431 = CTZ + { 3, &RISCVDescs.OperandInfo[7841] }, // Inst #11430 = CSRRWI + { 3, &RISCVDescs.OperandInfo[7838] }, // Inst #11429 = CSRRW + { 3, &RISCVDescs.OperandInfo[7841] }, // Inst #11428 = CSRRSI + { 3, &RISCVDescs.OperandInfo[7838] }, // Inst #11427 = CSRRS + { 3, &RISCVDescs.OperandInfo[7841] }, // Inst #11426 = CSRRCI + { 3, &RISCVDescs.OperandInfo[7838] }, // Inst #11425 = CSRRC + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #11424 = CPOPW + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #11423 = CPOP + { 2, &RISCVDescs.OperandInfo[13] }, // Inst #11422 = CM_PUSH + { 2, &RISCVDescs.OperandInfo[13] }, // Inst #11421 = CM_POPRETZ + { 2, &RISCVDescs.OperandInfo[13] }, // Inst #11420 = CM_POPRET + { 2, &RISCVDescs.OperandInfo[13] }, // Inst #11419 = CM_POP + { 2, &RISCVDescs.OperandInfo[7836] }, // Inst #11418 = CM_MVSA01 + { 2, &RISCVDescs.OperandInfo[7836] }, // Inst #11417 = CM_MVA01S + { 1, &RISCVDescs.OperandInfo[7807] }, // Inst #11416 = CM_JT + { 1, &RISCVDescs.OperandInfo[7835] }, // Inst #11415 = CM_JALT + { 0, &RISCVDescs.OperandInfo[1] }, // Inst #11414 = CMOP9 + { 0, &RISCVDescs.OperandInfo[1] }, // Inst #11413 = CMOP7 + { 0, &RISCVDescs.OperandInfo[1] }, // Inst #11412 = CMOP5 + { 0, &RISCVDescs.OperandInfo[1] }, // Inst #11411 = CMOP3 + { 0, &RISCVDescs.OperandInfo[1] }, // Inst #11410 = CMOP15 + { 0, &RISCVDescs.OperandInfo[1] }, // Inst #11409 = CMOP13 + { 0, &RISCVDescs.OperandInfo[1] }, // Inst #11408 = CMOP11 + { 0, &RISCVDescs.OperandInfo[1] }, // Inst #11407 = CMOP1 + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #11406 = CLZW + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #11405 = CLZ + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11404 = CLMULR + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11403 = CLMULH + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11402 = CLMUL + { 1, &RISCVDescs.OperandInfo[7834] }, // Inst #11401 = CBO_ZERO + { 1, &RISCVDescs.OperandInfo[7834] }, // Inst #11400 = CBO_INVAL + { 1, &RISCVDescs.OperandInfo[7834] }, // Inst #11399 = CBO_FLUSH + { 1, &RISCVDescs.OperandInfo[7834] }, // Inst #11398 = CBO_CLEAN + { 3, &RISCVDescs.OperandInfo[7831] }, // Inst #11397 = BSETI + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11396 = BSET + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #11395 = BREV8 + { 3, &RISCVDescs.OperandInfo[228] }, // Inst #11394 = BNE + { 3, &RISCVDescs.OperandInfo[228] }, // Inst #11393 = BLTU + { 3, &RISCVDescs.OperandInfo[228] }, // Inst #11392 = BLT + { 3, &RISCVDescs.OperandInfo[7831] }, // Inst #11391 = BINVI + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11390 = BINV + { 3, &RISCVDescs.OperandInfo[228] }, // Inst #11389 = BGEU + { 3, &RISCVDescs.OperandInfo[228] }, // Inst #11388 = BGE + { 3, &RISCVDescs.OperandInfo[7831] }, // Inst #11387 = BEXTI + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11386 = BEXT + { 3, &RISCVDescs.OperandInfo[228] }, // Inst #11385 = BEQ + { 3, &RISCVDescs.OperandInfo[7831] }, // Inst #11384 = BCLRI + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11383 = BCLR + { 2, &RISCVDescs.OperandInfo[7829] }, // Inst #11382 = AUIPC + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11381 = ANDN + { 3, &RISCVDescs.OperandInfo[7808] }, // Inst #11380 = ANDI + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11379 = AND + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11378 = AMOXOR_W_RL + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11377 = AMOXOR_W_AQ_RL + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11376 = AMOXOR_W_AQ + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11375 = AMOXOR_W + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11374 = AMOXOR_D_RL + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11373 = AMOXOR_D_AQ_RL + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11372 = AMOXOR_D_AQ + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11371 = AMOXOR_D + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11370 = AMOSWAP_W_RL + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11369 = AMOSWAP_W_AQ_RL + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11368 = AMOSWAP_W_AQ + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11367 = AMOSWAP_W + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11366 = AMOSWAP_D_RL + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11365 = AMOSWAP_D_AQ_RL + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11364 = AMOSWAP_D_AQ + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11363 = AMOSWAP_D + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11362 = AMOOR_W_RL + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11361 = AMOOR_W_AQ_RL + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11360 = AMOOR_W_AQ + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11359 = AMOOR_W + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11358 = AMOOR_D_RL + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11357 = AMOOR_D_AQ_RL + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11356 = AMOOR_D_AQ + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11355 = AMOOR_D + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11354 = AMOMIN_W_RL + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11353 = AMOMIN_W_AQ_RL + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11352 = AMOMIN_W_AQ + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11351 = AMOMIN_W + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11350 = AMOMIN_D_RL + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11349 = AMOMIN_D_AQ_RL + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11348 = AMOMIN_D_AQ + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11347 = AMOMIN_D + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11346 = AMOMINU_W_RL + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11345 = AMOMINU_W_AQ_RL + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11344 = AMOMINU_W_AQ + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11343 = AMOMINU_W + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11342 = AMOMINU_D_RL + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11341 = AMOMINU_D_AQ_RL + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11340 = AMOMINU_D_AQ + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11339 = AMOMINU_D + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11338 = AMOMAX_W_RL + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11337 = AMOMAX_W_AQ_RL + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11336 = AMOMAX_W_AQ + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11335 = AMOMAX_W + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11334 = AMOMAX_D_RL + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11333 = AMOMAX_D_AQ_RL + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11332 = AMOMAX_D_AQ + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11331 = AMOMAX_D + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11330 = AMOMAXU_W_RL + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11329 = AMOMAXU_W_AQ_RL + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11328 = AMOMAXU_W_AQ + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11327 = AMOMAXU_W + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11326 = AMOMAXU_D_RL + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11325 = AMOMAXU_D_AQ_RL + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11324 = AMOMAXU_D_AQ + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11323 = AMOMAXU_D + { 4, &RISCVDescs.OperandInfo[7825] }, // Inst #11322 = AMOCAS_W_RL + { 4, &RISCVDescs.OperandInfo[7825] }, // Inst #11321 = AMOCAS_W_AQ_RL + { 4, &RISCVDescs.OperandInfo[7825] }, // Inst #11320 = AMOCAS_W_AQ + { 4, &RISCVDescs.OperandInfo[7825] }, // Inst #11319 = AMOCAS_W + { 4, &RISCVDescs.OperandInfo[7821] }, // Inst #11318 = AMOCAS_Q_RL + { 4, &RISCVDescs.OperandInfo[7821] }, // Inst #11317 = AMOCAS_Q_AQ_RL + { 4, &RISCVDescs.OperandInfo[7821] }, // Inst #11316 = AMOCAS_Q_AQ + { 4, &RISCVDescs.OperandInfo[7821] }, // Inst #11315 = AMOCAS_Q + { 4, &RISCVDescs.OperandInfo[7825] }, // Inst #11314 = AMOCAS_D_RV64_RL + { 4, &RISCVDescs.OperandInfo[7825] }, // Inst #11313 = AMOCAS_D_RV64_AQ_RL + { 4, &RISCVDescs.OperandInfo[7825] }, // Inst #11312 = AMOCAS_D_RV64_AQ + { 4, &RISCVDescs.OperandInfo[7825] }, // Inst #11311 = AMOCAS_D_RV64 + { 4, &RISCVDescs.OperandInfo[7821] }, // Inst #11310 = AMOCAS_D_RV32_RL + { 4, &RISCVDescs.OperandInfo[7821] }, // Inst #11309 = AMOCAS_D_RV32_AQ_RL + { 4, &RISCVDescs.OperandInfo[7821] }, // Inst #11308 = AMOCAS_D_RV32_AQ + { 4, &RISCVDescs.OperandInfo[7821] }, // Inst #11307 = AMOCAS_D_RV32 + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11306 = AMOAND_W_RL + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11305 = AMOAND_W_AQ_RL + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11304 = AMOAND_W_AQ + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11303 = AMOAND_W + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11302 = AMOAND_D_RL + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11301 = AMOAND_D_AQ_RL + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11300 = AMOAND_D_AQ + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11299 = AMOAND_D + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11298 = AMOADD_W_RL + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11297 = AMOADD_W_AQ_RL + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11296 = AMOADD_W_AQ + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11295 = AMOADD_W + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11294 = AMOADD_D_RL + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11293 = AMOADD_D_AQ_RL + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11292 = AMOADD_D_AQ + { 3, &RISCVDescs.OperandInfo[7818] }, // Inst #11291 = AMOADD_D + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11290 = AES64KS2 + { 3, &RISCVDescs.OperandInfo[7815] }, // Inst #11289 = AES64KS1I + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #11288 = AES64IM + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11287 = AES64ESM + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11286 = AES64ES + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11285 = AES64DSM + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11284 = AES64DS + { 4, &RISCVDescs.OperandInfo[7811] }, // Inst #11283 = AES32ESMI + { 4, &RISCVDescs.OperandInfo[7811] }, // Inst #11282 = AES32ESI + { 4, &RISCVDescs.OperandInfo[7811] }, // Inst #11281 = AES32DSMI + { 4, &RISCVDescs.OperandInfo[7811] }, // Inst #11280 = AES32DSI + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11279 = ADD_UW + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11278 = ADDW + { 3, &RISCVDescs.OperandInfo[7808] }, // Inst #11277 = ADDIW + { 3, &RISCVDescs.OperandInfo[7808] }, // Inst #11276 = ADDI + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #11275 = ADD + { 1, &RISCVDescs.OperandInfo[7807] }, // Inst #11274 = WriteVXRMImm + { 1, &RISCVDescs.OperandInfo[7807] }, // Inst #11273 = WriteFRMImm + { 1, &RISCVDescs.OperandInfo[286] }, // Inst #11272 = WriteFRM + { 1, &RISCVDescs.OperandInfo[286] }, // Inst #11271 = WriteFFLAGS + { 2, &RISCVDescs.OperandInfo[7805] }, // Inst #11270 = SwapFRMImm + { 3, &RISCVDescs.OperandInfo[7802] }, // Inst #11269 = SplitF64Pseudo_INX + { 3, &RISCVDescs.OperandInfo[7799] }, // Inst #11268 = SplitF64Pseudo + { 6, &RISCVDescs.OperandInfo[7787] }, // Inst #11267 = Select_GPR_Using_CC_GPR + { 6, &RISCVDescs.OperandInfo[7793] }, // Inst #11266 = Select_FPR64_Using_CC_GPR + { 6, &RISCVDescs.OperandInfo[7787] }, // Inst #11265 = Select_FPR64INX_Using_CC_GPR + { 6, &RISCVDescs.OperandInfo[7781] }, // Inst #11264 = Select_FPR64IN32X_Using_CC_GPR + { 6, &RISCVDescs.OperandInfo[7775] }, // Inst #11263 = Select_FPR32_Using_CC_GPR + { 6, &RISCVDescs.OperandInfo[7769] }, // Inst #11262 = Select_FPR32INX_Using_CC_GPR + { 6, &RISCVDescs.OperandInfo[7763] }, // Inst #11261 = Select_FPR16_Using_CC_GPR + { 6, &RISCVDescs.OperandInfo[7757] }, // Inst #11260 = Select_FPR16INX_Using_CC_GPR + { 1, &RISCVDescs.OperandInfo[286] }, // Inst #11259 = ReadFRM + { 1, &RISCVDescs.OperandInfo[286] }, // Inst #11258 = ReadFFLAGS + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #11257 = ReadCycleWide + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #11256 = PseudoZEXT_W + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #11255 = PseudoZEXT_H + { 7, &RISCVDescs.OperandInfo[3787] }, // Inst #11254 = PseudoVZEXT_VF8_M8_MASK + { 6, &RISCVDescs.OperandInfo[3781] }, // Inst #11253 = PseudoVZEXT_VF8_M8 + { 7, &RISCVDescs.OperandInfo[3774] }, // Inst #11252 = PseudoVZEXT_VF8_M4_MASK + { 6, &RISCVDescs.OperandInfo[3768] }, // Inst #11251 = PseudoVZEXT_VF8_M4 + { 7, &RISCVDescs.OperandInfo[3527] }, // Inst #11250 = PseudoVZEXT_VF8_M2_MASK + { 6, &RISCVDescs.OperandInfo[3521] }, // Inst #11249 = PseudoVZEXT_VF8_M2 + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #11248 = PseudoVZEXT_VF8_M1_MASK + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #11247 = PseudoVZEXT_VF8_M1 + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #11246 = PseudoVZEXT_VF4_MF2_MASK + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #11245 = PseudoVZEXT_VF4_MF2 + { 7, &RISCVDescs.OperandInfo[6571] }, // Inst #11244 = PseudoVZEXT_VF4_M8_MASK + { 6, &RISCVDescs.OperandInfo[6565] }, // Inst #11243 = PseudoVZEXT_VF4_M8 + { 7, &RISCVDescs.OperandInfo[3774] }, // Inst #11242 = PseudoVZEXT_VF4_M4_MASK + { 6, &RISCVDescs.OperandInfo[3768] }, // Inst #11241 = PseudoVZEXT_VF4_M4 + { 7, &RISCVDescs.OperandInfo[3527] }, // Inst #11240 = PseudoVZEXT_VF4_M2_MASK + { 6, &RISCVDescs.OperandInfo[3521] }, // Inst #11239 = PseudoVZEXT_VF4_M2 + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #11238 = PseudoVZEXT_VF4_M1_MASK + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #11237 = PseudoVZEXT_VF4_M1 + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #11236 = PseudoVZEXT_VF2_MF4_MASK + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #11235 = PseudoVZEXT_VF2_MF4 + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #11234 = PseudoVZEXT_VF2_MF2_MASK + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #11233 = PseudoVZEXT_VF2_MF2 + { 7, &RISCVDescs.OperandInfo[3553] }, // Inst #11232 = PseudoVZEXT_VF2_M8_MASK + { 6, &RISCVDescs.OperandInfo[3547] }, // Inst #11231 = PseudoVZEXT_VF2_M8 + { 7, &RISCVDescs.OperandInfo[3540] }, // Inst #11230 = PseudoVZEXT_VF2_M4_MASK + { 6, &RISCVDescs.OperandInfo[3534] }, // Inst #11229 = PseudoVZEXT_VF2_M4 + { 7, &RISCVDescs.OperandInfo[3527] }, // Inst #11228 = PseudoVZEXT_VF2_M2_MASK + { 6, &RISCVDescs.OperandInfo[3521] }, // Inst #11227 = PseudoVZEXT_VF2_M2 + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #11226 = PseudoVZEXT_VF2_M1_MASK + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #11225 = PseudoVZEXT_VF2_M1 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #11224 = PseudoVXOR_VX_MF8_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #11223 = PseudoVXOR_VX_MF8 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #11222 = PseudoVXOR_VX_MF4_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #11221 = PseudoVXOR_VX_MF4 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #11220 = PseudoVXOR_VX_MF2_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #11219 = PseudoVXOR_VX_MF2 + { 8, &RISCVDescs.OperandInfo[809] }, // Inst #11218 = PseudoVXOR_VX_M8_MASK + { 7, &RISCVDescs.OperandInfo[802] }, // Inst #11217 = PseudoVXOR_VX_M8 + { 8, &RISCVDescs.OperandInfo[794] }, // Inst #11216 = PseudoVXOR_VX_M4_MASK + { 7, &RISCVDescs.OperandInfo[787] }, // Inst #11215 = PseudoVXOR_VX_M4 + { 8, &RISCVDescs.OperandInfo[779] }, // Inst #11214 = PseudoVXOR_VX_M2_MASK + { 7, &RISCVDescs.OperandInfo[772] }, // Inst #11213 = PseudoVXOR_VX_M2 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #11212 = PseudoVXOR_VX_M1_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #11211 = PseudoVXOR_VX_M1 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #11210 = PseudoVXOR_VV_MF8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #11209 = PseudoVXOR_VV_MF8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #11208 = PseudoVXOR_VV_MF4_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #11207 = PseudoVXOR_VV_MF4 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #11206 = PseudoVXOR_VV_MF2_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #11205 = PseudoVXOR_VV_MF2 + { 8, &RISCVDescs.OperandInfo[749] }, // Inst #11204 = PseudoVXOR_VV_M8_MASK + { 7, &RISCVDescs.OperandInfo[742] }, // Inst #11203 = PseudoVXOR_VV_M8 + { 8, &RISCVDescs.OperandInfo[734] }, // Inst #11202 = PseudoVXOR_VV_M4_MASK + { 7, &RISCVDescs.OperandInfo[727] }, // Inst #11201 = PseudoVXOR_VV_M4 + { 8, &RISCVDescs.OperandInfo[719] }, // Inst #11200 = PseudoVXOR_VV_M2_MASK + { 7, &RISCVDescs.OperandInfo[712] }, // Inst #11199 = PseudoVXOR_VV_M2 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #11198 = PseudoVXOR_VV_M1_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #11197 = PseudoVXOR_VV_M1 + { 8, &RISCVDescs.OperandInfo[644] }, // Inst #11196 = PseudoVXOR_VI_MF8_MASK + { 7, &RISCVDescs.OperandInfo[637] }, // Inst #11195 = PseudoVXOR_VI_MF8 + { 8, &RISCVDescs.OperandInfo[644] }, // Inst #11194 = PseudoVXOR_VI_MF4_MASK + { 7, &RISCVDescs.OperandInfo[637] }, // Inst #11193 = PseudoVXOR_VI_MF4 + { 8, &RISCVDescs.OperandInfo[644] }, // Inst #11192 = PseudoVXOR_VI_MF2_MASK + { 7, &RISCVDescs.OperandInfo[637] }, // Inst #11191 = PseudoVXOR_VI_MF2 + { 8, &RISCVDescs.OperandInfo[689] }, // Inst #11190 = PseudoVXOR_VI_M8_MASK + { 7, &RISCVDescs.OperandInfo[682] }, // Inst #11189 = PseudoVXOR_VI_M8 + { 8, &RISCVDescs.OperandInfo[674] }, // Inst #11188 = PseudoVXOR_VI_M4_MASK + { 7, &RISCVDescs.OperandInfo[667] }, // Inst #11187 = PseudoVXOR_VI_M4 + { 8, &RISCVDescs.OperandInfo[659] }, // Inst #11186 = PseudoVXOR_VI_M2_MASK + { 7, &RISCVDescs.OperandInfo[652] }, // Inst #11185 = PseudoVXOR_VI_M2 + { 8, &RISCVDescs.OperandInfo[644] }, // Inst #11184 = PseudoVXOR_VI_M1_MASK + { 7, &RISCVDescs.OperandInfo[637] }, // Inst #11183 = PseudoVXOR_VI_M1 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #11182 = PseudoVWSUB_WX_MF8_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #11181 = PseudoVWSUB_WX_MF8 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #11180 = PseudoVWSUB_WX_MF4_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #11179 = PseudoVWSUB_WX_MF4 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #11178 = PseudoVWSUB_WX_MF2_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #11177 = PseudoVWSUB_WX_MF2 + { 8, &RISCVDescs.OperandInfo[809] }, // Inst #11176 = PseudoVWSUB_WX_M4_MASK + { 7, &RISCVDescs.OperandInfo[802] }, // Inst #11175 = PseudoVWSUB_WX_M4 + { 8, &RISCVDescs.OperandInfo[794] }, // Inst #11174 = PseudoVWSUB_WX_M2_MASK + { 7, &RISCVDescs.OperandInfo[787] }, // Inst #11173 = PseudoVWSUB_WX_M2 + { 8, &RISCVDescs.OperandInfo[779] }, // Inst #11172 = PseudoVWSUB_WX_M1_MASK + { 7, &RISCVDescs.OperandInfo[772] }, // Inst #11171 = PseudoVWSUB_WX_M1 + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #11170 = PseudoVWSUB_WV_MF8_TIED + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #11169 = PseudoVWSUB_WV_MF8_MASK_TIED + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #11168 = PseudoVWSUB_WV_MF8_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #11167 = PseudoVWSUB_WV_MF8 + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #11166 = PseudoVWSUB_WV_MF4_TIED + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #11165 = PseudoVWSUB_WV_MF4_MASK_TIED + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #11164 = PseudoVWSUB_WV_MF4_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #11163 = PseudoVWSUB_WV_MF4 + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #11162 = PseudoVWSUB_WV_MF2_TIED + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #11161 = PseudoVWSUB_WV_MF2_MASK_TIED + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #11160 = PseudoVWSUB_WV_MF2_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #11159 = PseudoVWSUB_WV_MF2 + { 6, &RISCVDescs.OperandInfo[3547] }, // Inst #11158 = PseudoVWSUB_WV_M4_TIED + { 7, &RISCVDescs.OperandInfo[3553] }, // Inst #11157 = PseudoVWSUB_WV_M4_MASK_TIED + { 8, &RISCVDescs.OperandInfo[6332] }, // Inst #11156 = PseudoVWSUB_WV_M4_MASK + { 7, &RISCVDescs.OperandInfo[6325] }, // Inst #11155 = PseudoVWSUB_WV_M4 + { 6, &RISCVDescs.OperandInfo[3534] }, // Inst #11154 = PseudoVWSUB_WV_M2_TIED + { 7, &RISCVDescs.OperandInfo[3540] }, // Inst #11153 = PseudoVWSUB_WV_M2_MASK_TIED + { 8, &RISCVDescs.OperandInfo[6287] }, // Inst #11152 = PseudoVWSUB_WV_M2_MASK + { 7, &RISCVDescs.OperandInfo[6280] }, // Inst #11151 = PseudoVWSUB_WV_M2 + { 6, &RISCVDescs.OperandInfo[3521] }, // Inst #11150 = PseudoVWSUB_WV_M1_TIED + { 7, &RISCVDescs.OperandInfo[3527] }, // Inst #11149 = PseudoVWSUB_WV_M1_MASK_TIED + { 8, &RISCVDescs.OperandInfo[6242] }, // Inst #11148 = PseudoVWSUB_WV_M1_MASK + { 7, &RISCVDescs.OperandInfo[6235] }, // Inst #11147 = PseudoVWSUB_WV_M1 + { 8, &RISCVDescs.OperandInfo[6407] }, // Inst #11146 = PseudoVWSUB_VX_MF8_MASK + { 7, &RISCVDescs.OperandInfo[6400] }, // Inst #11145 = PseudoVWSUB_VX_MF8 + { 8, &RISCVDescs.OperandInfo[6407] }, // Inst #11144 = PseudoVWSUB_VX_MF4_MASK + { 7, &RISCVDescs.OperandInfo[6400] }, // Inst #11143 = PseudoVWSUB_VX_MF4 + { 8, &RISCVDescs.OperandInfo[6407] }, // Inst #11142 = PseudoVWSUB_VX_MF2_MASK + { 7, &RISCVDescs.OperandInfo[6400] }, // Inst #11141 = PseudoVWSUB_VX_MF2 + { 8, &RISCVDescs.OperandInfo[7659] }, // Inst #11140 = PseudoVWSUB_VX_M4_MASK + { 7, &RISCVDescs.OperandInfo[7652] }, // Inst #11139 = PseudoVWSUB_VX_M4 + { 8, &RISCVDescs.OperandInfo[7644] }, // Inst #11138 = PseudoVWSUB_VX_M2_MASK + { 7, &RISCVDescs.OperandInfo[7637] }, // Inst #11137 = PseudoVWSUB_VX_M2 + { 8, &RISCVDescs.OperandInfo[7629] }, // Inst #11136 = PseudoVWSUB_VX_M1_MASK + { 7, &RISCVDescs.OperandInfo[7622] }, // Inst #11135 = PseudoVWSUB_VX_M1 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #11134 = PseudoVWSUB_VV_MF8_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #11133 = PseudoVWSUB_VV_MF8 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #11132 = PseudoVWSUB_VV_MF4_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #11131 = PseudoVWSUB_VV_MF4 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #11130 = PseudoVWSUB_VV_MF2_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #11129 = PseudoVWSUB_VV_MF2 + { 8, &RISCVDescs.OperandInfo[7614] }, // Inst #11128 = PseudoVWSUB_VV_M4_MASK + { 7, &RISCVDescs.OperandInfo[7607] }, // Inst #11127 = PseudoVWSUB_VV_M4 + { 8, &RISCVDescs.OperandInfo[7599] }, // Inst #11126 = PseudoVWSUB_VV_M2_MASK + { 7, &RISCVDescs.OperandInfo[7592] }, // Inst #11125 = PseudoVWSUB_VV_M2 + { 8, &RISCVDescs.OperandInfo[7584] }, // Inst #11124 = PseudoVWSUB_VV_M1_MASK + { 7, &RISCVDescs.OperandInfo[7577] }, // Inst #11123 = PseudoVWSUB_VV_M1 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #11122 = PseudoVWSUBU_WX_MF8_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #11121 = PseudoVWSUBU_WX_MF8 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #11120 = PseudoVWSUBU_WX_MF4_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #11119 = PseudoVWSUBU_WX_MF4 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #11118 = PseudoVWSUBU_WX_MF2_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #11117 = PseudoVWSUBU_WX_MF2 + { 8, &RISCVDescs.OperandInfo[809] }, // Inst #11116 = PseudoVWSUBU_WX_M4_MASK + { 7, &RISCVDescs.OperandInfo[802] }, // Inst #11115 = PseudoVWSUBU_WX_M4 + { 8, &RISCVDescs.OperandInfo[794] }, // Inst #11114 = PseudoVWSUBU_WX_M2_MASK + { 7, &RISCVDescs.OperandInfo[787] }, // Inst #11113 = PseudoVWSUBU_WX_M2 + { 8, &RISCVDescs.OperandInfo[779] }, // Inst #11112 = PseudoVWSUBU_WX_M1_MASK + { 7, &RISCVDescs.OperandInfo[772] }, // Inst #11111 = PseudoVWSUBU_WX_M1 + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #11110 = PseudoVWSUBU_WV_MF8_TIED + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #11109 = PseudoVWSUBU_WV_MF8_MASK_TIED + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #11108 = PseudoVWSUBU_WV_MF8_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #11107 = PseudoVWSUBU_WV_MF8 + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #11106 = PseudoVWSUBU_WV_MF4_TIED + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #11105 = PseudoVWSUBU_WV_MF4_MASK_TIED + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #11104 = PseudoVWSUBU_WV_MF4_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #11103 = PseudoVWSUBU_WV_MF4 + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #11102 = PseudoVWSUBU_WV_MF2_TIED + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #11101 = PseudoVWSUBU_WV_MF2_MASK_TIED + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #11100 = PseudoVWSUBU_WV_MF2_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #11099 = PseudoVWSUBU_WV_MF2 + { 6, &RISCVDescs.OperandInfo[3547] }, // Inst #11098 = PseudoVWSUBU_WV_M4_TIED + { 7, &RISCVDescs.OperandInfo[3553] }, // Inst #11097 = PseudoVWSUBU_WV_M4_MASK_TIED + { 8, &RISCVDescs.OperandInfo[6332] }, // Inst #11096 = PseudoVWSUBU_WV_M4_MASK + { 7, &RISCVDescs.OperandInfo[6325] }, // Inst #11095 = PseudoVWSUBU_WV_M4 + { 6, &RISCVDescs.OperandInfo[3534] }, // Inst #11094 = PseudoVWSUBU_WV_M2_TIED + { 7, &RISCVDescs.OperandInfo[3540] }, // Inst #11093 = PseudoVWSUBU_WV_M2_MASK_TIED + { 8, &RISCVDescs.OperandInfo[6287] }, // Inst #11092 = PseudoVWSUBU_WV_M2_MASK + { 7, &RISCVDescs.OperandInfo[6280] }, // Inst #11091 = PseudoVWSUBU_WV_M2 + { 6, &RISCVDescs.OperandInfo[3521] }, // Inst #11090 = PseudoVWSUBU_WV_M1_TIED + { 7, &RISCVDescs.OperandInfo[3527] }, // Inst #11089 = PseudoVWSUBU_WV_M1_MASK_TIED + { 8, &RISCVDescs.OperandInfo[6242] }, // Inst #11088 = PseudoVWSUBU_WV_M1_MASK + { 7, &RISCVDescs.OperandInfo[6235] }, // Inst #11087 = PseudoVWSUBU_WV_M1 + { 8, &RISCVDescs.OperandInfo[6407] }, // Inst #11086 = PseudoVWSUBU_VX_MF8_MASK + { 7, &RISCVDescs.OperandInfo[6400] }, // Inst #11085 = PseudoVWSUBU_VX_MF8 + { 8, &RISCVDescs.OperandInfo[6407] }, // Inst #11084 = PseudoVWSUBU_VX_MF4_MASK + { 7, &RISCVDescs.OperandInfo[6400] }, // Inst #11083 = PseudoVWSUBU_VX_MF4 + { 8, &RISCVDescs.OperandInfo[6407] }, // Inst #11082 = PseudoVWSUBU_VX_MF2_MASK + { 7, &RISCVDescs.OperandInfo[6400] }, // Inst #11081 = PseudoVWSUBU_VX_MF2 + { 8, &RISCVDescs.OperandInfo[7659] }, // Inst #11080 = PseudoVWSUBU_VX_M4_MASK + { 7, &RISCVDescs.OperandInfo[7652] }, // Inst #11079 = PseudoVWSUBU_VX_M4 + { 8, &RISCVDescs.OperandInfo[7644] }, // Inst #11078 = PseudoVWSUBU_VX_M2_MASK + { 7, &RISCVDescs.OperandInfo[7637] }, // Inst #11077 = PseudoVWSUBU_VX_M2 + { 8, &RISCVDescs.OperandInfo[7629] }, // Inst #11076 = PseudoVWSUBU_VX_M1_MASK + { 7, &RISCVDescs.OperandInfo[7622] }, // Inst #11075 = PseudoVWSUBU_VX_M1 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #11074 = PseudoVWSUBU_VV_MF8_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #11073 = PseudoVWSUBU_VV_MF8 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #11072 = PseudoVWSUBU_VV_MF4_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #11071 = PseudoVWSUBU_VV_MF4 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #11070 = PseudoVWSUBU_VV_MF2_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #11069 = PseudoVWSUBU_VV_MF2 + { 8, &RISCVDescs.OperandInfo[7614] }, // Inst #11068 = PseudoVWSUBU_VV_M4_MASK + { 7, &RISCVDescs.OperandInfo[7607] }, // Inst #11067 = PseudoVWSUBU_VV_M4 + { 8, &RISCVDescs.OperandInfo[7599] }, // Inst #11066 = PseudoVWSUBU_VV_M2_MASK + { 7, &RISCVDescs.OperandInfo[7592] }, // Inst #11065 = PseudoVWSUBU_VV_M2 + { 8, &RISCVDescs.OperandInfo[7584] }, // Inst #11064 = PseudoVWSUBU_VV_M1_MASK + { 7, &RISCVDescs.OperandInfo[7577] }, // Inst #11063 = PseudoVWSUBU_VV_M1 + { 8, &RISCVDescs.OperandInfo[6407] }, // Inst #11062 = PseudoVWSLL_VX_MF8_MASK + { 7, &RISCVDescs.OperandInfo[6400] }, // Inst #11061 = PseudoVWSLL_VX_MF8 + { 8, &RISCVDescs.OperandInfo[6407] }, // Inst #11060 = PseudoVWSLL_VX_MF4_MASK + { 7, &RISCVDescs.OperandInfo[6400] }, // Inst #11059 = PseudoVWSLL_VX_MF4 + { 8, &RISCVDescs.OperandInfo[6407] }, // Inst #11058 = PseudoVWSLL_VX_MF2_MASK + { 7, &RISCVDescs.OperandInfo[6400] }, // Inst #11057 = PseudoVWSLL_VX_MF2 + { 8, &RISCVDescs.OperandInfo[7659] }, // Inst #11056 = PseudoVWSLL_VX_M4_MASK + { 7, &RISCVDescs.OperandInfo[7652] }, // Inst #11055 = PseudoVWSLL_VX_M4 + { 8, &RISCVDescs.OperandInfo[7644] }, // Inst #11054 = PseudoVWSLL_VX_M2_MASK + { 7, &RISCVDescs.OperandInfo[7637] }, // Inst #11053 = PseudoVWSLL_VX_M2 + { 8, &RISCVDescs.OperandInfo[7629] }, // Inst #11052 = PseudoVWSLL_VX_M1_MASK + { 7, &RISCVDescs.OperandInfo[7622] }, // Inst #11051 = PseudoVWSLL_VX_M1 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #11050 = PseudoVWSLL_VV_MF8_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #11049 = PseudoVWSLL_VV_MF8 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #11048 = PseudoVWSLL_VV_MF4_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #11047 = PseudoVWSLL_VV_MF4 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #11046 = PseudoVWSLL_VV_MF2_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #11045 = PseudoVWSLL_VV_MF2 + { 8, &RISCVDescs.OperandInfo[7614] }, // Inst #11044 = PseudoVWSLL_VV_M4_MASK + { 7, &RISCVDescs.OperandInfo[7607] }, // Inst #11043 = PseudoVWSLL_VV_M4 + { 8, &RISCVDescs.OperandInfo[7599] }, // Inst #11042 = PseudoVWSLL_VV_M2_MASK + { 7, &RISCVDescs.OperandInfo[7592] }, // Inst #11041 = PseudoVWSLL_VV_M2 + { 8, &RISCVDescs.OperandInfo[7584] }, // Inst #11040 = PseudoVWSLL_VV_M1_MASK + { 7, &RISCVDescs.OperandInfo[7577] }, // Inst #11039 = PseudoVWSLL_VV_M1 + { 8, &RISCVDescs.OperandInfo[6347] }, // Inst #11038 = PseudoVWSLL_VI_MF8_MASK + { 7, &RISCVDescs.OperandInfo[6340] }, // Inst #11037 = PseudoVWSLL_VI_MF8 + { 8, &RISCVDescs.OperandInfo[6347] }, // Inst #11036 = PseudoVWSLL_VI_MF4_MASK + { 7, &RISCVDescs.OperandInfo[6340] }, // Inst #11035 = PseudoVWSLL_VI_MF4 + { 8, &RISCVDescs.OperandInfo[6347] }, // Inst #11034 = PseudoVWSLL_VI_MF2_MASK + { 7, &RISCVDescs.OperandInfo[6340] }, // Inst #11033 = PseudoVWSLL_VI_MF2 + { 8, &RISCVDescs.OperandInfo[7749] }, // Inst #11032 = PseudoVWSLL_VI_M4_MASK + { 7, &RISCVDescs.OperandInfo[7742] }, // Inst #11031 = PseudoVWSLL_VI_M4 + { 8, &RISCVDescs.OperandInfo[7734] }, // Inst #11030 = PseudoVWSLL_VI_M2_MASK + { 7, &RISCVDescs.OperandInfo[7727] }, // Inst #11029 = PseudoVWSLL_VI_M2 + { 8, &RISCVDescs.OperandInfo[7719] }, // Inst #11028 = PseudoVWSLL_VI_M1_MASK + { 7, &RISCVDescs.OperandInfo[7712] }, // Inst #11027 = PseudoVWSLL_VI_M1 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #11026 = PseudoVWREDSUM_VS_MF8_E8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #11025 = PseudoVWREDSUM_VS_MF8_E8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #11024 = PseudoVWREDSUM_VS_MF4_E8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #11023 = PseudoVWREDSUM_VS_MF4_E8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #11022 = PseudoVWREDSUM_VS_MF4_E16_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #11021 = PseudoVWREDSUM_VS_MF4_E16 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #11020 = PseudoVWREDSUM_VS_MF2_E8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #11019 = PseudoVWREDSUM_VS_MF2_E8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #11018 = PseudoVWREDSUM_VS_MF2_E32_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #11017 = PseudoVWREDSUM_VS_MF2_E32 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #11016 = PseudoVWREDSUM_VS_MF2_E16_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #11015 = PseudoVWREDSUM_VS_MF2_E16 + { 8, &RISCVDescs.OperandInfo[2999] }, // Inst #11014 = PseudoVWREDSUM_VS_M8_E8_MASK + { 7, &RISCVDescs.OperandInfo[2992] }, // Inst #11013 = PseudoVWREDSUM_VS_M8_E8 + { 8, &RISCVDescs.OperandInfo[2999] }, // Inst #11012 = PseudoVWREDSUM_VS_M8_E32_MASK + { 7, &RISCVDescs.OperandInfo[2992] }, // Inst #11011 = PseudoVWREDSUM_VS_M8_E32 + { 8, &RISCVDescs.OperandInfo[2999] }, // Inst #11010 = PseudoVWREDSUM_VS_M8_E16_MASK + { 7, &RISCVDescs.OperandInfo[2992] }, // Inst #11009 = PseudoVWREDSUM_VS_M8_E16 + { 8, &RISCVDescs.OperandInfo[2984] }, // Inst #11008 = PseudoVWREDSUM_VS_M4_E8_MASK + { 7, &RISCVDescs.OperandInfo[2977] }, // Inst #11007 = PseudoVWREDSUM_VS_M4_E8 + { 8, &RISCVDescs.OperandInfo[2984] }, // Inst #11006 = PseudoVWREDSUM_VS_M4_E32_MASK + { 7, &RISCVDescs.OperandInfo[2977] }, // Inst #11005 = PseudoVWREDSUM_VS_M4_E32 + { 8, &RISCVDescs.OperandInfo[2984] }, // Inst #11004 = PseudoVWREDSUM_VS_M4_E16_MASK + { 7, &RISCVDescs.OperandInfo[2977] }, // Inst #11003 = PseudoVWREDSUM_VS_M4_E16 + { 8, &RISCVDescs.OperandInfo[2969] }, // Inst #11002 = PseudoVWREDSUM_VS_M2_E8_MASK + { 7, &RISCVDescs.OperandInfo[2962] }, // Inst #11001 = PseudoVWREDSUM_VS_M2_E8 + { 8, &RISCVDescs.OperandInfo[2969] }, // Inst #11000 = PseudoVWREDSUM_VS_M2_E32_MASK + { 7, &RISCVDescs.OperandInfo[2962] }, // Inst #10999 = PseudoVWREDSUM_VS_M2_E32 + { 8, &RISCVDescs.OperandInfo[2969] }, // Inst #10998 = PseudoVWREDSUM_VS_M2_E16_MASK + { 7, &RISCVDescs.OperandInfo[2962] }, // Inst #10997 = PseudoVWREDSUM_VS_M2_E16 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #10996 = PseudoVWREDSUM_VS_M1_E8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #10995 = PseudoVWREDSUM_VS_M1_E8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #10994 = PseudoVWREDSUM_VS_M1_E32_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #10993 = PseudoVWREDSUM_VS_M1_E32 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #10992 = PseudoVWREDSUM_VS_M1_E16_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #10991 = PseudoVWREDSUM_VS_M1_E16 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #10990 = PseudoVWREDSUMU_VS_MF8_E8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #10989 = PseudoVWREDSUMU_VS_MF8_E8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #10988 = PseudoVWREDSUMU_VS_MF4_E8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #10987 = PseudoVWREDSUMU_VS_MF4_E8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #10986 = PseudoVWREDSUMU_VS_MF4_E16_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #10985 = PseudoVWREDSUMU_VS_MF4_E16 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #10984 = PseudoVWREDSUMU_VS_MF2_E8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #10983 = PseudoVWREDSUMU_VS_MF2_E8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #10982 = PseudoVWREDSUMU_VS_MF2_E32_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #10981 = PseudoVWREDSUMU_VS_MF2_E32 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #10980 = PseudoVWREDSUMU_VS_MF2_E16_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #10979 = PseudoVWREDSUMU_VS_MF2_E16 + { 8, &RISCVDescs.OperandInfo[2999] }, // Inst #10978 = PseudoVWREDSUMU_VS_M8_E8_MASK + { 7, &RISCVDescs.OperandInfo[2992] }, // Inst #10977 = PseudoVWREDSUMU_VS_M8_E8 + { 8, &RISCVDescs.OperandInfo[2999] }, // Inst #10976 = PseudoVWREDSUMU_VS_M8_E32_MASK + { 7, &RISCVDescs.OperandInfo[2992] }, // Inst #10975 = PseudoVWREDSUMU_VS_M8_E32 + { 8, &RISCVDescs.OperandInfo[2999] }, // Inst #10974 = PseudoVWREDSUMU_VS_M8_E16_MASK + { 7, &RISCVDescs.OperandInfo[2992] }, // Inst #10973 = PseudoVWREDSUMU_VS_M8_E16 + { 8, &RISCVDescs.OperandInfo[2984] }, // Inst #10972 = PseudoVWREDSUMU_VS_M4_E8_MASK + { 7, &RISCVDescs.OperandInfo[2977] }, // Inst #10971 = PseudoVWREDSUMU_VS_M4_E8 + { 8, &RISCVDescs.OperandInfo[2984] }, // Inst #10970 = PseudoVWREDSUMU_VS_M4_E32_MASK + { 7, &RISCVDescs.OperandInfo[2977] }, // Inst #10969 = PseudoVWREDSUMU_VS_M4_E32 + { 8, &RISCVDescs.OperandInfo[2984] }, // Inst #10968 = PseudoVWREDSUMU_VS_M4_E16_MASK + { 7, &RISCVDescs.OperandInfo[2977] }, // Inst #10967 = PseudoVWREDSUMU_VS_M4_E16 + { 8, &RISCVDescs.OperandInfo[2969] }, // Inst #10966 = PseudoVWREDSUMU_VS_M2_E8_MASK + { 7, &RISCVDescs.OperandInfo[2962] }, // Inst #10965 = PseudoVWREDSUMU_VS_M2_E8 + { 8, &RISCVDescs.OperandInfo[2969] }, // Inst #10964 = PseudoVWREDSUMU_VS_M2_E32_MASK + { 7, &RISCVDescs.OperandInfo[2962] }, // Inst #10963 = PseudoVWREDSUMU_VS_M2_E32 + { 8, &RISCVDescs.OperandInfo[2969] }, // Inst #10962 = PseudoVWREDSUMU_VS_M2_E16_MASK + { 7, &RISCVDescs.OperandInfo[2962] }, // Inst #10961 = PseudoVWREDSUMU_VS_M2_E16 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #10960 = PseudoVWREDSUMU_VS_M1_E8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #10959 = PseudoVWREDSUMU_VS_M1_E8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #10958 = PseudoVWREDSUMU_VS_M1_E32_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #10957 = PseudoVWREDSUMU_VS_M1_E32 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #10956 = PseudoVWREDSUMU_VS_M1_E16_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #10955 = PseudoVWREDSUMU_VS_M1_E16 + { 8, &RISCVDescs.OperandInfo[6407] }, // Inst #10954 = PseudoVWMUL_VX_MF8_MASK + { 7, &RISCVDescs.OperandInfo[6400] }, // Inst #10953 = PseudoVWMUL_VX_MF8 + { 8, &RISCVDescs.OperandInfo[6407] }, // Inst #10952 = PseudoVWMUL_VX_MF4_MASK + { 7, &RISCVDescs.OperandInfo[6400] }, // Inst #10951 = PseudoVWMUL_VX_MF4 + { 8, &RISCVDescs.OperandInfo[6407] }, // Inst #10950 = PseudoVWMUL_VX_MF2_MASK + { 7, &RISCVDescs.OperandInfo[6400] }, // Inst #10949 = PseudoVWMUL_VX_MF2 + { 8, &RISCVDescs.OperandInfo[7659] }, // Inst #10948 = PseudoVWMUL_VX_M4_MASK + { 7, &RISCVDescs.OperandInfo[7652] }, // Inst #10947 = PseudoVWMUL_VX_M4 + { 8, &RISCVDescs.OperandInfo[7644] }, // Inst #10946 = PseudoVWMUL_VX_M2_MASK + { 7, &RISCVDescs.OperandInfo[7637] }, // Inst #10945 = PseudoVWMUL_VX_M2 + { 8, &RISCVDescs.OperandInfo[7629] }, // Inst #10944 = PseudoVWMUL_VX_M1_MASK + { 7, &RISCVDescs.OperandInfo[7622] }, // Inst #10943 = PseudoVWMUL_VX_M1 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #10942 = PseudoVWMUL_VV_MF8_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #10941 = PseudoVWMUL_VV_MF8 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #10940 = PseudoVWMUL_VV_MF4_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #10939 = PseudoVWMUL_VV_MF4 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #10938 = PseudoVWMUL_VV_MF2_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #10937 = PseudoVWMUL_VV_MF2 + { 8, &RISCVDescs.OperandInfo[7614] }, // Inst #10936 = PseudoVWMUL_VV_M4_MASK + { 7, &RISCVDescs.OperandInfo[7607] }, // Inst #10935 = PseudoVWMUL_VV_M4 + { 8, &RISCVDescs.OperandInfo[7599] }, // Inst #10934 = PseudoVWMUL_VV_M2_MASK + { 7, &RISCVDescs.OperandInfo[7592] }, // Inst #10933 = PseudoVWMUL_VV_M2 + { 8, &RISCVDescs.OperandInfo[7584] }, // Inst #10932 = PseudoVWMUL_VV_M1_MASK + { 7, &RISCVDescs.OperandInfo[7577] }, // Inst #10931 = PseudoVWMUL_VV_M1 + { 8, &RISCVDescs.OperandInfo[6407] }, // Inst #10930 = PseudoVWMULU_VX_MF8_MASK + { 7, &RISCVDescs.OperandInfo[6400] }, // Inst #10929 = PseudoVWMULU_VX_MF8 + { 8, &RISCVDescs.OperandInfo[6407] }, // Inst #10928 = PseudoVWMULU_VX_MF4_MASK + { 7, &RISCVDescs.OperandInfo[6400] }, // Inst #10927 = PseudoVWMULU_VX_MF4 + { 8, &RISCVDescs.OperandInfo[6407] }, // Inst #10926 = PseudoVWMULU_VX_MF2_MASK + { 7, &RISCVDescs.OperandInfo[6400] }, // Inst #10925 = PseudoVWMULU_VX_MF2 + { 8, &RISCVDescs.OperandInfo[7659] }, // Inst #10924 = PseudoVWMULU_VX_M4_MASK + { 7, &RISCVDescs.OperandInfo[7652] }, // Inst #10923 = PseudoVWMULU_VX_M4 + { 8, &RISCVDescs.OperandInfo[7644] }, // Inst #10922 = PseudoVWMULU_VX_M2_MASK + { 7, &RISCVDescs.OperandInfo[7637] }, // Inst #10921 = PseudoVWMULU_VX_M2 + { 8, &RISCVDescs.OperandInfo[7629] }, // Inst #10920 = PseudoVWMULU_VX_M1_MASK + { 7, &RISCVDescs.OperandInfo[7622] }, // Inst #10919 = PseudoVWMULU_VX_M1 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #10918 = PseudoVWMULU_VV_MF8_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #10917 = PseudoVWMULU_VV_MF8 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #10916 = PseudoVWMULU_VV_MF4_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #10915 = PseudoVWMULU_VV_MF4 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #10914 = PseudoVWMULU_VV_MF2_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #10913 = PseudoVWMULU_VV_MF2 + { 8, &RISCVDescs.OperandInfo[7614] }, // Inst #10912 = PseudoVWMULU_VV_M4_MASK + { 7, &RISCVDescs.OperandInfo[7607] }, // Inst #10911 = PseudoVWMULU_VV_M4 + { 8, &RISCVDescs.OperandInfo[7599] }, // Inst #10910 = PseudoVWMULU_VV_M2_MASK + { 7, &RISCVDescs.OperandInfo[7592] }, // Inst #10909 = PseudoVWMULU_VV_M2 + { 8, &RISCVDescs.OperandInfo[7584] }, // Inst #10908 = PseudoVWMULU_VV_M1_MASK + { 7, &RISCVDescs.OperandInfo[7577] }, // Inst #10907 = PseudoVWMULU_VV_M1 + { 8, &RISCVDescs.OperandInfo[6407] }, // Inst #10906 = PseudoVWMULSU_VX_MF8_MASK + { 7, &RISCVDescs.OperandInfo[6400] }, // Inst #10905 = PseudoVWMULSU_VX_MF8 + { 8, &RISCVDescs.OperandInfo[6407] }, // Inst #10904 = PseudoVWMULSU_VX_MF4_MASK + { 7, &RISCVDescs.OperandInfo[6400] }, // Inst #10903 = PseudoVWMULSU_VX_MF4 + { 8, &RISCVDescs.OperandInfo[6407] }, // Inst #10902 = PseudoVWMULSU_VX_MF2_MASK + { 7, &RISCVDescs.OperandInfo[6400] }, // Inst #10901 = PseudoVWMULSU_VX_MF2 + { 8, &RISCVDescs.OperandInfo[7659] }, // Inst #10900 = PseudoVWMULSU_VX_M4_MASK + { 7, &RISCVDescs.OperandInfo[7652] }, // Inst #10899 = PseudoVWMULSU_VX_M4 + { 8, &RISCVDescs.OperandInfo[7644] }, // Inst #10898 = PseudoVWMULSU_VX_M2_MASK + { 7, &RISCVDescs.OperandInfo[7637] }, // Inst #10897 = PseudoVWMULSU_VX_M2 + { 8, &RISCVDescs.OperandInfo[7629] }, // Inst #10896 = PseudoVWMULSU_VX_M1_MASK + { 7, &RISCVDescs.OperandInfo[7622] }, // Inst #10895 = PseudoVWMULSU_VX_M1 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #10894 = PseudoVWMULSU_VV_MF8_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #10893 = PseudoVWMULSU_VV_MF8 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #10892 = PseudoVWMULSU_VV_MF4_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #10891 = PseudoVWMULSU_VV_MF4 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #10890 = PseudoVWMULSU_VV_MF2_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #10889 = PseudoVWMULSU_VV_MF2 + { 8, &RISCVDescs.OperandInfo[7614] }, // Inst #10888 = PseudoVWMULSU_VV_M4_MASK + { 7, &RISCVDescs.OperandInfo[7607] }, // Inst #10887 = PseudoVWMULSU_VV_M4 + { 8, &RISCVDescs.OperandInfo[7599] }, // Inst #10886 = PseudoVWMULSU_VV_M2_MASK + { 7, &RISCVDescs.OperandInfo[7592] }, // Inst #10885 = PseudoVWMULSU_VV_M2 + { 8, &RISCVDescs.OperandInfo[7584] }, // Inst #10884 = PseudoVWMULSU_VV_M1_MASK + { 7, &RISCVDescs.OperandInfo[7577] }, // Inst #10883 = PseudoVWMULSU_VV_M1 + { 8, &RISCVDescs.OperandInfo[360] }, // Inst #10882 = PseudoVWMACC_VX_MF8_MASK + { 7, &RISCVDescs.OperandInfo[353] }, // Inst #10881 = PseudoVWMACC_VX_MF8 + { 8, &RISCVDescs.OperandInfo[360] }, // Inst #10880 = PseudoVWMACC_VX_MF4_MASK + { 7, &RISCVDescs.OperandInfo[353] }, // Inst #10879 = PseudoVWMACC_VX_MF4 + { 8, &RISCVDescs.OperandInfo[360] }, // Inst #10878 = PseudoVWMACC_VX_MF2_MASK + { 7, &RISCVDescs.OperandInfo[353] }, // Inst #10877 = PseudoVWMACC_VX_MF2 + { 8, &RISCVDescs.OperandInfo[7704] }, // Inst #10876 = PseudoVWMACC_VX_M4_MASK + { 7, &RISCVDescs.OperandInfo[7697] }, // Inst #10875 = PseudoVWMACC_VX_M4 + { 8, &RISCVDescs.OperandInfo[7689] }, // Inst #10874 = PseudoVWMACC_VX_M2_MASK + { 7, &RISCVDescs.OperandInfo[7682] }, // Inst #10873 = PseudoVWMACC_VX_M2 + { 8, &RISCVDescs.OperandInfo[7674] }, // Inst #10872 = PseudoVWMACC_VX_M1_MASK + { 7, &RISCVDescs.OperandInfo[7667] }, // Inst #10871 = PseudoVWMACC_VX_M1 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #10870 = PseudoVWMACC_VV_MF8_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #10869 = PseudoVWMACC_VV_MF8 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #10868 = PseudoVWMACC_VV_MF4_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #10867 = PseudoVWMACC_VV_MF4 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #10866 = PseudoVWMACC_VV_MF2_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #10865 = PseudoVWMACC_VV_MF2 + { 8, &RISCVDescs.OperandInfo[7614] }, // Inst #10864 = PseudoVWMACC_VV_M4_MASK + { 7, &RISCVDescs.OperandInfo[7607] }, // Inst #10863 = PseudoVWMACC_VV_M4 + { 8, &RISCVDescs.OperandInfo[7599] }, // Inst #10862 = PseudoVWMACC_VV_M2_MASK + { 7, &RISCVDescs.OperandInfo[7592] }, // Inst #10861 = PseudoVWMACC_VV_M2 + { 8, &RISCVDescs.OperandInfo[7584] }, // Inst #10860 = PseudoVWMACC_VV_M1_MASK + { 7, &RISCVDescs.OperandInfo[7577] }, // Inst #10859 = PseudoVWMACC_VV_M1 + { 8, &RISCVDescs.OperandInfo[360] }, // Inst #10858 = PseudoVWMACCU_VX_MF8_MASK + { 7, &RISCVDescs.OperandInfo[353] }, // Inst #10857 = PseudoVWMACCU_VX_MF8 + { 8, &RISCVDescs.OperandInfo[360] }, // Inst #10856 = PseudoVWMACCU_VX_MF4_MASK + { 7, &RISCVDescs.OperandInfo[353] }, // Inst #10855 = PseudoVWMACCU_VX_MF4 + { 8, &RISCVDescs.OperandInfo[360] }, // Inst #10854 = PseudoVWMACCU_VX_MF2_MASK + { 7, &RISCVDescs.OperandInfo[353] }, // Inst #10853 = PseudoVWMACCU_VX_MF2 + { 8, &RISCVDescs.OperandInfo[7704] }, // Inst #10852 = PseudoVWMACCU_VX_M4_MASK + { 7, &RISCVDescs.OperandInfo[7697] }, // Inst #10851 = PseudoVWMACCU_VX_M4 + { 8, &RISCVDescs.OperandInfo[7689] }, // Inst #10850 = PseudoVWMACCU_VX_M2_MASK + { 7, &RISCVDescs.OperandInfo[7682] }, // Inst #10849 = PseudoVWMACCU_VX_M2 + { 8, &RISCVDescs.OperandInfo[7674] }, // Inst #10848 = PseudoVWMACCU_VX_M1_MASK + { 7, &RISCVDescs.OperandInfo[7667] }, // Inst #10847 = PseudoVWMACCU_VX_M1 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #10846 = PseudoVWMACCU_VV_MF8_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #10845 = PseudoVWMACCU_VV_MF8 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #10844 = PseudoVWMACCU_VV_MF4_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #10843 = PseudoVWMACCU_VV_MF4 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #10842 = PseudoVWMACCU_VV_MF2_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #10841 = PseudoVWMACCU_VV_MF2 + { 8, &RISCVDescs.OperandInfo[7614] }, // Inst #10840 = PseudoVWMACCU_VV_M4_MASK + { 7, &RISCVDescs.OperandInfo[7607] }, // Inst #10839 = PseudoVWMACCU_VV_M4 + { 8, &RISCVDescs.OperandInfo[7599] }, // Inst #10838 = PseudoVWMACCU_VV_M2_MASK + { 7, &RISCVDescs.OperandInfo[7592] }, // Inst #10837 = PseudoVWMACCU_VV_M2 + { 8, &RISCVDescs.OperandInfo[7584] }, // Inst #10836 = PseudoVWMACCU_VV_M1_MASK + { 7, &RISCVDescs.OperandInfo[7577] }, // Inst #10835 = PseudoVWMACCU_VV_M1 + { 8, &RISCVDescs.OperandInfo[360] }, // Inst #10834 = PseudoVWMACCUS_VX_MF8_MASK + { 7, &RISCVDescs.OperandInfo[353] }, // Inst #10833 = PseudoVWMACCUS_VX_MF8 + { 8, &RISCVDescs.OperandInfo[360] }, // Inst #10832 = PseudoVWMACCUS_VX_MF4_MASK + { 7, &RISCVDescs.OperandInfo[353] }, // Inst #10831 = PseudoVWMACCUS_VX_MF4 + { 8, &RISCVDescs.OperandInfo[360] }, // Inst #10830 = PseudoVWMACCUS_VX_MF2_MASK + { 7, &RISCVDescs.OperandInfo[353] }, // Inst #10829 = PseudoVWMACCUS_VX_MF2 + { 8, &RISCVDescs.OperandInfo[7704] }, // Inst #10828 = PseudoVWMACCUS_VX_M4_MASK + { 7, &RISCVDescs.OperandInfo[7697] }, // Inst #10827 = PseudoVWMACCUS_VX_M4 + { 8, &RISCVDescs.OperandInfo[7689] }, // Inst #10826 = PseudoVWMACCUS_VX_M2_MASK + { 7, &RISCVDescs.OperandInfo[7682] }, // Inst #10825 = PseudoVWMACCUS_VX_M2 + { 8, &RISCVDescs.OperandInfo[7674] }, // Inst #10824 = PseudoVWMACCUS_VX_M1_MASK + { 7, &RISCVDescs.OperandInfo[7667] }, // Inst #10823 = PseudoVWMACCUS_VX_M1 + { 8, &RISCVDescs.OperandInfo[360] }, // Inst #10822 = PseudoVWMACCSU_VX_MF8_MASK + { 7, &RISCVDescs.OperandInfo[353] }, // Inst #10821 = PseudoVWMACCSU_VX_MF8 + { 8, &RISCVDescs.OperandInfo[360] }, // Inst #10820 = PseudoVWMACCSU_VX_MF4_MASK + { 7, &RISCVDescs.OperandInfo[353] }, // Inst #10819 = PseudoVWMACCSU_VX_MF4 + { 8, &RISCVDescs.OperandInfo[360] }, // Inst #10818 = PseudoVWMACCSU_VX_MF2_MASK + { 7, &RISCVDescs.OperandInfo[353] }, // Inst #10817 = PseudoVWMACCSU_VX_MF2 + { 8, &RISCVDescs.OperandInfo[7704] }, // Inst #10816 = PseudoVWMACCSU_VX_M4_MASK + { 7, &RISCVDescs.OperandInfo[7697] }, // Inst #10815 = PseudoVWMACCSU_VX_M4 + { 8, &RISCVDescs.OperandInfo[7689] }, // Inst #10814 = PseudoVWMACCSU_VX_M2_MASK + { 7, &RISCVDescs.OperandInfo[7682] }, // Inst #10813 = PseudoVWMACCSU_VX_M2 + { 8, &RISCVDescs.OperandInfo[7674] }, // Inst #10812 = PseudoVWMACCSU_VX_M1_MASK + { 7, &RISCVDescs.OperandInfo[7667] }, // Inst #10811 = PseudoVWMACCSU_VX_M1 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #10810 = PseudoVWMACCSU_VV_MF8_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #10809 = PseudoVWMACCSU_VV_MF8 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #10808 = PseudoVWMACCSU_VV_MF4_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #10807 = PseudoVWMACCSU_VV_MF4 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #10806 = PseudoVWMACCSU_VV_MF2_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #10805 = PseudoVWMACCSU_VV_MF2 + { 8, &RISCVDescs.OperandInfo[7614] }, // Inst #10804 = PseudoVWMACCSU_VV_M4_MASK + { 7, &RISCVDescs.OperandInfo[7607] }, // Inst #10803 = PseudoVWMACCSU_VV_M4 + { 8, &RISCVDescs.OperandInfo[7599] }, // Inst #10802 = PseudoVWMACCSU_VV_M2_MASK + { 7, &RISCVDescs.OperandInfo[7592] }, // Inst #10801 = PseudoVWMACCSU_VV_M2 + { 8, &RISCVDescs.OperandInfo[7584] }, // Inst #10800 = PseudoVWMACCSU_VV_M1_MASK + { 7, &RISCVDescs.OperandInfo[7577] }, // Inst #10799 = PseudoVWMACCSU_VV_M1 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #10798 = PseudoVWADD_WX_MF8_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #10797 = PseudoVWADD_WX_MF8 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #10796 = PseudoVWADD_WX_MF4_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #10795 = PseudoVWADD_WX_MF4 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #10794 = PseudoVWADD_WX_MF2_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #10793 = PseudoVWADD_WX_MF2 + { 8, &RISCVDescs.OperandInfo[809] }, // Inst #10792 = PseudoVWADD_WX_M4_MASK + { 7, &RISCVDescs.OperandInfo[802] }, // Inst #10791 = PseudoVWADD_WX_M4 + { 8, &RISCVDescs.OperandInfo[794] }, // Inst #10790 = PseudoVWADD_WX_M2_MASK + { 7, &RISCVDescs.OperandInfo[787] }, // Inst #10789 = PseudoVWADD_WX_M2 + { 8, &RISCVDescs.OperandInfo[779] }, // Inst #10788 = PseudoVWADD_WX_M1_MASK + { 7, &RISCVDescs.OperandInfo[772] }, // Inst #10787 = PseudoVWADD_WX_M1 + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #10786 = PseudoVWADD_WV_MF8_TIED + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #10785 = PseudoVWADD_WV_MF8_MASK_TIED + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #10784 = PseudoVWADD_WV_MF8_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #10783 = PseudoVWADD_WV_MF8 + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #10782 = PseudoVWADD_WV_MF4_TIED + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #10781 = PseudoVWADD_WV_MF4_MASK_TIED + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #10780 = PseudoVWADD_WV_MF4_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #10779 = PseudoVWADD_WV_MF4 + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #10778 = PseudoVWADD_WV_MF2_TIED + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #10777 = PseudoVWADD_WV_MF2_MASK_TIED + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #10776 = PseudoVWADD_WV_MF2_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #10775 = PseudoVWADD_WV_MF2 + { 6, &RISCVDescs.OperandInfo[3547] }, // Inst #10774 = PseudoVWADD_WV_M4_TIED + { 7, &RISCVDescs.OperandInfo[3553] }, // Inst #10773 = PseudoVWADD_WV_M4_MASK_TIED + { 8, &RISCVDescs.OperandInfo[6332] }, // Inst #10772 = PseudoVWADD_WV_M4_MASK + { 7, &RISCVDescs.OperandInfo[6325] }, // Inst #10771 = PseudoVWADD_WV_M4 + { 6, &RISCVDescs.OperandInfo[3534] }, // Inst #10770 = PseudoVWADD_WV_M2_TIED + { 7, &RISCVDescs.OperandInfo[3540] }, // Inst #10769 = PseudoVWADD_WV_M2_MASK_TIED + { 8, &RISCVDescs.OperandInfo[6287] }, // Inst #10768 = PseudoVWADD_WV_M2_MASK + { 7, &RISCVDescs.OperandInfo[6280] }, // Inst #10767 = PseudoVWADD_WV_M2 + { 6, &RISCVDescs.OperandInfo[3521] }, // Inst #10766 = PseudoVWADD_WV_M1_TIED + { 7, &RISCVDescs.OperandInfo[3527] }, // Inst #10765 = PseudoVWADD_WV_M1_MASK_TIED + { 8, &RISCVDescs.OperandInfo[6242] }, // Inst #10764 = PseudoVWADD_WV_M1_MASK + { 7, &RISCVDescs.OperandInfo[6235] }, // Inst #10763 = PseudoVWADD_WV_M1 + { 8, &RISCVDescs.OperandInfo[6407] }, // Inst #10762 = PseudoVWADD_VX_MF8_MASK + { 7, &RISCVDescs.OperandInfo[6400] }, // Inst #10761 = PseudoVWADD_VX_MF8 + { 8, &RISCVDescs.OperandInfo[6407] }, // Inst #10760 = PseudoVWADD_VX_MF4_MASK + { 7, &RISCVDescs.OperandInfo[6400] }, // Inst #10759 = PseudoVWADD_VX_MF4 + { 8, &RISCVDescs.OperandInfo[6407] }, // Inst #10758 = PseudoVWADD_VX_MF2_MASK + { 7, &RISCVDescs.OperandInfo[6400] }, // Inst #10757 = PseudoVWADD_VX_MF2 + { 8, &RISCVDescs.OperandInfo[7659] }, // Inst #10756 = PseudoVWADD_VX_M4_MASK + { 7, &RISCVDescs.OperandInfo[7652] }, // Inst #10755 = PseudoVWADD_VX_M4 + { 8, &RISCVDescs.OperandInfo[7644] }, // Inst #10754 = PseudoVWADD_VX_M2_MASK + { 7, &RISCVDescs.OperandInfo[7637] }, // Inst #10753 = PseudoVWADD_VX_M2 + { 8, &RISCVDescs.OperandInfo[7629] }, // Inst #10752 = PseudoVWADD_VX_M1_MASK + { 7, &RISCVDescs.OperandInfo[7622] }, // Inst #10751 = PseudoVWADD_VX_M1 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #10750 = PseudoVWADD_VV_MF8_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #10749 = PseudoVWADD_VV_MF8 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #10748 = PseudoVWADD_VV_MF4_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #10747 = PseudoVWADD_VV_MF4 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #10746 = PseudoVWADD_VV_MF2_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #10745 = PseudoVWADD_VV_MF2 + { 8, &RISCVDescs.OperandInfo[7614] }, // Inst #10744 = PseudoVWADD_VV_M4_MASK + { 7, &RISCVDescs.OperandInfo[7607] }, // Inst #10743 = PseudoVWADD_VV_M4 + { 8, &RISCVDescs.OperandInfo[7599] }, // Inst #10742 = PseudoVWADD_VV_M2_MASK + { 7, &RISCVDescs.OperandInfo[7592] }, // Inst #10741 = PseudoVWADD_VV_M2 + { 8, &RISCVDescs.OperandInfo[7584] }, // Inst #10740 = PseudoVWADD_VV_M1_MASK + { 7, &RISCVDescs.OperandInfo[7577] }, // Inst #10739 = PseudoVWADD_VV_M1 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #10738 = PseudoVWADDU_WX_MF8_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #10737 = PseudoVWADDU_WX_MF8 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #10736 = PseudoVWADDU_WX_MF4_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #10735 = PseudoVWADDU_WX_MF4 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #10734 = PseudoVWADDU_WX_MF2_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #10733 = PseudoVWADDU_WX_MF2 + { 8, &RISCVDescs.OperandInfo[809] }, // Inst #10732 = PseudoVWADDU_WX_M4_MASK + { 7, &RISCVDescs.OperandInfo[802] }, // Inst #10731 = PseudoVWADDU_WX_M4 + { 8, &RISCVDescs.OperandInfo[794] }, // Inst #10730 = PseudoVWADDU_WX_M2_MASK + { 7, &RISCVDescs.OperandInfo[787] }, // Inst #10729 = PseudoVWADDU_WX_M2 + { 8, &RISCVDescs.OperandInfo[779] }, // Inst #10728 = PseudoVWADDU_WX_M1_MASK + { 7, &RISCVDescs.OperandInfo[772] }, // Inst #10727 = PseudoVWADDU_WX_M1 + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #10726 = PseudoVWADDU_WV_MF8_TIED + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #10725 = PseudoVWADDU_WV_MF8_MASK_TIED + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #10724 = PseudoVWADDU_WV_MF8_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #10723 = PseudoVWADDU_WV_MF8 + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #10722 = PseudoVWADDU_WV_MF4_TIED + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #10721 = PseudoVWADDU_WV_MF4_MASK_TIED + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #10720 = PseudoVWADDU_WV_MF4_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #10719 = PseudoVWADDU_WV_MF4 + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #10718 = PseudoVWADDU_WV_MF2_TIED + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #10717 = PseudoVWADDU_WV_MF2_MASK_TIED + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #10716 = PseudoVWADDU_WV_MF2_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #10715 = PseudoVWADDU_WV_MF2 + { 6, &RISCVDescs.OperandInfo[3547] }, // Inst #10714 = PseudoVWADDU_WV_M4_TIED + { 7, &RISCVDescs.OperandInfo[3553] }, // Inst #10713 = PseudoVWADDU_WV_M4_MASK_TIED + { 8, &RISCVDescs.OperandInfo[6332] }, // Inst #10712 = PseudoVWADDU_WV_M4_MASK + { 7, &RISCVDescs.OperandInfo[6325] }, // Inst #10711 = PseudoVWADDU_WV_M4 + { 6, &RISCVDescs.OperandInfo[3534] }, // Inst #10710 = PseudoVWADDU_WV_M2_TIED + { 7, &RISCVDescs.OperandInfo[3540] }, // Inst #10709 = PseudoVWADDU_WV_M2_MASK_TIED + { 8, &RISCVDescs.OperandInfo[6287] }, // Inst #10708 = PseudoVWADDU_WV_M2_MASK + { 7, &RISCVDescs.OperandInfo[6280] }, // Inst #10707 = PseudoVWADDU_WV_M2 + { 6, &RISCVDescs.OperandInfo[3521] }, // Inst #10706 = PseudoVWADDU_WV_M1_TIED + { 7, &RISCVDescs.OperandInfo[3527] }, // Inst #10705 = PseudoVWADDU_WV_M1_MASK_TIED + { 8, &RISCVDescs.OperandInfo[6242] }, // Inst #10704 = PseudoVWADDU_WV_M1_MASK + { 7, &RISCVDescs.OperandInfo[6235] }, // Inst #10703 = PseudoVWADDU_WV_M1 + { 8, &RISCVDescs.OperandInfo[6407] }, // Inst #10702 = PseudoVWADDU_VX_MF8_MASK + { 7, &RISCVDescs.OperandInfo[6400] }, // Inst #10701 = PseudoVWADDU_VX_MF8 + { 8, &RISCVDescs.OperandInfo[6407] }, // Inst #10700 = PseudoVWADDU_VX_MF4_MASK + { 7, &RISCVDescs.OperandInfo[6400] }, // Inst #10699 = PseudoVWADDU_VX_MF4 + { 8, &RISCVDescs.OperandInfo[6407] }, // Inst #10698 = PseudoVWADDU_VX_MF2_MASK + { 7, &RISCVDescs.OperandInfo[6400] }, // Inst #10697 = PseudoVWADDU_VX_MF2 + { 8, &RISCVDescs.OperandInfo[7659] }, // Inst #10696 = PseudoVWADDU_VX_M4_MASK + { 7, &RISCVDescs.OperandInfo[7652] }, // Inst #10695 = PseudoVWADDU_VX_M4 + { 8, &RISCVDescs.OperandInfo[7644] }, // Inst #10694 = PseudoVWADDU_VX_M2_MASK + { 7, &RISCVDescs.OperandInfo[7637] }, // Inst #10693 = PseudoVWADDU_VX_M2 + { 8, &RISCVDescs.OperandInfo[7629] }, // Inst #10692 = PseudoVWADDU_VX_M1_MASK + { 7, &RISCVDescs.OperandInfo[7622] }, // Inst #10691 = PseudoVWADDU_VX_M1 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #10690 = PseudoVWADDU_VV_MF8_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #10689 = PseudoVWADDU_VV_MF8 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #10688 = PseudoVWADDU_VV_MF4_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #10687 = PseudoVWADDU_VV_MF4 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #10686 = PseudoVWADDU_VV_MF2_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #10685 = PseudoVWADDU_VV_MF2 + { 8, &RISCVDescs.OperandInfo[7614] }, // Inst #10684 = PseudoVWADDU_VV_M4_MASK + { 7, &RISCVDescs.OperandInfo[7607] }, // Inst #10683 = PseudoVWADDU_VV_M4 + { 8, &RISCVDescs.OperandInfo[7599] }, // Inst #10682 = PseudoVWADDU_VV_M2_MASK + { 7, &RISCVDescs.OperandInfo[7592] }, // Inst #10681 = PseudoVWADDU_VV_M2 + { 8, &RISCVDescs.OperandInfo[7584] }, // Inst #10680 = PseudoVWADDU_VV_M1_MASK + { 7, &RISCVDescs.OperandInfo[7577] }, // Inst #10679 = PseudoVWADDU_VV_M1 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #10678 = PseudoVSUXSEG8EI8_V_MF8_MF8_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #10677 = PseudoVSUXSEG8EI8_V_MF8_MF8 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #10676 = PseudoVSUXSEG8EI8_V_MF8_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #10675 = PseudoVSUXSEG8EI8_V_MF8_MF4 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #10674 = PseudoVSUXSEG8EI8_V_MF8_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #10673 = PseudoVSUXSEG8EI8_V_MF8_MF2 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #10672 = PseudoVSUXSEG8EI8_V_MF8_M1_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #10671 = PseudoVSUXSEG8EI8_V_MF8_M1 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #10670 = PseudoVSUXSEG8EI8_V_MF4_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #10669 = PseudoVSUXSEG8EI8_V_MF4_MF4 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #10668 = PseudoVSUXSEG8EI8_V_MF4_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #10667 = PseudoVSUXSEG8EI8_V_MF4_MF2 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #10666 = PseudoVSUXSEG8EI8_V_MF4_M1_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #10665 = PseudoVSUXSEG8EI8_V_MF4_M1 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #10664 = PseudoVSUXSEG8EI8_V_MF2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #10663 = PseudoVSUXSEG8EI8_V_MF2_MF2 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #10662 = PseudoVSUXSEG8EI8_V_MF2_M1_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #10661 = PseudoVSUXSEG8EI8_V_MF2_M1 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #10660 = PseudoVSUXSEG8EI8_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #10659 = PseudoVSUXSEG8EI8_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[7256] }, // Inst #10658 = PseudoVSUXSEG8EI64_V_M8_M1_MASK + { 5, &RISCVDescs.OperandInfo[7251] }, // Inst #10657 = PseudoVSUXSEG8EI64_V_M8_M1 + { 6, &RISCVDescs.OperandInfo[7245] }, // Inst #10656 = PseudoVSUXSEG8EI64_V_M4_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7240] }, // Inst #10655 = PseudoVSUXSEG8EI64_V_M4_MF2 + { 6, &RISCVDescs.OperandInfo[7245] }, // Inst #10654 = PseudoVSUXSEG8EI64_V_M4_M1_MASK + { 5, &RISCVDescs.OperandInfo[7240] }, // Inst #10653 = PseudoVSUXSEG8EI64_V_M4_M1 + { 6, &RISCVDescs.OperandInfo[7234] }, // Inst #10652 = PseudoVSUXSEG8EI64_V_M2_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7229] }, // Inst #10651 = PseudoVSUXSEG8EI64_V_M2_MF4 + { 6, &RISCVDescs.OperandInfo[7234] }, // Inst #10650 = PseudoVSUXSEG8EI64_V_M2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7229] }, // Inst #10649 = PseudoVSUXSEG8EI64_V_M2_MF2 + { 6, &RISCVDescs.OperandInfo[7234] }, // Inst #10648 = PseudoVSUXSEG8EI64_V_M2_M1_MASK + { 5, &RISCVDescs.OperandInfo[7229] }, // Inst #10647 = PseudoVSUXSEG8EI64_V_M2_M1 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #10646 = PseudoVSUXSEG8EI64_V_M1_MF8_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #10645 = PseudoVSUXSEG8EI64_V_M1_MF8 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #10644 = PseudoVSUXSEG8EI64_V_M1_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #10643 = PseudoVSUXSEG8EI64_V_M1_MF4 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #10642 = PseudoVSUXSEG8EI64_V_M1_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #10641 = PseudoVSUXSEG8EI64_V_M1_MF2 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #10640 = PseudoVSUXSEG8EI64_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #10639 = PseudoVSUXSEG8EI64_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #10638 = PseudoVSUXSEG8EI32_V_MF2_MF8_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #10637 = PseudoVSUXSEG8EI32_V_MF2_MF8 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #10636 = PseudoVSUXSEG8EI32_V_MF2_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #10635 = PseudoVSUXSEG8EI32_V_MF2_MF4 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #10634 = PseudoVSUXSEG8EI32_V_MF2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #10633 = PseudoVSUXSEG8EI32_V_MF2_MF2 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #10632 = PseudoVSUXSEG8EI32_V_MF2_M1_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #10631 = PseudoVSUXSEG8EI32_V_MF2_M1 + { 6, &RISCVDescs.OperandInfo[7245] }, // Inst #10630 = PseudoVSUXSEG8EI32_V_M4_M1_MASK + { 5, &RISCVDescs.OperandInfo[7240] }, // Inst #10629 = PseudoVSUXSEG8EI32_V_M4_M1 + { 6, &RISCVDescs.OperandInfo[7234] }, // Inst #10628 = PseudoVSUXSEG8EI32_V_M2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7229] }, // Inst #10627 = PseudoVSUXSEG8EI32_V_M2_MF2 + { 6, &RISCVDescs.OperandInfo[7234] }, // Inst #10626 = PseudoVSUXSEG8EI32_V_M2_M1_MASK + { 5, &RISCVDescs.OperandInfo[7229] }, // Inst #10625 = PseudoVSUXSEG8EI32_V_M2_M1 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #10624 = PseudoVSUXSEG8EI32_V_M1_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #10623 = PseudoVSUXSEG8EI32_V_M1_MF4 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #10622 = PseudoVSUXSEG8EI32_V_M1_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #10621 = PseudoVSUXSEG8EI32_V_M1_MF2 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #10620 = PseudoVSUXSEG8EI32_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #10619 = PseudoVSUXSEG8EI32_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #10618 = PseudoVSUXSEG8EI16_V_MF4_MF8_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #10617 = PseudoVSUXSEG8EI16_V_MF4_MF8 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #10616 = PseudoVSUXSEG8EI16_V_MF4_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #10615 = PseudoVSUXSEG8EI16_V_MF4_MF4 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #10614 = PseudoVSUXSEG8EI16_V_MF4_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #10613 = PseudoVSUXSEG8EI16_V_MF4_MF2 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #10612 = PseudoVSUXSEG8EI16_V_MF4_M1_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #10611 = PseudoVSUXSEG8EI16_V_MF4_M1 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #10610 = PseudoVSUXSEG8EI16_V_MF2_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #10609 = PseudoVSUXSEG8EI16_V_MF2_MF4 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #10608 = PseudoVSUXSEG8EI16_V_MF2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #10607 = PseudoVSUXSEG8EI16_V_MF2_MF2 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #10606 = PseudoVSUXSEG8EI16_V_MF2_M1_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #10605 = PseudoVSUXSEG8EI16_V_MF2_M1 + { 6, &RISCVDescs.OperandInfo[7234] }, // Inst #10604 = PseudoVSUXSEG8EI16_V_M2_M1_MASK + { 5, &RISCVDescs.OperandInfo[7229] }, // Inst #10603 = PseudoVSUXSEG8EI16_V_M2_M1 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #10602 = PseudoVSUXSEG8EI16_V_M1_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #10601 = PseudoVSUXSEG8EI16_V_M1_MF2 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #10600 = PseudoVSUXSEG8EI16_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #10599 = PseudoVSUXSEG8EI16_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #10598 = PseudoVSUXSEG7EI8_V_MF8_MF8_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #10597 = PseudoVSUXSEG7EI8_V_MF8_MF8 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #10596 = PseudoVSUXSEG7EI8_V_MF8_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #10595 = PseudoVSUXSEG7EI8_V_MF8_MF4 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #10594 = PseudoVSUXSEG7EI8_V_MF8_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #10593 = PseudoVSUXSEG7EI8_V_MF8_MF2 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #10592 = PseudoVSUXSEG7EI8_V_MF8_M1_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #10591 = PseudoVSUXSEG7EI8_V_MF8_M1 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #10590 = PseudoVSUXSEG7EI8_V_MF4_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #10589 = PseudoVSUXSEG7EI8_V_MF4_MF4 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #10588 = PseudoVSUXSEG7EI8_V_MF4_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #10587 = PseudoVSUXSEG7EI8_V_MF4_MF2 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #10586 = PseudoVSUXSEG7EI8_V_MF4_M1_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #10585 = PseudoVSUXSEG7EI8_V_MF4_M1 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #10584 = PseudoVSUXSEG7EI8_V_MF2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #10583 = PseudoVSUXSEG7EI8_V_MF2_MF2 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #10582 = PseudoVSUXSEG7EI8_V_MF2_M1_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #10581 = PseudoVSUXSEG7EI8_V_MF2_M1 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #10580 = PseudoVSUXSEG7EI8_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #10579 = PseudoVSUXSEG7EI8_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[7212] }, // Inst #10578 = PseudoVSUXSEG7EI64_V_M8_M1_MASK + { 5, &RISCVDescs.OperandInfo[7207] }, // Inst #10577 = PseudoVSUXSEG7EI64_V_M8_M1 + { 6, &RISCVDescs.OperandInfo[7201] }, // Inst #10576 = PseudoVSUXSEG7EI64_V_M4_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7196] }, // Inst #10575 = PseudoVSUXSEG7EI64_V_M4_MF2 + { 6, &RISCVDescs.OperandInfo[7201] }, // Inst #10574 = PseudoVSUXSEG7EI64_V_M4_M1_MASK + { 5, &RISCVDescs.OperandInfo[7196] }, // Inst #10573 = PseudoVSUXSEG7EI64_V_M4_M1 + { 6, &RISCVDescs.OperandInfo[7190] }, // Inst #10572 = PseudoVSUXSEG7EI64_V_M2_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7185] }, // Inst #10571 = PseudoVSUXSEG7EI64_V_M2_MF4 + { 6, &RISCVDescs.OperandInfo[7190] }, // Inst #10570 = PseudoVSUXSEG7EI64_V_M2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7185] }, // Inst #10569 = PseudoVSUXSEG7EI64_V_M2_MF2 + { 6, &RISCVDescs.OperandInfo[7190] }, // Inst #10568 = PseudoVSUXSEG7EI64_V_M2_M1_MASK + { 5, &RISCVDescs.OperandInfo[7185] }, // Inst #10567 = PseudoVSUXSEG7EI64_V_M2_M1 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #10566 = PseudoVSUXSEG7EI64_V_M1_MF8_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #10565 = PseudoVSUXSEG7EI64_V_M1_MF8 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #10564 = PseudoVSUXSEG7EI64_V_M1_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #10563 = PseudoVSUXSEG7EI64_V_M1_MF4 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #10562 = PseudoVSUXSEG7EI64_V_M1_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #10561 = PseudoVSUXSEG7EI64_V_M1_MF2 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #10560 = PseudoVSUXSEG7EI64_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #10559 = PseudoVSUXSEG7EI64_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #10558 = PseudoVSUXSEG7EI32_V_MF2_MF8_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #10557 = PseudoVSUXSEG7EI32_V_MF2_MF8 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #10556 = PseudoVSUXSEG7EI32_V_MF2_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #10555 = PseudoVSUXSEG7EI32_V_MF2_MF4 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #10554 = PseudoVSUXSEG7EI32_V_MF2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #10553 = PseudoVSUXSEG7EI32_V_MF2_MF2 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #10552 = PseudoVSUXSEG7EI32_V_MF2_M1_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #10551 = PseudoVSUXSEG7EI32_V_MF2_M1 + { 6, &RISCVDescs.OperandInfo[7201] }, // Inst #10550 = PseudoVSUXSEG7EI32_V_M4_M1_MASK + { 5, &RISCVDescs.OperandInfo[7196] }, // Inst #10549 = PseudoVSUXSEG7EI32_V_M4_M1 + { 6, &RISCVDescs.OperandInfo[7190] }, // Inst #10548 = PseudoVSUXSEG7EI32_V_M2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7185] }, // Inst #10547 = PseudoVSUXSEG7EI32_V_M2_MF2 + { 6, &RISCVDescs.OperandInfo[7190] }, // Inst #10546 = PseudoVSUXSEG7EI32_V_M2_M1_MASK + { 5, &RISCVDescs.OperandInfo[7185] }, // Inst #10545 = PseudoVSUXSEG7EI32_V_M2_M1 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #10544 = PseudoVSUXSEG7EI32_V_M1_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #10543 = PseudoVSUXSEG7EI32_V_M1_MF4 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #10542 = PseudoVSUXSEG7EI32_V_M1_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #10541 = PseudoVSUXSEG7EI32_V_M1_MF2 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #10540 = PseudoVSUXSEG7EI32_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #10539 = PseudoVSUXSEG7EI32_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #10538 = PseudoVSUXSEG7EI16_V_MF4_MF8_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #10537 = PseudoVSUXSEG7EI16_V_MF4_MF8 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #10536 = PseudoVSUXSEG7EI16_V_MF4_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #10535 = PseudoVSUXSEG7EI16_V_MF4_MF4 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #10534 = PseudoVSUXSEG7EI16_V_MF4_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #10533 = PseudoVSUXSEG7EI16_V_MF4_MF2 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #10532 = PseudoVSUXSEG7EI16_V_MF4_M1_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #10531 = PseudoVSUXSEG7EI16_V_MF4_M1 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #10530 = PseudoVSUXSEG7EI16_V_MF2_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #10529 = PseudoVSUXSEG7EI16_V_MF2_MF4 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #10528 = PseudoVSUXSEG7EI16_V_MF2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #10527 = PseudoVSUXSEG7EI16_V_MF2_MF2 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #10526 = PseudoVSUXSEG7EI16_V_MF2_M1_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #10525 = PseudoVSUXSEG7EI16_V_MF2_M1 + { 6, &RISCVDescs.OperandInfo[7190] }, // Inst #10524 = PseudoVSUXSEG7EI16_V_M2_M1_MASK + { 5, &RISCVDescs.OperandInfo[7185] }, // Inst #10523 = PseudoVSUXSEG7EI16_V_M2_M1 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #10522 = PseudoVSUXSEG7EI16_V_M1_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #10521 = PseudoVSUXSEG7EI16_V_M1_MF2 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #10520 = PseudoVSUXSEG7EI16_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #10519 = PseudoVSUXSEG7EI16_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #10518 = PseudoVSUXSEG6EI8_V_MF8_MF8_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #10517 = PseudoVSUXSEG6EI8_V_MF8_MF8 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #10516 = PseudoVSUXSEG6EI8_V_MF8_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #10515 = PseudoVSUXSEG6EI8_V_MF8_MF4 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #10514 = PseudoVSUXSEG6EI8_V_MF8_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #10513 = PseudoVSUXSEG6EI8_V_MF8_MF2 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #10512 = PseudoVSUXSEG6EI8_V_MF8_M1_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #10511 = PseudoVSUXSEG6EI8_V_MF8_M1 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #10510 = PseudoVSUXSEG6EI8_V_MF4_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #10509 = PseudoVSUXSEG6EI8_V_MF4_MF4 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #10508 = PseudoVSUXSEG6EI8_V_MF4_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #10507 = PseudoVSUXSEG6EI8_V_MF4_MF2 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #10506 = PseudoVSUXSEG6EI8_V_MF4_M1_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #10505 = PseudoVSUXSEG6EI8_V_MF4_M1 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #10504 = PseudoVSUXSEG6EI8_V_MF2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #10503 = PseudoVSUXSEG6EI8_V_MF2_MF2 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #10502 = PseudoVSUXSEG6EI8_V_MF2_M1_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #10501 = PseudoVSUXSEG6EI8_V_MF2_M1 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #10500 = PseudoVSUXSEG6EI8_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #10499 = PseudoVSUXSEG6EI8_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[7168] }, // Inst #10498 = PseudoVSUXSEG6EI64_V_M8_M1_MASK + { 5, &RISCVDescs.OperandInfo[7163] }, // Inst #10497 = PseudoVSUXSEG6EI64_V_M8_M1 + { 6, &RISCVDescs.OperandInfo[7157] }, // Inst #10496 = PseudoVSUXSEG6EI64_V_M4_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7152] }, // Inst #10495 = PseudoVSUXSEG6EI64_V_M4_MF2 + { 6, &RISCVDescs.OperandInfo[7157] }, // Inst #10494 = PseudoVSUXSEG6EI64_V_M4_M1_MASK + { 5, &RISCVDescs.OperandInfo[7152] }, // Inst #10493 = PseudoVSUXSEG6EI64_V_M4_M1 + { 6, &RISCVDescs.OperandInfo[7146] }, // Inst #10492 = PseudoVSUXSEG6EI64_V_M2_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7141] }, // Inst #10491 = PseudoVSUXSEG6EI64_V_M2_MF4 + { 6, &RISCVDescs.OperandInfo[7146] }, // Inst #10490 = PseudoVSUXSEG6EI64_V_M2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7141] }, // Inst #10489 = PseudoVSUXSEG6EI64_V_M2_MF2 + { 6, &RISCVDescs.OperandInfo[7146] }, // Inst #10488 = PseudoVSUXSEG6EI64_V_M2_M1_MASK + { 5, &RISCVDescs.OperandInfo[7141] }, // Inst #10487 = PseudoVSUXSEG6EI64_V_M2_M1 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #10486 = PseudoVSUXSEG6EI64_V_M1_MF8_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #10485 = PseudoVSUXSEG6EI64_V_M1_MF8 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #10484 = PseudoVSUXSEG6EI64_V_M1_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #10483 = PseudoVSUXSEG6EI64_V_M1_MF4 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #10482 = PseudoVSUXSEG6EI64_V_M1_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #10481 = PseudoVSUXSEG6EI64_V_M1_MF2 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #10480 = PseudoVSUXSEG6EI64_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #10479 = PseudoVSUXSEG6EI64_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #10478 = PseudoVSUXSEG6EI32_V_MF2_MF8_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #10477 = PseudoVSUXSEG6EI32_V_MF2_MF8 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #10476 = PseudoVSUXSEG6EI32_V_MF2_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #10475 = PseudoVSUXSEG6EI32_V_MF2_MF4 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #10474 = PseudoVSUXSEG6EI32_V_MF2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #10473 = PseudoVSUXSEG6EI32_V_MF2_MF2 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #10472 = PseudoVSUXSEG6EI32_V_MF2_M1_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #10471 = PseudoVSUXSEG6EI32_V_MF2_M1 + { 6, &RISCVDescs.OperandInfo[7157] }, // Inst #10470 = PseudoVSUXSEG6EI32_V_M4_M1_MASK + { 5, &RISCVDescs.OperandInfo[7152] }, // Inst #10469 = PseudoVSUXSEG6EI32_V_M4_M1 + { 6, &RISCVDescs.OperandInfo[7146] }, // Inst #10468 = PseudoVSUXSEG6EI32_V_M2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7141] }, // Inst #10467 = PseudoVSUXSEG6EI32_V_M2_MF2 + { 6, &RISCVDescs.OperandInfo[7146] }, // Inst #10466 = PseudoVSUXSEG6EI32_V_M2_M1_MASK + { 5, &RISCVDescs.OperandInfo[7141] }, // Inst #10465 = PseudoVSUXSEG6EI32_V_M2_M1 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #10464 = PseudoVSUXSEG6EI32_V_M1_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #10463 = PseudoVSUXSEG6EI32_V_M1_MF4 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #10462 = PseudoVSUXSEG6EI32_V_M1_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #10461 = PseudoVSUXSEG6EI32_V_M1_MF2 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #10460 = PseudoVSUXSEG6EI32_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #10459 = PseudoVSUXSEG6EI32_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #10458 = PseudoVSUXSEG6EI16_V_MF4_MF8_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #10457 = PseudoVSUXSEG6EI16_V_MF4_MF8 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #10456 = PseudoVSUXSEG6EI16_V_MF4_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #10455 = PseudoVSUXSEG6EI16_V_MF4_MF4 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #10454 = PseudoVSUXSEG6EI16_V_MF4_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #10453 = PseudoVSUXSEG6EI16_V_MF4_MF2 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #10452 = PseudoVSUXSEG6EI16_V_MF4_M1_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #10451 = PseudoVSUXSEG6EI16_V_MF4_M1 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #10450 = PseudoVSUXSEG6EI16_V_MF2_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #10449 = PseudoVSUXSEG6EI16_V_MF2_MF4 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #10448 = PseudoVSUXSEG6EI16_V_MF2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #10447 = PseudoVSUXSEG6EI16_V_MF2_MF2 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #10446 = PseudoVSUXSEG6EI16_V_MF2_M1_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #10445 = PseudoVSUXSEG6EI16_V_MF2_M1 + { 6, &RISCVDescs.OperandInfo[7146] }, // Inst #10444 = PseudoVSUXSEG6EI16_V_M2_M1_MASK + { 5, &RISCVDescs.OperandInfo[7141] }, // Inst #10443 = PseudoVSUXSEG6EI16_V_M2_M1 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #10442 = PseudoVSUXSEG6EI16_V_M1_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #10441 = PseudoVSUXSEG6EI16_V_M1_MF2 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #10440 = PseudoVSUXSEG6EI16_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #10439 = PseudoVSUXSEG6EI16_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #10438 = PseudoVSUXSEG5EI8_V_MF8_MF8_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #10437 = PseudoVSUXSEG5EI8_V_MF8_MF8 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #10436 = PseudoVSUXSEG5EI8_V_MF8_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #10435 = PseudoVSUXSEG5EI8_V_MF8_MF4 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #10434 = PseudoVSUXSEG5EI8_V_MF8_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #10433 = PseudoVSUXSEG5EI8_V_MF8_MF2 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #10432 = PseudoVSUXSEG5EI8_V_MF8_M1_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #10431 = PseudoVSUXSEG5EI8_V_MF8_M1 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #10430 = PseudoVSUXSEG5EI8_V_MF4_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #10429 = PseudoVSUXSEG5EI8_V_MF4_MF4 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #10428 = PseudoVSUXSEG5EI8_V_MF4_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #10427 = PseudoVSUXSEG5EI8_V_MF4_MF2 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #10426 = PseudoVSUXSEG5EI8_V_MF4_M1_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #10425 = PseudoVSUXSEG5EI8_V_MF4_M1 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #10424 = PseudoVSUXSEG5EI8_V_MF2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #10423 = PseudoVSUXSEG5EI8_V_MF2_MF2 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #10422 = PseudoVSUXSEG5EI8_V_MF2_M1_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #10421 = PseudoVSUXSEG5EI8_V_MF2_M1 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #10420 = PseudoVSUXSEG5EI8_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #10419 = PseudoVSUXSEG5EI8_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[7124] }, // Inst #10418 = PseudoVSUXSEG5EI64_V_M8_M1_MASK + { 5, &RISCVDescs.OperandInfo[7119] }, // Inst #10417 = PseudoVSUXSEG5EI64_V_M8_M1 + { 6, &RISCVDescs.OperandInfo[7113] }, // Inst #10416 = PseudoVSUXSEG5EI64_V_M4_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7108] }, // Inst #10415 = PseudoVSUXSEG5EI64_V_M4_MF2 + { 6, &RISCVDescs.OperandInfo[7113] }, // Inst #10414 = PseudoVSUXSEG5EI64_V_M4_M1_MASK + { 5, &RISCVDescs.OperandInfo[7108] }, // Inst #10413 = PseudoVSUXSEG5EI64_V_M4_M1 + { 6, &RISCVDescs.OperandInfo[7102] }, // Inst #10412 = PseudoVSUXSEG5EI64_V_M2_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7097] }, // Inst #10411 = PseudoVSUXSEG5EI64_V_M2_MF4 + { 6, &RISCVDescs.OperandInfo[7102] }, // Inst #10410 = PseudoVSUXSEG5EI64_V_M2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7097] }, // Inst #10409 = PseudoVSUXSEG5EI64_V_M2_MF2 + { 6, &RISCVDescs.OperandInfo[7102] }, // Inst #10408 = PseudoVSUXSEG5EI64_V_M2_M1_MASK + { 5, &RISCVDescs.OperandInfo[7097] }, // Inst #10407 = PseudoVSUXSEG5EI64_V_M2_M1 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #10406 = PseudoVSUXSEG5EI64_V_M1_MF8_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #10405 = PseudoVSUXSEG5EI64_V_M1_MF8 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #10404 = PseudoVSUXSEG5EI64_V_M1_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #10403 = PseudoVSUXSEG5EI64_V_M1_MF4 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #10402 = PseudoVSUXSEG5EI64_V_M1_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #10401 = PseudoVSUXSEG5EI64_V_M1_MF2 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #10400 = PseudoVSUXSEG5EI64_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #10399 = PseudoVSUXSEG5EI64_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #10398 = PseudoVSUXSEG5EI32_V_MF2_MF8_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #10397 = PseudoVSUXSEG5EI32_V_MF2_MF8 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #10396 = PseudoVSUXSEG5EI32_V_MF2_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #10395 = PseudoVSUXSEG5EI32_V_MF2_MF4 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #10394 = PseudoVSUXSEG5EI32_V_MF2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #10393 = PseudoVSUXSEG5EI32_V_MF2_MF2 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #10392 = PseudoVSUXSEG5EI32_V_MF2_M1_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #10391 = PseudoVSUXSEG5EI32_V_MF2_M1 + { 6, &RISCVDescs.OperandInfo[7113] }, // Inst #10390 = PseudoVSUXSEG5EI32_V_M4_M1_MASK + { 5, &RISCVDescs.OperandInfo[7108] }, // Inst #10389 = PseudoVSUXSEG5EI32_V_M4_M1 + { 6, &RISCVDescs.OperandInfo[7102] }, // Inst #10388 = PseudoVSUXSEG5EI32_V_M2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7097] }, // Inst #10387 = PseudoVSUXSEG5EI32_V_M2_MF2 + { 6, &RISCVDescs.OperandInfo[7102] }, // Inst #10386 = PseudoVSUXSEG5EI32_V_M2_M1_MASK + { 5, &RISCVDescs.OperandInfo[7097] }, // Inst #10385 = PseudoVSUXSEG5EI32_V_M2_M1 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #10384 = PseudoVSUXSEG5EI32_V_M1_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #10383 = PseudoVSUXSEG5EI32_V_M1_MF4 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #10382 = PseudoVSUXSEG5EI32_V_M1_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #10381 = PseudoVSUXSEG5EI32_V_M1_MF2 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #10380 = PseudoVSUXSEG5EI32_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #10379 = PseudoVSUXSEG5EI32_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #10378 = PseudoVSUXSEG5EI16_V_MF4_MF8_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #10377 = PseudoVSUXSEG5EI16_V_MF4_MF8 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #10376 = PseudoVSUXSEG5EI16_V_MF4_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #10375 = PseudoVSUXSEG5EI16_V_MF4_MF4 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #10374 = PseudoVSUXSEG5EI16_V_MF4_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #10373 = PseudoVSUXSEG5EI16_V_MF4_MF2 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #10372 = PseudoVSUXSEG5EI16_V_MF4_M1_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #10371 = PseudoVSUXSEG5EI16_V_MF4_M1 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #10370 = PseudoVSUXSEG5EI16_V_MF2_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #10369 = PseudoVSUXSEG5EI16_V_MF2_MF4 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #10368 = PseudoVSUXSEG5EI16_V_MF2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #10367 = PseudoVSUXSEG5EI16_V_MF2_MF2 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #10366 = PseudoVSUXSEG5EI16_V_MF2_M1_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #10365 = PseudoVSUXSEG5EI16_V_MF2_M1 + { 6, &RISCVDescs.OperandInfo[7102] }, // Inst #10364 = PseudoVSUXSEG5EI16_V_M2_M1_MASK + { 5, &RISCVDescs.OperandInfo[7097] }, // Inst #10363 = PseudoVSUXSEG5EI16_V_M2_M1 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #10362 = PseudoVSUXSEG5EI16_V_M1_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #10361 = PseudoVSUXSEG5EI16_V_M1_MF2 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #10360 = PseudoVSUXSEG5EI16_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #10359 = PseudoVSUXSEG5EI16_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #10358 = PseudoVSUXSEG4EI8_V_MF8_MF8_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #10357 = PseudoVSUXSEG4EI8_V_MF8_MF8 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #10356 = PseudoVSUXSEG4EI8_V_MF8_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #10355 = PseudoVSUXSEG4EI8_V_MF8_MF4 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #10354 = PseudoVSUXSEG4EI8_V_MF8_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #10353 = PseudoVSUXSEG4EI8_V_MF8_MF2 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #10352 = PseudoVSUXSEG4EI8_V_MF8_M1_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #10351 = PseudoVSUXSEG4EI8_V_MF8_M1 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #10350 = PseudoVSUXSEG4EI8_V_MF4_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #10349 = PseudoVSUXSEG4EI8_V_MF4_MF4 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #10348 = PseudoVSUXSEG4EI8_V_MF4_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #10347 = PseudoVSUXSEG4EI8_V_MF4_MF2 + { 6, &RISCVDescs.OperandInfo[7014] }, // Inst #10346 = PseudoVSUXSEG4EI8_V_MF4_M2_MASK + { 5, &RISCVDescs.OperandInfo[7009] }, // Inst #10345 = PseudoVSUXSEG4EI8_V_MF4_M2 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #10344 = PseudoVSUXSEG4EI8_V_MF4_M1_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #10343 = PseudoVSUXSEG4EI8_V_MF4_M1 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #10342 = PseudoVSUXSEG4EI8_V_MF2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #10341 = PseudoVSUXSEG4EI8_V_MF2_MF2 + { 6, &RISCVDescs.OperandInfo[7014] }, // Inst #10340 = PseudoVSUXSEG4EI8_V_MF2_M2_MASK + { 5, &RISCVDescs.OperandInfo[7009] }, // Inst #10339 = PseudoVSUXSEG4EI8_V_MF2_M2 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #10338 = PseudoVSUXSEG4EI8_V_MF2_M1_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #10337 = PseudoVSUXSEG4EI8_V_MF2_M1 + { 6, &RISCVDescs.OperandInfo[7036] }, // Inst #10336 = PseudoVSUXSEG4EI8_V_M2_M2_MASK + { 5, &RISCVDescs.OperandInfo[7031] }, // Inst #10335 = PseudoVSUXSEG4EI8_V_M2_M2 + { 6, &RISCVDescs.OperandInfo[7014] }, // Inst #10334 = PseudoVSUXSEG4EI8_V_M1_M2_MASK + { 5, &RISCVDescs.OperandInfo[7009] }, // Inst #10333 = PseudoVSUXSEG4EI8_V_M1_M2 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #10332 = PseudoVSUXSEG4EI8_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #10331 = PseudoVSUXSEG4EI8_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[7069] }, // Inst #10330 = PseudoVSUXSEG4EI64_V_M8_M2_MASK + { 5, &RISCVDescs.OperandInfo[7064] }, // Inst #10329 = PseudoVSUXSEG4EI64_V_M8_M2 + { 6, &RISCVDescs.OperandInfo[7080] }, // Inst #10328 = PseudoVSUXSEG4EI64_V_M8_M1_MASK + { 5, &RISCVDescs.OperandInfo[7075] }, // Inst #10327 = PseudoVSUXSEG4EI64_V_M8_M1 + { 6, &RISCVDescs.OperandInfo[7058] }, // Inst #10326 = PseudoVSUXSEG4EI64_V_M4_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7053] }, // Inst #10325 = PseudoVSUXSEG4EI64_V_M4_MF2 + { 6, &RISCVDescs.OperandInfo[7047] }, // Inst #10324 = PseudoVSUXSEG4EI64_V_M4_M2_MASK + { 5, &RISCVDescs.OperandInfo[7042] }, // Inst #10323 = PseudoVSUXSEG4EI64_V_M4_M2 + { 6, &RISCVDescs.OperandInfo[7058] }, // Inst #10322 = PseudoVSUXSEG4EI64_V_M4_M1_MASK + { 5, &RISCVDescs.OperandInfo[7053] }, // Inst #10321 = PseudoVSUXSEG4EI64_V_M4_M1 + { 6, &RISCVDescs.OperandInfo[7025] }, // Inst #10320 = PseudoVSUXSEG4EI64_V_M2_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7020] }, // Inst #10319 = PseudoVSUXSEG4EI64_V_M2_MF4 + { 6, &RISCVDescs.OperandInfo[7025] }, // Inst #10318 = PseudoVSUXSEG4EI64_V_M2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7020] }, // Inst #10317 = PseudoVSUXSEG4EI64_V_M2_MF2 + { 6, &RISCVDescs.OperandInfo[7036] }, // Inst #10316 = PseudoVSUXSEG4EI64_V_M2_M2_MASK + { 5, &RISCVDescs.OperandInfo[7031] }, // Inst #10315 = PseudoVSUXSEG4EI64_V_M2_M2 + { 6, &RISCVDescs.OperandInfo[7025] }, // Inst #10314 = PseudoVSUXSEG4EI64_V_M2_M1_MASK + { 5, &RISCVDescs.OperandInfo[7020] }, // Inst #10313 = PseudoVSUXSEG4EI64_V_M2_M1 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #10312 = PseudoVSUXSEG4EI64_V_M1_MF8_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #10311 = PseudoVSUXSEG4EI64_V_M1_MF8 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #10310 = PseudoVSUXSEG4EI64_V_M1_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #10309 = PseudoVSUXSEG4EI64_V_M1_MF4 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #10308 = PseudoVSUXSEG4EI64_V_M1_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #10307 = PseudoVSUXSEG4EI64_V_M1_MF2 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #10306 = PseudoVSUXSEG4EI64_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #10305 = PseudoVSUXSEG4EI64_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #10304 = PseudoVSUXSEG4EI32_V_MF2_MF8_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #10303 = PseudoVSUXSEG4EI32_V_MF2_MF8 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #10302 = PseudoVSUXSEG4EI32_V_MF2_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #10301 = PseudoVSUXSEG4EI32_V_MF2_MF4 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #10300 = PseudoVSUXSEG4EI32_V_MF2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #10299 = PseudoVSUXSEG4EI32_V_MF2_MF2 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #10298 = PseudoVSUXSEG4EI32_V_MF2_M1_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #10297 = PseudoVSUXSEG4EI32_V_MF2_M1 + { 6, &RISCVDescs.OperandInfo[7069] }, // Inst #10296 = PseudoVSUXSEG4EI32_V_M8_M2_MASK + { 5, &RISCVDescs.OperandInfo[7064] }, // Inst #10295 = PseudoVSUXSEG4EI32_V_M8_M2 + { 6, &RISCVDescs.OperandInfo[7047] }, // Inst #10294 = PseudoVSUXSEG4EI32_V_M4_M2_MASK + { 5, &RISCVDescs.OperandInfo[7042] }, // Inst #10293 = PseudoVSUXSEG4EI32_V_M4_M2 + { 6, &RISCVDescs.OperandInfo[7058] }, // Inst #10292 = PseudoVSUXSEG4EI32_V_M4_M1_MASK + { 5, &RISCVDescs.OperandInfo[7053] }, // Inst #10291 = PseudoVSUXSEG4EI32_V_M4_M1 + { 6, &RISCVDescs.OperandInfo[7025] }, // Inst #10290 = PseudoVSUXSEG4EI32_V_M2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7020] }, // Inst #10289 = PseudoVSUXSEG4EI32_V_M2_MF2 + { 6, &RISCVDescs.OperandInfo[7036] }, // Inst #10288 = PseudoVSUXSEG4EI32_V_M2_M2_MASK + { 5, &RISCVDescs.OperandInfo[7031] }, // Inst #10287 = PseudoVSUXSEG4EI32_V_M2_M2 + { 6, &RISCVDescs.OperandInfo[7025] }, // Inst #10286 = PseudoVSUXSEG4EI32_V_M2_M1_MASK + { 5, &RISCVDescs.OperandInfo[7020] }, // Inst #10285 = PseudoVSUXSEG4EI32_V_M2_M1 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #10284 = PseudoVSUXSEG4EI32_V_M1_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #10283 = PseudoVSUXSEG4EI32_V_M1_MF4 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #10282 = PseudoVSUXSEG4EI32_V_M1_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #10281 = PseudoVSUXSEG4EI32_V_M1_MF2 + { 6, &RISCVDescs.OperandInfo[7014] }, // Inst #10280 = PseudoVSUXSEG4EI32_V_M1_M2_MASK + { 5, &RISCVDescs.OperandInfo[7009] }, // Inst #10279 = PseudoVSUXSEG4EI32_V_M1_M2 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #10278 = PseudoVSUXSEG4EI32_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #10277 = PseudoVSUXSEG4EI32_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #10276 = PseudoVSUXSEG4EI16_V_MF4_MF8_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #10275 = PseudoVSUXSEG4EI16_V_MF4_MF8 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #10274 = PseudoVSUXSEG4EI16_V_MF4_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #10273 = PseudoVSUXSEG4EI16_V_MF4_MF4 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #10272 = PseudoVSUXSEG4EI16_V_MF4_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #10271 = PseudoVSUXSEG4EI16_V_MF4_MF2 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #10270 = PseudoVSUXSEG4EI16_V_MF4_M1_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #10269 = PseudoVSUXSEG4EI16_V_MF4_M1 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #10268 = PseudoVSUXSEG4EI16_V_MF2_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #10267 = PseudoVSUXSEG4EI16_V_MF2_MF4 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #10266 = PseudoVSUXSEG4EI16_V_MF2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #10265 = PseudoVSUXSEG4EI16_V_MF2_MF2 + { 6, &RISCVDescs.OperandInfo[7014] }, // Inst #10264 = PseudoVSUXSEG4EI16_V_MF2_M2_MASK + { 5, &RISCVDescs.OperandInfo[7009] }, // Inst #10263 = PseudoVSUXSEG4EI16_V_MF2_M2 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #10262 = PseudoVSUXSEG4EI16_V_MF2_M1_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #10261 = PseudoVSUXSEG4EI16_V_MF2_M1 + { 6, &RISCVDescs.OperandInfo[7047] }, // Inst #10260 = PseudoVSUXSEG4EI16_V_M4_M2_MASK + { 5, &RISCVDescs.OperandInfo[7042] }, // Inst #10259 = PseudoVSUXSEG4EI16_V_M4_M2 + { 6, &RISCVDescs.OperandInfo[7036] }, // Inst #10258 = PseudoVSUXSEG4EI16_V_M2_M2_MASK + { 5, &RISCVDescs.OperandInfo[7031] }, // Inst #10257 = PseudoVSUXSEG4EI16_V_M2_M2 + { 6, &RISCVDescs.OperandInfo[7025] }, // Inst #10256 = PseudoVSUXSEG4EI16_V_M2_M1_MASK + { 5, &RISCVDescs.OperandInfo[7020] }, // Inst #10255 = PseudoVSUXSEG4EI16_V_M2_M1 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #10254 = PseudoVSUXSEG4EI16_V_M1_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #10253 = PseudoVSUXSEG4EI16_V_M1_MF2 + { 6, &RISCVDescs.OperandInfo[7014] }, // Inst #10252 = PseudoVSUXSEG4EI16_V_M1_M2_MASK + { 5, &RISCVDescs.OperandInfo[7009] }, // Inst #10251 = PseudoVSUXSEG4EI16_V_M1_M2 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #10250 = PseudoVSUXSEG4EI16_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #10249 = PseudoVSUXSEG4EI16_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #10248 = PseudoVSUXSEG3EI8_V_MF8_MF8_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #10247 = PseudoVSUXSEG3EI8_V_MF8_MF8 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #10246 = PseudoVSUXSEG3EI8_V_MF8_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #10245 = PseudoVSUXSEG3EI8_V_MF8_MF4 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #10244 = PseudoVSUXSEG3EI8_V_MF8_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #10243 = PseudoVSUXSEG3EI8_V_MF8_MF2 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #10242 = PseudoVSUXSEG3EI8_V_MF8_M1_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #10241 = PseudoVSUXSEG3EI8_V_MF8_M1 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #10240 = PseudoVSUXSEG3EI8_V_MF4_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #10239 = PseudoVSUXSEG3EI8_V_MF4_MF4 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #10238 = PseudoVSUXSEG3EI8_V_MF4_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #10237 = PseudoVSUXSEG3EI8_V_MF4_MF2 + { 6, &RISCVDescs.OperandInfo[6926] }, // Inst #10236 = PseudoVSUXSEG3EI8_V_MF4_M2_MASK + { 5, &RISCVDescs.OperandInfo[6921] }, // Inst #10235 = PseudoVSUXSEG3EI8_V_MF4_M2 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #10234 = PseudoVSUXSEG3EI8_V_MF4_M1_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #10233 = PseudoVSUXSEG3EI8_V_MF4_M1 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #10232 = PseudoVSUXSEG3EI8_V_MF2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #10231 = PseudoVSUXSEG3EI8_V_MF2_MF2 + { 6, &RISCVDescs.OperandInfo[6926] }, // Inst #10230 = PseudoVSUXSEG3EI8_V_MF2_M2_MASK + { 5, &RISCVDescs.OperandInfo[6921] }, // Inst #10229 = PseudoVSUXSEG3EI8_V_MF2_M2 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #10228 = PseudoVSUXSEG3EI8_V_MF2_M1_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #10227 = PseudoVSUXSEG3EI8_V_MF2_M1 + { 6, &RISCVDescs.OperandInfo[6948] }, // Inst #10226 = PseudoVSUXSEG3EI8_V_M2_M2_MASK + { 5, &RISCVDescs.OperandInfo[6943] }, // Inst #10225 = PseudoVSUXSEG3EI8_V_M2_M2 + { 6, &RISCVDescs.OperandInfo[6926] }, // Inst #10224 = PseudoVSUXSEG3EI8_V_M1_M2_MASK + { 5, &RISCVDescs.OperandInfo[6921] }, // Inst #10223 = PseudoVSUXSEG3EI8_V_M1_M2 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #10222 = PseudoVSUXSEG3EI8_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #10221 = PseudoVSUXSEG3EI8_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[6981] }, // Inst #10220 = PseudoVSUXSEG3EI64_V_M8_M2_MASK + { 5, &RISCVDescs.OperandInfo[6976] }, // Inst #10219 = PseudoVSUXSEG3EI64_V_M8_M2 + { 6, &RISCVDescs.OperandInfo[6992] }, // Inst #10218 = PseudoVSUXSEG3EI64_V_M8_M1_MASK + { 5, &RISCVDescs.OperandInfo[6987] }, // Inst #10217 = PseudoVSUXSEG3EI64_V_M8_M1 + { 6, &RISCVDescs.OperandInfo[6970] }, // Inst #10216 = PseudoVSUXSEG3EI64_V_M4_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6965] }, // Inst #10215 = PseudoVSUXSEG3EI64_V_M4_MF2 + { 6, &RISCVDescs.OperandInfo[6959] }, // Inst #10214 = PseudoVSUXSEG3EI64_V_M4_M2_MASK + { 5, &RISCVDescs.OperandInfo[6954] }, // Inst #10213 = PseudoVSUXSEG3EI64_V_M4_M2 + { 6, &RISCVDescs.OperandInfo[6970] }, // Inst #10212 = PseudoVSUXSEG3EI64_V_M4_M1_MASK + { 5, &RISCVDescs.OperandInfo[6965] }, // Inst #10211 = PseudoVSUXSEG3EI64_V_M4_M1 + { 6, &RISCVDescs.OperandInfo[6937] }, // Inst #10210 = PseudoVSUXSEG3EI64_V_M2_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6932] }, // Inst #10209 = PseudoVSUXSEG3EI64_V_M2_MF4 + { 6, &RISCVDescs.OperandInfo[6937] }, // Inst #10208 = PseudoVSUXSEG3EI64_V_M2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6932] }, // Inst #10207 = PseudoVSUXSEG3EI64_V_M2_MF2 + { 6, &RISCVDescs.OperandInfo[6948] }, // Inst #10206 = PseudoVSUXSEG3EI64_V_M2_M2_MASK + { 5, &RISCVDescs.OperandInfo[6943] }, // Inst #10205 = PseudoVSUXSEG3EI64_V_M2_M2 + { 6, &RISCVDescs.OperandInfo[6937] }, // Inst #10204 = PseudoVSUXSEG3EI64_V_M2_M1_MASK + { 5, &RISCVDescs.OperandInfo[6932] }, // Inst #10203 = PseudoVSUXSEG3EI64_V_M2_M1 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #10202 = PseudoVSUXSEG3EI64_V_M1_MF8_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #10201 = PseudoVSUXSEG3EI64_V_M1_MF8 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #10200 = PseudoVSUXSEG3EI64_V_M1_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #10199 = PseudoVSUXSEG3EI64_V_M1_MF4 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #10198 = PseudoVSUXSEG3EI64_V_M1_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #10197 = PseudoVSUXSEG3EI64_V_M1_MF2 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #10196 = PseudoVSUXSEG3EI64_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #10195 = PseudoVSUXSEG3EI64_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #10194 = PseudoVSUXSEG3EI32_V_MF2_MF8_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #10193 = PseudoVSUXSEG3EI32_V_MF2_MF8 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #10192 = PseudoVSUXSEG3EI32_V_MF2_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #10191 = PseudoVSUXSEG3EI32_V_MF2_MF4 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #10190 = PseudoVSUXSEG3EI32_V_MF2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #10189 = PseudoVSUXSEG3EI32_V_MF2_MF2 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #10188 = PseudoVSUXSEG3EI32_V_MF2_M1_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #10187 = PseudoVSUXSEG3EI32_V_MF2_M1 + { 6, &RISCVDescs.OperandInfo[6981] }, // Inst #10186 = PseudoVSUXSEG3EI32_V_M8_M2_MASK + { 5, &RISCVDescs.OperandInfo[6976] }, // Inst #10185 = PseudoVSUXSEG3EI32_V_M8_M2 + { 6, &RISCVDescs.OperandInfo[6959] }, // Inst #10184 = PseudoVSUXSEG3EI32_V_M4_M2_MASK + { 5, &RISCVDescs.OperandInfo[6954] }, // Inst #10183 = PseudoVSUXSEG3EI32_V_M4_M2 + { 6, &RISCVDescs.OperandInfo[6970] }, // Inst #10182 = PseudoVSUXSEG3EI32_V_M4_M1_MASK + { 5, &RISCVDescs.OperandInfo[6965] }, // Inst #10181 = PseudoVSUXSEG3EI32_V_M4_M1 + { 6, &RISCVDescs.OperandInfo[6937] }, // Inst #10180 = PseudoVSUXSEG3EI32_V_M2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6932] }, // Inst #10179 = PseudoVSUXSEG3EI32_V_M2_MF2 + { 6, &RISCVDescs.OperandInfo[6948] }, // Inst #10178 = PseudoVSUXSEG3EI32_V_M2_M2_MASK + { 5, &RISCVDescs.OperandInfo[6943] }, // Inst #10177 = PseudoVSUXSEG3EI32_V_M2_M2 + { 6, &RISCVDescs.OperandInfo[6937] }, // Inst #10176 = PseudoVSUXSEG3EI32_V_M2_M1_MASK + { 5, &RISCVDescs.OperandInfo[6932] }, // Inst #10175 = PseudoVSUXSEG3EI32_V_M2_M1 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #10174 = PseudoVSUXSEG3EI32_V_M1_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #10173 = PseudoVSUXSEG3EI32_V_M1_MF4 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #10172 = PseudoVSUXSEG3EI32_V_M1_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #10171 = PseudoVSUXSEG3EI32_V_M1_MF2 + { 6, &RISCVDescs.OperandInfo[6926] }, // Inst #10170 = PseudoVSUXSEG3EI32_V_M1_M2_MASK + { 5, &RISCVDescs.OperandInfo[6921] }, // Inst #10169 = PseudoVSUXSEG3EI32_V_M1_M2 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #10168 = PseudoVSUXSEG3EI32_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #10167 = PseudoVSUXSEG3EI32_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #10166 = PseudoVSUXSEG3EI16_V_MF4_MF8_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #10165 = PseudoVSUXSEG3EI16_V_MF4_MF8 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #10164 = PseudoVSUXSEG3EI16_V_MF4_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #10163 = PseudoVSUXSEG3EI16_V_MF4_MF4 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #10162 = PseudoVSUXSEG3EI16_V_MF4_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #10161 = PseudoVSUXSEG3EI16_V_MF4_MF2 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #10160 = PseudoVSUXSEG3EI16_V_MF4_M1_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #10159 = PseudoVSUXSEG3EI16_V_MF4_M1 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #10158 = PseudoVSUXSEG3EI16_V_MF2_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #10157 = PseudoVSUXSEG3EI16_V_MF2_MF4 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #10156 = PseudoVSUXSEG3EI16_V_MF2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #10155 = PseudoVSUXSEG3EI16_V_MF2_MF2 + { 6, &RISCVDescs.OperandInfo[6926] }, // Inst #10154 = PseudoVSUXSEG3EI16_V_MF2_M2_MASK + { 5, &RISCVDescs.OperandInfo[6921] }, // Inst #10153 = PseudoVSUXSEG3EI16_V_MF2_M2 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #10152 = PseudoVSUXSEG3EI16_V_MF2_M1_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #10151 = PseudoVSUXSEG3EI16_V_MF2_M1 + { 6, &RISCVDescs.OperandInfo[6959] }, // Inst #10150 = PseudoVSUXSEG3EI16_V_M4_M2_MASK + { 5, &RISCVDescs.OperandInfo[6954] }, // Inst #10149 = PseudoVSUXSEG3EI16_V_M4_M2 + { 6, &RISCVDescs.OperandInfo[6948] }, // Inst #10148 = PseudoVSUXSEG3EI16_V_M2_M2_MASK + { 5, &RISCVDescs.OperandInfo[6943] }, // Inst #10147 = PseudoVSUXSEG3EI16_V_M2_M2 + { 6, &RISCVDescs.OperandInfo[6937] }, // Inst #10146 = PseudoVSUXSEG3EI16_V_M2_M1_MASK + { 5, &RISCVDescs.OperandInfo[6932] }, // Inst #10145 = PseudoVSUXSEG3EI16_V_M2_M1 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #10144 = PseudoVSUXSEG3EI16_V_M1_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #10143 = PseudoVSUXSEG3EI16_V_M1_MF2 + { 6, &RISCVDescs.OperandInfo[6926] }, // Inst #10142 = PseudoVSUXSEG3EI16_V_M1_M2_MASK + { 5, &RISCVDescs.OperandInfo[6921] }, // Inst #10141 = PseudoVSUXSEG3EI16_V_M1_M2 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #10140 = PseudoVSUXSEG3EI16_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #10139 = PseudoVSUXSEG3EI16_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #10138 = PseudoVSUXSEG2EI8_V_MF8_MF8_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #10137 = PseudoVSUXSEG2EI8_V_MF8_MF8 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #10136 = PseudoVSUXSEG2EI8_V_MF8_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #10135 = PseudoVSUXSEG2EI8_V_MF8_MF4 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #10134 = PseudoVSUXSEG2EI8_V_MF8_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #10133 = PseudoVSUXSEG2EI8_V_MF8_MF2 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #10132 = PseudoVSUXSEG2EI8_V_MF8_M1_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #10131 = PseudoVSUXSEG2EI8_V_MF8_M1 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #10130 = PseudoVSUXSEG2EI8_V_MF4_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #10129 = PseudoVSUXSEG2EI8_V_MF4_MF4 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #10128 = PseudoVSUXSEG2EI8_V_MF4_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #10127 = PseudoVSUXSEG2EI8_V_MF4_MF2 + { 6, &RISCVDescs.OperandInfo[6794] }, // Inst #10126 = PseudoVSUXSEG2EI8_V_MF4_M2_MASK + { 5, &RISCVDescs.OperandInfo[6789] }, // Inst #10125 = PseudoVSUXSEG2EI8_V_MF4_M2 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #10124 = PseudoVSUXSEG2EI8_V_MF4_M1_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #10123 = PseudoVSUXSEG2EI8_V_MF4_M1 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #10122 = PseudoVSUXSEG2EI8_V_MF2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #10121 = PseudoVSUXSEG2EI8_V_MF2_MF2 + { 6, &RISCVDescs.OperandInfo[6805] }, // Inst #10120 = PseudoVSUXSEG2EI8_V_MF2_M4_MASK + { 5, &RISCVDescs.OperandInfo[6800] }, // Inst #10119 = PseudoVSUXSEG2EI8_V_MF2_M4 + { 6, &RISCVDescs.OperandInfo[6794] }, // Inst #10118 = PseudoVSUXSEG2EI8_V_MF2_M2_MASK + { 5, &RISCVDescs.OperandInfo[6789] }, // Inst #10117 = PseudoVSUXSEG2EI8_V_MF2_M2 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #10116 = PseudoVSUXSEG2EI8_V_MF2_M1_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #10115 = PseudoVSUXSEG2EI8_V_MF2_M1 + { 6, &RISCVDescs.OperandInfo[6860] }, // Inst #10114 = PseudoVSUXSEG2EI8_V_M4_M4_MASK + { 5, &RISCVDescs.OperandInfo[6855] }, // Inst #10113 = PseudoVSUXSEG2EI8_V_M4_M4 + { 6, &RISCVDescs.OperandInfo[6838] }, // Inst #10112 = PseudoVSUXSEG2EI8_V_M2_M4_MASK + { 5, &RISCVDescs.OperandInfo[6833] }, // Inst #10111 = PseudoVSUXSEG2EI8_V_M2_M4 + { 6, &RISCVDescs.OperandInfo[6827] }, // Inst #10110 = PseudoVSUXSEG2EI8_V_M2_M2_MASK + { 5, &RISCVDescs.OperandInfo[6822] }, // Inst #10109 = PseudoVSUXSEG2EI8_V_M2_M2 + { 6, &RISCVDescs.OperandInfo[6805] }, // Inst #10108 = PseudoVSUXSEG2EI8_V_M1_M4_MASK + { 5, &RISCVDescs.OperandInfo[6800] }, // Inst #10107 = PseudoVSUXSEG2EI8_V_M1_M4 + { 6, &RISCVDescs.OperandInfo[6794] }, // Inst #10106 = PseudoVSUXSEG2EI8_V_M1_M2_MASK + { 5, &RISCVDescs.OperandInfo[6789] }, // Inst #10105 = PseudoVSUXSEG2EI8_V_M1_M2 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #10104 = PseudoVSUXSEG2EI8_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #10103 = PseudoVSUXSEG2EI8_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[6871] }, // Inst #10102 = PseudoVSUXSEG2EI64_V_M8_M4_MASK + { 5, &RISCVDescs.OperandInfo[6866] }, // Inst #10101 = PseudoVSUXSEG2EI64_V_M8_M4 + { 6, &RISCVDescs.OperandInfo[6893] }, // Inst #10100 = PseudoVSUXSEG2EI64_V_M8_M2_MASK + { 5, &RISCVDescs.OperandInfo[6888] }, // Inst #10099 = PseudoVSUXSEG2EI64_V_M8_M2 + { 6, &RISCVDescs.OperandInfo[6904] }, // Inst #10098 = PseudoVSUXSEG2EI64_V_M8_M1_MASK + { 5, &RISCVDescs.OperandInfo[6899] }, // Inst #10097 = PseudoVSUXSEG2EI64_V_M8_M1 + { 6, &RISCVDescs.OperandInfo[6882] }, // Inst #10096 = PseudoVSUXSEG2EI64_V_M4_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6877] }, // Inst #10095 = PseudoVSUXSEG2EI64_V_M4_MF2 + { 6, &RISCVDescs.OperandInfo[6860] }, // Inst #10094 = PseudoVSUXSEG2EI64_V_M4_M4_MASK + { 5, &RISCVDescs.OperandInfo[6855] }, // Inst #10093 = PseudoVSUXSEG2EI64_V_M4_M4 + { 6, &RISCVDescs.OperandInfo[6849] }, // Inst #10092 = PseudoVSUXSEG2EI64_V_M4_M2_MASK + { 5, &RISCVDescs.OperandInfo[6844] }, // Inst #10091 = PseudoVSUXSEG2EI64_V_M4_M2 + { 6, &RISCVDescs.OperandInfo[6882] }, // Inst #10090 = PseudoVSUXSEG2EI64_V_M4_M1_MASK + { 5, &RISCVDescs.OperandInfo[6877] }, // Inst #10089 = PseudoVSUXSEG2EI64_V_M4_M1 + { 6, &RISCVDescs.OperandInfo[6816] }, // Inst #10088 = PseudoVSUXSEG2EI64_V_M2_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6811] }, // Inst #10087 = PseudoVSUXSEG2EI64_V_M2_MF4 + { 6, &RISCVDescs.OperandInfo[6816] }, // Inst #10086 = PseudoVSUXSEG2EI64_V_M2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6811] }, // Inst #10085 = PseudoVSUXSEG2EI64_V_M2_MF2 + { 6, &RISCVDescs.OperandInfo[6827] }, // Inst #10084 = PseudoVSUXSEG2EI64_V_M2_M2_MASK + { 5, &RISCVDescs.OperandInfo[6822] }, // Inst #10083 = PseudoVSUXSEG2EI64_V_M2_M2 + { 6, &RISCVDescs.OperandInfo[6816] }, // Inst #10082 = PseudoVSUXSEG2EI64_V_M2_M1_MASK + { 5, &RISCVDescs.OperandInfo[6811] }, // Inst #10081 = PseudoVSUXSEG2EI64_V_M2_M1 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #10080 = PseudoVSUXSEG2EI64_V_M1_MF8_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #10079 = PseudoVSUXSEG2EI64_V_M1_MF8 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #10078 = PseudoVSUXSEG2EI64_V_M1_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #10077 = PseudoVSUXSEG2EI64_V_M1_MF4 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #10076 = PseudoVSUXSEG2EI64_V_M1_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #10075 = PseudoVSUXSEG2EI64_V_M1_MF2 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #10074 = PseudoVSUXSEG2EI64_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #10073 = PseudoVSUXSEG2EI64_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #10072 = PseudoVSUXSEG2EI32_V_MF2_MF8_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #10071 = PseudoVSUXSEG2EI32_V_MF2_MF8 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #10070 = PseudoVSUXSEG2EI32_V_MF2_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #10069 = PseudoVSUXSEG2EI32_V_MF2_MF4 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #10068 = PseudoVSUXSEG2EI32_V_MF2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #10067 = PseudoVSUXSEG2EI32_V_MF2_MF2 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #10066 = PseudoVSUXSEG2EI32_V_MF2_M1_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #10065 = PseudoVSUXSEG2EI32_V_MF2_M1 + { 6, &RISCVDescs.OperandInfo[6871] }, // Inst #10064 = PseudoVSUXSEG2EI32_V_M8_M4_MASK + { 5, &RISCVDescs.OperandInfo[6866] }, // Inst #10063 = PseudoVSUXSEG2EI32_V_M8_M4 + { 6, &RISCVDescs.OperandInfo[6893] }, // Inst #10062 = PseudoVSUXSEG2EI32_V_M8_M2_MASK + { 5, &RISCVDescs.OperandInfo[6888] }, // Inst #10061 = PseudoVSUXSEG2EI32_V_M8_M2 + { 6, &RISCVDescs.OperandInfo[6860] }, // Inst #10060 = PseudoVSUXSEG2EI32_V_M4_M4_MASK + { 5, &RISCVDescs.OperandInfo[6855] }, // Inst #10059 = PseudoVSUXSEG2EI32_V_M4_M4 + { 6, &RISCVDescs.OperandInfo[6849] }, // Inst #10058 = PseudoVSUXSEG2EI32_V_M4_M2_MASK + { 5, &RISCVDescs.OperandInfo[6844] }, // Inst #10057 = PseudoVSUXSEG2EI32_V_M4_M2 + { 6, &RISCVDescs.OperandInfo[6882] }, // Inst #10056 = PseudoVSUXSEG2EI32_V_M4_M1_MASK + { 5, &RISCVDescs.OperandInfo[6877] }, // Inst #10055 = PseudoVSUXSEG2EI32_V_M4_M1 + { 6, &RISCVDescs.OperandInfo[6816] }, // Inst #10054 = PseudoVSUXSEG2EI32_V_M2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6811] }, // Inst #10053 = PseudoVSUXSEG2EI32_V_M2_MF2 + { 6, &RISCVDescs.OperandInfo[6838] }, // Inst #10052 = PseudoVSUXSEG2EI32_V_M2_M4_MASK + { 5, &RISCVDescs.OperandInfo[6833] }, // Inst #10051 = PseudoVSUXSEG2EI32_V_M2_M4 + { 6, &RISCVDescs.OperandInfo[6827] }, // Inst #10050 = PseudoVSUXSEG2EI32_V_M2_M2_MASK + { 5, &RISCVDescs.OperandInfo[6822] }, // Inst #10049 = PseudoVSUXSEG2EI32_V_M2_M2 + { 6, &RISCVDescs.OperandInfo[6816] }, // Inst #10048 = PseudoVSUXSEG2EI32_V_M2_M1_MASK + { 5, &RISCVDescs.OperandInfo[6811] }, // Inst #10047 = PseudoVSUXSEG2EI32_V_M2_M1 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #10046 = PseudoVSUXSEG2EI32_V_M1_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #10045 = PseudoVSUXSEG2EI32_V_M1_MF4 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #10044 = PseudoVSUXSEG2EI32_V_M1_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #10043 = PseudoVSUXSEG2EI32_V_M1_MF2 + { 6, &RISCVDescs.OperandInfo[6794] }, // Inst #10042 = PseudoVSUXSEG2EI32_V_M1_M2_MASK + { 5, &RISCVDescs.OperandInfo[6789] }, // Inst #10041 = PseudoVSUXSEG2EI32_V_M1_M2 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #10040 = PseudoVSUXSEG2EI32_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #10039 = PseudoVSUXSEG2EI32_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #10038 = PseudoVSUXSEG2EI16_V_MF4_MF8_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #10037 = PseudoVSUXSEG2EI16_V_MF4_MF8 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #10036 = PseudoVSUXSEG2EI16_V_MF4_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #10035 = PseudoVSUXSEG2EI16_V_MF4_MF4 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #10034 = PseudoVSUXSEG2EI16_V_MF4_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #10033 = PseudoVSUXSEG2EI16_V_MF4_MF2 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #10032 = PseudoVSUXSEG2EI16_V_MF4_M1_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #10031 = PseudoVSUXSEG2EI16_V_MF4_M1 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #10030 = PseudoVSUXSEG2EI16_V_MF2_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #10029 = PseudoVSUXSEG2EI16_V_MF2_MF4 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #10028 = PseudoVSUXSEG2EI16_V_MF2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #10027 = PseudoVSUXSEG2EI16_V_MF2_MF2 + { 6, &RISCVDescs.OperandInfo[6794] }, // Inst #10026 = PseudoVSUXSEG2EI16_V_MF2_M2_MASK + { 5, &RISCVDescs.OperandInfo[6789] }, // Inst #10025 = PseudoVSUXSEG2EI16_V_MF2_M2 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #10024 = PseudoVSUXSEG2EI16_V_MF2_M1_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #10023 = PseudoVSUXSEG2EI16_V_MF2_M1 + { 6, &RISCVDescs.OperandInfo[6871] }, // Inst #10022 = PseudoVSUXSEG2EI16_V_M8_M4_MASK + { 5, &RISCVDescs.OperandInfo[6866] }, // Inst #10021 = PseudoVSUXSEG2EI16_V_M8_M4 + { 6, &RISCVDescs.OperandInfo[6860] }, // Inst #10020 = PseudoVSUXSEG2EI16_V_M4_M4_MASK + { 5, &RISCVDescs.OperandInfo[6855] }, // Inst #10019 = PseudoVSUXSEG2EI16_V_M4_M4 + { 6, &RISCVDescs.OperandInfo[6849] }, // Inst #10018 = PseudoVSUXSEG2EI16_V_M4_M2_MASK + { 5, &RISCVDescs.OperandInfo[6844] }, // Inst #10017 = PseudoVSUXSEG2EI16_V_M4_M2 + { 6, &RISCVDescs.OperandInfo[6838] }, // Inst #10016 = PseudoVSUXSEG2EI16_V_M2_M4_MASK + { 5, &RISCVDescs.OperandInfo[6833] }, // Inst #10015 = PseudoVSUXSEG2EI16_V_M2_M4 + { 6, &RISCVDescs.OperandInfo[6827] }, // Inst #10014 = PseudoVSUXSEG2EI16_V_M2_M2_MASK + { 5, &RISCVDescs.OperandInfo[6822] }, // Inst #10013 = PseudoVSUXSEG2EI16_V_M2_M2 + { 6, &RISCVDescs.OperandInfo[6816] }, // Inst #10012 = PseudoVSUXSEG2EI16_V_M2_M1_MASK + { 5, &RISCVDescs.OperandInfo[6811] }, // Inst #10011 = PseudoVSUXSEG2EI16_V_M2_M1 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #10010 = PseudoVSUXSEG2EI16_V_M1_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #10009 = PseudoVSUXSEG2EI16_V_M1_MF2 + { 6, &RISCVDescs.OperandInfo[6805] }, // Inst #10008 = PseudoVSUXSEG2EI16_V_M1_M4_MASK + { 5, &RISCVDescs.OperandInfo[6800] }, // Inst #10007 = PseudoVSUXSEG2EI16_V_M1_M4 + { 6, &RISCVDescs.OperandInfo[6794] }, // Inst #10006 = PseudoVSUXSEG2EI16_V_M1_M2_MASK + { 5, &RISCVDescs.OperandInfo[6789] }, // Inst #10005 = PseudoVSUXSEG2EI16_V_M1_M2 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #10004 = PseudoVSUXSEG2EI16_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #10003 = PseudoVSUXSEG2EI16_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #10002 = PseudoVSUXEI8_V_MF8_MF8_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #10001 = PseudoVSUXEI8_V_MF8_MF8 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #10000 = PseudoVSUXEI8_V_MF8_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #9999 = PseudoVSUXEI8_V_MF8_MF4 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #9998 = PseudoVSUXEI8_V_MF8_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #9997 = PseudoVSUXEI8_V_MF8_MF2 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #9996 = PseudoVSUXEI8_V_MF8_M1_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #9995 = PseudoVSUXEI8_V_MF8_M1 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #9994 = PseudoVSUXEI8_V_MF4_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #9993 = PseudoVSUXEI8_V_MF4_MF4 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #9992 = PseudoVSUXEI8_V_MF4_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #9991 = PseudoVSUXEI8_V_MF4_MF2 + { 6, &RISCVDescs.OperandInfo[6618] }, // Inst #9990 = PseudoVSUXEI8_V_MF4_M2_MASK + { 5, &RISCVDescs.OperandInfo[6613] }, // Inst #9989 = PseudoVSUXEI8_V_MF4_M2 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #9988 = PseudoVSUXEI8_V_MF4_M1_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #9987 = PseudoVSUXEI8_V_MF4_M1 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #9986 = PseudoVSUXEI8_V_MF2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #9985 = PseudoVSUXEI8_V_MF2_MF2 + { 6, &RISCVDescs.OperandInfo[6629] }, // Inst #9984 = PseudoVSUXEI8_V_MF2_M4_MASK + { 5, &RISCVDescs.OperandInfo[6624] }, // Inst #9983 = PseudoVSUXEI8_V_MF2_M4 + { 6, &RISCVDescs.OperandInfo[6618] }, // Inst #9982 = PseudoVSUXEI8_V_MF2_M2_MASK + { 5, &RISCVDescs.OperandInfo[6613] }, // Inst #9981 = PseudoVSUXEI8_V_MF2_M2 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #9980 = PseudoVSUXEI8_V_MF2_M1_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #9979 = PseudoVSUXEI8_V_MF2_M1 + { 6, &RISCVDescs.OperandInfo[6728] }, // Inst #9978 = PseudoVSUXEI8_V_M8_M8_MASK + { 5, &RISCVDescs.OperandInfo[6723] }, // Inst #9977 = PseudoVSUXEI8_V_M8_M8 + { 6, &RISCVDescs.OperandInfo[6706] }, // Inst #9976 = PseudoVSUXEI8_V_M4_M8_MASK + { 5, &RISCVDescs.OperandInfo[6701] }, // Inst #9975 = PseudoVSUXEI8_V_M4_M8 + { 6, &RISCVDescs.OperandInfo[6695] }, // Inst #9974 = PseudoVSUXEI8_V_M4_M4_MASK + { 5, &RISCVDescs.OperandInfo[6690] }, // Inst #9973 = PseudoVSUXEI8_V_M4_M4 + { 6, &RISCVDescs.OperandInfo[6673] }, // Inst #9972 = PseudoVSUXEI8_V_M2_M8_MASK + { 5, &RISCVDescs.OperandInfo[6668] }, // Inst #9971 = PseudoVSUXEI8_V_M2_M8 + { 6, &RISCVDescs.OperandInfo[6662] }, // Inst #9970 = PseudoVSUXEI8_V_M2_M4_MASK + { 5, &RISCVDescs.OperandInfo[6657] }, // Inst #9969 = PseudoVSUXEI8_V_M2_M4 + { 6, &RISCVDescs.OperandInfo[6651] }, // Inst #9968 = PseudoVSUXEI8_V_M2_M2_MASK + { 5, &RISCVDescs.OperandInfo[6646] }, // Inst #9967 = PseudoVSUXEI8_V_M2_M2 + { 6, &RISCVDescs.OperandInfo[6772] }, // Inst #9966 = PseudoVSUXEI8_V_M1_M8_MASK + { 5, &RISCVDescs.OperandInfo[6767] }, // Inst #9965 = PseudoVSUXEI8_V_M1_M8 + { 6, &RISCVDescs.OperandInfo[6629] }, // Inst #9964 = PseudoVSUXEI8_V_M1_M4_MASK + { 5, &RISCVDescs.OperandInfo[6624] }, // Inst #9963 = PseudoVSUXEI8_V_M1_M4 + { 6, &RISCVDescs.OperandInfo[6618] }, // Inst #9962 = PseudoVSUXEI8_V_M1_M2_MASK + { 5, &RISCVDescs.OperandInfo[6613] }, // Inst #9961 = PseudoVSUXEI8_V_M1_M2 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #9960 = PseudoVSUXEI8_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #9959 = PseudoVSUXEI8_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[6728] }, // Inst #9958 = PseudoVSUXEI64_V_M8_M8_MASK + { 5, &RISCVDescs.OperandInfo[6723] }, // Inst #9957 = PseudoVSUXEI64_V_M8_M8 + { 6, &RISCVDescs.OperandInfo[6717] }, // Inst #9956 = PseudoVSUXEI64_V_M8_M4_MASK + { 5, &RISCVDescs.OperandInfo[6712] }, // Inst #9955 = PseudoVSUXEI64_V_M8_M4 + { 6, &RISCVDescs.OperandInfo[6750] }, // Inst #9954 = PseudoVSUXEI64_V_M8_M2_MASK + { 5, &RISCVDescs.OperandInfo[6745] }, // Inst #9953 = PseudoVSUXEI64_V_M8_M2 + { 6, &RISCVDescs.OperandInfo[6761] }, // Inst #9952 = PseudoVSUXEI64_V_M8_M1_MASK + { 5, &RISCVDescs.OperandInfo[6756] }, // Inst #9951 = PseudoVSUXEI64_V_M8_M1 + { 6, &RISCVDescs.OperandInfo[6739] }, // Inst #9950 = PseudoVSUXEI64_V_M4_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6734] }, // Inst #9949 = PseudoVSUXEI64_V_M4_MF2 + { 6, &RISCVDescs.OperandInfo[6695] }, // Inst #9948 = PseudoVSUXEI64_V_M4_M4_MASK + { 5, &RISCVDescs.OperandInfo[6690] }, // Inst #9947 = PseudoVSUXEI64_V_M4_M4 + { 6, &RISCVDescs.OperandInfo[6684] }, // Inst #9946 = PseudoVSUXEI64_V_M4_M2_MASK + { 5, &RISCVDescs.OperandInfo[6679] }, // Inst #9945 = PseudoVSUXEI64_V_M4_M2 + { 6, &RISCVDescs.OperandInfo[6739] }, // Inst #9944 = PseudoVSUXEI64_V_M4_M1_MASK + { 5, &RISCVDescs.OperandInfo[6734] }, // Inst #9943 = PseudoVSUXEI64_V_M4_M1 + { 6, &RISCVDescs.OperandInfo[6640] }, // Inst #9942 = PseudoVSUXEI64_V_M2_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6635] }, // Inst #9941 = PseudoVSUXEI64_V_M2_MF4 + { 6, &RISCVDescs.OperandInfo[6640] }, // Inst #9940 = PseudoVSUXEI64_V_M2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6635] }, // Inst #9939 = PseudoVSUXEI64_V_M2_MF2 + { 6, &RISCVDescs.OperandInfo[6651] }, // Inst #9938 = PseudoVSUXEI64_V_M2_M2_MASK + { 5, &RISCVDescs.OperandInfo[6646] }, // Inst #9937 = PseudoVSUXEI64_V_M2_M2 + { 6, &RISCVDescs.OperandInfo[6640] }, // Inst #9936 = PseudoVSUXEI64_V_M2_M1_MASK + { 5, &RISCVDescs.OperandInfo[6635] }, // Inst #9935 = PseudoVSUXEI64_V_M2_M1 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #9934 = PseudoVSUXEI64_V_M1_MF8_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #9933 = PseudoVSUXEI64_V_M1_MF8 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #9932 = PseudoVSUXEI64_V_M1_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #9931 = PseudoVSUXEI64_V_M1_MF4 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #9930 = PseudoVSUXEI64_V_M1_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #9929 = PseudoVSUXEI64_V_M1_MF2 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #9928 = PseudoVSUXEI64_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #9927 = PseudoVSUXEI64_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #9926 = PseudoVSUXEI32_V_MF2_MF8_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #9925 = PseudoVSUXEI32_V_MF2_MF8 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #9924 = PseudoVSUXEI32_V_MF2_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #9923 = PseudoVSUXEI32_V_MF2_MF4 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #9922 = PseudoVSUXEI32_V_MF2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #9921 = PseudoVSUXEI32_V_MF2_MF2 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #9920 = PseudoVSUXEI32_V_MF2_M1_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #9919 = PseudoVSUXEI32_V_MF2_M1 + { 6, &RISCVDescs.OperandInfo[6728] }, // Inst #9918 = PseudoVSUXEI32_V_M8_M8_MASK + { 5, &RISCVDescs.OperandInfo[6723] }, // Inst #9917 = PseudoVSUXEI32_V_M8_M8 + { 6, &RISCVDescs.OperandInfo[6717] }, // Inst #9916 = PseudoVSUXEI32_V_M8_M4_MASK + { 5, &RISCVDescs.OperandInfo[6712] }, // Inst #9915 = PseudoVSUXEI32_V_M8_M4 + { 6, &RISCVDescs.OperandInfo[6750] }, // Inst #9914 = PseudoVSUXEI32_V_M8_M2_MASK + { 5, &RISCVDescs.OperandInfo[6745] }, // Inst #9913 = PseudoVSUXEI32_V_M8_M2 + { 6, &RISCVDescs.OperandInfo[6706] }, // Inst #9912 = PseudoVSUXEI32_V_M4_M8_MASK + { 5, &RISCVDescs.OperandInfo[6701] }, // Inst #9911 = PseudoVSUXEI32_V_M4_M8 + { 6, &RISCVDescs.OperandInfo[6695] }, // Inst #9910 = PseudoVSUXEI32_V_M4_M4_MASK + { 5, &RISCVDescs.OperandInfo[6690] }, // Inst #9909 = PseudoVSUXEI32_V_M4_M4 + { 6, &RISCVDescs.OperandInfo[6684] }, // Inst #9908 = PseudoVSUXEI32_V_M4_M2_MASK + { 5, &RISCVDescs.OperandInfo[6679] }, // Inst #9907 = PseudoVSUXEI32_V_M4_M2 + { 6, &RISCVDescs.OperandInfo[6739] }, // Inst #9906 = PseudoVSUXEI32_V_M4_M1_MASK + { 5, &RISCVDescs.OperandInfo[6734] }, // Inst #9905 = PseudoVSUXEI32_V_M4_M1 + { 6, &RISCVDescs.OperandInfo[6640] }, // Inst #9904 = PseudoVSUXEI32_V_M2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6635] }, // Inst #9903 = PseudoVSUXEI32_V_M2_MF2 + { 6, &RISCVDescs.OperandInfo[6662] }, // Inst #9902 = PseudoVSUXEI32_V_M2_M4_MASK + { 5, &RISCVDescs.OperandInfo[6657] }, // Inst #9901 = PseudoVSUXEI32_V_M2_M4 + { 6, &RISCVDescs.OperandInfo[6651] }, // Inst #9900 = PseudoVSUXEI32_V_M2_M2_MASK + { 5, &RISCVDescs.OperandInfo[6646] }, // Inst #9899 = PseudoVSUXEI32_V_M2_M2 + { 6, &RISCVDescs.OperandInfo[6640] }, // Inst #9898 = PseudoVSUXEI32_V_M2_M1_MASK + { 5, &RISCVDescs.OperandInfo[6635] }, // Inst #9897 = PseudoVSUXEI32_V_M2_M1 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #9896 = PseudoVSUXEI32_V_M1_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #9895 = PseudoVSUXEI32_V_M1_MF4 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #9894 = PseudoVSUXEI32_V_M1_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #9893 = PseudoVSUXEI32_V_M1_MF2 + { 6, &RISCVDescs.OperandInfo[6618] }, // Inst #9892 = PseudoVSUXEI32_V_M1_M2_MASK + { 5, &RISCVDescs.OperandInfo[6613] }, // Inst #9891 = PseudoVSUXEI32_V_M1_M2 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #9890 = PseudoVSUXEI32_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #9889 = PseudoVSUXEI32_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #9888 = PseudoVSUXEI16_V_MF4_MF8_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #9887 = PseudoVSUXEI16_V_MF4_MF8 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #9886 = PseudoVSUXEI16_V_MF4_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #9885 = PseudoVSUXEI16_V_MF4_MF4 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #9884 = PseudoVSUXEI16_V_MF4_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #9883 = PseudoVSUXEI16_V_MF4_MF2 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #9882 = PseudoVSUXEI16_V_MF4_M1_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #9881 = PseudoVSUXEI16_V_MF4_M1 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #9880 = PseudoVSUXEI16_V_MF2_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #9879 = PseudoVSUXEI16_V_MF2_MF4 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #9878 = PseudoVSUXEI16_V_MF2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #9877 = PseudoVSUXEI16_V_MF2_MF2 + { 6, &RISCVDescs.OperandInfo[6618] }, // Inst #9876 = PseudoVSUXEI16_V_MF2_M2_MASK + { 5, &RISCVDescs.OperandInfo[6613] }, // Inst #9875 = PseudoVSUXEI16_V_MF2_M2 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #9874 = PseudoVSUXEI16_V_MF2_M1_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #9873 = PseudoVSUXEI16_V_MF2_M1 + { 6, &RISCVDescs.OperandInfo[6728] }, // Inst #9872 = PseudoVSUXEI16_V_M8_M8_MASK + { 5, &RISCVDescs.OperandInfo[6723] }, // Inst #9871 = PseudoVSUXEI16_V_M8_M8 + { 6, &RISCVDescs.OperandInfo[6717] }, // Inst #9870 = PseudoVSUXEI16_V_M8_M4_MASK + { 5, &RISCVDescs.OperandInfo[6712] }, // Inst #9869 = PseudoVSUXEI16_V_M8_M4 + { 6, &RISCVDescs.OperandInfo[6706] }, // Inst #9868 = PseudoVSUXEI16_V_M4_M8_MASK + { 5, &RISCVDescs.OperandInfo[6701] }, // Inst #9867 = PseudoVSUXEI16_V_M4_M8 + { 6, &RISCVDescs.OperandInfo[6695] }, // Inst #9866 = PseudoVSUXEI16_V_M4_M4_MASK + { 5, &RISCVDescs.OperandInfo[6690] }, // Inst #9865 = PseudoVSUXEI16_V_M4_M4 + { 6, &RISCVDescs.OperandInfo[6684] }, // Inst #9864 = PseudoVSUXEI16_V_M4_M2_MASK + { 5, &RISCVDescs.OperandInfo[6679] }, // Inst #9863 = PseudoVSUXEI16_V_M4_M2 + { 6, &RISCVDescs.OperandInfo[6673] }, // Inst #9862 = PseudoVSUXEI16_V_M2_M8_MASK + { 5, &RISCVDescs.OperandInfo[6668] }, // Inst #9861 = PseudoVSUXEI16_V_M2_M8 + { 6, &RISCVDescs.OperandInfo[6662] }, // Inst #9860 = PseudoVSUXEI16_V_M2_M4_MASK + { 5, &RISCVDescs.OperandInfo[6657] }, // Inst #9859 = PseudoVSUXEI16_V_M2_M4 + { 6, &RISCVDescs.OperandInfo[6651] }, // Inst #9858 = PseudoVSUXEI16_V_M2_M2_MASK + { 5, &RISCVDescs.OperandInfo[6646] }, // Inst #9857 = PseudoVSUXEI16_V_M2_M2 + { 6, &RISCVDescs.OperandInfo[6640] }, // Inst #9856 = PseudoVSUXEI16_V_M2_M1_MASK + { 5, &RISCVDescs.OperandInfo[6635] }, // Inst #9855 = PseudoVSUXEI16_V_M2_M1 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #9854 = PseudoVSUXEI16_V_M1_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #9853 = PseudoVSUXEI16_V_M1_MF2 + { 6, &RISCVDescs.OperandInfo[6629] }, // Inst #9852 = PseudoVSUXEI16_V_M1_M4_MASK + { 5, &RISCVDescs.OperandInfo[6624] }, // Inst #9851 = PseudoVSUXEI16_V_M1_M4 + { 6, &RISCVDescs.OperandInfo[6618] }, // Inst #9850 = PseudoVSUXEI16_V_M1_M2_MASK + { 5, &RISCVDescs.OperandInfo[6613] }, // Inst #9849 = PseudoVSUXEI16_V_M1_M2 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #9848 = PseudoVSUXEI16_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #9847 = PseudoVSUXEI16_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #9846 = PseudoVSUB_VX_MF8_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #9845 = PseudoVSUB_VX_MF8 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #9844 = PseudoVSUB_VX_MF4_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #9843 = PseudoVSUB_VX_MF4 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #9842 = PseudoVSUB_VX_MF2_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #9841 = PseudoVSUB_VX_MF2 + { 8, &RISCVDescs.OperandInfo[809] }, // Inst #9840 = PseudoVSUB_VX_M8_MASK + { 7, &RISCVDescs.OperandInfo[802] }, // Inst #9839 = PseudoVSUB_VX_M8 + { 8, &RISCVDescs.OperandInfo[794] }, // Inst #9838 = PseudoVSUB_VX_M4_MASK + { 7, &RISCVDescs.OperandInfo[787] }, // Inst #9837 = PseudoVSUB_VX_M4 + { 8, &RISCVDescs.OperandInfo[779] }, // Inst #9836 = PseudoVSUB_VX_M2_MASK + { 7, &RISCVDescs.OperandInfo[772] }, // Inst #9835 = PseudoVSUB_VX_M2 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #9834 = PseudoVSUB_VX_M1_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #9833 = PseudoVSUB_VX_M1 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #9832 = PseudoVSUB_VV_MF8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #9831 = PseudoVSUB_VV_MF8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #9830 = PseudoVSUB_VV_MF4_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #9829 = PseudoVSUB_VV_MF4 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #9828 = PseudoVSUB_VV_MF2_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #9827 = PseudoVSUB_VV_MF2 + { 8, &RISCVDescs.OperandInfo[749] }, // Inst #9826 = PseudoVSUB_VV_M8_MASK + { 7, &RISCVDescs.OperandInfo[742] }, // Inst #9825 = PseudoVSUB_VV_M8 + { 8, &RISCVDescs.OperandInfo[734] }, // Inst #9824 = PseudoVSUB_VV_M4_MASK + { 7, &RISCVDescs.OperandInfo[727] }, // Inst #9823 = PseudoVSUB_VV_M4 + { 8, &RISCVDescs.OperandInfo[719] }, // Inst #9822 = PseudoVSUB_VV_M2_MASK + { 7, &RISCVDescs.OperandInfo[712] }, // Inst #9821 = PseudoVSUB_VV_M2 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #9820 = PseudoVSUB_VV_M1_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #9819 = PseudoVSUB_VV_M1 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #9818 = PseudoVSSUB_VX_MF8_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #9817 = PseudoVSSUB_VX_MF8 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #9816 = PseudoVSSUB_VX_MF4_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #9815 = PseudoVSSUB_VX_MF4 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #9814 = PseudoVSSUB_VX_MF2_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #9813 = PseudoVSSUB_VX_MF2 + { 8, &RISCVDescs.OperandInfo[809] }, // Inst #9812 = PseudoVSSUB_VX_M8_MASK + { 7, &RISCVDescs.OperandInfo[802] }, // Inst #9811 = PseudoVSSUB_VX_M8 + { 8, &RISCVDescs.OperandInfo[794] }, // Inst #9810 = PseudoVSSUB_VX_M4_MASK + { 7, &RISCVDescs.OperandInfo[787] }, // Inst #9809 = PseudoVSSUB_VX_M4 + { 8, &RISCVDescs.OperandInfo[779] }, // Inst #9808 = PseudoVSSUB_VX_M2_MASK + { 7, &RISCVDescs.OperandInfo[772] }, // Inst #9807 = PseudoVSSUB_VX_M2 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #9806 = PseudoVSSUB_VX_M1_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #9805 = PseudoVSSUB_VX_M1 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #9804 = PseudoVSSUB_VV_MF8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #9803 = PseudoVSSUB_VV_MF8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #9802 = PseudoVSSUB_VV_MF4_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #9801 = PseudoVSSUB_VV_MF4 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #9800 = PseudoVSSUB_VV_MF2_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #9799 = PseudoVSSUB_VV_MF2 + { 8, &RISCVDescs.OperandInfo[749] }, // Inst #9798 = PseudoVSSUB_VV_M8_MASK + { 7, &RISCVDescs.OperandInfo[742] }, // Inst #9797 = PseudoVSSUB_VV_M8 + { 8, &RISCVDescs.OperandInfo[734] }, // Inst #9796 = PseudoVSSUB_VV_M4_MASK + { 7, &RISCVDescs.OperandInfo[727] }, // Inst #9795 = PseudoVSSUB_VV_M4 + { 8, &RISCVDescs.OperandInfo[719] }, // Inst #9794 = PseudoVSSUB_VV_M2_MASK + { 7, &RISCVDescs.OperandInfo[712] }, // Inst #9793 = PseudoVSSUB_VV_M2 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #9792 = PseudoVSSUB_VV_M1_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #9791 = PseudoVSSUB_VV_M1 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #9790 = PseudoVSSUBU_VX_MF8_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #9789 = PseudoVSSUBU_VX_MF8 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #9788 = PseudoVSSUBU_VX_MF4_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #9787 = PseudoVSSUBU_VX_MF4 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #9786 = PseudoVSSUBU_VX_MF2_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #9785 = PseudoVSSUBU_VX_MF2 + { 8, &RISCVDescs.OperandInfo[809] }, // Inst #9784 = PseudoVSSUBU_VX_M8_MASK + { 7, &RISCVDescs.OperandInfo[802] }, // Inst #9783 = PseudoVSSUBU_VX_M8 + { 8, &RISCVDescs.OperandInfo[794] }, // Inst #9782 = PseudoVSSUBU_VX_M4_MASK + { 7, &RISCVDescs.OperandInfo[787] }, // Inst #9781 = PseudoVSSUBU_VX_M4 + { 8, &RISCVDescs.OperandInfo[779] }, // Inst #9780 = PseudoVSSUBU_VX_M2_MASK + { 7, &RISCVDescs.OperandInfo[772] }, // Inst #9779 = PseudoVSSUBU_VX_M2 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #9778 = PseudoVSSUBU_VX_M1_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #9777 = PseudoVSSUBU_VX_M1 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #9776 = PseudoVSSUBU_VV_MF8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #9775 = PseudoVSSUBU_VV_MF8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #9774 = PseudoVSSUBU_VV_MF4_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #9773 = PseudoVSSUBU_VV_MF4 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #9772 = PseudoVSSUBU_VV_MF2_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #9771 = PseudoVSSUBU_VV_MF2 + { 8, &RISCVDescs.OperandInfo[749] }, // Inst #9770 = PseudoVSSUBU_VV_M8_MASK + { 7, &RISCVDescs.OperandInfo[742] }, // Inst #9769 = PseudoVSSUBU_VV_M8 + { 8, &RISCVDescs.OperandInfo[734] }, // Inst #9768 = PseudoVSSUBU_VV_M4_MASK + { 7, &RISCVDescs.OperandInfo[727] }, // Inst #9767 = PseudoVSSUBU_VV_M4 + { 8, &RISCVDescs.OperandInfo[719] }, // Inst #9766 = PseudoVSSUBU_VV_M2_MASK + { 7, &RISCVDescs.OperandInfo[712] }, // Inst #9765 = PseudoVSSUBU_VV_M2 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #9764 = PseudoVSSUBU_VV_M1_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #9763 = PseudoVSSUBU_VV_M1 + { 6, &RISCVDescs.OperandInfo[7571] }, // Inst #9762 = PseudoVSSSEG8E8_V_MF8_MASK + { 5, &RISCVDescs.OperandInfo[7566] }, // Inst #9761 = PseudoVSSSEG8E8_V_MF8 + { 6, &RISCVDescs.OperandInfo[7571] }, // Inst #9760 = PseudoVSSSEG8E8_V_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7566] }, // Inst #9759 = PseudoVSSSEG8E8_V_MF4 + { 6, &RISCVDescs.OperandInfo[7571] }, // Inst #9758 = PseudoVSSSEG8E8_V_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7566] }, // Inst #9757 = PseudoVSSSEG8E8_V_MF2 + { 6, &RISCVDescs.OperandInfo[7571] }, // Inst #9756 = PseudoVSSSEG8E8_V_M1_MASK + { 5, &RISCVDescs.OperandInfo[7566] }, // Inst #9755 = PseudoVSSSEG8E8_V_M1 + { 6, &RISCVDescs.OperandInfo[7571] }, // Inst #9754 = PseudoVSSSEG8E64_V_M1_MASK + { 5, &RISCVDescs.OperandInfo[7566] }, // Inst #9753 = PseudoVSSSEG8E64_V_M1 + { 6, &RISCVDescs.OperandInfo[7571] }, // Inst #9752 = PseudoVSSSEG8E32_V_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7566] }, // Inst #9751 = PseudoVSSSEG8E32_V_MF2 + { 6, &RISCVDescs.OperandInfo[7571] }, // Inst #9750 = PseudoVSSSEG8E32_V_M1_MASK + { 5, &RISCVDescs.OperandInfo[7566] }, // Inst #9749 = PseudoVSSSEG8E32_V_M1 + { 6, &RISCVDescs.OperandInfo[7571] }, // Inst #9748 = PseudoVSSSEG8E16_V_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7566] }, // Inst #9747 = PseudoVSSSEG8E16_V_MF4 + { 6, &RISCVDescs.OperandInfo[7571] }, // Inst #9746 = PseudoVSSSEG8E16_V_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7566] }, // Inst #9745 = PseudoVSSSEG8E16_V_MF2 + { 6, &RISCVDescs.OperandInfo[7571] }, // Inst #9744 = PseudoVSSSEG8E16_V_M1_MASK + { 5, &RISCVDescs.OperandInfo[7566] }, // Inst #9743 = PseudoVSSSEG8E16_V_M1 + { 6, &RISCVDescs.OperandInfo[7560] }, // Inst #9742 = PseudoVSSSEG7E8_V_MF8_MASK + { 5, &RISCVDescs.OperandInfo[7555] }, // Inst #9741 = PseudoVSSSEG7E8_V_MF8 + { 6, &RISCVDescs.OperandInfo[7560] }, // Inst #9740 = PseudoVSSSEG7E8_V_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7555] }, // Inst #9739 = PseudoVSSSEG7E8_V_MF4 + { 6, &RISCVDescs.OperandInfo[7560] }, // Inst #9738 = PseudoVSSSEG7E8_V_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7555] }, // Inst #9737 = PseudoVSSSEG7E8_V_MF2 + { 6, &RISCVDescs.OperandInfo[7560] }, // Inst #9736 = PseudoVSSSEG7E8_V_M1_MASK + { 5, &RISCVDescs.OperandInfo[7555] }, // Inst #9735 = PseudoVSSSEG7E8_V_M1 + { 6, &RISCVDescs.OperandInfo[7560] }, // Inst #9734 = PseudoVSSSEG7E64_V_M1_MASK + { 5, &RISCVDescs.OperandInfo[7555] }, // Inst #9733 = PseudoVSSSEG7E64_V_M1 + { 6, &RISCVDescs.OperandInfo[7560] }, // Inst #9732 = PseudoVSSSEG7E32_V_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7555] }, // Inst #9731 = PseudoVSSSEG7E32_V_MF2 + { 6, &RISCVDescs.OperandInfo[7560] }, // Inst #9730 = PseudoVSSSEG7E32_V_M1_MASK + { 5, &RISCVDescs.OperandInfo[7555] }, // Inst #9729 = PseudoVSSSEG7E32_V_M1 + { 6, &RISCVDescs.OperandInfo[7560] }, // Inst #9728 = PseudoVSSSEG7E16_V_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7555] }, // Inst #9727 = PseudoVSSSEG7E16_V_MF4 + { 6, &RISCVDescs.OperandInfo[7560] }, // Inst #9726 = PseudoVSSSEG7E16_V_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7555] }, // Inst #9725 = PseudoVSSSEG7E16_V_MF2 + { 6, &RISCVDescs.OperandInfo[7560] }, // Inst #9724 = PseudoVSSSEG7E16_V_M1_MASK + { 5, &RISCVDescs.OperandInfo[7555] }, // Inst #9723 = PseudoVSSSEG7E16_V_M1 + { 6, &RISCVDescs.OperandInfo[7549] }, // Inst #9722 = PseudoVSSSEG6E8_V_MF8_MASK + { 5, &RISCVDescs.OperandInfo[7544] }, // Inst #9721 = PseudoVSSSEG6E8_V_MF8 + { 6, &RISCVDescs.OperandInfo[7549] }, // Inst #9720 = PseudoVSSSEG6E8_V_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7544] }, // Inst #9719 = PseudoVSSSEG6E8_V_MF4 + { 6, &RISCVDescs.OperandInfo[7549] }, // Inst #9718 = PseudoVSSSEG6E8_V_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7544] }, // Inst #9717 = PseudoVSSSEG6E8_V_MF2 + { 6, &RISCVDescs.OperandInfo[7549] }, // Inst #9716 = PseudoVSSSEG6E8_V_M1_MASK + { 5, &RISCVDescs.OperandInfo[7544] }, // Inst #9715 = PseudoVSSSEG6E8_V_M1 + { 6, &RISCVDescs.OperandInfo[7549] }, // Inst #9714 = PseudoVSSSEG6E64_V_M1_MASK + { 5, &RISCVDescs.OperandInfo[7544] }, // Inst #9713 = PseudoVSSSEG6E64_V_M1 + { 6, &RISCVDescs.OperandInfo[7549] }, // Inst #9712 = PseudoVSSSEG6E32_V_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7544] }, // Inst #9711 = PseudoVSSSEG6E32_V_MF2 + { 6, &RISCVDescs.OperandInfo[7549] }, // Inst #9710 = PseudoVSSSEG6E32_V_M1_MASK + { 5, &RISCVDescs.OperandInfo[7544] }, // Inst #9709 = PseudoVSSSEG6E32_V_M1 + { 6, &RISCVDescs.OperandInfo[7549] }, // Inst #9708 = PseudoVSSSEG6E16_V_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7544] }, // Inst #9707 = PseudoVSSSEG6E16_V_MF4 + { 6, &RISCVDescs.OperandInfo[7549] }, // Inst #9706 = PseudoVSSSEG6E16_V_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7544] }, // Inst #9705 = PseudoVSSSEG6E16_V_MF2 + { 6, &RISCVDescs.OperandInfo[7549] }, // Inst #9704 = PseudoVSSSEG6E16_V_M1_MASK + { 5, &RISCVDescs.OperandInfo[7544] }, // Inst #9703 = PseudoVSSSEG6E16_V_M1 + { 6, &RISCVDescs.OperandInfo[7538] }, // Inst #9702 = PseudoVSSSEG5E8_V_MF8_MASK + { 5, &RISCVDescs.OperandInfo[7533] }, // Inst #9701 = PseudoVSSSEG5E8_V_MF8 + { 6, &RISCVDescs.OperandInfo[7538] }, // Inst #9700 = PseudoVSSSEG5E8_V_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7533] }, // Inst #9699 = PseudoVSSSEG5E8_V_MF4 + { 6, &RISCVDescs.OperandInfo[7538] }, // Inst #9698 = PseudoVSSSEG5E8_V_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7533] }, // Inst #9697 = PseudoVSSSEG5E8_V_MF2 + { 6, &RISCVDescs.OperandInfo[7538] }, // Inst #9696 = PseudoVSSSEG5E8_V_M1_MASK + { 5, &RISCVDescs.OperandInfo[7533] }, // Inst #9695 = PseudoVSSSEG5E8_V_M1 + { 6, &RISCVDescs.OperandInfo[7538] }, // Inst #9694 = PseudoVSSSEG5E64_V_M1_MASK + { 5, &RISCVDescs.OperandInfo[7533] }, // Inst #9693 = PseudoVSSSEG5E64_V_M1 + { 6, &RISCVDescs.OperandInfo[7538] }, // Inst #9692 = PseudoVSSSEG5E32_V_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7533] }, // Inst #9691 = PseudoVSSSEG5E32_V_MF2 + { 6, &RISCVDescs.OperandInfo[7538] }, // Inst #9690 = PseudoVSSSEG5E32_V_M1_MASK + { 5, &RISCVDescs.OperandInfo[7533] }, // Inst #9689 = PseudoVSSSEG5E32_V_M1 + { 6, &RISCVDescs.OperandInfo[7538] }, // Inst #9688 = PseudoVSSSEG5E16_V_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7533] }, // Inst #9687 = PseudoVSSSEG5E16_V_MF4 + { 6, &RISCVDescs.OperandInfo[7538] }, // Inst #9686 = PseudoVSSSEG5E16_V_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7533] }, // Inst #9685 = PseudoVSSSEG5E16_V_MF2 + { 6, &RISCVDescs.OperandInfo[7538] }, // Inst #9684 = PseudoVSSSEG5E16_V_M1_MASK + { 5, &RISCVDescs.OperandInfo[7533] }, // Inst #9683 = PseudoVSSSEG5E16_V_M1 + { 6, &RISCVDescs.OperandInfo[7516] }, // Inst #9682 = PseudoVSSSEG4E8_V_MF8_MASK + { 5, &RISCVDescs.OperandInfo[7511] }, // Inst #9681 = PseudoVSSSEG4E8_V_MF8 + { 6, &RISCVDescs.OperandInfo[7516] }, // Inst #9680 = PseudoVSSSEG4E8_V_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7511] }, // Inst #9679 = PseudoVSSSEG4E8_V_MF4 + { 6, &RISCVDescs.OperandInfo[7516] }, // Inst #9678 = PseudoVSSSEG4E8_V_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7511] }, // Inst #9677 = PseudoVSSSEG4E8_V_MF2 + { 6, &RISCVDescs.OperandInfo[7527] }, // Inst #9676 = PseudoVSSSEG4E8_V_M2_MASK + { 5, &RISCVDescs.OperandInfo[7522] }, // Inst #9675 = PseudoVSSSEG4E8_V_M2 + { 6, &RISCVDescs.OperandInfo[7516] }, // Inst #9674 = PseudoVSSSEG4E8_V_M1_MASK + { 5, &RISCVDescs.OperandInfo[7511] }, // Inst #9673 = PseudoVSSSEG4E8_V_M1 + { 6, &RISCVDescs.OperandInfo[7527] }, // Inst #9672 = PseudoVSSSEG4E64_V_M2_MASK + { 5, &RISCVDescs.OperandInfo[7522] }, // Inst #9671 = PseudoVSSSEG4E64_V_M2 + { 6, &RISCVDescs.OperandInfo[7516] }, // Inst #9670 = PseudoVSSSEG4E64_V_M1_MASK + { 5, &RISCVDescs.OperandInfo[7511] }, // Inst #9669 = PseudoVSSSEG4E64_V_M1 + { 6, &RISCVDescs.OperandInfo[7516] }, // Inst #9668 = PseudoVSSSEG4E32_V_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7511] }, // Inst #9667 = PseudoVSSSEG4E32_V_MF2 + { 6, &RISCVDescs.OperandInfo[7527] }, // Inst #9666 = PseudoVSSSEG4E32_V_M2_MASK + { 5, &RISCVDescs.OperandInfo[7522] }, // Inst #9665 = PseudoVSSSEG4E32_V_M2 + { 6, &RISCVDescs.OperandInfo[7516] }, // Inst #9664 = PseudoVSSSEG4E32_V_M1_MASK + { 5, &RISCVDescs.OperandInfo[7511] }, // Inst #9663 = PseudoVSSSEG4E32_V_M1 + { 6, &RISCVDescs.OperandInfo[7516] }, // Inst #9662 = PseudoVSSSEG4E16_V_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7511] }, // Inst #9661 = PseudoVSSSEG4E16_V_MF4 + { 6, &RISCVDescs.OperandInfo[7516] }, // Inst #9660 = PseudoVSSSEG4E16_V_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7511] }, // Inst #9659 = PseudoVSSSEG4E16_V_MF2 + { 6, &RISCVDescs.OperandInfo[7527] }, // Inst #9658 = PseudoVSSSEG4E16_V_M2_MASK + { 5, &RISCVDescs.OperandInfo[7522] }, // Inst #9657 = PseudoVSSSEG4E16_V_M2 + { 6, &RISCVDescs.OperandInfo[7516] }, // Inst #9656 = PseudoVSSSEG4E16_V_M1_MASK + { 5, &RISCVDescs.OperandInfo[7511] }, // Inst #9655 = PseudoVSSSEG4E16_V_M1 + { 6, &RISCVDescs.OperandInfo[7494] }, // Inst #9654 = PseudoVSSSEG3E8_V_MF8_MASK + { 5, &RISCVDescs.OperandInfo[7489] }, // Inst #9653 = PseudoVSSSEG3E8_V_MF8 + { 6, &RISCVDescs.OperandInfo[7494] }, // Inst #9652 = PseudoVSSSEG3E8_V_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7489] }, // Inst #9651 = PseudoVSSSEG3E8_V_MF4 + { 6, &RISCVDescs.OperandInfo[7494] }, // Inst #9650 = PseudoVSSSEG3E8_V_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7489] }, // Inst #9649 = PseudoVSSSEG3E8_V_MF2 + { 6, &RISCVDescs.OperandInfo[7505] }, // Inst #9648 = PseudoVSSSEG3E8_V_M2_MASK + { 5, &RISCVDescs.OperandInfo[7500] }, // Inst #9647 = PseudoVSSSEG3E8_V_M2 + { 6, &RISCVDescs.OperandInfo[7494] }, // Inst #9646 = PseudoVSSSEG3E8_V_M1_MASK + { 5, &RISCVDescs.OperandInfo[7489] }, // Inst #9645 = PseudoVSSSEG3E8_V_M1 + { 6, &RISCVDescs.OperandInfo[7505] }, // Inst #9644 = PseudoVSSSEG3E64_V_M2_MASK + { 5, &RISCVDescs.OperandInfo[7500] }, // Inst #9643 = PseudoVSSSEG3E64_V_M2 + { 6, &RISCVDescs.OperandInfo[7494] }, // Inst #9642 = PseudoVSSSEG3E64_V_M1_MASK + { 5, &RISCVDescs.OperandInfo[7489] }, // Inst #9641 = PseudoVSSSEG3E64_V_M1 + { 6, &RISCVDescs.OperandInfo[7494] }, // Inst #9640 = PseudoVSSSEG3E32_V_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7489] }, // Inst #9639 = PseudoVSSSEG3E32_V_MF2 + { 6, &RISCVDescs.OperandInfo[7505] }, // Inst #9638 = PseudoVSSSEG3E32_V_M2_MASK + { 5, &RISCVDescs.OperandInfo[7500] }, // Inst #9637 = PseudoVSSSEG3E32_V_M2 + { 6, &RISCVDescs.OperandInfo[7494] }, // Inst #9636 = PseudoVSSSEG3E32_V_M1_MASK + { 5, &RISCVDescs.OperandInfo[7489] }, // Inst #9635 = PseudoVSSSEG3E32_V_M1 + { 6, &RISCVDescs.OperandInfo[7494] }, // Inst #9634 = PseudoVSSSEG3E16_V_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7489] }, // Inst #9633 = PseudoVSSSEG3E16_V_MF4 + { 6, &RISCVDescs.OperandInfo[7494] }, // Inst #9632 = PseudoVSSSEG3E16_V_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7489] }, // Inst #9631 = PseudoVSSSEG3E16_V_MF2 + { 6, &RISCVDescs.OperandInfo[7505] }, // Inst #9630 = PseudoVSSSEG3E16_V_M2_MASK + { 5, &RISCVDescs.OperandInfo[7500] }, // Inst #9629 = PseudoVSSSEG3E16_V_M2 + { 6, &RISCVDescs.OperandInfo[7494] }, // Inst #9628 = PseudoVSSSEG3E16_V_M1_MASK + { 5, &RISCVDescs.OperandInfo[7489] }, // Inst #9627 = PseudoVSSSEG3E16_V_M1 + { 6, &RISCVDescs.OperandInfo[7461] }, // Inst #9626 = PseudoVSSSEG2E8_V_MF8_MASK + { 5, &RISCVDescs.OperandInfo[7456] }, // Inst #9625 = PseudoVSSSEG2E8_V_MF8 + { 6, &RISCVDescs.OperandInfo[7461] }, // Inst #9624 = PseudoVSSSEG2E8_V_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7456] }, // Inst #9623 = PseudoVSSSEG2E8_V_MF4 + { 6, &RISCVDescs.OperandInfo[7461] }, // Inst #9622 = PseudoVSSSEG2E8_V_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7456] }, // Inst #9621 = PseudoVSSSEG2E8_V_MF2 + { 6, &RISCVDescs.OperandInfo[7483] }, // Inst #9620 = PseudoVSSSEG2E8_V_M4_MASK + { 5, &RISCVDescs.OperandInfo[7478] }, // Inst #9619 = PseudoVSSSEG2E8_V_M4 + { 6, &RISCVDescs.OperandInfo[7472] }, // Inst #9618 = PseudoVSSSEG2E8_V_M2_MASK + { 5, &RISCVDescs.OperandInfo[7467] }, // Inst #9617 = PseudoVSSSEG2E8_V_M2 + { 6, &RISCVDescs.OperandInfo[7461] }, // Inst #9616 = PseudoVSSSEG2E8_V_M1_MASK + { 5, &RISCVDescs.OperandInfo[7456] }, // Inst #9615 = PseudoVSSSEG2E8_V_M1 + { 6, &RISCVDescs.OperandInfo[7483] }, // Inst #9614 = PseudoVSSSEG2E64_V_M4_MASK + { 5, &RISCVDescs.OperandInfo[7478] }, // Inst #9613 = PseudoVSSSEG2E64_V_M4 + { 6, &RISCVDescs.OperandInfo[7472] }, // Inst #9612 = PseudoVSSSEG2E64_V_M2_MASK + { 5, &RISCVDescs.OperandInfo[7467] }, // Inst #9611 = PseudoVSSSEG2E64_V_M2 + { 6, &RISCVDescs.OperandInfo[7461] }, // Inst #9610 = PseudoVSSSEG2E64_V_M1_MASK + { 5, &RISCVDescs.OperandInfo[7456] }, // Inst #9609 = PseudoVSSSEG2E64_V_M1 + { 6, &RISCVDescs.OperandInfo[7461] }, // Inst #9608 = PseudoVSSSEG2E32_V_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7456] }, // Inst #9607 = PseudoVSSSEG2E32_V_MF2 + { 6, &RISCVDescs.OperandInfo[7483] }, // Inst #9606 = PseudoVSSSEG2E32_V_M4_MASK + { 5, &RISCVDescs.OperandInfo[7478] }, // Inst #9605 = PseudoVSSSEG2E32_V_M4 + { 6, &RISCVDescs.OperandInfo[7472] }, // Inst #9604 = PseudoVSSSEG2E32_V_M2_MASK + { 5, &RISCVDescs.OperandInfo[7467] }, // Inst #9603 = PseudoVSSSEG2E32_V_M2 + { 6, &RISCVDescs.OperandInfo[7461] }, // Inst #9602 = PseudoVSSSEG2E32_V_M1_MASK + { 5, &RISCVDescs.OperandInfo[7456] }, // Inst #9601 = PseudoVSSSEG2E32_V_M1 + { 6, &RISCVDescs.OperandInfo[7461] }, // Inst #9600 = PseudoVSSSEG2E16_V_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7456] }, // Inst #9599 = PseudoVSSSEG2E16_V_MF4 + { 6, &RISCVDescs.OperandInfo[7461] }, // Inst #9598 = PseudoVSSSEG2E16_V_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7456] }, // Inst #9597 = PseudoVSSSEG2E16_V_MF2 + { 6, &RISCVDescs.OperandInfo[7483] }, // Inst #9596 = PseudoVSSSEG2E16_V_M4_MASK + { 5, &RISCVDescs.OperandInfo[7478] }, // Inst #9595 = PseudoVSSSEG2E16_V_M4 + { 6, &RISCVDescs.OperandInfo[7472] }, // Inst #9594 = PseudoVSSSEG2E16_V_M2_MASK + { 5, &RISCVDescs.OperandInfo[7467] }, // Inst #9593 = PseudoVSSSEG2E16_V_M2 + { 6, &RISCVDescs.OperandInfo[7461] }, // Inst #9592 = PseudoVSSSEG2E16_V_M1_MASK + { 5, &RISCVDescs.OperandInfo[7456] }, // Inst #9591 = PseudoVSSSEG2E16_V_M1 + { 9, &RISCVDescs.OperandInfo[493] }, // Inst #9590 = PseudoVSSRL_VX_MF8_MASK + { 8, &RISCVDescs.OperandInfo[485] }, // Inst #9589 = PseudoVSSRL_VX_MF8 + { 9, &RISCVDescs.OperandInfo[493] }, // Inst #9588 = PseudoVSSRL_VX_MF4_MASK + { 8, &RISCVDescs.OperandInfo[485] }, // Inst #9587 = PseudoVSSRL_VX_MF4 + { 9, &RISCVDescs.OperandInfo[493] }, // Inst #9586 = PseudoVSSRL_VX_MF2_MASK + { 8, &RISCVDescs.OperandInfo[485] }, // Inst #9585 = PseudoVSSRL_VX_MF2 + { 9, &RISCVDescs.OperandInfo[544] }, // Inst #9584 = PseudoVSSRL_VX_M8_MASK + { 8, &RISCVDescs.OperandInfo[536] }, // Inst #9583 = PseudoVSSRL_VX_M8 + { 9, &RISCVDescs.OperandInfo[527] }, // Inst #9582 = PseudoVSSRL_VX_M4_MASK + { 8, &RISCVDescs.OperandInfo[519] }, // Inst #9581 = PseudoVSSRL_VX_M4 + { 9, &RISCVDescs.OperandInfo[510] }, // Inst #9580 = PseudoVSSRL_VX_M2_MASK + { 8, &RISCVDescs.OperandInfo[502] }, // Inst #9579 = PseudoVSSRL_VX_M2 + { 9, &RISCVDescs.OperandInfo[493] }, // Inst #9578 = PseudoVSSRL_VX_M1_MASK + { 8, &RISCVDescs.OperandInfo[485] }, // Inst #9577 = PseudoVSSRL_VX_M1 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #9576 = PseudoVSSRL_VV_MF8_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #9575 = PseudoVSSRL_VV_MF8 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #9574 = PseudoVSSRL_VV_MF4_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #9573 = PseudoVSSRL_VV_MF4 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #9572 = PseudoVSSRL_VV_MF2_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #9571 = PseudoVSSRL_VV_MF2 + { 9, &RISCVDescs.OperandInfo[476] }, // Inst #9570 = PseudoVSSRL_VV_M8_MASK + { 8, &RISCVDescs.OperandInfo[468] }, // Inst #9569 = PseudoVSSRL_VV_M8 + { 9, &RISCVDescs.OperandInfo[459] }, // Inst #9568 = PseudoVSSRL_VV_M4_MASK + { 8, &RISCVDescs.OperandInfo[451] }, // Inst #9567 = PseudoVSSRL_VV_M4 + { 9, &RISCVDescs.OperandInfo[442] }, // Inst #9566 = PseudoVSSRL_VV_M2_MASK + { 8, &RISCVDescs.OperandInfo[434] }, // Inst #9565 = PseudoVSSRL_VV_M2 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #9564 = PseudoVSSRL_VV_M1_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #9563 = PseudoVSSRL_VV_M1 + { 9, &RISCVDescs.OperandInfo[5923] }, // Inst #9562 = PseudoVSSRL_VI_MF8_MASK + { 8, &RISCVDescs.OperandInfo[5915] }, // Inst #9561 = PseudoVSSRL_VI_MF8 + { 9, &RISCVDescs.OperandInfo[5923] }, // Inst #9560 = PseudoVSSRL_VI_MF4_MASK + { 8, &RISCVDescs.OperandInfo[5915] }, // Inst #9559 = PseudoVSSRL_VI_MF4 + { 9, &RISCVDescs.OperandInfo[5923] }, // Inst #9558 = PseudoVSSRL_VI_MF2_MASK + { 8, &RISCVDescs.OperandInfo[5915] }, // Inst #9557 = PseudoVSSRL_VI_MF2 + { 9, &RISCVDescs.OperandInfo[7447] }, // Inst #9556 = PseudoVSSRL_VI_M8_MASK + { 8, &RISCVDescs.OperandInfo[7439] }, // Inst #9555 = PseudoVSSRL_VI_M8 + { 9, &RISCVDescs.OperandInfo[7430] }, // Inst #9554 = PseudoVSSRL_VI_M4_MASK + { 8, &RISCVDescs.OperandInfo[7422] }, // Inst #9553 = PseudoVSSRL_VI_M4 + { 9, &RISCVDescs.OperandInfo[7413] }, // Inst #9552 = PseudoVSSRL_VI_M2_MASK + { 8, &RISCVDescs.OperandInfo[7405] }, // Inst #9551 = PseudoVSSRL_VI_M2 + { 9, &RISCVDescs.OperandInfo[5923] }, // Inst #9550 = PseudoVSSRL_VI_M1_MASK + { 8, &RISCVDescs.OperandInfo[5915] }, // Inst #9549 = PseudoVSSRL_VI_M1 + { 9, &RISCVDescs.OperandInfo[493] }, // Inst #9548 = PseudoVSSRA_VX_MF8_MASK + { 8, &RISCVDescs.OperandInfo[485] }, // Inst #9547 = PseudoVSSRA_VX_MF8 + { 9, &RISCVDescs.OperandInfo[493] }, // Inst #9546 = PseudoVSSRA_VX_MF4_MASK + { 8, &RISCVDescs.OperandInfo[485] }, // Inst #9545 = PseudoVSSRA_VX_MF4 + { 9, &RISCVDescs.OperandInfo[493] }, // Inst #9544 = PseudoVSSRA_VX_MF2_MASK + { 8, &RISCVDescs.OperandInfo[485] }, // Inst #9543 = PseudoVSSRA_VX_MF2 + { 9, &RISCVDescs.OperandInfo[544] }, // Inst #9542 = PseudoVSSRA_VX_M8_MASK + { 8, &RISCVDescs.OperandInfo[536] }, // Inst #9541 = PseudoVSSRA_VX_M8 + { 9, &RISCVDescs.OperandInfo[527] }, // Inst #9540 = PseudoVSSRA_VX_M4_MASK + { 8, &RISCVDescs.OperandInfo[519] }, // Inst #9539 = PseudoVSSRA_VX_M4 + { 9, &RISCVDescs.OperandInfo[510] }, // Inst #9538 = PseudoVSSRA_VX_M2_MASK + { 8, &RISCVDescs.OperandInfo[502] }, // Inst #9537 = PseudoVSSRA_VX_M2 + { 9, &RISCVDescs.OperandInfo[493] }, // Inst #9536 = PseudoVSSRA_VX_M1_MASK + { 8, &RISCVDescs.OperandInfo[485] }, // Inst #9535 = PseudoVSSRA_VX_M1 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #9534 = PseudoVSSRA_VV_MF8_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #9533 = PseudoVSSRA_VV_MF8 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #9532 = PseudoVSSRA_VV_MF4_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #9531 = PseudoVSSRA_VV_MF4 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #9530 = PseudoVSSRA_VV_MF2_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #9529 = PseudoVSSRA_VV_MF2 + { 9, &RISCVDescs.OperandInfo[476] }, // Inst #9528 = PseudoVSSRA_VV_M8_MASK + { 8, &RISCVDescs.OperandInfo[468] }, // Inst #9527 = PseudoVSSRA_VV_M8 + { 9, &RISCVDescs.OperandInfo[459] }, // Inst #9526 = PseudoVSSRA_VV_M4_MASK + { 8, &RISCVDescs.OperandInfo[451] }, // Inst #9525 = PseudoVSSRA_VV_M4 + { 9, &RISCVDescs.OperandInfo[442] }, // Inst #9524 = PseudoVSSRA_VV_M2_MASK + { 8, &RISCVDescs.OperandInfo[434] }, // Inst #9523 = PseudoVSSRA_VV_M2 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #9522 = PseudoVSSRA_VV_M1_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #9521 = PseudoVSSRA_VV_M1 + { 9, &RISCVDescs.OperandInfo[5923] }, // Inst #9520 = PseudoVSSRA_VI_MF8_MASK + { 8, &RISCVDescs.OperandInfo[5915] }, // Inst #9519 = PseudoVSSRA_VI_MF8 + { 9, &RISCVDescs.OperandInfo[5923] }, // Inst #9518 = PseudoVSSRA_VI_MF4_MASK + { 8, &RISCVDescs.OperandInfo[5915] }, // Inst #9517 = PseudoVSSRA_VI_MF4 + { 9, &RISCVDescs.OperandInfo[5923] }, // Inst #9516 = PseudoVSSRA_VI_MF2_MASK + { 8, &RISCVDescs.OperandInfo[5915] }, // Inst #9515 = PseudoVSSRA_VI_MF2 + { 9, &RISCVDescs.OperandInfo[7447] }, // Inst #9514 = PseudoVSSRA_VI_M8_MASK + { 8, &RISCVDescs.OperandInfo[7439] }, // Inst #9513 = PseudoVSSRA_VI_M8 + { 9, &RISCVDescs.OperandInfo[7430] }, // Inst #9512 = PseudoVSSRA_VI_M4_MASK + { 8, &RISCVDescs.OperandInfo[7422] }, // Inst #9511 = PseudoVSSRA_VI_M4 + { 9, &RISCVDescs.OperandInfo[7413] }, // Inst #9510 = PseudoVSSRA_VI_M2_MASK + { 8, &RISCVDescs.OperandInfo[7405] }, // Inst #9509 = PseudoVSSRA_VI_M2 + { 9, &RISCVDescs.OperandInfo[5923] }, // Inst #9508 = PseudoVSSRA_VI_M1_MASK + { 8, &RISCVDescs.OperandInfo[5915] }, // Inst #9507 = PseudoVSSRA_VI_M1 + { 5, &RISCVDescs.OperandInfo[7400] }, // Inst #9506 = PseudoVSSEG8E8_V_MF8_MASK + { 4, &RISCVDescs.OperandInfo[7396] }, // Inst #9505 = PseudoVSSEG8E8_V_MF8 + { 5, &RISCVDescs.OperandInfo[7400] }, // Inst #9504 = PseudoVSSEG8E8_V_MF4_MASK + { 4, &RISCVDescs.OperandInfo[7396] }, // Inst #9503 = PseudoVSSEG8E8_V_MF4 + { 5, &RISCVDescs.OperandInfo[7400] }, // Inst #9502 = PseudoVSSEG8E8_V_MF2_MASK + { 4, &RISCVDescs.OperandInfo[7396] }, // Inst #9501 = PseudoVSSEG8E8_V_MF2 + { 5, &RISCVDescs.OperandInfo[7400] }, // Inst #9500 = PseudoVSSEG8E8_V_M1_MASK + { 4, &RISCVDescs.OperandInfo[7396] }, // Inst #9499 = PseudoVSSEG8E8_V_M1 + { 5, &RISCVDescs.OperandInfo[7400] }, // Inst #9498 = PseudoVSSEG8E64_V_M1_MASK + { 4, &RISCVDescs.OperandInfo[7396] }, // Inst #9497 = PseudoVSSEG8E64_V_M1 + { 5, &RISCVDescs.OperandInfo[7400] }, // Inst #9496 = PseudoVSSEG8E32_V_MF2_MASK + { 4, &RISCVDescs.OperandInfo[7396] }, // Inst #9495 = PseudoVSSEG8E32_V_MF2 + { 5, &RISCVDescs.OperandInfo[7400] }, // Inst #9494 = PseudoVSSEG8E32_V_M1_MASK + { 4, &RISCVDescs.OperandInfo[7396] }, // Inst #9493 = PseudoVSSEG8E32_V_M1 + { 5, &RISCVDescs.OperandInfo[7400] }, // Inst #9492 = PseudoVSSEG8E16_V_MF4_MASK + { 4, &RISCVDescs.OperandInfo[7396] }, // Inst #9491 = PseudoVSSEG8E16_V_MF4 + { 5, &RISCVDescs.OperandInfo[7400] }, // Inst #9490 = PseudoVSSEG8E16_V_MF2_MASK + { 4, &RISCVDescs.OperandInfo[7396] }, // Inst #9489 = PseudoVSSEG8E16_V_MF2 + { 5, &RISCVDescs.OperandInfo[7400] }, // Inst #9488 = PseudoVSSEG8E16_V_M1_MASK + { 4, &RISCVDescs.OperandInfo[7396] }, // Inst #9487 = PseudoVSSEG8E16_V_M1 + { 5, &RISCVDescs.OperandInfo[7391] }, // Inst #9486 = PseudoVSSEG7E8_V_MF8_MASK + { 4, &RISCVDescs.OperandInfo[7387] }, // Inst #9485 = PseudoVSSEG7E8_V_MF8 + { 5, &RISCVDescs.OperandInfo[7391] }, // Inst #9484 = PseudoVSSEG7E8_V_MF4_MASK + { 4, &RISCVDescs.OperandInfo[7387] }, // Inst #9483 = PseudoVSSEG7E8_V_MF4 + { 5, &RISCVDescs.OperandInfo[7391] }, // Inst #9482 = PseudoVSSEG7E8_V_MF2_MASK + { 4, &RISCVDescs.OperandInfo[7387] }, // Inst #9481 = PseudoVSSEG7E8_V_MF2 + { 5, &RISCVDescs.OperandInfo[7391] }, // Inst #9480 = PseudoVSSEG7E8_V_M1_MASK + { 4, &RISCVDescs.OperandInfo[7387] }, // Inst #9479 = PseudoVSSEG7E8_V_M1 + { 5, &RISCVDescs.OperandInfo[7391] }, // Inst #9478 = PseudoVSSEG7E64_V_M1_MASK + { 4, &RISCVDescs.OperandInfo[7387] }, // Inst #9477 = PseudoVSSEG7E64_V_M1 + { 5, &RISCVDescs.OperandInfo[7391] }, // Inst #9476 = PseudoVSSEG7E32_V_MF2_MASK + { 4, &RISCVDescs.OperandInfo[7387] }, // Inst #9475 = PseudoVSSEG7E32_V_MF2 + { 5, &RISCVDescs.OperandInfo[7391] }, // Inst #9474 = PseudoVSSEG7E32_V_M1_MASK + { 4, &RISCVDescs.OperandInfo[7387] }, // Inst #9473 = PseudoVSSEG7E32_V_M1 + { 5, &RISCVDescs.OperandInfo[7391] }, // Inst #9472 = PseudoVSSEG7E16_V_MF4_MASK + { 4, &RISCVDescs.OperandInfo[7387] }, // Inst #9471 = PseudoVSSEG7E16_V_MF4 + { 5, &RISCVDescs.OperandInfo[7391] }, // Inst #9470 = PseudoVSSEG7E16_V_MF2_MASK + { 4, &RISCVDescs.OperandInfo[7387] }, // Inst #9469 = PseudoVSSEG7E16_V_MF2 + { 5, &RISCVDescs.OperandInfo[7391] }, // Inst #9468 = PseudoVSSEG7E16_V_M1_MASK + { 4, &RISCVDescs.OperandInfo[7387] }, // Inst #9467 = PseudoVSSEG7E16_V_M1 + { 5, &RISCVDescs.OperandInfo[7382] }, // Inst #9466 = PseudoVSSEG6E8_V_MF8_MASK + { 4, &RISCVDescs.OperandInfo[7378] }, // Inst #9465 = PseudoVSSEG6E8_V_MF8 + { 5, &RISCVDescs.OperandInfo[7382] }, // Inst #9464 = PseudoVSSEG6E8_V_MF4_MASK + { 4, &RISCVDescs.OperandInfo[7378] }, // Inst #9463 = PseudoVSSEG6E8_V_MF4 + { 5, &RISCVDescs.OperandInfo[7382] }, // Inst #9462 = PseudoVSSEG6E8_V_MF2_MASK + { 4, &RISCVDescs.OperandInfo[7378] }, // Inst #9461 = PseudoVSSEG6E8_V_MF2 + { 5, &RISCVDescs.OperandInfo[7382] }, // Inst #9460 = PseudoVSSEG6E8_V_M1_MASK + { 4, &RISCVDescs.OperandInfo[7378] }, // Inst #9459 = PseudoVSSEG6E8_V_M1 + { 5, &RISCVDescs.OperandInfo[7382] }, // Inst #9458 = PseudoVSSEG6E64_V_M1_MASK + { 4, &RISCVDescs.OperandInfo[7378] }, // Inst #9457 = PseudoVSSEG6E64_V_M1 + { 5, &RISCVDescs.OperandInfo[7382] }, // Inst #9456 = PseudoVSSEG6E32_V_MF2_MASK + { 4, &RISCVDescs.OperandInfo[7378] }, // Inst #9455 = PseudoVSSEG6E32_V_MF2 + { 5, &RISCVDescs.OperandInfo[7382] }, // Inst #9454 = PseudoVSSEG6E32_V_M1_MASK + { 4, &RISCVDescs.OperandInfo[7378] }, // Inst #9453 = PseudoVSSEG6E32_V_M1 + { 5, &RISCVDescs.OperandInfo[7382] }, // Inst #9452 = PseudoVSSEG6E16_V_MF4_MASK + { 4, &RISCVDescs.OperandInfo[7378] }, // Inst #9451 = PseudoVSSEG6E16_V_MF4 + { 5, &RISCVDescs.OperandInfo[7382] }, // Inst #9450 = PseudoVSSEG6E16_V_MF2_MASK + { 4, &RISCVDescs.OperandInfo[7378] }, // Inst #9449 = PseudoVSSEG6E16_V_MF2 + { 5, &RISCVDescs.OperandInfo[7382] }, // Inst #9448 = PseudoVSSEG6E16_V_M1_MASK + { 4, &RISCVDescs.OperandInfo[7378] }, // Inst #9447 = PseudoVSSEG6E16_V_M1 + { 5, &RISCVDescs.OperandInfo[7373] }, // Inst #9446 = PseudoVSSEG5E8_V_MF8_MASK + { 4, &RISCVDescs.OperandInfo[7369] }, // Inst #9445 = PseudoVSSEG5E8_V_MF8 + { 5, &RISCVDescs.OperandInfo[7373] }, // Inst #9444 = PseudoVSSEG5E8_V_MF4_MASK + { 4, &RISCVDescs.OperandInfo[7369] }, // Inst #9443 = PseudoVSSEG5E8_V_MF4 + { 5, &RISCVDescs.OperandInfo[7373] }, // Inst #9442 = PseudoVSSEG5E8_V_MF2_MASK + { 4, &RISCVDescs.OperandInfo[7369] }, // Inst #9441 = PseudoVSSEG5E8_V_MF2 + { 5, &RISCVDescs.OperandInfo[7373] }, // Inst #9440 = PseudoVSSEG5E8_V_M1_MASK + { 4, &RISCVDescs.OperandInfo[7369] }, // Inst #9439 = PseudoVSSEG5E8_V_M1 + { 5, &RISCVDescs.OperandInfo[7373] }, // Inst #9438 = PseudoVSSEG5E64_V_M1_MASK + { 4, &RISCVDescs.OperandInfo[7369] }, // Inst #9437 = PseudoVSSEG5E64_V_M1 + { 5, &RISCVDescs.OperandInfo[7373] }, // Inst #9436 = PseudoVSSEG5E32_V_MF2_MASK + { 4, &RISCVDescs.OperandInfo[7369] }, // Inst #9435 = PseudoVSSEG5E32_V_MF2 + { 5, &RISCVDescs.OperandInfo[7373] }, // Inst #9434 = PseudoVSSEG5E32_V_M1_MASK + { 4, &RISCVDescs.OperandInfo[7369] }, // Inst #9433 = PseudoVSSEG5E32_V_M1 + { 5, &RISCVDescs.OperandInfo[7373] }, // Inst #9432 = PseudoVSSEG5E16_V_MF4_MASK + { 4, &RISCVDescs.OperandInfo[7369] }, // Inst #9431 = PseudoVSSEG5E16_V_MF4 + { 5, &RISCVDescs.OperandInfo[7373] }, // Inst #9430 = PseudoVSSEG5E16_V_MF2_MASK + { 4, &RISCVDescs.OperandInfo[7369] }, // Inst #9429 = PseudoVSSEG5E16_V_MF2 + { 5, &RISCVDescs.OperandInfo[7373] }, // Inst #9428 = PseudoVSSEG5E16_V_M1_MASK + { 4, &RISCVDescs.OperandInfo[7369] }, // Inst #9427 = PseudoVSSEG5E16_V_M1 + { 5, &RISCVDescs.OperandInfo[7355] }, // Inst #9426 = PseudoVSSEG4E8_V_MF8_MASK + { 4, &RISCVDescs.OperandInfo[7351] }, // Inst #9425 = PseudoVSSEG4E8_V_MF8 + { 5, &RISCVDescs.OperandInfo[7355] }, // Inst #9424 = PseudoVSSEG4E8_V_MF4_MASK + { 4, &RISCVDescs.OperandInfo[7351] }, // Inst #9423 = PseudoVSSEG4E8_V_MF4 + { 5, &RISCVDescs.OperandInfo[7355] }, // Inst #9422 = PseudoVSSEG4E8_V_MF2_MASK + { 4, &RISCVDescs.OperandInfo[7351] }, // Inst #9421 = PseudoVSSEG4E8_V_MF2 + { 5, &RISCVDescs.OperandInfo[7364] }, // Inst #9420 = PseudoVSSEG4E8_V_M2_MASK + { 4, &RISCVDescs.OperandInfo[7360] }, // Inst #9419 = PseudoVSSEG4E8_V_M2 + { 5, &RISCVDescs.OperandInfo[7355] }, // Inst #9418 = PseudoVSSEG4E8_V_M1_MASK + { 4, &RISCVDescs.OperandInfo[7351] }, // Inst #9417 = PseudoVSSEG4E8_V_M1 + { 5, &RISCVDescs.OperandInfo[7364] }, // Inst #9416 = PseudoVSSEG4E64_V_M2_MASK + { 4, &RISCVDescs.OperandInfo[7360] }, // Inst #9415 = PseudoVSSEG4E64_V_M2 + { 5, &RISCVDescs.OperandInfo[7355] }, // Inst #9414 = PseudoVSSEG4E64_V_M1_MASK + { 4, &RISCVDescs.OperandInfo[7351] }, // Inst #9413 = PseudoVSSEG4E64_V_M1 + { 5, &RISCVDescs.OperandInfo[7355] }, // Inst #9412 = PseudoVSSEG4E32_V_MF2_MASK + { 4, &RISCVDescs.OperandInfo[7351] }, // Inst #9411 = PseudoVSSEG4E32_V_MF2 + { 5, &RISCVDescs.OperandInfo[7364] }, // Inst #9410 = PseudoVSSEG4E32_V_M2_MASK + { 4, &RISCVDescs.OperandInfo[7360] }, // Inst #9409 = PseudoVSSEG4E32_V_M2 + { 5, &RISCVDescs.OperandInfo[7355] }, // Inst #9408 = PseudoVSSEG4E32_V_M1_MASK + { 4, &RISCVDescs.OperandInfo[7351] }, // Inst #9407 = PseudoVSSEG4E32_V_M1 + { 5, &RISCVDescs.OperandInfo[7355] }, // Inst #9406 = PseudoVSSEG4E16_V_MF4_MASK + { 4, &RISCVDescs.OperandInfo[7351] }, // Inst #9405 = PseudoVSSEG4E16_V_MF4 + { 5, &RISCVDescs.OperandInfo[7355] }, // Inst #9404 = PseudoVSSEG4E16_V_MF2_MASK + { 4, &RISCVDescs.OperandInfo[7351] }, // Inst #9403 = PseudoVSSEG4E16_V_MF2 + { 5, &RISCVDescs.OperandInfo[7364] }, // Inst #9402 = PseudoVSSEG4E16_V_M2_MASK + { 4, &RISCVDescs.OperandInfo[7360] }, // Inst #9401 = PseudoVSSEG4E16_V_M2 + { 5, &RISCVDescs.OperandInfo[7355] }, // Inst #9400 = PseudoVSSEG4E16_V_M1_MASK + { 4, &RISCVDescs.OperandInfo[7351] }, // Inst #9399 = PseudoVSSEG4E16_V_M1 + { 5, &RISCVDescs.OperandInfo[7337] }, // Inst #9398 = PseudoVSSEG3E8_V_MF8_MASK + { 4, &RISCVDescs.OperandInfo[7333] }, // Inst #9397 = PseudoVSSEG3E8_V_MF8 + { 5, &RISCVDescs.OperandInfo[7337] }, // Inst #9396 = PseudoVSSEG3E8_V_MF4_MASK + { 4, &RISCVDescs.OperandInfo[7333] }, // Inst #9395 = PseudoVSSEG3E8_V_MF4 + { 5, &RISCVDescs.OperandInfo[7337] }, // Inst #9394 = PseudoVSSEG3E8_V_MF2_MASK + { 4, &RISCVDescs.OperandInfo[7333] }, // Inst #9393 = PseudoVSSEG3E8_V_MF2 + { 5, &RISCVDescs.OperandInfo[7346] }, // Inst #9392 = PseudoVSSEG3E8_V_M2_MASK + { 4, &RISCVDescs.OperandInfo[7342] }, // Inst #9391 = PseudoVSSEG3E8_V_M2 + { 5, &RISCVDescs.OperandInfo[7337] }, // Inst #9390 = PseudoVSSEG3E8_V_M1_MASK + { 4, &RISCVDescs.OperandInfo[7333] }, // Inst #9389 = PseudoVSSEG3E8_V_M1 + { 5, &RISCVDescs.OperandInfo[7346] }, // Inst #9388 = PseudoVSSEG3E64_V_M2_MASK + { 4, &RISCVDescs.OperandInfo[7342] }, // Inst #9387 = PseudoVSSEG3E64_V_M2 + { 5, &RISCVDescs.OperandInfo[7337] }, // Inst #9386 = PseudoVSSEG3E64_V_M1_MASK + { 4, &RISCVDescs.OperandInfo[7333] }, // Inst #9385 = PseudoVSSEG3E64_V_M1 + { 5, &RISCVDescs.OperandInfo[7337] }, // Inst #9384 = PseudoVSSEG3E32_V_MF2_MASK + { 4, &RISCVDescs.OperandInfo[7333] }, // Inst #9383 = PseudoVSSEG3E32_V_MF2 + { 5, &RISCVDescs.OperandInfo[7346] }, // Inst #9382 = PseudoVSSEG3E32_V_M2_MASK + { 4, &RISCVDescs.OperandInfo[7342] }, // Inst #9381 = PseudoVSSEG3E32_V_M2 + { 5, &RISCVDescs.OperandInfo[7337] }, // Inst #9380 = PseudoVSSEG3E32_V_M1_MASK + { 4, &RISCVDescs.OperandInfo[7333] }, // Inst #9379 = PseudoVSSEG3E32_V_M1 + { 5, &RISCVDescs.OperandInfo[7337] }, // Inst #9378 = PseudoVSSEG3E16_V_MF4_MASK + { 4, &RISCVDescs.OperandInfo[7333] }, // Inst #9377 = PseudoVSSEG3E16_V_MF4 + { 5, &RISCVDescs.OperandInfo[7337] }, // Inst #9376 = PseudoVSSEG3E16_V_MF2_MASK + { 4, &RISCVDescs.OperandInfo[7333] }, // Inst #9375 = PseudoVSSEG3E16_V_MF2 + { 5, &RISCVDescs.OperandInfo[7346] }, // Inst #9374 = PseudoVSSEG3E16_V_M2_MASK + { 4, &RISCVDescs.OperandInfo[7342] }, // Inst #9373 = PseudoVSSEG3E16_V_M2 + { 5, &RISCVDescs.OperandInfo[7337] }, // Inst #9372 = PseudoVSSEG3E16_V_M1_MASK + { 4, &RISCVDescs.OperandInfo[7333] }, // Inst #9371 = PseudoVSSEG3E16_V_M1 + { 5, &RISCVDescs.OperandInfo[7310] }, // Inst #9370 = PseudoVSSEG2E8_V_MF8_MASK + { 4, &RISCVDescs.OperandInfo[7306] }, // Inst #9369 = PseudoVSSEG2E8_V_MF8 + { 5, &RISCVDescs.OperandInfo[7310] }, // Inst #9368 = PseudoVSSEG2E8_V_MF4_MASK + { 4, &RISCVDescs.OperandInfo[7306] }, // Inst #9367 = PseudoVSSEG2E8_V_MF4 + { 5, &RISCVDescs.OperandInfo[7310] }, // Inst #9366 = PseudoVSSEG2E8_V_MF2_MASK + { 4, &RISCVDescs.OperandInfo[7306] }, // Inst #9365 = PseudoVSSEG2E8_V_MF2 + { 5, &RISCVDescs.OperandInfo[7328] }, // Inst #9364 = PseudoVSSEG2E8_V_M4_MASK + { 4, &RISCVDescs.OperandInfo[7324] }, // Inst #9363 = PseudoVSSEG2E8_V_M4 + { 5, &RISCVDescs.OperandInfo[7319] }, // Inst #9362 = PseudoVSSEG2E8_V_M2_MASK + { 4, &RISCVDescs.OperandInfo[7315] }, // Inst #9361 = PseudoVSSEG2E8_V_M2 + { 5, &RISCVDescs.OperandInfo[7310] }, // Inst #9360 = PseudoVSSEG2E8_V_M1_MASK + { 4, &RISCVDescs.OperandInfo[7306] }, // Inst #9359 = PseudoVSSEG2E8_V_M1 + { 5, &RISCVDescs.OperandInfo[7328] }, // Inst #9358 = PseudoVSSEG2E64_V_M4_MASK + { 4, &RISCVDescs.OperandInfo[7324] }, // Inst #9357 = PseudoVSSEG2E64_V_M4 + { 5, &RISCVDescs.OperandInfo[7319] }, // Inst #9356 = PseudoVSSEG2E64_V_M2_MASK + { 4, &RISCVDescs.OperandInfo[7315] }, // Inst #9355 = PseudoVSSEG2E64_V_M2 + { 5, &RISCVDescs.OperandInfo[7310] }, // Inst #9354 = PseudoVSSEG2E64_V_M1_MASK + { 4, &RISCVDescs.OperandInfo[7306] }, // Inst #9353 = PseudoVSSEG2E64_V_M1 + { 5, &RISCVDescs.OperandInfo[7310] }, // Inst #9352 = PseudoVSSEG2E32_V_MF2_MASK + { 4, &RISCVDescs.OperandInfo[7306] }, // Inst #9351 = PseudoVSSEG2E32_V_MF2 + { 5, &RISCVDescs.OperandInfo[7328] }, // Inst #9350 = PseudoVSSEG2E32_V_M4_MASK + { 4, &RISCVDescs.OperandInfo[7324] }, // Inst #9349 = PseudoVSSEG2E32_V_M4 + { 5, &RISCVDescs.OperandInfo[7319] }, // Inst #9348 = PseudoVSSEG2E32_V_M2_MASK + { 4, &RISCVDescs.OperandInfo[7315] }, // Inst #9347 = PseudoVSSEG2E32_V_M2 + { 5, &RISCVDescs.OperandInfo[7310] }, // Inst #9346 = PseudoVSSEG2E32_V_M1_MASK + { 4, &RISCVDescs.OperandInfo[7306] }, // Inst #9345 = PseudoVSSEG2E32_V_M1 + { 5, &RISCVDescs.OperandInfo[7310] }, // Inst #9344 = PseudoVSSEG2E16_V_MF4_MASK + { 4, &RISCVDescs.OperandInfo[7306] }, // Inst #9343 = PseudoVSSEG2E16_V_MF4 + { 5, &RISCVDescs.OperandInfo[7310] }, // Inst #9342 = PseudoVSSEG2E16_V_MF2_MASK + { 4, &RISCVDescs.OperandInfo[7306] }, // Inst #9341 = PseudoVSSEG2E16_V_MF2 + { 5, &RISCVDescs.OperandInfo[7328] }, // Inst #9340 = PseudoVSSEG2E16_V_M4_MASK + { 4, &RISCVDescs.OperandInfo[7324] }, // Inst #9339 = PseudoVSSEG2E16_V_M4 + { 5, &RISCVDescs.OperandInfo[7319] }, // Inst #9338 = PseudoVSSEG2E16_V_M2_MASK + { 4, &RISCVDescs.OperandInfo[7315] }, // Inst #9337 = PseudoVSSEG2E16_V_M2 + { 5, &RISCVDescs.OperandInfo[7310] }, // Inst #9336 = PseudoVSSEG2E16_V_M1_MASK + { 4, &RISCVDescs.OperandInfo[7306] }, // Inst #9335 = PseudoVSSEG2E16_V_M1 + { 6, &RISCVDescs.OperandInfo[7267] }, // Inst #9334 = PseudoVSSE8_V_MF8_MASK + { 5, &RISCVDescs.OperandInfo[7262] }, // Inst #9333 = PseudoVSSE8_V_MF8 + { 6, &RISCVDescs.OperandInfo[7267] }, // Inst #9332 = PseudoVSSE8_V_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7262] }, // Inst #9331 = PseudoVSSE8_V_MF4 + { 6, &RISCVDescs.OperandInfo[7267] }, // Inst #9330 = PseudoVSSE8_V_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7262] }, // Inst #9329 = PseudoVSSE8_V_MF2 + { 6, &RISCVDescs.OperandInfo[7300] }, // Inst #9328 = PseudoVSSE8_V_M8_MASK + { 5, &RISCVDescs.OperandInfo[7295] }, // Inst #9327 = PseudoVSSE8_V_M8 + { 6, &RISCVDescs.OperandInfo[7289] }, // Inst #9326 = PseudoVSSE8_V_M4_MASK + { 5, &RISCVDescs.OperandInfo[7284] }, // Inst #9325 = PseudoVSSE8_V_M4 + { 6, &RISCVDescs.OperandInfo[7278] }, // Inst #9324 = PseudoVSSE8_V_M2_MASK + { 5, &RISCVDescs.OperandInfo[7273] }, // Inst #9323 = PseudoVSSE8_V_M2 + { 6, &RISCVDescs.OperandInfo[7267] }, // Inst #9322 = PseudoVSSE8_V_M1_MASK + { 5, &RISCVDescs.OperandInfo[7262] }, // Inst #9321 = PseudoVSSE8_V_M1 + { 6, &RISCVDescs.OperandInfo[7300] }, // Inst #9320 = PseudoVSSE64_V_M8_MASK + { 5, &RISCVDescs.OperandInfo[7295] }, // Inst #9319 = PseudoVSSE64_V_M8 + { 6, &RISCVDescs.OperandInfo[7289] }, // Inst #9318 = PseudoVSSE64_V_M4_MASK + { 5, &RISCVDescs.OperandInfo[7284] }, // Inst #9317 = PseudoVSSE64_V_M4 + { 6, &RISCVDescs.OperandInfo[7278] }, // Inst #9316 = PseudoVSSE64_V_M2_MASK + { 5, &RISCVDescs.OperandInfo[7273] }, // Inst #9315 = PseudoVSSE64_V_M2 + { 6, &RISCVDescs.OperandInfo[7267] }, // Inst #9314 = PseudoVSSE64_V_M1_MASK + { 5, &RISCVDescs.OperandInfo[7262] }, // Inst #9313 = PseudoVSSE64_V_M1 + { 6, &RISCVDescs.OperandInfo[7267] }, // Inst #9312 = PseudoVSSE32_V_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7262] }, // Inst #9311 = PseudoVSSE32_V_MF2 + { 6, &RISCVDescs.OperandInfo[7300] }, // Inst #9310 = PseudoVSSE32_V_M8_MASK + { 5, &RISCVDescs.OperandInfo[7295] }, // Inst #9309 = PseudoVSSE32_V_M8 + { 6, &RISCVDescs.OperandInfo[7289] }, // Inst #9308 = PseudoVSSE32_V_M4_MASK + { 5, &RISCVDescs.OperandInfo[7284] }, // Inst #9307 = PseudoVSSE32_V_M4 + { 6, &RISCVDescs.OperandInfo[7278] }, // Inst #9306 = PseudoVSSE32_V_M2_MASK + { 5, &RISCVDescs.OperandInfo[7273] }, // Inst #9305 = PseudoVSSE32_V_M2 + { 6, &RISCVDescs.OperandInfo[7267] }, // Inst #9304 = PseudoVSSE32_V_M1_MASK + { 5, &RISCVDescs.OperandInfo[7262] }, // Inst #9303 = PseudoVSSE32_V_M1 + { 6, &RISCVDescs.OperandInfo[7267] }, // Inst #9302 = PseudoVSSE16_V_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7262] }, // Inst #9301 = PseudoVSSE16_V_MF4 + { 6, &RISCVDescs.OperandInfo[7267] }, // Inst #9300 = PseudoVSSE16_V_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7262] }, // Inst #9299 = PseudoVSSE16_V_MF2 + { 6, &RISCVDescs.OperandInfo[7300] }, // Inst #9298 = PseudoVSSE16_V_M8_MASK + { 5, &RISCVDescs.OperandInfo[7295] }, // Inst #9297 = PseudoVSSE16_V_M8 + { 6, &RISCVDescs.OperandInfo[7289] }, // Inst #9296 = PseudoVSSE16_V_M4_MASK + { 5, &RISCVDescs.OperandInfo[7284] }, // Inst #9295 = PseudoVSSE16_V_M4 + { 6, &RISCVDescs.OperandInfo[7278] }, // Inst #9294 = PseudoVSSE16_V_M2_MASK + { 5, &RISCVDescs.OperandInfo[7273] }, // Inst #9293 = PseudoVSSE16_V_M2 + { 6, &RISCVDescs.OperandInfo[7267] }, // Inst #9292 = PseudoVSSE16_V_M1_MASK + { 5, &RISCVDescs.OperandInfo[7262] }, // Inst #9291 = PseudoVSSE16_V_M1 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #9290 = PseudoVSRL_VX_MF8_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #9289 = PseudoVSRL_VX_MF8 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #9288 = PseudoVSRL_VX_MF4_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #9287 = PseudoVSRL_VX_MF4 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #9286 = PseudoVSRL_VX_MF2_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #9285 = PseudoVSRL_VX_MF2 + { 8, &RISCVDescs.OperandInfo[809] }, // Inst #9284 = PseudoVSRL_VX_M8_MASK + { 7, &RISCVDescs.OperandInfo[802] }, // Inst #9283 = PseudoVSRL_VX_M8 + { 8, &RISCVDescs.OperandInfo[794] }, // Inst #9282 = PseudoVSRL_VX_M4_MASK + { 7, &RISCVDescs.OperandInfo[787] }, // Inst #9281 = PseudoVSRL_VX_M4 + { 8, &RISCVDescs.OperandInfo[779] }, // Inst #9280 = PseudoVSRL_VX_M2_MASK + { 7, &RISCVDescs.OperandInfo[772] }, // Inst #9279 = PseudoVSRL_VX_M2 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #9278 = PseudoVSRL_VX_M1_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #9277 = PseudoVSRL_VX_M1 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #9276 = PseudoVSRL_VV_MF8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #9275 = PseudoVSRL_VV_MF8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #9274 = PseudoVSRL_VV_MF4_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #9273 = PseudoVSRL_VV_MF4 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #9272 = PseudoVSRL_VV_MF2_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #9271 = PseudoVSRL_VV_MF2 + { 8, &RISCVDescs.OperandInfo[749] }, // Inst #9270 = PseudoVSRL_VV_M8_MASK + { 7, &RISCVDescs.OperandInfo[742] }, // Inst #9269 = PseudoVSRL_VV_M8 + { 8, &RISCVDescs.OperandInfo[734] }, // Inst #9268 = PseudoVSRL_VV_M4_MASK + { 7, &RISCVDescs.OperandInfo[727] }, // Inst #9267 = PseudoVSRL_VV_M4 + { 8, &RISCVDescs.OperandInfo[719] }, // Inst #9266 = PseudoVSRL_VV_M2_MASK + { 7, &RISCVDescs.OperandInfo[712] }, // Inst #9265 = PseudoVSRL_VV_M2 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #9264 = PseudoVSRL_VV_M1_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #9263 = PseudoVSRL_VV_M1 + { 8, &RISCVDescs.OperandInfo[6079] }, // Inst #9262 = PseudoVSRL_VI_MF8_MASK + { 7, &RISCVDescs.OperandInfo[877] }, // Inst #9261 = PseudoVSRL_VI_MF8 + { 8, &RISCVDescs.OperandInfo[6079] }, // Inst #9260 = PseudoVSRL_VI_MF4_MASK + { 7, &RISCVDescs.OperandInfo[877] }, // Inst #9259 = PseudoVSRL_VI_MF4 + { 8, &RISCVDescs.OperandInfo[6079] }, // Inst #9258 = PseudoVSRL_VI_MF2_MASK + { 7, &RISCVDescs.OperandInfo[877] }, // Inst #9257 = PseudoVSRL_VI_MF2 + { 8, &RISCVDescs.OperandInfo[6594] }, // Inst #9256 = PseudoVSRL_VI_M8_MASK + { 7, &RISCVDescs.OperandInfo[898] }, // Inst #9255 = PseudoVSRL_VI_M8 + { 8, &RISCVDescs.OperandInfo[6586] }, // Inst #9254 = PseudoVSRL_VI_M4_MASK + { 7, &RISCVDescs.OperandInfo[891] }, // Inst #9253 = PseudoVSRL_VI_M4 + { 8, &RISCVDescs.OperandInfo[6578] }, // Inst #9252 = PseudoVSRL_VI_M2_MASK + { 7, &RISCVDescs.OperandInfo[884] }, // Inst #9251 = PseudoVSRL_VI_M2 + { 8, &RISCVDescs.OperandInfo[6079] }, // Inst #9250 = PseudoVSRL_VI_M1_MASK + { 7, &RISCVDescs.OperandInfo[877] }, // Inst #9249 = PseudoVSRL_VI_M1 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #9248 = PseudoVSRA_VX_MF8_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #9247 = PseudoVSRA_VX_MF8 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #9246 = PseudoVSRA_VX_MF4_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #9245 = PseudoVSRA_VX_MF4 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #9244 = PseudoVSRA_VX_MF2_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #9243 = PseudoVSRA_VX_MF2 + { 8, &RISCVDescs.OperandInfo[809] }, // Inst #9242 = PseudoVSRA_VX_M8_MASK + { 7, &RISCVDescs.OperandInfo[802] }, // Inst #9241 = PseudoVSRA_VX_M8 + { 8, &RISCVDescs.OperandInfo[794] }, // Inst #9240 = PseudoVSRA_VX_M4_MASK + { 7, &RISCVDescs.OperandInfo[787] }, // Inst #9239 = PseudoVSRA_VX_M4 + { 8, &RISCVDescs.OperandInfo[779] }, // Inst #9238 = PseudoVSRA_VX_M2_MASK + { 7, &RISCVDescs.OperandInfo[772] }, // Inst #9237 = PseudoVSRA_VX_M2 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #9236 = PseudoVSRA_VX_M1_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #9235 = PseudoVSRA_VX_M1 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #9234 = PseudoVSRA_VV_MF8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #9233 = PseudoVSRA_VV_MF8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #9232 = PseudoVSRA_VV_MF4_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #9231 = PseudoVSRA_VV_MF4 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #9230 = PseudoVSRA_VV_MF2_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #9229 = PseudoVSRA_VV_MF2 + { 8, &RISCVDescs.OperandInfo[749] }, // Inst #9228 = PseudoVSRA_VV_M8_MASK + { 7, &RISCVDescs.OperandInfo[742] }, // Inst #9227 = PseudoVSRA_VV_M8 + { 8, &RISCVDescs.OperandInfo[734] }, // Inst #9226 = PseudoVSRA_VV_M4_MASK + { 7, &RISCVDescs.OperandInfo[727] }, // Inst #9225 = PseudoVSRA_VV_M4 + { 8, &RISCVDescs.OperandInfo[719] }, // Inst #9224 = PseudoVSRA_VV_M2_MASK + { 7, &RISCVDescs.OperandInfo[712] }, // Inst #9223 = PseudoVSRA_VV_M2 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #9222 = PseudoVSRA_VV_M1_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #9221 = PseudoVSRA_VV_M1 + { 8, &RISCVDescs.OperandInfo[6079] }, // Inst #9220 = PseudoVSRA_VI_MF8_MASK + { 7, &RISCVDescs.OperandInfo[877] }, // Inst #9219 = PseudoVSRA_VI_MF8 + { 8, &RISCVDescs.OperandInfo[6079] }, // Inst #9218 = PseudoVSRA_VI_MF4_MASK + { 7, &RISCVDescs.OperandInfo[877] }, // Inst #9217 = PseudoVSRA_VI_MF4 + { 8, &RISCVDescs.OperandInfo[6079] }, // Inst #9216 = PseudoVSRA_VI_MF2_MASK + { 7, &RISCVDescs.OperandInfo[877] }, // Inst #9215 = PseudoVSRA_VI_MF2 + { 8, &RISCVDescs.OperandInfo[6594] }, // Inst #9214 = PseudoVSRA_VI_M8_MASK + { 7, &RISCVDescs.OperandInfo[898] }, // Inst #9213 = PseudoVSRA_VI_M8 + { 8, &RISCVDescs.OperandInfo[6586] }, // Inst #9212 = PseudoVSRA_VI_M4_MASK + { 7, &RISCVDescs.OperandInfo[891] }, // Inst #9211 = PseudoVSRA_VI_M4 + { 8, &RISCVDescs.OperandInfo[6578] }, // Inst #9210 = PseudoVSRA_VI_M2_MASK + { 7, &RISCVDescs.OperandInfo[884] }, // Inst #9209 = PseudoVSRA_VI_M2 + { 8, &RISCVDescs.OperandInfo[6079] }, // Inst #9208 = PseudoVSRA_VI_M1_MASK + { 7, &RISCVDescs.OperandInfo[877] }, // Inst #9207 = PseudoVSRA_VI_M1 + { 2, &RISCVDescs.OperandInfo[6218] }, // Inst #9206 = PseudoVSPILL8_MF8 + { 2, &RISCVDescs.OperandInfo[6218] }, // Inst #9205 = PseudoVSPILL8_MF4 + { 2, &RISCVDescs.OperandInfo[6218] }, // Inst #9204 = PseudoVSPILL8_MF2 + { 2, &RISCVDescs.OperandInfo[6218] }, // Inst #9203 = PseudoVSPILL8_M1 + { 2, &RISCVDescs.OperandInfo[6216] }, // Inst #9202 = PseudoVSPILL7_MF8 + { 2, &RISCVDescs.OperandInfo[6216] }, // Inst #9201 = PseudoVSPILL7_MF4 + { 2, &RISCVDescs.OperandInfo[6216] }, // Inst #9200 = PseudoVSPILL7_MF2 + { 2, &RISCVDescs.OperandInfo[6216] }, // Inst #9199 = PseudoVSPILL7_M1 + { 2, &RISCVDescs.OperandInfo[6214] }, // Inst #9198 = PseudoVSPILL6_MF8 + { 2, &RISCVDescs.OperandInfo[6214] }, // Inst #9197 = PseudoVSPILL6_MF4 + { 2, &RISCVDescs.OperandInfo[6214] }, // Inst #9196 = PseudoVSPILL6_MF2 + { 2, &RISCVDescs.OperandInfo[6214] }, // Inst #9195 = PseudoVSPILL6_M1 + { 2, &RISCVDescs.OperandInfo[6212] }, // Inst #9194 = PseudoVSPILL5_MF8 + { 2, &RISCVDescs.OperandInfo[6212] }, // Inst #9193 = PseudoVSPILL5_MF4 + { 2, &RISCVDescs.OperandInfo[6212] }, // Inst #9192 = PseudoVSPILL5_MF2 + { 2, &RISCVDescs.OperandInfo[6212] }, // Inst #9191 = PseudoVSPILL5_M1 + { 2, &RISCVDescs.OperandInfo[6208] }, // Inst #9190 = PseudoVSPILL4_MF8 + { 2, &RISCVDescs.OperandInfo[6208] }, // Inst #9189 = PseudoVSPILL4_MF4 + { 2, &RISCVDescs.OperandInfo[6208] }, // Inst #9188 = PseudoVSPILL4_MF2 + { 2, &RISCVDescs.OperandInfo[6210] }, // Inst #9187 = PseudoVSPILL4_M2 + { 2, &RISCVDescs.OperandInfo[6208] }, // Inst #9186 = PseudoVSPILL4_M1 + { 2, &RISCVDescs.OperandInfo[6204] }, // Inst #9185 = PseudoVSPILL3_MF8 + { 2, &RISCVDescs.OperandInfo[6204] }, // Inst #9184 = PseudoVSPILL3_MF4 + { 2, &RISCVDescs.OperandInfo[6204] }, // Inst #9183 = PseudoVSPILL3_MF2 + { 2, &RISCVDescs.OperandInfo[6206] }, // Inst #9182 = PseudoVSPILL3_M2 + { 2, &RISCVDescs.OperandInfo[6204] }, // Inst #9181 = PseudoVSPILL3_M1 + { 2, &RISCVDescs.OperandInfo[6198] }, // Inst #9180 = PseudoVSPILL2_MF8 + { 2, &RISCVDescs.OperandInfo[6198] }, // Inst #9179 = PseudoVSPILL2_MF4 + { 2, &RISCVDescs.OperandInfo[6198] }, // Inst #9178 = PseudoVSPILL2_MF2 + { 2, &RISCVDescs.OperandInfo[6202] }, // Inst #9177 = PseudoVSPILL2_M4 + { 2, &RISCVDescs.OperandInfo[6200] }, // Inst #9176 = PseudoVSPILL2_M2 + { 2, &RISCVDescs.OperandInfo[6198] }, // Inst #9175 = PseudoVSPILL2_M1 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #9174 = PseudoVSOXSEG8EI8_V_MF8_MF8_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #9173 = PseudoVSOXSEG8EI8_V_MF8_MF8 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #9172 = PseudoVSOXSEG8EI8_V_MF8_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #9171 = PseudoVSOXSEG8EI8_V_MF8_MF4 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #9170 = PseudoVSOXSEG8EI8_V_MF8_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #9169 = PseudoVSOXSEG8EI8_V_MF8_MF2 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #9168 = PseudoVSOXSEG8EI8_V_MF8_M1_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #9167 = PseudoVSOXSEG8EI8_V_MF8_M1 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #9166 = PseudoVSOXSEG8EI8_V_MF4_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #9165 = PseudoVSOXSEG8EI8_V_MF4_MF4 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #9164 = PseudoVSOXSEG8EI8_V_MF4_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #9163 = PseudoVSOXSEG8EI8_V_MF4_MF2 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #9162 = PseudoVSOXSEG8EI8_V_MF4_M1_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #9161 = PseudoVSOXSEG8EI8_V_MF4_M1 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #9160 = PseudoVSOXSEG8EI8_V_MF2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #9159 = PseudoVSOXSEG8EI8_V_MF2_MF2 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #9158 = PseudoVSOXSEG8EI8_V_MF2_M1_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #9157 = PseudoVSOXSEG8EI8_V_MF2_M1 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #9156 = PseudoVSOXSEG8EI8_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #9155 = PseudoVSOXSEG8EI8_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[7256] }, // Inst #9154 = PseudoVSOXSEG8EI64_V_M8_M1_MASK + { 5, &RISCVDescs.OperandInfo[7251] }, // Inst #9153 = PseudoVSOXSEG8EI64_V_M8_M1 + { 6, &RISCVDescs.OperandInfo[7245] }, // Inst #9152 = PseudoVSOXSEG8EI64_V_M4_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7240] }, // Inst #9151 = PseudoVSOXSEG8EI64_V_M4_MF2 + { 6, &RISCVDescs.OperandInfo[7245] }, // Inst #9150 = PseudoVSOXSEG8EI64_V_M4_M1_MASK + { 5, &RISCVDescs.OperandInfo[7240] }, // Inst #9149 = PseudoVSOXSEG8EI64_V_M4_M1 + { 6, &RISCVDescs.OperandInfo[7234] }, // Inst #9148 = PseudoVSOXSEG8EI64_V_M2_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7229] }, // Inst #9147 = PseudoVSOXSEG8EI64_V_M2_MF4 + { 6, &RISCVDescs.OperandInfo[7234] }, // Inst #9146 = PseudoVSOXSEG8EI64_V_M2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7229] }, // Inst #9145 = PseudoVSOXSEG8EI64_V_M2_MF2 + { 6, &RISCVDescs.OperandInfo[7234] }, // Inst #9144 = PseudoVSOXSEG8EI64_V_M2_M1_MASK + { 5, &RISCVDescs.OperandInfo[7229] }, // Inst #9143 = PseudoVSOXSEG8EI64_V_M2_M1 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #9142 = PseudoVSOXSEG8EI64_V_M1_MF8_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #9141 = PseudoVSOXSEG8EI64_V_M1_MF8 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #9140 = PseudoVSOXSEG8EI64_V_M1_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #9139 = PseudoVSOXSEG8EI64_V_M1_MF4 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #9138 = PseudoVSOXSEG8EI64_V_M1_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #9137 = PseudoVSOXSEG8EI64_V_M1_MF2 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #9136 = PseudoVSOXSEG8EI64_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #9135 = PseudoVSOXSEG8EI64_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #9134 = PseudoVSOXSEG8EI32_V_MF2_MF8_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #9133 = PseudoVSOXSEG8EI32_V_MF2_MF8 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #9132 = PseudoVSOXSEG8EI32_V_MF2_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #9131 = PseudoVSOXSEG8EI32_V_MF2_MF4 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #9130 = PseudoVSOXSEG8EI32_V_MF2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #9129 = PseudoVSOXSEG8EI32_V_MF2_MF2 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #9128 = PseudoVSOXSEG8EI32_V_MF2_M1_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #9127 = PseudoVSOXSEG8EI32_V_MF2_M1 + { 6, &RISCVDescs.OperandInfo[7245] }, // Inst #9126 = PseudoVSOXSEG8EI32_V_M4_M1_MASK + { 5, &RISCVDescs.OperandInfo[7240] }, // Inst #9125 = PseudoVSOXSEG8EI32_V_M4_M1 + { 6, &RISCVDescs.OperandInfo[7234] }, // Inst #9124 = PseudoVSOXSEG8EI32_V_M2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7229] }, // Inst #9123 = PseudoVSOXSEG8EI32_V_M2_MF2 + { 6, &RISCVDescs.OperandInfo[7234] }, // Inst #9122 = PseudoVSOXSEG8EI32_V_M2_M1_MASK + { 5, &RISCVDescs.OperandInfo[7229] }, // Inst #9121 = PseudoVSOXSEG8EI32_V_M2_M1 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #9120 = PseudoVSOXSEG8EI32_V_M1_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #9119 = PseudoVSOXSEG8EI32_V_M1_MF4 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #9118 = PseudoVSOXSEG8EI32_V_M1_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #9117 = PseudoVSOXSEG8EI32_V_M1_MF2 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #9116 = PseudoVSOXSEG8EI32_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #9115 = PseudoVSOXSEG8EI32_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #9114 = PseudoVSOXSEG8EI16_V_MF4_MF8_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #9113 = PseudoVSOXSEG8EI16_V_MF4_MF8 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #9112 = PseudoVSOXSEG8EI16_V_MF4_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #9111 = PseudoVSOXSEG8EI16_V_MF4_MF4 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #9110 = PseudoVSOXSEG8EI16_V_MF4_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #9109 = PseudoVSOXSEG8EI16_V_MF4_MF2 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #9108 = PseudoVSOXSEG8EI16_V_MF4_M1_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #9107 = PseudoVSOXSEG8EI16_V_MF4_M1 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #9106 = PseudoVSOXSEG8EI16_V_MF2_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #9105 = PseudoVSOXSEG8EI16_V_MF2_MF4 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #9104 = PseudoVSOXSEG8EI16_V_MF2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #9103 = PseudoVSOXSEG8EI16_V_MF2_MF2 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #9102 = PseudoVSOXSEG8EI16_V_MF2_M1_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #9101 = PseudoVSOXSEG8EI16_V_MF2_M1 + { 6, &RISCVDescs.OperandInfo[7234] }, // Inst #9100 = PseudoVSOXSEG8EI16_V_M2_M1_MASK + { 5, &RISCVDescs.OperandInfo[7229] }, // Inst #9099 = PseudoVSOXSEG8EI16_V_M2_M1 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #9098 = PseudoVSOXSEG8EI16_V_M1_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #9097 = PseudoVSOXSEG8EI16_V_M1_MF2 + { 6, &RISCVDescs.OperandInfo[7223] }, // Inst #9096 = PseudoVSOXSEG8EI16_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[7218] }, // Inst #9095 = PseudoVSOXSEG8EI16_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #9094 = PseudoVSOXSEG7EI8_V_MF8_MF8_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #9093 = PseudoVSOXSEG7EI8_V_MF8_MF8 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #9092 = PseudoVSOXSEG7EI8_V_MF8_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #9091 = PseudoVSOXSEG7EI8_V_MF8_MF4 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #9090 = PseudoVSOXSEG7EI8_V_MF8_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #9089 = PseudoVSOXSEG7EI8_V_MF8_MF2 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #9088 = PseudoVSOXSEG7EI8_V_MF8_M1_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #9087 = PseudoVSOXSEG7EI8_V_MF8_M1 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #9086 = PseudoVSOXSEG7EI8_V_MF4_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #9085 = PseudoVSOXSEG7EI8_V_MF4_MF4 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #9084 = PseudoVSOXSEG7EI8_V_MF4_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #9083 = PseudoVSOXSEG7EI8_V_MF4_MF2 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #9082 = PseudoVSOXSEG7EI8_V_MF4_M1_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #9081 = PseudoVSOXSEG7EI8_V_MF4_M1 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #9080 = PseudoVSOXSEG7EI8_V_MF2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #9079 = PseudoVSOXSEG7EI8_V_MF2_MF2 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #9078 = PseudoVSOXSEG7EI8_V_MF2_M1_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #9077 = PseudoVSOXSEG7EI8_V_MF2_M1 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #9076 = PseudoVSOXSEG7EI8_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #9075 = PseudoVSOXSEG7EI8_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[7212] }, // Inst #9074 = PseudoVSOXSEG7EI64_V_M8_M1_MASK + { 5, &RISCVDescs.OperandInfo[7207] }, // Inst #9073 = PseudoVSOXSEG7EI64_V_M8_M1 + { 6, &RISCVDescs.OperandInfo[7201] }, // Inst #9072 = PseudoVSOXSEG7EI64_V_M4_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7196] }, // Inst #9071 = PseudoVSOXSEG7EI64_V_M4_MF2 + { 6, &RISCVDescs.OperandInfo[7201] }, // Inst #9070 = PseudoVSOXSEG7EI64_V_M4_M1_MASK + { 5, &RISCVDescs.OperandInfo[7196] }, // Inst #9069 = PseudoVSOXSEG7EI64_V_M4_M1 + { 6, &RISCVDescs.OperandInfo[7190] }, // Inst #9068 = PseudoVSOXSEG7EI64_V_M2_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7185] }, // Inst #9067 = PseudoVSOXSEG7EI64_V_M2_MF4 + { 6, &RISCVDescs.OperandInfo[7190] }, // Inst #9066 = PseudoVSOXSEG7EI64_V_M2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7185] }, // Inst #9065 = PseudoVSOXSEG7EI64_V_M2_MF2 + { 6, &RISCVDescs.OperandInfo[7190] }, // Inst #9064 = PseudoVSOXSEG7EI64_V_M2_M1_MASK + { 5, &RISCVDescs.OperandInfo[7185] }, // Inst #9063 = PseudoVSOXSEG7EI64_V_M2_M1 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #9062 = PseudoVSOXSEG7EI64_V_M1_MF8_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #9061 = PseudoVSOXSEG7EI64_V_M1_MF8 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #9060 = PseudoVSOXSEG7EI64_V_M1_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #9059 = PseudoVSOXSEG7EI64_V_M1_MF4 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #9058 = PseudoVSOXSEG7EI64_V_M1_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #9057 = PseudoVSOXSEG7EI64_V_M1_MF2 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #9056 = PseudoVSOXSEG7EI64_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #9055 = PseudoVSOXSEG7EI64_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #9054 = PseudoVSOXSEG7EI32_V_MF2_MF8_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #9053 = PseudoVSOXSEG7EI32_V_MF2_MF8 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #9052 = PseudoVSOXSEG7EI32_V_MF2_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #9051 = PseudoVSOXSEG7EI32_V_MF2_MF4 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #9050 = PseudoVSOXSEG7EI32_V_MF2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #9049 = PseudoVSOXSEG7EI32_V_MF2_MF2 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #9048 = PseudoVSOXSEG7EI32_V_MF2_M1_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #9047 = PseudoVSOXSEG7EI32_V_MF2_M1 + { 6, &RISCVDescs.OperandInfo[7201] }, // Inst #9046 = PseudoVSOXSEG7EI32_V_M4_M1_MASK + { 5, &RISCVDescs.OperandInfo[7196] }, // Inst #9045 = PseudoVSOXSEG7EI32_V_M4_M1 + { 6, &RISCVDescs.OperandInfo[7190] }, // Inst #9044 = PseudoVSOXSEG7EI32_V_M2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7185] }, // Inst #9043 = PseudoVSOXSEG7EI32_V_M2_MF2 + { 6, &RISCVDescs.OperandInfo[7190] }, // Inst #9042 = PseudoVSOXSEG7EI32_V_M2_M1_MASK + { 5, &RISCVDescs.OperandInfo[7185] }, // Inst #9041 = PseudoVSOXSEG7EI32_V_M2_M1 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #9040 = PseudoVSOXSEG7EI32_V_M1_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #9039 = PseudoVSOXSEG7EI32_V_M1_MF4 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #9038 = PseudoVSOXSEG7EI32_V_M1_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #9037 = PseudoVSOXSEG7EI32_V_M1_MF2 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #9036 = PseudoVSOXSEG7EI32_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #9035 = PseudoVSOXSEG7EI32_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #9034 = PseudoVSOXSEG7EI16_V_MF4_MF8_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #9033 = PseudoVSOXSEG7EI16_V_MF4_MF8 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #9032 = PseudoVSOXSEG7EI16_V_MF4_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #9031 = PseudoVSOXSEG7EI16_V_MF4_MF4 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #9030 = PseudoVSOXSEG7EI16_V_MF4_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #9029 = PseudoVSOXSEG7EI16_V_MF4_MF2 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #9028 = PseudoVSOXSEG7EI16_V_MF4_M1_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #9027 = PseudoVSOXSEG7EI16_V_MF4_M1 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #9026 = PseudoVSOXSEG7EI16_V_MF2_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #9025 = PseudoVSOXSEG7EI16_V_MF2_MF4 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #9024 = PseudoVSOXSEG7EI16_V_MF2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #9023 = PseudoVSOXSEG7EI16_V_MF2_MF2 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #9022 = PseudoVSOXSEG7EI16_V_MF2_M1_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #9021 = PseudoVSOXSEG7EI16_V_MF2_M1 + { 6, &RISCVDescs.OperandInfo[7190] }, // Inst #9020 = PseudoVSOXSEG7EI16_V_M2_M1_MASK + { 5, &RISCVDescs.OperandInfo[7185] }, // Inst #9019 = PseudoVSOXSEG7EI16_V_M2_M1 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #9018 = PseudoVSOXSEG7EI16_V_M1_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #9017 = PseudoVSOXSEG7EI16_V_M1_MF2 + { 6, &RISCVDescs.OperandInfo[7179] }, // Inst #9016 = PseudoVSOXSEG7EI16_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[7174] }, // Inst #9015 = PseudoVSOXSEG7EI16_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #9014 = PseudoVSOXSEG6EI8_V_MF8_MF8_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #9013 = PseudoVSOXSEG6EI8_V_MF8_MF8 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #9012 = PseudoVSOXSEG6EI8_V_MF8_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #9011 = PseudoVSOXSEG6EI8_V_MF8_MF4 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #9010 = PseudoVSOXSEG6EI8_V_MF8_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #9009 = PseudoVSOXSEG6EI8_V_MF8_MF2 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #9008 = PseudoVSOXSEG6EI8_V_MF8_M1_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #9007 = PseudoVSOXSEG6EI8_V_MF8_M1 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #9006 = PseudoVSOXSEG6EI8_V_MF4_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #9005 = PseudoVSOXSEG6EI8_V_MF4_MF4 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #9004 = PseudoVSOXSEG6EI8_V_MF4_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #9003 = PseudoVSOXSEG6EI8_V_MF4_MF2 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #9002 = PseudoVSOXSEG6EI8_V_MF4_M1_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #9001 = PseudoVSOXSEG6EI8_V_MF4_M1 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #9000 = PseudoVSOXSEG6EI8_V_MF2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #8999 = PseudoVSOXSEG6EI8_V_MF2_MF2 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #8998 = PseudoVSOXSEG6EI8_V_MF2_M1_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #8997 = PseudoVSOXSEG6EI8_V_MF2_M1 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #8996 = PseudoVSOXSEG6EI8_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #8995 = PseudoVSOXSEG6EI8_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[7168] }, // Inst #8994 = PseudoVSOXSEG6EI64_V_M8_M1_MASK + { 5, &RISCVDescs.OperandInfo[7163] }, // Inst #8993 = PseudoVSOXSEG6EI64_V_M8_M1 + { 6, &RISCVDescs.OperandInfo[7157] }, // Inst #8992 = PseudoVSOXSEG6EI64_V_M4_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7152] }, // Inst #8991 = PseudoVSOXSEG6EI64_V_M4_MF2 + { 6, &RISCVDescs.OperandInfo[7157] }, // Inst #8990 = PseudoVSOXSEG6EI64_V_M4_M1_MASK + { 5, &RISCVDescs.OperandInfo[7152] }, // Inst #8989 = PseudoVSOXSEG6EI64_V_M4_M1 + { 6, &RISCVDescs.OperandInfo[7146] }, // Inst #8988 = PseudoVSOXSEG6EI64_V_M2_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7141] }, // Inst #8987 = PseudoVSOXSEG6EI64_V_M2_MF4 + { 6, &RISCVDescs.OperandInfo[7146] }, // Inst #8986 = PseudoVSOXSEG6EI64_V_M2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7141] }, // Inst #8985 = PseudoVSOXSEG6EI64_V_M2_MF2 + { 6, &RISCVDescs.OperandInfo[7146] }, // Inst #8984 = PseudoVSOXSEG6EI64_V_M2_M1_MASK + { 5, &RISCVDescs.OperandInfo[7141] }, // Inst #8983 = PseudoVSOXSEG6EI64_V_M2_M1 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #8982 = PseudoVSOXSEG6EI64_V_M1_MF8_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #8981 = PseudoVSOXSEG6EI64_V_M1_MF8 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #8980 = PseudoVSOXSEG6EI64_V_M1_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #8979 = PseudoVSOXSEG6EI64_V_M1_MF4 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #8978 = PseudoVSOXSEG6EI64_V_M1_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #8977 = PseudoVSOXSEG6EI64_V_M1_MF2 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #8976 = PseudoVSOXSEG6EI64_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #8975 = PseudoVSOXSEG6EI64_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #8974 = PseudoVSOXSEG6EI32_V_MF2_MF8_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #8973 = PseudoVSOXSEG6EI32_V_MF2_MF8 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #8972 = PseudoVSOXSEG6EI32_V_MF2_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #8971 = PseudoVSOXSEG6EI32_V_MF2_MF4 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #8970 = PseudoVSOXSEG6EI32_V_MF2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #8969 = PseudoVSOXSEG6EI32_V_MF2_MF2 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #8968 = PseudoVSOXSEG6EI32_V_MF2_M1_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #8967 = PseudoVSOXSEG6EI32_V_MF2_M1 + { 6, &RISCVDescs.OperandInfo[7157] }, // Inst #8966 = PseudoVSOXSEG6EI32_V_M4_M1_MASK + { 5, &RISCVDescs.OperandInfo[7152] }, // Inst #8965 = PseudoVSOXSEG6EI32_V_M4_M1 + { 6, &RISCVDescs.OperandInfo[7146] }, // Inst #8964 = PseudoVSOXSEG6EI32_V_M2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7141] }, // Inst #8963 = PseudoVSOXSEG6EI32_V_M2_MF2 + { 6, &RISCVDescs.OperandInfo[7146] }, // Inst #8962 = PseudoVSOXSEG6EI32_V_M2_M1_MASK + { 5, &RISCVDescs.OperandInfo[7141] }, // Inst #8961 = PseudoVSOXSEG6EI32_V_M2_M1 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #8960 = PseudoVSOXSEG6EI32_V_M1_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #8959 = PseudoVSOXSEG6EI32_V_M1_MF4 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #8958 = PseudoVSOXSEG6EI32_V_M1_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #8957 = PseudoVSOXSEG6EI32_V_M1_MF2 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #8956 = PseudoVSOXSEG6EI32_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #8955 = PseudoVSOXSEG6EI32_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #8954 = PseudoVSOXSEG6EI16_V_MF4_MF8_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #8953 = PseudoVSOXSEG6EI16_V_MF4_MF8 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #8952 = PseudoVSOXSEG6EI16_V_MF4_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #8951 = PseudoVSOXSEG6EI16_V_MF4_MF4 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #8950 = PseudoVSOXSEG6EI16_V_MF4_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #8949 = PseudoVSOXSEG6EI16_V_MF4_MF2 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #8948 = PseudoVSOXSEG6EI16_V_MF4_M1_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #8947 = PseudoVSOXSEG6EI16_V_MF4_M1 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #8946 = PseudoVSOXSEG6EI16_V_MF2_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #8945 = PseudoVSOXSEG6EI16_V_MF2_MF4 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #8944 = PseudoVSOXSEG6EI16_V_MF2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #8943 = PseudoVSOXSEG6EI16_V_MF2_MF2 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #8942 = PseudoVSOXSEG6EI16_V_MF2_M1_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #8941 = PseudoVSOXSEG6EI16_V_MF2_M1 + { 6, &RISCVDescs.OperandInfo[7146] }, // Inst #8940 = PseudoVSOXSEG6EI16_V_M2_M1_MASK + { 5, &RISCVDescs.OperandInfo[7141] }, // Inst #8939 = PseudoVSOXSEG6EI16_V_M2_M1 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #8938 = PseudoVSOXSEG6EI16_V_M1_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #8937 = PseudoVSOXSEG6EI16_V_M1_MF2 + { 6, &RISCVDescs.OperandInfo[7135] }, // Inst #8936 = PseudoVSOXSEG6EI16_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[7130] }, // Inst #8935 = PseudoVSOXSEG6EI16_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #8934 = PseudoVSOXSEG5EI8_V_MF8_MF8_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #8933 = PseudoVSOXSEG5EI8_V_MF8_MF8 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #8932 = PseudoVSOXSEG5EI8_V_MF8_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #8931 = PseudoVSOXSEG5EI8_V_MF8_MF4 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #8930 = PseudoVSOXSEG5EI8_V_MF8_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #8929 = PseudoVSOXSEG5EI8_V_MF8_MF2 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #8928 = PseudoVSOXSEG5EI8_V_MF8_M1_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #8927 = PseudoVSOXSEG5EI8_V_MF8_M1 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #8926 = PseudoVSOXSEG5EI8_V_MF4_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #8925 = PseudoVSOXSEG5EI8_V_MF4_MF4 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #8924 = PseudoVSOXSEG5EI8_V_MF4_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #8923 = PseudoVSOXSEG5EI8_V_MF4_MF2 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #8922 = PseudoVSOXSEG5EI8_V_MF4_M1_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #8921 = PseudoVSOXSEG5EI8_V_MF4_M1 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #8920 = PseudoVSOXSEG5EI8_V_MF2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #8919 = PseudoVSOXSEG5EI8_V_MF2_MF2 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #8918 = PseudoVSOXSEG5EI8_V_MF2_M1_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #8917 = PseudoVSOXSEG5EI8_V_MF2_M1 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #8916 = PseudoVSOXSEG5EI8_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #8915 = PseudoVSOXSEG5EI8_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[7124] }, // Inst #8914 = PseudoVSOXSEG5EI64_V_M8_M1_MASK + { 5, &RISCVDescs.OperandInfo[7119] }, // Inst #8913 = PseudoVSOXSEG5EI64_V_M8_M1 + { 6, &RISCVDescs.OperandInfo[7113] }, // Inst #8912 = PseudoVSOXSEG5EI64_V_M4_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7108] }, // Inst #8911 = PseudoVSOXSEG5EI64_V_M4_MF2 + { 6, &RISCVDescs.OperandInfo[7113] }, // Inst #8910 = PseudoVSOXSEG5EI64_V_M4_M1_MASK + { 5, &RISCVDescs.OperandInfo[7108] }, // Inst #8909 = PseudoVSOXSEG5EI64_V_M4_M1 + { 6, &RISCVDescs.OperandInfo[7102] }, // Inst #8908 = PseudoVSOXSEG5EI64_V_M2_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7097] }, // Inst #8907 = PseudoVSOXSEG5EI64_V_M2_MF4 + { 6, &RISCVDescs.OperandInfo[7102] }, // Inst #8906 = PseudoVSOXSEG5EI64_V_M2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7097] }, // Inst #8905 = PseudoVSOXSEG5EI64_V_M2_MF2 + { 6, &RISCVDescs.OperandInfo[7102] }, // Inst #8904 = PseudoVSOXSEG5EI64_V_M2_M1_MASK + { 5, &RISCVDescs.OperandInfo[7097] }, // Inst #8903 = PseudoVSOXSEG5EI64_V_M2_M1 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #8902 = PseudoVSOXSEG5EI64_V_M1_MF8_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #8901 = PseudoVSOXSEG5EI64_V_M1_MF8 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #8900 = PseudoVSOXSEG5EI64_V_M1_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #8899 = PseudoVSOXSEG5EI64_V_M1_MF4 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #8898 = PseudoVSOXSEG5EI64_V_M1_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #8897 = PseudoVSOXSEG5EI64_V_M1_MF2 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #8896 = PseudoVSOXSEG5EI64_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #8895 = PseudoVSOXSEG5EI64_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #8894 = PseudoVSOXSEG5EI32_V_MF2_MF8_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #8893 = PseudoVSOXSEG5EI32_V_MF2_MF8 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #8892 = PseudoVSOXSEG5EI32_V_MF2_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #8891 = PseudoVSOXSEG5EI32_V_MF2_MF4 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #8890 = PseudoVSOXSEG5EI32_V_MF2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #8889 = PseudoVSOXSEG5EI32_V_MF2_MF2 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #8888 = PseudoVSOXSEG5EI32_V_MF2_M1_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #8887 = PseudoVSOXSEG5EI32_V_MF2_M1 + { 6, &RISCVDescs.OperandInfo[7113] }, // Inst #8886 = PseudoVSOXSEG5EI32_V_M4_M1_MASK + { 5, &RISCVDescs.OperandInfo[7108] }, // Inst #8885 = PseudoVSOXSEG5EI32_V_M4_M1 + { 6, &RISCVDescs.OperandInfo[7102] }, // Inst #8884 = PseudoVSOXSEG5EI32_V_M2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7097] }, // Inst #8883 = PseudoVSOXSEG5EI32_V_M2_MF2 + { 6, &RISCVDescs.OperandInfo[7102] }, // Inst #8882 = PseudoVSOXSEG5EI32_V_M2_M1_MASK + { 5, &RISCVDescs.OperandInfo[7097] }, // Inst #8881 = PseudoVSOXSEG5EI32_V_M2_M1 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #8880 = PseudoVSOXSEG5EI32_V_M1_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #8879 = PseudoVSOXSEG5EI32_V_M1_MF4 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #8878 = PseudoVSOXSEG5EI32_V_M1_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #8877 = PseudoVSOXSEG5EI32_V_M1_MF2 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #8876 = PseudoVSOXSEG5EI32_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #8875 = PseudoVSOXSEG5EI32_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #8874 = PseudoVSOXSEG5EI16_V_MF4_MF8_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #8873 = PseudoVSOXSEG5EI16_V_MF4_MF8 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #8872 = PseudoVSOXSEG5EI16_V_MF4_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #8871 = PseudoVSOXSEG5EI16_V_MF4_MF4 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #8870 = PseudoVSOXSEG5EI16_V_MF4_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #8869 = PseudoVSOXSEG5EI16_V_MF4_MF2 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #8868 = PseudoVSOXSEG5EI16_V_MF4_M1_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #8867 = PseudoVSOXSEG5EI16_V_MF4_M1 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #8866 = PseudoVSOXSEG5EI16_V_MF2_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #8865 = PseudoVSOXSEG5EI16_V_MF2_MF4 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #8864 = PseudoVSOXSEG5EI16_V_MF2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #8863 = PseudoVSOXSEG5EI16_V_MF2_MF2 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #8862 = PseudoVSOXSEG5EI16_V_MF2_M1_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #8861 = PseudoVSOXSEG5EI16_V_MF2_M1 + { 6, &RISCVDescs.OperandInfo[7102] }, // Inst #8860 = PseudoVSOXSEG5EI16_V_M2_M1_MASK + { 5, &RISCVDescs.OperandInfo[7097] }, // Inst #8859 = PseudoVSOXSEG5EI16_V_M2_M1 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #8858 = PseudoVSOXSEG5EI16_V_M1_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #8857 = PseudoVSOXSEG5EI16_V_M1_MF2 + { 6, &RISCVDescs.OperandInfo[7091] }, // Inst #8856 = PseudoVSOXSEG5EI16_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[7086] }, // Inst #8855 = PseudoVSOXSEG5EI16_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #8854 = PseudoVSOXSEG4EI8_V_MF8_MF8_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #8853 = PseudoVSOXSEG4EI8_V_MF8_MF8 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #8852 = PseudoVSOXSEG4EI8_V_MF8_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #8851 = PseudoVSOXSEG4EI8_V_MF8_MF4 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #8850 = PseudoVSOXSEG4EI8_V_MF8_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #8849 = PseudoVSOXSEG4EI8_V_MF8_MF2 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #8848 = PseudoVSOXSEG4EI8_V_MF8_M1_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #8847 = PseudoVSOXSEG4EI8_V_MF8_M1 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #8846 = PseudoVSOXSEG4EI8_V_MF4_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #8845 = PseudoVSOXSEG4EI8_V_MF4_MF4 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #8844 = PseudoVSOXSEG4EI8_V_MF4_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #8843 = PseudoVSOXSEG4EI8_V_MF4_MF2 + { 6, &RISCVDescs.OperandInfo[7014] }, // Inst #8842 = PseudoVSOXSEG4EI8_V_MF4_M2_MASK + { 5, &RISCVDescs.OperandInfo[7009] }, // Inst #8841 = PseudoVSOXSEG4EI8_V_MF4_M2 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #8840 = PseudoVSOXSEG4EI8_V_MF4_M1_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #8839 = PseudoVSOXSEG4EI8_V_MF4_M1 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #8838 = PseudoVSOXSEG4EI8_V_MF2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #8837 = PseudoVSOXSEG4EI8_V_MF2_MF2 + { 6, &RISCVDescs.OperandInfo[7014] }, // Inst #8836 = PseudoVSOXSEG4EI8_V_MF2_M2_MASK + { 5, &RISCVDescs.OperandInfo[7009] }, // Inst #8835 = PseudoVSOXSEG4EI8_V_MF2_M2 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #8834 = PseudoVSOXSEG4EI8_V_MF2_M1_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #8833 = PseudoVSOXSEG4EI8_V_MF2_M1 + { 6, &RISCVDescs.OperandInfo[7036] }, // Inst #8832 = PseudoVSOXSEG4EI8_V_M2_M2_MASK + { 5, &RISCVDescs.OperandInfo[7031] }, // Inst #8831 = PseudoVSOXSEG4EI8_V_M2_M2 + { 6, &RISCVDescs.OperandInfo[7014] }, // Inst #8830 = PseudoVSOXSEG4EI8_V_M1_M2_MASK + { 5, &RISCVDescs.OperandInfo[7009] }, // Inst #8829 = PseudoVSOXSEG4EI8_V_M1_M2 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #8828 = PseudoVSOXSEG4EI8_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #8827 = PseudoVSOXSEG4EI8_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[7069] }, // Inst #8826 = PseudoVSOXSEG4EI64_V_M8_M2_MASK + { 5, &RISCVDescs.OperandInfo[7064] }, // Inst #8825 = PseudoVSOXSEG4EI64_V_M8_M2 + { 6, &RISCVDescs.OperandInfo[7080] }, // Inst #8824 = PseudoVSOXSEG4EI64_V_M8_M1_MASK + { 5, &RISCVDescs.OperandInfo[7075] }, // Inst #8823 = PseudoVSOXSEG4EI64_V_M8_M1 + { 6, &RISCVDescs.OperandInfo[7058] }, // Inst #8822 = PseudoVSOXSEG4EI64_V_M4_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7053] }, // Inst #8821 = PseudoVSOXSEG4EI64_V_M4_MF2 + { 6, &RISCVDescs.OperandInfo[7047] }, // Inst #8820 = PseudoVSOXSEG4EI64_V_M4_M2_MASK + { 5, &RISCVDescs.OperandInfo[7042] }, // Inst #8819 = PseudoVSOXSEG4EI64_V_M4_M2 + { 6, &RISCVDescs.OperandInfo[7058] }, // Inst #8818 = PseudoVSOXSEG4EI64_V_M4_M1_MASK + { 5, &RISCVDescs.OperandInfo[7053] }, // Inst #8817 = PseudoVSOXSEG4EI64_V_M4_M1 + { 6, &RISCVDescs.OperandInfo[7025] }, // Inst #8816 = PseudoVSOXSEG4EI64_V_M2_MF4_MASK + { 5, &RISCVDescs.OperandInfo[7020] }, // Inst #8815 = PseudoVSOXSEG4EI64_V_M2_MF4 + { 6, &RISCVDescs.OperandInfo[7025] }, // Inst #8814 = PseudoVSOXSEG4EI64_V_M2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7020] }, // Inst #8813 = PseudoVSOXSEG4EI64_V_M2_MF2 + { 6, &RISCVDescs.OperandInfo[7036] }, // Inst #8812 = PseudoVSOXSEG4EI64_V_M2_M2_MASK + { 5, &RISCVDescs.OperandInfo[7031] }, // Inst #8811 = PseudoVSOXSEG4EI64_V_M2_M2 + { 6, &RISCVDescs.OperandInfo[7025] }, // Inst #8810 = PseudoVSOXSEG4EI64_V_M2_M1_MASK + { 5, &RISCVDescs.OperandInfo[7020] }, // Inst #8809 = PseudoVSOXSEG4EI64_V_M2_M1 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #8808 = PseudoVSOXSEG4EI64_V_M1_MF8_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #8807 = PseudoVSOXSEG4EI64_V_M1_MF8 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #8806 = PseudoVSOXSEG4EI64_V_M1_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #8805 = PseudoVSOXSEG4EI64_V_M1_MF4 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #8804 = PseudoVSOXSEG4EI64_V_M1_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #8803 = PseudoVSOXSEG4EI64_V_M1_MF2 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #8802 = PseudoVSOXSEG4EI64_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #8801 = PseudoVSOXSEG4EI64_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #8800 = PseudoVSOXSEG4EI32_V_MF2_MF8_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #8799 = PseudoVSOXSEG4EI32_V_MF2_MF8 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #8798 = PseudoVSOXSEG4EI32_V_MF2_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #8797 = PseudoVSOXSEG4EI32_V_MF2_MF4 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #8796 = PseudoVSOXSEG4EI32_V_MF2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #8795 = PseudoVSOXSEG4EI32_V_MF2_MF2 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #8794 = PseudoVSOXSEG4EI32_V_MF2_M1_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #8793 = PseudoVSOXSEG4EI32_V_MF2_M1 + { 6, &RISCVDescs.OperandInfo[7069] }, // Inst #8792 = PseudoVSOXSEG4EI32_V_M8_M2_MASK + { 5, &RISCVDescs.OperandInfo[7064] }, // Inst #8791 = PseudoVSOXSEG4EI32_V_M8_M2 + { 6, &RISCVDescs.OperandInfo[7047] }, // Inst #8790 = PseudoVSOXSEG4EI32_V_M4_M2_MASK + { 5, &RISCVDescs.OperandInfo[7042] }, // Inst #8789 = PseudoVSOXSEG4EI32_V_M4_M2 + { 6, &RISCVDescs.OperandInfo[7058] }, // Inst #8788 = PseudoVSOXSEG4EI32_V_M4_M1_MASK + { 5, &RISCVDescs.OperandInfo[7053] }, // Inst #8787 = PseudoVSOXSEG4EI32_V_M4_M1 + { 6, &RISCVDescs.OperandInfo[7025] }, // Inst #8786 = PseudoVSOXSEG4EI32_V_M2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[7020] }, // Inst #8785 = PseudoVSOXSEG4EI32_V_M2_MF2 + { 6, &RISCVDescs.OperandInfo[7036] }, // Inst #8784 = PseudoVSOXSEG4EI32_V_M2_M2_MASK + { 5, &RISCVDescs.OperandInfo[7031] }, // Inst #8783 = PseudoVSOXSEG4EI32_V_M2_M2 + { 6, &RISCVDescs.OperandInfo[7025] }, // Inst #8782 = PseudoVSOXSEG4EI32_V_M2_M1_MASK + { 5, &RISCVDescs.OperandInfo[7020] }, // Inst #8781 = PseudoVSOXSEG4EI32_V_M2_M1 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #8780 = PseudoVSOXSEG4EI32_V_M1_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #8779 = PseudoVSOXSEG4EI32_V_M1_MF4 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #8778 = PseudoVSOXSEG4EI32_V_M1_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #8777 = PseudoVSOXSEG4EI32_V_M1_MF2 + { 6, &RISCVDescs.OperandInfo[7014] }, // Inst #8776 = PseudoVSOXSEG4EI32_V_M1_M2_MASK + { 5, &RISCVDescs.OperandInfo[7009] }, // Inst #8775 = PseudoVSOXSEG4EI32_V_M1_M2 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #8774 = PseudoVSOXSEG4EI32_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #8773 = PseudoVSOXSEG4EI32_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #8772 = PseudoVSOXSEG4EI16_V_MF4_MF8_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #8771 = PseudoVSOXSEG4EI16_V_MF4_MF8 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #8770 = PseudoVSOXSEG4EI16_V_MF4_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #8769 = PseudoVSOXSEG4EI16_V_MF4_MF4 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #8768 = PseudoVSOXSEG4EI16_V_MF4_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #8767 = PseudoVSOXSEG4EI16_V_MF4_MF2 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #8766 = PseudoVSOXSEG4EI16_V_MF4_M1_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #8765 = PseudoVSOXSEG4EI16_V_MF4_M1 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #8764 = PseudoVSOXSEG4EI16_V_MF2_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #8763 = PseudoVSOXSEG4EI16_V_MF2_MF4 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #8762 = PseudoVSOXSEG4EI16_V_MF2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #8761 = PseudoVSOXSEG4EI16_V_MF2_MF2 + { 6, &RISCVDescs.OperandInfo[7014] }, // Inst #8760 = PseudoVSOXSEG4EI16_V_MF2_M2_MASK + { 5, &RISCVDescs.OperandInfo[7009] }, // Inst #8759 = PseudoVSOXSEG4EI16_V_MF2_M2 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #8758 = PseudoVSOXSEG4EI16_V_MF2_M1_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #8757 = PseudoVSOXSEG4EI16_V_MF2_M1 + { 6, &RISCVDescs.OperandInfo[7047] }, // Inst #8756 = PseudoVSOXSEG4EI16_V_M4_M2_MASK + { 5, &RISCVDescs.OperandInfo[7042] }, // Inst #8755 = PseudoVSOXSEG4EI16_V_M4_M2 + { 6, &RISCVDescs.OperandInfo[7036] }, // Inst #8754 = PseudoVSOXSEG4EI16_V_M2_M2_MASK + { 5, &RISCVDescs.OperandInfo[7031] }, // Inst #8753 = PseudoVSOXSEG4EI16_V_M2_M2 + { 6, &RISCVDescs.OperandInfo[7025] }, // Inst #8752 = PseudoVSOXSEG4EI16_V_M2_M1_MASK + { 5, &RISCVDescs.OperandInfo[7020] }, // Inst #8751 = PseudoVSOXSEG4EI16_V_M2_M1 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #8750 = PseudoVSOXSEG4EI16_V_M1_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #8749 = PseudoVSOXSEG4EI16_V_M1_MF2 + { 6, &RISCVDescs.OperandInfo[7014] }, // Inst #8748 = PseudoVSOXSEG4EI16_V_M1_M2_MASK + { 5, &RISCVDescs.OperandInfo[7009] }, // Inst #8747 = PseudoVSOXSEG4EI16_V_M1_M2 + { 6, &RISCVDescs.OperandInfo[7003] }, // Inst #8746 = PseudoVSOXSEG4EI16_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[6998] }, // Inst #8745 = PseudoVSOXSEG4EI16_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #8744 = PseudoVSOXSEG3EI8_V_MF8_MF8_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #8743 = PseudoVSOXSEG3EI8_V_MF8_MF8 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #8742 = PseudoVSOXSEG3EI8_V_MF8_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #8741 = PseudoVSOXSEG3EI8_V_MF8_MF4 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #8740 = PseudoVSOXSEG3EI8_V_MF8_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #8739 = PseudoVSOXSEG3EI8_V_MF8_MF2 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #8738 = PseudoVSOXSEG3EI8_V_MF8_M1_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #8737 = PseudoVSOXSEG3EI8_V_MF8_M1 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #8736 = PseudoVSOXSEG3EI8_V_MF4_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #8735 = PseudoVSOXSEG3EI8_V_MF4_MF4 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #8734 = PseudoVSOXSEG3EI8_V_MF4_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #8733 = PseudoVSOXSEG3EI8_V_MF4_MF2 + { 6, &RISCVDescs.OperandInfo[6926] }, // Inst #8732 = PseudoVSOXSEG3EI8_V_MF4_M2_MASK + { 5, &RISCVDescs.OperandInfo[6921] }, // Inst #8731 = PseudoVSOXSEG3EI8_V_MF4_M2 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #8730 = PseudoVSOXSEG3EI8_V_MF4_M1_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #8729 = PseudoVSOXSEG3EI8_V_MF4_M1 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #8728 = PseudoVSOXSEG3EI8_V_MF2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #8727 = PseudoVSOXSEG3EI8_V_MF2_MF2 + { 6, &RISCVDescs.OperandInfo[6926] }, // Inst #8726 = PseudoVSOXSEG3EI8_V_MF2_M2_MASK + { 5, &RISCVDescs.OperandInfo[6921] }, // Inst #8725 = PseudoVSOXSEG3EI8_V_MF2_M2 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #8724 = PseudoVSOXSEG3EI8_V_MF2_M1_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #8723 = PseudoVSOXSEG3EI8_V_MF2_M1 + { 6, &RISCVDescs.OperandInfo[6948] }, // Inst #8722 = PseudoVSOXSEG3EI8_V_M2_M2_MASK + { 5, &RISCVDescs.OperandInfo[6943] }, // Inst #8721 = PseudoVSOXSEG3EI8_V_M2_M2 + { 6, &RISCVDescs.OperandInfo[6926] }, // Inst #8720 = PseudoVSOXSEG3EI8_V_M1_M2_MASK + { 5, &RISCVDescs.OperandInfo[6921] }, // Inst #8719 = PseudoVSOXSEG3EI8_V_M1_M2 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #8718 = PseudoVSOXSEG3EI8_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #8717 = PseudoVSOXSEG3EI8_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[6981] }, // Inst #8716 = PseudoVSOXSEG3EI64_V_M8_M2_MASK + { 5, &RISCVDescs.OperandInfo[6976] }, // Inst #8715 = PseudoVSOXSEG3EI64_V_M8_M2 + { 6, &RISCVDescs.OperandInfo[6992] }, // Inst #8714 = PseudoVSOXSEG3EI64_V_M8_M1_MASK + { 5, &RISCVDescs.OperandInfo[6987] }, // Inst #8713 = PseudoVSOXSEG3EI64_V_M8_M1 + { 6, &RISCVDescs.OperandInfo[6970] }, // Inst #8712 = PseudoVSOXSEG3EI64_V_M4_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6965] }, // Inst #8711 = PseudoVSOXSEG3EI64_V_M4_MF2 + { 6, &RISCVDescs.OperandInfo[6959] }, // Inst #8710 = PseudoVSOXSEG3EI64_V_M4_M2_MASK + { 5, &RISCVDescs.OperandInfo[6954] }, // Inst #8709 = PseudoVSOXSEG3EI64_V_M4_M2 + { 6, &RISCVDescs.OperandInfo[6970] }, // Inst #8708 = PseudoVSOXSEG3EI64_V_M4_M1_MASK + { 5, &RISCVDescs.OperandInfo[6965] }, // Inst #8707 = PseudoVSOXSEG3EI64_V_M4_M1 + { 6, &RISCVDescs.OperandInfo[6937] }, // Inst #8706 = PseudoVSOXSEG3EI64_V_M2_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6932] }, // Inst #8705 = PseudoVSOXSEG3EI64_V_M2_MF4 + { 6, &RISCVDescs.OperandInfo[6937] }, // Inst #8704 = PseudoVSOXSEG3EI64_V_M2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6932] }, // Inst #8703 = PseudoVSOXSEG3EI64_V_M2_MF2 + { 6, &RISCVDescs.OperandInfo[6948] }, // Inst #8702 = PseudoVSOXSEG3EI64_V_M2_M2_MASK + { 5, &RISCVDescs.OperandInfo[6943] }, // Inst #8701 = PseudoVSOXSEG3EI64_V_M2_M2 + { 6, &RISCVDescs.OperandInfo[6937] }, // Inst #8700 = PseudoVSOXSEG3EI64_V_M2_M1_MASK + { 5, &RISCVDescs.OperandInfo[6932] }, // Inst #8699 = PseudoVSOXSEG3EI64_V_M2_M1 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #8698 = PseudoVSOXSEG3EI64_V_M1_MF8_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #8697 = PseudoVSOXSEG3EI64_V_M1_MF8 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #8696 = PseudoVSOXSEG3EI64_V_M1_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #8695 = PseudoVSOXSEG3EI64_V_M1_MF4 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #8694 = PseudoVSOXSEG3EI64_V_M1_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #8693 = PseudoVSOXSEG3EI64_V_M1_MF2 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #8692 = PseudoVSOXSEG3EI64_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #8691 = PseudoVSOXSEG3EI64_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #8690 = PseudoVSOXSEG3EI32_V_MF2_MF8_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #8689 = PseudoVSOXSEG3EI32_V_MF2_MF8 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #8688 = PseudoVSOXSEG3EI32_V_MF2_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #8687 = PseudoVSOXSEG3EI32_V_MF2_MF4 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #8686 = PseudoVSOXSEG3EI32_V_MF2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #8685 = PseudoVSOXSEG3EI32_V_MF2_MF2 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #8684 = PseudoVSOXSEG3EI32_V_MF2_M1_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #8683 = PseudoVSOXSEG3EI32_V_MF2_M1 + { 6, &RISCVDescs.OperandInfo[6981] }, // Inst #8682 = PseudoVSOXSEG3EI32_V_M8_M2_MASK + { 5, &RISCVDescs.OperandInfo[6976] }, // Inst #8681 = PseudoVSOXSEG3EI32_V_M8_M2 + { 6, &RISCVDescs.OperandInfo[6959] }, // Inst #8680 = PseudoVSOXSEG3EI32_V_M4_M2_MASK + { 5, &RISCVDescs.OperandInfo[6954] }, // Inst #8679 = PseudoVSOXSEG3EI32_V_M4_M2 + { 6, &RISCVDescs.OperandInfo[6970] }, // Inst #8678 = PseudoVSOXSEG3EI32_V_M4_M1_MASK + { 5, &RISCVDescs.OperandInfo[6965] }, // Inst #8677 = PseudoVSOXSEG3EI32_V_M4_M1 + { 6, &RISCVDescs.OperandInfo[6937] }, // Inst #8676 = PseudoVSOXSEG3EI32_V_M2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6932] }, // Inst #8675 = PseudoVSOXSEG3EI32_V_M2_MF2 + { 6, &RISCVDescs.OperandInfo[6948] }, // Inst #8674 = PseudoVSOXSEG3EI32_V_M2_M2_MASK + { 5, &RISCVDescs.OperandInfo[6943] }, // Inst #8673 = PseudoVSOXSEG3EI32_V_M2_M2 + { 6, &RISCVDescs.OperandInfo[6937] }, // Inst #8672 = PseudoVSOXSEG3EI32_V_M2_M1_MASK + { 5, &RISCVDescs.OperandInfo[6932] }, // Inst #8671 = PseudoVSOXSEG3EI32_V_M2_M1 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #8670 = PseudoVSOXSEG3EI32_V_M1_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #8669 = PseudoVSOXSEG3EI32_V_M1_MF4 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #8668 = PseudoVSOXSEG3EI32_V_M1_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #8667 = PseudoVSOXSEG3EI32_V_M1_MF2 + { 6, &RISCVDescs.OperandInfo[6926] }, // Inst #8666 = PseudoVSOXSEG3EI32_V_M1_M2_MASK + { 5, &RISCVDescs.OperandInfo[6921] }, // Inst #8665 = PseudoVSOXSEG3EI32_V_M1_M2 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #8664 = PseudoVSOXSEG3EI32_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #8663 = PseudoVSOXSEG3EI32_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #8662 = PseudoVSOXSEG3EI16_V_MF4_MF8_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #8661 = PseudoVSOXSEG3EI16_V_MF4_MF8 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #8660 = PseudoVSOXSEG3EI16_V_MF4_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #8659 = PseudoVSOXSEG3EI16_V_MF4_MF4 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #8658 = PseudoVSOXSEG3EI16_V_MF4_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #8657 = PseudoVSOXSEG3EI16_V_MF4_MF2 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #8656 = PseudoVSOXSEG3EI16_V_MF4_M1_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #8655 = PseudoVSOXSEG3EI16_V_MF4_M1 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #8654 = PseudoVSOXSEG3EI16_V_MF2_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #8653 = PseudoVSOXSEG3EI16_V_MF2_MF4 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #8652 = PseudoVSOXSEG3EI16_V_MF2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #8651 = PseudoVSOXSEG3EI16_V_MF2_MF2 + { 6, &RISCVDescs.OperandInfo[6926] }, // Inst #8650 = PseudoVSOXSEG3EI16_V_MF2_M2_MASK + { 5, &RISCVDescs.OperandInfo[6921] }, // Inst #8649 = PseudoVSOXSEG3EI16_V_MF2_M2 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #8648 = PseudoVSOXSEG3EI16_V_MF2_M1_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #8647 = PseudoVSOXSEG3EI16_V_MF2_M1 + { 6, &RISCVDescs.OperandInfo[6959] }, // Inst #8646 = PseudoVSOXSEG3EI16_V_M4_M2_MASK + { 5, &RISCVDescs.OperandInfo[6954] }, // Inst #8645 = PseudoVSOXSEG3EI16_V_M4_M2 + { 6, &RISCVDescs.OperandInfo[6948] }, // Inst #8644 = PseudoVSOXSEG3EI16_V_M2_M2_MASK + { 5, &RISCVDescs.OperandInfo[6943] }, // Inst #8643 = PseudoVSOXSEG3EI16_V_M2_M2 + { 6, &RISCVDescs.OperandInfo[6937] }, // Inst #8642 = PseudoVSOXSEG3EI16_V_M2_M1_MASK + { 5, &RISCVDescs.OperandInfo[6932] }, // Inst #8641 = PseudoVSOXSEG3EI16_V_M2_M1 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #8640 = PseudoVSOXSEG3EI16_V_M1_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #8639 = PseudoVSOXSEG3EI16_V_M1_MF2 + { 6, &RISCVDescs.OperandInfo[6926] }, // Inst #8638 = PseudoVSOXSEG3EI16_V_M1_M2_MASK + { 5, &RISCVDescs.OperandInfo[6921] }, // Inst #8637 = PseudoVSOXSEG3EI16_V_M1_M2 + { 6, &RISCVDescs.OperandInfo[6915] }, // Inst #8636 = PseudoVSOXSEG3EI16_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[6910] }, // Inst #8635 = PseudoVSOXSEG3EI16_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #8634 = PseudoVSOXSEG2EI8_V_MF8_MF8_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #8633 = PseudoVSOXSEG2EI8_V_MF8_MF8 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #8632 = PseudoVSOXSEG2EI8_V_MF8_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #8631 = PseudoVSOXSEG2EI8_V_MF8_MF4 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #8630 = PseudoVSOXSEG2EI8_V_MF8_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #8629 = PseudoVSOXSEG2EI8_V_MF8_MF2 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #8628 = PseudoVSOXSEG2EI8_V_MF8_M1_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #8627 = PseudoVSOXSEG2EI8_V_MF8_M1 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #8626 = PseudoVSOXSEG2EI8_V_MF4_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #8625 = PseudoVSOXSEG2EI8_V_MF4_MF4 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #8624 = PseudoVSOXSEG2EI8_V_MF4_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #8623 = PseudoVSOXSEG2EI8_V_MF4_MF2 + { 6, &RISCVDescs.OperandInfo[6794] }, // Inst #8622 = PseudoVSOXSEG2EI8_V_MF4_M2_MASK + { 5, &RISCVDescs.OperandInfo[6789] }, // Inst #8621 = PseudoVSOXSEG2EI8_V_MF4_M2 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #8620 = PseudoVSOXSEG2EI8_V_MF4_M1_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #8619 = PseudoVSOXSEG2EI8_V_MF4_M1 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #8618 = PseudoVSOXSEG2EI8_V_MF2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #8617 = PseudoVSOXSEG2EI8_V_MF2_MF2 + { 6, &RISCVDescs.OperandInfo[6805] }, // Inst #8616 = PseudoVSOXSEG2EI8_V_MF2_M4_MASK + { 5, &RISCVDescs.OperandInfo[6800] }, // Inst #8615 = PseudoVSOXSEG2EI8_V_MF2_M4 + { 6, &RISCVDescs.OperandInfo[6794] }, // Inst #8614 = PseudoVSOXSEG2EI8_V_MF2_M2_MASK + { 5, &RISCVDescs.OperandInfo[6789] }, // Inst #8613 = PseudoVSOXSEG2EI8_V_MF2_M2 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #8612 = PseudoVSOXSEG2EI8_V_MF2_M1_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #8611 = PseudoVSOXSEG2EI8_V_MF2_M1 + { 6, &RISCVDescs.OperandInfo[6860] }, // Inst #8610 = PseudoVSOXSEG2EI8_V_M4_M4_MASK + { 5, &RISCVDescs.OperandInfo[6855] }, // Inst #8609 = PseudoVSOXSEG2EI8_V_M4_M4 + { 6, &RISCVDescs.OperandInfo[6838] }, // Inst #8608 = PseudoVSOXSEG2EI8_V_M2_M4_MASK + { 5, &RISCVDescs.OperandInfo[6833] }, // Inst #8607 = PseudoVSOXSEG2EI8_V_M2_M4 + { 6, &RISCVDescs.OperandInfo[6827] }, // Inst #8606 = PseudoVSOXSEG2EI8_V_M2_M2_MASK + { 5, &RISCVDescs.OperandInfo[6822] }, // Inst #8605 = PseudoVSOXSEG2EI8_V_M2_M2 + { 6, &RISCVDescs.OperandInfo[6805] }, // Inst #8604 = PseudoVSOXSEG2EI8_V_M1_M4_MASK + { 5, &RISCVDescs.OperandInfo[6800] }, // Inst #8603 = PseudoVSOXSEG2EI8_V_M1_M4 + { 6, &RISCVDescs.OperandInfo[6794] }, // Inst #8602 = PseudoVSOXSEG2EI8_V_M1_M2_MASK + { 5, &RISCVDescs.OperandInfo[6789] }, // Inst #8601 = PseudoVSOXSEG2EI8_V_M1_M2 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #8600 = PseudoVSOXSEG2EI8_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #8599 = PseudoVSOXSEG2EI8_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[6871] }, // Inst #8598 = PseudoVSOXSEG2EI64_V_M8_M4_MASK + { 5, &RISCVDescs.OperandInfo[6866] }, // Inst #8597 = PseudoVSOXSEG2EI64_V_M8_M4 + { 6, &RISCVDescs.OperandInfo[6893] }, // Inst #8596 = PseudoVSOXSEG2EI64_V_M8_M2_MASK + { 5, &RISCVDescs.OperandInfo[6888] }, // Inst #8595 = PseudoVSOXSEG2EI64_V_M8_M2 + { 6, &RISCVDescs.OperandInfo[6904] }, // Inst #8594 = PseudoVSOXSEG2EI64_V_M8_M1_MASK + { 5, &RISCVDescs.OperandInfo[6899] }, // Inst #8593 = PseudoVSOXSEG2EI64_V_M8_M1 + { 6, &RISCVDescs.OperandInfo[6882] }, // Inst #8592 = PseudoVSOXSEG2EI64_V_M4_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6877] }, // Inst #8591 = PseudoVSOXSEG2EI64_V_M4_MF2 + { 6, &RISCVDescs.OperandInfo[6860] }, // Inst #8590 = PseudoVSOXSEG2EI64_V_M4_M4_MASK + { 5, &RISCVDescs.OperandInfo[6855] }, // Inst #8589 = PseudoVSOXSEG2EI64_V_M4_M4 + { 6, &RISCVDescs.OperandInfo[6849] }, // Inst #8588 = PseudoVSOXSEG2EI64_V_M4_M2_MASK + { 5, &RISCVDescs.OperandInfo[6844] }, // Inst #8587 = PseudoVSOXSEG2EI64_V_M4_M2 + { 6, &RISCVDescs.OperandInfo[6882] }, // Inst #8586 = PseudoVSOXSEG2EI64_V_M4_M1_MASK + { 5, &RISCVDescs.OperandInfo[6877] }, // Inst #8585 = PseudoVSOXSEG2EI64_V_M4_M1 + { 6, &RISCVDescs.OperandInfo[6816] }, // Inst #8584 = PseudoVSOXSEG2EI64_V_M2_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6811] }, // Inst #8583 = PseudoVSOXSEG2EI64_V_M2_MF4 + { 6, &RISCVDescs.OperandInfo[6816] }, // Inst #8582 = PseudoVSOXSEG2EI64_V_M2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6811] }, // Inst #8581 = PseudoVSOXSEG2EI64_V_M2_MF2 + { 6, &RISCVDescs.OperandInfo[6827] }, // Inst #8580 = PseudoVSOXSEG2EI64_V_M2_M2_MASK + { 5, &RISCVDescs.OperandInfo[6822] }, // Inst #8579 = PseudoVSOXSEG2EI64_V_M2_M2 + { 6, &RISCVDescs.OperandInfo[6816] }, // Inst #8578 = PseudoVSOXSEG2EI64_V_M2_M1_MASK + { 5, &RISCVDescs.OperandInfo[6811] }, // Inst #8577 = PseudoVSOXSEG2EI64_V_M2_M1 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #8576 = PseudoVSOXSEG2EI64_V_M1_MF8_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #8575 = PseudoVSOXSEG2EI64_V_M1_MF8 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #8574 = PseudoVSOXSEG2EI64_V_M1_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #8573 = PseudoVSOXSEG2EI64_V_M1_MF4 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #8572 = PseudoVSOXSEG2EI64_V_M1_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #8571 = PseudoVSOXSEG2EI64_V_M1_MF2 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #8570 = PseudoVSOXSEG2EI64_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #8569 = PseudoVSOXSEG2EI64_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #8568 = PseudoVSOXSEG2EI32_V_MF2_MF8_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #8567 = PseudoVSOXSEG2EI32_V_MF2_MF8 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #8566 = PseudoVSOXSEG2EI32_V_MF2_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #8565 = PseudoVSOXSEG2EI32_V_MF2_MF4 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #8564 = PseudoVSOXSEG2EI32_V_MF2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #8563 = PseudoVSOXSEG2EI32_V_MF2_MF2 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #8562 = PseudoVSOXSEG2EI32_V_MF2_M1_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #8561 = PseudoVSOXSEG2EI32_V_MF2_M1 + { 6, &RISCVDescs.OperandInfo[6871] }, // Inst #8560 = PseudoVSOXSEG2EI32_V_M8_M4_MASK + { 5, &RISCVDescs.OperandInfo[6866] }, // Inst #8559 = PseudoVSOXSEG2EI32_V_M8_M4 + { 6, &RISCVDescs.OperandInfo[6893] }, // Inst #8558 = PseudoVSOXSEG2EI32_V_M8_M2_MASK + { 5, &RISCVDescs.OperandInfo[6888] }, // Inst #8557 = PseudoVSOXSEG2EI32_V_M8_M2 + { 6, &RISCVDescs.OperandInfo[6860] }, // Inst #8556 = PseudoVSOXSEG2EI32_V_M4_M4_MASK + { 5, &RISCVDescs.OperandInfo[6855] }, // Inst #8555 = PseudoVSOXSEG2EI32_V_M4_M4 + { 6, &RISCVDescs.OperandInfo[6849] }, // Inst #8554 = PseudoVSOXSEG2EI32_V_M4_M2_MASK + { 5, &RISCVDescs.OperandInfo[6844] }, // Inst #8553 = PseudoVSOXSEG2EI32_V_M4_M2 + { 6, &RISCVDescs.OperandInfo[6882] }, // Inst #8552 = PseudoVSOXSEG2EI32_V_M4_M1_MASK + { 5, &RISCVDescs.OperandInfo[6877] }, // Inst #8551 = PseudoVSOXSEG2EI32_V_M4_M1 + { 6, &RISCVDescs.OperandInfo[6816] }, // Inst #8550 = PseudoVSOXSEG2EI32_V_M2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6811] }, // Inst #8549 = PseudoVSOXSEG2EI32_V_M2_MF2 + { 6, &RISCVDescs.OperandInfo[6838] }, // Inst #8548 = PseudoVSOXSEG2EI32_V_M2_M4_MASK + { 5, &RISCVDescs.OperandInfo[6833] }, // Inst #8547 = PseudoVSOXSEG2EI32_V_M2_M4 + { 6, &RISCVDescs.OperandInfo[6827] }, // Inst #8546 = PseudoVSOXSEG2EI32_V_M2_M2_MASK + { 5, &RISCVDescs.OperandInfo[6822] }, // Inst #8545 = PseudoVSOXSEG2EI32_V_M2_M2 + { 6, &RISCVDescs.OperandInfo[6816] }, // Inst #8544 = PseudoVSOXSEG2EI32_V_M2_M1_MASK + { 5, &RISCVDescs.OperandInfo[6811] }, // Inst #8543 = PseudoVSOXSEG2EI32_V_M2_M1 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #8542 = PseudoVSOXSEG2EI32_V_M1_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #8541 = PseudoVSOXSEG2EI32_V_M1_MF4 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #8540 = PseudoVSOXSEG2EI32_V_M1_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #8539 = PseudoVSOXSEG2EI32_V_M1_MF2 + { 6, &RISCVDescs.OperandInfo[6794] }, // Inst #8538 = PseudoVSOXSEG2EI32_V_M1_M2_MASK + { 5, &RISCVDescs.OperandInfo[6789] }, // Inst #8537 = PseudoVSOXSEG2EI32_V_M1_M2 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #8536 = PseudoVSOXSEG2EI32_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #8535 = PseudoVSOXSEG2EI32_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #8534 = PseudoVSOXSEG2EI16_V_MF4_MF8_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #8533 = PseudoVSOXSEG2EI16_V_MF4_MF8 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #8532 = PseudoVSOXSEG2EI16_V_MF4_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #8531 = PseudoVSOXSEG2EI16_V_MF4_MF4 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #8530 = PseudoVSOXSEG2EI16_V_MF4_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #8529 = PseudoVSOXSEG2EI16_V_MF4_MF2 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #8528 = PseudoVSOXSEG2EI16_V_MF4_M1_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #8527 = PseudoVSOXSEG2EI16_V_MF4_M1 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #8526 = PseudoVSOXSEG2EI16_V_MF2_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #8525 = PseudoVSOXSEG2EI16_V_MF2_MF4 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #8524 = PseudoVSOXSEG2EI16_V_MF2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #8523 = PseudoVSOXSEG2EI16_V_MF2_MF2 + { 6, &RISCVDescs.OperandInfo[6794] }, // Inst #8522 = PseudoVSOXSEG2EI16_V_MF2_M2_MASK + { 5, &RISCVDescs.OperandInfo[6789] }, // Inst #8521 = PseudoVSOXSEG2EI16_V_MF2_M2 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #8520 = PseudoVSOXSEG2EI16_V_MF2_M1_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #8519 = PseudoVSOXSEG2EI16_V_MF2_M1 + { 6, &RISCVDescs.OperandInfo[6871] }, // Inst #8518 = PseudoVSOXSEG2EI16_V_M8_M4_MASK + { 5, &RISCVDescs.OperandInfo[6866] }, // Inst #8517 = PseudoVSOXSEG2EI16_V_M8_M4 + { 6, &RISCVDescs.OperandInfo[6860] }, // Inst #8516 = PseudoVSOXSEG2EI16_V_M4_M4_MASK + { 5, &RISCVDescs.OperandInfo[6855] }, // Inst #8515 = PseudoVSOXSEG2EI16_V_M4_M4 + { 6, &RISCVDescs.OperandInfo[6849] }, // Inst #8514 = PseudoVSOXSEG2EI16_V_M4_M2_MASK + { 5, &RISCVDescs.OperandInfo[6844] }, // Inst #8513 = PseudoVSOXSEG2EI16_V_M4_M2 + { 6, &RISCVDescs.OperandInfo[6838] }, // Inst #8512 = PseudoVSOXSEG2EI16_V_M2_M4_MASK + { 5, &RISCVDescs.OperandInfo[6833] }, // Inst #8511 = PseudoVSOXSEG2EI16_V_M2_M4 + { 6, &RISCVDescs.OperandInfo[6827] }, // Inst #8510 = PseudoVSOXSEG2EI16_V_M2_M2_MASK + { 5, &RISCVDescs.OperandInfo[6822] }, // Inst #8509 = PseudoVSOXSEG2EI16_V_M2_M2 + { 6, &RISCVDescs.OperandInfo[6816] }, // Inst #8508 = PseudoVSOXSEG2EI16_V_M2_M1_MASK + { 5, &RISCVDescs.OperandInfo[6811] }, // Inst #8507 = PseudoVSOXSEG2EI16_V_M2_M1 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #8506 = PseudoVSOXSEG2EI16_V_M1_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #8505 = PseudoVSOXSEG2EI16_V_M1_MF2 + { 6, &RISCVDescs.OperandInfo[6805] }, // Inst #8504 = PseudoVSOXSEG2EI16_V_M1_M4_MASK + { 5, &RISCVDescs.OperandInfo[6800] }, // Inst #8503 = PseudoVSOXSEG2EI16_V_M1_M4 + { 6, &RISCVDescs.OperandInfo[6794] }, // Inst #8502 = PseudoVSOXSEG2EI16_V_M1_M2_MASK + { 5, &RISCVDescs.OperandInfo[6789] }, // Inst #8501 = PseudoVSOXSEG2EI16_V_M1_M2 + { 6, &RISCVDescs.OperandInfo[6783] }, // Inst #8500 = PseudoVSOXSEG2EI16_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[6778] }, // Inst #8499 = PseudoVSOXSEG2EI16_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #8498 = PseudoVSOXEI8_V_MF8_MF8_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #8497 = PseudoVSOXEI8_V_MF8_MF8 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #8496 = PseudoVSOXEI8_V_MF8_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #8495 = PseudoVSOXEI8_V_MF8_MF4 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #8494 = PseudoVSOXEI8_V_MF8_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #8493 = PseudoVSOXEI8_V_MF8_MF2 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #8492 = PseudoVSOXEI8_V_MF8_M1_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #8491 = PseudoVSOXEI8_V_MF8_M1 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #8490 = PseudoVSOXEI8_V_MF4_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #8489 = PseudoVSOXEI8_V_MF4_MF4 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #8488 = PseudoVSOXEI8_V_MF4_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #8487 = PseudoVSOXEI8_V_MF4_MF2 + { 6, &RISCVDescs.OperandInfo[6618] }, // Inst #8486 = PseudoVSOXEI8_V_MF4_M2_MASK + { 5, &RISCVDescs.OperandInfo[6613] }, // Inst #8485 = PseudoVSOXEI8_V_MF4_M2 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #8484 = PseudoVSOXEI8_V_MF4_M1_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #8483 = PseudoVSOXEI8_V_MF4_M1 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #8482 = PseudoVSOXEI8_V_MF2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #8481 = PseudoVSOXEI8_V_MF2_MF2 + { 6, &RISCVDescs.OperandInfo[6629] }, // Inst #8480 = PseudoVSOXEI8_V_MF2_M4_MASK + { 5, &RISCVDescs.OperandInfo[6624] }, // Inst #8479 = PseudoVSOXEI8_V_MF2_M4 + { 6, &RISCVDescs.OperandInfo[6618] }, // Inst #8478 = PseudoVSOXEI8_V_MF2_M2_MASK + { 5, &RISCVDescs.OperandInfo[6613] }, // Inst #8477 = PseudoVSOXEI8_V_MF2_M2 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #8476 = PseudoVSOXEI8_V_MF2_M1_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #8475 = PseudoVSOXEI8_V_MF2_M1 + { 6, &RISCVDescs.OperandInfo[6728] }, // Inst #8474 = PseudoVSOXEI8_V_M8_M8_MASK + { 5, &RISCVDescs.OperandInfo[6723] }, // Inst #8473 = PseudoVSOXEI8_V_M8_M8 + { 6, &RISCVDescs.OperandInfo[6706] }, // Inst #8472 = PseudoVSOXEI8_V_M4_M8_MASK + { 5, &RISCVDescs.OperandInfo[6701] }, // Inst #8471 = PseudoVSOXEI8_V_M4_M8 + { 6, &RISCVDescs.OperandInfo[6695] }, // Inst #8470 = PseudoVSOXEI8_V_M4_M4_MASK + { 5, &RISCVDescs.OperandInfo[6690] }, // Inst #8469 = PseudoVSOXEI8_V_M4_M4 + { 6, &RISCVDescs.OperandInfo[6673] }, // Inst #8468 = PseudoVSOXEI8_V_M2_M8_MASK + { 5, &RISCVDescs.OperandInfo[6668] }, // Inst #8467 = PseudoVSOXEI8_V_M2_M8 + { 6, &RISCVDescs.OperandInfo[6662] }, // Inst #8466 = PseudoVSOXEI8_V_M2_M4_MASK + { 5, &RISCVDescs.OperandInfo[6657] }, // Inst #8465 = PseudoVSOXEI8_V_M2_M4 + { 6, &RISCVDescs.OperandInfo[6651] }, // Inst #8464 = PseudoVSOXEI8_V_M2_M2_MASK + { 5, &RISCVDescs.OperandInfo[6646] }, // Inst #8463 = PseudoVSOXEI8_V_M2_M2 + { 6, &RISCVDescs.OperandInfo[6772] }, // Inst #8462 = PseudoVSOXEI8_V_M1_M8_MASK + { 5, &RISCVDescs.OperandInfo[6767] }, // Inst #8461 = PseudoVSOXEI8_V_M1_M8 + { 6, &RISCVDescs.OperandInfo[6629] }, // Inst #8460 = PseudoVSOXEI8_V_M1_M4_MASK + { 5, &RISCVDescs.OperandInfo[6624] }, // Inst #8459 = PseudoVSOXEI8_V_M1_M4 + { 6, &RISCVDescs.OperandInfo[6618] }, // Inst #8458 = PseudoVSOXEI8_V_M1_M2_MASK + { 5, &RISCVDescs.OperandInfo[6613] }, // Inst #8457 = PseudoVSOXEI8_V_M1_M2 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #8456 = PseudoVSOXEI8_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #8455 = PseudoVSOXEI8_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[6728] }, // Inst #8454 = PseudoVSOXEI64_V_M8_M8_MASK + { 5, &RISCVDescs.OperandInfo[6723] }, // Inst #8453 = PseudoVSOXEI64_V_M8_M8 + { 6, &RISCVDescs.OperandInfo[6717] }, // Inst #8452 = PseudoVSOXEI64_V_M8_M4_MASK + { 5, &RISCVDescs.OperandInfo[6712] }, // Inst #8451 = PseudoVSOXEI64_V_M8_M4 + { 6, &RISCVDescs.OperandInfo[6750] }, // Inst #8450 = PseudoVSOXEI64_V_M8_M2_MASK + { 5, &RISCVDescs.OperandInfo[6745] }, // Inst #8449 = PseudoVSOXEI64_V_M8_M2 + { 6, &RISCVDescs.OperandInfo[6761] }, // Inst #8448 = PseudoVSOXEI64_V_M8_M1_MASK + { 5, &RISCVDescs.OperandInfo[6756] }, // Inst #8447 = PseudoVSOXEI64_V_M8_M1 + { 6, &RISCVDescs.OperandInfo[6739] }, // Inst #8446 = PseudoVSOXEI64_V_M4_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6734] }, // Inst #8445 = PseudoVSOXEI64_V_M4_MF2 + { 6, &RISCVDescs.OperandInfo[6695] }, // Inst #8444 = PseudoVSOXEI64_V_M4_M4_MASK + { 5, &RISCVDescs.OperandInfo[6690] }, // Inst #8443 = PseudoVSOXEI64_V_M4_M4 + { 6, &RISCVDescs.OperandInfo[6684] }, // Inst #8442 = PseudoVSOXEI64_V_M4_M2_MASK + { 5, &RISCVDescs.OperandInfo[6679] }, // Inst #8441 = PseudoVSOXEI64_V_M4_M2 + { 6, &RISCVDescs.OperandInfo[6739] }, // Inst #8440 = PseudoVSOXEI64_V_M4_M1_MASK + { 5, &RISCVDescs.OperandInfo[6734] }, // Inst #8439 = PseudoVSOXEI64_V_M4_M1 + { 6, &RISCVDescs.OperandInfo[6640] }, // Inst #8438 = PseudoVSOXEI64_V_M2_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6635] }, // Inst #8437 = PseudoVSOXEI64_V_M2_MF4 + { 6, &RISCVDescs.OperandInfo[6640] }, // Inst #8436 = PseudoVSOXEI64_V_M2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6635] }, // Inst #8435 = PseudoVSOXEI64_V_M2_MF2 + { 6, &RISCVDescs.OperandInfo[6651] }, // Inst #8434 = PseudoVSOXEI64_V_M2_M2_MASK + { 5, &RISCVDescs.OperandInfo[6646] }, // Inst #8433 = PseudoVSOXEI64_V_M2_M2 + { 6, &RISCVDescs.OperandInfo[6640] }, // Inst #8432 = PseudoVSOXEI64_V_M2_M1_MASK + { 5, &RISCVDescs.OperandInfo[6635] }, // Inst #8431 = PseudoVSOXEI64_V_M2_M1 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #8430 = PseudoVSOXEI64_V_M1_MF8_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #8429 = PseudoVSOXEI64_V_M1_MF8 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #8428 = PseudoVSOXEI64_V_M1_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #8427 = PseudoVSOXEI64_V_M1_MF4 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #8426 = PseudoVSOXEI64_V_M1_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #8425 = PseudoVSOXEI64_V_M1_MF2 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #8424 = PseudoVSOXEI64_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #8423 = PseudoVSOXEI64_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #8422 = PseudoVSOXEI32_V_MF2_MF8_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #8421 = PseudoVSOXEI32_V_MF2_MF8 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #8420 = PseudoVSOXEI32_V_MF2_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #8419 = PseudoVSOXEI32_V_MF2_MF4 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #8418 = PseudoVSOXEI32_V_MF2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #8417 = PseudoVSOXEI32_V_MF2_MF2 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #8416 = PseudoVSOXEI32_V_MF2_M1_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #8415 = PseudoVSOXEI32_V_MF2_M1 + { 6, &RISCVDescs.OperandInfo[6728] }, // Inst #8414 = PseudoVSOXEI32_V_M8_M8_MASK + { 5, &RISCVDescs.OperandInfo[6723] }, // Inst #8413 = PseudoVSOXEI32_V_M8_M8 + { 6, &RISCVDescs.OperandInfo[6717] }, // Inst #8412 = PseudoVSOXEI32_V_M8_M4_MASK + { 5, &RISCVDescs.OperandInfo[6712] }, // Inst #8411 = PseudoVSOXEI32_V_M8_M4 + { 6, &RISCVDescs.OperandInfo[6750] }, // Inst #8410 = PseudoVSOXEI32_V_M8_M2_MASK + { 5, &RISCVDescs.OperandInfo[6745] }, // Inst #8409 = PseudoVSOXEI32_V_M8_M2 + { 6, &RISCVDescs.OperandInfo[6706] }, // Inst #8408 = PseudoVSOXEI32_V_M4_M8_MASK + { 5, &RISCVDescs.OperandInfo[6701] }, // Inst #8407 = PseudoVSOXEI32_V_M4_M8 + { 6, &RISCVDescs.OperandInfo[6695] }, // Inst #8406 = PseudoVSOXEI32_V_M4_M4_MASK + { 5, &RISCVDescs.OperandInfo[6690] }, // Inst #8405 = PseudoVSOXEI32_V_M4_M4 + { 6, &RISCVDescs.OperandInfo[6684] }, // Inst #8404 = PseudoVSOXEI32_V_M4_M2_MASK + { 5, &RISCVDescs.OperandInfo[6679] }, // Inst #8403 = PseudoVSOXEI32_V_M4_M2 + { 6, &RISCVDescs.OperandInfo[6739] }, // Inst #8402 = PseudoVSOXEI32_V_M4_M1_MASK + { 5, &RISCVDescs.OperandInfo[6734] }, // Inst #8401 = PseudoVSOXEI32_V_M4_M1 + { 6, &RISCVDescs.OperandInfo[6640] }, // Inst #8400 = PseudoVSOXEI32_V_M2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6635] }, // Inst #8399 = PseudoVSOXEI32_V_M2_MF2 + { 6, &RISCVDescs.OperandInfo[6662] }, // Inst #8398 = PseudoVSOXEI32_V_M2_M4_MASK + { 5, &RISCVDescs.OperandInfo[6657] }, // Inst #8397 = PseudoVSOXEI32_V_M2_M4 + { 6, &RISCVDescs.OperandInfo[6651] }, // Inst #8396 = PseudoVSOXEI32_V_M2_M2_MASK + { 5, &RISCVDescs.OperandInfo[6646] }, // Inst #8395 = PseudoVSOXEI32_V_M2_M2 + { 6, &RISCVDescs.OperandInfo[6640] }, // Inst #8394 = PseudoVSOXEI32_V_M2_M1_MASK + { 5, &RISCVDescs.OperandInfo[6635] }, // Inst #8393 = PseudoVSOXEI32_V_M2_M1 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #8392 = PseudoVSOXEI32_V_M1_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #8391 = PseudoVSOXEI32_V_M1_MF4 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #8390 = PseudoVSOXEI32_V_M1_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #8389 = PseudoVSOXEI32_V_M1_MF2 + { 6, &RISCVDescs.OperandInfo[6618] }, // Inst #8388 = PseudoVSOXEI32_V_M1_M2_MASK + { 5, &RISCVDescs.OperandInfo[6613] }, // Inst #8387 = PseudoVSOXEI32_V_M1_M2 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #8386 = PseudoVSOXEI32_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #8385 = PseudoVSOXEI32_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #8384 = PseudoVSOXEI16_V_MF4_MF8_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #8383 = PseudoVSOXEI16_V_MF4_MF8 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #8382 = PseudoVSOXEI16_V_MF4_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #8381 = PseudoVSOXEI16_V_MF4_MF4 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #8380 = PseudoVSOXEI16_V_MF4_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #8379 = PseudoVSOXEI16_V_MF4_MF2 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #8378 = PseudoVSOXEI16_V_MF4_M1_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #8377 = PseudoVSOXEI16_V_MF4_M1 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #8376 = PseudoVSOXEI16_V_MF2_MF4_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #8375 = PseudoVSOXEI16_V_MF2_MF4 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #8374 = PseudoVSOXEI16_V_MF2_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #8373 = PseudoVSOXEI16_V_MF2_MF2 + { 6, &RISCVDescs.OperandInfo[6618] }, // Inst #8372 = PseudoVSOXEI16_V_MF2_M2_MASK + { 5, &RISCVDescs.OperandInfo[6613] }, // Inst #8371 = PseudoVSOXEI16_V_MF2_M2 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #8370 = PseudoVSOXEI16_V_MF2_M1_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #8369 = PseudoVSOXEI16_V_MF2_M1 + { 6, &RISCVDescs.OperandInfo[6728] }, // Inst #8368 = PseudoVSOXEI16_V_M8_M8_MASK + { 5, &RISCVDescs.OperandInfo[6723] }, // Inst #8367 = PseudoVSOXEI16_V_M8_M8 + { 6, &RISCVDescs.OperandInfo[6717] }, // Inst #8366 = PseudoVSOXEI16_V_M8_M4_MASK + { 5, &RISCVDescs.OperandInfo[6712] }, // Inst #8365 = PseudoVSOXEI16_V_M8_M4 + { 6, &RISCVDescs.OperandInfo[6706] }, // Inst #8364 = PseudoVSOXEI16_V_M4_M8_MASK + { 5, &RISCVDescs.OperandInfo[6701] }, // Inst #8363 = PseudoVSOXEI16_V_M4_M8 + { 6, &RISCVDescs.OperandInfo[6695] }, // Inst #8362 = PseudoVSOXEI16_V_M4_M4_MASK + { 5, &RISCVDescs.OperandInfo[6690] }, // Inst #8361 = PseudoVSOXEI16_V_M4_M4 + { 6, &RISCVDescs.OperandInfo[6684] }, // Inst #8360 = PseudoVSOXEI16_V_M4_M2_MASK + { 5, &RISCVDescs.OperandInfo[6679] }, // Inst #8359 = PseudoVSOXEI16_V_M4_M2 + { 6, &RISCVDescs.OperandInfo[6673] }, // Inst #8358 = PseudoVSOXEI16_V_M2_M8_MASK + { 5, &RISCVDescs.OperandInfo[6668] }, // Inst #8357 = PseudoVSOXEI16_V_M2_M8 + { 6, &RISCVDescs.OperandInfo[6662] }, // Inst #8356 = PseudoVSOXEI16_V_M2_M4_MASK + { 5, &RISCVDescs.OperandInfo[6657] }, // Inst #8355 = PseudoVSOXEI16_V_M2_M4 + { 6, &RISCVDescs.OperandInfo[6651] }, // Inst #8354 = PseudoVSOXEI16_V_M2_M2_MASK + { 5, &RISCVDescs.OperandInfo[6646] }, // Inst #8353 = PseudoVSOXEI16_V_M2_M2 + { 6, &RISCVDescs.OperandInfo[6640] }, // Inst #8352 = PseudoVSOXEI16_V_M2_M1_MASK + { 5, &RISCVDescs.OperandInfo[6635] }, // Inst #8351 = PseudoVSOXEI16_V_M2_M1 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #8350 = PseudoVSOXEI16_V_M1_MF2_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #8349 = PseudoVSOXEI16_V_M1_MF2 + { 6, &RISCVDescs.OperandInfo[6629] }, // Inst #8348 = PseudoVSOXEI16_V_M1_M4_MASK + { 5, &RISCVDescs.OperandInfo[6624] }, // Inst #8347 = PseudoVSOXEI16_V_M1_M4 + { 6, &RISCVDescs.OperandInfo[6618] }, // Inst #8346 = PseudoVSOXEI16_V_M1_M2_MASK + { 5, &RISCVDescs.OperandInfo[6613] }, // Inst #8345 = PseudoVSOXEI16_V_M1_M2 + { 6, &RISCVDescs.OperandInfo[6607] }, // Inst #8344 = PseudoVSOXEI16_V_M1_M1_MASK + { 5, &RISCVDescs.OperandInfo[6602] }, // Inst #8343 = PseudoVSOXEI16_V_M1_M1 + { 4, &RISCVDescs.OperandInfo[6520] }, // Inst #8342 = PseudoVSM_V_B8 + { 4, &RISCVDescs.OperandInfo[6520] }, // Inst #8341 = PseudoVSM_V_B64 + { 4, &RISCVDescs.OperandInfo[6520] }, // Inst #8340 = PseudoVSM_V_B4 + { 4, &RISCVDescs.OperandInfo[6520] }, // Inst #8339 = PseudoVSM_V_B32 + { 4, &RISCVDescs.OperandInfo[6520] }, // Inst #8338 = PseudoVSM_V_B2 + { 4, &RISCVDescs.OperandInfo[6520] }, // Inst #8337 = PseudoVSM_V_B16 + { 4, &RISCVDescs.OperandInfo[6520] }, // Inst #8336 = PseudoVSM_V_B1 + { 9, &RISCVDescs.OperandInfo[493] }, // Inst #8335 = PseudoVSMUL_VX_MF8_MASK + { 8, &RISCVDescs.OperandInfo[485] }, // Inst #8334 = PseudoVSMUL_VX_MF8 + { 9, &RISCVDescs.OperandInfo[493] }, // Inst #8333 = PseudoVSMUL_VX_MF4_MASK + { 8, &RISCVDescs.OperandInfo[485] }, // Inst #8332 = PseudoVSMUL_VX_MF4 + { 9, &RISCVDescs.OperandInfo[493] }, // Inst #8331 = PseudoVSMUL_VX_MF2_MASK + { 8, &RISCVDescs.OperandInfo[485] }, // Inst #8330 = PseudoVSMUL_VX_MF2 + { 9, &RISCVDescs.OperandInfo[544] }, // Inst #8329 = PseudoVSMUL_VX_M8_MASK + { 8, &RISCVDescs.OperandInfo[536] }, // Inst #8328 = PseudoVSMUL_VX_M8 + { 9, &RISCVDescs.OperandInfo[527] }, // Inst #8327 = PseudoVSMUL_VX_M4_MASK + { 8, &RISCVDescs.OperandInfo[519] }, // Inst #8326 = PseudoVSMUL_VX_M4 + { 9, &RISCVDescs.OperandInfo[510] }, // Inst #8325 = PseudoVSMUL_VX_M2_MASK + { 8, &RISCVDescs.OperandInfo[502] }, // Inst #8324 = PseudoVSMUL_VX_M2 + { 9, &RISCVDescs.OperandInfo[493] }, // Inst #8323 = PseudoVSMUL_VX_M1_MASK + { 8, &RISCVDescs.OperandInfo[485] }, // Inst #8322 = PseudoVSMUL_VX_M1 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #8321 = PseudoVSMUL_VV_MF8_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #8320 = PseudoVSMUL_VV_MF8 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #8319 = PseudoVSMUL_VV_MF4_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #8318 = PseudoVSMUL_VV_MF4 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #8317 = PseudoVSMUL_VV_MF2_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #8316 = PseudoVSMUL_VV_MF2 + { 9, &RISCVDescs.OperandInfo[476] }, // Inst #8315 = PseudoVSMUL_VV_M8_MASK + { 8, &RISCVDescs.OperandInfo[468] }, // Inst #8314 = PseudoVSMUL_VV_M8 + { 9, &RISCVDescs.OperandInfo[459] }, // Inst #8313 = PseudoVSMUL_VV_M4_MASK + { 8, &RISCVDescs.OperandInfo[451] }, // Inst #8312 = PseudoVSMUL_VV_M4 + { 9, &RISCVDescs.OperandInfo[442] }, // Inst #8311 = PseudoVSMUL_VV_M2_MASK + { 8, &RISCVDescs.OperandInfo[434] }, // Inst #8310 = PseudoVSMUL_VV_M2 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #8309 = PseudoVSMUL_VV_M1_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #8308 = PseudoVSMUL_VV_M1 + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #8307 = PseudoVSM4R_VV_MF2 + { 6, &RISCVDescs.OperandInfo[871] }, // Inst #8306 = PseudoVSM4R_VV_M8 + { 6, &RISCVDescs.OperandInfo[847] }, // Inst #8305 = PseudoVSM4R_VV_M4 + { 6, &RISCVDescs.OperandInfo[829] }, // Inst #8304 = PseudoVSM4R_VV_M2 + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #8303 = PseudoVSM4R_VV_M1 + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #8302 = PseudoVSM4R_VS_MF2_MF8 + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #8301 = PseudoVSM4R_VS_MF2_MF4 + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #8300 = PseudoVSM4R_VS_MF2_MF2 + { 6, &RISCVDescs.OperandInfo[853] }, // Inst #8299 = PseudoVSM4R_VS_M8_MF8 + { 6, &RISCVDescs.OperandInfo[853] }, // Inst #8298 = PseudoVSM4R_VS_M8_MF4 + { 6, &RISCVDescs.OperandInfo[853] }, // Inst #8297 = PseudoVSM4R_VS_M8_MF2 + { 6, &RISCVDescs.OperandInfo[865] }, // Inst #8296 = PseudoVSM4R_VS_M8_M4 + { 6, &RISCVDescs.OperandInfo[859] }, // Inst #8295 = PseudoVSM4R_VS_M8_M2 + { 6, &RISCVDescs.OperandInfo[853] }, // Inst #8294 = PseudoVSM4R_VS_M8_M1 + { 6, &RISCVDescs.OperandInfo[835] }, // Inst #8293 = PseudoVSM4R_VS_M4_MF8 + { 6, &RISCVDescs.OperandInfo[835] }, // Inst #8292 = PseudoVSM4R_VS_M4_MF4 + { 6, &RISCVDescs.OperandInfo[835] }, // Inst #8291 = PseudoVSM4R_VS_M4_MF2 + { 6, &RISCVDescs.OperandInfo[847] }, // Inst #8290 = PseudoVSM4R_VS_M4_M4 + { 6, &RISCVDescs.OperandInfo[841] }, // Inst #8289 = PseudoVSM4R_VS_M4_M2 + { 6, &RISCVDescs.OperandInfo[835] }, // Inst #8288 = PseudoVSM4R_VS_M4_M1 + { 6, &RISCVDescs.OperandInfo[823] }, // Inst #8287 = PseudoVSM4R_VS_M2_MF8 + { 6, &RISCVDescs.OperandInfo[823] }, // Inst #8286 = PseudoVSM4R_VS_M2_MF4 + { 6, &RISCVDescs.OperandInfo[823] }, // Inst #8285 = PseudoVSM4R_VS_M2_MF2 + { 6, &RISCVDescs.OperandInfo[829] }, // Inst #8284 = PseudoVSM4R_VS_M2_M2 + { 6, &RISCVDescs.OperandInfo[823] }, // Inst #8283 = PseudoVSM4R_VS_M2_M1 + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #8282 = PseudoVSM4R_VS_M1_MF8 + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #8281 = PseudoVSM4R_VS_M1_MF4 + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #8280 = PseudoVSM4R_VS_M1_MF2 + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #8279 = PseudoVSM4R_VS_M1_M1 + { 7, &RISCVDescs.OperandInfo[877] }, // Inst #8278 = PseudoVSM4K_VI_MF2 + { 7, &RISCVDescs.OperandInfo[898] }, // Inst #8277 = PseudoVSM4K_VI_M8 + { 7, &RISCVDescs.OperandInfo[891] }, // Inst #8276 = PseudoVSM4K_VI_M4 + { 7, &RISCVDescs.OperandInfo[884] }, // Inst #8275 = PseudoVSM4K_VI_M2 + { 7, &RISCVDescs.OperandInfo[877] }, // Inst #8274 = PseudoVSM4K_VI_M1 + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #8273 = PseudoVSM3ME_VV_MF2 + { 7, &RISCVDescs.OperandInfo[742] }, // Inst #8272 = PseudoVSM3ME_VV_M8 + { 7, &RISCVDescs.OperandInfo[727] }, // Inst #8271 = PseudoVSM3ME_VV_M4 + { 7, &RISCVDescs.OperandInfo[712] }, // Inst #8270 = PseudoVSM3ME_VV_M2 + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #8269 = PseudoVSM3ME_VV_M1 + { 7, &RISCVDescs.OperandInfo[877] }, // Inst #8268 = PseudoVSM3C_VI_MF2 + { 7, &RISCVDescs.OperandInfo[898] }, // Inst #8267 = PseudoVSM3C_VI_M8 + { 7, &RISCVDescs.OperandInfo[891] }, // Inst #8266 = PseudoVSM3C_VI_M4 + { 7, &RISCVDescs.OperandInfo[884] }, // Inst #8265 = PseudoVSM3C_VI_M2 + { 7, &RISCVDescs.OperandInfo[877] }, // Inst #8264 = PseudoVSM3C_VI_M1 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #8263 = PseudoVSLL_VX_MF8_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #8262 = PseudoVSLL_VX_MF8 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #8261 = PseudoVSLL_VX_MF4_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #8260 = PseudoVSLL_VX_MF4 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #8259 = PseudoVSLL_VX_MF2_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #8258 = PseudoVSLL_VX_MF2 + { 8, &RISCVDescs.OperandInfo[809] }, // Inst #8257 = PseudoVSLL_VX_M8_MASK + { 7, &RISCVDescs.OperandInfo[802] }, // Inst #8256 = PseudoVSLL_VX_M8 + { 8, &RISCVDescs.OperandInfo[794] }, // Inst #8255 = PseudoVSLL_VX_M4_MASK + { 7, &RISCVDescs.OperandInfo[787] }, // Inst #8254 = PseudoVSLL_VX_M4 + { 8, &RISCVDescs.OperandInfo[779] }, // Inst #8253 = PseudoVSLL_VX_M2_MASK + { 7, &RISCVDescs.OperandInfo[772] }, // Inst #8252 = PseudoVSLL_VX_M2 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #8251 = PseudoVSLL_VX_M1_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #8250 = PseudoVSLL_VX_M1 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #8249 = PseudoVSLL_VV_MF8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #8248 = PseudoVSLL_VV_MF8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #8247 = PseudoVSLL_VV_MF4_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #8246 = PseudoVSLL_VV_MF4 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #8245 = PseudoVSLL_VV_MF2_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #8244 = PseudoVSLL_VV_MF2 + { 8, &RISCVDescs.OperandInfo[749] }, // Inst #8243 = PseudoVSLL_VV_M8_MASK + { 7, &RISCVDescs.OperandInfo[742] }, // Inst #8242 = PseudoVSLL_VV_M8 + { 8, &RISCVDescs.OperandInfo[734] }, // Inst #8241 = PseudoVSLL_VV_M4_MASK + { 7, &RISCVDescs.OperandInfo[727] }, // Inst #8240 = PseudoVSLL_VV_M4 + { 8, &RISCVDescs.OperandInfo[719] }, // Inst #8239 = PseudoVSLL_VV_M2_MASK + { 7, &RISCVDescs.OperandInfo[712] }, // Inst #8238 = PseudoVSLL_VV_M2 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #8237 = PseudoVSLL_VV_M1_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #8236 = PseudoVSLL_VV_M1 + { 8, &RISCVDescs.OperandInfo[6079] }, // Inst #8235 = PseudoVSLL_VI_MF8_MASK + { 7, &RISCVDescs.OperandInfo[877] }, // Inst #8234 = PseudoVSLL_VI_MF8 + { 8, &RISCVDescs.OperandInfo[6079] }, // Inst #8233 = PseudoVSLL_VI_MF4_MASK + { 7, &RISCVDescs.OperandInfo[877] }, // Inst #8232 = PseudoVSLL_VI_MF4 + { 8, &RISCVDescs.OperandInfo[6079] }, // Inst #8231 = PseudoVSLL_VI_MF2_MASK + { 7, &RISCVDescs.OperandInfo[877] }, // Inst #8230 = PseudoVSLL_VI_MF2 + { 8, &RISCVDescs.OperandInfo[6594] }, // Inst #8229 = PseudoVSLL_VI_M8_MASK + { 7, &RISCVDescs.OperandInfo[898] }, // Inst #8228 = PseudoVSLL_VI_M8 + { 8, &RISCVDescs.OperandInfo[6586] }, // Inst #8227 = PseudoVSLL_VI_M4_MASK + { 7, &RISCVDescs.OperandInfo[891] }, // Inst #8226 = PseudoVSLL_VI_M4 + { 8, &RISCVDescs.OperandInfo[6578] }, // Inst #8225 = PseudoVSLL_VI_M2_MASK + { 7, &RISCVDescs.OperandInfo[884] }, // Inst #8224 = PseudoVSLL_VI_M2 + { 8, &RISCVDescs.OperandInfo[6079] }, // Inst #8223 = PseudoVSLL_VI_M1_MASK + { 7, &RISCVDescs.OperandInfo[877] }, // Inst #8222 = PseudoVSLL_VI_M1 + { 8, &RISCVDescs.OperandInfo[6407] }, // Inst #8221 = PseudoVSLIDEUP_VX_MF8_MASK + { 7, &RISCVDescs.OperandInfo[6400] }, // Inst #8220 = PseudoVSLIDEUP_VX_MF8 + { 8, &RISCVDescs.OperandInfo[6407] }, // Inst #8219 = PseudoVSLIDEUP_VX_MF4_MASK + { 7, &RISCVDescs.OperandInfo[6400] }, // Inst #8218 = PseudoVSLIDEUP_VX_MF4 + { 8, &RISCVDescs.OperandInfo[6407] }, // Inst #8217 = PseudoVSLIDEUP_VX_MF2_MASK + { 7, &RISCVDescs.OperandInfo[6400] }, // Inst #8216 = PseudoVSLIDEUP_VX_MF2 + { 8, &RISCVDescs.OperandInfo[6452] }, // Inst #8215 = PseudoVSLIDEUP_VX_M8_MASK + { 7, &RISCVDescs.OperandInfo[6445] }, // Inst #8214 = PseudoVSLIDEUP_VX_M8 + { 8, &RISCVDescs.OperandInfo[6437] }, // Inst #8213 = PseudoVSLIDEUP_VX_M4_MASK + { 7, &RISCVDescs.OperandInfo[6430] }, // Inst #8212 = PseudoVSLIDEUP_VX_M4 + { 8, &RISCVDescs.OperandInfo[6422] }, // Inst #8211 = PseudoVSLIDEUP_VX_M2_MASK + { 7, &RISCVDescs.OperandInfo[6415] }, // Inst #8210 = PseudoVSLIDEUP_VX_M2 + { 8, &RISCVDescs.OperandInfo[6407] }, // Inst #8209 = PseudoVSLIDEUP_VX_M1_MASK + { 7, &RISCVDescs.OperandInfo[6400] }, // Inst #8208 = PseudoVSLIDEUP_VX_M1 + { 8, &RISCVDescs.OperandInfo[6347] }, // Inst #8207 = PseudoVSLIDEUP_VI_MF8_MASK + { 7, &RISCVDescs.OperandInfo[6340] }, // Inst #8206 = PseudoVSLIDEUP_VI_MF8 + { 8, &RISCVDescs.OperandInfo[6347] }, // Inst #8205 = PseudoVSLIDEUP_VI_MF4_MASK + { 7, &RISCVDescs.OperandInfo[6340] }, // Inst #8204 = PseudoVSLIDEUP_VI_MF4 + { 8, &RISCVDescs.OperandInfo[6347] }, // Inst #8203 = PseudoVSLIDEUP_VI_MF2_MASK + { 7, &RISCVDescs.OperandInfo[6340] }, // Inst #8202 = PseudoVSLIDEUP_VI_MF2 + { 8, &RISCVDescs.OperandInfo[6392] }, // Inst #8201 = PseudoVSLIDEUP_VI_M8_MASK + { 7, &RISCVDescs.OperandInfo[6385] }, // Inst #8200 = PseudoVSLIDEUP_VI_M8 + { 8, &RISCVDescs.OperandInfo[6377] }, // Inst #8199 = PseudoVSLIDEUP_VI_M4_MASK + { 7, &RISCVDescs.OperandInfo[6370] }, // Inst #8198 = PseudoVSLIDEUP_VI_M4 + { 8, &RISCVDescs.OperandInfo[6362] }, // Inst #8197 = PseudoVSLIDEUP_VI_M2_MASK + { 7, &RISCVDescs.OperandInfo[6355] }, // Inst #8196 = PseudoVSLIDEUP_VI_M2 + { 8, &RISCVDescs.OperandInfo[6347] }, // Inst #8195 = PseudoVSLIDEUP_VI_M1_MASK + { 7, &RISCVDescs.OperandInfo[6340] }, // Inst #8194 = PseudoVSLIDEUP_VI_M1 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #8193 = PseudoVSLIDEDOWN_VX_MF8_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #8192 = PseudoVSLIDEDOWN_VX_MF8 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #8191 = PseudoVSLIDEDOWN_VX_MF4_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #8190 = PseudoVSLIDEDOWN_VX_MF4 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #8189 = PseudoVSLIDEDOWN_VX_MF2_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #8188 = PseudoVSLIDEDOWN_VX_MF2 + { 8, &RISCVDescs.OperandInfo[809] }, // Inst #8187 = PseudoVSLIDEDOWN_VX_M8_MASK + { 7, &RISCVDescs.OperandInfo[802] }, // Inst #8186 = PseudoVSLIDEDOWN_VX_M8 + { 8, &RISCVDescs.OperandInfo[794] }, // Inst #8185 = PseudoVSLIDEDOWN_VX_M4_MASK + { 7, &RISCVDescs.OperandInfo[787] }, // Inst #8184 = PseudoVSLIDEDOWN_VX_M4 + { 8, &RISCVDescs.OperandInfo[779] }, // Inst #8183 = PseudoVSLIDEDOWN_VX_M2_MASK + { 7, &RISCVDescs.OperandInfo[772] }, // Inst #8182 = PseudoVSLIDEDOWN_VX_M2 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #8181 = PseudoVSLIDEDOWN_VX_M1_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #8180 = PseudoVSLIDEDOWN_VX_M1 + { 8, &RISCVDescs.OperandInfo[6079] }, // Inst #8179 = PseudoVSLIDEDOWN_VI_MF8_MASK + { 7, &RISCVDescs.OperandInfo[877] }, // Inst #8178 = PseudoVSLIDEDOWN_VI_MF8 + { 8, &RISCVDescs.OperandInfo[6079] }, // Inst #8177 = PseudoVSLIDEDOWN_VI_MF4_MASK + { 7, &RISCVDescs.OperandInfo[877] }, // Inst #8176 = PseudoVSLIDEDOWN_VI_MF4 + { 8, &RISCVDescs.OperandInfo[6079] }, // Inst #8175 = PseudoVSLIDEDOWN_VI_MF2_MASK + { 7, &RISCVDescs.OperandInfo[877] }, // Inst #8174 = PseudoVSLIDEDOWN_VI_MF2 + { 8, &RISCVDescs.OperandInfo[6594] }, // Inst #8173 = PseudoVSLIDEDOWN_VI_M8_MASK + { 7, &RISCVDescs.OperandInfo[898] }, // Inst #8172 = PseudoVSLIDEDOWN_VI_M8 + { 8, &RISCVDescs.OperandInfo[6586] }, // Inst #8171 = PseudoVSLIDEDOWN_VI_M4_MASK + { 7, &RISCVDescs.OperandInfo[891] }, // Inst #8170 = PseudoVSLIDEDOWN_VI_M4 + { 8, &RISCVDescs.OperandInfo[6578] }, // Inst #8169 = PseudoVSLIDEDOWN_VI_M2_MASK + { 7, &RISCVDescs.OperandInfo[884] }, // Inst #8168 = PseudoVSLIDEDOWN_VI_M2 + { 8, &RISCVDescs.OperandInfo[6079] }, // Inst #8167 = PseudoVSLIDEDOWN_VI_M1_MASK + { 7, &RISCVDescs.OperandInfo[877] }, // Inst #8166 = PseudoVSLIDEDOWN_VI_M1 + { 8, &RISCVDescs.OperandInfo[6407] }, // Inst #8165 = PseudoVSLIDE1UP_VX_MF8_MASK + { 7, &RISCVDescs.OperandInfo[6400] }, // Inst #8164 = PseudoVSLIDE1UP_VX_MF8 + { 8, &RISCVDescs.OperandInfo[6407] }, // Inst #8163 = PseudoVSLIDE1UP_VX_MF4_MASK + { 7, &RISCVDescs.OperandInfo[6400] }, // Inst #8162 = PseudoVSLIDE1UP_VX_MF4 + { 8, &RISCVDescs.OperandInfo[6407] }, // Inst #8161 = PseudoVSLIDE1UP_VX_MF2_MASK + { 7, &RISCVDescs.OperandInfo[6400] }, // Inst #8160 = PseudoVSLIDE1UP_VX_MF2 + { 8, &RISCVDescs.OperandInfo[6452] }, // Inst #8159 = PseudoVSLIDE1UP_VX_M8_MASK + { 7, &RISCVDescs.OperandInfo[6445] }, // Inst #8158 = PseudoVSLIDE1UP_VX_M8 + { 8, &RISCVDescs.OperandInfo[6437] }, // Inst #8157 = PseudoVSLIDE1UP_VX_M4_MASK + { 7, &RISCVDescs.OperandInfo[6430] }, // Inst #8156 = PseudoVSLIDE1UP_VX_M4 + { 8, &RISCVDescs.OperandInfo[6422] }, // Inst #8155 = PseudoVSLIDE1UP_VX_M2_MASK + { 7, &RISCVDescs.OperandInfo[6415] }, // Inst #8154 = PseudoVSLIDE1UP_VX_M2 + { 8, &RISCVDescs.OperandInfo[6407] }, // Inst #8153 = PseudoVSLIDE1UP_VX_M1_MASK + { 7, &RISCVDescs.OperandInfo[6400] }, // Inst #8152 = PseudoVSLIDE1UP_VX_M1 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #8151 = PseudoVSLIDE1DOWN_VX_MF8_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #8150 = PseudoVSLIDE1DOWN_VX_MF8 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #8149 = PseudoVSLIDE1DOWN_VX_MF4_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #8148 = PseudoVSLIDE1DOWN_VX_MF4 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #8147 = PseudoVSLIDE1DOWN_VX_MF2_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #8146 = PseudoVSLIDE1DOWN_VX_MF2 + { 8, &RISCVDescs.OperandInfo[809] }, // Inst #8145 = PseudoVSLIDE1DOWN_VX_M8_MASK + { 7, &RISCVDescs.OperandInfo[802] }, // Inst #8144 = PseudoVSLIDE1DOWN_VX_M8 + { 8, &RISCVDescs.OperandInfo[794] }, // Inst #8143 = PseudoVSLIDE1DOWN_VX_M4_MASK + { 7, &RISCVDescs.OperandInfo[787] }, // Inst #8142 = PseudoVSLIDE1DOWN_VX_M4 + { 8, &RISCVDescs.OperandInfo[779] }, // Inst #8141 = PseudoVSLIDE1DOWN_VX_M2_MASK + { 7, &RISCVDescs.OperandInfo[772] }, // Inst #8140 = PseudoVSLIDE1DOWN_VX_M2 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #8139 = PseudoVSLIDE1DOWN_VX_M1_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #8138 = PseudoVSLIDE1DOWN_VX_M1 + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #8137 = PseudoVSHA2MS_VV_MF2 + { 7, &RISCVDescs.OperandInfo[742] }, // Inst #8136 = PseudoVSHA2MS_VV_M8 + { 7, &RISCVDescs.OperandInfo[727] }, // Inst #8135 = PseudoVSHA2MS_VV_M4 + { 7, &RISCVDescs.OperandInfo[712] }, // Inst #8134 = PseudoVSHA2MS_VV_M2 + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #8133 = PseudoVSHA2MS_VV_M1 + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #8132 = PseudoVSHA2CL_VV_MF2 + { 7, &RISCVDescs.OperandInfo[742] }, // Inst #8131 = PseudoVSHA2CL_VV_M8 + { 7, &RISCVDescs.OperandInfo[727] }, // Inst #8130 = PseudoVSHA2CL_VV_M4 + { 7, &RISCVDescs.OperandInfo[712] }, // Inst #8129 = PseudoVSHA2CL_VV_M2 + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #8128 = PseudoVSHA2CL_VV_M1 + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #8127 = PseudoVSHA2CH_VV_MF2 + { 7, &RISCVDescs.OperandInfo[742] }, // Inst #8126 = PseudoVSHA2CH_VV_M8 + { 7, &RISCVDescs.OperandInfo[727] }, // Inst #8125 = PseudoVSHA2CH_VV_M4 + { 7, &RISCVDescs.OperandInfo[712] }, // Inst #8124 = PseudoVSHA2CH_VV_M2 + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #8123 = PseudoVSHA2CH_VV_M1 + { 7, &RISCVDescs.OperandInfo[3787] }, // Inst #8122 = PseudoVSEXT_VF8_M8_MASK + { 6, &RISCVDescs.OperandInfo[3781] }, // Inst #8121 = PseudoVSEXT_VF8_M8 + { 7, &RISCVDescs.OperandInfo[3774] }, // Inst #8120 = PseudoVSEXT_VF8_M4_MASK + { 6, &RISCVDescs.OperandInfo[3768] }, // Inst #8119 = PseudoVSEXT_VF8_M4 + { 7, &RISCVDescs.OperandInfo[3527] }, // Inst #8118 = PseudoVSEXT_VF8_M2_MASK + { 6, &RISCVDescs.OperandInfo[3521] }, // Inst #8117 = PseudoVSEXT_VF8_M2 + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #8116 = PseudoVSEXT_VF8_M1_MASK + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #8115 = PseudoVSEXT_VF8_M1 + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #8114 = PseudoVSEXT_VF4_MF2_MASK + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #8113 = PseudoVSEXT_VF4_MF2 + { 7, &RISCVDescs.OperandInfo[6571] }, // Inst #8112 = PseudoVSEXT_VF4_M8_MASK + { 6, &RISCVDescs.OperandInfo[6565] }, // Inst #8111 = PseudoVSEXT_VF4_M8 + { 7, &RISCVDescs.OperandInfo[3774] }, // Inst #8110 = PseudoVSEXT_VF4_M4_MASK + { 6, &RISCVDescs.OperandInfo[3768] }, // Inst #8109 = PseudoVSEXT_VF4_M4 + { 7, &RISCVDescs.OperandInfo[3527] }, // Inst #8108 = PseudoVSEXT_VF4_M2_MASK + { 6, &RISCVDescs.OperandInfo[3521] }, // Inst #8107 = PseudoVSEXT_VF4_M2 + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #8106 = PseudoVSEXT_VF4_M1_MASK + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #8105 = PseudoVSEXT_VF4_M1 + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #8104 = PseudoVSEXT_VF2_MF4_MASK + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #8103 = PseudoVSEXT_VF2_MF4 + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #8102 = PseudoVSEXT_VF2_MF2_MASK + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #8101 = PseudoVSEXT_VF2_MF2 + { 7, &RISCVDescs.OperandInfo[3553] }, // Inst #8100 = PseudoVSEXT_VF2_M8_MASK + { 6, &RISCVDescs.OperandInfo[3547] }, // Inst #8099 = PseudoVSEXT_VF2_M8 + { 7, &RISCVDescs.OperandInfo[3540] }, // Inst #8098 = PseudoVSEXT_VF2_M4_MASK + { 6, &RISCVDescs.OperandInfo[3534] }, // Inst #8097 = PseudoVSEXT_VF2_M4 + { 7, &RISCVDescs.OperandInfo[3527] }, // Inst #8096 = PseudoVSEXT_VF2_M2_MASK + { 6, &RISCVDescs.OperandInfo[3521] }, // Inst #8095 = PseudoVSEXT_VF2_M2 + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #8094 = PseudoVSEXT_VF2_M1_MASK + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #8093 = PseudoVSEXT_VF2_M1 + { 3, &RISCVDescs.OperandInfo[6562] }, // Inst #8092 = PseudoVSETVLIX0 + { 3, &RISCVDescs.OperandInfo[6559] }, // Inst #8091 = PseudoVSETVLI + { 3, &RISCVDescs.OperandInfo[6556] }, // Inst #8090 = PseudoVSETIVLI + { 5, &RISCVDescs.OperandInfo[6524] }, // Inst #8089 = PseudoVSE8_V_MF8_MASK + { 4, &RISCVDescs.OperandInfo[6520] }, // Inst #8088 = PseudoVSE8_V_MF8 + { 5, &RISCVDescs.OperandInfo[6524] }, // Inst #8087 = PseudoVSE8_V_MF4_MASK + { 4, &RISCVDescs.OperandInfo[6520] }, // Inst #8086 = PseudoVSE8_V_MF4 + { 5, &RISCVDescs.OperandInfo[6524] }, // Inst #8085 = PseudoVSE8_V_MF2_MASK + { 4, &RISCVDescs.OperandInfo[6520] }, // Inst #8084 = PseudoVSE8_V_MF2 + { 5, &RISCVDescs.OperandInfo[6551] }, // Inst #8083 = PseudoVSE8_V_M8_MASK + { 4, &RISCVDescs.OperandInfo[6547] }, // Inst #8082 = PseudoVSE8_V_M8 + { 5, &RISCVDescs.OperandInfo[6542] }, // Inst #8081 = PseudoVSE8_V_M4_MASK + { 4, &RISCVDescs.OperandInfo[6538] }, // Inst #8080 = PseudoVSE8_V_M4 + { 5, &RISCVDescs.OperandInfo[6533] }, // Inst #8079 = PseudoVSE8_V_M2_MASK + { 4, &RISCVDescs.OperandInfo[6529] }, // Inst #8078 = PseudoVSE8_V_M2 + { 5, &RISCVDescs.OperandInfo[6524] }, // Inst #8077 = PseudoVSE8_V_M1_MASK + { 4, &RISCVDescs.OperandInfo[6520] }, // Inst #8076 = PseudoVSE8_V_M1 + { 5, &RISCVDescs.OperandInfo[6551] }, // Inst #8075 = PseudoVSE64_V_M8_MASK + { 4, &RISCVDescs.OperandInfo[6547] }, // Inst #8074 = PseudoVSE64_V_M8 + { 5, &RISCVDescs.OperandInfo[6542] }, // Inst #8073 = PseudoVSE64_V_M4_MASK + { 4, &RISCVDescs.OperandInfo[6538] }, // Inst #8072 = PseudoVSE64_V_M4 + { 5, &RISCVDescs.OperandInfo[6533] }, // Inst #8071 = PseudoVSE64_V_M2_MASK + { 4, &RISCVDescs.OperandInfo[6529] }, // Inst #8070 = PseudoVSE64_V_M2 + { 5, &RISCVDescs.OperandInfo[6524] }, // Inst #8069 = PseudoVSE64_V_M1_MASK + { 4, &RISCVDescs.OperandInfo[6520] }, // Inst #8068 = PseudoVSE64_V_M1 + { 5, &RISCVDescs.OperandInfo[6524] }, // Inst #8067 = PseudoVSE32_V_MF2_MASK + { 4, &RISCVDescs.OperandInfo[6520] }, // Inst #8066 = PseudoVSE32_V_MF2 + { 5, &RISCVDescs.OperandInfo[6551] }, // Inst #8065 = PseudoVSE32_V_M8_MASK + { 4, &RISCVDescs.OperandInfo[6547] }, // Inst #8064 = PseudoVSE32_V_M8 + { 5, &RISCVDescs.OperandInfo[6542] }, // Inst #8063 = PseudoVSE32_V_M4_MASK + { 4, &RISCVDescs.OperandInfo[6538] }, // Inst #8062 = PseudoVSE32_V_M4 + { 5, &RISCVDescs.OperandInfo[6533] }, // Inst #8061 = PseudoVSE32_V_M2_MASK + { 4, &RISCVDescs.OperandInfo[6529] }, // Inst #8060 = PseudoVSE32_V_M2 + { 5, &RISCVDescs.OperandInfo[6524] }, // Inst #8059 = PseudoVSE32_V_M1_MASK + { 4, &RISCVDescs.OperandInfo[6520] }, // Inst #8058 = PseudoVSE32_V_M1 + { 5, &RISCVDescs.OperandInfo[6524] }, // Inst #8057 = PseudoVSE16_V_MF4_MASK + { 4, &RISCVDescs.OperandInfo[6520] }, // Inst #8056 = PseudoVSE16_V_MF4 + { 5, &RISCVDescs.OperandInfo[6524] }, // Inst #8055 = PseudoVSE16_V_MF2_MASK + { 4, &RISCVDescs.OperandInfo[6520] }, // Inst #8054 = PseudoVSE16_V_MF2 + { 5, &RISCVDescs.OperandInfo[6551] }, // Inst #8053 = PseudoVSE16_V_M8_MASK + { 4, &RISCVDescs.OperandInfo[6547] }, // Inst #8052 = PseudoVSE16_V_M8 + { 5, &RISCVDescs.OperandInfo[6542] }, // Inst #8051 = PseudoVSE16_V_M4_MASK + { 4, &RISCVDescs.OperandInfo[6538] }, // Inst #8050 = PseudoVSE16_V_M4 + { 5, &RISCVDescs.OperandInfo[6533] }, // Inst #8049 = PseudoVSE16_V_M2_MASK + { 4, &RISCVDescs.OperandInfo[6529] }, // Inst #8048 = PseudoVSE16_V_M2 + { 5, &RISCVDescs.OperandInfo[6524] }, // Inst #8047 = PseudoVSE16_V_M1_MASK + { 4, &RISCVDescs.OperandInfo[6520] }, // Inst #8046 = PseudoVSE16_V_M1 + { 7, &RISCVDescs.OperandInfo[609] }, // Inst #8045 = PseudoVSBC_VXM_MF8 + { 7, &RISCVDescs.OperandInfo[609] }, // Inst #8044 = PseudoVSBC_VXM_MF4 + { 7, &RISCVDescs.OperandInfo[609] }, // Inst #8043 = PseudoVSBC_VXM_MF2 + { 7, &RISCVDescs.OperandInfo[630] }, // Inst #8042 = PseudoVSBC_VXM_M8 + { 7, &RISCVDescs.OperandInfo[623] }, // Inst #8041 = PseudoVSBC_VXM_M4 + { 7, &RISCVDescs.OperandInfo[616] }, // Inst #8040 = PseudoVSBC_VXM_M2 + { 7, &RISCVDescs.OperandInfo[609] }, // Inst #8039 = PseudoVSBC_VXM_M1 + { 7, &RISCVDescs.OperandInfo[581] }, // Inst #8038 = PseudoVSBC_VVM_MF8 + { 7, &RISCVDescs.OperandInfo[581] }, // Inst #8037 = PseudoVSBC_VVM_MF4 + { 7, &RISCVDescs.OperandInfo[581] }, // Inst #8036 = PseudoVSBC_VVM_MF2 + { 7, &RISCVDescs.OperandInfo[602] }, // Inst #8035 = PseudoVSBC_VVM_M8 + { 7, &RISCVDescs.OperandInfo[595] }, // Inst #8034 = PseudoVSBC_VVM_M4 + { 7, &RISCVDescs.OperandInfo[588] }, // Inst #8033 = PseudoVSBC_VVM_M2 + { 7, &RISCVDescs.OperandInfo[581] }, // Inst #8032 = PseudoVSBC_VVM_M1 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #8031 = PseudoVSADD_VX_MF8_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #8030 = PseudoVSADD_VX_MF8 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #8029 = PseudoVSADD_VX_MF4_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #8028 = PseudoVSADD_VX_MF4 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #8027 = PseudoVSADD_VX_MF2_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #8026 = PseudoVSADD_VX_MF2 + { 8, &RISCVDescs.OperandInfo[809] }, // Inst #8025 = PseudoVSADD_VX_M8_MASK + { 7, &RISCVDescs.OperandInfo[802] }, // Inst #8024 = PseudoVSADD_VX_M8 + { 8, &RISCVDescs.OperandInfo[794] }, // Inst #8023 = PseudoVSADD_VX_M4_MASK + { 7, &RISCVDescs.OperandInfo[787] }, // Inst #8022 = PseudoVSADD_VX_M4 + { 8, &RISCVDescs.OperandInfo[779] }, // Inst #8021 = PseudoVSADD_VX_M2_MASK + { 7, &RISCVDescs.OperandInfo[772] }, // Inst #8020 = PseudoVSADD_VX_M2 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #8019 = PseudoVSADD_VX_M1_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #8018 = PseudoVSADD_VX_M1 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #8017 = PseudoVSADD_VV_MF8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #8016 = PseudoVSADD_VV_MF8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #8015 = PseudoVSADD_VV_MF4_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #8014 = PseudoVSADD_VV_MF4 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #8013 = PseudoVSADD_VV_MF2_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #8012 = PseudoVSADD_VV_MF2 + { 8, &RISCVDescs.OperandInfo[749] }, // Inst #8011 = PseudoVSADD_VV_M8_MASK + { 7, &RISCVDescs.OperandInfo[742] }, // Inst #8010 = PseudoVSADD_VV_M8 + { 8, &RISCVDescs.OperandInfo[734] }, // Inst #8009 = PseudoVSADD_VV_M4_MASK + { 7, &RISCVDescs.OperandInfo[727] }, // Inst #8008 = PseudoVSADD_VV_M4 + { 8, &RISCVDescs.OperandInfo[719] }, // Inst #8007 = PseudoVSADD_VV_M2_MASK + { 7, &RISCVDescs.OperandInfo[712] }, // Inst #8006 = PseudoVSADD_VV_M2 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #8005 = PseudoVSADD_VV_M1_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #8004 = PseudoVSADD_VV_M1 + { 8, &RISCVDescs.OperandInfo[644] }, // Inst #8003 = PseudoVSADD_VI_MF8_MASK + { 7, &RISCVDescs.OperandInfo[637] }, // Inst #8002 = PseudoVSADD_VI_MF8 + { 8, &RISCVDescs.OperandInfo[644] }, // Inst #8001 = PseudoVSADD_VI_MF4_MASK + { 7, &RISCVDescs.OperandInfo[637] }, // Inst #8000 = PseudoVSADD_VI_MF4 + { 8, &RISCVDescs.OperandInfo[644] }, // Inst #7999 = PseudoVSADD_VI_MF2_MASK + { 7, &RISCVDescs.OperandInfo[637] }, // Inst #7998 = PseudoVSADD_VI_MF2 + { 8, &RISCVDescs.OperandInfo[689] }, // Inst #7997 = PseudoVSADD_VI_M8_MASK + { 7, &RISCVDescs.OperandInfo[682] }, // Inst #7996 = PseudoVSADD_VI_M8 + { 8, &RISCVDescs.OperandInfo[674] }, // Inst #7995 = PseudoVSADD_VI_M4_MASK + { 7, &RISCVDescs.OperandInfo[667] }, // Inst #7994 = PseudoVSADD_VI_M4 + { 8, &RISCVDescs.OperandInfo[659] }, // Inst #7993 = PseudoVSADD_VI_M2_MASK + { 7, &RISCVDescs.OperandInfo[652] }, // Inst #7992 = PseudoVSADD_VI_M2 + { 8, &RISCVDescs.OperandInfo[644] }, // Inst #7991 = PseudoVSADD_VI_M1_MASK + { 7, &RISCVDescs.OperandInfo[637] }, // Inst #7990 = PseudoVSADD_VI_M1 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #7989 = PseudoVSADDU_VX_MF8_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #7988 = PseudoVSADDU_VX_MF8 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #7987 = PseudoVSADDU_VX_MF4_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #7986 = PseudoVSADDU_VX_MF4 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #7985 = PseudoVSADDU_VX_MF2_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #7984 = PseudoVSADDU_VX_MF2 + { 8, &RISCVDescs.OperandInfo[809] }, // Inst #7983 = PseudoVSADDU_VX_M8_MASK + { 7, &RISCVDescs.OperandInfo[802] }, // Inst #7982 = PseudoVSADDU_VX_M8 + { 8, &RISCVDescs.OperandInfo[794] }, // Inst #7981 = PseudoVSADDU_VX_M4_MASK + { 7, &RISCVDescs.OperandInfo[787] }, // Inst #7980 = PseudoVSADDU_VX_M4 + { 8, &RISCVDescs.OperandInfo[779] }, // Inst #7979 = PseudoVSADDU_VX_M2_MASK + { 7, &RISCVDescs.OperandInfo[772] }, // Inst #7978 = PseudoVSADDU_VX_M2 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #7977 = PseudoVSADDU_VX_M1_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #7976 = PseudoVSADDU_VX_M1 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7975 = PseudoVSADDU_VV_MF8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7974 = PseudoVSADDU_VV_MF8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7973 = PseudoVSADDU_VV_MF4_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7972 = PseudoVSADDU_VV_MF4 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7971 = PseudoVSADDU_VV_MF2_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7970 = PseudoVSADDU_VV_MF2 + { 8, &RISCVDescs.OperandInfo[749] }, // Inst #7969 = PseudoVSADDU_VV_M8_MASK + { 7, &RISCVDescs.OperandInfo[742] }, // Inst #7968 = PseudoVSADDU_VV_M8 + { 8, &RISCVDescs.OperandInfo[734] }, // Inst #7967 = PseudoVSADDU_VV_M4_MASK + { 7, &RISCVDescs.OperandInfo[727] }, // Inst #7966 = PseudoVSADDU_VV_M4 + { 8, &RISCVDescs.OperandInfo[719] }, // Inst #7965 = PseudoVSADDU_VV_M2_MASK + { 7, &RISCVDescs.OperandInfo[712] }, // Inst #7964 = PseudoVSADDU_VV_M2 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7963 = PseudoVSADDU_VV_M1_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7962 = PseudoVSADDU_VV_M1 + { 8, &RISCVDescs.OperandInfo[644] }, // Inst #7961 = PseudoVSADDU_VI_MF8_MASK + { 7, &RISCVDescs.OperandInfo[637] }, // Inst #7960 = PseudoVSADDU_VI_MF8 + { 8, &RISCVDescs.OperandInfo[644] }, // Inst #7959 = PseudoVSADDU_VI_MF4_MASK + { 7, &RISCVDescs.OperandInfo[637] }, // Inst #7958 = PseudoVSADDU_VI_MF4 + { 8, &RISCVDescs.OperandInfo[644] }, // Inst #7957 = PseudoVSADDU_VI_MF2_MASK + { 7, &RISCVDescs.OperandInfo[637] }, // Inst #7956 = PseudoVSADDU_VI_MF2 + { 8, &RISCVDescs.OperandInfo[689] }, // Inst #7955 = PseudoVSADDU_VI_M8_MASK + { 7, &RISCVDescs.OperandInfo[682] }, // Inst #7954 = PseudoVSADDU_VI_M8 + { 8, &RISCVDescs.OperandInfo[674] }, // Inst #7953 = PseudoVSADDU_VI_M4_MASK + { 7, &RISCVDescs.OperandInfo[667] }, // Inst #7952 = PseudoVSADDU_VI_M4 + { 8, &RISCVDescs.OperandInfo[659] }, // Inst #7951 = PseudoVSADDU_VI_M2_MASK + { 7, &RISCVDescs.OperandInfo[652] }, // Inst #7950 = PseudoVSADDU_VI_M2 + { 8, &RISCVDescs.OperandInfo[644] }, // Inst #7949 = PseudoVSADDU_VI_M1_MASK + { 7, &RISCVDescs.OperandInfo[637] }, // Inst #7948 = PseudoVSADDU_VI_M1 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #7947 = PseudoVRSUB_VX_MF8_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #7946 = PseudoVRSUB_VX_MF8 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #7945 = PseudoVRSUB_VX_MF4_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #7944 = PseudoVRSUB_VX_MF4 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #7943 = PseudoVRSUB_VX_MF2_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #7942 = PseudoVRSUB_VX_MF2 + { 8, &RISCVDescs.OperandInfo[809] }, // Inst #7941 = PseudoVRSUB_VX_M8_MASK + { 7, &RISCVDescs.OperandInfo[802] }, // Inst #7940 = PseudoVRSUB_VX_M8 + { 8, &RISCVDescs.OperandInfo[794] }, // Inst #7939 = PseudoVRSUB_VX_M4_MASK + { 7, &RISCVDescs.OperandInfo[787] }, // Inst #7938 = PseudoVRSUB_VX_M4 + { 8, &RISCVDescs.OperandInfo[779] }, // Inst #7937 = PseudoVRSUB_VX_M2_MASK + { 7, &RISCVDescs.OperandInfo[772] }, // Inst #7936 = PseudoVRSUB_VX_M2 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #7935 = PseudoVRSUB_VX_M1_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #7934 = PseudoVRSUB_VX_M1 + { 8, &RISCVDescs.OperandInfo[644] }, // Inst #7933 = PseudoVRSUB_VI_MF8_MASK + { 7, &RISCVDescs.OperandInfo[637] }, // Inst #7932 = PseudoVRSUB_VI_MF8 + { 8, &RISCVDescs.OperandInfo[644] }, // Inst #7931 = PseudoVRSUB_VI_MF4_MASK + { 7, &RISCVDescs.OperandInfo[637] }, // Inst #7930 = PseudoVRSUB_VI_MF4 + { 8, &RISCVDescs.OperandInfo[644] }, // Inst #7929 = PseudoVRSUB_VI_MF2_MASK + { 7, &RISCVDescs.OperandInfo[637] }, // Inst #7928 = PseudoVRSUB_VI_MF2 + { 8, &RISCVDescs.OperandInfo[689] }, // Inst #7927 = PseudoVRSUB_VI_M8_MASK + { 7, &RISCVDescs.OperandInfo[682] }, // Inst #7926 = PseudoVRSUB_VI_M8 + { 8, &RISCVDescs.OperandInfo[674] }, // Inst #7925 = PseudoVRSUB_VI_M4_MASK + { 7, &RISCVDescs.OperandInfo[667] }, // Inst #7924 = PseudoVRSUB_VI_M4 + { 8, &RISCVDescs.OperandInfo[659] }, // Inst #7923 = PseudoVRSUB_VI_M2_MASK + { 7, &RISCVDescs.OperandInfo[652] }, // Inst #7922 = PseudoVRSUB_VI_M2 + { 8, &RISCVDescs.OperandInfo[644] }, // Inst #7921 = PseudoVRSUB_VI_M1_MASK + { 7, &RISCVDescs.OperandInfo[637] }, // Inst #7920 = PseudoVRSUB_VI_M1 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #7919 = PseudoVROR_VX_MF8_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #7918 = PseudoVROR_VX_MF8 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #7917 = PseudoVROR_VX_MF4_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #7916 = PseudoVROR_VX_MF4 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #7915 = PseudoVROR_VX_MF2_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #7914 = PseudoVROR_VX_MF2 + { 8, &RISCVDescs.OperandInfo[809] }, // Inst #7913 = PseudoVROR_VX_M8_MASK + { 7, &RISCVDescs.OperandInfo[802] }, // Inst #7912 = PseudoVROR_VX_M8 + { 8, &RISCVDescs.OperandInfo[794] }, // Inst #7911 = PseudoVROR_VX_M4_MASK + { 7, &RISCVDescs.OperandInfo[787] }, // Inst #7910 = PseudoVROR_VX_M4 + { 8, &RISCVDescs.OperandInfo[779] }, // Inst #7909 = PseudoVROR_VX_M2_MASK + { 7, &RISCVDescs.OperandInfo[772] }, // Inst #7908 = PseudoVROR_VX_M2 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #7907 = PseudoVROR_VX_M1_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #7906 = PseudoVROR_VX_M1 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7905 = PseudoVROR_VV_MF8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7904 = PseudoVROR_VV_MF8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7903 = PseudoVROR_VV_MF4_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7902 = PseudoVROR_VV_MF4 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7901 = PseudoVROR_VV_MF2_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7900 = PseudoVROR_VV_MF2 + { 8, &RISCVDescs.OperandInfo[749] }, // Inst #7899 = PseudoVROR_VV_M8_MASK + { 7, &RISCVDescs.OperandInfo[742] }, // Inst #7898 = PseudoVROR_VV_M8 + { 8, &RISCVDescs.OperandInfo[734] }, // Inst #7897 = PseudoVROR_VV_M4_MASK + { 7, &RISCVDescs.OperandInfo[727] }, // Inst #7896 = PseudoVROR_VV_M4 + { 8, &RISCVDescs.OperandInfo[719] }, // Inst #7895 = PseudoVROR_VV_M2_MASK + { 7, &RISCVDescs.OperandInfo[712] }, // Inst #7894 = PseudoVROR_VV_M2 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7893 = PseudoVROR_VV_M1_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7892 = PseudoVROR_VV_M1 + { 8, &RISCVDescs.OperandInfo[6467] }, // Inst #7891 = PseudoVROR_VI_MF8_MASK + { 7, &RISCVDescs.OperandInfo[6460] }, // Inst #7890 = PseudoVROR_VI_MF8 + { 8, &RISCVDescs.OperandInfo[6467] }, // Inst #7889 = PseudoVROR_VI_MF4_MASK + { 7, &RISCVDescs.OperandInfo[6460] }, // Inst #7888 = PseudoVROR_VI_MF4 + { 8, &RISCVDescs.OperandInfo[6467] }, // Inst #7887 = PseudoVROR_VI_MF2_MASK + { 7, &RISCVDescs.OperandInfo[6460] }, // Inst #7886 = PseudoVROR_VI_MF2 + { 8, &RISCVDescs.OperandInfo[6512] }, // Inst #7885 = PseudoVROR_VI_M8_MASK + { 7, &RISCVDescs.OperandInfo[6505] }, // Inst #7884 = PseudoVROR_VI_M8 + { 8, &RISCVDescs.OperandInfo[6497] }, // Inst #7883 = PseudoVROR_VI_M4_MASK + { 7, &RISCVDescs.OperandInfo[6490] }, // Inst #7882 = PseudoVROR_VI_M4 + { 8, &RISCVDescs.OperandInfo[6482] }, // Inst #7881 = PseudoVROR_VI_M2_MASK + { 7, &RISCVDescs.OperandInfo[6475] }, // Inst #7880 = PseudoVROR_VI_M2 + { 8, &RISCVDescs.OperandInfo[6467] }, // Inst #7879 = PseudoVROR_VI_M1_MASK + { 7, &RISCVDescs.OperandInfo[6460] }, // Inst #7878 = PseudoVROR_VI_M1 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #7877 = PseudoVROL_VX_MF8_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #7876 = PseudoVROL_VX_MF8 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #7875 = PseudoVROL_VX_MF4_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #7874 = PseudoVROL_VX_MF4 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #7873 = PseudoVROL_VX_MF2_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #7872 = PseudoVROL_VX_MF2 + { 8, &RISCVDescs.OperandInfo[809] }, // Inst #7871 = PseudoVROL_VX_M8_MASK + { 7, &RISCVDescs.OperandInfo[802] }, // Inst #7870 = PseudoVROL_VX_M8 + { 8, &RISCVDescs.OperandInfo[794] }, // Inst #7869 = PseudoVROL_VX_M4_MASK + { 7, &RISCVDescs.OperandInfo[787] }, // Inst #7868 = PseudoVROL_VX_M4 + { 8, &RISCVDescs.OperandInfo[779] }, // Inst #7867 = PseudoVROL_VX_M2_MASK + { 7, &RISCVDescs.OperandInfo[772] }, // Inst #7866 = PseudoVROL_VX_M2 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #7865 = PseudoVROL_VX_M1_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #7864 = PseudoVROL_VX_M1 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7863 = PseudoVROL_VV_MF8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7862 = PseudoVROL_VV_MF8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7861 = PseudoVROL_VV_MF4_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7860 = PseudoVROL_VV_MF4 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7859 = PseudoVROL_VV_MF2_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7858 = PseudoVROL_VV_MF2 + { 8, &RISCVDescs.OperandInfo[749] }, // Inst #7857 = PseudoVROL_VV_M8_MASK + { 7, &RISCVDescs.OperandInfo[742] }, // Inst #7856 = PseudoVROL_VV_M8 + { 8, &RISCVDescs.OperandInfo[734] }, // Inst #7855 = PseudoVROL_VV_M4_MASK + { 7, &RISCVDescs.OperandInfo[727] }, // Inst #7854 = PseudoVROL_VV_M4 + { 8, &RISCVDescs.OperandInfo[719] }, // Inst #7853 = PseudoVROL_VV_M2_MASK + { 7, &RISCVDescs.OperandInfo[712] }, // Inst #7852 = PseudoVROL_VV_M2 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7851 = PseudoVROL_VV_M1_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7850 = PseudoVROL_VV_M1 + { 8, &RISCVDescs.OperandInfo[6407] }, // Inst #7849 = PseudoVRGATHER_VX_MF8_MASK + { 7, &RISCVDescs.OperandInfo[6400] }, // Inst #7848 = PseudoVRGATHER_VX_MF8 + { 8, &RISCVDescs.OperandInfo[6407] }, // Inst #7847 = PseudoVRGATHER_VX_MF4_MASK + { 7, &RISCVDescs.OperandInfo[6400] }, // Inst #7846 = PseudoVRGATHER_VX_MF4 + { 8, &RISCVDescs.OperandInfo[6407] }, // Inst #7845 = PseudoVRGATHER_VX_MF2_MASK + { 7, &RISCVDescs.OperandInfo[6400] }, // Inst #7844 = PseudoVRGATHER_VX_MF2 + { 8, &RISCVDescs.OperandInfo[6452] }, // Inst #7843 = PseudoVRGATHER_VX_M8_MASK + { 7, &RISCVDescs.OperandInfo[6445] }, // Inst #7842 = PseudoVRGATHER_VX_M8 + { 8, &RISCVDescs.OperandInfo[6437] }, // Inst #7841 = PseudoVRGATHER_VX_M4_MASK + { 7, &RISCVDescs.OperandInfo[6430] }, // Inst #7840 = PseudoVRGATHER_VX_M4 + { 8, &RISCVDescs.OperandInfo[6422] }, // Inst #7839 = PseudoVRGATHER_VX_M2_MASK + { 7, &RISCVDescs.OperandInfo[6415] }, // Inst #7838 = PseudoVRGATHER_VX_M2 + { 8, &RISCVDescs.OperandInfo[6407] }, // Inst #7837 = PseudoVRGATHER_VX_M1_MASK + { 7, &RISCVDescs.OperandInfo[6400] }, // Inst #7836 = PseudoVRGATHER_VX_M1 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #7835 = PseudoVRGATHER_VV_MF8_E8_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #7834 = PseudoVRGATHER_VV_MF8_E8 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #7833 = PseudoVRGATHER_VV_MF4_E8_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #7832 = PseudoVRGATHER_VV_MF4_E8 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #7831 = PseudoVRGATHER_VV_MF4_E16_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #7830 = PseudoVRGATHER_VV_MF4_E16 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #7829 = PseudoVRGATHER_VV_MF2_E8_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #7828 = PseudoVRGATHER_VV_MF2_E8 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #7827 = PseudoVRGATHER_VV_MF2_E32_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #7826 = PseudoVRGATHER_VV_MF2_E32 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #7825 = PseudoVRGATHER_VV_MF2_E16_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #7824 = PseudoVRGATHER_VV_MF2_E16 + { 8, &RISCVDescs.OperandInfo[345] }, // Inst #7823 = PseudoVRGATHER_VV_M8_E8_MASK + { 7, &RISCVDescs.OperandInfo[338] }, // Inst #7822 = PseudoVRGATHER_VV_M8_E8 + { 8, &RISCVDescs.OperandInfo[345] }, // Inst #7821 = PseudoVRGATHER_VV_M8_E64_MASK + { 7, &RISCVDescs.OperandInfo[338] }, // Inst #7820 = PseudoVRGATHER_VV_M8_E64 + { 8, &RISCVDescs.OperandInfo[345] }, // Inst #7819 = PseudoVRGATHER_VV_M8_E32_MASK + { 7, &RISCVDescs.OperandInfo[338] }, // Inst #7818 = PseudoVRGATHER_VV_M8_E32 + { 8, &RISCVDescs.OperandInfo[345] }, // Inst #7817 = PseudoVRGATHER_VV_M8_E16_MASK + { 7, &RISCVDescs.OperandInfo[338] }, // Inst #7816 = PseudoVRGATHER_VV_M8_E16 + { 8, &RISCVDescs.OperandInfo[330] }, // Inst #7815 = PseudoVRGATHER_VV_M4_E8_MASK + { 7, &RISCVDescs.OperandInfo[323] }, // Inst #7814 = PseudoVRGATHER_VV_M4_E8 + { 8, &RISCVDescs.OperandInfo[330] }, // Inst #7813 = PseudoVRGATHER_VV_M4_E64_MASK + { 7, &RISCVDescs.OperandInfo[323] }, // Inst #7812 = PseudoVRGATHER_VV_M4_E64 + { 8, &RISCVDescs.OperandInfo[330] }, // Inst #7811 = PseudoVRGATHER_VV_M4_E32_MASK + { 7, &RISCVDescs.OperandInfo[323] }, // Inst #7810 = PseudoVRGATHER_VV_M4_E32 + { 8, &RISCVDescs.OperandInfo[330] }, // Inst #7809 = PseudoVRGATHER_VV_M4_E16_MASK + { 7, &RISCVDescs.OperandInfo[323] }, // Inst #7808 = PseudoVRGATHER_VV_M4_E16 + { 8, &RISCVDescs.OperandInfo[315] }, // Inst #7807 = PseudoVRGATHER_VV_M2_E8_MASK + { 7, &RISCVDescs.OperandInfo[308] }, // Inst #7806 = PseudoVRGATHER_VV_M2_E8 + { 8, &RISCVDescs.OperandInfo[315] }, // Inst #7805 = PseudoVRGATHER_VV_M2_E64_MASK + { 7, &RISCVDescs.OperandInfo[308] }, // Inst #7804 = PseudoVRGATHER_VV_M2_E64 + { 8, &RISCVDescs.OperandInfo[315] }, // Inst #7803 = PseudoVRGATHER_VV_M2_E32_MASK + { 7, &RISCVDescs.OperandInfo[308] }, // Inst #7802 = PseudoVRGATHER_VV_M2_E32 + { 8, &RISCVDescs.OperandInfo[315] }, // Inst #7801 = PseudoVRGATHER_VV_M2_E16_MASK + { 7, &RISCVDescs.OperandInfo[308] }, // Inst #7800 = PseudoVRGATHER_VV_M2_E16 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #7799 = PseudoVRGATHER_VV_M1_E8_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #7798 = PseudoVRGATHER_VV_M1_E8 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #7797 = PseudoVRGATHER_VV_M1_E64_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #7796 = PseudoVRGATHER_VV_M1_E64 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #7795 = PseudoVRGATHER_VV_M1_E32_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #7794 = PseudoVRGATHER_VV_M1_E32 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #7793 = PseudoVRGATHER_VV_M1_E16_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #7792 = PseudoVRGATHER_VV_M1_E16 + { 8, &RISCVDescs.OperandInfo[6347] }, // Inst #7791 = PseudoVRGATHER_VI_MF8_MASK + { 7, &RISCVDescs.OperandInfo[6340] }, // Inst #7790 = PseudoVRGATHER_VI_MF8 + { 8, &RISCVDescs.OperandInfo[6347] }, // Inst #7789 = PseudoVRGATHER_VI_MF4_MASK + { 7, &RISCVDescs.OperandInfo[6340] }, // Inst #7788 = PseudoVRGATHER_VI_MF4 + { 8, &RISCVDescs.OperandInfo[6347] }, // Inst #7787 = PseudoVRGATHER_VI_MF2_MASK + { 7, &RISCVDescs.OperandInfo[6340] }, // Inst #7786 = PseudoVRGATHER_VI_MF2 + { 8, &RISCVDescs.OperandInfo[6392] }, // Inst #7785 = PseudoVRGATHER_VI_M8_MASK + { 7, &RISCVDescs.OperandInfo[6385] }, // Inst #7784 = PseudoVRGATHER_VI_M8 + { 8, &RISCVDescs.OperandInfo[6377] }, // Inst #7783 = PseudoVRGATHER_VI_M4_MASK + { 7, &RISCVDescs.OperandInfo[6370] }, // Inst #7782 = PseudoVRGATHER_VI_M4 + { 8, &RISCVDescs.OperandInfo[6362] }, // Inst #7781 = PseudoVRGATHER_VI_M2_MASK + { 7, &RISCVDescs.OperandInfo[6355] }, // Inst #7780 = PseudoVRGATHER_VI_M2 + { 8, &RISCVDescs.OperandInfo[6347] }, // Inst #7779 = PseudoVRGATHER_VI_M1_MASK + { 7, &RISCVDescs.OperandInfo[6340] }, // Inst #7778 = PseudoVRGATHER_VI_M1 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #7777 = PseudoVRGATHEREI16_VV_MF8_E8_MF8_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #7776 = PseudoVRGATHEREI16_VV_MF8_E8_MF8 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #7775 = PseudoVRGATHEREI16_VV_MF8_E8_MF4_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #7774 = PseudoVRGATHEREI16_VV_MF8_E8_MF4 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #7773 = PseudoVRGATHEREI16_VV_MF4_E8_MF8_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #7772 = PseudoVRGATHEREI16_VV_MF4_E8_MF8 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #7771 = PseudoVRGATHEREI16_VV_MF4_E8_MF4_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #7770 = PseudoVRGATHEREI16_VV_MF4_E8_MF4 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #7769 = PseudoVRGATHEREI16_VV_MF4_E8_MF2_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #7768 = PseudoVRGATHEREI16_VV_MF4_E8_MF2 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #7767 = PseudoVRGATHEREI16_VV_MF4_E16_MF8_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #7766 = PseudoVRGATHEREI16_VV_MF4_E16_MF8 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #7765 = PseudoVRGATHEREI16_VV_MF4_E16_MF4_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #7764 = PseudoVRGATHEREI16_VV_MF4_E16_MF4 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #7763 = PseudoVRGATHEREI16_VV_MF4_E16_MF2_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #7762 = PseudoVRGATHEREI16_VV_MF4_E16_MF2 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #7761 = PseudoVRGATHEREI16_VV_MF2_E8_MF8_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #7760 = PseudoVRGATHEREI16_VV_MF2_E8_MF8 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #7759 = PseudoVRGATHEREI16_VV_MF2_E8_MF4_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #7758 = PseudoVRGATHEREI16_VV_MF2_E8_MF4 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #7757 = PseudoVRGATHEREI16_VV_MF2_E8_MF2_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #7756 = PseudoVRGATHEREI16_VV_MF2_E8_MF2 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #7755 = PseudoVRGATHEREI16_VV_MF2_E8_M1_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #7754 = PseudoVRGATHEREI16_VV_MF2_E8_M1 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #7753 = PseudoVRGATHEREI16_VV_MF2_E32_MF8_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #7752 = PseudoVRGATHEREI16_VV_MF2_E32_MF8 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #7751 = PseudoVRGATHEREI16_VV_MF2_E32_MF4_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #7750 = PseudoVRGATHEREI16_VV_MF2_E32_MF4 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #7749 = PseudoVRGATHEREI16_VV_MF2_E32_MF2_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #7748 = PseudoVRGATHEREI16_VV_MF2_E32_MF2 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #7747 = PseudoVRGATHEREI16_VV_MF2_E32_M1_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #7746 = PseudoVRGATHEREI16_VV_MF2_E32_M1 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #7745 = PseudoVRGATHEREI16_VV_MF2_E16_MF8_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #7744 = PseudoVRGATHEREI16_VV_MF2_E16_MF8 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #7743 = PseudoVRGATHEREI16_VV_MF2_E16_MF4_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #7742 = PseudoVRGATHEREI16_VV_MF2_E16_MF4 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #7741 = PseudoVRGATHEREI16_VV_MF2_E16_MF2_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #7740 = PseudoVRGATHEREI16_VV_MF2_E16_MF2 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #7739 = PseudoVRGATHEREI16_VV_MF2_E16_M1_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #7738 = PseudoVRGATHEREI16_VV_MF2_E16_M1 + { 8, &RISCVDescs.OperandInfo[345] }, // Inst #7737 = PseudoVRGATHEREI16_VV_M8_E8_M8_MASK + { 7, &RISCVDescs.OperandInfo[338] }, // Inst #7736 = PseudoVRGATHEREI16_VV_M8_E8_M8 + { 8, &RISCVDescs.OperandInfo[6332] }, // Inst #7735 = PseudoVRGATHEREI16_VV_M8_E8_M4_MASK + { 7, &RISCVDescs.OperandInfo[6325] }, // Inst #7734 = PseudoVRGATHEREI16_VV_M8_E8_M4 + { 8, &RISCVDescs.OperandInfo[6317] }, // Inst #7733 = PseudoVRGATHEREI16_VV_M8_E8_M2_MASK + { 7, &RISCVDescs.OperandInfo[6310] }, // Inst #7732 = PseudoVRGATHEREI16_VV_M8_E8_M2 + { 8, &RISCVDescs.OperandInfo[345] }, // Inst #7731 = PseudoVRGATHEREI16_VV_M8_E64_M8_MASK + { 7, &RISCVDescs.OperandInfo[338] }, // Inst #7730 = PseudoVRGATHEREI16_VV_M8_E64_M8 + { 8, &RISCVDescs.OperandInfo[6332] }, // Inst #7729 = PseudoVRGATHEREI16_VV_M8_E64_M4_MASK + { 7, &RISCVDescs.OperandInfo[6325] }, // Inst #7728 = PseudoVRGATHEREI16_VV_M8_E64_M4 + { 8, &RISCVDescs.OperandInfo[6317] }, // Inst #7727 = PseudoVRGATHEREI16_VV_M8_E64_M2_MASK + { 7, &RISCVDescs.OperandInfo[6310] }, // Inst #7726 = PseudoVRGATHEREI16_VV_M8_E64_M2 + { 8, &RISCVDescs.OperandInfo[345] }, // Inst #7725 = PseudoVRGATHEREI16_VV_M8_E32_M8_MASK + { 7, &RISCVDescs.OperandInfo[338] }, // Inst #7724 = PseudoVRGATHEREI16_VV_M8_E32_M8 + { 8, &RISCVDescs.OperandInfo[6332] }, // Inst #7723 = PseudoVRGATHEREI16_VV_M8_E32_M4_MASK + { 7, &RISCVDescs.OperandInfo[6325] }, // Inst #7722 = PseudoVRGATHEREI16_VV_M8_E32_M4 + { 8, &RISCVDescs.OperandInfo[6317] }, // Inst #7721 = PseudoVRGATHEREI16_VV_M8_E32_M2_MASK + { 7, &RISCVDescs.OperandInfo[6310] }, // Inst #7720 = PseudoVRGATHEREI16_VV_M8_E32_M2 + { 8, &RISCVDescs.OperandInfo[345] }, // Inst #7719 = PseudoVRGATHEREI16_VV_M8_E16_M8_MASK + { 7, &RISCVDescs.OperandInfo[338] }, // Inst #7718 = PseudoVRGATHEREI16_VV_M8_E16_M8 + { 8, &RISCVDescs.OperandInfo[6332] }, // Inst #7717 = PseudoVRGATHEREI16_VV_M8_E16_M4_MASK + { 7, &RISCVDescs.OperandInfo[6325] }, // Inst #7716 = PseudoVRGATHEREI16_VV_M8_E16_M4 + { 8, &RISCVDescs.OperandInfo[6317] }, // Inst #7715 = PseudoVRGATHEREI16_VV_M8_E16_M2_MASK + { 7, &RISCVDescs.OperandInfo[6310] }, // Inst #7714 = PseudoVRGATHEREI16_VV_M8_E16_M2 + { 8, &RISCVDescs.OperandInfo[6302] }, // Inst #7713 = PseudoVRGATHEREI16_VV_M4_E8_M8_MASK + { 7, &RISCVDescs.OperandInfo[6295] }, // Inst #7712 = PseudoVRGATHEREI16_VV_M4_E8_M8 + { 8, &RISCVDescs.OperandInfo[330] }, // Inst #7711 = PseudoVRGATHEREI16_VV_M4_E8_M4_MASK + { 7, &RISCVDescs.OperandInfo[323] }, // Inst #7710 = PseudoVRGATHEREI16_VV_M4_E8_M4 + { 8, &RISCVDescs.OperandInfo[6287] }, // Inst #7709 = PseudoVRGATHEREI16_VV_M4_E8_M2_MASK + { 7, &RISCVDescs.OperandInfo[6280] }, // Inst #7708 = PseudoVRGATHEREI16_VV_M4_E8_M2 + { 8, &RISCVDescs.OperandInfo[6272] }, // Inst #7707 = PseudoVRGATHEREI16_VV_M4_E8_M1_MASK + { 7, &RISCVDescs.OperandInfo[6265] }, // Inst #7706 = PseudoVRGATHEREI16_VV_M4_E8_M1 + { 8, &RISCVDescs.OperandInfo[6302] }, // Inst #7705 = PseudoVRGATHEREI16_VV_M4_E64_M8_MASK + { 7, &RISCVDescs.OperandInfo[6295] }, // Inst #7704 = PseudoVRGATHEREI16_VV_M4_E64_M8 + { 8, &RISCVDescs.OperandInfo[330] }, // Inst #7703 = PseudoVRGATHEREI16_VV_M4_E64_M4_MASK + { 7, &RISCVDescs.OperandInfo[323] }, // Inst #7702 = PseudoVRGATHEREI16_VV_M4_E64_M4 + { 8, &RISCVDescs.OperandInfo[6287] }, // Inst #7701 = PseudoVRGATHEREI16_VV_M4_E64_M2_MASK + { 7, &RISCVDescs.OperandInfo[6280] }, // Inst #7700 = PseudoVRGATHEREI16_VV_M4_E64_M2 + { 8, &RISCVDescs.OperandInfo[6272] }, // Inst #7699 = PseudoVRGATHEREI16_VV_M4_E64_M1_MASK + { 7, &RISCVDescs.OperandInfo[6265] }, // Inst #7698 = PseudoVRGATHEREI16_VV_M4_E64_M1 + { 8, &RISCVDescs.OperandInfo[6302] }, // Inst #7697 = PseudoVRGATHEREI16_VV_M4_E32_M8_MASK + { 7, &RISCVDescs.OperandInfo[6295] }, // Inst #7696 = PseudoVRGATHEREI16_VV_M4_E32_M8 + { 8, &RISCVDescs.OperandInfo[330] }, // Inst #7695 = PseudoVRGATHEREI16_VV_M4_E32_M4_MASK + { 7, &RISCVDescs.OperandInfo[323] }, // Inst #7694 = PseudoVRGATHEREI16_VV_M4_E32_M4 + { 8, &RISCVDescs.OperandInfo[6287] }, // Inst #7693 = PseudoVRGATHEREI16_VV_M4_E32_M2_MASK + { 7, &RISCVDescs.OperandInfo[6280] }, // Inst #7692 = PseudoVRGATHEREI16_VV_M4_E32_M2 + { 8, &RISCVDescs.OperandInfo[6272] }, // Inst #7691 = PseudoVRGATHEREI16_VV_M4_E32_M1_MASK + { 7, &RISCVDescs.OperandInfo[6265] }, // Inst #7690 = PseudoVRGATHEREI16_VV_M4_E32_M1 + { 8, &RISCVDescs.OperandInfo[6302] }, // Inst #7689 = PseudoVRGATHEREI16_VV_M4_E16_M8_MASK + { 7, &RISCVDescs.OperandInfo[6295] }, // Inst #7688 = PseudoVRGATHEREI16_VV_M4_E16_M8 + { 8, &RISCVDescs.OperandInfo[330] }, // Inst #7687 = PseudoVRGATHEREI16_VV_M4_E16_M4_MASK + { 7, &RISCVDescs.OperandInfo[323] }, // Inst #7686 = PseudoVRGATHEREI16_VV_M4_E16_M4 + { 8, &RISCVDescs.OperandInfo[6287] }, // Inst #7685 = PseudoVRGATHEREI16_VV_M4_E16_M2_MASK + { 7, &RISCVDescs.OperandInfo[6280] }, // Inst #7684 = PseudoVRGATHEREI16_VV_M4_E16_M2 + { 8, &RISCVDescs.OperandInfo[6272] }, // Inst #7683 = PseudoVRGATHEREI16_VV_M4_E16_M1_MASK + { 7, &RISCVDescs.OperandInfo[6265] }, // Inst #7682 = PseudoVRGATHEREI16_VV_M4_E16_M1 + { 8, &RISCVDescs.OperandInfo[6242] }, // Inst #7681 = PseudoVRGATHEREI16_VV_M2_E8_MF2_MASK + { 7, &RISCVDescs.OperandInfo[6235] }, // Inst #7680 = PseudoVRGATHEREI16_VV_M2_E8_MF2 + { 8, &RISCVDescs.OperandInfo[6257] }, // Inst #7679 = PseudoVRGATHEREI16_VV_M2_E8_M4_MASK + { 7, &RISCVDescs.OperandInfo[6250] }, // Inst #7678 = PseudoVRGATHEREI16_VV_M2_E8_M4 + { 8, &RISCVDescs.OperandInfo[315] }, // Inst #7677 = PseudoVRGATHEREI16_VV_M2_E8_M2_MASK + { 7, &RISCVDescs.OperandInfo[308] }, // Inst #7676 = PseudoVRGATHEREI16_VV_M2_E8_M2 + { 8, &RISCVDescs.OperandInfo[6242] }, // Inst #7675 = PseudoVRGATHEREI16_VV_M2_E8_M1_MASK + { 7, &RISCVDescs.OperandInfo[6235] }, // Inst #7674 = PseudoVRGATHEREI16_VV_M2_E8_M1 + { 8, &RISCVDescs.OperandInfo[6242] }, // Inst #7673 = PseudoVRGATHEREI16_VV_M2_E64_MF2_MASK + { 7, &RISCVDescs.OperandInfo[6235] }, // Inst #7672 = PseudoVRGATHEREI16_VV_M2_E64_MF2 + { 8, &RISCVDescs.OperandInfo[6257] }, // Inst #7671 = PseudoVRGATHEREI16_VV_M2_E64_M4_MASK + { 7, &RISCVDescs.OperandInfo[6250] }, // Inst #7670 = PseudoVRGATHEREI16_VV_M2_E64_M4 + { 8, &RISCVDescs.OperandInfo[315] }, // Inst #7669 = PseudoVRGATHEREI16_VV_M2_E64_M2_MASK + { 7, &RISCVDescs.OperandInfo[308] }, // Inst #7668 = PseudoVRGATHEREI16_VV_M2_E64_M2 + { 8, &RISCVDescs.OperandInfo[6242] }, // Inst #7667 = PseudoVRGATHEREI16_VV_M2_E64_M1_MASK + { 7, &RISCVDescs.OperandInfo[6235] }, // Inst #7666 = PseudoVRGATHEREI16_VV_M2_E64_M1 + { 8, &RISCVDescs.OperandInfo[6242] }, // Inst #7665 = PseudoVRGATHEREI16_VV_M2_E32_MF2_MASK + { 7, &RISCVDescs.OperandInfo[6235] }, // Inst #7664 = PseudoVRGATHEREI16_VV_M2_E32_MF2 + { 8, &RISCVDescs.OperandInfo[6257] }, // Inst #7663 = PseudoVRGATHEREI16_VV_M2_E32_M4_MASK + { 7, &RISCVDescs.OperandInfo[6250] }, // Inst #7662 = PseudoVRGATHEREI16_VV_M2_E32_M4 + { 8, &RISCVDescs.OperandInfo[315] }, // Inst #7661 = PseudoVRGATHEREI16_VV_M2_E32_M2_MASK + { 7, &RISCVDescs.OperandInfo[308] }, // Inst #7660 = PseudoVRGATHEREI16_VV_M2_E32_M2 + { 8, &RISCVDescs.OperandInfo[6242] }, // Inst #7659 = PseudoVRGATHEREI16_VV_M2_E32_M1_MASK + { 7, &RISCVDescs.OperandInfo[6235] }, // Inst #7658 = PseudoVRGATHEREI16_VV_M2_E32_M1 + { 8, &RISCVDescs.OperandInfo[6242] }, // Inst #7657 = PseudoVRGATHEREI16_VV_M2_E16_MF2_MASK + { 7, &RISCVDescs.OperandInfo[6235] }, // Inst #7656 = PseudoVRGATHEREI16_VV_M2_E16_MF2 + { 8, &RISCVDescs.OperandInfo[6257] }, // Inst #7655 = PseudoVRGATHEREI16_VV_M2_E16_M4_MASK + { 7, &RISCVDescs.OperandInfo[6250] }, // Inst #7654 = PseudoVRGATHEREI16_VV_M2_E16_M4 + { 8, &RISCVDescs.OperandInfo[315] }, // Inst #7653 = PseudoVRGATHEREI16_VV_M2_E16_M2_MASK + { 7, &RISCVDescs.OperandInfo[308] }, // Inst #7652 = PseudoVRGATHEREI16_VV_M2_E16_M2 + { 8, &RISCVDescs.OperandInfo[6242] }, // Inst #7651 = PseudoVRGATHEREI16_VV_M2_E16_M1_MASK + { 7, &RISCVDescs.OperandInfo[6235] }, // Inst #7650 = PseudoVRGATHEREI16_VV_M2_E16_M1 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #7649 = PseudoVRGATHEREI16_VV_M1_E8_MF4_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #7648 = PseudoVRGATHEREI16_VV_M1_E8_MF4 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #7647 = PseudoVRGATHEREI16_VV_M1_E8_MF2_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #7646 = PseudoVRGATHEREI16_VV_M1_E8_MF2 + { 8, &RISCVDescs.OperandInfo[6227] }, // Inst #7645 = PseudoVRGATHEREI16_VV_M1_E8_M2_MASK + { 7, &RISCVDescs.OperandInfo[6220] }, // Inst #7644 = PseudoVRGATHEREI16_VV_M1_E8_M2 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #7643 = PseudoVRGATHEREI16_VV_M1_E8_M1_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #7642 = PseudoVRGATHEREI16_VV_M1_E8_M1 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #7641 = PseudoVRGATHEREI16_VV_M1_E64_MF4_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #7640 = PseudoVRGATHEREI16_VV_M1_E64_MF4 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #7639 = PseudoVRGATHEREI16_VV_M1_E64_MF2_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #7638 = PseudoVRGATHEREI16_VV_M1_E64_MF2 + { 8, &RISCVDescs.OperandInfo[6227] }, // Inst #7637 = PseudoVRGATHEREI16_VV_M1_E64_M2_MASK + { 7, &RISCVDescs.OperandInfo[6220] }, // Inst #7636 = PseudoVRGATHEREI16_VV_M1_E64_M2 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #7635 = PseudoVRGATHEREI16_VV_M1_E64_M1_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #7634 = PseudoVRGATHEREI16_VV_M1_E64_M1 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #7633 = PseudoVRGATHEREI16_VV_M1_E32_MF4_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #7632 = PseudoVRGATHEREI16_VV_M1_E32_MF4 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #7631 = PseudoVRGATHEREI16_VV_M1_E32_MF2_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #7630 = PseudoVRGATHEREI16_VV_M1_E32_MF2 + { 8, &RISCVDescs.OperandInfo[6227] }, // Inst #7629 = PseudoVRGATHEREI16_VV_M1_E32_M2_MASK + { 7, &RISCVDescs.OperandInfo[6220] }, // Inst #7628 = PseudoVRGATHEREI16_VV_M1_E32_M2 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #7627 = PseudoVRGATHEREI16_VV_M1_E32_M1_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #7626 = PseudoVRGATHEREI16_VV_M1_E32_M1 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #7625 = PseudoVRGATHEREI16_VV_M1_E16_MF4_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #7624 = PseudoVRGATHEREI16_VV_M1_E16_MF4 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #7623 = PseudoVRGATHEREI16_VV_M1_E16_MF2_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #7622 = PseudoVRGATHEREI16_VV_M1_E16_MF2 + { 8, &RISCVDescs.OperandInfo[6227] }, // Inst #7621 = PseudoVRGATHEREI16_VV_M1_E16_M2_MASK + { 7, &RISCVDescs.OperandInfo[6220] }, // Inst #7620 = PseudoVRGATHEREI16_VV_M1_E16_M2 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #7619 = PseudoVRGATHEREI16_VV_M1_E16_M1_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #7618 = PseudoVRGATHEREI16_VV_M1_E16_M1 + { 7, &RISCVDescs.OperandInfo[905] }, // Inst #7617 = PseudoVREV8_V_MF8_MASK + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #7616 = PseudoVREV8_V_MF8 + { 7, &RISCVDescs.OperandInfo[905] }, // Inst #7615 = PseudoVREV8_V_MF4_MASK + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #7614 = PseudoVREV8_V_MF4 + { 7, &RISCVDescs.OperandInfo[905] }, // Inst #7613 = PseudoVREV8_V_MF2_MASK + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #7612 = PseudoVREV8_V_MF2 + { 7, &RISCVDescs.OperandInfo[926] }, // Inst #7611 = PseudoVREV8_V_M8_MASK + { 6, &RISCVDescs.OperandInfo[871] }, // Inst #7610 = PseudoVREV8_V_M8 + { 7, &RISCVDescs.OperandInfo[919] }, // Inst #7609 = PseudoVREV8_V_M4_MASK + { 6, &RISCVDescs.OperandInfo[847] }, // Inst #7608 = PseudoVREV8_V_M4 + { 7, &RISCVDescs.OperandInfo[912] }, // Inst #7607 = PseudoVREV8_V_M2_MASK + { 6, &RISCVDescs.OperandInfo[829] }, // Inst #7606 = PseudoVREV8_V_M2 + { 7, &RISCVDescs.OperandInfo[905] }, // Inst #7605 = PseudoVREV8_V_M1_MASK + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #7604 = PseudoVREV8_V_M1 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #7603 = PseudoVREM_VX_MF8_E8_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #7602 = PseudoVREM_VX_MF8_E8 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #7601 = PseudoVREM_VX_MF4_E8_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #7600 = PseudoVREM_VX_MF4_E8 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #7599 = PseudoVREM_VX_MF4_E16_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #7598 = PseudoVREM_VX_MF4_E16 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #7597 = PseudoVREM_VX_MF2_E8_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #7596 = PseudoVREM_VX_MF2_E8 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #7595 = PseudoVREM_VX_MF2_E32_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #7594 = PseudoVREM_VX_MF2_E32 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #7593 = PseudoVREM_VX_MF2_E16_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #7592 = PseudoVREM_VX_MF2_E16 + { 8, &RISCVDescs.OperandInfo[809] }, // Inst #7591 = PseudoVREM_VX_M8_E8_MASK + { 7, &RISCVDescs.OperandInfo[802] }, // Inst #7590 = PseudoVREM_VX_M8_E8 + { 8, &RISCVDescs.OperandInfo[809] }, // Inst #7589 = PseudoVREM_VX_M8_E64_MASK + { 7, &RISCVDescs.OperandInfo[802] }, // Inst #7588 = PseudoVREM_VX_M8_E64 + { 8, &RISCVDescs.OperandInfo[809] }, // Inst #7587 = PseudoVREM_VX_M8_E32_MASK + { 7, &RISCVDescs.OperandInfo[802] }, // Inst #7586 = PseudoVREM_VX_M8_E32 + { 8, &RISCVDescs.OperandInfo[809] }, // Inst #7585 = PseudoVREM_VX_M8_E16_MASK + { 7, &RISCVDescs.OperandInfo[802] }, // Inst #7584 = PseudoVREM_VX_M8_E16 + { 8, &RISCVDescs.OperandInfo[794] }, // Inst #7583 = PseudoVREM_VX_M4_E8_MASK + { 7, &RISCVDescs.OperandInfo[787] }, // Inst #7582 = PseudoVREM_VX_M4_E8 + { 8, &RISCVDescs.OperandInfo[794] }, // Inst #7581 = PseudoVREM_VX_M4_E64_MASK + { 7, &RISCVDescs.OperandInfo[787] }, // Inst #7580 = PseudoVREM_VX_M4_E64 + { 8, &RISCVDescs.OperandInfo[794] }, // Inst #7579 = PseudoVREM_VX_M4_E32_MASK + { 7, &RISCVDescs.OperandInfo[787] }, // Inst #7578 = PseudoVREM_VX_M4_E32 + { 8, &RISCVDescs.OperandInfo[794] }, // Inst #7577 = PseudoVREM_VX_M4_E16_MASK + { 7, &RISCVDescs.OperandInfo[787] }, // Inst #7576 = PseudoVREM_VX_M4_E16 + { 8, &RISCVDescs.OperandInfo[779] }, // Inst #7575 = PseudoVREM_VX_M2_E8_MASK + { 7, &RISCVDescs.OperandInfo[772] }, // Inst #7574 = PseudoVREM_VX_M2_E8 + { 8, &RISCVDescs.OperandInfo[779] }, // Inst #7573 = PseudoVREM_VX_M2_E64_MASK + { 7, &RISCVDescs.OperandInfo[772] }, // Inst #7572 = PseudoVREM_VX_M2_E64 + { 8, &RISCVDescs.OperandInfo[779] }, // Inst #7571 = PseudoVREM_VX_M2_E32_MASK + { 7, &RISCVDescs.OperandInfo[772] }, // Inst #7570 = PseudoVREM_VX_M2_E32 + { 8, &RISCVDescs.OperandInfo[779] }, // Inst #7569 = PseudoVREM_VX_M2_E16_MASK + { 7, &RISCVDescs.OperandInfo[772] }, // Inst #7568 = PseudoVREM_VX_M2_E16 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #7567 = PseudoVREM_VX_M1_E8_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #7566 = PseudoVREM_VX_M1_E8 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #7565 = PseudoVREM_VX_M1_E64_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #7564 = PseudoVREM_VX_M1_E64 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #7563 = PseudoVREM_VX_M1_E32_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #7562 = PseudoVREM_VX_M1_E32 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #7561 = PseudoVREM_VX_M1_E16_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #7560 = PseudoVREM_VX_M1_E16 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7559 = PseudoVREM_VV_MF8_E8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7558 = PseudoVREM_VV_MF8_E8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7557 = PseudoVREM_VV_MF4_E8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7556 = PseudoVREM_VV_MF4_E8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7555 = PseudoVREM_VV_MF4_E16_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7554 = PseudoVREM_VV_MF4_E16 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7553 = PseudoVREM_VV_MF2_E8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7552 = PseudoVREM_VV_MF2_E8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7551 = PseudoVREM_VV_MF2_E32_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7550 = PseudoVREM_VV_MF2_E32 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7549 = PseudoVREM_VV_MF2_E16_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7548 = PseudoVREM_VV_MF2_E16 + { 8, &RISCVDescs.OperandInfo[749] }, // Inst #7547 = PseudoVREM_VV_M8_E8_MASK + { 7, &RISCVDescs.OperandInfo[742] }, // Inst #7546 = PseudoVREM_VV_M8_E8 + { 8, &RISCVDescs.OperandInfo[749] }, // Inst #7545 = PseudoVREM_VV_M8_E64_MASK + { 7, &RISCVDescs.OperandInfo[742] }, // Inst #7544 = PseudoVREM_VV_M8_E64 + { 8, &RISCVDescs.OperandInfo[749] }, // Inst #7543 = PseudoVREM_VV_M8_E32_MASK + { 7, &RISCVDescs.OperandInfo[742] }, // Inst #7542 = PseudoVREM_VV_M8_E32 + { 8, &RISCVDescs.OperandInfo[749] }, // Inst #7541 = PseudoVREM_VV_M8_E16_MASK + { 7, &RISCVDescs.OperandInfo[742] }, // Inst #7540 = PseudoVREM_VV_M8_E16 + { 8, &RISCVDescs.OperandInfo[734] }, // Inst #7539 = PseudoVREM_VV_M4_E8_MASK + { 7, &RISCVDescs.OperandInfo[727] }, // Inst #7538 = PseudoVREM_VV_M4_E8 + { 8, &RISCVDescs.OperandInfo[734] }, // Inst #7537 = PseudoVREM_VV_M4_E64_MASK + { 7, &RISCVDescs.OperandInfo[727] }, // Inst #7536 = PseudoVREM_VV_M4_E64 + { 8, &RISCVDescs.OperandInfo[734] }, // Inst #7535 = PseudoVREM_VV_M4_E32_MASK + { 7, &RISCVDescs.OperandInfo[727] }, // Inst #7534 = PseudoVREM_VV_M4_E32 + { 8, &RISCVDescs.OperandInfo[734] }, // Inst #7533 = PseudoVREM_VV_M4_E16_MASK + { 7, &RISCVDescs.OperandInfo[727] }, // Inst #7532 = PseudoVREM_VV_M4_E16 + { 8, &RISCVDescs.OperandInfo[719] }, // Inst #7531 = PseudoVREM_VV_M2_E8_MASK + { 7, &RISCVDescs.OperandInfo[712] }, // Inst #7530 = PseudoVREM_VV_M2_E8 + { 8, &RISCVDescs.OperandInfo[719] }, // Inst #7529 = PseudoVREM_VV_M2_E64_MASK + { 7, &RISCVDescs.OperandInfo[712] }, // Inst #7528 = PseudoVREM_VV_M2_E64 + { 8, &RISCVDescs.OperandInfo[719] }, // Inst #7527 = PseudoVREM_VV_M2_E32_MASK + { 7, &RISCVDescs.OperandInfo[712] }, // Inst #7526 = PseudoVREM_VV_M2_E32 + { 8, &RISCVDescs.OperandInfo[719] }, // Inst #7525 = PseudoVREM_VV_M2_E16_MASK + { 7, &RISCVDescs.OperandInfo[712] }, // Inst #7524 = PseudoVREM_VV_M2_E16 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7523 = PseudoVREM_VV_M1_E8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7522 = PseudoVREM_VV_M1_E8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7521 = PseudoVREM_VV_M1_E64_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7520 = PseudoVREM_VV_M1_E64 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7519 = PseudoVREM_VV_M1_E32_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7518 = PseudoVREM_VV_M1_E32 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7517 = PseudoVREM_VV_M1_E16_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7516 = PseudoVREM_VV_M1_E16 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #7515 = PseudoVREMU_VX_MF8_E8_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #7514 = PseudoVREMU_VX_MF8_E8 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #7513 = PseudoVREMU_VX_MF4_E8_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #7512 = PseudoVREMU_VX_MF4_E8 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #7511 = PseudoVREMU_VX_MF4_E16_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #7510 = PseudoVREMU_VX_MF4_E16 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #7509 = PseudoVREMU_VX_MF2_E8_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #7508 = PseudoVREMU_VX_MF2_E8 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #7507 = PseudoVREMU_VX_MF2_E32_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #7506 = PseudoVREMU_VX_MF2_E32 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #7505 = PseudoVREMU_VX_MF2_E16_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #7504 = PseudoVREMU_VX_MF2_E16 + { 8, &RISCVDescs.OperandInfo[809] }, // Inst #7503 = PseudoVREMU_VX_M8_E8_MASK + { 7, &RISCVDescs.OperandInfo[802] }, // Inst #7502 = PseudoVREMU_VX_M8_E8 + { 8, &RISCVDescs.OperandInfo[809] }, // Inst #7501 = PseudoVREMU_VX_M8_E64_MASK + { 7, &RISCVDescs.OperandInfo[802] }, // Inst #7500 = PseudoVREMU_VX_M8_E64 + { 8, &RISCVDescs.OperandInfo[809] }, // Inst #7499 = PseudoVREMU_VX_M8_E32_MASK + { 7, &RISCVDescs.OperandInfo[802] }, // Inst #7498 = PseudoVREMU_VX_M8_E32 + { 8, &RISCVDescs.OperandInfo[809] }, // Inst #7497 = PseudoVREMU_VX_M8_E16_MASK + { 7, &RISCVDescs.OperandInfo[802] }, // Inst #7496 = PseudoVREMU_VX_M8_E16 + { 8, &RISCVDescs.OperandInfo[794] }, // Inst #7495 = PseudoVREMU_VX_M4_E8_MASK + { 7, &RISCVDescs.OperandInfo[787] }, // Inst #7494 = PseudoVREMU_VX_M4_E8 + { 8, &RISCVDescs.OperandInfo[794] }, // Inst #7493 = PseudoVREMU_VX_M4_E64_MASK + { 7, &RISCVDescs.OperandInfo[787] }, // Inst #7492 = PseudoVREMU_VX_M4_E64 + { 8, &RISCVDescs.OperandInfo[794] }, // Inst #7491 = PseudoVREMU_VX_M4_E32_MASK + { 7, &RISCVDescs.OperandInfo[787] }, // Inst #7490 = PseudoVREMU_VX_M4_E32 + { 8, &RISCVDescs.OperandInfo[794] }, // Inst #7489 = PseudoVREMU_VX_M4_E16_MASK + { 7, &RISCVDescs.OperandInfo[787] }, // Inst #7488 = PseudoVREMU_VX_M4_E16 + { 8, &RISCVDescs.OperandInfo[779] }, // Inst #7487 = PseudoVREMU_VX_M2_E8_MASK + { 7, &RISCVDescs.OperandInfo[772] }, // Inst #7486 = PseudoVREMU_VX_M2_E8 + { 8, &RISCVDescs.OperandInfo[779] }, // Inst #7485 = PseudoVREMU_VX_M2_E64_MASK + { 7, &RISCVDescs.OperandInfo[772] }, // Inst #7484 = PseudoVREMU_VX_M2_E64 + { 8, &RISCVDescs.OperandInfo[779] }, // Inst #7483 = PseudoVREMU_VX_M2_E32_MASK + { 7, &RISCVDescs.OperandInfo[772] }, // Inst #7482 = PseudoVREMU_VX_M2_E32 + { 8, &RISCVDescs.OperandInfo[779] }, // Inst #7481 = PseudoVREMU_VX_M2_E16_MASK + { 7, &RISCVDescs.OperandInfo[772] }, // Inst #7480 = PseudoVREMU_VX_M2_E16 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #7479 = PseudoVREMU_VX_M1_E8_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #7478 = PseudoVREMU_VX_M1_E8 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #7477 = PseudoVREMU_VX_M1_E64_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #7476 = PseudoVREMU_VX_M1_E64 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #7475 = PseudoVREMU_VX_M1_E32_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #7474 = PseudoVREMU_VX_M1_E32 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #7473 = PseudoVREMU_VX_M1_E16_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #7472 = PseudoVREMU_VX_M1_E16 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7471 = PseudoVREMU_VV_MF8_E8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7470 = PseudoVREMU_VV_MF8_E8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7469 = PseudoVREMU_VV_MF4_E8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7468 = PseudoVREMU_VV_MF4_E8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7467 = PseudoVREMU_VV_MF4_E16_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7466 = PseudoVREMU_VV_MF4_E16 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7465 = PseudoVREMU_VV_MF2_E8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7464 = PseudoVREMU_VV_MF2_E8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7463 = PseudoVREMU_VV_MF2_E32_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7462 = PseudoVREMU_VV_MF2_E32 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7461 = PseudoVREMU_VV_MF2_E16_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7460 = PseudoVREMU_VV_MF2_E16 + { 8, &RISCVDescs.OperandInfo[749] }, // Inst #7459 = PseudoVREMU_VV_M8_E8_MASK + { 7, &RISCVDescs.OperandInfo[742] }, // Inst #7458 = PseudoVREMU_VV_M8_E8 + { 8, &RISCVDescs.OperandInfo[749] }, // Inst #7457 = PseudoVREMU_VV_M8_E64_MASK + { 7, &RISCVDescs.OperandInfo[742] }, // Inst #7456 = PseudoVREMU_VV_M8_E64 + { 8, &RISCVDescs.OperandInfo[749] }, // Inst #7455 = PseudoVREMU_VV_M8_E32_MASK + { 7, &RISCVDescs.OperandInfo[742] }, // Inst #7454 = PseudoVREMU_VV_M8_E32 + { 8, &RISCVDescs.OperandInfo[749] }, // Inst #7453 = PseudoVREMU_VV_M8_E16_MASK + { 7, &RISCVDescs.OperandInfo[742] }, // Inst #7452 = PseudoVREMU_VV_M8_E16 + { 8, &RISCVDescs.OperandInfo[734] }, // Inst #7451 = PseudoVREMU_VV_M4_E8_MASK + { 7, &RISCVDescs.OperandInfo[727] }, // Inst #7450 = PseudoVREMU_VV_M4_E8 + { 8, &RISCVDescs.OperandInfo[734] }, // Inst #7449 = PseudoVREMU_VV_M4_E64_MASK + { 7, &RISCVDescs.OperandInfo[727] }, // Inst #7448 = PseudoVREMU_VV_M4_E64 + { 8, &RISCVDescs.OperandInfo[734] }, // Inst #7447 = PseudoVREMU_VV_M4_E32_MASK + { 7, &RISCVDescs.OperandInfo[727] }, // Inst #7446 = PseudoVREMU_VV_M4_E32 + { 8, &RISCVDescs.OperandInfo[734] }, // Inst #7445 = PseudoVREMU_VV_M4_E16_MASK + { 7, &RISCVDescs.OperandInfo[727] }, // Inst #7444 = PseudoVREMU_VV_M4_E16 + { 8, &RISCVDescs.OperandInfo[719] }, // Inst #7443 = PseudoVREMU_VV_M2_E8_MASK + { 7, &RISCVDescs.OperandInfo[712] }, // Inst #7442 = PseudoVREMU_VV_M2_E8 + { 8, &RISCVDescs.OperandInfo[719] }, // Inst #7441 = PseudoVREMU_VV_M2_E64_MASK + { 7, &RISCVDescs.OperandInfo[712] }, // Inst #7440 = PseudoVREMU_VV_M2_E64 + { 8, &RISCVDescs.OperandInfo[719] }, // Inst #7439 = PseudoVREMU_VV_M2_E32_MASK + { 7, &RISCVDescs.OperandInfo[712] }, // Inst #7438 = PseudoVREMU_VV_M2_E32 + { 8, &RISCVDescs.OperandInfo[719] }, // Inst #7437 = PseudoVREMU_VV_M2_E16_MASK + { 7, &RISCVDescs.OperandInfo[712] }, // Inst #7436 = PseudoVREMU_VV_M2_E16 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7435 = PseudoVREMU_VV_M1_E8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7434 = PseudoVREMU_VV_M1_E8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7433 = PseudoVREMU_VV_M1_E64_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7432 = PseudoVREMU_VV_M1_E64 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7431 = PseudoVREMU_VV_M1_E32_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7430 = PseudoVREMU_VV_M1_E32 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7429 = PseudoVREMU_VV_M1_E16_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7428 = PseudoVREMU_VV_M1_E16 + { 2, &RISCVDescs.OperandInfo[6218] }, // Inst #7427 = PseudoVRELOAD8_MF8 + { 2, &RISCVDescs.OperandInfo[6218] }, // Inst #7426 = PseudoVRELOAD8_MF4 + { 2, &RISCVDescs.OperandInfo[6218] }, // Inst #7425 = PseudoVRELOAD8_MF2 + { 2, &RISCVDescs.OperandInfo[6218] }, // Inst #7424 = PseudoVRELOAD8_M1 + { 2, &RISCVDescs.OperandInfo[6216] }, // Inst #7423 = PseudoVRELOAD7_MF8 + { 2, &RISCVDescs.OperandInfo[6216] }, // Inst #7422 = PseudoVRELOAD7_MF4 + { 2, &RISCVDescs.OperandInfo[6216] }, // Inst #7421 = PseudoVRELOAD7_MF2 + { 2, &RISCVDescs.OperandInfo[6216] }, // Inst #7420 = PseudoVRELOAD7_M1 + { 2, &RISCVDescs.OperandInfo[6214] }, // Inst #7419 = PseudoVRELOAD6_MF8 + { 2, &RISCVDescs.OperandInfo[6214] }, // Inst #7418 = PseudoVRELOAD6_MF4 + { 2, &RISCVDescs.OperandInfo[6214] }, // Inst #7417 = PseudoVRELOAD6_MF2 + { 2, &RISCVDescs.OperandInfo[6214] }, // Inst #7416 = PseudoVRELOAD6_M1 + { 2, &RISCVDescs.OperandInfo[6212] }, // Inst #7415 = PseudoVRELOAD5_MF8 + { 2, &RISCVDescs.OperandInfo[6212] }, // Inst #7414 = PseudoVRELOAD5_MF4 + { 2, &RISCVDescs.OperandInfo[6212] }, // Inst #7413 = PseudoVRELOAD5_MF2 + { 2, &RISCVDescs.OperandInfo[6212] }, // Inst #7412 = PseudoVRELOAD5_M1 + { 2, &RISCVDescs.OperandInfo[6208] }, // Inst #7411 = PseudoVRELOAD4_MF8 + { 2, &RISCVDescs.OperandInfo[6208] }, // Inst #7410 = PseudoVRELOAD4_MF4 + { 2, &RISCVDescs.OperandInfo[6208] }, // Inst #7409 = PseudoVRELOAD4_MF2 + { 2, &RISCVDescs.OperandInfo[6210] }, // Inst #7408 = PseudoVRELOAD4_M2 + { 2, &RISCVDescs.OperandInfo[6208] }, // Inst #7407 = PseudoVRELOAD4_M1 + { 2, &RISCVDescs.OperandInfo[6204] }, // Inst #7406 = PseudoVRELOAD3_MF8 + { 2, &RISCVDescs.OperandInfo[6204] }, // Inst #7405 = PseudoVRELOAD3_MF4 + { 2, &RISCVDescs.OperandInfo[6204] }, // Inst #7404 = PseudoVRELOAD3_MF2 + { 2, &RISCVDescs.OperandInfo[6206] }, // Inst #7403 = PseudoVRELOAD3_M2 + { 2, &RISCVDescs.OperandInfo[6204] }, // Inst #7402 = PseudoVRELOAD3_M1 + { 2, &RISCVDescs.OperandInfo[6198] }, // Inst #7401 = PseudoVRELOAD2_MF8 + { 2, &RISCVDescs.OperandInfo[6198] }, // Inst #7400 = PseudoVRELOAD2_MF4 + { 2, &RISCVDescs.OperandInfo[6198] }, // Inst #7399 = PseudoVRELOAD2_MF2 + { 2, &RISCVDescs.OperandInfo[6202] }, // Inst #7398 = PseudoVRELOAD2_M4 + { 2, &RISCVDescs.OperandInfo[6200] }, // Inst #7397 = PseudoVRELOAD2_M2 + { 2, &RISCVDescs.OperandInfo[6198] }, // Inst #7396 = PseudoVRELOAD2_M1 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7395 = PseudoVREDXOR_VS_MF8_E8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7394 = PseudoVREDXOR_VS_MF8_E8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7393 = PseudoVREDXOR_VS_MF4_E8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7392 = PseudoVREDXOR_VS_MF4_E8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7391 = PseudoVREDXOR_VS_MF4_E16_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7390 = PseudoVREDXOR_VS_MF4_E16 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7389 = PseudoVREDXOR_VS_MF2_E8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7388 = PseudoVREDXOR_VS_MF2_E8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7387 = PseudoVREDXOR_VS_MF2_E32_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7386 = PseudoVREDXOR_VS_MF2_E32 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7385 = PseudoVREDXOR_VS_MF2_E16_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7384 = PseudoVREDXOR_VS_MF2_E16 + { 8, &RISCVDescs.OperandInfo[2999] }, // Inst #7383 = PseudoVREDXOR_VS_M8_E8_MASK + { 7, &RISCVDescs.OperandInfo[2992] }, // Inst #7382 = PseudoVREDXOR_VS_M8_E8 + { 8, &RISCVDescs.OperandInfo[2999] }, // Inst #7381 = PseudoVREDXOR_VS_M8_E64_MASK + { 7, &RISCVDescs.OperandInfo[2992] }, // Inst #7380 = PseudoVREDXOR_VS_M8_E64 + { 8, &RISCVDescs.OperandInfo[2999] }, // Inst #7379 = PseudoVREDXOR_VS_M8_E32_MASK + { 7, &RISCVDescs.OperandInfo[2992] }, // Inst #7378 = PseudoVREDXOR_VS_M8_E32 + { 8, &RISCVDescs.OperandInfo[2999] }, // Inst #7377 = PseudoVREDXOR_VS_M8_E16_MASK + { 7, &RISCVDescs.OperandInfo[2992] }, // Inst #7376 = PseudoVREDXOR_VS_M8_E16 + { 8, &RISCVDescs.OperandInfo[2984] }, // Inst #7375 = PseudoVREDXOR_VS_M4_E8_MASK + { 7, &RISCVDescs.OperandInfo[2977] }, // Inst #7374 = PseudoVREDXOR_VS_M4_E8 + { 8, &RISCVDescs.OperandInfo[2984] }, // Inst #7373 = PseudoVREDXOR_VS_M4_E64_MASK + { 7, &RISCVDescs.OperandInfo[2977] }, // Inst #7372 = PseudoVREDXOR_VS_M4_E64 + { 8, &RISCVDescs.OperandInfo[2984] }, // Inst #7371 = PseudoVREDXOR_VS_M4_E32_MASK + { 7, &RISCVDescs.OperandInfo[2977] }, // Inst #7370 = PseudoVREDXOR_VS_M4_E32 + { 8, &RISCVDescs.OperandInfo[2984] }, // Inst #7369 = PseudoVREDXOR_VS_M4_E16_MASK + { 7, &RISCVDescs.OperandInfo[2977] }, // Inst #7368 = PseudoVREDXOR_VS_M4_E16 + { 8, &RISCVDescs.OperandInfo[2969] }, // Inst #7367 = PseudoVREDXOR_VS_M2_E8_MASK + { 7, &RISCVDescs.OperandInfo[2962] }, // Inst #7366 = PseudoVREDXOR_VS_M2_E8 + { 8, &RISCVDescs.OperandInfo[2969] }, // Inst #7365 = PseudoVREDXOR_VS_M2_E64_MASK + { 7, &RISCVDescs.OperandInfo[2962] }, // Inst #7364 = PseudoVREDXOR_VS_M2_E64 + { 8, &RISCVDescs.OperandInfo[2969] }, // Inst #7363 = PseudoVREDXOR_VS_M2_E32_MASK + { 7, &RISCVDescs.OperandInfo[2962] }, // Inst #7362 = PseudoVREDXOR_VS_M2_E32 + { 8, &RISCVDescs.OperandInfo[2969] }, // Inst #7361 = PseudoVREDXOR_VS_M2_E16_MASK + { 7, &RISCVDescs.OperandInfo[2962] }, // Inst #7360 = PseudoVREDXOR_VS_M2_E16 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7359 = PseudoVREDXOR_VS_M1_E8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7358 = PseudoVREDXOR_VS_M1_E8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7357 = PseudoVREDXOR_VS_M1_E64_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7356 = PseudoVREDXOR_VS_M1_E64 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7355 = PseudoVREDXOR_VS_M1_E32_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7354 = PseudoVREDXOR_VS_M1_E32 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7353 = PseudoVREDXOR_VS_M1_E16_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7352 = PseudoVREDXOR_VS_M1_E16 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7351 = PseudoVREDSUM_VS_MF8_E8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7350 = PseudoVREDSUM_VS_MF8_E8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7349 = PseudoVREDSUM_VS_MF4_E8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7348 = PseudoVREDSUM_VS_MF4_E8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7347 = PseudoVREDSUM_VS_MF4_E16_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7346 = PseudoVREDSUM_VS_MF4_E16 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7345 = PseudoVREDSUM_VS_MF2_E8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7344 = PseudoVREDSUM_VS_MF2_E8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7343 = PseudoVREDSUM_VS_MF2_E32_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7342 = PseudoVREDSUM_VS_MF2_E32 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7341 = PseudoVREDSUM_VS_MF2_E16_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7340 = PseudoVREDSUM_VS_MF2_E16 + { 8, &RISCVDescs.OperandInfo[2999] }, // Inst #7339 = PseudoVREDSUM_VS_M8_E8_MASK + { 7, &RISCVDescs.OperandInfo[2992] }, // Inst #7338 = PseudoVREDSUM_VS_M8_E8 + { 8, &RISCVDescs.OperandInfo[2999] }, // Inst #7337 = PseudoVREDSUM_VS_M8_E64_MASK + { 7, &RISCVDescs.OperandInfo[2992] }, // Inst #7336 = PseudoVREDSUM_VS_M8_E64 + { 8, &RISCVDescs.OperandInfo[2999] }, // Inst #7335 = PseudoVREDSUM_VS_M8_E32_MASK + { 7, &RISCVDescs.OperandInfo[2992] }, // Inst #7334 = PseudoVREDSUM_VS_M8_E32 + { 8, &RISCVDescs.OperandInfo[2999] }, // Inst #7333 = PseudoVREDSUM_VS_M8_E16_MASK + { 7, &RISCVDescs.OperandInfo[2992] }, // Inst #7332 = PseudoVREDSUM_VS_M8_E16 + { 8, &RISCVDescs.OperandInfo[2984] }, // Inst #7331 = PseudoVREDSUM_VS_M4_E8_MASK + { 7, &RISCVDescs.OperandInfo[2977] }, // Inst #7330 = PseudoVREDSUM_VS_M4_E8 + { 8, &RISCVDescs.OperandInfo[2984] }, // Inst #7329 = PseudoVREDSUM_VS_M4_E64_MASK + { 7, &RISCVDescs.OperandInfo[2977] }, // Inst #7328 = PseudoVREDSUM_VS_M4_E64 + { 8, &RISCVDescs.OperandInfo[2984] }, // Inst #7327 = PseudoVREDSUM_VS_M4_E32_MASK + { 7, &RISCVDescs.OperandInfo[2977] }, // Inst #7326 = PseudoVREDSUM_VS_M4_E32 + { 8, &RISCVDescs.OperandInfo[2984] }, // Inst #7325 = PseudoVREDSUM_VS_M4_E16_MASK + { 7, &RISCVDescs.OperandInfo[2977] }, // Inst #7324 = PseudoVREDSUM_VS_M4_E16 + { 8, &RISCVDescs.OperandInfo[2969] }, // Inst #7323 = PseudoVREDSUM_VS_M2_E8_MASK + { 7, &RISCVDescs.OperandInfo[2962] }, // Inst #7322 = PseudoVREDSUM_VS_M2_E8 + { 8, &RISCVDescs.OperandInfo[2969] }, // Inst #7321 = PseudoVREDSUM_VS_M2_E64_MASK + { 7, &RISCVDescs.OperandInfo[2962] }, // Inst #7320 = PseudoVREDSUM_VS_M2_E64 + { 8, &RISCVDescs.OperandInfo[2969] }, // Inst #7319 = PseudoVREDSUM_VS_M2_E32_MASK + { 7, &RISCVDescs.OperandInfo[2962] }, // Inst #7318 = PseudoVREDSUM_VS_M2_E32 + { 8, &RISCVDescs.OperandInfo[2969] }, // Inst #7317 = PseudoVREDSUM_VS_M2_E16_MASK + { 7, &RISCVDescs.OperandInfo[2962] }, // Inst #7316 = PseudoVREDSUM_VS_M2_E16 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7315 = PseudoVREDSUM_VS_M1_E8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7314 = PseudoVREDSUM_VS_M1_E8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7313 = PseudoVREDSUM_VS_M1_E64_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7312 = PseudoVREDSUM_VS_M1_E64 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7311 = PseudoVREDSUM_VS_M1_E32_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7310 = PseudoVREDSUM_VS_M1_E32 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7309 = PseudoVREDSUM_VS_M1_E16_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7308 = PseudoVREDSUM_VS_M1_E16 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7307 = PseudoVREDOR_VS_MF8_E8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7306 = PseudoVREDOR_VS_MF8_E8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7305 = PseudoVREDOR_VS_MF4_E8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7304 = PseudoVREDOR_VS_MF4_E8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7303 = PseudoVREDOR_VS_MF4_E16_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7302 = PseudoVREDOR_VS_MF4_E16 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7301 = PseudoVREDOR_VS_MF2_E8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7300 = PseudoVREDOR_VS_MF2_E8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7299 = PseudoVREDOR_VS_MF2_E32_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7298 = PseudoVREDOR_VS_MF2_E32 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7297 = PseudoVREDOR_VS_MF2_E16_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7296 = PseudoVREDOR_VS_MF2_E16 + { 8, &RISCVDescs.OperandInfo[2999] }, // Inst #7295 = PseudoVREDOR_VS_M8_E8_MASK + { 7, &RISCVDescs.OperandInfo[2992] }, // Inst #7294 = PseudoVREDOR_VS_M8_E8 + { 8, &RISCVDescs.OperandInfo[2999] }, // Inst #7293 = PseudoVREDOR_VS_M8_E64_MASK + { 7, &RISCVDescs.OperandInfo[2992] }, // Inst #7292 = PseudoVREDOR_VS_M8_E64 + { 8, &RISCVDescs.OperandInfo[2999] }, // Inst #7291 = PseudoVREDOR_VS_M8_E32_MASK + { 7, &RISCVDescs.OperandInfo[2992] }, // Inst #7290 = PseudoVREDOR_VS_M8_E32 + { 8, &RISCVDescs.OperandInfo[2999] }, // Inst #7289 = PseudoVREDOR_VS_M8_E16_MASK + { 7, &RISCVDescs.OperandInfo[2992] }, // Inst #7288 = PseudoVREDOR_VS_M8_E16 + { 8, &RISCVDescs.OperandInfo[2984] }, // Inst #7287 = PseudoVREDOR_VS_M4_E8_MASK + { 7, &RISCVDescs.OperandInfo[2977] }, // Inst #7286 = PseudoVREDOR_VS_M4_E8 + { 8, &RISCVDescs.OperandInfo[2984] }, // Inst #7285 = PseudoVREDOR_VS_M4_E64_MASK + { 7, &RISCVDescs.OperandInfo[2977] }, // Inst #7284 = PseudoVREDOR_VS_M4_E64 + { 8, &RISCVDescs.OperandInfo[2984] }, // Inst #7283 = PseudoVREDOR_VS_M4_E32_MASK + { 7, &RISCVDescs.OperandInfo[2977] }, // Inst #7282 = PseudoVREDOR_VS_M4_E32 + { 8, &RISCVDescs.OperandInfo[2984] }, // Inst #7281 = PseudoVREDOR_VS_M4_E16_MASK + { 7, &RISCVDescs.OperandInfo[2977] }, // Inst #7280 = PseudoVREDOR_VS_M4_E16 + { 8, &RISCVDescs.OperandInfo[2969] }, // Inst #7279 = PseudoVREDOR_VS_M2_E8_MASK + { 7, &RISCVDescs.OperandInfo[2962] }, // Inst #7278 = PseudoVREDOR_VS_M2_E8 + { 8, &RISCVDescs.OperandInfo[2969] }, // Inst #7277 = PseudoVREDOR_VS_M2_E64_MASK + { 7, &RISCVDescs.OperandInfo[2962] }, // Inst #7276 = PseudoVREDOR_VS_M2_E64 + { 8, &RISCVDescs.OperandInfo[2969] }, // Inst #7275 = PseudoVREDOR_VS_M2_E32_MASK + { 7, &RISCVDescs.OperandInfo[2962] }, // Inst #7274 = PseudoVREDOR_VS_M2_E32 + { 8, &RISCVDescs.OperandInfo[2969] }, // Inst #7273 = PseudoVREDOR_VS_M2_E16_MASK + { 7, &RISCVDescs.OperandInfo[2962] }, // Inst #7272 = PseudoVREDOR_VS_M2_E16 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7271 = PseudoVREDOR_VS_M1_E8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7270 = PseudoVREDOR_VS_M1_E8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7269 = PseudoVREDOR_VS_M1_E64_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7268 = PseudoVREDOR_VS_M1_E64 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7267 = PseudoVREDOR_VS_M1_E32_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7266 = PseudoVREDOR_VS_M1_E32 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7265 = PseudoVREDOR_VS_M1_E16_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7264 = PseudoVREDOR_VS_M1_E16 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7263 = PseudoVREDMIN_VS_MF8_E8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7262 = PseudoVREDMIN_VS_MF8_E8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7261 = PseudoVREDMIN_VS_MF4_E8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7260 = PseudoVREDMIN_VS_MF4_E8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7259 = PseudoVREDMIN_VS_MF4_E16_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7258 = PseudoVREDMIN_VS_MF4_E16 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7257 = PseudoVREDMIN_VS_MF2_E8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7256 = PseudoVREDMIN_VS_MF2_E8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7255 = PseudoVREDMIN_VS_MF2_E32_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7254 = PseudoVREDMIN_VS_MF2_E32 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7253 = PseudoVREDMIN_VS_MF2_E16_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7252 = PseudoVREDMIN_VS_MF2_E16 + { 8, &RISCVDescs.OperandInfo[2999] }, // Inst #7251 = PseudoVREDMIN_VS_M8_E8_MASK + { 7, &RISCVDescs.OperandInfo[2992] }, // Inst #7250 = PseudoVREDMIN_VS_M8_E8 + { 8, &RISCVDescs.OperandInfo[2999] }, // Inst #7249 = PseudoVREDMIN_VS_M8_E64_MASK + { 7, &RISCVDescs.OperandInfo[2992] }, // Inst #7248 = PseudoVREDMIN_VS_M8_E64 + { 8, &RISCVDescs.OperandInfo[2999] }, // Inst #7247 = PseudoVREDMIN_VS_M8_E32_MASK + { 7, &RISCVDescs.OperandInfo[2992] }, // Inst #7246 = PseudoVREDMIN_VS_M8_E32 + { 8, &RISCVDescs.OperandInfo[2999] }, // Inst #7245 = PseudoVREDMIN_VS_M8_E16_MASK + { 7, &RISCVDescs.OperandInfo[2992] }, // Inst #7244 = PseudoVREDMIN_VS_M8_E16 + { 8, &RISCVDescs.OperandInfo[2984] }, // Inst #7243 = PseudoVREDMIN_VS_M4_E8_MASK + { 7, &RISCVDescs.OperandInfo[2977] }, // Inst #7242 = PseudoVREDMIN_VS_M4_E8 + { 8, &RISCVDescs.OperandInfo[2984] }, // Inst #7241 = PseudoVREDMIN_VS_M4_E64_MASK + { 7, &RISCVDescs.OperandInfo[2977] }, // Inst #7240 = PseudoVREDMIN_VS_M4_E64 + { 8, &RISCVDescs.OperandInfo[2984] }, // Inst #7239 = PseudoVREDMIN_VS_M4_E32_MASK + { 7, &RISCVDescs.OperandInfo[2977] }, // Inst #7238 = PseudoVREDMIN_VS_M4_E32 + { 8, &RISCVDescs.OperandInfo[2984] }, // Inst #7237 = PseudoVREDMIN_VS_M4_E16_MASK + { 7, &RISCVDescs.OperandInfo[2977] }, // Inst #7236 = PseudoVREDMIN_VS_M4_E16 + { 8, &RISCVDescs.OperandInfo[2969] }, // Inst #7235 = PseudoVREDMIN_VS_M2_E8_MASK + { 7, &RISCVDescs.OperandInfo[2962] }, // Inst #7234 = PseudoVREDMIN_VS_M2_E8 + { 8, &RISCVDescs.OperandInfo[2969] }, // Inst #7233 = PseudoVREDMIN_VS_M2_E64_MASK + { 7, &RISCVDescs.OperandInfo[2962] }, // Inst #7232 = PseudoVREDMIN_VS_M2_E64 + { 8, &RISCVDescs.OperandInfo[2969] }, // Inst #7231 = PseudoVREDMIN_VS_M2_E32_MASK + { 7, &RISCVDescs.OperandInfo[2962] }, // Inst #7230 = PseudoVREDMIN_VS_M2_E32 + { 8, &RISCVDescs.OperandInfo[2969] }, // Inst #7229 = PseudoVREDMIN_VS_M2_E16_MASK + { 7, &RISCVDescs.OperandInfo[2962] }, // Inst #7228 = PseudoVREDMIN_VS_M2_E16 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7227 = PseudoVREDMIN_VS_M1_E8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7226 = PseudoVREDMIN_VS_M1_E8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7225 = PseudoVREDMIN_VS_M1_E64_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7224 = PseudoVREDMIN_VS_M1_E64 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7223 = PseudoVREDMIN_VS_M1_E32_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7222 = PseudoVREDMIN_VS_M1_E32 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7221 = PseudoVREDMIN_VS_M1_E16_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7220 = PseudoVREDMIN_VS_M1_E16 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7219 = PseudoVREDMINU_VS_MF8_E8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7218 = PseudoVREDMINU_VS_MF8_E8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7217 = PseudoVREDMINU_VS_MF4_E8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7216 = PseudoVREDMINU_VS_MF4_E8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7215 = PseudoVREDMINU_VS_MF4_E16_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7214 = PseudoVREDMINU_VS_MF4_E16 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7213 = PseudoVREDMINU_VS_MF2_E8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7212 = PseudoVREDMINU_VS_MF2_E8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7211 = PseudoVREDMINU_VS_MF2_E32_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7210 = PseudoVREDMINU_VS_MF2_E32 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7209 = PseudoVREDMINU_VS_MF2_E16_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7208 = PseudoVREDMINU_VS_MF2_E16 + { 8, &RISCVDescs.OperandInfo[2999] }, // Inst #7207 = PseudoVREDMINU_VS_M8_E8_MASK + { 7, &RISCVDescs.OperandInfo[2992] }, // Inst #7206 = PseudoVREDMINU_VS_M8_E8 + { 8, &RISCVDescs.OperandInfo[2999] }, // Inst #7205 = PseudoVREDMINU_VS_M8_E64_MASK + { 7, &RISCVDescs.OperandInfo[2992] }, // Inst #7204 = PseudoVREDMINU_VS_M8_E64 + { 8, &RISCVDescs.OperandInfo[2999] }, // Inst #7203 = PseudoVREDMINU_VS_M8_E32_MASK + { 7, &RISCVDescs.OperandInfo[2992] }, // Inst #7202 = PseudoVREDMINU_VS_M8_E32 + { 8, &RISCVDescs.OperandInfo[2999] }, // Inst #7201 = PseudoVREDMINU_VS_M8_E16_MASK + { 7, &RISCVDescs.OperandInfo[2992] }, // Inst #7200 = PseudoVREDMINU_VS_M8_E16 + { 8, &RISCVDescs.OperandInfo[2984] }, // Inst #7199 = PseudoVREDMINU_VS_M4_E8_MASK + { 7, &RISCVDescs.OperandInfo[2977] }, // Inst #7198 = PseudoVREDMINU_VS_M4_E8 + { 8, &RISCVDescs.OperandInfo[2984] }, // Inst #7197 = PseudoVREDMINU_VS_M4_E64_MASK + { 7, &RISCVDescs.OperandInfo[2977] }, // Inst #7196 = PseudoVREDMINU_VS_M4_E64 + { 8, &RISCVDescs.OperandInfo[2984] }, // Inst #7195 = PseudoVREDMINU_VS_M4_E32_MASK + { 7, &RISCVDescs.OperandInfo[2977] }, // Inst #7194 = PseudoVREDMINU_VS_M4_E32 + { 8, &RISCVDescs.OperandInfo[2984] }, // Inst #7193 = PseudoVREDMINU_VS_M4_E16_MASK + { 7, &RISCVDescs.OperandInfo[2977] }, // Inst #7192 = PseudoVREDMINU_VS_M4_E16 + { 8, &RISCVDescs.OperandInfo[2969] }, // Inst #7191 = PseudoVREDMINU_VS_M2_E8_MASK + { 7, &RISCVDescs.OperandInfo[2962] }, // Inst #7190 = PseudoVREDMINU_VS_M2_E8 + { 8, &RISCVDescs.OperandInfo[2969] }, // Inst #7189 = PseudoVREDMINU_VS_M2_E64_MASK + { 7, &RISCVDescs.OperandInfo[2962] }, // Inst #7188 = PseudoVREDMINU_VS_M2_E64 + { 8, &RISCVDescs.OperandInfo[2969] }, // Inst #7187 = PseudoVREDMINU_VS_M2_E32_MASK + { 7, &RISCVDescs.OperandInfo[2962] }, // Inst #7186 = PseudoVREDMINU_VS_M2_E32 + { 8, &RISCVDescs.OperandInfo[2969] }, // Inst #7185 = PseudoVREDMINU_VS_M2_E16_MASK + { 7, &RISCVDescs.OperandInfo[2962] }, // Inst #7184 = PseudoVREDMINU_VS_M2_E16 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7183 = PseudoVREDMINU_VS_M1_E8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7182 = PseudoVREDMINU_VS_M1_E8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7181 = PseudoVREDMINU_VS_M1_E64_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7180 = PseudoVREDMINU_VS_M1_E64 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7179 = PseudoVREDMINU_VS_M1_E32_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7178 = PseudoVREDMINU_VS_M1_E32 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7177 = PseudoVREDMINU_VS_M1_E16_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7176 = PseudoVREDMINU_VS_M1_E16 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7175 = PseudoVREDMAX_VS_MF8_E8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7174 = PseudoVREDMAX_VS_MF8_E8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7173 = PseudoVREDMAX_VS_MF4_E8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7172 = PseudoVREDMAX_VS_MF4_E8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7171 = PseudoVREDMAX_VS_MF4_E16_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7170 = PseudoVREDMAX_VS_MF4_E16 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7169 = PseudoVREDMAX_VS_MF2_E8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7168 = PseudoVREDMAX_VS_MF2_E8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7167 = PseudoVREDMAX_VS_MF2_E32_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7166 = PseudoVREDMAX_VS_MF2_E32 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7165 = PseudoVREDMAX_VS_MF2_E16_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7164 = PseudoVREDMAX_VS_MF2_E16 + { 8, &RISCVDescs.OperandInfo[2999] }, // Inst #7163 = PseudoVREDMAX_VS_M8_E8_MASK + { 7, &RISCVDescs.OperandInfo[2992] }, // Inst #7162 = PseudoVREDMAX_VS_M8_E8 + { 8, &RISCVDescs.OperandInfo[2999] }, // Inst #7161 = PseudoVREDMAX_VS_M8_E64_MASK + { 7, &RISCVDescs.OperandInfo[2992] }, // Inst #7160 = PseudoVREDMAX_VS_M8_E64 + { 8, &RISCVDescs.OperandInfo[2999] }, // Inst #7159 = PseudoVREDMAX_VS_M8_E32_MASK + { 7, &RISCVDescs.OperandInfo[2992] }, // Inst #7158 = PseudoVREDMAX_VS_M8_E32 + { 8, &RISCVDescs.OperandInfo[2999] }, // Inst #7157 = PseudoVREDMAX_VS_M8_E16_MASK + { 7, &RISCVDescs.OperandInfo[2992] }, // Inst #7156 = PseudoVREDMAX_VS_M8_E16 + { 8, &RISCVDescs.OperandInfo[2984] }, // Inst #7155 = PseudoVREDMAX_VS_M4_E8_MASK + { 7, &RISCVDescs.OperandInfo[2977] }, // Inst #7154 = PseudoVREDMAX_VS_M4_E8 + { 8, &RISCVDescs.OperandInfo[2984] }, // Inst #7153 = PseudoVREDMAX_VS_M4_E64_MASK + { 7, &RISCVDescs.OperandInfo[2977] }, // Inst #7152 = PseudoVREDMAX_VS_M4_E64 + { 8, &RISCVDescs.OperandInfo[2984] }, // Inst #7151 = PseudoVREDMAX_VS_M4_E32_MASK + { 7, &RISCVDescs.OperandInfo[2977] }, // Inst #7150 = PseudoVREDMAX_VS_M4_E32 + { 8, &RISCVDescs.OperandInfo[2984] }, // Inst #7149 = PseudoVREDMAX_VS_M4_E16_MASK + { 7, &RISCVDescs.OperandInfo[2977] }, // Inst #7148 = PseudoVREDMAX_VS_M4_E16 + { 8, &RISCVDescs.OperandInfo[2969] }, // Inst #7147 = PseudoVREDMAX_VS_M2_E8_MASK + { 7, &RISCVDescs.OperandInfo[2962] }, // Inst #7146 = PseudoVREDMAX_VS_M2_E8 + { 8, &RISCVDescs.OperandInfo[2969] }, // Inst #7145 = PseudoVREDMAX_VS_M2_E64_MASK + { 7, &RISCVDescs.OperandInfo[2962] }, // Inst #7144 = PseudoVREDMAX_VS_M2_E64 + { 8, &RISCVDescs.OperandInfo[2969] }, // Inst #7143 = PseudoVREDMAX_VS_M2_E32_MASK + { 7, &RISCVDescs.OperandInfo[2962] }, // Inst #7142 = PseudoVREDMAX_VS_M2_E32 + { 8, &RISCVDescs.OperandInfo[2969] }, // Inst #7141 = PseudoVREDMAX_VS_M2_E16_MASK + { 7, &RISCVDescs.OperandInfo[2962] }, // Inst #7140 = PseudoVREDMAX_VS_M2_E16 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7139 = PseudoVREDMAX_VS_M1_E8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7138 = PseudoVREDMAX_VS_M1_E8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7137 = PseudoVREDMAX_VS_M1_E64_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7136 = PseudoVREDMAX_VS_M1_E64 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7135 = PseudoVREDMAX_VS_M1_E32_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7134 = PseudoVREDMAX_VS_M1_E32 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7133 = PseudoVREDMAX_VS_M1_E16_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7132 = PseudoVREDMAX_VS_M1_E16 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7131 = PseudoVREDMAXU_VS_MF8_E8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7130 = PseudoVREDMAXU_VS_MF8_E8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7129 = PseudoVREDMAXU_VS_MF4_E8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7128 = PseudoVREDMAXU_VS_MF4_E8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7127 = PseudoVREDMAXU_VS_MF4_E16_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7126 = PseudoVREDMAXU_VS_MF4_E16 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7125 = PseudoVREDMAXU_VS_MF2_E8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7124 = PseudoVREDMAXU_VS_MF2_E8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7123 = PseudoVREDMAXU_VS_MF2_E32_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7122 = PseudoVREDMAXU_VS_MF2_E32 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7121 = PseudoVREDMAXU_VS_MF2_E16_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7120 = PseudoVREDMAXU_VS_MF2_E16 + { 8, &RISCVDescs.OperandInfo[2999] }, // Inst #7119 = PseudoVREDMAXU_VS_M8_E8_MASK + { 7, &RISCVDescs.OperandInfo[2992] }, // Inst #7118 = PseudoVREDMAXU_VS_M8_E8 + { 8, &RISCVDescs.OperandInfo[2999] }, // Inst #7117 = PseudoVREDMAXU_VS_M8_E64_MASK + { 7, &RISCVDescs.OperandInfo[2992] }, // Inst #7116 = PseudoVREDMAXU_VS_M8_E64 + { 8, &RISCVDescs.OperandInfo[2999] }, // Inst #7115 = PseudoVREDMAXU_VS_M8_E32_MASK + { 7, &RISCVDescs.OperandInfo[2992] }, // Inst #7114 = PseudoVREDMAXU_VS_M8_E32 + { 8, &RISCVDescs.OperandInfo[2999] }, // Inst #7113 = PseudoVREDMAXU_VS_M8_E16_MASK + { 7, &RISCVDescs.OperandInfo[2992] }, // Inst #7112 = PseudoVREDMAXU_VS_M8_E16 + { 8, &RISCVDescs.OperandInfo[2984] }, // Inst #7111 = PseudoVREDMAXU_VS_M4_E8_MASK + { 7, &RISCVDescs.OperandInfo[2977] }, // Inst #7110 = PseudoVREDMAXU_VS_M4_E8 + { 8, &RISCVDescs.OperandInfo[2984] }, // Inst #7109 = PseudoVREDMAXU_VS_M4_E64_MASK + { 7, &RISCVDescs.OperandInfo[2977] }, // Inst #7108 = PseudoVREDMAXU_VS_M4_E64 + { 8, &RISCVDescs.OperandInfo[2984] }, // Inst #7107 = PseudoVREDMAXU_VS_M4_E32_MASK + { 7, &RISCVDescs.OperandInfo[2977] }, // Inst #7106 = PseudoVREDMAXU_VS_M4_E32 + { 8, &RISCVDescs.OperandInfo[2984] }, // Inst #7105 = PseudoVREDMAXU_VS_M4_E16_MASK + { 7, &RISCVDescs.OperandInfo[2977] }, // Inst #7104 = PseudoVREDMAXU_VS_M4_E16 + { 8, &RISCVDescs.OperandInfo[2969] }, // Inst #7103 = PseudoVREDMAXU_VS_M2_E8_MASK + { 7, &RISCVDescs.OperandInfo[2962] }, // Inst #7102 = PseudoVREDMAXU_VS_M2_E8 + { 8, &RISCVDescs.OperandInfo[2969] }, // Inst #7101 = PseudoVREDMAXU_VS_M2_E64_MASK + { 7, &RISCVDescs.OperandInfo[2962] }, // Inst #7100 = PseudoVREDMAXU_VS_M2_E64 + { 8, &RISCVDescs.OperandInfo[2969] }, // Inst #7099 = PseudoVREDMAXU_VS_M2_E32_MASK + { 7, &RISCVDescs.OperandInfo[2962] }, // Inst #7098 = PseudoVREDMAXU_VS_M2_E32 + { 8, &RISCVDescs.OperandInfo[2969] }, // Inst #7097 = PseudoVREDMAXU_VS_M2_E16_MASK + { 7, &RISCVDescs.OperandInfo[2962] }, // Inst #7096 = PseudoVREDMAXU_VS_M2_E16 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7095 = PseudoVREDMAXU_VS_M1_E8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7094 = PseudoVREDMAXU_VS_M1_E8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7093 = PseudoVREDMAXU_VS_M1_E64_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7092 = PseudoVREDMAXU_VS_M1_E64 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7091 = PseudoVREDMAXU_VS_M1_E32_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7090 = PseudoVREDMAXU_VS_M1_E32 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7089 = PseudoVREDMAXU_VS_M1_E16_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7088 = PseudoVREDMAXU_VS_M1_E16 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7087 = PseudoVREDAND_VS_MF8_E8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7086 = PseudoVREDAND_VS_MF8_E8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7085 = PseudoVREDAND_VS_MF4_E8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7084 = PseudoVREDAND_VS_MF4_E8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7083 = PseudoVREDAND_VS_MF4_E16_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7082 = PseudoVREDAND_VS_MF4_E16 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7081 = PseudoVREDAND_VS_MF2_E8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7080 = PseudoVREDAND_VS_MF2_E8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7079 = PseudoVREDAND_VS_MF2_E32_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7078 = PseudoVREDAND_VS_MF2_E32 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7077 = PseudoVREDAND_VS_MF2_E16_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7076 = PseudoVREDAND_VS_MF2_E16 + { 8, &RISCVDescs.OperandInfo[2999] }, // Inst #7075 = PseudoVREDAND_VS_M8_E8_MASK + { 7, &RISCVDescs.OperandInfo[2992] }, // Inst #7074 = PseudoVREDAND_VS_M8_E8 + { 8, &RISCVDescs.OperandInfo[2999] }, // Inst #7073 = PseudoVREDAND_VS_M8_E64_MASK + { 7, &RISCVDescs.OperandInfo[2992] }, // Inst #7072 = PseudoVREDAND_VS_M8_E64 + { 8, &RISCVDescs.OperandInfo[2999] }, // Inst #7071 = PseudoVREDAND_VS_M8_E32_MASK + { 7, &RISCVDescs.OperandInfo[2992] }, // Inst #7070 = PseudoVREDAND_VS_M8_E32 + { 8, &RISCVDescs.OperandInfo[2999] }, // Inst #7069 = PseudoVREDAND_VS_M8_E16_MASK + { 7, &RISCVDescs.OperandInfo[2992] }, // Inst #7068 = PseudoVREDAND_VS_M8_E16 + { 8, &RISCVDescs.OperandInfo[2984] }, // Inst #7067 = PseudoVREDAND_VS_M4_E8_MASK + { 7, &RISCVDescs.OperandInfo[2977] }, // Inst #7066 = PseudoVREDAND_VS_M4_E8 + { 8, &RISCVDescs.OperandInfo[2984] }, // Inst #7065 = PseudoVREDAND_VS_M4_E64_MASK + { 7, &RISCVDescs.OperandInfo[2977] }, // Inst #7064 = PseudoVREDAND_VS_M4_E64 + { 8, &RISCVDescs.OperandInfo[2984] }, // Inst #7063 = PseudoVREDAND_VS_M4_E32_MASK + { 7, &RISCVDescs.OperandInfo[2977] }, // Inst #7062 = PseudoVREDAND_VS_M4_E32 + { 8, &RISCVDescs.OperandInfo[2984] }, // Inst #7061 = PseudoVREDAND_VS_M4_E16_MASK + { 7, &RISCVDescs.OperandInfo[2977] }, // Inst #7060 = PseudoVREDAND_VS_M4_E16 + { 8, &RISCVDescs.OperandInfo[2969] }, // Inst #7059 = PseudoVREDAND_VS_M2_E8_MASK + { 7, &RISCVDescs.OperandInfo[2962] }, // Inst #7058 = PseudoVREDAND_VS_M2_E8 + { 8, &RISCVDescs.OperandInfo[2969] }, // Inst #7057 = PseudoVREDAND_VS_M2_E64_MASK + { 7, &RISCVDescs.OperandInfo[2962] }, // Inst #7056 = PseudoVREDAND_VS_M2_E64 + { 8, &RISCVDescs.OperandInfo[2969] }, // Inst #7055 = PseudoVREDAND_VS_M2_E32_MASK + { 7, &RISCVDescs.OperandInfo[2962] }, // Inst #7054 = PseudoVREDAND_VS_M2_E32 + { 8, &RISCVDescs.OperandInfo[2969] }, // Inst #7053 = PseudoVREDAND_VS_M2_E16_MASK + { 7, &RISCVDescs.OperandInfo[2962] }, // Inst #7052 = PseudoVREDAND_VS_M2_E16 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7051 = PseudoVREDAND_VS_M1_E8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7050 = PseudoVREDAND_VS_M1_E8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7049 = PseudoVREDAND_VS_M1_E64_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7048 = PseudoVREDAND_VS_M1_E64 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7047 = PseudoVREDAND_VS_M1_E32_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7046 = PseudoVREDAND_VS_M1_E32 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #7045 = PseudoVREDAND_VS_M1_E16_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7044 = PseudoVREDAND_VS_M1_E16 + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7043 = PseudoVQMACC_4x8x4_MF2 + { 7, &RISCVDescs.OperandInfo[3642] }, // Inst #7042 = PseudoVQMACC_4x8x4_M4 + { 7, &RISCVDescs.OperandInfo[3635] }, // Inst #7041 = PseudoVQMACC_4x8x4_M2 + { 7, &RISCVDescs.OperandInfo[3628] }, // Inst #7040 = PseudoVQMACC_4x8x4_M1 + { 7, &RISCVDescs.OperandInfo[6191] }, // Inst #7039 = PseudoVQMACC_2x8x2_M8 + { 7, &RISCVDescs.OperandInfo[6184] }, // Inst #7038 = PseudoVQMACC_2x8x2_M4 + { 7, &RISCVDescs.OperandInfo[6177] }, // Inst #7037 = PseudoVQMACC_2x8x2_M2 + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7036 = PseudoVQMACC_2x8x2_M1 + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7035 = PseudoVQMACCU_4x8x4_MF2 + { 7, &RISCVDescs.OperandInfo[3642] }, // Inst #7034 = PseudoVQMACCU_4x8x4_M4 + { 7, &RISCVDescs.OperandInfo[3635] }, // Inst #7033 = PseudoVQMACCU_4x8x4_M2 + { 7, &RISCVDescs.OperandInfo[3628] }, // Inst #7032 = PseudoVQMACCU_4x8x4_M1 + { 7, &RISCVDescs.OperandInfo[6191] }, // Inst #7031 = PseudoVQMACCU_2x8x2_M8 + { 7, &RISCVDescs.OperandInfo[6184] }, // Inst #7030 = PseudoVQMACCU_2x8x2_M4 + { 7, &RISCVDescs.OperandInfo[6177] }, // Inst #7029 = PseudoVQMACCU_2x8x2_M2 + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7028 = PseudoVQMACCU_2x8x2_M1 + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7027 = PseudoVQMACCUS_4x8x4_MF2 + { 7, &RISCVDescs.OperandInfo[3642] }, // Inst #7026 = PseudoVQMACCUS_4x8x4_M4 + { 7, &RISCVDescs.OperandInfo[3635] }, // Inst #7025 = PseudoVQMACCUS_4x8x4_M2 + { 7, &RISCVDescs.OperandInfo[3628] }, // Inst #7024 = PseudoVQMACCUS_4x8x4_M1 + { 7, &RISCVDescs.OperandInfo[6191] }, // Inst #7023 = PseudoVQMACCUS_2x8x2_M8 + { 7, &RISCVDescs.OperandInfo[6184] }, // Inst #7022 = PseudoVQMACCUS_2x8x2_M4 + { 7, &RISCVDescs.OperandInfo[6177] }, // Inst #7021 = PseudoVQMACCUS_2x8x2_M2 + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7020 = PseudoVQMACCUS_2x8x2_M1 + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7019 = PseudoVQMACCSU_4x8x4_MF2 + { 7, &RISCVDescs.OperandInfo[3642] }, // Inst #7018 = PseudoVQMACCSU_4x8x4_M4 + { 7, &RISCVDescs.OperandInfo[3635] }, // Inst #7017 = PseudoVQMACCSU_4x8x4_M2 + { 7, &RISCVDescs.OperandInfo[3628] }, // Inst #7016 = PseudoVQMACCSU_4x8x4_M1 + { 7, &RISCVDescs.OperandInfo[6191] }, // Inst #7015 = PseudoVQMACCSU_2x8x2_M8 + { 7, &RISCVDescs.OperandInfo[6184] }, // Inst #7014 = PseudoVQMACCSU_2x8x2_M4 + { 7, &RISCVDescs.OperandInfo[6177] }, // Inst #7013 = PseudoVQMACCSU_2x8x2_M2 + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #7012 = PseudoVQMACCSU_2x8x2_M1 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #7011 = PseudoVOR_VX_MF8_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #7010 = PseudoVOR_VX_MF8 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #7009 = PseudoVOR_VX_MF4_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #7008 = PseudoVOR_VX_MF4 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #7007 = PseudoVOR_VX_MF2_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #7006 = PseudoVOR_VX_MF2 + { 8, &RISCVDescs.OperandInfo[809] }, // Inst #7005 = PseudoVOR_VX_M8_MASK + { 7, &RISCVDescs.OperandInfo[802] }, // Inst #7004 = PseudoVOR_VX_M8 + { 8, &RISCVDescs.OperandInfo[794] }, // Inst #7003 = PseudoVOR_VX_M4_MASK + { 7, &RISCVDescs.OperandInfo[787] }, // Inst #7002 = PseudoVOR_VX_M4 + { 8, &RISCVDescs.OperandInfo[779] }, // Inst #7001 = PseudoVOR_VX_M2_MASK + { 7, &RISCVDescs.OperandInfo[772] }, // Inst #7000 = PseudoVOR_VX_M2 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #6999 = PseudoVOR_VX_M1_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #6998 = PseudoVOR_VX_M1 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #6997 = PseudoVOR_VV_MF8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #6996 = PseudoVOR_VV_MF8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #6995 = PseudoVOR_VV_MF4_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #6994 = PseudoVOR_VV_MF4 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #6993 = PseudoVOR_VV_MF2_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #6992 = PseudoVOR_VV_MF2 + { 8, &RISCVDescs.OperandInfo[749] }, // Inst #6991 = PseudoVOR_VV_M8_MASK + { 7, &RISCVDescs.OperandInfo[742] }, // Inst #6990 = PseudoVOR_VV_M8 + { 8, &RISCVDescs.OperandInfo[734] }, // Inst #6989 = PseudoVOR_VV_M4_MASK + { 7, &RISCVDescs.OperandInfo[727] }, // Inst #6988 = PseudoVOR_VV_M4 + { 8, &RISCVDescs.OperandInfo[719] }, // Inst #6987 = PseudoVOR_VV_M2_MASK + { 7, &RISCVDescs.OperandInfo[712] }, // Inst #6986 = PseudoVOR_VV_M2 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #6985 = PseudoVOR_VV_M1_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #6984 = PseudoVOR_VV_M1 + { 8, &RISCVDescs.OperandInfo[644] }, // Inst #6983 = PseudoVOR_VI_MF8_MASK + { 7, &RISCVDescs.OperandInfo[637] }, // Inst #6982 = PseudoVOR_VI_MF8 + { 8, &RISCVDescs.OperandInfo[644] }, // Inst #6981 = PseudoVOR_VI_MF4_MASK + { 7, &RISCVDescs.OperandInfo[637] }, // Inst #6980 = PseudoVOR_VI_MF4 + { 8, &RISCVDescs.OperandInfo[644] }, // Inst #6979 = PseudoVOR_VI_MF2_MASK + { 7, &RISCVDescs.OperandInfo[637] }, // Inst #6978 = PseudoVOR_VI_MF2 + { 8, &RISCVDescs.OperandInfo[689] }, // Inst #6977 = PseudoVOR_VI_M8_MASK + { 7, &RISCVDescs.OperandInfo[682] }, // Inst #6976 = PseudoVOR_VI_M8 + { 8, &RISCVDescs.OperandInfo[674] }, // Inst #6975 = PseudoVOR_VI_M4_MASK + { 7, &RISCVDescs.OperandInfo[667] }, // Inst #6974 = PseudoVOR_VI_M4 + { 8, &RISCVDescs.OperandInfo[659] }, // Inst #6973 = PseudoVOR_VI_M2_MASK + { 7, &RISCVDescs.OperandInfo[652] }, // Inst #6972 = PseudoVOR_VI_M2 + { 8, &RISCVDescs.OperandInfo[644] }, // Inst #6971 = PseudoVOR_VI_M1_MASK + { 7, &RISCVDescs.OperandInfo[637] }, // Inst #6970 = PseudoVOR_VI_M1 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #6969 = PseudoVNSRL_WX_MF8_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #6968 = PseudoVNSRL_WX_MF8 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #6967 = PseudoVNSRL_WX_MF4_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #6966 = PseudoVNSRL_WX_MF4 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #6965 = PseudoVNSRL_WX_MF2_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #6964 = PseudoVNSRL_WX_MF2 + { 8, &RISCVDescs.OperandInfo[6169] }, // Inst #6963 = PseudoVNSRL_WX_M4_MASK + { 7, &RISCVDescs.OperandInfo[6162] }, // Inst #6962 = PseudoVNSRL_WX_M4 + { 8, &RISCVDescs.OperandInfo[6154] }, // Inst #6961 = PseudoVNSRL_WX_M2_MASK + { 7, &RISCVDescs.OperandInfo[6147] }, // Inst #6960 = PseudoVNSRL_WX_M2 + { 8, &RISCVDescs.OperandInfo[6139] }, // Inst #6959 = PseudoVNSRL_WX_M1_MASK + { 7, &RISCVDescs.OperandInfo[6132] }, // Inst #6958 = PseudoVNSRL_WX_M1 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #6957 = PseudoVNSRL_WV_MF8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #6956 = PseudoVNSRL_WV_MF8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #6955 = PseudoVNSRL_WV_MF4_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #6954 = PseudoVNSRL_WV_MF4 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #6953 = PseudoVNSRL_WV_MF2_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #6952 = PseudoVNSRL_WV_MF2 + { 8, &RISCVDescs.OperandInfo[6124] }, // Inst #6951 = PseudoVNSRL_WV_M4_MASK + { 7, &RISCVDescs.OperandInfo[6117] }, // Inst #6950 = PseudoVNSRL_WV_M4 + { 8, &RISCVDescs.OperandInfo[6109] }, // Inst #6949 = PseudoVNSRL_WV_M2_MASK + { 7, &RISCVDescs.OperandInfo[6102] }, // Inst #6948 = PseudoVNSRL_WV_M2 + { 8, &RISCVDescs.OperandInfo[6094] }, // Inst #6947 = PseudoVNSRL_WV_M1_MASK + { 7, &RISCVDescs.OperandInfo[6087] }, // Inst #6946 = PseudoVNSRL_WV_M1 + { 8, &RISCVDescs.OperandInfo[6079] }, // Inst #6945 = PseudoVNSRL_WI_MF8_MASK + { 7, &RISCVDescs.OperandInfo[877] }, // Inst #6944 = PseudoVNSRL_WI_MF8 + { 8, &RISCVDescs.OperandInfo[6079] }, // Inst #6943 = PseudoVNSRL_WI_MF4_MASK + { 7, &RISCVDescs.OperandInfo[877] }, // Inst #6942 = PseudoVNSRL_WI_MF4 + { 8, &RISCVDescs.OperandInfo[6079] }, // Inst #6941 = PseudoVNSRL_WI_MF2_MASK + { 7, &RISCVDescs.OperandInfo[877] }, // Inst #6940 = PseudoVNSRL_WI_MF2 + { 8, &RISCVDescs.OperandInfo[6071] }, // Inst #6939 = PseudoVNSRL_WI_M4_MASK + { 7, &RISCVDescs.OperandInfo[6064] }, // Inst #6938 = PseudoVNSRL_WI_M4 + { 8, &RISCVDescs.OperandInfo[6056] }, // Inst #6937 = PseudoVNSRL_WI_M2_MASK + { 7, &RISCVDescs.OperandInfo[6049] }, // Inst #6936 = PseudoVNSRL_WI_M2 + { 8, &RISCVDescs.OperandInfo[6041] }, // Inst #6935 = PseudoVNSRL_WI_M1_MASK + { 7, &RISCVDescs.OperandInfo[6034] }, // Inst #6934 = PseudoVNSRL_WI_M1 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #6933 = PseudoVNSRA_WX_MF8_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #6932 = PseudoVNSRA_WX_MF8 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #6931 = PseudoVNSRA_WX_MF4_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #6930 = PseudoVNSRA_WX_MF4 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #6929 = PseudoVNSRA_WX_MF2_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #6928 = PseudoVNSRA_WX_MF2 + { 8, &RISCVDescs.OperandInfo[6169] }, // Inst #6927 = PseudoVNSRA_WX_M4_MASK + { 7, &RISCVDescs.OperandInfo[6162] }, // Inst #6926 = PseudoVNSRA_WX_M4 + { 8, &RISCVDescs.OperandInfo[6154] }, // Inst #6925 = PseudoVNSRA_WX_M2_MASK + { 7, &RISCVDescs.OperandInfo[6147] }, // Inst #6924 = PseudoVNSRA_WX_M2 + { 8, &RISCVDescs.OperandInfo[6139] }, // Inst #6923 = PseudoVNSRA_WX_M1_MASK + { 7, &RISCVDescs.OperandInfo[6132] }, // Inst #6922 = PseudoVNSRA_WX_M1 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #6921 = PseudoVNSRA_WV_MF8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #6920 = PseudoVNSRA_WV_MF8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #6919 = PseudoVNSRA_WV_MF4_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #6918 = PseudoVNSRA_WV_MF4 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #6917 = PseudoVNSRA_WV_MF2_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #6916 = PseudoVNSRA_WV_MF2 + { 8, &RISCVDescs.OperandInfo[6124] }, // Inst #6915 = PseudoVNSRA_WV_M4_MASK + { 7, &RISCVDescs.OperandInfo[6117] }, // Inst #6914 = PseudoVNSRA_WV_M4 + { 8, &RISCVDescs.OperandInfo[6109] }, // Inst #6913 = PseudoVNSRA_WV_M2_MASK + { 7, &RISCVDescs.OperandInfo[6102] }, // Inst #6912 = PseudoVNSRA_WV_M2 + { 8, &RISCVDescs.OperandInfo[6094] }, // Inst #6911 = PseudoVNSRA_WV_M1_MASK + { 7, &RISCVDescs.OperandInfo[6087] }, // Inst #6910 = PseudoVNSRA_WV_M1 + { 8, &RISCVDescs.OperandInfo[6079] }, // Inst #6909 = PseudoVNSRA_WI_MF8_MASK + { 7, &RISCVDescs.OperandInfo[877] }, // Inst #6908 = PseudoVNSRA_WI_MF8 + { 8, &RISCVDescs.OperandInfo[6079] }, // Inst #6907 = PseudoVNSRA_WI_MF4_MASK + { 7, &RISCVDescs.OperandInfo[877] }, // Inst #6906 = PseudoVNSRA_WI_MF4 + { 8, &RISCVDescs.OperandInfo[6079] }, // Inst #6905 = PseudoVNSRA_WI_MF2_MASK + { 7, &RISCVDescs.OperandInfo[877] }, // Inst #6904 = PseudoVNSRA_WI_MF2 + { 8, &RISCVDescs.OperandInfo[6071] }, // Inst #6903 = PseudoVNSRA_WI_M4_MASK + { 7, &RISCVDescs.OperandInfo[6064] }, // Inst #6902 = PseudoVNSRA_WI_M4 + { 8, &RISCVDescs.OperandInfo[6056] }, // Inst #6901 = PseudoVNSRA_WI_M2_MASK + { 7, &RISCVDescs.OperandInfo[6049] }, // Inst #6900 = PseudoVNSRA_WI_M2 + { 8, &RISCVDescs.OperandInfo[6041] }, // Inst #6899 = PseudoVNSRA_WI_M1_MASK + { 7, &RISCVDescs.OperandInfo[6034] }, // Inst #6898 = PseudoVNSRA_WI_M1 + { 8, &RISCVDescs.OperandInfo[5361] }, // Inst #6897 = PseudoVNMSUB_VX_MF8_MASK + { 7, &RISCVDescs.OperandInfo[5354] }, // Inst #6896 = PseudoVNMSUB_VX_MF8 + { 8, &RISCVDescs.OperandInfo[5361] }, // Inst #6895 = PseudoVNMSUB_VX_MF4_MASK + { 7, &RISCVDescs.OperandInfo[5354] }, // Inst #6894 = PseudoVNMSUB_VX_MF4 + { 8, &RISCVDescs.OperandInfo[5361] }, // Inst #6893 = PseudoVNMSUB_VX_MF2_MASK + { 7, &RISCVDescs.OperandInfo[5354] }, // Inst #6892 = PseudoVNMSUB_VX_MF2 + { 8, &RISCVDescs.OperandInfo[5406] }, // Inst #6891 = PseudoVNMSUB_VX_M8_MASK + { 7, &RISCVDescs.OperandInfo[5399] }, // Inst #6890 = PseudoVNMSUB_VX_M8 + { 8, &RISCVDescs.OperandInfo[5391] }, // Inst #6889 = PseudoVNMSUB_VX_M4_MASK + { 7, &RISCVDescs.OperandInfo[5384] }, // Inst #6888 = PseudoVNMSUB_VX_M4 + { 8, &RISCVDescs.OperandInfo[5376] }, // Inst #6887 = PseudoVNMSUB_VX_M2_MASK + { 7, &RISCVDescs.OperandInfo[5369] }, // Inst #6886 = PseudoVNMSUB_VX_M2 + { 8, &RISCVDescs.OperandInfo[5361] }, // Inst #6885 = PseudoVNMSUB_VX_M1_MASK + { 7, &RISCVDescs.OperandInfo[5354] }, // Inst #6884 = PseudoVNMSUB_VX_M1 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #6883 = PseudoVNMSUB_VV_MF8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #6882 = PseudoVNMSUB_VV_MF8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #6881 = PseudoVNMSUB_VV_MF4_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #6880 = PseudoVNMSUB_VV_MF4 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #6879 = PseudoVNMSUB_VV_MF2_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #6878 = PseudoVNMSUB_VV_MF2 + { 8, &RISCVDescs.OperandInfo[749] }, // Inst #6877 = PseudoVNMSUB_VV_M8_MASK + { 7, &RISCVDescs.OperandInfo[742] }, // Inst #6876 = PseudoVNMSUB_VV_M8 + { 8, &RISCVDescs.OperandInfo[734] }, // Inst #6875 = PseudoVNMSUB_VV_M4_MASK + { 7, &RISCVDescs.OperandInfo[727] }, // Inst #6874 = PseudoVNMSUB_VV_M4 + { 8, &RISCVDescs.OperandInfo[719] }, // Inst #6873 = PseudoVNMSUB_VV_M2_MASK + { 7, &RISCVDescs.OperandInfo[712] }, // Inst #6872 = PseudoVNMSUB_VV_M2 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #6871 = PseudoVNMSUB_VV_M1_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #6870 = PseudoVNMSUB_VV_M1 + { 8, &RISCVDescs.OperandInfo[5361] }, // Inst #6869 = PseudoVNMSAC_VX_MF8_MASK + { 7, &RISCVDescs.OperandInfo[5354] }, // Inst #6868 = PseudoVNMSAC_VX_MF8 + { 8, &RISCVDescs.OperandInfo[5361] }, // Inst #6867 = PseudoVNMSAC_VX_MF4_MASK + { 7, &RISCVDescs.OperandInfo[5354] }, // Inst #6866 = PseudoVNMSAC_VX_MF4 + { 8, &RISCVDescs.OperandInfo[5361] }, // Inst #6865 = PseudoVNMSAC_VX_MF2_MASK + { 7, &RISCVDescs.OperandInfo[5354] }, // Inst #6864 = PseudoVNMSAC_VX_MF2 + { 8, &RISCVDescs.OperandInfo[5406] }, // Inst #6863 = PseudoVNMSAC_VX_M8_MASK + { 7, &RISCVDescs.OperandInfo[5399] }, // Inst #6862 = PseudoVNMSAC_VX_M8 + { 8, &RISCVDescs.OperandInfo[5391] }, // Inst #6861 = PseudoVNMSAC_VX_M4_MASK + { 7, &RISCVDescs.OperandInfo[5384] }, // Inst #6860 = PseudoVNMSAC_VX_M4 + { 8, &RISCVDescs.OperandInfo[5376] }, // Inst #6859 = PseudoVNMSAC_VX_M2_MASK + { 7, &RISCVDescs.OperandInfo[5369] }, // Inst #6858 = PseudoVNMSAC_VX_M2 + { 8, &RISCVDescs.OperandInfo[5361] }, // Inst #6857 = PseudoVNMSAC_VX_M1_MASK + { 7, &RISCVDescs.OperandInfo[5354] }, // Inst #6856 = PseudoVNMSAC_VX_M1 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #6855 = PseudoVNMSAC_VV_MF8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #6854 = PseudoVNMSAC_VV_MF8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #6853 = PseudoVNMSAC_VV_MF4_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #6852 = PseudoVNMSAC_VV_MF4 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #6851 = PseudoVNMSAC_VV_MF2_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #6850 = PseudoVNMSAC_VV_MF2 + { 8, &RISCVDescs.OperandInfo[749] }, // Inst #6849 = PseudoVNMSAC_VV_M8_MASK + { 7, &RISCVDescs.OperandInfo[742] }, // Inst #6848 = PseudoVNMSAC_VV_M8 + { 8, &RISCVDescs.OperandInfo[734] }, // Inst #6847 = PseudoVNMSAC_VV_M4_MASK + { 7, &RISCVDescs.OperandInfo[727] }, // Inst #6846 = PseudoVNMSAC_VV_M4 + { 8, &RISCVDescs.OperandInfo[719] }, // Inst #6845 = PseudoVNMSAC_VV_M2_MASK + { 7, &RISCVDescs.OperandInfo[712] }, // Inst #6844 = PseudoVNMSAC_VV_M2 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #6843 = PseudoVNMSAC_VV_M1_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #6842 = PseudoVNMSAC_VV_M1 + { 9, &RISCVDescs.OperandInfo[493] }, // Inst #6841 = PseudoVNCLIP_WX_MF8_MASK + { 8, &RISCVDescs.OperandInfo[485] }, // Inst #6840 = PseudoVNCLIP_WX_MF8 + { 9, &RISCVDescs.OperandInfo[493] }, // Inst #6839 = PseudoVNCLIP_WX_MF4_MASK + { 8, &RISCVDescs.OperandInfo[485] }, // Inst #6838 = PseudoVNCLIP_WX_MF4 + { 9, &RISCVDescs.OperandInfo[493] }, // Inst #6837 = PseudoVNCLIP_WX_MF2_MASK + { 8, &RISCVDescs.OperandInfo[485] }, // Inst #6836 = PseudoVNCLIP_WX_MF2 + { 9, &RISCVDescs.OperandInfo[6025] }, // Inst #6835 = PseudoVNCLIP_WX_M4_MASK + { 8, &RISCVDescs.OperandInfo[6017] }, // Inst #6834 = PseudoVNCLIP_WX_M4 + { 9, &RISCVDescs.OperandInfo[6008] }, // Inst #6833 = PseudoVNCLIP_WX_M2_MASK + { 8, &RISCVDescs.OperandInfo[6000] }, // Inst #6832 = PseudoVNCLIP_WX_M2 + { 9, &RISCVDescs.OperandInfo[5991] }, // Inst #6831 = PseudoVNCLIP_WX_M1_MASK + { 8, &RISCVDescs.OperandInfo[5983] }, // Inst #6830 = PseudoVNCLIP_WX_M1 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #6829 = PseudoVNCLIP_WV_MF8_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #6828 = PseudoVNCLIP_WV_MF8 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #6827 = PseudoVNCLIP_WV_MF4_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #6826 = PseudoVNCLIP_WV_MF4 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #6825 = PseudoVNCLIP_WV_MF2_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #6824 = PseudoVNCLIP_WV_MF2 + { 9, &RISCVDescs.OperandInfo[5974] }, // Inst #6823 = PseudoVNCLIP_WV_M4_MASK + { 8, &RISCVDescs.OperandInfo[5966] }, // Inst #6822 = PseudoVNCLIP_WV_M4 + { 9, &RISCVDescs.OperandInfo[5957] }, // Inst #6821 = PseudoVNCLIP_WV_M2_MASK + { 8, &RISCVDescs.OperandInfo[5949] }, // Inst #6820 = PseudoVNCLIP_WV_M2 + { 9, &RISCVDescs.OperandInfo[5940] }, // Inst #6819 = PseudoVNCLIP_WV_M1_MASK + { 8, &RISCVDescs.OperandInfo[5932] }, // Inst #6818 = PseudoVNCLIP_WV_M1 + { 9, &RISCVDescs.OperandInfo[5923] }, // Inst #6817 = PseudoVNCLIP_WI_MF8_MASK + { 8, &RISCVDescs.OperandInfo[5915] }, // Inst #6816 = PseudoVNCLIP_WI_MF8 + { 9, &RISCVDescs.OperandInfo[5923] }, // Inst #6815 = PseudoVNCLIP_WI_MF4_MASK + { 8, &RISCVDescs.OperandInfo[5915] }, // Inst #6814 = PseudoVNCLIP_WI_MF4 + { 9, &RISCVDescs.OperandInfo[5923] }, // Inst #6813 = PseudoVNCLIP_WI_MF2_MASK + { 8, &RISCVDescs.OperandInfo[5915] }, // Inst #6812 = PseudoVNCLIP_WI_MF2 + { 9, &RISCVDescs.OperandInfo[5906] }, // Inst #6811 = PseudoVNCLIP_WI_M4_MASK + { 8, &RISCVDescs.OperandInfo[5898] }, // Inst #6810 = PseudoVNCLIP_WI_M4 + { 9, &RISCVDescs.OperandInfo[5889] }, // Inst #6809 = PseudoVNCLIP_WI_M2_MASK + { 8, &RISCVDescs.OperandInfo[5881] }, // Inst #6808 = PseudoVNCLIP_WI_M2 + { 9, &RISCVDescs.OperandInfo[5872] }, // Inst #6807 = PseudoVNCLIP_WI_M1_MASK + { 8, &RISCVDescs.OperandInfo[5864] }, // Inst #6806 = PseudoVNCLIP_WI_M1 + { 9, &RISCVDescs.OperandInfo[493] }, // Inst #6805 = PseudoVNCLIPU_WX_MF8_MASK + { 8, &RISCVDescs.OperandInfo[485] }, // Inst #6804 = PseudoVNCLIPU_WX_MF8 + { 9, &RISCVDescs.OperandInfo[493] }, // Inst #6803 = PseudoVNCLIPU_WX_MF4_MASK + { 8, &RISCVDescs.OperandInfo[485] }, // Inst #6802 = PseudoVNCLIPU_WX_MF4 + { 9, &RISCVDescs.OperandInfo[493] }, // Inst #6801 = PseudoVNCLIPU_WX_MF2_MASK + { 8, &RISCVDescs.OperandInfo[485] }, // Inst #6800 = PseudoVNCLIPU_WX_MF2 + { 9, &RISCVDescs.OperandInfo[6025] }, // Inst #6799 = PseudoVNCLIPU_WX_M4_MASK + { 8, &RISCVDescs.OperandInfo[6017] }, // Inst #6798 = PseudoVNCLIPU_WX_M4 + { 9, &RISCVDescs.OperandInfo[6008] }, // Inst #6797 = PseudoVNCLIPU_WX_M2_MASK + { 8, &RISCVDescs.OperandInfo[6000] }, // Inst #6796 = PseudoVNCLIPU_WX_M2 + { 9, &RISCVDescs.OperandInfo[5991] }, // Inst #6795 = PseudoVNCLIPU_WX_M1_MASK + { 8, &RISCVDescs.OperandInfo[5983] }, // Inst #6794 = PseudoVNCLIPU_WX_M1 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #6793 = PseudoVNCLIPU_WV_MF8_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #6792 = PseudoVNCLIPU_WV_MF8 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #6791 = PseudoVNCLIPU_WV_MF4_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #6790 = PseudoVNCLIPU_WV_MF4 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #6789 = PseudoVNCLIPU_WV_MF2_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #6788 = PseudoVNCLIPU_WV_MF2 + { 9, &RISCVDescs.OperandInfo[5974] }, // Inst #6787 = PseudoVNCLIPU_WV_M4_MASK + { 8, &RISCVDescs.OperandInfo[5966] }, // Inst #6786 = PseudoVNCLIPU_WV_M4 + { 9, &RISCVDescs.OperandInfo[5957] }, // Inst #6785 = PseudoVNCLIPU_WV_M2_MASK + { 8, &RISCVDescs.OperandInfo[5949] }, // Inst #6784 = PseudoVNCLIPU_WV_M2 + { 9, &RISCVDescs.OperandInfo[5940] }, // Inst #6783 = PseudoVNCLIPU_WV_M1_MASK + { 8, &RISCVDescs.OperandInfo[5932] }, // Inst #6782 = PseudoVNCLIPU_WV_M1 + { 9, &RISCVDescs.OperandInfo[5923] }, // Inst #6781 = PseudoVNCLIPU_WI_MF8_MASK + { 8, &RISCVDescs.OperandInfo[5915] }, // Inst #6780 = PseudoVNCLIPU_WI_MF8 + { 9, &RISCVDescs.OperandInfo[5923] }, // Inst #6779 = PseudoVNCLIPU_WI_MF4_MASK + { 8, &RISCVDescs.OperandInfo[5915] }, // Inst #6778 = PseudoVNCLIPU_WI_MF4 + { 9, &RISCVDescs.OperandInfo[5923] }, // Inst #6777 = PseudoVNCLIPU_WI_MF2_MASK + { 8, &RISCVDescs.OperandInfo[5915] }, // Inst #6776 = PseudoVNCLIPU_WI_MF2 + { 9, &RISCVDescs.OperandInfo[5906] }, // Inst #6775 = PseudoVNCLIPU_WI_M4_MASK + { 8, &RISCVDescs.OperandInfo[5898] }, // Inst #6774 = PseudoVNCLIPU_WI_M4 + { 9, &RISCVDescs.OperandInfo[5889] }, // Inst #6773 = PseudoVNCLIPU_WI_M2_MASK + { 8, &RISCVDescs.OperandInfo[5881] }, // Inst #6772 = PseudoVNCLIPU_WI_M2 + { 9, &RISCVDescs.OperandInfo[5872] }, // Inst #6771 = PseudoVNCLIPU_WI_M1_MASK + { 8, &RISCVDescs.OperandInfo[5864] }, // Inst #6770 = PseudoVNCLIPU_WI_M1 + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6769 = PseudoVMXOR_MM_MF8 + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6768 = PseudoVMXOR_MM_MF4 + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6767 = PseudoVMXOR_MM_MF2 + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6766 = PseudoVMXOR_MM_M8 + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6765 = PseudoVMXOR_MM_M4 + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6764 = PseudoVMXOR_MM_M2 + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6763 = PseudoVMXOR_MM_M1 + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6762 = PseudoVMXNOR_MM_MF8 + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6761 = PseudoVMXNOR_MM_MF4 + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6760 = PseudoVMXNOR_MM_MF2 + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6759 = PseudoVMXNOR_MM_M8 + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6758 = PseudoVMXNOR_MM_M4 + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6757 = PseudoVMXNOR_MM_M2 + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6756 = PseudoVMXNOR_MM_M1 + { 3, &RISCVDescs.OperandInfo[5861] }, // Inst #6755 = PseudoVMV_X_S + { 6, &RISCVDescs.OperandInfo[5837] }, // Inst #6754 = PseudoVMV_V_X_MF8 + { 6, &RISCVDescs.OperandInfo[5837] }, // Inst #6753 = PseudoVMV_V_X_MF4 + { 6, &RISCVDescs.OperandInfo[5837] }, // Inst #6752 = PseudoVMV_V_X_MF2 + { 6, &RISCVDescs.OperandInfo[5855] }, // Inst #6751 = PseudoVMV_V_X_M8 + { 6, &RISCVDescs.OperandInfo[5849] }, // Inst #6750 = PseudoVMV_V_X_M4 + { 6, &RISCVDescs.OperandInfo[5843] }, // Inst #6749 = PseudoVMV_V_X_M2 + { 6, &RISCVDescs.OperandInfo[5837] }, // Inst #6748 = PseudoVMV_V_X_M1 + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #6747 = PseudoVMV_V_V_MF8 + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #6746 = PseudoVMV_V_V_MF4 + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #6745 = PseudoVMV_V_V_MF2 + { 6, &RISCVDescs.OperandInfo[871] }, // Inst #6744 = PseudoVMV_V_V_M8 + { 6, &RISCVDescs.OperandInfo[847] }, // Inst #6743 = PseudoVMV_V_V_M4 + { 6, &RISCVDescs.OperandInfo[829] }, // Inst #6742 = PseudoVMV_V_V_M2 + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #6741 = PseudoVMV_V_V_M1 + { 6, &RISCVDescs.OperandInfo[5813] }, // Inst #6740 = PseudoVMV_V_I_MF8 + { 6, &RISCVDescs.OperandInfo[5813] }, // Inst #6739 = PseudoVMV_V_I_MF4 + { 6, &RISCVDescs.OperandInfo[5813] }, // Inst #6738 = PseudoVMV_V_I_MF2 + { 6, &RISCVDescs.OperandInfo[5831] }, // Inst #6737 = PseudoVMV_V_I_M8 + { 6, &RISCVDescs.OperandInfo[5825] }, // Inst #6736 = PseudoVMV_V_I_M4 + { 6, &RISCVDescs.OperandInfo[5819] }, // Inst #6735 = PseudoVMV_V_I_M2 + { 6, &RISCVDescs.OperandInfo[5813] }, // Inst #6734 = PseudoVMV_V_I_M1 + { 5, &RISCVDescs.OperandInfo[5808] }, // Inst #6733 = PseudoVMV_S_X + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #6732 = PseudoVMUL_VX_MF8_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #6731 = PseudoVMUL_VX_MF8 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #6730 = PseudoVMUL_VX_MF4_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #6729 = PseudoVMUL_VX_MF4 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #6728 = PseudoVMUL_VX_MF2_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #6727 = PseudoVMUL_VX_MF2 + { 8, &RISCVDescs.OperandInfo[809] }, // Inst #6726 = PseudoVMUL_VX_M8_MASK + { 7, &RISCVDescs.OperandInfo[802] }, // Inst #6725 = PseudoVMUL_VX_M8 + { 8, &RISCVDescs.OperandInfo[794] }, // Inst #6724 = PseudoVMUL_VX_M4_MASK + { 7, &RISCVDescs.OperandInfo[787] }, // Inst #6723 = PseudoVMUL_VX_M4 + { 8, &RISCVDescs.OperandInfo[779] }, // Inst #6722 = PseudoVMUL_VX_M2_MASK + { 7, &RISCVDescs.OperandInfo[772] }, // Inst #6721 = PseudoVMUL_VX_M2 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #6720 = PseudoVMUL_VX_M1_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #6719 = PseudoVMUL_VX_M1 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #6718 = PseudoVMUL_VV_MF8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #6717 = PseudoVMUL_VV_MF8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #6716 = PseudoVMUL_VV_MF4_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #6715 = PseudoVMUL_VV_MF4 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #6714 = PseudoVMUL_VV_MF2_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #6713 = PseudoVMUL_VV_MF2 + { 8, &RISCVDescs.OperandInfo[749] }, // Inst #6712 = PseudoVMUL_VV_M8_MASK + { 7, &RISCVDescs.OperandInfo[742] }, // Inst #6711 = PseudoVMUL_VV_M8 + { 8, &RISCVDescs.OperandInfo[734] }, // Inst #6710 = PseudoVMUL_VV_M4_MASK + { 7, &RISCVDescs.OperandInfo[727] }, // Inst #6709 = PseudoVMUL_VV_M4 + { 8, &RISCVDescs.OperandInfo[719] }, // Inst #6708 = PseudoVMUL_VV_M2_MASK + { 7, &RISCVDescs.OperandInfo[712] }, // Inst #6707 = PseudoVMUL_VV_M2 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #6706 = PseudoVMUL_VV_M1_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #6705 = PseudoVMUL_VV_M1 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #6704 = PseudoVMULH_VX_MF8_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #6703 = PseudoVMULH_VX_MF8 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #6702 = PseudoVMULH_VX_MF4_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #6701 = PseudoVMULH_VX_MF4 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #6700 = PseudoVMULH_VX_MF2_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #6699 = PseudoVMULH_VX_MF2 + { 8, &RISCVDescs.OperandInfo[809] }, // Inst #6698 = PseudoVMULH_VX_M8_MASK + { 7, &RISCVDescs.OperandInfo[802] }, // Inst #6697 = PseudoVMULH_VX_M8 + { 8, &RISCVDescs.OperandInfo[794] }, // Inst #6696 = PseudoVMULH_VX_M4_MASK + { 7, &RISCVDescs.OperandInfo[787] }, // Inst #6695 = PseudoVMULH_VX_M4 + { 8, &RISCVDescs.OperandInfo[779] }, // Inst #6694 = PseudoVMULH_VX_M2_MASK + { 7, &RISCVDescs.OperandInfo[772] }, // Inst #6693 = PseudoVMULH_VX_M2 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #6692 = PseudoVMULH_VX_M1_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #6691 = PseudoVMULH_VX_M1 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #6690 = PseudoVMULH_VV_MF8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #6689 = PseudoVMULH_VV_MF8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #6688 = PseudoVMULH_VV_MF4_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #6687 = PseudoVMULH_VV_MF4 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #6686 = PseudoVMULH_VV_MF2_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #6685 = PseudoVMULH_VV_MF2 + { 8, &RISCVDescs.OperandInfo[749] }, // Inst #6684 = PseudoVMULH_VV_M8_MASK + { 7, &RISCVDescs.OperandInfo[742] }, // Inst #6683 = PseudoVMULH_VV_M8 + { 8, &RISCVDescs.OperandInfo[734] }, // Inst #6682 = PseudoVMULH_VV_M4_MASK + { 7, &RISCVDescs.OperandInfo[727] }, // Inst #6681 = PseudoVMULH_VV_M4 + { 8, &RISCVDescs.OperandInfo[719] }, // Inst #6680 = PseudoVMULH_VV_M2_MASK + { 7, &RISCVDescs.OperandInfo[712] }, // Inst #6679 = PseudoVMULH_VV_M2 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #6678 = PseudoVMULH_VV_M1_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #6677 = PseudoVMULH_VV_M1 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #6676 = PseudoVMULHU_VX_MF8_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #6675 = PseudoVMULHU_VX_MF8 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #6674 = PseudoVMULHU_VX_MF4_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #6673 = PseudoVMULHU_VX_MF4 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #6672 = PseudoVMULHU_VX_MF2_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #6671 = PseudoVMULHU_VX_MF2 + { 8, &RISCVDescs.OperandInfo[809] }, // Inst #6670 = PseudoVMULHU_VX_M8_MASK + { 7, &RISCVDescs.OperandInfo[802] }, // Inst #6669 = PseudoVMULHU_VX_M8 + { 8, &RISCVDescs.OperandInfo[794] }, // Inst #6668 = PseudoVMULHU_VX_M4_MASK + { 7, &RISCVDescs.OperandInfo[787] }, // Inst #6667 = PseudoVMULHU_VX_M4 + { 8, &RISCVDescs.OperandInfo[779] }, // Inst #6666 = PseudoVMULHU_VX_M2_MASK + { 7, &RISCVDescs.OperandInfo[772] }, // Inst #6665 = PseudoVMULHU_VX_M2 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #6664 = PseudoVMULHU_VX_M1_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #6663 = PseudoVMULHU_VX_M1 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #6662 = PseudoVMULHU_VV_MF8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #6661 = PseudoVMULHU_VV_MF8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #6660 = PseudoVMULHU_VV_MF4_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #6659 = PseudoVMULHU_VV_MF4 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #6658 = PseudoVMULHU_VV_MF2_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #6657 = PseudoVMULHU_VV_MF2 + { 8, &RISCVDescs.OperandInfo[749] }, // Inst #6656 = PseudoVMULHU_VV_M8_MASK + { 7, &RISCVDescs.OperandInfo[742] }, // Inst #6655 = PseudoVMULHU_VV_M8 + { 8, &RISCVDescs.OperandInfo[734] }, // Inst #6654 = PseudoVMULHU_VV_M4_MASK + { 7, &RISCVDescs.OperandInfo[727] }, // Inst #6653 = PseudoVMULHU_VV_M4 + { 8, &RISCVDescs.OperandInfo[719] }, // Inst #6652 = PseudoVMULHU_VV_M2_MASK + { 7, &RISCVDescs.OperandInfo[712] }, // Inst #6651 = PseudoVMULHU_VV_M2 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #6650 = PseudoVMULHU_VV_M1_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #6649 = PseudoVMULHU_VV_M1 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #6648 = PseudoVMULHSU_VX_MF8_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #6647 = PseudoVMULHSU_VX_MF8 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #6646 = PseudoVMULHSU_VX_MF4_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #6645 = PseudoVMULHSU_VX_MF4 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #6644 = PseudoVMULHSU_VX_MF2_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #6643 = PseudoVMULHSU_VX_MF2 + { 8, &RISCVDescs.OperandInfo[809] }, // Inst #6642 = PseudoVMULHSU_VX_M8_MASK + { 7, &RISCVDescs.OperandInfo[802] }, // Inst #6641 = PseudoVMULHSU_VX_M8 + { 8, &RISCVDescs.OperandInfo[794] }, // Inst #6640 = PseudoVMULHSU_VX_M4_MASK + { 7, &RISCVDescs.OperandInfo[787] }, // Inst #6639 = PseudoVMULHSU_VX_M4 + { 8, &RISCVDescs.OperandInfo[779] }, // Inst #6638 = PseudoVMULHSU_VX_M2_MASK + { 7, &RISCVDescs.OperandInfo[772] }, // Inst #6637 = PseudoVMULHSU_VX_M2 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #6636 = PseudoVMULHSU_VX_M1_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #6635 = PseudoVMULHSU_VX_M1 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #6634 = PseudoVMULHSU_VV_MF8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #6633 = PseudoVMULHSU_VV_MF8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #6632 = PseudoVMULHSU_VV_MF4_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #6631 = PseudoVMULHSU_VV_MF4 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #6630 = PseudoVMULHSU_VV_MF2_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #6629 = PseudoVMULHSU_VV_MF2 + { 8, &RISCVDescs.OperandInfo[749] }, // Inst #6628 = PseudoVMULHSU_VV_M8_MASK + { 7, &RISCVDescs.OperandInfo[742] }, // Inst #6627 = PseudoVMULHSU_VV_M8 + { 8, &RISCVDescs.OperandInfo[734] }, // Inst #6626 = PseudoVMULHSU_VV_M4_MASK + { 7, &RISCVDescs.OperandInfo[727] }, // Inst #6625 = PseudoVMULHSU_VV_M4 + { 8, &RISCVDescs.OperandInfo[719] }, // Inst #6624 = PseudoVMULHSU_VV_M2_MASK + { 7, &RISCVDescs.OperandInfo[712] }, // Inst #6623 = PseudoVMULHSU_VV_M2 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #6622 = PseudoVMULHSU_VV_M1_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #6621 = PseudoVMULHSU_VV_M1 + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #6620 = PseudoVMSOF_M_B8_MASK + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #6619 = PseudoVMSOF_M_B8 + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #6618 = PseudoVMSOF_M_B64_MASK + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #6617 = PseudoVMSOF_M_B64 + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #6616 = PseudoVMSOF_M_B4_MASK + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #6615 = PseudoVMSOF_M_B4 + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #6614 = PseudoVMSOF_M_B32_MASK + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #6613 = PseudoVMSOF_M_B32 + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #6612 = PseudoVMSOF_M_B2_MASK + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #6611 = PseudoVMSOF_M_B2 + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #6610 = PseudoVMSOF_M_B1_MASK + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #6609 = PseudoVMSOF_M_B16_MASK + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #6608 = PseudoVMSOF_M_B16 + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #6607 = PseudoVMSOF_M_B1 + { 7, &RISCVDescs.OperandInfo[5764] }, // Inst #6606 = PseudoVMSNE_VX_MF8_MASK + { 5, &RISCVDescs.OperandInfo[5759] }, // Inst #6605 = PseudoVMSNE_VX_MF8 + { 7, &RISCVDescs.OperandInfo[5764] }, // Inst #6604 = PseudoVMSNE_VX_MF4_MASK + { 5, &RISCVDescs.OperandInfo[5759] }, // Inst #6603 = PseudoVMSNE_VX_MF4 + { 7, &RISCVDescs.OperandInfo[5764] }, // Inst #6602 = PseudoVMSNE_VX_MF2_MASK + { 5, &RISCVDescs.OperandInfo[5759] }, // Inst #6601 = PseudoVMSNE_VX_MF2 + { 7, &RISCVDescs.OperandInfo[5785] }, // Inst #6600 = PseudoVMSNE_VX_M8_MASK + { 5, &RISCVDescs.OperandInfo[5541] }, // Inst #6599 = PseudoVMSNE_VX_M8 + { 7, &RISCVDescs.OperandInfo[5778] }, // Inst #6598 = PseudoVMSNE_VX_M4_MASK + { 5, &RISCVDescs.OperandInfo[5536] }, // Inst #6597 = PseudoVMSNE_VX_M4 + { 7, &RISCVDescs.OperandInfo[5771] }, // Inst #6596 = PseudoVMSNE_VX_M2_MASK + { 5, &RISCVDescs.OperandInfo[5531] }, // Inst #6595 = PseudoVMSNE_VX_M2 + { 7, &RISCVDescs.OperandInfo[5764] }, // Inst #6594 = PseudoVMSNE_VX_M1_MASK + { 5, &RISCVDescs.OperandInfo[5759] }, // Inst #6593 = PseudoVMSNE_VX_M1 + { 7, &RISCVDescs.OperandInfo[5698] }, // Inst #6592 = PseudoVMSNE_VV_MF8_MASK + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6591 = PseudoVMSNE_VV_MF8 + { 7, &RISCVDescs.OperandInfo[5698] }, // Inst #6590 = PseudoVMSNE_VV_MF4_MASK + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6589 = PseudoVMSNE_VV_MF4 + { 7, &RISCVDescs.OperandInfo[5698] }, // Inst #6588 = PseudoVMSNE_VV_MF2_MASK + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6587 = PseudoVMSNE_VV_MF2 + { 7, &RISCVDescs.OperandInfo[5719] }, // Inst #6586 = PseudoVMSNE_VV_M8_MASK + { 5, &RISCVDescs.OperandInfo[5497] }, // Inst #6585 = PseudoVMSNE_VV_M8 + { 7, &RISCVDescs.OperandInfo[5712] }, // Inst #6584 = PseudoVMSNE_VV_M4_MASK + { 5, &RISCVDescs.OperandInfo[5492] }, // Inst #6583 = PseudoVMSNE_VV_M4 + { 7, &RISCVDescs.OperandInfo[5705] }, // Inst #6582 = PseudoVMSNE_VV_M2_MASK + { 5, &RISCVDescs.OperandInfo[5487] }, // Inst #6581 = PseudoVMSNE_VV_M2 + { 7, &RISCVDescs.OperandInfo[5698] }, // Inst #6580 = PseudoVMSNE_VV_M1_MASK + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6579 = PseudoVMSNE_VV_M1 + { 7, &RISCVDescs.OperandInfo[5731] }, // Inst #6578 = PseudoVMSNE_VI_MF8_MASK + { 5, &RISCVDescs.OperandInfo[5726] }, // Inst #6577 = PseudoVMSNE_VI_MF8 + { 7, &RISCVDescs.OperandInfo[5731] }, // Inst #6576 = PseudoVMSNE_VI_MF4_MASK + { 5, &RISCVDescs.OperandInfo[5726] }, // Inst #6575 = PseudoVMSNE_VI_MF4 + { 7, &RISCVDescs.OperandInfo[5731] }, // Inst #6574 = PseudoVMSNE_VI_MF2_MASK + { 5, &RISCVDescs.OperandInfo[5726] }, // Inst #6573 = PseudoVMSNE_VI_MF2 + { 7, &RISCVDescs.OperandInfo[5752] }, // Inst #6572 = PseudoVMSNE_VI_M8_MASK + { 5, &RISCVDescs.OperandInfo[5453] }, // Inst #6571 = PseudoVMSNE_VI_M8 + { 7, &RISCVDescs.OperandInfo[5745] }, // Inst #6570 = PseudoVMSNE_VI_M4_MASK + { 5, &RISCVDescs.OperandInfo[5448] }, // Inst #6569 = PseudoVMSNE_VI_M4 + { 7, &RISCVDescs.OperandInfo[5738] }, // Inst #6568 = PseudoVMSNE_VI_M2_MASK + { 5, &RISCVDescs.OperandInfo[5443] }, // Inst #6567 = PseudoVMSNE_VI_M2 + { 7, &RISCVDescs.OperandInfo[5731] }, // Inst #6566 = PseudoVMSNE_VI_M1_MASK + { 5, &RISCVDescs.OperandInfo[5726] }, // Inst #6565 = PseudoVMSNE_VI_M1 + { 7, &RISCVDescs.OperandInfo[5764] }, // Inst #6564 = PseudoVMSLT_VX_MF8_MASK + { 5, &RISCVDescs.OperandInfo[5759] }, // Inst #6563 = PseudoVMSLT_VX_MF8 + { 7, &RISCVDescs.OperandInfo[5764] }, // Inst #6562 = PseudoVMSLT_VX_MF4_MASK + { 5, &RISCVDescs.OperandInfo[5759] }, // Inst #6561 = PseudoVMSLT_VX_MF4 + { 7, &RISCVDescs.OperandInfo[5764] }, // Inst #6560 = PseudoVMSLT_VX_MF2_MASK + { 5, &RISCVDescs.OperandInfo[5759] }, // Inst #6559 = PseudoVMSLT_VX_MF2 + { 7, &RISCVDescs.OperandInfo[5785] }, // Inst #6558 = PseudoVMSLT_VX_M8_MASK + { 5, &RISCVDescs.OperandInfo[5541] }, // Inst #6557 = PseudoVMSLT_VX_M8 + { 7, &RISCVDescs.OperandInfo[5778] }, // Inst #6556 = PseudoVMSLT_VX_M4_MASK + { 5, &RISCVDescs.OperandInfo[5536] }, // Inst #6555 = PseudoVMSLT_VX_M4 + { 7, &RISCVDescs.OperandInfo[5771] }, // Inst #6554 = PseudoVMSLT_VX_M2_MASK + { 5, &RISCVDescs.OperandInfo[5531] }, // Inst #6553 = PseudoVMSLT_VX_M2 + { 7, &RISCVDescs.OperandInfo[5764] }, // Inst #6552 = PseudoVMSLT_VX_M1_MASK + { 5, &RISCVDescs.OperandInfo[5759] }, // Inst #6551 = PseudoVMSLT_VX_M1 + { 7, &RISCVDescs.OperandInfo[5698] }, // Inst #6550 = PseudoVMSLT_VV_MF8_MASK + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6549 = PseudoVMSLT_VV_MF8 + { 7, &RISCVDescs.OperandInfo[5698] }, // Inst #6548 = PseudoVMSLT_VV_MF4_MASK + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6547 = PseudoVMSLT_VV_MF4 + { 7, &RISCVDescs.OperandInfo[5698] }, // Inst #6546 = PseudoVMSLT_VV_MF2_MASK + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6545 = PseudoVMSLT_VV_MF2 + { 7, &RISCVDescs.OperandInfo[5719] }, // Inst #6544 = PseudoVMSLT_VV_M8_MASK + { 5, &RISCVDescs.OperandInfo[5497] }, // Inst #6543 = PseudoVMSLT_VV_M8 + { 7, &RISCVDescs.OperandInfo[5712] }, // Inst #6542 = PseudoVMSLT_VV_M4_MASK + { 5, &RISCVDescs.OperandInfo[5492] }, // Inst #6541 = PseudoVMSLT_VV_M4 + { 7, &RISCVDescs.OperandInfo[5705] }, // Inst #6540 = PseudoVMSLT_VV_M2_MASK + { 5, &RISCVDescs.OperandInfo[5487] }, // Inst #6539 = PseudoVMSLT_VV_M2 + { 7, &RISCVDescs.OperandInfo[5698] }, // Inst #6538 = PseudoVMSLT_VV_M1_MASK + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6537 = PseudoVMSLT_VV_M1 + { 4, &RISCVDescs.OperandInfo[5792] }, // Inst #6536 = PseudoVMSLT_VI + { 7, &RISCVDescs.OperandInfo[5764] }, // Inst #6535 = PseudoVMSLTU_VX_MF8_MASK + { 5, &RISCVDescs.OperandInfo[5759] }, // Inst #6534 = PseudoVMSLTU_VX_MF8 + { 7, &RISCVDescs.OperandInfo[5764] }, // Inst #6533 = PseudoVMSLTU_VX_MF4_MASK + { 5, &RISCVDescs.OperandInfo[5759] }, // Inst #6532 = PseudoVMSLTU_VX_MF4 + { 7, &RISCVDescs.OperandInfo[5764] }, // Inst #6531 = PseudoVMSLTU_VX_MF2_MASK + { 5, &RISCVDescs.OperandInfo[5759] }, // Inst #6530 = PseudoVMSLTU_VX_MF2 + { 7, &RISCVDescs.OperandInfo[5785] }, // Inst #6529 = PseudoVMSLTU_VX_M8_MASK + { 5, &RISCVDescs.OperandInfo[5541] }, // Inst #6528 = PseudoVMSLTU_VX_M8 + { 7, &RISCVDescs.OperandInfo[5778] }, // Inst #6527 = PseudoVMSLTU_VX_M4_MASK + { 5, &RISCVDescs.OperandInfo[5536] }, // Inst #6526 = PseudoVMSLTU_VX_M4 + { 7, &RISCVDescs.OperandInfo[5771] }, // Inst #6525 = PseudoVMSLTU_VX_M2_MASK + { 5, &RISCVDescs.OperandInfo[5531] }, // Inst #6524 = PseudoVMSLTU_VX_M2 + { 7, &RISCVDescs.OperandInfo[5764] }, // Inst #6523 = PseudoVMSLTU_VX_M1_MASK + { 5, &RISCVDescs.OperandInfo[5759] }, // Inst #6522 = PseudoVMSLTU_VX_M1 + { 7, &RISCVDescs.OperandInfo[5698] }, // Inst #6521 = PseudoVMSLTU_VV_MF8_MASK + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6520 = PseudoVMSLTU_VV_MF8 + { 7, &RISCVDescs.OperandInfo[5698] }, // Inst #6519 = PseudoVMSLTU_VV_MF4_MASK + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6518 = PseudoVMSLTU_VV_MF4 + { 7, &RISCVDescs.OperandInfo[5698] }, // Inst #6517 = PseudoVMSLTU_VV_MF2_MASK + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6516 = PseudoVMSLTU_VV_MF2 + { 7, &RISCVDescs.OperandInfo[5719] }, // Inst #6515 = PseudoVMSLTU_VV_M8_MASK + { 5, &RISCVDescs.OperandInfo[5497] }, // Inst #6514 = PseudoVMSLTU_VV_M8 + { 7, &RISCVDescs.OperandInfo[5712] }, // Inst #6513 = PseudoVMSLTU_VV_M4_MASK + { 5, &RISCVDescs.OperandInfo[5492] }, // Inst #6512 = PseudoVMSLTU_VV_M4 + { 7, &RISCVDescs.OperandInfo[5705] }, // Inst #6511 = PseudoVMSLTU_VV_M2_MASK + { 5, &RISCVDescs.OperandInfo[5487] }, // Inst #6510 = PseudoVMSLTU_VV_M2 + { 7, &RISCVDescs.OperandInfo[5698] }, // Inst #6509 = PseudoVMSLTU_VV_M1_MASK + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6508 = PseudoVMSLTU_VV_M1 + { 4, &RISCVDescs.OperandInfo[5792] }, // Inst #6507 = PseudoVMSLTU_VI + { 7, &RISCVDescs.OperandInfo[5764] }, // Inst #6506 = PseudoVMSLE_VX_MF8_MASK + { 5, &RISCVDescs.OperandInfo[5759] }, // Inst #6505 = PseudoVMSLE_VX_MF8 + { 7, &RISCVDescs.OperandInfo[5764] }, // Inst #6504 = PseudoVMSLE_VX_MF4_MASK + { 5, &RISCVDescs.OperandInfo[5759] }, // Inst #6503 = PseudoVMSLE_VX_MF4 + { 7, &RISCVDescs.OperandInfo[5764] }, // Inst #6502 = PseudoVMSLE_VX_MF2_MASK + { 5, &RISCVDescs.OperandInfo[5759] }, // Inst #6501 = PseudoVMSLE_VX_MF2 + { 7, &RISCVDescs.OperandInfo[5785] }, // Inst #6500 = PseudoVMSLE_VX_M8_MASK + { 5, &RISCVDescs.OperandInfo[5541] }, // Inst #6499 = PseudoVMSLE_VX_M8 + { 7, &RISCVDescs.OperandInfo[5778] }, // Inst #6498 = PseudoVMSLE_VX_M4_MASK + { 5, &RISCVDescs.OperandInfo[5536] }, // Inst #6497 = PseudoVMSLE_VX_M4 + { 7, &RISCVDescs.OperandInfo[5771] }, // Inst #6496 = PseudoVMSLE_VX_M2_MASK + { 5, &RISCVDescs.OperandInfo[5531] }, // Inst #6495 = PseudoVMSLE_VX_M2 + { 7, &RISCVDescs.OperandInfo[5764] }, // Inst #6494 = PseudoVMSLE_VX_M1_MASK + { 5, &RISCVDescs.OperandInfo[5759] }, // Inst #6493 = PseudoVMSLE_VX_M1 + { 7, &RISCVDescs.OperandInfo[5698] }, // Inst #6492 = PseudoVMSLE_VV_MF8_MASK + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6491 = PseudoVMSLE_VV_MF8 + { 7, &RISCVDescs.OperandInfo[5698] }, // Inst #6490 = PseudoVMSLE_VV_MF4_MASK + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6489 = PseudoVMSLE_VV_MF4 + { 7, &RISCVDescs.OperandInfo[5698] }, // Inst #6488 = PseudoVMSLE_VV_MF2_MASK + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6487 = PseudoVMSLE_VV_MF2 + { 7, &RISCVDescs.OperandInfo[5719] }, // Inst #6486 = PseudoVMSLE_VV_M8_MASK + { 5, &RISCVDescs.OperandInfo[5497] }, // Inst #6485 = PseudoVMSLE_VV_M8 + { 7, &RISCVDescs.OperandInfo[5712] }, // Inst #6484 = PseudoVMSLE_VV_M4_MASK + { 5, &RISCVDescs.OperandInfo[5492] }, // Inst #6483 = PseudoVMSLE_VV_M4 + { 7, &RISCVDescs.OperandInfo[5705] }, // Inst #6482 = PseudoVMSLE_VV_M2_MASK + { 5, &RISCVDescs.OperandInfo[5487] }, // Inst #6481 = PseudoVMSLE_VV_M2 + { 7, &RISCVDescs.OperandInfo[5698] }, // Inst #6480 = PseudoVMSLE_VV_M1_MASK + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6479 = PseudoVMSLE_VV_M1 + { 7, &RISCVDescs.OperandInfo[5731] }, // Inst #6478 = PseudoVMSLE_VI_MF8_MASK + { 5, &RISCVDescs.OperandInfo[5726] }, // Inst #6477 = PseudoVMSLE_VI_MF8 + { 7, &RISCVDescs.OperandInfo[5731] }, // Inst #6476 = PseudoVMSLE_VI_MF4_MASK + { 5, &RISCVDescs.OperandInfo[5726] }, // Inst #6475 = PseudoVMSLE_VI_MF4 + { 7, &RISCVDescs.OperandInfo[5731] }, // Inst #6474 = PseudoVMSLE_VI_MF2_MASK + { 5, &RISCVDescs.OperandInfo[5726] }, // Inst #6473 = PseudoVMSLE_VI_MF2 + { 7, &RISCVDescs.OperandInfo[5752] }, // Inst #6472 = PseudoVMSLE_VI_M8_MASK + { 5, &RISCVDescs.OperandInfo[5453] }, // Inst #6471 = PseudoVMSLE_VI_M8 + { 7, &RISCVDescs.OperandInfo[5745] }, // Inst #6470 = PseudoVMSLE_VI_M4_MASK + { 5, &RISCVDescs.OperandInfo[5448] }, // Inst #6469 = PseudoVMSLE_VI_M4 + { 7, &RISCVDescs.OperandInfo[5738] }, // Inst #6468 = PseudoVMSLE_VI_M2_MASK + { 5, &RISCVDescs.OperandInfo[5443] }, // Inst #6467 = PseudoVMSLE_VI_M2 + { 7, &RISCVDescs.OperandInfo[5731] }, // Inst #6466 = PseudoVMSLE_VI_M1_MASK + { 5, &RISCVDescs.OperandInfo[5726] }, // Inst #6465 = PseudoVMSLE_VI_M1 + { 7, &RISCVDescs.OperandInfo[5764] }, // Inst #6464 = PseudoVMSLEU_VX_MF8_MASK + { 5, &RISCVDescs.OperandInfo[5759] }, // Inst #6463 = PseudoVMSLEU_VX_MF8 + { 7, &RISCVDescs.OperandInfo[5764] }, // Inst #6462 = PseudoVMSLEU_VX_MF4_MASK + { 5, &RISCVDescs.OperandInfo[5759] }, // Inst #6461 = PseudoVMSLEU_VX_MF4 + { 7, &RISCVDescs.OperandInfo[5764] }, // Inst #6460 = PseudoVMSLEU_VX_MF2_MASK + { 5, &RISCVDescs.OperandInfo[5759] }, // Inst #6459 = PseudoVMSLEU_VX_MF2 + { 7, &RISCVDescs.OperandInfo[5785] }, // Inst #6458 = PseudoVMSLEU_VX_M8_MASK + { 5, &RISCVDescs.OperandInfo[5541] }, // Inst #6457 = PseudoVMSLEU_VX_M8 + { 7, &RISCVDescs.OperandInfo[5778] }, // Inst #6456 = PseudoVMSLEU_VX_M4_MASK + { 5, &RISCVDescs.OperandInfo[5536] }, // Inst #6455 = PseudoVMSLEU_VX_M4 + { 7, &RISCVDescs.OperandInfo[5771] }, // Inst #6454 = PseudoVMSLEU_VX_M2_MASK + { 5, &RISCVDescs.OperandInfo[5531] }, // Inst #6453 = PseudoVMSLEU_VX_M2 + { 7, &RISCVDescs.OperandInfo[5764] }, // Inst #6452 = PseudoVMSLEU_VX_M1_MASK + { 5, &RISCVDescs.OperandInfo[5759] }, // Inst #6451 = PseudoVMSLEU_VX_M1 + { 7, &RISCVDescs.OperandInfo[5698] }, // Inst #6450 = PseudoVMSLEU_VV_MF8_MASK + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6449 = PseudoVMSLEU_VV_MF8 + { 7, &RISCVDescs.OperandInfo[5698] }, // Inst #6448 = PseudoVMSLEU_VV_MF4_MASK + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6447 = PseudoVMSLEU_VV_MF4 + { 7, &RISCVDescs.OperandInfo[5698] }, // Inst #6446 = PseudoVMSLEU_VV_MF2_MASK + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6445 = PseudoVMSLEU_VV_MF2 + { 7, &RISCVDescs.OperandInfo[5719] }, // Inst #6444 = PseudoVMSLEU_VV_M8_MASK + { 5, &RISCVDescs.OperandInfo[5497] }, // Inst #6443 = PseudoVMSLEU_VV_M8 + { 7, &RISCVDescs.OperandInfo[5712] }, // Inst #6442 = PseudoVMSLEU_VV_M4_MASK + { 5, &RISCVDescs.OperandInfo[5492] }, // Inst #6441 = PseudoVMSLEU_VV_M4 + { 7, &RISCVDescs.OperandInfo[5705] }, // Inst #6440 = PseudoVMSLEU_VV_M2_MASK + { 5, &RISCVDescs.OperandInfo[5487] }, // Inst #6439 = PseudoVMSLEU_VV_M2 + { 7, &RISCVDescs.OperandInfo[5698] }, // Inst #6438 = PseudoVMSLEU_VV_M1_MASK + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6437 = PseudoVMSLEU_VV_M1 + { 7, &RISCVDescs.OperandInfo[5731] }, // Inst #6436 = PseudoVMSLEU_VI_MF8_MASK + { 5, &RISCVDescs.OperandInfo[5726] }, // Inst #6435 = PseudoVMSLEU_VI_MF8 + { 7, &RISCVDescs.OperandInfo[5731] }, // Inst #6434 = PseudoVMSLEU_VI_MF4_MASK + { 5, &RISCVDescs.OperandInfo[5726] }, // Inst #6433 = PseudoVMSLEU_VI_MF4 + { 7, &RISCVDescs.OperandInfo[5731] }, // Inst #6432 = PseudoVMSLEU_VI_MF2_MASK + { 5, &RISCVDescs.OperandInfo[5726] }, // Inst #6431 = PseudoVMSLEU_VI_MF2 + { 7, &RISCVDescs.OperandInfo[5752] }, // Inst #6430 = PseudoVMSLEU_VI_M8_MASK + { 5, &RISCVDescs.OperandInfo[5453] }, // Inst #6429 = PseudoVMSLEU_VI_M8 + { 7, &RISCVDescs.OperandInfo[5745] }, // Inst #6428 = PseudoVMSLEU_VI_M4_MASK + { 5, &RISCVDescs.OperandInfo[5448] }, // Inst #6427 = PseudoVMSLEU_VI_M4 + { 7, &RISCVDescs.OperandInfo[5738] }, // Inst #6426 = PseudoVMSLEU_VI_M2_MASK + { 5, &RISCVDescs.OperandInfo[5443] }, // Inst #6425 = PseudoVMSLEU_VI_M2 + { 7, &RISCVDescs.OperandInfo[5731] }, // Inst #6424 = PseudoVMSLEU_VI_M1_MASK + { 5, &RISCVDescs.OperandInfo[5726] }, // Inst #6423 = PseudoVMSLEU_VI_M1 + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #6422 = PseudoVMSIF_M_B8_MASK + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #6421 = PseudoVMSIF_M_B8 + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #6420 = PseudoVMSIF_M_B64_MASK + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #6419 = PseudoVMSIF_M_B64 + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #6418 = PseudoVMSIF_M_B4_MASK + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #6417 = PseudoVMSIF_M_B4 + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #6416 = PseudoVMSIF_M_B32_MASK + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #6415 = PseudoVMSIF_M_B32 + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #6414 = PseudoVMSIF_M_B2_MASK + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #6413 = PseudoVMSIF_M_B2 + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #6412 = PseudoVMSIF_M_B1_MASK + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #6411 = PseudoVMSIF_M_B16_MASK + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #6410 = PseudoVMSIF_M_B16 + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #6409 = PseudoVMSIF_M_B1 + { 7, &RISCVDescs.OperandInfo[5764] }, // Inst #6408 = PseudoVMSGT_VX_MF8_MASK + { 5, &RISCVDescs.OperandInfo[5759] }, // Inst #6407 = PseudoVMSGT_VX_MF8 + { 7, &RISCVDescs.OperandInfo[5764] }, // Inst #6406 = PseudoVMSGT_VX_MF4_MASK + { 5, &RISCVDescs.OperandInfo[5759] }, // Inst #6405 = PseudoVMSGT_VX_MF4 + { 7, &RISCVDescs.OperandInfo[5764] }, // Inst #6404 = PseudoVMSGT_VX_MF2_MASK + { 5, &RISCVDescs.OperandInfo[5759] }, // Inst #6403 = PseudoVMSGT_VX_MF2 + { 7, &RISCVDescs.OperandInfo[5785] }, // Inst #6402 = PseudoVMSGT_VX_M8_MASK + { 5, &RISCVDescs.OperandInfo[5541] }, // Inst #6401 = PseudoVMSGT_VX_M8 + { 7, &RISCVDescs.OperandInfo[5778] }, // Inst #6400 = PseudoVMSGT_VX_M4_MASK + { 5, &RISCVDescs.OperandInfo[5536] }, // Inst #6399 = PseudoVMSGT_VX_M4 + { 7, &RISCVDescs.OperandInfo[5771] }, // Inst #6398 = PseudoVMSGT_VX_M2_MASK + { 5, &RISCVDescs.OperandInfo[5531] }, // Inst #6397 = PseudoVMSGT_VX_M2 + { 7, &RISCVDescs.OperandInfo[5764] }, // Inst #6396 = PseudoVMSGT_VX_M1_MASK + { 5, &RISCVDescs.OperandInfo[5759] }, // Inst #6395 = PseudoVMSGT_VX_M1 + { 7, &RISCVDescs.OperandInfo[5731] }, // Inst #6394 = PseudoVMSGT_VI_MF8_MASK + { 5, &RISCVDescs.OperandInfo[5726] }, // Inst #6393 = PseudoVMSGT_VI_MF8 + { 7, &RISCVDescs.OperandInfo[5731] }, // Inst #6392 = PseudoVMSGT_VI_MF4_MASK + { 5, &RISCVDescs.OperandInfo[5726] }, // Inst #6391 = PseudoVMSGT_VI_MF4 + { 7, &RISCVDescs.OperandInfo[5731] }, // Inst #6390 = PseudoVMSGT_VI_MF2_MASK + { 5, &RISCVDescs.OperandInfo[5726] }, // Inst #6389 = PseudoVMSGT_VI_MF2 + { 7, &RISCVDescs.OperandInfo[5752] }, // Inst #6388 = PseudoVMSGT_VI_M8_MASK + { 5, &RISCVDescs.OperandInfo[5453] }, // Inst #6387 = PseudoVMSGT_VI_M8 + { 7, &RISCVDescs.OperandInfo[5745] }, // Inst #6386 = PseudoVMSGT_VI_M4_MASK + { 5, &RISCVDescs.OperandInfo[5448] }, // Inst #6385 = PseudoVMSGT_VI_M4 + { 7, &RISCVDescs.OperandInfo[5738] }, // Inst #6384 = PseudoVMSGT_VI_M2_MASK + { 5, &RISCVDescs.OperandInfo[5443] }, // Inst #6383 = PseudoVMSGT_VI_M2 + { 7, &RISCVDescs.OperandInfo[5731] }, // Inst #6382 = PseudoVMSGT_VI_M1_MASK + { 5, &RISCVDescs.OperandInfo[5726] }, // Inst #6381 = PseudoVMSGT_VI_M1 + { 7, &RISCVDescs.OperandInfo[5764] }, // Inst #6380 = PseudoVMSGTU_VX_MF8_MASK + { 5, &RISCVDescs.OperandInfo[5759] }, // Inst #6379 = PseudoVMSGTU_VX_MF8 + { 7, &RISCVDescs.OperandInfo[5764] }, // Inst #6378 = PseudoVMSGTU_VX_MF4_MASK + { 5, &RISCVDescs.OperandInfo[5759] }, // Inst #6377 = PseudoVMSGTU_VX_MF4 + { 7, &RISCVDescs.OperandInfo[5764] }, // Inst #6376 = PseudoVMSGTU_VX_MF2_MASK + { 5, &RISCVDescs.OperandInfo[5759] }, // Inst #6375 = PseudoVMSGTU_VX_MF2 + { 7, &RISCVDescs.OperandInfo[5785] }, // Inst #6374 = PseudoVMSGTU_VX_M8_MASK + { 5, &RISCVDescs.OperandInfo[5541] }, // Inst #6373 = PseudoVMSGTU_VX_M8 + { 7, &RISCVDescs.OperandInfo[5778] }, // Inst #6372 = PseudoVMSGTU_VX_M4_MASK + { 5, &RISCVDescs.OperandInfo[5536] }, // Inst #6371 = PseudoVMSGTU_VX_M4 + { 7, &RISCVDescs.OperandInfo[5771] }, // Inst #6370 = PseudoVMSGTU_VX_M2_MASK + { 5, &RISCVDescs.OperandInfo[5531] }, // Inst #6369 = PseudoVMSGTU_VX_M2 + { 7, &RISCVDescs.OperandInfo[5764] }, // Inst #6368 = PseudoVMSGTU_VX_M1_MASK + { 5, &RISCVDescs.OperandInfo[5759] }, // Inst #6367 = PseudoVMSGTU_VX_M1 + { 7, &RISCVDescs.OperandInfo[5731] }, // Inst #6366 = PseudoVMSGTU_VI_MF8_MASK + { 5, &RISCVDescs.OperandInfo[5726] }, // Inst #6365 = PseudoVMSGTU_VI_MF8 + { 7, &RISCVDescs.OperandInfo[5731] }, // Inst #6364 = PseudoVMSGTU_VI_MF4_MASK + { 5, &RISCVDescs.OperandInfo[5726] }, // Inst #6363 = PseudoVMSGTU_VI_MF4 + { 7, &RISCVDescs.OperandInfo[5731] }, // Inst #6362 = PseudoVMSGTU_VI_MF2_MASK + { 5, &RISCVDescs.OperandInfo[5726] }, // Inst #6361 = PseudoVMSGTU_VI_MF2 + { 7, &RISCVDescs.OperandInfo[5752] }, // Inst #6360 = PseudoVMSGTU_VI_M8_MASK + { 5, &RISCVDescs.OperandInfo[5453] }, // Inst #6359 = PseudoVMSGTU_VI_M8 + { 7, &RISCVDescs.OperandInfo[5745] }, // Inst #6358 = PseudoVMSGTU_VI_M4_MASK + { 5, &RISCVDescs.OperandInfo[5448] }, // Inst #6357 = PseudoVMSGTU_VI_M4 + { 7, &RISCVDescs.OperandInfo[5738] }, // Inst #6356 = PseudoVMSGTU_VI_M2_MASK + { 5, &RISCVDescs.OperandInfo[5443] }, // Inst #6355 = PseudoVMSGTU_VI_M2 + { 7, &RISCVDescs.OperandInfo[5731] }, // Inst #6354 = PseudoVMSGTU_VI_M1_MASK + { 5, &RISCVDescs.OperandInfo[5726] }, // Inst #6353 = PseudoVMSGTU_VI_M1 + { 5, &RISCVDescs.OperandInfo[5803] }, // Inst #6352 = PseudoVMSGE_VX_M_T + { 4, &RISCVDescs.OperandInfo[5799] }, // Inst #6351 = PseudoVMSGE_VX_M + { 3, &RISCVDescs.OperandInfo[5796] }, // Inst #6350 = PseudoVMSGE_VX + { 4, &RISCVDescs.OperandInfo[5792] }, // Inst #6349 = PseudoVMSGE_VI + { 5, &RISCVDescs.OperandInfo[5803] }, // Inst #6348 = PseudoVMSGEU_VX_M_T + { 4, &RISCVDescs.OperandInfo[5799] }, // Inst #6347 = PseudoVMSGEU_VX_M + { 3, &RISCVDescs.OperandInfo[5796] }, // Inst #6346 = PseudoVMSGEU_VX + { 4, &RISCVDescs.OperandInfo[5792] }, // Inst #6345 = PseudoVMSGEU_VI + { 3, &RISCVDescs.OperandInfo[5551] }, // Inst #6344 = PseudoVMSET_M_B8 + { 3, &RISCVDescs.OperandInfo[5551] }, // Inst #6343 = PseudoVMSET_M_B64 + { 3, &RISCVDescs.OperandInfo[5551] }, // Inst #6342 = PseudoVMSET_M_B4 + { 3, &RISCVDescs.OperandInfo[5551] }, // Inst #6341 = PseudoVMSET_M_B32 + { 3, &RISCVDescs.OperandInfo[5551] }, // Inst #6340 = PseudoVMSET_M_B2 + { 3, &RISCVDescs.OperandInfo[5551] }, // Inst #6339 = PseudoVMSET_M_B16 + { 3, &RISCVDescs.OperandInfo[5551] }, // Inst #6338 = PseudoVMSET_M_B1 + { 7, &RISCVDescs.OperandInfo[5764] }, // Inst #6337 = PseudoVMSEQ_VX_MF8_MASK + { 5, &RISCVDescs.OperandInfo[5759] }, // Inst #6336 = PseudoVMSEQ_VX_MF8 + { 7, &RISCVDescs.OperandInfo[5764] }, // Inst #6335 = PseudoVMSEQ_VX_MF4_MASK + { 5, &RISCVDescs.OperandInfo[5759] }, // Inst #6334 = PseudoVMSEQ_VX_MF4 + { 7, &RISCVDescs.OperandInfo[5764] }, // Inst #6333 = PseudoVMSEQ_VX_MF2_MASK + { 5, &RISCVDescs.OperandInfo[5759] }, // Inst #6332 = PseudoVMSEQ_VX_MF2 + { 7, &RISCVDescs.OperandInfo[5785] }, // Inst #6331 = PseudoVMSEQ_VX_M8_MASK + { 5, &RISCVDescs.OperandInfo[5541] }, // Inst #6330 = PseudoVMSEQ_VX_M8 + { 7, &RISCVDescs.OperandInfo[5778] }, // Inst #6329 = PseudoVMSEQ_VX_M4_MASK + { 5, &RISCVDescs.OperandInfo[5536] }, // Inst #6328 = PseudoVMSEQ_VX_M4 + { 7, &RISCVDescs.OperandInfo[5771] }, // Inst #6327 = PseudoVMSEQ_VX_M2_MASK + { 5, &RISCVDescs.OperandInfo[5531] }, // Inst #6326 = PseudoVMSEQ_VX_M2 + { 7, &RISCVDescs.OperandInfo[5764] }, // Inst #6325 = PseudoVMSEQ_VX_M1_MASK + { 5, &RISCVDescs.OperandInfo[5759] }, // Inst #6324 = PseudoVMSEQ_VX_M1 + { 7, &RISCVDescs.OperandInfo[5698] }, // Inst #6323 = PseudoVMSEQ_VV_MF8_MASK + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6322 = PseudoVMSEQ_VV_MF8 + { 7, &RISCVDescs.OperandInfo[5698] }, // Inst #6321 = PseudoVMSEQ_VV_MF4_MASK + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6320 = PseudoVMSEQ_VV_MF4 + { 7, &RISCVDescs.OperandInfo[5698] }, // Inst #6319 = PseudoVMSEQ_VV_MF2_MASK + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6318 = PseudoVMSEQ_VV_MF2 + { 7, &RISCVDescs.OperandInfo[5719] }, // Inst #6317 = PseudoVMSEQ_VV_M8_MASK + { 5, &RISCVDescs.OperandInfo[5497] }, // Inst #6316 = PseudoVMSEQ_VV_M8 + { 7, &RISCVDescs.OperandInfo[5712] }, // Inst #6315 = PseudoVMSEQ_VV_M4_MASK + { 5, &RISCVDescs.OperandInfo[5492] }, // Inst #6314 = PseudoVMSEQ_VV_M4 + { 7, &RISCVDescs.OperandInfo[5705] }, // Inst #6313 = PseudoVMSEQ_VV_M2_MASK + { 5, &RISCVDescs.OperandInfo[5487] }, // Inst #6312 = PseudoVMSEQ_VV_M2 + { 7, &RISCVDescs.OperandInfo[5698] }, // Inst #6311 = PseudoVMSEQ_VV_M1_MASK + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6310 = PseudoVMSEQ_VV_M1 + { 7, &RISCVDescs.OperandInfo[5731] }, // Inst #6309 = PseudoVMSEQ_VI_MF8_MASK + { 5, &RISCVDescs.OperandInfo[5726] }, // Inst #6308 = PseudoVMSEQ_VI_MF8 + { 7, &RISCVDescs.OperandInfo[5731] }, // Inst #6307 = PseudoVMSEQ_VI_MF4_MASK + { 5, &RISCVDescs.OperandInfo[5726] }, // Inst #6306 = PseudoVMSEQ_VI_MF4 + { 7, &RISCVDescs.OperandInfo[5731] }, // Inst #6305 = PseudoVMSEQ_VI_MF2_MASK + { 5, &RISCVDescs.OperandInfo[5726] }, // Inst #6304 = PseudoVMSEQ_VI_MF2 + { 7, &RISCVDescs.OperandInfo[5752] }, // Inst #6303 = PseudoVMSEQ_VI_M8_MASK + { 5, &RISCVDescs.OperandInfo[5453] }, // Inst #6302 = PseudoVMSEQ_VI_M8 + { 7, &RISCVDescs.OperandInfo[5745] }, // Inst #6301 = PseudoVMSEQ_VI_M4_MASK + { 5, &RISCVDescs.OperandInfo[5448] }, // Inst #6300 = PseudoVMSEQ_VI_M4 + { 7, &RISCVDescs.OperandInfo[5738] }, // Inst #6299 = PseudoVMSEQ_VI_M2_MASK + { 5, &RISCVDescs.OperandInfo[5443] }, // Inst #6298 = PseudoVMSEQ_VI_M2 + { 7, &RISCVDescs.OperandInfo[5731] }, // Inst #6297 = PseudoVMSEQ_VI_M1_MASK + { 5, &RISCVDescs.OperandInfo[5726] }, // Inst #6296 = PseudoVMSEQ_VI_M1 + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #6295 = PseudoVMSBF_M_B8_MASK + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #6294 = PseudoVMSBF_M_B8 + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #6293 = PseudoVMSBF_M_B64_MASK + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #6292 = PseudoVMSBF_M_B64 + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #6291 = PseudoVMSBF_M_B4_MASK + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #6290 = PseudoVMSBF_M_B4 + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #6289 = PseudoVMSBF_M_B32_MASK + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #6288 = PseudoVMSBF_M_B32 + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #6287 = PseudoVMSBF_M_B2_MASK + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #6286 = PseudoVMSBF_M_B2 + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #6285 = PseudoVMSBF_M_B1_MASK + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #6284 = PseudoVMSBF_M_B16_MASK + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #6283 = PseudoVMSBF_M_B16 + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #6282 = PseudoVMSBF_M_B1 + { 5, &RISCVDescs.OperandInfo[5526] }, // Inst #6281 = PseudoVMSBC_VX_MF8 + { 5, &RISCVDescs.OperandInfo[5526] }, // Inst #6280 = PseudoVMSBC_VX_MF4 + { 5, &RISCVDescs.OperandInfo[5526] }, // Inst #6279 = PseudoVMSBC_VX_MF2 + { 5, &RISCVDescs.OperandInfo[5541] }, // Inst #6278 = PseudoVMSBC_VX_M8 + { 5, &RISCVDescs.OperandInfo[5536] }, // Inst #6277 = PseudoVMSBC_VX_M4 + { 5, &RISCVDescs.OperandInfo[5531] }, // Inst #6276 = PseudoVMSBC_VX_M2 + { 5, &RISCVDescs.OperandInfo[5526] }, // Inst #6275 = PseudoVMSBC_VX_M1 + { 6, &RISCVDescs.OperandInfo[5502] }, // Inst #6274 = PseudoVMSBC_VXM_MF8 + { 6, &RISCVDescs.OperandInfo[5502] }, // Inst #6273 = PseudoVMSBC_VXM_MF4 + { 6, &RISCVDescs.OperandInfo[5502] }, // Inst #6272 = PseudoVMSBC_VXM_MF2 + { 6, &RISCVDescs.OperandInfo[5520] }, // Inst #6271 = PseudoVMSBC_VXM_M8 + { 6, &RISCVDescs.OperandInfo[5514] }, // Inst #6270 = PseudoVMSBC_VXM_M4 + { 6, &RISCVDescs.OperandInfo[5508] }, // Inst #6269 = PseudoVMSBC_VXM_M2 + { 6, &RISCVDescs.OperandInfo[5502] }, // Inst #6268 = PseudoVMSBC_VXM_M1 + { 5, &RISCVDescs.OperandInfo[5482] }, // Inst #6267 = PseudoVMSBC_VV_MF8 + { 5, &RISCVDescs.OperandInfo[5482] }, // Inst #6266 = PseudoVMSBC_VV_MF4 + { 5, &RISCVDescs.OperandInfo[5482] }, // Inst #6265 = PseudoVMSBC_VV_MF2 + { 5, &RISCVDescs.OperandInfo[5497] }, // Inst #6264 = PseudoVMSBC_VV_M8 + { 5, &RISCVDescs.OperandInfo[5492] }, // Inst #6263 = PseudoVMSBC_VV_M4 + { 5, &RISCVDescs.OperandInfo[5487] }, // Inst #6262 = PseudoVMSBC_VV_M2 + { 5, &RISCVDescs.OperandInfo[5482] }, // Inst #6261 = PseudoVMSBC_VV_M1 + { 6, &RISCVDescs.OperandInfo[5458] }, // Inst #6260 = PseudoVMSBC_VVM_MF8 + { 6, &RISCVDescs.OperandInfo[5458] }, // Inst #6259 = PseudoVMSBC_VVM_MF4 + { 6, &RISCVDescs.OperandInfo[5458] }, // Inst #6258 = PseudoVMSBC_VVM_MF2 + { 6, &RISCVDescs.OperandInfo[5476] }, // Inst #6257 = PseudoVMSBC_VVM_M8 + { 6, &RISCVDescs.OperandInfo[5470] }, // Inst #6256 = PseudoVMSBC_VVM_M4 + { 6, &RISCVDescs.OperandInfo[5464] }, // Inst #6255 = PseudoVMSBC_VVM_M2 + { 6, &RISCVDescs.OperandInfo[5458] }, // Inst #6254 = PseudoVMSBC_VVM_M1 + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6253 = PseudoVMOR_MM_MF8 + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6252 = PseudoVMOR_MM_MF4 + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6251 = PseudoVMOR_MM_MF2 + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6250 = PseudoVMOR_MM_M8 + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6249 = PseudoVMOR_MM_M4 + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6248 = PseudoVMOR_MM_M2 + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6247 = PseudoVMOR_MM_M1 + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6246 = PseudoVMORN_MM_MF8 + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6245 = PseudoVMORN_MM_MF4 + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6244 = PseudoVMORN_MM_MF2 + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6243 = PseudoVMORN_MM_M8 + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6242 = PseudoVMORN_MM_M4 + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6241 = PseudoVMORN_MM_M2 + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6240 = PseudoVMORN_MM_M1 + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6239 = PseudoVMNOR_MM_MF8 + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6238 = PseudoVMNOR_MM_MF4 + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6237 = PseudoVMNOR_MM_MF2 + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6236 = PseudoVMNOR_MM_M8 + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6235 = PseudoVMNOR_MM_M4 + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6234 = PseudoVMNOR_MM_M2 + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6233 = PseudoVMNOR_MM_M1 + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6232 = PseudoVMNAND_MM_MF8 + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6231 = PseudoVMNAND_MM_MF4 + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6230 = PseudoVMNAND_MM_MF2 + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6229 = PseudoVMNAND_MM_M8 + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6228 = PseudoVMNAND_MM_M4 + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6227 = PseudoVMNAND_MM_M2 + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6226 = PseudoVMNAND_MM_M1 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #6225 = PseudoVMIN_VX_MF8_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #6224 = PseudoVMIN_VX_MF8 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #6223 = PseudoVMIN_VX_MF4_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #6222 = PseudoVMIN_VX_MF4 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #6221 = PseudoVMIN_VX_MF2_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #6220 = PseudoVMIN_VX_MF2 + { 8, &RISCVDescs.OperandInfo[809] }, // Inst #6219 = PseudoVMIN_VX_M8_MASK + { 7, &RISCVDescs.OperandInfo[802] }, // Inst #6218 = PseudoVMIN_VX_M8 + { 8, &RISCVDescs.OperandInfo[794] }, // Inst #6217 = PseudoVMIN_VX_M4_MASK + { 7, &RISCVDescs.OperandInfo[787] }, // Inst #6216 = PseudoVMIN_VX_M4 + { 8, &RISCVDescs.OperandInfo[779] }, // Inst #6215 = PseudoVMIN_VX_M2_MASK + { 7, &RISCVDescs.OperandInfo[772] }, // Inst #6214 = PseudoVMIN_VX_M2 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #6213 = PseudoVMIN_VX_M1_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #6212 = PseudoVMIN_VX_M1 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #6211 = PseudoVMIN_VV_MF8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #6210 = PseudoVMIN_VV_MF8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #6209 = PseudoVMIN_VV_MF4_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #6208 = PseudoVMIN_VV_MF4 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #6207 = PseudoVMIN_VV_MF2_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #6206 = PseudoVMIN_VV_MF2 + { 8, &RISCVDescs.OperandInfo[749] }, // Inst #6205 = PseudoVMIN_VV_M8_MASK + { 7, &RISCVDescs.OperandInfo[742] }, // Inst #6204 = PseudoVMIN_VV_M8 + { 8, &RISCVDescs.OperandInfo[734] }, // Inst #6203 = PseudoVMIN_VV_M4_MASK + { 7, &RISCVDescs.OperandInfo[727] }, // Inst #6202 = PseudoVMIN_VV_M4 + { 8, &RISCVDescs.OperandInfo[719] }, // Inst #6201 = PseudoVMIN_VV_M2_MASK + { 7, &RISCVDescs.OperandInfo[712] }, // Inst #6200 = PseudoVMIN_VV_M2 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #6199 = PseudoVMIN_VV_M1_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #6198 = PseudoVMIN_VV_M1 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #6197 = PseudoVMINU_VX_MF8_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #6196 = PseudoVMINU_VX_MF8 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #6195 = PseudoVMINU_VX_MF4_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #6194 = PseudoVMINU_VX_MF4 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #6193 = PseudoVMINU_VX_MF2_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #6192 = PseudoVMINU_VX_MF2 + { 8, &RISCVDescs.OperandInfo[809] }, // Inst #6191 = PseudoVMINU_VX_M8_MASK + { 7, &RISCVDescs.OperandInfo[802] }, // Inst #6190 = PseudoVMINU_VX_M8 + { 8, &RISCVDescs.OperandInfo[794] }, // Inst #6189 = PseudoVMINU_VX_M4_MASK + { 7, &RISCVDescs.OperandInfo[787] }, // Inst #6188 = PseudoVMINU_VX_M4 + { 8, &RISCVDescs.OperandInfo[779] }, // Inst #6187 = PseudoVMINU_VX_M2_MASK + { 7, &RISCVDescs.OperandInfo[772] }, // Inst #6186 = PseudoVMINU_VX_M2 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #6185 = PseudoVMINU_VX_M1_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #6184 = PseudoVMINU_VX_M1 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #6183 = PseudoVMINU_VV_MF8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #6182 = PseudoVMINU_VV_MF8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #6181 = PseudoVMINU_VV_MF4_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #6180 = PseudoVMINU_VV_MF4 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #6179 = PseudoVMINU_VV_MF2_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #6178 = PseudoVMINU_VV_MF2 + { 8, &RISCVDescs.OperandInfo[749] }, // Inst #6177 = PseudoVMINU_VV_M8_MASK + { 7, &RISCVDescs.OperandInfo[742] }, // Inst #6176 = PseudoVMINU_VV_M8 + { 8, &RISCVDescs.OperandInfo[734] }, // Inst #6175 = PseudoVMINU_VV_M4_MASK + { 7, &RISCVDescs.OperandInfo[727] }, // Inst #6174 = PseudoVMINU_VV_M4 + { 8, &RISCVDescs.OperandInfo[719] }, // Inst #6173 = PseudoVMINU_VV_M2_MASK + { 7, &RISCVDescs.OperandInfo[712] }, // Inst #6172 = PseudoVMINU_VV_M2 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #6171 = PseudoVMINU_VV_M1_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #6170 = PseudoVMINU_VV_M1 + { 7, &RISCVDescs.OperandInfo[5698] }, // Inst #6169 = PseudoVMFNE_VV_MF4_MASK + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6168 = PseudoVMFNE_VV_MF4 + { 7, &RISCVDescs.OperandInfo[5698] }, // Inst #6167 = PseudoVMFNE_VV_MF2_MASK + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6166 = PseudoVMFNE_VV_MF2 + { 7, &RISCVDescs.OperandInfo[5719] }, // Inst #6165 = PseudoVMFNE_VV_M8_MASK + { 5, &RISCVDescs.OperandInfo[5497] }, // Inst #6164 = PseudoVMFNE_VV_M8 + { 7, &RISCVDescs.OperandInfo[5712] }, // Inst #6163 = PseudoVMFNE_VV_M4_MASK + { 5, &RISCVDescs.OperandInfo[5492] }, // Inst #6162 = PseudoVMFNE_VV_M4 + { 7, &RISCVDescs.OperandInfo[5705] }, // Inst #6161 = PseudoVMFNE_VV_M2_MASK + { 5, &RISCVDescs.OperandInfo[5487] }, // Inst #6160 = PseudoVMFNE_VV_M2 + { 7, &RISCVDescs.OperandInfo[5698] }, // Inst #6159 = PseudoVMFNE_VV_M1_MASK + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6158 = PseudoVMFNE_VV_M1 + { 7, &RISCVDescs.OperandInfo[5691] }, // Inst #6157 = PseudoVMFNE_VFPR64_M8_MASK + { 5, &RISCVDescs.OperandInfo[5686] }, // Inst #6156 = PseudoVMFNE_VFPR64_M8 + { 7, &RISCVDescs.OperandInfo[5679] }, // Inst #6155 = PseudoVMFNE_VFPR64_M4_MASK + { 5, &RISCVDescs.OperandInfo[5674] }, // Inst #6154 = PseudoVMFNE_VFPR64_M4 + { 7, &RISCVDescs.OperandInfo[5667] }, // Inst #6153 = PseudoVMFNE_VFPR64_M2_MASK + { 5, &RISCVDescs.OperandInfo[5662] }, // Inst #6152 = PseudoVMFNE_VFPR64_M2 + { 7, &RISCVDescs.OperandInfo[5655] }, // Inst #6151 = PseudoVMFNE_VFPR64_M1_MASK + { 5, &RISCVDescs.OperandInfo[5650] }, // Inst #6150 = PseudoVMFNE_VFPR64_M1 + { 7, &RISCVDescs.OperandInfo[5607] }, // Inst #6149 = PseudoVMFNE_VFPR32_MF2_MASK + { 5, &RISCVDescs.OperandInfo[5602] }, // Inst #6148 = PseudoVMFNE_VFPR32_MF2 + { 7, &RISCVDescs.OperandInfo[5643] }, // Inst #6147 = PseudoVMFNE_VFPR32_M8_MASK + { 5, &RISCVDescs.OperandInfo[5638] }, // Inst #6146 = PseudoVMFNE_VFPR32_M8 + { 7, &RISCVDescs.OperandInfo[5631] }, // Inst #6145 = PseudoVMFNE_VFPR32_M4_MASK + { 5, &RISCVDescs.OperandInfo[5626] }, // Inst #6144 = PseudoVMFNE_VFPR32_M4 + { 7, &RISCVDescs.OperandInfo[5619] }, // Inst #6143 = PseudoVMFNE_VFPR32_M2_MASK + { 5, &RISCVDescs.OperandInfo[5614] }, // Inst #6142 = PseudoVMFNE_VFPR32_M2 + { 7, &RISCVDescs.OperandInfo[5607] }, // Inst #6141 = PseudoVMFNE_VFPR32_M1_MASK + { 5, &RISCVDescs.OperandInfo[5602] }, // Inst #6140 = PseudoVMFNE_VFPR32_M1 + { 7, &RISCVDescs.OperandInfo[5559] }, // Inst #6139 = PseudoVMFNE_VFPR16_MF4_MASK + { 5, &RISCVDescs.OperandInfo[5554] }, // Inst #6138 = PseudoVMFNE_VFPR16_MF4 + { 7, &RISCVDescs.OperandInfo[5559] }, // Inst #6137 = PseudoVMFNE_VFPR16_MF2_MASK + { 5, &RISCVDescs.OperandInfo[5554] }, // Inst #6136 = PseudoVMFNE_VFPR16_MF2 + { 7, &RISCVDescs.OperandInfo[5595] }, // Inst #6135 = PseudoVMFNE_VFPR16_M8_MASK + { 5, &RISCVDescs.OperandInfo[5590] }, // Inst #6134 = PseudoVMFNE_VFPR16_M8 + { 7, &RISCVDescs.OperandInfo[5583] }, // Inst #6133 = PseudoVMFNE_VFPR16_M4_MASK + { 5, &RISCVDescs.OperandInfo[5578] }, // Inst #6132 = PseudoVMFNE_VFPR16_M4 + { 7, &RISCVDescs.OperandInfo[5571] }, // Inst #6131 = PseudoVMFNE_VFPR16_M2_MASK + { 5, &RISCVDescs.OperandInfo[5566] }, // Inst #6130 = PseudoVMFNE_VFPR16_M2 + { 7, &RISCVDescs.OperandInfo[5559] }, // Inst #6129 = PseudoVMFNE_VFPR16_M1_MASK + { 5, &RISCVDescs.OperandInfo[5554] }, // Inst #6128 = PseudoVMFNE_VFPR16_M1 + { 7, &RISCVDescs.OperandInfo[5698] }, // Inst #6127 = PseudoVMFLT_VV_MF4_MASK + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6126 = PseudoVMFLT_VV_MF4 + { 7, &RISCVDescs.OperandInfo[5698] }, // Inst #6125 = PseudoVMFLT_VV_MF2_MASK + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6124 = PseudoVMFLT_VV_MF2 + { 7, &RISCVDescs.OperandInfo[5719] }, // Inst #6123 = PseudoVMFLT_VV_M8_MASK + { 5, &RISCVDescs.OperandInfo[5497] }, // Inst #6122 = PseudoVMFLT_VV_M8 + { 7, &RISCVDescs.OperandInfo[5712] }, // Inst #6121 = PseudoVMFLT_VV_M4_MASK + { 5, &RISCVDescs.OperandInfo[5492] }, // Inst #6120 = PseudoVMFLT_VV_M4 + { 7, &RISCVDescs.OperandInfo[5705] }, // Inst #6119 = PseudoVMFLT_VV_M2_MASK + { 5, &RISCVDescs.OperandInfo[5487] }, // Inst #6118 = PseudoVMFLT_VV_M2 + { 7, &RISCVDescs.OperandInfo[5698] }, // Inst #6117 = PseudoVMFLT_VV_M1_MASK + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6116 = PseudoVMFLT_VV_M1 + { 7, &RISCVDescs.OperandInfo[5691] }, // Inst #6115 = PseudoVMFLT_VFPR64_M8_MASK + { 5, &RISCVDescs.OperandInfo[5686] }, // Inst #6114 = PseudoVMFLT_VFPR64_M8 + { 7, &RISCVDescs.OperandInfo[5679] }, // Inst #6113 = PseudoVMFLT_VFPR64_M4_MASK + { 5, &RISCVDescs.OperandInfo[5674] }, // Inst #6112 = PseudoVMFLT_VFPR64_M4 + { 7, &RISCVDescs.OperandInfo[5667] }, // Inst #6111 = PseudoVMFLT_VFPR64_M2_MASK + { 5, &RISCVDescs.OperandInfo[5662] }, // Inst #6110 = PseudoVMFLT_VFPR64_M2 + { 7, &RISCVDescs.OperandInfo[5655] }, // Inst #6109 = PseudoVMFLT_VFPR64_M1_MASK + { 5, &RISCVDescs.OperandInfo[5650] }, // Inst #6108 = PseudoVMFLT_VFPR64_M1 + { 7, &RISCVDescs.OperandInfo[5607] }, // Inst #6107 = PseudoVMFLT_VFPR32_MF2_MASK + { 5, &RISCVDescs.OperandInfo[5602] }, // Inst #6106 = PseudoVMFLT_VFPR32_MF2 + { 7, &RISCVDescs.OperandInfo[5643] }, // Inst #6105 = PseudoVMFLT_VFPR32_M8_MASK + { 5, &RISCVDescs.OperandInfo[5638] }, // Inst #6104 = PseudoVMFLT_VFPR32_M8 + { 7, &RISCVDescs.OperandInfo[5631] }, // Inst #6103 = PseudoVMFLT_VFPR32_M4_MASK + { 5, &RISCVDescs.OperandInfo[5626] }, // Inst #6102 = PseudoVMFLT_VFPR32_M4 + { 7, &RISCVDescs.OperandInfo[5619] }, // Inst #6101 = PseudoVMFLT_VFPR32_M2_MASK + { 5, &RISCVDescs.OperandInfo[5614] }, // Inst #6100 = PseudoVMFLT_VFPR32_M2 + { 7, &RISCVDescs.OperandInfo[5607] }, // Inst #6099 = PseudoVMFLT_VFPR32_M1_MASK + { 5, &RISCVDescs.OperandInfo[5602] }, // Inst #6098 = PseudoVMFLT_VFPR32_M1 + { 7, &RISCVDescs.OperandInfo[5559] }, // Inst #6097 = PseudoVMFLT_VFPR16_MF4_MASK + { 5, &RISCVDescs.OperandInfo[5554] }, // Inst #6096 = PseudoVMFLT_VFPR16_MF4 + { 7, &RISCVDescs.OperandInfo[5559] }, // Inst #6095 = PseudoVMFLT_VFPR16_MF2_MASK + { 5, &RISCVDescs.OperandInfo[5554] }, // Inst #6094 = PseudoVMFLT_VFPR16_MF2 + { 7, &RISCVDescs.OperandInfo[5595] }, // Inst #6093 = PseudoVMFLT_VFPR16_M8_MASK + { 5, &RISCVDescs.OperandInfo[5590] }, // Inst #6092 = PseudoVMFLT_VFPR16_M8 + { 7, &RISCVDescs.OperandInfo[5583] }, // Inst #6091 = PseudoVMFLT_VFPR16_M4_MASK + { 5, &RISCVDescs.OperandInfo[5578] }, // Inst #6090 = PseudoVMFLT_VFPR16_M4 + { 7, &RISCVDescs.OperandInfo[5571] }, // Inst #6089 = PseudoVMFLT_VFPR16_M2_MASK + { 5, &RISCVDescs.OperandInfo[5566] }, // Inst #6088 = PseudoVMFLT_VFPR16_M2 + { 7, &RISCVDescs.OperandInfo[5559] }, // Inst #6087 = PseudoVMFLT_VFPR16_M1_MASK + { 5, &RISCVDescs.OperandInfo[5554] }, // Inst #6086 = PseudoVMFLT_VFPR16_M1 + { 7, &RISCVDescs.OperandInfo[5698] }, // Inst #6085 = PseudoVMFLE_VV_MF4_MASK + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6084 = PseudoVMFLE_VV_MF4 + { 7, &RISCVDescs.OperandInfo[5698] }, // Inst #6083 = PseudoVMFLE_VV_MF2_MASK + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6082 = PseudoVMFLE_VV_MF2 + { 7, &RISCVDescs.OperandInfo[5719] }, // Inst #6081 = PseudoVMFLE_VV_M8_MASK + { 5, &RISCVDescs.OperandInfo[5497] }, // Inst #6080 = PseudoVMFLE_VV_M8 + { 7, &RISCVDescs.OperandInfo[5712] }, // Inst #6079 = PseudoVMFLE_VV_M4_MASK + { 5, &RISCVDescs.OperandInfo[5492] }, // Inst #6078 = PseudoVMFLE_VV_M4 + { 7, &RISCVDescs.OperandInfo[5705] }, // Inst #6077 = PseudoVMFLE_VV_M2_MASK + { 5, &RISCVDescs.OperandInfo[5487] }, // Inst #6076 = PseudoVMFLE_VV_M2 + { 7, &RISCVDescs.OperandInfo[5698] }, // Inst #6075 = PseudoVMFLE_VV_M1_MASK + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #6074 = PseudoVMFLE_VV_M1 + { 7, &RISCVDescs.OperandInfo[5691] }, // Inst #6073 = PseudoVMFLE_VFPR64_M8_MASK + { 5, &RISCVDescs.OperandInfo[5686] }, // Inst #6072 = PseudoVMFLE_VFPR64_M8 + { 7, &RISCVDescs.OperandInfo[5679] }, // Inst #6071 = PseudoVMFLE_VFPR64_M4_MASK + { 5, &RISCVDescs.OperandInfo[5674] }, // Inst #6070 = PseudoVMFLE_VFPR64_M4 + { 7, &RISCVDescs.OperandInfo[5667] }, // Inst #6069 = PseudoVMFLE_VFPR64_M2_MASK + { 5, &RISCVDescs.OperandInfo[5662] }, // Inst #6068 = PseudoVMFLE_VFPR64_M2 + { 7, &RISCVDescs.OperandInfo[5655] }, // Inst #6067 = PseudoVMFLE_VFPR64_M1_MASK + { 5, &RISCVDescs.OperandInfo[5650] }, // Inst #6066 = PseudoVMFLE_VFPR64_M1 + { 7, &RISCVDescs.OperandInfo[5607] }, // Inst #6065 = PseudoVMFLE_VFPR32_MF2_MASK + { 5, &RISCVDescs.OperandInfo[5602] }, // Inst #6064 = PseudoVMFLE_VFPR32_MF2 + { 7, &RISCVDescs.OperandInfo[5643] }, // Inst #6063 = PseudoVMFLE_VFPR32_M8_MASK + { 5, &RISCVDescs.OperandInfo[5638] }, // Inst #6062 = PseudoVMFLE_VFPR32_M8 + { 7, &RISCVDescs.OperandInfo[5631] }, // Inst #6061 = PseudoVMFLE_VFPR32_M4_MASK + { 5, &RISCVDescs.OperandInfo[5626] }, // Inst #6060 = PseudoVMFLE_VFPR32_M4 + { 7, &RISCVDescs.OperandInfo[5619] }, // Inst #6059 = PseudoVMFLE_VFPR32_M2_MASK + { 5, &RISCVDescs.OperandInfo[5614] }, // Inst #6058 = PseudoVMFLE_VFPR32_M2 + { 7, &RISCVDescs.OperandInfo[5607] }, // Inst #6057 = PseudoVMFLE_VFPR32_M1_MASK + { 5, &RISCVDescs.OperandInfo[5602] }, // Inst #6056 = PseudoVMFLE_VFPR32_M1 + { 7, &RISCVDescs.OperandInfo[5559] }, // Inst #6055 = PseudoVMFLE_VFPR16_MF4_MASK + { 5, &RISCVDescs.OperandInfo[5554] }, // Inst #6054 = PseudoVMFLE_VFPR16_MF4 + { 7, &RISCVDescs.OperandInfo[5559] }, // Inst #6053 = PseudoVMFLE_VFPR16_MF2_MASK + { 5, &RISCVDescs.OperandInfo[5554] }, // Inst #6052 = PseudoVMFLE_VFPR16_MF2 + { 7, &RISCVDescs.OperandInfo[5595] }, // Inst #6051 = PseudoVMFLE_VFPR16_M8_MASK + { 5, &RISCVDescs.OperandInfo[5590] }, // Inst #6050 = PseudoVMFLE_VFPR16_M8 + { 7, &RISCVDescs.OperandInfo[5583] }, // Inst #6049 = PseudoVMFLE_VFPR16_M4_MASK + { 5, &RISCVDescs.OperandInfo[5578] }, // Inst #6048 = PseudoVMFLE_VFPR16_M4 + { 7, &RISCVDescs.OperandInfo[5571] }, // Inst #6047 = PseudoVMFLE_VFPR16_M2_MASK + { 5, &RISCVDescs.OperandInfo[5566] }, // Inst #6046 = PseudoVMFLE_VFPR16_M2 + { 7, &RISCVDescs.OperandInfo[5559] }, // Inst #6045 = PseudoVMFLE_VFPR16_M1_MASK + { 5, &RISCVDescs.OperandInfo[5554] }, // Inst #6044 = PseudoVMFLE_VFPR16_M1 + { 7, &RISCVDescs.OperandInfo[5691] }, // Inst #6043 = PseudoVMFGT_VFPR64_M8_MASK + { 5, &RISCVDescs.OperandInfo[5686] }, // Inst #6042 = PseudoVMFGT_VFPR64_M8 + { 7, &RISCVDescs.OperandInfo[5679] }, // Inst #6041 = PseudoVMFGT_VFPR64_M4_MASK + { 5, &RISCVDescs.OperandInfo[5674] }, // Inst #6040 = PseudoVMFGT_VFPR64_M4 + { 7, &RISCVDescs.OperandInfo[5667] }, // Inst #6039 = PseudoVMFGT_VFPR64_M2_MASK + { 5, &RISCVDescs.OperandInfo[5662] }, // Inst #6038 = PseudoVMFGT_VFPR64_M2 + { 7, &RISCVDescs.OperandInfo[5655] }, // Inst #6037 = PseudoVMFGT_VFPR64_M1_MASK + { 5, &RISCVDescs.OperandInfo[5650] }, // Inst #6036 = PseudoVMFGT_VFPR64_M1 + { 7, &RISCVDescs.OperandInfo[5607] }, // Inst #6035 = PseudoVMFGT_VFPR32_MF2_MASK + { 5, &RISCVDescs.OperandInfo[5602] }, // Inst #6034 = PseudoVMFGT_VFPR32_MF2 + { 7, &RISCVDescs.OperandInfo[5643] }, // Inst #6033 = PseudoVMFGT_VFPR32_M8_MASK + { 5, &RISCVDescs.OperandInfo[5638] }, // Inst #6032 = PseudoVMFGT_VFPR32_M8 + { 7, &RISCVDescs.OperandInfo[5631] }, // Inst #6031 = PseudoVMFGT_VFPR32_M4_MASK + { 5, &RISCVDescs.OperandInfo[5626] }, // Inst #6030 = PseudoVMFGT_VFPR32_M4 + { 7, &RISCVDescs.OperandInfo[5619] }, // Inst #6029 = PseudoVMFGT_VFPR32_M2_MASK + { 5, &RISCVDescs.OperandInfo[5614] }, // Inst #6028 = PseudoVMFGT_VFPR32_M2 + { 7, &RISCVDescs.OperandInfo[5607] }, // Inst #6027 = PseudoVMFGT_VFPR32_M1_MASK + { 5, &RISCVDescs.OperandInfo[5602] }, // Inst #6026 = PseudoVMFGT_VFPR32_M1 + { 7, &RISCVDescs.OperandInfo[5559] }, // Inst #6025 = PseudoVMFGT_VFPR16_MF4_MASK + { 5, &RISCVDescs.OperandInfo[5554] }, // Inst #6024 = PseudoVMFGT_VFPR16_MF4 + { 7, &RISCVDescs.OperandInfo[5559] }, // Inst #6023 = PseudoVMFGT_VFPR16_MF2_MASK + { 5, &RISCVDescs.OperandInfo[5554] }, // Inst #6022 = PseudoVMFGT_VFPR16_MF2 + { 7, &RISCVDescs.OperandInfo[5595] }, // Inst #6021 = PseudoVMFGT_VFPR16_M8_MASK + { 5, &RISCVDescs.OperandInfo[5590] }, // Inst #6020 = PseudoVMFGT_VFPR16_M8 + { 7, &RISCVDescs.OperandInfo[5583] }, // Inst #6019 = PseudoVMFGT_VFPR16_M4_MASK + { 5, &RISCVDescs.OperandInfo[5578] }, // Inst #6018 = PseudoVMFGT_VFPR16_M4 + { 7, &RISCVDescs.OperandInfo[5571] }, // Inst #6017 = PseudoVMFGT_VFPR16_M2_MASK + { 5, &RISCVDescs.OperandInfo[5566] }, // Inst #6016 = PseudoVMFGT_VFPR16_M2 + { 7, &RISCVDescs.OperandInfo[5559] }, // Inst #6015 = PseudoVMFGT_VFPR16_M1_MASK + { 5, &RISCVDescs.OperandInfo[5554] }, // Inst #6014 = PseudoVMFGT_VFPR16_M1 + { 7, &RISCVDescs.OperandInfo[5691] }, // Inst #6013 = PseudoVMFGE_VFPR64_M8_MASK + { 5, &RISCVDescs.OperandInfo[5686] }, // Inst #6012 = PseudoVMFGE_VFPR64_M8 + { 7, &RISCVDescs.OperandInfo[5679] }, // Inst #6011 = PseudoVMFGE_VFPR64_M4_MASK + { 5, &RISCVDescs.OperandInfo[5674] }, // Inst #6010 = PseudoVMFGE_VFPR64_M4 + { 7, &RISCVDescs.OperandInfo[5667] }, // Inst #6009 = PseudoVMFGE_VFPR64_M2_MASK + { 5, &RISCVDescs.OperandInfo[5662] }, // Inst #6008 = PseudoVMFGE_VFPR64_M2 + { 7, &RISCVDescs.OperandInfo[5655] }, // Inst #6007 = PseudoVMFGE_VFPR64_M1_MASK + { 5, &RISCVDescs.OperandInfo[5650] }, // Inst #6006 = PseudoVMFGE_VFPR64_M1 + { 7, &RISCVDescs.OperandInfo[5607] }, // Inst #6005 = PseudoVMFGE_VFPR32_MF2_MASK + { 5, &RISCVDescs.OperandInfo[5602] }, // Inst #6004 = PseudoVMFGE_VFPR32_MF2 + { 7, &RISCVDescs.OperandInfo[5643] }, // Inst #6003 = PseudoVMFGE_VFPR32_M8_MASK + { 5, &RISCVDescs.OperandInfo[5638] }, // Inst #6002 = PseudoVMFGE_VFPR32_M8 + { 7, &RISCVDescs.OperandInfo[5631] }, // Inst #6001 = PseudoVMFGE_VFPR32_M4_MASK + { 5, &RISCVDescs.OperandInfo[5626] }, // Inst #6000 = PseudoVMFGE_VFPR32_M4 + { 7, &RISCVDescs.OperandInfo[5619] }, // Inst #5999 = PseudoVMFGE_VFPR32_M2_MASK + { 5, &RISCVDescs.OperandInfo[5614] }, // Inst #5998 = PseudoVMFGE_VFPR32_M2 + { 7, &RISCVDescs.OperandInfo[5607] }, // Inst #5997 = PseudoVMFGE_VFPR32_M1_MASK + { 5, &RISCVDescs.OperandInfo[5602] }, // Inst #5996 = PseudoVMFGE_VFPR32_M1 + { 7, &RISCVDescs.OperandInfo[5559] }, // Inst #5995 = PseudoVMFGE_VFPR16_MF4_MASK + { 5, &RISCVDescs.OperandInfo[5554] }, // Inst #5994 = PseudoVMFGE_VFPR16_MF4 + { 7, &RISCVDescs.OperandInfo[5559] }, // Inst #5993 = PseudoVMFGE_VFPR16_MF2_MASK + { 5, &RISCVDescs.OperandInfo[5554] }, // Inst #5992 = PseudoVMFGE_VFPR16_MF2 + { 7, &RISCVDescs.OperandInfo[5595] }, // Inst #5991 = PseudoVMFGE_VFPR16_M8_MASK + { 5, &RISCVDescs.OperandInfo[5590] }, // Inst #5990 = PseudoVMFGE_VFPR16_M8 + { 7, &RISCVDescs.OperandInfo[5583] }, // Inst #5989 = PseudoVMFGE_VFPR16_M4_MASK + { 5, &RISCVDescs.OperandInfo[5578] }, // Inst #5988 = PseudoVMFGE_VFPR16_M4 + { 7, &RISCVDescs.OperandInfo[5571] }, // Inst #5987 = PseudoVMFGE_VFPR16_M2_MASK + { 5, &RISCVDescs.OperandInfo[5566] }, // Inst #5986 = PseudoVMFGE_VFPR16_M2 + { 7, &RISCVDescs.OperandInfo[5559] }, // Inst #5985 = PseudoVMFGE_VFPR16_M1_MASK + { 5, &RISCVDescs.OperandInfo[5554] }, // Inst #5984 = PseudoVMFGE_VFPR16_M1 + { 7, &RISCVDescs.OperandInfo[5698] }, // Inst #5983 = PseudoVMFEQ_VV_MF4_MASK + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #5982 = PseudoVMFEQ_VV_MF4 + { 7, &RISCVDescs.OperandInfo[5698] }, // Inst #5981 = PseudoVMFEQ_VV_MF2_MASK + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #5980 = PseudoVMFEQ_VV_MF2 + { 7, &RISCVDescs.OperandInfo[5719] }, // Inst #5979 = PseudoVMFEQ_VV_M8_MASK + { 5, &RISCVDescs.OperandInfo[5497] }, // Inst #5978 = PseudoVMFEQ_VV_M8 + { 7, &RISCVDescs.OperandInfo[5712] }, // Inst #5977 = PseudoVMFEQ_VV_M4_MASK + { 5, &RISCVDescs.OperandInfo[5492] }, // Inst #5976 = PseudoVMFEQ_VV_M4 + { 7, &RISCVDescs.OperandInfo[5705] }, // Inst #5975 = PseudoVMFEQ_VV_M2_MASK + { 5, &RISCVDescs.OperandInfo[5487] }, // Inst #5974 = PseudoVMFEQ_VV_M2 + { 7, &RISCVDescs.OperandInfo[5698] }, // Inst #5973 = PseudoVMFEQ_VV_M1_MASK + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #5972 = PseudoVMFEQ_VV_M1 + { 7, &RISCVDescs.OperandInfo[5691] }, // Inst #5971 = PseudoVMFEQ_VFPR64_M8_MASK + { 5, &RISCVDescs.OperandInfo[5686] }, // Inst #5970 = PseudoVMFEQ_VFPR64_M8 + { 7, &RISCVDescs.OperandInfo[5679] }, // Inst #5969 = PseudoVMFEQ_VFPR64_M4_MASK + { 5, &RISCVDescs.OperandInfo[5674] }, // Inst #5968 = PseudoVMFEQ_VFPR64_M4 + { 7, &RISCVDescs.OperandInfo[5667] }, // Inst #5967 = PseudoVMFEQ_VFPR64_M2_MASK + { 5, &RISCVDescs.OperandInfo[5662] }, // Inst #5966 = PseudoVMFEQ_VFPR64_M2 + { 7, &RISCVDescs.OperandInfo[5655] }, // Inst #5965 = PseudoVMFEQ_VFPR64_M1_MASK + { 5, &RISCVDescs.OperandInfo[5650] }, // Inst #5964 = PseudoVMFEQ_VFPR64_M1 + { 7, &RISCVDescs.OperandInfo[5607] }, // Inst #5963 = PseudoVMFEQ_VFPR32_MF2_MASK + { 5, &RISCVDescs.OperandInfo[5602] }, // Inst #5962 = PseudoVMFEQ_VFPR32_MF2 + { 7, &RISCVDescs.OperandInfo[5643] }, // Inst #5961 = PseudoVMFEQ_VFPR32_M8_MASK + { 5, &RISCVDescs.OperandInfo[5638] }, // Inst #5960 = PseudoVMFEQ_VFPR32_M8 + { 7, &RISCVDescs.OperandInfo[5631] }, // Inst #5959 = PseudoVMFEQ_VFPR32_M4_MASK + { 5, &RISCVDescs.OperandInfo[5626] }, // Inst #5958 = PseudoVMFEQ_VFPR32_M4 + { 7, &RISCVDescs.OperandInfo[5619] }, // Inst #5957 = PseudoVMFEQ_VFPR32_M2_MASK + { 5, &RISCVDescs.OperandInfo[5614] }, // Inst #5956 = PseudoVMFEQ_VFPR32_M2 + { 7, &RISCVDescs.OperandInfo[5607] }, // Inst #5955 = PseudoVMFEQ_VFPR32_M1_MASK + { 5, &RISCVDescs.OperandInfo[5602] }, // Inst #5954 = PseudoVMFEQ_VFPR32_M1 + { 7, &RISCVDescs.OperandInfo[5559] }, // Inst #5953 = PseudoVMFEQ_VFPR16_MF4_MASK + { 5, &RISCVDescs.OperandInfo[5554] }, // Inst #5952 = PseudoVMFEQ_VFPR16_MF4 + { 7, &RISCVDescs.OperandInfo[5559] }, // Inst #5951 = PseudoVMFEQ_VFPR16_MF2_MASK + { 5, &RISCVDescs.OperandInfo[5554] }, // Inst #5950 = PseudoVMFEQ_VFPR16_MF2 + { 7, &RISCVDescs.OperandInfo[5595] }, // Inst #5949 = PseudoVMFEQ_VFPR16_M8_MASK + { 5, &RISCVDescs.OperandInfo[5590] }, // Inst #5948 = PseudoVMFEQ_VFPR16_M8 + { 7, &RISCVDescs.OperandInfo[5583] }, // Inst #5947 = PseudoVMFEQ_VFPR16_M4_MASK + { 5, &RISCVDescs.OperandInfo[5578] }, // Inst #5946 = PseudoVMFEQ_VFPR16_M4 + { 7, &RISCVDescs.OperandInfo[5571] }, // Inst #5945 = PseudoVMFEQ_VFPR16_M2_MASK + { 5, &RISCVDescs.OperandInfo[5566] }, // Inst #5944 = PseudoVMFEQ_VFPR16_M2 + { 7, &RISCVDescs.OperandInfo[5559] }, // Inst #5943 = PseudoVMFEQ_VFPR16_M1_MASK + { 5, &RISCVDescs.OperandInfo[5554] }, // Inst #5942 = PseudoVMFEQ_VFPR16_M1 + { 7, &RISCVDescs.OperandInfo[609] }, // Inst #5941 = PseudoVMERGE_VXM_MF8 + { 7, &RISCVDescs.OperandInfo[609] }, // Inst #5940 = PseudoVMERGE_VXM_MF4 + { 7, &RISCVDescs.OperandInfo[609] }, // Inst #5939 = PseudoVMERGE_VXM_MF2 + { 7, &RISCVDescs.OperandInfo[630] }, // Inst #5938 = PseudoVMERGE_VXM_M8 + { 7, &RISCVDescs.OperandInfo[623] }, // Inst #5937 = PseudoVMERGE_VXM_M4 + { 7, &RISCVDescs.OperandInfo[616] }, // Inst #5936 = PseudoVMERGE_VXM_M2 + { 7, &RISCVDescs.OperandInfo[609] }, // Inst #5935 = PseudoVMERGE_VXM_M1 + { 7, &RISCVDescs.OperandInfo[581] }, // Inst #5934 = PseudoVMERGE_VVM_MF8 + { 7, &RISCVDescs.OperandInfo[581] }, // Inst #5933 = PseudoVMERGE_VVM_MF4 + { 7, &RISCVDescs.OperandInfo[581] }, // Inst #5932 = PseudoVMERGE_VVM_MF2 + { 7, &RISCVDescs.OperandInfo[602] }, // Inst #5931 = PseudoVMERGE_VVM_M8 + { 7, &RISCVDescs.OperandInfo[595] }, // Inst #5930 = PseudoVMERGE_VVM_M4 + { 7, &RISCVDescs.OperandInfo[588] }, // Inst #5929 = PseudoVMERGE_VVM_M2 + { 7, &RISCVDescs.OperandInfo[581] }, // Inst #5928 = PseudoVMERGE_VVM_M1 + { 7, &RISCVDescs.OperandInfo[553] }, // Inst #5927 = PseudoVMERGE_VIM_MF8 + { 7, &RISCVDescs.OperandInfo[553] }, // Inst #5926 = PseudoVMERGE_VIM_MF4 + { 7, &RISCVDescs.OperandInfo[553] }, // Inst #5925 = PseudoVMERGE_VIM_MF2 + { 7, &RISCVDescs.OperandInfo[574] }, // Inst #5924 = PseudoVMERGE_VIM_M8 + { 7, &RISCVDescs.OperandInfo[567] }, // Inst #5923 = PseudoVMERGE_VIM_M4 + { 7, &RISCVDescs.OperandInfo[560] }, // Inst #5922 = PseudoVMERGE_VIM_M2 + { 7, &RISCVDescs.OperandInfo[553] }, // Inst #5921 = PseudoVMERGE_VIM_M1 + { 3, &RISCVDescs.OperandInfo[5551] }, // Inst #5920 = PseudoVMCLR_M_B8 + { 3, &RISCVDescs.OperandInfo[5551] }, // Inst #5919 = PseudoVMCLR_M_B64 + { 3, &RISCVDescs.OperandInfo[5551] }, // Inst #5918 = PseudoVMCLR_M_B4 + { 3, &RISCVDescs.OperandInfo[5551] }, // Inst #5917 = PseudoVMCLR_M_B32 + { 3, &RISCVDescs.OperandInfo[5551] }, // Inst #5916 = PseudoVMCLR_M_B2 + { 3, &RISCVDescs.OperandInfo[5551] }, // Inst #5915 = PseudoVMCLR_M_B16 + { 3, &RISCVDescs.OperandInfo[5551] }, // Inst #5914 = PseudoVMCLR_M_B1 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #5913 = PseudoVMAX_VX_MF8_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #5912 = PseudoVMAX_VX_MF8 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #5911 = PseudoVMAX_VX_MF4_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #5910 = PseudoVMAX_VX_MF4 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #5909 = PseudoVMAX_VX_MF2_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #5908 = PseudoVMAX_VX_MF2 + { 8, &RISCVDescs.OperandInfo[809] }, // Inst #5907 = PseudoVMAX_VX_M8_MASK + { 7, &RISCVDescs.OperandInfo[802] }, // Inst #5906 = PseudoVMAX_VX_M8 + { 8, &RISCVDescs.OperandInfo[794] }, // Inst #5905 = PseudoVMAX_VX_M4_MASK + { 7, &RISCVDescs.OperandInfo[787] }, // Inst #5904 = PseudoVMAX_VX_M4 + { 8, &RISCVDescs.OperandInfo[779] }, // Inst #5903 = PseudoVMAX_VX_M2_MASK + { 7, &RISCVDescs.OperandInfo[772] }, // Inst #5902 = PseudoVMAX_VX_M2 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #5901 = PseudoVMAX_VX_M1_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #5900 = PseudoVMAX_VX_M1 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #5899 = PseudoVMAX_VV_MF8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #5898 = PseudoVMAX_VV_MF8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #5897 = PseudoVMAX_VV_MF4_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #5896 = PseudoVMAX_VV_MF4 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #5895 = PseudoVMAX_VV_MF2_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #5894 = PseudoVMAX_VV_MF2 + { 8, &RISCVDescs.OperandInfo[749] }, // Inst #5893 = PseudoVMAX_VV_M8_MASK + { 7, &RISCVDescs.OperandInfo[742] }, // Inst #5892 = PseudoVMAX_VV_M8 + { 8, &RISCVDescs.OperandInfo[734] }, // Inst #5891 = PseudoVMAX_VV_M4_MASK + { 7, &RISCVDescs.OperandInfo[727] }, // Inst #5890 = PseudoVMAX_VV_M4 + { 8, &RISCVDescs.OperandInfo[719] }, // Inst #5889 = PseudoVMAX_VV_M2_MASK + { 7, &RISCVDescs.OperandInfo[712] }, // Inst #5888 = PseudoVMAX_VV_M2 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #5887 = PseudoVMAX_VV_M1_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #5886 = PseudoVMAX_VV_M1 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #5885 = PseudoVMAXU_VX_MF8_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #5884 = PseudoVMAXU_VX_MF8 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #5883 = PseudoVMAXU_VX_MF4_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #5882 = PseudoVMAXU_VX_MF4 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #5881 = PseudoVMAXU_VX_MF2_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #5880 = PseudoVMAXU_VX_MF2 + { 8, &RISCVDescs.OperandInfo[809] }, // Inst #5879 = PseudoVMAXU_VX_M8_MASK + { 7, &RISCVDescs.OperandInfo[802] }, // Inst #5878 = PseudoVMAXU_VX_M8 + { 8, &RISCVDescs.OperandInfo[794] }, // Inst #5877 = PseudoVMAXU_VX_M4_MASK + { 7, &RISCVDescs.OperandInfo[787] }, // Inst #5876 = PseudoVMAXU_VX_M4 + { 8, &RISCVDescs.OperandInfo[779] }, // Inst #5875 = PseudoVMAXU_VX_M2_MASK + { 7, &RISCVDescs.OperandInfo[772] }, // Inst #5874 = PseudoVMAXU_VX_M2 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #5873 = PseudoVMAXU_VX_M1_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #5872 = PseudoVMAXU_VX_M1 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #5871 = PseudoVMAXU_VV_MF8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #5870 = PseudoVMAXU_VV_MF8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #5869 = PseudoVMAXU_VV_MF4_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #5868 = PseudoVMAXU_VV_MF4 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #5867 = PseudoVMAXU_VV_MF2_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #5866 = PseudoVMAXU_VV_MF2 + { 8, &RISCVDescs.OperandInfo[749] }, // Inst #5865 = PseudoVMAXU_VV_M8_MASK + { 7, &RISCVDescs.OperandInfo[742] }, // Inst #5864 = PseudoVMAXU_VV_M8 + { 8, &RISCVDescs.OperandInfo[734] }, // Inst #5863 = PseudoVMAXU_VV_M4_MASK + { 7, &RISCVDescs.OperandInfo[727] }, // Inst #5862 = PseudoVMAXU_VV_M4 + { 8, &RISCVDescs.OperandInfo[719] }, // Inst #5861 = PseudoVMAXU_VV_M2_MASK + { 7, &RISCVDescs.OperandInfo[712] }, // Inst #5860 = PseudoVMAXU_VV_M2 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #5859 = PseudoVMAXU_VV_M1_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #5858 = PseudoVMAXU_VV_M1 + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #5857 = PseudoVMAND_MM_MF8 + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #5856 = PseudoVMAND_MM_MF4 + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #5855 = PseudoVMAND_MM_MF2 + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #5854 = PseudoVMAND_MM_M8 + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #5853 = PseudoVMAND_MM_M4 + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #5852 = PseudoVMAND_MM_M2 + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #5851 = PseudoVMAND_MM_M1 + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #5850 = PseudoVMANDN_MM_MF8 + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #5849 = PseudoVMANDN_MM_MF4 + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #5848 = PseudoVMANDN_MM_MF2 + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #5847 = PseudoVMANDN_MM_M8 + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #5846 = PseudoVMANDN_MM_M4 + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #5845 = PseudoVMANDN_MM_M2 + { 5, &RISCVDescs.OperandInfo[5546] }, // Inst #5844 = PseudoVMANDN_MM_M1 + { 8, &RISCVDescs.OperandInfo[5361] }, // Inst #5843 = PseudoVMADD_VX_MF8_MASK + { 7, &RISCVDescs.OperandInfo[5354] }, // Inst #5842 = PseudoVMADD_VX_MF8 + { 8, &RISCVDescs.OperandInfo[5361] }, // Inst #5841 = PseudoVMADD_VX_MF4_MASK + { 7, &RISCVDescs.OperandInfo[5354] }, // Inst #5840 = PseudoVMADD_VX_MF4 + { 8, &RISCVDescs.OperandInfo[5361] }, // Inst #5839 = PseudoVMADD_VX_MF2_MASK + { 7, &RISCVDescs.OperandInfo[5354] }, // Inst #5838 = PseudoVMADD_VX_MF2 + { 8, &RISCVDescs.OperandInfo[5406] }, // Inst #5837 = PseudoVMADD_VX_M8_MASK + { 7, &RISCVDescs.OperandInfo[5399] }, // Inst #5836 = PseudoVMADD_VX_M8 + { 8, &RISCVDescs.OperandInfo[5391] }, // Inst #5835 = PseudoVMADD_VX_M4_MASK + { 7, &RISCVDescs.OperandInfo[5384] }, // Inst #5834 = PseudoVMADD_VX_M4 + { 8, &RISCVDescs.OperandInfo[5376] }, // Inst #5833 = PseudoVMADD_VX_M2_MASK + { 7, &RISCVDescs.OperandInfo[5369] }, // Inst #5832 = PseudoVMADD_VX_M2 + { 8, &RISCVDescs.OperandInfo[5361] }, // Inst #5831 = PseudoVMADD_VX_M1_MASK + { 7, &RISCVDescs.OperandInfo[5354] }, // Inst #5830 = PseudoVMADD_VX_M1 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #5829 = PseudoVMADD_VV_MF8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #5828 = PseudoVMADD_VV_MF8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #5827 = PseudoVMADD_VV_MF4_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #5826 = PseudoVMADD_VV_MF4 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #5825 = PseudoVMADD_VV_MF2_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #5824 = PseudoVMADD_VV_MF2 + { 8, &RISCVDescs.OperandInfo[749] }, // Inst #5823 = PseudoVMADD_VV_M8_MASK + { 7, &RISCVDescs.OperandInfo[742] }, // Inst #5822 = PseudoVMADD_VV_M8 + { 8, &RISCVDescs.OperandInfo[734] }, // Inst #5821 = PseudoVMADD_VV_M4_MASK + { 7, &RISCVDescs.OperandInfo[727] }, // Inst #5820 = PseudoVMADD_VV_M4 + { 8, &RISCVDescs.OperandInfo[719] }, // Inst #5819 = PseudoVMADD_VV_M2_MASK + { 7, &RISCVDescs.OperandInfo[712] }, // Inst #5818 = PseudoVMADD_VV_M2 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #5817 = PseudoVMADD_VV_M1_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #5816 = PseudoVMADD_VV_M1 + { 5, &RISCVDescs.OperandInfo[5526] }, // Inst #5815 = PseudoVMADC_VX_MF8 + { 5, &RISCVDescs.OperandInfo[5526] }, // Inst #5814 = PseudoVMADC_VX_MF4 + { 5, &RISCVDescs.OperandInfo[5526] }, // Inst #5813 = PseudoVMADC_VX_MF2 + { 5, &RISCVDescs.OperandInfo[5541] }, // Inst #5812 = PseudoVMADC_VX_M8 + { 5, &RISCVDescs.OperandInfo[5536] }, // Inst #5811 = PseudoVMADC_VX_M4 + { 5, &RISCVDescs.OperandInfo[5531] }, // Inst #5810 = PseudoVMADC_VX_M2 + { 5, &RISCVDescs.OperandInfo[5526] }, // Inst #5809 = PseudoVMADC_VX_M1 + { 6, &RISCVDescs.OperandInfo[5502] }, // Inst #5808 = PseudoVMADC_VXM_MF8 + { 6, &RISCVDescs.OperandInfo[5502] }, // Inst #5807 = PseudoVMADC_VXM_MF4 + { 6, &RISCVDescs.OperandInfo[5502] }, // Inst #5806 = PseudoVMADC_VXM_MF2 + { 6, &RISCVDescs.OperandInfo[5520] }, // Inst #5805 = PseudoVMADC_VXM_M8 + { 6, &RISCVDescs.OperandInfo[5514] }, // Inst #5804 = PseudoVMADC_VXM_M4 + { 6, &RISCVDescs.OperandInfo[5508] }, // Inst #5803 = PseudoVMADC_VXM_M2 + { 6, &RISCVDescs.OperandInfo[5502] }, // Inst #5802 = PseudoVMADC_VXM_M1 + { 5, &RISCVDescs.OperandInfo[5482] }, // Inst #5801 = PseudoVMADC_VV_MF8 + { 5, &RISCVDescs.OperandInfo[5482] }, // Inst #5800 = PseudoVMADC_VV_MF4 + { 5, &RISCVDescs.OperandInfo[5482] }, // Inst #5799 = PseudoVMADC_VV_MF2 + { 5, &RISCVDescs.OperandInfo[5497] }, // Inst #5798 = PseudoVMADC_VV_M8 + { 5, &RISCVDescs.OperandInfo[5492] }, // Inst #5797 = PseudoVMADC_VV_M4 + { 5, &RISCVDescs.OperandInfo[5487] }, // Inst #5796 = PseudoVMADC_VV_M2 + { 5, &RISCVDescs.OperandInfo[5482] }, // Inst #5795 = PseudoVMADC_VV_M1 + { 6, &RISCVDescs.OperandInfo[5458] }, // Inst #5794 = PseudoVMADC_VVM_MF8 + { 6, &RISCVDescs.OperandInfo[5458] }, // Inst #5793 = PseudoVMADC_VVM_MF4 + { 6, &RISCVDescs.OperandInfo[5458] }, // Inst #5792 = PseudoVMADC_VVM_MF2 + { 6, &RISCVDescs.OperandInfo[5476] }, // Inst #5791 = PseudoVMADC_VVM_M8 + { 6, &RISCVDescs.OperandInfo[5470] }, // Inst #5790 = PseudoVMADC_VVM_M4 + { 6, &RISCVDescs.OperandInfo[5464] }, // Inst #5789 = PseudoVMADC_VVM_M2 + { 6, &RISCVDescs.OperandInfo[5458] }, // Inst #5788 = PseudoVMADC_VVM_M1 + { 5, &RISCVDescs.OperandInfo[5438] }, // Inst #5787 = PseudoVMADC_VI_MF8 + { 5, &RISCVDescs.OperandInfo[5438] }, // Inst #5786 = PseudoVMADC_VI_MF4 + { 5, &RISCVDescs.OperandInfo[5438] }, // Inst #5785 = PseudoVMADC_VI_MF2 + { 5, &RISCVDescs.OperandInfo[5453] }, // Inst #5784 = PseudoVMADC_VI_M8 + { 5, &RISCVDescs.OperandInfo[5448] }, // Inst #5783 = PseudoVMADC_VI_M4 + { 5, &RISCVDescs.OperandInfo[5443] }, // Inst #5782 = PseudoVMADC_VI_M2 + { 5, &RISCVDescs.OperandInfo[5438] }, // Inst #5781 = PseudoVMADC_VI_M1 + { 6, &RISCVDescs.OperandInfo[5414] }, // Inst #5780 = PseudoVMADC_VIM_MF8 + { 6, &RISCVDescs.OperandInfo[5414] }, // Inst #5779 = PseudoVMADC_VIM_MF4 + { 6, &RISCVDescs.OperandInfo[5414] }, // Inst #5778 = PseudoVMADC_VIM_MF2 + { 6, &RISCVDescs.OperandInfo[5432] }, // Inst #5777 = PseudoVMADC_VIM_M8 + { 6, &RISCVDescs.OperandInfo[5426] }, // Inst #5776 = PseudoVMADC_VIM_M4 + { 6, &RISCVDescs.OperandInfo[5420] }, // Inst #5775 = PseudoVMADC_VIM_M2 + { 6, &RISCVDescs.OperandInfo[5414] }, // Inst #5774 = PseudoVMADC_VIM_M1 + { 8, &RISCVDescs.OperandInfo[5361] }, // Inst #5773 = PseudoVMACC_VX_MF8_MASK + { 7, &RISCVDescs.OperandInfo[5354] }, // Inst #5772 = PseudoVMACC_VX_MF8 + { 8, &RISCVDescs.OperandInfo[5361] }, // Inst #5771 = PseudoVMACC_VX_MF4_MASK + { 7, &RISCVDescs.OperandInfo[5354] }, // Inst #5770 = PseudoVMACC_VX_MF4 + { 8, &RISCVDescs.OperandInfo[5361] }, // Inst #5769 = PseudoVMACC_VX_MF2_MASK + { 7, &RISCVDescs.OperandInfo[5354] }, // Inst #5768 = PseudoVMACC_VX_MF2 + { 8, &RISCVDescs.OperandInfo[5406] }, // Inst #5767 = PseudoVMACC_VX_M8_MASK + { 7, &RISCVDescs.OperandInfo[5399] }, // Inst #5766 = PseudoVMACC_VX_M8 + { 8, &RISCVDescs.OperandInfo[5391] }, // Inst #5765 = PseudoVMACC_VX_M4_MASK + { 7, &RISCVDescs.OperandInfo[5384] }, // Inst #5764 = PseudoVMACC_VX_M4 + { 8, &RISCVDescs.OperandInfo[5376] }, // Inst #5763 = PseudoVMACC_VX_M2_MASK + { 7, &RISCVDescs.OperandInfo[5369] }, // Inst #5762 = PseudoVMACC_VX_M2 + { 8, &RISCVDescs.OperandInfo[5361] }, // Inst #5761 = PseudoVMACC_VX_M1_MASK + { 7, &RISCVDescs.OperandInfo[5354] }, // Inst #5760 = PseudoVMACC_VX_M1 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #5759 = PseudoVMACC_VV_MF8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #5758 = PseudoVMACC_VV_MF8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #5757 = PseudoVMACC_VV_MF4_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #5756 = PseudoVMACC_VV_MF4 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #5755 = PseudoVMACC_VV_MF2_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #5754 = PseudoVMACC_VV_MF2 + { 8, &RISCVDescs.OperandInfo[749] }, // Inst #5753 = PseudoVMACC_VV_M8_MASK + { 7, &RISCVDescs.OperandInfo[742] }, // Inst #5752 = PseudoVMACC_VV_M8 + { 8, &RISCVDescs.OperandInfo[734] }, // Inst #5751 = PseudoVMACC_VV_M4_MASK + { 7, &RISCVDescs.OperandInfo[727] }, // Inst #5750 = PseudoVMACC_VV_M4 + { 8, &RISCVDescs.OperandInfo[719] }, // Inst #5749 = PseudoVMACC_VV_M2_MASK + { 7, &RISCVDescs.OperandInfo[712] }, // Inst #5748 = PseudoVMACC_VV_M2 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #5747 = PseudoVMACC_VV_M1_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #5746 = PseudoVMACC_VV_M1 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #5745 = PseudoVLUXSEG8EI8_V_MF8_MF8_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #5744 = PseudoVLUXSEG8EI8_V_MF8_MF8 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #5743 = PseudoVLUXSEG8EI8_V_MF8_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #5742 = PseudoVLUXSEG8EI8_V_MF8_MF4 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #5741 = PseudoVLUXSEG8EI8_V_MF8_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #5740 = PseudoVLUXSEG8EI8_V_MF8_MF2 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #5739 = PseudoVLUXSEG8EI8_V_MF8_M1_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #5738 = PseudoVLUXSEG8EI8_V_MF8_M1 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #5737 = PseudoVLUXSEG8EI8_V_MF4_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #5736 = PseudoVLUXSEG8EI8_V_MF4_MF4 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #5735 = PseudoVLUXSEG8EI8_V_MF4_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #5734 = PseudoVLUXSEG8EI8_V_MF4_MF2 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #5733 = PseudoVLUXSEG8EI8_V_MF4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #5732 = PseudoVLUXSEG8EI8_V_MF4_M1 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #5731 = PseudoVLUXSEG8EI8_V_MF2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #5730 = PseudoVLUXSEG8EI8_V_MF2_MF2 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #5729 = PseudoVLUXSEG8EI8_V_MF2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #5728 = PseudoVLUXSEG8EI8_V_MF2_M1 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #5727 = PseudoVLUXSEG8EI8_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #5726 = PseudoVLUXSEG8EI8_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[4813] }, // Inst #5725 = PseudoVLUXSEG8EI64_V_M8_M1_MASK + { 7, &RISCVDescs.OperandInfo[4806] }, // Inst #5724 = PseudoVLUXSEG8EI64_V_M8_M1 + { 8, &RISCVDescs.OperandInfo[4798] }, // Inst #5723 = PseudoVLUXSEG8EI64_V_M4_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4791] }, // Inst #5722 = PseudoVLUXSEG8EI64_V_M4_MF2 + { 8, &RISCVDescs.OperandInfo[4798] }, // Inst #5721 = PseudoVLUXSEG8EI64_V_M4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4791] }, // Inst #5720 = PseudoVLUXSEG8EI64_V_M4_M1 + { 8, &RISCVDescs.OperandInfo[4783] }, // Inst #5719 = PseudoVLUXSEG8EI64_V_M2_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4776] }, // Inst #5718 = PseudoVLUXSEG8EI64_V_M2_MF4 + { 8, &RISCVDescs.OperandInfo[4783] }, // Inst #5717 = PseudoVLUXSEG8EI64_V_M2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4776] }, // Inst #5716 = PseudoVLUXSEG8EI64_V_M2_MF2 + { 8, &RISCVDescs.OperandInfo[4783] }, // Inst #5715 = PseudoVLUXSEG8EI64_V_M2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4776] }, // Inst #5714 = PseudoVLUXSEG8EI64_V_M2_M1 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #5713 = PseudoVLUXSEG8EI64_V_M1_MF8_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #5712 = PseudoVLUXSEG8EI64_V_M1_MF8 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #5711 = PseudoVLUXSEG8EI64_V_M1_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #5710 = PseudoVLUXSEG8EI64_V_M1_MF4 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #5709 = PseudoVLUXSEG8EI64_V_M1_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #5708 = PseudoVLUXSEG8EI64_V_M1_MF2 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #5707 = PseudoVLUXSEG8EI64_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #5706 = PseudoVLUXSEG8EI64_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #5705 = PseudoVLUXSEG8EI32_V_MF2_MF8_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #5704 = PseudoVLUXSEG8EI32_V_MF2_MF8 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #5703 = PseudoVLUXSEG8EI32_V_MF2_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #5702 = PseudoVLUXSEG8EI32_V_MF2_MF4 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #5701 = PseudoVLUXSEG8EI32_V_MF2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #5700 = PseudoVLUXSEG8EI32_V_MF2_MF2 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #5699 = PseudoVLUXSEG8EI32_V_MF2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #5698 = PseudoVLUXSEG8EI32_V_MF2_M1 + { 8, &RISCVDescs.OperandInfo[4798] }, // Inst #5697 = PseudoVLUXSEG8EI32_V_M4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4791] }, // Inst #5696 = PseudoVLUXSEG8EI32_V_M4_M1 + { 8, &RISCVDescs.OperandInfo[4783] }, // Inst #5695 = PseudoVLUXSEG8EI32_V_M2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4776] }, // Inst #5694 = PseudoVLUXSEG8EI32_V_M2_MF2 + { 8, &RISCVDescs.OperandInfo[4783] }, // Inst #5693 = PseudoVLUXSEG8EI32_V_M2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4776] }, // Inst #5692 = PseudoVLUXSEG8EI32_V_M2_M1 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #5691 = PseudoVLUXSEG8EI32_V_M1_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #5690 = PseudoVLUXSEG8EI32_V_M1_MF4 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #5689 = PseudoVLUXSEG8EI32_V_M1_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #5688 = PseudoVLUXSEG8EI32_V_M1_MF2 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #5687 = PseudoVLUXSEG8EI32_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #5686 = PseudoVLUXSEG8EI32_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #5685 = PseudoVLUXSEG8EI16_V_MF4_MF8_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #5684 = PseudoVLUXSEG8EI16_V_MF4_MF8 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #5683 = PseudoVLUXSEG8EI16_V_MF4_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #5682 = PseudoVLUXSEG8EI16_V_MF4_MF4 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #5681 = PseudoVLUXSEG8EI16_V_MF4_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #5680 = PseudoVLUXSEG8EI16_V_MF4_MF2 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #5679 = PseudoVLUXSEG8EI16_V_MF4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #5678 = PseudoVLUXSEG8EI16_V_MF4_M1 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #5677 = PseudoVLUXSEG8EI16_V_MF2_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #5676 = PseudoVLUXSEG8EI16_V_MF2_MF4 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #5675 = PseudoVLUXSEG8EI16_V_MF2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #5674 = PseudoVLUXSEG8EI16_V_MF2_MF2 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #5673 = PseudoVLUXSEG8EI16_V_MF2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #5672 = PseudoVLUXSEG8EI16_V_MF2_M1 + { 8, &RISCVDescs.OperandInfo[4783] }, // Inst #5671 = PseudoVLUXSEG8EI16_V_M2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4776] }, // Inst #5670 = PseudoVLUXSEG8EI16_V_M2_M1 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #5669 = PseudoVLUXSEG8EI16_V_M1_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #5668 = PseudoVLUXSEG8EI16_V_M1_MF2 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #5667 = PseudoVLUXSEG8EI16_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #5666 = PseudoVLUXSEG8EI16_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #5665 = PseudoVLUXSEG7EI8_V_MF8_MF8_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #5664 = PseudoVLUXSEG7EI8_V_MF8_MF8 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #5663 = PseudoVLUXSEG7EI8_V_MF8_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #5662 = PseudoVLUXSEG7EI8_V_MF8_MF4 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #5661 = PseudoVLUXSEG7EI8_V_MF8_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #5660 = PseudoVLUXSEG7EI8_V_MF8_MF2 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #5659 = PseudoVLUXSEG7EI8_V_MF8_M1_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #5658 = PseudoVLUXSEG7EI8_V_MF8_M1 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #5657 = PseudoVLUXSEG7EI8_V_MF4_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #5656 = PseudoVLUXSEG7EI8_V_MF4_MF4 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #5655 = PseudoVLUXSEG7EI8_V_MF4_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #5654 = PseudoVLUXSEG7EI8_V_MF4_MF2 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #5653 = PseudoVLUXSEG7EI8_V_MF4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #5652 = PseudoVLUXSEG7EI8_V_MF4_M1 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #5651 = PseudoVLUXSEG7EI8_V_MF2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #5650 = PseudoVLUXSEG7EI8_V_MF2_MF2 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #5649 = PseudoVLUXSEG7EI8_V_MF2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #5648 = PseudoVLUXSEG7EI8_V_MF2_M1 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #5647 = PseudoVLUXSEG7EI8_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #5646 = PseudoVLUXSEG7EI8_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[4753] }, // Inst #5645 = PseudoVLUXSEG7EI64_V_M8_M1_MASK + { 7, &RISCVDescs.OperandInfo[4746] }, // Inst #5644 = PseudoVLUXSEG7EI64_V_M8_M1 + { 8, &RISCVDescs.OperandInfo[4738] }, // Inst #5643 = PseudoVLUXSEG7EI64_V_M4_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4731] }, // Inst #5642 = PseudoVLUXSEG7EI64_V_M4_MF2 + { 8, &RISCVDescs.OperandInfo[4738] }, // Inst #5641 = PseudoVLUXSEG7EI64_V_M4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4731] }, // Inst #5640 = PseudoVLUXSEG7EI64_V_M4_M1 + { 8, &RISCVDescs.OperandInfo[4723] }, // Inst #5639 = PseudoVLUXSEG7EI64_V_M2_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4716] }, // Inst #5638 = PseudoVLUXSEG7EI64_V_M2_MF4 + { 8, &RISCVDescs.OperandInfo[4723] }, // Inst #5637 = PseudoVLUXSEG7EI64_V_M2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4716] }, // Inst #5636 = PseudoVLUXSEG7EI64_V_M2_MF2 + { 8, &RISCVDescs.OperandInfo[4723] }, // Inst #5635 = PseudoVLUXSEG7EI64_V_M2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4716] }, // Inst #5634 = PseudoVLUXSEG7EI64_V_M2_M1 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #5633 = PseudoVLUXSEG7EI64_V_M1_MF8_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #5632 = PseudoVLUXSEG7EI64_V_M1_MF8 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #5631 = PseudoVLUXSEG7EI64_V_M1_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #5630 = PseudoVLUXSEG7EI64_V_M1_MF4 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #5629 = PseudoVLUXSEG7EI64_V_M1_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #5628 = PseudoVLUXSEG7EI64_V_M1_MF2 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #5627 = PseudoVLUXSEG7EI64_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #5626 = PseudoVLUXSEG7EI64_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #5625 = PseudoVLUXSEG7EI32_V_MF2_MF8_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #5624 = PseudoVLUXSEG7EI32_V_MF2_MF8 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #5623 = PseudoVLUXSEG7EI32_V_MF2_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #5622 = PseudoVLUXSEG7EI32_V_MF2_MF4 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #5621 = PseudoVLUXSEG7EI32_V_MF2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #5620 = PseudoVLUXSEG7EI32_V_MF2_MF2 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #5619 = PseudoVLUXSEG7EI32_V_MF2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #5618 = PseudoVLUXSEG7EI32_V_MF2_M1 + { 8, &RISCVDescs.OperandInfo[4738] }, // Inst #5617 = PseudoVLUXSEG7EI32_V_M4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4731] }, // Inst #5616 = PseudoVLUXSEG7EI32_V_M4_M1 + { 8, &RISCVDescs.OperandInfo[4723] }, // Inst #5615 = PseudoVLUXSEG7EI32_V_M2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4716] }, // Inst #5614 = PseudoVLUXSEG7EI32_V_M2_MF2 + { 8, &RISCVDescs.OperandInfo[4723] }, // Inst #5613 = PseudoVLUXSEG7EI32_V_M2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4716] }, // Inst #5612 = PseudoVLUXSEG7EI32_V_M2_M1 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #5611 = PseudoVLUXSEG7EI32_V_M1_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #5610 = PseudoVLUXSEG7EI32_V_M1_MF4 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #5609 = PseudoVLUXSEG7EI32_V_M1_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #5608 = PseudoVLUXSEG7EI32_V_M1_MF2 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #5607 = PseudoVLUXSEG7EI32_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #5606 = PseudoVLUXSEG7EI32_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #5605 = PseudoVLUXSEG7EI16_V_MF4_MF8_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #5604 = PseudoVLUXSEG7EI16_V_MF4_MF8 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #5603 = PseudoVLUXSEG7EI16_V_MF4_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #5602 = PseudoVLUXSEG7EI16_V_MF4_MF4 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #5601 = PseudoVLUXSEG7EI16_V_MF4_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #5600 = PseudoVLUXSEG7EI16_V_MF4_MF2 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #5599 = PseudoVLUXSEG7EI16_V_MF4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #5598 = PseudoVLUXSEG7EI16_V_MF4_M1 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #5597 = PseudoVLUXSEG7EI16_V_MF2_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #5596 = PseudoVLUXSEG7EI16_V_MF2_MF4 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #5595 = PseudoVLUXSEG7EI16_V_MF2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #5594 = PseudoVLUXSEG7EI16_V_MF2_MF2 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #5593 = PseudoVLUXSEG7EI16_V_MF2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #5592 = PseudoVLUXSEG7EI16_V_MF2_M1 + { 8, &RISCVDescs.OperandInfo[4723] }, // Inst #5591 = PseudoVLUXSEG7EI16_V_M2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4716] }, // Inst #5590 = PseudoVLUXSEG7EI16_V_M2_M1 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #5589 = PseudoVLUXSEG7EI16_V_M1_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #5588 = PseudoVLUXSEG7EI16_V_M1_MF2 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #5587 = PseudoVLUXSEG7EI16_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #5586 = PseudoVLUXSEG7EI16_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #5585 = PseudoVLUXSEG6EI8_V_MF8_MF8_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #5584 = PseudoVLUXSEG6EI8_V_MF8_MF8 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #5583 = PseudoVLUXSEG6EI8_V_MF8_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #5582 = PseudoVLUXSEG6EI8_V_MF8_MF4 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #5581 = PseudoVLUXSEG6EI8_V_MF8_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #5580 = PseudoVLUXSEG6EI8_V_MF8_MF2 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #5579 = PseudoVLUXSEG6EI8_V_MF8_M1_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #5578 = PseudoVLUXSEG6EI8_V_MF8_M1 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #5577 = PseudoVLUXSEG6EI8_V_MF4_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #5576 = PseudoVLUXSEG6EI8_V_MF4_MF4 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #5575 = PseudoVLUXSEG6EI8_V_MF4_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #5574 = PseudoVLUXSEG6EI8_V_MF4_MF2 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #5573 = PseudoVLUXSEG6EI8_V_MF4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #5572 = PseudoVLUXSEG6EI8_V_MF4_M1 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #5571 = PseudoVLUXSEG6EI8_V_MF2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #5570 = PseudoVLUXSEG6EI8_V_MF2_MF2 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #5569 = PseudoVLUXSEG6EI8_V_MF2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #5568 = PseudoVLUXSEG6EI8_V_MF2_M1 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #5567 = PseudoVLUXSEG6EI8_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #5566 = PseudoVLUXSEG6EI8_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[4693] }, // Inst #5565 = PseudoVLUXSEG6EI64_V_M8_M1_MASK + { 7, &RISCVDescs.OperandInfo[4686] }, // Inst #5564 = PseudoVLUXSEG6EI64_V_M8_M1 + { 8, &RISCVDescs.OperandInfo[4678] }, // Inst #5563 = PseudoVLUXSEG6EI64_V_M4_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4671] }, // Inst #5562 = PseudoVLUXSEG6EI64_V_M4_MF2 + { 8, &RISCVDescs.OperandInfo[4678] }, // Inst #5561 = PseudoVLUXSEG6EI64_V_M4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4671] }, // Inst #5560 = PseudoVLUXSEG6EI64_V_M4_M1 + { 8, &RISCVDescs.OperandInfo[4663] }, // Inst #5559 = PseudoVLUXSEG6EI64_V_M2_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4656] }, // Inst #5558 = PseudoVLUXSEG6EI64_V_M2_MF4 + { 8, &RISCVDescs.OperandInfo[4663] }, // Inst #5557 = PseudoVLUXSEG6EI64_V_M2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4656] }, // Inst #5556 = PseudoVLUXSEG6EI64_V_M2_MF2 + { 8, &RISCVDescs.OperandInfo[4663] }, // Inst #5555 = PseudoVLUXSEG6EI64_V_M2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4656] }, // Inst #5554 = PseudoVLUXSEG6EI64_V_M2_M1 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #5553 = PseudoVLUXSEG6EI64_V_M1_MF8_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #5552 = PseudoVLUXSEG6EI64_V_M1_MF8 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #5551 = PseudoVLUXSEG6EI64_V_M1_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #5550 = PseudoVLUXSEG6EI64_V_M1_MF4 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #5549 = PseudoVLUXSEG6EI64_V_M1_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #5548 = PseudoVLUXSEG6EI64_V_M1_MF2 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #5547 = PseudoVLUXSEG6EI64_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #5546 = PseudoVLUXSEG6EI64_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #5545 = PseudoVLUXSEG6EI32_V_MF2_MF8_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #5544 = PseudoVLUXSEG6EI32_V_MF2_MF8 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #5543 = PseudoVLUXSEG6EI32_V_MF2_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #5542 = PseudoVLUXSEG6EI32_V_MF2_MF4 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #5541 = PseudoVLUXSEG6EI32_V_MF2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #5540 = PseudoVLUXSEG6EI32_V_MF2_MF2 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #5539 = PseudoVLUXSEG6EI32_V_MF2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #5538 = PseudoVLUXSEG6EI32_V_MF2_M1 + { 8, &RISCVDescs.OperandInfo[4678] }, // Inst #5537 = PseudoVLUXSEG6EI32_V_M4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4671] }, // Inst #5536 = PseudoVLUXSEG6EI32_V_M4_M1 + { 8, &RISCVDescs.OperandInfo[4663] }, // Inst #5535 = PseudoVLUXSEG6EI32_V_M2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4656] }, // Inst #5534 = PseudoVLUXSEG6EI32_V_M2_MF2 + { 8, &RISCVDescs.OperandInfo[4663] }, // Inst #5533 = PseudoVLUXSEG6EI32_V_M2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4656] }, // Inst #5532 = PseudoVLUXSEG6EI32_V_M2_M1 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #5531 = PseudoVLUXSEG6EI32_V_M1_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #5530 = PseudoVLUXSEG6EI32_V_M1_MF4 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #5529 = PseudoVLUXSEG6EI32_V_M1_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #5528 = PseudoVLUXSEG6EI32_V_M1_MF2 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #5527 = PseudoVLUXSEG6EI32_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #5526 = PseudoVLUXSEG6EI32_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #5525 = PseudoVLUXSEG6EI16_V_MF4_MF8_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #5524 = PseudoVLUXSEG6EI16_V_MF4_MF8 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #5523 = PseudoVLUXSEG6EI16_V_MF4_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #5522 = PseudoVLUXSEG6EI16_V_MF4_MF4 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #5521 = PseudoVLUXSEG6EI16_V_MF4_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #5520 = PseudoVLUXSEG6EI16_V_MF4_MF2 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #5519 = PseudoVLUXSEG6EI16_V_MF4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #5518 = PseudoVLUXSEG6EI16_V_MF4_M1 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #5517 = PseudoVLUXSEG6EI16_V_MF2_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #5516 = PseudoVLUXSEG6EI16_V_MF2_MF4 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #5515 = PseudoVLUXSEG6EI16_V_MF2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #5514 = PseudoVLUXSEG6EI16_V_MF2_MF2 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #5513 = PseudoVLUXSEG6EI16_V_MF2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #5512 = PseudoVLUXSEG6EI16_V_MF2_M1 + { 8, &RISCVDescs.OperandInfo[4663] }, // Inst #5511 = PseudoVLUXSEG6EI16_V_M2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4656] }, // Inst #5510 = PseudoVLUXSEG6EI16_V_M2_M1 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #5509 = PseudoVLUXSEG6EI16_V_M1_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #5508 = PseudoVLUXSEG6EI16_V_M1_MF2 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #5507 = PseudoVLUXSEG6EI16_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #5506 = PseudoVLUXSEG6EI16_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #5505 = PseudoVLUXSEG5EI8_V_MF8_MF8_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #5504 = PseudoVLUXSEG5EI8_V_MF8_MF8 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #5503 = PseudoVLUXSEG5EI8_V_MF8_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #5502 = PseudoVLUXSEG5EI8_V_MF8_MF4 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #5501 = PseudoVLUXSEG5EI8_V_MF8_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #5500 = PseudoVLUXSEG5EI8_V_MF8_MF2 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #5499 = PseudoVLUXSEG5EI8_V_MF8_M1_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #5498 = PseudoVLUXSEG5EI8_V_MF8_M1 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #5497 = PseudoVLUXSEG5EI8_V_MF4_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #5496 = PseudoVLUXSEG5EI8_V_MF4_MF4 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #5495 = PseudoVLUXSEG5EI8_V_MF4_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #5494 = PseudoVLUXSEG5EI8_V_MF4_MF2 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #5493 = PseudoVLUXSEG5EI8_V_MF4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #5492 = PseudoVLUXSEG5EI8_V_MF4_M1 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #5491 = PseudoVLUXSEG5EI8_V_MF2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #5490 = PseudoVLUXSEG5EI8_V_MF2_MF2 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #5489 = PseudoVLUXSEG5EI8_V_MF2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #5488 = PseudoVLUXSEG5EI8_V_MF2_M1 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #5487 = PseudoVLUXSEG5EI8_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #5486 = PseudoVLUXSEG5EI8_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[4633] }, // Inst #5485 = PseudoVLUXSEG5EI64_V_M8_M1_MASK + { 7, &RISCVDescs.OperandInfo[4626] }, // Inst #5484 = PseudoVLUXSEG5EI64_V_M8_M1 + { 8, &RISCVDescs.OperandInfo[4618] }, // Inst #5483 = PseudoVLUXSEG5EI64_V_M4_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4611] }, // Inst #5482 = PseudoVLUXSEG5EI64_V_M4_MF2 + { 8, &RISCVDescs.OperandInfo[4618] }, // Inst #5481 = PseudoVLUXSEG5EI64_V_M4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4611] }, // Inst #5480 = PseudoVLUXSEG5EI64_V_M4_M1 + { 8, &RISCVDescs.OperandInfo[4603] }, // Inst #5479 = PseudoVLUXSEG5EI64_V_M2_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4596] }, // Inst #5478 = PseudoVLUXSEG5EI64_V_M2_MF4 + { 8, &RISCVDescs.OperandInfo[4603] }, // Inst #5477 = PseudoVLUXSEG5EI64_V_M2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4596] }, // Inst #5476 = PseudoVLUXSEG5EI64_V_M2_MF2 + { 8, &RISCVDescs.OperandInfo[4603] }, // Inst #5475 = PseudoVLUXSEG5EI64_V_M2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4596] }, // Inst #5474 = PseudoVLUXSEG5EI64_V_M2_M1 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #5473 = PseudoVLUXSEG5EI64_V_M1_MF8_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #5472 = PseudoVLUXSEG5EI64_V_M1_MF8 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #5471 = PseudoVLUXSEG5EI64_V_M1_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #5470 = PseudoVLUXSEG5EI64_V_M1_MF4 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #5469 = PseudoVLUXSEG5EI64_V_M1_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #5468 = PseudoVLUXSEG5EI64_V_M1_MF2 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #5467 = PseudoVLUXSEG5EI64_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #5466 = PseudoVLUXSEG5EI64_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #5465 = PseudoVLUXSEG5EI32_V_MF2_MF8_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #5464 = PseudoVLUXSEG5EI32_V_MF2_MF8 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #5463 = PseudoVLUXSEG5EI32_V_MF2_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #5462 = PseudoVLUXSEG5EI32_V_MF2_MF4 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #5461 = PseudoVLUXSEG5EI32_V_MF2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #5460 = PseudoVLUXSEG5EI32_V_MF2_MF2 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #5459 = PseudoVLUXSEG5EI32_V_MF2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #5458 = PseudoVLUXSEG5EI32_V_MF2_M1 + { 8, &RISCVDescs.OperandInfo[4618] }, // Inst #5457 = PseudoVLUXSEG5EI32_V_M4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4611] }, // Inst #5456 = PseudoVLUXSEG5EI32_V_M4_M1 + { 8, &RISCVDescs.OperandInfo[4603] }, // Inst #5455 = PseudoVLUXSEG5EI32_V_M2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4596] }, // Inst #5454 = PseudoVLUXSEG5EI32_V_M2_MF2 + { 8, &RISCVDescs.OperandInfo[4603] }, // Inst #5453 = PseudoVLUXSEG5EI32_V_M2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4596] }, // Inst #5452 = PseudoVLUXSEG5EI32_V_M2_M1 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #5451 = PseudoVLUXSEG5EI32_V_M1_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #5450 = PseudoVLUXSEG5EI32_V_M1_MF4 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #5449 = PseudoVLUXSEG5EI32_V_M1_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #5448 = PseudoVLUXSEG5EI32_V_M1_MF2 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #5447 = PseudoVLUXSEG5EI32_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #5446 = PseudoVLUXSEG5EI32_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #5445 = PseudoVLUXSEG5EI16_V_MF4_MF8_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #5444 = PseudoVLUXSEG5EI16_V_MF4_MF8 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #5443 = PseudoVLUXSEG5EI16_V_MF4_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #5442 = PseudoVLUXSEG5EI16_V_MF4_MF4 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #5441 = PseudoVLUXSEG5EI16_V_MF4_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #5440 = PseudoVLUXSEG5EI16_V_MF4_MF2 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #5439 = PseudoVLUXSEG5EI16_V_MF4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #5438 = PseudoVLUXSEG5EI16_V_MF4_M1 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #5437 = PseudoVLUXSEG5EI16_V_MF2_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #5436 = PseudoVLUXSEG5EI16_V_MF2_MF4 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #5435 = PseudoVLUXSEG5EI16_V_MF2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #5434 = PseudoVLUXSEG5EI16_V_MF2_MF2 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #5433 = PseudoVLUXSEG5EI16_V_MF2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #5432 = PseudoVLUXSEG5EI16_V_MF2_M1 + { 8, &RISCVDescs.OperandInfo[4603] }, // Inst #5431 = PseudoVLUXSEG5EI16_V_M2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4596] }, // Inst #5430 = PseudoVLUXSEG5EI16_V_M2_M1 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #5429 = PseudoVLUXSEG5EI16_V_M1_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #5428 = PseudoVLUXSEG5EI16_V_M1_MF2 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #5427 = PseudoVLUXSEG5EI16_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #5426 = PseudoVLUXSEG5EI16_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #5425 = PseudoVLUXSEG4EI8_V_MF8_MF8_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #5424 = PseudoVLUXSEG4EI8_V_MF8_MF8 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #5423 = PseudoVLUXSEG4EI8_V_MF8_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #5422 = PseudoVLUXSEG4EI8_V_MF8_MF4 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #5421 = PseudoVLUXSEG4EI8_V_MF8_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #5420 = PseudoVLUXSEG4EI8_V_MF8_MF2 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #5419 = PseudoVLUXSEG4EI8_V_MF8_M1_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #5418 = PseudoVLUXSEG4EI8_V_MF8_M1 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #5417 = PseudoVLUXSEG4EI8_V_MF4_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #5416 = PseudoVLUXSEG4EI8_V_MF4_MF4 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #5415 = PseudoVLUXSEG4EI8_V_MF4_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #5414 = PseudoVLUXSEG4EI8_V_MF4_MF2 + { 8, &RISCVDescs.OperandInfo[4483] }, // Inst #5413 = PseudoVLUXSEG4EI8_V_MF4_M2_MASK + { 7, &RISCVDescs.OperandInfo[4476] }, // Inst #5412 = PseudoVLUXSEG4EI8_V_MF4_M2 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #5411 = PseudoVLUXSEG4EI8_V_MF4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #5410 = PseudoVLUXSEG4EI8_V_MF4_M1 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #5409 = PseudoVLUXSEG4EI8_V_MF2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #5408 = PseudoVLUXSEG4EI8_V_MF2_MF2 + { 8, &RISCVDescs.OperandInfo[4483] }, // Inst #5407 = PseudoVLUXSEG4EI8_V_MF2_M2_MASK + { 7, &RISCVDescs.OperandInfo[4476] }, // Inst #5406 = PseudoVLUXSEG4EI8_V_MF2_M2 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #5405 = PseudoVLUXSEG4EI8_V_MF2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #5404 = PseudoVLUXSEG4EI8_V_MF2_M1 + { 8, &RISCVDescs.OperandInfo[4513] }, // Inst #5403 = PseudoVLUXSEG4EI8_V_M2_M2_MASK + { 7, &RISCVDescs.OperandInfo[4506] }, // Inst #5402 = PseudoVLUXSEG4EI8_V_M2_M2 + { 8, &RISCVDescs.OperandInfo[4483] }, // Inst #5401 = PseudoVLUXSEG4EI8_V_M1_M2_MASK + { 7, &RISCVDescs.OperandInfo[4476] }, // Inst #5400 = PseudoVLUXSEG4EI8_V_M1_M2 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #5399 = PseudoVLUXSEG4EI8_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #5398 = PseudoVLUXSEG4EI8_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[4558] }, // Inst #5397 = PseudoVLUXSEG4EI64_V_M8_M2_MASK + { 7, &RISCVDescs.OperandInfo[4551] }, // Inst #5396 = PseudoVLUXSEG4EI64_V_M8_M2 + { 8, &RISCVDescs.OperandInfo[4573] }, // Inst #5395 = PseudoVLUXSEG4EI64_V_M8_M1_MASK + { 7, &RISCVDescs.OperandInfo[4566] }, // Inst #5394 = PseudoVLUXSEG4EI64_V_M8_M1 + { 8, &RISCVDescs.OperandInfo[4543] }, // Inst #5393 = PseudoVLUXSEG4EI64_V_M4_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4536] }, // Inst #5392 = PseudoVLUXSEG4EI64_V_M4_MF2 + { 8, &RISCVDescs.OperandInfo[4528] }, // Inst #5391 = PseudoVLUXSEG4EI64_V_M4_M2_MASK + { 7, &RISCVDescs.OperandInfo[4521] }, // Inst #5390 = PseudoVLUXSEG4EI64_V_M4_M2 + { 8, &RISCVDescs.OperandInfo[4543] }, // Inst #5389 = PseudoVLUXSEG4EI64_V_M4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4536] }, // Inst #5388 = PseudoVLUXSEG4EI64_V_M4_M1 + { 8, &RISCVDescs.OperandInfo[4498] }, // Inst #5387 = PseudoVLUXSEG4EI64_V_M2_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4491] }, // Inst #5386 = PseudoVLUXSEG4EI64_V_M2_MF4 + { 8, &RISCVDescs.OperandInfo[4498] }, // Inst #5385 = PseudoVLUXSEG4EI64_V_M2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4491] }, // Inst #5384 = PseudoVLUXSEG4EI64_V_M2_MF2 + { 8, &RISCVDescs.OperandInfo[4513] }, // Inst #5383 = PseudoVLUXSEG4EI64_V_M2_M2_MASK + { 7, &RISCVDescs.OperandInfo[4506] }, // Inst #5382 = PseudoVLUXSEG4EI64_V_M2_M2 + { 8, &RISCVDescs.OperandInfo[4498] }, // Inst #5381 = PseudoVLUXSEG4EI64_V_M2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4491] }, // Inst #5380 = PseudoVLUXSEG4EI64_V_M2_M1 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #5379 = PseudoVLUXSEG4EI64_V_M1_MF8_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #5378 = PseudoVLUXSEG4EI64_V_M1_MF8 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #5377 = PseudoVLUXSEG4EI64_V_M1_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #5376 = PseudoVLUXSEG4EI64_V_M1_MF4 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #5375 = PseudoVLUXSEG4EI64_V_M1_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #5374 = PseudoVLUXSEG4EI64_V_M1_MF2 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #5373 = PseudoVLUXSEG4EI64_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #5372 = PseudoVLUXSEG4EI64_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #5371 = PseudoVLUXSEG4EI32_V_MF2_MF8_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #5370 = PseudoVLUXSEG4EI32_V_MF2_MF8 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #5369 = PseudoVLUXSEG4EI32_V_MF2_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #5368 = PseudoVLUXSEG4EI32_V_MF2_MF4 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #5367 = PseudoVLUXSEG4EI32_V_MF2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #5366 = PseudoVLUXSEG4EI32_V_MF2_MF2 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #5365 = PseudoVLUXSEG4EI32_V_MF2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #5364 = PseudoVLUXSEG4EI32_V_MF2_M1 + { 8, &RISCVDescs.OperandInfo[4558] }, // Inst #5363 = PseudoVLUXSEG4EI32_V_M8_M2_MASK + { 7, &RISCVDescs.OperandInfo[4551] }, // Inst #5362 = PseudoVLUXSEG4EI32_V_M8_M2 + { 8, &RISCVDescs.OperandInfo[4528] }, // Inst #5361 = PseudoVLUXSEG4EI32_V_M4_M2_MASK + { 7, &RISCVDescs.OperandInfo[4521] }, // Inst #5360 = PseudoVLUXSEG4EI32_V_M4_M2 + { 8, &RISCVDescs.OperandInfo[4543] }, // Inst #5359 = PseudoVLUXSEG4EI32_V_M4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4536] }, // Inst #5358 = PseudoVLUXSEG4EI32_V_M4_M1 + { 8, &RISCVDescs.OperandInfo[4498] }, // Inst #5357 = PseudoVLUXSEG4EI32_V_M2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4491] }, // Inst #5356 = PseudoVLUXSEG4EI32_V_M2_MF2 + { 8, &RISCVDescs.OperandInfo[4513] }, // Inst #5355 = PseudoVLUXSEG4EI32_V_M2_M2_MASK + { 7, &RISCVDescs.OperandInfo[4506] }, // Inst #5354 = PseudoVLUXSEG4EI32_V_M2_M2 + { 8, &RISCVDescs.OperandInfo[4498] }, // Inst #5353 = PseudoVLUXSEG4EI32_V_M2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4491] }, // Inst #5352 = PseudoVLUXSEG4EI32_V_M2_M1 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #5351 = PseudoVLUXSEG4EI32_V_M1_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #5350 = PseudoVLUXSEG4EI32_V_M1_MF4 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #5349 = PseudoVLUXSEG4EI32_V_M1_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #5348 = PseudoVLUXSEG4EI32_V_M1_MF2 + { 8, &RISCVDescs.OperandInfo[4483] }, // Inst #5347 = PseudoVLUXSEG4EI32_V_M1_M2_MASK + { 7, &RISCVDescs.OperandInfo[4476] }, // Inst #5346 = PseudoVLUXSEG4EI32_V_M1_M2 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #5345 = PseudoVLUXSEG4EI32_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #5344 = PseudoVLUXSEG4EI32_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #5343 = PseudoVLUXSEG4EI16_V_MF4_MF8_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #5342 = PseudoVLUXSEG4EI16_V_MF4_MF8 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #5341 = PseudoVLUXSEG4EI16_V_MF4_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #5340 = PseudoVLUXSEG4EI16_V_MF4_MF4 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #5339 = PseudoVLUXSEG4EI16_V_MF4_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #5338 = PseudoVLUXSEG4EI16_V_MF4_MF2 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #5337 = PseudoVLUXSEG4EI16_V_MF4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #5336 = PseudoVLUXSEG4EI16_V_MF4_M1 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #5335 = PseudoVLUXSEG4EI16_V_MF2_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #5334 = PseudoVLUXSEG4EI16_V_MF2_MF4 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #5333 = PseudoVLUXSEG4EI16_V_MF2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #5332 = PseudoVLUXSEG4EI16_V_MF2_MF2 + { 8, &RISCVDescs.OperandInfo[4483] }, // Inst #5331 = PseudoVLUXSEG4EI16_V_MF2_M2_MASK + { 7, &RISCVDescs.OperandInfo[4476] }, // Inst #5330 = PseudoVLUXSEG4EI16_V_MF2_M2 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #5329 = PseudoVLUXSEG4EI16_V_MF2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #5328 = PseudoVLUXSEG4EI16_V_MF2_M1 + { 8, &RISCVDescs.OperandInfo[4528] }, // Inst #5327 = PseudoVLUXSEG4EI16_V_M4_M2_MASK + { 7, &RISCVDescs.OperandInfo[4521] }, // Inst #5326 = PseudoVLUXSEG4EI16_V_M4_M2 + { 8, &RISCVDescs.OperandInfo[4513] }, // Inst #5325 = PseudoVLUXSEG4EI16_V_M2_M2_MASK + { 7, &RISCVDescs.OperandInfo[4506] }, // Inst #5324 = PseudoVLUXSEG4EI16_V_M2_M2 + { 8, &RISCVDescs.OperandInfo[4498] }, // Inst #5323 = PseudoVLUXSEG4EI16_V_M2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4491] }, // Inst #5322 = PseudoVLUXSEG4EI16_V_M2_M1 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #5321 = PseudoVLUXSEG4EI16_V_M1_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #5320 = PseudoVLUXSEG4EI16_V_M1_MF2 + { 8, &RISCVDescs.OperandInfo[4483] }, // Inst #5319 = PseudoVLUXSEG4EI16_V_M1_M2_MASK + { 7, &RISCVDescs.OperandInfo[4476] }, // Inst #5318 = PseudoVLUXSEG4EI16_V_M1_M2 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #5317 = PseudoVLUXSEG4EI16_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #5316 = PseudoVLUXSEG4EI16_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #5315 = PseudoVLUXSEG3EI8_V_MF8_MF8_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #5314 = PseudoVLUXSEG3EI8_V_MF8_MF8 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #5313 = PseudoVLUXSEG3EI8_V_MF8_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #5312 = PseudoVLUXSEG3EI8_V_MF8_MF4 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #5311 = PseudoVLUXSEG3EI8_V_MF8_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #5310 = PseudoVLUXSEG3EI8_V_MF8_MF2 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #5309 = PseudoVLUXSEG3EI8_V_MF8_M1_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #5308 = PseudoVLUXSEG3EI8_V_MF8_M1 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #5307 = PseudoVLUXSEG3EI8_V_MF4_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #5306 = PseudoVLUXSEG3EI8_V_MF4_MF4 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #5305 = PseudoVLUXSEG3EI8_V_MF4_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #5304 = PseudoVLUXSEG3EI8_V_MF4_MF2 + { 8, &RISCVDescs.OperandInfo[4363] }, // Inst #5303 = PseudoVLUXSEG3EI8_V_MF4_M2_MASK + { 7, &RISCVDescs.OperandInfo[4356] }, // Inst #5302 = PseudoVLUXSEG3EI8_V_MF4_M2 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #5301 = PseudoVLUXSEG3EI8_V_MF4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #5300 = PseudoVLUXSEG3EI8_V_MF4_M1 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #5299 = PseudoVLUXSEG3EI8_V_MF2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #5298 = PseudoVLUXSEG3EI8_V_MF2_MF2 + { 8, &RISCVDescs.OperandInfo[4363] }, // Inst #5297 = PseudoVLUXSEG3EI8_V_MF2_M2_MASK + { 7, &RISCVDescs.OperandInfo[4356] }, // Inst #5296 = PseudoVLUXSEG3EI8_V_MF2_M2 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #5295 = PseudoVLUXSEG3EI8_V_MF2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #5294 = PseudoVLUXSEG3EI8_V_MF2_M1 + { 8, &RISCVDescs.OperandInfo[4393] }, // Inst #5293 = PseudoVLUXSEG3EI8_V_M2_M2_MASK + { 7, &RISCVDescs.OperandInfo[4386] }, // Inst #5292 = PseudoVLUXSEG3EI8_V_M2_M2 + { 8, &RISCVDescs.OperandInfo[4363] }, // Inst #5291 = PseudoVLUXSEG3EI8_V_M1_M2_MASK + { 7, &RISCVDescs.OperandInfo[4356] }, // Inst #5290 = PseudoVLUXSEG3EI8_V_M1_M2 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #5289 = PseudoVLUXSEG3EI8_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #5288 = PseudoVLUXSEG3EI8_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[4438] }, // Inst #5287 = PseudoVLUXSEG3EI64_V_M8_M2_MASK + { 7, &RISCVDescs.OperandInfo[4431] }, // Inst #5286 = PseudoVLUXSEG3EI64_V_M8_M2 + { 8, &RISCVDescs.OperandInfo[4453] }, // Inst #5285 = PseudoVLUXSEG3EI64_V_M8_M1_MASK + { 7, &RISCVDescs.OperandInfo[4446] }, // Inst #5284 = PseudoVLUXSEG3EI64_V_M8_M1 + { 8, &RISCVDescs.OperandInfo[4423] }, // Inst #5283 = PseudoVLUXSEG3EI64_V_M4_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4416] }, // Inst #5282 = PseudoVLUXSEG3EI64_V_M4_MF2 + { 8, &RISCVDescs.OperandInfo[4408] }, // Inst #5281 = PseudoVLUXSEG3EI64_V_M4_M2_MASK + { 7, &RISCVDescs.OperandInfo[4401] }, // Inst #5280 = PseudoVLUXSEG3EI64_V_M4_M2 + { 8, &RISCVDescs.OperandInfo[4423] }, // Inst #5279 = PseudoVLUXSEG3EI64_V_M4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4416] }, // Inst #5278 = PseudoVLUXSEG3EI64_V_M4_M1 + { 8, &RISCVDescs.OperandInfo[4378] }, // Inst #5277 = PseudoVLUXSEG3EI64_V_M2_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4371] }, // Inst #5276 = PseudoVLUXSEG3EI64_V_M2_MF4 + { 8, &RISCVDescs.OperandInfo[4378] }, // Inst #5275 = PseudoVLUXSEG3EI64_V_M2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4371] }, // Inst #5274 = PseudoVLUXSEG3EI64_V_M2_MF2 + { 8, &RISCVDescs.OperandInfo[4393] }, // Inst #5273 = PseudoVLUXSEG3EI64_V_M2_M2_MASK + { 7, &RISCVDescs.OperandInfo[4386] }, // Inst #5272 = PseudoVLUXSEG3EI64_V_M2_M2 + { 8, &RISCVDescs.OperandInfo[4378] }, // Inst #5271 = PseudoVLUXSEG3EI64_V_M2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4371] }, // Inst #5270 = PseudoVLUXSEG3EI64_V_M2_M1 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #5269 = PseudoVLUXSEG3EI64_V_M1_MF8_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #5268 = PseudoVLUXSEG3EI64_V_M1_MF8 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #5267 = PseudoVLUXSEG3EI64_V_M1_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #5266 = PseudoVLUXSEG3EI64_V_M1_MF4 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #5265 = PseudoVLUXSEG3EI64_V_M1_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #5264 = PseudoVLUXSEG3EI64_V_M1_MF2 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #5263 = PseudoVLUXSEG3EI64_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #5262 = PseudoVLUXSEG3EI64_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #5261 = PseudoVLUXSEG3EI32_V_MF2_MF8_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #5260 = PseudoVLUXSEG3EI32_V_MF2_MF8 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #5259 = PseudoVLUXSEG3EI32_V_MF2_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #5258 = PseudoVLUXSEG3EI32_V_MF2_MF4 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #5257 = PseudoVLUXSEG3EI32_V_MF2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #5256 = PseudoVLUXSEG3EI32_V_MF2_MF2 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #5255 = PseudoVLUXSEG3EI32_V_MF2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #5254 = PseudoVLUXSEG3EI32_V_MF2_M1 + { 8, &RISCVDescs.OperandInfo[4438] }, // Inst #5253 = PseudoVLUXSEG3EI32_V_M8_M2_MASK + { 7, &RISCVDescs.OperandInfo[4431] }, // Inst #5252 = PseudoVLUXSEG3EI32_V_M8_M2 + { 8, &RISCVDescs.OperandInfo[4408] }, // Inst #5251 = PseudoVLUXSEG3EI32_V_M4_M2_MASK + { 7, &RISCVDescs.OperandInfo[4401] }, // Inst #5250 = PseudoVLUXSEG3EI32_V_M4_M2 + { 8, &RISCVDescs.OperandInfo[4423] }, // Inst #5249 = PseudoVLUXSEG3EI32_V_M4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4416] }, // Inst #5248 = PseudoVLUXSEG3EI32_V_M4_M1 + { 8, &RISCVDescs.OperandInfo[4378] }, // Inst #5247 = PseudoVLUXSEG3EI32_V_M2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4371] }, // Inst #5246 = PseudoVLUXSEG3EI32_V_M2_MF2 + { 8, &RISCVDescs.OperandInfo[4393] }, // Inst #5245 = PseudoVLUXSEG3EI32_V_M2_M2_MASK + { 7, &RISCVDescs.OperandInfo[4386] }, // Inst #5244 = PseudoVLUXSEG3EI32_V_M2_M2 + { 8, &RISCVDescs.OperandInfo[4378] }, // Inst #5243 = PseudoVLUXSEG3EI32_V_M2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4371] }, // Inst #5242 = PseudoVLUXSEG3EI32_V_M2_M1 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #5241 = PseudoVLUXSEG3EI32_V_M1_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #5240 = PseudoVLUXSEG3EI32_V_M1_MF4 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #5239 = PseudoVLUXSEG3EI32_V_M1_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #5238 = PseudoVLUXSEG3EI32_V_M1_MF2 + { 8, &RISCVDescs.OperandInfo[4363] }, // Inst #5237 = PseudoVLUXSEG3EI32_V_M1_M2_MASK + { 7, &RISCVDescs.OperandInfo[4356] }, // Inst #5236 = PseudoVLUXSEG3EI32_V_M1_M2 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #5235 = PseudoVLUXSEG3EI32_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #5234 = PseudoVLUXSEG3EI32_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #5233 = PseudoVLUXSEG3EI16_V_MF4_MF8_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #5232 = PseudoVLUXSEG3EI16_V_MF4_MF8 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #5231 = PseudoVLUXSEG3EI16_V_MF4_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #5230 = PseudoVLUXSEG3EI16_V_MF4_MF4 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #5229 = PseudoVLUXSEG3EI16_V_MF4_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #5228 = PseudoVLUXSEG3EI16_V_MF4_MF2 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #5227 = PseudoVLUXSEG3EI16_V_MF4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #5226 = PseudoVLUXSEG3EI16_V_MF4_M1 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #5225 = PseudoVLUXSEG3EI16_V_MF2_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #5224 = PseudoVLUXSEG3EI16_V_MF2_MF4 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #5223 = PseudoVLUXSEG3EI16_V_MF2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #5222 = PseudoVLUXSEG3EI16_V_MF2_MF2 + { 8, &RISCVDescs.OperandInfo[4363] }, // Inst #5221 = PseudoVLUXSEG3EI16_V_MF2_M2_MASK + { 7, &RISCVDescs.OperandInfo[4356] }, // Inst #5220 = PseudoVLUXSEG3EI16_V_MF2_M2 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #5219 = PseudoVLUXSEG3EI16_V_MF2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #5218 = PseudoVLUXSEG3EI16_V_MF2_M1 + { 8, &RISCVDescs.OperandInfo[4408] }, // Inst #5217 = PseudoVLUXSEG3EI16_V_M4_M2_MASK + { 7, &RISCVDescs.OperandInfo[4401] }, // Inst #5216 = PseudoVLUXSEG3EI16_V_M4_M2 + { 8, &RISCVDescs.OperandInfo[4393] }, // Inst #5215 = PseudoVLUXSEG3EI16_V_M2_M2_MASK + { 7, &RISCVDescs.OperandInfo[4386] }, // Inst #5214 = PseudoVLUXSEG3EI16_V_M2_M2 + { 8, &RISCVDescs.OperandInfo[4378] }, // Inst #5213 = PseudoVLUXSEG3EI16_V_M2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4371] }, // Inst #5212 = PseudoVLUXSEG3EI16_V_M2_M1 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #5211 = PseudoVLUXSEG3EI16_V_M1_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #5210 = PseudoVLUXSEG3EI16_V_M1_MF2 + { 8, &RISCVDescs.OperandInfo[4363] }, // Inst #5209 = PseudoVLUXSEG3EI16_V_M1_M2_MASK + { 7, &RISCVDescs.OperandInfo[4356] }, // Inst #5208 = PseudoVLUXSEG3EI16_V_M1_M2 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #5207 = PseudoVLUXSEG3EI16_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #5206 = PseudoVLUXSEG3EI16_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #5205 = PseudoVLUXSEG2EI8_V_MF8_MF8_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #5204 = PseudoVLUXSEG2EI8_V_MF8_MF8 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #5203 = PseudoVLUXSEG2EI8_V_MF8_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #5202 = PseudoVLUXSEG2EI8_V_MF8_MF4 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #5201 = PseudoVLUXSEG2EI8_V_MF8_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #5200 = PseudoVLUXSEG2EI8_V_MF8_MF2 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #5199 = PseudoVLUXSEG2EI8_V_MF8_M1_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #5198 = PseudoVLUXSEG2EI8_V_MF8_M1 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #5197 = PseudoVLUXSEG2EI8_V_MF4_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #5196 = PseudoVLUXSEG2EI8_V_MF4_MF4 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #5195 = PseudoVLUXSEG2EI8_V_MF4_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #5194 = PseudoVLUXSEG2EI8_V_MF4_MF2 + { 8, &RISCVDescs.OperandInfo[4183] }, // Inst #5193 = PseudoVLUXSEG2EI8_V_MF4_M2_MASK + { 7, &RISCVDescs.OperandInfo[4176] }, // Inst #5192 = PseudoVLUXSEG2EI8_V_MF4_M2 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #5191 = PseudoVLUXSEG2EI8_V_MF4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #5190 = PseudoVLUXSEG2EI8_V_MF4_M1 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #5189 = PseudoVLUXSEG2EI8_V_MF2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #5188 = PseudoVLUXSEG2EI8_V_MF2_MF2 + { 8, &RISCVDescs.OperandInfo[4198] }, // Inst #5187 = PseudoVLUXSEG2EI8_V_MF2_M4_MASK + { 7, &RISCVDescs.OperandInfo[4191] }, // Inst #5186 = PseudoVLUXSEG2EI8_V_MF2_M4 + { 8, &RISCVDescs.OperandInfo[4183] }, // Inst #5185 = PseudoVLUXSEG2EI8_V_MF2_M2_MASK + { 7, &RISCVDescs.OperandInfo[4176] }, // Inst #5184 = PseudoVLUXSEG2EI8_V_MF2_M2 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #5183 = PseudoVLUXSEG2EI8_V_MF2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #5182 = PseudoVLUXSEG2EI8_V_MF2_M1 + { 8, &RISCVDescs.OperandInfo[4273] }, // Inst #5181 = PseudoVLUXSEG2EI8_V_M4_M4_MASK + { 7, &RISCVDescs.OperandInfo[4266] }, // Inst #5180 = PseudoVLUXSEG2EI8_V_M4_M4 + { 8, &RISCVDescs.OperandInfo[4243] }, // Inst #5179 = PseudoVLUXSEG2EI8_V_M2_M4_MASK + { 7, &RISCVDescs.OperandInfo[4236] }, // Inst #5178 = PseudoVLUXSEG2EI8_V_M2_M4 + { 8, &RISCVDescs.OperandInfo[4228] }, // Inst #5177 = PseudoVLUXSEG2EI8_V_M2_M2_MASK + { 7, &RISCVDescs.OperandInfo[4221] }, // Inst #5176 = PseudoVLUXSEG2EI8_V_M2_M2 + { 8, &RISCVDescs.OperandInfo[4198] }, // Inst #5175 = PseudoVLUXSEG2EI8_V_M1_M4_MASK + { 7, &RISCVDescs.OperandInfo[4191] }, // Inst #5174 = PseudoVLUXSEG2EI8_V_M1_M4 + { 8, &RISCVDescs.OperandInfo[4183] }, // Inst #5173 = PseudoVLUXSEG2EI8_V_M1_M2_MASK + { 7, &RISCVDescs.OperandInfo[4176] }, // Inst #5172 = PseudoVLUXSEG2EI8_V_M1_M2 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #5171 = PseudoVLUXSEG2EI8_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #5170 = PseudoVLUXSEG2EI8_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[4288] }, // Inst #5169 = PseudoVLUXSEG2EI64_V_M8_M4_MASK + { 7, &RISCVDescs.OperandInfo[4281] }, // Inst #5168 = PseudoVLUXSEG2EI64_V_M8_M4 + { 8, &RISCVDescs.OperandInfo[4318] }, // Inst #5167 = PseudoVLUXSEG2EI64_V_M8_M2_MASK + { 7, &RISCVDescs.OperandInfo[4311] }, // Inst #5166 = PseudoVLUXSEG2EI64_V_M8_M2 + { 8, &RISCVDescs.OperandInfo[4333] }, // Inst #5165 = PseudoVLUXSEG2EI64_V_M8_M1_MASK + { 7, &RISCVDescs.OperandInfo[4326] }, // Inst #5164 = PseudoVLUXSEG2EI64_V_M8_M1 + { 8, &RISCVDescs.OperandInfo[4303] }, // Inst #5163 = PseudoVLUXSEG2EI64_V_M4_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4296] }, // Inst #5162 = PseudoVLUXSEG2EI64_V_M4_MF2 + { 8, &RISCVDescs.OperandInfo[4273] }, // Inst #5161 = PseudoVLUXSEG2EI64_V_M4_M4_MASK + { 7, &RISCVDescs.OperandInfo[4266] }, // Inst #5160 = PseudoVLUXSEG2EI64_V_M4_M4 + { 8, &RISCVDescs.OperandInfo[4258] }, // Inst #5159 = PseudoVLUXSEG2EI64_V_M4_M2_MASK + { 7, &RISCVDescs.OperandInfo[4251] }, // Inst #5158 = PseudoVLUXSEG2EI64_V_M4_M2 + { 8, &RISCVDescs.OperandInfo[4303] }, // Inst #5157 = PseudoVLUXSEG2EI64_V_M4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4296] }, // Inst #5156 = PseudoVLUXSEG2EI64_V_M4_M1 + { 8, &RISCVDescs.OperandInfo[4213] }, // Inst #5155 = PseudoVLUXSEG2EI64_V_M2_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4206] }, // Inst #5154 = PseudoVLUXSEG2EI64_V_M2_MF4 + { 8, &RISCVDescs.OperandInfo[4213] }, // Inst #5153 = PseudoVLUXSEG2EI64_V_M2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4206] }, // Inst #5152 = PseudoVLUXSEG2EI64_V_M2_MF2 + { 8, &RISCVDescs.OperandInfo[4228] }, // Inst #5151 = PseudoVLUXSEG2EI64_V_M2_M2_MASK + { 7, &RISCVDescs.OperandInfo[4221] }, // Inst #5150 = PseudoVLUXSEG2EI64_V_M2_M2 + { 8, &RISCVDescs.OperandInfo[4213] }, // Inst #5149 = PseudoVLUXSEG2EI64_V_M2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4206] }, // Inst #5148 = PseudoVLUXSEG2EI64_V_M2_M1 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #5147 = PseudoVLUXSEG2EI64_V_M1_MF8_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #5146 = PseudoVLUXSEG2EI64_V_M1_MF8 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #5145 = PseudoVLUXSEG2EI64_V_M1_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #5144 = PseudoVLUXSEG2EI64_V_M1_MF4 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #5143 = PseudoVLUXSEG2EI64_V_M1_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #5142 = PseudoVLUXSEG2EI64_V_M1_MF2 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #5141 = PseudoVLUXSEG2EI64_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #5140 = PseudoVLUXSEG2EI64_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #5139 = PseudoVLUXSEG2EI32_V_MF2_MF8_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #5138 = PseudoVLUXSEG2EI32_V_MF2_MF8 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #5137 = PseudoVLUXSEG2EI32_V_MF2_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #5136 = PseudoVLUXSEG2EI32_V_MF2_MF4 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #5135 = PseudoVLUXSEG2EI32_V_MF2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #5134 = PseudoVLUXSEG2EI32_V_MF2_MF2 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #5133 = PseudoVLUXSEG2EI32_V_MF2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #5132 = PseudoVLUXSEG2EI32_V_MF2_M1 + { 8, &RISCVDescs.OperandInfo[4288] }, // Inst #5131 = PseudoVLUXSEG2EI32_V_M8_M4_MASK + { 7, &RISCVDescs.OperandInfo[4281] }, // Inst #5130 = PseudoVLUXSEG2EI32_V_M8_M4 + { 8, &RISCVDescs.OperandInfo[4318] }, // Inst #5129 = PseudoVLUXSEG2EI32_V_M8_M2_MASK + { 7, &RISCVDescs.OperandInfo[4311] }, // Inst #5128 = PseudoVLUXSEG2EI32_V_M8_M2 + { 8, &RISCVDescs.OperandInfo[4273] }, // Inst #5127 = PseudoVLUXSEG2EI32_V_M4_M4_MASK + { 7, &RISCVDescs.OperandInfo[4266] }, // Inst #5126 = PseudoVLUXSEG2EI32_V_M4_M4 + { 8, &RISCVDescs.OperandInfo[4258] }, // Inst #5125 = PseudoVLUXSEG2EI32_V_M4_M2_MASK + { 7, &RISCVDescs.OperandInfo[4251] }, // Inst #5124 = PseudoVLUXSEG2EI32_V_M4_M2 + { 8, &RISCVDescs.OperandInfo[4303] }, // Inst #5123 = PseudoVLUXSEG2EI32_V_M4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4296] }, // Inst #5122 = PseudoVLUXSEG2EI32_V_M4_M1 + { 8, &RISCVDescs.OperandInfo[4213] }, // Inst #5121 = PseudoVLUXSEG2EI32_V_M2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4206] }, // Inst #5120 = PseudoVLUXSEG2EI32_V_M2_MF2 + { 8, &RISCVDescs.OperandInfo[4243] }, // Inst #5119 = PseudoVLUXSEG2EI32_V_M2_M4_MASK + { 7, &RISCVDescs.OperandInfo[4236] }, // Inst #5118 = PseudoVLUXSEG2EI32_V_M2_M4 + { 8, &RISCVDescs.OperandInfo[4228] }, // Inst #5117 = PseudoVLUXSEG2EI32_V_M2_M2_MASK + { 7, &RISCVDescs.OperandInfo[4221] }, // Inst #5116 = PseudoVLUXSEG2EI32_V_M2_M2 + { 8, &RISCVDescs.OperandInfo[4213] }, // Inst #5115 = PseudoVLUXSEG2EI32_V_M2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4206] }, // Inst #5114 = PseudoVLUXSEG2EI32_V_M2_M1 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #5113 = PseudoVLUXSEG2EI32_V_M1_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #5112 = PseudoVLUXSEG2EI32_V_M1_MF4 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #5111 = PseudoVLUXSEG2EI32_V_M1_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #5110 = PseudoVLUXSEG2EI32_V_M1_MF2 + { 8, &RISCVDescs.OperandInfo[4183] }, // Inst #5109 = PseudoVLUXSEG2EI32_V_M1_M2_MASK + { 7, &RISCVDescs.OperandInfo[4176] }, // Inst #5108 = PseudoVLUXSEG2EI32_V_M1_M2 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #5107 = PseudoVLUXSEG2EI32_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #5106 = PseudoVLUXSEG2EI32_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #5105 = PseudoVLUXSEG2EI16_V_MF4_MF8_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #5104 = PseudoVLUXSEG2EI16_V_MF4_MF8 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #5103 = PseudoVLUXSEG2EI16_V_MF4_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #5102 = PseudoVLUXSEG2EI16_V_MF4_MF4 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #5101 = PseudoVLUXSEG2EI16_V_MF4_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #5100 = PseudoVLUXSEG2EI16_V_MF4_MF2 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #5099 = PseudoVLUXSEG2EI16_V_MF4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #5098 = PseudoVLUXSEG2EI16_V_MF4_M1 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #5097 = PseudoVLUXSEG2EI16_V_MF2_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #5096 = PseudoVLUXSEG2EI16_V_MF2_MF4 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #5095 = PseudoVLUXSEG2EI16_V_MF2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #5094 = PseudoVLUXSEG2EI16_V_MF2_MF2 + { 8, &RISCVDescs.OperandInfo[4183] }, // Inst #5093 = PseudoVLUXSEG2EI16_V_MF2_M2_MASK + { 7, &RISCVDescs.OperandInfo[4176] }, // Inst #5092 = PseudoVLUXSEG2EI16_V_MF2_M2 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #5091 = PseudoVLUXSEG2EI16_V_MF2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #5090 = PseudoVLUXSEG2EI16_V_MF2_M1 + { 8, &RISCVDescs.OperandInfo[4288] }, // Inst #5089 = PseudoVLUXSEG2EI16_V_M8_M4_MASK + { 7, &RISCVDescs.OperandInfo[4281] }, // Inst #5088 = PseudoVLUXSEG2EI16_V_M8_M4 + { 8, &RISCVDescs.OperandInfo[4273] }, // Inst #5087 = PseudoVLUXSEG2EI16_V_M4_M4_MASK + { 7, &RISCVDescs.OperandInfo[4266] }, // Inst #5086 = PseudoVLUXSEG2EI16_V_M4_M4 + { 8, &RISCVDescs.OperandInfo[4258] }, // Inst #5085 = PseudoVLUXSEG2EI16_V_M4_M2_MASK + { 7, &RISCVDescs.OperandInfo[4251] }, // Inst #5084 = PseudoVLUXSEG2EI16_V_M4_M2 + { 8, &RISCVDescs.OperandInfo[4243] }, // Inst #5083 = PseudoVLUXSEG2EI16_V_M2_M4_MASK + { 7, &RISCVDescs.OperandInfo[4236] }, // Inst #5082 = PseudoVLUXSEG2EI16_V_M2_M4 + { 8, &RISCVDescs.OperandInfo[4228] }, // Inst #5081 = PseudoVLUXSEG2EI16_V_M2_M2_MASK + { 7, &RISCVDescs.OperandInfo[4221] }, // Inst #5080 = PseudoVLUXSEG2EI16_V_M2_M2 + { 8, &RISCVDescs.OperandInfo[4213] }, // Inst #5079 = PseudoVLUXSEG2EI16_V_M2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4206] }, // Inst #5078 = PseudoVLUXSEG2EI16_V_M2_M1 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #5077 = PseudoVLUXSEG2EI16_V_M1_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #5076 = PseudoVLUXSEG2EI16_V_M1_MF2 + { 8, &RISCVDescs.OperandInfo[4198] }, // Inst #5075 = PseudoVLUXSEG2EI16_V_M1_M4_MASK + { 7, &RISCVDescs.OperandInfo[4191] }, // Inst #5074 = PseudoVLUXSEG2EI16_V_M1_M4 + { 8, &RISCVDescs.OperandInfo[4183] }, // Inst #5073 = PseudoVLUXSEG2EI16_V_M1_M2_MASK + { 7, &RISCVDescs.OperandInfo[4176] }, // Inst #5072 = PseudoVLUXSEG2EI16_V_M1_M2 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #5071 = PseudoVLUXSEG2EI16_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #5070 = PseudoVLUXSEG2EI16_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[3913] }, // Inst #5069 = PseudoVLUXEI8_V_MF8_MF8_MASK + { 7, &RISCVDescs.OperandInfo[3906] }, // Inst #5068 = PseudoVLUXEI8_V_MF8_MF8 + { 8, &RISCVDescs.OperandInfo[3958] }, // Inst #5067 = PseudoVLUXEI8_V_MF8_MF4_MASK + { 7, &RISCVDescs.OperandInfo[3951] }, // Inst #5066 = PseudoVLUXEI8_V_MF8_MF4 + { 8, &RISCVDescs.OperandInfo[3958] }, // Inst #5065 = PseudoVLUXEI8_V_MF8_MF2_MASK + { 7, &RISCVDescs.OperandInfo[3951] }, // Inst #5064 = PseudoVLUXEI8_V_MF8_MF2 + { 8, &RISCVDescs.OperandInfo[3958] }, // Inst #5063 = PseudoVLUXEI8_V_MF8_M1_MASK + { 7, &RISCVDescs.OperandInfo[3951] }, // Inst #5062 = PseudoVLUXEI8_V_MF8_M1 + { 8, &RISCVDescs.OperandInfo[3913] }, // Inst #5061 = PseudoVLUXEI8_V_MF4_MF4_MASK + { 7, &RISCVDescs.OperandInfo[3906] }, // Inst #5060 = PseudoVLUXEI8_V_MF4_MF4 + { 8, &RISCVDescs.OperandInfo[3958] }, // Inst #5059 = PseudoVLUXEI8_V_MF4_MF2_MASK + { 7, &RISCVDescs.OperandInfo[3951] }, // Inst #5058 = PseudoVLUXEI8_V_MF4_MF2 + { 8, &RISCVDescs.OperandInfo[3928] }, // Inst #5057 = PseudoVLUXEI8_V_MF4_M2_MASK + { 7, &RISCVDescs.OperandInfo[3921] }, // Inst #5056 = PseudoVLUXEI8_V_MF4_M2 + { 8, &RISCVDescs.OperandInfo[3958] }, // Inst #5055 = PseudoVLUXEI8_V_MF4_M1_MASK + { 7, &RISCVDescs.OperandInfo[3951] }, // Inst #5054 = PseudoVLUXEI8_V_MF4_M1 + { 8, &RISCVDescs.OperandInfo[3913] }, // Inst #5053 = PseudoVLUXEI8_V_MF2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[3906] }, // Inst #5052 = PseudoVLUXEI8_V_MF2_MF2 + { 8, &RISCVDescs.OperandInfo[3943] }, // Inst #5051 = PseudoVLUXEI8_V_MF2_M4_MASK + { 7, &RISCVDescs.OperandInfo[3936] }, // Inst #5050 = PseudoVLUXEI8_V_MF2_M4 + { 8, &RISCVDescs.OperandInfo[3928] }, // Inst #5049 = PseudoVLUXEI8_V_MF2_M2_MASK + { 7, &RISCVDescs.OperandInfo[3921] }, // Inst #5048 = PseudoVLUXEI8_V_MF2_M2 + { 8, &RISCVDescs.OperandInfo[3958] }, // Inst #5047 = PseudoVLUXEI8_V_MF2_M1_MASK + { 7, &RISCVDescs.OperandInfo[3951] }, // Inst #5046 = PseudoVLUXEI8_V_MF2_M1 + { 8, &RISCVDescs.OperandInfo[4093] }, // Inst #5045 = PseudoVLUXEI8_V_M8_M8_MASK + { 7, &RISCVDescs.OperandInfo[4086] }, // Inst #5044 = PseudoVLUXEI8_V_M8_M8 + { 8, &RISCVDescs.OperandInfo[4063] }, // Inst #5043 = PseudoVLUXEI8_V_M4_M8_MASK + { 7, &RISCVDescs.OperandInfo[4056] }, // Inst #5042 = PseudoVLUXEI8_V_M4_M8 + { 8, &RISCVDescs.OperandInfo[4048] }, // Inst #5041 = PseudoVLUXEI8_V_M4_M4_MASK + { 7, &RISCVDescs.OperandInfo[4041] }, // Inst #5040 = PseudoVLUXEI8_V_M4_M4 + { 8, &RISCVDescs.OperandInfo[4018] }, // Inst #5039 = PseudoVLUXEI8_V_M2_M8_MASK + { 7, &RISCVDescs.OperandInfo[4011] }, // Inst #5038 = PseudoVLUXEI8_V_M2_M8 + { 8, &RISCVDescs.OperandInfo[4003] }, // Inst #5037 = PseudoVLUXEI8_V_M2_M4_MASK + { 7, &RISCVDescs.OperandInfo[3996] }, // Inst #5036 = PseudoVLUXEI8_V_M2_M4 + { 8, &RISCVDescs.OperandInfo[3988] }, // Inst #5035 = PseudoVLUXEI8_V_M2_M2_MASK + { 7, &RISCVDescs.OperandInfo[3981] }, // Inst #5034 = PseudoVLUXEI8_V_M2_M2 + { 8, &RISCVDescs.OperandInfo[4153] }, // Inst #5033 = PseudoVLUXEI8_V_M1_M8_MASK + { 7, &RISCVDescs.OperandInfo[4146] }, // Inst #5032 = PseudoVLUXEI8_V_M1_M8 + { 8, &RISCVDescs.OperandInfo[3943] }, // Inst #5031 = PseudoVLUXEI8_V_M1_M4_MASK + { 7, &RISCVDescs.OperandInfo[3936] }, // Inst #5030 = PseudoVLUXEI8_V_M1_M4 + { 8, &RISCVDescs.OperandInfo[3928] }, // Inst #5029 = PseudoVLUXEI8_V_M1_M2_MASK + { 7, &RISCVDescs.OperandInfo[3921] }, // Inst #5028 = PseudoVLUXEI8_V_M1_M2 + { 8, &RISCVDescs.OperandInfo[3913] }, // Inst #5027 = PseudoVLUXEI8_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[3906] }, // Inst #5026 = PseudoVLUXEI8_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[4093] }, // Inst #5025 = PseudoVLUXEI64_V_M8_M8_MASK + { 7, &RISCVDescs.OperandInfo[4086] }, // Inst #5024 = PseudoVLUXEI64_V_M8_M8 + { 8, &RISCVDescs.OperandInfo[4078] }, // Inst #5023 = PseudoVLUXEI64_V_M8_M4_MASK + { 7, &RISCVDescs.OperandInfo[4071] }, // Inst #5022 = PseudoVLUXEI64_V_M8_M4 + { 8, &RISCVDescs.OperandInfo[4123] }, // Inst #5021 = PseudoVLUXEI64_V_M8_M2_MASK + { 7, &RISCVDescs.OperandInfo[4116] }, // Inst #5020 = PseudoVLUXEI64_V_M8_M2 + { 8, &RISCVDescs.OperandInfo[4138] }, // Inst #5019 = PseudoVLUXEI64_V_M8_M1_MASK + { 7, &RISCVDescs.OperandInfo[4131] }, // Inst #5018 = PseudoVLUXEI64_V_M8_M1 + { 8, &RISCVDescs.OperandInfo[4108] }, // Inst #5017 = PseudoVLUXEI64_V_M4_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4101] }, // Inst #5016 = PseudoVLUXEI64_V_M4_MF2 + { 8, &RISCVDescs.OperandInfo[4048] }, // Inst #5015 = PseudoVLUXEI64_V_M4_M4_MASK + { 7, &RISCVDescs.OperandInfo[4041] }, // Inst #5014 = PseudoVLUXEI64_V_M4_M4 + { 8, &RISCVDescs.OperandInfo[4033] }, // Inst #5013 = PseudoVLUXEI64_V_M4_M2_MASK + { 7, &RISCVDescs.OperandInfo[4026] }, // Inst #5012 = PseudoVLUXEI64_V_M4_M2 + { 8, &RISCVDescs.OperandInfo[4108] }, // Inst #5011 = PseudoVLUXEI64_V_M4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4101] }, // Inst #5010 = PseudoVLUXEI64_V_M4_M1 + { 8, &RISCVDescs.OperandInfo[3973] }, // Inst #5009 = PseudoVLUXEI64_V_M2_MF4_MASK + { 7, &RISCVDescs.OperandInfo[3966] }, // Inst #5008 = PseudoVLUXEI64_V_M2_MF4 + { 8, &RISCVDescs.OperandInfo[3973] }, // Inst #5007 = PseudoVLUXEI64_V_M2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[3966] }, // Inst #5006 = PseudoVLUXEI64_V_M2_MF2 + { 8, &RISCVDescs.OperandInfo[3988] }, // Inst #5005 = PseudoVLUXEI64_V_M2_M2_MASK + { 7, &RISCVDescs.OperandInfo[3981] }, // Inst #5004 = PseudoVLUXEI64_V_M2_M2 + { 8, &RISCVDescs.OperandInfo[3973] }, // Inst #5003 = PseudoVLUXEI64_V_M2_M1_MASK + { 7, &RISCVDescs.OperandInfo[3966] }, // Inst #5002 = PseudoVLUXEI64_V_M2_M1 + { 8, &RISCVDescs.OperandInfo[3958] }, // Inst #5001 = PseudoVLUXEI64_V_M1_MF8_MASK + { 7, &RISCVDescs.OperandInfo[3951] }, // Inst #5000 = PseudoVLUXEI64_V_M1_MF8 + { 8, &RISCVDescs.OperandInfo[3958] }, // Inst #4999 = PseudoVLUXEI64_V_M1_MF4_MASK + { 7, &RISCVDescs.OperandInfo[3951] }, // Inst #4998 = PseudoVLUXEI64_V_M1_MF4 + { 8, &RISCVDescs.OperandInfo[3958] }, // Inst #4997 = PseudoVLUXEI64_V_M1_MF2_MASK + { 7, &RISCVDescs.OperandInfo[3951] }, // Inst #4996 = PseudoVLUXEI64_V_M1_MF2 + { 8, &RISCVDescs.OperandInfo[3913] }, // Inst #4995 = PseudoVLUXEI64_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[3906] }, // Inst #4994 = PseudoVLUXEI64_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[3958] }, // Inst #4993 = PseudoVLUXEI32_V_MF2_MF8_MASK + { 7, &RISCVDescs.OperandInfo[3951] }, // Inst #4992 = PseudoVLUXEI32_V_MF2_MF8 + { 8, &RISCVDescs.OperandInfo[3958] }, // Inst #4991 = PseudoVLUXEI32_V_MF2_MF4_MASK + { 7, &RISCVDescs.OperandInfo[3951] }, // Inst #4990 = PseudoVLUXEI32_V_MF2_MF4 + { 8, &RISCVDescs.OperandInfo[3913] }, // Inst #4989 = PseudoVLUXEI32_V_MF2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[3906] }, // Inst #4988 = PseudoVLUXEI32_V_MF2_MF2 + { 8, &RISCVDescs.OperandInfo[3958] }, // Inst #4987 = PseudoVLUXEI32_V_MF2_M1_MASK + { 7, &RISCVDescs.OperandInfo[3951] }, // Inst #4986 = PseudoVLUXEI32_V_MF2_M1 + { 8, &RISCVDescs.OperandInfo[4093] }, // Inst #4985 = PseudoVLUXEI32_V_M8_M8_MASK + { 7, &RISCVDescs.OperandInfo[4086] }, // Inst #4984 = PseudoVLUXEI32_V_M8_M8 + { 8, &RISCVDescs.OperandInfo[4078] }, // Inst #4983 = PseudoVLUXEI32_V_M8_M4_MASK + { 7, &RISCVDescs.OperandInfo[4071] }, // Inst #4982 = PseudoVLUXEI32_V_M8_M4 + { 8, &RISCVDescs.OperandInfo[4123] }, // Inst #4981 = PseudoVLUXEI32_V_M8_M2_MASK + { 7, &RISCVDescs.OperandInfo[4116] }, // Inst #4980 = PseudoVLUXEI32_V_M8_M2 + { 8, &RISCVDescs.OperandInfo[4063] }, // Inst #4979 = PseudoVLUXEI32_V_M4_M8_MASK + { 7, &RISCVDescs.OperandInfo[4056] }, // Inst #4978 = PseudoVLUXEI32_V_M4_M8 + { 8, &RISCVDescs.OperandInfo[4048] }, // Inst #4977 = PseudoVLUXEI32_V_M4_M4_MASK + { 7, &RISCVDescs.OperandInfo[4041] }, // Inst #4976 = PseudoVLUXEI32_V_M4_M4 + { 8, &RISCVDescs.OperandInfo[4033] }, // Inst #4975 = PseudoVLUXEI32_V_M4_M2_MASK + { 7, &RISCVDescs.OperandInfo[4026] }, // Inst #4974 = PseudoVLUXEI32_V_M4_M2 + { 8, &RISCVDescs.OperandInfo[4108] }, // Inst #4973 = PseudoVLUXEI32_V_M4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4101] }, // Inst #4972 = PseudoVLUXEI32_V_M4_M1 + { 8, &RISCVDescs.OperandInfo[3973] }, // Inst #4971 = PseudoVLUXEI32_V_M2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[3966] }, // Inst #4970 = PseudoVLUXEI32_V_M2_MF2 + { 8, &RISCVDescs.OperandInfo[4003] }, // Inst #4969 = PseudoVLUXEI32_V_M2_M4_MASK + { 7, &RISCVDescs.OperandInfo[3996] }, // Inst #4968 = PseudoVLUXEI32_V_M2_M4 + { 8, &RISCVDescs.OperandInfo[3988] }, // Inst #4967 = PseudoVLUXEI32_V_M2_M2_MASK + { 7, &RISCVDescs.OperandInfo[3981] }, // Inst #4966 = PseudoVLUXEI32_V_M2_M2 + { 8, &RISCVDescs.OperandInfo[3973] }, // Inst #4965 = PseudoVLUXEI32_V_M2_M1_MASK + { 7, &RISCVDescs.OperandInfo[3966] }, // Inst #4964 = PseudoVLUXEI32_V_M2_M1 + { 8, &RISCVDescs.OperandInfo[3958] }, // Inst #4963 = PseudoVLUXEI32_V_M1_MF4_MASK + { 7, &RISCVDescs.OperandInfo[3951] }, // Inst #4962 = PseudoVLUXEI32_V_M1_MF4 + { 8, &RISCVDescs.OperandInfo[3958] }, // Inst #4961 = PseudoVLUXEI32_V_M1_MF2_MASK + { 7, &RISCVDescs.OperandInfo[3951] }, // Inst #4960 = PseudoVLUXEI32_V_M1_MF2 + { 8, &RISCVDescs.OperandInfo[3928] }, // Inst #4959 = PseudoVLUXEI32_V_M1_M2_MASK + { 7, &RISCVDescs.OperandInfo[3921] }, // Inst #4958 = PseudoVLUXEI32_V_M1_M2 + { 8, &RISCVDescs.OperandInfo[3913] }, // Inst #4957 = PseudoVLUXEI32_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[3906] }, // Inst #4956 = PseudoVLUXEI32_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[3958] }, // Inst #4955 = PseudoVLUXEI16_V_MF4_MF8_MASK + { 7, &RISCVDescs.OperandInfo[3951] }, // Inst #4954 = PseudoVLUXEI16_V_MF4_MF8 + { 8, &RISCVDescs.OperandInfo[3913] }, // Inst #4953 = PseudoVLUXEI16_V_MF4_MF4_MASK + { 7, &RISCVDescs.OperandInfo[3906] }, // Inst #4952 = PseudoVLUXEI16_V_MF4_MF4 + { 8, &RISCVDescs.OperandInfo[3958] }, // Inst #4951 = PseudoVLUXEI16_V_MF4_MF2_MASK + { 7, &RISCVDescs.OperandInfo[3951] }, // Inst #4950 = PseudoVLUXEI16_V_MF4_MF2 + { 8, &RISCVDescs.OperandInfo[3958] }, // Inst #4949 = PseudoVLUXEI16_V_MF4_M1_MASK + { 7, &RISCVDescs.OperandInfo[3951] }, // Inst #4948 = PseudoVLUXEI16_V_MF4_M1 + { 8, &RISCVDescs.OperandInfo[3958] }, // Inst #4947 = PseudoVLUXEI16_V_MF2_MF4_MASK + { 7, &RISCVDescs.OperandInfo[3951] }, // Inst #4946 = PseudoVLUXEI16_V_MF2_MF4 + { 8, &RISCVDescs.OperandInfo[3913] }, // Inst #4945 = PseudoVLUXEI16_V_MF2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[3906] }, // Inst #4944 = PseudoVLUXEI16_V_MF2_MF2 + { 8, &RISCVDescs.OperandInfo[3928] }, // Inst #4943 = PseudoVLUXEI16_V_MF2_M2_MASK + { 7, &RISCVDescs.OperandInfo[3921] }, // Inst #4942 = PseudoVLUXEI16_V_MF2_M2 + { 8, &RISCVDescs.OperandInfo[3958] }, // Inst #4941 = PseudoVLUXEI16_V_MF2_M1_MASK + { 7, &RISCVDescs.OperandInfo[3951] }, // Inst #4940 = PseudoVLUXEI16_V_MF2_M1 + { 8, &RISCVDescs.OperandInfo[4093] }, // Inst #4939 = PseudoVLUXEI16_V_M8_M8_MASK + { 7, &RISCVDescs.OperandInfo[4086] }, // Inst #4938 = PseudoVLUXEI16_V_M8_M8 + { 8, &RISCVDescs.OperandInfo[4078] }, // Inst #4937 = PseudoVLUXEI16_V_M8_M4_MASK + { 7, &RISCVDescs.OperandInfo[4071] }, // Inst #4936 = PseudoVLUXEI16_V_M8_M4 + { 8, &RISCVDescs.OperandInfo[4063] }, // Inst #4935 = PseudoVLUXEI16_V_M4_M8_MASK + { 7, &RISCVDescs.OperandInfo[4056] }, // Inst #4934 = PseudoVLUXEI16_V_M4_M8 + { 8, &RISCVDescs.OperandInfo[4048] }, // Inst #4933 = PseudoVLUXEI16_V_M4_M4_MASK + { 7, &RISCVDescs.OperandInfo[4041] }, // Inst #4932 = PseudoVLUXEI16_V_M4_M4 + { 8, &RISCVDescs.OperandInfo[4033] }, // Inst #4931 = PseudoVLUXEI16_V_M4_M2_MASK + { 7, &RISCVDescs.OperandInfo[4026] }, // Inst #4930 = PseudoVLUXEI16_V_M4_M2 + { 8, &RISCVDescs.OperandInfo[4018] }, // Inst #4929 = PseudoVLUXEI16_V_M2_M8_MASK + { 7, &RISCVDescs.OperandInfo[4011] }, // Inst #4928 = PseudoVLUXEI16_V_M2_M8 + { 8, &RISCVDescs.OperandInfo[4003] }, // Inst #4927 = PseudoVLUXEI16_V_M2_M4_MASK + { 7, &RISCVDescs.OperandInfo[3996] }, // Inst #4926 = PseudoVLUXEI16_V_M2_M4 + { 8, &RISCVDescs.OperandInfo[3988] }, // Inst #4925 = PseudoVLUXEI16_V_M2_M2_MASK + { 7, &RISCVDescs.OperandInfo[3981] }, // Inst #4924 = PseudoVLUXEI16_V_M2_M2 + { 8, &RISCVDescs.OperandInfo[3973] }, // Inst #4923 = PseudoVLUXEI16_V_M2_M1_MASK + { 7, &RISCVDescs.OperandInfo[3966] }, // Inst #4922 = PseudoVLUXEI16_V_M2_M1 + { 8, &RISCVDescs.OperandInfo[3958] }, // Inst #4921 = PseudoVLUXEI16_V_M1_MF2_MASK + { 7, &RISCVDescs.OperandInfo[3951] }, // Inst #4920 = PseudoVLUXEI16_V_M1_MF2 + { 8, &RISCVDescs.OperandInfo[3943] }, // Inst #4919 = PseudoVLUXEI16_V_M1_M4_MASK + { 7, &RISCVDescs.OperandInfo[3936] }, // Inst #4918 = PseudoVLUXEI16_V_M1_M4 + { 8, &RISCVDescs.OperandInfo[3928] }, // Inst #4917 = PseudoVLUXEI16_V_M1_M2_MASK + { 7, &RISCVDescs.OperandInfo[3921] }, // Inst #4916 = PseudoVLUXEI16_V_M1_M2 + { 8, &RISCVDescs.OperandInfo[3913] }, // Inst #4915 = PseudoVLUXEI16_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[3906] }, // Inst #4914 = PseudoVLUXEI16_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[5346] }, // Inst #4913 = PseudoVLSSEG8E8_V_MF8_MASK + { 7, &RISCVDescs.OperandInfo[5339] }, // Inst #4912 = PseudoVLSSEG8E8_V_MF8 + { 8, &RISCVDescs.OperandInfo[5346] }, // Inst #4911 = PseudoVLSSEG8E8_V_MF4_MASK + { 7, &RISCVDescs.OperandInfo[5339] }, // Inst #4910 = PseudoVLSSEG8E8_V_MF4 + { 8, &RISCVDescs.OperandInfo[5346] }, // Inst #4909 = PseudoVLSSEG8E8_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[5339] }, // Inst #4908 = PseudoVLSSEG8E8_V_MF2 + { 8, &RISCVDescs.OperandInfo[5346] }, // Inst #4907 = PseudoVLSSEG8E8_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[5339] }, // Inst #4906 = PseudoVLSSEG8E8_V_M1 + { 8, &RISCVDescs.OperandInfo[5346] }, // Inst #4905 = PseudoVLSSEG8E64_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[5339] }, // Inst #4904 = PseudoVLSSEG8E64_V_M1 + { 8, &RISCVDescs.OperandInfo[5346] }, // Inst #4903 = PseudoVLSSEG8E32_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[5339] }, // Inst #4902 = PseudoVLSSEG8E32_V_MF2 + { 8, &RISCVDescs.OperandInfo[5346] }, // Inst #4901 = PseudoVLSSEG8E32_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[5339] }, // Inst #4900 = PseudoVLSSEG8E32_V_M1 + { 8, &RISCVDescs.OperandInfo[5346] }, // Inst #4899 = PseudoVLSSEG8E16_V_MF4_MASK + { 7, &RISCVDescs.OperandInfo[5339] }, // Inst #4898 = PseudoVLSSEG8E16_V_MF4 + { 8, &RISCVDescs.OperandInfo[5346] }, // Inst #4897 = PseudoVLSSEG8E16_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[5339] }, // Inst #4896 = PseudoVLSSEG8E16_V_MF2 + { 8, &RISCVDescs.OperandInfo[5346] }, // Inst #4895 = PseudoVLSSEG8E16_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[5339] }, // Inst #4894 = PseudoVLSSEG8E16_V_M1 + { 8, &RISCVDescs.OperandInfo[5331] }, // Inst #4893 = PseudoVLSSEG7E8_V_MF8_MASK + { 7, &RISCVDescs.OperandInfo[5324] }, // Inst #4892 = PseudoVLSSEG7E8_V_MF8 + { 8, &RISCVDescs.OperandInfo[5331] }, // Inst #4891 = PseudoVLSSEG7E8_V_MF4_MASK + { 7, &RISCVDescs.OperandInfo[5324] }, // Inst #4890 = PseudoVLSSEG7E8_V_MF4 + { 8, &RISCVDescs.OperandInfo[5331] }, // Inst #4889 = PseudoVLSSEG7E8_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[5324] }, // Inst #4888 = PseudoVLSSEG7E8_V_MF2 + { 8, &RISCVDescs.OperandInfo[5331] }, // Inst #4887 = PseudoVLSSEG7E8_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[5324] }, // Inst #4886 = PseudoVLSSEG7E8_V_M1 + { 8, &RISCVDescs.OperandInfo[5331] }, // Inst #4885 = PseudoVLSSEG7E64_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[5324] }, // Inst #4884 = PseudoVLSSEG7E64_V_M1 + { 8, &RISCVDescs.OperandInfo[5331] }, // Inst #4883 = PseudoVLSSEG7E32_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[5324] }, // Inst #4882 = PseudoVLSSEG7E32_V_MF2 + { 8, &RISCVDescs.OperandInfo[5331] }, // Inst #4881 = PseudoVLSSEG7E32_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[5324] }, // Inst #4880 = PseudoVLSSEG7E32_V_M1 + { 8, &RISCVDescs.OperandInfo[5331] }, // Inst #4879 = PseudoVLSSEG7E16_V_MF4_MASK + { 7, &RISCVDescs.OperandInfo[5324] }, // Inst #4878 = PseudoVLSSEG7E16_V_MF4 + { 8, &RISCVDescs.OperandInfo[5331] }, // Inst #4877 = PseudoVLSSEG7E16_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[5324] }, // Inst #4876 = PseudoVLSSEG7E16_V_MF2 + { 8, &RISCVDescs.OperandInfo[5331] }, // Inst #4875 = PseudoVLSSEG7E16_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[5324] }, // Inst #4874 = PseudoVLSSEG7E16_V_M1 + { 8, &RISCVDescs.OperandInfo[5316] }, // Inst #4873 = PseudoVLSSEG6E8_V_MF8_MASK + { 7, &RISCVDescs.OperandInfo[5309] }, // Inst #4872 = PseudoVLSSEG6E8_V_MF8 + { 8, &RISCVDescs.OperandInfo[5316] }, // Inst #4871 = PseudoVLSSEG6E8_V_MF4_MASK + { 7, &RISCVDescs.OperandInfo[5309] }, // Inst #4870 = PseudoVLSSEG6E8_V_MF4 + { 8, &RISCVDescs.OperandInfo[5316] }, // Inst #4869 = PseudoVLSSEG6E8_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[5309] }, // Inst #4868 = PseudoVLSSEG6E8_V_MF2 + { 8, &RISCVDescs.OperandInfo[5316] }, // Inst #4867 = PseudoVLSSEG6E8_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[5309] }, // Inst #4866 = PseudoVLSSEG6E8_V_M1 + { 8, &RISCVDescs.OperandInfo[5316] }, // Inst #4865 = PseudoVLSSEG6E64_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[5309] }, // Inst #4864 = PseudoVLSSEG6E64_V_M1 + { 8, &RISCVDescs.OperandInfo[5316] }, // Inst #4863 = PseudoVLSSEG6E32_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[5309] }, // Inst #4862 = PseudoVLSSEG6E32_V_MF2 + { 8, &RISCVDescs.OperandInfo[5316] }, // Inst #4861 = PseudoVLSSEG6E32_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[5309] }, // Inst #4860 = PseudoVLSSEG6E32_V_M1 + { 8, &RISCVDescs.OperandInfo[5316] }, // Inst #4859 = PseudoVLSSEG6E16_V_MF4_MASK + { 7, &RISCVDescs.OperandInfo[5309] }, // Inst #4858 = PseudoVLSSEG6E16_V_MF4 + { 8, &RISCVDescs.OperandInfo[5316] }, // Inst #4857 = PseudoVLSSEG6E16_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[5309] }, // Inst #4856 = PseudoVLSSEG6E16_V_MF2 + { 8, &RISCVDescs.OperandInfo[5316] }, // Inst #4855 = PseudoVLSSEG6E16_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[5309] }, // Inst #4854 = PseudoVLSSEG6E16_V_M1 + { 8, &RISCVDescs.OperandInfo[5301] }, // Inst #4853 = PseudoVLSSEG5E8_V_MF8_MASK + { 7, &RISCVDescs.OperandInfo[5294] }, // Inst #4852 = PseudoVLSSEG5E8_V_MF8 + { 8, &RISCVDescs.OperandInfo[5301] }, // Inst #4851 = PseudoVLSSEG5E8_V_MF4_MASK + { 7, &RISCVDescs.OperandInfo[5294] }, // Inst #4850 = PseudoVLSSEG5E8_V_MF4 + { 8, &RISCVDescs.OperandInfo[5301] }, // Inst #4849 = PseudoVLSSEG5E8_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[5294] }, // Inst #4848 = PseudoVLSSEG5E8_V_MF2 + { 8, &RISCVDescs.OperandInfo[5301] }, // Inst #4847 = PseudoVLSSEG5E8_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[5294] }, // Inst #4846 = PseudoVLSSEG5E8_V_M1 + { 8, &RISCVDescs.OperandInfo[5301] }, // Inst #4845 = PseudoVLSSEG5E64_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[5294] }, // Inst #4844 = PseudoVLSSEG5E64_V_M1 + { 8, &RISCVDescs.OperandInfo[5301] }, // Inst #4843 = PseudoVLSSEG5E32_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[5294] }, // Inst #4842 = PseudoVLSSEG5E32_V_MF2 + { 8, &RISCVDescs.OperandInfo[5301] }, // Inst #4841 = PseudoVLSSEG5E32_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[5294] }, // Inst #4840 = PseudoVLSSEG5E32_V_M1 + { 8, &RISCVDescs.OperandInfo[5301] }, // Inst #4839 = PseudoVLSSEG5E16_V_MF4_MASK + { 7, &RISCVDescs.OperandInfo[5294] }, // Inst #4838 = PseudoVLSSEG5E16_V_MF4 + { 8, &RISCVDescs.OperandInfo[5301] }, // Inst #4837 = PseudoVLSSEG5E16_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[5294] }, // Inst #4836 = PseudoVLSSEG5E16_V_MF2 + { 8, &RISCVDescs.OperandInfo[5301] }, // Inst #4835 = PseudoVLSSEG5E16_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[5294] }, // Inst #4834 = PseudoVLSSEG5E16_V_M1 + { 8, &RISCVDescs.OperandInfo[5271] }, // Inst #4833 = PseudoVLSSEG4E8_V_MF8_MASK + { 7, &RISCVDescs.OperandInfo[5264] }, // Inst #4832 = PseudoVLSSEG4E8_V_MF8 + { 8, &RISCVDescs.OperandInfo[5271] }, // Inst #4831 = PseudoVLSSEG4E8_V_MF4_MASK + { 7, &RISCVDescs.OperandInfo[5264] }, // Inst #4830 = PseudoVLSSEG4E8_V_MF4 + { 8, &RISCVDescs.OperandInfo[5271] }, // Inst #4829 = PseudoVLSSEG4E8_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[5264] }, // Inst #4828 = PseudoVLSSEG4E8_V_MF2 + { 8, &RISCVDescs.OperandInfo[5286] }, // Inst #4827 = PseudoVLSSEG4E8_V_M2_MASK + { 7, &RISCVDescs.OperandInfo[5279] }, // Inst #4826 = PseudoVLSSEG4E8_V_M2 + { 8, &RISCVDescs.OperandInfo[5271] }, // Inst #4825 = PseudoVLSSEG4E8_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[5264] }, // Inst #4824 = PseudoVLSSEG4E8_V_M1 + { 8, &RISCVDescs.OperandInfo[5286] }, // Inst #4823 = PseudoVLSSEG4E64_V_M2_MASK + { 7, &RISCVDescs.OperandInfo[5279] }, // Inst #4822 = PseudoVLSSEG4E64_V_M2 + { 8, &RISCVDescs.OperandInfo[5271] }, // Inst #4821 = PseudoVLSSEG4E64_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[5264] }, // Inst #4820 = PseudoVLSSEG4E64_V_M1 + { 8, &RISCVDescs.OperandInfo[5271] }, // Inst #4819 = PseudoVLSSEG4E32_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[5264] }, // Inst #4818 = PseudoVLSSEG4E32_V_MF2 + { 8, &RISCVDescs.OperandInfo[5286] }, // Inst #4817 = PseudoVLSSEG4E32_V_M2_MASK + { 7, &RISCVDescs.OperandInfo[5279] }, // Inst #4816 = PseudoVLSSEG4E32_V_M2 + { 8, &RISCVDescs.OperandInfo[5271] }, // Inst #4815 = PseudoVLSSEG4E32_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[5264] }, // Inst #4814 = PseudoVLSSEG4E32_V_M1 + { 8, &RISCVDescs.OperandInfo[5271] }, // Inst #4813 = PseudoVLSSEG4E16_V_MF4_MASK + { 7, &RISCVDescs.OperandInfo[5264] }, // Inst #4812 = PseudoVLSSEG4E16_V_MF4 + { 8, &RISCVDescs.OperandInfo[5271] }, // Inst #4811 = PseudoVLSSEG4E16_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[5264] }, // Inst #4810 = PseudoVLSSEG4E16_V_MF2 + { 8, &RISCVDescs.OperandInfo[5286] }, // Inst #4809 = PseudoVLSSEG4E16_V_M2_MASK + { 7, &RISCVDescs.OperandInfo[5279] }, // Inst #4808 = PseudoVLSSEG4E16_V_M2 + { 8, &RISCVDescs.OperandInfo[5271] }, // Inst #4807 = PseudoVLSSEG4E16_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[5264] }, // Inst #4806 = PseudoVLSSEG4E16_V_M1 + { 8, &RISCVDescs.OperandInfo[5241] }, // Inst #4805 = PseudoVLSSEG3E8_V_MF8_MASK + { 7, &RISCVDescs.OperandInfo[5234] }, // Inst #4804 = PseudoVLSSEG3E8_V_MF8 + { 8, &RISCVDescs.OperandInfo[5241] }, // Inst #4803 = PseudoVLSSEG3E8_V_MF4_MASK + { 7, &RISCVDescs.OperandInfo[5234] }, // Inst #4802 = PseudoVLSSEG3E8_V_MF4 + { 8, &RISCVDescs.OperandInfo[5241] }, // Inst #4801 = PseudoVLSSEG3E8_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[5234] }, // Inst #4800 = PseudoVLSSEG3E8_V_MF2 + { 8, &RISCVDescs.OperandInfo[5256] }, // Inst #4799 = PseudoVLSSEG3E8_V_M2_MASK + { 7, &RISCVDescs.OperandInfo[5249] }, // Inst #4798 = PseudoVLSSEG3E8_V_M2 + { 8, &RISCVDescs.OperandInfo[5241] }, // Inst #4797 = PseudoVLSSEG3E8_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[5234] }, // Inst #4796 = PseudoVLSSEG3E8_V_M1 + { 8, &RISCVDescs.OperandInfo[5256] }, // Inst #4795 = PseudoVLSSEG3E64_V_M2_MASK + { 7, &RISCVDescs.OperandInfo[5249] }, // Inst #4794 = PseudoVLSSEG3E64_V_M2 + { 8, &RISCVDescs.OperandInfo[5241] }, // Inst #4793 = PseudoVLSSEG3E64_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[5234] }, // Inst #4792 = PseudoVLSSEG3E64_V_M1 + { 8, &RISCVDescs.OperandInfo[5241] }, // Inst #4791 = PseudoVLSSEG3E32_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[5234] }, // Inst #4790 = PseudoVLSSEG3E32_V_MF2 + { 8, &RISCVDescs.OperandInfo[5256] }, // Inst #4789 = PseudoVLSSEG3E32_V_M2_MASK + { 7, &RISCVDescs.OperandInfo[5249] }, // Inst #4788 = PseudoVLSSEG3E32_V_M2 + { 8, &RISCVDescs.OperandInfo[5241] }, // Inst #4787 = PseudoVLSSEG3E32_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[5234] }, // Inst #4786 = PseudoVLSSEG3E32_V_M1 + { 8, &RISCVDescs.OperandInfo[5241] }, // Inst #4785 = PseudoVLSSEG3E16_V_MF4_MASK + { 7, &RISCVDescs.OperandInfo[5234] }, // Inst #4784 = PseudoVLSSEG3E16_V_MF4 + { 8, &RISCVDescs.OperandInfo[5241] }, // Inst #4783 = PseudoVLSSEG3E16_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[5234] }, // Inst #4782 = PseudoVLSSEG3E16_V_MF2 + { 8, &RISCVDescs.OperandInfo[5256] }, // Inst #4781 = PseudoVLSSEG3E16_V_M2_MASK + { 7, &RISCVDescs.OperandInfo[5249] }, // Inst #4780 = PseudoVLSSEG3E16_V_M2 + { 8, &RISCVDescs.OperandInfo[5241] }, // Inst #4779 = PseudoVLSSEG3E16_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[5234] }, // Inst #4778 = PseudoVLSSEG3E16_V_M1 + { 8, &RISCVDescs.OperandInfo[5196] }, // Inst #4777 = PseudoVLSSEG2E8_V_MF8_MASK + { 7, &RISCVDescs.OperandInfo[5189] }, // Inst #4776 = PseudoVLSSEG2E8_V_MF8 + { 8, &RISCVDescs.OperandInfo[5196] }, // Inst #4775 = PseudoVLSSEG2E8_V_MF4_MASK + { 7, &RISCVDescs.OperandInfo[5189] }, // Inst #4774 = PseudoVLSSEG2E8_V_MF4 + { 8, &RISCVDescs.OperandInfo[5196] }, // Inst #4773 = PseudoVLSSEG2E8_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[5189] }, // Inst #4772 = PseudoVLSSEG2E8_V_MF2 + { 8, &RISCVDescs.OperandInfo[5226] }, // Inst #4771 = PseudoVLSSEG2E8_V_M4_MASK + { 7, &RISCVDescs.OperandInfo[5219] }, // Inst #4770 = PseudoVLSSEG2E8_V_M4 + { 8, &RISCVDescs.OperandInfo[5211] }, // Inst #4769 = PseudoVLSSEG2E8_V_M2_MASK + { 7, &RISCVDescs.OperandInfo[5204] }, // Inst #4768 = PseudoVLSSEG2E8_V_M2 + { 8, &RISCVDescs.OperandInfo[5196] }, // Inst #4767 = PseudoVLSSEG2E8_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[5189] }, // Inst #4766 = PseudoVLSSEG2E8_V_M1 + { 8, &RISCVDescs.OperandInfo[5226] }, // Inst #4765 = PseudoVLSSEG2E64_V_M4_MASK + { 7, &RISCVDescs.OperandInfo[5219] }, // Inst #4764 = PseudoVLSSEG2E64_V_M4 + { 8, &RISCVDescs.OperandInfo[5211] }, // Inst #4763 = PseudoVLSSEG2E64_V_M2_MASK + { 7, &RISCVDescs.OperandInfo[5204] }, // Inst #4762 = PseudoVLSSEG2E64_V_M2 + { 8, &RISCVDescs.OperandInfo[5196] }, // Inst #4761 = PseudoVLSSEG2E64_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[5189] }, // Inst #4760 = PseudoVLSSEG2E64_V_M1 + { 8, &RISCVDescs.OperandInfo[5196] }, // Inst #4759 = PseudoVLSSEG2E32_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[5189] }, // Inst #4758 = PseudoVLSSEG2E32_V_MF2 + { 8, &RISCVDescs.OperandInfo[5226] }, // Inst #4757 = PseudoVLSSEG2E32_V_M4_MASK + { 7, &RISCVDescs.OperandInfo[5219] }, // Inst #4756 = PseudoVLSSEG2E32_V_M4 + { 8, &RISCVDescs.OperandInfo[5211] }, // Inst #4755 = PseudoVLSSEG2E32_V_M2_MASK + { 7, &RISCVDescs.OperandInfo[5204] }, // Inst #4754 = PseudoVLSSEG2E32_V_M2 + { 8, &RISCVDescs.OperandInfo[5196] }, // Inst #4753 = PseudoVLSSEG2E32_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[5189] }, // Inst #4752 = PseudoVLSSEG2E32_V_M1 + { 8, &RISCVDescs.OperandInfo[5196] }, // Inst #4751 = PseudoVLSSEG2E16_V_MF4_MASK + { 7, &RISCVDescs.OperandInfo[5189] }, // Inst #4750 = PseudoVLSSEG2E16_V_MF4 + { 8, &RISCVDescs.OperandInfo[5196] }, // Inst #4749 = PseudoVLSSEG2E16_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[5189] }, // Inst #4748 = PseudoVLSSEG2E16_V_MF2 + { 8, &RISCVDescs.OperandInfo[5226] }, // Inst #4747 = PseudoVLSSEG2E16_V_M4_MASK + { 7, &RISCVDescs.OperandInfo[5219] }, // Inst #4746 = PseudoVLSSEG2E16_V_M4 + { 8, &RISCVDescs.OperandInfo[5211] }, // Inst #4745 = PseudoVLSSEG2E16_V_M2_MASK + { 7, &RISCVDescs.OperandInfo[5204] }, // Inst #4744 = PseudoVLSSEG2E16_V_M2 + { 8, &RISCVDescs.OperandInfo[5196] }, // Inst #4743 = PseudoVLSSEG2E16_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[5189] }, // Inst #4742 = PseudoVLSSEG2E16_V_M1 + { 7, &RISCVDescs.OperandInfo[5182] }, // Inst #4741 = PseudoVLSEG8E8_V_MF8_MASK + { 6, &RISCVDescs.OperandInfo[5176] }, // Inst #4740 = PseudoVLSEG8E8_V_MF8 + { 7, &RISCVDescs.OperandInfo[5182] }, // Inst #4739 = PseudoVLSEG8E8_V_MF4_MASK + { 6, &RISCVDescs.OperandInfo[5176] }, // Inst #4738 = PseudoVLSEG8E8_V_MF4 + { 7, &RISCVDescs.OperandInfo[5182] }, // Inst #4737 = PseudoVLSEG8E8_V_MF2_MASK + { 6, &RISCVDescs.OperandInfo[5176] }, // Inst #4736 = PseudoVLSEG8E8_V_MF2 + { 7, &RISCVDescs.OperandInfo[5182] }, // Inst #4735 = PseudoVLSEG8E8_V_M1_MASK + { 6, &RISCVDescs.OperandInfo[5176] }, // Inst #4734 = PseudoVLSEG8E8_V_M1 + { 8, &RISCVDescs.OperandInfo[5168] }, // Inst #4733 = PseudoVLSEG8E8FF_V_MF8_MASK + { 7, &RISCVDescs.OperandInfo[5161] }, // Inst #4732 = PseudoVLSEG8E8FF_V_MF8 + { 8, &RISCVDescs.OperandInfo[5168] }, // Inst #4731 = PseudoVLSEG8E8FF_V_MF4_MASK + { 7, &RISCVDescs.OperandInfo[5161] }, // Inst #4730 = PseudoVLSEG8E8FF_V_MF4 + { 8, &RISCVDescs.OperandInfo[5168] }, // Inst #4729 = PseudoVLSEG8E8FF_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[5161] }, // Inst #4728 = PseudoVLSEG8E8FF_V_MF2 + { 8, &RISCVDescs.OperandInfo[5168] }, // Inst #4727 = PseudoVLSEG8E8FF_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[5161] }, // Inst #4726 = PseudoVLSEG8E8FF_V_M1 + { 7, &RISCVDescs.OperandInfo[5182] }, // Inst #4725 = PseudoVLSEG8E64_V_M1_MASK + { 6, &RISCVDescs.OperandInfo[5176] }, // Inst #4724 = PseudoVLSEG8E64_V_M1 + { 8, &RISCVDescs.OperandInfo[5168] }, // Inst #4723 = PseudoVLSEG8E64FF_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[5161] }, // Inst #4722 = PseudoVLSEG8E64FF_V_M1 + { 7, &RISCVDescs.OperandInfo[5182] }, // Inst #4721 = PseudoVLSEG8E32_V_MF2_MASK + { 6, &RISCVDescs.OperandInfo[5176] }, // Inst #4720 = PseudoVLSEG8E32_V_MF2 + { 7, &RISCVDescs.OperandInfo[5182] }, // Inst #4719 = PseudoVLSEG8E32_V_M1_MASK + { 6, &RISCVDescs.OperandInfo[5176] }, // Inst #4718 = PseudoVLSEG8E32_V_M1 + { 8, &RISCVDescs.OperandInfo[5168] }, // Inst #4717 = PseudoVLSEG8E32FF_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[5161] }, // Inst #4716 = PseudoVLSEG8E32FF_V_MF2 + { 8, &RISCVDescs.OperandInfo[5168] }, // Inst #4715 = PseudoVLSEG8E32FF_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[5161] }, // Inst #4714 = PseudoVLSEG8E32FF_V_M1 + { 7, &RISCVDescs.OperandInfo[5182] }, // Inst #4713 = PseudoVLSEG8E16_V_MF4_MASK + { 6, &RISCVDescs.OperandInfo[5176] }, // Inst #4712 = PseudoVLSEG8E16_V_MF4 + { 7, &RISCVDescs.OperandInfo[5182] }, // Inst #4711 = PseudoVLSEG8E16_V_MF2_MASK + { 6, &RISCVDescs.OperandInfo[5176] }, // Inst #4710 = PseudoVLSEG8E16_V_MF2 + { 7, &RISCVDescs.OperandInfo[5182] }, // Inst #4709 = PseudoVLSEG8E16_V_M1_MASK + { 6, &RISCVDescs.OperandInfo[5176] }, // Inst #4708 = PseudoVLSEG8E16_V_M1 + { 8, &RISCVDescs.OperandInfo[5168] }, // Inst #4707 = PseudoVLSEG8E16FF_V_MF4_MASK + { 7, &RISCVDescs.OperandInfo[5161] }, // Inst #4706 = PseudoVLSEG8E16FF_V_MF4 + { 8, &RISCVDescs.OperandInfo[5168] }, // Inst #4705 = PseudoVLSEG8E16FF_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[5161] }, // Inst #4704 = PseudoVLSEG8E16FF_V_MF2 + { 8, &RISCVDescs.OperandInfo[5168] }, // Inst #4703 = PseudoVLSEG8E16FF_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[5161] }, // Inst #4702 = PseudoVLSEG8E16FF_V_M1 + { 7, &RISCVDescs.OperandInfo[5154] }, // Inst #4701 = PseudoVLSEG7E8_V_MF8_MASK + { 6, &RISCVDescs.OperandInfo[5148] }, // Inst #4700 = PseudoVLSEG7E8_V_MF8 + { 7, &RISCVDescs.OperandInfo[5154] }, // Inst #4699 = PseudoVLSEG7E8_V_MF4_MASK + { 6, &RISCVDescs.OperandInfo[5148] }, // Inst #4698 = PseudoVLSEG7E8_V_MF4 + { 7, &RISCVDescs.OperandInfo[5154] }, // Inst #4697 = PseudoVLSEG7E8_V_MF2_MASK + { 6, &RISCVDescs.OperandInfo[5148] }, // Inst #4696 = PseudoVLSEG7E8_V_MF2 + { 7, &RISCVDescs.OperandInfo[5154] }, // Inst #4695 = PseudoVLSEG7E8_V_M1_MASK + { 6, &RISCVDescs.OperandInfo[5148] }, // Inst #4694 = PseudoVLSEG7E8_V_M1 + { 8, &RISCVDescs.OperandInfo[5140] }, // Inst #4693 = PseudoVLSEG7E8FF_V_MF8_MASK + { 7, &RISCVDescs.OperandInfo[5133] }, // Inst #4692 = PseudoVLSEG7E8FF_V_MF8 + { 8, &RISCVDescs.OperandInfo[5140] }, // Inst #4691 = PseudoVLSEG7E8FF_V_MF4_MASK + { 7, &RISCVDescs.OperandInfo[5133] }, // Inst #4690 = PseudoVLSEG7E8FF_V_MF4 + { 8, &RISCVDescs.OperandInfo[5140] }, // Inst #4689 = PseudoVLSEG7E8FF_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[5133] }, // Inst #4688 = PseudoVLSEG7E8FF_V_MF2 + { 8, &RISCVDescs.OperandInfo[5140] }, // Inst #4687 = PseudoVLSEG7E8FF_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[5133] }, // Inst #4686 = PseudoVLSEG7E8FF_V_M1 + { 7, &RISCVDescs.OperandInfo[5154] }, // Inst #4685 = PseudoVLSEG7E64_V_M1_MASK + { 6, &RISCVDescs.OperandInfo[5148] }, // Inst #4684 = PseudoVLSEG7E64_V_M1 + { 8, &RISCVDescs.OperandInfo[5140] }, // Inst #4683 = PseudoVLSEG7E64FF_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[5133] }, // Inst #4682 = PseudoVLSEG7E64FF_V_M1 + { 7, &RISCVDescs.OperandInfo[5154] }, // Inst #4681 = PseudoVLSEG7E32_V_MF2_MASK + { 6, &RISCVDescs.OperandInfo[5148] }, // Inst #4680 = PseudoVLSEG7E32_V_MF2 + { 7, &RISCVDescs.OperandInfo[5154] }, // Inst #4679 = PseudoVLSEG7E32_V_M1_MASK + { 6, &RISCVDescs.OperandInfo[5148] }, // Inst #4678 = PseudoVLSEG7E32_V_M1 + { 8, &RISCVDescs.OperandInfo[5140] }, // Inst #4677 = PseudoVLSEG7E32FF_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[5133] }, // Inst #4676 = PseudoVLSEG7E32FF_V_MF2 + { 8, &RISCVDescs.OperandInfo[5140] }, // Inst #4675 = PseudoVLSEG7E32FF_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[5133] }, // Inst #4674 = PseudoVLSEG7E32FF_V_M1 + { 7, &RISCVDescs.OperandInfo[5154] }, // Inst #4673 = PseudoVLSEG7E16_V_MF4_MASK + { 6, &RISCVDescs.OperandInfo[5148] }, // Inst #4672 = PseudoVLSEG7E16_V_MF4 + { 7, &RISCVDescs.OperandInfo[5154] }, // Inst #4671 = PseudoVLSEG7E16_V_MF2_MASK + { 6, &RISCVDescs.OperandInfo[5148] }, // Inst #4670 = PseudoVLSEG7E16_V_MF2 + { 7, &RISCVDescs.OperandInfo[5154] }, // Inst #4669 = PseudoVLSEG7E16_V_M1_MASK + { 6, &RISCVDescs.OperandInfo[5148] }, // Inst #4668 = PseudoVLSEG7E16_V_M1 + { 8, &RISCVDescs.OperandInfo[5140] }, // Inst #4667 = PseudoVLSEG7E16FF_V_MF4_MASK + { 7, &RISCVDescs.OperandInfo[5133] }, // Inst #4666 = PseudoVLSEG7E16FF_V_MF4 + { 8, &RISCVDescs.OperandInfo[5140] }, // Inst #4665 = PseudoVLSEG7E16FF_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[5133] }, // Inst #4664 = PseudoVLSEG7E16FF_V_MF2 + { 8, &RISCVDescs.OperandInfo[5140] }, // Inst #4663 = PseudoVLSEG7E16FF_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[5133] }, // Inst #4662 = PseudoVLSEG7E16FF_V_M1 + { 7, &RISCVDescs.OperandInfo[5126] }, // Inst #4661 = PseudoVLSEG6E8_V_MF8_MASK + { 6, &RISCVDescs.OperandInfo[5120] }, // Inst #4660 = PseudoVLSEG6E8_V_MF8 + { 7, &RISCVDescs.OperandInfo[5126] }, // Inst #4659 = PseudoVLSEG6E8_V_MF4_MASK + { 6, &RISCVDescs.OperandInfo[5120] }, // Inst #4658 = PseudoVLSEG6E8_V_MF4 + { 7, &RISCVDescs.OperandInfo[5126] }, // Inst #4657 = PseudoVLSEG6E8_V_MF2_MASK + { 6, &RISCVDescs.OperandInfo[5120] }, // Inst #4656 = PseudoVLSEG6E8_V_MF2 + { 7, &RISCVDescs.OperandInfo[5126] }, // Inst #4655 = PseudoVLSEG6E8_V_M1_MASK + { 6, &RISCVDescs.OperandInfo[5120] }, // Inst #4654 = PseudoVLSEG6E8_V_M1 + { 8, &RISCVDescs.OperandInfo[5112] }, // Inst #4653 = PseudoVLSEG6E8FF_V_MF8_MASK + { 7, &RISCVDescs.OperandInfo[5105] }, // Inst #4652 = PseudoVLSEG6E8FF_V_MF8 + { 8, &RISCVDescs.OperandInfo[5112] }, // Inst #4651 = PseudoVLSEG6E8FF_V_MF4_MASK + { 7, &RISCVDescs.OperandInfo[5105] }, // Inst #4650 = PseudoVLSEG6E8FF_V_MF4 + { 8, &RISCVDescs.OperandInfo[5112] }, // Inst #4649 = PseudoVLSEG6E8FF_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[5105] }, // Inst #4648 = PseudoVLSEG6E8FF_V_MF2 + { 8, &RISCVDescs.OperandInfo[5112] }, // Inst #4647 = PseudoVLSEG6E8FF_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[5105] }, // Inst #4646 = PseudoVLSEG6E8FF_V_M1 + { 7, &RISCVDescs.OperandInfo[5126] }, // Inst #4645 = PseudoVLSEG6E64_V_M1_MASK + { 6, &RISCVDescs.OperandInfo[5120] }, // Inst #4644 = PseudoVLSEG6E64_V_M1 + { 8, &RISCVDescs.OperandInfo[5112] }, // Inst #4643 = PseudoVLSEG6E64FF_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[5105] }, // Inst #4642 = PseudoVLSEG6E64FF_V_M1 + { 7, &RISCVDescs.OperandInfo[5126] }, // Inst #4641 = PseudoVLSEG6E32_V_MF2_MASK + { 6, &RISCVDescs.OperandInfo[5120] }, // Inst #4640 = PseudoVLSEG6E32_V_MF2 + { 7, &RISCVDescs.OperandInfo[5126] }, // Inst #4639 = PseudoVLSEG6E32_V_M1_MASK + { 6, &RISCVDescs.OperandInfo[5120] }, // Inst #4638 = PseudoVLSEG6E32_V_M1 + { 8, &RISCVDescs.OperandInfo[5112] }, // Inst #4637 = PseudoVLSEG6E32FF_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[5105] }, // Inst #4636 = PseudoVLSEG6E32FF_V_MF2 + { 8, &RISCVDescs.OperandInfo[5112] }, // Inst #4635 = PseudoVLSEG6E32FF_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[5105] }, // Inst #4634 = PseudoVLSEG6E32FF_V_M1 + { 7, &RISCVDescs.OperandInfo[5126] }, // Inst #4633 = PseudoVLSEG6E16_V_MF4_MASK + { 6, &RISCVDescs.OperandInfo[5120] }, // Inst #4632 = PseudoVLSEG6E16_V_MF4 + { 7, &RISCVDescs.OperandInfo[5126] }, // Inst #4631 = PseudoVLSEG6E16_V_MF2_MASK + { 6, &RISCVDescs.OperandInfo[5120] }, // Inst #4630 = PseudoVLSEG6E16_V_MF2 + { 7, &RISCVDescs.OperandInfo[5126] }, // Inst #4629 = PseudoVLSEG6E16_V_M1_MASK + { 6, &RISCVDescs.OperandInfo[5120] }, // Inst #4628 = PseudoVLSEG6E16_V_M1 + { 8, &RISCVDescs.OperandInfo[5112] }, // Inst #4627 = PseudoVLSEG6E16FF_V_MF4_MASK + { 7, &RISCVDescs.OperandInfo[5105] }, // Inst #4626 = PseudoVLSEG6E16FF_V_MF4 + { 8, &RISCVDescs.OperandInfo[5112] }, // Inst #4625 = PseudoVLSEG6E16FF_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[5105] }, // Inst #4624 = PseudoVLSEG6E16FF_V_MF2 + { 8, &RISCVDescs.OperandInfo[5112] }, // Inst #4623 = PseudoVLSEG6E16FF_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[5105] }, // Inst #4622 = PseudoVLSEG6E16FF_V_M1 + { 7, &RISCVDescs.OperandInfo[5098] }, // Inst #4621 = PseudoVLSEG5E8_V_MF8_MASK + { 6, &RISCVDescs.OperandInfo[5092] }, // Inst #4620 = PseudoVLSEG5E8_V_MF8 + { 7, &RISCVDescs.OperandInfo[5098] }, // Inst #4619 = PseudoVLSEG5E8_V_MF4_MASK + { 6, &RISCVDescs.OperandInfo[5092] }, // Inst #4618 = PseudoVLSEG5E8_V_MF4 + { 7, &RISCVDescs.OperandInfo[5098] }, // Inst #4617 = PseudoVLSEG5E8_V_MF2_MASK + { 6, &RISCVDescs.OperandInfo[5092] }, // Inst #4616 = PseudoVLSEG5E8_V_MF2 + { 7, &RISCVDescs.OperandInfo[5098] }, // Inst #4615 = PseudoVLSEG5E8_V_M1_MASK + { 6, &RISCVDescs.OperandInfo[5092] }, // Inst #4614 = PseudoVLSEG5E8_V_M1 + { 8, &RISCVDescs.OperandInfo[5084] }, // Inst #4613 = PseudoVLSEG5E8FF_V_MF8_MASK + { 7, &RISCVDescs.OperandInfo[5077] }, // Inst #4612 = PseudoVLSEG5E8FF_V_MF8 + { 8, &RISCVDescs.OperandInfo[5084] }, // Inst #4611 = PseudoVLSEG5E8FF_V_MF4_MASK + { 7, &RISCVDescs.OperandInfo[5077] }, // Inst #4610 = PseudoVLSEG5E8FF_V_MF4 + { 8, &RISCVDescs.OperandInfo[5084] }, // Inst #4609 = PseudoVLSEG5E8FF_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[5077] }, // Inst #4608 = PseudoVLSEG5E8FF_V_MF2 + { 8, &RISCVDescs.OperandInfo[5084] }, // Inst #4607 = PseudoVLSEG5E8FF_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[5077] }, // Inst #4606 = PseudoVLSEG5E8FF_V_M1 + { 7, &RISCVDescs.OperandInfo[5098] }, // Inst #4605 = PseudoVLSEG5E64_V_M1_MASK + { 6, &RISCVDescs.OperandInfo[5092] }, // Inst #4604 = PseudoVLSEG5E64_V_M1 + { 8, &RISCVDescs.OperandInfo[5084] }, // Inst #4603 = PseudoVLSEG5E64FF_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[5077] }, // Inst #4602 = PseudoVLSEG5E64FF_V_M1 + { 7, &RISCVDescs.OperandInfo[5098] }, // Inst #4601 = PseudoVLSEG5E32_V_MF2_MASK + { 6, &RISCVDescs.OperandInfo[5092] }, // Inst #4600 = PseudoVLSEG5E32_V_MF2 + { 7, &RISCVDescs.OperandInfo[5098] }, // Inst #4599 = PseudoVLSEG5E32_V_M1_MASK + { 6, &RISCVDescs.OperandInfo[5092] }, // Inst #4598 = PseudoVLSEG5E32_V_M1 + { 8, &RISCVDescs.OperandInfo[5084] }, // Inst #4597 = PseudoVLSEG5E32FF_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[5077] }, // Inst #4596 = PseudoVLSEG5E32FF_V_MF2 + { 8, &RISCVDescs.OperandInfo[5084] }, // Inst #4595 = PseudoVLSEG5E32FF_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[5077] }, // Inst #4594 = PseudoVLSEG5E32FF_V_M1 + { 7, &RISCVDescs.OperandInfo[5098] }, // Inst #4593 = PseudoVLSEG5E16_V_MF4_MASK + { 6, &RISCVDescs.OperandInfo[5092] }, // Inst #4592 = PseudoVLSEG5E16_V_MF4 + { 7, &RISCVDescs.OperandInfo[5098] }, // Inst #4591 = PseudoVLSEG5E16_V_MF2_MASK + { 6, &RISCVDescs.OperandInfo[5092] }, // Inst #4590 = PseudoVLSEG5E16_V_MF2 + { 7, &RISCVDescs.OperandInfo[5098] }, // Inst #4589 = PseudoVLSEG5E16_V_M1_MASK + { 6, &RISCVDescs.OperandInfo[5092] }, // Inst #4588 = PseudoVLSEG5E16_V_M1 + { 8, &RISCVDescs.OperandInfo[5084] }, // Inst #4587 = PseudoVLSEG5E16FF_V_MF4_MASK + { 7, &RISCVDescs.OperandInfo[5077] }, // Inst #4586 = PseudoVLSEG5E16FF_V_MF4 + { 8, &RISCVDescs.OperandInfo[5084] }, // Inst #4585 = PseudoVLSEG5E16FF_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[5077] }, // Inst #4584 = PseudoVLSEG5E16FF_V_MF2 + { 8, &RISCVDescs.OperandInfo[5084] }, // Inst #4583 = PseudoVLSEG5E16FF_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[5077] }, // Inst #4582 = PseudoVLSEG5E16FF_V_M1 + { 7, &RISCVDescs.OperandInfo[5057] }, // Inst #4581 = PseudoVLSEG4E8_V_MF8_MASK + { 6, &RISCVDescs.OperandInfo[5051] }, // Inst #4580 = PseudoVLSEG4E8_V_MF8 + { 7, &RISCVDescs.OperandInfo[5057] }, // Inst #4579 = PseudoVLSEG4E8_V_MF4_MASK + { 6, &RISCVDescs.OperandInfo[5051] }, // Inst #4578 = PseudoVLSEG4E8_V_MF4 + { 7, &RISCVDescs.OperandInfo[5057] }, // Inst #4577 = PseudoVLSEG4E8_V_MF2_MASK + { 6, &RISCVDescs.OperandInfo[5051] }, // Inst #4576 = PseudoVLSEG4E8_V_MF2 + { 7, &RISCVDescs.OperandInfo[5070] }, // Inst #4575 = PseudoVLSEG4E8_V_M2_MASK + { 6, &RISCVDescs.OperandInfo[5064] }, // Inst #4574 = PseudoVLSEG4E8_V_M2 + { 7, &RISCVDescs.OperandInfo[5057] }, // Inst #4573 = PseudoVLSEG4E8_V_M1_MASK + { 6, &RISCVDescs.OperandInfo[5051] }, // Inst #4572 = PseudoVLSEG4E8_V_M1 + { 8, &RISCVDescs.OperandInfo[5028] }, // Inst #4571 = PseudoVLSEG4E8FF_V_MF8_MASK + { 7, &RISCVDescs.OperandInfo[5021] }, // Inst #4570 = PseudoVLSEG4E8FF_V_MF8 + { 8, &RISCVDescs.OperandInfo[5028] }, // Inst #4569 = PseudoVLSEG4E8FF_V_MF4_MASK + { 7, &RISCVDescs.OperandInfo[5021] }, // Inst #4568 = PseudoVLSEG4E8FF_V_MF4 + { 8, &RISCVDescs.OperandInfo[5028] }, // Inst #4567 = PseudoVLSEG4E8FF_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[5021] }, // Inst #4566 = PseudoVLSEG4E8FF_V_MF2 + { 8, &RISCVDescs.OperandInfo[5043] }, // Inst #4565 = PseudoVLSEG4E8FF_V_M2_MASK + { 7, &RISCVDescs.OperandInfo[5036] }, // Inst #4564 = PseudoVLSEG4E8FF_V_M2 + { 8, &RISCVDescs.OperandInfo[5028] }, // Inst #4563 = PseudoVLSEG4E8FF_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[5021] }, // Inst #4562 = PseudoVLSEG4E8FF_V_M1 + { 7, &RISCVDescs.OperandInfo[5070] }, // Inst #4561 = PseudoVLSEG4E64_V_M2_MASK + { 6, &RISCVDescs.OperandInfo[5064] }, // Inst #4560 = PseudoVLSEG4E64_V_M2 + { 7, &RISCVDescs.OperandInfo[5057] }, // Inst #4559 = PseudoVLSEG4E64_V_M1_MASK + { 6, &RISCVDescs.OperandInfo[5051] }, // Inst #4558 = PseudoVLSEG4E64_V_M1 + { 8, &RISCVDescs.OperandInfo[5043] }, // Inst #4557 = PseudoVLSEG4E64FF_V_M2_MASK + { 7, &RISCVDescs.OperandInfo[5036] }, // Inst #4556 = PseudoVLSEG4E64FF_V_M2 + { 8, &RISCVDescs.OperandInfo[5028] }, // Inst #4555 = PseudoVLSEG4E64FF_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[5021] }, // Inst #4554 = PseudoVLSEG4E64FF_V_M1 + { 7, &RISCVDescs.OperandInfo[5057] }, // Inst #4553 = PseudoVLSEG4E32_V_MF2_MASK + { 6, &RISCVDescs.OperandInfo[5051] }, // Inst #4552 = PseudoVLSEG4E32_V_MF2 + { 7, &RISCVDescs.OperandInfo[5070] }, // Inst #4551 = PseudoVLSEG4E32_V_M2_MASK + { 6, &RISCVDescs.OperandInfo[5064] }, // Inst #4550 = PseudoVLSEG4E32_V_M2 + { 7, &RISCVDescs.OperandInfo[5057] }, // Inst #4549 = PseudoVLSEG4E32_V_M1_MASK + { 6, &RISCVDescs.OperandInfo[5051] }, // Inst #4548 = PseudoVLSEG4E32_V_M1 + { 8, &RISCVDescs.OperandInfo[5028] }, // Inst #4547 = PseudoVLSEG4E32FF_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[5021] }, // Inst #4546 = PseudoVLSEG4E32FF_V_MF2 + { 8, &RISCVDescs.OperandInfo[5043] }, // Inst #4545 = PseudoVLSEG4E32FF_V_M2_MASK + { 7, &RISCVDescs.OperandInfo[5036] }, // Inst #4544 = PseudoVLSEG4E32FF_V_M2 + { 8, &RISCVDescs.OperandInfo[5028] }, // Inst #4543 = PseudoVLSEG4E32FF_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[5021] }, // Inst #4542 = PseudoVLSEG4E32FF_V_M1 + { 7, &RISCVDescs.OperandInfo[5057] }, // Inst #4541 = PseudoVLSEG4E16_V_MF4_MASK + { 6, &RISCVDescs.OperandInfo[5051] }, // Inst #4540 = PseudoVLSEG4E16_V_MF4 + { 7, &RISCVDescs.OperandInfo[5057] }, // Inst #4539 = PseudoVLSEG4E16_V_MF2_MASK + { 6, &RISCVDescs.OperandInfo[5051] }, // Inst #4538 = PseudoVLSEG4E16_V_MF2 + { 7, &RISCVDescs.OperandInfo[5070] }, // Inst #4537 = PseudoVLSEG4E16_V_M2_MASK + { 6, &RISCVDescs.OperandInfo[5064] }, // Inst #4536 = PseudoVLSEG4E16_V_M2 + { 7, &RISCVDescs.OperandInfo[5057] }, // Inst #4535 = PseudoVLSEG4E16_V_M1_MASK + { 6, &RISCVDescs.OperandInfo[5051] }, // Inst #4534 = PseudoVLSEG4E16_V_M1 + { 8, &RISCVDescs.OperandInfo[5028] }, // Inst #4533 = PseudoVLSEG4E16FF_V_MF4_MASK + { 7, &RISCVDescs.OperandInfo[5021] }, // Inst #4532 = PseudoVLSEG4E16FF_V_MF4 + { 8, &RISCVDescs.OperandInfo[5028] }, // Inst #4531 = PseudoVLSEG4E16FF_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[5021] }, // Inst #4530 = PseudoVLSEG4E16FF_V_MF2 + { 8, &RISCVDescs.OperandInfo[5043] }, // Inst #4529 = PseudoVLSEG4E16FF_V_M2_MASK + { 7, &RISCVDescs.OperandInfo[5036] }, // Inst #4528 = PseudoVLSEG4E16FF_V_M2 + { 8, &RISCVDescs.OperandInfo[5028] }, // Inst #4527 = PseudoVLSEG4E16FF_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[5021] }, // Inst #4526 = PseudoVLSEG4E16FF_V_M1 + { 7, &RISCVDescs.OperandInfo[5001] }, // Inst #4525 = PseudoVLSEG3E8_V_MF8_MASK + { 6, &RISCVDescs.OperandInfo[4995] }, // Inst #4524 = PseudoVLSEG3E8_V_MF8 + { 7, &RISCVDescs.OperandInfo[5001] }, // Inst #4523 = PseudoVLSEG3E8_V_MF4_MASK + { 6, &RISCVDescs.OperandInfo[4995] }, // Inst #4522 = PseudoVLSEG3E8_V_MF4 + { 7, &RISCVDescs.OperandInfo[5001] }, // Inst #4521 = PseudoVLSEG3E8_V_MF2_MASK + { 6, &RISCVDescs.OperandInfo[4995] }, // Inst #4520 = PseudoVLSEG3E8_V_MF2 + { 7, &RISCVDescs.OperandInfo[5014] }, // Inst #4519 = PseudoVLSEG3E8_V_M2_MASK + { 6, &RISCVDescs.OperandInfo[5008] }, // Inst #4518 = PseudoVLSEG3E8_V_M2 + { 7, &RISCVDescs.OperandInfo[5001] }, // Inst #4517 = PseudoVLSEG3E8_V_M1_MASK + { 6, &RISCVDescs.OperandInfo[4995] }, // Inst #4516 = PseudoVLSEG3E8_V_M1 + { 8, &RISCVDescs.OperandInfo[4972] }, // Inst #4515 = PseudoVLSEG3E8FF_V_MF8_MASK + { 7, &RISCVDescs.OperandInfo[4965] }, // Inst #4514 = PseudoVLSEG3E8FF_V_MF8 + { 8, &RISCVDescs.OperandInfo[4972] }, // Inst #4513 = PseudoVLSEG3E8FF_V_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4965] }, // Inst #4512 = PseudoVLSEG3E8FF_V_MF4 + { 8, &RISCVDescs.OperandInfo[4972] }, // Inst #4511 = PseudoVLSEG3E8FF_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4965] }, // Inst #4510 = PseudoVLSEG3E8FF_V_MF2 + { 8, &RISCVDescs.OperandInfo[4987] }, // Inst #4509 = PseudoVLSEG3E8FF_V_M2_MASK + { 7, &RISCVDescs.OperandInfo[4980] }, // Inst #4508 = PseudoVLSEG3E8FF_V_M2 + { 8, &RISCVDescs.OperandInfo[4972] }, // Inst #4507 = PseudoVLSEG3E8FF_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[4965] }, // Inst #4506 = PseudoVLSEG3E8FF_V_M1 + { 7, &RISCVDescs.OperandInfo[5014] }, // Inst #4505 = PseudoVLSEG3E64_V_M2_MASK + { 6, &RISCVDescs.OperandInfo[5008] }, // Inst #4504 = PseudoVLSEG3E64_V_M2 + { 7, &RISCVDescs.OperandInfo[5001] }, // Inst #4503 = PseudoVLSEG3E64_V_M1_MASK + { 6, &RISCVDescs.OperandInfo[4995] }, // Inst #4502 = PseudoVLSEG3E64_V_M1 + { 8, &RISCVDescs.OperandInfo[4987] }, // Inst #4501 = PseudoVLSEG3E64FF_V_M2_MASK + { 7, &RISCVDescs.OperandInfo[4980] }, // Inst #4500 = PseudoVLSEG3E64FF_V_M2 + { 8, &RISCVDescs.OperandInfo[4972] }, // Inst #4499 = PseudoVLSEG3E64FF_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[4965] }, // Inst #4498 = PseudoVLSEG3E64FF_V_M1 + { 7, &RISCVDescs.OperandInfo[5001] }, // Inst #4497 = PseudoVLSEG3E32_V_MF2_MASK + { 6, &RISCVDescs.OperandInfo[4995] }, // Inst #4496 = PseudoVLSEG3E32_V_MF2 + { 7, &RISCVDescs.OperandInfo[5014] }, // Inst #4495 = PseudoVLSEG3E32_V_M2_MASK + { 6, &RISCVDescs.OperandInfo[5008] }, // Inst #4494 = PseudoVLSEG3E32_V_M2 + { 7, &RISCVDescs.OperandInfo[5001] }, // Inst #4493 = PseudoVLSEG3E32_V_M1_MASK + { 6, &RISCVDescs.OperandInfo[4995] }, // Inst #4492 = PseudoVLSEG3E32_V_M1 + { 8, &RISCVDescs.OperandInfo[4972] }, // Inst #4491 = PseudoVLSEG3E32FF_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4965] }, // Inst #4490 = PseudoVLSEG3E32FF_V_MF2 + { 8, &RISCVDescs.OperandInfo[4987] }, // Inst #4489 = PseudoVLSEG3E32FF_V_M2_MASK + { 7, &RISCVDescs.OperandInfo[4980] }, // Inst #4488 = PseudoVLSEG3E32FF_V_M2 + { 8, &RISCVDescs.OperandInfo[4972] }, // Inst #4487 = PseudoVLSEG3E32FF_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[4965] }, // Inst #4486 = PseudoVLSEG3E32FF_V_M1 + { 7, &RISCVDescs.OperandInfo[5001] }, // Inst #4485 = PseudoVLSEG3E16_V_MF4_MASK + { 6, &RISCVDescs.OperandInfo[4995] }, // Inst #4484 = PseudoVLSEG3E16_V_MF4 + { 7, &RISCVDescs.OperandInfo[5001] }, // Inst #4483 = PseudoVLSEG3E16_V_MF2_MASK + { 6, &RISCVDescs.OperandInfo[4995] }, // Inst #4482 = PseudoVLSEG3E16_V_MF2 + { 7, &RISCVDescs.OperandInfo[5014] }, // Inst #4481 = PseudoVLSEG3E16_V_M2_MASK + { 6, &RISCVDescs.OperandInfo[5008] }, // Inst #4480 = PseudoVLSEG3E16_V_M2 + { 7, &RISCVDescs.OperandInfo[5001] }, // Inst #4479 = PseudoVLSEG3E16_V_M1_MASK + { 6, &RISCVDescs.OperandInfo[4995] }, // Inst #4478 = PseudoVLSEG3E16_V_M1 + { 8, &RISCVDescs.OperandInfo[4972] }, // Inst #4477 = PseudoVLSEG3E16FF_V_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4965] }, // Inst #4476 = PseudoVLSEG3E16FF_V_MF4 + { 8, &RISCVDescs.OperandInfo[4972] }, // Inst #4475 = PseudoVLSEG3E16FF_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4965] }, // Inst #4474 = PseudoVLSEG3E16FF_V_MF2 + { 8, &RISCVDescs.OperandInfo[4987] }, // Inst #4473 = PseudoVLSEG3E16FF_V_M2_MASK + { 7, &RISCVDescs.OperandInfo[4980] }, // Inst #4472 = PseudoVLSEG3E16FF_V_M2 + { 8, &RISCVDescs.OperandInfo[4972] }, // Inst #4471 = PseudoVLSEG3E16FF_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[4965] }, // Inst #4470 = PseudoVLSEG3E16FF_V_M1 + { 7, &RISCVDescs.OperandInfo[4932] }, // Inst #4469 = PseudoVLSEG2E8_V_MF8_MASK + { 6, &RISCVDescs.OperandInfo[4926] }, // Inst #4468 = PseudoVLSEG2E8_V_MF8 + { 7, &RISCVDescs.OperandInfo[4932] }, // Inst #4467 = PseudoVLSEG2E8_V_MF4_MASK + { 6, &RISCVDescs.OperandInfo[4926] }, // Inst #4466 = PseudoVLSEG2E8_V_MF4 + { 7, &RISCVDescs.OperandInfo[4932] }, // Inst #4465 = PseudoVLSEG2E8_V_MF2_MASK + { 6, &RISCVDescs.OperandInfo[4926] }, // Inst #4464 = PseudoVLSEG2E8_V_MF2 + { 7, &RISCVDescs.OperandInfo[4958] }, // Inst #4463 = PseudoVLSEG2E8_V_M4_MASK + { 6, &RISCVDescs.OperandInfo[4952] }, // Inst #4462 = PseudoVLSEG2E8_V_M4 + { 7, &RISCVDescs.OperandInfo[4945] }, // Inst #4461 = PseudoVLSEG2E8_V_M2_MASK + { 6, &RISCVDescs.OperandInfo[4939] }, // Inst #4460 = PseudoVLSEG2E8_V_M2 + { 7, &RISCVDescs.OperandInfo[4932] }, // Inst #4459 = PseudoVLSEG2E8_V_M1_MASK + { 6, &RISCVDescs.OperandInfo[4926] }, // Inst #4458 = PseudoVLSEG2E8_V_M1 + { 8, &RISCVDescs.OperandInfo[4888] }, // Inst #4457 = PseudoVLSEG2E8FF_V_MF8_MASK + { 7, &RISCVDescs.OperandInfo[4881] }, // Inst #4456 = PseudoVLSEG2E8FF_V_MF8 + { 8, &RISCVDescs.OperandInfo[4888] }, // Inst #4455 = PseudoVLSEG2E8FF_V_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4881] }, // Inst #4454 = PseudoVLSEG2E8FF_V_MF4 + { 8, &RISCVDescs.OperandInfo[4888] }, // Inst #4453 = PseudoVLSEG2E8FF_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4881] }, // Inst #4452 = PseudoVLSEG2E8FF_V_MF2 + { 8, &RISCVDescs.OperandInfo[4918] }, // Inst #4451 = PseudoVLSEG2E8FF_V_M4_MASK + { 7, &RISCVDescs.OperandInfo[4911] }, // Inst #4450 = PseudoVLSEG2E8FF_V_M4 + { 8, &RISCVDescs.OperandInfo[4903] }, // Inst #4449 = PseudoVLSEG2E8FF_V_M2_MASK + { 7, &RISCVDescs.OperandInfo[4896] }, // Inst #4448 = PseudoVLSEG2E8FF_V_M2 + { 8, &RISCVDescs.OperandInfo[4888] }, // Inst #4447 = PseudoVLSEG2E8FF_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[4881] }, // Inst #4446 = PseudoVLSEG2E8FF_V_M1 + { 7, &RISCVDescs.OperandInfo[4958] }, // Inst #4445 = PseudoVLSEG2E64_V_M4_MASK + { 6, &RISCVDescs.OperandInfo[4952] }, // Inst #4444 = PseudoVLSEG2E64_V_M4 + { 7, &RISCVDescs.OperandInfo[4945] }, // Inst #4443 = PseudoVLSEG2E64_V_M2_MASK + { 6, &RISCVDescs.OperandInfo[4939] }, // Inst #4442 = PseudoVLSEG2E64_V_M2 + { 7, &RISCVDescs.OperandInfo[4932] }, // Inst #4441 = PseudoVLSEG2E64_V_M1_MASK + { 6, &RISCVDescs.OperandInfo[4926] }, // Inst #4440 = PseudoVLSEG2E64_V_M1 + { 8, &RISCVDescs.OperandInfo[4918] }, // Inst #4439 = PseudoVLSEG2E64FF_V_M4_MASK + { 7, &RISCVDescs.OperandInfo[4911] }, // Inst #4438 = PseudoVLSEG2E64FF_V_M4 + { 8, &RISCVDescs.OperandInfo[4903] }, // Inst #4437 = PseudoVLSEG2E64FF_V_M2_MASK + { 7, &RISCVDescs.OperandInfo[4896] }, // Inst #4436 = PseudoVLSEG2E64FF_V_M2 + { 8, &RISCVDescs.OperandInfo[4888] }, // Inst #4435 = PseudoVLSEG2E64FF_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[4881] }, // Inst #4434 = PseudoVLSEG2E64FF_V_M1 + { 7, &RISCVDescs.OperandInfo[4932] }, // Inst #4433 = PseudoVLSEG2E32_V_MF2_MASK + { 6, &RISCVDescs.OperandInfo[4926] }, // Inst #4432 = PseudoVLSEG2E32_V_MF2 + { 7, &RISCVDescs.OperandInfo[4958] }, // Inst #4431 = PseudoVLSEG2E32_V_M4_MASK + { 6, &RISCVDescs.OperandInfo[4952] }, // Inst #4430 = PseudoVLSEG2E32_V_M4 + { 7, &RISCVDescs.OperandInfo[4945] }, // Inst #4429 = PseudoVLSEG2E32_V_M2_MASK + { 6, &RISCVDescs.OperandInfo[4939] }, // Inst #4428 = PseudoVLSEG2E32_V_M2 + { 7, &RISCVDescs.OperandInfo[4932] }, // Inst #4427 = PseudoVLSEG2E32_V_M1_MASK + { 6, &RISCVDescs.OperandInfo[4926] }, // Inst #4426 = PseudoVLSEG2E32_V_M1 + { 8, &RISCVDescs.OperandInfo[4888] }, // Inst #4425 = PseudoVLSEG2E32FF_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4881] }, // Inst #4424 = PseudoVLSEG2E32FF_V_MF2 + { 8, &RISCVDescs.OperandInfo[4918] }, // Inst #4423 = PseudoVLSEG2E32FF_V_M4_MASK + { 7, &RISCVDescs.OperandInfo[4911] }, // Inst #4422 = PseudoVLSEG2E32FF_V_M4 + { 8, &RISCVDescs.OperandInfo[4903] }, // Inst #4421 = PseudoVLSEG2E32FF_V_M2_MASK + { 7, &RISCVDescs.OperandInfo[4896] }, // Inst #4420 = PseudoVLSEG2E32FF_V_M2 + { 8, &RISCVDescs.OperandInfo[4888] }, // Inst #4419 = PseudoVLSEG2E32FF_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[4881] }, // Inst #4418 = PseudoVLSEG2E32FF_V_M1 + { 7, &RISCVDescs.OperandInfo[4932] }, // Inst #4417 = PseudoVLSEG2E16_V_MF4_MASK + { 6, &RISCVDescs.OperandInfo[4926] }, // Inst #4416 = PseudoVLSEG2E16_V_MF4 + { 7, &RISCVDescs.OperandInfo[4932] }, // Inst #4415 = PseudoVLSEG2E16_V_MF2_MASK + { 6, &RISCVDescs.OperandInfo[4926] }, // Inst #4414 = PseudoVLSEG2E16_V_MF2 + { 7, &RISCVDescs.OperandInfo[4958] }, // Inst #4413 = PseudoVLSEG2E16_V_M4_MASK + { 6, &RISCVDescs.OperandInfo[4952] }, // Inst #4412 = PseudoVLSEG2E16_V_M4 + { 7, &RISCVDescs.OperandInfo[4945] }, // Inst #4411 = PseudoVLSEG2E16_V_M2_MASK + { 6, &RISCVDescs.OperandInfo[4939] }, // Inst #4410 = PseudoVLSEG2E16_V_M2 + { 7, &RISCVDescs.OperandInfo[4932] }, // Inst #4409 = PseudoVLSEG2E16_V_M1_MASK + { 6, &RISCVDescs.OperandInfo[4926] }, // Inst #4408 = PseudoVLSEG2E16_V_M1 + { 8, &RISCVDescs.OperandInfo[4888] }, // Inst #4407 = PseudoVLSEG2E16FF_V_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4881] }, // Inst #4406 = PseudoVLSEG2E16FF_V_MF4 + { 8, &RISCVDescs.OperandInfo[4888] }, // Inst #4405 = PseudoVLSEG2E16FF_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4881] }, // Inst #4404 = PseudoVLSEG2E16FF_V_MF2 + { 8, &RISCVDescs.OperandInfo[4918] }, // Inst #4403 = PseudoVLSEG2E16FF_V_M4_MASK + { 7, &RISCVDescs.OperandInfo[4911] }, // Inst #4402 = PseudoVLSEG2E16FF_V_M4 + { 8, &RISCVDescs.OperandInfo[4903] }, // Inst #4401 = PseudoVLSEG2E16FF_V_M2_MASK + { 7, &RISCVDescs.OperandInfo[4896] }, // Inst #4400 = PseudoVLSEG2E16FF_V_M2 + { 8, &RISCVDescs.OperandInfo[4888] }, // Inst #4399 = PseudoVLSEG2E16FF_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[4881] }, // Inst #4398 = PseudoVLSEG2E16FF_V_M1 + { 8, &RISCVDescs.OperandInfo[4828] }, // Inst #4397 = PseudoVLSE8_V_MF8_MASK + { 7, &RISCVDescs.OperandInfo[4821] }, // Inst #4396 = PseudoVLSE8_V_MF8 + { 8, &RISCVDescs.OperandInfo[4828] }, // Inst #4395 = PseudoVLSE8_V_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4821] }, // Inst #4394 = PseudoVLSE8_V_MF4 + { 8, &RISCVDescs.OperandInfo[4828] }, // Inst #4393 = PseudoVLSE8_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4821] }, // Inst #4392 = PseudoVLSE8_V_MF2 + { 8, &RISCVDescs.OperandInfo[4873] }, // Inst #4391 = PseudoVLSE8_V_M8_MASK + { 7, &RISCVDescs.OperandInfo[4866] }, // Inst #4390 = PseudoVLSE8_V_M8 + { 8, &RISCVDescs.OperandInfo[4858] }, // Inst #4389 = PseudoVLSE8_V_M4_MASK + { 7, &RISCVDescs.OperandInfo[4851] }, // Inst #4388 = PseudoVLSE8_V_M4 + { 8, &RISCVDescs.OperandInfo[4843] }, // Inst #4387 = PseudoVLSE8_V_M2_MASK + { 7, &RISCVDescs.OperandInfo[4836] }, // Inst #4386 = PseudoVLSE8_V_M2 + { 8, &RISCVDescs.OperandInfo[4828] }, // Inst #4385 = PseudoVLSE8_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[4821] }, // Inst #4384 = PseudoVLSE8_V_M1 + { 8, &RISCVDescs.OperandInfo[4873] }, // Inst #4383 = PseudoVLSE64_V_M8_MASK + { 7, &RISCVDescs.OperandInfo[4866] }, // Inst #4382 = PseudoVLSE64_V_M8 + { 8, &RISCVDescs.OperandInfo[4858] }, // Inst #4381 = PseudoVLSE64_V_M4_MASK + { 7, &RISCVDescs.OperandInfo[4851] }, // Inst #4380 = PseudoVLSE64_V_M4 + { 8, &RISCVDescs.OperandInfo[4843] }, // Inst #4379 = PseudoVLSE64_V_M2_MASK + { 7, &RISCVDescs.OperandInfo[4836] }, // Inst #4378 = PseudoVLSE64_V_M2 + { 8, &RISCVDescs.OperandInfo[4828] }, // Inst #4377 = PseudoVLSE64_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[4821] }, // Inst #4376 = PseudoVLSE64_V_M1 + { 8, &RISCVDescs.OperandInfo[4828] }, // Inst #4375 = PseudoVLSE32_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4821] }, // Inst #4374 = PseudoVLSE32_V_MF2 + { 8, &RISCVDescs.OperandInfo[4873] }, // Inst #4373 = PseudoVLSE32_V_M8_MASK + { 7, &RISCVDescs.OperandInfo[4866] }, // Inst #4372 = PseudoVLSE32_V_M8 + { 8, &RISCVDescs.OperandInfo[4858] }, // Inst #4371 = PseudoVLSE32_V_M4_MASK + { 7, &RISCVDescs.OperandInfo[4851] }, // Inst #4370 = PseudoVLSE32_V_M4 + { 8, &RISCVDescs.OperandInfo[4843] }, // Inst #4369 = PseudoVLSE32_V_M2_MASK + { 7, &RISCVDescs.OperandInfo[4836] }, // Inst #4368 = PseudoVLSE32_V_M2 + { 8, &RISCVDescs.OperandInfo[4828] }, // Inst #4367 = PseudoVLSE32_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[4821] }, // Inst #4366 = PseudoVLSE32_V_M1 + { 8, &RISCVDescs.OperandInfo[4828] }, // Inst #4365 = PseudoVLSE16_V_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4821] }, // Inst #4364 = PseudoVLSE16_V_MF4 + { 8, &RISCVDescs.OperandInfo[4828] }, // Inst #4363 = PseudoVLSE16_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4821] }, // Inst #4362 = PseudoVLSE16_V_MF2 + { 8, &RISCVDescs.OperandInfo[4873] }, // Inst #4361 = PseudoVLSE16_V_M8_MASK + { 7, &RISCVDescs.OperandInfo[4866] }, // Inst #4360 = PseudoVLSE16_V_M8 + { 8, &RISCVDescs.OperandInfo[4858] }, // Inst #4359 = PseudoVLSE16_V_M4_MASK + { 7, &RISCVDescs.OperandInfo[4851] }, // Inst #4358 = PseudoVLSE16_V_M4 + { 8, &RISCVDescs.OperandInfo[4843] }, // Inst #4357 = PseudoVLSE16_V_M2_MASK + { 7, &RISCVDescs.OperandInfo[4836] }, // Inst #4356 = PseudoVLSE16_V_M2 + { 8, &RISCVDescs.OperandInfo[4828] }, // Inst #4355 = PseudoVLSE16_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[4821] }, // Inst #4354 = PseudoVLSE16_V_M1 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #4353 = PseudoVLOXSEG8EI8_V_MF8_MF8_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #4352 = PseudoVLOXSEG8EI8_V_MF8_MF8 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #4351 = PseudoVLOXSEG8EI8_V_MF8_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #4350 = PseudoVLOXSEG8EI8_V_MF8_MF4 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #4349 = PseudoVLOXSEG8EI8_V_MF8_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #4348 = PseudoVLOXSEG8EI8_V_MF8_MF2 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #4347 = PseudoVLOXSEG8EI8_V_MF8_M1_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #4346 = PseudoVLOXSEG8EI8_V_MF8_M1 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #4345 = PseudoVLOXSEG8EI8_V_MF4_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #4344 = PseudoVLOXSEG8EI8_V_MF4_MF4 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #4343 = PseudoVLOXSEG8EI8_V_MF4_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #4342 = PseudoVLOXSEG8EI8_V_MF4_MF2 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #4341 = PseudoVLOXSEG8EI8_V_MF4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #4340 = PseudoVLOXSEG8EI8_V_MF4_M1 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #4339 = PseudoVLOXSEG8EI8_V_MF2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #4338 = PseudoVLOXSEG8EI8_V_MF2_MF2 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #4337 = PseudoVLOXSEG8EI8_V_MF2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #4336 = PseudoVLOXSEG8EI8_V_MF2_M1 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #4335 = PseudoVLOXSEG8EI8_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #4334 = PseudoVLOXSEG8EI8_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[4813] }, // Inst #4333 = PseudoVLOXSEG8EI64_V_M8_M1_MASK + { 7, &RISCVDescs.OperandInfo[4806] }, // Inst #4332 = PseudoVLOXSEG8EI64_V_M8_M1 + { 8, &RISCVDescs.OperandInfo[4798] }, // Inst #4331 = PseudoVLOXSEG8EI64_V_M4_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4791] }, // Inst #4330 = PseudoVLOXSEG8EI64_V_M4_MF2 + { 8, &RISCVDescs.OperandInfo[4798] }, // Inst #4329 = PseudoVLOXSEG8EI64_V_M4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4791] }, // Inst #4328 = PseudoVLOXSEG8EI64_V_M4_M1 + { 8, &RISCVDescs.OperandInfo[4783] }, // Inst #4327 = PseudoVLOXSEG8EI64_V_M2_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4776] }, // Inst #4326 = PseudoVLOXSEG8EI64_V_M2_MF4 + { 8, &RISCVDescs.OperandInfo[4783] }, // Inst #4325 = PseudoVLOXSEG8EI64_V_M2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4776] }, // Inst #4324 = PseudoVLOXSEG8EI64_V_M2_MF2 + { 8, &RISCVDescs.OperandInfo[4783] }, // Inst #4323 = PseudoVLOXSEG8EI64_V_M2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4776] }, // Inst #4322 = PseudoVLOXSEG8EI64_V_M2_M1 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #4321 = PseudoVLOXSEG8EI64_V_M1_MF8_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #4320 = PseudoVLOXSEG8EI64_V_M1_MF8 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #4319 = PseudoVLOXSEG8EI64_V_M1_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #4318 = PseudoVLOXSEG8EI64_V_M1_MF4 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #4317 = PseudoVLOXSEG8EI64_V_M1_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #4316 = PseudoVLOXSEG8EI64_V_M1_MF2 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #4315 = PseudoVLOXSEG8EI64_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #4314 = PseudoVLOXSEG8EI64_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #4313 = PseudoVLOXSEG8EI32_V_MF2_MF8_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #4312 = PseudoVLOXSEG8EI32_V_MF2_MF8 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #4311 = PseudoVLOXSEG8EI32_V_MF2_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #4310 = PseudoVLOXSEG8EI32_V_MF2_MF4 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #4309 = PseudoVLOXSEG8EI32_V_MF2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #4308 = PseudoVLOXSEG8EI32_V_MF2_MF2 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #4307 = PseudoVLOXSEG8EI32_V_MF2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #4306 = PseudoVLOXSEG8EI32_V_MF2_M1 + { 8, &RISCVDescs.OperandInfo[4798] }, // Inst #4305 = PseudoVLOXSEG8EI32_V_M4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4791] }, // Inst #4304 = PseudoVLOXSEG8EI32_V_M4_M1 + { 8, &RISCVDescs.OperandInfo[4783] }, // Inst #4303 = PseudoVLOXSEG8EI32_V_M2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4776] }, // Inst #4302 = PseudoVLOXSEG8EI32_V_M2_MF2 + { 8, &RISCVDescs.OperandInfo[4783] }, // Inst #4301 = PseudoVLOXSEG8EI32_V_M2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4776] }, // Inst #4300 = PseudoVLOXSEG8EI32_V_M2_M1 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #4299 = PseudoVLOXSEG8EI32_V_M1_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #4298 = PseudoVLOXSEG8EI32_V_M1_MF4 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #4297 = PseudoVLOXSEG8EI32_V_M1_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #4296 = PseudoVLOXSEG8EI32_V_M1_MF2 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #4295 = PseudoVLOXSEG8EI32_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #4294 = PseudoVLOXSEG8EI32_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #4293 = PseudoVLOXSEG8EI16_V_MF4_MF8_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #4292 = PseudoVLOXSEG8EI16_V_MF4_MF8 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #4291 = PseudoVLOXSEG8EI16_V_MF4_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #4290 = PseudoVLOXSEG8EI16_V_MF4_MF4 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #4289 = PseudoVLOXSEG8EI16_V_MF4_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #4288 = PseudoVLOXSEG8EI16_V_MF4_MF2 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #4287 = PseudoVLOXSEG8EI16_V_MF4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #4286 = PseudoVLOXSEG8EI16_V_MF4_M1 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #4285 = PseudoVLOXSEG8EI16_V_MF2_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #4284 = PseudoVLOXSEG8EI16_V_MF2_MF4 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #4283 = PseudoVLOXSEG8EI16_V_MF2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #4282 = PseudoVLOXSEG8EI16_V_MF2_MF2 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #4281 = PseudoVLOXSEG8EI16_V_MF2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #4280 = PseudoVLOXSEG8EI16_V_MF2_M1 + { 8, &RISCVDescs.OperandInfo[4783] }, // Inst #4279 = PseudoVLOXSEG8EI16_V_M2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4776] }, // Inst #4278 = PseudoVLOXSEG8EI16_V_M2_M1 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #4277 = PseudoVLOXSEG8EI16_V_M1_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #4276 = PseudoVLOXSEG8EI16_V_M1_MF2 + { 8, &RISCVDescs.OperandInfo[4768] }, // Inst #4275 = PseudoVLOXSEG8EI16_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[4761] }, // Inst #4274 = PseudoVLOXSEG8EI16_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #4273 = PseudoVLOXSEG7EI8_V_MF8_MF8_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #4272 = PseudoVLOXSEG7EI8_V_MF8_MF8 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #4271 = PseudoVLOXSEG7EI8_V_MF8_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #4270 = PseudoVLOXSEG7EI8_V_MF8_MF4 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #4269 = PseudoVLOXSEG7EI8_V_MF8_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #4268 = PseudoVLOXSEG7EI8_V_MF8_MF2 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #4267 = PseudoVLOXSEG7EI8_V_MF8_M1_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #4266 = PseudoVLOXSEG7EI8_V_MF8_M1 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #4265 = PseudoVLOXSEG7EI8_V_MF4_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #4264 = PseudoVLOXSEG7EI8_V_MF4_MF4 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #4263 = PseudoVLOXSEG7EI8_V_MF4_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #4262 = PseudoVLOXSEG7EI8_V_MF4_MF2 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #4261 = PseudoVLOXSEG7EI8_V_MF4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #4260 = PseudoVLOXSEG7EI8_V_MF4_M1 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #4259 = PseudoVLOXSEG7EI8_V_MF2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #4258 = PseudoVLOXSEG7EI8_V_MF2_MF2 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #4257 = PseudoVLOXSEG7EI8_V_MF2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #4256 = PseudoVLOXSEG7EI8_V_MF2_M1 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #4255 = PseudoVLOXSEG7EI8_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #4254 = PseudoVLOXSEG7EI8_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[4753] }, // Inst #4253 = PseudoVLOXSEG7EI64_V_M8_M1_MASK + { 7, &RISCVDescs.OperandInfo[4746] }, // Inst #4252 = PseudoVLOXSEG7EI64_V_M8_M1 + { 8, &RISCVDescs.OperandInfo[4738] }, // Inst #4251 = PseudoVLOXSEG7EI64_V_M4_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4731] }, // Inst #4250 = PseudoVLOXSEG7EI64_V_M4_MF2 + { 8, &RISCVDescs.OperandInfo[4738] }, // Inst #4249 = PseudoVLOXSEG7EI64_V_M4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4731] }, // Inst #4248 = PseudoVLOXSEG7EI64_V_M4_M1 + { 8, &RISCVDescs.OperandInfo[4723] }, // Inst #4247 = PseudoVLOXSEG7EI64_V_M2_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4716] }, // Inst #4246 = PseudoVLOXSEG7EI64_V_M2_MF4 + { 8, &RISCVDescs.OperandInfo[4723] }, // Inst #4245 = PseudoVLOXSEG7EI64_V_M2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4716] }, // Inst #4244 = PseudoVLOXSEG7EI64_V_M2_MF2 + { 8, &RISCVDescs.OperandInfo[4723] }, // Inst #4243 = PseudoVLOXSEG7EI64_V_M2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4716] }, // Inst #4242 = PseudoVLOXSEG7EI64_V_M2_M1 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #4241 = PseudoVLOXSEG7EI64_V_M1_MF8_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #4240 = PseudoVLOXSEG7EI64_V_M1_MF8 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #4239 = PseudoVLOXSEG7EI64_V_M1_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #4238 = PseudoVLOXSEG7EI64_V_M1_MF4 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #4237 = PseudoVLOXSEG7EI64_V_M1_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #4236 = PseudoVLOXSEG7EI64_V_M1_MF2 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #4235 = PseudoVLOXSEG7EI64_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #4234 = PseudoVLOXSEG7EI64_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #4233 = PseudoVLOXSEG7EI32_V_MF2_MF8_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #4232 = PseudoVLOXSEG7EI32_V_MF2_MF8 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #4231 = PseudoVLOXSEG7EI32_V_MF2_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #4230 = PseudoVLOXSEG7EI32_V_MF2_MF4 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #4229 = PseudoVLOXSEG7EI32_V_MF2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #4228 = PseudoVLOXSEG7EI32_V_MF2_MF2 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #4227 = PseudoVLOXSEG7EI32_V_MF2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #4226 = PseudoVLOXSEG7EI32_V_MF2_M1 + { 8, &RISCVDescs.OperandInfo[4738] }, // Inst #4225 = PseudoVLOXSEG7EI32_V_M4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4731] }, // Inst #4224 = PseudoVLOXSEG7EI32_V_M4_M1 + { 8, &RISCVDescs.OperandInfo[4723] }, // Inst #4223 = PseudoVLOXSEG7EI32_V_M2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4716] }, // Inst #4222 = PseudoVLOXSEG7EI32_V_M2_MF2 + { 8, &RISCVDescs.OperandInfo[4723] }, // Inst #4221 = PseudoVLOXSEG7EI32_V_M2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4716] }, // Inst #4220 = PseudoVLOXSEG7EI32_V_M2_M1 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #4219 = PseudoVLOXSEG7EI32_V_M1_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #4218 = PseudoVLOXSEG7EI32_V_M1_MF4 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #4217 = PseudoVLOXSEG7EI32_V_M1_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #4216 = PseudoVLOXSEG7EI32_V_M1_MF2 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #4215 = PseudoVLOXSEG7EI32_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #4214 = PseudoVLOXSEG7EI32_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #4213 = PseudoVLOXSEG7EI16_V_MF4_MF8_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #4212 = PseudoVLOXSEG7EI16_V_MF4_MF8 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #4211 = PseudoVLOXSEG7EI16_V_MF4_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #4210 = PseudoVLOXSEG7EI16_V_MF4_MF4 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #4209 = PseudoVLOXSEG7EI16_V_MF4_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #4208 = PseudoVLOXSEG7EI16_V_MF4_MF2 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #4207 = PseudoVLOXSEG7EI16_V_MF4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #4206 = PseudoVLOXSEG7EI16_V_MF4_M1 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #4205 = PseudoVLOXSEG7EI16_V_MF2_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #4204 = PseudoVLOXSEG7EI16_V_MF2_MF4 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #4203 = PseudoVLOXSEG7EI16_V_MF2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #4202 = PseudoVLOXSEG7EI16_V_MF2_MF2 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #4201 = PseudoVLOXSEG7EI16_V_MF2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #4200 = PseudoVLOXSEG7EI16_V_MF2_M1 + { 8, &RISCVDescs.OperandInfo[4723] }, // Inst #4199 = PseudoVLOXSEG7EI16_V_M2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4716] }, // Inst #4198 = PseudoVLOXSEG7EI16_V_M2_M1 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #4197 = PseudoVLOXSEG7EI16_V_M1_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #4196 = PseudoVLOXSEG7EI16_V_M1_MF2 + { 8, &RISCVDescs.OperandInfo[4708] }, // Inst #4195 = PseudoVLOXSEG7EI16_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[4701] }, // Inst #4194 = PseudoVLOXSEG7EI16_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #4193 = PseudoVLOXSEG6EI8_V_MF8_MF8_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #4192 = PseudoVLOXSEG6EI8_V_MF8_MF8 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #4191 = PseudoVLOXSEG6EI8_V_MF8_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #4190 = PseudoVLOXSEG6EI8_V_MF8_MF4 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #4189 = PseudoVLOXSEG6EI8_V_MF8_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #4188 = PseudoVLOXSEG6EI8_V_MF8_MF2 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #4187 = PseudoVLOXSEG6EI8_V_MF8_M1_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #4186 = PseudoVLOXSEG6EI8_V_MF8_M1 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #4185 = PseudoVLOXSEG6EI8_V_MF4_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #4184 = PseudoVLOXSEG6EI8_V_MF4_MF4 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #4183 = PseudoVLOXSEG6EI8_V_MF4_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #4182 = PseudoVLOXSEG6EI8_V_MF4_MF2 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #4181 = PseudoVLOXSEG6EI8_V_MF4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #4180 = PseudoVLOXSEG6EI8_V_MF4_M1 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #4179 = PseudoVLOXSEG6EI8_V_MF2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #4178 = PseudoVLOXSEG6EI8_V_MF2_MF2 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #4177 = PseudoVLOXSEG6EI8_V_MF2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #4176 = PseudoVLOXSEG6EI8_V_MF2_M1 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #4175 = PseudoVLOXSEG6EI8_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #4174 = PseudoVLOXSEG6EI8_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[4693] }, // Inst #4173 = PseudoVLOXSEG6EI64_V_M8_M1_MASK + { 7, &RISCVDescs.OperandInfo[4686] }, // Inst #4172 = PseudoVLOXSEG6EI64_V_M8_M1 + { 8, &RISCVDescs.OperandInfo[4678] }, // Inst #4171 = PseudoVLOXSEG6EI64_V_M4_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4671] }, // Inst #4170 = PseudoVLOXSEG6EI64_V_M4_MF2 + { 8, &RISCVDescs.OperandInfo[4678] }, // Inst #4169 = PseudoVLOXSEG6EI64_V_M4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4671] }, // Inst #4168 = PseudoVLOXSEG6EI64_V_M4_M1 + { 8, &RISCVDescs.OperandInfo[4663] }, // Inst #4167 = PseudoVLOXSEG6EI64_V_M2_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4656] }, // Inst #4166 = PseudoVLOXSEG6EI64_V_M2_MF4 + { 8, &RISCVDescs.OperandInfo[4663] }, // Inst #4165 = PseudoVLOXSEG6EI64_V_M2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4656] }, // Inst #4164 = PseudoVLOXSEG6EI64_V_M2_MF2 + { 8, &RISCVDescs.OperandInfo[4663] }, // Inst #4163 = PseudoVLOXSEG6EI64_V_M2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4656] }, // Inst #4162 = PseudoVLOXSEG6EI64_V_M2_M1 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #4161 = PseudoVLOXSEG6EI64_V_M1_MF8_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #4160 = PseudoVLOXSEG6EI64_V_M1_MF8 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #4159 = PseudoVLOXSEG6EI64_V_M1_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #4158 = PseudoVLOXSEG6EI64_V_M1_MF4 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #4157 = PseudoVLOXSEG6EI64_V_M1_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #4156 = PseudoVLOXSEG6EI64_V_M1_MF2 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #4155 = PseudoVLOXSEG6EI64_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #4154 = PseudoVLOXSEG6EI64_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #4153 = PseudoVLOXSEG6EI32_V_MF2_MF8_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #4152 = PseudoVLOXSEG6EI32_V_MF2_MF8 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #4151 = PseudoVLOXSEG6EI32_V_MF2_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #4150 = PseudoVLOXSEG6EI32_V_MF2_MF4 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #4149 = PseudoVLOXSEG6EI32_V_MF2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #4148 = PseudoVLOXSEG6EI32_V_MF2_MF2 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #4147 = PseudoVLOXSEG6EI32_V_MF2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #4146 = PseudoVLOXSEG6EI32_V_MF2_M1 + { 8, &RISCVDescs.OperandInfo[4678] }, // Inst #4145 = PseudoVLOXSEG6EI32_V_M4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4671] }, // Inst #4144 = PseudoVLOXSEG6EI32_V_M4_M1 + { 8, &RISCVDescs.OperandInfo[4663] }, // Inst #4143 = PseudoVLOXSEG6EI32_V_M2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4656] }, // Inst #4142 = PseudoVLOXSEG6EI32_V_M2_MF2 + { 8, &RISCVDescs.OperandInfo[4663] }, // Inst #4141 = PseudoVLOXSEG6EI32_V_M2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4656] }, // Inst #4140 = PseudoVLOXSEG6EI32_V_M2_M1 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #4139 = PseudoVLOXSEG6EI32_V_M1_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #4138 = PseudoVLOXSEG6EI32_V_M1_MF4 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #4137 = PseudoVLOXSEG6EI32_V_M1_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #4136 = PseudoVLOXSEG6EI32_V_M1_MF2 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #4135 = PseudoVLOXSEG6EI32_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #4134 = PseudoVLOXSEG6EI32_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #4133 = PseudoVLOXSEG6EI16_V_MF4_MF8_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #4132 = PseudoVLOXSEG6EI16_V_MF4_MF8 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #4131 = PseudoVLOXSEG6EI16_V_MF4_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #4130 = PseudoVLOXSEG6EI16_V_MF4_MF4 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #4129 = PseudoVLOXSEG6EI16_V_MF4_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #4128 = PseudoVLOXSEG6EI16_V_MF4_MF2 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #4127 = PseudoVLOXSEG6EI16_V_MF4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #4126 = PseudoVLOXSEG6EI16_V_MF4_M1 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #4125 = PseudoVLOXSEG6EI16_V_MF2_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #4124 = PseudoVLOXSEG6EI16_V_MF2_MF4 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #4123 = PseudoVLOXSEG6EI16_V_MF2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #4122 = PseudoVLOXSEG6EI16_V_MF2_MF2 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #4121 = PseudoVLOXSEG6EI16_V_MF2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #4120 = PseudoVLOXSEG6EI16_V_MF2_M1 + { 8, &RISCVDescs.OperandInfo[4663] }, // Inst #4119 = PseudoVLOXSEG6EI16_V_M2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4656] }, // Inst #4118 = PseudoVLOXSEG6EI16_V_M2_M1 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #4117 = PseudoVLOXSEG6EI16_V_M1_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #4116 = PseudoVLOXSEG6EI16_V_M1_MF2 + { 8, &RISCVDescs.OperandInfo[4648] }, // Inst #4115 = PseudoVLOXSEG6EI16_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[4641] }, // Inst #4114 = PseudoVLOXSEG6EI16_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #4113 = PseudoVLOXSEG5EI8_V_MF8_MF8_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #4112 = PseudoVLOXSEG5EI8_V_MF8_MF8 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #4111 = PseudoVLOXSEG5EI8_V_MF8_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #4110 = PseudoVLOXSEG5EI8_V_MF8_MF4 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #4109 = PseudoVLOXSEG5EI8_V_MF8_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #4108 = PseudoVLOXSEG5EI8_V_MF8_MF2 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #4107 = PseudoVLOXSEG5EI8_V_MF8_M1_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #4106 = PseudoVLOXSEG5EI8_V_MF8_M1 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #4105 = PseudoVLOXSEG5EI8_V_MF4_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #4104 = PseudoVLOXSEG5EI8_V_MF4_MF4 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #4103 = PseudoVLOXSEG5EI8_V_MF4_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #4102 = PseudoVLOXSEG5EI8_V_MF4_MF2 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #4101 = PseudoVLOXSEG5EI8_V_MF4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #4100 = PseudoVLOXSEG5EI8_V_MF4_M1 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #4099 = PseudoVLOXSEG5EI8_V_MF2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #4098 = PseudoVLOXSEG5EI8_V_MF2_MF2 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #4097 = PseudoVLOXSEG5EI8_V_MF2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #4096 = PseudoVLOXSEG5EI8_V_MF2_M1 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #4095 = PseudoVLOXSEG5EI8_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #4094 = PseudoVLOXSEG5EI8_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[4633] }, // Inst #4093 = PseudoVLOXSEG5EI64_V_M8_M1_MASK + { 7, &RISCVDescs.OperandInfo[4626] }, // Inst #4092 = PseudoVLOXSEG5EI64_V_M8_M1 + { 8, &RISCVDescs.OperandInfo[4618] }, // Inst #4091 = PseudoVLOXSEG5EI64_V_M4_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4611] }, // Inst #4090 = PseudoVLOXSEG5EI64_V_M4_MF2 + { 8, &RISCVDescs.OperandInfo[4618] }, // Inst #4089 = PseudoVLOXSEG5EI64_V_M4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4611] }, // Inst #4088 = PseudoVLOXSEG5EI64_V_M4_M1 + { 8, &RISCVDescs.OperandInfo[4603] }, // Inst #4087 = PseudoVLOXSEG5EI64_V_M2_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4596] }, // Inst #4086 = PseudoVLOXSEG5EI64_V_M2_MF4 + { 8, &RISCVDescs.OperandInfo[4603] }, // Inst #4085 = PseudoVLOXSEG5EI64_V_M2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4596] }, // Inst #4084 = PseudoVLOXSEG5EI64_V_M2_MF2 + { 8, &RISCVDescs.OperandInfo[4603] }, // Inst #4083 = PseudoVLOXSEG5EI64_V_M2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4596] }, // Inst #4082 = PseudoVLOXSEG5EI64_V_M2_M1 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #4081 = PseudoVLOXSEG5EI64_V_M1_MF8_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #4080 = PseudoVLOXSEG5EI64_V_M1_MF8 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #4079 = PseudoVLOXSEG5EI64_V_M1_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #4078 = PseudoVLOXSEG5EI64_V_M1_MF4 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #4077 = PseudoVLOXSEG5EI64_V_M1_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #4076 = PseudoVLOXSEG5EI64_V_M1_MF2 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #4075 = PseudoVLOXSEG5EI64_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #4074 = PseudoVLOXSEG5EI64_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #4073 = PseudoVLOXSEG5EI32_V_MF2_MF8_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #4072 = PseudoVLOXSEG5EI32_V_MF2_MF8 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #4071 = PseudoVLOXSEG5EI32_V_MF2_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #4070 = PseudoVLOXSEG5EI32_V_MF2_MF4 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #4069 = PseudoVLOXSEG5EI32_V_MF2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #4068 = PseudoVLOXSEG5EI32_V_MF2_MF2 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #4067 = PseudoVLOXSEG5EI32_V_MF2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #4066 = PseudoVLOXSEG5EI32_V_MF2_M1 + { 8, &RISCVDescs.OperandInfo[4618] }, // Inst #4065 = PseudoVLOXSEG5EI32_V_M4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4611] }, // Inst #4064 = PseudoVLOXSEG5EI32_V_M4_M1 + { 8, &RISCVDescs.OperandInfo[4603] }, // Inst #4063 = PseudoVLOXSEG5EI32_V_M2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4596] }, // Inst #4062 = PseudoVLOXSEG5EI32_V_M2_MF2 + { 8, &RISCVDescs.OperandInfo[4603] }, // Inst #4061 = PseudoVLOXSEG5EI32_V_M2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4596] }, // Inst #4060 = PseudoVLOXSEG5EI32_V_M2_M1 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #4059 = PseudoVLOXSEG5EI32_V_M1_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #4058 = PseudoVLOXSEG5EI32_V_M1_MF4 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #4057 = PseudoVLOXSEG5EI32_V_M1_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #4056 = PseudoVLOXSEG5EI32_V_M1_MF2 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #4055 = PseudoVLOXSEG5EI32_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #4054 = PseudoVLOXSEG5EI32_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #4053 = PseudoVLOXSEG5EI16_V_MF4_MF8_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #4052 = PseudoVLOXSEG5EI16_V_MF4_MF8 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #4051 = PseudoVLOXSEG5EI16_V_MF4_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #4050 = PseudoVLOXSEG5EI16_V_MF4_MF4 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #4049 = PseudoVLOXSEG5EI16_V_MF4_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #4048 = PseudoVLOXSEG5EI16_V_MF4_MF2 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #4047 = PseudoVLOXSEG5EI16_V_MF4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #4046 = PseudoVLOXSEG5EI16_V_MF4_M1 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #4045 = PseudoVLOXSEG5EI16_V_MF2_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #4044 = PseudoVLOXSEG5EI16_V_MF2_MF4 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #4043 = PseudoVLOXSEG5EI16_V_MF2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #4042 = PseudoVLOXSEG5EI16_V_MF2_MF2 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #4041 = PseudoVLOXSEG5EI16_V_MF2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #4040 = PseudoVLOXSEG5EI16_V_MF2_M1 + { 8, &RISCVDescs.OperandInfo[4603] }, // Inst #4039 = PseudoVLOXSEG5EI16_V_M2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4596] }, // Inst #4038 = PseudoVLOXSEG5EI16_V_M2_M1 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #4037 = PseudoVLOXSEG5EI16_V_M1_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #4036 = PseudoVLOXSEG5EI16_V_M1_MF2 + { 8, &RISCVDescs.OperandInfo[4588] }, // Inst #4035 = PseudoVLOXSEG5EI16_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[4581] }, // Inst #4034 = PseudoVLOXSEG5EI16_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #4033 = PseudoVLOXSEG4EI8_V_MF8_MF8_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #4032 = PseudoVLOXSEG4EI8_V_MF8_MF8 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #4031 = PseudoVLOXSEG4EI8_V_MF8_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #4030 = PseudoVLOXSEG4EI8_V_MF8_MF4 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #4029 = PseudoVLOXSEG4EI8_V_MF8_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #4028 = PseudoVLOXSEG4EI8_V_MF8_MF2 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #4027 = PseudoVLOXSEG4EI8_V_MF8_M1_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #4026 = PseudoVLOXSEG4EI8_V_MF8_M1 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #4025 = PseudoVLOXSEG4EI8_V_MF4_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #4024 = PseudoVLOXSEG4EI8_V_MF4_MF4 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #4023 = PseudoVLOXSEG4EI8_V_MF4_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #4022 = PseudoVLOXSEG4EI8_V_MF4_MF2 + { 8, &RISCVDescs.OperandInfo[4483] }, // Inst #4021 = PseudoVLOXSEG4EI8_V_MF4_M2_MASK + { 7, &RISCVDescs.OperandInfo[4476] }, // Inst #4020 = PseudoVLOXSEG4EI8_V_MF4_M2 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #4019 = PseudoVLOXSEG4EI8_V_MF4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #4018 = PseudoVLOXSEG4EI8_V_MF4_M1 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #4017 = PseudoVLOXSEG4EI8_V_MF2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #4016 = PseudoVLOXSEG4EI8_V_MF2_MF2 + { 8, &RISCVDescs.OperandInfo[4483] }, // Inst #4015 = PseudoVLOXSEG4EI8_V_MF2_M2_MASK + { 7, &RISCVDescs.OperandInfo[4476] }, // Inst #4014 = PseudoVLOXSEG4EI8_V_MF2_M2 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #4013 = PseudoVLOXSEG4EI8_V_MF2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #4012 = PseudoVLOXSEG4EI8_V_MF2_M1 + { 8, &RISCVDescs.OperandInfo[4513] }, // Inst #4011 = PseudoVLOXSEG4EI8_V_M2_M2_MASK + { 7, &RISCVDescs.OperandInfo[4506] }, // Inst #4010 = PseudoVLOXSEG4EI8_V_M2_M2 + { 8, &RISCVDescs.OperandInfo[4483] }, // Inst #4009 = PseudoVLOXSEG4EI8_V_M1_M2_MASK + { 7, &RISCVDescs.OperandInfo[4476] }, // Inst #4008 = PseudoVLOXSEG4EI8_V_M1_M2 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #4007 = PseudoVLOXSEG4EI8_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #4006 = PseudoVLOXSEG4EI8_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[4558] }, // Inst #4005 = PseudoVLOXSEG4EI64_V_M8_M2_MASK + { 7, &RISCVDescs.OperandInfo[4551] }, // Inst #4004 = PseudoVLOXSEG4EI64_V_M8_M2 + { 8, &RISCVDescs.OperandInfo[4573] }, // Inst #4003 = PseudoVLOXSEG4EI64_V_M8_M1_MASK + { 7, &RISCVDescs.OperandInfo[4566] }, // Inst #4002 = PseudoVLOXSEG4EI64_V_M8_M1 + { 8, &RISCVDescs.OperandInfo[4543] }, // Inst #4001 = PseudoVLOXSEG4EI64_V_M4_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4536] }, // Inst #4000 = PseudoVLOXSEG4EI64_V_M4_MF2 + { 8, &RISCVDescs.OperandInfo[4528] }, // Inst #3999 = PseudoVLOXSEG4EI64_V_M4_M2_MASK + { 7, &RISCVDescs.OperandInfo[4521] }, // Inst #3998 = PseudoVLOXSEG4EI64_V_M4_M2 + { 8, &RISCVDescs.OperandInfo[4543] }, // Inst #3997 = PseudoVLOXSEG4EI64_V_M4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4536] }, // Inst #3996 = PseudoVLOXSEG4EI64_V_M4_M1 + { 8, &RISCVDescs.OperandInfo[4498] }, // Inst #3995 = PseudoVLOXSEG4EI64_V_M2_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4491] }, // Inst #3994 = PseudoVLOXSEG4EI64_V_M2_MF4 + { 8, &RISCVDescs.OperandInfo[4498] }, // Inst #3993 = PseudoVLOXSEG4EI64_V_M2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4491] }, // Inst #3992 = PseudoVLOXSEG4EI64_V_M2_MF2 + { 8, &RISCVDescs.OperandInfo[4513] }, // Inst #3991 = PseudoVLOXSEG4EI64_V_M2_M2_MASK + { 7, &RISCVDescs.OperandInfo[4506] }, // Inst #3990 = PseudoVLOXSEG4EI64_V_M2_M2 + { 8, &RISCVDescs.OperandInfo[4498] }, // Inst #3989 = PseudoVLOXSEG4EI64_V_M2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4491] }, // Inst #3988 = PseudoVLOXSEG4EI64_V_M2_M1 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #3987 = PseudoVLOXSEG4EI64_V_M1_MF8_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #3986 = PseudoVLOXSEG4EI64_V_M1_MF8 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #3985 = PseudoVLOXSEG4EI64_V_M1_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #3984 = PseudoVLOXSEG4EI64_V_M1_MF4 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #3983 = PseudoVLOXSEG4EI64_V_M1_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #3982 = PseudoVLOXSEG4EI64_V_M1_MF2 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #3981 = PseudoVLOXSEG4EI64_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #3980 = PseudoVLOXSEG4EI64_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #3979 = PseudoVLOXSEG4EI32_V_MF2_MF8_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #3978 = PseudoVLOXSEG4EI32_V_MF2_MF8 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #3977 = PseudoVLOXSEG4EI32_V_MF2_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #3976 = PseudoVLOXSEG4EI32_V_MF2_MF4 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #3975 = PseudoVLOXSEG4EI32_V_MF2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #3974 = PseudoVLOXSEG4EI32_V_MF2_MF2 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #3973 = PseudoVLOXSEG4EI32_V_MF2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #3972 = PseudoVLOXSEG4EI32_V_MF2_M1 + { 8, &RISCVDescs.OperandInfo[4558] }, // Inst #3971 = PseudoVLOXSEG4EI32_V_M8_M2_MASK + { 7, &RISCVDescs.OperandInfo[4551] }, // Inst #3970 = PseudoVLOXSEG4EI32_V_M8_M2 + { 8, &RISCVDescs.OperandInfo[4528] }, // Inst #3969 = PseudoVLOXSEG4EI32_V_M4_M2_MASK + { 7, &RISCVDescs.OperandInfo[4521] }, // Inst #3968 = PseudoVLOXSEG4EI32_V_M4_M2 + { 8, &RISCVDescs.OperandInfo[4543] }, // Inst #3967 = PseudoVLOXSEG4EI32_V_M4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4536] }, // Inst #3966 = PseudoVLOXSEG4EI32_V_M4_M1 + { 8, &RISCVDescs.OperandInfo[4498] }, // Inst #3965 = PseudoVLOXSEG4EI32_V_M2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4491] }, // Inst #3964 = PseudoVLOXSEG4EI32_V_M2_MF2 + { 8, &RISCVDescs.OperandInfo[4513] }, // Inst #3963 = PseudoVLOXSEG4EI32_V_M2_M2_MASK + { 7, &RISCVDescs.OperandInfo[4506] }, // Inst #3962 = PseudoVLOXSEG4EI32_V_M2_M2 + { 8, &RISCVDescs.OperandInfo[4498] }, // Inst #3961 = PseudoVLOXSEG4EI32_V_M2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4491] }, // Inst #3960 = PseudoVLOXSEG4EI32_V_M2_M1 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #3959 = PseudoVLOXSEG4EI32_V_M1_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #3958 = PseudoVLOXSEG4EI32_V_M1_MF4 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #3957 = PseudoVLOXSEG4EI32_V_M1_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #3956 = PseudoVLOXSEG4EI32_V_M1_MF2 + { 8, &RISCVDescs.OperandInfo[4483] }, // Inst #3955 = PseudoVLOXSEG4EI32_V_M1_M2_MASK + { 7, &RISCVDescs.OperandInfo[4476] }, // Inst #3954 = PseudoVLOXSEG4EI32_V_M1_M2 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #3953 = PseudoVLOXSEG4EI32_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #3952 = PseudoVLOXSEG4EI32_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #3951 = PseudoVLOXSEG4EI16_V_MF4_MF8_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #3950 = PseudoVLOXSEG4EI16_V_MF4_MF8 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #3949 = PseudoVLOXSEG4EI16_V_MF4_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #3948 = PseudoVLOXSEG4EI16_V_MF4_MF4 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #3947 = PseudoVLOXSEG4EI16_V_MF4_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #3946 = PseudoVLOXSEG4EI16_V_MF4_MF2 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #3945 = PseudoVLOXSEG4EI16_V_MF4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #3944 = PseudoVLOXSEG4EI16_V_MF4_M1 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #3943 = PseudoVLOXSEG4EI16_V_MF2_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #3942 = PseudoVLOXSEG4EI16_V_MF2_MF4 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #3941 = PseudoVLOXSEG4EI16_V_MF2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #3940 = PseudoVLOXSEG4EI16_V_MF2_MF2 + { 8, &RISCVDescs.OperandInfo[4483] }, // Inst #3939 = PseudoVLOXSEG4EI16_V_MF2_M2_MASK + { 7, &RISCVDescs.OperandInfo[4476] }, // Inst #3938 = PseudoVLOXSEG4EI16_V_MF2_M2 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #3937 = PseudoVLOXSEG4EI16_V_MF2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #3936 = PseudoVLOXSEG4EI16_V_MF2_M1 + { 8, &RISCVDescs.OperandInfo[4528] }, // Inst #3935 = PseudoVLOXSEG4EI16_V_M4_M2_MASK + { 7, &RISCVDescs.OperandInfo[4521] }, // Inst #3934 = PseudoVLOXSEG4EI16_V_M4_M2 + { 8, &RISCVDescs.OperandInfo[4513] }, // Inst #3933 = PseudoVLOXSEG4EI16_V_M2_M2_MASK + { 7, &RISCVDescs.OperandInfo[4506] }, // Inst #3932 = PseudoVLOXSEG4EI16_V_M2_M2 + { 8, &RISCVDescs.OperandInfo[4498] }, // Inst #3931 = PseudoVLOXSEG4EI16_V_M2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4491] }, // Inst #3930 = PseudoVLOXSEG4EI16_V_M2_M1 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #3929 = PseudoVLOXSEG4EI16_V_M1_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #3928 = PseudoVLOXSEG4EI16_V_M1_MF2 + { 8, &RISCVDescs.OperandInfo[4483] }, // Inst #3927 = PseudoVLOXSEG4EI16_V_M1_M2_MASK + { 7, &RISCVDescs.OperandInfo[4476] }, // Inst #3926 = PseudoVLOXSEG4EI16_V_M1_M2 + { 8, &RISCVDescs.OperandInfo[4468] }, // Inst #3925 = PseudoVLOXSEG4EI16_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[4461] }, // Inst #3924 = PseudoVLOXSEG4EI16_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #3923 = PseudoVLOXSEG3EI8_V_MF8_MF8_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #3922 = PseudoVLOXSEG3EI8_V_MF8_MF8 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #3921 = PseudoVLOXSEG3EI8_V_MF8_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #3920 = PseudoVLOXSEG3EI8_V_MF8_MF4 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #3919 = PseudoVLOXSEG3EI8_V_MF8_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #3918 = PseudoVLOXSEG3EI8_V_MF8_MF2 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #3917 = PseudoVLOXSEG3EI8_V_MF8_M1_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #3916 = PseudoVLOXSEG3EI8_V_MF8_M1 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #3915 = PseudoVLOXSEG3EI8_V_MF4_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #3914 = PseudoVLOXSEG3EI8_V_MF4_MF4 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #3913 = PseudoVLOXSEG3EI8_V_MF4_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #3912 = PseudoVLOXSEG3EI8_V_MF4_MF2 + { 8, &RISCVDescs.OperandInfo[4363] }, // Inst #3911 = PseudoVLOXSEG3EI8_V_MF4_M2_MASK + { 7, &RISCVDescs.OperandInfo[4356] }, // Inst #3910 = PseudoVLOXSEG3EI8_V_MF4_M2 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #3909 = PseudoVLOXSEG3EI8_V_MF4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #3908 = PseudoVLOXSEG3EI8_V_MF4_M1 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #3907 = PseudoVLOXSEG3EI8_V_MF2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #3906 = PseudoVLOXSEG3EI8_V_MF2_MF2 + { 8, &RISCVDescs.OperandInfo[4363] }, // Inst #3905 = PseudoVLOXSEG3EI8_V_MF2_M2_MASK + { 7, &RISCVDescs.OperandInfo[4356] }, // Inst #3904 = PseudoVLOXSEG3EI8_V_MF2_M2 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #3903 = PseudoVLOXSEG3EI8_V_MF2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #3902 = PseudoVLOXSEG3EI8_V_MF2_M1 + { 8, &RISCVDescs.OperandInfo[4393] }, // Inst #3901 = PseudoVLOXSEG3EI8_V_M2_M2_MASK + { 7, &RISCVDescs.OperandInfo[4386] }, // Inst #3900 = PseudoVLOXSEG3EI8_V_M2_M2 + { 8, &RISCVDescs.OperandInfo[4363] }, // Inst #3899 = PseudoVLOXSEG3EI8_V_M1_M2_MASK + { 7, &RISCVDescs.OperandInfo[4356] }, // Inst #3898 = PseudoVLOXSEG3EI8_V_M1_M2 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #3897 = PseudoVLOXSEG3EI8_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #3896 = PseudoVLOXSEG3EI8_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[4438] }, // Inst #3895 = PseudoVLOXSEG3EI64_V_M8_M2_MASK + { 7, &RISCVDescs.OperandInfo[4431] }, // Inst #3894 = PseudoVLOXSEG3EI64_V_M8_M2 + { 8, &RISCVDescs.OperandInfo[4453] }, // Inst #3893 = PseudoVLOXSEG3EI64_V_M8_M1_MASK + { 7, &RISCVDescs.OperandInfo[4446] }, // Inst #3892 = PseudoVLOXSEG3EI64_V_M8_M1 + { 8, &RISCVDescs.OperandInfo[4423] }, // Inst #3891 = PseudoVLOXSEG3EI64_V_M4_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4416] }, // Inst #3890 = PseudoVLOXSEG3EI64_V_M4_MF2 + { 8, &RISCVDescs.OperandInfo[4408] }, // Inst #3889 = PseudoVLOXSEG3EI64_V_M4_M2_MASK + { 7, &RISCVDescs.OperandInfo[4401] }, // Inst #3888 = PseudoVLOXSEG3EI64_V_M4_M2 + { 8, &RISCVDescs.OperandInfo[4423] }, // Inst #3887 = PseudoVLOXSEG3EI64_V_M4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4416] }, // Inst #3886 = PseudoVLOXSEG3EI64_V_M4_M1 + { 8, &RISCVDescs.OperandInfo[4378] }, // Inst #3885 = PseudoVLOXSEG3EI64_V_M2_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4371] }, // Inst #3884 = PseudoVLOXSEG3EI64_V_M2_MF4 + { 8, &RISCVDescs.OperandInfo[4378] }, // Inst #3883 = PseudoVLOXSEG3EI64_V_M2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4371] }, // Inst #3882 = PseudoVLOXSEG3EI64_V_M2_MF2 + { 8, &RISCVDescs.OperandInfo[4393] }, // Inst #3881 = PseudoVLOXSEG3EI64_V_M2_M2_MASK + { 7, &RISCVDescs.OperandInfo[4386] }, // Inst #3880 = PseudoVLOXSEG3EI64_V_M2_M2 + { 8, &RISCVDescs.OperandInfo[4378] }, // Inst #3879 = PseudoVLOXSEG3EI64_V_M2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4371] }, // Inst #3878 = PseudoVLOXSEG3EI64_V_M2_M1 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #3877 = PseudoVLOXSEG3EI64_V_M1_MF8_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #3876 = PseudoVLOXSEG3EI64_V_M1_MF8 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #3875 = PseudoVLOXSEG3EI64_V_M1_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #3874 = PseudoVLOXSEG3EI64_V_M1_MF4 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #3873 = PseudoVLOXSEG3EI64_V_M1_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #3872 = PseudoVLOXSEG3EI64_V_M1_MF2 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #3871 = PseudoVLOXSEG3EI64_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #3870 = PseudoVLOXSEG3EI64_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #3869 = PseudoVLOXSEG3EI32_V_MF2_MF8_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #3868 = PseudoVLOXSEG3EI32_V_MF2_MF8 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #3867 = PseudoVLOXSEG3EI32_V_MF2_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #3866 = PseudoVLOXSEG3EI32_V_MF2_MF4 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #3865 = PseudoVLOXSEG3EI32_V_MF2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #3864 = PseudoVLOXSEG3EI32_V_MF2_MF2 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #3863 = PseudoVLOXSEG3EI32_V_MF2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #3862 = PseudoVLOXSEG3EI32_V_MF2_M1 + { 8, &RISCVDescs.OperandInfo[4438] }, // Inst #3861 = PseudoVLOXSEG3EI32_V_M8_M2_MASK + { 7, &RISCVDescs.OperandInfo[4431] }, // Inst #3860 = PseudoVLOXSEG3EI32_V_M8_M2 + { 8, &RISCVDescs.OperandInfo[4408] }, // Inst #3859 = PseudoVLOXSEG3EI32_V_M4_M2_MASK + { 7, &RISCVDescs.OperandInfo[4401] }, // Inst #3858 = PseudoVLOXSEG3EI32_V_M4_M2 + { 8, &RISCVDescs.OperandInfo[4423] }, // Inst #3857 = PseudoVLOXSEG3EI32_V_M4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4416] }, // Inst #3856 = PseudoVLOXSEG3EI32_V_M4_M1 + { 8, &RISCVDescs.OperandInfo[4378] }, // Inst #3855 = PseudoVLOXSEG3EI32_V_M2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4371] }, // Inst #3854 = PseudoVLOXSEG3EI32_V_M2_MF2 + { 8, &RISCVDescs.OperandInfo[4393] }, // Inst #3853 = PseudoVLOXSEG3EI32_V_M2_M2_MASK + { 7, &RISCVDescs.OperandInfo[4386] }, // Inst #3852 = PseudoVLOXSEG3EI32_V_M2_M2 + { 8, &RISCVDescs.OperandInfo[4378] }, // Inst #3851 = PseudoVLOXSEG3EI32_V_M2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4371] }, // Inst #3850 = PseudoVLOXSEG3EI32_V_M2_M1 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #3849 = PseudoVLOXSEG3EI32_V_M1_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #3848 = PseudoVLOXSEG3EI32_V_M1_MF4 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #3847 = PseudoVLOXSEG3EI32_V_M1_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #3846 = PseudoVLOXSEG3EI32_V_M1_MF2 + { 8, &RISCVDescs.OperandInfo[4363] }, // Inst #3845 = PseudoVLOXSEG3EI32_V_M1_M2_MASK + { 7, &RISCVDescs.OperandInfo[4356] }, // Inst #3844 = PseudoVLOXSEG3EI32_V_M1_M2 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #3843 = PseudoVLOXSEG3EI32_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #3842 = PseudoVLOXSEG3EI32_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #3841 = PseudoVLOXSEG3EI16_V_MF4_MF8_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #3840 = PseudoVLOXSEG3EI16_V_MF4_MF8 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #3839 = PseudoVLOXSEG3EI16_V_MF4_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #3838 = PseudoVLOXSEG3EI16_V_MF4_MF4 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #3837 = PseudoVLOXSEG3EI16_V_MF4_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #3836 = PseudoVLOXSEG3EI16_V_MF4_MF2 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #3835 = PseudoVLOXSEG3EI16_V_MF4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #3834 = PseudoVLOXSEG3EI16_V_MF4_M1 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #3833 = PseudoVLOXSEG3EI16_V_MF2_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #3832 = PseudoVLOXSEG3EI16_V_MF2_MF4 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #3831 = PseudoVLOXSEG3EI16_V_MF2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #3830 = PseudoVLOXSEG3EI16_V_MF2_MF2 + { 8, &RISCVDescs.OperandInfo[4363] }, // Inst #3829 = PseudoVLOXSEG3EI16_V_MF2_M2_MASK + { 7, &RISCVDescs.OperandInfo[4356] }, // Inst #3828 = PseudoVLOXSEG3EI16_V_MF2_M2 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #3827 = PseudoVLOXSEG3EI16_V_MF2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #3826 = PseudoVLOXSEG3EI16_V_MF2_M1 + { 8, &RISCVDescs.OperandInfo[4408] }, // Inst #3825 = PseudoVLOXSEG3EI16_V_M4_M2_MASK + { 7, &RISCVDescs.OperandInfo[4401] }, // Inst #3824 = PseudoVLOXSEG3EI16_V_M4_M2 + { 8, &RISCVDescs.OperandInfo[4393] }, // Inst #3823 = PseudoVLOXSEG3EI16_V_M2_M2_MASK + { 7, &RISCVDescs.OperandInfo[4386] }, // Inst #3822 = PseudoVLOXSEG3EI16_V_M2_M2 + { 8, &RISCVDescs.OperandInfo[4378] }, // Inst #3821 = PseudoVLOXSEG3EI16_V_M2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4371] }, // Inst #3820 = PseudoVLOXSEG3EI16_V_M2_M1 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #3819 = PseudoVLOXSEG3EI16_V_M1_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #3818 = PseudoVLOXSEG3EI16_V_M1_MF2 + { 8, &RISCVDescs.OperandInfo[4363] }, // Inst #3817 = PseudoVLOXSEG3EI16_V_M1_M2_MASK + { 7, &RISCVDescs.OperandInfo[4356] }, // Inst #3816 = PseudoVLOXSEG3EI16_V_M1_M2 + { 8, &RISCVDescs.OperandInfo[4348] }, // Inst #3815 = PseudoVLOXSEG3EI16_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[4341] }, // Inst #3814 = PseudoVLOXSEG3EI16_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #3813 = PseudoVLOXSEG2EI8_V_MF8_MF8_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #3812 = PseudoVLOXSEG2EI8_V_MF8_MF8 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #3811 = PseudoVLOXSEG2EI8_V_MF8_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #3810 = PseudoVLOXSEG2EI8_V_MF8_MF4 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #3809 = PseudoVLOXSEG2EI8_V_MF8_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #3808 = PseudoVLOXSEG2EI8_V_MF8_MF2 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #3807 = PseudoVLOXSEG2EI8_V_MF8_M1_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #3806 = PseudoVLOXSEG2EI8_V_MF8_M1 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #3805 = PseudoVLOXSEG2EI8_V_MF4_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #3804 = PseudoVLOXSEG2EI8_V_MF4_MF4 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #3803 = PseudoVLOXSEG2EI8_V_MF4_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #3802 = PseudoVLOXSEG2EI8_V_MF4_MF2 + { 8, &RISCVDescs.OperandInfo[4183] }, // Inst #3801 = PseudoVLOXSEG2EI8_V_MF4_M2_MASK + { 7, &RISCVDescs.OperandInfo[4176] }, // Inst #3800 = PseudoVLOXSEG2EI8_V_MF4_M2 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #3799 = PseudoVLOXSEG2EI8_V_MF4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #3798 = PseudoVLOXSEG2EI8_V_MF4_M1 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #3797 = PseudoVLOXSEG2EI8_V_MF2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #3796 = PseudoVLOXSEG2EI8_V_MF2_MF2 + { 8, &RISCVDescs.OperandInfo[4198] }, // Inst #3795 = PseudoVLOXSEG2EI8_V_MF2_M4_MASK + { 7, &RISCVDescs.OperandInfo[4191] }, // Inst #3794 = PseudoVLOXSEG2EI8_V_MF2_M4 + { 8, &RISCVDescs.OperandInfo[4183] }, // Inst #3793 = PseudoVLOXSEG2EI8_V_MF2_M2_MASK + { 7, &RISCVDescs.OperandInfo[4176] }, // Inst #3792 = PseudoVLOXSEG2EI8_V_MF2_M2 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #3791 = PseudoVLOXSEG2EI8_V_MF2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #3790 = PseudoVLOXSEG2EI8_V_MF2_M1 + { 8, &RISCVDescs.OperandInfo[4273] }, // Inst #3789 = PseudoVLOXSEG2EI8_V_M4_M4_MASK + { 7, &RISCVDescs.OperandInfo[4266] }, // Inst #3788 = PseudoVLOXSEG2EI8_V_M4_M4 + { 8, &RISCVDescs.OperandInfo[4243] }, // Inst #3787 = PseudoVLOXSEG2EI8_V_M2_M4_MASK + { 7, &RISCVDescs.OperandInfo[4236] }, // Inst #3786 = PseudoVLOXSEG2EI8_V_M2_M4 + { 8, &RISCVDescs.OperandInfo[4228] }, // Inst #3785 = PseudoVLOXSEG2EI8_V_M2_M2_MASK + { 7, &RISCVDescs.OperandInfo[4221] }, // Inst #3784 = PseudoVLOXSEG2EI8_V_M2_M2 + { 8, &RISCVDescs.OperandInfo[4198] }, // Inst #3783 = PseudoVLOXSEG2EI8_V_M1_M4_MASK + { 7, &RISCVDescs.OperandInfo[4191] }, // Inst #3782 = PseudoVLOXSEG2EI8_V_M1_M4 + { 8, &RISCVDescs.OperandInfo[4183] }, // Inst #3781 = PseudoVLOXSEG2EI8_V_M1_M2_MASK + { 7, &RISCVDescs.OperandInfo[4176] }, // Inst #3780 = PseudoVLOXSEG2EI8_V_M1_M2 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #3779 = PseudoVLOXSEG2EI8_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #3778 = PseudoVLOXSEG2EI8_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[4288] }, // Inst #3777 = PseudoVLOXSEG2EI64_V_M8_M4_MASK + { 7, &RISCVDescs.OperandInfo[4281] }, // Inst #3776 = PseudoVLOXSEG2EI64_V_M8_M4 + { 8, &RISCVDescs.OperandInfo[4318] }, // Inst #3775 = PseudoVLOXSEG2EI64_V_M8_M2_MASK + { 7, &RISCVDescs.OperandInfo[4311] }, // Inst #3774 = PseudoVLOXSEG2EI64_V_M8_M2 + { 8, &RISCVDescs.OperandInfo[4333] }, // Inst #3773 = PseudoVLOXSEG2EI64_V_M8_M1_MASK + { 7, &RISCVDescs.OperandInfo[4326] }, // Inst #3772 = PseudoVLOXSEG2EI64_V_M8_M1 + { 8, &RISCVDescs.OperandInfo[4303] }, // Inst #3771 = PseudoVLOXSEG2EI64_V_M4_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4296] }, // Inst #3770 = PseudoVLOXSEG2EI64_V_M4_MF2 + { 8, &RISCVDescs.OperandInfo[4273] }, // Inst #3769 = PseudoVLOXSEG2EI64_V_M4_M4_MASK + { 7, &RISCVDescs.OperandInfo[4266] }, // Inst #3768 = PseudoVLOXSEG2EI64_V_M4_M4 + { 8, &RISCVDescs.OperandInfo[4258] }, // Inst #3767 = PseudoVLOXSEG2EI64_V_M4_M2_MASK + { 7, &RISCVDescs.OperandInfo[4251] }, // Inst #3766 = PseudoVLOXSEG2EI64_V_M4_M2 + { 8, &RISCVDescs.OperandInfo[4303] }, // Inst #3765 = PseudoVLOXSEG2EI64_V_M4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4296] }, // Inst #3764 = PseudoVLOXSEG2EI64_V_M4_M1 + { 8, &RISCVDescs.OperandInfo[4213] }, // Inst #3763 = PseudoVLOXSEG2EI64_V_M2_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4206] }, // Inst #3762 = PseudoVLOXSEG2EI64_V_M2_MF4 + { 8, &RISCVDescs.OperandInfo[4213] }, // Inst #3761 = PseudoVLOXSEG2EI64_V_M2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4206] }, // Inst #3760 = PseudoVLOXSEG2EI64_V_M2_MF2 + { 8, &RISCVDescs.OperandInfo[4228] }, // Inst #3759 = PseudoVLOXSEG2EI64_V_M2_M2_MASK + { 7, &RISCVDescs.OperandInfo[4221] }, // Inst #3758 = PseudoVLOXSEG2EI64_V_M2_M2 + { 8, &RISCVDescs.OperandInfo[4213] }, // Inst #3757 = PseudoVLOXSEG2EI64_V_M2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4206] }, // Inst #3756 = PseudoVLOXSEG2EI64_V_M2_M1 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #3755 = PseudoVLOXSEG2EI64_V_M1_MF8_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #3754 = PseudoVLOXSEG2EI64_V_M1_MF8 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #3753 = PseudoVLOXSEG2EI64_V_M1_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #3752 = PseudoVLOXSEG2EI64_V_M1_MF4 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #3751 = PseudoVLOXSEG2EI64_V_M1_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #3750 = PseudoVLOXSEG2EI64_V_M1_MF2 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #3749 = PseudoVLOXSEG2EI64_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #3748 = PseudoVLOXSEG2EI64_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #3747 = PseudoVLOXSEG2EI32_V_MF2_MF8_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #3746 = PseudoVLOXSEG2EI32_V_MF2_MF8 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #3745 = PseudoVLOXSEG2EI32_V_MF2_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #3744 = PseudoVLOXSEG2EI32_V_MF2_MF4 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #3743 = PseudoVLOXSEG2EI32_V_MF2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #3742 = PseudoVLOXSEG2EI32_V_MF2_MF2 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #3741 = PseudoVLOXSEG2EI32_V_MF2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #3740 = PseudoVLOXSEG2EI32_V_MF2_M1 + { 8, &RISCVDescs.OperandInfo[4288] }, // Inst #3739 = PseudoVLOXSEG2EI32_V_M8_M4_MASK + { 7, &RISCVDescs.OperandInfo[4281] }, // Inst #3738 = PseudoVLOXSEG2EI32_V_M8_M4 + { 8, &RISCVDescs.OperandInfo[4318] }, // Inst #3737 = PseudoVLOXSEG2EI32_V_M8_M2_MASK + { 7, &RISCVDescs.OperandInfo[4311] }, // Inst #3736 = PseudoVLOXSEG2EI32_V_M8_M2 + { 8, &RISCVDescs.OperandInfo[4273] }, // Inst #3735 = PseudoVLOXSEG2EI32_V_M4_M4_MASK + { 7, &RISCVDescs.OperandInfo[4266] }, // Inst #3734 = PseudoVLOXSEG2EI32_V_M4_M4 + { 8, &RISCVDescs.OperandInfo[4258] }, // Inst #3733 = PseudoVLOXSEG2EI32_V_M4_M2_MASK + { 7, &RISCVDescs.OperandInfo[4251] }, // Inst #3732 = PseudoVLOXSEG2EI32_V_M4_M2 + { 8, &RISCVDescs.OperandInfo[4303] }, // Inst #3731 = PseudoVLOXSEG2EI32_V_M4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4296] }, // Inst #3730 = PseudoVLOXSEG2EI32_V_M4_M1 + { 8, &RISCVDescs.OperandInfo[4213] }, // Inst #3729 = PseudoVLOXSEG2EI32_V_M2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4206] }, // Inst #3728 = PseudoVLOXSEG2EI32_V_M2_MF2 + { 8, &RISCVDescs.OperandInfo[4243] }, // Inst #3727 = PseudoVLOXSEG2EI32_V_M2_M4_MASK + { 7, &RISCVDescs.OperandInfo[4236] }, // Inst #3726 = PseudoVLOXSEG2EI32_V_M2_M4 + { 8, &RISCVDescs.OperandInfo[4228] }, // Inst #3725 = PseudoVLOXSEG2EI32_V_M2_M2_MASK + { 7, &RISCVDescs.OperandInfo[4221] }, // Inst #3724 = PseudoVLOXSEG2EI32_V_M2_M2 + { 8, &RISCVDescs.OperandInfo[4213] }, // Inst #3723 = PseudoVLOXSEG2EI32_V_M2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4206] }, // Inst #3722 = PseudoVLOXSEG2EI32_V_M2_M1 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #3721 = PseudoVLOXSEG2EI32_V_M1_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #3720 = PseudoVLOXSEG2EI32_V_M1_MF4 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #3719 = PseudoVLOXSEG2EI32_V_M1_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #3718 = PseudoVLOXSEG2EI32_V_M1_MF2 + { 8, &RISCVDescs.OperandInfo[4183] }, // Inst #3717 = PseudoVLOXSEG2EI32_V_M1_M2_MASK + { 7, &RISCVDescs.OperandInfo[4176] }, // Inst #3716 = PseudoVLOXSEG2EI32_V_M1_M2 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #3715 = PseudoVLOXSEG2EI32_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #3714 = PseudoVLOXSEG2EI32_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #3713 = PseudoVLOXSEG2EI16_V_MF4_MF8_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #3712 = PseudoVLOXSEG2EI16_V_MF4_MF8 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #3711 = PseudoVLOXSEG2EI16_V_MF4_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #3710 = PseudoVLOXSEG2EI16_V_MF4_MF4 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #3709 = PseudoVLOXSEG2EI16_V_MF4_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #3708 = PseudoVLOXSEG2EI16_V_MF4_MF2 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #3707 = PseudoVLOXSEG2EI16_V_MF4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #3706 = PseudoVLOXSEG2EI16_V_MF4_M1 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #3705 = PseudoVLOXSEG2EI16_V_MF2_MF4_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #3704 = PseudoVLOXSEG2EI16_V_MF2_MF4 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #3703 = PseudoVLOXSEG2EI16_V_MF2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #3702 = PseudoVLOXSEG2EI16_V_MF2_MF2 + { 8, &RISCVDescs.OperandInfo[4183] }, // Inst #3701 = PseudoVLOXSEG2EI16_V_MF2_M2_MASK + { 7, &RISCVDescs.OperandInfo[4176] }, // Inst #3700 = PseudoVLOXSEG2EI16_V_MF2_M2 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #3699 = PseudoVLOXSEG2EI16_V_MF2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #3698 = PseudoVLOXSEG2EI16_V_MF2_M1 + { 8, &RISCVDescs.OperandInfo[4288] }, // Inst #3697 = PseudoVLOXSEG2EI16_V_M8_M4_MASK + { 7, &RISCVDescs.OperandInfo[4281] }, // Inst #3696 = PseudoVLOXSEG2EI16_V_M8_M4 + { 8, &RISCVDescs.OperandInfo[4273] }, // Inst #3695 = PseudoVLOXSEG2EI16_V_M4_M4_MASK + { 7, &RISCVDescs.OperandInfo[4266] }, // Inst #3694 = PseudoVLOXSEG2EI16_V_M4_M4 + { 8, &RISCVDescs.OperandInfo[4258] }, // Inst #3693 = PseudoVLOXSEG2EI16_V_M4_M2_MASK + { 7, &RISCVDescs.OperandInfo[4251] }, // Inst #3692 = PseudoVLOXSEG2EI16_V_M4_M2 + { 8, &RISCVDescs.OperandInfo[4243] }, // Inst #3691 = PseudoVLOXSEG2EI16_V_M2_M4_MASK + { 7, &RISCVDescs.OperandInfo[4236] }, // Inst #3690 = PseudoVLOXSEG2EI16_V_M2_M4 + { 8, &RISCVDescs.OperandInfo[4228] }, // Inst #3689 = PseudoVLOXSEG2EI16_V_M2_M2_MASK + { 7, &RISCVDescs.OperandInfo[4221] }, // Inst #3688 = PseudoVLOXSEG2EI16_V_M2_M2 + { 8, &RISCVDescs.OperandInfo[4213] }, // Inst #3687 = PseudoVLOXSEG2EI16_V_M2_M1_MASK + { 7, &RISCVDescs.OperandInfo[4206] }, // Inst #3686 = PseudoVLOXSEG2EI16_V_M2_M1 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #3685 = PseudoVLOXSEG2EI16_V_M1_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #3684 = PseudoVLOXSEG2EI16_V_M1_MF2 + { 8, &RISCVDescs.OperandInfo[4198] }, // Inst #3683 = PseudoVLOXSEG2EI16_V_M1_M4_MASK + { 7, &RISCVDescs.OperandInfo[4191] }, // Inst #3682 = PseudoVLOXSEG2EI16_V_M1_M4 + { 8, &RISCVDescs.OperandInfo[4183] }, // Inst #3681 = PseudoVLOXSEG2EI16_V_M1_M2_MASK + { 7, &RISCVDescs.OperandInfo[4176] }, // Inst #3680 = PseudoVLOXSEG2EI16_V_M1_M2 + { 8, &RISCVDescs.OperandInfo[4168] }, // Inst #3679 = PseudoVLOXSEG2EI16_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[4161] }, // Inst #3678 = PseudoVLOXSEG2EI16_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[3913] }, // Inst #3677 = PseudoVLOXEI8_V_MF8_MF8_MASK + { 7, &RISCVDescs.OperandInfo[3906] }, // Inst #3676 = PseudoVLOXEI8_V_MF8_MF8 + { 8, &RISCVDescs.OperandInfo[3958] }, // Inst #3675 = PseudoVLOXEI8_V_MF8_MF4_MASK + { 7, &RISCVDescs.OperandInfo[3951] }, // Inst #3674 = PseudoVLOXEI8_V_MF8_MF4 + { 8, &RISCVDescs.OperandInfo[3958] }, // Inst #3673 = PseudoVLOXEI8_V_MF8_MF2_MASK + { 7, &RISCVDescs.OperandInfo[3951] }, // Inst #3672 = PseudoVLOXEI8_V_MF8_MF2 + { 8, &RISCVDescs.OperandInfo[3958] }, // Inst #3671 = PseudoVLOXEI8_V_MF8_M1_MASK + { 7, &RISCVDescs.OperandInfo[3951] }, // Inst #3670 = PseudoVLOXEI8_V_MF8_M1 + { 8, &RISCVDescs.OperandInfo[3913] }, // Inst #3669 = PseudoVLOXEI8_V_MF4_MF4_MASK + { 7, &RISCVDescs.OperandInfo[3906] }, // Inst #3668 = PseudoVLOXEI8_V_MF4_MF4 + { 8, &RISCVDescs.OperandInfo[3958] }, // Inst #3667 = PseudoVLOXEI8_V_MF4_MF2_MASK + { 7, &RISCVDescs.OperandInfo[3951] }, // Inst #3666 = PseudoVLOXEI8_V_MF4_MF2 + { 8, &RISCVDescs.OperandInfo[3928] }, // Inst #3665 = PseudoVLOXEI8_V_MF4_M2_MASK + { 7, &RISCVDescs.OperandInfo[3921] }, // Inst #3664 = PseudoVLOXEI8_V_MF4_M2 + { 8, &RISCVDescs.OperandInfo[3958] }, // Inst #3663 = PseudoVLOXEI8_V_MF4_M1_MASK + { 7, &RISCVDescs.OperandInfo[3951] }, // Inst #3662 = PseudoVLOXEI8_V_MF4_M1 + { 8, &RISCVDescs.OperandInfo[3913] }, // Inst #3661 = PseudoVLOXEI8_V_MF2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[3906] }, // Inst #3660 = PseudoVLOXEI8_V_MF2_MF2 + { 8, &RISCVDescs.OperandInfo[3943] }, // Inst #3659 = PseudoVLOXEI8_V_MF2_M4_MASK + { 7, &RISCVDescs.OperandInfo[3936] }, // Inst #3658 = PseudoVLOXEI8_V_MF2_M4 + { 8, &RISCVDescs.OperandInfo[3928] }, // Inst #3657 = PseudoVLOXEI8_V_MF2_M2_MASK + { 7, &RISCVDescs.OperandInfo[3921] }, // Inst #3656 = PseudoVLOXEI8_V_MF2_M2 + { 8, &RISCVDescs.OperandInfo[3958] }, // Inst #3655 = PseudoVLOXEI8_V_MF2_M1_MASK + { 7, &RISCVDescs.OperandInfo[3951] }, // Inst #3654 = PseudoVLOXEI8_V_MF2_M1 + { 8, &RISCVDescs.OperandInfo[4093] }, // Inst #3653 = PseudoVLOXEI8_V_M8_M8_MASK + { 7, &RISCVDescs.OperandInfo[4086] }, // Inst #3652 = PseudoVLOXEI8_V_M8_M8 + { 8, &RISCVDescs.OperandInfo[4063] }, // Inst #3651 = PseudoVLOXEI8_V_M4_M8_MASK + { 7, &RISCVDescs.OperandInfo[4056] }, // Inst #3650 = PseudoVLOXEI8_V_M4_M8 + { 8, &RISCVDescs.OperandInfo[4048] }, // Inst #3649 = PseudoVLOXEI8_V_M4_M4_MASK + { 7, &RISCVDescs.OperandInfo[4041] }, // Inst #3648 = PseudoVLOXEI8_V_M4_M4 + { 8, &RISCVDescs.OperandInfo[4018] }, // Inst #3647 = PseudoVLOXEI8_V_M2_M8_MASK + { 7, &RISCVDescs.OperandInfo[4011] }, // Inst #3646 = PseudoVLOXEI8_V_M2_M8 + { 8, &RISCVDescs.OperandInfo[4003] }, // Inst #3645 = PseudoVLOXEI8_V_M2_M4_MASK + { 7, &RISCVDescs.OperandInfo[3996] }, // Inst #3644 = PseudoVLOXEI8_V_M2_M4 + { 8, &RISCVDescs.OperandInfo[3988] }, // Inst #3643 = PseudoVLOXEI8_V_M2_M2_MASK + { 7, &RISCVDescs.OperandInfo[3981] }, // Inst #3642 = PseudoVLOXEI8_V_M2_M2 + { 8, &RISCVDescs.OperandInfo[4153] }, // Inst #3641 = PseudoVLOXEI8_V_M1_M8_MASK + { 7, &RISCVDescs.OperandInfo[4146] }, // Inst #3640 = PseudoVLOXEI8_V_M1_M8 + { 8, &RISCVDescs.OperandInfo[3943] }, // Inst #3639 = PseudoVLOXEI8_V_M1_M4_MASK + { 7, &RISCVDescs.OperandInfo[3936] }, // Inst #3638 = PseudoVLOXEI8_V_M1_M4 + { 8, &RISCVDescs.OperandInfo[3928] }, // Inst #3637 = PseudoVLOXEI8_V_M1_M2_MASK + { 7, &RISCVDescs.OperandInfo[3921] }, // Inst #3636 = PseudoVLOXEI8_V_M1_M2 + { 8, &RISCVDescs.OperandInfo[3913] }, // Inst #3635 = PseudoVLOXEI8_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[3906] }, // Inst #3634 = PseudoVLOXEI8_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[4093] }, // Inst #3633 = PseudoVLOXEI64_V_M8_M8_MASK + { 7, &RISCVDescs.OperandInfo[4086] }, // Inst #3632 = PseudoVLOXEI64_V_M8_M8 + { 8, &RISCVDescs.OperandInfo[4078] }, // Inst #3631 = PseudoVLOXEI64_V_M8_M4_MASK + { 7, &RISCVDescs.OperandInfo[4071] }, // Inst #3630 = PseudoVLOXEI64_V_M8_M4 + { 8, &RISCVDescs.OperandInfo[4123] }, // Inst #3629 = PseudoVLOXEI64_V_M8_M2_MASK + { 7, &RISCVDescs.OperandInfo[4116] }, // Inst #3628 = PseudoVLOXEI64_V_M8_M2 + { 8, &RISCVDescs.OperandInfo[4138] }, // Inst #3627 = PseudoVLOXEI64_V_M8_M1_MASK + { 7, &RISCVDescs.OperandInfo[4131] }, // Inst #3626 = PseudoVLOXEI64_V_M8_M1 + { 8, &RISCVDescs.OperandInfo[4108] }, // Inst #3625 = PseudoVLOXEI64_V_M4_MF2_MASK + { 7, &RISCVDescs.OperandInfo[4101] }, // Inst #3624 = PseudoVLOXEI64_V_M4_MF2 + { 8, &RISCVDescs.OperandInfo[4048] }, // Inst #3623 = PseudoVLOXEI64_V_M4_M4_MASK + { 7, &RISCVDescs.OperandInfo[4041] }, // Inst #3622 = PseudoVLOXEI64_V_M4_M4 + { 8, &RISCVDescs.OperandInfo[4033] }, // Inst #3621 = PseudoVLOXEI64_V_M4_M2_MASK + { 7, &RISCVDescs.OperandInfo[4026] }, // Inst #3620 = PseudoVLOXEI64_V_M4_M2 + { 8, &RISCVDescs.OperandInfo[4108] }, // Inst #3619 = PseudoVLOXEI64_V_M4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4101] }, // Inst #3618 = PseudoVLOXEI64_V_M4_M1 + { 8, &RISCVDescs.OperandInfo[3973] }, // Inst #3617 = PseudoVLOXEI64_V_M2_MF4_MASK + { 7, &RISCVDescs.OperandInfo[3966] }, // Inst #3616 = PseudoVLOXEI64_V_M2_MF4 + { 8, &RISCVDescs.OperandInfo[3973] }, // Inst #3615 = PseudoVLOXEI64_V_M2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[3966] }, // Inst #3614 = PseudoVLOXEI64_V_M2_MF2 + { 8, &RISCVDescs.OperandInfo[3988] }, // Inst #3613 = PseudoVLOXEI64_V_M2_M2_MASK + { 7, &RISCVDescs.OperandInfo[3981] }, // Inst #3612 = PseudoVLOXEI64_V_M2_M2 + { 8, &RISCVDescs.OperandInfo[3973] }, // Inst #3611 = PseudoVLOXEI64_V_M2_M1_MASK + { 7, &RISCVDescs.OperandInfo[3966] }, // Inst #3610 = PseudoVLOXEI64_V_M2_M1 + { 8, &RISCVDescs.OperandInfo[3958] }, // Inst #3609 = PseudoVLOXEI64_V_M1_MF8_MASK + { 7, &RISCVDescs.OperandInfo[3951] }, // Inst #3608 = PseudoVLOXEI64_V_M1_MF8 + { 8, &RISCVDescs.OperandInfo[3958] }, // Inst #3607 = PseudoVLOXEI64_V_M1_MF4_MASK + { 7, &RISCVDescs.OperandInfo[3951] }, // Inst #3606 = PseudoVLOXEI64_V_M1_MF4 + { 8, &RISCVDescs.OperandInfo[3958] }, // Inst #3605 = PseudoVLOXEI64_V_M1_MF2_MASK + { 7, &RISCVDescs.OperandInfo[3951] }, // Inst #3604 = PseudoVLOXEI64_V_M1_MF2 + { 8, &RISCVDescs.OperandInfo[3913] }, // Inst #3603 = PseudoVLOXEI64_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[3906] }, // Inst #3602 = PseudoVLOXEI64_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[3958] }, // Inst #3601 = PseudoVLOXEI32_V_MF2_MF8_MASK + { 7, &RISCVDescs.OperandInfo[3951] }, // Inst #3600 = PseudoVLOXEI32_V_MF2_MF8 + { 8, &RISCVDescs.OperandInfo[3958] }, // Inst #3599 = PseudoVLOXEI32_V_MF2_MF4_MASK + { 7, &RISCVDescs.OperandInfo[3951] }, // Inst #3598 = PseudoVLOXEI32_V_MF2_MF4 + { 8, &RISCVDescs.OperandInfo[3913] }, // Inst #3597 = PseudoVLOXEI32_V_MF2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[3906] }, // Inst #3596 = PseudoVLOXEI32_V_MF2_MF2 + { 8, &RISCVDescs.OperandInfo[3958] }, // Inst #3595 = PseudoVLOXEI32_V_MF2_M1_MASK + { 7, &RISCVDescs.OperandInfo[3951] }, // Inst #3594 = PseudoVLOXEI32_V_MF2_M1 + { 8, &RISCVDescs.OperandInfo[4093] }, // Inst #3593 = PseudoVLOXEI32_V_M8_M8_MASK + { 7, &RISCVDescs.OperandInfo[4086] }, // Inst #3592 = PseudoVLOXEI32_V_M8_M8 + { 8, &RISCVDescs.OperandInfo[4078] }, // Inst #3591 = PseudoVLOXEI32_V_M8_M4_MASK + { 7, &RISCVDescs.OperandInfo[4071] }, // Inst #3590 = PseudoVLOXEI32_V_M8_M4 + { 8, &RISCVDescs.OperandInfo[4123] }, // Inst #3589 = PseudoVLOXEI32_V_M8_M2_MASK + { 7, &RISCVDescs.OperandInfo[4116] }, // Inst #3588 = PseudoVLOXEI32_V_M8_M2 + { 8, &RISCVDescs.OperandInfo[4063] }, // Inst #3587 = PseudoVLOXEI32_V_M4_M8_MASK + { 7, &RISCVDescs.OperandInfo[4056] }, // Inst #3586 = PseudoVLOXEI32_V_M4_M8 + { 8, &RISCVDescs.OperandInfo[4048] }, // Inst #3585 = PseudoVLOXEI32_V_M4_M4_MASK + { 7, &RISCVDescs.OperandInfo[4041] }, // Inst #3584 = PseudoVLOXEI32_V_M4_M4 + { 8, &RISCVDescs.OperandInfo[4033] }, // Inst #3583 = PseudoVLOXEI32_V_M4_M2_MASK + { 7, &RISCVDescs.OperandInfo[4026] }, // Inst #3582 = PseudoVLOXEI32_V_M4_M2 + { 8, &RISCVDescs.OperandInfo[4108] }, // Inst #3581 = PseudoVLOXEI32_V_M4_M1_MASK + { 7, &RISCVDescs.OperandInfo[4101] }, // Inst #3580 = PseudoVLOXEI32_V_M4_M1 + { 8, &RISCVDescs.OperandInfo[3973] }, // Inst #3579 = PseudoVLOXEI32_V_M2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[3966] }, // Inst #3578 = PseudoVLOXEI32_V_M2_MF2 + { 8, &RISCVDescs.OperandInfo[4003] }, // Inst #3577 = PseudoVLOXEI32_V_M2_M4_MASK + { 7, &RISCVDescs.OperandInfo[3996] }, // Inst #3576 = PseudoVLOXEI32_V_M2_M4 + { 8, &RISCVDescs.OperandInfo[3988] }, // Inst #3575 = PseudoVLOXEI32_V_M2_M2_MASK + { 7, &RISCVDescs.OperandInfo[3981] }, // Inst #3574 = PseudoVLOXEI32_V_M2_M2 + { 8, &RISCVDescs.OperandInfo[3973] }, // Inst #3573 = PseudoVLOXEI32_V_M2_M1_MASK + { 7, &RISCVDescs.OperandInfo[3966] }, // Inst #3572 = PseudoVLOXEI32_V_M2_M1 + { 8, &RISCVDescs.OperandInfo[3958] }, // Inst #3571 = PseudoVLOXEI32_V_M1_MF4_MASK + { 7, &RISCVDescs.OperandInfo[3951] }, // Inst #3570 = PseudoVLOXEI32_V_M1_MF4 + { 8, &RISCVDescs.OperandInfo[3958] }, // Inst #3569 = PseudoVLOXEI32_V_M1_MF2_MASK + { 7, &RISCVDescs.OperandInfo[3951] }, // Inst #3568 = PseudoVLOXEI32_V_M1_MF2 + { 8, &RISCVDescs.OperandInfo[3928] }, // Inst #3567 = PseudoVLOXEI32_V_M1_M2_MASK + { 7, &RISCVDescs.OperandInfo[3921] }, // Inst #3566 = PseudoVLOXEI32_V_M1_M2 + { 8, &RISCVDescs.OperandInfo[3913] }, // Inst #3565 = PseudoVLOXEI32_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[3906] }, // Inst #3564 = PseudoVLOXEI32_V_M1_M1 + { 8, &RISCVDescs.OperandInfo[3958] }, // Inst #3563 = PseudoVLOXEI16_V_MF4_MF8_MASK + { 7, &RISCVDescs.OperandInfo[3951] }, // Inst #3562 = PseudoVLOXEI16_V_MF4_MF8 + { 8, &RISCVDescs.OperandInfo[3913] }, // Inst #3561 = PseudoVLOXEI16_V_MF4_MF4_MASK + { 7, &RISCVDescs.OperandInfo[3906] }, // Inst #3560 = PseudoVLOXEI16_V_MF4_MF4 + { 8, &RISCVDescs.OperandInfo[3958] }, // Inst #3559 = PseudoVLOXEI16_V_MF4_MF2_MASK + { 7, &RISCVDescs.OperandInfo[3951] }, // Inst #3558 = PseudoVLOXEI16_V_MF4_MF2 + { 8, &RISCVDescs.OperandInfo[3958] }, // Inst #3557 = PseudoVLOXEI16_V_MF4_M1_MASK + { 7, &RISCVDescs.OperandInfo[3951] }, // Inst #3556 = PseudoVLOXEI16_V_MF4_M1 + { 8, &RISCVDescs.OperandInfo[3958] }, // Inst #3555 = PseudoVLOXEI16_V_MF2_MF4_MASK + { 7, &RISCVDescs.OperandInfo[3951] }, // Inst #3554 = PseudoVLOXEI16_V_MF2_MF4 + { 8, &RISCVDescs.OperandInfo[3913] }, // Inst #3553 = PseudoVLOXEI16_V_MF2_MF2_MASK + { 7, &RISCVDescs.OperandInfo[3906] }, // Inst #3552 = PseudoVLOXEI16_V_MF2_MF2 + { 8, &RISCVDescs.OperandInfo[3928] }, // Inst #3551 = PseudoVLOXEI16_V_MF2_M2_MASK + { 7, &RISCVDescs.OperandInfo[3921] }, // Inst #3550 = PseudoVLOXEI16_V_MF2_M2 + { 8, &RISCVDescs.OperandInfo[3958] }, // Inst #3549 = PseudoVLOXEI16_V_MF2_M1_MASK + { 7, &RISCVDescs.OperandInfo[3951] }, // Inst #3548 = PseudoVLOXEI16_V_MF2_M1 + { 8, &RISCVDescs.OperandInfo[4093] }, // Inst #3547 = PseudoVLOXEI16_V_M8_M8_MASK + { 7, &RISCVDescs.OperandInfo[4086] }, // Inst #3546 = PseudoVLOXEI16_V_M8_M8 + { 8, &RISCVDescs.OperandInfo[4078] }, // Inst #3545 = PseudoVLOXEI16_V_M8_M4_MASK + { 7, &RISCVDescs.OperandInfo[4071] }, // Inst #3544 = PseudoVLOXEI16_V_M8_M4 + { 8, &RISCVDescs.OperandInfo[4063] }, // Inst #3543 = PseudoVLOXEI16_V_M4_M8_MASK + { 7, &RISCVDescs.OperandInfo[4056] }, // Inst #3542 = PseudoVLOXEI16_V_M4_M8 + { 8, &RISCVDescs.OperandInfo[4048] }, // Inst #3541 = PseudoVLOXEI16_V_M4_M4_MASK + { 7, &RISCVDescs.OperandInfo[4041] }, // Inst #3540 = PseudoVLOXEI16_V_M4_M4 + { 8, &RISCVDescs.OperandInfo[4033] }, // Inst #3539 = PseudoVLOXEI16_V_M4_M2_MASK + { 7, &RISCVDescs.OperandInfo[4026] }, // Inst #3538 = PseudoVLOXEI16_V_M4_M2 + { 8, &RISCVDescs.OperandInfo[4018] }, // Inst #3537 = PseudoVLOXEI16_V_M2_M8_MASK + { 7, &RISCVDescs.OperandInfo[4011] }, // Inst #3536 = PseudoVLOXEI16_V_M2_M8 + { 8, &RISCVDescs.OperandInfo[4003] }, // Inst #3535 = PseudoVLOXEI16_V_M2_M4_MASK + { 7, &RISCVDescs.OperandInfo[3996] }, // Inst #3534 = PseudoVLOXEI16_V_M2_M4 + { 8, &RISCVDescs.OperandInfo[3988] }, // Inst #3533 = PseudoVLOXEI16_V_M2_M2_MASK + { 7, &RISCVDescs.OperandInfo[3981] }, // Inst #3532 = PseudoVLOXEI16_V_M2_M2 + { 8, &RISCVDescs.OperandInfo[3973] }, // Inst #3531 = PseudoVLOXEI16_V_M2_M1_MASK + { 7, &RISCVDescs.OperandInfo[3966] }, // Inst #3530 = PseudoVLOXEI16_V_M2_M1 + { 8, &RISCVDescs.OperandInfo[3958] }, // Inst #3529 = PseudoVLOXEI16_V_M1_MF2_MASK + { 7, &RISCVDescs.OperandInfo[3951] }, // Inst #3528 = PseudoVLOXEI16_V_M1_MF2 + { 8, &RISCVDescs.OperandInfo[3943] }, // Inst #3527 = PseudoVLOXEI16_V_M1_M4_MASK + { 7, &RISCVDescs.OperandInfo[3936] }, // Inst #3526 = PseudoVLOXEI16_V_M1_M4 + { 8, &RISCVDescs.OperandInfo[3928] }, // Inst #3525 = PseudoVLOXEI16_V_M1_M2_MASK + { 7, &RISCVDescs.OperandInfo[3921] }, // Inst #3524 = PseudoVLOXEI16_V_M1_M2 + { 8, &RISCVDescs.OperandInfo[3913] }, // Inst #3523 = PseudoVLOXEI16_V_M1_M1_MASK + { 7, &RISCVDescs.OperandInfo[3906] }, // Inst #3522 = PseudoVLOXEI16_V_M1_M1 + { 6, &RISCVDescs.OperandInfo[3854] }, // Inst #3521 = PseudoVLM_V_B8 + { 6, &RISCVDescs.OperandInfo[3854] }, // Inst #3520 = PseudoVLM_V_B64 + { 6, &RISCVDescs.OperandInfo[3854] }, // Inst #3519 = PseudoVLM_V_B4 + { 6, &RISCVDescs.OperandInfo[3854] }, // Inst #3518 = PseudoVLM_V_B32 + { 6, &RISCVDescs.OperandInfo[3854] }, // Inst #3517 = PseudoVLM_V_B2 + { 6, &RISCVDescs.OperandInfo[3854] }, // Inst #3516 = PseudoVLM_V_B16 + { 6, &RISCVDescs.OperandInfo[3854] }, // Inst #3515 = PseudoVLM_V_B1 + { 7, &RISCVDescs.OperandInfo[3860] }, // Inst #3514 = PseudoVLE8_V_MF8_MASK + { 6, &RISCVDescs.OperandInfo[3854] }, // Inst #3513 = PseudoVLE8_V_MF8 + { 7, &RISCVDescs.OperandInfo[3860] }, // Inst #3512 = PseudoVLE8_V_MF4_MASK + { 6, &RISCVDescs.OperandInfo[3854] }, // Inst #3511 = PseudoVLE8_V_MF4 + { 7, &RISCVDescs.OperandInfo[3860] }, // Inst #3510 = PseudoVLE8_V_MF2_MASK + { 6, &RISCVDescs.OperandInfo[3854] }, // Inst #3509 = PseudoVLE8_V_MF2 + { 7, &RISCVDescs.OperandInfo[3899] }, // Inst #3508 = PseudoVLE8_V_M8_MASK + { 6, &RISCVDescs.OperandInfo[3893] }, // Inst #3507 = PseudoVLE8_V_M8 + { 7, &RISCVDescs.OperandInfo[3886] }, // Inst #3506 = PseudoVLE8_V_M4_MASK + { 6, &RISCVDescs.OperandInfo[3880] }, // Inst #3505 = PseudoVLE8_V_M4 + { 7, &RISCVDescs.OperandInfo[3873] }, // Inst #3504 = PseudoVLE8_V_M2_MASK + { 6, &RISCVDescs.OperandInfo[3867] }, // Inst #3503 = PseudoVLE8_V_M2 + { 7, &RISCVDescs.OperandInfo[3860] }, // Inst #3502 = PseudoVLE8_V_M1_MASK + { 6, &RISCVDescs.OperandInfo[3854] }, // Inst #3501 = PseudoVLE8_V_M1 + { 8, &RISCVDescs.OperandInfo[3801] }, // Inst #3500 = PseudoVLE8FF_V_MF8_MASK + { 7, &RISCVDescs.OperandInfo[3794] }, // Inst #3499 = PseudoVLE8FF_V_MF8 + { 8, &RISCVDescs.OperandInfo[3801] }, // Inst #3498 = PseudoVLE8FF_V_MF4_MASK + { 7, &RISCVDescs.OperandInfo[3794] }, // Inst #3497 = PseudoVLE8FF_V_MF4 + { 8, &RISCVDescs.OperandInfo[3801] }, // Inst #3496 = PseudoVLE8FF_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[3794] }, // Inst #3495 = PseudoVLE8FF_V_MF2 + { 8, &RISCVDescs.OperandInfo[3846] }, // Inst #3494 = PseudoVLE8FF_V_M8_MASK + { 7, &RISCVDescs.OperandInfo[3839] }, // Inst #3493 = PseudoVLE8FF_V_M8 + { 8, &RISCVDescs.OperandInfo[3831] }, // Inst #3492 = PseudoVLE8FF_V_M4_MASK + { 7, &RISCVDescs.OperandInfo[3824] }, // Inst #3491 = PseudoVLE8FF_V_M4 + { 8, &RISCVDescs.OperandInfo[3816] }, // Inst #3490 = PseudoVLE8FF_V_M2_MASK + { 7, &RISCVDescs.OperandInfo[3809] }, // Inst #3489 = PseudoVLE8FF_V_M2 + { 8, &RISCVDescs.OperandInfo[3801] }, // Inst #3488 = PseudoVLE8FF_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[3794] }, // Inst #3487 = PseudoVLE8FF_V_M1 + { 7, &RISCVDescs.OperandInfo[3899] }, // Inst #3486 = PseudoVLE64_V_M8_MASK + { 6, &RISCVDescs.OperandInfo[3893] }, // Inst #3485 = PseudoVLE64_V_M8 + { 7, &RISCVDescs.OperandInfo[3886] }, // Inst #3484 = PseudoVLE64_V_M4_MASK + { 6, &RISCVDescs.OperandInfo[3880] }, // Inst #3483 = PseudoVLE64_V_M4 + { 7, &RISCVDescs.OperandInfo[3873] }, // Inst #3482 = PseudoVLE64_V_M2_MASK + { 6, &RISCVDescs.OperandInfo[3867] }, // Inst #3481 = PseudoVLE64_V_M2 + { 7, &RISCVDescs.OperandInfo[3860] }, // Inst #3480 = PseudoVLE64_V_M1_MASK + { 6, &RISCVDescs.OperandInfo[3854] }, // Inst #3479 = PseudoVLE64_V_M1 + { 8, &RISCVDescs.OperandInfo[3846] }, // Inst #3478 = PseudoVLE64FF_V_M8_MASK + { 7, &RISCVDescs.OperandInfo[3839] }, // Inst #3477 = PseudoVLE64FF_V_M8 + { 8, &RISCVDescs.OperandInfo[3831] }, // Inst #3476 = PseudoVLE64FF_V_M4_MASK + { 7, &RISCVDescs.OperandInfo[3824] }, // Inst #3475 = PseudoVLE64FF_V_M4 + { 8, &RISCVDescs.OperandInfo[3816] }, // Inst #3474 = PseudoVLE64FF_V_M2_MASK + { 7, &RISCVDescs.OperandInfo[3809] }, // Inst #3473 = PseudoVLE64FF_V_M2 + { 8, &RISCVDescs.OperandInfo[3801] }, // Inst #3472 = PseudoVLE64FF_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[3794] }, // Inst #3471 = PseudoVLE64FF_V_M1 + { 7, &RISCVDescs.OperandInfo[3860] }, // Inst #3470 = PseudoVLE32_V_MF2_MASK + { 6, &RISCVDescs.OperandInfo[3854] }, // Inst #3469 = PseudoVLE32_V_MF2 + { 7, &RISCVDescs.OperandInfo[3899] }, // Inst #3468 = PseudoVLE32_V_M8_MASK + { 6, &RISCVDescs.OperandInfo[3893] }, // Inst #3467 = PseudoVLE32_V_M8 + { 7, &RISCVDescs.OperandInfo[3886] }, // Inst #3466 = PseudoVLE32_V_M4_MASK + { 6, &RISCVDescs.OperandInfo[3880] }, // Inst #3465 = PseudoVLE32_V_M4 + { 7, &RISCVDescs.OperandInfo[3873] }, // Inst #3464 = PseudoVLE32_V_M2_MASK + { 6, &RISCVDescs.OperandInfo[3867] }, // Inst #3463 = PseudoVLE32_V_M2 + { 7, &RISCVDescs.OperandInfo[3860] }, // Inst #3462 = PseudoVLE32_V_M1_MASK + { 6, &RISCVDescs.OperandInfo[3854] }, // Inst #3461 = PseudoVLE32_V_M1 + { 8, &RISCVDescs.OperandInfo[3801] }, // Inst #3460 = PseudoVLE32FF_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[3794] }, // Inst #3459 = PseudoVLE32FF_V_MF2 + { 8, &RISCVDescs.OperandInfo[3846] }, // Inst #3458 = PseudoVLE32FF_V_M8_MASK + { 7, &RISCVDescs.OperandInfo[3839] }, // Inst #3457 = PseudoVLE32FF_V_M8 + { 8, &RISCVDescs.OperandInfo[3831] }, // Inst #3456 = PseudoVLE32FF_V_M4_MASK + { 7, &RISCVDescs.OperandInfo[3824] }, // Inst #3455 = PseudoVLE32FF_V_M4 + { 8, &RISCVDescs.OperandInfo[3816] }, // Inst #3454 = PseudoVLE32FF_V_M2_MASK + { 7, &RISCVDescs.OperandInfo[3809] }, // Inst #3453 = PseudoVLE32FF_V_M2 + { 8, &RISCVDescs.OperandInfo[3801] }, // Inst #3452 = PseudoVLE32FF_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[3794] }, // Inst #3451 = PseudoVLE32FF_V_M1 + { 7, &RISCVDescs.OperandInfo[3860] }, // Inst #3450 = PseudoVLE16_V_MF4_MASK + { 6, &RISCVDescs.OperandInfo[3854] }, // Inst #3449 = PseudoVLE16_V_MF4 + { 7, &RISCVDescs.OperandInfo[3860] }, // Inst #3448 = PseudoVLE16_V_MF2_MASK + { 6, &RISCVDescs.OperandInfo[3854] }, // Inst #3447 = PseudoVLE16_V_MF2 + { 7, &RISCVDescs.OperandInfo[3899] }, // Inst #3446 = PseudoVLE16_V_M8_MASK + { 6, &RISCVDescs.OperandInfo[3893] }, // Inst #3445 = PseudoVLE16_V_M8 + { 7, &RISCVDescs.OperandInfo[3886] }, // Inst #3444 = PseudoVLE16_V_M4_MASK + { 6, &RISCVDescs.OperandInfo[3880] }, // Inst #3443 = PseudoVLE16_V_M4 + { 7, &RISCVDescs.OperandInfo[3873] }, // Inst #3442 = PseudoVLE16_V_M2_MASK + { 6, &RISCVDescs.OperandInfo[3867] }, // Inst #3441 = PseudoVLE16_V_M2 + { 7, &RISCVDescs.OperandInfo[3860] }, // Inst #3440 = PseudoVLE16_V_M1_MASK + { 6, &RISCVDescs.OperandInfo[3854] }, // Inst #3439 = PseudoVLE16_V_M1 + { 8, &RISCVDescs.OperandInfo[3801] }, // Inst #3438 = PseudoVLE16FF_V_MF4_MASK + { 7, &RISCVDescs.OperandInfo[3794] }, // Inst #3437 = PseudoVLE16FF_V_MF4 + { 8, &RISCVDescs.OperandInfo[3801] }, // Inst #3436 = PseudoVLE16FF_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[3794] }, // Inst #3435 = PseudoVLE16FF_V_MF2 + { 8, &RISCVDescs.OperandInfo[3846] }, // Inst #3434 = PseudoVLE16FF_V_M8_MASK + { 7, &RISCVDescs.OperandInfo[3839] }, // Inst #3433 = PseudoVLE16FF_V_M8 + { 8, &RISCVDescs.OperandInfo[3831] }, // Inst #3432 = PseudoVLE16FF_V_M4_MASK + { 7, &RISCVDescs.OperandInfo[3824] }, // Inst #3431 = PseudoVLE16FF_V_M4 + { 8, &RISCVDescs.OperandInfo[3816] }, // Inst #3430 = PseudoVLE16FF_V_M2_MASK + { 7, &RISCVDescs.OperandInfo[3809] }, // Inst #3429 = PseudoVLE16FF_V_M2 + { 8, &RISCVDescs.OperandInfo[3801] }, // Inst #3428 = PseudoVLE16FF_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[3794] }, // Inst #3427 = PseudoVLE16FF_V_M1 + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #3426 = PseudoVIOTA_M_MF8_MASK + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #3425 = PseudoVIOTA_M_MF8 + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #3424 = PseudoVIOTA_M_MF4_MASK + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #3423 = PseudoVIOTA_M_MF4 + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #3422 = PseudoVIOTA_M_MF2_MASK + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #3421 = PseudoVIOTA_M_MF2 + { 7, &RISCVDescs.OperandInfo[3787] }, // Inst #3420 = PseudoVIOTA_M_M8_MASK + { 6, &RISCVDescs.OperandInfo[3781] }, // Inst #3419 = PseudoVIOTA_M_M8 + { 7, &RISCVDescs.OperandInfo[3774] }, // Inst #3418 = PseudoVIOTA_M_M4_MASK + { 6, &RISCVDescs.OperandInfo[3768] }, // Inst #3417 = PseudoVIOTA_M_M4 + { 7, &RISCVDescs.OperandInfo[3527] }, // Inst #3416 = PseudoVIOTA_M_M2_MASK + { 6, &RISCVDescs.OperandInfo[3521] }, // Inst #3415 = PseudoVIOTA_M_M2 + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #3414 = PseudoVIOTA_M_M1_MASK + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #3413 = PseudoVIOTA_M_M1 + { 6, &RISCVDescs.OperandInfo[3729] }, // Inst #3412 = PseudoVID_V_MF8_MASK + { 5, &RISCVDescs.OperandInfo[3724] }, // Inst #3411 = PseudoVID_V_MF8 + { 6, &RISCVDescs.OperandInfo[3729] }, // Inst #3410 = PseudoVID_V_MF4_MASK + { 5, &RISCVDescs.OperandInfo[3724] }, // Inst #3409 = PseudoVID_V_MF4 + { 6, &RISCVDescs.OperandInfo[3729] }, // Inst #3408 = PseudoVID_V_MF2_MASK + { 5, &RISCVDescs.OperandInfo[3724] }, // Inst #3407 = PseudoVID_V_MF2 + { 6, &RISCVDescs.OperandInfo[3762] }, // Inst #3406 = PseudoVID_V_M8_MASK + { 5, &RISCVDescs.OperandInfo[3757] }, // Inst #3405 = PseudoVID_V_M8 + { 6, &RISCVDescs.OperandInfo[3751] }, // Inst #3404 = PseudoVID_V_M4_MASK + { 5, &RISCVDescs.OperandInfo[3746] }, // Inst #3403 = PseudoVID_V_M4 + { 6, &RISCVDescs.OperandInfo[3740] }, // Inst #3402 = PseudoVID_V_M2_MASK + { 5, &RISCVDescs.OperandInfo[3735] }, // Inst #3401 = PseudoVID_V_M2 + { 6, &RISCVDescs.OperandInfo[3729] }, // Inst #3400 = PseudoVID_V_M1_MASK + { 5, &RISCVDescs.OperandInfo[3724] }, // Inst #3399 = PseudoVID_V_M1 + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #3398 = PseudoVGMUL_VV_MF2 + { 6, &RISCVDescs.OperandInfo[871] }, // Inst #3397 = PseudoVGMUL_VV_M8 + { 6, &RISCVDescs.OperandInfo[847] }, // Inst #3396 = PseudoVGMUL_VV_M4 + { 6, &RISCVDescs.OperandInfo[829] }, // Inst #3395 = PseudoVGMUL_VV_M2 + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #3394 = PseudoVGMUL_VV_M1 + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #3393 = PseudoVGHSH_VV_MF2 + { 7, &RISCVDescs.OperandInfo[742] }, // Inst #3392 = PseudoVGHSH_VV_M8 + { 7, &RISCVDescs.OperandInfo[727] }, // Inst #3391 = PseudoVGHSH_VV_M4 + { 7, &RISCVDescs.OperandInfo[712] }, // Inst #3390 = PseudoVGHSH_VV_M2 + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #3389 = PseudoVGHSH_VV_M1 + { 7, &RISCVDescs.OperandInfo[2827] }, // Inst #3388 = PseudoVFWSUB_WV_MF4_TIED + { 8, &RISCVDescs.OperandInfo[2834] }, // Inst #3387 = PseudoVFWSUB_WV_MF4_MASK_TIED + { 9, &RISCVDescs.OperandInfo[3416] }, // Inst #3386 = PseudoVFWSUB_WV_MF4_MASK + { 8, &RISCVDescs.OperandInfo[3408] }, // Inst #3385 = PseudoVFWSUB_WV_MF4 + { 7, &RISCVDescs.OperandInfo[2827] }, // Inst #3384 = PseudoVFWSUB_WV_MF2_TIED + { 8, &RISCVDescs.OperandInfo[2834] }, // Inst #3383 = PseudoVFWSUB_WV_MF2_MASK_TIED + { 9, &RISCVDescs.OperandInfo[3416] }, // Inst #3382 = PseudoVFWSUB_WV_MF2_MASK + { 8, &RISCVDescs.OperandInfo[3408] }, // Inst #3381 = PseudoVFWSUB_WV_MF2 + { 7, &RISCVDescs.OperandInfo[3514] }, // Inst #3380 = PseudoVFWSUB_WV_M4_TIED + { 8, &RISCVDescs.OperandInfo[3506] }, // Inst #3379 = PseudoVFWSUB_WV_M4_MASK_TIED + { 9, &RISCVDescs.OperandInfo[3497] }, // Inst #3378 = PseudoVFWSUB_WV_M4_MASK + { 8, &RISCVDescs.OperandInfo[3489] }, // Inst #3377 = PseudoVFWSUB_WV_M4 + { 7, &RISCVDescs.OperandInfo[3482] }, // Inst #3376 = PseudoVFWSUB_WV_M2_TIED + { 8, &RISCVDescs.OperandInfo[3474] }, // Inst #3375 = PseudoVFWSUB_WV_M2_MASK_TIED + { 9, &RISCVDescs.OperandInfo[3465] }, // Inst #3374 = PseudoVFWSUB_WV_M2_MASK + { 8, &RISCVDescs.OperandInfo[3457] }, // Inst #3373 = PseudoVFWSUB_WV_M2 + { 7, &RISCVDescs.OperandInfo[3450] }, // Inst #3372 = PseudoVFWSUB_WV_M1_TIED + { 8, &RISCVDescs.OperandInfo[3442] }, // Inst #3371 = PseudoVFWSUB_WV_M1_MASK_TIED + { 9, &RISCVDescs.OperandInfo[3433] }, // Inst #3370 = PseudoVFWSUB_WV_M1_MASK + { 8, &RISCVDescs.OperandInfo[3425] }, // Inst #3369 = PseudoVFWSUB_WV_M1 + { 9, &RISCVDescs.OperandInfo[1958] }, // Inst #3368 = PseudoVFWSUB_WFPR32_MF2_MASK + { 8, &RISCVDescs.OperandInfo[1950] }, // Inst #3367 = PseudoVFWSUB_WFPR32_MF2 + { 9, &RISCVDescs.OperandInfo[2009] }, // Inst #3366 = PseudoVFWSUB_WFPR32_M4_MASK + { 8, &RISCVDescs.OperandInfo[2001] }, // Inst #3365 = PseudoVFWSUB_WFPR32_M4 + { 9, &RISCVDescs.OperandInfo[1992] }, // Inst #3364 = PseudoVFWSUB_WFPR32_M2_MASK + { 8, &RISCVDescs.OperandInfo[1984] }, // Inst #3363 = PseudoVFWSUB_WFPR32_M2 + { 9, &RISCVDescs.OperandInfo[1975] }, // Inst #3362 = PseudoVFWSUB_WFPR32_M1_MASK + { 8, &RISCVDescs.OperandInfo[1967] }, // Inst #3361 = PseudoVFWSUB_WFPR32_M1 + { 9, &RISCVDescs.OperandInfo[1890] }, // Inst #3360 = PseudoVFWSUB_WFPR16_MF4_MASK + { 8, &RISCVDescs.OperandInfo[1882] }, // Inst #3359 = PseudoVFWSUB_WFPR16_MF4 + { 9, &RISCVDescs.OperandInfo[1890] }, // Inst #3358 = PseudoVFWSUB_WFPR16_MF2_MASK + { 8, &RISCVDescs.OperandInfo[1882] }, // Inst #3357 = PseudoVFWSUB_WFPR16_MF2 + { 9, &RISCVDescs.OperandInfo[1941] }, // Inst #3356 = PseudoVFWSUB_WFPR16_M4_MASK + { 8, &RISCVDescs.OperandInfo[1933] }, // Inst #3355 = PseudoVFWSUB_WFPR16_M4 + { 9, &RISCVDescs.OperandInfo[1924] }, // Inst #3354 = PseudoVFWSUB_WFPR16_M2_MASK + { 8, &RISCVDescs.OperandInfo[1916] }, // Inst #3353 = PseudoVFWSUB_WFPR16_M2 + { 9, &RISCVDescs.OperandInfo[1907] }, // Inst #3352 = PseudoVFWSUB_WFPR16_M1_MASK + { 8, &RISCVDescs.OperandInfo[1899] }, // Inst #3351 = PseudoVFWSUB_WFPR16_M1 + { 9, &RISCVDescs.OperandInfo[3416] }, // Inst #3350 = PseudoVFWSUB_VV_MF4_MASK + { 8, &RISCVDescs.OperandInfo[3408] }, // Inst #3349 = PseudoVFWSUB_VV_MF4 + { 9, &RISCVDescs.OperandInfo[3416] }, // Inst #3348 = PseudoVFWSUB_VV_MF2_MASK + { 8, &RISCVDescs.OperandInfo[3408] }, // Inst #3347 = PseudoVFWSUB_VV_MF2 + { 9, &RISCVDescs.OperandInfo[3399] }, // Inst #3346 = PseudoVFWSUB_VV_M4_MASK + { 8, &RISCVDescs.OperandInfo[3391] }, // Inst #3345 = PseudoVFWSUB_VV_M4 + { 9, &RISCVDescs.OperandInfo[3382] }, // Inst #3344 = PseudoVFWSUB_VV_M2_MASK + { 8, &RISCVDescs.OperandInfo[3374] }, // Inst #3343 = PseudoVFWSUB_VV_M2 + { 9, &RISCVDescs.OperandInfo[3365] }, // Inst #3342 = PseudoVFWSUB_VV_M1_MASK + { 8, &RISCVDescs.OperandInfo[3357] }, // Inst #3341 = PseudoVFWSUB_VV_M1 + { 9, &RISCVDescs.OperandInfo[2953] }, // Inst #3340 = PseudoVFWSUB_VFPR32_MF2_MASK + { 8, &RISCVDescs.OperandInfo[2945] }, // Inst #3339 = PseudoVFWSUB_VFPR32_MF2 + { 9, &RISCVDescs.OperandInfo[3348] }, // Inst #3338 = PseudoVFWSUB_VFPR32_M4_MASK + { 8, &RISCVDescs.OperandInfo[3340] }, // Inst #3337 = PseudoVFWSUB_VFPR32_M4 + { 9, &RISCVDescs.OperandInfo[3331] }, // Inst #3336 = PseudoVFWSUB_VFPR32_M2_MASK + { 8, &RISCVDescs.OperandInfo[3323] }, // Inst #3335 = PseudoVFWSUB_VFPR32_M2 + { 9, &RISCVDescs.OperandInfo[3314] }, // Inst #3334 = PseudoVFWSUB_VFPR32_M1_MASK + { 8, &RISCVDescs.OperandInfo[3306] }, // Inst #3333 = PseudoVFWSUB_VFPR32_M1 + { 9, &RISCVDescs.OperandInfo[3297] }, // Inst #3332 = PseudoVFWSUB_VFPR16_MF4_MASK + { 8, &RISCVDescs.OperandInfo[3289] }, // Inst #3331 = PseudoVFWSUB_VFPR16_MF4 + { 9, &RISCVDescs.OperandInfo[3297] }, // Inst #3330 = PseudoVFWSUB_VFPR16_MF2_MASK + { 8, &RISCVDescs.OperandInfo[3289] }, // Inst #3329 = PseudoVFWSUB_VFPR16_MF2 + { 9, &RISCVDescs.OperandInfo[3280] }, // Inst #3328 = PseudoVFWSUB_VFPR16_M4_MASK + { 8, &RISCVDescs.OperandInfo[3272] }, // Inst #3327 = PseudoVFWSUB_VFPR16_M4 + { 9, &RISCVDescs.OperandInfo[3263] }, // Inst #3326 = PseudoVFWSUB_VFPR16_M2_MASK + { 8, &RISCVDescs.OperandInfo[3255] }, // Inst #3325 = PseudoVFWSUB_VFPR16_M2 + { 9, &RISCVDescs.OperandInfo[3246] }, // Inst #3324 = PseudoVFWSUB_VFPR16_M1_MASK + { 8, &RISCVDescs.OperandInfo[3238] }, // Inst #3323 = PseudoVFWSUB_VFPR16_M1 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #3322 = PseudoVFWREDUSUM_VS_MF4_E16_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #3321 = PseudoVFWREDUSUM_VS_MF4_E16 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #3320 = PseudoVFWREDUSUM_VS_MF2_E32_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #3319 = PseudoVFWREDUSUM_VS_MF2_E32 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #3318 = PseudoVFWREDUSUM_VS_MF2_E16_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #3317 = PseudoVFWREDUSUM_VS_MF2_E16 + { 9, &RISCVDescs.OperandInfo[3049] }, // Inst #3316 = PseudoVFWREDUSUM_VS_M8_E32_MASK + { 8, &RISCVDescs.OperandInfo[3041] }, // Inst #3315 = PseudoVFWREDUSUM_VS_M8_E32 + { 9, &RISCVDescs.OperandInfo[3049] }, // Inst #3314 = PseudoVFWREDUSUM_VS_M8_E16_MASK + { 8, &RISCVDescs.OperandInfo[3041] }, // Inst #3313 = PseudoVFWREDUSUM_VS_M8_E16 + { 9, &RISCVDescs.OperandInfo[3032] }, // Inst #3312 = PseudoVFWREDUSUM_VS_M4_E32_MASK + { 8, &RISCVDescs.OperandInfo[3024] }, // Inst #3311 = PseudoVFWREDUSUM_VS_M4_E32 + { 9, &RISCVDescs.OperandInfo[3032] }, // Inst #3310 = PseudoVFWREDUSUM_VS_M4_E16_MASK + { 8, &RISCVDescs.OperandInfo[3024] }, // Inst #3309 = PseudoVFWREDUSUM_VS_M4_E16 + { 9, &RISCVDescs.OperandInfo[3015] }, // Inst #3308 = PseudoVFWREDUSUM_VS_M2_E32_MASK + { 8, &RISCVDescs.OperandInfo[3007] }, // Inst #3307 = PseudoVFWREDUSUM_VS_M2_E32 + { 9, &RISCVDescs.OperandInfo[3015] }, // Inst #3306 = PseudoVFWREDUSUM_VS_M2_E16_MASK + { 8, &RISCVDescs.OperandInfo[3007] }, // Inst #3305 = PseudoVFWREDUSUM_VS_M2_E16 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #3304 = PseudoVFWREDUSUM_VS_M1_E32_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #3303 = PseudoVFWREDUSUM_VS_M1_E32 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #3302 = PseudoVFWREDUSUM_VS_M1_E16_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #3301 = PseudoVFWREDUSUM_VS_M1_E16 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #3300 = PseudoVFWREDOSUM_VS_MF4_E16_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #3299 = PseudoVFWREDOSUM_VS_MF4_E16 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #3298 = PseudoVFWREDOSUM_VS_MF2_E32_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #3297 = PseudoVFWREDOSUM_VS_MF2_E32 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #3296 = PseudoVFWREDOSUM_VS_MF2_E16_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #3295 = PseudoVFWREDOSUM_VS_MF2_E16 + { 9, &RISCVDescs.OperandInfo[3049] }, // Inst #3294 = PseudoVFWREDOSUM_VS_M8_E32_MASK + { 8, &RISCVDescs.OperandInfo[3041] }, // Inst #3293 = PseudoVFWREDOSUM_VS_M8_E32 + { 9, &RISCVDescs.OperandInfo[3049] }, // Inst #3292 = PseudoVFWREDOSUM_VS_M8_E16_MASK + { 8, &RISCVDescs.OperandInfo[3041] }, // Inst #3291 = PseudoVFWREDOSUM_VS_M8_E16 + { 9, &RISCVDescs.OperandInfo[3032] }, // Inst #3290 = PseudoVFWREDOSUM_VS_M4_E32_MASK + { 8, &RISCVDescs.OperandInfo[3024] }, // Inst #3289 = PseudoVFWREDOSUM_VS_M4_E32 + { 9, &RISCVDescs.OperandInfo[3032] }, // Inst #3288 = PseudoVFWREDOSUM_VS_M4_E16_MASK + { 8, &RISCVDescs.OperandInfo[3024] }, // Inst #3287 = PseudoVFWREDOSUM_VS_M4_E16 + { 9, &RISCVDescs.OperandInfo[3015] }, // Inst #3286 = PseudoVFWREDOSUM_VS_M2_E32_MASK + { 8, &RISCVDescs.OperandInfo[3007] }, // Inst #3285 = PseudoVFWREDOSUM_VS_M2_E32 + { 9, &RISCVDescs.OperandInfo[3015] }, // Inst #3284 = PseudoVFWREDOSUM_VS_M2_E16_MASK + { 8, &RISCVDescs.OperandInfo[3007] }, // Inst #3283 = PseudoVFWREDOSUM_VS_M2_E16 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #3282 = PseudoVFWREDOSUM_VS_M1_E32_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #3281 = PseudoVFWREDOSUM_VS_M1_E32 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #3280 = PseudoVFWREDOSUM_VS_M1_E16_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #3279 = PseudoVFWREDOSUM_VS_M1_E16 + { 9, &RISCVDescs.OperandInfo[3416] }, // Inst #3278 = PseudoVFWNMSAC_VV_MF4_MASK + { 8, &RISCVDescs.OperandInfo[3408] }, // Inst #3277 = PseudoVFWNMSAC_VV_MF4 + { 9, &RISCVDescs.OperandInfo[3416] }, // Inst #3276 = PseudoVFWNMSAC_VV_MF2_MASK + { 8, &RISCVDescs.OperandInfo[3408] }, // Inst #3275 = PseudoVFWNMSAC_VV_MF2 + { 9, &RISCVDescs.OperandInfo[3399] }, // Inst #3274 = PseudoVFWNMSAC_VV_M4_MASK + { 8, &RISCVDescs.OperandInfo[3391] }, // Inst #3273 = PseudoVFWNMSAC_VV_M4 + { 9, &RISCVDescs.OperandInfo[3382] }, // Inst #3272 = PseudoVFWNMSAC_VV_M2_MASK + { 8, &RISCVDescs.OperandInfo[3374] }, // Inst #3271 = PseudoVFWNMSAC_VV_M2 + { 9, &RISCVDescs.OperandInfo[3365] }, // Inst #3270 = PseudoVFWNMSAC_VV_M1_MASK + { 8, &RISCVDescs.OperandInfo[3357] }, // Inst #3269 = PseudoVFWNMSAC_VV_M1 + { 9, &RISCVDescs.OperandInfo[3715] }, // Inst #3268 = PseudoVFWNMSAC_VFPR32_MF2_MASK + { 8, &RISCVDescs.OperandInfo[3707] }, // Inst #3267 = PseudoVFWNMSAC_VFPR32_MF2 + { 9, &RISCVDescs.OperandInfo[3698] }, // Inst #3266 = PseudoVFWNMSAC_VFPR32_M4_MASK + { 8, &RISCVDescs.OperandInfo[3690] }, // Inst #3265 = PseudoVFWNMSAC_VFPR32_M4 + { 9, &RISCVDescs.OperandInfo[3681] }, // Inst #3264 = PseudoVFWNMSAC_VFPR32_M2_MASK + { 8, &RISCVDescs.OperandInfo[3673] }, // Inst #3263 = PseudoVFWNMSAC_VFPR32_M2 + { 9, &RISCVDescs.OperandInfo[3664] }, // Inst #3262 = PseudoVFWNMSAC_VFPR32_M1_MASK + { 8, &RISCVDescs.OperandInfo[3656] }, // Inst #3261 = PseudoVFWNMSAC_VFPR32_M1 + { 9, &RISCVDescs.OperandInfo[3619] }, // Inst #3260 = PseudoVFWNMSAC_VFPR16_MF4_MASK + { 8, &RISCVDescs.OperandInfo[3611] }, // Inst #3259 = PseudoVFWNMSAC_VFPR16_MF4 + { 9, &RISCVDescs.OperandInfo[3619] }, // Inst #3258 = PseudoVFWNMSAC_VFPR16_MF2_MASK + { 8, &RISCVDescs.OperandInfo[3611] }, // Inst #3257 = PseudoVFWNMSAC_VFPR16_MF2 + { 9, &RISCVDescs.OperandInfo[3602] }, // Inst #3256 = PseudoVFWNMSAC_VFPR16_M4_MASK + { 8, &RISCVDescs.OperandInfo[3594] }, // Inst #3255 = PseudoVFWNMSAC_VFPR16_M4 + { 9, &RISCVDescs.OperandInfo[3585] }, // Inst #3254 = PseudoVFWNMSAC_VFPR16_M2_MASK + { 8, &RISCVDescs.OperandInfo[3577] }, // Inst #3253 = PseudoVFWNMSAC_VFPR16_M2 + { 9, &RISCVDescs.OperandInfo[3568] }, // Inst #3252 = PseudoVFWNMSAC_VFPR16_M1_MASK + { 8, &RISCVDescs.OperandInfo[3560] }, // Inst #3251 = PseudoVFWNMSAC_VFPR16_M1 + { 9, &RISCVDescs.OperandInfo[3416] }, // Inst #3250 = PseudoVFWNMACC_VV_MF4_MASK + { 8, &RISCVDescs.OperandInfo[3408] }, // Inst #3249 = PseudoVFWNMACC_VV_MF4 + { 9, &RISCVDescs.OperandInfo[3416] }, // Inst #3248 = PseudoVFWNMACC_VV_MF2_MASK + { 8, &RISCVDescs.OperandInfo[3408] }, // Inst #3247 = PseudoVFWNMACC_VV_MF2 + { 9, &RISCVDescs.OperandInfo[3399] }, // Inst #3246 = PseudoVFWNMACC_VV_M4_MASK + { 8, &RISCVDescs.OperandInfo[3391] }, // Inst #3245 = PseudoVFWNMACC_VV_M4 + { 9, &RISCVDescs.OperandInfo[3382] }, // Inst #3244 = PseudoVFWNMACC_VV_M2_MASK + { 8, &RISCVDescs.OperandInfo[3374] }, // Inst #3243 = PseudoVFWNMACC_VV_M2 + { 9, &RISCVDescs.OperandInfo[3365] }, // Inst #3242 = PseudoVFWNMACC_VV_M1_MASK + { 8, &RISCVDescs.OperandInfo[3357] }, // Inst #3241 = PseudoVFWNMACC_VV_M1 + { 9, &RISCVDescs.OperandInfo[3715] }, // Inst #3240 = PseudoVFWNMACC_VFPR32_MF2_MASK + { 8, &RISCVDescs.OperandInfo[3707] }, // Inst #3239 = PseudoVFWNMACC_VFPR32_MF2 + { 9, &RISCVDescs.OperandInfo[3698] }, // Inst #3238 = PseudoVFWNMACC_VFPR32_M4_MASK + { 8, &RISCVDescs.OperandInfo[3690] }, // Inst #3237 = PseudoVFWNMACC_VFPR32_M4 + { 9, &RISCVDescs.OperandInfo[3681] }, // Inst #3236 = PseudoVFWNMACC_VFPR32_M2_MASK + { 8, &RISCVDescs.OperandInfo[3673] }, // Inst #3235 = PseudoVFWNMACC_VFPR32_M2 + { 9, &RISCVDescs.OperandInfo[3664] }, // Inst #3234 = PseudoVFWNMACC_VFPR32_M1_MASK + { 8, &RISCVDescs.OperandInfo[3656] }, // Inst #3233 = PseudoVFWNMACC_VFPR32_M1 + { 9, &RISCVDescs.OperandInfo[3619] }, // Inst #3232 = PseudoVFWNMACC_VFPR16_MF4_MASK + { 8, &RISCVDescs.OperandInfo[3611] }, // Inst #3231 = PseudoVFWNMACC_VFPR16_MF4 + { 9, &RISCVDescs.OperandInfo[3619] }, // Inst #3230 = PseudoVFWNMACC_VFPR16_MF2_MASK + { 8, &RISCVDescs.OperandInfo[3611] }, // Inst #3229 = PseudoVFWNMACC_VFPR16_MF2 + { 9, &RISCVDescs.OperandInfo[3602] }, // Inst #3228 = PseudoVFWNMACC_VFPR16_M4_MASK + { 8, &RISCVDescs.OperandInfo[3594] }, // Inst #3227 = PseudoVFWNMACC_VFPR16_M4 + { 9, &RISCVDescs.OperandInfo[3585] }, // Inst #3226 = PseudoVFWNMACC_VFPR16_M2_MASK + { 8, &RISCVDescs.OperandInfo[3577] }, // Inst #3225 = PseudoVFWNMACC_VFPR16_M2 + { 9, &RISCVDescs.OperandInfo[3568] }, // Inst #3224 = PseudoVFWNMACC_VFPR16_M1_MASK + { 8, &RISCVDescs.OperandInfo[3560] }, // Inst #3223 = PseudoVFWNMACC_VFPR16_M1 + { 9, &RISCVDescs.OperandInfo[3416] }, // Inst #3222 = PseudoVFWMUL_VV_MF4_MASK + { 8, &RISCVDescs.OperandInfo[3408] }, // Inst #3221 = PseudoVFWMUL_VV_MF4 + { 9, &RISCVDescs.OperandInfo[3416] }, // Inst #3220 = PseudoVFWMUL_VV_MF2_MASK + { 8, &RISCVDescs.OperandInfo[3408] }, // Inst #3219 = PseudoVFWMUL_VV_MF2 + { 9, &RISCVDescs.OperandInfo[3399] }, // Inst #3218 = PseudoVFWMUL_VV_M4_MASK + { 8, &RISCVDescs.OperandInfo[3391] }, // Inst #3217 = PseudoVFWMUL_VV_M4 + { 9, &RISCVDescs.OperandInfo[3382] }, // Inst #3216 = PseudoVFWMUL_VV_M2_MASK + { 8, &RISCVDescs.OperandInfo[3374] }, // Inst #3215 = PseudoVFWMUL_VV_M2 + { 9, &RISCVDescs.OperandInfo[3365] }, // Inst #3214 = PseudoVFWMUL_VV_M1_MASK + { 8, &RISCVDescs.OperandInfo[3357] }, // Inst #3213 = PseudoVFWMUL_VV_M1 + { 9, &RISCVDescs.OperandInfo[2953] }, // Inst #3212 = PseudoVFWMUL_VFPR32_MF2_MASK + { 8, &RISCVDescs.OperandInfo[2945] }, // Inst #3211 = PseudoVFWMUL_VFPR32_MF2 + { 9, &RISCVDescs.OperandInfo[3348] }, // Inst #3210 = PseudoVFWMUL_VFPR32_M4_MASK + { 8, &RISCVDescs.OperandInfo[3340] }, // Inst #3209 = PseudoVFWMUL_VFPR32_M4 + { 9, &RISCVDescs.OperandInfo[3331] }, // Inst #3208 = PseudoVFWMUL_VFPR32_M2_MASK + { 8, &RISCVDescs.OperandInfo[3323] }, // Inst #3207 = PseudoVFWMUL_VFPR32_M2 + { 9, &RISCVDescs.OperandInfo[3314] }, // Inst #3206 = PseudoVFWMUL_VFPR32_M1_MASK + { 8, &RISCVDescs.OperandInfo[3306] }, // Inst #3205 = PseudoVFWMUL_VFPR32_M1 + { 9, &RISCVDescs.OperandInfo[3297] }, // Inst #3204 = PseudoVFWMUL_VFPR16_MF4_MASK + { 8, &RISCVDescs.OperandInfo[3289] }, // Inst #3203 = PseudoVFWMUL_VFPR16_MF4 + { 9, &RISCVDescs.OperandInfo[3297] }, // Inst #3202 = PseudoVFWMUL_VFPR16_MF2_MASK + { 8, &RISCVDescs.OperandInfo[3289] }, // Inst #3201 = PseudoVFWMUL_VFPR16_MF2 + { 9, &RISCVDescs.OperandInfo[3280] }, // Inst #3200 = PseudoVFWMUL_VFPR16_M4_MASK + { 8, &RISCVDescs.OperandInfo[3272] }, // Inst #3199 = PseudoVFWMUL_VFPR16_M4 + { 9, &RISCVDescs.OperandInfo[3263] }, // Inst #3198 = PseudoVFWMUL_VFPR16_M2_MASK + { 8, &RISCVDescs.OperandInfo[3255] }, // Inst #3197 = PseudoVFWMUL_VFPR16_M2 + { 9, &RISCVDescs.OperandInfo[3246] }, // Inst #3196 = PseudoVFWMUL_VFPR16_M1_MASK + { 8, &RISCVDescs.OperandInfo[3238] }, // Inst #3195 = PseudoVFWMUL_VFPR16_M1 + { 9, &RISCVDescs.OperandInfo[3416] }, // Inst #3194 = PseudoVFWMSAC_VV_MF4_MASK + { 8, &RISCVDescs.OperandInfo[3408] }, // Inst #3193 = PseudoVFWMSAC_VV_MF4 + { 9, &RISCVDescs.OperandInfo[3416] }, // Inst #3192 = PseudoVFWMSAC_VV_MF2_MASK + { 8, &RISCVDescs.OperandInfo[3408] }, // Inst #3191 = PseudoVFWMSAC_VV_MF2 + { 9, &RISCVDescs.OperandInfo[3399] }, // Inst #3190 = PseudoVFWMSAC_VV_M4_MASK + { 8, &RISCVDescs.OperandInfo[3391] }, // Inst #3189 = PseudoVFWMSAC_VV_M4 + { 9, &RISCVDescs.OperandInfo[3382] }, // Inst #3188 = PseudoVFWMSAC_VV_M2_MASK + { 8, &RISCVDescs.OperandInfo[3374] }, // Inst #3187 = PseudoVFWMSAC_VV_M2 + { 9, &RISCVDescs.OperandInfo[3365] }, // Inst #3186 = PseudoVFWMSAC_VV_M1_MASK + { 8, &RISCVDescs.OperandInfo[3357] }, // Inst #3185 = PseudoVFWMSAC_VV_M1 + { 9, &RISCVDescs.OperandInfo[3715] }, // Inst #3184 = PseudoVFWMSAC_VFPR32_MF2_MASK + { 8, &RISCVDescs.OperandInfo[3707] }, // Inst #3183 = PseudoVFWMSAC_VFPR32_MF2 + { 9, &RISCVDescs.OperandInfo[3698] }, // Inst #3182 = PseudoVFWMSAC_VFPR32_M4_MASK + { 8, &RISCVDescs.OperandInfo[3690] }, // Inst #3181 = PseudoVFWMSAC_VFPR32_M4 + { 9, &RISCVDescs.OperandInfo[3681] }, // Inst #3180 = PseudoVFWMSAC_VFPR32_M2_MASK + { 8, &RISCVDescs.OperandInfo[3673] }, // Inst #3179 = PseudoVFWMSAC_VFPR32_M2 + { 9, &RISCVDescs.OperandInfo[3664] }, // Inst #3178 = PseudoVFWMSAC_VFPR32_M1_MASK + { 8, &RISCVDescs.OperandInfo[3656] }, // Inst #3177 = PseudoVFWMSAC_VFPR32_M1 + { 9, &RISCVDescs.OperandInfo[3619] }, // Inst #3176 = PseudoVFWMSAC_VFPR16_MF4_MASK + { 8, &RISCVDescs.OperandInfo[3611] }, // Inst #3175 = PseudoVFWMSAC_VFPR16_MF4 + { 9, &RISCVDescs.OperandInfo[3619] }, // Inst #3174 = PseudoVFWMSAC_VFPR16_MF2_MASK + { 8, &RISCVDescs.OperandInfo[3611] }, // Inst #3173 = PseudoVFWMSAC_VFPR16_MF2 + { 9, &RISCVDescs.OperandInfo[3602] }, // Inst #3172 = PseudoVFWMSAC_VFPR16_M4_MASK + { 8, &RISCVDescs.OperandInfo[3594] }, // Inst #3171 = PseudoVFWMSAC_VFPR16_M4 + { 9, &RISCVDescs.OperandInfo[3585] }, // Inst #3170 = PseudoVFWMSAC_VFPR16_M2_MASK + { 8, &RISCVDescs.OperandInfo[3577] }, // Inst #3169 = PseudoVFWMSAC_VFPR16_M2 + { 9, &RISCVDescs.OperandInfo[3568] }, // Inst #3168 = PseudoVFWMSAC_VFPR16_M1_MASK + { 8, &RISCVDescs.OperandInfo[3560] }, // Inst #3167 = PseudoVFWMSAC_VFPR16_M1 + { 9, &RISCVDescs.OperandInfo[3416] }, // Inst #3166 = PseudoVFWMACC_VV_MF4_MASK + { 8, &RISCVDescs.OperandInfo[3408] }, // Inst #3165 = PseudoVFWMACC_VV_MF4 + { 9, &RISCVDescs.OperandInfo[3416] }, // Inst #3164 = PseudoVFWMACC_VV_MF2_MASK + { 8, &RISCVDescs.OperandInfo[3408] }, // Inst #3163 = PseudoVFWMACC_VV_MF2 + { 9, &RISCVDescs.OperandInfo[3399] }, // Inst #3162 = PseudoVFWMACC_VV_M4_MASK + { 8, &RISCVDescs.OperandInfo[3391] }, // Inst #3161 = PseudoVFWMACC_VV_M4 + { 9, &RISCVDescs.OperandInfo[3382] }, // Inst #3160 = PseudoVFWMACC_VV_M2_MASK + { 8, &RISCVDescs.OperandInfo[3374] }, // Inst #3159 = PseudoVFWMACC_VV_M2 + { 9, &RISCVDescs.OperandInfo[3365] }, // Inst #3158 = PseudoVFWMACC_VV_M1_MASK + { 8, &RISCVDescs.OperandInfo[3357] }, // Inst #3157 = PseudoVFWMACC_VV_M1 + { 9, &RISCVDescs.OperandInfo[3715] }, // Inst #3156 = PseudoVFWMACC_VFPR32_MF2_MASK + { 8, &RISCVDescs.OperandInfo[3707] }, // Inst #3155 = PseudoVFWMACC_VFPR32_MF2 + { 9, &RISCVDescs.OperandInfo[3698] }, // Inst #3154 = PseudoVFWMACC_VFPR32_M4_MASK + { 8, &RISCVDescs.OperandInfo[3690] }, // Inst #3153 = PseudoVFWMACC_VFPR32_M4 + { 9, &RISCVDescs.OperandInfo[3681] }, // Inst #3152 = PseudoVFWMACC_VFPR32_M2_MASK + { 8, &RISCVDescs.OperandInfo[3673] }, // Inst #3151 = PseudoVFWMACC_VFPR32_M2 + { 9, &RISCVDescs.OperandInfo[3664] }, // Inst #3150 = PseudoVFWMACC_VFPR32_M1_MASK + { 8, &RISCVDescs.OperandInfo[3656] }, // Inst #3149 = PseudoVFWMACC_VFPR32_M1 + { 9, &RISCVDescs.OperandInfo[3619] }, // Inst #3148 = PseudoVFWMACC_VFPR16_MF4_MASK + { 8, &RISCVDescs.OperandInfo[3611] }, // Inst #3147 = PseudoVFWMACC_VFPR16_MF4 + { 9, &RISCVDescs.OperandInfo[3619] }, // Inst #3146 = PseudoVFWMACC_VFPR16_MF2_MASK + { 8, &RISCVDescs.OperandInfo[3611] }, // Inst #3145 = PseudoVFWMACC_VFPR16_MF2 + { 9, &RISCVDescs.OperandInfo[3602] }, // Inst #3144 = PseudoVFWMACC_VFPR16_M4_MASK + { 8, &RISCVDescs.OperandInfo[3594] }, // Inst #3143 = PseudoVFWMACC_VFPR16_M4 + { 9, &RISCVDescs.OperandInfo[3585] }, // Inst #3142 = PseudoVFWMACC_VFPR16_M2_MASK + { 8, &RISCVDescs.OperandInfo[3577] }, // Inst #3141 = PseudoVFWMACC_VFPR16_M2 + { 9, &RISCVDescs.OperandInfo[3568] }, // Inst #3140 = PseudoVFWMACC_VFPR16_M1_MASK + { 8, &RISCVDescs.OperandInfo[3560] }, // Inst #3139 = PseudoVFWMACC_VFPR16_M1 + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #3138 = PseudoVFWMACC_4x4x4_MF4 + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #3137 = PseudoVFWMACC_4x4x4_MF2 + { 7, &RISCVDescs.OperandInfo[3649] }, // Inst #3136 = PseudoVFWMACC_4x4x4_M8 + { 7, &RISCVDescs.OperandInfo[3642] }, // Inst #3135 = PseudoVFWMACC_4x4x4_M4 + { 7, &RISCVDescs.OperandInfo[3635] }, // Inst #3134 = PseudoVFWMACC_4x4x4_M2 + { 7, &RISCVDescs.OperandInfo[3628] }, // Inst #3133 = PseudoVFWMACC_4x4x4_M1 + { 9, &RISCVDescs.OperandInfo[3416] }, // Inst #3132 = PseudoVFWMACCBF16_VV_MF4_MASK + { 8, &RISCVDescs.OperandInfo[3408] }, // Inst #3131 = PseudoVFWMACCBF16_VV_MF4 + { 9, &RISCVDescs.OperandInfo[3416] }, // Inst #3130 = PseudoVFWMACCBF16_VV_MF2_MASK + { 8, &RISCVDescs.OperandInfo[3408] }, // Inst #3129 = PseudoVFWMACCBF16_VV_MF2 + { 9, &RISCVDescs.OperandInfo[3399] }, // Inst #3128 = PseudoVFWMACCBF16_VV_M4_MASK + { 8, &RISCVDescs.OperandInfo[3391] }, // Inst #3127 = PseudoVFWMACCBF16_VV_M4 + { 9, &RISCVDescs.OperandInfo[3382] }, // Inst #3126 = PseudoVFWMACCBF16_VV_M2_MASK + { 8, &RISCVDescs.OperandInfo[3374] }, // Inst #3125 = PseudoVFWMACCBF16_VV_M2 + { 9, &RISCVDescs.OperandInfo[3365] }, // Inst #3124 = PseudoVFWMACCBF16_VV_M1_MASK + { 8, &RISCVDescs.OperandInfo[3357] }, // Inst #3123 = PseudoVFWMACCBF16_VV_M1 + { 9, &RISCVDescs.OperandInfo[3619] }, // Inst #3122 = PseudoVFWMACCBF16_VFPR16_MF4_MASK + { 8, &RISCVDescs.OperandInfo[3611] }, // Inst #3121 = PseudoVFWMACCBF16_VFPR16_MF4 + { 9, &RISCVDescs.OperandInfo[3619] }, // Inst #3120 = PseudoVFWMACCBF16_VFPR16_MF2_MASK + { 8, &RISCVDescs.OperandInfo[3611] }, // Inst #3119 = PseudoVFWMACCBF16_VFPR16_MF2 + { 9, &RISCVDescs.OperandInfo[3602] }, // Inst #3118 = PseudoVFWMACCBF16_VFPR16_M4_MASK + { 8, &RISCVDescs.OperandInfo[3594] }, // Inst #3117 = PseudoVFWMACCBF16_VFPR16_M4 + { 9, &RISCVDescs.OperandInfo[3585] }, // Inst #3116 = PseudoVFWMACCBF16_VFPR16_M2_MASK + { 8, &RISCVDescs.OperandInfo[3577] }, // Inst #3115 = PseudoVFWMACCBF16_VFPR16_M2 + { 9, &RISCVDescs.OperandInfo[3568] }, // Inst #3114 = PseudoVFWMACCBF16_VFPR16_M1_MASK + { 8, &RISCVDescs.OperandInfo[3560] }, // Inst #3113 = PseudoVFWMACCBF16_VFPR16_M1 + { 8, &RISCVDescs.OperandInfo[2834] }, // Inst #3112 = PseudoVFWCVT_X_F_V_MF4_MASK + { 7, &RISCVDescs.OperandInfo[2827] }, // Inst #3111 = PseudoVFWCVT_X_F_V_MF4 + { 8, &RISCVDescs.OperandInfo[2834] }, // Inst #3110 = PseudoVFWCVT_X_F_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[2827] }, // Inst #3109 = PseudoVFWCVT_X_F_V_MF2 + { 8, &RISCVDescs.OperandInfo[3506] }, // Inst #3108 = PseudoVFWCVT_X_F_V_M4_MASK + { 7, &RISCVDescs.OperandInfo[3514] }, // Inst #3107 = PseudoVFWCVT_X_F_V_M4 + { 8, &RISCVDescs.OperandInfo[3474] }, // Inst #3106 = PseudoVFWCVT_X_F_V_M2_MASK + { 7, &RISCVDescs.OperandInfo[3482] }, // Inst #3105 = PseudoVFWCVT_X_F_V_M2 + { 8, &RISCVDescs.OperandInfo[3442] }, // Inst #3104 = PseudoVFWCVT_X_F_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[3450] }, // Inst #3103 = PseudoVFWCVT_X_F_V_M1 + { 8, &RISCVDescs.OperandInfo[2834] }, // Inst #3102 = PseudoVFWCVT_XU_F_V_MF4_MASK + { 7, &RISCVDescs.OperandInfo[2827] }, // Inst #3101 = PseudoVFWCVT_XU_F_V_MF4 + { 8, &RISCVDescs.OperandInfo[2834] }, // Inst #3100 = PseudoVFWCVT_XU_F_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[2827] }, // Inst #3099 = PseudoVFWCVT_XU_F_V_MF2 + { 8, &RISCVDescs.OperandInfo[3506] }, // Inst #3098 = PseudoVFWCVT_XU_F_V_M4_MASK + { 7, &RISCVDescs.OperandInfo[3514] }, // Inst #3097 = PseudoVFWCVT_XU_F_V_M4 + { 8, &RISCVDescs.OperandInfo[3474] }, // Inst #3096 = PseudoVFWCVT_XU_F_V_M2_MASK + { 7, &RISCVDescs.OperandInfo[3482] }, // Inst #3095 = PseudoVFWCVT_XU_F_V_M2 + { 8, &RISCVDescs.OperandInfo[3442] }, // Inst #3094 = PseudoVFWCVT_XU_F_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[3450] }, // Inst #3093 = PseudoVFWCVT_XU_F_V_M1 + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #3092 = PseudoVFWCVT_RTZ_X_F_V_MF4_MASK + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #3091 = PseudoVFWCVT_RTZ_X_F_V_MF4 + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #3090 = PseudoVFWCVT_RTZ_X_F_V_MF2_MASK + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #3089 = PseudoVFWCVT_RTZ_X_F_V_MF2 + { 7, &RISCVDescs.OperandInfo[3553] }, // Inst #3088 = PseudoVFWCVT_RTZ_X_F_V_M4_MASK + { 6, &RISCVDescs.OperandInfo[3547] }, // Inst #3087 = PseudoVFWCVT_RTZ_X_F_V_M4 + { 7, &RISCVDescs.OperandInfo[3540] }, // Inst #3086 = PseudoVFWCVT_RTZ_X_F_V_M2_MASK + { 6, &RISCVDescs.OperandInfo[3534] }, // Inst #3085 = PseudoVFWCVT_RTZ_X_F_V_M2 + { 7, &RISCVDescs.OperandInfo[3527] }, // Inst #3084 = PseudoVFWCVT_RTZ_X_F_V_M1_MASK + { 6, &RISCVDescs.OperandInfo[3521] }, // Inst #3083 = PseudoVFWCVT_RTZ_X_F_V_M1 + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #3082 = PseudoVFWCVT_RTZ_XU_F_V_MF4_MASK + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #3081 = PseudoVFWCVT_RTZ_XU_F_V_MF4 + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #3080 = PseudoVFWCVT_RTZ_XU_F_V_MF2_MASK + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #3079 = PseudoVFWCVT_RTZ_XU_F_V_MF2 + { 7, &RISCVDescs.OperandInfo[3553] }, // Inst #3078 = PseudoVFWCVT_RTZ_XU_F_V_M4_MASK + { 6, &RISCVDescs.OperandInfo[3547] }, // Inst #3077 = PseudoVFWCVT_RTZ_XU_F_V_M4 + { 7, &RISCVDescs.OperandInfo[3540] }, // Inst #3076 = PseudoVFWCVT_RTZ_XU_F_V_M2_MASK + { 6, &RISCVDescs.OperandInfo[3534] }, // Inst #3075 = PseudoVFWCVT_RTZ_XU_F_V_M2 + { 7, &RISCVDescs.OperandInfo[3527] }, // Inst #3074 = PseudoVFWCVT_RTZ_XU_F_V_M1_MASK + { 6, &RISCVDescs.OperandInfo[3521] }, // Inst #3073 = PseudoVFWCVT_RTZ_XU_F_V_M1 + { 8, &RISCVDescs.OperandInfo[2834] }, // Inst #3072 = PseudoVFWCVT_RM_X_F_V_MF4_MASK + { 7, &RISCVDescs.OperandInfo[2827] }, // Inst #3071 = PseudoVFWCVT_RM_X_F_V_MF4 + { 8, &RISCVDescs.OperandInfo[2834] }, // Inst #3070 = PseudoVFWCVT_RM_X_F_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[2827] }, // Inst #3069 = PseudoVFWCVT_RM_X_F_V_MF2 + { 8, &RISCVDescs.OperandInfo[3506] }, // Inst #3068 = PseudoVFWCVT_RM_X_F_V_M4_MASK + { 7, &RISCVDescs.OperandInfo[3514] }, // Inst #3067 = PseudoVFWCVT_RM_X_F_V_M4 + { 8, &RISCVDescs.OperandInfo[3474] }, // Inst #3066 = PseudoVFWCVT_RM_X_F_V_M2_MASK + { 7, &RISCVDescs.OperandInfo[3482] }, // Inst #3065 = PseudoVFWCVT_RM_X_F_V_M2 + { 8, &RISCVDescs.OperandInfo[3442] }, // Inst #3064 = PseudoVFWCVT_RM_X_F_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[3450] }, // Inst #3063 = PseudoVFWCVT_RM_X_F_V_M1 + { 8, &RISCVDescs.OperandInfo[2834] }, // Inst #3062 = PseudoVFWCVT_RM_XU_F_V_MF4_MASK + { 7, &RISCVDescs.OperandInfo[2827] }, // Inst #3061 = PseudoVFWCVT_RM_XU_F_V_MF4 + { 8, &RISCVDescs.OperandInfo[2834] }, // Inst #3060 = PseudoVFWCVT_RM_XU_F_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[2827] }, // Inst #3059 = PseudoVFWCVT_RM_XU_F_V_MF2 + { 8, &RISCVDescs.OperandInfo[3506] }, // Inst #3058 = PseudoVFWCVT_RM_XU_F_V_M4_MASK + { 7, &RISCVDescs.OperandInfo[3514] }, // Inst #3057 = PseudoVFWCVT_RM_XU_F_V_M4 + { 8, &RISCVDescs.OperandInfo[3474] }, // Inst #3056 = PseudoVFWCVT_RM_XU_F_V_M2_MASK + { 7, &RISCVDescs.OperandInfo[3482] }, // Inst #3055 = PseudoVFWCVT_RM_XU_F_V_M2 + { 8, &RISCVDescs.OperandInfo[3442] }, // Inst #3054 = PseudoVFWCVT_RM_XU_F_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[3450] }, // Inst #3053 = PseudoVFWCVT_RM_XU_F_V_M1 + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #3052 = PseudoVFWCVT_F_X_V_MF8_MASK + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #3051 = PseudoVFWCVT_F_X_V_MF8 + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #3050 = PseudoVFWCVT_F_X_V_MF4_MASK + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #3049 = PseudoVFWCVT_F_X_V_MF4 + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #3048 = PseudoVFWCVT_F_X_V_MF2_MASK + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #3047 = PseudoVFWCVT_F_X_V_MF2 + { 7, &RISCVDescs.OperandInfo[3553] }, // Inst #3046 = PseudoVFWCVT_F_X_V_M4_MASK + { 6, &RISCVDescs.OperandInfo[3547] }, // Inst #3045 = PseudoVFWCVT_F_X_V_M4 + { 7, &RISCVDescs.OperandInfo[3540] }, // Inst #3044 = PseudoVFWCVT_F_X_V_M2_MASK + { 6, &RISCVDescs.OperandInfo[3534] }, // Inst #3043 = PseudoVFWCVT_F_X_V_M2 + { 7, &RISCVDescs.OperandInfo[3527] }, // Inst #3042 = PseudoVFWCVT_F_X_V_M1_MASK + { 6, &RISCVDescs.OperandInfo[3521] }, // Inst #3041 = PseudoVFWCVT_F_X_V_M1 + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #3040 = PseudoVFWCVT_F_XU_V_MF8_MASK + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #3039 = PseudoVFWCVT_F_XU_V_MF8 + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #3038 = PseudoVFWCVT_F_XU_V_MF4_MASK + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #3037 = PseudoVFWCVT_F_XU_V_MF4 + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #3036 = PseudoVFWCVT_F_XU_V_MF2_MASK + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #3035 = PseudoVFWCVT_F_XU_V_MF2 + { 7, &RISCVDescs.OperandInfo[3553] }, // Inst #3034 = PseudoVFWCVT_F_XU_V_M4_MASK + { 6, &RISCVDescs.OperandInfo[3547] }, // Inst #3033 = PseudoVFWCVT_F_XU_V_M4 + { 7, &RISCVDescs.OperandInfo[3540] }, // Inst #3032 = PseudoVFWCVT_F_XU_V_M2_MASK + { 6, &RISCVDescs.OperandInfo[3534] }, // Inst #3031 = PseudoVFWCVT_F_XU_V_M2 + { 7, &RISCVDescs.OperandInfo[3527] }, // Inst #3030 = PseudoVFWCVT_F_XU_V_M1_MASK + { 6, &RISCVDescs.OperandInfo[3521] }, // Inst #3029 = PseudoVFWCVT_F_XU_V_M1 + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #3028 = PseudoVFWCVT_F_F_V_MF4_MASK + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #3027 = PseudoVFWCVT_F_F_V_MF4 + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #3026 = PseudoVFWCVT_F_F_V_MF2_MASK + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #3025 = PseudoVFWCVT_F_F_V_MF2 + { 7, &RISCVDescs.OperandInfo[3553] }, // Inst #3024 = PseudoVFWCVT_F_F_V_M4_MASK + { 6, &RISCVDescs.OperandInfo[3547] }, // Inst #3023 = PseudoVFWCVT_F_F_V_M4 + { 7, &RISCVDescs.OperandInfo[3540] }, // Inst #3022 = PseudoVFWCVT_F_F_V_M2_MASK + { 6, &RISCVDescs.OperandInfo[3534] }, // Inst #3021 = PseudoVFWCVT_F_F_V_M2 + { 7, &RISCVDescs.OperandInfo[3527] }, // Inst #3020 = PseudoVFWCVT_F_F_V_M1_MASK + { 6, &RISCVDescs.OperandInfo[3521] }, // Inst #3019 = PseudoVFWCVT_F_F_V_M1 + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #3018 = PseudoVFWCVTBF16_F_F_V_MF4_MASK + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #3017 = PseudoVFWCVTBF16_F_F_V_MF4 + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #3016 = PseudoVFWCVTBF16_F_F_V_MF2_MASK + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #3015 = PseudoVFWCVTBF16_F_F_V_MF2 + { 7, &RISCVDescs.OperandInfo[3553] }, // Inst #3014 = PseudoVFWCVTBF16_F_F_V_M4_MASK + { 6, &RISCVDescs.OperandInfo[3547] }, // Inst #3013 = PseudoVFWCVTBF16_F_F_V_M4 + { 7, &RISCVDescs.OperandInfo[3540] }, // Inst #3012 = PseudoVFWCVTBF16_F_F_V_M2_MASK + { 6, &RISCVDescs.OperandInfo[3534] }, // Inst #3011 = PseudoVFWCVTBF16_F_F_V_M2 + { 7, &RISCVDescs.OperandInfo[3527] }, // Inst #3010 = PseudoVFWCVTBF16_F_F_V_M1_MASK + { 6, &RISCVDescs.OperandInfo[3521] }, // Inst #3009 = PseudoVFWCVTBF16_F_F_V_M1 + { 7, &RISCVDescs.OperandInfo[2827] }, // Inst #3008 = PseudoVFWADD_WV_MF4_TIED + { 8, &RISCVDescs.OperandInfo[2834] }, // Inst #3007 = PseudoVFWADD_WV_MF4_MASK_TIED + { 9, &RISCVDescs.OperandInfo[3416] }, // Inst #3006 = PseudoVFWADD_WV_MF4_MASK + { 8, &RISCVDescs.OperandInfo[3408] }, // Inst #3005 = PseudoVFWADD_WV_MF4 + { 7, &RISCVDescs.OperandInfo[2827] }, // Inst #3004 = PseudoVFWADD_WV_MF2_TIED + { 8, &RISCVDescs.OperandInfo[2834] }, // Inst #3003 = PseudoVFWADD_WV_MF2_MASK_TIED + { 9, &RISCVDescs.OperandInfo[3416] }, // Inst #3002 = PseudoVFWADD_WV_MF2_MASK + { 8, &RISCVDescs.OperandInfo[3408] }, // Inst #3001 = PseudoVFWADD_WV_MF2 + { 7, &RISCVDescs.OperandInfo[3514] }, // Inst #3000 = PseudoVFWADD_WV_M4_TIED + { 8, &RISCVDescs.OperandInfo[3506] }, // Inst #2999 = PseudoVFWADD_WV_M4_MASK_TIED + { 9, &RISCVDescs.OperandInfo[3497] }, // Inst #2998 = PseudoVFWADD_WV_M4_MASK + { 8, &RISCVDescs.OperandInfo[3489] }, // Inst #2997 = PseudoVFWADD_WV_M4 + { 7, &RISCVDescs.OperandInfo[3482] }, // Inst #2996 = PseudoVFWADD_WV_M2_TIED + { 8, &RISCVDescs.OperandInfo[3474] }, // Inst #2995 = PseudoVFWADD_WV_M2_MASK_TIED + { 9, &RISCVDescs.OperandInfo[3465] }, // Inst #2994 = PseudoVFWADD_WV_M2_MASK + { 8, &RISCVDescs.OperandInfo[3457] }, // Inst #2993 = PseudoVFWADD_WV_M2 + { 7, &RISCVDescs.OperandInfo[3450] }, // Inst #2992 = PseudoVFWADD_WV_M1_TIED + { 8, &RISCVDescs.OperandInfo[3442] }, // Inst #2991 = PseudoVFWADD_WV_M1_MASK_TIED + { 9, &RISCVDescs.OperandInfo[3433] }, // Inst #2990 = PseudoVFWADD_WV_M1_MASK + { 8, &RISCVDescs.OperandInfo[3425] }, // Inst #2989 = PseudoVFWADD_WV_M1 + { 9, &RISCVDescs.OperandInfo[1958] }, // Inst #2988 = PseudoVFWADD_WFPR32_MF2_MASK + { 8, &RISCVDescs.OperandInfo[1950] }, // Inst #2987 = PseudoVFWADD_WFPR32_MF2 + { 9, &RISCVDescs.OperandInfo[2009] }, // Inst #2986 = PseudoVFWADD_WFPR32_M4_MASK + { 8, &RISCVDescs.OperandInfo[2001] }, // Inst #2985 = PseudoVFWADD_WFPR32_M4 + { 9, &RISCVDescs.OperandInfo[1992] }, // Inst #2984 = PseudoVFWADD_WFPR32_M2_MASK + { 8, &RISCVDescs.OperandInfo[1984] }, // Inst #2983 = PseudoVFWADD_WFPR32_M2 + { 9, &RISCVDescs.OperandInfo[1975] }, // Inst #2982 = PseudoVFWADD_WFPR32_M1_MASK + { 8, &RISCVDescs.OperandInfo[1967] }, // Inst #2981 = PseudoVFWADD_WFPR32_M1 + { 9, &RISCVDescs.OperandInfo[1890] }, // Inst #2980 = PseudoVFWADD_WFPR16_MF4_MASK + { 8, &RISCVDescs.OperandInfo[1882] }, // Inst #2979 = PseudoVFWADD_WFPR16_MF4 + { 9, &RISCVDescs.OperandInfo[1890] }, // Inst #2978 = PseudoVFWADD_WFPR16_MF2_MASK + { 8, &RISCVDescs.OperandInfo[1882] }, // Inst #2977 = PseudoVFWADD_WFPR16_MF2 + { 9, &RISCVDescs.OperandInfo[1941] }, // Inst #2976 = PseudoVFWADD_WFPR16_M4_MASK + { 8, &RISCVDescs.OperandInfo[1933] }, // Inst #2975 = PseudoVFWADD_WFPR16_M4 + { 9, &RISCVDescs.OperandInfo[1924] }, // Inst #2974 = PseudoVFWADD_WFPR16_M2_MASK + { 8, &RISCVDescs.OperandInfo[1916] }, // Inst #2973 = PseudoVFWADD_WFPR16_M2 + { 9, &RISCVDescs.OperandInfo[1907] }, // Inst #2972 = PseudoVFWADD_WFPR16_M1_MASK + { 8, &RISCVDescs.OperandInfo[1899] }, // Inst #2971 = PseudoVFWADD_WFPR16_M1 + { 9, &RISCVDescs.OperandInfo[3416] }, // Inst #2970 = PseudoVFWADD_VV_MF4_MASK + { 8, &RISCVDescs.OperandInfo[3408] }, // Inst #2969 = PseudoVFWADD_VV_MF4 + { 9, &RISCVDescs.OperandInfo[3416] }, // Inst #2968 = PseudoVFWADD_VV_MF2_MASK + { 8, &RISCVDescs.OperandInfo[3408] }, // Inst #2967 = PseudoVFWADD_VV_MF2 + { 9, &RISCVDescs.OperandInfo[3399] }, // Inst #2966 = PseudoVFWADD_VV_M4_MASK + { 8, &RISCVDescs.OperandInfo[3391] }, // Inst #2965 = PseudoVFWADD_VV_M4 + { 9, &RISCVDescs.OperandInfo[3382] }, // Inst #2964 = PseudoVFWADD_VV_M2_MASK + { 8, &RISCVDescs.OperandInfo[3374] }, // Inst #2963 = PseudoVFWADD_VV_M2 + { 9, &RISCVDescs.OperandInfo[3365] }, // Inst #2962 = PseudoVFWADD_VV_M1_MASK + { 8, &RISCVDescs.OperandInfo[3357] }, // Inst #2961 = PseudoVFWADD_VV_M1 + { 9, &RISCVDescs.OperandInfo[2953] }, // Inst #2960 = PseudoVFWADD_VFPR32_MF2_MASK + { 8, &RISCVDescs.OperandInfo[2945] }, // Inst #2959 = PseudoVFWADD_VFPR32_MF2 + { 9, &RISCVDescs.OperandInfo[3348] }, // Inst #2958 = PseudoVFWADD_VFPR32_M4_MASK + { 8, &RISCVDescs.OperandInfo[3340] }, // Inst #2957 = PseudoVFWADD_VFPR32_M4 + { 9, &RISCVDescs.OperandInfo[3331] }, // Inst #2956 = PseudoVFWADD_VFPR32_M2_MASK + { 8, &RISCVDescs.OperandInfo[3323] }, // Inst #2955 = PseudoVFWADD_VFPR32_M2 + { 9, &RISCVDescs.OperandInfo[3314] }, // Inst #2954 = PseudoVFWADD_VFPR32_M1_MASK + { 8, &RISCVDescs.OperandInfo[3306] }, // Inst #2953 = PseudoVFWADD_VFPR32_M1 + { 9, &RISCVDescs.OperandInfo[3297] }, // Inst #2952 = PseudoVFWADD_VFPR16_MF4_MASK + { 8, &RISCVDescs.OperandInfo[3289] }, // Inst #2951 = PseudoVFWADD_VFPR16_MF4 + { 9, &RISCVDescs.OperandInfo[3297] }, // Inst #2950 = PseudoVFWADD_VFPR16_MF2_MASK + { 8, &RISCVDescs.OperandInfo[3289] }, // Inst #2949 = PseudoVFWADD_VFPR16_MF2 + { 9, &RISCVDescs.OperandInfo[3280] }, // Inst #2948 = PseudoVFWADD_VFPR16_M4_MASK + { 8, &RISCVDescs.OperandInfo[3272] }, // Inst #2947 = PseudoVFWADD_VFPR16_M4 + { 9, &RISCVDescs.OperandInfo[3263] }, // Inst #2946 = PseudoVFWADD_VFPR16_M2_MASK + { 8, &RISCVDescs.OperandInfo[3255] }, // Inst #2945 = PseudoVFWADD_VFPR16_M2 + { 9, &RISCVDescs.OperandInfo[3246] }, // Inst #2944 = PseudoVFWADD_VFPR16_M1_MASK + { 8, &RISCVDescs.OperandInfo[3238] }, // Inst #2943 = PseudoVFWADD_VFPR16_M1 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #2942 = PseudoVFSUB_VV_MF4_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #2941 = PseudoVFSUB_VV_MF4 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #2940 = PseudoVFSUB_VV_MF2_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #2939 = PseudoVFSUB_VV_MF2 + { 9, &RISCVDescs.OperandInfo[476] }, // Inst #2938 = PseudoVFSUB_VV_M8_MASK + { 8, &RISCVDescs.OperandInfo[468] }, // Inst #2937 = PseudoVFSUB_VV_M8 + { 9, &RISCVDescs.OperandInfo[459] }, // Inst #2936 = PseudoVFSUB_VV_M4_MASK + { 8, &RISCVDescs.OperandInfo[451] }, // Inst #2935 = PseudoVFSUB_VV_M4 + { 9, &RISCVDescs.OperandInfo[442] }, // Inst #2934 = PseudoVFSUB_VV_M2_MASK + { 8, &RISCVDescs.OperandInfo[434] }, // Inst #2933 = PseudoVFSUB_VV_M2 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #2932 = PseudoVFSUB_VV_M1_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #2931 = PseudoVFSUB_VV_M1 + { 9, &RISCVDescs.OperandInfo[2077] }, // Inst #2930 = PseudoVFSUB_VFPR64_M8_MASK + { 8, &RISCVDescs.OperandInfo[2069] }, // Inst #2929 = PseudoVFSUB_VFPR64_M8 + { 9, &RISCVDescs.OperandInfo[2060] }, // Inst #2928 = PseudoVFSUB_VFPR64_M4_MASK + { 8, &RISCVDescs.OperandInfo[2052] }, // Inst #2927 = PseudoVFSUB_VFPR64_M4 + { 9, &RISCVDescs.OperandInfo[2043] }, // Inst #2926 = PseudoVFSUB_VFPR64_M2_MASK + { 8, &RISCVDescs.OperandInfo[2035] }, // Inst #2925 = PseudoVFSUB_VFPR64_M2 + { 9, &RISCVDescs.OperandInfo[2026] }, // Inst #2924 = PseudoVFSUB_VFPR64_M1_MASK + { 8, &RISCVDescs.OperandInfo[2018] }, // Inst #2923 = PseudoVFSUB_VFPR64_M1 + { 9, &RISCVDescs.OperandInfo[1958] }, // Inst #2922 = PseudoVFSUB_VFPR32_MF2_MASK + { 8, &RISCVDescs.OperandInfo[1950] }, // Inst #2921 = PseudoVFSUB_VFPR32_MF2 + { 9, &RISCVDescs.OperandInfo[2009] }, // Inst #2920 = PseudoVFSUB_VFPR32_M8_MASK + { 8, &RISCVDescs.OperandInfo[2001] }, // Inst #2919 = PseudoVFSUB_VFPR32_M8 + { 9, &RISCVDescs.OperandInfo[1992] }, // Inst #2918 = PseudoVFSUB_VFPR32_M4_MASK + { 8, &RISCVDescs.OperandInfo[1984] }, // Inst #2917 = PseudoVFSUB_VFPR32_M4 + { 9, &RISCVDescs.OperandInfo[1975] }, // Inst #2916 = PseudoVFSUB_VFPR32_M2_MASK + { 8, &RISCVDescs.OperandInfo[1967] }, // Inst #2915 = PseudoVFSUB_VFPR32_M2 + { 9, &RISCVDescs.OperandInfo[1958] }, // Inst #2914 = PseudoVFSUB_VFPR32_M1_MASK + { 8, &RISCVDescs.OperandInfo[1950] }, // Inst #2913 = PseudoVFSUB_VFPR32_M1 + { 9, &RISCVDescs.OperandInfo[1890] }, // Inst #2912 = PseudoVFSUB_VFPR16_MF4_MASK + { 8, &RISCVDescs.OperandInfo[1882] }, // Inst #2911 = PseudoVFSUB_VFPR16_MF4 + { 9, &RISCVDescs.OperandInfo[1890] }, // Inst #2910 = PseudoVFSUB_VFPR16_MF2_MASK + { 8, &RISCVDescs.OperandInfo[1882] }, // Inst #2909 = PseudoVFSUB_VFPR16_MF2 + { 9, &RISCVDescs.OperandInfo[1941] }, // Inst #2908 = PseudoVFSUB_VFPR16_M8_MASK + { 8, &RISCVDescs.OperandInfo[1933] }, // Inst #2907 = PseudoVFSUB_VFPR16_M8 + { 9, &RISCVDescs.OperandInfo[1924] }, // Inst #2906 = PseudoVFSUB_VFPR16_M4_MASK + { 8, &RISCVDescs.OperandInfo[1916] }, // Inst #2905 = PseudoVFSUB_VFPR16_M4 + { 9, &RISCVDescs.OperandInfo[1907] }, // Inst #2904 = PseudoVFSUB_VFPR16_M2_MASK + { 8, &RISCVDescs.OperandInfo[1899] }, // Inst #2903 = PseudoVFSUB_VFPR16_M2 + { 9, &RISCVDescs.OperandInfo[1890] }, // Inst #2902 = PseudoVFSUB_VFPR16_M1_MASK + { 8, &RISCVDescs.OperandInfo[1882] }, // Inst #2901 = PseudoVFSUB_VFPR16_M1 + { 8, &RISCVDescs.OperandInfo[2093] }, // Inst #2900 = PseudoVFSQRT_V_MF4_E16_MASK + { 7, &RISCVDescs.OperandInfo[2086] }, // Inst #2899 = PseudoVFSQRT_V_MF4_E16 + { 8, &RISCVDescs.OperandInfo[2093] }, // Inst #2898 = PseudoVFSQRT_V_MF2_E32_MASK + { 7, &RISCVDescs.OperandInfo[2086] }, // Inst #2897 = PseudoVFSQRT_V_MF2_E32 + { 8, &RISCVDescs.OperandInfo[2093] }, // Inst #2896 = PseudoVFSQRT_V_MF2_E16_MASK + { 7, &RISCVDescs.OperandInfo[2086] }, // Inst #2895 = PseudoVFSQRT_V_MF2_E16 + { 8, &RISCVDescs.OperandInfo[2138] }, // Inst #2894 = PseudoVFSQRT_V_M8_E64_MASK + { 7, &RISCVDescs.OperandInfo[2131] }, // Inst #2893 = PseudoVFSQRT_V_M8_E64 + { 8, &RISCVDescs.OperandInfo[2138] }, // Inst #2892 = PseudoVFSQRT_V_M8_E32_MASK + { 7, &RISCVDescs.OperandInfo[2131] }, // Inst #2891 = PseudoVFSQRT_V_M8_E32 + { 8, &RISCVDescs.OperandInfo[2138] }, // Inst #2890 = PseudoVFSQRT_V_M8_E16_MASK + { 7, &RISCVDescs.OperandInfo[2131] }, // Inst #2889 = PseudoVFSQRT_V_M8_E16 + { 8, &RISCVDescs.OperandInfo[2123] }, // Inst #2888 = PseudoVFSQRT_V_M4_E64_MASK + { 7, &RISCVDescs.OperandInfo[2116] }, // Inst #2887 = PseudoVFSQRT_V_M4_E64 + { 8, &RISCVDescs.OperandInfo[2123] }, // Inst #2886 = PseudoVFSQRT_V_M4_E32_MASK + { 7, &RISCVDescs.OperandInfo[2116] }, // Inst #2885 = PseudoVFSQRT_V_M4_E32 + { 8, &RISCVDescs.OperandInfo[2123] }, // Inst #2884 = PseudoVFSQRT_V_M4_E16_MASK + { 7, &RISCVDescs.OperandInfo[2116] }, // Inst #2883 = PseudoVFSQRT_V_M4_E16 + { 8, &RISCVDescs.OperandInfo[2108] }, // Inst #2882 = PseudoVFSQRT_V_M2_E64_MASK + { 7, &RISCVDescs.OperandInfo[2101] }, // Inst #2881 = PseudoVFSQRT_V_M2_E64 + { 8, &RISCVDescs.OperandInfo[2108] }, // Inst #2880 = PseudoVFSQRT_V_M2_E32_MASK + { 7, &RISCVDescs.OperandInfo[2101] }, // Inst #2879 = PseudoVFSQRT_V_M2_E32 + { 8, &RISCVDescs.OperandInfo[2108] }, // Inst #2878 = PseudoVFSQRT_V_M2_E16_MASK + { 7, &RISCVDescs.OperandInfo[2101] }, // Inst #2877 = PseudoVFSQRT_V_M2_E16 + { 8, &RISCVDescs.OperandInfo[2093] }, // Inst #2876 = PseudoVFSQRT_V_M1_E64_MASK + { 7, &RISCVDescs.OperandInfo[2086] }, // Inst #2875 = PseudoVFSQRT_V_M1_E64 + { 8, &RISCVDescs.OperandInfo[2093] }, // Inst #2874 = PseudoVFSQRT_V_M1_E32_MASK + { 7, &RISCVDescs.OperandInfo[2086] }, // Inst #2873 = PseudoVFSQRT_V_M1_E32 + { 8, &RISCVDescs.OperandInfo[2093] }, // Inst #2872 = PseudoVFSQRT_V_M1_E16_MASK + { 7, &RISCVDescs.OperandInfo[2086] }, // Inst #2871 = PseudoVFSQRT_V_M1_E16 + { 8, &RISCVDescs.OperandInfo[3230] }, // Inst #2870 = PseudoVFSLIDE1UP_VFPR64_M8_MASK + { 7, &RISCVDescs.OperandInfo[3223] }, // Inst #2869 = PseudoVFSLIDE1UP_VFPR64_M8 + { 8, &RISCVDescs.OperandInfo[3215] }, // Inst #2868 = PseudoVFSLIDE1UP_VFPR64_M4_MASK + { 7, &RISCVDescs.OperandInfo[3208] }, // Inst #2867 = PseudoVFSLIDE1UP_VFPR64_M4 + { 8, &RISCVDescs.OperandInfo[3200] }, // Inst #2866 = PseudoVFSLIDE1UP_VFPR64_M2_MASK + { 7, &RISCVDescs.OperandInfo[3193] }, // Inst #2865 = PseudoVFSLIDE1UP_VFPR64_M2 + { 8, &RISCVDescs.OperandInfo[3185] }, // Inst #2864 = PseudoVFSLIDE1UP_VFPR64_M1_MASK + { 7, &RISCVDescs.OperandInfo[3178] }, // Inst #2863 = PseudoVFSLIDE1UP_VFPR64_M1 + { 8, &RISCVDescs.OperandInfo[3125] }, // Inst #2862 = PseudoVFSLIDE1UP_VFPR32_MF2_MASK + { 7, &RISCVDescs.OperandInfo[3118] }, // Inst #2861 = PseudoVFSLIDE1UP_VFPR32_MF2 + { 8, &RISCVDescs.OperandInfo[3170] }, // Inst #2860 = PseudoVFSLIDE1UP_VFPR32_M8_MASK + { 7, &RISCVDescs.OperandInfo[3163] }, // Inst #2859 = PseudoVFSLIDE1UP_VFPR32_M8 + { 8, &RISCVDescs.OperandInfo[3155] }, // Inst #2858 = PseudoVFSLIDE1UP_VFPR32_M4_MASK + { 7, &RISCVDescs.OperandInfo[3148] }, // Inst #2857 = PseudoVFSLIDE1UP_VFPR32_M4 + { 8, &RISCVDescs.OperandInfo[3140] }, // Inst #2856 = PseudoVFSLIDE1UP_VFPR32_M2_MASK + { 7, &RISCVDescs.OperandInfo[3133] }, // Inst #2855 = PseudoVFSLIDE1UP_VFPR32_M2 + { 8, &RISCVDescs.OperandInfo[3125] }, // Inst #2854 = PseudoVFSLIDE1UP_VFPR32_M1_MASK + { 7, &RISCVDescs.OperandInfo[3118] }, // Inst #2853 = PseudoVFSLIDE1UP_VFPR32_M1 + { 8, &RISCVDescs.OperandInfo[3065] }, // Inst #2852 = PseudoVFSLIDE1UP_VFPR16_MF4_MASK + { 7, &RISCVDescs.OperandInfo[3058] }, // Inst #2851 = PseudoVFSLIDE1UP_VFPR16_MF4 + { 8, &RISCVDescs.OperandInfo[3065] }, // Inst #2850 = PseudoVFSLIDE1UP_VFPR16_MF2_MASK + { 7, &RISCVDescs.OperandInfo[3058] }, // Inst #2849 = PseudoVFSLIDE1UP_VFPR16_MF2 + { 8, &RISCVDescs.OperandInfo[3110] }, // Inst #2848 = PseudoVFSLIDE1UP_VFPR16_M8_MASK + { 7, &RISCVDescs.OperandInfo[3103] }, // Inst #2847 = PseudoVFSLIDE1UP_VFPR16_M8 + { 8, &RISCVDescs.OperandInfo[3095] }, // Inst #2846 = PseudoVFSLIDE1UP_VFPR16_M4_MASK + { 7, &RISCVDescs.OperandInfo[3088] }, // Inst #2845 = PseudoVFSLIDE1UP_VFPR16_M4 + { 8, &RISCVDescs.OperandInfo[3080] }, // Inst #2844 = PseudoVFSLIDE1UP_VFPR16_M2_MASK + { 7, &RISCVDescs.OperandInfo[3073] }, // Inst #2843 = PseudoVFSLIDE1UP_VFPR16_M2 + { 8, &RISCVDescs.OperandInfo[3065] }, // Inst #2842 = PseudoVFSLIDE1UP_VFPR16_M1_MASK + { 7, &RISCVDescs.OperandInfo[3058] }, // Inst #2841 = PseudoVFSLIDE1UP_VFPR16_M1 + { 8, &RISCVDescs.OperandInfo[2522] }, // Inst #2840 = PseudoVFSLIDE1DOWN_VFPR64_M8_MASK + { 7, &RISCVDescs.OperandInfo[2515] }, // Inst #2839 = PseudoVFSLIDE1DOWN_VFPR64_M8 + { 8, &RISCVDescs.OperandInfo[2507] }, // Inst #2838 = PseudoVFSLIDE1DOWN_VFPR64_M4_MASK + { 7, &RISCVDescs.OperandInfo[2500] }, // Inst #2837 = PseudoVFSLIDE1DOWN_VFPR64_M4 + { 8, &RISCVDescs.OperandInfo[2492] }, // Inst #2836 = PseudoVFSLIDE1DOWN_VFPR64_M2_MASK + { 7, &RISCVDescs.OperandInfo[2485] }, // Inst #2835 = PseudoVFSLIDE1DOWN_VFPR64_M2 + { 8, &RISCVDescs.OperandInfo[2477] }, // Inst #2834 = PseudoVFSLIDE1DOWN_VFPR64_M1_MASK + { 7, &RISCVDescs.OperandInfo[2470] }, // Inst #2833 = PseudoVFSLIDE1DOWN_VFPR64_M1 + { 8, &RISCVDescs.OperandInfo[2417] }, // Inst #2832 = PseudoVFSLIDE1DOWN_VFPR32_MF2_MASK + { 7, &RISCVDescs.OperandInfo[2410] }, // Inst #2831 = PseudoVFSLIDE1DOWN_VFPR32_MF2 + { 8, &RISCVDescs.OperandInfo[2462] }, // Inst #2830 = PseudoVFSLIDE1DOWN_VFPR32_M8_MASK + { 7, &RISCVDescs.OperandInfo[2455] }, // Inst #2829 = PseudoVFSLIDE1DOWN_VFPR32_M8 + { 8, &RISCVDescs.OperandInfo[2447] }, // Inst #2828 = PseudoVFSLIDE1DOWN_VFPR32_M4_MASK + { 7, &RISCVDescs.OperandInfo[2440] }, // Inst #2827 = PseudoVFSLIDE1DOWN_VFPR32_M4 + { 8, &RISCVDescs.OperandInfo[2432] }, // Inst #2826 = PseudoVFSLIDE1DOWN_VFPR32_M2_MASK + { 7, &RISCVDescs.OperandInfo[2425] }, // Inst #2825 = PseudoVFSLIDE1DOWN_VFPR32_M2 + { 8, &RISCVDescs.OperandInfo[2417] }, // Inst #2824 = PseudoVFSLIDE1DOWN_VFPR32_M1_MASK + { 7, &RISCVDescs.OperandInfo[2410] }, // Inst #2823 = PseudoVFSLIDE1DOWN_VFPR32_M1 + { 8, &RISCVDescs.OperandInfo[2357] }, // Inst #2822 = PseudoVFSLIDE1DOWN_VFPR16_MF4_MASK + { 7, &RISCVDescs.OperandInfo[2350] }, // Inst #2821 = PseudoVFSLIDE1DOWN_VFPR16_MF4 + { 8, &RISCVDescs.OperandInfo[2357] }, // Inst #2820 = PseudoVFSLIDE1DOWN_VFPR16_MF2_MASK + { 7, &RISCVDescs.OperandInfo[2350] }, // Inst #2819 = PseudoVFSLIDE1DOWN_VFPR16_MF2 + { 8, &RISCVDescs.OperandInfo[2402] }, // Inst #2818 = PseudoVFSLIDE1DOWN_VFPR16_M8_MASK + { 7, &RISCVDescs.OperandInfo[2395] }, // Inst #2817 = PseudoVFSLIDE1DOWN_VFPR16_M8 + { 8, &RISCVDescs.OperandInfo[2387] }, // Inst #2816 = PseudoVFSLIDE1DOWN_VFPR16_M4_MASK + { 7, &RISCVDescs.OperandInfo[2380] }, // Inst #2815 = PseudoVFSLIDE1DOWN_VFPR16_M4 + { 8, &RISCVDescs.OperandInfo[2372] }, // Inst #2814 = PseudoVFSLIDE1DOWN_VFPR16_M2_MASK + { 7, &RISCVDescs.OperandInfo[2365] }, // Inst #2813 = PseudoVFSLIDE1DOWN_VFPR16_M2 + { 8, &RISCVDescs.OperandInfo[2357] }, // Inst #2812 = PseudoVFSLIDE1DOWN_VFPR16_M1_MASK + { 7, &RISCVDescs.OperandInfo[2350] }, // Inst #2811 = PseudoVFSLIDE1DOWN_VFPR16_M1 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #2810 = PseudoVFSGNJ_VV_MF4_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #2809 = PseudoVFSGNJ_VV_MF4 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #2808 = PseudoVFSGNJ_VV_MF2_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #2807 = PseudoVFSGNJ_VV_MF2 + { 8, &RISCVDescs.OperandInfo[749] }, // Inst #2806 = PseudoVFSGNJ_VV_M8_MASK + { 7, &RISCVDescs.OperandInfo[742] }, // Inst #2805 = PseudoVFSGNJ_VV_M8 + { 8, &RISCVDescs.OperandInfo[734] }, // Inst #2804 = PseudoVFSGNJ_VV_M4_MASK + { 7, &RISCVDescs.OperandInfo[727] }, // Inst #2803 = PseudoVFSGNJ_VV_M4 + { 8, &RISCVDescs.OperandInfo[719] }, // Inst #2802 = PseudoVFSGNJ_VV_M2_MASK + { 7, &RISCVDescs.OperandInfo[712] }, // Inst #2801 = PseudoVFSGNJ_VV_M2 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #2800 = PseudoVFSGNJ_VV_M1_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #2799 = PseudoVFSGNJ_VV_M1 + { 8, &RISCVDescs.OperandInfo[2522] }, // Inst #2798 = PseudoVFSGNJ_VFPR64_M8_MASK + { 7, &RISCVDescs.OperandInfo[2515] }, // Inst #2797 = PseudoVFSGNJ_VFPR64_M8 + { 8, &RISCVDescs.OperandInfo[2507] }, // Inst #2796 = PseudoVFSGNJ_VFPR64_M4_MASK + { 7, &RISCVDescs.OperandInfo[2500] }, // Inst #2795 = PseudoVFSGNJ_VFPR64_M4 + { 8, &RISCVDescs.OperandInfo[2492] }, // Inst #2794 = PseudoVFSGNJ_VFPR64_M2_MASK + { 7, &RISCVDescs.OperandInfo[2485] }, // Inst #2793 = PseudoVFSGNJ_VFPR64_M2 + { 8, &RISCVDescs.OperandInfo[2477] }, // Inst #2792 = PseudoVFSGNJ_VFPR64_M1_MASK + { 7, &RISCVDescs.OperandInfo[2470] }, // Inst #2791 = PseudoVFSGNJ_VFPR64_M1 + { 8, &RISCVDescs.OperandInfo[2417] }, // Inst #2790 = PseudoVFSGNJ_VFPR32_MF2_MASK + { 7, &RISCVDescs.OperandInfo[2410] }, // Inst #2789 = PseudoVFSGNJ_VFPR32_MF2 + { 8, &RISCVDescs.OperandInfo[2462] }, // Inst #2788 = PseudoVFSGNJ_VFPR32_M8_MASK + { 7, &RISCVDescs.OperandInfo[2455] }, // Inst #2787 = PseudoVFSGNJ_VFPR32_M8 + { 8, &RISCVDescs.OperandInfo[2447] }, // Inst #2786 = PseudoVFSGNJ_VFPR32_M4_MASK + { 7, &RISCVDescs.OperandInfo[2440] }, // Inst #2785 = PseudoVFSGNJ_VFPR32_M4 + { 8, &RISCVDescs.OperandInfo[2432] }, // Inst #2784 = PseudoVFSGNJ_VFPR32_M2_MASK + { 7, &RISCVDescs.OperandInfo[2425] }, // Inst #2783 = PseudoVFSGNJ_VFPR32_M2 + { 8, &RISCVDescs.OperandInfo[2417] }, // Inst #2782 = PseudoVFSGNJ_VFPR32_M1_MASK + { 7, &RISCVDescs.OperandInfo[2410] }, // Inst #2781 = PseudoVFSGNJ_VFPR32_M1 + { 8, &RISCVDescs.OperandInfo[2357] }, // Inst #2780 = PseudoVFSGNJ_VFPR16_MF4_MASK + { 7, &RISCVDescs.OperandInfo[2350] }, // Inst #2779 = PseudoVFSGNJ_VFPR16_MF4 + { 8, &RISCVDescs.OperandInfo[2357] }, // Inst #2778 = PseudoVFSGNJ_VFPR16_MF2_MASK + { 7, &RISCVDescs.OperandInfo[2350] }, // Inst #2777 = PseudoVFSGNJ_VFPR16_MF2 + { 8, &RISCVDescs.OperandInfo[2402] }, // Inst #2776 = PseudoVFSGNJ_VFPR16_M8_MASK + { 7, &RISCVDescs.OperandInfo[2395] }, // Inst #2775 = PseudoVFSGNJ_VFPR16_M8 + { 8, &RISCVDescs.OperandInfo[2387] }, // Inst #2774 = PseudoVFSGNJ_VFPR16_M4_MASK + { 7, &RISCVDescs.OperandInfo[2380] }, // Inst #2773 = PseudoVFSGNJ_VFPR16_M4 + { 8, &RISCVDescs.OperandInfo[2372] }, // Inst #2772 = PseudoVFSGNJ_VFPR16_M2_MASK + { 7, &RISCVDescs.OperandInfo[2365] }, // Inst #2771 = PseudoVFSGNJ_VFPR16_M2 + { 8, &RISCVDescs.OperandInfo[2357] }, // Inst #2770 = PseudoVFSGNJ_VFPR16_M1_MASK + { 7, &RISCVDescs.OperandInfo[2350] }, // Inst #2769 = PseudoVFSGNJ_VFPR16_M1 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #2768 = PseudoVFSGNJX_VV_MF4_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #2767 = PseudoVFSGNJX_VV_MF4 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #2766 = PseudoVFSGNJX_VV_MF2_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #2765 = PseudoVFSGNJX_VV_MF2 + { 8, &RISCVDescs.OperandInfo[749] }, // Inst #2764 = PseudoVFSGNJX_VV_M8_MASK + { 7, &RISCVDescs.OperandInfo[742] }, // Inst #2763 = PseudoVFSGNJX_VV_M8 + { 8, &RISCVDescs.OperandInfo[734] }, // Inst #2762 = PseudoVFSGNJX_VV_M4_MASK + { 7, &RISCVDescs.OperandInfo[727] }, // Inst #2761 = PseudoVFSGNJX_VV_M4 + { 8, &RISCVDescs.OperandInfo[719] }, // Inst #2760 = PseudoVFSGNJX_VV_M2_MASK + { 7, &RISCVDescs.OperandInfo[712] }, // Inst #2759 = PseudoVFSGNJX_VV_M2 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #2758 = PseudoVFSGNJX_VV_M1_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #2757 = PseudoVFSGNJX_VV_M1 + { 8, &RISCVDescs.OperandInfo[2522] }, // Inst #2756 = PseudoVFSGNJX_VFPR64_M8_MASK + { 7, &RISCVDescs.OperandInfo[2515] }, // Inst #2755 = PseudoVFSGNJX_VFPR64_M8 + { 8, &RISCVDescs.OperandInfo[2507] }, // Inst #2754 = PseudoVFSGNJX_VFPR64_M4_MASK + { 7, &RISCVDescs.OperandInfo[2500] }, // Inst #2753 = PseudoVFSGNJX_VFPR64_M4 + { 8, &RISCVDescs.OperandInfo[2492] }, // Inst #2752 = PseudoVFSGNJX_VFPR64_M2_MASK + { 7, &RISCVDescs.OperandInfo[2485] }, // Inst #2751 = PseudoVFSGNJX_VFPR64_M2 + { 8, &RISCVDescs.OperandInfo[2477] }, // Inst #2750 = PseudoVFSGNJX_VFPR64_M1_MASK + { 7, &RISCVDescs.OperandInfo[2470] }, // Inst #2749 = PseudoVFSGNJX_VFPR64_M1 + { 8, &RISCVDescs.OperandInfo[2417] }, // Inst #2748 = PseudoVFSGNJX_VFPR32_MF2_MASK + { 7, &RISCVDescs.OperandInfo[2410] }, // Inst #2747 = PseudoVFSGNJX_VFPR32_MF2 + { 8, &RISCVDescs.OperandInfo[2462] }, // Inst #2746 = PseudoVFSGNJX_VFPR32_M8_MASK + { 7, &RISCVDescs.OperandInfo[2455] }, // Inst #2745 = PseudoVFSGNJX_VFPR32_M8 + { 8, &RISCVDescs.OperandInfo[2447] }, // Inst #2744 = PseudoVFSGNJX_VFPR32_M4_MASK + { 7, &RISCVDescs.OperandInfo[2440] }, // Inst #2743 = PseudoVFSGNJX_VFPR32_M4 + { 8, &RISCVDescs.OperandInfo[2432] }, // Inst #2742 = PseudoVFSGNJX_VFPR32_M2_MASK + { 7, &RISCVDescs.OperandInfo[2425] }, // Inst #2741 = PseudoVFSGNJX_VFPR32_M2 + { 8, &RISCVDescs.OperandInfo[2417] }, // Inst #2740 = PseudoVFSGNJX_VFPR32_M1_MASK + { 7, &RISCVDescs.OperandInfo[2410] }, // Inst #2739 = PseudoVFSGNJX_VFPR32_M1 + { 8, &RISCVDescs.OperandInfo[2357] }, // Inst #2738 = PseudoVFSGNJX_VFPR16_MF4_MASK + { 7, &RISCVDescs.OperandInfo[2350] }, // Inst #2737 = PseudoVFSGNJX_VFPR16_MF4 + { 8, &RISCVDescs.OperandInfo[2357] }, // Inst #2736 = PseudoVFSGNJX_VFPR16_MF2_MASK + { 7, &RISCVDescs.OperandInfo[2350] }, // Inst #2735 = PseudoVFSGNJX_VFPR16_MF2 + { 8, &RISCVDescs.OperandInfo[2402] }, // Inst #2734 = PseudoVFSGNJX_VFPR16_M8_MASK + { 7, &RISCVDescs.OperandInfo[2395] }, // Inst #2733 = PseudoVFSGNJX_VFPR16_M8 + { 8, &RISCVDescs.OperandInfo[2387] }, // Inst #2732 = PseudoVFSGNJX_VFPR16_M4_MASK + { 7, &RISCVDescs.OperandInfo[2380] }, // Inst #2731 = PseudoVFSGNJX_VFPR16_M4 + { 8, &RISCVDescs.OperandInfo[2372] }, // Inst #2730 = PseudoVFSGNJX_VFPR16_M2_MASK + { 7, &RISCVDescs.OperandInfo[2365] }, // Inst #2729 = PseudoVFSGNJX_VFPR16_M2 + { 8, &RISCVDescs.OperandInfo[2357] }, // Inst #2728 = PseudoVFSGNJX_VFPR16_M1_MASK + { 7, &RISCVDescs.OperandInfo[2350] }, // Inst #2727 = PseudoVFSGNJX_VFPR16_M1 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #2726 = PseudoVFSGNJN_VV_MF4_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #2725 = PseudoVFSGNJN_VV_MF4 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #2724 = PseudoVFSGNJN_VV_MF2_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #2723 = PseudoVFSGNJN_VV_MF2 + { 8, &RISCVDescs.OperandInfo[749] }, // Inst #2722 = PseudoVFSGNJN_VV_M8_MASK + { 7, &RISCVDescs.OperandInfo[742] }, // Inst #2721 = PseudoVFSGNJN_VV_M8 + { 8, &RISCVDescs.OperandInfo[734] }, // Inst #2720 = PseudoVFSGNJN_VV_M4_MASK + { 7, &RISCVDescs.OperandInfo[727] }, // Inst #2719 = PseudoVFSGNJN_VV_M4 + { 8, &RISCVDescs.OperandInfo[719] }, // Inst #2718 = PseudoVFSGNJN_VV_M2_MASK + { 7, &RISCVDescs.OperandInfo[712] }, // Inst #2717 = PseudoVFSGNJN_VV_M2 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #2716 = PseudoVFSGNJN_VV_M1_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #2715 = PseudoVFSGNJN_VV_M1 + { 8, &RISCVDescs.OperandInfo[2522] }, // Inst #2714 = PseudoVFSGNJN_VFPR64_M8_MASK + { 7, &RISCVDescs.OperandInfo[2515] }, // Inst #2713 = PseudoVFSGNJN_VFPR64_M8 + { 8, &RISCVDescs.OperandInfo[2507] }, // Inst #2712 = PseudoVFSGNJN_VFPR64_M4_MASK + { 7, &RISCVDescs.OperandInfo[2500] }, // Inst #2711 = PseudoVFSGNJN_VFPR64_M4 + { 8, &RISCVDescs.OperandInfo[2492] }, // Inst #2710 = PseudoVFSGNJN_VFPR64_M2_MASK + { 7, &RISCVDescs.OperandInfo[2485] }, // Inst #2709 = PseudoVFSGNJN_VFPR64_M2 + { 8, &RISCVDescs.OperandInfo[2477] }, // Inst #2708 = PseudoVFSGNJN_VFPR64_M1_MASK + { 7, &RISCVDescs.OperandInfo[2470] }, // Inst #2707 = PseudoVFSGNJN_VFPR64_M1 + { 8, &RISCVDescs.OperandInfo[2417] }, // Inst #2706 = PseudoVFSGNJN_VFPR32_MF2_MASK + { 7, &RISCVDescs.OperandInfo[2410] }, // Inst #2705 = PseudoVFSGNJN_VFPR32_MF2 + { 8, &RISCVDescs.OperandInfo[2462] }, // Inst #2704 = PseudoVFSGNJN_VFPR32_M8_MASK + { 7, &RISCVDescs.OperandInfo[2455] }, // Inst #2703 = PseudoVFSGNJN_VFPR32_M8 + { 8, &RISCVDescs.OperandInfo[2447] }, // Inst #2702 = PseudoVFSGNJN_VFPR32_M4_MASK + { 7, &RISCVDescs.OperandInfo[2440] }, // Inst #2701 = PseudoVFSGNJN_VFPR32_M4 + { 8, &RISCVDescs.OperandInfo[2432] }, // Inst #2700 = PseudoVFSGNJN_VFPR32_M2_MASK + { 7, &RISCVDescs.OperandInfo[2425] }, // Inst #2699 = PseudoVFSGNJN_VFPR32_M2 + { 8, &RISCVDescs.OperandInfo[2417] }, // Inst #2698 = PseudoVFSGNJN_VFPR32_M1_MASK + { 7, &RISCVDescs.OperandInfo[2410] }, // Inst #2697 = PseudoVFSGNJN_VFPR32_M1 + { 8, &RISCVDescs.OperandInfo[2357] }, // Inst #2696 = PseudoVFSGNJN_VFPR16_MF4_MASK + { 7, &RISCVDescs.OperandInfo[2350] }, // Inst #2695 = PseudoVFSGNJN_VFPR16_MF4 + { 8, &RISCVDescs.OperandInfo[2357] }, // Inst #2694 = PseudoVFSGNJN_VFPR16_MF2_MASK + { 7, &RISCVDescs.OperandInfo[2350] }, // Inst #2693 = PseudoVFSGNJN_VFPR16_MF2 + { 8, &RISCVDescs.OperandInfo[2402] }, // Inst #2692 = PseudoVFSGNJN_VFPR16_M8_MASK + { 7, &RISCVDescs.OperandInfo[2395] }, // Inst #2691 = PseudoVFSGNJN_VFPR16_M8 + { 8, &RISCVDescs.OperandInfo[2387] }, // Inst #2690 = PseudoVFSGNJN_VFPR16_M4_MASK + { 7, &RISCVDescs.OperandInfo[2380] }, // Inst #2689 = PseudoVFSGNJN_VFPR16_M4 + { 8, &RISCVDescs.OperandInfo[2372] }, // Inst #2688 = PseudoVFSGNJN_VFPR16_M2_MASK + { 7, &RISCVDescs.OperandInfo[2365] }, // Inst #2687 = PseudoVFSGNJN_VFPR16_M2 + { 8, &RISCVDescs.OperandInfo[2357] }, // Inst #2686 = PseudoVFSGNJN_VFPR16_M1_MASK + { 7, &RISCVDescs.OperandInfo[2350] }, // Inst #2685 = PseudoVFSGNJN_VFPR16_M1 + { 9, &RISCVDescs.OperandInfo[2077] }, // Inst #2684 = PseudoVFRSUB_VFPR64_M8_MASK + { 8, &RISCVDescs.OperandInfo[2069] }, // Inst #2683 = PseudoVFRSUB_VFPR64_M8 + { 9, &RISCVDescs.OperandInfo[2060] }, // Inst #2682 = PseudoVFRSUB_VFPR64_M4_MASK + { 8, &RISCVDescs.OperandInfo[2052] }, // Inst #2681 = PseudoVFRSUB_VFPR64_M4 + { 9, &RISCVDescs.OperandInfo[2043] }, // Inst #2680 = PseudoVFRSUB_VFPR64_M2_MASK + { 8, &RISCVDescs.OperandInfo[2035] }, // Inst #2679 = PseudoVFRSUB_VFPR64_M2 + { 9, &RISCVDescs.OperandInfo[2026] }, // Inst #2678 = PseudoVFRSUB_VFPR64_M1_MASK + { 8, &RISCVDescs.OperandInfo[2018] }, // Inst #2677 = PseudoVFRSUB_VFPR64_M1 + { 9, &RISCVDescs.OperandInfo[1958] }, // Inst #2676 = PseudoVFRSUB_VFPR32_MF2_MASK + { 8, &RISCVDescs.OperandInfo[1950] }, // Inst #2675 = PseudoVFRSUB_VFPR32_MF2 + { 9, &RISCVDescs.OperandInfo[2009] }, // Inst #2674 = PseudoVFRSUB_VFPR32_M8_MASK + { 8, &RISCVDescs.OperandInfo[2001] }, // Inst #2673 = PseudoVFRSUB_VFPR32_M8 + { 9, &RISCVDescs.OperandInfo[1992] }, // Inst #2672 = PseudoVFRSUB_VFPR32_M4_MASK + { 8, &RISCVDescs.OperandInfo[1984] }, // Inst #2671 = PseudoVFRSUB_VFPR32_M4 + { 9, &RISCVDescs.OperandInfo[1975] }, // Inst #2670 = PseudoVFRSUB_VFPR32_M2_MASK + { 8, &RISCVDescs.OperandInfo[1967] }, // Inst #2669 = PseudoVFRSUB_VFPR32_M2 + { 9, &RISCVDescs.OperandInfo[1958] }, // Inst #2668 = PseudoVFRSUB_VFPR32_M1_MASK + { 8, &RISCVDescs.OperandInfo[1950] }, // Inst #2667 = PseudoVFRSUB_VFPR32_M1 + { 9, &RISCVDescs.OperandInfo[1890] }, // Inst #2666 = PseudoVFRSUB_VFPR16_MF4_MASK + { 8, &RISCVDescs.OperandInfo[1882] }, // Inst #2665 = PseudoVFRSUB_VFPR16_MF4 + { 9, &RISCVDescs.OperandInfo[1890] }, // Inst #2664 = PseudoVFRSUB_VFPR16_MF2_MASK + { 8, &RISCVDescs.OperandInfo[1882] }, // Inst #2663 = PseudoVFRSUB_VFPR16_MF2 + { 9, &RISCVDescs.OperandInfo[1941] }, // Inst #2662 = PseudoVFRSUB_VFPR16_M8_MASK + { 8, &RISCVDescs.OperandInfo[1933] }, // Inst #2661 = PseudoVFRSUB_VFPR16_M8 + { 9, &RISCVDescs.OperandInfo[1924] }, // Inst #2660 = PseudoVFRSUB_VFPR16_M4_MASK + { 8, &RISCVDescs.OperandInfo[1916] }, // Inst #2659 = PseudoVFRSUB_VFPR16_M4 + { 9, &RISCVDescs.OperandInfo[1907] }, // Inst #2658 = PseudoVFRSUB_VFPR16_M2_MASK + { 8, &RISCVDescs.OperandInfo[1899] }, // Inst #2657 = PseudoVFRSUB_VFPR16_M2 + { 9, &RISCVDescs.OperandInfo[1890] }, // Inst #2656 = PseudoVFRSUB_VFPR16_M1_MASK + { 8, &RISCVDescs.OperandInfo[1882] }, // Inst #2655 = PseudoVFRSUB_VFPR16_M1 + { 7, &RISCVDescs.OperandInfo[905] }, // Inst #2654 = PseudoVFRSQRT7_V_MF4_MASK + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #2653 = PseudoVFRSQRT7_V_MF4 + { 7, &RISCVDescs.OperandInfo[905] }, // Inst #2652 = PseudoVFRSQRT7_V_MF2_MASK + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #2651 = PseudoVFRSQRT7_V_MF2 + { 7, &RISCVDescs.OperandInfo[926] }, // Inst #2650 = PseudoVFRSQRT7_V_M8_MASK + { 6, &RISCVDescs.OperandInfo[871] }, // Inst #2649 = PseudoVFRSQRT7_V_M8 + { 7, &RISCVDescs.OperandInfo[919] }, // Inst #2648 = PseudoVFRSQRT7_V_M4_MASK + { 6, &RISCVDescs.OperandInfo[847] }, // Inst #2647 = PseudoVFRSQRT7_V_M4 + { 7, &RISCVDescs.OperandInfo[912] }, // Inst #2646 = PseudoVFRSQRT7_V_M2_MASK + { 6, &RISCVDescs.OperandInfo[829] }, // Inst #2645 = PseudoVFRSQRT7_V_M2 + { 7, &RISCVDescs.OperandInfo[905] }, // Inst #2644 = PseudoVFRSQRT7_V_M1_MASK + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #2643 = PseudoVFRSQRT7_V_M1 + { 7, &RISCVDescs.OperandInfo[905] }, // Inst #2642 = PseudoVFROUND_NOEXCEPT_V_MF4_MASK + { 7, &RISCVDescs.OperandInfo[905] }, // Inst #2641 = PseudoVFROUND_NOEXCEPT_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[926] }, // Inst #2640 = PseudoVFROUND_NOEXCEPT_V_M8_MASK + { 7, &RISCVDescs.OperandInfo[919] }, // Inst #2639 = PseudoVFROUND_NOEXCEPT_V_M4_MASK + { 7, &RISCVDescs.OperandInfo[912] }, // Inst #2638 = PseudoVFROUND_NOEXCEPT_V_M2_MASK + { 7, &RISCVDescs.OperandInfo[905] }, // Inst #2637 = PseudoVFROUND_NOEXCEPT_V_M1_MASK + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #2636 = PseudoVFREDUSUM_VS_MF4_E16_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #2635 = PseudoVFREDUSUM_VS_MF4_E16 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #2634 = PseudoVFREDUSUM_VS_MF2_E32_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #2633 = PseudoVFREDUSUM_VS_MF2_E32 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #2632 = PseudoVFREDUSUM_VS_MF2_E16_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #2631 = PseudoVFREDUSUM_VS_MF2_E16 + { 9, &RISCVDescs.OperandInfo[3049] }, // Inst #2630 = PseudoVFREDUSUM_VS_M8_E64_MASK + { 8, &RISCVDescs.OperandInfo[3041] }, // Inst #2629 = PseudoVFREDUSUM_VS_M8_E64 + { 9, &RISCVDescs.OperandInfo[3049] }, // Inst #2628 = PseudoVFREDUSUM_VS_M8_E32_MASK + { 8, &RISCVDescs.OperandInfo[3041] }, // Inst #2627 = PseudoVFREDUSUM_VS_M8_E32 + { 9, &RISCVDescs.OperandInfo[3049] }, // Inst #2626 = PseudoVFREDUSUM_VS_M8_E16_MASK + { 8, &RISCVDescs.OperandInfo[3041] }, // Inst #2625 = PseudoVFREDUSUM_VS_M8_E16 + { 9, &RISCVDescs.OperandInfo[3032] }, // Inst #2624 = PseudoVFREDUSUM_VS_M4_E64_MASK + { 8, &RISCVDescs.OperandInfo[3024] }, // Inst #2623 = PseudoVFREDUSUM_VS_M4_E64 + { 9, &RISCVDescs.OperandInfo[3032] }, // Inst #2622 = PseudoVFREDUSUM_VS_M4_E32_MASK + { 8, &RISCVDescs.OperandInfo[3024] }, // Inst #2621 = PseudoVFREDUSUM_VS_M4_E32 + { 9, &RISCVDescs.OperandInfo[3032] }, // Inst #2620 = PseudoVFREDUSUM_VS_M4_E16_MASK + { 8, &RISCVDescs.OperandInfo[3024] }, // Inst #2619 = PseudoVFREDUSUM_VS_M4_E16 + { 9, &RISCVDescs.OperandInfo[3015] }, // Inst #2618 = PseudoVFREDUSUM_VS_M2_E64_MASK + { 8, &RISCVDescs.OperandInfo[3007] }, // Inst #2617 = PseudoVFREDUSUM_VS_M2_E64 + { 9, &RISCVDescs.OperandInfo[3015] }, // Inst #2616 = PseudoVFREDUSUM_VS_M2_E32_MASK + { 8, &RISCVDescs.OperandInfo[3007] }, // Inst #2615 = PseudoVFREDUSUM_VS_M2_E32 + { 9, &RISCVDescs.OperandInfo[3015] }, // Inst #2614 = PseudoVFREDUSUM_VS_M2_E16_MASK + { 8, &RISCVDescs.OperandInfo[3007] }, // Inst #2613 = PseudoVFREDUSUM_VS_M2_E16 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #2612 = PseudoVFREDUSUM_VS_M1_E64_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #2611 = PseudoVFREDUSUM_VS_M1_E64 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #2610 = PseudoVFREDUSUM_VS_M1_E32_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #2609 = PseudoVFREDUSUM_VS_M1_E32 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #2608 = PseudoVFREDUSUM_VS_M1_E16_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #2607 = PseudoVFREDUSUM_VS_M1_E16 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #2606 = PseudoVFREDOSUM_VS_MF4_E16_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #2605 = PseudoVFREDOSUM_VS_MF4_E16 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #2604 = PseudoVFREDOSUM_VS_MF2_E32_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #2603 = PseudoVFREDOSUM_VS_MF2_E32 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #2602 = PseudoVFREDOSUM_VS_MF2_E16_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #2601 = PseudoVFREDOSUM_VS_MF2_E16 + { 9, &RISCVDescs.OperandInfo[3049] }, // Inst #2600 = PseudoVFREDOSUM_VS_M8_E64_MASK + { 8, &RISCVDescs.OperandInfo[3041] }, // Inst #2599 = PseudoVFREDOSUM_VS_M8_E64 + { 9, &RISCVDescs.OperandInfo[3049] }, // Inst #2598 = PseudoVFREDOSUM_VS_M8_E32_MASK + { 8, &RISCVDescs.OperandInfo[3041] }, // Inst #2597 = PseudoVFREDOSUM_VS_M8_E32 + { 9, &RISCVDescs.OperandInfo[3049] }, // Inst #2596 = PseudoVFREDOSUM_VS_M8_E16_MASK + { 8, &RISCVDescs.OperandInfo[3041] }, // Inst #2595 = PseudoVFREDOSUM_VS_M8_E16 + { 9, &RISCVDescs.OperandInfo[3032] }, // Inst #2594 = PseudoVFREDOSUM_VS_M4_E64_MASK + { 8, &RISCVDescs.OperandInfo[3024] }, // Inst #2593 = PseudoVFREDOSUM_VS_M4_E64 + { 9, &RISCVDescs.OperandInfo[3032] }, // Inst #2592 = PseudoVFREDOSUM_VS_M4_E32_MASK + { 8, &RISCVDescs.OperandInfo[3024] }, // Inst #2591 = PseudoVFREDOSUM_VS_M4_E32 + { 9, &RISCVDescs.OperandInfo[3032] }, // Inst #2590 = PseudoVFREDOSUM_VS_M4_E16_MASK + { 8, &RISCVDescs.OperandInfo[3024] }, // Inst #2589 = PseudoVFREDOSUM_VS_M4_E16 + { 9, &RISCVDescs.OperandInfo[3015] }, // Inst #2588 = PseudoVFREDOSUM_VS_M2_E64_MASK + { 8, &RISCVDescs.OperandInfo[3007] }, // Inst #2587 = PseudoVFREDOSUM_VS_M2_E64 + { 9, &RISCVDescs.OperandInfo[3015] }, // Inst #2586 = PseudoVFREDOSUM_VS_M2_E32_MASK + { 8, &RISCVDescs.OperandInfo[3007] }, // Inst #2585 = PseudoVFREDOSUM_VS_M2_E32 + { 9, &RISCVDescs.OperandInfo[3015] }, // Inst #2584 = PseudoVFREDOSUM_VS_M2_E16_MASK + { 8, &RISCVDescs.OperandInfo[3007] }, // Inst #2583 = PseudoVFREDOSUM_VS_M2_E16 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #2582 = PseudoVFREDOSUM_VS_M1_E64_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #2581 = PseudoVFREDOSUM_VS_M1_E64 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #2580 = PseudoVFREDOSUM_VS_M1_E32_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #2579 = PseudoVFREDOSUM_VS_M1_E32 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #2578 = PseudoVFREDOSUM_VS_M1_E16_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #2577 = PseudoVFREDOSUM_VS_M1_E16 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #2576 = PseudoVFREDMIN_VS_MF4_E16_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #2575 = PseudoVFREDMIN_VS_MF4_E16 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #2574 = PseudoVFREDMIN_VS_MF2_E32_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #2573 = PseudoVFREDMIN_VS_MF2_E32 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #2572 = PseudoVFREDMIN_VS_MF2_E16_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #2571 = PseudoVFREDMIN_VS_MF2_E16 + { 8, &RISCVDescs.OperandInfo[2999] }, // Inst #2570 = PseudoVFREDMIN_VS_M8_E64_MASK + { 7, &RISCVDescs.OperandInfo[2992] }, // Inst #2569 = PseudoVFREDMIN_VS_M8_E64 + { 8, &RISCVDescs.OperandInfo[2999] }, // Inst #2568 = PseudoVFREDMIN_VS_M8_E32_MASK + { 7, &RISCVDescs.OperandInfo[2992] }, // Inst #2567 = PseudoVFREDMIN_VS_M8_E32 + { 8, &RISCVDescs.OperandInfo[2999] }, // Inst #2566 = PseudoVFREDMIN_VS_M8_E16_MASK + { 7, &RISCVDescs.OperandInfo[2992] }, // Inst #2565 = PseudoVFREDMIN_VS_M8_E16 + { 8, &RISCVDescs.OperandInfo[2984] }, // Inst #2564 = PseudoVFREDMIN_VS_M4_E64_MASK + { 7, &RISCVDescs.OperandInfo[2977] }, // Inst #2563 = PseudoVFREDMIN_VS_M4_E64 + { 8, &RISCVDescs.OperandInfo[2984] }, // Inst #2562 = PseudoVFREDMIN_VS_M4_E32_MASK + { 7, &RISCVDescs.OperandInfo[2977] }, // Inst #2561 = PseudoVFREDMIN_VS_M4_E32 + { 8, &RISCVDescs.OperandInfo[2984] }, // Inst #2560 = PseudoVFREDMIN_VS_M4_E16_MASK + { 7, &RISCVDescs.OperandInfo[2977] }, // Inst #2559 = PseudoVFREDMIN_VS_M4_E16 + { 8, &RISCVDescs.OperandInfo[2969] }, // Inst #2558 = PseudoVFREDMIN_VS_M2_E64_MASK + { 7, &RISCVDescs.OperandInfo[2962] }, // Inst #2557 = PseudoVFREDMIN_VS_M2_E64 + { 8, &RISCVDescs.OperandInfo[2969] }, // Inst #2556 = PseudoVFREDMIN_VS_M2_E32_MASK + { 7, &RISCVDescs.OperandInfo[2962] }, // Inst #2555 = PseudoVFREDMIN_VS_M2_E32 + { 8, &RISCVDescs.OperandInfo[2969] }, // Inst #2554 = PseudoVFREDMIN_VS_M2_E16_MASK + { 7, &RISCVDescs.OperandInfo[2962] }, // Inst #2553 = PseudoVFREDMIN_VS_M2_E16 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #2552 = PseudoVFREDMIN_VS_M1_E64_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #2551 = PseudoVFREDMIN_VS_M1_E64 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #2550 = PseudoVFREDMIN_VS_M1_E32_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #2549 = PseudoVFREDMIN_VS_M1_E32 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #2548 = PseudoVFREDMIN_VS_M1_E16_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #2547 = PseudoVFREDMIN_VS_M1_E16 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #2546 = PseudoVFREDMAX_VS_MF4_E16_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #2545 = PseudoVFREDMAX_VS_MF4_E16 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #2544 = PseudoVFREDMAX_VS_MF2_E32_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #2543 = PseudoVFREDMAX_VS_MF2_E32 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #2542 = PseudoVFREDMAX_VS_MF2_E16_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #2541 = PseudoVFREDMAX_VS_MF2_E16 + { 8, &RISCVDescs.OperandInfo[2999] }, // Inst #2540 = PseudoVFREDMAX_VS_M8_E64_MASK + { 7, &RISCVDescs.OperandInfo[2992] }, // Inst #2539 = PseudoVFREDMAX_VS_M8_E64 + { 8, &RISCVDescs.OperandInfo[2999] }, // Inst #2538 = PseudoVFREDMAX_VS_M8_E32_MASK + { 7, &RISCVDescs.OperandInfo[2992] }, // Inst #2537 = PseudoVFREDMAX_VS_M8_E32 + { 8, &RISCVDescs.OperandInfo[2999] }, // Inst #2536 = PseudoVFREDMAX_VS_M8_E16_MASK + { 7, &RISCVDescs.OperandInfo[2992] }, // Inst #2535 = PseudoVFREDMAX_VS_M8_E16 + { 8, &RISCVDescs.OperandInfo[2984] }, // Inst #2534 = PseudoVFREDMAX_VS_M4_E64_MASK + { 7, &RISCVDescs.OperandInfo[2977] }, // Inst #2533 = PseudoVFREDMAX_VS_M4_E64 + { 8, &RISCVDescs.OperandInfo[2984] }, // Inst #2532 = PseudoVFREDMAX_VS_M4_E32_MASK + { 7, &RISCVDescs.OperandInfo[2977] }, // Inst #2531 = PseudoVFREDMAX_VS_M4_E32 + { 8, &RISCVDescs.OperandInfo[2984] }, // Inst #2530 = PseudoVFREDMAX_VS_M4_E16_MASK + { 7, &RISCVDescs.OperandInfo[2977] }, // Inst #2529 = PseudoVFREDMAX_VS_M4_E16 + { 8, &RISCVDescs.OperandInfo[2969] }, // Inst #2528 = PseudoVFREDMAX_VS_M2_E64_MASK + { 7, &RISCVDescs.OperandInfo[2962] }, // Inst #2527 = PseudoVFREDMAX_VS_M2_E64 + { 8, &RISCVDescs.OperandInfo[2969] }, // Inst #2526 = PseudoVFREDMAX_VS_M2_E32_MASK + { 7, &RISCVDescs.OperandInfo[2962] }, // Inst #2525 = PseudoVFREDMAX_VS_M2_E32 + { 8, &RISCVDescs.OperandInfo[2969] }, // Inst #2524 = PseudoVFREDMAX_VS_M2_E16_MASK + { 7, &RISCVDescs.OperandInfo[2962] }, // Inst #2523 = PseudoVFREDMAX_VS_M2_E16 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #2522 = PseudoVFREDMAX_VS_M1_E64_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #2521 = PseudoVFREDMAX_VS_M1_E64 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #2520 = PseudoVFREDMAX_VS_M1_E32_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #2519 = PseudoVFREDMAX_VS_M1_E32 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #2518 = PseudoVFREDMAX_VS_M1_E16_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #2517 = PseudoVFREDMAX_VS_M1_E16 + { 8, &RISCVDescs.OperandInfo[2093] }, // Inst #2516 = PseudoVFREC7_V_MF4_MASK + { 7, &RISCVDescs.OperandInfo[2086] }, // Inst #2515 = PseudoVFREC7_V_MF4 + { 8, &RISCVDescs.OperandInfo[2093] }, // Inst #2514 = PseudoVFREC7_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[2086] }, // Inst #2513 = PseudoVFREC7_V_MF2 + { 8, &RISCVDescs.OperandInfo[2138] }, // Inst #2512 = PseudoVFREC7_V_M8_MASK + { 7, &RISCVDescs.OperandInfo[2131] }, // Inst #2511 = PseudoVFREC7_V_M8 + { 8, &RISCVDescs.OperandInfo[2123] }, // Inst #2510 = PseudoVFREC7_V_M4_MASK + { 7, &RISCVDescs.OperandInfo[2116] }, // Inst #2509 = PseudoVFREC7_V_M4 + { 8, &RISCVDescs.OperandInfo[2108] }, // Inst #2508 = PseudoVFREC7_V_M2_MASK + { 7, &RISCVDescs.OperandInfo[2101] }, // Inst #2507 = PseudoVFREC7_V_M2 + { 8, &RISCVDescs.OperandInfo[2093] }, // Inst #2506 = PseudoVFREC7_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[2086] }, // Inst #2505 = PseudoVFREC7_V_M1 + { 9, &RISCVDescs.OperandInfo[2077] }, // Inst #2504 = PseudoVFRDIV_VFPR64_M8_E64_MASK + { 8, &RISCVDescs.OperandInfo[2069] }, // Inst #2503 = PseudoVFRDIV_VFPR64_M8_E64 + { 9, &RISCVDescs.OperandInfo[2060] }, // Inst #2502 = PseudoVFRDIV_VFPR64_M4_E64_MASK + { 8, &RISCVDescs.OperandInfo[2052] }, // Inst #2501 = PseudoVFRDIV_VFPR64_M4_E64 + { 9, &RISCVDescs.OperandInfo[2043] }, // Inst #2500 = PseudoVFRDIV_VFPR64_M2_E64_MASK + { 8, &RISCVDescs.OperandInfo[2035] }, // Inst #2499 = PseudoVFRDIV_VFPR64_M2_E64 + { 9, &RISCVDescs.OperandInfo[2026] }, // Inst #2498 = PseudoVFRDIV_VFPR64_M1_E64_MASK + { 8, &RISCVDescs.OperandInfo[2018] }, // Inst #2497 = PseudoVFRDIV_VFPR64_M1_E64 + { 9, &RISCVDescs.OperandInfo[1958] }, // Inst #2496 = PseudoVFRDIV_VFPR32_MF2_E32_MASK + { 8, &RISCVDescs.OperandInfo[1950] }, // Inst #2495 = PseudoVFRDIV_VFPR32_MF2_E32 + { 9, &RISCVDescs.OperandInfo[2009] }, // Inst #2494 = PseudoVFRDIV_VFPR32_M8_E32_MASK + { 8, &RISCVDescs.OperandInfo[2001] }, // Inst #2493 = PseudoVFRDIV_VFPR32_M8_E32 + { 9, &RISCVDescs.OperandInfo[1992] }, // Inst #2492 = PseudoVFRDIV_VFPR32_M4_E32_MASK + { 8, &RISCVDescs.OperandInfo[1984] }, // Inst #2491 = PseudoVFRDIV_VFPR32_M4_E32 + { 9, &RISCVDescs.OperandInfo[1975] }, // Inst #2490 = PseudoVFRDIV_VFPR32_M2_E32_MASK + { 8, &RISCVDescs.OperandInfo[1967] }, // Inst #2489 = PseudoVFRDIV_VFPR32_M2_E32 + { 9, &RISCVDescs.OperandInfo[1958] }, // Inst #2488 = PseudoVFRDIV_VFPR32_M1_E32_MASK + { 8, &RISCVDescs.OperandInfo[1950] }, // Inst #2487 = PseudoVFRDIV_VFPR32_M1_E32 + { 9, &RISCVDescs.OperandInfo[1890] }, // Inst #2486 = PseudoVFRDIV_VFPR16_MF4_E16_MASK + { 8, &RISCVDescs.OperandInfo[1882] }, // Inst #2485 = PseudoVFRDIV_VFPR16_MF4_E16 + { 9, &RISCVDescs.OperandInfo[1890] }, // Inst #2484 = PseudoVFRDIV_VFPR16_MF2_E16_MASK + { 8, &RISCVDescs.OperandInfo[1882] }, // Inst #2483 = PseudoVFRDIV_VFPR16_MF2_E16 + { 9, &RISCVDescs.OperandInfo[1941] }, // Inst #2482 = PseudoVFRDIV_VFPR16_M8_E16_MASK + { 8, &RISCVDescs.OperandInfo[1933] }, // Inst #2481 = PseudoVFRDIV_VFPR16_M8_E16 + { 9, &RISCVDescs.OperandInfo[1924] }, // Inst #2480 = PseudoVFRDIV_VFPR16_M4_E16_MASK + { 8, &RISCVDescs.OperandInfo[1916] }, // Inst #2479 = PseudoVFRDIV_VFPR16_M4_E16 + { 9, &RISCVDescs.OperandInfo[1907] }, // Inst #2478 = PseudoVFRDIV_VFPR16_M2_E16_MASK + { 8, &RISCVDescs.OperandInfo[1899] }, // Inst #2477 = PseudoVFRDIV_VFPR16_M2_E16 + { 9, &RISCVDescs.OperandInfo[1890] }, // Inst #2476 = PseudoVFRDIV_VFPR16_M1_E16_MASK + { 8, &RISCVDescs.OperandInfo[1882] }, // Inst #2475 = PseudoVFRDIV_VFPR16_M1_E16 + { 9, &RISCVDescs.OperandInfo[2953] }, // Inst #2474 = PseudoVFNRCLIP_X_F_QF_MF8_MASK + { 8, &RISCVDescs.OperandInfo[2945] }, // Inst #2473 = PseudoVFNRCLIP_X_F_QF_MF8 + { 9, &RISCVDescs.OperandInfo[2953] }, // Inst #2472 = PseudoVFNRCLIP_X_F_QF_MF4_MASK + { 8, &RISCVDescs.OperandInfo[2945] }, // Inst #2471 = PseudoVFNRCLIP_X_F_QF_MF4 + { 9, &RISCVDescs.OperandInfo[2936] }, // Inst #2470 = PseudoVFNRCLIP_X_F_QF_MF2_MASK + { 8, &RISCVDescs.OperandInfo[2928] }, // Inst #2469 = PseudoVFNRCLIP_X_F_QF_MF2 + { 9, &RISCVDescs.OperandInfo[2919] }, // Inst #2468 = PseudoVFNRCLIP_X_F_QF_M2_MASK + { 8, &RISCVDescs.OperandInfo[2911] }, // Inst #2467 = PseudoVFNRCLIP_X_F_QF_M2 + { 9, &RISCVDescs.OperandInfo[2902] }, // Inst #2466 = PseudoVFNRCLIP_X_F_QF_M1_MASK + { 8, &RISCVDescs.OperandInfo[2894] }, // Inst #2465 = PseudoVFNRCLIP_X_F_QF_M1 + { 9, &RISCVDescs.OperandInfo[2953] }, // Inst #2464 = PseudoVFNRCLIP_XU_F_QF_MF8_MASK + { 8, &RISCVDescs.OperandInfo[2945] }, // Inst #2463 = PseudoVFNRCLIP_XU_F_QF_MF8 + { 9, &RISCVDescs.OperandInfo[2953] }, // Inst #2462 = PseudoVFNRCLIP_XU_F_QF_MF4_MASK + { 8, &RISCVDescs.OperandInfo[2945] }, // Inst #2461 = PseudoVFNRCLIP_XU_F_QF_MF4 + { 9, &RISCVDescs.OperandInfo[2936] }, // Inst #2460 = PseudoVFNRCLIP_XU_F_QF_MF2_MASK + { 8, &RISCVDescs.OperandInfo[2928] }, // Inst #2459 = PseudoVFNRCLIP_XU_F_QF_MF2 + { 9, &RISCVDescs.OperandInfo[2919] }, // Inst #2458 = PseudoVFNRCLIP_XU_F_QF_M2_MASK + { 8, &RISCVDescs.OperandInfo[2911] }, // Inst #2457 = PseudoVFNRCLIP_XU_F_QF_M2 + { 9, &RISCVDescs.OperandInfo[2902] }, // Inst #2456 = PseudoVFNRCLIP_XU_F_QF_M1_MASK + { 8, &RISCVDescs.OperandInfo[2894] }, // Inst #2455 = PseudoVFNRCLIP_XU_F_QF_M1 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #2454 = PseudoVFNMSUB_VV_MF4_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #2453 = PseudoVFNMSUB_VV_MF4 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #2452 = PseudoVFNMSUB_VV_MF2_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #2451 = PseudoVFNMSUB_VV_MF2 + { 9, &RISCVDescs.OperandInfo[476] }, // Inst #2450 = PseudoVFNMSUB_VV_M8_MASK + { 8, &RISCVDescs.OperandInfo[468] }, // Inst #2449 = PseudoVFNMSUB_VV_M8 + { 9, &RISCVDescs.OperandInfo[459] }, // Inst #2448 = PseudoVFNMSUB_VV_M4_MASK + { 8, &RISCVDescs.OperandInfo[451] }, // Inst #2447 = PseudoVFNMSUB_VV_M4 + { 9, &RISCVDescs.OperandInfo[442] }, // Inst #2446 = PseudoVFNMSUB_VV_M2_MASK + { 8, &RISCVDescs.OperandInfo[434] }, // Inst #2445 = PseudoVFNMSUB_VV_M2 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #2444 = PseudoVFNMSUB_VV_M1_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #2443 = PseudoVFNMSUB_VV_M1 + { 9, &RISCVDescs.OperandInfo[2341] }, // Inst #2442 = PseudoVFNMSUB_VFPR64_M8_MASK + { 8, &RISCVDescs.OperandInfo[2333] }, // Inst #2441 = PseudoVFNMSUB_VFPR64_M8 + { 9, &RISCVDescs.OperandInfo[2324] }, // Inst #2440 = PseudoVFNMSUB_VFPR64_M4_MASK + { 8, &RISCVDescs.OperandInfo[2316] }, // Inst #2439 = PseudoVFNMSUB_VFPR64_M4 + { 9, &RISCVDescs.OperandInfo[2307] }, // Inst #2438 = PseudoVFNMSUB_VFPR64_M2_MASK + { 8, &RISCVDescs.OperandInfo[2299] }, // Inst #2437 = PseudoVFNMSUB_VFPR64_M2 + { 9, &RISCVDescs.OperandInfo[2290] }, // Inst #2436 = PseudoVFNMSUB_VFPR64_M1_MASK + { 8, &RISCVDescs.OperandInfo[2282] }, // Inst #2435 = PseudoVFNMSUB_VFPR64_M1 + { 9, &RISCVDescs.OperandInfo[2222] }, // Inst #2434 = PseudoVFNMSUB_VFPR32_MF2_MASK + { 8, &RISCVDescs.OperandInfo[2214] }, // Inst #2433 = PseudoVFNMSUB_VFPR32_MF2 + { 9, &RISCVDescs.OperandInfo[2273] }, // Inst #2432 = PseudoVFNMSUB_VFPR32_M8_MASK + { 8, &RISCVDescs.OperandInfo[2265] }, // Inst #2431 = PseudoVFNMSUB_VFPR32_M8 + { 9, &RISCVDescs.OperandInfo[2256] }, // Inst #2430 = PseudoVFNMSUB_VFPR32_M4_MASK + { 8, &RISCVDescs.OperandInfo[2248] }, // Inst #2429 = PseudoVFNMSUB_VFPR32_M4 + { 9, &RISCVDescs.OperandInfo[2239] }, // Inst #2428 = PseudoVFNMSUB_VFPR32_M2_MASK + { 8, &RISCVDescs.OperandInfo[2231] }, // Inst #2427 = PseudoVFNMSUB_VFPR32_M2 + { 9, &RISCVDescs.OperandInfo[2222] }, // Inst #2426 = PseudoVFNMSUB_VFPR32_M1_MASK + { 8, &RISCVDescs.OperandInfo[2214] }, // Inst #2425 = PseudoVFNMSUB_VFPR32_M1 + { 9, &RISCVDescs.OperandInfo[2154] }, // Inst #2424 = PseudoVFNMSUB_VFPR16_MF4_MASK + { 8, &RISCVDescs.OperandInfo[2146] }, // Inst #2423 = PseudoVFNMSUB_VFPR16_MF4 + { 9, &RISCVDescs.OperandInfo[2154] }, // Inst #2422 = PseudoVFNMSUB_VFPR16_MF2_MASK + { 8, &RISCVDescs.OperandInfo[2146] }, // Inst #2421 = PseudoVFNMSUB_VFPR16_MF2 + { 9, &RISCVDescs.OperandInfo[2205] }, // Inst #2420 = PseudoVFNMSUB_VFPR16_M8_MASK + { 8, &RISCVDescs.OperandInfo[2197] }, // Inst #2419 = PseudoVFNMSUB_VFPR16_M8 + { 9, &RISCVDescs.OperandInfo[2188] }, // Inst #2418 = PseudoVFNMSUB_VFPR16_M4_MASK + { 8, &RISCVDescs.OperandInfo[2180] }, // Inst #2417 = PseudoVFNMSUB_VFPR16_M4 + { 9, &RISCVDescs.OperandInfo[2171] }, // Inst #2416 = PseudoVFNMSUB_VFPR16_M2_MASK + { 8, &RISCVDescs.OperandInfo[2163] }, // Inst #2415 = PseudoVFNMSUB_VFPR16_M2 + { 9, &RISCVDescs.OperandInfo[2154] }, // Inst #2414 = PseudoVFNMSUB_VFPR16_M1_MASK + { 8, &RISCVDescs.OperandInfo[2146] }, // Inst #2413 = PseudoVFNMSUB_VFPR16_M1 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #2412 = PseudoVFNMSAC_VV_MF4_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #2411 = PseudoVFNMSAC_VV_MF4 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #2410 = PseudoVFNMSAC_VV_MF2_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #2409 = PseudoVFNMSAC_VV_MF2 + { 9, &RISCVDescs.OperandInfo[476] }, // Inst #2408 = PseudoVFNMSAC_VV_M8_MASK + { 8, &RISCVDescs.OperandInfo[468] }, // Inst #2407 = PseudoVFNMSAC_VV_M8 + { 9, &RISCVDescs.OperandInfo[459] }, // Inst #2406 = PseudoVFNMSAC_VV_M4_MASK + { 8, &RISCVDescs.OperandInfo[451] }, // Inst #2405 = PseudoVFNMSAC_VV_M4 + { 9, &RISCVDescs.OperandInfo[442] }, // Inst #2404 = PseudoVFNMSAC_VV_M2_MASK + { 8, &RISCVDescs.OperandInfo[434] }, // Inst #2403 = PseudoVFNMSAC_VV_M2 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #2402 = PseudoVFNMSAC_VV_M1_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #2401 = PseudoVFNMSAC_VV_M1 + { 9, &RISCVDescs.OperandInfo[2341] }, // Inst #2400 = PseudoVFNMSAC_VFPR64_M8_MASK + { 8, &RISCVDescs.OperandInfo[2333] }, // Inst #2399 = PseudoVFNMSAC_VFPR64_M8 + { 9, &RISCVDescs.OperandInfo[2324] }, // Inst #2398 = PseudoVFNMSAC_VFPR64_M4_MASK + { 8, &RISCVDescs.OperandInfo[2316] }, // Inst #2397 = PseudoVFNMSAC_VFPR64_M4 + { 9, &RISCVDescs.OperandInfo[2307] }, // Inst #2396 = PseudoVFNMSAC_VFPR64_M2_MASK + { 8, &RISCVDescs.OperandInfo[2299] }, // Inst #2395 = PseudoVFNMSAC_VFPR64_M2 + { 9, &RISCVDescs.OperandInfo[2290] }, // Inst #2394 = PseudoVFNMSAC_VFPR64_M1_MASK + { 8, &RISCVDescs.OperandInfo[2282] }, // Inst #2393 = PseudoVFNMSAC_VFPR64_M1 + { 9, &RISCVDescs.OperandInfo[2222] }, // Inst #2392 = PseudoVFNMSAC_VFPR32_MF2_MASK + { 8, &RISCVDescs.OperandInfo[2214] }, // Inst #2391 = PseudoVFNMSAC_VFPR32_MF2 + { 9, &RISCVDescs.OperandInfo[2273] }, // Inst #2390 = PseudoVFNMSAC_VFPR32_M8_MASK + { 8, &RISCVDescs.OperandInfo[2265] }, // Inst #2389 = PseudoVFNMSAC_VFPR32_M8 + { 9, &RISCVDescs.OperandInfo[2256] }, // Inst #2388 = PseudoVFNMSAC_VFPR32_M4_MASK + { 8, &RISCVDescs.OperandInfo[2248] }, // Inst #2387 = PseudoVFNMSAC_VFPR32_M4 + { 9, &RISCVDescs.OperandInfo[2239] }, // Inst #2386 = PseudoVFNMSAC_VFPR32_M2_MASK + { 8, &RISCVDescs.OperandInfo[2231] }, // Inst #2385 = PseudoVFNMSAC_VFPR32_M2 + { 9, &RISCVDescs.OperandInfo[2222] }, // Inst #2384 = PseudoVFNMSAC_VFPR32_M1_MASK + { 8, &RISCVDescs.OperandInfo[2214] }, // Inst #2383 = PseudoVFNMSAC_VFPR32_M1 + { 9, &RISCVDescs.OperandInfo[2154] }, // Inst #2382 = PseudoVFNMSAC_VFPR16_MF4_MASK + { 8, &RISCVDescs.OperandInfo[2146] }, // Inst #2381 = PseudoVFNMSAC_VFPR16_MF4 + { 9, &RISCVDescs.OperandInfo[2154] }, // Inst #2380 = PseudoVFNMSAC_VFPR16_MF2_MASK + { 8, &RISCVDescs.OperandInfo[2146] }, // Inst #2379 = PseudoVFNMSAC_VFPR16_MF2 + { 9, &RISCVDescs.OperandInfo[2205] }, // Inst #2378 = PseudoVFNMSAC_VFPR16_M8_MASK + { 8, &RISCVDescs.OperandInfo[2197] }, // Inst #2377 = PseudoVFNMSAC_VFPR16_M8 + { 9, &RISCVDescs.OperandInfo[2188] }, // Inst #2376 = PseudoVFNMSAC_VFPR16_M4_MASK + { 8, &RISCVDescs.OperandInfo[2180] }, // Inst #2375 = PseudoVFNMSAC_VFPR16_M4 + { 9, &RISCVDescs.OperandInfo[2171] }, // Inst #2374 = PseudoVFNMSAC_VFPR16_M2_MASK + { 8, &RISCVDescs.OperandInfo[2163] }, // Inst #2373 = PseudoVFNMSAC_VFPR16_M2 + { 9, &RISCVDescs.OperandInfo[2154] }, // Inst #2372 = PseudoVFNMSAC_VFPR16_M1_MASK + { 8, &RISCVDescs.OperandInfo[2146] }, // Inst #2371 = PseudoVFNMSAC_VFPR16_M1 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #2370 = PseudoVFNMADD_VV_MF4_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #2369 = PseudoVFNMADD_VV_MF4 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #2368 = PseudoVFNMADD_VV_MF2_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #2367 = PseudoVFNMADD_VV_MF2 + { 9, &RISCVDescs.OperandInfo[476] }, // Inst #2366 = PseudoVFNMADD_VV_M8_MASK + { 8, &RISCVDescs.OperandInfo[468] }, // Inst #2365 = PseudoVFNMADD_VV_M8 + { 9, &RISCVDescs.OperandInfo[459] }, // Inst #2364 = PseudoVFNMADD_VV_M4_MASK + { 8, &RISCVDescs.OperandInfo[451] }, // Inst #2363 = PseudoVFNMADD_VV_M4 + { 9, &RISCVDescs.OperandInfo[442] }, // Inst #2362 = PseudoVFNMADD_VV_M2_MASK + { 8, &RISCVDescs.OperandInfo[434] }, // Inst #2361 = PseudoVFNMADD_VV_M2 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #2360 = PseudoVFNMADD_VV_M1_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #2359 = PseudoVFNMADD_VV_M1 + { 9, &RISCVDescs.OperandInfo[2341] }, // Inst #2358 = PseudoVFNMADD_VFPR64_M8_MASK + { 8, &RISCVDescs.OperandInfo[2333] }, // Inst #2357 = PseudoVFNMADD_VFPR64_M8 + { 9, &RISCVDescs.OperandInfo[2324] }, // Inst #2356 = PseudoVFNMADD_VFPR64_M4_MASK + { 8, &RISCVDescs.OperandInfo[2316] }, // Inst #2355 = PseudoVFNMADD_VFPR64_M4 + { 9, &RISCVDescs.OperandInfo[2307] }, // Inst #2354 = PseudoVFNMADD_VFPR64_M2_MASK + { 8, &RISCVDescs.OperandInfo[2299] }, // Inst #2353 = PseudoVFNMADD_VFPR64_M2 + { 9, &RISCVDescs.OperandInfo[2290] }, // Inst #2352 = PseudoVFNMADD_VFPR64_M1_MASK + { 8, &RISCVDescs.OperandInfo[2282] }, // Inst #2351 = PseudoVFNMADD_VFPR64_M1 + { 9, &RISCVDescs.OperandInfo[2222] }, // Inst #2350 = PseudoVFNMADD_VFPR32_MF2_MASK + { 8, &RISCVDescs.OperandInfo[2214] }, // Inst #2349 = PseudoVFNMADD_VFPR32_MF2 + { 9, &RISCVDescs.OperandInfo[2273] }, // Inst #2348 = PseudoVFNMADD_VFPR32_M8_MASK + { 8, &RISCVDescs.OperandInfo[2265] }, // Inst #2347 = PseudoVFNMADD_VFPR32_M8 + { 9, &RISCVDescs.OperandInfo[2256] }, // Inst #2346 = PseudoVFNMADD_VFPR32_M4_MASK + { 8, &RISCVDescs.OperandInfo[2248] }, // Inst #2345 = PseudoVFNMADD_VFPR32_M4 + { 9, &RISCVDescs.OperandInfo[2239] }, // Inst #2344 = PseudoVFNMADD_VFPR32_M2_MASK + { 8, &RISCVDescs.OperandInfo[2231] }, // Inst #2343 = PseudoVFNMADD_VFPR32_M2 + { 9, &RISCVDescs.OperandInfo[2222] }, // Inst #2342 = PseudoVFNMADD_VFPR32_M1_MASK + { 8, &RISCVDescs.OperandInfo[2214] }, // Inst #2341 = PseudoVFNMADD_VFPR32_M1 + { 9, &RISCVDescs.OperandInfo[2154] }, // Inst #2340 = PseudoVFNMADD_VFPR16_MF4_MASK + { 8, &RISCVDescs.OperandInfo[2146] }, // Inst #2339 = PseudoVFNMADD_VFPR16_MF4 + { 9, &RISCVDescs.OperandInfo[2154] }, // Inst #2338 = PseudoVFNMADD_VFPR16_MF2_MASK + { 8, &RISCVDescs.OperandInfo[2146] }, // Inst #2337 = PseudoVFNMADD_VFPR16_MF2 + { 9, &RISCVDescs.OperandInfo[2205] }, // Inst #2336 = PseudoVFNMADD_VFPR16_M8_MASK + { 8, &RISCVDescs.OperandInfo[2197] }, // Inst #2335 = PseudoVFNMADD_VFPR16_M8 + { 9, &RISCVDescs.OperandInfo[2188] }, // Inst #2334 = PseudoVFNMADD_VFPR16_M4_MASK + { 8, &RISCVDescs.OperandInfo[2180] }, // Inst #2333 = PseudoVFNMADD_VFPR16_M4 + { 9, &RISCVDescs.OperandInfo[2171] }, // Inst #2332 = PseudoVFNMADD_VFPR16_M2_MASK + { 8, &RISCVDescs.OperandInfo[2163] }, // Inst #2331 = PseudoVFNMADD_VFPR16_M2 + { 9, &RISCVDescs.OperandInfo[2154] }, // Inst #2330 = PseudoVFNMADD_VFPR16_M1_MASK + { 8, &RISCVDescs.OperandInfo[2146] }, // Inst #2329 = PseudoVFNMADD_VFPR16_M1 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #2328 = PseudoVFNMACC_VV_MF4_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #2327 = PseudoVFNMACC_VV_MF4 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #2326 = PseudoVFNMACC_VV_MF2_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #2325 = PseudoVFNMACC_VV_MF2 + { 9, &RISCVDescs.OperandInfo[476] }, // Inst #2324 = PseudoVFNMACC_VV_M8_MASK + { 8, &RISCVDescs.OperandInfo[468] }, // Inst #2323 = PseudoVFNMACC_VV_M8 + { 9, &RISCVDescs.OperandInfo[459] }, // Inst #2322 = PseudoVFNMACC_VV_M4_MASK + { 8, &RISCVDescs.OperandInfo[451] }, // Inst #2321 = PseudoVFNMACC_VV_M4 + { 9, &RISCVDescs.OperandInfo[442] }, // Inst #2320 = PseudoVFNMACC_VV_M2_MASK + { 8, &RISCVDescs.OperandInfo[434] }, // Inst #2319 = PseudoVFNMACC_VV_M2 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #2318 = PseudoVFNMACC_VV_M1_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #2317 = PseudoVFNMACC_VV_M1 + { 9, &RISCVDescs.OperandInfo[2341] }, // Inst #2316 = PseudoVFNMACC_VFPR64_M8_MASK + { 8, &RISCVDescs.OperandInfo[2333] }, // Inst #2315 = PseudoVFNMACC_VFPR64_M8 + { 9, &RISCVDescs.OperandInfo[2324] }, // Inst #2314 = PseudoVFNMACC_VFPR64_M4_MASK + { 8, &RISCVDescs.OperandInfo[2316] }, // Inst #2313 = PseudoVFNMACC_VFPR64_M4 + { 9, &RISCVDescs.OperandInfo[2307] }, // Inst #2312 = PseudoVFNMACC_VFPR64_M2_MASK + { 8, &RISCVDescs.OperandInfo[2299] }, // Inst #2311 = PseudoVFNMACC_VFPR64_M2 + { 9, &RISCVDescs.OperandInfo[2290] }, // Inst #2310 = PseudoVFNMACC_VFPR64_M1_MASK + { 8, &RISCVDescs.OperandInfo[2282] }, // Inst #2309 = PseudoVFNMACC_VFPR64_M1 + { 9, &RISCVDescs.OperandInfo[2222] }, // Inst #2308 = PseudoVFNMACC_VFPR32_MF2_MASK + { 8, &RISCVDescs.OperandInfo[2214] }, // Inst #2307 = PseudoVFNMACC_VFPR32_MF2 + { 9, &RISCVDescs.OperandInfo[2273] }, // Inst #2306 = PseudoVFNMACC_VFPR32_M8_MASK + { 8, &RISCVDescs.OperandInfo[2265] }, // Inst #2305 = PseudoVFNMACC_VFPR32_M8 + { 9, &RISCVDescs.OperandInfo[2256] }, // Inst #2304 = PseudoVFNMACC_VFPR32_M4_MASK + { 8, &RISCVDescs.OperandInfo[2248] }, // Inst #2303 = PseudoVFNMACC_VFPR32_M4 + { 9, &RISCVDescs.OperandInfo[2239] }, // Inst #2302 = PseudoVFNMACC_VFPR32_M2_MASK + { 8, &RISCVDescs.OperandInfo[2231] }, // Inst #2301 = PseudoVFNMACC_VFPR32_M2 + { 9, &RISCVDescs.OperandInfo[2222] }, // Inst #2300 = PseudoVFNMACC_VFPR32_M1_MASK + { 8, &RISCVDescs.OperandInfo[2214] }, // Inst #2299 = PseudoVFNMACC_VFPR32_M1 + { 9, &RISCVDescs.OperandInfo[2154] }, // Inst #2298 = PseudoVFNMACC_VFPR16_MF4_MASK + { 8, &RISCVDescs.OperandInfo[2146] }, // Inst #2297 = PseudoVFNMACC_VFPR16_MF4 + { 9, &RISCVDescs.OperandInfo[2154] }, // Inst #2296 = PseudoVFNMACC_VFPR16_MF2_MASK + { 8, &RISCVDescs.OperandInfo[2146] }, // Inst #2295 = PseudoVFNMACC_VFPR16_MF2 + { 9, &RISCVDescs.OperandInfo[2205] }, // Inst #2294 = PseudoVFNMACC_VFPR16_M8_MASK + { 8, &RISCVDescs.OperandInfo[2197] }, // Inst #2293 = PseudoVFNMACC_VFPR16_M8 + { 9, &RISCVDescs.OperandInfo[2188] }, // Inst #2292 = PseudoVFNMACC_VFPR16_M4_MASK + { 8, &RISCVDescs.OperandInfo[2180] }, // Inst #2291 = PseudoVFNMACC_VFPR16_M4 + { 9, &RISCVDescs.OperandInfo[2171] }, // Inst #2290 = PseudoVFNMACC_VFPR16_M2_MASK + { 8, &RISCVDescs.OperandInfo[2163] }, // Inst #2289 = PseudoVFNMACC_VFPR16_M2 + { 9, &RISCVDescs.OperandInfo[2154] }, // Inst #2288 = PseudoVFNMACC_VFPR16_M1_MASK + { 8, &RISCVDescs.OperandInfo[2146] }, // Inst #2287 = PseudoVFNMACC_VFPR16_M1 + { 8, &RISCVDescs.OperandInfo[2834] }, // Inst #2286 = PseudoVFNCVT_X_F_W_MF8_MASK + { 7, &RISCVDescs.OperandInfo[2827] }, // Inst #2285 = PseudoVFNCVT_X_F_W_MF8 + { 8, &RISCVDescs.OperandInfo[2834] }, // Inst #2284 = PseudoVFNCVT_X_F_W_MF4_MASK + { 7, &RISCVDescs.OperandInfo[2827] }, // Inst #2283 = PseudoVFNCVT_X_F_W_MF4 + { 8, &RISCVDescs.OperandInfo[2834] }, // Inst #2282 = PseudoVFNCVT_X_F_W_MF2_MASK + { 7, &RISCVDescs.OperandInfo[2827] }, // Inst #2281 = PseudoVFNCVT_X_F_W_MF2 + { 8, &RISCVDescs.OperandInfo[2819] }, // Inst #2280 = PseudoVFNCVT_X_F_W_M4_MASK + { 7, &RISCVDescs.OperandInfo[2812] }, // Inst #2279 = PseudoVFNCVT_X_F_W_M4 + { 8, &RISCVDescs.OperandInfo[2804] }, // Inst #2278 = PseudoVFNCVT_X_F_W_M2_MASK + { 7, &RISCVDescs.OperandInfo[2797] }, // Inst #2277 = PseudoVFNCVT_X_F_W_M2 + { 8, &RISCVDescs.OperandInfo[2789] }, // Inst #2276 = PseudoVFNCVT_X_F_W_M1_MASK + { 7, &RISCVDescs.OperandInfo[2782] }, // Inst #2275 = PseudoVFNCVT_X_F_W_M1 + { 8, &RISCVDescs.OperandInfo[2834] }, // Inst #2274 = PseudoVFNCVT_XU_F_W_MF8_MASK + { 7, &RISCVDescs.OperandInfo[2827] }, // Inst #2273 = PseudoVFNCVT_XU_F_W_MF8 + { 8, &RISCVDescs.OperandInfo[2834] }, // Inst #2272 = PseudoVFNCVT_XU_F_W_MF4_MASK + { 7, &RISCVDescs.OperandInfo[2827] }, // Inst #2271 = PseudoVFNCVT_XU_F_W_MF4 + { 8, &RISCVDescs.OperandInfo[2834] }, // Inst #2270 = PseudoVFNCVT_XU_F_W_MF2_MASK + { 7, &RISCVDescs.OperandInfo[2827] }, // Inst #2269 = PseudoVFNCVT_XU_F_W_MF2 + { 8, &RISCVDescs.OperandInfo[2819] }, // Inst #2268 = PseudoVFNCVT_XU_F_W_M4_MASK + { 7, &RISCVDescs.OperandInfo[2812] }, // Inst #2267 = PseudoVFNCVT_XU_F_W_M4 + { 8, &RISCVDescs.OperandInfo[2804] }, // Inst #2266 = PseudoVFNCVT_XU_F_W_M2_MASK + { 7, &RISCVDescs.OperandInfo[2797] }, // Inst #2265 = PseudoVFNCVT_XU_F_W_M2 + { 8, &RISCVDescs.OperandInfo[2789] }, // Inst #2264 = PseudoVFNCVT_XU_F_W_M1_MASK + { 7, &RISCVDescs.OperandInfo[2782] }, // Inst #2263 = PseudoVFNCVT_XU_F_W_M1 + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #2262 = PseudoVFNCVT_RTZ_X_F_W_MF8_MASK + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #2261 = PseudoVFNCVT_RTZ_X_F_W_MF8 + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #2260 = PseudoVFNCVT_RTZ_X_F_W_MF4_MASK + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #2259 = PseudoVFNCVT_RTZ_X_F_W_MF4 + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #2258 = PseudoVFNCVT_RTZ_X_F_W_MF2_MASK + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #2257 = PseudoVFNCVT_RTZ_X_F_W_MF2 + { 7, &RISCVDescs.OperandInfo[2874] }, // Inst #2256 = PseudoVFNCVT_RTZ_X_F_W_M4_MASK + { 6, &RISCVDescs.OperandInfo[2868] }, // Inst #2255 = PseudoVFNCVT_RTZ_X_F_W_M4 + { 7, &RISCVDescs.OperandInfo[2861] }, // Inst #2254 = PseudoVFNCVT_RTZ_X_F_W_M2_MASK + { 6, &RISCVDescs.OperandInfo[2855] }, // Inst #2253 = PseudoVFNCVT_RTZ_X_F_W_M2 + { 7, &RISCVDescs.OperandInfo[2848] }, // Inst #2252 = PseudoVFNCVT_RTZ_X_F_W_M1_MASK + { 6, &RISCVDescs.OperandInfo[2842] }, // Inst #2251 = PseudoVFNCVT_RTZ_X_F_W_M1 + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #2250 = PseudoVFNCVT_RTZ_XU_F_W_MF8_MASK + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #2249 = PseudoVFNCVT_RTZ_XU_F_W_MF8 + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #2248 = PseudoVFNCVT_RTZ_XU_F_W_MF4_MASK + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #2247 = PseudoVFNCVT_RTZ_XU_F_W_MF4 + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #2246 = PseudoVFNCVT_RTZ_XU_F_W_MF2_MASK + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #2245 = PseudoVFNCVT_RTZ_XU_F_W_MF2 + { 7, &RISCVDescs.OperandInfo[2874] }, // Inst #2244 = PseudoVFNCVT_RTZ_XU_F_W_M4_MASK + { 6, &RISCVDescs.OperandInfo[2868] }, // Inst #2243 = PseudoVFNCVT_RTZ_XU_F_W_M4 + { 7, &RISCVDescs.OperandInfo[2861] }, // Inst #2242 = PseudoVFNCVT_RTZ_XU_F_W_M2_MASK + { 6, &RISCVDescs.OperandInfo[2855] }, // Inst #2241 = PseudoVFNCVT_RTZ_XU_F_W_M2 + { 7, &RISCVDescs.OperandInfo[2848] }, // Inst #2240 = PseudoVFNCVT_RTZ_XU_F_W_M1_MASK + { 6, &RISCVDescs.OperandInfo[2842] }, // Inst #2239 = PseudoVFNCVT_RTZ_XU_F_W_M1 + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #2238 = PseudoVFNCVT_ROD_F_F_W_MF4_MASK + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #2237 = PseudoVFNCVT_ROD_F_F_W_MF4 + { 7, &RISCVDescs.OperandInfo[2887] }, // Inst #2236 = PseudoVFNCVT_ROD_F_F_W_MF2_MASK + { 6, &RISCVDescs.OperandInfo[2881] }, // Inst #2235 = PseudoVFNCVT_ROD_F_F_W_MF2 + { 7, &RISCVDescs.OperandInfo[2874] }, // Inst #2234 = PseudoVFNCVT_ROD_F_F_W_M4_MASK + { 6, &RISCVDescs.OperandInfo[2868] }, // Inst #2233 = PseudoVFNCVT_ROD_F_F_W_M4 + { 7, &RISCVDescs.OperandInfo[2861] }, // Inst #2232 = PseudoVFNCVT_ROD_F_F_W_M2_MASK + { 6, &RISCVDescs.OperandInfo[2855] }, // Inst #2231 = PseudoVFNCVT_ROD_F_F_W_M2 + { 7, &RISCVDescs.OperandInfo[2848] }, // Inst #2230 = PseudoVFNCVT_ROD_F_F_W_M1_MASK + { 6, &RISCVDescs.OperandInfo[2842] }, // Inst #2229 = PseudoVFNCVT_ROD_F_F_W_M1 + { 8, &RISCVDescs.OperandInfo[2834] }, // Inst #2228 = PseudoVFNCVT_RM_X_F_W_MF8_MASK + { 7, &RISCVDescs.OperandInfo[2827] }, // Inst #2227 = PseudoVFNCVT_RM_X_F_W_MF8 + { 8, &RISCVDescs.OperandInfo[2834] }, // Inst #2226 = PseudoVFNCVT_RM_X_F_W_MF4_MASK + { 7, &RISCVDescs.OperandInfo[2827] }, // Inst #2225 = PseudoVFNCVT_RM_X_F_W_MF4 + { 8, &RISCVDescs.OperandInfo[2834] }, // Inst #2224 = PseudoVFNCVT_RM_X_F_W_MF2_MASK + { 7, &RISCVDescs.OperandInfo[2827] }, // Inst #2223 = PseudoVFNCVT_RM_X_F_W_MF2 + { 8, &RISCVDescs.OperandInfo[2819] }, // Inst #2222 = PseudoVFNCVT_RM_X_F_W_M4_MASK + { 7, &RISCVDescs.OperandInfo[2812] }, // Inst #2221 = PseudoVFNCVT_RM_X_F_W_M4 + { 8, &RISCVDescs.OperandInfo[2804] }, // Inst #2220 = PseudoVFNCVT_RM_X_F_W_M2_MASK + { 7, &RISCVDescs.OperandInfo[2797] }, // Inst #2219 = PseudoVFNCVT_RM_X_F_W_M2 + { 8, &RISCVDescs.OperandInfo[2789] }, // Inst #2218 = PseudoVFNCVT_RM_X_F_W_M1_MASK + { 7, &RISCVDescs.OperandInfo[2782] }, // Inst #2217 = PseudoVFNCVT_RM_X_F_W_M1 + { 8, &RISCVDescs.OperandInfo[2834] }, // Inst #2216 = PseudoVFNCVT_RM_XU_F_W_MF8_MASK + { 7, &RISCVDescs.OperandInfo[2827] }, // Inst #2215 = PseudoVFNCVT_RM_XU_F_W_MF8 + { 8, &RISCVDescs.OperandInfo[2834] }, // Inst #2214 = PseudoVFNCVT_RM_XU_F_W_MF4_MASK + { 7, &RISCVDescs.OperandInfo[2827] }, // Inst #2213 = PseudoVFNCVT_RM_XU_F_W_MF4 + { 8, &RISCVDescs.OperandInfo[2834] }, // Inst #2212 = PseudoVFNCVT_RM_XU_F_W_MF2_MASK + { 7, &RISCVDescs.OperandInfo[2827] }, // Inst #2211 = PseudoVFNCVT_RM_XU_F_W_MF2 + { 8, &RISCVDescs.OperandInfo[2819] }, // Inst #2210 = PseudoVFNCVT_RM_XU_F_W_M4_MASK + { 7, &RISCVDescs.OperandInfo[2812] }, // Inst #2209 = PseudoVFNCVT_RM_XU_F_W_M4 + { 8, &RISCVDescs.OperandInfo[2804] }, // Inst #2208 = PseudoVFNCVT_RM_XU_F_W_M2_MASK + { 7, &RISCVDescs.OperandInfo[2797] }, // Inst #2207 = PseudoVFNCVT_RM_XU_F_W_M2 + { 8, &RISCVDescs.OperandInfo[2789] }, // Inst #2206 = PseudoVFNCVT_RM_XU_F_W_M1_MASK + { 7, &RISCVDescs.OperandInfo[2782] }, // Inst #2205 = PseudoVFNCVT_RM_XU_F_W_M1 + { 8, &RISCVDescs.OperandInfo[2834] }, // Inst #2204 = PseudoVFNCVT_RM_F_X_W_MF4_MASK + { 7, &RISCVDescs.OperandInfo[2827] }, // Inst #2203 = PseudoVFNCVT_RM_F_X_W_MF4 + { 8, &RISCVDescs.OperandInfo[2834] }, // Inst #2202 = PseudoVFNCVT_RM_F_X_W_MF2_MASK + { 7, &RISCVDescs.OperandInfo[2827] }, // Inst #2201 = PseudoVFNCVT_RM_F_X_W_MF2 + { 8, &RISCVDescs.OperandInfo[2819] }, // Inst #2200 = PseudoVFNCVT_RM_F_X_W_M4_MASK + { 7, &RISCVDescs.OperandInfo[2812] }, // Inst #2199 = PseudoVFNCVT_RM_F_X_W_M4 + { 8, &RISCVDescs.OperandInfo[2804] }, // Inst #2198 = PseudoVFNCVT_RM_F_X_W_M2_MASK + { 7, &RISCVDescs.OperandInfo[2797] }, // Inst #2197 = PseudoVFNCVT_RM_F_X_W_M2 + { 8, &RISCVDescs.OperandInfo[2789] }, // Inst #2196 = PseudoVFNCVT_RM_F_X_W_M1_MASK + { 7, &RISCVDescs.OperandInfo[2782] }, // Inst #2195 = PseudoVFNCVT_RM_F_X_W_M1 + { 8, &RISCVDescs.OperandInfo[2834] }, // Inst #2194 = PseudoVFNCVT_RM_F_XU_W_MF4_MASK + { 7, &RISCVDescs.OperandInfo[2827] }, // Inst #2193 = PseudoVFNCVT_RM_F_XU_W_MF4 + { 8, &RISCVDescs.OperandInfo[2834] }, // Inst #2192 = PseudoVFNCVT_RM_F_XU_W_MF2_MASK + { 7, &RISCVDescs.OperandInfo[2827] }, // Inst #2191 = PseudoVFNCVT_RM_F_XU_W_MF2 + { 8, &RISCVDescs.OperandInfo[2819] }, // Inst #2190 = PseudoVFNCVT_RM_F_XU_W_M4_MASK + { 7, &RISCVDescs.OperandInfo[2812] }, // Inst #2189 = PseudoVFNCVT_RM_F_XU_W_M4 + { 8, &RISCVDescs.OperandInfo[2804] }, // Inst #2188 = PseudoVFNCVT_RM_F_XU_W_M2_MASK + { 7, &RISCVDescs.OperandInfo[2797] }, // Inst #2187 = PseudoVFNCVT_RM_F_XU_W_M2 + { 8, &RISCVDescs.OperandInfo[2789] }, // Inst #2186 = PseudoVFNCVT_RM_F_XU_W_M1_MASK + { 7, &RISCVDescs.OperandInfo[2782] }, // Inst #2185 = PseudoVFNCVT_RM_F_XU_W_M1 + { 8, &RISCVDescs.OperandInfo[2834] }, // Inst #2184 = PseudoVFNCVT_F_X_W_MF4_MASK + { 7, &RISCVDescs.OperandInfo[2827] }, // Inst #2183 = PseudoVFNCVT_F_X_W_MF4 + { 8, &RISCVDescs.OperandInfo[2834] }, // Inst #2182 = PseudoVFNCVT_F_X_W_MF2_MASK + { 7, &RISCVDescs.OperandInfo[2827] }, // Inst #2181 = PseudoVFNCVT_F_X_W_MF2 + { 8, &RISCVDescs.OperandInfo[2819] }, // Inst #2180 = PseudoVFNCVT_F_X_W_M4_MASK + { 7, &RISCVDescs.OperandInfo[2812] }, // Inst #2179 = PseudoVFNCVT_F_X_W_M4 + { 8, &RISCVDescs.OperandInfo[2804] }, // Inst #2178 = PseudoVFNCVT_F_X_W_M2_MASK + { 7, &RISCVDescs.OperandInfo[2797] }, // Inst #2177 = PseudoVFNCVT_F_X_W_M2 + { 8, &RISCVDescs.OperandInfo[2789] }, // Inst #2176 = PseudoVFNCVT_F_X_W_M1_MASK + { 7, &RISCVDescs.OperandInfo[2782] }, // Inst #2175 = PseudoVFNCVT_F_X_W_M1 + { 8, &RISCVDescs.OperandInfo[2834] }, // Inst #2174 = PseudoVFNCVT_F_XU_W_MF4_MASK + { 7, &RISCVDescs.OperandInfo[2827] }, // Inst #2173 = PseudoVFNCVT_F_XU_W_MF4 + { 8, &RISCVDescs.OperandInfo[2834] }, // Inst #2172 = PseudoVFNCVT_F_XU_W_MF2_MASK + { 7, &RISCVDescs.OperandInfo[2827] }, // Inst #2171 = PseudoVFNCVT_F_XU_W_MF2 + { 8, &RISCVDescs.OperandInfo[2819] }, // Inst #2170 = PseudoVFNCVT_F_XU_W_M4_MASK + { 7, &RISCVDescs.OperandInfo[2812] }, // Inst #2169 = PseudoVFNCVT_F_XU_W_M4 + { 8, &RISCVDescs.OperandInfo[2804] }, // Inst #2168 = PseudoVFNCVT_F_XU_W_M2_MASK + { 7, &RISCVDescs.OperandInfo[2797] }, // Inst #2167 = PseudoVFNCVT_F_XU_W_M2 + { 8, &RISCVDescs.OperandInfo[2789] }, // Inst #2166 = PseudoVFNCVT_F_XU_W_M1_MASK + { 7, &RISCVDescs.OperandInfo[2782] }, // Inst #2165 = PseudoVFNCVT_F_XU_W_M1 + { 8, &RISCVDescs.OperandInfo[2834] }, // Inst #2164 = PseudoVFNCVT_F_F_W_MF4_MASK + { 7, &RISCVDescs.OperandInfo[2827] }, // Inst #2163 = PseudoVFNCVT_F_F_W_MF4 + { 8, &RISCVDescs.OperandInfo[2834] }, // Inst #2162 = PseudoVFNCVT_F_F_W_MF2_MASK + { 7, &RISCVDescs.OperandInfo[2827] }, // Inst #2161 = PseudoVFNCVT_F_F_W_MF2 + { 8, &RISCVDescs.OperandInfo[2819] }, // Inst #2160 = PseudoVFNCVT_F_F_W_M4_MASK + { 7, &RISCVDescs.OperandInfo[2812] }, // Inst #2159 = PseudoVFNCVT_F_F_W_M4 + { 8, &RISCVDescs.OperandInfo[2804] }, // Inst #2158 = PseudoVFNCVT_F_F_W_M2_MASK + { 7, &RISCVDescs.OperandInfo[2797] }, // Inst #2157 = PseudoVFNCVT_F_F_W_M2 + { 8, &RISCVDescs.OperandInfo[2789] }, // Inst #2156 = PseudoVFNCVT_F_F_W_M1_MASK + { 7, &RISCVDescs.OperandInfo[2782] }, // Inst #2155 = PseudoVFNCVT_F_F_W_M1 + { 8, &RISCVDescs.OperandInfo[2834] }, // Inst #2154 = PseudoVFNCVTBF16_F_F_W_MF4_MASK + { 7, &RISCVDescs.OperandInfo[2827] }, // Inst #2153 = PseudoVFNCVTBF16_F_F_W_MF4 + { 8, &RISCVDescs.OperandInfo[2834] }, // Inst #2152 = PseudoVFNCVTBF16_F_F_W_MF2_MASK + { 7, &RISCVDescs.OperandInfo[2827] }, // Inst #2151 = PseudoVFNCVTBF16_F_F_W_MF2 + { 8, &RISCVDescs.OperandInfo[2819] }, // Inst #2150 = PseudoVFNCVTBF16_F_F_W_M4_MASK + { 7, &RISCVDescs.OperandInfo[2812] }, // Inst #2149 = PseudoVFNCVTBF16_F_F_W_M4 + { 8, &RISCVDescs.OperandInfo[2804] }, // Inst #2148 = PseudoVFNCVTBF16_F_F_W_M2_MASK + { 7, &RISCVDescs.OperandInfo[2797] }, // Inst #2147 = PseudoVFNCVTBF16_F_F_W_M2 + { 8, &RISCVDescs.OperandInfo[2789] }, // Inst #2146 = PseudoVFNCVTBF16_F_F_W_M1_MASK + { 7, &RISCVDescs.OperandInfo[2782] }, // Inst #2145 = PseudoVFNCVTBF16_F_F_W_M1 + { 6, &RISCVDescs.OperandInfo[2776] }, // Inst #2144 = PseudoVFMV_V_FPR64_M8 + { 6, &RISCVDescs.OperandInfo[2770] }, // Inst #2143 = PseudoVFMV_V_FPR64_M4 + { 6, &RISCVDescs.OperandInfo[2764] }, // Inst #2142 = PseudoVFMV_V_FPR64_M2 + { 6, &RISCVDescs.OperandInfo[2758] }, // Inst #2141 = PseudoVFMV_V_FPR64_M1 + { 6, &RISCVDescs.OperandInfo[2734] }, // Inst #2140 = PseudoVFMV_V_FPR32_MF2 + { 6, &RISCVDescs.OperandInfo[2752] }, // Inst #2139 = PseudoVFMV_V_FPR32_M8 + { 6, &RISCVDescs.OperandInfo[2746] }, // Inst #2138 = PseudoVFMV_V_FPR32_M4 + { 6, &RISCVDescs.OperandInfo[2740] }, // Inst #2137 = PseudoVFMV_V_FPR32_M2 + { 6, &RISCVDescs.OperandInfo[2734] }, // Inst #2136 = PseudoVFMV_V_FPR32_M1 + { 6, &RISCVDescs.OperandInfo[2710] }, // Inst #2135 = PseudoVFMV_V_FPR16_MF4 + { 6, &RISCVDescs.OperandInfo[2710] }, // Inst #2134 = PseudoVFMV_V_FPR16_MF2 + { 6, &RISCVDescs.OperandInfo[2728] }, // Inst #2133 = PseudoVFMV_V_FPR16_M8 + { 6, &RISCVDescs.OperandInfo[2722] }, // Inst #2132 = PseudoVFMV_V_FPR16_M4 + { 6, &RISCVDescs.OperandInfo[2716] }, // Inst #2131 = PseudoVFMV_V_FPR16_M2 + { 6, &RISCVDescs.OperandInfo[2710] }, // Inst #2130 = PseudoVFMV_V_FPR16_M1 + { 5, &RISCVDescs.OperandInfo[2705] }, // Inst #2129 = PseudoVFMV_S_FPR64_M8 + { 5, &RISCVDescs.OperandInfo[2700] }, // Inst #2128 = PseudoVFMV_S_FPR64_M4 + { 5, &RISCVDescs.OperandInfo[2695] }, // Inst #2127 = PseudoVFMV_S_FPR64_M2 + { 5, &RISCVDescs.OperandInfo[2690] }, // Inst #2126 = PseudoVFMV_S_FPR64_M1 + { 5, &RISCVDescs.OperandInfo[2670] }, // Inst #2125 = PseudoVFMV_S_FPR32_MF2 + { 5, &RISCVDescs.OperandInfo[2685] }, // Inst #2124 = PseudoVFMV_S_FPR32_M8 + { 5, &RISCVDescs.OperandInfo[2680] }, // Inst #2123 = PseudoVFMV_S_FPR32_M4 + { 5, &RISCVDescs.OperandInfo[2675] }, // Inst #2122 = PseudoVFMV_S_FPR32_M2 + { 5, &RISCVDescs.OperandInfo[2670] }, // Inst #2121 = PseudoVFMV_S_FPR32_M1 + { 5, &RISCVDescs.OperandInfo[2650] }, // Inst #2120 = PseudoVFMV_S_FPR16_MF4 + { 5, &RISCVDescs.OperandInfo[2650] }, // Inst #2119 = PseudoVFMV_S_FPR16_MF2 + { 5, &RISCVDescs.OperandInfo[2665] }, // Inst #2118 = PseudoVFMV_S_FPR16_M8 + { 5, &RISCVDescs.OperandInfo[2660] }, // Inst #2117 = PseudoVFMV_S_FPR16_M4 + { 5, &RISCVDescs.OperandInfo[2655] }, // Inst #2116 = PseudoVFMV_S_FPR16_M2 + { 5, &RISCVDescs.OperandInfo[2650] }, // Inst #2115 = PseudoVFMV_S_FPR16_M1 + { 3, &RISCVDescs.OperandInfo[2647] }, // Inst #2114 = PseudoVFMV_FPR64_S_M8 + { 3, &RISCVDescs.OperandInfo[2644] }, // Inst #2113 = PseudoVFMV_FPR64_S_M4 + { 3, &RISCVDescs.OperandInfo[2641] }, // Inst #2112 = PseudoVFMV_FPR64_S_M2 + { 3, &RISCVDescs.OperandInfo[2638] }, // Inst #2111 = PseudoVFMV_FPR64_S_M1 + { 3, &RISCVDescs.OperandInfo[2626] }, // Inst #2110 = PseudoVFMV_FPR32_S_MF2 + { 3, &RISCVDescs.OperandInfo[2635] }, // Inst #2109 = PseudoVFMV_FPR32_S_M8 + { 3, &RISCVDescs.OperandInfo[2632] }, // Inst #2108 = PseudoVFMV_FPR32_S_M4 + { 3, &RISCVDescs.OperandInfo[2629] }, // Inst #2107 = PseudoVFMV_FPR32_S_M2 + { 3, &RISCVDescs.OperandInfo[2626] }, // Inst #2106 = PseudoVFMV_FPR32_S_M1 + { 3, &RISCVDescs.OperandInfo[2614] }, // Inst #2105 = PseudoVFMV_FPR16_S_MF4 + { 3, &RISCVDescs.OperandInfo[2614] }, // Inst #2104 = PseudoVFMV_FPR16_S_MF2 + { 3, &RISCVDescs.OperandInfo[2623] }, // Inst #2103 = PseudoVFMV_FPR16_S_M8 + { 3, &RISCVDescs.OperandInfo[2620] }, // Inst #2102 = PseudoVFMV_FPR16_S_M4 + { 3, &RISCVDescs.OperandInfo[2617] }, // Inst #2101 = PseudoVFMV_FPR16_S_M2 + { 3, &RISCVDescs.OperandInfo[2614] }, // Inst #2100 = PseudoVFMV_FPR16_S_M1 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #2099 = PseudoVFMUL_VV_MF4_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #2098 = PseudoVFMUL_VV_MF4 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #2097 = PseudoVFMUL_VV_MF2_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #2096 = PseudoVFMUL_VV_MF2 + { 9, &RISCVDescs.OperandInfo[476] }, // Inst #2095 = PseudoVFMUL_VV_M8_MASK + { 8, &RISCVDescs.OperandInfo[468] }, // Inst #2094 = PseudoVFMUL_VV_M8 + { 9, &RISCVDescs.OperandInfo[459] }, // Inst #2093 = PseudoVFMUL_VV_M4_MASK + { 8, &RISCVDescs.OperandInfo[451] }, // Inst #2092 = PseudoVFMUL_VV_M4 + { 9, &RISCVDescs.OperandInfo[442] }, // Inst #2091 = PseudoVFMUL_VV_M2_MASK + { 8, &RISCVDescs.OperandInfo[434] }, // Inst #2090 = PseudoVFMUL_VV_M2 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #2089 = PseudoVFMUL_VV_M1_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #2088 = PseudoVFMUL_VV_M1 + { 9, &RISCVDescs.OperandInfo[2077] }, // Inst #2087 = PseudoVFMUL_VFPR64_M8_MASK + { 8, &RISCVDescs.OperandInfo[2069] }, // Inst #2086 = PseudoVFMUL_VFPR64_M8 + { 9, &RISCVDescs.OperandInfo[2060] }, // Inst #2085 = PseudoVFMUL_VFPR64_M4_MASK + { 8, &RISCVDescs.OperandInfo[2052] }, // Inst #2084 = PseudoVFMUL_VFPR64_M4 + { 9, &RISCVDescs.OperandInfo[2043] }, // Inst #2083 = PseudoVFMUL_VFPR64_M2_MASK + { 8, &RISCVDescs.OperandInfo[2035] }, // Inst #2082 = PseudoVFMUL_VFPR64_M2 + { 9, &RISCVDescs.OperandInfo[2026] }, // Inst #2081 = PseudoVFMUL_VFPR64_M1_MASK + { 8, &RISCVDescs.OperandInfo[2018] }, // Inst #2080 = PseudoVFMUL_VFPR64_M1 + { 9, &RISCVDescs.OperandInfo[1958] }, // Inst #2079 = PseudoVFMUL_VFPR32_MF2_MASK + { 8, &RISCVDescs.OperandInfo[1950] }, // Inst #2078 = PseudoVFMUL_VFPR32_MF2 + { 9, &RISCVDescs.OperandInfo[2009] }, // Inst #2077 = PseudoVFMUL_VFPR32_M8_MASK + { 8, &RISCVDescs.OperandInfo[2001] }, // Inst #2076 = PseudoVFMUL_VFPR32_M8 + { 9, &RISCVDescs.OperandInfo[1992] }, // Inst #2075 = PseudoVFMUL_VFPR32_M4_MASK + { 8, &RISCVDescs.OperandInfo[1984] }, // Inst #2074 = PseudoVFMUL_VFPR32_M4 + { 9, &RISCVDescs.OperandInfo[1975] }, // Inst #2073 = PseudoVFMUL_VFPR32_M2_MASK + { 8, &RISCVDescs.OperandInfo[1967] }, // Inst #2072 = PseudoVFMUL_VFPR32_M2 + { 9, &RISCVDescs.OperandInfo[1958] }, // Inst #2071 = PseudoVFMUL_VFPR32_M1_MASK + { 8, &RISCVDescs.OperandInfo[1950] }, // Inst #2070 = PseudoVFMUL_VFPR32_M1 + { 9, &RISCVDescs.OperandInfo[1890] }, // Inst #2069 = PseudoVFMUL_VFPR16_MF4_MASK + { 8, &RISCVDescs.OperandInfo[1882] }, // Inst #2068 = PseudoVFMUL_VFPR16_MF4 + { 9, &RISCVDescs.OperandInfo[1890] }, // Inst #2067 = PseudoVFMUL_VFPR16_MF2_MASK + { 8, &RISCVDescs.OperandInfo[1882] }, // Inst #2066 = PseudoVFMUL_VFPR16_MF2 + { 9, &RISCVDescs.OperandInfo[1941] }, // Inst #2065 = PseudoVFMUL_VFPR16_M8_MASK + { 8, &RISCVDescs.OperandInfo[1933] }, // Inst #2064 = PseudoVFMUL_VFPR16_M8 + { 9, &RISCVDescs.OperandInfo[1924] }, // Inst #2063 = PseudoVFMUL_VFPR16_M4_MASK + { 8, &RISCVDescs.OperandInfo[1916] }, // Inst #2062 = PseudoVFMUL_VFPR16_M4 + { 9, &RISCVDescs.OperandInfo[1907] }, // Inst #2061 = PseudoVFMUL_VFPR16_M2_MASK + { 8, &RISCVDescs.OperandInfo[1899] }, // Inst #2060 = PseudoVFMUL_VFPR16_M2 + { 9, &RISCVDescs.OperandInfo[1890] }, // Inst #2059 = PseudoVFMUL_VFPR16_M1_MASK + { 8, &RISCVDescs.OperandInfo[1882] }, // Inst #2058 = PseudoVFMUL_VFPR16_M1 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #2057 = PseudoVFMSUB_VV_MF4_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #2056 = PseudoVFMSUB_VV_MF4 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #2055 = PseudoVFMSUB_VV_MF2_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #2054 = PseudoVFMSUB_VV_MF2 + { 9, &RISCVDescs.OperandInfo[476] }, // Inst #2053 = PseudoVFMSUB_VV_M8_MASK + { 8, &RISCVDescs.OperandInfo[468] }, // Inst #2052 = PseudoVFMSUB_VV_M8 + { 9, &RISCVDescs.OperandInfo[459] }, // Inst #2051 = PseudoVFMSUB_VV_M4_MASK + { 8, &RISCVDescs.OperandInfo[451] }, // Inst #2050 = PseudoVFMSUB_VV_M4 + { 9, &RISCVDescs.OperandInfo[442] }, // Inst #2049 = PseudoVFMSUB_VV_M2_MASK + { 8, &RISCVDescs.OperandInfo[434] }, // Inst #2048 = PseudoVFMSUB_VV_M2 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #2047 = PseudoVFMSUB_VV_M1_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #2046 = PseudoVFMSUB_VV_M1 + { 9, &RISCVDescs.OperandInfo[2341] }, // Inst #2045 = PseudoVFMSUB_VFPR64_M8_MASK + { 8, &RISCVDescs.OperandInfo[2333] }, // Inst #2044 = PseudoVFMSUB_VFPR64_M8 + { 9, &RISCVDescs.OperandInfo[2324] }, // Inst #2043 = PseudoVFMSUB_VFPR64_M4_MASK + { 8, &RISCVDescs.OperandInfo[2316] }, // Inst #2042 = PseudoVFMSUB_VFPR64_M4 + { 9, &RISCVDescs.OperandInfo[2307] }, // Inst #2041 = PseudoVFMSUB_VFPR64_M2_MASK + { 8, &RISCVDescs.OperandInfo[2299] }, // Inst #2040 = PseudoVFMSUB_VFPR64_M2 + { 9, &RISCVDescs.OperandInfo[2290] }, // Inst #2039 = PseudoVFMSUB_VFPR64_M1_MASK + { 8, &RISCVDescs.OperandInfo[2282] }, // Inst #2038 = PseudoVFMSUB_VFPR64_M1 + { 9, &RISCVDescs.OperandInfo[2222] }, // Inst #2037 = PseudoVFMSUB_VFPR32_MF2_MASK + { 8, &RISCVDescs.OperandInfo[2214] }, // Inst #2036 = PseudoVFMSUB_VFPR32_MF2 + { 9, &RISCVDescs.OperandInfo[2273] }, // Inst #2035 = PseudoVFMSUB_VFPR32_M8_MASK + { 8, &RISCVDescs.OperandInfo[2265] }, // Inst #2034 = PseudoVFMSUB_VFPR32_M8 + { 9, &RISCVDescs.OperandInfo[2256] }, // Inst #2033 = PseudoVFMSUB_VFPR32_M4_MASK + { 8, &RISCVDescs.OperandInfo[2248] }, // Inst #2032 = PseudoVFMSUB_VFPR32_M4 + { 9, &RISCVDescs.OperandInfo[2239] }, // Inst #2031 = PseudoVFMSUB_VFPR32_M2_MASK + { 8, &RISCVDescs.OperandInfo[2231] }, // Inst #2030 = PseudoVFMSUB_VFPR32_M2 + { 9, &RISCVDescs.OperandInfo[2222] }, // Inst #2029 = PseudoVFMSUB_VFPR32_M1_MASK + { 8, &RISCVDescs.OperandInfo[2214] }, // Inst #2028 = PseudoVFMSUB_VFPR32_M1 + { 9, &RISCVDescs.OperandInfo[2154] }, // Inst #2027 = PseudoVFMSUB_VFPR16_MF4_MASK + { 8, &RISCVDescs.OperandInfo[2146] }, // Inst #2026 = PseudoVFMSUB_VFPR16_MF4 + { 9, &RISCVDescs.OperandInfo[2154] }, // Inst #2025 = PseudoVFMSUB_VFPR16_MF2_MASK + { 8, &RISCVDescs.OperandInfo[2146] }, // Inst #2024 = PseudoVFMSUB_VFPR16_MF2 + { 9, &RISCVDescs.OperandInfo[2205] }, // Inst #2023 = PseudoVFMSUB_VFPR16_M8_MASK + { 8, &RISCVDescs.OperandInfo[2197] }, // Inst #2022 = PseudoVFMSUB_VFPR16_M8 + { 9, &RISCVDescs.OperandInfo[2188] }, // Inst #2021 = PseudoVFMSUB_VFPR16_M4_MASK + { 8, &RISCVDescs.OperandInfo[2180] }, // Inst #2020 = PseudoVFMSUB_VFPR16_M4 + { 9, &RISCVDescs.OperandInfo[2171] }, // Inst #2019 = PseudoVFMSUB_VFPR16_M2_MASK + { 8, &RISCVDescs.OperandInfo[2163] }, // Inst #2018 = PseudoVFMSUB_VFPR16_M2 + { 9, &RISCVDescs.OperandInfo[2154] }, // Inst #2017 = PseudoVFMSUB_VFPR16_M1_MASK + { 8, &RISCVDescs.OperandInfo[2146] }, // Inst #2016 = PseudoVFMSUB_VFPR16_M1 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #2015 = PseudoVFMSAC_VV_MF4_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #2014 = PseudoVFMSAC_VV_MF4 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #2013 = PseudoVFMSAC_VV_MF2_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #2012 = PseudoVFMSAC_VV_MF2 + { 9, &RISCVDescs.OperandInfo[476] }, // Inst #2011 = PseudoVFMSAC_VV_M8_MASK + { 8, &RISCVDescs.OperandInfo[468] }, // Inst #2010 = PseudoVFMSAC_VV_M8 + { 9, &RISCVDescs.OperandInfo[459] }, // Inst #2009 = PseudoVFMSAC_VV_M4_MASK + { 8, &RISCVDescs.OperandInfo[451] }, // Inst #2008 = PseudoVFMSAC_VV_M4 + { 9, &RISCVDescs.OperandInfo[442] }, // Inst #2007 = PseudoVFMSAC_VV_M2_MASK + { 8, &RISCVDescs.OperandInfo[434] }, // Inst #2006 = PseudoVFMSAC_VV_M2 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #2005 = PseudoVFMSAC_VV_M1_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #2004 = PseudoVFMSAC_VV_M1 + { 9, &RISCVDescs.OperandInfo[2341] }, // Inst #2003 = PseudoVFMSAC_VFPR64_M8_MASK + { 8, &RISCVDescs.OperandInfo[2333] }, // Inst #2002 = PseudoVFMSAC_VFPR64_M8 + { 9, &RISCVDescs.OperandInfo[2324] }, // Inst #2001 = PseudoVFMSAC_VFPR64_M4_MASK + { 8, &RISCVDescs.OperandInfo[2316] }, // Inst #2000 = PseudoVFMSAC_VFPR64_M4 + { 9, &RISCVDescs.OperandInfo[2307] }, // Inst #1999 = PseudoVFMSAC_VFPR64_M2_MASK + { 8, &RISCVDescs.OperandInfo[2299] }, // Inst #1998 = PseudoVFMSAC_VFPR64_M2 + { 9, &RISCVDescs.OperandInfo[2290] }, // Inst #1997 = PseudoVFMSAC_VFPR64_M1_MASK + { 8, &RISCVDescs.OperandInfo[2282] }, // Inst #1996 = PseudoVFMSAC_VFPR64_M1 + { 9, &RISCVDescs.OperandInfo[2222] }, // Inst #1995 = PseudoVFMSAC_VFPR32_MF2_MASK + { 8, &RISCVDescs.OperandInfo[2214] }, // Inst #1994 = PseudoVFMSAC_VFPR32_MF2 + { 9, &RISCVDescs.OperandInfo[2273] }, // Inst #1993 = PseudoVFMSAC_VFPR32_M8_MASK + { 8, &RISCVDescs.OperandInfo[2265] }, // Inst #1992 = PseudoVFMSAC_VFPR32_M8 + { 9, &RISCVDescs.OperandInfo[2256] }, // Inst #1991 = PseudoVFMSAC_VFPR32_M4_MASK + { 8, &RISCVDescs.OperandInfo[2248] }, // Inst #1990 = PseudoVFMSAC_VFPR32_M4 + { 9, &RISCVDescs.OperandInfo[2239] }, // Inst #1989 = PseudoVFMSAC_VFPR32_M2_MASK + { 8, &RISCVDescs.OperandInfo[2231] }, // Inst #1988 = PseudoVFMSAC_VFPR32_M2 + { 9, &RISCVDescs.OperandInfo[2222] }, // Inst #1987 = PseudoVFMSAC_VFPR32_M1_MASK + { 8, &RISCVDescs.OperandInfo[2214] }, // Inst #1986 = PseudoVFMSAC_VFPR32_M1 + { 9, &RISCVDescs.OperandInfo[2154] }, // Inst #1985 = PseudoVFMSAC_VFPR16_MF4_MASK + { 8, &RISCVDescs.OperandInfo[2146] }, // Inst #1984 = PseudoVFMSAC_VFPR16_MF4 + { 9, &RISCVDescs.OperandInfo[2154] }, // Inst #1983 = PseudoVFMSAC_VFPR16_MF2_MASK + { 8, &RISCVDescs.OperandInfo[2146] }, // Inst #1982 = PseudoVFMSAC_VFPR16_MF2 + { 9, &RISCVDescs.OperandInfo[2205] }, // Inst #1981 = PseudoVFMSAC_VFPR16_M8_MASK + { 8, &RISCVDescs.OperandInfo[2197] }, // Inst #1980 = PseudoVFMSAC_VFPR16_M8 + { 9, &RISCVDescs.OperandInfo[2188] }, // Inst #1979 = PseudoVFMSAC_VFPR16_M4_MASK + { 8, &RISCVDescs.OperandInfo[2180] }, // Inst #1978 = PseudoVFMSAC_VFPR16_M4 + { 9, &RISCVDescs.OperandInfo[2171] }, // Inst #1977 = PseudoVFMSAC_VFPR16_M2_MASK + { 8, &RISCVDescs.OperandInfo[2163] }, // Inst #1976 = PseudoVFMSAC_VFPR16_M2 + { 9, &RISCVDescs.OperandInfo[2154] }, // Inst #1975 = PseudoVFMSAC_VFPR16_M1_MASK + { 8, &RISCVDescs.OperandInfo[2146] }, // Inst #1974 = PseudoVFMSAC_VFPR16_M1 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #1973 = PseudoVFMIN_VV_MF4_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #1972 = PseudoVFMIN_VV_MF4 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #1971 = PseudoVFMIN_VV_MF2_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #1970 = PseudoVFMIN_VV_MF2 + { 8, &RISCVDescs.OperandInfo[749] }, // Inst #1969 = PseudoVFMIN_VV_M8_MASK + { 7, &RISCVDescs.OperandInfo[742] }, // Inst #1968 = PseudoVFMIN_VV_M8 + { 8, &RISCVDescs.OperandInfo[734] }, // Inst #1967 = PseudoVFMIN_VV_M4_MASK + { 7, &RISCVDescs.OperandInfo[727] }, // Inst #1966 = PseudoVFMIN_VV_M4 + { 8, &RISCVDescs.OperandInfo[719] }, // Inst #1965 = PseudoVFMIN_VV_M2_MASK + { 7, &RISCVDescs.OperandInfo[712] }, // Inst #1964 = PseudoVFMIN_VV_M2 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #1963 = PseudoVFMIN_VV_M1_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #1962 = PseudoVFMIN_VV_M1 + { 8, &RISCVDescs.OperandInfo[2522] }, // Inst #1961 = PseudoVFMIN_VFPR64_M8_MASK + { 7, &RISCVDescs.OperandInfo[2515] }, // Inst #1960 = PseudoVFMIN_VFPR64_M8 + { 8, &RISCVDescs.OperandInfo[2507] }, // Inst #1959 = PseudoVFMIN_VFPR64_M4_MASK + { 7, &RISCVDescs.OperandInfo[2500] }, // Inst #1958 = PseudoVFMIN_VFPR64_M4 + { 8, &RISCVDescs.OperandInfo[2492] }, // Inst #1957 = PseudoVFMIN_VFPR64_M2_MASK + { 7, &RISCVDescs.OperandInfo[2485] }, // Inst #1956 = PseudoVFMIN_VFPR64_M2 + { 8, &RISCVDescs.OperandInfo[2477] }, // Inst #1955 = PseudoVFMIN_VFPR64_M1_MASK + { 7, &RISCVDescs.OperandInfo[2470] }, // Inst #1954 = PseudoVFMIN_VFPR64_M1 + { 8, &RISCVDescs.OperandInfo[2417] }, // Inst #1953 = PseudoVFMIN_VFPR32_MF2_MASK + { 7, &RISCVDescs.OperandInfo[2410] }, // Inst #1952 = PseudoVFMIN_VFPR32_MF2 + { 8, &RISCVDescs.OperandInfo[2462] }, // Inst #1951 = PseudoVFMIN_VFPR32_M8_MASK + { 7, &RISCVDescs.OperandInfo[2455] }, // Inst #1950 = PseudoVFMIN_VFPR32_M8 + { 8, &RISCVDescs.OperandInfo[2447] }, // Inst #1949 = PseudoVFMIN_VFPR32_M4_MASK + { 7, &RISCVDescs.OperandInfo[2440] }, // Inst #1948 = PseudoVFMIN_VFPR32_M4 + { 8, &RISCVDescs.OperandInfo[2432] }, // Inst #1947 = PseudoVFMIN_VFPR32_M2_MASK + { 7, &RISCVDescs.OperandInfo[2425] }, // Inst #1946 = PseudoVFMIN_VFPR32_M2 + { 8, &RISCVDescs.OperandInfo[2417] }, // Inst #1945 = PseudoVFMIN_VFPR32_M1_MASK + { 7, &RISCVDescs.OperandInfo[2410] }, // Inst #1944 = PseudoVFMIN_VFPR32_M1 + { 8, &RISCVDescs.OperandInfo[2357] }, // Inst #1943 = PseudoVFMIN_VFPR16_MF4_MASK + { 7, &RISCVDescs.OperandInfo[2350] }, // Inst #1942 = PseudoVFMIN_VFPR16_MF4 + { 8, &RISCVDescs.OperandInfo[2357] }, // Inst #1941 = PseudoVFMIN_VFPR16_MF2_MASK + { 7, &RISCVDescs.OperandInfo[2350] }, // Inst #1940 = PseudoVFMIN_VFPR16_MF2 + { 8, &RISCVDescs.OperandInfo[2402] }, // Inst #1939 = PseudoVFMIN_VFPR16_M8_MASK + { 7, &RISCVDescs.OperandInfo[2395] }, // Inst #1938 = PseudoVFMIN_VFPR16_M8 + { 8, &RISCVDescs.OperandInfo[2387] }, // Inst #1937 = PseudoVFMIN_VFPR16_M4_MASK + { 7, &RISCVDescs.OperandInfo[2380] }, // Inst #1936 = PseudoVFMIN_VFPR16_M4 + { 8, &RISCVDescs.OperandInfo[2372] }, // Inst #1935 = PseudoVFMIN_VFPR16_M2_MASK + { 7, &RISCVDescs.OperandInfo[2365] }, // Inst #1934 = PseudoVFMIN_VFPR16_M2 + { 8, &RISCVDescs.OperandInfo[2357] }, // Inst #1933 = PseudoVFMIN_VFPR16_M1_MASK + { 7, &RISCVDescs.OperandInfo[2350] }, // Inst #1932 = PseudoVFMIN_VFPR16_M1 + { 7, &RISCVDescs.OperandInfo[2607] }, // Inst #1931 = PseudoVFMERGE_VFPR64M_M8 + { 7, &RISCVDescs.OperandInfo[2600] }, // Inst #1930 = PseudoVFMERGE_VFPR64M_M4 + { 7, &RISCVDescs.OperandInfo[2593] }, // Inst #1929 = PseudoVFMERGE_VFPR64M_M2 + { 7, &RISCVDescs.OperandInfo[2586] }, // Inst #1928 = PseudoVFMERGE_VFPR64M_M1 + { 7, &RISCVDescs.OperandInfo[2558] }, // Inst #1927 = PseudoVFMERGE_VFPR32M_MF2 + { 7, &RISCVDescs.OperandInfo[2579] }, // Inst #1926 = PseudoVFMERGE_VFPR32M_M8 + { 7, &RISCVDescs.OperandInfo[2572] }, // Inst #1925 = PseudoVFMERGE_VFPR32M_M4 + { 7, &RISCVDescs.OperandInfo[2565] }, // Inst #1924 = PseudoVFMERGE_VFPR32M_M2 + { 7, &RISCVDescs.OperandInfo[2558] }, // Inst #1923 = PseudoVFMERGE_VFPR32M_M1 + { 7, &RISCVDescs.OperandInfo[2530] }, // Inst #1922 = PseudoVFMERGE_VFPR16M_MF4 + { 7, &RISCVDescs.OperandInfo[2530] }, // Inst #1921 = PseudoVFMERGE_VFPR16M_MF2 + { 7, &RISCVDescs.OperandInfo[2551] }, // Inst #1920 = PseudoVFMERGE_VFPR16M_M8 + { 7, &RISCVDescs.OperandInfo[2544] }, // Inst #1919 = PseudoVFMERGE_VFPR16M_M4 + { 7, &RISCVDescs.OperandInfo[2537] }, // Inst #1918 = PseudoVFMERGE_VFPR16M_M2 + { 7, &RISCVDescs.OperandInfo[2530] }, // Inst #1917 = PseudoVFMERGE_VFPR16M_M1 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #1916 = PseudoVFMAX_VV_MF4_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #1915 = PseudoVFMAX_VV_MF4 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #1914 = PseudoVFMAX_VV_MF2_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #1913 = PseudoVFMAX_VV_MF2 + { 8, &RISCVDescs.OperandInfo[749] }, // Inst #1912 = PseudoVFMAX_VV_M8_MASK + { 7, &RISCVDescs.OperandInfo[742] }, // Inst #1911 = PseudoVFMAX_VV_M8 + { 8, &RISCVDescs.OperandInfo[734] }, // Inst #1910 = PseudoVFMAX_VV_M4_MASK + { 7, &RISCVDescs.OperandInfo[727] }, // Inst #1909 = PseudoVFMAX_VV_M4 + { 8, &RISCVDescs.OperandInfo[719] }, // Inst #1908 = PseudoVFMAX_VV_M2_MASK + { 7, &RISCVDescs.OperandInfo[712] }, // Inst #1907 = PseudoVFMAX_VV_M2 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #1906 = PseudoVFMAX_VV_M1_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #1905 = PseudoVFMAX_VV_M1 + { 8, &RISCVDescs.OperandInfo[2522] }, // Inst #1904 = PseudoVFMAX_VFPR64_M8_MASK + { 7, &RISCVDescs.OperandInfo[2515] }, // Inst #1903 = PseudoVFMAX_VFPR64_M8 + { 8, &RISCVDescs.OperandInfo[2507] }, // Inst #1902 = PseudoVFMAX_VFPR64_M4_MASK + { 7, &RISCVDescs.OperandInfo[2500] }, // Inst #1901 = PseudoVFMAX_VFPR64_M4 + { 8, &RISCVDescs.OperandInfo[2492] }, // Inst #1900 = PseudoVFMAX_VFPR64_M2_MASK + { 7, &RISCVDescs.OperandInfo[2485] }, // Inst #1899 = PseudoVFMAX_VFPR64_M2 + { 8, &RISCVDescs.OperandInfo[2477] }, // Inst #1898 = PseudoVFMAX_VFPR64_M1_MASK + { 7, &RISCVDescs.OperandInfo[2470] }, // Inst #1897 = PseudoVFMAX_VFPR64_M1 + { 8, &RISCVDescs.OperandInfo[2417] }, // Inst #1896 = PseudoVFMAX_VFPR32_MF2_MASK + { 7, &RISCVDescs.OperandInfo[2410] }, // Inst #1895 = PseudoVFMAX_VFPR32_MF2 + { 8, &RISCVDescs.OperandInfo[2462] }, // Inst #1894 = PseudoVFMAX_VFPR32_M8_MASK + { 7, &RISCVDescs.OperandInfo[2455] }, // Inst #1893 = PseudoVFMAX_VFPR32_M8 + { 8, &RISCVDescs.OperandInfo[2447] }, // Inst #1892 = PseudoVFMAX_VFPR32_M4_MASK + { 7, &RISCVDescs.OperandInfo[2440] }, // Inst #1891 = PseudoVFMAX_VFPR32_M4 + { 8, &RISCVDescs.OperandInfo[2432] }, // Inst #1890 = PseudoVFMAX_VFPR32_M2_MASK + { 7, &RISCVDescs.OperandInfo[2425] }, // Inst #1889 = PseudoVFMAX_VFPR32_M2 + { 8, &RISCVDescs.OperandInfo[2417] }, // Inst #1888 = PseudoVFMAX_VFPR32_M1_MASK + { 7, &RISCVDescs.OperandInfo[2410] }, // Inst #1887 = PseudoVFMAX_VFPR32_M1 + { 8, &RISCVDescs.OperandInfo[2357] }, // Inst #1886 = PseudoVFMAX_VFPR16_MF4_MASK + { 7, &RISCVDescs.OperandInfo[2350] }, // Inst #1885 = PseudoVFMAX_VFPR16_MF4 + { 8, &RISCVDescs.OperandInfo[2357] }, // Inst #1884 = PseudoVFMAX_VFPR16_MF2_MASK + { 7, &RISCVDescs.OperandInfo[2350] }, // Inst #1883 = PseudoVFMAX_VFPR16_MF2 + { 8, &RISCVDescs.OperandInfo[2402] }, // Inst #1882 = PseudoVFMAX_VFPR16_M8_MASK + { 7, &RISCVDescs.OperandInfo[2395] }, // Inst #1881 = PseudoVFMAX_VFPR16_M8 + { 8, &RISCVDescs.OperandInfo[2387] }, // Inst #1880 = PseudoVFMAX_VFPR16_M4_MASK + { 7, &RISCVDescs.OperandInfo[2380] }, // Inst #1879 = PseudoVFMAX_VFPR16_M4 + { 8, &RISCVDescs.OperandInfo[2372] }, // Inst #1878 = PseudoVFMAX_VFPR16_M2_MASK + { 7, &RISCVDescs.OperandInfo[2365] }, // Inst #1877 = PseudoVFMAX_VFPR16_M2 + { 8, &RISCVDescs.OperandInfo[2357] }, // Inst #1876 = PseudoVFMAX_VFPR16_M1_MASK + { 7, &RISCVDescs.OperandInfo[2350] }, // Inst #1875 = PseudoVFMAX_VFPR16_M1 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #1874 = PseudoVFMADD_VV_MF4_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #1873 = PseudoVFMADD_VV_MF4 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #1872 = PseudoVFMADD_VV_MF2_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #1871 = PseudoVFMADD_VV_MF2 + { 9, &RISCVDescs.OperandInfo[476] }, // Inst #1870 = PseudoVFMADD_VV_M8_MASK + { 8, &RISCVDescs.OperandInfo[468] }, // Inst #1869 = PseudoVFMADD_VV_M8 + { 9, &RISCVDescs.OperandInfo[459] }, // Inst #1868 = PseudoVFMADD_VV_M4_MASK + { 8, &RISCVDescs.OperandInfo[451] }, // Inst #1867 = PseudoVFMADD_VV_M4 + { 9, &RISCVDescs.OperandInfo[442] }, // Inst #1866 = PseudoVFMADD_VV_M2_MASK + { 8, &RISCVDescs.OperandInfo[434] }, // Inst #1865 = PseudoVFMADD_VV_M2 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #1864 = PseudoVFMADD_VV_M1_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #1863 = PseudoVFMADD_VV_M1 + { 9, &RISCVDescs.OperandInfo[2341] }, // Inst #1862 = PseudoVFMADD_VFPR64_M8_MASK + { 8, &RISCVDescs.OperandInfo[2333] }, // Inst #1861 = PseudoVFMADD_VFPR64_M8 + { 9, &RISCVDescs.OperandInfo[2324] }, // Inst #1860 = PseudoVFMADD_VFPR64_M4_MASK + { 8, &RISCVDescs.OperandInfo[2316] }, // Inst #1859 = PseudoVFMADD_VFPR64_M4 + { 9, &RISCVDescs.OperandInfo[2307] }, // Inst #1858 = PseudoVFMADD_VFPR64_M2_MASK + { 8, &RISCVDescs.OperandInfo[2299] }, // Inst #1857 = PseudoVFMADD_VFPR64_M2 + { 9, &RISCVDescs.OperandInfo[2290] }, // Inst #1856 = PseudoVFMADD_VFPR64_M1_MASK + { 8, &RISCVDescs.OperandInfo[2282] }, // Inst #1855 = PseudoVFMADD_VFPR64_M1 + { 9, &RISCVDescs.OperandInfo[2222] }, // Inst #1854 = PseudoVFMADD_VFPR32_MF2_MASK + { 8, &RISCVDescs.OperandInfo[2214] }, // Inst #1853 = PseudoVFMADD_VFPR32_MF2 + { 9, &RISCVDescs.OperandInfo[2273] }, // Inst #1852 = PseudoVFMADD_VFPR32_M8_MASK + { 8, &RISCVDescs.OperandInfo[2265] }, // Inst #1851 = PseudoVFMADD_VFPR32_M8 + { 9, &RISCVDescs.OperandInfo[2256] }, // Inst #1850 = PseudoVFMADD_VFPR32_M4_MASK + { 8, &RISCVDescs.OperandInfo[2248] }, // Inst #1849 = PseudoVFMADD_VFPR32_M4 + { 9, &RISCVDescs.OperandInfo[2239] }, // Inst #1848 = PseudoVFMADD_VFPR32_M2_MASK + { 8, &RISCVDescs.OperandInfo[2231] }, // Inst #1847 = PseudoVFMADD_VFPR32_M2 + { 9, &RISCVDescs.OperandInfo[2222] }, // Inst #1846 = PseudoVFMADD_VFPR32_M1_MASK + { 8, &RISCVDescs.OperandInfo[2214] }, // Inst #1845 = PseudoVFMADD_VFPR32_M1 + { 9, &RISCVDescs.OperandInfo[2154] }, // Inst #1844 = PseudoVFMADD_VFPR16_MF4_MASK + { 8, &RISCVDescs.OperandInfo[2146] }, // Inst #1843 = PseudoVFMADD_VFPR16_MF4 + { 9, &RISCVDescs.OperandInfo[2154] }, // Inst #1842 = PseudoVFMADD_VFPR16_MF2_MASK + { 8, &RISCVDescs.OperandInfo[2146] }, // Inst #1841 = PseudoVFMADD_VFPR16_MF2 + { 9, &RISCVDescs.OperandInfo[2205] }, // Inst #1840 = PseudoVFMADD_VFPR16_M8_MASK + { 8, &RISCVDescs.OperandInfo[2197] }, // Inst #1839 = PseudoVFMADD_VFPR16_M8 + { 9, &RISCVDescs.OperandInfo[2188] }, // Inst #1838 = PseudoVFMADD_VFPR16_M4_MASK + { 8, &RISCVDescs.OperandInfo[2180] }, // Inst #1837 = PseudoVFMADD_VFPR16_M4 + { 9, &RISCVDescs.OperandInfo[2171] }, // Inst #1836 = PseudoVFMADD_VFPR16_M2_MASK + { 8, &RISCVDescs.OperandInfo[2163] }, // Inst #1835 = PseudoVFMADD_VFPR16_M2 + { 9, &RISCVDescs.OperandInfo[2154] }, // Inst #1834 = PseudoVFMADD_VFPR16_M1_MASK + { 8, &RISCVDescs.OperandInfo[2146] }, // Inst #1833 = PseudoVFMADD_VFPR16_M1 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #1832 = PseudoVFMACC_VV_MF4_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #1831 = PseudoVFMACC_VV_MF4 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #1830 = PseudoVFMACC_VV_MF2_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #1829 = PseudoVFMACC_VV_MF2 + { 9, &RISCVDescs.OperandInfo[476] }, // Inst #1828 = PseudoVFMACC_VV_M8_MASK + { 8, &RISCVDescs.OperandInfo[468] }, // Inst #1827 = PseudoVFMACC_VV_M8 + { 9, &RISCVDescs.OperandInfo[459] }, // Inst #1826 = PseudoVFMACC_VV_M4_MASK + { 8, &RISCVDescs.OperandInfo[451] }, // Inst #1825 = PseudoVFMACC_VV_M4 + { 9, &RISCVDescs.OperandInfo[442] }, // Inst #1824 = PseudoVFMACC_VV_M2_MASK + { 8, &RISCVDescs.OperandInfo[434] }, // Inst #1823 = PseudoVFMACC_VV_M2 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #1822 = PseudoVFMACC_VV_M1_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #1821 = PseudoVFMACC_VV_M1 + { 9, &RISCVDescs.OperandInfo[2341] }, // Inst #1820 = PseudoVFMACC_VFPR64_M8_MASK + { 8, &RISCVDescs.OperandInfo[2333] }, // Inst #1819 = PseudoVFMACC_VFPR64_M8 + { 9, &RISCVDescs.OperandInfo[2324] }, // Inst #1818 = PseudoVFMACC_VFPR64_M4_MASK + { 8, &RISCVDescs.OperandInfo[2316] }, // Inst #1817 = PseudoVFMACC_VFPR64_M4 + { 9, &RISCVDescs.OperandInfo[2307] }, // Inst #1816 = PseudoVFMACC_VFPR64_M2_MASK + { 8, &RISCVDescs.OperandInfo[2299] }, // Inst #1815 = PseudoVFMACC_VFPR64_M2 + { 9, &RISCVDescs.OperandInfo[2290] }, // Inst #1814 = PseudoVFMACC_VFPR64_M1_MASK + { 8, &RISCVDescs.OperandInfo[2282] }, // Inst #1813 = PseudoVFMACC_VFPR64_M1 + { 9, &RISCVDescs.OperandInfo[2222] }, // Inst #1812 = PseudoVFMACC_VFPR32_MF2_MASK + { 8, &RISCVDescs.OperandInfo[2214] }, // Inst #1811 = PseudoVFMACC_VFPR32_MF2 + { 9, &RISCVDescs.OperandInfo[2273] }, // Inst #1810 = PseudoVFMACC_VFPR32_M8_MASK + { 8, &RISCVDescs.OperandInfo[2265] }, // Inst #1809 = PseudoVFMACC_VFPR32_M8 + { 9, &RISCVDescs.OperandInfo[2256] }, // Inst #1808 = PseudoVFMACC_VFPR32_M4_MASK + { 8, &RISCVDescs.OperandInfo[2248] }, // Inst #1807 = PseudoVFMACC_VFPR32_M4 + { 9, &RISCVDescs.OperandInfo[2239] }, // Inst #1806 = PseudoVFMACC_VFPR32_M2_MASK + { 8, &RISCVDescs.OperandInfo[2231] }, // Inst #1805 = PseudoVFMACC_VFPR32_M2 + { 9, &RISCVDescs.OperandInfo[2222] }, // Inst #1804 = PseudoVFMACC_VFPR32_M1_MASK + { 8, &RISCVDescs.OperandInfo[2214] }, // Inst #1803 = PseudoVFMACC_VFPR32_M1 + { 9, &RISCVDescs.OperandInfo[2154] }, // Inst #1802 = PseudoVFMACC_VFPR16_MF4_MASK + { 8, &RISCVDescs.OperandInfo[2146] }, // Inst #1801 = PseudoVFMACC_VFPR16_MF4 + { 9, &RISCVDescs.OperandInfo[2154] }, // Inst #1800 = PseudoVFMACC_VFPR16_MF2_MASK + { 8, &RISCVDescs.OperandInfo[2146] }, // Inst #1799 = PseudoVFMACC_VFPR16_MF2 + { 9, &RISCVDescs.OperandInfo[2205] }, // Inst #1798 = PseudoVFMACC_VFPR16_M8_MASK + { 8, &RISCVDescs.OperandInfo[2197] }, // Inst #1797 = PseudoVFMACC_VFPR16_M8 + { 9, &RISCVDescs.OperandInfo[2188] }, // Inst #1796 = PseudoVFMACC_VFPR16_M4_MASK + { 8, &RISCVDescs.OperandInfo[2180] }, // Inst #1795 = PseudoVFMACC_VFPR16_M4 + { 9, &RISCVDescs.OperandInfo[2171] }, // Inst #1794 = PseudoVFMACC_VFPR16_M2_MASK + { 8, &RISCVDescs.OperandInfo[2163] }, // Inst #1793 = PseudoVFMACC_VFPR16_M2 + { 9, &RISCVDescs.OperandInfo[2154] }, // Inst #1792 = PseudoVFMACC_VFPR16_M1_MASK + { 8, &RISCVDescs.OperandInfo[2146] }, // Inst #1791 = PseudoVFMACC_VFPR16_M1 + { 5, &RISCVDescs.OperandInfo[961] }, // Inst #1790 = PseudoVFIRST_M_B8_MASK + { 4, &RISCVDescs.OperandInfo[957] }, // Inst #1789 = PseudoVFIRST_M_B8 + { 5, &RISCVDescs.OperandInfo[961] }, // Inst #1788 = PseudoVFIRST_M_B64_MASK + { 4, &RISCVDescs.OperandInfo[957] }, // Inst #1787 = PseudoVFIRST_M_B64 + { 5, &RISCVDescs.OperandInfo[961] }, // Inst #1786 = PseudoVFIRST_M_B4_MASK + { 4, &RISCVDescs.OperandInfo[957] }, // Inst #1785 = PseudoVFIRST_M_B4 + { 5, &RISCVDescs.OperandInfo[961] }, // Inst #1784 = PseudoVFIRST_M_B32_MASK + { 4, &RISCVDescs.OperandInfo[957] }, // Inst #1783 = PseudoVFIRST_M_B32 + { 5, &RISCVDescs.OperandInfo[961] }, // Inst #1782 = PseudoVFIRST_M_B2_MASK + { 4, &RISCVDescs.OperandInfo[957] }, // Inst #1781 = PseudoVFIRST_M_B2 + { 5, &RISCVDescs.OperandInfo[961] }, // Inst #1780 = PseudoVFIRST_M_B1_MASK + { 5, &RISCVDescs.OperandInfo[961] }, // Inst #1779 = PseudoVFIRST_M_B16_MASK + { 4, &RISCVDescs.OperandInfo[957] }, // Inst #1778 = PseudoVFIRST_M_B16 + { 4, &RISCVDescs.OperandInfo[957] }, // Inst #1777 = PseudoVFIRST_M_B1 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #1776 = PseudoVFDIV_VV_MF4_E16_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #1775 = PseudoVFDIV_VV_MF4_E16 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #1774 = PseudoVFDIV_VV_MF2_E32_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #1773 = PseudoVFDIV_VV_MF2_E32 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #1772 = PseudoVFDIV_VV_MF2_E16_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #1771 = PseudoVFDIV_VV_MF2_E16 + { 9, &RISCVDescs.OperandInfo[476] }, // Inst #1770 = PseudoVFDIV_VV_M8_E64_MASK + { 8, &RISCVDescs.OperandInfo[468] }, // Inst #1769 = PseudoVFDIV_VV_M8_E64 + { 9, &RISCVDescs.OperandInfo[476] }, // Inst #1768 = PseudoVFDIV_VV_M8_E32_MASK + { 8, &RISCVDescs.OperandInfo[468] }, // Inst #1767 = PseudoVFDIV_VV_M8_E32 + { 9, &RISCVDescs.OperandInfo[476] }, // Inst #1766 = PseudoVFDIV_VV_M8_E16_MASK + { 8, &RISCVDescs.OperandInfo[468] }, // Inst #1765 = PseudoVFDIV_VV_M8_E16 + { 9, &RISCVDescs.OperandInfo[459] }, // Inst #1764 = PseudoVFDIV_VV_M4_E64_MASK + { 8, &RISCVDescs.OperandInfo[451] }, // Inst #1763 = PseudoVFDIV_VV_M4_E64 + { 9, &RISCVDescs.OperandInfo[459] }, // Inst #1762 = PseudoVFDIV_VV_M4_E32_MASK + { 8, &RISCVDescs.OperandInfo[451] }, // Inst #1761 = PseudoVFDIV_VV_M4_E32 + { 9, &RISCVDescs.OperandInfo[459] }, // Inst #1760 = PseudoVFDIV_VV_M4_E16_MASK + { 8, &RISCVDescs.OperandInfo[451] }, // Inst #1759 = PseudoVFDIV_VV_M4_E16 + { 9, &RISCVDescs.OperandInfo[442] }, // Inst #1758 = PseudoVFDIV_VV_M2_E64_MASK + { 8, &RISCVDescs.OperandInfo[434] }, // Inst #1757 = PseudoVFDIV_VV_M2_E64 + { 9, &RISCVDescs.OperandInfo[442] }, // Inst #1756 = PseudoVFDIV_VV_M2_E32_MASK + { 8, &RISCVDescs.OperandInfo[434] }, // Inst #1755 = PseudoVFDIV_VV_M2_E32 + { 9, &RISCVDescs.OperandInfo[442] }, // Inst #1754 = PseudoVFDIV_VV_M2_E16_MASK + { 8, &RISCVDescs.OperandInfo[434] }, // Inst #1753 = PseudoVFDIV_VV_M2_E16 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #1752 = PseudoVFDIV_VV_M1_E64_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #1751 = PseudoVFDIV_VV_M1_E64 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #1750 = PseudoVFDIV_VV_M1_E32_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #1749 = PseudoVFDIV_VV_M1_E32 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #1748 = PseudoVFDIV_VV_M1_E16_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #1747 = PseudoVFDIV_VV_M1_E16 + { 9, &RISCVDescs.OperandInfo[2077] }, // Inst #1746 = PseudoVFDIV_VFPR64_M8_E64_MASK + { 8, &RISCVDescs.OperandInfo[2069] }, // Inst #1745 = PseudoVFDIV_VFPR64_M8_E64 + { 9, &RISCVDescs.OperandInfo[2060] }, // Inst #1744 = PseudoVFDIV_VFPR64_M4_E64_MASK + { 8, &RISCVDescs.OperandInfo[2052] }, // Inst #1743 = PseudoVFDIV_VFPR64_M4_E64 + { 9, &RISCVDescs.OperandInfo[2043] }, // Inst #1742 = PseudoVFDIV_VFPR64_M2_E64_MASK + { 8, &RISCVDescs.OperandInfo[2035] }, // Inst #1741 = PseudoVFDIV_VFPR64_M2_E64 + { 9, &RISCVDescs.OperandInfo[2026] }, // Inst #1740 = PseudoVFDIV_VFPR64_M1_E64_MASK + { 8, &RISCVDescs.OperandInfo[2018] }, // Inst #1739 = PseudoVFDIV_VFPR64_M1_E64 + { 9, &RISCVDescs.OperandInfo[1958] }, // Inst #1738 = PseudoVFDIV_VFPR32_MF2_E32_MASK + { 8, &RISCVDescs.OperandInfo[1950] }, // Inst #1737 = PseudoVFDIV_VFPR32_MF2_E32 + { 9, &RISCVDescs.OperandInfo[2009] }, // Inst #1736 = PseudoVFDIV_VFPR32_M8_E32_MASK + { 8, &RISCVDescs.OperandInfo[2001] }, // Inst #1735 = PseudoVFDIV_VFPR32_M8_E32 + { 9, &RISCVDescs.OperandInfo[1992] }, // Inst #1734 = PseudoVFDIV_VFPR32_M4_E32_MASK + { 8, &RISCVDescs.OperandInfo[1984] }, // Inst #1733 = PseudoVFDIV_VFPR32_M4_E32 + { 9, &RISCVDescs.OperandInfo[1975] }, // Inst #1732 = PseudoVFDIV_VFPR32_M2_E32_MASK + { 8, &RISCVDescs.OperandInfo[1967] }, // Inst #1731 = PseudoVFDIV_VFPR32_M2_E32 + { 9, &RISCVDescs.OperandInfo[1958] }, // Inst #1730 = PseudoVFDIV_VFPR32_M1_E32_MASK + { 8, &RISCVDescs.OperandInfo[1950] }, // Inst #1729 = PseudoVFDIV_VFPR32_M1_E32 + { 9, &RISCVDescs.OperandInfo[1890] }, // Inst #1728 = PseudoVFDIV_VFPR16_MF4_E16_MASK + { 8, &RISCVDescs.OperandInfo[1882] }, // Inst #1727 = PseudoVFDIV_VFPR16_MF4_E16 + { 9, &RISCVDescs.OperandInfo[1890] }, // Inst #1726 = PseudoVFDIV_VFPR16_MF2_E16_MASK + { 8, &RISCVDescs.OperandInfo[1882] }, // Inst #1725 = PseudoVFDIV_VFPR16_MF2_E16 + { 9, &RISCVDescs.OperandInfo[1941] }, // Inst #1724 = PseudoVFDIV_VFPR16_M8_E16_MASK + { 8, &RISCVDescs.OperandInfo[1933] }, // Inst #1723 = PseudoVFDIV_VFPR16_M8_E16 + { 9, &RISCVDescs.OperandInfo[1924] }, // Inst #1722 = PseudoVFDIV_VFPR16_M4_E16_MASK + { 8, &RISCVDescs.OperandInfo[1916] }, // Inst #1721 = PseudoVFDIV_VFPR16_M4_E16 + { 9, &RISCVDescs.OperandInfo[1907] }, // Inst #1720 = PseudoVFDIV_VFPR16_M2_E16_MASK + { 8, &RISCVDescs.OperandInfo[1899] }, // Inst #1719 = PseudoVFDIV_VFPR16_M2_E16 + { 9, &RISCVDescs.OperandInfo[1890] }, // Inst #1718 = PseudoVFDIV_VFPR16_M1_E16_MASK + { 8, &RISCVDescs.OperandInfo[1882] }, // Inst #1717 = PseudoVFDIV_VFPR16_M1_E16 + { 8, &RISCVDescs.OperandInfo[2093] }, // Inst #1716 = PseudoVFCVT_X_F_V_MF4_MASK + { 7, &RISCVDescs.OperandInfo[2086] }, // Inst #1715 = PseudoVFCVT_X_F_V_MF4 + { 8, &RISCVDescs.OperandInfo[2093] }, // Inst #1714 = PseudoVFCVT_X_F_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[2086] }, // Inst #1713 = PseudoVFCVT_X_F_V_MF2 + { 8, &RISCVDescs.OperandInfo[2138] }, // Inst #1712 = PseudoVFCVT_X_F_V_M8_MASK + { 7, &RISCVDescs.OperandInfo[2131] }, // Inst #1711 = PseudoVFCVT_X_F_V_M8 + { 8, &RISCVDescs.OperandInfo[2123] }, // Inst #1710 = PseudoVFCVT_X_F_V_M4_MASK + { 7, &RISCVDescs.OperandInfo[2116] }, // Inst #1709 = PseudoVFCVT_X_F_V_M4 + { 8, &RISCVDescs.OperandInfo[2108] }, // Inst #1708 = PseudoVFCVT_X_F_V_M2_MASK + { 7, &RISCVDescs.OperandInfo[2101] }, // Inst #1707 = PseudoVFCVT_X_F_V_M2 + { 8, &RISCVDescs.OperandInfo[2093] }, // Inst #1706 = PseudoVFCVT_X_F_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[2086] }, // Inst #1705 = PseudoVFCVT_X_F_V_M1 + { 8, &RISCVDescs.OperandInfo[2093] }, // Inst #1704 = PseudoVFCVT_XU_F_V_MF4_MASK + { 7, &RISCVDescs.OperandInfo[2086] }, // Inst #1703 = PseudoVFCVT_XU_F_V_MF4 + { 8, &RISCVDescs.OperandInfo[2093] }, // Inst #1702 = PseudoVFCVT_XU_F_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[2086] }, // Inst #1701 = PseudoVFCVT_XU_F_V_MF2 + { 8, &RISCVDescs.OperandInfo[2138] }, // Inst #1700 = PseudoVFCVT_XU_F_V_M8_MASK + { 7, &RISCVDescs.OperandInfo[2131] }, // Inst #1699 = PseudoVFCVT_XU_F_V_M8 + { 8, &RISCVDescs.OperandInfo[2123] }, // Inst #1698 = PseudoVFCVT_XU_F_V_M4_MASK + { 7, &RISCVDescs.OperandInfo[2116] }, // Inst #1697 = PseudoVFCVT_XU_F_V_M4 + { 8, &RISCVDescs.OperandInfo[2108] }, // Inst #1696 = PseudoVFCVT_XU_F_V_M2_MASK + { 7, &RISCVDescs.OperandInfo[2101] }, // Inst #1695 = PseudoVFCVT_XU_F_V_M2 + { 8, &RISCVDescs.OperandInfo[2093] }, // Inst #1694 = PseudoVFCVT_XU_F_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[2086] }, // Inst #1693 = PseudoVFCVT_XU_F_V_M1 + { 7, &RISCVDescs.OperandInfo[905] }, // Inst #1692 = PseudoVFCVT_RTZ_X_F_V_MF4_MASK + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #1691 = PseudoVFCVT_RTZ_X_F_V_MF4 + { 7, &RISCVDescs.OperandInfo[905] }, // Inst #1690 = PseudoVFCVT_RTZ_X_F_V_MF2_MASK + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #1689 = PseudoVFCVT_RTZ_X_F_V_MF2 + { 7, &RISCVDescs.OperandInfo[926] }, // Inst #1688 = PseudoVFCVT_RTZ_X_F_V_M8_MASK + { 6, &RISCVDescs.OperandInfo[871] }, // Inst #1687 = PseudoVFCVT_RTZ_X_F_V_M8 + { 7, &RISCVDescs.OperandInfo[919] }, // Inst #1686 = PseudoVFCVT_RTZ_X_F_V_M4_MASK + { 6, &RISCVDescs.OperandInfo[847] }, // Inst #1685 = PseudoVFCVT_RTZ_X_F_V_M4 + { 7, &RISCVDescs.OperandInfo[912] }, // Inst #1684 = PseudoVFCVT_RTZ_X_F_V_M2_MASK + { 6, &RISCVDescs.OperandInfo[829] }, // Inst #1683 = PseudoVFCVT_RTZ_X_F_V_M2 + { 7, &RISCVDescs.OperandInfo[905] }, // Inst #1682 = PseudoVFCVT_RTZ_X_F_V_M1_MASK + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #1681 = PseudoVFCVT_RTZ_X_F_V_M1 + { 7, &RISCVDescs.OperandInfo[905] }, // Inst #1680 = PseudoVFCVT_RTZ_XU_F_V_MF4_MASK + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #1679 = PseudoVFCVT_RTZ_XU_F_V_MF4 + { 7, &RISCVDescs.OperandInfo[905] }, // Inst #1678 = PseudoVFCVT_RTZ_XU_F_V_MF2_MASK + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #1677 = PseudoVFCVT_RTZ_XU_F_V_MF2 + { 7, &RISCVDescs.OperandInfo[926] }, // Inst #1676 = PseudoVFCVT_RTZ_XU_F_V_M8_MASK + { 6, &RISCVDescs.OperandInfo[871] }, // Inst #1675 = PseudoVFCVT_RTZ_XU_F_V_M8 + { 7, &RISCVDescs.OperandInfo[919] }, // Inst #1674 = PseudoVFCVT_RTZ_XU_F_V_M4_MASK + { 6, &RISCVDescs.OperandInfo[847] }, // Inst #1673 = PseudoVFCVT_RTZ_XU_F_V_M4 + { 7, &RISCVDescs.OperandInfo[912] }, // Inst #1672 = PseudoVFCVT_RTZ_XU_F_V_M2_MASK + { 6, &RISCVDescs.OperandInfo[829] }, // Inst #1671 = PseudoVFCVT_RTZ_XU_F_V_M2 + { 7, &RISCVDescs.OperandInfo[905] }, // Inst #1670 = PseudoVFCVT_RTZ_XU_F_V_M1_MASK + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #1669 = PseudoVFCVT_RTZ_XU_F_V_M1 + { 8, &RISCVDescs.OperandInfo[2093] }, // Inst #1668 = PseudoVFCVT_RM_X_F_V_MF4_MASK + { 7, &RISCVDescs.OperandInfo[2086] }, // Inst #1667 = PseudoVFCVT_RM_X_F_V_MF4 + { 8, &RISCVDescs.OperandInfo[2093] }, // Inst #1666 = PseudoVFCVT_RM_X_F_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[2086] }, // Inst #1665 = PseudoVFCVT_RM_X_F_V_MF2 + { 8, &RISCVDescs.OperandInfo[2138] }, // Inst #1664 = PseudoVFCVT_RM_X_F_V_M8_MASK + { 7, &RISCVDescs.OperandInfo[2131] }, // Inst #1663 = PseudoVFCVT_RM_X_F_V_M8 + { 8, &RISCVDescs.OperandInfo[2123] }, // Inst #1662 = PseudoVFCVT_RM_X_F_V_M4_MASK + { 7, &RISCVDescs.OperandInfo[2116] }, // Inst #1661 = PseudoVFCVT_RM_X_F_V_M4 + { 8, &RISCVDescs.OperandInfo[2108] }, // Inst #1660 = PseudoVFCVT_RM_X_F_V_M2_MASK + { 7, &RISCVDescs.OperandInfo[2101] }, // Inst #1659 = PseudoVFCVT_RM_X_F_V_M2 + { 8, &RISCVDescs.OperandInfo[2093] }, // Inst #1658 = PseudoVFCVT_RM_X_F_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[2086] }, // Inst #1657 = PseudoVFCVT_RM_X_F_V_M1 + { 8, &RISCVDescs.OperandInfo[2093] }, // Inst #1656 = PseudoVFCVT_RM_XU_F_V_MF4_MASK + { 7, &RISCVDescs.OperandInfo[2086] }, // Inst #1655 = PseudoVFCVT_RM_XU_F_V_MF4 + { 8, &RISCVDescs.OperandInfo[2093] }, // Inst #1654 = PseudoVFCVT_RM_XU_F_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[2086] }, // Inst #1653 = PseudoVFCVT_RM_XU_F_V_MF2 + { 8, &RISCVDescs.OperandInfo[2138] }, // Inst #1652 = PseudoVFCVT_RM_XU_F_V_M8_MASK + { 7, &RISCVDescs.OperandInfo[2131] }, // Inst #1651 = PseudoVFCVT_RM_XU_F_V_M8 + { 8, &RISCVDescs.OperandInfo[2123] }, // Inst #1650 = PseudoVFCVT_RM_XU_F_V_M4_MASK + { 7, &RISCVDescs.OperandInfo[2116] }, // Inst #1649 = PseudoVFCVT_RM_XU_F_V_M4 + { 8, &RISCVDescs.OperandInfo[2108] }, // Inst #1648 = PseudoVFCVT_RM_XU_F_V_M2_MASK + { 7, &RISCVDescs.OperandInfo[2101] }, // Inst #1647 = PseudoVFCVT_RM_XU_F_V_M2 + { 8, &RISCVDescs.OperandInfo[2093] }, // Inst #1646 = PseudoVFCVT_RM_XU_F_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[2086] }, // Inst #1645 = PseudoVFCVT_RM_XU_F_V_M1 + { 8, &RISCVDescs.OperandInfo[2093] }, // Inst #1644 = PseudoVFCVT_RM_F_X_V_MF4_MASK + { 7, &RISCVDescs.OperandInfo[2086] }, // Inst #1643 = PseudoVFCVT_RM_F_X_V_MF4 + { 8, &RISCVDescs.OperandInfo[2093] }, // Inst #1642 = PseudoVFCVT_RM_F_X_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[2086] }, // Inst #1641 = PseudoVFCVT_RM_F_X_V_MF2 + { 8, &RISCVDescs.OperandInfo[2138] }, // Inst #1640 = PseudoVFCVT_RM_F_X_V_M8_MASK + { 7, &RISCVDescs.OperandInfo[2131] }, // Inst #1639 = PseudoVFCVT_RM_F_X_V_M8 + { 8, &RISCVDescs.OperandInfo[2123] }, // Inst #1638 = PseudoVFCVT_RM_F_X_V_M4_MASK + { 7, &RISCVDescs.OperandInfo[2116] }, // Inst #1637 = PseudoVFCVT_RM_F_X_V_M4 + { 8, &RISCVDescs.OperandInfo[2108] }, // Inst #1636 = PseudoVFCVT_RM_F_X_V_M2_MASK + { 7, &RISCVDescs.OperandInfo[2101] }, // Inst #1635 = PseudoVFCVT_RM_F_X_V_M2 + { 8, &RISCVDescs.OperandInfo[2093] }, // Inst #1634 = PseudoVFCVT_RM_F_X_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[2086] }, // Inst #1633 = PseudoVFCVT_RM_F_X_V_M1 + { 8, &RISCVDescs.OperandInfo[2093] }, // Inst #1632 = PseudoVFCVT_RM_F_XU_V_MF4_MASK + { 7, &RISCVDescs.OperandInfo[2086] }, // Inst #1631 = PseudoVFCVT_RM_F_XU_V_MF4 + { 8, &RISCVDescs.OperandInfo[2093] }, // Inst #1630 = PseudoVFCVT_RM_F_XU_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[2086] }, // Inst #1629 = PseudoVFCVT_RM_F_XU_V_MF2 + { 8, &RISCVDescs.OperandInfo[2138] }, // Inst #1628 = PseudoVFCVT_RM_F_XU_V_M8_MASK + { 7, &RISCVDescs.OperandInfo[2131] }, // Inst #1627 = PseudoVFCVT_RM_F_XU_V_M8 + { 8, &RISCVDescs.OperandInfo[2123] }, // Inst #1626 = PseudoVFCVT_RM_F_XU_V_M4_MASK + { 7, &RISCVDescs.OperandInfo[2116] }, // Inst #1625 = PseudoVFCVT_RM_F_XU_V_M4 + { 8, &RISCVDescs.OperandInfo[2108] }, // Inst #1624 = PseudoVFCVT_RM_F_XU_V_M2_MASK + { 7, &RISCVDescs.OperandInfo[2101] }, // Inst #1623 = PseudoVFCVT_RM_F_XU_V_M2 + { 8, &RISCVDescs.OperandInfo[2093] }, // Inst #1622 = PseudoVFCVT_RM_F_XU_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[2086] }, // Inst #1621 = PseudoVFCVT_RM_F_XU_V_M1 + { 8, &RISCVDescs.OperandInfo[2093] }, // Inst #1620 = PseudoVFCVT_F_X_V_MF4_MASK + { 7, &RISCVDescs.OperandInfo[2086] }, // Inst #1619 = PseudoVFCVT_F_X_V_MF4 + { 8, &RISCVDescs.OperandInfo[2093] }, // Inst #1618 = PseudoVFCVT_F_X_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[2086] }, // Inst #1617 = PseudoVFCVT_F_X_V_MF2 + { 8, &RISCVDescs.OperandInfo[2138] }, // Inst #1616 = PseudoVFCVT_F_X_V_M8_MASK + { 7, &RISCVDescs.OperandInfo[2131] }, // Inst #1615 = PseudoVFCVT_F_X_V_M8 + { 8, &RISCVDescs.OperandInfo[2123] }, // Inst #1614 = PseudoVFCVT_F_X_V_M4_MASK + { 7, &RISCVDescs.OperandInfo[2116] }, // Inst #1613 = PseudoVFCVT_F_X_V_M4 + { 8, &RISCVDescs.OperandInfo[2108] }, // Inst #1612 = PseudoVFCVT_F_X_V_M2_MASK + { 7, &RISCVDescs.OperandInfo[2101] }, // Inst #1611 = PseudoVFCVT_F_X_V_M2 + { 8, &RISCVDescs.OperandInfo[2093] }, // Inst #1610 = PseudoVFCVT_F_X_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[2086] }, // Inst #1609 = PseudoVFCVT_F_X_V_M1 + { 8, &RISCVDescs.OperandInfo[2093] }, // Inst #1608 = PseudoVFCVT_F_XU_V_MF4_MASK + { 7, &RISCVDescs.OperandInfo[2086] }, // Inst #1607 = PseudoVFCVT_F_XU_V_MF4 + { 8, &RISCVDescs.OperandInfo[2093] }, // Inst #1606 = PseudoVFCVT_F_XU_V_MF2_MASK + { 7, &RISCVDescs.OperandInfo[2086] }, // Inst #1605 = PseudoVFCVT_F_XU_V_MF2 + { 8, &RISCVDescs.OperandInfo[2138] }, // Inst #1604 = PseudoVFCVT_F_XU_V_M8_MASK + { 7, &RISCVDescs.OperandInfo[2131] }, // Inst #1603 = PseudoVFCVT_F_XU_V_M8 + { 8, &RISCVDescs.OperandInfo[2123] }, // Inst #1602 = PseudoVFCVT_F_XU_V_M4_MASK + { 7, &RISCVDescs.OperandInfo[2116] }, // Inst #1601 = PseudoVFCVT_F_XU_V_M4 + { 8, &RISCVDescs.OperandInfo[2108] }, // Inst #1600 = PseudoVFCVT_F_XU_V_M2_MASK + { 7, &RISCVDescs.OperandInfo[2101] }, // Inst #1599 = PseudoVFCVT_F_XU_V_M2 + { 8, &RISCVDescs.OperandInfo[2093] }, // Inst #1598 = PseudoVFCVT_F_XU_V_M1_MASK + { 7, &RISCVDescs.OperandInfo[2086] }, // Inst #1597 = PseudoVFCVT_F_XU_V_M1 + { 7, &RISCVDescs.OperandInfo[905] }, // Inst #1596 = PseudoVFCLASS_V_MF4_MASK + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #1595 = PseudoVFCLASS_V_MF4 + { 7, &RISCVDescs.OperandInfo[905] }, // Inst #1594 = PseudoVFCLASS_V_MF2_MASK + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #1593 = PseudoVFCLASS_V_MF2 + { 7, &RISCVDescs.OperandInfo[926] }, // Inst #1592 = PseudoVFCLASS_V_M8_MASK + { 6, &RISCVDescs.OperandInfo[871] }, // Inst #1591 = PseudoVFCLASS_V_M8 + { 7, &RISCVDescs.OperandInfo[919] }, // Inst #1590 = PseudoVFCLASS_V_M4_MASK + { 6, &RISCVDescs.OperandInfo[847] }, // Inst #1589 = PseudoVFCLASS_V_M4 + { 7, &RISCVDescs.OperandInfo[912] }, // Inst #1588 = PseudoVFCLASS_V_M2_MASK + { 6, &RISCVDescs.OperandInfo[829] }, // Inst #1587 = PseudoVFCLASS_V_M2 + { 7, &RISCVDescs.OperandInfo[905] }, // Inst #1586 = PseudoVFCLASS_V_M1_MASK + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #1585 = PseudoVFCLASS_V_M1 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #1584 = PseudoVFADD_VV_MF4_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #1583 = PseudoVFADD_VV_MF4 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #1582 = PseudoVFADD_VV_MF2_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #1581 = PseudoVFADD_VV_MF2 + { 9, &RISCVDescs.OperandInfo[476] }, // Inst #1580 = PseudoVFADD_VV_M8_MASK + { 8, &RISCVDescs.OperandInfo[468] }, // Inst #1579 = PseudoVFADD_VV_M8 + { 9, &RISCVDescs.OperandInfo[459] }, // Inst #1578 = PseudoVFADD_VV_M4_MASK + { 8, &RISCVDescs.OperandInfo[451] }, // Inst #1577 = PseudoVFADD_VV_M4 + { 9, &RISCVDescs.OperandInfo[442] }, // Inst #1576 = PseudoVFADD_VV_M2_MASK + { 8, &RISCVDescs.OperandInfo[434] }, // Inst #1575 = PseudoVFADD_VV_M2 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #1574 = PseudoVFADD_VV_M1_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #1573 = PseudoVFADD_VV_M1 + { 9, &RISCVDescs.OperandInfo[2077] }, // Inst #1572 = PseudoVFADD_VFPR64_M8_MASK + { 8, &RISCVDescs.OperandInfo[2069] }, // Inst #1571 = PseudoVFADD_VFPR64_M8 + { 9, &RISCVDescs.OperandInfo[2060] }, // Inst #1570 = PseudoVFADD_VFPR64_M4_MASK + { 8, &RISCVDescs.OperandInfo[2052] }, // Inst #1569 = PseudoVFADD_VFPR64_M4 + { 9, &RISCVDescs.OperandInfo[2043] }, // Inst #1568 = PseudoVFADD_VFPR64_M2_MASK + { 8, &RISCVDescs.OperandInfo[2035] }, // Inst #1567 = PseudoVFADD_VFPR64_M2 + { 9, &RISCVDescs.OperandInfo[2026] }, // Inst #1566 = PseudoVFADD_VFPR64_M1_MASK + { 8, &RISCVDescs.OperandInfo[2018] }, // Inst #1565 = PseudoVFADD_VFPR64_M1 + { 9, &RISCVDescs.OperandInfo[1958] }, // Inst #1564 = PseudoVFADD_VFPR32_MF2_MASK + { 8, &RISCVDescs.OperandInfo[1950] }, // Inst #1563 = PseudoVFADD_VFPR32_MF2 + { 9, &RISCVDescs.OperandInfo[2009] }, // Inst #1562 = PseudoVFADD_VFPR32_M8_MASK + { 8, &RISCVDescs.OperandInfo[2001] }, // Inst #1561 = PseudoVFADD_VFPR32_M8 + { 9, &RISCVDescs.OperandInfo[1992] }, // Inst #1560 = PseudoVFADD_VFPR32_M4_MASK + { 8, &RISCVDescs.OperandInfo[1984] }, // Inst #1559 = PseudoVFADD_VFPR32_M4 + { 9, &RISCVDescs.OperandInfo[1975] }, // Inst #1558 = PseudoVFADD_VFPR32_M2_MASK + { 8, &RISCVDescs.OperandInfo[1967] }, // Inst #1557 = PseudoVFADD_VFPR32_M2 + { 9, &RISCVDescs.OperandInfo[1958] }, // Inst #1556 = PseudoVFADD_VFPR32_M1_MASK + { 8, &RISCVDescs.OperandInfo[1950] }, // Inst #1555 = PseudoVFADD_VFPR32_M1 + { 9, &RISCVDescs.OperandInfo[1890] }, // Inst #1554 = PseudoVFADD_VFPR16_MF4_MASK + { 8, &RISCVDescs.OperandInfo[1882] }, // Inst #1553 = PseudoVFADD_VFPR16_MF4 + { 9, &RISCVDescs.OperandInfo[1890] }, // Inst #1552 = PseudoVFADD_VFPR16_MF2_MASK + { 8, &RISCVDescs.OperandInfo[1882] }, // Inst #1551 = PseudoVFADD_VFPR16_MF2 + { 9, &RISCVDescs.OperandInfo[1941] }, // Inst #1550 = PseudoVFADD_VFPR16_M8_MASK + { 8, &RISCVDescs.OperandInfo[1933] }, // Inst #1549 = PseudoVFADD_VFPR16_M8 + { 9, &RISCVDescs.OperandInfo[1924] }, // Inst #1548 = PseudoVFADD_VFPR16_M4_MASK + { 8, &RISCVDescs.OperandInfo[1916] }, // Inst #1547 = PseudoVFADD_VFPR16_M4 + { 9, &RISCVDescs.OperandInfo[1907] }, // Inst #1546 = PseudoVFADD_VFPR16_M2_MASK + { 8, &RISCVDescs.OperandInfo[1899] }, // Inst #1545 = PseudoVFADD_VFPR16_M2 + { 9, &RISCVDescs.OperandInfo[1890] }, // Inst #1544 = PseudoVFADD_VFPR16_M1_MASK + { 8, &RISCVDescs.OperandInfo[1882] }, // Inst #1543 = PseudoVFADD_VFPR16_M1 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #1542 = PseudoVDIV_VX_MF8_E8_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #1541 = PseudoVDIV_VX_MF8_E8 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #1540 = PseudoVDIV_VX_MF4_E8_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #1539 = PseudoVDIV_VX_MF4_E8 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #1538 = PseudoVDIV_VX_MF4_E16_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #1537 = PseudoVDIV_VX_MF4_E16 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #1536 = PseudoVDIV_VX_MF2_E8_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #1535 = PseudoVDIV_VX_MF2_E8 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #1534 = PseudoVDIV_VX_MF2_E32_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #1533 = PseudoVDIV_VX_MF2_E32 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #1532 = PseudoVDIV_VX_MF2_E16_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #1531 = PseudoVDIV_VX_MF2_E16 + { 8, &RISCVDescs.OperandInfo[809] }, // Inst #1530 = PseudoVDIV_VX_M8_E8_MASK + { 7, &RISCVDescs.OperandInfo[802] }, // Inst #1529 = PseudoVDIV_VX_M8_E8 + { 8, &RISCVDescs.OperandInfo[809] }, // Inst #1528 = PseudoVDIV_VX_M8_E64_MASK + { 7, &RISCVDescs.OperandInfo[802] }, // Inst #1527 = PseudoVDIV_VX_M8_E64 + { 8, &RISCVDescs.OperandInfo[809] }, // Inst #1526 = PseudoVDIV_VX_M8_E32_MASK + { 7, &RISCVDescs.OperandInfo[802] }, // Inst #1525 = PseudoVDIV_VX_M8_E32 + { 8, &RISCVDescs.OperandInfo[809] }, // Inst #1524 = PseudoVDIV_VX_M8_E16_MASK + { 7, &RISCVDescs.OperandInfo[802] }, // Inst #1523 = PseudoVDIV_VX_M8_E16 + { 8, &RISCVDescs.OperandInfo[794] }, // Inst #1522 = PseudoVDIV_VX_M4_E8_MASK + { 7, &RISCVDescs.OperandInfo[787] }, // Inst #1521 = PseudoVDIV_VX_M4_E8 + { 8, &RISCVDescs.OperandInfo[794] }, // Inst #1520 = PseudoVDIV_VX_M4_E64_MASK + { 7, &RISCVDescs.OperandInfo[787] }, // Inst #1519 = PseudoVDIV_VX_M4_E64 + { 8, &RISCVDescs.OperandInfo[794] }, // Inst #1518 = PseudoVDIV_VX_M4_E32_MASK + { 7, &RISCVDescs.OperandInfo[787] }, // Inst #1517 = PseudoVDIV_VX_M4_E32 + { 8, &RISCVDescs.OperandInfo[794] }, // Inst #1516 = PseudoVDIV_VX_M4_E16_MASK + { 7, &RISCVDescs.OperandInfo[787] }, // Inst #1515 = PseudoVDIV_VX_M4_E16 + { 8, &RISCVDescs.OperandInfo[779] }, // Inst #1514 = PseudoVDIV_VX_M2_E8_MASK + { 7, &RISCVDescs.OperandInfo[772] }, // Inst #1513 = PseudoVDIV_VX_M2_E8 + { 8, &RISCVDescs.OperandInfo[779] }, // Inst #1512 = PseudoVDIV_VX_M2_E64_MASK + { 7, &RISCVDescs.OperandInfo[772] }, // Inst #1511 = PseudoVDIV_VX_M2_E64 + { 8, &RISCVDescs.OperandInfo[779] }, // Inst #1510 = PseudoVDIV_VX_M2_E32_MASK + { 7, &RISCVDescs.OperandInfo[772] }, // Inst #1509 = PseudoVDIV_VX_M2_E32 + { 8, &RISCVDescs.OperandInfo[779] }, // Inst #1508 = PseudoVDIV_VX_M2_E16_MASK + { 7, &RISCVDescs.OperandInfo[772] }, // Inst #1507 = PseudoVDIV_VX_M2_E16 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #1506 = PseudoVDIV_VX_M1_E8_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #1505 = PseudoVDIV_VX_M1_E8 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #1504 = PseudoVDIV_VX_M1_E64_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #1503 = PseudoVDIV_VX_M1_E64 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #1502 = PseudoVDIV_VX_M1_E32_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #1501 = PseudoVDIV_VX_M1_E32 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #1500 = PseudoVDIV_VX_M1_E16_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #1499 = PseudoVDIV_VX_M1_E16 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #1498 = PseudoVDIV_VV_MF8_E8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #1497 = PseudoVDIV_VV_MF8_E8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #1496 = PseudoVDIV_VV_MF4_E8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #1495 = PseudoVDIV_VV_MF4_E8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #1494 = PseudoVDIV_VV_MF4_E16_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #1493 = PseudoVDIV_VV_MF4_E16 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #1492 = PseudoVDIV_VV_MF2_E8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #1491 = PseudoVDIV_VV_MF2_E8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #1490 = PseudoVDIV_VV_MF2_E32_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #1489 = PseudoVDIV_VV_MF2_E32 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #1488 = PseudoVDIV_VV_MF2_E16_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #1487 = PseudoVDIV_VV_MF2_E16 + { 8, &RISCVDescs.OperandInfo[749] }, // Inst #1486 = PseudoVDIV_VV_M8_E8_MASK + { 7, &RISCVDescs.OperandInfo[742] }, // Inst #1485 = PseudoVDIV_VV_M8_E8 + { 8, &RISCVDescs.OperandInfo[749] }, // Inst #1484 = PseudoVDIV_VV_M8_E64_MASK + { 7, &RISCVDescs.OperandInfo[742] }, // Inst #1483 = PseudoVDIV_VV_M8_E64 + { 8, &RISCVDescs.OperandInfo[749] }, // Inst #1482 = PseudoVDIV_VV_M8_E32_MASK + { 7, &RISCVDescs.OperandInfo[742] }, // Inst #1481 = PseudoVDIV_VV_M8_E32 + { 8, &RISCVDescs.OperandInfo[749] }, // Inst #1480 = PseudoVDIV_VV_M8_E16_MASK + { 7, &RISCVDescs.OperandInfo[742] }, // Inst #1479 = PseudoVDIV_VV_M8_E16 + { 8, &RISCVDescs.OperandInfo[734] }, // Inst #1478 = PseudoVDIV_VV_M4_E8_MASK + { 7, &RISCVDescs.OperandInfo[727] }, // Inst #1477 = PseudoVDIV_VV_M4_E8 + { 8, &RISCVDescs.OperandInfo[734] }, // Inst #1476 = PseudoVDIV_VV_M4_E64_MASK + { 7, &RISCVDescs.OperandInfo[727] }, // Inst #1475 = PseudoVDIV_VV_M4_E64 + { 8, &RISCVDescs.OperandInfo[734] }, // Inst #1474 = PseudoVDIV_VV_M4_E32_MASK + { 7, &RISCVDescs.OperandInfo[727] }, // Inst #1473 = PseudoVDIV_VV_M4_E32 + { 8, &RISCVDescs.OperandInfo[734] }, // Inst #1472 = PseudoVDIV_VV_M4_E16_MASK + { 7, &RISCVDescs.OperandInfo[727] }, // Inst #1471 = PseudoVDIV_VV_M4_E16 + { 8, &RISCVDescs.OperandInfo[719] }, // Inst #1470 = PseudoVDIV_VV_M2_E8_MASK + { 7, &RISCVDescs.OperandInfo[712] }, // Inst #1469 = PseudoVDIV_VV_M2_E8 + { 8, &RISCVDescs.OperandInfo[719] }, // Inst #1468 = PseudoVDIV_VV_M2_E64_MASK + { 7, &RISCVDescs.OperandInfo[712] }, // Inst #1467 = PseudoVDIV_VV_M2_E64 + { 8, &RISCVDescs.OperandInfo[719] }, // Inst #1466 = PseudoVDIV_VV_M2_E32_MASK + { 7, &RISCVDescs.OperandInfo[712] }, // Inst #1465 = PseudoVDIV_VV_M2_E32 + { 8, &RISCVDescs.OperandInfo[719] }, // Inst #1464 = PseudoVDIV_VV_M2_E16_MASK + { 7, &RISCVDescs.OperandInfo[712] }, // Inst #1463 = PseudoVDIV_VV_M2_E16 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #1462 = PseudoVDIV_VV_M1_E8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #1461 = PseudoVDIV_VV_M1_E8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #1460 = PseudoVDIV_VV_M1_E64_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #1459 = PseudoVDIV_VV_M1_E64 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #1458 = PseudoVDIV_VV_M1_E32_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #1457 = PseudoVDIV_VV_M1_E32 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #1456 = PseudoVDIV_VV_M1_E16_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #1455 = PseudoVDIV_VV_M1_E16 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #1454 = PseudoVDIVU_VX_MF8_E8_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #1453 = PseudoVDIVU_VX_MF8_E8 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #1452 = PseudoVDIVU_VX_MF4_E8_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #1451 = PseudoVDIVU_VX_MF4_E8 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #1450 = PseudoVDIVU_VX_MF4_E16_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #1449 = PseudoVDIVU_VX_MF4_E16 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #1448 = PseudoVDIVU_VX_MF2_E8_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #1447 = PseudoVDIVU_VX_MF2_E8 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #1446 = PseudoVDIVU_VX_MF2_E32_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #1445 = PseudoVDIVU_VX_MF2_E32 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #1444 = PseudoVDIVU_VX_MF2_E16_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #1443 = PseudoVDIVU_VX_MF2_E16 + { 8, &RISCVDescs.OperandInfo[809] }, // Inst #1442 = PseudoVDIVU_VX_M8_E8_MASK + { 7, &RISCVDescs.OperandInfo[802] }, // Inst #1441 = PseudoVDIVU_VX_M8_E8 + { 8, &RISCVDescs.OperandInfo[809] }, // Inst #1440 = PseudoVDIVU_VX_M8_E64_MASK + { 7, &RISCVDescs.OperandInfo[802] }, // Inst #1439 = PseudoVDIVU_VX_M8_E64 + { 8, &RISCVDescs.OperandInfo[809] }, // Inst #1438 = PseudoVDIVU_VX_M8_E32_MASK + { 7, &RISCVDescs.OperandInfo[802] }, // Inst #1437 = PseudoVDIVU_VX_M8_E32 + { 8, &RISCVDescs.OperandInfo[809] }, // Inst #1436 = PseudoVDIVU_VX_M8_E16_MASK + { 7, &RISCVDescs.OperandInfo[802] }, // Inst #1435 = PseudoVDIVU_VX_M8_E16 + { 8, &RISCVDescs.OperandInfo[794] }, // Inst #1434 = PseudoVDIVU_VX_M4_E8_MASK + { 7, &RISCVDescs.OperandInfo[787] }, // Inst #1433 = PseudoVDIVU_VX_M4_E8 + { 8, &RISCVDescs.OperandInfo[794] }, // Inst #1432 = PseudoVDIVU_VX_M4_E64_MASK + { 7, &RISCVDescs.OperandInfo[787] }, // Inst #1431 = PseudoVDIVU_VX_M4_E64 + { 8, &RISCVDescs.OperandInfo[794] }, // Inst #1430 = PseudoVDIVU_VX_M4_E32_MASK + { 7, &RISCVDescs.OperandInfo[787] }, // Inst #1429 = PseudoVDIVU_VX_M4_E32 + { 8, &RISCVDescs.OperandInfo[794] }, // Inst #1428 = PseudoVDIVU_VX_M4_E16_MASK + { 7, &RISCVDescs.OperandInfo[787] }, // Inst #1427 = PseudoVDIVU_VX_M4_E16 + { 8, &RISCVDescs.OperandInfo[779] }, // Inst #1426 = PseudoVDIVU_VX_M2_E8_MASK + { 7, &RISCVDescs.OperandInfo[772] }, // Inst #1425 = PseudoVDIVU_VX_M2_E8 + { 8, &RISCVDescs.OperandInfo[779] }, // Inst #1424 = PseudoVDIVU_VX_M2_E64_MASK + { 7, &RISCVDescs.OperandInfo[772] }, // Inst #1423 = PseudoVDIVU_VX_M2_E64 + { 8, &RISCVDescs.OperandInfo[779] }, // Inst #1422 = PseudoVDIVU_VX_M2_E32_MASK + { 7, &RISCVDescs.OperandInfo[772] }, // Inst #1421 = PseudoVDIVU_VX_M2_E32 + { 8, &RISCVDescs.OperandInfo[779] }, // Inst #1420 = PseudoVDIVU_VX_M2_E16_MASK + { 7, &RISCVDescs.OperandInfo[772] }, // Inst #1419 = PseudoVDIVU_VX_M2_E16 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #1418 = PseudoVDIVU_VX_M1_E8_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #1417 = PseudoVDIVU_VX_M1_E8 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #1416 = PseudoVDIVU_VX_M1_E64_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #1415 = PseudoVDIVU_VX_M1_E64 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #1414 = PseudoVDIVU_VX_M1_E32_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #1413 = PseudoVDIVU_VX_M1_E32 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #1412 = PseudoVDIVU_VX_M1_E16_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #1411 = PseudoVDIVU_VX_M1_E16 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #1410 = PseudoVDIVU_VV_MF8_E8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #1409 = PseudoVDIVU_VV_MF8_E8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #1408 = PseudoVDIVU_VV_MF4_E8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #1407 = PseudoVDIVU_VV_MF4_E8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #1406 = PseudoVDIVU_VV_MF4_E16_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #1405 = PseudoVDIVU_VV_MF4_E16 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #1404 = PseudoVDIVU_VV_MF2_E8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #1403 = PseudoVDIVU_VV_MF2_E8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #1402 = PseudoVDIVU_VV_MF2_E32_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #1401 = PseudoVDIVU_VV_MF2_E32 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #1400 = PseudoVDIVU_VV_MF2_E16_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #1399 = PseudoVDIVU_VV_MF2_E16 + { 8, &RISCVDescs.OperandInfo[749] }, // Inst #1398 = PseudoVDIVU_VV_M8_E8_MASK + { 7, &RISCVDescs.OperandInfo[742] }, // Inst #1397 = PseudoVDIVU_VV_M8_E8 + { 8, &RISCVDescs.OperandInfo[749] }, // Inst #1396 = PseudoVDIVU_VV_M8_E64_MASK + { 7, &RISCVDescs.OperandInfo[742] }, // Inst #1395 = PseudoVDIVU_VV_M8_E64 + { 8, &RISCVDescs.OperandInfo[749] }, // Inst #1394 = PseudoVDIVU_VV_M8_E32_MASK + { 7, &RISCVDescs.OperandInfo[742] }, // Inst #1393 = PseudoVDIVU_VV_M8_E32 + { 8, &RISCVDescs.OperandInfo[749] }, // Inst #1392 = PseudoVDIVU_VV_M8_E16_MASK + { 7, &RISCVDescs.OperandInfo[742] }, // Inst #1391 = PseudoVDIVU_VV_M8_E16 + { 8, &RISCVDescs.OperandInfo[734] }, // Inst #1390 = PseudoVDIVU_VV_M4_E8_MASK + { 7, &RISCVDescs.OperandInfo[727] }, // Inst #1389 = PseudoVDIVU_VV_M4_E8 + { 8, &RISCVDescs.OperandInfo[734] }, // Inst #1388 = PseudoVDIVU_VV_M4_E64_MASK + { 7, &RISCVDescs.OperandInfo[727] }, // Inst #1387 = PseudoVDIVU_VV_M4_E64 + { 8, &RISCVDescs.OperandInfo[734] }, // Inst #1386 = PseudoVDIVU_VV_M4_E32_MASK + { 7, &RISCVDescs.OperandInfo[727] }, // Inst #1385 = PseudoVDIVU_VV_M4_E32 + { 8, &RISCVDescs.OperandInfo[734] }, // Inst #1384 = PseudoVDIVU_VV_M4_E16_MASK + { 7, &RISCVDescs.OperandInfo[727] }, // Inst #1383 = PseudoVDIVU_VV_M4_E16 + { 8, &RISCVDescs.OperandInfo[719] }, // Inst #1382 = PseudoVDIVU_VV_M2_E8_MASK + { 7, &RISCVDescs.OperandInfo[712] }, // Inst #1381 = PseudoVDIVU_VV_M2_E8 + { 8, &RISCVDescs.OperandInfo[719] }, // Inst #1380 = PseudoVDIVU_VV_M2_E64_MASK + { 7, &RISCVDescs.OperandInfo[712] }, // Inst #1379 = PseudoVDIVU_VV_M2_E64 + { 8, &RISCVDescs.OperandInfo[719] }, // Inst #1378 = PseudoVDIVU_VV_M2_E32_MASK + { 7, &RISCVDescs.OperandInfo[712] }, // Inst #1377 = PseudoVDIVU_VV_M2_E32 + { 8, &RISCVDescs.OperandInfo[719] }, // Inst #1376 = PseudoVDIVU_VV_M2_E16_MASK + { 7, &RISCVDescs.OperandInfo[712] }, // Inst #1375 = PseudoVDIVU_VV_M2_E16 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #1374 = PseudoVDIVU_VV_M1_E8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #1373 = PseudoVDIVU_VV_M1_E8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #1372 = PseudoVDIVU_VV_M1_E64_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #1371 = PseudoVDIVU_VV_M1_E64 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #1370 = PseudoVDIVU_VV_M1_E32_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #1369 = PseudoVDIVU_VV_M1_E32 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #1368 = PseudoVDIVU_VV_M1_E16_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #1367 = PseudoVDIVU_VV_M1_E16 + { 6, &RISCVDescs.OperandInfo[1876] }, // Inst #1366 = PseudoVC_X_SE_MF8 + { 6, &RISCVDescs.OperandInfo[1876] }, // Inst #1365 = PseudoVC_X_SE_MF4 + { 6, &RISCVDescs.OperandInfo[1876] }, // Inst #1364 = PseudoVC_X_SE_MF2 + { 6, &RISCVDescs.OperandInfo[1876] }, // Inst #1363 = PseudoVC_X_SE_M8 + { 6, &RISCVDescs.OperandInfo[1876] }, // Inst #1362 = PseudoVC_X_SE_M4 + { 6, &RISCVDescs.OperandInfo[1876] }, // Inst #1361 = PseudoVC_X_SE_M2 + { 6, &RISCVDescs.OperandInfo[1876] }, // Inst #1360 = PseudoVC_X_SE_M1 + { 6, &RISCVDescs.OperandInfo[1852] }, // Inst #1359 = PseudoVC_XV_SE_MF8 + { 6, &RISCVDescs.OperandInfo[1852] }, // Inst #1358 = PseudoVC_XV_SE_MF4 + { 6, &RISCVDescs.OperandInfo[1852] }, // Inst #1357 = PseudoVC_XV_SE_MF2 + { 6, &RISCVDescs.OperandInfo[1870] }, // Inst #1356 = PseudoVC_XV_SE_M8 + { 6, &RISCVDescs.OperandInfo[1864] }, // Inst #1355 = PseudoVC_XV_SE_M4 + { 6, &RISCVDescs.OperandInfo[1858] }, // Inst #1354 = PseudoVC_XV_SE_M2 + { 6, &RISCVDescs.OperandInfo[1852] }, // Inst #1353 = PseudoVC_XV_SE_M1 + { 6, &RISCVDescs.OperandInfo[1810] }, // Inst #1352 = PseudoVC_XVW_SE_MF8 + { 6, &RISCVDescs.OperandInfo[1810] }, // Inst #1351 = PseudoVC_XVW_SE_MF4 + { 6, &RISCVDescs.OperandInfo[1810] }, // Inst #1350 = PseudoVC_XVW_SE_MF2 + { 6, &RISCVDescs.OperandInfo[1846] }, // Inst #1349 = PseudoVC_XVW_SE_M4 + { 6, &RISCVDescs.OperandInfo[1840] }, // Inst #1348 = PseudoVC_XVW_SE_M2 + { 6, &RISCVDescs.OperandInfo[1834] }, // Inst #1347 = PseudoVC_XVW_SE_M1 + { 6, &RISCVDescs.OperandInfo[1810] }, // Inst #1346 = PseudoVC_XVV_SE_MF8 + { 6, &RISCVDescs.OperandInfo[1810] }, // Inst #1345 = PseudoVC_XVV_SE_MF4 + { 6, &RISCVDescs.OperandInfo[1810] }, // Inst #1344 = PseudoVC_XVV_SE_MF2 + { 6, &RISCVDescs.OperandInfo[1828] }, // Inst #1343 = PseudoVC_XVV_SE_M8 + { 6, &RISCVDescs.OperandInfo[1822] }, // Inst #1342 = PseudoVC_XVV_SE_M4 + { 6, &RISCVDescs.OperandInfo[1816] }, // Inst #1341 = PseudoVC_XVV_SE_M2 + { 6, &RISCVDescs.OperandInfo[1810] }, // Inst #1340 = PseudoVC_XVV_SE_M1 + { 6, &RISCVDescs.OperandInfo[1786] }, // Inst #1339 = PseudoVC_V_X_SE_MF8 + { 6, &RISCVDescs.OperandInfo[1786] }, // Inst #1338 = PseudoVC_V_X_SE_MF4 + { 6, &RISCVDescs.OperandInfo[1786] }, // Inst #1337 = PseudoVC_V_X_SE_MF2 + { 6, &RISCVDescs.OperandInfo[1804] }, // Inst #1336 = PseudoVC_V_X_SE_M8 + { 6, &RISCVDescs.OperandInfo[1798] }, // Inst #1335 = PseudoVC_V_X_SE_M4 + { 6, &RISCVDescs.OperandInfo[1792] }, // Inst #1334 = PseudoVC_V_X_SE_M2 + { 6, &RISCVDescs.OperandInfo[1786] }, // Inst #1333 = PseudoVC_V_X_SE_M1 + { 6, &RISCVDescs.OperandInfo[1786] }, // Inst #1332 = PseudoVC_V_X_MF8 + { 6, &RISCVDescs.OperandInfo[1786] }, // Inst #1331 = PseudoVC_V_X_MF4 + { 6, &RISCVDescs.OperandInfo[1786] }, // Inst #1330 = PseudoVC_V_X_MF2 + { 6, &RISCVDescs.OperandInfo[1804] }, // Inst #1329 = PseudoVC_V_X_M8 + { 6, &RISCVDescs.OperandInfo[1798] }, // Inst #1328 = PseudoVC_V_X_M4 + { 6, &RISCVDescs.OperandInfo[1792] }, // Inst #1327 = PseudoVC_V_X_M2 + { 6, &RISCVDescs.OperandInfo[1786] }, // Inst #1326 = PseudoVC_V_X_M1 + { 6, &RISCVDescs.OperandInfo[1762] }, // Inst #1325 = PseudoVC_V_XV_SE_MF8 + { 6, &RISCVDescs.OperandInfo[1762] }, // Inst #1324 = PseudoVC_V_XV_SE_MF4 + { 6, &RISCVDescs.OperandInfo[1762] }, // Inst #1323 = PseudoVC_V_XV_SE_MF2 + { 6, &RISCVDescs.OperandInfo[1780] }, // Inst #1322 = PseudoVC_V_XV_SE_M8 + { 6, &RISCVDescs.OperandInfo[1774] }, // Inst #1321 = PseudoVC_V_XV_SE_M4 + { 6, &RISCVDescs.OperandInfo[1768] }, // Inst #1320 = PseudoVC_V_XV_SE_M2 + { 6, &RISCVDescs.OperandInfo[1762] }, // Inst #1319 = PseudoVC_V_XV_SE_M1 + { 6, &RISCVDescs.OperandInfo[1762] }, // Inst #1318 = PseudoVC_V_XV_MF8 + { 6, &RISCVDescs.OperandInfo[1762] }, // Inst #1317 = PseudoVC_V_XV_MF4 + { 6, &RISCVDescs.OperandInfo[1762] }, // Inst #1316 = PseudoVC_V_XV_MF2 + { 6, &RISCVDescs.OperandInfo[1780] }, // Inst #1315 = PseudoVC_V_XV_M8 + { 6, &RISCVDescs.OperandInfo[1774] }, // Inst #1314 = PseudoVC_V_XV_M4 + { 6, &RISCVDescs.OperandInfo[1768] }, // Inst #1313 = PseudoVC_V_XV_M2 + { 6, &RISCVDescs.OperandInfo[1762] }, // Inst #1312 = PseudoVC_V_XV_M1 + { 7, &RISCVDescs.OperandInfo[1755] }, // Inst #1311 = PseudoVC_V_XVW_SE_MF8 + { 7, &RISCVDescs.OperandInfo[1755] }, // Inst #1310 = PseudoVC_V_XVW_SE_MF4 + { 7, &RISCVDescs.OperandInfo[1755] }, // Inst #1309 = PseudoVC_V_XVW_SE_MF2 + { 7, &RISCVDescs.OperandInfo[1748] }, // Inst #1308 = PseudoVC_V_XVW_SE_M4 + { 7, &RISCVDescs.OperandInfo[1741] }, // Inst #1307 = PseudoVC_V_XVW_SE_M2 + { 7, &RISCVDescs.OperandInfo[1734] }, // Inst #1306 = PseudoVC_V_XVW_SE_M1 + { 7, &RISCVDescs.OperandInfo[1755] }, // Inst #1305 = PseudoVC_V_XVW_MF8 + { 7, &RISCVDescs.OperandInfo[1755] }, // Inst #1304 = PseudoVC_V_XVW_MF4 + { 7, &RISCVDescs.OperandInfo[1755] }, // Inst #1303 = PseudoVC_V_XVW_MF2 + { 7, &RISCVDescs.OperandInfo[1748] }, // Inst #1302 = PseudoVC_V_XVW_M4 + { 7, &RISCVDescs.OperandInfo[1741] }, // Inst #1301 = PseudoVC_V_XVW_M2 + { 7, &RISCVDescs.OperandInfo[1734] }, // Inst #1300 = PseudoVC_V_XVW_M1 + { 7, &RISCVDescs.OperandInfo[1706] }, // Inst #1299 = PseudoVC_V_XVV_SE_MF8 + { 7, &RISCVDescs.OperandInfo[1706] }, // Inst #1298 = PseudoVC_V_XVV_SE_MF4 + { 7, &RISCVDescs.OperandInfo[1706] }, // Inst #1297 = PseudoVC_V_XVV_SE_MF2 + { 7, &RISCVDescs.OperandInfo[1727] }, // Inst #1296 = PseudoVC_V_XVV_SE_M8 + { 7, &RISCVDescs.OperandInfo[1720] }, // Inst #1295 = PseudoVC_V_XVV_SE_M4 + { 7, &RISCVDescs.OperandInfo[1713] }, // Inst #1294 = PseudoVC_V_XVV_SE_M2 + { 7, &RISCVDescs.OperandInfo[1706] }, // Inst #1293 = PseudoVC_V_XVV_SE_M1 + { 7, &RISCVDescs.OperandInfo[1706] }, // Inst #1292 = PseudoVC_V_XVV_MF8 + { 7, &RISCVDescs.OperandInfo[1706] }, // Inst #1291 = PseudoVC_V_XVV_MF4 + { 7, &RISCVDescs.OperandInfo[1706] }, // Inst #1290 = PseudoVC_V_XVV_MF2 + { 7, &RISCVDescs.OperandInfo[1727] }, // Inst #1289 = PseudoVC_V_XVV_M8 + { 7, &RISCVDescs.OperandInfo[1720] }, // Inst #1288 = PseudoVC_V_XVV_M4 + { 7, &RISCVDescs.OperandInfo[1713] }, // Inst #1287 = PseudoVC_V_XVV_M2 + { 7, &RISCVDescs.OperandInfo[1706] }, // Inst #1286 = PseudoVC_V_XVV_M1 + { 6, &RISCVDescs.OperandInfo[1682] }, // Inst #1285 = PseudoVC_V_VV_SE_MF8 + { 6, &RISCVDescs.OperandInfo[1682] }, // Inst #1284 = PseudoVC_V_VV_SE_MF4 + { 6, &RISCVDescs.OperandInfo[1682] }, // Inst #1283 = PseudoVC_V_VV_SE_MF2 + { 6, &RISCVDescs.OperandInfo[1700] }, // Inst #1282 = PseudoVC_V_VV_SE_M8 + { 6, &RISCVDescs.OperandInfo[1694] }, // Inst #1281 = PseudoVC_V_VV_SE_M4 + { 6, &RISCVDescs.OperandInfo[1688] }, // Inst #1280 = PseudoVC_V_VV_SE_M2 + { 6, &RISCVDescs.OperandInfo[1682] }, // Inst #1279 = PseudoVC_V_VV_SE_M1 + { 6, &RISCVDescs.OperandInfo[1682] }, // Inst #1278 = PseudoVC_V_VV_MF8 + { 6, &RISCVDescs.OperandInfo[1682] }, // Inst #1277 = PseudoVC_V_VV_MF4 + { 6, &RISCVDescs.OperandInfo[1682] }, // Inst #1276 = PseudoVC_V_VV_MF2 + { 6, &RISCVDescs.OperandInfo[1700] }, // Inst #1275 = PseudoVC_V_VV_M8 + { 6, &RISCVDescs.OperandInfo[1694] }, // Inst #1274 = PseudoVC_V_VV_M4 + { 6, &RISCVDescs.OperandInfo[1688] }, // Inst #1273 = PseudoVC_V_VV_M2 + { 6, &RISCVDescs.OperandInfo[1682] }, // Inst #1272 = PseudoVC_V_VV_M1 + { 7, &RISCVDescs.OperandInfo[1675] }, // Inst #1271 = PseudoVC_V_VVW_SE_MF8 + { 7, &RISCVDescs.OperandInfo[1675] }, // Inst #1270 = PseudoVC_V_VVW_SE_MF4 + { 7, &RISCVDescs.OperandInfo[1675] }, // Inst #1269 = PseudoVC_V_VVW_SE_MF2 + { 7, &RISCVDescs.OperandInfo[1668] }, // Inst #1268 = PseudoVC_V_VVW_SE_M4 + { 7, &RISCVDescs.OperandInfo[1661] }, // Inst #1267 = PseudoVC_V_VVW_SE_M2 + { 7, &RISCVDescs.OperandInfo[1654] }, // Inst #1266 = PseudoVC_V_VVW_SE_M1 + { 7, &RISCVDescs.OperandInfo[1675] }, // Inst #1265 = PseudoVC_V_VVW_MF8 + { 7, &RISCVDescs.OperandInfo[1675] }, // Inst #1264 = PseudoVC_V_VVW_MF4 + { 7, &RISCVDescs.OperandInfo[1675] }, // Inst #1263 = PseudoVC_V_VVW_MF2 + { 7, &RISCVDescs.OperandInfo[1668] }, // Inst #1262 = PseudoVC_V_VVW_M4 + { 7, &RISCVDescs.OperandInfo[1661] }, // Inst #1261 = PseudoVC_V_VVW_M2 + { 7, &RISCVDescs.OperandInfo[1654] }, // Inst #1260 = PseudoVC_V_VVW_M1 + { 7, &RISCVDescs.OperandInfo[1626] }, // Inst #1259 = PseudoVC_V_VVV_SE_MF8 + { 7, &RISCVDescs.OperandInfo[1626] }, // Inst #1258 = PseudoVC_V_VVV_SE_MF4 + { 7, &RISCVDescs.OperandInfo[1626] }, // Inst #1257 = PseudoVC_V_VVV_SE_MF2 + { 7, &RISCVDescs.OperandInfo[1647] }, // Inst #1256 = PseudoVC_V_VVV_SE_M8 + { 7, &RISCVDescs.OperandInfo[1640] }, // Inst #1255 = PseudoVC_V_VVV_SE_M4 + { 7, &RISCVDescs.OperandInfo[1633] }, // Inst #1254 = PseudoVC_V_VVV_SE_M2 + { 7, &RISCVDescs.OperandInfo[1626] }, // Inst #1253 = PseudoVC_V_VVV_SE_M1 + { 7, &RISCVDescs.OperandInfo[1626] }, // Inst #1252 = PseudoVC_V_VVV_MF8 + { 7, &RISCVDescs.OperandInfo[1626] }, // Inst #1251 = PseudoVC_V_VVV_MF4 + { 7, &RISCVDescs.OperandInfo[1626] }, // Inst #1250 = PseudoVC_V_VVV_MF2 + { 7, &RISCVDescs.OperandInfo[1647] }, // Inst #1249 = PseudoVC_V_VVV_M8 + { 7, &RISCVDescs.OperandInfo[1640] }, // Inst #1248 = PseudoVC_V_VVV_M4 + { 7, &RISCVDescs.OperandInfo[1633] }, // Inst #1247 = PseudoVC_V_VVV_M2 + { 7, &RISCVDescs.OperandInfo[1626] }, // Inst #1246 = PseudoVC_V_VVV_M1 + { 6, &RISCVDescs.OperandInfo[1602] }, // Inst #1245 = PseudoVC_V_I_SE_MF8 + { 6, &RISCVDescs.OperandInfo[1602] }, // Inst #1244 = PseudoVC_V_I_SE_MF4 + { 6, &RISCVDescs.OperandInfo[1602] }, // Inst #1243 = PseudoVC_V_I_SE_MF2 + { 6, &RISCVDescs.OperandInfo[1620] }, // Inst #1242 = PseudoVC_V_I_SE_M8 + { 6, &RISCVDescs.OperandInfo[1614] }, // Inst #1241 = PseudoVC_V_I_SE_M4 + { 6, &RISCVDescs.OperandInfo[1608] }, // Inst #1240 = PseudoVC_V_I_SE_M2 + { 6, &RISCVDescs.OperandInfo[1602] }, // Inst #1239 = PseudoVC_V_I_SE_M1 + { 6, &RISCVDescs.OperandInfo[1602] }, // Inst #1238 = PseudoVC_V_I_MF8 + { 6, &RISCVDescs.OperandInfo[1602] }, // Inst #1237 = PseudoVC_V_I_MF4 + { 6, &RISCVDescs.OperandInfo[1602] }, // Inst #1236 = PseudoVC_V_I_MF2 + { 6, &RISCVDescs.OperandInfo[1620] }, // Inst #1235 = PseudoVC_V_I_M8 + { 6, &RISCVDescs.OperandInfo[1614] }, // Inst #1234 = PseudoVC_V_I_M4 + { 6, &RISCVDescs.OperandInfo[1608] }, // Inst #1233 = PseudoVC_V_I_M2 + { 6, &RISCVDescs.OperandInfo[1602] }, // Inst #1232 = PseudoVC_V_I_M1 + { 6, &RISCVDescs.OperandInfo[1578] }, // Inst #1231 = PseudoVC_V_IV_SE_MF8 + { 6, &RISCVDescs.OperandInfo[1578] }, // Inst #1230 = PseudoVC_V_IV_SE_MF4 + { 6, &RISCVDescs.OperandInfo[1578] }, // Inst #1229 = PseudoVC_V_IV_SE_MF2 + { 6, &RISCVDescs.OperandInfo[1596] }, // Inst #1228 = PseudoVC_V_IV_SE_M8 + { 6, &RISCVDescs.OperandInfo[1590] }, // Inst #1227 = PseudoVC_V_IV_SE_M4 + { 6, &RISCVDescs.OperandInfo[1584] }, // Inst #1226 = PseudoVC_V_IV_SE_M2 + { 6, &RISCVDescs.OperandInfo[1578] }, // Inst #1225 = PseudoVC_V_IV_SE_M1 + { 6, &RISCVDescs.OperandInfo[1578] }, // Inst #1224 = PseudoVC_V_IV_MF8 + { 6, &RISCVDescs.OperandInfo[1578] }, // Inst #1223 = PseudoVC_V_IV_MF4 + { 6, &RISCVDescs.OperandInfo[1578] }, // Inst #1222 = PseudoVC_V_IV_MF2 + { 6, &RISCVDescs.OperandInfo[1596] }, // Inst #1221 = PseudoVC_V_IV_M8 + { 6, &RISCVDescs.OperandInfo[1590] }, // Inst #1220 = PseudoVC_V_IV_M4 + { 6, &RISCVDescs.OperandInfo[1584] }, // Inst #1219 = PseudoVC_V_IV_M2 + { 6, &RISCVDescs.OperandInfo[1578] }, // Inst #1218 = PseudoVC_V_IV_M1 + { 7, &RISCVDescs.OperandInfo[1571] }, // Inst #1217 = PseudoVC_V_IVW_SE_MF8 + { 7, &RISCVDescs.OperandInfo[1571] }, // Inst #1216 = PseudoVC_V_IVW_SE_MF4 + { 7, &RISCVDescs.OperandInfo[1571] }, // Inst #1215 = PseudoVC_V_IVW_SE_MF2 + { 7, &RISCVDescs.OperandInfo[1564] }, // Inst #1214 = PseudoVC_V_IVW_SE_M4 + { 7, &RISCVDescs.OperandInfo[1557] }, // Inst #1213 = PseudoVC_V_IVW_SE_M2 + { 7, &RISCVDescs.OperandInfo[1550] }, // Inst #1212 = PseudoVC_V_IVW_SE_M1 + { 7, &RISCVDescs.OperandInfo[1571] }, // Inst #1211 = PseudoVC_V_IVW_MF8 + { 7, &RISCVDescs.OperandInfo[1571] }, // Inst #1210 = PseudoVC_V_IVW_MF4 + { 7, &RISCVDescs.OperandInfo[1571] }, // Inst #1209 = PseudoVC_V_IVW_MF2 + { 7, &RISCVDescs.OperandInfo[1564] }, // Inst #1208 = PseudoVC_V_IVW_M4 + { 7, &RISCVDescs.OperandInfo[1557] }, // Inst #1207 = PseudoVC_V_IVW_M2 + { 7, &RISCVDescs.OperandInfo[1550] }, // Inst #1206 = PseudoVC_V_IVW_M1 + { 7, &RISCVDescs.OperandInfo[1522] }, // Inst #1205 = PseudoVC_V_IVV_SE_MF8 + { 7, &RISCVDescs.OperandInfo[1522] }, // Inst #1204 = PseudoVC_V_IVV_SE_MF4 + { 7, &RISCVDescs.OperandInfo[1522] }, // Inst #1203 = PseudoVC_V_IVV_SE_MF2 + { 7, &RISCVDescs.OperandInfo[1543] }, // Inst #1202 = PseudoVC_V_IVV_SE_M8 + { 7, &RISCVDescs.OperandInfo[1536] }, // Inst #1201 = PseudoVC_V_IVV_SE_M4 + { 7, &RISCVDescs.OperandInfo[1529] }, // Inst #1200 = PseudoVC_V_IVV_SE_M2 + { 7, &RISCVDescs.OperandInfo[1522] }, // Inst #1199 = PseudoVC_V_IVV_SE_M1 + { 7, &RISCVDescs.OperandInfo[1522] }, // Inst #1198 = PseudoVC_V_IVV_MF8 + { 7, &RISCVDescs.OperandInfo[1522] }, // Inst #1197 = PseudoVC_V_IVV_MF4 + { 7, &RISCVDescs.OperandInfo[1522] }, // Inst #1196 = PseudoVC_V_IVV_MF2 + { 7, &RISCVDescs.OperandInfo[1543] }, // Inst #1195 = PseudoVC_V_IVV_M8 + { 7, &RISCVDescs.OperandInfo[1536] }, // Inst #1194 = PseudoVC_V_IVV_M4 + { 7, &RISCVDescs.OperandInfo[1529] }, // Inst #1193 = PseudoVC_V_IVV_M2 + { 7, &RISCVDescs.OperandInfo[1522] }, // Inst #1192 = PseudoVC_V_IVV_M1 + { 6, &RISCVDescs.OperandInfo[1516] }, // Inst #1191 = PseudoVC_V_FPR64V_SE_M8 + { 6, &RISCVDescs.OperandInfo[1510] }, // Inst #1190 = PseudoVC_V_FPR64V_SE_M4 + { 6, &RISCVDescs.OperandInfo[1504] }, // Inst #1189 = PseudoVC_V_FPR64V_SE_M2 + { 6, &RISCVDescs.OperandInfo[1498] }, // Inst #1188 = PseudoVC_V_FPR64V_SE_M1 + { 6, &RISCVDescs.OperandInfo[1516] }, // Inst #1187 = PseudoVC_V_FPR64V_M8 + { 6, &RISCVDescs.OperandInfo[1510] }, // Inst #1186 = PseudoVC_V_FPR64V_M4 + { 6, &RISCVDescs.OperandInfo[1504] }, // Inst #1185 = PseudoVC_V_FPR64V_M2 + { 6, &RISCVDescs.OperandInfo[1498] }, // Inst #1184 = PseudoVC_V_FPR64V_M1 + { 7, &RISCVDescs.OperandInfo[1491] }, // Inst #1183 = PseudoVC_V_FPR64VV_SE_M8 + { 7, &RISCVDescs.OperandInfo[1484] }, // Inst #1182 = PseudoVC_V_FPR64VV_SE_M4 + { 7, &RISCVDescs.OperandInfo[1477] }, // Inst #1181 = PseudoVC_V_FPR64VV_SE_M2 + { 7, &RISCVDescs.OperandInfo[1470] }, // Inst #1180 = PseudoVC_V_FPR64VV_SE_M1 + { 7, &RISCVDescs.OperandInfo[1491] }, // Inst #1179 = PseudoVC_V_FPR64VV_M8 + { 7, &RISCVDescs.OperandInfo[1484] }, // Inst #1178 = PseudoVC_V_FPR64VV_M4 + { 7, &RISCVDescs.OperandInfo[1477] }, // Inst #1177 = PseudoVC_V_FPR64VV_M2 + { 7, &RISCVDescs.OperandInfo[1470] }, // Inst #1176 = PseudoVC_V_FPR64VV_M1 + { 6, &RISCVDescs.OperandInfo[1446] }, // Inst #1175 = PseudoVC_V_FPR32V_SE_MF2 + { 6, &RISCVDescs.OperandInfo[1464] }, // Inst #1174 = PseudoVC_V_FPR32V_SE_M8 + { 6, &RISCVDescs.OperandInfo[1458] }, // Inst #1173 = PseudoVC_V_FPR32V_SE_M4 + { 6, &RISCVDescs.OperandInfo[1452] }, // Inst #1172 = PseudoVC_V_FPR32V_SE_M2 + { 6, &RISCVDescs.OperandInfo[1446] }, // Inst #1171 = PseudoVC_V_FPR32V_SE_M1 + { 6, &RISCVDescs.OperandInfo[1446] }, // Inst #1170 = PseudoVC_V_FPR32V_MF2 + { 6, &RISCVDescs.OperandInfo[1464] }, // Inst #1169 = PseudoVC_V_FPR32V_M8 + { 6, &RISCVDescs.OperandInfo[1458] }, // Inst #1168 = PseudoVC_V_FPR32V_M4 + { 6, &RISCVDescs.OperandInfo[1452] }, // Inst #1167 = PseudoVC_V_FPR32V_M2 + { 6, &RISCVDescs.OperandInfo[1446] }, // Inst #1166 = PseudoVC_V_FPR32V_M1 + { 7, &RISCVDescs.OperandInfo[1439] }, // Inst #1165 = PseudoVC_V_FPR32VW_SE_MF2 + { 7, &RISCVDescs.OperandInfo[1432] }, // Inst #1164 = PseudoVC_V_FPR32VW_SE_M8 + { 7, &RISCVDescs.OperandInfo[1425] }, // Inst #1163 = PseudoVC_V_FPR32VW_SE_M4 + { 7, &RISCVDescs.OperandInfo[1418] }, // Inst #1162 = PseudoVC_V_FPR32VW_SE_M2 + { 7, &RISCVDescs.OperandInfo[1411] }, // Inst #1161 = PseudoVC_V_FPR32VW_SE_M1 + { 7, &RISCVDescs.OperandInfo[1439] }, // Inst #1160 = PseudoVC_V_FPR32VW_MF2 + { 7, &RISCVDescs.OperandInfo[1432] }, // Inst #1159 = PseudoVC_V_FPR32VW_M8 + { 7, &RISCVDescs.OperandInfo[1425] }, // Inst #1158 = PseudoVC_V_FPR32VW_M4 + { 7, &RISCVDescs.OperandInfo[1418] }, // Inst #1157 = PseudoVC_V_FPR32VW_M2 + { 7, &RISCVDescs.OperandInfo[1411] }, // Inst #1156 = PseudoVC_V_FPR32VW_M1 + { 7, &RISCVDescs.OperandInfo[1383] }, // Inst #1155 = PseudoVC_V_FPR32VV_SE_MF2 + { 7, &RISCVDescs.OperandInfo[1404] }, // Inst #1154 = PseudoVC_V_FPR32VV_SE_M8 + { 7, &RISCVDescs.OperandInfo[1397] }, // Inst #1153 = PseudoVC_V_FPR32VV_SE_M4 + { 7, &RISCVDescs.OperandInfo[1390] }, // Inst #1152 = PseudoVC_V_FPR32VV_SE_M2 + { 7, &RISCVDescs.OperandInfo[1383] }, // Inst #1151 = PseudoVC_V_FPR32VV_SE_M1 + { 7, &RISCVDescs.OperandInfo[1383] }, // Inst #1150 = PseudoVC_V_FPR32VV_MF2 + { 7, &RISCVDescs.OperandInfo[1404] }, // Inst #1149 = PseudoVC_V_FPR32VV_M8 + { 7, &RISCVDescs.OperandInfo[1397] }, // Inst #1148 = PseudoVC_V_FPR32VV_M4 + { 7, &RISCVDescs.OperandInfo[1390] }, // Inst #1147 = PseudoVC_V_FPR32VV_M2 + { 7, &RISCVDescs.OperandInfo[1383] }, // Inst #1146 = PseudoVC_V_FPR32VV_M1 + { 6, &RISCVDescs.OperandInfo[1359] }, // Inst #1145 = PseudoVC_V_FPR16V_SE_MF4 + { 6, &RISCVDescs.OperandInfo[1359] }, // Inst #1144 = PseudoVC_V_FPR16V_SE_MF2 + { 6, &RISCVDescs.OperandInfo[1377] }, // Inst #1143 = PseudoVC_V_FPR16V_SE_M8 + { 6, &RISCVDescs.OperandInfo[1371] }, // Inst #1142 = PseudoVC_V_FPR16V_SE_M4 + { 6, &RISCVDescs.OperandInfo[1365] }, // Inst #1141 = PseudoVC_V_FPR16V_SE_M2 + { 6, &RISCVDescs.OperandInfo[1359] }, // Inst #1140 = PseudoVC_V_FPR16V_SE_M1 + { 6, &RISCVDescs.OperandInfo[1359] }, // Inst #1139 = PseudoVC_V_FPR16V_MF4 + { 6, &RISCVDescs.OperandInfo[1359] }, // Inst #1138 = PseudoVC_V_FPR16V_MF2 + { 6, &RISCVDescs.OperandInfo[1377] }, // Inst #1137 = PseudoVC_V_FPR16V_M8 + { 6, &RISCVDescs.OperandInfo[1371] }, // Inst #1136 = PseudoVC_V_FPR16V_M4 + { 6, &RISCVDescs.OperandInfo[1365] }, // Inst #1135 = PseudoVC_V_FPR16V_M2 + { 6, &RISCVDescs.OperandInfo[1359] }, // Inst #1134 = PseudoVC_V_FPR16V_M1 + { 7, &RISCVDescs.OperandInfo[1352] }, // Inst #1133 = PseudoVC_V_FPR16VW_SE_MF4 + { 7, &RISCVDescs.OperandInfo[1352] }, // Inst #1132 = PseudoVC_V_FPR16VW_SE_MF2 + { 7, &RISCVDescs.OperandInfo[1345] }, // Inst #1131 = PseudoVC_V_FPR16VW_SE_M8 + { 7, &RISCVDescs.OperandInfo[1338] }, // Inst #1130 = PseudoVC_V_FPR16VW_SE_M4 + { 7, &RISCVDescs.OperandInfo[1331] }, // Inst #1129 = PseudoVC_V_FPR16VW_SE_M2 + { 7, &RISCVDescs.OperandInfo[1324] }, // Inst #1128 = PseudoVC_V_FPR16VW_SE_M1 + { 7, &RISCVDescs.OperandInfo[1352] }, // Inst #1127 = PseudoVC_V_FPR16VW_MF4 + { 7, &RISCVDescs.OperandInfo[1352] }, // Inst #1126 = PseudoVC_V_FPR16VW_MF2 + { 7, &RISCVDescs.OperandInfo[1345] }, // Inst #1125 = PseudoVC_V_FPR16VW_M8 + { 7, &RISCVDescs.OperandInfo[1338] }, // Inst #1124 = PseudoVC_V_FPR16VW_M4 + { 7, &RISCVDescs.OperandInfo[1331] }, // Inst #1123 = PseudoVC_V_FPR16VW_M2 + { 7, &RISCVDescs.OperandInfo[1324] }, // Inst #1122 = PseudoVC_V_FPR16VW_M1 + { 7, &RISCVDescs.OperandInfo[1296] }, // Inst #1121 = PseudoVC_V_FPR16VV_SE_MF4 + { 7, &RISCVDescs.OperandInfo[1296] }, // Inst #1120 = PseudoVC_V_FPR16VV_SE_MF2 + { 7, &RISCVDescs.OperandInfo[1317] }, // Inst #1119 = PseudoVC_V_FPR16VV_SE_M8 + { 7, &RISCVDescs.OperandInfo[1310] }, // Inst #1118 = PseudoVC_V_FPR16VV_SE_M4 + { 7, &RISCVDescs.OperandInfo[1303] }, // Inst #1117 = PseudoVC_V_FPR16VV_SE_M2 + { 7, &RISCVDescs.OperandInfo[1296] }, // Inst #1116 = PseudoVC_V_FPR16VV_SE_M1 + { 7, &RISCVDescs.OperandInfo[1296] }, // Inst #1115 = PseudoVC_V_FPR16VV_MF4 + { 7, &RISCVDescs.OperandInfo[1296] }, // Inst #1114 = PseudoVC_V_FPR16VV_MF2 + { 7, &RISCVDescs.OperandInfo[1317] }, // Inst #1113 = PseudoVC_V_FPR16VV_M8 + { 7, &RISCVDescs.OperandInfo[1310] }, // Inst #1112 = PseudoVC_V_FPR16VV_M4 + { 7, &RISCVDescs.OperandInfo[1303] }, // Inst #1111 = PseudoVC_V_FPR16VV_M2 + { 7, &RISCVDescs.OperandInfo[1296] }, // Inst #1110 = PseudoVC_V_FPR16VV_M1 + { 6, &RISCVDescs.OperandInfo[1272] }, // Inst #1109 = PseudoVC_VV_SE_MF8 + { 6, &RISCVDescs.OperandInfo[1272] }, // Inst #1108 = PseudoVC_VV_SE_MF4 + { 6, &RISCVDescs.OperandInfo[1272] }, // Inst #1107 = PseudoVC_VV_SE_MF2 + { 6, &RISCVDescs.OperandInfo[1290] }, // Inst #1106 = PseudoVC_VV_SE_M8 + { 6, &RISCVDescs.OperandInfo[1284] }, // Inst #1105 = PseudoVC_VV_SE_M4 + { 6, &RISCVDescs.OperandInfo[1278] }, // Inst #1104 = PseudoVC_VV_SE_M2 + { 6, &RISCVDescs.OperandInfo[1272] }, // Inst #1103 = PseudoVC_VV_SE_M1 + { 6, &RISCVDescs.OperandInfo[1230] }, // Inst #1102 = PseudoVC_VVW_SE_MF8 + { 6, &RISCVDescs.OperandInfo[1230] }, // Inst #1101 = PseudoVC_VVW_SE_MF4 + { 6, &RISCVDescs.OperandInfo[1230] }, // Inst #1100 = PseudoVC_VVW_SE_MF2 + { 6, &RISCVDescs.OperandInfo[1266] }, // Inst #1099 = PseudoVC_VVW_SE_M4 + { 6, &RISCVDescs.OperandInfo[1260] }, // Inst #1098 = PseudoVC_VVW_SE_M2 + { 6, &RISCVDescs.OperandInfo[1254] }, // Inst #1097 = PseudoVC_VVW_SE_M1 + { 6, &RISCVDescs.OperandInfo[1230] }, // Inst #1096 = PseudoVC_VVV_SE_MF8 + { 6, &RISCVDescs.OperandInfo[1230] }, // Inst #1095 = PseudoVC_VVV_SE_MF4 + { 6, &RISCVDescs.OperandInfo[1230] }, // Inst #1094 = PseudoVC_VVV_SE_MF2 + { 6, &RISCVDescs.OperandInfo[1248] }, // Inst #1093 = PseudoVC_VVV_SE_M8 + { 6, &RISCVDescs.OperandInfo[1242] }, // Inst #1092 = PseudoVC_VVV_SE_M4 + { 6, &RISCVDescs.OperandInfo[1236] }, // Inst #1091 = PseudoVC_VVV_SE_M2 + { 6, &RISCVDescs.OperandInfo[1230] }, // Inst #1090 = PseudoVC_VVV_SE_M1 + { 6, &RISCVDescs.OperandInfo[1224] }, // Inst #1089 = PseudoVC_I_SE_MF8 + { 6, &RISCVDescs.OperandInfo[1224] }, // Inst #1088 = PseudoVC_I_SE_MF4 + { 6, &RISCVDescs.OperandInfo[1224] }, // Inst #1087 = PseudoVC_I_SE_MF2 + { 6, &RISCVDescs.OperandInfo[1224] }, // Inst #1086 = PseudoVC_I_SE_M8 + { 6, &RISCVDescs.OperandInfo[1224] }, // Inst #1085 = PseudoVC_I_SE_M4 + { 6, &RISCVDescs.OperandInfo[1224] }, // Inst #1084 = PseudoVC_I_SE_M2 + { 6, &RISCVDescs.OperandInfo[1224] }, // Inst #1083 = PseudoVC_I_SE_M1 + { 6, &RISCVDescs.OperandInfo[1200] }, // Inst #1082 = PseudoVC_IV_SE_MF8 + { 6, &RISCVDescs.OperandInfo[1200] }, // Inst #1081 = PseudoVC_IV_SE_MF4 + { 6, &RISCVDescs.OperandInfo[1200] }, // Inst #1080 = PseudoVC_IV_SE_MF2 + { 6, &RISCVDescs.OperandInfo[1218] }, // Inst #1079 = PseudoVC_IV_SE_M8 + { 6, &RISCVDescs.OperandInfo[1212] }, // Inst #1078 = PseudoVC_IV_SE_M4 + { 6, &RISCVDescs.OperandInfo[1206] }, // Inst #1077 = PseudoVC_IV_SE_M2 + { 6, &RISCVDescs.OperandInfo[1200] }, // Inst #1076 = PseudoVC_IV_SE_M1 + { 6, &RISCVDescs.OperandInfo[1158] }, // Inst #1075 = PseudoVC_IVW_SE_MF8 + { 6, &RISCVDescs.OperandInfo[1158] }, // Inst #1074 = PseudoVC_IVW_SE_MF4 + { 6, &RISCVDescs.OperandInfo[1158] }, // Inst #1073 = PseudoVC_IVW_SE_MF2 + { 6, &RISCVDescs.OperandInfo[1194] }, // Inst #1072 = PseudoVC_IVW_SE_M4 + { 6, &RISCVDescs.OperandInfo[1188] }, // Inst #1071 = PseudoVC_IVW_SE_M2 + { 6, &RISCVDescs.OperandInfo[1182] }, // Inst #1070 = PseudoVC_IVW_SE_M1 + { 6, &RISCVDescs.OperandInfo[1158] }, // Inst #1069 = PseudoVC_IVV_SE_MF8 + { 6, &RISCVDescs.OperandInfo[1158] }, // Inst #1068 = PseudoVC_IVV_SE_MF4 + { 6, &RISCVDescs.OperandInfo[1158] }, // Inst #1067 = PseudoVC_IVV_SE_MF2 + { 6, &RISCVDescs.OperandInfo[1176] }, // Inst #1066 = PseudoVC_IVV_SE_M8 + { 6, &RISCVDescs.OperandInfo[1170] }, // Inst #1065 = PseudoVC_IVV_SE_M4 + { 6, &RISCVDescs.OperandInfo[1164] }, // Inst #1064 = PseudoVC_IVV_SE_M2 + { 6, &RISCVDescs.OperandInfo[1158] }, // Inst #1063 = PseudoVC_IVV_SE_M1 + { 6, &RISCVDescs.OperandInfo[1152] }, // Inst #1062 = PseudoVC_FPR64V_SE_M8 + { 6, &RISCVDescs.OperandInfo[1146] }, // Inst #1061 = PseudoVC_FPR64V_SE_M4 + { 6, &RISCVDescs.OperandInfo[1140] }, // Inst #1060 = PseudoVC_FPR64V_SE_M2 + { 6, &RISCVDescs.OperandInfo[1134] }, // Inst #1059 = PseudoVC_FPR64V_SE_M1 + { 6, &RISCVDescs.OperandInfo[1128] }, // Inst #1058 = PseudoVC_FPR64VV_SE_M8 + { 6, &RISCVDescs.OperandInfo[1122] }, // Inst #1057 = PseudoVC_FPR64VV_SE_M4 + { 6, &RISCVDescs.OperandInfo[1116] }, // Inst #1056 = PseudoVC_FPR64VV_SE_M2 + { 6, &RISCVDescs.OperandInfo[1110] }, // Inst #1055 = PseudoVC_FPR64VV_SE_M1 + { 6, &RISCVDescs.OperandInfo[1086] }, // Inst #1054 = PseudoVC_FPR32V_SE_MF2 + { 6, &RISCVDescs.OperandInfo[1104] }, // Inst #1053 = PseudoVC_FPR32V_SE_M8 + { 6, &RISCVDescs.OperandInfo[1098] }, // Inst #1052 = PseudoVC_FPR32V_SE_M4 + { 6, &RISCVDescs.OperandInfo[1092] }, // Inst #1051 = PseudoVC_FPR32V_SE_M2 + { 6, &RISCVDescs.OperandInfo[1086] }, // Inst #1050 = PseudoVC_FPR32V_SE_M1 + { 6, &RISCVDescs.OperandInfo[1038] }, // Inst #1049 = PseudoVC_FPR32VW_SE_MF2 + { 6, &RISCVDescs.OperandInfo[1080] }, // Inst #1048 = PseudoVC_FPR32VW_SE_M8 + { 6, &RISCVDescs.OperandInfo[1074] }, // Inst #1047 = PseudoVC_FPR32VW_SE_M4 + { 6, &RISCVDescs.OperandInfo[1068] }, // Inst #1046 = PseudoVC_FPR32VW_SE_M2 + { 6, &RISCVDescs.OperandInfo[1062] }, // Inst #1045 = PseudoVC_FPR32VW_SE_M1 + { 6, &RISCVDescs.OperandInfo[1038] }, // Inst #1044 = PseudoVC_FPR32VV_SE_MF2 + { 6, &RISCVDescs.OperandInfo[1056] }, // Inst #1043 = PseudoVC_FPR32VV_SE_M8 + { 6, &RISCVDescs.OperandInfo[1050] }, // Inst #1042 = PseudoVC_FPR32VV_SE_M4 + { 6, &RISCVDescs.OperandInfo[1044] }, // Inst #1041 = PseudoVC_FPR32VV_SE_M2 + { 6, &RISCVDescs.OperandInfo[1038] }, // Inst #1040 = PseudoVC_FPR32VV_SE_M1 + { 6, &RISCVDescs.OperandInfo[1014] }, // Inst #1039 = PseudoVC_FPR16V_SE_MF4 + { 6, &RISCVDescs.OperandInfo[1014] }, // Inst #1038 = PseudoVC_FPR16V_SE_MF2 + { 6, &RISCVDescs.OperandInfo[1032] }, // Inst #1037 = PseudoVC_FPR16V_SE_M8 + { 6, &RISCVDescs.OperandInfo[1026] }, // Inst #1036 = PseudoVC_FPR16V_SE_M4 + { 6, &RISCVDescs.OperandInfo[1020] }, // Inst #1035 = PseudoVC_FPR16V_SE_M2 + { 6, &RISCVDescs.OperandInfo[1014] }, // Inst #1034 = PseudoVC_FPR16V_SE_M1 + { 6, &RISCVDescs.OperandInfo[966] }, // Inst #1033 = PseudoVC_FPR16VW_SE_MF4 + { 6, &RISCVDescs.OperandInfo[966] }, // Inst #1032 = PseudoVC_FPR16VW_SE_MF2 + { 6, &RISCVDescs.OperandInfo[1008] }, // Inst #1031 = PseudoVC_FPR16VW_SE_M8 + { 6, &RISCVDescs.OperandInfo[1002] }, // Inst #1030 = PseudoVC_FPR16VW_SE_M4 + { 6, &RISCVDescs.OperandInfo[996] }, // Inst #1029 = PseudoVC_FPR16VW_SE_M2 + { 6, &RISCVDescs.OperandInfo[990] }, // Inst #1028 = PseudoVC_FPR16VW_SE_M1 + { 6, &RISCVDescs.OperandInfo[966] }, // Inst #1027 = PseudoVC_FPR16VV_SE_MF4 + { 6, &RISCVDescs.OperandInfo[966] }, // Inst #1026 = PseudoVC_FPR16VV_SE_MF2 + { 6, &RISCVDescs.OperandInfo[984] }, // Inst #1025 = PseudoVC_FPR16VV_SE_M8 + { 6, &RISCVDescs.OperandInfo[978] }, // Inst #1024 = PseudoVC_FPR16VV_SE_M4 + { 6, &RISCVDescs.OperandInfo[972] }, // Inst #1023 = PseudoVC_FPR16VV_SE_M2 + { 6, &RISCVDescs.OperandInfo[966] }, // Inst #1022 = PseudoVC_FPR16VV_SE_M1 + { 7, &RISCVDescs.OperandInfo[905] }, // Inst #1021 = PseudoVCTZ_V_MF8_MASK + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #1020 = PseudoVCTZ_V_MF8 + { 7, &RISCVDescs.OperandInfo[905] }, // Inst #1019 = PseudoVCTZ_V_MF4_MASK + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #1018 = PseudoVCTZ_V_MF4 + { 7, &RISCVDescs.OperandInfo[905] }, // Inst #1017 = PseudoVCTZ_V_MF2_MASK + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #1016 = PseudoVCTZ_V_MF2 + { 7, &RISCVDescs.OperandInfo[926] }, // Inst #1015 = PseudoVCTZ_V_M8_MASK + { 6, &RISCVDescs.OperandInfo[871] }, // Inst #1014 = PseudoVCTZ_V_M8 + { 7, &RISCVDescs.OperandInfo[919] }, // Inst #1013 = PseudoVCTZ_V_M4_MASK + { 6, &RISCVDescs.OperandInfo[847] }, // Inst #1012 = PseudoVCTZ_V_M4 + { 7, &RISCVDescs.OperandInfo[912] }, // Inst #1011 = PseudoVCTZ_V_M2_MASK + { 6, &RISCVDescs.OperandInfo[829] }, // Inst #1010 = PseudoVCTZ_V_M2 + { 7, &RISCVDescs.OperandInfo[905] }, // Inst #1009 = PseudoVCTZ_V_M1_MASK + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #1008 = PseudoVCTZ_V_M1 + { 7, &RISCVDescs.OperandInfo[905] }, // Inst #1007 = PseudoVCPOP_V_MF8_MASK + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #1006 = PseudoVCPOP_V_MF8 + { 7, &RISCVDescs.OperandInfo[905] }, // Inst #1005 = PseudoVCPOP_V_MF4_MASK + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #1004 = PseudoVCPOP_V_MF4 + { 7, &RISCVDescs.OperandInfo[905] }, // Inst #1003 = PseudoVCPOP_V_MF2_MASK + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #1002 = PseudoVCPOP_V_MF2 + { 7, &RISCVDescs.OperandInfo[926] }, // Inst #1001 = PseudoVCPOP_V_M8_MASK + { 6, &RISCVDescs.OperandInfo[871] }, // Inst #1000 = PseudoVCPOP_V_M8 + { 7, &RISCVDescs.OperandInfo[919] }, // Inst #999 = PseudoVCPOP_V_M4_MASK + { 6, &RISCVDescs.OperandInfo[847] }, // Inst #998 = PseudoVCPOP_V_M4 + { 7, &RISCVDescs.OperandInfo[912] }, // Inst #997 = PseudoVCPOP_V_M2_MASK + { 6, &RISCVDescs.OperandInfo[829] }, // Inst #996 = PseudoVCPOP_V_M2 + { 7, &RISCVDescs.OperandInfo[905] }, // Inst #995 = PseudoVCPOP_V_M1_MASK + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #994 = PseudoVCPOP_V_M1 + { 5, &RISCVDescs.OperandInfo[961] }, // Inst #993 = PseudoVCPOP_M_B8_MASK + { 4, &RISCVDescs.OperandInfo[957] }, // Inst #992 = PseudoVCPOP_M_B8 + { 5, &RISCVDescs.OperandInfo[961] }, // Inst #991 = PseudoVCPOP_M_B64_MASK + { 4, &RISCVDescs.OperandInfo[957] }, // Inst #990 = PseudoVCPOP_M_B64 + { 5, &RISCVDescs.OperandInfo[961] }, // Inst #989 = PseudoVCPOP_M_B4_MASK + { 4, &RISCVDescs.OperandInfo[957] }, // Inst #988 = PseudoVCPOP_M_B4 + { 5, &RISCVDescs.OperandInfo[961] }, // Inst #987 = PseudoVCPOP_M_B32_MASK + { 4, &RISCVDescs.OperandInfo[957] }, // Inst #986 = PseudoVCPOP_M_B32 + { 5, &RISCVDescs.OperandInfo[961] }, // Inst #985 = PseudoVCPOP_M_B2_MASK + { 4, &RISCVDescs.OperandInfo[957] }, // Inst #984 = PseudoVCPOP_M_B2 + { 5, &RISCVDescs.OperandInfo[961] }, // Inst #983 = PseudoVCPOP_M_B1_MASK + { 5, &RISCVDescs.OperandInfo[961] }, // Inst #982 = PseudoVCPOP_M_B16_MASK + { 4, &RISCVDescs.OperandInfo[957] }, // Inst #981 = PseudoVCPOP_M_B16 + { 4, &RISCVDescs.OperandInfo[957] }, // Inst #980 = PseudoVCPOP_M_B1 + { 6, &RISCVDescs.OperandInfo[933] }, // Inst #979 = PseudoVCOMPRESS_VM_MF8_E8 + { 6, &RISCVDescs.OperandInfo[933] }, // Inst #978 = PseudoVCOMPRESS_VM_MF4_E8 + { 6, &RISCVDescs.OperandInfo[933] }, // Inst #977 = PseudoVCOMPRESS_VM_MF4_E16 + { 6, &RISCVDescs.OperandInfo[933] }, // Inst #976 = PseudoVCOMPRESS_VM_MF2_E8 + { 6, &RISCVDescs.OperandInfo[933] }, // Inst #975 = PseudoVCOMPRESS_VM_MF2_E32 + { 6, &RISCVDescs.OperandInfo[933] }, // Inst #974 = PseudoVCOMPRESS_VM_MF2_E16 + { 6, &RISCVDescs.OperandInfo[951] }, // Inst #973 = PseudoVCOMPRESS_VM_M8_E8 + { 6, &RISCVDescs.OperandInfo[951] }, // Inst #972 = PseudoVCOMPRESS_VM_M8_E64 + { 6, &RISCVDescs.OperandInfo[951] }, // Inst #971 = PseudoVCOMPRESS_VM_M8_E32 + { 6, &RISCVDescs.OperandInfo[951] }, // Inst #970 = PseudoVCOMPRESS_VM_M8_E16 + { 6, &RISCVDescs.OperandInfo[945] }, // Inst #969 = PseudoVCOMPRESS_VM_M4_E8 + { 6, &RISCVDescs.OperandInfo[945] }, // Inst #968 = PseudoVCOMPRESS_VM_M4_E64 + { 6, &RISCVDescs.OperandInfo[945] }, // Inst #967 = PseudoVCOMPRESS_VM_M4_E32 + { 6, &RISCVDescs.OperandInfo[945] }, // Inst #966 = PseudoVCOMPRESS_VM_M4_E16 + { 6, &RISCVDescs.OperandInfo[939] }, // Inst #965 = PseudoVCOMPRESS_VM_M2_E8 + { 6, &RISCVDescs.OperandInfo[939] }, // Inst #964 = PseudoVCOMPRESS_VM_M2_E64 + { 6, &RISCVDescs.OperandInfo[939] }, // Inst #963 = PseudoVCOMPRESS_VM_M2_E32 + { 6, &RISCVDescs.OperandInfo[939] }, // Inst #962 = PseudoVCOMPRESS_VM_M2_E16 + { 6, &RISCVDescs.OperandInfo[933] }, // Inst #961 = PseudoVCOMPRESS_VM_M1_E8 + { 6, &RISCVDescs.OperandInfo[933] }, // Inst #960 = PseudoVCOMPRESS_VM_M1_E64 + { 6, &RISCVDescs.OperandInfo[933] }, // Inst #959 = PseudoVCOMPRESS_VM_M1_E32 + { 6, &RISCVDescs.OperandInfo[933] }, // Inst #958 = PseudoVCOMPRESS_VM_M1_E16 + { 7, &RISCVDescs.OperandInfo[905] }, // Inst #957 = PseudoVCLZ_V_MF8_MASK + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #956 = PseudoVCLZ_V_MF8 + { 7, &RISCVDescs.OperandInfo[905] }, // Inst #955 = PseudoVCLZ_V_MF4_MASK + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #954 = PseudoVCLZ_V_MF4 + { 7, &RISCVDescs.OperandInfo[905] }, // Inst #953 = PseudoVCLZ_V_MF2_MASK + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #952 = PseudoVCLZ_V_MF2 + { 7, &RISCVDescs.OperandInfo[926] }, // Inst #951 = PseudoVCLZ_V_M8_MASK + { 6, &RISCVDescs.OperandInfo[871] }, // Inst #950 = PseudoVCLZ_V_M8 + { 7, &RISCVDescs.OperandInfo[919] }, // Inst #949 = PseudoVCLZ_V_M4_MASK + { 6, &RISCVDescs.OperandInfo[847] }, // Inst #948 = PseudoVCLZ_V_M4 + { 7, &RISCVDescs.OperandInfo[912] }, // Inst #947 = PseudoVCLZ_V_M2_MASK + { 6, &RISCVDescs.OperandInfo[829] }, // Inst #946 = PseudoVCLZ_V_M2 + { 7, &RISCVDescs.OperandInfo[905] }, // Inst #945 = PseudoVCLZ_V_M1_MASK + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #944 = PseudoVCLZ_V_M1 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #943 = PseudoVCLMUL_VX_MF8_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #942 = PseudoVCLMUL_VX_MF8 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #941 = PseudoVCLMUL_VX_MF4_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #940 = PseudoVCLMUL_VX_MF4 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #939 = PseudoVCLMUL_VX_MF2_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #938 = PseudoVCLMUL_VX_MF2 + { 8, &RISCVDescs.OperandInfo[809] }, // Inst #937 = PseudoVCLMUL_VX_M8_MASK + { 7, &RISCVDescs.OperandInfo[802] }, // Inst #936 = PseudoVCLMUL_VX_M8 + { 8, &RISCVDescs.OperandInfo[794] }, // Inst #935 = PseudoVCLMUL_VX_M4_MASK + { 7, &RISCVDescs.OperandInfo[787] }, // Inst #934 = PseudoVCLMUL_VX_M4 + { 8, &RISCVDescs.OperandInfo[779] }, // Inst #933 = PseudoVCLMUL_VX_M2_MASK + { 7, &RISCVDescs.OperandInfo[772] }, // Inst #932 = PseudoVCLMUL_VX_M2 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #931 = PseudoVCLMUL_VX_M1_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #930 = PseudoVCLMUL_VX_M1 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #929 = PseudoVCLMUL_VV_MF8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #928 = PseudoVCLMUL_VV_MF8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #927 = PseudoVCLMUL_VV_MF4_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #926 = PseudoVCLMUL_VV_MF4 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #925 = PseudoVCLMUL_VV_MF2_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #924 = PseudoVCLMUL_VV_MF2 + { 8, &RISCVDescs.OperandInfo[749] }, // Inst #923 = PseudoVCLMUL_VV_M8_MASK + { 7, &RISCVDescs.OperandInfo[742] }, // Inst #922 = PseudoVCLMUL_VV_M8 + { 8, &RISCVDescs.OperandInfo[734] }, // Inst #921 = PseudoVCLMUL_VV_M4_MASK + { 7, &RISCVDescs.OperandInfo[727] }, // Inst #920 = PseudoVCLMUL_VV_M4 + { 8, &RISCVDescs.OperandInfo[719] }, // Inst #919 = PseudoVCLMUL_VV_M2_MASK + { 7, &RISCVDescs.OperandInfo[712] }, // Inst #918 = PseudoVCLMUL_VV_M2 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #917 = PseudoVCLMUL_VV_M1_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #916 = PseudoVCLMUL_VV_M1 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #915 = PseudoVCLMULH_VX_MF8_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #914 = PseudoVCLMULH_VX_MF8 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #913 = PseudoVCLMULH_VX_MF4_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #912 = PseudoVCLMULH_VX_MF4 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #911 = PseudoVCLMULH_VX_MF2_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #910 = PseudoVCLMULH_VX_MF2 + { 8, &RISCVDescs.OperandInfo[809] }, // Inst #909 = PseudoVCLMULH_VX_M8_MASK + { 7, &RISCVDescs.OperandInfo[802] }, // Inst #908 = PseudoVCLMULH_VX_M8 + { 8, &RISCVDescs.OperandInfo[794] }, // Inst #907 = PseudoVCLMULH_VX_M4_MASK + { 7, &RISCVDescs.OperandInfo[787] }, // Inst #906 = PseudoVCLMULH_VX_M4 + { 8, &RISCVDescs.OperandInfo[779] }, // Inst #905 = PseudoVCLMULH_VX_M2_MASK + { 7, &RISCVDescs.OperandInfo[772] }, // Inst #904 = PseudoVCLMULH_VX_M2 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #903 = PseudoVCLMULH_VX_M1_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #902 = PseudoVCLMULH_VX_M1 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #901 = PseudoVCLMULH_VV_MF8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #900 = PseudoVCLMULH_VV_MF8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #899 = PseudoVCLMULH_VV_MF4_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #898 = PseudoVCLMULH_VV_MF4 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #897 = PseudoVCLMULH_VV_MF2_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #896 = PseudoVCLMULH_VV_MF2 + { 8, &RISCVDescs.OperandInfo[749] }, // Inst #895 = PseudoVCLMULH_VV_M8_MASK + { 7, &RISCVDescs.OperandInfo[742] }, // Inst #894 = PseudoVCLMULH_VV_M8 + { 8, &RISCVDescs.OperandInfo[734] }, // Inst #893 = PseudoVCLMULH_VV_M4_MASK + { 7, &RISCVDescs.OperandInfo[727] }, // Inst #892 = PseudoVCLMULH_VV_M4 + { 8, &RISCVDescs.OperandInfo[719] }, // Inst #891 = PseudoVCLMULH_VV_M2_MASK + { 7, &RISCVDescs.OperandInfo[712] }, // Inst #890 = PseudoVCLMULH_VV_M2 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #889 = PseudoVCLMULH_VV_M1_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #888 = PseudoVCLMULH_VV_M1 + { 7, &RISCVDescs.OperandInfo[905] }, // Inst #887 = PseudoVBREV_V_MF8_MASK + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #886 = PseudoVBREV_V_MF8 + { 7, &RISCVDescs.OperandInfo[905] }, // Inst #885 = PseudoVBREV_V_MF4_MASK + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #884 = PseudoVBREV_V_MF4 + { 7, &RISCVDescs.OperandInfo[905] }, // Inst #883 = PseudoVBREV_V_MF2_MASK + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #882 = PseudoVBREV_V_MF2 + { 7, &RISCVDescs.OperandInfo[926] }, // Inst #881 = PseudoVBREV_V_M8_MASK + { 6, &RISCVDescs.OperandInfo[871] }, // Inst #880 = PseudoVBREV_V_M8 + { 7, &RISCVDescs.OperandInfo[919] }, // Inst #879 = PseudoVBREV_V_M4_MASK + { 6, &RISCVDescs.OperandInfo[847] }, // Inst #878 = PseudoVBREV_V_M4 + { 7, &RISCVDescs.OperandInfo[912] }, // Inst #877 = PseudoVBREV_V_M2_MASK + { 6, &RISCVDescs.OperandInfo[829] }, // Inst #876 = PseudoVBREV_V_M2 + { 7, &RISCVDescs.OperandInfo[905] }, // Inst #875 = PseudoVBREV_V_M1_MASK + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #874 = PseudoVBREV_V_M1 + { 7, &RISCVDescs.OperandInfo[905] }, // Inst #873 = PseudoVBREV8_V_MF8_MASK + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #872 = PseudoVBREV8_V_MF8 + { 7, &RISCVDescs.OperandInfo[905] }, // Inst #871 = PseudoVBREV8_V_MF4_MASK + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #870 = PseudoVBREV8_V_MF4 + { 7, &RISCVDescs.OperandInfo[905] }, // Inst #869 = PseudoVBREV8_V_MF2_MASK + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #868 = PseudoVBREV8_V_MF2 + { 7, &RISCVDescs.OperandInfo[926] }, // Inst #867 = PseudoVBREV8_V_M8_MASK + { 6, &RISCVDescs.OperandInfo[871] }, // Inst #866 = PseudoVBREV8_V_M8 + { 7, &RISCVDescs.OperandInfo[919] }, // Inst #865 = PseudoVBREV8_V_M4_MASK + { 6, &RISCVDescs.OperandInfo[847] }, // Inst #864 = PseudoVBREV8_V_M4 + { 7, &RISCVDescs.OperandInfo[912] }, // Inst #863 = PseudoVBREV8_V_M2_MASK + { 6, &RISCVDescs.OperandInfo[829] }, // Inst #862 = PseudoVBREV8_V_M2 + { 7, &RISCVDescs.OperandInfo[905] }, // Inst #861 = PseudoVBREV8_V_M1_MASK + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #860 = PseudoVBREV8_V_M1 + { 9, &RISCVDescs.OperandInfo[493] }, // Inst #859 = PseudoVASUB_VX_MF8_MASK + { 8, &RISCVDescs.OperandInfo[485] }, // Inst #858 = PseudoVASUB_VX_MF8 + { 9, &RISCVDescs.OperandInfo[493] }, // Inst #857 = PseudoVASUB_VX_MF4_MASK + { 8, &RISCVDescs.OperandInfo[485] }, // Inst #856 = PseudoVASUB_VX_MF4 + { 9, &RISCVDescs.OperandInfo[493] }, // Inst #855 = PseudoVASUB_VX_MF2_MASK + { 8, &RISCVDescs.OperandInfo[485] }, // Inst #854 = PseudoVASUB_VX_MF2 + { 9, &RISCVDescs.OperandInfo[544] }, // Inst #853 = PseudoVASUB_VX_M8_MASK + { 8, &RISCVDescs.OperandInfo[536] }, // Inst #852 = PseudoVASUB_VX_M8 + { 9, &RISCVDescs.OperandInfo[527] }, // Inst #851 = PseudoVASUB_VX_M4_MASK + { 8, &RISCVDescs.OperandInfo[519] }, // Inst #850 = PseudoVASUB_VX_M4 + { 9, &RISCVDescs.OperandInfo[510] }, // Inst #849 = PseudoVASUB_VX_M2_MASK + { 8, &RISCVDescs.OperandInfo[502] }, // Inst #848 = PseudoVASUB_VX_M2 + { 9, &RISCVDescs.OperandInfo[493] }, // Inst #847 = PseudoVASUB_VX_M1_MASK + { 8, &RISCVDescs.OperandInfo[485] }, // Inst #846 = PseudoVASUB_VX_M1 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #845 = PseudoVASUB_VV_MF8_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #844 = PseudoVASUB_VV_MF8 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #843 = PseudoVASUB_VV_MF4_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #842 = PseudoVASUB_VV_MF4 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #841 = PseudoVASUB_VV_MF2_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #840 = PseudoVASUB_VV_MF2 + { 9, &RISCVDescs.OperandInfo[476] }, // Inst #839 = PseudoVASUB_VV_M8_MASK + { 8, &RISCVDescs.OperandInfo[468] }, // Inst #838 = PseudoVASUB_VV_M8 + { 9, &RISCVDescs.OperandInfo[459] }, // Inst #837 = PseudoVASUB_VV_M4_MASK + { 8, &RISCVDescs.OperandInfo[451] }, // Inst #836 = PseudoVASUB_VV_M4 + { 9, &RISCVDescs.OperandInfo[442] }, // Inst #835 = PseudoVASUB_VV_M2_MASK + { 8, &RISCVDescs.OperandInfo[434] }, // Inst #834 = PseudoVASUB_VV_M2 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #833 = PseudoVASUB_VV_M1_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #832 = PseudoVASUB_VV_M1 + { 9, &RISCVDescs.OperandInfo[493] }, // Inst #831 = PseudoVASUBU_VX_MF8_MASK + { 8, &RISCVDescs.OperandInfo[485] }, // Inst #830 = PseudoVASUBU_VX_MF8 + { 9, &RISCVDescs.OperandInfo[493] }, // Inst #829 = PseudoVASUBU_VX_MF4_MASK + { 8, &RISCVDescs.OperandInfo[485] }, // Inst #828 = PseudoVASUBU_VX_MF4 + { 9, &RISCVDescs.OperandInfo[493] }, // Inst #827 = PseudoVASUBU_VX_MF2_MASK + { 8, &RISCVDescs.OperandInfo[485] }, // Inst #826 = PseudoVASUBU_VX_MF2 + { 9, &RISCVDescs.OperandInfo[544] }, // Inst #825 = PseudoVASUBU_VX_M8_MASK + { 8, &RISCVDescs.OperandInfo[536] }, // Inst #824 = PseudoVASUBU_VX_M8 + { 9, &RISCVDescs.OperandInfo[527] }, // Inst #823 = PseudoVASUBU_VX_M4_MASK + { 8, &RISCVDescs.OperandInfo[519] }, // Inst #822 = PseudoVASUBU_VX_M4 + { 9, &RISCVDescs.OperandInfo[510] }, // Inst #821 = PseudoVASUBU_VX_M2_MASK + { 8, &RISCVDescs.OperandInfo[502] }, // Inst #820 = PseudoVASUBU_VX_M2 + { 9, &RISCVDescs.OperandInfo[493] }, // Inst #819 = PseudoVASUBU_VX_M1_MASK + { 8, &RISCVDescs.OperandInfo[485] }, // Inst #818 = PseudoVASUBU_VX_M1 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #817 = PseudoVASUBU_VV_MF8_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #816 = PseudoVASUBU_VV_MF8 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #815 = PseudoVASUBU_VV_MF4_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #814 = PseudoVASUBU_VV_MF4 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #813 = PseudoVASUBU_VV_MF2_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #812 = PseudoVASUBU_VV_MF2 + { 9, &RISCVDescs.OperandInfo[476] }, // Inst #811 = PseudoVASUBU_VV_M8_MASK + { 8, &RISCVDescs.OperandInfo[468] }, // Inst #810 = PseudoVASUBU_VV_M8 + { 9, &RISCVDescs.OperandInfo[459] }, // Inst #809 = PseudoVASUBU_VV_M4_MASK + { 8, &RISCVDescs.OperandInfo[451] }, // Inst #808 = PseudoVASUBU_VV_M4 + { 9, &RISCVDescs.OperandInfo[442] }, // Inst #807 = PseudoVASUBU_VV_M2_MASK + { 8, &RISCVDescs.OperandInfo[434] }, // Inst #806 = PseudoVASUBU_VV_M2 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #805 = PseudoVASUBU_VV_M1_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #804 = PseudoVASUBU_VV_M1 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #803 = PseudoVAND_VX_MF8_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #802 = PseudoVAND_VX_MF8 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #801 = PseudoVAND_VX_MF4_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #800 = PseudoVAND_VX_MF4 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #799 = PseudoVAND_VX_MF2_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #798 = PseudoVAND_VX_MF2 + { 8, &RISCVDescs.OperandInfo[809] }, // Inst #797 = PseudoVAND_VX_M8_MASK + { 7, &RISCVDescs.OperandInfo[802] }, // Inst #796 = PseudoVAND_VX_M8 + { 8, &RISCVDescs.OperandInfo[794] }, // Inst #795 = PseudoVAND_VX_M4_MASK + { 7, &RISCVDescs.OperandInfo[787] }, // Inst #794 = PseudoVAND_VX_M4 + { 8, &RISCVDescs.OperandInfo[779] }, // Inst #793 = PseudoVAND_VX_M2_MASK + { 7, &RISCVDescs.OperandInfo[772] }, // Inst #792 = PseudoVAND_VX_M2 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #791 = PseudoVAND_VX_M1_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #790 = PseudoVAND_VX_M1 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #789 = PseudoVAND_VV_MF8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #788 = PseudoVAND_VV_MF8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #787 = PseudoVAND_VV_MF4_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #786 = PseudoVAND_VV_MF4 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #785 = PseudoVAND_VV_MF2_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #784 = PseudoVAND_VV_MF2 + { 8, &RISCVDescs.OperandInfo[749] }, // Inst #783 = PseudoVAND_VV_M8_MASK + { 7, &RISCVDescs.OperandInfo[742] }, // Inst #782 = PseudoVAND_VV_M8 + { 8, &RISCVDescs.OperandInfo[734] }, // Inst #781 = PseudoVAND_VV_M4_MASK + { 7, &RISCVDescs.OperandInfo[727] }, // Inst #780 = PseudoVAND_VV_M4 + { 8, &RISCVDescs.OperandInfo[719] }, // Inst #779 = PseudoVAND_VV_M2_MASK + { 7, &RISCVDescs.OperandInfo[712] }, // Inst #778 = PseudoVAND_VV_M2 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #777 = PseudoVAND_VV_M1_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #776 = PseudoVAND_VV_M1 + { 8, &RISCVDescs.OperandInfo[644] }, // Inst #775 = PseudoVAND_VI_MF8_MASK + { 7, &RISCVDescs.OperandInfo[637] }, // Inst #774 = PseudoVAND_VI_MF8 + { 8, &RISCVDescs.OperandInfo[644] }, // Inst #773 = PseudoVAND_VI_MF4_MASK + { 7, &RISCVDescs.OperandInfo[637] }, // Inst #772 = PseudoVAND_VI_MF4 + { 8, &RISCVDescs.OperandInfo[644] }, // Inst #771 = PseudoVAND_VI_MF2_MASK + { 7, &RISCVDescs.OperandInfo[637] }, // Inst #770 = PseudoVAND_VI_MF2 + { 8, &RISCVDescs.OperandInfo[689] }, // Inst #769 = PseudoVAND_VI_M8_MASK + { 7, &RISCVDescs.OperandInfo[682] }, // Inst #768 = PseudoVAND_VI_M8 + { 8, &RISCVDescs.OperandInfo[674] }, // Inst #767 = PseudoVAND_VI_M4_MASK + { 7, &RISCVDescs.OperandInfo[667] }, // Inst #766 = PseudoVAND_VI_M4 + { 8, &RISCVDescs.OperandInfo[659] }, // Inst #765 = PseudoVAND_VI_M2_MASK + { 7, &RISCVDescs.OperandInfo[652] }, // Inst #764 = PseudoVAND_VI_M2 + { 8, &RISCVDescs.OperandInfo[644] }, // Inst #763 = PseudoVAND_VI_M1_MASK + { 7, &RISCVDescs.OperandInfo[637] }, // Inst #762 = PseudoVAND_VI_M1 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #761 = PseudoVANDN_VX_MF8_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #760 = PseudoVANDN_VX_MF8 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #759 = PseudoVANDN_VX_MF4_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #758 = PseudoVANDN_VX_MF4 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #757 = PseudoVANDN_VX_MF2_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #756 = PseudoVANDN_VX_MF2 + { 8, &RISCVDescs.OperandInfo[809] }, // Inst #755 = PseudoVANDN_VX_M8_MASK + { 7, &RISCVDescs.OperandInfo[802] }, // Inst #754 = PseudoVANDN_VX_M8 + { 8, &RISCVDescs.OperandInfo[794] }, // Inst #753 = PseudoVANDN_VX_M4_MASK + { 7, &RISCVDescs.OperandInfo[787] }, // Inst #752 = PseudoVANDN_VX_M4 + { 8, &RISCVDescs.OperandInfo[779] }, // Inst #751 = PseudoVANDN_VX_M2_MASK + { 7, &RISCVDescs.OperandInfo[772] }, // Inst #750 = PseudoVANDN_VX_M2 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #749 = PseudoVANDN_VX_M1_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #748 = PseudoVANDN_VX_M1 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #747 = PseudoVANDN_VV_MF8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #746 = PseudoVANDN_VV_MF8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #745 = PseudoVANDN_VV_MF4_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #744 = PseudoVANDN_VV_MF4 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #743 = PseudoVANDN_VV_MF2_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #742 = PseudoVANDN_VV_MF2 + { 8, &RISCVDescs.OperandInfo[749] }, // Inst #741 = PseudoVANDN_VV_M8_MASK + { 7, &RISCVDescs.OperandInfo[742] }, // Inst #740 = PseudoVANDN_VV_M8 + { 8, &RISCVDescs.OperandInfo[734] }, // Inst #739 = PseudoVANDN_VV_M4_MASK + { 7, &RISCVDescs.OperandInfo[727] }, // Inst #738 = PseudoVANDN_VV_M4 + { 8, &RISCVDescs.OperandInfo[719] }, // Inst #737 = PseudoVANDN_VV_M2_MASK + { 7, &RISCVDescs.OperandInfo[712] }, // Inst #736 = PseudoVANDN_VV_M2 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #735 = PseudoVANDN_VV_M1_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #734 = PseudoVANDN_VV_M1 + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #733 = PseudoVAESZ_VS_MF2_MF8 + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #732 = PseudoVAESZ_VS_MF2_MF4 + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #731 = PseudoVAESZ_VS_MF2_MF2 + { 6, &RISCVDescs.OperandInfo[853] }, // Inst #730 = PseudoVAESZ_VS_M8_MF8 + { 6, &RISCVDescs.OperandInfo[853] }, // Inst #729 = PseudoVAESZ_VS_M8_MF4 + { 6, &RISCVDescs.OperandInfo[853] }, // Inst #728 = PseudoVAESZ_VS_M8_MF2 + { 6, &RISCVDescs.OperandInfo[865] }, // Inst #727 = PseudoVAESZ_VS_M8_M4 + { 6, &RISCVDescs.OperandInfo[859] }, // Inst #726 = PseudoVAESZ_VS_M8_M2 + { 6, &RISCVDescs.OperandInfo[853] }, // Inst #725 = PseudoVAESZ_VS_M8_M1 + { 6, &RISCVDescs.OperandInfo[835] }, // Inst #724 = PseudoVAESZ_VS_M4_MF8 + { 6, &RISCVDescs.OperandInfo[835] }, // Inst #723 = PseudoVAESZ_VS_M4_MF4 + { 6, &RISCVDescs.OperandInfo[835] }, // Inst #722 = PseudoVAESZ_VS_M4_MF2 + { 6, &RISCVDescs.OperandInfo[847] }, // Inst #721 = PseudoVAESZ_VS_M4_M4 + { 6, &RISCVDescs.OperandInfo[841] }, // Inst #720 = PseudoVAESZ_VS_M4_M2 + { 6, &RISCVDescs.OperandInfo[835] }, // Inst #719 = PseudoVAESZ_VS_M4_M1 + { 6, &RISCVDescs.OperandInfo[823] }, // Inst #718 = PseudoVAESZ_VS_M2_MF8 + { 6, &RISCVDescs.OperandInfo[823] }, // Inst #717 = PseudoVAESZ_VS_M2_MF4 + { 6, &RISCVDescs.OperandInfo[823] }, // Inst #716 = PseudoVAESZ_VS_M2_MF2 + { 6, &RISCVDescs.OperandInfo[829] }, // Inst #715 = PseudoVAESZ_VS_M2_M2 + { 6, &RISCVDescs.OperandInfo[823] }, // Inst #714 = PseudoVAESZ_VS_M2_M1 + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #713 = PseudoVAESZ_VS_M1_MF8 + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #712 = PseudoVAESZ_VS_M1_MF4 + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #711 = PseudoVAESZ_VS_M1_MF2 + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #710 = PseudoVAESZ_VS_M1_M1 + { 7, &RISCVDescs.OperandInfo[877] }, // Inst #709 = PseudoVAESKF2_VI_MF2 + { 7, &RISCVDescs.OperandInfo[898] }, // Inst #708 = PseudoVAESKF2_VI_M8 + { 7, &RISCVDescs.OperandInfo[891] }, // Inst #707 = PseudoVAESKF2_VI_M4 + { 7, &RISCVDescs.OperandInfo[884] }, // Inst #706 = PseudoVAESKF2_VI_M2 + { 7, &RISCVDescs.OperandInfo[877] }, // Inst #705 = PseudoVAESKF2_VI_M1 + { 7, &RISCVDescs.OperandInfo[877] }, // Inst #704 = PseudoVAESKF1_VI_MF2 + { 7, &RISCVDescs.OperandInfo[898] }, // Inst #703 = PseudoVAESKF1_VI_M8 + { 7, &RISCVDescs.OperandInfo[891] }, // Inst #702 = PseudoVAESKF1_VI_M4 + { 7, &RISCVDescs.OperandInfo[884] }, // Inst #701 = PseudoVAESKF1_VI_M2 + { 7, &RISCVDescs.OperandInfo[877] }, // Inst #700 = PseudoVAESKF1_VI_M1 + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #699 = PseudoVAESEM_VV_MF2 + { 6, &RISCVDescs.OperandInfo[871] }, // Inst #698 = PseudoVAESEM_VV_M8 + { 6, &RISCVDescs.OperandInfo[847] }, // Inst #697 = PseudoVAESEM_VV_M4 + { 6, &RISCVDescs.OperandInfo[829] }, // Inst #696 = PseudoVAESEM_VV_M2 + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #695 = PseudoVAESEM_VV_M1 + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #694 = PseudoVAESEM_VS_MF2_MF8 + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #693 = PseudoVAESEM_VS_MF2_MF4 + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #692 = PseudoVAESEM_VS_MF2_MF2 + { 6, &RISCVDescs.OperandInfo[853] }, // Inst #691 = PseudoVAESEM_VS_M8_MF8 + { 6, &RISCVDescs.OperandInfo[853] }, // Inst #690 = PseudoVAESEM_VS_M8_MF4 + { 6, &RISCVDescs.OperandInfo[853] }, // Inst #689 = PseudoVAESEM_VS_M8_MF2 + { 6, &RISCVDescs.OperandInfo[865] }, // Inst #688 = PseudoVAESEM_VS_M8_M4 + { 6, &RISCVDescs.OperandInfo[859] }, // Inst #687 = PseudoVAESEM_VS_M8_M2 + { 6, &RISCVDescs.OperandInfo[853] }, // Inst #686 = PseudoVAESEM_VS_M8_M1 + { 6, &RISCVDescs.OperandInfo[835] }, // Inst #685 = PseudoVAESEM_VS_M4_MF8 + { 6, &RISCVDescs.OperandInfo[835] }, // Inst #684 = PseudoVAESEM_VS_M4_MF4 + { 6, &RISCVDescs.OperandInfo[835] }, // Inst #683 = PseudoVAESEM_VS_M4_MF2 + { 6, &RISCVDescs.OperandInfo[847] }, // Inst #682 = PseudoVAESEM_VS_M4_M4 + { 6, &RISCVDescs.OperandInfo[841] }, // Inst #681 = PseudoVAESEM_VS_M4_M2 + { 6, &RISCVDescs.OperandInfo[835] }, // Inst #680 = PseudoVAESEM_VS_M4_M1 + { 6, &RISCVDescs.OperandInfo[823] }, // Inst #679 = PseudoVAESEM_VS_M2_MF8 + { 6, &RISCVDescs.OperandInfo[823] }, // Inst #678 = PseudoVAESEM_VS_M2_MF4 + { 6, &RISCVDescs.OperandInfo[823] }, // Inst #677 = PseudoVAESEM_VS_M2_MF2 + { 6, &RISCVDescs.OperandInfo[829] }, // Inst #676 = PseudoVAESEM_VS_M2_M2 + { 6, &RISCVDescs.OperandInfo[823] }, // Inst #675 = PseudoVAESEM_VS_M2_M1 + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #674 = PseudoVAESEM_VS_M1_MF8 + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #673 = PseudoVAESEM_VS_M1_MF4 + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #672 = PseudoVAESEM_VS_M1_MF2 + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #671 = PseudoVAESEM_VS_M1_M1 + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #670 = PseudoVAESEF_VV_MF2 + { 6, &RISCVDescs.OperandInfo[871] }, // Inst #669 = PseudoVAESEF_VV_M8 + { 6, &RISCVDescs.OperandInfo[847] }, // Inst #668 = PseudoVAESEF_VV_M4 + { 6, &RISCVDescs.OperandInfo[829] }, // Inst #667 = PseudoVAESEF_VV_M2 + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #666 = PseudoVAESEF_VV_M1 + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #665 = PseudoVAESEF_VS_MF2_MF8 + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #664 = PseudoVAESEF_VS_MF2_MF4 + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #663 = PseudoVAESEF_VS_MF2_MF2 + { 6, &RISCVDescs.OperandInfo[853] }, // Inst #662 = PseudoVAESEF_VS_M8_MF8 + { 6, &RISCVDescs.OperandInfo[853] }, // Inst #661 = PseudoVAESEF_VS_M8_MF4 + { 6, &RISCVDescs.OperandInfo[853] }, // Inst #660 = PseudoVAESEF_VS_M8_MF2 + { 6, &RISCVDescs.OperandInfo[865] }, // Inst #659 = PseudoVAESEF_VS_M8_M4 + { 6, &RISCVDescs.OperandInfo[859] }, // Inst #658 = PseudoVAESEF_VS_M8_M2 + { 6, &RISCVDescs.OperandInfo[853] }, // Inst #657 = PseudoVAESEF_VS_M8_M1 + { 6, &RISCVDescs.OperandInfo[835] }, // Inst #656 = PseudoVAESEF_VS_M4_MF8 + { 6, &RISCVDescs.OperandInfo[835] }, // Inst #655 = PseudoVAESEF_VS_M4_MF4 + { 6, &RISCVDescs.OperandInfo[835] }, // Inst #654 = PseudoVAESEF_VS_M4_MF2 + { 6, &RISCVDescs.OperandInfo[847] }, // Inst #653 = PseudoVAESEF_VS_M4_M4 + { 6, &RISCVDescs.OperandInfo[841] }, // Inst #652 = PseudoVAESEF_VS_M4_M2 + { 6, &RISCVDescs.OperandInfo[835] }, // Inst #651 = PseudoVAESEF_VS_M4_M1 + { 6, &RISCVDescs.OperandInfo[823] }, // Inst #650 = PseudoVAESEF_VS_M2_MF8 + { 6, &RISCVDescs.OperandInfo[823] }, // Inst #649 = PseudoVAESEF_VS_M2_MF4 + { 6, &RISCVDescs.OperandInfo[823] }, // Inst #648 = PseudoVAESEF_VS_M2_MF2 + { 6, &RISCVDescs.OperandInfo[829] }, // Inst #647 = PseudoVAESEF_VS_M2_M2 + { 6, &RISCVDescs.OperandInfo[823] }, // Inst #646 = PseudoVAESEF_VS_M2_M1 + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #645 = PseudoVAESEF_VS_M1_MF8 + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #644 = PseudoVAESEF_VS_M1_MF4 + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #643 = PseudoVAESEF_VS_M1_MF2 + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #642 = PseudoVAESEF_VS_M1_M1 + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #641 = PseudoVAESDM_VV_MF2 + { 6, &RISCVDescs.OperandInfo[871] }, // Inst #640 = PseudoVAESDM_VV_M8 + { 6, &RISCVDescs.OperandInfo[847] }, // Inst #639 = PseudoVAESDM_VV_M4 + { 6, &RISCVDescs.OperandInfo[829] }, // Inst #638 = PseudoVAESDM_VV_M2 + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #637 = PseudoVAESDM_VV_M1 + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #636 = PseudoVAESDM_VS_MF2_MF8 + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #635 = PseudoVAESDM_VS_MF2_MF4 + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #634 = PseudoVAESDM_VS_MF2_MF2 + { 6, &RISCVDescs.OperandInfo[853] }, // Inst #633 = PseudoVAESDM_VS_M8_MF8 + { 6, &RISCVDescs.OperandInfo[853] }, // Inst #632 = PseudoVAESDM_VS_M8_MF4 + { 6, &RISCVDescs.OperandInfo[853] }, // Inst #631 = PseudoVAESDM_VS_M8_MF2 + { 6, &RISCVDescs.OperandInfo[865] }, // Inst #630 = PseudoVAESDM_VS_M8_M4 + { 6, &RISCVDescs.OperandInfo[859] }, // Inst #629 = PseudoVAESDM_VS_M8_M2 + { 6, &RISCVDescs.OperandInfo[853] }, // Inst #628 = PseudoVAESDM_VS_M8_M1 + { 6, &RISCVDescs.OperandInfo[835] }, // Inst #627 = PseudoVAESDM_VS_M4_MF8 + { 6, &RISCVDescs.OperandInfo[835] }, // Inst #626 = PseudoVAESDM_VS_M4_MF4 + { 6, &RISCVDescs.OperandInfo[835] }, // Inst #625 = PseudoVAESDM_VS_M4_MF2 + { 6, &RISCVDescs.OperandInfo[847] }, // Inst #624 = PseudoVAESDM_VS_M4_M4 + { 6, &RISCVDescs.OperandInfo[841] }, // Inst #623 = PseudoVAESDM_VS_M4_M2 + { 6, &RISCVDescs.OperandInfo[835] }, // Inst #622 = PseudoVAESDM_VS_M4_M1 + { 6, &RISCVDescs.OperandInfo[823] }, // Inst #621 = PseudoVAESDM_VS_M2_MF8 + { 6, &RISCVDescs.OperandInfo[823] }, // Inst #620 = PseudoVAESDM_VS_M2_MF4 + { 6, &RISCVDescs.OperandInfo[823] }, // Inst #619 = PseudoVAESDM_VS_M2_MF2 + { 6, &RISCVDescs.OperandInfo[829] }, // Inst #618 = PseudoVAESDM_VS_M2_M2 + { 6, &RISCVDescs.OperandInfo[823] }, // Inst #617 = PseudoVAESDM_VS_M2_M1 + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #616 = PseudoVAESDM_VS_M1_MF8 + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #615 = PseudoVAESDM_VS_M1_MF4 + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #614 = PseudoVAESDM_VS_M1_MF2 + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #613 = PseudoVAESDM_VS_M1_M1 + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #612 = PseudoVAESDF_VV_MF2 + { 6, &RISCVDescs.OperandInfo[871] }, // Inst #611 = PseudoVAESDF_VV_M8 + { 6, &RISCVDescs.OperandInfo[847] }, // Inst #610 = PseudoVAESDF_VV_M4 + { 6, &RISCVDescs.OperandInfo[829] }, // Inst #609 = PseudoVAESDF_VV_M2 + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #608 = PseudoVAESDF_VV_M1 + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #607 = PseudoVAESDF_VS_MF2_MF8 + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #606 = PseudoVAESDF_VS_MF2_MF4 + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #605 = PseudoVAESDF_VS_MF2_MF2 + { 6, &RISCVDescs.OperandInfo[853] }, // Inst #604 = PseudoVAESDF_VS_M8_MF8 + { 6, &RISCVDescs.OperandInfo[853] }, // Inst #603 = PseudoVAESDF_VS_M8_MF4 + { 6, &RISCVDescs.OperandInfo[853] }, // Inst #602 = PseudoVAESDF_VS_M8_MF2 + { 6, &RISCVDescs.OperandInfo[865] }, // Inst #601 = PseudoVAESDF_VS_M8_M4 + { 6, &RISCVDescs.OperandInfo[859] }, // Inst #600 = PseudoVAESDF_VS_M8_M2 + { 6, &RISCVDescs.OperandInfo[853] }, // Inst #599 = PseudoVAESDF_VS_M8_M1 + { 6, &RISCVDescs.OperandInfo[835] }, // Inst #598 = PseudoVAESDF_VS_M4_MF8 + { 6, &RISCVDescs.OperandInfo[835] }, // Inst #597 = PseudoVAESDF_VS_M4_MF4 + { 6, &RISCVDescs.OperandInfo[835] }, // Inst #596 = PseudoVAESDF_VS_M4_MF2 + { 6, &RISCVDescs.OperandInfo[847] }, // Inst #595 = PseudoVAESDF_VS_M4_M4 + { 6, &RISCVDescs.OperandInfo[841] }, // Inst #594 = PseudoVAESDF_VS_M4_M2 + { 6, &RISCVDescs.OperandInfo[835] }, // Inst #593 = PseudoVAESDF_VS_M4_M1 + { 6, &RISCVDescs.OperandInfo[823] }, // Inst #592 = PseudoVAESDF_VS_M2_MF8 + { 6, &RISCVDescs.OperandInfo[823] }, // Inst #591 = PseudoVAESDF_VS_M2_MF4 + { 6, &RISCVDescs.OperandInfo[823] }, // Inst #590 = PseudoVAESDF_VS_M2_MF2 + { 6, &RISCVDescs.OperandInfo[829] }, // Inst #589 = PseudoVAESDF_VS_M2_M2 + { 6, &RISCVDescs.OperandInfo[823] }, // Inst #588 = PseudoVAESDF_VS_M2_M1 + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #587 = PseudoVAESDF_VS_M1_MF8 + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #586 = PseudoVAESDF_VS_M1_MF4 + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #585 = PseudoVAESDF_VS_M1_MF2 + { 6, &RISCVDescs.OperandInfo[817] }, // Inst #584 = PseudoVAESDF_VS_M1_M1 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #583 = PseudoVADD_VX_MF8_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #582 = PseudoVADD_VX_MF8 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #581 = PseudoVADD_VX_MF4_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #580 = PseudoVADD_VX_MF4 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #579 = PseudoVADD_VX_MF2_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #578 = PseudoVADD_VX_MF2 + { 8, &RISCVDescs.OperandInfo[809] }, // Inst #577 = PseudoVADD_VX_M8_MASK + { 7, &RISCVDescs.OperandInfo[802] }, // Inst #576 = PseudoVADD_VX_M8 + { 8, &RISCVDescs.OperandInfo[794] }, // Inst #575 = PseudoVADD_VX_M4_MASK + { 7, &RISCVDescs.OperandInfo[787] }, // Inst #574 = PseudoVADD_VX_M4 + { 8, &RISCVDescs.OperandInfo[779] }, // Inst #573 = PseudoVADD_VX_M2_MASK + { 7, &RISCVDescs.OperandInfo[772] }, // Inst #572 = PseudoVADD_VX_M2 + { 8, &RISCVDescs.OperandInfo[764] }, // Inst #571 = PseudoVADD_VX_M1_MASK + { 7, &RISCVDescs.OperandInfo[757] }, // Inst #570 = PseudoVADD_VX_M1 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #569 = PseudoVADD_VV_MF8_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #568 = PseudoVADD_VV_MF8 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #567 = PseudoVADD_VV_MF4_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #566 = PseudoVADD_VV_MF4 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #565 = PseudoVADD_VV_MF2_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #564 = PseudoVADD_VV_MF2 + { 8, &RISCVDescs.OperandInfo[749] }, // Inst #563 = PseudoVADD_VV_M8_MASK + { 7, &RISCVDescs.OperandInfo[742] }, // Inst #562 = PseudoVADD_VV_M8 + { 8, &RISCVDescs.OperandInfo[734] }, // Inst #561 = PseudoVADD_VV_M4_MASK + { 7, &RISCVDescs.OperandInfo[727] }, // Inst #560 = PseudoVADD_VV_M4 + { 8, &RISCVDescs.OperandInfo[719] }, // Inst #559 = PseudoVADD_VV_M2_MASK + { 7, &RISCVDescs.OperandInfo[712] }, // Inst #558 = PseudoVADD_VV_M2 + { 8, &RISCVDescs.OperandInfo[704] }, // Inst #557 = PseudoVADD_VV_M1_MASK + { 7, &RISCVDescs.OperandInfo[697] }, // Inst #556 = PseudoVADD_VV_M1 + { 8, &RISCVDescs.OperandInfo[644] }, // Inst #555 = PseudoVADD_VI_MF8_MASK + { 7, &RISCVDescs.OperandInfo[637] }, // Inst #554 = PseudoVADD_VI_MF8 + { 8, &RISCVDescs.OperandInfo[644] }, // Inst #553 = PseudoVADD_VI_MF4_MASK + { 7, &RISCVDescs.OperandInfo[637] }, // Inst #552 = PseudoVADD_VI_MF4 + { 8, &RISCVDescs.OperandInfo[644] }, // Inst #551 = PseudoVADD_VI_MF2_MASK + { 7, &RISCVDescs.OperandInfo[637] }, // Inst #550 = PseudoVADD_VI_MF2 + { 8, &RISCVDescs.OperandInfo[689] }, // Inst #549 = PseudoVADD_VI_M8_MASK + { 7, &RISCVDescs.OperandInfo[682] }, // Inst #548 = PseudoVADD_VI_M8 + { 8, &RISCVDescs.OperandInfo[674] }, // Inst #547 = PseudoVADD_VI_M4_MASK + { 7, &RISCVDescs.OperandInfo[667] }, // Inst #546 = PseudoVADD_VI_M4 + { 8, &RISCVDescs.OperandInfo[659] }, // Inst #545 = PseudoVADD_VI_M2_MASK + { 7, &RISCVDescs.OperandInfo[652] }, // Inst #544 = PseudoVADD_VI_M2 + { 8, &RISCVDescs.OperandInfo[644] }, // Inst #543 = PseudoVADD_VI_M1_MASK + { 7, &RISCVDescs.OperandInfo[637] }, // Inst #542 = PseudoVADD_VI_M1 + { 7, &RISCVDescs.OperandInfo[609] }, // Inst #541 = PseudoVADC_VXM_MF8 + { 7, &RISCVDescs.OperandInfo[609] }, // Inst #540 = PseudoVADC_VXM_MF4 + { 7, &RISCVDescs.OperandInfo[609] }, // Inst #539 = PseudoVADC_VXM_MF2 + { 7, &RISCVDescs.OperandInfo[630] }, // Inst #538 = PseudoVADC_VXM_M8 + { 7, &RISCVDescs.OperandInfo[623] }, // Inst #537 = PseudoVADC_VXM_M4 + { 7, &RISCVDescs.OperandInfo[616] }, // Inst #536 = PseudoVADC_VXM_M2 + { 7, &RISCVDescs.OperandInfo[609] }, // Inst #535 = PseudoVADC_VXM_M1 + { 7, &RISCVDescs.OperandInfo[581] }, // Inst #534 = PseudoVADC_VVM_MF8 + { 7, &RISCVDescs.OperandInfo[581] }, // Inst #533 = PseudoVADC_VVM_MF4 + { 7, &RISCVDescs.OperandInfo[581] }, // Inst #532 = PseudoVADC_VVM_MF2 + { 7, &RISCVDescs.OperandInfo[602] }, // Inst #531 = PseudoVADC_VVM_M8 + { 7, &RISCVDescs.OperandInfo[595] }, // Inst #530 = PseudoVADC_VVM_M4 + { 7, &RISCVDescs.OperandInfo[588] }, // Inst #529 = PseudoVADC_VVM_M2 + { 7, &RISCVDescs.OperandInfo[581] }, // Inst #528 = PseudoVADC_VVM_M1 + { 7, &RISCVDescs.OperandInfo[553] }, // Inst #527 = PseudoVADC_VIM_MF8 + { 7, &RISCVDescs.OperandInfo[553] }, // Inst #526 = PseudoVADC_VIM_MF4 + { 7, &RISCVDescs.OperandInfo[553] }, // Inst #525 = PseudoVADC_VIM_MF2 + { 7, &RISCVDescs.OperandInfo[574] }, // Inst #524 = PseudoVADC_VIM_M8 + { 7, &RISCVDescs.OperandInfo[567] }, // Inst #523 = PseudoVADC_VIM_M4 + { 7, &RISCVDescs.OperandInfo[560] }, // Inst #522 = PseudoVADC_VIM_M2 + { 7, &RISCVDescs.OperandInfo[553] }, // Inst #521 = PseudoVADC_VIM_M1 + { 9, &RISCVDescs.OperandInfo[493] }, // Inst #520 = PseudoVAADD_VX_MF8_MASK + { 8, &RISCVDescs.OperandInfo[485] }, // Inst #519 = PseudoVAADD_VX_MF8 + { 9, &RISCVDescs.OperandInfo[493] }, // Inst #518 = PseudoVAADD_VX_MF4_MASK + { 8, &RISCVDescs.OperandInfo[485] }, // Inst #517 = PseudoVAADD_VX_MF4 + { 9, &RISCVDescs.OperandInfo[493] }, // Inst #516 = PseudoVAADD_VX_MF2_MASK + { 8, &RISCVDescs.OperandInfo[485] }, // Inst #515 = PseudoVAADD_VX_MF2 + { 9, &RISCVDescs.OperandInfo[544] }, // Inst #514 = PseudoVAADD_VX_M8_MASK + { 8, &RISCVDescs.OperandInfo[536] }, // Inst #513 = PseudoVAADD_VX_M8 + { 9, &RISCVDescs.OperandInfo[527] }, // Inst #512 = PseudoVAADD_VX_M4_MASK + { 8, &RISCVDescs.OperandInfo[519] }, // Inst #511 = PseudoVAADD_VX_M4 + { 9, &RISCVDescs.OperandInfo[510] }, // Inst #510 = PseudoVAADD_VX_M2_MASK + { 8, &RISCVDescs.OperandInfo[502] }, // Inst #509 = PseudoVAADD_VX_M2 + { 9, &RISCVDescs.OperandInfo[493] }, // Inst #508 = PseudoVAADD_VX_M1_MASK + { 8, &RISCVDescs.OperandInfo[485] }, // Inst #507 = PseudoVAADD_VX_M1 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #506 = PseudoVAADD_VV_MF8_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #505 = PseudoVAADD_VV_MF8 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #504 = PseudoVAADD_VV_MF4_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #503 = PseudoVAADD_VV_MF4 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #502 = PseudoVAADD_VV_MF2_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #501 = PseudoVAADD_VV_MF2 + { 9, &RISCVDescs.OperandInfo[476] }, // Inst #500 = PseudoVAADD_VV_M8_MASK + { 8, &RISCVDescs.OperandInfo[468] }, // Inst #499 = PseudoVAADD_VV_M8 + { 9, &RISCVDescs.OperandInfo[459] }, // Inst #498 = PseudoVAADD_VV_M4_MASK + { 8, &RISCVDescs.OperandInfo[451] }, // Inst #497 = PseudoVAADD_VV_M4 + { 9, &RISCVDescs.OperandInfo[442] }, // Inst #496 = PseudoVAADD_VV_M2_MASK + { 8, &RISCVDescs.OperandInfo[434] }, // Inst #495 = PseudoVAADD_VV_M2 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #494 = PseudoVAADD_VV_M1_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #493 = PseudoVAADD_VV_M1 + { 9, &RISCVDescs.OperandInfo[493] }, // Inst #492 = PseudoVAADDU_VX_MF8_MASK + { 8, &RISCVDescs.OperandInfo[485] }, // Inst #491 = PseudoVAADDU_VX_MF8 + { 9, &RISCVDescs.OperandInfo[493] }, // Inst #490 = PseudoVAADDU_VX_MF4_MASK + { 8, &RISCVDescs.OperandInfo[485] }, // Inst #489 = PseudoVAADDU_VX_MF4 + { 9, &RISCVDescs.OperandInfo[493] }, // Inst #488 = PseudoVAADDU_VX_MF2_MASK + { 8, &RISCVDescs.OperandInfo[485] }, // Inst #487 = PseudoVAADDU_VX_MF2 + { 9, &RISCVDescs.OperandInfo[544] }, // Inst #486 = PseudoVAADDU_VX_M8_MASK + { 8, &RISCVDescs.OperandInfo[536] }, // Inst #485 = PseudoVAADDU_VX_M8 + { 9, &RISCVDescs.OperandInfo[527] }, // Inst #484 = PseudoVAADDU_VX_M4_MASK + { 8, &RISCVDescs.OperandInfo[519] }, // Inst #483 = PseudoVAADDU_VX_M4 + { 9, &RISCVDescs.OperandInfo[510] }, // Inst #482 = PseudoVAADDU_VX_M2_MASK + { 8, &RISCVDescs.OperandInfo[502] }, // Inst #481 = PseudoVAADDU_VX_M2 + { 9, &RISCVDescs.OperandInfo[493] }, // Inst #480 = PseudoVAADDU_VX_M1_MASK + { 8, &RISCVDescs.OperandInfo[485] }, // Inst #479 = PseudoVAADDU_VX_M1 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #478 = PseudoVAADDU_VV_MF8_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #477 = PseudoVAADDU_VV_MF8 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #476 = PseudoVAADDU_VV_MF4_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #475 = PseudoVAADDU_VV_MF4 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #474 = PseudoVAADDU_VV_MF2_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #473 = PseudoVAADDU_VV_MF2 + { 9, &RISCVDescs.OperandInfo[476] }, // Inst #472 = PseudoVAADDU_VV_M8_MASK + { 8, &RISCVDescs.OperandInfo[468] }, // Inst #471 = PseudoVAADDU_VV_M8 + { 9, &RISCVDescs.OperandInfo[459] }, // Inst #470 = PseudoVAADDU_VV_M4_MASK + { 8, &RISCVDescs.OperandInfo[451] }, // Inst #469 = PseudoVAADDU_VV_M4 + { 9, &RISCVDescs.OperandInfo[442] }, // Inst #468 = PseudoVAADDU_VV_M2_MASK + { 8, &RISCVDescs.OperandInfo[434] }, // Inst #467 = PseudoVAADDU_VV_M2 + { 9, &RISCVDescs.OperandInfo[425] }, // Inst #466 = PseudoVAADDU_VV_M1_MASK + { 8, &RISCVDescs.OperandInfo[417] }, // Inst #465 = PseudoVAADDU_VV_M1 + { 4, &RISCVDescs.OperandInfo[413] }, // Inst #464 = PseudoTLSDESCCall + { 8, &RISCVDescs.OperandInfo[360] }, // Inst #463 = PseudoTHVdotVMAQA_VX_MF2_MASK + { 7, &RISCVDescs.OperandInfo[353] }, // Inst #462 = PseudoTHVdotVMAQA_VX_MF2 + { 8, &RISCVDescs.OperandInfo[405] }, // Inst #461 = PseudoTHVdotVMAQA_VX_M8_MASK + { 7, &RISCVDescs.OperandInfo[398] }, // Inst #460 = PseudoTHVdotVMAQA_VX_M8 + { 8, &RISCVDescs.OperandInfo[390] }, // Inst #459 = PseudoTHVdotVMAQA_VX_M4_MASK + { 7, &RISCVDescs.OperandInfo[383] }, // Inst #458 = PseudoTHVdotVMAQA_VX_M4 + { 8, &RISCVDescs.OperandInfo[375] }, // Inst #457 = PseudoTHVdotVMAQA_VX_M2_MASK + { 7, &RISCVDescs.OperandInfo[368] }, // Inst #456 = PseudoTHVdotVMAQA_VX_M2 + { 8, &RISCVDescs.OperandInfo[360] }, // Inst #455 = PseudoTHVdotVMAQA_VX_M1_MASK + { 7, &RISCVDescs.OperandInfo[353] }, // Inst #454 = PseudoTHVdotVMAQA_VX_M1 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #453 = PseudoTHVdotVMAQA_VV_MF2_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #452 = PseudoTHVdotVMAQA_VV_MF2 + { 8, &RISCVDescs.OperandInfo[345] }, // Inst #451 = PseudoTHVdotVMAQA_VV_M8_MASK + { 7, &RISCVDescs.OperandInfo[338] }, // Inst #450 = PseudoTHVdotVMAQA_VV_M8 + { 8, &RISCVDescs.OperandInfo[330] }, // Inst #449 = PseudoTHVdotVMAQA_VV_M4_MASK + { 7, &RISCVDescs.OperandInfo[323] }, // Inst #448 = PseudoTHVdotVMAQA_VV_M4 + { 8, &RISCVDescs.OperandInfo[315] }, // Inst #447 = PseudoTHVdotVMAQA_VV_M2_MASK + { 7, &RISCVDescs.OperandInfo[308] }, // Inst #446 = PseudoTHVdotVMAQA_VV_M2 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #445 = PseudoTHVdotVMAQA_VV_M1_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #444 = PseudoTHVdotVMAQA_VV_M1 + { 8, &RISCVDescs.OperandInfo[360] }, // Inst #443 = PseudoTHVdotVMAQAU_VX_MF2_MASK + { 7, &RISCVDescs.OperandInfo[353] }, // Inst #442 = PseudoTHVdotVMAQAU_VX_MF2 + { 8, &RISCVDescs.OperandInfo[405] }, // Inst #441 = PseudoTHVdotVMAQAU_VX_M8_MASK + { 7, &RISCVDescs.OperandInfo[398] }, // Inst #440 = PseudoTHVdotVMAQAU_VX_M8 + { 8, &RISCVDescs.OperandInfo[390] }, // Inst #439 = PseudoTHVdotVMAQAU_VX_M4_MASK + { 7, &RISCVDescs.OperandInfo[383] }, // Inst #438 = PseudoTHVdotVMAQAU_VX_M4 + { 8, &RISCVDescs.OperandInfo[375] }, // Inst #437 = PseudoTHVdotVMAQAU_VX_M2_MASK + { 7, &RISCVDescs.OperandInfo[368] }, // Inst #436 = PseudoTHVdotVMAQAU_VX_M2 + { 8, &RISCVDescs.OperandInfo[360] }, // Inst #435 = PseudoTHVdotVMAQAU_VX_M1_MASK + { 7, &RISCVDescs.OperandInfo[353] }, // Inst #434 = PseudoTHVdotVMAQAU_VX_M1 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #433 = PseudoTHVdotVMAQAU_VV_MF2_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #432 = PseudoTHVdotVMAQAU_VV_MF2 + { 8, &RISCVDescs.OperandInfo[345] }, // Inst #431 = PseudoTHVdotVMAQAU_VV_M8_MASK + { 7, &RISCVDescs.OperandInfo[338] }, // Inst #430 = PseudoTHVdotVMAQAU_VV_M8 + { 8, &RISCVDescs.OperandInfo[330] }, // Inst #429 = PseudoTHVdotVMAQAU_VV_M4_MASK + { 7, &RISCVDescs.OperandInfo[323] }, // Inst #428 = PseudoTHVdotVMAQAU_VV_M4 + { 8, &RISCVDescs.OperandInfo[315] }, // Inst #427 = PseudoTHVdotVMAQAU_VV_M2_MASK + { 7, &RISCVDescs.OperandInfo[308] }, // Inst #426 = PseudoTHVdotVMAQAU_VV_M2 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #425 = PseudoTHVdotVMAQAU_VV_M1_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #424 = PseudoTHVdotVMAQAU_VV_M1 + { 8, &RISCVDescs.OperandInfo[360] }, // Inst #423 = PseudoTHVdotVMAQAUS_VX_MF2_MASK + { 7, &RISCVDescs.OperandInfo[353] }, // Inst #422 = PseudoTHVdotVMAQAUS_VX_MF2 + { 8, &RISCVDescs.OperandInfo[405] }, // Inst #421 = PseudoTHVdotVMAQAUS_VX_M8_MASK + { 7, &RISCVDescs.OperandInfo[398] }, // Inst #420 = PseudoTHVdotVMAQAUS_VX_M8 + { 8, &RISCVDescs.OperandInfo[390] }, // Inst #419 = PseudoTHVdotVMAQAUS_VX_M4_MASK + { 7, &RISCVDescs.OperandInfo[383] }, // Inst #418 = PseudoTHVdotVMAQAUS_VX_M4 + { 8, &RISCVDescs.OperandInfo[375] }, // Inst #417 = PseudoTHVdotVMAQAUS_VX_M2_MASK + { 7, &RISCVDescs.OperandInfo[368] }, // Inst #416 = PseudoTHVdotVMAQAUS_VX_M2 + { 8, &RISCVDescs.OperandInfo[360] }, // Inst #415 = PseudoTHVdotVMAQAUS_VX_M1_MASK + { 7, &RISCVDescs.OperandInfo[353] }, // Inst #414 = PseudoTHVdotVMAQAUS_VX_M1 + { 8, &RISCVDescs.OperandInfo[360] }, // Inst #413 = PseudoTHVdotVMAQASU_VX_MF2_MASK + { 7, &RISCVDescs.OperandInfo[353] }, // Inst #412 = PseudoTHVdotVMAQASU_VX_MF2 + { 8, &RISCVDescs.OperandInfo[405] }, // Inst #411 = PseudoTHVdotVMAQASU_VX_M8_MASK + { 7, &RISCVDescs.OperandInfo[398] }, // Inst #410 = PseudoTHVdotVMAQASU_VX_M8 + { 8, &RISCVDescs.OperandInfo[390] }, // Inst #409 = PseudoTHVdotVMAQASU_VX_M4_MASK + { 7, &RISCVDescs.OperandInfo[383] }, // Inst #408 = PseudoTHVdotVMAQASU_VX_M4 + { 8, &RISCVDescs.OperandInfo[375] }, // Inst #407 = PseudoTHVdotVMAQASU_VX_M2_MASK + { 7, &RISCVDescs.OperandInfo[368] }, // Inst #406 = PseudoTHVdotVMAQASU_VX_M2 + { 8, &RISCVDescs.OperandInfo[360] }, // Inst #405 = PseudoTHVdotVMAQASU_VX_M1_MASK + { 7, &RISCVDescs.OperandInfo[353] }, // Inst #404 = PseudoTHVdotVMAQASU_VX_M1 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #403 = PseudoTHVdotVMAQASU_VV_MF2_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #402 = PseudoTHVdotVMAQASU_VV_MF2 + { 8, &RISCVDescs.OperandInfo[345] }, // Inst #401 = PseudoTHVdotVMAQASU_VV_M8_MASK + { 7, &RISCVDescs.OperandInfo[338] }, // Inst #400 = PseudoTHVdotVMAQASU_VV_M8 + { 8, &RISCVDescs.OperandInfo[330] }, // Inst #399 = PseudoTHVdotVMAQASU_VV_M4_MASK + { 7, &RISCVDescs.OperandInfo[323] }, // Inst #398 = PseudoTHVdotVMAQASU_VV_M4 + { 8, &RISCVDescs.OperandInfo[315] }, // Inst #397 = PseudoTHVdotVMAQASU_VV_M2_MASK + { 7, &RISCVDescs.OperandInfo[308] }, // Inst #396 = PseudoTHVdotVMAQASU_VV_M2 + { 8, &RISCVDescs.OperandInfo[300] }, // Inst #395 = PseudoTHVdotVMAQASU_VV_M1_MASK + { 7, &RISCVDescs.OperandInfo[293] }, // Inst #394 = PseudoTHVdotVMAQASU_VV_M1 + { 1, &RISCVDescs.OperandInfo[292] }, // Inst #393 = PseudoTAILIndirect + { 1, &RISCVDescs.OperandInfo[0] }, // Inst #392 = PseudoTAIL + { 3, &RISCVDescs.OperandInfo[287] }, // Inst #391 = PseudoSW + { 3, &RISCVDescs.OperandInfo[287] }, // Inst #390 = PseudoSH + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #389 = PseudoSEXT_H + { 2, &RISCVDescs.OperandInfo[290] }, // Inst #388 = PseudoSEXT_B + { 3, &RISCVDescs.OperandInfo[287] }, // Inst #387 = PseudoSD + { 3, &RISCVDescs.OperandInfo[287] }, // Inst #386 = PseudoSB + { 1, &RISCVDescs.OperandInfo[286] }, // Inst #385 = PseudoReadVLENB + { 1, &RISCVDescs.OperandInfo[286] }, // Inst #384 = PseudoReadVL + { 1, &RISCVDescs.OperandInfo[285] }, // Inst #383 = PseudoRVVInitUndefM8 + { 1, &RISCVDescs.OperandInfo[284] }, // Inst #382 = PseudoRVVInitUndefM4 + { 1, &RISCVDescs.OperandInfo[283] }, // Inst #381 = PseudoRVVInitUndefM2 + { 1, &RISCVDescs.OperandInfo[282] }, // Inst #380 = PseudoRVVInitUndefM1 + { 3, &RISCVDescs.OperandInfo[279] }, // Inst #379 = PseudoRV32ZdinxSD + { 3, &RISCVDescs.OperandInfo[276] }, // Inst #378 = PseudoRV32ZdinxLD + { 0, &RISCVDescs.OperandInfo[1] }, // Inst #377 = PseudoRET + { 3, &RISCVDescs.OperandInfo[273] }, // Inst #376 = PseudoQuietFLT_S_INX + { 3, &RISCVDescs.OperandInfo[270] }, // Inst #375 = PseudoQuietFLT_S + { 3, &RISCVDescs.OperandInfo[267] }, // Inst #374 = PseudoQuietFLT_H_INX + { 3, &RISCVDescs.OperandInfo[264] }, // Inst #373 = PseudoQuietFLT_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #372 = PseudoQuietFLT_D_INX + { 3, &RISCVDescs.OperandInfo[258] }, // Inst #371 = PseudoQuietFLT_D_IN32X + { 3, &RISCVDescs.OperandInfo[255] }, // Inst #370 = PseudoQuietFLT_D + { 3, &RISCVDescs.OperandInfo[273] }, // Inst #369 = PseudoQuietFLE_S_INX + { 3, &RISCVDescs.OperandInfo[270] }, // Inst #368 = PseudoQuietFLE_S + { 3, &RISCVDescs.OperandInfo[267] }, // Inst #367 = PseudoQuietFLE_H_INX + { 3, &RISCVDescs.OperandInfo[264] }, // Inst #366 = PseudoQuietFLE_H + { 3, &RISCVDescs.OperandInfo[261] }, // Inst #365 = PseudoQuietFLE_D_INX + { 3, &RISCVDescs.OperandInfo[258] }, // Inst #364 = PseudoQuietFLE_D_IN32X + { 3, &RISCVDescs.OperandInfo[255] }, // Inst #363 = PseudoQuietFLE_D + { 2, &RISCVDescs.OperandInfo[253] }, // Inst #362 = PseudoMovImm + { 7, &RISCVDescs.OperandInfo[246] }, // Inst #361 = PseudoMaskedCmpXchg32 + { 6, &RISCVDescs.OperandInfo[189] }, // Inst #360 = PseudoMaskedAtomicSwap32 + { 7, &RISCVDescs.OperandInfo[239] }, // Inst #359 = PseudoMaskedAtomicLoadUMin32 + { 7, &RISCVDescs.OperandInfo[239] }, // Inst #358 = PseudoMaskedAtomicLoadUMax32 + { 6, &RISCVDescs.OperandInfo[189] }, // Inst #357 = PseudoMaskedAtomicLoadSub32 + { 6, &RISCVDescs.OperandInfo[189] }, // Inst #356 = PseudoMaskedAtomicLoadNand32 + { 8, &RISCVDescs.OperandInfo[231] }, // Inst #355 = PseudoMaskedAtomicLoadMin32 + { 8, &RISCVDescs.OperandInfo[231] }, // Inst #354 = PseudoMaskedAtomicLoadMax32 + { 6, &RISCVDescs.OperandInfo[189] }, // Inst #353 = PseudoMaskedAtomicLoadAdd32 + { 3, &RISCVDescs.OperandInfo[228] }, // Inst #352 = PseudoLongBNE + { 3, &RISCVDescs.OperandInfo[228] }, // Inst #351 = PseudoLongBLTU + { 3, &RISCVDescs.OperandInfo[228] }, // Inst #350 = PseudoLongBLT + { 3, &RISCVDescs.OperandInfo[228] }, // Inst #349 = PseudoLongBGEU + { 3, &RISCVDescs.OperandInfo[228] }, // Inst #348 = PseudoLongBGE + { 3, &RISCVDescs.OperandInfo[228] }, // Inst #347 = PseudoLongBEQ + { 2, &RISCVDescs.OperandInfo[161] }, // Inst #346 = PseudoLWU + { 2, &RISCVDescs.OperandInfo[161] }, // Inst #345 = PseudoLW + { 2, &RISCVDescs.OperandInfo[161] }, // Inst #344 = PseudoLLAImm + { 2, &RISCVDescs.OperandInfo[161] }, // Inst #343 = PseudoLLA + { 2, &RISCVDescs.OperandInfo[161] }, // Inst #342 = PseudoLI + { 2, &RISCVDescs.OperandInfo[161] }, // Inst #341 = PseudoLHU + { 2, &RISCVDescs.OperandInfo[161] }, // Inst #340 = PseudoLH + { 2, &RISCVDescs.OperandInfo[161] }, // Inst #339 = PseudoLGA + { 2, &RISCVDescs.OperandInfo[161] }, // Inst #338 = PseudoLD + { 2, &RISCVDescs.OperandInfo[161] }, // Inst #337 = PseudoLBU + { 2, &RISCVDescs.OperandInfo[161] }, // Inst #336 = PseudoLB + { 2, &RISCVDescs.OperandInfo[161] }, // Inst #335 = PseudoLA_TLS_IE + { 2, &RISCVDescs.OperandInfo[161] }, // Inst #334 = PseudoLA_TLS_GD + { 2, &RISCVDescs.OperandInfo[161] }, // Inst #333 = PseudoLA_TLSDESC + { 2, &RISCVDescs.OperandInfo[161] }, // Inst #332 = PseudoLAImm + { 2, &RISCVDescs.OperandInfo[161] }, // Inst #331 = PseudoLA + { 2, &RISCVDescs.OperandInfo[161] }, // Inst #330 = PseudoJump + { 3, &RISCVDescs.OperandInfo[201] }, // Inst #329 = PseudoFSW + { 3, &RISCVDescs.OperandInfo[198] }, // Inst #328 = PseudoFSH + { 3, &RISCVDescs.OperandInfo[195] }, // Inst #327 = PseudoFSD + { 4, &RISCVDescs.OperandInfo[224] }, // Inst #326 = PseudoFROUND_S_INX + { 4, &RISCVDescs.OperandInfo[220] }, // Inst #325 = PseudoFROUND_S + { 4, &RISCVDescs.OperandInfo[216] }, // Inst #324 = PseudoFROUND_H_INX + { 4, &RISCVDescs.OperandInfo[212] }, // Inst #323 = PseudoFROUND_H + { 4, &RISCVDescs.OperandInfo[148] }, // Inst #322 = PseudoFROUND_D_INX + { 4, &RISCVDescs.OperandInfo[208] }, // Inst #321 = PseudoFROUND_D_IN32X + { 4, &RISCVDescs.OperandInfo[204] }, // Inst #320 = PseudoFROUND_D + { 3, &RISCVDescs.OperandInfo[201] }, // Inst #319 = PseudoFLW + { 3, &RISCVDescs.OperandInfo[198] }, // Inst #318 = PseudoFLH + { 3, &RISCVDescs.OperandInfo[195] }, // Inst #317 = PseudoFLD + { 6, &RISCVDescs.OperandInfo[189] }, // Inst #316 = PseudoCmpXchg64 + { 6, &RISCVDescs.OperandInfo[189] }, // Inst #315 = PseudoCmpXchg32 + { 7, &RISCVDescs.OperandInfo[170] }, // Inst #314 = PseudoCCXORI + { 7, &RISCVDescs.OperandInfo[163] }, // Inst #313 = PseudoCCXOR + { 7, &RISCVDescs.OperandInfo[163] }, // Inst #312 = PseudoCCXNOR + { 7, &RISCVDescs.OperandInfo[163] }, // Inst #311 = PseudoCCSUBW + { 7, &RISCVDescs.OperandInfo[163] }, // Inst #310 = PseudoCCSUB + { 7, &RISCVDescs.OperandInfo[163] }, // Inst #309 = PseudoCCSRLW + { 7, &RISCVDescs.OperandInfo[170] }, // Inst #308 = PseudoCCSRLIW + { 7, &RISCVDescs.OperandInfo[170] }, // Inst #307 = PseudoCCSRLI + { 7, &RISCVDescs.OperandInfo[163] }, // Inst #306 = PseudoCCSRL + { 7, &RISCVDescs.OperandInfo[163] }, // Inst #305 = PseudoCCSRAW + { 7, &RISCVDescs.OperandInfo[170] }, // Inst #304 = PseudoCCSRAIW + { 7, &RISCVDescs.OperandInfo[170] }, // Inst #303 = PseudoCCSRAI + { 7, &RISCVDescs.OperandInfo[163] }, // Inst #302 = PseudoCCSRA + { 7, &RISCVDescs.OperandInfo[163] }, // Inst #301 = PseudoCCSLLW + { 7, &RISCVDescs.OperandInfo[170] }, // Inst #300 = PseudoCCSLLIW + { 7, &RISCVDescs.OperandInfo[170] }, // Inst #299 = PseudoCCSLLI + { 7, &RISCVDescs.OperandInfo[163] }, // Inst #298 = PseudoCCSLL + { 7, &RISCVDescs.OperandInfo[163] }, // Inst #297 = PseudoCCORN + { 7, &RISCVDescs.OperandInfo[170] }, // Inst #296 = PseudoCCORI + { 7, &RISCVDescs.OperandInfo[163] }, // Inst #295 = PseudoCCOR + { 6, &RISCVDescs.OperandInfo[183] }, // Inst #294 = PseudoCCMOVGPRNoX0 + { 6, &RISCVDescs.OperandInfo[177] }, // Inst #293 = PseudoCCMOVGPR + { 7, &RISCVDescs.OperandInfo[163] }, // Inst #292 = PseudoCCANDN + { 7, &RISCVDescs.OperandInfo[170] }, // Inst #291 = PseudoCCANDI + { 7, &RISCVDescs.OperandInfo[163] }, // Inst #290 = PseudoCCAND + { 7, &RISCVDescs.OperandInfo[163] }, // Inst #289 = PseudoCCADDW + { 7, &RISCVDescs.OperandInfo[170] }, // Inst #288 = PseudoCCADDIW + { 7, &RISCVDescs.OperandInfo[170] }, // Inst #287 = PseudoCCADDI + { 7, &RISCVDescs.OperandInfo[163] }, // Inst #286 = PseudoCCADD + { 2, &RISCVDescs.OperandInfo[161] }, // Inst #285 = PseudoCALLReg + { 1, &RISCVDescs.OperandInfo[160] }, // Inst #284 = PseudoCALLIndirect + { 1, &RISCVDescs.OperandInfo[0] }, // Inst #283 = PseudoCALL + { 2, &RISCVDescs.OperandInfo[158] }, // Inst #282 = PseudoBRIND + { 1, &RISCVDescs.OperandInfo[157] }, // Inst #281 = PseudoBR + { 5, &RISCVDescs.OperandInfo[152] }, // Inst #280 = PseudoAtomicLoadNand64 + { 5, &RISCVDescs.OperandInfo[152] }, // Inst #279 = PseudoAtomicLoadNand32 + { 4, &RISCVDescs.OperandInfo[148] }, // Inst #278 = PseudoAddTPRel + { 2, &RISCVDescs.OperandInfo[146] }, // Inst #277 = KCFI_CHECK + { 2, &RISCVDescs.OperandInfo[146] }, // Inst #276 = HWASAN_CHECK_MEMACCESS_SHORTGRANULES + { 2, &RISCVDescs.OperandInfo[56] }, // Inst #275 = G_FCLASS + { 3, &RISCVDescs.OperandInfo[143] }, // Inst #274 = BuildPairF64Pseudo_INX + { 3, &RISCVDescs.OperandInfo[140] }, // Inst #273 = BuildPairF64Pseudo + { 2, &RISCVDescs.OperandInfo[21] }, // Inst #272 = ADJCALLSTACKUP + { 2, &RISCVDescs.OperandInfo[21] }, // Inst #271 = ADJCALLSTACKDOWN + { 4, &RISCVDescs.OperandInfo[136] }, // Inst #270 = G_UBFX + { 4, &RISCVDescs.OperandInfo[136] }, // Inst #269 = G_SBFX + { 2, &RISCVDescs.OperandInfo[56] }, // Inst #268 = G_VECREDUCE_UMIN + { 2, &RISCVDescs.OperandInfo[56] }, // Inst #267 = G_VECREDUCE_UMAX + { 2, &RISCVDescs.OperandInfo[56] }, // Inst #266 = G_VECREDUCE_SMIN + { 2, &RISCVDescs.OperandInfo[56] }, // Inst #265 = G_VECREDUCE_SMAX + { 2, &RISCVDescs.OperandInfo[56] }, // Inst #264 = G_VECREDUCE_XOR + { 2, &RISCVDescs.OperandInfo[56] }, // Inst #263 = G_VECREDUCE_OR + { 2, &RISCVDescs.OperandInfo[56] }, // Inst #262 = G_VECREDUCE_AND + { 2, &RISCVDescs.OperandInfo[56] }, // Inst #261 = G_VECREDUCE_MUL + { 2, &RISCVDescs.OperandInfo[56] }, // Inst #260 = G_VECREDUCE_ADD + { 2, &RISCVDescs.OperandInfo[56] }, // Inst #259 = G_VECREDUCE_FMINIMUM + { 2, &RISCVDescs.OperandInfo[56] }, // Inst #258 = G_VECREDUCE_FMAXIMUM + { 2, &RISCVDescs.OperandInfo[56] }, // Inst #257 = G_VECREDUCE_FMIN + { 2, &RISCVDescs.OperandInfo[56] }, // Inst #256 = G_VECREDUCE_FMAX + { 2, &RISCVDescs.OperandInfo[56] }, // Inst #255 = G_VECREDUCE_FMUL + { 2, &RISCVDescs.OperandInfo[56] }, // Inst #254 = G_VECREDUCE_FADD + { 3, &RISCVDescs.OperandInfo[123] }, // Inst #253 = G_VECREDUCE_SEQ_FMUL + { 3, &RISCVDescs.OperandInfo[123] }, // Inst #252 = G_VECREDUCE_SEQ_FADD + { 3, &RISCVDescs.OperandInfo[53] }, // Inst #251 = G_BZERO + { 4, &RISCVDescs.OperandInfo[132] }, // Inst #250 = G_MEMSET + { 4, &RISCVDescs.OperandInfo[132] }, // Inst #249 = G_MEMMOVE + { 3, &RISCVDescs.OperandInfo[123] }, // Inst #248 = G_MEMCPY_INLINE + { 4, &RISCVDescs.OperandInfo[132] }, // Inst #247 = G_MEMCPY + { 2, &RISCVDescs.OperandInfo[130] }, // Inst #246 = G_WRITE_REGISTER + { 2, &RISCVDescs.OperandInfo[51] }, // Inst #245 = G_READ_REGISTER + { 3, &RISCVDescs.OperandInfo[96] }, // Inst #244 = G_STRICT_FLDEXP + { 2, &RISCVDescs.OperandInfo[62] }, // Inst #243 = G_STRICT_FSQRT + { 4, &RISCVDescs.OperandInfo[46] }, // Inst #242 = G_STRICT_FMA + { 3, &RISCVDescs.OperandInfo[43] }, // Inst #241 = G_STRICT_FREM + { 3, &RISCVDescs.OperandInfo[43] }, // Inst #240 = G_STRICT_FDIV + { 3, &RISCVDescs.OperandInfo[43] }, // Inst #239 = G_STRICT_FMUL + { 3, &RISCVDescs.OperandInfo[43] }, // Inst #238 = G_STRICT_FSUB + { 3, &RISCVDescs.OperandInfo[43] }, // Inst #237 = G_STRICT_FADD + { 1, &RISCVDescs.OperandInfo[50] }, // Inst #236 = G_STACKRESTORE + { 1, &RISCVDescs.OperandInfo[50] }, // Inst #235 = G_STACKSAVE + { 3, &RISCVDescs.OperandInfo[64] }, // Inst #234 = G_DYN_STACKALLOC + { 2, &RISCVDescs.OperandInfo[51] }, // Inst #233 = G_JUMP_TABLE + { 2, &RISCVDescs.OperandInfo[51] }, // Inst #232 = G_BLOCK_ADDR + { 2, &RISCVDescs.OperandInfo[56] }, // Inst #231 = G_ADDRSPACE_CAST + { 2, &RISCVDescs.OperandInfo[62] }, // Inst #230 = G_FNEARBYINT + { 2, &RISCVDescs.OperandInfo[62] }, // Inst #229 = G_FRINT + { 2, &RISCVDescs.OperandInfo[62] }, // Inst #228 = G_FFLOOR + { 2, &RISCVDescs.OperandInfo[62] }, // Inst #227 = G_FSQRT + { 2, &RISCVDescs.OperandInfo[62] }, // Inst #226 = G_FSIN + { 2, &RISCVDescs.OperandInfo[62] }, // Inst #225 = G_FCOS + { 2, &RISCVDescs.OperandInfo[62] }, // Inst #224 = G_FCEIL + { 2, &RISCVDescs.OperandInfo[62] }, // Inst #223 = G_BITREVERSE + { 2, &RISCVDescs.OperandInfo[62] }, // Inst #222 = G_BSWAP + { 2, &RISCVDescs.OperandInfo[56] }, // Inst #221 = G_CTPOP + { 2, &RISCVDescs.OperandInfo[56] }, // Inst #220 = G_CTLZ_ZERO_UNDEF + { 2, &RISCVDescs.OperandInfo[56] }, // Inst #219 = G_CTLZ + { 2, &RISCVDescs.OperandInfo[56] }, // Inst #218 = G_CTTZ_ZERO_UNDEF + { 2, &RISCVDescs.OperandInfo[56] }, // Inst #217 = G_CTTZ + { 4, &RISCVDescs.OperandInfo[126] }, // Inst #216 = G_SHUFFLE_VECTOR + { 3, &RISCVDescs.OperandInfo[123] }, // Inst #215 = G_EXTRACT_VECTOR_ELT + { 4, &RISCVDescs.OperandInfo[119] }, // Inst #214 = G_INSERT_VECTOR_ELT + { 3, &RISCVDescs.OperandInfo[116] }, // Inst #213 = G_BRJT + { 1, &RISCVDescs.OperandInfo[0] }, // Inst #212 = G_BR + { 2, &RISCVDescs.OperandInfo[56] }, // Inst #211 = G_LLROUND + { 2, &RISCVDescs.OperandInfo[56] }, // Inst #210 = G_LROUND + { 2, &RISCVDescs.OperandInfo[62] }, // Inst #209 = G_ABS + { 3, &RISCVDescs.OperandInfo[43] }, // Inst #208 = G_UMAX + { 3, &RISCVDescs.OperandInfo[43] }, // Inst #207 = G_UMIN + { 3, &RISCVDescs.OperandInfo[43] }, // Inst #206 = G_SMAX + { 3, &RISCVDescs.OperandInfo[43] }, // Inst #205 = G_SMIN + { 3, &RISCVDescs.OperandInfo[96] }, // Inst #204 = G_PTRMASK + { 3, &RISCVDescs.OperandInfo[96] }, // Inst #203 = G_PTR_ADD + { 0, &RISCVDescs.OperandInfo[1] }, // Inst #202 = G_RESET_FPMODE + { 1, &RISCVDescs.OperandInfo[50] }, // Inst #201 = G_SET_FPMODE + { 1, &RISCVDescs.OperandInfo[50] }, // Inst #200 = G_GET_FPMODE + { 0, &RISCVDescs.OperandInfo[1] }, // Inst #199 = G_RESET_FPENV + { 1, &RISCVDescs.OperandInfo[50] }, // Inst #198 = G_SET_FPENV + { 1, &RISCVDescs.OperandInfo[50] }, // Inst #197 = G_GET_FPENV + { 3, &RISCVDescs.OperandInfo[43] }, // Inst #196 = G_FMAXIMUM + { 3, &RISCVDescs.OperandInfo[43] }, // Inst #195 = G_FMINIMUM + { 3, &RISCVDescs.OperandInfo[43] }, // Inst #194 = G_FMAXNUM_IEEE + { 3, &RISCVDescs.OperandInfo[43] }, // Inst #193 = G_FMINNUM_IEEE + { 3, &RISCVDescs.OperandInfo[43] }, // Inst #192 = G_FMAXNUM + { 3, &RISCVDescs.OperandInfo[43] }, // Inst #191 = G_FMINNUM + { 2, &RISCVDescs.OperandInfo[62] }, // Inst #190 = G_FCANONICALIZE + { 3, &RISCVDescs.OperandInfo[93] }, // Inst #189 = G_IS_FPCLASS + { 3, &RISCVDescs.OperandInfo[96] }, // Inst #188 = G_FCOPYSIGN + { 2, &RISCVDescs.OperandInfo[62] }, // Inst #187 = G_FABS + { 2, &RISCVDescs.OperandInfo[56] }, // Inst #186 = G_UITOFP + { 2, &RISCVDescs.OperandInfo[56] }, // Inst #185 = G_SITOFP + { 2, &RISCVDescs.OperandInfo[56] }, // Inst #184 = G_FPTOUI + { 2, &RISCVDescs.OperandInfo[56] }, // Inst #183 = G_FPTOSI + { 2, &RISCVDescs.OperandInfo[56] }, // Inst #182 = G_FPTRUNC + { 2, &RISCVDescs.OperandInfo[56] }, // Inst #181 = G_FPEXT + { 2, &RISCVDescs.OperandInfo[62] }, // Inst #180 = G_FNEG + { 3, &RISCVDescs.OperandInfo[86] }, // Inst #179 = G_FFREXP + { 3, &RISCVDescs.OperandInfo[96] }, // Inst #178 = G_FLDEXP + { 2, &RISCVDescs.OperandInfo[62] }, // Inst #177 = G_FLOG10 + { 2, &RISCVDescs.OperandInfo[62] }, // Inst #176 = G_FLOG2 + { 2, &RISCVDescs.OperandInfo[62] }, // Inst #175 = G_FLOG + { 2, &RISCVDescs.OperandInfo[62] }, // Inst #174 = G_FEXP10 + { 2, &RISCVDescs.OperandInfo[62] }, // Inst #173 = G_FEXP2 + { 2, &RISCVDescs.OperandInfo[62] }, // Inst #172 = G_FEXP + { 3, &RISCVDescs.OperandInfo[96] }, // Inst #171 = G_FPOWI + { 3, &RISCVDescs.OperandInfo[43] }, // Inst #170 = G_FPOW + { 3, &RISCVDescs.OperandInfo[43] }, // Inst #169 = G_FREM + { 3, &RISCVDescs.OperandInfo[43] }, // Inst #168 = G_FDIV + { 4, &RISCVDescs.OperandInfo[46] }, // Inst #167 = G_FMAD + { 4, &RISCVDescs.OperandInfo[46] }, // Inst #166 = G_FMA + { 3, &RISCVDescs.OperandInfo[43] }, // Inst #165 = G_FMUL + { 3, &RISCVDescs.OperandInfo[43] }, // Inst #164 = G_FSUB + { 3, &RISCVDescs.OperandInfo[43] }, // Inst #163 = G_FADD + { 4, &RISCVDescs.OperandInfo[112] }, // Inst #162 = G_UDIVFIXSAT + { 4, &RISCVDescs.OperandInfo[112] }, // Inst #161 = G_SDIVFIXSAT + { 4, &RISCVDescs.OperandInfo[112] }, // Inst #160 = G_UDIVFIX + { 4, &RISCVDescs.OperandInfo[112] }, // Inst #159 = G_SDIVFIX + { 4, &RISCVDescs.OperandInfo[112] }, // Inst #158 = G_UMULFIXSAT + { 4, &RISCVDescs.OperandInfo[112] }, // Inst #157 = G_SMULFIXSAT + { 4, &RISCVDescs.OperandInfo[112] }, // Inst #156 = G_UMULFIX + { 4, &RISCVDescs.OperandInfo[112] }, // Inst #155 = G_SMULFIX + { 3, &RISCVDescs.OperandInfo[96] }, // Inst #154 = G_SSHLSAT + { 3, &RISCVDescs.OperandInfo[96] }, // Inst #153 = G_USHLSAT + { 3, &RISCVDescs.OperandInfo[43] }, // Inst #152 = G_SSUBSAT + { 3, &RISCVDescs.OperandInfo[43] }, // Inst #151 = G_USUBSAT + { 3, &RISCVDescs.OperandInfo[43] }, // Inst #150 = G_SADDSAT + { 3, &RISCVDescs.OperandInfo[43] }, // Inst #149 = G_UADDSAT + { 3, &RISCVDescs.OperandInfo[43] }, // Inst #148 = G_SMULH + { 3, &RISCVDescs.OperandInfo[43] }, // Inst #147 = G_UMULH + { 4, &RISCVDescs.OperandInfo[82] }, // Inst #146 = G_SMULO + { 4, &RISCVDescs.OperandInfo[82] }, // Inst #145 = G_UMULO + { 5, &RISCVDescs.OperandInfo[107] }, // Inst #144 = G_SSUBE + { 4, &RISCVDescs.OperandInfo[82] }, // Inst #143 = G_SSUBO + { 5, &RISCVDescs.OperandInfo[107] }, // Inst #142 = G_SADDE + { 4, &RISCVDescs.OperandInfo[82] }, // Inst #141 = G_SADDO + { 5, &RISCVDescs.OperandInfo[107] }, // Inst #140 = G_USUBE + { 4, &RISCVDescs.OperandInfo[82] }, // Inst #139 = G_USUBO + { 5, &RISCVDescs.OperandInfo[107] }, // Inst #138 = G_UADDE + { 4, &RISCVDescs.OperandInfo[82] }, // Inst #137 = G_UADDO + { 4, &RISCVDescs.OperandInfo[82] }, // Inst #136 = G_SELECT + { 4, &RISCVDescs.OperandInfo[103] }, // Inst #135 = G_FCMP + { 4, &RISCVDescs.OperandInfo[103] }, // Inst #134 = G_ICMP + { 3, &RISCVDescs.OperandInfo[96] }, // Inst #133 = G_ROTL + { 3, &RISCVDescs.OperandInfo[96] }, // Inst #132 = G_ROTR + { 4, &RISCVDescs.OperandInfo[99] }, // Inst #131 = G_FSHR + { 4, &RISCVDescs.OperandInfo[99] }, // Inst #130 = G_FSHL + { 3, &RISCVDescs.OperandInfo[96] }, // Inst #129 = G_ASHR + { 3, &RISCVDescs.OperandInfo[96] }, // Inst #128 = G_LSHR + { 3, &RISCVDescs.OperandInfo[96] }, // Inst #127 = G_SHL + { 2, &RISCVDescs.OperandInfo[56] }, // Inst #126 = G_ZEXT + { 3, &RISCVDescs.OperandInfo[40] }, // Inst #125 = G_SEXT_INREG + { 2, &RISCVDescs.OperandInfo[56] }, // Inst #124 = G_SEXT + { 3, &RISCVDescs.OperandInfo[93] }, // Inst #123 = G_VAARG + { 1, &RISCVDescs.OperandInfo[50] }, // Inst #122 = G_VASTART + { 2, &RISCVDescs.OperandInfo[51] }, // Inst #121 = G_FCONSTANT + { 2, &RISCVDescs.OperandInfo[51] }, // Inst #120 = G_CONSTANT + { 2, &RISCVDescs.OperandInfo[56] }, // Inst #119 = G_TRUNC + { 2, &RISCVDescs.OperandInfo[56] }, // Inst #118 = G_ANYEXT + { 1, &RISCVDescs.OperandInfo[0] }, // Inst #117 = G_INTRINSIC_CONVERGENT_W_SIDE_EFFECTS + { 1, &RISCVDescs.OperandInfo[0] }, // Inst #116 = G_INTRINSIC_CONVERGENT + { 1, &RISCVDescs.OperandInfo[0] }, // Inst #115 = G_INTRINSIC_W_SIDE_EFFECTS + { 1, &RISCVDescs.OperandInfo[0] }, // Inst #114 = G_INTRINSIC + { 0, &RISCVDescs.OperandInfo[1] }, // Inst #113 = G_INVOKE_REGION_START + { 1, &RISCVDescs.OperandInfo[50] }, // Inst #112 = G_BRINDIRECT + { 2, &RISCVDescs.OperandInfo[51] }, // Inst #111 = G_BRCOND + { 4, &RISCVDescs.OperandInfo[89] }, // Inst #110 = G_PREFETCH + { 2, &RISCVDescs.OperandInfo[21] }, // Inst #109 = G_FENCE + { 3, &RISCVDescs.OperandInfo[86] }, // Inst #108 = G_ATOMICRMW_UDEC_WRAP + { 3, &RISCVDescs.OperandInfo[86] }, // Inst #107 = G_ATOMICRMW_UINC_WRAP + { 3, &RISCVDescs.OperandInfo[86] }, // Inst #106 = G_ATOMICRMW_FMIN + { 3, &RISCVDescs.OperandInfo[86] }, // Inst #105 = G_ATOMICRMW_FMAX + { 3, &RISCVDescs.OperandInfo[86] }, // Inst #104 = G_ATOMICRMW_FSUB + { 3, &RISCVDescs.OperandInfo[86] }, // Inst #103 = G_ATOMICRMW_FADD + { 3, &RISCVDescs.OperandInfo[86] }, // Inst #102 = G_ATOMICRMW_UMIN + { 3, &RISCVDescs.OperandInfo[86] }, // Inst #101 = G_ATOMICRMW_UMAX + { 3, &RISCVDescs.OperandInfo[86] }, // Inst #100 = G_ATOMICRMW_MIN + { 3, &RISCVDescs.OperandInfo[86] }, // Inst #99 = G_ATOMICRMW_MAX + { 3, &RISCVDescs.OperandInfo[86] }, // Inst #98 = G_ATOMICRMW_XOR + { 3, &RISCVDescs.OperandInfo[86] }, // Inst #97 = G_ATOMICRMW_OR + { 3, &RISCVDescs.OperandInfo[86] }, // Inst #96 = G_ATOMICRMW_NAND + { 3, &RISCVDescs.OperandInfo[86] }, // Inst #95 = G_ATOMICRMW_AND + { 3, &RISCVDescs.OperandInfo[86] }, // Inst #94 = G_ATOMICRMW_SUB + { 3, &RISCVDescs.OperandInfo[86] }, // Inst #93 = G_ATOMICRMW_ADD + { 3, &RISCVDescs.OperandInfo[86] }, // Inst #92 = G_ATOMICRMW_XCHG + { 4, &RISCVDescs.OperandInfo[82] }, // Inst #91 = G_ATOMIC_CMPXCHG + { 5, &RISCVDescs.OperandInfo[77] }, // Inst #90 = G_ATOMIC_CMPXCHG_WITH_SUCCESS + { 5, &RISCVDescs.OperandInfo[72] }, // Inst #89 = G_INDEXED_STORE + { 2, &RISCVDescs.OperandInfo[56] }, // Inst #88 = G_STORE + { 5, &RISCVDescs.OperandInfo[67] }, // Inst #87 = G_INDEXED_ZEXTLOAD + { 5, &RISCVDescs.OperandInfo[67] }, // Inst #86 = G_INDEXED_SEXTLOAD + { 5, &RISCVDescs.OperandInfo[67] }, // Inst #85 = G_INDEXED_LOAD + { 2, &RISCVDescs.OperandInfo[56] }, // Inst #84 = G_ZEXTLOAD + { 2, &RISCVDescs.OperandInfo[56] }, // Inst #83 = G_SEXTLOAD + { 2, &RISCVDescs.OperandInfo[56] }, // Inst #82 = G_LOAD + { 1, &RISCVDescs.OperandInfo[50] }, // Inst #81 = G_READCYCLECOUNTER + { 2, &RISCVDescs.OperandInfo[62] }, // Inst #80 = G_INTRINSIC_ROUNDEVEN + { 2, &RISCVDescs.OperandInfo[56] }, // Inst #79 = G_INTRINSIC_LRINT + { 2, &RISCVDescs.OperandInfo[62] }, // Inst #78 = G_INTRINSIC_ROUND + { 2, &RISCVDescs.OperandInfo[62] }, // Inst #77 = G_INTRINSIC_TRUNC + { 3, &RISCVDescs.OperandInfo[64] }, // Inst #76 = G_INTRINSIC_FPTRUNC_ROUND + { 2, &RISCVDescs.OperandInfo[62] }, // Inst #75 = G_CONSTANT_FOLD_BARRIER + { 2, &RISCVDescs.OperandInfo[62] }, // Inst #74 = G_FREEZE + { 2, &RISCVDescs.OperandInfo[56] }, // Inst #73 = G_BITCAST + { 2, &RISCVDescs.OperandInfo[56] }, // Inst #72 = G_INTTOPTR + { 2, &RISCVDescs.OperandInfo[56] }, // Inst #71 = G_PTRTOINT + { 2, &RISCVDescs.OperandInfo[56] }, // Inst #70 = G_CONCAT_VECTORS + { 2, &RISCVDescs.OperandInfo[56] }, // Inst #69 = G_BUILD_VECTOR_TRUNC + { 2, &RISCVDescs.OperandInfo[56] }, // Inst #68 = G_BUILD_VECTOR + { 2, &RISCVDescs.OperandInfo[56] }, // Inst #67 = G_MERGE_VALUES + { 4, &RISCVDescs.OperandInfo[58] }, // Inst #66 = G_INSERT + { 2, &RISCVDescs.OperandInfo[56] }, // Inst #65 = G_UNMERGE_VALUES + { 3, &RISCVDescs.OperandInfo[53] }, // Inst #64 = G_EXTRACT + { 2, &RISCVDescs.OperandInfo[51] }, // Inst #63 = G_CONSTANT_POOL + { 2, &RISCVDescs.OperandInfo[51] }, // Inst #62 = G_GLOBAL_VALUE + { 2, &RISCVDescs.OperandInfo[51] }, // Inst #61 = G_FRAME_INDEX + { 1, &RISCVDescs.OperandInfo[50] }, // Inst #60 = G_PHI + { 1, &RISCVDescs.OperandInfo[50] }, // Inst #59 = G_IMPLICIT_DEF + { 3, &RISCVDescs.OperandInfo[43] }, // Inst #58 = G_XOR + { 3, &RISCVDescs.OperandInfo[43] }, // Inst #57 = G_OR + { 3, &RISCVDescs.OperandInfo[43] }, // Inst #56 = G_AND + { 4, &RISCVDescs.OperandInfo[46] }, // Inst #55 = G_UDIVREM + { 4, &RISCVDescs.OperandInfo[46] }, // Inst #54 = G_SDIVREM + { 3, &RISCVDescs.OperandInfo[43] }, // Inst #53 = G_UREM + { 3, &RISCVDescs.OperandInfo[43] }, // Inst #52 = G_SREM + { 3, &RISCVDescs.OperandInfo[43] }, // Inst #51 = G_UDIV + { 3, &RISCVDescs.OperandInfo[43] }, // Inst #50 = G_SDIV + { 3, &RISCVDescs.OperandInfo[43] }, // Inst #49 = G_MUL + { 3, &RISCVDescs.OperandInfo[43] }, // Inst #48 = G_SUB + { 3, &RISCVDescs.OperandInfo[43] }, // Inst #47 = G_ADD + { 3, &RISCVDescs.OperandInfo[40] }, // Inst #46 = G_ASSERT_ALIGN + { 3, &RISCVDescs.OperandInfo[40] }, // Inst #45 = G_ASSERT_ZEXT + { 3, &RISCVDescs.OperandInfo[40] }, // Inst #44 = G_ASSERT_SEXT + { 1, &RISCVDescs.OperandInfo[1] }, // Inst #43 = JUMP_TABLE_DEBUG_INFO + { 0, &RISCVDescs.OperandInfo[1] }, // Inst #42 = MEMBARRIER + { 0, &RISCVDescs.OperandInfo[1] }, // Inst #41 = ICALL_BRANCH_FUNNEL + { 3, &RISCVDescs.OperandInfo[37] }, // Inst #40 = PATCHABLE_TYPED_EVENT_CALL + { 2, &RISCVDescs.OperandInfo[35] }, // Inst #39 = PATCHABLE_EVENT_CALL + { 0, &RISCVDescs.OperandInfo[1] }, // Inst #38 = PATCHABLE_TAIL_CALL + { 0, &RISCVDescs.OperandInfo[1] }, // Inst #37 = PATCHABLE_FUNCTION_EXIT + { 0, &RISCVDescs.OperandInfo[1] }, // Inst #36 = PATCHABLE_RET + { 0, &RISCVDescs.OperandInfo[1] }, // Inst #35 = PATCHABLE_FUNCTION_ENTER + { 0, &RISCVDescs.OperandInfo[1] }, // Inst #34 = PATCHABLE_OP + { 1, &RISCVDescs.OperandInfo[0] }, // Inst #33 = FAULTING_OP + { 2, &RISCVDescs.OperandInfo[33] }, // Inst #32 = LOCAL_ESCAPE + { 0, &RISCVDescs.OperandInfo[1] }, // Inst #31 = STATEPOINT + { 3, &RISCVDescs.OperandInfo[30] }, // Inst #30 = PREALLOCATED_ARG + { 1, &RISCVDescs.OperandInfo[1] }, // Inst #29 = PREALLOCATED_SETUP + { 1, &RISCVDescs.OperandInfo[29] }, // Inst #28 = LOAD_STACK_GUARD + { 6, &RISCVDescs.OperandInfo[23] }, // Inst #27 = PATCHPOINT + { 0, &RISCVDescs.OperandInfo[1] }, // Inst #26 = FENTRY_CALL + { 2, &RISCVDescs.OperandInfo[21] }, // Inst #25 = STACKMAP + { 2, &RISCVDescs.OperandInfo[19] }, // Inst #24 = ARITH_FENCE + { 4, &RISCVDescs.OperandInfo[15] }, // Inst #23 = PSEUDO_PROBE + { 1, &RISCVDescs.OperandInfo[1] }, // Inst #22 = LIFETIME_END + { 1, &RISCVDescs.OperandInfo[1] }, // Inst #21 = LIFETIME_START + { 0, &RISCVDescs.OperandInfo[1] }, // Inst #20 = BUNDLE + { 2, &RISCVDescs.OperandInfo[13] }, // Inst #19 = COPY + { 2, &RISCVDescs.OperandInfo[13] }, // Inst #18 = REG_SEQUENCE + { 1, &RISCVDescs.OperandInfo[0] }, // Inst #17 = DBG_LABEL + { 0, &RISCVDescs.OperandInfo[1] }, // Inst #16 = DBG_PHI + { 0, &RISCVDescs.OperandInfo[1] }, // Inst #15 = DBG_INSTR_REF + { 0, &RISCVDescs.OperandInfo[1] }, // Inst #14 = DBG_VALUE_LIST + { 0, &RISCVDescs.OperandInfo[1] }, // Inst #13 = DBG_VALUE + { 3, &RISCVDescs.OperandInfo[2] }, // Inst #12 = COPY_TO_REGCLASS + { 4, &RISCVDescs.OperandInfo[9] }, // Inst #11 = SUBREG_TO_REG + { 1, &RISCVDescs.OperandInfo[0] }, // Inst #10 = IMPLICIT_DEF + { 4, &RISCVDescs.OperandInfo[5] }, // Inst #9 = INSERT_SUBREG + { 3, &RISCVDescs.OperandInfo[2] }, // Inst #8 = EXTRACT_SUBREG + { 0, &RISCVDescs.OperandInfo[1] }, // Inst #7 = KILL + { 1, &RISCVDescs.OperandInfo[1] }, // Inst #6 = ANNOTATION_LABEL + { 1, &RISCVDescs.OperandInfo[1] }, // Inst #5 = GC_LABEL + { 1, &RISCVDescs.OperandInfo[1] }, // Inst #4 = EH_LABEL + { 1, &RISCVDescs.OperandInfo[1] }, // Inst #3 = CFI_INSTRUCTION + { 0, &RISCVDescs.OperandInfo[1] }, // Inst #2 = INLINEASM_BR + { 0, &RISCVDescs.OperandInfo[1] }, // Inst #1 = INLINEASM + { 1, &RISCVDescs.OperandInfo[0] }, // Inst #0 = PHI + }, { + /* 0 */ { -1, 0, MCOI_OPERAND_UNKNOWN, 0 }, + /* 1 */ + /* 1 */ { -1, 0, MCOI_OPERAND_IMMEDIATE, 0 }, + /* 2 */ { -1, 0, MCOI_OPERAND_UNKNOWN, 0 }, { -1, 0, MCOI_OPERAND_UNKNOWN, 0 }, { -1, 0, MCOI_OPERAND_IMMEDIATE, 0 }, + /* 5 */ { -1, 0, MCOI_OPERAND_UNKNOWN, 0 }, { -1, 0, MCOI_OPERAND_UNKNOWN, CONSTRAINT_MCOI_TIED_TO(0) }, { -1, 0, MCOI_OPERAND_UNKNOWN, 0 }, { -1, 0, MCOI_OPERAND_IMMEDIATE, 0 }, + /* 9 */ { -1, 0, MCOI_OPERAND_UNKNOWN, 0 }, { -1, 0, MCOI_OPERAND_UNKNOWN, 0 }, { -1, 0, MCOI_OPERAND_UNKNOWN, 0 }, { -1, 0, MCOI_OPERAND_IMMEDIATE, 0 }, + /* 13 */ { -1, 0, MCOI_OPERAND_UNKNOWN, 0 }, { -1, 0, MCOI_OPERAND_UNKNOWN, 0 }, + /* 15 */ { -1, 0, MCOI_OPERAND_IMMEDIATE, 0 }, { -1, 0, MCOI_OPERAND_IMMEDIATE, 0 }, { -1, 0, MCOI_OPERAND_IMMEDIATE, 0 }, { -1, 0, MCOI_OPERAND_IMMEDIATE, 0 }, + /* 19 */ { -1, 0, MCOI_OPERAND_UNKNOWN, 0 }, { -1, 0, MCOI_OPERAND_UNKNOWN, CONSTRAINT_MCOI_TIED_TO(0) }, + /* 21 */ { -1, 0, MCOI_OPERAND_IMMEDIATE, 0 }, { -1, 0, MCOI_OPERAND_IMMEDIATE, 0 }, + /* 23 */ { -1, 0, MCOI_OPERAND_UNKNOWN, 0 }, { -1, 0, MCOI_OPERAND_IMMEDIATE, 0 }, { -1, 0, MCOI_OPERAND_IMMEDIATE, 0 }, { -1, 0, MCOI_OPERAND_UNKNOWN, 0 }, { -1, 0, MCOI_OPERAND_IMMEDIATE, 0 }, { -1, 0, MCOI_OPERAND_IMMEDIATE, 0 }, + /* 29 */ { 0, 0|(1<, 2013-2015 */ - - #ifdef GET_REGINFO_ENUM #undef GET_REGINFO_ENUM enum { RISCV_NoRegister, - RISCV_X0 = 1, - RISCV_X1 = 2, - RISCV_X2 = 3, - RISCV_X3 = 4, - RISCV_X4 = 5, - RISCV_X5 = 6, - RISCV_X6 = 7, - RISCV_X7 = 8, - RISCV_X8 = 9, - RISCV_X9 = 10, - RISCV_X10 = 11, - RISCV_X11 = 12, - RISCV_X12 = 13, - RISCV_X13 = 14, - RISCV_X14 = 15, - RISCV_X15 = 16, - RISCV_X16 = 17, - RISCV_X17 = 18, - RISCV_X18 = 19, - RISCV_X19 = 20, - RISCV_X20 = 21, - RISCV_X21 = 22, - RISCV_X22 = 23, - RISCV_X23 = 24, - RISCV_X24 = 25, - RISCV_X25 = 26, - RISCV_X26 = 27, - RISCV_X27 = 28, - RISCV_X28 = 29, - RISCV_X29 = 30, - RISCV_X30 = 31, - RISCV_X31 = 32, - RISCV_F0_32 = 33, - RISCV_F0_64 = 34, - RISCV_F1_32 = 35, - RISCV_F1_64 = 36, - RISCV_F2_32 = 37, - RISCV_F2_64 = 38, - RISCV_F3_32 = 39, - RISCV_F3_64 = 40, - RISCV_F4_32 = 41, - RISCV_F4_64 = 42, - RISCV_F5_32 = 43, - RISCV_F5_64 = 44, - RISCV_F6_32 = 45, - RISCV_F6_64 = 46, - RISCV_F7_32 = 47, - RISCV_F7_64 = 48, - RISCV_F8_32 = 49, - RISCV_F8_64 = 50, - RISCV_F9_32 = 51, - RISCV_F9_64 = 52, - RISCV_F10_32 = 53, - RISCV_F10_64 = 54, - RISCV_F11_32 = 55, - RISCV_F11_64 = 56, - RISCV_F12_32 = 57, - RISCV_F12_64 = 58, - RISCV_F13_32 = 59, - RISCV_F13_64 = 60, - RISCV_F14_32 = 61, - RISCV_F14_64 = 62, - RISCV_F15_32 = 63, - RISCV_F15_64 = 64, - RISCV_F16_32 = 65, - RISCV_F16_64 = 66, - RISCV_F17_32 = 67, - RISCV_F17_64 = 68, - RISCV_F18_32 = 69, - RISCV_F18_64 = 70, - RISCV_F19_32 = 71, - RISCV_F19_64 = 72, - RISCV_F20_32 = 73, - RISCV_F20_64 = 74, - RISCV_F21_32 = 75, - RISCV_F21_64 = 76, - RISCV_F22_32 = 77, - RISCV_F22_64 = 78, - RISCV_F23_32 = 79, - RISCV_F23_64 = 80, - RISCV_F24_32 = 81, - RISCV_F24_64 = 82, - RISCV_F25_32 = 83, - RISCV_F25_64 = 84, - RISCV_F26_32 = 85, - RISCV_F26_64 = 86, - RISCV_F27_32 = 87, - RISCV_F27_64 = 88, - RISCV_F28_32 = 89, - RISCV_F28_64 = 90, - RISCV_F29_32 = 91, - RISCV_F29_64 = 92, - RISCV_F30_32 = 93, - RISCV_F30_64 = 94, - RISCV_F31_32 = 95, - RISCV_F31_64 = 96, - RISCV_NUM_TARGET_REGS // 97 + RISCV_FFLAGS = 1, + RISCV_FRM = 2, + RISCV_SSP = 3, + RISCV_VL = 4, + RISCV_VLENB = 5, + RISCV_VTYPE = 6, + RISCV_VXRM = 7, + RISCV_VXSAT = 8, + RISCV_DUMMY_REG_PAIR_WITH_X0 = 9, + RISCV_V0 = 10, + RISCV_V1 = 11, + RISCV_V2 = 12, + RISCV_V3 = 13, + RISCV_V4 = 14, + RISCV_V5 = 15, + RISCV_V6 = 16, + RISCV_V7 = 17, + RISCV_V8 = 18, + RISCV_V9 = 19, + RISCV_V10 = 20, + RISCV_V11 = 21, + RISCV_V12 = 22, + RISCV_V13 = 23, + RISCV_V14 = 24, + RISCV_V15 = 25, + RISCV_V16 = 26, + RISCV_V17 = 27, + RISCV_V18 = 28, + RISCV_V19 = 29, + RISCV_V20 = 30, + RISCV_V21 = 31, + RISCV_V22 = 32, + RISCV_V23 = 33, + RISCV_V24 = 34, + RISCV_V25 = 35, + RISCV_V26 = 36, + RISCV_V27 = 37, + RISCV_V28 = 38, + RISCV_V29 = 39, + RISCV_V30 = 40, + RISCV_V31 = 41, + RISCV_X0 = 42, + RISCV_X1 = 43, + RISCV_X2 = 44, + RISCV_X3 = 45, + RISCV_X4 = 46, + RISCV_X5 = 47, + RISCV_X6 = 48, + RISCV_X7 = 49, + RISCV_X8 = 50, + RISCV_X9 = 51, + RISCV_X10 = 52, + RISCV_X11 = 53, + RISCV_X12 = 54, + RISCV_X13 = 55, + RISCV_X14 = 56, + RISCV_X15 = 57, + RISCV_X16 = 58, + RISCV_X17 = 59, + RISCV_X18 = 60, + RISCV_X19 = 61, + RISCV_X20 = 62, + RISCV_X21 = 63, + RISCV_X22 = 64, + RISCV_X23 = 65, + RISCV_X24 = 66, + RISCV_X25 = 67, + RISCV_X26 = 68, + RISCV_X27 = 69, + RISCV_X28 = 70, + RISCV_X29 = 71, + RISCV_X30 = 72, + RISCV_X31 = 73, + RISCV_F0_D = 74, + RISCV_F1_D = 75, + RISCV_F2_D = 76, + RISCV_F3_D = 77, + RISCV_F4_D = 78, + RISCV_F5_D = 79, + RISCV_F6_D = 80, + RISCV_F7_D = 81, + RISCV_F8_D = 82, + RISCV_F9_D = 83, + RISCV_F10_D = 84, + RISCV_F11_D = 85, + RISCV_F12_D = 86, + RISCV_F13_D = 87, + RISCV_F14_D = 88, + RISCV_F15_D = 89, + RISCV_F16_D = 90, + RISCV_F17_D = 91, + RISCV_F18_D = 92, + RISCV_F19_D = 93, + RISCV_F20_D = 94, + RISCV_F21_D = 95, + RISCV_F22_D = 96, + RISCV_F23_D = 97, + RISCV_F24_D = 98, + RISCV_F25_D = 99, + RISCV_F26_D = 100, + RISCV_F27_D = 101, + RISCV_F28_D = 102, + RISCV_F29_D = 103, + RISCV_F30_D = 104, + RISCV_F31_D = 105, + RISCV_F0_F = 106, + RISCV_F1_F = 107, + RISCV_F2_F = 108, + RISCV_F3_F = 109, + RISCV_F4_F = 110, + RISCV_F5_F = 111, + RISCV_F6_F = 112, + RISCV_F7_F = 113, + RISCV_F8_F = 114, + RISCV_F9_F = 115, + RISCV_F10_F = 116, + RISCV_F11_F = 117, + RISCV_F12_F = 118, + RISCV_F13_F = 119, + RISCV_F14_F = 120, + RISCV_F15_F = 121, + RISCV_F16_F = 122, + RISCV_F17_F = 123, + RISCV_F18_F = 124, + RISCV_F19_F = 125, + RISCV_F20_F = 126, + RISCV_F21_F = 127, + RISCV_F22_F = 128, + RISCV_F23_F = 129, + RISCV_F24_F = 130, + RISCV_F25_F = 131, + RISCV_F26_F = 132, + RISCV_F27_F = 133, + RISCV_F28_F = 134, + RISCV_F29_F = 135, + RISCV_F30_F = 136, + RISCV_F31_F = 137, + RISCV_F0_H = 138, + RISCV_F1_H = 139, + RISCV_F2_H = 140, + RISCV_F3_H = 141, + RISCV_F4_H = 142, + RISCV_F5_H = 143, + RISCV_F6_H = 144, + RISCV_F7_H = 145, + RISCV_F8_H = 146, + RISCV_F9_H = 147, + RISCV_F10_H = 148, + RISCV_F11_H = 149, + RISCV_F12_H = 150, + RISCV_F13_H = 151, + RISCV_F14_H = 152, + RISCV_F15_H = 153, + RISCV_F16_H = 154, + RISCV_F17_H = 155, + RISCV_F18_H = 156, + RISCV_F19_H = 157, + RISCV_F20_H = 158, + RISCV_F21_H = 159, + RISCV_F22_H = 160, + RISCV_F23_H = 161, + RISCV_F24_H = 162, + RISCV_F25_H = 163, + RISCV_F26_H = 164, + RISCV_F27_H = 165, + RISCV_F28_H = 166, + RISCV_F29_H = 167, + RISCV_F30_H = 168, + RISCV_F31_H = 169, + RISCV_X0_Pair = 170, + RISCV_V0M2 = 171, + RISCV_V0M4 = 172, + RISCV_V0M8 = 173, + RISCV_V2M2 = 174, + RISCV_V4M2 = 175, + RISCV_V4M4 = 176, + RISCV_V6M2 = 177, + RISCV_V8M2 = 178, + RISCV_V8M4 = 179, + RISCV_V8M8 = 180, + RISCV_V10M2 = 181, + RISCV_V12M2 = 182, + RISCV_V12M4 = 183, + RISCV_V14M2 = 184, + RISCV_V16M2 = 185, + RISCV_V16M4 = 186, + RISCV_V16M8 = 187, + RISCV_V18M2 = 188, + RISCV_V20M2 = 189, + RISCV_V20M4 = 190, + RISCV_V22M2 = 191, + RISCV_V24M2 = 192, + RISCV_V24M4 = 193, + RISCV_V24M8 = 194, + RISCV_V26M2 = 195, + RISCV_V28M2 = 196, + RISCV_V28M4 = 197, + RISCV_V30M2 = 198, + RISCV_X2_X3 = 199, + RISCV_X4_X5 = 200, + RISCV_X6_X7 = 201, + RISCV_X8_X9 = 202, + RISCV_X10_X11 = 203, + RISCV_X12_X13 = 204, + RISCV_X14_X15 = 205, + RISCV_X16_X17 = 206, + RISCV_X18_X19 = 207, + RISCV_X20_X21 = 208, + RISCV_X22_X23 = 209, + RISCV_X24_X25 = 210, + RISCV_X26_X27 = 211, + RISCV_X28_X29 = 212, + RISCV_X30_X31 = 213, + RISCV_V1_V2 = 214, + RISCV_V2_V3 = 215, + RISCV_V3_V4 = 216, + RISCV_V4_V5 = 217, + RISCV_V5_V6 = 218, + RISCV_V6_V7 = 219, + RISCV_V7_V8 = 220, + RISCV_V8_V9 = 221, + RISCV_V9_V10 = 222, + RISCV_V10_V11 = 223, + RISCV_V11_V12 = 224, + RISCV_V12_V13 = 225, + RISCV_V13_V14 = 226, + RISCV_V14_V15 = 227, + RISCV_V15_V16 = 228, + RISCV_V16_V17 = 229, + RISCV_V17_V18 = 230, + RISCV_V18_V19 = 231, + RISCV_V19_V20 = 232, + RISCV_V20_V21 = 233, + RISCV_V21_V22 = 234, + RISCV_V22_V23 = 235, + RISCV_V23_V24 = 236, + RISCV_V24_V25 = 237, + RISCV_V25_V26 = 238, + RISCV_V26_V27 = 239, + RISCV_V27_V28 = 240, + RISCV_V28_V29 = 241, + RISCV_V29_V30 = 242, + RISCV_V30_V31 = 243, + RISCV_V0_V1 = 244, + RISCV_V2M2_V4M2 = 245, + RISCV_V4M2_V6M2 = 246, + RISCV_V6M2_V8M2 = 247, + RISCV_V8M2_V10M2 = 248, + RISCV_V10M2_V12M2 = 249, + RISCV_V12M2_V14M2 = 250, + RISCV_V14M2_V16M2 = 251, + RISCV_V16M2_V18M2 = 252, + RISCV_V18M2_V20M2 = 253, + RISCV_V20M2_V22M2 = 254, + RISCV_V22M2_V24M2 = 255, + RISCV_V24M2_V26M2 = 256, + RISCV_V26M2_V28M2 = 257, + RISCV_V28M2_V30M2 = 258, + RISCV_V0M2_V2M2 = 259, + RISCV_V4M4_V8M4 = 260, + RISCV_V8M4_V12M4 = 261, + RISCV_V12M4_V16M4 = 262, + RISCV_V16M4_V20M4 = 263, + RISCV_V20M4_V24M4 = 264, + RISCV_V24M4_V28M4 = 265, + RISCV_V0M4_V4M4 = 266, + RISCV_V1_V2_V3 = 267, + RISCV_V2_V3_V4 = 268, + RISCV_V3_V4_V5 = 269, + RISCV_V4_V5_V6 = 270, + RISCV_V5_V6_V7 = 271, + RISCV_V6_V7_V8 = 272, + RISCV_V7_V8_V9 = 273, + RISCV_V8_V9_V10 = 274, + RISCV_V9_V10_V11 = 275, + RISCV_V10_V11_V12 = 276, + RISCV_V11_V12_V13 = 277, + RISCV_V12_V13_V14 = 278, + RISCV_V13_V14_V15 = 279, + RISCV_V14_V15_V16 = 280, + RISCV_V15_V16_V17 = 281, + RISCV_V16_V17_V18 = 282, + RISCV_V17_V18_V19 = 283, + RISCV_V18_V19_V20 = 284, + RISCV_V19_V20_V21 = 285, + RISCV_V20_V21_V22 = 286, + RISCV_V21_V22_V23 = 287, + RISCV_V22_V23_V24 = 288, + RISCV_V23_V24_V25 = 289, + RISCV_V24_V25_V26 = 290, + RISCV_V25_V26_V27 = 291, + RISCV_V26_V27_V28 = 292, + RISCV_V27_V28_V29 = 293, + RISCV_V28_V29_V30 = 294, + RISCV_V29_V30_V31 = 295, + RISCV_V0_V1_V2 = 296, + RISCV_V2M2_V4M2_V6M2 = 297, + RISCV_V4M2_V6M2_V8M2 = 298, + RISCV_V6M2_V8M2_V10M2 = 299, + RISCV_V8M2_V10M2_V12M2 = 300, + RISCV_V10M2_V12M2_V14M2 = 301, + RISCV_V12M2_V14M2_V16M2 = 302, + RISCV_V14M2_V16M2_V18M2 = 303, + RISCV_V16M2_V18M2_V20M2 = 304, + RISCV_V18M2_V20M2_V22M2 = 305, + RISCV_V20M2_V22M2_V24M2 = 306, + RISCV_V22M2_V24M2_V26M2 = 307, + RISCV_V24M2_V26M2_V28M2 = 308, + RISCV_V26M2_V28M2_V30M2 = 309, + RISCV_V0M2_V2M2_V4M2 = 310, + RISCV_V1_V2_V3_V4 = 311, + RISCV_V2_V3_V4_V5 = 312, + RISCV_V3_V4_V5_V6 = 313, + RISCV_V4_V5_V6_V7 = 314, + RISCV_V5_V6_V7_V8 = 315, + RISCV_V6_V7_V8_V9 = 316, + RISCV_V7_V8_V9_V10 = 317, + RISCV_V8_V9_V10_V11 = 318, + RISCV_V9_V10_V11_V12 = 319, + RISCV_V10_V11_V12_V13 = 320, + RISCV_V11_V12_V13_V14 = 321, + RISCV_V12_V13_V14_V15 = 322, + RISCV_V13_V14_V15_V16 = 323, + RISCV_V14_V15_V16_V17 = 324, + RISCV_V15_V16_V17_V18 = 325, + RISCV_V16_V17_V18_V19 = 326, + RISCV_V17_V18_V19_V20 = 327, + RISCV_V18_V19_V20_V21 = 328, + RISCV_V19_V20_V21_V22 = 329, + RISCV_V20_V21_V22_V23 = 330, + RISCV_V21_V22_V23_V24 = 331, + RISCV_V22_V23_V24_V25 = 332, + RISCV_V23_V24_V25_V26 = 333, + RISCV_V24_V25_V26_V27 = 334, + RISCV_V25_V26_V27_V28 = 335, + RISCV_V26_V27_V28_V29 = 336, + RISCV_V27_V28_V29_V30 = 337, + RISCV_V28_V29_V30_V31 = 338, + RISCV_V0_V1_V2_V3 = 339, + RISCV_V2M2_V4M2_V6M2_V8M2 = 340, + RISCV_V4M2_V6M2_V8M2_V10M2 = 341, + RISCV_V6M2_V8M2_V10M2_V12M2 = 342, + RISCV_V8M2_V10M2_V12M2_V14M2 = 343, + RISCV_V10M2_V12M2_V14M2_V16M2 = 344, + RISCV_V12M2_V14M2_V16M2_V18M2 = 345, + RISCV_V14M2_V16M2_V18M2_V20M2 = 346, + RISCV_V16M2_V18M2_V20M2_V22M2 = 347, + RISCV_V18M2_V20M2_V22M2_V24M2 = 348, + RISCV_V20M2_V22M2_V24M2_V26M2 = 349, + RISCV_V22M2_V24M2_V26M2_V28M2 = 350, + RISCV_V24M2_V26M2_V28M2_V30M2 = 351, + RISCV_V0M2_V2M2_V4M2_V6M2 = 352, + RISCV_V1_V2_V3_V4_V5 = 353, + RISCV_V2_V3_V4_V5_V6 = 354, + RISCV_V3_V4_V5_V6_V7 = 355, + RISCV_V4_V5_V6_V7_V8 = 356, + RISCV_V5_V6_V7_V8_V9 = 357, + RISCV_V6_V7_V8_V9_V10 = 358, + RISCV_V7_V8_V9_V10_V11 = 359, + RISCV_V8_V9_V10_V11_V12 = 360, + RISCV_V9_V10_V11_V12_V13 = 361, + RISCV_V10_V11_V12_V13_V14 = 362, + RISCV_V11_V12_V13_V14_V15 = 363, + RISCV_V12_V13_V14_V15_V16 = 364, + RISCV_V13_V14_V15_V16_V17 = 365, + RISCV_V14_V15_V16_V17_V18 = 366, + RISCV_V15_V16_V17_V18_V19 = 367, + RISCV_V16_V17_V18_V19_V20 = 368, + RISCV_V17_V18_V19_V20_V21 = 369, + RISCV_V18_V19_V20_V21_V22 = 370, + RISCV_V19_V20_V21_V22_V23 = 371, + RISCV_V20_V21_V22_V23_V24 = 372, + RISCV_V21_V22_V23_V24_V25 = 373, + RISCV_V22_V23_V24_V25_V26 = 374, + RISCV_V23_V24_V25_V26_V27 = 375, + RISCV_V24_V25_V26_V27_V28 = 376, + RISCV_V25_V26_V27_V28_V29 = 377, + RISCV_V26_V27_V28_V29_V30 = 378, + RISCV_V27_V28_V29_V30_V31 = 379, + RISCV_V0_V1_V2_V3_V4 = 380, + RISCV_V1_V2_V3_V4_V5_V6 = 381, + RISCV_V2_V3_V4_V5_V6_V7 = 382, + RISCV_V3_V4_V5_V6_V7_V8 = 383, + RISCV_V4_V5_V6_V7_V8_V9 = 384, + RISCV_V5_V6_V7_V8_V9_V10 = 385, + RISCV_V6_V7_V8_V9_V10_V11 = 386, + RISCV_V7_V8_V9_V10_V11_V12 = 387, + RISCV_V8_V9_V10_V11_V12_V13 = 388, + RISCV_V9_V10_V11_V12_V13_V14 = 389, + RISCV_V10_V11_V12_V13_V14_V15 = 390, + RISCV_V11_V12_V13_V14_V15_V16 = 391, + RISCV_V12_V13_V14_V15_V16_V17 = 392, + RISCV_V13_V14_V15_V16_V17_V18 = 393, + RISCV_V14_V15_V16_V17_V18_V19 = 394, + RISCV_V15_V16_V17_V18_V19_V20 = 395, + RISCV_V16_V17_V18_V19_V20_V21 = 396, + RISCV_V17_V18_V19_V20_V21_V22 = 397, + RISCV_V18_V19_V20_V21_V22_V23 = 398, + RISCV_V19_V20_V21_V22_V23_V24 = 399, + RISCV_V20_V21_V22_V23_V24_V25 = 400, + RISCV_V21_V22_V23_V24_V25_V26 = 401, + RISCV_V22_V23_V24_V25_V26_V27 = 402, + RISCV_V23_V24_V25_V26_V27_V28 = 403, + RISCV_V24_V25_V26_V27_V28_V29 = 404, + RISCV_V25_V26_V27_V28_V29_V30 = 405, + RISCV_V26_V27_V28_V29_V30_V31 = 406, + RISCV_V0_V1_V2_V3_V4_V5 = 407, + RISCV_V1_V2_V3_V4_V5_V6_V7 = 408, + RISCV_V2_V3_V4_V5_V6_V7_V8 = 409, + RISCV_V3_V4_V5_V6_V7_V8_V9 = 410, + RISCV_V4_V5_V6_V7_V8_V9_V10 = 411, + RISCV_V5_V6_V7_V8_V9_V10_V11 = 412, + RISCV_V6_V7_V8_V9_V10_V11_V12 = 413, + RISCV_V7_V8_V9_V10_V11_V12_V13 = 414, + RISCV_V8_V9_V10_V11_V12_V13_V14 = 415, + RISCV_V9_V10_V11_V12_V13_V14_V15 = 416, + RISCV_V10_V11_V12_V13_V14_V15_V16 = 417, + RISCV_V11_V12_V13_V14_V15_V16_V17 = 418, + RISCV_V12_V13_V14_V15_V16_V17_V18 = 419, + RISCV_V13_V14_V15_V16_V17_V18_V19 = 420, + RISCV_V14_V15_V16_V17_V18_V19_V20 = 421, + RISCV_V15_V16_V17_V18_V19_V20_V21 = 422, + RISCV_V16_V17_V18_V19_V20_V21_V22 = 423, + RISCV_V17_V18_V19_V20_V21_V22_V23 = 424, + RISCV_V18_V19_V20_V21_V22_V23_V24 = 425, + RISCV_V19_V20_V21_V22_V23_V24_V25 = 426, + RISCV_V20_V21_V22_V23_V24_V25_V26 = 427, + RISCV_V21_V22_V23_V24_V25_V26_V27 = 428, + RISCV_V22_V23_V24_V25_V26_V27_V28 = 429, + RISCV_V23_V24_V25_V26_V27_V28_V29 = 430, + RISCV_V24_V25_V26_V27_V28_V29_V30 = 431, + RISCV_V25_V26_V27_V28_V29_V30_V31 = 432, + RISCV_V0_V1_V2_V3_V4_V5_V6 = 433, + RISCV_V1_V2_V3_V4_V5_V6_V7_V8 = 434, + RISCV_V2_V3_V4_V5_V6_V7_V8_V9 = 435, + RISCV_V3_V4_V5_V6_V7_V8_V9_V10 = 436, + RISCV_V4_V5_V6_V7_V8_V9_V10_V11 = 437, + RISCV_V5_V6_V7_V8_V9_V10_V11_V12 = 438, + RISCV_V6_V7_V8_V9_V10_V11_V12_V13 = 439, + RISCV_V7_V8_V9_V10_V11_V12_V13_V14 = 440, + RISCV_V8_V9_V10_V11_V12_V13_V14_V15 = 441, + RISCV_V9_V10_V11_V12_V13_V14_V15_V16 = 442, + RISCV_V10_V11_V12_V13_V14_V15_V16_V17 = 443, + RISCV_V11_V12_V13_V14_V15_V16_V17_V18 = 444, + RISCV_V12_V13_V14_V15_V16_V17_V18_V19 = 445, + RISCV_V13_V14_V15_V16_V17_V18_V19_V20 = 446, + RISCV_V14_V15_V16_V17_V18_V19_V20_V21 = 447, + RISCV_V15_V16_V17_V18_V19_V20_V21_V22 = 448, + RISCV_V16_V17_V18_V19_V20_V21_V22_V23 = 449, + RISCV_V17_V18_V19_V20_V21_V22_V23_V24 = 450, + RISCV_V18_V19_V20_V21_V22_V23_V24_V25 = 451, + RISCV_V19_V20_V21_V22_V23_V24_V25_V26 = 452, + RISCV_V20_V21_V22_V23_V24_V25_V26_V27 = 453, + RISCV_V21_V22_V23_V24_V25_V26_V27_V28 = 454, + RISCV_V22_V23_V24_V25_V26_V27_V28_V29 = 455, + RISCV_V23_V24_V25_V26_V27_V28_V29_V30 = 456, + RISCV_V24_V25_V26_V27_V28_V29_V30_V31 = 457, + RISCV_V0_V1_V2_V3_V4_V5_V6_V7 = 458, + NUM_TARGET_REGS // 459 }; // Register classes + enum { - RISCV_FPR32RegClassID = 0, - RISCV_GPRRegClassID = 1, - RISCV_GPRNoX0RegClassID = 2, - RISCV_GPRNoX0X2RegClassID = 3, - RISCV_GPRTCRegClassID = 4, - RISCV_FPR32CRegClassID = 5, - RISCV_GPRCRegClassID = 6, - RISCV_GPRC_and_GPRTCRegClassID = 7, - RISCV_SPRegClassID = 8, - RISCV_FPR64RegClassID = 9, - RISCV_FPR64CRegClassID = 10, + RISCV_FPR16RegClassID = 0, + RISCV_GPRAllRegClassID = 1, + RISCV_FPR32RegClassID = 2, + RISCV_GPRRegClassID = 3, + RISCV_GPRF16RegClassID = 4, + RISCV_GPRF32RegClassID = 5, + RISCV_GPRNoX0RegClassID = 6, + RISCV_GPRNoX0X2RegClassID = 7, + RISCV_GPRJALRRegClassID = 8, + RISCV_GPRTCRegClassID = 9, + RISCV_FPR32CRegClassID = 10, + RISCV_GPRCRegClassID = 11, + RISCV_SR07RegClassID = 12, + RISCV_GPRC_and_GPRTCRegClassID = 13, + RISCV_VCSRRegClassID = 14, + RISCV_GPRC_and_SR07RegClassID = 15, + RISCV_GPRX1X5RegClassID = 16, + RISCV_GPRX0RegClassID = 17, + RISCV_GPRX1RegClassID = 18, + RISCV_GPRX5RegClassID = 19, + RISCV_SPRegClassID = 20, + RISCV_FPR64RegClassID = 21, + RISCV_VMRegClassID = 22, + RISCV_VRRegClassID = 23, + RISCV_VRNoV0RegClassID = 24, + RISCV_GPRPairRegClassID = 25, + RISCV_GPRPair_with_sub_gpr_even_in_GPRNoX0RegClassID = 26, + RISCV_GPRPair_with_sub_gpr_even_in_GPRNoX0X2RegClassID = 27, + RISCV_GPRPair_with_sub_gpr_even_in_GPRJALRRegClassID = 28, + RISCV_FPR64CRegClassID = 29, + RISCV_GPRPair_with_sub_gpr_even_in_GPRTCRegClassID = 30, + RISCV_GPRPair_with_sub_gpr_even_in_GPRCRegClassID = 31, + RISCV_GPRPair_with_sub_gpr_even_in_SR07RegClassID = 32, + RISCV_GPRPair_with_sub_gpr_even_in_GPRC_and_GPRTCRegClassID = 33, + RISCV_GPRPair_with_sub_gpr_even_in_GPRC_and_SR07RegClassID = 34, + RISCV_GPRPair_with_sub_gpr_even_in_GPRX0RegClassID = 35, + RISCV_GPRPair_with_sub_gpr_even_in_SPRegClassID = 36, + RISCV_GPRPair_with_sub_gpr_odd_in_GPRX1X5RegClassID = 37, + RISCV_VMV0RegClassID = 38, + RISCV_VRN2M1RegClassID = 39, + RISCV_VRN2M1NoV0RegClassID = 40, + RISCV_VRM2RegClassID = 41, + RISCV_VRM2NoV0RegClassID = 42, + RISCV_VRM2_with_sub_vrm1_0_in_VMV0RegClassID = 43, + RISCV_VRN2M1_with_sub_vrm1_0_in_VMV0RegClassID = 44, + RISCV_VRN3M1RegClassID = 45, + RISCV_VRN3M1NoV0RegClassID = 46, + RISCV_VRN3M1_with_sub_vrm1_0_in_VMV0RegClassID = 47, + RISCV_VRN4M1RegClassID = 48, + RISCV_VRN4M1NoV0RegClassID = 49, + RISCV_VRN2M2RegClassID = 50, + RISCV_VRN2M2NoV0RegClassID = 51, + RISCV_VRM4RegClassID = 52, + RISCV_VRM4NoV0RegClassID = 53, + RISCV_VRM4_with_sub_vrm1_0_in_VMV0RegClassID = 54, + RISCV_VRN2M2_with_sub_vrm1_0_in_VMV0RegClassID = 55, + RISCV_VRN4M1_with_sub_vrm1_0_in_VMV0RegClassID = 56, + RISCV_VRN5M1RegClassID = 57, + RISCV_VRN5M1NoV0RegClassID = 58, + RISCV_VRN5M1_with_sub_vrm1_0_in_VMV0RegClassID = 59, + RISCV_VRN6M1RegClassID = 60, + RISCV_VRN6M1NoV0RegClassID = 61, + RISCV_VRN3M2RegClassID = 62, + RISCV_VRN3M2NoV0RegClassID = 63, + RISCV_VRN3M2_with_sub_vrm1_0_in_VMV0RegClassID = 64, + RISCV_VRN6M1_with_sub_vrm1_0_in_VMV0RegClassID = 65, + RISCV_VRN7M1RegClassID = 66, + RISCV_VRN7M1NoV0RegClassID = 67, + RISCV_VRN7M1_with_sub_vrm1_0_in_VMV0RegClassID = 68, + RISCV_VRN8M1RegClassID = 69, + RISCV_VRN8M1NoV0RegClassID = 70, + RISCV_VRN4M2RegClassID = 71, + RISCV_VRN4M2NoV0RegClassID = 72, + RISCV_VRN2M4RegClassID = 73, + RISCV_VRN2M4NoV0RegClassID = 74, + RISCV_VRM8RegClassID = 75, + RISCV_VRM8NoV0RegClassID = 76, + RISCV_VRM8_with_sub_vrm1_0_in_VMV0RegClassID = 77, + RISCV_VRN2M4_with_sub_vrm1_0_in_VMV0RegClassID = 78, + RISCV_VRN4M2_with_sub_vrm1_0_in_VMV0RegClassID = 79, + RISCV_VRN8M1_with_sub_vrm1_0_in_VMV0RegClassID = 80, + }; // Register alternate name indices @@ -134,179 +556,915 @@ enum { enum { RISCV_ABIRegAltName, // 0 RISCV_NoRegAltName, // 1 - RISCV_NUM_TARGET_REG_ALT_NAMES = 2 + NUM_TARGET_REG_ALT_NAMES = 2 }; // Subregister indices enum { RISCV_NoSubRegister, - RISCV_sub_32, // 1 + RISCV_sub_16, // 1 + RISCV_sub_32, // 2 + RISCV_sub_gpr_even, // 3 + RISCV_sub_gpr_odd, // 4 + RISCV_sub_vrm1_0, // 5 + RISCV_sub_vrm1_1, // 6 + RISCV_sub_vrm1_2, // 7 + RISCV_sub_vrm1_3, // 8 + RISCV_sub_vrm1_4, // 9 + RISCV_sub_vrm1_5, // 10 + RISCV_sub_vrm1_6, // 11 + RISCV_sub_vrm1_7, // 12 + RISCV_sub_vrm2_0, // 13 + RISCV_sub_vrm2_1, // 14 + RISCV_sub_vrm2_2, // 15 + RISCV_sub_vrm2_3, // 16 + RISCV_sub_vrm4_0, // 17 + RISCV_sub_vrm4_1, // 18 + RISCV_sub_vrm1_0_sub_vrm1_1, // 19 + RISCV_sub_vrm1_0_sub_vrm1_1_sub_vrm1_2, // 20 + RISCV_sub_vrm1_0_sub_vrm1_1_sub_vrm1_2_sub_vrm1_3, // 21 + RISCV_sub_vrm1_1_sub_vrm1_2, // 22 + RISCV_sub_vrm1_1_sub_vrm1_2_sub_vrm1_3, // 23 + RISCV_sub_vrm1_2_sub_vrm1_3, // 24 + RISCV_sub_vrm1_0_sub_vrm1_1_sub_vrm1_2_sub_vrm1_3_sub_vrm1_4, // 25 + RISCV_sub_vrm1_0_sub_vrm1_1_sub_vrm1_2_sub_vrm1_3_sub_vrm1_4_sub_vrm1_5, // 26 + RISCV_sub_vrm1_0_sub_vrm1_1_sub_vrm1_2_sub_vrm1_3_sub_vrm1_4_sub_vrm1_5_sub_vrm1_6, // 27 + RISCV_sub_vrm1_0_sub_vrm1_1_sub_vrm1_2_sub_vrm1_3_sub_vrm1_4_sub_vrm1_5_sub_vrm1_6_sub_vrm1_7, // 28 + RISCV_sub_vrm1_1_sub_vrm1_2_sub_vrm1_3_sub_vrm1_4, // 29 + RISCV_sub_vrm1_1_sub_vrm1_2_sub_vrm1_3_sub_vrm1_4_sub_vrm1_5, // 30 + RISCV_sub_vrm1_1_sub_vrm1_2_sub_vrm1_3_sub_vrm1_4_sub_vrm1_5_sub_vrm1_6, // 31 + RISCV_sub_vrm1_1_sub_vrm1_2_sub_vrm1_3_sub_vrm1_4_sub_vrm1_5_sub_vrm1_6_sub_vrm1_7, // 32 + RISCV_sub_vrm1_2_sub_vrm1_3_sub_vrm1_4, // 33 + RISCV_sub_vrm1_2_sub_vrm1_3_sub_vrm1_4_sub_vrm1_5, // 34 + RISCV_sub_vrm1_2_sub_vrm1_3_sub_vrm1_4_sub_vrm1_5_sub_vrm1_6, // 35 + RISCV_sub_vrm1_2_sub_vrm1_3_sub_vrm1_4_sub_vrm1_5_sub_vrm1_6_sub_vrm1_7, // 36 + RISCV_sub_vrm1_3_sub_vrm1_4, // 37 + RISCV_sub_vrm1_3_sub_vrm1_4_sub_vrm1_5, // 38 + RISCV_sub_vrm1_3_sub_vrm1_4_sub_vrm1_5_sub_vrm1_6, // 39 + RISCV_sub_vrm1_3_sub_vrm1_4_sub_vrm1_5_sub_vrm1_6_sub_vrm1_7, // 40 + RISCV_sub_vrm1_4_sub_vrm1_5, // 41 + RISCV_sub_vrm1_4_sub_vrm1_5_sub_vrm1_6, // 42 + RISCV_sub_vrm1_4_sub_vrm1_5_sub_vrm1_6_sub_vrm1_7, // 43 + RISCV_sub_vrm1_5_sub_vrm1_6, // 44 + RISCV_sub_vrm1_5_sub_vrm1_6_sub_vrm1_7, // 45 + RISCV_sub_vrm1_6_sub_vrm1_7, // 46 + RISCV_sub_vrm2_0_sub_vrm2_1, // 47 + RISCV_sub_vrm2_0_sub_vrm2_1_sub_vrm2_2, // 48 + RISCV_sub_vrm2_0_sub_vrm2_1_sub_vrm2_2_sub_vrm2_3, // 49 + RISCV_sub_vrm2_1_sub_vrm2_2, // 50 + RISCV_sub_vrm2_1_sub_vrm2_2_sub_vrm2_3, // 51 + RISCV_sub_vrm2_2_sub_vrm2_3, // 52 RISCV_NUM_TARGET_SUBREGS }; #endif // GET_REGINFO_ENUM -/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\ -|* *| -|* MC Register Information *| -|* *| -|* Automatically generated file, do not edit! *| -|* *| -\*===----------------------------------------------------------------------===*/ +/* Capstone Disassembly Engine, https://www.capstone-engine.org */ +/* By Nguyen Anh Quynh , 2013-2022, */ +/* Rot127 2022-2024 */ +/* Automatically generated file by Capstone's LLVM TableGen Disassembler Backend. */ +/* LLVM-commit: */ +/* LLVM-tag: */ + +/* Do not edit. */ + +/* Capstone's LLVM TableGen Backends: */ +/* https://github.com/capstone-engine/llvm-capstone */ #ifdef GET_REGINFO_MC_DESC #undef GET_REGINFO_MC_DESC static const MCPhysReg RISCVRegDiffLists[] = { - /* 0 */ 1, 0, - /* 2 */ 32, 0, - /* 4 */ 33, 0, - /* 6 */ 34, 0, - /* 8 */ 35, 0, - /* 10 */ 36, 0, - /* 12 */ 37, 0, - /* 14 */ 38, 0, - /* 16 */ 39, 0, - /* 18 */ 40, 0, - /* 20 */ 41, 0, - /* 22 */ 42, 0, - /* 24 */ 43, 0, - /* 26 */ 44, 0, - /* 28 */ 45, 0, - /* 30 */ 46, 0, - /* 32 */ 47, 0, - /* 34 */ 48, 0, - /* 36 */ 49, 0, - /* 38 */ 50, 0, - /* 40 */ 51, 0, - /* 42 */ 52, 0, - /* 44 */ 53, 0, - /* 46 */ 54, 0, - /* 48 */ 55, 0, - /* 50 */ 56, 0, - /* 52 */ 57, 0, - /* 54 */ 58, 0, - /* 56 */ 59, 0, - /* 58 */ 60, 0, - /* 60 */ 61, 0, - /* 62 */ 62, 0, - /* 64 */ 63, 0, - /* 66 */ -1, 0, + /* 0 */ -105, 0, + /* 2 */ -103, 0, + /* 4 */ -101, 0, + /* 6 */ -99, 0, + /* 8 */ -97, 0, + /* 10 */ -95, 0, + /* 12 */ 25, -106, -86, 0, + /* 16 */ 157, -1, -3, 49, 52, 43, -80, 121, 27, 26, 25, -148, 42, -86, 0, + /* 31 */ 161, 1, 1, 71, 52, 43, -80, 121, 27, 26, 25, -148, 42, -86, 0, + /* 46 */ -1, -3, 64, 51, 42, -86, 0, + /* 53 */ 1, 1, 86, 51, 42, -86, 0, + /* 60 */ -104, -85, 0, + /* 63 */ -102, -84, 0, + /* 66 */ -100, -83, 0, + /* 69 */ -98, -82, 0, + /* 72 */ -96, -81, 0, + /* 75 */ -370, 1, 1, 1, 1, 230, 52, 43, -125, 53, -52, 96, -43, -52, 0, + /* 90 */ -342, 1, 1, 1, 1, 199, 53, 44, -96, 53, -52, 96, -43, -52, 0, + /* 105 */ -88, -161, 1, 163, -162, 1, 231, 52, 43, -125, 53, -52, 0, + /* 118 */ -397, 1, 1, 1, 1, 1, 229, 52, 43, -125, 53, -52, 165, -69, 42, -85, 44, -96, 53, -52, 0, + /* 139 */ -370, 1, 1, 1, 1, 1, 198, 53, 44, -96, 53, -52, 137, -41, 42, -85, 44, -96, 53, -52, 0, + /* 160 */ -423, 1, 1, 1, 1, 1, 1, 228, 52, 43, -125, 53, -52, 165, 27, -96, 42, 28, -113, 44, 42, -138, 53, 44, -96, 53, -52, 0, + /* 188 */ -397, 1, 1, 1, 1, 1, 1, 197, 53, 44, -96, 53, -52, 137, 28, -69, 42, 28, -113, 44, 42, -138, 53, 44, -96, 53, -52, 0, + /* 216 */ -448, 1, 1, 1, 1, 1, 1, 1, 227, 52, 43, -125, 53, -52, 165, 27, 26, -122, 42, 28, 27, -140, 44, 42, 28, -166, 53, 44, 42, -138, 53, 44, -96, 53, -52, 0, + /* 252 */ -423, 1, 1, 1, 1, 1, 1, 1, 196, 53, 44, -96, 53, -52, 137, 28, 27, -96, 42, 28, 27, -140, 44, 42, 28, -166, 53, 44, 42, -138, 53, 44, -96, 53, -52, 0, + /* 288 */ -71, -162, 1, 162, -161, 1, 200, 53, 44, -96, 53, -52, 0, + /* 301 */ -71, -161, 1, 162, -161, 1, 200, 53, 44, -96, 53, -52, 0, + /* 314 */ -70, -160, 1, 162, -161, 1, 200, 53, 44, -96, 53, -52, 0, + /* 327 */ -70, -161, 1, 161, -160, 1, 200, 53, 44, -96, 53, -52, 0, + /* 340 */ -68, -161, 1, 161, -160, 1, 200, 53, 44, -96, 53, -52, 0, + /* 353 */ -68, -160, 1, 161, -160, 1, 200, 53, 44, -96, 53, -52, 0, + /* 366 */ -67, -159, 1, 161, -160, 1, 200, 53, 44, -96, 53, -52, 0, + /* 379 */ -67, -160, 1, 160, -159, 1, 200, 53, 44, -96, 53, -52, 0, + /* 392 */ -65, -160, 1, 160, -159, 1, 200, 53, 44, -96, 53, -52, 0, + /* 405 */ -65, -159, 1, 160, -159, 1, 200, 53, 44, -96, 53, -52, 0, + /* 418 */ -64, -158, 1, 160, -159, 1, 200, 53, 44, -96, 53, -52, 0, + /* 431 */ -64, -159, 1, 159, -158, 1, 200, 53, 44, -96, 53, -52, 0, + /* 444 */ -62, -159, 1, 159, -158, 1, 200, 53, 44, -96, 53, -52, 0, + /* 457 */ -62, -158, 1, 159, -158, 1, 200, 53, 44, -96, 53, -52, 0, + /* 470 */ -329, 1, 1, 1, 231, 52, -82, 53, -52, 0, + /* 480 */ -300, 1, 1, 1, 200, 53, -52, 53, -52, 0, + /* 490 */ -94, -1, -161, 1, 163, -162, 1, 163, -1, -161, 1, 162, -161, 1, 227, 52, 43, -125, 53, -52, 165, 27, 26, 25, -147, 42, 28, 27, -140, 44, 42, 28, -166, 53, 44, 42, -138, 53, 44, -96, 53, -52, 40, 51, 42, -107, 52, -51, 0, + /* 539 */ -72, -1, -158, 1, 160, -159, 1, 160, -1, -158, 1, 159, -158, 1, 196, 53, 44, -96, 53, -52, 137, 28, 27, 26, -122, 42, 28, 27, -140, 44, 42, 28, -166, 53, 44, 42, -138, 53, 44, -96, 53, -52, 13, 52, 43, -94, 52, -51, 0, + /* 588 */ -74, -1, -159, 1, 160, -159, 1, 160, -1, -158, 1, 160, -159, 1, 196, 53, 44, -96, 53, -52, 137, 28, 27, 26, -122, 42, 28, 27, -140, 44, 42, 28, -166, 53, 44, 42, -138, 53, 44, -96, 53, -52, 15, 52, 43, -94, 52, -51, 0, + /* 637 */ -77, -1, -159, 1, 161, -160, 1, 161, -1, -159, 1, 160, -159, 1, 196, 53, 44, -96, 53, -52, 137, 28, 27, 26, -122, 42, 28, 27, -140, 44, 42, 28, -166, 53, 44, 42, -138, 53, 44, -96, 53, -52, 17, 52, 43, -94, 52, -51, 0, + /* 686 */ -79, -1, -160, 1, 161, -160, 1, 161, -1, -159, 1, 161, -160, 1, 196, 53, 44, -96, 53, -52, 137, 28, 27, 26, -122, 42, 28, 27, -140, 44, 42, 28, -166, 53, 44, 42, -138, 53, 44, -96, 53, -52, 19, 52, 43, -94, 52, -51, 0, + /* 735 */ -82, -1, -160, 1, 162, -161, 1, 162, -1, -160, 1, 161, -160, 1, 196, 53, 44, -96, 53, -52, 137, 28, 27, 26, -122, 42, 28, 27, -140, 44, 42, 28, -166, 53, 44, 42, -138, 53, 44, -96, 53, -52, 21, 52, 43, -94, 52, -51, 0, + /* 784 */ -84, -1, -161, 1, 162, -161, 1, 162, -1, -160, 1, 162, -161, 1, 196, 53, 44, -96, 53, -52, 137, 28, 27, 26, -122, 42, 28, 27, -140, 44, 42, 28, -166, 53, 44, 42, -138, 53, 44, -96, 53, -52, 23, 52, 43, -94, 52, -51, 0, + /* 833 */ -181, -161, 1, 163, -162, 1, 162, -161, 1, 162, -161, 1, 227, 52, 43, -125, 53, -52, 165, 27, 26, 25, -147, 42, 28, 27, -140, 44, 42, 28, -166, 53, 44, 42, -138, 53, 44, -96, 53, -52, 40, 51, -65, 52, -51, 0, + /* 879 */ -159, -158, 1, 160, -159, 1, 159, -158, 1, 159, -158, 1, 196, 53, 44, -96, 53, -52, 137, 28, 27, 26, -122, 42, 28, 27, -140, 44, 42, 28, -166, 53, 44, 42, -138, 53, 44, -96, 53, -52, 13, 52, -51, 52, -51, 0, + /* 925 */ -159, -159, 1, 159, -158, 1, 160, -159, 1, 159, -158, 1, 196, 53, 44, -96, 53, -52, 137, 28, 27, 26, -122, 42, 28, 27, -140, 44, 42, 28, -166, 53, 44, 42, -138, 53, 44, -96, 53, -52, 14, 52, -51, 52, -51, 0, + /* 971 */ -160, -159, 1, 160, -159, 1, 159, -158, 1, 160, -159, 1, 196, 53, 44, -96, 53, -52, 137, 28, 27, 26, -122, 42, 28, 27, -140, 44, 42, 28, -166, 53, 44, 42, -138, 53, 44, -96, 53, -52, 15, 52, -51, 52, -51, 0, + /* 1017 */ -160, -160, 1, 160, -159, 1, 160, -159, 1, 159, -158, 1, 196, 53, 44, -96, 53, -52, 137, 28, 27, 26, -122, 42, 28, 27, -140, 44, 42, 28, -166, 53, 44, 42, -138, 53, 44, -96, 53, -52, 16, 52, -51, 52, -51, 0, + /* 1063 */ -162, -159, 1, 161, -160, 1, 160, -159, 1, 160, -159, 1, 196, 53, 44, -96, 53, -52, 137, 28, 27, 26, -122, 42, 28, 27, -140, 44, 42, 28, -166, 53, 44, 42, -138, 53, 44, -96, 53, -52, 17, 52, -51, 52, -51, 0, + /* 1109 */ -162, -160, 1, 160, -159, 1, 161, -160, 1, 160, -159, 1, 196, 53, 44, -96, 53, -52, 137, 28, 27, 26, -122, 42, 28, 27, -140, 44, 42, 28, -166, 53, 44, 42, -138, 53, 44, -96, 53, -52, 18, 52, -51, 52, -51, 0, + /* 1155 */ -163, -160, 1, 161, -160, 1, 160, -159, 1, 161, -160, 1, 196, 53, 44, -96, 53, -52, 137, 28, 27, 26, -122, 42, 28, 27, -140, 44, 42, 28, -166, 53, 44, 42, -138, 53, 44, -96, 53, -52, 19, 52, -51, 52, -51, 0, + /* 1201 */ -163, -161, 1, 161, -160, 1, 161, -160, 1, 160, -159, 1, 196, 53, 44, -96, 53, -52, 137, 28, 27, 26, -122, 42, 28, 27, -140, 44, 42, 28, -166, 53, 44, 42, -138, 53, 44, -96, 53, -52, 20, 52, -51, 52, -51, 0, + /* 1247 */ -165, -160, 1, 162, -161, 1, 161, -160, 1, 161, -160, 1, 196, 53, 44, -96, 53, -52, 137, 28, 27, 26, -122, 42, 28, 27, -140, 44, 42, 28, -166, 53, 44, 42, -138, 53, 44, -96, 53, -52, 21, 52, -51, 52, -51, 0, + /* 1293 */ -165, -161, 1, 161, -160, 1, 162, -161, 1, 161, -160, 1, 196, 53, 44, -96, 53, -52, 137, 28, 27, 26, -122, 42, 28, 27, -140, 44, 42, 28, -166, 53, 44, 42, -138, 53, 44, -96, 53, -52, 22, 52, -51, 52, -51, 0, + /* 1339 */ -166, -161, 1, 162, -161, 1, 161, -160, 1, 162, -161, 1, 196, 53, 44, -96, 53, -52, 137, 28, 27, 26, -122, 42, 28, 27, -140, 44, 42, 28, -166, 53, 44, 42, -138, 53, 44, -96, 53, -52, 23, 52, -51, 52, -51, 0, + /* 1385 */ -166, -162, 1, 162, -161, 1, 162, -161, 1, 161, -160, 1, 196, 53, 44, -96, 53, -52, 137, 28, 27, 26, -122, 42, 28, 27, -140, 44, 42, 28, -166, 53, 44, 42, -138, 53, 44, -96, 53, -52, 24, 52, -51, 52, -51, 0, + /* 1431 */ -128, -33, 0, + /* 1434 */ -32, -32, 0, + /* 1437 */ -286, 1, 1, 232, -30, 0, + /* 1443 */ -139, -161, 1, 163, -162, 1, 162, -161, 1, 229, 52, 43, -125, 53, -52, 165, 27, -96, 42, -85, 44, -96, 53, -52, 42, -14, 0, + /* 1470 */ -234, 1, 0, + /* 1473 */ -203, 1, 0, + /* 1476 */ -1, -161, 1, 163, -162, 1, 0, + /* 1483 */ -1, -1, -161, 1, 163, -162, 1, 163, -1, -161, 1, 162, -161, 1, 0, + /* 1498 */ -1, -160, 1, 162, -161, 1, 0, + /* 1505 */ -1, -1, -160, 1, 162, -161, 1, 162, -1, -160, 1, 161, -160, 1, 0, + /* 1520 */ -1, -159, 1, 161, -160, 1, 0, + /* 1527 */ -1, -1, -159, 1, 161, -160, 1, 161, -1, -159, 1, 160, -159, 1, 0, + /* 1542 */ -1, -158, 1, 160, -159, 1, 0, + /* 1549 */ -1, -1, -158, 1, 160, -159, 1, 160, -1, -158, 1, 159, -158, 1, 0, + /* 1564 */ -155, 1, 0, + /* 1567 */ -154, 1, 0, + /* 1570 */ -153, 1, 0, + /* 1573 */ -152, 1, 0, + /* 1576 */ -151, 1, 0, + /* 1579 */ -150, 1, 0, + /* 1582 */ -149, 1, 0, + /* 1585 */ -148, 1, 0, + /* 1588 */ -147, 1, 0, + /* 1591 */ -146, 1, 0, + /* 1594 */ -145, 1, 0, + /* 1597 */ -144, 1, 0, + /* 1600 */ -143, 1, 0, + /* 1603 */ -142, 1, 0, + /* 1606 */ -141, 1, 0, + /* 1609 */ 1, 1, 1, 1, 1, 1, 1, 0, + /* 1617 */ -114, -159, 1, 159, -158, 1, 159, -158, 1, 198, 53, 44, -96, 53, -52, 137, 28, -69, 42, -85, 44, -96, 53, -52, 14, 1, 0, + /* 1644 */ -116, -158, 1, 160, -159, 1, 159, -158, 1, 198, 53, 44, -96, 53, -52, 137, 28, -69, 42, -85, 44, -96, 53, -52, 15, 1, 0, + /* 1671 */ -116, -159, 1, 159, -158, 1, 160, -159, 1, 198, 53, 44, -96, 53, -52, 137, 28, -69, 42, -85, 44, -96, 53, -52, 16, 1, 0, + /* 1698 */ -117, -159, 1, 160, -159, 1, 159, -158, 1, 198, 53, 44, -96, 53, -52, 137, 28, -69, 42, -85, 44, -96, 53, -52, 17, 1, 0, + /* 1725 */ -117, -160, 1, 160, -159, 1, 160, -159, 1, 198, 53, 44, -96, 53, -52, 137, 28, -69, 42, -85, 44, -96, 53, -52, 18, 1, 0, + /* 1752 */ -119, -159, 1, 161, -160, 1, 160, -159, 1, 198, 53, 44, -96, 53, -52, 137, 28, -69, 42, -85, 44, -96, 53, -52, 19, 1, 0, + /* 1779 */ -119, -160, 1, 160, -159, 1, 161, -160, 1, 198, 53, 44, -96, 53, -52, 137, 28, -69, 42, -85, 44, -96, 53, -52, 20, 1, 0, + /* 1806 */ -120, -160, 1, 161, -160, 1, 160, -159, 1, 198, 53, 44, -96, 53, -52, 137, 28, -69, 42, -85, 44, -96, 53, -52, 21, 1, 0, + /* 1833 */ -120, -161, 1, 161, -160, 1, 161, -160, 1, 198, 53, 44, -96, 53, -52, 137, 28, -69, 42, -85, 44, -96, 53, -52, 22, 1, 0, + /* 1860 */ -122, -160, 1, 162, -161, 1, 161, -160, 1, 198, 53, 44, -96, 53, -52, 137, 28, -69, 42, -85, 44, -96, 53, -52, 23, 1, 0, + /* 1887 */ -122, -161, 1, 161, -160, 1, 162, -161, 1, 198, 53, 44, -96, 53, -52, 137, 28, -69, 42, -85, 44, -96, 53, -52, 24, 1, 0, + /* 1914 */ -123, -161, 1, 162, -161, 1, 161, -160, 1, 198, 53, 44, -96, 53, -52, 137, 28, -69, 42, -85, 44, -96, 53, -52, 25, 1, 0, + /* 1941 */ -123, -162, 1, 162, -161, 1, 162, -161, 1, 198, 53, 44, -96, 53, -52, 137, 28, -69, 42, -85, 44, -96, 53, -52, 26, 1, 0, + /* 1968 */ 1, 70, 1, 0, + /* 1972 */ 1, 75, 1, 0, + /* 1976 */ -3, 76, 1, 0, + /* 1980 */ 1, 80, 1, 0, + /* 1984 */ -3, 81, 1, 0, + /* 1988 */ -256, 1, 1, 201, 1, 0, + /* 1994 */ 161, -2, 1, 42, 1, 51, 1, 43, -70, 28, 44, -71, 68, 41, 27, 26, -52, 27, 26, 25, -138, 42, -81, 59, 41, 1, 27, -26, 27, 26, -25, 26, 25, -141, 1, 42, -82, 126, 26, 1, 25, -97, 75, 26, -99, 92, 2, 2, 2, 0, + /* 2044 */ 160, -1, -3, 46, 1, 51, 43, -68, 26, 1, 43, -69, 68, 41, 1, 27, -67, 41, 27, 26, -52, 27, 26, 25, -139, 1, 42, -81, 95, 27, 26, 50, -161, 55, -86, 117, 26, 1, 25, -95, 47, 26, 1, 25, -97, 92, 2, 2, 2, 0, + /* 2094 */ 160, 1, 1, 40, 1, 51, 1, 43, -69, 27, 44, -70, 67, 41, 1, 27, -67, 41, 27, 26, -52, 27, 26, 25, -139, 1, 42, -81, 100, 28, 27, 26, -141, 43, -82, 122, 26, 1, 25, -95, 47, 26, 1, 25, -97, 92, 2, 2, 2, 0, + /* 2144 */ 52, 1, 43, -69, 68, 41, 1, 27, -67, 41, 27, 26, -52, 27, 26, 25, -139, 1, 42, -81, 123, 26, 1, 25, -95, 47, 26, 1, 25, -97, 92, 2, 2, 2, 0, + /* 2179 */ 160, -1, -3, 46, 1, 51, 1, 43, -72, 30, 44, -73, 70, 41, 27, 26, -52, 27, 26, 25, -140, 42, -82, 62, 41, 1, 27, -26, 27, 26, -25, 26, 25, -143, 1, 42, -83, 129, 26, 1, 25, -99, 77, 26, -101, 94, 2, 2, 2, 0, + /* 2229 */ 160, 1, -3, 44, 1, 51, 1, 43, -71, 29, 44, -72, 69, 41, 1, 27, -67, 41, 27, 26, -52, 27, 26, 25, -141, 1, 42, -82, 103, 28, 27, 26, -143, 43, -83, 125, 26, 1, 25, -97, 49, 26, 1, 25, -99, 94, 2, 2, 2, 0, + /* 2279 */ 160, -2, 1, 43, 1, 51, 43, -70, 28, 1, 43, -71, 110, 27, 26, 25, -138, 42, -81, 59, 41, 1, 27, -67, 41, 27, 26, -52, 27, 26, 25, -141, 1, 42, -82, 126, 26, 1, 25, -97, 49, 26, 1, 25, -99, 94, 2, 2, 2, 0, + /* 2329 */ 52, 1, 43, -71, 70, 41, 1, 27, -67, 41, 27, 26, -52, 27, 26, 25, -141, 1, 42, -82, 126, 26, 1, 25, -97, 49, 26, 1, 25, -99, 94, 2, 2, 2, 0, + /* 2364 */ 159, 1, 1, 41, 1, 51, 43, -69, 27, 1, 43, -70, 109, 27, -67, 41, 27, 26, -52, 27, 26, 25, -139, 1, 42, -81, 59, 41, 1, 27, 1, 26, 1, 25, -141, 43, -82, 149, 25, -95, 47, 26, 1, 25, -97, 94, 2, 2, 2, 0, + /* 2414 */ 52, 1, 43, -70, 69, 41, 27, 26, -52, 27, 26, 25, -138, 42, -81, 59, 41, 1, 27, 1, 26, 1, 25, -141, 43, -82, 126, 26, 1, 25, -97, 94, 2, 2, 2, 0, + /* 2450 */ 160, -2, 1, 43, 1, 51, 1, 43, -74, 32, 44, -75, 72, 41, 27, 26, -52, 27, 26, 25, -142, 42, -83, 65, 41, 1, 27, -26, 27, 26, -25, 26, 25, -145, 1, 42, -84, 132, 26, 1, 25, -101, 79, 26, -103, 96, 2, 2, 2, 0, + /* 2500 */ 159, 1, 1, 41, 1, 51, 1, 43, -73, 31, 44, -74, 71, 41, 1, 27, -67, 41, 27, 26, -52, 27, 26, 25, -143, 1, 42, -83, 106, 28, 27, 26, -145, 43, -84, 128, 26, 1, 25, -99, 51, 26, 1, 25, -101, 96, 2, 2, 2, 0, + /* 2550 */ 159, -1, -3, 47, 1, 51, 43, -72, 30, 1, 43, -73, 112, 27, 26, 25, -140, 42, -82, 62, 41, 1, 27, -67, 41, 27, 26, -52, 27, 26, 25, -143, 1, 42, -83, 129, 26, 1, 25, -99, 51, 26, 1, 25, -101, 96, 2, 2, 2, 0, + /* 2600 */ 52, 1, 43, -73, 72, 41, 1, 27, -67, 41, 27, 26, -52, 27, 26, 25, -143, 1, 42, -83, 129, 26, 1, 25, -99, 51, 26, 1, 25, -101, 96, 2, 2, 2, 0, + /* 2635 */ 159, 1, -3, 45, 1, 51, 43, -71, 29, 1, 43, -72, 111, 27, -67, 41, 27, 26, -52, 27, 26, 25, -141, 1, 42, -82, 62, 41, 1, 27, 1, 26, 1, 25, -143, 43, -83, 152, 25, -97, 49, 26, 1, 25, -99, 96, 2, 2, 2, 0, + /* 2685 */ 52, 1, 43, -72, 71, 41, 27, 26, -52, 27, 26, 25, -140, 42, -82, 62, 41, 1, 27, 1, 26, 1, 25, -143, 43, -83, 129, 26, 1, 25, -99, 96, 2, 2, 2, 0, + /* 2721 */ 159, -1, -3, 47, 1, 51, 1, 43, -76, 34, 44, -77, 74, 41, 27, 26, -52, 27, 26, 25, -144, 42, -84, 68, 41, 1, 27, -26, 27, 26, -25, 26, 25, -147, 1, 42, -85, 135, 26, 1, 25, -103, 81, 26, -105, 98, 2, 2, 2, 0, + /* 2771 */ 159, 1, -3, 45, 1, 51, 1, 43, -75, 33, 44, -76, 73, 41, 1, 27, -67, 41, 27, 26, -52, 27, 26, 25, -145, 1, 42, -84, 109, 28, 27, 26, -147, 43, -85, 131, 26, 1, 25, -101, 53, 26, 1, 25, -103, 98, 2, 2, 2, 0, + /* 2821 */ 159, -2, 1, 44, 1, 51, 43, -74, 32, 1, 43, -75, 114, 27, 26, 25, -142, 42, -83, 65, 41, 1, 27, -67, 41, 27, 26, -52, 27, 26, 25, -145, 1, 42, -84, 132, 26, 1, 25, -101, 53, 26, 1, 25, -103, 98, 2, 2, 2, 0, + /* 2871 */ 52, 1, 43, -75, 74, 41, 1, 27, -67, 41, 27, 26, -52, 27, 26, 25, -145, 1, 42, -84, 132, 26, 1, 25, -101, 53, 26, 1, 25, -103, 98, 2, 2, 2, 0, + /* 2906 */ 158, 1, 1, 42, 1, 51, 43, -73, 31, 1, 43, -74, 113, 27, -67, 41, 27, 26, -52, 27, 26, 25, -143, 1, 42, -83, 65, 41, 1, 27, 1, 26, 1, 25, -145, 43, -84, 155, 25, -99, 51, 26, 1, 25, -101, 98, 2, 2, 2, 0, + /* 2956 */ 52, 1, 43, -74, 73, 41, 27, 26, -52, 27, 26, 25, -142, 42, -83, 65, 41, 1, 27, 1, 26, 1, 25, -145, 43, -84, 132, 26, 1, 25, -101, 98, 2, 2, 2, 0, + /* 2992 */ 158, 1, 1, 42, 1, 51, 1, 43, -77, 35, 44, -78, 75, 41, 1, 27, -67, 41, 27, 26, -52, 27, 26, 25, -147, 1, 42, -85, 112, 28, 27, 26, -149, 43, -86, 134, 26, 1, 25, -103, 55, 26, 1, 25, -105, 100, 2, 2, 2, 0, + /* 3042 */ 158, -1, -3, 48, 1, 51, 43, -76, 34, 1, 43, -77, 116, 27, 26, 25, -144, 42, -84, 68, 41, 1, 27, -67, 41, 27, 26, -52, 27, 26, 25, -147, 1, 42, -85, 135, 26, 1, 25, -103, 55, 26, 1, 25, -105, 100, 2, 2, 2, 0, + /* 3092 */ 52, 1, 43, -77, 76, 41, 1, 27, -67, 41, 27, 26, -52, 27, 26, 25, -147, 1, 42, -85, 135, 26, 1, 25, -103, 55, 26, 1, 25, -105, 100, 2, 2, 2, 0, + /* 3127 */ 158, 1, -3, 46, 1, 51, 43, -75, 33, 1, 43, -76, 115, 27, -67, 41, 27, 26, -52, 27, 26, 25, -145, 1, 42, -84, 68, 41, 1, 27, 1, 26, 1, 25, -147, 43, -85, 158, 25, -101, 53, 26, 1, 25, -103, 100, 2, 2, 2, 0, + /* 3177 */ 52, 1, 43, -76, 75, 41, 27, 26, -52, 27, 26, 25, -144, 42, -84, 68, 41, 1, 27, 1, 26, 1, 25, -147, 43, -85, 135, 26, 1, 25, -103, 100, 2, 2, 2, 0, + /* 3213 */ 161, -1, -3, 45, 1, 51, 1, 43, -68, 26, 44, -69, 68, 41, 1, 27, -26, 27, 26, -25, 26, 25, -139, 1, 42, -81, 53, 41, 27, 52, -78, 27, 26, 50, -161, 55, -86, 117, 26, 1, 25, -95, 73, 26, -97, 92, 2, 2, 0, + /* 3262 */ 52, 43, -68, 26, 44, -69, 68, 41, 1, 27, -26, 27, 26, -25, 26, 25, -139, 1, 42, -81, 95, 27, 26, 50, -161, 55, -86, 117, 26, 1, 25, -95, 73, 26, -97, 92, 2, 2, 0, + /* 3301 */ 44, -69, 68, 41, 1, 27, -26, 27, 26, -25, 26, 25, -139, 1, 42, -81, 123, 26, 1, 25, -95, 73, 26, -97, 92, 2, 2, 0, + /* 3329 */ 52, 43, -70, 28, 44, -71, 110, 27, 26, 25, -138, 42, -81, 59, 41, 1, 27, -26, 27, 26, -25, 26, 25, -141, 1, 42, -82, 126, 26, 1, 25, -97, 75, 26, -99, 94, 2, 2, 0, + /* 3368 */ 44, -71, 70, 41, 1, 27, -26, 27, 26, -25, 26, 25, -141, 1, 42, -82, 126, 26, 1, 25, -97, 75, 26, -99, 94, 2, 2, 0, + /* 3396 */ 52, 43, -69, 27, 44, -70, 109, 27, -67, 41, 27, 26, -52, 27, 26, 25, -139, 1, 42, -81, 100, 28, 27, 26, -141, 43, -82, 149, 25, -95, 47, 26, 1, 25, -97, 94, 2, 2, 0, + /* 3435 */ 43, -69, 110, 27, -67, 41, 27, 26, -52, 27, 26, 25, -139, 1, 42, -81, 150, 25, -95, 47, 26, 1, 25, -97, 94, 2, 2, 0, + /* 3463 */ 44, -70, 69, 41, 27, 26, -52, 27, 26, 25, -138, 42, -81, 100, 28, 27, 26, -141, 43, -82, 126, 26, 1, 25, -97, 94, 2, 2, 0, + /* 3492 */ 41, 27, 26, -52, 27, 26, 25, -138, 42, -81, 127, 26, 1, 25, -97, 94, 2, 2, 0, + /* 3511 */ 52, 1, 43, -68, 69, 41, 1, 27, 1, 26, 1, 25, -139, 43, -81, 53, 41, 27, 52, -78, 27, 26, 50, -161, 55, -86, 117, 26, 1, 25, -95, 94, 2, 2, 0, + /* 3546 */ 43, -68, 69, 41, 1, 27, 1, 26, 1, 25, -139, 43, -81, 95, 27, 26, 50, -161, 55, -86, 117, 26, 1, 25, -95, 94, 2, 2, 0, + /* 3575 */ 160, 1, -3, 44, 1, 51, 43, -67, 25, 1, 43, -68, 69, 41, 1, 27, 1, 26, 1, 25, -139, 43, -81, 93, 54, -94, 41, 27, 52, -78, 27, 26, 50, -148, -13, 55, -86, 117, 26, 1, 25, -95, 94, 2, 2, 0, + /* 3621 */ 41, 1, 27, 1, 26, 1, 25, -139, 43, -81, 123, 26, 1, 25, -95, 94, 2, 2, 0, + /* 3640 */ 52, 43, -72, 30, 44, -73, 112, 27, 26, 25, -140, 42, -82, 62, 41, 1, 27, -26, 27, 26, -25, 26, 25, -143, 1, 42, -83, 129, 26, 1, 25, -99, 77, 26, -101, 96, 2, 2, 0, + /* 3679 */ 44, -73, 72, 41, 1, 27, -26, 27, 26, -25, 26, 25, -143, 1, 42, -83, 129, 26, 1, 25, -99, 77, 26, -101, 96, 2, 2, 0, + /* 3707 */ 52, 43, -71, 29, 44, -72, 111, 27, -67, 41, 27, 26, -52, 27, 26, 25, -141, 1, 42, -82, 103, 28, 27, 26, -143, 43, -83, 152, 25, -97, 49, 26, 1, 25, -99, 96, 2, 2, 0, + /* 3746 */ 43, -71, 112, 27, -67, 41, 27, 26, -52, 27, 26, 25, -141, 1, 42, -82, 153, 25, -97, 49, 26, 1, 25, -99, 96, 2, 2, 0, + /* 3774 */ 44, -72, 71, 41, 27, 26, -52, 27, 26, 25, -140, 42, -82, 103, 28, 27, 26, -143, 43, -83, 129, 26, 1, 25, -99, 96, 2, 2, 0, + /* 3803 */ 41, 27, 26, -52, 27, 26, 25, -140, 42, -82, 130, 26, 1, 25, -99, 96, 2, 2, 0, + /* 3822 */ 43, -70, 111, 27, 26, 25, -138, 42, -81, 59, 41, 1, 27, 1, 26, 1, 25, -141, 43, -82, 126, 26, 1, 25, -97, 96, 2, 2, 0, + /* 3851 */ 52, 43, -74, 32, 44, -75, 114, 27, 26, 25, -142, 42, -83, 65, 41, 1, 27, -26, 27, 26, -25, 26, 25, -145, 1, 42, -84, 132, 26, 1, 25, -101, 79, 26, -103, 98, 2, 2, 0, + /* 3890 */ 44, -75, 74, 41, 1, 27, -26, 27, 26, -25, 26, 25, -145, 1, 42, -84, 132, 26, 1, 25, -101, 79, 26, -103, 98, 2, 2, 0, + /* 3918 */ 52, 43, -73, 31, 44, -74, 113, 27, -67, 41, 27, 26, -52, 27, 26, 25, -143, 1, 42, -83, 106, 28, 27, 26, -145, 43, -84, 155, 25, -99, 51, 26, 1, 25, -101, 98, 2, 2, 0, + /* 3957 */ 43, -73, 114, 27, -67, 41, 27, 26, -52, 27, 26, 25, -143, 1, 42, -83, 156, 25, -99, 51, 26, 1, 25, -101, 98, 2, 2, 0, + /* 3985 */ 44, -74, 73, 41, 27, 26, -52, 27, 26, 25, -142, 42, -83, 106, 28, 27, 26, -145, 43, -84, 132, 26, 1, 25, -101, 98, 2, 2, 0, + /* 4014 */ 41, 27, 26, -52, 27, 26, 25, -142, 42, -83, 133, 26, 1, 25, -101, 98, 2, 2, 0, + /* 4033 */ 43, -72, 113, 27, 26, 25, -140, 42, -82, 62, 41, 1, 27, 1, 26, 1, 25, -143, 43, -83, 129, 26, 1, 25, -99, 98, 2, 2, 0, + /* 4062 */ 52, 43, -76, 34, 44, -77, 116, 27, 26, 25, -144, 42, -84, 68, 41, 1, 27, -26, 27, 26, -25, 26, 25, -147, 1, 42, -85, 135, 26, 1, 25, -103, 81, 26, -105, 100, 2, 2, 0, + /* 4101 */ 44, -77, 76, 41, 1, 27, -26, 27, 26, -25, 26, 25, -147, 1, 42, -85, 135, 26, 1, 25, -103, 81, 26, -105, 100, 2, 2, 0, + /* 4129 */ 52, 43, -75, 33, 44, -76, 115, 27, -67, 41, 27, 26, -52, 27, 26, 25, -145, 1, 42, -84, 109, 28, 27, 26, -147, 43, -85, 158, 25, -101, 53, 26, 1, 25, -103, 100, 2, 2, 0, + /* 4168 */ 43, -75, 116, 27, -67, 41, 27, 26, -52, 27, 26, 25, -145, 1, 42, -84, 159, 25, -101, 53, 26, 1, 25, -103, 100, 2, 2, 0, + /* 4196 */ 44, -76, 75, 41, 27, 26, -52, 27, 26, 25, -144, 42, -84, 109, 28, 27, 26, -147, 43, -85, 135, 26, 1, 25, -103, 100, 2, 2, 0, + /* 4225 */ 41, 27, 26, -52, 27, 26, 25, -144, 42, -84, 136, 26, 1, 25, -103, 100, 2, 2, 0, + /* 4244 */ 43, -74, 115, 27, 26, 25, -142, 42, -83, 65, 41, 1, 27, 1, 26, 1, 25, -145, 43, -84, 132, 26, 1, 25, -101, 100, 2, 2, 0, + /* 4273 */ 157, 1, 1, 43, 1, 51, 43, -77, 35, 1, 43, -78, 117, 27, -67, 41, 27, 26, -52, 27, 26, 25, -147, 1, 42, -85, 71, 41, 1, 27, 1, 26, 1, 25, -149, 43, -86, 161, 25, -103, 55, 26, 1, 25, -105, 102, 2, 2, 0, + /* 4322 */ 52, 43, -77, 35, 44, -78, 117, 27, -67, 41, 27, 26, -52, 27, 26, 25, -147, 1, 42, -85, 112, 28, 27, 26, -149, 43, -86, 161, 25, -103, 55, 26, 1, 25, -105, 102, 2, 2, 0, + /* 4361 */ 43, -77, 118, 27, -67, 41, 27, 26, -52, 27, 26, 25, -147, 1, 42, -85, 162, 25, -103, 55, 26, 1, 25, -105, 102, 2, 2, 0, + /* 4389 */ 159, -2, 1, 44, 1, 51, 1, 43, -78, 36, 44, -79, 76, 41, 27, 26, -52, 27, 26, 25, -146, 42, -85, 71, 41, 1, 27, -26, 27, 26, -25, 26, 25, -149, 1, 42, -86, 138, 26, 1, 25, -105, 102, 2, 2, 0, + /* 4435 */ 52, 1, 43, -78, 77, 41, 27, 26, -52, 27, 26, 25, -146, 42, -85, 71, 41, 1, 27, 1, 26, 1, 25, -149, 43, -86, 138, 26, 1, 25, -105, 102, 2, 2, 0, + /* 4470 */ 44, -78, 77, 41, 27, 26, -52, 27, 26, 25, -146, 42, -85, 112, 28, 27, 26, -149, 43, -86, 138, 26, 1, 25, -105, 102, 2, 2, 0, + /* 4499 */ 41, 27, 26, -52, 27, 26, 25, -146, 42, -85, 139, 26, 1, 25, -105, 102, 2, 2, 0, + /* 4518 */ 43, -76, 117, 27, 26, 25, -144, 42, -84, 68, 41, 1, 27, 1, 26, 1, 25, -147, 43, -85, 135, 26, 1, 25, -103, 102, 2, 2, 0, + /* 4547 */ -1, -3, 73, 1, 51, 1, 42, -81, 37, 55, -86, 74, 2, 0, + /* 4561 */ 1, 1, 67, 1, 50, 1, 42, -81, 40, 43, -82, 79, 2, 0, + /* 4575 */ 1, -3, 69, 1, 50, 1, 42, -82, 41, 43, -83, 80, 2, 0, + /* 4589 */ 51, 1, 42, -81, 80, 2, 0, + /* 4596 */ 1, 1, 64, 1, 50, 1, 42, -83, 42, 43, -84, 81, 2, 0, + /* 4610 */ -2, 1, 68, 1, 50, 42, -81, 40, 1, 42, -82, 81, 2, 0, + /* 4624 */ 51, 1, 42, -82, 81, 2, 0, + /* 4631 */ 1, -3, 66, 1, 50, 1, 42, -84, 43, 43, -85, 82, 2, 0, + /* 4645 */ -1, -3, 70, 1, 50, 42, -82, 41, 1, 42, -83, 82, 2, 0, + /* 4659 */ 51, 1, 42, -83, 82, 2, 0, + /* 4666 */ 1, 1, 61, 1, 50, 1, 42, -85, 44, 43, -86, 83, 2, 0, + /* 4680 */ -2, 1, 65, 1, 50, 42, -83, 42, 1, 42, -84, 83, 2, 0, + /* 4694 */ 51, 1, 42, -84, 83, 2, 0, + /* 4701 */ -1, -3, 67, 1, 50, 42, -84, 43, 1, 42, -85, 84, 2, 0, + /* 4715 */ 51, 1, 42, -85, 84, 2, 0, + /* 4722 */ -69, 110, 27, -26, 27, 26, -25, 26, 25, -139, 1, 42, -81, 150, 25, -95, 73, 26, -97, 94, 2, 0, + /* 4744 */ 27, 26, -25, 26, 25, -138, 42, -81, 153, 26, -97, 94, 2, 0, + /* 4758 */ 44, -68, 110, 28, 27, 26, -139, 43, -81, 53, 41, 27, 52, -78, 27, 26, 50, -161, 55, -86, 117, 26, 1, 25, -95, 94, 2, 0, + /* 4786 */ -68, 110, 28, 27, 26, -139, 43, -81, 95, 27, 26, 50, -161, 55, -86, 117, 26, 1, 25, -95, 94, 2, 0, + /* 4809 */ 161, 1, -3, 43, 1, 51, 1, 43, -67, 25, 44, -68, 110, 28, 27, 26, -139, 43, -81, 51, 69, -27, 54, -94, 41, 27, 52, -78, 27, 26, 50, -148, -13, 55, -86, 117, 26, 1, 25, -95, 94, 2, 0, + /* 4852 */ 161, -2, 1, 42, 1, 52, 1, 43, -67, 22, 72, -80, 52, 69, -27, 54, -94, 41, 27, 52, -78, 27, 26, 50, -148, -13, 55, -86, 117, 26, 1, 25, -95, 94, 2, 0, + /* 4888 */ 52, 1, 43, -67, 66, 69, -27, 54, -94, 41, 27, 52, -78, 27, 26, 50, -148, -13, 55, -86, 117, 26, 1, 25, -95, 94, 2, 0, + /* 4916 */ 52, 43, -67, 25, 44, -68, 110, 28, 27, 26, -139, 43, -81, 93, 54, -94, 41, 27, 52, -78, 27, 26, 50, -148, -13, 55, -86, 117, 26, 1, 25, -95, 94, 2, 0, + /* 4951 */ 43, -67, 108, 54, -94, 41, 27, 52, -78, 27, 26, 50, -148, -13, 55, -86, 117, 26, 1, 25, -95, 94, 2, 0, + /* 4975 */ 28, 27, 26, -139, 43, -81, 123, 26, 1, 25, -95, 94, 2, 0, + /* 4989 */ -71, 112, 27, -26, 27, 26, -25, 26, 25, -141, 1, 42, -82, 153, 25, -97, 75, 26, -99, 96, 2, 0, + /* 5011 */ 27, 26, -25, 26, 25, -140, 42, -82, 156, 26, -99, 96, 2, 0, + /* 5025 */ -70, 111, 27, 26, 25, -138, 42, -81, 100, 28, 27, 26, -141, 43, -82, 126, 26, 1, 25, -97, 96, 2, 0, + /* 5048 */ 27, 26, 25, -138, 42, -81, 127, 26, 1, 25, -97, 96, 2, 0, + /* 5062 */ 27, 1, 26, 1, 25, -139, 43, -81, 150, 25, -95, 96, 2, 0, + /* 5076 */ -73, 114, 27, -26, 27, 26, -25, 26, 25, -143, 1, 42, -83, 156, 25, -99, 77, 26, -101, 98, 2, 0, + /* 5098 */ 27, 26, -25, 26, 25, -142, 42, -83, 159, 26, -101, 98, 2, 0, + /* 5112 */ -72, 113, 27, 26, 25, -140, 42, -82, 103, 28, 27, 26, -143, 43, -83, 129, 26, 1, 25, -99, 98, 2, 0, + /* 5135 */ 27, 26, 25, -140, 42, -82, 130, 26, 1, 25, -99, 98, 2, 0, + /* 5149 */ 27, 1, 26, 1, 25, -141, 43, -82, 153, 25, -97, 98, 2, 0, + /* 5163 */ -75, 116, 27, -26, 27, 26, -25, 26, 25, -145, 1, 42, -84, 159, 25, -101, 79, 26, -103, 100, 2, 0, + /* 5185 */ 27, 26, -25, 26, 25, -144, 42, -84, 162, 26, -103, 100, 2, 0, + /* 5199 */ -74, 115, 27, 26, 25, -142, 42, -83, 106, 28, 27, 26, -145, 43, -84, 132, 26, 1, 25, -101, 100, 2, 0, + /* 5222 */ 27, 26, 25, -142, 42, -83, 133, 26, 1, 25, -101, 100, 2, 0, + /* 5236 */ 27, 1, 26, 1, 25, -143, 43, -83, 156, 25, -99, 100, 2, 0, + /* 5250 */ -77, 118, 27, -26, 27, 26, -25, 26, 25, -147, 1, 42, -85, 162, 25, -103, 81, 26, -105, 102, 2, 0, + /* 5272 */ 27, 26, -25, 26, 25, -146, 42, -85, 165, 26, -105, 102, 2, 0, + /* 5286 */ -76, 117, 27, 26, 25, -144, 42, -84, 109, 28, 27, 26, -147, 43, -85, 135, 26, 1, 25, -103, 102, 2, 0, + /* 5309 */ 27, 26, 25, -144, 42, -84, 136, 26, 1, 25, -103, 102, 2, 0, + /* 5323 */ 27, 1, 26, 1, 25, -145, 43, -84, 159, 25, -101, 102, 2, 0, + /* 5337 */ 52, 43, -78, 36, 44, -79, 118, 27, 26, 25, -146, 42, -85, 71, 41, 1, 27, -26, 27, 26, -25, 26, 25, -149, 1, 42, -86, 138, 26, 1, 25, -105, 104, 2, 0, + /* 5372 */ 44, -79, 78, 41, 1, 27, -26, 27, 26, -25, 26, 25, -149, 1, 42, -86, 138, 26, 1, 25, -105, 104, 2, 0, + /* 5396 */ 158, -2, 1, 45, 1, 51, 43, -78, 36, 1, 43, -79, 118, 27, 26, 25, -146, 42, -85, 71, 41, 1, 27, -67, 41, 27, 26, -52, 27, 26, 25, -149, 1, 42, -86, 138, 26, 1, 25, -105, 104, 2, 0, + /* 5439 */ 158, 1, -3, 46, 1, 51, 1, 43, -79, 37, 44, -80, 77, 41, 1, 27, -67, 41, 27, 26, -52, 27, 26, 25, -149, 1, 42, -86, 138, 26, 1, 25, -105, 104, 2, 0, + /* 5475 */ 52, 1, 43, -79, 78, 41, 1, 27, -67, 41, 27, 26, -52, 27, 26, 25, -149, 1, 42, -86, 138, 26, 1, 25, -105, 104, 2, 0, + /* 5503 */ 43, -78, 119, 27, 26, 25, -146, 42, -85, 71, 41, 1, 27, 1, 26, 1, 25, -149, 43, -86, 138, 26, 1, 25, -105, 104, 2, 0, + /* 5531 */ -78, 119, 27, 26, 25, -146, 42, -85, 112, 28, 27, 26, -149, 43, -86, 138, 26, 1, 25, -105, 104, 2, 0, + /* 5554 */ 27, 26, 25, -146, 42, -85, 139, 26, 1, 25, -105, 104, 2, 0, + /* 5568 */ 27, 1, 26, 1, 25, -147, 43, -85, 162, 25, -103, 104, 2, 0, + /* 5582 */ 26, 1, 25, -96, -81, 176, 2, 0, + /* 5590 */ 26, 1, 25, -98, -82, 179, 2, 0, + /* 5598 */ 26, 1, 25, -100, -83, 182, 2, 0, + /* 5606 */ 26, 1, 25, -102, -84, 185, 2, 0, + /* 5614 */ 26, 1, 25, -104, -85, 188, 2, 0, + /* 5622 */ -3, 87, 6, 0, + /* 5626 */ 32, 32, 0, + /* 5629 */ 33, 0, + /* 5631 */ -3, 71, 0, + /* 5634 */ 1, -3, 72, 1, 52, 43, -81, 50, -13, 55, -86, 74, 0, + /* 5647 */ -2, 1, 72, 14, 51, -13, 55, -86, 74, 0, + /* 5657 */ 65, -13, 55, -86, 74, 0, + /* 5663 */ 52, 43, -81, 37, 55, -86, 74, 0, + /* 5671 */ 43, -81, 80, 0, + /* 5675 */ 51, 42, -81, 40, 43, -82, 81, 0, + /* 5683 */ 51, 42, -82, 41, 43, -83, 82, 0, + /* 5691 */ 42, -81, 82, 0, + /* 5695 */ 51, 42, -83, 42, 43, -84, 83, 0, + /* 5703 */ 42, -82, 83, 0, + /* 5707 */ 51, 42, -84, 43, 43, -85, 84, 0, + /* 5715 */ 42, -83, 84, 0, + /* 5719 */ -2, 1, 62, 1, 50, 42, -85, 44, 1, 42, -86, 85, 0, + /* 5732 */ 1, -3, 63, 1, 50, 1, 42, -86, 85, 0, + /* 5742 */ 51, 1, 42, -86, 85, 0, + /* 5748 */ 51, 42, -85, 44, 43, -86, 85, 0, + /* 5756 */ 42, -84, 85, 0, + /* 5760 */ 42, -85, 86, 0, + /* 5764 */ 1, 93, 0, + /* 5767 */ 27, 52, -51, 26, 50, -161, 55, -86, 143, 26, -95, 94, 0, + /* 5780 */ 162, -2, 1, 41, 1, 53, 44, -67, 51, -29, 72, -80, 52, 69, -27, 54, -53, 27, 52, -51, 26, 50, -148, -13, 55, -86, 143, 26, -95, 94, 0, + /* 5811 */ 53, 44, -67, 22, 72, -80, 52, 69, -27, 54, -53, 27, 52, -51, 26, 50, -148, -13, 55, -86, 143, 26, -95, 94, 0, + /* 5836 */ 44, -67, 66, 69, -27, 54, -53, 27, 52, -51, 26, 50, -148, -13, 55, -86, 143, 26, -95, 94, 0, + /* 5857 */ -67, 108, 54, -53, 27, 52, -51, 26, 50, -148, -13, 55, -86, 143, 26, -95, 94, 0, + /* 5875 */ 26, 25, -138, 42, -81, 153, 26, -97, 96, 0, + /* 5885 */ 27, 26, -139, 43, -81, 150, 25, -95, 96, 0, + /* 5895 */ 26, 25, -140, 42, -82, 156, 26, -99, 98, 0, + /* 5905 */ 27, 26, -141, 43, -82, 153, 25, -97, 98, 0, + /* 5915 */ 26, 25, -142, 42, -83, 159, 26, -101, 100, 0, + /* 5925 */ 27, 26, -143, 43, -83, 156, 25, -99, 100, 0, + /* 5935 */ 26, 25, -144, 42, -84, 162, 26, -103, 102, 0, + /* 5945 */ 27, 26, -145, 43, -84, 159, 25, -101, 102, 0, + /* 5955 */ 26, 25, -146, 42, -85, 165, 26, -105, 104, 0, + /* 5965 */ 27, 26, -147, 43, -85, 162, 25, -103, 104, 0, + /* 5975 */ -79, 120, 27, -26, 27, 26, -25, 26, 25, -149, 1, 42, -86, 165, 25, -105, 106, 0, + /* 5993 */ 157, 1, -3, 47, 1, 51, 43, -79, 37, 1, 43, -80, 119, 27, -67, 41, 27, 26, -52, 27, 26, 25, -149, 1, 42, -86, 165, 25, -105, 106, 0, + /* 6024 */ 52, 43, -79, 37, 44, -80, 119, 27, -67, 41, 27, 26, -52, 27, 26, 25, -149, 1, 42, -86, 165, 25, -105, 106, 0, + /* 6049 */ 43, -79, 120, 27, -67, 41, 27, 26, -52, 27, 26, 25, -149, 1, 42, -86, 165, 25, -105, 106, 0, + /* 6070 */ 27, 1, 26, 1, 25, -149, 43, -86, 165, 25, -105, 106, 0, + /* 6083 */ 27, 26, -149, 43, -86, 165, 25, -105, 106, 0, + /* 6093 */ 128, 0, + /* 6095 */ 140, 0, + /* 6097 */ 141, 0, + /* 6099 */ 142, 0, + /* 6101 */ 143, 0, + /* 6103 */ 144, 0, + /* 6105 */ 145, 0, + /* 6107 */ 146, 0, + /* 6109 */ 147, 0, + /* 6111 */ 148, 0, + /* 6113 */ 149, 0, + /* 6115 */ 150, 0, + /* 6117 */ 151, 0, + /* 6119 */ 152, 0, + /* 6121 */ 153, 0, + /* 6123 */ 154, 0, + /* 6125 */ 155, 0, + /* 6127 */ 161, 0, + /* 6129 */ 52, -25, 50, -106, -86, 168, 0, + /* 6136 */ 160, 1, 1, 41, 30, 52, -29, 72, -80, 52, 69, -27, 54, -26, 52, -25, 50, -148, 42, -86, 168, 0, + /* 6158 */ 82, -29, 72, -80, 52, 69, -27, 54, -26, 52, -25, 50, -148, 42, -86, 168, 0, + /* 6175 */ 26, -96, -81, 176, 0, + /* 6180 */ 25, -96, -81, 178, 0, + /* 6185 */ 26, -98, -82, 179, 0, + /* 6190 */ 25, -98, -82, 181, 0, + /* 6195 */ 26, -100, -83, 182, 0, + /* 6200 */ 25, -100, -83, 184, 0, + /* 6205 */ 26, -102, -84, 185, 0, + /* 6210 */ 25, -102, -84, 187, 0, + /* 6215 */ 26, -104, -85, 188, 0, + /* 6220 */ 25, -104, -85, 190, 0, + /* 6225 */ 26, 1, 25, -106, -86, 191, 0, + /* 6232 */ 26, -106, -86, 191, 0, + /* 6237 */ 27, 26, -25, 26, 25, -148, 42, -86, 191, 0, + /* 6247 */ 158, -1, -3, 48, 1, 51, 1, 43, -80, 79, 41, 27, 26, -52, 27, 26, 25, -148, 42, -86, 191, 0, + /* 6269 */ 52, 1, 43, -80, 79, 41, 27, 26, -52, 27, 26, 25, -148, 42, -86, 191, 0, + /* 6286 */ 44, -80, 79, 41, 27, 26, -52, 27, 26, 25, -148, 42, -86, 191, 0, }; static const uint16_t RISCVSubRegIdxLists[] = { - /* 0 */ 1, 0, + /* 0 */ 2, 1, 0, + /* 3 */ 3, 4, 0, + /* 6 */ 5, 6, 0, + /* 9 */ 13, 5, 6, 14, 7, 8, 0, + /* 16 */ 17, 13, 5, 6, 14, 7, 8, 18, 15, 9, 10, 16, 11, 12, 0, + /* 31 */ 5, 6, 7, 19, 22, 0, + /* 37 */ 5, 6, 7, 8, 19, 20, 22, 23, 24, 0, + /* 47 */ 13, 5, 6, 14, 7, 8, 19, 20, 21, 22, 23, 24, 0, + /* 60 */ 5, 6, 7, 8, 9, 19, 20, 21, 22, 23, 24, 29, 33, 37, 0, + /* 75 */ 5, 6, 7, 8, 9, 10, 19, 20, 21, 22, 23, 24, 25, 29, 30, 33, 34, 37, 38, 41, 0, + /* 96 */ 5, 6, 7, 8, 9, 10, 11, 19, 20, 21, 22, 23, 24, 25, 26, 29, 30, 31, 33, 34, 35, 37, 38, 39, 41, 42, 44, 0, + /* 124 */ 5, 6, 7, 8, 9, 10, 11, 12, 19, 20, 21, 22, 23, 24, 25, 26, 27, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 0, + /* 160 */ 13, 5, 6, 14, 7, 8, 15, 9, 10, 19, 20, 21, 22, 23, 24, 25, 26, 29, 30, 33, 34, 37, 38, 41, 47, 50, 0, + /* 187 */ 13, 5, 6, 14, 7, 8, 15, 9, 10, 16, 11, 12, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 50, 51, 52, 0, + /* 233 */ 17, 13, 5, 6, 14, 7, 8, 18, 15, 9, 10, 16, 11, 12, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 0, }; static const MCRegisterDesc RISCVRegDesc[] = { // Descriptors - { 3, 0, 0, 0, 0, 0 }, - { 12, 1, 1, 1, 1057, 0 }, - { 27, 1, 1, 1, 1057, 0 }, - { 252, 1, 1, 1, 1057, 0 }, - { 263, 1, 1, 1, 1057, 0 }, - { 488, 1, 1, 1, 1057, 0 }, - { 499, 1, 1, 1, 1057, 0 }, - { 510, 1, 1, 1, 1057, 0 }, - { 521, 1, 1, 1, 1057, 0 }, - { 532, 1, 1, 1, 1057, 0 }, - { 543, 1, 1, 1, 1057, 0 }, - { 0, 1, 1, 1, 1057, 0 }, - { 15, 1, 1, 1, 1057, 0 }, - { 30, 1, 1, 1, 1057, 0 }, - { 255, 1, 1, 1, 1057, 0 }, - { 266, 1, 1, 1, 1057, 0 }, - { 491, 1, 1, 1, 1057, 0 }, - { 502, 1, 1, 1, 1057, 0 }, - { 513, 1, 1, 1, 1057, 0 }, - { 524, 1, 1, 1, 1057, 0 }, - { 535, 1, 1, 1, 1057, 0 }, - { 4, 1, 1, 1, 1057, 0 }, - { 19, 1, 1, 1, 1057, 0 }, - { 34, 1, 1, 1, 1057, 0 }, - { 259, 1, 1, 1, 1057, 0 }, - { 270, 1, 1, 1, 1057, 0 }, - { 495, 1, 1, 1, 1057, 0 }, - { 506, 1, 1, 1, 1057, 0 }, - { 517, 1, 1, 1, 1057, 0 }, - { 528, 1, 1, 1, 1057, 0 }, - { 539, 1, 1, 1, 1057, 0 }, - { 8, 1, 1, 1, 1057, 0 }, - { 23, 1, 1, 1, 1057, 0 }, - { 59, 1, 0, 1, 32, 0 }, - { 295, 66, 1, 0, 32, 2 }, - { 86, 1, 0, 1, 64, 0 }, - { 322, 66, 1, 0, 64, 2 }, - { 106, 1, 0, 1, 96, 0 }, - { 342, 66, 1, 0, 96, 2 }, - { 126, 1, 0, 1, 128, 0 }, - { 362, 66, 1, 0, 128, 2 }, - { 146, 1, 0, 1, 160, 0 }, - { 382, 66, 1, 0, 160, 2 }, - { 166, 1, 0, 1, 192, 0 }, - { 402, 66, 1, 0, 192, 2 }, - { 186, 1, 0, 1, 224, 0 }, - { 422, 66, 1, 0, 224, 2 }, - { 206, 1, 0, 1, 256, 0 }, - { 442, 66, 1, 0, 256, 2 }, - { 226, 1, 0, 1, 288, 0 }, - { 462, 66, 1, 0, 288, 2 }, - { 246, 1, 0, 1, 320, 0 }, - { 482, 66, 1, 0, 320, 2 }, - { 38, 1, 0, 1, 352, 0 }, - { 274, 66, 1, 0, 352, 2 }, - { 65, 1, 0, 1, 384, 0 }, - { 301, 66, 1, 0, 384, 2 }, - { 92, 1, 0, 1, 416, 0 }, - { 328, 66, 1, 0, 416, 2 }, - { 112, 1, 0, 1, 448, 0 }, - { 348, 66, 1, 0, 448, 2 }, - { 132, 1, 0, 1, 480, 0 }, - { 368, 66, 1, 0, 480, 2 }, - { 152, 1, 0, 1, 512, 0 }, - { 388, 66, 1, 0, 512, 2 }, - { 172, 1, 0, 1, 544, 0 }, - { 408, 66, 1, 0, 544, 2 }, - { 192, 1, 0, 1, 576, 0 }, - { 428, 66, 1, 0, 576, 2 }, - { 212, 1, 0, 1, 608, 0 }, - { 448, 66, 1, 0, 608, 2 }, - { 232, 1, 0, 1, 640, 0 }, - { 468, 66, 1, 0, 640, 2 }, - { 45, 1, 0, 1, 672, 0 }, - { 281, 66, 1, 0, 672, 2 }, - { 72, 1, 0, 1, 704, 0 }, - { 308, 66, 1, 0, 704, 2 }, - { 99, 1, 0, 1, 736, 0 }, - { 335, 66, 1, 0, 736, 2 }, - { 119, 1, 0, 1, 768, 0 }, - { 355, 66, 1, 0, 768, 2 }, - { 139, 1, 0, 1, 800, 0 }, - { 375, 66, 1, 0, 800, 2 }, - { 159, 1, 0, 1, 832, 0 }, - { 395, 66, 1, 0, 832, 2 }, - { 179, 1, 0, 1, 864, 0 }, - { 415, 66, 1, 0, 864, 2 }, - { 199, 1, 0, 1, 896, 0 }, - { 435, 66, 1, 0, 896, 2 }, - { 219, 1, 0, 1, 928, 0 }, - { 455, 66, 1, 0, 928, 2 }, - { 239, 1, 0, 1, 960, 0 }, - { 475, 66, 1, 0, 960, 2 }, - { 52, 1, 0, 1, 992, 0 }, - { 288, 66, 1, 0, 992, 2 }, - { 79, 1, 0, 1, 1024, 0 }, - { 315, 66, 1, 0, 1024, 2 }, + { 24, 0, 0, 0, 0, 0 }, + { 2034, 1, 1, 2, 4096, 50 }, + { 2021, 1, 1, 2, 4097, 50 }, + { 2030, 1, 1, 2, 4098, 50 }, + { 2018, 1, 1, 2, 4099, 50 }, + { 1460, 1, 1, 2, 4100, 50 }, + { 1648, 1, 1, 2, 4101, 50 }, + { 2025, 1, 1, 2, 4102, 50 }, + { 2041, 1, 1, 2, 4103, 50 }, + { 104, 1, 6127, 2, 4104, 50 }, + { 101, 1, 31, 2, 4105, 50 }, + { 244, 1, 6136, 2, 4106, 50 }, + { 651, 1, 5780, 2, 4107, 50 }, + { 742, 1, 4852, 2, 4108, 50 }, + { 916, 1, 4809, 2, 4109, 50 }, + { 1015, 1, 3575, 2, 4110, 50 }, + { 1113, 1, 3213, 2, 4111, 50 }, + { 1220, 1, 2044, 2, 4112, 50 }, + { 1344, 1, 2094, 2, 4113, 50 }, + { 1451, 1, 2364, 2, 4114, 50 }, + { 21, 1, 1994, 2, 4115, 50 }, + { 149, 1, 2279, 2, 4116, 50 }, + { 273, 1, 2229, 2, 4117, 50 }, + { 681, 1, 2635, 2, 4118, 50 }, + { 776, 1, 2179, 2, 4119, 50 }, + { 948, 1, 2550, 2, 4120, 50 }, + { 1051, 1, 2500, 2, 4121, 50 }, + { 1147, 1, 2906, 2, 4122, 50 }, + { 1257, 1, 2450, 2, 4123, 50 }, + { 1378, 1, 2821, 2, 4124, 50 }, + { 57, 1, 2771, 2, 4125, 50 }, + { 189, 1, 3127, 2, 4126, 50 }, + { 309, 1, 2721, 2, 4127, 50 }, + { 721, 1, 3042, 2, 4128, 50 }, + { 812, 1, 2992, 2, 4129, 50 }, + { 988, 1, 4273, 2, 4130, 50 }, + { 1087, 1, 4389, 2, 4131, 50 }, + { 1187, 1, 5396, 2, 4132, 50 }, + { 1293, 1, 5439, 2, 4133, 50 }, + { 1418, 1, 5993, 2, 4134, 50 }, + { 93, 1, 6247, 2, 4135, 50 }, + { 229, 1, 16, 2, 4136, 50 }, + { 124, 1, 6093, 2, 4137, 50 }, + { 247, 1, 1, 2, 4138, 50 }, + { 654, 1, 6125, 2, 4139, 50 }, + { 748, 1, 6123, 2, 4140, 50 }, + { 919, 1, 6123, 2, 4141, 50 }, + { 1021, 1, 6121, 2, 4142, 50 }, + { 1116, 1, 6121, 2, 4143, 50 }, + { 1226, 1, 6119, 2, 4144, 50 }, + { 1347, 1, 6119, 2, 4145, 50 }, + { 1457, 1, 6117, 2, 4146, 50 }, + { 25, 1, 6117, 2, 4147, 50 }, + { 157, 1, 6115, 2, 4148, 50 }, + { 277, 1, 6115, 2, 4149, 50 }, + { 689, 1, 6113, 2, 4150, 50 }, + { 780, 1, 6113, 2, 4151, 50 }, + { 956, 1, 6111, 2, 4152, 50 }, + { 1055, 1, 6111, 2, 4153, 50 }, + { 1155, 1, 6109, 2, 4154, 50 }, + { 1261, 1, 6109, 2, 4155, 50 }, + { 1386, 1, 6107, 2, 4156, 50 }, + { 61, 1, 6107, 2, 4157, 50 }, + { 197, 1, 6105, 2, 4158, 50 }, + { 313, 1, 6105, 2, 4159, 50 }, + { 729, 1, 6103, 2, 4160, 50 }, + { 816, 1, 6103, 2, 4161, 50 }, + { 996, 1, 6101, 2, 4162, 50 }, + { 1091, 1, 6101, 2, 4163, 50 }, + { 1195, 1, 6099, 2, 4164, 50 }, + { 1297, 1, 6099, 2, 4165, 50 }, + { 1426, 1, 6097, 2, 4166, 50 }, + { 97, 1, 6097, 2, 4167, 50 }, + { 237, 1, 6095, 2, 4168, 50 }, + { 1484, 5626, 1, 0, 4169, 0 }, + { 1507, 5626, 1, 0, 4170, 0 }, + { 1524, 5626, 1, 0, 4171, 0 }, + { 1541, 5626, 1, 0, 4172, 0 }, + { 1558, 5626, 1, 0, 4173, 0 }, + { 1575, 5626, 1, 0, 4174, 0 }, + { 1592, 5626, 1, 0, 4175, 0 }, + { 1609, 5626, 1, 0, 4176, 0 }, + { 1626, 5626, 1, 0, 4177, 0 }, + { 1643, 5626, 1, 0, 4178, 0 }, + { 1466, 5626, 1, 0, 4179, 0 }, + { 1489, 5626, 1, 0, 4180, 0 }, + { 1512, 5626, 1, 0, 4181, 0 }, + { 1529, 5626, 1, 0, 4182, 0 }, + { 1546, 5626, 1, 0, 4183, 0 }, + { 1563, 5626, 1, 0, 4184, 0 }, + { 1580, 5626, 1, 0, 4185, 0 }, + { 1597, 5626, 1, 0, 4186, 0 }, + { 1614, 5626, 1, 0, 4187, 0 }, + { 1631, 5626, 1, 0, 4188, 0 }, + { 1472, 5626, 1, 0, 4189, 0 }, + { 1495, 5626, 1, 0, 4190, 0 }, + { 1518, 5626, 1, 0, 4191, 0 }, + { 1535, 5626, 1, 0, 4192, 0 }, + { 1552, 5626, 1, 0, 4193, 0 }, + { 1569, 5626, 1, 0, 4194, 0 }, + { 1586, 5626, 1, 0, 4195, 0 }, + { 1603, 5626, 1, 0, 4196, 0 }, + { 1620, 5626, 1, 0, 4197, 0 }, + { 1637, 5626, 1, 0, 4198, 0 }, + { 1478, 5626, 1, 0, 4199, 0 }, + { 1501, 5626, 1, 0, 4200, 0 }, + { 1672, 5627, 1435, 1, 4169, 0 }, + { 1695, 5627, 1435, 1, 4170, 0 }, + { 1712, 5627, 1435, 1, 4171, 0 }, + { 1729, 5627, 1435, 1, 4172, 0 }, + { 1746, 5627, 1435, 1, 4173, 0 }, + { 1763, 5627, 1435, 1, 4174, 0 }, + { 1780, 5627, 1435, 1, 4175, 0 }, + { 1797, 5627, 1435, 1, 4176, 0 }, + { 1814, 5627, 1435, 1, 4177, 0 }, + { 1831, 5627, 1435, 1, 4178, 0 }, + { 1654, 5627, 1435, 1, 4179, 0 }, + { 1677, 5627, 1435, 1, 4180, 0 }, + { 1700, 5627, 1435, 1, 4181, 0 }, + { 1717, 5627, 1435, 1, 4182, 0 }, + { 1734, 5627, 1435, 1, 4183, 0 }, + { 1751, 5627, 1435, 1, 4184, 0 }, + { 1768, 5627, 1435, 1, 4185, 0 }, + { 1785, 5627, 1435, 1, 4186, 0 }, + { 1802, 5627, 1435, 1, 4187, 0 }, + { 1819, 5627, 1435, 1, 4188, 0 }, + { 1660, 5627, 1435, 1, 4189, 0 }, + { 1683, 5627, 1435, 1, 4190, 0 }, + { 1706, 5627, 1435, 1, 4191, 0 }, + { 1723, 5627, 1435, 1, 4192, 0 }, + { 1740, 5627, 1435, 1, 4193, 0 }, + { 1757, 5627, 1435, 1, 4194, 0 }, + { 1774, 5627, 1435, 1, 4195, 0 }, + { 1791, 5627, 1435, 1, 4196, 0 }, + { 1808, 5627, 1435, 1, 4197, 0 }, + { 1825, 5627, 1435, 1, 4198, 0 }, + { 1666, 5627, 1435, 1, 4199, 0 }, + { 1689, 5627, 1435, 1, 4200, 0 }, + { 1854, 1, 1434, 2, 4169, 50 }, + { 1877, 1, 1434, 2, 4170, 50 }, + { 1894, 1, 1434, 2, 4171, 50 }, + { 1911, 1, 1434, 2, 4172, 50 }, + { 1928, 1, 1434, 2, 4173, 50 }, + { 1945, 1, 1434, 2, 4174, 50 }, + { 1962, 1, 1434, 2, 4175, 50 }, + { 1979, 1, 1434, 2, 4176, 50 }, + { 1996, 1, 1434, 2, 4177, 50 }, + { 2013, 1, 1434, 2, 4178, 50 }, + { 1836, 1, 1434, 2, 4179, 50 }, + { 1859, 1, 1434, 2, 4180, 50 }, + { 1882, 1, 1434, 2, 4181, 50 }, + { 1899, 1, 1434, 2, 4182, 50 }, + { 1916, 1, 1434, 2, 4183, 50 }, + { 1933, 1, 1434, 2, 4184, 50 }, + { 1950, 1, 1434, 2, 4185, 50 }, + { 1967, 1, 1434, 2, 4186, 50 }, + { 1984, 1, 1434, 2, 4187, 50 }, + { 2001, 1, 1434, 2, 4188, 50 }, + { 1842, 1, 1434, 2, 4189, 50 }, + { 1865, 1, 1434, 2, 4190, 50 }, + { 1888, 1, 1434, 2, 4191, 50 }, + { 1905, 1, 1434, 2, 4192, 50 }, + { 1922, 1, 1434, 2, 4193, 50 }, + { 1939, 1, 1434, 2, 4194, 50 }, + { 1956, 1, 1434, 2, 4195, 50 }, + { 1973, 1, 1434, 2, 4196, 50 }, + { 1990, 1, 1434, 2, 4197, 50 }, + { 2007, 1, 1434, 2, 4198, 50 }, + { 1848, 1, 1434, 2, 4199, 50 }, + { 1871, 1, 1434, 2, 4200, 50 }, + { 2047, 1431, 1, 3, 23056392, 2 }, + { 386, 1495, 53, 6, 6025225, 8 }, + { 832, 1476, 5764, 9, 6606857, 15 }, + { 1301, 1483, 1, 16, 6590473, 41 }, + { 442, 1480, 5647, 6, 6025227, 8 }, + { 504, 1495, 5634, 6, 6025229, 8 }, + { 865, 1491, 5622, 9, 6606861, 15 }, + { 572, 1495, 4547, 6, 6025231, 8 }, + { 640, 1517, 4561, 6, 6025233, 8 }, + { 899, 1498, 1980, 9, 6606865, 15 }, + { 1318, 1505, 1, 16, 6590481, 41 }, + { 332, 1495, 4610, 6, 6025235, 8 }, + { 407, 1517, 4575, 6, 6025237, 8 }, + { 842, 1513, 1984, 9, 6606869, 15 }, + { 464, 1517, 4645, 6, 6025239, 8 }, + { 527, 1539, 4596, 6, 6025241, 8 }, + { 876, 1520, 1972, 9, 6606873, 15 }, + { 1312, 1527, 1, 16, 6590489, 41 }, + { 595, 1517, 4680, 6, 6025243, 8 }, + { 356, 1539, 4631, 6, 6025245, 8 }, + { 826, 1535, 1976, 9, 6606877, 15 }, + { 431, 1539, 4701, 6, 6025247, 8 }, + { 488, 1561, 4666, 6, 6025249, 8 }, + { 854, 1542, 1968, 9, 6606881, 15 }, + { 1306, 1549, 1, 16, 6590497, 41 }, + { 551, 1539, 5719, 6, 6025251, 8 }, + { 619, 1561, 5732, 6, 6025253, 8 }, + { 888, 1557, 5631, 9, 6606885, 15 }, + { 380, 1561, 46, 6, 6025255, 8 }, + { 745, 1564, 1, 3, 6025259, 5 }, + { 1018, 1567, 1, 3, 6025261, 5 }, + { 1223, 1570, 1, 3, 6025263, 5 }, + { 1454, 1573, 1, 3, 6025265, 5 }, + { 153, 1576, 1, 3, 6025267, 5 }, + { 685, 1579, 1, 3, 6025269, 5 }, + { 952, 1582, 1, 3, 6025271, 5 }, + { 1151, 1585, 1, 3, 6025273, 5 }, + { 1382, 1588, 1, 3, 6025275, 5 }, + { 193, 1591, 1, 3, 6025277, 5 }, + { 725, 1594, 1, 3, 6025279, 5 }, + { 992, 1597, 1, 3, 6025281, 5 }, + { 1191, 1600, 1, 3, 6025283, 5 }, + { 1422, 1603, 1, 3, 6025285, 5 }, + { 233, 1606, 1, 3, 6025287, 5 }, + { 648, 1473, 6158, 6, 6025226, 8 }, + { 739, 1473, 5811, 6, 6025227, 8 }, + { 913, 1473, 4888, 6, 6025228, 8 }, + { 1012, 1473, 4916, 6, 6025229, 8 }, + { 1110, 1473, 3511, 6, 6025230, 8 }, + { 1217, 1473, 3262, 6, 6025231, 8 }, + { 1341, 1473, 2144, 6, 6025232, 8 }, + { 1448, 1473, 3396, 6, 6025233, 8 }, + { 18, 1473, 2414, 6, 6025234, 8 }, + { 145, 1473, 3329, 6, 6025235, 8 }, + { 269, 1473, 2329, 6, 6025236, 8 }, + { 677, 1473, 3707, 6, 6025237, 8 }, + { 772, 1473, 2685, 6, 6025238, 8 }, + { 944, 1473, 3640, 6, 6025239, 8 }, + { 1047, 1473, 2600, 6, 6025240, 8 }, + { 1143, 1473, 3918, 6, 6025241, 8 }, + { 1253, 1473, 2956, 6, 6025242, 8 }, + { 1374, 1473, 3851, 6, 6025243, 8 }, + { 53, 1473, 2871, 6, 6025244, 8 }, + { 185, 1473, 4129, 6, 6025245, 8 }, + { 305, 1473, 3177, 6, 6025246, 8 }, + { 717, 1473, 4062, 6, 6025247, 8 }, + { 808, 1473, 3092, 6, 6025248, 8 }, + { 984, 1473, 4322, 6, 6025249, 8 }, + { 1083, 1473, 4435, 6, 6025250, 8 }, + { 1183, 1473, 5337, 6, 6025251, 8 }, + { 1289, 1473, 5475, 6, 6025252, 8 }, + { 1414, 1473, 6024, 6, 6025253, 8 }, + { 89, 1473, 6269, 6, 6025254, 8 }, + { 225, 1473, 20, 6, 6025255, 8 }, + { 241, 1470, 20, 6, 6025225, 8 }, + { 499, 288, 5657, 47, 6606859, 15 }, + { 567, 301, 5663, 47, 6606861, 15 }, + { 635, 327, 4589, 47, 6606863, 15 }, + { 327, 314, 5675, 47, 6606865, 15 }, + { 401, 340, 4624, 47, 6606867, 15 }, + { 458, 353, 5683, 47, 6606869, 15 }, + { 521, 379, 4659, 47, 6606871, 15 }, + { 589, 366, 5695, 47, 6606873, 15 }, + { 350, 392, 4694, 47, 6606875, 15 }, + { 425, 405, 5707, 47, 6606877, 15 }, + { 482, 431, 4715, 47, 6606879, 15 }, + { 545, 418, 5748, 47, 6606881, 15 }, + { 613, 444, 5742, 47, 6606883, 15 }, + { 374, 457, 49, 47, 6606885, 15 }, + { 437, 105, 49, 47, 6606857, 15 }, + { 894, 784, 1, 233, 6590477, 41 }, + { 837, 735, 1, 233, 6590481, 41 }, + { 870, 686, 1, 233, 6590485, 41 }, + { 820, 637, 1, 233, 6590489, 41 }, + { 848, 588, 1, 233, 6590493, 41 }, + { 882, 539, 1, 233, 6590497, 41 }, + { 860, 490, 1, 233, 6590473, 41 }, + { 736, 1988, 6143, 31, 6610954, 11 }, + { 910, 1988, 5836, 31, 6610955, 11 }, + { 1009, 1988, 4951, 31, 6610956, 11 }, + { 1107, 1988, 4758, 31, 6610957, 11 }, + { 1214, 1988, 3546, 31, 6610958, 11 }, + { 1338, 1988, 3301, 31, 6610959, 11 }, + { 1445, 1988, 3435, 31, 6610960, 11 }, + { 15, 1988, 3463, 31, 6610961, 11 }, + { 142, 1988, 3822, 31, 6610962, 11 }, + { 265, 1988, 3368, 31, 6610963, 11 }, + { 673, 1988, 3746, 31, 6610964, 11 }, + { 768, 1988, 3774, 31, 6610965, 11 }, + { 940, 1988, 4033, 31, 6610966, 11 }, + { 1043, 1988, 3679, 31, 6610967, 11 }, + { 1139, 1988, 3957, 31, 6610968, 11 }, + { 1249, 1988, 3985, 31, 6610969, 11 }, + { 1370, 1988, 4244, 31, 6610970, 11 }, + { 49, 1988, 3890, 31, 6610971, 11 }, + { 181, 1988, 4168, 31, 6610972, 11 }, + { 301, 1988, 4196, 31, 6610973, 11 }, + { 713, 1988, 4518, 31, 6610974, 11 }, + { 804, 1988, 4101, 31, 6610975, 11 }, + { 980, 1988, 4361, 31, 6610976, 11 }, + { 1079, 1988, 4470, 31, 6610977, 11 }, + { 1179, 1988, 5503, 31, 6610978, 11 }, + { 1285, 1988, 5372, 31, 6610979, 11 }, + { 1410, 1988, 6049, 31, 6610980, 11 }, + { 85, 1988, 6286, 31, 6610981, 11 }, + { 221, 1988, 21, 31, 6610982, 11 }, + { 645, 1437, 21, 31, 6610953, 11 }, + { 562, 1941, 5643, 160, 6598667, 26 }, + { 630, 1914, 5671, 160, 6598669, 26 }, + { 322, 1887, 5691, 160, 6598671, 26 }, + { 396, 1860, 5679, 160, 6598673, 26 }, + { 452, 1833, 5703, 160, 6598675, 26 }, + { 515, 1806, 5687, 160, 6598677, 26 }, + { 583, 1779, 5715, 160, 6598679, 26 }, + { 344, 1752, 5699, 160, 6598681, 26 }, + { 419, 1725, 5756, 160, 6598683, 26 }, + { 476, 1698, 5711, 160, 6598685, 26 }, + { 539, 1671, 5760, 160, 6598687, 26 }, + { 607, 1644, 5752, 160, 6598689, 26 }, + { 368, 1617, 28, 160, 6598691, 26 }, + { 494, 1443, 28, 160, 6598665, 26 }, + { 907, 480, 6146, 37, 6606858, 15 }, + { 1006, 480, 5857, 37, 6606859, 15 }, + { 1104, 480, 4768, 37, 6606860, 15 }, + { 1211, 480, 4786, 37, 6606861, 15 }, + { 1335, 480, 3621, 37, 6606862, 15 }, + { 1442, 480, 4722, 37, 6606863, 15 }, + { 12, 480, 3492, 37, 6606864, 15 }, + { 139, 480, 5025, 37, 6606865, 15 }, + { 262, 480, 3832, 37, 6606866, 15 }, + { 669, 480, 4989, 37, 6606867, 15 }, + { 764, 480, 3803, 37, 6606868, 15 }, + { 936, 480, 5112, 37, 6606869, 15 }, + { 1039, 480, 4043, 37, 6606870, 15 }, + { 1135, 480, 5076, 37, 6606871, 15 }, + { 1245, 480, 4014, 37, 6606872, 15 }, + { 1366, 480, 5199, 37, 6606873, 15 }, + { 45, 480, 4254, 37, 6606874, 15 }, + { 177, 480, 5163, 37, 6606875, 15 }, + { 297, 480, 4225, 37, 6606876, 15 }, + { 709, 480, 5286, 37, 6606877, 15 }, + { 800, 480, 4528, 37, 6606878, 15 }, + { 976, 480, 5250, 37, 6606879, 15 }, + { 1075, 480, 4499, 37, 6606880, 15 }, + { 1175, 480, 5531, 37, 6606881, 15 }, + { 1281, 480, 5513, 37, 6606882, 15 }, + { 1406, 480, 5975, 37, 6606883, 15 }, + { 81, 480, 6257, 37, 6606884, 15 }, + { 217, 480, 22, 37, 6606885, 15 }, + { 733, 470, 22, 37, 6606857, 15 }, + { 625, 1385, 1, 187, 6590475, 41 }, + { 317, 1339, 73, 187, 6590477, 41 }, + { 391, 1293, 1, 187, 6590479, 41 }, + { 447, 1247, 70, 187, 6590481, 41 }, + { 509, 1201, 1, 187, 6590483, 41 }, + { 577, 1155, 67, 187, 6590485, 41 }, + { 338, 1109, 1, 187, 6590487, 41 }, + { 413, 1063, 64, 187, 6590489, 41 }, + { 470, 1017, 1, 187, 6590491, 41 }, + { 533, 971, 61, 187, 6590493, 41 }, + { 601, 925, 1, 187, 6590495, 41 }, + { 362, 879, 14, 187, 6590497, 41 }, + { 557, 833, 14, 187, 6590473, 41 }, + { 1003, 90, 6148, 60, 6602762, 20 }, + { 1101, 90, 5767, 60, 6602763, 20 }, + { 1208, 90, 4772, 60, 6602764, 20 }, + { 1332, 90, 4975, 60, 6602765, 20 }, + { 1439, 90, 5062, 60, 6602766, 20 }, + { 9, 90, 4744, 60, 6602767, 20 }, + { 136, 90, 5048, 60, 6602768, 20 }, + { 259, 90, 5034, 60, 6602769, 20 }, + { 666, 90, 5149, 60, 6602770, 20 }, + { 760, 90, 5011, 60, 6602771, 20 }, + { 932, 90, 5135, 60, 6602772, 20 }, + { 1035, 90, 5121, 60, 6602773, 20 }, + { 1131, 90, 5236, 60, 6602774, 20 }, + { 1241, 90, 5098, 60, 6602775, 20 }, + { 1362, 90, 5222, 60, 6602776, 20 }, + { 41, 90, 5208, 60, 6602777, 20 }, + { 173, 90, 5323, 60, 6602778, 20 }, + { 293, 90, 5185, 60, 6602779, 20 }, + { 705, 90, 5309, 60, 6602780, 20 }, + { 796, 90, 5295, 60, 6602781, 20 }, + { 972, 90, 5568, 60, 6602782, 20 }, + { 1071, 90, 5272, 60, 6602783, 20 }, + { 1171, 90, 5554, 60, 6602784, 20 }, + { 1277, 90, 5540, 60, 6602785, 20 }, + { 1402, 90, 6070, 60, 6602786, 20 }, + { 77, 90, 6237, 60, 6602787, 20 }, + { 213, 90, 24, 60, 6602788, 20 }, + { 904, 75, 24, 60, 6602761, 20 }, + { 1098, 139, 6129, 75, 6598666, 26 }, + { 1205, 139, 5770, 75, 6598667, 26 }, + { 1329, 139, 4779, 75, 6598668, 26 }, + { 1436, 139, 5885, 75, 6598669, 26 }, + { 6, 139, 5582, 75, 6598670, 26 }, + { 133, 139, 5875, 75, 6598671, 26 }, + { 256, 139, 5041, 75, 6598672, 26 }, + { 663, 139, 5905, 75, 6598673, 26 }, + { 757, 139, 5590, 75, 6598674, 26 }, + { 928, 139, 5895, 75, 6598675, 26 }, + { 1031, 139, 5128, 75, 6598676, 26 }, + { 1127, 139, 5925, 75, 6598677, 26 }, + { 1237, 139, 5598, 75, 6598678, 26 }, + { 1358, 139, 5915, 75, 6598679, 26 }, + { 37, 139, 5215, 75, 6598680, 26 }, + { 169, 139, 5945, 75, 6598681, 26 }, + { 289, 139, 5606, 75, 6598682, 26 }, + { 701, 139, 5935, 75, 6598683, 26 }, + { 792, 139, 5302, 75, 6598684, 26 }, + { 968, 139, 5965, 75, 6598685, 26 }, + { 1067, 139, 5614, 75, 6598686, 26 }, + { 1167, 139, 5955, 75, 6598687, 26 }, + { 1273, 139, 5365, 75, 6598688, 26 }, + { 1398, 139, 6083, 75, 6598689, 26 }, + { 73, 139, 6225, 75, 6598690, 26 }, + { 209, 139, 25, 75, 6598691, 26 }, + { 1000, 118, 25, 75, 6598665, 26 }, + { 1202, 188, 6131, 96, 6594570, 33 }, + { 1326, 188, 5776, 96, 6594571, 33 }, + { 1433, 188, 5891, 96, 6594572, 33 }, + { 3, 188, 6175, 96, 6594573, 33 }, + { 130, 188, 6180, 96, 6594574, 33 }, + { 253, 188, 5881, 96, 6594575, 33 }, + { 660, 188, 5911, 96, 6594576, 33 }, + { 754, 188, 6185, 96, 6594577, 33 }, + { 925, 188, 6190, 96, 6594578, 33 }, + { 1027, 188, 5901, 96, 6594579, 33 }, + { 1123, 188, 5931, 96, 6594580, 33 }, + { 1233, 188, 6195, 96, 6594581, 33 }, + { 1354, 188, 6200, 96, 6594582, 33 }, + { 33, 188, 5921, 96, 6594583, 33 }, + { 165, 188, 5951, 96, 6594584, 33 }, + { 285, 188, 6205, 96, 6594585, 33 }, + { 697, 188, 6210, 96, 6594586, 33 }, + { 788, 188, 5941, 96, 6594587, 33 }, + { 964, 188, 5971, 96, 6594588, 33 }, + { 1063, 188, 6215, 96, 6594589, 33 }, + { 1163, 188, 6220, 96, 6594590, 33 }, + { 1269, 188, 5961, 96, 6594591, 33 }, + { 1394, 188, 5989, 96, 6594592, 33 }, + { 69, 188, 6232, 96, 6594593, 33 }, + { 205, 188, 12, 96, 6594594, 33 }, + { 1095, 160, 12, 96, 6594569, 33 }, + { 1323, 252, 1, 124, 6590474, 41 }, + { 1430, 252, 10, 124, 6590475, 41 }, + { 0, 252, 1, 124, 6590476, 41 }, + { 127, 252, 72, 124, 6590477, 41 }, + { 250, 252, 1, 124, 6590478, 41 }, + { 657, 252, 8, 124, 6590479, 41 }, + { 751, 252, 1, 124, 6590480, 41 }, + { 922, 252, 69, 124, 6590481, 41 }, + { 1024, 252, 1, 124, 6590482, 41 }, + { 1119, 252, 6, 124, 6590483, 41 }, + { 1229, 252, 1, 124, 6590484, 41 }, + { 1350, 252, 66, 124, 6590485, 41 }, + { 29, 252, 1, 124, 6590486, 41 }, + { 161, 252, 4, 124, 6590487, 41 }, + { 281, 252, 1, 124, 6590488, 41 }, + { 693, 252, 63, 124, 6590489, 41 }, + { 784, 252, 1, 124, 6590490, 41 }, + { 960, 252, 2, 124, 6590491, 41 }, + { 1059, 252, 1, 124, 6590492, 41 }, + { 1159, 252, 60, 124, 6590493, 41 }, + { 1265, 252, 1, 124, 6590494, 41 }, + { 1390, 252, 0, 124, 6590495, 41 }, + { 65, 252, 1, 124, 6590496, 41 }, + { 201, 252, 13, 124, 6590497, 41 }, + { 1199, 216, 13, 124, 6590473, 41 }, }; + // FPR16 Register Class... + static const MCPhysReg FPR16[] = { + RISCV_F15_H, RISCV_F14_H, RISCV_F13_H, RISCV_F12_H, RISCV_F11_H, RISCV_F10_H, RISCV_F0_H, RISCV_F1_H, RISCV_F2_H, RISCV_F3_H, RISCV_F4_H, RISCV_F5_H, RISCV_F6_H, RISCV_F7_H, RISCV_F16_H, RISCV_F17_H, RISCV_F28_H, RISCV_F29_H, RISCV_F30_H, RISCV_F31_H, RISCV_F8_H, RISCV_F9_H, RISCV_F18_H, RISCV_F19_H, RISCV_F20_H, RISCV_F21_H, RISCV_F22_H, RISCV_F23_H, RISCV_F24_H, RISCV_F25_H, RISCV_F26_H, RISCV_F27_H, + }; + + // FPR16 Bit set. + static const uint8_t FPR16Bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0x03, + }; + + // GPRAll Register Class... + static const MCPhysReg GPRAll[] = { + RISCV_X10, RISCV_X11, RISCV_X12, RISCV_X13, RISCV_X14, RISCV_X15, RISCV_X16, RISCV_X17, RISCV_X5, RISCV_X6, RISCV_X7, RISCV_X28, RISCV_X29, RISCV_X30, RISCV_X31, RISCV_X8, RISCV_X9, RISCV_X18, RISCV_X19, RISCV_X20, RISCV_X21, RISCV_X22, RISCV_X23, RISCV_X24, RISCV_X25, RISCV_X26, RISCV_X27, RISCV_X0, RISCV_X1, RISCV_X2, RISCV_X3, RISCV_X4, RISCV_DUMMY_REG_PAIR_WITH_X0, + }; + + // GPRAll Bit set. + static const uint8_t GPRAllBits[] = { + 0x00, 0x02, 0x00, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0x03, + }; + // FPR32 Register Class... static const MCPhysReg FPR32[] = { - RISCV_F0_32, RISCV_F1_32, RISCV_F2_32, RISCV_F3_32, RISCV_F4_32, RISCV_F5_32, RISCV_F6_32, RISCV_F7_32, RISCV_F10_32, RISCV_F11_32, RISCV_F12_32, RISCV_F13_32, RISCV_F14_32, RISCV_F15_32, RISCV_F16_32, RISCV_F17_32, RISCV_F28_32, RISCV_F29_32, RISCV_F30_32, RISCV_F31_32, RISCV_F8_32, RISCV_F9_32, RISCV_F18_32, RISCV_F19_32, RISCV_F20_32, RISCV_F21_32, RISCV_F22_32, RISCV_F23_32, RISCV_F24_32, RISCV_F25_32, RISCV_F26_32, RISCV_F27_32, + RISCV_F15_F, RISCV_F14_F, RISCV_F13_F, RISCV_F12_F, RISCV_F11_F, RISCV_F10_F, RISCV_F0_F, RISCV_F1_F, RISCV_F2_F, RISCV_F3_F, RISCV_F4_F, RISCV_F5_F, RISCV_F6_F, RISCV_F7_F, RISCV_F16_F, RISCV_F17_F, RISCV_F28_F, RISCV_F29_F, RISCV_F30_F, RISCV_F31_F, RISCV_F8_F, RISCV_F9_F, RISCV_F18_F, RISCV_F19_F, RISCV_F20_F, RISCV_F21_F, RISCV_F22_F, RISCV_F23_F, RISCV_F24_F, RISCV_F25_F, RISCV_F26_F, RISCV_F27_F, }; // FPR32 Bit set. static const uint8_t FPR32Bits[] = { - 0x00, 0x00, 0x00, 0x00, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0x03, }; // GPR Register Class... @@ -316,7 +1474,27 @@ static const MCRegisterDesc RISCVRegDesc[] = { // Descriptors // GPR Bit set. static const uint8_t GPRBits[] = { - 0xfe, 0xff, 0xff, 0xff, 0x01, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0x03, + }; + + // GPRF16 Register Class... + static const MCPhysReg GPRF16[] = { + RISCV_X10, RISCV_X11, RISCV_X12, RISCV_X13, RISCV_X14, RISCV_X15, RISCV_X16, RISCV_X17, RISCV_X5, RISCV_X6, RISCV_X7, RISCV_X28, RISCV_X29, RISCV_X30, RISCV_X31, RISCV_X8, RISCV_X9, RISCV_X18, RISCV_X19, RISCV_X20, RISCV_X21, RISCV_X22, RISCV_X23, RISCV_X24, RISCV_X25, RISCV_X26, RISCV_X27, RISCV_X0, RISCV_X1, RISCV_X2, RISCV_X3, RISCV_X4, + }; + + // GPRF16 Bit set. + static const uint8_t GPRF16Bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0x03, + }; + + // GPRF32 Register Class... + static const MCPhysReg GPRF32[] = { + RISCV_X10, RISCV_X11, RISCV_X12, RISCV_X13, RISCV_X14, RISCV_X15, RISCV_X16, RISCV_X17, RISCV_X5, RISCV_X6, RISCV_X7, RISCV_X28, RISCV_X29, RISCV_X30, RISCV_X31, RISCV_X8, RISCV_X9, RISCV_X18, RISCV_X19, RISCV_X20, RISCV_X21, RISCV_X22, RISCV_X23, RISCV_X24, RISCV_X25, RISCV_X26, RISCV_X27, RISCV_X0, RISCV_X1, RISCV_X2, RISCV_X3, RISCV_X4, + }; + + // GPRF32 Bit set. + static const uint8_t GPRF32Bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0x03, }; // GPRNoX0 Register Class... @@ -326,7 +1504,7 @@ static const MCRegisterDesc RISCVRegDesc[] = { // Descriptors // GPRNoX0 Bit set. static const uint8_t GPRNoX0Bits[] = { - 0xfc, 0xff, 0xff, 0xff, 0x01, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xff, 0xff, 0xff, 0x03, }; // GPRNoX0X2 Register Class... @@ -336,27 +1514,37 @@ static const MCRegisterDesc RISCVRegDesc[] = { // Descriptors // GPRNoX0X2 Bit set. static const uint8_t GPRNoX0X2Bits[] = { - 0xf4, 0xff, 0xff, 0xff, 0x01, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xe8, 0xff, 0xff, 0xff, 0x03, + }; + + // GPRJALR Register Class... + static const MCPhysReg GPRJALR[] = { + RISCV_X10, RISCV_X11, RISCV_X12, RISCV_X13, RISCV_X14, RISCV_X15, RISCV_X16, RISCV_X17, RISCV_X6, RISCV_X7, RISCV_X28, RISCV_X29, RISCV_X30, RISCV_X31, RISCV_X8, RISCV_X9, RISCV_X18, RISCV_X19, RISCV_X20, RISCV_X21, RISCV_X22, RISCV_X23, RISCV_X24, RISCV_X25, RISCV_X26, RISCV_X27, + }; + + // GPRJALR Bit set. + static const uint8_t GPRJALRBits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x03, }; // GPRTC Register Class... static const MCPhysReg GPRTC[] = { - RISCV_X5, RISCV_X6, RISCV_X7, RISCV_X10, RISCV_X11, RISCV_X12, RISCV_X13, RISCV_X14, RISCV_X15, RISCV_X16, RISCV_X17, RISCV_X28, RISCV_X29, RISCV_X30, RISCV_X31, + RISCV_X6, RISCV_X7, RISCV_X10, RISCV_X11, RISCV_X12, RISCV_X13, RISCV_X14, RISCV_X15, RISCV_X16, RISCV_X17, RISCV_X28, RISCV_X29, RISCV_X30, RISCV_X31, }; // GPRTC Bit set. static const uint8_t GPRTCBits[] = { - 0xc0, 0xf9, 0x07, 0xe0, 0x01, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf3, 0x0f, 0xc0, 0x03, }; // FPR32C Register Class... static const MCPhysReg FPR32C[] = { - RISCV_F10_32, RISCV_F11_32, RISCV_F12_32, RISCV_F13_32, RISCV_F14_32, RISCV_F15_32, RISCV_F8_32, RISCV_F9_32, + RISCV_F15_F, RISCV_F14_F, RISCV_F13_F, RISCV_F12_F, RISCV_F11_F, RISCV_F10_F, RISCV_F8_F, RISCV_F9_F, }; // FPR32C Bit set. static const uint8_t FPR32CBits[] = { - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xaa, 0xaa, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x03, }; // GPRC Register Class... @@ -366,7 +1554,17 @@ static const MCRegisterDesc RISCVRegDesc[] = { // Descriptors // GPRC Bit set. static const uint8_t GPRCBits[] = { - 0x00, 0xfe, 0x01, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x03, + }; + + // SR07 Register Class... + static const MCPhysReg SR07[] = { + RISCV_X8, RISCV_X9, RISCV_X18, RISCV_X19, RISCV_X20, RISCV_X21, RISCV_X22, RISCV_X23, + }; + + // SR07 Bit set. + static const uint8_t SR07Bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0xf0, 0x03, }; // GPRC_and_GPRTC Register Class... @@ -376,7 +1574,67 @@ static const MCRegisterDesc RISCVRegDesc[] = { // Descriptors // GPRC_and_GPRTC Bit set. static const uint8_t GPRC_and_GPRTCBits[] = { - 0x00, 0xf8, 0x01, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x03, + }; + + // VCSR Register Class... + static const MCPhysReg VCSR[] = { + RISCV_VTYPE, RISCV_VL, RISCV_VLENB, + }; + + // VCSR Bit set. + static const uint8_t VCSRBits[] = { + 0x70, + }; + + // GPRC_and_SR07 Register Class... + static const MCPhysReg GPRC_and_SR07[] = { + RISCV_X8, RISCV_X9, + }; + + // GPRC_and_SR07 Bit set. + static const uint8_t GPRC_and_SR07Bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, + }; + + // GPRX1X5 Register Class... + static const MCPhysReg GPRX1X5[] = { + RISCV_X1, RISCV_X5, + }; + + // GPRX1X5 Bit set. + static const uint8_t GPRX1X5Bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x88, + }; + + // GPRX0 Register Class... + static const MCPhysReg GPRX0[] = { + RISCV_X0, + }; + + // GPRX0 Bit set. + static const uint8_t GPRX0Bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, + }; + + // GPRX1 Register Class... + static const MCPhysReg GPRX1[] = { + RISCV_X1, + }; + + // GPRX1 Bit set. + static const uint8_t GPRX1Bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, + }; + + // GPRX5 Register Class... + static const MCPhysReg GPRX5[] = { + RISCV_X5, + }; + + // GPRX5 Bit set. + static const uint8_t GPRX5Bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, }; // SP Register Class... @@ -386,41 +1644,1155 @@ static const MCRegisterDesc RISCVRegDesc[] = { // Descriptors // SP Bit set. static const uint8_t SPBits[] = { - 0x08, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, }; // FPR64 Register Class... static const MCPhysReg FPR64[] = { - RISCV_F0_64, RISCV_F1_64, RISCV_F2_64, RISCV_F3_64, RISCV_F4_64, RISCV_F5_64, RISCV_F6_64, RISCV_F7_64, RISCV_F10_64, RISCV_F11_64, RISCV_F12_64, RISCV_F13_64, RISCV_F14_64, RISCV_F15_64, RISCV_F16_64, RISCV_F17_64, RISCV_F28_64, RISCV_F29_64, RISCV_F30_64, RISCV_F31_64, RISCV_F8_64, RISCV_F9_64, RISCV_F18_64, RISCV_F19_64, RISCV_F20_64, RISCV_F21_64, RISCV_F22_64, RISCV_F23_64, RISCV_F24_64, RISCV_F25_64, RISCV_F26_64, RISCV_F27_64, + RISCV_F15_D, RISCV_F14_D, RISCV_F13_D, RISCV_F12_D, RISCV_F11_D, RISCV_F10_D, RISCV_F0_D, RISCV_F1_D, RISCV_F2_D, RISCV_F3_D, RISCV_F4_D, RISCV_F5_D, RISCV_F6_D, RISCV_F7_D, RISCV_F16_D, RISCV_F17_D, RISCV_F28_D, RISCV_F29_D, RISCV_F30_D, RISCV_F31_D, RISCV_F8_D, RISCV_F9_D, RISCV_F18_D, RISCV_F19_D, RISCV_F20_D, RISCV_F21_D, RISCV_F22_D, RISCV_F23_D, RISCV_F24_D, RISCV_F25_D, RISCV_F26_D, RISCV_F27_D, }; // FPR64 Bit set. static const uint8_t FPR64Bits[] = { - 0x00, 0x00, 0x00, 0x00, 0x54, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x01, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0x03, + }; + + // VM Register Class... + static const MCPhysReg VM[] = { + RISCV_V8, RISCV_V9, RISCV_V10, RISCV_V11, RISCV_V12, RISCV_V13, RISCV_V14, RISCV_V15, RISCV_V16, RISCV_V17, RISCV_V18, RISCV_V19, RISCV_V20, RISCV_V21, RISCV_V22, RISCV_V23, RISCV_V24, RISCV_V25, RISCV_V26, RISCV_V27, RISCV_V28, RISCV_V29, RISCV_V30, RISCV_V31, RISCV_V0, RISCV_V1, RISCV_V2, RISCV_V3, RISCV_V4, RISCV_V5, RISCV_V6, RISCV_V7, + }; + + // VM Bit set. + static const uint8_t VMBits[] = { + 0x00, 0xfc, 0xff, 0xff, 0xff, 0x03, + }; + + // VR Register Class... + static const MCPhysReg VR[] = { + RISCV_V8, RISCV_V9, RISCV_V10, RISCV_V11, RISCV_V12, RISCV_V13, RISCV_V14, RISCV_V15, RISCV_V16, RISCV_V17, RISCV_V18, RISCV_V19, RISCV_V20, RISCV_V21, RISCV_V22, RISCV_V23, RISCV_V24, RISCV_V25, RISCV_V26, RISCV_V27, RISCV_V28, RISCV_V29, RISCV_V30, RISCV_V31, RISCV_V0, RISCV_V1, RISCV_V2, RISCV_V3, RISCV_V4, RISCV_V5, RISCV_V6, RISCV_V7, + }; + + // VR Bit set. + static const uint8_t VRBits[] = { + 0x00, 0xfc, 0xff, 0xff, 0xff, 0x03, + }; + + // VRNoV0 Register Class... + static const MCPhysReg VRNoV0[] = { + RISCV_V8, RISCV_V9, RISCV_V10, RISCV_V11, RISCV_V12, RISCV_V13, RISCV_V14, RISCV_V15, RISCV_V16, RISCV_V17, RISCV_V18, RISCV_V19, RISCV_V20, RISCV_V21, RISCV_V22, RISCV_V23, RISCV_V24, RISCV_V25, RISCV_V26, RISCV_V27, RISCV_V28, RISCV_V29, RISCV_V30, RISCV_V31, RISCV_V1, RISCV_V2, RISCV_V3, RISCV_V4, RISCV_V5, RISCV_V6, RISCV_V7, + }; + + // VRNoV0 Bit set. + static const uint8_t VRNoV0Bits[] = { + 0x00, 0xf8, 0xff, 0xff, 0xff, 0x03, + }; + + // GPRPair Register Class... + static const MCPhysReg GPRPair[] = { + RISCV_X10_X11, RISCV_X12_X13, RISCV_X14_X15, RISCV_X16_X17, RISCV_X6_X7, RISCV_X28_X29, RISCV_X30_X31, RISCV_X8_X9, RISCV_X18_X19, RISCV_X20_X21, RISCV_X22_X23, RISCV_X24_X25, RISCV_X26_X27, RISCV_X0_Pair, RISCV_X2_X3, RISCV_X4_X5, + }; + + // GPRPair Bit set. + static const uint8_t GPRPairBits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x80, 0xff, 0x3f, + }; + + // GPRPair_with_sub_gpr_even_in_GPRNoX0 Register Class... + static const MCPhysReg GPRPair_with_sub_gpr_even_in_GPRNoX0[] = { + RISCV_X10_X11, RISCV_X12_X13, RISCV_X14_X15, RISCV_X16_X17, RISCV_X6_X7, RISCV_X28_X29, RISCV_X30_X31, RISCV_X8_X9, RISCV_X18_X19, RISCV_X20_X21, RISCV_X22_X23, RISCV_X24_X25, RISCV_X26_X27, RISCV_X2_X3, RISCV_X4_X5, + }; + + // GPRPair_with_sub_gpr_even_in_GPRNoX0 Bit set. + static const uint8_t GPRPair_with_sub_gpr_even_in_GPRNoX0Bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xff, 0x3f, + }; + + // GPRPair_with_sub_gpr_even_in_GPRNoX0X2 Register Class... + static const MCPhysReg GPRPair_with_sub_gpr_even_in_GPRNoX0X2[] = { + RISCV_X10_X11, RISCV_X12_X13, RISCV_X14_X15, RISCV_X16_X17, RISCV_X6_X7, RISCV_X28_X29, RISCV_X30_X31, RISCV_X8_X9, RISCV_X18_X19, RISCV_X20_X21, RISCV_X22_X23, RISCV_X24_X25, RISCV_X26_X27, RISCV_X4_X5, + }; + + // GPRPair_with_sub_gpr_even_in_GPRNoX0X2 Bit set. + static const uint8_t GPRPair_with_sub_gpr_even_in_GPRNoX0X2Bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x3f, + }; + + // GPRPair_with_sub_gpr_even_in_GPRJALR Register Class... + static const MCPhysReg GPRPair_with_sub_gpr_even_in_GPRJALR[] = { + RISCV_X10_X11, RISCV_X12_X13, RISCV_X14_X15, RISCV_X16_X17, RISCV_X6_X7, RISCV_X28_X29, RISCV_X30_X31, RISCV_X8_X9, RISCV_X18_X19, RISCV_X20_X21, RISCV_X22_X23, RISCV_X24_X25, RISCV_X26_X27, + }; + + // GPRPair_with_sub_gpr_even_in_GPRJALR Bit set. + static const uint8_t GPRPair_with_sub_gpr_even_in_GPRJALRBits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x3f, }; // FPR64C Register Class... static const MCPhysReg FPR64C[] = { - RISCV_F10_64, RISCV_F11_64, RISCV_F12_64, RISCV_F13_64, RISCV_F14_64, RISCV_F15_64, RISCV_F8_64, RISCV_F9_64, + RISCV_F15_D, RISCV_F14_D, RISCV_F13_D, RISCV_F12_D, RISCV_F11_D, RISCV_F10_D, RISCV_F8_D, RISCV_F9_D, }; // FPR64C Bit set. static const uint8_t FPR64CBits[] = { - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x54, 0x55, 0x01, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x03, + }; + + // GPRPair_with_sub_gpr_even_in_GPRTC Register Class... + static const MCPhysReg GPRPair_with_sub_gpr_even_in_GPRTC[] = { + RISCV_X10_X11, RISCV_X12_X13, RISCV_X14_X15, RISCV_X16_X17, RISCV_X6_X7, RISCV_X28_X29, RISCV_X30_X31, + }; + + // GPRPair_with_sub_gpr_even_in_GPRTC Bit set. + static const uint8_t GPRPair_with_sub_gpr_even_in_GPRTCBits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7a, 0x30, + }; + + // GPRPair_with_sub_gpr_even_in_GPRC Register Class... + static const MCPhysReg GPRPair_with_sub_gpr_even_in_GPRC[] = { + RISCV_X10_X11, RISCV_X12_X13, RISCV_X14_X15, RISCV_X8_X9, + }; + + // GPRPair_with_sub_gpr_even_in_GPRC Bit set. + static const uint8_t GPRPair_with_sub_gpr_even_in_GPRCBits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, + }; + + // GPRPair_with_sub_gpr_even_in_SR07 Register Class... + static const MCPhysReg GPRPair_with_sub_gpr_even_in_SR07[] = { + RISCV_X8_X9, RISCV_X18_X19, RISCV_X20_X21, RISCV_X22_X23, + }; + + // GPRPair_with_sub_gpr_even_in_SR07 Bit set. + static const uint8_t GPRPair_with_sub_gpr_even_in_SR07Bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x84, 0x03, + }; + + // GPRPair_with_sub_gpr_even_in_GPRC_and_GPRTC Register Class... + static const MCPhysReg GPRPair_with_sub_gpr_even_in_GPRC_and_GPRTC[] = { + RISCV_X10_X11, RISCV_X12_X13, RISCV_X14_X15, + }; + + // GPRPair_with_sub_gpr_even_in_GPRC_and_GPRTC Bit set. + static const uint8_t GPRPair_with_sub_gpr_even_in_GPRC_and_GPRTCBits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, + }; + + // GPRPair_with_sub_gpr_even_in_GPRC_and_SR07 Register Class... + static const MCPhysReg GPRPair_with_sub_gpr_even_in_GPRC_and_SR07[] = { + RISCV_X8_X9, + }; + + // GPRPair_with_sub_gpr_even_in_GPRC_and_SR07 Bit set. + static const uint8_t GPRPair_with_sub_gpr_even_in_GPRC_and_SR07Bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, + }; + + // GPRPair_with_sub_gpr_even_in_GPRX0 Register Class... + static const MCPhysReg GPRPair_with_sub_gpr_even_in_GPRX0[] = { + RISCV_X0_Pair, + }; + + // GPRPair_with_sub_gpr_even_in_GPRX0 Bit set. + static const uint8_t GPRPair_with_sub_gpr_even_in_GPRX0Bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, + }; + + // GPRPair_with_sub_gpr_even_in_SP Register Class... + static const MCPhysReg GPRPair_with_sub_gpr_even_in_SP[] = { + RISCV_X2_X3, + }; + + // GPRPair_with_sub_gpr_even_in_SP Bit set. + static const uint8_t GPRPair_with_sub_gpr_even_in_SPBits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, + }; + + // GPRPair_with_sub_gpr_odd_in_GPRX1X5 Register Class... + static const MCPhysReg GPRPair_with_sub_gpr_odd_in_GPRX1X5[] = { + RISCV_X4_X5, + }; + + // GPRPair_with_sub_gpr_odd_in_GPRX1X5 Bit set. + static const uint8_t GPRPair_with_sub_gpr_odd_in_GPRX1X5Bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, + }; + + // VMV0 Register Class... + static const MCPhysReg VMV0[] = { + RISCV_V0, + }; + + // VMV0 Bit set. + static const uint8_t VMV0Bits[] = { + 0x00, 0x04, + }; + + // VRN2M1 Register Class... + static const MCPhysReg VRN2M1[] = { + RISCV_V8_V9, RISCV_V9_V10, RISCV_V10_V11, RISCV_V11_V12, RISCV_V12_V13, RISCV_V13_V14, RISCV_V14_V15, RISCV_V15_V16, RISCV_V16_V17, RISCV_V17_V18, RISCV_V18_V19, RISCV_V19_V20, RISCV_V20_V21, RISCV_V21_V22, RISCV_V22_V23, RISCV_V23_V24, RISCV_V24_V25, RISCV_V25_V26, RISCV_V26_V27, RISCV_V27_V28, RISCV_V28_V29, RISCV_V29_V30, RISCV_V30_V31, RISCV_V1_V2, RISCV_V2_V3, RISCV_V3_V4, RISCV_V4_V5, RISCV_V5_V6, RISCV_V6_V7, RISCV_V7_V8, RISCV_V0_V1, + }; + + // VRN2M1 Bit set. + static const uint8_t VRN2M1Bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xff, 0xff, 0xff, 0x1f, + }; + + // VRN2M1NoV0 Register Class... + static const MCPhysReg VRN2M1NoV0[] = { + RISCV_V8_V9, RISCV_V9_V10, RISCV_V10_V11, RISCV_V11_V12, RISCV_V12_V13, RISCV_V13_V14, RISCV_V14_V15, RISCV_V15_V16, RISCV_V16_V17, RISCV_V17_V18, RISCV_V18_V19, RISCV_V19_V20, RISCV_V20_V21, RISCV_V21_V22, RISCV_V22_V23, RISCV_V23_V24, RISCV_V24_V25, RISCV_V25_V26, RISCV_V26_V27, RISCV_V27_V28, RISCV_V28_V29, RISCV_V29_V30, RISCV_V30_V31, RISCV_V1_V2, RISCV_V2_V3, RISCV_V3_V4, RISCV_V4_V5, RISCV_V5_V6, RISCV_V6_V7, RISCV_V7_V8, + }; + + // VRN2M1NoV0 Bit set. + static const uint8_t VRN2M1NoV0Bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xff, 0xff, 0xff, 0x0f, + }; + + // VRM2 Register Class... + static const MCPhysReg VRM2[] = { + RISCV_V8M2, RISCV_V10M2, RISCV_V12M2, RISCV_V14M2, RISCV_V16M2, RISCV_V18M2, RISCV_V20M2, RISCV_V22M2, RISCV_V24M2, RISCV_V26M2, RISCV_V28M2, RISCV_V30M2, RISCV_V0M2, RISCV_V2M2, RISCV_V4M2, RISCV_V6M2, + }; + + // VRM2 Bit set. + static const uint8_t VRM2Bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc8, 0x66, 0xb3, 0x59, + }; + + // VRM2NoV0 Register Class... + static const MCPhysReg VRM2NoV0[] = { + RISCV_V8M2, RISCV_V10M2, RISCV_V12M2, RISCV_V14M2, RISCV_V16M2, RISCV_V18M2, RISCV_V20M2, RISCV_V22M2, RISCV_V24M2, RISCV_V26M2, RISCV_V28M2, RISCV_V30M2, RISCV_V2M2, RISCV_V4M2, RISCV_V6M2, + }; + + // VRM2NoV0 Bit set. + static const uint8_t VRM2NoV0Bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x66, 0xb3, 0x59, + }; + + // VRM2_with_sub_vrm1_0_in_VMV0 Register Class... + static const MCPhysReg VRM2_with_sub_vrm1_0_in_VMV0[] = { + RISCV_V0M2, + }; + + // VRM2_with_sub_vrm1_0_in_VMV0 Bit set. + static const uint8_t VRM2_with_sub_vrm1_0_in_VMV0Bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, + }; + + // VRN2M1_with_sub_vrm1_0_in_VMV0 Register Class... + static const MCPhysReg VRN2M1_with_sub_vrm1_0_in_VMV0[] = { + RISCV_V0_V1, + }; + + // VRN2M1_with_sub_vrm1_0_in_VMV0 Bit set. + static const uint8_t VRN2M1_with_sub_vrm1_0_in_VMV0Bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, + }; + + // VRN3M1 Register Class... + static const MCPhysReg VRN3M1[] = { + RISCV_V8_V9_V10, RISCV_V9_V10_V11, RISCV_V10_V11_V12, RISCV_V11_V12_V13, RISCV_V12_V13_V14, RISCV_V13_V14_V15, RISCV_V14_V15_V16, RISCV_V15_V16_V17, RISCV_V16_V17_V18, RISCV_V17_V18_V19, RISCV_V18_V19_V20, RISCV_V19_V20_V21, RISCV_V20_V21_V22, RISCV_V21_V22_V23, RISCV_V22_V23_V24, RISCV_V23_V24_V25, RISCV_V24_V25_V26, RISCV_V25_V26_V27, RISCV_V26_V27_V28, RISCV_V27_V28_V29, RISCV_V28_V29_V30, RISCV_V29_V30_V31, RISCV_V1_V2_V3, RISCV_V2_V3_V4, RISCV_V3_V4_V5, RISCV_V4_V5_V6, RISCV_V5_V6_V7, RISCV_V6_V7_V8, RISCV_V7_V8_V9, RISCV_V0_V1_V2, + }; + + // VRN3M1 Bit set. + static const uint8_t VRN3M1Bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xff, 0xff, 0xff, 0x01, + }; + + // VRN3M1NoV0 Register Class... + static const MCPhysReg VRN3M1NoV0[] = { + RISCV_V8_V9_V10, RISCV_V9_V10_V11, RISCV_V10_V11_V12, RISCV_V11_V12_V13, RISCV_V12_V13_V14, RISCV_V13_V14_V15, RISCV_V14_V15_V16, RISCV_V15_V16_V17, RISCV_V16_V17_V18, RISCV_V17_V18_V19, RISCV_V18_V19_V20, RISCV_V19_V20_V21, RISCV_V20_V21_V22, RISCV_V21_V22_V23, RISCV_V22_V23_V24, RISCV_V23_V24_V25, RISCV_V24_V25_V26, RISCV_V25_V26_V27, RISCV_V26_V27_V28, RISCV_V27_V28_V29, RISCV_V28_V29_V30, RISCV_V29_V30_V31, RISCV_V1_V2_V3, RISCV_V2_V3_V4, RISCV_V3_V4_V5, RISCV_V4_V5_V6, RISCV_V5_V6_V7, RISCV_V6_V7_V8, RISCV_V7_V8_V9, + }; + + // VRN3M1NoV0 Bit set. + static const uint8_t VRN3M1NoV0Bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xff, 0xff, 0xff, + }; + + // VRN3M1_with_sub_vrm1_0_in_VMV0 Register Class... + static const MCPhysReg VRN3M1_with_sub_vrm1_0_in_VMV0[] = { + RISCV_V0_V1_V2, + }; + + // VRN3M1_with_sub_vrm1_0_in_VMV0 Bit set. + static const uint8_t VRN3M1_with_sub_vrm1_0_in_VMV0Bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, + }; + + // VRN4M1 Register Class... + static const MCPhysReg VRN4M1[] = { + RISCV_V8_V9_V10_V11, RISCV_V9_V10_V11_V12, RISCV_V10_V11_V12_V13, RISCV_V11_V12_V13_V14, RISCV_V12_V13_V14_V15, RISCV_V13_V14_V15_V16, RISCV_V14_V15_V16_V17, RISCV_V15_V16_V17_V18, RISCV_V16_V17_V18_V19, RISCV_V17_V18_V19_V20, RISCV_V18_V19_V20_V21, RISCV_V19_V20_V21_V22, RISCV_V20_V21_V22_V23, RISCV_V21_V22_V23_V24, RISCV_V22_V23_V24_V25, RISCV_V23_V24_V25_V26, RISCV_V24_V25_V26_V27, RISCV_V25_V26_V27_V28, RISCV_V26_V27_V28_V29, RISCV_V27_V28_V29_V30, RISCV_V28_V29_V30_V31, RISCV_V1_V2_V3_V4, RISCV_V2_V3_V4_V5, RISCV_V3_V4_V5_V6, RISCV_V4_V5_V6_V7, RISCV_V5_V6_V7_V8, RISCV_V6_V7_V8_V9, RISCV_V7_V8_V9_V10, RISCV_V0_V1_V2_V3, + }; + + // VRN4M1 Bit set. + static const uint8_t VRN4M1Bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0x0f, + }; + + // VRN4M1NoV0 Register Class... + static const MCPhysReg VRN4M1NoV0[] = { + RISCV_V8_V9_V10_V11, RISCV_V9_V10_V11_V12, RISCV_V10_V11_V12_V13, RISCV_V11_V12_V13_V14, RISCV_V12_V13_V14_V15, RISCV_V13_V14_V15_V16, RISCV_V14_V15_V16_V17, RISCV_V15_V16_V17_V18, RISCV_V16_V17_V18_V19, RISCV_V17_V18_V19_V20, RISCV_V18_V19_V20_V21, RISCV_V19_V20_V21_V22, RISCV_V20_V21_V22_V23, RISCV_V21_V22_V23_V24, RISCV_V22_V23_V24_V25, RISCV_V23_V24_V25_V26, RISCV_V24_V25_V26_V27, RISCV_V25_V26_V27_V28, RISCV_V26_V27_V28_V29, RISCV_V27_V28_V29_V30, RISCV_V28_V29_V30_V31, RISCV_V1_V2_V3_V4, RISCV_V2_V3_V4_V5, RISCV_V3_V4_V5_V6, RISCV_V4_V5_V6_V7, RISCV_V5_V6_V7_V8, RISCV_V6_V7_V8_V9, RISCV_V7_V8_V9_V10, + }; + + // VRN4M1NoV0 Bit set. + static const uint8_t VRN4M1NoV0Bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0x07, + }; + + // VRN2M2 Register Class... + static const MCPhysReg VRN2M2[] = { + RISCV_V8M2_V10M2, RISCV_V10M2_V12M2, RISCV_V12M2_V14M2, RISCV_V14M2_V16M2, RISCV_V16M2_V18M2, RISCV_V18M2_V20M2, RISCV_V20M2_V22M2, RISCV_V22M2_V24M2, RISCV_V24M2_V26M2, RISCV_V26M2_V28M2, RISCV_V28M2_V30M2, RISCV_V2M2_V4M2, RISCV_V4M2_V6M2, RISCV_V6M2_V8M2, RISCV_V0M2_V2M2, + }; + + // VRN2M2 Bit set. + static const uint8_t VRN2M2Bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0xff, 0x0f, + }; + + // VRN2M2NoV0 Register Class... + static const MCPhysReg VRN2M2NoV0[] = { + RISCV_V8M2_V10M2, RISCV_V10M2_V12M2, RISCV_V12M2_V14M2, RISCV_V14M2_V16M2, RISCV_V16M2_V18M2, RISCV_V18M2_V20M2, RISCV_V20M2_V22M2, RISCV_V22M2_V24M2, RISCV_V24M2_V26M2, RISCV_V26M2_V28M2, RISCV_V28M2_V30M2, RISCV_V2M2_V4M2, RISCV_V4M2_V6M2, RISCV_V6M2_V8M2, + }; + + // VRN2M2NoV0 Bit set. + static const uint8_t VRN2M2NoV0Bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0xff, 0x07, + }; + + // VRM4 Register Class... + static const MCPhysReg VRM4[] = { + RISCV_V8M4, RISCV_V12M4, RISCV_V16M4, RISCV_V20M4, RISCV_V24M4, RISCV_V28M4, RISCV_V0M4, RISCV_V4M4, + }; + + // VRM4 Bit set. + static const uint8_t VRM4Bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x89, 0x44, 0x22, + }; + + // VRM4NoV0 Register Class... + static const MCPhysReg VRM4NoV0[] = { + RISCV_V8M4, RISCV_V12M4, RISCV_V16M4, RISCV_V20M4, RISCV_V24M4, RISCV_V28M4, RISCV_V4M4, + }; + + // VRM4NoV0 Bit set. + static const uint8_t VRM4NoV0Bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x89, 0x44, 0x22, + }; + + // VRM4_with_sub_vrm1_0_in_VMV0 Register Class... + static const MCPhysReg VRM4_with_sub_vrm1_0_in_VMV0[] = { + RISCV_V0M4, + }; + + // VRM4_with_sub_vrm1_0_in_VMV0 Bit set. + static const uint8_t VRM4_with_sub_vrm1_0_in_VMV0Bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, + }; + + // VRN2M2_with_sub_vrm1_0_in_VMV0 Register Class... + static const MCPhysReg VRN2M2_with_sub_vrm1_0_in_VMV0[] = { + RISCV_V0M2_V2M2, + }; + + // VRN2M2_with_sub_vrm1_0_in_VMV0 Bit set. + static const uint8_t VRN2M2_with_sub_vrm1_0_in_VMV0Bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, + }; + + // VRN4M1_with_sub_vrm1_0_in_VMV0 Register Class... + static const MCPhysReg VRN4M1_with_sub_vrm1_0_in_VMV0[] = { + RISCV_V0_V1_V2_V3, + }; + + // VRN4M1_with_sub_vrm1_0_in_VMV0 Bit set. + static const uint8_t VRN4M1_with_sub_vrm1_0_in_VMV0Bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, + }; + + // VRN5M1 Register Class... + static const MCPhysReg VRN5M1[] = { + RISCV_V8_V9_V10_V11_V12, RISCV_V9_V10_V11_V12_V13, RISCV_V10_V11_V12_V13_V14, RISCV_V11_V12_V13_V14_V15, RISCV_V12_V13_V14_V15_V16, RISCV_V13_V14_V15_V16_V17, RISCV_V14_V15_V16_V17_V18, RISCV_V15_V16_V17_V18_V19, RISCV_V16_V17_V18_V19_V20, RISCV_V17_V18_V19_V20_V21, RISCV_V18_V19_V20_V21_V22, RISCV_V19_V20_V21_V22_V23, RISCV_V20_V21_V22_V23_V24, RISCV_V21_V22_V23_V24_V25, RISCV_V22_V23_V24_V25_V26, RISCV_V23_V24_V25_V26_V27, RISCV_V24_V25_V26_V27_V28, RISCV_V25_V26_V27_V28_V29, RISCV_V26_V27_V28_V29_V30, RISCV_V27_V28_V29_V30_V31, RISCV_V1_V2_V3_V4_V5, RISCV_V2_V3_V4_V5_V6, RISCV_V3_V4_V5_V6_V7, RISCV_V4_V5_V6_V7_V8, RISCV_V5_V6_V7_V8_V9, RISCV_V6_V7_V8_V9_V10, RISCV_V7_V8_V9_V10_V11, RISCV_V0_V1_V2_V3_V4, + }; + + // VRN5M1 Bit set. + static const uint8_t VRN5M1Bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0xff, 0x1f, + }; + + // VRN5M1NoV0 Register Class... + static const MCPhysReg VRN5M1NoV0[] = { + RISCV_V8_V9_V10_V11_V12, RISCV_V9_V10_V11_V12_V13, RISCV_V10_V11_V12_V13_V14, RISCV_V11_V12_V13_V14_V15, RISCV_V12_V13_V14_V15_V16, RISCV_V13_V14_V15_V16_V17, RISCV_V14_V15_V16_V17_V18, RISCV_V15_V16_V17_V18_V19, RISCV_V16_V17_V18_V19_V20, RISCV_V17_V18_V19_V20_V21, RISCV_V18_V19_V20_V21_V22, RISCV_V19_V20_V21_V22_V23, RISCV_V20_V21_V22_V23_V24, RISCV_V21_V22_V23_V24_V25, RISCV_V22_V23_V24_V25_V26, RISCV_V23_V24_V25_V26_V27, RISCV_V24_V25_V26_V27_V28, RISCV_V25_V26_V27_V28_V29, RISCV_V26_V27_V28_V29_V30, RISCV_V27_V28_V29_V30_V31, RISCV_V1_V2_V3_V4_V5, RISCV_V2_V3_V4_V5_V6, RISCV_V3_V4_V5_V6_V7, RISCV_V4_V5_V6_V7_V8, RISCV_V5_V6_V7_V8_V9, RISCV_V6_V7_V8_V9_V10, RISCV_V7_V8_V9_V10_V11, + }; + + // VRN5M1NoV0 Bit set. + static const uint8_t VRN5M1NoV0Bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0xff, 0x0f, + }; + + // VRN5M1_with_sub_vrm1_0_in_VMV0 Register Class... + static const MCPhysReg VRN5M1_with_sub_vrm1_0_in_VMV0[] = { + RISCV_V0_V1_V2_V3_V4, + }; + + // VRN5M1_with_sub_vrm1_0_in_VMV0 Bit set. + static const uint8_t VRN5M1_with_sub_vrm1_0_in_VMV0Bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, + }; + + // VRN6M1 Register Class... + static const MCPhysReg VRN6M1[] = { + RISCV_V8_V9_V10_V11_V12_V13, RISCV_V9_V10_V11_V12_V13_V14, RISCV_V10_V11_V12_V13_V14_V15, RISCV_V11_V12_V13_V14_V15_V16, RISCV_V12_V13_V14_V15_V16_V17, RISCV_V13_V14_V15_V16_V17_V18, RISCV_V14_V15_V16_V17_V18_V19, RISCV_V15_V16_V17_V18_V19_V20, RISCV_V16_V17_V18_V19_V20_V21, RISCV_V17_V18_V19_V20_V21_V22, RISCV_V18_V19_V20_V21_V22_V23, RISCV_V19_V20_V21_V22_V23_V24, RISCV_V20_V21_V22_V23_V24_V25, RISCV_V21_V22_V23_V24_V25_V26, RISCV_V22_V23_V24_V25_V26_V27, RISCV_V23_V24_V25_V26_V27_V28, RISCV_V24_V25_V26_V27_V28_V29, RISCV_V25_V26_V27_V28_V29_V30, RISCV_V26_V27_V28_V29_V30_V31, RISCV_V1_V2_V3_V4_V5_V6, RISCV_V2_V3_V4_V5_V6_V7, RISCV_V3_V4_V5_V6_V7_V8, RISCV_V4_V5_V6_V7_V8_V9, RISCV_V5_V6_V7_V8_V9_V10, RISCV_V6_V7_V8_V9_V10_V11, RISCV_V7_V8_V9_V10_V11_V12, RISCV_V0_V1_V2_V3_V4_V5, + }; + + // VRN6M1 Bit set. + static const uint8_t VRN6M1Bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0xff, 0xff, 0xff, + }; + + // VRN6M1NoV0 Register Class... + static const MCPhysReg VRN6M1NoV0[] = { + RISCV_V8_V9_V10_V11_V12_V13, RISCV_V9_V10_V11_V12_V13_V14, RISCV_V10_V11_V12_V13_V14_V15, RISCV_V11_V12_V13_V14_V15_V16, RISCV_V12_V13_V14_V15_V16_V17, RISCV_V13_V14_V15_V16_V17_V18, RISCV_V14_V15_V16_V17_V18_V19, RISCV_V15_V16_V17_V18_V19_V20, RISCV_V16_V17_V18_V19_V20_V21, RISCV_V17_V18_V19_V20_V21_V22, RISCV_V18_V19_V20_V21_V22_V23, RISCV_V19_V20_V21_V22_V23_V24, RISCV_V20_V21_V22_V23_V24_V25, RISCV_V21_V22_V23_V24_V25_V26, RISCV_V22_V23_V24_V25_V26_V27, RISCV_V23_V24_V25_V26_V27_V28, RISCV_V24_V25_V26_V27_V28_V29, RISCV_V25_V26_V27_V28_V29_V30, RISCV_V26_V27_V28_V29_V30_V31, RISCV_V1_V2_V3_V4_V5_V6, RISCV_V2_V3_V4_V5_V6_V7, RISCV_V3_V4_V5_V6_V7_V8, RISCV_V4_V5_V6_V7_V8_V9, RISCV_V5_V6_V7_V8_V9_V10, RISCV_V6_V7_V8_V9_V10_V11, RISCV_V7_V8_V9_V10_V11_V12, + }; + + // VRN6M1NoV0 Bit set. + static const uint8_t VRN6M1NoV0Bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0xff, 0xff, 0x7f, + }; + + // VRN3M2 Register Class... + static const MCPhysReg VRN3M2[] = { + RISCV_V8M2_V10M2_V12M2, RISCV_V10M2_V12M2_V14M2, RISCV_V12M2_V14M2_V16M2, RISCV_V14M2_V16M2_V18M2, RISCV_V16M2_V18M2_V20M2, RISCV_V18M2_V20M2_V22M2, RISCV_V20M2_V22M2_V24M2, RISCV_V22M2_V24M2_V26M2, RISCV_V24M2_V26M2_V28M2, RISCV_V26M2_V28M2_V30M2, RISCV_V2M2_V4M2_V6M2, RISCV_V4M2_V6M2_V8M2, RISCV_V6M2_V8M2_V10M2, RISCV_V0M2_V2M2_V4M2, + }; + + // VRN3M2 Bit set. + static const uint8_t VRN3M2Bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x7f, + }; + + // VRN3M2NoV0 Register Class... + static const MCPhysReg VRN3M2NoV0[] = { + RISCV_V8M2_V10M2_V12M2, RISCV_V10M2_V12M2_V14M2, RISCV_V12M2_V14M2_V16M2, RISCV_V14M2_V16M2_V18M2, RISCV_V16M2_V18M2_V20M2, RISCV_V18M2_V20M2_V22M2, RISCV_V20M2_V22M2_V24M2, RISCV_V22M2_V24M2_V26M2, RISCV_V24M2_V26M2_V28M2, RISCV_V26M2_V28M2_V30M2, RISCV_V2M2_V4M2_V6M2, RISCV_V4M2_V6M2_V8M2, RISCV_V6M2_V8M2_V10M2, + }; + + // VRN3M2NoV0 Bit set. + static const uint8_t VRN3M2NoV0Bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x3f, + }; + + // VRN3M2_with_sub_vrm1_0_in_VMV0 Register Class... + static const MCPhysReg VRN3M2_with_sub_vrm1_0_in_VMV0[] = { + RISCV_V0M2_V2M2_V4M2, + }; + + // VRN3M2_with_sub_vrm1_0_in_VMV0 Bit set. + static const uint8_t VRN3M2_with_sub_vrm1_0_in_VMV0Bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, + }; + + // VRN6M1_with_sub_vrm1_0_in_VMV0 Register Class... + static const MCPhysReg VRN6M1_with_sub_vrm1_0_in_VMV0[] = { + RISCV_V0_V1_V2_V3_V4_V5, + }; + + // VRN6M1_with_sub_vrm1_0_in_VMV0 Bit set. + static const uint8_t VRN6M1_with_sub_vrm1_0_in_VMV0Bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, + }; + + // VRN7M1 Register Class... + static const MCPhysReg VRN7M1[] = { + RISCV_V8_V9_V10_V11_V12_V13_V14, RISCV_V9_V10_V11_V12_V13_V14_V15, RISCV_V10_V11_V12_V13_V14_V15_V16, RISCV_V11_V12_V13_V14_V15_V16_V17, RISCV_V12_V13_V14_V15_V16_V17_V18, RISCV_V13_V14_V15_V16_V17_V18_V19, RISCV_V14_V15_V16_V17_V18_V19_V20, RISCV_V15_V16_V17_V18_V19_V20_V21, RISCV_V16_V17_V18_V19_V20_V21_V22, RISCV_V17_V18_V19_V20_V21_V22_V23, RISCV_V18_V19_V20_V21_V22_V23_V24, RISCV_V19_V20_V21_V22_V23_V24_V25, RISCV_V20_V21_V22_V23_V24_V25_V26, RISCV_V21_V22_V23_V24_V25_V26_V27, RISCV_V22_V23_V24_V25_V26_V27_V28, RISCV_V23_V24_V25_V26_V27_V28_V29, RISCV_V24_V25_V26_V27_V28_V29_V30, RISCV_V25_V26_V27_V28_V29_V30_V31, RISCV_V1_V2_V3_V4_V5_V6_V7, RISCV_V2_V3_V4_V5_V6_V7_V8, RISCV_V3_V4_V5_V6_V7_V8_V9, RISCV_V4_V5_V6_V7_V8_V9_V10, RISCV_V5_V6_V7_V8_V9_V10_V11, RISCV_V6_V7_V8_V9_V10_V11_V12, RISCV_V7_V8_V9_V10_V11_V12_V13, RISCV_V0_V1_V2_V3_V4_V5_V6, + }; + + // VRN7M1 Bit set. + static const uint8_t VRN7M1Bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x03, + }; + + // VRN7M1NoV0 Register Class... + static const MCPhysReg VRN7M1NoV0[] = { + RISCV_V8_V9_V10_V11_V12_V13_V14, RISCV_V9_V10_V11_V12_V13_V14_V15, RISCV_V10_V11_V12_V13_V14_V15_V16, RISCV_V11_V12_V13_V14_V15_V16_V17, RISCV_V12_V13_V14_V15_V16_V17_V18, RISCV_V13_V14_V15_V16_V17_V18_V19, RISCV_V14_V15_V16_V17_V18_V19_V20, RISCV_V15_V16_V17_V18_V19_V20_V21, RISCV_V16_V17_V18_V19_V20_V21_V22, RISCV_V17_V18_V19_V20_V21_V22_V23, RISCV_V18_V19_V20_V21_V22_V23_V24, RISCV_V19_V20_V21_V22_V23_V24_V25, RISCV_V20_V21_V22_V23_V24_V25_V26, RISCV_V21_V22_V23_V24_V25_V26_V27, RISCV_V22_V23_V24_V25_V26_V27_V28, RISCV_V23_V24_V25_V26_V27_V28_V29, RISCV_V24_V25_V26_V27_V28_V29_V30, RISCV_V25_V26_V27_V28_V29_V30_V31, RISCV_V1_V2_V3_V4_V5_V6_V7, RISCV_V2_V3_V4_V5_V6_V7_V8, RISCV_V3_V4_V5_V6_V7_V8_V9, RISCV_V4_V5_V6_V7_V8_V9_V10, RISCV_V5_V6_V7_V8_V9_V10_V11, RISCV_V6_V7_V8_V9_V10_V11_V12, RISCV_V7_V8_V9_V10_V11_V12_V13, + }; + + // VRN7M1NoV0 Bit set. + static const uint8_t VRN7M1NoV0Bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x01, + }; + + // VRN7M1_with_sub_vrm1_0_in_VMV0 Register Class... + static const MCPhysReg VRN7M1_with_sub_vrm1_0_in_VMV0[] = { + RISCV_V0_V1_V2_V3_V4_V5_V6, + }; + + // VRN7M1_with_sub_vrm1_0_in_VMV0 Bit set. + static const uint8_t VRN7M1_with_sub_vrm1_0_in_VMV0Bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, + }; + + // VRN8M1 Register Class... + static const MCPhysReg VRN8M1[] = { + RISCV_V8_V9_V10_V11_V12_V13_V14_V15, RISCV_V9_V10_V11_V12_V13_V14_V15_V16, RISCV_V10_V11_V12_V13_V14_V15_V16_V17, RISCV_V11_V12_V13_V14_V15_V16_V17_V18, RISCV_V12_V13_V14_V15_V16_V17_V18_V19, RISCV_V13_V14_V15_V16_V17_V18_V19_V20, RISCV_V14_V15_V16_V17_V18_V19_V20_V21, RISCV_V15_V16_V17_V18_V19_V20_V21_V22, RISCV_V16_V17_V18_V19_V20_V21_V22_V23, RISCV_V17_V18_V19_V20_V21_V22_V23_V24, RISCV_V18_V19_V20_V21_V22_V23_V24_V25, RISCV_V19_V20_V21_V22_V23_V24_V25_V26, RISCV_V20_V21_V22_V23_V24_V25_V26_V27, RISCV_V21_V22_V23_V24_V25_V26_V27_V28, RISCV_V22_V23_V24_V25_V26_V27_V28_V29, RISCV_V23_V24_V25_V26_V27_V28_V29_V30, RISCV_V24_V25_V26_V27_V28_V29_V30_V31, RISCV_V1_V2_V3_V4_V5_V6_V7_V8, RISCV_V2_V3_V4_V5_V6_V7_V8_V9, RISCV_V3_V4_V5_V6_V7_V8_V9_V10, RISCV_V4_V5_V6_V7_V8_V9_V10_V11, RISCV_V5_V6_V7_V8_V9_V10_V11_V12, RISCV_V6_V7_V8_V9_V10_V11_V12_V13, RISCV_V7_V8_V9_V10_V11_V12_V13_V14, RISCV_V0_V1_V2_V3_V4_V5_V6_V7, + }; + + // VRN8M1 Bit set. + static const uint8_t VRN8M1Bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xff, 0xff, 0x07, + }; + + // VRN8M1NoV0 Register Class... + static const MCPhysReg VRN8M1NoV0[] = { + RISCV_V8_V9_V10_V11_V12_V13_V14_V15, RISCV_V9_V10_V11_V12_V13_V14_V15_V16, RISCV_V10_V11_V12_V13_V14_V15_V16_V17, RISCV_V11_V12_V13_V14_V15_V16_V17_V18, RISCV_V12_V13_V14_V15_V16_V17_V18_V19, RISCV_V13_V14_V15_V16_V17_V18_V19_V20, RISCV_V14_V15_V16_V17_V18_V19_V20_V21, RISCV_V15_V16_V17_V18_V19_V20_V21_V22, RISCV_V16_V17_V18_V19_V20_V21_V22_V23, RISCV_V17_V18_V19_V20_V21_V22_V23_V24, RISCV_V18_V19_V20_V21_V22_V23_V24_V25, RISCV_V19_V20_V21_V22_V23_V24_V25_V26, RISCV_V20_V21_V22_V23_V24_V25_V26_V27, RISCV_V21_V22_V23_V24_V25_V26_V27_V28, RISCV_V22_V23_V24_V25_V26_V27_V28_V29, RISCV_V23_V24_V25_V26_V27_V28_V29_V30, RISCV_V24_V25_V26_V27_V28_V29_V30_V31, RISCV_V1_V2_V3_V4_V5_V6_V7_V8, RISCV_V2_V3_V4_V5_V6_V7_V8_V9, RISCV_V3_V4_V5_V6_V7_V8_V9_V10, RISCV_V4_V5_V6_V7_V8_V9_V10_V11, RISCV_V5_V6_V7_V8_V9_V10_V11_V12, RISCV_V6_V7_V8_V9_V10_V11_V12_V13, RISCV_V7_V8_V9_V10_V11_V12_V13_V14, + }; + + // VRN8M1NoV0 Bit set. + static const uint8_t VRN8M1NoV0Bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xff, 0xff, 0x03, + }; + + // VRN4M2 Register Class... + static const MCPhysReg VRN4M2[] = { + RISCV_V8M2_V10M2_V12M2_V14M2, RISCV_V10M2_V12M2_V14M2_V16M2, RISCV_V12M2_V14M2_V16M2_V18M2, RISCV_V14M2_V16M2_V18M2_V20M2, RISCV_V16M2_V18M2_V20M2_V22M2, RISCV_V18M2_V20M2_V22M2_V24M2, RISCV_V20M2_V22M2_V24M2_V26M2, RISCV_V22M2_V24M2_V26M2_V28M2, RISCV_V24M2_V26M2_V28M2_V30M2, RISCV_V2M2_V4M2_V6M2_V8M2, RISCV_V4M2_V6M2_V8M2_V10M2, RISCV_V6M2_V8M2_V10M2_V12M2, RISCV_V0M2_V2M2_V4M2_V6M2, + }; + + // VRN4M2 Bit set. + static const uint8_t VRN4M2Bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xff, 0x01, + }; + + // VRN4M2NoV0 Register Class... + static const MCPhysReg VRN4M2NoV0[] = { + RISCV_V8M2_V10M2_V12M2_V14M2, RISCV_V10M2_V12M2_V14M2_V16M2, RISCV_V12M2_V14M2_V16M2_V18M2, RISCV_V14M2_V16M2_V18M2_V20M2, RISCV_V16M2_V18M2_V20M2_V22M2, RISCV_V18M2_V20M2_V22M2_V24M2, RISCV_V20M2_V22M2_V24M2_V26M2, RISCV_V22M2_V24M2_V26M2_V28M2, RISCV_V24M2_V26M2_V28M2_V30M2, RISCV_V2M2_V4M2_V6M2_V8M2, RISCV_V4M2_V6M2_V8M2_V10M2, RISCV_V6M2_V8M2_V10M2_V12M2, + }; + + // VRN4M2NoV0 Bit set. + static const uint8_t VRN4M2NoV0Bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xff, + }; + + // VRN2M4 Register Class... + static const MCPhysReg VRN2M4[] = { + RISCV_V8M4_V12M4, RISCV_V12M4_V16M4, RISCV_V16M4_V20M4, RISCV_V20M4_V24M4, RISCV_V24M4_V28M4, RISCV_V4M4_V8M4, RISCV_V0M4_V4M4, + }; + + // VRN2M4 Bit set. + static const uint8_t VRN2M4Bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x07, + }; + + // VRN2M4NoV0 Register Class... + static const MCPhysReg VRN2M4NoV0[] = { + RISCV_V8M4_V12M4, RISCV_V12M4_V16M4, RISCV_V16M4_V20M4, RISCV_V20M4_V24M4, RISCV_V24M4_V28M4, RISCV_V4M4_V8M4, + }; + + // VRN2M4NoV0 Bit set. + static const uint8_t VRN2M4NoV0Bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x03, + }; + + // VRM8 Register Class... + static const MCPhysReg VRM8[] = { + RISCV_V8M8, RISCV_V16M8, RISCV_V24M8, RISCV_V0M8, + }; + + // VRM8 Bit set. + static const uint8_t VRM8Bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x10, 0x08, 0x04, + }; + + // VRM8NoV0 Register Class... + static const MCPhysReg VRM8NoV0[] = { + RISCV_V8M8, RISCV_V16M8, RISCV_V24M8, + }; + + // VRM8NoV0 Bit set. + static const uint8_t VRM8NoV0Bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x08, 0x04, + }; + + // VRM8_with_sub_vrm1_0_in_VMV0 Register Class... + static const MCPhysReg VRM8_with_sub_vrm1_0_in_VMV0[] = { + RISCV_V0M8, + }; + + // VRM8_with_sub_vrm1_0_in_VMV0 Bit set. + static const uint8_t VRM8_with_sub_vrm1_0_in_VMV0Bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, + }; + + // VRN2M4_with_sub_vrm1_0_in_VMV0 Register Class... + static const MCPhysReg VRN2M4_with_sub_vrm1_0_in_VMV0[] = { + RISCV_V0M4_V4M4, + }; + + // VRN2M4_with_sub_vrm1_0_in_VMV0 Bit set. + static const uint8_t VRN2M4_with_sub_vrm1_0_in_VMV0Bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, + }; + + // VRN4M2_with_sub_vrm1_0_in_VMV0 Register Class... + static const MCPhysReg VRN4M2_with_sub_vrm1_0_in_VMV0[] = { + RISCV_V0M2_V2M2_V4M2_V6M2, + }; + + // VRN4M2_with_sub_vrm1_0_in_VMV0 Bit set. + static const uint8_t VRN4M2_with_sub_vrm1_0_in_VMV0Bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, + }; + + // VRN8M1_with_sub_vrm1_0_in_VMV0 Register Class... + static const MCPhysReg VRN8M1_with_sub_vrm1_0_in_VMV0[] = { + RISCV_V0_V1_V2_V3_V4_V5_V6_V7, + }; + + // VRN8M1_with_sub_vrm1_0_in_VMV0 Bit set. + static const uint8_t VRN8M1_with_sub_vrm1_0_in_VMV0Bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, }; static const MCRegisterClass RISCVMCRegisterClasses[] = { + { FPR16, FPR16Bits, sizeof(FPR16Bits) }, + { GPRAll, GPRAllBits, sizeof(GPRAllBits) }, { FPR32, FPR32Bits, sizeof(FPR32Bits) }, { GPR, GPRBits, sizeof(GPRBits) }, + { GPRF16, GPRF16Bits, sizeof(GPRF16Bits) }, + { GPRF32, GPRF32Bits, sizeof(GPRF32Bits) }, { GPRNoX0, GPRNoX0Bits, sizeof(GPRNoX0Bits) }, { GPRNoX0X2, GPRNoX0X2Bits, sizeof(GPRNoX0X2Bits) }, + { GPRJALR, GPRJALRBits, sizeof(GPRJALRBits) }, { GPRTC, GPRTCBits, sizeof(GPRTCBits) }, { FPR32C, FPR32CBits, sizeof(FPR32CBits) }, { GPRC, GPRCBits, sizeof(GPRCBits) }, + { SR07, SR07Bits, sizeof(SR07Bits) }, { GPRC_and_GPRTC, GPRC_and_GPRTCBits, sizeof(GPRC_and_GPRTCBits) }, + { VCSR, VCSRBits, sizeof(VCSRBits) }, + { GPRC_and_SR07, GPRC_and_SR07Bits, sizeof(GPRC_and_SR07Bits) }, + { GPRX1X5, GPRX1X5Bits, sizeof(GPRX1X5Bits) }, + { GPRX0, GPRX0Bits, sizeof(GPRX0Bits) }, + { GPRX1, GPRX1Bits, sizeof(GPRX1Bits) }, + { GPRX5, GPRX5Bits, sizeof(GPRX5Bits) }, { SP, SPBits, sizeof(SPBits) }, { FPR64, FPR64Bits, sizeof(FPR64Bits) }, + { VM, VMBits, sizeof(VMBits) }, + { VR, VRBits, sizeof(VRBits) }, + { VRNoV0, VRNoV0Bits, sizeof(VRNoV0Bits) }, + { GPRPair, GPRPairBits, sizeof(GPRPairBits) }, + { GPRPair_with_sub_gpr_even_in_GPRNoX0, GPRPair_with_sub_gpr_even_in_GPRNoX0Bits, sizeof(GPRPair_with_sub_gpr_even_in_GPRNoX0Bits) }, + { GPRPair_with_sub_gpr_even_in_GPRNoX0X2, GPRPair_with_sub_gpr_even_in_GPRNoX0X2Bits, sizeof(GPRPair_with_sub_gpr_even_in_GPRNoX0X2Bits) }, + { GPRPair_with_sub_gpr_even_in_GPRJALR, GPRPair_with_sub_gpr_even_in_GPRJALRBits, sizeof(GPRPair_with_sub_gpr_even_in_GPRJALRBits) }, { FPR64C, FPR64CBits, sizeof(FPR64CBits) }, + { GPRPair_with_sub_gpr_even_in_GPRTC, GPRPair_with_sub_gpr_even_in_GPRTCBits, sizeof(GPRPair_with_sub_gpr_even_in_GPRTCBits) }, + { GPRPair_with_sub_gpr_even_in_GPRC, GPRPair_with_sub_gpr_even_in_GPRCBits, sizeof(GPRPair_with_sub_gpr_even_in_GPRCBits) }, + { GPRPair_with_sub_gpr_even_in_SR07, GPRPair_with_sub_gpr_even_in_SR07Bits, sizeof(GPRPair_with_sub_gpr_even_in_SR07Bits) }, + { GPRPair_with_sub_gpr_even_in_GPRC_and_GPRTC, GPRPair_with_sub_gpr_even_in_GPRC_and_GPRTCBits, sizeof(GPRPair_with_sub_gpr_even_in_GPRC_and_GPRTCBits) }, + { GPRPair_with_sub_gpr_even_in_GPRC_and_SR07, GPRPair_with_sub_gpr_even_in_GPRC_and_SR07Bits, sizeof(GPRPair_with_sub_gpr_even_in_GPRC_and_SR07Bits) }, + { GPRPair_with_sub_gpr_even_in_GPRX0, GPRPair_with_sub_gpr_even_in_GPRX0Bits, sizeof(GPRPair_with_sub_gpr_even_in_GPRX0Bits) }, + { GPRPair_with_sub_gpr_even_in_SP, GPRPair_with_sub_gpr_even_in_SPBits, sizeof(GPRPair_with_sub_gpr_even_in_SPBits) }, + { GPRPair_with_sub_gpr_odd_in_GPRX1X5, GPRPair_with_sub_gpr_odd_in_GPRX1X5Bits, sizeof(GPRPair_with_sub_gpr_odd_in_GPRX1X5Bits) }, + { VMV0, VMV0Bits, sizeof(VMV0Bits) }, + { VRN2M1, VRN2M1Bits, sizeof(VRN2M1Bits) }, + { VRN2M1NoV0, VRN2M1NoV0Bits, sizeof(VRN2M1NoV0Bits) }, + { VRM2, VRM2Bits, sizeof(VRM2Bits) }, + { VRM2NoV0, VRM2NoV0Bits, sizeof(VRM2NoV0Bits) }, + { VRM2_with_sub_vrm1_0_in_VMV0, VRM2_with_sub_vrm1_0_in_VMV0Bits, sizeof(VRM2_with_sub_vrm1_0_in_VMV0Bits) }, + { VRN2M1_with_sub_vrm1_0_in_VMV0, VRN2M1_with_sub_vrm1_0_in_VMV0Bits, sizeof(VRN2M1_with_sub_vrm1_0_in_VMV0Bits) }, + { VRN3M1, VRN3M1Bits, sizeof(VRN3M1Bits) }, + { VRN3M1NoV0, VRN3M1NoV0Bits, sizeof(VRN3M1NoV0Bits) }, + { VRN3M1_with_sub_vrm1_0_in_VMV0, VRN3M1_with_sub_vrm1_0_in_VMV0Bits, sizeof(VRN3M1_with_sub_vrm1_0_in_VMV0Bits) }, + { VRN4M1, VRN4M1Bits, sizeof(VRN4M1Bits) }, + { VRN4M1NoV0, VRN4M1NoV0Bits, sizeof(VRN4M1NoV0Bits) }, + { VRN2M2, VRN2M2Bits, sizeof(VRN2M2Bits) }, + { VRN2M2NoV0, VRN2M2NoV0Bits, sizeof(VRN2M2NoV0Bits) }, + { VRM4, VRM4Bits, sizeof(VRM4Bits) }, + { VRM4NoV0, VRM4NoV0Bits, sizeof(VRM4NoV0Bits) }, + { VRM4_with_sub_vrm1_0_in_VMV0, VRM4_with_sub_vrm1_0_in_VMV0Bits, sizeof(VRM4_with_sub_vrm1_0_in_VMV0Bits) }, + { VRN2M2_with_sub_vrm1_0_in_VMV0, VRN2M2_with_sub_vrm1_0_in_VMV0Bits, sizeof(VRN2M2_with_sub_vrm1_0_in_VMV0Bits) }, + { VRN4M1_with_sub_vrm1_0_in_VMV0, VRN4M1_with_sub_vrm1_0_in_VMV0Bits, sizeof(VRN4M1_with_sub_vrm1_0_in_VMV0Bits) }, + { VRN5M1, VRN5M1Bits, sizeof(VRN5M1Bits) }, + { VRN5M1NoV0, VRN5M1NoV0Bits, sizeof(VRN5M1NoV0Bits) }, + { VRN5M1_with_sub_vrm1_0_in_VMV0, VRN5M1_with_sub_vrm1_0_in_VMV0Bits, sizeof(VRN5M1_with_sub_vrm1_0_in_VMV0Bits) }, + { VRN6M1, VRN6M1Bits, sizeof(VRN6M1Bits) }, + { VRN6M1NoV0, VRN6M1NoV0Bits, sizeof(VRN6M1NoV0Bits) }, + { VRN3M2, VRN3M2Bits, sizeof(VRN3M2Bits) }, + { VRN3M2NoV0, VRN3M2NoV0Bits, sizeof(VRN3M2NoV0Bits) }, + { VRN3M2_with_sub_vrm1_0_in_VMV0, VRN3M2_with_sub_vrm1_0_in_VMV0Bits, sizeof(VRN3M2_with_sub_vrm1_0_in_VMV0Bits) }, + { VRN6M1_with_sub_vrm1_0_in_VMV0, VRN6M1_with_sub_vrm1_0_in_VMV0Bits, sizeof(VRN6M1_with_sub_vrm1_0_in_VMV0Bits) }, + { VRN7M1, VRN7M1Bits, sizeof(VRN7M1Bits) }, + { VRN7M1NoV0, VRN7M1NoV0Bits, sizeof(VRN7M1NoV0Bits) }, + { VRN7M1_with_sub_vrm1_0_in_VMV0, VRN7M1_with_sub_vrm1_0_in_VMV0Bits, sizeof(VRN7M1_with_sub_vrm1_0_in_VMV0Bits) }, + { VRN8M1, VRN8M1Bits, sizeof(VRN8M1Bits) }, + { VRN8M1NoV0, VRN8M1NoV0Bits, sizeof(VRN8M1NoV0Bits) }, + { VRN4M2, VRN4M2Bits, sizeof(VRN4M2Bits) }, + { VRN4M2NoV0, VRN4M2NoV0Bits, sizeof(VRN4M2NoV0Bits) }, + { VRN2M4, VRN2M4Bits, sizeof(VRN2M4Bits) }, + { VRN2M4NoV0, VRN2M4NoV0Bits, sizeof(VRN2M4NoV0Bits) }, + { VRM8, VRM8Bits, sizeof(VRM8Bits) }, + { VRM8NoV0, VRM8NoV0Bits, sizeof(VRM8NoV0Bits) }, + { VRM8_with_sub_vrm1_0_in_VMV0, VRM8_with_sub_vrm1_0_in_VMV0Bits, sizeof(VRM8_with_sub_vrm1_0_in_VMV0Bits) }, + { VRN2M4_with_sub_vrm1_0_in_VMV0, VRN2M4_with_sub_vrm1_0_in_VMV0Bits, sizeof(VRN2M4_with_sub_vrm1_0_in_VMV0Bits) }, + { VRN4M2_with_sub_vrm1_0_in_VMV0, VRN4M2_with_sub_vrm1_0_in_VMV0Bits, sizeof(VRN4M2_with_sub_vrm1_0_in_VMV0Bits) }, + { VRN8M1_with_sub_vrm1_0_in_VMV0, VRN8M1_with_sub_vrm1_0_in_VMV0Bits, sizeof(VRN8M1_with_sub_vrm1_0_in_VMV0Bits) }, }; -#endif // GET_REGINFO_MC_DESC \ No newline at end of file +static const uint16_t RISCVRegEncodingTable[] = { + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 0, + 0, + 0, + 0, + 2, + 4, + 4, + 6, + 8, + 8, + 8, + 10, + 12, + 12, + 14, + 16, + 16, + 16, + 18, + 20, + 20, + 22, + 24, + 24, + 24, + 26, + 28, + 28, + 30, + 2, + 4, + 6, + 8, + 10, + 12, + 14, + 16, + 18, + 20, + 22, + 24, + 26, + 28, + 30, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 0, + 2, + 4, + 6, + 8, + 10, + 12, + 14, + 16, + 18, + 20, + 22, + 24, + 26, + 28, + 0, + 4, + 8, + 12, + 16, + 20, + 24, + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 0, + 2, + 4, + 6, + 8, + 10, + 12, + 14, + 16, + 18, + 20, + 22, + 24, + 26, + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 0, + 2, + 4, + 6, + 8, + 10, + 12, + 14, + 16, + 18, + 20, + 22, + 24, + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 0, +}; +#endif // GET_REGINFO_MC_DESC + + + diff --git a/arch/RISCV/RISCVGenSubtargetInfo.inc b/arch/RISCV/RISCVGenSubtargetInfo.inc index c857ce6c1c..37492b3a9c 100644 --- a/arch/RISCV/RISCVGenSubtargetInfo.inc +++ b/arch/RISCV/RISCVGenSubtargetInfo.inc @@ -1,33 +1,211 @@ -/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\ -|* *| -|* Subtarget Enumeration Source Fragment *| -|* *| -|* Automatically generated file, do not edit! *| -|* *| -\*===----------------------------------------------------------------------===*/ +/* Capstone Disassembly Engine, https://www.capstone-engine.org */ +/* By Nguyen Anh Quynh , 2013-2022, */ +/* Rot127 2022-2024 */ +/* Automatically generated file by Capstone's LLVM TableGen Disassembler Backend. */ -/* Capstone Disassembly Engine, http://www.capstone-engine.org */ -/* By Nguyen Anh Quynh , 2013-2015 */ +/* LLVM-commit: */ +/* LLVM-tag: */ +/* Do not edit. */ + +/* Capstone's LLVM TableGen Backends: */ +/* https://github.com/capstone-engine/llvm-capstone */ #ifdef GET_SUBTARGETINFO_ENUM #undef GET_SUBTARGETINFO_ENUM -/* - Make sure: - CS_MODE_RISCV64 = 0b11111 - CS_MODE_RISCV32 = 0b11110 -*/ - enum { - RISCV_Feature64Bit = 1ULL << 0, - RISCV_FeatureStdExtA = 1ULL << 1, - RISCV_FeatureStdExtC = 1ULL << 2, - RISCV_FeatureStdExtD = 1ULL << 3, - RISCV_FeatureStdExtF = 1ULL << 4, - RISCV_FeatureStdExtM = 1ULL << 5, - RISCV_FeatureRelax = 1ULL << 6, + RISCV_Experimental = 0, + RISCV_Feature32Bit = 1, + RISCV_Feature64Bit = 2, + RISCV_FeatureFastUnalignedAccess = 3, + RISCV_FeatureForcedAtomics = 4, + RISCV_FeatureNoRVCHints = 5, + RISCV_FeaturePostRAScheduler = 6, + RISCV_FeatureRVE = 7, + RISCV_FeatureRelax = 8, + RISCV_FeatureReserveX1 = 9, + RISCV_FeatureReserveX2 = 10, + RISCV_FeatureReserveX3 = 11, + RISCV_FeatureReserveX4 = 12, + RISCV_FeatureReserveX5 = 13, + RISCV_FeatureReserveX6 = 14, + RISCV_FeatureReserveX7 = 15, + RISCV_FeatureReserveX8 = 16, + RISCV_FeatureReserveX9 = 17, + RISCV_FeatureReserveX10 = 18, + RISCV_FeatureReserveX11 = 19, + RISCV_FeatureReserveX12 = 20, + RISCV_FeatureReserveX13 = 21, + RISCV_FeatureReserveX14 = 22, + RISCV_FeatureReserveX15 = 23, + RISCV_FeatureReserveX16 = 24, + RISCV_FeatureReserveX17 = 25, + RISCV_FeatureReserveX18 = 26, + RISCV_FeatureReserveX19 = 27, + RISCV_FeatureReserveX20 = 28, + RISCV_FeatureReserveX21 = 29, + RISCV_FeatureReserveX22 = 30, + RISCV_FeatureReserveX23 = 31, + RISCV_FeatureReserveX24 = 32, + RISCV_FeatureReserveX25 = 33, + RISCV_FeatureReserveX26 = 34, + RISCV_FeatureReserveX27 = 35, + RISCV_FeatureReserveX28 = 36, + RISCV_FeatureReserveX29 = 37, + RISCV_FeatureReserveX30 = 38, + RISCV_FeatureReserveX31 = 39, + RISCV_FeatureSaveRestore = 40, + RISCV_FeatureStdExtA = 41, + RISCV_FeatureStdExtC = 42, + RISCV_FeatureStdExtD = 43, + RISCV_FeatureStdExtF = 44, + RISCV_FeatureStdExtH = 45, + RISCV_FeatureStdExtI = 46, + RISCV_FeatureStdExtM = 47, + RISCV_FeatureStdExtSmaia = 48, + RISCV_FeatureStdExtSmepmp = 49, + RISCV_FeatureStdExtSsaia = 50, + RISCV_FeatureStdExtSvinval = 51, + RISCV_FeatureStdExtSvnapot = 52, + RISCV_FeatureStdExtSvpbmt = 53, + RISCV_FeatureStdExtV = 54, + RISCV_FeatureStdExtZa64rs = 55, + RISCV_FeatureStdExtZa128rs = 56, + RISCV_FeatureStdExtZacas = 57, + RISCV_FeatureStdExtZawrs = 58, + RISCV_FeatureStdExtZba = 59, + RISCV_FeatureStdExtZbb = 60, + RISCV_FeatureStdExtZbc = 61, + RISCV_FeatureStdExtZbkb = 62, + RISCV_FeatureStdExtZbkc = 63, + RISCV_FeatureStdExtZbkx = 64, + RISCV_FeatureStdExtZbs = 65, + RISCV_FeatureStdExtZca = 66, + RISCV_FeatureStdExtZcb = 67, + RISCV_FeatureStdExtZcd = 68, + RISCV_FeatureStdExtZce = 69, + RISCV_FeatureStdExtZcf = 70, + RISCV_FeatureStdExtZcmop = 71, + RISCV_FeatureStdExtZcmp = 72, + RISCV_FeatureStdExtZcmt = 73, + RISCV_FeatureStdExtZdinx = 74, + RISCV_FeatureStdExtZfa = 75, + RISCV_FeatureStdExtZfbfmin = 76, + RISCV_FeatureStdExtZfh = 77, + RISCV_FeatureStdExtZfhmin = 78, + RISCV_FeatureStdExtZfinx = 79, + RISCV_FeatureStdExtZhinx = 80, + RISCV_FeatureStdExtZhinxmin = 81, + RISCV_FeatureStdExtZic64b = 82, + RISCV_FeatureStdExtZicbom = 83, + RISCV_FeatureStdExtZicbop = 84, + RISCV_FeatureStdExtZicboz = 85, + RISCV_FeatureStdExtZiccamoa = 86, + RISCV_FeatureStdExtZiccif = 87, + RISCV_FeatureStdExtZicclsm = 88, + RISCV_FeatureStdExtZiccrse = 89, + RISCV_FeatureStdExtZicfilp = 90, + RISCV_FeatureStdExtZicfiss = 91, + RISCV_FeatureStdExtZicntr = 92, + RISCV_FeatureStdExtZicond = 93, + RISCV_FeatureStdExtZicsr = 94, + RISCV_FeatureStdExtZifencei = 95, + RISCV_FeatureStdExtZihintntl = 96, + RISCV_FeatureStdExtZihintpause = 97, + RISCV_FeatureStdExtZihpm = 98, + RISCV_FeatureStdExtZimop = 99, + RISCV_FeatureStdExtZk = 100, + RISCV_FeatureStdExtZkn = 101, + RISCV_FeatureStdExtZknd = 102, + RISCV_FeatureStdExtZkne = 103, + RISCV_FeatureStdExtZknh = 104, + RISCV_FeatureStdExtZkr = 105, + RISCV_FeatureStdExtZks = 106, + RISCV_FeatureStdExtZksed = 107, + RISCV_FeatureStdExtZksh = 108, + RISCV_FeatureStdExtZkt = 109, + RISCV_FeatureStdExtZmmul = 110, + RISCV_FeatureStdExtZtso = 111, + RISCV_FeatureStdExtZvbb = 112, + RISCV_FeatureStdExtZvbc = 113, + RISCV_FeatureStdExtZve32f = 114, + RISCV_FeatureStdExtZve32x = 115, + RISCV_FeatureStdExtZve64d = 116, + RISCV_FeatureStdExtZve64f = 117, + RISCV_FeatureStdExtZve64x = 118, + RISCV_FeatureStdExtZvfbfmin = 119, + RISCV_FeatureStdExtZvfbfwma = 120, + RISCV_FeatureStdExtZvfh = 121, + RISCV_FeatureStdExtZvfhmin = 122, + RISCV_FeatureStdExtZvkb = 123, + RISCV_FeatureStdExtZvkg = 124, + RISCV_FeatureStdExtZvkn = 125, + RISCV_FeatureStdExtZvknc = 126, + RISCV_FeatureStdExtZvkned = 127, + RISCV_FeatureStdExtZvkng = 128, + RISCV_FeatureStdExtZvknha = 129, + RISCV_FeatureStdExtZvknhb = 130, + RISCV_FeatureStdExtZvks = 131, + RISCV_FeatureStdExtZvksc = 132, + RISCV_FeatureStdExtZvksed = 133, + RISCV_FeatureStdExtZvksg = 134, + RISCV_FeatureStdExtZvksh = 135, + RISCV_FeatureStdExtZvkt = 136, + RISCV_FeatureStdExtZvl32b = 137, + RISCV_FeatureStdExtZvl64b = 138, + RISCV_FeatureStdExtZvl128b = 139, + RISCV_FeatureStdExtZvl256b = 140, + RISCV_FeatureStdExtZvl512b = 141, + RISCV_FeatureStdExtZvl1024b = 142, + RISCV_FeatureStdExtZvl2048b = 143, + RISCV_FeatureStdExtZvl4096b = 144, + RISCV_FeatureStdExtZvl8192b = 145, + RISCV_FeatureStdExtZvl16384b = 146, + RISCV_FeatureStdExtZvl32768b = 147, + RISCV_FeatureStdExtZvl65536b = 148, + RISCV_FeatureTaggedGlobals = 149, + RISCV_FeatureTrailingSeqCstFence = 150, + RISCV_FeatureVendorXCValu = 151, + RISCV_FeatureVendorXCVbi = 152, + RISCV_FeatureVendorXCVbitmanip = 153, + RISCV_FeatureVendorXCVelw = 154, + RISCV_FeatureVendorXCVmac = 155, + RISCV_FeatureVendorXCVmem = 156, + RISCV_FeatureVendorXCVsimd = 157, + RISCV_FeatureVendorXSfvcp = 158, + RISCV_FeatureVendorXSfvfnrclipxfqf = 159, + RISCV_FeatureVendorXSfvfwmaccqqq = 160, + RISCV_FeatureVendorXSfvqmaccdod = 161, + RISCV_FeatureVendorXSfvqmaccqoq = 162, + RISCV_FeatureVendorXTHeadBa = 163, + RISCV_FeatureVendorXTHeadBb = 164, + RISCV_FeatureVendorXTHeadBs = 165, + RISCV_FeatureVendorXTHeadCmo = 166, + RISCV_FeatureVendorXTHeadCondMov = 167, + RISCV_FeatureVendorXTHeadFMemIdx = 168, + RISCV_FeatureVendorXTHeadMac = 169, + RISCV_FeatureVendorXTHeadMemIdx = 170, + RISCV_FeatureVendorXTHeadMemPair = 171, + RISCV_FeatureVendorXTHeadSync = 172, + RISCV_FeatureVendorXTHeadVdot = 173, + RISCV_FeatureVendorXVentanaCondOps = 174, + RISCV_TuneAUIPCADDIFusion = 175, + RISCV_TuneConditionalCompressedMoveFusion = 176, + RISCV_TuneDLenFactor2 = 177, + RISCV_TuneLDADDFusion = 178, + RISCV_TuneLUIADDIFusion = 179, + RISCV_TuneNoDefaultUnroll = 180, + RISCV_TuneNoOptimizedZeroStrideLoad = 181, + RISCV_TuneShiftedZExtWFusion = 182, + RISCV_TuneShortForwardBranchOpt = 183, + RISCV_TuneSiFive7 = 184, + RISCV_TuneVentanaVeyron = 185, + RISCV_TuneZExtHFusion = 186, + RISCV_TuneZExtWFusion = 187, + RISCV_NumSubtargetFeatures = 188 }; - #endif // GET_SUBTARGETINFO_ENUM + + diff --git a/arch/RISCV/RISCVGenSystemOperands.inc b/arch/RISCV/RISCVGenSystemOperands.inc new file mode 100644 index 0000000000..e083807b7e --- /dev/null +++ b/arch/RISCV/RISCVGenSystemOperands.inc @@ -0,0 +1,34192 @@ +/* Capstone Disassembly Engine, https://www.capstone-engine.org */ +/* By Nguyen Anh Quynh , 2013-2022, */ +/* Rot127 2022-2024 */ +/* Automatically generated file by Capstone's LLVM TableGen Disassembler Backend. */ + +/* LLVM-commit: */ +/* LLVM-tag: */ + +/* Do not edit. */ + +/* Capstone's LLVM TableGen Backends: */ +/* https://github.com/capstone-engine/llvm-capstone */ + +#ifdef GET_RISCVMaskedPseudosTable_DECL +const RISCV_RISCVMaskedPseudoInfo *RISCV_getMaskedPseudoInfo(unsigned MaskedPseudo); +const RISCV_RISCVMaskedPseudoInfo *RISCV_lookupMaskedIntrinsicByUnmasked(unsigned UnmaskedPseudo); +#endif + +#ifdef GET_RISCVOpcodesList_DECL +const RISCV_RISCVOpcode *RISCV_lookupRISCVOpcodeByValue(uint8_t Value); +const RISCV_RISCVOpcode *RISCV_lookupRISCVOpcodeByName(const char * Name); +#endif + +#ifdef GET_RISCVTuneInfoTable_DECL +const RISCV_RISCVTuneInfo *RISCV_getRISCVTuneInfo(const char * Name); +#endif + +#ifdef GET_RISCVVInversePseudosTable_DECL +const RISCV_PseudoInfo *RISCV_getBaseInfo(unsigned BaseInstr, uint8_t VLMul, uint8_t SEW); +#endif + +#ifdef GET_RISCVVLETable_DECL +const RISCV_VLEPseudo *RISCV_getVLEPseudo(uint8_t Masked, uint8_t Strided, uint8_t FF, uint8_t Log2SEW, uint8_t LMUL); +#endif + +#ifdef GET_RISCVVLSEGTable_DECL +const RISCV_VLSEGPseudo *RISCV_getVLSEGPseudo(uint8_t NF, uint8_t Masked, uint8_t Strided, uint8_t FF, uint8_t Log2SEW, uint8_t LMUL); +#endif + +#ifdef GET_RISCVVLXSEGTable_DECL +const RISCV_VLXSEGPseudo *RISCV_getVLXSEGPseudo(uint8_t NF, uint8_t Masked, uint8_t Ordered, uint8_t Log2SEW, uint8_t LMUL, uint8_t IndexLMUL); +#endif + +#ifdef GET_RISCVVLXTable_DECL +const RISCV_VLX_VSXPseudo *RISCV_getVLXPseudo(uint8_t Masked, uint8_t Ordered, uint8_t Log2SEW, uint8_t LMUL, uint8_t IndexLMUL); +#endif + +#ifdef GET_RISCVVPseudosTable_DECL +const RISCV_PseudoInfo *RISCV_getPseudoInfo(unsigned Pseudo); +#endif + +#ifdef GET_RISCVVSETable_DECL +const RISCV_VSEPseudo *RISCV_getVSEPseudo(uint8_t Masked, uint8_t Strided, uint8_t Log2SEW, uint8_t LMUL); +#endif + +#ifdef GET_RISCVVSSEGTable_DECL +const RISCV_VSSEGPseudo *RISCV_getVSSEGPseudo(uint8_t NF, uint8_t Masked, uint8_t Strided, uint8_t Log2SEW, uint8_t LMUL); +#endif + +#ifdef GET_RISCVVSXSEGTable_DECL +const RISCV_VSXSEGPseudo *RISCV_getVSXSEGPseudo(uint8_t NF, uint8_t Masked, uint8_t Ordered, uint8_t Log2SEW, uint8_t LMUL, uint8_t IndexLMUL); +#endif + +#ifdef GET_RISCVVSXTable_DECL +const RISCV_VLX_VSXPseudo *RISCV_getVSXPseudo(uint8_t Masked, uint8_t Ordered, uint8_t Log2SEW, uint8_t LMUL, uint8_t IndexLMUL); +#endif + +#ifdef GET_SysRegsList_DECL +const RISCV_SysReg *RISCV_lookupSysRegByEncoding(uint16_t Encoding); +const RISCV_SysReg *RISCV_lookupSysRegByAltName(const char * AltName); +const RISCV_SysReg *RISCV_lookupSysRegByDeprecatedName(const char * DeprecatedName); +const RISCV_SysReg *RISCV_lookupSysRegByName(const char * Name); +#endif + +#ifdef GET_RISCVMaskedPseudosTable_IMPL +static const RISCV_RISCVMaskedPseudoInfo RISCVMaskedPseudosTable[] = { + { PseudoTHVdotVMAQASU_VV_M1_MASK, PseudoTHVdotVMAQASU_VV_M1, 0x3, false }, // 0 + { PseudoTHVdotVMAQASU_VV_M2_MASK, PseudoTHVdotVMAQASU_VV_M2, 0x3, false }, // 1 + { PseudoTHVdotVMAQASU_VV_M4_MASK, PseudoTHVdotVMAQASU_VV_M4, 0x3, false }, // 2 + { PseudoTHVdotVMAQASU_VV_M8_MASK, PseudoTHVdotVMAQASU_VV_M8, 0x3, false }, // 3 + { PseudoTHVdotVMAQASU_VV_MF2_MASK, PseudoTHVdotVMAQASU_VV_MF2, 0x3, false }, // 4 + { PseudoTHVdotVMAQASU_VX_M1_MASK, PseudoTHVdotVMAQASU_VX_M1, 0x3, false }, // 5 + { PseudoTHVdotVMAQASU_VX_M2_MASK, PseudoTHVdotVMAQASU_VX_M2, 0x3, false }, // 6 + { PseudoTHVdotVMAQASU_VX_M4_MASK, PseudoTHVdotVMAQASU_VX_M4, 0x3, false }, // 7 + { PseudoTHVdotVMAQASU_VX_M8_MASK, PseudoTHVdotVMAQASU_VX_M8, 0x3, false }, // 8 + { PseudoTHVdotVMAQASU_VX_MF2_MASK, PseudoTHVdotVMAQASU_VX_MF2, 0x3, false }, // 9 + { PseudoTHVdotVMAQAUS_VX_M1_MASK, PseudoTHVdotVMAQAUS_VX_M1, 0x3, false }, // 10 + { PseudoTHVdotVMAQAUS_VX_M2_MASK, PseudoTHVdotVMAQAUS_VX_M2, 0x3, false }, // 11 + { PseudoTHVdotVMAQAUS_VX_M4_MASK, PseudoTHVdotVMAQAUS_VX_M4, 0x3, false }, // 12 + { PseudoTHVdotVMAQAUS_VX_M8_MASK, PseudoTHVdotVMAQAUS_VX_M8, 0x3, false }, // 13 + { PseudoTHVdotVMAQAUS_VX_MF2_MASK, PseudoTHVdotVMAQAUS_VX_MF2, 0x3, false }, // 14 + { PseudoTHVdotVMAQAU_VV_M1_MASK, PseudoTHVdotVMAQAU_VV_M1, 0x3, false }, // 15 + { PseudoTHVdotVMAQAU_VV_M2_MASK, PseudoTHVdotVMAQAU_VV_M2, 0x3, false }, // 16 + { PseudoTHVdotVMAQAU_VV_M4_MASK, PseudoTHVdotVMAQAU_VV_M4, 0x3, false }, // 17 + { PseudoTHVdotVMAQAU_VV_M8_MASK, PseudoTHVdotVMAQAU_VV_M8, 0x3, false }, // 18 + { PseudoTHVdotVMAQAU_VV_MF2_MASK, PseudoTHVdotVMAQAU_VV_MF2, 0x3, false }, // 19 + { PseudoTHVdotVMAQAU_VX_M1_MASK, PseudoTHVdotVMAQAU_VX_M1, 0x3, false }, // 20 + { PseudoTHVdotVMAQAU_VX_M2_MASK, PseudoTHVdotVMAQAU_VX_M2, 0x3, false }, // 21 + { PseudoTHVdotVMAQAU_VX_M4_MASK, PseudoTHVdotVMAQAU_VX_M4, 0x3, false }, // 22 + { PseudoTHVdotVMAQAU_VX_M8_MASK, PseudoTHVdotVMAQAU_VX_M8, 0x3, false }, // 23 + { PseudoTHVdotVMAQAU_VX_MF2_MASK, PseudoTHVdotVMAQAU_VX_MF2, 0x3, false }, // 24 + { PseudoTHVdotVMAQA_VV_M1_MASK, PseudoTHVdotVMAQA_VV_M1, 0x3, false }, // 25 + { PseudoTHVdotVMAQA_VV_M2_MASK, PseudoTHVdotVMAQA_VV_M2, 0x3, false }, // 26 + { PseudoTHVdotVMAQA_VV_M4_MASK, PseudoTHVdotVMAQA_VV_M4, 0x3, false }, // 27 + { PseudoTHVdotVMAQA_VV_M8_MASK, PseudoTHVdotVMAQA_VV_M8, 0x3, false }, // 28 + { PseudoTHVdotVMAQA_VV_MF2_MASK, PseudoTHVdotVMAQA_VV_MF2, 0x3, false }, // 29 + { PseudoTHVdotVMAQA_VX_M1_MASK, PseudoTHVdotVMAQA_VX_M1, 0x3, false }, // 30 + { PseudoTHVdotVMAQA_VX_M2_MASK, PseudoTHVdotVMAQA_VX_M2, 0x3, false }, // 31 + { PseudoTHVdotVMAQA_VX_M4_MASK, PseudoTHVdotVMAQA_VX_M4, 0x3, false }, // 32 + { PseudoTHVdotVMAQA_VX_M8_MASK, PseudoTHVdotVMAQA_VX_M8, 0x3, false }, // 33 + { PseudoTHVdotVMAQA_VX_MF2_MASK, PseudoTHVdotVMAQA_VX_MF2, 0x3, false }, // 34 + { PseudoVAADDU_VV_M1_MASK, PseudoVAADDU_VV_M1, 0x3, false }, // 35 + { PseudoVAADDU_VV_M2_MASK, PseudoVAADDU_VV_M2, 0x3, false }, // 36 + { PseudoVAADDU_VV_M4_MASK, PseudoVAADDU_VV_M4, 0x3, false }, // 37 + { PseudoVAADDU_VV_M8_MASK, PseudoVAADDU_VV_M8, 0x3, false }, // 38 + { PseudoVAADDU_VV_MF2_MASK, PseudoVAADDU_VV_MF2, 0x3, false }, // 39 + { PseudoVAADDU_VV_MF4_MASK, PseudoVAADDU_VV_MF4, 0x3, false }, // 40 + { PseudoVAADDU_VV_MF8_MASK, PseudoVAADDU_VV_MF8, 0x3, false }, // 41 + { PseudoVAADDU_VX_M1_MASK, PseudoVAADDU_VX_M1, 0x3, false }, // 42 + { PseudoVAADDU_VX_M2_MASK, PseudoVAADDU_VX_M2, 0x3, false }, // 43 + { PseudoVAADDU_VX_M4_MASK, PseudoVAADDU_VX_M4, 0x3, false }, // 44 + { PseudoVAADDU_VX_M8_MASK, PseudoVAADDU_VX_M8, 0x3, false }, // 45 + { PseudoVAADDU_VX_MF2_MASK, PseudoVAADDU_VX_MF2, 0x3, false }, // 46 + { PseudoVAADDU_VX_MF4_MASK, PseudoVAADDU_VX_MF4, 0x3, false }, // 47 + { PseudoVAADDU_VX_MF8_MASK, PseudoVAADDU_VX_MF8, 0x3, false }, // 48 + { PseudoVAADD_VV_M1_MASK, PseudoVAADD_VV_M1, 0x3, false }, // 49 + { PseudoVAADD_VV_M2_MASK, PseudoVAADD_VV_M2, 0x3, false }, // 50 + { PseudoVAADD_VV_M4_MASK, PseudoVAADD_VV_M4, 0x3, false }, // 51 + { PseudoVAADD_VV_M8_MASK, PseudoVAADD_VV_M8, 0x3, false }, // 52 + { PseudoVAADD_VV_MF2_MASK, PseudoVAADD_VV_MF2, 0x3, false }, // 53 + { PseudoVAADD_VV_MF4_MASK, PseudoVAADD_VV_MF4, 0x3, false }, // 54 + { PseudoVAADD_VV_MF8_MASK, PseudoVAADD_VV_MF8, 0x3, false }, // 55 + { PseudoVAADD_VX_M1_MASK, PseudoVAADD_VX_M1, 0x3, false }, // 56 + { PseudoVAADD_VX_M2_MASK, PseudoVAADD_VX_M2, 0x3, false }, // 57 + { PseudoVAADD_VX_M4_MASK, PseudoVAADD_VX_M4, 0x3, false }, // 58 + { PseudoVAADD_VX_M8_MASK, PseudoVAADD_VX_M8, 0x3, false }, // 59 + { PseudoVAADD_VX_MF2_MASK, PseudoVAADD_VX_MF2, 0x3, false }, // 60 + { PseudoVAADD_VX_MF4_MASK, PseudoVAADD_VX_MF4, 0x3, false }, // 61 + { PseudoVAADD_VX_MF8_MASK, PseudoVAADD_VX_MF8, 0x3, false }, // 62 + { PseudoVADD_VI_M1_MASK, PseudoVADD_VI_M1, 0x3, false }, // 63 + { PseudoVADD_VI_M2_MASK, PseudoVADD_VI_M2, 0x3, false }, // 64 + { PseudoVADD_VI_M4_MASK, PseudoVADD_VI_M4, 0x3, false }, // 65 + { PseudoVADD_VI_M8_MASK, PseudoVADD_VI_M8, 0x3, false }, // 66 + { PseudoVADD_VI_MF2_MASK, PseudoVADD_VI_MF2, 0x3, false }, // 67 + { PseudoVADD_VI_MF4_MASK, PseudoVADD_VI_MF4, 0x3, false }, // 68 + { PseudoVADD_VI_MF8_MASK, PseudoVADD_VI_MF8, 0x3, false }, // 69 + { PseudoVADD_VV_M1_MASK, PseudoVADD_VV_M1, 0x3, false }, // 70 + { PseudoVADD_VV_M2_MASK, PseudoVADD_VV_M2, 0x3, false }, // 71 + { PseudoVADD_VV_M4_MASK, PseudoVADD_VV_M4, 0x3, false }, // 72 + { PseudoVADD_VV_M8_MASK, PseudoVADD_VV_M8, 0x3, false }, // 73 + { PseudoVADD_VV_MF2_MASK, PseudoVADD_VV_MF2, 0x3, false }, // 74 + { PseudoVADD_VV_MF4_MASK, PseudoVADD_VV_MF4, 0x3, false }, // 75 + { PseudoVADD_VV_MF8_MASK, PseudoVADD_VV_MF8, 0x3, false }, // 76 + { PseudoVADD_VX_M1_MASK, PseudoVADD_VX_M1, 0x3, false }, // 77 + { PseudoVADD_VX_M2_MASK, PseudoVADD_VX_M2, 0x3, false }, // 78 + { PseudoVADD_VX_M4_MASK, PseudoVADD_VX_M4, 0x3, false }, // 79 + { PseudoVADD_VX_M8_MASK, PseudoVADD_VX_M8, 0x3, false }, // 80 + { PseudoVADD_VX_MF2_MASK, PseudoVADD_VX_MF2, 0x3, false }, // 81 + { PseudoVADD_VX_MF4_MASK, PseudoVADD_VX_MF4, 0x3, false }, // 82 + { PseudoVADD_VX_MF8_MASK, PseudoVADD_VX_MF8, 0x3, false }, // 83 + { PseudoVANDN_VV_M1_MASK, PseudoVANDN_VV_M1, 0x3, false }, // 84 + { PseudoVANDN_VV_M2_MASK, PseudoVANDN_VV_M2, 0x3, false }, // 85 + { PseudoVANDN_VV_M4_MASK, PseudoVANDN_VV_M4, 0x3, false }, // 86 + { PseudoVANDN_VV_M8_MASK, PseudoVANDN_VV_M8, 0x3, false }, // 87 + { PseudoVANDN_VV_MF2_MASK, PseudoVANDN_VV_MF2, 0x3, false }, // 88 + { PseudoVANDN_VV_MF4_MASK, PseudoVANDN_VV_MF4, 0x3, false }, // 89 + { PseudoVANDN_VV_MF8_MASK, PseudoVANDN_VV_MF8, 0x3, false }, // 90 + { PseudoVANDN_VX_M1_MASK, PseudoVANDN_VX_M1, 0x3, false }, // 91 + { PseudoVANDN_VX_M2_MASK, PseudoVANDN_VX_M2, 0x3, false }, // 92 + { PseudoVANDN_VX_M4_MASK, PseudoVANDN_VX_M4, 0x3, false }, // 93 + { PseudoVANDN_VX_M8_MASK, PseudoVANDN_VX_M8, 0x3, false }, // 94 + { PseudoVANDN_VX_MF2_MASK, PseudoVANDN_VX_MF2, 0x3, false }, // 95 + { PseudoVANDN_VX_MF4_MASK, PseudoVANDN_VX_MF4, 0x3, false }, // 96 + { PseudoVANDN_VX_MF8_MASK, PseudoVANDN_VX_MF8, 0x3, false }, // 97 + { PseudoVAND_VI_M1_MASK, PseudoVAND_VI_M1, 0x3, false }, // 98 + { PseudoVAND_VI_M2_MASK, PseudoVAND_VI_M2, 0x3, false }, // 99 + { PseudoVAND_VI_M4_MASK, PseudoVAND_VI_M4, 0x3, false }, // 100 + { PseudoVAND_VI_M8_MASK, PseudoVAND_VI_M8, 0x3, false }, // 101 + { PseudoVAND_VI_MF2_MASK, PseudoVAND_VI_MF2, 0x3, false }, // 102 + { PseudoVAND_VI_MF4_MASK, PseudoVAND_VI_MF4, 0x3, false }, // 103 + { PseudoVAND_VI_MF8_MASK, PseudoVAND_VI_MF8, 0x3, false }, // 104 + { PseudoVAND_VV_M1_MASK, PseudoVAND_VV_M1, 0x3, false }, // 105 + { PseudoVAND_VV_M2_MASK, PseudoVAND_VV_M2, 0x3, false }, // 106 + { PseudoVAND_VV_M4_MASK, PseudoVAND_VV_M4, 0x3, false }, // 107 + { PseudoVAND_VV_M8_MASK, PseudoVAND_VV_M8, 0x3, false }, // 108 + { PseudoVAND_VV_MF2_MASK, PseudoVAND_VV_MF2, 0x3, false }, // 109 + { PseudoVAND_VV_MF4_MASK, PseudoVAND_VV_MF4, 0x3, false }, // 110 + { PseudoVAND_VV_MF8_MASK, PseudoVAND_VV_MF8, 0x3, false }, // 111 + { PseudoVAND_VX_M1_MASK, PseudoVAND_VX_M1, 0x3, false }, // 112 + { PseudoVAND_VX_M2_MASK, PseudoVAND_VX_M2, 0x3, false }, // 113 + { PseudoVAND_VX_M4_MASK, PseudoVAND_VX_M4, 0x3, false }, // 114 + { PseudoVAND_VX_M8_MASK, PseudoVAND_VX_M8, 0x3, false }, // 115 + { PseudoVAND_VX_MF2_MASK, PseudoVAND_VX_MF2, 0x3, false }, // 116 + { PseudoVAND_VX_MF4_MASK, PseudoVAND_VX_MF4, 0x3, false }, // 117 + { PseudoVAND_VX_MF8_MASK, PseudoVAND_VX_MF8, 0x3, false }, // 118 + { PseudoVASUBU_VV_M1_MASK, PseudoVASUBU_VV_M1, 0x3, false }, // 119 + { PseudoVASUBU_VV_M2_MASK, PseudoVASUBU_VV_M2, 0x3, false }, // 120 + { PseudoVASUBU_VV_M4_MASK, PseudoVASUBU_VV_M4, 0x3, false }, // 121 + { PseudoVASUBU_VV_M8_MASK, PseudoVASUBU_VV_M8, 0x3, false }, // 122 + { PseudoVASUBU_VV_MF2_MASK, PseudoVASUBU_VV_MF2, 0x3, false }, // 123 + { PseudoVASUBU_VV_MF4_MASK, PseudoVASUBU_VV_MF4, 0x3, false }, // 124 + { PseudoVASUBU_VV_MF8_MASK, PseudoVASUBU_VV_MF8, 0x3, false }, // 125 + { PseudoVASUBU_VX_M1_MASK, PseudoVASUBU_VX_M1, 0x3, false }, // 126 + { PseudoVASUBU_VX_M2_MASK, PseudoVASUBU_VX_M2, 0x3, false }, // 127 + { PseudoVASUBU_VX_M4_MASK, PseudoVASUBU_VX_M4, 0x3, false }, // 128 + { PseudoVASUBU_VX_M8_MASK, PseudoVASUBU_VX_M8, 0x3, false }, // 129 + { PseudoVASUBU_VX_MF2_MASK, PseudoVASUBU_VX_MF2, 0x3, false }, // 130 + { PseudoVASUBU_VX_MF4_MASK, PseudoVASUBU_VX_MF4, 0x3, false }, // 131 + { PseudoVASUBU_VX_MF8_MASK, PseudoVASUBU_VX_MF8, 0x3, false }, // 132 + { PseudoVASUB_VV_M1_MASK, PseudoVASUB_VV_M1, 0x3, false }, // 133 + { PseudoVASUB_VV_M2_MASK, PseudoVASUB_VV_M2, 0x3, false }, // 134 + { PseudoVASUB_VV_M4_MASK, PseudoVASUB_VV_M4, 0x3, false }, // 135 + { PseudoVASUB_VV_M8_MASK, PseudoVASUB_VV_M8, 0x3, false }, // 136 + { PseudoVASUB_VV_MF2_MASK, PseudoVASUB_VV_MF2, 0x3, false }, // 137 + { PseudoVASUB_VV_MF4_MASK, PseudoVASUB_VV_MF4, 0x3, false }, // 138 + { PseudoVASUB_VV_MF8_MASK, PseudoVASUB_VV_MF8, 0x3, false }, // 139 + { PseudoVASUB_VX_M1_MASK, PseudoVASUB_VX_M1, 0x3, false }, // 140 + { PseudoVASUB_VX_M2_MASK, PseudoVASUB_VX_M2, 0x3, false }, // 141 + { PseudoVASUB_VX_M4_MASK, PseudoVASUB_VX_M4, 0x3, false }, // 142 + { PseudoVASUB_VX_M8_MASK, PseudoVASUB_VX_M8, 0x3, false }, // 143 + { PseudoVASUB_VX_MF2_MASK, PseudoVASUB_VX_MF2, 0x3, false }, // 144 + { PseudoVASUB_VX_MF4_MASK, PseudoVASUB_VX_MF4, 0x3, false }, // 145 + { PseudoVASUB_VX_MF8_MASK, PseudoVASUB_VX_MF8, 0x3, false }, // 146 + { PseudoVBREV8_V_M1_MASK, PseudoVBREV8_V_M1, 0x2, false }, // 147 + { PseudoVBREV8_V_M2_MASK, PseudoVBREV8_V_M2, 0x2, false }, // 148 + { PseudoVBREV8_V_M4_MASK, PseudoVBREV8_V_M4, 0x2, false }, // 149 + { PseudoVBREV8_V_M8_MASK, PseudoVBREV8_V_M8, 0x2, false }, // 150 + { PseudoVBREV8_V_MF2_MASK, PseudoVBREV8_V_MF2, 0x2, false }, // 151 + { PseudoVBREV8_V_MF4_MASK, PseudoVBREV8_V_MF4, 0x2, false }, // 152 + { PseudoVBREV8_V_MF8_MASK, PseudoVBREV8_V_MF8, 0x2, false }, // 153 + { PseudoVBREV_V_M1_MASK, PseudoVBREV_V_M1, 0x2, false }, // 154 + { PseudoVBREV_V_M2_MASK, PseudoVBREV_V_M2, 0x2, false }, // 155 + { PseudoVBREV_V_M4_MASK, PseudoVBREV_V_M4, 0x2, false }, // 156 + { PseudoVBREV_V_M8_MASK, PseudoVBREV_V_M8, 0x2, false }, // 157 + { PseudoVBREV_V_MF2_MASK, PseudoVBREV_V_MF2, 0x2, false }, // 158 + { PseudoVBREV_V_MF4_MASK, PseudoVBREV_V_MF4, 0x2, false }, // 159 + { PseudoVBREV_V_MF8_MASK, PseudoVBREV_V_MF8, 0x2, false }, // 160 + { PseudoVCLMULH_VV_M1_MASK, PseudoVCLMULH_VV_M1, 0x3, false }, // 161 + { PseudoVCLMULH_VV_M2_MASK, PseudoVCLMULH_VV_M2, 0x3, false }, // 162 + { PseudoVCLMULH_VV_M4_MASK, PseudoVCLMULH_VV_M4, 0x3, false }, // 163 + { PseudoVCLMULH_VV_M8_MASK, PseudoVCLMULH_VV_M8, 0x3, false }, // 164 + { PseudoVCLMULH_VV_MF2_MASK, PseudoVCLMULH_VV_MF2, 0x3, false }, // 165 + { PseudoVCLMULH_VV_MF4_MASK, PseudoVCLMULH_VV_MF4, 0x3, false }, // 166 + { PseudoVCLMULH_VV_MF8_MASK, PseudoVCLMULH_VV_MF8, 0x3, false }, // 167 + { PseudoVCLMULH_VX_M1_MASK, PseudoVCLMULH_VX_M1, 0x3, false }, // 168 + { PseudoVCLMULH_VX_M2_MASK, PseudoVCLMULH_VX_M2, 0x3, false }, // 169 + { PseudoVCLMULH_VX_M4_MASK, PseudoVCLMULH_VX_M4, 0x3, false }, // 170 + { PseudoVCLMULH_VX_M8_MASK, PseudoVCLMULH_VX_M8, 0x3, false }, // 171 + { PseudoVCLMULH_VX_MF2_MASK, PseudoVCLMULH_VX_MF2, 0x3, false }, // 172 + { PseudoVCLMULH_VX_MF4_MASK, PseudoVCLMULH_VX_MF4, 0x3, false }, // 173 + { PseudoVCLMULH_VX_MF8_MASK, PseudoVCLMULH_VX_MF8, 0x3, false }, // 174 + { PseudoVCLMUL_VV_M1_MASK, PseudoVCLMUL_VV_M1, 0x3, false }, // 175 + { PseudoVCLMUL_VV_M2_MASK, PseudoVCLMUL_VV_M2, 0x3, false }, // 176 + { PseudoVCLMUL_VV_M4_MASK, PseudoVCLMUL_VV_M4, 0x3, false }, // 177 + { PseudoVCLMUL_VV_M8_MASK, PseudoVCLMUL_VV_M8, 0x3, false }, // 178 + { PseudoVCLMUL_VV_MF2_MASK, PseudoVCLMUL_VV_MF2, 0x3, false }, // 179 + { PseudoVCLMUL_VV_MF4_MASK, PseudoVCLMUL_VV_MF4, 0x3, false }, // 180 + { PseudoVCLMUL_VV_MF8_MASK, PseudoVCLMUL_VV_MF8, 0x3, false }, // 181 + { PseudoVCLMUL_VX_M1_MASK, PseudoVCLMUL_VX_M1, 0x3, false }, // 182 + { PseudoVCLMUL_VX_M2_MASK, PseudoVCLMUL_VX_M2, 0x3, false }, // 183 + { PseudoVCLMUL_VX_M4_MASK, PseudoVCLMUL_VX_M4, 0x3, false }, // 184 + { PseudoVCLMUL_VX_M8_MASK, PseudoVCLMUL_VX_M8, 0x3, false }, // 185 + { PseudoVCLMUL_VX_MF2_MASK, PseudoVCLMUL_VX_MF2, 0x3, false }, // 186 + { PseudoVCLMUL_VX_MF4_MASK, PseudoVCLMUL_VX_MF4, 0x3, false }, // 187 + { PseudoVCLMUL_VX_MF8_MASK, PseudoVCLMUL_VX_MF8, 0x3, false }, // 188 + { PseudoVCLZ_V_M1_MASK, PseudoVCLZ_V_M1, 0x2, false }, // 189 + { PseudoVCLZ_V_M2_MASK, PseudoVCLZ_V_M2, 0x2, false }, // 190 + { PseudoVCLZ_V_M4_MASK, PseudoVCLZ_V_M4, 0x2, false }, // 191 + { PseudoVCLZ_V_M8_MASK, PseudoVCLZ_V_M8, 0x2, false }, // 192 + { PseudoVCLZ_V_MF2_MASK, PseudoVCLZ_V_MF2, 0x2, false }, // 193 + { PseudoVCLZ_V_MF4_MASK, PseudoVCLZ_V_MF4, 0x2, false }, // 194 + { PseudoVCLZ_V_MF8_MASK, PseudoVCLZ_V_MF8, 0x2, false }, // 195 + { PseudoVCPOP_V_M1_MASK, PseudoVCPOP_V_M1, 0x2, false }, // 196 + { PseudoVCPOP_V_M2_MASK, PseudoVCPOP_V_M2, 0x2, false }, // 197 + { PseudoVCPOP_V_M4_MASK, PseudoVCPOP_V_M4, 0x2, false }, // 198 + { PseudoVCPOP_V_M8_MASK, PseudoVCPOP_V_M8, 0x2, false }, // 199 + { PseudoVCPOP_V_MF2_MASK, PseudoVCPOP_V_MF2, 0x2, false }, // 200 + { PseudoVCPOP_V_MF4_MASK, PseudoVCPOP_V_MF4, 0x2, false }, // 201 + { PseudoVCPOP_V_MF8_MASK, PseudoVCPOP_V_MF8, 0x2, false }, // 202 + { PseudoVCTZ_V_M1_MASK, PseudoVCTZ_V_M1, 0x2, false }, // 203 + { PseudoVCTZ_V_M2_MASK, PseudoVCTZ_V_M2, 0x2, false }, // 204 + { PseudoVCTZ_V_M4_MASK, PseudoVCTZ_V_M4, 0x2, false }, // 205 + { PseudoVCTZ_V_M8_MASK, PseudoVCTZ_V_M8, 0x2, false }, // 206 + { PseudoVCTZ_V_MF2_MASK, PseudoVCTZ_V_MF2, 0x2, false }, // 207 + { PseudoVCTZ_V_MF4_MASK, PseudoVCTZ_V_MF4, 0x2, false }, // 208 + { PseudoVCTZ_V_MF8_MASK, PseudoVCTZ_V_MF8, 0x2, false }, // 209 + { PseudoVDIVU_VV_M1_E16_MASK, PseudoVDIVU_VV_M1_E16, 0x3, false }, // 210 + { PseudoVDIVU_VV_M1_E32_MASK, PseudoVDIVU_VV_M1_E32, 0x3, false }, // 211 + { PseudoVDIVU_VV_M1_E64_MASK, PseudoVDIVU_VV_M1_E64, 0x3, false }, // 212 + { PseudoVDIVU_VV_M1_E8_MASK, PseudoVDIVU_VV_M1_E8, 0x3, false }, // 213 + { PseudoVDIVU_VV_M2_E16_MASK, PseudoVDIVU_VV_M2_E16, 0x3, false }, // 214 + { PseudoVDIVU_VV_M2_E32_MASK, PseudoVDIVU_VV_M2_E32, 0x3, false }, // 215 + { PseudoVDIVU_VV_M2_E64_MASK, PseudoVDIVU_VV_M2_E64, 0x3, false }, // 216 + { PseudoVDIVU_VV_M2_E8_MASK, PseudoVDIVU_VV_M2_E8, 0x3, false }, // 217 + { PseudoVDIVU_VV_M4_E16_MASK, PseudoVDIVU_VV_M4_E16, 0x3, false }, // 218 + { PseudoVDIVU_VV_M4_E32_MASK, PseudoVDIVU_VV_M4_E32, 0x3, false }, // 219 + { PseudoVDIVU_VV_M4_E64_MASK, PseudoVDIVU_VV_M4_E64, 0x3, false }, // 220 + { PseudoVDIVU_VV_M4_E8_MASK, PseudoVDIVU_VV_M4_E8, 0x3, false }, // 221 + { PseudoVDIVU_VV_M8_E16_MASK, PseudoVDIVU_VV_M8_E16, 0x3, false }, // 222 + { PseudoVDIVU_VV_M8_E32_MASK, PseudoVDIVU_VV_M8_E32, 0x3, false }, // 223 + { PseudoVDIVU_VV_M8_E64_MASK, PseudoVDIVU_VV_M8_E64, 0x3, false }, // 224 + { PseudoVDIVU_VV_M8_E8_MASK, PseudoVDIVU_VV_M8_E8, 0x3, false }, // 225 + { PseudoVDIVU_VV_MF2_E16_MASK, PseudoVDIVU_VV_MF2_E16, 0x3, false }, // 226 + { PseudoVDIVU_VV_MF2_E32_MASK, PseudoVDIVU_VV_MF2_E32, 0x3, false }, // 227 + { PseudoVDIVU_VV_MF2_E8_MASK, PseudoVDIVU_VV_MF2_E8, 0x3, false }, // 228 + { PseudoVDIVU_VV_MF4_E16_MASK, PseudoVDIVU_VV_MF4_E16, 0x3, false }, // 229 + { PseudoVDIVU_VV_MF4_E8_MASK, PseudoVDIVU_VV_MF4_E8, 0x3, false }, // 230 + { PseudoVDIVU_VV_MF8_E8_MASK, PseudoVDIVU_VV_MF8_E8, 0x3, false }, // 231 + { PseudoVDIVU_VX_M1_E16_MASK, PseudoVDIVU_VX_M1_E16, 0x3, false }, // 232 + { PseudoVDIVU_VX_M1_E32_MASK, PseudoVDIVU_VX_M1_E32, 0x3, false }, // 233 + { PseudoVDIVU_VX_M1_E64_MASK, PseudoVDIVU_VX_M1_E64, 0x3, false }, // 234 + { PseudoVDIVU_VX_M1_E8_MASK, PseudoVDIVU_VX_M1_E8, 0x3, false }, // 235 + { PseudoVDIVU_VX_M2_E16_MASK, PseudoVDIVU_VX_M2_E16, 0x3, false }, // 236 + { PseudoVDIVU_VX_M2_E32_MASK, PseudoVDIVU_VX_M2_E32, 0x3, false }, // 237 + { PseudoVDIVU_VX_M2_E64_MASK, PseudoVDIVU_VX_M2_E64, 0x3, false }, // 238 + { PseudoVDIVU_VX_M2_E8_MASK, PseudoVDIVU_VX_M2_E8, 0x3, false }, // 239 + { PseudoVDIVU_VX_M4_E16_MASK, PseudoVDIVU_VX_M4_E16, 0x3, false }, // 240 + { PseudoVDIVU_VX_M4_E32_MASK, PseudoVDIVU_VX_M4_E32, 0x3, false }, // 241 + { PseudoVDIVU_VX_M4_E64_MASK, PseudoVDIVU_VX_M4_E64, 0x3, false }, // 242 + { PseudoVDIVU_VX_M4_E8_MASK, PseudoVDIVU_VX_M4_E8, 0x3, false }, // 243 + { PseudoVDIVU_VX_M8_E16_MASK, PseudoVDIVU_VX_M8_E16, 0x3, false }, // 244 + { PseudoVDIVU_VX_M8_E32_MASK, PseudoVDIVU_VX_M8_E32, 0x3, false }, // 245 + { PseudoVDIVU_VX_M8_E64_MASK, PseudoVDIVU_VX_M8_E64, 0x3, false }, // 246 + { PseudoVDIVU_VX_M8_E8_MASK, PseudoVDIVU_VX_M8_E8, 0x3, false }, // 247 + { PseudoVDIVU_VX_MF2_E16_MASK, PseudoVDIVU_VX_MF2_E16, 0x3, false }, // 248 + { PseudoVDIVU_VX_MF2_E32_MASK, PseudoVDIVU_VX_MF2_E32, 0x3, false }, // 249 + { PseudoVDIVU_VX_MF2_E8_MASK, PseudoVDIVU_VX_MF2_E8, 0x3, false }, // 250 + { PseudoVDIVU_VX_MF4_E16_MASK, PseudoVDIVU_VX_MF4_E16, 0x3, false }, // 251 + { PseudoVDIVU_VX_MF4_E8_MASK, PseudoVDIVU_VX_MF4_E8, 0x3, false }, // 252 + { PseudoVDIVU_VX_MF8_E8_MASK, PseudoVDIVU_VX_MF8_E8, 0x3, false }, // 253 + { PseudoVDIV_VV_M1_E16_MASK, PseudoVDIV_VV_M1_E16, 0x3, false }, // 254 + { PseudoVDIV_VV_M1_E32_MASK, PseudoVDIV_VV_M1_E32, 0x3, false }, // 255 + { PseudoVDIV_VV_M1_E64_MASK, PseudoVDIV_VV_M1_E64, 0x3, false }, // 256 + { PseudoVDIV_VV_M1_E8_MASK, PseudoVDIV_VV_M1_E8, 0x3, false }, // 257 + { PseudoVDIV_VV_M2_E16_MASK, PseudoVDIV_VV_M2_E16, 0x3, false }, // 258 + { PseudoVDIV_VV_M2_E32_MASK, PseudoVDIV_VV_M2_E32, 0x3, false }, // 259 + { PseudoVDIV_VV_M2_E64_MASK, PseudoVDIV_VV_M2_E64, 0x3, false }, // 260 + { PseudoVDIV_VV_M2_E8_MASK, PseudoVDIV_VV_M2_E8, 0x3, false }, // 261 + { PseudoVDIV_VV_M4_E16_MASK, PseudoVDIV_VV_M4_E16, 0x3, false }, // 262 + { PseudoVDIV_VV_M4_E32_MASK, PseudoVDIV_VV_M4_E32, 0x3, false }, // 263 + { PseudoVDIV_VV_M4_E64_MASK, PseudoVDIV_VV_M4_E64, 0x3, false }, // 264 + { PseudoVDIV_VV_M4_E8_MASK, PseudoVDIV_VV_M4_E8, 0x3, false }, // 265 + { PseudoVDIV_VV_M8_E16_MASK, PseudoVDIV_VV_M8_E16, 0x3, false }, // 266 + { PseudoVDIV_VV_M8_E32_MASK, PseudoVDIV_VV_M8_E32, 0x3, false }, // 267 + { PseudoVDIV_VV_M8_E64_MASK, PseudoVDIV_VV_M8_E64, 0x3, false }, // 268 + { PseudoVDIV_VV_M8_E8_MASK, PseudoVDIV_VV_M8_E8, 0x3, false }, // 269 + { PseudoVDIV_VV_MF2_E16_MASK, PseudoVDIV_VV_MF2_E16, 0x3, false }, // 270 + { PseudoVDIV_VV_MF2_E32_MASK, PseudoVDIV_VV_MF2_E32, 0x3, false }, // 271 + { PseudoVDIV_VV_MF2_E8_MASK, PseudoVDIV_VV_MF2_E8, 0x3, false }, // 272 + { PseudoVDIV_VV_MF4_E16_MASK, PseudoVDIV_VV_MF4_E16, 0x3, false }, // 273 + { PseudoVDIV_VV_MF4_E8_MASK, PseudoVDIV_VV_MF4_E8, 0x3, false }, // 274 + { PseudoVDIV_VV_MF8_E8_MASK, PseudoVDIV_VV_MF8_E8, 0x3, false }, // 275 + { PseudoVDIV_VX_M1_E16_MASK, PseudoVDIV_VX_M1_E16, 0x3, false }, // 276 + { PseudoVDIV_VX_M1_E32_MASK, PseudoVDIV_VX_M1_E32, 0x3, false }, // 277 + { PseudoVDIV_VX_M1_E64_MASK, PseudoVDIV_VX_M1_E64, 0x3, false }, // 278 + { PseudoVDIV_VX_M1_E8_MASK, PseudoVDIV_VX_M1_E8, 0x3, false }, // 279 + { PseudoVDIV_VX_M2_E16_MASK, PseudoVDIV_VX_M2_E16, 0x3, false }, // 280 + { PseudoVDIV_VX_M2_E32_MASK, PseudoVDIV_VX_M2_E32, 0x3, false }, // 281 + { PseudoVDIV_VX_M2_E64_MASK, PseudoVDIV_VX_M2_E64, 0x3, false }, // 282 + { PseudoVDIV_VX_M2_E8_MASK, PseudoVDIV_VX_M2_E8, 0x3, false }, // 283 + { PseudoVDIV_VX_M4_E16_MASK, PseudoVDIV_VX_M4_E16, 0x3, false }, // 284 + { PseudoVDIV_VX_M4_E32_MASK, PseudoVDIV_VX_M4_E32, 0x3, false }, // 285 + { PseudoVDIV_VX_M4_E64_MASK, PseudoVDIV_VX_M4_E64, 0x3, false }, // 286 + { PseudoVDIV_VX_M4_E8_MASK, PseudoVDIV_VX_M4_E8, 0x3, false }, // 287 + { PseudoVDIV_VX_M8_E16_MASK, PseudoVDIV_VX_M8_E16, 0x3, false }, // 288 + { PseudoVDIV_VX_M8_E32_MASK, PseudoVDIV_VX_M8_E32, 0x3, false }, // 289 + { PseudoVDIV_VX_M8_E64_MASK, PseudoVDIV_VX_M8_E64, 0x3, false }, // 290 + { PseudoVDIV_VX_M8_E8_MASK, PseudoVDIV_VX_M8_E8, 0x3, false }, // 291 + { PseudoVDIV_VX_MF2_E16_MASK, PseudoVDIV_VX_MF2_E16, 0x3, false }, // 292 + { PseudoVDIV_VX_MF2_E32_MASK, PseudoVDIV_VX_MF2_E32, 0x3, false }, // 293 + { PseudoVDIV_VX_MF2_E8_MASK, PseudoVDIV_VX_MF2_E8, 0x3, false }, // 294 + { PseudoVDIV_VX_MF4_E16_MASK, PseudoVDIV_VX_MF4_E16, 0x3, false }, // 295 + { PseudoVDIV_VX_MF4_E8_MASK, PseudoVDIV_VX_MF4_E8, 0x3, false }, // 296 + { PseudoVDIV_VX_MF8_E8_MASK, PseudoVDIV_VX_MF8_E8, 0x3, false }, // 297 + { PseudoVFADD_VFPR16_M1_MASK, PseudoVFADD_VFPR16_M1, 0x3, false }, // 298 + { PseudoVFADD_VFPR16_M2_MASK, PseudoVFADD_VFPR16_M2, 0x3, false }, // 299 + { PseudoVFADD_VFPR16_M4_MASK, PseudoVFADD_VFPR16_M4, 0x3, false }, // 300 + { PseudoVFADD_VFPR16_M8_MASK, PseudoVFADD_VFPR16_M8, 0x3, false }, // 301 + { PseudoVFADD_VFPR16_MF2_MASK, PseudoVFADD_VFPR16_MF2, 0x3, false }, // 302 + { PseudoVFADD_VFPR16_MF4_MASK, PseudoVFADD_VFPR16_MF4, 0x3, false }, // 303 + { PseudoVFADD_VFPR32_M1_MASK, PseudoVFADD_VFPR32_M1, 0x3, false }, // 304 + { PseudoVFADD_VFPR32_M2_MASK, PseudoVFADD_VFPR32_M2, 0x3, false }, // 305 + { PseudoVFADD_VFPR32_M4_MASK, PseudoVFADD_VFPR32_M4, 0x3, false }, // 306 + { PseudoVFADD_VFPR32_M8_MASK, PseudoVFADD_VFPR32_M8, 0x3, false }, // 307 + { PseudoVFADD_VFPR32_MF2_MASK, PseudoVFADD_VFPR32_MF2, 0x3, false }, // 308 + { PseudoVFADD_VFPR64_M1_MASK, PseudoVFADD_VFPR64_M1, 0x3, false }, // 309 + { PseudoVFADD_VFPR64_M2_MASK, PseudoVFADD_VFPR64_M2, 0x3, false }, // 310 + { PseudoVFADD_VFPR64_M4_MASK, PseudoVFADD_VFPR64_M4, 0x3, false }, // 311 + { PseudoVFADD_VFPR64_M8_MASK, PseudoVFADD_VFPR64_M8, 0x3, false }, // 312 + { PseudoVFADD_VV_M1_MASK, PseudoVFADD_VV_M1, 0x3, false }, // 313 + { PseudoVFADD_VV_M2_MASK, PseudoVFADD_VV_M2, 0x3, false }, // 314 + { PseudoVFADD_VV_M4_MASK, PseudoVFADD_VV_M4, 0x3, false }, // 315 + { PseudoVFADD_VV_M8_MASK, PseudoVFADD_VV_M8, 0x3, false }, // 316 + { PseudoVFADD_VV_MF2_MASK, PseudoVFADD_VV_MF2, 0x3, false }, // 317 + { PseudoVFADD_VV_MF4_MASK, PseudoVFADD_VV_MF4, 0x3, false }, // 318 + { PseudoVFCLASS_V_M1_MASK, PseudoVFCLASS_V_M1, 0x2, false }, // 319 + { PseudoVFCLASS_V_M2_MASK, PseudoVFCLASS_V_M2, 0x2, false }, // 320 + { PseudoVFCLASS_V_M4_MASK, PseudoVFCLASS_V_M4, 0x2, false }, // 321 + { PseudoVFCLASS_V_M8_MASK, PseudoVFCLASS_V_M8, 0x2, false }, // 322 + { PseudoVFCLASS_V_MF2_MASK, PseudoVFCLASS_V_MF2, 0x2, false }, // 323 + { PseudoVFCLASS_V_MF4_MASK, PseudoVFCLASS_V_MF4, 0x2, false }, // 324 + { PseudoVFCVT_F_XU_V_M1_MASK, PseudoVFCVT_F_XU_V_M1, 0x2, false }, // 325 + { PseudoVFCVT_F_XU_V_M2_MASK, PseudoVFCVT_F_XU_V_M2, 0x2, false }, // 326 + { PseudoVFCVT_F_XU_V_M4_MASK, PseudoVFCVT_F_XU_V_M4, 0x2, false }, // 327 + { PseudoVFCVT_F_XU_V_M8_MASK, PseudoVFCVT_F_XU_V_M8, 0x2, false }, // 328 + { PseudoVFCVT_F_XU_V_MF2_MASK, PseudoVFCVT_F_XU_V_MF2, 0x2, false }, // 329 + { PseudoVFCVT_F_XU_V_MF4_MASK, PseudoVFCVT_F_XU_V_MF4, 0x2, false }, // 330 + { PseudoVFCVT_F_X_V_M1_MASK, PseudoVFCVT_F_X_V_M1, 0x2, false }, // 331 + { PseudoVFCVT_F_X_V_M2_MASK, PseudoVFCVT_F_X_V_M2, 0x2, false }, // 332 + { PseudoVFCVT_F_X_V_M4_MASK, PseudoVFCVT_F_X_V_M4, 0x2, false }, // 333 + { PseudoVFCVT_F_X_V_M8_MASK, PseudoVFCVT_F_X_V_M8, 0x2, false }, // 334 + { PseudoVFCVT_F_X_V_MF2_MASK, PseudoVFCVT_F_X_V_MF2, 0x2, false }, // 335 + { PseudoVFCVT_F_X_V_MF4_MASK, PseudoVFCVT_F_X_V_MF4, 0x2, false }, // 336 + { PseudoVFCVT_RM_F_XU_V_M1_MASK, PseudoVFCVT_RM_F_XU_V_M1, 0x2, false }, // 337 + { PseudoVFCVT_RM_F_XU_V_M2_MASK, PseudoVFCVT_RM_F_XU_V_M2, 0x2, false }, // 338 + { PseudoVFCVT_RM_F_XU_V_M4_MASK, PseudoVFCVT_RM_F_XU_V_M4, 0x2, false }, // 339 + { PseudoVFCVT_RM_F_XU_V_M8_MASK, PseudoVFCVT_RM_F_XU_V_M8, 0x2, false }, // 340 + { PseudoVFCVT_RM_F_XU_V_MF2_MASK, PseudoVFCVT_RM_F_XU_V_MF2, 0x2, false }, // 341 + { PseudoVFCVT_RM_F_XU_V_MF4_MASK, PseudoVFCVT_RM_F_XU_V_MF4, 0x2, false }, // 342 + { PseudoVFCVT_RM_F_X_V_M1_MASK, PseudoVFCVT_RM_F_X_V_M1, 0x2, false }, // 343 + { PseudoVFCVT_RM_F_X_V_M2_MASK, PseudoVFCVT_RM_F_X_V_M2, 0x2, false }, // 344 + { PseudoVFCVT_RM_F_X_V_M4_MASK, PseudoVFCVT_RM_F_X_V_M4, 0x2, false }, // 345 + { PseudoVFCVT_RM_F_X_V_M8_MASK, PseudoVFCVT_RM_F_X_V_M8, 0x2, false }, // 346 + { PseudoVFCVT_RM_F_X_V_MF2_MASK, PseudoVFCVT_RM_F_X_V_MF2, 0x2, false }, // 347 + { PseudoVFCVT_RM_F_X_V_MF4_MASK, PseudoVFCVT_RM_F_X_V_MF4, 0x2, false }, // 348 + { PseudoVFCVT_RM_XU_F_V_M1_MASK, PseudoVFCVT_RM_XU_F_V_M1, 0x2, false }, // 349 + { PseudoVFCVT_RM_XU_F_V_M2_MASK, PseudoVFCVT_RM_XU_F_V_M2, 0x2, false }, // 350 + { PseudoVFCVT_RM_XU_F_V_M4_MASK, PseudoVFCVT_RM_XU_F_V_M4, 0x2, false }, // 351 + { PseudoVFCVT_RM_XU_F_V_M8_MASK, PseudoVFCVT_RM_XU_F_V_M8, 0x2, false }, // 352 + { PseudoVFCVT_RM_XU_F_V_MF2_MASK, PseudoVFCVT_RM_XU_F_V_MF2, 0x2, false }, // 353 + { PseudoVFCVT_RM_XU_F_V_MF4_MASK, PseudoVFCVT_RM_XU_F_V_MF4, 0x2, false }, // 354 + { PseudoVFCVT_RM_X_F_V_M1_MASK, PseudoVFCVT_RM_X_F_V_M1, 0x2, false }, // 355 + { PseudoVFCVT_RM_X_F_V_M2_MASK, PseudoVFCVT_RM_X_F_V_M2, 0x2, false }, // 356 + { PseudoVFCVT_RM_X_F_V_M4_MASK, PseudoVFCVT_RM_X_F_V_M4, 0x2, false }, // 357 + { PseudoVFCVT_RM_X_F_V_M8_MASK, PseudoVFCVT_RM_X_F_V_M8, 0x2, false }, // 358 + { PseudoVFCVT_RM_X_F_V_MF2_MASK, PseudoVFCVT_RM_X_F_V_MF2, 0x2, false }, // 359 + { PseudoVFCVT_RM_X_F_V_MF4_MASK, PseudoVFCVT_RM_X_F_V_MF4, 0x2, false }, // 360 + { PseudoVFCVT_RTZ_XU_F_V_M1_MASK, PseudoVFCVT_RTZ_XU_F_V_M1, 0x2, false }, // 361 + { PseudoVFCVT_RTZ_XU_F_V_M2_MASK, PseudoVFCVT_RTZ_XU_F_V_M2, 0x2, false }, // 362 + { PseudoVFCVT_RTZ_XU_F_V_M4_MASK, PseudoVFCVT_RTZ_XU_F_V_M4, 0x2, false }, // 363 + { PseudoVFCVT_RTZ_XU_F_V_M8_MASK, PseudoVFCVT_RTZ_XU_F_V_M8, 0x2, false }, // 364 + { PseudoVFCVT_RTZ_XU_F_V_MF2_MASK, PseudoVFCVT_RTZ_XU_F_V_MF2, 0x2, false }, // 365 + { PseudoVFCVT_RTZ_XU_F_V_MF4_MASK, PseudoVFCVT_RTZ_XU_F_V_MF4, 0x2, false }, // 366 + { PseudoVFCVT_RTZ_X_F_V_M1_MASK, PseudoVFCVT_RTZ_X_F_V_M1, 0x2, false }, // 367 + { PseudoVFCVT_RTZ_X_F_V_M2_MASK, PseudoVFCVT_RTZ_X_F_V_M2, 0x2, false }, // 368 + { PseudoVFCVT_RTZ_X_F_V_M4_MASK, PseudoVFCVT_RTZ_X_F_V_M4, 0x2, false }, // 369 + { PseudoVFCVT_RTZ_X_F_V_M8_MASK, PseudoVFCVT_RTZ_X_F_V_M8, 0x2, false }, // 370 + { PseudoVFCVT_RTZ_X_F_V_MF2_MASK, PseudoVFCVT_RTZ_X_F_V_MF2, 0x2, false }, // 371 + { PseudoVFCVT_RTZ_X_F_V_MF4_MASK, PseudoVFCVT_RTZ_X_F_V_MF4, 0x2, false }, // 372 + { PseudoVFCVT_XU_F_V_M1_MASK, PseudoVFCVT_XU_F_V_M1, 0x2, false }, // 373 + { PseudoVFCVT_XU_F_V_M2_MASK, PseudoVFCVT_XU_F_V_M2, 0x2, false }, // 374 + { PseudoVFCVT_XU_F_V_M4_MASK, PseudoVFCVT_XU_F_V_M4, 0x2, false }, // 375 + { PseudoVFCVT_XU_F_V_M8_MASK, PseudoVFCVT_XU_F_V_M8, 0x2, false }, // 376 + { PseudoVFCVT_XU_F_V_MF2_MASK, PseudoVFCVT_XU_F_V_MF2, 0x2, false }, // 377 + { PseudoVFCVT_XU_F_V_MF4_MASK, PseudoVFCVT_XU_F_V_MF4, 0x2, false }, // 378 + { PseudoVFCVT_X_F_V_M1_MASK, PseudoVFCVT_X_F_V_M1, 0x2, false }, // 379 + { PseudoVFCVT_X_F_V_M2_MASK, PseudoVFCVT_X_F_V_M2, 0x2, false }, // 380 + { PseudoVFCVT_X_F_V_M4_MASK, PseudoVFCVT_X_F_V_M4, 0x2, false }, // 381 + { PseudoVFCVT_X_F_V_M8_MASK, PseudoVFCVT_X_F_V_M8, 0x2, false }, // 382 + { PseudoVFCVT_X_F_V_MF2_MASK, PseudoVFCVT_X_F_V_MF2, 0x2, false }, // 383 + { PseudoVFCVT_X_F_V_MF4_MASK, PseudoVFCVT_X_F_V_MF4, 0x2, false }, // 384 + { PseudoVFDIV_VFPR16_M1_E16_MASK, PseudoVFDIV_VFPR16_M1_E16, 0x3, false }, // 385 + { PseudoVFDIV_VFPR16_M2_E16_MASK, PseudoVFDIV_VFPR16_M2_E16, 0x3, false }, // 386 + { PseudoVFDIV_VFPR16_M4_E16_MASK, PseudoVFDIV_VFPR16_M4_E16, 0x3, false }, // 387 + { PseudoVFDIV_VFPR16_M8_E16_MASK, PseudoVFDIV_VFPR16_M8_E16, 0x3, false }, // 388 + { PseudoVFDIV_VFPR16_MF2_E16_MASK, PseudoVFDIV_VFPR16_MF2_E16, 0x3, false }, // 389 + { PseudoVFDIV_VFPR16_MF4_E16_MASK, PseudoVFDIV_VFPR16_MF4_E16, 0x3, false }, // 390 + { PseudoVFDIV_VFPR32_M1_E32_MASK, PseudoVFDIV_VFPR32_M1_E32, 0x3, false }, // 391 + { PseudoVFDIV_VFPR32_M2_E32_MASK, PseudoVFDIV_VFPR32_M2_E32, 0x3, false }, // 392 + { PseudoVFDIV_VFPR32_M4_E32_MASK, PseudoVFDIV_VFPR32_M4_E32, 0x3, false }, // 393 + { PseudoVFDIV_VFPR32_M8_E32_MASK, PseudoVFDIV_VFPR32_M8_E32, 0x3, false }, // 394 + { PseudoVFDIV_VFPR32_MF2_E32_MASK, PseudoVFDIV_VFPR32_MF2_E32, 0x3, false }, // 395 + { PseudoVFDIV_VFPR64_M1_E64_MASK, PseudoVFDIV_VFPR64_M1_E64, 0x3, false }, // 396 + { PseudoVFDIV_VFPR64_M2_E64_MASK, PseudoVFDIV_VFPR64_M2_E64, 0x3, false }, // 397 + { PseudoVFDIV_VFPR64_M4_E64_MASK, PseudoVFDIV_VFPR64_M4_E64, 0x3, false }, // 398 + { PseudoVFDIV_VFPR64_M8_E64_MASK, PseudoVFDIV_VFPR64_M8_E64, 0x3, false }, // 399 + { PseudoVFDIV_VV_M1_E16_MASK, PseudoVFDIV_VV_M1_E16, 0x3, false }, // 400 + { PseudoVFDIV_VV_M1_E32_MASK, PseudoVFDIV_VV_M1_E32, 0x3, false }, // 401 + { PseudoVFDIV_VV_M1_E64_MASK, PseudoVFDIV_VV_M1_E64, 0x3, false }, // 402 + { PseudoVFDIV_VV_M2_E16_MASK, PseudoVFDIV_VV_M2_E16, 0x3, false }, // 403 + { PseudoVFDIV_VV_M2_E32_MASK, PseudoVFDIV_VV_M2_E32, 0x3, false }, // 404 + { PseudoVFDIV_VV_M2_E64_MASK, PseudoVFDIV_VV_M2_E64, 0x3, false }, // 405 + { PseudoVFDIV_VV_M4_E16_MASK, PseudoVFDIV_VV_M4_E16, 0x3, false }, // 406 + { PseudoVFDIV_VV_M4_E32_MASK, PseudoVFDIV_VV_M4_E32, 0x3, false }, // 407 + { PseudoVFDIV_VV_M4_E64_MASK, PseudoVFDIV_VV_M4_E64, 0x3, false }, // 408 + { PseudoVFDIV_VV_M8_E16_MASK, PseudoVFDIV_VV_M8_E16, 0x3, false }, // 409 + { PseudoVFDIV_VV_M8_E32_MASK, PseudoVFDIV_VV_M8_E32, 0x3, false }, // 410 + { PseudoVFDIV_VV_M8_E64_MASK, PseudoVFDIV_VV_M8_E64, 0x3, false }, // 411 + { PseudoVFDIV_VV_MF2_E16_MASK, PseudoVFDIV_VV_MF2_E16, 0x3, false }, // 412 + { PseudoVFDIV_VV_MF2_E32_MASK, PseudoVFDIV_VV_MF2_E32, 0x3, false }, // 413 + { PseudoVFDIV_VV_MF4_E16_MASK, PseudoVFDIV_VV_MF4_E16, 0x3, false }, // 414 + { PseudoVFMACC_VFPR16_M1_MASK, PseudoVFMACC_VFPR16_M1, 0x3, false }, // 415 + { PseudoVFMACC_VFPR16_M2_MASK, PseudoVFMACC_VFPR16_M2, 0x3, false }, // 416 + { PseudoVFMACC_VFPR16_M4_MASK, PseudoVFMACC_VFPR16_M4, 0x3, false }, // 417 + { PseudoVFMACC_VFPR16_M8_MASK, PseudoVFMACC_VFPR16_M8, 0x3, false }, // 418 + { PseudoVFMACC_VFPR16_MF2_MASK, PseudoVFMACC_VFPR16_MF2, 0x3, false }, // 419 + { PseudoVFMACC_VFPR16_MF4_MASK, PseudoVFMACC_VFPR16_MF4, 0x3, false }, // 420 + { PseudoVFMACC_VFPR32_M1_MASK, PseudoVFMACC_VFPR32_M1, 0x3, false }, // 421 + { PseudoVFMACC_VFPR32_M2_MASK, PseudoVFMACC_VFPR32_M2, 0x3, false }, // 422 + { PseudoVFMACC_VFPR32_M4_MASK, PseudoVFMACC_VFPR32_M4, 0x3, false }, // 423 + { PseudoVFMACC_VFPR32_M8_MASK, PseudoVFMACC_VFPR32_M8, 0x3, false }, // 424 + { PseudoVFMACC_VFPR32_MF2_MASK, PseudoVFMACC_VFPR32_MF2, 0x3, false }, // 425 + { PseudoVFMACC_VFPR64_M1_MASK, PseudoVFMACC_VFPR64_M1, 0x3, false }, // 426 + { PseudoVFMACC_VFPR64_M2_MASK, PseudoVFMACC_VFPR64_M2, 0x3, false }, // 427 + { PseudoVFMACC_VFPR64_M4_MASK, PseudoVFMACC_VFPR64_M4, 0x3, false }, // 428 + { PseudoVFMACC_VFPR64_M8_MASK, PseudoVFMACC_VFPR64_M8, 0x3, false }, // 429 + { PseudoVFMACC_VV_M1_MASK, PseudoVFMACC_VV_M1, 0x3, false }, // 430 + { PseudoVFMACC_VV_M2_MASK, PseudoVFMACC_VV_M2, 0x3, false }, // 431 + { PseudoVFMACC_VV_M4_MASK, PseudoVFMACC_VV_M4, 0x3, false }, // 432 + { PseudoVFMACC_VV_M8_MASK, PseudoVFMACC_VV_M8, 0x3, false }, // 433 + { PseudoVFMACC_VV_MF2_MASK, PseudoVFMACC_VV_MF2, 0x3, false }, // 434 + { PseudoVFMACC_VV_MF4_MASK, PseudoVFMACC_VV_MF4, 0x3, false }, // 435 + { PseudoVFMADD_VFPR16_M1_MASK, PseudoVFMADD_VFPR16_M1, 0x3, false }, // 436 + { PseudoVFMADD_VFPR16_M2_MASK, PseudoVFMADD_VFPR16_M2, 0x3, false }, // 437 + { PseudoVFMADD_VFPR16_M4_MASK, PseudoVFMADD_VFPR16_M4, 0x3, false }, // 438 + { PseudoVFMADD_VFPR16_M8_MASK, PseudoVFMADD_VFPR16_M8, 0x3, false }, // 439 + { PseudoVFMADD_VFPR16_MF2_MASK, PseudoVFMADD_VFPR16_MF2, 0x3, false }, // 440 + { PseudoVFMADD_VFPR16_MF4_MASK, PseudoVFMADD_VFPR16_MF4, 0x3, false }, // 441 + { PseudoVFMADD_VFPR32_M1_MASK, PseudoVFMADD_VFPR32_M1, 0x3, false }, // 442 + { PseudoVFMADD_VFPR32_M2_MASK, PseudoVFMADD_VFPR32_M2, 0x3, false }, // 443 + { PseudoVFMADD_VFPR32_M4_MASK, PseudoVFMADD_VFPR32_M4, 0x3, false }, // 444 + { PseudoVFMADD_VFPR32_M8_MASK, PseudoVFMADD_VFPR32_M8, 0x3, false }, // 445 + { PseudoVFMADD_VFPR32_MF2_MASK, PseudoVFMADD_VFPR32_MF2, 0x3, false }, // 446 + { PseudoVFMADD_VFPR64_M1_MASK, PseudoVFMADD_VFPR64_M1, 0x3, false }, // 447 + { PseudoVFMADD_VFPR64_M2_MASK, PseudoVFMADD_VFPR64_M2, 0x3, false }, // 448 + { PseudoVFMADD_VFPR64_M4_MASK, PseudoVFMADD_VFPR64_M4, 0x3, false }, // 449 + { PseudoVFMADD_VFPR64_M8_MASK, PseudoVFMADD_VFPR64_M8, 0x3, false }, // 450 + { PseudoVFMADD_VV_M1_MASK, PseudoVFMADD_VV_M1, 0x3, false }, // 451 + { PseudoVFMADD_VV_M2_MASK, PseudoVFMADD_VV_M2, 0x3, false }, // 452 + { PseudoVFMADD_VV_M4_MASK, PseudoVFMADD_VV_M4, 0x3, false }, // 453 + { PseudoVFMADD_VV_M8_MASK, PseudoVFMADD_VV_M8, 0x3, false }, // 454 + { PseudoVFMADD_VV_MF2_MASK, PseudoVFMADD_VV_MF2, 0x3, false }, // 455 + { PseudoVFMADD_VV_MF4_MASK, PseudoVFMADD_VV_MF4, 0x3, false }, // 456 + { PseudoVFMAX_VFPR16_M1_MASK, PseudoVFMAX_VFPR16_M1, 0x3, false }, // 457 + { PseudoVFMAX_VFPR16_M2_MASK, PseudoVFMAX_VFPR16_M2, 0x3, false }, // 458 + { PseudoVFMAX_VFPR16_M4_MASK, PseudoVFMAX_VFPR16_M4, 0x3, false }, // 459 + { PseudoVFMAX_VFPR16_M8_MASK, PseudoVFMAX_VFPR16_M8, 0x3, false }, // 460 + { PseudoVFMAX_VFPR16_MF2_MASK, PseudoVFMAX_VFPR16_MF2, 0x3, false }, // 461 + { PseudoVFMAX_VFPR16_MF4_MASK, PseudoVFMAX_VFPR16_MF4, 0x3, false }, // 462 + { PseudoVFMAX_VFPR32_M1_MASK, PseudoVFMAX_VFPR32_M1, 0x3, false }, // 463 + { PseudoVFMAX_VFPR32_M2_MASK, PseudoVFMAX_VFPR32_M2, 0x3, false }, // 464 + { PseudoVFMAX_VFPR32_M4_MASK, PseudoVFMAX_VFPR32_M4, 0x3, false }, // 465 + { PseudoVFMAX_VFPR32_M8_MASK, PseudoVFMAX_VFPR32_M8, 0x3, false }, // 466 + { PseudoVFMAX_VFPR32_MF2_MASK, PseudoVFMAX_VFPR32_MF2, 0x3, false }, // 467 + { PseudoVFMAX_VFPR64_M1_MASK, PseudoVFMAX_VFPR64_M1, 0x3, false }, // 468 + { PseudoVFMAX_VFPR64_M2_MASK, PseudoVFMAX_VFPR64_M2, 0x3, false }, // 469 + { PseudoVFMAX_VFPR64_M4_MASK, PseudoVFMAX_VFPR64_M4, 0x3, false }, // 470 + { PseudoVFMAX_VFPR64_M8_MASK, PseudoVFMAX_VFPR64_M8, 0x3, false }, // 471 + { PseudoVFMAX_VV_M1_MASK, PseudoVFMAX_VV_M1, 0x3, false }, // 472 + { PseudoVFMAX_VV_M2_MASK, PseudoVFMAX_VV_M2, 0x3, false }, // 473 + { PseudoVFMAX_VV_M4_MASK, PseudoVFMAX_VV_M4, 0x3, false }, // 474 + { PseudoVFMAX_VV_M8_MASK, PseudoVFMAX_VV_M8, 0x3, false }, // 475 + { PseudoVFMAX_VV_MF2_MASK, PseudoVFMAX_VV_MF2, 0x3, false }, // 476 + { PseudoVFMAX_VV_MF4_MASK, PseudoVFMAX_VV_MF4, 0x3, false }, // 477 + { PseudoVFMIN_VFPR16_M1_MASK, PseudoVFMIN_VFPR16_M1, 0x3, false }, // 478 + { PseudoVFMIN_VFPR16_M2_MASK, PseudoVFMIN_VFPR16_M2, 0x3, false }, // 479 + { PseudoVFMIN_VFPR16_M4_MASK, PseudoVFMIN_VFPR16_M4, 0x3, false }, // 480 + { PseudoVFMIN_VFPR16_M8_MASK, PseudoVFMIN_VFPR16_M8, 0x3, false }, // 481 + { PseudoVFMIN_VFPR16_MF2_MASK, PseudoVFMIN_VFPR16_MF2, 0x3, false }, // 482 + { PseudoVFMIN_VFPR16_MF4_MASK, PseudoVFMIN_VFPR16_MF4, 0x3, false }, // 483 + { PseudoVFMIN_VFPR32_M1_MASK, PseudoVFMIN_VFPR32_M1, 0x3, false }, // 484 + { PseudoVFMIN_VFPR32_M2_MASK, PseudoVFMIN_VFPR32_M2, 0x3, false }, // 485 + { PseudoVFMIN_VFPR32_M4_MASK, PseudoVFMIN_VFPR32_M4, 0x3, false }, // 486 + { PseudoVFMIN_VFPR32_M8_MASK, PseudoVFMIN_VFPR32_M8, 0x3, false }, // 487 + { PseudoVFMIN_VFPR32_MF2_MASK, PseudoVFMIN_VFPR32_MF2, 0x3, false }, // 488 + { PseudoVFMIN_VFPR64_M1_MASK, PseudoVFMIN_VFPR64_M1, 0x3, false }, // 489 + { PseudoVFMIN_VFPR64_M2_MASK, PseudoVFMIN_VFPR64_M2, 0x3, false }, // 490 + { PseudoVFMIN_VFPR64_M4_MASK, PseudoVFMIN_VFPR64_M4, 0x3, false }, // 491 + { PseudoVFMIN_VFPR64_M8_MASK, PseudoVFMIN_VFPR64_M8, 0x3, false }, // 492 + { PseudoVFMIN_VV_M1_MASK, PseudoVFMIN_VV_M1, 0x3, false }, // 493 + { PseudoVFMIN_VV_M2_MASK, PseudoVFMIN_VV_M2, 0x3, false }, // 494 + { PseudoVFMIN_VV_M4_MASK, PseudoVFMIN_VV_M4, 0x3, false }, // 495 + { PseudoVFMIN_VV_M8_MASK, PseudoVFMIN_VV_M8, 0x3, false }, // 496 + { PseudoVFMIN_VV_MF2_MASK, PseudoVFMIN_VV_MF2, 0x3, false }, // 497 + { PseudoVFMIN_VV_MF4_MASK, PseudoVFMIN_VV_MF4, 0x3, false }, // 498 + { PseudoVFMSAC_VFPR16_M1_MASK, PseudoVFMSAC_VFPR16_M1, 0x3, false }, // 499 + { PseudoVFMSAC_VFPR16_M2_MASK, PseudoVFMSAC_VFPR16_M2, 0x3, false }, // 500 + { PseudoVFMSAC_VFPR16_M4_MASK, PseudoVFMSAC_VFPR16_M4, 0x3, false }, // 501 + { PseudoVFMSAC_VFPR16_M8_MASK, PseudoVFMSAC_VFPR16_M8, 0x3, false }, // 502 + { PseudoVFMSAC_VFPR16_MF2_MASK, PseudoVFMSAC_VFPR16_MF2, 0x3, false }, // 503 + { PseudoVFMSAC_VFPR16_MF4_MASK, PseudoVFMSAC_VFPR16_MF4, 0x3, false }, // 504 + { PseudoVFMSAC_VFPR32_M1_MASK, PseudoVFMSAC_VFPR32_M1, 0x3, false }, // 505 + { PseudoVFMSAC_VFPR32_M2_MASK, PseudoVFMSAC_VFPR32_M2, 0x3, false }, // 506 + { PseudoVFMSAC_VFPR32_M4_MASK, PseudoVFMSAC_VFPR32_M4, 0x3, false }, // 507 + { PseudoVFMSAC_VFPR32_M8_MASK, PseudoVFMSAC_VFPR32_M8, 0x3, false }, // 508 + { PseudoVFMSAC_VFPR32_MF2_MASK, PseudoVFMSAC_VFPR32_MF2, 0x3, false }, // 509 + { PseudoVFMSAC_VFPR64_M1_MASK, PseudoVFMSAC_VFPR64_M1, 0x3, false }, // 510 + { PseudoVFMSAC_VFPR64_M2_MASK, PseudoVFMSAC_VFPR64_M2, 0x3, false }, // 511 + { PseudoVFMSAC_VFPR64_M4_MASK, PseudoVFMSAC_VFPR64_M4, 0x3, false }, // 512 + { PseudoVFMSAC_VFPR64_M8_MASK, PseudoVFMSAC_VFPR64_M8, 0x3, false }, // 513 + { PseudoVFMSAC_VV_M1_MASK, PseudoVFMSAC_VV_M1, 0x3, false }, // 514 + { PseudoVFMSAC_VV_M2_MASK, PseudoVFMSAC_VV_M2, 0x3, false }, // 515 + { PseudoVFMSAC_VV_M4_MASK, PseudoVFMSAC_VV_M4, 0x3, false }, // 516 + { PseudoVFMSAC_VV_M8_MASK, PseudoVFMSAC_VV_M8, 0x3, false }, // 517 + { PseudoVFMSAC_VV_MF2_MASK, PseudoVFMSAC_VV_MF2, 0x3, false }, // 518 + { PseudoVFMSAC_VV_MF4_MASK, PseudoVFMSAC_VV_MF4, 0x3, false }, // 519 + { PseudoVFMSUB_VFPR16_M1_MASK, PseudoVFMSUB_VFPR16_M1, 0x3, false }, // 520 + { PseudoVFMSUB_VFPR16_M2_MASK, PseudoVFMSUB_VFPR16_M2, 0x3, false }, // 521 + { PseudoVFMSUB_VFPR16_M4_MASK, PseudoVFMSUB_VFPR16_M4, 0x3, false }, // 522 + { PseudoVFMSUB_VFPR16_M8_MASK, PseudoVFMSUB_VFPR16_M8, 0x3, false }, // 523 + { PseudoVFMSUB_VFPR16_MF2_MASK, PseudoVFMSUB_VFPR16_MF2, 0x3, false }, // 524 + { PseudoVFMSUB_VFPR16_MF4_MASK, PseudoVFMSUB_VFPR16_MF4, 0x3, false }, // 525 + { PseudoVFMSUB_VFPR32_M1_MASK, PseudoVFMSUB_VFPR32_M1, 0x3, false }, // 526 + { PseudoVFMSUB_VFPR32_M2_MASK, PseudoVFMSUB_VFPR32_M2, 0x3, false }, // 527 + { PseudoVFMSUB_VFPR32_M4_MASK, PseudoVFMSUB_VFPR32_M4, 0x3, false }, // 528 + { PseudoVFMSUB_VFPR32_M8_MASK, PseudoVFMSUB_VFPR32_M8, 0x3, false }, // 529 + { PseudoVFMSUB_VFPR32_MF2_MASK, PseudoVFMSUB_VFPR32_MF2, 0x3, false }, // 530 + { PseudoVFMSUB_VFPR64_M1_MASK, PseudoVFMSUB_VFPR64_M1, 0x3, false }, // 531 + { PseudoVFMSUB_VFPR64_M2_MASK, PseudoVFMSUB_VFPR64_M2, 0x3, false }, // 532 + { PseudoVFMSUB_VFPR64_M4_MASK, PseudoVFMSUB_VFPR64_M4, 0x3, false }, // 533 + { PseudoVFMSUB_VFPR64_M8_MASK, PseudoVFMSUB_VFPR64_M8, 0x3, false }, // 534 + { PseudoVFMSUB_VV_M1_MASK, PseudoVFMSUB_VV_M1, 0x3, false }, // 535 + { PseudoVFMSUB_VV_M2_MASK, PseudoVFMSUB_VV_M2, 0x3, false }, // 536 + { PseudoVFMSUB_VV_M4_MASK, PseudoVFMSUB_VV_M4, 0x3, false }, // 537 + { PseudoVFMSUB_VV_M8_MASK, PseudoVFMSUB_VV_M8, 0x3, false }, // 538 + { PseudoVFMSUB_VV_MF2_MASK, PseudoVFMSUB_VV_MF2, 0x3, false }, // 539 + { PseudoVFMSUB_VV_MF4_MASK, PseudoVFMSUB_VV_MF4, 0x3, false }, // 540 + { PseudoVFMUL_VFPR16_M1_MASK, PseudoVFMUL_VFPR16_M1, 0x3, false }, // 541 + { PseudoVFMUL_VFPR16_M2_MASK, PseudoVFMUL_VFPR16_M2, 0x3, false }, // 542 + { PseudoVFMUL_VFPR16_M4_MASK, PseudoVFMUL_VFPR16_M4, 0x3, false }, // 543 + { PseudoVFMUL_VFPR16_M8_MASK, PseudoVFMUL_VFPR16_M8, 0x3, false }, // 544 + { PseudoVFMUL_VFPR16_MF2_MASK, PseudoVFMUL_VFPR16_MF2, 0x3, false }, // 545 + { PseudoVFMUL_VFPR16_MF4_MASK, PseudoVFMUL_VFPR16_MF4, 0x3, false }, // 546 + { PseudoVFMUL_VFPR32_M1_MASK, PseudoVFMUL_VFPR32_M1, 0x3, false }, // 547 + { PseudoVFMUL_VFPR32_M2_MASK, PseudoVFMUL_VFPR32_M2, 0x3, false }, // 548 + { PseudoVFMUL_VFPR32_M4_MASK, PseudoVFMUL_VFPR32_M4, 0x3, false }, // 549 + { PseudoVFMUL_VFPR32_M8_MASK, PseudoVFMUL_VFPR32_M8, 0x3, false }, // 550 + { PseudoVFMUL_VFPR32_MF2_MASK, PseudoVFMUL_VFPR32_MF2, 0x3, false }, // 551 + { PseudoVFMUL_VFPR64_M1_MASK, PseudoVFMUL_VFPR64_M1, 0x3, false }, // 552 + { PseudoVFMUL_VFPR64_M2_MASK, PseudoVFMUL_VFPR64_M2, 0x3, false }, // 553 + { PseudoVFMUL_VFPR64_M4_MASK, PseudoVFMUL_VFPR64_M4, 0x3, false }, // 554 + { PseudoVFMUL_VFPR64_M8_MASK, PseudoVFMUL_VFPR64_M8, 0x3, false }, // 555 + { PseudoVFMUL_VV_M1_MASK, PseudoVFMUL_VV_M1, 0x3, false }, // 556 + { PseudoVFMUL_VV_M2_MASK, PseudoVFMUL_VV_M2, 0x3, false }, // 557 + { PseudoVFMUL_VV_M4_MASK, PseudoVFMUL_VV_M4, 0x3, false }, // 558 + { PseudoVFMUL_VV_M8_MASK, PseudoVFMUL_VV_M8, 0x3, false }, // 559 + { PseudoVFMUL_VV_MF2_MASK, PseudoVFMUL_VV_MF2, 0x3, false }, // 560 + { PseudoVFMUL_VV_MF4_MASK, PseudoVFMUL_VV_MF4, 0x3, false }, // 561 + { PseudoVFNCVTBF16_F_F_W_M1_MASK, PseudoVFNCVTBF16_F_F_W_M1, 0x2, false }, // 562 + { PseudoVFNCVTBF16_F_F_W_M2_MASK, PseudoVFNCVTBF16_F_F_W_M2, 0x2, false }, // 563 + { PseudoVFNCVTBF16_F_F_W_M4_MASK, PseudoVFNCVTBF16_F_F_W_M4, 0x2, false }, // 564 + { PseudoVFNCVTBF16_F_F_W_MF2_MASK, PseudoVFNCVTBF16_F_F_W_MF2, 0x2, false }, // 565 + { PseudoVFNCVTBF16_F_F_W_MF4_MASK, PseudoVFNCVTBF16_F_F_W_MF4, 0x2, false }, // 566 + { PseudoVFNCVT_F_F_W_M1_MASK, PseudoVFNCVT_F_F_W_M1, 0x2, false }, // 567 + { PseudoVFNCVT_F_F_W_M2_MASK, PseudoVFNCVT_F_F_W_M2, 0x2, false }, // 568 + { PseudoVFNCVT_F_F_W_M4_MASK, PseudoVFNCVT_F_F_W_M4, 0x2, false }, // 569 + { PseudoVFNCVT_F_F_W_MF2_MASK, PseudoVFNCVT_F_F_W_MF2, 0x2, false }, // 570 + { PseudoVFNCVT_F_F_W_MF4_MASK, PseudoVFNCVT_F_F_W_MF4, 0x2, false }, // 571 + { PseudoVFNCVT_F_XU_W_M1_MASK, PseudoVFNCVT_F_XU_W_M1, 0x2, false }, // 572 + { PseudoVFNCVT_F_XU_W_M2_MASK, PseudoVFNCVT_F_XU_W_M2, 0x2, false }, // 573 + { PseudoVFNCVT_F_XU_W_M4_MASK, PseudoVFNCVT_F_XU_W_M4, 0x2, false }, // 574 + { PseudoVFNCVT_F_XU_W_MF2_MASK, PseudoVFNCVT_F_XU_W_MF2, 0x2, false }, // 575 + { PseudoVFNCVT_F_XU_W_MF4_MASK, PseudoVFNCVT_F_XU_W_MF4, 0x2, false }, // 576 + { PseudoVFNCVT_F_X_W_M1_MASK, PseudoVFNCVT_F_X_W_M1, 0x2, false }, // 577 + { PseudoVFNCVT_F_X_W_M2_MASK, PseudoVFNCVT_F_X_W_M2, 0x2, false }, // 578 + { PseudoVFNCVT_F_X_W_M4_MASK, PseudoVFNCVT_F_X_W_M4, 0x2, false }, // 579 + { PseudoVFNCVT_F_X_W_MF2_MASK, PseudoVFNCVT_F_X_W_MF2, 0x2, false }, // 580 + { PseudoVFNCVT_F_X_W_MF4_MASK, PseudoVFNCVT_F_X_W_MF4, 0x2, false }, // 581 + { PseudoVFNCVT_RM_F_XU_W_M1_MASK, PseudoVFNCVT_RM_F_XU_W_M1, 0x2, false }, // 582 + { PseudoVFNCVT_RM_F_XU_W_M2_MASK, PseudoVFNCVT_RM_F_XU_W_M2, 0x2, false }, // 583 + { PseudoVFNCVT_RM_F_XU_W_M4_MASK, PseudoVFNCVT_RM_F_XU_W_M4, 0x2, false }, // 584 + { PseudoVFNCVT_RM_F_XU_W_MF2_MASK, PseudoVFNCVT_RM_F_XU_W_MF2, 0x2, false }, // 585 + { PseudoVFNCVT_RM_F_XU_W_MF4_MASK, PseudoVFNCVT_RM_F_XU_W_MF4, 0x2, false }, // 586 + { PseudoVFNCVT_RM_F_X_W_M1_MASK, PseudoVFNCVT_RM_F_X_W_M1, 0x2, false }, // 587 + { PseudoVFNCVT_RM_F_X_W_M2_MASK, PseudoVFNCVT_RM_F_X_W_M2, 0x2, false }, // 588 + { PseudoVFNCVT_RM_F_X_W_M4_MASK, PseudoVFNCVT_RM_F_X_W_M4, 0x2, false }, // 589 + { PseudoVFNCVT_RM_F_X_W_MF2_MASK, PseudoVFNCVT_RM_F_X_W_MF2, 0x2, false }, // 590 + { PseudoVFNCVT_RM_F_X_W_MF4_MASK, PseudoVFNCVT_RM_F_X_W_MF4, 0x2, false }, // 591 + { PseudoVFNCVT_RM_XU_F_W_M1_MASK, PseudoVFNCVT_RM_XU_F_W_M1, 0x2, false }, // 592 + { PseudoVFNCVT_RM_XU_F_W_M2_MASK, PseudoVFNCVT_RM_XU_F_W_M2, 0x2, false }, // 593 + { PseudoVFNCVT_RM_XU_F_W_M4_MASK, PseudoVFNCVT_RM_XU_F_W_M4, 0x2, false }, // 594 + { PseudoVFNCVT_RM_XU_F_W_MF2_MASK, PseudoVFNCVT_RM_XU_F_W_MF2, 0x2, false }, // 595 + { PseudoVFNCVT_RM_XU_F_W_MF4_MASK, PseudoVFNCVT_RM_XU_F_W_MF4, 0x2, false }, // 596 + { PseudoVFNCVT_RM_XU_F_W_MF8_MASK, PseudoVFNCVT_RM_XU_F_W_MF8, 0x2, false }, // 597 + { PseudoVFNCVT_RM_X_F_W_M1_MASK, PseudoVFNCVT_RM_X_F_W_M1, 0x2, false }, // 598 + { PseudoVFNCVT_RM_X_F_W_M2_MASK, PseudoVFNCVT_RM_X_F_W_M2, 0x2, false }, // 599 + { PseudoVFNCVT_RM_X_F_W_M4_MASK, PseudoVFNCVT_RM_X_F_W_M4, 0x2, false }, // 600 + { PseudoVFNCVT_RM_X_F_W_MF2_MASK, PseudoVFNCVT_RM_X_F_W_MF2, 0x2, false }, // 601 + { PseudoVFNCVT_RM_X_F_W_MF4_MASK, PseudoVFNCVT_RM_X_F_W_MF4, 0x2, false }, // 602 + { PseudoVFNCVT_RM_X_F_W_MF8_MASK, PseudoVFNCVT_RM_X_F_W_MF8, 0x2, false }, // 603 + { PseudoVFNCVT_ROD_F_F_W_M1_MASK, PseudoVFNCVT_ROD_F_F_W_M1, 0x2, false }, // 604 + { PseudoVFNCVT_ROD_F_F_W_M2_MASK, PseudoVFNCVT_ROD_F_F_W_M2, 0x2, false }, // 605 + { PseudoVFNCVT_ROD_F_F_W_M4_MASK, PseudoVFNCVT_ROD_F_F_W_M4, 0x2, false }, // 606 + { PseudoVFNCVT_ROD_F_F_W_MF2_MASK, PseudoVFNCVT_ROD_F_F_W_MF2, 0x2, false }, // 607 + { PseudoVFNCVT_ROD_F_F_W_MF4_MASK, PseudoVFNCVT_ROD_F_F_W_MF4, 0x2, false }, // 608 + { PseudoVFNCVT_RTZ_XU_F_W_M1_MASK, PseudoVFNCVT_RTZ_XU_F_W_M1, 0x2, false }, // 609 + { PseudoVFNCVT_RTZ_XU_F_W_M2_MASK, PseudoVFNCVT_RTZ_XU_F_W_M2, 0x2, false }, // 610 + { PseudoVFNCVT_RTZ_XU_F_W_M4_MASK, PseudoVFNCVT_RTZ_XU_F_W_M4, 0x2, false }, // 611 + { PseudoVFNCVT_RTZ_XU_F_W_MF2_MASK, PseudoVFNCVT_RTZ_XU_F_W_MF2, 0x2, false }, // 612 + { PseudoVFNCVT_RTZ_XU_F_W_MF4_MASK, PseudoVFNCVT_RTZ_XU_F_W_MF4, 0x2, false }, // 613 + { PseudoVFNCVT_RTZ_XU_F_W_MF8_MASK, PseudoVFNCVT_RTZ_XU_F_W_MF8, 0x2, false }, // 614 + { PseudoVFNCVT_RTZ_X_F_W_M1_MASK, PseudoVFNCVT_RTZ_X_F_W_M1, 0x2, false }, // 615 + { PseudoVFNCVT_RTZ_X_F_W_M2_MASK, PseudoVFNCVT_RTZ_X_F_W_M2, 0x2, false }, // 616 + { PseudoVFNCVT_RTZ_X_F_W_M4_MASK, PseudoVFNCVT_RTZ_X_F_W_M4, 0x2, false }, // 617 + { PseudoVFNCVT_RTZ_X_F_W_MF2_MASK, PseudoVFNCVT_RTZ_X_F_W_MF2, 0x2, false }, // 618 + { PseudoVFNCVT_RTZ_X_F_W_MF4_MASK, PseudoVFNCVT_RTZ_X_F_W_MF4, 0x2, false }, // 619 + { PseudoVFNCVT_RTZ_X_F_W_MF8_MASK, PseudoVFNCVT_RTZ_X_F_W_MF8, 0x2, false }, // 620 + { PseudoVFNCVT_XU_F_W_M1_MASK, PseudoVFNCVT_XU_F_W_M1, 0x2, false }, // 621 + { PseudoVFNCVT_XU_F_W_M2_MASK, PseudoVFNCVT_XU_F_W_M2, 0x2, false }, // 622 + { PseudoVFNCVT_XU_F_W_M4_MASK, PseudoVFNCVT_XU_F_W_M4, 0x2, false }, // 623 + { PseudoVFNCVT_XU_F_W_MF2_MASK, PseudoVFNCVT_XU_F_W_MF2, 0x2, false }, // 624 + { PseudoVFNCVT_XU_F_W_MF4_MASK, PseudoVFNCVT_XU_F_W_MF4, 0x2, false }, // 625 + { PseudoVFNCVT_XU_F_W_MF8_MASK, PseudoVFNCVT_XU_F_W_MF8, 0x2, false }, // 626 + { PseudoVFNCVT_X_F_W_M1_MASK, PseudoVFNCVT_X_F_W_M1, 0x2, false }, // 627 + { PseudoVFNCVT_X_F_W_M2_MASK, PseudoVFNCVT_X_F_W_M2, 0x2, false }, // 628 + { PseudoVFNCVT_X_F_W_M4_MASK, PseudoVFNCVT_X_F_W_M4, 0x2, false }, // 629 + { PseudoVFNCVT_X_F_W_MF2_MASK, PseudoVFNCVT_X_F_W_MF2, 0x2, false }, // 630 + { PseudoVFNCVT_X_F_W_MF4_MASK, PseudoVFNCVT_X_F_W_MF4, 0x2, false }, // 631 + { PseudoVFNCVT_X_F_W_MF8_MASK, PseudoVFNCVT_X_F_W_MF8, 0x2, false }, // 632 + { PseudoVFNMACC_VFPR16_M1_MASK, PseudoVFNMACC_VFPR16_M1, 0x3, false }, // 633 + { PseudoVFNMACC_VFPR16_M2_MASK, PseudoVFNMACC_VFPR16_M2, 0x3, false }, // 634 + { PseudoVFNMACC_VFPR16_M4_MASK, PseudoVFNMACC_VFPR16_M4, 0x3, false }, // 635 + { PseudoVFNMACC_VFPR16_M8_MASK, PseudoVFNMACC_VFPR16_M8, 0x3, false }, // 636 + { PseudoVFNMACC_VFPR16_MF2_MASK, PseudoVFNMACC_VFPR16_MF2, 0x3, false }, // 637 + { PseudoVFNMACC_VFPR16_MF4_MASK, PseudoVFNMACC_VFPR16_MF4, 0x3, false }, // 638 + { PseudoVFNMACC_VFPR32_M1_MASK, PseudoVFNMACC_VFPR32_M1, 0x3, false }, // 639 + { PseudoVFNMACC_VFPR32_M2_MASK, PseudoVFNMACC_VFPR32_M2, 0x3, false }, // 640 + { PseudoVFNMACC_VFPR32_M4_MASK, PseudoVFNMACC_VFPR32_M4, 0x3, false }, // 641 + { PseudoVFNMACC_VFPR32_M8_MASK, PseudoVFNMACC_VFPR32_M8, 0x3, false }, // 642 + { PseudoVFNMACC_VFPR32_MF2_MASK, PseudoVFNMACC_VFPR32_MF2, 0x3, false }, // 643 + { PseudoVFNMACC_VFPR64_M1_MASK, PseudoVFNMACC_VFPR64_M1, 0x3, false }, // 644 + { PseudoVFNMACC_VFPR64_M2_MASK, PseudoVFNMACC_VFPR64_M2, 0x3, false }, // 645 + { PseudoVFNMACC_VFPR64_M4_MASK, PseudoVFNMACC_VFPR64_M4, 0x3, false }, // 646 + { PseudoVFNMACC_VFPR64_M8_MASK, PseudoVFNMACC_VFPR64_M8, 0x3, false }, // 647 + { PseudoVFNMACC_VV_M1_MASK, PseudoVFNMACC_VV_M1, 0x3, false }, // 648 + { PseudoVFNMACC_VV_M2_MASK, PseudoVFNMACC_VV_M2, 0x3, false }, // 649 + { PseudoVFNMACC_VV_M4_MASK, PseudoVFNMACC_VV_M4, 0x3, false }, // 650 + { PseudoVFNMACC_VV_M8_MASK, PseudoVFNMACC_VV_M8, 0x3, false }, // 651 + { PseudoVFNMACC_VV_MF2_MASK, PseudoVFNMACC_VV_MF2, 0x3, false }, // 652 + { PseudoVFNMACC_VV_MF4_MASK, PseudoVFNMACC_VV_MF4, 0x3, false }, // 653 + { PseudoVFNMADD_VFPR16_M1_MASK, PseudoVFNMADD_VFPR16_M1, 0x3, false }, // 654 + { PseudoVFNMADD_VFPR16_M2_MASK, PseudoVFNMADD_VFPR16_M2, 0x3, false }, // 655 + { PseudoVFNMADD_VFPR16_M4_MASK, PseudoVFNMADD_VFPR16_M4, 0x3, false }, // 656 + { PseudoVFNMADD_VFPR16_M8_MASK, PseudoVFNMADD_VFPR16_M8, 0x3, false }, // 657 + { PseudoVFNMADD_VFPR16_MF2_MASK, PseudoVFNMADD_VFPR16_MF2, 0x3, false }, // 658 + { PseudoVFNMADD_VFPR16_MF4_MASK, PseudoVFNMADD_VFPR16_MF4, 0x3, false }, // 659 + { PseudoVFNMADD_VFPR32_M1_MASK, PseudoVFNMADD_VFPR32_M1, 0x3, false }, // 660 + { PseudoVFNMADD_VFPR32_M2_MASK, PseudoVFNMADD_VFPR32_M2, 0x3, false }, // 661 + { PseudoVFNMADD_VFPR32_M4_MASK, PseudoVFNMADD_VFPR32_M4, 0x3, false }, // 662 + { PseudoVFNMADD_VFPR32_M8_MASK, PseudoVFNMADD_VFPR32_M8, 0x3, false }, // 663 + { PseudoVFNMADD_VFPR32_MF2_MASK, PseudoVFNMADD_VFPR32_MF2, 0x3, false }, // 664 + { PseudoVFNMADD_VFPR64_M1_MASK, PseudoVFNMADD_VFPR64_M1, 0x3, false }, // 665 + { PseudoVFNMADD_VFPR64_M2_MASK, PseudoVFNMADD_VFPR64_M2, 0x3, false }, // 666 + { PseudoVFNMADD_VFPR64_M4_MASK, PseudoVFNMADD_VFPR64_M4, 0x3, false }, // 667 + { PseudoVFNMADD_VFPR64_M8_MASK, PseudoVFNMADD_VFPR64_M8, 0x3, false }, // 668 + { PseudoVFNMADD_VV_M1_MASK, PseudoVFNMADD_VV_M1, 0x3, false }, // 669 + { PseudoVFNMADD_VV_M2_MASK, PseudoVFNMADD_VV_M2, 0x3, false }, // 670 + { PseudoVFNMADD_VV_M4_MASK, PseudoVFNMADD_VV_M4, 0x3, false }, // 671 + { PseudoVFNMADD_VV_M8_MASK, PseudoVFNMADD_VV_M8, 0x3, false }, // 672 + { PseudoVFNMADD_VV_MF2_MASK, PseudoVFNMADD_VV_MF2, 0x3, false }, // 673 + { PseudoVFNMADD_VV_MF4_MASK, PseudoVFNMADD_VV_MF4, 0x3, false }, // 674 + { PseudoVFNMSAC_VFPR16_M1_MASK, PseudoVFNMSAC_VFPR16_M1, 0x3, false }, // 675 + { PseudoVFNMSAC_VFPR16_M2_MASK, PseudoVFNMSAC_VFPR16_M2, 0x3, false }, // 676 + { PseudoVFNMSAC_VFPR16_M4_MASK, PseudoVFNMSAC_VFPR16_M4, 0x3, false }, // 677 + { PseudoVFNMSAC_VFPR16_M8_MASK, PseudoVFNMSAC_VFPR16_M8, 0x3, false }, // 678 + { PseudoVFNMSAC_VFPR16_MF2_MASK, PseudoVFNMSAC_VFPR16_MF2, 0x3, false }, // 679 + { PseudoVFNMSAC_VFPR16_MF4_MASK, PseudoVFNMSAC_VFPR16_MF4, 0x3, false }, // 680 + { PseudoVFNMSAC_VFPR32_M1_MASK, PseudoVFNMSAC_VFPR32_M1, 0x3, false }, // 681 + { PseudoVFNMSAC_VFPR32_M2_MASK, PseudoVFNMSAC_VFPR32_M2, 0x3, false }, // 682 + { PseudoVFNMSAC_VFPR32_M4_MASK, PseudoVFNMSAC_VFPR32_M4, 0x3, false }, // 683 + { PseudoVFNMSAC_VFPR32_M8_MASK, PseudoVFNMSAC_VFPR32_M8, 0x3, false }, // 684 + { PseudoVFNMSAC_VFPR32_MF2_MASK, PseudoVFNMSAC_VFPR32_MF2, 0x3, false }, // 685 + { PseudoVFNMSAC_VFPR64_M1_MASK, PseudoVFNMSAC_VFPR64_M1, 0x3, false }, // 686 + { PseudoVFNMSAC_VFPR64_M2_MASK, PseudoVFNMSAC_VFPR64_M2, 0x3, false }, // 687 + { PseudoVFNMSAC_VFPR64_M4_MASK, PseudoVFNMSAC_VFPR64_M4, 0x3, false }, // 688 + { PseudoVFNMSAC_VFPR64_M8_MASK, PseudoVFNMSAC_VFPR64_M8, 0x3, false }, // 689 + { PseudoVFNMSAC_VV_M1_MASK, PseudoVFNMSAC_VV_M1, 0x3, false }, // 690 + { PseudoVFNMSAC_VV_M2_MASK, PseudoVFNMSAC_VV_M2, 0x3, false }, // 691 + { PseudoVFNMSAC_VV_M4_MASK, PseudoVFNMSAC_VV_M4, 0x3, false }, // 692 + { PseudoVFNMSAC_VV_M8_MASK, PseudoVFNMSAC_VV_M8, 0x3, false }, // 693 + { PseudoVFNMSAC_VV_MF2_MASK, PseudoVFNMSAC_VV_MF2, 0x3, false }, // 694 + { PseudoVFNMSAC_VV_MF4_MASK, PseudoVFNMSAC_VV_MF4, 0x3, false }, // 695 + { PseudoVFNMSUB_VFPR16_M1_MASK, PseudoVFNMSUB_VFPR16_M1, 0x3, false }, // 696 + { PseudoVFNMSUB_VFPR16_M2_MASK, PseudoVFNMSUB_VFPR16_M2, 0x3, false }, // 697 + { PseudoVFNMSUB_VFPR16_M4_MASK, PseudoVFNMSUB_VFPR16_M4, 0x3, false }, // 698 + { PseudoVFNMSUB_VFPR16_M8_MASK, PseudoVFNMSUB_VFPR16_M8, 0x3, false }, // 699 + { PseudoVFNMSUB_VFPR16_MF2_MASK, PseudoVFNMSUB_VFPR16_MF2, 0x3, false }, // 700 + { PseudoVFNMSUB_VFPR16_MF4_MASK, PseudoVFNMSUB_VFPR16_MF4, 0x3, false }, // 701 + { PseudoVFNMSUB_VFPR32_M1_MASK, PseudoVFNMSUB_VFPR32_M1, 0x3, false }, // 702 + { PseudoVFNMSUB_VFPR32_M2_MASK, PseudoVFNMSUB_VFPR32_M2, 0x3, false }, // 703 + { PseudoVFNMSUB_VFPR32_M4_MASK, PseudoVFNMSUB_VFPR32_M4, 0x3, false }, // 704 + { PseudoVFNMSUB_VFPR32_M8_MASK, PseudoVFNMSUB_VFPR32_M8, 0x3, false }, // 705 + { PseudoVFNMSUB_VFPR32_MF2_MASK, PseudoVFNMSUB_VFPR32_MF2, 0x3, false }, // 706 + { PseudoVFNMSUB_VFPR64_M1_MASK, PseudoVFNMSUB_VFPR64_M1, 0x3, false }, // 707 + { PseudoVFNMSUB_VFPR64_M2_MASK, PseudoVFNMSUB_VFPR64_M2, 0x3, false }, // 708 + { PseudoVFNMSUB_VFPR64_M4_MASK, PseudoVFNMSUB_VFPR64_M4, 0x3, false }, // 709 + { PseudoVFNMSUB_VFPR64_M8_MASK, PseudoVFNMSUB_VFPR64_M8, 0x3, false }, // 710 + { PseudoVFNMSUB_VV_M1_MASK, PseudoVFNMSUB_VV_M1, 0x3, false }, // 711 + { PseudoVFNMSUB_VV_M2_MASK, PseudoVFNMSUB_VV_M2, 0x3, false }, // 712 + { PseudoVFNMSUB_VV_M4_MASK, PseudoVFNMSUB_VV_M4, 0x3, false }, // 713 + { PseudoVFNMSUB_VV_M8_MASK, PseudoVFNMSUB_VV_M8, 0x3, false }, // 714 + { PseudoVFNMSUB_VV_MF2_MASK, PseudoVFNMSUB_VV_MF2, 0x3, false }, // 715 + { PseudoVFNMSUB_VV_MF4_MASK, PseudoVFNMSUB_VV_MF4, 0x3, false }, // 716 + { PseudoVFNRCLIP_XU_F_QF_M1_MASK, PseudoVFNRCLIP_XU_F_QF_M1, 0x3, false }, // 717 + { PseudoVFNRCLIP_XU_F_QF_M2_MASK, PseudoVFNRCLIP_XU_F_QF_M2, 0x3, false }, // 718 + { PseudoVFNRCLIP_XU_F_QF_MF2_MASK, PseudoVFNRCLIP_XU_F_QF_MF2, 0x3, false }, // 719 + { PseudoVFNRCLIP_XU_F_QF_MF4_MASK, PseudoVFNRCLIP_XU_F_QF_MF4, 0x3, false }, // 720 + { PseudoVFNRCLIP_XU_F_QF_MF8_MASK, PseudoVFNRCLIP_XU_F_QF_MF8, 0x3, false }, // 721 + { PseudoVFNRCLIP_X_F_QF_M1_MASK, PseudoVFNRCLIP_X_F_QF_M1, 0x3, false }, // 722 + { PseudoVFNRCLIP_X_F_QF_M2_MASK, PseudoVFNRCLIP_X_F_QF_M2, 0x3, false }, // 723 + { PseudoVFNRCLIP_X_F_QF_MF2_MASK, PseudoVFNRCLIP_X_F_QF_MF2, 0x3, false }, // 724 + { PseudoVFNRCLIP_X_F_QF_MF4_MASK, PseudoVFNRCLIP_X_F_QF_MF4, 0x3, false }, // 725 + { PseudoVFNRCLIP_X_F_QF_MF8_MASK, PseudoVFNRCLIP_X_F_QF_MF8, 0x3, false }, // 726 + { PseudoVFRDIV_VFPR16_M1_E16_MASK, PseudoVFRDIV_VFPR16_M1_E16, 0x3, false }, // 727 + { PseudoVFRDIV_VFPR16_M2_E16_MASK, PseudoVFRDIV_VFPR16_M2_E16, 0x3, false }, // 728 + { PseudoVFRDIV_VFPR16_M4_E16_MASK, PseudoVFRDIV_VFPR16_M4_E16, 0x3, false }, // 729 + { PseudoVFRDIV_VFPR16_M8_E16_MASK, PseudoVFRDIV_VFPR16_M8_E16, 0x3, false }, // 730 + { PseudoVFRDIV_VFPR16_MF2_E16_MASK, PseudoVFRDIV_VFPR16_MF2_E16, 0x3, false }, // 731 + { PseudoVFRDIV_VFPR16_MF4_E16_MASK, PseudoVFRDIV_VFPR16_MF4_E16, 0x3, false }, // 732 + { PseudoVFRDIV_VFPR32_M1_E32_MASK, PseudoVFRDIV_VFPR32_M1_E32, 0x3, false }, // 733 + { PseudoVFRDIV_VFPR32_M2_E32_MASK, PseudoVFRDIV_VFPR32_M2_E32, 0x3, false }, // 734 + { PseudoVFRDIV_VFPR32_M4_E32_MASK, PseudoVFRDIV_VFPR32_M4_E32, 0x3, false }, // 735 + { PseudoVFRDIV_VFPR32_M8_E32_MASK, PseudoVFRDIV_VFPR32_M8_E32, 0x3, false }, // 736 + { PseudoVFRDIV_VFPR32_MF2_E32_MASK, PseudoVFRDIV_VFPR32_MF2_E32, 0x3, false }, // 737 + { PseudoVFRDIV_VFPR64_M1_E64_MASK, PseudoVFRDIV_VFPR64_M1_E64, 0x3, false }, // 738 + { PseudoVFRDIV_VFPR64_M2_E64_MASK, PseudoVFRDIV_VFPR64_M2_E64, 0x3, false }, // 739 + { PseudoVFRDIV_VFPR64_M4_E64_MASK, PseudoVFRDIV_VFPR64_M4_E64, 0x3, false }, // 740 + { PseudoVFRDIV_VFPR64_M8_E64_MASK, PseudoVFRDIV_VFPR64_M8_E64, 0x3, false }, // 741 + { PseudoVFREC7_V_M1_MASK, PseudoVFREC7_V_M1, 0x2, false }, // 742 + { PseudoVFREC7_V_M2_MASK, PseudoVFREC7_V_M2, 0x2, false }, // 743 + { PseudoVFREC7_V_M4_MASK, PseudoVFREC7_V_M4, 0x2, false }, // 744 + { PseudoVFREC7_V_M8_MASK, PseudoVFREC7_V_M8, 0x2, false }, // 745 + { PseudoVFREC7_V_MF2_MASK, PseudoVFREC7_V_MF2, 0x2, false }, // 746 + { PseudoVFREC7_V_MF4_MASK, PseudoVFREC7_V_MF4, 0x2, false }, // 747 + { PseudoVFREDMAX_VS_M1_E16_MASK, PseudoVFREDMAX_VS_M1_E16, 0x3, true }, // 748 + { PseudoVFREDMAX_VS_M1_E32_MASK, PseudoVFREDMAX_VS_M1_E32, 0x3, true }, // 749 + { PseudoVFREDMAX_VS_M1_E64_MASK, PseudoVFREDMAX_VS_M1_E64, 0x3, true }, // 750 + { PseudoVFREDMAX_VS_M2_E16_MASK, PseudoVFREDMAX_VS_M2_E16, 0x3, true }, // 751 + { PseudoVFREDMAX_VS_M2_E32_MASK, PseudoVFREDMAX_VS_M2_E32, 0x3, true }, // 752 + { PseudoVFREDMAX_VS_M2_E64_MASK, PseudoVFREDMAX_VS_M2_E64, 0x3, true }, // 753 + { PseudoVFREDMAX_VS_M4_E16_MASK, PseudoVFREDMAX_VS_M4_E16, 0x3, true }, // 754 + { PseudoVFREDMAX_VS_M4_E32_MASK, PseudoVFREDMAX_VS_M4_E32, 0x3, true }, // 755 + { PseudoVFREDMAX_VS_M4_E64_MASK, PseudoVFREDMAX_VS_M4_E64, 0x3, true }, // 756 + { PseudoVFREDMAX_VS_M8_E16_MASK, PseudoVFREDMAX_VS_M8_E16, 0x3, true }, // 757 + { PseudoVFREDMAX_VS_M8_E32_MASK, PseudoVFREDMAX_VS_M8_E32, 0x3, true }, // 758 + { PseudoVFREDMAX_VS_M8_E64_MASK, PseudoVFREDMAX_VS_M8_E64, 0x3, true }, // 759 + { PseudoVFREDMAX_VS_MF2_E16_MASK, PseudoVFREDMAX_VS_MF2_E16, 0x3, true }, // 760 + { PseudoVFREDMAX_VS_MF2_E32_MASK, PseudoVFREDMAX_VS_MF2_E32, 0x3, true }, // 761 + { PseudoVFREDMAX_VS_MF4_E16_MASK, PseudoVFREDMAX_VS_MF4_E16, 0x3, true }, // 762 + { PseudoVFREDMIN_VS_M1_E16_MASK, PseudoVFREDMIN_VS_M1_E16, 0x3, true }, // 763 + { PseudoVFREDMIN_VS_M1_E32_MASK, PseudoVFREDMIN_VS_M1_E32, 0x3, true }, // 764 + { PseudoVFREDMIN_VS_M1_E64_MASK, PseudoVFREDMIN_VS_M1_E64, 0x3, true }, // 765 + { PseudoVFREDMIN_VS_M2_E16_MASK, PseudoVFREDMIN_VS_M2_E16, 0x3, true }, // 766 + { PseudoVFREDMIN_VS_M2_E32_MASK, PseudoVFREDMIN_VS_M2_E32, 0x3, true }, // 767 + { PseudoVFREDMIN_VS_M2_E64_MASK, PseudoVFREDMIN_VS_M2_E64, 0x3, true }, // 768 + { PseudoVFREDMIN_VS_M4_E16_MASK, PseudoVFREDMIN_VS_M4_E16, 0x3, true }, // 769 + { PseudoVFREDMIN_VS_M4_E32_MASK, PseudoVFREDMIN_VS_M4_E32, 0x3, true }, // 770 + { PseudoVFREDMIN_VS_M4_E64_MASK, PseudoVFREDMIN_VS_M4_E64, 0x3, true }, // 771 + { PseudoVFREDMIN_VS_M8_E16_MASK, PseudoVFREDMIN_VS_M8_E16, 0x3, true }, // 772 + { PseudoVFREDMIN_VS_M8_E32_MASK, PseudoVFREDMIN_VS_M8_E32, 0x3, true }, // 773 + { PseudoVFREDMIN_VS_M8_E64_MASK, PseudoVFREDMIN_VS_M8_E64, 0x3, true }, // 774 + { PseudoVFREDMIN_VS_MF2_E16_MASK, PseudoVFREDMIN_VS_MF2_E16, 0x3, true }, // 775 + { PseudoVFREDMIN_VS_MF2_E32_MASK, PseudoVFREDMIN_VS_MF2_E32, 0x3, true }, // 776 + { PseudoVFREDMIN_VS_MF4_E16_MASK, PseudoVFREDMIN_VS_MF4_E16, 0x3, true }, // 777 + { PseudoVFREDOSUM_VS_M1_E16_MASK, PseudoVFREDOSUM_VS_M1_E16, 0x3, true }, // 778 + { PseudoVFREDOSUM_VS_M1_E32_MASK, PseudoVFREDOSUM_VS_M1_E32, 0x3, true }, // 779 + { PseudoVFREDOSUM_VS_M1_E64_MASK, PseudoVFREDOSUM_VS_M1_E64, 0x3, true }, // 780 + { PseudoVFREDOSUM_VS_M2_E16_MASK, PseudoVFREDOSUM_VS_M2_E16, 0x3, true }, // 781 + { PseudoVFREDOSUM_VS_M2_E32_MASK, PseudoVFREDOSUM_VS_M2_E32, 0x3, true }, // 782 + { PseudoVFREDOSUM_VS_M2_E64_MASK, PseudoVFREDOSUM_VS_M2_E64, 0x3, true }, // 783 + { PseudoVFREDOSUM_VS_M4_E16_MASK, PseudoVFREDOSUM_VS_M4_E16, 0x3, true }, // 784 + { PseudoVFREDOSUM_VS_M4_E32_MASK, PseudoVFREDOSUM_VS_M4_E32, 0x3, true }, // 785 + { PseudoVFREDOSUM_VS_M4_E64_MASK, PseudoVFREDOSUM_VS_M4_E64, 0x3, true }, // 786 + { PseudoVFREDOSUM_VS_M8_E16_MASK, PseudoVFREDOSUM_VS_M8_E16, 0x3, true }, // 787 + { PseudoVFREDOSUM_VS_M8_E32_MASK, PseudoVFREDOSUM_VS_M8_E32, 0x3, true }, // 788 + { PseudoVFREDOSUM_VS_M8_E64_MASK, PseudoVFREDOSUM_VS_M8_E64, 0x3, true }, // 789 + { PseudoVFREDOSUM_VS_MF2_E16_MASK, PseudoVFREDOSUM_VS_MF2_E16, 0x3, true }, // 790 + { PseudoVFREDOSUM_VS_MF2_E32_MASK, PseudoVFREDOSUM_VS_MF2_E32, 0x3, true }, // 791 + { PseudoVFREDOSUM_VS_MF4_E16_MASK, PseudoVFREDOSUM_VS_MF4_E16, 0x3, true }, // 792 + { PseudoVFREDUSUM_VS_M1_E16_MASK, PseudoVFREDUSUM_VS_M1_E16, 0x3, true }, // 793 + { PseudoVFREDUSUM_VS_M1_E32_MASK, PseudoVFREDUSUM_VS_M1_E32, 0x3, true }, // 794 + { PseudoVFREDUSUM_VS_M1_E64_MASK, PseudoVFREDUSUM_VS_M1_E64, 0x3, true }, // 795 + { PseudoVFREDUSUM_VS_M2_E16_MASK, PseudoVFREDUSUM_VS_M2_E16, 0x3, true }, // 796 + { PseudoVFREDUSUM_VS_M2_E32_MASK, PseudoVFREDUSUM_VS_M2_E32, 0x3, true }, // 797 + { PseudoVFREDUSUM_VS_M2_E64_MASK, PseudoVFREDUSUM_VS_M2_E64, 0x3, true }, // 798 + { PseudoVFREDUSUM_VS_M4_E16_MASK, PseudoVFREDUSUM_VS_M4_E16, 0x3, true }, // 799 + { PseudoVFREDUSUM_VS_M4_E32_MASK, PseudoVFREDUSUM_VS_M4_E32, 0x3, true }, // 800 + { PseudoVFREDUSUM_VS_M4_E64_MASK, PseudoVFREDUSUM_VS_M4_E64, 0x3, true }, // 801 + { PseudoVFREDUSUM_VS_M8_E16_MASK, PseudoVFREDUSUM_VS_M8_E16, 0x3, true }, // 802 + { PseudoVFREDUSUM_VS_M8_E32_MASK, PseudoVFREDUSUM_VS_M8_E32, 0x3, true }, // 803 + { PseudoVFREDUSUM_VS_M8_E64_MASK, PseudoVFREDUSUM_VS_M8_E64, 0x3, true }, // 804 + { PseudoVFREDUSUM_VS_MF2_E16_MASK, PseudoVFREDUSUM_VS_MF2_E16, 0x3, true }, // 805 + { PseudoVFREDUSUM_VS_MF2_E32_MASK, PseudoVFREDUSUM_VS_MF2_E32, 0x3, true }, // 806 + { PseudoVFREDUSUM_VS_MF4_E16_MASK, PseudoVFREDUSUM_VS_MF4_E16, 0x3, true }, // 807 + { PseudoVFRSQRT7_V_M1_MASK, PseudoVFRSQRT7_V_M1, 0x2, false }, // 808 + { PseudoVFRSQRT7_V_M2_MASK, PseudoVFRSQRT7_V_M2, 0x2, false }, // 809 + { PseudoVFRSQRT7_V_M4_MASK, PseudoVFRSQRT7_V_M4, 0x2, false }, // 810 + { PseudoVFRSQRT7_V_M8_MASK, PseudoVFRSQRT7_V_M8, 0x2, false }, // 811 + { PseudoVFRSQRT7_V_MF2_MASK, PseudoVFRSQRT7_V_MF2, 0x2, false }, // 812 + { PseudoVFRSQRT7_V_MF4_MASK, PseudoVFRSQRT7_V_MF4, 0x2, false }, // 813 + { PseudoVFRSUB_VFPR16_M1_MASK, PseudoVFRSUB_VFPR16_M1, 0x3, false }, // 814 + { PseudoVFRSUB_VFPR16_M2_MASK, PseudoVFRSUB_VFPR16_M2, 0x3, false }, // 815 + { PseudoVFRSUB_VFPR16_M4_MASK, PseudoVFRSUB_VFPR16_M4, 0x3, false }, // 816 + { PseudoVFRSUB_VFPR16_M8_MASK, PseudoVFRSUB_VFPR16_M8, 0x3, false }, // 817 + { PseudoVFRSUB_VFPR16_MF2_MASK, PseudoVFRSUB_VFPR16_MF2, 0x3, false }, // 818 + { PseudoVFRSUB_VFPR16_MF4_MASK, PseudoVFRSUB_VFPR16_MF4, 0x3, false }, // 819 + { PseudoVFRSUB_VFPR32_M1_MASK, PseudoVFRSUB_VFPR32_M1, 0x3, false }, // 820 + { PseudoVFRSUB_VFPR32_M2_MASK, PseudoVFRSUB_VFPR32_M2, 0x3, false }, // 821 + { PseudoVFRSUB_VFPR32_M4_MASK, PseudoVFRSUB_VFPR32_M4, 0x3, false }, // 822 + { PseudoVFRSUB_VFPR32_M8_MASK, PseudoVFRSUB_VFPR32_M8, 0x3, false }, // 823 + { PseudoVFRSUB_VFPR32_MF2_MASK, PseudoVFRSUB_VFPR32_MF2, 0x3, false }, // 824 + { PseudoVFRSUB_VFPR64_M1_MASK, PseudoVFRSUB_VFPR64_M1, 0x3, false }, // 825 + { PseudoVFRSUB_VFPR64_M2_MASK, PseudoVFRSUB_VFPR64_M2, 0x3, false }, // 826 + { PseudoVFRSUB_VFPR64_M4_MASK, PseudoVFRSUB_VFPR64_M4, 0x3, false }, // 827 + { PseudoVFRSUB_VFPR64_M8_MASK, PseudoVFRSUB_VFPR64_M8, 0x3, false }, // 828 + { PseudoVFSGNJN_VFPR16_M1_MASK, PseudoVFSGNJN_VFPR16_M1, 0x3, false }, // 829 + { PseudoVFSGNJN_VFPR16_M2_MASK, PseudoVFSGNJN_VFPR16_M2, 0x3, false }, // 830 + { PseudoVFSGNJN_VFPR16_M4_MASK, PseudoVFSGNJN_VFPR16_M4, 0x3, false }, // 831 + { PseudoVFSGNJN_VFPR16_M8_MASK, PseudoVFSGNJN_VFPR16_M8, 0x3, false }, // 832 + { PseudoVFSGNJN_VFPR16_MF2_MASK, PseudoVFSGNJN_VFPR16_MF2, 0x3, false }, // 833 + { PseudoVFSGNJN_VFPR16_MF4_MASK, PseudoVFSGNJN_VFPR16_MF4, 0x3, false }, // 834 + { PseudoVFSGNJN_VFPR32_M1_MASK, PseudoVFSGNJN_VFPR32_M1, 0x3, false }, // 835 + { PseudoVFSGNJN_VFPR32_M2_MASK, PseudoVFSGNJN_VFPR32_M2, 0x3, false }, // 836 + { PseudoVFSGNJN_VFPR32_M4_MASK, PseudoVFSGNJN_VFPR32_M4, 0x3, false }, // 837 + { PseudoVFSGNJN_VFPR32_M8_MASK, PseudoVFSGNJN_VFPR32_M8, 0x3, false }, // 838 + { PseudoVFSGNJN_VFPR32_MF2_MASK, PseudoVFSGNJN_VFPR32_MF2, 0x3, false }, // 839 + { PseudoVFSGNJN_VFPR64_M1_MASK, PseudoVFSGNJN_VFPR64_M1, 0x3, false }, // 840 + { PseudoVFSGNJN_VFPR64_M2_MASK, PseudoVFSGNJN_VFPR64_M2, 0x3, false }, // 841 + { PseudoVFSGNJN_VFPR64_M4_MASK, PseudoVFSGNJN_VFPR64_M4, 0x3, false }, // 842 + { PseudoVFSGNJN_VFPR64_M8_MASK, PseudoVFSGNJN_VFPR64_M8, 0x3, false }, // 843 + { PseudoVFSGNJN_VV_M1_MASK, PseudoVFSGNJN_VV_M1, 0x3, false }, // 844 + { PseudoVFSGNJN_VV_M2_MASK, PseudoVFSGNJN_VV_M2, 0x3, false }, // 845 + { PseudoVFSGNJN_VV_M4_MASK, PseudoVFSGNJN_VV_M4, 0x3, false }, // 846 + { PseudoVFSGNJN_VV_M8_MASK, PseudoVFSGNJN_VV_M8, 0x3, false }, // 847 + { PseudoVFSGNJN_VV_MF2_MASK, PseudoVFSGNJN_VV_MF2, 0x3, false }, // 848 + { PseudoVFSGNJN_VV_MF4_MASK, PseudoVFSGNJN_VV_MF4, 0x3, false }, // 849 + { PseudoVFSGNJX_VFPR16_M1_MASK, PseudoVFSGNJX_VFPR16_M1, 0x3, false }, // 850 + { PseudoVFSGNJX_VFPR16_M2_MASK, PseudoVFSGNJX_VFPR16_M2, 0x3, false }, // 851 + { PseudoVFSGNJX_VFPR16_M4_MASK, PseudoVFSGNJX_VFPR16_M4, 0x3, false }, // 852 + { PseudoVFSGNJX_VFPR16_M8_MASK, PseudoVFSGNJX_VFPR16_M8, 0x3, false }, // 853 + { PseudoVFSGNJX_VFPR16_MF2_MASK, PseudoVFSGNJX_VFPR16_MF2, 0x3, false }, // 854 + { PseudoVFSGNJX_VFPR16_MF4_MASK, PseudoVFSGNJX_VFPR16_MF4, 0x3, false }, // 855 + { PseudoVFSGNJX_VFPR32_M1_MASK, PseudoVFSGNJX_VFPR32_M1, 0x3, false }, // 856 + { PseudoVFSGNJX_VFPR32_M2_MASK, PseudoVFSGNJX_VFPR32_M2, 0x3, false }, // 857 + { PseudoVFSGNJX_VFPR32_M4_MASK, PseudoVFSGNJX_VFPR32_M4, 0x3, false }, // 858 + { PseudoVFSGNJX_VFPR32_M8_MASK, PseudoVFSGNJX_VFPR32_M8, 0x3, false }, // 859 + { PseudoVFSGNJX_VFPR32_MF2_MASK, PseudoVFSGNJX_VFPR32_MF2, 0x3, false }, // 860 + { PseudoVFSGNJX_VFPR64_M1_MASK, PseudoVFSGNJX_VFPR64_M1, 0x3, false }, // 861 + { PseudoVFSGNJX_VFPR64_M2_MASK, PseudoVFSGNJX_VFPR64_M2, 0x3, false }, // 862 + { PseudoVFSGNJX_VFPR64_M4_MASK, PseudoVFSGNJX_VFPR64_M4, 0x3, false }, // 863 + { PseudoVFSGNJX_VFPR64_M8_MASK, PseudoVFSGNJX_VFPR64_M8, 0x3, false }, // 864 + { PseudoVFSGNJX_VV_M1_MASK, PseudoVFSGNJX_VV_M1, 0x3, false }, // 865 + { PseudoVFSGNJX_VV_M2_MASK, PseudoVFSGNJX_VV_M2, 0x3, false }, // 866 + { PseudoVFSGNJX_VV_M4_MASK, PseudoVFSGNJX_VV_M4, 0x3, false }, // 867 + { PseudoVFSGNJX_VV_M8_MASK, PseudoVFSGNJX_VV_M8, 0x3, false }, // 868 + { PseudoVFSGNJX_VV_MF2_MASK, PseudoVFSGNJX_VV_MF2, 0x3, false }, // 869 + { PseudoVFSGNJX_VV_MF4_MASK, PseudoVFSGNJX_VV_MF4, 0x3, false }, // 870 + { PseudoVFSGNJ_VFPR16_M1_MASK, PseudoVFSGNJ_VFPR16_M1, 0x3, false }, // 871 + { PseudoVFSGNJ_VFPR16_M2_MASK, PseudoVFSGNJ_VFPR16_M2, 0x3, false }, // 872 + { PseudoVFSGNJ_VFPR16_M4_MASK, PseudoVFSGNJ_VFPR16_M4, 0x3, false }, // 873 + { PseudoVFSGNJ_VFPR16_M8_MASK, PseudoVFSGNJ_VFPR16_M8, 0x3, false }, // 874 + { PseudoVFSGNJ_VFPR16_MF2_MASK, PseudoVFSGNJ_VFPR16_MF2, 0x3, false }, // 875 + { PseudoVFSGNJ_VFPR16_MF4_MASK, PseudoVFSGNJ_VFPR16_MF4, 0x3, false }, // 876 + { PseudoVFSGNJ_VFPR32_M1_MASK, PseudoVFSGNJ_VFPR32_M1, 0x3, false }, // 877 + { PseudoVFSGNJ_VFPR32_M2_MASK, PseudoVFSGNJ_VFPR32_M2, 0x3, false }, // 878 + { PseudoVFSGNJ_VFPR32_M4_MASK, PseudoVFSGNJ_VFPR32_M4, 0x3, false }, // 879 + { PseudoVFSGNJ_VFPR32_M8_MASK, PseudoVFSGNJ_VFPR32_M8, 0x3, false }, // 880 + { PseudoVFSGNJ_VFPR32_MF2_MASK, PseudoVFSGNJ_VFPR32_MF2, 0x3, false }, // 881 + { PseudoVFSGNJ_VFPR64_M1_MASK, PseudoVFSGNJ_VFPR64_M1, 0x3, false }, // 882 + { PseudoVFSGNJ_VFPR64_M2_MASK, PseudoVFSGNJ_VFPR64_M2, 0x3, false }, // 883 + { PseudoVFSGNJ_VFPR64_M4_MASK, PseudoVFSGNJ_VFPR64_M4, 0x3, false }, // 884 + { PseudoVFSGNJ_VFPR64_M8_MASK, PseudoVFSGNJ_VFPR64_M8, 0x3, false }, // 885 + { PseudoVFSGNJ_VV_M1_MASK, PseudoVFSGNJ_VV_M1, 0x3, false }, // 886 + { PseudoVFSGNJ_VV_M2_MASK, PseudoVFSGNJ_VV_M2, 0x3, false }, // 887 + { PseudoVFSGNJ_VV_M4_MASK, PseudoVFSGNJ_VV_M4, 0x3, false }, // 888 + { PseudoVFSGNJ_VV_M8_MASK, PseudoVFSGNJ_VV_M8, 0x3, false }, // 889 + { PseudoVFSGNJ_VV_MF2_MASK, PseudoVFSGNJ_VV_MF2, 0x3, false }, // 890 + { PseudoVFSGNJ_VV_MF4_MASK, PseudoVFSGNJ_VV_MF4, 0x3, false }, // 891 + { PseudoVFSLIDE1DOWN_VFPR16_M1_MASK, PseudoVFSLIDE1DOWN_VFPR16_M1, 0x3, false }, // 892 + { PseudoVFSLIDE1DOWN_VFPR16_M2_MASK, PseudoVFSLIDE1DOWN_VFPR16_M2, 0x3, false }, // 893 + { PseudoVFSLIDE1DOWN_VFPR16_M4_MASK, PseudoVFSLIDE1DOWN_VFPR16_M4, 0x3, false }, // 894 + { PseudoVFSLIDE1DOWN_VFPR16_M8_MASK, PseudoVFSLIDE1DOWN_VFPR16_M8, 0x3, false }, // 895 + { PseudoVFSLIDE1DOWN_VFPR16_MF2_MASK, PseudoVFSLIDE1DOWN_VFPR16_MF2, 0x3, false }, // 896 + { PseudoVFSLIDE1DOWN_VFPR16_MF4_MASK, PseudoVFSLIDE1DOWN_VFPR16_MF4, 0x3, false }, // 897 + { PseudoVFSLIDE1DOWN_VFPR32_M1_MASK, PseudoVFSLIDE1DOWN_VFPR32_M1, 0x3, false }, // 898 + { PseudoVFSLIDE1DOWN_VFPR32_M2_MASK, PseudoVFSLIDE1DOWN_VFPR32_M2, 0x3, false }, // 899 + { PseudoVFSLIDE1DOWN_VFPR32_M4_MASK, PseudoVFSLIDE1DOWN_VFPR32_M4, 0x3, false }, // 900 + { PseudoVFSLIDE1DOWN_VFPR32_M8_MASK, PseudoVFSLIDE1DOWN_VFPR32_M8, 0x3, false }, // 901 + { PseudoVFSLIDE1DOWN_VFPR32_MF2_MASK, PseudoVFSLIDE1DOWN_VFPR32_MF2, 0x3, false }, // 902 + { PseudoVFSLIDE1DOWN_VFPR64_M1_MASK, PseudoVFSLIDE1DOWN_VFPR64_M1, 0x3, false }, // 903 + { PseudoVFSLIDE1DOWN_VFPR64_M2_MASK, PseudoVFSLIDE1DOWN_VFPR64_M2, 0x3, false }, // 904 + { PseudoVFSLIDE1DOWN_VFPR64_M4_MASK, PseudoVFSLIDE1DOWN_VFPR64_M4, 0x3, false }, // 905 + { PseudoVFSLIDE1DOWN_VFPR64_M8_MASK, PseudoVFSLIDE1DOWN_VFPR64_M8, 0x3, false }, // 906 + { PseudoVFSLIDE1UP_VFPR16_M1_MASK, PseudoVFSLIDE1UP_VFPR16_M1, 0x3, false }, // 907 + { PseudoVFSLIDE1UP_VFPR16_M2_MASK, PseudoVFSLIDE1UP_VFPR16_M2, 0x3, false }, // 908 + { PseudoVFSLIDE1UP_VFPR16_M4_MASK, PseudoVFSLIDE1UP_VFPR16_M4, 0x3, false }, // 909 + { PseudoVFSLIDE1UP_VFPR16_M8_MASK, PseudoVFSLIDE1UP_VFPR16_M8, 0x3, false }, // 910 + { PseudoVFSLIDE1UP_VFPR16_MF2_MASK, PseudoVFSLIDE1UP_VFPR16_MF2, 0x3, false }, // 911 + { PseudoVFSLIDE1UP_VFPR16_MF4_MASK, PseudoVFSLIDE1UP_VFPR16_MF4, 0x3, false }, // 912 + { PseudoVFSLIDE1UP_VFPR32_M1_MASK, PseudoVFSLIDE1UP_VFPR32_M1, 0x3, false }, // 913 + { PseudoVFSLIDE1UP_VFPR32_M2_MASK, PseudoVFSLIDE1UP_VFPR32_M2, 0x3, false }, // 914 + { PseudoVFSLIDE1UP_VFPR32_M4_MASK, PseudoVFSLIDE1UP_VFPR32_M4, 0x3, false }, // 915 + { PseudoVFSLIDE1UP_VFPR32_M8_MASK, PseudoVFSLIDE1UP_VFPR32_M8, 0x3, false }, // 916 + { PseudoVFSLIDE1UP_VFPR32_MF2_MASK, PseudoVFSLIDE1UP_VFPR32_MF2, 0x3, false }, // 917 + { PseudoVFSLIDE1UP_VFPR64_M1_MASK, PseudoVFSLIDE1UP_VFPR64_M1, 0x3, false }, // 918 + { PseudoVFSLIDE1UP_VFPR64_M2_MASK, PseudoVFSLIDE1UP_VFPR64_M2, 0x3, false }, // 919 + { PseudoVFSLIDE1UP_VFPR64_M4_MASK, PseudoVFSLIDE1UP_VFPR64_M4, 0x3, false }, // 920 + { PseudoVFSLIDE1UP_VFPR64_M8_MASK, PseudoVFSLIDE1UP_VFPR64_M8, 0x3, false }, // 921 + { PseudoVFSQRT_V_M1_E16_MASK, PseudoVFSQRT_V_M1_E16, 0x2, false }, // 922 + { PseudoVFSQRT_V_M1_E32_MASK, PseudoVFSQRT_V_M1_E32, 0x2, false }, // 923 + { PseudoVFSQRT_V_M1_E64_MASK, PseudoVFSQRT_V_M1_E64, 0x2, false }, // 924 + { PseudoVFSQRT_V_M2_E16_MASK, PseudoVFSQRT_V_M2_E16, 0x2, false }, // 925 + { PseudoVFSQRT_V_M2_E32_MASK, PseudoVFSQRT_V_M2_E32, 0x2, false }, // 926 + { PseudoVFSQRT_V_M2_E64_MASK, PseudoVFSQRT_V_M2_E64, 0x2, false }, // 927 + { PseudoVFSQRT_V_M4_E16_MASK, PseudoVFSQRT_V_M4_E16, 0x2, false }, // 928 + { PseudoVFSQRT_V_M4_E32_MASK, PseudoVFSQRT_V_M4_E32, 0x2, false }, // 929 + { PseudoVFSQRT_V_M4_E64_MASK, PseudoVFSQRT_V_M4_E64, 0x2, false }, // 930 + { PseudoVFSQRT_V_M8_E16_MASK, PseudoVFSQRT_V_M8_E16, 0x2, false }, // 931 + { PseudoVFSQRT_V_M8_E32_MASK, PseudoVFSQRT_V_M8_E32, 0x2, false }, // 932 + { PseudoVFSQRT_V_M8_E64_MASK, PseudoVFSQRT_V_M8_E64, 0x2, false }, // 933 + { PseudoVFSQRT_V_MF2_E16_MASK, PseudoVFSQRT_V_MF2_E16, 0x2, false }, // 934 + { PseudoVFSQRT_V_MF2_E32_MASK, PseudoVFSQRT_V_MF2_E32, 0x2, false }, // 935 + { PseudoVFSQRT_V_MF4_E16_MASK, PseudoVFSQRT_V_MF4_E16, 0x2, false }, // 936 + { PseudoVFSUB_VFPR16_M1_MASK, PseudoVFSUB_VFPR16_M1, 0x3, false }, // 937 + { PseudoVFSUB_VFPR16_M2_MASK, PseudoVFSUB_VFPR16_M2, 0x3, false }, // 938 + { PseudoVFSUB_VFPR16_M4_MASK, PseudoVFSUB_VFPR16_M4, 0x3, false }, // 939 + { PseudoVFSUB_VFPR16_M8_MASK, PseudoVFSUB_VFPR16_M8, 0x3, false }, // 940 + { PseudoVFSUB_VFPR16_MF2_MASK, PseudoVFSUB_VFPR16_MF2, 0x3, false }, // 941 + { PseudoVFSUB_VFPR16_MF4_MASK, PseudoVFSUB_VFPR16_MF4, 0x3, false }, // 942 + { PseudoVFSUB_VFPR32_M1_MASK, PseudoVFSUB_VFPR32_M1, 0x3, false }, // 943 + { PseudoVFSUB_VFPR32_M2_MASK, PseudoVFSUB_VFPR32_M2, 0x3, false }, // 944 + { PseudoVFSUB_VFPR32_M4_MASK, PseudoVFSUB_VFPR32_M4, 0x3, false }, // 945 + { PseudoVFSUB_VFPR32_M8_MASK, PseudoVFSUB_VFPR32_M8, 0x3, false }, // 946 + { PseudoVFSUB_VFPR32_MF2_MASK, PseudoVFSUB_VFPR32_MF2, 0x3, false }, // 947 + { PseudoVFSUB_VFPR64_M1_MASK, PseudoVFSUB_VFPR64_M1, 0x3, false }, // 948 + { PseudoVFSUB_VFPR64_M2_MASK, PseudoVFSUB_VFPR64_M2, 0x3, false }, // 949 + { PseudoVFSUB_VFPR64_M4_MASK, PseudoVFSUB_VFPR64_M4, 0x3, false }, // 950 + { PseudoVFSUB_VFPR64_M8_MASK, PseudoVFSUB_VFPR64_M8, 0x3, false }, // 951 + { PseudoVFSUB_VV_M1_MASK, PseudoVFSUB_VV_M1, 0x3, false }, // 952 + { PseudoVFSUB_VV_M2_MASK, PseudoVFSUB_VV_M2, 0x3, false }, // 953 + { PseudoVFSUB_VV_M4_MASK, PseudoVFSUB_VV_M4, 0x3, false }, // 954 + { PseudoVFSUB_VV_M8_MASK, PseudoVFSUB_VV_M8, 0x3, false }, // 955 + { PseudoVFSUB_VV_MF2_MASK, PseudoVFSUB_VV_MF2, 0x3, false }, // 956 + { PseudoVFSUB_VV_MF4_MASK, PseudoVFSUB_VV_MF4, 0x3, false }, // 957 + { PseudoVFWADD_VFPR16_M1_MASK, PseudoVFWADD_VFPR16_M1, 0x3, false }, // 958 + { PseudoVFWADD_VFPR16_M2_MASK, PseudoVFWADD_VFPR16_M2, 0x3, false }, // 959 + { PseudoVFWADD_VFPR16_M4_MASK, PseudoVFWADD_VFPR16_M4, 0x3, false }, // 960 + { PseudoVFWADD_VFPR16_MF2_MASK, PseudoVFWADD_VFPR16_MF2, 0x3, false }, // 961 + { PseudoVFWADD_VFPR16_MF4_MASK, PseudoVFWADD_VFPR16_MF4, 0x3, false }, // 962 + { PseudoVFWADD_VFPR32_M1_MASK, PseudoVFWADD_VFPR32_M1, 0x3, false }, // 963 + { PseudoVFWADD_VFPR32_M2_MASK, PseudoVFWADD_VFPR32_M2, 0x3, false }, // 964 + { PseudoVFWADD_VFPR32_M4_MASK, PseudoVFWADD_VFPR32_M4, 0x3, false }, // 965 + { PseudoVFWADD_VFPR32_MF2_MASK, PseudoVFWADD_VFPR32_MF2, 0x3, false }, // 966 + { PseudoVFWADD_VV_M1_MASK, PseudoVFWADD_VV_M1, 0x3, false }, // 967 + { PseudoVFWADD_VV_M2_MASK, PseudoVFWADD_VV_M2, 0x3, false }, // 968 + { PseudoVFWADD_VV_M4_MASK, PseudoVFWADD_VV_M4, 0x3, false }, // 969 + { PseudoVFWADD_VV_MF2_MASK, PseudoVFWADD_VV_MF2, 0x3, false }, // 970 + { PseudoVFWADD_VV_MF4_MASK, PseudoVFWADD_VV_MF4, 0x3, false }, // 971 + { PseudoVFWADD_WFPR16_M1_MASK, PseudoVFWADD_WFPR16_M1, 0x3, false }, // 972 + { PseudoVFWADD_WFPR16_M2_MASK, PseudoVFWADD_WFPR16_M2, 0x3, false }, // 973 + { PseudoVFWADD_WFPR16_M4_MASK, PseudoVFWADD_WFPR16_M4, 0x3, false }, // 974 + { PseudoVFWADD_WFPR16_MF2_MASK, PseudoVFWADD_WFPR16_MF2, 0x3, false }, // 975 + { PseudoVFWADD_WFPR16_MF4_MASK, PseudoVFWADD_WFPR16_MF4, 0x3, false }, // 976 + { PseudoVFWADD_WFPR32_M1_MASK, PseudoVFWADD_WFPR32_M1, 0x3, false }, // 977 + { PseudoVFWADD_WFPR32_M2_MASK, PseudoVFWADD_WFPR32_M2, 0x3, false }, // 978 + { PseudoVFWADD_WFPR32_M4_MASK, PseudoVFWADD_WFPR32_M4, 0x3, false }, // 979 + { PseudoVFWADD_WFPR32_MF2_MASK, PseudoVFWADD_WFPR32_MF2, 0x3, false }, // 980 + { PseudoVFWADD_WV_M1_MASK, PseudoVFWADD_WV_M1, 0x3, false }, // 981 + { PseudoVFWADD_WV_M2_MASK, PseudoVFWADD_WV_M2, 0x3, false }, // 982 + { PseudoVFWADD_WV_M4_MASK, PseudoVFWADD_WV_M4, 0x3, false }, // 983 + { PseudoVFWADD_WV_MF2_MASK, PseudoVFWADD_WV_MF2, 0x3, false }, // 984 + { PseudoVFWADD_WV_MF4_MASK, PseudoVFWADD_WV_MF4, 0x3, false }, // 985 + { PseudoVFWCVTBF16_F_F_V_M1_MASK, PseudoVFWCVTBF16_F_F_V_M1, 0x2, false }, // 986 + { PseudoVFWCVTBF16_F_F_V_M2_MASK, PseudoVFWCVTBF16_F_F_V_M2, 0x2, false }, // 987 + { PseudoVFWCVTBF16_F_F_V_M4_MASK, PseudoVFWCVTBF16_F_F_V_M4, 0x2, false }, // 988 + { PseudoVFWCVTBF16_F_F_V_MF2_MASK, PseudoVFWCVTBF16_F_F_V_MF2, 0x2, false }, // 989 + { PseudoVFWCVTBF16_F_F_V_MF4_MASK, PseudoVFWCVTBF16_F_F_V_MF4, 0x2, false }, // 990 + { PseudoVFWCVT_F_F_V_M1_MASK, PseudoVFWCVT_F_F_V_M1, 0x2, false }, // 991 + { PseudoVFWCVT_F_F_V_M2_MASK, PseudoVFWCVT_F_F_V_M2, 0x2, false }, // 992 + { PseudoVFWCVT_F_F_V_M4_MASK, PseudoVFWCVT_F_F_V_M4, 0x2, false }, // 993 + { PseudoVFWCVT_F_F_V_MF2_MASK, PseudoVFWCVT_F_F_V_MF2, 0x2, false }, // 994 + { PseudoVFWCVT_F_F_V_MF4_MASK, PseudoVFWCVT_F_F_V_MF4, 0x2, false }, // 995 + { PseudoVFWCVT_F_XU_V_M1_MASK, PseudoVFWCVT_F_XU_V_M1, 0x2, false }, // 996 + { PseudoVFWCVT_F_XU_V_M2_MASK, PseudoVFWCVT_F_XU_V_M2, 0x2, false }, // 997 + { PseudoVFWCVT_F_XU_V_M4_MASK, PseudoVFWCVT_F_XU_V_M4, 0x2, false }, // 998 + { PseudoVFWCVT_F_XU_V_MF2_MASK, PseudoVFWCVT_F_XU_V_MF2, 0x2, false }, // 999 + { PseudoVFWCVT_F_XU_V_MF4_MASK, PseudoVFWCVT_F_XU_V_MF4, 0x2, false }, // 1000 + { PseudoVFWCVT_F_XU_V_MF8_MASK, PseudoVFWCVT_F_XU_V_MF8, 0x2, false }, // 1001 + { PseudoVFWCVT_F_X_V_M1_MASK, PseudoVFWCVT_F_X_V_M1, 0x2, false }, // 1002 + { PseudoVFWCVT_F_X_V_M2_MASK, PseudoVFWCVT_F_X_V_M2, 0x2, false }, // 1003 + { PseudoVFWCVT_F_X_V_M4_MASK, PseudoVFWCVT_F_X_V_M4, 0x2, false }, // 1004 + { PseudoVFWCVT_F_X_V_MF2_MASK, PseudoVFWCVT_F_X_V_MF2, 0x2, false }, // 1005 + { PseudoVFWCVT_F_X_V_MF4_MASK, PseudoVFWCVT_F_X_V_MF4, 0x2, false }, // 1006 + { PseudoVFWCVT_F_X_V_MF8_MASK, PseudoVFWCVT_F_X_V_MF8, 0x2, false }, // 1007 + { PseudoVFWCVT_RM_XU_F_V_M1_MASK, PseudoVFWCVT_RM_XU_F_V_M1, 0x2, false }, // 1008 + { PseudoVFWCVT_RM_XU_F_V_M2_MASK, PseudoVFWCVT_RM_XU_F_V_M2, 0x2, false }, // 1009 + { PseudoVFWCVT_RM_XU_F_V_M4_MASK, PseudoVFWCVT_RM_XU_F_V_M4, 0x2, false }, // 1010 + { PseudoVFWCVT_RM_XU_F_V_MF2_MASK, PseudoVFWCVT_RM_XU_F_V_MF2, 0x2, false }, // 1011 + { PseudoVFWCVT_RM_XU_F_V_MF4_MASK, PseudoVFWCVT_RM_XU_F_V_MF4, 0x2, false }, // 1012 + { PseudoVFWCVT_RM_X_F_V_M1_MASK, PseudoVFWCVT_RM_X_F_V_M1, 0x2, false }, // 1013 + { PseudoVFWCVT_RM_X_F_V_M2_MASK, PseudoVFWCVT_RM_X_F_V_M2, 0x2, false }, // 1014 + { PseudoVFWCVT_RM_X_F_V_M4_MASK, PseudoVFWCVT_RM_X_F_V_M4, 0x2, false }, // 1015 + { PseudoVFWCVT_RM_X_F_V_MF2_MASK, PseudoVFWCVT_RM_X_F_V_MF2, 0x2, false }, // 1016 + { PseudoVFWCVT_RM_X_F_V_MF4_MASK, PseudoVFWCVT_RM_X_F_V_MF4, 0x2, false }, // 1017 + { PseudoVFWCVT_RTZ_XU_F_V_M1_MASK, PseudoVFWCVT_RTZ_XU_F_V_M1, 0x2, false }, // 1018 + { PseudoVFWCVT_RTZ_XU_F_V_M2_MASK, PseudoVFWCVT_RTZ_XU_F_V_M2, 0x2, false }, // 1019 + { PseudoVFWCVT_RTZ_XU_F_V_M4_MASK, PseudoVFWCVT_RTZ_XU_F_V_M4, 0x2, false }, // 1020 + { PseudoVFWCVT_RTZ_XU_F_V_MF2_MASK, PseudoVFWCVT_RTZ_XU_F_V_MF2, 0x2, false }, // 1021 + { PseudoVFWCVT_RTZ_XU_F_V_MF4_MASK, PseudoVFWCVT_RTZ_XU_F_V_MF4, 0x2, false }, // 1022 + { PseudoVFWCVT_RTZ_X_F_V_M1_MASK, PseudoVFWCVT_RTZ_X_F_V_M1, 0x2, false }, // 1023 + { PseudoVFWCVT_RTZ_X_F_V_M2_MASK, PseudoVFWCVT_RTZ_X_F_V_M2, 0x2, false }, // 1024 + { PseudoVFWCVT_RTZ_X_F_V_M4_MASK, PseudoVFWCVT_RTZ_X_F_V_M4, 0x2, false }, // 1025 + { PseudoVFWCVT_RTZ_X_F_V_MF2_MASK, PseudoVFWCVT_RTZ_X_F_V_MF2, 0x2, false }, // 1026 + { PseudoVFWCVT_RTZ_X_F_V_MF4_MASK, PseudoVFWCVT_RTZ_X_F_V_MF4, 0x2, false }, // 1027 + { PseudoVFWCVT_XU_F_V_M1_MASK, PseudoVFWCVT_XU_F_V_M1, 0x2, false }, // 1028 + { PseudoVFWCVT_XU_F_V_M2_MASK, PseudoVFWCVT_XU_F_V_M2, 0x2, false }, // 1029 + { PseudoVFWCVT_XU_F_V_M4_MASK, PseudoVFWCVT_XU_F_V_M4, 0x2, false }, // 1030 + { PseudoVFWCVT_XU_F_V_MF2_MASK, PseudoVFWCVT_XU_F_V_MF2, 0x2, false }, // 1031 + { PseudoVFWCVT_XU_F_V_MF4_MASK, PseudoVFWCVT_XU_F_V_MF4, 0x2, false }, // 1032 + { PseudoVFWCVT_X_F_V_M1_MASK, PseudoVFWCVT_X_F_V_M1, 0x2, false }, // 1033 + { PseudoVFWCVT_X_F_V_M2_MASK, PseudoVFWCVT_X_F_V_M2, 0x2, false }, // 1034 + { PseudoVFWCVT_X_F_V_M4_MASK, PseudoVFWCVT_X_F_V_M4, 0x2, false }, // 1035 + { PseudoVFWCVT_X_F_V_MF2_MASK, PseudoVFWCVT_X_F_V_MF2, 0x2, false }, // 1036 + { PseudoVFWCVT_X_F_V_MF4_MASK, PseudoVFWCVT_X_F_V_MF4, 0x2, false }, // 1037 + { PseudoVFWMACCBF16_VFPR16_M1_MASK, PseudoVFWMACCBF16_VFPR16_M1, 0x3, false }, // 1038 + { PseudoVFWMACCBF16_VFPR16_M2_MASK, PseudoVFWMACCBF16_VFPR16_M2, 0x3, false }, // 1039 + { PseudoVFWMACCBF16_VFPR16_M4_MASK, PseudoVFWMACCBF16_VFPR16_M4, 0x3, false }, // 1040 + { PseudoVFWMACCBF16_VFPR16_MF2_MASK, PseudoVFWMACCBF16_VFPR16_MF2, 0x3, false }, // 1041 + { PseudoVFWMACCBF16_VFPR16_MF4_MASK, PseudoVFWMACCBF16_VFPR16_MF4, 0x3, false }, // 1042 + { PseudoVFWMACCBF16_VV_M1_MASK, PseudoVFWMACCBF16_VV_M1, 0x3, false }, // 1043 + { PseudoVFWMACCBF16_VV_M2_MASK, PseudoVFWMACCBF16_VV_M2, 0x3, false }, // 1044 + { PseudoVFWMACCBF16_VV_M4_MASK, PseudoVFWMACCBF16_VV_M4, 0x3, false }, // 1045 + { PseudoVFWMACCBF16_VV_MF2_MASK, PseudoVFWMACCBF16_VV_MF2, 0x3, false }, // 1046 + { PseudoVFWMACCBF16_VV_MF4_MASK, PseudoVFWMACCBF16_VV_MF4, 0x3, false }, // 1047 + { PseudoVFWMACC_VFPR16_M1_MASK, PseudoVFWMACC_VFPR16_M1, 0x3, false }, // 1048 + { PseudoVFWMACC_VFPR16_M2_MASK, PseudoVFWMACC_VFPR16_M2, 0x3, false }, // 1049 + { PseudoVFWMACC_VFPR16_M4_MASK, PseudoVFWMACC_VFPR16_M4, 0x3, false }, // 1050 + { PseudoVFWMACC_VFPR16_MF2_MASK, PseudoVFWMACC_VFPR16_MF2, 0x3, false }, // 1051 + { PseudoVFWMACC_VFPR16_MF4_MASK, PseudoVFWMACC_VFPR16_MF4, 0x3, false }, // 1052 + { PseudoVFWMACC_VFPR32_M1_MASK, PseudoVFWMACC_VFPR32_M1, 0x3, false }, // 1053 + { PseudoVFWMACC_VFPR32_M2_MASK, PseudoVFWMACC_VFPR32_M2, 0x3, false }, // 1054 + { PseudoVFWMACC_VFPR32_M4_MASK, PseudoVFWMACC_VFPR32_M4, 0x3, false }, // 1055 + { PseudoVFWMACC_VFPR32_MF2_MASK, PseudoVFWMACC_VFPR32_MF2, 0x3, false }, // 1056 + { PseudoVFWMACC_VV_M1_MASK, PseudoVFWMACC_VV_M1, 0x3, false }, // 1057 + { PseudoVFWMACC_VV_M2_MASK, PseudoVFWMACC_VV_M2, 0x3, false }, // 1058 + { PseudoVFWMACC_VV_M4_MASK, PseudoVFWMACC_VV_M4, 0x3, false }, // 1059 + { PseudoVFWMACC_VV_MF2_MASK, PseudoVFWMACC_VV_MF2, 0x3, false }, // 1060 + { PseudoVFWMACC_VV_MF4_MASK, PseudoVFWMACC_VV_MF4, 0x3, false }, // 1061 + { PseudoVFWMSAC_VFPR16_M1_MASK, PseudoVFWMSAC_VFPR16_M1, 0x3, false }, // 1062 + { PseudoVFWMSAC_VFPR16_M2_MASK, PseudoVFWMSAC_VFPR16_M2, 0x3, false }, // 1063 + { PseudoVFWMSAC_VFPR16_M4_MASK, PseudoVFWMSAC_VFPR16_M4, 0x3, false }, // 1064 + { PseudoVFWMSAC_VFPR16_MF2_MASK, PseudoVFWMSAC_VFPR16_MF2, 0x3, false }, // 1065 + { PseudoVFWMSAC_VFPR16_MF4_MASK, PseudoVFWMSAC_VFPR16_MF4, 0x3, false }, // 1066 + { PseudoVFWMSAC_VFPR32_M1_MASK, PseudoVFWMSAC_VFPR32_M1, 0x3, false }, // 1067 + { PseudoVFWMSAC_VFPR32_M2_MASK, PseudoVFWMSAC_VFPR32_M2, 0x3, false }, // 1068 + { PseudoVFWMSAC_VFPR32_M4_MASK, PseudoVFWMSAC_VFPR32_M4, 0x3, false }, // 1069 + { PseudoVFWMSAC_VFPR32_MF2_MASK, PseudoVFWMSAC_VFPR32_MF2, 0x3, false }, // 1070 + { PseudoVFWMSAC_VV_M1_MASK, PseudoVFWMSAC_VV_M1, 0x3, false }, // 1071 + { PseudoVFWMSAC_VV_M2_MASK, PseudoVFWMSAC_VV_M2, 0x3, false }, // 1072 + { PseudoVFWMSAC_VV_M4_MASK, PseudoVFWMSAC_VV_M4, 0x3, false }, // 1073 + { PseudoVFWMSAC_VV_MF2_MASK, PseudoVFWMSAC_VV_MF2, 0x3, false }, // 1074 + { PseudoVFWMSAC_VV_MF4_MASK, PseudoVFWMSAC_VV_MF4, 0x3, false }, // 1075 + { PseudoVFWMUL_VFPR16_M1_MASK, PseudoVFWMUL_VFPR16_M1, 0x3, false }, // 1076 + { PseudoVFWMUL_VFPR16_M2_MASK, PseudoVFWMUL_VFPR16_M2, 0x3, false }, // 1077 + { PseudoVFWMUL_VFPR16_M4_MASK, PseudoVFWMUL_VFPR16_M4, 0x3, false }, // 1078 + { PseudoVFWMUL_VFPR16_MF2_MASK, PseudoVFWMUL_VFPR16_MF2, 0x3, false }, // 1079 + { PseudoVFWMUL_VFPR16_MF4_MASK, PseudoVFWMUL_VFPR16_MF4, 0x3, false }, // 1080 + { PseudoVFWMUL_VFPR32_M1_MASK, PseudoVFWMUL_VFPR32_M1, 0x3, false }, // 1081 + { PseudoVFWMUL_VFPR32_M2_MASK, PseudoVFWMUL_VFPR32_M2, 0x3, false }, // 1082 + { PseudoVFWMUL_VFPR32_M4_MASK, PseudoVFWMUL_VFPR32_M4, 0x3, false }, // 1083 + { PseudoVFWMUL_VFPR32_MF2_MASK, PseudoVFWMUL_VFPR32_MF2, 0x3, false }, // 1084 + { PseudoVFWMUL_VV_M1_MASK, PseudoVFWMUL_VV_M1, 0x3, false }, // 1085 + { PseudoVFWMUL_VV_M2_MASK, PseudoVFWMUL_VV_M2, 0x3, false }, // 1086 + { PseudoVFWMUL_VV_M4_MASK, PseudoVFWMUL_VV_M4, 0x3, false }, // 1087 + { PseudoVFWMUL_VV_MF2_MASK, PseudoVFWMUL_VV_MF2, 0x3, false }, // 1088 + { PseudoVFWMUL_VV_MF4_MASK, PseudoVFWMUL_VV_MF4, 0x3, false }, // 1089 + { PseudoVFWNMACC_VFPR16_M1_MASK, PseudoVFWNMACC_VFPR16_M1, 0x3, false }, // 1090 + { PseudoVFWNMACC_VFPR16_M2_MASK, PseudoVFWNMACC_VFPR16_M2, 0x3, false }, // 1091 + { PseudoVFWNMACC_VFPR16_M4_MASK, PseudoVFWNMACC_VFPR16_M4, 0x3, false }, // 1092 + { PseudoVFWNMACC_VFPR16_MF2_MASK, PseudoVFWNMACC_VFPR16_MF2, 0x3, false }, // 1093 + { PseudoVFWNMACC_VFPR16_MF4_MASK, PseudoVFWNMACC_VFPR16_MF4, 0x3, false }, // 1094 + { PseudoVFWNMACC_VFPR32_M1_MASK, PseudoVFWNMACC_VFPR32_M1, 0x3, false }, // 1095 + { PseudoVFWNMACC_VFPR32_M2_MASK, PseudoVFWNMACC_VFPR32_M2, 0x3, false }, // 1096 + { PseudoVFWNMACC_VFPR32_M4_MASK, PseudoVFWNMACC_VFPR32_M4, 0x3, false }, // 1097 + { PseudoVFWNMACC_VFPR32_MF2_MASK, PseudoVFWNMACC_VFPR32_MF2, 0x3, false }, // 1098 + { PseudoVFWNMACC_VV_M1_MASK, PseudoVFWNMACC_VV_M1, 0x3, false }, // 1099 + { PseudoVFWNMACC_VV_M2_MASK, PseudoVFWNMACC_VV_M2, 0x3, false }, // 1100 + { PseudoVFWNMACC_VV_M4_MASK, PseudoVFWNMACC_VV_M4, 0x3, false }, // 1101 + { PseudoVFWNMACC_VV_MF2_MASK, PseudoVFWNMACC_VV_MF2, 0x3, false }, // 1102 + { PseudoVFWNMACC_VV_MF4_MASK, PseudoVFWNMACC_VV_MF4, 0x3, false }, // 1103 + { PseudoVFWNMSAC_VFPR16_M1_MASK, PseudoVFWNMSAC_VFPR16_M1, 0x3, false }, // 1104 + { PseudoVFWNMSAC_VFPR16_M2_MASK, PseudoVFWNMSAC_VFPR16_M2, 0x3, false }, // 1105 + { PseudoVFWNMSAC_VFPR16_M4_MASK, PseudoVFWNMSAC_VFPR16_M4, 0x3, false }, // 1106 + { PseudoVFWNMSAC_VFPR16_MF2_MASK, PseudoVFWNMSAC_VFPR16_MF2, 0x3, false }, // 1107 + { PseudoVFWNMSAC_VFPR16_MF4_MASK, PseudoVFWNMSAC_VFPR16_MF4, 0x3, false }, // 1108 + { PseudoVFWNMSAC_VFPR32_M1_MASK, PseudoVFWNMSAC_VFPR32_M1, 0x3, false }, // 1109 + { PseudoVFWNMSAC_VFPR32_M2_MASK, PseudoVFWNMSAC_VFPR32_M2, 0x3, false }, // 1110 + { PseudoVFWNMSAC_VFPR32_M4_MASK, PseudoVFWNMSAC_VFPR32_M4, 0x3, false }, // 1111 + { PseudoVFWNMSAC_VFPR32_MF2_MASK, PseudoVFWNMSAC_VFPR32_MF2, 0x3, false }, // 1112 + { PseudoVFWNMSAC_VV_M1_MASK, PseudoVFWNMSAC_VV_M1, 0x3, false }, // 1113 + { PseudoVFWNMSAC_VV_M2_MASK, PseudoVFWNMSAC_VV_M2, 0x3, false }, // 1114 + { PseudoVFWNMSAC_VV_M4_MASK, PseudoVFWNMSAC_VV_M4, 0x3, false }, // 1115 + { PseudoVFWNMSAC_VV_MF2_MASK, PseudoVFWNMSAC_VV_MF2, 0x3, false }, // 1116 + { PseudoVFWNMSAC_VV_MF4_MASK, PseudoVFWNMSAC_VV_MF4, 0x3, false }, // 1117 + { PseudoVFWREDOSUM_VS_M1_E16_MASK, PseudoVFWREDOSUM_VS_M1_E16, 0x3, true }, // 1118 + { PseudoVFWREDOSUM_VS_M1_E32_MASK, PseudoVFWREDOSUM_VS_M1_E32, 0x3, true }, // 1119 + { PseudoVFWREDOSUM_VS_M2_E16_MASK, PseudoVFWREDOSUM_VS_M2_E16, 0x3, true }, // 1120 + { PseudoVFWREDOSUM_VS_M2_E32_MASK, PseudoVFWREDOSUM_VS_M2_E32, 0x3, true }, // 1121 + { PseudoVFWREDOSUM_VS_M4_E16_MASK, PseudoVFWREDOSUM_VS_M4_E16, 0x3, true }, // 1122 + { PseudoVFWREDOSUM_VS_M4_E32_MASK, PseudoVFWREDOSUM_VS_M4_E32, 0x3, true }, // 1123 + { PseudoVFWREDOSUM_VS_M8_E16_MASK, PseudoVFWREDOSUM_VS_M8_E16, 0x3, true }, // 1124 + { PseudoVFWREDOSUM_VS_M8_E32_MASK, PseudoVFWREDOSUM_VS_M8_E32, 0x3, true }, // 1125 + { PseudoVFWREDOSUM_VS_MF2_E16_MASK, PseudoVFWREDOSUM_VS_MF2_E16, 0x3, true }, // 1126 + { PseudoVFWREDOSUM_VS_MF2_E32_MASK, PseudoVFWREDOSUM_VS_MF2_E32, 0x3, true }, // 1127 + { PseudoVFWREDOSUM_VS_MF4_E16_MASK, PseudoVFWREDOSUM_VS_MF4_E16, 0x3, true }, // 1128 + { PseudoVFWREDUSUM_VS_M1_E16_MASK, PseudoVFWREDUSUM_VS_M1_E16, 0x3, true }, // 1129 + { PseudoVFWREDUSUM_VS_M1_E32_MASK, PseudoVFWREDUSUM_VS_M1_E32, 0x3, true }, // 1130 + { PseudoVFWREDUSUM_VS_M2_E16_MASK, PseudoVFWREDUSUM_VS_M2_E16, 0x3, true }, // 1131 + { PseudoVFWREDUSUM_VS_M2_E32_MASK, PseudoVFWREDUSUM_VS_M2_E32, 0x3, true }, // 1132 + { PseudoVFWREDUSUM_VS_M4_E16_MASK, PseudoVFWREDUSUM_VS_M4_E16, 0x3, true }, // 1133 + { PseudoVFWREDUSUM_VS_M4_E32_MASK, PseudoVFWREDUSUM_VS_M4_E32, 0x3, true }, // 1134 + { PseudoVFWREDUSUM_VS_M8_E16_MASK, PseudoVFWREDUSUM_VS_M8_E16, 0x3, true }, // 1135 + { PseudoVFWREDUSUM_VS_M8_E32_MASK, PseudoVFWREDUSUM_VS_M8_E32, 0x3, true }, // 1136 + { PseudoVFWREDUSUM_VS_MF2_E16_MASK, PseudoVFWREDUSUM_VS_MF2_E16, 0x3, true }, // 1137 + { PseudoVFWREDUSUM_VS_MF2_E32_MASK, PseudoVFWREDUSUM_VS_MF2_E32, 0x3, true }, // 1138 + { PseudoVFWREDUSUM_VS_MF4_E16_MASK, PseudoVFWREDUSUM_VS_MF4_E16, 0x3, true }, // 1139 + { PseudoVFWSUB_VFPR16_M1_MASK, PseudoVFWSUB_VFPR16_M1, 0x3, false }, // 1140 + { PseudoVFWSUB_VFPR16_M2_MASK, PseudoVFWSUB_VFPR16_M2, 0x3, false }, // 1141 + { PseudoVFWSUB_VFPR16_M4_MASK, PseudoVFWSUB_VFPR16_M4, 0x3, false }, // 1142 + { PseudoVFWSUB_VFPR16_MF2_MASK, PseudoVFWSUB_VFPR16_MF2, 0x3, false }, // 1143 + { PseudoVFWSUB_VFPR16_MF4_MASK, PseudoVFWSUB_VFPR16_MF4, 0x3, false }, // 1144 + { PseudoVFWSUB_VFPR32_M1_MASK, PseudoVFWSUB_VFPR32_M1, 0x3, false }, // 1145 + { PseudoVFWSUB_VFPR32_M2_MASK, PseudoVFWSUB_VFPR32_M2, 0x3, false }, // 1146 + { PseudoVFWSUB_VFPR32_M4_MASK, PseudoVFWSUB_VFPR32_M4, 0x3, false }, // 1147 + { PseudoVFWSUB_VFPR32_MF2_MASK, PseudoVFWSUB_VFPR32_MF2, 0x3, false }, // 1148 + { PseudoVFWSUB_VV_M1_MASK, PseudoVFWSUB_VV_M1, 0x3, false }, // 1149 + { PseudoVFWSUB_VV_M2_MASK, PseudoVFWSUB_VV_M2, 0x3, false }, // 1150 + { PseudoVFWSUB_VV_M4_MASK, PseudoVFWSUB_VV_M4, 0x3, false }, // 1151 + { PseudoVFWSUB_VV_MF2_MASK, PseudoVFWSUB_VV_MF2, 0x3, false }, // 1152 + { PseudoVFWSUB_VV_MF4_MASK, PseudoVFWSUB_VV_MF4, 0x3, false }, // 1153 + { PseudoVFWSUB_WFPR16_M1_MASK, PseudoVFWSUB_WFPR16_M1, 0x3, false }, // 1154 + { PseudoVFWSUB_WFPR16_M2_MASK, PseudoVFWSUB_WFPR16_M2, 0x3, false }, // 1155 + { PseudoVFWSUB_WFPR16_M4_MASK, PseudoVFWSUB_WFPR16_M4, 0x3, false }, // 1156 + { PseudoVFWSUB_WFPR16_MF2_MASK, PseudoVFWSUB_WFPR16_MF2, 0x3, false }, // 1157 + { PseudoVFWSUB_WFPR16_MF4_MASK, PseudoVFWSUB_WFPR16_MF4, 0x3, false }, // 1158 + { PseudoVFWSUB_WFPR32_M1_MASK, PseudoVFWSUB_WFPR32_M1, 0x3, false }, // 1159 + { PseudoVFWSUB_WFPR32_M2_MASK, PseudoVFWSUB_WFPR32_M2, 0x3, false }, // 1160 + { PseudoVFWSUB_WFPR32_M4_MASK, PseudoVFWSUB_WFPR32_M4, 0x3, false }, // 1161 + { PseudoVFWSUB_WFPR32_MF2_MASK, PseudoVFWSUB_WFPR32_MF2, 0x3, false }, // 1162 + { PseudoVFWSUB_WV_M1_MASK, PseudoVFWSUB_WV_M1, 0x3, false }, // 1163 + { PseudoVFWSUB_WV_M2_MASK, PseudoVFWSUB_WV_M2, 0x3, false }, // 1164 + { PseudoVFWSUB_WV_M4_MASK, PseudoVFWSUB_WV_M4, 0x3, false }, // 1165 + { PseudoVFWSUB_WV_MF2_MASK, PseudoVFWSUB_WV_MF2, 0x3, false }, // 1166 + { PseudoVFWSUB_WV_MF4_MASK, PseudoVFWSUB_WV_MF4, 0x3, false }, // 1167 + { PseudoVID_V_M1_MASK, PseudoVID_V_M1, 0x1, false }, // 1168 + { PseudoVID_V_M2_MASK, PseudoVID_V_M2, 0x1, false }, // 1169 + { PseudoVID_V_M4_MASK, PseudoVID_V_M4, 0x1, false }, // 1170 + { PseudoVID_V_M8_MASK, PseudoVID_V_M8, 0x1, false }, // 1171 + { PseudoVID_V_MF2_MASK, PseudoVID_V_MF2, 0x1, false }, // 1172 + { PseudoVID_V_MF4_MASK, PseudoVID_V_MF4, 0x1, false }, // 1173 + { PseudoVID_V_MF8_MASK, PseudoVID_V_MF8, 0x1, false }, // 1174 + { PseudoVIOTA_M_M1_MASK, PseudoVIOTA_M_M1, 0x2, true }, // 1175 + { PseudoVIOTA_M_M2_MASK, PseudoVIOTA_M_M2, 0x2, true }, // 1176 + { PseudoVIOTA_M_M4_MASK, PseudoVIOTA_M_M4, 0x2, true }, // 1177 + { PseudoVIOTA_M_M8_MASK, PseudoVIOTA_M_M8, 0x2, true }, // 1178 + { PseudoVIOTA_M_MF2_MASK, PseudoVIOTA_M_MF2, 0x2, true }, // 1179 + { PseudoVIOTA_M_MF4_MASK, PseudoVIOTA_M_MF4, 0x2, true }, // 1180 + { PseudoVIOTA_M_MF8_MASK, PseudoVIOTA_M_MF8, 0x2, true }, // 1181 + { PseudoVLE16FF_V_M1_MASK, PseudoVLE16FF_V_M1, 0x2, false }, // 1182 + { PseudoVLE16FF_V_M2_MASK, PseudoVLE16FF_V_M2, 0x2, false }, // 1183 + { PseudoVLE16FF_V_M4_MASK, PseudoVLE16FF_V_M4, 0x2, false }, // 1184 + { PseudoVLE16FF_V_M8_MASK, PseudoVLE16FF_V_M8, 0x2, false }, // 1185 + { PseudoVLE16FF_V_MF2_MASK, PseudoVLE16FF_V_MF2, 0x2, false }, // 1186 + { PseudoVLE16FF_V_MF4_MASK, PseudoVLE16FF_V_MF4, 0x2, false }, // 1187 + { PseudoVLE16_V_M1_MASK, PseudoVLE16_V_M1, 0x2, false }, // 1188 + { PseudoVLE16_V_M2_MASK, PseudoVLE16_V_M2, 0x2, false }, // 1189 + { PseudoVLE16_V_M4_MASK, PseudoVLE16_V_M4, 0x2, false }, // 1190 + { PseudoVLE16_V_M8_MASK, PseudoVLE16_V_M8, 0x2, false }, // 1191 + { PseudoVLE16_V_MF2_MASK, PseudoVLE16_V_MF2, 0x2, false }, // 1192 + { PseudoVLE16_V_MF4_MASK, PseudoVLE16_V_MF4, 0x2, false }, // 1193 + { PseudoVLE32FF_V_M1_MASK, PseudoVLE32FF_V_M1, 0x2, false }, // 1194 + { PseudoVLE32FF_V_M2_MASK, PseudoVLE32FF_V_M2, 0x2, false }, // 1195 + { PseudoVLE32FF_V_M4_MASK, PseudoVLE32FF_V_M4, 0x2, false }, // 1196 + { PseudoVLE32FF_V_M8_MASK, PseudoVLE32FF_V_M8, 0x2, false }, // 1197 + { PseudoVLE32FF_V_MF2_MASK, PseudoVLE32FF_V_MF2, 0x2, false }, // 1198 + { PseudoVLE32_V_M1_MASK, PseudoVLE32_V_M1, 0x2, false }, // 1199 + { PseudoVLE32_V_M2_MASK, PseudoVLE32_V_M2, 0x2, false }, // 1200 + { PseudoVLE32_V_M4_MASK, PseudoVLE32_V_M4, 0x2, false }, // 1201 + { PseudoVLE32_V_M8_MASK, PseudoVLE32_V_M8, 0x2, false }, // 1202 + { PseudoVLE32_V_MF2_MASK, PseudoVLE32_V_MF2, 0x2, false }, // 1203 + { PseudoVLE64FF_V_M1_MASK, PseudoVLE64FF_V_M1, 0x2, false }, // 1204 + { PseudoVLE64FF_V_M2_MASK, PseudoVLE64FF_V_M2, 0x2, false }, // 1205 + { PseudoVLE64FF_V_M4_MASK, PseudoVLE64FF_V_M4, 0x2, false }, // 1206 + { PseudoVLE64FF_V_M8_MASK, PseudoVLE64FF_V_M8, 0x2, false }, // 1207 + { PseudoVLE64_V_M1_MASK, PseudoVLE64_V_M1, 0x2, false }, // 1208 + { PseudoVLE64_V_M2_MASK, PseudoVLE64_V_M2, 0x2, false }, // 1209 + { PseudoVLE64_V_M4_MASK, PseudoVLE64_V_M4, 0x2, false }, // 1210 + { PseudoVLE64_V_M8_MASK, PseudoVLE64_V_M8, 0x2, false }, // 1211 + { PseudoVLE8FF_V_M1_MASK, PseudoVLE8FF_V_M1, 0x2, false }, // 1212 + { PseudoVLE8FF_V_M2_MASK, PseudoVLE8FF_V_M2, 0x2, false }, // 1213 + { PseudoVLE8FF_V_M4_MASK, PseudoVLE8FF_V_M4, 0x2, false }, // 1214 + { PseudoVLE8FF_V_M8_MASK, PseudoVLE8FF_V_M8, 0x2, false }, // 1215 + { PseudoVLE8FF_V_MF2_MASK, PseudoVLE8FF_V_MF2, 0x2, false }, // 1216 + { PseudoVLE8FF_V_MF4_MASK, PseudoVLE8FF_V_MF4, 0x2, false }, // 1217 + { PseudoVLE8FF_V_MF8_MASK, PseudoVLE8FF_V_MF8, 0x2, false }, // 1218 + { PseudoVLE8_V_M1_MASK, PseudoVLE8_V_M1, 0x2, false }, // 1219 + { PseudoVLE8_V_M2_MASK, PseudoVLE8_V_M2, 0x2, false }, // 1220 + { PseudoVLE8_V_M4_MASK, PseudoVLE8_V_M4, 0x2, false }, // 1221 + { PseudoVLE8_V_M8_MASK, PseudoVLE8_V_M8, 0x2, false }, // 1222 + { PseudoVLE8_V_MF2_MASK, PseudoVLE8_V_MF2, 0x2, false }, // 1223 + { PseudoVLE8_V_MF4_MASK, PseudoVLE8_V_MF4, 0x2, false }, // 1224 + { PseudoVLE8_V_MF8_MASK, PseudoVLE8_V_MF8, 0x2, false }, // 1225 + { PseudoVLOXEI16_V_M1_M1_MASK, PseudoVLOXEI16_V_M1_M1, 0x3, false }, // 1226 + { PseudoVLOXEI16_V_M1_M2_MASK, PseudoVLOXEI16_V_M1_M2, 0x3, false }, // 1227 + { PseudoVLOXEI16_V_M1_M4_MASK, PseudoVLOXEI16_V_M1_M4, 0x3, false }, // 1228 + { PseudoVLOXEI16_V_M1_MF2_MASK, PseudoVLOXEI16_V_M1_MF2, 0x3, false }, // 1229 + { PseudoVLOXEI16_V_M2_M1_MASK, PseudoVLOXEI16_V_M2_M1, 0x3, false }, // 1230 + { PseudoVLOXEI16_V_M2_M2_MASK, PseudoVLOXEI16_V_M2_M2, 0x3, false }, // 1231 + { PseudoVLOXEI16_V_M2_M4_MASK, PseudoVLOXEI16_V_M2_M4, 0x3, false }, // 1232 + { PseudoVLOXEI16_V_M2_M8_MASK, PseudoVLOXEI16_V_M2_M8, 0x3, false }, // 1233 + { PseudoVLOXEI16_V_M4_M2_MASK, PseudoVLOXEI16_V_M4_M2, 0x3, false }, // 1234 + { PseudoVLOXEI16_V_M4_M4_MASK, PseudoVLOXEI16_V_M4_M4, 0x3, false }, // 1235 + { PseudoVLOXEI16_V_M4_M8_MASK, PseudoVLOXEI16_V_M4_M8, 0x3, false }, // 1236 + { PseudoVLOXEI16_V_M8_M4_MASK, PseudoVLOXEI16_V_M8_M4, 0x3, false }, // 1237 + { PseudoVLOXEI16_V_M8_M8_MASK, PseudoVLOXEI16_V_M8_M8, 0x3, false }, // 1238 + { PseudoVLOXEI16_V_MF2_M1_MASK, PseudoVLOXEI16_V_MF2_M1, 0x3, false }, // 1239 + { PseudoVLOXEI16_V_MF2_M2_MASK, PseudoVLOXEI16_V_MF2_M2, 0x3, false }, // 1240 + { PseudoVLOXEI16_V_MF2_MF2_MASK, PseudoVLOXEI16_V_MF2_MF2, 0x3, false }, // 1241 + { PseudoVLOXEI16_V_MF2_MF4_MASK, PseudoVLOXEI16_V_MF2_MF4, 0x3, false }, // 1242 + { PseudoVLOXEI16_V_MF4_M1_MASK, PseudoVLOXEI16_V_MF4_M1, 0x3, false }, // 1243 + { PseudoVLOXEI16_V_MF4_MF2_MASK, PseudoVLOXEI16_V_MF4_MF2, 0x3, false }, // 1244 + { PseudoVLOXEI16_V_MF4_MF4_MASK, PseudoVLOXEI16_V_MF4_MF4, 0x3, false }, // 1245 + { PseudoVLOXEI16_V_MF4_MF8_MASK, PseudoVLOXEI16_V_MF4_MF8, 0x3, false }, // 1246 + { PseudoVLOXEI32_V_M1_M1_MASK, PseudoVLOXEI32_V_M1_M1, 0x3, false }, // 1247 + { PseudoVLOXEI32_V_M1_M2_MASK, PseudoVLOXEI32_V_M1_M2, 0x3, false }, // 1248 + { PseudoVLOXEI32_V_M1_MF2_MASK, PseudoVLOXEI32_V_M1_MF2, 0x3, false }, // 1249 + { PseudoVLOXEI32_V_M1_MF4_MASK, PseudoVLOXEI32_V_M1_MF4, 0x3, false }, // 1250 + { PseudoVLOXEI32_V_M2_M1_MASK, PseudoVLOXEI32_V_M2_M1, 0x3, false }, // 1251 + { PseudoVLOXEI32_V_M2_M2_MASK, PseudoVLOXEI32_V_M2_M2, 0x3, false }, // 1252 + { PseudoVLOXEI32_V_M2_M4_MASK, PseudoVLOXEI32_V_M2_M4, 0x3, false }, // 1253 + { PseudoVLOXEI32_V_M2_MF2_MASK, PseudoVLOXEI32_V_M2_MF2, 0x3, false }, // 1254 + { PseudoVLOXEI32_V_M4_M1_MASK, PseudoVLOXEI32_V_M4_M1, 0x3, false }, // 1255 + { PseudoVLOXEI32_V_M4_M2_MASK, PseudoVLOXEI32_V_M4_M2, 0x3, false }, // 1256 + { PseudoVLOXEI32_V_M4_M4_MASK, PseudoVLOXEI32_V_M4_M4, 0x3, false }, // 1257 + { PseudoVLOXEI32_V_M4_M8_MASK, PseudoVLOXEI32_V_M4_M8, 0x3, false }, // 1258 + { PseudoVLOXEI32_V_M8_M2_MASK, PseudoVLOXEI32_V_M8_M2, 0x3, false }, // 1259 + { PseudoVLOXEI32_V_M8_M4_MASK, PseudoVLOXEI32_V_M8_M4, 0x3, false }, // 1260 + { PseudoVLOXEI32_V_M8_M8_MASK, PseudoVLOXEI32_V_M8_M8, 0x3, false }, // 1261 + { PseudoVLOXEI32_V_MF2_M1_MASK, PseudoVLOXEI32_V_MF2_M1, 0x3, false }, // 1262 + { PseudoVLOXEI32_V_MF2_MF2_MASK, PseudoVLOXEI32_V_MF2_MF2, 0x3, false }, // 1263 + { PseudoVLOXEI32_V_MF2_MF4_MASK, PseudoVLOXEI32_V_MF2_MF4, 0x3, false }, // 1264 + { PseudoVLOXEI32_V_MF2_MF8_MASK, PseudoVLOXEI32_V_MF2_MF8, 0x3, false }, // 1265 + { PseudoVLOXEI64_V_M1_M1_MASK, PseudoVLOXEI64_V_M1_M1, 0x3, false }, // 1266 + { PseudoVLOXEI64_V_M1_MF2_MASK, PseudoVLOXEI64_V_M1_MF2, 0x3, false }, // 1267 + { PseudoVLOXEI64_V_M1_MF4_MASK, PseudoVLOXEI64_V_M1_MF4, 0x3, false }, // 1268 + { PseudoVLOXEI64_V_M1_MF8_MASK, PseudoVLOXEI64_V_M1_MF8, 0x3, false }, // 1269 + { PseudoVLOXEI64_V_M2_M1_MASK, PseudoVLOXEI64_V_M2_M1, 0x3, false }, // 1270 + { PseudoVLOXEI64_V_M2_M2_MASK, PseudoVLOXEI64_V_M2_M2, 0x3, false }, // 1271 + { PseudoVLOXEI64_V_M2_MF2_MASK, PseudoVLOXEI64_V_M2_MF2, 0x3, false }, // 1272 + { PseudoVLOXEI64_V_M2_MF4_MASK, PseudoVLOXEI64_V_M2_MF4, 0x3, false }, // 1273 + { PseudoVLOXEI64_V_M4_M1_MASK, PseudoVLOXEI64_V_M4_M1, 0x3, false }, // 1274 + { PseudoVLOXEI64_V_M4_M2_MASK, PseudoVLOXEI64_V_M4_M2, 0x3, false }, // 1275 + { PseudoVLOXEI64_V_M4_M4_MASK, PseudoVLOXEI64_V_M4_M4, 0x3, false }, // 1276 + { PseudoVLOXEI64_V_M4_MF2_MASK, PseudoVLOXEI64_V_M4_MF2, 0x3, false }, // 1277 + { PseudoVLOXEI64_V_M8_M1_MASK, PseudoVLOXEI64_V_M8_M1, 0x3, false }, // 1278 + { PseudoVLOXEI64_V_M8_M2_MASK, PseudoVLOXEI64_V_M8_M2, 0x3, false }, // 1279 + { PseudoVLOXEI64_V_M8_M4_MASK, PseudoVLOXEI64_V_M8_M4, 0x3, false }, // 1280 + { PseudoVLOXEI64_V_M8_M8_MASK, PseudoVLOXEI64_V_M8_M8, 0x3, false }, // 1281 + { PseudoVLOXEI8_V_M1_M1_MASK, PseudoVLOXEI8_V_M1_M1, 0x3, false }, // 1282 + { PseudoVLOXEI8_V_M1_M2_MASK, PseudoVLOXEI8_V_M1_M2, 0x3, false }, // 1283 + { PseudoVLOXEI8_V_M1_M4_MASK, PseudoVLOXEI8_V_M1_M4, 0x3, false }, // 1284 + { PseudoVLOXEI8_V_M1_M8_MASK, PseudoVLOXEI8_V_M1_M8, 0x3, false }, // 1285 + { PseudoVLOXEI8_V_M2_M2_MASK, PseudoVLOXEI8_V_M2_M2, 0x3, false }, // 1286 + { PseudoVLOXEI8_V_M2_M4_MASK, PseudoVLOXEI8_V_M2_M4, 0x3, false }, // 1287 + { PseudoVLOXEI8_V_M2_M8_MASK, PseudoVLOXEI8_V_M2_M8, 0x3, false }, // 1288 + { PseudoVLOXEI8_V_M4_M4_MASK, PseudoVLOXEI8_V_M4_M4, 0x3, false }, // 1289 + { PseudoVLOXEI8_V_M4_M8_MASK, PseudoVLOXEI8_V_M4_M8, 0x3, false }, // 1290 + { PseudoVLOXEI8_V_M8_M8_MASK, PseudoVLOXEI8_V_M8_M8, 0x3, false }, // 1291 + { PseudoVLOXEI8_V_MF2_M1_MASK, PseudoVLOXEI8_V_MF2_M1, 0x3, false }, // 1292 + { PseudoVLOXEI8_V_MF2_M2_MASK, PseudoVLOXEI8_V_MF2_M2, 0x3, false }, // 1293 + { PseudoVLOXEI8_V_MF2_M4_MASK, PseudoVLOXEI8_V_MF2_M4, 0x3, false }, // 1294 + { PseudoVLOXEI8_V_MF2_MF2_MASK, PseudoVLOXEI8_V_MF2_MF2, 0x3, false }, // 1295 + { PseudoVLOXEI8_V_MF4_M1_MASK, PseudoVLOXEI8_V_MF4_M1, 0x3, false }, // 1296 + { PseudoVLOXEI8_V_MF4_M2_MASK, PseudoVLOXEI8_V_MF4_M2, 0x3, false }, // 1297 + { PseudoVLOXEI8_V_MF4_MF2_MASK, PseudoVLOXEI8_V_MF4_MF2, 0x3, false }, // 1298 + { PseudoVLOXEI8_V_MF4_MF4_MASK, PseudoVLOXEI8_V_MF4_MF4, 0x3, false }, // 1299 + { PseudoVLOXEI8_V_MF8_M1_MASK, PseudoVLOXEI8_V_MF8_M1, 0x3, false }, // 1300 + { PseudoVLOXEI8_V_MF8_MF2_MASK, PseudoVLOXEI8_V_MF8_MF2, 0x3, false }, // 1301 + { PseudoVLOXEI8_V_MF8_MF4_MASK, PseudoVLOXEI8_V_MF8_MF4, 0x3, false }, // 1302 + { PseudoVLOXEI8_V_MF8_MF8_MASK, PseudoVLOXEI8_V_MF8_MF8, 0x3, false }, // 1303 + { PseudoVLSE16_V_M1_MASK, PseudoVLSE16_V_M1, 0x3, false }, // 1304 + { PseudoVLSE16_V_M2_MASK, PseudoVLSE16_V_M2, 0x3, false }, // 1305 + { PseudoVLSE16_V_M4_MASK, PseudoVLSE16_V_M4, 0x3, false }, // 1306 + { PseudoVLSE16_V_M8_MASK, PseudoVLSE16_V_M8, 0x3, false }, // 1307 + { PseudoVLSE16_V_MF2_MASK, PseudoVLSE16_V_MF2, 0x3, false }, // 1308 + { PseudoVLSE16_V_MF4_MASK, PseudoVLSE16_V_MF4, 0x3, false }, // 1309 + { PseudoVLSE32_V_M1_MASK, PseudoVLSE32_V_M1, 0x3, false }, // 1310 + { PseudoVLSE32_V_M2_MASK, PseudoVLSE32_V_M2, 0x3, false }, // 1311 + { PseudoVLSE32_V_M4_MASK, PseudoVLSE32_V_M4, 0x3, false }, // 1312 + { PseudoVLSE32_V_M8_MASK, PseudoVLSE32_V_M8, 0x3, false }, // 1313 + { PseudoVLSE32_V_MF2_MASK, PseudoVLSE32_V_MF2, 0x3, false }, // 1314 + { PseudoVLSE64_V_M1_MASK, PseudoVLSE64_V_M1, 0x3, false }, // 1315 + { PseudoVLSE64_V_M2_MASK, PseudoVLSE64_V_M2, 0x3, false }, // 1316 + { PseudoVLSE64_V_M4_MASK, PseudoVLSE64_V_M4, 0x3, false }, // 1317 + { PseudoVLSE64_V_M8_MASK, PseudoVLSE64_V_M8, 0x3, false }, // 1318 + { PseudoVLSE8_V_M1_MASK, PseudoVLSE8_V_M1, 0x3, false }, // 1319 + { PseudoVLSE8_V_M2_MASK, PseudoVLSE8_V_M2, 0x3, false }, // 1320 + { PseudoVLSE8_V_M4_MASK, PseudoVLSE8_V_M4, 0x3, false }, // 1321 + { PseudoVLSE8_V_M8_MASK, PseudoVLSE8_V_M8, 0x3, false }, // 1322 + { PseudoVLSE8_V_MF2_MASK, PseudoVLSE8_V_MF2, 0x3, false }, // 1323 + { PseudoVLSE8_V_MF4_MASK, PseudoVLSE8_V_MF4, 0x3, false }, // 1324 + { PseudoVLSE8_V_MF8_MASK, PseudoVLSE8_V_MF8, 0x3, false }, // 1325 + { PseudoVLUXEI16_V_M1_M1_MASK, PseudoVLUXEI16_V_M1_M1, 0x3, false }, // 1326 + { PseudoVLUXEI16_V_M1_M2_MASK, PseudoVLUXEI16_V_M1_M2, 0x3, false }, // 1327 + { PseudoVLUXEI16_V_M1_M4_MASK, PseudoVLUXEI16_V_M1_M4, 0x3, false }, // 1328 + { PseudoVLUXEI16_V_M1_MF2_MASK, PseudoVLUXEI16_V_M1_MF2, 0x3, false }, // 1329 + { PseudoVLUXEI16_V_M2_M1_MASK, PseudoVLUXEI16_V_M2_M1, 0x3, false }, // 1330 + { PseudoVLUXEI16_V_M2_M2_MASK, PseudoVLUXEI16_V_M2_M2, 0x3, false }, // 1331 + { PseudoVLUXEI16_V_M2_M4_MASK, PseudoVLUXEI16_V_M2_M4, 0x3, false }, // 1332 + { PseudoVLUXEI16_V_M2_M8_MASK, PseudoVLUXEI16_V_M2_M8, 0x3, false }, // 1333 + { PseudoVLUXEI16_V_M4_M2_MASK, PseudoVLUXEI16_V_M4_M2, 0x3, false }, // 1334 + { PseudoVLUXEI16_V_M4_M4_MASK, PseudoVLUXEI16_V_M4_M4, 0x3, false }, // 1335 + { PseudoVLUXEI16_V_M4_M8_MASK, PseudoVLUXEI16_V_M4_M8, 0x3, false }, // 1336 + { PseudoVLUXEI16_V_M8_M4_MASK, PseudoVLUXEI16_V_M8_M4, 0x3, false }, // 1337 + { PseudoVLUXEI16_V_M8_M8_MASK, PseudoVLUXEI16_V_M8_M8, 0x3, false }, // 1338 + { PseudoVLUXEI16_V_MF2_M1_MASK, PseudoVLUXEI16_V_MF2_M1, 0x3, false }, // 1339 + { PseudoVLUXEI16_V_MF2_M2_MASK, PseudoVLUXEI16_V_MF2_M2, 0x3, false }, // 1340 + { PseudoVLUXEI16_V_MF2_MF2_MASK, PseudoVLUXEI16_V_MF2_MF2, 0x3, false }, // 1341 + { PseudoVLUXEI16_V_MF2_MF4_MASK, PseudoVLUXEI16_V_MF2_MF4, 0x3, false }, // 1342 + { PseudoVLUXEI16_V_MF4_M1_MASK, PseudoVLUXEI16_V_MF4_M1, 0x3, false }, // 1343 + { PseudoVLUXEI16_V_MF4_MF2_MASK, PseudoVLUXEI16_V_MF4_MF2, 0x3, false }, // 1344 + { PseudoVLUXEI16_V_MF4_MF4_MASK, PseudoVLUXEI16_V_MF4_MF4, 0x3, false }, // 1345 + { PseudoVLUXEI16_V_MF4_MF8_MASK, PseudoVLUXEI16_V_MF4_MF8, 0x3, false }, // 1346 + { PseudoVLUXEI32_V_M1_M1_MASK, PseudoVLUXEI32_V_M1_M1, 0x3, false }, // 1347 + { PseudoVLUXEI32_V_M1_M2_MASK, PseudoVLUXEI32_V_M1_M2, 0x3, false }, // 1348 + { PseudoVLUXEI32_V_M1_MF2_MASK, PseudoVLUXEI32_V_M1_MF2, 0x3, false }, // 1349 + { PseudoVLUXEI32_V_M1_MF4_MASK, PseudoVLUXEI32_V_M1_MF4, 0x3, false }, // 1350 + { PseudoVLUXEI32_V_M2_M1_MASK, PseudoVLUXEI32_V_M2_M1, 0x3, false }, // 1351 + { PseudoVLUXEI32_V_M2_M2_MASK, PseudoVLUXEI32_V_M2_M2, 0x3, false }, // 1352 + { PseudoVLUXEI32_V_M2_M4_MASK, PseudoVLUXEI32_V_M2_M4, 0x3, false }, // 1353 + { PseudoVLUXEI32_V_M2_MF2_MASK, PseudoVLUXEI32_V_M2_MF2, 0x3, false }, // 1354 + { PseudoVLUXEI32_V_M4_M1_MASK, PseudoVLUXEI32_V_M4_M1, 0x3, false }, // 1355 + { PseudoVLUXEI32_V_M4_M2_MASK, PseudoVLUXEI32_V_M4_M2, 0x3, false }, // 1356 + { PseudoVLUXEI32_V_M4_M4_MASK, PseudoVLUXEI32_V_M4_M4, 0x3, false }, // 1357 + { PseudoVLUXEI32_V_M4_M8_MASK, PseudoVLUXEI32_V_M4_M8, 0x3, false }, // 1358 + { PseudoVLUXEI32_V_M8_M2_MASK, PseudoVLUXEI32_V_M8_M2, 0x3, false }, // 1359 + { PseudoVLUXEI32_V_M8_M4_MASK, PseudoVLUXEI32_V_M8_M4, 0x3, false }, // 1360 + { PseudoVLUXEI32_V_M8_M8_MASK, PseudoVLUXEI32_V_M8_M8, 0x3, false }, // 1361 + { PseudoVLUXEI32_V_MF2_M1_MASK, PseudoVLUXEI32_V_MF2_M1, 0x3, false }, // 1362 + { PseudoVLUXEI32_V_MF2_MF2_MASK, PseudoVLUXEI32_V_MF2_MF2, 0x3, false }, // 1363 + { PseudoVLUXEI32_V_MF2_MF4_MASK, PseudoVLUXEI32_V_MF2_MF4, 0x3, false }, // 1364 + { PseudoVLUXEI32_V_MF2_MF8_MASK, PseudoVLUXEI32_V_MF2_MF8, 0x3, false }, // 1365 + { PseudoVLUXEI64_V_M1_M1_MASK, PseudoVLUXEI64_V_M1_M1, 0x3, false }, // 1366 + { PseudoVLUXEI64_V_M1_MF2_MASK, PseudoVLUXEI64_V_M1_MF2, 0x3, false }, // 1367 + { PseudoVLUXEI64_V_M1_MF4_MASK, PseudoVLUXEI64_V_M1_MF4, 0x3, false }, // 1368 + { PseudoVLUXEI64_V_M1_MF8_MASK, PseudoVLUXEI64_V_M1_MF8, 0x3, false }, // 1369 + { PseudoVLUXEI64_V_M2_M1_MASK, PseudoVLUXEI64_V_M2_M1, 0x3, false }, // 1370 + { PseudoVLUXEI64_V_M2_M2_MASK, PseudoVLUXEI64_V_M2_M2, 0x3, false }, // 1371 + { PseudoVLUXEI64_V_M2_MF2_MASK, PseudoVLUXEI64_V_M2_MF2, 0x3, false }, // 1372 + { PseudoVLUXEI64_V_M2_MF4_MASK, PseudoVLUXEI64_V_M2_MF4, 0x3, false }, // 1373 + { PseudoVLUXEI64_V_M4_M1_MASK, PseudoVLUXEI64_V_M4_M1, 0x3, false }, // 1374 + { PseudoVLUXEI64_V_M4_M2_MASK, PseudoVLUXEI64_V_M4_M2, 0x3, false }, // 1375 + { PseudoVLUXEI64_V_M4_M4_MASK, PseudoVLUXEI64_V_M4_M4, 0x3, false }, // 1376 + { PseudoVLUXEI64_V_M4_MF2_MASK, PseudoVLUXEI64_V_M4_MF2, 0x3, false }, // 1377 + { PseudoVLUXEI64_V_M8_M1_MASK, PseudoVLUXEI64_V_M8_M1, 0x3, false }, // 1378 + { PseudoVLUXEI64_V_M8_M2_MASK, PseudoVLUXEI64_V_M8_M2, 0x3, false }, // 1379 + { PseudoVLUXEI64_V_M8_M4_MASK, PseudoVLUXEI64_V_M8_M4, 0x3, false }, // 1380 + { PseudoVLUXEI64_V_M8_M8_MASK, PseudoVLUXEI64_V_M8_M8, 0x3, false }, // 1381 + { PseudoVLUXEI8_V_M1_M1_MASK, PseudoVLUXEI8_V_M1_M1, 0x3, false }, // 1382 + { PseudoVLUXEI8_V_M1_M2_MASK, PseudoVLUXEI8_V_M1_M2, 0x3, false }, // 1383 + { PseudoVLUXEI8_V_M1_M4_MASK, PseudoVLUXEI8_V_M1_M4, 0x3, false }, // 1384 + { PseudoVLUXEI8_V_M1_M8_MASK, PseudoVLUXEI8_V_M1_M8, 0x3, false }, // 1385 + { PseudoVLUXEI8_V_M2_M2_MASK, PseudoVLUXEI8_V_M2_M2, 0x3, false }, // 1386 + { PseudoVLUXEI8_V_M2_M4_MASK, PseudoVLUXEI8_V_M2_M4, 0x3, false }, // 1387 + { PseudoVLUXEI8_V_M2_M8_MASK, PseudoVLUXEI8_V_M2_M8, 0x3, false }, // 1388 + { PseudoVLUXEI8_V_M4_M4_MASK, PseudoVLUXEI8_V_M4_M4, 0x3, false }, // 1389 + { PseudoVLUXEI8_V_M4_M8_MASK, PseudoVLUXEI8_V_M4_M8, 0x3, false }, // 1390 + { PseudoVLUXEI8_V_M8_M8_MASK, PseudoVLUXEI8_V_M8_M8, 0x3, false }, // 1391 + { PseudoVLUXEI8_V_MF2_M1_MASK, PseudoVLUXEI8_V_MF2_M1, 0x3, false }, // 1392 + { PseudoVLUXEI8_V_MF2_M2_MASK, PseudoVLUXEI8_V_MF2_M2, 0x3, false }, // 1393 + { PseudoVLUXEI8_V_MF2_M4_MASK, PseudoVLUXEI8_V_MF2_M4, 0x3, false }, // 1394 + { PseudoVLUXEI8_V_MF2_MF2_MASK, PseudoVLUXEI8_V_MF2_MF2, 0x3, false }, // 1395 + { PseudoVLUXEI8_V_MF4_M1_MASK, PseudoVLUXEI8_V_MF4_M1, 0x3, false }, // 1396 + { PseudoVLUXEI8_V_MF4_M2_MASK, PseudoVLUXEI8_V_MF4_M2, 0x3, false }, // 1397 + { PseudoVLUXEI8_V_MF4_MF2_MASK, PseudoVLUXEI8_V_MF4_MF2, 0x3, false }, // 1398 + { PseudoVLUXEI8_V_MF4_MF4_MASK, PseudoVLUXEI8_V_MF4_MF4, 0x3, false }, // 1399 + { PseudoVLUXEI8_V_MF8_M1_MASK, PseudoVLUXEI8_V_MF8_M1, 0x3, false }, // 1400 + { PseudoVLUXEI8_V_MF8_MF2_MASK, PseudoVLUXEI8_V_MF8_MF2, 0x3, false }, // 1401 + { PseudoVLUXEI8_V_MF8_MF4_MASK, PseudoVLUXEI8_V_MF8_MF4, 0x3, false }, // 1402 + { PseudoVLUXEI8_V_MF8_MF8_MASK, PseudoVLUXEI8_V_MF8_MF8, 0x3, false }, // 1403 + { PseudoVMACC_VV_M1_MASK, PseudoVMACC_VV_M1, 0x3, false }, // 1404 + { PseudoVMACC_VV_M2_MASK, PseudoVMACC_VV_M2, 0x3, false }, // 1405 + { PseudoVMACC_VV_M4_MASK, PseudoVMACC_VV_M4, 0x3, false }, // 1406 + { PseudoVMACC_VV_M8_MASK, PseudoVMACC_VV_M8, 0x3, false }, // 1407 + { PseudoVMACC_VV_MF2_MASK, PseudoVMACC_VV_MF2, 0x3, false }, // 1408 + { PseudoVMACC_VV_MF4_MASK, PseudoVMACC_VV_MF4, 0x3, false }, // 1409 + { PseudoVMACC_VV_MF8_MASK, PseudoVMACC_VV_MF8, 0x3, false }, // 1410 + { PseudoVMACC_VX_M1_MASK, PseudoVMACC_VX_M1, 0x3, false }, // 1411 + { PseudoVMACC_VX_M2_MASK, PseudoVMACC_VX_M2, 0x3, false }, // 1412 + { PseudoVMACC_VX_M4_MASK, PseudoVMACC_VX_M4, 0x3, false }, // 1413 + { PseudoVMACC_VX_M8_MASK, PseudoVMACC_VX_M8, 0x3, false }, // 1414 + { PseudoVMACC_VX_MF2_MASK, PseudoVMACC_VX_MF2, 0x3, false }, // 1415 + { PseudoVMACC_VX_MF4_MASK, PseudoVMACC_VX_MF4, 0x3, false }, // 1416 + { PseudoVMACC_VX_MF8_MASK, PseudoVMACC_VX_MF8, 0x3, false }, // 1417 + { PseudoVMADD_VV_M1_MASK, PseudoVMADD_VV_M1, 0x3, false }, // 1418 + { PseudoVMADD_VV_M2_MASK, PseudoVMADD_VV_M2, 0x3, false }, // 1419 + { PseudoVMADD_VV_M4_MASK, PseudoVMADD_VV_M4, 0x3, false }, // 1420 + { PseudoVMADD_VV_M8_MASK, PseudoVMADD_VV_M8, 0x3, false }, // 1421 + { PseudoVMADD_VV_MF2_MASK, PseudoVMADD_VV_MF2, 0x3, false }, // 1422 + { PseudoVMADD_VV_MF4_MASK, PseudoVMADD_VV_MF4, 0x3, false }, // 1423 + { PseudoVMADD_VV_MF8_MASK, PseudoVMADD_VV_MF8, 0x3, false }, // 1424 + { PseudoVMADD_VX_M1_MASK, PseudoVMADD_VX_M1, 0x3, false }, // 1425 + { PseudoVMADD_VX_M2_MASK, PseudoVMADD_VX_M2, 0x3, false }, // 1426 + { PseudoVMADD_VX_M4_MASK, PseudoVMADD_VX_M4, 0x3, false }, // 1427 + { PseudoVMADD_VX_M8_MASK, PseudoVMADD_VX_M8, 0x3, false }, // 1428 + { PseudoVMADD_VX_MF2_MASK, PseudoVMADD_VX_MF2, 0x3, false }, // 1429 + { PseudoVMADD_VX_MF4_MASK, PseudoVMADD_VX_MF4, 0x3, false }, // 1430 + { PseudoVMADD_VX_MF8_MASK, PseudoVMADD_VX_MF8, 0x3, false }, // 1431 + { PseudoVMAXU_VV_M1_MASK, PseudoVMAXU_VV_M1, 0x3, false }, // 1432 + { PseudoVMAXU_VV_M2_MASK, PseudoVMAXU_VV_M2, 0x3, false }, // 1433 + { PseudoVMAXU_VV_M4_MASK, PseudoVMAXU_VV_M4, 0x3, false }, // 1434 + { PseudoVMAXU_VV_M8_MASK, PseudoVMAXU_VV_M8, 0x3, false }, // 1435 + { PseudoVMAXU_VV_MF2_MASK, PseudoVMAXU_VV_MF2, 0x3, false }, // 1436 + { PseudoVMAXU_VV_MF4_MASK, PseudoVMAXU_VV_MF4, 0x3, false }, // 1437 + { PseudoVMAXU_VV_MF8_MASK, PseudoVMAXU_VV_MF8, 0x3, false }, // 1438 + { PseudoVMAXU_VX_M1_MASK, PseudoVMAXU_VX_M1, 0x3, false }, // 1439 + { PseudoVMAXU_VX_M2_MASK, PseudoVMAXU_VX_M2, 0x3, false }, // 1440 + { PseudoVMAXU_VX_M4_MASK, PseudoVMAXU_VX_M4, 0x3, false }, // 1441 + { PseudoVMAXU_VX_M8_MASK, PseudoVMAXU_VX_M8, 0x3, false }, // 1442 + { PseudoVMAXU_VX_MF2_MASK, PseudoVMAXU_VX_MF2, 0x3, false }, // 1443 + { PseudoVMAXU_VX_MF4_MASK, PseudoVMAXU_VX_MF4, 0x3, false }, // 1444 + { PseudoVMAXU_VX_MF8_MASK, PseudoVMAXU_VX_MF8, 0x3, false }, // 1445 + { PseudoVMAX_VV_M1_MASK, PseudoVMAX_VV_M1, 0x3, false }, // 1446 + { PseudoVMAX_VV_M2_MASK, PseudoVMAX_VV_M2, 0x3, false }, // 1447 + { PseudoVMAX_VV_M4_MASK, PseudoVMAX_VV_M4, 0x3, false }, // 1448 + { PseudoVMAX_VV_M8_MASK, PseudoVMAX_VV_M8, 0x3, false }, // 1449 + { PseudoVMAX_VV_MF2_MASK, PseudoVMAX_VV_MF2, 0x3, false }, // 1450 + { PseudoVMAX_VV_MF4_MASK, PseudoVMAX_VV_MF4, 0x3, false }, // 1451 + { PseudoVMAX_VV_MF8_MASK, PseudoVMAX_VV_MF8, 0x3, false }, // 1452 + { PseudoVMAX_VX_M1_MASK, PseudoVMAX_VX_M1, 0x3, false }, // 1453 + { PseudoVMAX_VX_M2_MASK, PseudoVMAX_VX_M2, 0x3, false }, // 1454 + { PseudoVMAX_VX_M4_MASK, PseudoVMAX_VX_M4, 0x3, false }, // 1455 + { PseudoVMAX_VX_M8_MASK, PseudoVMAX_VX_M8, 0x3, false }, // 1456 + { PseudoVMAX_VX_MF2_MASK, PseudoVMAX_VX_MF2, 0x3, false }, // 1457 + { PseudoVMAX_VX_MF4_MASK, PseudoVMAX_VX_MF4, 0x3, false }, // 1458 + { PseudoVMAX_VX_MF8_MASK, PseudoVMAX_VX_MF8, 0x3, false }, // 1459 + { PseudoVMFEQ_VFPR16_M1_MASK, PseudoVMFEQ_VFPR16_M1, 0x3, false }, // 1460 + { PseudoVMFEQ_VFPR16_M2_MASK, PseudoVMFEQ_VFPR16_M2, 0x3, false }, // 1461 + { PseudoVMFEQ_VFPR16_M4_MASK, PseudoVMFEQ_VFPR16_M4, 0x3, false }, // 1462 + { PseudoVMFEQ_VFPR16_M8_MASK, PseudoVMFEQ_VFPR16_M8, 0x3, false }, // 1463 + { PseudoVMFEQ_VFPR16_MF2_MASK, PseudoVMFEQ_VFPR16_MF2, 0x3, false }, // 1464 + { PseudoVMFEQ_VFPR16_MF4_MASK, PseudoVMFEQ_VFPR16_MF4, 0x3, false }, // 1465 + { PseudoVMFEQ_VFPR32_M1_MASK, PseudoVMFEQ_VFPR32_M1, 0x3, false }, // 1466 + { PseudoVMFEQ_VFPR32_M2_MASK, PseudoVMFEQ_VFPR32_M2, 0x3, false }, // 1467 + { PseudoVMFEQ_VFPR32_M4_MASK, PseudoVMFEQ_VFPR32_M4, 0x3, false }, // 1468 + { PseudoVMFEQ_VFPR32_M8_MASK, PseudoVMFEQ_VFPR32_M8, 0x3, false }, // 1469 + { PseudoVMFEQ_VFPR32_MF2_MASK, PseudoVMFEQ_VFPR32_MF2, 0x3, false }, // 1470 + { PseudoVMFEQ_VFPR64_M1_MASK, PseudoVMFEQ_VFPR64_M1, 0x3, false }, // 1471 + { PseudoVMFEQ_VFPR64_M2_MASK, PseudoVMFEQ_VFPR64_M2, 0x3, false }, // 1472 + { PseudoVMFEQ_VFPR64_M4_MASK, PseudoVMFEQ_VFPR64_M4, 0x3, false }, // 1473 + { PseudoVMFEQ_VFPR64_M8_MASK, PseudoVMFEQ_VFPR64_M8, 0x3, false }, // 1474 + { PseudoVMFEQ_VV_M1_MASK, PseudoVMFEQ_VV_M1, 0x3, false }, // 1475 + { PseudoVMFEQ_VV_M2_MASK, PseudoVMFEQ_VV_M2, 0x3, false }, // 1476 + { PseudoVMFEQ_VV_M4_MASK, PseudoVMFEQ_VV_M4, 0x3, false }, // 1477 + { PseudoVMFEQ_VV_M8_MASK, PseudoVMFEQ_VV_M8, 0x3, false }, // 1478 + { PseudoVMFEQ_VV_MF2_MASK, PseudoVMFEQ_VV_MF2, 0x3, false }, // 1479 + { PseudoVMFEQ_VV_MF4_MASK, PseudoVMFEQ_VV_MF4, 0x3, false }, // 1480 + { PseudoVMFGE_VFPR16_M1_MASK, PseudoVMFGE_VFPR16_M1, 0x3, false }, // 1481 + { PseudoVMFGE_VFPR16_M2_MASK, PseudoVMFGE_VFPR16_M2, 0x3, false }, // 1482 + { PseudoVMFGE_VFPR16_M4_MASK, PseudoVMFGE_VFPR16_M4, 0x3, false }, // 1483 + { PseudoVMFGE_VFPR16_M8_MASK, PseudoVMFGE_VFPR16_M8, 0x3, false }, // 1484 + { PseudoVMFGE_VFPR16_MF2_MASK, PseudoVMFGE_VFPR16_MF2, 0x3, false }, // 1485 + { PseudoVMFGE_VFPR16_MF4_MASK, PseudoVMFGE_VFPR16_MF4, 0x3, false }, // 1486 + { PseudoVMFGE_VFPR32_M1_MASK, PseudoVMFGE_VFPR32_M1, 0x3, false }, // 1487 + { PseudoVMFGE_VFPR32_M2_MASK, PseudoVMFGE_VFPR32_M2, 0x3, false }, // 1488 + { PseudoVMFGE_VFPR32_M4_MASK, PseudoVMFGE_VFPR32_M4, 0x3, false }, // 1489 + { PseudoVMFGE_VFPR32_M8_MASK, PseudoVMFGE_VFPR32_M8, 0x3, false }, // 1490 + { PseudoVMFGE_VFPR32_MF2_MASK, PseudoVMFGE_VFPR32_MF2, 0x3, false }, // 1491 + { PseudoVMFGE_VFPR64_M1_MASK, PseudoVMFGE_VFPR64_M1, 0x3, false }, // 1492 + { PseudoVMFGE_VFPR64_M2_MASK, PseudoVMFGE_VFPR64_M2, 0x3, false }, // 1493 + { PseudoVMFGE_VFPR64_M4_MASK, PseudoVMFGE_VFPR64_M4, 0x3, false }, // 1494 + { PseudoVMFGE_VFPR64_M8_MASK, PseudoVMFGE_VFPR64_M8, 0x3, false }, // 1495 + { PseudoVMFGT_VFPR16_M1_MASK, PseudoVMFGT_VFPR16_M1, 0x3, false }, // 1496 + { PseudoVMFGT_VFPR16_M2_MASK, PseudoVMFGT_VFPR16_M2, 0x3, false }, // 1497 + { PseudoVMFGT_VFPR16_M4_MASK, PseudoVMFGT_VFPR16_M4, 0x3, false }, // 1498 + { PseudoVMFGT_VFPR16_M8_MASK, PseudoVMFGT_VFPR16_M8, 0x3, false }, // 1499 + { PseudoVMFGT_VFPR16_MF2_MASK, PseudoVMFGT_VFPR16_MF2, 0x3, false }, // 1500 + { PseudoVMFGT_VFPR16_MF4_MASK, PseudoVMFGT_VFPR16_MF4, 0x3, false }, // 1501 + { PseudoVMFGT_VFPR32_M1_MASK, PseudoVMFGT_VFPR32_M1, 0x3, false }, // 1502 + { PseudoVMFGT_VFPR32_M2_MASK, PseudoVMFGT_VFPR32_M2, 0x3, false }, // 1503 + { PseudoVMFGT_VFPR32_M4_MASK, PseudoVMFGT_VFPR32_M4, 0x3, false }, // 1504 + { PseudoVMFGT_VFPR32_M8_MASK, PseudoVMFGT_VFPR32_M8, 0x3, false }, // 1505 + { PseudoVMFGT_VFPR32_MF2_MASK, PseudoVMFGT_VFPR32_MF2, 0x3, false }, // 1506 + { PseudoVMFGT_VFPR64_M1_MASK, PseudoVMFGT_VFPR64_M1, 0x3, false }, // 1507 + { PseudoVMFGT_VFPR64_M2_MASK, PseudoVMFGT_VFPR64_M2, 0x3, false }, // 1508 + { PseudoVMFGT_VFPR64_M4_MASK, PseudoVMFGT_VFPR64_M4, 0x3, false }, // 1509 + { PseudoVMFGT_VFPR64_M8_MASK, PseudoVMFGT_VFPR64_M8, 0x3, false }, // 1510 + { PseudoVMFLE_VFPR16_M1_MASK, PseudoVMFLE_VFPR16_M1, 0x3, false }, // 1511 + { PseudoVMFLE_VFPR16_M2_MASK, PseudoVMFLE_VFPR16_M2, 0x3, false }, // 1512 + { PseudoVMFLE_VFPR16_M4_MASK, PseudoVMFLE_VFPR16_M4, 0x3, false }, // 1513 + { PseudoVMFLE_VFPR16_M8_MASK, PseudoVMFLE_VFPR16_M8, 0x3, false }, // 1514 + { PseudoVMFLE_VFPR16_MF2_MASK, PseudoVMFLE_VFPR16_MF2, 0x3, false }, // 1515 + { PseudoVMFLE_VFPR16_MF4_MASK, PseudoVMFLE_VFPR16_MF4, 0x3, false }, // 1516 + { PseudoVMFLE_VFPR32_M1_MASK, PseudoVMFLE_VFPR32_M1, 0x3, false }, // 1517 + { PseudoVMFLE_VFPR32_M2_MASK, PseudoVMFLE_VFPR32_M2, 0x3, false }, // 1518 + { PseudoVMFLE_VFPR32_M4_MASK, PseudoVMFLE_VFPR32_M4, 0x3, false }, // 1519 + { PseudoVMFLE_VFPR32_M8_MASK, PseudoVMFLE_VFPR32_M8, 0x3, false }, // 1520 + { PseudoVMFLE_VFPR32_MF2_MASK, PseudoVMFLE_VFPR32_MF2, 0x3, false }, // 1521 + { PseudoVMFLE_VFPR64_M1_MASK, PseudoVMFLE_VFPR64_M1, 0x3, false }, // 1522 + { PseudoVMFLE_VFPR64_M2_MASK, PseudoVMFLE_VFPR64_M2, 0x3, false }, // 1523 + { PseudoVMFLE_VFPR64_M4_MASK, PseudoVMFLE_VFPR64_M4, 0x3, false }, // 1524 + { PseudoVMFLE_VFPR64_M8_MASK, PseudoVMFLE_VFPR64_M8, 0x3, false }, // 1525 + { PseudoVMFLE_VV_M1_MASK, PseudoVMFLE_VV_M1, 0x3, false }, // 1526 + { PseudoVMFLE_VV_M2_MASK, PseudoVMFLE_VV_M2, 0x3, false }, // 1527 + { PseudoVMFLE_VV_M4_MASK, PseudoVMFLE_VV_M4, 0x3, false }, // 1528 + { PseudoVMFLE_VV_M8_MASK, PseudoVMFLE_VV_M8, 0x3, false }, // 1529 + { PseudoVMFLE_VV_MF2_MASK, PseudoVMFLE_VV_MF2, 0x3, false }, // 1530 + { PseudoVMFLE_VV_MF4_MASK, PseudoVMFLE_VV_MF4, 0x3, false }, // 1531 + { PseudoVMFLT_VFPR16_M1_MASK, PseudoVMFLT_VFPR16_M1, 0x3, false }, // 1532 + { PseudoVMFLT_VFPR16_M2_MASK, PseudoVMFLT_VFPR16_M2, 0x3, false }, // 1533 + { PseudoVMFLT_VFPR16_M4_MASK, PseudoVMFLT_VFPR16_M4, 0x3, false }, // 1534 + { PseudoVMFLT_VFPR16_M8_MASK, PseudoVMFLT_VFPR16_M8, 0x3, false }, // 1535 + { PseudoVMFLT_VFPR16_MF2_MASK, PseudoVMFLT_VFPR16_MF2, 0x3, false }, // 1536 + { PseudoVMFLT_VFPR16_MF4_MASK, PseudoVMFLT_VFPR16_MF4, 0x3, false }, // 1537 + { PseudoVMFLT_VFPR32_M1_MASK, PseudoVMFLT_VFPR32_M1, 0x3, false }, // 1538 + { PseudoVMFLT_VFPR32_M2_MASK, PseudoVMFLT_VFPR32_M2, 0x3, false }, // 1539 + { PseudoVMFLT_VFPR32_M4_MASK, PseudoVMFLT_VFPR32_M4, 0x3, false }, // 1540 + { PseudoVMFLT_VFPR32_M8_MASK, PseudoVMFLT_VFPR32_M8, 0x3, false }, // 1541 + { PseudoVMFLT_VFPR32_MF2_MASK, PseudoVMFLT_VFPR32_MF2, 0x3, false }, // 1542 + { PseudoVMFLT_VFPR64_M1_MASK, PseudoVMFLT_VFPR64_M1, 0x3, false }, // 1543 + { PseudoVMFLT_VFPR64_M2_MASK, PseudoVMFLT_VFPR64_M2, 0x3, false }, // 1544 + { PseudoVMFLT_VFPR64_M4_MASK, PseudoVMFLT_VFPR64_M4, 0x3, false }, // 1545 + { PseudoVMFLT_VFPR64_M8_MASK, PseudoVMFLT_VFPR64_M8, 0x3, false }, // 1546 + { PseudoVMFLT_VV_M1_MASK, PseudoVMFLT_VV_M1, 0x3, false }, // 1547 + { PseudoVMFLT_VV_M2_MASK, PseudoVMFLT_VV_M2, 0x3, false }, // 1548 + { PseudoVMFLT_VV_M4_MASK, PseudoVMFLT_VV_M4, 0x3, false }, // 1549 + { PseudoVMFLT_VV_M8_MASK, PseudoVMFLT_VV_M8, 0x3, false }, // 1550 + { PseudoVMFLT_VV_MF2_MASK, PseudoVMFLT_VV_MF2, 0x3, false }, // 1551 + { PseudoVMFLT_VV_MF4_MASK, PseudoVMFLT_VV_MF4, 0x3, false }, // 1552 + { PseudoVMFNE_VFPR16_M1_MASK, PseudoVMFNE_VFPR16_M1, 0x3, false }, // 1553 + { PseudoVMFNE_VFPR16_M2_MASK, PseudoVMFNE_VFPR16_M2, 0x3, false }, // 1554 + { PseudoVMFNE_VFPR16_M4_MASK, PseudoVMFNE_VFPR16_M4, 0x3, false }, // 1555 + { PseudoVMFNE_VFPR16_M8_MASK, PseudoVMFNE_VFPR16_M8, 0x3, false }, // 1556 + { PseudoVMFNE_VFPR16_MF2_MASK, PseudoVMFNE_VFPR16_MF2, 0x3, false }, // 1557 + { PseudoVMFNE_VFPR16_MF4_MASK, PseudoVMFNE_VFPR16_MF4, 0x3, false }, // 1558 + { PseudoVMFNE_VFPR32_M1_MASK, PseudoVMFNE_VFPR32_M1, 0x3, false }, // 1559 + { PseudoVMFNE_VFPR32_M2_MASK, PseudoVMFNE_VFPR32_M2, 0x3, false }, // 1560 + { PseudoVMFNE_VFPR32_M4_MASK, PseudoVMFNE_VFPR32_M4, 0x3, false }, // 1561 + { PseudoVMFNE_VFPR32_M8_MASK, PseudoVMFNE_VFPR32_M8, 0x3, false }, // 1562 + { PseudoVMFNE_VFPR32_MF2_MASK, PseudoVMFNE_VFPR32_MF2, 0x3, false }, // 1563 + { PseudoVMFNE_VFPR64_M1_MASK, PseudoVMFNE_VFPR64_M1, 0x3, false }, // 1564 + { PseudoVMFNE_VFPR64_M2_MASK, PseudoVMFNE_VFPR64_M2, 0x3, false }, // 1565 + { PseudoVMFNE_VFPR64_M4_MASK, PseudoVMFNE_VFPR64_M4, 0x3, false }, // 1566 + { PseudoVMFNE_VFPR64_M8_MASK, PseudoVMFNE_VFPR64_M8, 0x3, false }, // 1567 + { PseudoVMFNE_VV_M1_MASK, PseudoVMFNE_VV_M1, 0x3, false }, // 1568 + { PseudoVMFNE_VV_M2_MASK, PseudoVMFNE_VV_M2, 0x3, false }, // 1569 + { PseudoVMFNE_VV_M4_MASK, PseudoVMFNE_VV_M4, 0x3, false }, // 1570 + { PseudoVMFNE_VV_M8_MASK, PseudoVMFNE_VV_M8, 0x3, false }, // 1571 + { PseudoVMFNE_VV_MF2_MASK, PseudoVMFNE_VV_MF2, 0x3, false }, // 1572 + { PseudoVMFNE_VV_MF4_MASK, PseudoVMFNE_VV_MF4, 0x3, false }, // 1573 + { PseudoVMINU_VV_M1_MASK, PseudoVMINU_VV_M1, 0x3, false }, // 1574 + { PseudoVMINU_VV_M2_MASK, PseudoVMINU_VV_M2, 0x3, false }, // 1575 + { PseudoVMINU_VV_M4_MASK, PseudoVMINU_VV_M4, 0x3, false }, // 1576 + { PseudoVMINU_VV_M8_MASK, PseudoVMINU_VV_M8, 0x3, false }, // 1577 + { PseudoVMINU_VV_MF2_MASK, PseudoVMINU_VV_MF2, 0x3, false }, // 1578 + { PseudoVMINU_VV_MF4_MASK, PseudoVMINU_VV_MF4, 0x3, false }, // 1579 + { PseudoVMINU_VV_MF8_MASK, PseudoVMINU_VV_MF8, 0x3, false }, // 1580 + { PseudoVMINU_VX_M1_MASK, PseudoVMINU_VX_M1, 0x3, false }, // 1581 + { PseudoVMINU_VX_M2_MASK, PseudoVMINU_VX_M2, 0x3, false }, // 1582 + { PseudoVMINU_VX_M4_MASK, PseudoVMINU_VX_M4, 0x3, false }, // 1583 + { PseudoVMINU_VX_M8_MASK, PseudoVMINU_VX_M8, 0x3, false }, // 1584 + { PseudoVMINU_VX_MF2_MASK, PseudoVMINU_VX_MF2, 0x3, false }, // 1585 + { PseudoVMINU_VX_MF4_MASK, PseudoVMINU_VX_MF4, 0x3, false }, // 1586 + { PseudoVMINU_VX_MF8_MASK, PseudoVMINU_VX_MF8, 0x3, false }, // 1587 + { PseudoVMIN_VV_M1_MASK, PseudoVMIN_VV_M1, 0x3, false }, // 1588 + { PseudoVMIN_VV_M2_MASK, PseudoVMIN_VV_M2, 0x3, false }, // 1589 + { PseudoVMIN_VV_M4_MASK, PseudoVMIN_VV_M4, 0x3, false }, // 1590 + { PseudoVMIN_VV_M8_MASK, PseudoVMIN_VV_M8, 0x3, false }, // 1591 + { PseudoVMIN_VV_MF2_MASK, PseudoVMIN_VV_MF2, 0x3, false }, // 1592 + { PseudoVMIN_VV_MF4_MASK, PseudoVMIN_VV_MF4, 0x3, false }, // 1593 + { PseudoVMIN_VV_MF8_MASK, PseudoVMIN_VV_MF8, 0x3, false }, // 1594 + { PseudoVMIN_VX_M1_MASK, PseudoVMIN_VX_M1, 0x3, false }, // 1595 + { PseudoVMIN_VX_M2_MASK, PseudoVMIN_VX_M2, 0x3, false }, // 1596 + { PseudoVMIN_VX_M4_MASK, PseudoVMIN_VX_M4, 0x3, false }, // 1597 + { PseudoVMIN_VX_M8_MASK, PseudoVMIN_VX_M8, 0x3, false }, // 1598 + { PseudoVMIN_VX_MF2_MASK, PseudoVMIN_VX_MF2, 0x3, false }, // 1599 + { PseudoVMIN_VX_MF4_MASK, PseudoVMIN_VX_MF4, 0x3, false }, // 1600 + { PseudoVMIN_VX_MF8_MASK, PseudoVMIN_VX_MF8, 0x3, false }, // 1601 + { PseudoVMSEQ_VI_M1_MASK, PseudoVMSEQ_VI_M1, 0x3, false }, // 1602 + { PseudoVMSEQ_VI_M2_MASK, PseudoVMSEQ_VI_M2, 0x3, false }, // 1603 + { PseudoVMSEQ_VI_M4_MASK, PseudoVMSEQ_VI_M4, 0x3, false }, // 1604 + { PseudoVMSEQ_VI_M8_MASK, PseudoVMSEQ_VI_M8, 0x3, false }, // 1605 + { PseudoVMSEQ_VI_MF2_MASK, PseudoVMSEQ_VI_MF2, 0x3, false }, // 1606 + { PseudoVMSEQ_VI_MF4_MASK, PseudoVMSEQ_VI_MF4, 0x3, false }, // 1607 + { PseudoVMSEQ_VI_MF8_MASK, PseudoVMSEQ_VI_MF8, 0x3, false }, // 1608 + { PseudoVMSEQ_VV_M1_MASK, PseudoVMSEQ_VV_M1, 0x3, false }, // 1609 + { PseudoVMSEQ_VV_M2_MASK, PseudoVMSEQ_VV_M2, 0x3, false }, // 1610 + { PseudoVMSEQ_VV_M4_MASK, PseudoVMSEQ_VV_M4, 0x3, false }, // 1611 + { PseudoVMSEQ_VV_M8_MASK, PseudoVMSEQ_VV_M8, 0x3, false }, // 1612 + { PseudoVMSEQ_VV_MF2_MASK, PseudoVMSEQ_VV_MF2, 0x3, false }, // 1613 + { PseudoVMSEQ_VV_MF4_MASK, PseudoVMSEQ_VV_MF4, 0x3, false }, // 1614 + { PseudoVMSEQ_VV_MF8_MASK, PseudoVMSEQ_VV_MF8, 0x3, false }, // 1615 + { PseudoVMSEQ_VX_M1_MASK, PseudoVMSEQ_VX_M1, 0x3, false }, // 1616 + { PseudoVMSEQ_VX_M2_MASK, PseudoVMSEQ_VX_M2, 0x3, false }, // 1617 + { PseudoVMSEQ_VX_M4_MASK, PseudoVMSEQ_VX_M4, 0x3, false }, // 1618 + { PseudoVMSEQ_VX_M8_MASK, PseudoVMSEQ_VX_M8, 0x3, false }, // 1619 + { PseudoVMSEQ_VX_MF2_MASK, PseudoVMSEQ_VX_MF2, 0x3, false }, // 1620 + { PseudoVMSEQ_VX_MF4_MASK, PseudoVMSEQ_VX_MF4, 0x3, false }, // 1621 + { PseudoVMSEQ_VX_MF8_MASK, PseudoVMSEQ_VX_MF8, 0x3, false }, // 1622 + { PseudoVMSGTU_VI_M1_MASK, PseudoVMSGTU_VI_M1, 0x3, false }, // 1623 + { PseudoVMSGTU_VI_M2_MASK, PseudoVMSGTU_VI_M2, 0x3, false }, // 1624 + { PseudoVMSGTU_VI_M4_MASK, PseudoVMSGTU_VI_M4, 0x3, false }, // 1625 + { PseudoVMSGTU_VI_M8_MASK, PseudoVMSGTU_VI_M8, 0x3, false }, // 1626 + { PseudoVMSGTU_VI_MF2_MASK, PseudoVMSGTU_VI_MF2, 0x3, false }, // 1627 + { PseudoVMSGTU_VI_MF4_MASK, PseudoVMSGTU_VI_MF4, 0x3, false }, // 1628 + { PseudoVMSGTU_VI_MF8_MASK, PseudoVMSGTU_VI_MF8, 0x3, false }, // 1629 + { PseudoVMSGTU_VX_M1_MASK, PseudoVMSGTU_VX_M1, 0x3, false }, // 1630 + { PseudoVMSGTU_VX_M2_MASK, PseudoVMSGTU_VX_M2, 0x3, false }, // 1631 + { PseudoVMSGTU_VX_M4_MASK, PseudoVMSGTU_VX_M4, 0x3, false }, // 1632 + { PseudoVMSGTU_VX_M8_MASK, PseudoVMSGTU_VX_M8, 0x3, false }, // 1633 + { PseudoVMSGTU_VX_MF2_MASK, PseudoVMSGTU_VX_MF2, 0x3, false }, // 1634 + { PseudoVMSGTU_VX_MF4_MASK, PseudoVMSGTU_VX_MF4, 0x3, false }, // 1635 + { PseudoVMSGTU_VX_MF8_MASK, PseudoVMSGTU_VX_MF8, 0x3, false }, // 1636 + { PseudoVMSGT_VI_M1_MASK, PseudoVMSGT_VI_M1, 0x3, false }, // 1637 + { PseudoVMSGT_VI_M2_MASK, PseudoVMSGT_VI_M2, 0x3, false }, // 1638 + { PseudoVMSGT_VI_M4_MASK, PseudoVMSGT_VI_M4, 0x3, false }, // 1639 + { PseudoVMSGT_VI_M8_MASK, PseudoVMSGT_VI_M8, 0x3, false }, // 1640 + { PseudoVMSGT_VI_MF2_MASK, PseudoVMSGT_VI_MF2, 0x3, false }, // 1641 + { PseudoVMSGT_VI_MF4_MASK, PseudoVMSGT_VI_MF4, 0x3, false }, // 1642 + { PseudoVMSGT_VI_MF8_MASK, PseudoVMSGT_VI_MF8, 0x3, false }, // 1643 + { PseudoVMSGT_VX_M1_MASK, PseudoVMSGT_VX_M1, 0x3, false }, // 1644 + { PseudoVMSGT_VX_M2_MASK, PseudoVMSGT_VX_M2, 0x3, false }, // 1645 + { PseudoVMSGT_VX_M4_MASK, PseudoVMSGT_VX_M4, 0x3, false }, // 1646 + { PseudoVMSGT_VX_M8_MASK, PseudoVMSGT_VX_M8, 0x3, false }, // 1647 + { PseudoVMSGT_VX_MF2_MASK, PseudoVMSGT_VX_MF2, 0x3, false }, // 1648 + { PseudoVMSGT_VX_MF4_MASK, PseudoVMSGT_VX_MF4, 0x3, false }, // 1649 + { PseudoVMSGT_VX_MF8_MASK, PseudoVMSGT_VX_MF8, 0x3, false }, // 1650 + { PseudoVMSLEU_VI_M1_MASK, PseudoVMSLEU_VI_M1, 0x3, false }, // 1651 + { PseudoVMSLEU_VI_M2_MASK, PseudoVMSLEU_VI_M2, 0x3, false }, // 1652 + { PseudoVMSLEU_VI_M4_MASK, PseudoVMSLEU_VI_M4, 0x3, false }, // 1653 + { PseudoVMSLEU_VI_M8_MASK, PseudoVMSLEU_VI_M8, 0x3, false }, // 1654 + { PseudoVMSLEU_VI_MF2_MASK, PseudoVMSLEU_VI_MF2, 0x3, false }, // 1655 + { PseudoVMSLEU_VI_MF4_MASK, PseudoVMSLEU_VI_MF4, 0x3, false }, // 1656 + { PseudoVMSLEU_VI_MF8_MASK, PseudoVMSLEU_VI_MF8, 0x3, false }, // 1657 + { PseudoVMSLEU_VV_M1_MASK, PseudoVMSLEU_VV_M1, 0x3, false }, // 1658 + { PseudoVMSLEU_VV_M2_MASK, PseudoVMSLEU_VV_M2, 0x3, false }, // 1659 + { PseudoVMSLEU_VV_M4_MASK, PseudoVMSLEU_VV_M4, 0x3, false }, // 1660 + { PseudoVMSLEU_VV_M8_MASK, PseudoVMSLEU_VV_M8, 0x3, false }, // 1661 + { PseudoVMSLEU_VV_MF2_MASK, PseudoVMSLEU_VV_MF2, 0x3, false }, // 1662 + { PseudoVMSLEU_VV_MF4_MASK, PseudoVMSLEU_VV_MF4, 0x3, false }, // 1663 + { PseudoVMSLEU_VV_MF8_MASK, PseudoVMSLEU_VV_MF8, 0x3, false }, // 1664 + { PseudoVMSLEU_VX_M1_MASK, PseudoVMSLEU_VX_M1, 0x3, false }, // 1665 + { PseudoVMSLEU_VX_M2_MASK, PseudoVMSLEU_VX_M2, 0x3, false }, // 1666 + { PseudoVMSLEU_VX_M4_MASK, PseudoVMSLEU_VX_M4, 0x3, false }, // 1667 + { PseudoVMSLEU_VX_M8_MASK, PseudoVMSLEU_VX_M8, 0x3, false }, // 1668 + { PseudoVMSLEU_VX_MF2_MASK, PseudoVMSLEU_VX_MF2, 0x3, false }, // 1669 + { PseudoVMSLEU_VX_MF4_MASK, PseudoVMSLEU_VX_MF4, 0x3, false }, // 1670 + { PseudoVMSLEU_VX_MF8_MASK, PseudoVMSLEU_VX_MF8, 0x3, false }, // 1671 + { PseudoVMSLE_VI_M1_MASK, PseudoVMSLE_VI_M1, 0x3, false }, // 1672 + { PseudoVMSLE_VI_M2_MASK, PseudoVMSLE_VI_M2, 0x3, false }, // 1673 + { PseudoVMSLE_VI_M4_MASK, PseudoVMSLE_VI_M4, 0x3, false }, // 1674 + { PseudoVMSLE_VI_M8_MASK, PseudoVMSLE_VI_M8, 0x3, false }, // 1675 + { PseudoVMSLE_VI_MF2_MASK, PseudoVMSLE_VI_MF2, 0x3, false }, // 1676 + { PseudoVMSLE_VI_MF4_MASK, PseudoVMSLE_VI_MF4, 0x3, false }, // 1677 + { PseudoVMSLE_VI_MF8_MASK, PseudoVMSLE_VI_MF8, 0x3, false }, // 1678 + { PseudoVMSLE_VV_M1_MASK, PseudoVMSLE_VV_M1, 0x3, false }, // 1679 + { PseudoVMSLE_VV_M2_MASK, PseudoVMSLE_VV_M2, 0x3, false }, // 1680 + { PseudoVMSLE_VV_M4_MASK, PseudoVMSLE_VV_M4, 0x3, false }, // 1681 + { PseudoVMSLE_VV_M8_MASK, PseudoVMSLE_VV_M8, 0x3, false }, // 1682 + { PseudoVMSLE_VV_MF2_MASK, PseudoVMSLE_VV_MF2, 0x3, false }, // 1683 + { PseudoVMSLE_VV_MF4_MASK, PseudoVMSLE_VV_MF4, 0x3, false }, // 1684 + { PseudoVMSLE_VV_MF8_MASK, PseudoVMSLE_VV_MF8, 0x3, false }, // 1685 + { PseudoVMSLE_VX_M1_MASK, PseudoVMSLE_VX_M1, 0x3, false }, // 1686 + { PseudoVMSLE_VX_M2_MASK, PseudoVMSLE_VX_M2, 0x3, false }, // 1687 + { PseudoVMSLE_VX_M4_MASK, PseudoVMSLE_VX_M4, 0x3, false }, // 1688 + { PseudoVMSLE_VX_M8_MASK, PseudoVMSLE_VX_M8, 0x3, false }, // 1689 + { PseudoVMSLE_VX_MF2_MASK, PseudoVMSLE_VX_MF2, 0x3, false }, // 1690 + { PseudoVMSLE_VX_MF4_MASK, PseudoVMSLE_VX_MF4, 0x3, false }, // 1691 + { PseudoVMSLE_VX_MF8_MASK, PseudoVMSLE_VX_MF8, 0x3, false }, // 1692 + { PseudoVMSLTU_VV_M1_MASK, PseudoVMSLTU_VV_M1, 0x3, false }, // 1693 + { PseudoVMSLTU_VV_M2_MASK, PseudoVMSLTU_VV_M2, 0x3, false }, // 1694 + { PseudoVMSLTU_VV_M4_MASK, PseudoVMSLTU_VV_M4, 0x3, false }, // 1695 + { PseudoVMSLTU_VV_M8_MASK, PseudoVMSLTU_VV_M8, 0x3, false }, // 1696 + { PseudoVMSLTU_VV_MF2_MASK, PseudoVMSLTU_VV_MF2, 0x3, false }, // 1697 + { PseudoVMSLTU_VV_MF4_MASK, PseudoVMSLTU_VV_MF4, 0x3, false }, // 1698 + { PseudoVMSLTU_VV_MF8_MASK, PseudoVMSLTU_VV_MF8, 0x3, false }, // 1699 + { PseudoVMSLTU_VX_M1_MASK, PseudoVMSLTU_VX_M1, 0x3, false }, // 1700 + { PseudoVMSLTU_VX_M2_MASK, PseudoVMSLTU_VX_M2, 0x3, false }, // 1701 + { PseudoVMSLTU_VX_M4_MASK, PseudoVMSLTU_VX_M4, 0x3, false }, // 1702 + { PseudoVMSLTU_VX_M8_MASK, PseudoVMSLTU_VX_M8, 0x3, false }, // 1703 + { PseudoVMSLTU_VX_MF2_MASK, PseudoVMSLTU_VX_MF2, 0x3, false }, // 1704 + { PseudoVMSLTU_VX_MF4_MASK, PseudoVMSLTU_VX_MF4, 0x3, false }, // 1705 + { PseudoVMSLTU_VX_MF8_MASK, PseudoVMSLTU_VX_MF8, 0x3, false }, // 1706 + { PseudoVMSLT_VV_M1_MASK, PseudoVMSLT_VV_M1, 0x3, false }, // 1707 + { PseudoVMSLT_VV_M2_MASK, PseudoVMSLT_VV_M2, 0x3, false }, // 1708 + { PseudoVMSLT_VV_M4_MASK, PseudoVMSLT_VV_M4, 0x3, false }, // 1709 + { PseudoVMSLT_VV_M8_MASK, PseudoVMSLT_VV_M8, 0x3, false }, // 1710 + { PseudoVMSLT_VV_MF2_MASK, PseudoVMSLT_VV_MF2, 0x3, false }, // 1711 + { PseudoVMSLT_VV_MF4_MASK, PseudoVMSLT_VV_MF4, 0x3, false }, // 1712 + { PseudoVMSLT_VV_MF8_MASK, PseudoVMSLT_VV_MF8, 0x3, false }, // 1713 + { PseudoVMSLT_VX_M1_MASK, PseudoVMSLT_VX_M1, 0x3, false }, // 1714 + { PseudoVMSLT_VX_M2_MASK, PseudoVMSLT_VX_M2, 0x3, false }, // 1715 + { PseudoVMSLT_VX_M4_MASK, PseudoVMSLT_VX_M4, 0x3, false }, // 1716 + { PseudoVMSLT_VX_M8_MASK, PseudoVMSLT_VX_M8, 0x3, false }, // 1717 + { PseudoVMSLT_VX_MF2_MASK, PseudoVMSLT_VX_MF2, 0x3, false }, // 1718 + { PseudoVMSLT_VX_MF4_MASK, PseudoVMSLT_VX_MF4, 0x3, false }, // 1719 + { PseudoVMSLT_VX_MF8_MASK, PseudoVMSLT_VX_MF8, 0x3, false }, // 1720 + { PseudoVMSNE_VI_M1_MASK, PseudoVMSNE_VI_M1, 0x3, false }, // 1721 + { PseudoVMSNE_VI_M2_MASK, PseudoVMSNE_VI_M2, 0x3, false }, // 1722 + { PseudoVMSNE_VI_M4_MASK, PseudoVMSNE_VI_M4, 0x3, false }, // 1723 + { PseudoVMSNE_VI_M8_MASK, PseudoVMSNE_VI_M8, 0x3, false }, // 1724 + { PseudoVMSNE_VI_MF2_MASK, PseudoVMSNE_VI_MF2, 0x3, false }, // 1725 + { PseudoVMSNE_VI_MF4_MASK, PseudoVMSNE_VI_MF4, 0x3, false }, // 1726 + { PseudoVMSNE_VI_MF8_MASK, PseudoVMSNE_VI_MF8, 0x3, false }, // 1727 + { PseudoVMSNE_VV_M1_MASK, PseudoVMSNE_VV_M1, 0x3, false }, // 1728 + { PseudoVMSNE_VV_M2_MASK, PseudoVMSNE_VV_M2, 0x3, false }, // 1729 + { PseudoVMSNE_VV_M4_MASK, PseudoVMSNE_VV_M4, 0x3, false }, // 1730 + { PseudoVMSNE_VV_M8_MASK, PseudoVMSNE_VV_M8, 0x3, false }, // 1731 + { PseudoVMSNE_VV_MF2_MASK, PseudoVMSNE_VV_MF2, 0x3, false }, // 1732 + { PseudoVMSNE_VV_MF4_MASK, PseudoVMSNE_VV_MF4, 0x3, false }, // 1733 + { PseudoVMSNE_VV_MF8_MASK, PseudoVMSNE_VV_MF8, 0x3, false }, // 1734 + { PseudoVMSNE_VX_M1_MASK, PseudoVMSNE_VX_M1, 0x3, false }, // 1735 + { PseudoVMSNE_VX_M2_MASK, PseudoVMSNE_VX_M2, 0x3, false }, // 1736 + { PseudoVMSNE_VX_M4_MASK, PseudoVMSNE_VX_M4, 0x3, false }, // 1737 + { PseudoVMSNE_VX_M8_MASK, PseudoVMSNE_VX_M8, 0x3, false }, // 1738 + { PseudoVMSNE_VX_MF2_MASK, PseudoVMSNE_VX_MF2, 0x3, false }, // 1739 + { PseudoVMSNE_VX_MF4_MASK, PseudoVMSNE_VX_MF4, 0x3, false }, // 1740 + { PseudoVMSNE_VX_MF8_MASK, PseudoVMSNE_VX_MF8, 0x3, false }, // 1741 + { PseudoVMULHSU_VV_M1_MASK, PseudoVMULHSU_VV_M1, 0x3, false }, // 1742 + { PseudoVMULHSU_VV_M2_MASK, PseudoVMULHSU_VV_M2, 0x3, false }, // 1743 + { PseudoVMULHSU_VV_M4_MASK, PseudoVMULHSU_VV_M4, 0x3, false }, // 1744 + { PseudoVMULHSU_VV_M8_MASK, PseudoVMULHSU_VV_M8, 0x3, false }, // 1745 + { PseudoVMULHSU_VV_MF2_MASK, PseudoVMULHSU_VV_MF2, 0x3, false }, // 1746 + { PseudoVMULHSU_VV_MF4_MASK, PseudoVMULHSU_VV_MF4, 0x3, false }, // 1747 + { PseudoVMULHSU_VV_MF8_MASK, PseudoVMULHSU_VV_MF8, 0x3, false }, // 1748 + { PseudoVMULHSU_VX_M1_MASK, PseudoVMULHSU_VX_M1, 0x3, false }, // 1749 + { PseudoVMULHSU_VX_M2_MASK, PseudoVMULHSU_VX_M2, 0x3, false }, // 1750 + { PseudoVMULHSU_VX_M4_MASK, PseudoVMULHSU_VX_M4, 0x3, false }, // 1751 + { PseudoVMULHSU_VX_M8_MASK, PseudoVMULHSU_VX_M8, 0x3, false }, // 1752 + { PseudoVMULHSU_VX_MF2_MASK, PseudoVMULHSU_VX_MF2, 0x3, false }, // 1753 + { PseudoVMULHSU_VX_MF4_MASK, PseudoVMULHSU_VX_MF4, 0x3, false }, // 1754 + { PseudoVMULHSU_VX_MF8_MASK, PseudoVMULHSU_VX_MF8, 0x3, false }, // 1755 + { PseudoVMULHU_VV_M1_MASK, PseudoVMULHU_VV_M1, 0x3, false }, // 1756 + { PseudoVMULHU_VV_M2_MASK, PseudoVMULHU_VV_M2, 0x3, false }, // 1757 + { PseudoVMULHU_VV_M4_MASK, PseudoVMULHU_VV_M4, 0x3, false }, // 1758 + { PseudoVMULHU_VV_M8_MASK, PseudoVMULHU_VV_M8, 0x3, false }, // 1759 + { PseudoVMULHU_VV_MF2_MASK, PseudoVMULHU_VV_MF2, 0x3, false }, // 1760 + { PseudoVMULHU_VV_MF4_MASK, PseudoVMULHU_VV_MF4, 0x3, false }, // 1761 + { PseudoVMULHU_VV_MF8_MASK, PseudoVMULHU_VV_MF8, 0x3, false }, // 1762 + { PseudoVMULHU_VX_M1_MASK, PseudoVMULHU_VX_M1, 0x3, false }, // 1763 + { PseudoVMULHU_VX_M2_MASK, PseudoVMULHU_VX_M2, 0x3, false }, // 1764 + { PseudoVMULHU_VX_M4_MASK, PseudoVMULHU_VX_M4, 0x3, false }, // 1765 + { PseudoVMULHU_VX_M8_MASK, PseudoVMULHU_VX_M8, 0x3, false }, // 1766 + { PseudoVMULHU_VX_MF2_MASK, PseudoVMULHU_VX_MF2, 0x3, false }, // 1767 + { PseudoVMULHU_VX_MF4_MASK, PseudoVMULHU_VX_MF4, 0x3, false }, // 1768 + { PseudoVMULHU_VX_MF8_MASK, PseudoVMULHU_VX_MF8, 0x3, false }, // 1769 + { PseudoVMULH_VV_M1_MASK, PseudoVMULH_VV_M1, 0x3, false }, // 1770 + { PseudoVMULH_VV_M2_MASK, PseudoVMULH_VV_M2, 0x3, false }, // 1771 + { PseudoVMULH_VV_M4_MASK, PseudoVMULH_VV_M4, 0x3, false }, // 1772 + { PseudoVMULH_VV_M8_MASK, PseudoVMULH_VV_M8, 0x3, false }, // 1773 + { PseudoVMULH_VV_MF2_MASK, PseudoVMULH_VV_MF2, 0x3, false }, // 1774 + { PseudoVMULH_VV_MF4_MASK, PseudoVMULH_VV_MF4, 0x3, false }, // 1775 + { PseudoVMULH_VV_MF8_MASK, PseudoVMULH_VV_MF8, 0x3, false }, // 1776 + { PseudoVMULH_VX_M1_MASK, PseudoVMULH_VX_M1, 0x3, false }, // 1777 + { PseudoVMULH_VX_M2_MASK, PseudoVMULH_VX_M2, 0x3, false }, // 1778 + { PseudoVMULH_VX_M4_MASK, PseudoVMULH_VX_M4, 0x3, false }, // 1779 + { PseudoVMULH_VX_M8_MASK, PseudoVMULH_VX_M8, 0x3, false }, // 1780 + { PseudoVMULH_VX_MF2_MASK, PseudoVMULH_VX_MF2, 0x3, false }, // 1781 + { PseudoVMULH_VX_MF4_MASK, PseudoVMULH_VX_MF4, 0x3, false }, // 1782 + { PseudoVMULH_VX_MF8_MASK, PseudoVMULH_VX_MF8, 0x3, false }, // 1783 + { PseudoVMUL_VV_M1_MASK, PseudoVMUL_VV_M1, 0x3, false }, // 1784 + { PseudoVMUL_VV_M2_MASK, PseudoVMUL_VV_M2, 0x3, false }, // 1785 + { PseudoVMUL_VV_M4_MASK, PseudoVMUL_VV_M4, 0x3, false }, // 1786 + { PseudoVMUL_VV_M8_MASK, PseudoVMUL_VV_M8, 0x3, false }, // 1787 + { PseudoVMUL_VV_MF2_MASK, PseudoVMUL_VV_MF2, 0x3, false }, // 1788 + { PseudoVMUL_VV_MF4_MASK, PseudoVMUL_VV_MF4, 0x3, false }, // 1789 + { PseudoVMUL_VV_MF8_MASK, PseudoVMUL_VV_MF8, 0x3, false }, // 1790 + { PseudoVMUL_VX_M1_MASK, PseudoVMUL_VX_M1, 0x3, false }, // 1791 + { PseudoVMUL_VX_M2_MASK, PseudoVMUL_VX_M2, 0x3, false }, // 1792 + { PseudoVMUL_VX_M4_MASK, PseudoVMUL_VX_M4, 0x3, false }, // 1793 + { PseudoVMUL_VX_M8_MASK, PseudoVMUL_VX_M8, 0x3, false }, // 1794 + { PseudoVMUL_VX_MF2_MASK, PseudoVMUL_VX_MF2, 0x3, false }, // 1795 + { PseudoVMUL_VX_MF4_MASK, PseudoVMUL_VX_MF4, 0x3, false }, // 1796 + { PseudoVMUL_VX_MF8_MASK, PseudoVMUL_VX_MF8, 0x3, false }, // 1797 + { PseudoVNCLIPU_WI_M1_MASK, PseudoVNCLIPU_WI_M1, 0x3, false }, // 1798 + { PseudoVNCLIPU_WI_M2_MASK, PseudoVNCLIPU_WI_M2, 0x3, false }, // 1799 + { PseudoVNCLIPU_WI_M4_MASK, PseudoVNCLIPU_WI_M4, 0x3, false }, // 1800 + { PseudoVNCLIPU_WI_MF2_MASK, PseudoVNCLIPU_WI_MF2, 0x3, false }, // 1801 + { PseudoVNCLIPU_WI_MF4_MASK, PseudoVNCLIPU_WI_MF4, 0x3, false }, // 1802 + { PseudoVNCLIPU_WI_MF8_MASK, PseudoVNCLIPU_WI_MF8, 0x3, false }, // 1803 + { PseudoVNCLIPU_WV_M1_MASK, PseudoVNCLIPU_WV_M1, 0x3, false }, // 1804 + { PseudoVNCLIPU_WV_M2_MASK, PseudoVNCLIPU_WV_M2, 0x3, false }, // 1805 + { PseudoVNCLIPU_WV_M4_MASK, PseudoVNCLIPU_WV_M4, 0x3, false }, // 1806 + { PseudoVNCLIPU_WV_MF2_MASK, PseudoVNCLIPU_WV_MF2, 0x3, false }, // 1807 + { PseudoVNCLIPU_WV_MF4_MASK, PseudoVNCLIPU_WV_MF4, 0x3, false }, // 1808 + { PseudoVNCLIPU_WV_MF8_MASK, PseudoVNCLIPU_WV_MF8, 0x3, false }, // 1809 + { PseudoVNCLIPU_WX_M1_MASK, PseudoVNCLIPU_WX_M1, 0x3, false }, // 1810 + { PseudoVNCLIPU_WX_M2_MASK, PseudoVNCLIPU_WX_M2, 0x3, false }, // 1811 + { PseudoVNCLIPU_WX_M4_MASK, PseudoVNCLIPU_WX_M4, 0x3, false }, // 1812 + { PseudoVNCLIPU_WX_MF2_MASK, PseudoVNCLIPU_WX_MF2, 0x3, false }, // 1813 + { PseudoVNCLIPU_WX_MF4_MASK, PseudoVNCLIPU_WX_MF4, 0x3, false }, // 1814 + { PseudoVNCLIPU_WX_MF8_MASK, PseudoVNCLIPU_WX_MF8, 0x3, false }, // 1815 + { PseudoVNCLIP_WI_M1_MASK, PseudoVNCLIP_WI_M1, 0x3, false }, // 1816 + { PseudoVNCLIP_WI_M2_MASK, PseudoVNCLIP_WI_M2, 0x3, false }, // 1817 + { PseudoVNCLIP_WI_M4_MASK, PseudoVNCLIP_WI_M4, 0x3, false }, // 1818 + { PseudoVNCLIP_WI_MF2_MASK, PseudoVNCLIP_WI_MF2, 0x3, false }, // 1819 + { PseudoVNCLIP_WI_MF4_MASK, PseudoVNCLIP_WI_MF4, 0x3, false }, // 1820 + { PseudoVNCLIP_WI_MF8_MASK, PseudoVNCLIP_WI_MF8, 0x3, false }, // 1821 + { PseudoVNCLIP_WV_M1_MASK, PseudoVNCLIP_WV_M1, 0x3, false }, // 1822 + { PseudoVNCLIP_WV_M2_MASK, PseudoVNCLIP_WV_M2, 0x3, false }, // 1823 + { PseudoVNCLIP_WV_M4_MASK, PseudoVNCLIP_WV_M4, 0x3, false }, // 1824 + { PseudoVNCLIP_WV_MF2_MASK, PseudoVNCLIP_WV_MF2, 0x3, false }, // 1825 + { PseudoVNCLIP_WV_MF4_MASK, PseudoVNCLIP_WV_MF4, 0x3, false }, // 1826 + { PseudoVNCLIP_WV_MF8_MASK, PseudoVNCLIP_WV_MF8, 0x3, false }, // 1827 + { PseudoVNCLIP_WX_M1_MASK, PseudoVNCLIP_WX_M1, 0x3, false }, // 1828 + { PseudoVNCLIP_WX_M2_MASK, PseudoVNCLIP_WX_M2, 0x3, false }, // 1829 + { PseudoVNCLIP_WX_M4_MASK, PseudoVNCLIP_WX_M4, 0x3, false }, // 1830 + { PseudoVNCLIP_WX_MF2_MASK, PseudoVNCLIP_WX_MF2, 0x3, false }, // 1831 + { PseudoVNCLIP_WX_MF4_MASK, PseudoVNCLIP_WX_MF4, 0x3, false }, // 1832 + { PseudoVNCLIP_WX_MF8_MASK, PseudoVNCLIP_WX_MF8, 0x3, false }, // 1833 + { PseudoVNMSAC_VV_M1_MASK, PseudoVNMSAC_VV_M1, 0x3, false }, // 1834 + { PseudoVNMSAC_VV_M2_MASK, PseudoVNMSAC_VV_M2, 0x3, false }, // 1835 + { PseudoVNMSAC_VV_M4_MASK, PseudoVNMSAC_VV_M4, 0x3, false }, // 1836 + { PseudoVNMSAC_VV_M8_MASK, PseudoVNMSAC_VV_M8, 0x3, false }, // 1837 + { PseudoVNMSAC_VV_MF2_MASK, PseudoVNMSAC_VV_MF2, 0x3, false }, // 1838 + { PseudoVNMSAC_VV_MF4_MASK, PseudoVNMSAC_VV_MF4, 0x3, false }, // 1839 + { PseudoVNMSAC_VV_MF8_MASK, PseudoVNMSAC_VV_MF8, 0x3, false }, // 1840 + { PseudoVNMSAC_VX_M1_MASK, PseudoVNMSAC_VX_M1, 0x3, false }, // 1841 + { PseudoVNMSAC_VX_M2_MASK, PseudoVNMSAC_VX_M2, 0x3, false }, // 1842 + { PseudoVNMSAC_VX_M4_MASK, PseudoVNMSAC_VX_M4, 0x3, false }, // 1843 + { PseudoVNMSAC_VX_M8_MASK, PseudoVNMSAC_VX_M8, 0x3, false }, // 1844 + { PseudoVNMSAC_VX_MF2_MASK, PseudoVNMSAC_VX_MF2, 0x3, false }, // 1845 + { PseudoVNMSAC_VX_MF4_MASK, PseudoVNMSAC_VX_MF4, 0x3, false }, // 1846 + { PseudoVNMSAC_VX_MF8_MASK, PseudoVNMSAC_VX_MF8, 0x3, false }, // 1847 + { PseudoVNMSUB_VV_M1_MASK, PseudoVNMSUB_VV_M1, 0x3, false }, // 1848 + { PseudoVNMSUB_VV_M2_MASK, PseudoVNMSUB_VV_M2, 0x3, false }, // 1849 + { PseudoVNMSUB_VV_M4_MASK, PseudoVNMSUB_VV_M4, 0x3, false }, // 1850 + { PseudoVNMSUB_VV_M8_MASK, PseudoVNMSUB_VV_M8, 0x3, false }, // 1851 + { PseudoVNMSUB_VV_MF2_MASK, PseudoVNMSUB_VV_MF2, 0x3, false }, // 1852 + { PseudoVNMSUB_VV_MF4_MASK, PseudoVNMSUB_VV_MF4, 0x3, false }, // 1853 + { PseudoVNMSUB_VV_MF8_MASK, PseudoVNMSUB_VV_MF8, 0x3, false }, // 1854 + { PseudoVNMSUB_VX_M1_MASK, PseudoVNMSUB_VX_M1, 0x3, false }, // 1855 + { PseudoVNMSUB_VX_M2_MASK, PseudoVNMSUB_VX_M2, 0x3, false }, // 1856 + { PseudoVNMSUB_VX_M4_MASK, PseudoVNMSUB_VX_M4, 0x3, false }, // 1857 + { PseudoVNMSUB_VX_M8_MASK, PseudoVNMSUB_VX_M8, 0x3, false }, // 1858 + { PseudoVNMSUB_VX_MF2_MASK, PseudoVNMSUB_VX_MF2, 0x3, false }, // 1859 + { PseudoVNMSUB_VX_MF4_MASK, PseudoVNMSUB_VX_MF4, 0x3, false }, // 1860 + { PseudoVNMSUB_VX_MF8_MASK, PseudoVNMSUB_VX_MF8, 0x3, false }, // 1861 + { PseudoVNSRA_WI_M1_MASK, PseudoVNSRA_WI_M1, 0x3, false }, // 1862 + { PseudoVNSRA_WI_M2_MASK, PseudoVNSRA_WI_M2, 0x3, false }, // 1863 + { PseudoVNSRA_WI_M4_MASK, PseudoVNSRA_WI_M4, 0x3, false }, // 1864 + { PseudoVNSRA_WI_MF2_MASK, PseudoVNSRA_WI_MF2, 0x3, false }, // 1865 + { PseudoVNSRA_WI_MF4_MASK, PseudoVNSRA_WI_MF4, 0x3, false }, // 1866 + { PseudoVNSRA_WI_MF8_MASK, PseudoVNSRA_WI_MF8, 0x3, false }, // 1867 + { PseudoVNSRA_WV_M1_MASK, PseudoVNSRA_WV_M1, 0x3, false }, // 1868 + { PseudoVNSRA_WV_M2_MASK, PseudoVNSRA_WV_M2, 0x3, false }, // 1869 + { PseudoVNSRA_WV_M4_MASK, PseudoVNSRA_WV_M4, 0x3, false }, // 1870 + { PseudoVNSRA_WV_MF2_MASK, PseudoVNSRA_WV_MF2, 0x3, false }, // 1871 + { PseudoVNSRA_WV_MF4_MASK, PseudoVNSRA_WV_MF4, 0x3, false }, // 1872 + { PseudoVNSRA_WV_MF8_MASK, PseudoVNSRA_WV_MF8, 0x3, false }, // 1873 + { PseudoVNSRA_WX_M1_MASK, PseudoVNSRA_WX_M1, 0x3, false }, // 1874 + { PseudoVNSRA_WX_M2_MASK, PseudoVNSRA_WX_M2, 0x3, false }, // 1875 + { PseudoVNSRA_WX_M4_MASK, PseudoVNSRA_WX_M4, 0x3, false }, // 1876 + { PseudoVNSRA_WX_MF2_MASK, PseudoVNSRA_WX_MF2, 0x3, false }, // 1877 + { PseudoVNSRA_WX_MF4_MASK, PseudoVNSRA_WX_MF4, 0x3, false }, // 1878 + { PseudoVNSRA_WX_MF8_MASK, PseudoVNSRA_WX_MF8, 0x3, false }, // 1879 + { PseudoVNSRL_WI_M1_MASK, PseudoVNSRL_WI_M1, 0x3, false }, // 1880 + { PseudoVNSRL_WI_M2_MASK, PseudoVNSRL_WI_M2, 0x3, false }, // 1881 + { PseudoVNSRL_WI_M4_MASK, PseudoVNSRL_WI_M4, 0x3, false }, // 1882 + { PseudoVNSRL_WI_MF2_MASK, PseudoVNSRL_WI_MF2, 0x3, false }, // 1883 + { PseudoVNSRL_WI_MF4_MASK, PseudoVNSRL_WI_MF4, 0x3, false }, // 1884 + { PseudoVNSRL_WI_MF8_MASK, PseudoVNSRL_WI_MF8, 0x3, false }, // 1885 + { PseudoVNSRL_WV_M1_MASK, PseudoVNSRL_WV_M1, 0x3, false }, // 1886 + { PseudoVNSRL_WV_M2_MASK, PseudoVNSRL_WV_M2, 0x3, false }, // 1887 + { PseudoVNSRL_WV_M4_MASK, PseudoVNSRL_WV_M4, 0x3, false }, // 1888 + { PseudoVNSRL_WV_MF2_MASK, PseudoVNSRL_WV_MF2, 0x3, false }, // 1889 + { PseudoVNSRL_WV_MF4_MASK, PseudoVNSRL_WV_MF4, 0x3, false }, // 1890 + { PseudoVNSRL_WV_MF8_MASK, PseudoVNSRL_WV_MF8, 0x3, false }, // 1891 + { PseudoVNSRL_WX_M1_MASK, PseudoVNSRL_WX_M1, 0x3, false }, // 1892 + { PseudoVNSRL_WX_M2_MASK, PseudoVNSRL_WX_M2, 0x3, false }, // 1893 + { PseudoVNSRL_WX_M4_MASK, PseudoVNSRL_WX_M4, 0x3, false }, // 1894 + { PseudoVNSRL_WX_MF2_MASK, PseudoVNSRL_WX_MF2, 0x3, false }, // 1895 + { PseudoVNSRL_WX_MF4_MASK, PseudoVNSRL_WX_MF4, 0x3, false }, // 1896 + { PseudoVNSRL_WX_MF8_MASK, PseudoVNSRL_WX_MF8, 0x3, false }, // 1897 + { PseudoVOR_VI_M1_MASK, PseudoVOR_VI_M1, 0x3, false }, // 1898 + { PseudoVOR_VI_M2_MASK, PseudoVOR_VI_M2, 0x3, false }, // 1899 + { PseudoVOR_VI_M4_MASK, PseudoVOR_VI_M4, 0x3, false }, // 1900 + { PseudoVOR_VI_M8_MASK, PseudoVOR_VI_M8, 0x3, false }, // 1901 + { PseudoVOR_VI_MF2_MASK, PseudoVOR_VI_MF2, 0x3, false }, // 1902 + { PseudoVOR_VI_MF4_MASK, PseudoVOR_VI_MF4, 0x3, false }, // 1903 + { PseudoVOR_VI_MF8_MASK, PseudoVOR_VI_MF8, 0x3, false }, // 1904 + { PseudoVOR_VV_M1_MASK, PseudoVOR_VV_M1, 0x3, false }, // 1905 + { PseudoVOR_VV_M2_MASK, PseudoVOR_VV_M2, 0x3, false }, // 1906 + { PseudoVOR_VV_M4_MASK, PseudoVOR_VV_M4, 0x3, false }, // 1907 + { PseudoVOR_VV_M8_MASK, PseudoVOR_VV_M8, 0x3, false }, // 1908 + { PseudoVOR_VV_MF2_MASK, PseudoVOR_VV_MF2, 0x3, false }, // 1909 + { PseudoVOR_VV_MF4_MASK, PseudoVOR_VV_MF4, 0x3, false }, // 1910 + { PseudoVOR_VV_MF8_MASK, PseudoVOR_VV_MF8, 0x3, false }, // 1911 + { PseudoVOR_VX_M1_MASK, PseudoVOR_VX_M1, 0x3, false }, // 1912 + { PseudoVOR_VX_M2_MASK, PseudoVOR_VX_M2, 0x3, false }, // 1913 + { PseudoVOR_VX_M4_MASK, PseudoVOR_VX_M4, 0x3, false }, // 1914 + { PseudoVOR_VX_M8_MASK, PseudoVOR_VX_M8, 0x3, false }, // 1915 + { PseudoVOR_VX_MF2_MASK, PseudoVOR_VX_MF2, 0x3, false }, // 1916 + { PseudoVOR_VX_MF4_MASK, PseudoVOR_VX_MF4, 0x3, false }, // 1917 + { PseudoVOR_VX_MF8_MASK, PseudoVOR_VX_MF8, 0x3, false }, // 1918 + { PseudoVREDAND_VS_M1_E16_MASK, PseudoVREDAND_VS_M1_E16, 0x3, true }, // 1919 + { PseudoVREDAND_VS_M1_E32_MASK, PseudoVREDAND_VS_M1_E32, 0x3, true }, // 1920 + { PseudoVREDAND_VS_M1_E64_MASK, PseudoVREDAND_VS_M1_E64, 0x3, true }, // 1921 + { PseudoVREDAND_VS_M1_E8_MASK, PseudoVREDAND_VS_M1_E8, 0x3, true }, // 1922 + { PseudoVREDAND_VS_M2_E16_MASK, PseudoVREDAND_VS_M2_E16, 0x3, true }, // 1923 + { PseudoVREDAND_VS_M2_E32_MASK, PseudoVREDAND_VS_M2_E32, 0x3, true }, // 1924 + { PseudoVREDAND_VS_M2_E64_MASK, PseudoVREDAND_VS_M2_E64, 0x3, true }, // 1925 + { PseudoVREDAND_VS_M2_E8_MASK, PseudoVREDAND_VS_M2_E8, 0x3, true }, // 1926 + { PseudoVREDAND_VS_M4_E16_MASK, PseudoVREDAND_VS_M4_E16, 0x3, true }, // 1927 + { PseudoVREDAND_VS_M4_E32_MASK, PseudoVREDAND_VS_M4_E32, 0x3, true }, // 1928 + { PseudoVREDAND_VS_M4_E64_MASK, PseudoVREDAND_VS_M4_E64, 0x3, true }, // 1929 + { PseudoVREDAND_VS_M4_E8_MASK, PseudoVREDAND_VS_M4_E8, 0x3, true }, // 1930 + { PseudoVREDAND_VS_M8_E16_MASK, PseudoVREDAND_VS_M8_E16, 0x3, true }, // 1931 + { PseudoVREDAND_VS_M8_E32_MASK, PseudoVREDAND_VS_M8_E32, 0x3, true }, // 1932 + { PseudoVREDAND_VS_M8_E64_MASK, PseudoVREDAND_VS_M8_E64, 0x3, true }, // 1933 + { PseudoVREDAND_VS_M8_E8_MASK, PseudoVREDAND_VS_M8_E8, 0x3, true }, // 1934 + { PseudoVREDAND_VS_MF2_E16_MASK, PseudoVREDAND_VS_MF2_E16, 0x3, true }, // 1935 + { PseudoVREDAND_VS_MF2_E32_MASK, PseudoVREDAND_VS_MF2_E32, 0x3, true }, // 1936 + { PseudoVREDAND_VS_MF2_E8_MASK, PseudoVREDAND_VS_MF2_E8, 0x3, true }, // 1937 + { PseudoVREDAND_VS_MF4_E16_MASK, PseudoVREDAND_VS_MF4_E16, 0x3, true }, // 1938 + { PseudoVREDAND_VS_MF4_E8_MASK, PseudoVREDAND_VS_MF4_E8, 0x3, true }, // 1939 + { PseudoVREDAND_VS_MF8_E8_MASK, PseudoVREDAND_VS_MF8_E8, 0x3, true }, // 1940 + { PseudoVREDMAXU_VS_M1_E16_MASK, PseudoVREDMAXU_VS_M1_E16, 0x3, true }, // 1941 + { PseudoVREDMAXU_VS_M1_E32_MASK, PseudoVREDMAXU_VS_M1_E32, 0x3, true }, // 1942 + { PseudoVREDMAXU_VS_M1_E64_MASK, PseudoVREDMAXU_VS_M1_E64, 0x3, true }, // 1943 + { PseudoVREDMAXU_VS_M1_E8_MASK, PseudoVREDMAXU_VS_M1_E8, 0x3, true }, // 1944 + { PseudoVREDMAXU_VS_M2_E16_MASK, PseudoVREDMAXU_VS_M2_E16, 0x3, true }, // 1945 + { PseudoVREDMAXU_VS_M2_E32_MASK, PseudoVREDMAXU_VS_M2_E32, 0x3, true }, // 1946 + { PseudoVREDMAXU_VS_M2_E64_MASK, PseudoVREDMAXU_VS_M2_E64, 0x3, true }, // 1947 + { PseudoVREDMAXU_VS_M2_E8_MASK, PseudoVREDMAXU_VS_M2_E8, 0x3, true }, // 1948 + { PseudoVREDMAXU_VS_M4_E16_MASK, PseudoVREDMAXU_VS_M4_E16, 0x3, true }, // 1949 + { PseudoVREDMAXU_VS_M4_E32_MASK, PseudoVREDMAXU_VS_M4_E32, 0x3, true }, // 1950 + { PseudoVREDMAXU_VS_M4_E64_MASK, PseudoVREDMAXU_VS_M4_E64, 0x3, true }, // 1951 + { PseudoVREDMAXU_VS_M4_E8_MASK, PseudoVREDMAXU_VS_M4_E8, 0x3, true }, // 1952 + { PseudoVREDMAXU_VS_M8_E16_MASK, PseudoVREDMAXU_VS_M8_E16, 0x3, true }, // 1953 + { PseudoVREDMAXU_VS_M8_E32_MASK, PseudoVREDMAXU_VS_M8_E32, 0x3, true }, // 1954 + { PseudoVREDMAXU_VS_M8_E64_MASK, PseudoVREDMAXU_VS_M8_E64, 0x3, true }, // 1955 + { PseudoVREDMAXU_VS_M8_E8_MASK, PseudoVREDMAXU_VS_M8_E8, 0x3, true }, // 1956 + { PseudoVREDMAXU_VS_MF2_E16_MASK, PseudoVREDMAXU_VS_MF2_E16, 0x3, true }, // 1957 + { PseudoVREDMAXU_VS_MF2_E32_MASK, PseudoVREDMAXU_VS_MF2_E32, 0x3, true }, // 1958 + { PseudoVREDMAXU_VS_MF2_E8_MASK, PseudoVREDMAXU_VS_MF2_E8, 0x3, true }, // 1959 + { PseudoVREDMAXU_VS_MF4_E16_MASK, PseudoVREDMAXU_VS_MF4_E16, 0x3, true }, // 1960 + { PseudoVREDMAXU_VS_MF4_E8_MASK, PseudoVREDMAXU_VS_MF4_E8, 0x3, true }, // 1961 + { PseudoVREDMAXU_VS_MF8_E8_MASK, PseudoVREDMAXU_VS_MF8_E8, 0x3, true }, // 1962 + { PseudoVREDMAX_VS_M1_E16_MASK, PseudoVREDMAX_VS_M1_E16, 0x3, true }, // 1963 + { PseudoVREDMAX_VS_M1_E32_MASK, PseudoVREDMAX_VS_M1_E32, 0x3, true }, // 1964 + { PseudoVREDMAX_VS_M1_E64_MASK, PseudoVREDMAX_VS_M1_E64, 0x3, true }, // 1965 + { PseudoVREDMAX_VS_M1_E8_MASK, PseudoVREDMAX_VS_M1_E8, 0x3, true }, // 1966 + { PseudoVREDMAX_VS_M2_E16_MASK, PseudoVREDMAX_VS_M2_E16, 0x3, true }, // 1967 + { PseudoVREDMAX_VS_M2_E32_MASK, PseudoVREDMAX_VS_M2_E32, 0x3, true }, // 1968 + { PseudoVREDMAX_VS_M2_E64_MASK, PseudoVREDMAX_VS_M2_E64, 0x3, true }, // 1969 + { PseudoVREDMAX_VS_M2_E8_MASK, PseudoVREDMAX_VS_M2_E8, 0x3, true }, // 1970 + { PseudoVREDMAX_VS_M4_E16_MASK, PseudoVREDMAX_VS_M4_E16, 0x3, true }, // 1971 + { PseudoVREDMAX_VS_M4_E32_MASK, PseudoVREDMAX_VS_M4_E32, 0x3, true }, // 1972 + { PseudoVREDMAX_VS_M4_E64_MASK, PseudoVREDMAX_VS_M4_E64, 0x3, true }, // 1973 + { PseudoVREDMAX_VS_M4_E8_MASK, PseudoVREDMAX_VS_M4_E8, 0x3, true }, // 1974 + { PseudoVREDMAX_VS_M8_E16_MASK, PseudoVREDMAX_VS_M8_E16, 0x3, true }, // 1975 + { PseudoVREDMAX_VS_M8_E32_MASK, PseudoVREDMAX_VS_M8_E32, 0x3, true }, // 1976 + { PseudoVREDMAX_VS_M8_E64_MASK, PseudoVREDMAX_VS_M8_E64, 0x3, true }, // 1977 + { PseudoVREDMAX_VS_M8_E8_MASK, PseudoVREDMAX_VS_M8_E8, 0x3, true }, // 1978 + { PseudoVREDMAX_VS_MF2_E16_MASK, PseudoVREDMAX_VS_MF2_E16, 0x3, true }, // 1979 + { PseudoVREDMAX_VS_MF2_E32_MASK, PseudoVREDMAX_VS_MF2_E32, 0x3, true }, // 1980 + { PseudoVREDMAX_VS_MF2_E8_MASK, PseudoVREDMAX_VS_MF2_E8, 0x3, true }, // 1981 + { PseudoVREDMAX_VS_MF4_E16_MASK, PseudoVREDMAX_VS_MF4_E16, 0x3, true }, // 1982 + { PseudoVREDMAX_VS_MF4_E8_MASK, PseudoVREDMAX_VS_MF4_E8, 0x3, true }, // 1983 + { PseudoVREDMAX_VS_MF8_E8_MASK, PseudoVREDMAX_VS_MF8_E8, 0x3, true }, // 1984 + { PseudoVREDMINU_VS_M1_E16_MASK, PseudoVREDMINU_VS_M1_E16, 0x3, true }, // 1985 + { PseudoVREDMINU_VS_M1_E32_MASK, PseudoVREDMINU_VS_M1_E32, 0x3, true }, // 1986 + { PseudoVREDMINU_VS_M1_E64_MASK, PseudoVREDMINU_VS_M1_E64, 0x3, true }, // 1987 + { PseudoVREDMINU_VS_M1_E8_MASK, PseudoVREDMINU_VS_M1_E8, 0x3, true }, // 1988 + { PseudoVREDMINU_VS_M2_E16_MASK, PseudoVREDMINU_VS_M2_E16, 0x3, true }, // 1989 + { PseudoVREDMINU_VS_M2_E32_MASK, PseudoVREDMINU_VS_M2_E32, 0x3, true }, // 1990 + { PseudoVREDMINU_VS_M2_E64_MASK, PseudoVREDMINU_VS_M2_E64, 0x3, true }, // 1991 + { PseudoVREDMINU_VS_M2_E8_MASK, PseudoVREDMINU_VS_M2_E8, 0x3, true }, // 1992 + { PseudoVREDMINU_VS_M4_E16_MASK, PseudoVREDMINU_VS_M4_E16, 0x3, true }, // 1993 + { PseudoVREDMINU_VS_M4_E32_MASK, PseudoVREDMINU_VS_M4_E32, 0x3, true }, // 1994 + { PseudoVREDMINU_VS_M4_E64_MASK, PseudoVREDMINU_VS_M4_E64, 0x3, true }, // 1995 + { PseudoVREDMINU_VS_M4_E8_MASK, PseudoVREDMINU_VS_M4_E8, 0x3, true }, // 1996 + { PseudoVREDMINU_VS_M8_E16_MASK, PseudoVREDMINU_VS_M8_E16, 0x3, true }, // 1997 + { PseudoVREDMINU_VS_M8_E32_MASK, PseudoVREDMINU_VS_M8_E32, 0x3, true }, // 1998 + { PseudoVREDMINU_VS_M8_E64_MASK, PseudoVREDMINU_VS_M8_E64, 0x3, true }, // 1999 + { PseudoVREDMINU_VS_M8_E8_MASK, PseudoVREDMINU_VS_M8_E8, 0x3, true }, // 2000 + { PseudoVREDMINU_VS_MF2_E16_MASK, PseudoVREDMINU_VS_MF2_E16, 0x3, true }, // 2001 + { PseudoVREDMINU_VS_MF2_E32_MASK, PseudoVREDMINU_VS_MF2_E32, 0x3, true }, // 2002 + { PseudoVREDMINU_VS_MF2_E8_MASK, PseudoVREDMINU_VS_MF2_E8, 0x3, true }, // 2003 + { PseudoVREDMINU_VS_MF4_E16_MASK, PseudoVREDMINU_VS_MF4_E16, 0x3, true }, // 2004 + { PseudoVREDMINU_VS_MF4_E8_MASK, PseudoVREDMINU_VS_MF4_E8, 0x3, true }, // 2005 + { PseudoVREDMINU_VS_MF8_E8_MASK, PseudoVREDMINU_VS_MF8_E8, 0x3, true }, // 2006 + { PseudoVREDMIN_VS_M1_E16_MASK, PseudoVREDMIN_VS_M1_E16, 0x3, true }, // 2007 + { PseudoVREDMIN_VS_M1_E32_MASK, PseudoVREDMIN_VS_M1_E32, 0x3, true }, // 2008 + { PseudoVREDMIN_VS_M1_E64_MASK, PseudoVREDMIN_VS_M1_E64, 0x3, true }, // 2009 + { PseudoVREDMIN_VS_M1_E8_MASK, PseudoVREDMIN_VS_M1_E8, 0x3, true }, // 2010 + { PseudoVREDMIN_VS_M2_E16_MASK, PseudoVREDMIN_VS_M2_E16, 0x3, true }, // 2011 + { PseudoVREDMIN_VS_M2_E32_MASK, PseudoVREDMIN_VS_M2_E32, 0x3, true }, // 2012 + { PseudoVREDMIN_VS_M2_E64_MASK, PseudoVREDMIN_VS_M2_E64, 0x3, true }, // 2013 + { PseudoVREDMIN_VS_M2_E8_MASK, PseudoVREDMIN_VS_M2_E8, 0x3, true }, // 2014 + { PseudoVREDMIN_VS_M4_E16_MASK, PseudoVREDMIN_VS_M4_E16, 0x3, true }, // 2015 + { PseudoVREDMIN_VS_M4_E32_MASK, PseudoVREDMIN_VS_M4_E32, 0x3, true }, // 2016 + { PseudoVREDMIN_VS_M4_E64_MASK, PseudoVREDMIN_VS_M4_E64, 0x3, true }, // 2017 + { PseudoVREDMIN_VS_M4_E8_MASK, PseudoVREDMIN_VS_M4_E8, 0x3, true }, // 2018 + { PseudoVREDMIN_VS_M8_E16_MASK, PseudoVREDMIN_VS_M8_E16, 0x3, true }, // 2019 + { PseudoVREDMIN_VS_M8_E32_MASK, PseudoVREDMIN_VS_M8_E32, 0x3, true }, // 2020 + { PseudoVREDMIN_VS_M8_E64_MASK, PseudoVREDMIN_VS_M8_E64, 0x3, true }, // 2021 + { PseudoVREDMIN_VS_M8_E8_MASK, PseudoVREDMIN_VS_M8_E8, 0x3, true }, // 2022 + { PseudoVREDMIN_VS_MF2_E16_MASK, PseudoVREDMIN_VS_MF2_E16, 0x3, true }, // 2023 + { PseudoVREDMIN_VS_MF2_E32_MASK, PseudoVREDMIN_VS_MF2_E32, 0x3, true }, // 2024 + { PseudoVREDMIN_VS_MF2_E8_MASK, PseudoVREDMIN_VS_MF2_E8, 0x3, true }, // 2025 + { PseudoVREDMIN_VS_MF4_E16_MASK, PseudoVREDMIN_VS_MF4_E16, 0x3, true }, // 2026 + { PseudoVREDMIN_VS_MF4_E8_MASK, PseudoVREDMIN_VS_MF4_E8, 0x3, true }, // 2027 + { PseudoVREDMIN_VS_MF8_E8_MASK, PseudoVREDMIN_VS_MF8_E8, 0x3, true }, // 2028 + { PseudoVREDOR_VS_M1_E16_MASK, PseudoVREDOR_VS_M1_E16, 0x3, true }, // 2029 + { PseudoVREDOR_VS_M1_E32_MASK, PseudoVREDOR_VS_M1_E32, 0x3, true }, // 2030 + { PseudoVREDOR_VS_M1_E64_MASK, PseudoVREDOR_VS_M1_E64, 0x3, true }, // 2031 + { PseudoVREDOR_VS_M1_E8_MASK, PseudoVREDOR_VS_M1_E8, 0x3, true }, // 2032 + { PseudoVREDOR_VS_M2_E16_MASK, PseudoVREDOR_VS_M2_E16, 0x3, true }, // 2033 + { PseudoVREDOR_VS_M2_E32_MASK, PseudoVREDOR_VS_M2_E32, 0x3, true }, // 2034 + { PseudoVREDOR_VS_M2_E64_MASK, PseudoVREDOR_VS_M2_E64, 0x3, true }, // 2035 + { PseudoVREDOR_VS_M2_E8_MASK, PseudoVREDOR_VS_M2_E8, 0x3, true }, // 2036 + { PseudoVREDOR_VS_M4_E16_MASK, PseudoVREDOR_VS_M4_E16, 0x3, true }, // 2037 + { PseudoVREDOR_VS_M4_E32_MASK, PseudoVREDOR_VS_M4_E32, 0x3, true }, // 2038 + { PseudoVREDOR_VS_M4_E64_MASK, PseudoVREDOR_VS_M4_E64, 0x3, true }, // 2039 + { PseudoVREDOR_VS_M4_E8_MASK, PseudoVREDOR_VS_M4_E8, 0x3, true }, // 2040 + { PseudoVREDOR_VS_M8_E16_MASK, PseudoVREDOR_VS_M8_E16, 0x3, true }, // 2041 + { PseudoVREDOR_VS_M8_E32_MASK, PseudoVREDOR_VS_M8_E32, 0x3, true }, // 2042 + { PseudoVREDOR_VS_M8_E64_MASK, PseudoVREDOR_VS_M8_E64, 0x3, true }, // 2043 + { PseudoVREDOR_VS_M8_E8_MASK, PseudoVREDOR_VS_M8_E8, 0x3, true }, // 2044 + { PseudoVREDOR_VS_MF2_E16_MASK, PseudoVREDOR_VS_MF2_E16, 0x3, true }, // 2045 + { PseudoVREDOR_VS_MF2_E32_MASK, PseudoVREDOR_VS_MF2_E32, 0x3, true }, // 2046 + { PseudoVREDOR_VS_MF2_E8_MASK, PseudoVREDOR_VS_MF2_E8, 0x3, true }, // 2047 + { PseudoVREDOR_VS_MF4_E16_MASK, PseudoVREDOR_VS_MF4_E16, 0x3, true }, // 2048 + { PseudoVREDOR_VS_MF4_E8_MASK, PseudoVREDOR_VS_MF4_E8, 0x3, true }, // 2049 + { PseudoVREDOR_VS_MF8_E8_MASK, PseudoVREDOR_VS_MF8_E8, 0x3, true }, // 2050 + { PseudoVREDSUM_VS_M1_E16_MASK, PseudoVREDSUM_VS_M1_E16, 0x3, true }, // 2051 + { PseudoVREDSUM_VS_M1_E32_MASK, PseudoVREDSUM_VS_M1_E32, 0x3, true }, // 2052 + { PseudoVREDSUM_VS_M1_E64_MASK, PseudoVREDSUM_VS_M1_E64, 0x3, true }, // 2053 + { PseudoVREDSUM_VS_M1_E8_MASK, PseudoVREDSUM_VS_M1_E8, 0x3, true }, // 2054 + { PseudoVREDSUM_VS_M2_E16_MASK, PseudoVREDSUM_VS_M2_E16, 0x3, true }, // 2055 + { PseudoVREDSUM_VS_M2_E32_MASK, PseudoVREDSUM_VS_M2_E32, 0x3, true }, // 2056 + { PseudoVREDSUM_VS_M2_E64_MASK, PseudoVREDSUM_VS_M2_E64, 0x3, true }, // 2057 + { PseudoVREDSUM_VS_M2_E8_MASK, PseudoVREDSUM_VS_M2_E8, 0x3, true }, // 2058 + { PseudoVREDSUM_VS_M4_E16_MASK, PseudoVREDSUM_VS_M4_E16, 0x3, true }, // 2059 + { PseudoVREDSUM_VS_M4_E32_MASK, PseudoVREDSUM_VS_M4_E32, 0x3, true }, // 2060 + { PseudoVREDSUM_VS_M4_E64_MASK, PseudoVREDSUM_VS_M4_E64, 0x3, true }, // 2061 + { PseudoVREDSUM_VS_M4_E8_MASK, PseudoVREDSUM_VS_M4_E8, 0x3, true }, // 2062 + { PseudoVREDSUM_VS_M8_E16_MASK, PseudoVREDSUM_VS_M8_E16, 0x3, true }, // 2063 + { PseudoVREDSUM_VS_M8_E32_MASK, PseudoVREDSUM_VS_M8_E32, 0x3, true }, // 2064 + { PseudoVREDSUM_VS_M8_E64_MASK, PseudoVREDSUM_VS_M8_E64, 0x3, true }, // 2065 + { PseudoVREDSUM_VS_M8_E8_MASK, PseudoVREDSUM_VS_M8_E8, 0x3, true }, // 2066 + { PseudoVREDSUM_VS_MF2_E16_MASK, PseudoVREDSUM_VS_MF2_E16, 0x3, true }, // 2067 + { PseudoVREDSUM_VS_MF2_E32_MASK, PseudoVREDSUM_VS_MF2_E32, 0x3, true }, // 2068 + { PseudoVREDSUM_VS_MF2_E8_MASK, PseudoVREDSUM_VS_MF2_E8, 0x3, true }, // 2069 + { PseudoVREDSUM_VS_MF4_E16_MASK, PseudoVREDSUM_VS_MF4_E16, 0x3, true }, // 2070 + { PseudoVREDSUM_VS_MF4_E8_MASK, PseudoVREDSUM_VS_MF4_E8, 0x3, true }, // 2071 + { PseudoVREDSUM_VS_MF8_E8_MASK, PseudoVREDSUM_VS_MF8_E8, 0x3, true }, // 2072 + { PseudoVREDXOR_VS_M1_E16_MASK, PseudoVREDXOR_VS_M1_E16, 0x3, true }, // 2073 + { PseudoVREDXOR_VS_M1_E32_MASK, PseudoVREDXOR_VS_M1_E32, 0x3, true }, // 2074 + { PseudoVREDXOR_VS_M1_E64_MASK, PseudoVREDXOR_VS_M1_E64, 0x3, true }, // 2075 + { PseudoVREDXOR_VS_M1_E8_MASK, PseudoVREDXOR_VS_M1_E8, 0x3, true }, // 2076 + { PseudoVREDXOR_VS_M2_E16_MASK, PseudoVREDXOR_VS_M2_E16, 0x3, true }, // 2077 + { PseudoVREDXOR_VS_M2_E32_MASK, PseudoVREDXOR_VS_M2_E32, 0x3, true }, // 2078 + { PseudoVREDXOR_VS_M2_E64_MASK, PseudoVREDXOR_VS_M2_E64, 0x3, true }, // 2079 + { PseudoVREDXOR_VS_M2_E8_MASK, PseudoVREDXOR_VS_M2_E8, 0x3, true }, // 2080 + { PseudoVREDXOR_VS_M4_E16_MASK, PseudoVREDXOR_VS_M4_E16, 0x3, true }, // 2081 + { PseudoVREDXOR_VS_M4_E32_MASK, PseudoVREDXOR_VS_M4_E32, 0x3, true }, // 2082 + { PseudoVREDXOR_VS_M4_E64_MASK, PseudoVREDXOR_VS_M4_E64, 0x3, true }, // 2083 + { PseudoVREDXOR_VS_M4_E8_MASK, PseudoVREDXOR_VS_M4_E8, 0x3, true }, // 2084 + { PseudoVREDXOR_VS_M8_E16_MASK, PseudoVREDXOR_VS_M8_E16, 0x3, true }, // 2085 + { PseudoVREDXOR_VS_M8_E32_MASK, PseudoVREDXOR_VS_M8_E32, 0x3, true }, // 2086 + { PseudoVREDXOR_VS_M8_E64_MASK, PseudoVREDXOR_VS_M8_E64, 0x3, true }, // 2087 + { PseudoVREDXOR_VS_M8_E8_MASK, PseudoVREDXOR_VS_M8_E8, 0x3, true }, // 2088 + { PseudoVREDXOR_VS_MF2_E16_MASK, PseudoVREDXOR_VS_MF2_E16, 0x3, true }, // 2089 + { PseudoVREDXOR_VS_MF2_E32_MASK, PseudoVREDXOR_VS_MF2_E32, 0x3, true }, // 2090 + { PseudoVREDXOR_VS_MF2_E8_MASK, PseudoVREDXOR_VS_MF2_E8, 0x3, true }, // 2091 + { PseudoVREDXOR_VS_MF4_E16_MASK, PseudoVREDXOR_VS_MF4_E16, 0x3, true }, // 2092 + { PseudoVREDXOR_VS_MF4_E8_MASK, PseudoVREDXOR_VS_MF4_E8, 0x3, true }, // 2093 + { PseudoVREDXOR_VS_MF8_E8_MASK, PseudoVREDXOR_VS_MF8_E8, 0x3, true }, // 2094 + { PseudoVREMU_VV_M1_E16_MASK, PseudoVREMU_VV_M1_E16, 0x3, false }, // 2095 + { PseudoVREMU_VV_M1_E32_MASK, PseudoVREMU_VV_M1_E32, 0x3, false }, // 2096 + { PseudoVREMU_VV_M1_E64_MASK, PseudoVREMU_VV_M1_E64, 0x3, false }, // 2097 + { PseudoVREMU_VV_M1_E8_MASK, PseudoVREMU_VV_M1_E8, 0x3, false }, // 2098 + { PseudoVREMU_VV_M2_E16_MASK, PseudoVREMU_VV_M2_E16, 0x3, false }, // 2099 + { PseudoVREMU_VV_M2_E32_MASK, PseudoVREMU_VV_M2_E32, 0x3, false }, // 2100 + { PseudoVREMU_VV_M2_E64_MASK, PseudoVREMU_VV_M2_E64, 0x3, false }, // 2101 + { PseudoVREMU_VV_M2_E8_MASK, PseudoVREMU_VV_M2_E8, 0x3, false }, // 2102 + { PseudoVREMU_VV_M4_E16_MASK, PseudoVREMU_VV_M4_E16, 0x3, false }, // 2103 + { PseudoVREMU_VV_M4_E32_MASK, PseudoVREMU_VV_M4_E32, 0x3, false }, // 2104 + { PseudoVREMU_VV_M4_E64_MASK, PseudoVREMU_VV_M4_E64, 0x3, false }, // 2105 + { PseudoVREMU_VV_M4_E8_MASK, PseudoVREMU_VV_M4_E8, 0x3, false }, // 2106 + { PseudoVREMU_VV_M8_E16_MASK, PseudoVREMU_VV_M8_E16, 0x3, false }, // 2107 + { PseudoVREMU_VV_M8_E32_MASK, PseudoVREMU_VV_M8_E32, 0x3, false }, // 2108 + { PseudoVREMU_VV_M8_E64_MASK, PseudoVREMU_VV_M8_E64, 0x3, false }, // 2109 + { PseudoVREMU_VV_M8_E8_MASK, PseudoVREMU_VV_M8_E8, 0x3, false }, // 2110 + { PseudoVREMU_VV_MF2_E16_MASK, PseudoVREMU_VV_MF2_E16, 0x3, false }, // 2111 + { PseudoVREMU_VV_MF2_E32_MASK, PseudoVREMU_VV_MF2_E32, 0x3, false }, // 2112 + { PseudoVREMU_VV_MF2_E8_MASK, PseudoVREMU_VV_MF2_E8, 0x3, false }, // 2113 + { PseudoVREMU_VV_MF4_E16_MASK, PseudoVREMU_VV_MF4_E16, 0x3, false }, // 2114 + { PseudoVREMU_VV_MF4_E8_MASK, PseudoVREMU_VV_MF4_E8, 0x3, false }, // 2115 + { PseudoVREMU_VV_MF8_E8_MASK, PseudoVREMU_VV_MF8_E8, 0x3, false }, // 2116 + { PseudoVREMU_VX_M1_E16_MASK, PseudoVREMU_VX_M1_E16, 0x3, false }, // 2117 + { PseudoVREMU_VX_M1_E32_MASK, PseudoVREMU_VX_M1_E32, 0x3, false }, // 2118 + { PseudoVREMU_VX_M1_E64_MASK, PseudoVREMU_VX_M1_E64, 0x3, false }, // 2119 + { PseudoVREMU_VX_M1_E8_MASK, PseudoVREMU_VX_M1_E8, 0x3, false }, // 2120 + { PseudoVREMU_VX_M2_E16_MASK, PseudoVREMU_VX_M2_E16, 0x3, false }, // 2121 + { PseudoVREMU_VX_M2_E32_MASK, PseudoVREMU_VX_M2_E32, 0x3, false }, // 2122 + { PseudoVREMU_VX_M2_E64_MASK, PseudoVREMU_VX_M2_E64, 0x3, false }, // 2123 + { PseudoVREMU_VX_M2_E8_MASK, PseudoVREMU_VX_M2_E8, 0x3, false }, // 2124 + { PseudoVREMU_VX_M4_E16_MASK, PseudoVREMU_VX_M4_E16, 0x3, false }, // 2125 + { PseudoVREMU_VX_M4_E32_MASK, PseudoVREMU_VX_M4_E32, 0x3, false }, // 2126 + { PseudoVREMU_VX_M4_E64_MASK, PseudoVREMU_VX_M4_E64, 0x3, false }, // 2127 + { PseudoVREMU_VX_M4_E8_MASK, PseudoVREMU_VX_M4_E8, 0x3, false }, // 2128 + { PseudoVREMU_VX_M8_E16_MASK, PseudoVREMU_VX_M8_E16, 0x3, false }, // 2129 + { PseudoVREMU_VX_M8_E32_MASK, PseudoVREMU_VX_M8_E32, 0x3, false }, // 2130 + { PseudoVREMU_VX_M8_E64_MASK, PseudoVREMU_VX_M8_E64, 0x3, false }, // 2131 + { PseudoVREMU_VX_M8_E8_MASK, PseudoVREMU_VX_M8_E8, 0x3, false }, // 2132 + { PseudoVREMU_VX_MF2_E16_MASK, PseudoVREMU_VX_MF2_E16, 0x3, false }, // 2133 + { PseudoVREMU_VX_MF2_E32_MASK, PseudoVREMU_VX_MF2_E32, 0x3, false }, // 2134 + { PseudoVREMU_VX_MF2_E8_MASK, PseudoVREMU_VX_MF2_E8, 0x3, false }, // 2135 + { PseudoVREMU_VX_MF4_E16_MASK, PseudoVREMU_VX_MF4_E16, 0x3, false }, // 2136 + { PseudoVREMU_VX_MF4_E8_MASK, PseudoVREMU_VX_MF4_E8, 0x3, false }, // 2137 + { PseudoVREMU_VX_MF8_E8_MASK, PseudoVREMU_VX_MF8_E8, 0x3, false }, // 2138 + { PseudoVREM_VV_M1_E16_MASK, PseudoVREM_VV_M1_E16, 0x3, false }, // 2139 + { PseudoVREM_VV_M1_E32_MASK, PseudoVREM_VV_M1_E32, 0x3, false }, // 2140 + { PseudoVREM_VV_M1_E64_MASK, PseudoVREM_VV_M1_E64, 0x3, false }, // 2141 + { PseudoVREM_VV_M1_E8_MASK, PseudoVREM_VV_M1_E8, 0x3, false }, // 2142 + { PseudoVREM_VV_M2_E16_MASK, PseudoVREM_VV_M2_E16, 0x3, false }, // 2143 + { PseudoVREM_VV_M2_E32_MASK, PseudoVREM_VV_M2_E32, 0x3, false }, // 2144 + { PseudoVREM_VV_M2_E64_MASK, PseudoVREM_VV_M2_E64, 0x3, false }, // 2145 + { PseudoVREM_VV_M2_E8_MASK, PseudoVREM_VV_M2_E8, 0x3, false }, // 2146 + { PseudoVREM_VV_M4_E16_MASK, PseudoVREM_VV_M4_E16, 0x3, false }, // 2147 + { PseudoVREM_VV_M4_E32_MASK, PseudoVREM_VV_M4_E32, 0x3, false }, // 2148 + { PseudoVREM_VV_M4_E64_MASK, PseudoVREM_VV_M4_E64, 0x3, false }, // 2149 + { PseudoVREM_VV_M4_E8_MASK, PseudoVREM_VV_M4_E8, 0x3, false }, // 2150 + { PseudoVREM_VV_M8_E16_MASK, PseudoVREM_VV_M8_E16, 0x3, false }, // 2151 + { PseudoVREM_VV_M8_E32_MASK, PseudoVREM_VV_M8_E32, 0x3, false }, // 2152 + { PseudoVREM_VV_M8_E64_MASK, PseudoVREM_VV_M8_E64, 0x3, false }, // 2153 + { PseudoVREM_VV_M8_E8_MASK, PseudoVREM_VV_M8_E8, 0x3, false }, // 2154 + { PseudoVREM_VV_MF2_E16_MASK, PseudoVREM_VV_MF2_E16, 0x3, false }, // 2155 + { PseudoVREM_VV_MF2_E32_MASK, PseudoVREM_VV_MF2_E32, 0x3, false }, // 2156 + { PseudoVREM_VV_MF2_E8_MASK, PseudoVREM_VV_MF2_E8, 0x3, false }, // 2157 + { PseudoVREM_VV_MF4_E16_MASK, PseudoVREM_VV_MF4_E16, 0x3, false }, // 2158 + { PseudoVREM_VV_MF4_E8_MASK, PseudoVREM_VV_MF4_E8, 0x3, false }, // 2159 + { PseudoVREM_VV_MF8_E8_MASK, PseudoVREM_VV_MF8_E8, 0x3, false }, // 2160 + { PseudoVREM_VX_M1_E16_MASK, PseudoVREM_VX_M1_E16, 0x3, false }, // 2161 + { PseudoVREM_VX_M1_E32_MASK, PseudoVREM_VX_M1_E32, 0x3, false }, // 2162 + { PseudoVREM_VX_M1_E64_MASK, PseudoVREM_VX_M1_E64, 0x3, false }, // 2163 + { PseudoVREM_VX_M1_E8_MASK, PseudoVREM_VX_M1_E8, 0x3, false }, // 2164 + { PseudoVREM_VX_M2_E16_MASK, PseudoVREM_VX_M2_E16, 0x3, false }, // 2165 + { PseudoVREM_VX_M2_E32_MASK, PseudoVREM_VX_M2_E32, 0x3, false }, // 2166 + { PseudoVREM_VX_M2_E64_MASK, PseudoVREM_VX_M2_E64, 0x3, false }, // 2167 + { PseudoVREM_VX_M2_E8_MASK, PseudoVREM_VX_M2_E8, 0x3, false }, // 2168 + { PseudoVREM_VX_M4_E16_MASK, PseudoVREM_VX_M4_E16, 0x3, false }, // 2169 + { PseudoVREM_VX_M4_E32_MASK, PseudoVREM_VX_M4_E32, 0x3, false }, // 2170 + { PseudoVREM_VX_M4_E64_MASK, PseudoVREM_VX_M4_E64, 0x3, false }, // 2171 + { PseudoVREM_VX_M4_E8_MASK, PseudoVREM_VX_M4_E8, 0x3, false }, // 2172 + { PseudoVREM_VX_M8_E16_MASK, PseudoVREM_VX_M8_E16, 0x3, false }, // 2173 + { PseudoVREM_VX_M8_E32_MASK, PseudoVREM_VX_M8_E32, 0x3, false }, // 2174 + { PseudoVREM_VX_M8_E64_MASK, PseudoVREM_VX_M8_E64, 0x3, false }, // 2175 + { PseudoVREM_VX_M8_E8_MASK, PseudoVREM_VX_M8_E8, 0x3, false }, // 2176 + { PseudoVREM_VX_MF2_E16_MASK, PseudoVREM_VX_MF2_E16, 0x3, false }, // 2177 + { PseudoVREM_VX_MF2_E32_MASK, PseudoVREM_VX_MF2_E32, 0x3, false }, // 2178 + { PseudoVREM_VX_MF2_E8_MASK, PseudoVREM_VX_MF2_E8, 0x3, false }, // 2179 + { PseudoVREM_VX_MF4_E16_MASK, PseudoVREM_VX_MF4_E16, 0x3, false }, // 2180 + { PseudoVREM_VX_MF4_E8_MASK, PseudoVREM_VX_MF4_E8, 0x3, false }, // 2181 + { PseudoVREM_VX_MF8_E8_MASK, PseudoVREM_VX_MF8_E8, 0x3, false }, // 2182 + { PseudoVREV8_V_M1_MASK, PseudoVREV8_V_M1, 0x2, false }, // 2183 + { PseudoVREV8_V_M2_MASK, PseudoVREV8_V_M2, 0x2, false }, // 2184 + { PseudoVREV8_V_M4_MASK, PseudoVREV8_V_M4, 0x2, false }, // 2185 + { PseudoVREV8_V_M8_MASK, PseudoVREV8_V_M8, 0x2, false }, // 2186 + { PseudoVREV8_V_MF2_MASK, PseudoVREV8_V_MF2, 0x2, false }, // 2187 + { PseudoVREV8_V_MF4_MASK, PseudoVREV8_V_MF4, 0x2, false }, // 2188 + { PseudoVREV8_V_MF8_MASK, PseudoVREV8_V_MF8, 0x2, false }, // 2189 + { PseudoVRGATHEREI16_VV_M1_E16_M1_MASK, PseudoVRGATHEREI16_VV_M1_E16_M1, 0x3, false }, // 2190 + { PseudoVRGATHEREI16_VV_M1_E16_M2_MASK, PseudoVRGATHEREI16_VV_M1_E16_M2, 0x3, false }, // 2191 + { PseudoVRGATHEREI16_VV_M1_E16_MF2_MASK, PseudoVRGATHEREI16_VV_M1_E16_MF2, 0x3, false }, // 2192 + { PseudoVRGATHEREI16_VV_M1_E16_MF4_MASK, PseudoVRGATHEREI16_VV_M1_E16_MF4, 0x3, false }, // 2193 + { PseudoVRGATHEREI16_VV_M1_E32_M1_MASK, PseudoVRGATHEREI16_VV_M1_E32_M1, 0x3, false }, // 2194 + { PseudoVRGATHEREI16_VV_M1_E32_M2_MASK, PseudoVRGATHEREI16_VV_M1_E32_M2, 0x3, false }, // 2195 + { PseudoVRGATHEREI16_VV_M1_E32_MF2_MASK, PseudoVRGATHEREI16_VV_M1_E32_MF2, 0x3, false }, // 2196 + { PseudoVRGATHEREI16_VV_M1_E32_MF4_MASK, PseudoVRGATHEREI16_VV_M1_E32_MF4, 0x3, false }, // 2197 + { PseudoVRGATHEREI16_VV_M1_E64_M1_MASK, PseudoVRGATHEREI16_VV_M1_E64_M1, 0x3, false }, // 2198 + { PseudoVRGATHEREI16_VV_M1_E64_M2_MASK, PseudoVRGATHEREI16_VV_M1_E64_M2, 0x3, false }, // 2199 + { PseudoVRGATHEREI16_VV_M1_E64_MF2_MASK, PseudoVRGATHEREI16_VV_M1_E64_MF2, 0x3, false }, // 2200 + { PseudoVRGATHEREI16_VV_M1_E64_MF4_MASK, PseudoVRGATHEREI16_VV_M1_E64_MF4, 0x3, false }, // 2201 + { PseudoVRGATHEREI16_VV_M1_E8_M1_MASK, PseudoVRGATHEREI16_VV_M1_E8_M1, 0x3, false }, // 2202 + { PseudoVRGATHEREI16_VV_M1_E8_M2_MASK, PseudoVRGATHEREI16_VV_M1_E8_M2, 0x3, false }, // 2203 + { PseudoVRGATHEREI16_VV_M1_E8_MF2_MASK, PseudoVRGATHEREI16_VV_M1_E8_MF2, 0x3, false }, // 2204 + { PseudoVRGATHEREI16_VV_M1_E8_MF4_MASK, PseudoVRGATHEREI16_VV_M1_E8_MF4, 0x3, false }, // 2205 + { PseudoVRGATHEREI16_VV_M2_E16_M1_MASK, PseudoVRGATHEREI16_VV_M2_E16_M1, 0x3, false }, // 2206 + { PseudoVRGATHEREI16_VV_M2_E16_M2_MASK, PseudoVRGATHEREI16_VV_M2_E16_M2, 0x3, false }, // 2207 + { PseudoVRGATHEREI16_VV_M2_E16_M4_MASK, PseudoVRGATHEREI16_VV_M2_E16_M4, 0x3, false }, // 2208 + { PseudoVRGATHEREI16_VV_M2_E16_MF2_MASK, PseudoVRGATHEREI16_VV_M2_E16_MF2, 0x3, false }, // 2209 + { PseudoVRGATHEREI16_VV_M2_E32_M1_MASK, PseudoVRGATHEREI16_VV_M2_E32_M1, 0x3, false }, // 2210 + { PseudoVRGATHEREI16_VV_M2_E32_M2_MASK, PseudoVRGATHEREI16_VV_M2_E32_M2, 0x3, false }, // 2211 + { PseudoVRGATHEREI16_VV_M2_E32_M4_MASK, PseudoVRGATHEREI16_VV_M2_E32_M4, 0x3, false }, // 2212 + { PseudoVRGATHEREI16_VV_M2_E32_MF2_MASK, PseudoVRGATHEREI16_VV_M2_E32_MF2, 0x3, false }, // 2213 + { PseudoVRGATHEREI16_VV_M2_E64_M1_MASK, PseudoVRGATHEREI16_VV_M2_E64_M1, 0x3, false }, // 2214 + { PseudoVRGATHEREI16_VV_M2_E64_M2_MASK, PseudoVRGATHEREI16_VV_M2_E64_M2, 0x3, false }, // 2215 + { PseudoVRGATHEREI16_VV_M2_E64_M4_MASK, PseudoVRGATHEREI16_VV_M2_E64_M4, 0x3, false }, // 2216 + { PseudoVRGATHEREI16_VV_M2_E64_MF2_MASK, PseudoVRGATHEREI16_VV_M2_E64_MF2, 0x3, false }, // 2217 + { PseudoVRGATHEREI16_VV_M2_E8_M1_MASK, PseudoVRGATHEREI16_VV_M2_E8_M1, 0x3, false }, // 2218 + { PseudoVRGATHEREI16_VV_M2_E8_M2_MASK, PseudoVRGATHEREI16_VV_M2_E8_M2, 0x3, false }, // 2219 + { PseudoVRGATHEREI16_VV_M2_E8_M4_MASK, PseudoVRGATHEREI16_VV_M2_E8_M4, 0x3, false }, // 2220 + { PseudoVRGATHEREI16_VV_M2_E8_MF2_MASK, PseudoVRGATHEREI16_VV_M2_E8_MF2, 0x3, false }, // 2221 + { PseudoVRGATHEREI16_VV_M4_E16_M1_MASK, PseudoVRGATHEREI16_VV_M4_E16_M1, 0x3, false }, // 2222 + { PseudoVRGATHEREI16_VV_M4_E16_M2_MASK, PseudoVRGATHEREI16_VV_M4_E16_M2, 0x3, false }, // 2223 + { PseudoVRGATHEREI16_VV_M4_E16_M4_MASK, PseudoVRGATHEREI16_VV_M4_E16_M4, 0x3, false }, // 2224 + { PseudoVRGATHEREI16_VV_M4_E16_M8_MASK, PseudoVRGATHEREI16_VV_M4_E16_M8, 0x3, false }, // 2225 + { PseudoVRGATHEREI16_VV_M4_E32_M1_MASK, PseudoVRGATHEREI16_VV_M4_E32_M1, 0x3, false }, // 2226 + { PseudoVRGATHEREI16_VV_M4_E32_M2_MASK, PseudoVRGATHEREI16_VV_M4_E32_M2, 0x3, false }, // 2227 + { PseudoVRGATHEREI16_VV_M4_E32_M4_MASK, PseudoVRGATHEREI16_VV_M4_E32_M4, 0x3, false }, // 2228 + { PseudoVRGATHEREI16_VV_M4_E32_M8_MASK, PseudoVRGATHEREI16_VV_M4_E32_M8, 0x3, false }, // 2229 + { PseudoVRGATHEREI16_VV_M4_E64_M1_MASK, PseudoVRGATHEREI16_VV_M4_E64_M1, 0x3, false }, // 2230 + { PseudoVRGATHEREI16_VV_M4_E64_M2_MASK, PseudoVRGATHEREI16_VV_M4_E64_M2, 0x3, false }, // 2231 + { PseudoVRGATHEREI16_VV_M4_E64_M4_MASK, PseudoVRGATHEREI16_VV_M4_E64_M4, 0x3, false }, // 2232 + { PseudoVRGATHEREI16_VV_M4_E64_M8_MASK, PseudoVRGATHEREI16_VV_M4_E64_M8, 0x3, false }, // 2233 + { PseudoVRGATHEREI16_VV_M4_E8_M1_MASK, PseudoVRGATHEREI16_VV_M4_E8_M1, 0x3, false }, // 2234 + { PseudoVRGATHEREI16_VV_M4_E8_M2_MASK, PseudoVRGATHEREI16_VV_M4_E8_M2, 0x3, false }, // 2235 + { PseudoVRGATHEREI16_VV_M4_E8_M4_MASK, PseudoVRGATHEREI16_VV_M4_E8_M4, 0x3, false }, // 2236 + { PseudoVRGATHEREI16_VV_M4_E8_M8_MASK, PseudoVRGATHEREI16_VV_M4_E8_M8, 0x3, false }, // 2237 + { PseudoVRGATHEREI16_VV_M8_E16_M2_MASK, PseudoVRGATHEREI16_VV_M8_E16_M2, 0x3, false }, // 2238 + { PseudoVRGATHEREI16_VV_M8_E16_M4_MASK, PseudoVRGATHEREI16_VV_M8_E16_M4, 0x3, false }, // 2239 + { PseudoVRGATHEREI16_VV_M8_E16_M8_MASK, PseudoVRGATHEREI16_VV_M8_E16_M8, 0x3, false }, // 2240 + { PseudoVRGATHEREI16_VV_M8_E32_M2_MASK, PseudoVRGATHEREI16_VV_M8_E32_M2, 0x3, false }, // 2241 + { PseudoVRGATHEREI16_VV_M8_E32_M4_MASK, PseudoVRGATHEREI16_VV_M8_E32_M4, 0x3, false }, // 2242 + { PseudoVRGATHEREI16_VV_M8_E32_M8_MASK, PseudoVRGATHEREI16_VV_M8_E32_M8, 0x3, false }, // 2243 + { PseudoVRGATHEREI16_VV_M8_E64_M2_MASK, PseudoVRGATHEREI16_VV_M8_E64_M2, 0x3, false }, // 2244 + { PseudoVRGATHEREI16_VV_M8_E64_M4_MASK, PseudoVRGATHEREI16_VV_M8_E64_M4, 0x3, false }, // 2245 + { PseudoVRGATHEREI16_VV_M8_E64_M8_MASK, PseudoVRGATHEREI16_VV_M8_E64_M8, 0x3, false }, // 2246 + { PseudoVRGATHEREI16_VV_M8_E8_M2_MASK, PseudoVRGATHEREI16_VV_M8_E8_M2, 0x3, false }, // 2247 + { PseudoVRGATHEREI16_VV_M8_E8_M4_MASK, PseudoVRGATHEREI16_VV_M8_E8_M4, 0x3, false }, // 2248 + { PseudoVRGATHEREI16_VV_M8_E8_M8_MASK, PseudoVRGATHEREI16_VV_M8_E8_M8, 0x3, false }, // 2249 + { PseudoVRGATHEREI16_VV_MF2_E16_M1_MASK, PseudoVRGATHEREI16_VV_MF2_E16_M1, 0x3, false }, // 2250 + { PseudoVRGATHEREI16_VV_MF2_E16_MF2_MASK, PseudoVRGATHEREI16_VV_MF2_E16_MF2, 0x3, false }, // 2251 + { PseudoVRGATHEREI16_VV_MF2_E16_MF4_MASK, PseudoVRGATHEREI16_VV_MF2_E16_MF4, 0x3, false }, // 2252 + { PseudoVRGATHEREI16_VV_MF2_E16_MF8_MASK, PseudoVRGATHEREI16_VV_MF2_E16_MF8, 0x3, false }, // 2253 + { PseudoVRGATHEREI16_VV_MF2_E32_M1_MASK, PseudoVRGATHEREI16_VV_MF2_E32_M1, 0x3, false }, // 2254 + { PseudoVRGATHEREI16_VV_MF2_E32_MF2_MASK, PseudoVRGATHEREI16_VV_MF2_E32_MF2, 0x3, false }, // 2255 + { PseudoVRGATHEREI16_VV_MF2_E32_MF4_MASK, PseudoVRGATHEREI16_VV_MF2_E32_MF4, 0x3, false }, // 2256 + { PseudoVRGATHEREI16_VV_MF2_E32_MF8_MASK, PseudoVRGATHEREI16_VV_MF2_E32_MF8, 0x3, false }, // 2257 + { PseudoVRGATHEREI16_VV_MF2_E8_M1_MASK, PseudoVRGATHEREI16_VV_MF2_E8_M1, 0x3, false }, // 2258 + { PseudoVRGATHEREI16_VV_MF2_E8_MF2_MASK, PseudoVRGATHEREI16_VV_MF2_E8_MF2, 0x3, false }, // 2259 + { PseudoVRGATHEREI16_VV_MF2_E8_MF4_MASK, PseudoVRGATHEREI16_VV_MF2_E8_MF4, 0x3, false }, // 2260 + { PseudoVRGATHEREI16_VV_MF2_E8_MF8_MASK, PseudoVRGATHEREI16_VV_MF2_E8_MF8, 0x3, false }, // 2261 + { PseudoVRGATHEREI16_VV_MF4_E16_MF2_MASK, PseudoVRGATHEREI16_VV_MF4_E16_MF2, 0x3, false }, // 2262 + { PseudoVRGATHEREI16_VV_MF4_E16_MF4_MASK, PseudoVRGATHEREI16_VV_MF4_E16_MF4, 0x3, false }, // 2263 + { PseudoVRGATHEREI16_VV_MF4_E16_MF8_MASK, PseudoVRGATHEREI16_VV_MF4_E16_MF8, 0x3, false }, // 2264 + { PseudoVRGATHEREI16_VV_MF4_E8_MF2_MASK, PseudoVRGATHEREI16_VV_MF4_E8_MF2, 0x3, false }, // 2265 + { PseudoVRGATHEREI16_VV_MF4_E8_MF4_MASK, PseudoVRGATHEREI16_VV_MF4_E8_MF4, 0x3, false }, // 2266 + { PseudoVRGATHEREI16_VV_MF4_E8_MF8_MASK, PseudoVRGATHEREI16_VV_MF4_E8_MF8, 0x3, false }, // 2267 + { PseudoVRGATHEREI16_VV_MF8_E8_MF4_MASK, PseudoVRGATHEREI16_VV_MF8_E8_MF4, 0x3, false }, // 2268 + { PseudoVRGATHEREI16_VV_MF8_E8_MF8_MASK, PseudoVRGATHEREI16_VV_MF8_E8_MF8, 0x3, false }, // 2269 + { PseudoVRGATHER_VI_M1_MASK, PseudoVRGATHER_VI_M1, 0x3, false }, // 2270 + { PseudoVRGATHER_VI_M2_MASK, PseudoVRGATHER_VI_M2, 0x3, false }, // 2271 + { PseudoVRGATHER_VI_M4_MASK, PseudoVRGATHER_VI_M4, 0x3, false }, // 2272 + { PseudoVRGATHER_VI_M8_MASK, PseudoVRGATHER_VI_M8, 0x3, false }, // 2273 + { PseudoVRGATHER_VI_MF2_MASK, PseudoVRGATHER_VI_MF2, 0x3, false }, // 2274 + { PseudoVRGATHER_VI_MF4_MASK, PseudoVRGATHER_VI_MF4, 0x3, false }, // 2275 + { PseudoVRGATHER_VI_MF8_MASK, PseudoVRGATHER_VI_MF8, 0x3, false }, // 2276 + { PseudoVRGATHER_VV_M1_E16_MASK, PseudoVRGATHER_VV_M1_E16, 0x3, false }, // 2277 + { PseudoVRGATHER_VV_M1_E32_MASK, PseudoVRGATHER_VV_M1_E32, 0x3, false }, // 2278 + { PseudoVRGATHER_VV_M1_E64_MASK, PseudoVRGATHER_VV_M1_E64, 0x3, false }, // 2279 + { PseudoVRGATHER_VV_M1_E8_MASK, PseudoVRGATHER_VV_M1_E8, 0x3, false }, // 2280 + { PseudoVRGATHER_VV_M2_E16_MASK, PseudoVRGATHER_VV_M2_E16, 0x3, false }, // 2281 + { PseudoVRGATHER_VV_M2_E32_MASK, PseudoVRGATHER_VV_M2_E32, 0x3, false }, // 2282 + { PseudoVRGATHER_VV_M2_E64_MASK, PseudoVRGATHER_VV_M2_E64, 0x3, false }, // 2283 + { PseudoVRGATHER_VV_M2_E8_MASK, PseudoVRGATHER_VV_M2_E8, 0x3, false }, // 2284 + { PseudoVRGATHER_VV_M4_E16_MASK, PseudoVRGATHER_VV_M4_E16, 0x3, false }, // 2285 + { PseudoVRGATHER_VV_M4_E32_MASK, PseudoVRGATHER_VV_M4_E32, 0x3, false }, // 2286 + { PseudoVRGATHER_VV_M4_E64_MASK, PseudoVRGATHER_VV_M4_E64, 0x3, false }, // 2287 + { PseudoVRGATHER_VV_M4_E8_MASK, PseudoVRGATHER_VV_M4_E8, 0x3, false }, // 2288 + { PseudoVRGATHER_VV_M8_E16_MASK, PseudoVRGATHER_VV_M8_E16, 0x3, false }, // 2289 + { PseudoVRGATHER_VV_M8_E32_MASK, PseudoVRGATHER_VV_M8_E32, 0x3, false }, // 2290 + { PseudoVRGATHER_VV_M8_E64_MASK, PseudoVRGATHER_VV_M8_E64, 0x3, false }, // 2291 + { PseudoVRGATHER_VV_M8_E8_MASK, PseudoVRGATHER_VV_M8_E8, 0x3, false }, // 2292 + { PseudoVRGATHER_VV_MF2_E16_MASK, PseudoVRGATHER_VV_MF2_E16, 0x3, false }, // 2293 + { PseudoVRGATHER_VV_MF2_E32_MASK, PseudoVRGATHER_VV_MF2_E32, 0x3, false }, // 2294 + { PseudoVRGATHER_VV_MF2_E8_MASK, PseudoVRGATHER_VV_MF2_E8, 0x3, false }, // 2295 + { PseudoVRGATHER_VV_MF4_E16_MASK, PseudoVRGATHER_VV_MF4_E16, 0x3, false }, // 2296 + { PseudoVRGATHER_VV_MF4_E8_MASK, PseudoVRGATHER_VV_MF4_E8, 0x3, false }, // 2297 + { PseudoVRGATHER_VV_MF8_E8_MASK, PseudoVRGATHER_VV_MF8_E8, 0x3, false }, // 2298 + { PseudoVRGATHER_VX_M1_MASK, PseudoVRGATHER_VX_M1, 0x3, false }, // 2299 + { PseudoVRGATHER_VX_M2_MASK, PseudoVRGATHER_VX_M2, 0x3, false }, // 2300 + { PseudoVRGATHER_VX_M4_MASK, PseudoVRGATHER_VX_M4, 0x3, false }, // 2301 + { PseudoVRGATHER_VX_M8_MASK, PseudoVRGATHER_VX_M8, 0x3, false }, // 2302 + { PseudoVRGATHER_VX_MF2_MASK, PseudoVRGATHER_VX_MF2, 0x3, false }, // 2303 + { PseudoVRGATHER_VX_MF4_MASK, PseudoVRGATHER_VX_MF4, 0x3, false }, // 2304 + { PseudoVRGATHER_VX_MF8_MASK, PseudoVRGATHER_VX_MF8, 0x3, false }, // 2305 + { PseudoVROL_VV_M1_MASK, PseudoVROL_VV_M1, 0x3, false }, // 2306 + { PseudoVROL_VV_M2_MASK, PseudoVROL_VV_M2, 0x3, false }, // 2307 + { PseudoVROL_VV_M4_MASK, PseudoVROL_VV_M4, 0x3, false }, // 2308 + { PseudoVROL_VV_M8_MASK, PseudoVROL_VV_M8, 0x3, false }, // 2309 + { PseudoVROL_VV_MF2_MASK, PseudoVROL_VV_MF2, 0x3, false }, // 2310 + { PseudoVROL_VV_MF4_MASK, PseudoVROL_VV_MF4, 0x3, false }, // 2311 + { PseudoVROL_VV_MF8_MASK, PseudoVROL_VV_MF8, 0x3, false }, // 2312 + { PseudoVROL_VX_M1_MASK, PseudoVROL_VX_M1, 0x3, false }, // 2313 + { PseudoVROL_VX_M2_MASK, PseudoVROL_VX_M2, 0x3, false }, // 2314 + { PseudoVROL_VX_M4_MASK, PseudoVROL_VX_M4, 0x3, false }, // 2315 + { PseudoVROL_VX_M8_MASK, PseudoVROL_VX_M8, 0x3, false }, // 2316 + { PseudoVROL_VX_MF2_MASK, PseudoVROL_VX_MF2, 0x3, false }, // 2317 + { PseudoVROL_VX_MF4_MASK, PseudoVROL_VX_MF4, 0x3, false }, // 2318 + { PseudoVROL_VX_MF8_MASK, PseudoVROL_VX_MF8, 0x3, false }, // 2319 + { PseudoVROR_VI_M1_MASK, PseudoVROR_VI_M1, 0x3, false }, // 2320 + { PseudoVROR_VI_M2_MASK, PseudoVROR_VI_M2, 0x3, false }, // 2321 + { PseudoVROR_VI_M4_MASK, PseudoVROR_VI_M4, 0x3, false }, // 2322 + { PseudoVROR_VI_M8_MASK, PseudoVROR_VI_M8, 0x3, false }, // 2323 + { PseudoVROR_VI_MF2_MASK, PseudoVROR_VI_MF2, 0x3, false }, // 2324 + { PseudoVROR_VI_MF4_MASK, PseudoVROR_VI_MF4, 0x3, false }, // 2325 + { PseudoVROR_VI_MF8_MASK, PseudoVROR_VI_MF8, 0x3, false }, // 2326 + { PseudoVROR_VV_M1_MASK, PseudoVROR_VV_M1, 0x3, false }, // 2327 + { PseudoVROR_VV_M2_MASK, PseudoVROR_VV_M2, 0x3, false }, // 2328 + { PseudoVROR_VV_M4_MASK, PseudoVROR_VV_M4, 0x3, false }, // 2329 + { PseudoVROR_VV_M8_MASK, PseudoVROR_VV_M8, 0x3, false }, // 2330 + { PseudoVROR_VV_MF2_MASK, PseudoVROR_VV_MF2, 0x3, false }, // 2331 + { PseudoVROR_VV_MF4_MASK, PseudoVROR_VV_MF4, 0x3, false }, // 2332 + { PseudoVROR_VV_MF8_MASK, PseudoVROR_VV_MF8, 0x3, false }, // 2333 + { PseudoVROR_VX_M1_MASK, PseudoVROR_VX_M1, 0x3, false }, // 2334 + { PseudoVROR_VX_M2_MASK, PseudoVROR_VX_M2, 0x3, false }, // 2335 + { PseudoVROR_VX_M4_MASK, PseudoVROR_VX_M4, 0x3, false }, // 2336 + { PseudoVROR_VX_M8_MASK, PseudoVROR_VX_M8, 0x3, false }, // 2337 + { PseudoVROR_VX_MF2_MASK, PseudoVROR_VX_MF2, 0x3, false }, // 2338 + { PseudoVROR_VX_MF4_MASK, PseudoVROR_VX_MF4, 0x3, false }, // 2339 + { PseudoVROR_VX_MF8_MASK, PseudoVROR_VX_MF8, 0x3, false }, // 2340 + { PseudoVRSUB_VI_M1_MASK, PseudoVRSUB_VI_M1, 0x3, false }, // 2341 + { PseudoVRSUB_VI_M2_MASK, PseudoVRSUB_VI_M2, 0x3, false }, // 2342 + { PseudoVRSUB_VI_M4_MASK, PseudoVRSUB_VI_M4, 0x3, false }, // 2343 + { PseudoVRSUB_VI_M8_MASK, PseudoVRSUB_VI_M8, 0x3, false }, // 2344 + { PseudoVRSUB_VI_MF2_MASK, PseudoVRSUB_VI_MF2, 0x3, false }, // 2345 + { PseudoVRSUB_VI_MF4_MASK, PseudoVRSUB_VI_MF4, 0x3, false }, // 2346 + { PseudoVRSUB_VI_MF8_MASK, PseudoVRSUB_VI_MF8, 0x3, false }, // 2347 + { PseudoVRSUB_VX_M1_MASK, PseudoVRSUB_VX_M1, 0x3, false }, // 2348 + { PseudoVRSUB_VX_M2_MASK, PseudoVRSUB_VX_M2, 0x3, false }, // 2349 + { PseudoVRSUB_VX_M4_MASK, PseudoVRSUB_VX_M4, 0x3, false }, // 2350 + { PseudoVRSUB_VX_M8_MASK, PseudoVRSUB_VX_M8, 0x3, false }, // 2351 + { PseudoVRSUB_VX_MF2_MASK, PseudoVRSUB_VX_MF2, 0x3, false }, // 2352 + { PseudoVRSUB_VX_MF4_MASK, PseudoVRSUB_VX_MF4, 0x3, false }, // 2353 + { PseudoVRSUB_VX_MF8_MASK, PseudoVRSUB_VX_MF8, 0x3, false }, // 2354 + { PseudoVSADDU_VI_M1_MASK, PseudoVSADDU_VI_M1, 0x3, false }, // 2355 + { PseudoVSADDU_VI_M2_MASK, PseudoVSADDU_VI_M2, 0x3, false }, // 2356 + { PseudoVSADDU_VI_M4_MASK, PseudoVSADDU_VI_M4, 0x3, false }, // 2357 + { PseudoVSADDU_VI_M8_MASK, PseudoVSADDU_VI_M8, 0x3, false }, // 2358 + { PseudoVSADDU_VI_MF2_MASK, PseudoVSADDU_VI_MF2, 0x3, false }, // 2359 + { PseudoVSADDU_VI_MF4_MASK, PseudoVSADDU_VI_MF4, 0x3, false }, // 2360 + { PseudoVSADDU_VI_MF8_MASK, PseudoVSADDU_VI_MF8, 0x3, false }, // 2361 + { PseudoVSADDU_VV_M1_MASK, PseudoVSADDU_VV_M1, 0x3, false }, // 2362 + { PseudoVSADDU_VV_M2_MASK, PseudoVSADDU_VV_M2, 0x3, false }, // 2363 + { PseudoVSADDU_VV_M4_MASK, PseudoVSADDU_VV_M4, 0x3, false }, // 2364 + { PseudoVSADDU_VV_M8_MASK, PseudoVSADDU_VV_M8, 0x3, false }, // 2365 + { PseudoVSADDU_VV_MF2_MASK, PseudoVSADDU_VV_MF2, 0x3, false }, // 2366 + { PseudoVSADDU_VV_MF4_MASK, PseudoVSADDU_VV_MF4, 0x3, false }, // 2367 + { PseudoVSADDU_VV_MF8_MASK, PseudoVSADDU_VV_MF8, 0x3, false }, // 2368 + { PseudoVSADDU_VX_M1_MASK, PseudoVSADDU_VX_M1, 0x3, false }, // 2369 + { PseudoVSADDU_VX_M2_MASK, PseudoVSADDU_VX_M2, 0x3, false }, // 2370 + { PseudoVSADDU_VX_M4_MASK, PseudoVSADDU_VX_M4, 0x3, false }, // 2371 + { PseudoVSADDU_VX_M8_MASK, PseudoVSADDU_VX_M8, 0x3, false }, // 2372 + { PseudoVSADDU_VX_MF2_MASK, PseudoVSADDU_VX_MF2, 0x3, false }, // 2373 + { PseudoVSADDU_VX_MF4_MASK, PseudoVSADDU_VX_MF4, 0x3, false }, // 2374 + { PseudoVSADDU_VX_MF8_MASK, PseudoVSADDU_VX_MF8, 0x3, false }, // 2375 + { PseudoVSADD_VI_M1_MASK, PseudoVSADD_VI_M1, 0x3, false }, // 2376 + { PseudoVSADD_VI_M2_MASK, PseudoVSADD_VI_M2, 0x3, false }, // 2377 + { PseudoVSADD_VI_M4_MASK, PseudoVSADD_VI_M4, 0x3, false }, // 2378 + { PseudoVSADD_VI_M8_MASK, PseudoVSADD_VI_M8, 0x3, false }, // 2379 + { PseudoVSADD_VI_MF2_MASK, PseudoVSADD_VI_MF2, 0x3, false }, // 2380 + { PseudoVSADD_VI_MF4_MASK, PseudoVSADD_VI_MF4, 0x3, false }, // 2381 + { PseudoVSADD_VI_MF8_MASK, PseudoVSADD_VI_MF8, 0x3, false }, // 2382 + { PseudoVSADD_VV_M1_MASK, PseudoVSADD_VV_M1, 0x3, false }, // 2383 + { PseudoVSADD_VV_M2_MASK, PseudoVSADD_VV_M2, 0x3, false }, // 2384 + { PseudoVSADD_VV_M4_MASK, PseudoVSADD_VV_M4, 0x3, false }, // 2385 + { PseudoVSADD_VV_M8_MASK, PseudoVSADD_VV_M8, 0x3, false }, // 2386 + { PseudoVSADD_VV_MF2_MASK, PseudoVSADD_VV_MF2, 0x3, false }, // 2387 + { PseudoVSADD_VV_MF4_MASK, PseudoVSADD_VV_MF4, 0x3, false }, // 2388 + { PseudoVSADD_VV_MF8_MASK, PseudoVSADD_VV_MF8, 0x3, false }, // 2389 + { PseudoVSADD_VX_M1_MASK, PseudoVSADD_VX_M1, 0x3, false }, // 2390 + { PseudoVSADD_VX_M2_MASK, PseudoVSADD_VX_M2, 0x3, false }, // 2391 + { PseudoVSADD_VX_M4_MASK, PseudoVSADD_VX_M4, 0x3, false }, // 2392 + { PseudoVSADD_VX_M8_MASK, PseudoVSADD_VX_M8, 0x3, false }, // 2393 + { PseudoVSADD_VX_MF2_MASK, PseudoVSADD_VX_MF2, 0x3, false }, // 2394 + { PseudoVSADD_VX_MF4_MASK, PseudoVSADD_VX_MF4, 0x3, false }, // 2395 + { PseudoVSADD_VX_MF8_MASK, PseudoVSADD_VX_MF8, 0x3, false }, // 2396 + { PseudoVSEXT_VF2_M1_MASK, PseudoVSEXT_VF2_M1, 0x2, false }, // 2397 + { PseudoVSEXT_VF2_M2_MASK, PseudoVSEXT_VF2_M2, 0x2, false }, // 2398 + { PseudoVSEXT_VF2_M4_MASK, PseudoVSEXT_VF2_M4, 0x2, false }, // 2399 + { PseudoVSEXT_VF2_M8_MASK, PseudoVSEXT_VF2_M8, 0x2, false }, // 2400 + { PseudoVSEXT_VF2_MF2_MASK, PseudoVSEXT_VF2_MF2, 0x2, false }, // 2401 + { PseudoVSEXT_VF2_MF4_MASK, PseudoVSEXT_VF2_MF4, 0x2, false }, // 2402 + { PseudoVSEXT_VF4_M1_MASK, PseudoVSEXT_VF4_M1, 0x2, false }, // 2403 + { PseudoVSEXT_VF4_M2_MASK, PseudoVSEXT_VF4_M2, 0x2, false }, // 2404 + { PseudoVSEXT_VF4_M4_MASK, PseudoVSEXT_VF4_M4, 0x2, false }, // 2405 + { PseudoVSEXT_VF4_M8_MASK, PseudoVSEXT_VF4_M8, 0x2, false }, // 2406 + { PseudoVSEXT_VF4_MF2_MASK, PseudoVSEXT_VF4_MF2, 0x2, false }, // 2407 + { PseudoVSEXT_VF8_M1_MASK, PseudoVSEXT_VF8_M1, 0x2, false }, // 2408 + { PseudoVSEXT_VF8_M2_MASK, PseudoVSEXT_VF8_M2, 0x2, false }, // 2409 + { PseudoVSEXT_VF8_M4_MASK, PseudoVSEXT_VF8_M4, 0x2, false }, // 2410 + { PseudoVSEXT_VF8_M8_MASK, PseudoVSEXT_VF8_M8, 0x2, false }, // 2411 + { PseudoVSLIDE1DOWN_VX_M1_MASK, PseudoVSLIDE1DOWN_VX_M1, 0x3, false }, // 2412 + { PseudoVSLIDE1DOWN_VX_M2_MASK, PseudoVSLIDE1DOWN_VX_M2, 0x3, false }, // 2413 + { PseudoVSLIDE1DOWN_VX_M4_MASK, PseudoVSLIDE1DOWN_VX_M4, 0x3, false }, // 2414 + { PseudoVSLIDE1DOWN_VX_M8_MASK, PseudoVSLIDE1DOWN_VX_M8, 0x3, false }, // 2415 + { PseudoVSLIDE1DOWN_VX_MF2_MASK, PseudoVSLIDE1DOWN_VX_MF2, 0x3, false }, // 2416 + { PseudoVSLIDE1DOWN_VX_MF4_MASK, PseudoVSLIDE1DOWN_VX_MF4, 0x3, false }, // 2417 + { PseudoVSLIDE1DOWN_VX_MF8_MASK, PseudoVSLIDE1DOWN_VX_MF8, 0x3, false }, // 2418 + { PseudoVSLIDE1UP_VX_M1_MASK, PseudoVSLIDE1UP_VX_M1, 0x3, false }, // 2419 + { PseudoVSLIDE1UP_VX_M2_MASK, PseudoVSLIDE1UP_VX_M2, 0x3, false }, // 2420 + { PseudoVSLIDE1UP_VX_M4_MASK, PseudoVSLIDE1UP_VX_M4, 0x3, false }, // 2421 + { PseudoVSLIDE1UP_VX_M8_MASK, PseudoVSLIDE1UP_VX_M8, 0x3, false }, // 2422 + { PseudoVSLIDE1UP_VX_MF2_MASK, PseudoVSLIDE1UP_VX_MF2, 0x3, false }, // 2423 + { PseudoVSLIDE1UP_VX_MF4_MASK, PseudoVSLIDE1UP_VX_MF4, 0x3, false }, // 2424 + { PseudoVSLIDE1UP_VX_MF8_MASK, PseudoVSLIDE1UP_VX_MF8, 0x3, false }, // 2425 + { PseudoVSLIDEDOWN_VI_M1_MASK, PseudoVSLIDEDOWN_VI_M1, 0x3, false }, // 2426 + { PseudoVSLIDEDOWN_VI_M2_MASK, PseudoVSLIDEDOWN_VI_M2, 0x3, false }, // 2427 + { PseudoVSLIDEDOWN_VI_M4_MASK, PseudoVSLIDEDOWN_VI_M4, 0x3, false }, // 2428 + { PseudoVSLIDEDOWN_VI_M8_MASK, PseudoVSLIDEDOWN_VI_M8, 0x3, false }, // 2429 + { PseudoVSLIDEDOWN_VI_MF2_MASK, PseudoVSLIDEDOWN_VI_MF2, 0x3, false }, // 2430 + { PseudoVSLIDEDOWN_VI_MF4_MASK, PseudoVSLIDEDOWN_VI_MF4, 0x3, false }, // 2431 + { PseudoVSLIDEDOWN_VI_MF8_MASK, PseudoVSLIDEDOWN_VI_MF8, 0x3, false }, // 2432 + { PseudoVSLIDEDOWN_VX_M1_MASK, PseudoVSLIDEDOWN_VX_M1, 0x3, false }, // 2433 + { PseudoVSLIDEDOWN_VX_M2_MASK, PseudoVSLIDEDOWN_VX_M2, 0x3, false }, // 2434 + { PseudoVSLIDEDOWN_VX_M4_MASK, PseudoVSLIDEDOWN_VX_M4, 0x3, false }, // 2435 + { PseudoVSLIDEDOWN_VX_M8_MASK, PseudoVSLIDEDOWN_VX_M8, 0x3, false }, // 2436 + { PseudoVSLIDEDOWN_VX_MF2_MASK, PseudoVSLIDEDOWN_VX_MF2, 0x3, false }, // 2437 + { PseudoVSLIDEDOWN_VX_MF4_MASK, PseudoVSLIDEDOWN_VX_MF4, 0x3, false }, // 2438 + { PseudoVSLIDEDOWN_VX_MF8_MASK, PseudoVSLIDEDOWN_VX_MF8, 0x3, false }, // 2439 + { PseudoVSLIDEUP_VI_M1_MASK, PseudoVSLIDEUP_VI_M1, 0x3, false }, // 2440 + { PseudoVSLIDEUP_VI_M2_MASK, PseudoVSLIDEUP_VI_M2, 0x3, false }, // 2441 + { PseudoVSLIDEUP_VI_M4_MASK, PseudoVSLIDEUP_VI_M4, 0x3, false }, // 2442 + { PseudoVSLIDEUP_VI_M8_MASK, PseudoVSLIDEUP_VI_M8, 0x3, false }, // 2443 + { PseudoVSLIDEUP_VI_MF2_MASK, PseudoVSLIDEUP_VI_MF2, 0x3, false }, // 2444 + { PseudoVSLIDEUP_VI_MF4_MASK, PseudoVSLIDEUP_VI_MF4, 0x3, false }, // 2445 + { PseudoVSLIDEUP_VI_MF8_MASK, PseudoVSLIDEUP_VI_MF8, 0x3, false }, // 2446 + { PseudoVSLIDEUP_VX_M1_MASK, PseudoVSLIDEUP_VX_M1, 0x3, false }, // 2447 + { PseudoVSLIDEUP_VX_M2_MASK, PseudoVSLIDEUP_VX_M2, 0x3, false }, // 2448 + { PseudoVSLIDEUP_VX_M4_MASK, PseudoVSLIDEUP_VX_M4, 0x3, false }, // 2449 + { PseudoVSLIDEUP_VX_M8_MASK, PseudoVSLIDEUP_VX_M8, 0x3, false }, // 2450 + { PseudoVSLIDEUP_VX_MF2_MASK, PseudoVSLIDEUP_VX_MF2, 0x3, false }, // 2451 + { PseudoVSLIDEUP_VX_MF4_MASK, PseudoVSLIDEUP_VX_MF4, 0x3, false }, // 2452 + { PseudoVSLIDEUP_VX_MF8_MASK, PseudoVSLIDEUP_VX_MF8, 0x3, false }, // 2453 + { PseudoVSLL_VI_M1_MASK, PseudoVSLL_VI_M1, 0x3, false }, // 2454 + { PseudoVSLL_VI_M2_MASK, PseudoVSLL_VI_M2, 0x3, false }, // 2455 + { PseudoVSLL_VI_M4_MASK, PseudoVSLL_VI_M4, 0x3, false }, // 2456 + { PseudoVSLL_VI_M8_MASK, PseudoVSLL_VI_M8, 0x3, false }, // 2457 + { PseudoVSLL_VI_MF2_MASK, PseudoVSLL_VI_MF2, 0x3, false }, // 2458 + { PseudoVSLL_VI_MF4_MASK, PseudoVSLL_VI_MF4, 0x3, false }, // 2459 + { PseudoVSLL_VI_MF8_MASK, PseudoVSLL_VI_MF8, 0x3, false }, // 2460 + { PseudoVSLL_VV_M1_MASK, PseudoVSLL_VV_M1, 0x3, false }, // 2461 + { PseudoVSLL_VV_M2_MASK, PseudoVSLL_VV_M2, 0x3, false }, // 2462 + { PseudoVSLL_VV_M4_MASK, PseudoVSLL_VV_M4, 0x3, false }, // 2463 + { PseudoVSLL_VV_M8_MASK, PseudoVSLL_VV_M8, 0x3, false }, // 2464 + { PseudoVSLL_VV_MF2_MASK, PseudoVSLL_VV_MF2, 0x3, false }, // 2465 + { PseudoVSLL_VV_MF4_MASK, PseudoVSLL_VV_MF4, 0x3, false }, // 2466 + { PseudoVSLL_VV_MF8_MASK, PseudoVSLL_VV_MF8, 0x3, false }, // 2467 + { PseudoVSLL_VX_M1_MASK, PseudoVSLL_VX_M1, 0x3, false }, // 2468 + { PseudoVSLL_VX_M2_MASK, PseudoVSLL_VX_M2, 0x3, false }, // 2469 + { PseudoVSLL_VX_M4_MASK, PseudoVSLL_VX_M4, 0x3, false }, // 2470 + { PseudoVSLL_VX_M8_MASK, PseudoVSLL_VX_M8, 0x3, false }, // 2471 + { PseudoVSLL_VX_MF2_MASK, PseudoVSLL_VX_MF2, 0x3, false }, // 2472 + { PseudoVSLL_VX_MF4_MASK, PseudoVSLL_VX_MF4, 0x3, false }, // 2473 + { PseudoVSLL_VX_MF8_MASK, PseudoVSLL_VX_MF8, 0x3, false }, // 2474 + { PseudoVSMUL_VV_M1_MASK, PseudoVSMUL_VV_M1, 0x3, false }, // 2475 + { PseudoVSMUL_VV_M2_MASK, PseudoVSMUL_VV_M2, 0x3, false }, // 2476 + { PseudoVSMUL_VV_M4_MASK, PseudoVSMUL_VV_M4, 0x3, false }, // 2477 + { PseudoVSMUL_VV_M8_MASK, PseudoVSMUL_VV_M8, 0x3, false }, // 2478 + { PseudoVSMUL_VV_MF2_MASK, PseudoVSMUL_VV_MF2, 0x3, false }, // 2479 + { PseudoVSMUL_VV_MF4_MASK, PseudoVSMUL_VV_MF4, 0x3, false }, // 2480 + { PseudoVSMUL_VV_MF8_MASK, PseudoVSMUL_VV_MF8, 0x3, false }, // 2481 + { PseudoVSMUL_VX_M1_MASK, PseudoVSMUL_VX_M1, 0x3, false }, // 2482 + { PseudoVSMUL_VX_M2_MASK, PseudoVSMUL_VX_M2, 0x3, false }, // 2483 + { PseudoVSMUL_VX_M4_MASK, PseudoVSMUL_VX_M4, 0x3, false }, // 2484 + { PseudoVSMUL_VX_M8_MASK, PseudoVSMUL_VX_M8, 0x3, false }, // 2485 + { PseudoVSMUL_VX_MF2_MASK, PseudoVSMUL_VX_MF2, 0x3, false }, // 2486 + { PseudoVSMUL_VX_MF4_MASK, PseudoVSMUL_VX_MF4, 0x3, false }, // 2487 + { PseudoVSMUL_VX_MF8_MASK, PseudoVSMUL_VX_MF8, 0x3, false }, // 2488 + { PseudoVSRA_VI_M1_MASK, PseudoVSRA_VI_M1, 0x3, false }, // 2489 + { PseudoVSRA_VI_M2_MASK, PseudoVSRA_VI_M2, 0x3, false }, // 2490 + { PseudoVSRA_VI_M4_MASK, PseudoVSRA_VI_M4, 0x3, false }, // 2491 + { PseudoVSRA_VI_M8_MASK, PseudoVSRA_VI_M8, 0x3, false }, // 2492 + { PseudoVSRA_VI_MF2_MASK, PseudoVSRA_VI_MF2, 0x3, false }, // 2493 + { PseudoVSRA_VI_MF4_MASK, PseudoVSRA_VI_MF4, 0x3, false }, // 2494 + { PseudoVSRA_VI_MF8_MASK, PseudoVSRA_VI_MF8, 0x3, false }, // 2495 + { PseudoVSRA_VV_M1_MASK, PseudoVSRA_VV_M1, 0x3, false }, // 2496 + { PseudoVSRA_VV_M2_MASK, PseudoVSRA_VV_M2, 0x3, false }, // 2497 + { PseudoVSRA_VV_M4_MASK, PseudoVSRA_VV_M4, 0x3, false }, // 2498 + { PseudoVSRA_VV_M8_MASK, PseudoVSRA_VV_M8, 0x3, false }, // 2499 + { PseudoVSRA_VV_MF2_MASK, PseudoVSRA_VV_MF2, 0x3, false }, // 2500 + { PseudoVSRA_VV_MF4_MASK, PseudoVSRA_VV_MF4, 0x3, false }, // 2501 + { PseudoVSRA_VV_MF8_MASK, PseudoVSRA_VV_MF8, 0x3, false }, // 2502 + { PseudoVSRA_VX_M1_MASK, PseudoVSRA_VX_M1, 0x3, false }, // 2503 + { PseudoVSRA_VX_M2_MASK, PseudoVSRA_VX_M2, 0x3, false }, // 2504 + { PseudoVSRA_VX_M4_MASK, PseudoVSRA_VX_M4, 0x3, false }, // 2505 + { PseudoVSRA_VX_M8_MASK, PseudoVSRA_VX_M8, 0x3, false }, // 2506 + { PseudoVSRA_VX_MF2_MASK, PseudoVSRA_VX_MF2, 0x3, false }, // 2507 + { PseudoVSRA_VX_MF4_MASK, PseudoVSRA_VX_MF4, 0x3, false }, // 2508 + { PseudoVSRA_VX_MF8_MASK, PseudoVSRA_VX_MF8, 0x3, false }, // 2509 + { PseudoVSRL_VI_M1_MASK, PseudoVSRL_VI_M1, 0x3, false }, // 2510 + { PseudoVSRL_VI_M2_MASK, PseudoVSRL_VI_M2, 0x3, false }, // 2511 + { PseudoVSRL_VI_M4_MASK, PseudoVSRL_VI_M4, 0x3, false }, // 2512 + { PseudoVSRL_VI_M8_MASK, PseudoVSRL_VI_M8, 0x3, false }, // 2513 + { PseudoVSRL_VI_MF2_MASK, PseudoVSRL_VI_MF2, 0x3, false }, // 2514 + { PseudoVSRL_VI_MF4_MASK, PseudoVSRL_VI_MF4, 0x3, false }, // 2515 + { PseudoVSRL_VI_MF8_MASK, PseudoVSRL_VI_MF8, 0x3, false }, // 2516 + { PseudoVSRL_VV_M1_MASK, PseudoVSRL_VV_M1, 0x3, false }, // 2517 + { PseudoVSRL_VV_M2_MASK, PseudoVSRL_VV_M2, 0x3, false }, // 2518 + { PseudoVSRL_VV_M4_MASK, PseudoVSRL_VV_M4, 0x3, false }, // 2519 + { PseudoVSRL_VV_M8_MASK, PseudoVSRL_VV_M8, 0x3, false }, // 2520 + { PseudoVSRL_VV_MF2_MASK, PseudoVSRL_VV_MF2, 0x3, false }, // 2521 + { PseudoVSRL_VV_MF4_MASK, PseudoVSRL_VV_MF4, 0x3, false }, // 2522 + { PseudoVSRL_VV_MF8_MASK, PseudoVSRL_VV_MF8, 0x3, false }, // 2523 + { PseudoVSRL_VX_M1_MASK, PseudoVSRL_VX_M1, 0x3, false }, // 2524 + { PseudoVSRL_VX_M2_MASK, PseudoVSRL_VX_M2, 0x3, false }, // 2525 + { PseudoVSRL_VX_M4_MASK, PseudoVSRL_VX_M4, 0x3, false }, // 2526 + { PseudoVSRL_VX_M8_MASK, PseudoVSRL_VX_M8, 0x3, false }, // 2527 + { PseudoVSRL_VX_MF2_MASK, PseudoVSRL_VX_MF2, 0x3, false }, // 2528 + { PseudoVSRL_VX_MF4_MASK, PseudoVSRL_VX_MF4, 0x3, false }, // 2529 + { PseudoVSRL_VX_MF8_MASK, PseudoVSRL_VX_MF8, 0x3, false }, // 2530 + { PseudoVSSRA_VI_M1_MASK, PseudoVSSRA_VI_M1, 0x3, false }, // 2531 + { PseudoVSSRA_VI_M2_MASK, PseudoVSSRA_VI_M2, 0x3, false }, // 2532 + { PseudoVSSRA_VI_M4_MASK, PseudoVSSRA_VI_M4, 0x3, false }, // 2533 + { PseudoVSSRA_VI_M8_MASK, PseudoVSSRA_VI_M8, 0x3, false }, // 2534 + { PseudoVSSRA_VI_MF2_MASK, PseudoVSSRA_VI_MF2, 0x3, false }, // 2535 + { PseudoVSSRA_VI_MF4_MASK, PseudoVSSRA_VI_MF4, 0x3, false }, // 2536 + { PseudoVSSRA_VI_MF8_MASK, PseudoVSSRA_VI_MF8, 0x3, false }, // 2537 + { PseudoVSSRA_VV_M1_MASK, PseudoVSSRA_VV_M1, 0x3, false }, // 2538 + { PseudoVSSRA_VV_M2_MASK, PseudoVSSRA_VV_M2, 0x3, false }, // 2539 + { PseudoVSSRA_VV_M4_MASK, PseudoVSSRA_VV_M4, 0x3, false }, // 2540 + { PseudoVSSRA_VV_M8_MASK, PseudoVSSRA_VV_M8, 0x3, false }, // 2541 + { PseudoVSSRA_VV_MF2_MASK, PseudoVSSRA_VV_MF2, 0x3, false }, // 2542 + { PseudoVSSRA_VV_MF4_MASK, PseudoVSSRA_VV_MF4, 0x3, false }, // 2543 + { PseudoVSSRA_VV_MF8_MASK, PseudoVSSRA_VV_MF8, 0x3, false }, // 2544 + { PseudoVSSRA_VX_M1_MASK, PseudoVSSRA_VX_M1, 0x3, false }, // 2545 + { PseudoVSSRA_VX_M2_MASK, PseudoVSSRA_VX_M2, 0x3, false }, // 2546 + { PseudoVSSRA_VX_M4_MASK, PseudoVSSRA_VX_M4, 0x3, false }, // 2547 + { PseudoVSSRA_VX_M8_MASK, PseudoVSSRA_VX_M8, 0x3, false }, // 2548 + { PseudoVSSRA_VX_MF2_MASK, PseudoVSSRA_VX_MF2, 0x3, false }, // 2549 + { PseudoVSSRA_VX_MF4_MASK, PseudoVSSRA_VX_MF4, 0x3, false }, // 2550 + { PseudoVSSRA_VX_MF8_MASK, PseudoVSSRA_VX_MF8, 0x3, false }, // 2551 + { PseudoVSSRL_VI_M1_MASK, PseudoVSSRL_VI_M1, 0x3, false }, // 2552 + { PseudoVSSRL_VI_M2_MASK, PseudoVSSRL_VI_M2, 0x3, false }, // 2553 + { PseudoVSSRL_VI_M4_MASK, PseudoVSSRL_VI_M4, 0x3, false }, // 2554 + { PseudoVSSRL_VI_M8_MASK, PseudoVSSRL_VI_M8, 0x3, false }, // 2555 + { PseudoVSSRL_VI_MF2_MASK, PseudoVSSRL_VI_MF2, 0x3, false }, // 2556 + { PseudoVSSRL_VI_MF4_MASK, PseudoVSSRL_VI_MF4, 0x3, false }, // 2557 + { PseudoVSSRL_VI_MF8_MASK, PseudoVSSRL_VI_MF8, 0x3, false }, // 2558 + { PseudoVSSRL_VV_M1_MASK, PseudoVSSRL_VV_M1, 0x3, false }, // 2559 + { PseudoVSSRL_VV_M2_MASK, PseudoVSSRL_VV_M2, 0x3, false }, // 2560 + { PseudoVSSRL_VV_M4_MASK, PseudoVSSRL_VV_M4, 0x3, false }, // 2561 + { PseudoVSSRL_VV_M8_MASK, PseudoVSSRL_VV_M8, 0x3, false }, // 2562 + { PseudoVSSRL_VV_MF2_MASK, PseudoVSSRL_VV_MF2, 0x3, false }, // 2563 + { PseudoVSSRL_VV_MF4_MASK, PseudoVSSRL_VV_MF4, 0x3, false }, // 2564 + { PseudoVSSRL_VV_MF8_MASK, PseudoVSSRL_VV_MF8, 0x3, false }, // 2565 + { PseudoVSSRL_VX_M1_MASK, PseudoVSSRL_VX_M1, 0x3, false }, // 2566 + { PseudoVSSRL_VX_M2_MASK, PseudoVSSRL_VX_M2, 0x3, false }, // 2567 + { PseudoVSSRL_VX_M4_MASK, PseudoVSSRL_VX_M4, 0x3, false }, // 2568 + { PseudoVSSRL_VX_M8_MASK, PseudoVSSRL_VX_M8, 0x3, false }, // 2569 + { PseudoVSSRL_VX_MF2_MASK, PseudoVSSRL_VX_MF2, 0x3, false }, // 2570 + { PseudoVSSRL_VX_MF4_MASK, PseudoVSSRL_VX_MF4, 0x3, false }, // 2571 + { PseudoVSSRL_VX_MF8_MASK, PseudoVSSRL_VX_MF8, 0x3, false }, // 2572 + { PseudoVSSUBU_VV_M1_MASK, PseudoVSSUBU_VV_M1, 0x3, false }, // 2573 + { PseudoVSSUBU_VV_M2_MASK, PseudoVSSUBU_VV_M2, 0x3, false }, // 2574 + { PseudoVSSUBU_VV_M4_MASK, PseudoVSSUBU_VV_M4, 0x3, false }, // 2575 + { PseudoVSSUBU_VV_M8_MASK, PseudoVSSUBU_VV_M8, 0x3, false }, // 2576 + { PseudoVSSUBU_VV_MF2_MASK, PseudoVSSUBU_VV_MF2, 0x3, false }, // 2577 + { PseudoVSSUBU_VV_MF4_MASK, PseudoVSSUBU_VV_MF4, 0x3, false }, // 2578 + { PseudoVSSUBU_VV_MF8_MASK, PseudoVSSUBU_VV_MF8, 0x3, false }, // 2579 + { PseudoVSSUBU_VX_M1_MASK, PseudoVSSUBU_VX_M1, 0x3, false }, // 2580 + { PseudoVSSUBU_VX_M2_MASK, PseudoVSSUBU_VX_M2, 0x3, false }, // 2581 + { PseudoVSSUBU_VX_M4_MASK, PseudoVSSUBU_VX_M4, 0x3, false }, // 2582 + { PseudoVSSUBU_VX_M8_MASK, PseudoVSSUBU_VX_M8, 0x3, false }, // 2583 + { PseudoVSSUBU_VX_MF2_MASK, PseudoVSSUBU_VX_MF2, 0x3, false }, // 2584 + { PseudoVSSUBU_VX_MF4_MASK, PseudoVSSUBU_VX_MF4, 0x3, false }, // 2585 + { PseudoVSSUBU_VX_MF8_MASK, PseudoVSSUBU_VX_MF8, 0x3, false }, // 2586 + { PseudoVSSUB_VV_M1_MASK, PseudoVSSUB_VV_M1, 0x3, false }, // 2587 + { PseudoVSSUB_VV_M2_MASK, PseudoVSSUB_VV_M2, 0x3, false }, // 2588 + { PseudoVSSUB_VV_M4_MASK, PseudoVSSUB_VV_M4, 0x3, false }, // 2589 + { PseudoVSSUB_VV_M8_MASK, PseudoVSSUB_VV_M8, 0x3, false }, // 2590 + { PseudoVSSUB_VV_MF2_MASK, PseudoVSSUB_VV_MF2, 0x3, false }, // 2591 + { PseudoVSSUB_VV_MF4_MASK, PseudoVSSUB_VV_MF4, 0x3, false }, // 2592 + { PseudoVSSUB_VV_MF8_MASK, PseudoVSSUB_VV_MF8, 0x3, false }, // 2593 + { PseudoVSSUB_VX_M1_MASK, PseudoVSSUB_VX_M1, 0x3, false }, // 2594 + { PseudoVSSUB_VX_M2_MASK, PseudoVSSUB_VX_M2, 0x3, false }, // 2595 + { PseudoVSSUB_VX_M4_MASK, PseudoVSSUB_VX_M4, 0x3, false }, // 2596 + { PseudoVSSUB_VX_M8_MASK, PseudoVSSUB_VX_M8, 0x3, false }, // 2597 + { PseudoVSSUB_VX_MF2_MASK, PseudoVSSUB_VX_MF2, 0x3, false }, // 2598 + { PseudoVSSUB_VX_MF4_MASK, PseudoVSSUB_VX_MF4, 0x3, false }, // 2599 + { PseudoVSSUB_VX_MF8_MASK, PseudoVSSUB_VX_MF8, 0x3, false }, // 2600 + { PseudoVSUB_VV_M1_MASK, PseudoVSUB_VV_M1, 0x3, false }, // 2601 + { PseudoVSUB_VV_M2_MASK, PseudoVSUB_VV_M2, 0x3, false }, // 2602 + { PseudoVSUB_VV_M4_MASK, PseudoVSUB_VV_M4, 0x3, false }, // 2603 + { PseudoVSUB_VV_M8_MASK, PseudoVSUB_VV_M8, 0x3, false }, // 2604 + { PseudoVSUB_VV_MF2_MASK, PseudoVSUB_VV_MF2, 0x3, false }, // 2605 + { PseudoVSUB_VV_MF4_MASK, PseudoVSUB_VV_MF4, 0x3, false }, // 2606 + { PseudoVSUB_VV_MF8_MASK, PseudoVSUB_VV_MF8, 0x3, false }, // 2607 + { PseudoVSUB_VX_M1_MASK, PseudoVSUB_VX_M1, 0x3, false }, // 2608 + { PseudoVSUB_VX_M2_MASK, PseudoVSUB_VX_M2, 0x3, false }, // 2609 + { PseudoVSUB_VX_M4_MASK, PseudoVSUB_VX_M4, 0x3, false }, // 2610 + { PseudoVSUB_VX_M8_MASK, PseudoVSUB_VX_M8, 0x3, false }, // 2611 + { PseudoVSUB_VX_MF2_MASK, PseudoVSUB_VX_MF2, 0x3, false }, // 2612 + { PseudoVSUB_VX_MF4_MASK, PseudoVSUB_VX_MF4, 0x3, false }, // 2613 + { PseudoVSUB_VX_MF8_MASK, PseudoVSUB_VX_MF8, 0x3, false }, // 2614 + { PseudoVWADDU_VV_M1_MASK, PseudoVWADDU_VV_M1, 0x3, false }, // 2615 + { PseudoVWADDU_VV_M2_MASK, PseudoVWADDU_VV_M2, 0x3, false }, // 2616 + { PseudoVWADDU_VV_M4_MASK, PseudoVWADDU_VV_M4, 0x3, false }, // 2617 + { PseudoVWADDU_VV_MF2_MASK, PseudoVWADDU_VV_MF2, 0x3, false }, // 2618 + { PseudoVWADDU_VV_MF4_MASK, PseudoVWADDU_VV_MF4, 0x3, false }, // 2619 + { PseudoVWADDU_VV_MF8_MASK, PseudoVWADDU_VV_MF8, 0x3, false }, // 2620 + { PseudoVWADDU_VX_M1_MASK, PseudoVWADDU_VX_M1, 0x3, false }, // 2621 + { PseudoVWADDU_VX_M2_MASK, PseudoVWADDU_VX_M2, 0x3, false }, // 2622 + { PseudoVWADDU_VX_M4_MASK, PseudoVWADDU_VX_M4, 0x3, false }, // 2623 + { PseudoVWADDU_VX_MF2_MASK, PseudoVWADDU_VX_MF2, 0x3, false }, // 2624 + { PseudoVWADDU_VX_MF4_MASK, PseudoVWADDU_VX_MF4, 0x3, false }, // 2625 + { PseudoVWADDU_VX_MF8_MASK, PseudoVWADDU_VX_MF8, 0x3, false }, // 2626 + { PseudoVWADDU_WV_M1_MASK, PseudoVWADDU_WV_M1, 0x3, false }, // 2627 + { PseudoVWADDU_WV_M2_MASK, PseudoVWADDU_WV_M2, 0x3, false }, // 2628 + { PseudoVWADDU_WV_M4_MASK, PseudoVWADDU_WV_M4, 0x3, false }, // 2629 + { PseudoVWADDU_WV_MF2_MASK, PseudoVWADDU_WV_MF2, 0x3, false }, // 2630 + { PseudoVWADDU_WV_MF4_MASK, PseudoVWADDU_WV_MF4, 0x3, false }, // 2631 + { PseudoVWADDU_WV_MF8_MASK, PseudoVWADDU_WV_MF8, 0x3, false }, // 2632 + { PseudoVWADDU_WX_M1_MASK, PseudoVWADDU_WX_M1, 0x3, false }, // 2633 + { PseudoVWADDU_WX_M2_MASK, PseudoVWADDU_WX_M2, 0x3, false }, // 2634 + { PseudoVWADDU_WX_M4_MASK, PseudoVWADDU_WX_M4, 0x3, false }, // 2635 + { PseudoVWADDU_WX_MF2_MASK, PseudoVWADDU_WX_MF2, 0x3, false }, // 2636 + { PseudoVWADDU_WX_MF4_MASK, PseudoVWADDU_WX_MF4, 0x3, false }, // 2637 + { PseudoVWADDU_WX_MF8_MASK, PseudoVWADDU_WX_MF8, 0x3, false }, // 2638 + { PseudoVWADD_VV_M1_MASK, PseudoVWADD_VV_M1, 0x3, false }, // 2639 + { PseudoVWADD_VV_M2_MASK, PseudoVWADD_VV_M2, 0x3, false }, // 2640 + { PseudoVWADD_VV_M4_MASK, PseudoVWADD_VV_M4, 0x3, false }, // 2641 + { PseudoVWADD_VV_MF2_MASK, PseudoVWADD_VV_MF2, 0x3, false }, // 2642 + { PseudoVWADD_VV_MF4_MASK, PseudoVWADD_VV_MF4, 0x3, false }, // 2643 + { PseudoVWADD_VV_MF8_MASK, PseudoVWADD_VV_MF8, 0x3, false }, // 2644 + { PseudoVWADD_VX_M1_MASK, PseudoVWADD_VX_M1, 0x3, false }, // 2645 + { PseudoVWADD_VX_M2_MASK, PseudoVWADD_VX_M2, 0x3, false }, // 2646 + { PseudoVWADD_VX_M4_MASK, PseudoVWADD_VX_M4, 0x3, false }, // 2647 + { PseudoVWADD_VX_MF2_MASK, PseudoVWADD_VX_MF2, 0x3, false }, // 2648 + { PseudoVWADD_VX_MF4_MASK, PseudoVWADD_VX_MF4, 0x3, false }, // 2649 + { PseudoVWADD_VX_MF8_MASK, PseudoVWADD_VX_MF8, 0x3, false }, // 2650 + { PseudoVWADD_WV_M1_MASK, PseudoVWADD_WV_M1, 0x3, false }, // 2651 + { PseudoVWADD_WV_M2_MASK, PseudoVWADD_WV_M2, 0x3, false }, // 2652 + { PseudoVWADD_WV_M4_MASK, PseudoVWADD_WV_M4, 0x3, false }, // 2653 + { PseudoVWADD_WV_MF2_MASK, PseudoVWADD_WV_MF2, 0x3, false }, // 2654 + { PseudoVWADD_WV_MF4_MASK, PseudoVWADD_WV_MF4, 0x3, false }, // 2655 + { PseudoVWADD_WV_MF8_MASK, PseudoVWADD_WV_MF8, 0x3, false }, // 2656 + { PseudoVWADD_WX_M1_MASK, PseudoVWADD_WX_M1, 0x3, false }, // 2657 + { PseudoVWADD_WX_M2_MASK, PseudoVWADD_WX_M2, 0x3, false }, // 2658 + { PseudoVWADD_WX_M4_MASK, PseudoVWADD_WX_M4, 0x3, false }, // 2659 + { PseudoVWADD_WX_MF2_MASK, PseudoVWADD_WX_MF2, 0x3, false }, // 2660 + { PseudoVWADD_WX_MF4_MASK, PseudoVWADD_WX_MF4, 0x3, false }, // 2661 + { PseudoVWADD_WX_MF8_MASK, PseudoVWADD_WX_MF8, 0x3, false }, // 2662 + { PseudoVWMACCSU_VV_M1_MASK, PseudoVWMACCSU_VV_M1, 0x3, false }, // 2663 + { PseudoVWMACCSU_VV_M2_MASK, PseudoVWMACCSU_VV_M2, 0x3, false }, // 2664 + { PseudoVWMACCSU_VV_M4_MASK, PseudoVWMACCSU_VV_M4, 0x3, false }, // 2665 + { PseudoVWMACCSU_VV_MF2_MASK, PseudoVWMACCSU_VV_MF2, 0x3, false }, // 2666 + { PseudoVWMACCSU_VV_MF4_MASK, PseudoVWMACCSU_VV_MF4, 0x3, false }, // 2667 + { PseudoVWMACCSU_VV_MF8_MASK, PseudoVWMACCSU_VV_MF8, 0x3, false }, // 2668 + { PseudoVWMACCSU_VX_M1_MASK, PseudoVWMACCSU_VX_M1, 0x3, false }, // 2669 + { PseudoVWMACCSU_VX_M2_MASK, PseudoVWMACCSU_VX_M2, 0x3, false }, // 2670 + { PseudoVWMACCSU_VX_M4_MASK, PseudoVWMACCSU_VX_M4, 0x3, false }, // 2671 + { PseudoVWMACCSU_VX_MF2_MASK, PseudoVWMACCSU_VX_MF2, 0x3, false }, // 2672 + { PseudoVWMACCSU_VX_MF4_MASK, PseudoVWMACCSU_VX_MF4, 0x3, false }, // 2673 + { PseudoVWMACCSU_VX_MF8_MASK, PseudoVWMACCSU_VX_MF8, 0x3, false }, // 2674 + { PseudoVWMACCUS_VX_M1_MASK, PseudoVWMACCUS_VX_M1, 0x3, false }, // 2675 + { PseudoVWMACCUS_VX_M2_MASK, PseudoVWMACCUS_VX_M2, 0x3, false }, // 2676 + { PseudoVWMACCUS_VX_M4_MASK, PseudoVWMACCUS_VX_M4, 0x3, false }, // 2677 + { PseudoVWMACCUS_VX_MF2_MASK, PseudoVWMACCUS_VX_MF2, 0x3, false }, // 2678 + { PseudoVWMACCUS_VX_MF4_MASK, PseudoVWMACCUS_VX_MF4, 0x3, false }, // 2679 + { PseudoVWMACCUS_VX_MF8_MASK, PseudoVWMACCUS_VX_MF8, 0x3, false }, // 2680 + { PseudoVWMACCU_VV_M1_MASK, PseudoVWMACCU_VV_M1, 0x3, false }, // 2681 + { PseudoVWMACCU_VV_M2_MASK, PseudoVWMACCU_VV_M2, 0x3, false }, // 2682 + { PseudoVWMACCU_VV_M4_MASK, PseudoVWMACCU_VV_M4, 0x3, false }, // 2683 + { PseudoVWMACCU_VV_MF2_MASK, PseudoVWMACCU_VV_MF2, 0x3, false }, // 2684 + { PseudoVWMACCU_VV_MF4_MASK, PseudoVWMACCU_VV_MF4, 0x3, false }, // 2685 + { PseudoVWMACCU_VV_MF8_MASK, PseudoVWMACCU_VV_MF8, 0x3, false }, // 2686 + { PseudoVWMACCU_VX_M1_MASK, PseudoVWMACCU_VX_M1, 0x3, false }, // 2687 + { PseudoVWMACCU_VX_M2_MASK, PseudoVWMACCU_VX_M2, 0x3, false }, // 2688 + { PseudoVWMACCU_VX_M4_MASK, PseudoVWMACCU_VX_M4, 0x3, false }, // 2689 + { PseudoVWMACCU_VX_MF2_MASK, PseudoVWMACCU_VX_MF2, 0x3, false }, // 2690 + { PseudoVWMACCU_VX_MF4_MASK, PseudoVWMACCU_VX_MF4, 0x3, false }, // 2691 + { PseudoVWMACCU_VX_MF8_MASK, PseudoVWMACCU_VX_MF8, 0x3, false }, // 2692 + { PseudoVWMACC_VV_M1_MASK, PseudoVWMACC_VV_M1, 0x3, false }, // 2693 + { PseudoVWMACC_VV_M2_MASK, PseudoVWMACC_VV_M2, 0x3, false }, // 2694 + { PseudoVWMACC_VV_M4_MASK, PseudoVWMACC_VV_M4, 0x3, false }, // 2695 + { PseudoVWMACC_VV_MF2_MASK, PseudoVWMACC_VV_MF2, 0x3, false }, // 2696 + { PseudoVWMACC_VV_MF4_MASK, PseudoVWMACC_VV_MF4, 0x3, false }, // 2697 + { PseudoVWMACC_VV_MF8_MASK, PseudoVWMACC_VV_MF8, 0x3, false }, // 2698 + { PseudoVWMACC_VX_M1_MASK, PseudoVWMACC_VX_M1, 0x3, false }, // 2699 + { PseudoVWMACC_VX_M2_MASK, PseudoVWMACC_VX_M2, 0x3, false }, // 2700 + { PseudoVWMACC_VX_M4_MASK, PseudoVWMACC_VX_M4, 0x3, false }, // 2701 + { PseudoVWMACC_VX_MF2_MASK, PseudoVWMACC_VX_MF2, 0x3, false }, // 2702 + { PseudoVWMACC_VX_MF4_MASK, PseudoVWMACC_VX_MF4, 0x3, false }, // 2703 + { PseudoVWMACC_VX_MF8_MASK, PseudoVWMACC_VX_MF8, 0x3, false }, // 2704 + { PseudoVWMULSU_VV_M1_MASK, PseudoVWMULSU_VV_M1, 0x3, false }, // 2705 + { PseudoVWMULSU_VV_M2_MASK, PseudoVWMULSU_VV_M2, 0x3, false }, // 2706 + { PseudoVWMULSU_VV_M4_MASK, PseudoVWMULSU_VV_M4, 0x3, false }, // 2707 + { PseudoVWMULSU_VV_MF2_MASK, PseudoVWMULSU_VV_MF2, 0x3, false }, // 2708 + { PseudoVWMULSU_VV_MF4_MASK, PseudoVWMULSU_VV_MF4, 0x3, false }, // 2709 + { PseudoVWMULSU_VV_MF8_MASK, PseudoVWMULSU_VV_MF8, 0x3, false }, // 2710 + { PseudoVWMULSU_VX_M1_MASK, PseudoVWMULSU_VX_M1, 0x3, false }, // 2711 + { PseudoVWMULSU_VX_M2_MASK, PseudoVWMULSU_VX_M2, 0x3, false }, // 2712 + { PseudoVWMULSU_VX_M4_MASK, PseudoVWMULSU_VX_M4, 0x3, false }, // 2713 + { PseudoVWMULSU_VX_MF2_MASK, PseudoVWMULSU_VX_MF2, 0x3, false }, // 2714 + { PseudoVWMULSU_VX_MF4_MASK, PseudoVWMULSU_VX_MF4, 0x3, false }, // 2715 + { PseudoVWMULSU_VX_MF8_MASK, PseudoVWMULSU_VX_MF8, 0x3, false }, // 2716 + { PseudoVWMULU_VV_M1_MASK, PseudoVWMULU_VV_M1, 0x3, false }, // 2717 + { PseudoVWMULU_VV_M2_MASK, PseudoVWMULU_VV_M2, 0x3, false }, // 2718 + { PseudoVWMULU_VV_M4_MASK, PseudoVWMULU_VV_M4, 0x3, false }, // 2719 + { PseudoVWMULU_VV_MF2_MASK, PseudoVWMULU_VV_MF2, 0x3, false }, // 2720 + { PseudoVWMULU_VV_MF4_MASK, PseudoVWMULU_VV_MF4, 0x3, false }, // 2721 + { PseudoVWMULU_VV_MF8_MASK, PseudoVWMULU_VV_MF8, 0x3, false }, // 2722 + { PseudoVWMULU_VX_M1_MASK, PseudoVWMULU_VX_M1, 0x3, false }, // 2723 + { PseudoVWMULU_VX_M2_MASK, PseudoVWMULU_VX_M2, 0x3, false }, // 2724 + { PseudoVWMULU_VX_M4_MASK, PseudoVWMULU_VX_M4, 0x3, false }, // 2725 + { PseudoVWMULU_VX_MF2_MASK, PseudoVWMULU_VX_MF2, 0x3, false }, // 2726 + { PseudoVWMULU_VX_MF4_MASK, PseudoVWMULU_VX_MF4, 0x3, false }, // 2727 + { PseudoVWMULU_VX_MF8_MASK, PseudoVWMULU_VX_MF8, 0x3, false }, // 2728 + { PseudoVWMUL_VV_M1_MASK, PseudoVWMUL_VV_M1, 0x3, false }, // 2729 + { PseudoVWMUL_VV_M2_MASK, PseudoVWMUL_VV_M2, 0x3, false }, // 2730 + { PseudoVWMUL_VV_M4_MASK, PseudoVWMUL_VV_M4, 0x3, false }, // 2731 + { PseudoVWMUL_VV_MF2_MASK, PseudoVWMUL_VV_MF2, 0x3, false }, // 2732 + { PseudoVWMUL_VV_MF4_MASK, PseudoVWMUL_VV_MF4, 0x3, false }, // 2733 + { PseudoVWMUL_VV_MF8_MASK, PseudoVWMUL_VV_MF8, 0x3, false }, // 2734 + { PseudoVWMUL_VX_M1_MASK, PseudoVWMUL_VX_M1, 0x3, false }, // 2735 + { PseudoVWMUL_VX_M2_MASK, PseudoVWMUL_VX_M2, 0x3, false }, // 2736 + { PseudoVWMUL_VX_M4_MASK, PseudoVWMUL_VX_M4, 0x3, false }, // 2737 + { PseudoVWMUL_VX_MF2_MASK, PseudoVWMUL_VX_MF2, 0x3, false }, // 2738 + { PseudoVWMUL_VX_MF4_MASK, PseudoVWMUL_VX_MF4, 0x3, false }, // 2739 + { PseudoVWMUL_VX_MF8_MASK, PseudoVWMUL_VX_MF8, 0x3, false }, // 2740 + { PseudoVWREDSUMU_VS_M1_E16_MASK, PseudoVWREDSUMU_VS_M1_E16, 0x3, true }, // 2741 + { PseudoVWREDSUMU_VS_M1_E32_MASK, PseudoVWREDSUMU_VS_M1_E32, 0x3, true }, // 2742 + { PseudoVWREDSUMU_VS_M1_E8_MASK, PseudoVWREDSUMU_VS_M1_E8, 0x3, true }, // 2743 + { PseudoVWREDSUMU_VS_M2_E16_MASK, PseudoVWREDSUMU_VS_M2_E16, 0x3, true }, // 2744 + { PseudoVWREDSUMU_VS_M2_E32_MASK, PseudoVWREDSUMU_VS_M2_E32, 0x3, true }, // 2745 + { PseudoVWREDSUMU_VS_M2_E8_MASK, PseudoVWREDSUMU_VS_M2_E8, 0x3, true }, // 2746 + { PseudoVWREDSUMU_VS_M4_E16_MASK, PseudoVWREDSUMU_VS_M4_E16, 0x3, true }, // 2747 + { PseudoVWREDSUMU_VS_M4_E32_MASK, PseudoVWREDSUMU_VS_M4_E32, 0x3, true }, // 2748 + { PseudoVWREDSUMU_VS_M4_E8_MASK, PseudoVWREDSUMU_VS_M4_E8, 0x3, true }, // 2749 + { PseudoVWREDSUMU_VS_M8_E16_MASK, PseudoVWREDSUMU_VS_M8_E16, 0x3, true }, // 2750 + { PseudoVWREDSUMU_VS_M8_E32_MASK, PseudoVWREDSUMU_VS_M8_E32, 0x3, true }, // 2751 + { PseudoVWREDSUMU_VS_M8_E8_MASK, PseudoVWREDSUMU_VS_M8_E8, 0x3, true }, // 2752 + { PseudoVWREDSUMU_VS_MF2_E16_MASK, PseudoVWREDSUMU_VS_MF2_E16, 0x3, true }, // 2753 + { PseudoVWREDSUMU_VS_MF2_E32_MASK, PseudoVWREDSUMU_VS_MF2_E32, 0x3, true }, // 2754 + { PseudoVWREDSUMU_VS_MF2_E8_MASK, PseudoVWREDSUMU_VS_MF2_E8, 0x3, true }, // 2755 + { PseudoVWREDSUMU_VS_MF4_E16_MASK, PseudoVWREDSUMU_VS_MF4_E16, 0x3, true }, // 2756 + { PseudoVWREDSUMU_VS_MF4_E8_MASK, PseudoVWREDSUMU_VS_MF4_E8, 0x3, true }, // 2757 + { PseudoVWREDSUMU_VS_MF8_E8_MASK, PseudoVWREDSUMU_VS_MF8_E8, 0x3, true }, // 2758 + { PseudoVWREDSUM_VS_M1_E16_MASK, PseudoVWREDSUM_VS_M1_E16, 0x3, true }, // 2759 + { PseudoVWREDSUM_VS_M1_E32_MASK, PseudoVWREDSUM_VS_M1_E32, 0x3, true }, // 2760 + { PseudoVWREDSUM_VS_M1_E8_MASK, PseudoVWREDSUM_VS_M1_E8, 0x3, true }, // 2761 + { PseudoVWREDSUM_VS_M2_E16_MASK, PseudoVWREDSUM_VS_M2_E16, 0x3, true }, // 2762 + { PseudoVWREDSUM_VS_M2_E32_MASK, PseudoVWREDSUM_VS_M2_E32, 0x3, true }, // 2763 + { PseudoVWREDSUM_VS_M2_E8_MASK, PseudoVWREDSUM_VS_M2_E8, 0x3, true }, // 2764 + { PseudoVWREDSUM_VS_M4_E16_MASK, PseudoVWREDSUM_VS_M4_E16, 0x3, true }, // 2765 + { PseudoVWREDSUM_VS_M4_E32_MASK, PseudoVWREDSUM_VS_M4_E32, 0x3, true }, // 2766 + { PseudoVWREDSUM_VS_M4_E8_MASK, PseudoVWREDSUM_VS_M4_E8, 0x3, true }, // 2767 + { PseudoVWREDSUM_VS_M8_E16_MASK, PseudoVWREDSUM_VS_M8_E16, 0x3, true }, // 2768 + { PseudoVWREDSUM_VS_M8_E32_MASK, PseudoVWREDSUM_VS_M8_E32, 0x3, true }, // 2769 + { PseudoVWREDSUM_VS_M8_E8_MASK, PseudoVWREDSUM_VS_M8_E8, 0x3, true }, // 2770 + { PseudoVWREDSUM_VS_MF2_E16_MASK, PseudoVWREDSUM_VS_MF2_E16, 0x3, true }, // 2771 + { PseudoVWREDSUM_VS_MF2_E32_MASK, PseudoVWREDSUM_VS_MF2_E32, 0x3, true }, // 2772 + { PseudoVWREDSUM_VS_MF2_E8_MASK, PseudoVWREDSUM_VS_MF2_E8, 0x3, true }, // 2773 + { PseudoVWREDSUM_VS_MF4_E16_MASK, PseudoVWREDSUM_VS_MF4_E16, 0x3, true }, // 2774 + { PseudoVWREDSUM_VS_MF4_E8_MASK, PseudoVWREDSUM_VS_MF4_E8, 0x3, true }, // 2775 + { PseudoVWREDSUM_VS_MF8_E8_MASK, PseudoVWREDSUM_VS_MF8_E8, 0x3, true }, // 2776 + { PseudoVWSLL_VI_M1_MASK, PseudoVWSLL_VI_M1, 0x3, false }, // 2777 + { PseudoVWSLL_VI_M2_MASK, PseudoVWSLL_VI_M2, 0x3, false }, // 2778 + { PseudoVWSLL_VI_M4_MASK, PseudoVWSLL_VI_M4, 0x3, false }, // 2779 + { PseudoVWSLL_VI_MF2_MASK, PseudoVWSLL_VI_MF2, 0x3, false }, // 2780 + { PseudoVWSLL_VI_MF4_MASK, PseudoVWSLL_VI_MF4, 0x3, false }, // 2781 + { PseudoVWSLL_VI_MF8_MASK, PseudoVWSLL_VI_MF8, 0x3, false }, // 2782 + { PseudoVWSLL_VV_M1_MASK, PseudoVWSLL_VV_M1, 0x3, false }, // 2783 + { PseudoVWSLL_VV_M2_MASK, PseudoVWSLL_VV_M2, 0x3, false }, // 2784 + { PseudoVWSLL_VV_M4_MASK, PseudoVWSLL_VV_M4, 0x3, false }, // 2785 + { PseudoVWSLL_VV_MF2_MASK, PseudoVWSLL_VV_MF2, 0x3, false }, // 2786 + { PseudoVWSLL_VV_MF4_MASK, PseudoVWSLL_VV_MF4, 0x3, false }, // 2787 + { PseudoVWSLL_VV_MF8_MASK, PseudoVWSLL_VV_MF8, 0x3, false }, // 2788 + { PseudoVWSLL_VX_M1_MASK, PseudoVWSLL_VX_M1, 0x3, false }, // 2789 + { PseudoVWSLL_VX_M2_MASK, PseudoVWSLL_VX_M2, 0x3, false }, // 2790 + { PseudoVWSLL_VX_M4_MASK, PseudoVWSLL_VX_M4, 0x3, false }, // 2791 + { PseudoVWSLL_VX_MF2_MASK, PseudoVWSLL_VX_MF2, 0x3, false }, // 2792 + { PseudoVWSLL_VX_MF4_MASK, PseudoVWSLL_VX_MF4, 0x3, false }, // 2793 + { PseudoVWSLL_VX_MF8_MASK, PseudoVWSLL_VX_MF8, 0x3, false }, // 2794 + { PseudoVWSUBU_VV_M1_MASK, PseudoVWSUBU_VV_M1, 0x3, false }, // 2795 + { PseudoVWSUBU_VV_M2_MASK, PseudoVWSUBU_VV_M2, 0x3, false }, // 2796 + { PseudoVWSUBU_VV_M4_MASK, PseudoVWSUBU_VV_M4, 0x3, false }, // 2797 + { PseudoVWSUBU_VV_MF2_MASK, PseudoVWSUBU_VV_MF2, 0x3, false }, // 2798 + { PseudoVWSUBU_VV_MF4_MASK, PseudoVWSUBU_VV_MF4, 0x3, false }, // 2799 + { PseudoVWSUBU_VV_MF8_MASK, PseudoVWSUBU_VV_MF8, 0x3, false }, // 2800 + { PseudoVWSUBU_VX_M1_MASK, PseudoVWSUBU_VX_M1, 0x3, false }, // 2801 + { PseudoVWSUBU_VX_M2_MASK, PseudoVWSUBU_VX_M2, 0x3, false }, // 2802 + { PseudoVWSUBU_VX_M4_MASK, PseudoVWSUBU_VX_M4, 0x3, false }, // 2803 + { PseudoVWSUBU_VX_MF2_MASK, PseudoVWSUBU_VX_MF2, 0x3, false }, // 2804 + { PseudoVWSUBU_VX_MF4_MASK, PseudoVWSUBU_VX_MF4, 0x3, false }, // 2805 + { PseudoVWSUBU_VX_MF8_MASK, PseudoVWSUBU_VX_MF8, 0x3, false }, // 2806 + { PseudoVWSUBU_WV_M1_MASK, PseudoVWSUBU_WV_M1, 0x3, false }, // 2807 + { PseudoVWSUBU_WV_M2_MASK, PseudoVWSUBU_WV_M2, 0x3, false }, // 2808 + { PseudoVWSUBU_WV_M4_MASK, PseudoVWSUBU_WV_M4, 0x3, false }, // 2809 + { PseudoVWSUBU_WV_MF2_MASK, PseudoVWSUBU_WV_MF2, 0x3, false }, // 2810 + { PseudoVWSUBU_WV_MF4_MASK, PseudoVWSUBU_WV_MF4, 0x3, false }, // 2811 + { PseudoVWSUBU_WV_MF8_MASK, PseudoVWSUBU_WV_MF8, 0x3, false }, // 2812 + { PseudoVWSUBU_WX_M1_MASK, PseudoVWSUBU_WX_M1, 0x3, false }, // 2813 + { PseudoVWSUBU_WX_M2_MASK, PseudoVWSUBU_WX_M2, 0x3, false }, // 2814 + { PseudoVWSUBU_WX_M4_MASK, PseudoVWSUBU_WX_M4, 0x3, false }, // 2815 + { PseudoVWSUBU_WX_MF2_MASK, PseudoVWSUBU_WX_MF2, 0x3, false }, // 2816 + { PseudoVWSUBU_WX_MF4_MASK, PseudoVWSUBU_WX_MF4, 0x3, false }, // 2817 + { PseudoVWSUBU_WX_MF8_MASK, PseudoVWSUBU_WX_MF8, 0x3, false }, // 2818 + { PseudoVWSUB_VV_M1_MASK, PseudoVWSUB_VV_M1, 0x3, false }, // 2819 + { PseudoVWSUB_VV_M2_MASK, PseudoVWSUB_VV_M2, 0x3, false }, // 2820 + { PseudoVWSUB_VV_M4_MASK, PseudoVWSUB_VV_M4, 0x3, false }, // 2821 + { PseudoVWSUB_VV_MF2_MASK, PseudoVWSUB_VV_MF2, 0x3, false }, // 2822 + { PseudoVWSUB_VV_MF4_MASK, PseudoVWSUB_VV_MF4, 0x3, false }, // 2823 + { PseudoVWSUB_VV_MF8_MASK, PseudoVWSUB_VV_MF8, 0x3, false }, // 2824 + { PseudoVWSUB_VX_M1_MASK, PseudoVWSUB_VX_M1, 0x3, false }, // 2825 + { PseudoVWSUB_VX_M2_MASK, PseudoVWSUB_VX_M2, 0x3, false }, // 2826 + { PseudoVWSUB_VX_M4_MASK, PseudoVWSUB_VX_M4, 0x3, false }, // 2827 + { PseudoVWSUB_VX_MF2_MASK, PseudoVWSUB_VX_MF2, 0x3, false }, // 2828 + { PseudoVWSUB_VX_MF4_MASK, PseudoVWSUB_VX_MF4, 0x3, false }, // 2829 + { PseudoVWSUB_VX_MF8_MASK, PseudoVWSUB_VX_MF8, 0x3, false }, // 2830 + { PseudoVWSUB_WV_M1_MASK, PseudoVWSUB_WV_M1, 0x3, false }, // 2831 + { PseudoVWSUB_WV_M2_MASK, PseudoVWSUB_WV_M2, 0x3, false }, // 2832 + { PseudoVWSUB_WV_M4_MASK, PseudoVWSUB_WV_M4, 0x3, false }, // 2833 + { PseudoVWSUB_WV_MF2_MASK, PseudoVWSUB_WV_MF2, 0x3, false }, // 2834 + { PseudoVWSUB_WV_MF4_MASK, PseudoVWSUB_WV_MF4, 0x3, false }, // 2835 + { PseudoVWSUB_WV_MF8_MASK, PseudoVWSUB_WV_MF8, 0x3, false }, // 2836 + { PseudoVWSUB_WX_M1_MASK, PseudoVWSUB_WX_M1, 0x3, false }, // 2837 + { PseudoVWSUB_WX_M2_MASK, PseudoVWSUB_WX_M2, 0x3, false }, // 2838 + { PseudoVWSUB_WX_M4_MASK, PseudoVWSUB_WX_M4, 0x3, false }, // 2839 + { PseudoVWSUB_WX_MF2_MASK, PseudoVWSUB_WX_MF2, 0x3, false }, // 2840 + { PseudoVWSUB_WX_MF4_MASK, PseudoVWSUB_WX_MF4, 0x3, false }, // 2841 + { PseudoVWSUB_WX_MF8_MASK, PseudoVWSUB_WX_MF8, 0x3, false }, // 2842 + { PseudoVXOR_VI_M1_MASK, PseudoVXOR_VI_M1, 0x3, false }, // 2843 + { PseudoVXOR_VI_M2_MASK, PseudoVXOR_VI_M2, 0x3, false }, // 2844 + { PseudoVXOR_VI_M4_MASK, PseudoVXOR_VI_M4, 0x3, false }, // 2845 + { PseudoVXOR_VI_M8_MASK, PseudoVXOR_VI_M8, 0x3, false }, // 2846 + { PseudoVXOR_VI_MF2_MASK, PseudoVXOR_VI_MF2, 0x3, false }, // 2847 + { PseudoVXOR_VI_MF4_MASK, PseudoVXOR_VI_MF4, 0x3, false }, // 2848 + { PseudoVXOR_VI_MF8_MASK, PseudoVXOR_VI_MF8, 0x3, false }, // 2849 + { PseudoVXOR_VV_M1_MASK, PseudoVXOR_VV_M1, 0x3, false }, // 2850 + { PseudoVXOR_VV_M2_MASK, PseudoVXOR_VV_M2, 0x3, false }, // 2851 + { PseudoVXOR_VV_M4_MASK, PseudoVXOR_VV_M4, 0x3, false }, // 2852 + { PseudoVXOR_VV_M8_MASK, PseudoVXOR_VV_M8, 0x3, false }, // 2853 + { PseudoVXOR_VV_MF2_MASK, PseudoVXOR_VV_MF2, 0x3, false }, // 2854 + { PseudoVXOR_VV_MF4_MASK, PseudoVXOR_VV_MF4, 0x3, false }, // 2855 + { PseudoVXOR_VV_MF8_MASK, PseudoVXOR_VV_MF8, 0x3, false }, // 2856 + { PseudoVXOR_VX_M1_MASK, PseudoVXOR_VX_M1, 0x3, false }, // 2857 + { PseudoVXOR_VX_M2_MASK, PseudoVXOR_VX_M2, 0x3, false }, // 2858 + { PseudoVXOR_VX_M4_MASK, PseudoVXOR_VX_M4, 0x3, false }, // 2859 + { PseudoVXOR_VX_M8_MASK, PseudoVXOR_VX_M8, 0x3, false }, // 2860 + { PseudoVXOR_VX_MF2_MASK, PseudoVXOR_VX_MF2, 0x3, false }, // 2861 + { PseudoVXOR_VX_MF4_MASK, PseudoVXOR_VX_MF4, 0x3, false }, // 2862 + { PseudoVXOR_VX_MF8_MASK, PseudoVXOR_VX_MF8, 0x3, false }, // 2863 + { PseudoVZEXT_VF2_M1_MASK, PseudoVZEXT_VF2_M1, 0x2, false }, // 2864 + { PseudoVZEXT_VF2_M2_MASK, PseudoVZEXT_VF2_M2, 0x2, false }, // 2865 + { PseudoVZEXT_VF2_M4_MASK, PseudoVZEXT_VF2_M4, 0x2, false }, // 2866 + { PseudoVZEXT_VF2_M8_MASK, PseudoVZEXT_VF2_M8, 0x2, false }, // 2867 + { PseudoVZEXT_VF2_MF2_MASK, PseudoVZEXT_VF2_MF2, 0x2, false }, // 2868 + { PseudoVZEXT_VF2_MF4_MASK, PseudoVZEXT_VF2_MF4, 0x2, false }, // 2869 + { PseudoVZEXT_VF4_M1_MASK, PseudoVZEXT_VF4_M1, 0x2, false }, // 2870 + { PseudoVZEXT_VF4_M2_MASK, PseudoVZEXT_VF4_M2, 0x2, false }, // 2871 + { PseudoVZEXT_VF4_M4_MASK, PseudoVZEXT_VF4_M4, 0x2, false }, // 2872 + { PseudoVZEXT_VF4_M8_MASK, PseudoVZEXT_VF4_M8, 0x2, false }, // 2873 + { PseudoVZEXT_VF4_MF2_MASK, PseudoVZEXT_VF4_MF2, 0x2, false }, // 2874 + { PseudoVZEXT_VF8_M1_MASK, PseudoVZEXT_VF8_M1, 0x2, false }, // 2875 + { PseudoVZEXT_VF8_M2_MASK, PseudoVZEXT_VF8_M2, 0x2, false }, // 2876 + { PseudoVZEXT_VF8_M4_MASK, PseudoVZEXT_VF8_M4, 0x2, false }, // 2877 + { PseudoVZEXT_VF8_M8_MASK, PseudoVZEXT_VF8_M8, 0x2, false }, // 2878 + }; + +const RISCV_RISCVMaskedPseudoInfo *RISCV_getMaskedPseudoInfo(unsigned MaskedPseudo) { + unsigned i = binsearch_IndexTypeEncoding(Index, ARR_SIZE(Index), MaskedPseudo); + if (i == -1) + return NULL; + else + return &RISCVMaskedPseudosTable[Index[i].index]; +} + +const RISCV_RISCVMaskedPseudoInfo *RISCV_lookupMaskedIntrinsicByUnmasked(unsigned UnmaskedPseudo) { + static const struct IndexType Index[] = { + { PseudoTHVdotVMAQASU_VV_M1, 0 }, + { PseudoTHVdotVMAQASU_VV_M2, 1 }, + { PseudoTHVdotVMAQASU_VV_M4, 2 }, + { PseudoTHVdotVMAQASU_VV_M8, 3 }, + { PseudoTHVdotVMAQASU_VV_MF2, 4 }, + { PseudoTHVdotVMAQASU_VX_M1, 5 }, + { PseudoTHVdotVMAQASU_VX_M2, 6 }, + { PseudoTHVdotVMAQASU_VX_M4, 7 }, + { PseudoTHVdotVMAQASU_VX_M8, 8 }, + { PseudoTHVdotVMAQASU_VX_MF2, 9 }, + { PseudoTHVdotVMAQAUS_VX_M1, 10 }, + { PseudoTHVdotVMAQAUS_VX_M2, 11 }, + { PseudoTHVdotVMAQAUS_VX_M4, 12 }, + { PseudoTHVdotVMAQAUS_VX_M8, 13 }, + { PseudoTHVdotVMAQAUS_VX_MF2, 14 }, + { PseudoTHVdotVMAQAU_VV_M1, 15 }, + { PseudoTHVdotVMAQAU_VV_M2, 16 }, + { PseudoTHVdotVMAQAU_VV_M4, 17 }, + { PseudoTHVdotVMAQAU_VV_M8, 18 }, + { PseudoTHVdotVMAQAU_VV_MF2, 19 }, + { PseudoTHVdotVMAQAU_VX_M1, 20 }, + { PseudoTHVdotVMAQAU_VX_M2, 21 }, + { PseudoTHVdotVMAQAU_VX_M4, 22 }, + { PseudoTHVdotVMAQAU_VX_M8, 23 }, + { PseudoTHVdotVMAQAU_VX_MF2, 24 }, + { PseudoTHVdotVMAQA_VV_M1, 25 }, + { PseudoTHVdotVMAQA_VV_M2, 26 }, + { PseudoTHVdotVMAQA_VV_M4, 27 }, + { PseudoTHVdotVMAQA_VV_M8, 28 }, + { PseudoTHVdotVMAQA_VV_MF2, 29 }, + { PseudoTHVdotVMAQA_VX_M1, 30 }, + { PseudoTHVdotVMAQA_VX_M2, 31 }, + { PseudoTHVdotVMAQA_VX_M4, 32 }, + { PseudoTHVdotVMAQA_VX_M8, 33 }, + { PseudoTHVdotVMAQA_VX_MF2, 34 }, + { PseudoVAADDU_VV_M1, 35 }, + { PseudoVAADDU_VV_M2, 36 }, + { PseudoVAADDU_VV_M4, 37 }, + { PseudoVAADDU_VV_M8, 38 }, + { PseudoVAADDU_VV_MF2, 39 }, + { PseudoVAADDU_VV_MF4, 40 }, + { PseudoVAADDU_VV_MF8, 41 }, + { PseudoVAADDU_VX_M1, 42 }, + { PseudoVAADDU_VX_M2, 43 }, + { PseudoVAADDU_VX_M4, 44 }, + { PseudoVAADDU_VX_M8, 45 }, + { PseudoVAADDU_VX_MF2, 46 }, + { PseudoVAADDU_VX_MF4, 47 }, + { PseudoVAADDU_VX_MF8, 48 }, + { PseudoVAADD_VV_M1, 49 }, + { PseudoVAADD_VV_M2, 50 }, + { PseudoVAADD_VV_M4, 51 }, + { PseudoVAADD_VV_M8, 52 }, + { PseudoVAADD_VV_MF2, 53 }, + { PseudoVAADD_VV_MF4, 54 }, + { PseudoVAADD_VV_MF8, 55 }, + { PseudoVAADD_VX_M1, 56 }, + { PseudoVAADD_VX_M2, 57 }, + { PseudoVAADD_VX_M4, 58 }, + { PseudoVAADD_VX_M8, 59 }, + { PseudoVAADD_VX_MF2, 60 }, + { PseudoVAADD_VX_MF4, 61 }, + { PseudoVAADD_VX_MF8, 62 }, + { PseudoVADD_VI_M1, 63 }, + { PseudoVADD_VI_M2, 64 }, + { PseudoVADD_VI_M4, 65 }, + { PseudoVADD_VI_M8, 66 }, + { PseudoVADD_VI_MF2, 67 }, + { PseudoVADD_VI_MF4, 68 }, + { PseudoVADD_VI_MF8, 69 }, + { PseudoVADD_VV_M1, 70 }, + { PseudoVADD_VV_M2, 71 }, + { PseudoVADD_VV_M4, 72 }, + { PseudoVADD_VV_M8, 73 }, + { PseudoVADD_VV_MF2, 74 }, + { PseudoVADD_VV_MF4, 75 }, + { PseudoVADD_VV_MF8, 76 }, + { PseudoVADD_VX_M1, 77 }, + { PseudoVADD_VX_M2, 78 }, + { PseudoVADD_VX_M4, 79 }, + { PseudoVADD_VX_M8, 80 }, + { PseudoVADD_VX_MF2, 81 }, + { PseudoVADD_VX_MF4, 82 }, + { PseudoVADD_VX_MF8, 83 }, + { PseudoVANDN_VV_M1, 84 }, + { PseudoVANDN_VV_M2, 85 }, + { PseudoVANDN_VV_M4, 86 }, + { PseudoVANDN_VV_M8, 87 }, + { PseudoVANDN_VV_MF2, 88 }, + { PseudoVANDN_VV_MF4, 89 }, + { PseudoVANDN_VV_MF8, 90 }, + { PseudoVANDN_VX_M1, 91 }, + { PseudoVANDN_VX_M2, 92 }, + { PseudoVANDN_VX_M4, 93 }, + { PseudoVANDN_VX_M8, 94 }, + { PseudoVANDN_VX_MF2, 95 }, + { PseudoVANDN_VX_MF4, 96 }, + { PseudoVANDN_VX_MF8, 97 }, + { PseudoVAND_VI_M1, 98 }, + { PseudoVAND_VI_M2, 99 }, + { PseudoVAND_VI_M4, 100 }, + { PseudoVAND_VI_M8, 101 }, + { PseudoVAND_VI_MF2, 102 }, + { PseudoVAND_VI_MF4, 103 }, + { PseudoVAND_VI_MF8, 104 }, + { PseudoVAND_VV_M1, 105 }, + { PseudoVAND_VV_M2, 106 }, + { PseudoVAND_VV_M4, 107 }, + { PseudoVAND_VV_M8, 108 }, + { PseudoVAND_VV_MF2, 109 }, + { PseudoVAND_VV_MF4, 110 }, + { PseudoVAND_VV_MF8, 111 }, + { PseudoVAND_VX_M1, 112 }, + { PseudoVAND_VX_M2, 113 }, + { PseudoVAND_VX_M4, 114 }, + { PseudoVAND_VX_M8, 115 }, + { PseudoVAND_VX_MF2, 116 }, + { PseudoVAND_VX_MF4, 117 }, + { PseudoVAND_VX_MF8, 118 }, + { PseudoVASUBU_VV_M1, 119 }, + { PseudoVASUBU_VV_M2, 120 }, + { PseudoVASUBU_VV_M4, 121 }, + { PseudoVASUBU_VV_M8, 122 }, + { PseudoVASUBU_VV_MF2, 123 }, + { PseudoVASUBU_VV_MF4, 124 }, + { PseudoVASUBU_VV_MF8, 125 }, + { PseudoVASUBU_VX_M1, 126 }, + { PseudoVASUBU_VX_M2, 127 }, + { PseudoVASUBU_VX_M4, 128 }, + { PseudoVASUBU_VX_M8, 129 }, + { PseudoVASUBU_VX_MF2, 130 }, + { PseudoVASUBU_VX_MF4, 131 }, + { PseudoVASUBU_VX_MF8, 132 }, + { PseudoVASUB_VV_M1, 133 }, + { PseudoVASUB_VV_M2, 134 }, + { PseudoVASUB_VV_M4, 135 }, + { PseudoVASUB_VV_M8, 136 }, + { PseudoVASUB_VV_MF2, 137 }, + { PseudoVASUB_VV_MF4, 138 }, + { PseudoVASUB_VV_MF8, 139 }, + { PseudoVASUB_VX_M1, 140 }, + { PseudoVASUB_VX_M2, 141 }, + { PseudoVASUB_VX_M4, 142 }, + { PseudoVASUB_VX_M8, 143 }, + { PseudoVASUB_VX_MF2, 144 }, + { PseudoVASUB_VX_MF4, 145 }, + { PseudoVASUB_VX_MF8, 146 }, + { PseudoVBREV8_V_M1, 147 }, + { PseudoVBREV8_V_M2, 148 }, + { PseudoVBREV8_V_M4, 149 }, + { PseudoVBREV8_V_M8, 150 }, + { PseudoVBREV8_V_MF2, 151 }, + { PseudoVBREV8_V_MF4, 152 }, + { PseudoVBREV8_V_MF8, 153 }, + { PseudoVBREV_V_M1, 154 }, + { PseudoVBREV_V_M2, 155 }, + { PseudoVBREV_V_M4, 156 }, + { PseudoVBREV_V_M8, 157 }, + { PseudoVBREV_V_MF2, 158 }, + { PseudoVBREV_V_MF4, 159 }, + { PseudoVBREV_V_MF8, 160 }, + { PseudoVCLMULH_VV_M1, 161 }, + { PseudoVCLMULH_VV_M2, 162 }, + { PseudoVCLMULH_VV_M4, 163 }, + { PseudoVCLMULH_VV_M8, 164 }, + { PseudoVCLMULH_VV_MF2, 165 }, + { PseudoVCLMULH_VV_MF4, 166 }, + { PseudoVCLMULH_VV_MF8, 167 }, + { PseudoVCLMULH_VX_M1, 168 }, + { PseudoVCLMULH_VX_M2, 169 }, + { PseudoVCLMULH_VX_M4, 170 }, + { PseudoVCLMULH_VX_M8, 171 }, + { PseudoVCLMULH_VX_MF2, 172 }, + { PseudoVCLMULH_VX_MF4, 173 }, + { PseudoVCLMULH_VX_MF8, 174 }, + { PseudoVCLMUL_VV_M1, 175 }, + { PseudoVCLMUL_VV_M2, 176 }, + { PseudoVCLMUL_VV_M4, 177 }, + { PseudoVCLMUL_VV_M8, 178 }, + { PseudoVCLMUL_VV_MF2, 179 }, + { PseudoVCLMUL_VV_MF4, 180 }, + { PseudoVCLMUL_VV_MF8, 181 }, + { PseudoVCLMUL_VX_M1, 182 }, + { PseudoVCLMUL_VX_M2, 183 }, + { PseudoVCLMUL_VX_M4, 184 }, + { PseudoVCLMUL_VX_M8, 185 }, + { PseudoVCLMUL_VX_MF2, 186 }, + { PseudoVCLMUL_VX_MF4, 187 }, + { PseudoVCLMUL_VX_MF8, 188 }, + { PseudoVCLZ_V_M1, 189 }, + { PseudoVCLZ_V_M2, 190 }, + { PseudoVCLZ_V_M4, 191 }, + { PseudoVCLZ_V_M8, 192 }, + { PseudoVCLZ_V_MF2, 193 }, + { PseudoVCLZ_V_MF4, 194 }, + { PseudoVCLZ_V_MF8, 195 }, + { PseudoVCPOP_V_M1, 196 }, + { PseudoVCPOP_V_M2, 197 }, + { PseudoVCPOP_V_M4, 198 }, + { PseudoVCPOP_V_M8, 199 }, + { PseudoVCPOP_V_MF2, 200 }, + { PseudoVCPOP_V_MF4, 201 }, + { PseudoVCPOP_V_MF8, 202 }, + { PseudoVCTZ_V_M1, 203 }, + { PseudoVCTZ_V_M2, 204 }, + { PseudoVCTZ_V_M4, 205 }, + { PseudoVCTZ_V_M8, 206 }, + { PseudoVCTZ_V_MF2, 207 }, + { PseudoVCTZ_V_MF4, 208 }, + { PseudoVCTZ_V_MF8, 209 }, + { PseudoVDIVU_VV_M1_E16, 210 }, + { PseudoVDIVU_VV_M1_E32, 211 }, + { PseudoVDIVU_VV_M1_E64, 212 }, + { PseudoVDIVU_VV_M1_E8, 213 }, + { PseudoVDIVU_VV_M2_E16, 214 }, + { PseudoVDIVU_VV_M2_E32, 215 }, + { PseudoVDIVU_VV_M2_E64, 216 }, + { PseudoVDIVU_VV_M2_E8, 217 }, + { PseudoVDIVU_VV_M4_E16, 218 }, + { PseudoVDIVU_VV_M4_E32, 219 }, + { PseudoVDIVU_VV_M4_E64, 220 }, + { PseudoVDIVU_VV_M4_E8, 221 }, + { PseudoVDIVU_VV_M8_E16, 222 }, + { PseudoVDIVU_VV_M8_E32, 223 }, + { PseudoVDIVU_VV_M8_E64, 224 }, + { PseudoVDIVU_VV_M8_E8, 225 }, + { PseudoVDIVU_VV_MF2_E16, 226 }, + { PseudoVDIVU_VV_MF2_E32, 227 }, + { PseudoVDIVU_VV_MF2_E8, 228 }, + { PseudoVDIVU_VV_MF4_E16, 229 }, + { PseudoVDIVU_VV_MF4_E8, 230 }, + { PseudoVDIVU_VV_MF8_E8, 231 }, + { PseudoVDIVU_VX_M1_E16, 232 }, + { PseudoVDIVU_VX_M1_E32, 233 }, + { PseudoVDIVU_VX_M1_E64, 234 }, + { PseudoVDIVU_VX_M1_E8, 235 }, + { PseudoVDIVU_VX_M2_E16, 236 }, + { PseudoVDIVU_VX_M2_E32, 237 }, + { PseudoVDIVU_VX_M2_E64, 238 }, + { PseudoVDIVU_VX_M2_E8, 239 }, + { PseudoVDIVU_VX_M4_E16, 240 }, + { PseudoVDIVU_VX_M4_E32, 241 }, + { PseudoVDIVU_VX_M4_E64, 242 }, + { PseudoVDIVU_VX_M4_E8, 243 }, + { PseudoVDIVU_VX_M8_E16, 244 }, + { PseudoVDIVU_VX_M8_E32, 245 }, + { PseudoVDIVU_VX_M8_E64, 246 }, + { PseudoVDIVU_VX_M8_E8, 247 }, + { PseudoVDIVU_VX_MF2_E16, 248 }, + { PseudoVDIVU_VX_MF2_E32, 249 }, + { PseudoVDIVU_VX_MF2_E8, 250 }, + { PseudoVDIVU_VX_MF4_E16, 251 }, + { PseudoVDIVU_VX_MF4_E8, 252 }, + { PseudoVDIVU_VX_MF8_E8, 253 }, + { PseudoVDIV_VV_M1_E16, 254 }, + { PseudoVDIV_VV_M1_E32, 255 }, + { PseudoVDIV_VV_M1_E64, 256 }, + { PseudoVDIV_VV_M1_E8, 257 }, + { PseudoVDIV_VV_M2_E16, 258 }, + { PseudoVDIV_VV_M2_E32, 259 }, + { PseudoVDIV_VV_M2_E64, 260 }, + { PseudoVDIV_VV_M2_E8, 261 }, + { PseudoVDIV_VV_M4_E16, 262 }, + { PseudoVDIV_VV_M4_E32, 263 }, + { PseudoVDIV_VV_M4_E64, 264 }, + { PseudoVDIV_VV_M4_E8, 265 }, + { PseudoVDIV_VV_M8_E16, 266 }, + { PseudoVDIV_VV_M8_E32, 267 }, + { PseudoVDIV_VV_M8_E64, 268 }, + { PseudoVDIV_VV_M8_E8, 269 }, + { PseudoVDIV_VV_MF2_E16, 270 }, + { PseudoVDIV_VV_MF2_E32, 271 }, + { PseudoVDIV_VV_MF2_E8, 272 }, + { PseudoVDIV_VV_MF4_E16, 273 }, + { PseudoVDIV_VV_MF4_E8, 274 }, + { PseudoVDIV_VV_MF8_E8, 275 }, + { PseudoVDIV_VX_M1_E16, 276 }, + { PseudoVDIV_VX_M1_E32, 277 }, + { PseudoVDIV_VX_M1_E64, 278 }, + { PseudoVDIV_VX_M1_E8, 279 }, + { PseudoVDIV_VX_M2_E16, 280 }, + { PseudoVDIV_VX_M2_E32, 281 }, + { PseudoVDIV_VX_M2_E64, 282 }, + { PseudoVDIV_VX_M2_E8, 283 }, + { PseudoVDIV_VX_M4_E16, 284 }, + { PseudoVDIV_VX_M4_E32, 285 }, + { PseudoVDIV_VX_M4_E64, 286 }, + { PseudoVDIV_VX_M4_E8, 287 }, + { PseudoVDIV_VX_M8_E16, 288 }, + { PseudoVDIV_VX_M8_E32, 289 }, + { PseudoVDIV_VX_M8_E64, 290 }, + { PseudoVDIV_VX_M8_E8, 291 }, + { PseudoVDIV_VX_MF2_E16, 292 }, + { PseudoVDIV_VX_MF2_E32, 293 }, + { PseudoVDIV_VX_MF2_E8, 294 }, + { PseudoVDIV_VX_MF4_E16, 295 }, + { PseudoVDIV_VX_MF4_E8, 296 }, + { PseudoVDIV_VX_MF8_E8, 297 }, + { PseudoVFADD_VFPR16_M1, 298 }, + { PseudoVFADD_VFPR16_M2, 299 }, + { PseudoVFADD_VFPR16_M4, 300 }, + { PseudoVFADD_VFPR16_M8, 301 }, + { PseudoVFADD_VFPR16_MF2, 302 }, + { PseudoVFADD_VFPR16_MF4, 303 }, + { PseudoVFADD_VFPR32_M1, 304 }, + { PseudoVFADD_VFPR32_M2, 305 }, + { PseudoVFADD_VFPR32_M4, 306 }, + { PseudoVFADD_VFPR32_M8, 307 }, + { PseudoVFADD_VFPR32_MF2, 308 }, + { PseudoVFADD_VFPR64_M1, 309 }, + { PseudoVFADD_VFPR64_M2, 310 }, + { PseudoVFADD_VFPR64_M4, 311 }, + { PseudoVFADD_VFPR64_M8, 312 }, + { PseudoVFADD_VV_M1, 313 }, + { PseudoVFADD_VV_M2, 314 }, + { PseudoVFADD_VV_M4, 315 }, + { PseudoVFADD_VV_M8, 316 }, + { PseudoVFADD_VV_MF2, 317 }, + { PseudoVFADD_VV_MF4, 318 }, + { PseudoVFCLASS_V_M1, 319 }, + { PseudoVFCLASS_V_M2, 320 }, + { PseudoVFCLASS_V_M4, 321 }, + { PseudoVFCLASS_V_M8, 322 }, + { PseudoVFCLASS_V_MF2, 323 }, + { PseudoVFCLASS_V_MF4, 324 }, + { PseudoVFCVT_F_XU_V_M1, 325 }, + { PseudoVFCVT_F_XU_V_M2, 326 }, + { PseudoVFCVT_F_XU_V_M4, 327 }, + { PseudoVFCVT_F_XU_V_M8, 328 }, + { PseudoVFCVT_F_XU_V_MF2, 329 }, + { PseudoVFCVT_F_XU_V_MF4, 330 }, + { PseudoVFCVT_F_X_V_M1, 331 }, + { PseudoVFCVT_F_X_V_M2, 332 }, + { PseudoVFCVT_F_X_V_M4, 333 }, + { PseudoVFCVT_F_X_V_M8, 334 }, + { PseudoVFCVT_F_X_V_MF2, 335 }, + { PseudoVFCVT_F_X_V_MF4, 336 }, + { PseudoVFCVT_RM_F_XU_V_M1, 337 }, + { PseudoVFCVT_RM_F_XU_V_M2, 338 }, + { PseudoVFCVT_RM_F_XU_V_M4, 339 }, + { PseudoVFCVT_RM_F_XU_V_M8, 340 }, + { PseudoVFCVT_RM_F_XU_V_MF2, 341 }, + { PseudoVFCVT_RM_F_XU_V_MF4, 342 }, + { PseudoVFCVT_RM_F_X_V_M1, 343 }, + { PseudoVFCVT_RM_F_X_V_M2, 344 }, + { PseudoVFCVT_RM_F_X_V_M4, 345 }, + { PseudoVFCVT_RM_F_X_V_M8, 346 }, + { PseudoVFCVT_RM_F_X_V_MF2, 347 }, + { PseudoVFCVT_RM_F_X_V_MF4, 348 }, + { PseudoVFCVT_RM_XU_F_V_M1, 349 }, + { PseudoVFCVT_RM_XU_F_V_M2, 350 }, + { PseudoVFCVT_RM_XU_F_V_M4, 351 }, + { PseudoVFCVT_RM_XU_F_V_M8, 352 }, + { PseudoVFCVT_RM_XU_F_V_MF2, 353 }, + { PseudoVFCVT_RM_XU_F_V_MF4, 354 }, + { PseudoVFCVT_RM_X_F_V_M1, 355 }, + { PseudoVFCVT_RM_X_F_V_M2, 356 }, + { PseudoVFCVT_RM_X_F_V_M4, 357 }, + { PseudoVFCVT_RM_X_F_V_M8, 358 }, + { PseudoVFCVT_RM_X_F_V_MF2, 359 }, + { PseudoVFCVT_RM_X_F_V_MF4, 360 }, + { PseudoVFCVT_RTZ_XU_F_V_M1, 361 }, + { PseudoVFCVT_RTZ_XU_F_V_M2, 362 }, + { PseudoVFCVT_RTZ_XU_F_V_M4, 363 }, + { PseudoVFCVT_RTZ_XU_F_V_M8, 364 }, + { PseudoVFCVT_RTZ_XU_F_V_MF2, 365 }, + { PseudoVFCVT_RTZ_XU_F_V_MF4, 366 }, + { PseudoVFCVT_RTZ_X_F_V_M1, 367 }, + { PseudoVFCVT_RTZ_X_F_V_M2, 368 }, + { PseudoVFCVT_RTZ_X_F_V_M4, 369 }, + { PseudoVFCVT_RTZ_X_F_V_M8, 370 }, + { PseudoVFCVT_RTZ_X_F_V_MF2, 371 }, + { PseudoVFCVT_RTZ_X_F_V_MF4, 372 }, + { PseudoVFCVT_XU_F_V_M1, 373 }, + { PseudoVFCVT_XU_F_V_M2, 374 }, + { PseudoVFCVT_XU_F_V_M4, 375 }, + { PseudoVFCVT_XU_F_V_M8, 376 }, + { PseudoVFCVT_XU_F_V_MF2, 377 }, + { PseudoVFCVT_XU_F_V_MF4, 378 }, + { PseudoVFCVT_X_F_V_M1, 379 }, + { PseudoVFCVT_X_F_V_M2, 380 }, + { PseudoVFCVT_X_F_V_M4, 381 }, + { PseudoVFCVT_X_F_V_M8, 382 }, + { PseudoVFCVT_X_F_V_MF2, 383 }, + { PseudoVFCVT_X_F_V_MF4, 384 }, + { PseudoVFDIV_VFPR16_M1_E16, 385 }, + { PseudoVFDIV_VFPR16_M2_E16, 386 }, + { PseudoVFDIV_VFPR16_M4_E16, 387 }, + { PseudoVFDIV_VFPR16_M8_E16, 388 }, + { PseudoVFDIV_VFPR16_MF2_E16, 389 }, + { PseudoVFDIV_VFPR16_MF4_E16, 390 }, + { PseudoVFDIV_VFPR32_M1_E32, 391 }, + { PseudoVFDIV_VFPR32_M2_E32, 392 }, + { PseudoVFDIV_VFPR32_M4_E32, 393 }, + { PseudoVFDIV_VFPR32_M8_E32, 394 }, + { PseudoVFDIV_VFPR32_MF2_E32, 395 }, + { PseudoVFDIV_VFPR64_M1_E64, 396 }, + { PseudoVFDIV_VFPR64_M2_E64, 397 }, + { PseudoVFDIV_VFPR64_M4_E64, 398 }, + { PseudoVFDIV_VFPR64_M8_E64, 399 }, + { PseudoVFDIV_VV_M1_E16, 400 }, + { PseudoVFDIV_VV_M1_E32, 401 }, + { PseudoVFDIV_VV_M1_E64, 402 }, + { PseudoVFDIV_VV_M2_E16, 403 }, + { PseudoVFDIV_VV_M2_E32, 404 }, + { PseudoVFDIV_VV_M2_E64, 405 }, + { PseudoVFDIV_VV_M4_E16, 406 }, + { PseudoVFDIV_VV_M4_E32, 407 }, + { PseudoVFDIV_VV_M4_E64, 408 }, + { PseudoVFDIV_VV_M8_E16, 409 }, + { PseudoVFDIV_VV_M8_E32, 410 }, + { PseudoVFDIV_VV_M8_E64, 411 }, + { PseudoVFDIV_VV_MF2_E16, 412 }, + { PseudoVFDIV_VV_MF2_E32, 413 }, + { PseudoVFDIV_VV_MF4_E16, 414 }, + { PseudoVFMACC_VFPR16_M1, 415 }, + { PseudoVFMACC_VFPR16_M2, 416 }, + { PseudoVFMACC_VFPR16_M4, 417 }, + { PseudoVFMACC_VFPR16_M8, 418 }, + { PseudoVFMACC_VFPR16_MF2, 419 }, + { PseudoVFMACC_VFPR16_MF4, 420 }, + { PseudoVFMACC_VFPR32_M1, 421 }, + { PseudoVFMACC_VFPR32_M2, 422 }, + { PseudoVFMACC_VFPR32_M4, 423 }, + { PseudoVFMACC_VFPR32_M8, 424 }, + { PseudoVFMACC_VFPR32_MF2, 425 }, + { PseudoVFMACC_VFPR64_M1, 426 }, + { PseudoVFMACC_VFPR64_M2, 427 }, + { PseudoVFMACC_VFPR64_M4, 428 }, + { PseudoVFMACC_VFPR64_M8, 429 }, + { PseudoVFMACC_VV_M1, 430 }, + { PseudoVFMACC_VV_M2, 431 }, + { PseudoVFMACC_VV_M4, 432 }, + { PseudoVFMACC_VV_M8, 433 }, + { PseudoVFMACC_VV_MF2, 434 }, + { PseudoVFMACC_VV_MF4, 435 }, + { PseudoVFMADD_VFPR16_M1, 436 }, + { PseudoVFMADD_VFPR16_M2, 437 }, + { PseudoVFMADD_VFPR16_M4, 438 }, + { PseudoVFMADD_VFPR16_M8, 439 }, + { PseudoVFMADD_VFPR16_MF2, 440 }, + { PseudoVFMADD_VFPR16_MF4, 441 }, + { PseudoVFMADD_VFPR32_M1, 442 }, + { PseudoVFMADD_VFPR32_M2, 443 }, + { PseudoVFMADD_VFPR32_M4, 444 }, + { PseudoVFMADD_VFPR32_M8, 445 }, + { PseudoVFMADD_VFPR32_MF2, 446 }, + { PseudoVFMADD_VFPR64_M1, 447 }, + { PseudoVFMADD_VFPR64_M2, 448 }, + { PseudoVFMADD_VFPR64_M4, 449 }, + { PseudoVFMADD_VFPR64_M8, 450 }, + { PseudoVFMADD_VV_M1, 451 }, + { PseudoVFMADD_VV_M2, 452 }, + { PseudoVFMADD_VV_M4, 453 }, + { PseudoVFMADD_VV_M8, 454 }, + { PseudoVFMADD_VV_MF2, 455 }, + { PseudoVFMADD_VV_MF4, 456 }, + { PseudoVFMAX_VFPR16_M1, 457 }, + { PseudoVFMAX_VFPR16_M2, 458 }, + { PseudoVFMAX_VFPR16_M4, 459 }, + { PseudoVFMAX_VFPR16_M8, 460 }, + { PseudoVFMAX_VFPR16_MF2, 461 }, + { PseudoVFMAX_VFPR16_MF4, 462 }, + { PseudoVFMAX_VFPR32_M1, 463 }, + { PseudoVFMAX_VFPR32_M2, 464 }, + { PseudoVFMAX_VFPR32_M4, 465 }, + { PseudoVFMAX_VFPR32_M8, 466 }, + { PseudoVFMAX_VFPR32_MF2, 467 }, + { PseudoVFMAX_VFPR64_M1, 468 }, + { PseudoVFMAX_VFPR64_M2, 469 }, + { PseudoVFMAX_VFPR64_M4, 470 }, + { PseudoVFMAX_VFPR64_M8, 471 }, + { PseudoVFMAX_VV_M1, 472 }, + { PseudoVFMAX_VV_M2, 473 }, + { PseudoVFMAX_VV_M4, 474 }, + { PseudoVFMAX_VV_M8, 475 }, + { PseudoVFMAX_VV_MF2, 476 }, + { PseudoVFMAX_VV_MF4, 477 }, + { PseudoVFMIN_VFPR16_M1, 478 }, + { PseudoVFMIN_VFPR16_M2, 479 }, + { PseudoVFMIN_VFPR16_M4, 480 }, + { PseudoVFMIN_VFPR16_M8, 481 }, + { PseudoVFMIN_VFPR16_MF2, 482 }, + { PseudoVFMIN_VFPR16_MF4, 483 }, + { PseudoVFMIN_VFPR32_M1, 484 }, + { PseudoVFMIN_VFPR32_M2, 485 }, + { PseudoVFMIN_VFPR32_M4, 486 }, + { PseudoVFMIN_VFPR32_M8, 487 }, + { PseudoVFMIN_VFPR32_MF2, 488 }, + { PseudoVFMIN_VFPR64_M1, 489 }, + { PseudoVFMIN_VFPR64_M2, 490 }, + { PseudoVFMIN_VFPR64_M4, 491 }, + { PseudoVFMIN_VFPR64_M8, 492 }, + { PseudoVFMIN_VV_M1, 493 }, + { PseudoVFMIN_VV_M2, 494 }, + { PseudoVFMIN_VV_M4, 495 }, + { PseudoVFMIN_VV_M8, 496 }, + { PseudoVFMIN_VV_MF2, 497 }, + { PseudoVFMIN_VV_MF4, 498 }, + { PseudoVFMSAC_VFPR16_M1, 499 }, + { PseudoVFMSAC_VFPR16_M2, 500 }, + { PseudoVFMSAC_VFPR16_M4, 501 }, + { PseudoVFMSAC_VFPR16_M8, 502 }, + { PseudoVFMSAC_VFPR16_MF2, 503 }, + { PseudoVFMSAC_VFPR16_MF4, 504 }, + { PseudoVFMSAC_VFPR32_M1, 505 }, + { PseudoVFMSAC_VFPR32_M2, 506 }, + { PseudoVFMSAC_VFPR32_M4, 507 }, + { PseudoVFMSAC_VFPR32_M8, 508 }, + { PseudoVFMSAC_VFPR32_MF2, 509 }, + { PseudoVFMSAC_VFPR64_M1, 510 }, + { PseudoVFMSAC_VFPR64_M2, 511 }, + { PseudoVFMSAC_VFPR64_M4, 512 }, + { PseudoVFMSAC_VFPR64_M8, 513 }, + { PseudoVFMSAC_VV_M1, 514 }, + { PseudoVFMSAC_VV_M2, 515 }, + { PseudoVFMSAC_VV_M4, 516 }, + { PseudoVFMSAC_VV_M8, 517 }, + { PseudoVFMSAC_VV_MF2, 518 }, + { PseudoVFMSAC_VV_MF4, 519 }, + { PseudoVFMSUB_VFPR16_M1, 520 }, + { PseudoVFMSUB_VFPR16_M2, 521 }, + { PseudoVFMSUB_VFPR16_M4, 522 }, + { PseudoVFMSUB_VFPR16_M8, 523 }, + { PseudoVFMSUB_VFPR16_MF2, 524 }, + { PseudoVFMSUB_VFPR16_MF4, 525 }, + { PseudoVFMSUB_VFPR32_M1, 526 }, + { PseudoVFMSUB_VFPR32_M2, 527 }, + { PseudoVFMSUB_VFPR32_M4, 528 }, + { PseudoVFMSUB_VFPR32_M8, 529 }, + { PseudoVFMSUB_VFPR32_MF2, 530 }, + { PseudoVFMSUB_VFPR64_M1, 531 }, + { PseudoVFMSUB_VFPR64_M2, 532 }, + { PseudoVFMSUB_VFPR64_M4, 533 }, + { PseudoVFMSUB_VFPR64_M8, 534 }, + { PseudoVFMSUB_VV_M1, 535 }, + { PseudoVFMSUB_VV_M2, 536 }, + { PseudoVFMSUB_VV_M4, 537 }, + { PseudoVFMSUB_VV_M8, 538 }, + { PseudoVFMSUB_VV_MF2, 539 }, + { PseudoVFMSUB_VV_MF4, 540 }, + { PseudoVFMUL_VFPR16_M1, 541 }, + { PseudoVFMUL_VFPR16_M2, 542 }, + { PseudoVFMUL_VFPR16_M4, 543 }, + { PseudoVFMUL_VFPR16_M8, 544 }, + { PseudoVFMUL_VFPR16_MF2, 545 }, + { PseudoVFMUL_VFPR16_MF4, 546 }, + { PseudoVFMUL_VFPR32_M1, 547 }, + { PseudoVFMUL_VFPR32_M2, 548 }, + { PseudoVFMUL_VFPR32_M4, 549 }, + { PseudoVFMUL_VFPR32_M8, 550 }, + { PseudoVFMUL_VFPR32_MF2, 551 }, + { PseudoVFMUL_VFPR64_M1, 552 }, + { PseudoVFMUL_VFPR64_M2, 553 }, + { PseudoVFMUL_VFPR64_M4, 554 }, + { PseudoVFMUL_VFPR64_M8, 555 }, + { PseudoVFMUL_VV_M1, 556 }, + { PseudoVFMUL_VV_M2, 557 }, + { PseudoVFMUL_VV_M4, 558 }, + { PseudoVFMUL_VV_M8, 559 }, + { PseudoVFMUL_VV_MF2, 560 }, + { PseudoVFMUL_VV_MF4, 561 }, + { PseudoVFNCVTBF16_F_F_W_M1, 562 }, + { PseudoVFNCVTBF16_F_F_W_M2, 563 }, + { PseudoVFNCVTBF16_F_F_W_M4, 564 }, + { PseudoVFNCVTBF16_F_F_W_MF2, 565 }, + { PseudoVFNCVTBF16_F_F_W_MF4, 566 }, + { PseudoVFNCVT_F_F_W_M1, 567 }, + { PseudoVFNCVT_F_F_W_M2, 568 }, + { PseudoVFNCVT_F_F_W_M4, 569 }, + { PseudoVFNCVT_F_F_W_MF2, 570 }, + { PseudoVFNCVT_F_F_W_MF4, 571 }, + { PseudoVFNCVT_F_XU_W_M1, 572 }, + { PseudoVFNCVT_F_XU_W_M2, 573 }, + { PseudoVFNCVT_F_XU_W_M4, 574 }, + { PseudoVFNCVT_F_XU_W_MF2, 575 }, + { PseudoVFNCVT_F_XU_W_MF4, 576 }, + { PseudoVFNCVT_F_X_W_M1, 577 }, + { PseudoVFNCVT_F_X_W_M2, 578 }, + { PseudoVFNCVT_F_X_W_M4, 579 }, + { PseudoVFNCVT_F_X_W_MF2, 580 }, + { PseudoVFNCVT_F_X_W_MF4, 581 }, + { PseudoVFNCVT_RM_F_XU_W_M1, 582 }, + { PseudoVFNCVT_RM_F_XU_W_M2, 583 }, + { PseudoVFNCVT_RM_F_XU_W_M4, 584 }, + { PseudoVFNCVT_RM_F_XU_W_MF2, 585 }, + { PseudoVFNCVT_RM_F_XU_W_MF4, 586 }, + { PseudoVFNCVT_RM_F_X_W_M1, 587 }, + { PseudoVFNCVT_RM_F_X_W_M2, 588 }, + { PseudoVFNCVT_RM_F_X_W_M4, 589 }, + { PseudoVFNCVT_RM_F_X_W_MF2, 590 }, + { PseudoVFNCVT_RM_F_X_W_MF4, 591 }, + { PseudoVFNCVT_RM_XU_F_W_M1, 592 }, + { PseudoVFNCVT_RM_XU_F_W_M2, 593 }, + { PseudoVFNCVT_RM_XU_F_W_M4, 594 }, + { PseudoVFNCVT_RM_XU_F_W_MF2, 595 }, + { PseudoVFNCVT_RM_XU_F_W_MF4, 596 }, + { PseudoVFNCVT_RM_XU_F_W_MF8, 597 }, + { PseudoVFNCVT_RM_X_F_W_M1, 598 }, + { PseudoVFNCVT_RM_X_F_W_M2, 599 }, + { PseudoVFNCVT_RM_X_F_W_M4, 600 }, + { PseudoVFNCVT_RM_X_F_W_MF2, 601 }, + { PseudoVFNCVT_RM_X_F_W_MF4, 602 }, + { PseudoVFNCVT_RM_X_F_W_MF8, 603 }, + { PseudoVFNCVT_ROD_F_F_W_M1, 604 }, + { PseudoVFNCVT_ROD_F_F_W_M2, 605 }, + { PseudoVFNCVT_ROD_F_F_W_M4, 606 }, + { PseudoVFNCVT_ROD_F_F_W_MF2, 607 }, + { PseudoVFNCVT_ROD_F_F_W_MF4, 608 }, + { PseudoVFNCVT_RTZ_XU_F_W_M1, 609 }, + { PseudoVFNCVT_RTZ_XU_F_W_M2, 610 }, + { PseudoVFNCVT_RTZ_XU_F_W_M4, 611 }, + { PseudoVFNCVT_RTZ_XU_F_W_MF2, 612 }, + { PseudoVFNCVT_RTZ_XU_F_W_MF4, 613 }, + { PseudoVFNCVT_RTZ_XU_F_W_MF8, 614 }, + { PseudoVFNCVT_RTZ_X_F_W_M1, 615 }, + { PseudoVFNCVT_RTZ_X_F_W_M2, 616 }, + { PseudoVFNCVT_RTZ_X_F_W_M4, 617 }, + { PseudoVFNCVT_RTZ_X_F_W_MF2, 618 }, + { PseudoVFNCVT_RTZ_X_F_W_MF4, 619 }, + { PseudoVFNCVT_RTZ_X_F_W_MF8, 620 }, + { PseudoVFNCVT_XU_F_W_M1, 621 }, + { PseudoVFNCVT_XU_F_W_M2, 622 }, + { PseudoVFNCVT_XU_F_W_M4, 623 }, + { PseudoVFNCVT_XU_F_W_MF2, 624 }, + { PseudoVFNCVT_XU_F_W_MF4, 625 }, + { PseudoVFNCVT_XU_F_W_MF8, 626 }, + { PseudoVFNCVT_X_F_W_M1, 627 }, + { PseudoVFNCVT_X_F_W_M2, 628 }, + { PseudoVFNCVT_X_F_W_M4, 629 }, + { PseudoVFNCVT_X_F_W_MF2, 630 }, + { PseudoVFNCVT_X_F_W_MF4, 631 }, + { PseudoVFNCVT_X_F_W_MF8, 632 }, + { PseudoVFNMACC_VFPR16_M1, 633 }, + { PseudoVFNMACC_VFPR16_M2, 634 }, + { PseudoVFNMACC_VFPR16_M4, 635 }, + { PseudoVFNMACC_VFPR16_M8, 636 }, + { PseudoVFNMACC_VFPR16_MF2, 637 }, + { PseudoVFNMACC_VFPR16_MF4, 638 }, + { PseudoVFNMACC_VFPR32_M1, 639 }, + { PseudoVFNMACC_VFPR32_M2, 640 }, + { PseudoVFNMACC_VFPR32_M4, 641 }, + { PseudoVFNMACC_VFPR32_M8, 642 }, + { PseudoVFNMACC_VFPR32_MF2, 643 }, + { PseudoVFNMACC_VFPR64_M1, 644 }, + { PseudoVFNMACC_VFPR64_M2, 645 }, + { PseudoVFNMACC_VFPR64_M4, 646 }, + { PseudoVFNMACC_VFPR64_M8, 647 }, + { PseudoVFNMACC_VV_M1, 648 }, + { PseudoVFNMACC_VV_M2, 649 }, + { PseudoVFNMACC_VV_M4, 650 }, + { PseudoVFNMACC_VV_M8, 651 }, + { PseudoVFNMACC_VV_MF2, 652 }, + { PseudoVFNMACC_VV_MF4, 653 }, + { PseudoVFNMADD_VFPR16_M1, 654 }, + { PseudoVFNMADD_VFPR16_M2, 655 }, + { PseudoVFNMADD_VFPR16_M4, 656 }, + { PseudoVFNMADD_VFPR16_M8, 657 }, + { PseudoVFNMADD_VFPR16_MF2, 658 }, + { PseudoVFNMADD_VFPR16_MF4, 659 }, + { PseudoVFNMADD_VFPR32_M1, 660 }, + { PseudoVFNMADD_VFPR32_M2, 661 }, + { PseudoVFNMADD_VFPR32_M4, 662 }, + { PseudoVFNMADD_VFPR32_M8, 663 }, + { PseudoVFNMADD_VFPR32_MF2, 664 }, + { PseudoVFNMADD_VFPR64_M1, 665 }, + { PseudoVFNMADD_VFPR64_M2, 666 }, + { PseudoVFNMADD_VFPR64_M4, 667 }, + { PseudoVFNMADD_VFPR64_M8, 668 }, + { PseudoVFNMADD_VV_M1, 669 }, + { PseudoVFNMADD_VV_M2, 670 }, + { PseudoVFNMADD_VV_M4, 671 }, + { PseudoVFNMADD_VV_M8, 672 }, + { PseudoVFNMADD_VV_MF2, 673 }, + { PseudoVFNMADD_VV_MF4, 674 }, + { PseudoVFNMSAC_VFPR16_M1, 675 }, + { PseudoVFNMSAC_VFPR16_M2, 676 }, + { PseudoVFNMSAC_VFPR16_M4, 677 }, + { PseudoVFNMSAC_VFPR16_M8, 678 }, + { PseudoVFNMSAC_VFPR16_MF2, 679 }, + { PseudoVFNMSAC_VFPR16_MF4, 680 }, + { PseudoVFNMSAC_VFPR32_M1, 681 }, + { PseudoVFNMSAC_VFPR32_M2, 682 }, + { PseudoVFNMSAC_VFPR32_M4, 683 }, + { PseudoVFNMSAC_VFPR32_M8, 684 }, + { PseudoVFNMSAC_VFPR32_MF2, 685 }, + { PseudoVFNMSAC_VFPR64_M1, 686 }, + { PseudoVFNMSAC_VFPR64_M2, 687 }, + { PseudoVFNMSAC_VFPR64_M4, 688 }, + { PseudoVFNMSAC_VFPR64_M8, 689 }, + { PseudoVFNMSAC_VV_M1, 690 }, + { PseudoVFNMSAC_VV_M2, 691 }, + { PseudoVFNMSAC_VV_M4, 692 }, + { PseudoVFNMSAC_VV_M8, 693 }, + { PseudoVFNMSAC_VV_MF2, 694 }, + { PseudoVFNMSAC_VV_MF4, 695 }, + { PseudoVFNMSUB_VFPR16_M1, 696 }, + { PseudoVFNMSUB_VFPR16_M2, 697 }, + { PseudoVFNMSUB_VFPR16_M4, 698 }, + { PseudoVFNMSUB_VFPR16_M8, 699 }, + { PseudoVFNMSUB_VFPR16_MF2, 700 }, + { PseudoVFNMSUB_VFPR16_MF4, 701 }, + { PseudoVFNMSUB_VFPR32_M1, 702 }, + { PseudoVFNMSUB_VFPR32_M2, 703 }, + { PseudoVFNMSUB_VFPR32_M4, 704 }, + { PseudoVFNMSUB_VFPR32_M8, 705 }, + { PseudoVFNMSUB_VFPR32_MF2, 706 }, + { PseudoVFNMSUB_VFPR64_M1, 707 }, + { PseudoVFNMSUB_VFPR64_M2, 708 }, + { PseudoVFNMSUB_VFPR64_M4, 709 }, + { PseudoVFNMSUB_VFPR64_M8, 710 }, + { PseudoVFNMSUB_VV_M1, 711 }, + { PseudoVFNMSUB_VV_M2, 712 }, + { PseudoVFNMSUB_VV_M4, 713 }, + { PseudoVFNMSUB_VV_M8, 714 }, + { PseudoVFNMSUB_VV_MF2, 715 }, + { PseudoVFNMSUB_VV_MF4, 716 }, + { PseudoVFNRCLIP_XU_F_QF_M1, 717 }, + { PseudoVFNRCLIP_XU_F_QF_M2, 718 }, + { PseudoVFNRCLIP_XU_F_QF_MF2, 719 }, + { PseudoVFNRCLIP_XU_F_QF_MF4, 720 }, + { PseudoVFNRCLIP_XU_F_QF_MF8, 721 }, + { PseudoVFNRCLIP_X_F_QF_M1, 722 }, + { PseudoVFNRCLIP_X_F_QF_M2, 723 }, + { PseudoVFNRCLIP_X_F_QF_MF2, 724 }, + { PseudoVFNRCLIP_X_F_QF_MF4, 725 }, + { PseudoVFNRCLIP_X_F_QF_MF8, 726 }, + { PseudoVFRDIV_VFPR16_M1_E16, 727 }, + { PseudoVFRDIV_VFPR16_M2_E16, 728 }, + { PseudoVFRDIV_VFPR16_M4_E16, 729 }, + { PseudoVFRDIV_VFPR16_M8_E16, 730 }, + { PseudoVFRDIV_VFPR16_MF2_E16, 731 }, + { PseudoVFRDIV_VFPR16_MF4_E16, 732 }, + { PseudoVFRDIV_VFPR32_M1_E32, 733 }, + { PseudoVFRDIV_VFPR32_M2_E32, 734 }, + { PseudoVFRDIV_VFPR32_M4_E32, 735 }, + { PseudoVFRDIV_VFPR32_M8_E32, 736 }, + { PseudoVFRDIV_VFPR32_MF2_E32, 737 }, + { PseudoVFRDIV_VFPR64_M1_E64, 738 }, + { PseudoVFRDIV_VFPR64_M2_E64, 739 }, + { PseudoVFRDIV_VFPR64_M4_E64, 740 }, + { PseudoVFRDIV_VFPR64_M8_E64, 741 }, + { PseudoVFREC7_V_M1, 742 }, + { PseudoVFREC7_V_M2, 743 }, + { PseudoVFREC7_V_M4, 744 }, + { PseudoVFREC7_V_M8, 745 }, + { PseudoVFREC7_V_MF2, 746 }, + { PseudoVFREC7_V_MF4, 747 }, + { PseudoVFREDMAX_VS_M1_E16, 748 }, + { PseudoVFREDMAX_VS_M1_E32, 749 }, + { PseudoVFREDMAX_VS_M1_E64, 750 }, + { PseudoVFREDMAX_VS_M2_E16, 751 }, + { PseudoVFREDMAX_VS_M2_E32, 752 }, + { PseudoVFREDMAX_VS_M2_E64, 753 }, + { PseudoVFREDMAX_VS_M4_E16, 754 }, + { PseudoVFREDMAX_VS_M4_E32, 755 }, + { PseudoVFREDMAX_VS_M4_E64, 756 }, + { PseudoVFREDMAX_VS_M8_E16, 757 }, + { PseudoVFREDMAX_VS_M8_E32, 758 }, + { PseudoVFREDMAX_VS_M8_E64, 759 }, + { PseudoVFREDMAX_VS_MF2_E16, 760 }, + { PseudoVFREDMAX_VS_MF2_E32, 761 }, + { PseudoVFREDMAX_VS_MF4_E16, 762 }, + { PseudoVFREDMIN_VS_M1_E16, 763 }, + { PseudoVFREDMIN_VS_M1_E32, 764 }, + { PseudoVFREDMIN_VS_M1_E64, 765 }, + { PseudoVFREDMIN_VS_M2_E16, 766 }, + { PseudoVFREDMIN_VS_M2_E32, 767 }, + { PseudoVFREDMIN_VS_M2_E64, 768 }, + { PseudoVFREDMIN_VS_M4_E16, 769 }, + { PseudoVFREDMIN_VS_M4_E32, 770 }, + { PseudoVFREDMIN_VS_M4_E64, 771 }, + { PseudoVFREDMIN_VS_M8_E16, 772 }, + { PseudoVFREDMIN_VS_M8_E32, 773 }, + { PseudoVFREDMIN_VS_M8_E64, 774 }, + { PseudoVFREDMIN_VS_MF2_E16, 775 }, + { PseudoVFREDMIN_VS_MF2_E32, 776 }, + { PseudoVFREDMIN_VS_MF4_E16, 777 }, + { PseudoVFREDOSUM_VS_M1_E16, 778 }, + { PseudoVFREDOSUM_VS_M1_E32, 779 }, + { PseudoVFREDOSUM_VS_M1_E64, 780 }, + { PseudoVFREDOSUM_VS_M2_E16, 781 }, + { PseudoVFREDOSUM_VS_M2_E32, 782 }, + { PseudoVFREDOSUM_VS_M2_E64, 783 }, + { PseudoVFREDOSUM_VS_M4_E16, 784 }, + { PseudoVFREDOSUM_VS_M4_E32, 785 }, + { PseudoVFREDOSUM_VS_M4_E64, 786 }, + { PseudoVFREDOSUM_VS_M8_E16, 787 }, + { PseudoVFREDOSUM_VS_M8_E32, 788 }, + { PseudoVFREDOSUM_VS_M8_E64, 789 }, + { PseudoVFREDOSUM_VS_MF2_E16, 790 }, + { PseudoVFREDOSUM_VS_MF2_E32, 791 }, + { PseudoVFREDOSUM_VS_MF4_E16, 792 }, + { PseudoVFREDUSUM_VS_M1_E16, 793 }, + { PseudoVFREDUSUM_VS_M1_E32, 794 }, + { PseudoVFREDUSUM_VS_M1_E64, 795 }, + { PseudoVFREDUSUM_VS_M2_E16, 796 }, + { PseudoVFREDUSUM_VS_M2_E32, 797 }, + { PseudoVFREDUSUM_VS_M2_E64, 798 }, + { PseudoVFREDUSUM_VS_M4_E16, 799 }, + { PseudoVFREDUSUM_VS_M4_E32, 800 }, + { PseudoVFREDUSUM_VS_M4_E64, 801 }, + { PseudoVFREDUSUM_VS_M8_E16, 802 }, + { PseudoVFREDUSUM_VS_M8_E32, 803 }, + { PseudoVFREDUSUM_VS_M8_E64, 804 }, + { PseudoVFREDUSUM_VS_MF2_E16, 805 }, + { PseudoVFREDUSUM_VS_MF2_E32, 806 }, + { PseudoVFREDUSUM_VS_MF4_E16, 807 }, + { PseudoVFRSQRT7_V_M1, 808 }, + { PseudoVFRSQRT7_V_M2, 809 }, + { PseudoVFRSQRT7_V_M4, 810 }, + { PseudoVFRSQRT7_V_M8, 811 }, + { PseudoVFRSQRT7_V_MF2, 812 }, + { PseudoVFRSQRT7_V_MF4, 813 }, + { PseudoVFRSUB_VFPR16_M1, 814 }, + { PseudoVFRSUB_VFPR16_M2, 815 }, + { PseudoVFRSUB_VFPR16_M4, 816 }, + { PseudoVFRSUB_VFPR16_M8, 817 }, + { PseudoVFRSUB_VFPR16_MF2, 818 }, + { PseudoVFRSUB_VFPR16_MF4, 819 }, + { PseudoVFRSUB_VFPR32_M1, 820 }, + { PseudoVFRSUB_VFPR32_M2, 821 }, + { PseudoVFRSUB_VFPR32_M4, 822 }, + { PseudoVFRSUB_VFPR32_M8, 823 }, + { PseudoVFRSUB_VFPR32_MF2, 824 }, + { PseudoVFRSUB_VFPR64_M1, 825 }, + { PseudoVFRSUB_VFPR64_M2, 826 }, + { PseudoVFRSUB_VFPR64_M4, 827 }, + { PseudoVFRSUB_VFPR64_M8, 828 }, + { PseudoVFSGNJN_VFPR16_M1, 829 }, + { PseudoVFSGNJN_VFPR16_M2, 830 }, + { PseudoVFSGNJN_VFPR16_M4, 831 }, + { PseudoVFSGNJN_VFPR16_M8, 832 }, + { PseudoVFSGNJN_VFPR16_MF2, 833 }, + { PseudoVFSGNJN_VFPR16_MF4, 834 }, + { PseudoVFSGNJN_VFPR32_M1, 835 }, + { PseudoVFSGNJN_VFPR32_M2, 836 }, + { PseudoVFSGNJN_VFPR32_M4, 837 }, + { PseudoVFSGNJN_VFPR32_M8, 838 }, + { PseudoVFSGNJN_VFPR32_MF2, 839 }, + { PseudoVFSGNJN_VFPR64_M1, 840 }, + { PseudoVFSGNJN_VFPR64_M2, 841 }, + { PseudoVFSGNJN_VFPR64_M4, 842 }, + { PseudoVFSGNJN_VFPR64_M8, 843 }, + { PseudoVFSGNJN_VV_M1, 844 }, + { PseudoVFSGNJN_VV_M2, 845 }, + { PseudoVFSGNJN_VV_M4, 846 }, + { PseudoVFSGNJN_VV_M8, 847 }, + { PseudoVFSGNJN_VV_MF2, 848 }, + { PseudoVFSGNJN_VV_MF4, 849 }, + { PseudoVFSGNJX_VFPR16_M1, 850 }, + { PseudoVFSGNJX_VFPR16_M2, 851 }, + { PseudoVFSGNJX_VFPR16_M4, 852 }, + { PseudoVFSGNJX_VFPR16_M8, 853 }, + { PseudoVFSGNJX_VFPR16_MF2, 854 }, + { PseudoVFSGNJX_VFPR16_MF4, 855 }, + { PseudoVFSGNJX_VFPR32_M1, 856 }, + { PseudoVFSGNJX_VFPR32_M2, 857 }, + { PseudoVFSGNJX_VFPR32_M4, 858 }, + { PseudoVFSGNJX_VFPR32_M8, 859 }, + { PseudoVFSGNJX_VFPR32_MF2, 860 }, + { PseudoVFSGNJX_VFPR64_M1, 861 }, + { PseudoVFSGNJX_VFPR64_M2, 862 }, + { PseudoVFSGNJX_VFPR64_M4, 863 }, + { PseudoVFSGNJX_VFPR64_M8, 864 }, + { PseudoVFSGNJX_VV_M1, 865 }, + { PseudoVFSGNJX_VV_M2, 866 }, + { PseudoVFSGNJX_VV_M4, 867 }, + { PseudoVFSGNJX_VV_M8, 868 }, + { PseudoVFSGNJX_VV_MF2, 869 }, + { PseudoVFSGNJX_VV_MF4, 870 }, + { PseudoVFSGNJ_VFPR16_M1, 871 }, + { PseudoVFSGNJ_VFPR16_M2, 872 }, + { PseudoVFSGNJ_VFPR16_M4, 873 }, + { PseudoVFSGNJ_VFPR16_M8, 874 }, + { PseudoVFSGNJ_VFPR16_MF2, 875 }, + { PseudoVFSGNJ_VFPR16_MF4, 876 }, + { PseudoVFSGNJ_VFPR32_M1, 877 }, + { PseudoVFSGNJ_VFPR32_M2, 878 }, + { PseudoVFSGNJ_VFPR32_M4, 879 }, + { PseudoVFSGNJ_VFPR32_M8, 880 }, + { PseudoVFSGNJ_VFPR32_MF2, 881 }, + { PseudoVFSGNJ_VFPR64_M1, 882 }, + { PseudoVFSGNJ_VFPR64_M2, 883 }, + { PseudoVFSGNJ_VFPR64_M4, 884 }, + { PseudoVFSGNJ_VFPR64_M8, 885 }, + { PseudoVFSGNJ_VV_M1, 886 }, + { PseudoVFSGNJ_VV_M2, 887 }, + { PseudoVFSGNJ_VV_M4, 888 }, + { PseudoVFSGNJ_VV_M8, 889 }, + { PseudoVFSGNJ_VV_MF2, 890 }, + { PseudoVFSGNJ_VV_MF4, 891 }, + { PseudoVFSLIDE1DOWN_VFPR16_M1, 892 }, + { PseudoVFSLIDE1DOWN_VFPR16_M2, 893 }, + { PseudoVFSLIDE1DOWN_VFPR16_M4, 894 }, + { PseudoVFSLIDE1DOWN_VFPR16_M8, 895 }, + { PseudoVFSLIDE1DOWN_VFPR16_MF2, 896 }, + { PseudoVFSLIDE1DOWN_VFPR16_MF4, 897 }, + { PseudoVFSLIDE1DOWN_VFPR32_M1, 898 }, + { PseudoVFSLIDE1DOWN_VFPR32_M2, 899 }, + { PseudoVFSLIDE1DOWN_VFPR32_M4, 900 }, + { PseudoVFSLIDE1DOWN_VFPR32_M8, 901 }, + { PseudoVFSLIDE1DOWN_VFPR32_MF2, 902 }, + { PseudoVFSLIDE1DOWN_VFPR64_M1, 903 }, + { PseudoVFSLIDE1DOWN_VFPR64_M2, 904 }, + { PseudoVFSLIDE1DOWN_VFPR64_M4, 905 }, + { PseudoVFSLIDE1DOWN_VFPR64_M8, 906 }, + { PseudoVFSLIDE1UP_VFPR16_M1, 907 }, + { PseudoVFSLIDE1UP_VFPR16_M2, 908 }, + { PseudoVFSLIDE1UP_VFPR16_M4, 909 }, + { PseudoVFSLIDE1UP_VFPR16_M8, 910 }, + { PseudoVFSLIDE1UP_VFPR16_MF2, 911 }, + { PseudoVFSLIDE1UP_VFPR16_MF4, 912 }, + { PseudoVFSLIDE1UP_VFPR32_M1, 913 }, + { PseudoVFSLIDE1UP_VFPR32_M2, 914 }, + { PseudoVFSLIDE1UP_VFPR32_M4, 915 }, + { PseudoVFSLIDE1UP_VFPR32_M8, 916 }, + { PseudoVFSLIDE1UP_VFPR32_MF2, 917 }, + { PseudoVFSLIDE1UP_VFPR64_M1, 918 }, + { PseudoVFSLIDE1UP_VFPR64_M2, 919 }, + { PseudoVFSLIDE1UP_VFPR64_M4, 920 }, + { PseudoVFSLIDE1UP_VFPR64_M8, 921 }, + { PseudoVFSQRT_V_M1_E16, 922 }, + { PseudoVFSQRT_V_M1_E32, 923 }, + { PseudoVFSQRT_V_M1_E64, 924 }, + { PseudoVFSQRT_V_M2_E16, 925 }, + { PseudoVFSQRT_V_M2_E32, 926 }, + { PseudoVFSQRT_V_M2_E64, 927 }, + { PseudoVFSQRT_V_M4_E16, 928 }, + { PseudoVFSQRT_V_M4_E32, 929 }, + { PseudoVFSQRT_V_M4_E64, 930 }, + { PseudoVFSQRT_V_M8_E16, 931 }, + { PseudoVFSQRT_V_M8_E32, 932 }, + { PseudoVFSQRT_V_M8_E64, 933 }, + { PseudoVFSQRT_V_MF2_E16, 934 }, + { PseudoVFSQRT_V_MF2_E32, 935 }, + { PseudoVFSQRT_V_MF4_E16, 936 }, + { PseudoVFSUB_VFPR16_M1, 937 }, + { PseudoVFSUB_VFPR16_M2, 938 }, + { PseudoVFSUB_VFPR16_M4, 939 }, + { PseudoVFSUB_VFPR16_M8, 940 }, + { PseudoVFSUB_VFPR16_MF2, 941 }, + { PseudoVFSUB_VFPR16_MF4, 942 }, + { PseudoVFSUB_VFPR32_M1, 943 }, + { PseudoVFSUB_VFPR32_M2, 944 }, + { PseudoVFSUB_VFPR32_M4, 945 }, + { PseudoVFSUB_VFPR32_M8, 946 }, + { PseudoVFSUB_VFPR32_MF2, 947 }, + { PseudoVFSUB_VFPR64_M1, 948 }, + { PseudoVFSUB_VFPR64_M2, 949 }, + { PseudoVFSUB_VFPR64_M4, 950 }, + { PseudoVFSUB_VFPR64_M8, 951 }, + { PseudoVFSUB_VV_M1, 952 }, + { PseudoVFSUB_VV_M2, 953 }, + { PseudoVFSUB_VV_M4, 954 }, + { PseudoVFSUB_VV_M8, 955 }, + { PseudoVFSUB_VV_MF2, 956 }, + { PseudoVFSUB_VV_MF4, 957 }, + { PseudoVFWADD_VFPR16_M1, 958 }, + { PseudoVFWADD_VFPR16_M2, 959 }, + { PseudoVFWADD_VFPR16_M4, 960 }, + { PseudoVFWADD_VFPR16_MF2, 961 }, + { PseudoVFWADD_VFPR16_MF4, 962 }, + { PseudoVFWADD_VFPR32_M1, 963 }, + { PseudoVFWADD_VFPR32_M2, 964 }, + { PseudoVFWADD_VFPR32_M4, 965 }, + { PseudoVFWADD_VFPR32_MF2, 966 }, + { PseudoVFWADD_VV_M1, 967 }, + { PseudoVFWADD_VV_M2, 968 }, + { PseudoVFWADD_VV_M4, 969 }, + { PseudoVFWADD_VV_MF2, 970 }, + { PseudoVFWADD_VV_MF4, 971 }, + { PseudoVFWADD_WFPR16_M1, 972 }, + { PseudoVFWADD_WFPR16_M2, 973 }, + { PseudoVFWADD_WFPR16_M4, 974 }, + { PseudoVFWADD_WFPR16_MF2, 975 }, + { PseudoVFWADD_WFPR16_MF4, 976 }, + { PseudoVFWADD_WFPR32_M1, 977 }, + { PseudoVFWADD_WFPR32_M2, 978 }, + { PseudoVFWADD_WFPR32_M4, 979 }, + { PseudoVFWADD_WFPR32_MF2, 980 }, + { PseudoVFWADD_WV_M1, 981 }, + { PseudoVFWADD_WV_M2, 982 }, + { PseudoVFWADD_WV_M4, 983 }, + { PseudoVFWADD_WV_MF2, 984 }, + { PseudoVFWADD_WV_MF4, 985 }, + { PseudoVFWCVTBF16_F_F_V_M1, 986 }, + { PseudoVFWCVTBF16_F_F_V_M2, 987 }, + { PseudoVFWCVTBF16_F_F_V_M4, 988 }, + { PseudoVFWCVTBF16_F_F_V_MF2, 989 }, + { PseudoVFWCVTBF16_F_F_V_MF4, 990 }, + { PseudoVFWCVT_F_F_V_M1, 991 }, + { PseudoVFWCVT_F_F_V_M2, 992 }, + { PseudoVFWCVT_F_F_V_M4, 993 }, + { PseudoVFWCVT_F_F_V_MF2, 994 }, + { PseudoVFWCVT_F_F_V_MF4, 995 }, + { PseudoVFWCVT_F_XU_V_M1, 996 }, + { PseudoVFWCVT_F_XU_V_M2, 997 }, + { PseudoVFWCVT_F_XU_V_M4, 998 }, + { PseudoVFWCVT_F_XU_V_MF2, 999 }, + { PseudoVFWCVT_F_XU_V_MF4, 1000 }, + { PseudoVFWCVT_F_XU_V_MF8, 1001 }, + { PseudoVFWCVT_F_X_V_M1, 1002 }, + { PseudoVFWCVT_F_X_V_M2, 1003 }, + { PseudoVFWCVT_F_X_V_M4, 1004 }, + { PseudoVFWCVT_F_X_V_MF2, 1005 }, + { PseudoVFWCVT_F_X_V_MF4, 1006 }, + { PseudoVFWCVT_F_X_V_MF8, 1007 }, + { PseudoVFWCVT_RM_XU_F_V_M1, 1008 }, + { PseudoVFWCVT_RM_XU_F_V_M2, 1009 }, + { PseudoVFWCVT_RM_XU_F_V_M4, 1010 }, + { PseudoVFWCVT_RM_XU_F_V_MF2, 1011 }, + { PseudoVFWCVT_RM_XU_F_V_MF4, 1012 }, + { PseudoVFWCVT_RM_X_F_V_M1, 1013 }, + { PseudoVFWCVT_RM_X_F_V_M2, 1014 }, + { PseudoVFWCVT_RM_X_F_V_M4, 1015 }, + { PseudoVFWCVT_RM_X_F_V_MF2, 1016 }, + { PseudoVFWCVT_RM_X_F_V_MF4, 1017 }, + { PseudoVFWCVT_RTZ_XU_F_V_M1, 1018 }, + { PseudoVFWCVT_RTZ_XU_F_V_M2, 1019 }, + { PseudoVFWCVT_RTZ_XU_F_V_M4, 1020 }, + { PseudoVFWCVT_RTZ_XU_F_V_MF2, 1021 }, + { PseudoVFWCVT_RTZ_XU_F_V_MF4, 1022 }, + { PseudoVFWCVT_RTZ_X_F_V_M1, 1023 }, + { PseudoVFWCVT_RTZ_X_F_V_M2, 1024 }, + { PseudoVFWCVT_RTZ_X_F_V_M4, 1025 }, + { PseudoVFWCVT_RTZ_X_F_V_MF2, 1026 }, + { PseudoVFWCVT_RTZ_X_F_V_MF4, 1027 }, + { PseudoVFWCVT_XU_F_V_M1, 1028 }, + { PseudoVFWCVT_XU_F_V_M2, 1029 }, + { PseudoVFWCVT_XU_F_V_M4, 1030 }, + { PseudoVFWCVT_XU_F_V_MF2, 1031 }, + { PseudoVFWCVT_XU_F_V_MF4, 1032 }, + { PseudoVFWCVT_X_F_V_M1, 1033 }, + { PseudoVFWCVT_X_F_V_M2, 1034 }, + { PseudoVFWCVT_X_F_V_M4, 1035 }, + { PseudoVFWCVT_X_F_V_MF2, 1036 }, + { PseudoVFWCVT_X_F_V_MF4, 1037 }, + { PseudoVFWMACCBF16_VFPR16_M1, 1038 }, + { PseudoVFWMACCBF16_VFPR16_M2, 1039 }, + { PseudoVFWMACCBF16_VFPR16_M4, 1040 }, + { PseudoVFWMACCBF16_VFPR16_MF2, 1041 }, + { PseudoVFWMACCBF16_VFPR16_MF4, 1042 }, + { PseudoVFWMACCBF16_VV_M1, 1043 }, + { PseudoVFWMACCBF16_VV_M2, 1044 }, + { PseudoVFWMACCBF16_VV_M4, 1045 }, + { PseudoVFWMACCBF16_VV_MF2, 1046 }, + { PseudoVFWMACCBF16_VV_MF4, 1047 }, + { PseudoVFWMACC_VFPR16_M1, 1048 }, + { PseudoVFWMACC_VFPR16_M2, 1049 }, + { PseudoVFWMACC_VFPR16_M4, 1050 }, + { PseudoVFWMACC_VFPR16_MF2, 1051 }, + { PseudoVFWMACC_VFPR16_MF4, 1052 }, + { PseudoVFWMACC_VFPR32_M1, 1053 }, + { PseudoVFWMACC_VFPR32_M2, 1054 }, + { PseudoVFWMACC_VFPR32_M4, 1055 }, + { PseudoVFWMACC_VFPR32_MF2, 1056 }, + { PseudoVFWMACC_VV_M1, 1057 }, + { PseudoVFWMACC_VV_M2, 1058 }, + { PseudoVFWMACC_VV_M4, 1059 }, + { PseudoVFWMACC_VV_MF2, 1060 }, + { PseudoVFWMACC_VV_MF4, 1061 }, + { PseudoVFWMSAC_VFPR16_M1, 1062 }, + { PseudoVFWMSAC_VFPR16_M2, 1063 }, + { PseudoVFWMSAC_VFPR16_M4, 1064 }, + { PseudoVFWMSAC_VFPR16_MF2, 1065 }, + { PseudoVFWMSAC_VFPR16_MF4, 1066 }, + { PseudoVFWMSAC_VFPR32_M1, 1067 }, + { PseudoVFWMSAC_VFPR32_M2, 1068 }, + { PseudoVFWMSAC_VFPR32_M4, 1069 }, + { PseudoVFWMSAC_VFPR32_MF2, 1070 }, + { PseudoVFWMSAC_VV_M1, 1071 }, + { PseudoVFWMSAC_VV_M2, 1072 }, + { PseudoVFWMSAC_VV_M4, 1073 }, + { PseudoVFWMSAC_VV_MF2, 1074 }, + { PseudoVFWMSAC_VV_MF4, 1075 }, + { PseudoVFWMUL_VFPR16_M1, 1076 }, + { PseudoVFWMUL_VFPR16_M2, 1077 }, + { PseudoVFWMUL_VFPR16_M4, 1078 }, + { PseudoVFWMUL_VFPR16_MF2, 1079 }, + { PseudoVFWMUL_VFPR16_MF4, 1080 }, + { PseudoVFWMUL_VFPR32_M1, 1081 }, + { PseudoVFWMUL_VFPR32_M2, 1082 }, + { PseudoVFWMUL_VFPR32_M4, 1083 }, + { PseudoVFWMUL_VFPR32_MF2, 1084 }, + { PseudoVFWMUL_VV_M1, 1085 }, + { PseudoVFWMUL_VV_M2, 1086 }, + { PseudoVFWMUL_VV_M4, 1087 }, + { PseudoVFWMUL_VV_MF2, 1088 }, + { PseudoVFWMUL_VV_MF4, 1089 }, + { PseudoVFWNMACC_VFPR16_M1, 1090 }, + { PseudoVFWNMACC_VFPR16_M2, 1091 }, + { PseudoVFWNMACC_VFPR16_M4, 1092 }, + { PseudoVFWNMACC_VFPR16_MF2, 1093 }, + { PseudoVFWNMACC_VFPR16_MF4, 1094 }, + { PseudoVFWNMACC_VFPR32_M1, 1095 }, + { PseudoVFWNMACC_VFPR32_M2, 1096 }, + { PseudoVFWNMACC_VFPR32_M4, 1097 }, + { PseudoVFWNMACC_VFPR32_MF2, 1098 }, + { PseudoVFWNMACC_VV_M1, 1099 }, + { PseudoVFWNMACC_VV_M2, 1100 }, + { PseudoVFWNMACC_VV_M4, 1101 }, + { PseudoVFWNMACC_VV_MF2, 1102 }, + { PseudoVFWNMACC_VV_MF4, 1103 }, + { PseudoVFWNMSAC_VFPR16_M1, 1104 }, + { PseudoVFWNMSAC_VFPR16_M2, 1105 }, + { PseudoVFWNMSAC_VFPR16_M4, 1106 }, + { PseudoVFWNMSAC_VFPR16_MF2, 1107 }, + { PseudoVFWNMSAC_VFPR16_MF4, 1108 }, + { PseudoVFWNMSAC_VFPR32_M1, 1109 }, + { PseudoVFWNMSAC_VFPR32_M2, 1110 }, + { PseudoVFWNMSAC_VFPR32_M4, 1111 }, + { PseudoVFWNMSAC_VFPR32_MF2, 1112 }, + { PseudoVFWNMSAC_VV_M1, 1113 }, + { PseudoVFWNMSAC_VV_M2, 1114 }, + { PseudoVFWNMSAC_VV_M4, 1115 }, + { PseudoVFWNMSAC_VV_MF2, 1116 }, + { PseudoVFWNMSAC_VV_MF4, 1117 }, + { PseudoVFWREDOSUM_VS_M1_E16, 1118 }, + { PseudoVFWREDOSUM_VS_M1_E32, 1119 }, + { PseudoVFWREDOSUM_VS_M2_E16, 1120 }, + { PseudoVFWREDOSUM_VS_M2_E32, 1121 }, + { PseudoVFWREDOSUM_VS_M4_E16, 1122 }, + { PseudoVFWREDOSUM_VS_M4_E32, 1123 }, + { PseudoVFWREDOSUM_VS_M8_E16, 1124 }, + { PseudoVFWREDOSUM_VS_M8_E32, 1125 }, + { PseudoVFWREDOSUM_VS_MF2_E16, 1126 }, + { PseudoVFWREDOSUM_VS_MF2_E32, 1127 }, + { PseudoVFWREDOSUM_VS_MF4_E16, 1128 }, + { PseudoVFWREDUSUM_VS_M1_E16, 1129 }, + { PseudoVFWREDUSUM_VS_M1_E32, 1130 }, + { PseudoVFWREDUSUM_VS_M2_E16, 1131 }, + { PseudoVFWREDUSUM_VS_M2_E32, 1132 }, + { PseudoVFWREDUSUM_VS_M4_E16, 1133 }, + { PseudoVFWREDUSUM_VS_M4_E32, 1134 }, + { PseudoVFWREDUSUM_VS_M8_E16, 1135 }, + { PseudoVFWREDUSUM_VS_M8_E32, 1136 }, + { PseudoVFWREDUSUM_VS_MF2_E16, 1137 }, + { PseudoVFWREDUSUM_VS_MF2_E32, 1138 }, + { PseudoVFWREDUSUM_VS_MF4_E16, 1139 }, + { PseudoVFWSUB_VFPR16_M1, 1140 }, + { PseudoVFWSUB_VFPR16_M2, 1141 }, + { PseudoVFWSUB_VFPR16_M4, 1142 }, + { PseudoVFWSUB_VFPR16_MF2, 1143 }, + { PseudoVFWSUB_VFPR16_MF4, 1144 }, + { PseudoVFWSUB_VFPR32_M1, 1145 }, + { PseudoVFWSUB_VFPR32_M2, 1146 }, + { PseudoVFWSUB_VFPR32_M4, 1147 }, + { PseudoVFWSUB_VFPR32_MF2, 1148 }, + { PseudoVFWSUB_VV_M1, 1149 }, + { PseudoVFWSUB_VV_M2, 1150 }, + { PseudoVFWSUB_VV_M4, 1151 }, + { PseudoVFWSUB_VV_MF2, 1152 }, + { PseudoVFWSUB_VV_MF4, 1153 }, + { PseudoVFWSUB_WFPR16_M1, 1154 }, + { PseudoVFWSUB_WFPR16_M2, 1155 }, + { PseudoVFWSUB_WFPR16_M4, 1156 }, + { PseudoVFWSUB_WFPR16_MF2, 1157 }, + { PseudoVFWSUB_WFPR16_MF4, 1158 }, + { PseudoVFWSUB_WFPR32_M1, 1159 }, + { PseudoVFWSUB_WFPR32_M2, 1160 }, + { PseudoVFWSUB_WFPR32_M4, 1161 }, + { PseudoVFWSUB_WFPR32_MF2, 1162 }, + { PseudoVFWSUB_WV_M1, 1163 }, + { PseudoVFWSUB_WV_M2, 1164 }, + { PseudoVFWSUB_WV_M4, 1165 }, + { PseudoVFWSUB_WV_MF2, 1166 }, + { PseudoVFWSUB_WV_MF4, 1167 }, + { PseudoVID_V_M1, 1168 }, + { PseudoVID_V_M2, 1169 }, + { PseudoVID_V_M4, 1170 }, + { PseudoVID_V_M8, 1171 }, + { PseudoVID_V_MF2, 1172 }, + { PseudoVID_V_MF4, 1173 }, + { PseudoVID_V_MF8, 1174 }, + { PseudoVIOTA_M_M1, 1175 }, + { PseudoVIOTA_M_M2, 1176 }, + { PseudoVIOTA_M_M4, 1177 }, + { PseudoVIOTA_M_M8, 1178 }, + { PseudoVIOTA_M_MF2, 1179 }, + { PseudoVIOTA_M_MF4, 1180 }, + { PseudoVIOTA_M_MF8, 1181 }, + { PseudoVLE16FF_V_M1, 1182 }, + { PseudoVLE16FF_V_M2, 1183 }, + { PseudoVLE16FF_V_M4, 1184 }, + { PseudoVLE16FF_V_M8, 1185 }, + { PseudoVLE16FF_V_MF2, 1186 }, + { PseudoVLE16FF_V_MF4, 1187 }, + { PseudoVLE16_V_M1, 1188 }, + { PseudoVLE16_V_M2, 1189 }, + { PseudoVLE16_V_M4, 1190 }, + { PseudoVLE16_V_M8, 1191 }, + { PseudoVLE16_V_MF2, 1192 }, + { PseudoVLE16_V_MF4, 1193 }, + { PseudoVLE32FF_V_M1, 1194 }, + { PseudoVLE32FF_V_M2, 1195 }, + { PseudoVLE32FF_V_M4, 1196 }, + { PseudoVLE32FF_V_M8, 1197 }, + { PseudoVLE32FF_V_MF2, 1198 }, + { PseudoVLE32_V_M1, 1199 }, + { PseudoVLE32_V_M2, 1200 }, + { PseudoVLE32_V_M4, 1201 }, + { PseudoVLE32_V_M8, 1202 }, + { PseudoVLE32_V_MF2, 1203 }, + { PseudoVLE64FF_V_M1, 1204 }, + { PseudoVLE64FF_V_M2, 1205 }, + { PseudoVLE64FF_V_M4, 1206 }, + { PseudoVLE64FF_V_M8, 1207 }, + { PseudoVLE64_V_M1, 1208 }, + { PseudoVLE64_V_M2, 1209 }, + { PseudoVLE64_V_M4, 1210 }, + { PseudoVLE64_V_M8, 1211 }, + { PseudoVLE8FF_V_M1, 1212 }, + { PseudoVLE8FF_V_M2, 1213 }, + { PseudoVLE8FF_V_M4, 1214 }, + { PseudoVLE8FF_V_M8, 1215 }, + { PseudoVLE8FF_V_MF2, 1216 }, + { PseudoVLE8FF_V_MF4, 1217 }, + { PseudoVLE8FF_V_MF8, 1218 }, + { PseudoVLE8_V_M1, 1219 }, + { PseudoVLE8_V_M2, 1220 }, + { PseudoVLE8_V_M4, 1221 }, + { PseudoVLE8_V_M8, 1222 }, + { PseudoVLE8_V_MF2, 1223 }, + { PseudoVLE8_V_MF4, 1224 }, + { PseudoVLE8_V_MF8, 1225 }, + { PseudoVLOXEI16_V_M1_M1, 1226 }, + { PseudoVLOXEI16_V_M1_M2, 1227 }, + { PseudoVLOXEI16_V_M1_M4, 1228 }, + { PseudoVLOXEI16_V_M1_MF2, 1229 }, + { PseudoVLOXEI16_V_M2_M1, 1230 }, + { PseudoVLOXEI16_V_M2_M2, 1231 }, + { PseudoVLOXEI16_V_M2_M4, 1232 }, + { PseudoVLOXEI16_V_M2_M8, 1233 }, + { PseudoVLOXEI16_V_M4_M2, 1234 }, + { PseudoVLOXEI16_V_M4_M4, 1235 }, + { PseudoVLOXEI16_V_M4_M8, 1236 }, + { PseudoVLOXEI16_V_M8_M4, 1237 }, + { PseudoVLOXEI16_V_M8_M8, 1238 }, + { PseudoVLOXEI16_V_MF2_M1, 1239 }, + { PseudoVLOXEI16_V_MF2_M2, 1240 }, + { PseudoVLOXEI16_V_MF2_MF2, 1241 }, + { PseudoVLOXEI16_V_MF2_MF4, 1242 }, + { PseudoVLOXEI16_V_MF4_M1, 1243 }, + { PseudoVLOXEI16_V_MF4_MF2, 1244 }, + { PseudoVLOXEI16_V_MF4_MF4, 1245 }, + { PseudoVLOXEI16_V_MF4_MF8, 1246 }, + { PseudoVLOXEI32_V_M1_M1, 1247 }, + { PseudoVLOXEI32_V_M1_M2, 1248 }, + { PseudoVLOXEI32_V_M1_MF2, 1249 }, + { PseudoVLOXEI32_V_M1_MF4, 1250 }, + { PseudoVLOXEI32_V_M2_M1, 1251 }, + { PseudoVLOXEI32_V_M2_M2, 1252 }, + { PseudoVLOXEI32_V_M2_M4, 1253 }, + { PseudoVLOXEI32_V_M2_MF2, 1254 }, + { PseudoVLOXEI32_V_M4_M1, 1255 }, + { PseudoVLOXEI32_V_M4_M2, 1256 }, + { PseudoVLOXEI32_V_M4_M4, 1257 }, + { PseudoVLOXEI32_V_M4_M8, 1258 }, + { PseudoVLOXEI32_V_M8_M2, 1259 }, + { PseudoVLOXEI32_V_M8_M4, 1260 }, + { PseudoVLOXEI32_V_M8_M8, 1261 }, + { PseudoVLOXEI32_V_MF2_M1, 1262 }, + { PseudoVLOXEI32_V_MF2_MF2, 1263 }, + { PseudoVLOXEI32_V_MF2_MF4, 1264 }, + { PseudoVLOXEI32_V_MF2_MF8, 1265 }, + { PseudoVLOXEI64_V_M1_M1, 1266 }, + { PseudoVLOXEI64_V_M1_MF2, 1267 }, + { PseudoVLOXEI64_V_M1_MF4, 1268 }, + { PseudoVLOXEI64_V_M1_MF8, 1269 }, + { PseudoVLOXEI64_V_M2_M1, 1270 }, + { PseudoVLOXEI64_V_M2_M2, 1271 }, + { PseudoVLOXEI64_V_M2_MF2, 1272 }, + { PseudoVLOXEI64_V_M2_MF4, 1273 }, + { PseudoVLOXEI64_V_M4_M1, 1274 }, + { PseudoVLOXEI64_V_M4_M2, 1275 }, + { PseudoVLOXEI64_V_M4_M4, 1276 }, + { PseudoVLOXEI64_V_M4_MF2, 1277 }, + { PseudoVLOXEI64_V_M8_M1, 1278 }, + { PseudoVLOXEI64_V_M8_M2, 1279 }, + { PseudoVLOXEI64_V_M8_M4, 1280 }, + { PseudoVLOXEI64_V_M8_M8, 1281 }, + { PseudoVLOXEI8_V_M1_M1, 1282 }, + { PseudoVLOXEI8_V_M1_M2, 1283 }, + { PseudoVLOXEI8_V_M1_M4, 1284 }, + { PseudoVLOXEI8_V_M1_M8, 1285 }, + { PseudoVLOXEI8_V_M2_M2, 1286 }, + { PseudoVLOXEI8_V_M2_M4, 1287 }, + { PseudoVLOXEI8_V_M2_M8, 1288 }, + { PseudoVLOXEI8_V_M4_M4, 1289 }, + { PseudoVLOXEI8_V_M4_M8, 1290 }, + { PseudoVLOXEI8_V_M8_M8, 1291 }, + { PseudoVLOXEI8_V_MF2_M1, 1292 }, + { PseudoVLOXEI8_V_MF2_M2, 1293 }, + { PseudoVLOXEI8_V_MF2_M4, 1294 }, + { PseudoVLOXEI8_V_MF2_MF2, 1295 }, + { PseudoVLOXEI8_V_MF4_M1, 1296 }, + { PseudoVLOXEI8_V_MF4_M2, 1297 }, + { PseudoVLOXEI8_V_MF4_MF2, 1298 }, + { PseudoVLOXEI8_V_MF4_MF4, 1299 }, + { PseudoVLOXEI8_V_MF8_M1, 1300 }, + { PseudoVLOXEI8_V_MF8_MF2, 1301 }, + { PseudoVLOXEI8_V_MF8_MF4, 1302 }, + { PseudoVLOXEI8_V_MF8_MF8, 1303 }, + { PseudoVLSE16_V_M1, 1304 }, + { PseudoVLSE16_V_M2, 1305 }, + { PseudoVLSE16_V_M4, 1306 }, + { PseudoVLSE16_V_M8, 1307 }, + { PseudoVLSE16_V_MF2, 1308 }, + { PseudoVLSE16_V_MF4, 1309 }, + { PseudoVLSE32_V_M1, 1310 }, + { PseudoVLSE32_V_M2, 1311 }, + { PseudoVLSE32_V_M4, 1312 }, + { PseudoVLSE32_V_M8, 1313 }, + { PseudoVLSE32_V_MF2, 1314 }, + { PseudoVLSE64_V_M1, 1315 }, + { PseudoVLSE64_V_M2, 1316 }, + { PseudoVLSE64_V_M4, 1317 }, + { PseudoVLSE64_V_M8, 1318 }, + { PseudoVLSE8_V_M1, 1319 }, + { PseudoVLSE8_V_M2, 1320 }, + { PseudoVLSE8_V_M4, 1321 }, + { PseudoVLSE8_V_M8, 1322 }, + { PseudoVLSE8_V_MF2, 1323 }, + { PseudoVLSE8_V_MF4, 1324 }, + { PseudoVLSE8_V_MF8, 1325 }, + { PseudoVLUXEI16_V_M1_M1, 1326 }, + { PseudoVLUXEI16_V_M1_M2, 1327 }, + { PseudoVLUXEI16_V_M1_M4, 1328 }, + { PseudoVLUXEI16_V_M1_MF2, 1329 }, + { PseudoVLUXEI16_V_M2_M1, 1330 }, + { PseudoVLUXEI16_V_M2_M2, 1331 }, + { PseudoVLUXEI16_V_M2_M4, 1332 }, + { PseudoVLUXEI16_V_M2_M8, 1333 }, + { PseudoVLUXEI16_V_M4_M2, 1334 }, + { PseudoVLUXEI16_V_M4_M4, 1335 }, + { PseudoVLUXEI16_V_M4_M8, 1336 }, + { PseudoVLUXEI16_V_M8_M4, 1337 }, + { PseudoVLUXEI16_V_M8_M8, 1338 }, + { PseudoVLUXEI16_V_MF2_M1, 1339 }, + { PseudoVLUXEI16_V_MF2_M2, 1340 }, + { PseudoVLUXEI16_V_MF2_MF2, 1341 }, + { PseudoVLUXEI16_V_MF2_MF4, 1342 }, + { PseudoVLUXEI16_V_MF4_M1, 1343 }, + { PseudoVLUXEI16_V_MF4_MF2, 1344 }, + { PseudoVLUXEI16_V_MF4_MF4, 1345 }, + { PseudoVLUXEI16_V_MF4_MF8, 1346 }, + { PseudoVLUXEI32_V_M1_M1, 1347 }, + { PseudoVLUXEI32_V_M1_M2, 1348 }, + { PseudoVLUXEI32_V_M1_MF2, 1349 }, + { PseudoVLUXEI32_V_M1_MF4, 1350 }, + { PseudoVLUXEI32_V_M2_M1, 1351 }, + { PseudoVLUXEI32_V_M2_M2, 1352 }, + { PseudoVLUXEI32_V_M2_M4, 1353 }, + { PseudoVLUXEI32_V_M2_MF2, 1354 }, + { PseudoVLUXEI32_V_M4_M1, 1355 }, + { PseudoVLUXEI32_V_M4_M2, 1356 }, + { PseudoVLUXEI32_V_M4_M4, 1357 }, + { PseudoVLUXEI32_V_M4_M8, 1358 }, + { PseudoVLUXEI32_V_M8_M2, 1359 }, + { PseudoVLUXEI32_V_M8_M4, 1360 }, + { PseudoVLUXEI32_V_M8_M8, 1361 }, + { PseudoVLUXEI32_V_MF2_M1, 1362 }, + { PseudoVLUXEI32_V_MF2_MF2, 1363 }, + { PseudoVLUXEI32_V_MF2_MF4, 1364 }, + { PseudoVLUXEI32_V_MF2_MF8, 1365 }, + { PseudoVLUXEI64_V_M1_M1, 1366 }, + { PseudoVLUXEI64_V_M1_MF2, 1367 }, + { PseudoVLUXEI64_V_M1_MF4, 1368 }, + { PseudoVLUXEI64_V_M1_MF8, 1369 }, + { PseudoVLUXEI64_V_M2_M1, 1370 }, + { PseudoVLUXEI64_V_M2_M2, 1371 }, + { PseudoVLUXEI64_V_M2_MF2, 1372 }, + { PseudoVLUXEI64_V_M2_MF4, 1373 }, + { PseudoVLUXEI64_V_M4_M1, 1374 }, + { PseudoVLUXEI64_V_M4_M2, 1375 }, + { PseudoVLUXEI64_V_M4_M4, 1376 }, + { PseudoVLUXEI64_V_M4_MF2, 1377 }, + { PseudoVLUXEI64_V_M8_M1, 1378 }, + { PseudoVLUXEI64_V_M8_M2, 1379 }, + { PseudoVLUXEI64_V_M8_M4, 1380 }, + { PseudoVLUXEI64_V_M8_M8, 1381 }, + { PseudoVLUXEI8_V_M1_M1, 1382 }, + { PseudoVLUXEI8_V_M1_M2, 1383 }, + { PseudoVLUXEI8_V_M1_M4, 1384 }, + { PseudoVLUXEI8_V_M1_M8, 1385 }, + { PseudoVLUXEI8_V_M2_M2, 1386 }, + { PseudoVLUXEI8_V_M2_M4, 1387 }, + { PseudoVLUXEI8_V_M2_M8, 1388 }, + { PseudoVLUXEI8_V_M4_M4, 1389 }, + { PseudoVLUXEI8_V_M4_M8, 1390 }, + { PseudoVLUXEI8_V_M8_M8, 1391 }, + { PseudoVLUXEI8_V_MF2_M1, 1392 }, + { PseudoVLUXEI8_V_MF2_M2, 1393 }, + { PseudoVLUXEI8_V_MF2_M4, 1394 }, + { PseudoVLUXEI8_V_MF2_MF2, 1395 }, + { PseudoVLUXEI8_V_MF4_M1, 1396 }, + { PseudoVLUXEI8_V_MF4_M2, 1397 }, + { PseudoVLUXEI8_V_MF4_MF2, 1398 }, + { PseudoVLUXEI8_V_MF4_MF4, 1399 }, + { PseudoVLUXEI8_V_MF8_M1, 1400 }, + { PseudoVLUXEI8_V_MF8_MF2, 1401 }, + { PseudoVLUXEI8_V_MF8_MF4, 1402 }, + { PseudoVLUXEI8_V_MF8_MF8, 1403 }, + { PseudoVMACC_VV_M1, 1404 }, + { PseudoVMACC_VV_M2, 1405 }, + { PseudoVMACC_VV_M4, 1406 }, + { PseudoVMACC_VV_M8, 1407 }, + { PseudoVMACC_VV_MF2, 1408 }, + { PseudoVMACC_VV_MF4, 1409 }, + { PseudoVMACC_VV_MF8, 1410 }, + { PseudoVMACC_VX_M1, 1411 }, + { PseudoVMACC_VX_M2, 1412 }, + { PseudoVMACC_VX_M4, 1413 }, + { PseudoVMACC_VX_M8, 1414 }, + { PseudoVMACC_VX_MF2, 1415 }, + { PseudoVMACC_VX_MF4, 1416 }, + { PseudoVMACC_VX_MF8, 1417 }, + { PseudoVMADD_VV_M1, 1418 }, + { PseudoVMADD_VV_M2, 1419 }, + { PseudoVMADD_VV_M4, 1420 }, + { PseudoVMADD_VV_M8, 1421 }, + { PseudoVMADD_VV_MF2, 1422 }, + { PseudoVMADD_VV_MF4, 1423 }, + { PseudoVMADD_VV_MF8, 1424 }, + { PseudoVMADD_VX_M1, 1425 }, + { PseudoVMADD_VX_M2, 1426 }, + { PseudoVMADD_VX_M4, 1427 }, + { PseudoVMADD_VX_M8, 1428 }, + { PseudoVMADD_VX_MF2, 1429 }, + { PseudoVMADD_VX_MF4, 1430 }, + { PseudoVMADD_VX_MF8, 1431 }, + { PseudoVMAXU_VV_M1, 1432 }, + { PseudoVMAXU_VV_M2, 1433 }, + { PseudoVMAXU_VV_M4, 1434 }, + { PseudoVMAXU_VV_M8, 1435 }, + { PseudoVMAXU_VV_MF2, 1436 }, + { PseudoVMAXU_VV_MF4, 1437 }, + { PseudoVMAXU_VV_MF8, 1438 }, + { PseudoVMAXU_VX_M1, 1439 }, + { PseudoVMAXU_VX_M2, 1440 }, + { PseudoVMAXU_VX_M4, 1441 }, + { PseudoVMAXU_VX_M8, 1442 }, + { PseudoVMAXU_VX_MF2, 1443 }, + { PseudoVMAXU_VX_MF4, 1444 }, + { PseudoVMAXU_VX_MF8, 1445 }, + { PseudoVMAX_VV_M1, 1446 }, + { PseudoVMAX_VV_M2, 1447 }, + { PseudoVMAX_VV_M4, 1448 }, + { PseudoVMAX_VV_M8, 1449 }, + { PseudoVMAX_VV_MF2, 1450 }, + { PseudoVMAX_VV_MF4, 1451 }, + { PseudoVMAX_VV_MF8, 1452 }, + { PseudoVMAX_VX_M1, 1453 }, + { PseudoVMAX_VX_M2, 1454 }, + { PseudoVMAX_VX_M4, 1455 }, + { PseudoVMAX_VX_M8, 1456 }, + { PseudoVMAX_VX_MF2, 1457 }, + { PseudoVMAX_VX_MF4, 1458 }, + { PseudoVMAX_VX_MF8, 1459 }, + { PseudoVMFEQ_VFPR16_M1, 1460 }, + { PseudoVMFEQ_VFPR16_M2, 1461 }, + { PseudoVMFEQ_VFPR16_M4, 1462 }, + { PseudoVMFEQ_VFPR16_M8, 1463 }, + { PseudoVMFEQ_VFPR16_MF2, 1464 }, + { PseudoVMFEQ_VFPR16_MF4, 1465 }, + { PseudoVMFEQ_VFPR32_M1, 1466 }, + { PseudoVMFEQ_VFPR32_M2, 1467 }, + { PseudoVMFEQ_VFPR32_M4, 1468 }, + { PseudoVMFEQ_VFPR32_M8, 1469 }, + { PseudoVMFEQ_VFPR32_MF2, 1470 }, + { PseudoVMFEQ_VFPR64_M1, 1471 }, + { PseudoVMFEQ_VFPR64_M2, 1472 }, + { PseudoVMFEQ_VFPR64_M4, 1473 }, + { PseudoVMFEQ_VFPR64_M8, 1474 }, + { PseudoVMFEQ_VV_M1, 1475 }, + { PseudoVMFEQ_VV_M2, 1476 }, + { PseudoVMFEQ_VV_M4, 1477 }, + { PseudoVMFEQ_VV_M8, 1478 }, + { PseudoVMFEQ_VV_MF2, 1479 }, + { PseudoVMFEQ_VV_MF4, 1480 }, + { PseudoVMFGE_VFPR16_M1, 1481 }, + { PseudoVMFGE_VFPR16_M2, 1482 }, + { PseudoVMFGE_VFPR16_M4, 1483 }, + { PseudoVMFGE_VFPR16_M8, 1484 }, + { PseudoVMFGE_VFPR16_MF2, 1485 }, + { PseudoVMFGE_VFPR16_MF4, 1486 }, + { PseudoVMFGE_VFPR32_M1, 1487 }, + { PseudoVMFGE_VFPR32_M2, 1488 }, + { PseudoVMFGE_VFPR32_M4, 1489 }, + { PseudoVMFGE_VFPR32_M8, 1490 }, + { PseudoVMFGE_VFPR32_MF2, 1491 }, + { PseudoVMFGE_VFPR64_M1, 1492 }, + { PseudoVMFGE_VFPR64_M2, 1493 }, + { PseudoVMFGE_VFPR64_M4, 1494 }, + { PseudoVMFGE_VFPR64_M8, 1495 }, + { PseudoVMFGT_VFPR16_M1, 1496 }, + { PseudoVMFGT_VFPR16_M2, 1497 }, + { PseudoVMFGT_VFPR16_M4, 1498 }, + { PseudoVMFGT_VFPR16_M8, 1499 }, + { PseudoVMFGT_VFPR16_MF2, 1500 }, + { PseudoVMFGT_VFPR16_MF4, 1501 }, + { PseudoVMFGT_VFPR32_M1, 1502 }, + { PseudoVMFGT_VFPR32_M2, 1503 }, + { PseudoVMFGT_VFPR32_M4, 1504 }, + { PseudoVMFGT_VFPR32_M8, 1505 }, + { PseudoVMFGT_VFPR32_MF2, 1506 }, + { PseudoVMFGT_VFPR64_M1, 1507 }, + { PseudoVMFGT_VFPR64_M2, 1508 }, + { PseudoVMFGT_VFPR64_M4, 1509 }, + { PseudoVMFGT_VFPR64_M8, 1510 }, + { PseudoVMFLE_VFPR16_M1, 1511 }, + { PseudoVMFLE_VFPR16_M2, 1512 }, + { PseudoVMFLE_VFPR16_M4, 1513 }, + { PseudoVMFLE_VFPR16_M8, 1514 }, + { PseudoVMFLE_VFPR16_MF2, 1515 }, + { PseudoVMFLE_VFPR16_MF4, 1516 }, + { PseudoVMFLE_VFPR32_M1, 1517 }, + { PseudoVMFLE_VFPR32_M2, 1518 }, + { PseudoVMFLE_VFPR32_M4, 1519 }, + { PseudoVMFLE_VFPR32_M8, 1520 }, + { PseudoVMFLE_VFPR32_MF2, 1521 }, + { PseudoVMFLE_VFPR64_M1, 1522 }, + { PseudoVMFLE_VFPR64_M2, 1523 }, + { PseudoVMFLE_VFPR64_M4, 1524 }, + { PseudoVMFLE_VFPR64_M8, 1525 }, + { PseudoVMFLE_VV_M1, 1526 }, + { PseudoVMFLE_VV_M2, 1527 }, + { PseudoVMFLE_VV_M4, 1528 }, + { PseudoVMFLE_VV_M8, 1529 }, + { PseudoVMFLE_VV_MF2, 1530 }, + { PseudoVMFLE_VV_MF4, 1531 }, + { PseudoVMFLT_VFPR16_M1, 1532 }, + { PseudoVMFLT_VFPR16_M2, 1533 }, + { PseudoVMFLT_VFPR16_M4, 1534 }, + { PseudoVMFLT_VFPR16_M8, 1535 }, + { PseudoVMFLT_VFPR16_MF2, 1536 }, + { PseudoVMFLT_VFPR16_MF4, 1537 }, + { PseudoVMFLT_VFPR32_M1, 1538 }, + { PseudoVMFLT_VFPR32_M2, 1539 }, + { PseudoVMFLT_VFPR32_M4, 1540 }, + { PseudoVMFLT_VFPR32_M8, 1541 }, + { PseudoVMFLT_VFPR32_MF2, 1542 }, + { PseudoVMFLT_VFPR64_M1, 1543 }, + { PseudoVMFLT_VFPR64_M2, 1544 }, + { PseudoVMFLT_VFPR64_M4, 1545 }, + { PseudoVMFLT_VFPR64_M8, 1546 }, + { PseudoVMFLT_VV_M1, 1547 }, + { PseudoVMFLT_VV_M2, 1548 }, + { PseudoVMFLT_VV_M4, 1549 }, + { PseudoVMFLT_VV_M8, 1550 }, + { PseudoVMFLT_VV_MF2, 1551 }, + { PseudoVMFLT_VV_MF4, 1552 }, + { PseudoVMFNE_VFPR16_M1, 1553 }, + { PseudoVMFNE_VFPR16_M2, 1554 }, + { PseudoVMFNE_VFPR16_M4, 1555 }, + { PseudoVMFNE_VFPR16_M8, 1556 }, + { PseudoVMFNE_VFPR16_MF2, 1557 }, + { PseudoVMFNE_VFPR16_MF4, 1558 }, + { PseudoVMFNE_VFPR32_M1, 1559 }, + { PseudoVMFNE_VFPR32_M2, 1560 }, + { PseudoVMFNE_VFPR32_M4, 1561 }, + { PseudoVMFNE_VFPR32_M8, 1562 }, + { PseudoVMFNE_VFPR32_MF2, 1563 }, + { PseudoVMFNE_VFPR64_M1, 1564 }, + { PseudoVMFNE_VFPR64_M2, 1565 }, + { PseudoVMFNE_VFPR64_M4, 1566 }, + { PseudoVMFNE_VFPR64_M8, 1567 }, + { PseudoVMFNE_VV_M1, 1568 }, + { PseudoVMFNE_VV_M2, 1569 }, + { PseudoVMFNE_VV_M4, 1570 }, + { PseudoVMFNE_VV_M8, 1571 }, + { PseudoVMFNE_VV_MF2, 1572 }, + { PseudoVMFNE_VV_MF4, 1573 }, + { PseudoVMINU_VV_M1, 1574 }, + { PseudoVMINU_VV_M2, 1575 }, + { PseudoVMINU_VV_M4, 1576 }, + { PseudoVMINU_VV_M8, 1577 }, + { PseudoVMINU_VV_MF2, 1578 }, + { PseudoVMINU_VV_MF4, 1579 }, + { PseudoVMINU_VV_MF8, 1580 }, + { PseudoVMINU_VX_M1, 1581 }, + { PseudoVMINU_VX_M2, 1582 }, + { PseudoVMINU_VX_M4, 1583 }, + { PseudoVMINU_VX_M8, 1584 }, + { PseudoVMINU_VX_MF2, 1585 }, + { PseudoVMINU_VX_MF4, 1586 }, + { PseudoVMINU_VX_MF8, 1587 }, + { PseudoVMIN_VV_M1, 1588 }, + { PseudoVMIN_VV_M2, 1589 }, + { PseudoVMIN_VV_M4, 1590 }, + { PseudoVMIN_VV_M8, 1591 }, + { PseudoVMIN_VV_MF2, 1592 }, + { PseudoVMIN_VV_MF4, 1593 }, + { PseudoVMIN_VV_MF8, 1594 }, + { PseudoVMIN_VX_M1, 1595 }, + { PseudoVMIN_VX_M2, 1596 }, + { PseudoVMIN_VX_M4, 1597 }, + { PseudoVMIN_VX_M8, 1598 }, + { PseudoVMIN_VX_MF2, 1599 }, + { PseudoVMIN_VX_MF4, 1600 }, + { PseudoVMIN_VX_MF8, 1601 }, + { PseudoVMSEQ_VI_M1, 1602 }, + { PseudoVMSEQ_VI_M2, 1603 }, + { PseudoVMSEQ_VI_M4, 1604 }, + { PseudoVMSEQ_VI_M8, 1605 }, + { PseudoVMSEQ_VI_MF2, 1606 }, + { PseudoVMSEQ_VI_MF4, 1607 }, + { PseudoVMSEQ_VI_MF8, 1608 }, + { PseudoVMSEQ_VV_M1, 1609 }, + { PseudoVMSEQ_VV_M2, 1610 }, + { PseudoVMSEQ_VV_M4, 1611 }, + { PseudoVMSEQ_VV_M8, 1612 }, + { PseudoVMSEQ_VV_MF2, 1613 }, + { PseudoVMSEQ_VV_MF4, 1614 }, + { PseudoVMSEQ_VV_MF8, 1615 }, + { PseudoVMSEQ_VX_M1, 1616 }, + { PseudoVMSEQ_VX_M2, 1617 }, + { PseudoVMSEQ_VX_M4, 1618 }, + { PseudoVMSEQ_VX_M8, 1619 }, + { PseudoVMSEQ_VX_MF2, 1620 }, + { PseudoVMSEQ_VX_MF4, 1621 }, + { PseudoVMSEQ_VX_MF8, 1622 }, + { PseudoVMSGTU_VI_M1, 1623 }, + { PseudoVMSGTU_VI_M2, 1624 }, + { PseudoVMSGTU_VI_M4, 1625 }, + { PseudoVMSGTU_VI_M8, 1626 }, + { PseudoVMSGTU_VI_MF2, 1627 }, + { PseudoVMSGTU_VI_MF4, 1628 }, + { PseudoVMSGTU_VI_MF8, 1629 }, + { PseudoVMSGTU_VX_M1, 1630 }, + { PseudoVMSGTU_VX_M2, 1631 }, + { PseudoVMSGTU_VX_M4, 1632 }, + { PseudoVMSGTU_VX_M8, 1633 }, + { PseudoVMSGTU_VX_MF2, 1634 }, + { PseudoVMSGTU_VX_MF4, 1635 }, + { PseudoVMSGTU_VX_MF8, 1636 }, + { PseudoVMSGT_VI_M1, 1637 }, + { PseudoVMSGT_VI_M2, 1638 }, + { PseudoVMSGT_VI_M4, 1639 }, + { PseudoVMSGT_VI_M8, 1640 }, + { PseudoVMSGT_VI_MF2, 1641 }, + { PseudoVMSGT_VI_MF4, 1642 }, + { PseudoVMSGT_VI_MF8, 1643 }, + { PseudoVMSGT_VX_M1, 1644 }, + { PseudoVMSGT_VX_M2, 1645 }, + { PseudoVMSGT_VX_M4, 1646 }, + { PseudoVMSGT_VX_M8, 1647 }, + { PseudoVMSGT_VX_MF2, 1648 }, + { PseudoVMSGT_VX_MF4, 1649 }, + { PseudoVMSGT_VX_MF8, 1650 }, + { PseudoVMSLEU_VI_M1, 1651 }, + { PseudoVMSLEU_VI_M2, 1652 }, + { PseudoVMSLEU_VI_M4, 1653 }, + { PseudoVMSLEU_VI_M8, 1654 }, + { PseudoVMSLEU_VI_MF2, 1655 }, + { PseudoVMSLEU_VI_MF4, 1656 }, + { PseudoVMSLEU_VI_MF8, 1657 }, + { PseudoVMSLEU_VV_M1, 1658 }, + { PseudoVMSLEU_VV_M2, 1659 }, + { PseudoVMSLEU_VV_M4, 1660 }, + { PseudoVMSLEU_VV_M8, 1661 }, + { PseudoVMSLEU_VV_MF2, 1662 }, + { PseudoVMSLEU_VV_MF4, 1663 }, + { PseudoVMSLEU_VV_MF8, 1664 }, + { PseudoVMSLEU_VX_M1, 1665 }, + { PseudoVMSLEU_VX_M2, 1666 }, + { PseudoVMSLEU_VX_M4, 1667 }, + { PseudoVMSLEU_VX_M8, 1668 }, + { PseudoVMSLEU_VX_MF2, 1669 }, + { PseudoVMSLEU_VX_MF4, 1670 }, + { PseudoVMSLEU_VX_MF8, 1671 }, + { PseudoVMSLE_VI_M1, 1672 }, + { PseudoVMSLE_VI_M2, 1673 }, + { PseudoVMSLE_VI_M4, 1674 }, + { PseudoVMSLE_VI_M8, 1675 }, + { PseudoVMSLE_VI_MF2, 1676 }, + { PseudoVMSLE_VI_MF4, 1677 }, + { PseudoVMSLE_VI_MF8, 1678 }, + { PseudoVMSLE_VV_M1, 1679 }, + { PseudoVMSLE_VV_M2, 1680 }, + { PseudoVMSLE_VV_M4, 1681 }, + { PseudoVMSLE_VV_M8, 1682 }, + { PseudoVMSLE_VV_MF2, 1683 }, + { PseudoVMSLE_VV_MF4, 1684 }, + { PseudoVMSLE_VV_MF8, 1685 }, + { PseudoVMSLE_VX_M1, 1686 }, + { PseudoVMSLE_VX_M2, 1687 }, + { PseudoVMSLE_VX_M4, 1688 }, + { PseudoVMSLE_VX_M8, 1689 }, + { PseudoVMSLE_VX_MF2, 1690 }, + { PseudoVMSLE_VX_MF4, 1691 }, + { PseudoVMSLE_VX_MF8, 1692 }, + { PseudoVMSLTU_VV_M1, 1693 }, + { PseudoVMSLTU_VV_M2, 1694 }, + { PseudoVMSLTU_VV_M4, 1695 }, + { PseudoVMSLTU_VV_M8, 1696 }, + { PseudoVMSLTU_VV_MF2, 1697 }, + { PseudoVMSLTU_VV_MF4, 1698 }, + { PseudoVMSLTU_VV_MF8, 1699 }, + { PseudoVMSLTU_VX_M1, 1700 }, + { PseudoVMSLTU_VX_M2, 1701 }, + { PseudoVMSLTU_VX_M4, 1702 }, + { PseudoVMSLTU_VX_M8, 1703 }, + { PseudoVMSLTU_VX_MF2, 1704 }, + { PseudoVMSLTU_VX_MF4, 1705 }, + { PseudoVMSLTU_VX_MF8, 1706 }, + { PseudoVMSLT_VV_M1, 1707 }, + { PseudoVMSLT_VV_M2, 1708 }, + { PseudoVMSLT_VV_M4, 1709 }, + { PseudoVMSLT_VV_M8, 1710 }, + { PseudoVMSLT_VV_MF2, 1711 }, + { PseudoVMSLT_VV_MF4, 1712 }, + { PseudoVMSLT_VV_MF8, 1713 }, + { PseudoVMSLT_VX_M1, 1714 }, + { PseudoVMSLT_VX_M2, 1715 }, + { PseudoVMSLT_VX_M4, 1716 }, + { PseudoVMSLT_VX_M8, 1717 }, + { PseudoVMSLT_VX_MF2, 1718 }, + { PseudoVMSLT_VX_MF4, 1719 }, + { PseudoVMSLT_VX_MF8, 1720 }, + { PseudoVMSNE_VI_M1, 1721 }, + { PseudoVMSNE_VI_M2, 1722 }, + { PseudoVMSNE_VI_M4, 1723 }, + { PseudoVMSNE_VI_M8, 1724 }, + { PseudoVMSNE_VI_MF2, 1725 }, + { PseudoVMSNE_VI_MF4, 1726 }, + { PseudoVMSNE_VI_MF8, 1727 }, + { PseudoVMSNE_VV_M1, 1728 }, + { PseudoVMSNE_VV_M2, 1729 }, + { PseudoVMSNE_VV_M4, 1730 }, + { PseudoVMSNE_VV_M8, 1731 }, + { PseudoVMSNE_VV_MF2, 1732 }, + { PseudoVMSNE_VV_MF4, 1733 }, + { PseudoVMSNE_VV_MF8, 1734 }, + { PseudoVMSNE_VX_M1, 1735 }, + { PseudoVMSNE_VX_M2, 1736 }, + { PseudoVMSNE_VX_M4, 1737 }, + { PseudoVMSNE_VX_M8, 1738 }, + { PseudoVMSNE_VX_MF2, 1739 }, + { PseudoVMSNE_VX_MF4, 1740 }, + { PseudoVMSNE_VX_MF8, 1741 }, + { PseudoVMULHSU_VV_M1, 1742 }, + { PseudoVMULHSU_VV_M2, 1743 }, + { PseudoVMULHSU_VV_M4, 1744 }, + { PseudoVMULHSU_VV_M8, 1745 }, + { PseudoVMULHSU_VV_MF2, 1746 }, + { PseudoVMULHSU_VV_MF4, 1747 }, + { PseudoVMULHSU_VV_MF8, 1748 }, + { PseudoVMULHSU_VX_M1, 1749 }, + { PseudoVMULHSU_VX_M2, 1750 }, + { PseudoVMULHSU_VX_M4, 1751 }, + { PseudoVMULHSU_VX_M8, 1752 }, + { PseudoVMULHSU_VX_MF2, 1753 }, + { PseudoVMULHSU_VX_MF4, 1754 }, + { PseudoVMULHSU_VX_MF8, 1755 }, + { PseudoVMULHU_VV_M1, 1756 }, + { PseudoVMULHU_VV_M2, 1757 }, + { PseudoVMULHU_VV_M4, 1758 }, + { PseudoVMULHU_VV_M8, 1759 }, + { PseudoVMULHU_VV_MF2, 1760 }, + { PseudoVMULHU_VV_MF4, 1761 }, + { PseudoVMULHU_VV_MF8, 1762 }, + { PseudoVMULHU_VX_M1, 1763 }, + { PseudoVMULHU_VX_M2, 1764 }, + { PseudoVMULHU_VX_M4, 1765 }, + { PseudoVMULHU_VX_M8, 1766 }, + { PseudoVMULHU_VX_MF2, 1767 }, + { PseudoVMULHU_VX_MF4, 1768 }, + { PseudoVMULHU_VX_MF8, 1769 }, + { PseudoVMULH_VV_M1, 1770 }, + { PseudoVMULH_VV_M2, 1771 }, + { PseudoVMULH_VV_M4, 1772 }, + { PseudoVMULH_VV_M8, 1773 }, + { PseudoVMULH_VV_MF2, 1774 }, + { PseudoVMULH_VV_MF4, 1775 }, + { PseudoVMULH_VV_MF8, 1776 }, + { PseudoVMULH_VX_M1, 1777 }, + { PseudoVMULH_VX_M2, 1778 }, + { PseudoVMULH_VX_M4, 1779 }, + { PseudoVMULH_VX_M8, 1780 }, + { PseudoVMULH_VX_MF2, 1781 }, + { PseudoVMULH_VX_MF4, 1782 }, + { PseudoVMULH_VX_MF8, 1783 }, + { PseudoVMUL_VV_M1, 1784 }, + { PseudoVMUL_VV_M2, 1785 }, + { PseudoVMUL_VV_M4, 1786 }, + { PseudoVMUL_VV_M8, 1787 }, + { PseudoVMUL_VV_MF2, 1788 }, + { PseudoVMUL_VV_MF4, 1789 }, + { PseudoVMUL_VV_MF8, 1790 }, + { PseudoVMUL_VX_M1, 1791 }, + { PseudoVMUL_VX_M2, 1792 }, + { PseudoVMUL_VX_M4, 1793 }, + { PseudoVMUL_VX_M8, 1794 }, + { PseudoVMUL_VX_MF2, 1795 }, + { PseudoVMUL_VX_MF4, 1796 }, + { PseudoVMUL_VX_MF8, 1797 }, + { PseudoVNCLIPU_WI_M1, 1798 }, + { PseudoVNCLIPU_WI_M2, 1799 }, + { PseudoVNCLIPU_WI_M4, 1800 }, + { PseudoVNCLIPU_WI_MF2, 1801 }, + { PseudoVNCLIPU_WI_MF4, 1802 }, + { PseudoVNCLIPU_WI_MF8, 1803 }, + { PseudoVNCLIPU_WV_M1, 1804 }, + { PseudoVNCLIPU_WV_M2, 1805 }, + { PseudoVNCLIPU_WV_M4, 1806 }, + { PseudoVNCLIPU_WV_MF2, 1807 }, + { PseudoVNCLIPU_WV_MF4, 1808 }, + { PseudoVNCLIPU_WV_MF8, 1809 }, + { PseudoVNCLIPU_WX_M1, 1810 }, + { PseudoVNCLIPU_WX_M2, 1811 }, + { PseudoVNCLIPU_WX_M4, 1812 }, + { PseudoVNCLIPU_WX_MF2, 1813 }, + { PseudoVNCLIPU_WX_MF4, 1814 }, + { PseudoVNCLIPU_WX_MF8, 1815 }, + { PseudoVNCLIP_WI_M1, 1816 }, + { PseudoVNCLIP_WI_M2, 1817 }, + { PseudoVNCLIP_WI_M4, 1818 }, + { PseudoVNCLIP_WI_MF2, 1819 }, + { PseudoVNCLIP_WI_MF4, 1820 }, + { PseudoVNCLIP_WI_MF8, 1821 }, + { PseudoVNCLIP_WV_M1, 1822 }, + { PseudoVNCLIP_WV_M2, 1823 }, + { PseudoVNCLIP_WV_M4, 1824 }, + { PseudoVNCLIP_WV_MF2, 1825 }, + { PseudoVNCLIP_WV_MF4, 1826 }, + { PseudoVNCLIP_WV_MF8, 1827 }, + { PseudoVNCLIP_WX_M1, 1828 }, + { PseudoVNCLIP_WX_M2, 1829 }, + { PseudoVNCLIP_WX_M4, 1830 }, + { PseudoVNCLIP_WX_MF2, 1831 }, + { PseudoVNCLIP_WX_MF4, 1832 }, + { PseudoVNCLIP_WX_MF8, 1833 }, + { PseudoVNMSAC_VV_M1, 1834 }, + { PseudoVNMSAC_VV_M2, 1835 }, + { PseudoVNMSAC_VV_M4, 1836 }, + { PseudoVNMSAC_VV_M8, 1837 }, + { PseudoVNMSAC_VV_MF2, 1838 }, + { PseudoVNMSAC_VV_MF4, 1839 }, + { PseudoVNMSAC_VV_MF8, 1840 }, + { PseudoVNMSAC_VX_M1, 1841 }, + { PseudoVNMSAC_VX_M2, 1842 }, + { PseudoVNMSAC_VX_M4, 1843 }, + { PseudoVNMSAC_VX_M8, 1844 }, + { PseudoVNMSAC_VX_MF2, 1845 }, + { PseudoVNMSAC_VX_MF4, 1846 }, + { PseudoVNMSAC_VX_MF8, 1847 }, + { PseudoVNMSUB_VV_M1, 1848 }, + { PseudoVNMSUB_VV_M2, 1849 }, + { PseudoVNMSUB_VV_M4, 1850 }, + { PseudoVNMSUB_VV_M8, 1851 }, + { PseudoVNMSUB_VV_MF2, 1852 }, + { PseudoVNMSUB_VV_MF4, 1853 }, + { PseudoVNMSUB_VV_MF8, 1854 }, + { PseudoVNMSUB_VX_M1, 1855 }, + { PseudoVNMSUB_VX_M2, 1856 }, + { PseudoVNMSUB_VX_M4, 1857 }, + { PseudoVNMSUB_VX_M8, 1858 }, + { PseudoVNMSUB_VX_MF2, 1859 }, + { PseudoVNMSUB_VX_MF4, 1860 }, + { PseudoVNMSUB_VX_MF8, 1861 }, + { PseudoVNSRA_WI_M1, 1862 }, + { PseudoVNSRA_WI_M2, 1863 }, + { PseudoVNSRA_WI_M4, 1864 }, + { PseudoVNSRA_WI_MF2, 1865 }, + { PseudoVNSRA_WI_MF4, 1866 }, + { PseudoVNSRA_WI_MF8, 1867 }, + { PseudoVNSRA_WV_M1, 1868 }, + { PseudoVNSRA_WV_M2, 1869 }, + { PseudoVNSRA_WV_M4, 1870 }, + { PseudoVNSRA_WV_MF2, 1871 }, + { PseudoVNSRA_WV_MF4, 1872 }, + { PseudoVNSRA_WV_MF8, 1873 }, + { PseudoVNSRA_WX_M1, 1874 }, + { PseudoVNSRA_WX_M2, 1875 }, + { PseudoVNSRA_WX_M4, 1876 }, + { PseudoVNSRA_WX_MF2, 1877 }, + { PseudoVNSRA_WX_MF4, 1878 }, + { PseudoVNSRA_WX_MF8, 1879 }, + { PseudoVNSRL_WI_M1, 1880 }, + { PseudoVNSRL_WI_M2, 1881 }, + { PseudoVNSRL_WI_M4, 1882 }, + { PseudoVNSRL_WI_MF2, 1883 }, + { PseudoVNSRL_WI_MF4, 1884 }, + { PseudoVNSRL_WI_MF8, 1885 }, + { PseudoVNSRL_WV_M1, 1886 }, + { PseudoVNSRL_WV_M2, 1887 }, + { PseudoVNSRL_WV_M4, 1888 }, + { PseudoVNSRL_WV_MF2, 1889 }, + { PseudoVNSRL_WV_MF4, 1890 }, + { PseudoVNSRL_WV_MF8, 1891 }, + { PseudoVNSRL_WX_M1, 1892 }, + { PseudoVNSRL_WX_M2, 1893 }, + { PseudoVNSRL_WX_M4, 1894 }, + { PseudoVNSRL_WX_MF2, 1895 }, + { PseudoVNSRL_WX_MF4, 1896 }, + { PseudoVNSRL_WX_MF8, 1897 }, + { PseudoVOR_VI_M1, 1898 }, + { PseudoVOR_VI_M2, 1899 }, + { PseudoVOR_VI_M4, 1900 }, + { PseudoVOR_VI_M8, 1901 }, + { PseudoVOR_VI_MF2, 1902 }, + { PseudoVOR_VI_MF4, 1903 }, + { PseudoVOR_VI_MF8, 1904 }, + { PseudoVOR_VV_M1, 1905 }, + { PseudoVOR_VV_M2, 1906 }, + { PseudoVOR_VV_M4, 1907 }, + { PseudoVOR_VV_M8, 1908 }, + { PseudoVOR_VV_MF2, 1909 }, + { PseudoVOR_VV_MF4, 1910 }, + { PseudoVOR_VV_MF8, 1911 }, + { PseudoVOR_VX_M1, 1912 }, + { PseudoVOR_VX_M2, 1913 }, + { PseudoVOR_VX_M4, 1914 }, + { PseudoVOR_VX_M8, 1915 }, + { PseudoVOR_VX_MF2, 1916 }, + { PseudoVOR_VX_MF4, 1917 }, + { PseudoVOR_VX_MF8, 1918 }, + { PseudoVREDAND_VS_M1_E16, 1919 }, + { PseudoVREDAND_VS_M1_E32, 1920 }, + { PseudoVREDAND_VS_M1_E64, 1921 }, + { PseudoVREDAND_VS_M1_E8, 1922 }, + { PseudoVREDAND_VS_M2_E16, 1923 }, + { PseudoVREDAND_VS_M2_E32, 1924 }, + { PseudoVREDAND_VS_M2_E64, 1925 }, + { PseudoVREDAND_VS_M2_E8, 1926 }, + { PseudoVREDAND_VS_M4_E16, 1927 }, + { PseudoVREDAND_VS_M4_E32, 1928 }, + { PseudoVREDAND_VS_M4_E64, 1929 }, + { PseudoVREDAND_VS_M4_E8, 1930 }, + { PseudoVREDAND_VS_M8_E16, 1931 }, + { PseudoVREDAND_VS_M8_E32, 1932 }, + { PseudoVREDAND_VS_M8_E64, 1933 }, + { PseudoVREDAND_VS_M8_E8, 1934 }, + { PseudoVREDAND_VS_MF2_E16, 1935 }, + { PseudoVREDAND_VS_MF2_E32, 1936 }, + { PseudoVREDAND_VS_MF2_E8, 1937 }, + { PseudoVREDAND_VS_MF4_E16, 1938 }, + { PseudoVREDAND_VS_MF4_E8, 1939 }, + { PseudoVREDAND_VS_MF8_E8, 1940 }, + { PseudoVREDMAXU_VS_M1_E16, 1941 }, + { PseudoVREDMAXU_VS_M1_E32, 1942 }, + { PseudoVREDMAXU_VS_M1_E64, 1943 }, + { PseudoVREDMAXU_VS_M1_E8, 1944 }, + { PseudoVREDMAXU_VS_M2_E16, 1945 }, + { PseudoVREDMAXU_VS_M2_E32, 1946 }, + { PseudoVREDMAXU_VS_M2_E64, 1947 }, + { PseudoVREDMAXU_VS_M2_E8, 1948 }, + { PseudoVREDMAXU_VS_M4_E16, 1949 }, + { PseudoVREDMAXU_VS_M4_E32, 1950 }, + { PseudoVREDMAXU_VS_M4_E64, 1951 }, + { PseudoVREDMAXU_VS_M4_E8, 1952 }, + { PseudoVREDMAXU_VS_M8_E16, 1953 }, + { PseudoVREDMAXU_VS_M8_E32, 1954 }, + { PseudoVREDMAXU_VS_M8_E64, 1955 }, + { PseudoVREDMAXU_VS_M8_E8, 1956 }, + { PseudoVREDMAXU_VS_MF2_E16, 1957 }, + { PseudoVREDMAXU_VS_MF2_E32, 1958 }, + { PseudoVREDMAXU_VS_MF2_E8, 1959 }, + { PseudoVREDMAXU_VS_MF4_E16, 1960 }, + { PseudoVREDMAXU_VS_MF4_E8, 1961 }, + { PseudoVREDMAXU_VS_MF8_E8, 1962 }, + { PseudoVREDMAX_VS_M1_E16, 1963 }, + { PseudoVREDMAX_VS_M1_E32, 1964 }, + { PseudoVREDMAX_VS_M1_E64, 1965 }, + { PseudoVREDMAX_VS_M1_E8, 1966 }, + { PseudoVREDMAX_VS_M2_E16, 1967 }, + { PseudoVREDMAX_VS_M2_E32, 1968 }, + { PseudoVREDMAX_VS_M2_E64, 1969 }, + { PseudoVREDMAX_VS_M2_E8, 1970 }, + { PseudoVREDMAX_VS_M4_E16, 1971 }, + { PseudoVREDMAX_VS_M4_E32, 1972 }, + { PseudoVREDMAX_VS_M4_E64, 1973 }, + { PseudoVREDMAX_VS_M4_E8, 1974 }, + { PseudoVREDMAX_VS_M8_E16, 1975 }, + { PseudoVREDMAX_VS_M8_E32, 1976 }, + { PseudoVREDMAX_VS_M8_E64, 1977 }, + { PseudoVREDMAX_VS_M8_E8, 1978 }, + { PseudoVREDMAX_VS_MF2_E16, 1979 }, + { PseudoVREDMAX_VS_MF2_E32, 1980 }, + { PseudoVREDMAX_VS_MF2_E8, 1981 }, + { PseudoVREDMAX_VS_MF4_E16, 1982 }, + { PseudoVREDMAX_VS_MF4_E8, 1983 }, + { PseudoVREDMAX_VS_MF8_E8, 1984 }, + { PseudoVREDMINU_VS_M1_E16, 1985 }, + { PseudoVREDMINU_VS_M1_E32, 1986 }, + { PseudoVREDMINU_VS_M1_E64, 1987 }, + { PseudoVREDMINU_VS_M1_E8, 1988 }, + { PseudoVREDMINU_VS_M2_E16, 1989 }, + { PseudoVREDMINU_VS_M2_E32, 1990 }, + { PseudoVREDMINU_VS_M2_E64, 1991 }, + { PseudoVREDMINU_VS_M2_E8, 1992 }, + { PseudoVREDMINU_VS_M4_E16, 1993 }, + { PseudoVREDMINU_VS_M4_E32, 1994 }, + { PseudoVREDMINU_VS_M4_E64, 1995 }, + { PseudoVREDMINU_VS_M4_E8, 1996 }, + { PseudoVREDMINU_VS_M8_E16, 1997 }, + { PseudoVREDMINU_VS_M8_E32, 1998 }, + { PseudoVREDMINU_VS_M8_E64, 1999 }, + { PseudoVREDMINU_VS_M8_E8, 2000 }, + { PseudoVREDMINU_VS_MF2_E16, 2001 }, + { PseudoVREDMINU_VS_MF2_E32, 2002 }, + { PseudoVREDMINU_VS_MF2_E8, 2003 }, + { PseudoVREDMINU_VS_MF4_E16, 2004 }, + { PseudoVREDMINU_VS_MF4_E8, 2005 }, + { PseudoVREDMINU_VS_MF8_E8, 2006 }, + { PseudoVREDMIN_VS_M1_E16, 2007 }, + { PseudoVREDMIN_VS_M1_E32, 2008 }, + { PseudoVREDMIN_VS_M1_E64, 2009 }, + { PseudoVREDMIN_VS_M1_E8, 2010 }, + { PseudoVREDMIN_VS_M2_E16, 2011 }, + { PseudoVREDMIN_VS_M2_E32, 2012 }, + { PseudoVREDMIN_VS_M2_E64, 2013 }, + { PseudoVREDMIN_VS_M2_E8, 2014 }, + { PseudoVREDMIN_VS_M4_E16, 2015 }, + { PseudoVREDMIN_VS_M4_E32, 2016 }, + { PseudoVREDMIN_VS_M4_E64, 2017 }, + { PseudoVREDMIN_VS_M4_E8, 2018 }, + { PseudoVREDMIN_VS_M8_E16, 2019 }, + { PseudoVREDMIN_VS_M8_E32, 2020 }, + { PseudoVREDMIN_VS_M8_E64, 2021 }, + { PseudoVREDMIN_VS_M8_E8, 2022 }, + { PseudoVREDMIN_VS_MF2_E16, 2023 }, + { PseudoVREDMIN_VS_MF2_E32, 2024 }, + { PseudoVREDMIN_VS_MF2_E8, 2025 }, + { PseudoVREDMIN_VS_MF4_E16, 2026 }, + { PseudoVREDMIN_VS_MF4_E8, 2027 }, + { PseudoVREDMIN_VS_MF8_E8, 2028 }, + { PseudoVREDOR_VS_M1_E16, 2029 }, + { PseudoVREDOR_VS_M1_E32, 2030 }, + { PseudoVREDOR_VS_M1_E64, 2031 }, + { PseudoVREDOR_VS_M1_E8, 2032 }, + { PseudoVREDOR_VS_M2_E16, 2033 }, + { PseudoVREDOR_VS_M2_E32, 2034 }, + { PseudoVREDOR_VS_M2_E64, 2035 }, + { PseudoVREDOR_VS_M2_E8, 2036 }, + { PseudoVREDOR_VS_M4_E16, 2037 }, + { PseudoVREDOR_VS_M4_E32, 2038 }, + { PseudoVREDOR_VS_M4_E64, 2039 }, + { PseudoVREDOR_VS_M4_E8, 2040 }, + { PseudoVREDOR_VS_M8_E16, 2041 }, + { PseudoVREDOR_VS_M8_E32, 2042 }, + { PseudoVREDOR_VS_M8_E64, 2043 }, + { PseudoVREDOR_VS_M8_E8, 2044 }, + { PseudoVREDOR_VS_MF2_E16, 2045 }, + { PseudoVREDOR_VS_MF2_E32, 2046 }, + { PseudoVREDOR_VS_MF2_E8, 2047 }, + { PseudoVREDOR_VS_MF4_E16, 2048 }, + { PseudoVREDOR_VS_MF4_E8, 2049 }, + { PseudoVREDOR_VS_MF8_E8, 2050 }, + { PseudoVREDSUM_VS_M1_E16, 2051 }, + { PseudoVREDSUM_VS_M1_E32, 2052 }, + { PseudoVREDSUM_VS_M1_E64, 2053 }, + { PseudoVREDSUM_VS_M1_E8, 2054 }, + { PseudoVREDSUM_VS_M2_E16, 2055 }, + { PseudoVREDSUM_VS_M2_E32, 2056 }, + { PseudoVREDSUM_VS_M2_E64, 2057 }, + { PseudoVREDSUM_VS_M2_E8, 2058 }, + { PseudoVREDSUM_VS_M4_E16, 2059 }, + { PseudoVREDSUM_VS_M4_E32, 2060 }, + { PseudoVREDSUM_VS_M4_E64, 2061 }, + { PseudoVREDSUM_VS_M4_E8, 2062 }, + { PseudoVREDSUM_VS_M8_E16, 2063 }, + { PseudoVREDSUM_VS_M8_E32, 2064 }, + { PseudoVREDSUM_VS_M8_E64, 2065 }, + { PseudoVREDSUM_VS_M8_E8, 2066 }, + { PseudoVREDSUM_VS_MF2_E16, 2067 }, + { PseudoVREDSUM_VS_MF2_E32, 2068 }, + { PseudoVREDSUM_VS_MF2_E8, 2069 }, + { PseudoVREDSUM_VS_MF4_E16, 2070 }, + { PseudoVREDSUM_VS_MF4_E8, 2071 }, + { PseudoVREDSUM_VS_MF8_E8, 2072 }, + { PseudoVREDXOR_VS_M1_E16, 2073 }, + { PseudoVREDXOR_VS_M1_E32, 2074 }, + { PseudoVREDXOR_VS_M1_E64, 2075 }, + { PseudoVREDXOR_VS_M1_E8, 2076 }, + { PseudoVREDXOR_VS_M2_E16, 2077 }, + { PseudoVREDXOR_VS_M2_E32, 2078 }, + { PseudoVREDXOR_VS_M2_E64, 2079 }, + { PseudoVREDXOR_VS_M2_E8, 2080 }, + { PseudoVREDXOR_VS_M4_E16, 2081 }, + { PseudoVREDXOR_VS_M4_E32, 2082 }, + { PseudoVREDXOR_VS_M4_E64, 2083 }, + { PseudoVREDXOR_VS_M4_E8, 2084 }, + { PseudoVREDXOR_VS_M8_E16, 2085 }, + { PseudoVREDXOR_VS_M8_E32, 2086 }, + { PseudoVREDXOR_VS_M8_E64, 2087 }, + { PseudoVREDXOR_VS_M8_E8, 2088 }, + { PseudoVREDXOR_VS_MF2_E16, 2089 }, + { PseudoVREDXOR_VS_MF2_E32, 2090 }, + { PseudoVREDXOR_VS_MF2_E8, 2091 }, + { PseudoVREDXOR_VS_MF4_E16, 2092 }, + { PseudoVREDXOR_VS_MF4_E8, 2093 }, + { PseudoVREDXOR_VS_MF8_E8, 2094 }, + { PseudoVREMU_VV_M1_E16, 2095 }, + { PseudoVREMU_VV_M1_E32, 2096 }, + { PseudoVREMU_VV_M1_E64, 2097 }, + { PseudoVREMU_VV_M1_E8, 2098 }, + { PseudoVREMU_VV_M2_E16, 2099 }, + { PseudoVREMU_VV_M2_E32, 2100 }, + { PseudoVREMU_VV_M2_E64, 2101 }, + { PseudoVREMU_VV_M2_E8, 2102 }, + { PseudoVREMU_VV_M4_E16, 2103 }, + { PseudoVREMU_VV_M4_E32, 2104 }, + { PseudoVREMU_VV_M4_E64, 2105 }, + { PseudoVREMU_VV_M4_E8, 2106 }, + { PseudoVREMU_VV_M8_E16, 2107 }, + { PseudoVREMU_VV_M8_E32, 2108 }, + { PseudoVREMU_VV_M8_E64, 2109 }, + { PseudoVREMU_VV_M8_E8, 2110 }, + { PseudoVREMU_VV_MF2_E16, 2111 }, + { PseudoVREMU_VV_MF2_E32, 2112 }, + { PseudoVREMU_VV_MF2_E8, 2113 }, + { PseudoVREMU_VV_MF4_E16, 2114 }, + { PseudoVREMU_VV_MF4_E8, 2115 }, + { PseudoVREMU_VV_MF8_E8, 2116 }, + { PseudoVREMU_VX_M1_E16, 2117 }, + { PseudoVREMU_VX_M1_E32, 2118 }, + { PseudoVREMU_VX_M1_E64, 2119 }, + { PseudoVREMU_VX_M1_E8, 2120 }, + { PseudoVREMU_VX_M2_E16, 2121 }, + { PseudoVREMU_VX_M2_E32, 2122 }, + { PseudoVREMU_VX_M2_E64, 2123 }, + { PseudoVREMU_VX_M2_E8, 2124 }, + { PseudoVREMU_VX_M4_E16, 2125 }, + { PseudoVREMU_VX_M4_E32, 2126 }, + { PseudoVREMU_VX_M4_E64, 2127 }, + { PseudoVREMU_VX_M4_E8, 2128 }, + { PseudoVREMU_VX_M8_E16, 2129 }, + { PseudoVREMU_VX_M8_E32, 2130 }, + { PseudoVREMU_VX_M8_E64, 2131 }, + { PseudoVREMU_VX_M8_E8, 2132 }, + { PseudoVREMU_VX_MF2_E16, 2133 }, + { PseudoVREMU_VX_MF2_E32, 2134 }, + { PseudoVREMU_VX_MF2_E8, 2135 }, + { PseudoVREMU_VX_MF4_E16, 2136 }, + { PseudoVREMU_VX_MF4_E8, 2137 }, + { PseudoVREMU_VX_MF8_E8, 2138 }, + { PseudoVREM_VV_M1_E16, 2139 }, + { PseudoVREM_VV_M1_E32, 2140 }, + { PseudoVREM_VV_M1_E64, 2141 }, + { PseudoVREM_VV_M1_E8, 2142 }, + { PseudoVREM_VV_M2_E16, 2143 }, + { PseudoVREM_VV_M2_E32, 2144 }, + { PseudoVREM_VV_M2_E64, 2145 }, + { PseudoVREM_VV_M2_E8, 2146 }, + { PseudoVREM_VV_M4_E16, 2147 }, + { PseudoVREM_VV_M4_E32, 2148 }, + { PseudoVREM_VV_M4_E64, 2149 }, + { PseudoVREM_VV_M4_E8, 2150 }, + { PseudoVREM_VV_M8_E16, 2151 }, + { PseudoVREM_VV_M8_E32, 2152 }, + { PseudoVREM_VV_M8_E64, 2153 }, + { PseudoVREM_VV_M8_E8, 2154 }, + { PseudoVREM_VV_MF2_E16, 2155 }, + { PseudoVREM_VV_MF2_E32, 2156 }, + { PseudoVREM_VV_MF2_E8, 2157 }, + { PseudoVREM_VV_MF4_E16, 2158 }, + { PseudoVREM_VV_MF4_E8, 2159 }, + { PseudoVREM_VV_MF8_E8, 2160 }, + { PseudoVREM_VX_M1_E16, 2161 }, + { PseudoVREM_VX_M1_E32, 2162 }, + { PseudoVREM_VX_M1_E64, 2163 }, + { PseudoVREM_VX_M1_E8, 2164 }, + { PseudoVREM_VX_M2_E16, 2165 }, + { PseudoVREM_VX_M2_E32, 2166 }, + { PseudoVREM_VX_M2_E64, 2167 }, + { PseudoVREM_VX_M2_E8, 2168 }, + { PseudoVREM_VX_M4_E16, 2169 }, + { PseudoVREM_VX_M4_E32, 2170 }, + { PseudoVREM_VX_M4_E64, 2171 }, + { PseudoVREM_VX_M4_E8, 2172 }, + { PseudoVREM_VX_M8_E16, 2173 }, + { PseudoVREM_VX_M8_E32, 2174 }, + { PseudoVREM_VX_M8_E64, 2175 }, + { PseudoVREM_VX_M8_E8, 2176 }, + { PseudoVREM_VX_MF2_E16, 2177 }, + { PseudoVREM_VX_MF2_E32, 2178 }, + { PseudoVREM_VX_MF2_E8, 2179 }, + { PseudoVREM_VX_MF4_E16, 2180 }, + { PseudoVREM_VX_MF4_E8, 2181 }, + { PseudoVREM_VX_MF8_E8, 2182 }, + { PseudoVREV8_V_M1, 2183 }, + { PseudoVREV8_V_M2, 2184 }, + { PseudoVREV8_V_M4, 2185 }, + { PseudoVREV8_V_M8, 2186 }, + { PseudoVREV8_V_MF2, 2187 }, + { PseudoVREV8_V_MF4, 2188 }, + { PseudoVREV8_V_MF8, 2189 }, + { PseudoVRGATHEREI16_VV_M1_E16_M1, 2190 }, + { PseudoVRGATHEREI16_VV_M1_E16_M2, 2191 }, + { PseudoVRGATHEREI16_VV_M1_E16_MF2, 2192 }, + { PseudoVRGATHEREI16_VV_M1_E16_MF4, 2193 }, + { PseudoVRGATHEREI16_VV_M1_E32_M1, 2194 }, + { PseudoVRGATHEREI16_VV_M1_E32_M2, 2195 }, + { PseudoVRGATHEREI16_VV_M1_E32_MF2, 2196 }, + { PseudoVRGATHEREI16_VV_M1_E32_MF4, 2197 }, + { PseudoVRGATHEREI16_VV_M1_E64_M1, 2198 }, + { PseudoVRGATHEREI16_VV_M1_E64_M2, 2199 }, + { PseudoVRGATHEREI16_VV_M1_E64_MF2, 2200 }, + { PseudoVRGATHEREI16_VV_M1_E64_MF4, 2201 }, + { PseudoVRGATHEREI16_VV_M1_E8_M1, 2202 }, + { PseudoVRGATHEREI16_VV_M1_E8_M2, 2203 }, + { PseudoVRGATHEREI16_VV_M1_E8_MF2, 2204 }, + { PseudoVRGATHEREI16_VV_M1_E8_MF4, 2205 }, + { PseudoVRGATHEREI16_VV_M2_E16_M1, 2206 }, + { PseudoVRGATHEREI16_VV_M2_E16_M2, 2207 }, + { PseudoVRGATHEREI16_VV_M2_E16_M4, 2208 }, + { PseudoVRGATHEREI16_VV_M2_E16_MF2, 2209 }, + { PseudoVRGATHEREI16_VV_M2_E32_M1, 2210 }, + { PseudoVRGATHEREI16_VV_M2_E32_M2, 2211 }, + { PseudoVRGATHEREI16_VV_M2_E32_M4, 2212 }, + { PseudoVRGATHEREI16_VV_M2_E32_MF2, 2213 }, + { PseudoVRGATHEREI16_VV_M2_E64_M1, 2214 }, + { PseudoVRGATHEREI16_VV_M2_E64_M2, 2215 }, + { PseudoVRGATHEREI16_VV_M2_E64_M4, 2216 }, + { PseudoVRGATHEREI16_VV_M2_E64_MF2, 2217 }, + { PseudoVRGATHEREI16_VV_M2_E8_M1, 2218 }, + { PseudoVRGATHEREI16_VV_M2_E8_M2, 2219 }, + { PseudoVRGATHEREI16_VV_M2_E8_M4, 2220 }, + { PseudoVRGATHEREI16_VV_M2_E8_MF2, 2221 }, + { PseudoVRGATHEREI16_VV_M4_E16_M1, 2222 }, + { PseudoVRGATHEREI16_VV_M4_E16_M2, 2223 }, + { PseudoVRGATHEREI16_VV_M4_E16_M4, 2224 }, + { PseudoVRGATHEREI16_VV_M4_E16_M8, 2225 }, + { PseudoVRGATHEREI16_VV_M4_E32_M1, 2226 }, + { PseudoVRGATHEREI16_VV_M4_E32_M2, 2227 }, + { PseudoVRGATHEREI16_VV_M4_E32_M4, 2228 }, + { PseudoVRGATHEREI16_VV_M4_E32_M8, 2229 }, + { PseudoVRGATHEREI16_VV_M4_E64_M1, 2230 }, + { PseudoVRGATHEREI16_VV_M4_E64_M2, 2231 }, + { PseudoVRGATHEREI16_VV_M4_E64_M4, 2232 }, + { PseudoVRGATHEREI16_VV_M4_E64_M8, 2233 }, + { PseudoVRGATHEREI16_VV_M4_E8_M1, 2234 }, + { PseudoVRGATHEREI16_VV_M4_E8_M2, 2235 }, + { PseudoVRGATHEREI16_VV_M4_E8_M4, 2236 }, + { PseudoVRGATHEREI16_VV_M4_E8_M8, 2237 }, + { PseudoVRGATHEREI16_VV_M8_E16_M2, 2238 }, + { PseudoVRGATHEREI16_VV_M8_E16_M4, 2239 }, + { PseudoVRGATHEREI16_VV_M8_E16_M8, 2240 }, + { PseudoVRGATHEREI16_VV_M8_E32_M2, 2241 }, + { PseudoVRGATHEREI16_VV_M8_E32_M4, 2242 }, + { PseudoVRGATHEREI16_VV_M8_E32_M8, 2243 }, + { PseudoVRGATHEREI16_VV_M8_E64_M2, 2244 }, + { PseudoVRGATHEREI16_VV_M8_E64_M4, 2245 }, + { PseudoVRGATHEREI16_VV_M8_E64_M8, 2246 }, + { PseudoVRGATHEREI16_VV_M8_E8_M2, 2247 }, + { PseudoVRGATHEREI16_VV_M8_E8_M4, 2248 }, + { PseudoVRGATHEREI16_VV_M8_E8_M8, 2249 }, + { PseudoVRGATHEREI16_VV_MF2_E16_M1, 2250 }, + { PseudoVRGATHEREI16_VV_MF2_E16_MF2, 2251 }, + { PseudoVRGATHEREI16_VV_MF2_E16_MF4, 2252 }, + { PseudoVRGATHEREI16_VV_MF2_E16_MF8, 2253 }, + { PseudoVRGATHEREI16_VV_MF2_E32_M1, 2254 }, + { PseudoVRGATHEREI16_VV_MF2_E32_MF2, 2255 }, + { PseudoVRGATHEREI16_VV_MF2_E32_MF4, 2256 }, + { PseudoVRGATHEREI16_VV_MF2_E32_MF8, 2257 }, + { PseudoVRGATHEREI16_VV_MF2_E8_M1, 2258 }, + { PseudoVRGATHEREI16_VV_MF2_E8_MF2, 2259 }, + { PseudoVRGATHEREI16_VV_MF2_E8_MF4, 2260 }, + { PseudoVRGATHEREI16_VV_MF2_E8_MF8, 2261 }, + { PseudoVRGATHEREI16_VV_MF4_E16_MF2, 2262 }, + { PseudoVRGATHEREI16_VV_MF4_E16_MF4, 2263 }, + { PseudoVRGATHEREI16_VV_MF4_E16_MF8, 2264 }, + { PseudoVRGATHEREI16_VV_MF4_E8_MF2, 2265 }, + { PseudoVRGATHEREI16_VV_MF4_E8_MF4, 2266 }, + { PseudoVRGATHEREI16_VV_MF4_E8_MF8, 2267 }, + { PseudoVRGATHEREI16_VV_MF8_E8_MF4, 2268 }, + { PseudoVRGATHEREI16_VV_MF8_E8_MF8, 2269 }, + { PseudoVRGATHER_VI_M1, 2270 }, + { PseudoVRGATHER_VI_M2, 2271 }, + { PseudoVRGATHER_VI_M4, 2272 }, + { PseudoVRGATHER_VI_M8, 2273 }, + { PseudoVRGATHER_VI_MF2, 2274 }, + { PseudoVRGATHER_VI_MF4, 2275 }, + { PseudoVRGATHER_VI_MF8, 2276 }, + { PseudoVRGATHER_VV_M1_E16, 2277 }, + { PseudoVRGATHER_VV_M1_E32, 2278 }, + { PseudoVRGATHER_VV_M1_E64, 2279 }, + { PseudoVRGATHER_VV_M1_E8, 2280 }, + { PseudoVRGATHER_VV_M2_E16, 2281 }, + { PseudoVRGATHER_VV_M2_E32, 2282 }, + { PseudoVRGATHER_VV_M2_E64, 2283 }, + { PseudoVRGATHER_VV_M2_E8, 2284 }, + { PseudoVRGATHER_VV_M4_E16, 2285 }, + { PseudoVRGATHER_VV_M4_E32, 2286 }, + { PseudoVRGATHER_VV_M4_E64, 2287 }, + { PseudoVRGATHER_VV_M4_E8, 2288 }, + { PseudoVRGATHER_VV_M8_E16, 2289 }, + { PseudoVRGATHER_VV_M8_E32, 2290 }, + { PseudoVRGATHER_VV_M8_E64, 2291 }, + { PseudoVRGATHER_VV_M8_E8, 2292 }, + { PseudoVRGATHER_VV_MF2_E16, 2293 }, + { PseudoVRGATHER_VV_MF2_E32, 2294 }, + { PseudoVRGATHER_VV_MF2_E8, 2295 }, + { PseudoVRGATHER_VV_MF4_E16, 2296 }, + { PseudoVRGATHER_VV_MF4_E8, 2297 }, + { PseudoVRGATHER_VV_MF8_E8, 2298 }, + { PseudoVRGATHER_VX_M1, 2299 }, + { PseudoVRGATHER_VX_M2, 2300 }, + { PseudoVRGATHER_VX_M4, 2301 }, + { PseudoVRGATHER_VX_M8, 2302 }, + { PseudoVRGATHER_VX_MF2, 2303 }, + { PseudoVRGATHER_VX_MF4, 2304 }, + { PseudoVRGATHER_VX_MF8, 2305 }, + { PseudoVROL_VV_M1, 2306 }, + { PseudoVROL_VV_M2, 2307 }, + { PseudoVROL_VV_M4, 2308 }, + { PseudoVROL_VV_M8, 2309 }, + { PseudoVROL_VV_MF2, 2310 }, + { PseudoVROL_VV_MF4, 2311 }, + { PseudoVROL_VV_MF8, 2312 }, + { PseudoVROL_VX_M1, 2313 }, + { PseudoVROL_VX_M2, 2314 }, + { PseudoVROL_VX_M4, 2315 }, + { PseudoVROL_VX_M8, 2316 }, + { PseudoVROL_VX_MF2, 2317 }, + { PseudoVROL_VX_MF4, 2318 }, + { PseudoVROL_VX_MF8, 2319 }, + { PseudoVROR_VI_M1, 2320 }, + { PseudoVROR_VI_M2, 2321 }, + { PseudoVROR_VI_M4, 2322 }, + { PseudoVROR_VI_M8, 2323 }, + { PseudoVROR_VI_MF2, 2324 }, + { PseudoVROR_VI_MF4, 2325 }, + { PseudoVROR_VI_MF8, 2326 }, + { PseudoVROR_VV_M1, 2327 }, + { PseudoVROR_VV_M2, 2328 }, + { PseudoVROR_VV_M4, 2329 }, + { PseudoVROR_VV_M8, 2330 }, + { PseudoVROR_VV_MF2, 2331 }, + { PseudoVROR_VV_MF4, 2332 }, + { PseudoVROR_VV_MF8, 2333 }, + { PseudoVROR_VX_M1, 2334 }, + { PseudoVROR_VX_M2, 2335 }, + { PseudoVROR_VX_M4, 2336 }, + { PseudoVROR_VX_M8, 2337 }, + { PseudoVROR_VX_MF2, 2338 }, + { PseudoVROR_VX_MF4, 2339 }, + { PseudoVROR_VX_MF8, 2340 }, + { PseudoVRSUB_VI_M1, 2341 }, + { PseudoVRSUB_VI_M2, 2342 }, + { PseudoVRSUB_VI_M4, 2343 }, + { PseudoVRSUB_VI_M8, 2344 }, + { PseudoVRSUB_VI_MF2, 2345 }, + { PseudoVRSUB_VI_MF4, 2346 }, + { PseudoVRSUB_VI_MF8, 2347 }, + { PseudoVRSUB_VX_M1, 2348 }, + { PseudoVRSUB_VX_M2, 2349 }, + { PseudoVRSUB_VX_M4, 2350 }, + { PseudoVRSUB_VX_M8, 2351 }, + { PseudoVRSUB_VX_MF2, 2352 }, + { PseudoVRSUB_VX_MF4, 2353 }, + { PseudoVRSUB_VX_MF8, 2354 }, + { PseudoVSADDU_VI_M1, 2355 }, + { PseudoVSADDU_VI_M2, 2356 }, + { PseudoVSADDU_VI_M4, 2357 }, + { PseudoVSADDU_VI_M8, 2358 }, + { PseudoVSADDU_VI_MF2, 2359 }, + { PseudoVSADDU_VI_MF4, 2360 }, + { PseudoVSADDU_VI_MF8, 2361 }, + { PseudoVSADDU_VV_M1, 2362 }, + { PseudoVSADDU_VV_M2, 2363 }, + { PseudoVSADDU_VV_M4, 2364 }, + { PseudoVSADDU_VV_M8, 2365 }, + { PseudoVSADDU_VV_MF2, 2366 }, + { PseudoVSADDU_VV_MF4, 2367 }, + { PseudoVSADDU_VV_MF8, 2368 }, + { PseudoVSADDU_VX_M1, 2369 }, + { PseudoVSADDU_VX_M2, 2370 }, + { PseudoVSADDU_VX_M4, 2371 }, + { PseudoVSADDU_VX_M8, 2372 }, + { PseudoVSADDU_VX_MF2, 2373 }, + { PseudoVSADDU_VX_MF4, 2374 }, + { PseudoVSADDU_VX_MF8, 2375 }, + { PseudoVSADD_VI_M1, 2376 }, + { PseudoVSADD_VI_M2, 2377 }, + { PseudoVSADD_VI_M4, 2378 }, + { PseudoVSADD_VI_M8, 2379 }, + { PseudoVSADD_VI_MF2, 2380 }, + { PseudoVSADD_VI_MF4, 2381 }, + { PseudoVSADD_VI_MF8, 2382 }, + { PseudoVSADD_VV_M1, 2383 }, + { PseudoVSADD_VV_M2, 2384 }, + { PseudoVSADD_VV_M4, 2385 }, + { PseudoVSADD_VV_M8, 2386 }, + { PseudoVSADD_VV_MF2, 2387 }, + { PseudoVSADD_VV_MF4, 2388 }, + { PseudoVSADD_VV_MF8, 2389 }, + { PseudoVSADD_VX_M1, 2390 }, + { PseudoVSADD_VX_M2, 2391 }, + { PseudoVSADD_VX_M4, 2392 }, + { PseudoVSADD_VX_M8, 2393 }, + { PseudoVSADD_VX_MF2, 2394 }, + { PseudoVSADD_VX_MF4, 2395 }, + { PseudoVSADD_VX_MF8, 2396 }, + { PseudoVSEXT_VF2_M1, 2397 }, + { PseudoVSEXT_VF2_M2, 2398 }, + { PseudoVSEXT_VF2_M4, 2399 }, + { PseudoVSEXT_VF2_M8, 2400 }, + { PseudoVSEXT_VF2_MF2, 2401 }, + { PseudoVSEXT_VF2_MF4, 2402 }, + { PseudoVSEXT_VF4_M1, 2403 }, + { PseudoVSEXT_VF4_M2, 2404 }, + { PseudoVSEXT_VF4_M4, 2405 }, + { PseudoVSEXT_VF4_M8, 2406 }, + { PseudoVSEXT_VF4_MF2, 2407 }, + { PseudoVSEXT_VF8_M1, 2408 }, + { PseudoVSEXT_VF8_M2, 2409 }, + { PseudoVSEXT_VF8_M4, 2410 }, + { PseudoVSEXT_VF8_M8, 2411 }, + { PseudoVSLIDE1DOWN_VX_M1, 2412 }, + { PseudoVSLIDE1DOWN_VX_M2, 2413 }, + { PseudoVSLIDE1DOWN_VX_M4, 2414 }, + { PseudoVSLIDE1DOWN_VX_M8, 2415 }, + { PseudoVSLIDE1DOWN_VX_MF2, 2416 }, + { PseudoVSLIDE1DOWN_VX_MF4, 2417 }, + { PseudoVSLIDE1DOWN_VX_MF8, 2418 }, + { PseudoVSLIDE1UP_VX_M1, 2419 }, + { PseudoVSLIDE1UP_VX_M2, 2420 }, + { PseudoVSLIDE1UP_VX_M4, 2421 }, + { PseudoVSLIDE1UP_VX_M8, 2422 }, + { PseudoVSLIDE1UP_VX_MF2, 2423 }, + { PseudoVSLIDE1UP_VX_MF4, 2424 }, + { PseudoVSLIDE1UP_VX_MF8, 2425 }, + { PseudoVSLIDEDOWN_VI_M1, 2426 }, + { PseudoVSLIDEDOWN_VI_M2, 2427 }, + { PseudoVSLIDEDOWN_VI_M4, 2428 }, + { PseudoVSLIDEDOWN_VI_M8, 2429 }, + { PseudoVSLIDEDOWN_VI_MF2, 2430 }, + { PseudoVSLIDEDOWN_VI_MF4, 2431 }, + { PseudoVSLIDEDOWN_VI_MF8, 2432 }, + { PseudoVSLIDEDOWN_VX_M1, 2433 }, + { PseudoVSLIDEDOWN_VX_M2, 2434 }, + { PseudoVSLIDEDOWN_VX_M4, 2435 }, + { PseudoVSLIDEDOWN_VX_M8, 2436 }, + { PseudoVSLIDEDOWN_VX_MF2, 2437 }, + { PseudoVSLIDEDOWN_VX_MF4, 2438 }, + { PseudoVSLIDEDOWN_VX_MF8, 2439 }, + { PseudoVSLIDEUP_VI_M1, 2440 }, + { PseudoVSLIDEUP_VI_M2, 2441 }, + { PseudoVSLIDEUP_VI_M4, 2442 }, + { PseudoVSLIDEUP_VI_M8, 2443 }, + { PseudoVSLIDEUP_VI_MF2, 2444 }, + { PseudoVSLIDEUP_VI_MF4, 2445 }, + { PseudoVSLIDEUP_VI_MF8, 2446 }, + { PseudoVSLIDEUP_VX_M1, 2447 }, + { PseudoVSLIDEUP_VX_M2, 2448 }, + { PseudoVSLIDEUP_VX_M4, 2449 }, + { PseudoVSLIDEUP_VX_M8, 2450 }, + { PseudoVSLIDEUP_VX_MF2, 2451 }, + { PseudoVSLIDEUP_VX_MF4, 2452 }, + { PseudoVSLIDEUP_VX_MF8, 2453 }, + { PseudoVSLL_VI_M1, 2454 }, + { PseudoVSLL_VI_M2, 2455 }, + { PseudoVSLL_VI_M4, 2456 }, + { PseudoVSLL_VI_M8, 2457 }, + { PseudoVSLL_VI_MF2, 2458 }, + { PseudoVSLL_VI_MF4, 2459 }, + { PseudoVSLL_VI_MF8, 2460 }, + { PseudoVSLL_VV_M1, 2461 }, + { PseudoVSLL_VV_M2, 2462 }, + { PseudoVSLL_VV_M4, 2463 }, + { PseudoVSLL_VV_M8, 2464 }, + { PseudoVSLL_VV_MF2, 2465 }, + { PseudoVSLL_VV_MF4, 2466 }, + { PseudoVSLL_VV_MF8, 2467 }, + { PseudoVSLL_VX_M1, 2468 }, + { PseudoVSLL_VX_M2, 2469 }, + { PseudoVSLL_VX_M4, 2470 }, + { PseudoVSLL_VX_M8, 2471 }, + { PseudoVSLL_VX_MF2, 2472 }, + { PseudoVSLL_VX_MF4, 2473 }, + { PseudoVSLL_VX_MF8, 2474 }, + { PseudoVSMUL_VV_M1, 2475 }, + { PseudoVSMUL_VV_M2, 2476 }, + { PseudoVSMUL_VV_M4, 2477 }, + { PseudoVSMUL_VV_M8, 2478 }, + { PseudoVSMUL_VV_MF2, 2479 }, + { PseudoVSMUL_VV_MF4, 2480 }, + { PseudoVSMUL_VV_MF8, 2481 }, + { PseudoVSMUL_VX_M1, 2482 }, + { PseudoVSMUL_VX_M2, 2483 }, + { PseudoVSMUL_VX_M4, 2484 }, + { PseudoVSMUL_VX_M8, 2485 }, + { PseudoVSMUL_VX_MF2, 2486 }, + { PseudoVSMUL_VX_MF4, 2487 }, + { PseudoVSMUL_VX_MF8, 2488 }, + { PseudoVSRA_VI_M1, 2489 }, + { PseudoVSRA_VI_M2, 2490 }, + { PseudoVSRA_VI_M4, 2491 }, + { PseudoVSRA_VI_M8, 2492 }, + { PseudoVSRA_VI_MF2, 2493 }, + { PseudoVSRA_VI_MF4, 2494 }, + { PseudoVSRA_VI_MF8, 2495 }, + { PseudoVSRA_VV_M1, 2496 }, + { PseudoVSRA_VV_M2, 2497 }, + { PseudoVSRA_VV_M4, 2498 }, + { PseudoVSRA_VV_M8, 2499 }, + { PseudoVSRA_VV_MF2, 2500 }, + { PseudoVSRA_VV_MF4, 2501 }, + { PseudoVSRA_VV_MF8, 2502 }, + { PseudoVSRA_VX_M1, 2503 }, + { PseudoVSRA_VX_M2, 2504 }, + { PseudoVSRA_VX_M4, 2505 }, + { PseudoVSRA_VX_M8, 2506 }, + { PseudoVSRA_VX_MF2, 2507 }, + { PseudoVSRA_VX_MF4, 2508 }, + { PseudoVSRA_VX_MF8, 2509 }, + { PseudoVSRL_VI_M1, 2510 }, + { PseudoVSRL_VI_M2, 2511 }, + { PseudoVSRL_VI_M4, 2512 }, + { PseudoVSRL_VI_M8, 2513 }, + { PseudoVSRL_VI_MF2, 2514 }, + { PseudoVSRL_VI_MF4, 2515 }, + { PseudoVSRL_VI_MF8, 2516 }, + { PseudoVSRL_VV_M1, 2517 }, + { PseudoVSRL_VV_M2, 2518 }, + { PseudoVSRL_VV_M4, 2519 }, + { PseudoVSRL_VV_M8, 2520 }, + { PseudoVSRL_VV_MF2, 2521 }, + { PseudoVSRL_VV_MF4, 2522 }, + { PseudoVSRL_VV_MF8, 2523 }, + { PseudoVSRL_VX_M1, 2524 }, + { PseudoVSRL_VX_M2, 2525 }, + { PseudoVSRL_VX_M4, 2526 }, + { PseudoVSRL_VX_M8, 2527 }, + { PseudoVSRL_VX_MF2, 2528 }, + { PseudoVSRL_VX_MF4, 2529 }, + { PseudoVSRL_VX_MF8, 2530 }, + { PseudoVSSRA_VI_M1, 2531 }, + { PseudoVSSRA_VI_M2, 2532 }, + { PseudoVSSRA_VI_M4, 2533 }, + { PseudoVSSRA_VI_M8, 2534 }, + { PseudoVSSRA_VI_MF2, 2535 }, + { PseudoVSSRA_VI_MF4, 2536 }, + { PseudoVSSRA_VI_MF8, 2537 }, + { PseudoVSSRA_VV_M1, 2538 }, + { PseudoVSSRA_VV_M2, 2539 }, + { PseudoVSSRA_VV_M4, 2540 }, + { PseudoVSSRA_VV_M8, 2541 }, + { PseudoVSSRA_VV_MF2, 2542 }, + { PseudoVSSRA_VV_MF4, 2543 }, + { PseudoVSSRA_VV_MF8, 2544 }, + { PseudoVSSRA_VX_M1, 2545 }, + { PseudoVSSRA_VX_M2, 2546 }, + { PseudoVSSRA_VX_M4, 2547 }, + { PseudoVSSRA_VX_M8, 2548 }, + { PseudoVSSRA_VX_MF2, 2549 }, + { PseudoVSSRA_VX_MF4, 2550 }, + { PseudoVSSRA_VX_MF8, 2551 }, + { PseudoVSSRL_VI_M1, 2552 }, + { PseudoVSSRL_VI_M2, 2553 }, + { PseudoVSSRL_VI_M4, 2554 }, + { PseudoVSSRL_VI_M8, 2555 }, + { PseudoVSSRL_VI_MF2, 2556 }, + { PseudoVSSRL_VI_MF4, 2557 }, + { PseudoVSSRL_VI_MF8, 2558 }, + { PseudoVSSRL_VV_M1, 2559 }, + { PseudoVSSRL_VV_M2, 2560 }, + { PseudoVSSRL_VV_M4, 2561 }, + { PseudoVSSRL_VV_M8, 2562 }, + { PseudoVSSRL_VV_MF2, 2563 }, + { PseudoVSSRL_VV_MF4, 2564 }, + { PseudoVSSRL_VV_MF8, 2565 }, + { PseudoVSSRL_VX_M1, 2566 }, + { PseudoVSSRL_VX_M2, 2567 }, + { PseudoVSSRL_VX_M4, 2568 }, + { PseudoVSSRL_VX_M8, 2569 }, + { PseudoVSSRL_VX_MF2, 2570 }, + { PseudoVSSRL_VX_MF4, 2571 }, + { PseudoVSSRL_VX_MF8, 2572 }, + { PseudoVSSUBU_VV_M1, 2573 }, + { PseudoVSSUBU_VV_M2, 2574 }, + { PseudoVSSUBU_VV_M4, 2575 }, + { PseudoVSSUBU_VV_M8, 2576 }, + { PseudoVSSUBU_VV_MF2, 2577 }, + { PseudoVSSUBU_VV_MF4, 2578 }, + { PseudoVSSUBU_VV_MF8, 2579 }, + { PseudoVSSUBU_VX_M1, 2580 }, + { PseudoVSSUBU_VX_M2, 2581 }, + { PseudoVSSUBU_VX_M4, 2582 }, + { PseudoVSSUBU_VX_M8, 2583 }, + { PseudoVSSUBU_VX_MF2, 2584 }, + { PseudoVSSUBU_VX_MF4, 2585 }, + { PseudoVSSUBU_VX_MF8, 2586 }, + { PseudoVSSUB_VV_M1, 2587 }, + { PseudoVSSUB_VV_M2, 2588 }, + { PseudoVSSUB_VV_M4, 2589 }, + { PseudoVSSUB_VV_M8, 2590 }, + { PseudoVSSUB_VV_MF2, 2591 }, + { PseudoVSSUB_VV_MF4, 2592 }, + { PseudoVSSUB_VV_MF8, 2593 }, + { PseudoVSSUB_VX_M1, 2594 }, + { PseudoVSSUB_VX_M2, 2595 }, + { PseudoVSSUB_VX_M4, 2596 }, + { PseudoVSSUB_VX_M8, 2597 }, + { PseudoVSSUB_VX_MF2, 2598 }, + { PseudoVSSUB_VX_MF4, 2599 }, + { PseudoVSSUB_VX_MF8, 2600 }, + { PseudoVSUB_VV_M1, 2601 }, + { PseudoVSUB_VV_M2, 2602 }, + { PseudoVSUB_VV_M4, 2603 }, + { PseudoVSUB_VV_M8, 2604 }, + { PseudoVSUB_VV_MF2, 2605 }, + { PseudoVSUB_VV_MF4, 2606 }, + { PseudoVSUB_VV_MF8, 2607 }, + { PseudoVSUB_VX_M1, 2608 }, + { PseudoVSUB_VX_M2, 2609 }, + { PseudoVSUB_VX_M4, 2610 }, + { PseudoVSUB_VX_M8, 2611 }, + { PseudoVSUB_VX_MF2, 2612 }, + { PseudoVSUB_VX_MF4, 2613 }, + { PseudoVSUB_VX_MF8, 2614 }, + { PseudoVWADDU_VV_M1, 2615 }, + { PseudoVWADDU_VV_M2, 2616 }, + { PseudoVWADDU_VV_M4, 2617 }, + { PseudoVWADDU_VV_MF2, 2618 }, + { PseudoVWADDU_VV_MF4, 2619 }, + { PseudoVWADDU_VV_MF8, 2620 }, + { PseudoVWADDU_VX_M1, 2621 }, + { PseudoVWADDU_VX_M2, 2622 }, + { PseudoVWADDU_VX_M4, 2623 }, + { PseudoVWADDU_VX_MF2, 2624 }, + { PseudoVWADDU_VX_MF4, 2625 }, + { PseudoVWADDU_VX_MF8, 2626 }, + { PseudoVWADDU_WV_M1, 2627 }, + { PseudoVWADDU_WV_M2, 2628 }, + { PseudoVWADDU_WV_M4, 2629 }, + { PseudoVWADDU_WV_MF2, 2630 }, + { PseudoVWADDU_WV_MF4, 2631 }, + { PseudoVWADDU_WV_MF8, 2632 }, + { PseudoVWADDU_WX_M1, 2633 }, + { PseudoVWADDU_WX_M2, 2634 }, + { PseudoVWADDU_WX_M4, 2635 }, + { PseudoVWADDU_WX_MF2, 2636 }, + { PseudoVWADDU_WX_MF4, 2637 }, + { PseudoVWADDU_WX_MF8, 2638 }, + { PseudoVWADD_VV_M1, 2639 }, + { PseudoVWADD_VV_M2, 2640 }, + { PseudoVWADD_VV_M4, 2641 }, + { PseudoVWADD_VV_MF2, 2642 }, + { PseudoVWADD_VV_MF4, 2643 }, + { PseudoVWADD_VV_MF8, 2644 }, + { PseudoVWADD_VX_M1, 2645 }, + { PseudoVWADD_VX_M2, 2646 }, + { PseudoVWADD_VX_M4, 2647 }, + { PseudoVWADD_VX_MF2, 2648 }, + { PseudoVWADD_VX_MF4, 2649 }, + { PseudoVWADD_VX_MF8, 2650 }, + { PseudoVWADD_WV_M1, 2651 }, + { PseudoVWADD_WV_M2, 2652 }, + { PseudoVWADD_WV_M4, 2653 }, + { PseudoVWADD_WV_MF2, 2654 }, + { PseudoVWADD_WV_MF4, 2655 }, + { PseudoVWADD_WV_MF8, 2656 }, + { PseudoVWADD_WX_M1, 2657 }, + { PseudoVWADD_WX_M2, 2658 }, + { PseudoVWADD_WX_M4, 2659 }, + { PseudoVWADD_WX_MF2, 2660 }, + { PseudoVWADD_WX_MF4, 2661 }, + { PseudoVWADD_WX_MF8, 2662 }, + { PseudoVWMACCSU_VV_M1, 2663 }, + { PseudoVWMACCSU_VV_M2, 2664 }, + { PseudoVWMACCSU_VV_M4, 2665 }, + { PseudoVWMACCSU_VV_MF2, 2666 }, + { PseudoVWMACCSU_VV_MF4, 2667 }, + { PseudoVWMACCSU_VV_MF8, 2668 }, + { PseudoVWMACCSU_VX_M1, 2669 }, + { PseudoVWMACCSU_VX_M2, 2670 }, + { PseudoVWMACCSU_VX_M4, 2671 }, + { PseudoVWMACCSU_VX_MF2, 2672 }, + { PseudoVWMACCSU_VX_MF4, 2673 }, + { PseudoVWMACCSU_VX_MF8, 2674 }, + { PseudoVWMACCUS_VX_M1, 2675 }, + { PseudoVWMACCUS_VX_M2, 2676 }, + { PseudoVWMACCUS_VX_M4, 2677 }, + { PseudoVWMACCUS_VX_MF2, 2678 }, + { PseudoVWMACCUS_VX_MF4, 2679 }, + { PseudoVWMACCUS_VX_MF8, 2680 }, + { PseudoVWMACCU_VV_M1, 2681 }, + { PseudoVWMACCU_VV_M2, 2682 }, + { PseudoVWMACCU_VV_M4, 2683 }, + { PseudoVWMACCU_VV_MF2, 2684 }, + { PseudoVWMACCU_VV_MF4, 2685 }, + { PseudoVWMACCU_VV_MF8, 2686 }, + { PseudoVWMACCU_VX_M1, 2687 }, + { PseudoVWMACCU_VX_M2, 2688 }, + { PseudoVWMACCU_VX_M4, 2689 }, + { PseudoVWMACCU_VX_MF2, 2690 }, + { PseudoVWMACCU_VX_MF4, 2691 }, + { PseudoVWMACCU_VX_MF8, 2692 }, + { PseudoVWMACC_VV_M1, 2693 }, + { PseudoVWMACC_VV_M2, 2694 }, + { PseudoVWMACC_VV_M4, 2695 }, + { PseudoVWMACC_VV_MF2, 2696 }, + { PseudoVWMACC_VV_MF4, 2697 }, + { PseudoVWMACC_VV_MF8, 2698 }, + { PseudoVWMACC_VX_M1, 2699 }, + { PseudoVWMACC_VX_M2, 2700 }, + { PseudoVWMACC_VX_M4, 2701 }, + { PseudoVWMACC_VX_MF2, 2702 }, + { PseudoVWMACC_VX_MF4, 2703 }, + { PseudoVWMACC_VX_MF8, 2704 }, + { PseudoVWMULSU_VV_M1, 2705 }, + { PseudoVWMULSU_VV_M2, 2706 }, + { PseudoVWMULSU_VV_M4, 2707 }, + { PseudoVWMULSU_VV_MF2, 2708 }, + { PseudoVWMULSU_VV_MF4, 2709 }, + { PseudoVWMULSU_VV_MF8, 2710 }, + { PseudoVWMULSU_VX_M1, 2711 }, + { PseudoVWMULSU_VX_M2, 2712 }, + { PseudoVWMULSU_VX_M4, 2713 }, + { PseudoVWMULSU_VX_MF2, 2714 }, + { PseudoVWMULSU_VX_MF4, 2715 }, + { PseudoVWMULSU_VX_MF8, 2716 }, + { PseudoVWMULU_VV_M1, 2717 }, + { PseudoVWMULU_VV_M2, 2718 }, + { PseudoVWMULU_VV_M4, 2719 }, + { PseudoVWMULU_VV_MF2, 2720 }, + { PseudoVWMULU_VV_MF4, 2721 }, + { PseudoVWMULU_VV_MF8, 2722 }, + { PseudoVWMULU_VX_M1, 2723 }, + { PseudoVWMULU_VX_M2, 2724 }, + { PseudoVWMULU_VX_M4, 2725 }, + { PseudoVWMULU_VX_MF2, 2726 }, + { PseudoVWMULU_VX_MF4, 2727 }, + { PseudoVWMULU_VX_MF8, 2728 }, + { PseudoVWMUL_VV_M1, 2729 }, + { PseudoVWMUL_VV_M2, 2730 }, + { PseudoVWMUL_VV_M4, 2731 }, + { PseudoVWMUL_VV_MF2, 2732 }, + { PseudoVWMUL_VV_MF4, 2733 }, + { PseudoVWMUL_VV_MF8, 2734 }, + { PseudoVWMUL_VX_M1, 2735 }, + { PseudoVWMUL_VX_M2, 2736 }, + { PseudoVWMUL_VX_M4, 2737 }, + { PseudoVWMUL_VX_MF2, 2738 }, + { PseudoVWMUL_VX_MF4, 2739 }, + { PseudoVWMUL_VX_MF8, 2740 }, + { PseudoVWREDSUMU_VS_M1_E16, 2741 }, + { PseudoVWREDSUMU_VS_M1_E32, 2742 }, + { PseudoVWREDSUMU_VS_M1_E8, 2743 }, + { PseudoVWREDSUMU_VS_M2_E16, 2744 }, + { PseudoVWREDSUMU_VS_M2_E32, 2745 }, + { PseudoVWREDSUMU_VS_M2_E8, 2746 }, + { PseudoVWREDSUMU_VS_M4_E16, 2747 }, + { PseudoVWREDSUMU_VS_M4_E32, 2748 }, + { PseudoVWREDSUMU_VS_M4_E8, 2749 }, + { PseudoVWREDSUMU_VS_M8_E16, 2750 }, + { PseudoVWREDSUMU_VS_M8_E32, 2751 }, + { PseudoVWREDSUMU_VS_M8_E8, 2752 }, + { PseudoVWREDSUMU_VS_MF2_E16, 2753 }, + { PseudoVWREDSUMU_VS_MF2_E32, 2754 }, + { PseudoVWREDSUMU_VS_MF2_E8, 2755 }, + { PseudoVWREDSUMU_VS_MF4_E16, 2756 }, + { PseudoVWREDSUMU_VS_MF4_E8, 2757 }, + { PseudoVWREDSUMU_VS_MF8_E8, 2758 }, + { PseudoVWREDSUM_VS_M1_E16, 2759 }, + { PseudoVWREDSUM_VS_M1_E32, 2760 }, + { PseudoVWREDSUM_VS_M1_E8, 2761 }, + { PseudoVWREDSUM_VS_M2_E16, 2762 }, + { PseudoVWREDSUM_VS_M2_E32, 2763 }, + { PseudoVWREDSUM_VS_M2_E8, 2764 }, + { PseudoVWREDSUM_VS_M4_E16, 2765 }, + { PseudoVWREDSUM_VS_M4_E32, 2766 }, + { PseudoVWREDSUM_VS_M4_E8, 2767 }, + { PseudoVWREDSUM_VS_M8_E16, 2768 }, + { PseudoVWREDSUM_VS_M8_E32, 2769 }, + { PseudoVWREDSUM_VS_M8_E8, 2770 }, + { PseudoVWREDSUM_VS_MF2_E16, 2771 }, + { PseudoVWREDSUM_VS_MF2_E32, 2772 }, + { PseudoVWREDSUM_VS_MF2_E8, 2773 }, + { PseudoVWREDSUM_VS_MF4_E16, 2774 }, + { PseudoVWREDSUM_VS_MF4_E8, 2775 }, + { PseudoVWREDSUM_VS_MF8_E8, 2776 }, + { PseudoVWSLL_VI_M1, 2777 }, + { PseudoVWSLL_VI_M2, 2778 }, + { PseudoVWSLL_VI_M4, 2779 }, + { PseudoVWSLL_VI_MF2, 2780 }, + { PseudoVWSLL_VI_MF4, 2781 }, + { PseudoVWSLL_VI_MF8, 2782 }, + { PseudoVWSLL_VV_M1, 2783 }, + { PseudoVWSLL_VV_M2, 2784 }, + { PseudoVWSLL_VV_M4, 2785 }, + { PseudoVWSLL_VV_MF2, 2786 }, + { PseudoVWSLL_VV_MF4, 2787 }, + { PseudoVWSLL_VV_MF8, 2788 }, + { PseudoVWSLL_VX_M1, 2789 }, + { PseudoVWSLL_VX_M2, 2790 }, + { PseudoVWSLL_VX_M4, 2791 }, + { PseudoVWSLL_VX_MF2, 2792 }, + { PseudoVWSLL_VX_MF4, 2793 }, + { PseudoVWSLL_VX_MF8, 2794 }, + { PseudoVWSUBU_VV_M1, 2795 }, + { PseudoVWSUBU_VV_M2, 2796 }, + { PseudoVWSUBU_VV_M4, 2797 }, + { PseudoVWSUBU_VV_MF2, 2798 }, + { PseudoVWSUBU_VV_MF4, 2799 }, + { PseudoVWSUBU_VV_MF8, 2800 }, + { PseudoVWSUBU_VX_M1, 2801 }, + { PseudoVWSUBU_VX_M2, 2802 }, + { PseudoVWSUBU_VX_M4, 2803 }, + { PseudoVWSUBU_VX_MF2, 2804 }, + { PseudoVWSUBU_VX_MF4, 2805 }, + { PseudoVWSUBU_VX_MF8, 2806 }, + { PseudoVWSUBU_WV_M1, 2807 }, + { PseudoVWSUBU_WV_M2, 2808 }, + { PseudoVWSUBU_WV_M4, 2809 }, + { PseudoVWSUBU_WV_MF2, 2810 }, + { PseudoVWSUBU_WV_MF4, 2811 }, + { PseudoVWSUBU_WV_MF8, 2812 }, + { PseudoVWSUBU_WX_M1, 2813 }, + { PseudoVWSUBU_WX_M2, 2814 }, + { PseudoVWSUBU_WX_M4, 2815 }, + { PseudoVWSUBU_WX_MF2, 2816 }, + { PseudoVWSUBU_WX_MF4, 2817 }, + { PseudoVWSUBU_WX_MF8, 2818 }, + { PseudoVWSUB_VV_M1, 2819 }, + { PseudoVWSUB_VV_M2, 2820 }, + { PseudoVWSUB_VV_M4, 2821 }, + { PseudoVWSUB_VV_MF2, 2822 }, + { PseudoVWSUB_VV_MF4, 2823 }, + { PseudoVWSUB_VV_MF8, 2824 }, + { PseudoVWSUB_VX_M1, 2825 }, + { PseudoVWSUB_VX_M2, 2826 }, + { PseudoVWSUB_VX_M4, 2827 }, + { PseudoVWSUB_VX_MF2, 2828 }, + { PseudoVWSUB_VX_MF4, 2829 }, + { PseudoVWSUB_VX_MF8, 2830 }, + { PseudoVWSUB_WV_M1, 2831 }, + { PseudoVWSUB_WV_M2, 2832 }, + { PseudoVWSUB_WV_M4, 2833 }, + { PseudoVWSUB_WV_MF2, 2834 }, + { PseudoVWSUB_WV_MF4, 2835 }, + { PseudoVWSUB_WV_MF8, 2836 }, + { PseudoVWSUB_WX_M1, 2837 }, + { PseudoVWSUB_WX_M2, 2838 }, + { PseudoVWSUB_WX_M4, 2839 }, + { PseudoVWSUB_WX_MF2, 2840 }, + { PseudoVWSUB_WX_MF4, 2841 }, + { PseudoVWSUB_WX_MF8, 2842 }, + { PseudoVXOR_VI_M1, 2843 }, + { PseudoVXOR_VI_M2, 2844 }, + { PseudoVXOR_VI_M4, 2845 }, + { PseudoVXOR_VI_M8, 2846 }, + { PseudoVXOR_VI_MF2, 2847 }, + { PseudoVXOR_VI_MF4, 2848 }, + { PseudoVXOR_VI_MF8, 2849 }, + { PseudoVXOR_VV_M1, 2850 }, + { PseudoVXOR_VV_M2, 2851 }, + { PseudoVXOR_VV_M4, 2852 }, + { PseudoVXOR_VV_M8, 2853 }, + { PseudoVXOR_VV_MF2, 2854 }, + { PseudoVXOR_VV_MF4, 2855 }, + { PseudoVXOR_VV_MF8, 2856 }, + { PseudoVXOR_VX_M1, 2857 }, + { PseudoVXOR_VX_M2, 2858 }, + { PseudoVXOR_VX_M4, 2859 }, + { PseudoVXOR_VX_M8, 2860 }, + { PseudoVXOR_VX_MF2, 2861 }, + { PseudoVXOR_VX_MF4, 2862 }, + { PseudoVXOR_VX_MF8, 2863 }, + { PseudoVZEXT_VF2_M1, 2864 }, + { PseudoVZEXT_VF2_M2, 2865 }, + { PseudoVZEXT_VF2_M4, 2866 }, + { PseudoVZEXT_VF2_M8, 2867 }, + { PseudoVZEXT_VF2_MF2, 2868 }, + { PseudoVZEXT_VF2_MF4, 2869 }, + { PseudoVZEXT_VF4_M1, 2870 }, + { PseudoVZEXT_VF4_M2, 2871 }, + { PseudoVZEXT_VF4_M4, 2872 }, + { PseudoVZEXT_VF4_M8, 2873 }, + { PseudoVZEXT_VF4_MF2, 2874 }, + { PseudoVZEXT_VF8_M1, 2875 }, + { PseudoVZEXT_VF8_M2, 2876 }, + { PseudoVZEXT_VF8_M4, 2877 }, + { PseudoVZEXT_VF8_M8, 2878 }, + }; + + unsigned i = binsearch_IndexTypeEncoding(Index, ARR_SIZE(Index), UnmaskedPseudo); + if (i == -1) + return NULL; + else + return &RISCVMaskedPseudosTable[Index[i].index]; +} + +#endif + +#ifdef GET_RISCVOpcodesList_IMPL +static const RISCV_RISCVOpcode RISCVOpcodesList[] = { + { "LOAD", { .raw_val = RISCV_RISCVOPCODE_LOAD }, 0x3 }, // 0 + { "LOAD_FP", { .raw_val = RISCV_RISCVOPCODE_LOAD_FP }, 0x7 }, // 1 + { "CUSTOM_0", { .raw_val = RISCV_RISCVOPCODE_CUSTOM_0 }, 0xB }, // 2 + { "MISC_MEM", { .raw_val = RISCV_RISCVOPCODE_MISC_MEM }, 0xF }, // 3 + { "OP_IMM", { .raw_val = RISCV_RISCVOPCODE_OP_IMM }, 0x13 }, // 4 + { "AUIPC", { .raw_val = RISCV_RISCVOPCODE_AUIPC }, 0x17 }, // 5 + { "OP_IMM_32", { .raw_val = RISCV_RISCVOPCODE_OP_IMM_32 }, 0x1B }, // 6 + { "STORE", { .raw_val = RISCV_RISCVOPCODE_STORE }, 0x23 }, // 7 + { "STORE_FP", { .raw_val = RISCV_RISCVOPCODE_STORE_FP }, 0x27 }, // 8 + { "CUSTOM_1", { .raw_val = RISCV_RISCVOPCODE_CUSTOM_1 }, 0x2B }, // 9 + { "AMO", { .raw_val = RISCV_RISCVOPCODE_AMO }, 0x2F }, // 10 + { "OP", { .raw_val = RISCV_RISCVOPCODE_OP }, 0x33 }, // 11 + { "LUI", { .raw_val = RISCV_RISCVOPCODE_LUI }, 0x37 }, // 12 + { "OP_32", { .raw_val = RISCV_RISCVOPCODE_OP_32 }, 0x3B }, // 13 + { "MADD", { .raw_val = RISCV_RISCVOPCODE_MADD }, 0x43 }, // 14 + { "MSUB", { .raw_val = RISCV_RISCVOPCODE_MSUB }, 0x47 }, // 15 + { "NMSUB", { .raw_val = RISCV_RISCVOPCODE_NMSUB }, 0x4B }, // 16 + { "NMADD", { .raw_val = RISCV_RISCVOPCODE_NMADD }, 0x4F }, // 17 + { "OP_FP", { .raw_val = RISCV_RISCVOPCODE_OP_FP }, 0x53 }, // 18 + { "OP_V", { .raw_val = RISCV_RISCVOPCODE_OP_V }, 0x57 }, // 19 + { "CUSTOM_2", { .raw_val = RISCV_RISCVOPCODE_CUSTOM_2 }, 0x5B }, // 20 + { "BRANCH", { .raw_val = RISCV_RISCVOPCODE_BRANCH }, 0x63 }, // 21 + { "JALR", { .raw_val = RISCV_RISCVOPCODE_JALR }, 0x67 }, // 22 + { "JAL", { .raw_val = RISCV_RISCVOPCODE_JAL }, 0x6F }, // 23 + { "SYSTEM", { .raw_val = RISCV_RISCVOPCODE_SYSTEM }, 0x73 }, // 24 + { "OP_P", { .raw_val = RISCV_RISCVOPCODE_OP_P }, 0x77 }, // 25 + { "CUSTOM_3", { .raw_val = RISCV_RISCVOPCODE_CUSTOM_3 }, 0x7B }, // 26 + }; + +const RISCV_RISCVOpcode *RISCV_lookupRISCVOpcodeByValue(uint8_t Value) { +static const struct IndexType Index[] = { +{3,0}, +{7,1}, +{11,2}, +{15,3}, +{19,4}, +{23,5}, +{27,6}, +{35,7}, +{39,8}, +{43,9}, +{47,10}, +{51,11}, +{55,12}, +{59,13}, +{67,14}, +{71,15}, +{75,16}, +{79,17}, +{83,18}, +{87,19}, +{91,20}, +{99,21}, +{103,22}, +{111,23}, +{115,24}, +{119,25}, +{123,26}, +}; + unsigned i = binsearch_IndexTypeEncoding(Index, ARR_SIZE(Index), Value); + if (i == -1) + return NULL; + else + return &RISCVOpcodesList[Index[i].index]; +} + +const RISCV_RISCVOpcode *RISCV_lookupRISCVOpcodeByName(const char * Name) { + static const struct IndexTypeStr Index[] = { + { "AMO", 10 }, + { "AUIPC", 5 }, + { "BRANCH", 21 }, + { "CUSTOM_0", 2 }, + { "CUSTOM_1", 9 }, + { "CUSTOM_2", 20 }, + { "CUSTOM_3", 26 }, + { "JAL", 23 }, + { "JALR", 22 }, + { "LOAD", 0 }, + { "LOAD_FP", 1 }, + { "LUI", 12 }, + { "MADD", 14 }, + { "MISC_MEM", 3 }, + { "MSUB", 15 }, + { "NMADD", 17 }, + { "NMSUB", 16 }, + { "OP", 11 }, + { "OP_32", 13 }, + { "OP_FP", 18 }, + { "OP_IMM", 4 }, + { "OP_IMM_32", 6 }, + { "OP_P", 25 }, + { "OP_V", 19 }, + { "STORE", 7 }, + { "STORE_FP", 8 }, + { "SYSTEM", 24 }, + }; + + unsigned i = binsearch_IndexTypeStrEncoding(Index, ARR_SIZE(Index), Name); + if (i == -1) + return NULL; + else + return &RISCVOpcodesList[Index[i].index]; +} + +#endif + +#ifdef GET_RISCVTuneInfoTable_IMPL +static const RISCV_RISCVTuneInfo RISCVTuneInfoTable[] = { + { "generic", { .raw_val = RISCV_RISCVTUNEINFO_GENERIC }, 0x1, 0x1, 0x0, 0x0, 0x1, 0xFFFFFFFF, 0x5 }, // 0 + { "generic-rv32", { .raw_val = RISCV_RISCVTUNEINFO_GENERIC-RV32 }, 0x1, 0x1, 0x0, 0x0, 0x1, 0xFFFFFFFF, 0x5 }, // 1 + { "generic-rv64", { .raw_val = RISCV_RISCVTUNEINFO_GENERIC-RV64 }, 0x1, 0x1, 0x0, 0x0, 0x1, 0xFFFFFFFF, 0x5 }, // 2 + }; + +const RISCV_RISCVTuneInfo *RISCV_getRISCVTuneInfo(const char * Name) { + static const struct IndexTypeStr Index[] = { + { "GENERIC", 0 }, + { "GENERIC-RV32", 1 }, + { "GENERIC-RV64", 2 }, + }; + + unsigned i = binsearch_IndexTypeStrEncoding(Index, ARR_SIZE(Index), Name); + if (i == -1) + return NULL; + else + return &RISCVTuneInfoTable[Index[i].index]; +} + +#endif + +#ifdef GET_RISCVVInversePseudosTable_IMPL +static const RISCV_PseudoInfo RISCVVInversePseudosTable[] = { + { PseudoTHVdotVMAQASU_VV_M1, THVdotVMAQASU_VV, 0x0, 0x0 }, // 0 + { PseudoTHVdotVMAQASU_VV_M1_MASK, THVdotVMAQASU_VV, 0x0, 0x0 }, // 1 + { PseudoTHVdotVMAQASU_VV_M2, THVdotVMAQASU_VV, 0x1, 0x0 }, // 2 + { PseudoTHVdotVMAQASU_VV_M2_MASK, THVdotVMAQASU_VV, 0x1, 0x0 }, // 3 + { PseudoTHVdotVMAQASU_VV_M4, THVdotVMAQASU_VV, 0x2, 0x0 }, // 4 + { PseudoTHVdotVMAQASU_VV_M4_MASK, THVdotVMAQASU_VV, 0x2, 0x0 }, // 5 + { PseudoTHVdotVMAQASU_VV_M8, THVdotVMAQASU_VV, 0x3, 0x0 }, // 6 + { PseudoTHVdotVMAQASU_VV_M8_MASK, THVdotVMAQASU_VV, 0x3, 0x0 }, // 7 + { PseudoTHVdotVMAQASU_VV_MF2, THVdotVMAQASU_VV, 0x7, 0x0 }, // 8 + { PseudoTHVdotVMAQASU_VV_MF2_MASK, THVdotVMAQASU_VV, 0x7, 0x0 }, // 9 + { PseudoTHVdotVMAQASU_VX_M1, THVdotVMAQASU_VX, 0x0, 0x0 }, // 10 + { PseudoTHVdotVMAQASU_VX_M1_MASK, THVdotVMAQASU_VX, 0x0, 0x0 }, // 11 + { PseudoTHVdotVMAQASU_VX_M2, THVdotVMAQASU_VX, 0x1, 0x0 }, // 12 + { PseudoTHVdotVMAQASU_VX_M2_MASK, THVdotVMAQASU_VX, 0x1, 0x0 }, // 13 + { PseudoTHVdotVMAQASU_VX_M4, THVdotVMAQASU_VX, 0x2, 0x0 }, // 14 + { PseudoTHVdotVMAQASU_VX_M4_MASK, THVdotVMAQASU_VX, 0x2, 0x0 }, // 15 + { PseudoTHVdotVMAQASU_VX_M8, THVdotVMAQASU_VX, 0x3, 0x0 }, // 16 + { PseudoTHVdotVMAQASU_VX_M8_MASK, THVdotVMAQASU_VX, 0x3, 0x0 }, // 17 + { PseudoTHVdotVMAQASU_VX_MF2, THVdotVMAQASU_VX, 0x7, 0x0 }, // 18 + { PseudoTHVdotVMAQASU_VX_MF2_MASK, THVdotVMAQASU_VX, 0x7, 0x0 }, // 19 + { PseudoTHVdotVMAQAUS_VX_M1, THVdotVMAQAUS_VX, 0x0, 0x0 }, // 20 + { PseudoTHVdotVMAQAUS_VX_M1_MASK, THVdotVMAQAUS_VX, 0x0, 0x0 }, // 21 + { PseudoTHVdotVMAQAUS_VX_M2, THVdotVMAQAUS_VX, 0x1, 0x0 }, // 22 + { PseudoTHVdotVMAQAUS_VX_M2_MASK, THVdotVMAQAUS_VX, 0x1, 0x0 }, // 23 + { PseudoTHVdotVMAQAUS_VX_M4, THVdotVMAQAUS_VX, 0x2, 0x0 }, // 24 + { PseudoTHVdotVMAQAUS_VX_M4_MASK, THVdotVMAQAUS_VX, 0x2, 0x0 }, // 25 + { PseudoTHVdotVMAQAUS_VX_M8, THVdotVMAQAUS_VX, 0x3, 0x0 }, // 26 + { PseudoTHVdotVMAQAUS_VX_M8_MASK, THVdotVMAQAUS_VX, 0x3, 0x0 }, // 27 + { PseudoTHVdotVMAQAUS_VX_MF2, THVdotVMAQAUS_VX, 0x7, 0x0 }, // 28 + { PseudoTHVdotVMAQAUS_VX_MF2_MASK, THVdotVMAQAUS_VX, 0x7, 0x0 }, // 29 + { PseudoTHVdotVMAQAU_VV_M1, THVdotVMAQAU_VV, 0x0, 0x0 }, // 30 + { PseudoTHVdotVMAQAU_VV_M1_MASK, THVdotVMAQAU_VV, 0x0, 0x0 }, // 31 + { PseudoTHVdotVMAQAU_VV_M2, THVdotVMAQAU_VV, 0x1, 0x0 }, // 32 + { PseudoTHVdotVMAQAU_VV_M2_MASK, THVdotVMAQAU_VV, 0x1, 0x0 }, // 33 + { PseudoTHVdotVMAQAU_VV_M4, THVdotVMAQAU_VV, 0x2, 0x0 }, // 34 + { PseudoTHVdotVMAQAU_VV_M4_MASK, THVdotVMAQAU_VV, 0x2, 0x0 }, // 35 + { PseudoTHVdotVMAQAU_VV_M8, THVdotVMAQAU_VV, 0x3, 0x0 }, // 36 + { PseudoTHVdotVMAQAU_VV_M8_MASK, THVdotVMAQAU_VV, 0x3, 0x0 }, // 37 + { PseudoTHVdotVMAQAU_VV_MF2, THVdotVMAQAU_VV, 0x7, 0x0 }, // 38 + { PseudoTHVdotVMAQAU_VV_MF2_MASK, THVdotVMAQAU_VV, 0x7, 0x0 }, // 39 + { PseudoTHVdotVMAQAU_VX_M1, THVdotVMAQAU_VX, 0x0, 0x0 }, // 40 + { PseudoTHVdotVMAQAU_VX_M1_MASK, THVdotVMAQAU_VX, 0x0, 0x0 }, // 41 + { PseudoTHVdotVMAQAU_VX_M2, THVdotVMAQAU_VX, 0x1, 0x0 }, // 42 + { PseudoTHVdotVMAQAU_VX_M2_MASK, THVdotVMAQAU_VX, 0x1, 0x0 }, // 43 + { PseudoTHVdotVMAQAU_VX_M4, THVdotVMAQAU_VX, 0x2, 0x0 }, // 44 + { PseudoTHVdotVMAQAU_VX_M4_MASK, THVdotVMAQAU_VX, 0x2, 0x0 }, // 45 + { PseudoTHVdotVMAQAU_VX_M8, THVdotVMAQAU_VX, 0x3, 0x0 }, // 46 + { PseudoTHVdotVMAQAU_VX_M8_MASK, THVdotVMAQAU_VX, 0x3, 0x0 }, // 47 + { PseudoTHVdotVMAQAU_VX_MF2, THVdotVMAQAU_VX, 0x7, 0x0 }, // 48 + { PseudoTHVdotVMAQAU_VX_MF2_MASK, THVdotVMAQAU_VX, 0x7, 0x0 }, // 49 + { PseudoTHVdotVMAQA_VV_M1, THVdotVMAQA_VV, 0x0, 0x0 }, // 50 + { PseudoTHVdotVMAQA_VV_M1_MASK, THVdotVMAQA_VV, 0x0, 0x0 }, // 51 + { PseudoTHVdotVMAQA_VV_M2, THVdotVMAQA_VV, 0x1, 0x0 }, // 52 + { PseudoTHVdotVMAQA_VV_M2_MASK, THVdotVMAQA_VV, 0x1, 0x0 }, // 53 + { PseudoTHVdotVMAQA_VV_M4, THVdotVMAQA_VV, 0x2, 0x0 }, // 54 + { PseudoTHVdotVMAQA_VV_M4_MASK, THVdotVMAQA_VV, 0x2, 0x0 }, // 55 + { PseudoTHVdotVMAQA_VV_M8, THVdotVMAQA_VV, 0x3, 0x0 }, // 56 + { PseudoTHVdotVMAQA_VV_M8_MASK, THVdotVMAQA_VV, 0x3, 0x0 }, // 57 + { PseudoTHVdotVMAQA_VV_MF2, THVdotVMAQA_VV, 0x7, 0x0 }, // 58 + { PseudoTHVdotVMAQA_VV_MF2_MASK, THVdotVMAQA_VV, 0x7, 0x0 }, // 59 + { PseudoTHVdotVMAQA_VX_M1, THVdotVMAQA_VX, 0x0, 0x0 }, // 60 + { PseudoTHVdotVMAQA_VX_M1_MASK, THVdotVMAQA_VX, 0x0, 0x0 }, // 61 + { PseudoTHVdotVMAQA_VX_M2, THVdotVMAQA_VX, 0x1, 0x0 }, // 62 + { PseudoTHVdotVMAQA_VX_M2_MASK, THVdotVMAQA_VX, 0x1, 0x0 }, // 63 + { PseudoTHVdotVMAQA_VX_M4, THVdotVMAQA_VX, 0x2, 0x0 }, // 64 + { PseudoTHVdotVMAQA_VX_M4_MASK, THVdotVMAQA_VX, 0x2, 0x0 }, // 65 + { PseudoTHVdotVMAQA_VX_M8, THVdotVMAQA_VX, 0x3, 0x0 }, // 66 + { PseudoTHVdotVMAQA_VX_M8_MASK, THVdotVMAQA_VX, 0x3, 0x0 }, // 67 + { PseudoTHVdotVMAQA_VX_MF2, THVdotVMAQA_VX, 0x7, 0x0 }, // 68 + { PseudoTHVdotVMAQA_VX_MF2_MASK, THVdotVMAQA_VX, 0x7, 0x0 }, // 69 + { PseudoVAADDU_VV_M1, VAADDU_VV, 0x0, 0x0 }, // 70 + { PseudoVAADDU_VV_M1_MASK, VAADDU_VV, 0x0, 0x0 }, // 71 + { PseudoVAADDU_VV_M2, VAADDU_VV, 0x1, 0x0 }, // 72 + { PseudoVAADDU_VV_M2_MASK, VAADDU_VV, 0x1, 0x0 }, // 73 + { PseudoVAADDU_VV_M4, VAADDU_VV, 0x2, 0x0 }, // 74 + { PseudoVAADDU_VV_M4_MASK, VAADDU_VV, 0x2, 0x0 }, // 75 + { PseudoVAADDU_VV_M8, VAADDU_VV, 0x3, 0x0 }, // 76 + { PseudoVAADDU_VV_M8_MASK, VAADDU_VV, 0x3, 0x0 }, // 77 + { PseudoVAADDU_VV_MF8, VAADDU_VV, 0x5, 0x0 }, // 78 + { PseudoVAADDU_VV_MF8_MASK, VAADDU_VV, 0x5, 0x0 }, // 79 + { PseudoVAADDU_VV_MF4, VAADDU_VV, 0x6, 0x0 }, // 80 + { PseudoVAADDU_VV_MF4_MASK, VAADDU_VV, 0x6, 0x0 }, // 81 + { PseudoVAADDU_VV_MF2, VAADDU_VV, 0x7, 0x0 }, // 82 + { PseudoVAADDU_VV_MF2_MASK, VAADDU_VV, 0x7, 0x0 }, // 83 + { PseudoVAADDU_VX_M1, VAADDU_VX, 0x0, 0x0 }, // 84 + { PseudoVAADDU_VX_M1_MASK, VAADDU_VX, 0x0, 0x0 }, // 85 + { PseudoVAADDU_VX_M2, VAADDU_VX, 0x1, 0x0 }, // 86 + { PseudoVAADDU_VX_M2_MASK, VAADDU_VX, 0x1, 0x0 }, // 87 + { PseudoVAADDU_VX_M4, VAADDU_VX, 0x2, 0x0 }, // 88 + { PseudoVAADDU_VX_M4_MASK, VAADDU_VX, 0x2, 0x0 }, // 89 + { PseudoVAADDU_VX_M8, VAADDU_VX, 0x3, 0x0 }, // 90 + { PseudoVAADDU_VX_M8_MASK, VAADDU_VX, 0x3, 0x0 }, // 91 + { PseudoVAADDU_VX_MF8, VAADDU_VX, 0x5, 0x0 }, // 92 + { PseudoVAADDU_VX_MF8_MASK, VAADDU_VX, 0x5, 0x0 }, // 93 + { PseudoVAADDU_VX_MF4, VAADDU_VX, 0x6, 0x0 }, // 94 + { PseudoVAADDU_VX_MF4_MASK, VAADDU_VX, 0x6, 0x0 }, // 95 + { PseudoVAADDU_VX_MF2, VAADDU_VX, 0x7, 0x0 }, // 96 + { PseudoVAADDU_VX_MF2_MASK, VAADDU_VX, 0x7, 0x0 }, // 97 + { PseudoVAADD_VV_M1, VAADD_VV, 0x0, 0x0 }, // 98 + { PseudoVAADD_VV_M1_MASK, VAADD_VV, 0x0, 0x0 }, // 99 + { PseudoVAADD_VV_M2, VAADD_VV, 0x1, 0x0 }, // 100 + { PseudoVAADD_VV_M2_MASK, VAADD_VV, 0x1, 0x0 }, // 101 + { PseudoVAADD_VV_M4, VAADD_VV, 0x2, 0x0 }, // 102 + { PseudoVAADD_VV_M4_MASK, VAADD_VV, 0x2, 0x0 }, // 103 + { PseudoVAADD_VV_M8, VAADD_VV, 0x3, 0x0 }, // 104 + { PseudoVAADD_VV_M8_MASK, VAADD_VV, 0x3, 0x0 }, // 105 + { PseudoVAADD_VV_MF8, VAADD_VV, 0x5, 0x0 }, // 106 + { PseudoVAADD_VV_MF8_MASK, VAADD_VV, 0x5, 0x0 }, // 107 + { PseudoVAADD_VV_MF4, VAADD_VV, 0x6, 0x0 }, // 108 + { PseudoVAADD_VV_MF4_MASK, VAADD_VV, 0x6, 0x0 }, // 109 + { PseudoVAADD_VV_MF2, VAADD_VV, 0x7, 0x0 }, // 110 + { PseudoVAADD_VV_MF2_MASK, VAADD_VV, 0x7, 0x0 }, // 111 + { PseudoVAADD_VX_M1, VAADD_VX, 0x0, 0x0 }, // 112 + { PseudoVAADD_VX_M1_MASK, VAADD_VX, 0x0, 0x0 }, // 113 + { PseudoVAADD_VX_M2, VAADD_VX, 0x1, 0x0 }, // 114 + { PseudoVAADD_VX_M2_MASK, VAADD_VX, 0x1, 0x0 }, // 115 + { PseudoVAADD_VX_M4, VAADD_VX, 0x2, 0x0 }, // 116 + { PseudoVAADD_VX_M4_MASK, VAADD_VX, 0x2, 0x0 }, // 117 + { PseudoVAADD_VX_M8, VAADD_VX, 0x3, 0x0 }, // 118 + { PseudoVAADD_VX_M8_MASK, VAADD_VX, 0x3, 0x0 }, // 119 + { PseudoVAADD_VX_MF8, VAADD_VX, 0x5, 0x0 }, // 120 + { PseudoVAADD_VX_MF8_MASK, VAADD_VX, 0x5, 0x0 }, // 121 + { PseudoVAADD_VX_MF4, VAADD_VX, 0x6, 0x0 }, // 122 + { PseudoVAADD_VX_MF4_MASK, VAADD_VX, 0x6, 0x0 }, // 123 + { PseudoVAADD_VX_MF2, VAADD_VX, 0x7, 0x0 }, // 124 + { PseudoVAADD_VX_MF2_MASK, VAADD_VX, 0x7, 0x0 }, // 125 + { PseudoVADC_VIM_M1, VADC_VIM, 0x0, 0x0 }, // 126 + { PseudoVADC_VIM_M2, VADC_VIM, 0x1, 0x0 }, // 127 + { PseudoVADC_VIM_M4, VADC_VIM, 0x2, 0x0 }, // 128 + { PseudoVADC_VIM_M8, VADC_VIM, 0x3, 0x0 }, // 129 + { PseudoVADC_VIM_MF8, VADC_VIM, 0x5, 0x0 }, // 130 + { PseudoVADC_VIM_MF4, VADC_VIM, 0x6, 0x0 }, // 131 + { PseudoVADC_VIM_MF2, VADC_VIM, 0x7, 0x0 }, // 132 + { PseudoVADC_VVM_M1, VADC_VVM, 0x0, 0x0 }, // 133 + { PseudoVADC_VVM_M2, VADC_VVM, 0x1, 0x0 }, // 134 + { PseudoVADC_VVM_M4, VADC_VVM, 0x2, 0x0 }, // 135 + { PseudoVADC_VVM_M8, VADC_VVM, 0x3, 0x0 }, // 136 + { PseudoVADC_VVM_MF8, VADC_VVM, 0x5, 0x0 }, // 137 + { PseudoVADC_VVM_MF4, VADC_VVM, 0x6, 0x0 }, // 138 + { PseudoVADC_VVM_MF2, VADC_VVM, 0x7, 0x0 }, // 139 + { PseudoVADC_VXM_M1, VADC_VXM, 0x0, 0x0 }, // 140 + { PseudoVADC_VXM_M2, VADC_VXM, 0x1, 0x0 }, // 141 + { PseudoVADC_VXM_M4, VADC_VXM, 0x2, 0x0 }, // 142 + { PseudoVADC_VXM_M8, VADC_VXM, 0x3, 0x0 }, // 143 + { PseudoVADC_VXM_MF8, VADC_VXM, 0x5, 0x0 }, // 144 + { PseudoVADC_VXM_MF4, VADC_VXM, 0x6, 0x0 }, // 145 + { PseudoVADC_VXM_MF2, VADC_VXM, 0x7, 0x0 }, // 146 + { PseudoVADD_VI_M1, VADD_VI, 0x0, 0x0 }, // 147 + { PseudoVADD_VI_M1_MASK, VADD_VI, 0x0, 0x0 }, // 148 + { PseudoVADD_VI_M2, VADD_VI, 0x1, 0x0 }, // 149 + { PseudoVADD_VI_M2_MASK, VADD_VI, 0x1, 0x0 }, // 150 + { PseudoVADD_VI_M4, VADD_VI, 0x2, 0x0 }, // 151 + { PseudoVADD_VI_M4_MASK, VADD_VI, 0x2, 0x0 }, // 152 + { PseudoVADD_VI_M8, VADD_VI, 0x3, 0x0 }, // 153 + { PseudoVADD_VI_M8_MASK, VADD_VI, 0x3, 0x0 }, // 154 + { PseudoVADD_VI_MF8, VADD_VI, 0x5, 0x0 }, // 155 + { PseudoVADD_VI_MF8_MASK, VADD_VI, 0x5, 0x0 }, // 156 + { PseudoVADD_VI_MF4, VADD_VI, 0x6, 0x0 }, // 157 + { PseudoVADD_VI_MF4_MASK, VADD_VI, 0x6, 0x0 }, // 158 + { PseudoVADD_VI_MF2, VADD_VI, 0x7, 0x0 }, // 159 + { PseudoVADD_VI_MF2_MASK, VADD_VI, 0x7, 0x0 }, // 160 + { PseudoVADD_VV_M1, VADD_VV, 0x0, 0x0 }, // 161 + { PseudoVADD_VV_M1_MASK, VADD_VV, 0x0, 0x0 }, // 162 + { PseudoVADD_VV_M2, VADD_VV, 0x1, 0x0 }, // 163 + { PseudoVADD_VV_M2_MASK, VADD_VV, 0x1, 0x0 }, // 164 + { PseudoVADD_VV_M4, VADD_VV, 0x2, 0x0 }, // 165 + { PseudoVADD_VV_M4_MASK, VADD_VV, 0x2, 0x0 }, // 166 + { PseudoVADD_VV_M8, VADD_VV, 0x3, 0x0 }, // 167 + { PseudoVADD_VV_M8_MASK, VADD_VV, 0x3, 0x0 }, // 168 + { PseudoVADD_VV_MF8, VADD_VV, 0x5, 0x0 }, // 169 + { PseudoVADD_VV_MF8_MASK, VADD_VV, 0x5, 0x0 }, // 170 + { PseudoVADD_VV_MF4, VADD_VV, 0x6, 0x0 }, // 171 + { PseudoVADD_VV_MF4_MASK, VADD_VV, 0x6, 0x0 }, // 172 + { PseudoVADD_VV_MF2, VADD_VV, 0x7, 0x0 }, // 173 + { PseudoVADD_VV_MF2_MASK, VADD_VV, 0x7, 0x0 }, // 174 + { PseudoVADD_VX_M1, VADD_VX, 0x0, 0x0 }, // 175 + { PseudoVADD_VX_M1_MASK, VADD_VX, 0x0, 0x0 }, // 176 + { PseudoVADD_VX_M2, VADD_VX, 0x1, 0x0 }, // 177 + { PseudoVADD_VX_M2_MASK, VADD_VX, 0x1, 0x0 }, // 178 + { PseudoVADD_VX_M4, VADD_VX, 0x2, 0x0 }, // 179 + { PseudoVADD_VX_M4_MASK, VADD_VX, 0x2, 0x0 }, // 180 + { PseudoVADD_VX_M8, VADD_VX, 0x3, 0x0 }, // 181 + { PseudoVADD_VX_M8_MASK, VADD_VX, 0x3, 0x0 }, // 182 + { PseudoVADD_VX_MF8, VADD_VX, 0x5, 0x0 }, // 183 + { PseudoVADD_VX_MF8_MASK, VADD_VX, 0x5, 0x0 }, // 184 + { PseudoVADD_VX_MF4, VADD_VX, 0x6, 0x0 }, // 185 + { PseudoVADD_VX_MF4_MASK, VADD_VX, 0x6, 0x0 }, // 186 + { PseudoVADD_VX_MF2, VADD_VX, 0x7, 0x0 }, // 187 + { PseudoVADD_VX_MF2_MASK, VADD_VX, 0x7, 0x0 }, // 188 + { PseudoVAESDF_VS_M1_M1, VAESDF_VS, 0x0, 0x0 }, // 189 + { PseudoVAESDF_VS_M1_MF2, VAESDF_VS, 0x0, 0x0 }, // 190 + { PseudoVAESDF_VS_M1_MF4, VAESDF_VS, 0x0, 0x0 }, // 191 + { PseudoVAESDF_VS_M1_MF8, VAESDF_VS, 0x0, 0x0 }, // 192 + { PseudoVAESDF_VS_M2_M1, VAESDF_VS, 0x1, 0x0 }, // 193 + { PseudoVAESDF_VS_M2_M2, VAESDF_VS, 0x1, 0x0 }, // 194 + { PseudoVAESDF_VS_M2_MF2, VAESDF_VS, 0x1, 0x0 }, // 195 + { PseudoVAESDF_VS_M2_MF4, VAESDF_VS, 0x1, 0x0 }, // 196 + { PseudoVAESDF_VS_M2_MF8, VAESDF_VS, 0x1, 0x0 }, // 197 + { PseudoVAESDF_VS_M4_M1, VAESDF_VS, 0x2, 0x0 }, // 198 + { PseudoVAESDF_VS_M4_M2, VAESDF_VS, 0x2, 0x0 }, // 199 + { PseudoVAESDF_VS_M4_M4, VAESDF_VS, 0x2, 0x0 }, // 200 + { PseudoVAESDF_VS_M4_MF2, VAESDF_VS, 0x2, 0x0 }, // 201 + { PseudoVAESDF_VS_M4_MF4, VAESDF_VS, 0x2, 0x0 }, // 202 + { PseudoVAESDF_VS_M4_MF8, VAESDF_VS, 0x2, 0x0 }, // 203 + { PseudoVAESDF_VS_M8_M1, VAESDF_VS, 0x3, 0x0 }, // 204 + { PseudoVAESDF_VS_M8_M2, VAESDF_VS, 0x3, 0x0 }, // 205 + { PseudoVAESDF_VS_M8_M4, VAESDF_VS, 0x3, 0x0 }, // 206 + { PseudoVAESDF_VS_M8_MF2, VAESDF_VS, 0x3, 0x0 }, // 207 + { PseudoVAESDF_VS_M8_MF4, VAESDF_VS, 0x3, 0x0 }, // 208 + { PseudoVAESDF_VS_M8_MF8, VAESDF_VS, 0x3, 0x0 }, // 209 + { PseudoVAESDF_VS_MF2_MF2, VAESDF_VS, 0x7, 0x0 }, // 210 + { PseudoVAESDF_VS_MF2_MF4, VAESDF_VS, 0x7, 0x0 }, // 211 + { PseudoVAESDF_VS_MF2_MF8, VAESDF_VS, 0x7, 0x0 }, // 212 + { PseudoVAESDF_VV_M1, VAESDF_VV, 0x0, 0x0 }, // 213 + { PseudoVAESDF_VV_M2, VAESDF_VV, 0x1, 0x0 }, // 214 + { PseudoVAESDF_VV_M4, VAESDF_VV, 0x2, 0x0 }, // 215 + { PseudoVAESDF_VV_M8, VAESDF_VV, 0x3, 0x0 }, // 216 + { PseudoVAESDF_VV_MF2, VAESDF_VV, 0x7, 0x0 }, // 217 + { PseudoVAESDM_VS_M1_M1, VAESDM_VS, 0x0, 0x0 }, // 218 + { PseudoVAESDM_VS_M1_MF2, VAESDM_VS, 0x0, 0x0 }, // 219 + { PseudoVAESDM_VS_M1_MF4, VAESDM_VS, 0x0, 0x0 }, // 220 + { PseudoVAESDM_VS_M1_MF8, VAESDM_VS, 0x0, 0x0 }, // 221 + { PseudoVAESDM_VS_M2_M1, VAESDM_VS, 0x1, 0x0 }, // 222 + { PseudoVAESDM_VS_M2_M2, VAESDM_VS, 0x1, 0x0 }, // 223 + { PseudoVAESDM_VS_M2_MF2, VAESDM_VS, 0x1, 0x0 }, // 224 + { PseudoVAESDM_VS_M2_MF4, VAESDM_VS, 0x1, 0x0 }, // 225 + { PseudoVAESDM_VS_M2_MF8, VAESDM_VS, 0x1, 0x0 }, // 226 + { PseudoVAESDM_VS_M4_M1, VAESDM_VS, 0x2, 0x0 }, // 227 + { PseudoVAESDM_VS_M4_M2, VAESDM_VS, 0x2, 0x0 }, // 228 + { PseudoVAESDM_VS_M4_M4, VAESDM_VS, 0x2, 0x0 }, // 229 + { PseudoVAESDM_VS_M4_MF2, VAESDM_VS, 0x2, 0x0 }, // 230 + { PseudoVAESDM_VS_M4_MF4, VAESDM_VS, 0x2, 0x0 }, // 231 + { PseudoVAESDM_VS_M4_MF8, VAESDM_VS, 0x2, 0x0 }, // 232 + { PseudoVAESDM_VS_M8_M1, VAESDM_VS, 0x3, 0x0 }, // 233 + { PseudoVAESDM_VS_M8_M2, VAESDM_VS, 0x3, 0x0 }, // 234 + { PseudoVAESDM_VS_M8_M4, VAESDM_VS, 0x3, 0x0 }, // 235 + { PseudoVAESDM_VS_M8_MF2, VAESDM_VS, 0x3, 0x0 }, // 236 + { PseudoVAESDM_VS_M8_MF4, VAESDM_VS, 0x3, 0x0 }, // 237 + { PseudoVAESDM_VS_M8_MF8, VAESDM_VS, 0x3, 0x0 }, // 238 + { PseudoVAESDM_VS_MF2_MF2, VAESDM_VS, 0x7, 0x0 }, // 239 + { PseudoVAESDM_VS_MF2_MF4, VAESDM_VS, 0x7, 0x0 }, // 240 + { PseudoVAESDM_VS_MF2_MF8, VAESDM_VS, 0x7, 0x0 }, // 241 + { PseudoVAESDM_VV_M1, VAESDM_VV, 0x0, 0x0 }, // 242 + { PseudoVAESDM_VV_M2, VAESDM_VV, 0x1, 0x0 }, // 243 + { PseudoVAESDM_VV_M4, VAESDM_VV, 0x2, 0x0 }, // 244 + { PseudoVAESDM_VV_M8, VAESDM_VV, 0x3, 0x0 }, // 245 + { PseudoVAESDM_VV_MF2, VAESDM_VV, 0x7, 0x0 }, // 246 + { PseudoVAESEF_VS_M1_M1, VAESEF_VS, 0x0, 0x0 }, // 247 + { PseudoVAESEF_VS_M1_MF2, VAESEF_VS, 0x0, 0x0 }, // 248 + { PseudoVAESEF_VS_M1_MF4, VAESEF_VS, 0x0, 0x0 }, // 249 + { PseudoVAESEF_VS_M1_MF8, VAESEF_VS, 0x0, 0x0 }, // 250 + { PseudoVAESEF_VS_M2_M1, VAESEF_VS, 0x1, 0x0 }, // 251 + { PseudoVAESEF_VS_M2_M2, VAESEF_VS, 0x1, 0x0 }, // 252 + { PseudoVAESEF_VS_M2_MF2, VAESEF_VS, 0x1, 0x0 }, // 253 + { PseudoVAESEF_VS_M2_MF4, VAESEF_VS, 0x1, 0x0 }, // 254 + { PseudoVAESEF_VS_M2_MF8, VAESEF_VS, 0x1, 0x0 }, // 255 + { PseudoVAESEF_VS_M4_M1, VAESEF_VS, 0x2, 0x0 }, // 256 + { PseudoVAESEF_VS_M4_M2, VAESEF_VS, 0x2, 0x0 }, // 257 + { PseudoVAESEF_VS_M4_M4, VAESEF_VS, 0x2, 0x0 }, // 258 + { PseudoVAESEF_VS_M4_MF2, VAESEF_VS, 0x2, 0x0 }, // 259 + { PseudoVAESEF_VS_M4_MF4, VAESEF_VS, 0x2, 0x0 }, // 260 + { PseudoVAESEF_VS_M4_MF8, VAESEF_VS, 0x2, 0x0 }, // 261 + { PseudoVAESEF_VS_M8_M1, VAESEF_VS, 0x3, 0x0 }, // 262 + { PseudoVAESEF_VS_M8_M2, VAESEF_VS, 0x3, 0x0 }, // 263 + { PseudoVAESEF_VS_M8_M4, VAESEF_VS, 0x3, 0x0 }, // 264 + { PseudoVAESEF_VS_M8_MF2, VAESEF_VS, 0x3, 0x0 }, // 265 + { PseudoVAESEF_VS_M8_MF4, VAESEF_VS, 0x3, 0x0 }, // 266 + { PseudoVAESEF_VS_M8_MF8, VAESEF_VS, 0x3, 0x0 }, // 267 + { PseudoVAESEF_VS_MF2_MF2, VAESEF_VS, 0x7, 0x0 }, // 268 + { PseudoVAESEF_VS_MF2_MF4, VAESEF_VS, 0x7, 0x0 }, // 269 + { PseudoVAESEF_VS_MF2_MF8, VAESEF_VS, 0x7, 0x0 }, // 270 + { PseudoVAESEF_VV_M1, VAESEF_VV, 0x0, 0x0 }, // 271 + { PseudoVAESEF_VV_M2, VAESEF_VV, 0x1, 0x0 }, // 272 + { PseudoVAESEF_VV_M4, VAESEF_VV, 0x2, 0x0 }, // 273 + { PseudoVAESEF_VV_M8, VAESEF_VV, 0x3, 0x0 }, // 274 + { PseudoVAESEF_VV_MF2, VAESEF_VV, 0x7, 0x0 }, // 275 + { PseudoVAESEM_VS_M1_M1, VAESEM_VS, 0x0, 0x0 }, // 276 + { PseudoVAESEM_VS_M1_MF2, VAESEM_VS, 0x0, 0x0 }, // 277 + { PseudoVAESEM_VS_M1_MF4, VAESEM_VS, 0x0, 0x0 }, // 278 + { PseudoVAESEM_VS_M1_MF8, VAESEM_VS, 0x0, 0x0 }, // 279 + { PseudoVAESEM_VS_M2_M1, VAESEM_VS, 0x1, 0x0 }, // 280 + { PseudoVAESEM_VS_M2_M2, VAESEM_VS, 0x1, 0x0 }, // 281 + { PseudoVAESEM_VS_M2_MF2, VAESEM_VS, 0x1, 0x0 }, // 282 + { PseudoVAESEM_VS_M2_MF4, VAESEM_VS, 0x1, 0x0 }, // 283 + { PseudoVAESEM_VS_M2_MF8, VAESEM_VS, 0x1, 0x0 }, // 284 + { PseudoVAESEM_VS_M4_M1, VAESEM_VS, 0x2, 0x0 }, // 285 + { PseudoVAESEM_VS_M4_M2, VAESEM_VS, 0x2, 0x0 }, // 286 + { PseudoVAESEM_VS_M4_M4, VAESEM_VS, 0x2, 0x0 }, // 287 + { PseudoVAESEM_VS_M4_MF2, VAESEM_VS, 0x2, 0x0 }, // 288 + { PseudoVAESEM_VS_M4_MF4, VAESEM_VS, 0x2, 0x0 }, // 289 + { PseudoVAESEM_VS_M4_MF8, VAESEM_VS, 0x2, 0x0 }, // 290 + { PseudoVAESEM_VS_M8_M1, VAESEM_VS, 0x3, 0x0 }, // 291 + { PseudoVAESEM_VS_M8_M2, VAESEM_VS, 0x3, 0x0 }, // 292 + { PseudoVAESEM_VS_M8_M4, VAESEM_VS, 0x3, 0x0 }, // 293 + { PseudoVAESEM_VS_M8_MF2, VAESEM_VS, 0x3, 0x0 }, // 294 + { PseudoVAESEM_VS_M8_MF4, VAESEM_VS, 0x3, 0x0 }, // 295 + { PseudoVAESEM_VS_M8_MF8, VAESEM_VS, 0x3, 0x0 }, // 296 + { PseudoVAESEM_VS_MF2_MF2, VAESEM_VS, 0x7, 0x0 }, // 297 + { PseudoVAESEM_VS_MF2_MF4, VAESEM_VS, 0x7, 0x0 }, // 298 + { PseudoVAESEM_VS_MF2_MF8, VAESEM_VS, 0x7, 0x0 }, // 299 + { PseudoVAESEM_VV_M1, VAESEM_VV, 0x0, 0x0 }, // 300 + { PseudoVAESEM_VV_M2, VAESEM_VV, 0x1, 0x0 }, // 301 + { PseudoVAESEM_VV_M4, VAESEM_VV, 0x2, 0x0 }, // 302 + { PseudoVAESEM_VV_M8, VAESEM_VV, 0x3, 0x0 }, // 303 + { PseudoVAESEM_VV_MF2, VAESEM_VV, 0x7, 0x0 }, // 304 + { PseudoVAESKF1_VI_M1, VAESKF1_VI, 0x0, 0x0 }, // 305 + { PseudoVAESKF1_VI_M2, VAESKF1_VI, 0x1, 0x0 }, // 306 + { PseudoVAESKF1_VI_M4, VAESKF1_VI, 0x2, 0x0 }, // 307 + { PseudoVAESKF1_VI_M8, VAESKF1_VI, 0x3, 0x0 }, // 308 + { PseudoVAESKF1_VI_MF2, VAESKF1_VI, 0x7, 0x0 }, // 309 + { PseudoVAESKF2_VI_M1, VAESKF2_VI, 0x0, 0x0 }, // 310 + { PseudoVAESKF2_VI_M2, VAESKF2_VI, 0x1, 0x0 }, // 311 + { PseudoVAESKF2_VI_M4, VAESKF2_VI, 0x2, 0x0 }, // 312 + { PseudoVAESKF2_VI_M8, VAESKF2_VI, 0x3, 0x0 }, // 313 + { PseudoVAESKF2_VI_MF2, VAESKF2_VI, 0x7, 0x0 }, // 314 + { PseudoVAESZ_VS_M1_M1, VAESZ_VS, 0x0, 0x0 }, // 315 + { PseudoVAESZ_VS_M1_MF2, VAESZ_VS, 0x0, 0x0 }, // 316 + { PseudoVAESZ_VS_M1_MF4, VAESZ_VS, 0x0, 0x0 }, // 317 + { PseudoVAESZ_VS_M1_MF8, VAESZ_VS, 0x0, 0x0 }, // 318 + { PseudoVAESZ_VS_M2_M1, VAESZ_VS, 0x1, 0x0 }, // 319 + { PseudoVAESZ_VS_M2_M2, VAESZ_VS, 0x1, 0x0 }, // 320 + { PseudoVAESZ_VS_M2_MF2, VAESZ_VS, 0x1, 0x0 }, // 321 + { PseudoVAESZ_VS_M2_MF4, VAESZ_VS, 0x1, 0x0 }, // 322 + { PseudoVAESZ_VS_M2_MF8, VAESZ_VS, 0x1, 0x0 }, // 323 + { PseudoVAESZ_VS_M4_M1, VAESZ_VS, 0x2, 0x0 }, // 324 + { PseudoVAESZ_VS_M4_M2, VAESZ_VS, 0x2, 0x0 }, // 325 + { PseudoVAESZ_VS_M4_M4, VAESZ_VS, 0x2, 0x0 }, // 326 + { PseudoVAESZ_VS_M4_MF2, VAESZ_VS, 0x2, 0x0 }, // 327 + { PseudoVAESZ_VS_M4_MF4, VAESZ_VS, 0x2, 0x0 }, // 328 + { PseudoVAESZ_VS_M4_MF8, VAESZ_VS, 0x2, 0x0 }, // 329 + { PseudoVAESZ_VS_M8_M1, VAESZ_VS, 0x3, 0x0 }, // 330 + { PseudoVAESZ_VS_M8_M2, VAESZ_VS, 0x3, 0x0 }, // 331 + { PseudoVAESZ_VS_M8_M4, VAESZ_VS, 0x3, 0x0 }, // 332 + { PseudoVAESZ_VS_M8_MF2, VAESZ_VS, 0x3, 0x0 }, // 333 + { PseudoVAESZ_VS_M8_MF4, VAESZ_VS, 0x3, 0x0 }, // 334 + { PseudoVAESZ_VS_M8_MF8, VAESZ_VS, 0x3, 0x0 }, // 335 + { PseudoVAESZ_VS_MF2_MF2, VAESZ_VS, 0x7, 0x0 }, // 336 + { PseudoVAESZ_VS_MF2_MF4, VAESZ_VS, 0x7, 0x0 }, // 337 + { PseudoVAESZ_VS_MF2_MF8, VAESZ_VS, 0x7, 0x0 }, // 338 + { PseudoVANDN_VV_M1, VANDN_VV, 0x0, 0x0 }, // 339 + { PseudoVANDN_VV_M1_MASK, VANDN_VV, 0x0, 0x0 }, // 340 + { PseudoVANDN_VV_M2, VANDN_VV, 0x1, 0x0 }, // 341 + { PseudoVANDN_VV_M2_MASK, VANDN_VV, 0x1, 0x0 }, // 342 + { PseudoVANDN_VV_M4, VANDN_VV, 0x2, 0x0 }, // 343 + { PseudoVANDN_VV_M4_MASK, VANDN_VV, 0x2, 0x0 }, // 344 + { PseudoVANDN_VV_M8, VANDN_VV, 0x3, 0x0 }, // 345 + { PseudoVANDN_VV_M8_MASK, VANDN_VV, 0x3, 0x0 }, // 346 + { PseudoVANDN_VV_MF8, VANDN_VV, 0x5, 0x0 }, // 347 + { PseudoVANDN_VV_MF8_MASK, VANDN_VV, 0x5, 0x0 }, // 348 + { PseudoVANDN_VV_MF4, VANDN_VV, 0x6, 0x0 }, // 349 + { PseudoVANDN_VV_MF4_MASK, VANDN_VV, 0x6, 0x0 }, // 350 + { PseudoVANDN_VV_MF2, VANDN_VV, 0x7, 0x0 }, // 351 + { PseudoVANDN_VV_MF2_MASK, VANDN_VV, 0x7, 0x0 }, // 352 + { PseudoVANDN_VX_M1, VANDN_VX, 0x0, 0x0 }, // 353 + { PseudoVANDN_VX_M1_MASK, VANDN_VX, 0x0, 0x0 }, // 354 + { PseudoVANDN_VX_M2, VANDN_VX, 0x1, 0x0 }, // 355 + { PseudoVANDN_VX_M2_MASK, VANDN_VX, 0x1, 0x0 }, // 356 + { PseudoVANDN_VX_M4, VANDN_VX, 0x2, 0x0 }, // 357 + { PseudoVANDN_VX_M4_MASK, VANDN_VX, 0x2, 0x0 }, // 358 + { PseudoVANDN_VX_M8, VANDN_VX, 0x3, 0x0 }, // 359 + { PseudoVANDN_VX_M8_MASK, VANDN_VX, 0x3, 0x0 }, // 360 + { PseudoVANDN_VX_MF8, VANDN_VX, 0x5, 0x0 }, // 361 + { PseudoVANDN_VX_MF8_MASK, VANDN_VX, 0x5, 0x0 }, // 362 + { PseudoVANDN_VX_MF4, VANDN_VX, 0x6, 0x0 }, // 363 + { PseudoVANDN_VX_MF4_MASK, VANDN_VX, 0x6, 0x0 }, // 364 + { PseudoVANDN_VX_MF2, VANDN_VX, 0x7, 0x0 }, // 365 + { PseudoVANDN_VX_MF2_MASK, VANDN_VX, 0x7, 0x0 }, // 366 + { PseudoVAND_VI_M1, VAND_VI, 0x0, 0x0 }, // 367 + { PseudoVAND_VI_M1_MASK, VAND_VI, 0x0, 0x0 }, // 368 + { PseudoVAND_VI_M2, VAND_VI, 0x1, 0x0 }, // 369 + { PseudoVAND_VI_M2_MASK, VAND_VI, 0x1, 0x0 }, // 370 + { PseudoVAND_VI_M4, VAND_VI, 0x2, 0x0 }, // 371 + { PseudoVAND_VI_M4_MASK, VAND_VI, 0x2, 0x0 }, // 372 + { PseudoVAND_VI_M8, VAND_VI, 0x3, 0x0 }, // 373 + { PseudoVAND_VI_M8_MASK, VAND_VI, 0x3, 0x0 }, // 374 + { PseudoVAND_VI_MF8, VAND_VI, 0x5, 0x0 }, // 375 + { PseudoVAND_VI_MF8_MASK, VAND_VI, 0x5, 0x0 }, // 376 + { PseudoVAND_VI_MF4, VAND_VI, 0x6, 0x0 }, // 377 + { PseudoVAND_VI_MF4_MASK, VAND_VI, 0x6, 0x0 }, // 378 + { PseudoVAND_VI_MF2, VAND_VI, 0x7, 0x0 }, // 379 + { PseudoVAND_VI_MF2_MASK, VAND_VI, 0x7, 0x0 }, // 380 + { PseudoVAND_VV_M1, VAND_VV, 0x0, 0x0 }, // 381 + { PseudoVAND_VV_M1_MASK, VAND_VV, 0x0, 0x0 }, // 382 + { PseudoVAND_VV_M2, VAND_VV, 0x1, 0x0 }, // 383 + { PseudoVAND_VV_M2_MASK, VAND_VV, 0x1, 0x0 }, // 384 + { PseudoVAND_VV_M4, VAND_VV, 0x2, 0x0 }, // 385 + { PseudoVAND_VV_M4_MASK, VAND_VV, 0x2, 0x0 }, // 386 + { PseudoVAND_VV_M8, VAND_VV, 0x3, 0x0 }, // 387 + { PseudoVAND_VV_M8_MASK, VAND_VV, 0x3, 0x0 }, // 388 + { PseudoVAND_VV_MF8, VAND_VV, 0x5, 0x0 }, // 389 + { PseudoVAND_VV_MF8_MASK, VAND_VV, 0x5, 0x0 }, // 390 + { PseudoVAND_VV_MF4, VAND_VV, 0x6, 0x0 }, // 391 + { PseudoVAND_VV_MF4_MASK, VAND_VV, 0x6, 0x0 }, // 392 + { PseudoVAND_VV_MF2, VAND_VV, 0x7, 0x0 }, // 393 + { PseudoVAND_VV_MF2_MASK, VAND_VV, 0x7, 0x0 }, // 394 + { PseudoVAND_VX_M1, VAND_VX, 0x0, 0x0 }, // 395 + { PseudoVAND_VX_M1_MASK, VAND_VX, 0x0, 0x0 }, // 396 + { PseudoVAND_VX_M2, VAND_VX, 0x1, 0x0 }, // 397 + { PseudoVAND_VX_M2_MASK, VAND_VX, 0x1, 0x0 }, // 398 + { PseudoVAND_VX_M4, VAND_VX, 0x2, 0x0 }, // 399 + { PseudoVAND_VX_M4_MASK, VAND_VX, 0x2, 0x0 }, // 400 + { PseudoVAND_VX_M8, VAND_VX, 0x3, 0x0 }, // 401 + { PseudoVAND_VX_M8_MASK, VAND_VX, 0x3, 0x0 }, // 402 + { PseudoVAND_VX_MF8, VAND_VX, 0x5, 0x0 }, // 403 + { PseudoVAND_VX_MF8_MASK, VAND_VX, 0x5, 0x0 }, // 404 + { PseudoVAND_VX_MF4, VAND_VX, 0x6, 0x0 }, // 405 + { PseudoVAND_VX_MF4_MASK, VAND_VX, 0x6, 0x0 }, // 406 + { PseudoVAND_VX_MF2, VAND_VX, 0x7, 0x0 }, // 407 + { PseudoVAND_VX_MF2_MASK, VAND_VX, 0x7, 0x0 }, // 408 + { PseudoVASUBU_VV_M1, VASUBU_VV, 0x0, 0x0 }, // 409 + { PseudoVASUBU_VV_M1_MASK, VASUBU_VV, 0x0, 0x0 }, // 410 + { PseudoVASUBU_VV_M2, VASUBU_VV, 0x1, 0x0 }, // 411 + { PseudoVASUBU_VV_M2_MASK, VASUBU_VV, 0x1, 0x0 }, // 412 + { PseudoVASUBU_VV_M4, VASUBU_VV, 0x2, 0x0 }, // 413 + { PseudoVASUBU_VV_M4_MASK, VASUBU_VV, 0x2, 0x0 }, // 414 + { PseudoVASUBU_VV_M8, VASUBU_VV, 0x3, 0x0 }, // 415 + { PseudoVASUBU_VV_M8_MASK, VASUBU_VV, 0x3, 0x0 }, // 416 + { PseudoVASUBU_VV_MF8, VASUBU_VV, 0x5, 0x0 }, // 417 + { PseudoVASUBU_VV_MF8_MASK, VASUBU_VV, 0x5, 0x0 }, // 418 + { PseudoVASUBU_VV_MF4, VASUBU_VV, 0x6, 0x0 }, // 419 + { PseudoVASUBU_VV_MF4_MASK, VASUBU_VV, 0x6, 0x0 }, // 420 + { PseudoVASUBU_VV_MF2, VASUBU_VV, 0x7, 0x0 }, // 421 + { PseudoVASUBU_VV_MF2_MASK, VASUBU_VV, 0x7, 0x0 }, // 422 + { PseudoVASUBU_VX_M1, VASUBU_VX, 0x0, 0x0 }, // 423 + { PseudoVASUBU_VX_M1_MASK, VASUBU_VX, 0x0, 0x0 }, // 424 + { PseudoVASUBU_VX_M2, VASUBU_VX, 0x1, 0x0 }, // 425 + { PseudoVASUBU_VX_M2_MASK, VASUBU_VX, 0x1, 0x0 }, // 426 + { PseudoVASUBU_VX_M4, VASUBU_VX, 0x2, 0x0 }, // 427 + { PseudoVASUBU_VX_M4_MASK, VASUBU_VX, 0x2, 0x0 }, // 428 + { PseudoVASUBU_VX_M8, VASUBU_VX, 0x3, 0x0 }, // 429 + { PseudoVASUBU_VX_M8_MASK, VASUBU_VX, 0x3, 0x0 }, // 430 + { PseudoVASUBU_VX_MF8, VASUBU_VX, 0x5, 0x0 }, // 431 + { PseudoVASUBU_VX_MF8_MASK, VASUBU_VX, 0x5, 0x0 }, // 432 + { PseudoVASUBU_VX_MF4, VASUBU_VX, 0x6, 0x0 }, // 433 + { PseudoVASUBU_VX_MF4_MASK, VASUBU_VX, 0x6, 0x0 }, // 434 + { PseudoVASUBU_VX_MF2, VASUBU_VX, 0x7, 0x0 }, // 435 + { PseudoVASUBU_VX_MF2_MASK, VASUBU_VX, 0x7, 0x0 }, // 436 + { PseudoVASUB_VV_M1, VASUB_VV, 0x0, 0x0 }, // 437 + { PseudoVASUB_VV_M1_MASK, VASUB_VV, 0x0, 0x0 }, // 438 + { PseudoVASUB_VV_M2, VASUB_VV, 0x1, 0x0 }, // 439 + { PseudoVASUB_VV_M2_MASK, VASUB_VV, 0x1, 0x0 }, // 440 + { PseudoVASUB_VV_M4, VASUB_VV, 0x2, 0x0 }, // 441 + { PseudoVASUB_VV_M4_MASK, VASUB_VV, 0x2, 0x0 }, // 442 + { PseudoVASUB_VV_M8, VASUB_VV, 0x3, 0x0 }, // 443 + { PseudoVASUB_VV_M8_MASK, VASUB_VV, 0x3, 0x0 }, // 444 + { PseudoVASUB_VV_MF8, VASUB_VV, 0x5, 0x0 }, // 445 + { PseudoVASUB_VV_MF8_MASK, VASUB_VV, 0x5, 0x0 }, // 446 + { PseudoVASUB_VV_MF4, VASUB_VV, 0x6, 0x0 }, // 447 + { PseudoVASUB_VV_MF4_MASK, VASUB_VV, 0x6, 0x0 }, // 448 + { PseudoVASUB_VV_MF2, VASUB_VV, 0x7, 0x0 }, // 449 + { PseudoVASUB_VV_MF2_MASK, VASUB_VV, 0x7, 0x0 }, // 450 + { PseudoVASUB_VX_M1, VASUB_VX, 0x0, 0x0 }, // 451 + { PseudoVASUB_VX_M1_MASK, VASUB_VX, 0x0, 0x0 }, // 452 + { PseudoVASUB_VX_M2, VASUB_VX, 0x1, 0x0 }, // 453 + { PseudoVASUB_VX_M2_MASK, VASUB_VX, 0x1, 0x0 }, // 454 + { PseudoVASUB_VX_M4, VASUB_VX, 0x2, 0x0 }, // 455 + { PseudoVASUB_VX_M4_MASK, VASUB_VX, 0x2, 0x0 }, // 456 + { PseudoVASUB_VX_M8, VASUB_VX, 0x3, 0x0 }, // 457 + { PseudoVASUB_VX_M8_MASK, VASUB_VX, 0x3, 0x0 }, // 458 + { PseudoVASUB_VX_MF8, VASUB_VX, 0x5, 0x0 }, // 459 + { PseudoVASUB_VX_MF8_MASK, VASUB_VX, 0x5, 0x0 }, // 460 + { PseudoVASUB_VX_MF4, VASUB_VX, 0x6, 0x0 }, // 461 + { PseudoVASUB_VX_MF4_MASK, VASUB_VX, 0x6, 0x0 }, // 462 + { PseudoVASUB_VX_MF2, VASUB_VX, 0x7, 0x0 }, // 463 + { PseudoVASUB_VX_MF2_MASK, VASUB_VX, 0x7, 0x0 }, // 464 + { PseudoVBREV8_V_M1, VBREV8_V, 0x0, 0x0 }, // 465 + { PseudoVBREV8_V_M1_MASK, VBREV8_V, 0x0, 0x0 }, // 466 + { PseudoVBREV8_V_M2, VBREV8_V, 0x1, 0x0 }, // 467 + { PseudoVBREV8_V_M2_MASK, VBREV8_V, 0x1, 0x0 }, // 468 + { PseudoVBREV8_V_M4, VBREV8_V, 0x2, 0x0 }, // 469 + { PseudoVBREV8_V_M4_MASK, VBREV8_V, 0x2, 0x0 }, // 470 + { PseudoVBREV8_V_M8, VBREV8_V, 0x3, 0x0 }, // 471 + { PseudoVBREV8_V_M8_MASK, VBREV8_V, 0x3, 0x0 }, // 472 + { PseudoVBREV8_V_MF8, VBREV8_V, 0x5, 0x0 }, // 473 + { PseudoVBREV8_V_MF8_MASK, VBREV8_V, 0x5, 0x0 }, // 474 + { PseudoVBREV8_V_MF4, VBREV8_V, 0x6, 0x0 }, // 475 + { PseudoVBREV8_V_MF4_MASK, VBREV8_V, 0x6, 0x0 }, // 476 + { PseudoVBREV8_V_MF2, VBREV8_V, 0x7, 0x0 }, // 477 + { PseudoVBREV8_V_MF2_MASK, VBREV8_V, 0x7, 0x0 }, // 478 + { PseudoVBREV_V_M1, VBREV_V, 0x0, 0x0 }, // 479 + { PseudoVBREV_V_M1_MASK, VBREV_V, 0x0, 0x0 }, // 480 + { PseudoVBREV_V_M2, VBREV_V, 0x1, 0x0 }, // 481 + { PseudoVBREV_V_M2_MASK, VBREV_V, 0x1, 0x0 }, // 482 + { PseudoVBREV_V_M4, VBREV_V, 0x2, 0x0 }, // 483 + { PseudoVBREV_V_M4_MASK, VBREV_V, 0x2, 0x0 }, // 484 + { PseudoVBREV_V_M8, VBREV_V, 0x3, 0x0 }, // 485 + { PseudoVBREV_V_M8_MASK, VBREV_V, 0x3, 0x0 }, // 486 + { PseudoVBREV_V_MF8, VBREV_V, 0x5, 0x0 }, // 487 + { PseudoVBREV_V_MF8_MASK, VBREV_V, 0x5, 0x0 }, // 488 + { PseudoVBREV_V_MF4, VBREV_V, 0x6, 0x0 }, // 489 + { PseudoVBREV_V_MF4_MASK, VBREV_V, 0x6, 0x0 }, // 490 + { PseudoVBREV_V_MF2, VBREV_V, 0x7, 0x0 }, // 491 + { PseudoVBREV_V_MF2_MASK, VBREV_V, 0x7, 0x0 }, // 492 + { PseudoVCLMULH_VV_M1, VCLMULH_VV, 0x0, 0x0 }, // 493 + { PseudoVCLMULH_VV_M1_MASK, VCLMULH_VV, 0x0, 0x0 }, // 494 + { PseudoVCLMULH_VV_M2, VCLMULH_VV, 0x1, 0x0 }, // 495 + { PseudoVCLMULH_VV_M2_MASK, VCLMULH_VV, 0x1, 0x0 }, // 496 + { PseudoVCLMULH_VV_M4, VCLMULH_VV, 0x2, 0x0 }, // 497 + { PseudoVCLMULH_VV_M4_MASK, VCLMULH_VV, 0x2, 0x0 }, // 498 + { PseudoVCLMULH_VV_M8, VCLMULH_VV, 0x3, 0x0 }, // 499 + { PseudoVCLMULH_VV_M8_MASK, VCLMULH_VV, 0x3, 0x0 }, // 500 + { PseudoVCLMULH_VV_MF8, VCLMULH_VV, 0x5, 0x0 }, // 501 + { PseudoVCLMULH_VV_MF8_MASK, VCLMULH_VV, 0x5, 0x0 }, // 502 + { PseudoVCLMULH_VV_MF4, VCLMULH_VV, 0x6, 0x0 }, // 503 + { PseudoVCLMULH_VV_MF4_MASK, VCLMULH_VV, 0x6, 0x0 }, // 504 + { PseudoVCLMULH_VV_MF2, VCLMULH_VV, 0x7, 0x0 }, // 505 + { PseudoVCLMULH_VV_MF2_MASK, VCLMULH_VV, 0x7, 0x0 }, // 506 + { PseudoVCLMULH_VX_M1, VCLMULH_VX, 0x0, 0x0 }, // 507 + { PseudoVCLMULH_VX_M1_MASK, VCLMULH_VX, 0x0, 0x0 }, // 508 + { PseudoVCLMULH_VX_M2, VCLMULH_VX, 0x1, 0x0 }, // 509 + { PseudoVCLMULH_VX_M2_MASK, VCLMULH_VX, 0x1, 0x0 }, // 510 + { PseudoVCLMULH_VX_M4, VCLMULH_VX, 0x2, 0x0 }, // 511 + { PseudoVCLMULH_VX_M4_MASK, VCLMULH_VX, 0x2, 0x0 }, // 512 + { PseudoVCLMULH_VX_M8, VCLMULH_VX, 0x3, 0x0 }, // 513 + { PseudoVCLMULH_VX_M8_MASK, VCLMULH_VX, 0x3, 0x0 }, // 514 + { PseudoVCLMULH_VX_MF8, VCLMULH_VX, 0x5, 0x0 }, // 515 + { PseudoVCLMULH_VX_MF8_MASK, VCLMULH_VX, 0x5, 0x0 }, // 516 + { PseudoVCLMULH_VX_MF4, VCLMULH_VX, 0x6, 0x0 }, // 517 + { PseudoVCLMULH_VX_MF4_MASK, VCLMULH_VX, 0x6, 0x0 }, // 518 + { PseudoVCLMULH_VX_MF2, VCLMULH_VX, 0x7, 0x0 }, // 519 + { PseudoVCLMULH_VX_MF2_MASK, VCLMULH_VX, 0x7, 0x0 }, // 520 + { PseudoVCLMUL_VV_M1, VCLMUL_VV, 0x0, 0x0 }, // 521 + { PseudoVCLMUL_VV_M1_MASK, VCLMUL_VV, 0x0, 0x0 }, // 522 + { PseudoVCLMUL_VV_M2, VCLMUL_VV, 0x1, 0x0 }, // 523 + { PseudoVCLMUL_VV_M2_MASK, VCLMUL_VV, 0x1, 0x0 }, // 524 + { PseudoVCLMUL_VV_M4, VCLMUL_VV, 0x2, 0x0 }, // 525 + { PseudoVCLMUL_VV_M4_MASK, VCLMUL_VV, 0x2, 0x0 }, // 526 + { PseudoVCLMUL_VV_M8, VCLMUL_VV, 0x3, 0x0 }, // 527 + { PseudoVCLMUL_VV_M8_MASK, VCLMUL_VV, 0x3, 0x0 }, // 528 + { PseudoVCLMUL_VV_MF8, VCLMUL_VV, 0x5, 0x0 }, // 529 + { PseudoVCLMUL_VV_MF8_MASK, VCLMUL_VV, 0x5, 0x0 }, // 530 + { PseudoVCLMUL_VV_MF4, VCLMUL_VV, 0x6, 0x0 }, // 531 + { PseudoVCLMUL_VV_MF4_MASK, VCLMUL_VV, 0x6, 0x0 }, // 532 + { PseudoVCLMUL_VV_MF2, VCLMUL_VV, 0x7, 0x0 }, // 533 + { PseudoVCLMUL_VV_MF2_MASK, VCLMUL_VV, 0x7, 0x0 }, // 534 + { PseudoVCLMUL_VX_M1, VCLMUL_VX, 0x0, 0x0 }, // 535 + { PseudoVCLMUL_VX_M1_MASK, VCLMUL_VX, 0x0, 0x0 }, // 536 + { PseudoVCLMUL_VX_M2, VCLMUL_VX, 0x1, 0x0 }, // 537 + { PseudoVCLMUL_VX_M2_MASK, VCLMUL_VX, 0x1, 0x0 }, // 538 + { PseudoVCLMUL_VX_M4, VCLMUL_VX, 0x2, 0x0 }, // 539 + { PseudoVCLMUL_VX_M4_MASK, VCLMUL_VX, 0x2, 0x0 }, // 540 + { PseudoVCLMUL_VX_M8, VCLMUL_VX, 0x3, 0x0 }, // 541 + { PseudoVCLMUL_VX_M8_MASK, VCLMUL_VX, 0x3, 0x0 }, // 542 + { PseudoVCLMUL_VX_MF8, VCLMUL_VX, 0x5, 0x0 }, // 543 + { PseudoVCLMUL_VX_MF8_MASK, VCLMUL_VX, 0x5, 0x0 }, // 544 + { PseudoVCLMUL_VX_MF4, VCLMUL_VX, 0x6, 0x0 }, // 545 + { PseudoVCLMUL_VX_MF4_MASK, VCLMUL_VX, 0x6, 0x0 }, // 546 + { PseudoVCLMUL_VX_MF2, VCLMUL_VX, 0x7, 0x0 }, // 547 + { PseudoVCLMUL_VX_MF2_MASK, VCLMUL_VX, 0x7, 0x0 }, // 548 + { PseudoVCLZ_V_M1, VCLZ_V, 0x0, 0x0 }, // 549 + { PseudoVCLZ_V_M1_MASK, VCLZ_V, 0x0, 0x0 }, // 550 + { PseudoVCLZ_V_M2, VCLZ_V, 0x1, 0x0 }, // 551 + { PseudoVCLZ_V_M2_MASK, VCLZ_V, 0x1, 0x0 }, // 552 + { PseudoVCLZ_V_M4, VCLZ_V, 0x2, 0x0 }, // 553 + { PseudoVCLZ_V_M4_MASK, VCLZ_V, 0x2, 0x0 }, // 554 + { PseudoVCLZ_V_M8, VCLZ_V, 0x3, 0x0 }, // 555 + { PseudoVCLZ_V_M8_MASK, VCLZ_V, 0x3, 0x0 }, // 556 + { PseudoVCLZ_V_MF8, VCLZ_V, 0x5, 0x0 }, // 557 + { PseudoVCLZ_V_MF8_MASK, VCLZ_V, 0x5, 0x0 }, // 558 + { PseudoVCLZ_V_MF4, VCLZ_V, 0x6, 0x0 }, // 559 + { PseudoVCLZ_V_MF4_MASK, VCLZ_V, 0x6, 0x0 }, // 560 + { PseudoVCLZ_V_MF2, VCLZ_V, 0x7, 0x0 }, // 561 + { PseudoVCLZ_V_MF2_MASK, VCLZ_V, 0x7, 0x0 }, // 562 + { PseudoVCOMPRESS_VM_M1_E8, VCOMPRESS_VM, 0x0, 0x8 }, // 563 + { PseudoVCOMPRESS_VM_M1_E16, VCOMPRESS_VM, 0x0, 0x10 }, // 564 + { PseudoVCOMPRESS_VM_M1_E32, VCOMPRESS_VM, 0x0, 0x20 }, // 565 + { PseudoVCOMPRESS_VM_M1_E64, VCOMPRESS_VM, 0x0, 0x40 }, // 566 + { PseudoVCOMPRESS_VM_M2_E8, VCOMPRESS_VM, 0x1, 0x8 }, // 567 + { PseudoVCOMPRESS_VM_M2_E16, VCOMPRESS_VM, 0x1, 0x10 }, // 568 + { PseudoVCOMPRESS_VM_M2_E32, VCOMPRESS_VM, 0x1, 0x20 }, // 569 + { PseudoVCOMPRESS_VM_M2_E64, VCOMPRESS_VM, 0x1, 0x40 }, // 570 + { PseudoVCOMPRESS_VM_M4_E8, VCOMPRESS_VM, 0x2, 0x8 }, // 571 + { PseudoVCOMPRESS_VM_M4_E16, VCOMPRESS_VM, 0x2, 0x10 }, // 572 + { PseudoVCOMPRESS_VM_M4_E32, VCOMPRESS_VM, 0x2, 0x20 }, // 573 + { PseudoVCOMPRESS_VM_M4_E64, VCOMPRESS_VM, 0x2, 0x40 }, // 574 + { PseudoVCOMPRESS_VM_M8_E8, VCOMPRESS_VM, 0x3, 0x8 }, // 575 + { PseudoVCOMPRESS_VM_M8_E16, VCOMPRESS_VM, 0x3, 0x10 }, // 576 + { PseudoVCOMPRESS_VM_M8_E32, VCOMPRESS_VM, 0x3, 0x20 }, // 577 + { PseudoVCOMPRESS_VM_M8_E64, VCOMPRESS_VM, 0x3, 0x40 }, // 578 + { PseudoVCOMPRESS_VM_MF8_E8, VCOMPRESS_VM, 0x5, 0x8 }, // 579 + { PseudoVCOMPRESS_VM_MF4_E8, VCOMPRESS_VM, 0x6, 0x8 }, // 580 + { PseudoVCOMPRESS_VM_MF4_E16, VCOMPRESS_VM, 0x6, 0x10 }, // 581 + { PseudoVCOMPRESS_VM_MF2_E8, VCOMPRESS_VM, 0x7, 0x8 }, // 582 + { PseudoVCOMPRESS_VM_MF2_E16, VCOMPRESS_VM, 0x7, 0x10 }, // 583 + { PseudoVCOMPRESS_VM_MF2_E32, VCOMPRESS_VM, 0x7, 0x20 }, // 584 + { PseudoVCPOP_M_B8, VCPOP_M, 0x0, 0x0 }, // 585 + { PseudoVCPOP_M_B8_MASK, VCPOP_M, 0x0, 0x0 }, // 586 + { PseudoVCPOP_M_B16, VCPOP_M, 0x1, 0x0 }, // 587 + { PseudoVCPOP_M_B16_MASK, VCPOP_M, 0x1, 0x0 }, // 588 + { PseudoVCPOP_M_B32, VCPOP_M, 0x2, 0x0 }, // 589 + { PseudoVCPOP_M_B32_MASK, VCPOP_M, 0x2, 0x0 }, // 590 + { PseudoVCPOP_M_B64, VCPOP_M, 0x3, 0x0 }, // 591 + { PseudoVCPOP_M_B64_MASK, VCPOP_M, 0x3, 0x0 }, // 592 + { PseudoVCPOP_M_B1, VCPOP_M, 0x5, 0x0 }, // 593 + { PseudoVCPOP_M_B1_MASK, VCPOP_M, 0x5, 0x0 }, // 594 + { PseudoVCPOP_M_B2, VCPOP_M, 0x6, 0x0 }, // 595 + { PseudoVCPOP_M_B2_MASK, VCPOP_M, 0x6, 0x0 }, // 596 + { PseudoVCPOP_M_B4, VCPOP_M, 0x7, 0x0 }, // 597 + { PseudoVCPOP_M_B4_MASK, VCPOP_M, 0x7, 0x0 }, // 598 + { PseudoVCPOP_V_M1, VCPOP_V, 0x0, 0x0 }, // 599 + { PseudoVCPOP_V_M1_MASK, VCPOP_V, 0x0, 0x0 }, // 600 + { PseudoVCPOP_V_M2, VCPOP_V, 0x1, 0x0 }, // 601 + { PseudoVCPOP_V_M2_MASK, VCPOP_V, 0x1, 0x0 }, // 602 + { PseudoVCPOP_V_M4, VCPOP_V, 0x2, 0x0 }, // 603 + { PseudoVCPOP_V_M4_MASK, VCPOP_V, 0x2, 0x0 }, // 604 + { PseudoVCPOP_V_M8, VCPOP_V, 0x3, 0x0 }, // 605 + { PseudoVCPOP_V_M8_MASK, VCPOP_V, 0x3, 0x0 }, // 606 + { PseudoVCPOP_V_MF8, VCPOP_V, 0x5, 0x0 }, // 607 + { PseudoVCPOP_V_MF8_MASK, VCPOP_V, 0x5, 0x0 }, // 608 + { PseudoVCPOP_V_MF4, VCPOP_V, 0x6, 0x0 }, // 609 + { PseudoVCPOP_V_MF4_MASK, VCPOP_V, 0x6, 0x0 }, // 610 + { PseudoVCPOP_V_MF2, VCPOP_V, 0x7, 0x0 }, // 611 + { PseudoVCPOP_V_MF2_MASK, VCPOP_V, 0x7, 0x0 }, // 612 + { PseudoVCTZ_V_M1, VCTZ_V, 0x0, 0x0 }, // 613 + { PseudoVCTZ_V_M1_MASK, VCTZ_V, 0x0, 0x0 }, // 614 + { PseudoVCTZ_V_M2, VCTZ_V, 0x1, 0x0 }, // 615 + { PseudoVCTZ_V_M2_MASK, VCTZ_V, 0x1, 0x0 }, // 616 + { PseudoVCTZ_V_M4, VCTZ_V, 0x2, 0x0 }, // 617 + { PseudoVCTZ_V_M4_MASK, VCTZ_V, 0x2, 0x0 }, // 618 + { PseudoVCTZ_V_M8, VCTZ_V, 0x3, 0x0 }, // 619 + { PseudoVCTZ_V_M8_MASK, VCTZ_V, 0x3, 0x0 }, // 620 + { PseudoVCTZ_V_MF8, VCTZ_V, 0x5, 0x0 }, // 621 + { PseudoVCTZ_V_MF8_MASK, VCTZ_V, 0x5, 0x0 }, // 622 + { PseudoVCTZ_V_MF4, VCTZ_V, 0x6, 0x0 }, // 623 + { PseudoVCTZ_V_MF4_MASK, VCTZ_V, 0x6, 0x0 }, // 624 + { PseudoVCTZ_V_MF2, VCTZ_V, 0x7, 0x0 }, // 625 + { PseudoVCTZ_V_MF2_MASK, VCTZ_V, 0x7, 0x0 }, // 626 + { PseudoVC_FPR16V_SE_M1, VC_FV, 0x0, 0x0 }, // 627 + { PseudoVC_FPR32V_SE_M1, VC_FV, 0x0, 0x0 }, // 628 + { PseudoVC_FPR64V_SE_M1, VC_FV, 0x0, 0x0 }, // 629 + { PseudoVC_FPR16V_SE_M2, VC_FV, 0x1, 0x0 }, // 630 + { PseudoVC_FPR32V_SE_M2, VC_FV, 0x1, 0x0 }, // 631 + { PseudoVC_FPR64V_SE_M2, VC_FV, 0x1, 0x0 }, // 632 + { PseudoVC_FPR16V_SE_M4, VC_FV, 0x2, 0x0 }, // 633 + { PseudoVC_FPR32V_SE_M4, VC_FV, 0x2, 0x0 }, // 634 + { PseudoVC_FPR64V_SE_M4, VC_FV, 0x2, 0x0 }, // 635 + { PseudoVC_FPR16V_SE_M8, VC_FV, 0x3, 0x0 }, // 636 + { PseudoVC_FPR32V_SE_M8, VC_FV, 0x3, 0x0 }, // 637 + { PseudoVC_FPR64V_SE_M8, VC_FV, 0x3, 0x0 }, // 638 + { PseudoVC_FPR16V_SE_MF4, VC_FV, 0x6, 0x0 }, // 639 + { PseudoVC_FPR16V_SE_MF2, VC_FV, 0x7, 0x0 }, // 640 + { PseudoVC_FPR32V_SE_MF2, VC_FV, 0x7, 0x0 }, // 641 + { PseudoVC_FPR16VV_SE_M1, VC_FVV, 0x0, 0x0 }, // 642 + { PseudoVC_FPR32VV_SE_M1, VC_FVV, 0x0, 0x0 }, // 643 + { PseudoVC_FPR64VV_SE_M1, VC_FVV, 0x0, 0x0 }, // 644 + { PseudoVC_FPR16VV_SE_M2, VC_FVV, 0x1, 0x0 }, // 645 + { PseudoVC_FPR32VV_SE_M2, VC_FVV, 0x1, 0x0 }, // 646 + { PseudoVC_FPR64VV_SE_M2, VC_FVV, 0x1, 0x0 }, // 647 + { PseudoVC_FPR16VV_SE_M4, VC_FVV, 0x2, 0x0 }, // 648 + { PseudoVC_FPR32VV_SE_M4, VC_FVV, 0x2, 0x0 }, // 649 + { PseudoVC_FPR64VV_SE_M4, VC_FVV, 0x2, 0x0 }, // 650 + { PseudoVC_FPR16VV_SE_M8, VC_FVV, 0x3, 0x0 }, // 651 + { PseudoVC_FPR32VV_SE_M8, VC_FVV, 0x3, 0x0 }, // 652 + { PseudoVC_FPR64VV_SE_M8, VC_FVV, 0x3, 0x0 }, // 653 + { PseudoVC_FPR16VV_SE_MF4, VC_FVV, 0x6, 0x0 }, // 654 + { PseudoVC_FPR16VV_SE_MF2, VC_FVV, 0x7, 0x0 }, // 655 + { PseudoVC_FPR32VV_SE_MF2, VC_FVV, 0x7, 0x0 }, // 656 + { PseudoVC_FPR16VW_SE_M1, VC_FVW, 0x0, 0x0 }, // 657 + { PseudoVC_FPR32VW_SE_M1, VC_FVW, 0x0, 0x0 }, // 658 + { PseudoVC_FPR16VW_SE_M2, VC_FVW, 0x1, 0x0 }, // 659 + { PseudoVC_FPR32VW_SE_M2, VC_FVW, 0x1, 0x0 }, // 660 + { PseudoVC_FPR16VW_SE_M4, VC_FVW, 0x2, 0x0 }, // 661 + { PseudoVC_FPR32VW_SE_M4, VC_FVW, 0x2, 0x0 }, // 662 + { PseudoVC_FPR16VW_SE_M8, VC_FVW, 0x3, 0x0 }, // 663 + { PseudoVC_FPR32VW_SE_M8, VC_FVW, 0x3, 0x0 }, // 664 + { PseudoVC_FPR16VW_SE_MF4, VC_FVW, 0x6, 0x0 }, // 665 + { PseudoVC_FPR16VW_SE_MF2, VC_FVW, 0x7, 0x0 }, // 666 + { PseudoVC_FPR32VW_SE_MF2, VC_FVW, 0x7, 0x0 }, // 667 + { PseudoVC_I_SE_M1, VC_I, 0x0, 0x0 }, // 668 + { PseudoVC_I_SE_M2, VC_I, 0x1, 0x0 }, // 669 + { PseudoVC_I_SE_M4, VC_I, 0x2, 0x0 }, // 670 + { PseudoVC_I_SE_M8, VC_I, 0x3, 0x0 }, // 671 + { PseudoVC_I_SE_MF8, VC_I, 0x5, 0x0 }, // 672 + { PseudoVC_I_SE_MF4, VC_I, 0x6, 0x0 }, // 673 + { PseudoVC_I_SE_MF2, VC_I, 0x7, 0x0 }, // 674 + { PseudoVC_IV_SE_M1, VC_IV, 0x0, 0x0 }, // 675 + { PseudoVC_IV_SE_M2, VC_IV, 0x1, 0x0 }, // 676 + { PseudoVC_IV_SE_M4, VC_IV, 0x2, 0x0 }, // 677 + { PseudoVC_IV_SE_M8, VC_IV, 0x3, 0x0 }, // 678 + { PseudoVC_IV_SE_MF8, VC_IV, 0x5, 0x0 }, // 679 + { PseudoVC_IV_SE_MF4, VC_IV, 0x6, 0x0 }, // 680 + { PseudoVC_IV_SE_MF2, VC_IV, 0x7, 0x0 }, // 681 + { PseudoVC_IVV_SE_M1, VC_IVV, 0x0, 0x0 }, // 682 + { PseudoVC_IVV_SE_M2, VC_IVV, 0x1, 0x0 }, // 683 + { PseudoVC_IVV_SE_M4, VC_IVV, 0x2, 0x0 }, // 684 + { PseudoVC_IVV_SE_M8, VC_IVV, 0x3, 0x0 }, // 685 + { PseudoVC_IVV_SE_MF8, VC_IVV, 0x5, 0x0 }, // 686 + { PseudoVC_IVV_SE_MF4, VC_IVV, 0x6, 0x0 }, // 687 + { PseudoVC_IVV_SE_MF2, VC_IVV, 0x7, 0x0 }, // 688 + { PseudoVC_IVW_SE_M1, VC_IVW, 0x0, 0x0 }, // 689 + { PseudoVC_IVW_SE_M2, VC_IVW, 0x1, 0x0 }, // 690 + { PseudoVC_IVW_SE_M4, VC_IVW, 0x2, 0x0 }, // 691 + { PseudoVC_IVW_SE_MF8, VC_IVW, 0x5, 0x0 }, // 692 + { PseudoVC_IVW_SE_MF4, VC_IVW, 0x6, 0x0 }, // 693 + { PseudoVC_IVW_SE_MF2, VC_IVW, 0x7, 0x0 }, // 694 + { PseudoVC_VV_SE_M1, VC_VV, 0x0, 0x0 }, // 695 + { PseudoVC_VV_SE_M2, VC_VV, 0x1, 0x0 }, // 696 + { PseudoVC_VV_SE_M4, VC_VV, 0x2, 0x0 }, // 697 + { PseudoVC_VV_SE_M8, VC_VV, 0x3, 0x0 }, // 698 + { PseudoVC_VV_SE_MF8, VC_VV, 0x5, 0x0 }, // 699 + { PseudoVC_VV_SE_MF4, VC_VV, 0x6, 0x0 }, // 700 + { PseudoVC_VV_SE_MF2, VC_VV, 0x7, 0x0 }, // 701 + { PseudoVC_VVV_SE_M1, VC_VVV, 0x0, 0x0 }, // 702 + { PseudoVC_VVV_SE_M2, VC_VVV, 0x1, 0x0 }, // 703 + { PseudoVC_VVV_SE_M4, VC_VVV, 0x2, 0x0 }, // 704 + { PseudoVC_VVV_SE_M8, VC_VVV, 0x3, 0x0 }, // 705 + { PseudoVC_VVV_SE_MF8, VC_VVV, 0x5, 0x0 }, // 706 + { PseudoVC_VVV_SE_MF4, VC_VVV, 0x6, 0x0 }, // 707 + { PseudoVC_VVV_SE_MF2, VC_VVV, 0x7, 0x0 }, // 708 + { PseudoVC_VVW_SE_M1, VC_VVW, 0x0, 0x0 }, // 709 + { PseudoVC_VVW_SE_M2, VC_VVW, 0x1, 0x0 }, // 710 + { PseudoVC_VVW_SE_M4, VC_VVW, 0x2, 0x0 }, // 711 + { PseudoVC_VVW_SE_MF8, VC_VVW, 0x5, 0x0 }, // 712 + { PseudoVC_VVW_SE_MF4, VC_VVW, 0x6, 0x0 }, // 713 + { PseudoVC_VVW_SE_MF2, VC_VVW, 0x7, 0x0 }, // 714 + { PseudoVC_V_FPR16V_M1, VC_V_FV, 0x0, 0x0 }, // 715 + { PseudoVC_V_FPR16V_SE_M1, VC_V_FV, 0x0, 0x0 }, // 716 + { PseudoVC_V_FPR32V_M1, VC_V_FV, 0x0, 0x0 }, // 717 + { PseudoVC_V_FPR32V_SE_M1, VC_V_FV, 0x0, 0x0 }, // 718 + { PseudoVC_V_FPR64V_M1, VC_V_FV, 0x0, 0x0 }, // 719 + { PseudoVC_V_FPR64V_SE_M1, VC_V_FV, 0x0, 0x0 }, // 720 + { PseudoVC_V_FPR16V_M2, VC_V_FV, 0x1, 0x0 }, // 721 + { PseudoVC_V_FPR16V_SE_M2, VC_V_FV, 0x1, 0x0 }, // 722 + { PseudoVC_V_FPR32V_M2, VC_V_FV, 0x1, 0x0 }, // 723 + { PseudoVC_V_FPR32V_SE_M2, VC_V_FV, 0x1, 0x0 }, // 724 + { PseudoVC_V_FPR64V_M2, VC_V_FV, 0x1, 0x0 }, // 725 + { PseudoVC_V_FPR64V_SE_M2, VC_V_FV, 0x1, 0x0 }, // 726 + { PseudoVC_V_FPR16V_M4, VC_V_FV, 0x2, 0x0 }, // 727 + { PseudoVC_V_FPR16V_SE_M4, VC_V_FV, 0x2, 0x0 }, // 728 + { PseudoVC_V_FPR32V_M4, VC_V_FV, 0x2, 0x0 }, // 729 + { PseudoVC_V_FPR32V_SE_M4, VC_V_FV, 0x2, 0x0 }, // 730 + { PseudoVC_V_FPR64V_M4, VC_V_FV, 0x2, 0x0 }, // 731 + { PseudoVC_V_FPR64V_SE_M4, VC_V_FV, 0x2, 0x0 }, // 732 + { PseudoVC_V_FPR16V_M8, VC_V_FV, 0x3, 0x0 }, // 733 + { PseudoVC_V_FPR16V_SE_M8, VC_V_FV, 0x3, 0x0 }, // 734 + { PseudoVC_V_FPR32V_M8, VC_V_FV, 0x3, 0x0 }, // 735 + { PseudoVC_V_FPR32V_SE_M8, VC_V_FV, 0x3, 0x0 }, // 736 + { PseudoVC_V_FPR64V_M8, VC_V_FV, 0x3, 0x0 }, // 737 + { PseudoVC_V_FPR64V_SE_M8, VC_V_FV, 0x3, 0x0 }, // 738 + { PseudoVC_V_FPR16V_MF4, VC_V_FV, 0x6, 0x0 }, // 739 + { PseudoVC_V_FPR16V_SE_MF4, VC_V_FV, 0x6, 0x0 }, // 740 + { PseudoVC_V_FPR16V_MF2, VC_V_FV, 0x7, 0x0 }, // 741 + { PseudoVC_V_FPR16V_SE_MF2, VC_V_FV, 0x7, 0x0 }, // 742 + { PseudoVC_V_FPR32V_MF2, VC_V_FV, 0x7, 0x0 }, // 743 + { PseudoVC_V_FPR32V_SE_MF2, VC_V_FV, 0x7, 0x0 }, // 744 + { PseudoVC_V_FPR16VV_M1, VC_V_FVV, 0x0, 0x0 }, // 745 + { PseudoVC_V_FPR16VV_SE_M1, VC_V_FVV, 0x0, 0x0 }, // 746 + { PseudoVC_V_FPR32VV_M1, VC_V_FVV, 0x0, 0x0 }, // 747 + { PseudoVC_V_FPR32VV_SE_M1, VC_V_FVV, 0x0, 0x0 }, // 748 + { PseudoVC_V_FPR64VV_M1, VC_V_FVV, 0x0, 0x0 }, // 749 + { PseudoVC_V_FPR64VV_SE_M1, VC_V_FVV, 0x0, 0x0 }, // 750 + { PseudoVC_V_FPR16VV_M2, VC_V_FVV, 0x1, 0x0 }, // 751 + { PseudoVC_V_FPR16VV_SE_M2, VC_V_FVV, 0x1, 0x0 }, // 752 + { PseudoVC_V_FPR32VV_M2, VC_V_FVV, 0x1, 0x0 }, // 753 + { PseudoVC_V_FPR32VV_SE_M2, VC_V_FVV, 0x1, 0x0 }, // 754 + { PseudoVC_V_FPR64VV_M2, VC_V_FVV, 0x1, 0x0 }, // 755 + { PseudoVC_V_FPR64VV_SE_M2, VC_V_FVV, 0x1, 0x0 }, // 756 + { PseudoVC_V_FPR16VV_M4, VC_V_FVV, 0x2, 0x0 }, // 757 + { PseudoVC_V_FPR16VV_SE_M4, VC_V_FVV, 0x2, 0x0 }, // 758 + { PseudoVC_V_FPR32VV_M4, VC_V_FVV, 0x2, 0x0 }, // 759 + { PseudoVC_V_FPR32VV_SE_M4, VC_V_FVV, 0x2, 0x0 }, // 760 + { PseudoVC_V_FPR64VV_M4, VC_V_FVV, 0x2, 0x0 }, // 761 + { PseudoVC_V_FPR64VV_SE_M4, VC_V_FVV, 0x2, 0x0 }, // 762 + { PseudoVC_V_FPR16VV_M8, VC_V_FVV, 0x3, 0x0 }, // 763 + { PseudoVC_V_FPR16VV_SE_M8, VC_V_FVV, 0x3, 0x0 }, // 764 + { PseudoVC_V_FPR32VV_M8, VC_V_FVV, 0x3, 0x0 }, // 765 + { PseudoVC_V_FPR32VV_SE_M8, VC_V_FVV, 0x3, 0x0 }, // 766 + { PseudoVC_V_FPR64VV_M8, VC_V_FVV, 0x3, 0x0 }, // 767 + { PseudoVC_V_FPR64VV_SE_M8, VC_V_FVV, 0x3, 0x0 }, // 768 + { PseudoVC_V_FPR16VV_MF4, VC_V_FVV, 0x6, 0x0 }, // 769 + { PseudoVC_V_FPR16VV_SE_MF4, VC_V_FVV, 0x6, 0x0 }, // 770 + { PseudoVC_V_FPR16VV_MF2, VC_V_FVV, 0x7, 0x0 }, // 771 + { PseudoVC_V_FPR16VV_SE_MF2, VC_V_FVV, 0x7, 0x0 }, // 772 + { PseudoVC_V_FPR32VV_MF2, VC_V_FVV, 0x7, 0x0 }, // 773 + { PseudoVC_V_FPR32VV_SE_MF2, VC_V_FVV, 0x7, 0x0 }, // 774 + { PseudoVC_V_FPR16VW_M1, VC_V_FVW, 0x0, 0x0 }, // 775 + { PseudoVC_V_FPR16VW_SE_M1, VC_V_FVW, 0x0, 0x0 }, // 776 + { PseudoVC_V_FPR32VW_M1, VC_V_FVW, 0x0, 0x0 }, // 777 + { PseudoVC_V_FPR32VW_SE_M1, VC_V_FVW, 0x0, 0x0 }, // 778 + { PseudoVC_V_FPR16VW_M2, VC_V_FVW, 0x1, 0x0 }, // 779 + { PseudoVC_V_FPR16VW_SE_M2, VC_V_FVW, 0x1, 0x0 }, // 780 + { PseudoVC_V_FPR32VW_M2, VC_V_FVW, 0x1, 0x0 }, // 781 + { PseudoVC_V_FPR32VW_SE_M2, VC_V_FVW, 0x1, 0x0 }, // 782 + { PseudoVC_V_FPR16VW_M4, VC_V_FVW, 0x2, 0x0 }, // 783 + { PseudoVC_V_FPR16VW_SE_M4, VC_V_FVW, 0x2, 0x0 }, // 784 + { PseudoVC_V_FPR32VW_M4, VC_V_FVW, 0x2, 0x0 }, // 785 + { PseudoVC_V_FPR32VW_SE_M4, VC_V_FVW, 0x2, 0x0 }, // 786 + { PseudoVC_V_FPR16VW_M8, VC_V_FVW, 0x3, 0x0 }, // 787 + { PseudoVC_V_FPR16VW_SE_M8, VC_V_FVW, 0x3, 0x0 }, // 788 + { PseudoVC_V_FPR32VW_M8, VC_V_FVW, 0x3, 0x0 }, // 789 + { PseudoVC_V_FPR32VW_SE_M8, VC_V_FVW, 0x3, 0x0 }, // 790 + { PseudoVC_V_FPR16VW_MF4, VC_V_FVW, 0x6, 0x0 }, // 791 + { PseudoVC_V_FPR16VW_SE_MF4, VC_V_FVW, 0x6, 0x0 }, // 792 + { PseudoVC_V_FPR16VW_MF2, VC_V_FVW, 0x7, 0x0 }, // 793 + { PseudoVC_V_FPR16VW_SE_MF2, VC_V_FVW, 0x7, 0x0 }, // 794 + { PseudoVC_V_FPR32VW_MF2, VC_V_FVW, 0x7, 0x0 }, // 795 + { PseudoVC_V_FPR32VW_SE_MF2, VC_V_FVW, 0x7, 0x0 }, // 796 + { PseudoVC_V_I_M1, VC_V_I, 0x0, 0x0 }, // 797 + { PseudoVC_V_I_SE_M1, VC_V_I, 0x0, 0x0 }, // 798 + { PseudoVC_V_I_M2, VC_V_I, 0x1, 0x0 }, // 799 + { PseudoVC_V_I_SE_M2, VC_V_I, 0x1, 0x0 }, // 800 + { PseudoVC_V_I_M4, VC_V_I, 0x2, 0x0 }, // 801 + { PseudoVC_V_I_SE_M4, VC_V_I, 0x2, 0x0 }, // 802 + { PseudoVC_V_I_M8, VC_V_I, 0x3, 0x0 }, // 803 + { PseudoVC_V_I_SE_M8, VC_V_I, 0x3, 0x0 }, // 804 + { PseudoVC_V_I_MF8, VC_V_I, 0x5, 0x0 }, // 805 + { PseudoVC_V_I_SE_MF8, VC_V_I, 0x5, 0x0 }, // 806 + { PseudoVC_V_I_MF4, VC_V_I, 0x6, 0x0 }, // 807 + { PseudoVC_V_I_SE_MF4, VC_V_I, 0x6, 0x0 }, // 808 + { PseudoVC_V_I_MF2, VC_V_I, 0x7, 0x0 }, // 809 + { PseudoVC_V_I_SE_MF2, VC_V_I, 0x7, 0x0 }, // 810 + { PseudoVC_V_IV_M1, VC_V_IV, 0x0, 0x0 }, // 811 + { PseudoVC_V_IV_SE_M1, VC_V_IV, 0x0, 0x0 }, // 812 + { PseudoVC_V_IV_M2, VC_V_IV, 0x1, 0x0 }, // 813 + { PseudoVC_V_IV_SE_M2, VC_V_IV, 0x1, 0x0 }, // 814 + { PseudoVC_V_IV_M4, VC_V_IV, 0x2, 0x0 }, // 815 + { PseudoVC_V_IV_SE_M4, VC_V_IV, 0x2, 0x0 }, // 816 + { PseudoVC_V_IV_M8, VC_V_IV, 0x3, 0x0 }, // 817 + { PseudoVC_V_IV_SE_M8, VC_V_IV, 0x3, 0x0 }, // 818 + { PseudoVC_V_IV_MF8, VC_V_IV, 0x5, 0x0 }, // 819 + { PseudoVC_V_IV_SE_MF8, VC_V_IV, 0x5, 0x0 }, // 820 + { PseudoVC_V_IV_MF4, VC_V_IV, 0x6, 0x0 }, // 821 + { PseudoVC_V_IV_SE_MF4, VC_V_IV, 0x6, 0x0 }, // 822 + { PseudoVC_V_IV_MF2, VC_V_IV, 0x7, 0x0 }, // 823 + { PseudoVC_V_IV_SE_MF2, VC_V_IV, 0x7, 0x0 }, // 824 + { PseudoVC_V_IVV_M1, VC_V_IVV, 0x0, 0x0 }, // 825 + { PseudoVC_V_IVV_SE_M1, VC_V_IVV, 0x0, 0x0 }, // 826 + { PseudoVC_V_IVV_M2, VC_V_IVV, 0x1, 0x0 }, // 827 + { PseudoVC_V_IVV_SE_M2, VC_V_IVV, 0x1, 0x0 }, // 828 + { PseudoVC_V_IVV_M4, VC_V_IVV, 0x2, 0x0 }, // 829 + { PseudoVC_V_IVV_SE_M4, VC_V_IVV, 0x2, 0x0 }, // 830 + { PseudoVC_V_IVV_M8, VC_V_IVV, 0x3, 0x0 }, // 831 + { PseudoVC_V_IVV_SE_M8, VC_V_IVV, 0x3, 0x0 }, // 832 + { PseudoVC_V_IVV_MF8, VC_V_IVV, 0x5, 0x0 }, // 833 + { PseudoVC_V_IVV_SE_MF8, VC_V_IVV, 0x5, 0x0 }, // 834 + { PseudoVC_V_IVV_MF4, VC_V_IVV, 0x6, 0x0 }, // 835 + { PseudoVC_V_IVV_SE_MF4, VC_V_IVV, 0x6, 0x0 }, // 836 + { PseudoVC_V_IVV_MF2, VC_V_IVV, 0x7, 0x0 }, // 837 + { PseudoVC_V_IVV_SE_MF2, VC_V_IVV, 0x7, 0x0 }, // 838 + { PseudoVC_V_IVW_M1, VC_V_IVW, 0x0, 0x0 }, // 839 + { PseudoVC_V_IVW_SE_M1, VC_V_IVW, 0x0, 0x0 }, // 840 + { PseudoVC_V_IVW_M2, VC_V_IVW, 0x1, 0x0 }, // 841 + { PseudoVC_V_IVW_SE_M2, VC_V_IVW, 0x1, 0x0 }, // 842 + { PseudoVC_V_IVW_M4, VC_V_IVW, 0x2, 0x0 }, // 843 + { PseudoVC_V_IVW_SE_M4, VC_V_IVW, 0x2, 0x0 }, // 844 + { PseudoVC_V_IVW_MF8, VC_V_IVW, 0x5, 0x0 }, // 845 + { PseudoVC_V_IVW_SE_MF8, VC_V_IVW, 0x5, 0x0 }, // 846 + { PseudoVC_V_IVW_MF4, VC_V_IVW, 0x6, 0x0 }, // 847 + { PseudoVC_V_IVW_SE_MF4, VC_V_IVW, 0x6, 0x0 }, // 848 + { PseudoVC_V_IVW_MF2, VC_V_IVW, 0x7, 0x0 }, // 849 + { PseudoVC_V_IVW_SE_MF2, VC_V_IVW, 0x7, 0x0 }, // 850 + { PseudoVC_V_VV_M1, VC_V_VV, 0x0, 0x0 }, // 851 + { PseudoVC_V_VV_SE_M1, VC_V_VV, 0x0, 0x0 }, // 852 + { PseudoVC_V_VV_M2, VC_V_VV, 0x1, 0x0 }, // 853 + { PseudoVC_V_VV_SE_M2, VC_V_VV, 0x1, 0x0 }, // 854 + { PseudoVC_V_VV_M4, VC_V_VV, 0x2, 0x0 }, // 855 + { PseudoVC_V_VV_SE_M4, VC_V_VV, 0x2, 0x0 }, // 856 + { PseudoVC_V_VV_M8, VC_V_VV, 0x3, 0x0 }, // 857 + { PseudoVC_V_VV_SE_M8, VC_V_VV, 0x3, 0x0 }, // 858 + { PseudoVC_V_VV_MF8, VC_V_VV, 0x5, 0x0 }, // 859 + { PseudoVC_V_VV_SE_MF8, VC_V_VV, 0x5, 0x0 }, // 860 + { PseudoVC_V_VV_MF4, VC_V_VV, 0x6, 0x0 }, // 861 + { PseudoVC_V_VV_SE_MF4, VC_V_VV, 0x6, 0x0 }, // 862 + { PseudoVC_V_VV_MF2, VC_V_VV, 0x7, 0x0 }, // 863 + { PseudoVC_V_VV_SE_MF2, VC_V_VV, 0x7, 0x0 }, // 864 + { PseudoVC_V_VVV_M1, VC_V_VVV, 0x0, 0x0 }, // 865 + { PseudoVC_V_VVV_SE_M1, VC_V_VVV, 0x0, 0x0 }, // 866 + { PseudoVC_V_VVV_M2, VC_V_VVV, 0x1, 0x0 }, // 867 + { PseudoVC_V_VVV_SE_M2, VC_V_VVV, 0x1, 0x0 }, // 868 + { PseudoVC_V_VVV_M4, VC_V_VVV, 0x2, 0x0 }, // 869 + { PseudoVC_V_VVV_SE_M4, VC_V_VVV, 0x2, 0x0 }, // 870 + { PseudoVC_V_VVV_M8, VC_V_VVV, 0x3, 0x0 }, // 871 + { PseudoVC_V_VVV_SE_M8, VC_V_VVV, 0x3, 0x0 }, // 872 + { PseudoVC_V_VVV_MF8, VC_V_VVV, 0x5, 0x0 }, // 873 + { PseudoVC_V_VVV_SE_MF8, VC_V_VVV, 0x5, 0x0 }, // 874 + { PseudoVC_V_VVV_MF4, VC_V_VVV, 0x6, 0x0 }, // 875 + { PseudoVC_V_VVV_SE_MF4, VC_V_VVV, 0x6, 0x0 }, // 876 + { PseudoVC_V_VVV_MF2, VC_V_VVV, 0x7, 0x0 }, // 877 + { PseudoVC_V_VVV_SE_MF2, VC_V_VVV, 0x7, 0x0 }, // 878 + { PseudoVC_V_VVW_M1, VC_V_VVW, 0x0, 0x0 }, // 879 + { PseudoVC_V_VVW_SE_M1, VC_V_VVW, 0x0, 0x0 }, // 880 + { PseudoVC_V_VVW_M2, VC_V_VVW, 0x1, 0x0 }, // 881 + { PseudoVC_V_VVW_SE_M2, VC_V_VVW, 0x1, 0x0 }, // 882 + { PseudoVC_V_VVW_M4, VC_V_VVW, 0x2, 0x0 }, // 883 + { PseudoVC_V_VVW_SE_M4, VC_V_VVW, 0x2, 0x0 }, // 884 + { PseudoVC_V_VVW_MF8, VC_V_VVW, 0x5, 0x0 }, // 885 + { PseudoVC_V_VVW_SE_MF8, VC_V_VVW, 0x5, 0x0 }, // 886 + { PseudoVC_V_VVW_MF4, VC_V_VVW, 0x6, 0x0 }, // 887 + { PseudoVC_V_VVW_SE_MF4, VC_V_VVW, 0x6, 0x0 }, // 888 + { PseudoVC_V_VVW_MF2, VC_V_VVW, 0x7, 0x0 }, // 889 + { PseudoVC_V_VVW_SE_MF2, VC_V_VVW, 0x7, 0x0 }, // 890 + { PseudoVC_V_X_M1, VC_V_X, 0x0, 0x0 }, // 891 + { PseudoVC_V_X_SE_M1, VC_V_X, 0x0, 0x0 }, // 892 + { PseudoVC_V_X_M2, VC_V_X, 0x1, 0x0 }, // 893 + { PseudoVC_V_X_SE_M2, VC_V_X, 0x1, 0x0 }, // 894 + { PseudoVC_V_X_M4, VC_V_X, 0x2, 0x0 }, // 895 + { PseudoVC_V_X_SE_M4, VC_V_X, 0x2, 0x0 }, // 896 + { PseudoVC_V_X_M8, VC_V_X, 0x3, 0x0 }, // 897 + { PseudoVC_V_X_SE_M8, VC_V_X, 0x3, 0x0 }, // 898 + { PseudoVC_V_X_MF8, VC_V_X, 0x5, 0x0 }, // 899 + { PseudoVC_V_X_SE_MF8, VC_V_X, 0x5, 0x0 }, // 900 + { PseudoVC_V_X_MF4, VC_V_X, 0x6, 0x0 }, // 901 + { PseudoVC_V_X_SE_MF4, VC_V_X, 0x6, 0x0 }, // 902 + { PseudoVC_V_X_MF2, VC_V_X, 0x7, 0x0 }, // 903 + { PseudoVC_V_X_SE_MF2, VC_V_X, 0x7, 0x0 }, // 904 + { PseudoVC_V_XV_M1, VC_V_XV, 0x0, 0x0 }, // 905 + { PseudoVC_V_XV_SE_M1, VC_V_XV, 0x0, 0x0 }, // 906 + { PseudoVC_V_XV_M2, VC_V_XV, 0x1, 0x0 }, // 907 + { PseudoVC_V_XV_SE_M2, VC_V_XV, 0x1, 0x0 }, // 908 + { PseudoVC_V_XV_M4, VC_V_XV, 0x2, 0x0 }, // 909 + { PseudoVC_V_XV_SE_M4, VC_V_XV, 0x2, 0x0 }, // 910 + { PseudoVC_V_XV_M8, VC_V_XV, 0x3, 0x0 }, // 911 + { PseudoVC_V_XV_SE_M8, VC_V_XV, 0x3, 0x0 }, // 912 + { PseudoVC_V_XV_MF8, VC_V_XV, 0x5, 0x0 }, // 913 + { PseudoVC_V_XV_SE_MF8, VC_V_XV, 0x5, 0x0 }, // 914 + { PseudoVC_V_XV_MF4, VC_V_XV, 0x6, 0x0 }, // 915 + { PseudoVC_V_XV_SE_MF4, VC_V_XV, 0x6, 0x0 }, // 916 + { PseudoVC_V_XV_MF2, VC_V_XV, 0x7, 0x0 }, // 917 + { PseudoVC_V_XV_SE_MF2, VC_V_XV, 0x7, 0x0 }, // 918 + { PseudoVC_V_XVV_M1, VC_V_XVV, 0x0, 0x0 }, // 919 + { PseudoVC_V_XVV_SE_M1, VC_V_XVV, 0x0, 0x0 }, // 920 + { PseudoVC_V_XVV_M2, VC_V_XVV, 0x1, 0x0 }, // 921 + { PseudoVC_V_XVV_SE_M2, VC_V_XVV, 0x1, 0x0 }, // 922 + { PseudoVC_V_XVV_M4, VC_V_XVV, 0x2, 0x0 }, // 923 + { PseudoVC_V_XVV_SE_M4, VC_V_XVV, 0x2, 0x0 }, // 924 + { PseudoVC_V_XVV_M8, VC_V_XVV, 0x3, 0x0 }, // 925 + { PseudoVC_V_XVV_SE_M8, VC_V_XVV, 0x3, 0x0 }, // 926 + { PseudoVC_V_XVV_MF8, VC_V_XVV, 0x5, 0x0 }, // 927 + { PseudoVC_V_XVV_SE_MF8, VC_V_XVV, 0x5, 0x0 }, // 928 + { PseudoVC_V_XVV_MF4, VC_V_XVV, 0x6, 0x0 }, // 929 + { PseudoVC_V_XVV_SE_MF4, VC_V_XVV, 0x6, 0x0 }, // 930 + { PseudoVC_V_XVV_MF2, VC_V_XVV, 0x7, 0x0 }, // 931 + { PseudoVC_V_XVV_SE_MF2, VC_V_XVV, 0x7, 0x0 }, // 932 + { PseudoVC_V_XVW_M1, VC_V_XVW, 0x0, 0x0 }, // 933 + { PseudoVC_V_XVW_SE_M1, VC_V_XVW, 0x0, 0x0 }, // 934 + { PseudoVC_V_XVW_M2, VC_V_XVW, 0x1, 0x0 }, // 935 + { PseudoVC_V_XVW_SE_M2, VC_V_XVW, 0x1, 0x0 }, // 936 + { PseudoVC_V_XVW_M4, VC_V_XVW, 0x2, 0x0 }, // 937 + { PseudoVC_V_XVW_SE_M4, VC_V_XVW, 0x2, 0x0 }, // 938 + { PseudoVC_V_XVW_MF8, VC_V_XVW, 0x5, 0x0 }, // 939 + { PseudoVC_V_XVW_SE_MF8, VC_V_XVW, 0x5, 0x0 }, // 940 + { PseudoVC_V_XVW_MF4, VC_V_XVW, 0x6, 0x0 }, // 941 + { PseudoVC_V_XVW_SE_MF4, VC_V_XVW, 0x6, 0x0 }, // 942 + { PseudoVC_V_XVW_MF2, VC_V_XVW, 0x7, 0x0 }, // 943 + { PseudoVC_V_XVW_SE_MF2, VC_V_XVW, 0x7, 0x0 }, // 944 + { PseudoVC_X_SE_M1, VC_X, 0x0, 0x0 }, // 945 + { PseudoVC_X_SE_M2, VC_X, 0x1, 0x0 }, // 946 + { PseudoVC_X_SE_M4, VC_X, 0x2, 0x0 }, // 947 + { PseudoVC_X_SE_M8, VC_X, 0x3, 0x0 }, // 948 + { PseudoVC_X_SE_MF8, VC_X, 0x5, 0x0 }, // 949 + { PseudoVC_X_SE_MF4, VC_X, 0x6, 0x0 }, // 950 + { PseudoVC_X_SE_MF2, VC_X, 0x7, 0x0 }, // 951 + { PseudoVC_XV_SE_M1, VC_XV, 0x0, 0x0 }, // 952 + { PseudoVC_XV_SE_M2, VC_XV, 0x1, 0x0 }, // 953 + { PseudoVC_XV_SE_M4, VC_XV, 0x2, 0x0 }, // 954 + { PseudoVC_XV_SE_M8, VC_XV, 0x3, 0x0 }, // 955 + { PseudoVC_XV_SE_MF8, VC_XV, 0x5, 0x0 }, // 956 + { PseudoVC_XV_SE_MF4, VC_XV, 0x6, 0x0 }, // 957 + { PseudoVC_XV_SE_MF2, VC_XV, 0x7, 0x0 }, // 958 + { PseudoVC_XVV_SE_M1, VC_XVV, 0x0, 0x0 }, // 959 + { PseudoVC_XVV_SE_M2, VC_XVV, 0x1, 0x0 }, // 960 + { PseudoVC_XVV_SE_M4, VC_XVV, 0x2, 0x0 }, // 961 + { PseudoVC_XVV_SE_M8, VC_XVV, 0x3, 0x0 }, // 962 + { PseudoVC_XVV_SE_MF8, VC_XVV, 0x5, 0x0 }, // 963 + { PseudoVC_XVV_SE_MF4, VC_XVV, 0x6, 0x0 }, // 964 + { PseudoVC_XVV_SE_MF2, VC_XVV, 0x7, 0x0 }, // 965 + { PseudoVC_XVW_SE_M1, VC_XVW, 0x0, 0x0 }, // 966 + { PseudoVC_XVW_SE_M2, VC_XVW, 0x1, 0x0 }, // 967 + { PseudoVC_XVW_SE_M4, VC_XVW, 0x2, 0x0 }, // 968 + { PseudoVC_XVW_SE_MF8, VC_XVW, 0x5, 0x0 }, // 969 + { PseudoVC_XVW_SE_MF4, VC_XVW, 0x6, 0x0 }, // 970 + { PseudoVC_XVW_SE_MF2, VC_XVW, 0x7, 0x0 }, // 971 + { PseudoVDIVU_VV_M1_E8, VDIVU_VV, 0x0, 0x8 }, // 972 + { PseudoVDIVU_VV_M1_E8_MASK, VDIVU_VV, 0x0, 0x8 }, // 973 + { PseudoVDIVU_VV_M1_E16, VDIVU_VV, 0x0, 0x10 }, // 974 + { PseudoVDIVU_VV_M1_E16_MASK, VDIVU_VV, 0x0, 0x10 }, // 975 + { PseudoVDIVU_VV_M1_E32, VDIVU_VV, 0x0, 0x20 }, // 976 + { PseudoVDIVU_VV_M1_E32_MASK, VDIVU_VV, 0x0, 0x20 }, // 977 + { PseudoVDIVU_VV_M1_E64, VDIVU_VV, 0x0, 0x40 }, // 978 + { PseudoVDIVU_VV_M1_E64_MASK, VDIVU_VV, 0x0, 0x40 }, // 979 + { PseudoVDIVU_VV_M2_E8, VDIVU_VV, 0x1, 0x8 }, // 980 + { PseudoVDIVU_VV_M2_E8_MASK, VDIVU_VV, 0x1, 0x8 }, // 981 + { PseudoVDIVU_VV_M2_E16, VDIVU_VV, 0x1, 0x10 }, // 982 + { PseudoVDIVU_VV_M2_E16_MASK, VDIVU_VV, 0x1, 0x10 }, // 983 + { PseudoVDIVU_VV_M2_E32, VDIVU_VV, 0x1, 0x20 }, // 984 + { PseudoVDIVU_VV_M2_E32_MASK, VDIVU_VV, 0x1, 0x20 }, // 985 + { PseudoVDIVU_VV_M2_E64, VDIVU_VV, 0x1, 0x40 }, // 986 + { PseudoVDIVU_VV_M2_E64_MASK, VDIVU_VV, 0x1, 0x40 }, // 987 + { PseudoVDIVU_VV_M4_E8, VDIVU_VV, 0x2, 0x8 }, // 988 + { PseudoVDIVU_VV_M4_E8_MASK, VDIVU_VV, 0x2, 0x8 }, // 989 + { PseudoVDIVU_VV_M4_E16, VDIVU_VV, 0x2, 0x10 }, // 990 + { PseudoVDIVU_VV_M4_E16_MASK, VDIVU_VV, 0x2, 0x10 }, // 991 + { PseudoVDIVU_VV_M4_E32, VDIVU_VV, 0x2, 0x20 }, // 992 + { PseudoVDIVU_VV_M4_E32_MASK, VDIVU_VV, 0x2, 0x20 }, // 993 + { PseudoVDIVU_VV_M4_E64, VDIVU_VV, 0x2, 0x40 }, // 994 + { PseudoVDIVU_VV_M4_E64_MASK, VDIVU_VV, 0x2, 0x40 }, // 995 + { PseudoVDIVU_VV_M8_E8, VDIVU_VV, 0x3, 0x8 }, // 996 + { PseudoVDIVU_VV_M8_E8_MASK, VDIVU_VV, 0x3, 0x8 }, // 997 + { PseudoVDIVU_VV_M8_E16, VDIVU_VV, 0x3, 0x10 }, // 998 + { PseudoVDIVU_VV_M8_E16_MASK, VDIVU_VV, 0x3, 0x10 }, // 999 + { PseudoVDIVU_VV_M8_E32, VDIVU_VV, 0x3, 0x20 }, // 1000 + { PseudoVDIVU_VV_M8_E32_MASK, VDIVU_VV, 0x3, 0x20 }, // 1001 + { PseudoVDIVU_VV_M8_E64, VDIVU_VV, 0x3, 0x40 }, // 1002 + { PseudoVDIVU_VV_M8_E64_MASK, VDIVU_VV, 0x3, 0x40 }, // 1003 + { PseudoVDIVU_VV_MF8_E8, VDIVU_VV, 0x5, 0x8 }, // 1004 + { PseudoVDIVU_VV_MF8_E8_MASK, VDIVU_VV, 0x5, 0x8 }, // 1005 + { PseudoVDIVU_VV_MF4_E8, VDIVU_VV, 0x6, 0x8 }, // 1006 + { PseudoVDIVU_VV_MF4_E8_MASK, VDIVU_VV, 0x6, 0x8 }, // 1007 + { PseudoVDIVU_VV_MF4_E16, VDIVU_VV, 0x6, 0x10 }, // 1008 + { PseudoVDIVU_VV_MF4_E16_MASK, VDIVU_VV, 0x6, 0x10 }, // 1009 + { PseudoVDIVU_VV_MF2_E8, VDIVU_VV, 0x7, 0x8 }, // 1010 + { PseudoVDIVU_VV_MF2_E8_MASK, VDIVU_VV, 0x7, 0x8 }, // 1011 + { PseudoVDIVU_VV_MF2_E16, VDIVU_VV, 0x7, 0x10 }, // 1012 + { PseudoVDIVU_VV_MF2_E16_MASK, VDIVU_VV, 0x7, 0x10 }, // 1013 + { PseudoVDIVU_VV_MF2_E32, VDIVU_VV, 0x7, 0x20 }, // 1014 + { PseudoVDIVU_VV_MF2_E32_MASK, VDIVU_VV, 0x7, 0x20 }, // 1015 + { PseudoVDIVU_VX_M1_E8, VDIVU_VX, 0x0, 0x8 }, // 1016 + { PseudoVDIVU_VX_M1_E8_MASK, VDIVU_VX, 0x0, 0x8 }, // 1017 + { PseudoVDIVU_VX_M1_E16, VDIVU_VX, 0x0, 0x10 }, // 1018 + { PseudoVDIVU_VX_M1_E16_MASK, VDIVU_VX, 0x0, 0x10 }, // 1019 + { PseudoVDIVU_VX_M1_E32, VDIVU_VX, 0x0, 0x20 }, // 1020 + { PseudoVDIVU_VX_M1_E32_MASK, VDIVU_VX, 0x0, 0x20 }, // 1021 + { PseudoVDIVU_VX_M1_E64, VDIVU_VX, 0x0, 0x40 }, // 1022 + { PseudoVDIVU_VX_M1_E64_MASK, VDIVU_VX, 0x0, 0x40 }, // 1023 + { PseudoVDIVU_VX_M2_E8, VDIVU_VX, 0x1, 0x8 }, // 1024 + { PseudoVDIVU_VX_M2_E8_MASK, VDIVU_VX, 0x1, 0x8 }, // 1025 + { PseudoVDIVU_VX_M2_E16, VDIVU_VX, 0x1, 0x10 }, // 1026 + { PseudoVDIVU_VX_M2_E16_MASK, VDIVU_VX, 0x1, 0x10 }, // 1027 + { PseudoVDIVU_VX_M2_E32, VDIVU_VX, 0x1, 0x20 }, // 1028 + { PseudoVDIVU_VX_M2_E32_MASK, VDIVU_VX, 0x1, 0x20 }, // 1029 + { PseudoVDIVU_VX_M2_E64, VDIVU_VX, 0x1, 0x40 }, // 1030 + { PseudoVDIVU_VX_M2_E64_MASK, VDIVU_VX, 0x1, 0x40 }, // 1031 + { PseudoVDIVU_VX_M4_E8, VDIVU_VX, 0x2, 0x8 }, // 1032 + { PseudoVDIVU_VX_M4_E8_MASK, VDIVU_VX, 0x2, 0x8 }, // 1033 + { PseudoVDIVU_VX_M4_E16, VDIVU_VX, 0x2, 0x10 }, // 1034 + { PseudoVDIVU_VX_M4_E16_MASK, VDIVU_VX, 0x2, 0x10 }, // 1035 + { PseudoVDIVU_VX_M4_E32, VDIVU_VX, 0x2, 0x20 }, // 1036 + { PseudoVDIVU_VX_M4_E32_MASK, VDIVU_VX, 0x2, 0x20 }, // 1037 + { PseudoVDIVU_VX_M4_E64, VDIVU_VX, 0x2, 0x40 }, // 1038 + { PseudoVDIVU_VX_M4_E64_MASK, VDIVU_VX, 0x2, 0x40 }, // 1039 + { PseudoVDIVU_VX_M8_E8, VDIVU_VX, 0x3, 0x8 }, // 1040 + { PseudoVDIVU_VX_M8_E8_MASK, VDIVU_VX, 0x3, 0x8 }, // 1041 + { PseudoVDIVU_VX_M8_E16, VDIVU_VX, 0x3, 0x10 }, // 1042 + { PseudoVDIVU_VX_M8_E16_MASK, VDIVU_VX, 0x3, 0x10 }, // 1043 + { PseudoVDIVU_VX_M8_E32, VDIVU_VX, 0x3, 0x20 }, // 1044 + { PseudoVDIVU_VX_M8_E32_MASK, VDIVU_VX, 0x3, 0x20 }, // 1045 + { PseudoVDIVU_VX_M8_E64, VDIVU_VX, 0x3, 0x40 }, // 1046 + { PseudoVDIVU_VX_M8_E64_MASK, VDIVU_VX, 0x3, 0x40 }, // 1047 + { PseudoVDIVU_VX_MF8_E8, VDIVU_VX, 0x5, 0x8 }, // 1048 + { PseudoVDIVU_VX_MF8_E8_MASK, VDIVU_VX, 0x5, 0x8 }, // 1049 + { PseudoVDIVU_VX_MF4_E8, VDIVU_VX, 0x6, 0x8 }, // 1050 + { PseudoVDIVU_VX_MF4_E8_MASK, VDIVU_VX, 0x6, 0x8 }, // 1051 + { PseudoVDIVU_VX_MF4_E16, VDIVU_VX, 0x6, 0x10 }, // 1052 + { PseudoVDIVU_VX_MF4_E16_MASK, VDIVU_VX, 0x6, 0x10 }, // 1053 + { PseudoVDIVU_VX_MF2_E8, VDIVU_VX, 0x7, 0x8 }, // 1054 + { PseudoVDIVU_VX_MF2_E8_MASK, VDIVU_VX, 0x7, 0x8 }, // 1055 + { PseudoVDIVU_VX_MF2_E16, VDIVU_VX, 0x7, 0x10 }, // 1056 + { PseudoVDIVU_VX_MF2_E16_MASK, VDIVU_VX, 0x7, 0x10 }, // 1057 + { PseudoVDIVU_VX_MF2_E32, VDIVU_VX, 0x7, 0x20 }, // 1058 + { PseudoVDIVU_VX_MF2_E32_MASK, VDIVU_VX, 0x7, 0x20 }, // 1059 + { PseudoVDIV_VV_M1_E8, VDIV_VV, 0x0, 0x8 }, // 1060 + { PseudoVDIV_VV_M1_E8_MASK, VDIV_VV, 0x0, 0x8 }, // 1061 + { PseudoVDIV_VV_M1_E16, VDIV_VV, 0x0, 0x10 }, // 1062 + { PseudoVDIV_VV_M1_E16_MASK, VDIV_VV, 0x0, 0x10 }, // 1063 + { PseudoVDIV_VV_M1_E32, VDIV_VV, 0x0, 0x20 }, // 1064 + { PseudoVDIV_VV_M1_E32_MASK, VDIV_VV, 0x0, 0x20 }, // 1065 + { PseudoVDIV_VV_M1_E64, VDIV_VV, 0x0, 0x40 }, // 1066 + { PseudoVDIV_VV_M1_E64_MASK, VDIV_VV, 0x0, 0x40 }, // 1067 + { PseudoVDIV_VV_M2_E8, VDIV_VV, 0x1, 0x8 }, // 1068 + { PseudoVDIV_VV_M2_E8_MASK, VDIV_VV, 0x1, 0x8 }, // 1069 + { PseudoVDIV_VV_M2_E16, VDIV_VV, 0x1, 0x10 }, // 1070 + { PseudoVDIV_VV_M2_E16_MASK, VDIV_VV, 0x1, 0x10 }, // 1071 + { PseudoVDIV_VV_M2_E32, VDIV_VV, 0x1, 0x20 }, // 1072 + { PseudoVDIV_VV_M2_E32_MASK, VDIV_VV, 0x1, 0x20 }, // 1073 + { PseudoVDIV_VV_M2_E64, VDIV_VV, 0x1, 0x40 }, // 1074 + { PseudoVDIV_VV_M2_E64_MASK, VDIV_VV, 0x1, 0x40 }, // 1075 + { PseudoVDIV_VV_M4_E8, VDIV_VV, 0x2, 0x8 }, // 1076 + { PseudoVDIV_VV_M4_E8_MASK, VDIV_VV, 0x2, 0x8 }, // 1077 + { PseudoVDIV_VV_M4_E16, VDIV_VV, 0x2, 0x10 }, // 1078 + { PseudoVDIV_VV_M4_E16_MASK, VDIV_VV, 0x2, 0x10 }, // 1079 + { PseudoVDIV_VV_M4_E32, VDIV_VV, 0x2, 0x20 }, // 1080 + { PseudoVDIV_VV_M4_E32_MASK, VDIV_VV, 0x2, 0x20 }, // 1081 + { PseudoVDIV_VV_M4_E64, VDIV_VV, 0x2, 0x40 }, // 1082 + { PseudoVDIV_VV_M4_E64_MASK, VDIV_VV, 0x2, 0x40 }, // 1083 + { PseudoVDIV_VV_M8_E8, VDIV_VV, 0x3, 0x8 }, // 1084 + { PseudoVDIV_VV_M8_E8_MASK, VDIV_VV, 0x3, 0x8 }, // 1085 + { PseudoVDIV_VV_M8_E16, VDIV_VV, 0x3, 0x10 }, // 1086 + { PseudoVDIV_VV_M8_E16_MASK, VDIV_VV, 0x3, 0x10 }, // 1087 + { PseudoVDIV_VV_M8_E32, VDIV_VV, 0x3, 0x20 }, // 1088 + { PseudoVDIV_VV_M8_E32_MASK, VDIV_VV, 0x3, 0x20 }, // 1089 + { PseudoVDIV_VV_M8_E64, VDIV_VV, 0x3, 0x40 }, // 1090 + { PseudoVDIV_VV_M8_E64_MASK, VDIV_VV, 0x3, 0x40 }, // 1091 + { PseudoVDIV_VV_MF8_E8, VDIV_VV, 0x5, 0x8 }, // 1092 + { PseudoVDIV_VV_MF8_E8_MASK, VDIV_VV, 0x5, 0x8 }, // 1093 + { PseudoVDIV_VV_MF4_E8, VDIV_VV, 0x6, 0x8 }, // 1094 + { PseudoVDIV_VV_MF4_E8_MASK, VDIV_VV, 0x6, 0x8 }, // 1095 + { PseudoVDIV_VV_MF4_E16, VDIV_VV, 0x6, 0x10 }, // 1096 + { PseudoVDIV_VV_MF4_E16_MASK, VDIV_VV, 0x6, 0x10 }, // 1097 + { PseudoVDIV_VV_MF2_E8, VDIV_VV, 0x7, 0x8 }, // 1098 + { PseudoVDIV_VV_MF2_E8_MASK, VDIV_VV, 0x7, 0x8 }, // 1099 + { PseudoVDIV_VV_MF2_E16, VDIV_VV, 0x7, 0x10 }, // 1100 + { PseudoVDIV_VV_MF2_E16_MASK, VDIV_VV, 0x7, 0x10 }, // 1101 + { PseudoVDIV_VV_MF2_E32, VDIV_VV, 0x7, 0x20 }, // 1102 + { PseudoVDIV_VV_MF2_E32_MASK, VDIV_VV, 0x7, 0x20 }, // 1103 + { PseudoVDIV_VX_M1_E8, VDIV_VX, 0x0, 0x8 }, // 1104 + { PseudoVDIV_VX_M1_E8_MASK, VDIV_VX, 0x0, 0x8 }, // 1105 + { PseudoVDIV_VX_M1_E16, VDIV_VX, 0x0, 0x10 }, // 1106 + { PseudoVDIV_VX_M1_E16_MASK, VDIV_VX, 0x0, 0x10 }, // 1107 + { PseudoVDIV_VX_M1_E32, VDIV_VX, 0x0, 0x20 }, // 1108 + { PseudoVDIV_VX_M1_E32_MASK, VDIV_VX, 0x0, 0x20 }, // 1109 + { PseudoVDIV_VX_M1_E64, VDIV_VX, 0x0, 0x40 }, // 1110 + { PseudoVDIV_VX_M1_E64_MASK, VDIV_VX, 0x0, 0x40 }, // 1111 + { PseudoVDIV_VX_M2_E8, VDIV_VX, 0x1, 0x8 }, // 1112 + { PseudoVDIV_VX_M2_E8_MASK, VDIV_VX, 0x1, 0x8 }, // 1113 + { PseudoVDIV_VX_M2_E16, VDIV_VX, 0x1, 0x10 }, // 1114 + { PseudoVDIV_VX_M2_E16_MASK, VDIV_VX, 0x1, 0x10 }, // 1115 + { PseudoVDIV_VX_M2_E32, VDIV_VX, 0x1, 0x20 }, // 1116 + { PseudoVDIV_VX_M2_E32_MASK, VDIV_VX, 0x1, 0x20 }, // 1117 + { PseudoVDIV_VX_M2_E64, VDIV_VX, 0x1, 0x40 }, // 1118 + { PseudoVDIV_VX_M2_E64_MASK, VDIV_VX, 0x1, 0x40 }, // 1119 + { PseudoVDIV_VX_M4_E8, VDIV_VX, 0x2, 0x8 }, // 1120 + { PseudoVDIV_VX_M4_E8_MASK, VDIV_VX, 0x2, 0x8 }, // 1121 + { PseudoVDIV_VX_M4_E16, VDIV_VX, 0x2, 0x10 }, // 1122 + { PseudoVDIV_VX_M4_E16_MASK, VDIV_VX, 0x2, 0x10 }, // 1123 + { PseudoVDIV_VX_M4_E32, VDIV_VX, 0x2, 0x20 }, // 1124 + { PseudoVDIV_VX_M4_E32_MASK, VDIV_VX, 0x2, 0x20 }, // 1125 + { PseudoVDIV_VX_M4_E64, VDIV_VX, 0x2, 0x40 }, // 1126 + { PseudoVDIV_VX_M4_E64_MASK, VDIV_VX, 0x2, 0x40 }, // 1127 + { PseudoVDIV_VX_M8_E8, VDIV_VX, 0x3, 0x8 }, // 1128 + { PseudoVDIV_VX_M8_E8_MASK, VDIV_VX, 0x3, 0x8 }, // 1129 + { PseudoVDIV_VX_M8_E16, VDIV_VX, 0x3, 0x10 }, // 1130 + { PseudoVDIV_VX_M8_E16_MASK, VDIV_VX, 0x3, 0x10 }, // 1131 + { PseudoVDIV_VX_M8_E32, VDIV_VX, 0x3, 0x20 }, // 1132 + { PseudoVDIV_VX_M8_E32_MASK, VDIV_VX, 0x3, 0x20 }, // 1133 + { PseudoVDIV_VX_M8_E64, VDIV_VX, 0x3, 0x40 }, // 1134 + { PseudoVDIV_VX_M8_E64_MASK, VDIV_VX, 0x3, 0x40 }, // 1135 + { PseudoVDIV_VX_MF8_E8, VDIV_VX, 0x5, 0x8 }, // 1136 + { PseudoVDIV_VX_MF8_E8_MASK, VDIV_VX, 0x5, 0x8 }, // 1137 + { PseudoVDIV_VX_MF4_E8, VDIV_VX, 0x6, 0x8 }, // 1138 + { PseudoVDIV_VX_MF4_E8_MASK, VDIV_VX, 0x6, 0x8 }, // 1139 + { PseudoVDIV_VX_MF4_E16, VDIV_VX, 0x6, 0x10 }, // 1140 + { PseudoVDIV_VX_MF4_E16_MASK, VDIV_VX, 0x6, 0x10 }, // 1141 + { PseudoVDIV_VX_MF2_E8, VDIV_VX, 0x7, 0x8 }, // 1142 + { PseudoVDIV_VX_MF2_E8_MASK, VDIV_VX, 0x7, 0x8 }, // 1143 + { PseudoVDIV_VX_MF2_E16, VDIV_VX, 0x7, 0x10 }, // 1144 + { PseudoVDIV_VX_MF2_E16_MASK, VDIV_VX, 0x7, 0x10 }, // 1145 + { PseudoVDIV_VX_MF2_E32, VDIV_VX, 0x7, 0x20 }, // 1146 + { PseudoVDIV_VX_MF2_E32_MASK, VDIV_VX, 0x7, 0x20 }, // 1147 + { PseudoVFADD_VFPR16_M1, VFADD_VF, 0x0, 0x0 }, // 1148 + { PseudoVFADD_VFPR16_M1_MASK, VFADD_VF, 0x0, 0x0 }, // 1149 + { PseudoVFADD_VFPR32_M1, VFADD_VF, 0x0, 0x0 }, // 1150 + { PseudoVFADD_VFPR32_M1_MASK, VFADD_VF, 0x0, 0x0 }, // 1151 + { PseudoVFADD_VFPR64_M1, VFADD_VF, 0x0, 0x0 }, // 1152 + { PseudoVFADD_VFPR64_M1_MASK, VFADD_VF, 0x0, 0x0 }, // 1153 + { PseudoVFADD_VFPR16_M2, VFADD_VF, 0x1, 0x0 }, // 1154 + { PseudoVFADD_VFPR16_M2_MASK, VFADD_VF, 0x1, 0x0 }, // 1155 + { PseudoVFADD_VFPR32_M2, VFADD_VF, 0x1, 0x0 }, // 1156 + { PseudoVFADD_VFPR32_M2_MASK, VFADD_VF, 0x1, 0x0 }, // 1157 + { PseudoVFADD_VFPR64_M2, VFADD_VF, 0x1, 0x0 }, // 1158 + { PseudoVFADD_VFPR64_M2_MASK, VFADD_VF, 0x1, 0x0 }, // 1159 + { PseudoVFADD_VFPR16_M4, VFADD_VF, 0x2, 0x0 }, // 1160 + { PseudoVFADD_VFPR16_M4_MASK, VFADD_VF, 0x2, 0x0 }, // 1161 + { PseudoVFADD_VFPR32_M4, VFADD_VF, 0x2, 0x0 }, // 1162 + { PseudoVFADD_VFPR32_M4_MASK, VFADD_VF, 0x2, 0x0 }, // 1163 + { PseudoVFADD_VFPR64_M4, VFADD_VF, 0x2, 0x0 }, // 1164 + { PseudoVFADD_VFPR64_M4_MASK, VFADD_VF, 0x2, 0x0 }, // 1165 + { PseudoVFADD_VFPR16_M8, VFADD_VF, 0x3, 0x0 }, // 1166 + { PseudoVFADD_VFPR16_M8_MASK, VFADD_VF, 0x3, 0x0 }, // 1167 + { PseudoVFADD_VFPR32_M8, VFADD_VF, 0x3, 0x0 }, // 1168 + { PseudoVFADD_VFPR32_M8_MASK, VFADD_VF, 0x3, 0x0 }, // 1169 + { PseudoVFADD_VFPR64_M8, VFADD_VF, 0x3, 0x0 }, // 1170 + { PseudoVFADD_VFPR64_M8_MASK, VFADD_VF, 0x3, 0x0 }, // 1171 + { PseudoVFADD_VFPR16_MF4, VFADD_VF, 0x6, 0x0 }, // 1172 + { PseudoVFADD_VFPR16_MF4_MASK, VFADD_VF, 0x6, 0x0 }, // 1173 + { PseudoVFADD_VFPR16_MF2, VFADD_VF, 0x7, 0x0 }, // 1174 + { PseudoVFADD_VFPR16_MF2_MASK, VFADD_VF, 0x7, 0x0 }, // 1175 + { PseudoVFADD_VFPR32_MF2, VFADD_VF, 0x7, 0x0 }, // 1176 + { PseudoVFADD_VFPR32_MF2_MASK, VFADD_VF, 0x7, 0x0 }, // 1177 + { PseudoVFADD_VV_M1, VFADD_VV, 0x0, 0x0 }, // 1178 + { PseudoVFADD_VV_M1_MASK, VFADD_VV, 0x0, 0x0 }, // 1179 + { PseudoVFADD_VV_M2, VFADD_VV, 0x1, 0x0 }, // 1180 + { PseudoVFADD_VV_M2_MASK, VFADD_VV, 0x1, 0x0 }, // 1181 + { PseudoVFADD_VV_M4, VFADD_VV, 0x2, 0x0 }, // 1182 + { PseudoVFADD_VV_M4_MASK, VFADD_VV, 0x2, 0x0 }, // 1183 + { PseudoVFADD_VV_M8, VFADD_VV, 0x3, 0x0 }, // 1184 + { PseudoVFADD_VV_M8_MASK, VFADD_VV, 0x3, 0x0 }, // 1185 + { PseudoVFADD_VV_MF4, VFADD_VV, 0x6, 0x0 }, // 1186 + { PseudoVFADD_VV_MF4_MASK, VFADD_VV, 0x6, 0x0 }, // 1187 + { PseudoVFADD_VV_MF2, VFADD_VV, 0x7, 0x0 }, // 1188 + { PseudoVFADD_VV_MF2_MASK, VFADD_VV, 0x7, 0x0 }, // 1189 + { PseudoVFCLASS_V_M1, VFCLASS_V, 0x0, 0x0 }, // 1190 + { PseudoVFCLASS_V_M1_MASK, VFCLASS_V, 0x0, 0x0 }, // 1191 + { PseudoVFCLASS_V_M2, VFCLASS_V, 0x1, 0x0 }, // 1192 + { PseudoVFCLASS_V_M2_MASK, VFCLASS_V, 0x1, 0x0 }, // 1193 + { PseudoVFCLASS_V_M4, VFCLASS_V, 0x2, 0x0 }, // 1194 + { PseudoVFCLASS_V_M4_MASK, VFCLASS_V, 0x2, 0x0 }, // 1195 + { PseudoVFCLASS_V_M8, VFCLASS_V, 0x3, 0x0 }, // 1196 + { PseudoVFCLASS_V_M8_MASK, VFCLASS_V, 0x3, 0x0 }, // 1197 + { PseudoVFCLASS_V_MF4, VFCLASS_V, 0x6, 0x0 }, // 1198 + { PseudoVFCLASS_V_MF4_MASK, VFCLASS_V, 0x6, 0x0 }, // 1199 + { PseudoVFCLASS_V_MF2, VFCLASS_V, 0x7, 0x0 }, // 1200 + { PseudoVFCLASS_V_MF2_MASK, VFCLASS_V, 0x7, 0x0 }, // 1201 + { PseudoVFCVT_F_XU_V_M1, VFCVT_F_XU_V, 0x0, 0x0 }, // 1202 + { PseudoVFCVT_F_XU_V_M1_MASK, VFCVT_F_XU_V, 0x0, 0x0 }, // 1203 + { PseudoVFCVT_RM_F_XU_V_M1, VFCVT_F_XU_V, 0x0, 0x0 }, // 1204 + { PseudoVFCVT_RM_F_XU_V_M1_MASK, VFCVT_F_XU_V, 0x0, 0x0 }, // 1205 + { PseudoVFCVT_F_XU_V_M2, VFCVT_F_XU_V, 0x1, 0x0 }, // 1206 + { PseudoVFCVT_F_XU_V_M2_MASK, VFCVT_F_XU_V, 0x1, 0x0 }, // 1207 + { PseudoVFCVT_RM_F_XU_V_M2, VFCVT_F_XU_V, 0x1, 0x0 }, // 1208 + { PseudoVFCVT_RM_F_XU_V_M2_MASK, VFCVT_F_XU_V, 0x1, 0x0 }, // 1209 + { PseudoVFCVT_F_XU_V_M4, VFCVT_F_XU_V, 0x2, 0x0 }, // 1210 + { PseudoVFCVT_F_XU_V_M4_MASK, VFCVT_F_XU_V, 0x2, 0x0 }, // 1211 + { PseudoVFCVT_RM_F_XU_V_M4, VFCVT_F_XU_V, 0x2, 0x0 }, // 1212 + { PseudoVFCVT_RM_F_XU_V_M4_MASK, VFCVT_F_XU_V, 0x2, 0x0 }, // 1213 + { PseudoVFCVT_F_XU_V_M8, VFCVT_F_XU_V, 0x3, 0x0 }, // 1214 + { PseudoVFCVT_F_XU_V_M8_MASK, VFCVT_F_XU_V, 0x3, 0x0 }, // 1215 + { PseudoVFCVT_RM_F_XU_V_M8, VFCVT_F_XU_V, 0x3, 0x0 }, // 1216 + { PseudoVFCVT_RM_F_XU_V_M8_MASK, VFCVT_F_XU_V, 0x3, 0x0 }, // 1217 + { PseudoVFCVT_F_XU_V_MF4, VFCVT_F_XU_V, 0x6, 0x0 }, // 1218 + { PseudoVFCVT_F_XU_V_MF4_MASK, VFCVT_F_XU_V, 0x6, 0x0 }, // 1219 + { PseudoVFCVT_RM_F_XU_V_MF4, VFCVT_F_XU_V, 0x6, 0x0 }, // 1220 + { PseudoVFCVT_RM_F_XU_V_MF4_MASK, VFCVT_F_XU_V, 0x6, 0x0 }, // 1221 + { PseudoVFCVT_F_XU_V_MF2, VFCVT_F_XU_V, 0x7, 0x0 }, // 1222 + { PseudoVFCVT_F_XU_V_MF2_MASK, VFCVT_F_XU_V, 0x7, 0x0 }, // 1223 + { PseudoVFCVT_RM_F_XU_V_MF2, VFCVT_F_XU_V, 0x7, 0x0 }, // 1224 + { PseudoVFCVT_RM_F_XU_V_MF2_MASK, VFCVT_F_XU_V, 0x7, 0x0 }, // 1225 + { PseudoVFCVT_F_X_V_M1, VFCVT_F_X_V, 0x0, 0x0 }, // 1226 + { PseudoVFCVT_F_X_V_M1_MASK, VFCVT_F_X_V, 0x0, 0x0 }, // 1227 + { PseudoVFCVT_RM_F_X_V_M1, VFCVT_F_X_V, 0x0, 0x0 }, // 1228 + { PseudoVFCVT_RM_F_X_V_M1_MASK, VFCVT_F_X_V, 0x0, 0x0 }, // 1229 + { PseudoVFCVT_F_X_V_M2, VFCVT_F_X_V, 0x1, 0x0 }, // 1230 + { PseudoVFCVT_F_X_V_M2_MASK, VFCVT_F_X_V, 0x1, 0x0 }, // 1231 + { PseudoVFCVT_RM_F_X_V_M2, VFCVT_F_X_V, 0x1, 0x0 }, // 1232 + { PseudoVFCVT_RM_F_X_V_M2_MASK, VFCVT_F_X_V, 0x1, 0x0 }, // 1233 + { PseudoVFCVT_F_X_V_M4, VFCVT_F_X_V, 0x2, 0x0 }, // 1234 + { PseudoVFCVT_F_X_V_M4_MASK, VFCVT_F_X_V, 0x2, 0x0 }, // 1235 + { PseudoVFCVT_RM_F_X_V_M4, VFCVT_F_X_V, 0x2, 0x0 }, // 1236 + { PseudoVFCVT_RM_F_X_V_M4_MASK, VFCVT_F_X_V, 0x2, 0x0 }, // 1237 + { PseudoVFCVT_F_X_V_M8, VFCVT_F_X_V, 0x3, 0x0 }, // 1238 + { PseudoVFCVT_F_X_V_M8_MASK, VFCVT_F_X_V, 0x3, 0x0 }, // 1239 + { PseudoVFCVT_RM_F_X_V_M8, VFCVT_F_X_V, 0x3, 0x0 }, // 1240 + { PseudoVFCVT_RM_F_X_V_M8_MASK, VFCVT_F_X_V, 0x3, 0x0 }, // 1241 + { PseudoVFCVT_F_X_V_MF4, VFCVT_F_X_V, 0x6, 0x0 }, // 1242 + { PseudoVFCVT_F_X_V_MF4_MASK, VFCVT_F_X_V, 0x6, 0x0 }, // 1243 + { PseudoVFCVT_RM_F_X_V_MF4, VFCVT_F_X_V, 0x6, 0x0 }, // 1244 + { PseudoVFCVT_RM_F_X_V_MF4_MASK, VFCVT_F_X_V, 0x6, 0x0 }, // 1245 + { PseudoVFCVT_F_X_V_MF2, VFCVT_F_X_V, 0x7, 0x0 }, // 1246 + { PseudoVFCVT_F_X_V_MF2_MASK, VFCVT_F_X_V, 0x7, 0x0 }, // 1247 + { PseudoVFCVT_RM_F_X_V_MF2, VFCVT_F_X_V, 0x7, 0x0 }, // 1248 + { PseudoVFCVT_RM_F_X_V_MF2_MASK, VFCVT_F_X_V, 0x7, 0x0 }, // 1249 + { PseudoVFCVT_RTZ_XU_F_V_M1, VFCVT_RTZ_XU_F_V, 0x0, 0x0 }, // 1250 + { PseudoVFCVT_RTZ_XU_F_V_M1_MASK, VFCVT_RTZ_XU_F_V, 0x0, 0x0 }, // 1251 + { PseudoVFCVT_RTZ_XU_F_V_M2, VFCVT_RTZ_XU_F_V, 0x1, 0x0 }, // 1252 + { PseudoVFCVT_RTZ_XU_F_V_M2_MASK, VFCVT_RTZ_XU_F_V, 0x1, 0x0 }, // 1253 + { PseudoVFCVT_RTZ_XU_F_V_M4, VFCVT_RTZ_XU_F_V, 0x2, 0x0 }, // 1254 + { PseudoVFCVT_RTZ_XU_F_V_M4_MASK, VFCVT_RTZ_XU_F_V, 0x2, 0x0 }, // 1255 + { PseudoVFCVT_RTZ_XU_F_V_M8, VFCVT_RTZ_XU_F_V, 0x3, 0x0 }, // 1256 + { PseudoVFCVT_RTZ_XU_F_V_M8_MASK, VFCVT_RTZ_XU_F_V, 0x3, 0x0 }, // 1257 + { PseudoVFCVT_RTZ_XU_F_V_MF4, VFCVT_RTZ_XU_F_V, 0x6, 0x0 }, // 1258 + { PseudoVFCVT_RTZ_XU_F_V_MF4_MASK, VFCVT_RTZ_XU_F_V, 0x6, 0x0 }, // 1259 + { PseudoVFCVT_RTZ_XU_F_V_MF2, VFCVT_RTZ_XU_F_V, 0x7, 0x0 }, // 1260 + { PseudoVFCVT_RTZ_XU_F_V_MF2_MASK, VFCVT_RTZ_XU_F_V, 0x7, 0x0 }, // 1261 + { PseudoVFCVT_RTZ_X_F_V_M1, VFCVT_RTZ_X_F_V, 0x0, 0x0 }, // 1262 + { PseudoVFCVT_RTZ_X_F_V_M1_MASK, VFCVT_RTZ_X_F_V, 0x0, 0x0 }, // 1263 + { PseudoVFCVT_RTZ_X_F_V_M2, VFCVT_RTZ_X_F_V, 0x1, 0x0 }, // 1264 + { PseudoVFCVT_RTZ_X_F_V_M2_MASK, VFCVT_RTZ_X_F_V, 0x1, 0x0 }, // 1265 + { PseudoVFCVT_RTZ_X_F_V_M4, VFCVT_RTZ_X_F_V, 0x2, 0x0 }, // 1266 + { PseudoVFCVT_RTZ_X_F_V_M4_MASK, VFCVT_RTZ_X_F_V, 0x2, 0x0 }, // 1267 + { PseudoVFCVT_RTZ_X_F_V_M8, VFCVT_RTZ_X_F_V, 0x3, 0x0 }, // 1268 + { PseudoVFCVT_RTZ_X_F_V_M8_MASK, VFCVT_RTZ_X_F_V, 0x3, 0x0 }, // 1269 + { PseudoVFCVT_RTZ_X_F_V_MF4, VFCVT_RTZ_X_F_V, 0x6, 0x0 }, // 1270 + { PseudoVFCVT_RTZ_X_F_V_MF4_MASK, VFCVT_RTZ_X_F_V, 0x6, 0x0 }, // 1271 + { PseudoVFCVT_RTZ_X_F_V_MF2, VFCVT_RTZ_X_F_V, 0x7, 0x0 }, // 1272 + { PseudoVFCVT_RTZ_X_F_V_MF2_MASK, VFCVT_RTZ_X_F_V, 0x7, 0x0 }, // 1273 + { PseudoVFCVT_RM_XU_F_V_M1, VFCVT_XU_F_V, 0x0, 0x0 }, // 1274 + { PseudoVFCVT_RM_XU_F_V_M1_MASK, VFCVT_XU_F_V, 0x0, 0x0 }, // 1275 + { PseudoVFCVT_XU_F_V_M1, VFCVT_XU_F_V, 0x0, 0x0 }, // 1276 + { PseudoVFCVT_XU_F_V_M1_MASK, VFCVT_XU_F_V, 0x0, 0x0 }, // 1277 + { PseudoVFCVT_RM_XU_F_V_M2, VFCVT_XU_F_V, 0x1, 0x0 }, // 1278 + { PseudoVFCVT_RM_XU_F_V_M2_MASK, VFCVT_XU_F_V, 0x1, 0x0 }, // 1279 + { PseudoVFCVT_XU_F_V_M2, VFCVT_XU_F_V, 0x1, 0x0 }, // 1280 + { PseudoVFCVT_XU_F_V_M2_MASK, VFCVT_XU_F_V, 0x1, 0x0 }, // 1281 + { PseudoVFCVT_RM_XU_F_V_M4, VFCVT_XU_F_V, 0x2, 0x0 }, // 1282 + { PseudoVFCVT_RM_XU_F_V_M4_MASK, VFCVT_XU_F_V, 0x2, 0x0 }, // 1283 + { PseudoVFCVT_XU_F_V_M4, VFCVT_XU_F_V, 0x2, 0x0 }, // 1284 + { PseudoVFCVT_XU_F_V_M4_MASK, VFCVT_XU_F_V, 0x2, 0x0 }, // 1285 + { PseudoVFCVT_RM_XU_F_V_M8, VFCVT_XU_F_V, 0x3, 0x0 }, // 1286 + { PseudoVFCVT_RM_XU_F_V_M8_MASK, VFCVT_XU_F_V, 0x3, 0x0 }, // 1287 + { PseudoVFCVT_XU_F_V_M8, VFCVT_XU_F_V, 0x3, 0x0 }, // 1288 + { PseudoVFCVT_XU_F_V_M8_MASK, VFCVT_XU_F_V, 0x3, 0x0 }, // 1289 + { PseudoVFCVT_RM_XU_F_V_MF4, VFCVT_XU_F_V, 0x6, 0x0 }, // 1290 + { PseudoVFCVT_RM_XU_F_V_MF4_MASK, VFCVT_XU_F_V, 0x6, 0x0 }, // 1291 + { PseudoVFCVT_XU_F_V_MF4, VFCVT_XU_F_V, 0x6, 0x0 }, // 1292 + { PseudoVFCVT_XU_F_V_MF4_MASK, VFCVT_XU_F_V, 0x6, 0x0 }, // 1293 + { PseudoVFCVT_RM_XU_F_V_MF2, VFCVT_XU_F_V, 0x7, 0x0 }, // 1294 + { PseudoVFCVT_RM_XU_F_V_MF2_MASK, VFCVT_XU_F_V, 0x7, 0x0 }, // 1295 + { PseudoVFCVT_XU_F_V_MF2, VFCVT_XU_F_V, 0x7, 0x0 }, // 1296 + { PseudoVFCVT_XU_F_V_MF2_MASK, VFCVT_XU_F_V, 0x7, 0x0 }, // 1297 + { PseudoVFCVT_RM_X_F_V_M1, VFCVT_X_F_V, 0x0, 0x0 }, // 1298 + { PseudoVFCVT_RM_X_F_V_M1_MASK, VFCVT_X_F_V, 0x0, 0x0 }, // 1299 + { PseudoVFCVT_X_F_V_M1, VFCVT_X_F_V, 0x0, 0x0 }, // 1300 + { PseudoVFCVT_X_F_V_M1_MASK, VFCVT_X_F_V, 0x0, 0x0 }, // 1301 + { PseudoVFCVT_RM_X_F_V_M2, VFCVT_X_F_V, 0x1, 0x0 }, // 1302 + { PseudoVFCVT_RM_X_F_V_M2_MASK, VFCVT_X_F_V, 0x1, 0x0 }, // 1303 + { PseudoVFCVT_X_F_V_M2, VFCVT_X_F_V, 0x1, 0x0 }, // 1304 + { PseudoVFCVT_X_F_V_M2_MASK, VFCVT_X_F_V, 0x1, 0x0 }, // 1305 + { PseudoVFCVT_RM_X_F_V_M4, VFCVT_X_F_V, 0x2, 0x0 }, // 1306 + { PseudoVFCVT_RM_X_F_V_M4_MASK, VFCVT_X_F_V, 0x2, 0x0 }, // 1307 + { PseudoVFCVT_X_F_V_M4, VFCVT_X_F_V, 0x2, 0x0 }, // 1308 + { PseudoVFCVT_X_F_V_M4_MASK, VFCVT_X_F_V, 0x2, 0x0 }, // 1309 + { PseudoVFCVT_RM_X_F_V_M8, VFCVT_X_F_V, 0x3, 0x0 }, // 1310 + { PseudoVFCVT_RM_X_F_V_M8_MASK, VFCVT_X_F_V, 0x3, 0x0 }, // 1311 + { PseudoVFCVT_X_F_V_M8, VFCVT_X_F_V, 0x3, 0x0 }, // 1312 + { PseudoVFCVT_X_F_V_M8_MASK, VFCVT_X_F_V, 0x3, 0x0 }, // 1313 + { PseudoVFCVT_RM_X_F_V_MF4, VFCVT_X_F_V, 0x6, 0x0 }, // 1314 + { PseudoVFCVT_RM_X_F_V_MF4_MASK, VFCVT_X_F_V, 0x6, 0x0 }, // 1315 + { PseudoVFCVT_X_F_V_MF4, VFCVT_X_F_V, 0x6, 0x0 }, // 1316 + { PseudoVFCVT_X_F_V_MF4_MASK, VFCVT_X_F_V, 0x6, 0x0 }, // 1317 + { PseudoVFCVT_RM_X_F_V_MF2, VFCVT_X_F_V, 0x7, 0x0 }, // 1318 + { PseudoVFCVT_RM_X_F_V_MF2_MASK, VFCVT_X_F_V, 0x7, 0x0 }, // 1319 + { PseudoVFCVT_X_F_V_MF2, VFCVT_X_F_V, 0x7, 0x0 }, // 1320 + { PseudoVFCVT_X_F_V_MF2_MASK, VFCVT_X_F_V, 0x7, 0x0 }, // 1321 + { PseudoVFDIV_VFPR16_M1_E16, VFDIV_VF, 0x0, 0x10 }, // 1322 + { PseudoVFDIV_VFPR16_M1_E16_MASK, VFDIV_VF, 0x0, 0x10 }, // 1323 + { PseudoVFDIV_VFPR32_M1_E32, VFDIV_VF, 0x0, 0x20 }, // 1324 + { PseudoVFDIV_VFPR32_M1_E32_MASK, VFDIV_VF, 0x0, 0x20 }, // 1325 + { PseudoVFDIV_VFPR64_M1_E64, VFDIV_VF, 0x0, 0x40 }, // 1326 + { PseudoVFDIV_VFPR64_M1_E64_MASK, VFDIV_VF, 0x0, 0x40 }, // 1327 + { PseudoVFDIV_VFPR16_M2_E16, VFDIV_VF, 0x1, 0x10 }, // 1328 + { PseudoVFDIV_VFPR16_M2_E16_MASK, VFDIV_VF, 0x1, 0x10 }, // 1329 + { PseudoVFDIV_VFPR32_M2_E32, VFDIV_VF, 0x1, 0x20 }, // 1330 + { PseudoVFDIV_VFPR32_M2_E32_MASK, VFDIV_VF, 0x1, 0x20 }, // 1331 + { PseudoVFDIV_VFPR64_M2_E64, VFDIV_VF, 0x1, 0x40 }, // 1332 + { PseudoVFDIV_VFPR64_M2_E64_MASK, VFDIV_VF, 0x1, 0x40 }, // 1333 + { PseudoVFDIV_VFPR16_M4_E16, VFDIV_VF, 0x2, 0x10 }, // 1334 + { PseudoVFDIV_VFPR16_M4_E16_MASK, VFDIV_VF, 0x2, 0x10 }, // 1335 + { PseudoVFDIV_VFPR32_M4_E32, VFDIV_VF, 0x2, 0x20 }, // 1336 + { PseudoVFDIV_VFPR32_M4_E32_MASK, VFDIV_VF, 0x2, 0x20 }, // 1337 + { PseudoVFDIV_VFPR64_M4_E64, VFDIV_VF, 0x2, 0x40 }, // 1338 + { PseudoVFDIV_VFPR64_M4_E64_MASK, VFDIV_VF, 0x2, 0x40 }, // 1339 + { PseudoVFDIV_VFPR16_M8_E16, VFDIV_VF, 0x3, 0x10 }, // 1340 + { PseudoVFDIV_VFPR16_M8_E16_MASK, VFDIV_VF, 0x3, 0x10 }, // 1341 + { PseudoVFDIV_VFPR32_M8_E32, VFDIV_VF, 0x3, 0x20 }, // 1342 + { PseudoVFDIV_VFPR32_M8_E32_MASK, VFDIV_VF, 0x3, 0x20 }, // 1343 + { PseudoVFDIV_VFPR64_M8_E64, VFDIV_VF, 0x3, 0x40 }, // 1344 + { PseudoVFDIV_VFPR64_M8_E64_MASK, VFDIV_VF, 0x3, 0x40 }, // 1345 + { PseudoVFDIV_VFPR16_MF4_E16, VFDIV_VF, 0x6, 0x10 }, // 1346 + { PseudoVFDIV_VFPR16_MF4_E16_MASK, VFDIV_VF, 0x6, 0x10 }, // 1347 + { PseudoVFDIV_VFPR16_MF2_E16, VFDIV_VF, 0x7, 0x10 }, // 1348 + { PseudoVFDIV_VFPR16_MF2_E16_MASK, VFDIV_VF, 0x7, 0x10 }, // 1349 + { PseudoVFDIV_VFPR32_MF2_E32, VFDIV_VF, 0x7, 0x20 }, // 1350 + { PseudoVFDIV_VFPR32_MF2_E32_MASK, VFDIV_VF, 0x7, 0x20 }, // 1351 + { PseudoVFDIV_VV_M1_E16, VFDIV_VV, 0x0, 0x10 }, // 1352 + { PseudoVFDIV_VV_M1_E16_MASK, VFDIV_VV, 0x0, 0x10 }, // 1353 + { PseudoVFDIV_VV_M1_E32, VFDIV_VV, 0x0, 0x20 }, // 1354 + { PseudoVFDIV_VV_M1_E32_MASK, VFDIV_VV, 0x0, 0x20 }, // 1355 + { PseudoVFDIV_VV_M1_E64, VFDIV_VV, 0x0, 0x40 }, // 1356 + { PseudoVFDIV_VV_M1_E64_MASK, VFDIV_VV, 0x0, 0x40 }, // 1357 + { PseudoVFDIV_VV_M2_E16, VFDIV_VV, 0x1, 0x10 }, // 1358 + { PseudoVFDIV_VV_M2_E16_MASK, VFDIV_VV, 0x1, 0x10 }, // 1359 + { PseudoVFDIV_VV_M2_E32, VFDIV_VV, 0x1, 0x20 }, // 1360 + { PseudoVFDIV_VV_M2_E32_MASK, VFDIV_VV, 0x1, 0x20 }, // 1361 + { PseudoVFDIV_VV_M2_E64, VFDIV_VV, 0x1, 0x40 }, // 1362 + { PseudoVFDIV_VV_M2_E64_MASK, VFDIV_VV, 0x1, 0x40 }, // 1363 + { PseudoVFDIV_VV_M4_E16, VFDIV_VV, 0x2, 0x10 }, // 1364 + { PseudoVFDIV_VV_M4_E16_MASK, VFDIV_VV, 0x2, 0x10 }, // 1365 + { PseudoVFDIV_VV_M4_E32, VFDIV_VV, 0x2, 0x20 }, // 1366 + { PseudoVFDIV_VV_M4_E32_MASK, VFDIV_VV, 0x2, 0x20 }, // 1367 + { PseudoVFDIV_VV_M4_E64, VFDIV_VV, 0x2, 0x40 }, // 1368 + { PseudoVFDIV_VV_M4_E64_MASK, VFDIV_VV, 0x2, 0x40 }, // 1369 + { PseudoVFDIV_VV_M8_E16, VFDIV_VV, 0x3, 0x10 }, // 1370 + { PseudoVFDIV_VV_M8_E16_MASK, VFDIV_VV, 0x3, 0x10 }, // 1371 + { PseudoVFDIV_VV_M8_E32, VFDIV_VV, 0x3, 0x20 }, // 1372 + { PseudoVFDIV_VV_M8_E32_MASK, VFDIV_VV, 0x3, 0x20 }, // 1373 + { PseudoVFDIV_VV_M8_E64, VFDIV_VV, 0x3, 0x40 }, // 1374 + { PseudoVFDIV_VV_M8_E64_MASK, VFDIV_VV, 0x3, 0x40 }, // 1375 + { PseudoVFDIV_VV_MF4_E16, VFDIV_VV, 0x6, 0x10 }, // 1376 + { PseudoVFDIV_VV_MF4_E16_MASK, VFDIV_VV, 0x6, 0x10 }, // 1377 + { PseudoVFDIV_VV_MF2_E16, VFDIV_VV, 0x7, 0x10 }, // 1378 + { PseudoVFDIV_VV_MF2_E16_MASK, VFDIV_VV, 0x7, 0x10 }, // 1379 + { PseudoVFDIV_VV_MF2_E32, VFDIV_VV, 0x7, 0x20 }, // 1380 + { PseudoVFDIV_VV_MF2_E32_MASK, VFDIV_VV, 0x7, 0x20 }, // 1381 + { PseudoVFIRST_M_B8, VFIRST_M, 0x0, 0x0 }, // 1382 + { PseudoVFIRST_M_B8_MASK, VFIRST_M, 0x0, 0x0 }, // 1383 + { PseudoVFIRST_M_B16, VFIRST_M, 0x1, 0x0 }, // 1384 + { PseudoVFIRST_M_B16_MASK, VFIRST_M, 0x1, 0x0 }, // 1385 + { PseudoVFIRST_M_B32, VFIRST_M, 0x2, 0x0 }, // 1386 + { PseudoVFIRST_M_B32_MASK, VFIRST_M, 0x2, 0x0 }, // 1387 + { PseudoVFIRST_M_B64, VFIRST_M, 0x3, 0x0 }, // 1388 + { PseudoVFIRST_M_B64_MASK, VFIRST_M, 0x3, 0x0 }, // 1389 + { PseudoVFIRST_M_B1, VFIRST_M, 0x5, 0x0 }, // 1390 + { PseudoVFIRST_M_B1_MASK, VFIRST_M, 0x5, 0x0 }, // 1391 + { PseudoVFIRST_M_B2, VFIRST_M, 0x6, 0x0 }, // 1392 + { PseudoVFIRST_M_B2_MASK, VFIRST_M, 0x6, 0x0 }, // 1393 + { PseudoVFIRST_M_B4, VFIRST_M, 0x7, 0x0 }, // 1394 + { PseudoVFIRST_M_B4_MASK, VFIRST_M, 0x7, 0x0 }, // 1395 + { PseudoVFMACC_VFPR16_M1, VFMACC_VF, 0x0, 0x0 }, // 1396 + { PseudoVFMACC_VFPR16_M1_MASK, VFMACC_VF, 0x0, 0x0 }, // 1397 + { PseudoVFMACC_VFPR32_M1, VFMACC_VF, 0x0, 0x0 }, // 1398 + { PseudoVFMACC_VFPR32_M1_MASK, VFMACC_VF, 0x0, 0x0 }, // 1399 + { PseudoVFMACC_VFPR64_M1, VFMACC_VF, 0x0, 0x0 }, // 1400 + { PseudoVFMACC_VFPR64_M1_MASK, VFMACC_VF, 0x0, 0x0 }, // 1401 + { PseudoVFMACC_VFPR16_M2, VFMACC_VF, 0x1, 0x0 }, // 1402 + { PseudoVFMACC_VFPR16_M2_MASK, VFMACC_VF, 0x1, 0x0 }, // 1403 + { PseudoVFMACC_VFPR32_M2, VFMACC_VF, 0x1, 0x0 }, // 1404 + { PseudoVFMACC_VFPR32_M2_MASK, VFMACC_VF, 0x1, 0x0 }, // 1405 + { PseudoVFMACC_VFPR64_M2, VFMACC_VF, 0x1, 0x0 }, // 1406 + { PseudoVFMACC_VFPR64_M2_MASK, VFMACC_VF, 0x1, 0x0 }, // 1407 + { PseudoVFMACC_VFPR16_M4, VFMACC_VF, 0x2, 0x0 }, // 1408 + { PseudoVFMACC_VFPR16_M4_MASK, VFMACC_VF, 0x2, 0x0 }, // 1409 + { PseudoVFMACC_VFPR32_M4, VFMACC_VF, 0x2, 0x0 }, // 1410 + { PseudoVFMACC_VFPR32_M4_MASK, VFMACC_VF, 0x2, 0x0 }, // 1411 + { PseudoVFMACC_VFPR64_M4, VFMACC_VF, 0x2, 0x0 }, // 1412 + { PseudoVFMACC_VFPR64_M4_MASK, VFMACC_VF, 0x2, 0x0 }, // 1413 + { PseudoVFMACC_VFPR16_M8, VFMACC_VF, 0x3, 0x0 }, // 1414 + { PseudoVFMACC_VFPR16_M8_MASK, VFMACC_VF, 0x3, 0x0 }, // 1415 + { PseudoVFMACC_VFPR32_M8, VFMACC_VF, 0x3, 0x0 }, // 1416 + { PseudoVFMACC_VFPR32_M8_MASK, VFMACC_VF, 0x3, 0x0 }, // 1417 + { PseudoVFMACC_VFPR64_M8, VFMACC_VF, 0x3, 0x0 }, // 1418 + { PseudoVFMACC_VFPR64_M8_MASK, VFMACC_VF, 0x3, 0x0 }, // 1419 + { PseudoVFMACC_VFPR16_MF4, VFMACC_VF, 0x6, 0x0 }, // 1420 + { PseudoVFMACC_VFPR16_MF4_MASK, VFMACC_VF, 0x6, 0x0 }, // 1421 + { PseudoVFMACC_VFPR16_MF2, VFMACC_VF, 0x7, 0x0 }, // 1422 + { PseudoVFMACC_VFPR16_MF2_MASK, VFMACC_VF, 0x7, 0x0 }, // 1423 + { PseudoVFMACC_VFPR32_MF2, VFMACC_VF, 0x7, 0x0 }, // 1424 + { PseudoVFMACC_VFPR32_MF2_MASK, VFMACC_VF, 0x7, 0x0 }, // 1425 + { PseudoVFMACC_VV_M1, VFMACC_VV, 0x0, 0x0 }, // 1426 + { PseudoVFMACC_VV_M1_MASK, VFMACC_VV, 0x0, 0x0 }, // 1427 + { PseudoVFMACC_VV_M2, VFMACC_VV, 0x1, 0x0 }, // 1428 + { PseudoVFMACC_VV_M2_MASK, VFMACC_VV, 0x1, 0x0 }, // 1429 + { PseudoVFMACC_VV_M4, VFMACC_VV, 0x2, 0x0 }, // 1430 + { PseudoVFMACC_VV_M4_MASK, VFMACC_VV, 0x2, 0x0 }, // 1431 + { PseudoVFMACC_VV_M8, VFMACC_VV, 0x3, 0x0 }, // 1432 + { PseudoVFMACC_VV_M8_MASK, VFMACC_VV, 0x3, 0x0 }, // 1433 + { PseudoVFMACC_VV_MF4, VFMACC_VV, 0x6, 0x0 }, // 1434 + { PseudoVFMACC_VV_MF4_MASK, VFMACC_VV, 0x6, 0x0 }, // 1435 + { PseudoVFMACC_VV_MF2, VFMACC_VV, 0x7, 0x0 }, // 1436 + { PseudoVFMACC_VV_MF2_MASK, VFMACC_VV, 0x7, 0x0 }, // 1437 + { PseudoVFMADD_VFPR16_M1, VFMADD_VF, 0x0, 0x0 }, // 1438 + { PseudoVFMADD_VFPR16_M1_MASK, VFMADD_VF, 0x0, 0x0 }, // 1439 + { PseudoVFMADD_VFPR32_M1, VFMADD_VF, 0x0, 0x0 }, // 1440 + { PseudoVFMADD_VFPR32_M1_MASK, VFMADD_VF, 0x0, 0x0 }, // 1441 + { PseudoVFMADD_VFPR64_M1, VFMADD_VF, 0x0, 0x0 }, // 1442 + { PseudoVFMADD_VFPR64_M1_MASK, VFMADD_VF, 0x0, 0x0 }, // 1443 + { PseudoVFMADD_VFPR16_M2, VFMADD_VF, 0x1, 0x0 }, // 1444 + { PseudoVFMADD_VFPR16_M2_MASK, VFMADD_VF, 0x1, 0x0 }, // 1445 + { PseudoVFMADD_VFPR32_M2, VFMADD_VF, 0x1, 0x0 }, // 1446 + { PseudoVFMADD_VFPR32_M2_MASK, VFMADD_VF, 0x1, 0x0 }, // 1447 + { PseudoVFMADD_VFPR64_M2, VFMADD_VF, 0x1, 0x0 }, // 1448 + { PseudoVFMADD_VFPR64_M2_MASK, VFMADD_VF, 0x1, 0x0 }, // 1449 + { PseudoVFMADD_VFPR16_M4, VFMADD_VF, 0x2, 0x0 }, // 1450 + { PseudoVFMADD_VFPR16_M4_MASK, VFMADD_VF, 0x2, 0x0 }, // 1451 + { PseudoVFMADD_VFPR32_M4, VFMADD_VF, 0x2, 0x0 }, // 1452 + { PseudoVFMADD_VFPR32_M4_MASK, VFMADD_VF, 0x2, 0x0 }, // 1453 + { PseudoVFMADD_VFPR64_M4, VFMADD_VF, 0x2, 0x0 }, // 1454 + { PseudoVFMADD_VFPR64_M4_MASK, VFMADD_VF, 0x2, 0x0 }, // 1455 + { PseudoVFMADD_VFPR16_M8, VFMADD_VF, 0x3, 0x0 }, // 1456 + { PseudoVFMADD_VFPR16_M8_MASK, VFMADD_VF, 0x3, 0x0 }, // 1457 + { PseudoVFMADD_VFPR32_M8, VFMADD_VF, 0x3, 0x0 }, // 1458 + { PseudoVFMADD_VFPR32_M8_MASK, VFMADD_VF, 0x3, 0x0 }, // 1459 + { PseudoVFMADD_VFPR64_M8, VFMADD_VF, 0x3, 0x0 }, // 1460 + { PseudoVFMADD_VFPR64_M8_MASK, VFMADD_VF, 0x3, 0x0 }, // 1461 + { PseudoVFMADD_VFPR16_MF4, VFMADD_VF, 0x6, 0x0 }, // 1462 + { PseudoVFMADD_VFPR16_MF4_MASK, VFMADD_VF, 0x6, 0x0 }, // 1463 + { PseudoVFMADD_VFPR16_MF2, VFMADD_VF, 0x7, 0x0 }, // 1464 + { PseudoVFMADD_VFPR16_MF2_MASK, VFMADD_VF, 0x7, 0x0 }, // 1465 + { PseudoVFMADD_VFPR32_MF2, VFMADD_VF, 0x7, 0x0 }, // 1466 + { PseudoVFMADD_VFPR32_MF2_MASK, VFMADD_VF, 0x7, 0x0 }, // 1467 + { PseudoVFMADD_VV_M1, VFMADD_VV, 0x0, 0x0 }, // 1468 + { PseudoVFMADD_VV_M1_MASK, VFMADD_VV, 0x0, 0x0 }, // 1469 + { PseudoVFMADD_VV_M2, VFMADD_VV, 0x1, 0x0 }, // 1470 + { PseudoVFMADD_VV_M2_MASK, VFMADD_VV, 0x1, 0x0 }, // 1471 + { PseudoVFMADD_VV_M4, VFMADD_VV, 0x2, 0x0 }, // 1472 + { PseudoVFMADD_VV_M4_MASK, VFMADD_VV, 0x2, 0x0 }, // 1473 + { PseudoVFMADD_VV_M8, VFMADD_VV, 0x3, 0x0 }, // 1474 + { PseudoVFMADD_VV_M8_MASK, VFMADD_VV, 0x3, 0x0 }, // 1475 + { PseudoVFMADD_VV_MF4, VFMADD_VV, 0x6, 0x0 }, // 1476 + { PseudoVFMADD_VV_MF4_MASK, VFMADD_VV, 0x6, 0x0 }, // 1477 + { PseudoVFMADD_VV_MF2, VFMADD_VV, 0x7, 0x0 }, // 1478 + { PseudoVFMADD_VV_MF2_MASK, VFMADD_VV, 0x7, 0x0 }, // 1479 + { PseudoVFMAX_VFPR16_M1, VFMAX_VF, 0x0, 0x0 }, // 1480 + { PseudoVFMAX_VFPR16_M1_MASK, VFMAX_VF, 0x0, 0x0 }, // 1481 + { PseudoVFMAX_VFPR32_M1, VFMAX_VF, 0x0, 0x0 }, // 1482 + { PseudoVFMAX_VFPR32_M1_MASK, VFMAX_VF, 0x0, 0x0 }, // 1483 + { PseudoVFMAX_VFPR64_M1, VFMAX_VF, 0x0, 0x0 }, // 1484 + { PseudoVFMAX_VFPR64_M1_MASK, VFMAX_VF, 0x0, 0x0 }, // 1485 + { PseudoVFMAX_VFPR16_M2, VFMAX_VF, 0x1, 0x0 }, // 1486 + { PseudoVFMAX_VFPR16_M2_MASK, VFMAX_VF, 0x1, 0x0 }, // 1487 + { PseudoVFMAX_VFPR32_M2, VFMAX_VF, 0x1, 0x0 }, // 1488 + { PseudoVFMAX_VFPR32_M2_MASK, VFMAX_VF, 0x1, 0x0 }, // 1489 + { PseudoVFMAX_VFPR64_M2, VFMAX_VF, 0x1, 0x0 }, // 1490 + { PseudoVFMAX_VFPR64_M2_MASK, VFMAX_VF, 0x1, 0x0 }, // 1491 + { PseudoVFMAX_VFPR16_M4, VFMAX_VF, 0x2, 0x0 }, // 1492 + { PseudoVFMAX_VFPR16_M4_MASK, VFMAX_VF, 0x2, 0x0 }, // 1493 + { PseudoVFMAX_VFPR32_M4, VFMAX_VF, 0x2, 0x0 }, // 1494 + { PseudoVFMAX_VFPR32_M4_MASK, VFMAX_VF, 0x2, 0x0 }, // 1495 + { PseudoVFMAX_VFPR64_M4, VFMAX_VF, 0x2, 0x0 }, // 1496 + { PseudoVFMAX_VFPR64_M4_MASK, VFMAX_VF, 0x2, 0x0 }, // 1497 + { PseudoVFMAX_VFPR16_M8, VFMAX_VF, 0x3, 0x0 }, // 1498 + { PseudoVFMAX_VFPR16_M8_MASK, VFMAX_VF, 0x3, 0x0 }, // 1499 + { PseudoVFMAX_VFPR32_M8, VFMAX_VF, 0x3, 0x0 }, // 1500 + { PseudoVFMAX_VFPR32_M8_MASK, VFMAX_VF, 0x3, 0x0 }, // 1501 + { PseudoVFMAX_VFPR64_M8, VFMAX_VF, 0x3, 0x0 }, // 1502 + { PseudoVFMAX_VFPR64_M8_MASK, VFMAX_VF, 0x3, 0x0 }, // 1503 + { PseudoVFMAX_VFPR16_MF4, VFMAX_VF, 0x6, 0x0 }, // 1504 + { PseudoVFMAX_VFPR16_MF4_MASK, VFMAX_VF, 0x6, 0x0 }, // 1505 + { PseudoVFMAX_VFPR16_MF2, VFMAX_VF, 0x7, 0x0 }, // 1506 + { PseudoVFMAX_VFPR16_MF2_MASK, VFMAX_VF, 0x7, 0x0 }, // 1507 + { PseudoVFMAX_VFPR32_MF2, VFMAX_VF, 0x7, 0x0 }, // 1508 + { PseudoVFMAX_VFPR32_MF2_MASK, VFMAX_VF, 0x7, 0x0 }, // 1509 + { PseudoVFMAX_VV_M1, VFMAX_VV, 0x0, 0x0 }, // 1510 + { PseudoVFMAX_VV_M1_MASK, VFMAX_VV, 0x0, 0x0 }, // 1511 + { PseudoVFMAX_VV_M2, VFMAX_VV, 0x1, 0x0 }, // 1512 + { PseudoVFMAX_VV_M2_MASK, VFMAX_VV, 0x1, 0x0 }, // 1513 + { PseudoVFMAX_VV_M4, VFMAX_VV, 0x2, 0x0 }, // 1514 + { PseudoVFMAX_VV_M4_MASK, VFMAX_VV, 0x2, 0x0 }, // 1515 + { PseudoVFMAX_VV_M8, VFMAX_VV, 0x3, 0x0 }, // 1516 + { PseudoVFMAX_VV_M8_MASK, VFMAX_VV, 0x3, 0x0 }, // 1517 + { PseudoVFMAX_VV_MF4, VFMAX_VV, 0x6, 0x0 }, // 1518 + { PseudoVFMAX_VV_MF4_MASK, VFMAX_VV, 0x6, 0x0 }, // 1519 + { PseudoVFMAX_VV_MF2, VFMAX_VV, 0x7, 0x0 }, // 1520 + { PseudoVFMAX_VV_MF2_MASK, VFMAX_VV, 0x7, 0x0 }, // 1521 + { PseudoVFMERGE_VFPR16M_M1, VFMERGE_VFM, 0x0, 0x0 }, // 1522 + { PseudoVFMERGE_VFPR32M_M1, VFMERGE_VFM, 0x0, 0x0 }, // 1523 + { PseudoVFMERGE_VFPR64M_M1, VFMERGE_VFM, 0x0, 0x0 }, // 1524 + { PseudoVFMERGE_VFPR16M_M2, VFMERGE_VFM, 0x1, 0x0 }, // 1525 + { PseudoVFMERGE_VFPR32M_M2, VFMERGE_VFM, 0x1, 0x0 }, // 1526 + { PseudoVFMERGE_VFPR64M_M2, VFMERGE_VFM, 0x1, 0x0 }, // 1527 + { PseudoVFMERGE_VFPR16M_M4, VFMERGE_VFM, 0x2, 0x0 }, // 1528 + { PseudoVFMERGE_VFPR32M_M4, VFMERGE_VFM, 0x2, 0x0 }, // 1529 + { PseudoVFMERGE_VFPR64M_M4, VFMERGE_VFM, 0x2, 0x0 }, // 1530 + { PseudoVFMERGE_VFPR16M_M8, VFMERGE_VFM, 0x3, 0x0 }, // 1531 + { PseudoVFMERGE_VFPR32M_M8, VFMERGE_VFM, 0x3, 0x0 }, // 1532 + { PseudoVFMERGE_VFPR64M_M8, VFMERGE_VFM, 0x3, 0x0 }, // 1533 + { PseudoVFMERGE_VFPR16M_MF4, VFMERGE_VFM, 0x6, 0x0 }, // 1534 + { PseudoVFMERGE_VFPR16M_MF2, VFMERGE_VFM, 0x7, 0x0 }, // 1535 + { PseudoVFMERGE_VFPR32M_MF2, VFMERGE_VFM, 0x7, 0x0 }, // 1536 + { PseudoVFMIN_VFPR16_M1, VFMIN_VF, 0x0, 0x0 }, // 1537 + { PseudoVFMIN_VFPR16_M1_MASK, VFMIN_VF, 0x0, 0x0 }, // 1538 + { PseudoVFMIN_VFPR32_M1, VFMIN_VF, 0x0, 0x0 }, // 1539 + { PseudoVFMIN_VFPR32_M1_MASK, VFMIN_VF, 0x0, 0x0 }, // 1540 + { PseudoVFMIN_VFPR64_M1, VFMIN_VF, 0x0, 0x0 }, // 1541 + { PseudoVFMIN_VFPR64_M1_MASK, VFMIN_VF, 0x0, 0x0 }, // 1542 + { PseudoVFMIN_VFPR16_M2, VFMIN_VF, 0x1, 0x0 }, // 1543 + { PseudoVFMIN_VFPR16_M2_MASK, VFMIN_VF, 0x1, 0x0 }, // 1544 + { PseudoVFMIN_VFPR32_M2, VFMIN_VF, 0x1, 0x0 }, // 1545 + { PseudoVFMIN_VFPR32_M2_MASK, VFMIN_VF, 0x1, 0x0 }, // 1546 + { PseudoVFMIN_VFPR64_M2, VFMIN_VF, 0x1, 0x0 }, // 1547 + { PseudoVFMIN_VFPR64_M2_MASK, VFMIN_VF, 0x1, 0x0 }, // 1548 + { PseudoVFMIN_VFPR16_M4, VFMIN_VF, 0x2, 0x0 }, // 1549 + { PseudoVFMIN_VFPR16_M4_MASK, VFMIN_VF, 0x2, 0x0 }, // 1550 + { PseudoVFMIN_VFPR32_M4, VFMIN_VF, 0x2, 0x0 }, // 1551 + { PseudoVFMIN_VFPR32_M4_MASK, VFMIN_VF, 0x2, 0x0 }, // 1552 + { PseudoVFMIN_VFPR64_M4, VFMIN_VF, 0x2, 0x0 }, // 1553 + { PseudoVFMIN_VFPR64_M4_MASK, VFMIN_VF, 0x2, 0x0 }, // 1554 + { PseudoVFMIN_VFPR16_M8, VFMIN_VF, 0x3, 0x0 }, // 1555 + { PseudoVFMIN_VFPR16_M8_MASK, VFMIN_VF, 0x3, 0x0 }, // 1556 + { PseudoVFMIN_VFPR32_M8, VFMIN_VF, 0x3, 0x0 }, // 1557 + { PseudoVFMIN_VFPR32_M8_MASK, VFMIN_VF, 0x3, 0x0 }, // 1558 + { PseudoVFMIN_VFPR64_M8, VFMIN_VF, 0x3, 0x0 }, // 1559 + { PseudoVFMIN_VFPR64_M8_MASK, VFMIN_VF, 0x3, 0x0 }, // 1560 + { PseudoVFMIN_VFPR16_MF4, VFMIN_VF, 0x6, 0x0 }, // 1561 + { PseudoVFMIN_VFPR16_MF4_MASK, VFMIN_VF, 0x6, 0x0 }, // 1562 + { PseudoVFMIN_VFPR16_MF2, VFMIN_VF, 0x7, 0x0 }, // 1563 + { PseudoVFMIN_VFPR16_MF2_MASK, VFMIN_VF, 0x7, 0x0 }, // 1564 + { PseudoVFMIN_VFPR32_MF2, VFMIN_VF, 0x7, 0x0 }, // 1565 + { PseudoVFMIN_VFPR32_MF2_MASK, VFMIN_VF, 0x7, 0x0 }, // 1566 + { PseudoVFMIN_VV_M1, VFMIN_VV, 0x0, 0x0 }, // 1567 + { PseudoVFMIN_VV_M1_MASK, VFMIN_VV, 0x0, 0x0 }, // 1568 + { PseudoVFMIN_VV_M2, VFMIN_VV, 0x1, 0x0 }, // 1569 + { PseudoVFMIN_VV_M2_MASK, VFMIN_VV, 0x1, 0x0 }, // 1570 + { PseudoVFMIN_VV_M4, VFMIN_VV, 0x2, 0x0 }, // 1571 + { PseudoVFMIN_VV_M4_MASK, VFMIN_VV, 0x2, 0x0 }, // 1572 + { PseudoVFMIN_VV_M8, VFMIN_VV, 0x3, 0x0 }, // 1573 + { PseudoVFMIN_VV_M8_MASK, VFMIN_VV, 0x3, 0x0 }, // 1574 + { PseudoVFMIN_VV_MF4, VFMIN_VV, 0x6, 0x0 }, // 1575 + { PseudoVFMIN_VV_MF4_MASK, VFMIN_VV, 0x6, 0x0 }, // 1576 + { PseudoVFMIN_VV_MF2, VFMIN_VV, 0x7, 0x0 }, // 1577 + { PseudoVFMIN_VV_MF2_MASK, VFMIN_VV, 0x7, 0x0 }, // 1578 + { PseudoVFMSAC_VFPR16_M1, VFMSAC_VF, 0x0, 0x0 }, // 1579 + { PseudoVFMSAC_VFPR16_M1_MASK, VFMSAC_VF, 0x0, 0x0 }, // 1580 + { PseudoVFMSAC_VFPR32_M1, VFMSAC_VF, 0x0, 0x0 }, // 1581 + { PseudoVFMSAC_VFPR32_M1_MASK, VFMSAC_VF, 0x0, 0x0 }, // 1582 + { PseudoVFMSAC_VFPR64_M1, VFMSAC_VF, 0x0, 0x0 }, // 1583 + { PseudoVFMSAC_VFPR64_M1_MASK, VFMSAC_VF, 0x0, 0x0 }, // 1584 + { PseudoVFMSAC_VFPR16_M2, VFMSAC_VF, 0x1, 0x0 }, // 1585 + { PseudoVFMSAC_VFPR16_M2_MASK, VFMSAC_VF, 0x1, 0x0 }, // 1586 + { PseudoVFMSAC_VFPR32_M2, VFMSAC_VF, 0x1, 0x0 }, // 1587 + { PseudoVFMSAC_VFPR32_M2_MASK, VFMSAC_VF, 0x1, 0x0 }, // 1588 + { PseudoVFMSAC_VFPR64_M2, VFMSAC_VF, 0x1, 0x0 }, // 1589 + { PseudoVFMSAC_VFPR64_M2_MASK, VFMSAC_VF, 0x1, 0x0 }, // 1590 + { PseudoVFMSAC_VFPR16_M4, VFMSAC_VF, 0x2, 0x0 }, // 1591 + { PseudoVFMSAC_VFPR16_M4_MASK, VFMSAC_VF, 0x2, 0x0 }, // 1592 + { PseudoVFMSAC_VFPR32_M4, VFMSAC_VF, 0x2, 0x0 }, // 1593 + { PseudoVFMSAC_VFPR32_M4_MASK, VFMSAC_VF, 0x2, 0x0 }, // 1594 + { PseudoVFMSAC_VFPR64_M4, VFMSAC_VF, 0x2, 0x0 }, // 1595 + { PseudoVFMSAC_VFPR64_M4_MASK, VFMSAC_VF, 0x2, 0x0 }, // 1596 + { PseudoVFMSAC_VFPR16_M8, VFMSAC_VF, 0x3, 0x0 }, // 1597 + { PseudoVFMSAC_VFPR16_M8_MASK, VFMSAC_VF, 0x3, 0x0 }, // 1598 + { PseudoVFMSAC_VFPR32_M8, VFMSAC_VF, 0x3, 0x0 }, // 1599 + { PseudoVFMSAC_VFPR32_M8_MASK, VFMSAC_VF, 0x3, 0x0 }, // 1600 + { PseudoVFMSAC_VFPR64_M8, VFMSAC_VF, 0x3, 0x0 }, // 1601 + { PseudoVFMSAC_VFPR64_M8_MASK, VFMSAC_VF, 0x3, 0x0 }, // 1602 + { PseudoVFMSAC_VFPR16_MF4, VFMSAC_VF, 0x6, 0x0 }, // 1603 + { PseudoVFMSAC_VFPR16_MF4_MASK, VFMSAC_VF, 0x6, 0x0 }, // 1604 + { PseudoVFMSAC_VFPR16_MF2, VFMSAC_VF, 0x7, 0x0 }, // 1605 + { PseudoVFMSAC_VFPR16_MF2_MASK, VFMSAC_VF, 0x7, 0x0 }, // 1606 + { PseudoVFMSAC_VFPR32_MF2, VFMSAC_VF, 0x7, 0x0 }, // 1607 + { PseudoVFMSAC_VFPR32_MF2_MASK, VFMSAC_VF, 0x7, 0x0 }, // 1608 + { PseudoVFMSAC_VV_M1, VFMSAC_VV, 0x0, 0x0 }, // 1609 + { PseudoVFMSAC_VV_M1_MASK, VFMSAC_VV, 0x0, 0x0 }, // 1610 + { PseudoVFMSAC_VV_M2, VFMSAC_VV, 0x1, 0x0 }, // 1611 + { PseudoVFMSAC_VV_M2_MASK, VFMSAC_VV, 0x1, 0x0 }, // 1612 + { PseudoVFMSAC_VV_M4, VFMSAC_VV, 0x2, 0x0 }, // 1613 + { PseudoVFMSAC_VV_M4_MASK, VFMSAC_VV, 0x2, 0x0 }, // 1614 + { PseudoVFMSAC_VV_M8, VFMSAC_VV, 0x3, 0x0 }, // 1615 + { PseudoVFMSAC_VV_M8_MASK, VFMSAC_VV, 0x3, 0x0 }, // 1616 + { PseudoVFMSAC_VV_MF4, VFMSAC_VV, 0x6, 0x0 }, // 1617 + { PseudoVFMSAC_VV_MF4_MASK, VFMSAC_VV, 0x6, 0x0 }, // 1618 + { PseudoVFMSAC_VV_MF2, VFMSAC_VV, 0x7, 0x0 }, // 1619 + { PseudoVFMSAC_VV_MF2_MASK, VFMSAC_VV, 0x7, 0x0 }, // 1620 + { PseudoVFMSUB_VFPR16_M1, VFMSUB_VF, 0x0, 0x0 }, // 1621 + { PseudoVFMSUB_VFPR16_M1_MASK, VFMSUB_VF, 0x0, 0x0 }, // 1622 + { PseudoVFMSUB_VFPR32_M1, VFMSUB_VF, 0x0, 0x0 }, // 1623 + { PseudoVFMSUB_VFPR32_M1_MASK, VFMSUB_VF, 0x0, 0x0 }, // 1624 + { PseudoVFMSUB_VFPR64_M1, VFMSUB_VF, 0x0, 0x0 }, // 1625 + { PseudoVFMSUB_VFPR64_M1_MASK, VFMSUB_VF, 0x0, 0x0 }, // 1626 + { PseudoVFMSUB_VFPR16_M2, VFMSUB_VF, 0x1, 0x0 }, // 1627 + { PseudoVFMSUB_VFPR16_M2_MASK, VFMSUB_VF, 0x1, 0x0 }, // 1628 + { PseudoVFMSUB_VFPR32_M2, VFMSUB_VF, 0x1, 0x0 }, // 1629 + { PseudoVFMSUB_VFPR32_M2_MASK, VFMSUB_VF, 0x1, 0x0 }, // 1630 + { PseudoVFMSUB_VFPR64_M2, VFMSUB_VF, 0x1, 0x0 }, // 1631 + { PseudoVFMSUB_VFPR64_M2_MASK, VFMSUB_VF, 0x1, 0x0 }, // 1632 + { PseudoVFMSUB_VFPR16_M4, VFMSUB_VF, 0x2, 0x0 }, // 1633 + { PseudoVFMSUB_VFPR16_M4_MASK, VFMSUB_VF, 0x2, 0x0 }, // 1634 + { PseudoVFMSUB_VFPR32_M4, VFMSUB_VF, 0x2, 0x0 }, // 1635 + { PseudoVFMSUB_VFPR32_M4_MASK, VFMSUB_VF, 0x2, 0x0 }, // 1636 + { PseudoVFMSUB_VFPR64_M4, VFMSUB_VF, 0x2, 0x0 }, // 1637 + { PseudoVFMSUB_VFPR64_M4_MASK, VFMSUB_VF, 0x2, 0x0 }, // 1638 + { PseudoVFMSUB_VFPR16_M8, VFMSUB_VF, 0x3, 0x0 }, // 1639 + { PseudoVFMSUB_VFPR16_M8_MASK, VFMSUB_VF, 0x3, 0x0 }, // 1640 + { PseudoVFMSUB_VFPR32_M8, VFMSUB_VF, 0x3, 0x0 }, // 1641 + { PseudoVFMSUB_VFPR32_M8_MASK, VFMSUB_VF, 0x3, 0x0 }, // 1642 + { PseudoVFMSUB_VFPR64_M8, VFMSUB_VF, 0x3, 0x0 }, // 1643 + { PseudoVFMSUB_VFPR64_M8_MASK, VFMSUB_VF, 0x3, 0x0 }, // 1644 + { PseudoVFMSUB_VFPR16_MF4, VFMSUB_VF, 0x6, 0x0 }, // 1645 + { PseudoVFMSUB_VFPR16_MF4_MASK, VFMSUB_VF, 0x6, 0x0 }, // 1646 + { PseudoVFMSUB_VFPR16_MF2, VFMSUB_VF, 0x7, 0x0 }, // 1647 + { PseudoVFMSUB_VFPR16_MF2_MASK, VFMSUB_VF, 0x7, 0x0 }, // 1648 + { PseudoVFMSUB_VFPR32_MF2, VFMSUB_VF, 0x7, 0x0 }, // 1649 + { PseudoVFMSUB_VFPR32_MF2_MASK, VFMSUB_VF, 0x7, 0x0 }, // 1650 + { PseudoVFMSUB_VV_M1, VFMSUB_VV, 0x0, 0x0 }, // 1651 + { PseudoVFMSUB_VV_M1_MASK, VFMSUB_VV, 0x0, 0x0 }, // 1652 + { PseudoVFMSUB_VV_M2, VFMSUB_VV, 0x1, 0x0 }, // 1653 + { PseudoVFMSUB_VV_M2_MASK, VFMSUB_VV, 0x1, 0x0 }, // 1654 + { PseudoVFMSUB_VV_M4, VFMSUB_VV, 0x2, 0x0 }, // 1655 + { PseudoVFMSUB_VV_M4_MASK, VFMSUB_VV, 0x2, 0x0 }, // 1656 + { PseudoVFMSUB_VV_M8, VFMSUB_VV, 0x3, 0x0 }, // 1657 + { PseudoVFMSUB_VV_M8_MASK, VFMSUB_VV, 0x3, 0x0 }, // 1658 + { PseudoVFMSUB_VV_MF4, VFMSUB_VV, 0x6, 0x0 }, // 1659 + { PseudoVFMSUB_VV_MF4_MASK, VFMSUB_VV, 0x6, 0x0 }, // 1660 + { PseudoVFMSUB_VV_MF2, VFMSUB_VV, 0x7, 0x0 }, // 1661 + { PseudoVFMSUB_VV_MF2_MASK, VFMSUB_VV, 0x7, 0x0 }, // 1662 + { PseudoVFMUL_VFPR16_M1, VFMUL_VF, 0x0, 0x0 }, // 1663 + { PseudoVFMUL_VFPR16_M1_MASK, VFMUL_VF, 0x0, 0x0 }, // 1664 + { PseudoVFMUL_VFPR32_M1, VFMUL_VF, 0x0, 0x0 }, // 1665 + { PseudoVFMUL_VFPR32_M1_MASK, VFMUL_VF, 0x0, 0x0 }, // 1666 + { PseudoVFMUL_VFPR64_M1, VFMUL_VF, 0x0, 0x0 }, // 1667 + { PseudoVFMUL_VFPR64_M1_MASK, VFMUL_VF, 0x0, 0x0 }, // 1668 + { PseudoVFMUL_VFPR16_M2, VFMUL_VF, 0x1, 0x0 }, // 1669 + { PseudoVFMUL_VFPR16_M2_MASK, VFMUL_VF, 0x1, 0x0 }, // 1670 + { PseudoVFMUL_VFPR32_M2, VFMUL_VF, 0x1, 0x0 }, // 1671 + { PseudoVFMUL_VFPR32_M2_MASK, VFMUL_VF, 0x1, 0x0 }, // 1672 + { PseudoVFMUL_VFPR64_M2, VFMUL_VF, 0x1, 0x0 }, // 1673 + { PseudoVFMUL_VFPR64_M2_MASK, VFMUL_VF, 0x1, 0x0 }, // 1674 + { PseudoVFMUL_VFPR16_M4, VFMUL_VF, 0x2, 0x0 }, // 1675 + { PseudoVFMUL_VFPR16_M4_MASK, VFMUL_VF, 0x2, 0x0 }, // 1676 + { PseudoVFMUL_VFPR32_M4, VFMUL_VF, 0x2, 0x0 }, // 1677 + { PseudoVFMUL_VFPR32_M4_MASK, VFMUL_VF, 0x2, 0x0 }, // 1678 + { PseudoVFMUL_VFPR64_M4, VFMUL_VF, 0x2, 0x0 }, // 1679 + { PseudoVFMUL_VFPR64_M4_MASK, VFMUL_VF, 0x2, 0x0 }, // 1680 + { PseudoVFMUL_VFPR16_M8, VFMUL_VF, 0x3, 0x0 }, // 1681 + { PseudoVFMUL_VFPR16_M8_MASK, VFMUL_VF, 0x3, 0x0 }, // 1682 + { PseudoVFMUL_VFPR32_M8, VFMUL_VF, 0x3, 0x0 }, // 1683 + { PseudoVFMUL_VFPR32_M8_MASK, VFMUL_VF, 0x3, 0x0 }, // 1684 + { PseudoVFMUL_VFPR64_M8, VFMUL_VF, 0x3, 0x0 }, // 1685 + { PseudoVFMUL_VFPR64_M8_MASK, VFMUL_VF, 0x3, 0x0 }, // 1686 + { PseudoVFMUL_VFPR16_MF4, VFMUL_VF, 0x6, 0x0 }, // 1687 + { PseudoVFMUL_VFPR16_MF4_MASK, VFMUL_VF, 0x6, 0x0 }, // 1688 + { PseudoVFMUL_VFPR16_MF2, VFMUL_VF, 0x7, 0x0 }, // 1689 + { PseudoVFMUL_VFPR16_MF2_MASK, VFMUL_VF, 0x7, 0x0 }, // 1690 + { PseudoVFMUL_VFPR32_MF2, VFMUL_VF, 0x7, 0x0 }, // 1691 + { PseudoVFMUL_VFPR32_MF2_MASK, VFMUL_VF, 0x7, 0x0 }, // 1692 + { PseudoVFMUL_VV_M1, VFMUL_VV, 0x0, 0x0 }, // 1693 + { PseudoVFMUL_VV_M1_MASK, VFMUL_VV, 0x0, 0x0 }, // 1694 + { PseudoVFMUL_VV_M2, VFMUL_VV, 0x1, 0x0 }, // 1695 + { PseudoVFMUL_VV_M2_MASK, VFMUL_VV, 0x1, 0x0 }, // 1696 + { PseudoVFMUL_VV_M4, VFMUL_VV, 0x2, 0x0 }, // 1697 + { PseudoVFMUL_VV_M4_MASK, VFMUL_VV, 0x2, 0x0 }, // 1698 + { PseudoVFMUL_VV_M8, VFMUL_VV, 0x3, 0x0 }, // 1699 + { PseudoVFMUL_VV_M8_MASK, VFMUL_VV, 0x3, 0x0 }, // 1700 + { PseudoVFMUL_VV_MF4, VFMUL_VV, 0x6, 0x0 }, // 1701 + { PseudoVFMUL_VV_MF4_MASK, VFMUL_VV, 0x6, 0x0 }, // 1702 + { PseudoVFMUL_VV_MF2, VFMUL_VV, 0x7, 0x0 }, // 1703 + { PseudoVFMUL_VV_MF2_MASK, VFMUL_VV, 0x7, 0x0 }, // 1704 + { PseudoVFMV_FPR16_S_M1, VFMV_F_S, 0x0, 0x0 }, // 1705 + { PseudoVFMV_FPR32_S_M1, VFMV_F_S, 0x0, 0x0 }, // 1706 + { PseudoVFMV_FPR64_S_M1, VFMV_F_S, 0x0, 0x0 }, // 1707 + { PseudoVFMV_FPR16_S_M2, VFMV_F_S, 0x1, 0x0 }, // 1708 + { PseudoVFMV_FPR32_S_M2, VFMV_F_S, 0x1, 0x0 }, // 1709 + { PseudoVFMV_FPR64_S_M2, VFMV_F_S, 0x1, 0x0 }, // 1710 + { PseudoVFMV_FPR16_S_M4, VFMV_F_S, 0x2, 0x0 }, // 1711 + { PseudoVFMV_FPR32_S_M4, VFMV_F_S, 0x2, 0x0 }, // 1712 + { PseudoVFMV_FPR64_S_M4, VFMV_F_S, 0x2, 0x0 }, // 1713 + { PseudoVFMV_FPR16_S_M8, VFMV_F_S, 0x3, 0x0 }, // 1714 + { PseudoVFMV_FPR32_S_M8, VFMV_F_S, 0x3, 0x0 }, // 1715 + { PseudoVFMV_FPR64_S_M8, VFMV_F_S, 0x3, 0x0 }, // 1716 + { PseudoVFMV_FPR16_S_MF4, VFMV_F_S, 0x6, 0x0 }, // 1717 + { PseudoVFMV_FPR16_S_MF2, VFMV_F_S, 0x7, 0x0 }, // 1718 + { PseudoVFMV_FPR32_S_MF2, VFMV_F_S, 0x7, 0x0 }, // 1719 + { PseudoVFMV_S_FPR16_M1, VFMV_S_F, 0x0, 0x0 }, // 1720 + { PseudoVFMV_S_FPR32_M1, VFMV_S_F, 0x0, 0x0 }, // 1721 + { PseudoVFMV_S_FPR64_M1, VFMV_S_F, 0x0, 0x0 }, // 1722 + { PseudoVFMV_S_FPR16_M2, VFMV_S_F, 0x1, 0x0 }, // 1723 + { PseudoVFMV_S_FPR32_M2, VFMV_S_F, 0x1, 0x0 }, // 1724 + { PseudoVFMV_S_FPR64_M2, VFMV_S_F, 0x1, 0x0 }, // 1725 + { PseudoVFMV_S_FPR16_M4, VFMV_S_F, 0x2, 0x0 }, // 1726 + { PseudoVFMV_S_FPR32_M4, VFMV_S_F, 0x2, 0x0 }, // 1727 + { PseudoVFMV_S_FPR64_M4, VFMV_S_F, 0x2, 0x0 }, // 1728 + { PseudoVFMV_S_FPR16_M8, VFMV_S_F, 0x3, 0x0 }, // 1729 + { PseudoVFMV_S_FPR32_M8, VFMV_S_F, 0x3, 0x0 }, // 1730 + { PseudoVFMV_S_FPR64_M8, VFMV_S_F, 0x3, 0x0 }, // 1731 + { PseudoVFMV_S_FPR16_MF4, VFMV_S_F, 0x6, 0x0 }, // 1732 + { PseudoVFMV_S_FPR16_MF2, VFMV_S_F, 0x7, 0x0 }, // 1733 + { PseudoVFMV_S_FPR32_MF2, VFMV_S_F, 0x7, 0x0 }, // 1734 + { PseudoVFMV_V_FPR16_M1, VFMV_V_F, 0x0, 0x0 }, // 1735 + { PseudoVFMV_V_FPR32_M1, VFMV_V_F, 0x0, 0x0 }, // 1736 + { PseudoVFMV_V_FPR64_M1, VFMV_V_F, 0x0, 0x0 }, // 1737 + { PseudoVFMV_V_FPR16_M2, VFMV_V_F, 0x1, 0x0 }, // 1738 + { PseudoVFMV_V_FPR32_M2, VFMV_V_F, 0x1, 0x0 }, // 1739 + { PseudoVFMV_V_FPR64_M2, VFMV_V_F, 0x1, 0x0 }, // 1740 + { PseudoVFMV_V_FPR16_M4, VFMV_V_F, 0x2, 0x0 }, // 1741 + { PseudoVFMV_V_FPR32_M4, VFMV_V_F, 0x2, 0x0 }, // 1742 + { PseudoVFMV_V_FPR64_M4, VFMV_V_F, 0x2, 0x0 }, // 1743 + { PseudoVFMV_V_FPR16_M8, VFMV_V_F, 0x3, 0x0 }, // 1744 + { PseudoVFMV_V_FPR32_M8, VFMV_V_F, 0x3, 0x0 }, // 1745 + { PseudoVFMV_V_FPR64_M8, VFMV_V_F, 0x3, 0x0 }, // 1746 + { PseudoVFMV_V_FPR16_MF4, VFMV_V_F, 0x6, 0x0 }, // 1747 + { PseudoVFMV_V_FPR16_MF2, VFMV_V_F, 0x7, 0x0 }, // 1748 + { PseudoVFMV_V_FPR32_MF2, VFMV_V_F, 0x7, 0x0 }, // 1749 + { PseudoVFNCVTBF16_F_F_W_M1, VFNCVTBF16_F_F_W, 0x0, 0x0 }, // 1750 + { PseudoVFNCVTBF16_F_F_W_M1_MASK, VFNCVTBF16_F_F_W, 0x0, 0x0 }, // 1751 + { PseudoVFNCVTBF16_F_F_W_M2, VFNCVTBF16_F_F_W, 0x1, 0x0 }, // 1752 + { PseudoVFNCVTBF16_F_F_W_M2_MASK, VFNCVTBF16_F_F_W, 0x1, 0x0 }, // 1753 + { PseudoVFNCVTBF16_F_F_W_M4, VFNCVTBF16_F_F_W, 0x2, 0x0 }, // 1754 + { PseudoVFNCVTBF16_F_F_W_M4_MASK, VFNCVTBF16_F_F_W, 0x2, 0x0 }, // 1755 + { PseudoVFNCVTBF16_F_F_W_MF4, VFNCVTBF16_F_F_W, 0x6, 0x0 }, // 1756 + { PseudoVFNCVTBF16_F_F_W_MF4_MASK, VFNCVTBF16_F_F_W, 0x6, 0x0 }, // 1757 + { PseudoVFNCVTBF16_F_F_W_MF2, VFNCVTBF16_F_F_W, 0x7, 0x0 }, // 1758 + { PseudoVFNCVTBF16_F_F_W_MF2_MASK, VFNCVTBF16_F_F_W, 0x7, 0x0 }, // 1759 + { PseudoVFNCVT_F_F_W_M1, VFNCVT_F_F_W, 0x0, 0x0 }, // 1760 + { PseudoVFNCVT_F_F_W_M1_MASK, VFNCVT_F_F_W, 0x0, 0x0 }, // 1761 + { PseudoVFNCVT_F_F_W_M2, VFNCVT_F_F_W, 0x1, 0x0 }, // 1762 + { PseudoVFNCVT_F_F_W_M2_MASK, VFNCVT_F_F_W, 0x1, 0x0 }, // 1763 + { PseudoVFNCVT_F_F_W_M4, VFNCVT_F_F_W, 0x2, 0x0 }, // 1764 + { PseudoVFNCVT_F_F_W_M4_MASK, VFNCVT_F_F_W, 0x2, 0x0 }, // 1765 + { PseudoVFNCVT_F_F_W_MF4, VFNCVT_F_F_W, 0x6, 0x0 }, // 1766 + { PseudoVFNCVT_F_F_W_MF4_MASK, VFNCVT_F_F_W, 0x6, 0x0 }, // 1767 + { PseudoVFNCVT_F_F_W_MF2, VFNCVT_F_F_W, 0x7, 0x0 }, // 1768 + { PseudoVFNCVT_F_F_W_MF2_MASK, VFNCVT_F_F_W, 0x7, 0x0 }, // 1769 + { PseudoVFNCVT_F_XU_W_M1, VFNCVT_F_XU_W, 0x0, 0x0 }, // 1770 + { PseudoVFNCVT_F_XU_W_M1_MASK, VFNCVT_F_XU_W, 0x0, 0x0 }, // 1771 + { PseudoVFNCVT_RM_F_XU_W_M1, VFNCVT_F_XU_W, 0x0, 0x0 }, // 1772 + { PseudoVFNCVT_RM_F_XU_W_M1_MASK, VFNCVT_F_XU_W, 0x0, 0x0 }, // 1773 + { PseudoVFNCVT_F_XU_W_M2, VFNCVT_F_XU_W, 0x1, 0x0 }, // 1774 + { PseudoVFNCVT_F_XU_W_M2_MASK, VFNCVT_F_XU_W, 0x1, 0x0 }, // 1775 + { PseudoVFNCVT_RM_F_XU_W_M2, VFNCVT_F_XU_W, 0x1, 0x0 }, // 1776 + { PseudoVFNCVT_RM_F_XU_W_M2_MASK, VFNCVT_F_XU_W, 0x1, 0x0 }, // 1777 + { PseudoVFNCVT_F_XU_W_M4, VFNCVT_F_XU_W, 0x2, 0x0 }, // 1778 + { PseudoVFNCVT_F_XU_W_M4_MASK, VFNCVT_F_XU_W, 0x2, 0x0 }, // 1779 + { PseudoVFNCVT_RM_F_XU_W_M4, VFNCVT_F_XU_W, 0x2, 0x0 }, // 1780 + { PseudoVFNCVT_RM_F_XU_W_M4_MASK, VFNCVT_F_XU_W, 0x2, 0x0 }, // 1781 + { PseudoVFNCVT_F_XU_W_MF4, VFNCVT_F_XU_W, 0x6, 0x0 }, // 1782 + { PseudoVFNCVT_F_XU_W_MF4_MASK, VFNCVT_F_XU_W, 0x6, 0x0 }, // 1783 + { PseudoVFNCVT_RM_F_XU_W_MF4, VFNCVT_F_XU_W, 0x6, 0x0 }, // 1784 + { PseudoVFNCVT_RM_F_XU_W_MF4_MASK, VFNCVT_F_XU_W, 0x6, 0x0 }, // 1785 + { PseudoVFNCVT_F_XU_W_MF2, VFNCVT_F_XU_W, 0x7, 0x0 }, // 1786 + { PseudoVFNCVT_F_XU_W_MF2_MASK, VFNCVT_F_XU_W, 0x7, 0x0 }, // 1787 + { PseudoVFNCVT_RM_F_XU_W_MF2, VFNCVT_F_XU_W, 0x7, 0x0 }, // 1788 + { PseudoVFNCVT_RM_F_XU_W_MF2_MASK, VFNCVT_F_XU_W, 0x7, 0x0 }, // 1789 + { PseudoVFNCVT_F_X_W_M1, VFNCVT_F_X_W, 0x0, 0x0 }, // 1790 + { PseudoVFNCVT_F_X_W_M1_MASK, VFNCVT_F_X_W, 0x0, 0x0 }, // 1791 + { PseudoVFNCVT_RM_F_X_W_M1, VFNCVT_F_X_W, 0x0, 0x0 }, // 1792 + { PseudoVFNCVT_RM_F_X_W_M1_MASK, VFNCVT_F_X_W, 0x0, 0x0 }, // 1793 + { PseudoVFNCVT_F_X_W_M2, VFNCVT_F_X_W, 0x1, 0x0 }, // 1794 + { PseudoVFNCVT_F_X_W_M2_MASK, VFNCVT_F_X_W, 0x1, 0x0 }, // 1795 + { PseudoVFNCVT_RM_F_X_W_M2, VFNCVT_F_X_W, 0x1, 0x0 }, // 1796 + { PseudoVFNCVT_RM_F_X_W_M2_MASK, VFNCVT_F_X_W, 0x1, 0x0 }, // 1797 + { PseudoVFNCVT_F_X_W_M4, VFNCVT_F_X_W, 0x2, 0x0 }, // 1798 + { PseudoVFNCVT_F_X_W_M4_MASK, VFNCVT_F_X_W, 0x2, 0x0 }, // 1799 + { PseudoVFNCVT_RM_F_X_W_M4, VFNCVT_F_X_W, 0x2, 0x0 }, // 1800 + { PseudoVFNCVT_RM_F_X_W_M4_MASK, VFNCVT_F_X_W, 0x2, 0x0 }, // 1801 + { PseudoVFNCVT_F_X_W_MF4, VFNCVT_F_X_W, 0x6, 0x0 }, // 1802 + { PseudoVFNCVT_F_X_W_MF4_MASK, VFNCVT_F_X_W, 0x6, 0x0 }, // 1803 + { PseudoVFNCVT_RM_F_X_W_MF4, VFNCVT_F_X_W, 0x6, 0x0 }, // 1804 + { PseudoVFNCVT_RM_F_X_W_MF4_MASK, VFNCVT_F_X_W, 0x6, 0x0 }, // 1805 + { PseudoVFNCVT_F_X_W_MF2, VFNCVT_F_X_W, 0x7, 0x0 }, // 1806 + { PseudoVFNCVT_F_X_W_MF2_MASK, VFNCVT_F_X_W, 0x7, 0x0 }, // 1807 + { PseudoVFNCVT_RM_F_X_W_MF2, VFNCVT_F_X_W, 0x7, 0x0 }, // 1808 + { PseudoVFNCVT_RM_F_X_W_MF2_MASK, VFNCVT_F_X_W, 0x7, 0x0 }, // 1809 + { PseudoVFNCVT_ROD_F_F_W_M1, VFNCVT_ROD_F_F_W, 0x0, 0x0 }, // 1810 + { PseudoVFNCVT_ROD_F_F_W_M1_MASK, VFNCVT_ROD_F_F_W, 0x0, 0x0 }, // 1811 + { PseudoVFNCVT_ROD_F_F_W_M2, VFNCVT_ROD_F_F_W, 0x1, 0x0 }, // 1812 + { PseudoVFNCVT_ROD_F_F_W_M2_MASK, VFNCVT_ROD_F_F_W, 0x1, 0x0 }, // 1813 + { PseudoVFNCVT_ROD_F_F_W_M4, VFNCVT_ROD_F_F_W, 0x2, 0x0 }, // 1814 + { PseudoVFNCVT_ROD_F_F_W_M4_MASK, VFNCVT_ROD_F_F_W, 0x2, 0x0 }, // 1815 + { PseudoVFNCVT_ROD_F_F_W_MF4, VFNCVT_ROD_F_F_W, 0x6, 0x0 }, // 1816 + { PseudoVFNCVT_ROD_F_F_W_MF4_MASK, VFNCVT_ROD_F_F_W, 0x6, 0x0 }, // 1817 + { PseudoVFNCVT_ROD_F_F_W_MF2, VFNCVT_ROD_F_F_W, 0x7, 0x0 }, // 1818 + { PseudoVFNCVT_ROD_F_F_W_MF2_MASK, VFNCVT_ROD_F_F_W, 0x7, 0x0 }, // 1819 + { PseudoVFNCVT_RTZ_XU_F_W_M1, VFNCVT_RTZ_XU_F_W, 0x0, 0x0 }, // 1820 + { PseudoVFNCVT_RTZ_XU_F_W_M1_MASK, VFNCVT_RTZ_XU_F_W, 0x0, 0x0 }, // 1821 + { PseudoVFNCVT_RTZ_XU_F_W_M2, VFNCVT_RTZ_XU_F_W, 0x1, 0x0 }, // 1822 + { PseudoVFNCVT_RTZ_XU_F_W_M2_MASK, VFNCVT_RTZ_XU_F_W, 0x1, 0x0 }, // 1823 + { PseudoVFNCVT_RTZ_XU_F_W_M4, VFNCVT_RTZ_XU_F_W, 0x2, 0x0 }, // 1824 + { PseudoVFNCVT_RTZ_XU_F_W_M4_MASK, VFNCVT_RTZ_XU_F_W, 0x2, 0x0 }, // 1825 + { PseudoVFNCVT_RTZ_XU_F_W_MF8, VFNCVT_RTZ_XU_F_W, 0x5, 0x0 }, // 1826 + { PseudoVFNCVT_RTZ_XU_F_W_MF8_MASK, VFNCVT_RTZ_XU_F_W, 0x5, 0x0 }, // 1827 + { PseudoVFNCVT_RTZ_XU_F_W_MF4, VFNCVT_RTZ_XU_F_W, 0x6, 0x0 }, // 1828 + { PseudoVFNCVT_RTZ_XU_F_W_MF4_MASK, VFNCVT_RTZ_XU_F_W, 0x6, 0x0 }, // 1829 + { PseudoVFNCVT_RTZ_XU_F_W_MF2, VFNCVT_RTZ_XU_F_W, 0x7, 0x0 }, // 1830 + { PseudoVFNCVT_RTZ_XU_F_W_MF2_MASK, VFNCVT_RTZ_XU_F_W, 0x7, 0x0 }, // 1831 + { PseudoVFNCVT_RTZ_X_F_W_M1, VFNCVT_RTZ_X_F_W, 0x0, 0x0 }, // 1832 + { PseudoVFNCVT_RTZ_X_F_W_M1_MASK, VFNCVT_RTZ_X_F_W, 0x0, 0x0 }, // 1833 + { PseudoVFNCVT_RTZ_X_F_W_M2, VFNCVT_RTZ_X_F_W, 0x1, 0x0 }, // 1834 + { PseudoVFNCVT_RTZ_X_F_W_M2_MASK, VFNCVT_RTZ_X_F_W, 0x1, 0x0 }, // 1835 + { PseudoVFNCVT_RTZ_X_F_W_M4, VFNCVT_RTZ_X_F_W, 0x2, 0x0 }, // 1836 + { PseudoVFNCVT_RTZ_X_F_W_M4_MASK, VFNCVT_RTZ_X_F_W, 0x2, 0x0 }, // 1837 + { PseudoVFNCVT_RTZ_X_F_W_MF8, VFNCVT_RTZ_X_F_W, 0x5, 0x0 }, // 1838 + { PseudoVFNCVT_RTZ_X_F_W_MF8_MASK, VFNCVT_RTZ_X_F_W, 0x5, 0x0 }, // 1839 + { PseudoVFNCVT_RTZ_X_F_W_MF4, VFNCVT_RTZ_X_F_W, 0x6, 0x0 }, // 1840 + { PseudoVFNCVT_RTZ_X_F_W_MF4_MASK, VFNCVT_RTZ_X_F_W, 0x6, 0x0 }, // 1841 + { PseudoVFNCVT_RTZ_X_F_W_MF2, VFNCVT_RTZ_X_F_W, 0x7, 0x0 }, // 1842 + { PseudoVFNCVT_RTZ_X_F_W_MF2_MASK, VFNCVT_RTZ_X_F_W, 0x7, 0x0 }, // 1843 + { PseudoVFNCVT_RM_XU_F_W_M1, VFNCVT_XU_F_W, 0x0, 0x0 }, // 1844 + { PseudoVFNCVT_RM_XU_F_W_M1_MASK, VFNCVT_XU_F_W, 0x0, 0x0 }, // 1845 + { PseudoVFNCVT_XU_F_W_M1, VFNCVT_XU_F_W, 0x0, 0x0 }, // 1846 + { PseudoVFNCVT_XU_F_W_M1_MASK, VFNCVT_XU_F_W, 0x0, 0x0 }, // 1847 + { PseudoVFNCVT_RM_XU_F_W_M2, VFNCVT_XU_F_W, 0x1, 0x0 }, // 1848 + { PseudoVFNCVT_RM_XU_F_W_M2_MASK, VFNCVT_XU_F_W, 0x1, 0x0 }, // 1849 + { PseudoVFNCVT_XU_F_W_M2, VFNCVT_XU_F_W, 0x1, 0x0 }, // 1850 + { PseudoVFNCVT_XU_F_W_M2_MASK, VFNCVT_XU_F_W, 0x1, 0x0 }, // 1851 + { PseudoVFNCVT_RM_XU_F_W_M4, VFNCVT_XU_F_W, 0x2, 0x0 }, // 1852 + { PseudoVFNCVT_RM_XU_F_W_M4_MASK, VFNCVT_XU_F_W, 0x2, 0x0 }, // 1853 + { PseudoVFNCVT_XU_F_W_M4, VFNCVT_XU_F_W, 0x2, 0x0 }, // 1854 + { PseudoVFNCVT_XU_F_W_M4_MASK, VFNCVT_XU_F_W, 0x2, 0x0 }, // 1855 + { PseudoVFNCVT_RM_XU_F_W_MF8, VFNCVT_XU_F_W, 0x5, 0x0 }, // 1856 + { PseudoVFNCVT_RM_XU_F_W_MF8_MASK, VFNCVT_XU_F_W, 0x5, 0x0 }, // 1857 + { PseudoVFNCVT_XU_F_W_MF8, VFNCVT_XU_F_W, 0x5, 0x0 }, // 1858 + { PseudoVFNCVT_XU_F_W_MF8_MASK, VFNCVT_XU_F_W, 0x5, 0x0 }, // 1859 + { PseudoVFNCVT_RM_XU_F_W_MF4, VFNCVT_XU_F_W, 0x6, 0x0 }, // 1860 + { PseudoVFNCVT_RM_XU_F_W_MF4_MASK, VFNCVT_XU_F_W, 0x6, 0x0 }, // 1861 + { PseudoVFNCVT_XU_F_W_MF4, VFNCVT_XU_F_W, 0x6, 0x0 }, // 1862 + { PseudoVFNCVT_XU_F_W_MF4_MASK, VFNCVT_XU_F_W, 0x6, 0x0 }, // 1863 + { PseudoVFNCVT_RM_XU_F_W_MF2, VFNCVT_XU_F_W, 0x7, 0x0 }, // 1864 + { PseudoVFNCVT_RM_XU_F_W_MF2_MASK, VFNCVT_XU_F_W, 0x7, 0x0 }, // 1865 + { PseudoVFNCVT_XU_F_W_MF2, VFNCVT_XU_F_W, 0x7, 0x0 }, // 1866 + { PseudoVFNCVT_XU_F_W_MF2_MASK, VFNCVT_XU_F_W, 0x7, 0x0 }, // 1867 + { PseudoVFNCVT_RM_X_F_W_M1, VFNCVT_X_F_W, 0x0, 0x0 }, // 1868 + { PseudoVFNCVT_RM_X_F_W_M1_MASK, VFNCVT_X_F_W, 0x0, 0x0 }, // 1869 + { PseudoVFNCVT_X_F_W_M1, VFNCVT_X_F_W, 0x0, 0x0 }, // 1870 + { PseudoVFNCVT_X_F_W_M1_MASK, VFNCVT_X_F_W, 0x0, 0x0 }, // 1871 + { PseudoVFNCVT_RM_X_F_W_M2, VFNCVT_X_F_W, 0x1, 0x0 }, // 1872 + { PseudoVFNCVT_RM_X_F_W_M2_MASK, VFNCVT_X_F_W, 0x1, 0x0 }, // 1873 + { PseudoVFNCVT_X_F_W_M2, VFNCVT_X_F_W, 0x1, 0x0 }, // 1874 + { PseudoVFNCVT_X_F_W_M2_MASK, VFNCVT_X_F_W, 0x1, 0x0 }, // 1875 + { PseudoVFNCVT_RM_X_F_W_M4, VFNCVT_X_F_W, 0x2, 0x0 }, // 1876 + { PseudoVFNCVT_RM_X_F_W_M4_MASK, VFNCVT_X_F_W, 0x2, 0x0 }, // 1877 + { PseudoVFNCVT_X_F_W_M4, VFNCVT_X_F_W, 0x2, 0x0 }, // 1878 + { PseudoVFNCVT_X_F_W_M4_MASK, VFNCVT_X_F_W, 0x2, 0x0 }, // 1879 + { PseudoVFNCVT_RM_X_F_W_MF8, VFNCVT_X_F_W, 0x5, 0x0 }, // 1880 + { PseudoVFNCVT_RM_X_F_W_MF8_MASK, VFNCVT_X_F_W, 0x5, 0x0 }, // 1881 + { PseudoVFNCVT_X_F_W_MF8, VFNCVT_X_F_W, 0x5, 0x0 }, // 1882 + { PseudoVFNCVT_X_F_W_MF8_MASK, VFNCVT_X_F_W, 0x5, 0x0 }, // 1883 + { PseudoVFNCVT_RM_X_F_W_MF4, VFNCVT_X_F_W, 0x6, 0x0 }, // 1884 + { PseudoVFNCVT_RM_X_F_W_MF4_MASK, VFNCVT_X_F_W, 0x6, 0x0 }, // 1885 + { PseudoVFNCVT_X_F_W_MF4, VFNCVT_X_F_W, 0x6, 0x0 }, // 1886 + { PseudoVFNCVT_X_F_W_MF4_MASK, VFNCVT_X_F_W, 0x6, 0x0 }, // 1887 + { PseudoVFNCVT_RM_X_F_W_MF2, VFNCVT_X_F_W, 0x7, 0x0 }, // 1888 + { PseudoVFNCVT_RM_X_F_W_MF2_MASK, VFNCVT_X_F_W, 0x7, 0x0 }, // 1889 + { PseudoVFNCVT_X_F_W_MF2, VFNCVT_X_F_W, 0x7, 0x0 }, // 1890 + { PseudoVFNCVT_X_F_W_MF2_MASK, VFNCVT_X_F_W, 0x7, 0x0 }, // 1891 + { PseudoVFNMACC_VFPR16_M1, VFNMACC_VF, 0x0, 0x0 }, // 1892 + { PseudoVFNMACC_VFPR16_M1_MASK, VFNMACC_VF, 0x0, 0x0 }, // 1893 + { PseudoVFNMACC_VFPR32_M1, VFNMACC_VF, 0x0, 0x0 }, // 1894 + { PseudoVFNMACC_VFPR32_M1_MASK, VFNMACC_VF, 0x0, 0x0 }, // 1895 + { PseudoVFNMACC_VFPR64_M1, VFNMACC_VF, 0x0, 0x0 }, // 1896 + { PseudoVFNMACC_VFPR64_M1_MASK, VFNMACC_VF, 0x0, 0x0 }, // 1897 + { PseudoVFNMACC_VFPR16_M2, VFNMACC_VF, 0x1, 0x0 }, // 1898 + { PseudoVFNMACC_VFPR16_M2_MASK, VFNMACC_VF, 0x1, 0x0 }, // 1899 + { PseudoVFNMACC_VFPR32_M2, VFNMACC_VF, 0x1, 0x0 }, // 1900 + { PseudoVFNMACC_VFPR32_M2_MASK, VFNMACC_VF, 0x1, 0x0 }, // 1901 + { PseudoVFNMACC_VFPR64_M2, VFNMACC_VF, 0x1, 0x0 }, // 1902 + { PseudoVFNMACC_VFPR64_M2_MASK, VFNMACC_VF, 0x1, 0x0 }, // 1903 + { PseudoVFNMACC_VFPR16_M4, VFNMACC_VF, 0x2, 0x0 }, // 1904 + { PseudoVFNMACC_VFPR16_M4_MASK, VFNMACC_VF, 0x2, 0x0 }, // 1905 + { PseudoVFNMACC_VFPR32_M4, VFNMACC_VF, 0x2, 0x0 }, // 1906 + { PseudoVFNMACC_VFPR32_M4_MASK, VFNMACC_VF, 0x2, 0x0 }, // 1907 + { PseudoVFNMACC_VFPR64_M4, VFNMACC_VF, 0x2, 0x0 }, // 1908 + { PseudoVFNMACC_VFPR64_M4_MASK, VFNMACC_VF, 0x2, 0x0 }, // 1909 + { PseudoVFNMACC_VFPR16_M8, VFNMACC_VF, 0x3, 0x0 }, // 1910 + { PseudoVFNMACC_VFPR16_M8_MASK, VFNMACC_VF, 0x3, 0x0 }, // 1911 + { PseudoVFNMACC_VFPR32_M8, VFNMACC_VF, 0x3, 0x0 }, // 1912 + { PseudoVFNMACC_VFPR32_M8_MASK, VFNMACC_VF, 0x3, 0x0 }, // 1913 + { PseudoVFNMACC_VFPR64_M8, VFNMACC_VF, 0x3, 0x0 }, // 1914 + { PseudoVFNMACC_VFPR64_M8_MASK, VFNMACC_VF, 0x3, 0x0 }, // 1915 + { PseudoVFNMACC_VFPR16_MF4, VFNMACC_VF, 0x6, 0x0 }, // 1916 + { PseudoVFNMACC_VFPR16_MF4_MASK, VFNMACC_VF, 0x6, 0x0 }, // 1917 + { PseudoVFNMACC_VFPR16_MF2, VFNMACC_VF, 0x7, 0x0 }, // 1918 + { PseudoVFNMACC_VFPR16_MF2_MASK, VFNMACC_VF, 0x7, 0x0 }, // 1919 + { PseudoVFNMACC_VFPR32_MF2, VFNMACC_VF, 0x7, 0x0 }, // 1920 + { PseudoVFNMACC_VFPR32_MF2_MASK, VFNMACC_VF, 0x7, 0x0 }, // 1921 + { PseudoVFNMACC_VV_M1, VFNMACC_VV, 0x0, 0x0 }, // 1922 + { PseudoVFNMACC_VV_M1_MASK, VFNMACC_VV, 0x0, 0x0 }, // 1923 + { PseudoVFNMACC_VV_M2, VFNMACC_VV, 0x1, 0x0 }, // 1924 + { PseudoVFNMACC_VV_M2_MASK, VFNMACC_VV, 0x1, 0x0 }, // 1925 + { PseudoVFNMACC_VV_M4, VFNMACC_VV, 0x2, 0x0 }, // 1926 + { PseudoVFNMACC_VV_M4_MASK, VFNMACC_VV, 0x2, 0x0 }, // 1927 + { PseudoVFNMACC_VV_M8, VFNMACC_VV, 0x3, 0x0 }, // 1928 + { PseudoVFNMACC_VV_M8_MASK, VFNMACC_VV, 0x3, 0x0 }, // 1929 + { PseudoVFNMACC_VV_MF4, VFNMACC_VV, 0x6, 0x0 }, // 1930 + { PseudoVFNMACC_VV_MF4_MASK, VFNMACC_VV, 0x6, 0x0 }, // 1931 + { PseudoVFNMACC_VV_MF2, VFNMACC_VV, 0x7, 0x0 }, // 1932 + { PseudoVFNMACC_VV_MF2_MASK, VFNMACC_VV, 0x7, 0x0 }, // 1933 + { PseudoVFNMADD_VFPR16_M1, VFNMADD_VF, 0x0, 0x0 }, // 1934 + { PseudoVFNMADD_VFPR16_M1_MASK, VFNMADD_VF, 0x0, 0x0 }, // 1935 + { PseudoVFNMADD_VFPR32_M1, VFNMADD_VF, 0x0, 0x0 }, // 1936 + { PseudoVFNMADD_VFPR32_M1_MASK, VFNMADD_VF, 0x0, 0x0 }, // 1937 + { PseudoVFNMADD_VFPR64_M1, VFNMADD_VF, 0x0, 0x0 }, // 1938 + { PseudoVFNMADD_VFPR64_M1_MASK, VFNMADD_VF, 0x0, 0x0 }, // 1939 + { PseudoVFNMADD_VFPR16_M2, VFNMADD_VF, 0x1, 0x0 }, // 1940 + { PseudoVFNMADD_VFPR16_M2_MASK, VFNMADD_VF, 0x1, 0x0 }, // 1941 + { PseudoVFNMADD_VFPR32_M2, VFNMADD_VF, 0x1, 0x0 }, // 1942 + { PseudoVFNMADD_VFPR32_M2_MASK, VFNMADD_VF, 0x1, 0x0 }, // 1943 + { PseudoVFNMADD_VFPR64_M2, VFNMADD_VF, 0x1, 0x0 }, // 1944 + { PseudoVFNMADD_VFPR64_M2_MASK, VFNMADD_VF, 0x1, 0x0 }, // 1945 + { PseudoVFNMADD_VFPR16_M4, VFNMADD_VF, 0x2, 0x0 }, // 1946 + { PseudoVFNMADD_VFPR16_M4_MASK, VFNMADD_VF, 0x2, 0x0 }, // 1947 + { PseudoVFNMADD_VFPR32_M4, VFNMADD_VF, 0x2, 0x0 }, // 1948 + { PseudoVFNMADD_VFPR32_M4_MASK, VFNMADD_VF, 0x2, 0x0 }, // 1949 + { PseudoVFNMADD_VFPR64_M4, VFNMADD_VF, 0x2, 0x0 }, // 1950 + { PseudoVFNMADD_VFPR64_M4_MASK, VFNMADD_VF, 0x2, 0x0 }, // 1951 + { PseudoVFNMADD_VFPR16_M8, VFNMADD_VF, 0x3, 0x0 }, // 1952 + { PseudoVFNMADD_VFPR16_M8_MASK, VFNMADD_VF, 0x3, 0x0 }, // 1953 + { PseudoVFNMADD_VFPR32_M8, VFNMADD_VF, 0x3, 0x0 }, // 1954 + { PseudoVFNMADD_VFPR32_M8_MASK, VFNMADD_VF, 0x3, 0x0 }, // 1955 + { PseudoVFNMADD_VFPR64_M8, VFNMADD_VF, 0x3, 0x0 }, // 1956 + { PseudoVFNMADD_VFPR64_M8_MASK, VFNMADD_VF, 0x3, 0x0 }, // 1957 + { PseudoVFNMADD_VFPR16_MF4, VFNMADD_VF, 0x6, 0x0 }, // 1958 + { PseudoVFNMADD_VFPR16_MF4_MASK, VFNMADD_VF, 0x6, 0x0 }, // 1959 + { PseudoVFNMADD_VFPR16_MF2, VFNMADD_VF, 0x7, 0x0 }, // 1960 + { PseudoVFNMADD_VFPR16_MF2_MASK, VFNMADD_VF, 0x7, 0x0 }, // 1961 + { PseudoVFNMADD_VFPR32_MF2, VFNMADD_VF, 0x7, 0x0 }, // 1962 + { PseudoVFNMADD_VFPR32_MF2_MASK, VFNMADD_VF, 0x7, 0x0 }, // 1963 + { PseudoVFNMADD_VV_M1, VFNMADD_VV, 0x0, 0x0 }, // 1964 + { PseudoVFNMADD_VV_M1_MASK, VFNMADD_VV, 0x0, 0x0 }, // 1965 + { PseudoVFNMADD_VV_M2, VFNMADD_VV, 0x1, 0x0 }, // 1966 + { PseudoVFNMADD_VV_M2_MASK, VFNMADD_VV, 0x1, 0x0 }, // 1967 + { PseudoVFNMADD_VV_M4, VFNMADD_VV, 0x2, 0x0 }, // 1968 + { PseudoVFNMADD_VV_M4_MASK, VFNMADD_VV, 0x2, 0x0 }, // 1969 + { PseudoVFNMADD_VV_M8, VFNMADD_VV, 0x3, 0x0 }, // 1970 + { PseudoVFNMADD_VV_M8_MASK, VFNMADD_VV, 0x3, 0x0 }, // 1971 + { PseudoVFNMADD_VV_MF4, VFNMADD_VV, 0x6, 0x0 }, // 1972 + { PseudoVFNMADD_VV_MF4_MASK, VFNMADD_VV, 0x6, 0x0 }, // 1973 + { PseudoVFNMADD_VV_MF2, VFNMADD_VV, 0x7, 0x0 }, // 1974 + { PseudoVFNMADD_VV_MF2_MASK, VFNMADD_VV, 0x7, 0x0 }, // 1975 + { PseudoVFNMSAC_VFPR16_M1, VFNMSAC_VF, 0x0, 0x0 }, // 1976 + { PseudoVFNMSAC_VFPR16_M1_MASK, VFNMSAC_VF, 0x0, 0x0 }, // 1977 + { PseudoVFNMSAC_VFPR32_M1, VFNMSAC_VF, 0x0, 0x0 }, // 1978 + { PseudoVFNMSAC_VFPR32_M1_MASK, VFNMSAC_VF, 0x0, 0x0 }, // 1979 + { PseudoVFNMSAC_VFPR64_M1, VFNMSAC_VF, 0x0, 0x0 }, // 1980 + { PseudoVFNMSAC_VFPR64_M1_MASK, VFNMSAC_VF, 0x0, 0x0 }, // 1981 + { PseudoVFNMSAC_VFPR16_M2, VFNMSAC_VF, 0x1, 0x0 }, // 1982 + { PseudoVFNMSAC_VFPR16_M2_MASK, VFNMSAC_VF, 0x1, 0x0 }, // 1983 + { PseudoVFNMSAC_VFPR32_M2, VFNMSAC_VF, 0x1, 0x0 }, // 1984 + { PseudoVFNMSAC_VFPR32_M2_MASK, VFNMSAC_VF, 0x1, 0x0 }, // 1985 + { PseudoVFNMSAC_VFPR64_M2, VFNMSAC_VF, 0x1, 0x0 }, // 1986 + { PseudoVFNMSAC_VFPR64_M2_MASK, VFNMSAC_VF, 0x1, 0x0 }, // 1987 + { PseudoVFNMSAC_VFPR16_M4, VFNMSAC_VF, 0x2, 0x0 }, // 1988 + { PseudoVFNMSAC_VFPR16_M4_MASK, VFNMSAC_VF, 0x2, 0x0 }, // 1989 + { PseudoVFNMSAC_VFPR32_M4, VFNMSAC_VF, 0x2, 0x0 }, // 1990 + { PseudoVFNMSAC_VFPR32_M4_MASK, VFNMSAC_VF, 0x2, 0x0 }, // 1991 + { PseudoVFNMSAC_VFPR64_M4, VFNMSAC_VF, 0x2, 0x0 }, // 1992 + { PseudoVFNMSAC_VFPR64_M4_MASK, VFNMSAC_VF, 0x2, 0x0 }, // 1993 + { PseudoVFNMSAC_VFPR16_M8, VFNMSAC_VF, 0x3, 0x0 }, // 1994 + { PseudoVFNMSAC_VFPR16_M8_MASK, VFNMSAC_VF, 0x3, 0x0 }, // 1995 + { PseudoVFNMSAC_VFPR32_M8, VFNMSAC_VF, 0x3, 0x0 }, // 1996 + { PseudoVFNMSAC_VFPR32_M8_MASK, VFNMSAC_VF, 0x3, 0x0 }, // 1997 + { PseudoVFNMSAC_VFPR64_M8, VFNMSAC_VF, 0x3, 0x0 }, // 1998 + { PseudoVFNMSAC_VFPR64_M8_MASK, VFNMSAC_VF, 0x3, 0x0 }, // 1999 + { PseudoVFNMSAC_VFPR16_MF4, VFNMSAC_VF, 0x6, 0x0 }, // 2000 + { PseudoVFNMSAC_VFPR16_MF4_MASK, VFNMSAC_VF, 0x6, 0x0 }, // 2001 + { PseudoVFNMSAC_VFPR16_MF2, VFNMSAC_VF, 0x7, 0x0 }, // 2002 + { PseudoVFNMSAC_VFPR16_MF2_MASK, VFNMSAC_VF, 0x7, 0x0 }, // 2003 + { PseudoVFNMSAC_VFPR32_MF2, VFNMSAC_VF, 0x7, 0x0 }, // 2004 + { PseudoVFNMSAC_VFPR32_MF2_MASK, VFNMSAC_VF, 0x7, 0x0 }, // 2005 + { PseudoVFNMSAC_VV_M1, VFNMSAC_VV, 0x0, 0x0 }, // 2006 + { PseudoVFNMSAC_VV_M1_MASK, VFNMSAC_VV, 0x0, 0x0 }, // 2007 + { PseudoVFNMSAC_VV_M2, VFNMSAC_VV, 0x1, 0x0 }, // 2008 + { PseudoVFNMSAC_VV_M2_MASK, VFNMSAC_VV, 0x1, 0x0 }, // 2009 + { PseudoVFNMSAC_VV_M4, VFNMSAC_VV, 0x2, 0x0 }, // 2010 + { PseudoVFNMSAC_VV_M4_MASK, VFNMSAC_VV, 0x2, 0x0 }, // 2011 + { PseudoVFNMSAC_VV_M8, VFNMSAC_VV, 0x3, 0x0 }, // 2012 + { PseudoVFNMSAC_VV_M8_MASK, VFNMSAC_VV, 0x3, 0x0 }, // 2013 + { PseudoVFNMSAC_VV_MF4, VFNMSAC_VV, 0x6, 0x0 }, // 2014 + { PseudoVFNMSAC_VV_MF4_MASK, VFNMSAC_VV, 0x6, 0x0 }, // 2015 + { PseudoVFNMSAC_VV_MF2, VFNMSAC_VV, 0x7, 0x0 }, // 2016 + { PseudoVFNMSAC_VV_MF2_MASK, VFNMSAC_VV, 0x7, 0x0 }, // 2017 + { PseudoVFNMSUB_VFPR16_M1, VFNMSUB_VF, 0x0, 0x0 }, // 2018 + { PseudoVFNMSUB_VFPR16_M1_MASK, VFNMSUB_VF, 0x0, 0x0 }, // 2019 + { PseudoVFNMSUB_VFPR32_M1, VFNMSUB_VF, 0x0, 0x0 }, // 2020 + { PseudoVFNMSUB_VFPR32_M1_MASK, VFNMSUB_VF, 0x0, 0x0 }, // 2021 + { PseudoVFNMSUB_VFPR64_M1, VFNMSUB_VF, 0x0, 0x0 }, // 2022 + { PseudoVFNMSUB_VFPR64_M1_MASK, VFNMSUB_VF, 0x0, 0x0 }, // 2023 + { PseudoVFNMSUB_VFPR16_M2, VFNMSUB_VF, 0x1, 0x0 }, // 2024 + { PseudoVFNMSUB_VFPR16_M2_MASK, VFNMSUB_VF, 0x1, 0x0 }, // 2025 + { PseudoVFNMSUB_VFPR32_M2, VFNMSUB_VF, 0x1, 0x0 }, // 2026 + { PseudoVFNMSUB_VFPR32_M2_MASK, VFNMSUB_VF, 0x1, 0x0 }, // 2027 + { PseudoVFNMSUB_VFPR64_M2, VFNMSUB_VF, 0x1, 0x0 }, // 2028 + { PseudoVFNMSUB_VFPR64_M2_MASK, VFNMSUB_VF, 0x1, 0x0 }, // 2029 + { PseudoVFNMSUB_VFPR16_M4, VFNMSUB_VF, 0x2, 0x0 }, // 2030 + { PseudoVFNMSUB_VFPR16_M4_MASK, VFNMSUB_VF, 0x2, 0x0 }, // 2031 + { PseudoVFNMSUB_VFPR32_M4, VFNMSUB_VF, 0x2, 0x0 }, // 2032 + { PseudoVFNMSUB_VFPR32_M4_MASK, VFNMSUB_VF, 0x2, 0x0 }, // 2033 + { PseudoVFNMSUB_VFPR64_M4, VFNMSUB_VF, 0x2, 0x0 }, // 2034 + { PseudoVFNMSUB_VFPR64_M4_MASK, VFNMSUB_VF, 0x2, 0x0 }, // 2035 + { PseudoVFNMSUB_VFPR16_M8, VFNMSUB_VF, 0x3, 0x0 }, // 2036 + { PseudoVFNMSUB_VFPR16_M8_MASK, VFNMSUB_VF, 0x3, 0x0 }, // 2037 + { PseudoVFNMSUB_VFPR32_M8, VFNMSUB_VF, 0x3, 0x0 }, // 2038 + { PseudoVFNMSUB_VFPR32_M8_MASK, VFNMSUB_VF, 0x3, 0x0 }, // 2039 + { PseudoVFNMSUB_VFPR64_M8, VFNMSUB_VF, 0x3, 0x0 }, // 2040 + { PseudoVFNMSUB_VFPR64_M8_MASK, VFNMSUB_VF, 0x3, 0x0 }, // 2041 + { PseudoVFNMSUB_VFPR16_MF4, VFNMSUB_VF, 0x6, 0x0 }, // 2042 + { PseudoVFNMSUB_VFPR16_MF4_MASK, VFNMSUB_VF, 0x6, 0x0 }, // 2043 + { PseudoVFNMSUB_VFPR16_MF2, VFNMSUB_VF, 0x7, 0x0 }, // 2044 + { PseudoVFNMSUB_VFPR16_MF2_MASK, VFNMSUB_VF, 0x7, 0x0 }, // 2045 + { PseudoVFNMSUB_VFPR32_MF2, VFNMSUB_VF, 0x7, 0x0 }, // 2046 + { PseudoVFNMSUB_VFPR32_MF2_MASK, VFNMSUB_VF, 0x7, 0x0 }, // 2047 + { PseudoVFNMSUB_VV_M1, VFNMSUB_VV, 0x0, 0x0 }, // 2048 + { PseudoVFNMSUB_VV_M1_MASK, VFNMSUB_VV, 0x0, 0x0 }, // 2049 + { PseudoVFNMSUB_VV_M2, VFNMSUB_VV, 0x1, 0x0 }, // 2050 + { PseudoVFNMSUB_VV_M2_MASK, VFNMSUB_VV, 0x1, 0x0 }, // 2051 + { PseudoVFNMSUB_VV_M4, VFNMSUB_VV, 0x2, 0x0 }, // 2052 + { PseudoVFNMSUB_VV_M4_MASK, VFNMSUB_VV, 0x2, 0x0 }, // 2053 + { PseudoVFNMSUB_VV_M8, VFNMSUB_VV, 0x3, 0x0 }, // 2054 + { PseudoVFNMSUB_VV_M8_MASK, VFNMSUB_VV, 0x3, 0x0 }, // 2055 + { PseudoVFNMSUB_VV_MF4, VFNMSUB_VV, 0x6, 0x0 }, // 2056 + { PseudoVFNMSUB_VV_MF4_MASK, VFNMSUB_VV, 0x6, 0x0 }, // 2057 + { PseudoVFNMSUB_VV_MF2, VFNMSUB_VV, 0x7, 0x0 }, // 2058 + { PseudoVFNMSUB_VV_MF2_MASK, VFNMSUB_VV, 0x7, 0x0 }, // 2059 + { PseudoVFNRCLIP_XU_F_QF_M1, VFNRCLIP_XU_F_QF, 0x0, 0x0 }, // 2060 + { PseudoVFNRCLIP_XU_F_QF_M1_MASK, VFNRCLIP_XU_F_QF, 0x0, 0x0 }, // 2061 + { PseudoVFNRCLIP_XU_F_QF_M2, VFNRCLIP_XU_F_QF, 0x1, 0x0 }, // 2062 + { PseudoVFNRCLIP_XU_F_QF_M2_MASK, VFNRCLIP_XU_F_QF, 0x1, 0x0 }, // 2063 + { PseudoVFNRCLIP_XU_F_QF_MF8, VFNRCLIP_XU_F_QF, 0x5, 0x0 }, // 2064 + { PseudoVFNRCLIP_XU_F_QF_MF8_MASK, VFNRCLIP_XU_F_QF, 0x5, 0x0 }, // 2065 + { PseudoVFNRCLIP_XU_F_QF_MF4, VFNRCLIP_XU_F_QF, 0x6, 0x0 }, // 2066 + { PseudoVFNRCLIP_XU_F_QF_MF4_MASK, VFNRCLIP_XU_F_QF, 0x6, 0x0 }, // 2067 + { PseudoVFNRCLIP_XU_F_QF_MF2, VFNRCLIP_XU_F_QF, 0x7, 0x0 }, // 2068 + { PseudoVFNRCLIP_XU_F_QF_MF2_MASK, VFNRCLIP_XU_F_QF, 0x7, 0x0 }, // 2069 + { PseudoVFNRCLIP_X_F_QF_M1, VFNRCLIP_X_F_QF, 0x0, 0x0 }, // 2070 + { PseudoVFNRCLIP_X_F_QF_M1_MASK, VFNRCLIP_X_F_QF, 0x0, 0x0 }, // 2071 + { PseudoVFNRCLIP_X_F_QF_M2, VFNRCLIP_X_F_QF, 0x1, 0x0 }, // 2072 + { PseudoVFNRCLIP_X_F_QF_M2_MASK, VFNRCLIP_X_F_QF, 0x1, 0x0 }, // 2073 + { PseudoVFNRCLIP_X_F_QF_MF8, VFNRCLIP_X_F_QF, 0x5, 0x0 }, // 2074 + { PseudoVFNRCLIP_X_F_QF_MF8_MASK, VFNRCLIP_X_F_QF, 0x5, 0x0 }, // 2075 + { PseudoVFNRCLIP_X_F_QF_MF4, VFNRCLIP_X_F_QF, 0x6, 0x0 }, // 2076 + { PseudoVFNRCLIP_X_F_QF_MF4_MASK, VFNRCLIP_X_F_QF, 0x6, 0x0 }, // 2077 + { PseudoVFNRCLIP_X_F_QF_MF2, VFNRCLIP_X_F_QF, 0x7, 0x0 }, // 2078 + { PseudoVFNRCLIP_X_F_QF_MF2_MASK, VFNRCLIP_X_F_QF, 0x7, 0x0 }, // 2079 + { PseudoVFRDIV_VFPR16_M1_E16, VFRDIV_VF, 0x0, 0x10 }, // 2080 + { PseudoVFRDIV_VFPR16_M1_E16_MASK, VFRDIV_VF, 0x0, 0x10 }, // 2081 + { PseudoVFRDIV_VFPR32_M1_E32, VFRDIV_VF, 0x0, 0x20 }, // 2082 + { PseudoVFRDIV_VFPR32_M1_E32_MASK, VFRDIV_VF, 0x0, 0x20 }, // 2083 + { PseudoVFRDIV_VFPR64_M1_E64, VFRDIV_VF, 0x0, 0x40 }, // 2084 + { PseudoVFRDIV_VFPR64_M1_E64_MASK, VFRDIV_VF, 0x0, 0x40 }, // 2085 + { PseudoVFRDIV_VFPR16_M2_E16, VFRDIV_VF, 0x1, 0x10 }, // 2086 + { PseudoVFRDIV_VFPR16_M2_E16_MASK, VFRDIV_VF, 0x1, 0x10 }, // 2087 + { PseudoVFRDIV_VFPR32_M2_E32, VFRDIV_VF, 0x1, 0x20 }, // 2088 + { PseudoVFRDIV_VFPR32_M2_E32_MASK, VFRDIV_VF, 0x1, 0x20 }, // 2089 + { PseudoVFRDIV_VFPR64_M2_E64, VFRDIV_VF, 0x1, 0x40 }, // 2090 + { PseudoVFRDIV_VFPR64_M2_E64_MASK, VFRDIV_VF, 0x1, 0x40 }, // 2091 + { PseudoVFRDIV_VFPR16_M4_E16, VFRDIV_VF, 0x2, 0x10 }, // 2092 + { PseudoVFRDIV_VFPR16_M4_E16_MASK, VFRDIV_VF, 0x2, 0x10 }, // 2093 + { PseudoVFRDIV_VFPR32_M4_E32, VFRDIV_VF, 0x2, 0x20 }, // 2094 + { PseudoVFRDIV_VFPR32_M4_E32_MASK, VFRDIV_VF, 0x2, 0x20 }, // 2095 + { PseudoVFRDIV_VFPR64_M4_E64, VFRDIV_VF, 0x2, 0x40 }, // 2096 + { PseudoVFRDIV_VFPR64_M4_E64_MASK, VFRDIV_VF, 0x2, 0x40 }, // 2097 + { PseudoVFRDIV_VFPR16_M8_E16, VFRDIV_VF, 0x3, 0x10 }, // 2098 + { PseudoVFRDIV_VFPR16_M8_E16_MASK, VFRDIV_VF, 0x3, 0x10 }, // 2099 + { PseudoVFRDIV_VFPR32_M8_E32, VFRDIV_VF, 0x3, 0x20 }, // 2100 + { PseudoVFRDIV_VFPR32_M8_E32_MASK, VFRDIV_VF, 0x3, 0x20 }, // 2101 + { PseudoVFRDIV_VFPR64_M8_E64, VFRDIV_VF, 0x3, 0x40 }, // 2102 + { PseudoVFRDIV_VFPR64_M8_E64_MASK, VFRDIV_VF, 0x3, 0x40 }, // 2103 + { PseudoVFRDIV_VFPR16_MF4_E16, VFRDIV_VF, 0x6, 0x10 }, // 2104 + { PseudoVFRDIV_VFPR16_MF4_E16_MASK, VFRDIV_VF, 0x6, 0x10 }, // 2105 + { PseudoVFRDIV_VFPR16_MF2_E16, VFRDIV_VF, 0x7, 0x10 }, // 2106 + { PseudoVFRDIV_VFPR16_MF2_E16_MASK, VFRDIV_VF, 0x7, 0x10 }, // 2107 + { PseudoVFRDIV_VFPR32_MF2_E32, VFRDIV_VF, 0x7, 0x20 }, // 2108 + { PseudoVFRDIV_VFPR32_MF2_E32_MASK, VFRDIV_VF, 0x7, 0x20 }, // 2109 + { PseudoVFREC7_V_M1, VFREC7_V, 0x0, 0x0 }, // 2110 + { PseudoVFREC7_V_M1_MASK, VFREC7_V, 0x0, 0x0 }, // 2111 + { PseudoVFREC7_V_M2, VFREC7_V, 0x1, 0x0 }, // 2112 + { PseudoVFREC7_V_M2_MASK, VFREC7_V, 0x1, 0x0 }, // 2113 + { PseudoVFREC7_V_M4, VFREC7_V, 0x2, 0x0 }, // 2114 + { PseudoVFREC7_V_M4_MASK, VFREC7_V, 0x2, 0x0 }, // 2115 + { PseudoVFREC7_V_M8, VFREC7_V, 0x3, 0x0 }, // 2116 + { PseudoVFREC7_V_M8_MASK, VFREC7_V, 0x3, 0x0 }, // 2117 + { PseudoVFREC7_V_MF4, VFREC7_V, 0x6, 0x0 }, // 2118 + { PseudoVFREC7_V_MF4_MASK, VFREC7_V, 0x6, 0x0 }, // 2119 + { PseudoVFREC7_V_MF2, VFREC7_V, 0x7, 0x0 }, // 2120 + { PseudoVFREC7_V_MF2_MASK, VFREC7_V, 0x7, 0x0 }, // 2121 + { PseudoVFREDMAX_VS_M1_E16, VFREDMAX_VS, 0x0, 0x10 }, // 2122 + { PseudoVFREDMAX_VS_M1_E16_MASK, VFREDMAX_VS, 0x0, 0x10 }, // 2123 + { PseudoVFREDMAX_VS_M1_E32, VFREDMAX_VS, 0x0, 0x20 }, // 2124 + { PseudoVFREDMAX_VS_M1_E32_MASK, VFREDMAX_VS, 0x0, 0x20 }, // 2125 + { PseudoVFREDMAX_VS_M1_E64, VFREDMAX_VS, 0x0, 0x40 }, // 2126 + { PseudoVFREDMAX_VS_M1_E64_MASK, VFREDMAX_VS, 0x0, 0x40 }, // 2127 + { PseudoVFREDMAX_VS_M2_E16, VFREDMAX_VS, 0x1, 0x10 }, // 2128 + { PseudoVFREDMAX_VS_M2_E16_MASK, VFREDMAX_VS, 0x1, 0x10 }, // 2129 + { PseudoVFREDMAX_VS_M2_E32, VFREDMAX_VS, 0x1, 0x20 }, // 2130 + { PseudoVFREDMAX_VS_M2_E32_MASK, VFREDMAX_VS, 0x1, 0x20 }, // 2131 + { PseudoVFREDMAX_VS_M2_E64, VFREDMAX_VS, 0x1, 0x40 }, // 2132 + { PseudoVFREDMAX_VS_M2_E64_MASK, VFREDMAX_VS, 0x1, 0x40 }, // 2133 + { PseudoVFREDMAX_VS_M4_E16, VFREDMAX_VS, 0x2, 0x10 }, // 2134 + { PseudoVFREDMAX_VS_M4_E16_MASK, VFREDMAX_VS, 0x2, 0x10 }, // 2135 + { PseudoVFREDMAX_VS_M4_E32, VFREDMAX_VS, 0x2, 0x20 }, // 2136 + { PseudoVFREDMAX_VS_M4_E32_MASK, VFREDMAX_VS, 0x2, 0x20 }, // 2137 + { PseudoVFREDMAX_VS_M4_E64, VFREDMAX_VS, 0x2, 0x40 }, // 2138 + { PseudoVFREDMAX_VS_M4_E64_MASK, VFREDMAX_VS, 0x2, 0x40 }, // 2139 + { PseudoVFREDMAX_VS_M8_E16, VFREDMAX_VS, 0x3, 0x10 }, // 2140 + { PseudoVFREDMAX_VS_M8_E16_MASK, VFREDMAX_VS, 0x3, 0x10 }, // 2141 + { PseudoVFREDMAX_VS_M8_E32, VFREDMAX_VS, 0x3, 0x20 }, // 2142 + { PseudoVFREDMAX_VS_M8_E32_MASK, VFREDMAX_VS, 0x3, 0x20 }, // 2143 + { PseudoVFREDMAX_VS_M8_E64, VFREDMAX_VS, 0x3, 0x40 }, // 2144 + { PseudoVFREDMAX_VS_M8_E64_MASK, VFREDMAX_VS, 0x3, 0x40 }, // 2145 + { PseudoVFREDMAX_VS_MF4_E16, VFREDMAX_VS, 0x6, 0x10 }, // 2146 + { PseudoVFREDMAX_VS_MF4_E16_MASK, VFREDMAX_VS, 0x6, 0x10 }, // 2147 + { PseudoVFREDMAX_VS_MF2_E16, VFREDMAX_VS, 0x7, 0x10 }, // 2148 + { PseudoVFREDMAX_VS_MF2_E16_MASK, VFREDMAX_VS, 0x7, 0x10 }, // 2149 + { PseudoVFREDMAX_VS_MF2_E32, VFREDMAX_VS, 0x7, 0x20 }, // 2150 + { PseudoVFREDMAX_VS_MF2_E32_MASK, VFREDMAX_VS, 0x7, 0x20 }, // 2151 + { PseudoVFREDMIN_VS_M1_E16, VFREDMIN_VS, 0x0, 0x10 }, // 2152 + { PseudoVFREDMIN_VS_M1_E16_MASK, VFREDMIN_VS, 0x0, 0x10 }, // 2153 + { PseudoVFREDMIN_VS_M1_E32, VFREDMIN_VS, 0x0, 0x20 }, // 2154 + { PseudoVFREDMIN_VS_M1_E32_MASK, VFREDMIN_VS, 0x0, 0x20 }, // 2155 + { PseudoVFREDMIN_VS_M1_E64, VFREDMIN_VS, 0x0, 0x40 }, // 2156 + { PseudoVFREDMIN_VS_M1_E64_MASK, VFREDMIN_VS, 0x0, 0x40 }, // 2157 + { PseudoVFREDMIN_VS_M2_E16, VFREDMIN_VS, 0x1, 0x10 }, // 2158 + { PseudoVFREDMIN_VS_M2_E16_MASK, VFREDMIN_VS, 0x1, 0x10 }, // 2159 + { PseudoVFREDMIN_VS_M2_E32, VFREDMIN_VS, 0x1, 0x20 }, // 2160 + { PseudoVFREDMIN_VS_M2_E32_MASK, VFREDMIN_VS, 0x1, 0x20 }, // 2161 + { PseudoVFREDMIN_VS_M2_E64, VFREDMIN_VS, 0x1, 0x40 }, // 2162 + { PseudoVFREDMIN_VS_M2_E64_MASK, VFREDMIN_VS, 0x1, 0x40 }, // 2163 + { PseudoVFREDMIN_VS_M4_E16, VFREDMIN_VS, 0x2, 0x10 }, // 2164 + { PseudoVFREDMIN_VS_M4_E16_MASK, VFREDMIN_VS, 0x2, 0x10 }, // 2165 + { PseudoVFREDMIN_VS_M4_E32, VFREDMIN_VS, 0x2, 0x20 }, // 2166 + { PseudoVFREDMIN_VS_M4_E32_MASK, VFREDMIN_VS, 0x2, 0x20 }, // 2167 + { PseudoVFREDMIN_VS_M4_E64, VFREDMIN_VS, 0x2, 0x40 }, // 2168 + { PseudoVFREDMIN_VS_M4_E64_MASK, VFREDMIN_VS, 0x2, 0x40 }, // 2169 + { PseudoVFREDMIN_VS_M8_E16, VFREDMIN_VS, 0x3, 0x10 }, // 2170 + { PseudoVFREDMIN_VS_M8_E16_MASK, VFREDMIN_VS, 0x3, 0x10 }, // 2171 + { PseudoVFREDMIN_VS_M8_E32, VFREDMIN_VS, 0x3, 0x20 }, // 2172 + { PseudoVFREDMIN_VS_M8_E32_MASK, VFREDMIN_VS, 0x3, 0x20 }, // 2173 + { PseudoVFREDMIN_VS_M8_E64, VFREDMIN_VS, 0x3, 0x40 }, // 2174 + { PseudoVFREDMIN_VS_M8_E64_MASK, VFREDMIN_VS, 0x3, 0x40 }, // 2175 + { PseudoVFREDMIN_VS_MF4_E16, VFREDMIN_VS, 0x6, 0x10 }, // 2176 + { PseudoVFREDMIN_VS_MF4_E16_MASK, VFREDMIN_VS, 0x6, 0x10 }, // 2177 + { PseudoVFREDMIN_VS_MF2_E16, VFREDMIN_VS, 0x7, 0x10 }, // 2178 + { PseudoVFREDMIN_VS_MF2_E16_MASK, VFREDMIN_VS, 0x7, 0x10 }, // 2179 + { PseudoVFREDMIN_VS_MF2_E32, VFREDMIN_VS, 0x7, 0x20 }, // 2180 + { PseudoVFREDMIN_VS_MF2_E32_MASK, VFREDMIN_VS, 0x7, 0x20 }, // 2181 + { PseudoVFREDOSUM_VS_M1_E16, VFREDOSUM_VS, 0x0, 0x10 }, // 2182 + { PseudoVFREDOSUM_VS_M1_E16_MASK, VFREDOSUM_VS, 0x0, 0x10 }, // 2183 + { PseudoVFREDOSUM_VS_M1_E32, VFREDOSUM_VS, 0x0, 0x20 }, // 2184 + { PseudoVFREDOSUM_VS_M1_E32_MASK, VFREDOSUM_VS, 0x0, 0x20 }, // 2185 + { PseudoVFREDOSUM_VS_M1_E64, VFREDOSUM_VS, 0x0, 0x40 }, // 2186 + { PseudoVFREDOSUM_VS_M1_E64_MASK, VFREDOSUM_VS, 0x0, 0x40 }, // 2187 + { PseudoVFREDOSUM_VS_M2_E16, VFREDOSUM_VS, 0x1, 0x10 }, // 2188 + { PseudoVFREDOSUM_VS_M2_E16_MASK, VFREDOSUM_VS, 0x1, 0x10 }, // 2189 + { PseudoVFREDOSUM_VS_M2_E32, VFREDOSUM_VS, 0x1, 0x20 }, // 2190 + { PseudoVFREDOSUM_VS_M2_E32_MASK, VFREDOSUM_VS, 0x1, 0x20 }, // 2191 + { PseudoVFREDOSUM_VS_M2_E64, VFREDOSUM_VS, 0x1, 0x40 }, // 2192 + { PseudoVFREDOSUM_VS_M2_E64_MASK, VFREDOSUM_VS, 0x1, 0x40 }, // 2193 + { PseudoVFREDOSUM_VS_M4_E16, VFREDOSUM_VS, 0x2, 0x10 }, // 2194 + { PseudoVFREDOSUM_VS_M4_E16_MASK, VFREDOSUM_VS, 0x2, 0x10 }, // 2195 + { PseudoVFREDOSUM_VS_M4_E32, VFREDOSUM_VS, 0x2, 0x20 }, // 2196 + { PseudoVFREDOSUM_VS_M4_E32_MASK, VFREDOSUM_VS, 0x2, 0x20 }, // 2197 + { PseudoVFREDOSUM_VS_M4_E64, VFREDOSUM_VS, 0x2, 0x40 }, // 2198 + { PseudoVFREDOSUM_VS_M4_E64_MASK, VFREDOSUM_VS, 0x2, 0x40 }, // 2199 + { PseudoVFREDOSUM_VS_M8_E16, VFREDOSUM_VS, 0x3, 0x10 }, // 2200 + { PseudoVFREDOSUM_VS_M8_E16_MASK, VFREDOSUM_VS, 0x3, 0x10 }, // 2201 + { PseudoVFREDOSUM_VS_M8_E32, VFREDOSUM_VS, 0x3, 0x20 }, // 2202 + { PseudoVFREDOSUM_VS_M8_E32_MASK, VFREDOSUM_VS, 0x3, 0x20 }, // 2203 + { PseudoVFREDOSUM_VS_M8_E64, VFREDOSUM_VS, 0x3, 0x40 }, // 2204 + { PseudoVFREDOSUM_VS_M8_E64_MASK, VFREDOSUM_VS, 0x3, 0x40 }, // 2205 + { PseudoVFREDOSUM_VS_MF4_E16, VFREDOSUM_VS, 0x6, 0x10 }, // 2206 + { PseudoVFREDOSUM_VS_MF4_E16_MASK, VFREDOSUM_VS, 0x6, 0x10 }, // 2207 + { PseudoVFREDOSUM_VS_MF2_E16, VFREDOSUM_VS, 0x7, 0x10 }, // 2208 + { PseudoVFREDOSUM_VS_MF2_E16_MASK, VFREDOSUM_VS, 0x7, 0x10 }, // 2209 + { PseudoVFREDOSUM_VS_MF2_E32, VFREDOSUM_VS, 0x7, 0x20 }, // 2210 + { PseudoVFREDOSUM_VS_MF2_E32_MASK, VFREDOSUM_VS, 0x7, 0x20 }, // 2211 + { PseudoVFREDUSUM_VS_M1_E16, VFREDUSUM_VS, 0x0, 0x10 }, // 2212 + { PseudoVFREDUSUM_VS_M1_E16_MASK, VFREDUSUM_VS, 0x0, 0x10 }, // 2213 + { PseudoVFREDUSUM_VS_M1_E32, VFREDUSUM_VS, 0x0, 0x20 }, // 2214 + { PseudoVFREDUSUM_VS_M1_E32_MASK, VFREDUSUM_VS, 0x0, 0x20 }, // 2215 + { PseudoVFREDUSUM_VS_M1_E64, VFREDUSUM_VS, 0x0, 0x40 }, // 2216 + { PseudoVFREDUSUM_VS_M1_E64_MASK, VFREDUSUM_VS, 0x0, 0x40 }, // 2217 + { PseudoVFREDUSUM_VS_M2_E16, VFREDUSUM_VS, 0x1, 0x10 }, // 2218 + { PseudoVFREDUSUM_VS_M2_E16_MASK, VFREDUSUM_VS, 0x1, 0x10 }, // 2219 + { PseudoVFREDUSUM_VS_M2_E32, VFREDUSUM_VS, 0x1, 0x20 }, // 2220 + { PseudoVFREDUSUM_VS_M2_E32_MASK, VFREDUSUM_VS, 0x1, 0x20 }, // 2221 + { PseudoVFREDUSUM_VS_M2_E64, VFREDUSUM_VS, 0x1, 0x40 }, // 2222 + { PseudoVFREDUSUM_VS_M2_E64_MASK, VFREDUSUM_VS, 0x1, 0x40 }, // 2223 + { PseudoVFREDUSUM_VS_M4_E16, VFREDUSUM_VS, 0x2, 0x10 }, // 2224 + { PseudoVFREDUSUM_VS_M4_E16_MASK, VFREDUSUM_VS, 0x2, 0x10 }, // 2225 + { PseudoVFREDUSUM_VS_M4_E32, VFREDUSUM_VS, 0x2, 0x20 }, // 2226 + { PseudoVFREDUSUM_VS_M4_E32_MASK, VFREDUSUM_VS, 0x2, 0x20 }, // 2227 + { PseudoVFREDUSUM_VS_M4_E64, VFREDUSUM_VS, 0x2, 0x40 }, // 2228 + { PseudoVFREDUSUM_VS_M4_E64_MASK, VFREDUSUM_VS, 0x2, 0x40 }, // 2229 + { PseudoVFREDUSUM_VS_M8_E16, VFREDUSUM_VS, 0x3, 0x10 }, // 2230 + { PseudoVFREDUSUM_VS_M8_E16_MASK, VFREDUSUM_VS, 0x3, 0x10 }, // 2231 + { PseudoVFREDUSUM_VS_M8_E32, VFREDUSUM_VS, 0x3, 0x20 }, // 2232 + { PseudoVFREDUSUM_VS_M8_E32_MASK, VFREDUSUM_VS, 0x3, 0x20 }, // 2233 + { PseudoVFREDUSUM_VS_M8_E64, VFREDUSUM_VS, 0x3, 0x40 }, // 2234 + { PseudoVFREDUSUM_VS_M8_E64_MASK, VFREDUSUM_VS, 0x3, 0x40 }, // 2235 + { PseudoVFREDUSUM_VS_MF4_E16, VFREDUSUM_VS, 0x6, 0x10 }, // 2236 + { PseudoVFREDUSUM_VS_MF4_E16_MASK, VFREDUSUM_VS, 0x6, 0x10 }, // 2237 + { PseudoVFREDUSUM_VS_MF2_E16, VFREDUSUM_VS, 0x7, 0x10 }, // 2238 + { PseudoVFREDUSUM_VS_MF2_E16_MASK, VFREDUSUM_VS, 0x7, 0x10 }, // 2239 + { PseudoVFREDUSUM_VS_MF2_E32, VFREDUSUM_VS, 0x7, 0x20 }, // 2240 + { PseudoVFREDUSUM_VS_MF2_E32_MASK, VFREDUSUM_VS, 0x7, 0x20 }, // 2241 + { PseudoVFRSQRT7_V_M1, VFRSQRT7_V, 0x0, 0x0 }, // 2242 + { PseudoVFRSQRT7_V_M1_MASK, VFRSQRT7_V, 0x0, 0x0 }, // 2243 + { PseudoVFRSQRT7_V_M2, VFRSQRT7_V, 0x1, 0x0 }, // 2244 + { PseudoVFRSQRT7_V_M2_MASK, VFRSQRT7_V, 0x1, 0x0 }, // 2245 + { PseudoVFRSQRT7_V_M4, VFRSQRT7_V, 0x2, 0x0 }, // 2246 + { PseudoVFRSQRT7_V_M4_MASK, VFRSQRT7_V, 0x2, 0x0 }, // 2247 + { PseudoVFRSQRT7_V_M8, VFRSQRT7_V, 0x3, 0x0 }, // 2248 + { PseudoVFRSQRT7_V_M8_MASK, VFRSQRT7_V, 0x3, 0x0 }, // 2249 + { PseudoVFRSQRT7_V_MF4, VFRSQRT7_V, 0x6, 0x0 }, // 2250 + { PseudoVFRSQRT7_V_MF4_MASK, VFRSQRT7_V, 0x6, 0x0 }, // 2251 + { PseudoVFRSQRT7_V_MF2, VFRSQRT7_V, 0x7, 0x0 }, // 2252 + { PseudoVFRSQRT7_V_MF2_MASK, VFRSQRT7_V, 0x7, 0x0 }, // 2253 + { PseudoVFRSUB_VFPR16_M1, VFRSUB_VF, 0x0, 0x0 }, // 2254 + { PseudoVFRSUB_VFPR16_M1_MASK, VFRSUB_VF, 0x0, 0x0 }, // 2255 + { PseudoVFRSUB_VFPR32_M1, VFRSUB_VF, 0x0, 0x0 }, // 2256 + { PseudoVFRSUB_VFPR32_M1_MASK, VFRSUB_VF, 0x0, 0x0 }, // 2257 + { PseudoVFRSUB_VFPR64_M1, VFRSUB_VF, 0x0, 0x0 }, // 2258 + { PseudoVFRSUB_VFPR64_M1_MASK, VFRSUB_VF, 0x0, 0x0 }, // 2259 + { PseudoVFRSUB_VFPR16_M2, VFRSUB_VF, 0x1, 0x0 }, // 2260 + { PseudoVFRSUB_VFPR16_M2_MASK, VFRSUB_VF, 0x1, 0x0 }, // 2261 + { PseudoVFRSUB_VFPR32_M2, VFRSUB_VF, 0x1, 0x0 }, // 2262 + { PseudoVFRSUB_VFPR32_M2_MASK, VFRSUB_VF, 0x1, 0x0 }, // 2263 + { PseudoVFRSUB_VFPR64_M2, VFRSUB_VF, 0x1, 0x0 }, // 2264 + { PseudoVFRSUB_VFPR64_M2_MASK, VFRSUB_VF, 0x1, 0x0 }, // 2265 + { PseudoVFRSUB_VFPR16_M4, VFRSUB_VF, 0x2, 0x0 }, // 2266 + { PseudoVFRSUB_VFPR16_M4_MASK, VFRSUB_VF, 0x2, 0x0 }, // 2267 + { PseudoVFRSUB_VFPR32_M4, VFRSUB_VF, 0x2, 0x0 }, // 2268 + { PseudoVFRSUB_VFPR32_M4_MASK, VFRSUB_VF, 0x2, 0x0 }, // 2269 + { PseudoVFRSUB_VFPR64_M4, VFRSUB_VF, 0x2, 0x0 }, // 2270 + { PseudoVFRSUB_VFPR64_M4_MASK, VFRSUB_VF, 0x2, 0x0 }, // 2271 + { PseudoVFRSUB_VFPR16_M8, VFRSUB_VF, 0x3, 0x0 }, // 2272 + { PseudoVFRSUB_VFPR16_M8_MASK, VFRSUB_VF, 0x3, 0x0 }, // 2273 + { PseudoVFRSUB_VFPR32_M8, VFRSUB_VF, 0x3, 0x0 }, // 2274 + { PseudoVFRSUB_VFPR32_M8_MASK, VFRSUB_VF, 0x3, 0x0 }, // 2275 + { PseudoVFRSUB_VFPR64_M8, VFRSUB_VF, 0x3, 0x0 }, // 2276 + { PseudoVFRSUB_VFPR64_M8_MASK, VFRSUB_VF, 0x3, 0x0 }, // 2277 + { PseudoVFRSUB_VFPR16_MF4, VFRSUB_VF, 0x6, 0x0 }, // 2278 + { PseudoVFRSUB_VFPR16_MF4_MASK, VFRSUB_VF, 0x6, 0x0 }, // 2279 + { PseudoVFRSUB_VFPR16_MF2, VFRSUB_VF, 0x7, 0x0 }, // 2280 + { PseudoVFRSUB_VFPR16_MF2_MASK, VFRSUB_VF, 0x7, 0x0 }, // 2281 + { PseudoVFRSUB_VFPR32_MF2, VFRSUB_VF, 0x7, 0x0 }, // 2282 + { PseudoVFRSUB_VFPR32_MF2_MASK, VFRSUB_VF, 0x7, 0x0 }, // 2283 + { PseudoVFSGNJN_VFPR16_M1, VFSGNJN_VF, 0x0, 0x0 }, // 2284 + { PseudoVFSGNJN_VFPR16_M1_MASK, VFSGNJN_VF, 0x0, 0x0 }, // 2285 + { PseudoVFSGNJN_VFPR32_M1, VFSGNJN_VF, 0x0, 0x0 }, // 2286 + { PseudoVFSGNJN_VFPR32_M1_MASK, VFSGNJN_VF, 0x0, 0x0 }, // 2287 + { PseudoVFSGNJN_VFPR64_M1, VFSGNJN_VF, 0x0, 0x0 }, // 2288 + { PseudoVFSGNJN_VFPR64_M1_MASK, VFSGNJN_VF, 0x0, 0x0 }, // 2289 + { PseudoVFSGNJN_VFPR16_M2, VFSGNJN_VF, 0x1, 0x0 }, // 2290 + { PseudoVFSGNJN_VFPR16_M2_MASK, VFSGNJN_VF, 0x1, 0x0 }, // 2291 + { PseudoVFSGNJN_VFPR32_M2, VFSGNJN_VF, 0x1, 0x0 }, // 2292 + { PseudoVFSGNJN_VFPR32_M2_MASK, VFSGNJN_VF, 0x1, 0x0 }, // 2293 + { PseudoVFSGNJN_VFPR64_M2, VFSGNJN_VF, 0x1, 0x0 }, // 2294 + { PseudoVFSGNJN_VFPR64_M2_MASK, VFSGNJN_VF, 0x1, 0x0 }, // 2295 + { PseudoVFSGNJN_VFPR16_M4, VFSGNJN_VF, 0x2, 0x0 }, // 2296 + { PseudoVFSGNJN_VFPR16_M4_MASK, VFSGNJN_VF, 0x2, 0x0 }, // 2297 + { PseudoVFSGNJN_VFPR32_M4, VFSGNJN_VF, 0x2, 0x0 }, // 2298 + { PseudoVFSGNJN_VFPR32_M4_MASK, VFSGNJN_VF, 0x2, 0x0 }, // 2299 + { PseudoVFSGNJN_VFPR64_M4, VFSGNJN_VF, 0x2, 0x0 }, // 2300 + { PseudoVFSGNJN_VFPR64_M4_MASK, VFSGNJN_VF, 0x2, 0x0 }, // 2301 + { PseudoVFSGNJN_VFPR16_M8, VFSGNJN_VF, 0x3, 0x0 }, // 2302 + { PseudoVFSGNJN_VFPR16_M8_MASK, VFSGNJN_VF, 0x3, 0x0 }, // 2303 + { PseudoVFSGNJN_VFPR32_M8, VFSGNJN_VF, 0x3, 0x0 }, // 2304 + { PseudoVFSGNJN_VFPR32_M8_MASK, VFSGNJN_VF, 0x3, 0x0 }, // 2305 + { PseudoVFSGNJN_VFPR64_M8, VFSGNJN_VF, 0x3, 0x0 }, // 2306 + { PseudoVFSGNJN_VFPR64_M8_MASK, VFSGNJN_VF, 0x3, 0x0 }, // 2307 + { PseudoVFSGNJN_VFPR16_MF4, VFSGNJN_VF, 0x6, 0x0 }, // 2308 + { PseudoVFSGNJN_VFPR16_MF4_MASK, VFSGNJN_VF, 0x6, 0x0 }, // 2309 + { PseudoVFSGNJN_VFPR16_MF2, VFSGNJN_VF, 0x7, 0x0 }, // 2310 + { PseudoVFSGNJN_VFPR16_MF2_MASK, VFSGNJN_VF, 0x7, 0x0 }, // 2311 + { PseudoVFSGNJN_VFPR32_MF2, VFSGNJN_VF, 0x7, 0x0 }, // 2312 + { PseudoVFSGNJN_VFPR32_MF2_MASK, VFSGNJN_VF, 0x7, 0x0 }, // 2313 + { PseudoVFSGNJN_VV_M1, VFSGNJN_VV, 0x0, 0x0 }, // 2314 + { PseudoVFSGNJN_VV_M1_MASK, VFSGNJN_VV, 0x0, 0x0 }, // 2315 + { PseudoVFSGNJN_VV_M2, VFSGNJN_VV, 0x1, 0x0 }, // 2316 + { PseudoVFSGNJN_VV_M2_MASK, VFSGNJN_VV, 0x1, 0x0 }, // 2317 + { PseudoVFSGNJN_VV_M4, VFSGNJN_VV, 0x2, 0x0 }, // 2318 + { PseudoVFSGNJN_VV_M4_MASK, VFSGNJN_VV, 0x2, 0x0 }, // 2319 + { PseudoVFSGNJN_VV_M8, VFSGNJN_VV, 0x3, 0x0 }, // 2320 + { PseudoVFSGNJN_VV_M8_MASK, VFSGNJN_VV, 0x3, 0x0 }, // 2321 + { PseudoVFSGNJN_VV_MF4, VFSGNJN_VV, 0x6, 0x0 }, // 2322 + { PseudoVFSGNJN_VV_MF4_MASK, VFSGNJN_VV, 0x6, 0x0 }, // 2323 + { PseudoVFSGNJN_VV_MF2, VFSGNJN_VV, 0x7, 0x0 }, // 2324 + { PseudoVFSGNJN_VV_MF2_MASK, VFSGNJN_VV, 0x7, 0x0 }, // 2325 + { PseudoVFSGNJX_VFPR16_M1, VFSGNJX_VF, 0x0, 0x0 }, // 2326 + { PseudoVFSGNJX_VFPR16_M1_MASK, VFSGNJX_VF, 0x0, 0x0 }, // 2327 + { PseudoVFSGNJX_VFPR32_M1, VFSGNJX_VF, 0x0, 0x0 }, // 2328 + { PseudoVFSGNJX_VFPR32_M1_MASK, VFSGNJX_VF, 0x0, 0x0 }, // 2329 + { PseudoVFSGNJX_VFPR64_M1, VFSGNJX_VF, 0x0, 0x0 }, // 2330 + { PseudoVFSGNJX_VFPR64_M1_MASK, VFSGNJX_VF, 0x0, 0x0 }, // 2331 + { PseudoVFSGNJX_VFPR16_M2, VFSGNJX_VF, 0x1, 0x0 }, // 2332 + { PseudoVFSGNJX_VFPR16_M2_MASK, VFSGNJX_VF, 0x1, 0x0 }, // 2333 + { PseudoVFSGNJX_VFPR32_M2, VFSGNJX_VF, 0x1, 0x0 }, // 2334 + { PseudoVFSGNJX_VFPR32_M2_MASK, VFSGNJX_VF, 0x1, 0x0 }, // 2335 + { PseudoVFSGNJX_VFPR64_M2, VFSGNJX_VF, 0x1, 0x0 }, // 2336 + { PseudoVFSGNJX_VFPR64_M2_MASK, VFSGNJX_VF, 0x1, 0x0 }, // 2337 + { PseudoVFSGNJX_VFPR16_M4, VFSGNJX_VF, 0x2, 0x0 }, // 2338 + { PseudoVFSGNJX_VFPR16_M4_MASK, VFSGNJX_VF, 0x2, 0x0 }, // 2339 + { PseudoVFSGNJX_VFPR32_M4, VFSGNJX_VF, 0x2, 0x0 }, // 2340 + { PseudoVFSGNJX_VFPR32_M4_MASK, VFSGNJX_VF, 0x2, 0x0 }, // 2341 + { PseudoVFSGNJX_VFPR64_M4, VFSGNJX_VF, 0x2, 0x0 }, // 2342 + { PseudoVFSGNJX_VFPR64_M4_MASK, VFSGNJX_VF, 0x2, 0x0 }, // 2343 + { PseudoVFSGNJX_VFPR16_M8, VFSGNJX_VF, 0x3, 0x0 }, // 2344 + { PseudoVFSGNJX_VFPR16_M8_MASK, VFSGNJX_VF, 0x3, 0x0 }, // 2345 + { PseudoVFSGNJX_VFPR32_M8, VFSGNJX_VF, 0x3, 0x0 }, // 2346 + { PseudoVFSGNJX_VFPR32_M8_MASK, VFSGNJX_VF, 0x3, 0x0 }, // 2347 + { PseudoVFSGNJX_VFPR64_M8, VFSGNJX_VF, 0x3, 0x0 }, // 2348 + { PseudoVFSGNJX_VFPR64_M8_MASK, VFSGNJX_VF, 0x3, 0x0 }, // 2349 + { PseudoVFSGNJX_VFPR16_MF4, VFSGNJX_VF, 0x6, 0x0 }, // 2350 + { PseudoVFSGNJX_VFPR16_MF4_MASK, VFSGNJX_VF, 0x6, 0x0 }, // 2351 + { PseudoVFSGNJX_VFPR16_MF2, VFSGNJX_VF, 0x7, 0x0 }, // 2352 + { PseudoVFSGNJX_VFPR16_MF2_MASK, VFSGNJX_VF, 0x7, 0x0 }, // 2353 + { PseudoVFSGNJX_VFPR32_MF2, VFSGNJX_VF, 0x7, 0x0 }, // 2354 + { PseudoVFSGNJX_VFPR32_MF2_MASK, VFSGNJX_VF, 0x7, 0x0 }, // 2355 + { PseudoVFSGNJX_VV_M1, VFSGNJX_VV, 0x0, 0x0 }, // 2356 + { PseudoVFSGNJX_VV_M1_MASK, VFSGNJX_VV, 0x0, 0x0 }, // 2357 + { PseudoVFSGNJX_VV_M2, VFSGNJX_VV, 0x1, 0x0 }, // 2358 + { PseudoVFSGNJX_VV_M2_MASK, VFSGNJX_VV, 0x1, 0x0 }, // 2359 + { PseudoVFSGNJX_VV_M4, VFSGNJX_VV, 0x2, 0x0 }, // 2360 + { PseudoVFSGNJX_VV_M4_MASK, VFSGNJX_VV, 0x2, 0x0 }, // 2361 + { PseudoVFSGNJX_VV_M8, VFSGNJX_VV, 0x3, 0x0 }, // 2362 + { PseudoVFSGNJX_VV_M8_MASK, VFSGNJX_VV, 0x3, 0x0 }, // 2363 + { PseudoVFSGNJX_VV_MF4, VFSGNJX_VV, 0x6, 0x0 }, // 2364 + { PseudoVFSGNJX_VV_MF4_MASK, VFSGNJX_VV, 0x6, 0x0 }, // 2365 + { PseudoVFSGNJX_VV_MF2, VFSGNJX_VV, 0x7, 0x0 }, // 2366 + { PseudoVFSGNJX_VV_MF2_MASK, VFSGNJX_VV, 0x7, 0x0 }, // 2367 + { PseudoVFSGNJ_VFPR16_M1, VFSGNJ_VF, 0x0, 0x0 }, // 2368 + { PseudoVFSGNJ_VFPR16_M1_MASK, VFSGNJ_VF, 0x0, 0x0 }, // 2369 + { PseudoVFSGNJ_VFPR32_M1, VFSGNJ_VF, 0x0, 0x0 }, // 2370 + { PseudoVFSGNJ_VFPR32_M1_MASK, VFSGNJ_VF, 0x0, 0x0 }, // 2371 + { PseudoVFSGNJ_VFPR64_M1, VFSGNJ_VF, 0x0, 0x0 }, // 2372 + { PseudoVFSGNJ_VFPR64_M1_MASK, VFSGNJ_VF, 0x0, 0x0 }, // 2373 + { PseudoVFSGNJ_VFPR16_M2, VFSGNJ_VF, 0x1, 0x0 }, // 2374 + { PseudoVFSGNJ_VFPR16_M2_MASK, VFSGNJ_VF, 0x1, 0x0 }, // 2375 + { PseudoVFSGNJ_VFPR32_M2, VFSGNJ_VF, 0x1, 0x0 }, // 2376 + { PseudoVFSGNJ_VFPR32_M2_MASK, VFSGNJ_VF, 0x1, 0x0 }, // 2377 + { PseudoVFSGNJ_VFPR64_M2, VFSGNJ_VF, 0x1, 0x0 }, // 2378 + { PseudoVFSGNJ_VFPR64_M2_MASK, VFSGNJ_VF, 0x1, 0x0 }, // 2379 + { PseudoVFSGNJ_VFPR16_M4, VFSGNJ_VF, 0x2, 0x0 }, // 2380 + { PseudoVFSGNJ_VFPR16_M4_MASK, VFSGNJ_VF, 0x2, 0x0 }, // 2381 + { PseudoVFSGNJ_VFPR32_M4, VFSGNJ_VF, 0x2, 0x0 }, // 2382 + { PseudoVFSGNJ_VFPR32_M4_MASK, VFSGNJ_VF, 0x2, 0x0 }, // 2383 + { PseudoVFSGNJ_VFPR64_M4, VFSGNJ_VF, 0x2, 0x0 }, // 2384 + { PseudoVFSGNJ_VFPR64_M4_MASK, VFSGNJ_VF, 0x2, 0x0 }, // 2385 + { PseudoVFSGNJ_VFPR16_M8, VFSGNJ_VF, 0x3, 0x0 }, // 2386 + { PseudoVFSGNJ_VFPR16_M8_MASK, VFSGNJ_VF, 0x3, 0x0 }, // 2387 + { PseudoVFSGNJ_VFPR32_M8, VFSGNJ_VF, 0x3, 0x0 }, // 2388 + { PseudoVFSGNJ_VFPR32_M8_MASK, VFSGNJ_VF, 0x3, 0x0 }, // 2389 + { PseudoVFSGNJ_VFPR64_M8, VFSGNJ_VF, 0x3, 0x0 }, // 2390 + { PseudoVFSGNJ_VFPR64_M8_MASK, VFSGNJ_VF, 0x3, 0x0 }, // 2391 + { PseudoVFSGNJ_VFPR16_MF4, VFSGNJ_VF, 0x6, 0x0 }, // 2392 + { PseudoVFSGNJ_VFPR16_MF4_MASK, VFSGNJ_VF, 0x6, 0x0 }, // 2393 + { PseudoVFSGNJ_VFPR16_MF2, VFSGNJ_VF, 0x7, 0x0 }, // 2394 + { PseudoVFSGNJ_VFPR16_MF2_MASK, VFSGNJ_VF, 0x7, 0x0 }, // 2395 + { PseudoVFSGNJ_VFPR32_MF2, VFSGNJ_VF, 0x7, 0x0 }, // 2396 + { PseudoVFSGNJ_VFPR32_MF2_MASK, VFSGNJ_VF, 0x7, 0x0 }, // 2397 + { PseudoVFSGNJ_VV_M1, VFSGNJ_VV, 0x0, 0x0 }, // 2398 + { PseudoVFSGNJ_VV_M1_MASK, VFSGNJ_VV, 0x0, 0x0 }, // 2399 + { PseudoVFSGNJ_VV_M2, VFSGNJ_VV, 0x1, 0x0 }, // 2400 + { PseudoVFSGNJ_VV_M2_MASK, VFSGNJ_VV, 0x1, 0x0 }, // 2401 + { PseudoVFSGNJ_VV_M4, VFSGNJ_VV, 0x2, 0x0 }, // 2402 + { PseudoVFSGNJ_VV_M4_MASK, VFSGNJ_VV, 0x2, 0x0 }, // 2403 + { PseudoVFSGNJ_VV_M8, VFSGNJ_VV, 0x3, 0x0 }, // 2404 + { PseudoVFSGNJ_VV_M8_MASK, VFSGNJ_VV, 0x3, 0x0 }, // 2405 + { PseudoVFSGNJ_VV_MF4, VFSGNJ_VV, 0x6, 0x0 }, // 2406 + { PseudoVFSGNJ_VV_MF4_MASK, VFSGNJ_VV, 0x6, 0x0 }, // 2407 + { PseudoVFSGNJ_VV_MF2, VFSGNJ_VV, 0x7, 0x0 }, // 2408 + { PseudoVFSGNJ_VV_MF2_MASK, VFSGNJ_VV, 0x7, 0x0 }, // 2409 + { PseudoVFSLIDE1DOWN_VFPR16_M1, VFSLIDE1DOWN_VF, 0x0, 0x0 }, // 2410 + { PseudoVFSLIDE1DOWN_VFPR16_M1_MASK, VFSLIDE1DOWN_VF, 0x0, 0x0 }, // 2411 + { PseudoVFSLIDE1DOWN_VFPR32_M1, VFSLIDE1DOWN_VF, 0x0, 0x0 }, // 2412 + { PseudoVFSLIDE1DOWN_VFPR32_M1_MASK, VFSLIDE1DOWN_VF, 0x0, 0x0 }, // 2413 + { PseudoVFSLIDE1DOWN_VFPR64_M1, VFSLIDE1DOWN_VF, 0x0, 0x0 }, // 2414 + { PseudoVFSLIDE1DOWN_VFPR64_M1_MASK, VFSLIDE1DOWN_VF, 0x0, 0x0 }, // 2415 + { PseudoVFSLIDE1DOWN_VFPR16_M2, VFSLIDE1DOWN_VF, 0x1, 0x0 }, // 2416 + { PseudoVFSLIDE1DOWN_VFPR16_M2_MASK, VFSLIDE1DOWN_VF, 0x1, 0x0 }, // 2417 + { PseudoVFSLIDE1DOWN_VFPR32_M2, VFSLIDE1DOWN_VF, 0x1, 0x0 }, // 2418 + { PseudoVFSLIDE1DOWN_VFPR32_M2_MASK, VFSLIDE1DOWN_VF, 0x1, 0x0 }, // 2419 + { PseudoVFSLIDE1DOWN_VFPR64_M2, VFSLIDE1DOWN_VF, 0x1, 0x0 }, // 2420 + { PseudoVFSLIDE1DOWN_VFPR64_M2_MASK, VFSLIDE1DOWN_VF, 0x1, 0x0 }, // 2421 + { PseudoVFSLIDE1DOWN_VFPR16_M4, VFSLIDE1DOWN_VF, 0x2, 0x0 }, // 2422 + { PseudoVFSLIDE1DOWN_VFPR16_M4_MASK, VFSLIDE1DOWN_VF, 0x2, 0x0 }, // 2423 + { PseudoVFSLIDE1DOWN_VFPR32_M4, VFSLIDE1DOWN_VF, 0x2, 0x0 }, // 2424 + { PseudoVFSLIDE1DOWN_VFPR32_M4_MASK, VFSLIDE1DOWN_VF, 0x2, 0x0 }, // 2425 + { PseudoVFSLIDE1DOWN_VFPR64_M4, VFSLIDE1DOWN_VF, 0x2, 0x0 }, // 2426 + { PseudoVFSLIDE1DOWN_VFPR64_M4_MASK, VFSLIDE1DOWN_VF, 0x2, 0x0 }, // 2427 + { PseudoVFSLIDE1DOWN_VFPR16_M8, VFSLIDE1DOWN_VF, 0x3, 0x0 }, // 2428 + { PseudoVFSLIDE1DOWN_VFPR16_M8_MASK, VFSLIDE1DOWN_VF, 0x3, 0x0 }, // 2429 + { PseudoVFSLIDE1DOWN_VFPR32_M8, VFSLIDE1DOWN_VF, 0x3, 0x0 }, // 2430 + { PseudoVFSLIDE1DOWN_VFPR32_M8_MASK, VFSLIDE1DOWN_VF, 0x3, 0x0 }, // 2431 + { PseudoVFSLIDE1DOWN_VFPR64_M8, VFSLIDE1DOWN_VF, 0x3, 0x0 }, // 2432 + { PseudoVFSLIDE1DOWN_VFPR64_M8_MASK, VFSLIDE1DOWN_VF, 0x3, 0x0 }, // 2433 + { PseudoVFSLIDE1DOWN_VFPR16_MF4, VFSLIDE1DOWN_VF, 0x6, 0x0 }, // 2434 + { PseudoVFSLIDE1DOWN_VFPR16_MF4_MASK, VFSLIDE1DOWN_VF, 0x6, 0x0 }, // 2435 + { PseudoVFSLIDE1DOWN_VFPR16_MF2, VFSLIDE1DOWN_VF, 0x7, 0x0 }, // 2436 + { PseudoVFSLIDE1DOWN_VFPR16_MF2_MASK, VFSLIDE1DOWN_VF, 0x7, 0x0 }, // 2437 + { PseudoVFSLIDE1DOWN_VFPR32_MF2, VFSLIDE1DOWN_VF, 0x7, 0x0 }, // 2438 + { PseudoVFSLIDE1DOWN_VFPR32_MF2_MASK, VFSLIDE1DOWN_VF, 0x7, 0x0 }, // 2439 + { PseudoVFSLIDE1UP_VFPR16_M1, VFSLIDE1UP_VF, 0x0, 0x0 }, // 2440 + { PseudoVFSLIDE1UP_VFPR16_M1_MASK, VFSLIDE1UP_VF, 0x0, 0x0 }, // 2441 + { PseudoVFSLIDE1UP_VFPR32_M1, VFSLIDE1UP_VF, 0x0, 0x0 }, // 2442 + { PseudoVFSLIDE1UP_VFPR32_M1_MASK, VFSLIDE1UP_VF, 0x0, 0x0 }, // 2443 + { PseudoVFSLIDE1UP_VFPR64_M1, VFSLIDE1UP_VF, 0x0, 0x0 }, // 2444 + { PseudoVFSLIDE1UP_VFPR64_M1_MASK, VFSLIDE1UP_VF, 0x0, 0x0 }, // 2445 + { PseudoVFSLIDE1UP_VFPR16_M2, VFSLIDE1UP_VF, 0x1, 0x0 }, // 2446 + { PseudoVFSLIDE1UP_VFPR16_M2_MASK, VFSLIDE1UP_VF, 0x1, 0x0 }, // 2447 + { PseudoVFSLIDE1UP_VFPR32_M2, VFSLIDE1UP_VF, 0x1, 0x0 }, // 2448 + { PseudoVFSLIDE1UP_VFPR32_M2_MASK, VFSLIDE1UP_VF, 0x1, 0x0 }, // 2449 + { PseudoVFSLIDE1UP_VFPR64_M2, VFSLIDE1UP_VF, 0x1, 0x0 }, // 2450 + { PseudoVFSLIDE1UP_VFPR64_M2_MASK, VFSLIDE1UP_VF, 0x1, 0x0 }, // 2451 + { PseudoVFSLIDE1UP_VFPR16_M4, VFSLIDE1UP_VF, 0x2, 0x0 }, // 2452 + { PseudoVFSLIDE1UP_VFPR16_M4_MASK, VFSLIDE1UP_VF, 0x2, 0x0 }, // 2453 + { PseudoVFSLIDE1UP_VFPR32_M4, VFSLIDE1UP_VF, 0x2, 0x0 }, // 2454 + { PseudoVFSLIDE1UP_VFPR32_M4_MASK, VFSLIDE1UP_VF, 0x2, 0x0 }, // 2455 + { PseudoVFSLIDE1UP_VFPR64_M4, VFSLIDE1UP_VF, 0x2, 0x0 }, // 2456 + { PseudoVFSLIDE1UP_VFPR64_M4_MASK, VFSLIDE1UP_VF, 0x2, 0x0 }, // 2457 + { PseudoVFSLIDE1UP_VFPR16_M8, VFSLIDE1UP_VF, 0x3, 0x0 }, // 2458 + { PseudoVFSLIDE1UP_VFPR16_M8_MASK, VFSLIDE1UP_VF, 0x3, 0x0 }, // 2459 + { PseudoVFSLIDE1UP_VFPR32_M8, VFSLIDE1UP_VF, 0x3, 0x0 }, // 2460 + { PseudoVFSLIDE1UP_VFPR32_M8_MASK, VFSLIDE1UP_VF, 0x3, 0x0 }, // 2461 + { PseudoVFSLIDE1UP_VFPR64_M8, VFSLIDE1UP_VF, 0x3, 0x0 }, // 2462 + { PseudoVFSLIDE1UP_VFPR64_M8_MASK, VFSLIDE1UP_VF, 0x3, 0x0 }, // 2463 + { PseudoVFSLIDE1UP_VFPR16_MF4, VFSLIDE1UP_VF, 0x6, 0x0 }, // 2464 + { PseudoVFSLIDE1UP_VFPR16_MF4_MASK, VFSLIDE1UP_VF, 0x6, 0x0 }, // 2465 + { PseudoVFSLIDE1UP_VFPR16_MF2, VFSLIDE1UP_VF, 0x7, 0x0 }, // 2466 + { PseudoVFSLIDE1UP_VFPR16_MF2_MASK, VFSLIDE1UP_VF, 0x7, 0x0 }, // 2467 + { PseudoVFSLIDE1UP_VFPR32_MF2, VFSLIDE1UP_VF, 0x7, 0x0 }, // 2468 + { PseudoVFSLIDE1UP_VFPR32_MF2_MASK, VFSLIDE1UP_VF, 0x7, 0x0 }, // 2469 + { PseudoVFSQRT_V_M1_E16, VFSQRT_V, 0x0, 0x10 }, // 2470 + { PseudoVFSQRT_V_M1_E16_MASK, VFSQRT_V, 0x0, 0x10 }, // 2471 + { PseudoVFSQRT_V_M1_E32, VFSQRT_V, 0x0, 0x20 }, // 2472 + { PseudoVFSQRT_V_M1_E32_MASK, VFSQRT_V, 0x0, 0x20 }, // 2473 + { PseudoVFSQRT_V_M1_E64, VFSQRT_V, 0x0, 0x40 }, // 2474 + { PseudoVFSQRT_V_M1_E64_MASK, VFSQRT_V, 0x0, 0x40 }, // 2475 + { PseudoVFSQRT_V_M2_E16, VFSQRT_V, 0x1, 0x10 }, // 2476 + { PseudoVFSQRT_V_M2_E16_MASK, VFSQRT_V, 0x1, 0x10 }, // 2477 + { PseudoVFSQRT_V_M2_E32, VFSQRT_V, 0x1, 0x20 }, // 2478 + { PseudoVFSQRT_V_M2_E32_MASK, VFSQRT_V, 0x1, 0x20 }, // 2479 + { PseudoVFSQRT_V_M2_E64, VFSQRT_V, 0x1, 0x40 }, // 2480 + { PseudoVFSQRT_V_M2_E64_MASK, VFSQRT_V, 0x1, 0x40 }, // 2481 + { PseudoVFSQRT_V_M4_E16, VFSQRT_V, 0x2, 0x10 }, // 2482 + { PseudoVFSQRT_V_M4_E16_MASK, VFSQRT_V, 0x2, 0x10 }, // 2483 + { PseudoVFSQRT_V_M4_E32, VFSQRT_V, 0x2, 0x20 }, // 2484 + { PseudoVFSQRT_V_M4_E32_MASK, VFSQRT_V, 0x2, 0x20 }, // 2485 + { PseudoVFSQRT_V_M4_E64, VFSQRT_V, 0x2, 0x40 }, // 2486 + { PseudoVFSQRT_V_M4_E64_MASK, VFSQRT_V, 0x2, 0x40 }, // 2487 + { PseudoVFSQRT_V_M8_E16, VFSQRT_V, 0x3, 0x10 }, // 2488 + { PseudoVFSQRT_V_M8_E16_MASK, VFSQRT_V, 0x3, 0x10 }, // 2489 + { PseudoVFSQRT_V_M8_E32, VFSQRT_V, 0x3, 0x20 }, // 2490 + { PseudoVFSQRT_V_M8_E32_MASK, VFSQRT_V, 0x3, 0x20 }, // 2491 + { PseudoVFSQRT_V_M8_E64, VFSQRT_V, 0x3, 0x40 }, // 2492 + { PseudoVFSQRT_V_M8_E64_MASK, VFSQRT_V, 0x3, 0x40 }, // 2493 + { PseudoVFSQRT_V_MF4_E16, VFSQRT_V, 0x6, 0x10 }, // 2494 + { PseudoVFSQRT_V_MF4_E16_MASK, VFSQRT_V, 0x6, 0x10 }, // 2495 + { PseudoVFSQRT_V_MF2_E16, VFSQRT_V, 0x7, 0x10 }, // 2496 + { PseudoVFSQRT_V_MF2_E16_MASK, VFSQRT_V, 0x7, 0x10 }, // 2497 + { PseudoVFSQRT_V_MF2_E32, VFSQRT_V, 0x7, 0x20 }, // 2498 + { PseudoVFSQRT_V_MF2_E32_MASK, VFSQRT_V, 0x7, 0x20 }, // 2499 + { PseudoVFSUB_VFPR16_M1, VFSUB_VF, 0x0, 0x0 }, // 2500 + { PseudoVFSUB_VFPR16_M1_MASK, VFSUB_VF, 0x0, 0x0 }, // 2501 + { PseudoVFSUB_VFPR32_M1, VFSUB_VF, 0x0, 0x0 }, // 2502 + { PseudoVFSUB_VFPR32_M1_MASK, VFSUB_VF, 0x0, 0x0 }, // 2503 + { PseudoVFSUB_VFPR64_M1, VFSUB_VF, 0x0, 0x0 }, // 2504 + { PseudoVFSUB_VFPR64_M1_MASK, VFSUB_VF, 0x0, 0x0 }, // 2505 + { PseudoVFSUB_VFPR16_M2, VFSUB_VF, 0x1, 0x0 }, // 2506 + { PseudoVFSUB_VFPR16_M2_MASK, VFSUB_VF, 0x1, 0x0 }, // 2507 + { PseudoVFSUB_VFPR32_M2, VFSUB_VF, 0x1, 0x0 }, // 2508 + { PseudoVFSUB_VFPR32_M2_MASK, VFSUB_VF, 0x1, 0x0 }, // 2509 + { PseudoVFSUB_VFPR64_M2, VFSUB_VF, 0x1, 0x0 }, // 2510 + { PseudoVFSUB_VFPR64_M2_MASK, VFSUB_VF, 0x1, 0x0 }, // 2511 + { PseudoVFSUB_VFPR16_M4, VFSUB_VF, 0x2, 0x0 }, // 2512 + { PseudoVFSUB_VFPR16_M4_MASK, VFSUB_VF, 0x2, 0x0 }, // 2513 + { PseudoVFSUB_VFPR32_M4, VFSUB_VF, 0x2, 0x0 }, // 2514 + { PseudoVFSUB_VFPR32_M4_MASK, VFSUB_VF, 0x2, 0x0 }, // 2515 + { PseudoVFSUB_VFPR64_M4, VFSUB_VF, 0x2, 0x0 }, // 2516 + { PseudoVFSUB_VFPR64_M4_MASK, VFSUB_VF, 0x2, 0x0 }, // 2517 + { PseudoVFSUB_VFPR16_M8, VFSUB_VF, 0x3, 0x0 }, // 2518 + { PseudoVFSUB_VFPR16_M8_MASK, VFSUB_VF, 0x3, 0x0 }, // 2519 + { PseudoVFSUB_VFPR32_M8, VFSUB_VF, 0x3, 0x0 }, // 2520 + { PseudoVFSUB_VFPR32_M8_MASK, VFSUB_VF, 0x3, 0x0 }, // 2521 + { PseudoVFSUB_VFPR64_M8, VFSUB_VF, 0x3, 0x0 }, // 2522 + { PseudoVFSUB_VFPR64_M8_MASK, VFSUB_VF, 0x3, 0x0 }, // 2523 + { PseudoVFSUB_VFPR16_MF4, VFSUB_VF, 0x6, 0x0 }, // 2524 + { PseudoVFSUB_VFPR16_MF4_MASK, VFSUB_VF, 0x6, 0x0 }, // 2525 + { PseudoVFSUB_VFPR16_MF2, VFSUB_VF, 0x7, 0x0 }, // 2526 + { PseudoVFSUB_VFPR16_MF2_MASK, VFSUB_VF, 0x7, 0x0 }, // 2527 + { PseudoVFSUB_VFPR32_MF2, VFSUB_VF, 0x7, 0x0 }, // 2528 + { PseudoVFSUB_VFPR32_MF2_MASK, VFSUB_VF, 0x7, 0x0 }, // 2529 + { PseudoVFSUB_VV_M1, VFSUB_VV, 0x0, 0x0 }, // 2530 + { PseudoVFSUB_VV_M1_MASK, VFSUB_VV, 0x0, 0x0 }, // 2531 + { PseudoVFSUB_VV_M2, VFSUB_VV, 0x1, 0x0 }, // 2532 + { PseudoVFSUB_VV_M2_MASK, VFSUB_VV, 0x1, 0x0 }, // 2533 + { PseudoVFSUB_VV_M4, VFSUB_VV, 0x2, 0x0 }, // 2534 + { PseudoVFSUB_VV_M4_MASK, VFSUB_VV, 0x2, 0x0 }, // 2535 + { PseudoVFSUB_VV_M8, VFSUB_VV, 0x3, 0x0 }, // 2536 + { PseudoVFSUB_VV_M8_MASK, VFSUB_VV, 0x3, 0x0 }, // 2537 + { PseudoVFSUB_VV_MF4, VFSUB_VV, 0x6, 0x0 }, // 2538 + { PseudoVFSUB_VV_MF4_MASK, VFSUB_VV, 0x6, 0x0 }, // 2539 + { PseudoVFSUB_VV_MF2, VFSUB_VV, 0x7, 0x0 }, // 2540 + { PseudoVFSUB_VV_MF2_MASK, VFSUB_VV, 0x7, 0x0 }, // 2541 + { PseudoVFWADD_VFPR16_M1, VFWADD_VF, 0x0, 0x0 }, // 2542 + { PseudoVFWADD_VFPR16_M1_MASK, VFWADD_VF, 0x0, 0x0 }, // 2543 + { PseudoVFWADD_VFPR32_M1, VFWADD_VF, 0x0, 0x0 }, // 2544 + { PseudoVFWADD_VFPR32_M1_MASK, VFWADD_VF, 0x0, 0x0 }, // 2545 + { PseudoVFWADD_VFPR16_M2, VFWADD_VF, 0x1, 0x0 }, // 2546 + { PseudoVFWADD_VFPR16_M2_MASK, VFWADD_VF, 0x1, 0x0 }, // 2547 + { PseudoVFWADD_VFPR32_M2, VFWADD_VF, 0x1, 0x0 }, // 2548 + { PseudoVFWADD_VFPR32_M2_MASK, VFWADD_VF, 0x1, 0x0 }, // 2549 + { PseudoVFWADD_VFPR16_M4, VFWADD_VF, 0x2, 0x0 }, // 2550 + { PseudoVFWADD_VFPR16_M4_MASK, VFWADD_VF, 0x2, 0x0 }, // 2551 + { PseudoVFWADD_VFPR32_M4, VFWADD_VF, 0x2, 0x0 }, // 2552 + { PseudoVFWADD_VFPR32_M4_MASK, VFWADD_VF, 0x2, 0x0 }, // 2553 + { PseudoVFWADD_VFPR16_MF4, VFWADD_VF, 0x6, 0x0 }, // 2554 + { PseudoVFWADD_VFPR16_MF4_MASK, VFWADD_VF, 0x6, 0x0 }, // 2555 + { PseudoVFWADD_VFPR16_MF2, VFWADD_VF, 0x7, 0x0 }, // 2556 + { PseudoVFWADD_VFPR16_MF2_MASK, VFWADD_VF, 0x7, 0x0 }, // 2557 + { PseudoVFWADD_VFPR32_MF2, VFWADD_VF, 0x7, 0x0 }, // 2558 + { PseudoVFWADD_VFPR32_MF2_MASK, VFWADD_VF, 0x7, 0x0 }, // 2559 + { PseudoVFWADD_VV_M1, VFWADD_VV, 0x0, 0x0 }, // 2560 + { PseudoVFWADD_VV_M1_MASK, VFWADD_VV, 0x0, 0x0 }, // 2561 + { PseudoVFWADD_VV_M2, VFWADD_VV, 0x1, 0x0 }, // 2562 + { PseudoVFWADD_VV_M2_MASK, VFWADD_VV, 0x1, 0x0 }, // 2563 + { PseudoVFWADD_VV_M4, VFWADD_VV, 0x2, 0x0 }, // 2564 + { PseudoVFWADD_VV_M4_MASK, VFWADD_VV, 0x2, 0x0 }, // 2565 + { PseudoVFWADD_VV_MF4, VFWADD_VV, 0x6, 0x0 }, // 2566 + { PseudoVFWADD_VV_MF4_MASK, VFWADD_VV, 0x6, 0x0 }, // 2567 + { PseudoVFWADD_VV_MF2, VFWADD_VV, 0x7, 0x0 }, // 2568 + { PseudoVFWADD_VV_MF2_MASK, VFWADD_VV, 0x7, 0x0 }, // 2569 + { PseudoVFWADD_WFPR16_M1, VFWADD_WF, 0x0, 0x0 }, // 2570 + { PseudoVFWADD_WFPR16_M1_MASK, VFWADD_WF, 0x0, 0x0 }, // 2571 + { PseudoVFWADD_WFPR32_M1, VFWADD_WF, 0x0, 0x0 }, // 2572 + { PseudoVFWADD_WFPR32_M1_MASK, VFWADD_WF, 0x0, 0x0 }, // 2573 + { PseudoVFWADD_WFPR16_M2, VFWADD_WF, 0x1, 0x0 }, // 2574 + { PseudoVFWADD_WFPR16_M2_MASK, VFWADD_WF, 0x1, 0x0 }, // 2575 + { PseudoVFWADD_WFPR32_M2, VFWADD_WF, 0x1, 0x0 }, // 2576 + { PseudoVFWADD_WFPR32_M2_MASK, VFWADD_WF, 0x1, 0x0 }, // 2577 + { PseudoVFWADD_WFPR16_M4, VFWADD_WF, 0x2, 0x0 }, // 2578 + { PseudoVFWADD_WFPR16_M4_MASK, VFWADD_WF, 0x2, 0x0 }, // 2579 + { PseudoVFWADD_WFPR32_M4, VFWADD_WF, 0x2, 0x0 }, // 2580 + { PseudoVFWADD_WFPR32_M4_MASK, VFWADD_WF, 0x2, 0x0 }, // 2581 + { PseudoVFWADD_WFPR16_MF4, VFWADD_WF, 0x6, 0x0 }, // 2582 + { PseudoVFWADD_WFPR16_MF4_MASK, VFWADD_WF, 0x6, 0x0 }, // 2583 + { PseudoVFWADD_WFPR16_MF2, VFWADD_WF, 0x7, 0x0 }, // 2584 + { PseudoVFWADD_WFPR16_MF2_MASK, VFWADD_WF, 0x7, 0x0 }, // 2585 + { PseudoVFWADD_WFPR32_MF2, VFWADD_WF, 0x7, 0x0 }, // 2586 + { PseudoVFWADD_WFPR32_MF2_MASK, VFWADD_WF, 0x7, 0x0 }, // 2587 + { PseudoVFWADD_WV_M1, VFWADD_WV, 0x0, 0x0 }, // 2588 + { PseudoVFWADD_WV_M1_MASK, VFWADD_WV, 0x0, 0x0 }, // 2589 + { PseudoVFWADD_WV_M1_MASK_TIED, VFWADD_WV, 0x0, 0x0 }, // 2590 + { PseudoVFWADD_WV_M1_TIED, VFWADD_WV, 0x0, 0x0 }, // 2591 + { PseudoVFWADD_WV_M2, VFWADD_WV, 0x1, 0x0 }, // 2592 + { PseudoVFWADD_WV_M2_MASK, VFWADD_WV, 0x1, 0x0 }, // 2593 + { PseudoVFWADD_WV_M2_MASK_TIED, VFWADD_WV, 0x1, 0x0 }, // 2594 + { PseudoVFWADD_WV_M2_TIED, VFWADD_WV, 0x1, 0x0 }, // 2595 + { PseudoVFWADD_WV_M4, VFWADD_WV, 0x2, 0x0 }, // 2596 + { PseudoVFWADD_WV_M4_MASK, VFWADD_WV, 0x2, 0x0 }, // 2597 + { PseudoVFWADD_WV_M4_MASK_TIED, VFWADD_WV, 0x2, 0x0 }, // 2598 + { PseudoVFWADD_WV_M4_TIED, VFWADD_WV, 0x2, 0x0 }, // 2599 + { PseudoVFWADD_WV_MF4, VFWADD_WV, 0x6, 0x0 }, // 2600 + { PseudoVFWADD_WV_MF4_MASK, VFWADD_WV, 0x6, 0x0 }, // 2601 + { PseudoVFWADD_WV_MF4_MASK_TIED, VFWADD_WV, 0x6, 0x0 }, // 2602 + { PseudoVFWADD_WV_MF4_TIED, VFWADD_WV, 0x6, 0x0 }, // 2603 + { PseudoVFWADD_WV_MF2, VFWADD_WV, 0x7, 0x0 }, // 2604 + { PseudoVFWADD_WV_MF2_MASK, VFWADD_WV, 0x7, 0x0 }, // 2605 + { PseudoVFWADD_WV_MF2_MASK_TIED, VFWADD_WV, 0x7, 0x0 }, // 2606 + { PseudoVFWADD_WV_MF2_TIED, VFWADD_WV, 0x7, 0x0 }, // 2607 + { PseudoVFWCVTBF16_F_F_V_M1, VFWCVTBF16_F_F_V, 0x0, 0x0 }, // 2608 + { PseudoVFWCVTBF16_F_F_V_M1_MASK, VFWCVTBF16_F_F_V, 0x0, 0x0 }, // 2609 + { PseudoVFWCVTBF16_F_F_V_M2, VFWCVTBF16_F_F_V, 0x1, 0x0 }, // 2610 + { PseudoVFWCVTBF16_F_F_V_M2_MASK, VFWCVTBF16_F_F_V, 0x1, 0x0 }, // 2611 + { PseudoVFWCVTBF16_F_F_V_M4, VFWCVTBF16_F_F_V, 0x2, 0x0 }, // 2612 + { PseudoVFWCVTBF16_F_F_V_M4_MASK, VFWCVTBF16_F_F_V, 0x2, 0x0 }, // 2613 + { PseudoVFWCVTBF16_F_F_V_MF4, VFWCVTBF16_F_F_V, 0x6, 0x0 }, // 2614 + { PseudoVFWCVTBF16_F_F_V_MF4_MASK, VFWCVTBF16_F_F_V, 0x6, 0x0 }, // 2615 + { PseudoVFWCVTBF16_F_F_V_MF2, VFWCVTBF16_F_F_V, 0x7, 0x0 }, // 2616 + { PseudoVFWCVTBF16_F_F_V_MF2_MASK, VFWCVTBF16_F_F_V, 0x7, 0x0 }, // 2617 + { PseudoVFWCVT_F_F_V_M1, VFWCVT_F_F_V, 0x0, 0x0 }, // 2618 + { PseudoVFWCVT_F_F_V_M1_MASK, VFWCVT_F_F_V, 0x0, 0x0 }, // 2619 + { PseudoVFWCVT_F_F_V_M2, VFWCVT_F_F_V, 0x1, 0x0 }, // 2620 + { PseudoVFWCVT_F_F_V_M2_MASK, VFWCVT_F_F_V, 0x1, 0x0 }, // 2621 + { PseudoVFWCVT_F_F_V_M4, VFWCVT_F_F_V, 0x2, 0x0 }, // 2622 + { PseudoVFWCVT_F_F_V_M4_MASK, VFWCVT_F_F_V, 0x2, 0x0 }, // 2623 + { PseudoVFWCVT_F_F_V_MF4, VFWCVT_F_F_V, 0x6, 0x0 }, // 2624 + { PseudoVFWCVT_F_F_V_MF4_MASK, VFWCVT_F_F_V, 0x6, 0x0 }, // 2625 + { PseudoVFWCVT_F_F_V_MF2, VFWCVT_F_F_V, 0x7, 0x0 }, // 2626 + { PseudoVFWCVT_F_F_V_MF2_MASK, VFWCVT_F_F_V, 0x7, 0x0 }, // 2627 + { PseudoVFWCVT_F_XU_V_M1, VFWCVT_F_XU_V, 0x0, 0x0 }, // 2628 + { PseudoVFWCVT_F_XU_V_M1_MASK, VFWCVT_F_XU_V, 0x0, 0x0 }, // 2629 + { PseudoVFWCVT_F_XU_V_M2, VFWCVT_F_XU_V, 0x1, 0x0 }, // 2630 + { PseudoVFWCVT_F_XU_V_M2_MASK, VFWCVT_F_XU_V, 0x1, 0x0 }, // 2631 + { PseudoVFWCVT_F_XU_V_M4, VFWCVT_F_XU_V, 0x2, 0x0 }, // 2632 + { PseudoVFWCVT_F_XU_V_M4_MASK, VFWCVT_F_XU_V, 0x2, 0x0 }, // 2633 + { PseudoVFWCVT_F_XU_V_MF8, VFWCVT_F_XU_V, 0x5, 0x0 }, // 2634 + { PseudoVFWCVT_F_XU_V_MF8_MASK, VFWCVT_F_XU_V, 0x5, 0x0 }, // 2635 + { PseudoVFWCVT_F_XU_V_MF4, VFWCVT_F_XU_V, 0x6, 0x0 }, // 2636 + { PseudoVFWCVT_F_XU_V_MF4_MASK, VFWCVT_F_XU_V, 0x6, 0x0 }, // 2637 + { PseudoVFWCVT_F_XU_V_MF2, VFWCVT_F_XU_V, 0x7, 0x0 }, // 2638 + { PseudoVFWCVT_F_XU_V_MF2_MASK, VFWCVT_F_XU_V, 0x7, 0x0 }, // 2639 + { PseudoVFWCVT_F_X_V_M1, VFWCVT_F_X_V, 0x0, 0x0 }, // 2640 + { PseudoVFWCVT_F_X_V_M1_MASK, VFWCVT_F_X_V, 0x0, 0x0 }, // 2641 + { PseudoVFWCVT_F_X_V_M2, VFWCVT_F_X_V, 0x1, 0x0 }, // 2642 + { PseudoVFWCVT_F_X_V_M2_MASK, VFWCVT_F_X_V, 0x1, 0x0 }, // 2643 + { PseudoVFWCVT_F_X_V_M4, VFWCVT_F_X_V, 0x2, 0x0 }, // 2644 + { PseudoVFWCVT_F_X_V_M4_MASK, VFWCVT_F_X_V, 0x2, 0x0 }, // 2645 + { PseudoVFWCVT_F_X_V_MF8, VFWCVT_F_X_V, 0x5, 0x0 }, // 2646 + { PseudoVFWCVT_F_X_V_MF8_MASK, VFWCVT_F_X_V, 0x5, 0x0 }, // 2647 + { PseudoVFWCVT_F_X_V_MF4, VFWCVT_F_X_V, 0x6, 0x0 }, // 2648 + { PseudoVFWCVT_F_X_V_MF4_MASK, VFWCVT_F_X_V, 0x6, 0x0 }, // 2649 + { PseudoVFWCVT_F_X_V_MF2, VFWCVT_F_X_V, 0x7, 0x0 }, // 2650 + { PseudoVFWCVT_F_X_V_MF2_MASK, VFWCVT_F_X_V, 0x7, 0x0 }, // 2651 + { PseudoVFWCVT_RTZ_XU_F_V_M1, VFWCVT_RTZ_XU_F_V, 0x0, 0x0 }, // 2652 + { PseudoVFWCVT_RTZ_XU_F_V_M1_MASK, VFWCVT_RTZ_XU_F_V, 0x0, 0x0 }, // 2653 + { PseudoVFWCVT_RTZ_XU_F_V_M2, VFWCVT_RTZ_XU_F_V, 0x1, 0x0 }, // 2654 + { PseudoVFWCVT_RTZ_XU_F_V_M2_MASK, VFWCVT_RTZ_XU_F_V, 0x1, 0x0 }, // 2655 + { PseudoVFWCVT_RTZ_XU_F_V_M4, VFWCVT_RTZ_XU_F_V, 0x2, 0x0 }, // 2656 + { PseudoVFWCVT_RTZ_XU_F_V_M4_MASK, VFWCVT_RTZ_XU_F_V, 0x2, 0x0 }, // 2657 + { PseudoVFWCVT_RTZ_XU_F_V_MF4, VFWCVT_RTZ_XU_F_V, 0x6, 0x0 }, // 2658 + { PseudoVFWCVT_RTZ_XU_F_V_MF4_MASK, VFWCVT_RTZ_XU_F_V, 0x6, 0x0 }, // 2659 + { PseudoVFWCVT_RTZ_XU_F_V_MF2, VFWCVT_RTZ_XU_F_V, 0x7, 0x0 }, // 2660 + { PseudoVFWCVT_RTZ_XU_F_V_MF2_MASK, VFWCVT_RTZ_XU_F_V, 0x7, 0x0 }, // 2661 + { PseudoVFWCVT_RTZ_X_F_V_M1, VFWCVT_RTZ_X_F_V, 0x0, 0x0 }, // 2662 + { PseudoVFWCVT_RTZ_X_F_V_M1_MASK, VFWCVT_RTZ_X_F_V, 0x0, 0x0 }, // 2663 + { PseudoVFWCVT_RTZ_X_F_V_M2, VFWCVT_RTZ_X_F_V, 0x1, 0x0 }, // 2664 + { PseudoVFWCVT_RTZ_X_F_V_M2_MASK, VFWCVT_RTZ_X_F_V, 0x1, 0x0 }, // 2665 + { PseudoVFWCVT_RTZ_X_F_V_M4, VFWCVT_RTZ_X_F_V, 0x2, 0x0 }, // 2666 + { PseudoVFWCVT_RTZ_X_F_V_M4_MASK, VFWCVT_RTZ_X_F_V, 0x2, 0x0 }, // 2667 + { PseudoVFWCVT_RTZ_X_F_V_MF4, VFWCVT_RTZ_X_F_V, 0x6, 0x0 }, // 2668 + { PseudoVFWCVT_RTZ_X_F_V_MF4_MASK, VFWCVT_RTZ_X_F_V, 0x6, 0x0 }, // 2669 + { PseudoVFWCVT_RTZ_X_F_V_MF2, VFWCVT_RTZ_X_F_V, 0x7, 0x0 }, // 2670 + { PseudoVFWCVT_RTZ_X_F_V_MF2_MASK, VFWCVT_RTZ_X_F_V, 0x7, 0x0 }, // 2671 + { PseudoVFWCVT_RM_XU_F_V_M1, VFWCVT_XU_F_V, 0x0, 0x0 }, // 2672 + { PseudoVFWCVT_RM_XU_F_V_M1_MASK, VFWCVT_XU_F_V, 0x0, 0x0 }, // 2673 + { PseudoVFWCVT_XU_F_V_M1, VFWCVT_XU_F_V, 0x0, 0x0 }, // 2674 + { PseudoVFWCVT_XU_F_V_M1_MASK, VFWCVT_XU_F_V, 0x0, 0x0 }, // 2675 + { PseudoVFWCVT_RM_XU_F_V_M2, VFWCVT_XU_F_V, 0x1, 0x0 }, // 2676 + { PseudoVFWCVT_RM_XU_F_V_M2_MASK, VFWCVT_XU_F_V, 0x1, 0x0 }, // 2677 + { PseudoVFWCVT_XU_F_V_M2, VFWCVT_XU_F_V, 0x1, 0x0 }, // 2678 + { PseudoVFWCVT_XU_F_V_M2_MASK, VFWCVT_XU_F_V, 0x1, 0x0 }, // 2679 + { PseudoVFWCVT_RM_XU_F_V_M4, VFWCVT_XU_F_V, 0x2, 0x0 }, // 2680 + { PseudoVFWCVT_RM_XU_F_V_M4_MASK, VFWCVT_XU_F_V, 0x2, 0x0 }, // 2681 + { PseudoVFWCVT_XU_F_V_M4, VFWCVT_XU_F_V, 0x2, 0x0 }, // 2682 + { PseudoVFWCVT_XU_F_V_M4_MASK, VFWCVT_XU_F_V, 0x2, 0x0 }, // 2683 + { PseudoVFWCVT_RM_XU_F_V_MF4, VFWCVT_XU_F_V, 0x6, 0x0 }, // 2684 + { PseudoVFWCVT_RM_XU_F_V_MF4_MASK, VFWCVT_XU_F_V, 0x6, 0x0 }, // 2685 + { PseudoVFWCVT_XU_F_V_MF4, VFWCVT_XU_F_V, 0x6, 0x0 }, // 2686 + { PseudoVFWCVT_XU_F_V_MF4_MASK, VFWCVT_XU_F_V, 0x6, 0x0 }, // 2687 + { PseudoVFWCVT_RM_XU_F_V_MF2, VFWCVT_XU_F_V, 0x7, 0x0 }, // 2688 + { PseudoVFWCVT_RM_XU_F_V_MF2_MASK, VFWCVT_XU_F_V, 0x7, 0x0 }, // 2689 + { PseudoVFWCVT_XU_F_V_MF2, VFWCVT_XU_F_V, 0x7, 0x0 }, // 2690 + { PseudoVFWCVT_XU_F_V_MF2_MASK, VFWCVT_XU_F_V, 0x7, 0x0 }, // 2691 + { PseudoVFWCVT_RM_X_F_V_M1, VFWCVT_X_F_V, 0x0, 0x0 }, // 2692 + { PseudoVFWCVT_RM_X_F_V_M1_MASK, VFWCVT_X_F_V, 0x0, 0x0 }, // 2693 + { PseudoVFWCVT_X_F_V_M1, VFWCVT_X_F_V, 0x0, 0x0 }, // 2694 + { PseudoVFWCVT_X_F_V_M1_MASK, VFWCVT_X_F_V, 0x0, 0x0 }, // 2695 + { PseudoVFWCVT_RM_X_F_V_M2, VFWCVT_X_F_V, 0x1, 0x0 }, // 2696 + { PseudoVFWCVT_RM_X_F_V_M2_MASK, VFWCVT_X_F_V, 0x1, 0x0 }, // 2697 + { PseudoVFWCVT_X_F_V_M2, VFWCVT_X_F_V, 0x1, 0x0 }, // 2698 + { PseudoVFWCVT_X_F_V_M2_MASK, VFWCVT_X_F_V, 0x1, 0x0 }, // 2699 + { PseudoVFWCVT_RM_X_F_V_M4, VFWCVT_X_F_V, 0x2, 0x0 }, // 2700 + { PseudoVFWCVT_RM_X_F_V_M4_MASK, VFWCVT_X_F_V, 0x2, 0x0 }, // 2701 + { PseudoVFWCVT_X_F_V_M4, VFWCVT_X_F_V, 0x2, 0x0 }, // 2702 + { PseudoVFWCVT_X_F_V_M4_MASK, VFWCVT_X_F_V, 0x2, 0x0 }, // 2703 + { PseudoVFWCVT_RM_X_F_V_MF4, VFWCVT_X_F_V, 0x6, 0x0 }, // 2704 + { PseudoVFWCVT_RM_X_F_V_MF4_MASK, VFWCVT_X_F_V, 0x6, 0x0 }, // 2705 + { PseudoVFWCVT_X_F_V_MF4, VFWCVT_X_F_V, 0x6, 0x0 }, // 2706 + { PseudoVFWCVT_X_F_V_MF4_MASK, VFWCVT_X_F_V, 0x6, 0x0 }, // 2707 + { PseudoVFWCVT_RM_X_F_V_MF2, VFWCVT_X_F_V, 0x7, 0x0 }, // 2708 + { PseudoVFWCVT_RM_X_F_V_MF2_MASK, VFWCVT_X_F_V, 0x7, 0x0 }, // 2709 + { PseudoVFWCVT_X_F_V_MF2, VFWCVT_X_F_V, 0x7, 0x0 }, // 2710 + { PseudoVFWCVT_X_F_V_MF2_MASK, VFWCVT_X_F_V, 0x7, 0x0 }, // 2711 + { PseudoVFWMACCBF16_VFPR16_M1, VFWMACCBF16_VF, 0x0, 0x0 }, // 2712 + { PseudoVFWMACCBF16_VFPR16_M1_MASK, VFWMACCBF16_VF, 0x0, 0x0 }, // 2713 + { PseudoVFWMACCBF16_VFPR16_M2, VFWMACCBF16_VF, 0x1, 0x0 }, // 2714 + { PseudoVFWMACCBF16_VFPR16_M2_MASK, VFWMACCBF16_VF, 0x1, 0x0 }, // 2715 + { PseudoVFWMACCBF16_VFPR16_M4, VFWMACCBF16_VF, 0x2, 0x0 }, // 2716 + { PseudoVFWMACCBF16_VFPR16_M4_MASK, VFWMACCBF16_VF, 0x2, 0x0 }, // 2717 + { PseudoVFWMACCBF16_VFPR16_MF4, VFWMACCBF16_VF, 0x6, 0x0 }, // 2718 + { PseudoVFWMACCBF16_VFPR16_MF4_MASK, VFWMACCBF16_VF, 0x6, 0x0 }, // 2719 + { PseudoVFWMACCBF16_VFPR16_MF2, VFWMACCBF16_VF, 0x7, 0x0 }, // 2720 + { PseudoVFWMACCBF16_VFPR16_MF2_MASK, VFWMACCBF16_VF, 0x7, 0x0 }, // 2721 + { PseudoVFWMACCBF16_VV_M1, VFWMACCBF16_VV, 0x0, 0x0 }, // 2722 + { PseudoVFWMACCBF16_VV_M1_MASK, VFWMACCBF16_VV, 0x0, 0x0 }, // 2723 + { PseudoVFWMACCBF16_VV_M2, VFWMACCBF16_VV, 0x1, 0x0 }, // 2724 + { PseudoVFWMACCBF16_VV_M2_MASK, VFWMACCBF16_VV, 0x1, 0x0 }, // 2725 + { PseudoVFWMACCBF16_VV_M4, VFWMACCBF16_VV, 0x2, 0x0 }, // 2726 + { PseudoVFWMACCBF16_VV_M4_MASK, VFWMACCBF16_VV, 0x2, 0x0 }, // 2727 + { PseudoVFWMACCBF16_VV_MF4, VFWMACCBF16_VV, 0x6, 0x0 }, // 2728 + { PseudoVFWMACCBF16_VV_MF4_MASK, VFWMACCBF16_VV, 0x6, 0x0 }, // 2729 + { PseudoVFWMACCBF16_VV_MF2, VFWMACCBF16_VV, 0x7, 0x0 }, // 2730 + { PseudoVFWMACCBF16_VV_MF2_MASK, VFWMACCBF16_VV, 0x7, 0x0 }, // 2731 + { PseudoVFWMACC_4x4x4_M1, VFWMACC_4x4x4, 0x0, 0x0 }, // 2732 + { PseudoVFWMACC_4x4x4_M2, VFWMACC_4x4x4, 0x1, 0x0 }, // 2733 + { PseudoVFWMACC_4x4x4_M4, VFWMACC_4x4x4, 0x2, 0x0 }, // 2734 + { PseudoVFWMACC_4x4x4_M8, VFWMACC_4x4x4, 0x3, 0x0 }, // 2735 + { PseudoVFWMACC_4x4x4_MF4, VFWMACC_4x4x4, 0x6, 0x0 }, // 2736 + { PseudoVFWMACC_4x4x4_MF2, VFWMACC_4x4x4, 0x7, 0x0 }, // 2737 + { PseudoVFWMACC_VFPR16_M1, VFWMACC_VF, 0x0, 0x0 }, // 2738 + { PseudoVFWMACC_VFPR16_M1_MASK, VFWMACC_VF, 0x0, 0x0 }, // 2739 + { PseudoVFWMACC_VFPR32_M1, VFWMACC_VF, 0x0, 0x0 }, // 2740 + { PseudoVFWMACC_VFPR32_M1_MASK, VFWMACC_VF, 0x0, 0x0 }, // 2741 + { PseudoVFWMACC_VFPR16_M2, VFWMACC_VF, 0x1, 0x0 }, // 2742 + { PseudoVFWMACC_VFPR16_M2_MASK, VFWMACC_VF, 0x1, 0x0 }, // 2743 + { PseudoVFWMACC_VFPR32_M2, VFWMACC_VF, 0x1, 0x0 }, // 2744 + { PseudoVFWMACC_VFPR32_M2_MASK, VFWMACC_VF, 0x1, 0x0 }, // 2745 + { PseudoVFWMACC_VFPR16_M4, VFWMACC_VF, 0x2, 0x0 }, // 2746 + { PseudoVFWMACC_VFPR16_M4_MASK, VFWMACC_VF, 0x2, 0x0 }, // 2747 + { PseudoVFWMACC_VFPR32_M4, VFWMACC_VF, 0x2, 0x0 }, // 2748 + { PseudoVFWMACC_VFPR32_M4_MASK, VFWMACC_VF, 0x2, 0x0 }, // 2749 + { PseudoVFWMACC_VFPR16_MF4, VFWMACC_VF, 0x6, 0x0 }, // 2750 + { PseudoVFWMACC_VFPR16_MF4_MASK, VFWMACC_VF, 0x6, 0x0 }, // 2751 + { PseudoVFWMACC_VFPR16_MF2, VFWMACC_VF, 0x7, 0x0 }, // 2752 + { PseudoVFWMACC_VFPR16_MF2_MASK, VFWMACC_VF, 0x7, 0x0 }, // 2753 + { PseudoVFWMACC_VFPR32_MF2, VFWMACC_VF, 0x7, 0x0 }, // 2754 + { PseudoVFWMACC_VFPR32_MF2_MASK, VFWMACC_VF, 0x7, 0x0 }, // 2755 + { PseudoVFWMACC_VV_M1, VFWMACC_VV, 0x0, 0x0 }, // 2756 + { PseudoVFWMACC_VV_M1_MASK, VFWMACC_VV, 0x0, 0x0 }, // 2757 + { PseudoVFWMACC_VV_M2, VFWMACC_VV, 0x1, 0x0 }, // 2758 + { PseudoVFWMACC_VV_M2_MASK, VFWMACC_VV, 0x1, 0x0 }, // 2759 + { PseudoVFWMACC_VV_M4, VFWMACC_VV, 0x2, 0x0 }, // 2760 + { PseudoVFWMACC_VV_M4_MASK, VFWMACC_VV, 0x2, 0x0 }, // 2761 + { PseudoVFWMACC_VV_MF4, VFWMACC_VV, 0x6, 0x0 }, // 2762 + { PseudoVFWMACC_VV_MF4_MASK, VFWMACC_VV, 0x6, 0x0 }, // 2763 + { PseudoVFWMACC_VV_MF2, VFWMACC_VV, 0x7, 0x0 }, // 2764 + { PseudoVFWMACC_VV_MF2_MASK, VFWMACC_VV, 0x7, 0x0 }, // 2765 + { PseudoVFWMSAC_VFPR16_M1, VFWMSAC_VF, 0x0, 0x0 }, // 2766 + { PseudoVFWMSAC_VFPR16_M1_MASK, VFWMSAC_VF, 0x0, 0x0 }, // 2767 + { PseudoVFWMSAC_VFPR32_M1, VFWMSAC_VF, 0x0, 0x0 }, // 2768 + { PseudoVFWMSAC_VFPR32_M1_MASK, VFWMSAC_VF, 0x0, 0x0 }, // 2769 + { PseudoVFWMSAC_VFPR16_M2, VFWMSAC_VF, 0x1, 0x0 }, // 2770 + { PseudoVFWMSAC_VFPR16_M2_MASK, VFWMSAC_VF, 0x1, 0x0 }, // 2771 + { PseudoVFWMSAC_VFPR32_M2, VFWMSAC_VF, 0x1, 0x0 }, // 2772 + { PseudoVFWMSAC_VFPR32_M2_MASK, VFWMSAC_VF, 0x1, 0x0 }, // 2773 + { PseudoVFWMSAC_VFPR16_M4, VFWMSAC_VF, 0x2, 0x0 }, // 2774 + { PseudoVFWMSAC_VFPR16_M4_MASK, VFWMSAC_VF, 0x2, 0x0 }, // 2775 + { PseudoVFWMSAC_VFPR32_M4, VFWMSAC_VF, 0x2, 0x0 }, // 2776 + { PseudoVFWMSAC_VFPR32_M4_MASK, VFWMSAC_VF, 0x2, 0x0 }, // 2777 + { PseudoVFWMSAC_VFPR16_MF4, VFWMSAC_VF, 0x6, 0x0 }, // 2778 + { PseudoVFWMSAC_VFPR16_MF4_MASK, VFWMSAC_VF, 0x6, 0x0 }, // 2779 + { PseudoVFWMSAC_VFPR16_MF2, VFWMSAC_VF, 0x7, 0x0 }, // 2780 + { PseudoVFWMSAC_VFPR16_MF2_MASK, VFWMSAC_VF, 0x7, 0x0 }, // 2781 + { PseudoVFWMSAC_VFPR32_MF2, VFWMSAC_VF, 0x7, 0x0 }, // 2782 + { PseudoVFWMSAC_VFPR32_MF2_MASK, VFWMSAC_VF, 0x7, 0x0 }, // 2783 + { PseudoVFWMSAC_VV_M1, VFWMSAC_VV, 0x0, 0x0 }, // 2784 + { PseudoVFWMSAC_VV_M1_MASK, VFWMSAC_VV, 0x0, 0x0 }, // 2785 + { PseudoVFWMSAC_VV_M2, VFWMSAC_VV, 0x1, 0x0 }, // 2786 + { PseudoVFWMSAC_VV_M2_MASK, VFWMSAC_VV, 0x1, 0x0 }, // 2787 + { PseudoVFWMSAC_VV_M4, VFWMSAC_VV, 0x2, 0x0 }, // 2788 + { PseudoVFWMSAC_VV_M4_MASK, VFWMSAC_VV, 0x2, 0x0 }, // 2789 + { PseudoVFWMSAC_VV_MF4, VFWMSAC_VV, 0x6, 0x0 }, // 2790 + { PseudoVFWMSAC_VV_MF4_MASK, VFWMSAC_VV, 0x6, 0x0 }, // 2791 + { PseudoVFWMSAC_VV_MF2, VFWMSAC_VV, 0x7, 0x0 }, // 2792 + { PseudoVFWMSAC_VV_MF2_MASK, VFWMSAC_VV, 0x7, 0x0 }, // 2793 + { PseudoVFWMUL_VFPR16_M1, VFWMUL_VF, 0x0, 0x0 }, // 2794 + { PseudoVFWMUL_VFPR16_M1_MASK, VFWMUL_VF, 0x0, 0x0 }, // 2795 + { PseudoVFWMUL_VFPR32_M1, VFWMUL_VF, 0x0, 0x0 }, // 2796 + { PseudoVFWMUL_VFPR32_M1_MASK, VFWMUL_VF, 0x0, 0x0 }, // 2797 + { PseudoVFWMUL_VFPR16_M2, VFWMUL_VF, 0x1, 0x0 }, // 2798 + { PseudoVFWMUL_VFPR16_M2_MASK, VFWMUL_VF, 0x1, 0x0 }, // 2799 + { PseudoVFWMUL_VFPR32_M2, VFWMUL_VF, 0x1, 0x0 }, // 2800 + { PseudoVFWMUL_VFPR32_M2_MASK, VFWMUL_VF, 0x1, 0x0 }, // 2801 + { PseudoVFWMUL_VFPR16_M4, VFWMUL_VF, 0x2, 0x0 }, // 2802 + { PseudoVFWMUL_VFPR16_M4_MASK, VFWMUL_VF, 0x2, 0x0 }, // 2803 + { PseudoVFWMUL_VFPR32_M4, VFWMUL_VF, 0x2, 0x0 }, // 2804 + { PseudoVFWMUL_VFPR32_M4_MASK, VFWMUL_VF, 0x2, 0x0 }, // 2805 + { PseudoVFWMUL_VFPR16_MF4, VFWMUL_VF, 0x6, 0x0 }, // 2806 + { PseudoVFWMUL_VFPR16_MF4_MASK, VFWMUL_VF, 0x6, 0x0 }, // 2807 + { PseudoVFWMUL_VFPR16_MF2, VFWMUL_VF, 0x7, 0x0 }, // 2808 + { PseudoVFWMUL_VFPR16_MF2_MASK, VFWMUL_VF, 0x7, 0x0 }, // 2809 + { PseudoVFWMUL_VFPR32_MF2, VFWMUL_VF, 0x7, 0x0 }, // 2810 + { PseudoVFWMUL_VFPR32_MF2_MASK, VFWMUL_VF, 0x7, 0x0 }, // 2811 + { PseudoVFWMUL_VV_M1, VFWMUL_VV, 0x0, 0x0 }, // 2812 + { PseudoVFWMUL_VV_M1_MASK, VFWMUL_VV, 0x0, 0x0 }, // 2813 + { PseudoVFWMUL_VV_M2, VFWMUL_VV, 0x1, 0x0 }, // 2814 + { PseudoVFWMUL_VV_M2_MASK, VFWMUL_VV, 0x1, 0x0 }, // 2815 + { PseudoVFWMUL_VV_M4, VFWMUL_VV, 0x2, 0x0 }, // 2816 + { PseudoVFWMUL_VV_M4_MASK, VFWMUL_VV, 0x2, 0x0 }, // 2817 + { PseudoVFWMUL_VV_MF4, VFWMUL_VV, 0x6, 0x0 }, // 2818 + { PseudoVFWMUL_VV_MF4_MASK, VFWMUL_VV, 0x6, 0x0 }, // 2819 + { PseudoVFWMUL_VV_MF2, VFWMUL_VV, 0x7, 0x0 }, // 2820 + { PseudoVFWMUL_VV_MF2_MASK, VFWMUL_VV, 0x7, 0x0 }, // 2821 + { PseudoVFWNMACC_VFPR16_M1, VFWNMACC_VF, 0x0, 0x0 }, // 2822 + { PseudoVFWNMACC_VFPR16_M1_MASK, VFWNMACC_VF, 0x0, 0x0 }, // 2823 + { PseudoVFWNMACC_VFPR32_M1, VFWNMACC_VF, 0x0, 0x0 }, // 2824 + { PseudoVFWNMACC_VFPR32_M1_MASK, VFWNMACC_VF, 0x0, 0x0 }, // 2825 + { PseudoVFWNMACC_VFPR16_M2, VFWNMACC_VF, 0x1, 0x0 }, // 2826 + { PseudoVFWNMACC_VFPR16_M2_MASK, VFWNMACC_VF, 0x1, 0x0 }, // 2827 + { PseudoVFWNMACC_VFPR32_M2, VFWNMACC_VF, 0x1, 0x0 }, // 2828 + { PseudoVFWNMACC_VFPR32_M2_MASK, VFWNMACC_VF, 0x1, 0x0 }, // 2829 + { PseudoVFWNMACC_VFPR16_M4, VFWNMACC_VF, 0x2, 0x0 }, // 2830 + { PseudoVFWNMACC_VFPR16_M4_MASK, VFWNMACC_VF, 0x2, 0x0 }, // 2831 + { PseudoVFWNMACC_VFPR32_M4, VFWNMACC_VF, 0x2, 0x0 }, // 2832 + { PseudoVFWNMACC_VFPR32_M4_MASK, VFWNMACC_VF, 0x2, 0x0 }, // 2833 + { PseudoVFWNMACC_VFPR16_MF4, VFWNMACC_VF, 0x6, 0x0 }, // 2834 + { PseudoVFWNMACC_VFPR16_MF4_MASK, VFWNMACC_VF, 0x6, 0x0 }, // 2835 + { PseudoVFWNMACC_VFPR16_MF2, VFWNMACC_VF, 0x7, 0x0 }, // 2836 + { PseudoVFWNMACC_VFPR16_MF2_MASK, VFWNMACC_VF, 0x7, 0x0 }, // 2837 + { PseudoVFWNMACC_VFPR32_MF2, VFWNMACC_VF, 0x7, 0x0 }, // 2838 + { PseudoVFWNMACC_VFPR32_MF2_MASK, VFWNMACC_VF, 0x7, 0x0 }, // 2839 + { PseudoVFWNMACC_VV_M1, VFWNMACC_VV, 0x0, 0x0 }, // 2840 + { PseudoVFWNMACC_VV_M1_MASK, VFWNMACC_VV, 0x0, 0x0 }, // 2841 + { PseudoVFWNMACC_VV_M2, VFWNMACC_VV, 0x1, 0x0 }, // 2842 + { PseudoVFWNMACC_VV_M2_MASK, VFWNMACC_VV, 0x1, 0x0 }, // 2843 + { PseudoVFWNMACC_VV_M4, VFWNMACC_VV, 0x2, 0x0 }, // 2844 + { PseudoVFWNMACC_VV_M4_MASK, VFWNMACC_VV, 0x2, 0x0 }, // 2845 + { PseudoVFWNMACC_VV_MF4, VFWNMACC_VV, 0x6, 0x0 }, // 2846 + { PseudoVFWNMACC_VV_MF4_MASK, VFWNMACC_VV, 0x6, 0x0 }, // 2847 + { PseudoVFWNMACC_VV_MF2, VFWNMACC_VV, 0x7, 0x0 }, // 2848 + { PseudoVFWNMACC_VV_MF2_MASK, VFWNMACC_VV, 0x7, 0x0 }, // 2849 + { PseudoVFWNMSAC_VFPR16_M1, VFWNMSAC_VF, 0x0, 0x0 }, // 2850 + { PseudoVFWNMSAC_VFPR16_M1_MASK, VFWNMSAC_VF, 0x0, 0x0 }, // 2851 + { PseudoVFWNMSAC_VFPR32_M1, VFWNMSAC_VF, 0x0, 0x0 }, // 2852 + { PseudoVFWNMSAC_VFPR32_M1_MASK, VFWNMSAC_VF, 0x0, 0x0 }, // 2853 + { PseudoVFWNMSAC_VFPR16_M2, VFWNMSAC_VF, 0x1, 0x0 }, // 2854 + { PseudoVFWNMSAC_VFPR16_M2_MASK, VFWNMSAC_VF, 0x1, 0x0 }, // 2855 + { PseudoVFWNMSAC_VFPR32_M2, VFWNMSAC_VF, 0x1, 0x0 }, // 2856 + { PseudoVFWNMSAC_VFPR32_M2_MASK, VFWNMSAC_VF, 0x1, 0x0 }, // 2857 + { PseudoVFWNMSAC_VFPR16_M4, VFWNMSAC_VF, 0x2, 0x0 }, // 2858 + { PseudoVFWNMSAC_VFPR16_M4_MASK, VFWNMSAC_VF, 0x2, 0x0 }, // 2859 + { PseudoVFWNMSAC_VFPR32_M4, VFWNMSAC_VF, 0x2, 0x0 }, // 2860 + { PseudoVFWNMSAC_VFPR32_M4_MASK, VFWNMSAC_VF, 0x2, 0x0 }, // 2861 + { PseudoVFWNMSAC_VFPR16_MF4, VFWNMSAC_VF, 0x6, 0x0 }, // 2862 + { PseudoVFWNMSAC_VFPR16_MF4_MASK, VFWNMSAC_VF, 0x6, 0x0 }, // 2863 + { PseudoVFWNMSAC_VFPR16_MF2, VFWNMSAC_VF, 0x7, 0x0 }, // 2864 + { PseudoVFWNMSAC_VFPR16_MF2_MASK, VFWNMSAC_VF, 0x7, 0x0 }, // 2865 + { PseudoVFWNMSAC_VFPR32_MF2, VFWNMSAC_VF, 0x7, 0x0 }, // 2866 + { PseudoVFWNMSAC_VFPR32_MF2_MASK, VFWNMSAC_VF, 0x7, 0x0 }, // 2867 + { PseudoVFWNMSAC_VV_M1, VFWNMSAC_VV, 0x0, 0x0 }, // 2868 + { PseudoVFWNMSAC_VV_M1_MASK, VFWNMSAC_VV, 0x0, 0x0 }, // 2869 + { PseudoVFWNMSAC_VV_M2, VFWNMSAC_VV, 0x1, 0x0 }, // 2870 + { PseudoVFWNMSAC_VV_M2_MASK, VFWNMSAC_VV, 0x1, 0x0 }, // 2871 + { PseudoVFWNMSAC_VV_M4, VFWNMSAC_VV, 0x2, 0x0 }, // 2872 + { PseudoVFWNMSAC_VV_M4_MASK, VFWNMSAC_VV, 0x2, 0x0 }, // 2873 + { PseudoVFWNMSAC_VV_MF4, VFWNMSAC_VV, 0x6, 0x0 }, // 2874 + { PseudoVFWNMSAC_VV_MF4_MASK, VFWNMSAC_VV, 0x6, 0x0 }, // 2875 + { PseudoVFWNMSAC_VV_MF2, VFWNMSAC_VV, 0x7, 0x0 }, // 2876 + { PseudoVFWNMSAC_VV_MF2_MASK, VFWNMSAC_VV, 0x7, 0x0 }, // 2877 + { PseudoVFWREDOSUM_VS_M1_E16, VFWREDOSUM_VS, 0x0, 0x10 }, // 2878 + { PseudoVFWREDOSUM_VS_M1_E16_MASK, VFWREDOSUM_VS, 0x0, 0x10 }, // 2879 + { PseudoVFWREDOSUM_VS_M1_E32, VFWREDOSUM_VS, 0x0, 0x20 }, // 2880 + { PseudoVFWREDOSUM_VS_M1_E32_MASK, VFWREDOSUM_VS, 0x0, 0x20 }, // 2881 + { PseudoVFWREDOSUM_VS_M2_E16, VFWREDOSUM_VS, 0x1, 0x10 }, // 2882 + { PseudoVFWREDOSUM_VS_M2_E16_MASK, VFWREDOSUM_VS, 0x1, 0x10 }, // 2883 + { PseudoVFWREDOSUM_VS_M2_E32, VFWREDOSUM_VS, 0x1, 0x20 }, // 2884 + { PseudoVFWREDOSUM_VS_M2_E32_MASK, VFWREDOSUM_VS, 0x1, 0x20 }, // 2885 + { PseudoVFWREDOSUM_VS_M4_E16, VFWREDOSUM_VS, 0x2, 0x10 }, // 2886 + { PseudoVFWREDOSUM_VS_M4_E16_MASK, VFWREDOSUM_VS, 0x2, 0x10 }, // 2887 + { PseudoVFWREDOSUM_VS_M4_E32, VFWREDOSUM_VS, 0x2, 0x20 }, // 2888 + { PseudoVFWREDOSUM_VS_M4_E32_MASK, VFWREDOSUM_VS, 0x2, 0x20 }, // 2889 + { PseudoVFWREDOSUM_VS_M8_E16, VFWREDOSUM_VS, 0x3, 0x10 }, // 2890 + { PseudoVFWREDOSUM_VS_M8_E16_MASK, VFWREDOSUM_VS, 0x3, 0x10 }, // 2891 + { PseudoVFWREDOSUM_VS_M8_E32, VFWREDOSUM_VS, 0x3, 0x20 }, // 2892 + { PseudoVFWREDOSUM_VS_M8_E32_MASK, VFWREDOSUM_VS, 0x3, 0x20 }, // 2893 + { PseudoVFWREDOSUM_VS_MF4_E16, VFWREDOSUM_VS, 0x6, 0x10 }, // 2894 + { PseudoVFWREDOSUM_VS_MF4_E16_MASK, VFWREDOSUM_VS, 0x6, 0x10 }, // 2895 + { PseudoVFWREDOSUM_VS_MF2_E16, VFWREDOSUM_VS, 0x7, 0x10 }, // 2896 + { PseudoVFWREDOSUM_VS_MF2_E16_MASK, VFWREDOSUM_VS, 0x7, 0x10 }, // 2897 + { PseudoVFWREDOSUM_VS_MF2_E32, VFWREDOSUM_VS, 0x7, 0x20 }, // 2898 + { PseudoVFWREDOSUM_VS_MF2_E32_MASK, VFWREDOSUM_VS, 0x7, 0x20 }, // 2899 + { PseudoVFWREDUSUM_VS_M1_E16, VFWREDUSUM_VS, 0x0, 0x10 }, // 2900 + { PseudoVFWREDUSUM_VS_M1_E16_MASK, VFWREDUSUM_VS, 0x0, 0x10 }, // 2901 + { PseudoVFWREDUSUM_VS_M1_E32, VFWREDUSUM_VS, 0x0, 0x20 }, // 2902 + { PseudoVFWREDUSUM_VS_M1_E32_MASK, VFWREDUSUM_VS, 0x0, 0x20 }, // 2903 + { PseudoVFWREDUSUM_VS_M2_E16, VFWREDUSUM_VS, 0x1, 0x10 }, // 2904 + { PseudoVFWREDUSUM_VS_M2_E16_MASK, VFWREDUSUM_VS, 0x1, 0x10 }, // 2905 + { PseudoVFWREDUSUM_VS_M2_E32, VFWREDUSUM_VS, 0x1, 0x20 }, // 2906 + { PseudoVFWREDUSUM_VS_M2_E32_MASK, VFWREDUSUM_VS, 0x1, 0x20 }, // 2907 + { PseudoVFWREDUSUM_VS_M4_E16, VFWREDUSUM_VS, 0x2, 0x10 }, // 2908 + { PseudoVFWREDUSUM_VS_M4_E16_MASK, VFWREDUSUM_VS, 0x2, 0x10 }, // 2909 + { PseudoVFWREDUSUM_VS_M4_E32, VFWREDUSUM_VS, 0x2, 0x20 }, // 2910 + { PseudoVFWREDUSUM_VS_M4_E32_MASK, VFWREDUSUM_VS, 0x2, 0x20 }, // 2911 + { PseudoVFWREDUSUM_VS_M8_E16, VFWREDUSUM_VS, 0x3, 0x10 }, // 2912 + { PseudoVFWREDUSUM_VS_M8_E16_MASK, VFWREDUSUM_VS, 0x3, 0x10 }, // 2913 + { PseudoVFWREDUSUM_VS_M8_E32, VFWREDUSUM_VS, 0x3, 0x20 }, // 2914 + { PseudoVFWREDUSUM_VS_M8_E32_MASK, VFWREDUSUM_VS, 0x3, 0x20 }, // 2915 + { PseudoVFWREDUSUM_VS_MF4_E16, VFWREDUSUM_VS, 0x6, 0x10 }, // 2916 + { PseudoVFWREDUSUM_VS_MF4_E16_MASK, VFWREDUSUM_VS, 0x6, 0x10 }, // 2917 + { PseudoVFWREDUSUM_VS_MF2_E16, VFWREDUSUM_VS, 0x7, 0x10 }, // 2918 + { PseudoVFWREDUSUM_VS_MF2_E16_MASK, VFWREDUSUM_VS, 0x7, 0x10 }, // 2919 + { PseudoVFWREDUSUM_VS_MF2_E32, VFWREDUSUM_VS, 0x7, 0x20 }, // 2920 + { PseudoVFWREDUSUM_VS_MF2_E32_MASK, VFWREDUSUM_VS, 0x7, 0x20 }, // 2921 + { PseudoVFWSUB_VFPR16_M1, VFWSUB_VF, 0x0, 0x0 }, // 2922 + { PseudoVFWSUB_VFPR16_M1_MASK, VFWSUB_VF, 0x0, 0x0 }, // 2923 + { PseudoVFWSUB_VFPR32_M1, VFWSUB_VF, 0x0, 0x0 }, // 2924 + { PseudoVFWSUB_VFPR32_M1_MASK, VFWSUB_VF, 0x0, 0x0 }, // 2925 + { PseudoVFWSUB_VFPR16_M2, VFWSUB_VF, 0x1, 0x0 }, // 2926 + { PseudoVFWSUB_VFPR16_M2_MASK, VFWSUB_VF, 0x1, 0x0 }, // 2927 + { PseudoVFWSUB_VFPR32_M2, VFWSUB_VF, 0x1, 0x0 }, // 2928 + { PseudoVFWSUB_VFPR32_M2_MASK, VFWSUB_VF, 0x1, 0x0 }, // 2929 + { PseudoVFWSUB_VFPR16_M4, VFWSUB_VF, 0x2, 0x0 }, // 2930 + { PseudoVFWSUB_VFPR16_M4_MASK, VFWSUB_VF, 0x2, 0x0 }, // 2931 + { PseudoVFWSUB_VFPR32_M4, VFWSUB_VF, 0x2, 0x0 }, // 2932 + { PseudoVFWSUB_VFPR32_M4_MASK, VFWSUB_VF, 0x2, 0x0 }, // 2933 + { PseudoVFWSUB_VFPR16_MF4, VFWSUB_VF, 0x6, 0x0 }, // 2934 + { PseudoVFWSUB_VFPR16_MF4_MASK, VFWSUB_VF, 0x6, 0x0 }, // 2935 + { PseudoVFWSUB_VFPR16_MF2, VFWSUB_VF, 0x7, 0x0 }, // 2936 + { PseudoVFWSUB_VFPR16_MF2_MASK, VFWSUB_VF, 0x7, 0x0 }, // 2937 + { PseudoVFWSUB_VFPR32_MF2, VFWSUB_VF, 0x7, 0x0 }, // 2938 + { PseudoVFWSUB_VFPR32_MF2_MASK, VFWSUB_VF, 0x7, 0x0 }, // 2939 + { PseudoVFWSUB_VV_M1, VFWSUB_VV, 0x0, 0x0 }, // 2940 + { PseudoVFWSUB_VV_M1_MASK, VFWSUB_VV, 0x0, 0x0 }, // 2941 + { PseudoVFWSUB_VV_M2, VFWSUB_VV, 0x1, 0x0 }, // 2942 + { PseudoVFWSUB_VV_M2_MASK, VFWSUB_VV, 0x1, 0x0 }, // 2943 + { PseudoVFWSUB_VV_M4, VFWSUB_VV, 0x2, 0x0 }, // 2944 + { PseudoVFWSUB_VV_M4_MASK, VFWSUB_VV, 0x2, 0x0 }, // 2945 + { PseudoVFWSUB_VV_MF4, VFWSUB_VV, 0x6, 0x0 }, // 2946 + { PseudoVFWSUB_VV_MF4_MASK, VFWSUB_VV, 0x6, 0x0 }, // 2947 + { PseudoVFWSUB_VV_MF2, VFWSUB_VV, 0x7, 0x0 }, // 2948 + { PseudoVFWSUB_VV_MF2_MASK, VFWSUB_VV, 0x7, 0x0 }, // 2949 + { PseudoVFWSUB_WFPR16_M1, VFWSUB_WF, 0x0, 0x0 }, // 2950 + { PseudoVFWSUB_WFPR16_M1_MASK, VFWSUB_WF, 0x0, 0x0 }, // 2951 + { PseudoVFWSUB_WFPR32_M1, VFWSUB_WF, 0x0, 0x0 }, // 2952 + { PseudoVFWSUB_WFPR32_M1_MASK, VFWSUB_WF, 0x0, 0x0 }, // 2953 + { PseudoVFWSUB_WFPR16_M2, VFWSUB_WF, 0x1, 0x0 }, // 2954 + { PseudoVFWSUB_WFPR16_M2_MASK, VFWSUB_WF, 0x1, 0x0 }, // 2955 + { PseudoVFWSUB_WFPR32_M2, VFWSUB_WF, 0x1, 0x0 }, // 2956 + { PseudoVFWSUB_WFPR32_M2_MASK, VFWSUB_WF, 0x1, 0x0 }, // 2957 + { PseudoVFWSUB_WFPR16_M4, VFWSUB_WF, 0x2, 0x0 }, // 2958 + { PseudoVFWSUB_WFPR16_M4_MASK, VFWSUB_WF, 0x2, 0x0 }, // 2959 + { PseudoVFWSUB_WFPR32_M4, VFWSUB_WF, 0x2, 0x0 }, // 2960 + { PseudoVFWSUB_WFPR32_M4_MASK, VFWSUB_WF, 0x2, 0x0 }, // 2961 + { PseudoVFWSUB_WFPR16_MF4, VFWSUB_WF, 0x6, 0x0 }, // 2962 + { PseudoVFWSUB_WFPR16_MF4_MASK, VFWSUB_WF, 0x6, 0x0 }, // 2963 + { PseudoVFWSUB_WFPR16_MF2, VFWSUB_WF, 0x7, 0x0 }, // 2964 + { PseudoVFWSUB_WFPR16_MF2_MASK, VFWSUB_WF, 0x7, 0x0 }, // 2965 + { PseudoVFWSUB_WFPR32_MF2, VFWSUB_WF, 0x7, 0x0 }, // 2966 + { PseudoVFWSUB_WFPR32_MF2_MASK, VFWSUB_WF, 0x7, 0x0 }, // 2967 + { PseudoVFWSUB_WV_M1, VFWSUB_WV, 0x0, 0x0 }, // 2968 + { PseudoVFWSUB_WV_M1_MASK, VFWSUB_WV, 0x0, 0x0 }, // 2969 + { PseudoVFWSUB_WV_M1_MASK_TIED, VFWSUB_WV, 0x0, 0x0 }, // 2970 + { PseudoVFWSUB_WV_M1_TIED, VFWSUB_WV, 0x0, 0x0 }, // 2971 + { PseudoVFWSUB_WV_M2, VFWSUB_WV, 0x1, 0x0 }, // 2972 + { PseudoVFWSUB_WV_M2_MASK, VFWSUB_WV, 0x1, 0x0 }, // 2973 + { PseudoVFWSUB_WV_M2_MASK_TIED, VFWSUB_WV, 0x1, 0x0 }, // 2974 + { PseudoVFWSUB_WV_M2_TIED, VFWSUB_WV, 0x1, 0x0 }, // 2975 + { PseudoVFWSUB_WV_M4, VFWSUB_WV, 0x2, 0x0 }, // 2976 + { PseudoVFWSUB_WV_M4_MASK, VFWSUB_WV, 0x2, 0x0 }, // 2977 + { PseudoVFWSUB_WV_M4_MASK_TIED, VFWSUB_WV, 0x2, 0x0 }, // 2978 + { PseudoVFWSUB_WV_M4_TIED, VFWSUB_WV, 0x2, 0x0 }, // 2979 + { PseudoVFWSUB_WV_MF4, VFWSUB_WV, 0x6, 0x0 }, // 2980 + { PseudoVFWSUB_WV_MF4_MASK, VFWSUB_WV, 0x6, 0x0 }, // 2981 + { PseudoVFWSUB_WV_MF4_MASK_TIED, VFWSUB_WV, 0x6, 0x0 }, // 2982 + { PseudoVFWSUB_WV_MF4_TIED, VFWSUB_WV, 0x6, 0x0 }, // 2983 + { PseudoVFWSUB_WV_MF2, VFWSUB_WV, 0x7, 0x0 }, // 2984 + { PseudoVFWSUB_WV_MF2_MASK, VFWSUB_WV, 0x7, 0x0 }, // 2985 + { PseudoVFWSUB_WV_MF2_MASK_TIED, VFWSUB_WV, 0x7, 0x0 }, // 2986 + { PseudoVFWSUB_WV_MF2_TIED, VFWSUB_WV, 0x7, 0x0 }, // 2987 + { PseudoVGHSH_VV_M1, VGHSH_VV, 0x0, 0x0 }, // 2988 + { PseudoVGHSH_VV_M2, VGHSH_VV, 0x1, 0x0 }, // 2989 + { PseudoVGHSH_VV_M4, VGHSH_VV, 0x2, 0x0 }, // 2990 + { PseudoVGHSH_VV_M8, VGHSH_VV, 0x3, 0x0 }, // 2991 + { PseudoVGHSH_VV_MF2, VGHSH_VV, 0x7, 0x0 }, // 2992 + { PseudoVGMUL_VV_M1, VGMUL_VV, 0x0, 0x0 }, // 2993 + { PseudoVGMUL_VV_M2, VGMUL_VV, 0x1, 0x0 }, // 2994 + { PseudoVGMUL_VV_M4, VGMUL_VV, 0x2, 0x0 }, // 2995 + { PseudoVGMUL_VV_M8, VGMUL_VV, 0x3, 0x0 }, // 2996 + { PseudoVGMUL_VV_MF2, VGMUL_VV, 0x7, 0x0 }, // 2997 + { PseudoVID_V_M1, VID_V, 0x0, 0x0 }, // 2998 + { PseudoVID_V_M1_MASK, VID_V, 0x0, 0x0 }, // 2999 + { PseudoVID_V_M2, VID_V, 0x1, 0x0 }, // 3000 + { PseudoVID_V_M2_MASK, VID_V, 0x1, 0x0 }, // 3001 + { PseudoVID_V_M4, VID_V, 0x2, 0x0 }, // 3002 + { PseudoVID_V_M4_MASK, VID_V, 0x2, 0x0 }, // 3003 + { PseudoVID_V_M8, VID_V, 0x3, 0x0 }, // 3004 + { PseudoVID_V_M8_MASK, VID_V, 0x3, 0x0 }, // 3005 + { PseudoVID_V_MF8, VID_V, 0x5, 0x0 }, // 3006 + { PseudoVID_V_MF8_MASK, VID_V, 0x5, 0x0 }, // 3007 + { PseudoVID_V_MF4, VID_V, 0x6, 0x0 }, // 3008 + { PseudoVID_V_MF4_MASK, VID_V, 0x6, 0x0 }, // 3009 + { PseudoVID_V_MF2, VID_V, 0x7, 0x0 }, // 3010 + { PseudoVID_V_MF2_MASK, VID_V, 0x7, 0x0 }, // 3011 + { PseudoVIOTA_M_M1, VIOTA_M, 0x0, 0x0 }, // 3012 + { PseudoVIOTA_M_M1_MASK, VIOTA_M, 0x0, 0x0 }, // 3013 + { PseudoVIOTA_M_M2, VIOTA_M, 0x1, 0x0 }, // 3014 + { PseudoVIOTA_M_M2_MASK, VIOTA_M, 0x1, 0x0 }, // 3015 + { PseudoVIOTA_M_M4, VIOTA_M, 0x2, 0x0 }, // 3016 + { PseudoVIOTA_M_M4_MASK, VIOTA_M, 0x2, 0x0 }, // 3017 + { PseudoVIOTA_M_M8, VIOTA_M, 0x3, 0x0 }, // 3018 + { PseudoVIOTA_M_M8_MASK, VIOTA_M, 0x3, 0x0 }, // 3019 + { PseudoVIOTA_M_MF8, VIOTA_M, 0x5, 0x0 }, // 3020 + { PseudoVIOTA_M_MF8_MASK, VIOTA_M, 0x5, 0x0 }, // 3021 + { PseudoVIOTA_M_MF4, VIOTA_M, 0x6, 0x0 }, // 3022 + { PseudoVIOTA_M_MF4_MASK, VIOTA_M, 0x6, 0x0 }, // 3023 + { PseudoVIOTA_M_MF2, VIOTA_M, 0x7, 0x0 }, // 3024 + { PseudoVIOTA_M_MF2_MASK, VIOTA_M, 0x7, 0x0 }, // 3025 + { PseudoVLE16FF_V_M1, VLE16FF_V, 0x0, 0x10 }, // 3026 + { PseudoVLE16FF_V_M1_MASK, VLE16FF_V, 0x0, 0x10 }, // 3027 + { PseudoVLE16FF_V_M2, VLE16FF_V, 0x1, 0x10 }, // 3028 + { PseudoVLE16FF_V_M2_MASK, VLE16FF_V, 0x1, 0x10 }, // 3029 + { PseudoVLE16FF_V_M4, VLE16FF_V, 0x2, 0x10 }, // 3030 + { PseudoVLE16FF_V_M4_MASK, VLE16FF_V, 0x2, 0x10 }, // 3031 + { PseudoVLE16FF_V_M8, VLE16FF_V, 0x3, 0x10 }, // 3032 + { PseudoVLE16FF_V_M8_MASK, VLE16FF_V, 0x3, 0x10 }, // 3033 + { PseudoVLE16FF_V_MF4, VLE16FF_V, 0x6, 0x10 }, // 3034 + { PseudoVLE16FF_V_MF4_MASK, VLE16FF_V, 0x6, 0x10 }, // 3035 + { PseudoVLE16FF_V_MF2, VLE16FF_V, 0x7, 0x10 }, // 3036 + { PseudoVLE16FF_V_MF2_MASK, VLE16FF_V, 0x7, 0x10 }, // 3037 + { PseudoVLE16_V_M1, VLE16_V, 0x0, 0x10 }, // 3038 + { PseudoVLE16_V_M1_MASK, VLE16_V, 0x0, 0x10 }, // 3039 + { PseudoVLE16_V_M2, VLE16_V, 0x1, 0x10 }, // 3040 + { PseudoVLE16_V_M2_MASK, VLE16_V, 0x1, 0x10 }, // 3041 + { PseudoVLE16_V_M4, VLE16_V, 0x2, 0x10 }, // 3042 + { PseudoVLE16_V_M4_MASK, VLE16_V, 0x2, 0x10 }, // 3043 + { PseudoVLE16_V_M8, VLE16_V, 0x3, 0x10 }, // 3044 + { PseudoVLE16_V_M8_MASK, VLE16_V, 0x3, 0x10 }, // 3045 + { PseudoVLE16_V_MF4, VLE16_V, 0x6, 0x10 }, // 3046 + { PseudoVLE16_V_MF4_MASK, VLE16_V, 0x6, 0x10 }, // 3047 + { PseudoVLE16_V_MF2, VLE16_V, 0x7, 0x10 }, // 3048 + { PseudoVLE16_V_MF2_MASK, VLE16_V, 0x7, 0x10 }, // 3049 + { PseudoVLE32FF_V_M1, VLE32FF_V, 0x0, 0x20 }, // 3050 + { PseudoVLE32FF_V_M1_MASK, VLE32FF_V, 0x0, 0x20 }, // 3051 + { PseudoVLE32FF_V_M2, VLE32FF_V, 0x1, 0x20 }, // 3052 + { PseudoVLE32FF_V_M2_MASK, VLE32FF_V, 0x1, 0x20 }, // 3053 + { PseudoVLE32FF_V_M4, VLE32FF_V, 0x2, 0x20 }, // 3054 + { PseudoVLE32FF_V_M4_MASK, VLE32FF_V, 0x2, 0x20 }, // 3055 + { PseudoVLE32FF_V_M8, VLE32FF_V, 0x3, 0x20 }, // 3056 + { PseudoVLE32FF_V_M8_MASK, VLE32FF_V, 0x3, 0x20 }, // 3057 + { PseudoVLE32FF_V_MF2, VLE32FF_V, 0x7, 0x20 }, // 3058 + { PseudoVLE32FF_V_MF2_MASK, VLE32FF_V, 0x7, 0x20 }, // 3059 + { PseudoVLE32_V_M1, VLE32_V, 0x0, 0x20 }, // 3060 + { PseudoVLE32_V_M1_MASK, VLE32_V, 0x0, 0x20 }, // 3061 + { PseudoVLE32_V_M2, VLE32_V, 0x1, 0x20 }, // 3062 + { PseudoVLE32_V_M2_MASK, VLE32_V, 0x1, 0x20 }, // 3063 + { PseudoVLE32_V_M4, VLE32_V, 0x2, 0x20 }, // 3064 + { PseudoVLE32_V_M4_MASK, VLE32_V, 0x2, 0x20 }, // 3065 + { PseudoVLE32_V_M8, VLE32_V, 0x3, 0x20 }, // 3066 + { PseudoVLE32_V_M8_MASK, VLE32_V, 0x3, 0x20 }, // 3067 + { PseudoVLE32_V_MF2, VLE32_V, 0x7, 0x20 }, // 3068 + { PseudoVLE32_V_MF2_MASK, VLE32_V, 0x7, 0x20 }, // 3069 + { PseudoVLE64FF_V_M1, VLE64FF_V, 0x0, 0x40 }, // 3070 + { PseudoVLE64FF_V_M1_MASK, VLE64FF_V, 0x0, 0x40 }, // 3071 + { PseudoVLE64FF_V_M2, VLE64FF_V, 0x1, 0x40 }, // 3072 + { PseudoVLE64FF_V_M2_MASK, VLE64FF_V, 0x1, 0x40 }, // 3073 + { PseudoVLE64FF_V_M4, VLE64FF_V, 0x2, 0x40 }, // 3074 + { PseudoVLE64FF_V_M4_MASK, VLE64FF_V, 0x2, 0x40 }, // 3075 + { PseudoVLE64FF_V_M8, VLE64FF_V, 0x3, 0x40 }, // 3076 + { PseudoVLE64FF_V_M8_MASK, VLE64FF_V, 0x3, 0x40 }, // 3077 + { PseudoVLE64_V_M1, VLE64_V, 0x0, 0x40 }, // 3078 + { PseudoVLE64_V_M1_MASK, VLE64_V, 0x0, 0x40 }, // 3079 + { PseudoVLE64_V_M2, VLE64_V, 0x1, 0x40 }, // 3080 + { PseudoVLE64_V_M2_MASK, VLE64_V, 0x1, 0x40 }, // 3081 + { PseudoVLE64_V_M4, VLE64_V, 0x2, 0x40 }, // 3082 + { PseudoVLE64_V_M4_MASK, VLE64_V, 0x2, 0x40 }, // 3083 + { PseudoVLE64_V_M8, VLE64_V, 0x3, 0x40 }, // 3084 + { PseudoVLE64_V_M8_MASK, VLE64_V, 0x3, 0x40 }, // 3085 + { PseudoVLE8FF_V_M1, VLE8FF_V, 0x0, 0x8 }, // 3086 + { PseudoVLE8FF_V_M1_MASK, VLE8FF_V, 0x0, 0x8 }, // 3087 + { PseudoVLE8FF_V_M2, VLE8FF_V, 0x1, 0x8 }, // 3088 + { PseudoVLE8FF_V_M2_MASK, VLE8FF_V, 0x1, 0x8 }, // 3089 + { PseudoVLE8FF_V_M4, VLE8FF_V, 0x2, 0x8 }, // 3090 + { PseudoVLE8FF_V_M4_MASK, VLE8FF_V, 0x2, 0x8 }, // 3091 + { PseudoVLE8FF_V_M8, VLE8FF_V, 0x3, 0x8 }, // 3092 + { PseudoVLE8FF_V_M8_MASK, VLE8FF_V, 0x3, 0x8 }, // 3093 + { PseudoVLE8FF_V_MF8, VLE8FF_V, 0x5, 0x8 }, // 3094 + { PseudoVLE8FF_V_MF8_MASK, VLE8FF_V, 0x5, 0x8 }, // 3095 + { PseudoVLE8FF_V_MF4, VLE8FF_V, 0x6, 0x8 }, // 3096 + { PseudoVLE8FF_V_MF4_MASK, VLE8FF_V, 0x6, 0x8 }, // 3097 + { PseudoVLE8FF_V_MF2, VLE8FF_V, 0x7, 0x8 }, // 3098 + { PseudoVLE8FF_V_MF2_MASK, VLE8FF_V, 0x7, 0x8 }, // 3099 + { PseudoVLE8_V_M1, VLE8_V, 0x0, 0x8 }, // 3100 + { PseudoVLE8_V_M1_MASK, VLE8_V, 0x0, 0x8 }, // 3101 + { PseudoVLE8_V_M2, VLE8_V, 0x1, 0x8 }, // 3102 + { PseudoVLE8_V_M2_MASK, VLE8_V, 0x1, 0x8 }, // 3103 + { PseudoVLE8_V_M4, VLE8_V, 0x2, 0x8 }, // 3104 + { PseudoVLE8_V_M4_MASK, VLE8_V, 0x2, 0x8 }, // 3105 + { PseudoVLE8_V_M8, VLE8_V, 0x3, 0x8 }, // 3106 + { PseudoVLE8_V_M8_MASK, VLE8_V, 0x3, 0x8 }, // 3107 + { PseudoVLE8_V_MF8, VLE8_V, 0x5, 0x8 }, // 3108 + { PseudoVLE8_V_MF8_MASK, VLE8_V, 0x5, 0x8 }, // 3109 + { PseudoVLE8_V_MF4, VLE8_V, 0x6, 0x8 }, // 3110 + { PseudoVLE8_V_MF4_MASK, VLE8_V, 0x6, 0x8 }, // 3111 + { PseudoVLE8_V_MF2, VLE8_V, 0x7, 0x8 }, // 3112 + { PseudoVLE8_V_MF2_MASK, VLE8_V, 0x7, 0x8 }, // 3113 + { PseudoVLM_V_B8, VLM_V, 0x0, 0x0 }, // 3114 + { PseudoVLM_V_B16, VLM_V, 0x1, 0x0 }, // 3115 + { PseudoVLM_V_B32, VLM_V, 0x2, 0x0 }, // 3116 + { PseudoVLM_V_B64, VLM_V, 0x3, 0x0 }, // 3117 + { PseudoVLM_V_B1, VLM_V, 0x5, 0x0 }, // 3118 + { PseudoVLM_V_B2, VLM_V, 0x6, 0x0 }, // 3119 + { PseudoVLM_V_B4, VLM_V, 0x7, 0x0 }, // 3120 + { PseudoVLOXEI16_V_M1_M1, VLOXEI16_V, 0x0, 0x0 }, // 3121 + { PseudoVLOXEI16_V_M1_M1_MASK, VLOXEI16_V, 0x0, 0x0 }, // 3122 + { PseudoVLOXEI16_V_M2_M1, VLOXEI16_V, 0x0, 0x0 }, // 3123 + { PseudoVLOXEI16_V_M2_M1_MASK, VLOXEI16_V, 0x0, 0x0 }, // 3124 + { PseudoVLOXEI16_V_MF2_M1, VLOXEI16_V, 0x0, 0x0 }, // 3125 + { PseudoVLOXEI16_V_MF2_M1_MASK, VLOXEI16_V, 0x0, 0x0 }, // 3126 + { PseudoVLOXEI16_V_MF4_M1, VLOXEI16_V, 0x0, 0x0 }, // 3127 + { PseudoVLOXEI16_V_MF4_M1_MASK, VLOXEI16_V, 0x0, 0x0 }, // 3128 + { PseudoVLOXEI16_V_M1_M2, VLOXEI16_V, 0x1, 0x0 }, // 3129 + { PseudoVLOXEI16_V_M1_M2_MASK, VLOXEI16_V, 0x1, 0x0 }, // 3130 + { PseudoVLOXEI16_V_M2_M2, VLOXEI16_V, 0x1, 0x0 }, // 3131 + { PseudoVLOXEI16_V_M2_M2_MASK, VLOXEI16_V, 0x1, 0x0 }, // 3132 + { PseudoVLOXEI16_V_M4_M2, VLOXEI16_V, 0x1, 0x0 }, // 3133 + { PseudoVLOXEI16_V_M4_M2_MASK, VLOXEI16_V, 0x1, 0x0 }, // 3134 + { PseudoVLOXEI16_V_MF2_M2, VLOXEI16_V, 0x1, 0x0 }, // 3135 + { PseudoVLOXEI16_V_MF2_M2_MASK, VLOXEI16_V, 0x1, 0x0 }, // 3136 + { PseudoVLOXEI16_V_M1_M4, VLOXEI16_V, 0x2, 0x0 }, // 3137 + { PseudoVLOXEI16_V_M1_M4_MASK, VLOXEI16_V, 0x2, 0x0 }, // 3138 + { PseudoVLOXEI16_V_M2_M4, VLOXEI16_V, 0x2, 0x0 }, // 3139 + { PseudoVLOXEI16_V_M2_M4_MASK, VLOXEI16_V, 0x2, 0x0 }, // 3140 + { PseudoVLOXEI16_V_M4_M4, VLOXEI16_V, 0x2, 0x0 }, // 3141 + { PseudoVLOXEI16_V_M4_M4_MASK, VLOXEI16_V, 0x2, 0x0 }, // 3142 + { PseudoVLOXEI16_V_M8_M4, VLOXEI16_V, 0x2, 0x0 }, // 3143 + { PseudoVLOXEI16_V_M8_M4_MASK, VLOXEI16_V, 0x2, 0x0 }, // 3144 + { PseudoVLOXEI16_V_M2_M8, VLOXEI16_V, 0x3, 0x0 }, // 3145 + { PseudoVLOXEI16_V_M2_M8_MASK, VLOXEI16_V, 0x3, 0x0 }, // 3146 + { PseudoVLOXEI16_V_M4_M8, VLOXEI16_V, 0x3, 0x0 }, // 3147 + { PseudoVLOXEI16_V_M4_M8_MASK, VLOXEI16_V, 0x3, 0x0 }, // 3148 + { PseudoVLOXEI16_V_M8_M8, VLOXEI16_V, 0x3, 0x0 }, // 3149 + { PseudoVLOXEI16_V_M8_M8_MASK, VLOXEI16_V, 0x3, 0x0 }, // 3150 + { PseudoVLOXEI16_V_MF4_MF8, VLOXEI16_V, 0x5, 0x0 }, // 3151 + { PseudoVLOXEI16_V_MF4_MF8_MASK, VLOXEI16_V, 0x5, 0x0 }, // 3152 + { PseudoVLOXEI16_V_MF2_MF4, VLOXEI16_V, 0x6, 0x0 }, // 3153 + { PseudoVLOXEI16_V_MF2_MF4_MASK, VLOXEI16_V, 0x6, 0x0 }, // 3154 + { PseudoVLOXEI16_V_MF4_MF4, VLOXEI16_V, 0x6, 0x0 }, // 3155 + { PseudoVLOXEI16_V_MF4_MF4_MASK, VLOXEI16_V, 0x6, 0x0 }, // 3156 + { PseudoVLOXEI16_V_M1_MF2, VLOXEI16_V, 0x7, 0x0 }, // 3157 + { PseudoVLOXEI16_V_M1_MF2_MASK, VLOXEI16_V, 0x7, 0x0 }, // 3158 + { PseudoVLOXEI16_V_MF2_MF2, VLOXEI16_V, 0x7, 0x0 }, // 3159 + { PseudoVLOXEI16_V_MF2_MF2_MASK, VLOXEI16_V, 0x7, 0x0 }, // 3160 + { PseudoVLOXEI16_V_MF4_MF2, VLOXEI16_V, 0x7, 0x0 }, // 3161 + { PseudoVLOXEI16_V_MF4_MF2_MASK, VLOXEI16_V, 0x7, 0x0 }, // 3162 + { PseudoVLOXEI32_V_M1_M1, VLOXEI32_V, 0x0, 0x0 }, // 3163 + { PseudoVLOXEI32_V_M1_M1_MASK, VLOXEI32_V, 0x0, 0x0 }, // 3164 + { PseudoVLOXEI32_V_M2_M1, VLOXEI32_V, 0x0, 0x0 }, // 3165 + { PseudoVLOXEI32_V_M2_M1_MASK, VLOXEI32_V, 0x0, 0x0 }, // 3166 + { PseudoVLOXEI32_V_M4_M1, VLOXEI32_V, 0x0, 0x0 }, // 3167 + { PseudoVLOXEI32_V_M4_M1_MASK, VLOXEI32_V, 0x0, 0x0 }, // 3168 + { PseudoVLOXEI32_V_MF2_M1, VLOXEI32_V, 0x0, 0x0 }, // 3169 + { PseudoVLOXEI32_V_MF2_M1_MASK, VLOXEI32_V, 0x0, 0x0 }, // 3170 + { PseudoVLOXEI32_V_M1_M2, VLOXEI32_V, 0x1, 0x0 }, // 3171 + { PseudoVLOXEI32_V_M1_M2_MASK, VLOXEI32_V, 0x1, 0x0 }, // 3172 + { PseudoVLOXEI32_V_M2_M2, VLOXEI32_V, 0x1, 0x0 }, // 3173 + { PseudoVLOXEI32_V_M2_M2_MASK, VLOXEI32_V, 0x1, 0x0 }, // 3174 + { PseudoVLOXEI32_V_M4_M2, VLOXEI32_V, 0x1, 0x0 }, // 3175 + { PseudoVLOXEI32_V_M4_M2_MASK, VLOXEI32_V, 0x1, 0x0 }, // 3176 + { PseudoVLOXEI32_V_M8_M2, VLOXEI32_V, 0x1, 0x0 }, // 3177 + { PseudoVLOXEI32_V_M8_M2_MASK, VLOXEI32_V, 0x1, 0x0 }, // 3178 + { PseudoVLOXEI32_V_M2_M4, VLOXEI32_V, 0x2, 0x0 }, // 3179 + { PseudoVLOXEI32_V_M2_M4_MASK, VLOXEI32_V, 0x2, 0x0 }, // 3180 + { PseudoVLOXEI32_V_M4_M4, VLOXEI32_V, 0x2, 0x0 }, // 3181 + { PseudoVLOXEI32_V_M4_M4_MASK, VLOXEI32_V, 0x2, 0x0 }, // 3182 + { PseudoVLOXEI32_V_M8_M4, VLOXEI32_V, 0x2, 0x0 }, // 3183 + { PseudoVLOXEI32_V_M8_M4_MASK, VLOXEI32_V, 0x2, 0x0 }, // 3184 + { PseudoVLOXEI32_V_M4_M8, VLOXEI32_V, 0x3, 0x0 }, // 3185 + { PseudoVLOXEI32_V_M4_M8_MASK, VLOXEI32_V, 0x3, 0x0 }, // 3186 + { PseudoVLOXEI32_V_M8_M8, VLOXEI32_V, 0x3, 0x0 }, // 3187 + { PseudoVLOXEI32_V_M8_M8_MASK, VLOXEI32_V, 0x3, 0x0 }, // 3188 + { PseudoVLOXEI32_V_MF2_MF8, VLOXEI32_V, 0x5, 0x0 }, // 3189 + { PseudoVLOXEI32_V_MF2_MF8_MASK, VLOXEI32_V, 0x5, 0x0 }, // 3190 + { PseudoVLOXEI32_V_M1_MF4, VLOXEI32_V, 0x6, 0x0 }, // 3191 + { PseudoVLOXEI32_V_M1_MF4_MASK, VLOXEI32_V, 0x6, 0x0 }, // 3192 + { PseudoVLOXEI32_V_MF2_MF4, VLOXEI32_V, 0x6, 0x0 }, // 3193 + { PseudoVLOXEI32_V_MF2_MF4_MASK, VLOXEI32_V, 0x6, 0x0 }, // 3194 + { PseudoVLOXEI32_V_M1_MF2, VLOXEI32_V, 0x7, 0x0 }, // 3195 + { PseudoVLOXEI32_V_M1_MF2_MASK, VLOXEI32_V, 0x7, 0x0 }, // 3196 + { PseudoVLOXEI32_V_M2_MF2, VLOXEI32_V, 0x7, 0x0 }, // 3197 + { PseudoVLOXEI32_V_M2_MF2_MASK, VLOXEI32_V, 0x7, 0x0 }, // 3198 + { PseudoVLOXEI32_V_MF2_MF2, VLOXEI32_V, 0x7, 0x0 }, // 3199 + { PseudoVLOXEI32_V_MF2_MF2_MASK, VLOXEI32_V, 0x7, 0x0 }, // 3200 + { PseudoVLOXEI64_V_M1_M1, VLOXEI64_V, 0x0, 0x0 }, // 3201 + { PseudoVLOXEI64_V_M1_M1_MASK, VLOXEI64_V, 0x0, 0x0 }, // 3202 + { PseudoVLOXEI64_V_M2_M1, VLOXEI64_V, 0x0, 0x0 }, // 3203 + { PseudoVLOXEI64_V_M2_M1_MASK, VLOXEI64_V, 0x0, 0x0 }, // 3204 + { PseudoVLOXEI64_V_M4_M1, VLOXEI64_V, 0x0, 0x0 }, // 3205 + { PseudoVLOXEI64_V_M4_M1_MASK, VLOXEI64_V, 0x0, 0x0 }, // 3206 + { PseudoVLOXEI64_V_M8_M1, VLOXEI64_V, 0x0, 0x0 }, // 3207 + { PseudoVLOXEI64_V_M8_M1_MASK, VLOXEI64_V, 0x0, 0x0 }, // 3208 + { PseudoVLOXEI64_V_M2_M2, VLOXEI64_V, 0x1, 0x0 }, // 3209 + { PseudoVLOXEI64_V_M2_M2_MASK, VLOXEI64_V, 0x1, 0x0 }, // 3210 + { PseudoVLOXEI64_V_M4_M2, VLOXEI64_V, 0x1, 0x0 }, // 3211 + { PseudoVLOXEI64_V_M4_M2_MASK, VLOXEI64_V, 0x1, 0x0 }, // 3212 + { PseudoVLOXEI64_V_M8_M2, VLOXEI64_V, 0x1, 0x0 }, // 3213 + { PseudoVLOXEI64_V_M8_M2_MASK, VLOXEI64_V, 0x1, 0x0 }, // 3214 + { PseudoVLOXEI64_V_M4_M4, VLOXEI64_V, 0x2, 0x0 }, // 3215 + { PseudoVLOXEI64_V_M4_M4_MASK, VLOXEI64_V, 0x2, 0x0 }, // 3216 + { PseudoVLOXEI64_V_M8_M4, VLOXEI64_V, 0x2, 0x0 }, // 3217 + { PseudoVLOXEI64_V_M8_M4_MASK, VLOXEI64_V, 0x2, 0x0 }, // 3218 + { PseudoVLOXEI64_V_M8_M8, VLOXEI64_V, 0x3, 0x0 }, // 3219 + { PseudoVLOXEI64_V_M8_M8_MASK, VLOXEI64_V, 0x3, 0x0 }, // 3220 + { PseudoVLOXEI64_V_M1_MF8, VLOXEI64_V, 0x5, 0x0 }, // 3221 + { PseudoVLOXEI64_V_M1_MF8_MASK, VLOXEI64_V, 0x5, 0x0 }, // 3222 + { PseudoVLOXEI64_V_M1_MF4, VLOXEI64_V, 0x6, 0x0 }, // 3223 + { PseudoVLOXEI64_V_M1_MF4_MASK, VLOXEI64_V, 0x6, 0x0 }, // 3224 + { PseudoVLOXEI64_V_M2_MF4, VLOXEI64_V, 0x6, 0x0 }, // 3225 + { PseudoVLOXEI64_V_M2_MF4_MASK, VLOXEI64_V, 0x6, 0x0 }, // 3226 + { PseudoVLOXEI64_V_M1_MF2, VLOXEI64_V, 0x7, 0x0 }, // 3227 + { PseudoVLOXEI64_V_M1_MF2_MASK, VLOXEI64_V, 0x7, 0x0 }, // 3228 + { PseudoVLOXEI64_V_M2_MF2, VLOXEI64_V, 0x7, 0x0 }, // 3229 + { PseudoVLOXEI64_V_M2_MF2_MASK, VLOXEI64_V, 0x7, 0x0 }, // 3230 + { PseudoVLOXEI64_V_M4_MF2, VLOXEI64_V, 0x7, 0x0 }, // 3231 + { PseudoVLOXEI64_V_M4_MF2_MASK, VLOXEI64_V, 0x7, 0x0 }, // 3232 + { PseudoVLOXEI8_V_M1_M1, VLOXEI8_V, 0x0, 0x0 }, // 3233 + { PseudoVLOXEI8_V_M1_M1_MASK, VLOXEI8_V, 0x0, 0x0 }, // 3234 + { PseudoVLOXEI8_V_MF2_M1, VLOXEI8_V, 0x0, 0x0 }, // 3235 + { PseudoVLOXEI8_V_MF2_M1_MASK, VLOXEI8_V, 0x0, 0x0 }, // 3236 + { PseudoVLOXEI8_V_MF4_M1, VLOXEI8_V, 0x0, 0x0 }, // 3237 + { PseudoVLOXEI8_V_MF4_M1_MASK, VLOXEI8_V, 0x0, 0x0 }, // 3238 + { PseudoVLOXEI8_V_MF8_M1, VLOXEI8_V, 0x0, 0x0 }, // 3239 + { PseudoVLOXEI8_V_MF8_M1_MASK, VLOXEI8_V, 0x0, 0x0 }, // 3240 + { PseudoVLOXEI8_V_M1_M2, VLOXEI8_V, 0x1, 0x0 }, // 3241 + { PseudoVLOXEI8_V_M1_M2_MASK, VLOXEI8_V, 0x1, 0x0 }, // 3242 + { PseudoVLOXEI8_V_M2_M2, VLOXEI8_V, 0x1, 0x0 }, // 3243 + { PseudoVLOXEI8_V_M2_M2_MASK, VLOXEI8_V, 0x1, 0x0 }, // 3244 + { PseudoVLOXEI8_V_MF2_M2, VLOXEI8_V, 0x1, 0x0 }, // 3245 + { PseudoVLOXEI8_V_MF2_M2_MASK, VLOXEI8_V, 0x1, 0x0 }, // 3246 + { PseudoVLOXEI8_V_MF4_M2, VLOXEI8_V, 0x1, 0x0 }, // 3247 + { PseudoVLOXEI8_V_MF4_M2_MASK, VLOXEI8_V, 0x1, 0x0 }, // 3248 + { PseudoVLOXEI8_V_M1_M4, VLOXEI8_V, 0x2, 0x0 }, // 3249 + { PseudoVLOXEI8_V_M1_M4_MASK, VLOXEI8_V, 0x2, 0x0 }, // 3250 + { PseudoVLOXEI8_V_M2_M4, VLOXEI8_V, 0x2, 0x0 }, // 3251 + { PseudoVLOXEI8_V_M2_M4_MASK, VLOXEI8_V, 0x2, 0x0 }, // 3252 + { PseudoVLOXEI8_V_M4_M4, VLOXEI8_V, 0x2, 0x0 }, // 3253 + { PseudoVLOXEI8_V_M4_M4_MASK, VLOXEI8_V, 0x2, 0x0 }, // 3254 + { PseudoVLOXEI8_V_MF2_M4, VLOXEI8_V, 0x2, 0x0 }, // 3255 + { PseudoVLOXEI8_V_MF2_M4_MASK, VLOXEI8_V, 0x2, 0x0 }, // 3256 + { PseudoVLOXEI8_V_M1_M8, VLOXEI8_V, 0x3, 0x0 }, // 3257 + { PseudoVLOXEI8_V_M1_M8_MASK, VLOXEI8_V, 0x3, 0x0 }, // 3258 + { PseudoVLOXEI8_V_M2_M8, VLOXEI8_V, 0x3, 0x0 }, // 3259 + { PseudoVLOXEI8_V_M2_M8_MASK, VLOXEI8_V, 0x3, 0x0 }, // 3260 + { PseudoVLOXEI8_V_M4_M8, VLOXEI8_V, 0x3, 0x0 }, // 3261 + { PseudoVLOXEI8_V_M4_M8_MASK, VLOXEI8_V, 0x3, 0x0 }, // 3262 + { PseudoVLOXEI8_V_M8_M8, VLOXEI8_V, 0x3, 0x0 }, // 3263 + { PseudoVLOXEI8_V_M8_M8_MASK, VLOXEI8_V, 0x3, 0x0 }, // 3264 + { PseudoVLOXEI8_V_MF8_MF8, VLOXEI8_V, 0x5, 0x0 }, // 3265 + { PseudoVLOXEI8_V_MF8_MF8_MASK, VLOXEI8_V, 0x5, 0x0 }, // 3266 + { PseudoVLOXEI8_V_MF4_MF4, VLOXEI8_V, 0x6, 0x0 }, // 3267 + { PseudoVLOXEI8_V_MF4_MF4_MASK, VLOXEI8_V, 0x6, 0x0 }, // 3268 + { PseudoVLOXEI8_V_MF8_MF4, VLOXEI8_V, 0x6, 0x0 }, // 3269 + { PseudoVLOXEI8_V_MF8_MF4_MASK, VLOXEI8_V, 0x6, 0x0 }, // 3270 + { PseudoVLOXEI8_V_MF2_MF2, VLOXEI8_V, 0x7, 0x0 }, // 3271 + { PseudoVLOXEI8_V_MF2_MF2_MASK, VLOXEI8_V, 0x7, 0x0 }, // 3272 + { PseudoVLOXEI8_V_MF4_MF2, VLOXEI8_V, 0x7, 0x0 }, // 3273 + { PseudoVLOXEI8_V_MF4_MF2_MASK, VLOXEI8_V, 0x7, 0x0 }, // 3274 + { PseudoVLOXEI8_V_MF8_MF2, VLOXEI8_V, 0x7, 0x0 }, // 3275 + { PseudoVLOXEI8_V_MF8_MF2_MASK, VLOXEI8_V, 0x7, 0x0 }, // 3276 + { PseudoVLOXSEG2EI16_V_M1_M1, VLOXSEG2EI16_V, 0x0, 0x0 }, // 3277 + { PseudoVLOXSEG2EI16_V_M1_M1_MASK, VLOXSEG2EI16_V, 0x0, 0x0 }, // 3278 + { PseudoVLOXSEG2EI16_V_M2_M1, VLOXSEG2EI16_V, 0x0, 0x0 }, // 3279 + { PseudoVLOXSEG2EI16_V_M2_M1_MASK, VLOXSEG2EI16_V, 0x0, 0x0 }, // 3280 + { PseudoVLOXSEG2EI16_V_MF2_M1, VLOXSEG2EI16_V, 0x0, 0x0 }, // 3281 + { PseudoVLOXSEG2EI16_V_MF2_M1_MASK, VLOXSEG2EI16_V, 0x0, 0x0 }, // 3282 + { PseudoVLOXSEG2EI16_V_MF4_M1, VLOXSEG2EI16_V, 0x0, 0x0 }, // 3283 + { PseudoVLOXSEG2EI16_V_MF4_M1_MASK, VLOXSEG2EI16_V, 0x0, 0x0 }, // 3284 + { PseudoVLOXSEG2EI16_V_M1_M2, VLOXSEG2EI16_V, 0x1, 0x0 }, // 3285 + { PseudoVLOXSEG2EI16_V_M1_M2_MASK, VLOXSEG2EI16_V, 0x1, 0x0 }, // 3286 + { PseudoVLOXSEG2EI16_V_M2_M2, VLOXSEG2EI16_V, 0x1, 0x0 }, // 3287 + { PseudoVLOXSEG2EI16_V_M2_M2_MASK, VLOXSEG2EI16_V, 0x1, 0x0 }, // 3288 + { PseudoVLOXSEG2EI16_V_M4_M2, VLOXSEG2EI16_V, 0x1, 0x0 }, // 3289 + { PseudoVLOXSEG2EI16_V_M4_M2_MASK, VLOXSEG2EI16_V, 0x1, 0x0 }, // 3290 + { PseudoVLOXSEG2EI16_V_MF2_M2, VLOXSEG2EI16_V, 0x1, 0x0 }, // 3291 + { PseudoVLOXSEG2EI16_V_MF2_M2_MASK, VLOXSEG2EI16_V, 0x1, 0x0 }, // 3292 + { PseudoVLOXSEG2EI16_V_M1_M4, VLOXSEG2EI16_V, 0x2, 0x0 }, // 3293 + { PseudoVLOXSEG2EI16_V_M1_M4_MASK, VLOXSEG2EI16_V, 0x2, 0x0 }, // 3294 + { PseudoVLOXSEG2EI16_V_M2_M4, VLOXSEG2EI16_V, 0x2, 0x0 }, // 3295 + { PseudoVLOXSEG2EI16_V_M2_M4_MASK, VLOXSEG2EI16_V, 0x2, 0x0 }, // 3296 + { PseudoVLOXSEG2EI16_V_M4_M4, VLOXSEG2EI16_V, 0x2, 0x0 }, // 3297 + { PseudoVLOXSEG2EI16_V_M4_M4_MASK, VLOXSEG2EI16_V, 0x2, 0x0 }, // 3298 + { PseudoVLOXSEG2EI16_V_M8_M4, VLOXSEG2EI16_V, 0x2, 0x0 }, // 3299 + { PseudoVLOXSEG2EI16_V_M8_M4_MASK, VLOXSEG2EI16_V, 0x2, 0x0 }, // 3300 + { PseudoVLOXSEG2EI16_V_MF4_MF8, VLOXSEG2EI16_V, 0x5, 0x0 }, // 3301 + { PseudoVLOXSEG2EI16_V_MF4_MF8_MASK, VLOXSEG2EI16_V, 0x5, 0x0 }, // 3302 + { PseudoVLOXSEG2EI16_V_MF2_MF4, VLOXSEG2EI16_V, 0x6, 0x0 }, // 3303 + { PseudoVLOXSEG2EI16_V_MF2_MF4_MASK, VLOXSEG2EI16_V, 0x6, 0x0 }, // 3304 + { PseudoVLOXSEG2EI16_V_MF4_MF4, VLOXSEG2EI16_V, 0x6, 0x0 }, // 3305 + { PseudoVLOXSEG2EI16_V_MF4_MF4_MASK, VLOXSEG2EI16_V, 0x6, 0x0 }, // 3306 + { PseudoVLOXSEG2EI16_V_M1_MF2, VLOXSEG2EI16_V, 0x7, 0x0 }, // 3307 + { PseudoVLOXSEG2EI16_V_M1_MF2_MASK, VLOXSEG2EI16_V, 0x7, 0x0 }, // 3308 + { PseudoVLOXSEG2EI16_V_MF2_MF2, VLOXSEG2EI16_V, 0x7, 0x0 }, // 3309 + { PseudoVLOXSEG2EI16_V_MF2_MF2_MASK, VLOXSEG2EI16_V, 0x7, 0x0 }, // 3310 + { PseudoVLOXSEG2EI16_V_MF4_MF2, VLOXSEG2EI16_V, 0x7, 0x0 }, // 3311 + { PseudoVLOXSEG2EI16_V_MF4_MF2_MASK, VLOXSEG2EI16_V, 0x7, 0x0 }, // 3312 + { PseudoVLOXSEG2EI32_V_M1_M1, VLOXSEG2EI32_V, 0x0, 0x0 }, // 3313 + { PseudoVLOXSEG2EI32_V_M1_M1_MASK, VLOXSEG2EI32_V, 0x0, 0x0 }, // 3314 + { PseudoVLOXSEG2EI32_V_M2_M1, VLOXSEG2EI32_V, 0x0, 0x0 }, // 3315 + { PseudoVLOXSEG2EI32_V_M2_M1_MASK, VLOXSEG2EI32_V, 0x0, 0x0 }, // 3316 + { PseudoVLOXSEG2EI32_V_M4_M1, VLOXSEG2EI32_V, 0x0, 0x0 }, // 3317 + { PseudoVLOXSEG2EI32_V_M4_M1_MASK, VLOXSEG2EI32_V, 0x0, 0x0 }, // 3318 + { PseudoVLOXSEG2EI32_V_MF2_M1, VLOXSEG2EI32_V, 0x0, 0x0 }, // 3319 + { PseudoVLOXSEG2EI32_V_MF2_M1_MASK, VLOXSEG2EI32_V, 0x0, 0x0 }, // 3320 + { PseudoVLOXSEG2EI32_V_M1_M2, VLOXSEG2EI32_V, 0x1, 0x0 }, // 3321 + { PseudoVLOXSEG2EI32_V_M1_M2_MASK, VLOXSEG2EI32_V, 0x1, 0x0 }, // 3322 + { PseudoVLOXSEG2EI32_V_M2_M2, VLOXSEG2EI32_V, 0x1, 0x0 }, // 3323 + { PseudoVLOXSEG2EI32_V_M2_M2_MASK, VLOXSEG2EI32_V, 0x1, 0x0 }, // 3324 + { PseudoVLOXSEG2EI32_V_M4_M2, VLOXSEG2EI32_V, 0x1, 0x0 }, // 3325 + { PseudoVLOXSEG2EI32_V_M4_M2_MASK, VLOXSEG2EI32_V, 0x1, 0x0 }, // 3326 + { PseudoVLOXSEG2EI32_V_M8_M2, VLOXSEG2EI32_V, 0x1, 0x0 }, // 3327 + { PseudoVLOXSEG2EI32_V_M8_M2_MASK, VLOXSEG2EI32_V, 0x1, 0x0 }, // 3328 + { PseudoVLOXSEG2EI32_V_M2_M4, VLOXSEG2EI32_V, 0x2, 0x0 }, // 3329 + { PseudoVLOXSEG2EI32_V_M2_M4_MASK, VLOXSEG2EI32_V, 0x2, 0x0 }, // 3330 + { PseudoVLOXSEG2EI32_V_M4_M4, VLOXSEG2EI32_V, 0x2, 0x0 }, // 3331 + { PseudoVLOXSEG2EI32_V_M4_M4_MASK, VLOXSEG2EI32_V, 0x2, 0x0 }, // 3332 + { PseudoVLOXSEG2EI32_V_M8_M4, VLOXSEG2EI32_V, 0x2, 0x0 }, // 3333 + { PseudoVLOXSEG2EI32_V_M8_M4_MASK, VLOXSEG2EI32_V, 0x2, 0x0 }, // 3334 + { PseudoVLOXSEG2EI32_V_MF2_MF8, VLOXSEG2EI32_V, 0x5, 0x0 }, // 3335 + { PseudoVLOXSEG2EI32_V_MF2_MF8_MASK, VLOXSEG2EI32_V, 0x5, 0x0 }, // 3336 + { PseudoVLOXSEG2EI32_V_M1_MF4, VLOXSEG2EI32_V, 0x6, 0x0 }, // 3337 + { PseudoVLOXSEG2EI32_V_M1_MF4_MASK, VLOXSEG2EI32_V, 0x6, 0x0 }, // 3338 + { PseudoVLOXSEG2EI32_V_MF2_MF4, VLOXSEG2EI32_V, 0x6, 0x0 }, // 3339 + { PseudoVLOXSEG2EI32_V_MF2_MF4_MASK, VLOXSEG2EI32_V, 0x6, 0x0 }, // 3340 + { PseudoVLOXSEG2EI32_V_M1_MF2, VLOXSEG2EI32_V, 0x7, 0x0 }, // 3341 + { PseudoVLOXSEG2EI32_V_M1_MF2_MASK, VLOXSEG2EI32_V, 0x7, 0x0 }, // 3342 + { PseudoVLOXSEG2EI32_V_M2_MF2, VLOXSEG2EI32_V, 0x7, 0x0 }, // 3343 + { PseudoVLOXSEG2EI32_V_M2_MF2_MASK, VLOXSEG2EI32_V, 0x7, 0x0 }, // 3344 + { PseudoVLOXSEG2EI32_V_MF2_MF2, VLOXSEG2EI32_V, 0x7, 0x0 }, // 3345 + { PseudoVLOXSEG2EI32_V_MF2_MF2_MASK, VLOXSEG2EI32_V, 0x7, 0x0 }, // 3346 + { PseudoVLOXSEG2EI64_V_M1_M1, VLOXSEG2EI64_V, 0x0, 0x0 }, // 3347 + { PseudoVLOXSEG2EI64_V_M1_M1_MASK, VLOXSEG2EI64_V, 0x0, 0x0 }, // 3348 + { PseudoVLOXSEG2EI64_V_M2_M1, VLOXSEG2EI64_V, 0x0, 0x0 }, // 3349 + { PseudoVLOXSEG2EI64_V_M2_M1_MASK, VLOXSEG2EI64_V, 0x0, 0x0 }, // 3350 + { PseudoVLOXSEG2EI64_V_M4_M1, VLOXSEG2EI64_V, 0x0, 0x0 }, // 3351 + { PseudoVLOXSEG2EI64_V_M4_M1_MASK, VLOXSEG2EI64_V, 0x0, 0x0 }, // 3352 + { PseudoVLOXSEG2EI64_V_M8_M1, VLOXSEG2EI64_V, 0x0, 0x0 }, // 3353 + { PseudoVLOXSEG2EI64_V_M8_M1_MASK, VLOXSEG2EI64_V, 0x0, 0x0 }, // 3354 + { PseudoVLOXSEG2EI64_V_M2_M2, VLOXSEG2EI64_V, 0x1, 0x0 }, // 3355 + { PseudoVLOXSEG2EI64_V_M2_M2_MASK, VLOXSEG2EI64_V, 0x1, 0x0 }, // 3356 + { PseudoVLOXSEG2EI64_V_M4_M2, VLOXSEG2EI64_V, 0x1, 0x0 }, // 3357 + { PseudoVLOXSEG2EI64_V_M4_M2_MASK, VLOXSEG2EI64_V, 0x1, 0x0 }, // 3358 + { PseudoVLOXSEG2EI64_V_M8_M2, VLOXSEG2EI64_V, 0x1, 0x0 }, // 3359 + { PseudoVLOXSEG2EI64_V_M8_M2_MASK, VLOXSEG2EI64_V, 0x1, 0x0 }, // 3360 + { PseudoVLOXSEG2EI64_V_M4_M4, VLOXSEG2EI64_V, 0x2, 0x0 }, // 3361 + { PseudoVLOXSEG2EI64_V_M4_M4_MASK, VLOXSEG2EI64_V, 0x2, 0x0 }, // 3362 + { PseudoVLOXSEG2EI64_V_M8_M4, VLOXSEG2EI64_V, 0x2, 0x0 }, // 3363 + { PseudoVLOXSEG2EI64_V_M8_M4_MASK, VLOXSEG2EI64_V, 0x2, 0x0 }, // 3364 + { PseudoVLOXSEG2EI64_V_M1_MF8, VLOXSEG2EI64_V, 0x5, 0x0 }, // 3365 + { PseudoVLOXSEG2EI64_V_M1_MF8_MASK, VLOXSEG2EI64_V, 0x5, 0x0 }, // 3366 + { PseudoVLOXSEG2EI64_V_M1_MF4, VLOXSEG2EI64_V, 0x6, 0x0 }, // 3367 + { PseudoVLOXSEG2EI64_V_M1_MF4_MASK, VLOXSEG2EI64_V, 0x6, 0x0 }, // 3368 + { PseudoVLOXSEG2EI64_V_M2_MF4, VLOXSEG2EI64_V, 0x6, 0x0 }, // 3369 + { PseudoVLOXSEG2EI64_V_M2_MF4_MASK, VLOXSEG2EI64_V, 0x6, 0x0 }, // 3370 + { PseudoVLOXSEG2EI64_V_M1_MF2, VLOXSEG2EI64_V, 0x7, 0x0 }, // 3371 + { PseudoVLOXSEG2EI64_V_M1_MF2_MASK, VLOXSEG2EI64_V, 0x7, 0x0 }, // 3372 + { PseudoVLOXSEG2EI64_V_M2_MF2, VLOXSEG2EI64_V, 0x7, 0x0 }, // 3373 + { PseudoVLOXSEG2EI64_V_M2_MF2_MASK, VLOXSEG2EI64_V, 0x7, 0x0 }, // 3374 + { PseudoVLOXSEG2EI64_V_M4_MF2, VLOXSEG2EI64_V, 0x7, 0x0 }, // 3375 + { PseudoVLOXSEG2EI64_V_M4_MF2_MASK, VLOXSEG2EI64_V, 0x7, 0x0 }, // 3376 + { PseudoVLOXSEG2EI8_V_M1_M1, VLOXSEG2EI8_V, 0x0, 0x0 }, // 3377 + { PseudoVLOXSEG2EI8_V_M1_M1_MASK, VLOXSEG2EI8_V, 0x0, 0x0 }, // 3378 + { PseudoVLOXSEG2EI8_V_MF2_M1, VLOXSEG2EI8_V, 0x0, 0x0 }, // 3379 + { PseudoVLOXSEG2EI8_V_MF2_M1_MASK, VLOXSEG2EI8_V, 0x0, 0x0 }, // 3380 + { PseudoVLOXSEG2EI8_V_MF4_M1, VLOXSEG2EI8_V, 0x0, 0x0 }, // 3381 + { PseudoVLOXSEG2EI8_V_MF4_M1_MASK, VLOXSEG2EI8_V, 0x0, 0x0 }, // 3382 + { PseudoVLOXSEG2EI8_V_MF8_M1, VLOXSEG2EI8_V, 0x0, 0x0 }, // 3383 + { PseudoVLOXSEG2EI8_V_MF8_M1_MASK, VLOXSEG2EI8_V, 0x0, 0x0 }, // 3384 + { PseudoVLOXSEG2EI8_V_M1_M2, VLOXSEG2EI8_V, 0x1, 0x0 }, // 3385 + { PseudoVLOXSEG2EI8_V_M1_M2_MASK, VLOXSEG2EI8_V, 0x1, 0x0 }, // 3386 + { PseudoVLOXSEG2EI8_V_M2_M2, VLOXSEG2EI8_V, 0x1, 0x0 }, // 3387 + { PseudoVLOXSEG2EI8_V_M2_M2_MASK, VLOXSEG2EI8_V, 0x1, 0x0 }, // 3388 + { PseudoVLOXSEG2EI8_V_MF2_M2, VLOXSEG2EI8_V, 0x1, 0x0 }, // 3389 + { PseudoVLOXSEG2EI8_V_MF2_M2_MASK, VLOXSEG2EI8_V, 0x1, 0x0 }, // 3390 + { PseudoVLOXSEG2EI8_V_MF4_M2, VLOXSEG2EI8_V, 0x1, 0x0 }, // 3391 + { PseudoVLOXSEG2EI8_V_MF4_M2_MASK, VLOXSEG2EI8_V, 0x1, 0x0 }, // 3392 + { PseudoVLOXSEG2EI8_V_M1_M4, VLOXSEG2EI8_V, 0x2, 0x0 }, // 3393 + { PseudoVLOXSEG2EI8_V_M1_M4_MASK, VLOXSEG2EI8_V, 0x2, 0x0 }, // 3394 + { PseudoVLOXSEG2EI8_V_M2_M4, VLOXSEG2EI8_V, 0x2, 0x0 }, // 3395 + { PseudoVLOXSEG2EI8_V_M2_M4_MASK, VLOXSEG2EI8_V, 0x2, 0x0 }, // 3396 + { PseudoVLOXSEG2EI8_V_M4_M4, VLOXSEG2EI8_V, 0x2, 0x0 }, // 3397 + { PseudoVLOXSEG2EI8_V_M4_M4_MASK, VLOXSEG2EI8_V, 0x2, 0x0 }, // 3398 + { PseudoVLOXSEG2EI8_V_MF2_M4, VLOXSEG2EI8_V, 0x2, 0x0 }, // 3399 + { PseudoVLOXSEG2EI8_V_MF2_M4_MASK, VLOXSEG2EI8_V, 0x2, 0x0 }, // 3400 + { PseudoVLOXSEG2EI8_V_MF8_MF8, VLOXSEG2EI8_V, 0x5, 0x0 }, // 3401 + { PseudoVLOXSEG2EI8_V_MF8_MF8_MASK, VLOXSEG2EI8_V, 0x5, 0x0 }, // 3402 + { PseudoVLOXSEG2EI8_V_MF4_MF4, VLOXSEG2EI8_V, 0x6, 0x0 }, // 3403 + { PseudoVLOXSEG2EI8_V_MF4_MF4_MASK, VLOXSEG2EI8_V, 0x6, 0x0 }, // 3404 + { PseudoVLOXSEG2EI8_V_MF8_MF4, VLOXSEG2EI8_V, 0x6, 0x0 }, // 3405 + { PseudoVLOXSEG2EI8_V_MF8_MF4_MASK, VLOXSEG2EI8_V, 0x6, 0x0 }, // 3406 + { PseudoVLOXSEG2EI8_V_MF2_MF2, VLOXSEG2EI8_V, 0x7, 0x0 }, // 3407 + { PseudoVLOXSEG2EI8_V_MF2_MF2_MASK, VLOXSEG2EI8_V, 0x7, 0x0 }, // 3408 + { PseudoVLOXSEG2EI8_V_MF4_MF2, VLOXSEG2EI8_V, 0x7, 0x0 }, // 3409 + { PseudoVLOXSEG2EI8_V_MF4_MF2_MASK, VLOXSEG2EI8_V, 0x7, 0x0 }, // 3410 + { PseudoVLOXSEG2EI8_V_MF8_MF2, VLOXSEG2EI8_V, 0x7, 0x0 }, // 3411 + { PseudoVLOXSEG2EI8_V_MF8_MF2_MASK, VLOXSEG2EI8_V, 0x7, 0x0 }, // 3412 + { PseudoVLOXSEG3EI16_V_M1_M1, VLOXSEG3EI16_V, 0x0, 0x0 }, // 3413 + { PseudoVLOXSEG3EI16_V_M1_M1_MASK, VLOXSEG3EI16_V, 0x0, 0x0 }, // 3414 + { PseudoVLOXSEG3EI16_V_M2_M1, VLOXSEG3EI16_V, 0x0, 0x0 }, // 3415 + { PseudoVLOXSEG3EI16_V_M2_M1_MASK, VLOXSEG3EI16_V, 0x0, 0x0 }, // 3416 + { PseudoVLOXSEG3EI16_V_MF2_M1, VLOXSEG3EI16_V, 0x0, 0x0 }, // 3417 + { PseudoVLOXSEG3EI16_V_MF2_M1_MASK, VLOXSEG3EI16_V, 0x0, 0x0 }, // 3418 + { PseudoVLOXSEG3EI16_V_MF4_M1, VLOXSEG3EI16_V, 0x0, 0x0 }, // 3419 + { PseudoVLOXSEG3EI16_V_MF4_M1_MASK, VLOXSEG3EI16_V, 0x0, 0x0 }, // 3420 + { PseudoVLOXSEG3EI16_V_M1_M2, VLOXSEG3EI16_V, 0x1, 0x0 }, // 3421 + { PseudoVLOXSEG3EI16_V_M1_M2_MASK, VLOXSEG3EI16_V, 0x1, 0x0 }, // 3422 + { PseudoVLOXSEG3EI16_V_M2_M2, VLOXSEG3EI16_V, 0x1, 0x0 }, // 3423 + { PseudoVLOXSEG3EI16_V_M2_M2_MASK, VLOXSEG3EI16_V, 0x1, 0x0 }, // 3424 + { PseudoVLOXSEG3EI16_V_M4_M2, VLOXSEG3EI16_V, 0x1, 0x0 }, // 3425 + { PseudoVLOXSEG3EI16_V_M4_M2_MASK, VLOXSEG3EI16_V, 0x1, 0x0 }, // 3426 + { PseudoVLOXSEG3EI16_V_MF2_M2, VLOXSEG3EI16_V, 0x1, 0x0 }, // 3427 + { PseudoVLOXSEG3EI16_V_MF2_M2_MASK, VLOXSEG3EI16_V, 0x1, 0x0 }, // 3428 + { PseudoVLOXSEG3EI16_V_MF4_MF8, VLOXSEG3EI16_V, 0x5, 0x0 }, // 3429 + { PseudoVLOXSEG3EI16_V_MF4_MF8_MASK, VLOXSEG3EI16_V, 0x5, 0x0 }, // 3430 + { PseudoVLOXSEG3EI16_V_MF2_MF4, VLOXSEG3EI16_V, 0x6, 0x0 }, // 3431 + { PseudoVLOXSEG3EI16_V_MF2_MF4_MASK, VLOXSEG3EI16_V, 0x6, 0x0 }, // 3432 + { PseudoVLOXSEG3EI16_V_MF4_MF4, VLOXSEG3EI16_V, 0x6, 0x0 }, // 3433 + { PseudoVLOXSEG3EI16_V_MF4_MF4_MASK, VLOXSEG3EI16_V, 0x6, 0x0 }, // 3434 + { PseudoVLOXSEG3EI16_V_M1_MF2, VLOXSEG3EI16_V, 0x7, 0x0 }, // 3435 + { PseudoVLOXSEG3EI16_V_M1_MF2_MASK, VLOXSEG3EI16_V, 0x7, 0x0 }, // 3436 + { PseudoVLOXSEG3EI16_V_MF2_MF2, VLOXSEG3EI16_V, 0x7, 0x0 }, // 3437 + { PseudoVLOXSEG3EI16_V_MF2_MF2_MASK, VLOXSEG3EI16_V, 0x7, 0x0 }, // 3438 + { PseudoVLOXSEG3EI16_V_MF4_MF2, VLOXSEG3EI16_V, 0x7, 0x0 }, // 3439 + { PseudoVLOXSEG3EI16_V_MF4_MF2_MASK, VLOXSEG3EI16_V, 0x7, 0x0 }, // 3440 + { PseudoVLOXSEG3EI32_V_M1_M1, VLOXSEG3EI32_V, 0x0, 0x0 }, // 3441 + { PseudoVLOXSEG3EI32_V_M1_M1_MASK, VLOXSEG3EI32_V, 0x0, 0x0 }, // 3442 + { PseudoVLOXSEG3EI32_V_M2_M1, VLOXSEG3EI32_V, 0x0, 0x0 }, // 3443 + { PseudoVLOXSEG3EI32_V_M2_M1_MASK, VLOXSEG3EI32_V, 0x0, 0x0 }, // 3444 + { PseudoVLOXSEG3EI32_V_M4_M1, VLOXSEG3EI32_V, 0x0, 0x0 }, // 3445 + { PseudoVLOXSEG3EI32_V_M4_M1_MASK, VLOXSEG3EI32_V, 0x0, 0x0 }, // 3446 + { PseudoVLOXSEG3EI32_V_MF2_M1, VLOXSEG3EI32_V, 0x0, 0x0 }, // 3447 + { PseudoVLOXSEG3EI32_V_MF2_M1_MASK, VLOXSEG3EI32_V, 0x0, 0x0 }, // 3448 + { PseudoVLOXSEG3EI32_V_M1_M2, VLOXSEG3EI32_V, 0x1, 0x0 }, // 3449 + { PseudoVLOXSEG3EI32_V_M1_M2_MASK, VLOXSEG3EI32_V, 0x1, 0x0 }, // 3450 + { PseudoVLOXSEG3EI32_V_M2_M2, VLOXSEG3EI32_V, 0x1, 0x0 }, // 3451 + { PseudoVLOXSEG3EI32_V_M2_M2_MASK, VLOXSEG3EI32_V, 0x1, 0x0 }, // 3452 + { PseudoVLOXSEG3EI32_V_M4_M2, VLOXSEG3EI32_V, 0x1, 0x0 }, // 3453 + { PseudoVLOXSEG3EI32_V_M4_M2_MASK, VLOXSEG3EI32_V, 0x1, 0x0 }, // 3454 + { PseudoVLOXSEG3EI32_V_M8_M2, VLOXSEG3EI32_V, 0x1, 0x0 }, // 3455 + { PseudoVLOXSEG3EI32_V_M8_M2_MASK, VLOXSEG3EI32_V, 0x1, 0x0 }, // 3456 + { PseudoVLOXSEG3EI32_V_MF2_MF8, VLOXSEG3EI32_V, 0x5, 0x0 }, // 3457 + { PseudoVLOXSEG3EI32_V_MF2_MF8_MASK, VLOXSEG3EI32_V, 0x5, 0x0 }, // 3458 + { PseudoVLOXSEG3EI32_V_M1_MF4, VLOXSEG3EI32_V, 0x6, 0x0 }, // 3459 + { PseudoVLOXSEG3EI32_V_M1_MF4_MASK, VLOXSEG3EI32_V, 0x6, 0x0 }, // 3460 + { PseudoVLOXSEG3EI32_V_MF2_MF4, VLOXSEG3EI32_V, 0x6, 0x0 }, // 3461 + { PseudoVLOXSEG3EI32_V_MF2_MF4_MASK, VLOXSEG3EI32_V, 0x6, 0x0 }, // 3462 + { PseudoVLOXSEG3EI32_V_M1_MF2, VLOXSEG3EI32_V, 0x7, 0x0 }, // 3463 + { PseudoVLOXSEG3EI32_V_M1_MF2_MASK, VLOXSEG3EI32_V, 0x7, 0x0 }, // 3464 + { PseudoVLOXSEG3EI32_V_M2_MF2, VLOXSEG3EI32_V, 0x7, 0x0 }, // 3465 + { PseudoVLOXSEG3EI32_V_M2_MF2_MASK, VLOXSEG3EI32_V, 0x7, 0x0 }, // 3466 + { PseudoVLOXSEG3EI32_V_MF2_MF2, VLOXSEG3EI32_V, 0x7, 0x0 }, // 3467 + { PseudoVLOXSEG3EI32_V_MF2_MF2_MASK, VLOXSEG3EI32_V, 0x7, 0x0 }, // 3468 + { PseudoVLOXSEG3EI64_V_M1_M1, VLOXSEG3EI64_V, 0x0, 0x0 }, // 3469 + { PseudoVLOXSEG3EI64_V_M1_M1_MASK, VLOXSEG3EI64_V, 0x0, 0x0 }, // 3470 + { PseudoVLOXSEG3EI64_V_M2_M1, VLOXSEG3EI64_V, 0x0, 0x0 }, // 3471 + { PseudoVLOXSEG3EI64_V_M2_M1_MASK, VLOXSEG3EI64_V, 0x0, 0x0 }, // 3472 + { PseudoVLOXSEG3EI64_V_M4_M1, VLOXSEG3EI64_V, 0x0, 0x0 }, // 3473 + { PseudoVLOXSEG3EI64_V_M4_M1_MASK, VLOXSEG3EI64_V, 0x0, 0x0 }, // 3474 + { PseudoVLOXSEG3EI64_V_M8_M1, VLOXSEG3EI64_V, 0x0, 0x0 }, // 3475 + { PseudoVLOXSEG3EI64_V_M8_M1_MASK, VLOXSEG3EI64_V, 0x0, 0x0 }, // 3476 + { PseudoVLOXSEG3EI64_V_M2_M2, VLOXSEG3EI64_V, 0x1, 0x0 }, // 3477 + { PseudoVLOXSEG3EI64_V_M2_M2_MASK, VLOXSEG3EI64_V, 0x1, 0x0 }, // 3478 + { PseudoVLOXSEG3EI64_V_M4_M2, VLOXSEG3EI64_V, 0x1, 0x0 }, // 3479 + { PseudoVLOXSEG3EI64_V_M4_M2_MASK, VLOXSEG3EI64_V, 0x1, 0x0 }, // 3480 + { PseudoVLOXSEG3EI64_V_M8_M2, VLOXSEG3EI64_V, 0x1, 0x0 }, // 3481 + { PseudoVLOXSEG3EI64_V_M8_M2_MASK, VLOXSEG3EI64_V, 0x1, 0x0 }, // 3482 + { PseudoVLOXSEG3EI64_V_M1_MF8, VLOXSEG3EI64_V, 0x5, 0x0 }, // 3483 + { PseudoVLOXSEG3EI64_V_M1_MF8_MASK, VLOXSEG3EI64_V, 0x5, 0x0 }, // 3484 + { PseudoVLOXSEG3EI64_V_M1_MF4, VLOXSEG3EI64_V, 0x6, 0x0 }, // 3485 + { PseudoVLOXSEG3EI64_V_M1_MF4_MASK, VLOXSEG3EI64_V, 0x6, 0x0 }, // 3486 + { PseudoVLOXSEG3EI64_V_M2_MF4, VLOXSEG3EI64_V, 0x6, 0x0 }, // 3487 + { PseudoVLOXSEG3EI64_V_M2_MF4_MASK, VLOXSEG3EI64_V, 0x6, 0x0 }, // 3488 + { PseudoVLOXSEG3EI64_V_M1_MF2, VLOXSEG3EI64_V, 0x7, 0x0 }, // 3489 + { PseudoVLOXSEG3EI64_V_M1_MF2_MASK, VLOXSEG3EI64_V, 0x7, 0x0 }, // 3490 + { PseudoVLOXSEG3EI64_V_M2_MF2, VLOXSEG3EI64_V, 0x7, 0x0 }, // 3491 + { PseudoVLOXSEG3EI64_V_M2_MF2_MASK, VLOXSEG3EI64_V, 0x7, 0x0 }, // 3492 + { PseudoVLOXSEG3EI64_V_M4_MF2, VLOXSEG3EI64_V, 0x7, 0x0 }, // 3493 + { PseudoVLOXSEG3EI64_V_M4_MF2_MASK, VLOXSEG3EI64_V, 0x7, 0x0 }, // 3494 + { PseudoVLOXSEG3EI8_V_M1_M1, VLOXSEG3EI8_V, 0x0, 0x0 }, // 3495 + { PseudoVLOXSEG3EI8_V_M1_M1_MASK, VLOXSEG3EI8_V, 0x0, 0x0 }, // 3496 + { PseudoVLOXSEG3EI8_V_MF2_M1, VLOXSEG3EI8_V, 0x0, 0x0 }, // 3497 + { PseudoVLOXSEG3EI8_V_MF2_M1_MASK, VLOXSEG3EI8_V, 0x0, 0x0 }, // 3498 + { PseudoVLOXSEG3EI8_V_MF4_M1, VLOXSEG3EI8_V, 0x0, 0x0 }, // 3499 + { PseudoVLOXSEG3EI8_V_MF4_M1_MASK, VLOXSEG3EI8_V, 0x0, 0x0 }, // 3500 + { PseudoVLOXSEG3EI8_V_MF8_M1, VLOXSEG3EI8_V, 0x0, 0x0 }, // 3501 + { PseudoVLOXSEG3EI8_V_MF8_M1_MASK, VLOXSEG3EI8_V, 0x0, 0x0 }, // 3502 + { PseudoVLOXSEG3EI8_V_M1_M2, VLOXSEG3EI8_V, 0x1, 0x0 }, // 3503 + { PseudoVLOXSEG3EI8_V_M1_M2_MASK, VLOXSEG3EI8_V, 0x1, 0x0 }, // 3504 + { PseudoVLOXSEG3EI8_V_M2_M2, VLOXSEG3EI8_V, 0x1, 0x0 }, // 3505 + { PseudoVLOXSEG3EI8_V_M2_M2_MASK, VLOXSEG3EI8_V, 0x1, 0x0 }, // 3506 + { PseudoVLOXSEG3EI8_V_MF2_M2, VLOXSEG3EI8_V, 0x1, 0x0 }, // 3507 + { PseudoVLOXSEG3EI8_V_MF2_M2_MASK, VLOXSEG3EI8_V, 0x1, 0x0 }, // 3508 + { PseudoVLOXSEG3EI8_V_MF4_M2, VLOXSEG3EI8_V, 0x1, 0x0 }, // 3509 + { PseudoVLOXSEG3EI8_V_MF4_M2_MASK, VLOXSEG3EI8_V, 0x1, 0x0 }, // 3510 + { PseudoVLOXSEG3EI8_V_MF8_MF8, VLOXSEG3EI8_V, 0x5, 0x0 }, // 3511 + { PseudoVLOXSEG3EI8_V_MF8_MF8_MASK, VLOXSEG3EI8_V, 0x5, 0x0 }, // 3512 + { PseudoVLOXSEG3EI8_V_MF4_MF4, VLOXSEG3EI8_V, 0x6, 0x0 }, // 3513 + { PseudoVLOXSEG3EI8_V_MF4_MF4_MASK, VLOXSEG3EI8_V, 0x6, 0x0 }, // 3514 + { PseudoVLOXSEG3EI8_V_MF8_MF4, VLOXSEG3EI8_V, 0x6, 0x0 }, // 3515 + { PseudoVLOXSEG3EI8_V_MF8_MF4_MASK, VLOXSEG3EI8_V, 0x6, 0x0 }, // 3516 + { PseudoVLOXSEG3EI8_V_MF2_MF2, VLOXSEG3EI8_V, 0x7, 0x0 }, // 3517 + { PseudoVLOXSEG3EI8_V_MF2_MF2_MASK, VLOXSEG3EI8_V, 0x7, 0x0 }, // 3518 + { PseudoVLOXSEG3EI8_V_MF4_MF2, VLOXSEG3EI8_V, 0x7, 0x0 }, // 3519 + { PseudoVLOXSEG3EI8_V_MF4_MF2_MASK, VLOXSEG3EI8_V, 0x7, 0x0 }, // 3520 + { PseudoVLOXSEG3EI8_V_MF8_MF2, VLOXSEG3EI8_V, 0x7, 0x0 }, // 3521 + { PseudoVLOXSEG3EI8_V_MF8_MF2_MASK, VLOXSEG3EI8_V, 0x7, 0x0 }, // 3522 + { PseudoVLOXSEG4EI16_V_M1_M1, VLOXSEG4EI16_V, 0x0, 0x0 }, // 3523 + { PseudoVLOXSEG4EI16_V_M1_M1_MASK, VLOXSEG4EI16_V, 0x0, 0x0 }, // 3524 + { PseudoVLOXSEG4EI16_V_M2_M1, VLOXSEG4EI16_V, 0x0, 0x0 }, // 3525 + { PseudoVLOXSEG4EI16_V_M2_M1_MASK, VLOXSEG4EI16_V, 0x0, 0x0 }, // 3526 + { PseudoVLOXSEG4EI16_V_MF2_M1, VLOXSEG4EI16_V, 0x0, 0x0 }, // 3527 + { PseudoVLOXSEG4EI16_V_MF2_M1_MASK, VLOXSEG4EI16_V, 0x0, 0x0 }, // 3528 + { PseudoVLOXSEG4EI16_V_MF4_M1, VLOXSEG4EI16_V, 0x0, 0x0 }, // 3529 + { PseudoVLOXSEG4EI16_V_MF4_M1_MASK, VLOXSEG4EI16_V, 0x0, 0x0 }, // 3530 + { PseudoVLOXSEG4EI16_V_M1_M2, VLOXSEG4EI16_V, 0x1, 0x0 }, // 3531 + { PseudoVLOXSEG4EI16_V_M1_M2_MASK, VLOXSEG4EI16_V, 0x1, 0x0 }, // 3532 + { PseudoVLOXSEG4EI16_V_M2_M2, VLOXSEG4EI16_V, 0x1, 0x0 }, // 3533 + { PseudoVLOXSEG4EI16_V_M2_M2_MASK, VLOXSEG4EI16_V, 0x1, 0x0 }, // 3534 + { PseudoVLOXSEG4EI16_V_M4_M2, VLOXSEG4EI16_V, 0x1, 0x0 }, // 3535 + { PseudoVLOXSEG4EI16_V_M4_M2_MASK, VLOXSEG4EI16_V, 0x1, 0x0 }, // 3536 + { PseudoVLOXSEG4EI16_V_MF2_M2, VLOXSEG4EI16_V, 0x1, 0x0 }, // 3537 + { PseudoVLOXSEG4EI16_V_MF2_M2_MASK, VLOXSEG4EI16_V, 0x1, 0x0 }, // 3538 + { PseudoVLOXSEG4EI16_V_MF4_MF8, VLOXSEG4EI16_V, 0x5, 0x0 }, // 3539 + { PseudoVLOXSEG4EI16_V_MF4_MF8_MASK, VLOXSEG4EI16_V, 0x5, 0x0 }, // 3540 + { PseudoVLOXSEG4EI16_V_MF2_MF4, VLOXSEG4EI16_V, 0x6, 0x0 }, // 3541 + { PseudoVLOXSEG4EI16_V_MF2_MF4_MASK, VLOXSEG4EI16_V, 0x6, 0x0 }, // 3542 + { PseudoVLOXSEG4EI16_V_MF4_MF4, VLOXSEG4EI16_V, 0x6, 0x0 }, // 3543 + { PseudoVLOXSEG4EI16_V_MF4_MF4_MASK, VLOXSEG4EI16_V, 0x6, 0x0 }, // 3544 + { PseudoVLOXSEG4EI16_V_M1_MF2, VLOXSEG4EI16_V, 0x7, 0x0 }, // 3545 + { PseudoVLOXSEG4EI16_V_M1_MF2_MASK, VLOXSEG4EI16_V, 0x7, 0x0 }, // 3546 + { PseudoVLOXSEG4EI16_V_MF2_MF2, VLOXSEG4EI16_V, 0x7, 0x0 }, // 3547 + { PseudoVLOXSEG4EI16_V_MF2_MF2_MASK, VLOXSEG4EI16_V, 0x7, 0x0 }, // 3548 + { PseudoVLOXSEG4EI16_V_MF4_MF2, VLOXSEG4EI16_V, 0x7, 0x0 }, // 3549 + { PseudoVLOXSEG4EI16_V_MF4_MF2_MASK, VLOXSEG4EI16_V, 0x7, 0x0 }, // 3550 + { PseudoVLOXSEG4EI32_V_M1_M1, VLOXSEG4EI32_V, 0x0, 0x0 }, // 3551 + { PseudoVLOXSEG4EI32_V_M1_M1_MASK, VLOXSEG4EI32_V, 0x0, 0x0 }, // 3552 + { PseudoVLOXSEG4EI32_V_M2_M1, VLOXSEG4EI32_V, 0x0, 0x0 }, // 3553 + { PseudoVLOXSEG4EI32_V_M2_M1_MASK, VLOXSEG4EI32_V, 0x0, 0x0 }, // 3554 + { PseudoVLOXSEG4EI32_V_M4_M1, VLOXSEG4EI32_V, 0x0, 0x0 }, // 3555 + { PseudoVLOXSEG4EI32_V_M4_M1_MASK, VLOXSEG4EI32_V, 0x0, 0x0 }, // 3556 + { PseudoVLOXSEG4EI32_V_MF2_M1, VLOXSEG4EI32_V, 0x0, 0x0 }, // 3557 + { PseudoVLOXSEG4EI32_V_MF2_M1_MASK, VLOXSEG4EI32_V, 0x0, 0x0 }, // 3558 + { PseudoVLOXSEG4EI32_V_M1_M2, VLOXSEG4EI32_V, 0x1, 0x0 }, // 3559 + { PseudoVLOXSEG4EI32_V_M1_M2_MASK, VLOXSEG4EI32_V, 0x1, 0x0 }, // 3560 + { PseudoVLOXSEG4EI32_V_M2_M2, VLOXSEG4EI32_V, 0x1, 0x0 }, // 3561 + { PseudoVLOXSEG4EI32_V_M2_M2_MASK, VLOXSEG4EI32_V, 0x1, 0x0 }, // 3562 + { PseudoVLOXSEG4EI32_V_M4_M2, VLOXSEG4EI32_V, 0x1, 0x0 }, // 3563 + { PseudoVLOXSEG4EI32_V_M4_M2_MASK, VLOXSEG4EI32_V, 0x1, 0x0 }, // 3564 + { PseudoVLOXSEG4EI32_V_M8_M2, VLOXSEG4EI32_V, 0x1, 0x0 }, // 3565 + { PseudoVLOXSEG4EI32_V_M8_M2_MASK, VLOXSEG4EI32_V, 0x1, 0x0 }, // 3566 + { PseudoVLOXSEG4EI32_V_MF2_MF8, VLOXSEG4EI32_V, 0x5, 0x0 }, // 3567 + { PseudoVLOXSEG4EI32_V_MF2_MF8_MASK, VLOXSEG4EI32_V, 0x5, 0x0 }, // 3568 + { PseudoVLOXSEG4EI32_V_M1_MF4, VLOXSEG4EI32_V, 0x6, 0x0 }, // 3569 + { PseudoVLOXSEG4EI32_V_M1_MF4_MASK, VLOXSEG4EI32_V, 0x6, 0x0 }, // 3570 + { PseudoVLOXSEG4EI32_V_MF2_MF4, VLOXSEG4EI32_V, 0x6, 0x0 }, // 3571 + { PseudoVLOXSEG4EI32_V_MF2_MF4_MASK, VLOXSEG4EI32_V, 0x6, 0x0 }, // 3572 + { PseudoVLOXSEG4EI32_V_M1_MF2, VLOXSEG4EI32_V, 0x7, 0x0 }, // 3573 + { PseudoVLOXSEG4EI32_V_M1_MF2_MASK, VLOXSEG4EI32_V, 0x7, 0x0 }, // 3574 + { PseudoVLOXSEG4EI32_V_M2_MF2, VLOXSEG4EI32_V, 0x7, 0x0 }, // 3575 + { PseudoVLOXSEG4EI32_V_M2_MF2_MASK, VLOXSEG4EI32_V, 0x7, 0x0 }, // 3576 + { PseudoVLOXSEG4EI32_V_MF2_MF2, VLOXSEG4EI32_V, 0x7, 0x0 }, // 3577 + { PseudoVLOXSEG4EI32_V_MF2_MF2_MASK, VLOXSEG4EI32_V, 0x7, 0x0 }, // 3578 + { PseudoVLOXSEG4EI64_V_M1_M1, VLOXSEG4EI64_V, 0x0, 0x0 }, // 3579 + { PseudoVLOXSEG4EI64_V_M1_M1_MASK, VLOXSEG4EI64_V, 0x0, 0x0 }, // 3580 + { PseudoVLOXSEG4EI64_V_M2_M1, VLOXSEG4EI64_V, 0x0, 0x0 }, // 3581 + { PseudoVLOXSEG4EI64_V_M2_M1_MASK, VLOXSEG4EI64_V, 0x0, 0x0 }, // 3582 + { PseudoVLOXSEG4EI64_V_M4_M1, VLOXSEG4EI64_V, 0x0, 0x0 }, // 3583 + { PseudoVLOXSEG4EI64_V_M4_M1_MASK, VLOXSEG4EI64_V, 0x0, 0x0 }, // 3584 + { PseudoVLOXSEG4EI64_V_M8_M1, VLOXSEG4EI64_V, 0x0, 0x0 }, // 3585 + { PseudoVLOXSEG4EI64_V_M8_M1_MASK, VLOXSEG4EI64_V, 0x0, 0x0 }, // 3586 + { PseudoVLOXSEG4EI64_V_M2_M2, VLOXSEG4EI64_V, 0x1, 0x0 }, // 3587 + { PseudoVLOXSEG4EI64_V_M2_M2_MASK, VLOXSEG4EI64_V, 0x1, 0x0 }, // 3588 + { PseudoVLOXSEG4EI64_V_M4_M2, VLOXSEG4EI64_V, 0x1, 0x0 }, // 3589 + { PseudoVLOXSEG4EI64_V_M4_M2_MASK, VLOXSEG4EI64_V, 0x1, 0x0 }, // 3590 + { PseudoVLOXSEG4EI64_V_M8_M2, VLOXSEG4EI64_V, 0x1, 0x0 }, // 3591 + { PseudoVLOXSEG4EI64_V_M8_M2_MASK, VLOXSEG4EI64_V, 0x1, 0x0 }, // 3592 + { PseudoVLOXSEG4EI64_V_M1_MF8, VLOXSEG4EI64_V, 0x5, 0x0 }, // 3593 + { PseudoVLOXSEG4EI64_V_M1_MF8_MASK, VLOXSEG4EI64_V, 0x5, 0x0 }, // 3594 + { PseudoVLOXSEG4EI64_V_M1_MF4, VLOXSEG4EI64_V, 0x6, 0x0 }, // 3595 + { PseudoVLOXSEG4EI64_V_M1_MF4_MASK, VLOXSEG4EI64_V, 0x6, 0x0 }, // 3596 + { PseudoVLOXSEG4EI64_V_M2_MF4, VLOXSEG4EI64_V, 0x6, 0x0 }, // 3597 + { PseudoVLOXSEG4EI64_V_M2_MF4_MASK, VLOXSEG4EI64_V, 0x6, 0x0 }, // 3598 + { PseudoVLOXSEG4EI64_V_M1_MF2, VLOXSEG4EI64_V, 0x7, 0x0 }, // 3599 + { PseudoVLOXSEG4EI64_V_M1_MF2_MASK, VLOXSEG4EI64_V, 0x7, 0x0 }, // 3600 + { PseudoVLOXSEG4EI64_V_M2_MF2, VLOXSEG4EI64_V, 0x7, 0x0 }, // 3601 + { PseudoVLOXSEG4EI64_V_M2_MF2_MASK, VLOXSEG4EI64_V, 0x7, 0x0 }, // 3602 + { PseudoVLOXSEG4EI64_V_M4_MF2, VLOXSEG4EI64_V, 0x7, 0x0 }, // 3603 + { PseudoVLOXSEG4EI64_V_M4_MF2_MASK, VLOXSEG4EI64_V, 0x7, 0x0 }, // 3604 + { PseudoVLOXSEG4EI8_V_M1_M1, VLOXSEG4EI8_V, 0x0, 0x0 }, // 3605 + { PseudoVLOXSEG4EI8_V_M1_M1_MASK, VLOXSEG4EI8_V, 0x0, 0x0 }, // 3606 + { PseudoVLOXSEG4EI8_V_MF2_M1, VLOXSEG4EI8_V, 0x0, 0x0 }, // 3607 + { PseudoVLOXSEG4EI8_V_MF2_M1_MASK, VLOXSEG4EI8_V, 0x0, 0x0 }, // 3608 + { PseudoVLOXSEG4EI8_V_MF4_M1, VLOXSEG4EI8_V, 0x0, 0x0 }, // 3609 + { PseudoVLOXSEG4EI8_V_MF4_M1_MASK, VLOXSEG4EI8_V, 0x0, 0x0 }, // 3610 + { PseudoVLOXSEG4EI8_V_MF8_M1, VLOXSEG4EI8_V, 0x0, 0x0 }, // 3611 + { PseudoVLOXSEG4EI8_V_MF8_M1_MASK, VLOXSEG4EI8_V, 0x0, 0x0 }, // 3612 + { PseudoVLOXSEG4EI8_V_M1_M2, VLOXSEG4EI8_V, 0x1, 0x0 }, // 3613 + { PseudoVLOXSEG4EI8_V_M1_M2_MASK, VLOXSEG4EI8_V, 0x1, 0x0 }, // 3614 + { PseudoVLOXSEG4EI8_V_M2_M2, VLOXSEG4EI8_V, 0x1, 0x0 }, // 3615 + { PseudoVLOXSEG4EI8_V_M2_M2_MASK, VLOXSEG4EI8_V, 0x1, 0x0 }, // 3616 + { PseudoVLOXSEG4EI8_V_MF2_M2, VLOXSEG4EI8_V, 0x1, 0x0 }, // 3617 + { PseudoVLOXSEG4EI8_V_MF2_M2_MASK, VLOXSEG4EI8_V, 0x1, 0x0 }, // 3618 + { PseudoVLOXSEG4EI8_V_MF4_M2, VLOXSEG4EI8_V, 0x1, 0x0 }, // 3619 + { PseudoVLOXSEG4EI8_V_MF4_M2_MASK, VLOXSEG4EI8_V, 0x1, 0x0 }, // 3620 + { PseudoVLOXSEG4EI8_V_MF8_MF8, VLOXSEG4EI8_V, 0x5, 0x0 }, // 3621 + { PseudoVLOXSEG4EI8_V_MF8_MF8_MASK, VLOXSEG4EI8_V, 0x5, 0x0 }, // 3622 + { PseudoVLOXSEG4EI8_V_MF4_MF4, VLOXSEG4EI8_V, 0x6, 0x0 }, // 3623 + { PseudoVLOXSEG4EI8_V_MF4_MF4_MASK, VLOXSEG4EI8_V, 0x6, 0x0 }, // 3624 + { PseudoVLOXSEG4EI8_V_MF8_MF4, VLOXSEG4EI8_V, 0x6, 0x0 }, // 3625 + { PseudoVLOXSEG4EI8_V_MF8_MF4_MASK, VLOXSEG4EI8_V, 0x6, 0x0 }, // 3626 + { PseudoVLOXSEG4EI8_V_MF2_MF2, VLOXSEG4EI8_V, 0x7, 0x0 }, // 3627 + { PseudoVLOXSEG4EI8_V_MF2_MF2_MASK, VLOXSEG4EI8_V, 0x7, 0x0 }, // 3628 + { PseudoVLOXSEG4EI8_V_MF4_MF2, VLOXSEG4EI8_V, 0x7, 0x0 }, // 3629 + { PseudoVLOXSEG4EI8_V_MF4_MF2_MASK, VLOXSEG4EI8_V, 0x7, 0x0 }, // 3630 + { PseudoVLOXSEG4EI8_V_MF8_MF2, VLOXSEG4EI8_V, 0x7, 0x0 }, // 3631 + { PseudoVLOXSEG4EI8_V_MF8_MF2_MASK, VLOXSEG4EI8_V, 0x7, 0x0 }, // 3632 + { PseudoVLOXSEG5EI16_V_M1_M1, VLOXSEG5EI16_V, 0x0, 0x0 }, // 3633 + { PseudoVLOXSEG5EI16_V_M1_M1_MASK, VLOXSEG5EI16_V, 0x0, 0x0 }, // 3634 + { PseudoVLOXSEG5EI16_V_M2_M1, VLOXSEG5EI16_V, 0x0, 0x0 }, // 3635 + { PseudoVLOXSEG5EI16_V_M2_M1_MASK, VLOXSEG5EI16_V, 0x0, 0x0 }, // 3636 + { PseudoVLOXSEG5EI16_V_MF2_M1, VLOXSEG5EI16_V, 0x0, 0x0 }, // 3637 + { PseudoVLOXSEG5EI16_V_MF2_M1_MASK, VLOXSEG5EI16_V, 0x0, 0x0 }, // 3638 + { PseudoVLOXSEG5EI16_V_MF4_M1, VLOXSEG5EI16_V, 0x0, 0x0 }, // 3639 + { PseudoVLOXSEG5EI16_V_MF4_M1_MASK, VLOXSEG5EI16_V, 0x0, 0x0 }, // 3640 + { PseudoVLOXSEG5EI16_V_MF4_MF8, VLOXSEG5EI16_V, 0x5, 0x0 }, // 3641 + { PseudoVLOXSEG5EI16_V_MF4_MF8_MASK, VLOXSEG5EI16_V, 0x5, 0x0 }, // 3642 + { PseudoVLOXSEG5EI16_V_MF2_MF4, VLOXSEG5EI16_V, 0x6, 0x0 }, // 3643 + { PseudoVLOXSEG5EI16_V_MF2_MF4_MASK, VLOXSEG5EI16_V, 0x6, 0x0 }, // 3644 + { PseudoVLOXSEG5EI16_V_MF4_MF4, VLOXSEG5EI16_V, 0x6, 0x0 }, // 3645 + { PseudoVLOXSEG5EI16_V_MF4_MF4_MASK, VLOXSEG5EI16_V, 0x6, 0x0 }, // 3646 + { PseudoVLOXSEG5EI16_V_M1_MF2, VLOXSEG5EI16_V, 0x7, 0x0 }, // 3647 + { PseudoVLOXSEG5EI16_V_M1_MF2_MASK, VLOXSEG5EI16_V, 0x7, 0x0 }, // 3648 + { PseudoVLOXSEG5EI16_V_MF2_MF2, VLOXSEG5EI16_V, 0x7, 0x0 }, // 3649 + { PseudoVLOXSEG5EI16_V_MF2_MF2_MASK, VLOXSEG5EI16_V, 0x7, 0x0 }, // 3650 + { PseudoVLOXSEG5EI16_V_MF4_MF2, VLOXSEG5EI16_V, 0x7, 0x0 }, // 3651 + { PseudoVLOXSEG5EI16_V_MF4_MF2_MASK, VLOXSEG5EI16_V, 0x7, 0x0 }, // 3652 + { PseudoVLOXSEG5EI32_V_M1_M1, VLOXSEG5EI32_V, 0x0, 0x0 }, // 3653 + { PseudoVLOXSEG5EI32_V_M1_M1_MASK, VLOXSEG5EI32_V, 0x0, 0x0 }, // 3654 + { PseudoVLOXSEG5EI32_V_M2_M1, VLOXSEG5EI32_V, 0x0, 0x0 }, // 3655 + { PseudoVLOXSEG5EI32_V_M2_M1_MASK, VLOXSEG5EI32_V, 0x0, 0x0 }, // 3656 + { PseudoVLOXSEG5EI32_V_M4_M1, VLOXSEG5EI32_V, 0x0, 0x0 }, // 3657 + { PseudoVLOXSEG5EI32_V_M4_M1_MASK, VLOXSEG5EI32_V, 0x0, 0x0 }, // 3658 + { PseudoVLOXSEG5EI32_V_MF2_M1, VLOXSEG5EI32_V, 0x0, 0x0 }, // 3659 + { PseudoVLOXSEG5EI32_V_MF2_M1_MASK, VLOXSEG5EI32_V, 0x0, 0x0 }, // 3660 + { PseudoVLOXSEG5EI32_V_MF2_MF8, VLOXSEG5EI32_V, 0x5, 0x0 }, // 3661 + { PseudoVLOXSEG5EI32_V_MF2_MF8_MASK, VLOXSEG5EI32_V, 0x5, 0x0 }, // 3662 + { PseudoVLOXSEG5EI32_V_M1_MF4, VLOXSEG5EI32_V, 0x6, 0x0 }, // 3663 + { PseudoVLOXSEG5EI32_V_M1_MF4_MASK, VLOXSEG5EI32_V, 0x6, 0x0 }, // 3664 + { PseudoVLOXSEG5EI32_V_MF2_MF4, VLOXSEG5EI32_V, 0x6, 0x0 }, // 3665 + { PseudoVLOXSEG5EI32_V_MF2_MF4_MASK, VLOXSEG5EI32_V, 0x6, 0x0 }, // 3666 + { PseudoVLOXSEG5EI32_V_M1_MF2, VLOXSEG5EI32_V, 0x7, 0x0 }, // 3667 + { PseudoVLOXSEG5EI32_V_M1_MF2_MASK, VLOXSEG5EI32_V, 0x7, 0x0 }, // 3668 + { PseudoVLOXSEG5EI32_V_M2_MF2, VLOXSEG5EI32_V, 0x7, 0x0 }, // 3669 + { PseudoVLOXSEG5EI32_V_M2_MF2_MASK, VLOXSEG5EI32_V, 0x7, 0x0 }, // 3670 + { PseudoVLOXSEG5EI32_V_MF2_MF2, VLOXSEG5EI32_V, 0x7, 0x0 }, // 3671 + { PseudoVLOXSEG5EI32_V_MF2_MF2_MASK, VLOXSEG5EI32_V, 0x7, 0x0 }, // 3672 + { PseudoVLOXSEG5EI64_V_M1_M1, VLOXSEG5EI64_V, 0x0, 0x0 }, // 3673 + { PseudoVLOXSEG5EI64_V_M1_M1_MASK, VLOXSEG5EI64_V, 0x0, 0x0 }, // 3674 + { PseudoVLOXSEG5EI64_V_M2_M1, VLOXSEG5EI64_V, 0x0, 0x0 }, // 3675 + { PseudoVLOXSEG5EI64_V_M2_M1_MASK, VLOXSEG5EI64_V, 0x0, 0x0 }, // 3676 + { PseudoVLOXSEG5EI64_V_M4_M1, VLOXSEG5EI64_V, 0x0, 0x0 }, // 3677 + { PseudoVLOXSEG5EI64_V_M4_M1_MASK, VLOXSEG5EI64_V, 0x0, 0x0 }, // 3678 + { PseudoVLOXSEG5EI64_V_M8_M1, VLOXSEG5EI64_V, 0x0, 0x0 }, // 3679 + { PseudoVLOXSEG5EI64_V_M8_M1_MASK, VLOXSEG5EI64_V, 0x0, 0x0 }, // 3680 + { PseudoVLOXSEG5EI64_V_M1_MF8, VLOXSEG5EI64_V, 0x5, 0x0 }, // 3681 + { PseudoVLOXSEG5EI64_V_M1_MF8_MASK, VLOXSEG5EI64_V, 0x5, 0x0 }, // 3682 + { PseudoVLOXSEG5EI64_V_M1_MF4, VLOXSEG5EI64_V, 0x6, 0x0 }, // 3683 + { PseudoVLOXSEG5EI64_V_M1_MF4_MASK, VLOXSEG5EI64_V, 0x6, 0x0 }, // 3684 + { PseudoVLOXSEG5EI64_V_M2_MF4, VLOXSEG5EI64_V, 0x6, 0x0 }, // 3685 + { PseudoVLOXSEG5EI64_V_M2_MF4_MASK, VLOXSEG5EI64_V, 0x6, 0x0 }, // 3686 + { PseudoVLOXSEG5EI64_V_M1_MF2, VLOXSEG5EI64_V, 0x7, 0x0 }, // 3687 + { PseudoVLOXSEG5EI64_V_M1_MF2_MASK, VLOXSEG5EI64_V, 0x7, 0x0 }, // 3688 + { PseudoVLOXSEG5EI64_V_M2_MF2, VLOXSEG5EI64_V, 0x7, 0x0 }, // 3689 + { PseudoVLOXSEG5EI64_V_M2_MF2_MASK, VLOXSEG5EI64_V, 0x7, 0x0 }, // 3690 + { PseudoVLOXSEG5EI64_V_M4_MF2, VLOXSEG5EI64_V, 0x7, 0x0 }, // 3691 + { PseudoVLOXSEG5EI64_V_M4_MF2_MASK, VLOXSEG5EI64_V, 0x7, 0x0 }, // 3692 + { PseudoVLOXSEG5EI8_V_M1_M1, VLOXSEG5EI8_V, 0x0, 0x0 }, // 3693 + { PseudoVLOXSEG5EI8_V_M1_M1_MASK, VLOXSEG5EI8_V, 0x0, 0x0 }, // 3694 + { PseudoVLOXSEG5EI8_V_MF2_M1, VLOXSEG5EI8_V, 0x0, 0x0 }, // 3695 + { PseudoVLOXSEG5EI8_V_MF2_M1_MASK, VLOXSEG5EI8_V, 0x0, 0x0 }, // 3696 + { PseudoVLOXSEG5EI8_V_MF4_M1, VLOXSEG5EI8_V, 0x0, 0x0 }, // 3697 + { PseudoVLOXSEG5EI8_V_MF4_M1_MASK, VLOXSEG5EI8_V, 0x0, 0x0 }, // 3698 + { PseudoVLOXSEG5EI8_V_MF8_M1, VLOXSEG5EI8_V, 0x0, 0x0 }, // 3699 + { PseudoVLOXSEG5EI8_V_MF8_M1_MASK, VLOXSEG5EI8_V, 0x0, 0x0 }, // 3700 + { PseudoVLOXSEG5EI8_V_MF8_MF8, VLOXSEG5EI8_V, 0x5, 0x0 }, // 3701 + { PseudoVLOXSEG5EI8_V_MF8_MF8_MASK, VLOXSEG5EI8_V, 0x5, 0x0 }, // 3702 + { PseudoVLOXSEG5EI8_V_MF4_MF4, VLOXSEG5EI8_V, 0x6, 0x0 }, // 3703 + { PseudoVLOXSEG5EI8_V_MF4_MF4_MASK, VLOXSEG5EI8_V, 0x6, 0x0 }, // 3704 + { PseudoVLOXSEG5EI8_V_MF8_MF4, VLOXSEG5EI8_V, 0x6, 0x0 }, // 3705 + { PseudoVLOXSEG5EI8_V_MF8_MF4_MASK, VLOXSEG5EI8_V, 0x6, 0x0 }, // 3706 + { PseudoVLOXSEG5EI8_V_MF2_MF2, VLOXSEG5EI8_V, 0x7, 0x0 }, // 3707 + { PseudoVLOXSEG5EI8_V_MF2_MF2_MASK, VLOXSEG5EI8_V, 0x7, 0x0 }, // 3708 + { PseudoVLOXSEG5EI8_V_MF4_MF2, VLOXSEG5EI8_V, 0x7, 0x0 }, // 3709 + { PseudoVLOXSEG5EI8_V_MF4_MF2_MASK, VLOXSEG5EI8_V, 0x7, 0x0 }, // 3710 + { PseudoVLOXSEG5EI8_V_MF8_MF2, VLOXSEG5EI8_V, 0x7, 0x0 }, // 3711 + { PseudoVLOXSEG5EI8_V_MF8_MF2_MASK, VLOXSEG5EI8_V, 0x7, 0x0 }, // 3712 + { PseudoVLOXSEG6EI16_V_M1_M1, VLOXSEG6EI16_V, 0x0, 0x0 }, // 3713 + { PseudoVLOXSEG6EI16_V_M1_M1_MASK, VLOXSEG6EI16_V, 0x0, 0x0 }, // 3714 + { PseudoVLOXSEG6EI16_V_M2_M1, VLOXSEG6EI16_V, 0x0, 0x0 }, // 3715 + { PseudoVLOXSEG6EI16_V_M2_M1_MASK, VLOXSEG6EI16_V, 0x0, 0x0 }, // 3716 + { PseudoVLOXSEG6EI16_V_MF2_M1, VLOXSEG6EI16_V, 0x0, 0x0 }, // 3717 + { PseudoVLOXSEG6EI16_V_MF2_M1_MASK, VLOXSEG6EI16_V, 0x0, 0x0 }, // 3718 + { PseudoVLOXSEG6EI16_V_MF4_M1, VLOXSEG6EI16_V, 0x0, 0x0 }, // 3719 + { PseudoVLOXSEG6EI16_V_MF4_M1_MASK, VLOXSEG6EI16_V, 0x0, 0x0 }, // 3720 + { PseudoVLOXSEG6EI16_V_MF4_MF8, VLOXSEG6EI16_V, 0x5, 0x0 }, // 3721 + { PseudoVLOXSEG6EI16_V_MF4_MF8_MASK, VLOXSEG6EI16_V, 0x5, 0x0 }, // 3722 + { PseudoVLOXSEG6EI16_V_MF2_MF4, VLOXSEG6EI16_V, 0x6, 0x0 }, // 3723 + { PseudoVLOXSEG6EI16_V_MF2_MF4_MASK, VLOXSEG6EI16_V, 0x6, 0x0 }, // 3724 + { PseudoVLOXSEG6EI16_V_MF4_MF4, VLOXSEG6EI16_V, 0x6, 0x0 }, // 3725 + { PseudoVLOXSEG6EI16_V_MF4_MF4_MASK, VLOXSEG6EI16_V, 0x6, 0x0 }, // 3726 + { PseudoVLOXSEG6EI16_V_M1_MF2, VLOXSEG6EI16_V, 0x7, 0x0 }, // 3727 + { PseudoVLOXSEG6EI16_V_M1_MF2_MASK, VLOXSEG6EI16_V, 0x7, 0x0 }, // 3728 + { PseudoVLOXSEG6EI16_V_MF2_MF2, VLOXSEG6EI16_V, 0x7, 0x0 }, // 3729 + { PseudoVLOXSEG6EI16_V_MF2_MF2_MASK, VLOXSEG6EI16_V, 0x7, 0x0 }, // 3730 + { PseudoVLOXSEG6EI16_V_MF4_MF2, VLOXSEG6EI16_V, 0x7, 0x0 }, // 3731 + { PseudoVLOXSEG6EI16_V_MF4_MF2_MASK, VLOXSEG6EI16_V, 0x7, 0x0 }, // 3732 + { PseudoVLOXSEG6EI32_V_M1_M1, VLOXSEG6EI32_V, 0x0, 0x0 }, // 3733 + { PseudoVLOXSEG6EI32_V_M1_M1_MASK, VLOXSEG6EI32_V, 0x0, 0x0 }, // 3734 + { PseudoVLOXSEG6EI32_V_M2_M1, VLOXSEG6EI32_V, 0x0, 0x0 }, // 3735 + { PseudoVLOXSEG6EI32_V_M2_M1_MASK, VLOXSEG6EI32_V, 0x0, 0x0 }, // 3736 + { PseudoVLOXSEG6EI32_V_M4_M1, VLOXSEG6EI32_V, 0x0, 0x0 }, // 3737 + { PseudoVLOXSEG6EI32_V_M4_M1_MASK, VLOXSEG6EI32_V, 0x0, 0x0 }, // 3738 + { PseudoVLOXSEG6EI32_V_MF2_M1, VLOXSEG6EI32_V, 0x0, 0x0 }, // 3739 + { PseudoVLOXSEG6EI32_V_MF2_M1_MASK, VLOXSEG6EI32_V, 0x0, 0x0 }, // 3740 + { PseudoVLOXSEG6EI32_V_MF2_MF8, VLOXSEG6EI32_V, 0x5, 0x0 }, // 3741 + { PseudoVLOXSEG6EI32_V_MF2_MF8_MASK, VLOXSEG6EI32_V, 0x5, 0x0 }, // 3742 + { PseudoVLOXSEG6EI32_V_M1_MF4, VLOXSEG6EI32_V, 0x6, 0x0 }, // 3743 + { PseudoVLOXSEG6EI32_V_M1_MF4_MASK, VLOXSEG6EI32_V, 0x6, 0x0 }, // 3744 + { PseudoVLOXSEG6EI32_V_MF2_MF4, VLOXSEG6EI32_V, 0x6, 0x0 }, // 3745 + { PseudoVLOXSEG6EI32_V_MF2_MF4_MASK, VLOXSEG6EI32_V, 0x6, 0x0 }, // 3746 + { PseudoVLOXSEG6EI32_V_M1_MF2, VLOXSEG6EI32_V, 0x7, 0x0 }, // 3747 + { PseudoVLOXSEG6EI32_V_M1_MF2_MASK, VLOXSEG6EI32_V, 0x7, 0x0 }, // 3748 + { PseudoVLOXSEG6EI32_V_M2_MF2, VLOXSEG6EI32_V, 0x7, 0x0 }, // 3749 + { PseudoVLOXSEG6EI32_V_M2_MF2_MASK, VLOXSEG6EI32_V, 0x7, 0x0 }, // 3750 + { PseudoVLOXSEG6EI32_V_MF2_MF2, VLOXSEG6EI32_V, 0x7, 0x0 }, // 3751 + { PseudoVLOXSEG6EI32_V_MF2_MF2_MASK, VLOXSEG6EI32_V, 0x7, 0x0 }, // 3752 + { PseudoVLOXSEG6EI64_V_M1_M1, VLOXSEG6EI64_V, 0x0, 0x0 }, // 3753 + { PseudoVLOXSEG6EI64_V_M1_M1_MASK, VLOXSEG6EI64_V, 0x0, 0x0 }, // 3754 + { PseudoVLOXSEG6EI64_V_M2_M1, VLOXSEG6EI64_V, 0x0, 0x0 }, // 3755 + { PseudoVLOXSEG6EI64_V_M2_M1_MASK, VLOXSEG6EI64_V, 0x0, 0x0 }, // 3756 + { PseudoVLOXSEG6EI64_V_M4_M1, VLOXSEG6EI64_V, 0x0, 0x0 }, // 3757 + { PseudoVLOXSEG6EI64_V_M4_M1_MASK, VLOXSEG6EI64_V, 0x0, 0x0 }, // 3758 + { PseudoVLOXSEG6EI64_V_M8_M1, VLOXSEG6EI64_V, 0x0, 0x0 }, // 3759 + { PseudoVLOXSEG6EI64_V_M8_M1_MASK, VLOXSEG6EI64_V, 0x0, 0x0 }, // 3760 + { PseudoVLOXSEG6EI64_V_M1_MF8, VLOXSEG6EI64_V, 0x5, 0x0 }, // 3761 + { PseudoVLOXSEG6EI64_V_M1_MF8_MASK, VLOXSEG6EI64_V, 0x5, 0x0 }, // 3762 + { PseudoVLOXSEG6EI64_V_M1_MF4, VLOXSEG6EI64_V, 0x6, 0x0 }, // 3763 + { PseudoVLOXSEG6EI64_V_M1_MF4_MASK, VLOXSEG6EI64_V, 0x6, 0x0 }, // 3764 + { PseudoVLOXSEG6EI64_V_M2_MF4, VLOXSEG6EI64_V, 0x6, 0x0 }, // 3765 + { PseudoVLOXSEG6EI64_V_M2_MF4_MASK, VLOXSEG6EI64_V, 0x6, 0x0 }, // 3766 + { PseudoVLOXSEG6EI64_V_M1_MF2, VLOXSEG6EI64_V, 0x7, 0x0 }, // 3767 + { PseudoVLOXSEG6EI64_V_M1_MF2_MASK, VLOXSEG6EI64_V, 0x7, 0x0 }, // 3768 + { PseudoVLOXSEG6EI64_V_M2_MF2, VLOXSEG6EI64_V, 0x7, 0x0 }, // 3769 + { PseudoVLOXSEG6EI64_V_M2_MF2_MASK, VLOXSEG6EI64_V, 0x7, 0x0 }, // 3770 + { PseudoVLOXSEG6EI64_V_M4_MF2, VLOXSEG6EI64_V, 0x7, 0x0 }, // 3771 + { PseudoVLOXSEG6EI64_V_M4_MF2_MASK, VLOXSEG6EI64_V, 0x7, 0x0 }, // 3772 + { PseudoVLOXSEG6EI8_V_M1_M1, VLOXSEG6EI8_V, 0x0, 0x0 }, // 3773 + { PseudoVLOXSEG6EI8_V_M1_M1_MASK, VLOXSEG6EI8_V, 0x0, 0x0 }, // 3774 + { PseudoVLOXSEG6EI8_V_MF2_M1, VLOXSEG6EI8_V, 0x0, 0x0 }, // 3775 + { PseudoVLOXSEG6EI8_V_MF2_M1_MASK, VLOXSEG6EI8_V, 0x0, 0x0 }, // 3776 + { PseudoVLOXSEG6EI8_V_MF4_M1, VLOXSEG6EI8_V, 0x0, 0x0 }, // 3777 + { PseudoVLOXSEG6EI8_V_MF4_M1_MASK, VLOXSEG6EI8_V, 0x0, 0x0 }, // 3778 + { PseudoVLOXSEG6EI8_V_MF8_M1, VLOXSEG6EI8_V, 0x0, 0x0 }, // 3779 + { PseudoVLOXSEG6EI8_V_MF8_M1_MASK, VLOXSEG6EI8_V, 0x0, 0x0 }, // 3780 + { PseudoVLOXSEG6EI8_V_MF8_MF8, VLOXSEG6EI8_V, 0x5, 0x0 }, // 3781 + { PseudoVLOXSEG6EI8_V_MF8_MF8_MASK, VLOXSEG6EI8_V, 0x5, 0x0 }, // 3782 + { PseudoVLOXSEG6EI8_V_MF4_MF4, VLOXSEG6EI8_V, 0x6, 0x0 }, // 3783 + { PseudoVLOXSEG6EI8_V_MF4_MF4_MASK, VLOXSEG6EI8_V, 0x6, 0x0 }, // 3784 + { PseudoVLOXSEG6EI8_V_MF8_MF4, VLOXSEG6EI8_V, 0x6, 0x0 }, // 3785 + { PseudoVLOXSEG6EI8_V_MF8_MF4_MASK, VLOXSEG6EI8_V, 0x6, 0x0 }, // 3786 + { PseudoVLOXSEG6EI8_V_MF2_MF2, VLOXSEG6EI8_V, 0x7, 0x0 }, // 3787 + { PseudoVLOXSEG6EI8_V_MF2_MF2_MASK, VLOXSEG6EI8_V, 0x7, 0x0 }, // 3788 + { PseudoVLOXSEG6EI8_V_MF4_MF2, VLOXSEG6EI8_V, 0x7, 0x0 }, // 3789 + { PseudoVLOXSEG6EI8_V_MF4_MF2_MASK, VLOXSEG6EI8_V, 0x7, 0x0 }, // 3790 + { PseudoVLOXSEG6EI8_V_MF8_MF2, VLOXSEG6EI8_V, 0x7, 0x0 }, // 3791 + { PseudoVLOXSEG6EI8_V_MF8_MF2_MASK, VLOXSEG6EI8_V, 0x7, 0x0 }, // 3792 + { PseudoVLOXSEG7EI16_V_M1_M1, VLOXSEG7EI16_V, 0x0, 0x0 }, // 3793 + { PseudoVLOXSEG7EI16_V_M1_M1_MASK, VLOXSEG7EI16_V, 0x0, 0x0 }, // 3794 + { PseudoVLOXSEG7EI16_V_M2_M1, VLOXSEG7EI16_V, 0x0, 0x0 }, // 3795 + { PseudoVLOXSEG7EI16_V_M2_M1_MASK, VLOXSEG7EI16_V, 0x0, 0x0 }, // 3796 + { PseudoVLOXSEG7EI16_V_MF2_M1, VLOXSEG7EI16_V, 0x0, 0x0 }, // 3797 + { PseudoVLOXSEG7EI16_V_MF2_M1_MASK, VLOXSEG7EI16_V, 0x0, 0x0 }, // 3798 + { PseudoVLOXSEG7EI16_V_MF4_M1, VLOXSEG7EI16_V, 0x0, 0x0 }, // 3799 + { PseudoVLOXSEG7EI16_V_MF4_M1_MASK, VLOXSEG7EI16_V, 0x0, 0x0 }, // 3800 + { PseudoVLOXSEG7EI16_V_MF4_MF8, VLOXSEG7EI16_V, 0x5, 0x0 }, // 3801 + { PseudoVLOXSEG7EI16_V_MF4_MF8_MASK, VLOXSEG7EI16_V, 0x5, 0x0 }, // 3802 + { PseudoVLOXSEG7EI16_V_MF2_MF4, VLOXSEG7EI16_V, 0x6, 0x0 }, // 3803 + { PseudoVLOXSEG7EI16_V_MF2_MF4_MASK, VLOXSEG7EI16_V, 0x6, 0x0 }, // 3804 + { PseudoVLOXSEG7EI16_V_MF4_MF4, VLOXSEG7EI16_V, 0x6, 0x0 }, // 3805 + { PseudoVLOXSEG7EI16_V_MF4_MF4_MASK, VLOXSEG7EI16_V, 0x6, 0x0 }, // 3806 + { PseudoVLOXSEG7EI16_V_M1_MF2, VLOXSEG7EI16_V, 0x7, 0x0 }, // 3807 + { PseudoVLOXSEG7EI16_V_M1_MF2_MASK, VLOXSEG7EI16_V, 0x7, 0x0 }, // 3808 + { PseudoVLOXSEG7EI16_V_MF2_MF2, VLOXSEG7EI16_V, 0x7, 0x0 }, // 3809 + { PseudoVLOXSEG7EI16_V_MF2_MF2_MASK, VLOXSEG7EI16_V, 0x7, 0x0 }, // 3810 + { PseudoVLOXSEG7EI16_V_MF4_MF2, VLOXSEG7EI16_V, 0x7, 0x0 }, // 3811 + { PseudoVLOXSEG7EI16_V_MF4_MF2_MASK, VLOXSEG7EI16_V, 0x7, 0x0 }, // 3812 + { PseudoVLOXSEG7EI32_V_M1_M1, VLOXSEG7EI32_V, 0x0, 0x0 }, // 3813 + { PseudoVLOXSEG7EI32_V_M1_M1_MASK, VLOXSEG7EI32_V, 0x0, 0x0 }, // 3814 + { PseudoVLOXSEG7EI32_V_M2_M1, VLOXSEG7EI32_V, 0x0, 0x0 }, // 3815 + { PseudoVLOXSEG7EI32_V_M2_M1_MASK, VLOXSEG7EI32_V, 0x0, 0x0 }, // 3816 + { PseudoVLOXSEG7EI32_V_M4_M1, VLOXSEG7EI32_V, 0x0, 0x0 }, // 3817 + { PseudoVLOXSEG7EI32_V_M4_M1_MASK, VLOXSEG7EI32_V, 0x0, 0x0 }, // 3818 + { PseudoVLOXSEG7EI32_V_MF2_M1, VLOXSEG7EI32_V, 0x0, 0x0 }, // 3819 + { PseudoVLOXSEG7EI32_V_MF2_M1_MASK, VLOXSEG7EI32_V, 0x0, 0x0 }, // 3820 + { PseudoVLOXSEG7EI32_V_MF2_MF8, VLOXSEG7EI32_V, 0x5, 0x0 }, // 3821 + { PseudoVLOXSEG7EI32_V_MF2_MF8_MASK, VLOXSEG7EI32_V, 0x5, 0x0 }, // 3822 + { PseudoVLOXSEG7EI32_V_M1_MF4, VLOXSEG7EI32_V, 0x6, 0x0 }, // 3823 + { PseudoVLOXSEG7EI32_V_M1_MF4_MASK, VLOXSEG7EI32_V, 0x6, 0x0 }, // 3824 + { PseudoVLOXSEG7EI32_V_MF2_MF4, VLOXSEG7EI32_V, 0x6, 0x0 }, // 3825 + { PseudoVLOXSEG7EI32_V_MF2_MF4_MASK, VLOXSEG7EI32_V, 0x6, 0x0 }, // 3826 + { PseudoVLOXSEG7EI32_V_M1_MF2, VLOXSEG7EI32_V, 0x7, 0x0 }, // 3827 + { PseudoVLOXSEG7EI32_V_M1_MF2_MASK, VLOXSEG7EI32_V, 0x7, 0x0 }, // 3828 + { PseudoVLOXSEG7EI32_V_M2_MF2, VLOXSEG7EI32_V, 0x7, 0x0 }, // 3829 + { PseudoVLOXSEG7EI32_V_M2_MF2_MASK, VLOXSEG7EI32_V, 0x7, 0x0 }, // 3830 + { PseudoVLOXSEG7EI32_V_MF2_MF2, VLOXSEG7EI32_V, 0x7, 0x0 }, // 3831 + { PseudoVLOXSEG7EI32_V_MF2_MF2_MASK, VLOXSEG7EI32_V, 0x7, 0x0 }, // 3832 + { PseudoVLOXSEG7EI64_V_M1_M1, VLOXSEG7EI64_V, 0x0, 0x0 }, // 3833 + { PseudoVLOXSEG7EI64_V_M1_M1_MASK, VLOXSEG7EI64_V, 0x0, 0x0 }, // 3834 + { PseudoVLOXSEG7EI64_V_M2_M1, VLOXSEG7EI64_V, 0x0, 0x0 }, // 3835 + { PseudoVLOXSEG7EI64_V_M2_M1_MASK, VLOXSEG7EI64_V, 0x0, 0x0 }, // 3836 + { PseudoVLOXSEG7EI64_V_M4_M1, VLOXSEG7EI64_V, 0x0, 0x0 }, // 3837 + { PseudoVLOXSEG7EI64_V_M4_M1_MASK, VLOXSEG7EI64_V, 0x0, 0x0 }, // 3838 + { PseudoVLOXSEG7EI64_V_M8_M1, VLOXSEG7EI64_V, 0x0, 0x0 }, // 3839 + { PseudoVLOXSEG7EI64_V_M8_M1_MASK, VLOXSEG7EI64_V, 0x0, 0x0 }, // 3840 + { PseudoVLOXSEG7EI64_V_M1_MF8, VLOXSEG7EI64_V, 0x5, 0x0 }, // 3841 + { PseudoVLOXSEG7EI64_V_M1_MF8_MASK, VLOXSEG7EI64_V, 0x5, 0x0 }, // 3842 + { PseudoVLOXSEG7EI64_V_M1_MF4, VLOXSEG7EI64_V, 0x6, 0x0 }, // 3843 + { PseudoVLOXSEG7EI64_V_M1_MF4_MASK, VLOXSEG7EI64_V, 0x6, 0x0 }, // 3844 + { PseudoVLOXSEG7EI64_V_M2_MF4, VLOXSEG7EI64_V, 0x6, 0x0 }, // 3845 + { PseudoVLOXSEG7EI64_V_M2_MF4_MASK, VLOXSEG7EI64_V, 0x6, 0x0 }, // 3846 + { PseudoVLOXSEG7EI64_V_M1_MF2, VLOXSEG7EI64_V, 0x7, 0x0 }, // 3847 + { PseudoVLOXSEG7EI64_V_M1_MF2_MASK, VLOXSEG7EI64_V, 0x7, 0x0 }, // 3848 + { PseudoVLOXSEG7EI64_V_M2_MF2, VLOXSEG7EI64_V, 0x7, 0x0 }, // 3849 + { PseudoVLOXSEG7EI64_V_M2_MF2_MASK, VLOXSEG7EI64_V, 0x7, 0x0 }, // 3850 + { PseudoVLOXSEG7EI64_V_M4_MF2, VLOXSEG7EI64_V, 0x7, 0x0 }, // 3851 + { PseudoVLOXSEG7EI64_V_M4_MF2_MASK, VLOXSEG7EI64_V, 0x7, 0x0 }, // 3852 + { PseudoVLOXSEG7EI8_V_M1_M1, VLOXSEG7EI8_V, 0x0, 0x0 }, // 3853 + { PseudoVLOXSEG7EI8_V_M1_M1_MASK, VLOXSEG7EI8_V, 0x0, 0x0 }, // 3854 + { PseudoVLOXSEG7EI8_V_MF2_M1, VLOXSEG7EI8_V, 0x0, 0x0 }, // 3855 + { PseudoVLOXSEG7EI8_V_MF2_M1_MASK, VLOXSEG7EI8_V, 0x0, 0x0 }, // 3856 + { PseudoVLOXSEG7EI8_V_MF4_M1, VLOXSEG7EI8_V, 0x0, 0x0 }, // 3857 + { PseudoVLOXSEG7EI8_V_MF4_M1_MASK, VLOXSEG7EI8_V, 0x0, 0x0 }, // 3858 + { PseudoVLOXSEG7EI8_V_MF8_M1, VLOXSEG7EI8_V, 0x0, 0x0 }, // 3859 + { PseudoVLOXSEG7EI8_V_MF8_M1_MASK, VLOXSEG7EI8_V, 0x0, 0x0 }, // 3860 + { PseudoVLOXSEG7EI8_V_MF8_MF8, VLOXSEG7EI8_V, 0x5, 0x0 }, // 3861 + { PseudoVLOXSEG7EI8_V_MF8_MF8_MASK, VLOXSEG7EI8_V, 0x5, 0x0 }, // 3862 + { PseudoVLOXSEG7EI8_V_MF4_MF4, VLOXSEG7EI8_V, 0x6, 0x0 }, // 3863 + { PseudoVLOXSEG7EI8_V_MF4_MF4_MASK, VLOXSEG7EI8_V, 0x6, 0x0 }, // 3864 + { PseudoVLOXSEG7EI8_V_MF8_MF4, VLOXSEG7EI8_V, 0x6, 0x0 }, // 3865 + { PseudoVLOXSEG7EI8_V_MF8_MF4_MASK, VLOXSEG7EI8_V, 0x6, 0x0 }, // 3866 + { PseudoVLOXSEG7EI8_V_MF2_MF2, VLOXSEG7EI8_V, 0x7, 0x0 }, // 3867 + { PseudoVLOXSEG7EI8_V_MF2_MF2_MASK, VLOXSEG7EI8_V, 0x7, 0x0 }, // 3868 + { PseudoVLOXSEG7EI8_V_MF4_MF2, VLOXSEG7EI8_V, 0x7, 0x0 }, // 3869 + { PseudoVLOXSEG7EI8_V_MF4_MF2_MASK, VLOXSEG7EI8_V, 0x7, 0x0 }, // 3870 + { PseudoVLOXSEG7EI8_V_MF8_MF2, VLOXSEG7EI8_V, 0x7, 0x0 }, // 3871 + { PseudoVLOXSEG7EI8_V_MF8_MF2_MASK, VLOXSEG7EI8_V, 0x7, 0x0 }, // 3872 + { PseudoVLOXSEG8EI16_V_M1_M1, VLOXSEG8EI16_V, 0x0, 0x0 }, // 3873 + { PseudoVLOXSEG8EI16_V_M1_M1_MASK, VLOXSEG8EI16_V, 0x0, 0x0 }, // 3874 + { PseudoVLOXSEG8EI16_V_M2_M1, VLOXSEG8EI16_V, 0x0, 0x0 }, // 3875 + { PseudoVLOXSEG8EI16_V_M2_M1_MASK, VLOXSEG8EI16_V, 0x0, 0x0 }, // 3876 + { PseudoVLOXSEG8EI16_V_MF2_M1, VLOXSEG8EI16_V, 0x0, 0x0 }, // 3877 + { PseudoVLOXSEG8EI16_V_MF2_M1_MASK, VLOXSEG8EI16_V, 0x0, 0x0 }, // 3878 + { PseudoVLOXSEG8EI16_V_MF4_M1, VLOXSEG8EI16_V, 0x0, 0x0 }, // 3879 + { PseudoVLOXSEG8EI16_V_MF4_M1_MASK, VLOXSEG8EI16_V, 0x0, 0x0 }, // 3880 + { PseudoVLOXSEG8EI16_V_MF4_MF8, VLOXSEG8EI16_V, 0x5, 0x0 }, // 3881 + { PseudoVLOXSEG8EI16_V_MF4_MF8_MASK, VLOXSEG8EI16_V, 0x5, 0x0 }, // 3882 + { PseudoVLOXSEG8EI16_V_MF2_MF4, VLOXSEG8EI16_V, 0x6, 0x0 }, // 3883 + { PseudoVLOXSEG8EI16_V_MF2_MF4_MASK, VLOXSEG8EI16_V, 0x6, 0x0 }, // 3884 + { PseudoVLOXSEG8EI16_V_MF4_MF4, VLOXSEG8EI16_V, 0x6, 0x0 }, // 3885 + { PseudoVLOXSEG8EI16_V_MF4_MF4_MASK, VLOXSEG8EI16_V, 0x6, 0x0 }, // 3886 + { PseudoVLOXSEG8EI16_V_M1_MF2, VLOXSEG8EI16_V, 0x7, 0x0 }, // 3887 + { PseudoVLOXSEG8EI16_V_M1_MF2_MASK, VLOXSEG8EI16_V, 0x7, 0x0 }, // 3888 + { PseudoVLOXSEG8EI16_V_MF2_MF2, VLOXSEG8EI16_V, 0x7, 0x0 }, // 3889 + { PseudoVLOXSEG8EI16_V_MF2_MF2_MASK, VLOXSEG8EI16_V, 0x7, 0x0 }, // 3890 + { PseudoVLOXSEG8EI16_V_MF4_MF2, VLOXSEG8EI16_V, 0x7, 0x0 }, // 3891 + { PseudoVLOXSEG8EI16_V_MF4_MF2_MASK, VLOXSEG8EI16_V, 0x7, 0x0 }, // 3892 + { PseudoVLOXSEG8EI32_V_M1_M1, VLOXSEG8EI32_V, 0x0, 0x0 }, // 3893 + { PseudoVLOXSEG8EI32_V_M1_M1_MASK, VLOXSEG8EI32_V, 0x0, 0x0 }, // 3894 + { PseudoVLOXSEG8EI32_V_M2_M1, VLOXSEG8EI32_V, 0x0, 0x0 }, // 3895 + { PseudoVLOXSEG8EI32_V_M2_M1_MASK, VLOXSEG8EI32_V, 0x0, 0x0 }, // 3896 + { PseudoVLOXSEG8EI32_V_M4_M1, VLOXSEG8EI32_V, 0x0, 0x0 }, // 3897 + { PseudoVLOXSEG8EI32_V_M4_M1_MASK, VLOXSEG8EI32_V, 0x0, 0x0 }, // 3898 + { PseudoVLOXSEG8EI32_V_MF2_M1, VLOXSEG8EI32_V, 0x0, 0x0 }, // 3899 + { PseudoVLOXSEG8EI32_V_MF2_M1_MASK, VLOXSEG8EI32_V, 0x0, 0x0 }, // 3900 + { PseudoVLOXSEG8EI32_V_MF2_MF8, VLOXSEG8EI32_V, 0x5, 0x0 }, // 3901 + { PseudoVLOXSEG8EI32_V_MF2_MF8_MASK, VLOXSEG8EI32_V, 0x5, 0x0 }, // 3902 + { PseudoVLOXSEG8EI32_V_M1_MF4, VLOXSEG8EI32_V, 0x6, 0x0 }, // 3903 + { PseudoVLOXSEG8EI32_V_M1_MF4_MASK, VLOXSEG8EI32_V, 0x6, 0x0 }, // 3904 + { PseudoVLOXSEG8EI32_V_MF2_MF4, VLOXSEG8EI32_V, 0x6, 0x0 }, // 3905 + { PseudoVLOXSEG8EI32_V_MF2_MF4_MASK, VLOXSEG8EI32_V, 0x6, 0x0 }, // 3906 + { PseudoVLOXSEG8EI32_V_M1_MF2, VLOXSEG8EI32_V, 0x7, 0x0 }, // 3907 + { PseudoVLOXSEG8EI32_V_M1_MF2_MASK, VLOXSEG8EI32_V, 0x7, 0x0 }, // 3908 + { PseudoVLOXSEG8EI32_V_M2_MF2, VLOXSEG8EI32_V, 0x7, 0x0 }, // 3909 + { PseudoVLOXSEG8EI32_V_M2_MF2_MASK, VLOXSEG8EI32_V, 0x7, 0x0 }, // 3910 + { PseudoVLOXSEG8EI32_V_MF2_MF2, VLOXSEG8EI32_V, 0x7, 0x0 }, // 3911 + { PseudoVLOXSEG8EI32_V_MF2_MF2_MASK, VLOXSEG8EI32_V, 0x7, 0x0 }, // 3912 + { PseudoVLOXSEG8EI64_V_M1_M1, VLOXSEG8EI64_V, 0x0, 0x0 }, // 3913 + { PseudoVLOXSEG8EI64_V_M1_M1_MASK, VLOXSEG8EI64_V, 0x0, 0x0 }, // 3914 + { PseudoVLOXSEG8EI64_V_M2_M1, VLOXSEG8EI64_V, 0x0, 0x0 }, // 3915 + { PseudoVLOXSEG8EI64_V_M2_M1_MASK, VLOXSEG8EI64_V, 0x0, 0x0 }, // 3916 + { PseudoVLOXSEG8EI64_V_M4_M1, VLOXSEG8EI64_V, 0x0, 0x0 }, // 3917 + { PseudoVLOXSEG8EI64_V_M4_M1_MASK, VLOXSEG8EI64_V, 0x0, 0x0 }, // 3918 + { PseudoVLOXSEG8EI64_V_M8_M1, VLOXSEG8EI64_V, 0x0, 0x0 }, // 3919 + { PseudoVLOXSEG8EI64_V_M8_M1_MASK, VLOXSEG8EI64_V, 0x0, 0x0 }, // 3920 + { PseudoVLOXSEG8EI64_V_M1_MF8, VLOXSEG8EI64_V, 0x5, 0x0 }, // 3921 + { PseudoVLOXSEG8EI64_V_M1_MF8_MASK, VLOXSEG8EI64_V, 0x5, 0x0 }, // 3922 + { PseudoVLOXSEG8EI64_V_M1_MF4, VLOXSEG8EI64_V, 0x6, 0x0 }, // 3923 + { PseudoVLOXSEG8EI64_V_M1_MF4_MASK, VLOXSEG8EI64_V, 0x6, 0x0 }, // 3924 + { PseudoVLOXSEG8EI64_V_M2_MF4, VLOXSEG8EI64_V, 0x6, 0x0 }, // 3925 + { PseudoVLOXSEG8EI64_V_M2_MF4_MASK, VLOXSEG8EI64_V, 0x6, 0x0 }, // 3926 + { PseudoVLOXSEG8EI64_V_M1_MF2, VLOXSEG8EI64_V, 0x7, 0x0 }, // 3927 + { PseudoVLOXSEG8EI64_V_M1_MF2_MASK, VLOXSEG8EI64_V, 0x7, 0x0 }, // 3928 + { PseudoVLOXSEG8EI64_V_M2_MF2, VLOXSEG8EI64_V, 0x7, 0x0 }, // 3929 + { PseudoVLOXSEG8EI64_V_M2_MF2_MASK, VLOXSEG8EI64_V, 0x7, 0x0 }, // 3930 + { PseudoVLOXSEG8EI64_V_M4_MF2, VLOXSEG8EI64_V, 0x7, 0x0 }, // 3931 + { PseudoVLOXSEG8EI64_V_M4_MF2_MASK, VLOXSEG8EI64_V, 0x7, 0x0 }, // 3932 + { PseudoVLOXSEG8EI8_V_M1_M1, VLOXSEG8EI8_V, 0x0, 0x0 }, // 3933 + { PseudoVLOXSEG8EI8_V_M1_M1_MASK, VLOXSEG8EI8_V, 0x0, 0x0 }, // 3934 + { PseudoVLOXSEG8EI8_V_MF2_M1, VLOXSEG8EI8_V, 0x0, 0x0 }, // 3935 + { PseudoVLOXSEG8EI8_V_MF2_M1_MASK, VLOXSEG8EI8_V, 0x0, 0x0 }, // 3936 + { PseudoVLOXSEG8EI8_V_MF4_M1, VLOXSEG8EI8_V, 0x0, 0x0 }, // 3937 + { PseudoVLOXSEG8EI8_V_MF4_M1_MASK, VLOXSEG8EI8_V, 0x0, 0x0 }, // 3938 + { PseudoVLOXSEG8EI8_V_MF8_M1, VLOXSEG8EI8_V, 0x0, 0x0 }, // 3939 + { PseudoVLOXSEG8EI8_V_MF8_M1_MASK, VLOXSEG8EI8_V, 0x0, 0x0 }, // 3940 + { PseudoVLOXSEG8EI8_V_MF8_MF8, VLOXSEG8EI8_V, 0x5, 0x0 }, // 3941 + { PseudoVLOXSEG8EI8_V_MF8_MF8_MASK, VLOXSEG8EI8_V, 0x5, 0x0 }, // 3942 + { PseudoVLOXSEG8EI8_V_MF4_MF4, VLOXSEG8EI8_V, 0x6, 0x0 }, // 3943 + { PseudoVLOXSEG8EI8_V_MF4_MF4_MASK, VLOXSEG8EI8_V, 0x6, 0x0 }, // 3944 + { PseudoVLOXSEG8EI8_V_MF8_MF4, VLOXSEG8EI8_V, 0x6, 0x0 }, // 3945 + { PseudoVLOXSEG8EI8_V_MF8_MF4_MASK, VLOXSEG8EI8_V, 0x6, 0x0 }, // 3946 + { PseudoVLOXSEG8EI8_V_MF2_MF2, VLOXSEG8EI8_V, 0x7, 0x0 }, // 3947 + { PseudoVLOXSEG8EI8_V_MF2_MF2_MASK, VLOXSEG8EI8_V, 0x7, 0x0 }, // 3948 + { PseudoVLOXSEG8EI8_V_MF4_MF2, VLOXSEG8EI8_V, 0x7, 0x0 }, // 3949 + { PseudoVLOXSEG8EI8_V_MF4_MF2_MASK, VLOXSEG8EI8_V, 0x7, 0x0 }, // 3950 + { PseudoVLOXSEG8EI8_V_MF8_MF2, VLOXSEG8EI8_V, 0x7, 0x0 }, // 3951 + { PseudoVLOXSEG8EI8_V_MF8_MF2_MASK, VLOXSEG8EI8_V, 0x7, 0x0 }, // 3952 + { PseudoVLSE16_V_M1, VLSE16_V, 0x0, 0x10 }, // 3953 + { PseudoVLSE16_V_M1_MASK, VLSE16_V, 0x0, 0x10 }, // 3954 + { PseudoVLSE16_V_M2, VLSE16_V, 0x1, 0x10 }, // 3955 + { PseudoVLSE16_V_M2_MASK, VLSE16_V, 0x1, 0x10 }, // 3956 + { PseudoVLSE16_V_M4, VLSE16_V, 0x2, 0x10 }, // 3957 + { PseudoVLSE16_V_M4_MASK, VLSE16_V, 0x2, 0x10 }, // 3958 + { PseudoVLSE16_V_M8, VLSE16_V, 0x3, 0x10 }, // 3959 + { PseudoVLSE16_V_M8_MASK, VLSE16_V, 0x3, 0x10 }, // 3960 + { PseudoVLSE16_V_MF4, VLSE16_V, 0x6, 0x10 }, // 3961 + { PseudoVLSE16_V_MF4_MASK, VLSE16_V, 0x6, 0x10 }, // 3962 + { PseudoVLSE16_V_MF2, VLSE16_V, 0x7, 0x10 }, // 3963 + { PseudoVLSE16_V_MF2_MASK, VLSE16_V, 0x7, 0x10 }, // 3964 + { PseudoVLSE32_V_M1, VLSE32_V, 0x0, 0x20 }, // 3965 + { PseudoVLSE32_V_M1_MASK, VLSE32_V, 0x0, 0x20 }, // 3966 + { PseudoVLSE32_V_M2, VLSE32_V, 0x1, 0x20 }, // 3967 + { PseudoVLSE32_V_M2_MASK, VLSE32_V, 0x1, 0x20 }, // 3968 + { PseudoVLSE32_V_M4, VLSE32_V, 0x2, 0x20 }, // 3969 + { PseudoVLSE32_V_M4_MASK, VLSE32_V, 0x2, 0x20 }, // 3970 + { PseudoVLSE32_V_M8, VLSE32_V, 0x3, 0x20 }, // 3971 + { PseudoVLSE32_V_M8_MASK, VLSE32_V, 0x3, 0x20 }, // 3972 + { PseudoVLSE32_V_MF2, VLSE32_V, 0x7, 0x20 }, // 3973 + { PseudoVLSE32_V_MF2_MASK, VLSE32_V, 0x7, 0x20 }, // 3974 + { PseudoVLSE64_V_M1, VLSE64_V, 0x0, 0x40 }, // 3975 + { PseudoVLSE64_V_M1_MASK, VLSE64_V, 0x0, 0x40 }, // 3976 + { PseudoVLSE64_V_M2, VLSE64_V, 0x1, 0x40 }, // 3977 + { PseudoVLSE64_V_M2_MASK, VLSE64_V, 0x1, 0x40 }, // 3978 + { PseudoVLSE64_V_M4, VLSE64_V, 0x2, 0x40 }, // 3979 + { PseudoVLSE64_V_M4_MASK, VLSE64_V, 0x2, 0x40 }, // 3980 + { PseudoVLSE64_V_M8, VLSE64_V, 0x3, 0x40 }, // 3981 + { PseudoVLSE64_V_M8_MASK, VLSE64_V, 0x3, 0x40 }, // 3982 + { PseudoVLSE8_V_M1, VLSE8_V, 0x0, 0x8 }, // 3983 + { PseudoVLSE8_V_M1_MASK, VLSE8_V, 0x0, 0x8 }, // 3984 + { PseudoVLSE8_V_M2, VLSE8_V, 0x1, 0x8 }, // 3985 + { PseudoVLSE8_V_M2_MASK, VLSE8_V, 0x1, 0x8 }, // 3986 + { PseudoVLSE8_V_M4, VLSE8_V, 0x2, 0x8 }, // 3987 + { PseudoVLSE8_V_M4_MASK, VLSE8_V, 0x2, 0x8 }, // 3988 + { PseudoVLSE8_V_M8, VLSE8_V, 0x3, 0x8 }, // 3989 + { PseudoVLSE8_V_M8_MASK, VLSE8_V, 0x3, 0x8 }, // 3990 + { PseudoVLSE8_V_MF8, VLSE8_V, 0x5, 0x8 }, // 3991 + { PseudoVLSE8_V_MF8_MASK, VLSE8_V, 0x5, 0x8 }, // 3992 + { PseudoVLSE8_V_MF4, VLSE8_V, 0x6, 0x8 }, // 3993 + { PseudoVLSE8_V_MF4_MASK, VLSE8_V, 0x6, 0x8 }, // 3994 + { PseudoVLSE8_V_MF2, VLSE8_V, 0x7, 0x8 }, // 3995 + { PseudoVLSE8_V_MF2_MASK, VLSE8_V, 0x7, 0x8 }, // 3996 + { PseudoVLSEG2E16FF_V_M1, VLSEG2E16FF_V, 0x0, 0x10 }, // 3997 + { PseudoVLSEG2E16FF_V_M1_MASK, VLSEG2E16FF_V, 0x0, 0x10 }, // 3998 + { PseudoVLSEG2E16FF_V_M2, VLSEG2E16FF_V, 0x1, 0x10 }, // 3999 + { PseudoVLSEG2E16FF_V_M2_MASK, VLSEG2E16FF_V, 0x1, 0x10 }, // 4000 + { PseudoVLSEG2E16FF_V_M4, VLSEG2E16FF_V, 0x2, 0x10 }, // 4001 + { PseudoVLSEG2E16FF_V_M4_MASK, VLSEG2E16FF_V, 0x2, 0x10 }, // 4002 + { PseudoVLSEG2E16FF_V_MF4, VLSEG2E16FF_V, 0x6, 0x10 }, // 4003 + { PseudoVLSEG2E16FF_V_MF4_MASK, VLSEG2E16FF_V, 0x6, 0x10 }, // 4004 + { PseudoVLSEG2E16FF_V_MF2, VLSEG2E16FF_V, 0x7, 0x10 }, // 4005 + { PseudoVLSEG2E16FF_V_MF2_MASK, VLSEG2E16FF_V, 0x7, 0x10 }, // 4006 + { PseudoVLSEG2E16_V_M1, VLSEG2E16_V, 0x0, 0x10 }, // 4007 + { PseudoVLSEG2E16_V_M1_MASK, VLSEG2E16_V, 0x0, 0x10 }, // 4008 + { PseudoVLSEG2E16_V_M2, VLSEG2E16_V, 0x1, 0x10 }, // 4009 + { PseudoVLSEG2E16_V_M2_MASK, VLSEG2E16_V, 0x1, 0x10 }, // 4010 + { PseudoVLSEG2E16_V_M4, VLSEG2E16_V, 0x2, 0x10 }, // 4011 + { PseudoVLSEG2E16_V_M4_MASK, VLSEG2E16_V, 0x2, 0x10 }, // 4012 + { PseudoVLSEG2E16_V_MF4, VLSEG2E16_V, 0x6, 0x10 }, // 4013 + { PseudoVLSEG2E16_V_MF4_MASK, VLSEG2E16_V, 0x6, 0x10 }, // 4014 + { PseudoVLSEG2E16_V_MF2, VLSEG2E16_V, 0x7, 0x10 }, // 4015 + { PseudoVLSEG2E16_V_MF2_MASK, VLSEG2E16_V, 0x7, 0x10 }, // 4016 + { PseudoVLSEG2E32FF_V_M1, VLSEG2E32FF_V, 0x0, 0x20 }, // 4017 + { PseudoVLSEG2E32FF_V_M1_MASK, VLSEG2E32FF_V, 0x0, 0x20 }, // 4018 + { PseudoVLSEG2E32FF_V_M2, VLSEG2E32FF_V, 0x1, 0x20 }, // 4019 + { PseudoVLSEG2E32FF_V_M2_MASK, VLSEG2E32FF_V, 0x1, 0x20 }, // 4020 + { PseudoVLSEG2E32FF_V_M4, VLSEG2E32FF_V, 0x2, 0x20 }, // 4021 + { PseudoVLSEG2E32FF_V_M4_MASK, VLSEG2E32FF_V, 0x2, 0x20 }, // 4022 + { PseudoVLSEG2E32FF_V_MF2, VLSEG2E32FF_V, 0x7, 0x20 }, // 4023 + { PseudoVLSEG2E32FF_V_MF2_MASK, VLSEG2E32FF_V, 0x7, 0x20 }, // 4024 + { PseudoVLSEG2E32_V_M1, VLSEG2E32_V, 0x0, 0x20 }, // 4025 + { PseudoVLSEG2E32_V_M1_MASK, VLSEG2E32_V, 0x0, 0x20 }, // 4026 + { PseudoVLSEG2E32_V_M2, VLSEG2E32_V, 0x1, 0x20 }, // 4027 + { PseudoVLSEG2E32_V_M2_MASK, VLSEG2E32_V, 0x1, 0x20 }, // 4028 + { PseudoVLSEG2E32_V_M4, VLSEG2E32_V, 0x2, 0x20 }, // 4029 + { PseudoVLSEG2E32_V_M4_MASK, VLSEG2E32_V, 0x2, 0x20 }, // 4030 + { PseudoVLSEG2E32_V_MF2, VLSEG2E32_V, 0x7, 0x20 }, // 4031 + { PseudoVLSEG2E32_V_MF2_MASK, VLSEG2E32_V, 0x7, 0x20 }, // 4032 + { PseudoVLSEG2E64FF_V_M1, VLSEG2E64FF_V, 0x0, 0x40 }, // 4033 + { PseudoVLSEG2E64FF_V_M1_MASK, VLSEG2E64FF_V, 0x0, 0x40 }, // 4034 + { PseudoVLSEG2E64FF_V_M2, VLSEG2E64FF_V, 0x1, 0x40 }, // 4035 + { PseudoVLSEG2E64FF_V_M2_MASK, VLSEG2E64FF_V, 0x1, 0x40 }, // 4036 + { PseudoVLSEG2E64FF_V_M4, VLSEG2E64FF_V, 0x2, 0x40 }, // 4037 + { PseudoVLSEG2E64FF_V_M4_MASK, VLSEG2E64FF_V, 0x2, 0x40 }, // 4038 + { PseudoVLSEG2E64_V_M1, VLSEG2E64_V, 0x0, 0x40 }, // 4039 + { PseudoVLSEG2E64_V_M1_MASK, VLSEG2E64_V, 0x0, 0x40 }, // 4040 + { PseudoVLSEG2E64_V_M2, VLSEG2E64_V, 0x1, 0x40 }, // 4041 + { PseudoVLSEG2E64_V_M2_MASK, VLSEG2E64_V, 0x1, 0x40 }, // 4042 + { PseudoVLSEG2E64_V_M4, VLSEG2E64_V, 0x2, 0x40 }, // 4043 + { PseudoVLSEG2E64_V_M4_MASK, VLSEG2E64_V, 0x2, 0x40 }, // 4044 + { PseudoVLSEG2E8FF_V_M1, VLSEG2E8FF_V, 0x0, 0x8 }, // 4045 + { PseudoVLSEG2E8FF_V_M1_MASK, VLSEG2E8FF_V, 0x0, 0x8 }, // 4046 + { PseudoVLSEG2E8FF_V_M2, VLSEG2E8FF_V, 0x1, 0x8 }, // 4047 + { PseudoVLSEG2E8FF_V_M2_MASK, VLSEG2E8FF_V, 0x1, 0x8 }, // 4048 + { PseudoVLSEG2E8FF_V_M4, VLSEG2E8FF_V, 0x2, 0x8 }, // 4049 + { PseudoVLSEG2E8FF_V_M4_MASK, VLSEG2E8FF_V, 0x2, 0x8 }, // 4050 + { PseudoVLSEG2E8FF_V_MF8, VLSEG2E8FF_V, 0x5, 0x8 }, // 4051 + { PseudoVLSEG2E8FF_V_MF8_MASK, VLSEG2E8FF_V, 0x5, 0x8 }, // 4052 + { PseudoVLSEG2E8FF_V_MF4, VLSEG2E8FF_V, 0x6, 0x8 }, // 4053 + { PseudoVLSEG2E8FF_V_MF4_MASK, VLSEG2E8FF_V, 0x6, 0x8 }, // 4054 + { PseudoVLSEG2E8FF_V_MF2, VLSEG2E8FF_V, 0x7, 0x8 }, // 4055 + { PseudoVLSEG2E8FF_V_MF2_MASK, VLSEG2E8FF_V, 0x7, 0x8 }, // 4056 + { PseudoVLSEG2E8_V_M1, VLSEG2E8_V, 0x0, 0x8 }, // 4057 + { PseudoVLSEG2E8_V_M1_MASK, VLSEG2E8_V, 0x0, 0x8 }, // 4058 + { PseudoVLSEG2E8_V_M2, VLSEG2E8_V, 0x1, 0x8 }, // 4059 + { PseudoVLSEG2E8_V_M2_MASK, VLSEG2E8_V, 0x1, 0x8 }, // 4060 + { PseudoVLSEG2E8_V_M4, VLSEG2E8_V, 0x2, 0x8 }, // 4061 + { PseudoVLSEG2E8_V_M4_MASK, VLSEG2E8_V, 0x2, 0x8 }, // 4062 + { PseudoVLSEG2E8_V_MF8, VLSEG2E8_V, 0x5, 0x8 }, // 4063 + { PseudoVLSEG2E8_V_MF8_MASK, VLSEG2E8_V, 0x5, 0x8 }, // 4064 + { PseudoVLSEG2E8_V_MF4, VLSEG2E8_V, 0x6, 0x8 }, // 4065 + { PseudoVLSEG2E8_V_MF4_MASK, VLSEG2E8_V, 0x6, 0x8 }, // 4066 + { PseudoVLSEG2E8_V_MF2, VLSEG2E8_V, 0x7, 0x8 }, // 4067 + { PseudoVLSEG2E8_V_MF2_MASK, VLSEG2E8_V, 0x7, 0x8 }, // 4068 + { PseudoVLSEG3E16FF_V_M1, VLSEG3E16FF_V, 0x0, 0x10 }, // 4069 + { PseudoVLSEG3E16FF_V_M1_MASK, VLSEG3E16FF_V, 0x0, 0x10 }, // 4070 + { PseudoVLSEG3E16FF_V_M2, VLSEG3E16FF_V, 0x1, 0x10 }, // 4071 + { PseudoVLSEG3E16FF_V_M2_MASK, VLSEG3E16FF_V, 0x1, 0x10 }, // 4072 + { PseudoVLSEG3E16FF_V_MF4, VLSEG3E16FF_V, 0x6, 0x10 }, // 4073 + { PseudoVLSEG3E16FF_V_MF4_MASK, VLSEG3E16FF_V, 0x6, 0x10 }, // 4074 + { PseudoVLSEG3E16FF_V_MF2, VLSEG3E16FF_V, 0x7, 0x10 }, // 4075 + { PseudoVLSEG3E16FF_V_MF2_MASK, VLSEG3E16FF_V, 0x7, 0x10 }, // 4076 + { PseudoVLSEG3E16_V_M1, VLSEG3E16_V, 0x0, 0x10 }, // 4077 + { PseudoVLSEG3E16_V_M1_MASK, VLSEG3E16_V, 0x0, 0x10 }, // 4078 + { PseudoVLSEG3E16_V_M2, VLSEG3E16_V, 0x1, 0x10 }, // 4079 + { PseudoVLSEG3E16_V_M2_MASK, VLSEG3E16_V, 0x1, 0x10 }, // 4080 + { PseudoVLSEG3E16_V_MF4, VLSEG3E16_V, 0x6, 0x10 }, // 4081 + { PseudoVLSEG3E16_V_MF4_MASK, VLSEG3E16_V, 0x6, 0x10 }, // 4082 + { PseudoVLSEG3E16_V_MF2, VLSEG3E16_V, 0x7, 0x10 }, // 4083 + { PseudoVLSEG3E16_V_MF2_MASK, VLSEG3E16_V, 0x7, 0x10 }, // 4084 + { PseudoVLSEG3E32FF_V_M1, VLSEG3E32FF_V, 0x0, 0x20 }, // 4085 + { PseudoVLSEG3E32FF_V_M1_MASK, VLSEG3E32FF_V, 0x0, 0x20 }, // 4086 + { PseudoVLSEG3E32FF_V_M2, VLSEG3E32FF_V, 0x1, 0x20 }, // 4087 + { PseudoVLSEG3E32FF_V_M2_MASK, VLSEG3E32FF_V, 0x1, 0x20 }, // 4088 + { PseudoVLSEG3E32FF_V_MF2, VLSEG3E32FF_V, 0x7, 0x20 }, // 4089 + { PseudoVLSEG3E32FF_V_MF2_MASK, VLSEG3E32FF_V, 0x7, 0x20 }, // 4090 + { PseudoVLSEG3E32_V_M1, VLSEG3E32_V, 0x0, 0x20 }, // 4091 + { PseudoVLSEG3E32_V_M1_MASK, VLSEG3E32_V, 0x0, 0x20 }, // 4092 + { PseudoVLSEG3E32_V_M2, VLSEG3E32_V, 0x1, 0x20 }, // 4093 + { PseudoVLSEG3E32_V_M2_MASK, VLSEG3E32_V, 0x1, 0x20 }, // 4094 + { PseudoVLSEG3E32_V_MF2, VLSEG3E32_V, 0x7, 0x20 }, // 4095 + { PseudoVLSEG3E32_V_MF2_MASK, VLSEG3E32_V, 0x7, 0x20 }, // 4096 + { PseudoVLSEG3E64FF_V_M1, VLSEG3E64FF_V, 0x0, 0x40 }, // 4097 + { PseudoVLSEG3E64FF_V_M1_MASK, VLSEG3E64FF_V, 0x0, 0x40 }, // 4098 + { PseudoVLSEG3E64FF_V_M2, VLSEG3E64FF_V, 0x1, 0x40 }, // 4099 + { PseudoVLSEG3E64FF_V_M2_MASK, VLSEG3E64FF_V, 0x1, 0x40 }, // 4100 + { PseudoVLSEG3E64_V_M1, VLSEG3E64_V, 0x0, 0x40 }, // 4101 + { PseudoVLSEG3E64_V_M1_MASK, VLSEG3E64_V, 0x0, 0x40 }, // 4102 + { PseudoVLSEG3E64_V_M2, VLSEG3E64_V, 0x1, 0x40 }, // 4103 + { PseudoVLSEG3E64_V_M2_MASK, VLSEG3E64_V, 0x1, 0x40 }, // 4104 + { PseudoVLSEG3E8FF_V_M1, VLSEG3E8FF_V, 0x0, 0x8 }, // 4105 + { PseudoVLSEG3E8FF_V_M1_MASK, VLSEG3E8FF_V, 0x0, 0x8 }, // 4106 + { PseudoVLSEG3E8FF_V_M2, VLSEG3E8FF_V, 0x1, 0x8 }, // 4107 + { PseudoVLSEG3E8FF_V_M2_MASK, VLSEG3E8FF_V, 0x1, 0x8 }, // 4108 + { PseudoVLSEG3E8FF_V_MF8, VLSEG3E8FF_V, 0x5, 0x8 }, // 4109 + { PseudoVLSEG3E8FF_V_MF8_MASK, VLSEG3E8FF_V, 0x5, 0x8 }, // 4110 + { PseudoVLSEG3E8FF_V_MF4, VLSEG3E8FF_V, 0x6, 0x8 }, // 4111 + { PseudoVLSEG3E8FF_V_MF4_MASK, VLSEG3E8FF_V, 0x6, 0x8 }, // 4112 + { PseudoVLSEG3E8FF_V_MF2, VLSEG3E8FF_V, 0x7, 0x8 }, // 4113 + { PseudoVLSEG3E8FF_V_MF2_MASK, VLSEG3E8FF_V, 0x7, 0x8 }, // 4114 + { PseudoVLSEG3E8_V_M1, VLSEG3E8_V, 0x0, 0x8 }, // 4115 + { PseudoVLSEG3E8_V_M1_MASK, VLSEG3E8_V, 0x0, 0x8 }, // 4116 + { PseudoVLSEG3E8_V_M2, VLSEG3E8_V, 0x1, 0x8 }, // 4117 + { PseudoVLSEG3E8_V_M2_MASK, VLSEG3E8_V, 0x1, 0x8 }, // 4118 + { PseudoVLSEG3E8_V_MF8, VLSEG3E8_V, 0x5, 0x8 }, // 4119 + { PseudoVLSEG3E8_V_MF8_MASK, VLSEG3E8_V, 0x5, 0x8 }, // 4120 + { PseudoVLSEG3E8_V_MF4, VLSEG3E8_V, 0x6, 0x8 }, // 4121 + { PseudoVLSEG3E8_V_MF4_MASK, VLSEG3E8_V, 0x6, 0x8 }, // 4122 + { PseudoVLSEG3E8_V_MF2, VLSEG3E8_V, 0x7, 0x8 }, // 4123 + { PseudoVLSEG3E8_V_MF2_MASK, VLSEG3E8_V, 0x7, 0x8 }, // 4124 + { PseudoVLSEG4E16FF_V_M1, VLSEG4E16FF_V, 0x0, 0x10 }, // 4125 + { PseudoVLSEG4E16FF_V_M1_MASK, VLSEG4E16FF_V, 0x0, 0x10 }, // 4126 + { PseudoVLSEG4E16FF_V_M2, VLSEG4E16FF_V, 0x1, 0x10 }, // 4127 + { PseudoVLSEG4E16FF_V_M2_MASK, VLSEG4E16FF_V, 0x1, 0x10 }, // 4128 + { PseudoVLSEG4E16FF_V_MF4, VLSEG4E16FF_V, 0x6, 0x10 }, // 4129 + { PseudoVLSEG4E16FF_V_MF4_MASK, VLSEG4E16FF_V, 0x6, 0x10 }, // 4130 + { PseudoVLSEG4E16FF_V_MF2, VLSEG4E16FF_V, 0x7, 0x10 }, // 4131 + { PseudoVLSEG4E16FF_V_MF2_MASK, VLSEG4E16FF_V, 0x7, 0x10 }, // 4132 + { PseudoVLSEG4E16_V_M1, VLSEG4E16_V, 0x0, 0x10 }, // 4133 + { PseudoVLSEG4E16_V_M1_MASK, VLSEG4E16_V, 0x0, 0x10 }, // 4134 + { PseudoVLSEG4E16_V_M2, VLSEG4E16_V, 0x1, 0x10 }, // 4135 + { PseudoVLSEG4E16_V_M2_MASK, VLSEG4E16_V, 0x1, 0x10 }, // 4136 + { PseudoVLSEG4E16_V_MF4, VLSEG4E16_V, 0x6, 0x10 }, // 4137 + { PseudoVLSEG4E16_V_MF4_MASK, VLSEG4E16_V, 0x6, 0x10 }, // 4138 + { PseudoVLSEG4E16_V_MF2, VLSEG4E16_V, 0x7, 0x10 }, // 4139 + { PseudoVLSEG4E16_V_MF2_MASK, VLSEG4E16_V, 0x7, 0x10 }, // 4140 + { PseudoVLSEG4E32FF_V_M1, VLSEG4E32FF_V, 0x0, 0x20 }, // 4141 + { PseudoVLSEG4E32FF_V_M1_MASK, VLSEG4E32FF_V, 0x0, 0x20 }, // 4142 + { PseudoVLSEG4E32FF_V_M2, VLSEG4E32FF_V, 0x1, 0x20 }, // 4143 + { PseudoVLSEG4E32FF_V_M2_MASK, VLSEG4E32FF_V, 0x1, 0x20 }, // 4144 + { PseudoVLSEG4E32FF_V_MF2, VLSEG4E32FF_V, 0x7, 0x20 }, // 4145 + { PseudoVLSEG4E32FF_V_MF2_MASK, VLSEG4E32FF_V, 0x7, 0x20 }, // 4146 + { PseudoVLSEG4E32_V_M1, VLSEG4E32_V, 0x0, 0x20 }, // 4147 + { PseudoVLSEG4E32_V_M1_MASK, VLSEG4E32_V, 0x0, 0x20 }, // 4148 + { PseudoVLSEG4E32_V_M2, VLSEG4E32_V, 0x1, 0x20 }, // 4149 + { PseudoVLSEG4E32_V_M2_MASK, VLSEG4E32_V, 0x1, 0x20 }, // 4150 + { PseudoVLSEG4E32_V_MF2, VLSEG4E32_V, 0x7, 0x20 }, // 4151 + { PseudoVLSEG4E32_V_MF2_MASK, VLSEG4E32_V, 0x7, 0x20 }, // 4152 + { PseudoVLSEG4E64FF_V_M1, VLSEG4E64FF_V, 0x0, 0x40 }, // 4153 + { PseudoVLSEG4E64FF_V_M1_MASK, VLSEG4E64FF_V, 0x0, 0x40 }, // 4154 + { PseudoVLSEG4E64FF_V_M2, VLSEG4E64FF_V, 0x1, 0x40 }, // 4155 + { PseudoVLSEG4E64FF_V_M2_MASK, VLSEG4E64FF_V, 0x1, 0x40 }, // 4156 + { PseudoVLSEG4E64_V_M1, VLSEG4E64_V, 0x0, 0x40 }, // 4157 + { PseudoVLSEG4E64_V_M1_MASK, VLSEG4E64_V, 0x0, 0x40 }, // 4158 + { PseudoVLSEG4E64_V_M2, VLSEG4E64_V, 0x1, 0x40 }, // 4159 + { PseudoVLSEG4E64_V_M2_MASK, VLSEG4E64_V, 0x1, 0x40 }, // 4160 + { PseudoVLSEG4E8FF_V_M1, VLSEG4E8FF_V, 0x0, 0x8 }, // 4161 + { PseudoVLSEG4E8FF_V_M1_MASK, VLSEG4E8FF_V, 0x0, 0x8 }, // 4162 + { PseudoVLSEG4E8FF_V_M2, VLSEG4E8FF_V, 0x1, 0x8 }, // 4163 + { PseudoVLSEG4E8FF_V_M2_MASK, VLSEG4E8FF_V, 0x1, 0x8 }, // 4164 + { PseudoVLSEG4E8FF_V_MF8, VLSEG4E8FF_V, 0x5, 0x8 }, // 4165 + { PseudoVLSEG4E8FF_V_MF8_MASK, VLSEG4E8FF_V, 0x5, 0x8 }, // 4166 + { PseudoVLSEG4E8FF_V_MF4, VLSEG4E8FF_V, 0x6, 0x8 }, // 4167 + { PseudoVLSEG4E8FF_V_MF4_MASK, VLSEG4E8FF_V, 0x6, 0x8 }, // 4168 + { PseudoVLSEG4E8FF_V_MF2, VLSEG4E8FF_V, 0x7, 0x8 }, // 4169 + { PseudoVLSEG4E8FF_V_MF2_MASK, VLSEG4E8FF_V, 0x7, 0x8 }, // 4170 + { PseudoVLSEG4E8_V_M1, VLSEG4E8_V, 0x0, 0x8 }, // 4171 + { PseudoVLSEG4E8_V_M1_MASK, VLSEG4E8_V, 0x0, 0x8 }, // 4172 + { PseudoVLSEG4E8_V_M2, VLSEG4E8_V, 0x1, 0x8 }, // 4173 + { PseudoVLSEG4E8_V_M2_MASK, VLSEG4E8_V, 0x1, 0x8 }, // 4174 + { PseudoVLSEG4E8_V_MF8, VLSEG4E8_V, 0x5, 0x8 }, // 4175 + { PseudoVLSEG4E8_V_MF8_MASK, VLSEG4E8_V, 0x5, 0x8 }, // 4176 + { PseudoVLSEG4E8_V_MF4, VLSEG4E8_V, 0x6, 0x8 }, // 4177 + { PseudoVLSEG4E8_V_MF4_MASK, VLSEG4E8_V, 0x6, 0x8 }, // 4178 + { PseudoVLSEG4E8_V_MF2, VLSEG4E8_V, 0x7, 0x8 }, // 4179 + { PseudoVLSEG4E8_V_MF2_MASK, VLSEG4E8_V, 0x7, 0x8 }, // 4180 + { PseudoVLSEG5E16FF_V_M1, VLSEG5E16FF_V, 0x0, 0x10 }, // 4181 + { PseudoVLSEG5E16FF_V_M1_MASK, VLSEG5E16FF_V, 0x0, 0x10 }, // 4182 + { PseudoVLSEG5E16FF_V_MF4, VLSEG5E16FF_V, 0x6, 0x10 }, // 4183 + { PseudoVLSEG5E16FF_V_MF4_MASK, VLSEG5E16FF_V, 0x6, 0x10 }, // 4184 + { PseudoVLSEG5E16FF_V_MF2, VLSEG5E16FF_V, 0x7, 0x10 }, // 4185 + { PseudoVLSEG5E16FF_V_MF2_MASK, VLSEG5E16FF_V, 0x7, 0x10 }, // 4186 + { PseudoVLSEG5E16_V_M1, VLSEG5E16_V, 0x0, 0x10 }, // 4187 + { PseudoVLSEG5E16_V_M1_MASK, VLSEG5E16_V, 0x0, 0x10 }, // 4188 + { PseudoVLSEG5E16_V_MF4, VLSEG5E16_V, 0x6, 0x10 }, // 4189 + { PseudoVLSEG5E16_V_MF4_MASK, VLSEG5E16_V, 0x6, 0x10 }, // 4190 + { PseudoVLSEG5E16_V_MF2, VLSEG5E16_V, 0x7, 0x10 }, // 4191 + { PseudoVLSEG5E16_V_MF2_MASK, VLSEG5E16_V, 0x7, 0x10 }, // 4192 + { PseudoVLSEG5E32FF_V_M1, VLSEG5E32FF_V, 0x0, 0x20 }, // 4193 + { PseudoVLSEG5E32FF_V_M1_MASK, VLSEG5E32FF_V, 0x0, 0x20 }, // 4194 + { PseudoVLSEG5E32FF_V_MF2, VLSEG5E32FF_V, 0x7, 0x20 }, // 4195 + { PseudoVLSEG5E32FF_V_MF2_MASK, VLSEG5E32FF_V, 0x7, 0x20 }, // 4196 + { PseudoVLSEG5E32_V_M1, VLSEG5E32_V, 0x0, 0x20 }, // 4197 + { PseudoVLSEG5E32_V_M1_MASK, VLSEG5E32_V, 0x0, 0x20 }, // 4198 + { PseudoVLSEG5E32_V_MF2, VLSEG5E32_V, 0x7, 0x20 }, // 4199 + { PseudoVLSEG5E32_V_MF2_MASK, VLSEG5E32_V, 0x7, 0x20 }, // 4200 + { PseudoVLSEG5E64FF_V_M1, VLSEG5E64FF_V, 0x0, 0x40 }, // 4201 + { PseudoVLSEG5E64FF_V_M1_MASK, VLSEG5E64FF_V, 0x0, 0x40 }, // 4202 + { PseudoVLSEG5E64_V_M1, VLSEG5E64_V, 0x0, 0x40 }, // 4203 + { PseudoVLSEG5E64_V_M1_MASK, VLSEG5E64_V, 0x0, 0x40 }, // 4204 + { PseudoVLSEG5E8FF_V_M1, VLSEG5E8FF_V, 0x0, 0x8 }, // 4205 + { PseudoVLSEG5E8FF_V_M1_MASK, VLSEG5E8FF_V, 0x0, 0x8 }, // 4206 + { PseudoVLSEG5E8FF_V_MF8, VLSEG5E8FF_V, 0x5, 0x8 }, // 4207 + { PseudoVLSEG5E8FF_V_MF8_MASK, VLSEG5E8FF_V, 0x5, 0x8 }, // 4208 + { PseudoVLSEG5E8FF_V_MF4, VLSEG5E8FF_V, 0x6, 0x8 }, // 4209 + { PseudoVLSEG5E8FF_V_MF4_MASK, VLSEG5E8FF_V, 0x6, 0x8 }, // 4210 + { PseudoVLSEG5E8FF_V_MF2, VLSEG5E8FF_V, 0x7, 0x8 }, // 4211 + { PseudoVLSEG5E8FF_V_MF2_MASK, VLSEG5E8FF_V, 0x7, 0x8 }, // 4212 + { PseudoVLSEG5E8_V_M1, VLSEG5E8_V, 0x0, 0x8 }, // 4213 + { PseudoVLSEG5E8_V_M1_MASK, VLSEG5E8_V, 0x0, 0x8 }, // 4214 + { PseudoVLSEG5E8_V_MF8, VLSEG5E8_V, 0x5, 0x8 }, // 4215 + { PseudoVLSEG5E8_V_MF8_MASK, VLSEG5E8_V, 0x5, 0x8 }, // 4216 + { PseudoVLSEG5E8_V_MF4, VLSEG5E8_V, 0x6, 0x8 }, // 4217 + { PseudoVLSEG5E8_V_MF4_MASK, VLSEG5E8_V, 0x6, 0x8 }, // 4218 + { PseudoVLSEG5E8_V_MF2, VLSEG5E8_V, 0x7, 0x8 }, // 4219 + { PseudoVLSEG5E8_V_MF2_MASK, VLSEG5E8_V, 0x7, 0x8 }, // 4220 + { PseudoVLSEG6E16FF_V_M1, VLSEG6E16FF_V, 0x0, 0x10 }, // 4221 + { PseudoVLSEG6E16FF_V_M1_MASK, VLSEG6E16FF_V, 0x0, 0x10 }, // 4222 + { PseudoVLSEG6E16FF_V_MF4, VLSEG6E16FF_V, 0x6, 0x10 }, // 4223 + { PseudoVLSEG6E16FF_V_MF4_MASK, VLSEG6E16FF_V, 0x6, 0x10 }, // 4224 + { PseudoVLSEG6E16FF_V_MF2, VLSEG6E16FF_V, 0x7, 0x10 }, // 4225 + { PseudoVLSEG6E16FF_V_MF2_MASK, VLSEG6E16FF_V, 0x7, 0x10 }, // 4226 + { PseudoVLSEG6E16_V_M1, VLSEG6E16_V, 0x0, 0x10 }, // 4227 + { PseudoVLSEG6E16_V_M1_MASK, VLSEG6E16_V, 0x0, 0x10 }, // 4228 + { PseudoVLSEG6E16_V_MF4, VLSEG6E16_V, 0x6, 0x10 }, // 4229 + { PseudoVLSEG6E16_V_MF4_MASK, VLSEG6E16_V, 0x6, 0x10 }, // 4230 + { PseudoVLSEG6E16_V_MF2, VLSEG6E16_V, 0x7, 0x10 }, // 4231 + { PseudoVLSEG6E16_V_MF2_MASK, VLSEG6E16_V, 0x7, 0x10 }, // 4232 + { PseudoVLSEG6E32FF_V_M1, VLSEG6E32FF_V, 0x0, 0x20 }, // 4233 + { PseudoVLSEG6E32FF_V_M1_MASK, VLSEG6E32FF_V, 0x0, 0x20 }, // 4234 + { PseudoVLSEG6E32FF_V_MF2, VLSEG6E32FF_V, 0x7, 0x20 }, // 4235 + { PseudoVLSEG6E32FF_V_MF2_MASK, VLSEG6E32FF_V, 0x7, 0x20 }, // 4236 + { PseudoVLSEG6E32_V_M1, VLSEG6E32_V, 0x0, 0x20 }, // 4237 + { PseudoVLSEG6E32_V_M1_MASK, VLSEG6E32_V, 0x0, 0x20 }, // 4238 + { PseudoVLSEG6E32_V_MF2, VLSEG6E32_V, 0x7, 0x20 }, // 4239 + { PseudoVLSEG6E32_V_MF2_MASK, VLSEG6E32_V, 0x7, 0x20 }, // 4240 + { PseudoVLSEG6E64FF_V_M1, VLSEG6E64FF_V, 0x0, 0x40 }, // 4241 + { PseudoVLSEG6E64FF_V_M1_MASK, VLSEG6E64FF_V, 0x0, 0x40 }, // 4242 + { PseudoVLSEG6E64_V_M1, VLSEG6E64_V, 0x0, 0x40 }, // 4243 + { PseudoVLSEG6E64_V_M1_MASK, VLSEG6E64_V, 0x0, 0x40 }, // 4244 + { PseudoVLSEG6E8FF_V_M1, VLSEG6E8FF_V, 0x0, 0x8 }, // 4245 + { PseudoVLSEG6E8FF_V_M1_MASK, VLSEG6E8FF_V, 0x0, 0x8 }, // 4246 + { PseudoVLSEG6E8FF_V_MF8, VLSEG6E8FF_V, 0x5, 0x8 }, // 4247 + { PseudoVLSEG6E8FF_V_MF8_MASK, VLSEG6E8FF_V, 0x5, 0x8 }, // 4248 + { PseudoVLSEG6E8FF_V_MF4, VLSEG6E8FF_V, 0x6, 0x8 }, // 4249 + { PseudoVLSEG6E8FF_V_MF4_MASK, VLSEG6E8FF_V, 0x6, 0x8 }, // 4250 + { PseudoVLSEG6E8FF_V_MF2, VLSEG6E8FF_V, 0x7, 0x8 }, // 4251 + { PseudoVLSEG6E8FF_V_MF2_MASK, VLSEG6E8FF_V, 0x7, 0x8 }, // 4252 + { PseudoVLSEG6E8_V_M1, VLSEG6E8_V, 0x0, 0x8 }, // 4253 + { PseudoVLSEG6E8_V_M1_MASK, VLSEG6E8_V, 0x0, 0x8 }, // 4254 + { PseudoVLSEG6E8_V_MF8, VLSEG6E8_V, 0x5, 0x8 }, // 4255 + { PseudoVLSEG6E8_V_MF8_MASK, VLSEG6E8_V, 0x5, 0x8 }, // 4256 + { PseudoVLSEG6E8_V_MF4, VLSEG6E8_V, 0x6, 0x8 }, // 4257 + { PseudoVLSEG6E8_V_MF4_MASK, VLSEG6E8_V, 0x6, 0x8 }, // 4258 + { PseudoVLSEG6E8_V_MF2, VLSEG6E8_V, 0x7, 0x8 }, // 4259 + { PseudoVLSEG6E8_V_MF2_MASK, VLSEG6E8_V, 0x7, 0x8 }, // 4260 + { PseudoVLSEG7E16FF_V_M1, VLSEG7E16FF_V, 0x0, 0x10 }, // 4261 + { PseudoVLSEG7E16FF_V_M1_MASK, VLSEG7E16FF_V, 0x0, 0x10 }, // 4262 + { PseudoVLSEG7E16FF_V_MF4, VLSEG7E16FF_V, 0x6, 0x10 }, // 4263 + { PseudoVLSEG7E16FF_V_MF4_MASK, VLSEG7E16FF_V, 0x6, 0x10 }, // 4264 + { PseudoVLSEG7E16FF_V_MF2, VLSEG7E16FF_V, 0x7, 0x10 }, // 4265 + { PseudoVLSEG7E16FF_V_MF2_MASK, VLSEG7E16FF_V, 0x7, 0x10 }, // 4266 + { PseudoVLSEG7E16_V_M1, VLSEG7E16_V, 0x0, 0x10 }, // 4267 + { PseudoVLSEG7E16_V_M1_MASK, VLSEG7E16_V, 0x0, 0x10 }, // 4268 + { PseudoVLSEG7E16_V_MF4, VLSEG7E16_V, 0x6, 0x10 }, // 4269 + { PseudoVLSEG7E16_V_MF4_MASK, VLSEG7E16_V, 0x6, 0x10 }, // 4270 + { PseudoVLSEG7E16_V_MF2, VLSEG7E16_V, 0x7, 0x10 }, // 4271 + { PseudoVLSEG7E16_V_MF2_MASK, VLSEG7E16_V, 0x7, 0x10 }, // 4272 + { PseudoVLSEG7E32FF_V_M1, VLSEG7E32FF_V, 0x0, 0x20 }, // 4273 + { PseudoVLSEG7E32FF_V_M1_MASK, VLSEG7E32FF_V, 0x0, 0x20 }, // 4274 + { PseudoVLSEG7E32FF_V_MF2, VLSEG7E32FF_V, 0x7, 0x20 }, // 4275 + { PseudoVLSEG7E32FF_V_MF2_MASK, VLSEG7E32FF_V, 0x7, 0x20 }, // 4276 + { PseudoVLSEG7E32_V_M1, VLSEG7E32_V, 0x0, 0x20 }, // 4277 + { PseudoVLSEG7E32_V_M1_MASK, VLSEG7E32_V, 0x0, 0x20 }, // 4278 + { PseudoVLSEG7E32_V_MF2, VLSEG7E32_V, 0x7, 0x20 }, // 4279 + { PseudoVLSEG7E32_V_MF2_MASK, VLSEG7E32_V, 0x7, 0x20 }, // 4280 + { PseudoVLSEG7E64FF_V_M1, VLSEG7E64FF_V, 0x0, 0x40 }, // 4281 + { PseudoVLSEG7E64FF_V_M1_MASK, VLSEG7E64FF_V, 0x0, 0x40 }, // 4282 + { PseudoVLSEG7E64_V_M1, VLSEG7E64_V, 0x0, 0x40 }, // 4283 + { PseudoVLSEG7E64_V_M1_MASK, VLSEG7E64_V, 0x0, 0x40 }, // 4284 + { PseudoVLSEG7E8FF_V_M1, VLSEG7E8FF_V, 0x0, 0x8 }, // 4285 + { PseudoVLSEG7E8FF_V_M1_MASK, VLSEG7E8FF_V, 0x0, 0x8 }, // 4286 + { PseudoVLSEG7E8FF_V_MF8, VLSEG7E8FF_V, 0x5, 0x8 }, // 4287 + { PseudoVLSEG7E8FF_V_MF8_MASK, VLSEG7E8FF_V, 0x5, 0x8 }, // 4288 + { PseudoVLSEG7E8FF_V_MF4, VLSEG7E8FF_V, 0x6, 0x8 }, // 4289 + { PseudoVLSEG7E8FF_V_MF4_MASK, VLSEG7E8FF_V, 0x6, 0x8 }, // 4290 + { PseudoVLSEG7E8FF_V_MF2, VLSEG7E8FF_V, 0x7, 0x8 }, // 4291 + { PseudoVLSEG7E8FF_V_MF2_MASK, VLSEG7E8FF_V, 0x7, 0x8 }, // 4292 + { PseudoVLSEG7E8_V_M1, VLSEG7E8_V, 0x0, 0x8 }, // 4293 + { PseudoVLSEG7E8_V_M1_MASK, VLSEG7E8_V, 0x0, 0x8 }, // 4294 + { PseudoVLSEG7E8_V_MF8, VLSEG7E8_V, 0x5, 0x8 }, // 4295 + { PseudoVLSEG7E8_V_MF8_MASK, VLSEG7E8_V, 0x5, 0x8 }, // 4296 + { PseudoVLSEG7E8_V_MF4, VLSEG7E8_V, 0x6, 0x8 }, // 4297 + { PseudoVLSEG7E8_V_MF4_MASK, VLSEG7E8_V, 0x6, 0x8 }, // 4298 + { PseudoVLSEG7E8_V_MF2, VLSEG7E8_V, 0x7, 0x8 }, // 4299 + { PseudoVLSEG7E8_V_MF2_MASK, VLSEG7E8_V, 0x7, 0x8 }, // 4300 + { PseudoVLSEG8E16FF_V_M1, VLSEG8E16FF_V, 0x0, 0x10 }, // 4301 + { PseudoVLSEG8E16FF_V_M1_MASK, VLSEG8E16FF_V, 0x0, 0x10 }, // 4302 + { PseudoVLSEG8E16FF_V_MF4, VLSEG8E16FF_V, 0x6, 0x10 }, // 4303 + { PseudoVLSEG8E16FF_V_MF4_MASK, VLSEG8E16FF_V, 0x6, 0x10 }, // 4304 + { PseudoVLSEG8E16FF_V_MF2, VLSEG8E16FF_V, 0x7, 0x10 }, // 4305 + { PseudoVLSEG8E16FF_V_MF2_MASK, VLSEG8E16FF_V, 0x7, 0x10 }, // 4306 + { PseudoVLSEG8E16_V_M1, VLSEG8E16_V, 0x0, 0x10 }, // 4307 + { PseudoVLSEG8E16_V_M1_MASK, VLSEG8E16_V, 0x0, 0x10 }, // 4308 + { PseudoVLSEG8E16_V_MF4, VLSEG8E16_V, 0x6, 0x10 }, // 4309 + { PseudoVLSEG8E16_V_MF4_MASK, VLSEG8E16_V, 0x6, 0x10 }, // 4310 + { PseudoVLSEG8E16_V_MF2, VLSEG8E16_V, 0x7, 0x10 }, // 4311 + { PseudoVLSEG8E16_V_MF2_MASK, VLSEG8E16_V, 0x7, 0x10 }, // 4312 + { PseudoVLSEG8E32FF_V_M1, VLSEG8E32FF_V, 0x0, 0x20 }, // 4313 + { PseudoVLSEG8E32FF_V_M1_MASK, VLSEG8E32FF_V, 0x0, 0x20 }, // 4314 + { PseudoVLSEG8E32FF_V_MF2, VLSEG8E32FF_V, 0x7, 0x20 }, // 4315 + { PseudoVLSEG8E32FF_V_MF2_MASK, VLSEG8E32FF_V, 0x7, 0x20 }, // 4316 + { PseudoVLSEG8E32_V_M1, VLSEG8E32_V, 0x0, 0x20 }, // 4317 + { PseudoVLSEG8E32_V_M1_MASK, VLSEG8E32_V, 0x0, 0x20 }, // 4318 + { PseudoVLSEG8E32_V_MF2, VLSEG8E32_V, 0x7, 0x20 }, // 4319 + { PseudoVLSEG8E32_V_MF2_MASK, VLSEG8E32_V, 0x7, 0x20 }, // 4320 + { PseudoVLSEG8E64FF_V_M1, VLSEG8E64FF_V, 0x0, 0x40 }, // 4321 + { PseudoVLSEG8E64FF_V_M1_MASK, VLSEG8E64FF_V, 0x0, 0x40 }, // 4322 + { PseudoVLSEG8E64_V_M1, VLSEG8E64_V, 0x0, 0x40 }, // 4323 + { PseudoVLSEG8E64_V_M1_MASK, VLSEG8E64_V, 0x0, 0x40 }, // 4324 + { PseudoVLSEG8E8FF_V_M1, VLSEG8E8FF_V, 0x0, 0x8 }, // 4325 + { PseudoVLSEG8E8FF_V_M1_MASK, VLSEG8E8FF_V, 0x0, 0x8 }, // 4326 + { PseudoVLSEG8E8FF_V_MF8, VLSEG8E8FF_V, 0x5, 0x8 }, // 4327 + { PseudoVLSEG8E8FF_V_MF8_MASK, VLSEG8E8FF_V, 0x5, 0x8 }, // 4328 + { PseudoVLSEG8E8FF_V_MF4, VLSEG8E8FF_V, 0x6, 0x8 }, // 4329 + { PseudoVLSEG8E8FF_V_MF4_MASK, VLSEG8E8FF_V, 0x6, 0x8 }, // 4330 + { PseudoVLSEG8E8FF_V_MF2, VLSEG8E8FF_V, 0x7, 0x8 }, // 4331 + { PseudoVLSEG8E8FF_V_MF2_MASK, VLSEG8E8FF_V, 0x7, 0x8 }, // 4332 + { PseudoVLSEG8E8_V_M1, VLSEG8E8_V, 0x0, 0x8 }, // 4333 + { PseudoVLSEG8E8_V_M1_MASK, VLSEG8E8_V, 0x0, 0x8 }, // 4334 + { PseudoVLSEG8E8_V_MF8, VLSEG8E8_V, 0x5, 0x8 }, // 4335 + { PseudoVLSEG8E8_V_MF8_MASK, VLSEG8E8_V, 0x5, 0x8 }, // 4336 + { PseudoVLSEG8E8_V_MF4, VLSEG8E8_V, 0x6, 0x8 }, // 4337 + { PseudoVLSEG8E8_V_MF4_MASK, VLSEG8E8_V, 0x6, 0x8 }, // 4338 + { PseudoVLSEG8E8_V_MF2, VLSEG8E8_V, 0x7, 0x8 }, // 4339 + { PseudoVLSEG8E8_V_MF2_MASK, VLSEG8E8_V, 0x7, 0x8 }, // 4340 + { PseudoVLSSEG2E16_V_M1, VLSSEG2E16_V, 0x0, 0x10 }, // 4341 + { PseudoVLSSEG2E16_V_M1_MASK, VLSSEG2E16_V, 0x0, 0x10 }, // 4342 + { PseudoVLSSEG2E16_V_M2, VLSSEG2E16_V, 0x1, 0x10 }, // 4343 + { PseudoVLSSEG2E16_V_M2_MASK, VLSSEG2E16_V, 0x1, 0x10 }, // 4344 + { PseudoVLSSEG2E16_V_M4, VLSSEG2E16_V, 0x2, 0x10 }, // 4345 + { PseudoVLSSEG2E16_V_M4_MASK, VLSSEG2E16_V, 0x2, 0x10 }, // 4346 + { PseudoVLSSEG2E16_V_MF4, VLSSEG2E16_V, 0x6, 0x10 }, // 4347 + { PseudoVLSSEG2E16_V_MF4_MASK, VLSSEG2E16_V, 0x6, 0x10 }, // 4348 + { PseudoVLSSEG2E16_V_MF2, VLSSEG2E16_V, 0x7, 0x10 }, // 4349 + { PseudoVLSSEG2E16_V_MF2_MASK, VLSSEG2E16_V, 0x7, 0x10 }, // 4350 + { PseudoVLSSEG2E32_V_M1, VLSSEG2E32_V, 0x0, 0x20 }, // 4351 + { PseudoVLSSEG2E32_V_M1_MASK, VLSSEG2E32_V, 0x0, 0x20 }, // 4352 + { PseudoVLSSEG2E32_V_M2, VLSSEG2E32_V, 0x1, 0x20 }, // 4353 + { PseudoVLSSEG2E32_V_M2_MASK, VLSSEG2E32_V, 0x1, 0x20 }, // 4354 + { PseudoVLSSEG2E32_V_M4, VLSSEG2E32_V, 0x2, 0x20 }, // 4355 + { PseudoVLSSEG2E32_V_M4_MASK, VLSSEG2E32_V, 0x2, 0x20 }, // 4356 + { PseudoVLSSEG2E32_V_MF2, VLSSEG2E32_V, 0x7, 0x20 }, // 4357 + { PseudoVLSSEG2E32_V_MF2_MASK, VLSSEG2E32_V, 0x7, 0x20 }, // 4358 + { PseudoVLSSEG2E64_V_M1, VLSSEG2E64_V, 0x0, 0x40 }, // 4359 + { PseudoVLSSEG2E64_V_M1_MASK, VLSSEG2E64_V, 0x0, 0x40 }, // 4360 + { PseudoVLSSEG2E64_V_M2, VLSSEG2E64_V, 0x1, 0x40 }, // 4361 + { PseudoVLSSEG2E64_V_M2_MASK, VLSSEG2E64_V, 0x1, 0x40 }, // 4362 + { PseudoVLSSEG2E64_V_M4, VLSSEG2E64_V, 0x2, 0x40 }, // 4363 + { PseudoVLSSEG2E64_V_M4_MASK, VLSSEG2E64_V, 0x2, 0x40 }, // 4364 + { PseudoVLSSEG2E8_V_M1, VLSSEG2E8_V, 0x0, 0x8 }, // 4365 + { PseudoVLSSEG2E8_V_M1_MASK, VLSSEG2E8_V, 0x0, 0x8 }, // 4366 + { PseudoVLSSEG2E8_V_M2, VLSSEG2E8_V, 0x1, 0x8 }, // 4367 + { PseudoVLSSEG2E8_V_M2_MASK, VLSSEG2E8_V, 0x1, 0x8 }, // 4368 + { PseudoVLSSEG2E8_V_M4, VLSSEG2E8_V, 0x2, 0x8 }, // 4369 + { PseudoVLSSEG2E8_V_M4_MASK, VLSSEG2E8_V, 0x2, 0x8 }, // 4370 + { PseudoVLSSEG2E8_V_MF8, VLSSEG2E8_V, 0x5, 0x8 }, // 4371 + { PseudoVLSSEG2E8_V_MF8_MASK, VLSSEG2E8_V, 0x5, 0x8 }, // 4372 + { PseudoVLSSEG2E8_V_MF4, VLSSEG2E8_V, 0x6, 0x8 }, // 4373 + { PseudoVLSSEG2E8_V_MF4_MASK, VLSSEG2E8_V, 0x6, 0x8 }, // 4374 + { PseudoVLSSEG2E8_V_MF2, VLSSEG2E8_V, 0x7, 0x8 }, // 4375 + { PseudoVLSSEG2E8_V_MF2_MASK, VLSSEG2E8_V, 0x7, 0x8 }, // 4376 + { PseudoVLSSEG3E16_V_M1, VLSSEG3E16_V, 0x0, 0x10 }, // 4377 + { PseudoVLSSEG3E16_V_M1_MASK, VLSSEG3E16_V, 0x0, 0x10 }, // 4378 + { PseudoVLSSEG3E16_V_M2, VLSSEG3E16_V, 0x1, 0x10 }, // 4379 + { PseudoVLSSEG3E16_V_M2_MASK, VLSSEG3E16_V, 0x1, 0x10 }, // 4380 + { PseudoVLSSEG3E16_V_MF4, VLSSEG3E16_V, 0x6, 0x10 }, // 4381 + { PseudoVLSSEG3E16_V_MF4_MASK, VLSSEG3E16_V, 0x6, 0x10 }, // 4382 + { PseudoVLSSEG3E16_V_MF2, VLSSEG3E16_V, 0x7, 0x10 }, // 4383 + { PseudoVLSSEG3E16_V_MF2_MASK, VLSSEG3E16_V, 0x7, 0x10 }, // 4384 + { PseudoVLSSEG3E32_V_M1, VLSSEG3E32_V, 0x0, 0x20 }, // 4385 + { PseudoVLSSEG3E32_V_M1_MASK, VLSSEG3E32_V, 0x0, 0x20 }, // 4386 + { PseudoVLSSEG3E32_V_M2, VLSSEG3E32_V, 0x1, 0x20 }, // 4387 + { PseudoVLSSEG3E32_V_M2_MASK, VLSSEG3E32_V, 0x1, 0x20 }, // 4388 + { PseudoVLSSEG3E32_V_MF2, VLSSEG3E32_V, 0x7, 0x20 }, // 4389 + { PseudoVLSSEG3E32_V_MF2_MASK, VLSSEG3E32_V, 0x7, 0x20 }, // 4390 + { PseudoVLSSEG3E64_V_M1, VLSSEG3E64_V, 0x0, 0x40 }, // 4391 + { PseudoVLSSEG3E64_V_M1_MASK, VLSSEG3E64_V, 0x0, 0x40 }, // 4392 + { PseudoVLSSEG3E64_V_M2, VLSSEG3E64_V, 0x1, 0x40 }, // 4393 + { PseudoVLSSEG3E64_V_M2_MASK, VLSSEG3E64_V, 0x1, 0x40 }, // 4394 + { PseudoVLSSEG3E8_V_M1, VLSSEG3E8_V, 0x0, 0x8 }, // 4395 + { PseudoVLSSEG3E8_V_M1_MASK, VLSSEG3E8_V, 0x0, 0x8 }, // 4396 + { PseudoVLSSEG3E8_V_M2, VLSSEG3E8_V, 0x1, 0x8 }, // 4397 + { PseudoVLSSEG3E8_V_M2_MASK, VLSSEG3E8_V, 0x1, 0x8 }, // 4398 + { PseudoVLSSEG3E8_V_MF8, VLSSEG3E8_V, 0x5, 0x8 }, // 4399 + { PseudoVLSSEG3E8_V_MF8_MASK, VLSSEG3E8_V, 0x5, 0x8 }, // 4400 + { PseudoVLSSEG3E8_V_MF4, VLSSEG3E8_V, 0x6, 0x8 }, // 4401 + { PseudoVLSSEG3E8_V_MF4_MASK, VLSSEG3E8_V, 0x6, 0x8 }, // 4402 + { PseudoVLSSEG3E8_V_MF2, VLSSEG3E8_V, 0x7, 0x8 }, // 4403 + { PseudoVLSSEG3E8_V_MF2_MASK, VLSSEG3E8_V, 0x7, 0x8 }, // 4404 + { PseudoVLSSEG4E16_V_M1, VLSSEG4E16_V, 0x0, 0x10 }, // 4405 + { PseudoVLSSEG4E16_V_M1_MASK, VLSSEG4E16_V, 0x0, 0x10 }, // 4406 + { PseudoVLSSEG4E16_V_M2, VLSSEG4E16_V, 0x1, 0x10 }, // 4407 + { PseudoVLSSEG4E16_V_M2_MASK, VLSSEG4E16_V, 0x1, 0x10 }, // 4408 + { PseudoVLSSEG4E16_V_MF4, VLSSEG4E16_V, 0x6, 0x10 }, // 4409 + { PseudoVLSSEG4E16_V_MF4_MASK, VLSSEG4E16_V, 0x6, 0x10 }, // 4410 + { PseudoVLSSEG4E16_V_MF2, VLSSEG4E16_V, 0x7, 0x10 }, // 4411 + { PseudoVLSSEG4E16_V_MF2_MASK, VLSSEG4E16_V, 0x7, 0x10 }, // 4412 + { PseudoVLSSEG4E32_V_M1, VLSSEG4E32_V, 0x0, 0x20 }, // 4413 + { PseudoVLSSEG4E32_V_M1_MASK, VLSSEG4E32_V, 0x0, 0x20 }, // 4414 + { PseudoVLSSEG4E32_V_M2, VLSSEG4E32_V, 0x1, 0x20 }, // 4415 + { PseudoVLSSEG4E32_V_M2_MASK, VLSSEG4E32_V, 0x1, 0x20 }, // 4416 + { PseudoVLSSEG4E32_V_MF2, VLSSEG4E32_V, 0x7, 0x20 }, // 4417 + { PseudoVLSSEG4E32_V_MF2_MASK, VLSSEG4E32_V, 0x7, 0x20 }, // 4418 + { PseudoVLSSEG4E64_V_M1, VLSSEG4E64_V, 0x0, 0x40 }, // 4419 + { PseudoVLSSEG4E64_V_M1_MASK, VLSSEG4E64_V, 0x0, 0x40 }, // 4420 + { PseudoVLSSEG4E64_V_M2, VLSSEG4E64_V, 0x1, 0x40 }, // 4421 + { PseudoVLSSEG4E64_V_M2_MASK, VLSSEG4E64_V, 0x1, 0x40 }, // 4422 + { PseudoVLSSEG4E8_V_M1, VLSSEG4E8_V, 0x0, 0x8 }, // 4423 + { PseudoVLSSEG4E8_V_M1_MASK, VLSSEG4E8_V, 0x0, 0x8 }, // 4424 + { PseudoVLSSEG4E8_V_M2, VLSSEG4E8_V, 0x1, 0x8 }, // 4425 + { PseudoVLSSEG4E8_V_M2_MASK, VLSSEG4E8_V, 0x1, 0x8 }, // 4426 + { PseudoVLSSEG4E8_V_MF8, VLSSEG4E8_V, 0x5, 0x8 }, // 4427 + { PseudoVLSSEG4E8_V_MF8_MASK, VLSSEG4E8_V, 0x5, 0x8 }, // 4428 + { PseudoVLSSEG4E8_V_MF4, VLSSEG4E8_V, 0x6, 0x8 }, // 4429 + { PseudoVLSSEG4E8_V_MF4_MASK, VLSSEG4E8_V, 0x6, 0x8 }, // 4430 + { PseudoVLSSEG4E8_V_MF2, VLSSEG4E8_V, 0x7, 0x8 }, // 4431 + { PseudoVLSSEG4E8_V_MF2_MASK, VLSSEG4E8_V, 0x7, 0x8 }, // 4432 + { PseudoVLSSEG5E16_V_M1, VLSSEG5E16_V, 0x0, 0x10 }, // 4433 + { PseudoVLSSEG5E16_V_M1_MASK, VLSSEG5E16_V, 0x0, 0x10 }, // 4434 + { PseudoVLSSEG5E16_V_MF4, VLSSEG5E16_V, 0x6, 0x10 }, // 4435 + { PseudoVLSSEG5E16_V_MF4_MASK, VLSSEG5E16_V, 0x6, 0x10 }, // 4436 + { PseudoVLSSEG5E16_V_MF2, VLSSEG5E16_V, 0x7, 0x10 }, // 4437 + { PseudoVLSSEG5E16_V_MF2_MASK, VLSSEG5E16_V, 0x7, 0x10 }, // 4438 + { PseudoVLSSEG5E32_V_M1, VLSSEG5E32_V, 0x0, 0x20 }, // 4439 + { PseudoVLSSEG5E32_V_M1_MASK, VLSSEG5E32_V, 0x0, 0x20 }, // 4440 + { PseudoVLSSEG5E32_V_MF2, VLSSEG5E32_V, 0x7, 0x20 }, // 4441 + { PseudoVLSSEG5E32_V_MF2_MASK, VLSSEG5E32_V, 0x7, 0x20 }, // 4442 + { PseudoVLSSEG5E64_V_M1, VLSSEG5E64_V, 0x0, 0x40 }, // 4443 + { PseudoVLSSEG5E64_V_M1_MASK, VLSSEG5E64_V, 0x0, 0x40 }, // 4444 + { PseudoVLSSEG5E8_V_M1, VLSSEG5E8_V, 0x0, 0x8 }, // 4445 + { PseudoVLSSEG5E8_V_M1_MASK, VLSSEG5E8_V, 0x0, 0x8 }, // 4446 + { PseudoVLSSEG5E8_V_MF8, VLSSEG5E8_V, 0x5, 0x8 }, // 4447 + { PseudoVLSSEG5E8_V_MF8_MASK, VLSSEG5E8_V, 0x5, 0x8 }, // 4448 + { PseudoVLSSEG5E8_V_MF4, VLSSEG5E8_V, 0x6, 0x8 }, // 4449 + { PseudoVLSSEG5E8_V_MF4_MASK, VLSSEG5E8_V, 0x6, 0x8 }, // 4450 + { PseudoVLSSEG5E8_V_MF2, VLSSEG5E8_V, 0x7, 0x8 }, // 4451 + { PseudoVLSSEG5E8_V_MF2_MASK, VLSSEG5E8_V, 0x7, 0x8 }, // 4452 + { PseudoVLSSEG6E16_V_M1, VLSSEG6E16_V, 0x0, 0x10 }, // 4453 + { PseudoVLSSEG6E16_V_M1_MASK, VLSSEG6E16_V, 0x0, 0x10 }, // 4454 + { PseudoVLSSEG6E16_V_MF4, VLSSEG6E16_V, 0x6, 0x10 }, // 4455 + { PseudoVLSSEG6E16_V_MF4_MASK, VLSSEG6E16_V, 0x6, 0x10 }, // 4456 + { PseudoVLSSEG6E16_V_MF2, VLSSEG6E16_V, 0x7, 0x10 }, // 4457 + { PseudoVLSSEG6E16_V_MF2_MASK, VLSSEG6E16_V, 0x7, 0x10 }, // 4458 + { PseudoVLSSEG6E32_V_M1, VLSSEG6E32_V, 0x0, 0x20 }, // 4459 + { PseudoVLSSEG6E32_V_M1_MASK, VLSSEG6E32_V, 0x0, 0x20 }, // 4460 + { PseudoVLSSEG6E32_V_MF2, VLSSEG6E32_V, 0x7, 0x20 }, // 4461 + { PseudoVLSSEG6E32_V_MF2_MASK, VLSSEG6E32_V, 0x7, 0x20 }, // 4462 + { PseudoVLSSEG6E64_V_M1, VLSSEG6E64_V, 0x0, 0x40 }, // 4463 + { PseudoVLSSEG6E64_V_M1_MASK, VLSSEG6E64_V, 0x0, 0x40 }, // 4464 + { PseudoVLSSEG6E8_V_M1, VLSSEG6E8_V, 0x0, 0x8 }, // 4465 + { PseudoVLSSEG6E8_V_M1_MASK, VLSSEG6E8_V, 0x0, 0x8 }, // 4466 + { PseudoVLSSEG6E8_V_MF8, VLSSEG6E8_V, 0x5, 0x8 }, // 4467 + { PseudoVLSSEG6E8_V_MF8_MASK, VLSSEG6E8_V, 0x5, 0x8 }, // 4468 + { PseudoVLSSEG6E8_V_MF4, VLSSEG6E8_V, 0x6, 0x8 }, // 4469 + { PseudoVLSSEG6E8_V_MF4_MASK, VLSSEG6E8_V, 0x6, 0x8 }, // 4470 + { PseudoVLSSEG6E8_V_MF2, VLSSEG6E8_V, 0x7, 0x8 }, // 4471 + { PseudoVLSSEG6E8_V_MF2_MASK, VLSSEG6E8_V, 0x7, 0x8 }, // 4472 + { PseudoVLSSEG7E16_V_M1, VLSSEG7E16_V, 0x0, 0x10 }, // 4473 + { PseudoVLSSEG7E16_V_M1_MASK, VLSSEG7E16_V, 0x0, 0x10 }, // 4474 + { PseudoVLSSEG7E16_V_MF4, VLSSEG7E16_V, 0x6, 0x10 }, // 4475 + { PseudoVLSSEG7E16_V_MF4_MASK, VLSSEG7E16_V, 0x6, 0x10 }, // 4476 + { PseudoVLSSEG7E16_V_MF2, VLSSEG7E16_V, 0x7, 0x10 }, // 4477 + { PseudoVLSSEG7E16_V_MF2_MASK, VLSSEG7E16_V, 0x7, 0x10 }, // 4478 + { PseudoVLSSEG7E32_V_M1, VLSSEG7E32_V, 0x0, 0x20 }, // 4479 + { PseudoVLSSEG7E32_V_M1_MASK, VLSSEG7E32_V, 0x0, 0x20 }, // 4480 + { PseudoVLSSEG7E32_V_MF2, VLSSEG7E32_V, 0x7, 0x20 }, // 4481 + { PseudoVLSSEG7E32_V_MF2_MASK, VLSSEG7E32_V, 0x7, 0x20 }, // 4482 + { PseudoVLSSEG7E64_V_M1, VLSSEG7E64_V, 0x0, 0x40 }, // 4483 + { PseudoVLSSEG7E64_V_M1_MASK, VLSSEG7E64_V, 0x0, 0x40 }, // 4484 + { PseudoVLSSEG7E8_V_M1, VLSSEG7E8_V, 0x0, 0x8 }, // 4485 + { PseudoVLSSEG7E8_V_M1_MASK, VLSSEG7E8_V, 0x0, 0x8 }, // 4486 + { PseudoVLSSEG7E8_V_MF8, VLSSEG7E8_V, 0x5, 0x8 }, // 4487 + { PseudoVLSSEG7E8_V_MF8_MASK, VLSSEG7E8_V, 0x5, 0x8 }, // 4488 + { PseudoVLSSEG7E8_V_MF4, VLSSEG7E8_V, 0x6, 0x8 }, // 4489 + { PseudoVLSSEG7E8_V_MF4_MASK, VLSSEG7E8_V, 0x6, 0x8 }, // 4490 + { PseudoVLSSEG7E8_V_MF2, VLSSEG7E8_V, 0x7, 0x8 }, // 4491 + { PseudoVLSSEG7E8_V_MF2_MASK, VLSSEG7E8_V, 0x7, 0x8 }, // 4492 + { PseudoVLSSEG8E16_V_M1, VLSSEG8E16_V, 0x0, 0x10 }, // 4493 + { PseudoVLSSEG8E16_V_M1_MASK, VLSSEG8E16_V, 0x0, 0x10 }, // 4494 + { PseudoVLSSEG8E16_V_MF4, VLSSEG8E16_V, 0x6, 0x10 }, // 4495 + { PseudoVLSSEG8E16_V_MF4_MASK, VLSSEG8E16_V, 0x6, 0x10 }, // 4496 + { PseudoVLSSEG8E16_V_MF2, VLSSEG8E16_V, 0x7, 0x10 }, // 4497 + { PseudoVLSSEG8E16_V_MF2_MASK, VLSSEG8E16_V, 0x7, 0x10 }, // 4498 + { PseudoVLSSEG8E32_V_M1, VLSSEG8E32_V, 0x0, 0x20 }, // 4499 + { PseudoVLSSEG8E32_V_M1_MASK, VLSSEG8E32_V, 0x0, 0x20 }, // 4500 + { PseudoVLSSEG8E32_V_MF2, VLSSEG8E32_V, 0x7, 0x20 }, // 4501 + { PseudoVLSSEG8E32_V_MF2_MASK, VLSSEG8E32_V, 0x7, 0x20 }, // 4502 + { PseudoVLSSEG8E64_V_M1, VLSSEG8E64_V, 0x0, 0x40 }, // 4503 + { PseudoVLSSEG8E64_V_M1_MASK, VLSSEG8E64_V, 0x0, 0x40 }, // 4504 + { PseudoVLSSEG8E8_V_M1, VLSSEG8E8_V, 0x0, 0x8 }, // 4505 + { PseudoVLSSEG8E8_V_M1_MASK, VLSSEG8E8_V, 0x0, 0x8 }, // 4506 + { PseudoVLSSEG8E8_V_MF8, VLSSEG8E8_V, 0x5, 0x8 }, // 4507 + { PseudoVLSSEG8E8_V_MF8_MASK, VLSSEG8E8_V, 0x5, 0x8 }, // 4508 + { PseudoVLSSEG8E8_V_MF4, VLSSEG8E8_V, 0x6, 0x8 }, // 4509 + { PseudoVLSSEG8E8_V_MF4_MASK, VLSSEG8E8_V, 0x6, 0x8 }, // 4510 + { PseudoVLSSEG8E8_V_MF2, VLSSEG8E8_V, 0x7, 0x8 }, // 4511 + { PseudoVLSSEG8E8_V_MF2_MASK, VLSSEG8E8_V, 0x7, 0x8 }, // 4512 + { PseudoVLUXEI16_V_M1_M1, VLUXEI16_V, 0x0, 0x0 }, // 4513 + { PseudoVLUXEI16_V_M1_M1_MASK, VLUXEI16_V, 0x0, 0x0 }, // 4514 + { PseudoVLUXEI16_V_M2_M1, VLUXEI16_V, 0x0, 0x0 }, // 4515 + { PseudoVLUXEI16_V_M2_M1_MASK, VLUXEI16_V, 0x0, 0x0 }, // 4516 + { PseudoVLUXEI16_V_MF2_M1, VLUXEI16_V, 0x0, 0x0 }, // 4517 + { PseudoVLUXEI16_V_MF2_M1_MASK, VLUXEI16_V, 0x0, 0x0 }, // 4518 + { PseudoVLUXEI16_V_MF4_M1, VLUXEI16_V, 0x0, 0x0 }, // 4519 + { PseudoVLUXEI16_V_MF4_M1_MASK, VLUXEI16_V, 0x0, 0x0 }, // 4520 + { PseudoVLUXEI16_V_M1_M2, VLUXEI16_V, 0x1, 0x0 }, // 4521 + { PseudoVLUXEI16_V_M1_M2_MASK, VLUXEI16_V, 0x1, 0x0 }, // 4522 + { PseudoVLUXEI16_V_M2_M2, VLUXEI16_V, 0x1, 0x0 }, // 4523 + { PseudoVLUXEI16_V_M2_M2_MASK, VLUXEI16_V, 0x1, 0x0 }, // 4524 + { PseudoVLUXEI16_V_M4_M2, VLUXEI16_V, 0x1, 0x0 }, // 4525 + { PseudoVLUXEI16_V_M4_M2_MASK, VLUXEI16_V, 0x1, 0x0 }, // 4526 + { PseudoVLUXEI16_V_MF2_M2, VLUXEI16_V, 0x1, 0x0 }, // 4527 + { PseudoVLUXEI16_V_MF2_M2_MASK, VLUXEI16_V, 0x1, 0x0 }, // 4528 + { PseudoVLUXEI16_V_M1_M4, VLUXEI16_V, 0x2, 0x0 }, // 4529 + { PseudoVLUXEI16_V_M1_M4_MASK, VLUXEI16_V, 0x2, 0x0 }, // 4530 + { PseudoVLUXEI16_V_M2_M4, VLUXEI16_V, 0x2, 0x0 }, // 4531 + { PseudoVLUXEI16_V_M2_M4_MASK, VLUXEI16_V, 0x2, 0x0 }, // 4532 + { PseudoVLUXEI16_V_M4_M4, VLUXEI16_V, 0x2, 0x0 }, // 4533 + { PseudoVLUXEI16_V_M4_M4_MASK, VLUXEI16_V, 0x2, 0x0 }, // 4534 + { PseudoVLUXEI16_V_M8_M4, VLUXEI16_V, 0x2, 0x0 }, // 4535 + { PseudoVLUXEI16_V_M8_M4_MASK, VLUXEI16_V, 0x2, 0x0 }, // 4536 + { PseudoVLUXEI16_V_M2_M8, VLUXEI16_V, 0x3, 0x0 }, // 4537 + { PseudoVLUXEI16_V_M2_M8_MASK, VLUXEI16_V, 0x3, 0x0 }, // 4538 + { PseudoVLUXEI16_V_M4_M8, VLUXEI16_V, 0x3, 0x0 }, // 4539 + { PseudoVLUXEI16_V_M4_M8_MASK, VLUXEI16_V, 0x3, 0x0 }, // 4540 + { PseudoVLUXEI16_V_M8_M8, VLUXEI16_V, 0x3, 0x0 }, // 4541 + { PseudoVLUXEI16_V_M8_M8_MASK, VLUXEI16_V, 0x3, 0x0 }, // 4542 + { PseudoVLUXEI16_V_MF4_MF8, VLUXEI16_V, 0x5, 0x0 }, // 4543 + { PseudoVLUXEI16_V_MF4_MF8_MASK, VLUXEI16_V, 0x5, 0x0 }, // 4544 + { PseudoVLUXEI16_V_MF2_MF4, VLUXEI16_V, 0x6, 0x0 }, // 4545 + { PseudoVLUXEI16_V_MF2_MF4_MASK, VLUXEI16_V, 0x6, 0x0 }, // 4546 + { PseudoVLUXEI16_V_MF4_MF4, VLUXEI16_V, 0x6, 0x0 }, // 4547 + { PseudoVLUXEI16_V_MF4_MF4_MASK, VLUXEI16_V, 0x6, 0x0 }, // 4548 + { PseudoVLUXEI16_V_M1_MF2, VLUXEI16_V, 0x7, 0x0 }, // 4549 + { PseudoVLUXEI16_V_M1_MF2_MASK, VLUXEI16_V, 0x7, 0x0 }, // 4550 + { PseudoVLUXEI16_V_MF2_MF2, VLUXEI16_V, 0x7, 0x0 }, // 4551 + { PseudoVLUXEI16_V_MF2_MF2_MASK, VLUXEI16_V, 0x7, 0x0 }, // 4552 + { PseudoVLUXEI16_V_MF4_MF2, VLUXEI16_V, 0x7, 0x0 }, // 4553 + { PseudoVLUXEI16_V_MF4_MF2_MASK, VLUXEI16_V, 0x7, 0x0 }, // 4554 + { PseudoVLUXEI32_V_M1_M1, VLUXEI32_V, 0x0, 0x0 }, // 4555 + { PseudoVLUXEI32_V_M1_M1_MASK, VLUXEI32_V, 0x0, 0x0 }, // 4556 + { PseudoVLUXEI32_V_M2_M1, VLUXEI32_V, 0x0, 0x0 }, // 4557 + { PseudoVLUXEI32_V_M2_M1_MASK, VLUXEI32_V, 0x0, 0x0 }, // 4558 + { PseudoVLUXEI32_V_M4_M1, VLUXEI32_V, 0x0, 0x0 }, // 4559 + { PseudoVLUXEI32_V_M4_M1_MASK, VLUXEI32_V, 0x0, 0x0 }, // 4560 + { PseudoVLUXEI32_V_MF2_M1, VLUXEI32_V, 0x0, 0x0 }, // 4561 + { PseudoVLUXEI32_V_MF2_M1_MASK, VLUXEI32_V, 0x0, 0x0 }, // 4562 + { PseudoVLUXEI32_V_M1_M2, VLUXEI32_V, 0x1, 0x0 }, // 4563 + { PseudoVLUXEI32_V_M1_M2_MASK, VLUXEI32_V, 0x1, 0x0 }, // 4564 + { PseudoVLUXEI32_V_M2_M2, VLUXEI32_V, 0x1, 0x0 }, // 4565 + { PseudoVLUXEI32_V_M2_M2_MASK, VLUXEI32_V, 0x1, 0x0 }, // 4566 + { PseudoVLUXEI32_V_M4_M2, VLUXEI32_V, 0x1, 0x0 }, // 4567 + { PseudoVLUXEI32_V_M4_M2_MASK, VLUXEI32_V, 0x1, 0x0 }, // 4568 + { PseudoVLUXEI32_V_M8_M2, VLUXEI32_V, 0x1, 0x0 }, // 4569 + { PseudoVLUXEI32_V_M8_M2_MASK, VLUXEI32_V, 0x1, 0x0 }, // 4570 + { PseudoVLUXEI32_V_M2_M4, VLUXEI32_V, 0x2, 0x0 }, // 4571 + { PseudoVLUXEI32_V_M2_M4_MASK, VLUXEI32_V, 0x2, 0x0 }, // 4572 + { PseudoVLUXEI32_V_M4_M4, VLUXEI32_V, 0x2, 0x0 }, // 4573 + { PseudoVLUXEI32_V_M4_M4_MASK, VLUXEI32_V, 0x2, 0x0 }, // 4574 + { PseudoVLUXEI32_V_M8_M4, VLUXEI32_V, 0x2, 0x0 }, // 4575 + { PseudoVLUXEI32_V_M8_M4_MASK, VLUXEI32_V, 0x2, 0x0 }, // 4576 + { PseudoVLUXEI32_V_M4_M8, VLUXEI32_V, 0x3, 0x0 }, // 4577 + { PseudoVLUXEI32_V_M4_M8_MASK, VLUXEI32_V, 0x3, 0x0 }, // 4578 + { PseudoVLUXEI32_V_M8_M8, VLUXEI32_V, 0x3, 0x0 }, // 4579 + { PseudoVLUXEI32_V_M8_M8_MASK, VLUXEI32_V, 0x3, 0x0 }, // 4580 + { PseudoVLUXEI32_V_MF2_MF8, VLUXEI32_V, 0x5, 0x0 }, // 4581 + { PseudoVLUXEI32_V_MF2_MF8_MASK, VLUXEI32_V, 0x5, 0x0 }, // 4582 + { PseudoVLUXEI32_V_M1_MF4, VLUXEI32_V, 0x6, 0x0 }, // 4583 + { PseudoVLUXEI32_V_M1_MF4_MASK, VLUXEI32_V, 0x6, 0x0 }, // 4584 + { PseudoVLUXEI32_V_MF2_MF4, VLUXEI32_V, 0x6, 0x0 }, // 4585 + { PseudoVLUXEI32_V_MF2_MF4_MASK, VLUXEI32_V, 0x6, 0x0 }, // 4586 + { PseudoVLUXEI32_V_M1_MF2, VLUXEI32_V, 0x7, 0x0 }, // 4587 + { PseudoVLUXEI32_V_M1_MF2_MASK, VLUXEI32_V, 0x7, 0x0 }, // 4588 + { PseudoVLUXEI32_V_M2_MF2, VLUXEI32_V, 0x7, 0x0 }, // 4589 + { PseudoVLUXEI32_V_M2_MF2_MASK, VLUXEI32_V, 0x7, 0x0 }, // 4590 + { PseudoVLUXEI32_V_MF2_MF2, VLUXEI32_V, 0x7, 0x0 }, // 4591 + { PseudoVLUXEI32_V_MF2_MF2_MASK, VLUXEI32_V, 0x7, 0x0 }, // 4592 + { PseudoVLUXEI64_V_M1_M1, VLUXEI64_V, 0x0, 0x0 }, // 4593 + { PseudoVLUXEI64_V_M1_M1_MASK, VLUXEI64_V, 0x0, 0x0 }, // 4594 + { PseudoVLUXEI64_V_M2_M1, VLUXEI64_V, 0x0, 0x0 }, // 4595 + { PseudoVLUXEI64_V_M2_M1_MASK, VLUXEI64_V, 0x0, 0x0 }, // 4596 + { PseudoVLUXEI64_V_M4_M1, VLUXEI64_V, 0x0, 0x0 }, // 4597 + { PseudoVLUXEI64_V_M4_M1_MASK, VLUXEI64_V, 0x0, 0x0 }, // 4598 + { PseudoVLUXEI64_V_M8_M1, VLUXEI64_V, 0x0, 0x0 }, // 4599 + { PseudoVLUXEI64_V_M8_M1_MASK, VLUXEI64_V, 0x0, 0x0 }, // 4600 + { PseudoVLUXEI64_V_M2_M2, VLUXEI64_V, 0x1, 0x0 }, // 4601 + { PseudoVLUXEI64_V_M2_M2_MASK, VLUXEI64_V, 0x1, 0x0 }, // 4602 + { PseudoVLUXEI64_V_M4_M2, VLUXEI64_V, 0x1, 0x0 }, // 4603 + { PseudoVLUXEI64_V_M4_M2_MASK, VLUXEI64_V, 0x1, 0x0 }, // 4604 + { PseudoVLUXEI64_V_M8_M2, VLUXEI64_V, 0x1, 0x0 }, // 4605 + { PseudoVLUXEI64_V_M8_M2_MASK, VLUXEI64_V, 0x1, 0x0 }, // 4606 + { PseudoVLUXEI64_V_M4_M4, VLUXEI64_V, 0x2, 0x0 }, // 4607 + { PseudoVLUXEI64_V_M4_M4_MASK, VLUXEI64_V, 0x2, 0x0 }, // 4608 + { PseudoVLUXEI64_V_M8_M4, VLUXEI64_V, 0x2, 0x0 }, // 4609 + { PseudoVLUXEI64_V_M8_M4_MASK, VLUXEI64_V, 0x2, 0x0 }, // 4610 + { PseudoVLUXEI64_V_M8_M8, VLUXEI64_V, 0x3, 0x0 }, // 4611 + { PseudoVLUXEI64_V_M8_M8_MASK, VLUXEI64_V, 0x3, 0x0 }, // 4612 + { PseudoVLUXEI64_V_M1_MF8, VLUXEI64_V, 0x5, 0x0 }, // 4613 + { PseudoVLUXEI64_V_M1_MF8_MASK, VLUXEI64_V, 0x5, 0x0 }, // 4614 + { PseudoVLUXEI64_V_M1_MF4, VLUXEI64_V, 0x6, 0x0 }, // 4615 + { PseudoVLUXEI64_V_M1_MF4_MASK, VLUXEI64_V, 0x6, 0x0 }, // 4616 + { PseudoVLUXEI64_V_M2_MF4, VLUXEI64_V, 0x6, 0x0 }, // 4617 + { PseudoVLUXEI64_V_M2_MF4_MASK, VLUXEI64_V, 0x6, 0x0 }, // 4618 + { PseudoVLUXEI64_V_M1_MF2, VLUXEI64_V, 0x7, 0x0 }, // 4619 + { PseudoVLUXEI64_V_M1_MF2_MASK, VLUXEI64_V, 0x7, 0x0 }, // 4620 + { PseudoVLUXEI64_V_M2_MF2, VLUXEI64_V, 0x7, 0x0 }, // 4621 + { PseudoVLUXEI64_V_M2_MF2_MASK, VLUXEI64_V, 0x7, 0x0 }, // 4622 + { PseudoVLUXEI64_V_M4_MF2, VLUXEI64_V, 0x7, 0x0 }, // 4623 + { PseudoVLUXEI64_V_M4_MF2_MASK, VLUXEI64_V, 0x7, 0x0 }, // 4624 + { PseudoVLUXEI8_V_M1_M1, VLUXEI8_V, 0x0, 0x0 }, // 4625 + { PseudoVLUXEI8_V_M1_M1_MASK, VLUXEI8_V, 0x0, 0x0 }, // 4626 + { PseudoVLUXEI8_V_MF2_M1, VLUXEI8_V, 0x0, 0x0 }, // 4627 + { PseudoVLUXEI8_V_MF2_M1_MASK, VLUXEI8_V, 0x0, 0x0 }, // 4628 + { PseudoVLUXEI8_V_MF4_M1, VLUXEI8_V, 0x0, 0x0 }, // 4629 + { PseudoVLUXEI8_V_MF4_M1_MASK, VLUXEI8_V, 0x0, 0x0 }, // 4630 + { PseudoVLUXEI8_V_MF8_M1, VLUXEI8_V, 0x0, 0x0 }, // 4631 + { PseudoVLUXEI8_V_MF8_M1_MASK, VLUXEI8_V, 0x0, 0x0 }, // 4632 + { PseudoVLUXEI8_V_M1_M2, VLUXEI8_V, 0x1, 0x0 }, // 4633 + { PseudoVLUXEI8_V_M1_M2_MASK, VLUXEI8_V, 0x1, 0x0 }, // 4634 + { PseudoVLUXEI8_V_M2_M2, VLUXEI8_V, 0x1, 0x0 }, // 4635 + { PseudoVLUXEI8_V_M2_M2_MASK, VLUXEI8_V, 0x1, 0x0 }, // 4636 + { PseudoVLUXEI8_V_MF2_M2, VLUXEI8_V, 0x1, 0x0 }, // 4637 + { PseudoVLUXEI8_V_MF2_M2_MASK, VLUXEI8_V, 0x1, 0x0 }, // 4638 + { PseudoVLUXEI8_V_MF4_M2, VLUXEI8_V, 0x1, 0x0 }, // 4639 + { PseudoVLUXEI8_V_MF4_M2_MASK, VLUXEI8_V, 0x1, 0x0 }, // 4640 + { PseudoVLUXEI8_V_M1_M4, VLUXEI8_V, 0x2, 0x0 }, // 4641 + { PseudoVLUXEI8_V_M1_M4_MASK, VLUXEI8_V, 0x2, 0x0 }, // 4642 + { PseudoVLUXEI8_V_M2_M4, VLUXEI8_V, 0x2, 0x0 }, // 4643 + { PseudoVLUXEI8_V_M2_M4_MASK, VLUXEI8_V, 0x2, 0x0 }, // 4644 + { PseudoVLUXEI8_V_M4_M4, VLUXEI8_V, 0x2, 0x0 }, // 4645 + { PseudoVLUXEI8_V_M4_M4_MASK, VLUXEI8_V, 0x2, 0x0 }, // 4646 + { PseudoVLUXEI8_V_MF2_M4, VLUXEI8_V, 0x2, 0x0 }, // 4647 + { PseudoVLUXEI8_V_MF2_M4_MASK, VLUXEI8_V, 0x2, 0x0 }, // 4648 + { PseudoVLUXEI8_V_M1_M8, VLUXEI8_V, 0x3, 0x0 }, // 4649 + { PseudoVLUXEI8_V_M1_M8_MASK, VLUXEI8_V, 0x3, 0x0 }, // 4650 + { PseudoVLUXEI8_V_M2_M8, VLUXEI8_V, 0x3, 0x0 }, // 4651 + { PseudoVLUXEI8_V_M2_M8_MASK, VLUXEI8_V, 0x3, 0x0 }, // 4652 + { PseudoVLUXEI8_V_M4_M8, VLUXEI8_V, 0x3, 0x0 }, // 4653 + { PseudoVLUXEI8_V_M4_M8_MASK, VLUXEI8_V, 0x3, 0x0 }, // 4654 + { PseudoVLUXEI8_V_M8_M8, VLUXEI8_V, 0x3, 0x0 }, // 4655 + { PseudoVLUXEI8_V_M8_M8_MASK, VLUXEI8_V, 0x3, 0x0 }, // 4656 + { PseudoVLUXEI8_V_MF8_MF8, VLUXEI8_V, 0x5, 0x0 }, // 4657 + { PseudoVLUXEI8_V_MF8_MF8_MASK, VLUXEI8_V, 0x5, 0x0 }, // 4658 + { PseudoVLUXEI8_V_MF4_MF4, VLUXEI8_V, 0x6, 0x0 }, // 4659 + { PseudoVLUXEI8_V_MF4_MF4_MASK, VLUXEI8_V, 0x6, 0x0 }, // 4660 + { PseudoVLUXEI8_V_MF8_MF4, VLUXEI8_V, 0x6, 0x0 }, // 4661 + { PseudoVLUXEI8_V_MF8_MF4_MASK, VLUXEI8_V, 0x6, 0x0 }, // 4662 + { PseudoVLUXEI8_V_MF2_MF2, VLUXEI8_V, 0x7, 0x0 }, // 4663 + { PseudoVLUXEI8_V_MF2_MF2_MASK, VLUXEI8_V, 0x7, 0x0 }, // 4664 + { PseudoVLUXEI8_V_MF4_MF2, VLUXEI8_V, 0x7, 0x0 }, // 4665 + { PseudoVLUXEI8_V_MF4_MF2_MASK, VLUXEI8_V, 0x7, 0x0 }, // 4666 + { PseudoVLUXEI8_V_MF8_MF2, VLUXEI8_V, 0x7, 0x0 }, // 4667 + { PseudoVLUXEI8_V_MF8_MF2_MASK, VLUXEI8_V, 0x7, 0x0 }, // 4668 + { PseudoVLUXSEG2EI16_V_M1_M1, VLUXSEG2EI16_V, 0x0, 0x0 }, // 4669 + { PseudoVLUXSEG2EI16_V_M1_M1_MASK, VLUXSEG2EI16_V, 0x0, 0x0 }, // 4670 + { PseudoVLUXSEG2EI16_V_M2_M1, VLUXSEG2EI16_V, 0x0, 0x0 }, // 4671 + { PseudoVLUXSEG2EI16_V_M2_M1_MASK, VLUXSEG2EI16_V, 0x0, 0x0 }, // 4672 + { PseudoVLUXSEG2EI16_V_MF2_M1, VLUXSEG2EI16_V, 0x0, 0x0 }, // 4673 + { PseudoVLUXSEG2EI16_V_MF2_M1_MASK, VLUXSEG2EI16_V, 0x0, 0x0 }, // 4674 + { PseudoVLUXSEG2EI16_V_MF4_M1, VLUXSEG2EI16_V, 0x0, 0x0 }, // 4675 + { PseudoVLUXSEG2EI16_V_MF4_M1_MASK, VLUXSEG2EI16_V, 0x0, 0x0 }, // 4676 + { PseudoVLUXSEG2EI16_V_M1_M2, VLUXSEG2EI16_V, 0x1, 0x0 }, // 4677 + { PseudoVLUXSEG2EI16_V_M1_M2_MASK, VLUXSEG2EI16_V, 0x1, 0x0 }, // 4678 + { PseudoVLUXSEG2EI16_V_M2_M2, VLUXSEG2EI16_V, 0x1, 0x0 }, // 4679 + { PseudoVLUXSEG2EI16_V_M2_M2_MASK, VLUXSEG2EI16_V, 0x1, 0x0 }, // 4680 + { PseudoVLUXSEG2EI16_V_M4_M2, VLUXSEG2EI16_V, 0x1, 0x0 }, // 4681 + { PseudoVLUXSEG2EI16_V_M4_M2_MASK, VLUXSEG2EI16_V, 0x1, 0x0 }, // 4682 + { PseudoVLUXSEG2EI16_V_MF2_M2, VLUXSEG2EI16_V, 0x1, 0x0 }, // 4683 + { PseudoVLUXSEG2EI16_V_MF2_M2_MASK, VLUXSEG2EI16_V, 0x1, 0x0 }, // 4684 + { PseudoVLUXSEG2EI16_V_M1_M4, VLUXSEG2EI16_V, 0x2, 0x0 }, // 4685 + { PseudoVLUXSEG2EI16_V_M1_M4_MASK, VLUXSEG2EI16_V, 0x2, 0x0 }, // 4686 + { PseudoVLUXSEG2EI16_V_M2_M4, VLUXSEG2EI16_V, 0x2, 0x0 }, // 4687 + { PseudoVLUXSEG2EI16_V_M2_M4_MASK, VLUXSEG2EI16_V, 0x2, 0x0 }, // 4688 + { PseudoVLUXSEG2EI16_V_M4_M4, VLUXSEG2EI16_V, 0x2, 0x0 }, // 4689 + { PseudoVLUXSEG2EI16_V_M4_M4_MASK, VLUXSEG2EI16_V, 0x2, 0x0 }, // 4690 + { PseudoVLUXSEG2EI16_V_M8_M4, VLUXSEG2EI16_V, 0x2, 0x0 }, // 4691 + { PseudoVLUXSEG2EI16_V_M8_M4_MASK, VLUXSEG2EI16_V, 0x2, 0x0 }, // 4692 + { PseudoVLUXSEG2EI16_V_MF4_MF8, VLUXSEG2EI16_V, 0x5, 0x0 }, // 4693 + { PseudoVLUXSEG2EI16_V_MF4_MF8_MASK, VLUXSEG2EI16_V, 0x5, 0x0 }, // 4694 + { PseudoVLUXSEG2EI16_V_MF2_MF4, VLUXSEG2EI16_V, 0x6, 0x0 }, // 4695 + { PseudoVLUXSEG2EI16_V_MF2_MF4_MASK, VLUXSEG2EI16_V, 0x6, 0x0 }, // 4696 + { PseudoVLUXSEG2EI16_V_MF4_MF4, VLUXSEG2EI16_V, 0x6, 0x0 }, // 4697 + { PseudoVLUXSEG2EI16_V_MF4_MF4_MASK, VLUXSEG2EI16_V, 0x6, 0x0 }, // 4698 + { PseudoVLUXSEG2EI16_V_M1_MF2, VLUXSEG2EI16_V, 0x7, 0x0 }, // 4699 + { PseudoVLUXSEG2EI16_V_M1_MF2_MASK, VLUXSEG2EI16_V, 0x7, 0x0 }, // 4700 + { PseudoVLUXSEG2EI16_V_MF2_MF2, VLUXSEG2EI16_V, 0x7, 0x0 }, // 4701 + { PseudoVLUXSEG2EI16_V_MF2_MF2_MASK, VLUXSEG2EI16_V, 0x7, 0x0 }, // 4702 + { PseudoVLUXSEG2EI16_V_MF4_MF2, VLUXSEG2EI16_V, 0x7, 0x0 }, // 4703 + { PseudoVLUXSEG2EI16_V_MF4_MF2_MASK, VLUXSEG2EI16_V, 0x7, 0x0 }, // 4704 + { PseudoVLUXSEG2EI32_V_M1_M1, VLUXSEG2EI32_V, 0x0, 0x0 }, // 4705 + { PseudoVLUXSEG2EI32_V_M1_M1_MASK, VLUXSEG2EI32_V, 0x0, 0x0 }, // 4706 + { PseudoVLUXSEG2EI32_V_M2_M1, VLUXSEG2EI32_V, 0x0, 0x0 }, // 4707 + { PseudoVLUXSEG2EI32_V_M2_M1_MASK, VLUXSEG2EI32_V, 0x0, 0x0 }, // 4708 + { PseudoVLUXSEG2EI32_V_M4_M1, VLUXSEG2EI32_V, 0x0, 0x0 }, // 4709 + { PseudoVLUXSEG2EI32_V_M4_M1_MASK, VLUXSEG2EI32_V, 0x0, 0x0 }, // 4710 + { PseudoVLUXSEG2EI32_V_MF2_M1, VLUXSEG2EI32_V, 0x0, 0x0 }, // 4711 + { PseudoVLUXSEG2EI32_V_MF2_M1_MASK, VLUXSEG2EI32_V, 0x0, 0x0 }, // 4712 + { PseudoVLUXSEG2EI32_V_M1_M2, VLUXSEG2EI32_V, 0x1, 0x0 }, // 4713 + { PseudoVLUXSEG2EI32_V_M1_M2_MASK, VLUXSEG2EI32_V, 0x1, 0x0 }, // 4714 + { PseudoVLUXSEG2EI32_V_M2_M2, VLUXSEG2EI32_V, 0x1, 0x0 }, // 4715 + { PseudoVLUXSEG2EI32_V_M2_M2_MASK, VLUXSEG2EI32_V, 0x1, 0x0 }, // 4716 + { PseudoVLUXSEG2EI32_V_M4_M2, VLUXSEG2EI32_V, 0x1, 0x0 }, // 4717 + { PseudoVLUXSEG2EI32_V_M4_M2_MASK, VLUXSEG2EI32_V, 0x1, 0x0 }, // 4718 + { PseudoVLUXSEG2EI32_V_M8_M2, VLUXSEG2EI32_V, 0x1, 0x0 }, // 4719 + { PseudoVLUXSEG2EI32_V_M8_M2_MASK, VLUXSEG2EI32_V, 0x1, 0x0 }, // 4720 + { PseudoVLUXSEG2EI32_V_M2_M4, VLUXSEG2EI32_V, 0x2, 0x0 }, // 4721 + { PseudoVLUXSEG2EI32_V_M2_M4_MASK, VLUXSEG2EI32_V, 0x2, 0x0 }, // 4722 + { PseudoVLUXSEG2EI32_V_M4_M4, VLUXSEG2EI32_V, 0x2, 0x0 }, // 4723 + { PseudoVLUXSEG2EI32_V_M4_M4_MASK, VLUXSEG2EI32_V, 0x2, 0x0 }, // 4724 + { PseudoVLUXSEG2EI32_V_M8_M4, VLUXSEG2EI32_V, 0x2, 0x0 }, // 4725 + { PseudoVLUXSEG2EI32_V_M8_M4_MASK, VLUXSEG2EI32_V, 0x2, 0x0 }, // 4726 + { PseudoVLUXSEG2EI32_V_MF2_MF8, VLUXSEG2EI32_V, 0x5, 0x0 }, // 4727 + { PseudoVLUXSEG2EI32_V_MF2_MF8_MASK, VLUXSEG2EI32_V, 0x5, 0x0 }, // 4728 + { PseudoVLUXSEG2EI32_V_M1_MF4, VLUXSEG2EI32_V, 0x6, 0x0 }, // 4729 + { PseudoVLUXSEG2EI32_V_M1_MF4_MASK, VLUXSEG2EI32_V, 0x6, 0x0 }, // 4730 + { PseudoVLUXSEG2EI32_V_MF2_MF4, VLUXSEG2EI32_V, 0x6, 0x0 }, // 4731 + { PseudoVLUXSEG2EI32_V_MF2_MF4_MASK, VLUXSEG2EI32_V, 0x6, 0x0 }, // 4732 + { PseudoVLUXSEG2EI32_V_M1_MF2, VLUXSEG2EI32_V, 0x7, 0x0 }, // 4733 + { PseudoVLUXSEG2EI32_V_M1_MF2_MASK, VLUXSEG2EI32_V, 0x7, 0x0 }, // 4734 + { PseudoVLUXSEG2EI32_V_M2_MF2, VLUXSEG2EI32_V, 0x7, 0x0 }, // 4735 + { PseudoVLUXSEG2EI32_V_M2_MF2_MASK, VLUXSEG2EI32_V, 0x7, 0x0 }, // 4736 + { PseudoVLUXSEG2EI32_V_MF2_MF2, VLUXSEG2EI32_V, 0x7, 0x0 }, // 4737 + { PseudoVLUXSEG2EI32_V_MF2_MF2_MASK, VLUXSEG2EI32_V, 0x7, 0x0 }, // 4738 + { PseudoVLUXSEG2EI64_V_M1_M1, VLUXSEG2EI64_V, 0x0, 0x0 }, // 4739 + { PseudoVLUXSEG2EI64_V_M1_M1_MASK, VLUXSEG2EI64_V, 0x0, 0x0 }, // 4740 + { PseudoVLUXSEG2EI64_V_M2_M1, VLUXSEG2EI64_V, 0x0, 0x0 }, // 4741 + { PseudoVLUXSEG2EI64_V_M2_M1_MASK, VLUXSEG2EI64_V, 0x0, 0x0 }, // 4742 + { PseudoVLUXSEG2EI64_V_M4_M1, VLUXSEG2EI64_V, 0x0, 0x0 }, // 4743 + { PseudoVLUXSEG2EI64_V_M4_M1_MASK, VLUXSEG2EI64_V, 0x0, 0x0 }, // 4744 + { PseudoVLUXSEG2EI64_V_M8_M1, VLUXSEG2EI64_V, 0x0, 0x0 }, // 4745 + { PseudoVLUXSEG2EI64_V_M8_M1_MASK, VLUXSEG2EI64_V, 0x0, 0x0 }, // 4746 + { PseudoVLUXSEG2EI64_V_M2_M2, VLUXSEG2EI64_V, 0x1, 0x0 }, // 4747 + { PseudoVLUXSEG2EI64_V_M2_M2_MASK, VLUXSEG2EI64_V, 0x1, 0x0 }, // 4748 + { PseudoVLUXSEG2EI64_V_M4_M2, VLUXSEG2EI64_V, 0x1, 0x0 }, // 4749 + { PseudoVLUXSEG2EI64_V_M4_M2_MASK, VLUXSEG2EI64_V, 0x1, 0x0 }, // 4750 + { PseudoVLUXSEG2EI64_V_M8_M2, VLUXSEG2EI64_V, 0x1, 0x0 }, // 4751 + { PseudoVLUXSEG2EI64_V_M8_M2_MASK, VLUXSEG2EI64_V, 0x1, 0x0 }, // 4752 + { PseudoVLUXSEG2EI64_V_M4_M4, VLUXSEG2EI64_V, 0x2, 0x0 }, // 4753 + { PseudoVLUXSEG2EI64_V_M4_M4_MASK, VLUXSEG2EI64_V, 0x2, 0x0 }, // 4754 + { PseudoVLUXSEG2EI64_V_M8_M4, VLUXSEG2EI64_V, 0x2, 0x0 }, // 4755 + { PseudoVLUXSEG2EI64_V_M8_M4_MASK, VLUXSEG2EI64_V, 0x2, 0x0 }, // 4756 + { PseudoVLUXSEG2EI64_V_M1_MF8, VLUXSEG2EI64_V, 0x5, 0x0 }, // 4757 + { PseudoVLUXSEG2EI64_V_M1_MF8_MASK, VLUXSEG2EI64_V, 0x5, 0x0 }, // 4758 + { PseudoVLUXSEG2EI64_V_M1_MF4, VLUXSEG2EI64_V, 0x6, 0x0 }, // 4759 + { PseudoVLUXSEG2EI64_V_M1_MF4_MASK, VLUXSEG2EI64_V, 0x6, 0x0 }, // 4760 + { PseudoVLUXSEG2EI64_V_M2_MF4, VLUXSEG2EI64_V, 0x6, 0x0 }, // 4761 + { PseudoVLUXSEG2EI64_V_M2_MF4_MASK, VLUXSEG2EI64_V, 0x6, 0x0 }, // 4762 + { PseudoVLUXSEG2EI64_V_M1_MF2, VLUXSEG2EI64_V, 0x7, 0x0 }, // 4763 + { PseudoVLUXSEG2EI64_V_M1_MF2_MASK, VLUXSEG2EI64_V, 0x7, 0x0 }, // 4764 + { PseudoVLUXSEG2EI64_V_M2_MF2, VLUXSEG2EI64_V, 0x7, 0x0 }, // 4765 + { PseudoVLUXSEG2EI64_V_M2_MF2_MASK, VLUXSEG2EI64_V, 0x7, 0x0 }, // 4766 + { PseudoVLUXSEG2EI64_V_M4_MF2, VLUXSEG2EI64_V, 0x7, 0x0 }, // 4767 + { PseudoVLUXSEG2EI64_V_M4_MF2_MASK, VLUXSEG2EI64_V, 0x7, 0x0 }, // 4768 + { PseudoVLUXSEG2EI8_V_M1_M1, VLUXSEG2EI8_V, 0x0, 0x0 }, // 4769 + { PseudoVLUXSEG2EI8_V_M1_M1_MASK, VLUXSEG2EI8_V, 0x0, 0x0 }, // 4770 + { PseudoVLUXSEG2EI8_V_MF2_M1, VLUXSEG2EI8_V, 0x0, 0x0 }, // 4771 + { PseudoVLUXSEG2EI8_V_MF2_M1_MASK, VLUXSEG2EI8_V, 0x0, 0x0 }, // 4772 + { PseudoVLUXSEG2EI8_V_MF4_M1, VLUXSEG2EI8_V, 0x0, 0x0 }, // 4773 + { PseudoVLUXSEG2EI8_V_MF4_M1_MASK, VLUXSEG2EI8_V, 0x0, 0x0 }, // 4774 + { PseudoVLUXSEG2EI8_V_MF8_M1, VLUXSEG2EI8_V, 0x0, 0x0 }, // 4775 + { PseudoVLUXSEG2EI8_V_MF8_M1_MASK, VLUXSEG2EI8_V, 0x0, 0x0 }, // 4776 + { PseudoVLUXSEG2EI8_V_M1_M2, VLUXSEG2EI8_V, 0x1, 0x0 }, // 4777 + { PseudoVLUXSEG2EI8_V_M1_M2_MASK, VLUXSEG2EI8_V, 0x1, 0x0 }, // 4778 + { PseudoVLUXSEG2EI8_V_M2_M2, VLUXSEG2EI8_V, 0x1, 0x0 }, // 4779 + { PseudoVLUXSEG2EI8_V_M2_M2_MASK, VLUXSEG2EI8_V, 0x1, 0x0 }, // 4780 + { PseudoVLUXSEG2EI8_V_MF2_M2, VLUXSEG2EI8_V, 0x1, 0x0 }, // 4781 + { PseudoVLUXSEG2EI8_V_MF2_M2_MASK, VLUXSEG2EI8_V, 0x1, 0x0 }, // 4782 + { PseudoVLUXSEG2EI8_V_MF4_M2, VLUXSEG2EI8_V, 0x1, 0x0 }, // 4783 + { PseudoVLUXSEG2EI8_V_MF4_M2_MASK, VLUXSEG2EI8_V, 0x1, 0x0 }, // 4784 + { PseudoVLUXSEG2EI8_V_M1_M4, VLUXSEG2EI8_V, 0x2, 0x0 }, // 4785 + { PseudoVLUXSEG2EI8_V_M1_M4_MASK, VLUXSEG2EI8_V, 0x2, 0x0 }, // 4786 + { PseudoVLUXSEG2EI8_V_M2_M4, VLUXSEG2EI8_V, 0x2, 0x0 }, // 4787 + { PseudoVLUXSEG2EI8_V_M2_M4_MASK, VLUXSEG2EI8_V, 0x2, 0x0 }, // 4788 + { PseudoVLUXSEG2EI8_V_M4_M4, VLUXSEG2EI8_V, 0x2, 0x0 }, // 4789 + { PseudoVLUXSEG2EI8_V_M4_M4_MASK, VLUXSEG2EI8_V, 0x2, 0x0 }, // 4790 + { PseudoVLUXSEG2EI8_V_MF2_M4, VLUXSEG2EI8_V, 0x2, 0x0 }, // 4791 + { PseudoVLUXSEG2EI8_V_MF2_M4_MASK, VLUXSEG2EI8_V, 0x2, 0x0 }, // 4792 + { PseudoVLUXSEG2EI8_V_MF8_MF8, VLUXSEG2EI8_V, 0x5, 0x0 }, // 4793 + { PseudoVLUXSEG2EI8_V_MF8_MF8_MASK, VLUXSEG2EI8_V, 0x5, 0x0 }, // 4794 + { PseudoVLUXSEG2EI8_V_MF4_MF4, VLUXSEG2EI8_V, 0x6, 0x0 }, // 4795 + { PseudoVLUXSEG2EI8_V_MF4_MF4_MASK, VLUXSEG2EI8_V, 0x6, 0x0 }, // 4796 + { PseudoVLUXSEG2EI8_V_MF8_MF4, VLUXSEG2EI8_V, 0x6, 0x0 }, // 4797 + { PseudoVLUXSEG2EI8_V_MF8_MF4_MASK, VLUXSEG2EI8_V, 0x6, 0x0 }, // 4798 + { PseudoVLUXSEG2EI8_V_MF2_MF2, VLUXSEG2EI8_V, 0x7, 0x0 }, // 4799 + { PseudoVLUXSEG2EI8_V_MF2_MF2_MASK, VLUXSEG2EI8_V, 0x7, 0x0 }, // 4800 + { PseudoVLUXSEG2EI8_V_MF4_MF2, VLUXSEG2EI8_V, 0x7, 0x0 }, // 4801 + { PseudoVLUXSEG2EI8_V_MF4_MF2_MASK, VLUXSEG2EI8_V, 0x7, 0x0 }, // 4802 + { PseudoVLUXSEG2EI8_V_MF8_MF2, VLUXSEG2EI8_V, 0x7, 0x0 }, // 4803 + { PseudoVLUXSEG2EI8_V_MF8_MF2_MASK, VLUXSEG2EI8_V, 0x7, 0x0 }, // 4804 + { PseudoVLUXSEG3EI16_V_M1_M1, VLUXSEG3EI16_V, 0x0, 0x0 }, // 4805 + { PseudoVLUXSEG3EI16_V_M1_M1_MASK, VLUXSEG3EI16_V, 0x0, 0x0 }, // 4806 + { PseudoVLUXSEG3EI16_V_M2_M1, VLUXSEG3EI16_V, 0x0, 0x0 }, // 4807 + { PseudoVLUXSEG3EI16_V_M2_M1_MASK, VLUXSEG3EI16_V, 0x0, 0x0 }, // 4808 + { PseudoVLUXSEG3EI16_V_MF2_M1, VLUXSEG3EI16_V, 0x0, 0x0 }, // 4809 + { PseudoVLUXSEG3EI16_V_MF2_M1_MASK, VLUXSEG3EI16_V, 0x0, 0x0 }, // 4810 + { PseudoVLUXSEG3EI16_V_MF4_M1, VLUXSEG3EI16_V, 0x0, 0x0 }, // 4811 + { PseudoVLUXSEG3EI16_V_MF4_M1_MASK, VLUXSEG3EI16_V, 0x0, 0x0 }, // 4812 + { PseudoVLUXSEG3EI16_V_M1_M2, VLUXSEG3EI16_V, 0x1, 0x0 }, // 4813 + { PseudoVLUXSEG3EI16_V_M1_M2_MASK, VLUXSEG3EI16_V, 0x1, 0x0 }, // 4814 + { PseudoVLUXSEG3EI16_V_M2_M2, VLUXSEG3EI16_V, 0x1, 0x0 }, // 4815 + { PseudoVLUXSEG3EI16_V_M2_M2_MASK, VLUXSEG3EI16_V, 0x1, 0x0 }, // 4816 + { PseudoVLUXSEG3EI16_V_M4_M2, VLUXSEG3EI16_V, 0x1, 0x0 }, // 4817 + { PseudoVLUXSEG3EI16_V_M4_M2_MASK, VLUXSEG3EI16_V, 0x1, 0x0 }, // 4818 + { PseudoVLUXSEG3EI16_V_MF2_M2, VLUXSEG3EI16_V, 0x1, 0x0 }, // 4819 + { PseudoVLUXSEG3EI16_V_MF2_M2_MASK, VLUXSEG3EI16_V, 0x1, 0x0 }, // 4820 + { PseudoVLUXSEG3EI16_V_MF4_MF8, VLUXSEG3EI16_V, 0x5, 0x0 }, // 4821 + { PseudoVLUXSEG3EI16_V_MF4_MF8_MASK, VLUXSEG3EI16_V, 0x5, 0x0 }, // 4822 + { PseudoVLUXSEG3EI16_V_MF2_MF4, VLUXSEG3EI16_V, 0x6, 0x0 }, // 4823 + { PseudoVLUXSEG3EI16_V_MF2_MF4_MASK, VLUXSEG3EI16_V, 0x6, 0x0 }, // 4824 + { PseudoVLUXSEG3EI16_V_MF4_MF4, VLUXSEG3EI16_V, 0x6, 0x0 }, // 4825 + { PseudoVLUXSEG3EI16_V_MF4_MF4_MASK, VLUXSEG3EI16_V, 0x6, 0x0 }, // 4826 + { PseudoVLUXSEG3EI16_V_M1_MF2, VLUXSEG3EI16_V, 0x7, 0x0 }, // 4827 + { PseudoVLUXSEG3EI16_V_M1_MF2_MASK, VLUXSEG3EI16_V, 0x7, 0x0 }, // 4828 + { PseudoVLUXSEG3EI16_V_MF2_MF2, VLUXSEG3EI16_V, 0x7, 0x0 }, // 4829 + { PseudoVLUXSEG3EI16_V_MF2_MF2_MASK, VLUXSEG3EI16_V, 0x7, 0x0 }, // 4830 + { PseudoVLUXSEG3EI16_V_MF4_MF2, VLUXSEG3EI16_V, 0x7, 0x0 }, // 4831 + { PseudoVLUXSEG3EI16_V_MF4_MF2_MASK, VLUXSEG3EI16_V, 0x7, 0x0 }, // 4832 + { PseudoVLUXSEG3EI32_V_M1_M1, VLUXSEG3EI32_V, 0x0, 0x0 }, // 4833 + { PseudoVLUXSEG3EI32_V_M1_M1_MASK, VLUXSEG3EI32_V, 0x0, 0x0 }, // 4834 + { PseudoVLUXSEG3EI32_V_M2_M1, VLUXSEG3EI32_V, 0x0, 0x0 }, // 4835 + { PseudoVLUXSEG3EI32_V_M2_M1_MASK, VLUXSEG3EI32_V, 0x0, 0x0 }, // 4836 + { PseudoVLUXSEG3EI32_V_M4_M1, VLUXSEG3EI32_V, 0x0, 0x0 }, // 4837 + { PseudoVLUXSEG3EI32_V_M4_M1_MASK, VLUXSEG3EI32_V, 0x0, 0x0 }, // 4838 + { PseudoVLUXSEG3EI32_V_MF2_M1, VLUXSEG3EI32_V, 0x0, 0x0 }, // 4839 + { PseudoVLUXSEG3EI32_V_MF2_M1_MASK, VLUXSEG3EI32_V, 0x0, 0x0 }, // 4840 + { PseudoVLUXSEG3EI32_V_M1_M2, VLUXSEG3EI32_V, 0x1, 0x0 }, // 4841 + { PseudoVLUXSEG3EI32_V_M1_M2_MASK, VLUXSEG3EI32_V, 0x1, 0x0 }, // 4842 + { PseudoVLUXSEG3EI32_V_M2_M2, VLUXSEG3EI32_V, 0x1, 0x0 }, // 4843 + { PseudoVLUXSEG3EI32_V_M2_M2_MASK, VLUXSEG3EI32_V, 0x1, 0x0 }, // 4844 + { PseudoVLUXSEG3EI32_V_M4_M2, VLUXSEG3EI32_V, 0x1, 0x0 }, // 4845 + { PseudoVLUXSEG3EI32_V_M4_M2_MASK, VLUXSEG3EI32_V, 0x1, 0x0 }, // 4846 + { PseudoVLUXSEG3EI32_V_M8_M2, VLUXSEG3EI32_V, 0x1, 0x0 }, // 4847 + { PseudoVLUXSEG3EI32_V_M8_M2_MASK, VLUXSEG3EI32_V, 0x1, 0x0 }, // 4848 + { PseudoVLUXSEG3EI32_V_MF2_MF8, VLUXSEG3EI32_V, 0x5, 0x0 }, // 4849 + { PseudoVLUXSEG3EI32_V_MF2_MF8_MASK, VLUXSEG3EI32_V, 0x5, 0x0 }, // 4850 + { PseudoVLUXSEG3EI32_V_M1_MF4, VLUXSEG3EI32_V, 0x6, 0x0 }, // 4851 + { PseudoVLUXSEG3EI32_V_M1_MF4_MASK, VLUXSEG3EI32_V, 0x6, 0x0 }, // 4852 + { PseudoVLUXSEG3EI32_V_MF2_MF4, VLUXSEG3EI32_V, 0x6, 0x0 }, // 4853 + { PseudoVLUXSEG3EI32_V_MF2_MF4_MASK, VLUXSEG3EI32_V, 0x6, 0x0 }, // 4854 + { PseudoVLUXSEG3EI32_V_M1_MF2, VLUXSEG3EI32_V, 0x7, 0x0 }, // 4855 + { PseudoVLUXSEG3EI32_V_M1_MF2_MASK, VLUXSEG3EI32_V, 0x7, 0x0 }, // 4856 + { PseudoVLUXSEG3EI32_V_M2_MF2, VLUXSEG3EI32_V, 0x7, 0x0 }, // 4857 + { PseudoVLUXSEG3EI32_V_M2_MF2_MASK, VLUXSEG3EI32_V, 0x7, 0x0 }, // 4858 + { PseudoVLUXSEG3EI32_V_MF2_MF2, VLUXSEG3EI32_V, 0x7, 0x0 }, // 4859 + { PseudoVLUXSEG3EI32_V_MF2_MF2_MASK, VLUXSEG3EI32_V, 0x7, 0x0 }, // 4860 + { PseudoVLUXSEG3EI64_V_M1_M1, VLUXSEG3EI64_V, 0x0, 0x0 }, // 4861 + { PseudoVLUXSEG3EI64_V_M1_M1_MASK, VLUXSEG3EI64_V, 0x0, 0x0 }, // 4862 + { PseudoVLUXSEG3EI64_V_M2_M1, VLUXSEG3EI64_V, 0x0, 0x0 }, // 4863 + { PseudoVLUXSEG3EI64_V_M2_M1_MASK, VLUXSEG3EI64_V, 0x0, 0x0 }, // 4864 + { PseudoVLUXSEG3EI64_V_M4_M1, VLUXSEG3EI64_V, 0x0, 0x0 }, // 4865 + { PseudoVLUXSEG3EI64_V_M4_M1_MASK, VLUXSEG3EI64_V, 0x0, 0x0 }, // 4866 + { PseudoVLUXSEG3EI64_V_M8_M1, VLUXSEG3EI64_V, 0x0, 0x0 }, // 4867 + { PseudoVLUXSEG3EI64_V_M8_M1_MASK, VLUXSEG3EI64_V, 0x0, 0x0 }, // 4868 + { PseudoVLUXSEG3EI64_V_M2_M2, VLUXSEG3EI64_V, 0x1, 0x0 }, // 4869 + { PseudoVLUXSEG3EI64_V_M2_M2_MASK, VLUXSEG3EI64_V, 0x1, 0x0 }, // 4870 + { PseudoVLUXSEG3EI64_V_M4_M2, VLUXSEG3EI64_V, 0x1, 0x0 }, // 4871 + { PseudoVLUXSEG3EI64_V_M4_M2_MASK, VLUXSEG3EI64_V, 0x1, 0x0 }, // 4872 + { PseudoVLUXSEG3EI64_V_M8_M2, VLUXSEG3EI64_V, 0x1, 0x0 }, // 4873 + { PseudoVLUXSEG3EI64_V_M8_M2_MASK, VLUXSEG3EI64_V, 0x1, 0x0 }, // 4874 + { PseudoVLUXSEG3EI64_V_M1_MF8, VLUXSEG3EI64_V, 0x5, 0x0 }, // 4875 + { PseudoVLUXSEG3EI64_V_M1_MF8_MASK, VLUXSEG3EI64_V, 0x5, 0x0 }, // 4876 + { PseudoVLUXSEG3EI64_V_M1_MF4, VLUXSEG3EI64_V, 0x6, 0x0 }, // 4877 + { PseudoVLUXSEG3EI64_V_M1_MF4_MASK, VLUXSEG3EI64_V, 0x6, 0x0 }, // 4878 + { PseudoVLUXSEG3EI64_V_M2_MF4, VLUXSEG3EI64_V, 0x6, 0x0 }, // 4879 + { PseudoVLUXSEG3EI64_V_M2_MF4_MASK, VLUXSEG3EI64_V, 0x6, 0x0 }, // 4880 + { PseudoVLUXSEG3EI64_V_M1_MF2, VLUXSEG3EI64_V, 0x7, 0x0 }, // 4881 + { PseudoVLUXSEG3EI64_V_M1_MF2_MASK, VLUXSEG3EI64_V, 0x7, 0x0 }, // 4882 + { PseudoVLUXSEG3EI64_V_M2_MF2, VLUXSEG3EI64_V, 0x7, 0x0 }, // 4883 + { PseudoVLUXSEG3EI64_V_M2_MF2_MASK, VLUXSEG3EI64_V, 0x7, 0x0 }, // 4884 + { PseudoVLUXSEG3EI64_V_M4_MF2, VLUXSEG3EI64_V, 0x7, 0x0 }, // 4885 + { PseudoVLUXSEG3EI64_V_M4_MF2_MASK, VLUXSEG3EI64_V, 0x7, 0x0 }, // 4886 + { PseudoVLUXSEG3EI8_V_M1_M1, VLUXSEG3EI8_V, 0x0, 0x0 }, // 4887 + { PseudoVLUXSEG3EI8_V_M1_M1_MASK, VLUXSEG3EI8_V, 0x0, 0x0 }, // 4888 + { PseudoVLUXSEG3EI8_V_MF2_M1, VLUXSEG3EI8_V, 0x0, 0x0 }, // 4889 + { PseudoVLUXSEG3EI8_V_MF2_M1_MASK, VLUXSEG3EI8_V, 0x0, 0x0 }, // 4890 + { PseudoVLUXSEG3EI8_V_MF4_M1, VLUXSEG3EI8_V, 0x0, 0x0 }, // 4891 + { PseudoVLUXSEG3EI8_V_MF4_M1_MASK, VLUXSEG3EI8_V, 0x0, 0x0 }, // 4892 + { PseudoVLUXSEG3EI8_V_MF8_M1, VLUXSEG3EI8_V, 0x0, 0x0 }, // 4893 + { PseudoVLUXSEG3EI8_V_MF8_M1_MASK, VLUXSEG3EI8_V, 0x0, 0x0 }, // 4894 + { PseudoVLUXSEG3EI8_V_M1_M2, VLUXSEG3EI8_V, 0x1, 0x0 }, // 4895 + { PseudoVLUXSEG3EI8_V_M1_M2_MASK, VLUXSEG3EI8_V, 0x1, 0x0 }, // 4896 + { PseudoVLUXSEG3EI8_V_M2_M2, VLUXSEG3EI8_V, 0x1, 0x0 }, // 4897 + { PseudoVLUXSEG3EI8_V_M2_M2_MASK, VLUXSEG3EI8_V, 0x1, 0x0 }, // 4898 + { PseudoVLUXSEG3EI8_V_MF2_M2, VLUXSEG3EI8_V, 0x1, 0x0 }, // 4899 + { PseudoVLUXSEG3EI8_V_MF2_M2_MASK, VLUXSEG3EI8_V, 0x1, 0x0 }, // 4900 + { PseudoVLUXSEG3EI8_V_MF4_M2, VLUXSEG3EI8_V, 0x1, 0x0 }, // 4901 + { PseudoVLUXSEG3EI8_V_MF4_M2_MASK, VLUXSEG3EI8_V, 0x1, 0x0 }, // 4902 + { PseudoVLUXSEG3EI8_V_MF8_MF8, VLUXSEG3EI8_V, 0x5, 0x0 }, // 4903 + { PseudoVLUXSEG3EI8_V_MF8_MF8_MASK, VLUXSEG3EI8_V, 0x5, 0x0 }, // 4904 + { PseudoVLUXSEG3EI8_V_MF4_MF4, VLUXSEG3EI8_V, 0x6, 0x0 }, // 4905 + { PseudoVLUXSEG3EI8_V_MF4_MF4_MASK, VLUXSEG3EI8_V, 0x6, 0x0 }, // 4906 + { PseudoVLUXSEG3EI8_V_MF8_MF4, VLUXSEG3EI8_V, 0x6, 0x0 }, // 4907 + { PseudoVLUXSEG3EI8_V_MF8_MF4_MASK, VLUXSEG3EI8_V, 0x6, 0x0 }, // 4908 + { PseudoVLUXSEG3EI8_V_MF2_MF2, VLUXSEG3EI8_V, 0x7, 0x0 }, // 4909 + { PseudoVLUXSEG3EI8_V_MF2_MF2_MASK, VLUXSEG3EI8_V, 0x7, 0x0 }, // 4910 + { PseudoVLUXSEG3EI8_V_MF4_MF2, VLUXSEG3EI8_V, 0x7, 0x0 }, // 4911 + { PseudoVLUXSEG3EI8_V_MF4_MF2_MASK, VLUXSEG3EI8_V, 0x7, 0x0 }, // 4912 + { PseudoVLUXSEG3EI8_V_MF8_MF2, VLUXSEG3EI8_V, 0x7, 0x0 }, // 4913 + { PseudoVLUXSEG3EI8_V_MF8_MF2_MASK, VLUXSEG3EI8_V, 0x7, 0x0 }, // 4914 + { PseudoVLUXSEG4EI16_V_M1_M1, VLUXSEG4EI16_V, 0x0, 0x0 }, // 4915 + { PseudoVLUXSEG4EI16_V_M1_M1_MASK, VLUXSEG4EI16_V, 0x0, 0x0 }, // 4916 + { PseudoVLUXSEG4EI16_V_M2_M1, VLUXSEG4EI16_V, 0x0, 0x0 }, // 4917 + { PseudoVLUXSEG4EI16_V_M2_M1_MASK, VLUXSEG4EI16_V, 0x0, 0x0 }, // 4918 + { PseudoVLUXSEG4EI16_V_MF2_M1, VLUXSEG4EI16_V, 0x0, 0x0 }, // 4919 + { PseudoVLUXSEG4EI16_V_MF2_M1_MASK, VLUXSEG4EI16_V, 0x0, 0x0 }, // 4920 + { PseudoVLUXSEG4EI16_V_MF4_M1, VLUXSEG4EI16_V, 0x0, 0x0 }, // 4921 + { PseudoVLUXSEG4EI16_V_MF4_M1_MASK, VLUXSEG4EI16_V, 0x0, 0x0 }, // 4922 + { PseudoVLUXSEG4EI16_V_M1_M2, VLUXSEG4EI16_V, 0x1, 0x0 }, // 4923 + { PseudoVLUXSEG4EI16_V_M1_M2_MASK, VLUXSEG4EI16_V, 0x1, 0x0 }, // 4924 + { PseudoVLUXSEG4EI16_V_M2_M2, VLUXSEG4EI16_V, 0x1, 0x0 }, // 4925 + { PseudoVLUXSEG4EI16_V_M2_M2_MASK, VLUXSEG4EI16_V, 0x1, 0x0 }, // 4926 + { PseudoVLUXSEG4EI16_V_M4_M2, VLUXSEG4EI16_V, 0x1, 0x0 }, // 4927 + { PseudoVLUXSEG4EI16_V_M4_M2_MASK, VLUXSEG4EI16_V, 0x1, 0x0 }, // 4928 + { PseudoVLUXSEG4EI16_V_MF2_M2, VLUXSEG4EI16_V, 0x1, 0x0 }, // 4929 + { PseudoVLUXSEG4EI16_V_MF2_M2_MASK, VLUXSEG4EI16_V, 0x1, 0x0 }, // 4930 + { PseudoVLUXSEG4EI16_V_MF4_MF8, VLUXSEG4EI16_V, 0x5, 0x0 }, // 4931 + { PseudoVLUXSEG4EI16_V_MF4_MF8_MASK, VLUXSEG4EI16_V, 0x5, 0x0 }, // 4932 + { PseudoVLUXSEG4EI16_V_MF2_MF4, VLUXSEG4EI16_V, 0x6, 0x0 }, // 4933 + { PseudoVLUXSEG4EI16_V_MF2_MF4_MASK, VLUXSEG4EI16_V, 0x6, 0x0 }, // 4934 + { PseudoVLUXSEG4EI16_V_MF4_MF4, VLUXSEG4EI16_V, 0x6, 0x0 }, // 4935 + { PseudoVLUXSEG4EI16_V_MF4_MF4_MASK, VLUXSEG4EI16_V, 0x6, 0x0 }, // 4936 + { PseudoVLUXSEG4EI16_V_M1_MF2, VLUXSEG4EI16_V, 0x7, 0x0 }, // 4937 + { PseudoVLUXSEG4EI16_V_M1_MF2_MASK, VLUXSEG4EI16_V, 0x7, 0x0 }, // 4938 + { PseudoVLUXSEG4EI16_V_MF2_MF2, VLUXSEG4EI16_V, 0x7, 0x0 }, // 4939 + { PseudoVLUXSEG4EI16_V_MF2_MF2_MASK, VLUXSEG4EI16_V, 0x7, 0x0 }, // 4940 + { PseudoVLUXSEG4EI16_V_MF4_MF2, VLUXSEG4EI16_V, 0x7, 0x0 }, // 4941 + { PseudoVLUXSEG4EI16_V_MF4_MF2_MASK, VLUXSEG4EI16_V, 0x7, 0x0 }, // 4942 + { PseudoVLUXSEG4EI32_V_M1_M1, VLUXSEG4EI32_V, 0x0, 0x0 }, // 4943 + { PseudoVLUXSEG4EI32_V_M1_M1_MASK, VLUXSEG4EI32_V, 0x0, 0x0 }, // 4944 + { PseudoVLUXSEG4EI32_V_M2_M1, VLUXSEG4EI32_V, 0x0, 0x0 }, // 4945 + { PseudoVLUXSEG4EI32_V_M2_M1_MASK, VLUXSEG4EI32_V, 0x0, 0x0 }, // 4946 + { PseudoVLUXSEG4EI32_V_M4_M1, VLUXSEG4EI32_V, 0x0, 0x0 }, // 4947 + { PseudoVLUXSEG4EI32_V_M4_M1_MASK, VLUXSEG4EI32_V, 0x0, 0x0 }, // 4948 + { PseudoVLUXSEG4EI32_V_MF2_M1, VLUXSEG4EI32_V, 0x0, 0x0 }, // 4949 + { PseudoVLUXSEG4EI32_V_MF2_M1_MASK, VLUXSEG4EI32_V, 0x0, 0x0 }, // 4950 + { PseudoVLUXSEG4EI32_V_M1_M2, VLUXSEG4EI32_V, 0x1, 0x0 }, // 4951 + { PseudoVLUXSEG4EI32_V_M1_M2_MASK, VLUXSEG4EI32_V, 0x1, 0x0 }, // 4952 + { PseudoVLUXSEG4EI32_V_M2_M2, VLUXSEG4EI32_V, 0x1, 0x0 }, // 4953 + { PseudoVLUXSEG4EI32_V_M2_M2_MASK, VLUXSEG4EI32_V, 0x1, 0x0 }, // 4954 + { PseudoVLUXSEG4EI32_V_M4_M2, VLUXSEG4EI32_V, 0x1, 0x0 }, // 4955 + { PseudoVLUXSEG4EI32_V_M4_M2_MASK, VLUXSEG4EI32_V, 0x1, 0x0 }, // 4956 + { PseudoVLUXSEG4EI32_V_M8_M2, VLUXSEG4EI32_V, 0x1, 0x0 }, // 4957 + { PseudoVLUXSEG4EI32_V_M8_M2_MASK, VLUXSEG4EI32_V, 0x1, 0x0 }, // 4958 + { PseudoVLUXSEG4EI32_V_MF2_MF8, VLUXSEG4EI32_V, 0x5, 0x0 }, // 4959 + { PseudoVLUXSEG4EI32_V_MF2_MF8_MASK, VLUXSEG4EI32_V, 0x5, 0x0 }, // 4960 + { PseudoVLUXSEG4EI32_V_M1_MF4, VLUXSEG4EI32_V, 0x6, 0x0 }, // 4961 + { PseudoVLUXSEG4EI32_V_M1_MF4_MASK, VLUXSEG4EI32_V, 0x6, 0x0 }, // 4962 + { PseudoVLUXSEG4EI32_V_MF2_MF4, VLUXSEG4EI32_V, 0x6, 0x0 }, // 4963 + { PseudoVLUXSEG4EI32_V_MF2_MF4_MASK, VLUXSEG4EI32_V, 0x6, 0x0 }, // 4964 + { PseudoVLUXSEG4EI32_V_M1_MF2, VLUXSEG4EI32_V, 0x7, 0x0 }, // 4965 + { PseudoVLUXSEG4EI32_V_M1_MF2_MASK, VLUXSEG4EI32_V, 0x7, 0x0 }, // 4966 + { PseudoVLUXSEG4EI32_V_M2_MF2, VLUXSEG4EI32_V, 0x7, 0x0 }, // 4967 + { PseudoVLUXSEG4EI32_V_M2_MF2_MASK, VLUXSEG4EI32_V, 0x7, 0x0 }, // 4968 + { PseudoVLUXSEG4EI32_V_MF2_MF2, VLUXSEG4EI32_V, 0x7, 0x0 }, // 4969 + { PseudoVLUXSEG4EI32_V_MF2_MF2_MASK, VLUXSEG4EI32_V, 0x7, 0x0 }, // 4970 + { PseudoVLUXSEG4EI64_V_M1_M1, VLUXSEG4EI64_V, 0x0, 0x0 }, // 4971 + { PseudoVLUXSEG4EI64_V_M1_M1_MASK, VLUXSEG4EI64_V, 0x0, 0x0 }, // 4972 + { PseudoVLUXSEG4EI64_V_M2_M1, VLUXSEG4EI64_V, 0x0, 0x0 }, // 4973 + { PseudoVLUXSEG4EI64_V_M2_M1_MASK, VLUXSEG4EI64_V, 0x0, 0x0 }, // 4974 + { PseudoVLUXSEG4EI64_V_M4_M1, VLUXSEG4EI64_V, 0x0, 0x0 }, // 4975 + { PseudoVLUXSEG4EI64_V_M4_M1_MASK, VLUXSEG4EI64_V, 0x0, 0x0 }, // 4976 + { PseudoVLUXSEG4EI64_V_M8_M1, VLUXSEG4EI64_V, 0x0, 0x0 }, // 4977 + { PseudoVLUXSEG4EI64_V_M8_M1_MASK, VLUXSEG4EI64_V, 0x0, 0x0 }, // 4978 + { PseudoVLUXSEG4EI64_V_M2_M2, VLUXSEG4EI64_V, 0x1, 0x0 }, // 4979 + { PseudoVLUXSEG4EI64_V_M2_M2_MASK, VLUXSEG4EI64_V, 0x1, 0x0 }, // 4980 + { PseudoVLUXSEG4EI64_V_M4_M2, VLUXSEG4EI64_V, 0x1, 0x0 }, // 4981 + { PseudoVLUXSEG4EI64_V_M4_M2_MASK, VLUXSEG4EI64_V, 0x1, 0x0 }, // 4982 + { PseudoVLUXSEG4EI64_V_M8_M2, VLUXSEG4EI64_V, 0x1, 0x0 }, // 4983 + { PseudoVLUXSEG4EI64_V_M8_M2_MASK, VLUXSEG4EI64_V, 0x1, 0x0 }, // 4984 + { PseudoVLUXSEG4EI64_V_M1_MF8, VLUXSEG4EI64_V, 0x5, 0x0 }, // 4985 + { PseudoVLUXSEG4EI64_V_M1_MF8_MASK, VLUXSEG4EI64_V, 0x5, 0x0 }, // 4986 + { PseudoVLUXSEG4EI64_V_M1_MF4, VLUXSEG4EI64_V, 0x6, 0x0 }, // 4987 + { PseudoVLUXSEG4EI64_V_M1_MF4_MASK, VLUXSEG4EI64_V, 0x6, 0x0 }, // 4988 + { PseudoVLUXSEG4EI64_V_M2_MF4, VLUXSEG4EI64_V, 0x6, 0x0 }, // 4989 + { PseudoVLUXSEG4EI64_V_M2_MF4_MASK, VLUXSEG4EI64_V, 0x6, 0x0 }, // 4990 + { PseudoVLUXSEG4EI64_V_M1_MF2, VLUXSEG4EI64_V, 0x7, 0x0 }, // 4991 + { PseudoVLUXSEG4EI64_V_M1_MF2_MASK, VLUXSEG4EI64_V, 0x7, 0x0 }, // 4992 + { PseudoVLUXSEG4EI64_V_M2_MF2, VLUXSEG4EI64_V, 0x7, 0x0 }, // 4993 + { PseudoVLUXSEG4EI64_V_M2_MF2_MASK, VLUXSEG4EI64_V, 0x7, 0x0 }, // 4994 + { PseudoVLUXSEG4EI64_V_M4_MF2, VLUXSEG4EI64_V, 0x7, 0x0 }, // 4995 + { PseudoVLUXSEG4EI64_V_M4_MF2_MASK, VLUXSEG4EI64_V, 0x7, 0x0 }, // 4996 + { PseudoVLUXSEG4EI8_V_M1_M1, VLUXSEG4EI8_V, 0x0, 0x0 }, // 4997 + { PseudoVLUXSEG4EI8_V_M1_M1_MASK, VLUXSEG4EI8_V, 0x0, 0x0 }, // 4998 + { PseudoVLUXSEG4EI8_V_MF2_M1, VLUXSEG4EI8_V, 0x0, 0x0 }, // 4999 + { PseudoVLUXSEG4EI8_V_MF2_M1_MASK, VLUXSEG4EI8_V, 0x0, 0x0 }, // 5000 + { PseudoVLUXSEG4EI8_V_MF4_M1, VLUXSEG4EI8_V, 0x0, 0x0 }, // 5001 + { PseudoVLUXSEG4EI8_V_MF4_M1_MASK, VLUXSEG4EI8_V, 0x0, 0x0 }, // 5002 + { PseudoVLUXSEG4EI8_V_MF8_M1, VLUXSEG4EI8_V, 0x0, 0x0 }, // 5003 + { PseudoVLUXSEG4EI8_V_MF8_M1_MASK, VLUXSEG4EI8_V, 0x0, 0x0 }, // 5004 + { PseudoVLUXSEG4EI8_V_M1_M2, VLUXSEG4EI8_V, 0x1, 0x0 }, // 5005 + { PseudoVLUXSEG4EI8_V_M1_M2_MASK, VLUXSEG4EI8_V, 0x1, 0x0 }, // 5006 + { PseudoVLUXSEG4EI8_V_M2_M2, VLUXSEG4EI8_V, 0x1, 0x0 }, // 5007 + { PseudoVLUXSEG4EI8_V_M2_M2_MASK, VLUXSEG4EI8_V, 0x1, 0x0 }, // 5008 + { PseudoVLUXSEG4EI8_V_MF2_M2, VLUXSEG4EI8_V, 0x1, 0x0 }, // 5009 + { PseudoVLUXSEG4EI8_V_MF2_M2_MASK, VLUXSEG4EI8_V, 0x1, 0x0 }, // 5010 + { PseudoVLUXSEG4EI8_V_MF4_M2, VLUXSEG4EI8_V, 0x1, 0x0 }, // 5011 + { PseudoVLUXSEG4EI8_V_MF4_M2_MASK, VLUXSEG4EI8_V, 0x1, 0x0 }, // 5012 + { PseudoVLUXSEG4EI8_V_MF8_MF8, VLUXSEG4EI8_V, 0x5, 0x0 }, // 5013 + { PseudoVLUXSEG4EI8_V_MF8_MF8_MASK, VLUXSEG4EI8_V, 0x5, 0x0 }, // 5014 + { PseudoVLUXSEG4EI8_V_MF4_MF4, VLUXSEG4EI8_V, 0x6, 0x0 }, // 5015 + { PseudoVLUXSEG4EI8_V_MF4_MF4_MASK, VLUXSEG4EI8_V, 0x6, 0x0 }, // 5016 + { PseudoVLUXSEG4EI8_V_MF8_MF4, VLUXSEG4EI8_V, 0x6, 0x0 }, // 5017 + { PseudoVLUXSEG4EI8_V_MF8_MF4_MASK, VLUXSEG4EI8_V, 0x6, 0x0 }, // 5018 + { PseudoVLUXSEG4EI8_V_MF2_MF2, VLUXSEG4EI8_V, 0x7, 0x0 }, // 5019 + { PseudoVLUXSEG4EI8_V_MF2_MF2_MASK, VLUXSEG4EI8_V, 0x7, 0x0 }, // 5020 + { PseudoVLUXSEG4EI8_V_MF4_MF2, VLUXSEG4EI8_V, 0x7, 0x0 }, // 5021 + { PseudoVLUXSEG4EI8_V_MF4_MF2_MASK, VLUXSEG4EI8_V, 0x7, 0x0 }, // 5022 + { PseudoVLUXSEG4EI8_V_MF8_MF2, VLUXSEG4EI8_V, 0x7, 0x0 }, // 5023 + { PseudoVLUXSEG4EI8_V_MF8_MF2_MASK, VLUXSEG4EI8_V, 0x7, 0x0 }, // 5024 + { PseudoVLUXSEG5EI16_V_M1_M1, VLUXSEG5EI16_V, 0x0, 0x0 }, // 5025 + { PseudoVLUXSEG5EI16_V_M1_M1_MASK, VLUXSEG5EI16_V, 0x0, 0x0 }, // 5026 + { PseudoVLUXSEG5EI16_V_M2_M1, VLUXSEG5EI16_V, 0x0, 0x0 }, // 5027 + { PseudoVLUXSEG5EI16_V_M2_M1_MASK, VLUXSEG5EI16_V, 0x0, 0x0 }, // 5028 + { PseudoVLUXSEG5EI16_V_MF2_M1, VLUXSEG5EI16_V, 0x0, 0x0 }, // 5029 + { PseudoVLUXSEG5EI16_V_MF2_M1_MASK, VLUXSEG5EI16_V, 0x0, 0x0 }, // 5030 + { PseudoVLUXSEG5EI16_V_MF4_M1, VLUXSEG5EI16_V, 0x0, 0x0 }, // 5031 + { PseudoVLUXSEG5EI16_V_MF4_M1_MASK, VLUXSEG5EI16_V, 0x0, 0x0 }, // 5032 + { PseudoVLUXSEG5EI16_V_MF4_MF8, VLUXSEG5EI16_V, 0x5, 0x0 }, // 5033 + { PseudoVLUXSEG5EI16_V_MF4_MF8_MASK, VLUXSEG5EI16_V, 0x5, 0x0 }, // 5034 + { PseudoVLUXSEG5EI16_V_MF2_MF4, VLUXSEG5EI16_V, 0x6, 0x0 }, // 5035 + { PseudoVLUXSEG5EI16_V_MF2_MF4_MASK, VLUXSEG5EI16_V, 0x6, 0x0 }, // 5036 + { PseudoVLUXSEG5EI16_V_MF4_MF4, VLUXSEG5EI16_V, 0x6, 0x0 }, // 5037 + { PseudoVLUXSEG5EI16_V_MF4_MF4_MASK, VLUXSEG5EI16_V, 0x6, 0x0 }, // 5038 + { PseudoVLUXSEG5EI16_V_M1_MF2, VLUXSEG5EI16_V, 0x7, 0x0 }, // 5039 + { PseudoVLUXSEG5EI16_V_M1_MF2_MASK, VLUXSEG5EI16_V, 0x7, 0x0 }, // 5040 + { PseudoVLUXSEG5EI16_V_MF2_MF2, VLUXSEG5EI16_V, 0x7, 0x0 }, // 5041 + { PseudoVLUXSEG5EI16_V_MF2_MF2_MASK, VLUXSEG5EI16_V, 0x7, 0x0 }, // 5042 + { PseudoVLUXSEG5EI16_V_MF4_MF2, VLUXSEG5EI16_V, 0x7, 0x0 }, // 5043 + { PseudoVLUXSEG5EI16_V_MF4_MF2_MASK, VLUXSEG5EI16_V, 0x7, 0x0 }, // 5044 + { PseudoVLUXSEG5EI32_V_M1_M1, VLUXSEG5EI32_V, 0x0, 0x0 }, // 5045 + { PseudoVLUXSEG5EI32_V_M1_M1_MASK, VLUXSEG5EI32_V, 0x0, 0x0 }, // 5046 + { PseudoVLUXSEG5EI32_V_M2_M1, VLUXSEG5EI32_V, 0x0, 0x0 }, // 5047 + { PseudoVLUXSEG5EI32_V_M2_M1_MASK, VLUXSEG5EI32_V, 0x0, 0x0 }, // 5048 + { PseudoVLUXSEG5EI32_V_M4_M1, VLUXSEG5EI32_V, 0x0, 0x0 }, // 5049 + { PseudoVLUXSEG5EI32_V_M4_M1_MASK, VLUXSEG5EI32_V, 0x0, 0x0 }, // 5050 + { PseudoVLUXSEG5EI32_V_MF2_M1, VLUXSEG5EI32_V, 0x0, 0x0 }, // 5051 + { PseudoVLUXSEG5EI32_V_MF2_M1_MASK, VLUXSEG5EI32_V, 0x0, 0x0 }, // 5052 + { PseudoVLUXSEG5EI32_V_MF2_MF8, VLUXSEG5EI32_V, 0x5, 0x0 }, // 5053 + { PseudoVLUXSEG5EI32_V_MF2_MF8_MASK, VLUXSEG5EI32_V, 0x5, 0x0 }, // 5054 + { PseudoVLUXSEG5EI32_V_M1_MF4, VLUXSEG5EI32_V, 0x6, 0x0 }, // 5055 + { PseudoVLUXSEG5EI32_V_M1_MF4_MASK, VLUXSEG5EI32_V, 0x6, 0x0 }, // 5056 + { PseudoVLUXSEG5EI32_V_MF2_MF4, VLUXSEG5EI32_V, 0x6, 0x0 }, // 5057 + { PseudoVLUXSEG5EI32_V_MF2_MF4_MASK, VLUXSEG5EI32_V, 0x6, 0x0 }, // 5058 + { PseudoVLUXSEG5EI32_V_M1_MF2, VLUXSEG5EI32_V, 0x7, 0x0 }, // 5059 + { PseudoVLUXSEG5EI32_V_M1_MF2_MASK, VLUXSEG5EI32_V, 0x7, 0x0 }, // 5060 + { PseudoVLUXSEG5EI32_V_M2_MF2, VLUXSEG5EI32_V, 0x7, 0x0 }, // 5061 + { PseudoVLUXSEG5EI32_V_M2_MF2_MASK, VLUXSEG5EI32_V, 0x7, 0x0 }, // 5062 + { PseudoVLUXSEG5EI32_V_MF2_MF2, VLUXSEG5EI32_V, 0x7, 0x0 }, // 5063 + { PseudoVLUXSEG5EI32_V_MF2_MF2_MASK, VLUXSEG5EI32_V, 0x7, 0x0 }, // 5064 + { PseudoVLUXSEG5EI64_V_M1_M1, VLUXSEG5EI64_V, 0x0, 0x0 }, // 5065 + { PseudoVLUXSEG5EI64_V_M1_M1_MASK, VLUXSEG5EI64_V, 0x0, 0x0 }, // 5066 + { PseudoVLUXSEG5EI64_V_M2_M1, VLUXSEG5EI64_V, 0x0, 0x0 }, // 5067 + { PseudoVLUXSEG5EI64_V_M2_M1_MASK, VLUXSEG5EI64_V, 0x0, 0x0 }, // 5068 + { PseudoVLUXSEG5EI64_V_M4_M1, VLUXSEG5EI64_V, 0x0, 0x0 }, // 5069 + { PseudoVLUXSEG5EI64_V_M4_M1_MASK, VLUXSEG5EI64_V, 0x0, 0x0 }, // 5070 + { PseudoVLUXSEG5EI64_V_M8_M1, VLUXSEG5EI64_V, 0x0, 0x0 }, // 5071 + { PseudoVLUXSEG5EI64_V_M8_M1_MASK, VLUXSEG5EI64_V, 0x0, 0x0 }, // 5072 + { PseudoVLUXSEG5EI64_V_M1_MF8, VLUXSEG5EI64_V, 0x5, 0x0 }, // 5073 + { PseudoVLUXSEG5EI64_V_M1_MF8_MASK, VLUXSEG5EI64_V, 0x5, 0x0 }, // 5074 + { PseudoVLUXSEG5EI64_V_M1_MF4, VLUXSEG5EI64_V, 0x6, 0x0 }, // 5075 + { PseudoVLUXSEG5EI64_V_M1_MF4_MASK, VLUXSEG5EI64_V, 0x6, 0x0 }, // 5076 + { PseudoVLUXSEG5EI64_V_M2_MF4, VLUXSEG5EI64_V, 0x6, 0x0 }, // 5077 + { PseudoVLUXSEG5EI64_V_M2_MF4_MASK, VLUXSEG5EI64_V, 0x6, 0x0 }, // 5078 + { PseudoVLUXSEG5EI64_V_M1_MF2, VLUXSEG5EI64_V, 0x7, 0x0 }, // 5079 + { PseudoVLUXSEG5EI64_V_M1_MF2_MASK, VLUXSEG5EI64_V, 0x7, 0x0 }, // 5080 + { PseudoVLUXSEG5EI64_V_M2_MF2, VLUXSEG5EI64_V, 0x7, 0x0 }, // 5081 + { PseudoVLUXSEG5EI64_V_M2_MF2_MASK, VLUXSEG5EI64_V, 0x7, 0x0 }, // 5082 + { PseudoVLUXSEG5EI64_V_M4_MF2, VLUXSEG5EI64_V, 0x7, 0x0 }, // 5083 + { PseudoVLUXSEG5EI64_V_M4_MF2_MASK, VLUXSEG5EI64_V, 0x7, 0x0 }, // 5084 + { PseudoVLUXSEG5EI8_V_M1_M1, VLUXSEG5EI8_V, 0x0, 0x0 }, // 5085 + { PseudoVLUXSEG5EI8_V_M1_M1_MASK, VLUXSEG5EI8_V, 0x0, 0x0 }, // 5086 + { PseudoVLUXSEG5EI8_V_MF2_M1, VLUXSEG5EI8_V, 0x0, 0x0 }, // 5087 + { PseudoVLUXSEG5EI8_V_MF2_M1_MASK, VLUXSEG5EI8_V, 0x0, 0x0 }, // 5088 + { PseudoVLUXSEG5EI8_V_MF4_M1, VLUXSEG5EI8_V, 0x0, 0x0 }, // 5089 + { PseudoVLUXSEG5EI8_V_MF4_M1_MASK, VLUXSEG5EI8_V, 0x0, 0x0 }, // 5090 + { PseudoVLUXSEG5EI8_V_MF8_M1, VLUXSEG5EI8_V, 0x0, 0x0 }, // 5091 + { PseudoVLUXSEG5EI8_V_MF8_M1_MASK, VLUXSEG5EI8_V, 0x0, 0x0 }, // 5092 + { PseudoVLUXSEG5EI8_V_MF8_MF8, VLUXSEG5EI8_V, 0x5, 0x0 }, // 5093 + { PseudoVLUXSEG5EI8_V_MF8_MF8_MASK, VLUXSEG5EI8_V, 0x5, 0x0 }, // 5094 + { PseudoVLUXSEG5EI8_V_MF4_MF4, VLUXSEG5EI8_V, 0x6, 0x0 }, // 5095 + { PseudoVLUXSEG5EI8_V_MF4_MF4_MASK, VLUXSEG5EI8_V, 0x6, 0x0 }, // 5096 + { PseudoVLUXSEG5EI8_V_MF8_MF4, VLUXSEG5EI8_V, 0x6, 0x0 }, // 5097 + { PseudoVLUXSEG5EI8_V_MF8_MF4_MASK, VLUXSEG5EI8_V, 0x6, 0x0 }, // 5098 + { PseudoVLUXSEG5EI8_V_MF2_MF2, VLUXSEG5EI8_V, 0x7, 0x0 }, // 5099 + { PseudoVLUXSEG5EI8_V_MF2_MF2_MASK, VLUXSEG5EI8_V, 0x7, 0x0 }, // 5100 + { PseudoVLUXSEG5EI8_V_MF4_MF2, VLUXSEG5EI8_V, 0x7, 0x0 }, // 5101 + { PseudoVLUXSEG5EI8_V_MF4_MF2_MASK, VLUXSEG5EI8_V, 0x7, 0x0 }, // 5102 + { PseudoVLUXSEG5EI8_V_MF8_MF2, VLUXSEG5EI8_V, 0x7, 0x0 }, // 5103 + { PseudoVLUXSEG5EI8_V_MF8_MF2_MASK, VLUXSEG5EI8_V, 0x7, 0x0 }, // 5104 + { PseudoVLUXSEG6EI16_V_M1_M1, VLUXSEG6EI16_V, 0x0, 0x0 }, // 5105 + { PseudoVLUXSEG6EI16_V_M1_M1_MASK, VLUXSEG6EI16_V, 0x0, 0x0 }, // 5106 + { PseudoVLUXSEG6EI16_V_M2_M1, VLUXSEG6EI16_V, 0x0, 0x0 }, // 5107 + { PseudoVLUXSEG6EI16_V_M2_M1_MASK, VLUXSEG6EI16_V, 0x0, 0x0 }, // 5108 + { PseudoVLUXSEG6EI16_V_MF2_M1, VLUXSEG6EI16_V, 0x0, 0x0 }, // 5109 + { PseudoVLUXSEG6EI16_V_MF2_M1_MASK, VLUXSEG6EI16_V, 0x0, 0x0 }, // 5110 + { PseudoVLUXSEG6EI16_V_MF4_M1, VLUXSEG6EI16_V, 0x0, 0x0 }, // 5111 + { PseudoVLUXSEG6EI16_V_MF4_M1_MASK, VLUXSEG6EI16_V, 0x0, 0x0 }, // 5112 + { PseudoVLUXSEG6EI16_V_MF4_MF8, VLUXSEG6EI16_V, 0x5, 0x0 }, // 5113 + { PseudoVLUXSEG6EI16_V_MF4_MF8_MASK, VLUXSEG6EI16_V, 0x5, 0x0 }, // 5114 + { PseudoVLUXSEG6EI16_V_MF2_MF4, VLUXSEG6EI16_V, 0x6, 0x0 }, // 5115 + { PseudoVLUXSEG6EI16_V_MF2_MF4_MASK, VLUXSEG6EI16_V, 0x6, 0x0 }, // 5116 + { PseudoVLUXSEG6EI16_V_MF4_MF4, VLUXSEG6EI16_V, 0x6, 0x0 }, // 5117 + { PseudoVLUXSEG6EI16_V_MF4_MF4_MASK, VLUXSEG6EI16_V, 0x6, 0x0 }, // 5118 + { PseudoVLUXSEG6EI16_V_M1_MF2, VLUXSEG6EI16_V, 0x7, 0x0 }, // 5119 + { PseudoVLUXSEG6EI16_V_M1_MF2_MASK, VLUXSEG6EI16_V, 0x7, 0x0 }, // 5120 + { PseudoVLUXSEG6EI16_V_MF2_MF2, VLUXSEG6EI16_V, 0x7, 0x0 }, // 5121 + { PseudoVLUXSEG6EI16_V_MF2_MF2_MASK, VLUXSEG6EI16_V, 0x7, 0x0 }, // 5122 + { PseudoVLUXSEG6EI16_V_MF4_MF2, VLUXSEG6EI16_V, 0x7, 0x0 }, // 5123 + { PseudoVLUXSEG6EI16_V_MF4_MF2_MASK, VLUXSEG6EI16_V, 0x7, 0x0 }, // 5124 + { PseudoVLUXSEG6EI32_V_M1_M1, VLUXSEG6EI32_V, 0x0, 0x0 }, // 5125 + { PseudoVLUXSEG6EI32_V_M1_M1_MASK, VLUXSEG6EI32_V, 0x0, 0x0 }, // 5126 + { PseudoVLUXSEG6EI32_V_M2_M1, VLUXSEG6EI32_V, 0x0, 0x0 }, // 5127 + { PseudoVLUXSEG6EI32_V_M2_M1_MASK, VLUXSEG6EI32_V, 0x0, 0x0 }, // 5128 + { PseudoVLUXSEG6EI32_V_M4_M1, VLUXSEG6EI32_V, 0x0, 0x0 }, // 5129 + { PseudoVLUXSEG6EI32_V_M4_M1_MASK, VLUXSEG6EI32_V, 0x0, 0x0 }, // 5130 + { PseudoVLUXSEG6EI32_V_MF2_M1, VLUXSEG6EI32_V, 0x0, 0x0 }, // 5131 + { PseudoVLUXSEG6EI32_V_MF2_M1_MASK, VLUXSEG6EI32_V, 0x0, 0x0 }, // 5132 + { PseudoVLUXSEG6EI32_V_MF2_MF8, VLUXSEG6EI32_V, 0x5, 0x0 }, // 5133 + { PseudoVLUXSEG6EI32_V_MF2_MF8_MASK, VLUXSEG6EI32_V, 0x5, 0x0 }, // 5134 + { PseudoVLUXSEG6EI32_V_M1_MF4, VLUXSEG6EI32_V, 0x6, 0x0 }, // 5135 + { PseudoVLUXSEG6EI32_V_M1_MF4_MASK, VLUXSEG6EI32_V, 0x6, 0x0 }, // 5136 + { PseudoVLUXSEG6EI32_V_MF2_MF4, VLUXSEG6EI32_V, 0x6, 0x0 }, // 5137 + { PseudoVLUXSEG6EI32_V_MF2_MF4_MASK, VLUXSEG6EI32_V, 0x6, 0x0 }, // 5138 + { PseudoVLUXSEG6EI32_V_M1_MF2, VLUXSEG6EI32_V, 0x7, 0x0 }, // 5139 + { PseudoVLUXSEG6EI32_V_M1_MF2_MASK, VLUXSEG6EI32_V, 0x7, 0x0 }, // 5140 + { PseudoVLUXSEG6EI32_V_M2_MF2, VLUXSEG6EI32_V, 0x7, 0x0 }, // 5141 + { PseudoVLUXSEG6EI32_V_M2_MF2_MASK, VLUXSEG6EI32_V, 0x7, 0x0 }, // 5142 + { PseudoVLUXSEG6EI32_V_MF2_MF2, VLUXSEG6EI32_V, 0x7, 0x0 }, // 5143 + { PseudoVLUXSEG6EI32_V_MF2_MF2_MASK, VLUXSEG6EI32_V, 0x7, 0x0 }, // 5144 + { PseudoVLUXSEG6EI64_V_M1_M1, VLUXSEG6EI64_V, 0x0, 0x0 }, // 5145 + { PseudoVLUXSEG6EI64_V_M1_M1_MASK, VLUXSEG6EI64_V, 0x0, 0x0 }, // 5146 + { PseudoVLUXSEG6EI64_V_M2_M1, VLUXSEG6EI64_V, 0x0, 0x0 }, // 5147 + { PseudoVLUXSEG6EI64_V_M2_M1_MASK, VLUXSEG6EI64_V, 0x0, 0x0 }, // 5148 + { PseudoVLUXSEG6EI64_V_M4_M1, VLUXSEG6EI64_V, 0x0, 0x0 }, // 5149 + { PseudoVLUXSEG6EI64_V_M4_M1_MASK, VLUXSEG6EI64_V, 0x0, 0x0 }, // 5150 + { PseudoVLUXSEG6EI64_V_M8_M1, VLUXSEG6EI64_V, 0x0, 0x0 }, // 5151 + { PseudoVLUXSEG6EI64_V_M8_M1_MASK, VLUXSEG6EI64_V, 0x0, 0x0 }, // 5152 + { PseudoVLUXSEG6EI64_V_M1_MF8, VLUXSEG6EI64_V, 0x5, 0x0 }, // 5153 + { PseudoVLUXSEG6EI64_V_M1_MF8_MASK, VLUXSEG6EI64_V, 0x5, 0x0 }, // 5154 + { PseudoVLUXSEG6EI64_V_M1_MF4, VLUXSEG6EI64_V, 0x6, 0x0 }, // 5155 + { PseudoVLUXSEG6EI64_V_M1_MF4_MASK, VLUXSEG6EI64_V, 0x6, 0x0 }, // 5156 + { PseudoVLUXSEG6EI64_V_M2_MF4, VLUXSEG6EI64_V, 0x6, 0x0 }, // 5157 + { PseudoVLUXSEG6EI64_V_M2_MF4_MASK, VLUXSEG6EI64_V, 0x6, 0x0 }, // 5158 + { PseudoVLUXSEG6EI64_V_M1_MF2, VLUXSEG6EI64_V, 0x7, 0x0 }, // 5159 + { PseudoVLUXSEG6EI64_V_M1_MF2_MASK, VLUXSEG6EI64_V, 0x7, 0x0 }, // 5160 + { PseudoVLUXSEG6EI64_V_M2_MF2, VLUXSEG6EI64_V, 0x7, 0x0 }, // 5161 + { PseudoVLUXSEG6EI64_V_M2_MF2_MASK, VLUXSEG6EI64_V, 0x7, 0x0 }, // 5162 + { PseudoVLUXSEG6EI64_V_M4_MF2, VLUXSEG6EI64_V, 0x7, 0x0 }, // 5163 + { PseudoVLUXSEG6EI64_V_M4_MF2_MASK, VLUXSEG6EI64_V, 0x7, 0x0 }, // 5164 + { PseudoVLUXSEG6EI8_V_M1_M1, VLUXSEG6EI8_V, 0x0, 0x0 }, // 5165 + { PseudoVLUXSEG6EI8_V_M1_M1_MASK, VLUXSEG6EI8_V, 0x0, 0x0 }, // 5166 + { PseudoVLUXSEG6EI8_V_MF2_M1, VLUXSEG6EI8_V, 0x0, 0x0 }, // 5167 + { PseudoVLUXSEG6EI8_V_MF2_M1_MASK, VLUXSEG6EI8_V, 0x0, 0x0 }, // 5168 + { PseudoVLUXSEG6EI8_V_MF4_M1, VLUXSEG6EI8_V, 0x0, 0x0 }, // 5169 + { PseudoVLUXSEG6EI8_V_MF4_M1_MASK, VLUXSEG6EI8_V, 0x0, 0x0 }, // 5170 + { PseudoVLUXSEG6EI8_V_MF8_M1, VLUXSEG6EI8_V, 0x0, 0x0 }, // 5171 + { PseudoVLUXSEG6EI8_V_MF8_M1_MASK, VLUXSEG6EI8_V, 0x0, 0x0 }, // 5172 + { PseudoVLUXSEG6EI8_V_MF8_MF8, VLUXSEG6EI8_V, 0x5, 0x0 }, // 5173 + { PseudoVLUXSEG6EI8_V_MF8_MF8_MASK, VLUXSEG6EI8_V, 0x5, 0x0 }, // 5174 + { PseudoVLUXSEG6EI8_V_MF4_MF4, VLUXSEG6EI8_V, 0x6, 0x0 }, // 5175 + { PseudoVLUXSEG6EI8_V_MF4_MF4_MASK, VLUXSEG6EI8_V, 0x6, 0x0 }, // 5176 + { PseudoVLUXSEG6EI8_V_MF8_MF4, VLUXSEG6EI8_V, 0x6, 0x0 }, // 5177 + { PseudoVLUXSEG6EI8_V_MF8_MF4_MASK, VLUXSEG6EI8_V, 0x6, 0x0 }, // 5178 + { PseudoVLUXSEG6EI8_V_MF2_MF2, VLUXSEG6EI8_V, 0x7, 0x0 }, // 5179 + { PseudoVLUXSEG6EI8_V_MF2_MF2_MASK, VLUXSEG6EI8_V, 0x7, 0x0 }, // 5180 + { PseudoVLUXSEG6EI8_V_MF4_MF2, VLUXSEG6EI8_V, 0x7, 0x0 }, // 5181 + { PseudoVLUXSEG6EI8_V_MF4_MF2_MASK, VLUXSEG6EI8_V, 0x7, 0x0 }, // 5182 + { PseudoVLUXSEG6EI8_V_MF8_MF2, VLUXSEG6EI8_V, 0x7, 0x0 }, // 5183 + { PseudoVLUXSEG6EI8_V_MF8_MF2_MASK, VLUXSEG6EI8_V, 0x7, 0x0 }, // 5184 + { PseudoVLUXSEG7EI16_V_M1_M1, VLUXSEG7EI16_V, 0x0, 0x0 }, // 5185 + { PseudoVLUXSEG7EI16_V_M1_M1_MASK, VLUXSEG7EI16_V, 0x0, 0x0 }, // 5186 + { PseudoVLUXSEG7EI16_V_M2_M1, VLUXSEG7EI16_V, 0x0, 0x0 }, // 5187 + { PseudoVLUXSEG7EI16_V_M2_M1_MASK, VLUXSEG7EI16_V, 0x0, 0x0 }, // 5188 + { PseudoVLUXSEG7EI16_V_MF2_M1, VLUXSEG7EI16_V, 0x0, 0x0 }, // 5189 + { PseudoVLUXSEG7EI16_V_MF2_M1_MASK, VLUXSEG7EI16_V, 0x0, 0x0 }, // 5190 + { PseudoVLUXSEG7EI16_V_MF4_M1, VLUXSEG7EI16_V, 0x0, 0x0 }, // 5191 + { PseudoVLUXSEG7EI16_V_MF4_M1_MASK, VLUXSEG7EI16_V, 0x0, 0x0 }, // 5192 + { PseudoVLUXSEG7EI16_V_MF4_MF8, VLUXSEG7EI16_V, 0x5, 0x0 }, // 5193 + { PseudoVLUXSEG7EI16_V_MF4_MF8_MASK, VLUXSEG7EI16_V, 0x5, 0x0 }, // 5194 + { PseudoVLUXSEG7EI16_V_MF2_MF4, VLUXSEG7EI16_V, 0x6, 0x0 }, // 5195 + { PseudoVLUXSEG7EI16_V_MF2_MF4_MASK, VLUXSEG7EI16_V, 0x6, 0x0 }, // 5196 + { PseudoVLUXSEG7EI16_V_MF4_MF4, VLUXSEG7EI16_V, 0x6, 0x0 }, // 5197 + { PseudoVLUXSEG7EI16_V_MF4_MF4_MASK, VLUXSEG7EI16_V, 0x6, 0x0 }, // 5198 + { PseudoVLUXSEG7EI16_V_M1_MF2, VLUXSEG7EI16_V, 0x7, 0x0 }, // 5199 + { PseudoVLUXSEG7EI16_V_M1_MF2_MASK, VLUXSEG7EI16_V, 0x7, 0x0 }, // 5200 + { PseudoVLUXSEG7EI16_V_MF2_MF2, VLUXSEG7EI16_V, 0x7, 0x0 }, // 5201 + { PseudoVLUXSEG7EI16_V_MF2_MF2_MASK, VLUXSEG7EI16_V, 0x7, 0x0 }, // 5202 + { PseudoVLUXSEG7EI16_V_MF4_MF2, VLUXSEG7EI16_V, 0x7, 0x0 }, // 5203 + { PseudoVLUXSEG7EI16_V_MF4_MF2_MASK, VLUXSEG7EI16_V, 0x7, 0x0 }, // 5204 + { PseudoVLUXSEG7EI32_V_M1_M1, VLUXSEG7EI32_V, 0x0, 0x0 }, // 5205 + { PseudoVLUXSEG7EI32_V_M1_M1_MASK, VLUXSEG7EI32_V, 0x0, 0x0 }, // 5206 + { PseudoVLUXSEG7EI32_V_M2_M1, VLUXSEG7EI32_V, 0x0, 0x0 }, // 5207 + { PseudoVLUXSEG7EI32_V_M2_M1_MASK, VLUXSEG7EI32_V, 0x0, 0x0 }, // 5208 + { PseudoVLUXSEG7EI32_V_M4_M1, VLUXSEG7EI32_V, 0x0, 0x0 }, // 5209 + { PseudoVLUXSEG7EI32_V_M4_M1_MASK, VLUXSEG7EI32_V, 0x0, 0x0 }, // 5210 + { PseudoVLUXSEG7EI32_V_MF2_M1, VLUXSEG7EI32_V, 0x0, 0x0 }, // 5211 + { PseudoVLUXSEG7EI32_V_MF2_M1_MASK, VLUXSEG7EI32_V, 0x0, 0x0 }, // 5212 + { PseudoVLUXSEG7EI32_V_MF2_MF8, VLUXSEG7EI32_V, 0x5, 0x0 }, // 5213 + { PseudoVLUXSEG7EI32_V_MF2_MF8_MASK, VLUXSEG7EI32_V, 0x5, 0x0 }, // 5214 + { PseudoVLUXSEG7EI32_V_M1_MF4, VLUXSEG7EI32_V, 0x6, 0x0 }, // 5215 + { PseudoVLUXSEG7EI32_V_M1_MF4_MASK, VLUXSEG7EI32_V, 0x6, 0x0 }, // 5216 + { PseudoVLUXSEG7EI32_V_MF2_MF4, VLUXSEG7EI32_V, 0x6, 0x0 }, // 5217 + { PseudoVLUXSEG7EI32_V_MF2_MF4_MASK, VLUXSEG7EI32_V, 0x6, 0x0 }, // 5218 + { PseudoVLUXSEG7EI32_V_M1_MF2, VLUXSEG7EI32_V, 0x7, 0x0 }, // 5219 + { PseudoVLUXSEG7EI32_V_M1_MF2_MASK, VLUXSEG7EI32_V, 0x7, 0x0 }, // 5220 + { PseudoVLUXSEG7EI32_V_M2_MF2, VLUXSEG7EI32_V, 0x7, 0x0 }, // 5221 + { PseudoVLUXSEG7EI32_V_M2_MF2_MASK, VLUXSEG7EI32_V, 0x7, 0x0 }, // 5222 + { PseudoVLUXSEG7EI32_V_MF2_MF2, VLUXSEG7EI32_V, 0x7, 0x0 }, // 5223 + { PseudoVLUXSEG7EI32_V_MF2_MF2_MASK, VLUXSEG7EI32_V, 0x7, 0x0 }, // 5224 + { PseudoVLUXSEG7EI64_V_M1_M1, VLUXSEG7EI64_V, 0x0, 0x0 }, // 5225 + { PseudoVLUXSEG7EI64_V_M1_M1_MASK, VLUXSEG7EI64_V, 0x0, 0x0 }, // 5226 + { PseudoVLUXSEG7EI64_V_M2_M1, VLUXSEG7EI64_V, 0x0, 0x0 }, // 5227 + { PseudoVLUXSEG7EI64_V_M2_M1_MASK, VLUXSEG7EI64_V, 0x0, 0x0 }, // 5228 + { PseudoVLUXSEG7EI64_V_M4_M1, VLUXSEG7EI64_V, 0x0, 0x0 }, // 5229 + { PseudoVLUXSEG7EI64_V_M4_M1_MASK, VLUXSEG7EI64_V, 0x0, 0x0 }, // 5230 + { PseudoVLUXSEG7EI64_V_M8_M1, VLUXSEG7EI64_V, 0x0, 0x0 }, // 5231 + { PseudoVLUXSEG7EI64_V_M8_M1_MASK, VLUXSEG7EI64_V, 0x0, 0x0 }, // 5232 + { PseudoVLUXSEG7EI64_V_M1_MF8, VLUXSEG7EI64_V, 0x5, 0x0 }, // 5233 + { PseudoVLUXSEG7EI64_V_M1_MF8_MASK, VLUXSEG7EI64_V, 0x5, 0x0 }, // 5234 + { PseudoVLUXSEG7EI64_V_M1_MF4, VLUXSEG7EI64_V, 0x6, 0x0 }, // 5235 + { PseudoVLUXSEG7EI64_V_M1_MF4_MASK, VLUXSEG7EI64_V, 0x6, 0x0 }, // 5236 + { PseudoVLUXSEG7EI64_V_M2_MF4, VLUXSEG7EI64_V, 0x6, 0x0 }, // 5237 + { PseudoVLUXSEG7EI64_V_M2_MF4_MASK, VLUXSEG7EI64_V, 0x6, 0x0 }, // 5238 + { PseudoVLUXSEG7EI64_V_M1_MF2, VLUXSEG7EI64_V, 0x7, 0x0 }, // 5239 + { PseudoVLUXSEG7EI64_V_M1_MF2_MASK, VLUXSEG7EI64_V, 0x7, 0x0 }, // 5240 + { PseudoVLUXSEG7EI64_V_M2_MF2, VLUXSEG7EI64_V, 0x7, 0x0 }, // 5241 + { PseudoVLUXSEG7EI64_V_M2_MF2_MASK, VLUXSEG7EI64_V, 0x7, 0x0 }, // 5242 + { PseudoVLUXSEG7EI64_V_M4_MF2, VLUXSEG7EI64_V, 0x7, 0x0 }, // 5243 + { PseudoVLUXSEG7EI64_V_M4_MF2_MASK, VLUXSEG7EI64_V, 0x7, 0x0 }, // 5244 + { PseudoVLUXSEG7EI8_V_M1_M1, VLUXSEG7EI8_V, 0x0, 0x0 }, // 5245 + { PseudoVLUXSEG7EI8_V_M1_M1_MASK, VLUXSEG7EI8_V, 0x0, 0x0 }, // 5246 + { PseudoVLUXSEG7EI8_V_MF2_M1, VLUXSEG7EI8_V, 0x0, 0x0 }, // 5247 + { PseudoVLUXSEG7EI8_V_MF2_M1_MASK, VLUXSEG7EI8_V, 0x0, 0x0 }, // 5248 + { PseudoVLUXSEG7EI8_V_MF4_M1, VLUXSEG7EI8_V, 0x0, 0x0 }, // 5249 + { PseudoVLUXSEG7EI8_V_MF4_M1_MASK, VLUXSEG7EI8_V, 0x0, 0x0 }, // 5250 + { PseudoVLUXSEG7EI8_V_MF8_M1, VLUXSEG7EI8_V, 0x0, 0x0 }, // 5251 + { PseudoVLUXSEG7EI8_V_MF8_M1_MASK, VLUXSEG7EI8_V, 0x0, 0x0 }, // 5252 + { PseudoVLUXSEG7EI8_V_MF8_MF8, VLUXSEG7EI8_V, 0x5, 0x0 }, // 5253 + { PseudoVLUXSEG7EI8_V_MF8_MF8_MASK, VLUXSEG7EI8_V, 0x5, 0x0 }, // 5254 + { PseudoVLUXSEG7EI8_V_MF4_MF4, VLUXSEG7EI8_V, 0x6, 0x0 }, // 5255 + { PseudoVLUXSEG7EI8_V_MF4_MF4_MASK, VLUXSEG7EI8_V, 0x6, 0x0 }, // 5256 + { PseudoVLUXSEG7EI8_V_MF8_MF4, VLUXSEG7EI8_V, 0x6, 0x0 }, // 5257 + { PseudoVLUXSEG7EI8_V_MF8_MF4_MASK, VLUXSEG7EI8_V, 0x6, 0x0 }, // 5258 + { PseudoVLUXSEG7EI8_V_MF2_MF2, VLUXSEG7EI8_V, 0x7, 0x0 }, // 5259 + { PseudoVLUXSEG7EI8_V_MF2_MF2_MASK, VLUXSEG7EI8_V, 0x7, 0x0 }, // 5260 + { PseudoVLUXSEG7EI8_V_MF4_MF2, VLUXSEG7EI8_V, 0x7, 0x0 }, // 5261 + { PseudoVLUXSEG7EI8_V_MF4_MF2_MASK, VLUXSEG7EI8_V, 0x7, 0x0 }, // 5262 + { PseudoVLUXSEG7EI8_V_MF8_MF2, VLUXSEG7EI8_V, 0x7, 0x0 }, // 5263 + { PseudoVLUXSEG7EI8_V_MF8_MF2_MASK, VLUXSEG7EI8_V, 0x7, 0x0 }, // 5264 + { PseudoVLUXSEG8EI16_V_M1_M1, VLUXSEG8EI16_V, 0x0, 0x0 }, // 5265 + { PseudoVLUXSEG8EI16_V_M1_M1_MASK, VLUXSEG8EI16_V, 0x0, 0x0 }, // 5266 + { PseudoVLUXSEG8EI16_V_M2_M1, VLUXSEG8EI16_V, 0x0, 0x0 }, // 5267 + { PseudoVLUXSEG8EI16_V_M2_M1_MASK, VLUXSEG8EI16_V, 0x0, 0x0 }, // 5268 + { PseudoVLUXSEG8EI16_V_MF2_M1, VLUXSEG8EI16_V, 0x0, 0x0 }, // 5269 + { PseudoVLUXSEG8EI16_V_MF2_M1_MASK, VLUXSEG8EI16_V, 0x0, 0x0 }, // 5270 + { PseudoVLUXSEG8EI16_V_MF4_M1, VLUXSEG8EI16_V, 0x0, 0x0 }, // 5271 + { PseudoVLUXSEG8EI16_V_MF4_M1_MASK, VLUXSEG8EI16_V, 0x0, 0x0 }, // 5272 + { PseudoVLUXSEG8EI16_V_MF4_MF8, VLUXSEG8EI16_V, 0x5, 0x0 }, // 5273 + { PseudoVLUXSEG8EI16_V_MF4_MF8_MASK, VLUXSEG8EI16_V, 0x5, 0x0 }, // 5274 + { PseudoVLUXSEG8EI16_V_MF2_MF4, VLUXSEG8EI16_V, 0x6, 0x0 }, // 5275 + { PseudoVLUXSEG8EI16_V_MF2_MF4_MASK, VLUXSEG8EI16_V, 0x6, 0x0 }, // 5276 + { PseudoVLUXSEG8EI16_V_MF4_MF4, VLUXSEG8EI16_V, 0x6, 0x0 }, // 5277 + { PseudoVLUXSEG8EI16_V_MF4_MF4_MASK, VLUXSEG8EI16_V, 0x6, 0x0 }, // 5278 + { PseudoVLUXSEG8EI16_V_M1_MF2, VLUXSEG8EI16_V, 0x7, 0x0 }, // 5279 + { PseudoVLUXSEG8EI16_V_M1_MF2_MASK, VLUXSEG8EI16_V, 0x7, 0x0 }, // 5280 + { PseudoVLUXSEG8EI16_V_MF2_MF2, VLUXSEG8EI16_V, 0x7, 0x0 }, // 5281 + { PseudoVLUXSEG8EI16_V_MF2_MF2_MASK, VLUXSEG8EI16_V, 0x7, 0x0 }, // 5282 + { PseudoVLUXSEG8EI16_V_MF4_MF2, VLUXSEG8EI16_V, 0x7, 0x0 }, // 5283 + { PseudoVLUXSEG8EI16_V_MF4_MF2_MASK, VLUXSEG8EI16_V, 0x7, 0x0 }, // 5284 + { PseudoVLUXSEG8EI32_V_M1_M1, VLUXSEG8EI32_V, 0x0, 0x0 }, // 5285 + { PseudoVLUXSEG8EI32_V_M1_M1_MASK, VLUXSEG8EI32_V, 0x0, 0x0 }, // 5286 + { PseudoVLUXSEG8EI32_V_M2_M1, VLUXSEG8EI32_V, 0x0, 0x0 }, // 5287 + { PseudoVLUXSEG8EI32_V_M2_M1_MASK, VLUXSEG8EI32_V, 0x0, 0x0 }, // 5288 + { PseudoVLUXSEG8EI32_V_M4_M1, VLUXSEG8EI32_V, 0x0, 0x0 }, // 5289 + { PseudoVLUXSEG8EI32_V_M4_M1_MASK, VLUXSEG8EI32_V, 0x0, 0x0 }, // 5290 + { PseudoVLUXSEG8EI32_V_MF2_M1, VLUXSEG8EI32_V, 0x0, 0x0 }, // 5291 + { PseudoVLUXSEG8EI32_V_MF2_M1_MASK, VLUXSEG8EI32_V, 0x0, 0x0 }, // 5292 + { PseudoVLUXSEG8EI32_V_MF2_MF8, VLUXSEG8EI32_V, 0x5, 0x0 }, // 5293 + { PseudoVLUXSEG8EI32_V_MF2_MF8_MASK, VLUXSEG8EI32_V, 0x5, 0x0 }, // 5294 + { PseudoVLUXSEG8EI32_V_M1_MF4, VLUXSEG8EI32_V, 0x6, 0x0 }, // 5295 + { PseudoVLUXSEG8EI32_V_M1_MF4_MASK, VLUXSEG8EI32_V, 0x6, 0x0 }, // 5296 + { PseudoVLUXSEG8EI32_V_MF2_MF4, VLUXSEG8EI32_V, 0x6, 0x0 }, // 5297 + { PseudoVLUXSEG8EI32_V_MF2_MF4_MASK, VLUXSEG8EI32_V, 0x6, 0x0 }, // 5298 + { PseudoVLUXSEG8EI32_V_M1_MF2, VLUXSEG8EI32_V, 0x7, 0x0 }, // 5299 + { PseudoVLUXSEG8EI32_V_M1_MF2_MASK, VLUXSEG8EI32_V, 0x7, 0x0 }, // 5300 + { PseudoVLUXSEG8EI32_V_M2_MF2, VLUXSEG8EI32_V, 0x7, 0x0 }, // 5301 + { PseudoVLUXSEG8EI32_V_M2_MF2_MASK, VLUXSEG8EI32_V, 0x7, 0x0 }, // 5302 + { PseudoVLUXSEG8EI32_V_MF2_MF2, VLUXSEG8EI32_V, 0x7, 0x0 }, // 5303 + { PseudoVLUXSEG8EI32_V_MF2_MF2_MASK, VLUXSEG8EI32_V, 0x7, 0x0 }, // 5304 + { PseudoVLUXSEG8EI64_V_M1_M1, VLUXSEG8EI64_V, 0x0, 0x0 }, // 5305 + { PseudoVLUXSEG8EI64_V_M1_M1_MASK, VLUXSEG8EI64_V, 0x0, 0x0 }, // 5306 + { PseudoVLUXSEG8EI64_V_M2_M1, VLUXSEG8EI64_V, 0x0, 0x0 }, // 5307 + { PseudoVLUXSEG8EI64_V_M2_M1_MASK, VLUXSEG8EI64_V, 0x0, 0x0 }, // 5308 + { PseudoVLUXSEG8EI64_V_M4_M1, VLUXSEG8EI64_V, 0x0, 0x0 }, // 5309 + { PseudoVLUXSEG8EI64_V_M4_M1_MASK, VLUXSEG8EI64_V, 0x0, 0x0 }, // 5310 + { PseudoVLUXSEG8EI64_V_M8_M1, VLUXSEG8EI64_V, 0x0, 0x0 }, // 5311 + { PseudoVLUXSEG8EI64_V_M8_M1_MASK, VLUXSEG8EI64_V, 0x0, 0x0 }, // 5312 + { PseudoVLUXSEG8EI64_V_M1_MF8, VLUXSEG8EI64_V, 0x5, 0x0 }, // 5313 + { PseudoVLUXSEG8EI64_V_M1_MF8_MASK, VLUXSEG8EI64_V, 0x5, 0x0 }, // 5314 + { PseudoVLUXSEG8EI64_V_M1_MF4, VLUXSEG8EI64_V, 0x6, 0x0 }, // 5315 + { PseudoVLUXSEG8EI64_V_M1_MF4_MASK, VLUXSEG8EI64_V, 0x6, 0x0 }, // 5316 + { PseudoVLUXSEG8EI64_V_M2_MF4, VLUXSEG8EI64_V, 0x6, 0x0 }, // 5317 + { PseudoVLUXSEG8EI64_V_M2_MF4_MASK, VLUXSEG8EI64_V, 0x6, 0x0 }, // 5318 + { PseudoVLUXSEG8EI64_V_M1_MF2, VLUXSEG8EI64_V, 0x7, 0x0 }, // 5319 + { PseudoVLUXSEG8EI64_V_M1_MF2_MASK, VLUXSEG8EI64_V, 0x7, 0x0 }, // 5320 + { PseudoVLUXSEG8EI64_V_M2_MF2, VLUXSEG8EI64_V, 0x7, 0x0 }, // 5321 + { PseudoVLUXSEG8EI64_V_M2_MF2_MASK, VLUXSEG8EI64_V, 0x7, 0x0 }, // 5322 + { PseudoVLUXSEG8EI64_V_M4_MF2, VLUXSEG8EI64_V, 0x7, 0x0 }, // 5323 + { PseudoVLUXSEG8EI64_V_M4_MF2_MASK, VLUXSEG8EI64_V, 0x7, 0x0 }, // 5324 + { PseudoVLUXSEG8EI8_V_M1_M1, VLUXSEG8EI8_V, 0x0, 0x0 }, // 5325 + { PseudoVLUXSEG8EI8_V_M1_M1_MASK, VLUXSEG8EI8_V, 0x0, 0x0 }, // 5326 + { PseudoVLUXSEG8EI8_V_MF2_M1, VLUXSEG8EI8_V, 0x0, 0x0 }, // 5327 + { PseudoVLUXSEG8EI8_V_MF2_M1_MASK, VLUXSEG8EI8_V, 0x0, 0x0 }, // 5328 + { PseudoVLUXSEG8EI8_V_MF4_M1, VLUXSEG8EI8_V, 0x0, 0x0 }, // 5329 + { PseudoVLUXSEG8EI8_V_MF4_M1_MASK, VLUXSEG8EI8_V, 0x0, 0x0 }, // 5330 + { PseudoVLUXSEG8EI8_V_MF8_M1, VLUXSEG8EI8_V, 0x0, 0x0 }, // 5331 + { PseudoVLUXSEG8EI8_V_MF8_M1_MASK, VLUXSEG8EI8_V, 0x0, 0x0 }, // 5332 + { PseudoVLUXSEG8EI8_V_MF8_MF8, VLUXSEG8EI8_V, 0x5, 0x0 }, // 5333 + { PseudoVLUXSEG8EI8_V_MF8_MF8_MASK, VLUXSEG8EI8_V, 0x5, 0x0 }, // 5334 + { PseudoVLUXSEG8EI8_V_MF4_MF4, VLUXSEG8EI8_V, 0x6, 0x0 }, // 5335 + { PseudoVLUXSEG8EI8_V_MF4_MF4_MASK, VLUXSEG8EI8_V, 0x6, 0x0 }, // 5336 + { PseudoVLUXSEG8EI8_V_MF8_MF4, VLUXSEG8EI8_V, 0x6, 0x0 }, // 5337 + { PseudoVLUXSEG8EI8_V_MF8_MF4_MASK, VLUXSEG8EI8_V, 0x6, 0x0 }, // 5338 + { PseudoVLUXSEG8EI8_V_MF2_MF2, VLUXSEG8EI8_V, 0x7, 0x0 }, // 5339 + { PseudoVLUXSEG8EI8_V_MF2_MF2_MASK, VLUXSEG8EI8_V, 0x7, 0x0 }, // 5340 + { PseudoVLUXSEG8EI8_V_MF4_MF2, VLUXSEG8EI8_V, 0x7, 0x0 }, // 5341 + { PseudoVLUXSEG8EI8_V_MF4_MF2_MASK, VLUXSEG8EI8_V, 0x7, 0x0 }, // 5342 + { PseudoVLUXSEG8EI8_V_MF8_MF2, VLUXSEG8EI8_V, 0x7, 0x0 }, // 5343 + { PseudoVLUXSEG8EI8_V_MF8_MF2_MASK, VLUXSEG8EI8_V, 0x7, 0x0 }, // 5344 + { PseudoVMACC_VV_M1, VMACC_VV, 0x0, 0x0 }, // 5345 + { PseudoVMACC_VV_M1_MASK, VMACC_VV, 0x0, 0x0 }, // 5346 + { PseudoVMACC_VV_M2, VMACC_VV, 0x1, 0x0 }, // 5347 + { PseudoVMACC_VV_M2_MASK, VMACC_VV, 0x1, 0x0 }, // 5348 + { PseudoVMACC_VV_M4, VMACC_VV, 0x2, 0x0 }, // 5349 + { PseudoVMACC_VV_M4_MASK, VMACC_VV, 0x2, 0x0 }, // 5350 + { PseudoVMACC_VV_M8, VMACC_VV, 0x3, 0x0 }, // 5351 + { PseudoVMACC_VV_M8_MASK, VMACC_VV, 0x3, 0x0 }, // 5352 + { PseudoVMACC_VV_MF8, VMACC_VV, 0x5, 0x0 }, // 5353 + { PseudoVMACC_VV_MF8_MASK, VMACC_VV, 0x5, 0x0 }, // 5354 + { PseudoVMACC_VV_MF4, VMACC_VV, 0x6, 0x0 }, // 5355 + { PseudoVMACC_VV_MF4_MASK, VMACC_VV, 0x6, 0x0 }, // 5356 + { PseudoVMACC_VV_MF2, VMACC_VV, 0x7, 0x0 }, // 5357 + { PseudoVMACC_VV_MF2_MASK, VMACC_VV, 0x7, 0x0 }, // 5358 + { PseudoVMACC_VX_M1, VMACC_VX, 0x0, 0x0 }, // 5359 + { PseudoVMACC_VX_M1_MASK, VMACC_VX, 0x0, 0x0 }, // 5360 + { PseudoVMACC_VX_M2, VMACC_VX, 0x1, 0x0 }, // 5361 + { PseudoVMACC_VX_M2_MASK, VMACC_VX, 0x1, 0x0 }, // 5362 + { PseudoVMACC_VX_M4, VMACC_VX, 0x2, 0x0 }, // 5363 + { PseudoVMACC_VX_M4_MASK, VMACC_VX, 0x2, 0x0 }, // 5364 + { PseudoVMACC_VX_M8, VMACC_VX, 0x3, 0x0 }, // 5365 + { PseudoVMACC_VX_M8_MASK, VMACC_VX, 0x3, 0x0 }, // 5366 + { PseudoVMACC_VX_MF8, VMACC_VX, 0x5, 0x0 }, // 5367 + { PseudoVMACC_VX_MF8_MASK, VMACC_VX, 0x5, 0x0 }, // 5368 + { PseudoVMACC_VX_MF4, VMACC_VX, 0x6, 0x0 }, // 5369 + { PseudoVMACC_VX_MF4_MASK, VMACC_VX, 0x6, 0x0 }, // 5370 + { PseudoVMACC_VX_MF2, VMACC_VX, 0x7, 0x0 }, // 5371 + { PseudoVMACC_VX_MF2_MASK, VMACC_VX, 0x7, 0x0 }, // 5372 + { PseudoVMADC_VI_M1, VMADC_VI, 0x0, 0x0 }, // 5373 + { PseudoVMADC_VI_M2, VMADC_VI, 0x1, 0x0 }, // 5374 + { PseudoVMADC_VI_M4, VMADC_VI, 0x2, 0x0 }, // 5375 + { PseudoVMADC_VI_M8, VMADC_VI, 0x3, 0x0 }, // 5376 + { PseudoVMADC_VI_MF8, VMADC_VI, 0x5, 0x0 }, // 5377 + { PseudoVMADC_VI_MF4, VMADC_VI, 0x6, 0x0 }, // 5378 + { PseudoVMADC_VI_MF2, VMADC_VI, 0x7, 0x0 }, // 5379 + { PseudoVMADC_VIM_M1, VMADC_VIM, 0x0, 0x0 }, // 5380 + { PseudoVMADC_VIM_M2, VMADC_VIM, 0x1, 0x0 }, // 5381 + { PseudoVMADC_VIM_M4, VMADC_VIM, 0x2, 0x0 }, // 5382 + { PseudoVMADC_VIM_M8, VMADC_VIM, 0x3, 0x0 }, // 5383 + { PseudoVMADC_VIM_MF8, VMADC_VIM, 0x5, 0x0 }, // 5384 + { PseudoVMADC_VIM_MF4, VMADC_VIM, 0x6, 0x0 }, // 5385 + { PseudoVMADC_VIM_MF2, VMADC_VIM, 0x7, 0x0 }, // 5386 + { PseudoVMADC_VV_M1, VMADC_VV, 0x0, 0x0 }, // 5387 + { PseudoVMADC_VV_M2, VMADC_VV, 0x1, 0x0 }, // 5388 + { PseudoVMADC_VV_M4, VMADC_VV, 0x2, 0x0 }, // 5389 + { PseudoVMADC_VV_M8, VMADC_VV, 0x3, 0x0 }, // 5390 + { PseudoVMADC_VV_MF8, VMADC_VV, 0x5, 0x0 }, // 5391 + { PseudoVMADC_VV_MF4, VMADC_VV, 0x6, 0x0 }, // 5392 + { PseudoVMADC_VV_MF2, VMADC_VV, 0x7, 0x0 }, // 5393 + { PseudoVMADC_VVM_M1, VMADC_VVM, 0x0, 0x0 }, // 5394 + { PseudoVMADC_VVM_M2, VMADC_VVM, 0x1, 0x0 }, // 5395 + { PseudoVMADC_VVM_M4, VMADC_VVM, 0x2, 0x0 }, // 5396 + { PseudoVMADC_VVM_M8, VMADC_VVM, 0x3, 0x0 }, // 5397 + { PseudoVMADC_VVM_MF8, VMADC_VVM, 0x5, 0x0 }, // 5398 + { PseudoVMADC_VVM_MF4, VMADC_VVM, 0x6, 0x0 }, // 5399 + { PseudoVMADC_VVM_MF2, VMADC_VVM, 0x7, 0x0 }, // 5400 + { PseudoVMADC_VX_M1, VMADC_VX, 0x0, 0x0 }, // 5401 + { PseudoVMADC_VX_M2, VMADC_VX, 0x1, 0x0 }, // 5402 + { PseudoVMADC_VX_M4, VMADC_VX, 0x2, 0x0 }, // 5403 + { PseudoVMADC_VX_M8, VMADC_VX, 0x3, 0x0 }, // 5404 + { PseudoVMADC_VX_MF8, VMADC_VX, 0x5, 0x0 }, // 5405 + { PseudoVMADC_VX_MF4, VMADC_VX, 0x6, 0x0 }, // 5406 + { PseudoVMADC_VX_MF2, VMADC_VX, 0x7, 0x0 }, // 5407 + { PseudoVMADC_VXM_M1, VMADC_VXM, 0x0, 0x0 }, // 5408 + { PseudoVMADC_VXM_M2, VMADC_VXM, 0x1, 0x0 }, // 5409 + { PseudoVMADC_VXM_M4, VMADC_VXM, 0x2, 0x0 }, // 5410 + { PseudoVMADC_VXM_M8, VMADC_VXM, 0x3, 0x0 }, // 5411 + { PseudoVMADC_VXM_MF8, VMADC_VXM, 0x5, 0x0 }, // 5412 + { PseudoVMADC_VXM_MF4, VMADC_VXM, 0x6, 0x0 }, // 5413 + { PseudoVMADC_VXM_MF2, VMADC_VXM, 0x7, 0x0 }, // 5414 + { PseudoVMADD_VV_M1, VMADD_VV, 0x0, 0x0 }, // 5415 + { PseudoVMADD_VV_M1_MASK, VMADD_VV, 0x0, 0x0 }, // 5416 + { PseudoVMADD_VV_M2, VMADD_VV, 0x1, 0x0 }, // 5417 + { PseudoVMADD_VV_M2_MASK, VMADD_VV, 0x1, 0x0 }, // 5418 + { PseudoVMADD_VV_M4, VMADD_VV, 0x2, 0x0 }, // 5419 + { PseudoVMADD_VV_M4_MASK, VMADD_VV, 0x2, 0x0 }, // 5420 + { PseudoVMADD_VV_M8, VMADD_VV, 0x3, 0x0 }, // 5421 + { PseudoVMADD_VV_M8_MASK, VMADD_VV, 0x3, 0x0 }, // 5422 + { PseudoVMADD_VV_MF8, VMADD_VV, 0x5, 0x0 }, // 5423 + { PseudoVMADD_VV_MF8_MASK, VMADD_VV, 0x5, 0x0 }, // 5424 + { PseudoVMADD_VV_MF4, VMADD_VV, 0x6, 0x0 }, // 5425 + { PseudoVMADD_VV_MF4_MASK, VMADD_VV, 0x6, 0x0 }, // 5426 + { PseudoVMADD_VV_MF2, VMADD_VV, 0x7, 0x0 }, // 5427 + { PseudoVMADD_VV_MF2_MASK, VMADD_VV, 0x7, 0x0 }, // 5428 + { PseudoVMADD_VX_M1, VMADD_VX, 0x0, 0x0 }, // 5429 + { PseudoVMADD_VX_M1_MASK, VMADD_VX, 0x0, 0x0 }, // 5430 + { PseudoVMADD_VX_M2, VMADD_VX, 0x1, 0x0 }, // 5431 + { PseudoVMADD_VX_M2_MASK, VMADD_VX, 0x1, 0x0 }, // 5432 + { PseudoVMADD_VX_M4, VMADD_VX, 0x2, 0x0 }, // 5433 + { PseudoVMADD_VX_M4_MASK, VMADD_VX, 0x2, 0x0 }, // 5434 + { PseudoVMADD_VX_M8, VMADD_VX, 0x3, 0x0 }, // 5435 + { PseudoVMADD_VX_M8_MASK, VMADD_VX, 0x3, 0x0 }, // 5436 + { PseudoVMADD_VX_MF8, VMADD_VX, 0x5, 0x0 }, // 5437 + { PseudoVMADD_VX_MF8_MASK, VMADD_VX, 0x5, 0x0 }, // 5438 + { PseudoVMADD_VX_MF4, VMADD_VX, 0x6, 0x0 }, // 5439 + { PseudoVMADD_VX_MF4_MASK, VMADD_VX, 0x6, 0x0 }, // 5440 + { PseudoVMADD_VX_MF2, VMADD_VX, 0x7, 0x0 }, // 5441 + { PseudoVMADD_VX_MF2_MASK, VMADD_VX, 0x7, 0x0 }, // 5442 + { PseudoVMANDN_MM_M1, VMANDN_MM, 0x0, 0x0 }, // 5443 + { PseudoVMANDN_MM_M2, VMANDN_MM, 0x1, 0x0 }, // 5444 + { PseudoVMANDN_MM_M4, VMANDN_MM, 0x2, 0x0 }, // 5445 + { PseudoVMANDN_MM_M8, VMANDN_MM, 0x3, 0x0 }, // 5446 + { PseudoVMANDN_MM_MF8, VMANDN_MM, 0x5, 0x0 }, // 5447 + { PseudoVMANDN_MM_MF4, VMANDN_MM, 0x6, 0x0 }, // 5448 + { PseudoVMANDN_MM_MF2, VMANDN_MM, 0x7, 0x0 }, // 5449 + { PseudoVMAND_MM_M1, VMAND_MM, 0x0, 0x0 }, // 5450 + { PseudoVMAND_MM_M2, VMAND_MM, 0x1, 0x0 }, // 5451 + { PseudoVMAND_MM_M4, VMAND_MM, 0x2, 0x0 }, // 5452 + { PseudoVMAND_MM_M8, VMAND_MM, 0x3, 0x0 }, // 5453 + { PseudoVMAND_MM_MF8, VMAND_MM, 0x5, 0x0 }, // 5454 + { PseudoVMAND_MM_MF4, VMAND_MM, 0x6, 0x0 }, // 5455 + { PseudoVMAND_MM_MF2, VMAND_MM, 0x7, 0x0 }, // 5456 + { PseudoVMAXU_VV_M1, VMAXU_VV, 0x0, 0x0 }, // 5457 + { PseudoVMAXU_VV_M1_MASK, VMAXU_VV, 0x0, 0x0 }, // 5458 + { PseudoVMAXU_VV_M2, VMAXU_VV, 0x1, 0x0 }, // 5459 + { PseudoVMAXU_VV_M2_MASK, VMAXU_VV, 0x1, 0x0 }, // 5460 + { PseudoVMAXU_VV_M4, VMAXU_VV, 0x2, 0x0 }, // 5461 + { PseudoVMAXU_VV_M4_MASK, VMAXU_VV, 0x2, 0x0 }, // 5462 + { PseudoVMAXU_VV_M8, VMAXU_VV, 0x3, 0x0 }, // 5463 + { PseudoVMAXU_VV_M8_MASK, VMAXU_VV, 0x3, 0x0 }, // 5464 + { PseudoVMAXU_VV_MF8, VMAXU_VV, 0x5, 0x0 }, // 5465 + { PseudoVMAXU_VV_MF8_MASK, VMAXU_VV, 0x5, 0x0 }, // 5466 + { PseudoVMAXU_VV_MF4, VMAXU_VV, 0x6, 0x0 }, // 5467 + { PseudoVMAXU_VV_MF4_MASK, VMAXU_VV, 0x6, 0x0 }, // 5468 + { PseudoVMAXU_VV_MF2, VMAXU_VV, 0x7, 0x0 }, // 5469 + { PseudoVMAXU_VV_MF2_MASK, VMAXU_VV, 0x7, 0x0 }, // 5470 + { PseudoVMAXU_VX_M1, VMAXU_VX, 0x0, 0x0 }, // 5471 + { PseudoVMAXU_VX_M1_MASK, VMAXU_VX, 0x0, 0x0 }, // 5472 + { PseudoVMAXU_VX_M2, VMAXU_VX, 0x1, 0x0 }, // 5473 + { PseudoVMAXU_VX_M2_MASK, VMAXU_VX, 0x1, 0x0 }, // 5474 + { PseudoVMAXU_VX_M4, VMAXU_VX, 0x2, 0x0 }, // 5475 + { PseudoVMAXU_VX_M4_MASK, VMAXU_VX, 0x2, 0x0 }, // 5476 + { PseudoVMAXU_VX_M8, VMAXU_VX, 0x3, 0x0 }, // 5477 + { PseudoVMAXU_VX_M8_MASK, VMAXU_VX, 0x3, 0x0 }, // 5478 + { PseudoVMAXU_VX_MF8, VMAXU_VX, 0x5, 0x0 }, // 5479 + { PseudoVMAXU_VX_MF8_MASK, VMAXU_VX, 0x5, 0x0 }, // 5480 + { PseudoVMAXU_VX_MF4, VMAXU_VX, 0x6, 0x0 }, // 5481 + { PseudoVMAXU_VX_MF4_MASK, VMAXU_VX, 0x6, 0x0 }, // 5482 + { PseudoVMAXU_VX_MF2, VMAXU_VX, 0x7, 0x0 }, // 5483 + { PseudoVMAXU_VX_MF2_MASK, VMAXU_VX, 0x7, 0x0 }, // 5484 + { PseudoVMAX_VV_M1, VMAX_VV, 0x0, 0x0 }, // 5485 + { PseudoVMAX_VV_M1_MASK, VMAX_VV, 0x0, 0x0 }, // 5486 + { PseudoVMAX_VV_M2, VMAX_VV, 0x1, 0x0 }, // 5487 + { PseudoVMAX_VV_M2_MASK, VMAX_VV, 0x1, 0x0 }, // 5488 + { PseudoVMAX_VV_M4, VMAX_VV, 0x2, 0x0 }, // 5489 + { PseudoVMAX_VV_M4_MASK, VMAX_VV, 0x2, 0x0 }, // 5490 + { PseudoVMAX_VV_M8, VMAX_VV, 0x3, 0x0 }, // 5491 + { PseudoVMAX_VV_M8_MASK, VMAX_VV, 0x3, 0x0 }, // 5492 + { PseudoVMAX_VV_MF8, VMAX_VV, 0x5, 0x0 }, // 5493 + { PseudoVMAX_VV_MF8_MASK, VMAX_VV, 0x5, 0x0 }, // 5494 + { PseudoVMAX_VV_MF4, VMAX_VV, 0x6, 0x0 }, // 5495 + { PseudoVMAX_VV_MF4_MASK, VMAX_VV, 0x6, 0x0 }, // 5496 + { PseudoVMAX_VV_MF2, VMAX_VV, 0x7, 0x0 }, // 5497 + { PseudoVMAX_VV_MF2_MASK, VMAX_VV, 0x7, 0x0 }, // 5498 + { PseudoVMAX_VX_M1, VMAX_VX, 0x0, 0x0 }, // 5499 + { PseudoVMAX_VX_M1_MASK, VMAX_VX, 0x0, 0x0 }, // 5500 + { PseudoVMAX_VX_M2, VMAX_VX, 0x1, 0x0 }, // 5501 + { PseudoVMAX_VX_M2_MASK, VMAX_VX, 0x1, 0x0 }, // 5502 + { PseudoVMAX_VX_M4, VMAX_VX, 0x2, 0x0 }, // 5503 + { PseudoVMAX_VX_M4_MASK, VMAX_VX, 0x2, 0x0 }, // 5504 + { PseudoVMAX_VX_M8, VMAX_VX, 0x3, 0x0 }, // 5505 + { PseudoVMAX_VX_M8_MASK, VMAX_VX, 0x3, 0x0 }, // 5506 + { PseudoVMAX_VX_MF8, VMAX_VX, 0x5, 0x0 }, // 5507 + { PseudoVMAX_VX_MF8_MASK, VMAX_VX, 0x5, 0x0 }, // 5508 + { PseudoVMAX_VX_MF4, VMAX_VX, 0x6, 0x0 }, // 5509 + { PseudoVMAX_VX_MF4_MASK, VMAX_VX, 0x6, 0x0 }, // 5510 + { PseudoVMAX_VX_MF2, VMAX_VX, 0x7, 0x0 }, // 5511 + { PseudoVMAX_VX_MF2_MASK, VMAX_VX, 0x7, 0x0 }, // 5512 + { PseudoVMERGE_VIM_M1, VMERGE_VIM, 0x0, 0x0 }, // 5513 + { PseudoVMERGE_VIM_M2, VMERGE_VIM, 0x1, 0x0 }, // 5514 + { PseudoVMERGE_VIM_M4, VMERGE_VIM, 0x2, 0x0 }, // 5515 + { PseudoVMERGE_VIM_M8, VMERGE_VIM, 0x3, 0x0 }, // 5516 + { PseudoVMERGE_VIM_MF8, VMERGE_VIM, 0x5, 0x0 }, // 5517 + { PseudoVMERGE_VIM_MF4, VMERGE_VIM, 0x6, 0x0 }, // 5518 + { PseudoVMERGE_VIM_MF2, VMERGE_VIM, 0x7, 0x0 }, // 5519 + { PseudoVMERGE_VVM_M1, VMERGE_VVM, 0x0, 0x0 }, // 5520 + { PseudoVMERGE_VVM_M2, VMERGE_VVM, 0x1, 0x0 }, // 5521 + { PseudoVMERGE_VVM_M4, VMERGE_VVM, 0x2, 0x0 }, // 5522 + { PseudoVMERGE_VVM_M8, VMERGE_VVM, 0x3, 0x0 }, // 5523 + { PseudoVMERGE_VVM_MF8, VMERGE_VVM, 0x5, 0x0 }, // 5524 + { PseudoVMERGE_VVM_MF4, VMERGE_VVM, 0x6, 0x0 }, // 5525 + { PseudoVMERGE_VVM_MF2, VMERGE_VVM, 0x7, 0x0 }, // 5526 + { PseudoVMERGE_VXM_M1, VMERGE_VXM, 0x0, 0x0 }, // 5527 + { PseudoVMERGE_VXM_M2, VMERGE_VXM, 0x1, 0x0 }, // 5528 + { PseudoVMERGE_VXM_M4, VMERGE_VXM, 0x2, 0x0 }, // 5529 + { PseudoVMERGE_VXM_M8, VMERGE_VXM, 0x3, 0x0 }, // 5530 + { PseudoVMERGE_VXM_MF8, VMERGE_VXM, 0x5, 0x0 }, // 5531 + { PseudoVMERGE_VXM_MF4, VMERGE_VXM, 0x6, 0x0 }, // 5532 + { PseudoVMERGE_VXM_MF2, VMERGE_VXM, 0x7, 0x0 }, // 5533 + { PseudoVMFEQ_VFPR16_M1, VMFEQ_VF, 0x0, 0x0 }, // 5534 + { PseudoVMFEQ_VFPR16_M1_MASK, VMFEQ_VF, 0x0, 0x0 }, // 5535 + { PseudoVMFEQ_VFPR32_M1, VMFEQ_VF, 0x0, 0x0 }, // 5536 + { PseudoVMFEQ_VFPR32_M1_MASK, VMFEQ_VF, 0x0, 0x0 }, // 5537 + { PseudoVMFEQ_VFPR64_M1, VMFEQ_VF, 0x0, 0x0 }, // 5538 + { PseudoVMFEQ_VFPR64_M1_MASK, VMFEQ_VF, 0x0, 0x0 }, // 5539 + { PseudoVMFEQ_VFPR16_M2, VMFEQ_VF, 0x1, 0x0 }, // 5540 + { PseudoVMFEQ_VFPR16_M2_MASK, VMFEQ_VF, 0x1, 0x0 }, // 5541 + { PseudoVMFEQ_VFPR32_M2, VMFEQ_VF, 0x1, 0x0 }, // 5542 + { PseudoVMFEQ_VFPR32_M2_MASK, VMFEQ_VF, 0x1, 0x0 }, // 5543 + { PseudoVMFEQ_VFPR64_M2, VMFEQ_VF, 0x1, 0x0 }, // 5544 + { PseudoVMFEQ_VFPR64_M2_MASK, VMFEQ_VF, 0x1, 0x0 }, // 5545 + { PseudoVMFEQ_VFPR16_M4, VMFEQ_VF, 0x2, 0x0 }, // 5546 + { PseudoVMFEQ_VFPR16_M4_MASK, VMFEQ_VF, 0x2, 0x0 }, // 5547 + { PseudoVMFEQ_VFPR32_M4, VMFEQ_VF, 0x2, 0x0 }, // 5548 + { PseudoVMFEQ_VFPR32_M4_MASK, VMFEQ_VF, 0x2, 0x0 }, // 5549 + { PseudoVMFEQ_VFPR64_M4, VMFEQ_VF, 0x2, 0x0 }, // 5550 + { PseudoVMFEQ_VFPR64_M4_MASK, VMFEQ_VF, 0x2, 0x0 }, // 5551 + { PseudoVMFEQ_VFPR16_M8, VMFEQ_VF, 0x3, 0x0 }, // 5552 + { PseudoVMFEQ_VFPR16_M8_MASK, VMFEQ_VF, 0x3, 0x0 }, // 5553 + { PseudoVMFEQ_VFPR32_M8, VMFEQ_VF, 0x3, 0x0 }, // 5554 + { PseudoVMFEQ_VFPR32_M8_MASK, VMFEQ_VF, 0x3, 0x0 }, // 5555 + { PseudoVMFEQ_VFPR64_M8, VMFEQ_VF, 0x3, 0x0 }, // 5556 + { PseudoVMFEQ_VFPR64_M8_MASK, VMFEQ_VF, 0x3, 0x0 }, // 5557 + { PseudoVMFEQ_VFPR16_MF4, VMFEQ_VF, 0x6, 0x0 }, // 5558 + { PseudoVMFEQ_VFPR16_MF4_MASK, VMFEQ_VF, 0x6, 0x0 }, // 5559 + { PseudoVMFEQ_VFPR16_MF2, VMFEQ_VF, 0x7, 0x0 }, // 5560 + { PseudoVMFEQ_VFPR16_MF2_MASK, VMFEQ_VF, 0x7, 0x0 }, // 5561 + { PseudoVMFEQ_VFPR32_MF2, VMFEQ_VF, 0x7, 0x0 }, // 5562 + { PseudoVMFEQ_VFPR32_MF2_MASK, VMFEQ_VF, 0x7, 0x0 }, // 5563 + { PseudoVMFEQ_VV_M1, VMFEQ_VV, 0x0, 0x0 }, // 5564 + { PseudoVMFEQ_VV_M1_MASK, VMFEQ_VV, 0x0, 0x0 }, // 5565 + { PseudoVMFEQ_VV_M2, VMFEQ_VV, 0x1, 0x0 }, // 5566 + { PseudoVMFEQ_VV_M2_MASK, VMFEQ_VV, 0x1, 0x0 }, // 5567 + { PseudoVMFEQ_VV_M4, VMFEQ_VV, 0x2, 0x0 }, // 5568 + { PseudoVMFEQ_VV_M4_MASK, VMFEQ_VV, 0x2, 0x0 }, // 5569 + { PseudoVMFEQ_VV_M8, VMFEQ_VV, 0x3, 0x0 }, // 5570 + { PseudoVMFEQ_VV_M8_MASK, VMFEQ_VV, 0x3, 0x0 }, // 5571 + { PseudoVMFEQ_VV_MF4, VMFEQ_VV, 0x6, 0x0 }, // 5572 + { PseudoVMFEQ_VV_MF4_MASK, VMFEQ_VV, 0x6, 0x0 }, // 5573 + { PseudoVMFEQ_VV_MF2, VMFEQ_VV, 0x7, 0x0 }, // 5574 + { PseudoVMFEQ_VV_MF2_MASK, VMFEQ_VV, 0x7, 0x0 }, // 5575 + { PseudoVMFGE_VFPR16_M1, VMFGE_VF, 0x0, 0x0 }, // 5576 + { PseudoVMFGE_VFPR16_M1_MASK, VMFGE_VF, 0x0, 0x0 }, // 5577 + { PseudoVMFGE_VFPR32_M1, VMFGE_VF, 0x0, 0x0 }, // 5578 + { PseudoVMFGE_VFPR32_M1_MASK, VMFGE_VF, 0x0, 0x0 }, // 5579 + { PseudoVMFGE_VFPR64_M1, VMFGE_VF, 0x0, 0x0 }, // 5580 + { PseudoVMFGE_VFPR64_M1_MASK, VMFGE_VF, 0x0, 0x0 }, // 5581 + { PseudoVMFGE_VFPR16_M2, VMFGE_VF, 0x1, 0x0 }, // 5582 + { PseudoVMFGE_VFPR16_M2_MASK, VMFGE_VF, 0x1, 0x0 }, // 5583 + { PseudoVMFGE_VFPR32_M2, VMFGE_VF, 0x1, 0x0 }, // 5584 + { PseudoVMFGE_VFPR32_M2_MASK, VMFGE_VF, 0x1, 0x0 }, // 5585 + { PseudoVMFGE_VFPR64_M2, VMFGE_VF, 0x1, 0x0 }, // 5586 + { PseudoVMFGE_VFPR64_M2_MASK, VMFGE_VF, 0x1, 0x0 }, // 5587 + { PseudoVMFGE_VFPR16_M4, VMFGE_VF, 0x2, 0x0 }, // 5588 + { PseudoVMFGE_VFPR16_M4_MASK, VMFGE_VF, 0x2, 0x0 }, // 5589 + { PseudoVMFGE_VFPR32_M4, VMFGE_VF, 0x2, 0x0 }, // 5590 + { PseudoVMFGE_VFPR32_M4_MASK, VMFGE_VF, 0x2, 0x0 }, // 5591 + { PseudoVMFGE_VFPR64_M4, VMFGE_VF, 0x2, 0x0 }, // 5592 + { PseudoVMFGE_VFPR64_M4_MASK, VMFGE_VF, 0x2, 0x0 }, // 5593 + { PseudoVMFGE_VFPR16_M8, VMFGE_VF, 0x3, 0x0 }, // 5594 + { PseudoVMFGE_VFPR16_M8_MASK, VMFGE_VF, 0x3, 0x0 }, // 5595 + { PseudoVMFGE_VFPR32_M8, VMFGE_VF, 0x3, 0x0 }, // 5596 + { PseudoVMFGE_VFPR32_M8_MASK, VMFGE_VF, 0x3, 0x0 }, // 5597 + { PseudoVMFGE_VFPR64_M8, VMFGE_VF, 0x3, 0x0 }, // 5598 + { PseudoVMFGE_VFPR64_M8_MASK, VMFGE_VF, 0x3, 0x0 }, // 5599 + { PseudoVMFGE_VFPR16_MF4, VMFGE_VF, 0x6, 0x0 }, // 5600 + { PseudoVMFGE_VFPR16_MF4_MASK, VMFGE_VF, 0x6, 0x0 }, // 5601 + { PseudoVMFGE_VFPR16_MF2, VMFGE_VF, 0x7, 0x0 }, // 5602 + { PseudoVMFGE_VFPR16_MF2_MASK, VMFGE_VF, 0x7, 0x0 }, // 5603 + { PseudoVMFGE_VFPR32_MF2, VMFGE_VF, 0x7, 0x0 }, // 5604 + { PseudoVMFGE_VFPR32_MF2_MASK, VMFGE_VF, 0x7, 0x0 }, // 5605 + { PseudoVMFGT_VFPR16_M1, VMFGT_VF, 0x0, 0x0 }, // 5606 + { PseudoVMFGT_VFPR16_M1_MASK, VMFGT_VF, 0x0, 0x0 }, // 5607 + { PseudoVMFGT_VFPR32_M1, VMFGT_VF, 0x0, 0x0 }, // 5608 + { PseudoVMFGT_VFPR32_M1_MASK, VMFGT_VF, 0x0, 0x0 }, // 5609 + { PseudoVMFGT_VFPR64_M1, VMFGT_VF, 0x0, 0x0 }, // 5610 + { PseudoVMFGT_VFPR64_M1_MASK, VMFGT_VF, 0x0, 0x0 }, // 5611 + { PseudoVMFGT_VFPR16_M2, VMFGT_VF, 0x1, 0x0 }, // 5612 + { PseudoVMFGT_VFPR16_M2_MASK, VMFGT_VF, 0x1, 0x0 }, // 5613 + { PseudoVMFGT_VFPR32_M2, VMFGT_VF, 0x1, 0x0 }, // 5614 + { PseudoVMFGT_VFPR32_M2_MASK, VMFGT_VF, 0x1, 0x0 }, // 5615 + { PseudoVMFGT_VFPR64_M2, VMFGT_VF, 0x1, 0x0 }, // 5616 + { PseudoVMFGT_VFPR64_M2_MASK, VMFGT_VF, 0x1, 0x0 }, // 5617 + { PseudoVMFGT_VFPR16_M4, VMFGT_VF, 0x2, 0x0 }, // 5618 + { PseudoVMFGT_VFPR16_M4_MASK, VMFGT_VF, 0x2, 0x0 }, // 5619 + { PseudoVMFGT_VFPR32_M4, VMFGT_VF, 0x2, 0x0 }, // 5620 + { PseudoVMFGT_VFPR32_M4_MASK, VMFGT_VF, 0x2, 0x0 }, // 5621 + { PseudoVMFGT_VFPR64_M4, VMFGT_VF, 0x2, 0x0 }, // 5622 + { PseudoVMFGT_VFPR64_M4_MASK, VMFGT_VF, 0x2, 0x0 }, // 5623 + { PseudoVMFGT_VFPR16_M8, VMFGT_VF, 0x3, 0x0 }, // 5624 + { PseudoVMFGT_VFPR16_M8_MASK, VMFGT_VF, 0x3, 0x0 }, // 5625 + { PseudoVMFGT_VFPR32_M8, VMFGT_VF, 0x3, 0x0 }, // 5626 + { PseudoVMFGT_VFPR32_M8_MASK, VMFGT_VF, 0x3, 0x0 }, // 5627 + { PseudoVMFGT_VFPR64_M8, VMFGT_VF, 0x3, 0x0 }, // 5628 + { PseudoVMFGT_VFPR64_M8_MASK, VMFGT_VF, 0x3, 0x0 }, // 5629 + { PseudoVMFGT_VFPR16_MF4, VMFGT_VF, 0x6, 0x0 }, // 5630 + { PseudoVMFGT_VFPR16_MF4_MASK, VMFGT_VF, 0x6, 0x0 }, // 5631 + { PseudoVMFGT_VFPR16_MF2, VMFGT_VF, 0x7, 0x0 }, // 5632 + { PseudoVMFGT_VFPR16_MF2_MASK, VMFGT_VF, 0x7, 0x0 }, // 5633 + { PseudoVMFGT_VFPR32_MF2, VMFGT_VF, 0x7, 0x0 }, // 5634 + { PseudoVMFGT_VFPR32_MF2_MASK, VMFGT_VF, 0x7, 0x0 }, // 5635 + { PseudoVMFLE_VFPR16_M1, VMFLE_VF, 0x0, 0x0 }, // 5636 + { PseudoVMFLE_VFPR16_M1_MASK, VMFLE_VF, 0x0, 0x0 }, // 5637 + { PseudoVMFLE_VFPR32_M1, VMFLE_VF, 0x0, 0x0 }, // 5638 + { PseudoVMFLE_VFPR32_M1_MASK, VMFLE_VF, 0x0, 0x0 }, // 5639 + { PseudoVMFLE_VFPR64_M1, VMFLE_VF, 0x0, 0x0 }, // 5640 + { PseudoVMFLE_VFPR64_M1_MASK, VMFLE_VF, 0x0, 0x0 }, // 5641 + { PseudoVMFLE_VFPR16_M2, VMFLE_VF, 0x1, 0x0 }, // 5642 + { PseudoVMFLE_VFPR16_M2_MASK, VMFLE_VF, 0x1, 0x0 }, // 5643 + { PseudoVMFLE_VFPR32_M2, VMFLE_VF, 0x1, 0x0 }, // 5644 + { PseudoVMFLE_VFPR32_M2_MASK, VMFLE_VF, 0x1, 0x0 }, // 5645 + { PseudoVMFLE_VFPR64_M2, VMFLE_VF, 0x1, 0x0 }, // 5646 + { PseudoVMFLE_VFPR64_M2_MASK, VMFLE_VF, 0x1, 0x0 }, // 5647 + { PseudoVMFLE_VFPR16_M4, VMFLE_VF, 0x2, 0x0 }, // 5648 + { PseudoVMFLE_VFPR16_M4_MASK, VMFLE_VF, 0x2, 0x0 }, // 5649 + { PseudoVMFLE_VFPR32_M4, VMFLE_VF, 0x2, 0x0 }, // 5650 + { PseudoVMFLE_VFPR32_M4_MASK, VMFLE_VF, 0x2, 0x0 }, // 5651 + { PseudoVMFLE_VFPR64_M4, VMFLE_VF, 0x2, 0x0 }, // 5652 + { PseudoVMFLE_VFPR64_M4_MASK, VMFLE_VF, 0x2, 0x0 }, // 5653 + { PseudoVMFLE_VFPR16_M8, VMFLE_VF, 0x3, 0x0 }, // 5654 + { PseudoVMFLE_VFPR16_M8_MASK, VMFLE_VF, 0x3, 0x0 }, // 5655 + { PseudoVMFLE_VFPR32_M8, VMFLE_VF, 0x3, 0x0 }, // 5656 + { PseudoVMFLE_VFPR32_M8_MASK, VMFLE_VF, 0x3, 0x0 }, // 5657 + { PseudoVMFLE_VFPR64_M8, VMFLE_VF, 0x3, 0x0 }, // 5658 + { PseudoVMFLE_VFPR64_M8_MASK, VMFLE_VF, 0x3, 0x0 }, // 5659 + { PseudoVMFLE_VFPR16_MF4, VMFLE_VF, 0x6, 0x0 }, // 5660 + { PseudoVMFLE_VFPR16_MF4_MASK, VMFLE_VF, 0x6, 0x0 }, // 5661 + { PseudoVMFLE_VFPR16_MF2, VMFLE_VF, 0x7, 0x0 }, // 5662 + { PseudoVMFLE_VFPR16_MF2_MASK, VMFLE_VF, 0x7, 0x0 }, // 5663 + { PseudoVMFLE_VFPR32_MF2, VMFLE_VF, 0x7, 0x0 }, // 5664 + { PseudoVMFLE_VFPR32_MF2_MASK, VMFLE_VF, 0x7, 0x0 }, // 5665 + { PseudoVMFLE_VV_M1, VMFLE_VV, 0x0, 0x0 }, // 5666 + { PseudoVMFLE_VV_M1_MASK, VMFLE_VV, 0x0, 0x0 }, // 5667 + { PseudoVMFLE_VV_M2, VMFLE_VV, 0x1, 0x0 }, // 5668 + { PseudoVMFLE_VV_M2_MASK, VMFLE_VV, 0x1, 0x0 }, // 5669 + { PseudoVMFLE_VV_M4, VMFLE_VV, 0x2, 0x0 }, // 5670 + { PseudoVMFLE_VV_M4_MASK, VMFLE_VV, 0x2, 0x0 }, // 5671 + { PseudoVMFLE_VV_M8, VMFLE_VV, 0x3, 0x0 }, // 5672 + { PseudoVMFLE_VV_M8_MASK, VMFLE_VV, 0x3, 0x0 }, // 5673 + { PseudoVMFLE_VV_MF4, VMFLE_VV, 0x6, 0x0 }, // 5674 + { PseudoVMFLE_VV_MF4_MASK, VMFLE_VV, 0x6, 0x0 }, // 5675 + { PseudoVMFLE_VV_MF2, VMFLE_VV, 0x7, 0x0 }, // 5676 + { PseudoVMFLE_VV_MF2_MASK, VMFLE_VV, 0x7, 0x0 }, // 5677 + { PseudoVMFLT_VFPR16_M1, VMFLT_VF, 0x0, 0x0 }, // 5678 + { PseudoVMFLT_VFPR16_M1_MASK, VMFLT_VF, 0x0, 0x0 }, // 5679 + { PseudoVMFLT_VFPR32_M1, VMFLT_VF, 0x0, 0x0 }, // 5680 + { PseudoVMFLT_VFPR32_M1_MASK, VMFLT_VF, 0x0, 0x0 }, // 5681 + { PseudoVMFLT_VFPR64_M1, VMFLT_VF, 0x0, 0x0 }, // 5682 + { PseudoVMFLT_VFPR64_M1_MASK, VMFLT_VF, 0x0, 0x0 }, // 5683 + { PseudoVMFLT_VFPR16_M2, VMFLT_VF, 0x1, 0x0 }, // 5684 + { PseudoVMFLT_VFPR16_M2_MASK, VMFLT_VF, 0x1, 0x0 }, // 5685 + { PseudoVMFLT_VFPR32_M2, VMFLT_VF, 0x1, 0x0 }, // 5686 + { PseudoVMFLT_VFPR32_M2_MASK, VMFLT_VF, 0x1, 0x0 }, // 5687 + { PseudoVMFLT_VFPR64_M2, VMFLT_VF, 0x1, 0x0 }, // 5688 + { PseudoVMFLT_VFPR64_M2_MASK, VMFLT_VF, 0x1, 0x0 }, // 5689 + { PseudoVMFLT_VFPR16_M4, VMFLT_VF, 0x2, 0x0 }, // 5690 + { PseudoVMFLT_VFPR16_M4_MASK, VMFLT_VF, 0x2, 0x0 }, // 5691 + { PseudoVMFLT_VFPR32_M4, VMFLT_VF, 0x2, 0x0 }, // 5692 + { PseudoVMFLT_VFPR32_M4_MASK, VMFLT_VF, 0x2, 0x0 }, // 5693 + { PseudoVMFLT_VFPR64_M4, VMFLT_VF, 0x2, 0x0 }, // 5694 + { PseudoVMFLT_VFPR64_M4_MASK, VMFLT_VF, 0x2, 0x0 }, // 5695 + { PseudoVMFLT_VFPR16_M8, VMFLT_VF, 0x3, 0x0 }, // 5696 + { PseudoVMFLT_VFPR16_M8_MASK, VMFLT_VF, 0x3, 0x0 }, // 5697 + { PseudoVMFLT_VFPR32_M8, VMFLT_VF, 0x3, 0x0 }, // 5698 + { PseudoVMFLT_VFPR32_M8_MASK, VMFLT_VF, 0x3, 0x0 }, // 5699 + { PseudoVMFLT_VFPR64_M8, VMFLT_VF, 0x3, 0x0 }, // 5700 + { PseudoVMFLT_VFPR64_M8_MASK, VMFLT_VF, 0x3, 0x0 }, // 5701 + { PseudoVMFLT_VFPR16_MF4, VMFLT_VF, 0x6, 0x0 }, // 5702 + { PseudoVMFLT_VFPR16_MF4_MASK, VMFLT_VF, 0x6, 0x0 }, // 5703 + { PseudoVMFLT_VFPR16_MF2, VMFLT_VF, 0x7, 0x0 }, // 5704 + { PseudoVMFLT_VFPR16_MF2_MASK, VMFLT_VF, 0x7, 0x0 }, // 5705 + { PseudoVMFLT_VFPR32_MF2, VMFLT_VF, 0x7, 0x0 }, // 5706 + { PseudoVMFLT_VFPR32_MF2_MASK, VMFLT_VF, 0x7, 0x0 }, // 5707 + { PseudoVMFLT_VV_M1, VMFLT_VV, 0x0, 0x0 }, // 5708 + { PseudoVMFLT_VV_M1_MASK, VMFLT_VV, 0x0, 0x0 }, // 5709 + { PseudoVMFLT_VV_M2, VMFLT_VV, 0x1, 0x0 }, // 5710 + { PseudoVMFLT_VV_M2_MASK, VMFLT_VV, 0x1, 0x0 }, // 5711 + { PseudoVMFLT_VV_M4, VMFLT_VV, 0x2, 0x0 }, // 5712 + { PseudoVMFLT_VV_M4_MASK, VMFLT_VV, 0x2, 0x0 }, // 5713 + { PseudoVMFLT_VV_M8, VMFLT_VV, 0x3, 0x0 }, // 5714 + { PseudoVMFLT_VV_M8_MASK, VMFLT_VV, 0x3, 0x0 }, // 5715 + { PseudoVMFLT_VV_MF4, VMFLT_VV, 0x6, 0x0 }, // 5716 + { PseudoVMFLT_VV_MF4_MASK, VMFLT_VV, 0x6, 0x0 }, // 5717 + { PseudoVMFLT_VV_MF2, VMFLT_VV, 0x7, 0x0 }, // 5718 + { PseudoVMFLT_VV_MF2_MASK, VMFLT_VV, 0x7, 0x0 }, // 5719 + { PseudoVMFNE_VFPR16_M1, VMFNE_VF, 0x0, 0x0 }, // 5720 + { PseudoVMFNE_VFPR16_M1_MASK, VMFNE_VF, 0x0, 0x0 }, // 5721 + { PseudoVMFNE_VFPR32_M1, VMFNE_VF, 0x0, 0x0 }, // 5722 + { PseudoVMFNE_VFPR32_M1_MASK, VMFNE_VF, 0x0, 0x0 }, // 5723 + { PseudoVMFNE_VFPR64_M1, VMFNE_VF, 0x0, 0x0 }, // 5724 + { PseudoVMFNE_VFPR64_M1_MASK, VMFNE_VF, 0x0, 0x0 }, // 5725 + { PseudoVMFNE_VFPR16_M2, VMFNE_VF, 0x1, 0x0 }, // 5726 + { PseudoVMFNE_VFPR16_M2_MASK, VMFNE_VF, 0x1, 0x0 }, // 5727 + { PseudoVMFNE_VFPR32_M2, VMFNE_VF, 0x1, 0x0 }, // 5728 + { PseudoVMFNE_VFPR32_M2_MASK, VMFNE_VF, 0x1, 0x0 }, // 5729 + { PseudoVMFNE_VFPR64_M2, VMFNE_VF, 0x1, 0x0 }, // 5730 + { PseudoVMFNE_VFPR64_M2_MASK, VMFNE_VF, 0x1, 0x0 }, // 5731 + { PseudoVMFNE_VFPR16_M4, VMFNE_VF, 0x2, 0x0 }, // 5732 + { PseudoVMFNE_VFPR16_M4_MASK, VMFNE_VF, 0x2, 0x0 }, // 5733 + { PseudoVMFNE_VFPR32_M4, VMFNE_VF, 0x2, 0x0 }, // 5734 + { PseudoVMFNE_VFPR32_M4_MASK, VMFNE_VF, 0x2, 0x0 }, // 5735 + { PseudoVMFNE_VFPR64_M4, VMFNE_VF, 0x2, 0x0 }, // 5736 + { PseudoVMFNE_VFPR64_M4_MASK, VMFNE_VF, 0x2, 0x0 }, // 5737 + { PseudoVMFNE_VFPR16_M8, VMFNE_VF, 0x3, 0x0 }, // 5738 + { PseudoVMFNE_VFPR16_M8_MASK, VMFNE_VF, 0x3, 0x0 }, // 5739 + { PseudoVMFNE_VFPR32_M8, VMFNE_VF, 0x3, 0x0 }, // 5740 + { PseudoVMFNE_VFPR32_M8_MASK, VMFNE_VF, 0x3, 0x0 }, // 5741 + { PseudoVMFNE_VFPR64_M8, VMFNE_VF, 0x3, 0x0 }, // 5742 + { PseudoVMFNE_VFPR64_M8_MASK, VMFNE_VF, 0x3, 0x0 }, // 5743 + { PseudoVMFNE_VFPR16_MF4, VMFNE_VF, 0x6, 0x0 }, // 5744 + { PseudoVMFNE_VFPR16_MF4_MASK, VMFNE_VF, 0x6, 0x0 }, // 5745 + { PseudoVMFNE_VFPR16_MF2, VMFNE_VF, 0x7, 0x0 }, // 5746 + { PseudoVMFNE_VFPR16_MF2_MASK, VMFNE_VF, 0x7, 0x0 }, // 5747 + { PseudoVMFNE_VFPR32_MF2, VMFNE_VF, 0x7, 0x0 }, // 5748 + { PseudoVMFNE_VFPR32_MF2_MASK, VMFNE_VF, 0x7, 0x0 }, // 5749 + { PseudoVMFNE_VV_M1, VMFNE_VV, 0x0, 0x0 }, // 5750 + { PseudoVMFNE_VV_M1_MASK, VMFNE_VV, 0x0, 0x0 }, // 5751 + { PseudoVMFNE_VV_M2, VMFNE_VV, 0x1, 0x0 }, // 5752 + { PseudoVMFNE_VV_M2_MASK, VMFNE_VV, 0x1, 0x0 }, // 5753 + { PseudoVMFNE_VV_M4, VMFNE_VV, 0x2, 0x0 }, // 5754 + { PseudoVMFNE_VV_M4_MASK, VMFNE_VV, 0x2, 0x0 }, // 5755 + { PseudoVMFNE_VV_M8, VMFNE_VV, 0x3, 0x0 }, // 5756 + { PseudoVMFNE_VV_M8_MASK, VMFNE_VV, 0x3, 0x0 }, // 5757 + { PseudoVMFNE_VV_MF4, VMFNE_VV, 0x6, 0x0 }, // 5758 + { PseudoVMFNE_VV_MF4_MASK, VMFNE_VV, 0x6, 0x0 }, // 5759 + { PseudoVMFNE_VV_MF2, VMFNE_VV, 0x7, 0x0 }, // 5760 + { PseudoVMFNE_VV_MF2_MASK, VMFNE_VV, 0x7, 0x0 }, // 5761 + { PseudoVMINU_VV_M1, VMINU_VV, 0x0, 0x0 }, // 5762 + { PseudoVMINU_VV_M1_MASK, VMINU_VV, 0x0, 0x0 }, // 5763 + { PseudoVMINU_VV_M2, VMINU_VV, 0x1, 0x0 }, // 5764 + { PseudoVMINU_VV_M2_MASK, VMINU_VV, 0x1, 0x0 }, // 5765 + { PseudoVMINU_VV_M4, VMINU_VV, 0x2, 0x0 }, // 5766 + { PseudoVMINU_VV_M4_MASK, VMINU_VV, 0x2, 0x0 }, // 5767 + { PseudoVMINU_VV_M8, VMINU_VV, 0x3, 0x0 }, // 5768 + { PseudoVMINU_VV_M8_MASK, VMINU_VV, 0x3, 0x0 }, // 5769 + { PseudoVMINU_VV_MF8, VMINU_VV, 0x5, 0x0 }, // 5770 + { PseudoVMINU_VV_MF8_MASK, VMINU_VV, 0x5, 0x0 }, // 5771 + { PseudoVMINU_VV_MF4, VMINU_VV, 0x6, 0x0 }, // 5772 + { PseudoVMINU_VV_MF4_MASK, VMINU_VV, 0x6, 0x0 }, // 5773 + { PseudoVMINU_VV_MF2, VMINU_VV, 0x7, 0x0 }, // 5774 + { PseudoVMINU_VV_MF2_MASK, VMINU_VV, 0x7, 0x0 }, // 5775 + { PseudoVMINU_VX_M1, VMINU_VX, 0x0, 0x0 }, // 5776 + { PseudoVMINU_VX_M1_MASK, VMINU_VX, 0x0, 0x0 }, // 5777 + { PseudoVMINU_VX_M2, VMINU_VX, 0x1, 0x0 }, // 5778 + { PseudoVMINU_VX_M2_MASK, VMINU_VX, 0x1, 0x0 }, // 5779 + { PseudoVMINU_VX_M4, VMINU_VX, 0x2, 0x0 }, // 5780 + { PseudoVMINU_VX_M4_MASK, VMINU_VX, 0x2, 0x0 }, // 5781 + { PseudoVMINU_VX_M8, VMINU_VX, 0x3, 0x0 }, // 5782 + { PseudoVMINU_VX_M8_MASK, VMINU_VX, 0x3, 0x0 }, // 5783 + { PseudoVMINU_VX_MF8, VMINU_VX, 0x5, 0x0 }, // 5784 + { PseudoVMINU_VX_MF8_MASK, VMINU_VX, 0x5, 0x0 }, // 5785 + { PseudoVMINU_VX_MF4, VMINU_VX, 0x6, 0x0 }, // 5786 + { PseudoVMINU_VX_MF4_MASK, VMINU_VX, 0x6, 0x0 }, // 5787 + { PseudoVMINU_VX_MF2, VMINU_VX, 0x7, 0x0 }, // 5788 + { PseudoVMINU_VX_MF2_MASK, VMINU_VX, 0x7, 0x0 }, // 5789 + { PseudoVMIN_VV_M1, VMIN_VV, 0x0, 0x0 }, // 5790 + { PseudoVMIN_VV_M1_MASK, VMIN_VV, 0x0, 0x0 }, // 5791 + { PseudoVMIN_VV_M2, VMIN_VV, 0x1, 0x0 }, // 5792 + { PseudoVMIN_VV_M2_MASK, VMIN_VV, 0x1, 0x0 }, // 5793 + { PseudoVMIN_VV_M4, VMIN_VV, 0x2, 0x0 }, // 5794 + { PseudoVMIN_VV_M4_MASK, VMIN_VV, 0x2, 0x0 }, // 5795 + { PseudoVMIN_VV_M8, VMIN_VV, 0x3, 0x0 }, // 5796 + { PseudoVMIN_VV_M8_MASK, VMIN_VV, 0x3, 0x0 }, // 5797 + { PseudoVMIN_VV_MF8, VMIN_VV, 0x5, 0x0 }, // 5798 + { PseudoVMIN_VV_MF8_MASK, VMIN_VV, 0x5, 0x0 }, // 5799 + { PseudoVMIN_VV_MF4, VMIN_VV, 0x6, 0x0 }, // 5800 + { PseudoVMIN_VV_MF4_MASK, VMIN_VV, 0x6, 0x0 }, // 5801 + { PseudoVMIN_VV_MF2, VMIN_VV, 0x7, 0x0 }, // 5802 + { PseudoVMIN_VV_MF2_MASK, VMIN_VV, 0x7, 0x0 }, // 5803 + { PseudoVMIN_VX_M1, VMIN_VX, 0x0, 0x0 }, // 5804 + { PseudoVMIN_VX_M1_MASK, VMIN_VX, 0x0, 0x0 }, // 5805 + { PseudoVMIN_VX_M2, VMIN_VX, 0x1, 0x0 }, // 5806 + { PseudoVMIN_VX_M2_MASK, VMIN_VX, 0x1, 0x0 }, // 5807 + { PseudoVMIN_VX_M4, VMIN_VX, 0x2, 0x0 }, // 5808 + { PseudoVMIN_VX_M4_MASK, VMIN_VX, 0x2, 0x0 }, // 5809 + { PseudoVMIN_VX_M8, VMIN_VX, 0x3, 0x0 }, // 5810 + { PseudoVMIN_VX_M8_MASK, VMIN_VX, 0x3, 0x0 }, // 5811 + { PseudoVMIN_VX_MF8, VMIN_VX, 0x5, 0x0 }, // 5812 + { PseudoVMIN_VX_MF8_MASK, VMIN_VX, 0x5, 0x0 }, // 5813 + { PseudoVMIN_VX_MF4, VMIN_VX, 0x6, 0x0 }, // 5814 + { PseudoVMIN_VX_MF4_MASK, VMIN_VX, 0x6, 0x0 }, // 5815 + { PseudoVMIN_VX_MF2, VMIN_VX, 0x7, 0x0 }, // 5816 + { PseudoVMIN_VX_MF2_MASK, VMIN_VX, 0x7, 0x0 }, // 5817 + { PseudoVMNAND_MM_M1, VMNAND_MM, 0x0, 0x0 }, // 5818 + { PseudoVMNAND_MM_M2, VMNAND_MM, 0x1, 0x0 }, // 5819 + { PseudoVMNAND_MM_M4, VMNAND_MM, 0x2, 0x0 }, // 5820 + { PseudoVMNAND_MM_M8, VMNAND_MM, 0x3, 0x0 }, // 5821 + { PseudoVMNAND_MM_MF8, VMNAND_MM, 0x5, 0x0 }, // 5822 + { PseudoVMNAND_MM_MF4, VMNAND_MM, 0x6, 0x0 }, // 5823 + { PseudoVMNAND_MM_MF2, VMNAND_MM, 0x7, 0x0 }, // 5824 + { PseudoVMNOR_MM_M1, VMNOR_MM, 0x0, 0x0 }, // 5825 + { PseudoVMNOR_MM_M2, VMNOR_MM, 0x1, 0x0 }, // 5826 + { PseudoVMNOR_MM_M4, VMNOR_MM, 0x2, 0x0 }, // 5827 + { PseudoVMNOR_MM_M8, VMNOR_MM, 0x3, 0x0 }, // 5828 + { PseudoVMNOR_MM_MF8, VMNOR_MM, 0x5, 0x0 }, // 5829 + { PseudoVMNOR_MM_MF4, VMNOR_MM, 0x6, 0x0 }, // 5830 + { PseudoVMNOR_MM_MF2, VMNOR_MM, 0x7, 0x0 }, // 5831 + { PseudoVMORN_MM_M1, VMORN_MM, 0x0, 0x0 }, // 5832 + { PseudoVMORN_MM_M2, VMORN_MM, 0x1, 0x0 }, // 5833 + { PseudoVMORN_MM_M4, VMORN_MM, 0x2, 0x0 }, // 5834 + { PseudoVMORN_MM_M8, VMORN_MM, 0x3, 0x0 }, // 5835 + { PseudoVMORN_MM_MF8, VMORN_MM, 0x5, 0x0 }, // 5836 + { PseudoVMORN_MM_MF4, VMORN_MM, 0x6, 0x0 }, // 5837 + { PseudoVMORN_MM_MF2, VMORN_MM, 0x7, 0x0 }, // 5838 + { PseudoVMOR_MM_M1, VMOR_MM, 0x0, 0x0 }, // 5839 + { PseudoVMOR_MM_M2, VMOR_MM, 0x1, 0x0 }, // 5840 + { PseudoVMOR_MM_M4, VMOR_MM, 0x2, 0x0 }, // 5841 + { PseudoVMOR_MM_M8, VMOR_MM, 0x3, 0x0 }, // 5842 + { PseudoVMOR_MM_MF8, VMOR_MM, 0x5, 0x0 }, // 5843 + { PseudoVMOR_MM_MF4, VMOR_MM, 0x6, 0x0 }, // 5844 + { PseudoVMOR_MM_MF2, VMOR_MM, 0x7, 0x0 }, // 5845 + { PseudoVMSBC_VV_M1, VMSBC_VV, 0x0, 0x0 }, // 5846 + { PseudoVMSBC_VV_M2, VMSBC_VV, 0x1, 0x0 }, // 5847 + { PseudoVMSBC_VV_M4, VMSBC_VV, 0x2, 0x0 }, // 5848 + { PseudoVMSBC_VV_M8, VMSBC_VV, 0x3, 0x0 }, // 5849 + { PseudoVMSBC_VV_MF8, VMSBC_VV, 0x5, 0x0 }, // 5850 + { PseudoVMSBC_VV_MF4, VMSBC_VV, 0x6, 0x0 }, // 5851 + { PseudoVMSBC_VV_MF2, VMSBC_VV, 0x7, 0x0 }, // 5852 + { PseudoVMSBC_VVM_M1, VMSBC_VVM, 0x0, 0x0 }, // 5853 + { PseudoVMSBC_VVM_M2, VMSBC_VVM, 0x1, 0x0 }, // 5854 + { PseudoVMSBC_VVM_M4, VMSBC_VVM, 0x2, 0x0 }, // 5855 + { PseudoVMSBC_VVM_M8, VMSBC_VVM, 0x3, 0x0 }, // 5856 + { PseudoVMSBC_VVM_MF8, VMSBC_VVM, 0x5, 0x0 }, // 5857 + { PseudoVMSBC_VVM_MF4, VMSBC_VVM, 0x6, 0x0 }, // 5858 + { PseudoVMSBC_VVM_MF2, VMSBC_VVM, 0x7, 0x0 }, // 5859 + { PseudoVMSBC_VX_M1, VMSBC_VX, 0x0, 0x0 }, // 5860 + { PseudoVMSBC_VX_M2, VMSBC_VX, 0x1, 0x0 }, // 5861 + { PseudoVMSBC_VX_M4, VMSBC_VX, 0x2, 0x0 }, // 5862 + { PseudoVMSBC_VX_M8, VMSBC_VX, 0x3, 0x0 }, // 5863 + { PseudoVMSBC_VX_MF8, VMSBC_VX, 0x5, 0x0 }, // 5864 + { PseudoVMSBC_VX_MF4, VMSBC_VX, 0x6, 0x0 }, // 5865 + { PseudoVMSBC_VX_MF2, VMSBC_VX, 0x7, 0x0 }, // 5866 + { PseudoVMSBC_VXM_M1, VMSBC_VXM, 0x0, 0x0 }, // 5867 + { PseudoVMSBC_VXM_M2, VMSBC_VXM, 0x1, 0x0 }, // 5868 + { PseudoVMSBC_VXM_M4, VMSBC_VXM, 0x2, 0x0 }, // 5869 + { PseudoVMSBC_VXM_M8, VMSBC_VXM, 0x3, 0x0 }, // 5870 + { PseudoVMSBC_VXM_MF8, VMSBC_VXM, 0x5, 0x0 }, // 5871 + { PseudoVMSBC_VXM_MF4, VMSBC_VXM, 0x6, 0x0 }, // 5872 + { PseudoVMSBC_VXM_MF2, VMSBC_VXM, 0x7, 0x0 }, // 5873 + { PseudoVMSBF_M_B8, VMSBF_M, 0x0, 0x0 }, // 5874 + { PseudoVMSBF_M_B8_MASK, VMSBF_M, 0x0, 0x0 }, // 5875 + { PseudoVMSBF_M_B16, VMSBF_M, 0x1, 0x0 }, // 5876 + { PseudoVMSBF_M_B16_MASK, VMSBF_M, 0x1, 0x0 }, // 5877 + { PseudoVMSBF_M_B32, VMSBF_M, 0x2, 0x0 }, // 5878 + { PseudoVMSBF_M_B32_MASK, VMSBF_M, 0x2, 0x0 }, // 5879 + { PseudoVMSBF_M_B64, VMSBF_M, 0x3, 0x0 }, // 5880 + { PseudoVMSBF_M_B64_MASK, VMSBF_M, 0x3, 0x0 }, // 5881 + { PseudoVMSBF_M_B1, VMSBF_M, 0x5, 0x0 }, // 5882 + { PseudoVMSBF_M_B1_MASK, VMSBF_M, 0x5, 0x0 }, // 5883 + { PseudoVMSBF_M_B2, VMSBF_M, 0x6, 0x0 }, // 5884 + { PseudoVMSBF_M_B2_MASK, VMSBF_M, 0x6, 0x0 }, // 5885 + { PseudoVMSBF_M_B4, VMSBF_M, 0x7, 0x0 }, // 5886 + { PseudoVMSBF_M_B4_MASK, VMSBF_M, 0x7, 0x0 }, // 5887 + { PseudoVMSEQ_VI_M1, VMSEQ_VI, 0x0, 0x0 }, // 5888 + { PseudoVMSEQ_VI_M1_MASK, VMSEQ_VI, 0x0, 0x0 }, // 5889 + { PseudoVMSEQ_VI_M2, VMSEQ_VI, 0x1, 0x0 }, // 5890 + { PseudoVMSEQ_VI_M2_MASK, VMSEQ_VI, 0x1, 0x0 }, // 5891 + { PseudoVMSEQ_VI_M4, VMSEQ_VI, 0x2, 0x0 }, // 5892 + { PseudoVMSEQ_VI_M4_MASK, VMSEQ_VI, 0x2, 0x0 }, // 5893 + { PseudoVMSEQ_VI_M8, VMSEQ_VI, 0x3, 0x0 }, // 5894 + { PseudoVMSEQ_VI_M8_MASK, VMSEQ_VI, 0x3, 0x0 }, // 5895 + { PseudoVMSEQ_VI_MF8, VMSEQ_VI, 0x5, 0x0 }, // 5896 + { PseudoVMSEQ_VI_MF8_MASK, VMSEQ_VI, 0x5, 0x0 }, // 5897 + { PseudoVMSEQ_VI_MF4, VMSEQ_VI, 0x6, 0x0 }, // 5898 + { PseudoVMSEQ_VI_MF4_MASK, VMSEQ_VI, 0x6, 0x0 }, // 5899 + { PseudoVMSEQ_VI_MF2, VMSEQ_VI, 0x7, 0x0 }, // 5900 + { PseudoVMSEQ_VI_MF2_MASK, VMSEQ_VI, 0x7, 0x0 }, // 5901 + { PseudoVMSEQ_VV_M1, VMSEQ_VV, 0x0, 0x0 }, // 5902 + { PseudoVMSEQ_VV_M1_MASK, VMSEQ_VV, 0x0, 0x0 }, // 5903 + { PseudoVMSEQ_VV_M2, VMSEQ_VV, 0x1, 0x0 }, // 5904 + { PseudoVMSEQ_VV_M2_MASK, VMSEQ_VV, 0x1, 0x0 }, // 5905 + { PseudoVMSEQ_VV_M4, VMSEQ_VV, 0x2, 0x0 }, // 5906 + { PseudoVMSEQ_VV_M4_MASK, VMSEQ_VV, 0x2, 0x0 }, // 5907 + { PseudoVMSEQ_VV_M8, VMSEQ_VV, 0x3, 0x0 }, // 5908 + { PseudoVMSEQ_VV_M8_MASK, VMSEQ_VV, 0x3, 0x0 }, // 5909 + { PseudoVMSEQ_VV_MF8, VMSEQ_VV, 0x5, 0x0 }, // 5910 + { PseudoVMSEQ_VV_MF8_MASK, VMSEQ_VV, 0x5, 0x0 }, // 5911 + { PseudoVMSEQ_VV_MF4, VMSEQ_VV, 0x6, 0x0 }, // 5912 + { PseudoVMSEQ_VV_MF4_MASK, VMSEQ_VV, 0x6, 0x0 }, // 5913 + { PseudoVMSEQ_VV_MF2, VMSEQ_VV, 0x7, 0x0 }, // 5914 + { PseudoVMSEQ_VV_MF2_MASK, VMSEQ_VV, 0x7, 0x0 }, // 5915 + { PseudoVMSEQ_VX_M1, VMSEQ_VX, 0x0, 0x0 }, // 5916 + { PseudoVMSEQ_VX_M1_MASK, VMSEQ_VX, 0x0, 0x0 }, // 5917 + { PseudoVMSEQ_VX_M2, VMSEQ_VX, 0x1, 0x0 }, // 5918 + { PseudoVMSEQ_VX_M2_MASK, VMSEQ_VX, 0x1, 0x0 }, // 5919 + { PseudoVMSEQ_VX_M4, VMSEQ_VX, 0x2, 0x0 }, // 5920 + { PseudoVMSEQ_VX_M4_MASK, VMSEQ_VX, 0x2, 0x0 }, // 5921 + { PseudoVMSEQ_VX_M8, VMSEQ_VX, 0x3, 0x0 }, // 5922 + { PseudoVMSEQ_VX_M8_MASK, VMSEQ_VX, 0x3, 0x0 }, // 5923 + { PseudoVMSEQ_VX_MF8, VMSEQ_VX, 0x5, 0x0 }, // 5924 + { PseudoVMSEQ_VX_MF8_MASK, VMSEQ_VX, 0x5, 0x0 }, // 5925 + { PseudoVMSEQ_VX_MF4, VMSEQ_VX, 0x6, 0x0 }, // 5926 + { PseudoVMSEQ_VX_MF4_MASK, VMSEQ_VX, 0x6, 0x0 }, // 5927 + { PseudoVMSEQ_VX_MF2, VMSEQ_VX, 0x7, 0x0 }, // 5928 + { PseudoVMSEQ_VX_MF2_MASK, VMSEQ_VX, 0x7, 0x0 }, // 5929 + { PseudoVMSGTU_VI_M1, VMSGTU_VI, 0x0, 0x0 }, // 5930 + { PseudoVMSGTU_VI_M1_MASK, VMSGTU_VI, 0x0, 0x0 }, // 5931 + { PseudoVMSGTU_VI_M2, VMSGTU_VI, 0x1, 0x0 }, // 5932 + { PseudoVMSGTU_VI_M2_MASK, VMSGTU_VI, 0x1, 0x0 }, // 5933 + { PseudoVMSGTU_VI_M4, VMSGTU_VI, 0x2, 0x0 }, // 5934 + { PseudoVMSGTU_VI_M4_MASK, VMSGTU_VI, 0x2, 0x0 }, // 5935 + { PseudoVMSGTU_VI_M8, VMSGTU_VI, 0x3, 0x0 }, // 5936 + { PseudoVMSGTU_VI_M8_MASK, VMSGTU_VI, 0x3, 0x0 }, // 5937 + { PseudoVMSGTU_VI_MF8, VMSGTU_VI, 0x5, 0x0 }, // 5938 + { PseudoVMSGTU_VI_MF8_MASK, VMSGTU_VI, 0x5, 0x0 }, // 5939 + { PseudoVMSGTU_VI_MF4, VMSGTU_VI, 0x6, 0x0 }, // 5940 + { PseudoVMSGTU_VI_MF4_MASK, VMSGTU_VI, 0x6, 0x0 }, // 5941 + { PseudoVMSGTU_VI_MF2, VMSGTU_VI, 0x7, 0x0 }, // 5942 + { PseudoVMSGTU_VI_MF2_MASK, VMSGTU_VI, 0x7, 0x0 }, // 5943 + { PseudoVMSGTU_VX_M1, VMSGTU_VX, 0x0, 0x0 }, // 5944 + { PseudoVMSGTU_VX_M1_MASK, VMSGTU_VX, 0x0, 0x0 }, // 5945 + { PseudoVMSGTU_VX_M2, VMSGTU_VX, 0x1, 0x0 }, // 5946 + { PseudoVMSGTU_VX_M2_MASK, VMSGTU_VX, 0x1, 0x0 }, // 5947 + { PseudoVMSGTU_VX_M4, VMSGTU_VX, 0x2, 0x0 }, // 5948 + { PseudoVMSGTU_VX_M4_MASK, VMSGTU_VX, 0x2, 0x0 }, // 5949 + { PseudoVMSGTU_VX_M8, VMSGTU_VX, 0x3, 0x0 }, // 5950 + { PseudoVMSGTU_VX_M8_MASK, VMSGTU_VX, 0x3, 0x0 }, // 5951 + { PseudoVMSGTU_VX_MF8, VMSGTU_VX, 0x5, 0x0 }, // 5952 + { PseudoVMSGTU_VX_MF8_MASK, VMSGTU_VX, 0x5, 0x0 }, // 5953 + { PseudoVMSGTU_VX_MF4, VMSGTU_VX, 0x6, 0x0 }, // 5954 + { PseudoVMSGTU_VX_MF4_MASK, VMSGTU_VX, 0x6, 0x0 }, // 5955 + { PseudoVMSGTU_VX_MF2, VMSGTU_VX, 0x7, 0x0 }, // 5956 + { PseudoVMSGTU_VX_MF2_MASK, VMSGTU_VX, 0x7, 0x0 }, // 5957 + { PseudoVMSGT_VI_M1, VMSGT_VI, 0x0, 0x0 }, // 5958 + { PseudoVMSGT_VI_M1_MASK, VMSGT_VI, 0x0, 0x0 }, // 5959 + { PseudoVMSGT_VI_M2, VMSGT_VI, 0x1, 0x0 }, // 5960 + { PseudoVMSGT_VI_M2_MASK, VMSGT_VI, 0x1, 0x0 }, // 5961 + { PseudoVMSGT_VI_M4, VMSGT_VI, 0x2, 0x0 }, // 5962 + { PseudoVMSGT_VI_M4_MASK, VMSGT_VI, 0x2, 0x0 }, // 5963 + { PseudoVMSGT_VI_M8, VMSGT_VI, 0x3, 0x0 }, // 5964 + { PseudoVMSGT_VI_M8_MASK, VMSGT_VI, 0x3, 0x0 }, // 5965 + { PseudoVMSGT_VI_MF8, VMSGT_VI, 0x5, 0x0 }, // 5966 + { PseudoVMSGT_VI_MF8_MASK, VMSGT_VI, 0x5, 0x0 }, // 5967 + { PseudoVMSGT_VI_MF4, VMSGT_VI, 0x6, 0x0 }, // 5968 + { PseudoVMSGT_VI_MF4_MASK, VMSGT_VI, 0x6, 0x0 }, // 5969 + { PseudoVMSGT_VI_MF2, VMSGT_VI, 0x7, 0x0 }, // 5970 + { PseudoVMSGT_VI_MF2_MASK, VMSGT_VI, 0x7, 0x0 }, // 5971 + { PseudoVMSGT_VX_M1, VMSGT_VX, 0x0, 0x0 }, // 5972 + { PseudoVMSGT_VX_M1_MASK, VMSGT_VX, 0x0, 0x0 }, // 5973 + { PseudoVMSGT_VX_M2, VMSGT_VX, 0x1, 0x0 }, // 5974 + { PseudoVMSGT_VX_M2_MASK, VMSGT_VX, 0x1, 0x0 }, // 5975 + { PseudoVMSGT_VX_M4, VMSGT_VX, 0x2, 0x0 }, // 5976 + { PseudoVMSGT_VX_M4_MASK, VMSGT_VX, 0x2, 0x0 }, // 5977 + { PseudoVMSGT_VX_M8, VMSGT_VX, 0x3, 0x0 }, // 5978 + { PseudoVMSGT_VX_M8_MASK, VMSGT_VX, 0x3, 0x0 }, // 5979 + { PseudoVMSGT_VX_MF8, VMSGT_VX, 0x5, 0x0 }, // 5980 + { PseudoVMSGT_VX_MF8_MASK, VMSGT_VX, 0x5, 0x0 }, // 5981 + { PseudoVMSGT_VX_MF4, VMSGT_VX, 0x6, 0x0 }, // 5982 + { PseudoVMSGT_VX_MF4_MASK, VMSGT_VX, 0x6, 0x0 }, // 5983 + { PseudoVMSGT_VX_MF2, VMSGT_VX, 0x7, 0x0 }, // 5984 + { PseudoVMSGT_VX_MF2_MASK, VMSGT_VX, 0x7, 0x0 }, // 5985 + { PseudoVMSIF_M_B8, VMSIF_M, 0x0, 0x0 }, // 5986 + { PseudoVMSIF_M_B8_MASK, VMSIF_M, 0x0, 0x0 }, // 5987 + { PseudoVMSIF_M_B16, VMSIF_M, 0x1, 0x0 }, // 5988 + { PseudoVMSIF_M_B16_MASK, VMSIF_M, 0x1, 0x0 }, // 5989 + { PseudoVMSIF_M_B32, VMSIF_M, 0x2, 0x0 }, // 5990 + { PseudoVMSIF_M_B32_MASK, VMSIF_M, 0x2, 0x0 }, // 5991 + { PseudoVMSIF_M_B64, VMSIF_M, 0x3, 0x0 }, // 5992 + { PseudoVMSIF_M_B64_MASK, VMSIF_M, 0x3, 0x0 }, // 5993 + { PseudoVMSIF_M_B1, VMSIF_M, 0x5, 0x0 }, // 5994 + { PseudoVMSIF_M_B1_MASK, VMSIF_M, 0x5, 0x0 }, // 5995 + { PseudoVMSIF_M_B2, VMSIF_M, 0x6, 0x0 }, // 5996 + { PseudoVMSIF_M_B2_MASK, VMSIF_M, 0x6, 0x0 }, // 5997 + { PseudoVMSIF_M_B4, VMSIF_M, 0x7, 0x0 }, // 5998 + { PseudoVMSIF_M_B4_MASK, VMSIF_M, 0x7, 0x0 }, // 5999 + { PseudoVMSLEU_VI_M1, VMSLEU_VI, 0x0, 0x0 }, // 6000 + { PseudoVMSLEU_VI_M1_MASK, VMSLEU_VI, 0x0, 0x0 }, // 6001 + { PseudoVMSLEU_VI_M2, VMSLEU_VI, 0x1, 0x0 }, // 6002 + { PseudoVMSLEU_VI_M2_MASK, VMSLEU_VI, 0x1, 0x0 }, // 6003 + { PseudoVMSLEU_VI_M4, VMSLEU_VI, 0x2, 0x0 }, // 6004 + { PseudoVMSLEU_VI_M4_MASK, VMSLEU_VI, 0x2, 0x0 }, // 6005 + { PseudoVMSLEU_VI_M8, VMSLEU_VI, 0x3, 0x0 }, // 6006 + { PseudoVMSLEU_VI_M8_MASK, VMSLEU_VI, 0x3, 0x0 }, // 6007 + { PseudoVMSLEU_VI_MF8, VMSLEU_VI, 0x5, 0x0 }, // 6008 + { PseudoVMSLEU_VI_MF8_MASK, VMSLEU_VI, 0x5, 0x0 }, // 6009 + { PseudoVMSLEU_VI_MF4, VMSLEU_VI, 0x6, 0x0 }, // 6010 + { PseudoVMSLEU_VI_MF4_MASK, VMSLEU_VI, 0x6, 0x0 }, // 6011 + { PseudoVMSLEU_VI_MF2, VMSLEU_VI, 0x7, 0x0 }, // 6012 + { PseudoVMSLEU_VI_MF2_MASK, VMSLEU_VI, 0x7, 0x0 }, // 6013 + { PseudoVMSLEU_VV_M1, VMSLEU_VV, 0x0, 0x0 }, // 6014 + { PseudoVMSLEU_VV_M1_MASK, VMSLEU_VV, 0x0, 0x0 }, // 6015 + { PseudoVMSLEU_VV_M2, VMSLEU_VV, 0x1, 0x0 }, // 6016 + { PseudoVMSLEU_VV_M2_MASK, VMSLEU_VV, 0x1, 0x0 }, // 6017 + { PseudoVMSLEU_VV_M4, VMSLEU_VV, 0x2, 0x0 }, // 6018 + { PseudoVMSLEU_VV_M4_MASK, VMSLEU_VV, 0x2, 0x0 }, // 6019 + { PseudoVMSLEU_VV_M8, VMSLEU_VV, 0x3, 0x0 }, // 6020 + { PseudoVMSLEU_VV_M8_MASK, VMSLEU_VV, 0x3, 0x0 }, // 6021 + { PseudoVMSLEU_VV_MF8, VMSLEU_VV, 0x5, 0x0 }, // 6022 + { PseudoVMSLEU_VV_MF8_MASK, VMSLEU_VV, 0x5, 0x0 }, // 6023 + { PseudoVMSLEU_VV_MF4, VMSLEU_VV, 0x6, 0x0 }, // 6024 + { PseudoVMSLEU_VV_MF4_MASK, VMSLEU_VV, 0x6, 0x0 }, // 6025 + { PseudoVMSLEU_VV_MF2, VMSLEU_VV, 0x7, 0x0 }, // 6026 + { PseudoVMSLEU_VV_MF2_MASK, VMSLEU_VV, 0x7, 0x0 }, // 6027 + { PseudoVMSLEU_VX_M1, VMSLEU_VX, 0x0, 0x0 }, // 6028 + { PseudoVMSLEU_VX_M1_MASK, VMSLEU_VX, 0x0, 0x0 }, // 6029 + { PseudoVMSLEU_VX_M2, VMSLEU_VX, 0x1, 0x0 }, // 6030 + { PseudoVMSLEU_VX_M2_MASK, VMSLEU_VX, 0x1, 0x0 }, // 6031 + { PseudoVMSLEU_VX_M4, VMSLEU_VX, 0x2, 0x0 }, // 6032 + { PseudoVMSLEU_VX_M4_MASK, VMSLEU_VX, 0x2, 0x0 }, // 6033 + { PseudoVMSLEU_VX_M8, VMSLEU_VX, 0x3, 0x0 }, // 6034 + { PseudoVMSLEU_VX_M8_MASK, VMSLEU_VX, 0x3, 0x0 }, // 6035 + { PseudoVMSLEU_VX_MF8, VMSLEU_VX, 0x5, 0x0 }, // 6036 + { PseudoVMSLEU_VX_MF8_MASK, VMSLEU_VX, 0x5, 0x0 }, // 6037 + { PseudoVMSLEU_VX_MF4, VMSLEU_VX, 0x6, 0x0 }, // 6038 + { PseudoVMSLEU_VX_MF4_MASK, VMSLEU_VX, 0x6, 0x0 }, // 6039 + { PseudoVMSLEU_VX_MF2, VMSLEU_VX, 0x7, 0x0 }, // 6040 + { PseudoVMSLEU_VX_MF2_MASK, VMSLEU_VX, 0x7, 0x0 }, // 6041 + { PseudoVMSLE_VI_M1, VMSLE_VI, 0x0, 0x0 }, // 6042 + { PseudoVMSLE_VI_M1_MASK, VMSLE_VI, 0x0, 0x0 }, // 6043 + { PseudoVMSLE_VI_M2, VMSLE_VI, 0x1, 0x0 }, // 6044 + { PseudoVMSLE_VI_M2_MASK, VMSLE_VI, 0x1, 0x0 }, // 6045 + { PseudoVMSLE_VI_M4, VMSLE_VI, 0x2, 0x0 }, // 6046 + { PseudoVMSLE_VI_M4_MASK, VMSLE_VI, 0x2, 0x0 }, // 6047 + { PseudoVMSLE_VI_M8, VMSLE_VI, 0x3, 0x0 }, // 6048 + { PseudoVMSLE_VI_M8_MASK, VMSLE_VI, 0x3, 0x0 }, // 6049 + { PseudoVMSLE_VI_MF8, VMSLE_VI, 0x5, 0x0 }, // 6050 + { PseudoVMSLE_VI_MF8_MASK, VMSLE_VI, 0x5, 0x0 }, // 6051 + { PseudoVMSLE_VI_MF4, VMSLE_VI, 0x6, 0x0 }, // 6052 + { PseudoVMSLE_VI_MF4_MASK, VMSLE_VI, 0x6, 0x0 }, // 6053 + { PseudoVMSLE_VI_MF2, VMSLE_VI, 0x7, 0x0 }, // 6054 + { PseudoVMSLE_VI_MF2_MASK, VMSLE_VI, 0x7, 0x0 }, // 6055 + { PseudoVMSLE_VV_M1, VMSLE_VV, 0x0, 0x0 }, // 6056 + { PseudoVMSLE_VV_M1_MASK, VMSLE_VV, 0x0, 0x0 }, // 6057 + { PseudoVMSLE_VV_M2, VMSLE_VV, 0x1, 0x0 }, // 6058 + { PseudoVMSLE_VV_M2_MASK, VMSLE_VV, 0x1, 0x0 }, // 6059 + { PseudoVMSLE_VV_M4, VMSLE_VV, 0x2, 0x0 }, // 6060 + { PseudoVMSLE_VV_M4_MASK, VMSLE_VV, 0x2, 0x0 }, // 6061 + { PseudoVMSLE_VV_M8, VMSLE_VV, 0x3, 0x0 }, // 6062 + { PseudoVMSLE_VV_M8_MASK, VMSLE_VV, 0x3, 0x0 }, // 6063 + { PseudoVMSLE_VV_MF8, VMSLE_VV, 0x5, 0x0 }, // 6064 + { PseudoVMSLE_VV_MF8_MASK, VMSLE_VV, 0x5, 0x0 }, // 6065 + { PseudoVMSLE_VV_MF4, VMSLE_VV, 0x6, 0x0 }, // 6066 + { PseudoVMSLE_VV_MF4_MASK, VMSLE_VV, 0x6, 0x0 }, // 6067 + { PseudoVMSLE_VV_MF2, VMSLE_VV, 0x7, 0x0 }, // 6068 + { PseudoVMSLE_VV_MF2_MASK, VMSLE_VV, 0x7, 0x0 }, // 6069 + { PseudoVMSLE_VX_M1, VMSLE_VX, 0x0, 0x0 }, // 6070 + { PseudoVMSLE_VX_M1_MASK, VMSLE_VX, 0x0, 0x0 }, // 6071 + { PseudoVMSLE_VX_M2, VMSLE_VX, 0x1, 0x0 }, // 6072 + { PseudoVMSLE_VX_M2_MASK, VMSLE_VX, 0x1, 0x0 }, // 6073 + { PseudoVMSLE_VX_M4, VMSLE_VX, 0x2, 0x0 }, // 6074 + { PseudoVMSLE_VX_M4_MASK, VMSLE_VX, 0x2, 0x0 }, // 6075 + { PseudoVMSLE_VX_M8, VMSLE_VX, 0x3, 0x0 }, // 6076 + { PseudoVMSLE_VX_M8_MASK, VMSLE_VX, 0x3, 0x0 }, // 6077 + { PseudoVMSLE_VX_MF8, VMSLE_VX, 0x5, 0x0 }, // 6078 + { PseudoVMSLE_VX_MF8_MASK, VMSLE_VX, 0x5, 0x0 }, // 6079 + { PseudoVMSLE_VX_MF4, VMSLE_VX, 0x6, 0x0 }, // 6080 + { PseudoVMSLE_VX_MF4_MASK, VMSLE_VX, 0x6, 0x0 }, // 6081 + { PseudoVMSLE_VX_MF2, VMSLE_VX, 0x7, 0x0 }, // 6082 + { PseudoVMSLE_VX_MF2_MASK, VMSLE_VX, 0x7, 0x0 }, // 6083 + { PseudoVMSLTU_VV_M1, VMSLTU_VV, 0x0, 0x0 }, // 6084 + { PseudoVMSLTU_VV_M1_MASK, VMSLTU_VV, 0x0, 0x0 }, // 6085 + { PseudoVMSLTU_VV_M2, VMSLTU_VV, 0x1, 0x0 }, // 6086 + { PseudoVMSLTU_VV_M2_MASK, VMSLTU_VV, 0x1, 0x0 }, // 6087 + { PseudoVMSLTU_VV_M4, VMSLTU_VV, 0x2, 0x0 }, // 6088 + { PseudoVMSLTU_VV_M4_MASK, VMSLTU_VV, 0x2, 0x0 }, // 6089 + { PseudoVMSLTU_VV_M8, VMSLTU_VV, 0x3, 0x0 }, // 6090 + { PseudoVMSLTU_VV_M8_MASK, VMSLTU_VV, 0x3, 0x0 }, // 6091 + { PseudoVMSLTU_VV_MF8, VMSLTU_VV, 0x5, 0x0 }, // 6092 + { PseudoVMSLTU_VV_MF8_MASK, VMSLTU_VV, 0x5, 0x0 }, // 6093 + { PseudoVMSLTU_VV_MF4, VMSLTU_VV, 0x6, 0x0 }, // 6094 + { PseudoVMSLTU_VV_MF4_MASK, VMSLTU_VV, 0x6, 0x0 }, // 6095 + { PseudoVMSLTU_VV_MF2, VMSLTU_VV, 0x7, 0x0 }, // 6096 + { PseudoVMSLTU_VV_MF2_MASK, VMSLTU_VV, 0x7, 0x0 }, // 6097 + { PseudoVMSLTU_VX_M1, VMSLTU_VX, 0x0, 0x0 }, // 6098 + { PseudoVMSLTU_VX_M1_MASK, VMSLTU_VX, 0x0, 0x0 }, // 6099 + { PseudoVMSLTU_VX_M2, VMSLTU_VX, 0x1, 0x0 }, // 6100 + { PseudoVMSLTU_VX_M2_MASK, VMSLTU_VX, 0x1, 0x0 }, // 6101 + { PseudoVMSLTU_VX_M4, VMSLTU_VX, 0x2, 0x0 }, // 6102 + { PseudoVMSLTU_VX_M4_MASK, VMSLTU_VX, 0x2, 0x0 }, // 6103 + { PseudoVMSLTU_VX_M8, VMSLTU_VX, 0x3, 0x0 }, // 6104 + { PseudoVMSLTU_VX_M8_MASK, VMSLTU_VX, 0x3, 0x0 }, // 6105 + { PseudoVMSLTU_VX_MF8, VMSLTU_VX, 0x5, 0x0 }, // 6106 + { PseudoVMSLTU_VX_MF8_MASK, VMSLTU_VX, 0x5, 0x0 }, // 6107 + { PseudoVMSLTU_VX_MF4, VMSLTU_VX, 0x6, 0x0 }, // 6108 + { PseudoVMSLTU_VX_MF4_MASK, VMSLTU_VX, 0x6, 0x0 }, // 6109 + { PseudoVMSLTU_VX_MF2, VMSLTU_VX, 0x7, 0x0 }, // 6110 + { PseudoVMSLTU_VX_MF2_MASK, VMSLTU_VX, 0x7, 0x0 }, // 6111 + { PseudoVMSLT_VV_M1, VMSLT_VV, 0x0, 0x0 }, // 6112 + { PseudoVMSLT_VV_M1_MASK, VMSLT_VV, 0x0, 0x0 }, // 6113 + { PseudoVMSLT_VV_M2, VMSLT_VV, 0x1, 0x0 }, // 6114 + { PseudoVMSLT_VV_M2_MASK, VMSLT_VV, 0x1, 0x0 }, // 6115 + { PseudoVMSLT_VV_M4, VMSLT_VV, 0x2, 0x0 }, // 6116 + { PseudoVMSLT_VV_M4_MASK, VMSLT_VV, 0x2, 0x0 }, // 6117 + { PseudoVMSLT_VV_M8, VMSLT_VV, 0x3, 0x0 }, // 6118 + { PseudoVMSLT_VV_M8_MASK, VMSLT_VV, 0x3, 0x0 }, // 6119 + { PseudoVMSLT_VV_MF8, VMSLT_VV, 0x5, 0x0 }, // 6120 + { PseudoVMSLT_VV_MF8_MASK, VMSLT_VV, 0x5, 0x0 }, // 6121 + { PseudoVMSLT_VV_MF4, VMSLT_VV, 0x6, 0x0 }, // 6122 + { PseudoVMSLT_VV_MF4_MASK, VMSLT_VV, 0x6, 0x0 }, // 6123 + { PseudoVMSLT_VV_MF2, VMSLT_VV, 0x7, 0x0 }, // 6124 + { PseudoVMSLT_VV_MF2_MASK, VMSLT_VV, 0x7, 0x0 }, // 6125 + { PseudoVMSLT_VX_M1, VMSLT_VX, 0x0, 0x0 }, // 6126 + { PseudoVMSLT_VX_M1_MASK, VMSLT_VX, 0x0, 0x0 }, // 6127 + { PseudoVMSLT_VX_M2, VMSLT_VX, 0x1, 0x0 }, // 6128 + { PseudoVMSLT_VX_M2_MASK, VMSLT_VX, 0x1, 0x0 }, // 6129 + { PseudoVMSLT_VX_M4, VMSLT_VX, 0x2, 0x0 }, // 6130 + { PseudoVMSLT_VX_M4_MASK, VMSLT_VX, 0x2, 0x0 }, // 6131 + { PseudoVMSLT_VX_M8, VMSLT_VX, 0x3, 0x0 }, // 6132 + { PseudoVMSLT_VX_M8_MASK, VMSLT_VX, 0x3, 0x0 }, // 6133 + { PseudoVMSLT_VX_MF8, VMSLT_VX, 0x5, 0x0 }, // 6134 + { PseudoVMSLT_VX_MF8_MASK, VMSLT_VX, 0x5, 0x0 }, // 6135 + { PseudoVMSLT_VX_MF4, VMSLT_VX, 0x6, 0x0 }, // 6136 + { PseudoVMSLT_VX_MF4_MASK, VMSLT_VX, 0x6, 0x0 }, // 6137 + { PseudoVMSLT_VX_MF2, VMSLT_VX, 0x7, 0x0 }, // 6138 + { PseudoVMSLT_VX_MF2_MASK, VMSLT_VX, 0x7, 0x0 }, // 6139 + { PseudoVMSNE_VI_M1, VMSNE_VI, 0x0, 0x0 }, // 6140 + { PseudoVMSNE_VI_M1_MASK, VMSNE_VI, 0x0, 0x0 }, // 6141 + { PseudoVMSNE_VI_M2, VMSNE_VI, 0x1, 0x0 }, // 6142 + { PseudoVMSNE_VI_M2_MASK, VMSNE_VI, 0x1, 0x0 }, // 6143 + { PseudoVMSNE_VI_M4, VMSNE_VI, 0x2, 0x0 }, // 6144 + { PseudoVMSNE_VI_M4_MASK, VMSNE_VI, 0x2, 0x0 }, // 6145 + { PseudoVMSNE_VI_M8, VMSNE_VI, 0x3, 0x0 }, // 6146 + { PseudoVMSNE_VI_M8_MASK, VMSNE_VI, 0x3, 0x0 }, // 6147 + { PseudoVMSNE_VI_MF8, VMSNE_VI, 0x5, 0x0 }, // 6148 + { PseudoVMSNE_VI_MF8_MASK, VMSNE_VI, 0x5, 0x0 }, // 6149 + { PseudoVMSNE_VI_MF4, VMSNE_VI, 0x6, 0x0 }, // 6150 + { PseudoVMSNE_VI_MF4_MASK, VMSNE_VI, 0x6, 0x0 }, // 6151 + { PseudoVMSNE_VI_MF2, VMSNE_VI, 0x7, 0x0 }, // 6152 + { PseudoVMSNE_VI_MF2_MASK, VMSNE_VI, 0x7, 0x0 }, // 6153 + { PseudoVMSNE_VV_M1, VMSNE_VV, 0x0, 0x0 }, // 6154 + { PseudoVMSNE_VV_M1_MASK, VMSNE_VV, 0x0, 0x0 }, // 6155 + { PseudoVMSNE_VV_M2, VMSNE_VV, 0x1, 0x0 }, // 6156 + { PseudoVMSNE_VV_M2_MASK, VMSNE_VV, 0x1, 0x0 }, // 6157 + { PseudoVMSNE_VV_M4, VMSNE_VV, 0x2, 0x0 }, // 6158 + { PseudoVMSNE_VV_M4_MASK, VMSNE_VV, 0x2, 0x0 }, // 6159 + { PseudoVMSNE_VV_M8, VMSNE_VV, 0x3, 0x0 }, // 6160 + { PseudoVMSNE_VV_M8_MASK, VMSNE_VV, 0x3, 0x0 }, // 6161 + { PseudoVMSNE_VV_MF8, VMSNE_VV, 0x5, 0x0 }, // 6162 + { PseudoVMSNE_VV_MF8_MASK, VMSNE_VV, 0x5, 0x0 }, // 6163 + { PseudoVMSNE_VV_MF4, VMSNE_VV, 0x6, 0x0 }, // 6164 + { PseudoVMSNE_VV_MF4_MASK, VMSNE_VV, 0x6, 0x0 }, // 6165 + { PseudoVMSNE_VV_MF2, VMSNE_VV, 0x7, 0x0 }, // 6166 + { PseudoVMSNE_VV_MF2_MASK, VMSNE_VV, 0x7, 0x0 }, // 6167 + { PseudoVMSNE_VX_M1, VMSNE_VX, 0x0, 0x0 }, // 6168 + { PseudoVMSNE_VX_M1_MASK, VMSNE_VX, 0x0, 0x0 }, // 6169 + { PseudoVMSNE_VX_M2, VMSNE_VX, 0x1, 0x0 }, // 6170 + { PseudoVMSNE_VX_M2_MASK, VMSNE_VX, 0x1, 0x0 }, // 6171 + { PseudoVMSNE_VX_M4, VMSNE_VX, 0x2, 0x0 }, // 6172 + { PseudoVMSNE_VX_M4_MASK, VMSNE_VX, 0x2, 0x0 }, // 6173 + { PseudoVMSNE_VX_M8, VMSNE_VX, 0x3, 0x0 }, // 6174 + { PseudoVMSNE_VX_M8_MASK, VMSNE_VX, 0x3, 0x0 }, // 6175 + { PseudoVMSNE_VX_MF8, VMSNE_VX, 0x5, 0x0 }, // 6176 + { PseudoVMSNE_VX_MF8_MASK, VMSNE_VX, 0x5, 0x0 }, // 6177 + { PseudoVMSNE_VX_MF4, VMSNE_VX, 0x6, 0x0 }, // 6178 + { PseudoVMSNE_VX_MF4_MASK, VMSNE_VX, 0x6, 0x0 }, // 6179 + { PseudoVMSNE_VX_MF2, VMSNE_VX, 0x7, 0x0 }, // 6180 + { PseudoVMSNE_VX_MF2_MASK, VMSNE_VX, 0x7, 0x0 }, // 6181 + { PseudoVMSOF_M_B8, VMSOF_M, 0x0, 0x0 }, // 6182 + { PseudoVMSOF_M_B8_MASK, VMSOF_M, 0x0, 0x0 }, // 6183 + { PseudoVMSOF_M_B16, VMSOF_M, 0x1, 0x0 }, // 6184 + { PseudoVMSOF_M_B16_MASK, VMSOF_M, 0x1, 0x0 }, // 6185 + { PseudoVMSOF_M_B32, VMSOF_M, 0x2, 0x0 }, // 6186 + { PseudoVMSOF_M_B32_MASK, VMSOF_M, 0x2, 0x0 }, // 6187 + { PseudoVMSOF_M_B64, VMSOF_M, 0x3, 0x0 }, // 6188 + { PseudoVMSOF_M_B64_MASK, VMSOF_M, 0x3, 0x0 }, // 6189 + { PseudoVMSOF_M_B1, VMSOF_M, 0x5, 0x0 }, // 6190 + { PseudoVMSOF_M_B1_MASK, VMSOF_M, 0x5, 0x0 }, // 6191 + { PseudoVMSOF_M_B2, VMSOF_M, 0x6, 0x0 }, // 6192 + { PseudoVMSOF_M_B2_MASK, VMSOF_M, 0x6, 0x0 }, // 6193 + { PseudoVMSOF_M_B4, VMSOF_M, 0x7, 0x0 }, // 6194 + { PseudoVMSOF_M_B4_MASK, VMSOF_M, 0x7, 0x0 }, // 6195 + { PseudoVMULHSU_VV_M1, VMULHSU_VV, 0x0, 0x0 }, // 6196 + { PseudoVMULHSU_VV_M1_MASK, VMULHSU_VV, 0x0, 0x0 }, // 6197 + { PseudoVMULHSU_VV_M2, VMULHSU_VV, 0x1, 0x0 }, // 6198 + { PseudoVMULHSU_VV_M2_MASK, VMULHSU_VV, 0x1, 0x0 }, // 6199 + { PseudoVMULHSU_VV_M4, VMULHSU_VV, 0x2, 0x0 }, // 6200 + { PseudoVMULHSU_VV_M4_MASK, VMULHSU_VV, 0x2, 0x0 }, // 6201 + { PseudoVMULHSU_VV_M8, VMULHSU_VV, 0x3, 0x0 }, // 6202 + { PseudoVMULHSU_VV_M8_MASK, VMULHSU_VV, 0x3, 0x0 }, // 6203 + { PseudoVMULHSU_VV_MF8, VMULHSU_VV, 0x5, 0x0 }, // 6204 + { PseudoVMULHSU_VV_MF8_MASK, VMULHSU_VV, 0x5, 0x0 }, // 6205 + { PseudoVMULHSU_VV_MF4, VMULHSU_VV, 0x6, 0x0 }, // 6206 + { PseudoVMULHSU_VV_MF4_MASK, VMULHSU_VV, 0x6, 0x0 }, // 6207 + { PseudoVMULHSU_VV_MF2, VMULHSU_VV, 0x7, 0x0 }, // 6208 + { PseudoVMULHSU_VV_MF2_MASK, VMULHSU_VV, 0x7, 0x0 }, // 6209 + { PseudoVMULHSU_VX_M1, VMULHSU_VX, 0x0, 0x0 }, // 6210 + { PseudoVMULHSU_VX_M1_MASK, VMULHSU_VX, 0x0, 0x0 }, // 6211 + { PseudoVMULHSU_VX_M2, VMULHSU_VX, 0x1, 0x0 }, // 6212 + { PseudoVMULHSU_VX_M2_MASK, VMULHSU_VX, 0x1, 0x0 }, // 6213 + { PseudoVMULHSU_VX_M4, VMULHSU_VX, 0x2, 0x0 }, // 6214 + { PseudoVMULHSU_VX_M4_MASK, VMULHSU_VX, 0x2, 0x0 }, // 6215 + { PseudoVMULHSU_VX_M8, VMULHSU_VX, 0x3, 0x0 }, // 6216 + { PseudoVMULHSU_VX_M8_MASK, VMULHSU_VX, 0x3, 0x0 }, // 6217 + { PseudoVMULHSU_VX_MF8, VMULHSU_VX, 0x5, 0x0 }, // 6218 + { PseudoVMULHSU_VX_MF8_MASK, VMULHSU_VX, 0x5, 0x0 }, // 6219 + { PseudoVMULHSU_VX_MF4, VMULHSU_VX, 0x6, 0x0 }, // 6220 + { PseudoVMULHSU_VX_MF4_MASK, VMULHSU_VX, 0x6, 0x0 }, // 6221 + { PseudoVMULHSU_VX_MF2, VMULHSU_VX, 0x7, 0x0 }, // 6222 + { PseudoVMULHSU_VX_MF2_MASK, VMULHSU_VX, 0x7, 0x0 }, // 6223 + { PseudoVMULHU_VV_M1, VMULHU_VV, 0x0, 0x0 }, // 6224 + { PseudoVMULHU_VV_M1_MASK, VMULHU_VV, 0x0, 0x0 }, // 6225 + { PseudoVMULHU_VV_M2, VMULHU_VV, 0x1, 0x0 }, // 6226 + { PseudoVMULHU_VV_M2_MASK, VMULHU_VV, 0x1, 0x0 }, // 6227 + { PseudoVMULHU_VV_M4, VMULHU_VV, 0x2, 0x0 }, // 6228 + { PseudoVMULHU_VV_M4_MASK, VMULHU_VV, 0x2, 0x0 }, // 6229 + { PseudoVMULHU_VV_M8, VMULHU_VV, 0x3, 0x0 }, // 6230 + { PseudoVMULHU_VV_M8_MASK, VMULHU_VV, 0x3, 0x0 }, // 6231 + { PseudoVMULHU_VV_MF8, VMULHU_VV, 0x5, 0x0 }, // 6232 + { PseudoVMULHU_VV_MF8_MASK, VMULHU_VV, 0x5, 0x0 }, // 6233 + { PseudoVMULHU_VV_MF4, VMULHU_VV, 0x6, 0x0 }, // 6234 + { PseudoVMULHU_VV_MF4_MASK, VMULHU_VV, 0x6, 0x0 }, // 6235 + { PseudoVMULHU_VV_MF2, VMULHU_VV, 0x7, 0x0 }, // 6236 + { PseudoVMULHU_VV_MF2_MASK, VMULHU_VV, 0x7, 0x0 }, // 6237 + { PseudoVMULHU_VX_M1, VMULHU_VX, 0x0, 0x0 }, // 6238 + { PseudoVMULHU_VX_M1_MASK, VMULHU_VX, 0x0, 0x0 }, // 6239 + { PseudoVMULHU_VX_M2, VMULHU_VX, 0x1, 0x0 }, // 6240 + { PseudoVMULHU_VX_M2_MASK, VMULHU_VX, 0x1, 0x0 }, // 6241 + { PseudoVMULHU_VX_M4, VMULHU_VX, 0x2, 0x0 }, // 6242 + { PseudoVMULHU_VX_M4_MASK, VMULHU_VX, 0x2, 0x0 }, // 6243 + { PseudoVMULHU_VX_M8, VMULHU_VX, 0x3, 0x0 }, // 6244 + { PseudoVMULHU_VX_M8_MASK, VMULHU_VX, 0x3, 0x0 }, // 6245 + { PseudoVMULHU_VX_MF8, VMULHU_VX, 0x5, 0x0 }, // 6246 + { PseudoVMULHU_VX_MF8_MASK, VMULHU_VX, 0x5, 0x0 }, // 6247 + { PseudoVMULHU_VX_MF4, VMULHU_VX, 0x6, 0x0 }, // 6248 + { PseudoVMULHU_VX_MF4_MASK, VMULHU_VX, 0x6, 0x0 }, // 6249 + { PseudoVMULHU_VX_MF2, VMULHU_VX, 0x7, 0x0 }, // 6250 + { PseudoVMULHU_VX_MF2_MASK, VMULHU_VX, 0x7, 0x0 }, // 6251 + { PseudoVMULH_VV_M1, VMULH_VV, 0x0, 0x0 }, // 6252 + { PseudoVMULH_VV_M1_MASK, VMULH_VV, 0x0, 0x0 }, // 6253 + { PseudoVMULH_VV_M2, VMULH_VV, 0x1, 0x0 }, // 6254 + { PseudoVMULH_VV_M2_MASK, VMULH_VV, 0x1, 0x0 }, // 6255 + { PseudoVMULH_VV_M4, VMULH_VV, 0x2, 0x0 }, // 6256 + { PseudoVMULH_VV_M4_MASK, VMULH_VV, 0x2, 0x0 }, // 6257 + { PseudoVMULH_VV_M8, VMULH_VV, 0x3, 0x0 }, // 6258 + { PseudoVMULH_VV_M8_MASK, VMULH_VV, 0x3, 0x0 }, // 6259 + { PseudoVMULH_VV_MF8, VMULH_VV, 0x5, 0x0 }, // 6260 + { PseudoVMULH_VV_MF8_MASK, VMULH_VV, 0x5, 0x0 }, // 6261 + { PseudoVMULH_VV_MF4, VMULH_VV, 0x6, 0x0 }, // 6262 + { PseudoVMULH_VV_MF4_MASK, VMULH_VV, 0x6, 0x0 }, // 6263 + { PseudoVMULH_VV_MF2, VMULH_VV, 0x7, 0x0 }, // 6264 + { PseudoVMULH_VV_MF2_MASK, VMULH_VV, 0x7, 0x0 }, // 6265 + { PseudoVMULH_VX_M1, VMULH_VX, 0x0, 0x0 }, // 6266 + { PseudoVMULH_VX_M1_MASK, VMULH_VX, 0x0, 0x0 }, // 6267 + { PseudoVMULH_VX_M2, VMULH_VX, 0x1, 0x0 }, // 6268 + { PseudoVMULH_VX_M2_MASK, VMULH_VX, 0x1, 0x0 }, // 6269 + { PseudoVMULH_VX_M4, VMULH_VX, 0x2, 0x0 }, // 6270 + { PseudoVMULH_VX_M4_MASK, VMULH_VX, 0x2, 0x0 }, // 6271 + { PseudoVMULH_VX_M8, VMULH_VX, 0x3, 0x0 }, // 6272 + { PseudoVMULH_VX_M8_MASK, VMULH_VX, 0x3, 0x0 }, // 6273 + { PseudoVMULH_VX_MF8, VMULH_VX, 0x5, 0x0 }, // 6274 + { PseudoVMULH_VX_MF8_MASK, VMULH_VX, 0x5, 0x0 }, // 6275 + { PseudoVMULH_VX_MF4, VMULH_VX, 0x6, 0x0 }, // 6276 + { PseudoVMULH_VX_MF4_MASK, VMULH_VX, 0x6, 0x0 }, // 6277 + { PseudoVMULH_VX_MF2, VMULH_VX, 0x7, 0x0 }, // 6278 + { PseudoVMULH_VX_MF2_MASK, VMULH_VX, 0x7, 0x0 }, // 6279 + { PseudoVMUL_VV_M1, VMUL_VV, 0x0, 0x0 }, // 6280 + { PseudoVMUL_VV_M1_MASK, VMUL_VV, 0x0, 0x0 }, // 6281 + { PseudoVMUL_VV_M2, VMUL_VV, 0x1, 0x0 }, // 6282 + { PseudoVMUL_VV_M2_MASK, VMUL_VV, 0x1, 0x0 }, // 6283 + { PseudoVMUL_VV_M4, VMUL_VV, 0x2, 0x0 }, // 6284 + { PseudoVMUL_VV_M4_MASK, VMUL_VV, 0x2, 0x0 }, // 6285 + { PseudoVMUL_VV_M8, VMUL_VV, 0x3, 0x0 }, // 6286 + { PseudoVMUL_VV_M8_MASK, VMUL_VV, 0x3, 0x0 }, // 6287 + { PseudoVMUL_VV_MF8, VMUL_VV, 0x5, 0x0 }, // 6288 + { PseudoVMUL_VV_MF8_MASK, VMUL_VV, 0x5, 0x0 }, // 6289 + { PseudoVMUL_VV_MF4, VMUL_VV, 0x6, 0x0 }, // 6290 + { PseudoVMUL_VV_MF4_MASK, VMUL_VV, 0x6, 0x0 }, // 6291 + { PseudoVMUL_VV_MF2, VMUL_VV, 0x7, 0x0 }, // 6292 + { PseudoVMUL_VV_MF2_MASK, VMUL_VV, 0x7, 0x0 }, // 6293 + { PseudoVMUL_VX_M1, VMUL_VX, 0x0, 0x0 }, // 6294 + { PseudoVMUL_VX_M1_MASK, VMUL_VX, 0x0, 0x0 }, // 6295 + { PseudoVMUL_VX_M2, VMUL_VX, 0x1, 0x0 }, // 6296 + { PseudoVMUL_VX_M2_MASK, VMUL_VX, 0x1, 0x0 }, // 6297 + { PseudoVMUL_VX_M4, VMUL_VX, 0x2, 0x0 }, // 6298 + { PseudoVMUL_VX_M4_MASK, VMUL_VX, 0x2, 0x0 }, // 6299 + { PseudoVMUL_VX_M8, VMUL_VX, 0x3, 0x0 }, // 6300 + { PseudoVMUL_VX_M8_MASK, VMUL_VX, 0x3, 0x0 }, // 6301 + { PseudoVMUL_VX_MF8, VMUL_VX, 0x5, 0x0 }, // 6302 + { PseudoVMUL_VX_MF8_MASK, VMUL_VX, 0x5, 0x0 }, // 6303 + { PseudoVMUL_VX_MF4, VMUL_VX, 0x6, 0x0 }, // 6304 + { PseudoVMUL_VX_MF4_MASK, VMUL_VX, 0x6, 0x0 }, // 6305 + { PseudoVMUL_VX_MF2, VMUL_VX, 0x7, 0x0 }, // 6306 + { PseudoVMUL_VX_MF2_MASK, VMUL_VX, 0x7, 0x0 }, // 6307 + { PseudoVMV_S_X, VMV_S_X, 0x0, 0x0 }, // 6308 + { PseudoVMV_V_I_M1, VMV_V_I, 0x0, 0x0 }, // 6309 + { PseudoVMV_V_I_M2, VMV_V_I, 0x1, 0x0 }, // 6310 + { PseudoVMV_V_I_M4, VMV_V_I, 0x2, 0x0 }, // 6311 + { PseudoVMV_V_I_M8, VMV_V_I, 0x3, 0x0 }, // 6312 + { PseudoVMV_V_I_MF8, VMV_V_I, 0x5, 0x0 }, // 6313 + { PseudoVMV_V_I_MF4, VMV_V_I, 0x6, 0x0 }, // 6314 + { PseudoVMV_V_I_MF2, VMV_V_I, 0x7, 0x0 }, // 6315 + { PseudoVMV_V_V_M1, VMV_V_V, 0x0, 0x0 }, // 6316 + { PseudoVMV_V_V_M2, VMV_V_V, 0x1, 0x0 }, // 6317 + { PseudoVMV_V_V_M4, VMV_V_V, 0x2, 0x0 }, // 6318 + { PseudoVMV_V_V_M8, VMV_V_V, 0x3, 0x0 }, // 6319 + { PseudoVMV_V_V_MF8, VMV_V_V, 0x5, 0x0 }, // 6320 + { PseudoVMV_V_V_MF4, VMV_V_V, 0x6, 0x0 }, // 6321 + { PseudoVMV_V_V_MF2, VMV_V_V, 0x7, 0x0 }, // 6322 + { PseudoVMV_V_X_M1, VMV_V_X, 0x0, 0x0 }, // 6323 + { PseudoVMV_V_X_M2, VMV_V_X, 0x1, 0x0 }, // 6324 + { PseudoVMV_V_X_M4, VMV_V_X, 0x2, 0x0 }, // 6325 + { PseudoVMV_V_X_M8, VMV_V_X, 0x3, 0x0 }, // 6326 + { PseudoVMV_V_X_MF8, VMV_V_X, 0x5, 0x0 }, // 6327 + { PseudoVMV_V_X_MF4, VMV_V_X, 0x6, 0x0 }, // 6328 + { PseudoVMV_V_X_MF2, VMV_V_X, 0x7, 0x0 }, // 6329 + { PseudoVMV_X_S, VMV_X_S, 0x0, 0x0 }, // 6330 + { PseudoVMSET_M_B8, VMXNOR_MM, 0x0, 0x0 }, // 6331 + { PseudoVMXNOR_MM_M1, VMXNOR_MM, 0x0, 0x0 }, // 6332 + { PseudoVMSET_M_B16, VMXNOR_MM, 0x1, 0x0 }, // 6333 + { PseudoVMXNOR_MM_M2, VMXNOR_MM, 0x1, 0x0 }, // 6334 + { PseudoVMSET_M_B32, VMXNOR_MM, 0x2, 0x0 }, // 6335 + { PseudoVMXNOR_MM_M4, VMXNOR_MM, 0x2, 0x0 }, // 6336 + { PseudoVMSET_M_B64, VMXNOR_MM, 0x3, 0x0 }, // 6337 + { PseudoVMXNOR_MM_M8, VMXNOR_MM, 0x3, 0x0 }, // 6338 + { PseudoVMSET_M_B1, VMXNOR_MM, 0x5, 0x0 }, // 6339 + { PseudoVMXNOR_MM_MF8, VMXNOR_MM, 0x5, 0x0 }, // 6340 + { PseudoVMSET_M_B2, VMXNOR_MM, 0x6, 0x0 }, // 6341 + { PseudoVMXNOR_MM_MF4, VMXNOR_MM, 0x6, 0x0 }, // 6342 + { PseudoVMSET_M_B4, VMXNOR_MM, 0x7, 0x0 }, // 6343 + { PseudoVMXNOR_MM_MF2, VMXNOR_MM, 0x7, 0x0 }, // 6344 + { PseudoVMCLR_M_B8, VMXOR_MM, 0x0, 0x0 }, // 6345 + { PseudoVMXOR_MM_M1, VMXOR_MM, 0x0, 0x0 }, // 6346 + { PseudoVMCLR_M_B16, VMXOR_MM, 0x1, 0x0 }, // 6347 + { PseudoVMXOR_MM_M2, VMXOR_MM, 0x1, 0x0 }, // 6348 + { PseudoVMCLR_M_B32, VMXOR_MM, 0x2, 0x0 }, // 6349 + { PseudoVMXOR_MM_M4, VMXOR_MM, 0x2, 0x0 }, // 6350 + { PseudoVMCLR_M_B64, VMXOR_MM, 0x3, 0x0 }, // 6351 + { PseudoVMXOR_MM_M8, VMXOR_MM, 0x3, 0x0 }, // 6352 + { PseudoVMCLR_M_B1, VMXOR_MM, 0x5, 0x0 }, // 6353 + { PseudoVMXOR_MM_MF8, VMXOR_MM, 0x5, 0x0 }, // 6354 + { PseudoVMCLR_M_B2, VMXOR_MM, 0x6, 0x0 }, // 6355 + { PseudoVMXOR_MM_MF4, VMXOR_MM, 0x6, 0x0 }, // 6356 + { PseudoVMCLR_M_B4, VMXOR_MM, 0x7, 0x0 }, // 6357 + { PseudoVMXOR_MM_MF2, VMXOR_MM, 0x7, 0x0 }, // 6358 + { PseudoVNCLIPU_WI_M1, VNCLIPU_WI, 0x0, 0x0 }, // 6359 + { PseudoVNCLIPU_WI_M1_MASK, VNCLIPU_WI, 0x0, 0x0 }, // 6360 + { PseudoVNCLIPU_WI_M2, VNCLIPU_WI, 0x1, 0x0 }, // 6361 + { PseudoVNCLIPU_WI_M2_MASK, VNCLIPU_WI, 0x1, 0x0 }, // 6362 + { PseudoVNCLIPU_WI_M4, VNCLIPU_WI, 0x2, 0x0 }, // 6363 + { PseudoVNCLIPU_WI_M4_MASK, VNCLIPU_WI, 0x2, 0x0 }, // 6364 + { PseudoVNCLIPU_WI_MF8, VNCLIPU_WI, 0x5, 0x0 }, // 6365 + { PseudoVNCLIPU_WI_MF8_MASK, VNCLIPU_WI, 0x5, 0x0 }, // 6366 + { PseudoVNCLIPU_WI_MF4, VNCLIPU_WI, 0x6, 0x0 }, // 6367 + { PseudoVNCLIPU_WI_MF4_MASK, VNCLIPU_WI, 0x6, 0x0 }, // 6368 + { PseudoVNCLIPU_WI_MF2, VNCLIPU_WI, 0x7, 0x0 }, // 6369 + { PseudoVNCLIPU_WI_MF2_MASK, VNCLIPU_WI, 0x7, 0x0 }, // 6370 + { PseudoVNCLIPU_WV_M1, VNCLIPU_WV, 0x0, 0x0 }, // 6371 + { PseudoVNCLIPU_WV_M1_MASK, VNCLIPU_WV, 0x0, 0x0 }, // 6372 + { PseudoVNCLIPU_WV_M2, VNCLIPU_WV, 0x1, 0x0 }, // 6373 + { PseudoVNCLIPU_WV_M2_MASK, VNCLIPU_WV, 0x1, 0x0 }, // 6374 + { PseudoVNCLIPU_WV_M4, VNCLIPU_WV, 0x2, 0x0 }, // 6375 + { PseudoVNCLIPU_WV_M4_MASK, VNCLIPU_WV, 0x2, 0x0 }, // 6376 + { PseudoVNCLIPU_WV_MF8, VNCLIPU_WV, 0x5, 0x0 }, // 6377 + { PseudoVNCLIPU_WV_MF8_MASK, VNCLIPU_WV, 0x5, 0x0 }, // 6378 + { PseudoVNCLIPU_WV_MF4, VNCLIPU_WV, 0x6, 0x0 }, // 6379 + { PseudoVNCLIPU_WV_MF4_MASK, VNCLIPU_WV, 0x6, 0x0 }, // 6380 + { PseudoVNCLIPU_WV_MF2, VNCLIPU_WV, 0x7, 0x0 }, // 6381 + { PseudoVNCLIPU_WV_MF2_MASK, VNCLIPU_WV, 0x7, 0x0 }, // 6382 + { PseudoVNCLIPU_WX_M1, VNCLIPU_WX, 0x0, 0x0 }, // 6383 + { PseudoVNCLIPU_WX_M1_MASK, VNCLIPU_WX, 0x0, 0x0 }, // 6384 + { PseudoVNCLIPU_WX_M2, VNCLIPU_WX, 0x1, 0x0 }, // 6385 + { PseudoVNCLIPU_WX_M2_MASK, VNCLIPU_WX, 0x1, 0x0 }, // 6386 + { PseudoVNCLIPU_WX_M4, VNCLIPU_WX, 0x2, 0x0 }, // 6387 + { PseudoVNCLIPU_WX_M4_MASK, VNCLIPU_WX, 0x2, 0x0 }, // 6388 + { PseudoVNCLIPU_WX_MF8, VNCLIPU_WX, 0x5, 0x0 }, // 6389 + { PseudoVNCLIPU_WX_MF8_MASK, VNCLIPU_WX, 0x5, 0x0 }, // 6390 + { PseudoVNCLIPU_WX_MF4, VNCLIPU_WX, 0x6, 0x0 }, // 6391 + { PseudoVNCLIPU_WX_MF4_MASK, VNCLIPU_WX, 0x6, 0x0 }, // 6392 + { PseudoVNCLIPU_WX_MF2, VNCLIPU_WX, 0x7, 0x0 }, // 6393 + { PseudoVNCLIPU_WX_MF2_MASK, VNCLIPU_WX, 0x7, 0x0 }, // 6394 + { PseudoVNCLIP_WI_M1, VNCLIP_WI, 0x0, 0x0 }, // 6395 + { PseudoVNCLIP_WI_M1_MASK, VNCLIP_WI, 0x0, 0x0 }, // 6396 + { PseudoVNCLIP_WI_M2, VNCLIP_WI, 0x1, 0x0 }, // 6397 + { PseudoVNCLIP_WI_M2_MASK, VNCLIP_WI, 0x1, 0x0 }, // 6398 + { PseudoVNCLIP_WI_M4, VNCLIP_WI, 0x2, 0x0 }, // 6399 + { PseudoVNCLIP_WI_M4_MASK, VNCLIP_WI, 0x2, 0x0 }, // 6400 + { PseudoVNCLIP_WI_MF8, VNCLIP_WI, 0x5, 0x0 }, // 6401 + { PseudoVNCLIP_WI_MF8_MASK, VNCLIP_WI, 0x5, 0x0 }, // 6402 + { PseudoVNCLIP_WI_MF4, VNCLIP_WI, 0x6, 0x0 }, // 6403 + { PseudoVNCLIP_WI_MF4_MASK, VNCLIP_WI, 0x6, 0x0 }, // 6404 + { PseudoVNCLIP_WI_MF2, VNCLIP_WI, 0x7, 0x0 }, // 6405 + { PseudoVNCLIP_WI_MF2_MASK, VNCLIP_WI, 0x7, 0x0 }, // 6406 + { PseudoVNCLIP_WV_M1, VNCLIP_WV, 0x0, 0x0 }, // 6407 + { PseudoVNCLIP_WV_M1_MASK, VNCLIP_WV, 0x0, 0x0 }, // 6408 + { PseudoVNCLIP_WV_M2, VNCLIP_WV, 0x1, 0x0 }, // 6409 + { PseudoVNCLIP_WV_M2_MASK, VNCLIP_WV, 0x1, 0x0 }, // 6410 + { PseudoVNCLIP_WV_M4, VNCLIP_WV, 0x2, 0x0 }, // 6411 + { PseudoVNCLIP_WV_M4_MASK, VNCLIP_WV, 0x2, 0x0 }, // 6412 + { PseudoVNCLIP_WV_MF8, VNCLIP_WV, 0x5, 0x0 }, // 6413 + { PseudoVNCLIP_WV_MF8_MASK, VNCLIP_WV, 0x5, 0x0 }, // 6414 + { PseudoVNCLIP_WV_MF4, VNCLIP_WV, 0x6, 0x0 }, // 6415 + { PseudoVNCLIP_WV_MF4_MASK, VNCLIP_WV, 0x6, 0x0 }, // 6416 + { PseudoVNCLIP_WV_MF2, VNCLIP_WV, 0x7, 0x0 }, // 6417 + { PseudoVNCLIP_WV_MF2_MASK, VNCLIP_WV, 0x7, 0x0 }, // 6418 + { PseudoVNCLIP_WX_M1, VNCLIP_WX, 0x0, 0x0 }, // 6419 + { PseudoVNCLIP_WX_M1_MASK, VNCLIP_WX, 0x0, 0x0 }, // 6420 + { PseudoVNCLIP_WX_M2, VNCLIP_WX, 0x1, 0x0 }, // 6421 + { PseudoVNCLIP_WX_M2_MASK, VNCLIP_WX, 0x1, 0x0 }, // 6422 + { PseudoVNCLIP_WX_M4, VNCLIP_WX, 0x2, 0x0 }, // 6423 + { PseudoVNCLIP_WX_M4_MASK, VNCLIP_WX, 0x2, 0x0 }, // 6424 + { PseudoVNCLIP_WX_MF8, VNCLIP_WX, 0x5, 0x0 }, // 6425 + { PseudoVNCLIP_WX_MF8_MASK, VNCLIP_WX, 0x5, 0x0 }, // 6426 + { PseudoVNCLIP_WX_MF4, VNCLIP_WX, 0x6, 0x0 }, // 6427 + { PseudoVNCLIP_WX_MF4_MASK, VNCLIP_WX, 0x6, 0x0 }, // 6428 + { PseudoVNCLIP_WX_MF2, VNCLIP_WX, 0x7, 0x0 }, // 6429 + { PseudoVNCLIP_WX_MF2_MASK, VNCLIP_WX, 0x7, 0x0 }, // 6430 + { PseudoVNMSAC_VV_M1, VNMSAC_VV, 0x0, 0x0 }, // 6431 + { PseudoVNMSAC_VV_M1_MASK, VNMSAC_VV, 0x0, 0x0 }, // 6432 + { PseudoVNMSAC_VV_M2, VNMSAC_VV, 0x1, 0x0 }, // 6433 + { PseudoVNMSAC_VV_M2_MASK, VNMSAC_VV, 0x1, 0x0 }, // 6434 + { PseudoVNMSAC_VV_M4, VNMSAC_VV, 0x2, 0x0 }, // 6435 + { PseudoVNMSAC_VV_M4_MASK, VNMSAC_VV, 0x2, 0x0 }, // 6436 + { PseudoVNMSAC_VV_M8, VNMSAC_VV, 0x3, 0x0 }, // 6437 + { PseudoVNMSAC_VV_M8_MASK, VNMSAC_VV, 0x3, 0x0 }, // 6438 + { PseudoVNMSAC_VV_MF8, VNMSAC_VV, 0x5, 0x0 }, // 6439 + { PseudoVNMSAC_VV_MF8_MASK, VNMSAC_VV, 0x5, 0x0 }, // 6440 + { PseudoVNMSAC_VV_MF4, VNMSAC_VV, 0x6, 0x0 }, // 6441 + { PseudoVNMSAC_VV_MF4_MASK, VNMSAC_VV, 0x6, 0x0 }, // 6442 + { PseudoVNMSAC_VV_MF2, VNMSAC_VV, 0x7, 0x0 }, // 6443 + { PseudoVNMSAC_VV_MF2_MASK, VNMSAC_VV, 0x7, 0x0 }, // 6444 + { PseudoVNMSAC_VX_M1, VNMSAC_VX, 0x0, 0x0 }, // 6445 + { PseudoVNMSAC_VX_M1_MASK, VNMSAC_VX, 0x0, 0x0 }, // 6446 + { PseudoVNMSAC_VX_M2, VNMSAC_VX, 0x1, 0x0 }, // 6447 + { PseudoVNMSAC_VX_M2_MASK, VNMSAC_VX, 0x1, 0x0 }, // 6448 + { PseudoVNMSAC_VX_M4, VNMSAC_VX, 0x2, 0x0 }, // 6449 + { PseudoVNMSAC_VX_M4_MASK, VNMSAC_VX, 0x2, 0x0 }, // 6450 + { PseudoVNMSAC_VX_M8, VNMSAC_VX, 0x3, 0x0 }, // 6451 + { PseudoVNMSAC_VX_M8_MASK, VNMSAC_VX, 0x3, 0x0 }, // 6452 + { PseudoVNMSAC_VX_MF8, VNMSAC_VX, 0x5, 0x0 }, // 6453 + { PseudoVNMSAC_VX_MF8_MASK, VNMSAC_VX, 0x5, 0x0 }, // 6454 + { PseudoVNMSAC_VX_MF4, VNMSAC_VX, 0x6, 0x0 }, // 6455 + { PseudoVNMSAC_VX_MF4_MASK, VNMSAC_VX, 0x6, 0x0 }, // 6456 + { PseudoVNMSAC_VX_MF2, VNMSAC_VX, 0x7, 0x0 }, // 6457 + { PseudoVNMSAC_VX_MF2_MASK, VNMSAC_VX, 0x7, 0x0 }, // 6458 + { PseudoVNMSUB_VV_M1, VNMSUB_VV, 0x0, 0x0 }, // 6459 + { PseudoVNMSUB_VV_M1_MASK, VNMSUB_VV, 0x0, 0x0 }, // 6460 + { PseudoVNMSUB_VV_M2, VNMSUB_VV, 0x1, 0x0 }, // 6461 + { PseudoVNMSUB_VV_M2_MASK, VNMSUB_VV, 0x1, 0x0 }, // 6462 + { PseudoVNMSUB_VV_M4, VNMSUB_VV, 0x2, 0x0 }, // 6463 + { PseudoVNMSUB_VV_M4_MASK, VNMSUB_VV, 0x2, 0x0 }, // 6464 + { PseudoVNMSUB_VV_M8, VNMSUB_VV, 0x3, 0x0 }, // 6465 + { PseudoVNMSUB_VV_M8_MASK, VNMSUB_VV, 0x3, 0x0 }, // 6466 + { PseudoVNMSUB_VV_MF8, VNMSUB_VV, 0x5, 0x0 }, // 6467 + { PseudoVNMSUB_VV_MF8_MASK, VNMSUB_VV, 0x5, 0x0 }, // 6468 + { PseudoVNMSUB_VV_MF4, VNMSUB_VV, 0x6, 0x0 }, // 6469 + { PseudoVNMSUB_VV_MF4_MASK, VNMSUB_VV, 0x6, 0x0 }, // 6470 + { PseudoVNMSUB_VV_MF2, VNMSUB_VV, 0x7, 0x0 }, // 6471 + { PseudoVNMSUB_VV_MF2_MASK, VNMSUB_VV, 0x7, 0x0 }, // 6472 + { PseudoVNMSUB_VX_M1, VNMSUB_VX, 0x0, 0x0 }, // 6473 + { PseudoVNMSUB_VX_M1_MASK, VNMSUB_VX, 0x0, 0x0 }, // 6474 + { PseudoVNMSUB_VX_M2, VNMSUB_VX, 0x1, 0x0 }, // 6475 + { PseudoVNMSUB_VX_M2_MASK, VNMSUB_VX, 0x1, 0x0 }, // 6476 + { PseudoVNMSUB_VX_M4, VNMSUB_VX, 0x2, 0x0 }, // 6477 + { PseudoVNMSUB_VX_M4_MASK, VNMSUB_VX, 0x2, 0x0 }, // 6478 + { PseudoVNMSUB_VX_M8, VNMSUB_VX, 0x3, 0x0 }, // 6479 + { PseudoVNMSUB_VX_M8_MASK, VNMSUB_VX, 0x3, 0x0 }, // 6480 + { PseudoVNMSUB_VX_MF8, VNMSUB_VX, 0x5, 0x0 }, // 6481 + { PseudoVNMSUB_VX_MF8_MASK, VNMSUB_VX, 0x5, 0x0 }, // 6482 + { PseudoVNMSUB_VX_MF4, VNMSUB_VX, 0x6, 0x0 }, // 6483 + { PseudoVNMSUB_VX_MF4_MASK, VNMSUB_VX, 0x6, 0x0 }, // 6484 + { PseudoVNMSUB_VX_MF2, VNMSUB_VX, 0x7, 0x0 }, // 6485 + { PseudoVNMSUB_VX_MF2_MASK, VNMSUB_VX, 0x7, 0x0 }, // 6486 + { PseudoVNSRA_WI_M1, VNSRA_WI, 0x0, 0x0 }, // 6487 + { PseudoVNSRA_WI_M1_MASK, VNSRA_WI, 0x0, 0x0 }, // 6488 + { PseudoVNSRA_WI_M2, VNSRA_WI, 0x1, 0x0 }, // 6489 + { PseudoVNSRA_WI_M2_MASK, VNSRA_WI, 0x1, 0x0 }, // 6490 + { PseudoVNSRA_WI_M4, VNSRA_WI, 0x2, 0x0 }, // 6491 + { PseudoVNSRA_WI_M4_MASK, VNSRA_WI, 0x2, 0x0 }, // 6492 + { PseudoVNSRA_WI_MF8, VNSRA_WI, 0x5, 0x0 }, // 6493 + { PseudoVNSRA_WI_MF8_MASK, VNSRA_WI, 0x5, 0x0 }, // 6494 + { PseudoVNSRA_WI_MF4, VNSRA_WI, 0x6, 0x0 }, // 6495 + { PseudoVNSRA_WI_MF4_MASK, VNSRA_WI, 0x6, 0x0 }, // 6496 + { PseudoVNSRA_WI_MF2, VNSRA_WI, 0x7, 0x0 }, // 6497 + { PseudoVNSRA_WI_MF2_MASK, VNSRA_WI, 0x7, 0x0 }, // 6498 + { PseudoVNSRA_WV_M1, VNSRA_WV, 0x0, 0x0 }, // 6499 + { PseudoVNSRA_WV_M1_MASK, VNSRA_WV, 0x0, 0x0 }, // 6500 + { PseudoVNSRA_WV_M2, VNSRA_WV, 0x1, 0x0 }, // 6501 + { PseudoVNSRA_WV_M2_MASK, VNSRA_WV, 0x1, 0x0 }, // 6502 + { PseudoVNSRA_WV_M4, VNSRA_WV, 0x2, 0x0 }, // 6503 + { PseudoVNSRA_WV_M4_MASK, VNSRA_WV, 0x2, 0x0 }, // 6504 + { PseudoVNSRA_WV_MF8, VNSRA_WV, 0x5, 0x0 }, // 6505 + { PseudoVNSRA_WV_MF8_MASK, VNSRA_WV, 0x5, 0x0 }, // 6506 + { PseudoVNSRA_WV_MF4, VNSRA_WV, 0x6, 0x0 }, // 6507 + { PseudoVNSRA_WV_MF4_MASK, VNSRA_WV, 0x6, 0x0 }, // 6508 + { PseudoVNSRA_WV_MF2, VNSRA_WV, 0x7, 0x0 }, // 6509 + { PseudoVNSRA_WV_MF2_MASK, VNSRA_WV, 0x7, 0x0 }, // 6510 + { PseudoVNSRA_WX_M1, VNSRA_WX, 0x0, 0x0 }, // 6511 + { PseudoVNSRA_WX_M1_MASK, VNSRA_WX, 0x0, 0x0 }, // 6512 + { PseudoVNSRA_WX_M2, VNSRA_WX, 0x1, 0x0 }, // 6513 + { PseudoVNSRA_WX_M2_MASK, VNSRA_WX, 0x1, 0x0 }, // 6514 + { PseudoVNSRA_WX_M4, VNSRA_WX, 0x2, 0x0 }, // 6515 + { PseudoVNSRA_WX_M4_MASK, VNSRA_WX, 0x2, 0x0 }, // 6516 + { PseudoVNSRA_WX_MF8, VNSRA_WX, 0x5, 0x0 }, // 6517 + { PseudoVNSRA_WX_MF8_MASK, VNSRA_WX, 0x5, 0x0 }, // 6518 + { PseudoVNSRA_WX_MF4, VNSRA_WX, 0x6, 0x0 }, // 6519 + { PseudoVNSRA_WX_MF4_MASK, VNSRA_WX, 0x6, 0x0 }, // 6520 + { PseudoVNSRA_WX_MF2, VNSRA_WX, 0x7, 0x0 }, // 6521 + { PseudoVNSRA_WX_MF2_MASK, VNSRA_WX, 0x7, 0x0 }, // 6522 + { PseudoVNSRL_WI_M1, VNSRL_WI, 0x0, 0x0 }, // 6523 + { PseudoVNSRL_WI_M1_MASK, VNSRL_WI, 0x0, 0x0 }, // 6524 + { PseudoVNSRL_WI_M2, VNSRL_WI, 0x1, 0x0 }, // 6525 + { PseudoVNSRL_WI_M2_MASK, VNSRL_WI, 0x1, 0x0 }, // 6526 + { PseudoVNSRL_WI_M4, VNSRL_WI, 0x2, 0x0 }, // 6527 + { PseudoVNSRL_WI_M4_MASK, VNSRL_WI, 0x2, 0x0 }, // 6528 + { PseudoVNSRL_WI_MF8, VNSRL_WI, 0x5, 0x0 }, // 6529 + { PseudoVNSRL_WI_MF8_MASK, VNSRL_WI, 0x5, 0x0 }, // 6530 + { PseudoVNSRL_WI_MF4, VNSRL_WI, 0x6, 0x0 }, // 6531 + { PseudoVNSRL_WI_MF4_MASK, VNSRL_WI, 0x6, 0x0 }, // 6532 + { PseudoVNSRL_WI_MF2, VNSRL_WI, 0x7, 0x0 }, // 6533 + { PseudoVNSRL_WI_MF2_MASK, VNSRL_WI, 0x7, 0x0 }, // 6534 + { PseudoVNSRL_WV_M1, VNSRL_WV, 0x0, 0x0 }, // 6535 + { PseudoVNSRL_WV_M1_MASK, VNSRL_WV, 0x0, 0x0 }, // 6536 + { PseudoVNSRL_WV_M2, VNSRL_WV, 0x1, 0x0 }, // 6537 + { PseudoVNSRL_WV_M2_MASK, VNSRL_WV, 0x1, 0x0 }, // 6538 + { PseudoVNSRL_WV_M4, VNSRL_WV, 0x2, 0x0 }, // 6539 + { PseudoVNSRL_WV_M4_MASK, VNSRL_WV, 0x2, 0x0 }, // 6540 + { PseudoVNSRL_WV_MF8, VNSRL_WV, 0x5, 0x0 }, // 6541 + { PseudoVNSRL_WV_MF8_MASK, VNSRL_WV, 0x5, 0x0 }, // 6542 + { PseudoVNSRL_WV_MF4, VNSRL_WV, 0x6, 0x0 }, // 6543 + { PseudoVNSRL_WV_MF4_MASK, VNSRL_WV, 0x6, 0x0 }, // 6544 + { PseudoVNSRL_WV_MF2, VNSRL_WV, 0x7, 0x0 }, // 6545 + { PseudoVNSRL_WV_MF2_MASK, VNSRL_WV, 0x7, 0x0 }, // 6546 + { PseudoVNSRL_WX_M1, VNSRL_WX, 0x0, 0x0 }, // 6547 + { PseudoVNSRL_WX_M1_MASK, VNSRL_WX, 0x0, 0x0 }, // 6548 + { PseudoVNSRL_WX_M2, VNSRL_WX, 0x1, 0x0 }, // 6549 + { PseudoVNSRL_WX_M2_MASK, VNSRL_WX, 0x1, 0x0 }, // 6550 + { PseudoVNSRL_WX_M4, VNSRL_WX, 0x2, 0x0 }, // 6551 + { PseudoVNSRL_WX_M4_MASK, VNSRL_WX, 0x2, 0x0 }, // 6552 + { PseudoVNSRL_WX_MF8, VNSRL_WX, 0x5, 0x0 }, // 6553 + { PseudoVNSRL_WX_MF8_MASK, VNSRL_WX, 0x5, 0x0 }, // 6554 + { PseudoVNSRL_WX_MF4, VNSRL_WX, 0x6, 0x0 }, // 6555 + { PseudoVNSRL_WX_MF4_MASK, VNSRL_WX, 0x6, 0x0 }, // 6556 + { PseudoVNSRL_WX_MF2, VNSRL_WX, 0x7, 0x0 }, // 6557 + { PseudoVNSRL_WX_MF2_MASK, VNSRL_WX, 0x7, 0x0 }, // 6558 + { PseudoVOR_VI_M1, VOR_VI, 0x0, 0x0 }, // 6559 + { PseudoVOR_VI_M1_MASK, VOR_VI, 0x0, 0x0 }, // 6560 + { PseudoVOR_VI_M2, VOR_VI, 0x1, 0x0 }, // 6561 + { PseudoVOR_VI_M2_MASK, VOR_VI, 0x1, 0x0 }, // 6562 + { PseudoVOR_VI_M4, VOR_VI, 0x2, 0x0 }, // 6563 + { PseudoVOR_VI_M4_MASK, VOR_VI, 0x2, 0x0 }, // 6564 + { PseudoVOR_VI_M8, VOR_VI, 0x3, 0x0 }, // 6565 + { PseudoVOR_VI_M8_MASK, VOR_VI, 0x3, 0x0 }, // 6566 + { PseudoVOR_VI_MF8, VOR_VI, 0x5, 0x0 }, // 6567 + { PseudoVOR_VI_MF8_MASK, VOR_VI, 0x5, 0x0 }, // 6568 + { PseudoVOR_VI_MF4, VOR_VI, 0x6, 0x0 }, // 6569 + { PseudoVOR_VI_MF4_MASK, VOR_VI, 0x6, 0x0 }, // 6570 + { PseudoVOR_VI_MF2, VOR_VI, 0x7, 0x0 }, // 6571 + { PseudoVOR_VI_MF2_MASK, VOR_VI, 0x7, 0x0 }, // 6572 + { PseudoVOR_VV_M1, VOR_VV, 0x0, 0x0 }, // 6573 + { PseudoVOR_VV_M1_MASK, VOR_VV, 0x0, 0x0 }, // 6574 + { PseudoVOR_VV_M2, VOR_VV, 0x1, 0x0 }, // 6575 + { PseudoVOR_VV_M2_MASK, VOR_VV, 0x1, 0x0 }, // 6576 + { PseudoVOR_VV_M4, VOR_VV, 0x2, 0x0 }, // 6577 + { PseudoVOR_VV_M4_MASK, VOR_VV, 0x2, 0x0 }, // 6578 + { PseudoVOR_VV_M8, VOR_VV, 0x3, 0x0 }, // 6579 + { PseudoVOR_VV_M8_MASK, VOR_VV, 0x3, 0x0 }, // 6580 + { PseudoVOR_VV_MF8, VOR_VV, 0x5, 0x0 }, // 6581 + { PseudoVOR_VV_MF8_MASK, VOR_VV, 0x5, 0x0 }, // 6582 + { PseudoVOR_VV_MF4, VOR_VV, 0x6, 0x0 }, // 6583 + { PseudoVOR_VV_MF4_MASK, VOR_VV, 0x6, 0x0 }, // 6584 + { PseudoVOR_VV_MF2, VOR_VV, 0x7, 0x0 }, // 6585 + { PseudoVOR_VV_MF2_MASK, VOR_VV, 0x7, 0x0 }, // 6586 + { PseudoVOR_VX_M1, VOR_VX, 0x0, 0x0 }, // 6587 + { PseudoVOR_VX_M1_MASK, VOR_VX, 0x0, 0x0 }, // 6588 + { PseudoVOR_VX_M2, VOR_VX, 0x1, 0x0 }, // 6589 + { PseudoVOR_VX_M2_MASK, VOR_VX, 0x1, 0x0 }, // 6590 + { PseudoVOR_VX_M4, VOR_VX, 0x2, 0x0 }, // 6591 + { PseudoVOR_VX_M4_MASK, VOR_VX, 0x2, 0x0 }, // 6592 + { PseudoVOR_VX_M8, VOR_VX, 0x3, 0x0 }, // 6593 + { PseudoVOR_VX_M8_MASK, VOR_VX, 0x3, 0x0 }, // 6594 + { PseudoVOR_VX_MF8, VOR_VX, 0x5, 0x0 }, // 6595 + { PseudoVOR_VX_MF8_MASK, VOR_VX, 0x5, 0x0 }, // 6596 + { PseudoVOR_VX_MF4, VOR_VX, 0x6, 0x0 }, // 6597 + { PseudoVOR_VX_MF4_MASK, VOR_VX, 0x6, 0x0 }, // 6598 + { PseudoVOR_VX_MF2, VOR_VX, 0x7, 0x0 }, // 6599 + { PseudoVOR_VX_MF2_MASK, VOR_VX, 0x7, 0x0 }, // 6600 + { PseudoVQMACCSU_2x8x2_M1, VQMACCSU_2x8x2, 0x0, 0x0 }, // 6601 + { PseudoVQMACCSU_2x8x2_M2, VQMACCSU_2x8x2, 0x1, 0x0 }, // 6602 + { PseudoVQMACCSU_2x8x2_M4, VQMACCSU_2x8x2, 0x2, 0x0 }, // 6603 + { PseudoVQMACCSU_2x8x2_M8, VQMACCSU_2x8x2, 0x3, 0x0 }, // 6604 + { PseudoVQMACCSU_4x8x4_M1, VQMACCSU_4x8x4, 0x0, 0x0 }, // 6605 + { PseudoVQMACCSU_4x8x4_M2, VQMACCSU_4x8x4, 0x1, 0x0 }, // 6606 + { PseudoVQMACCSU_4x8x4_M4, VQMACCSU_4x8x4, 0x2, 0x0 }, // 6607 + { PseudoVQMACCSU_4x8x4_MF2, VQMACCSU_4x8x4, 0x7, 0x0 }, // 6608 + { PseudoVQMACCUS_2x8x2_M1, VQMACCUS_2x8x2, 0x0, 0x0 }, // 6609 + { PseudoVQMACCUS_2x8x2_M2, VQMACCUS_2x8x2, 0x1, 0x0 }, // 6610 + { PseudoVQMACCUS_2x8x2_M4, VQMACCUS_2x8x2, 0x2, 0x0 }, // 6611 + { PseudoVQMACCUS_2x8x2_M8, VQMACCUS_2x8x2, 0x3, 0x0 }, // 6612 + { PseudoVQMACCUS_4x8x4_M1, VQMACCUS_4x8x4, 0x0, 0x0 }, // 6613 + { PseudoVQMACCUS_4x8x4_M2, VQMACCUS_4x8x4, 0x1, 0x0 }, // 6614 + { PseudoVQMACCUS_4x8x4_M4, VQMACCUS_4x8x4, 0x2, 0x0 }, // 6615 + { PseudoVQMACCUS_4x8x4_MF2, VQMACCUS_4x8x4, 0x7, 0x0 }, // 6616 + { PseudoVQMACCU_2x8x2_M1, VQMACCU_2x8x2, 0x0, 0x0 }, // 6617 + { PseudoVQMACCU_2x8x2_M2, VQMACCU_2x8x2, 0x1, 0x0 }, // 6618 + { PseudoVQMACCU_2x8x2_M4, VQMACCU_2x8x2, 0x2, 0x0 }, // 6619 + { PseudoVQMACCU_2x8x2_M8, VQMACCU_2x8x2, 0x3, 0x0 }, // 6620 + { PseudoVQMACCU_4x8x4_M1, VQMACCU_4x8x4, 0x0, 0x0 }, // 6621 + { PseudoVQMACCU_4x8x4_M2, VQMACCU_4x8x4, 0x1, 0x0 }, // 6622 + { PseudoVQMACCU_4x8x4_M4, VQMACCU_4x8x4, 0x2, 0x0 }, // 6623 + { PseudoVQMACCU_4x8x4_MF2, VQMACCU_4x8x4, 0x7, 0x0 }, // 6624 + { PseudoVQMACC_2x8x2_M1, VQMACC_2x8x2, 0x0, 0x0 }, // 6625 + { PseudoVQMACC_2x8x2_M2, VQMACC_2x8x2, 0x1, 0x0 }, // 6626 + { PseudoVQMACC_2x8x2_M4, VQMACC_2x8x2, 0x2, 0x0 }, // 6627 + { PseudoVQMACC_2x8x2_M8, VQMACC_2x8x2, 0x3, 0x0 }, // 6628 + { PseudoVQMACC_4x8x4_M1, VQMACC_4x8x4, 0x0, 0x0 }, // 6629 + { PseudoVQMACC_4x8x4_M2, VQMACC_4x8x4, 0x1, 0x0 }, // 6630 + { PseudoVQMACC_4x8x4_M4, VQMACC_4x8x4, 0x2, 0x0 }, // 6631 + { PseudoVQMACC_4x8x4_MF2, VQMACC_4x8x4, 0x7, 0x0 }, // 6632 + { PseudoVREDAND_VS_M1_E8, VREDAND_VS, 0x0, 0x8 }, // 6633 + { PseudoVREDAND_VS_M1_E8_MASK, VREDAND_VS, 0x0, 0x8 }, // 6634 + { PseudoVREDAND_VS_M1_E16, VREDAND_VS, 0x0, 0x10 }, // 6635 + { PseudoVREDAND_VS_M1_E16_MASK, VREDAND_VS, 0x0, 0x10 }, // 6636 + { PseudoVREDAND_VS_M1_E32, VREDAND_VS, 0x0, 0x20 }, // 6637 + { PseudoVREDAND_VS_M1_E32_MASK, VREDAND_VS, 0x0, 0x20 }, // 6638 + { PseudoVREDAND_VS_M1_E64, VREDAND_VS, 0x0, 0x40 }, // 6639 + { PseudoVREDAND_VS_M1_E64_MASK, VREDAND_VS, 0x0, 0x40 }, // 6640 + { PseudoVREDAND_VS_M2_E8, VREDAND_VS, 0x1, 0x8 }, // 6641 + { PseudoVREDAND_VS_M2_E8_MASK, VREDAND_VS, 0x1, 0x8 }, // 6642 + { PseudoVREDAND_VS_M2_E16, VREDAND_VS, 0x1, 0x10 }, // 6643 + { PseudoVREDAND_VS_M2_E16_MASK, VREDAND_VS, 0x1, 0x10 }, // 6644 + { PseudoVREDAND_VS_M2_E32, VREDAND_VS, 0x1, 0x20 }, // 6645 + { PseudoVREDAND_VS_M2_E32_MASK, VREDAND_VS, 0x1, 0x20 }, // 6646 + { PseudoVREDAND_VS_M2_E64, VREDAND_VS, 0x1, 0x40 }, // 6647 + { PseudoVREDAND_VS_M2_E64_MASK, VREDAND_VS, 0x1, 0x40 }, // 6648 + { PseudoVREDAND_VS_M4_E8, VREDAND_VS, 0x2, 0x8 }, // 6649 + { PseudoVREDAND_VS_M4_E8_MASK, VREDAND_VS, 0x2, 0x8 }, // 6650 + { PseudoVREDAND_VS_M4_E16, VREDAND_VS, 0x2, 0x10 }, // 6651 + { PseudoVREDAND_VS_M4_E16_MASK, VREDAND_VS, 0x2, 0x10 }, // 6652 + { PseudoVREDAND_VS_M4_E32, VREDAND_VS, 0x2, 0x20 }, // 6653 + { PseudoVREDAND_VS_M4_E32_MASK, VREDAND_VS, 0x2, 0x20 }, // 6654 + { PseudoVREDAND_VS_M4_E64, VREDAND_VS, 0x2, 0x40 }, // 6655 + { PseudoVREDAND_VS_M4_E64_MASK, VREDAND_VS, 0x2, 0x40 }, // 6656 + { PseudoVREDAND_VS_M8_E8, VREDAND_VS, 0x3, 0x8 }, // 6657 + { PseudoVREDAND_VS_M8_E8_MASK, VREDAND_VS, 0x3, 0x8 }, // 6658 + { PseudoVREDAND_VS_M8_E16, VREDAND_VS, 0x3, 0x10 }, // 6659 + { PseudoVREDAND_VS_M8_E16_MASK, VREDAND_VS, 0x3, 0x10 }, // 6660 + { PseudoVREDAND_VS_M8_E32, VREDAND_VS, 0x3, 0x20 }, // 6661 + { PseudoVREDAND_VS_M8_E32_MASK, VREDAND_VS, 0x3, 0x20 }, // 6662 + { PseudoVREDAND_VS_M8_E64, VREDAND_VS, 0x3, 0x40 }, // 6663 + { PseudoVREDAND_VS_M8_E64_MASK, VREDAND_VS, 0x3, 0x40 }, // 6664 + { PseudoVREDAND_VS_MF8_E8, VREDAND_VS, 0x5, 0x8 }, // 6665 + { PseudoVREDAND_VS_MF8_E8_MASK, VREDAND_VS, 0x5, 0x8 }, // 6666 + { PseudoVREDAND_VS_MF4_E8, VREDAND_VS, 0x6, 0x8 }, // 6667 + { PseudoVREDAND_VS_MF4_E8_MASK, VREDAND_VS, 0x6, 0x8 }, // 6668 + { PseudoVREDAND_VS_MF4_E16, VREDAND_VS, 0x6, 0x10 }, // 6669 + { PseudoVREDAND_VS_MF4_E16_MASK, VREDAND_VS, 0x6, 0x10 }, // 6670 + { PseudoVREDAND_VS_MF2_E8, VREDAND_VS, 0x7, 0x8 }, // 6671 + { PseudoVREDAND_VS_MF2_E8_MASK, VREDAND_VS, 0x7, 0x8 }, // 6672 + { PseudoVREDAND_VS_MF2_E16, VREDAND_VS, 0x7, 0x10 }, // 6673 + { PseudoVREDAND_VS_MF2_E16_MASK, VREDAND_VS, 0x7, 0x10 }, // 6674 + { PseudoVREDAND_VS_MF2_E32, VREDAND_VS, 0x7, 0x20 }, // 6675 + { PseudoVREDAND_VS_MF2_E32_MASK, VREDAND_VS, 0x7, 0x20 }, // 6676 + { PseudoVREDMAXU_VS_M1_E8, VREDMAXU_VS, 0x0, 0x8 }, // 6677 + { PseudoVREDMAXU_VS_M1_E8_MASK, VREDMAXU_VS, 0x0, 0x8 }, // 6678 + { PseudoVREDMAXU_VS_M1_E16, VREDMAXU_VS, 0x0, 0x10 }, // 6679 + { PseudoVREDMAXU_VS_M1_E16_MASK, VREDMAXU_VS, 0x0, 0x10 }, // 6680 + { PseudoVREDMAXU_VS_M1_E32, VREDMAXU_VS, 0x0, 0x20 }, // 6681 + { PseudoVREDMAXU_VS_M1_E32_MASK, VREDMAXU_VS, 0x0, 0x20 }, // 6682 + { PseudoVREDMAXU_VS_M1_E64, VREDMAXU_VS, 0x0, 0x40 }, // 6683 + { PseudoVREDMAXU_VS_M1_E64_MASK, VREDMAXU_VS, 0x0, 0x40 }, // 6684 + { PseudoVREDMAXU_VS_M2_E8, VREDMAXU_VS, 0x1, 0x8 }, // 6685 + { PseudoVREDMAXU_VS_M2_E8_MASK, VREDMAXU_VS, 0x1, 0x8 }, // 6686 + { PseudoVREDMAXU_VS_M2_E16, VREDMAXU_VS, 0x1, 0x10 }, // 6687 + { PseudoVREDMAXU_VS_M2_E16_MASK, VREDMAXU_VS, 0x1, 0x10 }, // 6688 + { PseudoVREDMAXU_VS_M2_E32, VREDMAXU_VS, 0x1, 0x20 }, // 6689 + { PseudoVREDMAXU_VS_M2_E32_MASK, VREDMAXU_VS, 0x1, 0x20 }, // 6690 + { PseudoVREDMAXU_VS_M2_E64, VREDMAXU_VS, 0x1, 0x40 }, // 6691 + { PseudoVREDMAXU_VS_M2_E64_MASK, VREDMAXU_VS, 0x1, 0x40 }, // 6692 + { PseudoVREDMAXU_VS_M4_E8, VREDMAXU_VS, 0x2, 0x8 }, // 6693 + { PseudoVREDMAXU_VS_M4_E8_MASK, VREDMAXU_VS, 0x2, 0x8 }, // 6694 + { PseudoVREDMAXU_VS_M4_E16, VREDMAXU_VS, 0x2, 0x10 }, // 6695 + { PseudoVREDMAXU_VS_M4_E16_MASK, VREDMAXU_VS, 0x2, 0x10 }, // 6696 + { PseudoVREDMAXU_VS_M4_E32, VREDMAXU_VS, 0x2, 0x20 }, // 6697 + { PseudoVREDMAXU_VS_M4_E32_MASK, VREDMAXU_VS, 0x2, 0x20 }, // 6698 + { PseudoVREDMAXU_VS_M4_E64, VREDMAXU_VS, 0x2, 0x40 }, // 6699 + { PseudoVREDMAXU_VS_M4_E64_MASK, VREDMAXU_VS, 0x2, 0x40 }, // 6700 + { PseudoVREDMAXU_VS_M8_E8, VREDMAXU_VS, 0x3, 0x8 }, // 6701 + { PseudoVREDMAXU_VS_M8_E8_MASK, VREDMAXU_VS, 0x3, 0x8 }, // 6702 + { PseudoVREDMAXU_VS_M8_E16, VREDMAXU_VS, 0x3, 0x10 }, // 6703 + { PseudoVREDMAXU_VS_M8_E16_MASK, VREDMAXU_VS, 0x3, 0x10 }, // 6704 + { PseudoVREDMAXU_VS_M8_E32, VREDMAXU_VS, 0x3, 0x20 }, // 6705 + { PseudoVREDMAXU_VS_M8_E32_MASK, VREDMAXU_VS, 0x3, 0x20 }, // 6706 + { PseudoVREDMAXU_VS_M8_E64, VREDMAXU_VS, 0x3, 0x40 }, // 6707 + { PseudoVREDMAXU_VS_M8_E64_MASK, VREDMAXU_VS, 0x3, 0x40 }, // 6708 + { PseudoVREDMAXU_VS_MF8_E8, VREDMAXU_VS, 0x5, 0x8 }, // 6709 + { PseudoVREDMAXU_VS_MF8_E8_MASK, VREDMAXU_VS, 0x5, 0x8 }, // 6710 + { PseudoVREDMAXU_VS_MF4_E8, VREDMAXU_VS, 0x6, 0x8 }, // 6711 + { PseudoVREDMAXU_VS_MF4_E8_MASK, VREDMAXU_VS, 0x6, 0x8 }, // 6712 + { PseudoVREDMAXU_VS_MF4_E16, VREDMAXU_VS, 0x6, 0x10 }, // 6713 + { PseudoVREDMAXU_VS_MF4_E16_MASK, VREDMAXU_VS, 0x6, 0x10 }, // 6714 + { PseudoVREDMAXU_VS_MF2_E8, VREDMAXU_VS, 0x7, 0x8 }, // 6715 + { PseudoVREDMAXU_VS_MF2_E8_MASK, VREDMAXU_VS, 0x7, 0x8 }, // 6716 + { PseudoVREDMAXU_VS_MF2_E16, VREDMAXU_VS, 0x7, 0x10 }, // 6717 + { PseudoVREDMAXU_VS_MF2_E16_MASK, VREDMAXU_VS, 0x7, 0x10 }, // 6718 + { PseudoVREDMAXU_VS_MF2_E32, VREDMAXU_VS, 0x7, 0x20 }, // 6719 + { PseudoVREDMAXU_VS_MF2_E32_MASK, VREDMAXU_VS, 0x7, 0x20 }, // 6720 + { PseudoVREDMAX_VS_M1_E8, VREDMAX_VS, 0x0, 0x8 }, // 6721 + { PseudoVREDMAX_VS_M1_E8_MASK, VREDMAX_VS, 0x0, 0x8 }, // 6722 + { PseudoVREDMAX_VS_M1_E16, VREDMAX_VS, 0x0, 0x10 }, // 6723 + { PseudoVREDMAX_VS_M1_E16_MASK, VREDMAX_VS, 0x0, 0x10 }, // 6724 + { PseudoVREDMAX_VS_M1_E32, VREDMAX_VS, 0x0, 0x20 }, // 6725 + { PseudoVREDMAX_VS_M1_E32_MASK, VREDMAX_VS, 0x0, 0x20 }, // 6726 + { PseudoVREDMAX_VS_M1_E64, VREDMAX_VS, 0x0, 0x40 }, // 6727 + { PseudoVREDMAX_VS_M1_E64_MASK, VREDMAX_VS, 0x0, 0x40 }, // 6728 + { PseudoVREDMAX_VS_M2_E8, VREDMAX_VS, 0x1, 0x8 }, // 6729 + { PseudoVREDMAX_VS_M2_E8_MASK, VREDMAX_VS, 0x1, 0x8 }, // 6730 + { PseudoVREDMAX_VS_M2_E16, VREDMAX_VS, 0x1, 0x10 }, // 6731 + { PseudoVREDMAX_VS_M2_E16_MASK, VREDMAX_VS, 0x1, 0x10 }, // 6732 + { PseudoVREDMAX_VS_M2_E32, VREDMAX_VS, 0x1, 0x20 }, // 6733 + { PseudoVREDMAX_VS_M2_E32_MASK, VREDMAX_VS, 0x1, 0x20 }, // 6734 + { PseudoVREDMAX_VS_M2_E64, VREDMAX_VS, 0x1, 0x40 }, // 6735 + { PseudoVREDMAX_VS_M2_E64_MASK, VREDMAX_VS, 0x1, 0x40 }, // 6736 + { PseudoVREDMAX_VS_M4_E8, VREDMAX_VS, 0x2, 0x8 }, // 6737 + { PseudoVREDMAX_VS_M4_E8_MASK, VREDMAX_VS, 0x2, 0x8 }, // 6738 + { PseudoVREDMAX_VS_M4_E16, VREDMAX_VS, 0x2, 0x10 }, // 6739 + { PseudoVREDMAX_VS_M4_E16_MASK, VREDMAX_VS, 0x2, 0x10 }, // 6740 + { PseudoVREDMAX_VS_M4_E32, VREDMAX_VS, 0x2, 0x20 }, // 6741 + { PseudoVREDMAX_VS_M4_E32_MASK, VREDMAX_VS, 0x2, 0x20 }, // 6742 + { PseudoVREDMAX_VS_M4_E64, VREDMAX_VS, 0x2, 0x40 }, // 6743 + { PseudoVREDMAX_VS_M4_E64_MASK, VREDMAX_VS, 0x2, 0x40 }, // 6744 + { PseudoVREDMAX_VS_M8_E8, VREDMAX_VS, 0x3, 0x8 }, // 6745 + { PseudoVREDMAX_VS_M8_E8_MASK, VREDMAX_VS, 0x3, 0x8 }, // 6746 + { PseudoVREDMAX_VS_M8_E16, VREDMAX_VS, 0x3, 0x10 }, // 6747 + { PseudoVREDMAX_VS_M8_E16_MASK, VREDMAX_VS, 0x3, 0x10 }, // 6748 + { PseudoVREDMAX_VS_M8_E32, VREDMAX_VS, 0x3, 0x20 }, // 6749 + { PseudoVREDMAX_VS_M8_E32_MASK, VREDMAX_VS, 0x3, 0x20 }, // 6750 + { PseudoVREDMAX_VS_M8_E64, VREDMAX_VS, 0x3, 0x40 }, // 6751 + { PseudoVREDMAX_VS_M8_E64_MASK, VREDMAX_VS, 0x3, 0x40 }, // 6752 + { PseudoVREDMAX_VS_MF8_E8, VREDMAX_VS, 0x5, 0x8 }, // 6753 + { PseudoVREDMAX_VS_MF8_E8_MASK, VREDMAX_VS, 0x5, 0x8 }, // 6754 + { PseudoVREDMAX_VS_MF4_E8, VREDMAX_VS, 0x6, 0x8 }, // 6755 + { PseudoVREDMAX_VS_MF4_E8_MASK, VREDMAX_VS, 0x6, 0x8 }, // 6756 + { PseudoVREDMAX_VS_MF4_E16, VREDMAX_VS, 0x6, 0x10 }, // 6757 + { PseudoVREDMAX_VS_MF4_E16_MASK, VREDMAX_VS, 0x6, 0x10 }, // 6758 + { PseudoVREDMAX_VS_MF2_E8, VREDMAX_VS, 0x7, 0x8 }, // 6759 + { PseudoVREDMAX_VS_MF2_E8_MASK, VREDMAX_VS, 0x7, 0x8 }, // 6760 + { PseudoVREDMAX_VS_MF2_E16, VREDMAX_VS, 0x7, 0x10 }, // 6761 + { PseudoVREDMAX_VS_MF2_E16_MASK, VREDMAX_VS, 0x7, 0x10 }, // 6762 + { PseudoVREDMAX_VS_MF2_E32, VREDMAX_VS, 0x7, 0x20 }, // 6763 + { PseudoVREDMAX_VS_MF2_E32_MASK, VREDMAX_VS, 0x7, 0x20 }, // 6764 + { PseudoVREDMINU_VS_M1_E8, VREDMINU_VS, 0x0, 0x8 }, // 6765 + { PseudoVREDMINU_VS_M1_E8_MASK, VREDMINU_VS, 0x0, 0x8 }, // 6766 + { PseudoVREDMINU_VS_M1_E16, VREDMINU_VS, 0x0, 0x10 }, // 6767 + { PseudoVREDMINU_VS_M1_E16_MASK, VREDMINU_VS, 0x0, 0x10 }, // 6768 + { PseudoVREDMINU_VS_M1_E32, VREDMINU_VS, 0x0, 0x20 }, // 6769 + { PseudoVREDMINU_VS_M1_E32_MASK, VREDMINU_VS, 0x0, 0x20 }, // 6770 + { PseudoVREDMINU_VS_M1_E64, VREDMINU_VS, 0x0, 0x40 }, // 6771 + { PseudoVREDMINU_VS_M1_E64_MASK, VREDMINU_VS, 0x0, 0x40 }, // 6772 + { PseudoVREDMINU_VS_M2_E8, VREDMINU_VS, 0x1, 0x8 }, // 6773 + { PseudoVREDMINU_VS_M2_E8_MASK, VREDMINU_VS, 0x1, 0x8 }, // 6774 + { PseudoVREDMINU_VS_M2_E16, VREDMINU_VS, 0x1, 0x10 }, // 6775 + { PseudoVREDMINU_VS_M2_E16_MASK, VREDMINU_VS, 0x1, 0x10 }, // 6776 + { PseudoVREDMINU_VS_M2_E32, VREDMINU_VS, 0x1, 0x20 }, // 6777 + { PseudoVREDMINU_VS_M2_E32_MASK, VREDMINU_VS, 0x1, 0x20 }, // 6778 + { PseudoVREDMINU_VS_M2_E64, VREDMINU_VS, 0x1, 0x40 }, // 6779 + { PseudoVREDMINU_VS_M2_E64_MASK, VREDMINU_VS, 0x1, 0x40 }, // 6780 + { PseudoVREDMINU_VS_M4_E8, VREDMINU_VS, 0x2, 0x8 }, // 6781 + { PseudoVREDMINU_VS_M4_E8_MASK, VREDMINU_VS, 0x2, 0x8 }, // 6782 + { PseudoVREDMINU_VS_M4_E16, VREDMINU_VS, 0x2, 0x10 }, // 6783 + { PseudoVREDMINU_VS_M4_E16_MASK, VREDMINU_VS, 0x2, 0x10 }, // 6784 + { PseudoVREDMINU_VS_M4_E32, VREDMINU_VS, 0x2, 0x20 }, // 6785 + { PseudoVREDMINU_VS_M4_E32_MASK, VREDMINU_VS, 0x2, 0x20 }, // 6786 + { PseudoVREDMINU_VS_M4_E64, VREDMINU_VS, 0x2, 0x40 }, // 6787 + { PseudoVREDMINU_VS_M4_E64_MASK, VREDMINU_VS, 0x2, 0x40 }, // 6788 + { PseudoVREDMINU_VS_M8_E8, VREDMINU_VS, 0x3, 0x8 }, // 6789 + { PseudoVREDMINU_VS_M8_E8_MASK, VREDMINU_VS, 0x3, 0x8 }, // 6790 + { PseudoVREDMINU_VS_M8_E16, VREDMINU_VS, 0x3, 0x10 }, // 6791 + { PseudoVREDMINU_VS_M8_E16_MASK, VREDMINU_VS, 0x3, 0x10 }, // 6792 + { PseudoVREDMINU_VS_M8_E32, VREDMINU_VS, 0x3, 0x20 }, // 6793 + { PseudoVREDMINU_VS_M8_E32_MASK, VREDMINU_VS, 0x3, 0x20 }, // 6794 + { PseudoVREDMINU_VS_M8_E64, VREDMINU_VS, 0x3, 0x40 }, // 6795 + { PseudoVREDMINU_VS_M8_E64_MASK, VREDMINU_VS, 0x3, 0x40 }, // 6796 + { PseudoVREDMINU_VS_MF8_E8, VREDMINU_VS, 0x5, 0x8 }, // 6797 + { PseudoVREDMINU_VS_MF8_E8_MASK, VREDMINU_VS, 0x5, 0x8 }, // 6798 + { PseudoVREDMINU_VS_MF4_E8, VREDMINU_VS, 0x6, 0x8 }, // 6799 + { PseudoVREDMINU_VS_MF4_E8_MASK, VREDMINU_VS, 0x6, 0x8 }, // 6800 + { PseudoVREDMINU_VS_MF4_E16, VREDMINU_VS, 0x6, 0x10 }, // 6801 + { PseudoVREDMINU_VS_MF4_E16_MASK, VREDMINU_VS, 0x6, 0x10 }, // 6802 + { PseudoVREDMINU_VS_MF2_E8, VREDMINU_VS, 0x7, 0x8 }, // 6803 + { PseudoVREDMINU_VS_MF2_E8_MASK, VREDMINU_VS, 0x7, 0x8 }, // 6804 + { PseudoVREDMINU_VS_MF2_E16, VREDMINU_VS, 0x7, 0x10 }, // 6805 + { PseudoVREDMINU_VS_MF2_E16_MASK, VREDMINU_VS, 0x7, 0x10 }, // 6806 + { PseudoVREDMINU_VS_MF2_E32, VREDMINU_VS, 0x7, 0x20 }, // 6807 + { PseudoVREDMINU_VS_MF2_E32_MASK, VREDMINU_VS, 0x7, 0x20 }, // 6808 + { PseudoVREDMIN_VS_M1_E8, VREDMIN_VS, 0x0, 0x8 }, // 6809 + { PseudoVREDMIN_VS_M1_E8_MASK, VREDMIN_VS, 0x0, 0x8 }, // 6810 + { PseudoVREDMIN_VS_M1_E16, VREDMIN_VS, 0x0, 0x10 }, // 6811 + { PseudoVREDMIN_VS_M1_E16_MASK, VREDMIN_VS, 0x0, 0x10 }, // 6812 + { PseudoVREDMIN_VS_M1_E32, VREDMIN_VS, 0x0, 0x20 }, // 6813 + { PseudoVREDMIN_VS_M1_E32_MASK, VREDMIN_VS, 0x0, 0x20 }, // 6814 + { PseudoVREDMIN_VS_M1_E64, VREDMIN_VS, 0x0, 0x40 }, // 6815 + { PseudoVREDMIN_VS_M1_E64_MASK, VREDMIN_VS, 0x0, 0x40 }, // 6816 + { PseudoVREDMIN_VS_M2_E8, VREDMIN_VS, 0x1, 0x8 }, // 6817 + { PseudoVREDMIN_VS_M2_E8_MASK, VREDMIN_VS, 0x1, 0x8 }, // 6818 + { PseudoVREDMIN_VS_M2_E16, VREDMIN_VS, 0x1, 0x10 }, // 6819 + { PseudoVREDMIN_VS_M2_E16_MASK, VREDMIN_VS, 0x1, 0x10 }, // 6820 + { PseudoVREDMIN_VS_M2_E32, VREDMIN_VS, 0x1, 0x20 }, // 6821 + { PseudoVREDMIN_VS_M2_E32_MASK, VREDMIN_VS, 0x1, 0x20 }, // 6822 + { PseudoVREDMIN_VS_M2_E64, VREDMIN_VS, 0x1, 0x40 }, // 6823 + { PseudoVREDMIN_VS_M2_E64_MASK, VREDMIN_VS, 0x1, 0x40 }, // 6824 + { PseudoVREDMIN_VS_M4_E8, VREDMIN_VS, 0x2, 0x8 }, // 6825 + { PseudoVREDMIN_VS_M4_E8_MASK, VREDMIN_VS, 0x2, 0x8 }, // 6826 + { PseudoVREDMIN_VS_M4_E16, VREDMIN_VS, 0x2, 0x10 }, // 6827 + { PseudoVREDMIN_VS_M4_E16_MASK, VREDMIN_VS, 0x2, 0x10 }, // 6828 + { PseudoVREDMIN_VS_M4_E32, VREDMIN_VS, 0x2, 0x20 }, // 6829 + { PseudoVREDMIN_VS_M4_E32_MASK, VREDMIN_VS, 0x2, 0x20 }, // 6830 + { PseudoVREDMIN_VS_M4_E64, VREDMIN_VS, 0x2, 0x40 }, // 6831 + { PseudoVREDMIN_VS_M4_E64_MASK, VREDMIN_VS, 0x2, 0x40 }, // 6832 + { PseudoVREDMIN_VS_M8_E8, VREDMIN_VS, 0x3, 0x8 }, // 6833 + { PseudoVREDMIN_VS_M8_E8_MASK, VREDMIN_VS, 0x3, 0x8 }, // 6834 + { PseudoVREDMIN_VS_M8_E16, VREDMIN_VS, 0x3, 0x10 }, // 6835 + { PseudoVREDMIN_VS_M8_E16_MASK, VREDMIN_VS, 0x3, 0x10 }, // 6836 + { PseudoVREDMIN_VS_M8_E32, VREDMIN_VS, 0x3, 0x20 }, // 6837 + { PseudoVREDMIN_VS_M8_E32_MASK, VREDMIN_VS, 0x3, 0x20 }, // 6838 + { PseudoVREDMIN_VS_M8_E64, VREDMIN_VS, 0x3, 0x40 }, // 6839 + { PseudoVREDMIN_VS_M8_E64_MASK, VREDMIN_VS, 0x3, 0x40 }, // 6840 + { PseudoVREDMIN_VS_MF8_E8, VREDMIN_VS, 0x5, 0x8 }, // 6841 + { PseudoVREDMIN_VS_MF8_E8_MASK, VREDMIN_VS, 0x5, 0x8 }, // 6842 + { PseudoVREDMIN_VS_MF4_E8, VREDMIN_VS, 0x6, 0x8 }, // 6843 + { PseudoVREDMIN_VS_MF4_E8_MASK, VREDMIN_VS, 0x6, 0x8 }, // 6844 + { PseudoVREDMIN_VS_MF4_E16, VREDMIN_VS, 0x6, 0x10 }, // 6845 + { PseudoVREDMIN_VS_MF4_E16_MASK, VREDMIN_VS, 0x6, 0x10 }, // 6846 + { PseudoVREDMIN_VS_MF2_E8, VREDMIN_VS, 0x7, 0x8 }, // 6847 + { PseudoVREDMIN_VS_MF2_E8_MASK, VREDMIN_VS, 0x7, 0x8 }, // 6848 + { PseudoVREDMIN_VS_MF2_E16, VREDMIN_VS, 0x7, 0x10 }, // 6849 + { PseudoVREDMIN_VS_MF2_E16_MASK, VREDMIN_VS, 0x7, 0x10 }, // 6850 + { PseudoVREDMIN_VS_MF2_E32, VREDMIN_VS, 0x7, 0x20 }, // 6851 + { PseudoVREDMIN_VS_MF2_E32_MASK, VREDMIN_VS, 0x7, 0x20 }, // 6852 + { PseudoVREDOR_VS_M1_E8, VREDOR_VS, 0x0, 0x8 }, // 6853 + { PseudoVREDOR_VS_M1_E8_MASK, VREDOR_VS, 0x0, 0x8 }, // 6854 + { PseudoVREDOR_VS_M1_E16, VREDOR_VS, 0x0, 0x10 }, // 6855 + { PseudoVREDOR_VS_M1_E16_MASK, VREDOR_VS, 0x0, 0x10 }, // 6856 + { PseudoVREDOR_VS_M1_E32, VREDOR_VS, 0x0, 0x20 }, // 6857 + { PseudoVREDOR_VS_M1_E32_MASK, VREDOR_VS, 0x0, 0x20 }, // 6858 + { PseudoVREDOR_VS_M1_E64, VREDOR_VS, 0x0, 0x40 }, // 6859 + { PseudoVREDOR_VS_M1_E64_MASK, VREDOR_VS, 0x0, 0x40 }, // 6860 + { PseudoVREDOR_VS_M2_E8, VREDOR_VS, 0x1, 0x8 }, // 6861 + { PseudoVREDOR_VS_M2_E8_MASK, VREDOR_VS, 0x1, 0x8 }, // 6862 + { PseudoVREDOR_VS_M2_E16, VREDOR_VS, 0x1, 0x10 }, // 6863 + { PseudoVREDOR_VS_M2_E16_MASK, VREDOR_VS, 0x1, 0x10 }, // 6864 + { PseudoVREDOR_VS_M2_E32, VREDOR_VS, 0x1, 0x20 }, // 6865 + { PseudoVREDOR_VS_M2_E32_MASK, VREDOR_VS, 0x1, 0x20 }, // 6866 + { PseudoVREDOR_VS_M2_E64, VREDOR_VS, 0x1, 0x40 }, // 6867 + { PseudoVREDOR_VS_M2_E64_MASK, VREDOR_VS, 0x1, 0x40 }, // 6868 + { PseudoVREDOR_VS_M4_E8, VREDOR_VS, 0x2, 0x8 }, // 6869 + { PseudoVREDOR_VS_M4_E8_MASK, VREDOR_VS, 0x2, 0x8 }, // 6870 + { PseudoVREDOR_VS_M4_E16, VREDOR_VS, 0x2, 0x10 }, // 6871 + { PseudoVREDOR_VS_M4_E16_MASK, VREDOR_VS, 0x2, 0x10 }, // 6872 + { PseudoVREDOR_VS_M4_E32, VREDOR_VS, 0x2, 0x20 }, // 6873 + { PseudoVREDOR_VS_M4_E32_MASK, VREDOR_VS, 0x2, 0x20 }, // 6874 + { PseudoVREDOR_VS_M4_E64, VREDOR_VS, 0x2, 0x40 }, // 6875 + { PseudoVREDOR_VS_M4_E64_MASK, VREDOR_VS, 0x2, 0x40 }, // 6876 + { PseudoVREDOR_VS_M8_E8, VREDOR_VS, 0x3, 0x8 }, // 6877 + { PseudoVREDOR_VS_M8_E8_MASK, VREDOR_VS, 0x3, 0x8 }, // 6878 + { PseudoVREDOR_VS_M8_E16, VREDOR_VS, 0x3, 0x10 }, // 6879 + { PseudoVREDOR_VS_M8_E16_MASK, VREDOR_VS, 0x3, 0x10 }, // 6880 + { PseudoVREDOR_VS_M8_E32, VREDOR_VS, 0x3, 0x20 }, // 6881 + { PseudoVREDOR_VS_M8_E32_MASK, VREDOR_VS, 0x3, 0x20 }, // 6882 + { PseudoVREDOR_VS_M8_E64, VREDOR_VS, 0x3, 0x40 }, // 6883 + { PseudoVREDOR_VS_M8_E64_MASK, VREDOR_VS, 0x3, 0x40 }, // 6884 + { PseudoVREDOR_VS_MF8_E8, VREDOR_VS, 0x5, 0x8 }, // 6885 + { PseudoVREDOR_VS_MF8_E8_MASK, VREDOR_VS, 0x5, 0x8 }, // 6886 + { PseudoVREDOR_VS_MF4_E8, VREDOR_VS, 0x6, 0x8 }, // 6887 + { PseudoVREDOR_VS_MF4_E8_MASK, VREDOR_VS, 0x6, 0x8 }, // 6888 + { PseudoVREDOR_VS_MF4_E16, VREDOR_VS, 0x6, 0x10 }, // 6889 + { PseudoVREDOR_VS_MF4_E16_MASK, VREDOR_VS, 0x6, 0x10 }, // 6890 + { PseudoVREDOR_VS_MF2_E8, VREDOR_VS, 0x7, 0x8 }, // 6891 + { PseudoVREDOR_VS_MF2_E8_MASK, VREDOR_VS, 0x7, 0x8 }, // 6892 + { PseudoVREDOR_VS_MF2_E16, VREDOR_VS, 0x7, 0x10 }, // 6893 + { PseudoVREDOR_VS_MF2_E16_MASK, VREDOR_VS, 0x7, 0x10 }, // 6894 + { PseudoVREDOR_VS_MF2_E32, VREDOR_VS, 0x7, 0x20 }, // 6895 + { PseudoVREDOR_VS_MF2_E32_MASK, VREDOR_VS, 0x7, 0x20 }, // 6896 + { PseudoVREDSUM_VS_M1_E8, VREDSUM_VS, 0x0, 0x8 }, // 6897 + { PseudoVREDSUM_VS_M1_E8_MASK, VREDSUM_VS, 0x0, 0x8 }, // 6898 + { PseudoVREDSUM_VS_M1_E16, VREDSUM_VS, 0x0, 0x10 }, // 6899 + { PseudoVREDSUM_VS_M1_E16_MASK, VREDSUM_VS, 0x0, 0x10 }, // 6900 + { PseudoVREDSUM_VS_M1_E32, VREDSUM_VS, 0x0, 0x20 }, // 6901 + { PseudoVREDSUM_VS_M1_E32_MASK, VREDSUM_VS, 0x0, 0x20 }, // 6902 + { PseudoVREDSUM_VS_M1_E64, VREDSUM_VS, 0x0, 0x40 }, // 6903 + { PseudoVREDSUM_VS_M1_E64_MASK, VREDSUM_VS, 0x0, 0x40 }, // 6904 + { PseudoVREDSUM_VS_M2_E8, VREDSUM_VS, 0x1, 0x8 }, // 6905 + { PseudoVREDSUM_VS_M2_E8_MASK, VREDSUM_VS, 0x1, 0x8 }, // 6906 + { PseudoVREDSUM_VS_M2_E16, VREDSUM_VS, 0x1, 0x10 }, // 6907 + { PseudoVREDSUM_VS_M2_E16_MASK, VREDSUM_VS, 0x1, 0x10 }, // 6908 + { PseudoVREDSUM_VS_M2_E32, VREDSUM_VS, 0x1, 0x20 }, // 6909 + { PseudoVREDSUM_VS_M2_E32_MASK, VREDSUM_VS, 0x1, 0x20 }, // 6910 + { PseudoVREDSUM_VS_M2_E64, VREDSUM_VS, 0x1, 0x40 }, // 6911 + { PseudoVREDSUM_VS_M2_E64_MASK, VREDSUM_VS, 0x1, 0x40 }, // 6912 + { PseudoVREDSUM_VS_M4_E8, VREDSUM_VS, 0x2, 0x8 }, // 6913 + { PseudoVREDSUM_VS_M4_E8_MASK, VREDSUM_VS, 0x2, 0x8 }, // 6914 + { PseudoVREDSUM_VS_M4_E16, VREDSUM_VS, 0x2, 0x10 }, // 6915 + { PseudoVREDSUM_VS_M4_E16_MASK, VREDSUM_VS, 0x2, 0x10 }, // 6916 + { PseudoVREDSUM_VS_M4_E32, VREDSUM_VS, 0x2, 0x20 }, // 6917 + { PseudoVREDSUM_VS_M4_E32_MASK, VREDSUM_VS, 0x2, 0x20 }, // 6918 + { PseudoVREDSUM_VS_M4_E64, VREDSUM_VS, 0x2, 0x40 }, // 6919 + { PseudoVREDSUM_VS_M4_E64_MASK, VREDSUM_VS, 0x2, 0x40 }, // 6920 + { PseudoVREDSUM_VS_M8_E8, VREDSUM_VS, 0x3, 0x8 }, // 6921 + { PseudoVREDSUM_VS_M8_E8_MASK, VREDSUM_VS, 0x3, 0x8 }, // 6922 + { PseudoVREDSUM_VS_M8_E16, VREDSUM_VS, 0x3, 0x10 }, // 6923 + { PseudoVREDSUM_VS_M8_E16_MASK, VREDSUM_VS, 0x3, 0x10 }, // 6924 + { PseudoVREDSUM_VS_M8_E32, VREDSUM_VS, 0x3, 0x20 }, // 6925 + { PseudoVREDSUM_VS_M8_E32_MASK, VREDSUM_VS, 0x3, 0x20 }, // 6926 + { PseudoVREDSUM_VS_M8_E64, VREDSUM_VS, 0x3, 0x40 }, // 6927 + { PseudoVREDSUM_VS_M8_E64_MASK, VREDSUM_VS, 0x3, 0x40 }, // 6928 + { PseudoVREDSUM_VS_MF8_E8, VREDSUM_VS, 0x5, 0x8 }, // 6929 + { PseudoVREDSUM_VS_MF8_E8_MASK, VREDSUM_VS, 0x5, 0x8 }, // 6930 + { PseudoVREDSUM_VS_MF4_E8, VREDSUM_VS, 0x6, 0x8 }, // 6931 + { PseudoVREDSUM_VS_MF4_E8_MASK, VREDSUM_VS, 0x6, 0x8 }, // 6932 + { PseudoVREDSUM_VS_MF4_E16, VREDSUM_VS, 0x6, 0x10 }, // 6933 + { PseudoVREDSUM_VS_MF4_E16_MASK, VREDSUM_VS, 0x6, 0x10 }, // 6934 + { PseudoVREDSUM_VS_MF2_E8, VREDSUM_VS, 0x7, 0x8 }, // 6935 + { PseudoVREDSUM_VS_MF2_E8_MASK, VREDSUM_VS, 0x7, 0x8 }, // 6936 + { PseudoVREDSUM_VS_MF2_E16, VREDSUM_VS, 0x7, 0x10 }, // 6937 + { PseudoVREDSUM_VS_MF2_E16_MASK, VREDSUM_VS, 0x7, 0x10 }, // 6938 + { PseudoVREDSUM_VS_MF2_E32, VREDSUM_VS, 0x7, 0x20 }, // 6939 + { PseudoVREDSUM_VS_MF2_E32_MASK, VREDSUM_VS, 0x7, 0x20 }, // 6940 + { PseudoVREDXOR_VS_M1_E8, VREDXOR_VS, 0x0, 0x8 }, // 6941 + { PseudoVREDXOR_VS_M1_E8_MASK, VREDXOR_VS, 0x0, 0x8 }, // 6942 + { PseudoVREDXOR_VS_M1_E16, VREDXOR_VS, 0x0, 0x10 }, // 6943 + { PseudoVREDXOR_VS_M1_E16_MASK, VREDXOR_VS, 0x0, 0x10 }, // 6944 + { PseudoVREDXOR_VS_M1_E32, VREDXOR_VS, 0x0, 0x20 }, // 6945 + { PseudoVREDXOR_VS_M1_E32_MASK, VREDXOR_VS, 0x0, 0x20 }, // 6946 + { PseudoVREDXOR_VS_M1_E64, VREDXOR_VS, 0x0, 0x40 }, // 6947 + { PseudoVREDXOR_VS_M1_E64_MASK, VREDXOR_VS, 0x0, 0x40 }, // 6948 + { PseudoVREDXOR_VS_M2_E8, VREDXOR_VS, 0x1, 0x8 }, // 6949 + { PseudoVREDXOR_VS_M2_E8_MASK, VREDXOR_VS, 0x1, 0x8 }, // 6950 + { PseudoVREDXOR_VS_M2_E16, VREDXOR_VS, 0x1, 0x10 }, // 6951 + { PseudoVREDXOR_VS_M2_E16_MASK, VREDXOR_VS, 0x1, 0x10 }, // 6952 + { PseudoVREDXOR_VS_M2_E32, VREDXOR_VS, 0x1, 0x20 }, // 6953 + { PseudoVREDXOR_VS_M2_E32_MASK, VREDXOR_VS, 0x1, 0x20 }, // 6954 + { PseudoVREDXOR_VS_M2_E64, VREDXOR_VS, 0x1, 0x40 }, // 6955 + { PseudoVREDXOR_VS_M2_E64_MASK, VREDXOR_VS, 0x1, 0x40 }, // 6956 + { PseudoVREDXOR_VS_M4_E8, VREDXOR_VS, 0x2, 0x8 }, // 6957 + { PseudoVREDXOR_VS_M4_E8_MASK, VREDXOR_VS, 0x2, 0x8 }, // 6958 + { PseudoVREDXOR_VS_M4_E16, VREDXOR_VS, 0x2, 0x10 }, // 6959 + { PseudoVREDXOR_VS_M4_E16_MASK, VREDXOR_VS, 0x2, 0x10 }, // 6960 + { PseudoVREDXOR_VS_M4_E32, VREDXOR_VS, 0x2, 0x20 }, // 6961 + { PseudoVREDXOR_VS_M4_E32_MASK, VREDXOR_VS, 0x2, 0x20 }, // 6962 + { PseudoVREDXOR_VS_M4_E64, VREDXOR_VS, 0x2, 0x40 }, // 6963 + { PseudoVREDXOR_VS_M4_E64_MASK, VREDXOR_VS, 0x2, 0x40 }, // 6964 + { PseudoVREDXOR_VS_M8_E8, VREDXOR_VS, 0x3, 0x8 }, // 6965 + { PseudoVREDXOR_VS_M8_E8_MASK, VREDXOR_VS, 0x3, 0x8 }, // 6966 + { PseudoVREDXOR_VS_M8_E16, VREDXOR_VS, 0x3, 0x10 }, // 6967 + { PseudoVREDXOR_VS_M8_E16_MASK, VREDXOR_VS, 0x3, 0x10 }, // 6968 + { PseudoVREDXOR_VS_M8_E32, VREDXOR_VS, 0x3, 0x20 }, // 6969 + { PseudoVREDXOR_VS_M8_E32_MASK, VREDXOR_VS, 0x3, 0x20 }, // 6970 + { PseudoVREDXOR_VS_M8_E64, VREDXOR_VS, 0x3, 0x40 }, // 6971 + { PseudoVREDXOR_VS_M8_E64_MASK, VREDXOR_VS, 0x3, 0x40 }, // 6972 + { PseudoVREDXOR_VS_MF8_E8, VREDXOR_VS, 0x5, 0x8 }, // 6973 + { PseudoVREDXOR_VS_MF8_E8_MASK, VREDXOR_VS, 0x5, 0x8 }, // 6974 + { PseudoVREDXOR_VS_MF4_E8, VREDXOR_VS, 0x6, 0x8 }, // 6975 + { PseudoVREDXOR_VS_MF4_E8_MASK, VREDXOR_VS, 0x6, 0x8 }, // 6976 + { PseudoVREDXOR_VS_MF4_E16, VREDXOR_VS, 0x6, 0x10 }, // 6977 + { PseudoVREDXOR_VS_MF4_E16_MASK, VREDXOR_VS, 0x6, 0x10 }, // 6978 + { PseudoVREDXOR_VS_MF2_E8, VREDXOR_VS, 0x7, 0x8 }, // 6979 + { PseudoVREDXOR_VS_MF2_E8_MASK, VREDXOR_VS, 0x7, 0x8 }, // 6980 + { PseudoVREDXOR_VS_MF2_E16, VREDXOR_VS, 0x7, 0x10 }, // 6981 + { PseudoVREDXOR_VS_MF2_E16_MASK, VREDXOR_VS, 0x7, 0x10 }, // 6982 + { PseudoVREDXOR_VS_MF2_E32, VREDXOR_VS, 0x7, 0x20 }, // 6983 + { PseudoVREDXOR_VS_MF2_E32_MASK, VREDXOR_VS, 0x7, 0x20 }, // 6984 + { PseudoVREMU_VV_M1_E8, VREMU_VV, 0x0, 0x8 }, // 6985 + { PseudoVREMU_VV_M1_E8_MASK, VREMU_VV, 0x0, 0x8 }, // 6986 + { PseudoVREMU_VV_M1_E16, VREMU_VV, 0x0, 0x10 }, // 6987 + { PseudoVREMU_VV_M1_E16_MASK, VREMU_VV, 0x0, 0x10 }, // 6988 + { PseudoVREMU_VV_M1_E32, VREMU_VV, 0x0, 0x20 }, // 6989 + { PseudoVREMU_VV_M1_E32_MASK, VREMU_VV, 0x0, 0x20 }, // 6990 + { PseudoVREMU_VV_M1_E64, VREMU_VV, 0x0, 0x40 }, // 6991 + { PseudoVREMU_VV_M1_E64_MASK, VREMU_VV, 0x0, 0x40 }, // 6992 + { PseudoVREMU_VV_M2_E8, VREMU_VV, 0x1, 0x8 }, // 6993 + { PseudoVREMU_VV_M2_E8_MASK, VREMU_VV, 0x1, 0x8 }, // 6994 + { PseudoVREMU_VV_M2_E16, VREMU_VV, 0x1, 0x10 }, // 6995 + { PseudoVREMU_VV_M2_E16_MASK, VREMU_VV, 0x1, 0x10 }, // 6996 + { PseudoVREMU_VV_M2_E32, VREMU_VV, 0x1, 0x20 }, // 6997 + { PseudoVREMU_VV_M2_E32_MASK, VREMU_VV, 0x1, 0x20 }, // 6998 + { PseudoVREMU_VV_M2_E64, VREMU_VV, 0x1, 0x40 }, // 6999 + { PseudoVREMU_VV_M2_E64_MASK, VREMU_VV, 0x1, 0x40 }, // 7000 + { PseudoVREMU_VV_M4_E8, VREMU_VV, 0x2, 0x8 }, // 7001 + { PseudoVREMU_VV_M4_E8_MASK, VREMU_VV, 0x2, 0x8 }, // 7002 + { PseudoVREMU_VV_M4_E16, VREMU_VV, 0x2, 0x10 }, // 7003 + { PseudoVREMU_VV_M4_E16_MASK, VREMU_VV, 0x2, 0x10 }, // 7004 + { PseudoVREMU_VV_M4_E32, VREMU_VV, 0x2, 0x20 }, // 7005 + { PseudoVREMU_VV_M4_E32_MASK, VREMU_VV, 0x2, 0x20 }, // 7006 + { PseudoVREMU_VV_M4_E64, VREMU_VV, 0x2, 0x40 }, // 7007 + { PseudoVREMU_VV_M4_E64_MASK, VREMU_VV, 0x2, 0x40 }, // 7008 + { PseudoVREMU_VV_M8_E8, VREMU_VV, 0x3, 0x8 }, // 7009 + { PseudoVREMU_VV_M8_E8_MASK, VREMU_VV, 0x3, 0x8 }, // 7010 + { PseudoVREMU_VV_M8_E16, VREMU_VV, 0x3, 0x10 }, // 7011 + { PseudoVREMU_VV_M8_E16_MASK, VREMU_VV, 0x3, 0x10 }, // 7012 + { PseudoVREMU_VV_M8_E32, VREMU_VV, 0x3, 0x20 }, // 7013 + { PseudoVREMU_VV_M8_E32_MASK, VREMU_VV, 0x3, 0x20 }, // 7014 + { PseudoVREMU_VV_M8_E64, VREMU_VV, 0x3, 0x40 }, // 7015 + { PseudoVREMU_VV_M8_E64_MASK, VREMU_VV, 0x3, 0x40 }, // 7016 + { PseudoVREMU_VV_MF8_E8, VREMU_VV, 0x5, 0x8 }, // 7017 + { PseudoVREMU_VV_MF8_E8_MASK, VREMU_VV, 0x5, 0x8 }, // 7018 + { PseudoVREMU_VV_MF4_E8, VREMU_VV, 0x6, 0x8 }, // 7019 + { PseudoVREMU_VV_MF4_E8_MASK, VREMU_VV, 0x6, 0x8 }, // 7020 + { PseudoVREMU_VV_MF4_E16, VREMU_VV, 0x6, 0x10 }, // 7021 + { PseudoVREMU_VV_MF4_E16_MASK, VREMU_VV, 0x6, 0x10 }, // 7022 + { PseudoVREMU_VV_MF2_E8, VREMU_VV, 0x7, 0x8 }, // 7023 + { PseudoVREMU_VV_MF2_E8_MASK, VREMU_VV, 0x7, 0x8 }, // 7024 + { PseudoVREMU_VV_MF2_E16, VREMU_VV, 0x7, 0x10 }, // 7025 + { PseudoVREMU_VV_MF2_E16_MASK, VREMU_VV, 0x7, 0x10 }, // 7026 + { PseudoVREMU_VV_MF2_E32, VREMU_VV, 0x7, 0x20 }, // 7027 + { PseudoVREMU_VV_MF2_E32_MASK, VREMU_VV, 0x7, 0x20 }, // 7028 + { PseudoVREMU_VX_M1_E8, VREMU_VX, 0x0, 0x8 }, // 7029 + { PseudoVREMU_VX_M1_E8_MASK, VREMU_VX, 0x0, 0x8 }, // 7030 + { PseudoVREMU_VX_M1_E16, VREMU_VX, 0x0, 0x10 }, // 7031 + { PseudoVREMU_VX_M1_E16_MASK, VREMU_VX, 0x0, 0x10 }, // 7032 + { PseudoVREMU_VX_M1_E32, VREMU_VX, 0x0, 0x20 }, // 7033 + { PseudoVREMU_VX_M1_E32_MASK, VREMU_VX, 0x0, 0x20 }, // 7034 + { PseudoVREMU_VX_M1_E64, VREMU_VX, 0x0, 0x40 }, // 7035 + { PseudoVREMU_VX_M1_E64_MASK, VREMU_VX, 0x0, 0x40 }, // 7036 + { PseudoVREMU_VX_M2_E8, VREMU_VX, 0x1, 0x8 }, // 7037 + { PseudoVREMU_VX_M2_E8_MASK, VREMU_VX, 0x1, 0x8 }, // 7038 + { PseudoVREMU_VX_M2_E16, VREMU_VX, 0x1, 0x10 }, // 7039 + { PseudoVREMU_VX_M2_E16_MASK, VREMU_VX, 0x1, 0x10 }, // 7040 + { PseudoVREMU_VX_M2_E32, VREMU_VX, 0x1, 0x20 }, // 7041 + { PseudoVREMU_VX_M2_E32_MASK, VREMU_VX, 0x1, 0x20 }, // 7042 + { PseudoVREMU_VX_M2_E64, VREMU_VX, 0x1, 0x40 }, // 7043 + { PseudoVREMU_VX_M2_E64_MASK, VREMU_VX, 0x1, 0x40 }, // 7044 + { PseudoVREMU_VX_M4_E8, VREMU_VX, 0x2, 0x8 }, // 7045 + { PseudoVREMU_VX_M4_E8_MASK, VREMU_VX, 0x2, 0x8 }, // 7046 + { PseudoVREMU_VX_M4_E16, VREMU_VX, 0x2, 0x10 }, // 7047 + { PseudoVREMU_VX_M4_E16_MASK, VREMU_VX, 0x2, 0x10 }, // 7048 + { PseudoVREMU_VX_M4_E32, VREMU_VX, 0x2, 0x20 }, // 7049 + { PseudoVREMU_VX_M4_E32_MASK, VREMU_VX, 0x2, 0x20 }, // 7050 + { PseudoVREMU_VX_M4_E64, VREMU_VX, 0x2, 0x40 }, // 7051 + { PseudoVREMU_VX_M4_E64_MASK, VREMU_VX, 0x2, 0x40 }, // 7052 + { PseudoVREMU_VX_M8_E8, VREMU_VX, 0x3, 0x8 }, // 7053 + { PseudoVREMU_VX_M8_E8_MASK, VREMU_VX, 0x3, 0x8 }, // 7054 + { PseudoVREMU_VX_M8_E16, VREMU_VX, 0x3, 0x10 }, // 7055 + { PseudoVREMU_VX_M8_E16_MASK, VREMU_VX, 0x3, 0x10 }, // 7056 + { PseudoVREMU_VX_M8_E32, VREMU_VX, 0x3, 0x20 }, // 7057 + { PseudoVREMU_VX_M8_E32_MASK, VREMU_VX, 0x3, 0x20 }, // 7058 + { PseudoVREMU_VX_M8_E64, VREMU_VX, 0x3, 0x40 }, // 7059 + { PseudoVREMU_VX_M8_E64_MASK, VREMU_VX, 0x3, 0x40 }, // 7060 + { PseudoVREMU_VX_MF8_E8, VREMU_VX, 0x5, 0x8 }, // 7061 + { PseudoVREMU_VX_MF8_E8_MASK, VREMU_VX, 0x5, 0x8 }, // 7062 + { PseudoVREMU_VX_MF4_E8, VREMU_VX, 0x6, 0x8 }, // 7063 + { PseudoVREMU_VX_MF4_E8_MASK, VREMU_VX, 0x6, 0x8 }, // 7064 + { PseudoVREMU_VX_MF4_E16, VREMU_VX, 0x6, 0x10 }, // 7065 + { PseudoVREMU_VX_MF4_E16_MASK, VREMU_VX, 0x6, 0x10 }, // 7066 + { PseudoVREMU_VX_MF2_E8, VREMU_VX, 0x7, 0x8 }, // 7067 + { PseudoVREMU_VX_MF2_E8_MASK, VREMU_VX, 0x7, 0x8 }, // 7068 + { PseudoVREMU_VX_MF2_E16, VREMU_VX, 0x7, 0x10 }, // 7069 + { PseudoVREMU_VX_MF2_E16_MASK, VREMU_VX, 0x7, 0x10 }, // 7070 + { PseudoVREMU_VX_MF2_E32, VREMU_VX, 0x7, 0x20 }, // 7071 + { PseudoVREMU_VX_MF2_E32_MASK, VREMU_VX, 0x7, 0x20 }, // 7072 + { PseudoVREM_VV_M1_E8, VREM_VV, 0x0, 0x8 }, // 7073 + { PseudoVREM_VV_M1_E8_MASK, VREM_VV, 0x0, 0x8 }, // 7074 + { PseudoVREM_VV_M1_E16, VREM_VV, 0x0, 0x10 }, // 7075 + { PseudoVREM_VV_M1_E16_MASK, VREM_VV, 0x0, 0x10 }, // 7076 + { PseudoVREM_VV_M1_E32, VREM_VV, 0x0, 0x20 }, // 7077 + { PseudoVREM_VV_M1_E32_MASK, VREM_VV, 0x0, 0x20 }, // 7078 + { PseudoVREM_VV_M1_E64, VREM_VV, 0x0, 0x40 }, // 7079 + { PseudoVREM_VV_M1_E64_MASK, VREM_VV, 0x0, 0x40 }, // 7080 + { PseudoVREM_VV_M2_E8, VREM_VV, 0x1, 0x8 }, // 7081 + { PseudoVREM_VV_M2_E8_MASK, VREM_VV, 0x1, 0x8 }, // 7082 + { PseudoVREM_VV_M2_E16, VREM_VV, 0x1, 0x10 }, // 7083 + { PseudoVREM_VV_M2_E16_MASK, VREM_VV, 0x1, 0x10 }, // 7084 + { PseudoVREM_VV_M2_E32, VREM_VV, 0x1, 0x20 }, // 7085 + { PseudoVREM_VV_M2_E32_MASK, VREM_VV, 0x1, 0x20 }, // 7086 + { PseudoVREM_VV_M2_E64, VREM_VV, 0x1, 0x40 }, // 7087 + { PseudoVREM_VV_M2_E64_MASK, VREM_VV, 0x1, 0x40 }, // 7088 + { PseudoVREM_VV_M4_E8, VREM_VV, 0x2, 0x8 }, // 7089 + { PseudoVREM_VV_M4_E8_MASK, VREM_VV, 0x2, 0x8 }, // 7090 + { PseudoVREM_VV_M4_E16, VREM_VV, 0x2, 0x10 }, // 7091 + { PseudoVREM_VV_M4_E16_MASK, VREM_VV, 0x2, 0x10 }, // 7092 + { PseudoVREM_VV_M4_E32, VREM_VV, 0x2, 0x20 }, // 7093 + { PseudoVREM_VV_M4_E32_MASK, VREM_VV, 0x2, 0x20 }, // 7094 + { PseudoVREM_VV_M4_E64, VREM_VV, 0x2, 0x40 }, // 7095 + { PseudoVREM_VV_M4_E64_MASK, VREM_VV, 0x2, 0x40 }, // 7096 + { PseudoVREM_VV_M8_E8, VREM_VV, 0x3, 0x8 }, // 7097 + { PseudoVREM_VV_M8_E8_MASK, VREM_VV, 0x3, 0x8 }, // 7098 + { PseudoVREM_VV_M8_E16, VREM_VV, 0x3, 0x10 }, // 7099 + { PseudoVREM_VV_M8_E16_MASK, VREM_VV, 0x3, 0x10 }, // 7100 + { PseudoVREM_VV_M8_E32, VREM_VV, 0x3, 0x20 }, // 7101 + { PseudoVREM_VV_M8_E32_MASK, VREM_VV, 0x3, 0x20 }, // 7102 + { PseudoVREM_VV_M8_E64, VREM_VV, 0x3, 0x40 }, // 7103 + { PseudoVREM_VV_M8_E64_MASK, VREM_VV, 0x3, 0x40 }, // 7104 + { PseudoVREM_VV_MF8_E8, VREM_VV, 0x5, 0x8 }, // 7105 + { PseudoVREM_VV_MF8_E8_MASK, VREM_VV, 0x5, 0x8 }, // 7106 + { PseudoVREM_VV_MF4_E8, VREM_VV, 0x6, 0x8 }, // 7107 + { PseudoVREM_VV_MF4_E8_MASK, VREM_VV, 0x6, 0x8 }, // 7108 + { PseudoVREM_VV_MF4_E16, VREM_VV, 0x6, 0x10 }, // 7109 + { PseudoVREM_VV_MF4_E16_MASK, VREM_VV, 0x6, 0x10 }, // 7110 + { PseudoVREM_VV_MF2_E8, VREM_VV, 0x7, 0x8 }, // 7111 + { PseudoVREM_VV_MF2_E8_MASK, VREM_VV, 0x7, 0x8 }, // 7112 + { PseudoVREM_VV_MF2_E16, VREM_VV, 0x7, 0x10 }, // 7113 + { PseudoVREM_VV_MF2_E16_MASK, VREM_VV, 0x7, 0x10 }, // 7114 + { PseudoVREM_VV_MF2_E32, VREM_VV, 0x7, 0x20 }, // 7115 + { PseudoVREM_VV_MF2_E32_MASK, VREM_VV, 0x7, 0x20 }, // 7116 + { PseudoVREM_VX_M1_E8, VREM_VX, 0x0, 0x8 }, // 7117 + { PseudoVREM_VX_M1_E8_MASK, VREM_VX, 0x0, 0x8 }, // 7118 + { PseudoVREM_VX_M1_E16, VREM_VX, 0x0, 0x10 }, // 7119 + { PseudoVREM_VX_M1_E16_MASK, VREM_VX, 0x0, 0x10 }, // 7120 + { PseudoVREM_VX_M1_E32, VREM_VX, 0x0, 0x20 }, // 7121 + { PseudoVREM_VX_M1_E32_MASK, VREM_VX, 0x0, 0x20 }, // 7122 + { PseudoVREM_VX_M1_E64, VREM_VX, 0x0, 0x40 }, // 7123 + { PseudoVREM_VX_M1_E64_MASK, VREM_VX, 0x0, 0x40 }, // 7124 + { PseudoVREM_VX_M2_E8, VREM_VX, 0x1, 0x8 }, // 7125 + { PseudoVREM_VX_M2_E8_MASK, VREM_VX, 0x1, 0x8 }, // 7126 + { PseudoVREM_VX_M2_E16, VREM_VX, 0x1, 0x10 }, // 7127 + { PseudoVREM_VX_M2_E16_MASK, VREM_VX, 0x1, 0x10 }, // 7128 + { PseudoVREM_VX_M2_E32, VREM_VX, 0x1, 0x20 }, // 7129 + { PseudoVREM_VX_M2_E32_MASK, VREM_VX, 0x1, 0x20 }, // 7130 + { PseudoVREM_VX_M2_E64, VREM_VX, 0x1, 0x40 }, // 7131 + { PseudoVREM_VX_M2_E64_MASK, VREM_VX, 0x1, 0x40 }, // 7132 + { PseudoVREM_VX_M4_E8, VREM_VX, 0x2, 0x8 }, // 7133 + { PseudoVREM_VX_M4_E8_MASK, VREM_VX, 0x2, 0x8 }, // 7134 + { PseudoVREM_VX_M4_E16, VREM_VX, 0x2, 0x10 }, // 7135 + { PseudoVREM_VX_M4_E16_MASK, VREM_VX, 0x2, 0x10 }, // 7136 + { PseudoVREM_VX_M4_E32, VREM_VX, 0x2, 0x20 }, // 7137 + { PseudoVREM_VX_M4_E32_MASK, VREM_VX, 0x2, 0x20 }, // 7138 + { PseudoVREM_VX_M4_E64, VREM_VX, 0x2, 0x40 }, // 7139 + { PseudoVREM_VX_M4_E64_MASK, VREM_VX, 0x2, 0x40 }, // 7140 + { PseudoVREM_VX_M8_E8, VREM_VX, 0x3, 0x8 }, // 7141 + { PseudoVREM_VX_M8_E8_MASK, VREM_VX, 0x3, 0x8 }, // 7142 + { PseudoVREM_VX_M8_E16, VREM_VX, 0x3, 0x10 }, // 7143 + { PseudoVREM_VX_M8_E16_MASK, VREM_VX, 0x3, 0x10 }, // 7144 + { PseudoVREM_VX_M8_E32, VREM_VX, 0x3, 0x20 }, // 7145 + { PseudoVREM_VX_M8_E32_MASK, VREM_VX, 0x3, 0x20 }, // 7146 + { PseudoVREM_VX_M8_E64, VREM_VX, 0x3, 0x40 }, // 7147 + { PseudoVREM_VX_M8_E64_MASK, VREM_VX, 0x3, 0x40 }, // 7148 + { PseudoVREM_VX_MF8_E8, VREM_VX, 0x5, 0x8 }, // 7149 + { PseudoVREM_VX_MF8_E8_MASK, VREM_VX, 0x5, 0x8 }, // 7150 + { PseudoVREM_VX_MF4_E8, VREM_VX, 0x6, 0x8 }, // 7151 + { PseudoVREM_VX_MF4_E8_MASK, VREM_VX, 0x6, 0x8 }, // 7152 + { PseudoVREM_VX_MF4_E16, VREM_VX, 0x6, 0x10 }, // 7153 + { PseudoVREM_VX_MF4_E16_MASK, VREM_VX, 0x6, 0x10 }, // 7154 + { PseudoVREM_VX_MF2_E8, VREM_VX, 0x7, 0x8 }, // 7155 + { PseudoVREM_VX_MF2_E8_MASK, VREM_VX, 0x7, 0x8 }, // 7156 + { PseudoVREM_VX_MF2_E16, VREM_VX, 0x7, 0x10 }, // 7157 + { PseudoVREM_VX_MF2_E16_MASK, VREM_VX, 0x7, 0x10 }, // 7158 + { PseudoVREM_VX_MF2_E32, VREM_VX, 0x7, 0x20 }, // 7159 + { PseudoVREM_VX_MF2_E32_MASK, VREM_VX, 0x7, 0x20 }, // 7160 + { PseudoVREV8_V_M1, VREV8_V, 0x0, 0x0 }, // 7161 + { PseudoVREV8_V_M1_MASK, VREV8_V, 0x0, 0x0 }, // 7162 + { PseudoVREV8_V_M2, VREV8_V, 0x1, 0x0 }, // 7163 + { PseudoVREV8_V_M2_MASK, VREV8_V, 0x1, 0x0 }, // 7164 + { PseudoVREV8_V_M4, VREV8_V, 0x2, 0x0 }, // 7165 + { PseudoVREV8_V_M4_MASK, VREV8_V, 0x2, 0x0 }, // 7166 + { PseudoVREV8_V_M8, VREV8_V, 0x3, 0x0 }, // 7167 + { PseudoVREV8_V_M8_MASK, VREV8_V, 0x3, 0x0 }, // 7168 + { PseudoVREV8_V_MF8, VREV8_V, 0x5, 0x0 }, // 7169 + { PseudoVREV8_V_MF8_MASK, VREV8_V, 0x5, 0x0 }, // 7170 + { PseudoVREV8_V_MF4, VREV8_V, 0x6, 0x0 }, // 7171 + { PseudoVREV8_V_MF4_MASK, VREV8_V, 0x6, 0x0 }, // 7172 + { PseudoVREV8_V_MF2, VREV8_V, 0x7, 0x0 }, // 7173 + { PseudoVREV8_V_MF2_MASK, VREV8_V, 0x7, 0x0 }, // 7174 + { PseudoVRGATHEREI16_VV_M1_E8_M1, VRGATHEREI16_VV, 0x0, 0x8 }, // 7175 + { PseudoVRGATHEREI16_VV_M1_E8_M1_MASK, VRGATHEREI16_VV, 0x0, 0x8 }, // 7176 + { PseudoVRGATHEREI16_VV_M1_E8_M2, VRGATHEREI16_VV, 0x0, 0x8 }, // 7177 + { PseudoVRGATHEREI16_VV_M1_E8_M2_MASK, VRGATHEREI16_VV, 0x0, 0x8 }, // 7178 + { PseudoVRGATHEREI16_VV_M1_E8_MF2, VRGATHEREI16_VV, 0x0, 0x8 }, // 7179 + { PseudoVRGATHEREI16_VV_M1_E8_MF2_MASK, VRGATHEREI16_VV, 0x0, 0x8 }, // 7180 + { PseudoVRGATHEREI16_VV_M1_E8_MF4, VRGATHEREI16_VV, 0x0, 0x8 }, // 7181 + { PseudoVRGATHEREI16_VV_M1_E8_MF4_MASK, VRGATHEREI16_VV, 0x0, 0x8 }, // 7182 + { PseudoVRGATHEREI16_VV_M1_E16_M1, VRGATHEREI16_VV, 0x0, 0x10 }, // 7183 + { PseudoVRGATHEREI16_VV_M1_E16_M1_MASK, VRGATHEREI16_VV, 0x0, 0x10 }, // 7184 + { PseudoVRGATHEREI16_VV_M1_E16_M2, VRGATHEREI16_VV, 0x0, 0x10 }, // 7185 + { PseudoVRGATHEREI16_VV_M1_E16_M2_MASK, VRGATHEREI16_VV, 0x0, 0x10 }, // 7186 + { PseudoVRGATHEREI16_VV_M1_E16_MF2, VRGATHEREI16_VV, 0x0, 0x10 }, // 7187 + { PseudoVRGATHEREI16_VV_M1_E16_MF2_MASK, VRGATHEREI16_VV, 0x0, 0x10 }, // 7188 + { PseudoVRGATHEREI16_VV_M1_E16_MF4, VRGATHEREI16_VV, 0x0, 0x10 }, // 7189 + { PseudoVRGATHEREI16_VV_M1_E16_MF4_MASK, VRGATHEREI16_VV, 0x0, 0x10 }, // 7190 + { PseudoVRGATHEREI16_VV_M1_E32_M1, VRGATHEREI16_VV, 0x0, 0x20 }, // 7191 + { PseudoVRGATHEREI16_VV_M1_E32_M1_MASK, VRGATHEREI16_VV, 0x0, 0x20 }, // 7192 + { PseudoVRGATHEREI16_VV_M1_E32_M2, VRGATHEREI16_VV, 0x0, 0x20 }, // 7193 + { PseudoVRGATHEREI16_VV_M1_E32_M2_MASK, VRGATHEREI16_VV, 0x0, 0x20 }, // 7194 + { PseudoVRGATHEREI16_VV_M1_E32_MF2, VRGATHEREI16_VV, 0x0, 0x20 }, // 7195 + { PseudoVRGATHEREI16_VV_M1_E32_MF2_MASK, VRGATHEREI16_VV, 0x0, 0x20 }, // 7196 + { PseudoVRGATHEREI16_VV_M1_E32_MF4, VRGATHEREI16_VV, 0x0, 0x20 }, // 7197 + { PseudoVRGATHEREI16_VV_M1_E32_MF4_MASK, VRGATHEREI16_VV, 0x0, 0x20 }, // 7198 + { PseudoVRGATHEREI16_VV_M1_E64_M1, VRGATHEREI16_VV, 0x0, 0x40 }, // 7199 + { PseudoVRGATHEREI16_VV_M1_E64_M1_MASK, VRGATHEREI16_VV, 0x0, 0x40 }, // 7200 + { PseudoVRGATHEREI16_VV_M1_E64_M2, VRGATHEREI16_VV, 0x0, 0x40 }, // 7201 + { PseudoVRGATHEREI16_VV_M1_E64_M2_MASK, VRGATHEREI16_VV, 0x0, 0x40 }, // 7202 + { PseudoVRGATHEREI16_VV_M1_E64_MF2, VRGATHEREI16_VV, 0x0, 0x40 }, // 7203 + { PseudoVRGATHEREI16_VV_M1_E64_MF2_MASK, VRGATHEREI16_VV, 0x0, 0x40 }, // 7204 + { PseudoVRGATHEREI16_VV_M1_E64_MF4, VRGATHEREI16_VV, 0x0, 0x40 }, // 7205 + { PseudoVRGATHEREI16_VV_M1_E64_MF4_MASK, VRGATHEREI16_VV, 0x0, 0x40 }, // 7206 + { PseudoVRGATHEREI16_VV_M2_E8_M1, VRGATHEREI16_VV, 0x1, 0x8 }, // 7207 + { PseudoVRGATHEREI16_VV_M2_E8_M1_MASK, VRGATHEREI16_VV, 0x1, 0x8 }, // 7208 + { PseudoVRGATHEREI16_VV_M2_E8_M2, VRGATHEREI16_VV, 0x1, 0x8 }, // 7209 + { PseudoVRGATHEREI16_VV_M2_E8_M2_MASK, VRGATHEREI16_VV, 0x1, 0x8 }, // 7210 + { PseudoVRGATHEREI16_VV_M2_E8_M4, VRGATHEREI16_VV, 0x1, 0x8 }, // 7211 + { PseudoVRGATHEREI16_VV_M2_E8_M4_MASK, VRGATHEREI16_VV, 0x1, 0x8 }, // 7212 + { PseudoVRGATHEREI16_VV_M2_E8_MF2, VRGATHEREI16_VV, 0x1, 0x8 }, // 7213 + { PseudoVRGATHEREI16_VV_M2_E8_MF2_MASK, VRGATHEREI16_VV, 0x1, 0x8 }, // 7214 + { PseudoVRGATHEREI16_VV_M2_E16_M1, VRGATHEREI16_VV, 0x1, 0x10 }, // 7215 + { PseudoVRGATHEREI16_VV_M2_E16_M1_MASK, VRGATHEREI16_VV, 0x1, 0x10 }, // 7216 + { PseudoVRGATHEREI16_VV_M2_E16_M2, VRGATHEREI16_VV, 0x1, 0x10 }, // 7217 + { PseudoVRGATHEREI16_VV_M2_E16_M2_MASK, VRGATHEREI16_VV, 0x1, 0x10 }, // 7218 + { PseudoVRGATHEREI16_VV_M2_E16_M4, VRGATHEREI16_VV, 0x1, 0x10 }, // 7219 + { PseudoVRGATHEREI16_VV_M2_E16_M4_MASK, VRGATHEREI16_VV, 0x1, 0x10 }, // 7220 + { PseudoVRGATHEREI16_VV_M2_E16_MF2, VRGATHEREI16_VV, 0x1, 0x10 }, // 7221 + { PseudoVRGATHEREI16_VV_M2_E16_MF2_MASK, VRGATHEREI16_VV, 0x1, 0x10 }, // 7222 + { PseudoVRGATHEREI16_VV_M2_E32_M1, VRGATHEREI16_VV, 0x1, 0x20 }, // 7223 + { PseudoVRGATHEREI16_VV_M2_E32_M1_MASK, VRGATHEREI16_VV, 0x1, 0x20 }, // 7224 + { PseudoVRGATHEREI16_VV_M2_E32_M2, VRGATHEREI16_VV, 0x1, 0x20 }, // 7225 + { PseudoVRGATHEREI16_VV_M2_E32_M2_MASK, VRGATHEREI16_VV, 0x1, 0x20 }, // 7226 + { PseudoVRGATHEREI16_VV_M2_E32_M4, VRGATHEREI16_VV, 0x1, 0x20 }, // 7227 + { PseudoVRGATHEREI16_VV_M2_E32_M4_MASK, VRGATHEREI16_VV, 0x1, 0x20 }, // 7228 + { PseudoVRGATHEREI16_VV_M2_E32_MF2, VRGATHEREI16_VV, 0x1, 0x20 }, // 7229 + { PseudoVRGATHEREI16_VV_M2_E32_MF2_MASK, VRGATHEREI16_VV, 0x1, 0x20 }, // 7230 + { PseudoVRGATHEREI16_VV_M2_E64_M1, VRGATHEREI16_VV, 0x1, 0x40 }, // 7231 + { PseudoVRGATHEREI16_VV_M2_E64_M1_MASK, VRGATHEREI16_VV, 0x1, 0x40 }, // 7232 + { PseudoVRGATHEREI16_VV_M2_E64_M2, VRGATHEREI16_VV, 0x1, 0x40 }, // 7233 + { PseudoVRGATHEREI16_VV_M2_E64_M2_MASK, VRGATHEREI16_VV, 0x1, 0x40 }, // 7234 + { PseudoVRGATHEREI16_VV_M2_E64_M4, VRGATHEREI16_VV, 0x1, 0x40 }, // 7235 + { PseudoVRGATHEREI16_VV_M2_E64_M4_MASK, VRGATHEREI16_VV, 0x1, 0x40 }, // 7236 + { PseudoVRGATHEREI16_VV_M2_E64_MF2, VRGATHEREI16_VV, 0x1, 0x40 }, // 7237 + { PseudoVRGATHEREI16_VV_M2_E64_MF2_MASK, VRGATHEREI16_VV, 0x1, 0x40 }, // 7238 + { PseudoVRGATHEREI16_VV_M4_E8_M1, VRGATHEREI16_VV, 0x2, 0x8 }, // 7239 + { PseudoVRGATHEREI16_VV_M4_E8_M1_MASK, VRGATHEREI16_VV, 0x2, 0x8 }, // 7240 + { PseudoVRGATHEREI16_VV_M4_E8_M2, VRGATHEREI16_VV, 0x2, 0x8 }, // 7241 + { PseudoVRGATHEREI16_VV_M4_E8_M2_MASK, VRGATHEREI16_VV, 0x2, 0x8 }, // 7242 + { PseudoVRGATHEREI16_VV_M4_E8_M4, VRGATHEREI16_VV, 0x2, 0x8 }, // 7243 + { PseudoVRGATHEREI16_VV_M4_E8_M4_MASK, VRGATHEREI16_VV, 0x2, 0x8 }, // 7244 + { PseudoVRGATHEREI16_VV_M4_E8_M8, VRGATHEREI16_VV, 0x2, 0x8 }, // 7245 + { PseudoVRGATHEREI16_VV_M4_E8_M8_MASK, VRGATHEREI16_VV, 0x2, 0x8 }, // 7246 + { PseudoVRGATHEREI16_VV_M4_E16_M1, VRGATHEREI16_VV, 0x2, 0x10 }, // 7247 + { PseudoVRGATHEREI16_VV_M4_E16_M1_MASK, VRGATHEREI16_VV, 0x2, 0x10 }, // 7248 + { PseudoVRGATHEREI16_VV_M4_E16_M2, VRGATHEREI16_VV, 0x2, 0x10 }, // 7249 + { PseudoVRGATHEREI16_VV_M4_E16_M2_MASK, VRGATHEREI16_VV, 0x2, 0x10 }, // 7250 + { PseudoVRGATHEREI16_VV_M4_E16_M4, VRGATHEREI16_VV, 0x2, 0x10 }, // 7251 + { PseudoVRGATHEREI16_VV_M4_E16_M4_MASK, VRGATHEREI16_VV, 0x2, 0x10 }, // 7252 + { PseudoVRGATHEREI16_VV_M4_E16_M8, VRGATHEREI16_VV, 0x2, 0x10 }, // 7253 + { PseudoVRGATHEREI16_VV_M4_E16_M8_MASK, VRGATHEREI16_VV, 0x2, 0x10 }, // 7254 + { PseudoVRGATHEREI16_VV_M4_E32_M1, VRGATHEREI16_VV, 0x2, 0x20 }, // 7255 + { PseudoVRGATHEREI16_VV_M4_E32_M1_MASK, VRGATHEREI16_VV, 0x2, 0x20 }, // 7256 + { PseudoVRGATHEREI16_VV_M4_E32_M2, VRGATHEREI16_VV, 0x2, 0x20 }, // 7257 + { PseudoVRGATHEREI16_VV_M4_E32_M2_MASK, VRGATHEREI16_VV, 0x2, 0x20 }, // 7258 + { PseudoVRGATHEREI16_VV_M4_E32_M4, VRGATHEREI16_VV, 0x2, 0x20 }, // 7259 + { PseudoVRGATHEREI16_VV_M4_E32_M4_MASK, VRGATHEREI16_VV, 0x2, 0x20 }, // 7260 + { PseudoVRGATHEREI16_VV_M4_E32_M8, VRGATHEREI16_VV, 0x2, 0x20 }, // 7261 + { PseudoVRGATHEREI16_VV_M4_E32_M8_MASK, VRGATHEREI16_VV, 0x2, 0x20 }, // 7262 + { PseudoVRGATHEREI16_VV_M4_E64_M1, VRGATHEREI16_VV, 0x2, 0x40 }, // 7263 + { PseudoVRGATHEREI16_VV_M4_E64_M1_MASK, VRGATHEREI16_VV, 0x2, 0x40 }, // 7264 + { PseudoVRGATHEREI16_VV_M4_E64_M2, VRGATHEREI16_VV, 0x2, 0x40 }, // 7265 + { PseudoVRGATHEREI16_VV_M4_E64_M2_MASK, VRGATHEREI16_VV, 0x2, 0x40 }, // 7266 + { PseudoVRGATHEREI16_VV_M4_E64_M4, VRGATHEREI16_VV, 0x2, 0x40 }, // 7267 + { PseudoVRGATHEREI16_VV_M4_E64_M4_MASK, VRGATHEREI16_VV, 0x2, 0x40 }, // 7268 + { PseudoVRGATHEREI16_VV_M4_E64_M8, VRGATHEREI16_VV, 0x2, 0x40 }, // 7269 + { PseudoVRGATHEREI16_VV_M4_E64_M8_MASK, VRGATHEREI16_VV, 0x2, 0x40 }, // 7270 + { PseudoVRGATHEREI16_VV_M8_E8_M2, VRGATHEREI16_VV, 0x3, 0x8 }, // 7271 + { PseudoVRGATHEREI16_VV_M8_E8_M2_MASK, VRGATHEREI16_VV, 0x3, 0x8 }, // 7272 + { PseudoVRGATHEREI16_VV_M8_E8_M4, VRGATHEREI16_VV, 0x3, 0x8 }, // 7273 + { PseudoVRGATHEREI16_VV_M8_E8_M4_MASK, VRGATHEREI16_VV, 0x3, 0x8 }, // 7274 + { PseudoVRGATHEREI16_VV_M8_E8_M8, VRGATHEREI16_VV, 0x3, 0x8 }, // 7275 + { PseudoVRGATHEREI16_VV_M8_E8_M8_MASK, VRGATHEREI16_VV, 0x3, 0x8 }, // 7276 + { PseudoVRGATHEREI16_VV_M8_E16_M2, VRGATHEREI16_VV, 0x3, 0x10 }, // 7277 + { PseudoVRGATHEREI16_VV_M8_E16_M2_MASK, VRGATHEREI16_VV, 0x3, 0x10 }, // 7278 + { PseudoVRGATHEREI16_VV_M8_E16_M4, VRGATHEREI16_VV, 0x3, 0x10 }, // 7279 + { PseudoVRGATHEREI16_VV_M8_E16_M4_MASK, VRGATHEREI16_VV, 0x3, 0x10 }, // 7280 + { PseudoVRGATHEREI16_VV_M8_E16_M8, VRGATHEREI16_VV, 0x3, 0x10 }, // 7281 + { PseudoVRGATHEREI16_VV_M8_E16_M8_MASK, VRGATHEREI16_VV, 0x3, 0x10 }, // 7282 + { PseudoVRGATHEREI16_VV_M8_E32_M2, VRGATHEREI16_VV, 0x3, 0x20 }, // 7283 + { PseudoVRGATHEREI16_VV_M8_E32_M2_MASK, VRGATHEREI16_VV, 0x3, 0x20 }, // 7284 + { PseudoVRGATHEREI16_VV_M8_E32_M4, VRGATHEREI16_VV, 0x3, 0x20 }, // 7285 + { PseudoVRGATHEREI16_VV_M8_E32_M4_MASK, VRGATHEREI16_VV, 0x3, 0x20 }, // 7286 + { PseudoVRGATHEREI16_VV_M8_E32_M8, VRGATHEREI16_VV, 0x3, 0x20 }, // 7287 + { PseudoVRGATHEREI16_VV_M8_E32_M8_MASK, VRGATHEREI16_VV, 0x3, 0x20 }, // 7288 + { PseudoVRGATHEREI16_VV_M8_E64_M2, VRGATHEREI16_VV, 0x3, 0x40 }, // 7289 + { PseudoVRGATHEREI16_VV_M8_E64_M2_MASK, VRGATHEREI16_VV, 0x3, 0x40 }, // 7290 + { PseudoVRGATHEREI16_VV_M8_E64_M4, VRGATHEREI16_VV, 0x3, 0x40 }, // 7291 + { PseudoVRGATHEREI16_VV_M8_E64_M4_MASK, VRGATHEREI16_VV, 0x3, 0x40 }, // 7292 + { PseudoVRGATHEREI16_VV_M8_E64_M8, VRGATHEREI16_VV, 0x3, 0x40 }, // 7293 + { PseudoVRGATHEREI16_VV_M8_E64_M8_MASK, VRGATHEREI16_VV, 0x3, 0x40 }, // 7294 + { PseudoVRGATHEREI16_VV_MF8_E8_MF4, VRGATHEREI16_VV, 0x5, 0x8 }, // 7295 + { PseudoVRGATHEREI16_VV_MF8_E8_MF4_MASK, VRGATHEREI16_VV, 0x5, 0x8 }, // 7296 + { PseudoVRGATHEREI16_VV_MF8_E8_MF8, VRGATHEREI16_VV, 0x5, 0x8 }, // 7297 + { PseudoVRGATHEREI16_VV_MF8_E8_MF8_MASK, VRGATHEREI16_VV, 0x5, 0x8 }, // 7298 + { PseudoVRGATHEREI16_VV_MF4_E8_MF2, VRGATHEREI16_VV, 0x6, 0x8 }, // 7299 + { PseudoVRGATHEREI16_VV_MF4_E8_MF2_MASK, VRGATHEREI16_VV, 0x6, 0x8 }, // 7300 + { PseudoVRGATHEREI16_VV_MF4_E8_MF4, VRGATHEREI16_VV, 0x6, 0x8 }, // 7301 + { PseudoVRGATHEREI16_VV_MF4_E8_MF4_MASK, VRGATHEREI16_VV, 0x6, 0x8 }, // 7302 + { PseudoVRGATHEREI16_VV_MF4_E8_MF8, VRGATHEREI16_VV, 0x6, 0x8 }, // 7303 + { PseudoVRGATHEREI16_VV_MF4_E8_MF8_MASK, VRGATHEREI16_VV, 0x6, 0x8 }, // 7304 + { PseudoVRGATHEREI16_VV_MF4_E16_MF2, VRGATHEREI16_VV, 0x6, 0x10 }, // 7305 + { PseudoVRGATHEREI16_VV_MF4_E16_MF2_MASK, VRGATHEREI16_VV, 0x6, 0x10 }, // 7306 + { PseudoVRGATHEREI16_VV_MF4_E16_MF4, VRGATHEREI16_VV, 0x6, 0x10 }, // 7307 + { PseudoVRGATHEREI16_VV_MF4_E16_MF4_MASK, VRGATHEREI16_VV, 0x6, 0x10 }, // 7308 + { PseudoVRGATHEREI16_VV_MF4_E16_MF8, VRGATHEREI16_VV, 0x6, 0x10 }, // 7309 + { PseudoVRGATHEREI16_VV_MF4_E16_MF8_MASK, VRGATHEREI16_VV, 0x6, 0x10 }, // 7310 + { PseudoVRGATHEREI16_VV_MF2_E8_M1, VRGATHEREI16_VV, 0x7, 0x8 }, // 7311 + { PseudoVRGATHEREI16_VV_MF2_E8_M1_MASK, VRGATHEREI16_VV, 0x7, 0x8 }, // 7312 + { PseudoVRGATHEREI16_VV_MF2_E8_MF2, VRGATHEREI16_VV, 0x7, 0x8 }, // 7313 + { PseudoVRGATHEREI16_VV_MF2_E8_MF2_MASK, VRGATHEREI16_VV, 0x7, 0x8 }, // 7314 + { PseudoVRGATHEREI16_VV_MF2_E8_MF4, VRGATHEREI16_VV, 0x7, 0x8 }, // 7315 + { PseudoVRGATHEREI16_VV_MF2_E8_MF4_MASK, VRGATHEREI16_VV, 0x7, 0x8 }, // 7316 + { PseudoVRGATHEREI16_VV_MF2_E8_MF8, VRGATHEREI16_VV, 0x7, 0x8 }, // 7317 + { PseudoVRGATHEREI16_VV_MF2_E8_MF8_MASK, VRGATHEREI16_VV, 0x7, 0x8 }, // 7318 + { PseudoVRGATHEREI16_VV_MF2_E16_M1, VRGATHEREI16_VV, 0x7, 0x10 }, // 7319 + { PseudoVRGATHEREI16_VV_MF2_E16_M1_MASK, VRGATHEREI16_VV, 0x7, 0x10 }, // 7320 + { PseudoVRGATHEREI16_VV_MF2_E16_MF2, VRGATHEREI16_VV, 0x7, 0x10 }, // 7321 + { PseudoVRGATHEREI16_VV_MF2_E16_MF2_MASK, VRGATHEREI16_VV, 0x7, 0x10 }, // 7322 + { PseudoVRGATHEREI16_VV_MF2_E16_MF4, VRGATHEREI16_VV, 0x7, 0x10 }, // 7323 + { PseudoVRGATHEREI16_VV_MF2_E16_MF4_MASK, VRGATHEREI16_VV, 0x7, 0x10 }, // 7324 + { PseudoVRGATHEREI16_VV_MF2_E16_MF8, VRGATHEREI16_VV, 0x7, 0x10 }, // 7325 + { PseudoVRGATHEREI16_VV_MF2_E16_MF8_MASK, VRGATHEREI16_VV, 0x7, 0x10 }, // 7326 + { PseudoVRGATHEREI16_VV_MF2_E32_M1, VRGATHEREI16_VV, 0x7, 0x20 }, // 7327 + { PseudoVRGATHEREI16_VV_MF2_E32_M1_MASK, VRGATHEREI16_VV, 0x7, 0x20 }, // 7328 + { PseudoVRGATHEREI16_VV_MF2_E32_MF2, VRGATHEREI16_VV, 0x7, 0x20 }, // 7329 + { PseudoVRGATHEREI16_VV_MF2_E32_MF2_MASK, VRGATHEREI16_VV, 0x7, 0x20 }, // 7330 + { PseudoVRGATHEREI16_VV_MF2_E32_MF4, VRGATHEREI16_VV, 0x7, 0x20 }, // 7331 + { PseudoVRGATHEREI16_VV_MF2_E32_MF4_MASK, VRGATHEREI16_VV, 0x7, 0x20 }, // 7332 + { PseudoVRGATHEREI16_VV_MF2_E32_MF8, VRGATHEREI16_VV, 0x7, 0x20 }, // 7333 + { PseudoVRGATHEREI16_VV_MF2_E32_MF8_MASK, VRGATHEREI16_VV, 0x7, 0x20 }, // 7334 + { PseudoVRGATHER_VI_M1, VRGATHER_VI, 0x0, 0x0 }, // 7335 + { PseudoVRGATHER_VI_M1_MASK, VRGATHER_VI, 0x0, 0x0 }, // 7336 + { PseudoVRGATHER_VI_M2, VRGATHER_VI, 0x1, 0x0 }, // 7337 + { PseudoVRGATHER_VI_M2_MASK, VRGATHER_VI, 0x1, 0x0 }, // 7338 + { PseudoVRGATHER_VI_M4, VRGATHER_VI, 0x2, 0x0 }, // 7339 + { PseudoVRGATHER_VI_M4_MASK, VRGATHER_VI, 0x2, 0x0 }, // 7340 + { PseudoVRGATHER_VI_M8, VRGATHER_VI, 0x3, 0x0 }, // 7341 + { PseudoVRGATHER_VI_M8_MASK, VRGATHER_VI, 0x3, 0x0 }, // 7342 + { PseudoVRGATHER_VI_MF8, VRGATHER_VI, 0x5, 0x0 }, // 7343 + { PseudoVRGATHER_VI_MF8_MASK, VRGATHER_VI, 0x5, 0x0 }, // 7344 + { PseudoVRGATHER_VI_MF4, VRGATHER_VI, 0x6, 0x0 }, // 7345 + { PseudoVRGATHER_VI_MF4_MASK, VRGATHER_VI, 0x6, 0x0 }, // 7346 + { PseudoVRGATHER_VI_MF2, VRGATHER_VI, 0x7, 0x0 }, // 7347 + { PseudoVRGATHER_VI_MF2_MASK, VRGATHER_VI, 0x7, 0x0 }, // 7348 + { PseudoVRGATHER_VV_M1_E8, VRGATHER_VV, 0x0, 0x8 }, // 7349 + { PseudoVRGATHER_VV_M1_E8_MASK, VRGATHER_VV, 0x0, 0x8 }, // 7350 + { PseudoVRGATHER_VV_M1_E16, VRGATHER_VV, 0x0, 0x10 }, // 7351 + { PseudoVRGATHER_VV_M1_E16_MASK, VRGATHER_VV, 0x0, 0x10 }, // 7352 + { PseudoVRGATHER_VV_M1_E32, VRGATHER_VV, 0x0, 0x20 }, // 7353 + { PseudoVRGATHER_VV_M1_E32_MASK, VRGATHER_VV, 0x0, 0x20 }, // 7354 + { PseudoVRGATHER_VV_M1_E64, VRGATHER_VV, 0x0, 0x40 }, // 7355 + { PseudoVRGATHER_VV_M1_E64_MASK, VRGATHER_VV, 0x0, 0x40 }, // 7356 + { PseudoVRGATHER_VV_M2_E8, VRGATHER_VV, 0x1, 0x8 }, // 7357 + { PseudoVRGATHER_VV_M2_E8_MASK, VRGATHER_VV, 0x1, 0x8 }, // 7358 + { PseudoVRGATHER_VV_M2_E16, VRGATHER_VV, 0x1, 0x10 }, // 7359 + { PseudoVRGATHER_VV_M2_E16_MASK, VRGATHER_VV, 0x1, 0x10 }, // 7360 + { PseudoVRGATHER_VV_M2_E32, VRGATHER_VV, 0x1, 0x20 }, // 7361 + { PseudoVRGATHER_VV_M2_E32_MASK, VRGATHER_VV, 0x1, 0x20 }, // 7362 + { PseudoVRGATHER_VV_M2_E64, VRGATHER_VV, 0x1, 0x40 }, // 7363 + { PseudoVRGATHER_VV_M2_E64_MASK, VRGATHER_VV, 0x1, 0x40 }, // 7364 + { PseudoVRGATHER_VV_M4_E8, VRGATHER_VV, 0x2, 0x8 }, // 7365 + { PseudoVRGATHER_VV_M4_E8_MASK, VRGATHER_VV, 0x2, 0x8 }, // 7366 + { PseudoVRGATHER_VV_M4_E16, VRGATHER_VV, 0x2, 0x10 }, // 7367 + { PseudoVRGATHER_VV_M4_E16_MASK, VRGATHER_VV, 0x2, 0x10 }, // 7368 + { PseudoVRGATHER_VV_M4_E32, VRGATHER_VV, 0x2, 0x20 }, // 7369 + { PseudoVRGATHER_VV_M4_E32_MASK, VRGATHER_VV, 0x2, 0x20 }, // 7370 + { PseudoVRGATHER_VV_M4_E64, VRGATHER_VV, 0x2, 0x40 }, // 7371 + { PseudoVRGATHER_VV_M4_E64_MASK, VRGATHER_VV, 0x2, 0x40 }, // 7372 + { PseudoVRGATHER_VV_M8_E8, VRGATHER_VV, 0x3, 0x8 }, // 7373 + { PseudoVRGATHER_VV_M8_E8_MASK, VRGATHER_VV, 0x3, 0x8 }, // 7374 + { PseudoVRGATHER_VV_M8_E16, VRGATHER_VV, 0x3, 0x10 }, // 7375 + { PseudoVRGATHER_VV_M8_E16_MASK, VRGATHER_VV, 0x3, 0x10 }, // 7376 + { PseudoVRGATHER_VV_M8_E32, VRGATHER_VV, 0x3, 0x20 }, // 7377 + { PseudoVRGATHER_VV_M8_E32_MASK, VRGATHER_VV, 0x3, 0x20 }, // 7378 + { PseudoVRGATHER_VV_M8_E64, VRGATHER_VV, 0x3, 0x40 }, // 7379 + { PseudoVRGATHER_VV_M8_E64_MASK, VRGATHER_VV, 0x3, 0x40 }, // 7380 + { PseudoVRGATHER_VV_MF8_E8, VRGATHER_VV, 0x5, 0x8 }, // 7381 + { PseudoVRGATHER_VV_MF8_E8_MASK, VRGATHER_VV, 0x5, 0x8 }, // 7382 + { PseudoVRGATHER_VV_MF4_E8, VRGATHER_VV, 0x6, 0x8 }, // 7383 + { PseudoVRGATHER_VV_MF4_E8_MASK, VRGATHER_VV, 0x6, 0x8 }, // 7384 + { PseudoVRGATHER_VV_MF4_E16, VRGATHER_VV, 0x6, 0x10 }, // 7385 + { PseudoVRGATHER_VV_MF4_E16_MASK, VRGATHER_VV, 0x6, 0x10 }, // 7386 + { PseudoVRGATHER_VV_MF2_E8, VRGATHER_VV, 0x7, 0x8 }, // 7387 + { PseudoVRGATHER_VV_MF2_E8_MASK, VRGATHER_VV, 0x7, 0x8 }, // 7388 + { PseudoVRGATHER_VV_MF2_E16, VRGATHER_VV, 0x7, 0x10 }, // 7389 + { PseudoVRGATHER_VV_MF2_E16_MASK, VRGATHER_VV, 0x7, 0x10 }, // 7390 + { PseudoVRGATHER_VV_MF2_E32, VRGATHER_VV, 0x7, 0x20 }, // 7391 + { PseudoVRGATHER_VV_MF2_E32_MASK, VRGATHER_VV, 0x7, 0x20 }, // 7392 + { PseudoVRGATHER_VX_M1, VRGATHER_VX, 0x0, 0x0 }, // 7393 + { PseudoVRGATHER_VX_M1_MASK, VRGATHER_VX, 0x0, 0x0 }, // 7394 + { PseudoVRGATHER_VX_M2, VRGATHER_VX, 0x1, 0x0 }, // 7395 + { PseudoVRGATHER_VX_M2_MASK, VRGATHER_VX, 0x1, 0x0 }, // 7396 + { PseudoVRGATHER_VX_M4, VRGATHER_VX, 0x2, 0x0 }, // 7397 + { PseudoVRGATHER_VX_M4_MASK, VRGATHER_VX, 0x2, 0x0 }, // 7398 + { PseudoVRGATHER_VX_M8, VRGATHER_VX, 0x3, 0x0 }, // 7399 + { PseudoVRGATHER_VX_M8_MASK, VRGATHER_VX, 0x3, 0x0 }, // 7400 + { PseudoVRGATHER_VX_MF8, VRGATHER_VX, 0x5, 0x0 }, // 7401 + { PseudoVRGATHER_VX_MF8_MASK, VRGATHER_VX, 0x5, 0x0 }, // 7402 + { PseudoVRGATHER_VX_MF4, VRGATHER_VX, 0x6, 0x0 }, // 7403 + { PseudoVRGATHER_VX_MF4_MASK, VRGATHER_VX, 0x6, 0x0 }, // 7404 + { PseudoVRGATHER_VX_MF2, VRGATHER_VX, 0x7, 0x0 }, // 7405 + { PseudoVRGATHER_VX_MF2_MASK, VRGATHER_VX, 0x7, 0x0 }, // 7406 + { PseudoVROL_VV_M1, VROL_VV, 0x0, 0x0 }, // 7407 + { PseudoVROL_VV_M1_MASK, VROL_VV, 0x0, 0x0 }, // 7408 + { PseudoVROL_VV_M2, VROL_VV, 0x1, 0x0 }, // 7409 + { PseudoVROL_VV_M2_MASK, VROL_VV, 0x1, 0x0 }, // 7410 + { PseudoVROL_VV_M4, VROL_VV, 0x2, 0x0 }, // 7411 + { PseudoVROL_VV_M4_MASK, VROL_VV, 0x2, 0x0 }, // 7412 + { PseudoVROL_VV_M8, VROL_VV, 0x3, 0x0 }, // 7413 + { PseudoVROL_VV_M8_MASK, VROL_VV, 0x3, 0x0 }, // 7414 + { PseudoVROL_VV_MF8, VROL_VV, 0x5, 0x0 }, // 7415 + { PseudoVROL_VV_MF8_MASK, VROL_VV, 0x5, 0x0 }, // 7416 + { PseudoVROL_VV_MF4, VROL_VV, 0x6, 0x0 }, // 7417 + { PseudoVROL_VV_MF4_MASK, VROL_VV, 0x6, 0x0 }, // 7418 + { PseudoVROL_VV_MF2, VROL_VV, 0x7, 0x0 }, // 7419 + { PseudoVROL_VV_MF2_MASK, VROL_VV, 0x7, 0x0 }, // 7420 + { PseudoVROL_VX_M1, VROL_VX, 0x0, 0x0 }, // 7421 + { PseudoVROL_VX_M1_MASK, VROL_VX, 0x0, 0x0 }, // 7422 + { PseudoVROL_VX_M2, VROL_VX, 0x1, 0x0 }, // 7423 + { PseudoVROL_VX_M2_MASK, VROL_VX, 0x1, 0x0 }, // 7424 + { PseudoVROL_VX_M4, VROL_VX, 0x2, 0x0 }, // 7425 + { PseudoVROL_VX_M4_MASK, VROL_VX, 0x2, 0x0 }, // 7426 + { PseudoVROL_VX_M8, VROL_VX, 0x3, 0x0 }, // 7427 + { PseudoVROL_VX_M8_MASK, VROL_VX, 0x3, 0x0 }, // 7428 + { PseudoVROL_VX_MF8, VROL_VX, 0x5, 0x0 }, // 7429 + { PseudoVROL_VX_MF8_MASK, VROL_VX, 0x5, 0x0 }, // 7430 + { PseudoVROL_VX_MF4, VROL_VX, 0x6, 0x0 }, // 7431 + { PseudoVROL_VX_MF4_MASK, VROL_VX, 0x6, 0x0 }, // 7432 + { PseudoVROL_VX_MF2, VROL_VX, 0x7, 0x0 }, // 7433 + { PseudoVROL_VX_MF2_MASK, VROL_VX, 0x7, 0x0 }, // 7434 + { PseudoVROR_VI_M1, VROR_VI, 0x0, 0x0 }, // 7435 + { PseudoVROR_VI_M1_MASK, VROR_VI, 0x0, 0x0 }, // 7436 + { PseudoVROR_VI_M2, VROR_VI, 0x1, 0x0 }, // 7437 + { PseudoVROR_VI_M2_MASK, VROR_VI, 0x1, 0x0 }, // 7438 + { PseudoVROR_VI_M4, VROR_VI, 0x2, 0x0 }, // 7439 + { PseudoVROR_VI_M4_MASK, VROR_VI, 0x2, 0x0 }, // 7440 + { PseudoVROR_VI_M8, VROR_VI, 0x3, 0x0 }, // 7441 + { PseudoVROR_VI_M8_MASK, VROR_VI, 0x3, 0x0 }, // 7442 + { PseudoVROR_VI_MF8, VROR_VI, 0x5, 0x0 }, // 7443 + { PseudoVROR_VI_MF8_MASK, VROR_VI, 0x5, 0x0 }, // 7444 + { PseudoVROR_VI_MF4, VROR_VI, 0x6, 0x0 }, // 7445 + { PseudoVROR_VI_MF4_MASK, VROR_VI, 0x6, 0x0 }, // 7446 + { PseudoVROR_VI_MF2, VROR_VI, 0x7, 0x0 }, // 7447 + { PseudoVROR_VI_MF2_MASK, VROR_VI, 0x7, 0x0 }, // 7448 + { PseudoVROR_VV_M1, VROR_VV, 0x0, 0x0 }, // 7449 + { PseudoVROR_VV_M1_MASK, VROR_VV, 0x0, 0x0 }, // 7450 + { PseudoVROR_VV_M2, VROR_VV, 0x1, 0x0 }, // 7451 + { PseudoVROR_VV_M2_MASK, VROR_VV, 0x1, 0x0 }, // 7452 + { PseudoVROR_VV_M4, VROR_VV, 0x2, 0x0 }, // 7453 + { PseudoVROR_VV_M4_MASK, VROR_VV, 0x2, 0x0 }, // 7454 + { PseudoVROR_VV_M8, VROR_VV, 0x3, 0x0 }, // 7455 + { PseudoVROR_VV_M8_MASK, VROR_VV, 0x3, 0x0 }, // 7456 + { PseudoVROR_VV_MF8, VROR_VV, 0x5, 0x0 }, // 7457 + { PseudoVROR_VV_MF8_MASK, VROR_VV, 0x5, 0x0 }, // 7458 + { PseudoVROR_VV_MF4, VROR_VV, 0x6, 0x0 }, // 7459 + { PseudoVROR_VV_MF4_MASK, VROR_VV, 0x6, 0x0 }, // 7460 + { PseudoVROR_VV_MF2, VROR_VV, 0x7, 0x0 }, // 7461 + { PseudoVROR_VV_MF2_MASK, VROR_VV, 0x7, 0x0 }, // 7462 + { PseudoVROR_VX_M1, VROR_VX, 0x0, 0x0 }, // 7463 + { PseudoVROR_VX_M1_MASK, VROR_VX, 0x0, 0x0 }, // 7464 + { PseudoVROR_VX_M2, VROR_VX, 0x1, 0x0 }, // 7465 + { PseudoVROR_VX_M2_MASK, VROR_VX, 0x1, 0x0 }, // 7466 + { PseudoVROR_VX_M4, VROR_VX, 0x2, 0x0 }, // 7467 + { PseudoVROR_VX_M4_MASK, VROR_VX, 0x2, 0x0 }, // 7468 + { PseudoVROR_VX_M8, VROR_VX, 0x3, 0x0 }, // 7469 + { PseudoVROR_VX_M8_MASK, VROR_VX, 0x3, 0x0 }, // 7470 + { PseudoVROR_VX_MF8, VROR_VX, 0x5, 0x0 }, // 7471 + { PseudoVROR_VX_MF8_MASK, VROR_VX, 0x5, 0x0 }, // 7472 + { PseudoVROR_VX_MF4, VROR_VX, 0x6, 0x0 }, // 7473 + { PseudoVROR_VX_MF4_MASK, VROR_VX, 0x6, 0x0 }, // 7474 + { PseudoVROR_VX_MF2, VROR_VX, 0x7, 0x0 }, // 7475 + { PseudoVROR_VX_MF2_MASK, VROR_VX, 0x7, 0x0 }, // 7476 + { PseudoVRSUB_VI_M1, VRSUB_VI, 0x0, 0x0 }, // 7477 + { PseudoVRSUB_VI_M1_MASK, VRSUB_VI, 0x0, 0x0 }, // 7478 + { PseudoVRSUB_VI_M2, VRSUB_VI, 0x1, 0x0 }, // 7479 + { PseudoVRSUB_VI_M2_MASK, VRSUB_VI, 0x1, 0x0 }, // 7480 + { PseudoVRSUB_VI_M4, VRSUB_VI, 0x2, 0x0 }, // 7481 + { PseudoVRSUB_VI_M4_MASK, VRSUB_VI, 0x2, 0x0 }, // 7482 + { PseudoVRSUB_VI_M8, VRSUB_VI, 0x3, 0x0 }, // 7483 + { PseudoVRSUB_VI_M8_MASK, VRSUB_VI, 0x3, 0x0 }, // 7484 + { PseudoVRSUB_VI_MF8, VRSUB_VI, 0x5, 0x0 }, // 7485 + { PseudoVRSUB_VI_MF8_MASK, VRSUB_VI, 0x5, 0x0 }, // 7486 + { PseudoVRSUB_VI_MF4, VRSUB_VI, 0x6, 0x0 }, // 7487 + { PseudoVRSUB_VI_MF4_MASK, VRSUB_VI, 0x6, 0x0 }, // 7488 + { PseudoVRSUB_VI_MF2, VRSUB_VI, 0x7, 0x0 }, // 7489 + { PseudoVRSUB_VI_MF2_MASK, VRSUB_VI, 0x7, 0x0 }, // 7490 + { PseudoVRSUB_VX_M1, VRSUB_VX, 0x0, 0x0 }, // 7491 + { PseudoVRSUB_VX_M1_MASK, VRSUB_VX, 0x0, 0x0 }, // 7492 + { PseudoVRSUB_VX_M2, VRSUB_VX, 0x1, 0x0 }, // 7493 + { PseudoVRSUB_VX_M2_MASK, VRSUB_VX, 0x1, 0x0 }, // 7494 + { PseudoVRSUB_VX_M4, VRSUB_VX, 0x2, 0x0 }, // 7495 + { PseudoVRSUB_VX_M4_MASK, VRSUB_VX, 0x2, 0x0 }, // 7496 + { PseudoVRSUB_VX_M8, VRSUB_VX, 0x3, 0x0 }, // 7497 + { PseudoVRSUB_VX_M8_MASK, VRSUB_VX, 0x3, 0x0 }, // 7498 + { PseudoVRSUB_VX_MF8, VRSUB_VX, 0x5, 0x0 }, // 7499 + { PseudoVRSUB_VX_MF8_MASK, VRSUB_VX, 0x5, 0x0 }, // 7500 + { PseudoVRSUB_VX_MF4, VRSUB_VX, 0x6, 0x0 }, // 7501 + { PseudoVRSUB_VX_MF4_MASK, VRSUB_VX, 0x6, 0x0 }, // 7502 + { PseudoVRSUB_VX_MF2, VRSUB_VX, 0x7, 0x0 }, // 7503 + { PseudoVRSUB_VX_MF2_MASK, VRSUB_VX, 0x7, 0x0 }, // 7504 + { PseudoVSADDU_VI_M1, VSADDU_VI, 0x0, 0x0 }, // 7505 + { PseudoVSADDU_VI_M1_MASK, VSADDU_VI, 0x0, 0x0 }, // 7506 + { PseudoVSADDU_VI_M2, VSADDU_VI, 0x1, 0x0 }, // 7507 + { PseudoVSADDU_VI_M2_MASK, VSADDU_VI, 0x1, 0x0 }, // 7508 + { PseudoVSADDU_VI_M4, VSADDU_VI, 0x2, 0x0 }, // 7509 + { PseudoVSADDU_VI_M4_MASK, VSADDU_VI, 0x2, 0x0 }, // 7510 + { PseudoVSADDU_VI_M8, VSADDU_VI, 0x3, 0x0 }, // 7511 + { PseudoVSADDU_VI_M8_MASK, VSADDU_VI, 0x3, 0x0 }, // 7512 + { PseudoVSADDU_VI_MF8, VSADDU_VI, 0x5, 0x0 }, // 7513 + { PseudoVSADDU_VI_MF8_MASK, VSADDU_VI, 0x5, 0x0 }, // 7514 + { PseudoVSADDU_VI_MF4, VSADDU_VI, 0x6, 0x0 }, // 7515 + { PseudoVSADDU_VI_MF4_MASK, VSADDU_VI, 0x6, 0x0 }, // 7516 + { PseudoVSADDU_VI_MF2, VSADDU_VI, 0x7, 0x0 }, // 7517 + { PseudoVSADDU_VI_MF2_MASK, VSADDU_VI, 0x7, 0x0 }, // 7518 + { PseudoVSADDU_VV_M1, VSADDU_VV, 0x0, 0x0 }, // 7519 + { PseudoVSADDU_VV_M1_MASK, VSADDU_VV, 0x0, 0x0 }, // 7520 + { PseudoVSADDU_VV_M2, VSADDU_VV, 0x1, 0x0 }, // 7521 + { PseudoVSADDU_VV_M2_MASK, VSADDU_VV, 0x1, 0x0 }, // 7522 + { PseudoVSADDU_VV_M4, VSADDU_VV, 0x2, 0x0 }, // 7523 + { PseudoVSADDU_VV_M4_MASK, VSADDU_VV, 0x2, 0x0 }, // 7524 + { PseudoVSADDU_VV_M8, VSADDU_VV, 0x3, 0x0 }, // 7525 + { PseudoVSADDU_VV_M8_MASK, VSADDU_VV, 0x3, 0x0 }, // 7526 + { PseudoVSADDU_VV_MF8, VSADDU_VV, 0x5, 0x0 }, // 7527 + { PseudoVSADDU_VV_MF8_MASK, VSADDU_VV, 0x5, 0x0 }, // 7528 + { PseudoVSADDU_VV_MF4, VSADDU_VV, 0x6, 0x0 }, // 7529 + { PseudoVSADDU_VV_MF4_MASK, VSADDU_VV, 0x6, 0x0 }, // 7530 + { PseudoVSADDU_VV_MF2, VSADDU_VV, 0x7, 0x0 }, // 7531 + { PseudoVSADDU_VV_MF2_MASK, VSADDU_VV, 0x7, 0x0 }, // 7532 + { PseudoVSADDU_VX_M1, VSADDU_VX, 0x0, 0x0 }, // 7533 + { PseudoVSADDU_VX_M1_MASK, VSADDU_VX, 0x0, 0x0 }, // 7534 + { PseudoVSADDU_VX_M2, VSADDU_VX, 0x1, 0x0 }, // 7535 + { PseudoVSADDU_VX_M2_MASK, VSADDU_VX, 0x1, 0x0 }, // 7536 + { PseudoVSADDU_VX_M4, VSADDU_VX, 0x2, 0x0 }, // 7537 + { PseudoVSADDU_VX_M4_MASK, VSADDU_VX, 0x2, 0x0 }, // 7538 + { PseudoVSADDU_VX_M8, VSADDU_VX, 0x3, 0x0 }, // 7539 + { PseudoVSADDU_VX_M8_MASK, VSADDU_VX, 0x3, 0x0 }, // 7540 + { PseudoVSADDU_VX_MF8, VSADDU_VX, 0x5, 0x0 }, // 7541 + { PseudoVSADDU_VX_MF8_MASK, VSADDU_VX, 0x5, 0x0 }, // 7542 + { PseudoVSADDU_VX_MF4, VSADDU_VX, 0x6, 0x0 }, // 7543 + { PseudoVSADDU_VX_MF4_MASK, VSADDU_VX, 0x6, 0x0 }, // 7544 + { PseudoVSADDU_VX_MF2, VSADDU_VX, 0x7, 0x0 }, // 7545 + { PseudoVSADDU_VX_MF2_MASK, VSADDU_VX, 0x7, 0x0 }, // 7546 + { PseudoVSADD_VI_M1, VSADD_VI, 0x0, 0x0 }, // 7547 + { PseudoVSADD_VI_M1_MASK, VSADD_VI, 0x0, 0x0 }, // 7548 + { PseudoVSADD_VI_M2, VSADD_VI, 0x1, 0x0 }, // 7549 + { PseudoVSADD_VI_M2_MASK, VSADD_VI, 0x1, 0x0 }, // 7550 + { PseudoVSADD_VI_M4, VSADD_VI, 0x2, 0x0 }, // 7551 + { PseudoVSADD_VI_M4_MASK, VSADD_VI, 0x2, 0x0 }, // 7552 + { PseudoVSADD_VI_M8, VSADD_VI, 0x3, 0x0 }, // 7553 + { PseudoVSADD_VI_M8_MASK, VSADD_VI, 0x3, 0x0 }, // 7554 + { PseudoVSADD_VI_MF8, VSADD_VI, 0x5, 0x0 }, // 7555 + { PseudoVSADD_VI_MF8_MASK, VSADD_VI, 0x5, 0x0 }, // 7556 + { PseudoVSADD_VI_MF4, VSADD_VI, 0x6, 0x0 }, // 7557 + { PseudoVSADD_VI_MF4_MASK, VSADD_VI, 0x6, 0x0 }, // 7558 + { PseudoVSADD_VI_MF2, VSADD_VI, 0x7, 0x0 }, // 7559 + { PseudoVSADD_VI_MF2_MASK, VSADD_VI, 0x7, 0x0 }, // 7560 + { PseudoVSADD_VV_M1, VSADD_VV, 0x0, 0x0 }, // 7561 + { PseudoVSADD_VV_M1_MASK, VSADD_VV, 0x0, 0x0 }, // 7562 + { PseudoVSADD_VV_M2, VSADD_VV, 0x1, 0x0 }, // 7563 + { PseudoVSADD_VV_M2_MASK, VSADD_VV, 0x1, 0x0 }, // 7564 + { PseudoVSADD_VV_M4, VSADD_VV, 0x2, 0x0 }, // 7565 + { PseudoVSADD_VV_M4_MASK, VSADD_VV, 0x2, 0x0 }, // 7566 + { PseudoVSADD_VV_M8, VSADD_VV, 0x3, 0x0 }, // 7567 + { PseudoVSADD_VV_M8_MASK, VSADD_VV, 0x3, 0x0 }, // 7568 + { PseudoVSADD_VV_MF8, VSADD_VV, 0x5, 0x0 }, // 7569 + { PseudoVSADD_VV_MF8_MASK, VSADD_VV, 0x5, 0x0 }, // 7570 + { PseudoVSADD_VV_MF4, VSADD_VV, 0x6, 0x0 }, // 7571 + { PseudoVSADD_VV_MF4_MASK, VSADD_VV, 0x6, 0x0 }, // 7572 + { PseudoVSADD_VV_MF2, VSADD_VV, 0x7, 0x0 }, // 7573 + { PseudoVSADD_VV_MF2_MASK, VSADD_VV, 0x7, 0x0 }, // 7574 + { PseudoVSADD_VX_M1, VSADD_VX, 0x0, 0x0 }, // 7575 + { PseudoVSADD_VX_M1_MASK, VSADD_VX, 0x0, 0x0 }, // 7576 + { PseudoVSADD_VX_M2, VSADD_VX, 0x1, 0x0 }, // 7577 + { PseudoVSADD_VX_M2_MASK, VSADD_VX, 0x1, 0x0 }, // 7578 + { PseudoVSADD_VX_M4, VSADD_VX, 0x2, 0x0 }, // 7579 + { PseudoVSADD_VX_M4_MASK, VSADD_VX, 0x2, 0x0 }, // 7580 + { PseudoVSADD_VX_M8, VSADD_VX, 0x3, 0x0 }, // 7581 + { PseudoVSADD_VX_M8_MASK, VSADD_VX, 0x3, 0x0 }, // 7582 + { PseudoVSADD_VX_MF8, VSADD_VX, 0x5, 0x0 }, // 7583 + { PseudoVSADD_VX_MF8_MASK, VSADD_VX, 0x5, 0x0 }, // 7584 + { PseudoVSADD_VX_MF4, VSADD_VX, 0x6, 0x0 }, // 7585 + { PseudoVSADD_VX_MF4_MASK, VSADD_VX, 0x6, 0x0 }, // 7586 + { PseudoVSADD_VX_MF2, VSADD_VX, 0x7, 0x0 }, // 7587 + { PseudoVSADD_VX_MF2_MASK, VSADD_VX, 0x7, 0x0 }, // 7588 + { PseudoVSBC_VVM_M1, VSBC_VVM, 0x0, 0x0 }, // 7589 + { PseudoVSBC_VVM_M2, VSBC_VVM, 0x1, 0x0 }, // 7590 + { PseudoVSBC_VVM_M4, VSBC_VVM, 0x2, 0x0 }, // 7591 + { PseudoVSBC_VVM_M8, VSBC_VVM, 0x3, 0x0 }, // 7592 + { PseudoVSBC_VVM_MF8, VSBC_VVM, 0x5, 0x0 }, // 7593 + { PseudoVSBC_VVM_MF4, VSBC_VVM, 0x6, 0x0 }, // 7594 + { PseudoVSBC_VVM_MF2, VSBC_VVM, 0x7, 0x0 }, // 7595 + { PseudoVSBC_VXM_M1, VSBC_VXM, 0x0, 0x0 }, // 7596 + { PseudoVSBC_VXM_M2, VSBC_VXM, 0x1, 0x0 }, // 7597 + { PseudoVSBC_VXM_M4, VSBC_VXM, 0x2, 0x0 }, // 7598 + { PseudoVSBC_VXM_M8, VSBC_VXM, 0x3, 0x0 }, // 7599 + { PseudoVSBC_VXM_MF8, VSBC_VXM, 0x5, 0x0 }, // 7600 + { PseudoVSBC_VXM_MF4, VSBC_VXM, 0x6, 0x0 }, // 7601 + { PseudoVSBC_VXM_MF2, VSBC_VXM, 0x7, 0x0 }, // 7602 + { PseudoVSE16_V_M1, VSE16_V, 0x0, 0x10 }, // 7603 + { PseudoVSE16_V_M1_MASK, VSE16_V, 0x0, 0x10 }, // 7604 + { PseudoVSE16_V_M2, VSE16_V, 0x1, 0x10 }, // 7605 + { PseudoVSE16_V_M2_MASK, VSE16_V, 0x1, 0x10 }, // 7606 + { PseudoVSE16_V_M4, VSE16_V, 0x2, 0x10 }, // 7607 + { PseudoVSE16_V_M4_MASK, VSE16_V, 0x2, 0x10 }, // 7608 + { PseudoVSE16_V_M8, VSE16_V, 0x3, 0x10 }, // 7609 + { PseudoVSE16_V_M8_MASK, VSE16_V, 0x3, 0x10 }, // 7610 + { PseudoVSE16_V_MF4, VSE16_V, 0x6, 0x10 }, // 7611 + { PseudoVSE16_V_MF4_MASK, VSE16_V, 0x6, 0x10 }, // 7612 + { PseudoVSE16_V_MF2, VSE16_V, 0x7, 0x10 }, // 7613 + { PseudoVSE16_V_MF2_MASK, VSE16_V, 0x7, 0x10 }, // 7614 + { PseudoVSE32_V_M1, VSE32_V, 0x0, 0x20 }, // 7615 + { PseudoVSE32_V_M1_MASK, VSE32_V, 0x0, 0x20 }, // 7616 + { PseudoVSE32_V_M2, VSE32_V, 0x1, 0x20 }, // 7617 + { PseudoVSE32_V_M2_MASK, VSE32_V, 0x1, 0x20 }, // 7618 + { PseudoVSE32_V_M4, VSE32_V, 0x2, 0x20 }, // 7619 + { PseudoVSE32_V_M4_MASK, VSE32_V, 0x2, 0x20 }, // 7620 + { PseudoVSE32_V_M8, VSE32_V, 0x3, 0x20 }, // 7621 + { PseudoVSE32_V_M8_MASK, VSE32_V, 0x3, 0x20 }, // 7622 + { PseudoVSE32_V_MF2, VSE32_V, 0x7, 0x20 }, // 7623 + { PseudoVSE32_V_MF2_MASK, VSE32_V, 0x7, 0x20 }, // 7624 + { PseudoVSE64_V_M1, VSE64_V, 0x0, 0x40 }, // 7625 + { PseudoVSE64_V_M1_MASK, VSE64_V, 0x0, 0x40 }, // 7626 + { PseudoVSE64_V_M2, VSE64_V, 0x1, 0x40 }, // 7627 + { PseudoVSE64_V_M2_MASK, VSE64_V, 0x1, 0x40 }, // 7628 + { PseudoVSE64_V_M4, VSE64_V, 0x2, 0x40 }, // 7629 + { PseudoVSE64_V_M4_MASK, VSE64_V, 0x2, 0x40 }, // 7630 + { PseudoVSE64_V_M8, VSE64_V, 0x3, 0x40 }, // 7631 + { PseudoVSE64_V_M8_MASK, VSE64_V, 0x3, 0x40 }, // 7632 + { PseudoVSE8_V_M1, VSE8_V, 0x0, 0x8 }, // 7633 + { PseudoVSE8_V_M1_MASK, VSE8_V, 0x0, 0x8 }, // 7634 + { PseudoVSE8_V_M2, VSE8_V, 0x1, 0x8 }, // 7635 + { PseudoVSE8_V_M2_MASK, VSE8_V, 0x1, 0x8 }, // 7636 + { PseudoVSE8_V_M4, VSE8_V, 0x2, 0x8 }, // 7637 + { PseudoVSE8_V_M4_MASK, VSE8_V, 0x2, 0x8 }, // 7638 + { PseudoVSE8_V_M8, VSE8_V, 0x3, 0x8 }, // 7639 + { PseudoVSE8_V_M8_MASK, VSE8_V, 0x3, 0x8 }, // 7640 + { PseudoVSE8_V_MF8, VSE8_V, 0x5, 0x8 }, // 7641 + { PseudoVSE8_V_MF8_MASK, VSE8_V, 0x5, 0x8 }, // 7642 + { PseudoVSE8_V_MF4, VSE8_V, 0x6, 0x8 }, // 7643 + { PseudoVSE8_V_MF4_MASK, VSE8_V, 0x6, 0x8 }, // 7644 + { PseudoVSE8_V_MF2, VSE8_V, 0x7, 0x8 }, // 7645 + { PseudoVSE8_V_MF2_MASK, VSE8_V, 0x7, 0x8 }, // 7646 + { PseudoVSEXT_VF2_M1, VSEXT_VF2, 0x0, 0x0 }, // 7647 + { PseudoVSEXT_VF2_M1_MASK, VSEXT_VF2, 0x0, 0x0 }, // 7648 + { PseudoVSEXT_VF2_M2, VSEXT_VF2, 0x1, 0x0 }, // 7649 + { PseudoVSEXT_VF2_M2_MASK, VSEXT_VF2, 0x1, 0x0 }, // 7650 + { PseudoVSEXT_VF2_M4, VSEXT_VF2, 0x2, 0x0 }, // 7651 + { PseudoVSEXT_VF2_M4_MASK, VSEXT_VF2, 0x2, 0x0 }, // 7652 + { PseudoVSEXT_VF2_M8, VSEXT_VF2, 0x3, 0x0 }, // 7653 + { PseudoVSEXT_VF2_M8_MASK, VSEXT_VF2, 0x3, 0x0 }, // 7654 + { PseudoVSEXT_VF2_MF4, VSEXT_VF2, 0x6, 0x0 }, // 7655 + { PseudoVSEXT_VF2_MF4_MASK, VSEXT_VF2, 0x6, 0x0 }, // 7656 + { PseudoVSEXT_VF2_MF2, VSEXT_VF2, 0x7, 0x0 }, // 7657 + { PseudoVSEXT_VF2_MF2_MASK, VSEXT_VF2, 0x7, 0x0 }, // 7658 + { PseudoVSEXT_VF4_M1, VSEXT_VF4, 0x0, 0x0 }, // 7659 + { PseudoVSEXT_VF4_M1_MASK, VSEXT_VF4, 0x0, 0x0 }, // 7660 + { PseudoVSEXT_VF4_M2, VSEXT_VF4, 0x1, 0x0 }, // 7661 + { PseudoVSEXT_VF4_M2_MASK, VSEXT_VF4, 0x1, 0x0 }, // 7662 + { PseudoVSEXT_VF4_M4, VSEXT_VF4, 0x2, 0x0 }, // 7663 + { PseudoVSEXT_VF4_M4_MASK, VSEXT_VF4, 0x2, 0x0 }, // 7664 + { PseudoVSEXT_VF4_M8, VSEXT_VF4, 0x3, 0x0 }, // 7665 + { PseudoVSEXT_VF4_M8_MASK, VSEXT_VF4, 0x3, 0x0 }, // 7666 + { PseudoVSEXT_VF4_MF2, VSEXT_VF4, 0x7, 0x0 }, // 7667 + { PseudoVSEXT_VF4_MF2_MASK, VSEXT_VF4, 0x7, 0x0 }, // 7668 + { PseudoVSEXT_VF8_M1, VSEXT_VF8, 0x0, 0x0 }, // 7669 + { PseudoVSEXT_VF8_M1_MASK, VSEXT_VF8, 0x0, 0x0 }, // 7670 + { PseudoVSEXT_VF8_M2, VSEXT_VF8, 0x1, 0x0 }, // 7671 + { PseudoVSEXT_VF8_M2_MASK, VSEXT_VF8, 0x1, 0x0 }, // 7672 + { PseudoVSEXT_VF8_M4, VSEXT_VF8, 0x2, 0x0 }, // 7673 + { PseudoVSEXT_VF8_M4_MASK, VSEXT_VF8, 0x2, 0x0 }, // 7674 + { PseudoVSEXT_VF8_M8, VSEXT_VF8, 0x3, 0x0 }, // 7675 + { PseudoVSEXT_VF8_M8_MASK, VSEXT_VF8, 0x3, 0x0 }, // 7676 + { PseudoVSHA2CH_VV_M1, VSHA2CH_VV, 0x0, 0x0 }, // 7677 + { PseudoVSHA2CH_VV_M2, VSHA2CH_VV, 0x1, 0x0 }, // 7678 + { PseudoVSHA2CH_VV_M4, VSHA2CH_VV, 0x2, 0x0 }, // 7679 + { PseudoVSHA2CH_VV_M8, VSHA2CH_VV, 0x3, 0x0 }, // 7680 + { PseudoVSHA2CH_VV_MF2, VSHA2CH_VV, 0x7, 0x0 }, // 7681 + { PseudoVSHA2CL_VV_M1, VSHA2CL_VV, 0x0, 0x0 }, // 7682 + { PseudoVSHA2CL_VV_M2, VSHA2CL_VV, 0x1, 0x0 }, // 7683 + { PseudoVSHA2CL_VV_M4, VSHA2CL_VV, 0x2, 0x0 }, // 7684 + { PseudoVSHA2CL_VV_M8, VSHA2CL_VV, 0x3, 0x0 }, // 7685 + { PseudoVSHA2CL_VV_MF2, VSHA2CL_VV, 0x7, 0x0 }, // 7686 + { PseudoVSHA2MS_VV_M1, VSHA2MS_VV, 0x0, 0x0 }, // 7687 + { PseudoVSHA2MS_VV_M2, VSHA2MS_VV, 0x1, 0x0 }, // 7688 + { PseudoVSHA2MS_VV_M4, VSHA2MS_VV, 0x2, 0x0 }, // 7689 + { PseudoVSHA2MS_VV_M8, VSHA2MS_VV, 0x3, 0x0 }, // 7690 + { PseudoVSHA2MS_VV_MF2, VSHA2MS_VV, 0x7, 0x0 }, // 7691 + { PseudoVSLIDE1DOWN_VX_M1, VSLIDE1DOWN_VX, 0x0, 0x0 }, // 7692 + { PseudoVSLIDE1DOWN_VX_M1_MASK, VSLIDE1DOWN_VX, 0x0, 0x0 }, // 7693 + { PseudoVSLIDE1DOWN_VX_M2, VSLIDE1DOWN_VX, 0x1, 0x0 }, // 7694 + { PseudoVSLIDE1DOWN_VX_M2_MASK, VSLIDE1DOWN_VX, 0x1, 0x0 }, // 7695 + { PseudoVSLIDE1DOWN_VX_M4, VSLIDE1DOWN_VX, 0x2, 0x0 }, // 7696 + { PseudoVSLIDE1DOWN_VX_M4_MASK, VSLIDE1DOWN_VX, 0x2, 0x0 }, // 7697 + { PseudoVSLIDE1DOWN_VX_M8, VSLIDE1DOWN_VX, 0x3, 0x0 }, // 7698 + { PseudoVSLIDE1DOWN_VX_M8_MASK, VSLIDE1DOWN_VX, 0x3, 0x0 }, // 7699 + { PseudoVSLIDE1DOWN_VX_MF8, VSLIDE1DOWN_VX, 0x5, 0x0 }, // 7700 + { PseudoVSLIDE1DOWN_VX_MF8_MASK, VSLIDE1DOWN_VX, 0x5, 0x0 }, // 7701 + { PseudoVSLIDE1DOWN_VX_MF4, VSLIDE1DOWN_VX, 0x6, 0x0 }, // 7702 + { PseudoVSLIDE1DOWN_VX_MF4_MASK, VSLIDE1DOWN_VX, 0x6, 0x0 }, // 7703 + { PseudoVSLIDE1DOWN_VX_MF2, VSLIDE1DOWN_VX, 0x7, 0x0 }, // 7704 + { PseudoVSLIDE1DOWN_VX_MF2_MASK, VSLIDE1DOWN_VX, 0x7, 0x0 }, // 7705 + { PseudoVSLIDE1UP_VX_M1, VSLIDE1UP_VX, 0x0, 0x0 }, // 7706 + { PseudoVSLIDE1UP_VX_M1_MASK, VSLIDE1UP_VX, 0x0, 0x0 }, // 7707 + { PseudoVSLIDE1UP_VX_M2, VSLIDE1UP_VX, 0x1, 0x0 }, // 7708 + { PseudoVSLIDE1UP_VX_M2_MASK, VSLIDE1UP_VX, 0x1, 0x0 }, // 7709 + { PseudoVSLIDE1UP_VX_M4, VSLIDE1UP_VX, 0x2, 0x0 }, // 7710 + { PseudoVSLIDE1UP_VX_M4_MASK, VSLIDE1UP_VX, 0x2, 0x0 }, // 7711 + { PseudoVSLIDE1UP_VX_M8, VSLIDE1UP_VX, 0x3, 0x0 }, // 7712 + { PseudoVSLIDE1UP_VX_M8_MASK, VSLIDE1UP_VX, 0x3, 0x0 }, // 7713 + { PseudoVSLIDE1UP_VX_MF8, VSLIDE1UP_VX, 0x5, 0x0 }, // 7714 + { PseudoVSLIDE1UP_VX_MF8_MASK, VSLIDE1UP_VX, 0x5, 0x0 }, // 7715 + { PseudoVSLIDE1UP_VX_MF4, VSLIDE1UP_VX, 0x6, 0x0 }, // 7716 + { PseudoVSLIDE1UP_VX_MF4_MASK, VSLIDE1UP_VX, 0x6, 0x0 }, // 7717 + { PseudoVSLIDE1UP_VX_MF2, VSLIDE1UP_VX, 0x7, 0x0 }, // 7718 + { PseudoVSLIDE1UP_VX_MF2_MASK, VSLIDE1UP_VX, 0x7, 0x0 }, // 7719 + { PseudoVSLIDEDOWN_VI_M1, VSLIDEDOWN_VI, 0x0, 0x0 }, // 7720 + { PseudoVSLIDEDOWN_VI_M1_MASK, VSLIDEDOWN_VI, 0x0, 0x0 }, // 7721 + { PseudoVSLIDEDOWN_VI_M2, VSLIDEDOWN_VI, 0x1, 0x0 }, // 7722 + { PseudoVSLIDEDOWN_VI_M2_MASK, VSLIDEDOWN_VI, 0x1, 0x0 }, // 7723 + { PseudoVSLIDEDOWN_VI_M4, VSLIDEDOWN_VI, 0x2, 0x0 }, // 7724 + { PseudoVSLIDEDOWN_VI_M4_MASK, VSLIDEDOWN_VI, 0x2, 0x0 }, // 7725 + { PseudoVSLIDEDOWN_VI_M8, VSLIDEDOWN_VI, 0x3, 0x0 }, // 7726 + { PseudoVSLIDEDOWN_VI_M8_MASK, VSLIDEDOWN_VI, 0x3, 0x0 }, // 7727 + { PseudoVSLIDEDOWN_VI_MF8, VSLIDEDOWN_VI, 0x5, 0x0 }, // 7728 + { PseudoVSLIDEDOWN_VI_MF8_MASK, VSLIDEDOWN_VI, 0x5, 0x0 }, // 7729 + { PseudoVSLIDEDOWN_VI_MF4, VSLIDEDOWN_VI, 0x6, 0x0 }, // 7730 + { PseudoVSLIDEDOWN_VI_MF4_MASK, VSLIDEDOWN_VI, 0x6, 0x0 }, // 7731 + { PseudoVSLIDEDOWN_VI_MF2, VSLIDEDOWN_VI, 0x7, 0x0 }, // 7732 + { PseudoVSLIDEDOWN_VI_MF2_MASK, VSLIDEDOWN_VI, 0x7, 0x0 }, // 7733 + { PseudoVSLIDEDOWN_VX_M1, VSLIDEDOWN_VX, 0x0, 0x0 }, // 7734 + { PseudoVSLIDEDOWN_VX_M1_MASK, VSLIDEDOWN_VX, 0x0, 0x0 }, // 7735 + { PseudoVSLIDEDOWN_VX_M2, VSLIDEDOWN_VX, 0x1, 0x0 }, // 7736 + { PseudoVSLIDEDOWN_VX_M2_MASK, VSLIDEDOWN_VX, 0x1, 0x0 }, // 7737 + { PseudoVSLIDEDOWN_VX_M4, VSLIDEDOWN_VX, 0x2, 0x0 }, // 7738 + { PseudoVSLIDEDOWN_VX_M4_MASK, VSLIDEDOWN_VX, 0x2, 0x0 }, // 7739 + { PseudoVSLIDEDOWN_VX_M8, VSLIDEDOWN_VX, 0x3, 0x0 }, // 7740 + { PseudoVSLIDEDOWN_VX_M8_MASK, VSLIDEDOWN_VX, 0x3, 0x0 }, // 7741 + { PseudoVSLIDEDOWN_VX_MF8, VSLIDEDOWN_VX, 0x5, 0x0 }, // 7742 + { PseudoVSLIDEDOWN_VX_MF8_MASK, VSLIDEDOWN_VX, 0x5, 0x0 }, // 7743 + { PseudoVSLIDEDOWN_VX_MF4, VSLIDEDOWN_VX, 0x6, 0x0 }, // 7744 + { PseudoVSLIDEDOWN_VX_MF4_MASK, VSLIDEDOWN_VX, 0x6, 0x0 }, // 7745 + { PseudoVSLIDEDOWN_VX_MF2, VSLIDEDOWN_VX, 0x7, 0x0 }, // 7746 + { PseudoVSLIDEDOWN_VX_MF2_MASK, VSLIDEDOWN_VX, 0x7, 0x0 }, // 7747 + { PseudoVSLIDEUP_VI_M1, VSLIDEUP_VI, 0x0, 0x0 }, // 7748 + { PseudoVSLIDEUP_VI_M1_MASK, VSLIDEUP_VI, 0x0, 0x0 }, // 7749 + { PseudoVSLIDEUP_VI_M2, VSLIDEUP_VI, 0x1, 0x0 }, // 7750 + { PseudoVSLIDEUP_VI_M2_MASK, VSLIDEUP_VI, 0x1, 0x0 }, // 7751 + { PseudoVSLIDEUP_VI_M4, VSLIDEUP_VI, 0x2, 0x0 }, // 7752 + { PseudoVSLIDEUP_VI_M4_MASK, VSLIDEUP_VI, 0x2, 0x0 }, // 7753 + { PseudoVSLIDEUP_VI_M8, VSLIDEUP_VI, 0x3, 0x0 }, // 7754 + { PseudoVSLIDEUP_VI_M8_MASK, VSLIDEUP_VI, 0x3, 0x0 }, // 7755 + { PseudoVSLIDEUP_VI_MF8, VSLIDEUP_VI, 0x5, 0x0 }, // 7756 + { PseudoVSLIDEUP_VI_MF8_MASK, VSLIDEUP_VI, 0x5, 0x0 }, // 7757 + { PseudoVSLIDEUP_VI_MF4, VSLIDEUP_VI, 0x6, 0x0 }, // 7758 + { PseudoVSLIDEUP_VI_MF4_MASK, VSLIDEUP_VI, 0x6, 0x0 }, // 7759 + { PseudoVSLIDEUP_VI_MF2, VSLIDEUP_VI, 0x7, 0x0 }, // 7760 + { PseudoVSLIDEUP_VI_MF2_MASK, VSLIDEUP_VI, 0x7, 0x0 }, // 7761 + { PseudoVSLIDEUP_VX_M1, VSLIDEUP_VX, 0x0, 0x0 }, // 7762 + { PseudoVSLIDEUP_VX_M1_MASK, VSLIDEUP_VX, 0x0, 0x0 }, // 7763 + { PseudoVSLIDEUP_VX_M2, VSLIDEUP_VX, 0x1, 0x0 }, // 7764 + { PseudoVSLIDEUP_VX_M2_MASK, VSLIDEUP_VX, 0x1, 0x0 }, // 7765 + { PseudoVSLIDEUP_VX_M4, VSLIDEUP_VX, 0x2, 0x0 }, // 7766 + { PseudoVSLIDEUP_VX_M4_MASK, VSLIDEUP_VX, 0x2, 0x0 }, // 7767 + { PseudoVSLIDEUP_VX_M8, VSLIDEUP_VX, 0x3, 0x0 }, // 7768 + { PseudoVSLIDEUP_VX_M8_MASK, VSLIDEUP_VX, 0x3, 0x0 }, // 7769 + { PseudoVSLIDEUP_VX_MF8, VSLIDEUP_VX, 0x5, 0x0 }, // 7770 + { PseudoVSLIDEUP_VX_MF8_MASK, VSLIDEUP_VX, 0x5, 0x0 }, // 7771 + { PseudoVSLIDEUP_VX_MF4, VSLIDEUP_VX, 0x6, 0x0 }, // 7772 + { PseudoVSLIDEUP_VX_MF4_MASK, VSLIDEUP_VX, 0x6, 0x0 }, // 7773 + { PseudoVSLIDEUP_VX_MF2, VSLIDEUP_VX, 0x7, 0x0 }, // 7774 + { PseudoVSLIDEUP_VX_MF2_MASK, VSLIDEUP_VX, 0x7, 0x0 }, // 7775 + { PseudoVSLL_VI_M1, VSLL_VI, 0x0, 0x0 }, // 7776 + { PseudoVSLL_VI_M1_MASK, VSLL_VI, 0x0, 0x0 }, // 7777 + { PseudoVSLL_VI_M2, VSLL_VI, 0x1, 0x0 }, // 7778 + { PseudoVSLL_VI_M2_MASK, VSLL_VI, 0x1, 0x0 }, // 7779 + { PseudoVSLL_VI_M4, VSLL_VI, 0x2, 0x0 }, // 7780 + { PseudoVSLL_VI_M4_MASK, VSLL_VI, 0x2, 0x0 }, // 7781 + { PseudoVSLL_VI_M8, VSLL_VI, 0x3, 0x0 }, // 7782 + { PseudoVSLL_VI_M8_MASK, VSLL_VI, 0x3, 0x0 }, // 7783 + { PseudoVSLL_VI_MF8, VSLL_VI, 0x5, 0x0 }, // 7784 + { PseudoVSLL_VI_MF8_MASK, VSLL_VI, 0x5, 0x0 }, // 7785 + { PseudoVSLL_VI_MF4, VSLL_VI, 0x6, 0x0 }, // 7786 + { PseudoVSLL_VI_MF4_MASK, VSLL_VI, 0x6, 0x0 }, // 7787 + { PseudoVSLL_VI_MF2, VSLL_VI, 0x7, 0x0 }, // 7788 + { PseudoVSLL_VI_MF2_MASK, VSLL_VI, 0x7, 0x0 }, // 7789 + { PseudoVSLL_VV_M1, VSLL_VV, 0x0, 0x0 }, // 7790 + { PseudoVSLL_VV_M1_MASK, VSLL_VV, 0x0, 0x0 }, // 7791 + { PseudoVSLL_VV_M2, VSLL_VV, 0x1, 0x0 }, // 7792 + { PseudoVSLL_VV_M2_MASK, VSLL_VV, 0x1, 0x0 }, // 7793 + { PseudoVSLL_VV_M4, VSLL_VV, 0x2, 0x0 }, // 7794 + { PseudoVSLL_VV_M4_MASK, VSLL_VV, 0x2, 0x0 }, // 7795 + { PseudoVSLL_VV_M8, VSLL_VV, 0x3, 0x0 }, // 7796 + { PseudoVSLL_VV_M8_MASK, VSLL_VV, 0x3, 0x0 }, // 7797 + { PseudoVSLL_VV_MF8, VSLL_VV, 0x5, 0x0 }, // 7798 + { PseudoVSLL_VV_MF8_MASK, VSLL_VV, 0x5, 0x0 }, // 7799 + { PseudoVSLL_VV_MF4, VSLL_VV, 0x6, 0x0 }, // 7800 + { PseudoVSLL_VV_MF4_MASK, VSLL_VV, 0x6, 0x0 }, // 7801 + { PseudoVSLL_VV_MF2, VSLL_VV, 0x7, 0x0 }, // 7802 + { PseudoVSLL_VV_MF2_MASK, VSLL_VV, 0x7, 0x0 }, // 7803 + { PseudoVSLL_VX_M1, VSLL_VX, 0x0, 0x0 }, // 7804 + { PseudoVSLL_VX_M1_MASK, VSLL_VX, 0x0, 0x0 }, // 7805 + { PseudoVSLL_VX_M2, VSLL_VX, 0x1, 0x0 }, // 7806 + { PseudoVSLL_VX_M2_MASK, VSLL_VX, 0x1, 0x0 }, // 7807 + { PseudoVSLL_VX_M4, VSLL_VX, 0x2, 0x0 }, // 7808 + { PseudoVSLL_VX_M4_MASK, VSLL_VX, 0x2, 0x0 }, // 7809 + { PseudoVSLL_VX_M8, VSLL_VX, 0x3, 0x0 }, // 7810 + { PseudoVSLL_VX_M8_MASK, VSLL_VX, 0x3, 0x0 }, // 7811 + { PseudoVSLL_VX_MF8, VSLL_VX, 0x5, 0x0 }, // 7812 + { PseudoVSLL_VX_MF8_MASK, VSLL_VX, 0x5, 0x0 }, // 7813 + { PseudoVSLL_VX_MF4, VSLL_VX, 0x6, 0x0 }, // 7814 + { PseudoVSLL_VX_MF4_MASK, VSLL_VX, 0x6, 0x0 }, // 7815 + { PseudoVSLL_VX_MF2, VSLL_VX, 0x7, 0x0 }, // 7816 + { PseudoVSLL_VX_MF2_MASK, VSLL_VX, 0x7, 0x0 }, // 7817 + { PseudoVSM3C_VI_M1, VSM3C_VI, 0x0, 0x0 }, // 7818 + { PseudoVSM3C_VI_M2, VSM3C_VI, 0x1, 0x0 }, // 7819 + { PseudoVSM3C_VI_M4, VSM3C_VI, 0x2, 0x0 }, // 7820 + { PseudoVSM3C_VI_M8, VSM3C_VI, 0x3, 0x0 }, // 7821 + { PseudoVSM3C_VI_MF2, VSM3C_VI, 0x7, 0x0 }, // 7822 + { PseudoVSM3ME_VV_M1, VSM3ME_VV, 0x0, 0x0 }, // 7823 + { PseudoVSM3ME_VV_M2, VSM3ME_VV, 0x1, 0x0 }, // 7824 + { PseudoVSM3ME_VV_M4, VSM3ME_VV, 0x2, 0x0 }, // 7825 + { PseudoVSM3ME_VV_M8, VSM3ME_VV, 0x3, 0x0 }, // 7826 + { PseudoVSM3ME_VV_MF2, VSM3ME_VV, 0x7, 0x0 }, // 7827 + { PseudoVSM4K_VI_M1, VSM4K_VI, 0x0, 0x0 }, // 7828 + { PseudoVSM4K_VI_M2, VSM4K_VI, 0x1, 0x0 }, // 7829 + { PseudoVSM4K_VI_M4, VSM4K_VI, 0x2, 0x0 }, // 7830 + { PseudoVSM4K_VI_M8, VSM4K_VI, 0x3, 0x0 }, // 7831 + { PseudoVSM4K_VI_MF2, VSM4K_VI, 0x7, 0x0 }, // 7832 + { PseudoVSM4R_VS_M1_M1, VSM4R_VS, 0x0, 0x0 }, // 7833 + { PseudoVSM4R_VS_M1_MF2, VSM4R_VS, 0x0, 0x0 }, // 7834 + { PseudoVSM4R_VS_M1_MF4, VSM4R_VS, 0x0, 0x0 }, // 7835 + { PseudoVSM4R_VS_M1_MF8, VSM4R_VS, 0x0, 0x0 }, // 7836 + { PseudoVSM4R_VS_M2_M1, VSM4R_VS, 0x1, 0x0 }, // 7837 + { PseudoVSM4R_VS_M2_M2, VSM4R_VS, 0x1, 0x0 }, // 7838 + { PseudoVSM4R_VS_M2_MF2, VSM4R_VS, 0x1, 0x0 }, // 7839 + { PseudoVSM4R_VS_M2_MF4, VSM4R_VS, 0x1, 0x0 }, // 7840 + { PseudoVSM4R_VS_M2_MF8, VSM4R_VS, 0x1, 0x0 }, // 7841 + { PseudoVSM4R_VS_M4_M1, VSM4R_VS, 0x2, 0x0 }, // 7842 + { PseudoVSM4R_VS_M4_M2, VSM4R_VS, 0x2, 0x0 }, // 7843 + { PseudoVSM4R_VS_M4_M4, VSM4R_VS, 0x2, 0x0 }, // 7844 + { PseudoVSM4R_VS_M4_MF2, VSM4R_VS, 0x2, 0x0 }, // 7845 + { PseudoVSM4R_VS_M4_MF4, VSM4R_VS, 0x2, 0x0 }, // 7846 + { PseudoVSM4R_VS_M4_MF8, VSM4R_VS, 0x2, 0x0 }, // 7847 + { PseudoVSM4R_VS_M8_M1, VSM4R_VS, 0x3, 0x0 }, // 7848 + { PseudoVSM4R_VS_M8_M2, VSM4R_VS, 0x3, 0x0 }, // 7849 + { PseudoVSM4R_VS_M8_M4, VSM4R_VS, 0x3, 0x0 }, // 7850 + { PseudoVSM4R_VS_M8_MF2, VSM4R_VS, 0x3, 0x0 }, // 7851 + { PseudoVSM4R_VS_M8_MF4, VSM4R_VS, 0x3, 0x0 }, // 7852 + { PseudoVSM4R_VS_M8_MF8, VSM4R_VS, 0x3, 0x0 }, // 7853 + { PseudoVSM4R_VS_MF2_MF2, VSM4R_VS, 0x7, 0x0 }, // 7854 + { PseudoVSM4R_VS_MF2_MF4, VSM4R_VS, 0x7, 0x0 }, // 7855 + { PseudoVSM4R_VS_MF2_MF8, VSM4R_VS, 0x7, 0x0 }, // 7856 + { PseudoVSM4R_VV_M1, VSM4R_VV, 0x0, 0x0 }, // 7857 + { PseudoVSM4R_VV_M2, VSM4R_VV, 0x1, 0x0 }, // 7858 + { PseudoVSM4R_VV_M4, VSM4R_VV, 0x2, 0x0 }, // 7859 + { PseudoVSM4R_VV_M8, VSM4R_VV, 0x3, 0x0 }, // 7860 + { PseudoVSM4R_VV_MF2, VSM4R_VV, 0x7, 0x0 }, // 7861 + { PseudoVSMUL_VV_M1, VSMUL_VV, 0x0, 0x0 }, // 7862 + { PseudoVSMUL_VV_M1_MASK, VSMUL_VV, 0x0, 0x0 }, // 7863 + { PseudoVSMUL_VV_M2, VSMUL_VV, 0x1, 0x0 }, // 7864 + { PseudoVSMUL_VV_M2_MASK, VSMUL_VV, 0x1, 0x0 }, // 7865 + { PseudoVSMUL_VV_M4, VSMUL_VV, 0x2, 0x0 }, // 7866 + { PseudoVSMUL_VV_M4_MASK, VSMUL_VV, 0x2, 0x0 }, // 7867 + { PseudoVSMUL_VV_M8, VSMUL_VV, 0x3, 0x0 }, // 7868 + { PseudoVSMUL_VV_M8_MASK, VSMUL_VV, 0x3, 0x0 }, // 7869 + { PseudoVSMUL_VV_MF8, VSMUL_VV, 0x5, 0x0 }, // 7870 + { PseudoVSMUL_VV_MF8_MASK, VSMUL_VV, 0x5, 0x0 }, // 7871 + { PseudoVSMUL_VV_MF4, VSMUL_VV, 0x6, 0x0 }, // 7872 + { PseudoVSMUL_VV_MF4_MASK, VSMUL_VV, 0x6, 0x0 }, // 7873 + { PseudoVSMUL_VV_MF2, VSMUL_VV, 0x7, 0x0 }, // 7874 + { PseudoVSMUL_VV_MF2_MASK, VSMUL_VV, 0x7, 0x0 }, // 7875 + { PseudoVSMUL_VX_M1, VSMUL_VX, 0x0, 0x0 }, // 7876 + { PseudoVSMUL_VX_M1_MASK, VSMUL_VX, 0x0, 0x0 }, // 7877 + { PseudoVSMUL_VX_M2, VSMUL_VX, 0x1, 0x0 }, // 7878 + { PseudoVSMUL_VX_M2_MASK, VSMUL_VX, 0x1, 0x0 }, // 7879 + { PseudoVSMUL_VX_M4, VSMUL_VX, 0x2, 0x0 }, // 7880 + { PseudoVSMUL_VX_M4_MASK, VSMUL_VX, 0x2, 0x0 }, // 7881 + { PseudoVSMUL_VX_M8, VSMUL_VX, 0x3, 0x0 }, // 7882 + { PseudoVSMUL_VX_M8_MASK, VSMUL_VX, 0x3, 0x0 }, // 7883 + { PseudoVSMUL_VX_MF8, VSMUL_VX, 0x5, 0x0 }, // 7884 + { PseudoVSMUL_VX_MF8_MASK, VSMUL_VX, 0x5, 0x0 }, // 7885 + { PseudoVSMUL_VX_MF4, VSMUL_VX, 0x6, 0x0 }, // 7886 + { PseudoVSMUL_VX_MF4_MASK, VSMUL_VX, 0x6, 0x0 }, // 7887 + { PseudoVSMUL_VX_MF2, VSMUL_VX, 0x7, 0x0 }, // 7888 + { PseudoVSMUL_VX_MF2_MASK, VSMUL_VX, 0x7, 0x0 }, // 7889 + { PseudoVSM_V_B8, VSM_V, 0x0, 0x0 }, // 7890 + { PseudoVSM_V_B16, VSM_V, 0x1, 0x0 }, // 7891 + { PseudoVSM_V_B32, VSM_V, 0x2, 0x0 }, // 7892 + { PseudoVSM_V_B64, VSM_V, 0x3, 0x0 }, // 7893 + { PseudoVSM_V_B1, VSM_V, 0x5, 0x0 }, // 7894 + { PseudoVSM_V_B2, VSM_V, 0x6, 0x0 }, // 7895 + { PseudoVSM_V_B4, VSM_V, 0x7, 0x0 }, // 7896 + { PseudoVSOXEI16_V_M1_M1, VSOXEI16_V, 0x0, 0x0 }, // 7897 + { PseudoVSOXEI16_V_M1_M1_MASK, VSOXEI16_V, 0x0, 0x0 }, // 7898 + { PseudoVSOXEI16_V_M2_M1, VSOXEI16_V, 0x0, 0x0 }, // 7899 + { PseudoVSOXEI16_V_M2_M1_MASK, VSOXEI16_V, 0x0, 0x0 }, // 7900 + { PseudoVSOXEI16_V_MF2_M1, VSOXEI16_V, 0x0, 0x0 }, // 7901 + { PseudoVSOXEI16_V_MF2_M1_MASK, VSOXEI16_V, 0x0, 0x0 }, // 7902 + { PseudoVSOXEI16_V_MF4_M1, VSOXEI16_V, 0x0, 0x0 }, // 7903 + { PseudoVSOXEI16_V_MF4_M1_MASK, VSOXEI16_V, 0x0, 0x0 }, // 7904 + { PseudoVSOXEI16_V_M1_M2, VSOXEI16_V, 0x1, 0x0 }, // 7905 + { PseudoVSOXEI16_V_M1_M2_MASK, VSOXEI16_V, 0x1, 0x0 }, // 7906 + { PseudoVSOXEI16_V_M2_M2, VSOXEI16_V, 0x1, 0x0 }, // 7907 + { PseudoVSOXEI16_V_M2_M2_MASK, VSOXEI16_V, 0x1, 0x0 }, // 7908 + { PseudoVSOXEI16_V_M4_M2, VSOXEI16_V, 0x1, 0x0 }, // 7909 + { PseudoVSOXEI16_V_M4_M2_MASK, VSOXEI16_V, 0x1, 0x0 }, // 7910 + { PseudoVSOXEI16_V_MF2_M2, VSOXEI16_V, 0x1, 0x0 }, // 7911 + { PseudoVSOXEI16_V_MF2_M2_MASK, VSOXEI16_V, 0x1, 0x0 }, // 7912 + { PseudoVSOXEI16_V_M1_M4, VSOXEI16_V, 0x2, 0x0 }, // 7913 + { PseudoVSOXEI16_V_M1_M4_MASK, VSOXEI16_V, 0x2, 0x0 }, // 7914 + { PseudoVSOXEI16_V_M2_M4, VSOXEI16_V, 0x2, 0x0 }, // 7915 + { PseudoVSOXEI16_V_M2_M4_MASK, VSOXEI16_V, 0x2, 0x0 }, // 7916 + { PseudoVSOXEI16_V_M4_M4, VSOXEI16_V, 0x2, 0x0 }, // 7917 + { PseudoVSOXEI16_V_M4_M4_MASK, VSOXEI16_V, 0x2, 0x0 }, // 7918 + { PseudoVSOXEI16_V_M8_M4, VSOXEI16_V, 0x2, 0x0 }, // 7919 + { PseudoVSOXEI16_V_M8_M4_MASK, VSOXEI16_V, 0x2, 0x0 }, // 7920 + { PseudoVSOXEI16_V_M2_M8, VSOXEI16_V, 0x3, 0x0 }, // 7921 + { PseudoVSOXEI16_V_M2_M8_MASK, VSOXEI16_V, 0x3, 0x0 }, // 7922 + { PseudoVSOXEI16_V_M4_M8, VSOXEI16_V, 0x3, 0x0 }, // 7923 + { PseudoVSOXEI16_V_M4_M8_MASK, VSOXEI16_V, 0x3, 0x0 }, // 7924 + { PseudoVSOXEI16_V_M8_M8, VSOXEI16_V, 0x3, 0x0 }, // 7925 + { PseudoVSOXEI16_V_M8_M8_MASK, VSOXEI16_V, 0x3, 0x0 }, // 7926 + { PseudoVSOXEI16_V_MF4_MF8, VSOXEI16_V, 0x5, 0x0 }, // 7927 + { PseudoVSOXEI16_V_MF4_MF8_MASK, VSOXEI16_V, 0x5, 0x0 }, // 7928 + { PseudoVSOXEI16_V_MF2_MF4, VSOXEI16_V, 0x6, 0x0 }, // 7929 + { PseudoVSOXEI16_V_MF2_MF4_MASK, VSOXEI16_V, 0x6, 0x0 }, // 7930 + { PseudoVSOXEI16_V_MF4_MF4, VSOXEI16_V, 0x6, 0x0 }, // 7931 + { PseudoVSOXEI16_V_MF4_MF4_MASK, VSOXEI16_V, 0x6, 0x0 }, // 7932 + { PseudoVSOXEI16_V_M1_MF2, VSOXEI16_V, 0x7, 0x0 }, // 7933 + { PseudoVSOXEI16_V_M1_MF2_MASK, VSOXEI16_V, 0x7, 0x0 }, // 7934 + { PseudoVSOXEI16_V_MF2_MF2, VSOXEI16_V, 0x7, 0x0 }, // 7935 + { PseudoVSOXEI16_V_MF2_MF2_MASK, VSOXEI16_V, 0x7, 0x0 }, // 7936 + { PseudoVSOXEI16_V_MF4_MF2, VSOXEI16_V, 0x7, 0x0 }, // 7937 + { PseudoVSOXEI16_V_MF4_MF2_MASK, VSOXEI16_V, 0x7, 0x0 }, // 7938 + { PseudoVSOXEI32_V_M1_M1, VSOXEI32_V, 0x0, 0x0 }, // 7939 + { PseudoVSOXEI32_V_M1_M1_MASK, VSOXEI32_V, 0x0, 0x0 }, // 7940 + { PseudoVSOXEI32_V_M2_M1, VSOXEI32_V, 0x0, 0x0 }, // 7941 + { PseudoVSOXEI32_V_M2_M1_MASK, VSOXEI32_V, 0x0, 0x0 }, // 7942 + { PseudoVSOXEI32_V_M4_M1, VSOXEI32_V, 0x0, 0x0 }, // 7943 + { PseudoVSOXEI32_V_M4_M1_MASK, VSOXEI32_V, 0x0, 0x0 }, // 7944 + { PseudoVSOXEI32_V_MF2_M1, VSOXEI32_V, 0x0, 0x0 }, // 7945 + { PseudoVSOXEI32_V_MF2_M1_MASK, VSOXEI32_V, 0x0, 0x0 }, // 7946 + { PseudoVSOXEI32_V_M1_M2, VSOXEI32_V, 0x1, 0x0 }, // 7947 + { PseudoVSOXEI32_V_M1_M2_MASK, VSOXEI32_V, 0x1, 0x0 }, // 7948 + { PseudoVSOXEI32_V_M2_M2, VSOXEI32_V, 0x1, 0x0 }, // 7949 + { PseudoVSOXEI32_V_M2_M2_MASK, VSOXEI32_V, 0x1, 0x0 }, // 7950 + { PseudoVSOXEI32_V_M4_M2, VSOXEI32_V, 0x1, 0x0 }, // 7951 + { PseudoVSOXEI32_V_M4_M2_MASK, VSOXEI32_V, 0x1, 0x0 }, // 7952 + { PseudoVSOXEI32_V_M8_M2, VSOXEI32_V, 0x1, 0x0 }, // 7953 + { PseudoVSOXEI32_V_M8_M2_MASK, VSOXEI32_V, 0x1, 0x0 }, // 7954 + { PseudoVSOXEI32_V_M2_M4, VSOXEI32_V, 0x2, 0x0 }, // 7955 + { PseudoVSOXEI32_V_M2_M4_MASK, VSOXEI32_V, 0x2, 0x0 }, // 7956 + { PseudoVSOXEI32_V_M4_M4, VSOXEI32_V, 0x2, 0x0 }, // 7957 + { PseudoVSOXEI32_V_M4_M4_MASK, VSOXEI32_V, 0x2, 0x0 }, // 7958 + { PseudoVSOXEI32_V_M8_M4, VSOXEI32_V, 0x2, 0x0 }, // 7959 + { PseudoVSOXEI32_V_M8_M4_MASK, VSOXEI32_V, 0x2, 0x0 }, // 7960 + { PseudoVSOXEI32_V_M4_M8, VSOXEI32_V, 0x3, 0x0 }, // 7961 + { PseudoVSOXEI32_V_M4_M8_MASK, VSOXEI32_V, 0x3, 0x0 }, // 7962 + { PseudoVSOXEI32_V_M8_M8, VSOXEI32_V, 0x3, 0x0 }, // 7963 + { PseudoVSOXEI32_V_M8_M8_MASK, VSOXEI32_V, 0x3, 0x0 }, // 7964 + { PseudoVSOXEI32_V_MF2_MF8, VSOXEI32_V, 0x5, 0x0 }, // 7965 + { PseudoVSOXEI32_V_MF2_MF8_MASK, VSOXEI32_V, 0x5, 0x0 }, // 7966 + { PseudoVSOXEI32_V_M1_MF4, VSOXEI32_V, 0x6, 0x0 }, // 7967 + { PseudoVSOXEI32_V_M1_MF4_MASK, VSOXEI32_V, 0x6, 0x0 }, // 7968 + { PseudoVSOXEI32_V_MF2_MF4, VSOXEI32_V, 0x6, 0x0 }, // 7969 + { PseudoVSOXEI32_V_MF2_MF4_MASK, VSOXEI32_V, 0x6, 0x0 }, // 7970 + { PseudoVSOXEI32_V_M1_MF2, VSOXEI32_V, 0x7, 0x0 }, // 7971 + { PseudoVSOXEI32_V_M1_MF2_MASK, VSOXEI32_V, 0x7, 0x0 }, // 7972 + { PseudoVSOXEI32_V_M2_MF2, VSOXEI32_V, 0x7, 0x0 }, // 7973 + { PseudoVSOXEI32_V_M2_MF2_MASK, VSOXEI32_V, 0x7, 0x0 }, // 7974 + { PseudoVSOXEI32_V_MF2_MF2, VSOXEI32_V, 0x7, 0x0 }, // 7975 + { PseudoVSOXEI32_V_MF2_MF2_MASK, VSOXEI32_V, 0x7, 0x0 }, // 7976 + { PseudoVSOXEI64_V_M1_M1, VSOXEI64_V, 0x0, 0x0 }, // 7977 + { PseudoVSOXEI64_V_M1_M1_MASK, VSOXEI64_V, 0x0, 0x0 }, // 7978 + { PseudoVSOXEI64_V_M2_M1, VSOXEI64_V, 0x0, 0x0 }, // 7979 + { PseudoVSOXEI64_V_M2_M1_MASK, VSOXEI64_V, 0x0, 0x0 }, // 7980 + { PseudoVSOXEI64_V_M4_M1, VSOXEI64_V, 0x0, 0x0 }, // 7981 + { PseudoVSOXEI64_V_M4_M1_MASK, VSOXEI64_V, 0x0, 0x0 }, // 7982 + { PseudoVSOXEI64_V_M8_M1, VSOXEI64_V, 0x0, 0x0 }, // 7983 + { PseudoVSOXEI64_V_M8_M1_MASK, VSOXEI64_V, 0x0, 0x0 }, // 7984 + { PseudoVSOXEI64_V_M2_M2, VSOXEI64_V, 0x1, 0x0 }, // 7985 + { PseudoVSOXEI64_V_M2_M2_MASK, VSOXEI64_V, 0x1, 0x0 }, // 7986 + { PseudoVSOXEI64_V_M4_M2, VSOXEI64_V, 0x1, 0x0 }, // 7987 + { PseudoVSOXEI64_V_M4_M2_MASK, VSOXEI64_V, 0x1, 0x0 }, // 7988 + { PseudoVSOXEI64_V_M8_M2, VSOXEI64_V, 0x1, 0x0 }, // 7989 + { PseudoVSOXEI64_V_M8_M2_MASK, VSOXEI64_V, 0x1, 0x0 }, // 7990 + { PseudoVSOXEI64_V_M4_M4, VSOXEI64_V, 0x2, 0x0 }, // 7991 + { PseudoVSOXEI64_V_M4_M4_MASK, VSOXEI64_V, 0x2, 0x0 }, // 7992 + { PseudoVSOXEI64_V_M8_M4, VSOXEI64_V, 0x2, 0x0 }, // 7993 + { PseudoVSOXEI64_V_M8_M4_MASK, VSOXEI64_V, 0x2, 0x0 }, // 7994 + { PseudoVSOXEI64_V_M8_M8, VSOXEI64_V, 0x3, 0x0 }, // 7995 + { PseudoVSOXEI64_V_M8_M8_MASK, VSOXEI64_V, 0x3, 0x0 }, // 7996 + { PseudoVSOXEI64_V_M1_MF8, VSOXEI64_V, 0x5, 0x0 }, // 7997 + { PseudoVSOXEI64_V_M1_MF8_MASK, VSOXEI64_V, 0x5, 0x0 }, // 7998 + { PseudoVSOXEI64_V_M1_MF4, VSOXEI64_V, 0x6, 0x0 }, // 7999 + { PseudoVSOXEI64_V_M1_MF4_MASK, VSOXEI64_V, 0x6, 0x0 }, // 8000 + { PseudoVSOXEI64_V_M2_MF4, VSOXEI64_V, 0x6, 0x0 }, // 8001 + { PseudoVSOXEI64_V_M2_MF4_MASK, VSOXEI64_V, 0x6, 0x0 }, // 8002 + { PseudoVSOXEI64_V_M1_MF2, VSOXEI64_V, 0x7, 0x0 }, // 8003 + { PseudoVSOXEI64_V_M1_MF2_MASK, VSOXEI64_V, 0x7, 0x0 }, // 8004 + { PseudoVSOXEI64_V_M2_MF2, VSOXEI64_V, 0x7, 0x0 }, // 8005 + { PseudoVSOXEI64_V_M2_MF2_MASK, VSOXEI64_V, 0x7, 0x0 }, // 8006 + { PseudoVSOXEI64_V_M4_MF2, VSOXEI64_V, 0x7, 0x0 }, // 8007 + { PseudoVSOXEI64_V_M4_MF2_MASK, VSOXEI64_V, 0x7, 0x0 }, // 8008 + { PseudoVSOXEI8_V_M1_M1, VSOXEI8_V, 0x0, 0x0 }, // 8009 + { PseudoVSOXEI8_V_M1_M1_MASK, VSOXEI8_V, 0x0, 0x0 }, // 8010 + { PseudoVSOXEI8_V_MF2_M1, VSOXEI8_V, 0x0, 0x0 }, // 8011 + { PseudoVSOXEI8_V_MF2_M1_MASK, VSOXEI8_V, 0x0, 0x0 }, // 8012 + { PseudoVSOXEI8_V_MF4_M1, VSOXEI8_V, 0x0, 0x0 }, // 8013 + { PseudoVSOXEI8_V_MF4_M1_MASK, VSOXEI8_V, 0x0, 0x0 }, // 8014 + { PseudoVSOXEI8_V_MF8_M1, VSOXEI8_V, 0x0, 0x0 }, // 8015 + { PseudoVSOXEI8_V_MF8_M1_MASK, VSOXEI8_V, 0x0, 0x0 }, // 8016 + { PseudoVSOXEI8_V_M1_M2, VSOXEI8_V, 0x1, 0x0 }, // 8017 + { PseudoVSOXEI8_V_M1_M2_MASK, VSOXEI8_V, 0x1, 0x0 }, // 8018 + { PseudoVSOXEI8_V_M2_M2, VSOXEI8_V, 0x1, 0x0 }, // 8019 + { PseudoVSOXEI8_V_M2_M2_MASK, VSOXEI8_V, 0x1, 0x0 }, // 8020 + { PseudoVSOXEI8_V_MF2_M2, VSOXEI8_V, 0x1, 0x0 }, // 8021 + { PseudoVSOXEI8_V_MF2_M2_MASK, VSOXEI8_V, 0x1, 0x0 }, // 8022 + { PseudoVSOXEI8_V_MF4_M2, VSOXEI8_V, 0x1, 0x0 }, // 8023 + { PseudoVSOXEI8_V_MF4_M2_MASK, VSOXEI8_V, 0x1, 0x0 }, // 8024 + { PseudoVSOXEI8_V_M1_M4, VSOXEI8_V, 0x2, 0x0 }, // 8025 + { PseudoVSOXEI8_V_M1_M4_MASK, VSOXEI8_V, 0x2, 0x0 }, // 8026 + { PseudoVSOXEI8_V_M2_M4, VSOXEI8_V, 0x2, 0x0 }, // 8027 + { PseudoVSOXEI8_V_M2_M4_MASK, VSOXEI8_V, 0x2, 0x0 }, // 8028 + { PseudoVSOXEI8_V_M4_M4, VSOXEI8_V, 0x2, 0x0 }, // 8029 + { PseudoVSOXEI8_V_M4_M4_MASK, VSOXEI8_V, 0x2, 0x0 }, // 8030 + { PseudoVSOXEI8_V_MF2_M4, VSOXEI8_V, 0x2, 0x0 }, // 8031 + { PseudoVSOXEI8_V_MF2_M4_MASK, VSOXEI8_V, 0x2, 0x0 }, // 8032 + { PseudoVSOXEI8_V_M1_M8, VSOXEI8_V, 0x3, 0x0 }, // 8033 + { PseudoVSOXEI8_V_M1_M8_MASK, VSOXEI8_V, 0x3, 0x0 }, // 8034 + { PseudoVSOXEI8_V_M2_M8, VSOXEI8_V, 0x3, 0x0 }, // 8035 + { PseudoVSOXEI8_V_M2_M8_MASK, VSOXEI8_V, 0x3, 0x0 }, // 8036 + { PseudoVSOXEI8_V_M4_M8, VSOXEI8_V, 0x3, 0x0 }, // 8037 + { PseudoVSOXEI8_V_M4_M8_MASK, VSOXEI8_V, 0x3, 0x0 }, // 8038 + { PseudoVSOXEI8_V_M8_M8, VSOXEI8_V, 0x3, 0x0 }, // 8039 + { PseudoVSOXEI8_V_M8_M8_MASK, VSOXEI8_V, 0x3, 0x0 }, // 8040 + { PseudoVSOXEI8_V_MF8_MF8, VSOXEI8_V, 0x5, 0x0 }, // 8041 + { PseudoVSOXEI8_V_MF8_MF8_MASK, VSOXEI8_V, 0x5, 0x0 }, // 8042 + { PseudoVSOXEI8_V_MF4_MF4, VSOXEI8_V, 0x6, 0x0 }, // 8043 + { PseudoVSOXEI8_V_MF4_MF4_MASK, VSOXEI8_V, 0x6, 0x0 }, // 8044 + { PseudoVSOXEI8_V_MF8_MF4, VSOXEI8_V, 0x6, 0x0 }, // 8045 + { PseudoVSOXEI8_V_MF8_MF4_MASK, VSOXEI8_V, 0x6, 0x0 }, // 8046 + { PseudoVSOXEI8_V_MF2_MF2, VSOXEI8_V, 0x7, 0x0 }, // 8047 + { PseudoVSOXEI8_V_MF2_MF2_MASK, VSOXEI8_V, 0x7, 0x0 }, // 8048 + { PseudoVSOXEI8_V_MF4_MF2, VSOXEI8_V, 0x7, 0x0 }, // 8049 + { PseudoVSOXEI8_V_MF4_MF2_MASK, VSOXEI8_V, 0x7, 0x0 }, // 8050 + { PseudoVSOXEI8_V_MF8_MF2, VSOXEI8_V, 0x7, 0x0 }, // 8051 + { PseudoVSOXEI8_V_MF8_MF2_MASK, VSOXEI8_V, 0x7, 0x0 }, // 8052 + { PseudoVSOXSEG2EI16_V_M1_M1, VSOXSEG2EI16_V, 0x0, 0x0 }, // 8053 + { PseudoVSOXSEG2EI16_V_M1_M1_MASK, VSOXSEG2EI16_V, 0x0, 0x0 }, // 8054 + { PseudoVSOXSEG2EI16_V_M2_M1, VSOXSEG2EI16_V, 0x0, 0x0 }, // 8055 + { PseudoVSOXSEG2EI16_V_M2_M1_MASK, VSOXSEG2EI16_V, 0x0, 0x0 }, // 8056 + { PseudoVSOXSEG2EI16_V_MF2_M1, VSOXSEG2EI16_V, 0x0, 0x0 }, // 8057 + { PseudoVSOXSEG2EI16_V_MF2_M1_MASK, VSOXSEG2EI16_V, 0x0, 0x0 }, // 8058 + { PseudoVSOXSEG2EI16_V_MF4_M1, VSOXSEG2EI16_V, 0x0, 0x0 }, // 8059 + { PseudoVSOXSEG2EI16_V_MF4_M1_MASK, VSOXSEG2EI16_V, 0x0, 0x0 }, // 8060 + { PseudoVSOXSEG2EI16_V_M1_M2, VSOXSEG2EI16_V, 0x1, 0x0 }, // 8061 + { PseudoVSOXSEG2EI16_V_M1_M2_MASK, VSOXSEG2EI16_V, 0x1, 0x0 }, // 8062 + { PseudoVSOXSEG2EI16_V_M2_M2, VSOXSEG2EI16_V, 0x1, 0x0 }, // 8063 + { PseudoVSOXSEG2EI16_V_M2_M2_MASK, VSOXSEG2EI16_V, 0x1, 0x0 }, // 8064 + { PseudoVSOXSEG2EI16_V_M4_M2, VSOXSEG2EI16_V, 0x1, 0x0 }, // 8065 + { PseudoVSOXSEG2EI16_V_M4_M2_MASK, VSOXSEG2EI16_V, 0x1, 0x0 }, // 8066 + { PseudoVSOXSEG2EI16_V_MF2_M2, VSOXSEG2EI16_V, 0x1, 0x0 }, // 8067 + { PseudoVSOXSEG2EI16_V_MF2_M2_MASK, VSOXSEG2EI16_V, 0x1, 0x0 }, // 8068 + { PseudoVSOXSEG2EI16_V_M1_M4, VSOXSEG2EI16_V, 0x2, 0x0 }, // 8069 + { PseudoVSOXSEG2EI16_V_M1_M4_MASK, VSOXSEG2EI16_V, 0x2, 0x0 }, // 8070 + { PseudoVSOXSEG2EI16_V_M2_M4, VSOXSEG2EI16_V, 0x2, 0x0 }, // 8071 + { PseudoVSOXSEG2EI16_V_M2_M4_MASK, VSOXSEG2EI16_V, 0x2, 0x0 }, // 8072 + { PseudoVSOXSEG2EI16_V_M4_M4, VSOXSEG2EI16_V, 0x2, 0x0 }, // 8073 + { PseudoVSOXSEG2EI16_V_M4_M4_MASK, VSOXSEG2EI16_V, 0x2, 0x0 }, // 8074 + { PseudoVSOXSEG2EI16_V_M8_M4, VSOXSEG2EI16_V, 0x2, 0x0 }, // 8075 + { PseudoVSOXSEG2EI16_V_M8_M4_MASK, VSOXSEG2EI16_V, 0x2, 0x0 }, // 8076 + { PseudoVSOXSEG2EI16_V_MF4_MF8, VSOXSEG2EI16_V, 0x5, 0x0 }, // 8077 + { PseudoVSOXSEG2EI16_V_MF4_MF8_MASK, VSOXSEG2EI16_V, 0x5, 0x0 }, // 8078 + { PseudoVSOXSEG2EI16_V_MF2_MF4, VSOXSEG2EI16_V, 0x6, 0x0 }, // 8079 + { PseudoVSOXSEG2EI16_V_MF2_MF4_MASK, VSOXSEG2EI16_V, 0x6, 0x0 }, // 8080 + { PseudoVSOXSEG2EI16_V_MF4_MF4, VSOXSEG2EI16_V, 0x6, 0x0 }, // 8081 + { PseudoVSOXSEG2EI16_V_MF4_MF4_MASK, VSOXSEG2EI16_V, 0x6, 0x0 }, // 8082 + { PseudoVSOXSEG2EI16_V_M1_MF2, VSOXSEG2EI16_V, 0x7, 0x0 }, // 8083 + { PseudoVSOXSEG2EI16_V_M1_MF2_MASK, VSOXSEG2EI16_V, 0x7, 0x0 }, // 8084 + { PseudoVSOXSEG2EI16_V_MF2_MF2, VSOXSEG2EI16_V, 0x7, 0x0 }, // 8085 + { PseudoVSOXSEG2EI16_V_MF2_MF2_MASK, VSOXSEG2EI16_V, 0x7, 0x0 }, // 8086 + { PseudoVSOXSEG2EI16_V_MF4_MF2, VSOXSEG2EI16_V, 0x7, 0x0 }, // 8087 + { PseudoVSOXSEG2EI16_V_MF4_MF2_MASK, VSOXSEG2EI16_V, 0x7, 0x0 }, // 8088 + { PseudoVSOXSEG2EI32_V_M1_M1, VSOXSEG2EI32_V, 0x0, 0x0 }, // 8089 + { PseudoVSOXSEG2EI32_V_M1_M1_MASK, VSOXSEG2EI32_V, 0x0, 0x0 }, // 8090 + { PseudoVSOXSEG2EI32_V_M2_M1, VSOXSEG2EI32_V, 0x0, 0x0 }, // 8091 + { PseudoVSOXSEG2EI32_V_M2_M1_MASK, VSOXSEG2EI32_V, 0x0, 0x0 }, // 8092 + { PseudoVSOXSEG2EI32_V_M4_M1, VSOXSEG2EI32_V, 0x0, 0x0 }, // 8093 + { PseudoVSOXSEG2EI32_V_M4_M1_MASK, VSOXSEG2EI32_V, 0x0, 0x0 }, // 8094 + { PseudoVSOXSEG2EI32_V_MF2_M1, VSOXSEG2EI32_V, 0x0, 0x0 }, // 8095 + { PseudoVSOXSEG2EI32_V_MF2_M1_MASK, VSOXSEG2EI32_V, 0x0, 0x0 }, // 8096 + { PseudoVSOXSEG2EI32_V_M1_M2, VSOXSEG2EI32_V, 0x1, 0x0 }, // 8097 + { PseudoVSOXSEG2EI32_V_M1_M2_MASK, VSOXSEG2EI32_V, 0x1, 0x0 }, // 8098 + { PseudoVSOXSEG2EI32_V_M2_M2, VSOXSEG2EI32_V, 0x1, 0x0 }, // 8099 + { PseudoVSOXSEG2EI32_V_M2_M2_MASK, VSOXSEG2EI32_V, 0x1, 0x0 }, // 8100 + { PseudoVSOXSEG2EI32_V_M4_M2, VSOXSEG2EI32_V, 0x1, 0x0 }, // 8101 + { PseudoVSOXSEG2EI32_V_M4_M2_MASK, VSOXSEG2EI32_V, 0x1, 0x0 }, // 8102 + { PseudoVSOXSEG2EI32_V_M8_M2, VSOXSEG2EI32_V, 0x1, 0x0 }, // 8103 + { PseudoVSOXSEG2EI32_V_M8_M2_MASK, VSOXSEG2EI32_V, 0x1, 0x0 }, // 8104 + { PseudoVSOXSEG2EI32_V_M2_M4, VSOXSEG2EI32_V, 0x2, 0x0 }, // 8105 + { PseudoVSOXSEG2EI32_V_M2_M4_MASK, VSOXSEG2EI32_V, 0x2, 0x0 }, // 8106 + { PseudoVSOXSEG2EI32_V_M4_M4, VSOXSEG2EI32_V, 0x2, 0x0 }, // 8107 + { PseudoVSOXSEG2EI32_V_M4_M4_MASK, VSOXSEG2EI32_V, 0x2, 0x0 }, // 8108 + { PseudoVSOXSEG2EI32_V_M8_M4, VSOXSEG2EI32_V, 0x2, 0x0 }, // 8109 + { PseudoVSOXSEG2EI32_V_M8_M4_MASK, VSOXSEG2EI32_V, 0x2, 0x0 }, // 8110 + { PseudoVSOXSEG2EI32_V_MF2_MF8, VSOXSEG2EI32_V, 0x5, 0x0 }, // 8111 + { PseudoVSOXSEG2EI32_V_MF2_MF8_MASK, VSOXSEG2EI32_V, 0x5, 0x0 }, // 8112 + { PseudoVSOXSEG2EI32_V_M1_MF4, VSOXSEG2EI32_V, 0x6, 0x0 }, // 8113 + { PseudoVSOXSEG2EI32_V_M1_MF4_MASK, VSOXSEG2EI32_V, 0x6, 0x0 }, // 8114 + { PseudoVSOXSEG2EI32_V_MF2_MF4, VSOXSEG2EI32_V, 0x6, 0x0 }, // 8115 + { PseudoVSOXSEG2EI32_V_MF2_MF4_MASK, VSOXSEG2EI32_V, 0x6, 0x0 }, // 8116 + { PseudoVSOXSEG2EI32_V_M1_MF2, VSOXSEG2EI32_V, 0x7, 0x0 }, // 8117 + { PseudoVSOXSEG2EI32_V_M1_MF2_MASK, VSOXSEG2EI32_V, 0x7, 0x0 }, // 8118 + { PseudoVSOXSEG2EI32_V_M2_MF2, VSOXSEG2EI32_V, 0x7, 0x0 }, // 8119 + { PseudoVSOXSEG2EI32_V_M2_MF2_MASK, VSOXSEG2EI32_V, 0x7, 0x0 }, // 8120 + { PseudoVSOXSEG2EI32_V_MF2_MF2, VSOXSEG2EI32_V, 0x7, 0x0 }, // 8121 + { PseudoVSOXSEG2EI32_V_MF2_MF2_MASK, VSOXSEG2EI32_V, 0x7, 0x0 }, // 8122 + { PseudoVSOXSEG2EI64_V_M1_M1, VSOXSEG2EI64_V, 0x0, 0x0 }, // 8123 + { PseudoVSOXSEG2EI64_V_M1_M1_MASK, VSOXSEG2EI64_V, 0x0, 0x0 }, // 8124 + { PseudoVSOXSEG2EI64_V_M2_M1, VSOXSEG2EI64_V, 0x0, 0x0 }, // 8125 + { PseudoVSOXSEG2EI64_V_M2_M1_MASK, VSOXSEG2EI64_V, 0x0, 0x0 }, // 8126 + { PseudoVSOXSEG2EI64_V_M4_M1, VSOXSEG2EI64_V, 0x0, 0x0 }, // 8127 + { PseudoVSOXSEG2EI64_V_M4_M1_MASK, VSOXSEG2EI64_V, 0x0, 0x0 }, // 8128 + { PseudoVSOXSEG2EI64_V_M8_M1, VSOXSEG2EI64_V, 0x0, 0x0 }, // 8129 + { PseudoVSOXSEG2EI64_V_M8_M1_MASK, VSOXSEG2EI64_V, 0x0, 0x0 }, // 8130 + { PseudoVSOXSEG2EI64_V_M2_M2, VSOXSEG2EI64_V, 0x1, 0x0 }, // 8131 + { PseudoVSOXSEG2EI64_V_M2_M2_MASK, VSOXSEG2EI64_V, 0x1, 0x0 }, // 8132 + { PseudoVSOXSEG2EI64_V_M4_M2, VSOXSEG2EI64_V, 0x1, 0x0 }, // 8133 + { PseudoVSOXSEG2EI64_V_M4_M2_MASK, VSOXSEG2EI64_V, 0x1, 0x0 }, // 8134 + { PseudoVSOXSEG2EI64_V_M8_M2, VSOXSEG2EI64_V, 0x1, 0x0 }, // 8135 + { PseudoVSOXSEG2EI64_V_M8_M2_MASK, VSOXSEG2EI64_V, 0x1, 0x0 }, // 8136 + { PseudoVSOXSEG2EI64_V_M4_M4, VSOXSEG2EI64_V, 0x2, 0x0 }, // 8137 + { PseudoVSOXSEG2EI64_V_M4_M4_MASK, VSOXSEG2EI64_V, 0x2, 0x0 }, // 8138 + { PseudoVSOXSEG2EI64_V_M8_M4, VSOXSEG2EI64_V, 0x2, 0x0 }, // 8139 + { PseudoVSOXSEG2EI64_V_M8_M4_MASK, VSOXSEG2EI64_V, 0x2, 0x0 }, // 8140 + { PseudoVSOXSEG2EI64_V_M1_MF8, VSOXSEG2EI64_V, 0x5, 0x0 }, // 8141 + { PseudoVSOXSEG2EI64_V_M1_MF8_MASK, VSOXSEG2EI64_V, 0x5, 0x0 }, // 8142 + { PseudoVSOXSEG2EI64_V_M1_MF4, VSOXSEG2EI64_V, 0x6, 0x0 }, // 8143 + { PseudoVSOXSEG2EI64_V_M1_MF4_MASK, VSOXSEG2EI64_V, 0x6, 0x0 }, // 8144 + { PseudoVSOXSEG2EI64_V_M2_MF4, VSOXSEG2EI64_V, 0x6, 0x0 }, // 8145 + { PseudoVSOXSEG2EI64_V_M2_MF4_MASK, VSOXSEG2EI64_V, 0x6, 0x0 }, // 8146 + { PseudoVSOXSEG2EI64_V_M1_MF2, VSOXSEG2EI64_V, 0x7, 0x0 }, // 8147 + { PseudoVSOXSEG2EI64_V_M1_MF2_MASK, VSOXSEG2EI64_V, 0x7, 0x0 }, // 8148 + { PseudoVSOXSEG2EI64_V_M2_MF2, VSOXSEG2EI64_V, 0x7, 0x0 }, // 8149 + { PseudoVSOXSEG2EI64_V_M2_MF2_MASK, VSOXSEG2EI64_V, 0x7, 0x0 }, // 8150 + { PseudoVSOXSEG2EI64_V_M4_MF2, VSOXSEG2EI64_V, 0x7, 0x0 }, // 8151 + { PseudoVSOXSEG2EI64_V_M4_MF2_MASK, VSOXSEG2EI64_V, 0x7, 0x0 }, // 8152 + { PseudoVSOXSEG2EI8_V_M1_M1, VSOXSEG2EI8_V, 0x0, 0x0 }, // 8153 + { PseudoVSOXSEG2EI8_V_M1_M1_MASK, VSOXSEG2EI8_V, 0x0, 0x0 }, // 8154 + { PseudoVSOXSEG2EI8_V_MF2_M1, VSOXSEG2EI8_V, 0x0, 0x0 }, // 8155 + { PseudoVSOXSEG2EI8_V_MF2_M1_MASK, VSOXSEG2EI8_V, 0x0, 0x0 }, // 8156 + { PseudoVSOXSEG2EI8_V_MF4_M1, VSOXSEG2EI8_V, 0x0, 0x0 }, // 8157 + { PseudoVSOXSEG2EI8_V_MF4_M1_MASK, VSOXSEG2EI8_V, 0x0, 0x0 }, // 8158 + { PseudoVSOXSEG2EI8_V_MF8_M1, VSOXSEG2EI8_V, 0x0, 0x0 }, // 8159 + { PseudoVSOXSEG2EI8_V_MF8_M1_MASK, VSOXSEG2EI8_V, 0x0, 0x0 }, // 8160 + { PseudoVSOXSEG2EI8_V_M1_M2, VSOXSEG2EI8_V, 0x1, 0x0 }, // 8161 + { PseudoVSOXSEG2EI8_V_M1_M2_MASK, VSOXSEG2EI8_V, 0x1, 0x0 }, // 8162 + { PseudoVSOXSEG2EI8_V_M2_M2, VSOXSEG2EI8_V, 0x1, 0x0 }, // 8163 + { PseudoVSOXSEG2EI8_V_M2_M2_MASK, VSOXSEG2EI8_V, 0x1, 0x0 }, // 8164 + { PseudoVSOXSEG2EI8_V_MF2_M2, VSOXSEG2EI8_V, 0x1, 0x0 }, // 8165 + { PseudoVSOXSEG2EI8_V_MF2_M2_MASK, VSOXSEG2EI8_V, 0x1, 0x0 }, // 8166 + { PseudoVSOXSEG2EI8_V_MF4_M2, VSOXSEG2EI8_V, 0x1, 0x0 }, // 8167 + { PseudoVSOXSEG2EI8_V_MF4_M2_MASK, VSOXSEG2EI8_V, 0x1, 0x0 }, // 8168 + { PseudoVSOXSEG2EI8_V_M1_M4, VSOXSEG2EI8_V, 0x2, 0x0 }, // 8169 + { PseudoVSOXSEG2EI8_V_M1_M4_MASK, VSOXSEG2EI8_V, 0x2, 0x0 }, // 8170 + { PseudoVSOXSEG2EI8_V_M2_M4, VSOXSEG2EI8_V, 0x2, 0x0 }, // 8171 + { PseudoVSOXSEG2EI8_V_M2_M4_MASK, VSOXSEG2EI8_V, 0x2, 0x0 }, // 8172 + { PseudoVSOXSEG2EI8_V_M4_M4, VSOXSEG2EI8_V, 0x2, 0x0 }, // 8173 + { PseudoVSOXSEG2EI8_V_M4_M4_MASK, VSOXSEG2EI8_V, 0x2, 0x0 }, // 8174 + { PseudoVSOXSEG2EI8_V_MF2_M4, VSOXSEG2EI8_V, 0x2, 0x0 }, // 8175 + { PseudoVSOXSEG2EI8_V_MF2_M4_MASK, VSOXSEG2EI8_V, 0x2, 0x0 }, // 8176 + { PseudoVSOXSEG2EI8_V_MF8_MF8, VSOXSEG2EI8_V, 0x5, 0x0 }, // 8177 + { PseudoVSOXSEG2EI8_V_MF8_MF8_MASK, VSOXSEG2EI8_V, 0x5, 0x0 }, // 8178 + { PseudoVSOXSEG2EI8_V_MF4_MF4, VSOXSEG2EI8_V, 0x6, 0x0 }, // 8179 + { PseudoVSOXSEG2EI8_V_MF4_MF4_MASK, VSOXSEG2EI8_V, 0x6, 0x0 }, // 8180 + { PseudoVSOXSEG2EI8_V_MF8_MF4, VSOXSEG2EI8_V, 0x6, 0x0 }, // 8181 + { PseudoVSOXSEG2EI8_V_MF8_MF4_MASK, VSOXSEG2EI8_V, 0x6, 0x0 }, // 8182 + { PseudoVSOXSEG2EI8_V_MF2_MF2, VSOXSEG2EI8_V, 0x7, 0x0 }, // 8183 + { PseudoVSOXSEG2EI8_V_MF2_MF2_MASK, VSOXSEG2EI8_V, 0x7, 0x0 }, // 8184 + { PseudoVSOXSEG2EI8_V_MF4_MF2, VSOXSEG2EI8_V, 0x7, 0x0 }, // 8185 + { PseudoVSOXSEG2EI8_V_MF4_MF2_MASK, VSOXSEG2EI8_V, 0x7, 0x0 }, // 8186 + { PseudoVSOXSEG2EI8_V_MF8_MF2, VSOXSEG2EI8_V, 0x7, 0x0 }, // 8187 + { PseudoVSOXSEG2EI8_V_MF8_MF2_MASK, VSOXSEG2EI8_V, 0x7, 0x0 }, // 8188 + { PseudoVSOXSEG3EI16_V_M1_M1, VSOXSEG3EI16_V, 0x0, 0x0 }, // 8189 + { PseudoVSOXSEG3EI16_V_M1_M1_MASK, VSOXSEG3EI16_V, 0x0, 0x0 }, // 8190 + { PseudoVSOXSEG3EI16_V_M2_M1, VSOXSEG3EI16_V, 0x0, 0x0 }, // 8191 + { PseudoVSOXSEG3EI16_V_M2_M1_MASK, VSOXSEG3EI16_V, 0x0, 0x0 }, // 8192 + { PseudoVSOXSEG3EI16_V_MF2_M1, VSOXSEG3EI16_V, 0x0, 0x0 }, // 8193 + { PseudoVSOXSEG3EI16_V_MF2_M1_MASK, VSOXSEG3EI16_V, 0x0, 0x0 }, // 8194 + { PseudoVSOXSEG3EI16_V_MF4_M1, VSOXSEG3EI16_V, 0x0, 0x0 }, // 8195 + { PseudoVSOXSEG3EI16_V_MF4_M1_MASK, VSOXSEG3EI16_V, 0x0, 0x0 }, // 8196 + { PseudoVSOXSEG3EI16_V_M1_M2, VSOXSEG3EI16_V, 0x1, 0x0 }, // 8197 + { PseudoVSOXSEG3EI16_V_M1_M2_MASK, VSOXSEG3EI16_V, 0x1, 0x0 }, // 8198 + { PseudoVSOXSEG3EI16_V_M2_M2, VSOXSEG3EI16_V, 0x1, 0x0 }, // 8199 + { PseudoVSOXSEG3EI16_V_M2_M2_MASK, VSOXSEG3EI16_V, 0x1, 0x0 }, // 8200 + { PseudoVSOXSEG3EI16_V_M4_M2, VSOXSEG3EI16_V, 0x1, 0x0 }, // 8201 + { PseudoVSOXSEG3EI16_V_M4_M2_MASK, VSOXSEG3EI16_V, 0x1, 0x0 }, // 8202 + { PseudoVSOXSEG3EI16_V_MF2_M2, VSOXSEG3EI16_V, 0x1, 0x0 }, // 8203 + { PseudoVSOXSEG3EI16_V_MF2_M2_MASK, VSOXSEG3EI16_V, 0x1, 0x0 }, // 8204 + { PseudoVSOXSEG3EI16_V_MF4_MF8, VSOXSEG3EI16_V, 0x5, 0x0 }, // 8205 + { PseudoVSOXSEG3EI16_V_MF4_MF8_MASK, VSOXSEG3EI16_V, 0x5, 0x0 }, // 8206 + { PseudoVSOXSEG3EI16_V_MF2_MF4, VSOXSEG3EI16_V, 0x6, 0x0 }, // 8207 + { PseudoVSOXSEG3EI16_V_MF2_MF4_MASK, VSOXSEG3EI16_V, 0x6, 0x0 }, // 8208 + { PseudoVSOXSEG3EI16_V_MF4_MF4, VSOXSEG3EI16_V, 0x6, 0x0 }, // 8209 + { PseudoVSOXSEG3EI16_V_MF4_MF4_MASK, VSOXSEG3EI16_V, 0x6, 0x0 }, // 8210 + { PseudoVSOXSEG3EI16_V_M1_MF2, VSOXSEG3EI16_V, 0x7, 0x0 }, // 8211 + { PseudoVSOXSEG3EI16_V_M1_MF2_MASK, VSOXSEG3EI16_V, 0x7, 0x0 }, // 8212 + { PseudoVSOXSEG3EI16_V_MF2_MF2, VSOXSEG3EI16_V, 0x7, 0x0 }, // 8213 + { PseudoVSOXSEG3EI16_V_MF2_MF2_MASK, VSOXSEG3EI16_V, 0x7, 0x0 }, // 8214 + { PseudoVSOXSEG3EI16_V_MF4_MF2, VSOXSEG3EI16_V, 0x7, 0x0 }, // 8215 + { PseudoVSOXSEG3EI16_V_MF4_MF2_MASK, VSOXSEG3EI16_V, 0x7, 0x0 }, // 8216 + { PseudoVSOXSEG3EI32_V_M1_M1, VSOXSEG3EI32_V, 0x0, 0x0 }, // 8217 + { PseudoVSOXSEG3EI32_V_M1_M1_MASK, VSOXSEG3EI32_V, 0x0, 0x0 }, // 8218 + { PseudoVSOXSEG3EI32_V_M2_M1, VSOXSEG3EI32_V, 0x0, 0x0 }, // 8219 + { PseudoVSOXSEG3EI32_V_M2_M1_MASK, VSOXSEG3EI32_V, 0x0, 0x0 }, // 8220 + { PseudoVSOXSEG3EI32_V_M4_M1, VSOXSEG3EI32_V, 0x0, 0x0 }, // 8221 + { PseudoVSOXSEG3EI32_V_M4_M1_MASK, VSOXSEG3EI32_V, 0x0, 0x0 }, // 8222 + { PseudoVSOXSEG3EI32_V_MF2_M1, VSOXSEG3EI32_V, 0x0, 0x0 }, // 8223 + { PseudoVSOXSEG3EI32_V_MF2_M1_MASK, VSOXSEG3EI32_V, 0x0, 0x0 }, // 8224 + { PseudoVSOXSEG3EI32_V_M1_M2, VSOXSEG3EI32_V, 0x1, 0x0 }, // 8225 + { PseudoVSOXSEG3EI32_V_M1_M2_MASK, VSOXSEG3EI32_V, 0x1, 0x0 }, // 8226 + { PseudoVSOXSEG3EI32_V_M2_M2, VSOXSEG3EI32_V, 0x1, 0x0 }, // 8227 + { PseudoVSOXSEG3EI32_V_M2_M2_MASK, VSOXSEG3EI32_V, 0x1, 0x0 }, // 8228 + { PseudoVSOXSEG3EI32_V_M4_M2, VSOXSEG3EI32_V, 0x1, 0x0 }, // 8229 + { PseudoVSOXSEG3EI32_V_M4_M2_MASK, VSOXSEG3EI32_V, 0x1, 0x0 }, // 8230 + { PseudoVSOXSEG3EI32_V_M8_M2, VSOXSEG3EI32_V, 0x1, 0x0 }, // 8231 + { PseudoVSOXSEG3EI32_V_M8_M2_MASK, VSOXSEG3EI32_V, 0x1, 0x0 }, // 8232 + { PseudoVSOXSEG3EI32_V_MF2_MF8, VSOXSEG3EI32_V, 0x5, 0x0 }, // 8233 + { PseudoVSOXSEG3EI32_V_MF2_MF8_MASK, VSOXSEG3EI32_V, 0x5, 0x0 }, // 8234 + { PseudoVSOXSEG3EI32_V_M1_MF4, VSOXSEG3EI32_V, 0x6, 0x0 }, // 8235 + { PseudoVSOXSEG3EI32_V_M1_MF4_MASK, VSOXSEG3EI32_V, 0x6, 0x0 }, // 8236 + { PseudoVSOXSEG3EI32_V_MF2_MF4, VSOXSEG3EI32_V, 0x6, 0x0 }, // 8237 + { PseudoVSOXSEG3EI32_V_MF2_MF4_MASK, VSOXSEG3EI32_V, 0x6, 0x0 }, // 8238 + { PseudoVSOXSEG3EI32_V_M1_MF2, VSOXSEG3EI32_V, 0x7, 0x0 }, // 8239 + { PseudoVSOXSEG3EI32_V_M1_MF2_MASK, VSOXSEG3EI32_V, 0x7, 0x0 }, // 8240 + { PseudoVSOXSEG3EI32_V_M2_MF2, VSOXSEG3EI32_V, 0x7, 0x0 }, // 8241 + { PseudoVSOXSEG3EI32_V_M2_MF2_MASK, VSOXSEG3EI32_V, 0x7, 0x0 }, // 8242 + { PseudoVSOXSEG3EI32_V_MF2_MF2, VSOXSEG3EI32_V, 0x7, 0x0 }, // 8243 + { PseudoVSOXSEG3EI32_V_MF2_MF2_MASK, VSOXSEG3EI32_V, 0x7, 0x0 }, // 8244 + { PseudoVSOXSEG3EI64_V_M1_M1, VSOXSEG3EI64_V, 0x0, 0x0 }, // 8245 + { PseudoVSOXSEG3EI64_V_M1_M1_MASK, VSOXSEG3EI64_V, 0x0, 0x0 }, // 8246 + { PseudoVSOXSEG3EI64_V_M2_M1, VSOXSEG3EI64_V, 0x0, 0x0 }, // 8247 + { PseudoVSOXSEG3EI64_V_M2_M1_MASK, VSOXSEG3EI64_V, 0x0, 0x0 }, // 8248 + { PseudoVSOXSEG3EI64_V_M4_M1, VSOXSEG3EI64_V, 0x0, 0x0 }, // 8249 + { PseudoVSOXSEG3EI64_V_M4_M1_MASK, VSOXSEG3EI64_V, 0x0, 0x0 }, // 8250 + { PseudoVSOXSEG3EI64_V_M8_M1, VSOXSEG3EI64_V, 0x0, 0x0 }, // 8251 + { PseudoVSOXSEG3EI64_V_M8_M1_MASK, VSOXSEG3EI64_V, 0x0, 0x0 }, // 8252 + { PseudoVSOXSEG3EI64_V_M2_M2, VSOXSEG3EI64_V, 0x1, 0x0 }, // 8253 + { PseudoVSOXSEG3EI64_V_M2_M2_MASK, VSOXSEG3EI64_V, 0x1, 0x0 }, // 8254 + { PseudoVSOXSEG3EI64_V_M4_M2, VSOXSEG3EI64_V, 0x1, 0x0 }, // 8255 + { PseudoVSOXSEG3EI64_V_M4_M2_MASK, VSOXSEG3EI64_V, 0x1, 0x0 }, // 8256 + { PseudoVSOXSEG3EI64_V_M8_M2, VSOXSEG3EI64_V, 0x1, 0x0 }, // 8257 + { PseudoVSOXSEG3EI64_V_M8_M2_MASK, VSOXSEG3EI64_V, 0x1, 0x0 }, // 8258 + { PseudoVSOXSEG3EI64_V_M1_MF8, VSOXSEG3EI64_V, 0x5, 0x0 }, // 8259 + { PseudoVSOXSEG3EI64_V_M1_MF8_MASK, VSOXSEG3EI64_V, 0x5, 0x0 }, // 8260 + { PseudoVSOXSEG3EI64_V_M1_MF4, VSOXSEG3EI64_V, 0x6, 0x0 }, // 8261 + { PseudoVSOXSEG3EI64_V_M1_MF4_MASK, VSOXSEG3EI64_V, 0x6, 0x0 }, // 8262 + { PseudoVSOXSEG3EI64_V_M2_MF4, VSOXSEG3EI64_V, 0x6, 0x0 }, // 8263 + { PseudoVSOXSEG3EI64_V_M2_MF4_MASK, VSOXSEG3EI64_V, 0x6, 0x0 }, // 8264 + { PseudoVSOXSEG3EI64_V_M1_MF2, VSOXSEG3EI64_V, 0x7, 0x0 }, // 8265 + { PseudoVSOXSEG3EI64_V_M1_MF2_MASK, VSOXSEG3EI64_V, 0x7, 0x0 }, // 8266 + { PseudoVSOXSEG3EI64_V_M2_MF2, VSOXSEG3EI64_V, 0x7, 0x0 }, // 8267 + { PseudoVSOXSEG3EI64_V_M2_MF2_MASK, VSOXSEG3EI64_V, 0x7, 0x0 }, // 8268 + { PseudoVSOXSEG3EI64_V_M4_MF2, VSOXSEG3EI64_V, 0x7, 0x0 }, // 8269 + { PseudoVSOXSEG3EI64_V_M4_MF2_MASK, VSOXSEG3EI64_V, 0x7, 0x0 }, // 8270 + { PseudoVSOXSEG3EI8_V_M1_M1, VSOXSEG3EI8_V, 0x0, 0x0 }, // 8271 + { PseudoVSOXSEG3EI8_V_M1_M1_MASK, VSOXSEG3EI8_V, 0x0, 0x0 }, // 8272 + { PseudoVSOXSEG3EI8_V_MF2_M1, VSOXSEG3EI8_V, 0x0, 0x0 }, // 8273 + { PseudoVSOXSEG3EI8_V_MF2_M1_MASK, VSOXSEG3EI8_V, 0x0, 0x0 }, // 8274 + { PseudoVSOXSEG3EI8_V_MF4_M1, VSOXSEG3EI8_V, 0x0, 0x0 }, // 8275 + { PseudoVSOXSEG3EI8_V_MF4_M1_MASK, VSOXSEG3EI8_V, 0x0, 0x0 }, // 8276 + { PseudoVSOXSEG3EI8_V_MF8_M1, VSOXSEG3EI8_V, 0x0, 0x0 }, // 8277 + { PseudoVSOXSEG3EI8_V_MF8_M1_MASK, VSOXSEG3EI8_V, 0x0, 0x0 }, // 8278 + { PseudoVSOXSEG3EI8_V_M1_M2, VSOXSEG3EI8_V, 0x1, 0x0 }, // 8279 + { PseudoVSOXSEG3EI8_V_M1_M2_MASK, VSOXSEG3EI8_V, 0x1, 0x0 }, // 8280 + { PseudoVSOXSEG3EI8_V_M2_M2, VSOXSEG3EI8_V, 0x1, 0x0 }, // 8281 + { PseudoVSOXSEG3EI8_V_M2_M2_MASK, VSOXSEG3EI8_V, 0x1, 0x0 }, // 8282 + { PseudoVSOXSEG3EI8_V_MF2_M2, VSOXSEG3EI8_V, 0x1, 0x0 }, // 8283 + { PseudoVSOXSEG3EI8_V_MF2_M2_MASK, VSOXSEG3EI8_V, 0x1, 0x0 }, // 8284 + { PseudoVSOXSEG3EI8_V_MF4_M2, VSOXSEG3EI8_V, 0x1, 0x0 }, // 8285 + { PseudoVSOXSEG3EI8_V_MF4_M2_MASK, VSOXSEG3EI8_V, 0x1, 0x0 }, // 8286 + { PseudoVSOXSEG3EI8_V_MF8_MF8, VSOXSEG3EI8_V, 0x5, 0x0 }, // 8287 + { PseudoVSOXSEG3EI8_V_MF8_MF8_MASK, VSOXSEG3EI8_V, 0x5, 0x0 }, // 8288 + { PseudoVSOXSEG3EI8_V_MF4_MF4, VSOXSEG3EI8_V, 0x6, 0x0 }, // 8289 + { PseudoVSOXSEG3EI8_V_MF4_MF4_MASK, VSOXSEG3EI8_V, 0x6, 0x0 }, // 8290 + { PseudoVSOXSEG3EI8_V_MF8_MF4, VSOXSEG3EI8_V, 0x6, 0x0 }, // 8291 + { PseudoVSOXSEG3EI8_V_MF8_MF4_MASK, VSOXSEG3EI8_V, 0x6, 0x0 }, // 8292 + { PseudoVSOXSEG3EI8_V_MF2_MF2, VSOXSEG3EI8_V, 0x7, 0x0 }, // 8293 + { PseudoVSOXSEG3EI8_V_MF2_MF2_MASK, VSOXSEG3EI8_V, 0x7, 0x0 }, // 8294 + { PseudoVSOXSEG3EI8_V_MF4_MF2, VSOXSEG3EI8_V, 0x7, 0x0 }, // 8295 + { PseudoVSOXSEG3EI8_V_MF4_MF2_MASK, VSOXSEG3EI8_V, 0x7, 0x0 }, // 8296 + { PseudoVSOXSEG3EI8_V_MF8_MF2, VSOXSEG3EI8_V, 0x7, 0x0 }, // 8297 + { PseudoVSOXSEG3EI8_V_MF8_MF2_MASK, VSOXSEG3EI8_V, 0x7, 0x0 }, // 8298 + { PseudoVSOXSEG4EI16_V_M1_M1, VSOXSEG4EI16_V, 0x0, 0x0 }, // 8299 + { PseudoVSOXSEG4EI16_V_M1_M1_MASK, VSOXSEG4EI16_V, 0x0, 0x0 }, // 8300 + { PseudoVSOXSEG4EI16_V_M2_M1, VSOXSEG4EI16_V, 0x0, 0x0 }, // 8301 + { PseudoVSOXSEG4EI16_V_M2_M1_MASK, VSOXSEG4EI16_V, 0x0, 0x0 }, // 8302 + { PseudoVSOXSEG4EI16_V_MF2_M1, VSOXSEG4EI16_V, 0x0, 0x0 }, // 8303 + { PseudoVSOXSEG4EI16_V_MF2_M1_MASK, VSOXSEG4EI16_V, 0x0, 0x0 }, // 8304 + { PseudoVSOXSEG4EI16_V_MF4_M1, VSOXSEG4EI16_V, 0x0, 0x0 }, // 8305 + { PseudoVSOXSEG4EI16_V_MF4_M1_MASK, VSOXSEG4EI16_V, 0x0, 0x0 }, // 8306 + { PseudoVSOXSEG4EI16_V_M1_M2, VSOXSEG4EI16_V, 0x1, 0x0 }, // 8307 + { PseudoVSOXSEG4EI16_V_M1_M2_MASK, VSOXSEG4EI16_V, 0x1, 0x0 }, // 8308 + { PseudoVSOXSEG4EI16_V_M2_M2, VSOXSEG4EI16_V, 0x1, 0x0 }, // 8309 + { PseudoVSOXSEG4EI16_V_M2_M2_MASK, VSOXSEG4EI16_V, 0x1, 0x0 }, // 8310 + { PseudoVSOXSEG4EI16_V_M4_M2, VSOXSEG4EI16_V, 0x1, 0x0 }, // 8311 + { PseudoVSOXSEG4EI16_V_M4_M2_MASK, VSOXSEG4EI16_V, 0x1, 0x0 }, // 8312 + { PseudoVSOXSEG4EI16_V_MF2_M2, VSOXSEG4EI16_V, 0x1, 0x0 }, // 8313 + { PseudoVSOXSEG4EI16_V_MF2_M2_MASK, VSOXSEG4EI16_V, 0x1, 0x0 }, // 8314 + { PseudoVSOXSEG4EI16_V_MF4_MF8, VSOXSEG4EI16_V, 0x5, 0x0 }, // 8315 + { PseudoVSOXSEG4EI16_V_MF4_MF8_MASK, VSOXSEG4EI16_V, 0x5, 0x0 }, // 8316 + { PseudoVSOXSEG4EI16_V_MF2_MF4, VSOXSEG4EI16_V, 0x6, 0x0 }, // 8317 + { PseudoVSOXSEG4EI16_V_MF2_MF4_MASK, VSOXSEG4EI16_V, 0x6, 0x0 }, // 8318 + { PseudoVSOXSEG4EI16_V_MF4_MF4, VSOXSEG4EI16_V, 0x6, 0x0 }, // 8319 + { PseudoVSOXSEG4EI16_V_MF4_MF4_MASK, VSOXSEG4EI16_V, 0x6, 0x0 }, // 8320 + { PseudoVSOXSEG4EI16_V_M1_MF2, VSOXSEG4EI16_V, 0x7, 0x0 }, // 8321 + { PseudoVSOXSEG4EI16_V_M1_MF2_MASK, VSOXSEG4EI16_V, 0x7, 0x0 }, // 8322 + { PseudoVSOXSEG4EI16_V_MF2_MF2, VSOXSEG4EI16_V, 0x7, 0x0 }, // 8323 + { PseudoVSOXSEG4EI16_V_MF2_MF2_MASK, VSOXSEG4EI16_V, 0x7, 0x0 }, // 8324 + { PseudoVSOXSEG4EI16_V_MF4_MF2, VSOXSEG4EI16_V, 0x7, 0x0 }, // 8325 + { PseudoVSOXSEG4EI16_V_MF4_MF2_MASK, VSOXSEG4EI16_V, 0x7, 0x0 }, // 8326 + { PseudoVSOXSEG4EI32_V_M1_M1, VSOXSEG4EI32_V, 0x0, 0x0 }, // 8327 + { PseudoVSOXSEG4EI32_V_M1_M1_MASK, VSOXSEG4EI32_V, 0x0, 0x0 }, // 8328 + { PseudoVSOXSEG4EI32_V_M2_M1, VSOXSEG4EI32_V, 0x0, 0x0 }, // 8329 + { PseudoVSOXSEG4EI32_V_M2_M1_MASK, VSOXSEG4EI32_V, 0x0, 0x0 }, // 8330 + { PseudoVSOXSEG4EI32_V_M4_M1, VSOXSEG4EI32_V, 0x0, 0x0 }, // 8331 + { PseudoVSOXSEG4EI32_V_M4_M1_MASK, VSOXSEG4EI32_V, 0x0, 0x0 }, // 8332 + { PseudoVSOXSEG4EI32_V_MF2_M1, VSOXSEG4EI32_V, 0x0, 0x0 }, // 8333 + { PseudoVSOXSEG4EI32_V_MF2_M1_MASK, VSOXSEG4EI32_V, 0x0, 0x0 }, // 8334 + { PseudoVSOXSEG4EI32_V_M1_M2, VSOXSEG4EI32_V, 0x1, 0x0 }, // 8335 + { PseudoVSOXSEG4EI32_V_M1_M2_MASK, VSOXSEG4EI32_V, 0x1, 0x0 }, // 8336 + { PseudoVSOXSEG4EI32_V_M2_M2, VSOXSEG4EI32_V, 0x1, 0x0 }, // 8337 + { PseudoVSOXSEG4EI32_V_M2_M2_MASK, VSOXSEG4EI32_V, 0x1, 0x0 }, // 8338 + { PseudoVSOXSEG4EI32_V_M4_M2, VSOXSEG4EI32_V, 0x1, 0x0 }, // 8339 + { PseudoVSOXSEG4EI32_V_M4_M2_MASK, VSOXSEG4EI32_V, 0x1, 0x0 }, // 8340 + { PseudoVSOXSEG4EI32_V_M8_M2, VSOXSEG4EI32_V, 0x1, 0x0 }, // 8341 + { PseudoVSOXSEG4EI32_V_M8_M2_MASK, VSOXSEG4EI32_V, 0x1, 0x0 }, // 8342 + { PseudoVSOXSEG4EI32_V_MF2_MF8, VSOXSEG4EI32_V, 0x5, 0x0 }, // 8343 + { PseudoVSOXSEG4EI32_V_MF2_MF8_MASK, VSOXSEG4EI32_V, 0x5, 0x0 }, // 8344 + { PseudoVSOXSEG4EI32_V_M1_MF4, VSOXSEG4EI32_V, 0x6, 0x0 }, // 8345 + { PseudoVSOXSEG4EI32_V_M1_MF4_MASK, VSOXSEG4EI32_V, 0x6, 0x0 }, // 8346 + { PseudoVSOXSEG4EI32_V_MF2_MF4, VSOXSEG4EI32_V, 0x6, 0x0 }, // 8347 + { PseudoVSOXSEG4EI32_V_MF2_MF4_MASK, VSOXSEG4EI32_V, 0x6, 0x0 }, // 8348 + { PseudoVSOXSEG4EI32_V_M1_MF2, VSOXSEG4EI32_V, 0x7, 0x0 }, // 8349 + { PseudoVSOXSEG4EI32_V_M1_MF2_MASK, VSOXSEG4EI32_V, 0x7, 0x0 }, // 8350 + { PseudoVSOXSEG4EI32_V_M2_MF2, VSOXSEG4EI32_V, 0x7, 0x0 }, // 8351 + { PseudoVSOXSEG4EI32_V_M2_MF2_MASK, VSOXSEG4EI32_V, 0x7, 0x0 }, // 8352 + { PseudoVSOXSEG4EI32_V_MF2_MF2, VSOXSEG4EI32_V, 0x7, 0x0 }, // 8353 + { PseudoVSOXSEG4EI32_V_MF2_MF2_MASK, VSOXSEG4EI32_V, 0x7, 0x0 }, // 8354 + { PseudoVSOXSEG4EI64_V_M1_M1, VSOXSEG4EI64_V, 0x0, 0x0 }, // 8355 + { PseudoVSOXSEG4EI64_V_M1_M1_MASK, VSOXSEG4EI64_V, 0x0, 0x0 }, // 8356 + { PseudoVSOXSEG4EI64_V_M2_M1, VSOXSEG4EI64_V, 0x0, 0x0 }, // 8357 + { PseudoVSOXSEG4EI64_V_M2_M1_MASK, VSOXSEG4EI64_V, 0x0, 0x0 }, // 8358 + { PseudoVSOXSEG4EI64_V_M4_M1, VSOXSEG4EI64_V, 0x0, 0x0 }, // 8359 + { PseudoVSOXSEG4EI64_V_M4_M1_MASK, VSOXSEG4EI64_V, 0x0, 0x0 }, // 8360 + { PseudoVSOXSEG4EI64_V_M8_M1, VSOXSEG4EI64_V, 0x0, 0x0 }, // 8361 + { PseudoVSOXSEG4EI64_V_M8_M1_MASK, VSOXSEG4EI64_V, 0x0, 0x0 }, // 8362 + { PseudoVSOXSEG4EI64_V_M2_M2, VSOXSEG4EI64_V, 0x1, 0x0 }, // 8363 + { PseudoVSOXSEG4EI64_V_M2_M2_MASK, VSOXSEG4EI64_V, 0x1, 0x0 }, // 8364 + { PseudoVSOXSEG4EI64_V_M4_M2, VSOXSEG4EI64_V, 0x1, 0x0 }, // 8365 + { PseudoVSOXSEG4EI64_V_M4_M2_MASK, VSOXSEG4EI64_V, 0x1, 0x0 }, // 8366 + { PseudoVSOXSEG4EI64_V_M8_M2, VSOXSEG4EI64_V, 0x1, 0x0 }, // 8367 + { PseudoVSOXSEG4EI64_V_M8_M2_MASK, VSOXSEG4EI64_V, 0x1, 0x0 }, // 8368 + { PseudoVSOXSEG4EI64_V_M1_MF8, VSOXSEG4EI64_V, 0x5, 0x0 }, // 8369 + { PseudoVSOXSEG4EI64_V_M1_MF8_MASK, VSOXSEG4EI64_V, 0x5, 0x0 }, // 8370 + { PseudoVSOXSEG4EI64_V_M1_MF4, VSOXSEG4EI64_V, 0x6, 0x0 }, // 8371 + { PseudoVSOXSEG4EI64_V_M1_MF4_MASK, VSOXSEG4EI64_V, 0x6, 0x0 }, // 8372 + { PseudoVSOXSEG4EI64_V_M2_MF4, VSOXSEG4EI64_V, 0x6, 0x0 }, // 8373 + { PseudoVSOXSEG4EI64_V_M2_MF4_MASK, VSOXSEG4EI64_V, 0x6, 0x0 }, // 8374 + { PseudoVSOXSEG4EI64_V_M1_MF2, VSOXSEG4EI64_V, 0x7, 0x0 }, // 8375 + { PseudoVSOXSEG4EI64_V_M1_MF2_MASK, VSOXSEG4EI64_V, 0x7, 0x0 }, // 8376 + { PseudoVSOXSEG4EI64_V_M2_MF2, VSOXSEG4EI64_V, 0x7, 0x0 }, // 8377 + { PseudoVSOXSEG4EI64_V_M2_MF2_MASK, VSOXSEG4EI64_V, 0x7, 0x0 }, // 8378 + { PseudoVSOXSEG4EI64_V_M4_MF2, VSOXSEG4EI64_V, 0x7, 0x0 }, // 8379 + { PseudoVSOXSEG4EI64_V_M4_MF2_MASK, VSOXSEG4EI64_V, 0x7, 0x0 }, // 8380 + { PseudoVSOXSEG4EI8_V_M1_M1, VSOXSEG4EI8_V, 0x0, 0x0 }, // 8381 + { PseudoVSOXSEG4EI8_V_M1_M1_MASK, VSOXSEG4EI8_V, 0x0, 0x0 }, // 8382 + { PseudoVSOXSEG4EI8_V_MF2_M1, VSOXSEG4EI8_V, 0x0, 0x0 }, // 8383 + { PseudoVSOXSEG4EI8_V_MF2_M1_MASK, VSOXSEG4EI8_V, 0x0, 0x0 }, // 8384 + { PseudoVSOXSEG4EI8_V_MF4_M1, VSOXSEG4EI8_V, 0x0, 0x0 }, // 8385 + { PseudoVSOXSEG4EI8_V_MF4_M1_MASK, VSOXSEG4EI8_V, 0x0, 0x0 }, // 8386 + { PseudoVSOXSEG4EI8_V_MF8_M1, VSOXSEG4EI8_V, 0x0, 0x0 }, // 8387 + { PseudoVSOXSEG4EI8_V_MF8_M1_MASK, VSOXSEG4EI8_V, 0x0, 0x0 }, // 8388 + { PseudoVSOXSEG4EI8_V_M1_M2, VSOXSEG4EI8_V, 0x1, 0x0 }, // 8389 + { PseudoVSOXSEG4EI8_V_M1_M2_MASK, VSOXSEG4EI8_V, 0x1, 0x0 }, // 8390 + { PseudoVSOXSEG4EI8_V_M2_M2, VSOXSEG4EI8_V, 0x1, 0x0 }, // 8391 + { PseudoVSOXSEG4EI8_V_M2_M2_MASK, VSOXSEG4EI8_V, 0x1, 0x0 }, // 8392 + { PseudoVSOXSEG4EI8_V_MF2_M2, VSOXSEG4EI8_V, 0x1, 0x0 }, // 8393 + { PseudoVSOXSEG4EI8_V_MF2_M2_MASK, VSOXSEG4EI8_V, 0x1, 0x0 }, // 8394 + { PseudoVSOXSEG4EI8_V_MF4_M2, VSOXSEG4EI8_V, 0x1, 0x0 }, // 8395 + { PseudoVSOXSEG4EI8_V_MF4_M2_MASK, VSOXSEG4EI8_V, 0x1, 0x0 }, // 8396 + { PseudoVSOXSEG4EI8_V_MF8_MF8, VSOXSEG4EI8_V, 0x5, 0x0 }, // 8397 + { PseudoVSOXSEG4EI8_V_MF8_MF8_MASK, VSOXSEG4EI8_V, 0x5, 0x0 }, // 8398 + { PseudoVSOXSEG4EI8_V_MF4_MF4, VSOXSEG4EI8_V, 0x6, 0x0 }, // 8399 + { PseudoVSOXSEG4EI8_V_MF4_MF4_MASK, VSOXSEG4EI8_V, 0x6, 0x0 }, // 8400 + { PseudoVSOXSEG4EI8_V_MF8_MF4, VSOXSEG4EI8_V, 0x6, 0x0 }, // 8401 + { PseudoVSOXSEG4EI8_V_MF8_MF4_MASK, VSOXSEG4EI8_V, 0x6, 0x0 }, // 8402 + { PseudoVSOXSEG4EI8_V_MF2_MF2, VSOXSEG4EI8_V, 0x7, 0x0 }, // 8403 + { PseudoVSOXSEG4EI8_V_MF2_MF2_MASK, VSOXSEG4EI8_V, 0x7, 0x0 }, // 8404 + { PseudoVSOXSEG4EI8_V_MF4_MF2, VSOXSEG4EI8_V, 0x7, 0x0 }, // 8405 + { PseudoVSOXSEG4EI8_V_MF4_MF2_MASK, VSOXSEG4EI8_V, 0x7, 0x0 }, // 8406 + { PseudoVSOXSEG4EI8_V_MF8_MF2, VSOXSEG4EI8_V, 0x7, 0x0 }, // 8407 + { PseudoVSOXSEG4EI8_V_MF8_MF2_MASK, VSOXSEG4EI8_V, 0x7, 0x0 }, // 8408 + { PseudoVSOXSEG5EI16_V_M1_M1, VSOXSEG5EI16_V, 0x0, 0x0 }, // 8409 + { PseudoVSOXSEG5EI16_V_M1_M1_MASK, VSOXSEG5EI16_V, 0x0, 0x0 }, // 8410 + { PseudoVSOXSEG5EI16_V_M2_M1, VSOXSEG5EI16_V, 0x0, 0x0 }, // 8411 + { PseudoVSOXSEG5EI16_V_M2_M1_MASK, VSOXSEG5EI16_V, 0x0, 0x0 }, // 8412 + { PseudoVSOXSEG5EI16_V_MF2_M1, VSOXSEG5EI16_V, 0x0, 0x0 }, // 8413 + { PseudoVSOXSEG5EI16_V_MF2_M1_MASK, VSOXSEG5EI16_V, 0x0, 0x0 }, // 8414 + { PseudoVSOXSEG5EI16_V_MF4_M1, VSOXSEG5EI16_V, 0x0, 0x0 }, // 8415 + { PseudoVSOXSEG5EI16_V_MF4_M1_MASK, VSOXSEG5EI16_V, 0x0, 0x0 }, // 8416 + { PseudoVSOXSEG5EI16_V_MF4_MF8, VSOXSEG5EI16_V, 0x5, 0x0 }, // 8417 + { PseudoVSOXSEG5EI16_V_MF4_MF8_MASK, VSOXSEG5EI16_V, 0x5, 0x0 }, // 8418 + { PseudoVSOXSEG5EI16_V_MF2_MF4, VSOXSEG5EI16_V, 0x6, 0x0 }, // 8419 + { PseudoVSOXSEG5EI16_V_MF2_MF4_MASK, VSOXSEG5EI16_V, 0x6, 0x0 }, // 8420 + { PseudoVSOXSEG5EI16_V_MF4_MF4, VSOXSEG5EI16_V, 0x6, 0x0 }, // 8421 + { PseudoVSOXSEG5EI16_V_MF4_MF4_MASK, VSOXSEG5EI16_V, 0x6, 0x0 }, // 8422 + { PseudoVSOXSEG5EI16_V_M1_MF2, VSOXSEG5EI16_V, 0x7, 0x0 }, // 8423 + { PseudoVSOXSEG5EI16_V_M1_MF2_MASK, VSOXSEG5EI16_V, 0x7, 0x0 }, // 8424 + { PseudoVSOXSEG5EI16_V_MF2_MF2, VSOXSEG5EI16_V, 0x7, 0x0 }, // 8425 + { PseudoVSOXSEG5EI16_V_MF2_MF2_MASK, VSOXSEG5EI16_V, 0x7, 0x0 }, // 8426 + { PseudoVSOXSEG5EI16_V_MF4_MF2, VSOXSEG5EI16_V, 0x7, 0x0 }, // 8427 + { PseudoVSOXSEG5EI16_V_MF4_MF2_MASK, VSOXSEG5EI16_V, 0x7, 0x0 }, // 8428 + { PseudoVSOXSEG5EI32_V_M1_M1, VSOXSEG5EI32_V, 0x0, 0x0 }, // 8429 + { PseudoVSOXSEG5EI32_V_M1_M1_MASK, VSOXSEG5EI32_V, 0x0, 0x0 }, // 8430 + { PseudoVSOXSEG5EI32_V_M2_M1, VSOXSEG5EI32_V, 0x0, 0x0 }, // 8431 + { PseudoVSOXSEG5EI32_V_M2_M1_MASK, VSOXSEG5EI32_V, 0x0, 0x0 }, // 8432 + { PseudoVSOXSEG5EI32_V_M4_M1, VSOXSEG5EI32_V, 0x0, 0x0 }, // 8433 + { PseudoVSOXSEG5EI32_V_M4_M1_MASK, VSOXSEG5EI32_V, 0x0, 0x0 }, // 8434 + { PseudoVSOXSEG5EI32_V_MF2_M1, VSOXSEG5EI32_V, 0x0, 0x0 }, // 8435 + { PseudoVSOXSEG5EI32_V_MF2_M1_MASK, VSOXSEG5EI32_V, 0x0, 0x0 }, // 8436 + { PseudoVSOXSEG5EI32_V_MF2_MF8, VSOXSEG5EI32_V, 0x5, 0x0 }, // 8437 + { PseudoVSOXSEG5EI32_V_MF2_MF8_MASK, VSOXSEG5EI32_V, 0x5, 0x0 }, // 8438 + { PseudoVSOXSEG5EI32_V_M1_MF4, VSOXSEG5EI32_V, 0x6, 0x0 }, // 8439 + { PseudoVSOXSEG5EI32_V_M1_MF4_MASK, VSOXSEG5EI32_V, 0x6, 0x0 }, // 8440 + { PseudoVSOXSEG5EI32_V_MF2_MF4, VSOXSEG5EI32_V, 0x6, 0x0 }, // 8441 + { PseudoVSOXSEG5EI32_V_MF2_MF4_MASK, VSOXSEG5EI32_V, 0x6, 0x0 }, // 8442 + { PseudoVSOXSEG5EI32_V_M1_MF2, VSOXSEG5EI32_V, 0x7, 0x0 }, // 8443 + { PseudoVSOXSEG5EI32_V_M1_MF2_MASK, VSOXSEG5EI32_V, 0x7, 0x0 }, // 8444 + { PseudoVSOXSEG5EI32_V_M2_MF2, VSOXSEG5EI32_V, 0x7, 0x0 }, // 8445 + { PseudoVSOXSEG5EI32_V_M2_MF2_MASK, VSOXSEG5EI32_V, 0x7, 0x0 }, // 8446 + { PseudoVSOXSEG5EI32_V_MF2_MF2, VSOXSEG5EI32_V, 0x7, 0x0 }, // 8447 + { PseudoVSOXSEG5EI32_V_MF2_MF2_MASK, VSOXSEG5EI32_V, 0x7, 0x0 }, // 8448 + { PseudoVSOXSEG5EI64_V_M1_M1, VSOXSEG5EI64_V, 0x0, 0x0 }, // 8449 + { PseudoVSOXSEG5EI64_V_M1_M1_MASK, VSOXSEG5EI64_V, 0x0, 0x0 }, // 8450 + { PseudoVSOXSEG5EI64_V_M2_M1, VSOXSEG5EI64_V, 0x0, 0x0 }, // 8451 + { PseudoVSOXSEG5EI64_V_M2_M1_MASK, VSOXSEG5EI64_V, 0x0, 0x0 }, // 8452 + { PseudoVSOXSEG5EI64_V_M4_M1, VSOXSEG5EI64_V, 0x0, 0x0 }, // 8453 + { PseudoVSOXSEG5EI64_V_M4_M1_MASK, VSOXSEG5EI64_V, 0x0, 0x0 }, // 8454 + { PseudoVSOXSEG5EI64_V_M8_M1, VSOXSEG5EI64_V, 0x0, 0x0 }, // 8455 + { PseudoVSOXSEG5EI64_V_M8_M1_MASK, VSOXSEG5EI64_V, 0x0, 0x0 }, // 8456 + { PseudoVSOXSEG5EI64_V_M1_MF8, VSOXSEG5EI64_V, 0x5, 0x0 }, // 8457 + { PseudoVSOXSEG5EI64_V_M1_MF8_MASK, VSOXSEG5EI64_V, 0x5, 0x0 }, // 8458 + { PseudoVSOXSEG5EI64_V_M1_MF4, VSOXSEG5EI64_V, 0x6, 0x0 }, // 8459 + { PseudoVSOXSEG5EI64_V_M1_MF4_MASK, VSOXSEG5EI64_V, 0x6, 0x0 }, // 8460 + { PseudoVSOXSEG5EI64_V_M2_MF4, VSOXSEG5EI64_V, 0x6, 0x0 }, // 8461 + { PseudoVSOXSEG5EI64_V_M2_MF4_MASK, VSOXSEG5EI64_V, 0x6, 0x0 }, // 8462 + { PseudoVSOXSEG5EI64_V_M1_MF2, VSOXSEG5EI64_V, 0x7, 0x0 }, // 8463 + { PseudoVSOXSEG5EI64_V_M1_MF2_MASK, VSOXSEG5EI64_V, 0x7, 0x0 }, // 8464 + { PseudoVSOXSEG5EI64_V_M2_MF2, VSOXSEG5EI64_V, 0x7, 0x0 }, // 8465 + { PseudoVSOXSEG5EI64_V_M2_MF2_MASK, VSOXSEG5EI64_V, 0x7, 0x0 }, // 8466 + { PseudoVSOXSEG5EI64_V_M4_MF2, VSOXSEG5EI64_V, 0x7, 0x0 }, // 8467 + { PseudoVSOXSEG5EI64_V_M4_MF2_MASK, VSOXSEG5EI64_V, 0x7, 0x0 }, // 8468 + { PseudoVSOXSEG5EI8_V_M1_M1, VSOXSEG5EI8_V, 0x0, 0x0 }, // 8469 + { PseudoVSOXSEG5EI8_V_M1_M1_MASK, VSOXSEG5EI8_V, 0x0, 0x0 }, // 8470 + { PseudoVSOXSEG5EI8_V_MF2_M1, VSOXSEG5EI8_V, 0x0, 0x0 }, // 8471 + { PseudoVSOXSEG5EI8_V_MF2_M1_MASK, VSOXSEG5EI8_V, 0x0, 0x0 }, // 8472 + { PseudoVSOXSEG5EI8_V_MF4_M1, VSOXSEG5EI8_V, 0x0, 0x0 }, // 8473 + { PseudoVSOXSEG5EI8_V_MF4_M1_MASK, VSOXSEG5EI8_V, 0x0, 0x0 }, // 8474 + { PseudoVSOXSEG5EI8_V_MF8_M1, VSOXSEG5EI8_V, 0x0, 0x0 }, // 8475 + { PseudoVSOXSEG5EI8_V_MF8_M1_MASK, VSOXSEG5EI8_V, 0x0, 0x0 }, // 8476 + { PseudoVSOXSEG5EI8_V_MF8_MF8, VSOXSEG5EI8_V, 0x5, 0x0 }, // 8477 + { PseudoVSOXSEG5EI8_V_MF8_MF8_MASK, VSOXSEG5EI8_V, 0x5, 0x0 }, // 8478 + { PseudoVSOXSEG5EI8_V_MF4_MF4, VSOXSEG5EI8_V, 0x6, 0x0 }, // 8479 + { PseudoVSOXSEG5EI8_V_MF4_MF4_MASK, VSOXSEG5EI8_V, 0x6, 0x0 }, // 8480 + { PseudoVSOXSEG5EI8_V_MF8_MF4, VSOXSEG5EI8_V, 0x6, 0x0 }, // 8481 + { PseudoVSOXSEG5EI8_V_MF8_MF4_MASK, VSOXSEG5EI8_V, 0x6, 0x0 }, // 8482 + { PseudoVSOXSEG5EI8_V_MF2_MF2, VSOXSEG5EI8_V, 0x7, 0x0 }, // 8483 + { PseudoVSOXSEG5EI8_V_MF2_MF2_MASK, VSOXSEG5EI8_V, 0x7, 0x0 }, // 8484 + { PseudoVSOXSEG5EI8_V_MF4_MF2, VSOXSEG5EI8_V, 0x7, 0x0 }, // 8485 + { PseudoVSOXSEG5EI8_V_MF4_MF2_MASK, VSOXSEG5EI8_V, 0x7, 0x0 }, // 8486 + { PseudoVSOXSEG5EI8_V_MF8_MF2, VSOXSEG5EI8_V, 0x7, 0x0 }, // 8487 + { PseudoVSOXSEG5EI8_V_MF8_MF2_MASK, VSOXSEG5EI8_V, 0x7, 0x0 }, // 8488 + { PseudoVSOXSEG6EI16_V_M1_M1, VSOXSEG6EI16_V, 0x0, 0x0 }, // 8489 + { PseudoVSOXSEG6EI16_V_M1_M1_MASK, VSOXSEG6EI16_V, 0x0, 0x0 }, // 8490 + { PseudoVSOXSEG6EI16_V_M2_M1, VSOXSEG6EI16_V, 0x0, 0x0 }, // 8491 + { PseudoVSOXSEG6EI16_V_M2_M1_MASK, VSOXSEG6EI16_V, 0x0, 0x0 }, // 8492 + { PseudoVSOXSEG6EI16_V_MF2_M1, VSOXSEG6EI16_V, 0x0, 0x0 }, // 8493 + { PseudoVSOXSEG6EI16_V_MF2_M1_MASK, VSOXSEG6EI16_V, 0x0, 0x0 }, // 8494 + { PseudoVSOXSEG6EI16_V_MF4_M1, VSOXSEG6EI16_V, 0x0, 0x0 }, // 8495 + { PseudoVSOXSEG6EI16_V_MF4_M1_MASK, VSOXSEG6EI16_V, 0x0, 0x0 }, // 8496 + { PseudoVSOXSEG6EI16_V_MF4_MF8, VSOXSEG6EI16_V, 0x5, 0x0 }, // 8497 + { PseudoVSOXSEG6EI16_V_MF4_MF8_MASK, VSOXSEG6EI16_V, 0x5, 0x0 }, // 8498 + { PseudoVSOXSEG6EI16_V_MF2_MF4, VSOXSEG6EI16_V, 0x6, 0x0 }, // 8499 + { PseudoVSOXSEG6EI16_V_MF2_MF4_MASK, VSOXSEG6EI16_V, 0x6, 0x0 }, // 8500 + { PseudoVSOXSEG6EI16_V_MF4_MF4, VSOXSEG6EI16_V, 0x6, 0x0 }, // 8501 + { PseudoVSOXSEG6EI16_V_MF4_MF4_MASK, VSOXSEG6EI16_V, 0x6, 0x0 }, // 8502 + { PseudoVSOXSEG6EI16_V_M1_MF2, VSOXSEG6EI16_V, 0x7, 0x0 }, // 8503 + { PseudoVSOXSEG6EI16_V_M1_MF2_MASK, VSOXSEG6EI16_V, 0x7, 0x0 }, // 8504 + { PseudoVSOXSEG6EI16_V_MF2_MF2, VSOXSEG6EI16_V, 0x7, 0x0 }, // 8505 + { PseudoVSOXSEG6EI16_V_MF2_MF2_MASK, VSOXSEG6EI16_V, 0x7, 0x0 }, // 8506 + { PseudoVSOXSEG6EI16_V_MF4_MF2, VSOXSEG6EI16_V, 0x7, 0x0 }, // 8507 + { PseudoVSOXSEG6EI16_V_MF4_MF2_MASK, VSOXSEG6EI16_V, 0x7, 0x0 }, // 8508 + { PseudoVSOXSEG6EI32_V_M1_M1, VSOXSEG6EI32_V, 0x0, 0x0 }, // 8509 + { PseudoVSOXSEG6EI32_V_M1_M1_MASK, VSOXSEG6EI32_V, 0x0, 0x0 }, // 8510 + { PseudoVSOXSEG6EI32_V_M2_M1, VSOXSEG6EI32_V, 0x0, 0x0 }, // 8511 + { PseudoVSOXSEG6EI32_V_M2_M1_MASK, VSOXSEG6EI32_V, 0x0, 0x0 }, // 8512 + { PseudoVSOXSEG6EI32_V_M4_M1, VSOXSEG6EI32_V, 0x0, 0x0 }, // 8513 + { PseudoVSOXSEG6EI32_V_M4_M1_MASK, VSOXSEG6EI32_V, 0x0, 0x0 }, // 8514 + { PseudoVSOXSEG6EI32_V_MF2_M1, VSOXSEG6EI32_V, 0x0, 0x0 }, // 8515 + { PseudoVSOXSEG6EI32_V_MF2_M1_MASK, VSOXSEG6EI32_V, 0x0, 0x0 }, // 8516 + { PseudoVSOXSEG6EI32_V_MF2_MF8, VSOXSEG6EI32_V, 0x5, 0x0 }, // 8517 + { PseudoVSOXSEG6EI32_V_MF2_MF8_MASK, VSOXSEG6EI32_V, 0x5, 0x0 }, // 8518 + { PseudoVSOXSEG6EI32_V_M1_MF4, VSOXSEG6EI32_V, 0x6, 0x0 }, // 8519 + { PseudoVSOXSEG6EI32_V_M1_MF4_MASK, VSOXSEG6EI32_V, 0x6, 0x0 }, // 8520 + { PseudoVSOXSEG6EI32_V_MF2_MF4, VSOXSEG6EI32_V, 0x6, 0x0 }, // 8521 + { PseudoVSOXSEG6EI32_V_MF2_MF4_MASK, VSOXSEG6EI32_V, 0x6, 0x0 }, // 8522 + { PseudoVSOXSEG6EI32_V_M1_MF2, VSOXSEG6EI32_V, 0x7, 0x0 }, // 8523 + { PseudoVSOXSEG6EI32_V_M1_MF2_MASK, VSOXSEG6EI32_V, 0x7, 0x0 }, // 8524 + { PseudoVSOXSEG6EI32_V_M2_MF2, VSOXSEG6EI32_V, 0x7, 0x0 }, // 8525 + { PseudoVSOXSEG6EI32_V_M2_MF2_MASK, VSOXSEG6EI32_V, 0x7, 0x0 }, // 8526 + { PseudoVSOXSEG6EI32_V_MF2_MF2, VSOXSEG6EI32_V, 0x7, 0x0 }, // 8527 + { PseudoVSOXSEG6EI32_V_MF2_MF2_MASK, VSOXSEG6EI32_V, 0x7, 0x0 }, // 8528 + { PseudoVSOXSEG6EI64_V_M1_M1, VSOXSEG6EI64_V, 0x0, 0x0 }, // 8529 + { PseudoVSOXSEG6EI64_V_M1_M1_MASK, VSOXSEG6EI64_V, 0x0, 0x0 }, // 8530 + { PseudoVSOXSEG6EI64_V_M2_M1, VSOXSEG6EI64_V, 0x0, 0x0 }, // 8531 + { PseudoVSOXSEG6EI64_V_M2_M1_MASK, VSOXSEG6EI64_V, 0x0, 0x0 }, // 8532 + { PseudoVSOXSEG6EI64_V_M4_M1, VSOXSEG6EI64_V, 0x0, 0x0 }, // 8533 + { PseudoVSOXSEG6EI64_V_M4_M1_MASK, VSOXSEG6EI64_V, 0x0, 0x0 }, // 8534 + { PseudoVSOXSEG6EI64_V_M8_M1, VSOXSEG6EI64_V, 0x0, 0x0 }, // 8535 + { PseudoVSOXSEG6EI64_V_M8_M1_MASK, VSOXSEG6EI64_V, 0x0, 0x0 }, // 8536 + { PseudoVSOXSEG6EI64_V_M1_MF8, VSOXSEG6EI64_V, 0x5, 0x0 }, // 8537 + { PseudoVSOXSEG6EI64_V_M1_MF8_MASK, VSOXSEG6EI64_V, 0x5, 0x0 }, // 8538 + { PseudoVSOXSEG6EI64_V_M1_MF4, VSOXSEG6EI64_V, 0x6, 0x0 }, // 8539 + { PseudoVSOXSEG6EI64_V_M1_MF4_MASK, VSOXSEG6EI64_V, 0x6, 0x0 }, // 8540 + { PseudoVSOXSEG6EI64_V_M2_MF4, VSOXSEG6EI64_V, 0x6, 0x0 }, // 8541 + { PseudoVSOXSEG6EI64_V_M2_MF4_MASK, VSOXSEG6EI64_V, 0x6, 0x0 }, // 8542 + { PseudoVSOXSEG6EI64_V_M1_MF2, VSOXSEG6EI64_V, 0x7, 0x0 }, // 8543 + { PseudoVSOXSEG6EI64_V_M1_MF2_MASK, VSOXSEG6EI64_V, 0x7, 0x0 }, // 8544 + { PseudoVSOXSEG6EI64_V_M2_MF2, VSOXSEG6EI64_V, 0x7, 0x0 }, // 8545 + { PseudoVSOXSEG6EI64_V_M2_MF2_MASK, VSOXSEG6EI64_V, 0x7, 0x0 }, // 8546 + { PseudoVSOXSEG6EI64_V_M4_MF2, VSOXSEG6EI64_V, 0x7, 0x0 }, // 8547 + { PseudoVSOXSEG6EI64_V_M4_MF2_MASK, VSOXSEG6EI64_V, 0x7, 0x0 }, // 8548 + { PseudoVSOXSEG6EI8_V_M1_M1, VSOXSEG6EI8_V, 0x0, 0x0 }, // 8549 + { PseudoVSOXSEG6EI8_V_M1_M1_MASK, VSOXSEG6EI8_V, 0x0, 0x0 }, // 8550 + { PseudoVSOXSEG6EI8_V_MF2_M1, VSOXSEG6EI8_V, 0x0, 0x0 }, // 8551 + { PseudoVSOXSEG6EI8_V_MF2_M1_MASK, VSOXSEG6EI8_V, 0x0, 0x0 }, // 8552 + { PseudoVSOXSEG6EI8_V_MF4_M1, VSOXSEG6EI8_V, 0x0, 0x0 }, // 8553 + { PseudoVSOXSEG6EI8_V_MF4_M1_MASK, VSOXSEG6EI8_V, 0x0, 0x0 }, // 8554 + { PseudoVSOXSEG6EI8_V_MF8_M1, VSOXSEG6EI8_V, 0x0, 0x0 }, // 8555 + { PseudoVSOXSEG6EI8_V_MF8_M1_MASK, VSOXSEG6EI8_V, 0x0, 0x0 }, // 8556 + { PseudoVSOXSEG6EI8_V_MF8_MF8, VSOXSEG6EI8_V, 0x5, 0x0 }, // 8557 + { PseudoVSOXSEG6EI8_V_MF8_MF8_MASK, VSOXSEG6EI8_V, 0x5, 0x0 }, // 8558 + { PseudoVSOXSEG6EI8_V_MF4_MF4, VSOXSEG6EI8_V, 0x6, 0x0 }, // 8559 + { PseudoVSOXSEG6EI8_V_MF4_MF4_MASK, VSOXSEG6EI8_V, 0x6, 0x0 }, // 8560 + { PseudoVSOXSEG6EI8_V_MF8_MF4, VSOXSEG6EI8_V, 0x6, 0x0 }, // 8561 + { PseudoVSOXSEG6EI8_V_MF8_MF4_MASK, VSOXSEG6EI8_V, 0x6, 0x0 }, // 8562 + { PseudoVSOXSEG6EI8_V_MF2_MF2, VSOXSEG6EI8_V, 0x7, 0x0 }, // 8563 + { PseudoVSOXSEG6EI8_V_MF2_MF2_MASK, VSOXSEG6EI8_V, 0x7, 0x0 }, // 8564 + { PseudoVSOXSEG6EI8_V_MF4_MF2, VSOXSEG6EI8_V, 0x7, 0x0 }, // 8565 + { PseudoVSOXSEG6EI8_V_MF4_MF2_MASK, VSOXSEG6EI8_V, 0x7, 0x0 }, // 8566 + { PseudoVSOXSEG6EI8_V_MF8_MF2, VSOXSEG6EI8_V, 0x7, 0x0 }, // 8567 + { PseudoVSOXSEG6EI8_V_MF8_MF2_MASK, VSOXSEG6EI8_V, 0x7, 0x0 }, // 8568 + { PseudoVSOXSEG7EI16_V_M1_M1, VSOXSEG7EI16_V, 0x0, 0x0 }, // 8569 + { PseudoVSOXSEG7EI16_V_M1_M1_MASK, VSOXSEG7EI16_V, 0x0, 0x0 }, // 8570 + { PseudoVSOXSEG7EI16_V_M2_M1, VSOXSEG7EI16_V, 0x0, 0x0 }, // 8571 + { PseudoVSOXSEG7EI16_V_M2_M1_MASK, VSOXSEG7EI16_V, 0x0, 0x0 }, // 8572 + { PseudoVSOXSEG7EI16_V_MF2_M1, VSOXSEG7EI16_V, 0x0, 0x0 }, // 8573 + { PseudoVSOXSEG7EI16_V_MF2_M1_MASK, VSOXSEG7EI16_V, 0x0, 0x0 }, // 8574 + { PseudoVSOXSEG7EI16_V_MF4_M1, VSOXSEG7EI16_V, 0x0, 0x0 }, // 8575 + { PseudoVSOXSEG7EI16_V_MF4_M1_MASK, VSOXSEG7EI16_V, 0x0, 0x0 }, // 8576 + { PseudoVSOXSEG7EI16_V_MF4_MF8, VSOXSEG7EI16_V, 0x5, 0x0 }, // 8577 + { PseudoVSOXSEG7EI16_V_MF4_MF8_MASK, VSOXSEG7EI16_V, 0x5, 0x0 }, // 8578 + { PseudoVSOXSEG7EI16_V_MF2_MF4, VSOXSEG7EI16_V, 0x6, 0x0 }, // 8579 + { PseudoVSOXSEG7EI16_V_MF2_MF4_MASK, VSOXSEG7EI16_V, 0x6, 0x0 }, // 8580 + { PseudoVSOXSEG7EI16_V_MF4_MF4, VSOXSEG7EI16_V, 0x6, 0x0 }, // 8581 + { PseudoVSOXSEG7EI16_V_MF4_MF4_MASK, VSOXSEG7EI16_V, 0x6, 0x0 }, // 8582 + { PseudoVSOXSEG7EI16_V_M1_MF2, VSOXSEG7EI16_V, 0x7, 0x0 }, // 8583 + { PseudoVSOXSEG7EI16_V_M1_MF2_MASK, VSOXSEG7EI16_V, 0x7, 0x0 }, // 8584 + { PseudoVSOXSEG7EI16_V_MF2_MF2, VSOXSEG7EI16_V, 0x7, 0x0 }, // 8585 + { PseudoVSOXSEG7EI16_V_MF2_MF2_MASK, VSOXSEG7EI16_V, 0x7, 0x0 }, // 8586 + { PseudoVSOXSEG7EI16_V_MF4_MF2, VSOXSEG7EI16_V, 0x7, 0x0 }, // 8587 + { PseudoVSOXSEG7EI16_V_MF4_MF2_MASK, VSOXSEG7EI16_V, 0x7, 0x0 }, // 8588 + { PseudoVSOXSEG7EI32_V_M1_M1, VSOXSEG7EI32_V, 0x0, 0x0 }, // 8589 + { PseudoVSOXSEG7EI32_V_M1_M1_MASK, VSOXSEG7EI32_V, 0x0, 0x0 }, // 8590 + { PseudoVSOXSEG7EI32_V_M2_M1, VSOXSEG7EI32_V, 0x0, 0x0 }, // 8591 + { PseudoVSOXSEG7EI32_V_M2_M1_MASK, VSOXSEG7EI32_V, 0x0, 0x0 }, // 8592 + { PseudoVSOXSEG7EI32_V_M4_M1, VSOXSEG7EI32_V, 0x0, 0x0 }, // 8593 + { PseudoVSOXSEG7EI32_V_M4_M1_MASK, VSOXSEG7EI32_V, 0x0, 0x0 }, // 8594 + { PseudoVSOXSEG7EI32_V_MF2_M1, VSOXSEG7EI32_V, 0x0, 0x0 }, // 8595 + { PseudoVSOXSEG7EI32_V_MF2_M1_MASK, VSOXSEG7EI32_V, 0x0, 0x0 }, // 8596 + { PseudoVSOXSEG7EI32_V_MF2_MF8, VSOXSEG7EI32_V, 0x5, 0x0 }, // 8597 + { PseudoVSOXSEG7EI32_V_MF2_MF8_MASK, VSOXSEG7EI32_V, 0x5, 0x0 }, // 8598 + { PseudoVSOXSEG7EI32_V_M1_MF4, VSOXSEG7EI32_V, 0x6, 0x0 }, // 8599 + { PseudoVSOXSEG7EI32_V_M1_MF4_MASK, VSOXSEG7EI32_V, 0x6, 0x0 }, // 8600 + { PseudoVSOXSEG7EI32_V_MF2_MF4, VSOXSEG7EI32_V, 0x6, 0x0 }, // 8601 + { PseudoVSOXSEG7EI32_V_MF2_MF4_MASK, VSOXSEG7EI32_V, 0x6, 0x0 }, // 8602 + { PseudoVSOXSEG7EI32_V_M1_MF2, VSOXSEG7EI32_V, 0x7, 0x0 }, // 8603 + { PseudoVSOXSEG7EI32_V_M1_MF2_MASK, VSOXSEG7EI32_V, 0x7, 0x0 }, // 8604 + { PseudoVSOXSEG7EI32_V_M2_MF2, VSOXSEG7EI32_V, 0x7, 0x0 }, // 8605 + { PseudoVSOXSEG7EI32_V_M2_MF2_MASK, VSOXSEG7EI32_V, 0x7, 0x0 }, // 8606 + { PseudoVSOXSEG7EI32_V_MF2_MF2, VSOXSEG7EI32_V, 0x7, 0x0 }, // 8607 + { PseudoVSOXSEG7EI32_V_MF2_MF2_MASK, VSOXSEG7EI32_V, 0x7, 0x0 }, // 8608 + { PseudoVSOXSEG7EI64_V_M1_M1, VSOXSEG7EI64_V, 0x0, 0x0 }, // 8609 + { PseudoVSOXSEG7EI64_V_M1_M1_MASK, VSOXSEG7EI64_V, 0x0, 0x0 }, // 8610 + { PseudoVSOXSEG7EI64_V_M2_M1, VSOXSEG7EI64_V, 0x0, 0x0 }, // 8611 + { PseudoVSOXSEG7EI64_V_M2_M1_MASK, VSOXSEG7EI64_V, 0x0, 0x0 }, // 8612 + { PseudoVSOXSEG7EI64_V_M4_M1, VSOXSEG7EI64_V, 0x0, 0x0 }, // 8613 + { PseudoVSOXSEG7EI64_V_M4_M1_MASK, VSOXSEG7EI64_V, 0x0, 0x0 }, // 8614 + { PseudoVSOXSEG7EI64_V_M8_M1, VSOXSEG7EI64_V, 0x0, 0x0 }, // 8615 + { PseudoVSOXSEG7EI64_V_M8_M1_MASK, VSOXSEG7EI64_V, 0x0, 0x0 }, // 8616 + { PseudoVSOXSEG7EI64_V_M1_MF8, VSOXSEG7EI64_V, 0x5, 0x0 }, // 8617 + { PseudoVSOXSEG7EI64_V_M1_MF8_MASK, VSOXSEG7EI64_V, 0x5, 0x0 }, // 8618 + { PseudoVSOXSEG7EI64_V_M1_MF4, VSOXSEG7EI64_V, 0x6, 0x0 }, // 8619 + { PseudoVSOXSEG7EI64_V_M1_MF4_MASK, VSOXSEG7EI64_V, 0x6, 0x0 }, // 8620 + { PseudoVSOXSEG7EI64_V_M2_MF4, VSOXSEG7EI64_V, 0x6, 0x0 }, // 8621 + { PseudoVSOXSEG7EI64_V_M2_MF4_MASK, VSOXSEG7EI64_V, 0x6, 0x0 }, // 8622 + { PseudoVSOXSEG7EI64_V_M1_MF2, VSOXSEG7EI64_V, 0x7, 0x0 }, // 8623 + { PseudoVSOXSEG7EI64_V_M1_MF2_MASK, VSOXSEG7EI64_V, 0x7, 0x0 }, // 8624 + { PseudoVSOXSEG7EI64_V_M2_MF2, VSOXSEG7EI64_V, 0x7, 0x0 }, // 8625 + { PseudoVSOXSEG7EI64_V_M2_MF2_MASK, VSOXSEG7EI64_V, 0x7, 0x0 }, // 8626 + { PseudoVSOXSEG7EI64_V_M4_MF2, VSOXSEG7EI64_V, 0x7, 0x0 }, // 8627 + { PseudoVSOXSEG7EI64_V_M4_MF2_MASK, VSOXSEG7EI64_V, 0x7, 0x0 }, // 8628 + { PseudoVSOXSEG7EI8_V_M1_M1, VSOXSEG7EI8_V, 0x0, 0x0 }, // 8629 + { PseudoVSOXSEG7EI8_V_M1_M1_MASK, VSOXSEG7EI8_V, 0x0, 0x0 }, // 8630 + { PseudoVSOXSEG7EI8_V_MF2_M1, VSOXSEG7EI8_V, 0x0, 0x0 }, // 8631 + { PseudoVSOXSEG7EI8_V_MF2_M1_MASK, VSOXSEG7EI8_V, 0x0, 0x0 }, // 8632 + { PseudoVSOXSEG7EI8_V_MF4_M1, VSOXSEG7EI8_V, 0x0, 0x0 }, // 8633 + { PseudoVSOXSEG7EI8_V_MF4_M1_MASK, VSOXSEG7EI8_V, 0x0, 0x0 }, // 8634 + { PseudoVSOXSEG7EI8_V_MF8_M1, VSOXSEG7EI8_V, 0x0, 0x0 }, // 8635 + { PseudoVSOXSEG7EI8_V_MF8_M1_MASK, VSOXSEG7EI8_V, 0x0, 0x0 }, // 8636 + { PseudoVSOXSEG7EI8_V_MF8_MF8, VSOXSEG7EI8_V, 0x5, 0x0 }, // 8637 + { PseudoVSOXSEG7EI8_V_MF8_MF8_MASK, VSOXSEG7EI8_V, 0x5, 0x0 }, // 8638 + { PseudoVSOXSEG7EI8_V_MF4_MF4, VSOXSEG7EI8_V, 0x6, 0x0 }, // 8639 + { PseudoVSOXSEG7EI8_V_MF4_MF4_MASK, VSOXSEG7EI8_V, 0x6, 0x0 }, // 8640 + { PseudoVSOXSEG7EI8_V_MF8_MF4, VSOXSEG7EI8_V, 0x6, 0x0 }, // 8641 + { PseudoVSOXSEG7EI8_V_MF8_MF4_MASK, VSOXSEG7EI8_V, 0x6, 0x0 }, // 8642 + { PseudoVSOXSEG7EI8_V_MF2_MF2, VSOXSEG7EI8_V, 0x7, 0x0 }, // 8643 + { PseudoVSOXSEG7EI8_V_MF2_MF2_MASK, VSOXSEG7EI8_V, 0x7, 0x0 }, // 8644 + { PseudoVSOXSEG7EI8_V_MF4_MF2, VSOXSEG7EI8_V, 0x7, 0x0 }, // 8645 + { PseudoVSOXSEG7EI8_V_MF4_MF2_MASK, VSOXSEG7EI8_V, 0x7, 0x0 }, // 8646 + { PseudoVSOXSEG7EI8_V_MF8_MF2, VSOXSEG7EI8_V, 0x7, 0x0 }, // 8647 + { PseudoVSOXSEG7EI8_V_MF8_MF2_MASK, VSOXSEG7EI8_V, 0x7, 0x0 }, // 8648 + { PseudoVSOXSEG8EI16_V_M1_M1, VSOXSEG8EI16_V, 0x0, 0x0 }, // 8649 + { PseudoVSOXSEG8EI16_V_M1_M1_MASK, VSOXSEG8EI16_V, 0x0, 0x0 }, // 8650 + { PseudoVSOXSEG8EI16_V_M2_M1, VSOXSEG8EI16_V, 0x0, 0x0 }, // 8651 + { PseudoVSOXSEG8EI16_V_M2_M1_MASK, VSOXSEG8EI16_V, 0x0, 0x0 }, // 8652 + { PseudoVSOXSEG8EI16_V_MF2_M1, VSOXSEG8EI16_V, 0x0, 0x0 }, // 8653 + { PseudoVSOXSEG8EI16_V_MF2_M1_MASK, VSOXSEG8EI16_V, 0x0, 0x0 }, // 8654 + { PseudoVSOXSEG8EI16_V_MF4_M1, VSOXSEG8EI16_V, 0x0, 0x0 }, // 8655 + { PseudoVSOXSEG8EI16_V_MF4_M1_MASK, VSOXSEG8EI16_V, 0x0, 0x0 }, // 8656 + { PseudoVSOXSEG8EI16_V_MF4_MF8, VSOXSEG8EI16_V, 0x5, 0x0 }, // 8657 + { PseudoVSOXSEG8EI16_V_MF4_MF8_MASK, VSOXSEG8EI16_V, 0x5, 0x0 }, // 8658 + { PseudoVSOXSEG8EI16_V_MF2_MF4, VSOXSEG8EI16_V, 0x6, 0x0 }, // 8659 + { PseudoVSOXSEG8EI16_V_MF2_MF4_MASK, VSOXSEG8EI16_V, 0x6, 0x0 }, // 8660 + { PseudoVSOXSEG8EI16_V_MF4_MF4, VSOXSEG8EI16_V, 0x6, 0x0 }, // 8661 + { PseudoVSOXSEG8EI16_V_MF4_MF4_MASK, VSOXSEG8EI16_V, 0x6, 0x0 }, // 8662 + { PseudoVSOXSEG8EI16_V_M1_MF2, VSOXSEG8EI16_V, 0x7, 0x0 }, // 8663 + { PseudoVSOXSEG8EI16_V_M1_MF2_MASK, VSOXSEG8EI16_V, 0x7, 0x0 }, // 8664 + { PseudoVSOXSEG8EI16_V_MF2_MF2, VSOXSEG8EI16_V, 0x7, 0x0 }, // 8665 + { PseudoVSOXSEG8EI16_V_MF2_MF2_MASK, VSOXSEG8EI16_V, 0x7, 0x0 }, // 8666 + { PseudoVSOXSEG8EI16_V_MF4_MF2, VSOXSEG8EI16_V, 0x7, 0x0 }, // 8667 + { PseudoVSOXSEG8EI16_V_MF4_MF2_MASK, VSOXSEG8EI16_V, 0x7, 0x0 }, // 8668 + { PseudoVSOXSEG8EI32_V_M1_M1, VSOXSEG8EI32_V, 0x0, 0x0 }, // 8669 + { PseudoVSOXSEG8EI32_V_M1_M1_MASK, VSOXSEG8EI32_V, 0x0, 0x0 }, // 8670 + { PseudoVSOXSEG8EI32_V_M2_M1, VSOXSEG8EI32_V, 0x0, 0x0 }, // 8671 + { PseudoVSOXSEG8EI32_V_M2_M1_MASK, VSOXSEG8EI32_V, 0x0, 0x0 }, // 8672 + { PseudoVSOXSEG8EI32_V_M4_M1, VSOXSEG8EI32_V, 0x0, 0x0 }, // 8673 + { PseudoVSOXSEG8EI32_V_M4_M1_MASK, VSOXSEG8EI32_V, 0x0, 0x0 }, // 8674 + { PseudoVSOXSEG8EI32_V_MF2_M1, VSOXSEG8EI32_V, 0x0, 0x0 }, // 8675 + { PseudoVSOXSEG8EI32_V_MF2_M1_MASK, VSOXSEG8EI32_V, 0x0, 0x0 }, // 8676 + { PseudoVSOXSEG8EI32_V_MF2_MF8, VSOXSEG8EI32_V, 0x5, 0x0 }, // 8677 + { PseudoVSOXSEG8EI32_V_MF2_MF8_MASK, VSOXSEG8EI32_V, 0x5, 0x0 }, // 8678 + { PseudoVSOXSEG8EI32_V_M1_MF4, VSOXSEG8EI32_V, 0x6, 0x0 }, // 8679 + { PseudoVSOXSEG8EI32_V_M1_MF4_MASK, VSOXSEG8EI32_V, 0x6, 0x0 }, // 8680 + { PseudoVSOXSEG8EI32_V_MF2_MF4, VSOXSEG8EI32_V, 0x6, 0x0 }, // 8681 + { PseudoVSOXSEG8EI32_V_MF2_MF4_MASK, VSOXSEG8EI32_V, 0x6, 0x0 }, // 8682 + { PseudoVSOXSEG8EI32_V_M1_MF2, VSOXSEG8EI32_V, 0x7, 0x0 }, // 8683 + { PseudoVSOXSEG8EI32_V_M1_MF2_MASK, VSOXSEG8EI32_V, 0x7, 0x0 }, // 8684 + { PseudoVSOXSEG8EI32_V_M2_MF2, VSOXSEG8EI32_V, 0x7, 0x0 }, // 8685 + { PseudoVSOXSEG8EI32_V_M2_MF2_MASK, VSOXSEG8EI32_V, 0x7, 0x0 }, // 8686 + { PseudoVSOXSEG8EI32_V_MF2_MF2, VSOXSEG8EI32_V, 0x7, 0x0 }, // 8687 + { PseudoVSOXSEG8EI32_V_MF2_MF2_MASK, VSOXSEG8EI32_V, 0x7, 0x0 }, // 8688 + { PseudoVSOXSEG8EI64_V_M1_M1, VSOXSEG8EI64_V, 0x0, 0x0 }, // 8689 + { PseudoVSOXSEG8EI64_V_M1_M1_MASK, VSOXSEG8EI64_V, 0x0, 0x0 }, // 8690 + { PseudoVSOXSEG8EI64_V_M2_M1, VSOXSEG8EI64_V, 0x0, 0x0 }, // 8691 + { PseudoVSOXSEG8EI64_V_M2_M1_MASK, VSOXSEG8EI64_V, 0x0, 0x0 }, // 8692 + { PseudoVSOXSEG8EI64_V_M4_M1, VSOXSEG8EI64_V, 0x0, 0x0 }, // 8693 + { PseudoVSOXSEG8EI64_V_M4_M1_MASK, VSOXSEG8EI64_V, 0x0, 0x0 }, // 8694 + { PseudoVSOXSEG8EI64_V_M8_M1, VSOXSEG8EI64_V, 0x0, 0x0 }, // 8695 + { PseudoVSOXSEG8EI64_V_M8_M1_MASK, VSOXSEG8EI64_V, 0x0, 0x0 }, // 8696 + { PseudoVSOXSEG8EI64_V_M1_MF8, VSOXSEG8EI64_V, 0x5, 0x0 }, // 8697 + { PseudoVSOXSEG8EI64_V_M1_MF8_MASK, VSOXSEG8EI64_V, 0x5, 0x0 }, // 8698 + { PseudoVSOXSEG8EI64_V_M1_MF4, VSOXSEG8EI64_V, 0x6, 0x0 }, // 8699 + { PseudoVSOXSEG8EI64_V_M1_MF4_MASK, VSOXSEG8EI64_V, 0x6, 0x0 }, // 8700 + { PseudoVSOXSEG8EI64_V_M2_MF4, VSOXSEG8EI64_V, 0x6, 0x0 }, // 8701 + { PseudoVSOXSEG8EI64_V_M2_MF4_MASK, VSOXSEG8EI64_V, 0x6, 0x0 }, // 8702 + { PseudoVSOXSEG8EI64_V_M1_MF2, VSOXSEG8EI64_V, 0x7, 0x0 }, // 8703 + { PseudoVSOXSEG8EI64_V_M1_MF2_MASK, VSOXSEG8EI64_V, 0x7, 0x0 }, // 8704 + { PseudoVSOXSEG8EI64_V_M2_MF2, VSOXSEG8EI64_V, 0x7, 0x0 }, // 8705 + { PseudoVSOXSEG8EI64_V_M2_MF2_MASK, VSOXSEG8EI64_V, 0x7, 0x0 }, // 8706 + { PseudoVSOXSEG8EI64_V_M4_MF2, VSOXSEG8EI64_V, 0x7, 0x0 }, // 8707 + { PseudoVSOXSEG8EI64_V_M4_MF2_MASK, VSOXSEG8EI64_V, 0x7, 0x0 }, // 8708 + { PseudoVSOXSEG8EI8_V_M1_M1, VSOXSEG8EI8_V, 0x0, 0x0 }, // 8709 + { PseudoVSOXSEG8EI8_V_M1_M1_MASK, VSOXSEG8EI8_V, 0x0, 0x0 }, // 8710 + { PseudoVSOXSEG8EI8_V_MF2_M1, VSOXSEG8EI8_V, 0x0, 0x0 }, // 8711 + { PseudoVSOXSEG8EI8_V_MF2_M1_MASK, VSOXSEG8EI8_V, 0x0, 0x0 }, // 8712 + { PseudoVSOXSEG8EI8_V_MF4_M1, VSOXSEG8EI8_V, 0x0, 0x0 }, // 8713 + { PseudoVSOXSEG8EI8_V_MF4_M1_MASK, VSOXSEG8EI8_V, 0x0, 0x0 }, // 8714 + { PseudoVSOXSEG8EI8_V_MF8_M1, VSOXSEG8EI8_V, 0x0, 0x0 }, // 8715 + { PseudoVSOXSEG8EI8_V_MF8_M1_MASK, VSOXSEG8EI8_V, 0x0, 0x0 }, // 8716 + { PseudoVSOXSEG8EI8_V_MF8_MF8, VSOXSEG8EI8_V, 0x5, 0x0 }, // 8717 + { PseudoVSOXSEG8EI8_V_MF8_MF8_MASK, VSOXSEG8EI8_V, 0x5, 0x0 }, // 8718 + { PseudoVSOXSEG8EI8_V_MF4_MF4, VSOXSEG8EI8_V, 0x6, 0x0 }, // 8719 + { PseudoVSOXSEG8EI8_V_MF4_MF4_MASK, VSOXSEG8EI8_V, 0x6, 0x0 }, // 8720 + { PseudoVSOXSEG8EI8_V_MF8_MF4, VSOXSEG8EI8_V, 0x6, 0x0 }, // 8721 + { PseudoVSOXSEG8EI8_V_MF8_MF4_MASK, VSOXSEG8EI8_V, 0x6, 0x0 }, // 8722 + { PseudoVSOXSEG8EI8_V_MF2_MF2, VSOXSEG8EI8_V, 0x7, 0x0 }, // 8723 + { PseudoVSOXSEG8EI8_V_MF2_MF2_MASK, VSOXSEG8EI8_V, 0x7, 0x0 }, // 8724 + { PseudoVSOXSEG8EI8_V_MF4_MF2, VSOXSEG8EI8_V, 0x7, 0x0 }, // 8725 + { PseudoVSOXSEG8EI8_V_MF4_MF2_MASK, VSOXSEG8EI8_V, 0x7, 0x0 }, // 8726 + { PseudoVSOXSEG8EI8_V_MF8_MF2, VSOXSEG8EI8_V, 0x7, 0x0 }, // 8727 + { PseudoVSOXSEG8EI8_V_MF8_MF2_MASK, VSOXSEG8EI8_V, 0x7, 0x0 }, // 8728 + { PseudoVSRA_VI_M1, VSRA_VI, 0x0, 0x0 }, // 8729 + { PseudoVSRA_VI_M1_MASK, VSRA_VI, 0x0, 0x0 }, // 8730 + { PseudoVSRA_VI_M2, VSRA_VI, 0x1, 0x0 }, // 8731 + { PseudoVSRA_VI_M2_MASK, VSRA_VI, 0x1, 0x0 }, // 8732 + { PseudoVSRA_VI_M4, VSRA_VI, 0x2, 0x0 }, // 8733 + { PseudoVSRA_VI_M4_MASK, VSRA_VI, 0x2, 0x0 }, // 8734 + { PseudoVSRA_VI_M8, VSRA_VI, 0x3, 0x0 }, // 8735 + { PseudoVSRA_VI_M8_MASK, VSRA_VI, 0x3, 0x0 }, // 8736 + { PseudoVSRA_VI_MF8, VSRA_VI, 0x5, 0x0 }, // 8737 + { PseudoVSRA_VI_MF8_MASK, VSRA_VI, 0x5, 0x0 }, // 8738 + { PseudoVSRA_VI_MF4, VSRA_VI, 0x6, 0x0 }, // 8739 + { PseudoVSRA_VI_MF4_MASK, VSRA_VI, 0x6, 0x0 }, // 8740 + { PseudoVSRA_VI_MF2, VSRA_VI, 0x7, 0x0 }, // 8741 + { PseudoVSRA_VI_MF2_MASK, VSRA_VI, 0x7, 0x0 }, // 8742 + { PseudoVSRA_VV_M1, VSRA_VV, 0x0, 0x0 }, // 8743 + { PseudoVSRA_VV_M1_MASK, VSRA_VV, 0x0, 0x0 }, // 8744 + { PseudoVSRA_VV_M2, VSRA_VV, 0x1, 0x0 }, // 8745 + { PseudoVSRA_VV_M2_MASK, VSRA_VV, 0x1, 0x0 }, // 8746 + { PseudoVSRA_VV_M4, VSRA_VV, 0x2, 0x0 }, // 8747 + { PseudoVSRA_VV_M4_MASK, VSRA_VV, 0x2, 0x0 }, // 8748 + { PseudoVSRA_VV_M8, VSRA_VV, 0x3, 0x0 }, // 8749 + { PseudoVSRA_VV_M8_MASK, VSRA_VV, 0x3, 0x0 }, // 8750 + { PseudoVSRA_VV_MF8, VSRA_VV, 0x5, 0x0 }, // 8751 + { PseudoVSRA_VV_MF8_MASK, VSRA_VV, 0x5, 0x0 }, // 8752 + { PseudoVSRA_VV_MF4, VSRA_VV, 0x6, 0x0 }, // 8753 + { PseudoVSRA_VV_MF4_MASK, VSRA_VV, 0x6, 0x0 }, // 8754 + { PseudoVSRA_VV_MF2, VSRA_VV, 0x7, 0x0 }, // 8755 + { PseudoVSRA_VV_MF2_MASK, VSRA_VV, 0x7, 0x0 }, // 8756 + { PseudoVSRA_VX_M1, VSRA_VX, 0x0, 0x0 }, // 8757 + { PseudoVSRA_VX_M1_MASK, VSRA_VX, 0x0, 0x0 }, // 8758 + { PseudoVSRA_VX_M2, VSRA_VX, 0x1, 0x0 }, // 8759 + { PseudoVSRA_VX_M2_MASK, VSRA_VX, 0x1, 0x0 }, // 8760 + { PseudoVSRA_VX_M4, VSRA_VX, 0x2, 0x0 }, // 8761 + { PseudoVSRA_VX_M4_MASK, VSRA_VX, 0x2, 0x0 }, // 8762 + { PseudoVSRA_VX_M8, VSRA_VX, 0x3, 0x0 }, // 8763 + { PseudoVSRA_VX_M8_MASK, VSRA_VX, 0x3, 0x0 }, // 8764 + { PseudoVSRA_VX_MF8, VSRA_VX, 0x5, 0x0 }, // 8765 + { PseudoVSRA_VX_MF8_MASK, VSRA_VX, 0x5, 0x0 }, // 8766 + { PseudoVSRA_VX_MF4, VSRA_VX, 0x6, 0x0 }, // 8767 + { PseudoVSRA_VX_MF4_MASK, VSRA_VX, 0x6, 0x0 }, // 8768 + { PseudoVSRA_VX_MF2, VSRA_VX, 0x7, 0x0 }, // 8769 + { PseudoVSRA_VX_MF2_MASK, VSRA_VX, 0x7, 0x0 }, // 8770 + { PseudoVSRL_VI_M1, VSRL_VI, 0x0, 0x0 }, // 8771 + { PseudoVSRL_VI_M1_MASK, VSRL_VI, 0x0, 0x0 }, // 8772 + { PseudoVSRL_VI_M2, VSRL_VI, 0x1, 0x0 }, // 8773 + { PseudoVSRL_VI_M2_MASK, VSRL_VI, 0x1, 0x0 }, // 8774 + { PseudoVSRL_VI_M4, VSRL_VI, 0x2, 0x0 }, // 8775 + { PseudoVSRL_VI_M4_MASK, VSRL_VI, 0x2, 0x0 }, // 8776 + { PseudoVSRL_VI_M8, VSRL_VI, 0x3, 0x0 }, // 8777 + { PseudoVSRL_VI_M8_MASK, VSRL_VI, 0x3, 0x0 }, // 8778 + { PseudoVSRL_VI_MF8, VSRL_VI, 0x5, 0x0 }, // 8779 + { PseudoVSRL_VI_MF8_MASK, VSRL_VI, 0x5, 0x0 }, // 8780 + { PseudoVSRL_VI_MF4, VSRL_VI, 0x6, 0x0 }, // 8781 + { PseudoVSRL_VI_MF4_MASK, VSRL_VI, 0x6, 0x0 }, // 8782 + { PseudoVSRL_VI_MF2, VSRL_VI, 0x7, 0x0 }, // 8783 + { PseudoVSRL_VI_MF2_MASK, VSRL_VI, 0x7, 0x0 }, // 8784 + { PseudoVSRL_VV_M1, VSRL_VV, 0x0, 0x0 }, // 8785 + { PseudoVSRL_VV_M1_MASK, VSRL_VV, 0x0, 0x0 }, // 8786 + { PseudoVSRL_VV_M2, VSRL_VV, 0x1, 0x0 }, // 8787 + { PseudoVSRL_VV_M2_MASK, VSRL_VV, 0x1, 0x0 }, // 8788 + { PseudoVSRL_VV_M4, VSRL_VV, 0x2, 0x0 }, // 8789 + { PseudoVSRL_VV_M4_MASK, VSRL_VV, 0x2, 0x0 }, // 8790 + { PseudoVSRL_VV_M8, VSRL_VV, 0x3, 0x0 }, // 8791 + { PseudoVSRL_VV_M8_MASK, VSRL_VV, 0x3, 0x0 }, // 8792 + { PseudoVSRL_VV_MF8, VSRL_VV, 0x5, 0x0 }, // 8793 + { PseudoVSRL_VV_MF8_MASK, VSRL_VV, 0x5, 0x0 }, // 8794 + { PseudoVSRL_VV_MF4, VSRL_VV, 0x6, 0x0 }, // 8795 + { PseudoVSRL_VV_MF4_MASK, VSRL_VV, 0x6, 0x0 }, // 8796 + { PseudoVSRL_VV_MF2, VSRL_VV, 0x7, 0x0 }, // 8797 + { PseudoVSRL_VV_MF2_MASK, VSRL_VV, 0x7, 0x0 }, // 8798 + { PseudoVSRL_VX_M1, VSRL_VX, 0x0, 0x0 }, // 8799 + { PseudoVSRL_VX_M1_MASK, VSRL_VX, 0x0, 0x0 }, // 8800 + { PseudoVSRL_VX_M2, VSRL_VX, 0x1, 0x0 }, // 8801 + { PseudoVSRL_VX_M2_MASK, VSRL_VX, 0x1, 0x0 }, // 8802 + { PseudoVSRL_VX_M4, VSRL_VX, 0x2, 0x0 }, // 8803 + { PseudoVSRL_VX_M4_MASK, VSRL_VX, 0x2, 0x0 }, // 8804 + { PseudoVSRL_VX_M8, VSRL_VX, 0x3, 0x0 }, // 8805 + { PseudoVSRL_VX_M8_MASK, VSRL_VX, 0x3, 0x0 }, // 8806 + { PseudoVSRL_VX_MF8, VSRL_VX, 0x5, 0x0 }, // 8807 + { PseudoVSRL_VX_MF8_MASK, VSRL_VX, 0x5, 0x0 }, // 8808 + { PseudoVSRL_VX_MF4, VSRL_VX, 0x6, 0x0 }, // 8809 + { PseudoVSRL_VX_MF4_MASK, VSRL_VX, 0x6, 0x0 }, // 8810 + { PseudoVSRL_VX_MF2, VSRL_VX, 0x7, 0x0 }, // 8811 + { PseudoVSRL_VX_MF2_MASK, VSRL_VX, 0x7, 0x0 }, // 8812 + { PseudoVSSE16_V_M1, VSSE16_V, 0x0, 0x10 }, // 8813 + { PseudoVSSE16_V_M1_MASK, VSSE16_V, 0x0, 0x10 }, // 8814 + { PseudoVSSE16_V_M2, VSSE16_V, 0x1, 0x10 }, // 8815 + { PseudoVSSE16_V_M2_MASK, VSSE16_V, 0x1, 0x10 }, // 8816 + { PseudoVSSE16_V_M4, VSSE16_V, 0x2, 0x10 }, // 8817 + { PseudoVSSE16_V_M4_MASK, VSSE16_V, 0x2, 0x10 }, // 8818 + { PseudoVSSE16_V_M8, VSSE16_V, 0x3, 0x10 }, // 8819 + { PseudoVSSE16_V_M8_MASK, VSSE16_V, 0x3, 0x10 }, // 8820 + { PseudoVSSE16_V_MF4, VSSE16_V, 0x6, 0x10 }, // 8821 + { PseudoVSSE16_V_MF4_MASK, VSSE16_V, 0x6, 0x10 }, // 8822 + { PseudoVSSE16_V_MF2, VSSE16_V, 0x7, 0x10 }, // 8823 + { PseudoVSSE16_V_MF2_MASK, VSSE16_V, 0x7, 0x10 }, // 8824 + { PseudoVSSE32_V_M1, VSSE32_V, 0x0, 0x20 }, // 8825 + { PseudoVSSE32_V_M1_MASK, VSSE32_V, 0x0, 0x20 }, // 8826 + { PseudoVSSE32_V_M2, VSSE32_V, 0x1, 0x20 }, // 8827 + { PseudoVSSE32_V_M2_MASK, VSSE32_V, 0x1, 0x20 }, // 8828 + { PseudoVSSE32_V_M4, VSSE32_V, 0x2, 0x20 }, // 8829 + { PseudoVSSE32_V_M4_MASK, VSSE32_V, 0x2, 0x20 }, // 8830 + { PseudoVSSE32_V_M8, VSSE32_V, 0x3, 0x20 }, // 8831 + { PseudoVSSE32_V_M8_MASK, VSSE32_V, 0x3, 0x20 }, // 8832 + { PseudoVSSE32_V_MF2, VSSE32_V, 0x7, 0x20 }, // 8833 + { PseudoVSSE32_V_MF2_MASK, VSSE32_V, 0x7, 0x20 }, // 8834 + { PseudoVSSE64_V_M1, VSSE64_V, 0x0, 0x40 }, // 8835 + { PseudoVSSE64_V_M1_MASK, VSSE64_V, 0x0, 0x40 }, // 8836 + { PseudoVSSE64_V_M2, VSSE64_V, 0x1, 0x40 }, // 8837 + { PseudoVSSE64_V_M2_MASK, VSSE64_V, 0x1, 0x40 }, // 8838 + { PseudoVSSE64_V_M4, VSSE64_V, 0x2, 0x40 }, // 8839 + { PseudoVSSE64_V_M4_MASK, VSSE64_V, 0x2, 0x40 }, // 8840 + { PseudoVSSE64_V_M8, VSSE64_V, 0x3, 0x40 }, // 8841 + { PseudoVSSE64_V_M8_MASK, VSSE64_V, 0x3, 0x40 }, // 8842 + { PseudoVSSE8_V_M1, VSSE8_V, 0x0, 0x8 }, // 8843 + { PseudoVSSE8_V_M1_MASK, VSSE8_V, 0x0, 0x8 }, // 8844 + { PseudoVSSE8_V_M2, VSSE8_V, 0x1, 0x8 }, // 8845 + { PseudoVSSE8_V_M2_MASK, VSSE8_V, 0x1, 0x8 }, // 8846 + { PseudoVSSE8_V_M4, VSSE8_V, 0x2, 0x8 }, // 8847 + { PseudoVSSE8_V_M4_MASK, VSSE8_V, 0x2, 0x8 }, // 8848 + { PseudoVSSE8_V_M8, VSSE8_V, 0x3, 0x8 }, // 8849 + { PseudoVSSE8_V_M8_MASK, VSSE8_V, 0x3, 0x8 }, // 8850 + { PseudoVSSE8_V_MF8, VSSE8_V, 0x5, 0x8 }, // 8851 + { PseudoVSSE8_V_MF8_MASK, VSSE8_V, 0x5, 0x8 }, // 8852 + { PseudoVSSE8_V_MF4, VSSE8_V, 0x6, 0x8 }, // 8853 + { PseudoVSSE8_V_MF4_MASK, VSSE8_V, 0x6, 0x8 }, // 8854 + { PseudoVSSE8_V_MF2, VSSE8_V, 0x7, 0x8 }, // 8855 + { PseudoVSSE8_V_MF2_MASK, VSSE8_V, 0x7, 0x8 }, // 8856 + { PseudoVSSEG2E16_V_M1, VSSEG2E16_V, 0x0, 0x10 }, // 8857 + { PseudoVSSEG2E16_V_M1_MASK, VSSEG2E16_V, 0x0, 0x10 }, // 8858 + { PseudoVSSEG2E16_V_M2, VSSEG2E16_V, 0x1, 0x10 }, // 8859 + { PseudoVSSEG2E16_V_M2_MASK, VSSEG2E16_V, 0x1, 0x10 }, // 8860 + { PseudoVSSEG2E16_V_M4, VSSEG2E16_V, 0x2, 0x10 }, // 8861 + { PseudoVSSEG2E16_V_M4_MASK, VSSEG2E16_V, 0x2, 0x10 }, // 8862 + { PseudoVSSEG2E16_V_MF4, VSSEG2E16_V, 0x6, 0x10 }, // 8863 + { PseudoVSSEG2E16_V_MF4_MASK, VSSEG2E16_V, 0x6, 0x10 }, // 8864 + { PseudoVSSEG2E16_V_MF2, VSSEG2E16_V, 0x7, 0x10 }, // 8865 + { PseudoVSSEG2E16_V_MF2_MASK, VSSEG2E16_V, 0x7, 0x10 }, // 8866 + { PseudoVSSEG2E32_V_M1, VSSEG2E32_V, 0x0, 0x20 }, // 8867 + { PseudoVSSEG2E32_V_M1_MASK, VSSEG2E32_V, 0x0, 0x20 }, // 8868 + { PseudoVSSEG2E32_V_M2, VSSEG2E32_V, 0x1, 0x20 }, // 8869 + { PseudoVSSEG2E32_V_M2_MASK, VSSEG2E32_V, 0x1, 0x20 }, // 8870 + { PseudoVSSEG2E32_V_M4, VSSEG2E32_V, 0x2, 0x20 }, // 8871 + { PseudoVSSEG2E32_V_M4_MASK, VSSEG2E32_V, 0x2, 0x20 }, // 8872 + { PseudoVSSEG2E32_V_MF2, VSSEG2E32_V, 0x7, 0x20 }, // 8873 + { PseudoVSSEG2E32_V_MF2_MASK, VSSEG2E32_V, 0x7, 0x20 }, // 8874 + { PseudoVSSEG2E64_V_M1, VSSEG2E64_V, 0x0, 0x40 }, // 8875 + { PseudoVSSEG2E64_V_M1_MASK, VSSEG2E64_V, 0x0, 0x40 }, // 8876 + { PseudoVSSEG2E64_V_M2, VSSEG2E64_V, 0x1, 0x40 }, // 8877 + { PseudoVSSEG2E64_V_M2_MASK, VSSEG2E64_V, 0x1, 0x40 }, // 8878 + { PseudoVSSEG2E64_V_M4, VSSEG2E64_V, 0x2, 0x40 }, // 8879 + { PseudoVSSEG2E64_V_M4_MASK, VSSEG2E64_V, 0x2, 0x40 }, // 8880 + { PseudoVSSEG2E8_V_M1, VSSEG2E8_V, 0x0, 0x8 }, // 8881 + { PseudoVSSEG2E8_V_M1_MASK, VSSEG2E8_V, 0x0, 0x8 }, // 8882 + { PseudoVSSEG2E8_V_M2, VSSEG2E8_V, 0x1, 0x8 }, // 8883 + { PseudoVSSEG2E8_V_M2_MASK, VSSEG2E8_V, 0x1, 0x8 }, // 8884 + { PseudoVSSEG2E8_V_M4, VSSEG2E8_V, 0x2, 0x8 }, // 8885 + { PseudoVSSEG2E8_V_M4_MASK, VSSEG2E8_V, 0x2, 0x8 }, // 8886 + { PseudoVSSEG2E8_V_MF8, VSSEG2E8_V, 0x5, 0x8 }, // 8887 + { PseudoVSSEG2E8_V_MF8_MASK, VSSEG2E8_V, 0x5, 0x8 }, // 8888 + { PseudoVSSEG2E8_V_MF4, VSSEG2E8_V, 0x6, 0x8 }, // 8889 + { PseudoVSSEG2E8_V_MF4_MASK, VSSEG2E8_V, 0x6, 0x8 }, // 8890 + { PseudoVSSEG2E8_V_MF2, VSSEG2E8_V, 0x7, 0x8 }, // 8891 + { PseudoVSSEG2E8_V_MF2_MASK, VSSEG2E8_V, 0x7, 0x8 }, // 8892 + { PseudoVSSEG3E16_V_M1, VSSEG3E16_V, 0x0, 0x10 }, // 8893 + { PseudoVSSEG3E16_V_M1_MASK, VSSEG3E16_V, 0x0, 0x10 }, // 8894 + { PseudoVSSEG3E16_V_M2, VSSEG3E16_V, 0x1, 0x10 }, // 8895 + { PseudoVSSEG3E16_V_M2_MASK, VSSEG3E16_V, 0x1, 0x10 }, // 8896 + { PseudoVSSEG3E16_V_MF4, VSSEG3E16_V, 0x6, 0x10 }, // 8897 + { PseudoVSSEG3E16_V_MF4_MASK, VSSEG3E16_V, 0x6, 0x10 }, // 8898 + { PseudoVSSEG3E16_V_MF2, VSSEG3E16_V, 0x7, 0x10 }, // 8899 + { PseudoVSSEG3E16_V_MF2_MASK, VSSEG3E16_V, 0x7, 0x10 }, // 8900 + { PseudoVSSEG3E32_V_M1, VSSEG3E32_V, 0x0, 0x20 }, // 8901 + { PseudoVSSEG3E32_V_M1_MASK, VSSEG3E32_V, 0x0, 0x20 }, // 8902 + { PseudoVSSEG3E32_V_M2, VSSEG3E32_V, 0x1, 0x20 }, // 8903 + { PseudoVSSEG3E32_V_M2_MASK, VSSEG3E32_V, 0x1, 0x20 }, // 8904 + { PseudoVSSEG3E32_V_MF2, VSSEG3E32_V, 0x7, 0x20 }, // 8905 + { PseudoVSSEG3E32_V_MF2_MASK, VSSEG3E32_V, 0x7, 0x20 }, // 8906 + { PseudoVSSEG3E64_V_M1, VSSEG3E64_V, 0x0, 0x40 }, // 8907 + { PseudoVSSEG3E64_V_M1_MASK, VSSEG3E64_V, 0x0, 0x40 }, // 8908 + { PseudoVSSEG3E64_V_M2, VSSEG3E64_V, 0x1, 0x40 }, // 8909 + { PseudoVSSEG3E64_V_M2_MASK, VSSEG3E64_V, 0x1, 0x40 }, // 8910 + { PseudoVSSEG3E8_V_M1, VSSEG3E8_V, 0x0, 0x8 }, // 8911 + { PseudoVSSEG3E8_V_M1_MASK, VSSEG3E8_V, 0x0, 0x8 }, // 8912 + { PseudoVSSEG3E8_V_M2, VSSEG3E8_V, 0x1, 0x8 }, // 8913 + { PseudoVSSEG3E8_V_M2_MASK, VSSEG3E8_V, 0x1, 0x8 }, // 8914 + { PseudoVSSEG3E8_V_MF8, VSSEG3E8_V, 0x5, 0x8 }, // 8915 + { PseudoVSSEG3E8_V_MF8_MASK, VSSEG3E8_V, 0x5, 0x8 }, // 8916 + { PseudoVSSEG3E8_V_MF4, VSSEG3E8_V, 0x6, 0x8 }, // 8917 + { PseudoVSSEG3E8_V_MF4_MASK, VSSEG3E8_V, 0x6, 0x8 }, // 8918 + { PseudoVSSEG3E8_V_MF2, VSSEG3E8_V, 0x7, 0x8 }, // 8919 + { PseudoVSSEG3E8_V_MF2_MASK, VSSEG3E8_V, 0x7, 0x8 }, // 8920 + { PseudoVSSEG4E16_V_M1, VSSEG4E16_V, 0x0, 0x10 }, // 8921 + { PseudoVSSEG4E16_V_M1_MASK, VSSEG4E16_V, 0x0, 0x10 }, // 8922 + { PseudoVSSEG4E16_V_M2, VSSEG4E16_V, 0x1, 0x10 }, // 8923 + { PseudoVSSEG4E16_V_M2_MASK, VSSEG4E16_V, 0x1, 0x10 }, // 8924 + { PseudoVSSEG4E16_V_MF4, VSSEG4E16_V, 0x6, 0x10 }, // 8925 + { PseudoVSSEG4E16_V_MF4_MASK, VSSEG4E16_V, 0x6, 0x10 }, // 8926 + { PseudoVSSEG4E16_V_MF2, VSSEG4E16_V, 0x7, 0x10 }, // 8927 + { PseudoVSSEG4E16_V_MF2_MASK, VSSEG4E16_V, 0x7, 0x10 }, // 8928 + { PseudoVSSEG4E32_V_M1, VSSEG4E32_V, 0x0, 0x20 }, // 8929 + { PseudoVSSEG4E32_V_M1_MASK, VSSEG4E32_V, 0x0, 0x20 }, // 8930 + { PseudoVSSEG4E32_V_M2, VSSEG4E32_V, 0x1, 0x20 }, // 8931 + { PseudoVSSEG4E32_V_M2_MASK, VSSEG4E32_V, 0x1, 0x20 }, // 8932 + { PseudoVSSEG4E32_V_MF2, VSSEG4E32_V, 0x7, 0x20 }, // 8933 + { PseudoVSSEG4E32_V_MF2_MASK, VSSEG4E32_V, 0x7, 0x20 }, // 8934 + { PseudoVSSEG4E64_V_M1, VSSEG4E64_V, 0x0, 0x40 }, // 8935 + { PseudoVSSEG4E64_V_M1_MASK, VSSEG4E64_V, 0x0, 0x40 }, // 8936 + { PseudoVSSEG4E64_V_M2, VSSEG4E64_V, 0x1, 0x40 }, // 8937 + { PseudoVSSEG4E64_V_M2_MASK, VSSEG4E64_V, 0x1, 0x40 }, // 8938 + { PseudoVSSEG4E8_V_M1, VSSEG4E8_V, 0x0, 0x8 }, // 8939 + { PseudoVSSEG4E8_V_M1_MASK, VSSEG4E8_V, 0x0, 0x8 }, // 8940 + { PseudoVSSEG4E8_V_M2, VSSEG4E8_V, 0x1, 0x8 }, // 8941 + { PseudoVSSEG4E8_V_M2_MASK, VSSEG4E8_V, 0x1, 0x8 }, // 8942 + { PseudoVSSEG4E8_V_MF8, VSSEG4E8_V, 0x5, 0x8 }, // 8943 + { PseudoVSSEG4E8_V_MF8_MASK, VSSEG4E8_V, 0x5, 0x8 }, // 8944 + { PseudoVSSEG4E8_V_MF4, VSSEG4E8_V, 0x6, 0x8 }, // 8945 + { PseudoVSSEG4E8_V_MF4_MASK, VSSEG4E8_V, 0x6, 0x8 }, // 8946 + { PseudoVSSEG4E8_V_MF2, VSSEG4E8_V, 0x7, 0x8 }, // 8947 + { PseudoVSSEG4E8_V_MF2_MASK, VSSEG4E8_V, 0x7, 0x8 }, // 8948 + { PseudoVSSEG5E16_V_M1, VSSEG5E16_V, 0x0, 0x10 }, // 8949 + { PseudoVSSEG5E16_V_M1_MASK, VSSEG5E16_V, 0x0, 0x10 }, // 8950 + { PseudoVSSEG5E16_V_MF4, VSSEG5E16_V, 0x6, 0x10 }, // 8951 + { PseudoVSSEG5E16_V_MF4_MASK, VSSEG5E16_V, 0x6, 0x10 }, // 8952 + { PseudoVSSEG5E16_V_MF2, VSSEG5E16_V, 0x7, 0x10 }, // 8953 + { PseudoVSSEG5E16_V_MF2_MASK, VSSEG5E16_V, 0x7, 0x10 }, // 8954 + { PseudoVSSEG5E32_V_M1, VSSEG5E32_V, 0x0, 0x20 }, // 8955 + { PseudoVSSEG5E32_V_M1_MASK, VSSEG5E32_V, 0x0, 0x20 }, // 8956 + { PseudoVSSEG5E32_V_MF2, VSSEG5E32_V, 0x7, 0x20 }, // 8957 + { PseudoVSSEG5E32_V_MF2_MASK, VSSEG5E32_V, 0x7, 0x20 }, // 8958 + { PseudoVSSEG5E64_V_M1, VSSEG5E64_V, 0x0, 0x40 }, // 8959 + { PseudoVSSEG5E64_V_M1_MASK, VSSEG5E64_V, 0x0, 0x40 }, // 8960 + { PseudoVSSEG5E8_V_M1, VSSEG5E8_V, 0x0, 0x8 }, // 8961 + { PseudoVSSEG5E8_V_M1_MASK, VSSEG5E8_V, 0x0, 0x8 }, // 8962 + { PseudoVSSEG5E8_V_MF8, VSSEG5E8_V, 0x5, 0x8 }, // 8963 + { PseudoVSSEG5E8_V_MF8_MASK, VSSEG5E8_V, 0x5, 0x8 }, // 8964 + { PseudoVSSEG5E8_V_MF4, VSSEG5E8_V, 0x6, 0x8 }, // 8965 + { PseudoVSSEG5E8_V_MF4_MASK, VSSEG5E8_V, 0x6, 0x8 }, // 8966 + { PseudoVSSEG5E8_V_MF2, VSSEG5E8_V, 0x7, 0x8 }, // 8967 + { PseudoVSSEG5E8_V_MF2_MASK, VSSEG5E8_V, 0x7, 0x8 }, // 8968 + { PseudoVSSEG6E16_V_M1, VSSEG6E16_V, 0x0, 0x10 }, // 8969 + { PseudoVSSEG6E16_V_M1_MASK, VSSEG6E16_V, 0x0, 0x10 }, // 8970 + { PseudoVSSEG6E16_V_MF4, VSSEG6E16_V, 0x6, 0x10 }, // 8971 + { PseudoVSSEG6E16_V_MF4_MASK, VSSEG6E16_V, 0x6, 0x10 }, // 8972 + { PseudoVSSEG6E16_V_MF2, VSSEG6E16_V, 0x7, 0x10 }, // 8973 + { PseudoVSSEG6E16_V_MF2_MASK, VSSEG6E16_V, 0x7, 0x10 }, // 8974 + { PseudoVSSEG6E32_V_M1, VSSEG6E32_V, 0x0, 0x20 }, // 8975 + { PseudoVSSEG6E32_V_M1_MASK, VSSEG6E32_V, 0x0, 0x20 }, // 8976 + { PseudoVSSEG6E32_V_MF2, VSSEG6E32_V, 0x7, 0x20 }, // 8977 + { PseudoVSSEG6E32_V_MF2_MASK, VSSEG6E32_V, 0x7, 0x20 }, // 8978 + { PseudoVSSEG6E64_V_M1, VSSEG6E64_V, 0x0, 0x40 }, // 8979 + { PseudoVSSEG6E64_V_M1_MASK, VSSEG6E64_V, 0x0, 0x40 }, // 8980 + { PseudoVSSEG6E8_V_M1, VSSEG6E8_V, 0x0, 0x8 }, // 8981 + { PseudoVSSEG6E8_V_M1_MASK, VSSEG6E8_V, 0x0, 0x8 }, // 8982 + { PseudoVSSEG6E8_V_MF8, VSSEG6E8_V, 0x5, 0x8 }, // 8983 + { PseudoVSSEG6E8_V_MF8_MASK, VSSEG6E8_V, 0x5, 0x8 }, // 8984 + { PseudoVSSEG6E8_V_MF4, VSSEG6E8_V, 0x6, 0x8 }, // 8985 + { PseudoVSSEG6E8_V_MF4_MASK, VSSEG6E8_V, 0x6, 0x8 }, // 8986 + { PseudoVSSEG6E8_V_MF2, VSSEG6E8_V, 0x7, 0x8 }, // 8987 + { PseudoVSSEG6E8_V_MF2_MASK, VSSEG6E8_V, 0x7, 0x8 }, // 8988 + { PseudoVSSEG7E16_V_M1, VSSEG7E16_V, 0x0, 0x10 }, // 8989 + { PseudoVSSEG7E16_V_M1_MASK, VSSEG7E16_V, 0x0, 0x10 }, // 8990 + { PseudoVSSEG7E16_V_MF4, VSSEG7E16_V, 0x6, 0x10 }, // 8991 + { PseudoVSSEG7E16_V_MF4_MASK, VSSEG7E16_V, 0x6, 0x10 }, // 8992 + { PseudoVSSEG7E16_V_MF2, VSSEG7E16_V, 0x7, 0x10 }, // 8993 + { PseudoVSSEG7E16_V_MF2_MASK, VSSEG7E16_V, 0x7, 0x10 }, // 8994 + { PseudoVSSEG7E32_V_M1, VSSEG7E32_V, 0x0, 0x20 }, // 8995 + { PseudoVSSEG7E32_V_M1_MASK, VSSEG7E32_V, 0x0, 0x20 }, // 8996 + { PseudoVSSEG7E32_V_MF2, VSSEG7E32_V, 0x7, 0x20 }, // 8997 + { PseudoVSSEG7E32_V_MF2_MASK, VSSEG7E32_V, 0x7, 0x20 }, // 8998 + { PseudoVSSEG7E64_V_M1, VSSEG7E64_V, 0x0, 0x40 }, // 8999 + { PseudoVSSEG7E64_V_M1_MASK, VSSEG7E64_V, 0x0, 0x40 }, // 9000 + { PseudoVSSEG7E8_V_M1, VSSEG7E8_V, 0x0, 0x8 }, // 9001 + { PseudoVSSEG7E8_V_M1_MASK, VSSEG7E8_V, 0x0, 0x8 }, // 9002 + { PseudoVSSEG7E8_V_MF8, VSSEG7E8_V, 0x5, 0x8 }, // 9003 + { PseudoVSSEG7E8_V_MF8_MASK, VSSEG7E8_V, 0x5, 0x8 }, // 9004 + { PseudoVSSEG7E8_V_MF4, VSSEG7E8_V, 0x6, 0x8 }, // 9005 + { PseudoVSSEG7E8_V_MF4_MASK, VSSEG7E8_V, 0x6, 0x8 }, // 9006 + { PseudoVSSEG7E8_V_MF2, VSSEG7E8_V, 0x7, 0x8 }, // 9007 + { PseudoVSSEG7E8_V_MF2_MASK, VSSEG7E8_V, 0x7, 0x8 }, // 9008 + { PseudoVSSEG8E16_V_M1, VSSEG8E16_V, 0x0, 0x10 }, // 9009 + { PseudoVSSEG8E16_V_M1_MASK, VSSEG8E16_V, 0x0, 0x10 }, // 9010 + { PseudoVSSEG8E16_V_MF4, VSSEG8E16_V, 0x6, 0x10 }, // 9011 + { PseudoVSSEG8E16_V_MF4_MASK, VSSEG8E16_V, 0x6, 0x10 }, // 9012 + { PseudoVSSEG8E16_V_MF2, VSSEG8E16_V, 0x7, 0x10 }, // 9013 + { PseudoVSSEG8E16_V_MF2_MASK, VSSEG8E16_V, 0x7, 0x10 }, // 9014 + { PseudoVSSEG8E32_V_M1, VSSEG8E32_V, 0x0, 0x20 }, // 9015 + { PseudoVSSEG8E32_V_M1_MASK, VSSEG8E32_V, 0x0, 0x20 }, // 9016 + { PseudoVSSEG8E32_V_MF2, VSSEG8E32_V, 0x7, 0x20 }, // 9017 + { PseudoVSSEG8E32_V_MF2_MASK, VSSEG8E32_V, 0x7, 0x20 }, // 9018 + { PseudoVSSEG8E64_V_M1, VSSEG8E64_V, 0x0, 0x40 }, // 9019 + { PseudoVSSEG8E64_V_M1_MASK, VSSEG8E64_V, 0x0, 0x40 }, // 9020 + { PseudoVSSEG8E8_V_M1, VSSEG8E8_V, 0x0, 0x8 }, // 9021 + { PseudoVSSEG8E8_V_M1_MASK, VSSEG8E8_V, 0x0, 0x8 }, // 9022 + { PseudoVSSEG8E8_V_MF8, VSSEG8E8_V, 0x5, 0x8 }, // 9023 + { PseudoVSSEG8E8_V_MF8_MASK, VSSEG8E8_V, 0x5, 0x8 }, // 9024 + { PseudoVSSEG8E8_V_MF4, VSSEG8E8_V, 0x6, 0x8 }, // 9025 + { PseudoVSSEG8E8_V_MF4_MASK, VSSEG8E8_V, 0x6, 0x8 }, // 9026 + { PseudoVSSEG8E8_V_MF2, VSSEG8E8_V, 0x7, 0x8 }, // 9027 + { PseudoVSSEG8E8_V_MF2_MASK, VSSEG8E8_V, 0x7, 0x8 }, // 9028 + { PseudoVSSRA_VI_M1, VSSRA_VI, 0x0, 0x0 }, // 9029 + { PseudoVSSRA_VI_M1_MASK, VSSRA_VI, 0x0, 0x0 }, // 9030 + { PseudoVSSRA_VI_M2, VSSRA_VI, 0x1, 0x0 }, // 9031 + { PseudoVSSRA_VI_M2_MASK, VSSRA_VI, 0x1, 0x0 }, // 9032 + { PseudoVSSRA_VI_M4, VSSRA_VI, 0x2, 0x0 }, // 9033 + { PseudoVSSRA_VI_M4_MASK, VSSRA_VI, 0x2, 0x0 }, // 9034 + { PseudoVSSRA_VI_M8, VSSRA_VI, 0x3, 0x0 }, // 9035 + { PseudoVSSRA_VI_M8_MASK, VSSRA_VI, 0x3, 0x0 }, // 9036 + { PseudoVSSRA_VI_MF8, VSSRA_VI, 0x5, 0x0 }, // 9037 + { PseudoVSSRA_VI_MF8_MASK, VSSRA_VI, 0x5, 0x0 }, // 9038 + { PseudoVSSRA_VI_MF4, VSSRA_VI, 0x6, 0x0 }, // 9039 + { PseudoVSSRA_VI_MF4_MASK, VSSRA_VI, 0x6, 0x0 }, // 9040 + { PseudoVSSRA_VI_MF2, VSSRA_VI, 0x7, 0x0 }, // 9041 + { PseudoVSSRA_VI_MF2_MASK, VSSRA_VI, 0x7, 0x0 }, // 9042 + { PseudoVSSRA_VV_M1, VSSRA_VV, 0x0, 0x0 }, // 9043 + { PseudoVSSRA_VV_M1_MASK, VSSRA_VV, 0x0, 0x0 }, // 9044 + { PseudoVSSRA_VV_M2, VSSRA_VV, 0x1, 0x0 }, // 9045 + { PseudoVSSRA_VV_M2_MASK, VSSRA_VV, 0x1, 0x0 }, // 9046 + { PseudoVSSRA_VV_M4, VSSRA_VV, 0x2, 0x0 }, // 9047 + { PseudoVSSRA_VV_M4_MASK, VSSRA_VV, 0x2, 0x0 }, // 9048 + { PseudoVSSRA_VV_M8, VSSRA_VV, 0x3, 0x0 }, // 9049 + { PseudoVSSRA_VV_M8_MASK, VSSRA_VV, 0x3, 0x0 }, // 9050 + { PseudoVSSRA_VV_MF8, VSSRA_VV, 0x5, 0x0 }, // 9051 + { PseudoVSSRA_VV_MF8_MASK, VSSRA_VV, 0x5, 0x0 }, // 9052 + { PseudoVSSRA_VV_MF4, VSSRA_VV, 0x6, 0x0 }, // 9053 + { PseudoVSSRA_VV_MF4_MASK, VSSRA_VV, 0x6, 0x0 }, // 9054 + { PseudoVSSRA_VV_MF2, VSSRA_VV, 0x7, 0x0 }, // 9055 + { PseudoVSSRA_VV_MF2_MASK, VSSRA_VV, 0x7, 0x0 }, // 9056 + { PseudoVSSRA_VX_M1, VSSRA_VX, 0x0, 0x0 }, // 9057 + { PseudoVSSRA_VX_M1_MASK, VSSRA_VX, 0x0, 0x0 }, // 9058 + { PseudoVSSRA_VX_M2, VSSRA_VX, 0x1, 0x0 }, // 9059 + { PseudoVSSRA_VX_M2_MASK, VSSRA_VX, 0x1, 0x0 }, // 9060 + { PseudoVSSRA_VX_M4, VSSRA_VX, 0x2, 0x0 }, // 9061 + { PseudoVSSRA_VX_M4_MASK, VSSRA_VX, 0x2, 0x0 }, // 9062 + { PseudoVSSRA_VX_M8, VSSRA_VX, 0x3, 0x0 }, // 9063 + { PseudoVSSRA_VX_M8_MASK, VSSRA_VX, 0x3, 0x0 }, // 9064 + { PseudoVSSRA_VX_MF8, VSSRA_VX, 0x5, 0x0 }, // 9065 + { PseudoVSSRA_VX_MF8_MASK, VSSRA_VX, 0x5, 0x0 }, // 9066 + { PseudoVSSRA_VX_MF4, VSSRA_VX, 0x6, 0x0 }, // 9067 + { PseudoVSSRA_VX_MF4_MASK, VSSRA_VX, 0x6, 0x0 }, // 9068 + { PseudoVSSRA_VX_MF2, VSSRA_VX, 0x7, 0x0 }, // 9069 + { PseudoVSSRA_VX_MF2_MASK, VSSRA_VX, 0x7, 0x0 }, // 9070 + { PseudoVSSRL_VI_M1, VSSRL_VI, 0x0, 0x0 }, // 9071 + { PseudoVSSRL_VI_M1_MASK, VSSRL_VI, 0x0, 0x0 }, // 9072 + { PseudoVSSRL_VI_M2, VSSRL_VI, 0x1, 0x0 }, // 9073 + { PseudoVSSRL_VI_M2_MASK, VSSRL_VI, 0x1, 0x0 }, // 9074 + { PseudoVSSRL_VI_M4, VSSRL_VI, 0x2, 0x0 }, // 9075 + { PseudoVSSRL_VI_M4_MASK, VSSRL_VI, 0x2, 0x0 }, // 9076 + { PseudoVSSRL_VI_M8, VSSRL_VI, 0x3, 0x0 }, // 9077 + { PseudoVSSRL_VI_M8_MASK, VSSRL_VI, 0x3, 0x0 }, // 9078 + { PseudoVSSRL_VI_MF8, VSSRL_VI, 0x5, 0x0 }, // 9079 + { PseudoVSSRL_VI_MF8_MASK, VSSRL_VI, 0x5, 0x0 }, // 9080 + { PseudoVSSRL_VI_MF4, VSSRL_VI, 0x6, 0x0 }, // 9081 + { PseudoVSSRL_VI_MF4_MASK, VSSRL_VI, 0x6, 0x0 }, // 9082 + { PseudoVSSRL_VI_MF2, VSSRL_VI, 0x7, 0x0 }, // 9083 + { PseudoVSSRL_VI_MF2_MASK, VSSRL_VI, 0x7, 0x0 }, // 9084 + { PseudoVSSRL_VV_M1, VSSRL_VV, 0x0, 0x0 }, // 9085 + { PseudoVSSRL_VV_M1_MASK, VSSRL_VV, 0x0, 0x0 }, // 9086 + { PseudoVSSRL_VV_M2, VSSRL_VV, 0x1, 0x0 }, // 9087 + { PseudoVSSRL_VV_M2_MASK, VSSRL_VV, 0x1, 0x0 }, // 9088 + { PseudoVSSRL_VV_M4, VSSRL_VV, 0x2, 0x0 }, // 9089 + { PseudoVSSRL_VV_M4_MASK, VSSRL_VV, 0x2, 0x0 }, // 9090 + { PseudoVSSRL_VV_M8, VSSRL_VV, 0x3, 0x0 }, // 9091 + { PseudoVSSRL_VV_M8_MASK, VSSRL_VV, 0x3, 0x0 }, // 9092 + { PseudoVSSRL_VV_MF8, VSSRL_VV, 0x5, 0x0 }, // 9093 + { PseudoVSSRL_VV_MF8_MASK, VSSRL_VV, 0x5, 0x0 }, // 9094 + { PseudoVSSRL_VV_MF4, VSSRL_VV, 0x6, 0x0 }, // 9095 + { PseudoVSSRL_VV_MF4_MASK, VSSRL_VV, 0x6, 0x0 }, // 9096 + { PseudoVSSRL_VV_MF2, VSSRL_VV, 0x7, 0x0 }, // 9097 + { PseudoVSSRL_VV_MF2_MASK, VSSRL_VV, 0x7, 0x0 }, // 9098 + { PseudoVSSRL_VX_M1, VSSRL_VX, 0x0, 0x0 }, // 9099 + { PseudoVSSRL_VX_M1_MASK, VSSRL_VX, 0x0, 0x0 }, // 9100 + { PseudoVSSRL_VX_M2, VSSRL_VX, 0x1, 0x0 }, // 9101 + { PseudoVSSRL_VX_M2_MASK, VSSRL_VX, 0x1, 0x0 }, // 9102 + { PseudoVSSRL_VX_M4, VSSRL_VX, 0x2, 0x0 }, // 9103 + { PseudoVSSRL_VX_M4_MASK, VSSRL_VX, 0x2, 0x0 }, // 9104 + { PseudoVSSRL_VX_M8, VSSRL_VX, 0x3, 0x0 }, // 9105 + { PseudoVSSRL_VX_M8_MASK, VSSRL_VX, 0x3, 0x0 }, // 9106 + { PseudoVSSRL_VX_MF8, VSSRL_VX, 0x5, 0x0 }, // 9107 + { PseudoVSSRL_VX_MF8_MASK, VSSRL_VX, 0x5, 0x0 }, // 9108 + { PseudoVSSRL_VX_MF4, VSSRL_VX, 0x6, 0x0 }, // 9109 + { PseudoVSSRL_VX_MF4_MASK, VSSRL_VX, 0x6, 0x0 }, // 9110 + { PseudoVSSRL_VX_MF2, VSSRL_VX, 0x7, 0x0 }, // 9111 + { PseudoVSSRL_VX_MF2_MASK, VSSRL_VX, 0x7, 0x0 }, // 9112 + { PseudoVSSSEG2E16_V_M1, VSSSEG2E16_V, 0x0, 0x10 }, // 9113 + { PseudoVSSSEG2E16_V_M1_MASK, VSSSEG2E16_V, 0x0, 0x10 }, // 9114 + { PseudoVSSSEG2E16_V_M2, VSSSEG2E16_V, 0x1, 0x10 }, // 9115 + { PseudoVSSSEG2E16_V_M2_MASK, VSSSEG2E16_V, 0x1, 0x10 }, // 9116 + { PseudoVSSSEG2E16_V_M4, VSSSEG2E16_V, 0x2, 0x10 }, // 9117 + { PseudoVSSSEG2E16_V_M4_MASK, VSSSEG2E16_V, 0x2, 0x10 }, // 9118 + { PseudoVSSSEG2E16_V_MF4, VSSSEG2E16_V, 0x6, 0x10 }, // 9119 + { PseudoVSSSEG2E16_V_MF4_MASK, VSSSEG2E16_V, 0x6, 0x10 }, // 9120 + { PseudoVSSSEG2E16_V_MF2, VSSSEG2E16_V, 0x7, 0x10 }, // 9121 + { PseudoVSSSEG2E16_V_MF2_MASK, VSSSEG2E16_V, 0x7, 0x10 }, // 9122 + { PseudoVSSSEG2E32_V_M1, VSSSEG2E32_V, 0x0, 0x20 }, // 9123 + { PseudoVSSSEG2E32_V_M1_MASK, VSSSEG2E32_V, 0x0, 0x20 }, // 9124 + { PseudoVSSSEG2E32_V_M2, VSSSEG2E32_V, 0x1, 0x20 }, // 9125 + { PseudoVSSSEG2E32_V_M2_MASK, VSSSEG2E32_V, 0x1, 0x20 }, // 9126 + { PseudoVSSSEG2E32_V_M4, VSSSEG2E32_V, 0x2, 0x20 }, // 9127 + { PseudoVSSSEG2E32_V_M4_MASK, VSSSEG2E32_V, 0x2, 0x20 }, // 9128 + { PseudoVSSSEG2E32_V_MF2, VSSSEG2E32_V, 0x7, 0x20 }, // 9129 + { PseudoVSSSEG2E32_V_MF2_MASK, VSSSEG2E32_V, 0x7, 0x20 }, // 9130 + { PseudoVSSSEG2E64_V_M1, VSSSEG2E64_V, 0x0, 0x40 }, // 9131 + { PseudoVSSSEG2E64_V_M1_MASK, VSSSEG2E64_V, 0x0, 0x40 }, // 9132 + { PseudoVSSSEG2E64_V_M2, VSSSEG2E64_V, 0x1, 0x40 }, // 9133 + { PseudoVSSSEG2E64_V_M2_MASK, VSSSEG2E64_V, 0x1, 0x40 }, // 9134 + { PseudoVSSSEG2E64_V_M4, VSSSEG2E64_V, 0x2, 0x40 }, // 9135 + { PseudoVSSSEG2E64_V_M4_MASK, VSSSEG2E64_V, 0x2, 0x40 }, // 9136 + { PseudoVSSSEG2E8_V_M1, VSSSEG2E8_V, 0x0, 0x8 }, // 9137 + { PseudoVSSSEG2E8_V_M1_MASK, VSSSEG2E8_V, 0x0, 0x8 }, // 9138 + { PseudoVSSSEG2E8_V_M2, VSSSEG2E8_V, 0x1, 0x8 }, // 9139 + { PseudoVSSSEG2E8_V_M2_MASK, VSSSEG2E8_V, 0x1, 0x8 }, // 9140 + { PseudoVSSSEG2E8_V_M4, VSSSEG2E8_V, 0x2, 0x8 }, // 9141 + { PseudoVSSSEG2E8_V_M4_MASK, VSSSEG2E8_V, 0x2, 0x8 }, // 9142 + { PseudoVSSSEG2E8_V_MF8, VSSSEG2E8_V, 0x5, 0x8 }, // 9143 + { PseudoVSSSEG2E8_V_MF8_MASK, VSSSEG2E8_V, 0x5, 0x8 }, // 9144 + { PseudoVSSSEG2E8_V_MF4, VSSSEG2E8_V, 0x6, 0x8 }, // 9145 + { PseudoVSSSEG2E8_V_MF4_MASK, VSSSEG2E8_V, 0x6, 0x8 }, // 9146 + { PseudoVSSSEG2E8_V_MF2, VSSSEG2E8_V, 0x7, 0x8 }, // 9147 + { PseudoVSSSEG2E8_V_MF2_MASK, VSSSEG2E8_V, 0x7, 0x8 }, // 9148 + { PseudoVSSSEG3E16_V_M1, VSSSEG3E16_V, 0x0, 0x10 }, // 9149 + { PseudoVSSSEG3E16_V_M1_MASK, VSSSEG3E16_V, 0x0, 0x10 }, // 9150 + { PseudoVSSSEG3E16_V_M2, VSSSEG3E16_V, 0x1, 0x10 }, // 9151 + { PseudoVSSSEG3E16_V_M2_MASK, VSSSEG3E16_V, 0x1, 0x10 }, // 9152 + { PseudoVSSSEG3E16_V_MF4, VSSSEG3E16_V, 0x6, 0x10 }, // 9153 + { PseudoVSSSEG3E16_V_MF4_MASK, VSSSEG3E16_V, 0x6, 0x10 }, // 9154 + { PseudoVSSSEG3E16_V_MF2, VSSSEG3E16_V, 0x7, 0x10 }, // 9155 + { PseudoVSSSEG3E16_V_MF2_MASK, VSSSEG3E16_V, 0x7, 0x10 }, // 9156 + { PseudoVSSSEG3E32_V_M1, VSSSEG3E32_V, 0x0, 0x20 }, // 9157 + { PseudoVSSSEG3E32_V_M1_MASK, VSSSEG3E32_V, 0x0, 0x20 }, // 9158 + { PseudoVSSSEG3E32_V_M2, VSSSEG3E32_V, 0x1, 0x20 }, // 9159 + { PseudoVSSSEG3E32_V_M2_MASK, VSSSEG3E32_V, 0x1, 0x20 }, // 9160 + { PseudoVSSSEG3E32_V_MF2, VSSSEG3E32_V, 0x7, 0x20 }, // 9161 + { PseudoVSSSEG3E32_V_MF2_MASK, VSSSEG3E32_V, 0x7, 0x20 }, // 9162 + { PseudoVSSSEG3E64_V_M1, VSSSEG3E64_V, 0x0, 0x40 }, // 9163 + { PseudoVSSSEG3E64_V_M1_MASK, VSSSEG3E64_V, 0x0, 0x40 }, // 9164 + { PseudoVSSSEG3E64_V_M2, VSSSEG3E64_V, 0x1, 0x40 }, // 9165 + { PseudoVSSSEG3E64_V_M2_MASK, VSSSEG3E64_V, 0x1, 0x40 }, // 9166 + { PseudoVSSSEG3E8_V_M1, VSSSEG3E8_V, 0x0, 0x8 }, // 9167 + { PseudoVSSSEG3E8_V_M1_MASK, VSSSEG3E8_V, 0x0, 0x8 }, // 9168 + { PseudoVSSSEG3E8_V_M2, VSSSEG3E8_V, 0x1, 0x8 }, // 9169 + { PseudoVSSSEG3E8_V_M2_MASK, VSSSEG3E8_V, 0x1, 0x8 }, // 9170 + { PseudoVSSSEG3E8_V_MF8, VSSSEG3E8_V, 0x5, 0x8 }, // 9171 + { PseudoVSSSEG3E8_V_MF8_MASK, VSSSEG3E8_V, 0x5, 0x8 }, // 9172 + { PseudoVSSSEG3E8_V_MF4, VSSSEG3E8_V, 0x6, 0x8 }, // 9173 + { PseudoVSSSEG3E8_V_MF4_MASK, VSSSEG3E8_V, 0x6, 0x8 }, // 9174 + { PseudoVSSSEG3E8_V_MF2, VSSSEG3E8_V, 0x7, 0x8 }, // 9175 + { PseudoVSSSEG3E8_V_MF2_MASK, VSSSEG3E8_V, 0x7, 0x8 }, // 9176 + { PseudoVSSSEG4E16_V_M1, VSSSEG4E16_V, 0x0, 0x10 }, // 9177 + { PseudoVSSSEG4E16_V_M1_MASK, VSSSEG4E16_V, 0x0, 0x10 }, // 9178 + { PseudoVSSSEG4E16_V_M2, VSSSEG4E16_V, 0x1, 0x10 }, // 9179 + { PseudoVSSSEG4E16_V_M2_MASK, VSSSEG4E16_V, 0x1, 0x10 }, // 9180 + { PseudoVSSSEG4E16_V_MF4, VSSSEG4E16_V, 0x6, 0x10 }, // 9181 + { PseudoVSSSEG4E16_V_MF4_MASK, VSSSEG4E16_V, 0x6, 0x10 }, // 9182 + { PseudoVSSSEG4E16_V_MF2, VSSSEG4E16_V, 0x7, 0x10 }, // 9183 + { PseudoVSSSEG4E16_V_MF2_MASK, VSSSEG4E16_V, 0x7, 0x10 }, // 9184 + { PseudoVSSSEG4E32_V_M1, VSSSEG4E32_V, 0x0, 0x20 }, // 9185 + { PseudoVSSSEG4E32_V_M1_MASK, VSSSEG4E32_V, 0x0, 0x20 }, // 9186 + { PseudoVSSSEG4E32_V_M2, VSSSEG4E32_V, 0x1, 0x20 }, // 9187 + { PseudoVSSSEG4E32_V_M2_MASK, VSSSEG4E32_V, 0x1, 0x20 }, // 9188 + { PseudoVSSSEG4E32_V_MF2, VSSSEG4E32_V, 0x7, 0x20 }, // 9189 + { PseudoVSSSEG4E32_V_MF2_MASK, VSSSEG4E32_V, 0x7, 0x20 }, // 9190 + { PseudoVSSSEG4E64_V_M1, VSSSEG4E64_V, 0x0, 0x40 }, // 9191 + { PseudoVSSSEG4E64_V_M1_MASK, VSSSEG4E64_V, 0x0, 0x40 }, // 9192 + { PseudoVSSSEG4E64_V_M2, VSSSEG4E64_V, 0x1, 0x40 }, // 9193 + { PseudoVSSSEG4E64_V_M2_MASK, VSSSEG4E64_V, 0x1, 0x40 }, // 9194 + { PseudoVSSSEG4E8_V_M1, VSSSEG4E8_V, 0x0, 0x8 }, // 9195 + { PseudoVSSSEG4E8_V_M1_MASK, VSSSEG4E8_V, 0x0, 0x8 }, // 9196 + { PseudoVSSSEG4E8_V_M2, VSSSEG4E8_V, 0x1, 0x8 }, // 9197 + { PseudoVSSSEG4E8_V_M2_MASK, VSSSEG4E8_V, 0x1, 0x8 }, // 9198 + { PseudoVSSSEG4E8_V_MF8, VSSSEG4E8_V, 0x5, 0x8 }, // 9199 + { PseudoVSSSEG4E8_V_MF8_MASK, VSSSEG4E8_V, 0x5, 0x8 }, // 9200 + { PseudoVSSSEG4E8_V_MF4, VSSSEG4E8_V, 0x6, 0x8 }, // 9201 + { PseudoVSSSEG4E8_V_MF4_MASK, VSSSEG4E8_V, 0x6, 0x8 }, // 9202 + { PseudoVSSSEG4E8_V_MF2, VSSSEG4E8_V, 0x7, 0x8 }, // 9203 + { PseudoVSSSEG4E8_V_MF2_MASK, VSSSEG4E8_V, 0x7, 0x8 }, // 9204 + { PseudoVSSSEG5E16_V_M1, VSSSEG5E16_V, 0x0, 0x10 }, // 9205 + { PseudoVSSSEG5E16_V_M1_MASK, VSSSEG5E16_V, 0x0, 0x10 }, // 9206 + { PseudoVSSSEG5E16_V_MF4, VSSSEG5E16_V, 0x6, 0x10 }, // 9207 + { PseudoVSSSEG5E16_V_MF4_MASK, VSSSEG5E16_V, 0x6, 0x10 }, // 9208 + { PseudoVSSSEG5E16_V_MF2, VSSSEG5E16_V, 0x7, 0x10 }, // 9209 + { PseudoVSSSEG5E16_V_MF2_MASK, VSSSEG5E16_V, 0x7, 0x10 }, // 9210 + { PseudoVSSSEG5E32_V_M1, VSSSEG5E32_V, 0x0, 0x20 }, // 9211 + { PseudoVSSSEG5E32_V_M1_MASK, VSSSEG5E32_V, 0x0, 0x20 }, // 9212 + { PseudoVSSSEG5E32_V_MF2, VSSSEG5E32_V, 0x7, 0x20 }, // 9213 + { PseudoVSSSEG5E32_V_MF2_MASK, VSSSEG5E32_V, 0x7, 0x20 }, // 9214 + { PseudoVSSSEG5E64_V_M1, VSSSEG5E64_V, 0x0, 0x40 }, // 9215 + { PseudoVSSSEG5E64_V_M1_MASK, VSSSEG5E64_V, 0x0, 0x40 }, // 9216 + { PseudoVSSSEG5E8_V_M1, VSSSEG5E8_V, 0x0, 0x8 }, // 9217 + { PseudoVSSSEG5E8_V_M1_MASK, VSSSEG5E8_V, 0x0, 0x8 }, // 9218 + { PseudoVSSSEG5E8_V_MF8, VSSSEG5E8_V, 0x5, 0x8 }, // 9219 + { PseudoVSSSEG5E8_V_MF8_MASK, VSSSEG5E8_V, 0x5, 0x8 }, // 9220 + { PseudoVSSSEG5E8_V_MF4, VSSSEG5E8_V, 0x6, 0x8 }, // 9221 + { PseudoVSSSEG5E8_V_MF4_MASK, VSSSEG5E8_V, 0x6, 0x8 }, // 9222 + { PseudoVSSSEG5E8_V_MF2, VSSSEG5E8_V, 0x7, 0x8 }, // 9223 + { PseudoVSSSEG5E8_V_MF2_MASK, VSSSEG5E8_V, 0x7, 0x8 }, // 9224 + { PseudoVSSSEG6E16_V_M1, VSSSEG6E16_V, 0x0, 0x10 }, // 9225 + { PseudoVSSSEG6E16_V_M1_MASK, VSSSEG6E16_V, 0x0, 0x10 }, // 9226 + { PseudoVSSSEG6E16_V_MF4, VSSSEG6E16_V, 0x6, 0x10 }, // 9227 + { PseudoVSSSEG6E16_V_MF4_MASK, VSSSEG6E16_V, 0x6, 0x10 }, // 9228 + { PseudoVSSSEG6E16_V_MF2, VSSSEG6E16_V, 0x7, 0x10 }, // 9229 + { PseudoVSSSEG6E16_V_MF2_MASK, VSSSEG6E16_V, 0x7, 0x10 }, // 9230 + { PseudoVSSSEG6E32_V_M1, VSSSEG6E32_V, 0x0, 0x20 }, // 9231 + { PseudoVSSSEG6E32_V_M1_MASK, VSSSEG6E32_V, 0x0, 0x20 }, // 9232 + { PseudoVSSSEG6E32_V_MF2, VSSSEG6E32_V, 0x7, 0x20 }, // 9233 + { PseudoVSSSEG6E32_V_MF2_MASK, VSSSEG6E32_V, 0x7, 0x20 }, // 9234 + { PseudoVSSSEG6E64_V_M1, VSSSEG6E64_V, 0x0, 0x40 }, // 9235 + { PseudoVSSSEG6E64_V_M1_MASK, VSSSEG6E64_V, 0x0, 0x40 }, // 9236 + { PseudoVSSSEG6E8_V_M1, VSSSEG6E8_V, 0x0, 0x8 }, // 9237 + { PseudoVSSSEG6E8_V_M1_MASK, VSSSEG6E8_V, 0x0, 0x8 }, // 9238 + { PseudoVSSSEG6E8_V_MF8, VSSSEG6E8_V, 0x5, 0x8 }, // 9239 + { PseudoVSSSEG6E8_V_MF8_MASK, VSSSEG6E8_V, 0x5, 0x8 }, // 9240 + { PseudoVSSSEG6E8_V_MF4, VSSSEG6E8_V, 0x6, 0x8 }, // 9241 + { PseudoVSSSEG6E8_V_MF4_MASK, VSSSEG6E8_V, 0x6, 0x8 }, // 9242 + { PseudoVSSSEG6E8_V_MF2, VSSSEG6E8_V, 0x7, 0x8 }, // 9243 + { PseudoVSSSEG6E8_V_MF2_MASK, VSSSEG6E8_V, 0x7, 0x8 }, // 9244 + { PseudoVSSSEG7E16_V_M1, VSSSEG7E16_V, 0x0, 0x10 }, // 9245 + { PseudoVSSSEG7E16_V_M1_MASK, VSSSEG7E16_V, 0x0, 0x10 }, // 9246 + { PseudoVSSSEG7E16_V_MF4, VSSSEG7E16_V, 0x6, 0x10 }, // 9247 + { PseudoVSSSEG7E16_V_MF4_MASK, VSSSEG7E16_V, 0x6, 0x10 }, // 9248 + { PseudoVSSSEG7E16_V_MF2, VSSSEG7E16_V, 0x7, 0x10 }, // 9249 + { PseudoVSSSEG7E16_V_MF2_MASK, VSSSEG7E16_V, 0x7, 0x10 }, // 9250 + { PseudoVSSSEG7E32_V_M1, VSSSEG7E32_V, 0x0, 0x20 }, // 9251 + { PseudoVSSSEG7E32_V_M1_MASK, VSSSEG7E32_V, 0x0, 0x20 }, // 9252 + { PseudoVSSSEG7E32_V_MF2, VSSSEG7E32_V, 0x7, 0x20 }, // 9253 + { PseudoVSSSEG7E32_V_MF2_MASK, VSSSEG7E32_V, 0x7, 0x20 }, // 9254 + { PseudoVSSSEG7E64_V_M1, VSSSEG7E64_V, 0x0, 0x40 }, // 9255 + { PseudoVSSSEG7E64_V_M1_MASK, VSSSEG7E64_V, 0x0, 0x40 }, // 9256 + { PseudoVSSSEG7E8_V_M1, VSSSEG7E8_V, 0x0, 0x8 }, // 9257 + { PseudoVSSSEG7E8_V_M1_MASK, VSSSEG7E8_V, 0x0, 0x8 }, // 9258 + { PseudoVSSSEG7E8_V_MF8, VSSSEG7E8_V, 0x5, 0x8 }, // 9259 + { PseudoVSSSEG7E8_V_MF8_MASK, VSSSEG7E8_V, 0x5, 0x8 }, // 9260 + { PseudoVSSSEG7E8_V_MF4, VSSSEG7E8_V, 0x6, 0x8 }, // 9261 + { PseudoVSSSEG7E8_V_MF4_MASK, VSSSEG7E8_V, 0x6, 0x8 }, // 9262 + { PseudoVSSSEG7E8_V_MF2, VSSSEG7E8_V, 0x7, 0x8 }, // 9263 + { PseudoVSSSEG7E8_V_MF2_MASK, VSSSEG7E8_V, 0x7, 0x8 }, // 9264 + { PseudoVSSSEG8E16_V_M1, VSSSEG8E16_V, 0x0, 0x10 }, // 9265 + { PseudoVSSSEG8E16_V_M1_MASK, VSSSEG8E16_V, 0x0, 0x10 }, // 9266 + { PseudoVSSSEG8E16_V_MF4, VSSSEG8E16_V, 0x6, 0x10 }, // 9267 + { PseudoVSSSEG8E16_V_MF4_MASK, VSSSEG8E16_V, 0x6, 0x10 }, // 9268 + { PseudoVSSSEG8E16_V_MF2, VSSSEG8E16_V, 0x7, 0x10 }, // 9269 + { PseudoVSSSEG8E16_V_MF2_MASK, VSSSEG8E16_V, 0x7, 0x10 }, // 9270 + { PseudoVSSSEG8E32_V_M1, VSSSEG8E32_V, 0x0, 0x20 }, // 9271 + { PseudoVSSSEG8E32_V_M1_MASK, VSSSEG8E32_V, 0x0, 0x20 }, // 9272 + { PseudoVSSSEG8E32_V_MF2, VSSSEG8E32_V, 0x7, 0x20 }, // 9273 + { PseudoVSSSEG8E32_V_MF2_MASK, VSSSEG8E32_V, 0x7, 0x20 }, // 9274 + { PseudoVSSSEG8E64_V_M1, VSSSEG8E64_V, 0x0, 0x40 }, // 9275 + { PseudoVSSSEG8E64_V_M1_MASK, VSSSEG8E64_V, 0x0, 0x40 }, // 9276 + { PseudoVSSSEG8E8_V_M1, VSSSEG8E8_V, 0x0, 0x8 }, // 9277 + { PseudoVSSSEG8E8_V_M1_MASK, VSSSEG8E8_V, 0x0, 0x8 }, // 9278 + { PseudoVSSSEG8E8_V_MF8, VSSSEG8E8_V, 0x5, 0x8 }, // 9279 + { PseudoVSSSEG8E8_V_MF8_MASK, VSSSEG8E8_V, 0x5, 0x8 }, // 9280 + { PseudoVSSSEG8E8_V_MF4, VSSSEG8E8_V, 0x6, 0x8 }, // 9281 + { PseudoVSSSEG8E8_V_MF4_MASK, VSSSEG8E8_V, 0x6, 0x8 }, // 9282 + { PseudoVSSSEG8E8_V_MF2, VSSSEG8E8_V, 0x7, 0x8 }, // 9283 + { PseudoVSSSEG8E8_V_MF2_MASK, VSSSEG8E8_V, 0x7, 0x8 }, // 9284 + { PseudoVSSUBU_VV_M1, VSSUBU_VV, 0x0, 0x0 }, // 9285 + { PseudoVSSUBU_VV_M1_MASK, VSSUBU_VV, 0x0, 0x0 }, // 9286 + { PseudoVSSUBU_VV_M2, VSSUBU_VV, 0x1, 0x0 }, // 9287 + { PseudoVSSUBU_VV_M2_MASK, VSSUBU_VV, 0x1, 0x0 }, // 9288 + { PseudoVSSUBU_VV_M4, VSSUBU_VV, 0x2, 0x0 }, // 9289 + { PseudoVSSUBU_VV_M4_MASK, VSSUBU_VV, 0x2, 0x0 }, // 9290 + { PseudoVSSUBU_VV_M8, VSSUBU_VV, 0x3, 0x0 }, // 9291 + { PseudoVSSUBU_VV_M8_MASK, VSSUBU_VV, 0x3, 0x0 }, // 9292 + { PseudoVSSUBU_VV_MF8, VSSUBU_VV, 0x5, 0x0 }, // 9293 + { PseudoVSSUBU_VV_MF8_MASK, VSSUBU_VV, 0x5, 0x0 }, // 9294 + { PseudoVSSUBU_VV_MF4, VSSUBU_VV, 0x6, 0x0 }, // 9295 + { PseudoVSSUBU_VV_MF4_MASK, VSSUBU_VV, 0x6, 0x0 }, // 9296 + { PseudoVSSUBU_VV_MF2, VSSUBU_VV, 0x7, 0x0 }, // 9297 + { PseudoVSSUBU_VV_MF2_MASK, VSSUBU_VV, 0x7, 0x0 }, // 9298 + { PseudoVSSUBU_VX_M1, VSSUBU_VX, 0x0, 0x0 }, // 9299 + { PseudoVSSUBU_VX_M1_MASK, VSSUBU_VX, 0x0, 0x0 }, // 9300 + { PseudoVSSUBU_VX_M2, VSSUBU_VX, 0x1, 0x0 }, // 9301 + { PseudoVSSUBU_VX_M2_MASK, VSSUBU_VX, 0x1, 0x0 }, // 9302 + { PseudoVSSUBU_VX_M4, VSSUBU_VX, 0x2, 0x0 }, // 9303 + { PseudoVSSUBU_VX_M4_MASK, VSSUBU_VX, 0x2, 0x0 }, // 9304 + { PseudoVSSUBU_VX_M8, VSSUBU_VX, 0x3, 0x0 }, // 9305 + { PseudoVSSUBU_VX_M8_MASK, VSSUBU_VX, 0x3, 0x0 }, // 9306 + { PseudoVSSUBU_VX_MF8, VSSUBU_VX, 0x5, 0x0 }, // 9307 + { PseudoVSSUBU_VX_MF8_MASK, VSSUBU_VX, 0x5, 0x0 }, // 9308 + { PseudoVSSUBU_VX_MF4, VSSUBU_VX, 0x6, 0x0 }, // 9309 + { PseudoVSSUBU_VX_MF4_MASK, VSSUBU_VX, 0x6, 0x0 }, // 9310 + { PseudoVSSUBU_VX_MF2, VSSUBU_VX, 0x7, 0x0 }, // 9311 + { PseudoVSSUBU_VX_MF2_MASK, VSSUBU_VX, 0x7, 0x0 }, // 9312 + { PseudoVSSUB_VV_M1, VSSUB_VV, 0x0, 0x0 }, // 9313 + { PseudoVSSUB_VV_M1_MASK, VSSUB_VV, 0x0, 0x0 }, // 9314 + { PseudoVSSUB_VV_M2, VSSUB_VV, 0x1, 0x0 }, // 9315 + { PseudoVSSUB_VV_M2_MASK, VSSUB_VV, 0x1, 0x0 }, // 9316 + { PseudoVSSUB_VV_M4, VSSUB_VV, 0x2, 0x0 }, // 9317 + { PseudoVSSUB_VV_M4_MASK, VSSUB_VV, 0x2, 0x0 }, // 9318 + { PseudoVSSUB_VV_M8, VSSUB_VV, 0x3, 0x0 }, // 9319 + { PseudoVSSUB_VV_M8_MASK, VSSUB_VV, 0x3, 0x0 }, // 9320 + { PseudoVSSUB_VV_MF8, VSSUB_VV, 0x5, 0x0 }, // 9321 + { PseudoVSSUB_VV_MF8_MASK, VSSUB_VV, 0x5, 0x0 }, // 9322 + { PseudoVSSUB_VV_MF4, VSSUB_VV, 0x6, 0x0 }, // 9323 + { PseudoVSSUB_VV_MF4_MASK, VSSUB_VV, 0x6, 0x0 }, // 9324 + { PseudoVSSUB_VV_MF2, VSSUB_VV, 0x7, 0x0 }, // 9325 + { PseudoVSSUB_VV_MF2_MASK, VSSUB_VV, 0x7, 0x0 }, // 9326 + { PseudoVSSUB_VX_M1, VSSUB_VX, 0x0, 0x0 }, // 9327 + { PseudoVSSUB_VX_M1_MASK, VSSUB_VX, 0x0, 0x0 }, // 9328 + { PseudoVSSUB_VX_M2, VSSUB_VX, 0x1, 0x0 }, // 9329 + { PseudoVSSUB_VX_M2_MASK, VSSUB_VX, 0x1, 0x0 }, // 9330 + { PseudoVSSUB_VX_M4, VSSUB_VX, 0x2, 0x0 }, // 9331 + { PseudoVSSUB_VX_M4_MASK, VSSUB_VX, 0x2, 0x0 }, // 9332 + { PseudoVSSUB_VX_M8, VSSUB_VX, 0x3, 0x0 }, // 9333 + { PseudoVSSUB_VX_M8_MASK, VSSUB_VX, 0x3, 0x0 }, // 9334 + { PseudoVSSUB_VX_MF8, VSSUB_VX, 0x5, 0x0 }, // 9335 + { PseudoVSSUB_VX_MF8_MASK, VSSUB_VX, 0x5, 0x0 }, // 9336 + { PseudoVSSUB_VX_MF4, VSSUB_VX, 0x6, 0x0 }, // 9337 + { PseudoVSSUB_VX_MF4_MASK, VSSUB_VX, 0x6, 0x0 }, // 9338 + { PseudoVSSUB_VX_MF2, VSSUB_VX, 0x7, 0x0 }, // 9339 + { PseudoVSSUB_VX_MF2_MASK, VSSUB_VX, 0x7, 0x0 }, // 9340 + { PseudoVSUB_VV_M1, VSUB_VV, 0x0, 0x0 }, // 9341 + { PseudoVSUB_VV_M1_MASK, VSUB_VV, 0x0, 0x0 }, // 9342 + { PseudoVSUB_VV_M2, VSUB_VV, 0x1, 0x0 }, // 9343 + { PseudoVSUB_VV_M2_MASK, VSUB_VV, 0x1, 0x0 }, // 9344 + { PseudoVSUB_VV_M4, VSUB_VV, 0x2, 0x0 }, // 9345 + { PseudoVSUB_VV_M4_MASK, VSUB_VV, 0x2, 0x0 }, // 9346 + { PseudoVSUB_VV_M8, VSUB_VV, 0x3, 0x0 }, // 9347 + { PseudoVSUB_VV_M8_MASK, VSUB_VV, 0x3, 0x0 }, // 9348 + { PseudoVSUB_VV_MF8, VSUB_VV, 0x5, 0x0 }, // 9349 + { PseudoVSUB_VV_MF8_MASK, VSUB_VV, 0x5, 0x0 }, // 9350 + { PseudoVSUB_VV_MF4, VSUB_VV, 0x6, 0x0 }, // 9351 + { PseudoVSUB_VV_MF4_MASK, VSUB_VV, 0x6, 0x0 }, // 9352 + { PseudoVSUB_VV_MF2, VSUB_VV, 0x7, 0x0 }, // 9353 + { PseudoVSUB_VV_MF2_MASK, VSUB_VV, 0x7, 0x0 }, // 9354 + { PseudoVSUB_VX_M1, VSUB_VX, 0x0, 0x0 }, // 9355 + { PseudoVSUB_VX_M1_MASK, VSUB_VX, 0x0, 0x0 }, // 9356 + { PseudoVSUB_VX_M2, VSUB_VX, 0x1, 0x0 }, // 9357 + { PseudoVSUB_VX_M2_MASK, VSUB_VX, 0x1, 0x0 }, // 9358 + { PseudoVSUB_VX_M4, VSUB_VX, 0x2, 0x0 }, // 9359 + { PseudoVSUB_VX_M4_MASK, VSUB_VX, 0x2, 0x0 }, // 9360 + { PseudoVSUB_VX_M8, VSUB_VX, 0x3, 0x0 }, // 9361 + { PseudoVSUB_VX_M8_MASK, VSUB_VX, 0x3, 0x0 }, // 9362 + { PseudoVSUB_VX_MF8, VSUB_VX, 0x5, 0x0 }, // 9363 + { PseudoVSUB_VX_MF8_MASK, VSUB_VX, 0x5, 0x0 }, // 9364 + { PseudoVSUB_VX_MF4, VSUB_VX, 0x6, 0x0 }, // 9365 + { PseudoVSUB_VX_MF4_MASK, VSUB_VX, 0x6, 0x0 }, // 9366 + { PseudoVSUB_VX_MF2, VSUB_VX, 0x7, 0x0 }, // 9367 + { PseudoVSUB_VX_MF2_MASK, VSUB_VX, 0x7, 0x0 }, // 9368 + { PseudoVSUXEI16_V_M1_M1, VSUXEI16_V, 0x0, 0x0 }, // 9369 + { PseudoVSUXEI16_V_M1_M1_MASK, VSUXEI16_V, 0x0, 0x0 }, // 9370 + { PseudoVSUXEI16_V_M2_M1, VSUXEI16_V, 0x0, 0x0 }, // 9371 + { PseudoVSUXEI16_V_M2_M1_MASK, VSUXEI16_V, 0x0, 0x0 }, // 9372 + { PseudoVSUXEI16_V_MF2_M1, VSUXEI16_V, 0x0, 0x0 }, // 9373 + { PseudoVSUXEI16_V_MF2_M1_MASK, VSUXEI16_V, 0x0, 0x0 }, // 9374 + { PseudoVSUXEI16_V_MF4_M1, VSUXEI16_V, 0x0, 0x0 }, // 9375 + { PseudoVSUXEI16_V_MF4_M1_MASK, VSUXEI16_V, 0x0, 0x0 }, // 9376 + { PseudoVSUXEI16_V_M1_M2, VSUXEI16_V, 0x1, 0x0 }, // 9377 + { PseudoVSUXEI16_V_M1_M2_MASK, VSUXEI16_V, 0x1, 0x0 }, // 9378 + { PseudoVSUXEI16_V_M2_M2, VSUXEI16_V, 0x1, 0x0 }, // 9379 + { PseudoVSUXEI16_V_M2_M2_MASK, VSUXEI16_V, 0x1, 0x0 }, // 9380 + { PseudoVSUXEI16_V_M4_M2, VSUXEI16_V, 0x1, 0x0 }, // 9381 + { PseudoVSUXEI16_V_M4_M2_MASK, VSUXEI16_V, 0x1, 0x0 }, // 9382 + { PseudoVSUXEI16_V_MF2_M2, VSUXEI16_V, 0x1, 0x0 }, // 9383 + { PseudoVSUXEI16_V_MF2_M2_MASK, VSUXEI16_V, 0x1, 0x0 }, // 9384 + { PseudoVSUXEI16_V_M1_M4, VSUXEI16_V, 0x2, 0x0 }, // 9385 + { PseudoVSUXEI16_V_M1_M4_MASK, VSUXEI16_V, 0x2, 0x0 }, // 9386 + { PseudoVSUXEI16_V_M2_M4, VSUXEI16_V, 0x2, 0x0 }, // 9387 + { PseudoVSUXEI16_V_M2_M4_MASK, VSUXEI16_V, 0x2, 0x0 }, // 9388 + { PseudoVSUXEI16_V_M4_M4, VSUXEI16_V, 0x2, 0x0 }, // 9389 + { PseudoVSUXEI16_V_M4_M4_MASK, VSUXEI16_V, 0x2, 0x0 }, // 9390 + { PseudoVSUXEI16_V_M8_M4, VSUXEI16_V, 0x2, 0x0 }, // 9391 + { PseudoVSUXEI16_V_M8_M4_MASK, VSUXEI16_V, 0x2, 0x0 }, // 9392 + { PseudoVSUXEI16_V_M2_M8, VSUXEI16_V, 0x3, 0x0 }, // 9393 + { PseudoVSUXEI16_V_M2_M8_MASK, VSUXEI16_V, 0x3, 0x0 }, // 9394 + { PseudoVSUXEI16_V_M4_M8, VSUXEI16_V, 0x3, 0x0 }, // 9395 + { PseudoVSUXEI16_V_M4_M8_MASK, VSUXEI16_V, 0x3, 0x0 }, // 9396 + { PseudoVSUXEI16_V_M8_M8, VSUXEI16_V, 0x3, 0x0 }, // 9397 + { PseudoVSUXEI16_V_M8_M8_MASK, VSUXEI16_V, 0x3, 0x0 }, // 9398 + { PseudoVSUXEI16_V_MF4_MF8, VSUXEI16_V, 0x5, 0x0 }, // 9399 + { PseudoVSUXEI16_V_MF4_MF8_MASK, VSUXEI16_V, 0x5, 0x0 }, // 9400 + { PseudoVSUXEI16_V_MF2_MF4, VSUXEI16_V, 0x6, 0x0 }, // 9401 + { PseudoVSUXEI16_V_MF2_MF4_MASK, VSUXEI16_V, 0x6, 0x0 }, // 9402 + { PseudoVSUXEI16_V_MF4_MF4, VSUXEI16_V, 0x6, 0x0 }, // 9403 + { PseudoVSUXEI16_V_MF4_MF4_MASK, VSUXEI16_V, 0x6, 0x0 }, // 9404 + { PseudoVSUXEI16_V_M1_MF2, VSUXEI16_V, 0x7, 0x0 }, // 9405 + { PseudoVSUXEI16_V_M1_MF2_MASK, VSUXEI16_V, 0x7, 0x0 }, // 9406 + { PseudoVSUXEI16_V_MF2_MF2, VSUXEI16_V, 0x7, 0x0 }, // 9407 + { PseudoVSUXEI16_V_MF2_MF2_MASK, VSUXEI16_V, 0x7, 0x0 }, // 9408 + { PseudoVSUXEI16_V_MF4_MF2, VSUXEI16_V, 0x7, 0x0 }, // 9409 + { PseudoVSUXEI16_V_MF4_MF2_MASK, VSUXEI16_V, 0x7, 0x0 }, // 9410 + { PseudoVSUXEI32_V_M1_M1, VSUXEI32_V, 0x0, 0x0 }, // 9411 + { PseudoVSUXEI32_V_M1_M1_MASK, VSUXEI32_V, 0x0, 0x0 }, // 9412 + { PseudoVSUXEI32_V_M2_M1, VSUXEI32_V, 0x0, 0x0 }, // 9413 + { PseudoVSUXEI32_V_M2_M1_MASK, VSUXEI32_V, 0x0, 0x0 }, // 9414 + { PseudoVSUXEI32_V_M4_M1, VSUXEI32_V, 0x0, 0x0 }, // 9415 + { PseudoVSUXEI32_V_M4_M1_MASK, VSUXEI32_V, 0x0, 0x0 }, // 9416 + { PseudoVSUXEI32_V_MF2_M1, VSUXEI32_V, 0x0, 0x0 }, // 9417 + { PseudoVSUXEI32_V_MF2_M1_MASK, VSUXEI32_V, 0x0, 0x0 }, // 9418 + { PseudoVSUXEI32_V_M1_M2, VSUXEI32_V, 0x1, 0x0 }, // 9419 + { PseudoVSUXEI32_V_M1_M2_MASK, VSUXEI32_V, 0x1, 0x0 }, // 9420 + { PseudoVSUXEI32_V_M2_M2, VSUXEI32_V, 0x1, 0x0 }, // 9421 + { PseudoVSUXEI32_V_M2_M2_MASK, VSUXEI32_V, 0x1, 0x0 }, // 9422 + { PseudoVSUXEI32_V_M4_M2, VSUXEI32_V, 0x1, 0x0 }, // 9423 + { PseudoVSUXEI32_V_M4_M2_MASK, VSUXEI32_V, 0x1, 0x0 }, // 9424 + { PseudoVSUXEI32_V_M8_M2, VSUXEI32_V, 0x1, 0x0 }, // 9425 + { PseudoVSUXEI32_V_M8_M2_MASK, VSUXEI32_V, 0x1, 0x0 }, // 9426 + { PseudoVSUXEI32_V_M2_M4, VSUXEI32_V, 0x2, 0x0 }, // 9427 + { PseudoVSUXEI32_V_M2_M4_MASK, VSUXEI32_V, 0x2, 0x0 }, // 9428 + { PseudoVSUXEI32_V_M4_M4, VSUXEI32_V, 0x2, 0x0 }, // 9429 + { PseudoVSUXEI32_V_M4_M4_MASK, VSUXEI32_V, 0x2, 0x0 }, // 9430 + { PseudoVSUXEI32_V_M8_M4, VSUXEI32_V, 0x2, 0x0 }, // 9431 + { PseudoVSUXEI32_V_M8_M4_MASK, VSUXEI32_V, 0x2, 0x0 }, // 9432 + { PseudoVSUXEI32_V_M4_M8, VSUXEI32_V, 0x3, 0x0 }, // 9433 + { PseudoVSUXEI32_V_M4_M8_MASK, VSUXEI32_V, 0x3, 0x0 }, // 9434 + { PseudoVSUXEI32_V_M8_M8, VSUXEI32_V, 0x3, 0x0 }, // 9435 + { PseudoVSUXEI32_V_M8_M8_MASK, VSUXEI32_V, 0x3, 0x0 }, // 9436 + { PseudoVSUXEI32_V_MF2_MF8, VSUXEI32_V, 0x5, 0x0 }, // 9437 + { PseudoVSUXEI32_V_MF2_MF8_MASK, VSUXEI32_V, 0x5, 0x0 }, // 9438 + { PseudoVSUXEI32_V_M1_MF4, VSUXEI32_V, 0x6, 0x0 }, // 9439 + { PseudoVSUXEI32_V_M1_MF4_MASK, VSUXEI32_V, 0x6, 0x0 }, // 9440 + { PseudoVSUXEI32_V_MF2_MF4, VSUXEI32_V, 0x6, 0x0 }, // 9441 + { PseudoVSUXEI32_V_MF2_MF4_MASK, VSUXEI32_V, 0x6, 0x0 }, // 9442 + { PseudoVSUXEI32_V_M1_MF2, VSUXEI32_V, 0x7, 0x0 }, // 9443 + { PseudoVSUXEI32_V_M1_MF2_MASK, VSUXEI32_V, 0x7, 0x0 }, // 9444 + { PseudoVSUXEI32_V_M2_MF2, VSUXEI32_V, 0x7, 0x0 }, // 9445 + { PseudoVSUXEI32_V_M2_MF2_MASK, VSUXEI32_V, 0x7, 0x0 }, // 9446 + { PseudoVSUXEI32_V_MF2_MF2, VSUXEI32_V, 0x7, 0x0 }, // 9447 + { PseudoVSUXEI32_V_MF2_MF2_MASK, VSUXEI32_V, 0x7, 0x0 }, // 9448 + { PseudoVSUXEI64_V_M1_M1, VSUXEI64_V, 0x0, 0x0 }, // 9449 + { PseudoVSUXEI64_V_M1_M1_MASK, VSUXEI64_V, 0x0, 0x0 }, // 9450 + { PseudoVSUXEI64_V_M2_M1, VSUXEI64_V, 0x0, 0x0 }, // 9451 + { PseudoVSUXEI64_V_M2_M1_MASK, VSUXEI64_V, 0x0, 0x0 }, // 9452 + { PseudoVSUXEI64_V_M4_M1, VSUXEI64_V, 0x0, 0x0 }, // 9453 + { PseudoVSUXEI64_V_M4_M1_MASK, VSUXEI64_V, 0x0, 0x0 }, // 9454 + { PseudoVSUXEI64_V_M8_M1, VSUXEI64_V, 0x0, 0x0 }, // 9455 + { PseudoVSUXEI64_V_M8_M1_MASK, VSUXEI64_V, 0x0, 0x0 }, // 9456 + { PseudoVSUXEI64_V_M2_M2, VSUXEI64_V, 0x1, 0x0 }, // 9457 + { PseudoVSUXEI64_V_M2_M2_MASK, VSUXEI64_V, 0x1, 0x0 }, // 9458 + { PseudoVSUXEI64_V_M4_M2, VSUXEI64_V, 0x1, 0x0 }, // 9459 + { PseudoVSUXEI64_V_M4_M2_MASK, VSUXEI64_V, 0x1, 0x0 }, // 9460 + { PseudoVSUXEI64_V_M8_M2, VSUXEI64_V, 0x1, 0x0 }, // 9461 + { PseudoVSUXEI64_V_M8_M2_MASK, VSUXEI64_V, 0x1, 0x0 }, // 9462 + { PseudoVSUXEI64_V_M4_M4, VSUXEI64_V, 0x2, 0x0 }, // 9463 + { PseudoVSUXEI64_V_M4_M4_MASK, VSUXEI64_V, 0x2, 0x0 }, // 9464 + { PseudoVSUXEI64_V_M8_M4, VSUXEI64_V, 0x2, 0x0 }, // 9465 + { PseudoVSUXEI64_V_M8_M4_MASK, VSUXEI64_V, 0x2, 0x0 }, // 9466 + { PseudoVSUXEI64_V_M8_M8, VSUXEI64_V, 0x3, 0x0 }, // 9467 + { PseudoVSUXEI64_V_M8_M8_MASK, VSUXEI64_V, 0x3, 0x0 }, // 9468 + { PseudoVSUXEI64_V_M1_MF8, VSUXEI64_V, 0x5, 0x0 }, // 9469 + { PseudoVSUXEI64_V_M1_MF8_MASK, VSUXEI64_V, 0x5, 0x0 }, // 9470 + { PseudoVSUXEI64_V_M1_MF4, VSUXEI64_V, 0x6, 0x0 }, // 9471 + { PseudoVSUXEI64_V_M1_MF4_MASK, VSUXEI64_V, 0x6, 0x0 }, // 9472 + { PseudoVSUXEI64_V_M2_MF4, VSUXEI64_V, 0x6, 0x0 }, // 9473 + { PseudoVSUXEI64_V_M2_MF4_MASK, VSUXEI64_V, 0x6, 0x0 }, // 9474 + { PseudoVSUXEI64_V_M1_MF2, VSUXEI64_V, 0x7, 0x0 }, // 9475 + { PseudoVSUXEI64_V_M1_MF2_MASK, VSUXEI64_V, 0x7, 0x0 }, // 9476 + { PseudoVSUXEI64_V_M2_MF2, VSUXEI64_V, 0x7, 0x0 }, // 9477 + { PseudoVSUXEI64_V_M2_MF2_MASK, VSUXEI64_V, 0x7, 0x0 }, // 9478 + { PseudoVSUXEI64_V_M4_MF2, VSUXEI64_V, 0x7, 0x0 }, // 9479 + { PseudoVSUXEI64_V_M4_MF2_MASK, VSUXEI64_V, 0x7, 0x0 }, // 9480 + { PseudoVSUXEI8_V_M1_M1, VSUXEI8_V, 0x0, 0x0 }, // 9481 + { PseudoVSUXEI8_V_M1_M1_MASK, VSUXEI8_V, 0x0, 0x0 }, // 9482 + { PseudoVSUXEI8_V_MF2_M1, VSUXEI8_V, 0x0, 0x0 }, // 9483 + { PseudoVSUXEI8_V_MF2_M1_MASK, VSUXEI8_V, 0x0, 0x0 }, // 9484 + { PseudoVSUXEI8_V_MF4_M1, VSUXEI8_V, 0x0, 0x0 }, // 9485 + { PseudoVSUXEI8_V_MF4_M1_MASK, VSUXEI8_V, 0x0, 0x0 }, // 9486 + { PseudoVSUXEI8_V_MF8_M1, VSUXEI8_V, 0x0, 0x0 }, // 9487 + { PseudoVSUXEI8_V_MF8_M1_MASK, VSUXEI8_V, 0x0, 0x0 }, // 9488 + { PseudoVSUXEI8_V_M1_M2, VSUXEI8_V, 0x1, 0x0 }, // 9489 + { PseudoVSUXEI8_V_M1_M2_MASK, VSUXEI8_V, 0x1, 0x0 }, // 9490 + { PseudoVSUXEI8_V_M2_M2, VSUXEI8_V, 0x1, 0x0 }, // 9491 + { PseudoVSUXEI8_V_M2_M2_MASK, VSUXEI8_V, 0x1, 0x0 }, // 9492 + { PseudoVSUXEI8_V_MF2_M2, VSUXEI8_V, 0x1, 0x0 }, // 9493 + { PseudoVSUXEI8_V_MF2_M2_MASK, VSUXEI8_V, 0x1, 0x0 }, // 9494 + { PseudoVSUXEI8_V_MF4_M2, VSUXEI8_V, 0x1, 0x0 }, // 9495 + { PseudoVSUXEI8_V_MF4_M2_MASK, VSUXEI8_V, 0x1, 0x0 }, // 9496 + { PseudoVSUXEI8_V_M1_M4, VSUXEI8_V, 0x2, 0x0 }, // 9497 + { PseudoVSUXEI8_V_M1_M4_MASK, VSUXEI8_V, 0x2, 0x0 }, // 9498 + { PseudoVSUXEI8_V_M2_M4, VSUXEI8_V, 0x2, 0x0 }, // 9499 + { PseudoVSUXEI8_V_M2_M4_MASK, VSUXEI8_V, 0x2, 0x0 }, // 9500 + { PseudoVSUXEI8_V_M4_M4, VSUXEI8_V, 0x2, 0x0 }, // 9501 + { PseudoVSUXEI8_V_M4_M4_MASK, VSUXEI8_V, 0x2, 0x0 }, // 9502 + { PseudoVSUXEI8_V_MF2_M4, VSUXEI8_V, 0x2, 0x0 }, // 9503 + { PseudoVSUXEI8_V_MF2_M4_MASK, VSUXEI8_V, 0x2, 0x0 }, // 9504 + { PseudoVSUXEI8_V_M1_M8, VSUXEI8_V, 0x3, 0x0 }, // 9505 + { PseudoVSUXEI8_V_M1_M8_MASK, VSUXEI8_V, 0x3, 0x0 }, // 9506 + { PseudoVSUXEI8_V_M2_M8, VSUXEI8_V, 0x3, 0x0 }, // 9507 + { PseudoVSUXEI8_V_M2_M8_MASK, VSUXEI8_V, 0x3, 0x0 }, // 9508 + { PseudoVSUXEI8_V_M4_M8, VSUXEI8_V, 0x3, 0x0 }, // 9509 + { PseudoVSUXEI8_V_M4_M8_MASK, VSUXEI8_V, 0x3, 0x0 }, // 9510 + { PseudoVSUXEI8_V_M8_M8, VSUXEI8_V, 0x3, 0x0 }, // 9511 + { PseudoVSUXEI8_V_M8_M8_MASK, VSUXEI8_V, 0x3, 0x0 }, // 9512 + { PseudoVSUXEI8_V_MF8_MF8, VSUXEI8_V, 0x5, 0x0 }, // 9513 + { PseudoVSUXEI8_V_MF8_MF8_MASK, VSUXEI8_V, 0x5, 0x0 }, // 9514 + { PseudoVSUXEI8_V_MF4_MF4, VSUXEI8_V, 0x6, 0x0 }, // 9515 + { PseudoVSUXEI8_V_MF4_MF4_MASK, VSUXEI8_V, 0x6, 0x0 }, // 9516 + { PseudoVSUXEI8_V_MF8_MF4, VSUXEI8_V, 0x6, 0x0 }, // 9517 + { PseudoVSUXEI8_V_MF8_MF4_MASK, VSUXEI8_V, 0x6, 0x0 }, // 9518 + { PseudoVSUXEI8_V_MF2_MF2, VSUXEI8_V, 0x7, 0x0 }, // 9519 + { PseudoVSUXEI8_V_MF2_MF2_MASK, VSUXEI8_V, 0x7, 0x0 }, // 9520 + { PseudoVSUXEI8_V_MF4_MF2, VSUXEI8_V, 0x7, 0x0 }, // 9521 + { PseudoVSUXEI8_V_MF4_MF2_MASK, VSUXEI8_V, 0x7, 0x0 }, // 9522 + { PseudoVSUXEI8_V_MF8_MF2, VSUXEI8_V, 0x7, 0x0 }, // 9523 + { PseudoVSUXEI8_V_MF8_MF2_MASK, VSUXEI8_V, 0x7, 0x0 }, // 9524 + { PseudoVSUXSEG2EI16_V_M1_M1, VSUXSEG2EI16_V, 0x0, 0x0 }, // 9525 + { PseudoVSUXSEG2EI16_V_M1_M1_MASK, VSUXSEG2EI16_V, 0x0, 0x0 }, // 9526 + { PseudoVSUXSEG2EI16_V_M2_M1, VSUXSEG2EI16_V, 0x0, 0x0 }, // 9527 + { PseudoVSUXSEG2EI16_V_M2_M1_MASK, VSUXSEG2EI16_V, 0x0, 0x0 }, // 9528 + { PseudoVSUXSEG2EI16_V_MF2_M1, VSUXSEG2EI16_V, 0x0, 0x0 }, // 9529 + { PseudoVSUXSEG2EI16_V_MF2_M1_MASK, VSUXSEG2EI16_V, 0x0, 0x0 }, // 9530 + { PseudoVSUXSEG2EI16_V_MF4_M1, VSUXSEG2EI16_V, 0x0, 0x0 }, // 9531 + { PseudoVSUXSEG2EI16_V_MF4_M1_MASK, VSUXSEG2EI16_V, 0x0, 0x0 }, // 9532 + { PseudoVSUXSEG2EI16_V_M1_M2, VSUXSEG2EI16_V, 0x1, 0x0 }, // 9533 + { PseudoVSUXSEG2EI16_V_M1_M2_MASK, VSUXSEG2EI16_V, 0x1, 0x0 }, // 9534 + { PseudoVSUXSEG2EI16_V_M2_M2, VSUXSEG2EI16_V, 0x1, 0x0 }, // 9535 + { PseudoVSUXSEG2EI16_V_M2_M2_MASK, VSUXSEG2EI16_V, 0x1, 0x0 }, // 9536 + { PseudoVSUXSEG2EI16_V_M4_M2, VSUXSEG2EI16_V, 0x1, 0x0 }, // 9537 + { PseudoVSUXSEG2EI16_V_M4_M2_MASK, VSUXSEG2EI16_V, 0x1, 0x0 }, // 9538 + { PseudoVSUXSEG2EI16_V_MF2_M2, VSUXSEG2EI16_V, 0x1, 0x0 }, // 9539 + { PseudoVSUXSEG2EI16_V_MF2_M2_MASK, VSUXSEG2EI16_V, 0x1, 0x0 }, // 9540 + { PseudoVSUXSEG2EI16_V_M1_M4, VSUXSEG2EI16_V, 0x2, 0x0 }, // 9541 + { PseudoVSUXSEG2EI16_V_M1_M4_MASK, VSUXSEG2EI16_V, 0x2, 0x0 }, // 9542 + { PseudoVSUXSEG2EI16_V_M2_M4, VSUXSEG2EI16_V, 0x2, 0x0 }, // 9543 + { PseudoVSUXSEG2EI16_V_M2_M4_MASK, VSUXSEG2EI16_V, 0x2, 0x0 }, // 9544 + { PseudoVSUXSEG2EI16_V_M4_M4, VSUXSEG2EI16_V, 0x2, 0x0 }, // 9545 + { PseudoVSUXSEG2EI16_V_M4_M4_MASK, VSUXSEG2EI16_V, 0x2, 0x0 }, // 9546 + { PseudoVSUXSEG2EI16_V_M8_M4, VSUXSEG2EI16_V, 0x2, 0x0 }, // 9547 + { PseudoVSUXSEG2EI16_V_M8_M4_MASK, VSUXSEG2EI16_V, 0x2, 0x0 }, // 9548 + { PseudoVSUXSEG2EI16_V_MF4_MF8, VSUXSEG2EI16_V, 0x5, 0x0 }, // 9549 + { PseudoVSUXSEG2EI16_V_MF4_MF8_MASK, VSUXSEG2EI16_V, 0x5, 0x0 }, // 9550 + { PseudoVSUXSEG2EI16_V_MF2_MF4, VSUXSEG2EI16_V, 0x6, 0x0 }, // 9551 + { PseudoVSUXSEG2EI16_V_MF2_MF4_MASK, VSUXSEG2EI16_V, 0x6, 0x0 }, // 9552 + { PseudoVSUXSEG2EI16_V_MF4_MF4, VSUXSEG2EI16_V, 0x6, 0x0 }, // 9553 + { PseudoVSUXSEG2EI16_V_MF4_MF4_MASK, VSUXSEG2EI16_V, 0x6, 0x0 }, // 9554 + { PseudoVSUXSEG2EI16_V_M1_MF2, VSUXSEG2EI16_V, 0x7, 0x0 }, // 9555 + { PseudoVSUXSEG2EI16_V_M1_MF2_MASK, VSUXSEG2EI16_V, 0x7, 0x0 }, // 9556 + { PseudoVSUXSEG2EI16_V_MF2_MF2, VSUXSEG2EI16_V, 0x7, 0x0 }, // 9557 + { PseudoVSUXSEG2EI16_V_MF2_MF2_MASK, VSUXSEG2EI16_V, 0x7, 0x0 }, // 9558 + { PseudoVSUXSEG2EI16_V_MF4_MF2, VSUXSEG2EI16_V, 0x7, 0x0 }, // 9559 + { PseudoVSUXSEG2EI16_V_MF4_MF2_MASK, VSUXSEG2EI16_V, 0x7, 0x0 }, // 9560 + { PseudoVSUXSEG2EI32_V_M1_M1, VSUXSEG2EI32_V, 0x0, 0x0 }, // 9561 + { PseudoVSUXSEG2EI32_V_M1_M1_MASK, VSUXSEG2EI32_V, 0x0, 0x0 }, // 9562 + { PseudoVSUXSEG2EI32_V_M2_M1, VSUXSEG2EI32_V, 0x0, 0x0 }, // 9563 + { PseudoVSUXSEG2EI32_V_M2_M1_MASK, VSUXSEG2EI32_V, 0x0, 0x0 }, // 9564 + { PseudoVSUXSEG2EI32_V_M4_M1, VSUXSEG2EI32_V, 0x0, 0x0 }, // 9565 + { PseudoVSUXSEG2EI32_V_M4_M1_MASK, VSUXSEG2EI32_V, 0x0, 0x0 }, // 9566 + { PseudoVSUXSEG2EI32_V_MF2_M1, VSUXSEG2EI32_V, 0x0, 0x0 }, // 9567 + { PseudoVSUXSEG2EI32_V_MF2_M1_MASK, VSUXSEG2EI32_V, 0x0, 0x0 }, // 9568 + { PseudoVSUXSEG2EI32_V_M1_M2, VSUXSEG2EI32_V, 0x1, 0x0 }, // 9569 + { PseudoVSUXSEG2EI32_V_M1_M2_MASK, VSUXSEG2EI32_V, 0x1, 0x0 }, // 9570 + { PseudoVSUXSEG2EI32_V_M2_M2, VSUXSEG2EI32_V, 0x1, 0x0 }, // 9571 + { PseudoVSUXSEG2EI32_V_M2_M2_MASK, VSUXSEG2EI32_V, 0x1, 0x0 }, // 9572 + { PseudoVSUXSEG2EI32_V_M4_M2, VSUXSEG2EI32_V, 0x1, 0x0 }, // 9573 + { PseudoVSUXSEG2EI32_V_M4_M2_MASK, VSUXSEG2EI32_V, 0x1, 0x0 }, // 9574 + { PseudoVSUXSEG2EI32_V_M8_M2, VSUXSEG2EI32_V, 0x1, 0x0 }, // 9575 + { PseudoVSUXSEG2EI32_V_M8_M2_MASK, VSUXSEG2EI32_V, 0x1, 0x0 }, // 9576 + { PseudoVSUXSEG2EI32_V_M2_M4, VSUXSEG2EI32_V, 0x2, 0x0 }, // 9577 + { PseudoVSUXSEG2EI32_V_M2_M4_MASK, VSUXSEG2EI32_V, 0x2, 0x0 }, // 9578 + { PseudoVSUXSEG2EI32_V_M4_M4, VSUXSEG2EI32_V, 0x2, 0x0 }, // 9579 + { PseudoVSUXSEG2EI32_V_M4_M4_MASK, VSUXSEG2EI32_V, 0x2, 0x0 }, // 9580 + { PseudoVSUXSEG2EI32_V_M8_M4, VSUXSEG2EI32_V, 0x2, 0x0 }, // 9581 + { PseudoVSUXSEG2EI32_V_M8_M4_MASK, VSUXSEG2EI32_V, 0x2, 0x0 }, // 9582 + { PseudoVSUXSEG2EI32_V_MF2_MF8, VSUXSEG2EI32_V, 0x5, 0x0 }, // 9583 + { PseudoVSUXSEG2EI32_V_MF2_MF8_MASK, VSUXSEG2EI32_V, 0x5, 0x0 }, // 9584 + { PseudoVSUXSEG2EI32_V_M1_MF4, VSUXSEG2EI32_V, 0x6, 0x0 }, // 9585 + { PseudoVSUXSEG2EI32_V_M1_MF4_MASK, VSUXSEG2EI32_V, 0x6, 0x0 }, // 9586 + { PseudoVSUXSEG2EI32_V_MF2_MF4, VSUXSEG2EI32_V, 0x6, 0x0 }, // 9587 + { PseudoVSUXSEG2EI32_V_MF2_MF4_MASK, VSUXSEG2EI32_V, 0x6, 0x0 }, // 9588 + { PseudoVSUXSEG2EI32_V_M1_MF2, VSUXSEG2EI32_V, 0x7, 0x0 }, // 9589 + { PseudoVSUXSEG2EI32_V_M1_MF2_MASK, VSUXSEG2EI32_V, 0x7, 0x0 }, // 9590 + { PseudoVSUXSEG2EI32_V_M2_MF2, VSUXSEG2EI32_V, 0x7, 0x0 }, // 9591 + { PseudoVSUXSEG2EI32_V_M2_MF2_MASK, VSUXSEG2EI32_V, 0x7, 0x0 }, // 9592 + { PseudoVSUXSEG2EI32_V_MF2_MF2, VSUXSEG2EI32_V, 0x7, 0x0 }, // 9593 + { PseudoVSUXSEG2EI32_V_MF2_MF2_MASK, VSUXSEG2EI32_V, 0x7, 0x0 }, // 9594 + { PseudoVSUXSEG2EI64_V_M1_M1, VSUXSEG2EI64_V, 0x0, 0x0 }, // 9595 + { PseudoVSUXSEG2EI64_V_M1_M1_MASK, VSUXSEG2EI64_V, 0x0, 0x0 }, // 9596 + { PseudoVSUXSEG2EI64_V_M2_M1, VSUXSEG2EI64_V, 0x0, 0x0 }, // 9597 + { PseudoVSUXSEG2EI64_V_M2_M1_MASK, VSUXSEG2EI64_V, 0x0, 0x0 }, // 9598 + { PseudoVSUXSEG2EI64_V_M4_M1, VSUXSEG2EI64_V, 0x0, 0x0 }, // 9599 + { PseudoVSUXSEG2EI64_V_M4_M1_MASK, VSUXSEG2EI64_V, 0x0, 0x0 }, // 9600 + { PseudoVSUXSEG2EI64_V_M8_M1, VSUXSEG2EI64_V, 0x0, 0x0 }, // 9601 + { PseudoVSUXSEG2EI64_V_M8_M1_MASK, VSUXSEG2EI64_V, 0x0, 0x0 }, // 9602 + { PseudoVSUXSEG2EI64_V_M2_M2, VSUXSEG2EI64_V, 0x1, 0x0 }, // 9603 + { PseudoVSUXSEG2EI64_V_M2_M2_MASK, VSUXSEG2EI64_V, 0x1, 0x0 }, // 9604 + { PseudoVSUXSEG2EI64_V_M4_M2, VSUXSEG2EI64_V, 0x1, 0x0 }, // 9605 + { PseudoVSUXSEG2EI64_V_M4_M2_MASK, VSUXSEG2EI64_V, 0x1, 0x0 }, // 9606 + { PseudoVSUXSEG2EI64_V_M8_M2, VSUXSEG2EI64_V, 0x1, 0x0 }, // 9607 + { PseudoVSUXSEG2EI64_V_M8_M2_MASK, VSUXSEG2EI64_V, 0x1, 0x0 }, // 9608 + { PseudoVSUXSEG2EI64_V_M4_M4, VSUXSEG2EI64_V, 0x2, 0x0 }, // 9609 + { PseudoVSUXSEG2EI64_V_M4_M4_MASK, VSUXSEG2EI64_V, 0x2, 0x0 }, // 9610 + { PseudoVSUXSEG2EI64_V_M8_M4, VSUXSEG2EI64_V, 0x2, 0x0 }, // 9611 + { PseudoVSUXSEG2EI64_V_M8_M4_MASK, VSUXSEG2EI64_V, 0x2, 0x0 }, // 9612 + { PseudoVSUXSEG2EI64_V_M1_MF8, VSUXSEG2EI64_V, 0x5, 0x0 }, // 9613 + { PseudoVSUXSEG2EI64_V_M1_MF8_MASK, VSUXSEG2EI64_V, 0x5, 0x0 }, // 9614 + { PseudoVSUXSEG2EI64_V_M1_MF4, VSUXSEG2EI64_V, 0x6, 0x0 }, // 9615 + { PseudoVSUXSEG2EI64_V_M1_MF4_MASK, VSUXSEG2EI64_V, 0x6, 0x0 }, // 9616 + { PseudoVSUXSEG2EI64_V_M2_MF4, VSUXSEG2EI64_V, 0x6, 0x0 }, // 9617 + { PseudoVSUXSEG2EI64_V_M2_MF4_MASK, VSUXSEG2EI64_V, 0x6, 0x0 }, // 9618 + { PseudoVSUXSEG2EI64_V_M1_MF2, VSUXSEG2EI64_V, 0x7, 0x0 }, // 9619 + { PseudoVSUXSEG2EI64_V_M1_MF2_MASK, VSUXSEG2EI64_V, 0x7, 0x0 }, // 9620 + { PseudoVSUXSEG2EI64_V_M2_MF2, VSUXSEG2EI64_V, 0x7, 0x0 }, // 9621 + { PseudoVSUXSEG2EI64_V_M2_MF2_MASK, VSUXSEG2EI64_V, 0x7, 0x0 }, // 9622 + { PseudoVSUXSEG2EI64_V_M4_MF2, VSUXSEG2EI64_V, 0x7, 0x0 }, // 9623 + { PseudoVSUXSEG2EI64_V_M4_MF2_MASK, VSUXSEG2EI64_V, 0x7, 0x0 }, // 9624 + { PseudoVSUXSEG2EI8_V_M1_M1, VSUXSEG2EI8_V, 0x0, 0x0 }, // 9625 + { PseudoVSUXSEG2EI8_V_M1_M1_MASK, VSUXSEG2EI8_V, 0x0, 0x0 }, // 9626 + { PseudoVSUXSEG2EI8_V_MF2_M1, VSUXSEG2EI8_V, 0x0, 0x0 }, // 9627 + { PseudoVSUXSEG2EI8_V_MF2_M1_MASK, VSUXSEG2EI8_V, 0x0, 0x0 }, // 9628 + { PseudoVSUXSEG2EI8_V_MF4_M1, VSUXSEG2EI8_V, 0x0, 0x0 }, // 9629 + { PseudoVSUXSEG2EI8_V_MF4_M1_MASK, VSUXSEG2EI8_V, 0x0, 0x0 }, // 9630 + { PseudoVSUXSEG2EI8_V_MF8_M1, VSUXSEG2EI8_V, 0x0, 0x0 }, // 9631 + { PseudoVSUXSEG2EI8_V_MF8_M1_MASK, VSUXSEG2EI8_V, 0x0, 0x0 }, // 9632 + { PseudoVSUXSEG2EI8_V_M1_M2, VSUXSEG2EI8_V, 0x1, 0x0 }, // 9633 + { PseudoVSUXSEG2EI8_V_M1_M2_MASK, VSUXSEG2EI8_V, 0x1, 0x0 }, // 9634 + { PseudoVSUXSEG2EI8_V_M2_M2, VSUXSEG2EI8_V, 0x1, 0x0 }, // 9635 + { PseudoVSUXSEG2EI8_V_M2_M2_MASK, VSUXSEG2EI8_V, 0x1, 0x0 }, // 9636 + { PseudoVSUXSEG2EI8_V_MF2_M2, VSUXSEG2EI8_V, 0x1, 0x0 }, // 9637 + { PseudoVSUXSEG2EI8_V_MF2_M2_MASK, VSUXSEG2EI8_V, 0x1, 0x0 }, // 9638 + { PseudoVSUXSEG2EI8_V_MF4_M2, VSUXSEG2EI8_V, 0x1, 0x0 }, // 9639 + { PseudoVSUXSEG2EI8_V_MF4_M2_MASK, VSUXSEG2EI8_V, 0x1, 0x0 }, // 9640 + { PseudoVSUXSEG2EI8_V_M1_M4, VSUXSEG2EI8_V, 0x2, 0x0 }, // 9641 + { PseudoVSUXSEG2EI8_V_M1_M4_MASK, VSUXSEG2EI8_V, 0x2, 0x0 }, // 9642 + { PseudoVSUXSEG2EI8_V_M2_M4, VSUXSEG2EI8_V, 0x2, 0x0 }, // 9643 + { PseudoVSUXSEG2EI8_V_M2_M4_MASK, VSUXSEG2EI8_V, 0x2, 0x0 }, // 9644 + { PseudoVSUXSEG2EI8_V_M4_M4, VSUXSEG2EI8_V, 0x2, 0x0 }, // 9645 + { PseudoVSUXSEG2EI8_V_M4_M4_MASK, VSUXSEG2EI8_V, 0x2, 0x0 }, // 9646 + { PseudoVSUXSEG2EI8_V_MF2_M4, VSUXSEG2EI8_V, 0x2, 0x0 }, // 9647 + { PseudoVSUXSEG2EI8_V_MF2_M4_MASK, VSUXSEG2EI8_V, 0x2, 0x0 }, // 9648 + { PseudoVSUXSEG2EI8_V_MF8_MF8, VSUXSEG2EI8_V, 0x5, 0x0 }, // 9649 + { PseudoVSUXSEG2EI8_V_MF8_MF8_MASK, VSUXSEG2EI8_V, 0x5, 0x0 }, // 9650 + { PseudoVSUXSEG2EI8_V_MF4_MF4, VSUXSEG2EI8_V, 0x6, 0x0 }, // 9651 + { PseudoVSUXSEG2EI8_V_MF4_MF4_MASK, VSUXSEG2EI8_V, 0x6, 0x0 }, // 9652 + { PseudoVSUXSEG2EI8_V_MF8_MF4, VSUXSEG2EI8_V, 0x6, 0x0 }, // 9653 + { PseudoVSUXSEG2EI8_V_MF8_MF4_MASK, VSUXSEG2EI8_V, 0x6, 0x0 }, // 9654 + { PseudoVSUXSEG2EI8_V_MF2_MF2, VSUXSEG2EI8_V, 0x7, 0x0 }, // 9655 + { PseudoVSUXSEG2EI8_V_MF2_MF2_MASK, VSUXSEG2EI8_V, 0x7, 0x0 }, // 9656 + { PseudoVSUXSEG2EI8_V_MF4_MF2, VSUXSEG2EI8_V, 0x7, 0x0 }, // 9657 + { PseudoVSUXSEG2EI8_V_MF4_MF2_MASK, VSUXSEG2EI8_V, 0x7, 0x0 }, // 9658 + { PseudoVSUXSEG2EI8_V_MF8_MF2, VSUXSEG2EI8_V, 0x7, 0x0 }, // 9659 + { PseudoVSUXSEG2EI8_V_MF8_MF2_MASK, VSUXSEG2EI8_V, 0x7, 0x0 }, // 9660 + { PseudoVSUXSEG3EI16_V_M1_M1, VSUXSEG3EI16_V, 0x0, 0x0 }, // 9661 + { PseudoVSUXSEG3EI16_V_M1_M1_MASK, VSUXSEG3EI16_V, 0x0, 0x0 }, // 9662 + { PseudoVSUXSEG3EI16_V_M2_M1, VSUXSEG3EI16_V, 0x0, 0x0 }, // 9663 + { PseudoVSUXSEG3EI16_V_M2_M1_MASK, VSUXSEG3EI16_V, 0x0, 0x0 }, // 9664 + { PseudoVSUXSEG3EI16_V_MF2_M1, VSUXSEG3EI16_V, 0x0, 0x0 }, // 9665 + { PseudoVSUXSEG3EI16_V_MF2_M1_MASK, VSUXSEG3EI16_V, 0x0, 0x0 }, // 9666 + { PseudoVSUXSEG3EI16_V_MF4_M1, VSUXSEG3EI16_V, 0x0, 0x0 }, // 9667 + { PseudoVSUXSEG3EI16_V_MF4_M1_MASK, VSUXSEG3EI16_V, 0x0, 0x0 }, // 9668 + { PseudoVSUXSEG3EI16_V_M1_M2, VSUXSEG3EI16_V, 0x1, 0x0 }, // 9669 + { PseudoVSUXSEG3EI16_V_M1_M2_MASK, VSUXSEG3EI16_V, 0x1, 0x0 }, // 9670 + { PseudoVSUXSEG3EI16_V_M2_M2, VSUXSEG3EI16_V, 0x1, 0x0 }, // 9671 + { PseudoVSUXSEG3EI16_V_M2_M2_MASK, VSUXSEG3EI16_V, 0x1, 0x0 }, // 9672 + { PseudoVSUXSEG3EI16_V_M4_M2, VSUXSEG3EI16_V, 0x1, 0x0 }, // 9673 + { PseudoVSUXSEG3EI16_V_M4_M2_MASK, VSUXSEG3EI16_V, 0x1, 0x0 }, // 9674 + { PseudoVSUXSEG3EI16_V_MF2_M2, VSUXSEG3EI16_V, 0x1, 0x0 }, // 9675 + { PseudoVSUXSEG3EI16_V_MF2_M2_MASK, VSUXSEG3EI16_V, 0x1, 0x0 }, // 9676 + { PseudoVSUXSEG3EI16_V_MF4_MF8, VSUXSEG3EI16_V, 0x5, 0x0 }, // 9677 + { PseudoVSUXSEG3EI16_V_MF4_MF8_MASK, VSUXSEG3EI16_V, 0x5, 0x0 }, // 9678 + { PseudoVSUXSEG3EI16_V_MF2_MF4, VSUXSEG3EI16_V, 0x6, 0x0 }, // 9679 + { PseudoVSUXSEG3EI16_V_MF2_MF4_MASK, VSUXSEG3EI16_V, 0x6, 0x0 }, // 9680 + { PseudoVSUXSEG3EI16_V_MF4_MF4, VSUXSEG3EI16_V, 0x6, 0x0 }, // 9681 + { PseudoVSUXSEG3EI16_V_MF4_MF4_MASK, VSUXSEG3EI16_V, 0x6, 0x0 }, // 9682 + { PseudoVSUXSEG3EI16_V_M1_MF2, VSUXSEG3EI16_V, 0x7, 0x0 }, // 9683 + { PseudoVSUXSEG3EI16_V_M1_MF2_MASK, VSUXSEG3EI16_V, 0x7, 0x0 }, // 9684 + { PseudoVSUXSEG3EI16_V_MF2_MF2, VSUXSEG3EI16_V, 0x7, 0x0 }, // 9685 + { PseudoVSUXSEG3EI16_V_MF2_MF2_MASK, VSUXSEG3EI16_V, 0x7, 0x0 }, // 9686 + { PseudoVSUXSEG3EI16_V_MF4_MF2, VSUXSEG3EI16_V, 0x7, 0x0 }, // 9687 + { PseudoVSUXSEG3EI16_V_MF4_MF2_MASK, VSUXSEG3EI16_V, 0x7, 0x0 }, // 9688 + { PseudoVSUXSEG3EI32_V_M1_M1, VSUXSEG3EI32_V, 0x0, 0x0 }, // 9689 + { PseudoVSUXSEG3EI32_V_M1_M1_MASK, VSUXSEG3EI32_V, 0x0, 0x0 }, // 9690 + { PseudoVSUXSEG3EI32_V_M2_M1, VSUXSEG3EI32_V, 0x0, 0x0 }, // 9691 + { PseudoVSUXSEG3EI32_V_M2_M1_MASK, VSUXSEG3EI32_V, 0x0, 0x0 }, // 9692 + { PseudoVSUXSEG3EI32_V_M4_M1, VSUXSEG3EI32_V, 0x0, 0x0 }, // 9693 + { PseudoVSUXSEG3EI32_V_M4_M1_MASK, VSUXSEG3EI32_V, 0x0, 0x0 }, // 9694 + { PseudoVSUXSEG3EI32_V_MF2_M1, VSUXSEG3EI32_V, 0x0, 0x0 }, // 9695 + { PseudoVSUXSEG3EI32_V_MF2_M1_MASK, VSUXSEG3EI32_V, 0x0, 0x0 }, // 9696 + { PseudoVSUXSEG3EI32_V_M1_M2, VSUXSEG3EI32_V, 0x1, 0x0 }, // 9697 + { PseudoVSUXSEG3EI32_V_M1_M2_MASK, VSUXSEG3EI32_V, 0x1, 0x0 }, // 9698 + { PseudoVSUXSEG3EI32_V_M2_M2, VSUXSEG3EI32_V, 0x1, 0x0 }, // 9699 + { PseudoVSUXSEG3EI32_V_M2_M2_MASK, VSUXSEG3EI32_V, 0x1, 0x0 }, // 9700 + { PseudoVSUXSEG3EI32_V_M4_M2, VSUXSEG3EI32_V, 0x1, 0x0 }, // 9701 + { PseudoVSUXSEG3EI32_V_M4_M2_MASK, VSUXSEG3EI32_V, 0x1, 0x0 }, // 9702 + { PseudoVSUXSEG3EI32_V_M8_M2, VSUXSEG3EI32_V, 0x1, 0x0 }, // 9703 + { PseudoVSUXSEG3EI32_V_M8_M2_MASK, VSUXSEG3EI32_V, 0x1, 0x0 }, // 9704 + { PseudoVSUXSEG3EI32_V_MF2_MF8, VSUXSEG3EI32_V, 0x5, 0x0 }, // 9705 + { PseudoVSUXSEG3EI32_V_MF2_MF8_MASK, VSUXSEG3EI32_V, 0x5, 0x0 }, // 9706 + { PseudoVSUXSEG3EI32_V_M1_MF4, VSUXSEG3EI32_V, 0x6, 0x0 }, // 9707 + { PseudoVSUXSEG3EI32_V_M1_MF4_MASK, VSUXSEG3EI32_V, 0x6, 0x0 }, // 9708 + { PseudoVSUXSEG3EI32_V_MF2_MF4, VSUXSEG3EI32_V, 0x6, 0x0 }, // 9709 + { PseudoVSUXSEG3EI32_V_MF2_MF4_MASK, VSUXSEG3EI32_V, 0x6, 0x0 }, // 9710 + { PseudoVSUXSEG3EI32_V_M1_MF2, VSUXSEG3EI32_V, 0x7, 0x0 }, // 9711 + { PseudoVSUXSEG3EI32_V_M1_MF2_MASK, VSUXSEG3EI32_V, 0x7, 0x0 }, // 9712 + { PseudoVSUXSEG3EI32_V_M2_MF2, VSUXSEG3EI32_V, 0x7, 0x0 }, // 9713 + { PseudoVSUXSEG3EI32_V_M2_MF2_MASK, VSUXSEG3EI32_V, 0x7, 0x0 }, // 9714 + { PseudoVSUXSEG3EI32_V_MF2_MF2, VSUXSEG3EI32_V, 0x7, 0x0 }, // 9715 + { PseudoVSUXSEG3EI32_V_MF2_MF2_MASK, VSUXSEG3EI32_V, 0x7, 0x0 }, // 9716 + { PseudoVSUXSEG3EI64_V_M1_M1, VSUXSEG3EI64_V, 0x0, 0x0 }, // 9717 + { PseudoVSUXSEG3EI64_V_M1_M1_MASK, VSUXSEG3EI64_V, 0x0, 0x0 }, // 9718 + { PseudoVSUXSEG3EI64_V_M2_M1, VSUXSEG3EI64_V, 0x0, 0x0 }, // 9719 + { PseudoVSUXSEG3EI64_V_M2_M1_MASK, VSUXSEG3EI64_V, 0x0, 0x0 }, // 9720 + { PseudoVSUXSEG3EI64_V_M4_M1, VSUXSEG3EI64_V, 0x0, 0x0 }, // 9721 + { PseudoVSUXSEG3EI64_V_M4_M1_MASK, VSUXSEG3EI64_V, 0x0, 0x0 }, // 9722 + { PseudoVSUXSEG3EI64_V_M8_M1, VSUXSEG3EI64_V, 0x0, 0x0 }, // 9723 + { PseudoVSUXSEG3EI64_V_M8_M1_MASK, VSUXSEG3EI64_V, 0x0, 0x0 }, // 9724 + { PseudoVSUXSEG3EI64_V_M2_M2, VSUXSEG3EI64_V, 0x1, 0x0 }, // 9725 + { PseudoVSUXSEG3EI64_V_M2_M2_MASK, VSUXSEG3EI64_V, 0x1, 0x0 }, // 9726 + { PseudoVSUXSEG3EI64_V_M4_M2, VSUXSEG3EI64_V, 0x1, 0x0 }, // 9727 + { PseudoVSUXSEG3EI64_V_M4_M2_MASK, VSUXSEG3EI64_V, 0x1, 0x0 }, // 9728 + { PseudoVSUXSEG3EI64_V_M8_M2, VSUXSEG3EI64_V, 0x1, 0x0 }, // 9729 + { PseudoVSUXSEG3EI64_V_M8_M2_MASK, VSUXSEG3EI64_V, 0x1, 0x0 }, // 9730 + { PseudoVSUXSEG3EI64_V_M1_MF8, VSUXSEG3EI64_V, 0x5, 0x0 }, // 9731 + { PseudoVSUXSEG3EI64_V_M1_MF8_MASK, VSUXSEG3EI64_V, 0x5, 0x0 }, // 9732 + { PseudoVSUXSEG3EI64_V_M1_MF4, VSUXSEG3EI64_V, 0x6, 0x0 }, // 9733 + { PseudoVSUXSEG3EI64_V_M1_MF4_MASK, VSUXSEG3EI64_V, 0x6, 0x0 }, // 9734 + { PseudoVSUXSEG3EI64_V_M2_MF4, VSUXSEG3EI64_V, 0x6, 0x0 }, // 9735 + { PseudoVSUXSEG3EI64_V_M2_MF4_MASK, VSUXSEG3EI64_V, 0x6, 0x0 }, // 9736 + { PseudoVSUXSEG3EI64_V_M1_MF2, VSUXSEG3EI64_V, 0x7, 0x0 }, // 9737 + { PseudoVSUXSEG3EI64_V_M1_MF2_MASK, VSUXSEG3EI64_V, 0x7, 0x0 }, // 9738 + { PseudoVSUXSEG3EI64_V_M2_MF2, VSUXSEG3EI64_V, 0x7, 0x0 }, // 9739 + { PseudoVSUXSEG3EI64_V_M2_MF2_MASK, VSUXSEG3EI64_V, 0x7, 0x0 }, // 9740 + { PseudoVSUXSEG3EI64_V_M4_MF2, VSUXSEG3EI64_V, 0x7, 0x0 }, // 9741 + { PseudoVSUXSEG3EI64_V_M4_MF2_MASK, VSUXSEG3EI64_V, 0x7, 0x0 }, // 9742 + { PseudoVSUXSEG3EI8_V_M1_M1, VSUXSEG3EI8_V, 0x0, 0x0 }, // 9743 + { PseudoVSUXSEG3EI8_V_M1_M1_MASK, VSUXSEG3EI8_V, 0x0, 0x0 }, // 9744 + { PseudoVSUXSEG3EI8_V_MF2_M1, VSUXSEG3EI8_V, 0x0, 0x0 }, // 9745 + { PseudoVSUXSEG3EI8_V_MF2_M1_MASK, VSUXSEG3EI8_V, 0x0, 0x0 }, // 9746 + { PseudoVSUXSEG3EI8_V_MF4_M1, VSUXSEG3EI8_V, 0x0, 0x0 }, // 9747 + { PseudoVSUXSEG3EI8_V_MF4_M1_MASK, VSUXSEG3EI8_V, 0x0, 0x0 }, // 9748 + { PseudoVSUXSEG3EI8_V_MF8_M1, VSUXSEG3EI8_V, 0x0, 0x0 }, // 9749 + { PseudoVSUXSEG3EI8_V_MF8_M1_MASK, VSUXSEG3EI8_V, 0x0, 0x0 }, // 9750 + { PseudoVSUXSEG3EI8_V_M1_M2, VSUXSEG3EI8_V, 0x1, 0x0 }, // 9751 + { PseudoVSUXSEG3EI8_V_M1_M2_MASK, VSUXSEG3EI8_V, 0x1, 0x0 }, // 9752 + { PseudoVSUXSEG3EI8_V_M2_M2, VSUXSEG3EI8_V, 0x1, 0x0 }, // 9753 + { PseudoVSUXSEG3EI8_V_M2_M2_MASK, VSUXSEG3EI8_V, 0x1, 0x0 }, // 9754 + { PseudoVSUXSEG3EI8_V_MF2_M2, VSUXSEG3EI8_V, 0x1, 0x0 }, // 9755 + { PseudoVSUXSEG3EI8_V_MF2_M2_MASK, VSUXSEG3EI8_V, 0x1, 0x0 }, // 9756 + { PseudoVSUXSEG3EI8_V_MF4_M2, VSUXSEG3EI8_V, 0x1, 0x0 }, // 9757 + { PseudoVSUXSEG3EI8_V_MF4_M2_MASK, VSUXSEG3EI8_V, 0x1, 0x0 }, // 9758 + { PseudoVSUXSEG3EI8_V_MF8_MF8, VSUXSEG3EI8_V, 0x5, 0x0 }, // 9759 + { PseudoVSUXSEG3EI8_V_MF8_MF8_MASK, VSUXSEG3EI8_V, 0x5, 0x0 }, // 9760 + { PseudoVSUXSEG3EI8_V_MF4_MF4, VSUXSEG3EI8_V, 0x6, 0x0 }, // 9761 + { PseudoVSUXSEG3EI8_V_MF4_MF4_MASK, VSUXSEG3EI8_V, 0x6, 0x0 }, // 9762 + { PseudoVSUXSEG3EI8_V_MF8_MF4, VSUXSEG3EI8_V, 0x6, 0x0 }, // 9763 + { PseudoVSUXSEG3EI8_V_MF8_MF4_MASK, VSUXSEG3EI8_V, 0x6, 0x0 }, // 9764 + { PseudoVSUXSEG3EI8_V_MF2_MF2, VSUXSEG3EI8_V, 0x7, 0x0 }, // 9765 + { PseudoVSUXSEG3EI8_V_MF2_MF2_MASK, VSUXSEG3EI8_V, 0x7, 0x0 }, // 9766 + { PseudoVSUXSEG3EI8_V_MF4_MF2, VSUXSEG3EI8_V, 0x7, 0x0 }, // 9767 + { PseudoVSUXSEG3EI8_V_MF4_MF2_MASK, VSUXSEG3EI8_V, 0x7, 0x0 }, // 9768 + { PseudoVSUXSEG3EI8_V_MF8_MF2, VSUXSEG3EI8_V, 0x7, 0x0 }, // 9769 + { PseudoVSUXSEG3EI8_V_MF8_MF2_MASK, VSUXSEG3EI8_V, 0x7, 0x0 }, // 9770 + { PseudoVSUXSEG4EI16_V_M1_M1, VSUXSEG4EI16_V, 0x0, 0x0 }, // 9771 + { PseudoVSUXSEG4EI16_V_M1_M1_MASK, VSUXSEG4EI16_V, 0x0, 0x0 }, // 9772 + { PseudoVSUXSEG4EI16_V_M2_M1, VSUXSEG4EI16_V, 0x0, 0x0 }, // 9773 + { PseudoVSUXSEG4EI16_V_M2_M1_MASK, VSUXSEG4EI16_V, 0x0, 0x0 }, // 9774 + { PseudoVSUXSEG4EI16_V_MF2_M1, VSUXSEG4EI16_V, 0x0, 0x0 }, // 9775 + { PseudoVSUXSEG4EI16_V_MF2_M1_MASK, VSUXSEG4EI16_V, 0x0, 0x0 }, // 9776 + { PseudoVSUXSEG4EI16_V_MF4_M1, VSUXSEG4EI16_V, 0x0, 0x0 }, // 9777 + { PseudoVSUXSEG4EI16_V_MF4_M1_MASK, VSUXSEG4EI16_V, 0x0, 0x0 }, // 9778 + { PseudoVSUXSEG4EI16_V_M1_M2, VSUXSEG4EI16_V, 0x1, 0x0 }, // 9779 + { PseudoVSUXSEG4EI16_V_M1_M2_MASK, VSUXSEG4EI16_V, 0x1, 0x0 }, // 9780 + { PseudoVSUXSEG4EI16_V_M2_M2, VSUXSEG4EI16_V, 0x1, 0x0 }, // 9781 + { PseudoVSUXSEG4EI16_V_M2_M2_MASK, VSUXSEG4EI16_V, 0x1, 0x0 }, // 9782 + { PseudoVSUXSEG4EI16_V_M4_M2, VSUXSEG4EI16_V, 0x1, 0x0 }, // 9783 + { PseudoVSUXSEG4EI16_V_M4_M2_MASK, VSUXSEG4EI16_V, 0x1, 0x0 }, // 9784 + { PseudoVSUXSEG4EI16_V_MF2_M2, VSUXSEG4EI16_V, 0x1, 0x0 }, // 9785 + { PseudoVSUXSEG4EI16_V_MF2_M2_MASK, VSUXSEG4EI16_V, 0x1, 0x0 }, // 9786 + { PseudoVSUXSEG4EI16_V_MF4_MF8, VSUXSEG4EI16_V, 0x5, 0x0 }, // 9787 + { PseudoVSUXSEG4EI16_V_MF4_MF8_MASK, VSUXSEG4EI16_V, 0x5, 0x0 }, // 9788 + { PseudoVSUXSEG4EI16_V_MF2_MF4, VSUXSEG4EI16_V, 0x6, 0x0 }, // 9789 + { PseudoVSUXSEG4EI16_V_MF2_MF4_MASK, VSUXSEG4EI16_V, 0x6, 0x0 }, // 9790 + { PseudoVSUXSEG4EI16_V_MF4_MF4, VSUXSEG4EI16_V, 0x6, 0x0 }, // 9791 + { PseudoVSUXSEG4EI16_V_MF4_MF4_MASK, VSUXSEG4EI16_V, 0x6, 0x0 }, // 9792 + { PseudoVSUXSEG4EI16_V_M1_MF2, VSUXSEG4EI16_V, 0x7, 0x0 }, // 9793 + { PseudoVSUXSEG4EI16_V_M1_MF2_MASK, VSUXSEG4EI16_V, 0x7, 0x0 }, // 9794 + { PseudoVSUXSEG4EI16_V_MF2_MF2, VSUXSEG4EI16_V, 0x7, 0x0 }, // 9795 + { PseudoVSUXSEG4EI16_V_MF2_MF2_MASK, VSUXSEG4EI16_V, 0x7, 0x0 }, // 9796 + { PseudoVSUXSEG4EI16_V_MF4_MF2, VSUXSEG4EI16_V, 0x7, 0x0 }, // 9797 + { PseudoVSUXSEG4EI16_V_MF4_MF2_MASK, VSUXSEG4EI16_V, 0x7, 0x0 }, // 9798 + { PseudoVSUXSEG4EI32_V_M1_M1, VSUXSEG4EI32_V, 0x0, 0x0 }, // 9799 + { PseudoVSUXSEG4EI32_V_M1_M1_MASK, VSUXSEG4EI32_V, 0x0, 0x0 }, // 9800 + { PseudoVSUXSEG4EI32_V_M2_M1, VSUXSEG4EI32_V, 0x0, 0x0 }, // 9801 + { PseudoVSUXSEG4EI32_V_M2_M1_MASK, VSUXSEG4EI32_V, 0x0, 0x0 }, // 9802 + { PseudoVSUXSEG4EI32_V_M4_M1, VSUXSEG4EI32_V, 0x0, 0x0 }, // 9803 + { PseudoVSUXSEG4EI32_V_M4_M1_MASK, VSUXSEG4EI32_V, 0x0, 0x0 }, // 9804 + { PseudoVSUXSEG4EI32_V_MF2_M1, VSUXSEG4EI32_V, 0x0, 0x0 }, // 9805 + { PseudoVSUXSEG4EI32_V_MF2_M1_MASK, VSUXSEG4EI32_V, 0x0, 0x0 }, // 9806 + { PseudoVSUXSEG4EI32_V_M1_M2, VSUXSEG4EI32_V, 0x1, 0x0 }, // 9807 + { PseudoVSUXSEG4EI32_V_M1_M2_MASK, VSUXSEG4EI32_V, 0x1, 0x0 }, // 9808 + { PseudoVSUXSEG4EI32_V_M2_M2, VSUXSEG4EI32_V, 0x1, 0x0 }, // 9809 + { PseudoVSUXSEG4EI32_V_M2_M2_MASK, VSUXSEG4EI32_V, 0x1, 0x0 }, // 9810 + { PseudoVSUXSEG4EI32_V_M4_M2, VSUXSEG4EI32_V, 0x1, 0x0 }, // 9811 + { PseudoVSUXSEG4EI32_V_M4_M2_MASK, VSUXSEG4EI32_V, 0x1, 0x0 }, // 9812 + { PseudoVSUXSEG4EI32_V_M8_M2, VSUXSEG4EI32_V, 0x1, 0x0 }, // 9813 + { PseudoVSUXSEG4EI32_V_M8_M2_MASK, VSUXSEG4EI32_V, 0x1, 0x0 }, // 9814 + { PseudoVSUXSEG4EI32_V_MF2_MF8, VSUXSEG4EI32_V, 0x5, 0x0 }, // 9815 + { PseudoVSUXSEG4EI32_V_MF2_MF8_MASK, VSUXSEG4EI32_V, 0x5, 0x0 }, // 9816 + { PseudoVSUXSEG4EI32_V_M1_MF4, VSUXSEG4EI32_V, 0x6, 0x0 }, // 9817 + { PseudoVSUXSEG4EI32_V_M1_MF4_MASK, VSUXSEG4EI32_V, 0x6, 0x0 }, // 9818 + { PseudoVSUXSEG4EI32_V_MF2_MF4, VSUXSEG4EI32_V, 0x6, 0x0 }, // 9819 + { PseudoVSUXSEG4EI32_V_MF2_MF4_MASK, VSUXSEG4EI32_V, 0x6, 0x0 }, // 9820 + { PseudoVSUXSEG4EI32_V_M1_MF2, VSUXSEG4EI32_V, 0x7, 0x0 }, // 9821 + { PseudoVSUXSEG4EI32_V_M1_MF2_MASK, VSUXSEG4EI32_V, 0x7, 0x0 }, // 9822 + { PseudoVSUXSEG4EI32_V_M2_MF2, VSUXSEG4EI32_V, 0x7, 0x0 }, // 9823 + { PseudoVSUXSEG4EI32_V_M2_MF2_MASK, VSUXSEG4EI32_V, 0x7, 0x0 }, // 9824 + { PseudoVSUXSEG4EI32_V_MF2_MF2, VSUXSEG4EI32_V, 0x7, 0x0 }, // 9825 + { PseudoVSUXSEG4EI32_V_MF2_MF2_MASK, VSUXSEG4EI32_V, 0x7, 0x0 }, // 9826 + { PseudoVSUXSEG4EI64_V_M1_M1, VSUXSEG4EI64_V, 0x0, 0x0 }, // 9827 + { PseudoVSUXSEG4EI64_V_M1_M1_MASK, VSUXSEG4EI64_V, 0x0, 0x0 }, // 9828 + { PseudoVSUXSEG4EI64_V_M2_M1, VSUXSEG4EI64_V, 0x0, 0x0 }, // 9829 + { PseudoVSUXSEG4EI64_V_M2_M1_MASK, VSUXSEG4EI64_V, 0x0, 0x0 }, // 9830 + { PseudoVSUXSEG4EI64_V_M4_M1, VSUXSEG4EI64_V, 0x0, 0x0 }, // 9831 + { PseudoVSUXSEG4EI64_V_M4_M1_MASK, VSUXSEG4EI64_V, 0x0, 0x0 }, // 9832 + { PseudoVSUXSEG4EI64_V_M8_M1, VSUXSEG4EI64_V, 0x0, 0x0 }, // 9833 + { PseudoVSUXSEG4EI64_V_M8_M1_MASK, VSUXSEG4EI64_V, 0x0, 0x0 }, // 9834 + { PseudoVSUXSEG4EI64_V_M2_M2, VSUXSEG4EI64_V, 0x1, 0x0 }, // 9835 + { PseudoVSUXSEG4EI64_V_M2_M2_MASK, VSUXSEG4EI64_V, 0x1, 0x0 }, // 9836 + { PseudoVSUXSEG4EI64_V_M4_M2, VSUXSEG4EI64_V, 0x1, 0x0 }, // 9837 + { PseudoVSUXSEG4EI64_V_M4_M2_MASK, VSUXSEG4EI64_V, 0x1, 0x0 }, // 9838 + { PseudoVSUXSEG4EI64_V_M8_M2, VSUXSEG4EI64_V, 0x1, 0x0 }, // 9839 + { PseudoVSUXSEG4EI64_V_M8_M2_MASK, VSUXSEG4EI64_V, 0x1, 0x0 }, // 9840 + { PseudoVSUXSEG4EI64_V_M1_MF8, VSUXSEG4EI64_V, 0x5, 0x0 }, // 9841 + { PseudoVSUXSEG4EI64_V_M1_MF8_MASK, VSUXSEG4EI64_V, 0x5, 0x0 }, // 9842 + { PseudoVSUXSEG4EI64_V_M1_MF4, VSUXSEG4EI64_V, 0x6, 0x0 }, // 9843 + { PseudoVSUXSEG4EI64_V_M1_MF4_MASK, VSUXSEG4EI64_V, 0x6, 0x0 }, // 9844 + { PseudoVSUXSEG4EI64_V_M2_MF4, VSUXSEG4EI64_V, 0x6, 0x0 }, // 9845 + { PseudoVSUXSEG4EI64_V_M2_MF4_MASK, VSUXSEG4EI64_V, 0x6, 0x0 }, // 9846 + { PseudoVSUXSEG4EI64_V_M1_MF2, VSUXSEG4EI64_V, 0x7, 0x0 }, // 9847 + { PseudoVSUXSEG4EI64_V_M1_MF2_MASK, VSUXSEG4EI64_V, 0x7, 0x0 }, // 9848 + { PseudoVSUXSEG4EI64_V_M2_MF2, VSUXSEG4EI64_V, 0x7, 0x0 }, // 9849 + { PseudoVSUXSEG4EI64_V_M2_MF2_MASK, VSUXSEG4EI64_V, 0x7, 0x0 }, // 9850 + { PseudoVSUXSEG4EI64_V_M4_MF2, VSUXSEG4EI64_V, 0x7, 0x0 }, // 9851 + { PseudoVSUXSEG4EI64_V_M4_MF2_MASK, VSUXSEG4EI64_V, 0x7, 0x0 }, // 9852 + { PseudoVSUXSEG4EI8_V_M1_M1, VSUXSEG4EI8_V, 0x0, 0x0 }, // 9853 + { PseudoVSUXSEG4EI8_V_M1_M1_MASK, VSUXSEG4EI8_V, 0x0, 0x0 }, // 9854 + { PseudoVSUXSEG4EI8_V_MF2_M1, VSUXSEG4EI8_V, 0x0, 0x0 }, // 9855 + { PseudoVSUXSEG4EI8_V_MF2_M1_MASK, VSUXSEG4EI8_V, 0x0, 0x0 }, // 9856 + { PseudoVSUXSEG4EI8_V_MF4_M1, VSUXSEG4EI8_V, 0x0, 0x0 }, // 9857 + { PseudoVSUXSEG4EI8_V_MF4_M1_MASK, VSUXSEG4EI8_V, 0x0, 0x0 }, // 9858 + { PseudoVSUXSEG4EI8_V_MF8_M1, VSUXSEG4EI8_V, 0x0, 0x0 }, // 9859 + { PseudoVSUXSEG4EI8_V_MF8_M1_MASK, VSUXSEG4EI8_V, 0x0, 0x0 }, // 9860 + { PseudoVSUXSEG4EI8_V_M1_M2, VSUXSEG4EI8_V, 0x1, 0x0 }, // 9861 + { PseudoVSUXSEG4EI8_V_M1_M2_MASK, VSUXSEG4EI8_V, 0x1, 0x0 }, // 9862 + { PseudoVSUXSEG4EI8_V_M2_M2, VSUXSEG4EI8_V, 0x1, 0x0 }, // 9863 + { PseudoVSUXSEG4EI8_V_M2_M2_MASK, VSUXSEG4EI8_V, 0x1, 0x0 }, // 9864 + { PseudoVSUXSEG4EI8_V_MF2_M2, VSUXSEG4EI8_V, 0x1, 0x0 }, // 9865 + { PseudoVSUXSEG4EI8_V_MF2_M2_MASK, VSUXSEG4EI8_V, 0x1, 0x0 }, // 9866 + { PseudoVSUXSEG4EI8_V_MF4_M2, VSUXSEG4EI8_V, 0x1, 0x0 }, // 9867 + { PseudoVSUXSEG4EI8_V_MF4_M2_MASK, VSUXSEG4EI8_V, 0x1, 0x0 }, // 9868 + { PseudoVSUXSEG4EI8_V_MF8_MF8, VSUXSEG4EI8_V, 0x5, 0x0 }, // 9869 + { PseudoVSUXSEG4EI8_V_MF8_MF8_MASK, VSUXSEG4EI8_V, 0x5, 0x0 }, // 9870 + { PseudoVSUXSEG4EI8_V_MF4_MF4, VSUXSEG4EI8_V, 0x6, 0x0 }, // 9871 + { PseudoVSUXSEG4EI8_V_MF4_MF4_MASK, VSUXSEG4EI8_V, 0x6, 0x0 }, // 9872 + { PseudoVSUXSEG4EI8_V_MF8_MF4, VSUXSEG4EI8_V, 0x6, 0x0 }, // 9873 + { PseudoVSUXSEG4EI8_V_MF8_MF4_MASK, VSUXSEG4EI8_V, 0x6, 0x0 }, // 9874 + { PseudoVSUXSEG4EI8_V_MF2_MF2, VSUXSEG4EI8_V, 0x7, 0x0 }, // 9875 + { PseudoVSUXSEG4EI8_V_MF2_MF2_MASK, VSUXSEG4EI8_V, 0x7, 0x0 }, // 9876 + { PseudoVSUXSEG4EI8_V_MF4_MF2, VSUXSEG4EI8_V, 0x7, 0x0 }, // 9877 + { PseudoVSUXSEG4EI8_V_MF4_MF2_MASK, VSUXSEG4EI8_V, 0x7, 0x0 }, // 9878 + { PseudoVSUXSEG4EI8_V_MF8_MF2, VSUXSEG4EI8_V, 0x7, 0x0 }, // 9879 + { PseudoVSUXSEG4EI8_V_MF8_MF2_MASK, VSUXSEG4EI8_V, 0x7, 0x0 }, // 9880 + { PseudoVSUXSEG5EI16_V_M1_M1, VSUXSEG5EI16_V, 0x0, 0x0 }, // 9881 + { PseudoVSUXSEG5EI16_V_M1_M1_MASK, VSUXSEG5EI16_V, 0x0, 0x0 }, // 9882 + { PseudoVSUXSEG5EI16_V_M2_M1, VSUXSEG5EI16_V, 0x0, 0x0 }, // 9883 + { PseudoVSUXSEG5EI16_V_M2_M1_MASK, VSUXSEG5EI16_V, 0x0, 0x0 }, // 9884 + { PseudoVSUXSEG5EI16_V_MF2_M1, VSUXSEG5EI16_V, 0x0, 0x0 }, // 9885 + { PseudoVSUXSEG5EI16_V_MF2_M1_MASK, VSUXSEG5EI16_V, 0x0, 0x0 }, // 9886 + { PseudoVSUXSEG5EI16_V_MF4_M1, VSUXSEG5EI16_V, 0x0, 0x0 }, // 9887 + { PseudoVSUXSEG5EI16_V_MF4_M1_MASK, VSUXSEG5EI16_V, 0x0, 0x0 }, // 9888 + { PseudoVSUXSEG5EI16_V_MF4_MF8, VSUXSEG5EI16_V, 0x5, 0x0 }, // 9889 + { PseudoVSUXSEG5EI16_V_MF4_MF8_MASK, VSUXSEG5EI16_V, 0x5, 0x0 }, // 9890 + { PseudoVSUXSEG5EI16_V_MF2_MF4, VSUXSEG5EI16_V, 0x6, 0x0 }, // 9891 + { PseudoVSUXSEG5EI16_V_MF2_MF4_MASK, VSUXSEG5EI16_V, 0x6, 0x0 }, // 9892 + { PseudoVSUXSEG5EI16_V_MF4_MF4, VSUXSEG5EI16_V, 0x6, 0x0 }, // 9893 + { PseudoVSUXSEG5EI16_V_MF4_MF4_MASK, VSUXSEG5EI16_V, 0x6, 0x0 }, // 9894 + { PseudoVSUXSEG5EI16_V_M1_MF2, VSUXSEG5EI16_V, 0x7, 0x0 }, // 9895 + { PseudoVSUXSEG5EI16_V_M1_MF2_MASK, VSUXSEG5EI16_V, 0x7, 0x0 }, // 9896 + { PseudoVSUXSEG5EI16_V_MF2_MF2, VSUXSEG5EI16_V, 0x7, 0x0 }, // 9897 + { PseudoVSUXSEG5EI16_V_MF2_MF2_MASK, VSUXSEG5EI16_V, 0x7, 0x0 }, // 9898 + { PseudoVSUXSEG5EI16_V_MF4_MF2, VSUXSEG5EI16_V, 0x7, 0x0 }, // 9899 + { PseudoVSUXSEG5EI16_V_MF4_MF2_MASK, VSUXSEG5EI16_V, 0x7, 0x0 }, // 9900 + { PseudoVSUXSEG5EI32_V_M1_M1, VSUXSEG5EI32_V, 0x0, 0x0 }, // 9901 + { PseudoVSUXSEG5EI32_V_M1_M1_MASK, VSUXSEG5EI32_V, 0x0, 0x0 }, // 9902 + { PseudoVSUXSEG5EI32_V_M2_M1, VSUXSEG5EI32_V, 0x0, 0x0 }, // 9903 + { PseudoVSUXSEG5EI32_V_M2_M1_MASK, VSUXSEG5EI32_V, 0x0, 0x0 }, // 9904 + { PseudoVSUXSEG5EI32_V_M4_M1, VSUXSEG5EI32_V, 0x0, 0x0 }, // 9905 + { PseudoVSUXSEG5EI32_V_M4_M1_MASK, VSUXSEG5EI32_V, 0x0, 0x0 }, // 9906 + { PseudoVSUXSEG5EI32_V_MF2_M1, VSUXSEG5EI32_V, 0x0, 0x0 }, // 9907 + { PseudoVSUXSEG5EI32_V_MF2_M1_MASK, VSUXSEG5EI32_V, 0x0, 0x0 }, // 9908 + { PseudoVSUXSEG5EI32_V_MF2_MF8, VSUXSEG5EI32_V, 0x5, 0x0 }, // 9909 + { PseudoVSUXSEG5EI32_V_MF2_MF8_MASK, VSUXSEG5EI32_V, 0x5, 0x0 }, // 9910 + { PseudoVSUXSEG5EI32_V_M1_MF4, VSUXSEG5EI32_V, 0x6, 0x0 }, // 9911 + { PseudoVSUXSEG5EI32_V_M1_MF4_MASK, VSUXSEG5EI32_V, 0x6, 0x0 }, // 9912 + { PseudoVSUXSEG5EI32_V_MF2_MF4, VSUXSEG5EI32_V, 0x6, 0x0 }, // 9913 + { PseudoVSUXSEG5EI32_V_MF2_MF4_MASK, VSUXSEG5EI32_V, 0x6, 0x0 }, // 9914 + { PseudoVSUXSEG5EI32_V_M1_MF2, VSUXSEG5EI32_V, 0x7, 0x0 }, // 9915 + { PseudoVSUXSEG5EI32_V_M1_MF2_MASK, VSUXSEG5EI32_V, 0x7, 0x0 }, // 9916 + { PseudoVSUXSEG5EI32_V_M2_MF2, VSUXSEG5EI32_V, 0x7, 0x0 }, // 9917 + { PseudoVSUXSEG5EI32_V_M2_MF2_MASK, VSUXSEG5EI32_V, 0x7, 0x0 }, // 9918 + { PseudoVSUXSEG5EI32_V_MF2_MF2, VSUXSEG5EI32_V, 0x7, 0x0 }, // 9919 + { PseudoVSUXSEG5EI32_V_MF2_MF2_MASK, VSUXSEG5EI32_V, 0x7, 0x0 }, // 9920 + { PseudoVSUXSEG5EI64_V_M1_M1, VSUXSEG5EI64_V, 0x0, 0x0 }, // 9921 + { PseudoVSUXSEG5EI64_V_M1_M1_MASK, VSUXSEG5EI64_V, 0x0, 0x0 }, // 9922 + { PseudoVSUXSEG5EI64_V_M2_M1, VSUXSEG5EI64_V, 0x0, 0x0 }, // 9923 + { PseudoVSUXSEG5EI64_V_M2_M1_MASK, VSUXSEG5EI64_V, 0x0, 0x0 }, // 9924 + { PseudoVSUXSEG5EI64_V_M4_M1, VSUXSEG5EI64_V, 0x0, 0x0 }, // 9925 + { PseudoVSUXSEG5EI64_V_M4_M1_MASK, VSUXSEG5EI64_V, 0x0, 0x0 }, // 9926 + { PseudoVSUXSEG5EI64_V_M8_M1, VSUXSEG5EI64_V, 0x0, 0x0 }, // 9927 + { PseudoVSUXSEG5EI64_V_M8_M1_MASK, VSUXSEG5EI64_V, 0x0, 0x0 }, // 9928 + { PseudoVSUXSEG5EI64_V_M1_MF8, VSUXSEG5EI64_V, 0x5, 0x0 }, // 9929 + { PseudoVSUXSEG5EI64_V_M1_MF8_MASK, VSUXSEG5EI64_V, 0x5, 0x0 }, // 9930 + { PseudoVSUXSEG5EI64_V_M1_MF4, VSUXSEG5EI64_V, 0x6, 0x0 }, // 9931 + { PseudoVSUXSEG5EI64_V_M1_MF4_MASK, VSUXSEG5EI64_V, 0x6, 0x0 }, // 9932 + { PseudoVSUXSEG5EI64_V_M2_MF4, VSUXSEG5EI64_V, 0x6, 0x0 }, // 9933 + { PseudoVSUXSEG5EI64_V_M2_MF4_MASK, VSUXSEG5EI64_V, 0x6, 0x0 }, // 9934 + { PseudoVSUXSEG5EI64_V_M1_MF2, VSUXSEG5EI64_V, 0x7, 0x0 }, // 9935 + { PseudoVSUXSEG5EI64_V_M1_MF2_MASK, VSUXSEG5EI64_V, 0x7, 0x0 }, // 9936 + { PseudoVSUXSEG5EI64_V_M2_MF2, VSUXSEG5EI64_V, 0x7, 0x0 }, // 9937 + { PseudoVSUXSEG5EI64_V_M2_MF2_MASK, VSUXSEG5EI64_V, 0x7, 0x0 }, // 9938 + { PseudoVSUXSEG5EI64_V_M4_MF2, VSUXSEG5EI64_V, 0x7, 0x0 }, // 9939 + { PseudoVSUXSEG5EI64_V_M4_MF2_MASK, VSUXSEG5EI64_V, 0x7, 0x0 }, // 9940 + { PseudoVSUXSEG5EI8_V_M1_M1, VSUXSEG5EI8_V, 0x0, 0x0 }, // 9941 + { PseudoVSUXSEG5EI8_V_M1_M1_MASK, VSUXSEG5EI8_V, 0x0, 0x0 }, // 9942 + { PseudoVSUXSEG5EI8_V_MF2_M1, VSUXSEG5EI8_V, 0x0, 0x0 }, // 9943 + { PseudoVSUXSEG5EI8_V_MF2_M1_MASK, VSUXSEG5EI8_V, 0x0, 0x0 }, // 9944 + { PseudoVSUXSEG5EI8_V_MF4_M1, VSUXSEG5EI8_V, 0x0, 0x0 }, // 9945 + { PseudoVSUXSEG5EI8_V_MF4_M1_MASK, VSUXSEG5EI8_V, 0x0, 0x0 }, // 9946 + { PseudoVSUXSEG5EI8_V_MF8_M1, VSUXSEG5EI8_V, 0x0, 0x0 }, // 9947 + { PseudoVSUXSEG5EI8_V_MF8_M1_MASK, VSUXSEG5EI8_V, 0x0, 0x0 }, // 9948 + { PseudoVSUXSEG5EI8_V_MF8_MF8, VSUXSEG5EI8_V, 0x5, 0x0 }, // 9949 + { PseudoVSUXSEG5EI8_V_MF8_MF8_MASK, VSUXSEG5EI8_V, 0x5, 0x0 }, // 9950 + { PseudoVSUXSEG5EI8_V_MF4_MF4, VSUXSEG5EI8_V, 0x6, 0x0 }, // 9951 + { PseudoVSUXSEG5EI8_V_MF4_MF4_MASK, VSUXSEG5EI8_V, 0x6, 0x0 }, // 9952 + { PseudoVSUXSEG5EI8_V_MF8_MF4, VSUXSEG5EI8_V, 0x6, 0x0 }, // 9953 + { PseudoVSUXSEG5EI8_V_MF8_MF4_MASK, VSUXSEG5EI8_V, 0x6, 0x0 }, // 9954 + { PseudoVSUXSEG5EI8_V_MF2_MF2, VSUXSEG5EI8_V, 0x7, 0x0 }, // 9955 + { PseudoVSUXSEG5EI8_V_MF2_MF2_MASK, VSUXSEG5EI8_V, 0x7, 0x0 }, // 9956 + { PseudoVSUXSEG5EI8_V_MF4_MF2, VSUXSEG5EI8_V, 0x7, 0x0 }, // 9957 + { PseudoVSUXSEG5EI8_V_MF4_MF2_MASK, VSUXSEG5EI8_V, 0x7, 0x0 }, // 9958 + { PseudoVSUXSEG5EI8_V_MF8_MF2, VSUXSEG5EI8_V, 0x7, 0x0 }, // 9959 + { PseudoVSUXSEG5EI8_V_MF8_MF2_MASK, VSUXSEG5EI8_V, 0x7, 0x0 }, // 9960 + { PseudoVSUXSEG6EI16_V_M1_M1, VSUXSEG6EI16_V, 0x0, 0x0 }, // 9961 + { PseudoVSUXSEG6EI16_V_M1_M1_MASK, VSUXSEG6EI16_V, 0x0, 0x0 }, // 9962 + { PseudoVSUXSEG6EI16_V_M2_M1, VSUXSEG6EI16_V, 0x0, 0x0 }, // 9963 + { PseudoVSUXSEG6EI16_V_M2_M1_MASK, VSUXSEG6EI16_V, 0x0, 0x0 }, // 9964 + { PseudoVSUXSEG6EI16_V_MF2_M1, VSUXSEG6EI16_V, 0x0, 0x0 }, // 9965 + { PseudoVSUXSEG6EI16_V_MF2_M1_MASK, VSUXSEG6EI16_V, 0x0, 0x0 }, // 9966 + { PseudoVSUXSEG6EI16_V_MF4_M1, VSUXSEG6EI16_V, 0x0, 0x0 }, // 9967 + { PseudoVSUXSEG6EI16_V_MF4_M1_MASK, VSUXSEG6EI16_V, 0x0, 0x0 }, // 9968 + { PseudoVSUXSEG6EI16_V_MF4_MF8, VSUXSEG6EI16_V, 0x5, 0x0 }, // 9969 + { PseudoVSUXSEG6EI16_V_MF4_MF8_MASK, VSUXSEG6EI16_V, 0x5, 0x0 }, // 9970 + { PseudoVSUXSEG6EI16_V_MF2_MF4, VSUXSEG6EI16_V, 0x6, 0x0 }, // 9971 + { PseudoVSUXSEG6EI16_V_MF2_MF4_MASK, VSUXSEG6EI16_V, 0x6, 0x0 }, // 9972 + { PseudoVSUXSEG6EI16_V_MF4_MF4, VSUXSEG6EI16_V, 0x6, 0x0 }, // 9973 + { PseudoVSUXSEG6EI16_V_MF4_MF4_MASK, VSUXSEG6EI16_V, 0x6, 0x0 }, // 9974 + { PseudoVSUXSEG6EI16_V_M1_MF2, VSUXSEG6EI16_V, 0x7, 0x0 }, // 9975 + { PseudoVSUXSEG6EI16_V_M1_MF2_MASK, VSUXSEG6EI16_V, 0x7, 0x0 }, // 9976 + { PseudoVSUXSEG6EI16_V_MF2_MF2, VSUXSEG6EI16_V, 0x7, 0x0 }, // 9977 + { PseudoVSUXSEG6EI16_V_MF2_MF2_MASK, VSUXSEG6EI16_V, 0x7, 0x0 }, // 9978 + { PseudoVSUXSEG6EI16_V_MF4_MF2, VSUXSEG6EI16_V, 0x7, 0x0 }, // 9979 + { PseudoVSUXSEG6EI16_V_MF4_MF2_MASK, VSUXSEG6EI16_V, 0x7, 0x0 }, // 9980 + { PseudoVSUXSEG6EI32_V_M1_M1, VSUXSEG6EI32_V, 0x0, 0x0 }, // 9981 + { PseudoVSUXSEG6EI32_V_M1_M1_MASK, VSUXSEG6EI32_V, 0x0, 0x0 }, // 9982 + { PseudoVSUXSEG6EI32_V_M2_M1, VSUXSEG6EI32_V, 0x0, 0x0 }, // 9983 + { PseudoVSUXSEG6EI32_V_M2_M1_MASK, VSUXSEG6EI32_V, 0x0, 0x0 }, // 9984 + { PseudoVSUXSEG6EI32_V_M4_M1, VSUXSEG6EI32_V, 0x0, 0x0 }, // 9985 + { PseudoVSUXSEG6EI32_V_M4_M1_MASK, VSUXSEG6EI32_V, 0x0, 0x0 }, // 9986 + { PseudoVSUXSEG6EI32_V_MF2_M1, VSUXSEG6EI32_V, 0x0, 0x0 }, // 9987 + { PseudoVSUXSEG6EI32_V_MF2_M1_MASK, VSUXSEG6EI32_V, 0x0, 0x0 }, // 9988 + { PseudoVSUXSEG6EI32_V_MF2_MF8, VSUXSEG6EI32_V, 0x5, 0x0 }, // 9989 + { PseudoVSUXSEG6EI32_V_MF2_MF8_MASK, VSUXSEG6EI32_V, 0x5, 0x0 }, // 9990 + { PseudoVSUXSEG6EI32_V_M1_MF4, VSUXSEG6EI32_V, 0x6, 0x0 }, // 9991 + { PseudoVSUXSEG6EI32_V_M1_MF4_MASK, VSUXSEG6EI32_V, 0x6, 0x0 }, // 9992 + { PseudoVSUXSEG6EI32_V_MF2_MF4, VSUXSEG6EI32_V, 0x6, 0x0 }, // 9993 + { PseudoVSUXSEG6EI32_V_MF2_MF4_MASK, VSUXSEG6EI32_V, 0x6, 0x0 }, // 9994 + { PseudoVSUXSEG6EI32_V_M1_MF2, VSUXSEG6EI32_V, 0x7, 0x0 }, // 9995 + { PseudoVSUXSEG6EI32_V_M1_MF2_MASK, VSUXSEG6EI32_V, 0x7, 0x0 }, // 9996 + { PseudoVSUXSEG6EI32_V_M2_MF2, VSUXSEG6EI32_V, 0x7, 0x0 }, // 9997 + { PseudoVSUXSEG6EI32_V_M2_MF2_MASK, VSUXSEG6EI32_V, 0x7, 0x0 }, // 9998 + { PseudoVSUXSEG6EI32_V_MF2_MF2, VSUXSEG6EI32_V, 0x7, 0x0 }, // 9999 + { PseudoVSUXSEG6EI32_V_MF2_MF2_MASK, VSUXSEG6EI32_V, 0x7, 0x0 }, // 10000 + { PseudoVSUXSEG6EI64_V_M1_M1, VSUXSEG6EI64_V, 0x0, 0x0 }, // 10001 + { PseudoVSUXSEG6EI64_V_M1_M1_MASK, VSUXSEG6EI64_V, 0x0, 0x0 }, // 10002 + { PseudoVSUXSEG6EI64_V_M2_M1, VSUXSEG6EI64_V, 0x0, 0x0 }, // 10003 + { PseudoVSUXSEG6EI64_V_M2_M1_MASK, VSUXSEG6EI64_V, 0x0, 0x0 }, // 10004 + { PseudoVSUXSEG6EI64_V_M4_M1, VSUXSEG6EI64_V, 0x0, 0x0 }, // 10005 + { PseudoVSUXSEG6EI64_V_M4_M1_MASK, VSUXSEG6EI64_V, 0x0, 0x0 }, // 10006 + { PseudoVSUXSEG6EI64_V_M8_M1, VSUXSEG6EI64_V, 0x0, 0x0 }, // 10007 + { PseudoVSUXSEG6EI64_V_M8_M1_MASK, VSUXSEG6EI64_V, 0x0, 0x0 }, // 10008 + { PseudoVSUXSEG6EI64_V_M1_MF8, VSUXSEG6EI64_V, 0x5, 0x0 }, // 10009 + { PseudoVSUXSEG6EI64_V_M1_MF8_MASK, VSUXSEG6EI64_V, 0x5, 0x0 }, // 10010 + { PseudoVSUXSEG6EI64_V_M1_MF4, VSUXSEG6EI64_V, 0x6, 0x0 }, // 10011 + { PseudoVSUXSEG6EI64_V_M1_MF4_MASK, VSUXSEG6EI64_V, 0x6, 0x0 }, // 10012 + { PseudoVSUXSEG6EI64_V_M2_MF4, VSUXSEG6EI64_V, 0x6, 0x0 }, // 10013 + { PseudoVSUXSEG6EI64_V_M2_MF4_MASK, VSUXSEG6EI64_V, 0x6, 0x0 }, // 10014 + { PseudoVSUXSEG6EI64_V_M1_MF2, VSUXSEG6EI64_V, 0x7, 0x0 }, // 10015 + { PseudoVSUXSEG6EI64_V_M1_MF2_MASK, VSUXSEG6EI64_V, 0x7, 0x0 }, // 10016 + { PseudoVSUXSEG6EI64_V_M2_MF2, VSUXSEG6EI64_V, 0x7, 0x0 }, // 10017 + { PseudoVSUXSEG6EI64_V_M2_MF2_MASK, VSUXSEG6EI64_V, 0x7, 0x0 }, // 10018 + { PseudoVSUXSEG6EI64_V_M4_MF2, VSUXSEG6EI64_V, 0x7, 0x0 }, // 10019 + { PseudoVSUXSEG6EI64_V_M4_MF2_MASK, VSUXSEG6EI64_V, 0x7, 0x0 }, // 10020 + { PseudoVSUXSEG6EI8_V_M1_M1, VSUXSEG6EI8_V, 0x0, 0x0 }, // 10021 + { PseudoVSUXSEG6EI8_V_M1_M1_MASK, VSUXSEG6EI8_V, 0x0, 0x0 }, // 10022 + { PseudoVSUXSEG6EI8_V_MF2_M1, VSUXSEG6EI8_V, 0x0, 0x0 }, // 10023 + { PseudoVSUXSEG6EI8_V_MF2_M1_MASK, VSUXSEG6EI8_V, 0x0, 0x0 }, // 10024 + { PseudoVSUXSEG6EI8_V_MF4_M1, VSUXSEG6EI8_V, 0x0, 0x0 }, // 10025 + { PseudoVSUXSEG6EI8_V_MF4_M1_MASK, VSUXSEG6EI8_V, 0x0, 0x0 }, // 10026 + { PseudoVSUXSEG6EI8_V_MF8_M1, VSUXSEG6EI8_V, 0x0, 0x0 }, // 10027 + { PseudoVSUXSEG6EI8_V_MF8_M1_MASK, VSUXSEG6EI8_V, 0x0, 0x0 }, // 10028 + { PseudoVSUXSEG6EI8_V_MF8_MF8, VSUXSEG6EI8_V, 0x5, 0x0 }, // 10029 + { PseudoVSUXSEG6EI8_V_MF8_MF8_MASK, VSUXSEG6EI8_V, 0x5, 0x0 }, // 10030 + { PseudoVSUXSEG6EI8_V_MF4_MF4, VSUXSEG6EI8_V, 0x6, 0x0 }, // 10031 + { PseudoVSUXSEG6EI8_V_MF4_MF4_MASK, VSUXSEG6EI8_V, 0x6, 0x0 }, // 10032 + { PseudoVSUXSEG6EI8_V_MF8_MF4, VSUXSEG6EI8_V, 0x6, 0x0 }, // 10033 + { PseudoVSUXSEG6EI8_V_MF8_MF4_MASK, VSUXSEG6EI8_V, 0x6, 0x0 }, // 10034 + { PseudoVSUXSEG6EI8_V_MF2_MF2, VSUXSEG6EI8_V, 0x7, 0x0 }, // 10035 + { PseudoVSUXSEG6EI8_V_MF2_MF2_MASK, VSUXSEG6EI8_V, 0x7, 0x0 }, // 10036 + { PseudoVSUXSEG6EI8_V_MF4_MF2, VSUXSEG6EI8_V, 0x7, 0x0 }, // 10037 + { PseudoVSUXSEG6EI8_V_MF4_MF2_MASK, VSUXSEG6EI8_V, 0x7, 0x0 }, // 10038 + { PseudoVSUXSEG6EI8_V_MF8_MF2, VSUXSEG6EI8_V, 0x7, 0x0 }, // 10039 + { PseudoVSUXSEG6EI8_V_MF8_MF2_MASK, VSUXSEG6EI8_V, 0x7, 0x0 }, // 10040 + { PseudoVSUXSEG7EI16_V_M1_M1, VSUXSEG7EI16_V, 0x0, 0x0 }, // 10041 + { PseudoVSUXSEG7EI16_V_M1_M1_MASK, VSUXSEG7EI16_V, 0x0, 0x0 }, // 10042 + { PseudoVSUXSEG7EI16_V_M2_M1, VSUXSEG7EI16_V, 0x0, 0x0 }, // 10043 + { PseudoVSUXSEG7EI16_V_M2_M1_MASK, VSUXSEG7EI16_V, 0x0, 0x0 }, // 10044 + { PseudoVSUXSEG7EI16_V_MF2_M1, VSUXSEG7EI16_V, 0x0, 0x0 }, // 10045 + { PseudoVSUXSEG7EI16_V_MF2_M1_MASK, VSUXSEG7EI16_V, 0x0, 0x0 }, // 10046 + { PseudoVSUXSEG7EI16_V_MF4_M1, VSUXSEG7EI16_V, 0x0, 0x0 }, // 10047 + { PseudoVSUXSEG7EI16_V_MF4_M1_MASK, VSUXSEG7EI16_V, 0x0, 0x0 }, // 10048 + { PseudoVSUXSEG7EI16_V_MF4_MF8, VSUXSEG7EI16_V, 0x5, 0x0 }, // 10049 + { PseudoVSUXSEG7EI16_V_MF4_MF8_MASK, VSUXSEG7EI16_V, 0x5, 0x0 }, // 10050 + { PseudoVSUXSEG7EI16_V_MF2_MF4, VSUXSEG7EI16_V, 0x6, 0x0 }, // 10051 + { PseudoVSUXSEG7EI16_V_MF2_MF4_MASK, VSUXSEG7EI16_V, 0x6, 0x0 }, // 10052 + { PseudoVSUXSEG7EI16_V_MF4_MF4, VSUXSEG7EI16_V, 0x6, 0x0 }, // 10053 + { PseudoVSUXSEG7EI16_V_MF4_MF4_MASK, VSUXSEG7EI16_V, 0x6, 0x0 }, // 10054 + { PseudoVSUXSEG7EI16_V_M1_MF2, VSUXSEG7EI16_V, 0x7, 0x0 }, // 10055 + { PseudoVSUXSEG7EI16_V_M1_MF2_MASK, VSUXSEG7EI16_V, 0x7, 0x0 }, // 10056 + { PseudoVSUXSEG7EI16_V_MF2_MF2, VSUXSEG7EI16_V, 0x7, 0x0 }, // 10057 + { PseudoVSUXSEG7EI16_V_MF2_MF2_MASK, VSUXSEG7EI16_V, 0x7, 0x0 }, // 10058 + { PseudoVSUXSEG7EI16_V_MF4_MF2, VSUXSEG7EI16_V, 0x7, 0x0 }, // 10059 + { PseudoVSUXSEG7EI16_V_MF4_MF2_MASK, VSUXSEG7EI16_V, 0x7, 0x0 }, // 10060 + { PseudoVSUXSEG7EI32_V_M1_M1, VSUXSEG7EI32_V, 0x0, 0x0 }, // 10061 + { PseudoVSUXSEG7EI32_V_M1_M1_MASK, VSUXSEG7EI32_V, 0x0, 0x0 }, // 10062 + { PseudoVSUXSEG7EI32_V_M2_M1, VSUXSEG7EI32_V, 0x0, 0x0 }, // 10063 + { PseudoVSUXSEG7EI32_V_M2_M1_MASK, VSUXSEG7EI32_V, 0x0, 0x0 }, // 10064 + { PseudoVSUXSEG7EI32_V_M4_M1, VSUXSEG7EI32_V, 0x0, 0x0 }, // 10065 + { PseudoVSUXSEG7EI32_V_M4_M1_MASK, VSUXSEG7EI32_V, 0x0, 0x0 }, // 10066 + { PseudoVSUXSEG7EI32_V_MF2_M1, VSUXSEG7EI32_V, 0x0, 0x0 }, // 10067 + { PseudoVSUXSEG7EI32_V_MF2_M1_MASK, VSUXSEG7EI32_V, 0x0, 0x0 }, // 10068 + { PseudoVSUXSEG7EI32_V_MF2_MF8, VSUXSEG7EI32_V, 0x5, 0x0 }, // 10069 + { PseudoVSUXSEG7EI32_V_MF2_MF8_MASK, VSUXSEG7EI32_V, 0x5, 0x0 }, // 10070 + { PseudoVSUXSEG7EI32_V_M1_MF4, VSUXSEG7EI32_V, 0x6, 0x0 }, // 10071 + { PseudoVSUXSEG7EI32_V_M1_MF4_MASK, VSUXSEG7EI32_V, 0x6, 0x0 }, // 10072 + { PseudoVSUXSEG7EI32_V_MF2_MF4, VSUXSEG7EI32_V, 0x6, 0x0 }, // 10073 + { PseudoVSUXSEG7EI32_V_MF2_MF4_MASK, VSUXSEG7EI32_V, 0x6, 0x0 }, // 10074 + { PseudoVSUXSEG7EI32_V_M1_MF2, VSUXSEG7EI32_V, 0x7, 0x0 }, // 10075 + { PseudoVSUXSEG7EI32_V_M1_MF2_MASK, VSUXSEG7EI32_V, 0x7, 0x0 }, // 10076 + { PseudoVSUXSEG7EI32_V_M2_MF2, VSUXSEG7EI32_V, 0x7, 0x0 }, // 10077 + { PseudoVSUXSEG7EI32_V_M2_MF2_MASK, VSUXSEG7EI32_V, 0x7, 0x0 }, // 10078 + { PseudoVSUXSEG7EI32_V_MF2_MF2, VSUXSEG7EI32_V, 0x7, 0x0 }, // 10079 + { PseudoVSUXSEG7EI32_V_MF2_MF2_MASK, VSUXSEG7EI32_V, 0x7, 0x0 }, // 10080 + { PseudoVSUXSEG7EI64_V_M1_M1, VSUXSEG7EI64_V, 0x0, 0x0 }, // 10081 + { PseudoVSUXSEG7EI64_V_M1_M1_MASK, VSUXSEG7EI64_V, 0x0, 0x0 }, // 10082 + { PseudoVSUXSEG7EI64_V_M2_M1, VSUXSEG7EI64_V, 0x0, 0x0 }, // 10083 + { PseudoVSUXSEG7EI64_V_M2_M1_MASK, VSUXSEG7EI64_V, 0x0, 0x0 }, // 10084 + { PseudoVSUXSEG7EI64_V_M4_M1, VSUXSEG7EI64_V, 0x0, 0x0 }, // 10085 + { PseudoVSUXSEG7EI64_V_M4_M1_MASK, VSUXSEG7EI64_V, 0x0, 0x0 }, // 10086 + { PseudoVSUXSEG7EI64_V_M8_M1, VSUXSEG7EI64_V, 0x0, 0x0 }, // 10087 + { PseudoVSUXSEG7EI64_V_M8_M1_MASK, VSUXSEG7EI64_V, 0x0, 0x0 }, // 10088 + { PseudoVSUXSEG7EI64_V_M1_MF8, VSUXSEG7EI64_V, 0x5, 0x0 }, // 10089 + { PseudoVSUXSEG7EI64_V_M1_MF8_MASK, VSUXSEG7EI64_V, 0x5, 0x0 }, // 10090 + { PseudoVSUXSEG7EI64_V_M1_MF4, VSUXSEG7EI64_V, 0x6, 0x0 }, // 10091 + { PseudoVSUXSEG7EI64_V_M1_MF4_MASK, VSUXSEG7EI64_V, 0x6, 0x0 }, // 10092 + { PseudoVSUXSEG7EI64_V_M2_MF4, VSUXSEG7EI64_V, 0x6, 0x0 }, // 10093 + { PseudoVSUXSEG7EI64_V_M2_MF4_MASK, VSUXSEG7EI64_V, 0x6, 0x0 }, // 10094 + { PseudoVSUXSEG7EI64_V_M1_MF2, VSUXSEG7EI64_V, 0x7, 0x0 }, // 10095 + { PseudoVSUXSEG7EI64_V_M1_MF2_MASK, VSUXSEG7EI64_V, 0x7, 0x0 }, // 10096 + { PseudoVSUXSEG7EI64_V_M2_MF2, VSUXSEG7EI64_V, 0x7, 0x0 }, // 10097 + { PseudoVSUXSEG7EI64_V_M2_MF2_MASK, VSUXSEG7EI64_V, 0x7, 0x0 }, // 10098 + { PseudoVSUXSEG7EI64_V_M4_MF2, VSUXSEG7EI64_V, 0x7, 0x0 }, // 10099 + { PseudoVSUXSEG7EI64_V_M4_MF2_MASK, VSUXSEG7EI64_V, 0x7, 0x0 }, // 10100 + { PseudoVSUXSEG7EI8_V_M1_M1, VSUXSEG7EI8_V, 0x0, 0x0 }, // 10101 + { PseudoVSUXSEG7EI8_V_M1_M1_MASK, VSUXSEG7EI8_V, 0x0, 0x0 }, // 10102 + { PseudoVSUXSEG7EI8_V_MF2_M1, VSUXSEG7EI8_V, 0x0, 0x0 }, // 10103 + { PseudoVSUXSEG7EI8_V_MF2_M1_MASK, VSUXSEG7EI8_V, 0x0, 0x0 }, // 10104 + { PseudoVSUXSEG7EI8_V_MF4_M1, VSUXSEG7EI8_V, 0x0, 0x0 }, // 10105 + { PseudoVSUXSEG7EI8_V_MF4_M1_MASK, VSUXSEG7EI8_V, 0x0, 0x0 }, // 10106 + { PseudoVSUXSEG7EI8_V_MF8_M1, VSUXSEG7EI8_V, 0x0, 0x0 }, // 10107 + { PseudoVSUXSEG7EI8_V_MF8_M1_MASK, VSUXSEG7EI8_V, 0x0, 0x0 }, // 10108 + { PseudoVSUXSEG7EI8_V_MF8_MF8, VSUXSEG7EI8_V, 0x5, 0x0 }, // 10109 + { PseudoVSUXSEG7EI8_V_MF8_MF8_MASK, VSUXSEG7EI8_V, 0x5, 0x0 }, // 10110 + { PseudoVSUXSEG7EI8_V_MF4_MF4, VSUXSEG7EI8_V, 0x6, 0x0 }, // 10111 + { PseudoVSUXSEG7EI8_V_MF4_MF4_MASK, VSUXSEG7EI8_V, 0x6, 0x0 }, // 10112 + { PseudoVSUXSEG7EI8_V_MF8_MF4, VSUXSEG7EI8_V, 0x6, 0x0 }, // 10113 + { PseudoVSUXSEG7EI8_V_MF8_MF4_MASK, VSUXSEG7EI8_V, 0x6, 0x0 }, // 10114 + { PseudoVSUXSEG7EI8_V_MF2_MF2, VSUXSEG7EI8_V, 0x7, 0x0 }, // 10115 + { PseudoVSUXSEG7EI8_V_MF2_MF2_MASK, VSUXSEG7EI8_V, 0x7, 0x0 }, // 10116 + { PseudoVSUXSEG7EI8_V_MF4_MF2, VSUXSEG7EI8_V, 0x7, 0x0 }, // 10117 + { PseudoVSUXSEG7EI8_V_MF4_MF2_MASK, VSUXSEG7EI8_V, 0x7, 0x0 }, // 10118 + { PseudoVSUXSEG7EI8_V_MF8_MF2, VSUXSEG7EI8_V, 0x7, 0x0 }, // 10119 + { PseudoVSUXSEG7EI8_V_MF8_MF2_MASK, VSUXSEG7EI8_V, 0x7, 0x0 }, // 10120 + { PseudoVSUXSEG8EI16_V_M1_M1, VSUXSEG8EI16_V, 0x0, 0x0 }, // 10121 + { PseudoVSUXSEG8EI16_V_M1_M1_MASK, VSUXSEG8EI16_V, 0x0, 0x0 }, // 10122 + { PseudoVSUXSEG8EI16_V_M2_M1, VSUXSEG8EI16_V, 0x0, 0x0 }, // 10123 + { PseudoVSUXSEG8EI16_V_M2_M1_MASK, VSUXSEG8EI16_V, 0x0, 0x0 }, // 10124 + { PseudoVSUXSEG8EI16_V_MF2_M1, VSUXSEG8EI16_V, 0x0, 0x0 }, // 10125 + { PseudoVSUXSEG8EI16_V_MF2_M1_MASK, VSUXSEG8EI16_V, 0x0, 0x0 }, // 10126 + { PseudoVSUXSEG8EI16_V_MF4_M1, VSUXSEG8EI16_V, 0x0, 0x0 }, // 10127 + { PseudoVSUXSEG8EI16_V_MF4_M1_MASK, VSUXSEG8EI16_V, 0x0, 0x0 }, // 10128 + { PseudoVSUXSEG8EI16_V_MF4_MF8, VSUXSEG8EI16_V, 0x5, 0x0 }, // 10129 + { PseudoVSUXSEG8EI16_V_MF4_MF8_MASK, VSUXSEG8EI16_V, 0x5, 0x0 }, // 10130 + { PseudoVSUXSEG8EI16_V_MF2_MF4, VSUXSEG8EI16_V, 0x6, 0x0 }, // 10131 + { PseudoVSUXSEG8EI16_V_MF2_MF4_MASK, VSUXSEG8EI16_V, 0x6, 0x0 }, // 10132 + { PseudoVSUXSEG8EI16_V_MF4_MF4, VSUXSEG8EI16_V, 0x6, 0x0 }, // 10133 + { PseudoVSUXSEG8EI16_V_MF4_MF4_MASK, VSUXSEG8EI16_V, 0x6, 0x0 }, // 10134 + { PseudoVSUXSEG8EI16_V_M1_MF2, VSUXSEG8EI16_V, 0x7, 0x0 }, // 10135 + { PseudoVSUXSEG8EI16_V_M1_MF2_MASK, VSUXSEG8EI16_V, 0x7, 0x0 }, // 10136 + { PseudoVSUXSEG8EI16_V_MF2_MF2, VSUXSEG8EI16_V, 0x7, 0x0 }, // 10137 + { PseudoVSUXSEG8EI16_V_MF2_MF2_MASK, VSUXSEG8EI16_V, 0x7, 0x0 }, // 10138 + { PseudoVSUXSEG8EI16_V_MF4_MF2, VSUXSEG8EI16_V, 0x7, 0x0 }, // 10139 + { PseudoVSUXSEG8EI16_V_MF4_MF2_MASK, VSUXSEG8EI16_V, 0x7, 0x0 }, // 10140 + { PseudoVSUXSEG8EI32_V_M1_M1, VSUXSEG8EI32_V, 0x0, 0x0 }, // 10141 + { PseudoVSUXSEG8EI32_V_M1_M1_MASK, VSUXSEG8EI32_V, 0x0, 0x0 }, // 10142 + { PseudoVSUXSEG8EI32_V_M2_M1, VSUXSEG8EI32_V, 0x0, 0x0 }, // 10143 + { PseudoVSUXSEG8EI32_V_M2_M1_MASK, VSUXSEG8EI32_V, 0x0, 0x0 }, // 10144 + { PseudoVSUXSEG8EI32_V_M4_M1, VSUXSEG8EI32_V, 0x0, 0x0 }, // 10145 + { PseudoVSUXSEG8EI32_V_M4_M1_MASK, VSUXSEG8EI32_V, 0x0, 0x0 }, // 10146 + { PseudoVSUXSEG8EI32_V_MF2_M1, VSUXSEG8EI32_V, 0x0, 0x0 }, // 10147 + { PseudoVSUXSEG8EI32_V_MF2_M1_MASK, VSUXSEG8EI32_V, 0x0, 0x0 }, // 10148 + { PseudoVSUXSEG8EI32_V_MF2_MF8, VSUXSEG8EI32_V, 0x5, 0x0 }, // 10149 + { PseudoVSUXSEG8EI32_V_MF2_MF8_MASK, VSUXSEG8EI32_V, 0x5, 0x0 }, // 10150 + { PseudoVSUXSEG8EI32_V_M1_MF4, VSUXSEG8EI32_V, 0x6, 0x0 }, // 10151 + { PseudoVSUXSEG8EI32_V_M1_MF4_MASK, VSUXSEG8EI32_V, 0x6, 0x0 }, // 10152 + { PseudoVSUXSEG8EI32_V_MF2_MF4, VSUXSEG8EI32_V, 0x6, 0x0 }, // 10153 + { PseudoVSUXSEG8EI32_V_MF2_MF4_MASK, VSUXSEG8EI32_V, 0x6, 0x0 }, // 10154 + { PseudoVSUXSEG8EI32_V_M1_MF2, VSUXSEG8EI32_V, 0x7, 0x0 }, // 10155 + { PseudoVSUXSEG8EI32_V_M1_MF2_MASK, VSUXSEG8EI32_V, 0x7, 0x0 }, // 10156 + { PseudoVSUXSEG8EI32_V_M2_MF2, VSUXSEG8EI32_V, 0x7, 0x0 }, // 10157 + { PseudoVSUXSEG8EI32_V_M2_MF2_MASK, VSUXSEG8EI32_V, 0x7, 0x0 }, // 10158 + { PseudoVSUXSEG8EI32_V_MF2_MF2, VSUXSEG8EI32_V, 0x7, 0x0 }, // 10159 + { PseudoVSUXSEG8EI32_V_MF2_MF2_MASK, VSUXSEG8EI32_V, 0x7, 0x0 }, // 10160 + { PseudoVSUXSEG8EI64_V_M1_M1, VSUXSEG8EI64_V, 0x0, 0x0 }, // 10161 + { PseudoVSUXSEG8EI64_V_M1_M1_MASK, VSUXSEG8EI64_V, 0x0, 0x0 }, // 10162 + { PseudoVSUXSEG8EI64_V_M2_M1, VSUXSEG8EI64_V, 0x0, 0x0 }, // 10163 + { PseudoVSUXSEG8EI64_V_M2_M1_MASK, VSUXSEG8EI64_V, 0x0, 0x0 }, // 10164 + { PseudoVSUXSEG8EI64_V_M4_M1, VSUXSEG8EI64_V, 0x0, 0x0 }, // 10165 + { PseudoVSUXSEG8EI64_V_M4_M1_MASK, VSUXSEG8EI64_V, 0x0, 0x0 }, // 10166 + { PseudoVSUXSEG8EI64_V_M8_M1, VSUXSEG8EI64_V, 0x0, 0x0 }, // 10167 + { PseudoVSUXSEG8EI64_V_M8_M1_MASK, VSUXSEG8EI64_V, 0x0, 0x0 }, // 10168 + { PseudoVSUXSEG8EI64_V_M1_MF8, VSUXSEG8EI64_V, 0x5, 0x0 }, // 10169 + { PseudoVSUXSEG8EI64_V_M1_MF8_MASK, VSUXSEG8EI64_V, 0x5, 0x0 }, // 10170 + { PseudoVSUXSEG8EI64_V_M1_MF4, VSUXSEG8EI64_V, 0x6, 0x0 }, // 10171 + { PseudoVSUXSEG8EI64_V_M1_MF4_MASK, VSUXSEG8EI64_V, 0x6, 0x0 }, // 10172 + { PseudoVSUXSEG8EI64_V_M2_MF4, VSUXSEG8EI64_V, 0x6, 0x0 }, // 10173 + { PseudoVSUXSEG8EI64_V_M2_MF4_MASK, VSUXSEG8EI64_V, 0x6, 0x0 }, // 10174 + { PseudoVSUXSEG8EI64_V_M1_MF2, VSUXSEG8EI64_V, 0x7, 0x0 }, // 10175 + { PseudoVSUXSEG8EI64_V_M1_MF2_MASK, VSUXSEG8EI64_V, 0x7, 0x0 }, // 10176 + { PseudoVSUXSEG8EI64_V_M2_MF2, VSUXSEG8EI64_V, 0x7, 0x0 }, // 10177 + { PseudoVSUXSEG8EI64_V_M2_MF2_MASK, VSUXSEG8EI64_V, 0x7, 0x0 }, // 10178 + { PseudoVSUXSEG8EI64_V_M4_MF2, VSUXSEG8EI64_V, 0x7, 0x0 }, // 10179 + { PseudoVSUXSEG8EI64_V_M4_MF2_MASK, VSUXSEG8EI64_V, 0x7, 0x0 }, // 10180 + { PseudoVSUXSEG8EI8_V_M1_M1, VSUXSEG8EI8_V, 0x0, 0x0 }, // 10181 + { PseudoVSUXSEG8EI8_V_M1_M1_MASK, VSUXSEG8EI8_V, 0x0, 0x0 }, // 10182 + { PseudoVSUXSEG8EI8_V_MF2_M1, VSUXSEG8EI8_V, 0x0, 0x0 }, // 10183 + { PseudoVSUXSEG8EI8_V_MF2_M1_MASK, VSUXSEG8EI8_V, 0x0, 0x0 }, // 10184 + { PseudoVSUXSEG8EI8_V_MF4_M1, VSUXSEG8EI8_V, 0x0, 0x0 }, // 10185 + { PseudoVSUXSEG8EI8_V_MF4_M1_MASK, VSUXSEG8EI8_V, 0x0, 0x0 }, // 10186 + { PseudoVSUXSEG8EI8_V_MF8_M1, VSUXSEG8EI8_V, 0x0, 0x0 }, // 10187 + { PseudoVSUXSEG8EI8_V_MF8_M1_MASK, VSUXSEG8EI8_V, 0x0, 0x0 }, // 10188 + { PseudoVSUXSEG8EI8_V_MF8_MF8, VSUXSEG8EI8_V, 0x5, 0x0 }, // 10189 + { PseudoVSUXSEG8EI8_V_MF8_MF8_MASK, VSUXSEG8EI8_V, 0x5, 0x0 }, // 10190 + { PseudoVSUXSEG8EI8_V_MF4_MF4, VSUXSEG8EI8_V, 0x6, 0x0 }, // 10191 + { PseudoVSUXSEG8EI8_V_MF4_MF4_MASK, VSUXSEG8EI8_V, 0x6, 0x0 }, // 10192 + { PseudoVSUXSEG8EI8_V_MF8_MF4, VSUXSEG8EI8_V, 0x6, 0x0 }, // 10193 + { PseudoVSUXSEG8EI8_V_MF8_MF4_MASK, VSUXSEG8EI8_V, 0x6, 0x0 }, // 10194 + { PseudoVSUXSEG8EI8_V_MF2_MF2, VSUXSEG8EI8_V, 0x7, 0x0 }, // 10195 + { PseudoVSUXSEG8EI8_V_MF2_MF2_MASK, VSUXSEG8EI8_V, 0x7, 0x0 }, // 10196 + { PseudoVSUXSEG8EI8_V_MF4_MF2, VSUXSEG8EI8_V, 0x7, 0x0 }, // 10197 + { PseudoVSUXSEG8EI8_V_MF4_MF2_MASK, VSUXSEG8EI8_V, 0x7, 0x0 }, // 10198 + { PseudoVSUXSEG8EI8_V_MF8_MF2, VSUXSEG8EI8_V, 0x7, 0x0 }, // 10199 + { PseudoVSUXSEG8EI8_V_MF8_MF2_MASK, VSUXSEG8EI8_V, 0x7, 0x0 }, // 10200 + { PseudoVWADDU_VV_M1, VWADDU_VV, 0x0, 0x0 }, // 10201 + { PseudoVWADDU_VV_M1_MASK, VWADDU_VV, 0x0, 0x0 }, // 10202 + { PseudoVWADDU_VV_M2, VWADDU_VV, 0x1, 0x0 }, // 10203 + { PseudoVWADDU_VV_M2_MASK, VWADDU_VV, 0x1, 0x0 }, // 10204 + { PseudoVWADDU_VV_M4, VWADDU_VV, 0x2, 0x0 }, // 10205 + { PseudoVWADDU_VV_M4_MASK, VWADDU_VV, 0x2, 0x0 }, // 10206 + { PseudoVWADDU_VV_MF8, VWADDU_VV, 0x5, 0x0 }, // 10207 + { PseudoVWADDU_VV_MF8_MASK, VWADDU_VV, 0x5, 0x0 }, // 10208 + { PseudoVWADDU_VV_MF4, VWADDU_VV, 0x6, 0x0 }, // 10209 + { PseudoVWADDU_VV_MF4_MASK, VWADDU_VV, 0x6, 0x0 }, // 10210 + { PseudoVWADDU_VV_MF2, VWADDU_VV, 0x7, 0x0 }, // 10211 + { PseudoVWADDU_VV_MF2_MASK, VWADDU_VV, 0x7, 0x0 }, // 10212 + { PseudoVWADDU_VX_M1, VWADDU_VX, 0x0, 0x0 }, // 10213 + { PseudoVWADDU_VX_M1_MASK, VWADDU_VX, 0x0, 0x0 }, // 10214 + { PseudoVWADDU_VX_M2, VWADDU_VX, 0x1, 0x0 }, // 10215 + { PseudoVWADDU_VX_M2_MASK, VWADDU_VX, 0x1, 0x0 }, // 10216 + { PseudoVWADDU_VX_M4, VWADDU_VX, 0x2, 0x0 }, // 10217 + { PseudoVWADDU_VX_M4_MASK, VWADDU_VX, 0x2, 0x0 }, // 10218 + { PseudoVWADDU_VX_MF8, VWADDU_VX, 0x5, 0x0 }, // 10219 + { PseudoVWADDU_VX_MF8_MASK, VWADDU_VX, 0x5, 0x0 }, // 10220 + { PseudoVWADDU_VX_MF4, VWADDU_VX, 0x6, 0x0 }, // 10221 + { PseudoVWADDU_VX_MF4_MASK, VWADDU_VX, 0x6, 0x0 }, // 10222 + { PseudoVWADDU_VX_MF2, VWADDU_VX, 0x7, 0x0 }, // 10223 + { PseudoVWADDU_VX_MF2_MASK, VWADDU_VX, 0x7, 0x0 }, // 10224 + { PseudoVWADDU_WV_M1, VWADDU_WV, 0x0, 0x0 }, // 10225 + { PseudoVWADDU_WV_M1_MASK, VWADDU_WV, 0x0, 0x0 }, // 10226 + { PseudoVWADDU_WV_M1_MASK_TIED, VWADDU_WV, 0x0, 0x0 }, // 10227 + { PseudoVWADDU_WV_M1_TIED, VWADDU_WV, 0x0, 0x0 }, // 10228 + { PseudoVWADDU_WV_M2, VWADDU_WV, 0x1, 0x0 }, // 10229 + { PseudoVWADDU_WV_M2_MASK, VWADDU_WV, 0x1, 0x0 }, // 10230 + { PseudoVWADDU_WV_M2_MASK_TIED, VWADDU_WV, 0x1, 0x0 }, // 10231 + { PseudoVWADDU_WV_M2_TIED, VWADDU_WV, 0x1, 0x0 }, // 10232 + { PseudoVWADDU_WV_M4, VWADDU_WV, 0x2, 0x0 }, // 10233 + { PseudoVWADDU_WV_M4_MASK, VWADDU_WV, 0x2, 0x0 }, // 10234 + { PseudoVWADDU_WV_M4_MASK_TIED, VWADDU_WV, 0x2, 0x0 }, // 10235 + { PseudoVWADDU_WV_M4_TIED, VWADDU_WV, 0x2, 0x0 }, // 10236 + { PseudoVWADDU_WV_MF8, VWADDU_WV, 0x5, 0x0 }, // 10237 + { PseudoVWADDU_WV_MF8_MASK, VWADDU_WV, 0x5, 0x0 }, // 10238 + { PseudoVWADDU_WV_MF8_MASK_TIED, VWADDU_WV, 0x5, 0x0 }, // 10239 + { PseudoVWADDU_WV_MF8_TIED, VWADDU_WV, 0x5, 0x0 }, // 10240 + { PseudoVWADDU_WV_MF4, VWADDU_WV, 0x6, 0x0 }, // 10241 + { PseudoVWADDU_WV_MF4_MASK, VWADDU_WV, 0x6, 0x0 }, // 10242 + { PseudoVWADDU_WV_MF4_MASK_TIED, VWADDU_WV, 0x6, 0x0 }, // 10243 + { PseudoVWADDU_WV_MF4_TIED, VWADDU_WV, 0x6, 0x0 }, // 10244 + { PseudoVWADDU_WV_MF2, VWADDU_WV, 0x7, 0x0 }, // 10245 + { PseudoVWADDU_WV_MF2_MASK, VWADDU_WV, 0x7, 0x0 }, // 10246 + { PseudoVWADDU_WV_MF2_MASK_TIED, VWADDU_WV, 0x7, 0x0 }, // 10247 + { PseudoVWADDU_WV_MF2_TIED, VWADDU_WV, 0x7, 0x0 }, // 10248 + { PseudoVWADDU_WX_M1, VWADDU_WX, 0x0, 0x0 }, // 10249 + { PseudoVWADDU_WX_M1_MASK, VWADDU_WX, 0x0, 0x0 }, // 10250 + { PseudoVWADDU_WX_M2, VWADDU_WX, 0x1, 0x0 }, // 10251 + { PseudoVWADDU_WX_M2_MASK, VWADDU_WX, 0x1, 0x0 }, // 10252 + { PseudoVWADDU_WX_M4, VWADDU_WX, 0x2, 0x0 }, // 10253 + { PseudoVWADDU_WX_M4_MASK, VWADDU_WX, 0x2, 0x0 }, // 10254 + { PseudoVWADDU_WX_MF8, VWADDU_WX, 0x5, 0x0 }, // 10255 + { PseudoVWADDU_WX_MF8_MASK, VWADDU_WX, 0x5, 0x0 }, // 10256 + { PseudoVWADDU_WX_MF4, VWADDU_WX, 0x6, 0x0 }, // 10257 + { PseudoVWADDU_WX_MF4_MASK, VWADDU_WX, 0x6, 0x0 }, // 10258 + { PseudoVWADDU_WX_MF2, VWADDU_WX, 0x7, 0x0 }, // 10259 + { PseudoVWADDU_WX_MF2_MASK, VWADDU_WX, 0x7, 0x0 }, // 10260 + { PseudoVWADD_VV_M1, VWADD_VV, 0x0, 0x0 }, // 10261 + { PseudoVWADD_VV_M1_MASK, VWADD_VV, 0x0, 0x0 }, // 10262 + { PseudoVWADD_VV_M2, VWADD_VV, 0x1, 0x0 }, // 10263 + { PseudoVWADD_VV_M2_MASK, VWADD_VV, 0x1, 0x0 }, // 10264 + { PseudoVWADD_VV_M4, VWADD_VV, 0x2, 0x0 }, // 10265 + { PseudoVWADD_VV_M4_MASK, VWADD_VV, 0x2, 0x0 }, // 10266 + { PseudoVWADD_VV_MF8, VWADD_VV, 0x5, 0x0 }, // 10267 + { PseudoVWADD_VV_MF8_MASK, VWADD_VV, 0x5, 0x0 }, // 10268 + { PseudoVWADD_VV_MF4, VWADD_VV, 0x6, 0x0 }, // 10269 + { PseudoVWADD_VV_MF4_MASK, VWADD_VV, 0x6, 0x0 }, // 10270 + { PseudoVWADD_VV_MF2, VWADD_VV, 0x7, 0x0 }, // 10271 + { PseudoVWADD_VV_MF2_MASK, VWADD_VV, 0x7, 0x0 }, // 10272 + { PseudoVWADD_VX_M1, VWADD_VX, 0x0, 0x0 }, // 10273 + { PseudoVWADD_VX_M1_MASK, VWADD_VX, 0x0, 0x0 }, // 10274 + { PseudoVWADD_VX_M2, VWADD_VX, 0x1, 0x0 }, // 10275 + { PseudoVWADD_VX_M2_MASK, VWADD_VX, 0x1, 0x0 }, // 10276 + { PseudoVWADD_VX_M4, VWADD_VX, 0x2, 0x0 }, // 10277 + { PseudoVWADD_VX_M4_MASK, VWADD_VX, 0x2, 0x0 }, // 10278 + { PseudoVWADD_VX_MF8, VWADD_VX, 0x5, 0x0 }, // 10279 + { PseudoVWADD_VX_MF8_MASK, VWADD_VX, 0x5, 0x0 }, // 10280 + { PseudoVWADD_VX_MF4, VWADD_VX, 0x6, 0x0 }, // 10281 + { PseudoVWADD_VX_MF4_MASK, VWADD_VX, 0x6, 0x0 }, // 10282 + { PseudoVWADD_VX_MF2, VWADD_VX, 0x7, 0x0 }, // 10283 + { PseudoVWADD_VX_MF2_MASK, VWADD_VX, 0x7, 0x0 }, // 10284 + { PseudoVWADD_WV_M1, VWADD_WV, 0x0, 0x0 }, // 10285 + { PseudoVWADD_WV_M1_MASK, VWADD_WV, 0x0, 0x0 }, // 10286 + { PseudoVWADD_WV_M1_MASK_TIED, VWADD_WV, 0x0, 0x0 }, // 10287 + { PseudoVWADD_WV_M1_TIED, VWADD_WV, 0x0, 0x0 }, // 10288 + { PseudoVWADD_WV_M2, VWADD_WV, 0x1, 0x0 }, // 10289 + { PseudoVWADD_WV_M2_MASK, VWADD_WV, 0x1, 0x0 }, // 10290 + { PseudoVWADD_WV_M2_MASK_TIED, VWADD_WV, 0x1, 0x0 }, // 10291 + { PseudoVWADD_WV_M2_TIED, VWADD_WV, 0x1, 0x0 }, // 10292 + { PseudoVWADD_WV_M4, VWADD_WV, 0x2, 0x0 }, // 10293 + { PseudoVWADD_WV_M4_MASK, VWADD_WV, 0x2, 0x0 }, // 10294 + { PseudoVWADD_WV_M4_MASK_TIED, VWADD_WV, 0x2, 0x0 }, // 10295 + { PseudoVWADD_WV_M4_TIED, VWADD_WV, 0x2, 0x0 }, // 10296 + { PseudoVWADD_WV_MF8, VWADD_WV, 0x5, 0x0 }, // 10297 + { PseudoVWADD_WV_MF8_MASK, VWADD_WV, 0x5, 0x0 }, // 10298 + { PseudoVWADD_WV_MF8_MASK_TIED, VWADD_WV, 0x5, 0x0 }, // 10299 + { PseudoVWADD_WV_MF8_TIED, VWADD_WV, 0x5, 0x0 }, // 10300 + { PseudoVWADD_WV_MF4, VWADD_WV, 0x6, 0x0 }, // 10301 + { PseudoVWADD_WV_MF4_MASK, VWADD_WV, 0x6, 0x0 }, // 10302 + { PseudoVWADD_WV_MF4_MASK_TIED, VWADD_WV, 0x6, 0x0 }, // 10303 + { PseudoVWADD_WV_MF4_TIED, VWADD_WV, 0x6, 0x0 }, // 10304 + { PseudoVWADD_WV_MF2, VWADD_WV, 0x7, 0x0 }, // 10305 + { PseudoVWADD_WV_MF2_MASK, VWADD_WV, 0x7, 0x0 }, // 10306 + { PseudoVWADD_WV_MF2_MASK_TIED, VWADD_WV, 0x7, 0x0 }, // 10307 + { PseudoVWADD_WV_MF2_TIED, VWADD_WV, 0x7, 0x0 }, // 10308 + { PseudoVWADD_WX_M1, VWADD_WX, 0x0, 0x0 }, // 10309 + { PseudoVWADD_WX_M1_MASK, VWADD_WX, 0x0, 0x0 }, // 10310 + { PseudoVWADD_WX_M2, VWADD_WX, 0x1, 0x0 }, // 10311 + { PseudoVWADD_WX_M2_MASK, VWADD_WX, 0x1, 0x0 }, // 10312 + { PseudoVWADD_WX_M4, VWADD_WX, 0x2, 0x0 }, // 10313 + { PseudoVWADD_WX_M4_MASK, VWADD_WX, 0x2, 0x0 }, // 10314 + { PseudoVWADD_WX_MF8, VWADD_WX, 0x5, 0x0 }, // 10315 + { PseudoVWADD_WX_MF8_MASK, VWADD_WX, 0x5, 0x0 }, // 10316 + { PseudoVWADD_WX_MF4, VWADD_WX, 0x6, 0x0 }, // 10317 + { PseudoVWADD_WX_MF4_MASK, VWADD_WX, 0x6, 0x0 }, // 10318 + { PseudoVWADD_WX_MF2, VWADD_WX, 0x7, 0x0 }, // 10319 + { PseudoVWADD_WX_MF2_MASK, VWADD_WX, 0x7, 0x0 }, // 10320 + { PseudoVWMACCSU_VV_M1, VWMACCSU_VV, 0x0, 0x0 }, // 10321 + { PseudoVWMACCSU_VV_M1_MASK, VWMACCSU_VV, 0x0, 0x0 }, // 10322 + { PseudoVWMACCSU_VV_M2, VWMACCSU_VV, 0x1, 0x0 }, // 10323 + { PseudoVWMACCSU_VV_M2_MASK, VWMACCSU_VV, 0x1, 0x0 }, // 10324 + { PseudoVWMACCSU_VV_M4, VWMACCSU_VV, 0x2, 0x0 }, // 10325 + { PseudoVWMACCSU_VV_M4_MASK, VWMACCSU_VV, 0x2, 0x0 }, // 10326 + { PseudoVWMACCSU_VV_MF8, VWMACCSU_VV, 0x5, 0x0 }, // 10327 + { PseudoVWMACCSU_VV_MF8_MASK, VWMACCSU_VV, 0x5, 0x0 }, // 10328 + { PseudoVWMACCSU_VV_MF4, VWMACCSU_VV, 0x6, 0x0 }, // 10329 + { PseudoVWMACCSU_VV_MF4_MASK, VWMACCSU_VV, 0x6, 0x0 }, // 10330 + { PseudoVWMACCSU_VV_MF2, VWMACCSU_VV, 0x7, 0x0 }, // 10331 + { PseudoVWMACCSU_VV_MF2_MASK, VWMACCSU_VV, 0x7, 0x0 }, // 10332 + { PseudoVWMACCSU_VX_M1, VWMACCSU_VX, 0x0, 0x0 }, // 10333 + { PseudoVWMACCSU_VX_M1_MASK, VWMACCSU_VX, 0x0, 0x0 }, // 10334 + { PseudoVWMACCSU_VX_M2, VWMACCSU_VX, 0x1, 0x0 }, // 10335 + { PseudoVWMACCSU_VX_M2_MASK, VWMACCSU_VX, 0x1, 0x0 }, // 10336 + { PseudoVWMACCSU_VX_M4, VWMACCSU_VX, 0x2, 0x0 }, // 10337 + { PseudoVWMACCSU_VX_M4_MASK, VWMACCSU_VX, 0x2, 0x0 }, // 10338 + { PseudoVWMACCSU_VX_MF8, VWMACCSU_VX, 0x5, 0x0 }, // 10339 + { PseudoVWMACCSU_VX_MF8_MASK, VWMACCSU_VX, 0x5, 0x0 }, // 10340 + { PseudoVWMACCSU_VX_MF4, VWMACCSU_VX, 0x6, 0x0 }, // 10341 + { PseudoVWMACCSU_VX_MF4_MASK, VWMACCSU_VX, 0x6, 0x0 }, // 10342 + { PseudoVWMACCSU_VX_MF2, VWMACCSU_VX, 0x7, 0x0 }, // 10343 + { PseudoVWMACCSU_VX_MF2_MASK, VWMACCSU_VX, 0x7, 0x0 }, // 10344 + { PseudoVWMACCUS_VX_M1, VWMACCUS_VX, 0x0, 0x0 }, // 10345 + { PseudoVWMACCUS_VX_M1_MASK, VWMACCUS_VX, 0x0, 0x0 }, // 10346 + { PseudoVWMACCUS_VX_M2, VWMACCUS_VX, 0x1, 0x0 }, // 10347 + { PseudoVWMACCUS_VX_M2_MASK, VWMACCUS_VX, 0x1, 0x0 }, // 10348 + { PseudoVWMACCUS_VX_M4, VWMACCUS_VX, 0x2, 0x0 }, // 10349 + { PseudoVWMACCUS_VX_M4_MASK, VWMACCUS_VX, 0x2, 0x0 }, // 10350 + { PseudoVWMACCUS_VX_MF8, VWMACCUS_VX, 0x5, 0x0 }, // 10351 + { PseudoVWMACCUS_VX_MF8_MASK, VWMACCUS_VX, 0x5, 0x0 }, // 10352 + { PseudoVWMACCUS_VX_MF4, VWMACCUS_VX, 0x6, 0x0 }, // 10353 + { PseudoVWMACCUS_VX_MF4_MASK, VWMACCUS_VX, 0x6, 0x0 }, // 10354 + { PseudoVWMACCUS_VX_MF2, VWMACCUS_VX, 0x7, 0x0 }, // 10355 + { PseudoVWMACCUS_VX_MF2_MASK, VWMACCUS_VX, 0x7, 0x0 }, // 10356 + { PseudoVWMACCU_VV_M1, VWMACCU_VV, 0x0, 0x0 }, // 10357 + { PseudoVWMACCU_VV_M1_MASK, VWMACCU_VV, 0x0, 0x0 }, // 10358 + { PseudoVWMACCU_VV_M2, VWMACCU_VV, 0x1, 0x0 }, // 10359 + { PseudoVWMACCU_VV_M2_MASK, VWMACCU_VV, 0x1, 0x0 }, // 10360 + { PseudoVWMACCU_VV_M4, VWMACCU_VV, 0x2, 0x0 }, // 10361 + { PseudoVWMACCU_VV_M4_MASK, VWMACCU_VV, 0x2, 0x0 }, // 10362 + { PseudoVWMACCU_VV_MF8, VWMACCU_VV, 0x5, 0x0 }, // 10363 + { PseudoVWMACCU_VV_MF8_MASK, VWMACCU_VV, 0x5, 0x0 }, // 10364 + { PseudoVWMACCU_VV_MF4, VWMACCU_VV, 0x6, 0x0 }, // 10365 + { PseudoVWMACCU_VV_MF4_MASK, VWMACCU_VV, 0x6, 0x0 }, // 10366 + { PseudoVWMACCU_VV_MF2, VWMACCU_VV, 0x7, 0x0 }, // 10367 + { PseudoVWMACCU_VV_MF2_MASK, VWMACCU_VV, 0x7, 0x0 }, // 10368 + { PseudoVWMACCU_VX_M1, VWMACCU_VX, 0x0, 0x0 }, // 10369 + { PseudoVWMACCU_VX_M1_MASK, VWMACCU_VX, 0x0, 0x0 }, // 10370 + { PseudoVWMACCU_VX_M2, VWMACCU_VX, 0x1, 0x0 }, // 10371 + { PseudoVWMACCU_VX_M2_MASK, VWMACCU_VX, 0x1, 0x0 }, // 10372 + { PseudoVWMACCU_VX_M4, VWMACCU_VX, 0x2, 0x0 }, // 10373 + { PseudoVWMACCU_VX_M4_MASK, VWMACCU_VX, 0x2, 0x0 }, // 10374 + { PseudoVWMACCU_VX_MF8, VWMACCU_VX, 0x5, 0x0 }, // 10375 + { PseudoVWMACCU_VX_MF8_MASK, VWMACCU_VX, 0x5, 0x0 }, // 10376 + { PseudoVWMACCU_VX_MF4, VWMACCU_VX, 0x6, 0x0 }, // 10377 + { PseudoVWMACCU_VX_MF4_MASK, VWMACCU_VX, 0x6, 0x0 }, // 10378 + { PseudoVWMACCU_VX_MF2, VWMACCU_VX, 0x7, 0x0 }, // 10379 + { PseudoVWMACCU_VX_MF2_MASK, VWMACCU_VX, 0x7, 0x0 }, // 10380 + { PseudoVWMACC_VV_M1, VWMACC_VV, 0x0, 0x0 }, // 10381 + { PseudoVWMACC_VV_M1_MASK, VWMACC_VV, 0x0, 0x0 }, // 10382 + { PseudoVWMACC_VV_M2, VWMACC_VV, 0x1, 0x0 }, // 10383 + { PseudoVWMACC_VV_M2_MASK, VWMACC_VV, 0x1, 0x0 }, // 10384 + { PseudoVWMACC_VV_M4, VWMACC_VV, 0x2, 0x0 }, // 10385 + { PseudoVWMACC_VV_M4_MASK, VWMACC_VV, 0x2, 0x0 }, // 10386 + { PseudoVWMACC_VV_MF8, VWMACC_VV, 0x5, 0x0 }, // 10387 + { PseudoVWMACC_VV_MF8_MASK, VWMACC_VV, 0x5, 0x0 }, // 10388 + { PseudoVWMACC_VV_MF4, VWMACC_VV, 0x6, 0x0 }, // 10389 + { PseudoVWMACC_VV_MF4_MASK, VWMACC_VV, 0x6, 0x0 }, // 10390 + { PseudoVWMACC_VV_MF2, VWMACC_VV, 0x7, 0x0 }, // 10391 + { PseudoVWMACC_VV_MF2_MASK, VWMACC_VV, 0x7, 0x0 }, // 10392 + { PseudoVWMACC_VX_M1, VWMACC_VX, 0x0, 0x0 }, // 10393 + { PseudoVWMACC_VX_M1_MASK, VWMACC_VX, 0x0, 0x0 }, // 10394 + { PseudoVWMACC_VX_M2, VWMACC_VX, 0x1, 0x0 }, // 10395 + { PseudoVWMACC_VX_M2_MASK, VWMACC_VX, 0x1, 0x0 }, // 10396 + { PseudoVWMACC_VX_M4, VWMACC_VX, 0x2, 0x0 }, // 10397 + { PseudoVWMACC_VX_M4_MASK, VWMACC_VX, 0x2, 0x0 }, // 10398 + { PseudoVWMACC_VX_MF8, VWMACC_VX, 0x5, 0x0 }, // 10399 + { PseudoVWMACC_VX_MF8_MASK, VWMACC_VX, 0x5, 0x0 }, // 10400 + { PseudoVWMACC_VX_MF4, VWMACC_VX, 0x6, 0x0 }, // 10401 + { PseudoVWMACC_VX_MF4_MASK, VWMACC_VX, 0x6, 0x0 }, // 10402 + { PseudoVWMACC_VX_MF2, VWMACC_VX, 0x7, 0x0 }, // 10403 + { PseudoVWMACC_VX_MF2_MASK, VWMACC_VX, 0x7, 0x0 }, // 10404 + { PseudoVWMULSU_VV_M1, VWMULSU_VV, 0x0, 0x0 }, // 10405 + { PseudoVWMULSU_VV_M1_MASK, VWMULSU_VV, 0x0, 0x0 }, // 10406 + { PseudoVWMULSU_VV_M2, VWMULSU_VV, 0x1, 0x0 }, // 10407 + { PseudoVWMULSU_VV_M2_MASK, VWMULSU_VV, 0x1, 0x0 }, // 10408 + { PseudoVWMULSU_VV_M4, VWMULSU_VV, 0x2, 0x0 }, // 10409 + { PseudoVWMULSU_VV_M4_MASK, VWMULSU_VV, 0x2, 0x0 }, // 10410 + { PseudoVWMULSU_VV_MF8, VWMULSU_VV, 0x5, 0x0 }, // 10411 + { PseudoVWMULSU_VV_MF8_MASK, VWMULSU_VV, 0x5, 0x0 }, // 10412 + { PseudoVWMULSU_VV_MF4, VWMULSU_VV, 0x6, 0x0 }, // 10413 + { PseudoVWMULSU_VV_MF4_MASK, VWMULSU_VV, 0x6, 0x0 }, // 10414 + { PseudoVWMULSU_VV_MF2, VWMULSU_VV, 0x7, 0x0 }, // 10415 + { PseudoVWMULSU_VV_MF2_MASK, VWMULSU_VV, 0x7, 0x0 }, // 10416 + { PseudoVWMULSU_VX_M1, VWMULSU_VX, 0x0, 0x0 }, // 10417 + { PseudoVWMULSU_VX_M1_MASK, VWMULSU_VX, 0x0, 0x0 }, // 10418 + { PseudoVWMULSU_VX_M2, VWMULSU_VX, 0x1, 0x0 }, // 10419 + { PseudoVWMULSU_VX_M2_MASK, VWMULSU_VX, 0x1, 0x0 }, // 10420 + { PseudoVWMULSU_VX_M4, VWMULSU_VX, 0x2, 0x0 }, // 10421 + { PseudoVWMULSU_VX_M4_MASK, VWMULSU_VX, 0x2, 0x0 }, // 10422 + { PseudoVWMULSU_VX_MF8, VWMULSU_VX, 0x5, 0x0 }, // 10423 + { PseudoVWMULSU_VX_MF8_MASK, VWMULSU_VX, 0x5, 0x0 }, // 10424 + { PseudoVWMULSU_VX_MF4, VWMULSU_VX, 0x6, 0x0 }, // 10425 + { PseudoVWMULSU_VX_MF4_MASK, VWMULSU_VX, 0x6, 0x0 }, // 10426 + { PseudoVWMULSU_VX_MF2, VWMULSU_VX, 0x7, 0x0 }, // 10427 + { PseudoVWMULSU_VX_MF2_MASK, VWMULSU_VX, 0x7, 0x0 }, // 10428 + { PseudoVWMULU_VV_M1, VWMULU_VV, 0x0, 0x0 }, // 10429 + { PseudoVWMULU_VV_M1_MASK, VWMULU_VV, 0x0, 0x0 }, // 10430 + { PseudoVWMULU_VV_M2, VWMULU_VV, 0x1, 0x0 }, // 10431 + { PseudoVWMULU_VV_M2_MASK, VWMULU_VV, 0x1, 0x0 }, // 10432 + { PseudoVWMULU_VV_M4, VWMULU_VV, 0x2, 0x0 }, // 10433 + { PseudoVWMULU_VV_M4_MASK, VWMULU_VV, 0x2, 0x0 }, // 10434 + { PseudoVWMULU_VV_MF8, VWMULU_VV, 0x5, 0x0 }, // 10435 + { PseudoVWMULU_VV_MF8_MASK, VWMULU_VV, 0x5, 0x0 }, // 10436 + { PseudoVWMULU_VV_MF4, VWMULU_VV, 0x6, 0x0 }, // 10437 + { PseudoVWMULU_VV_MF4_MASK, VWMULU_VV, 0x6, 0x0 }, // 10438 + { PseudoVWMULU_VV_MF2, VWMULU_VV, 0x7, 0x0 }, // 10439 + { PseudoVWMULU_VV_MF2_MASK, VWMULU_VV, 0x7, 0x0 }, // 10440 + { PseudoVWMULU_VX_M1, VWMULU_VX, 0x0, 0x0 }, // 10441 + { PseudoVWMULU_VX_M1_MASK, VWMULU_VX, 0x0, 0x0 }, // 10442 + { PseudoVWMULU_VX_M2, VWMULU_VX, 0x1, 0x0 }, // 10443 + { PseudoVWMULU_VX_M2_MASK, VWMULU_VX, 0x1, 0x0 }, // 10444 + { PseudoVWMULU_VX_M4, VWMULU_VX, 0x2, 0x0 }, // 10445 + { PseudoVWMULU_VX_M4_MASK, VWMULU_VX, 0x2, 0x0 }, // 10446 + { PseudoVWMULU_VX_MF8, VWMULU_VX, 0x5, 0x0 }, // 10447 + { PseudoVWMULU_VX_MF8_MASK, VWMULU_VX, 0x5, 0x0 }, // 10448 + { PseudoVWMULU_VX_MF4, VWMULU_VX, 0x6, 0x0 }, // 10449 + { PseudoVWMULU_VX_MF4_MASK, VWMULU_VX, 0x6, 0x0 }, // 10450 + { PseudoVWMULU_VX_MF2, VWMULU_VX, 0x7, 0x0 }, // 10451 + { PseudoVWMULU_VX_MF2_MASK, VWMULU_VX, 0x7, 0x0 }, // 10452 + { PseudoVWMUL_VV_M1, VWMUL_VV, 0x0, 0x0 }, // 10453 + { PseudoVWMUL_VV_M1_MASK, VWMUL_VV, 0x0, 0x0 }, // 10454 + { PseudoVWMUL_VV_M2, VWMUL_VV, 0x1, 0x0 }, // 10455 + { PseudoVWMUL_VV_M2_MASK, VWMUL_VV, 0x1, 0x0 }, // 10456 + { PseudoVWMUL_VV_M4, VWMUL_VV, 0x2, 0x0 }, // 10457 + { PseudoVWMUL_VV_M4_MASK, VWMUL_VV, 0x2, 0x0 }, // 10458 + { PseudoVWMUL_VV_MF8, VWMUL_VV, 0x5, 0x0 }, // 10459 + { PseudoVWMUL_VV_MF8_MASK, VWMUL_VV, 0x5, 0x0 }, // 10460 + { PseudoVWMUL_VV_MF4, VWMUL_VV, 0x6, 0x0 }, // 10461 + { PseudoVWMUL_VV_MF4_MASK, VWMUL_VV, 0x6, 0x0 }, // 10462 + { PseudoVWMUL_VV_MF2, VWMUL_VV, 0x7, 0x0 }, // 10463 + { PseudoVWMUL_VV_MF2_MASK, VWMUL_VV, 0x7, 0x0 }, // 10464 + { PseudoVWMUL_VX_M1, VWMUL_VX, 0x0, 0x0 }, // 10465 + { PseudoVWMUL_VX_M1_MASK, VWMUL_VX, 0x0, 0x0 }, // 10466 + { PseudoVWMUL_VX_M2, VWMUL_VX, 0x1, 0x0 }, // 10467 + { PseudoVWMUL_VX_M2_MASK, VWMUL_VX, 0x1, 0x0 }, // 10468 + { PseudoVWMUL_VX_M4, VWMUL_VX, 0x2, 0x0 }, // 10469 + { PseudoVWMUL_VX_M4_MASK, VWMUL_VX, 0x2, 0x0 }, // 10470 + { PseudoVWMUL_VX_MF8, VWMUL_VX, 0x5, 0x0 }, // 10471 + { PseudoVWMUL_VX_MF8_MASK, VWMUL_VX, 0x5, 0x0 }, // 10472 + { PseudoVWMUL_VX_MF4, VWMUL_VX, 0x6, 0x0 }, // 10473 + { PseudoVWMUL_VX_MF4_MASK, VWMUL_VX, 0x6, 0x0 }, // 10474 + { PseudoVWMUL_VX_MF2, VWMUL_VX, 0x7, 0x0 }, // 10475 + { PseudoVWMUL_VX_MF2_MASK, VWMUL_VX, 0x7, 0x0 }, // 10476 + { PseudoVWREDSUMU_VS_M1_E8, VWREDSUMU_VS, 0x0, 0x8 }, // 10477 + { PseudoVWREDSUMU_VS_M1_E8_MASK, VWREDSUMU_VS, 0x0, 0x8 }, // 10478 + { PseudoVWREDSUMU_VS_M1_E16, VWREDSUMU_VS, 0x0, 0x10 }, // 10479 + { PseudoVWREDSUMU_VS_M1_E16_MASK, VWREDSUMU_VS, 0x0, 0x10 }, // 10480 + { PseudoVWREDSUMU_VS_M1_E32, VWREDSUMU_VS, 0x0, 0x20 }, // 10481 + { PseudoVWREDSUMU_VS_M1_E32_MASK, VWREDSUMU_VS, 0x0, 0x20 }, // 10482 + { PseudoVWREDSUMU_VS_M2_E8, VWREDSUMU_VS, 0x1, 0x8 }, // 10483 + { PseudoVWREDSUMU_VS_M2_E8_MASK, VWREDSUMU_VS, 0x1, 0x8 }, // 10484 + { PseudoVWREDSUMU_VS_M2_E16, VWREDSUMU_VS, 0x1, 0x10 }, // 10485 + { PseudoVWREDSUMU_VS_M2_E16_MASK, VWREDSUMU_VS, 0x1, 0x10 }, // 10486 + { PseudoVWREDSUMU_VS_M2_E32, VWREDSUMU_VS, 0x1, 0x20 }, // 10487 + { PseudoVWREDSUMU_VS_M2_E32_MASK, VWREDSUMU_VS, 0x1, 0x20 }, // 10488 + { PseudoVWREDSUMU_VS_M4_E8, VWREDSUMU_VS, 0x2, 0x8 }, // 10489 + { PseudoVWREDSUMU_VS_M4_E8_MASK, VWREDSUMU_VS, 0x2, 0x8 }, // 10490 + { PseudoVWREDSUMU_VS_M4_E16, VWREDSUMU_VS, 0x2, 0x10 }, // 10491 + { PseudoVWREDSUMU_VS_M4_E16_MASK, VWREDSUMU_VS, 0x2, 0x10 }, // 10492 + { PseudoVWREDSUMU_VS_M4_E32, VWREDSUMU_VS, 0x2, 0x20 }, // 10493 + { PseudoVWREDSUMU_VS_M4_E32_MASK, VWREDSUMU_VS, 0x2, 0x20 }, // 10494 + { PseudoVWREDSUMU_VS_M8_E8, VWREDSUMU_VS, 0x3, 0x8 }, // 10495 + { PseudoVWREDSUMU_VS_M8_E8_MASK, VWREDSUMU_VS, 0x3, 0x8 }, // 10496 + { PseudoVWREDSUMU_VS_M8_E16, VWREDSUMU_VS, 0x3, 0x10 }, // 10497 + { PseudoVWREDSUMU_VS_M8_E16_MASK, VWREDSUMU_VS, 0x3, 0x10 }, // 10498 + { PseudoVWREDSUMU_VS_M8_E32, VWREDSUMU_VS, 0x3, 0x20 }, // 10499 + { PseudoVWREDSUMU_VS_M8_E32_MASK, VWREDSUMU_VS, 0x3, 0x20 }, // 10500 + { PseudoVWREDSUMU_VS_MF8_E8, VWREDSUMU_VS, 0x5, 0x8 }, // 10501 + { PseudoVWREDSUMU_VS_MF8_E8_MASK, VWREDSUMU_VS, 0x5, 0x8 }, // 10502 + { PseudoVWREDSUMU_VS_MF4_E8, VWREDSUMU_VS, 0x6, 0x8 }, // 10503 + { PseudoVWREDSUMU_VS_MF4_E8_MASK, VWREDSUMU_VS, 0x6, 0x8 }, // 10504 + { PseudoVWREDSUMU_VS_MF4_E16, VWREDSUMU_VS, 0x6, 0x10 }, // 10505 + { PseudoVWREDSUMU_VS_MF4_E16_MASK, VWREDSUMU_VS, 0x6, 0x10 }, // 10506 + { PseudoVWREDSUMU_VS_MF2_E8, VWREDSUMU_VS, 0x7, 0x8 }, // 10507 + { PseudoVWREDSUMU_VS_MF2_E8_MASK, VWREDSUMU_VS, 0x7, 0x8 }, // 10508 + { PseudoVWREDSUMU_VS_MF2_E16, VWREDSUMU_VS, 0x7, 0x10 }, // 10509 + { PseudoVWREDSUMU_VS_MF2_E16_MASK, VWREDSUMU_VS, 0x7, 0x10 }, // 10510 + { PseudoVWREDSUMU_VS_MF2_E32, VWREDSUMU_VS, 0x7, 0x20 }, // 10511 + { PseudoVWREDSUMU_VS_MF2_E32_MASK, VWREDSUMU_VS, 0x7, 0x20 }, // 10512 + { PseudoVWREDSUM_VS_M1_E8, VWREDSUM_VS, 0x0, 0x8 }, // 10513 + { PseudoVWREDSUM_VS_M1_E8_MASK, VWREDSUM_VS, 0x0, 0x8 }, // 10514 + { PseudoVWREDSUM_VS_M1_E16, VWREDSUM_VS, 0x0, 0x10 }, // 10515 + { PseudoVWREDSUM_VS_M1_E16_MASK, VWREDSUM_VS, 0x0, 0x10 }, // 10516 + { PseudoVWREDSUM_VS_M1_E32, VWREDSUM_VS, 0x0, 0x20 }, // 10517 + { PseudoVWREDSUM_VS_M1_E32_MASK, VWREDSUM_VS, 0x0, 0x20 }, // 10518 + { PseudoVWREDSUM_VS_M2_E8, VWREDSUM_VS, 0x1, 0x8 }, // 10519 + { PseudoVWREDSUM_VS_M2_E8_MASK, VWREDSUM_VS, 0x1, 0x8 }, // 10520 + { PseudoVWREDSUM_VS_M2_E16, VWREDSUM_VS, 0x1, 0x10 }, // 10521 + { PseudoVWREDSUM_VS_M2_E16_MASK, VWREDSUM_VS, 0x1, 0x10 }, // 10522 + { PseudoVWREDSUM_VS_M2_E32, VWREDSUM_VS, 0x1, 0x20 }, // 10523 + { PseudoVWREDSUM_VS_M2_E32_MASK, VWREDSUM_VS, 0x1, 0x20 }, // 10524 + { PseudoVWREDSUM_VS_M4_E8, VWREDSUM_VS, 0x2, 0x8 }, // 10525 + { PseudoVWREDSUM_VS_M4_E8_MASK, VWREDSUM_VS, 0x2, 0x8 }, // 10526 + { PseudoVWREDSUM_VS_M4_E16, VWREDSUM_VS, 0x2, 0x10 }, // 10527 + { PseudoVWREDSUM_VS_M4_E16_MASK, VWREDSUM_VS, 0x2, 0x10 }, // 10528 + { PseudoVWREDSUM_VS_M4_E32, VWREDSUM_VS, 0x2, 0x20 }, // 10529 + { PseudoVWREDSUM_VS_M4_E32_MASK, VWREDSUM_VS, 0x2, 0x20 }, // 10530 + { PseudoVWREDSUM_VS_M8_E8, VWREDSUM_VS, 0x3, 0x8 }, // 10531 + { PseudoVWREDSUM_VS_M8_E8_MASK, VWREDSUM_VS, 0x3, 0x8 }, // 10532 + { PseudoVWREDSUM_VS_M8_E16, VWREDSUM_VS, 0x3, 0x10 }, // 10533 + { PseudoVWREDSUM_VS_M8_E16_MASK, VWREDSUM_VS, 0x3, 0x10 }, // 10534 + { PseudoVWREDSUM_VS_M8_E32, VWREDSUM_VS, 0x3, 0x20 }, // 10535 + { PseudoVWREDSUM_VS_M8_E32_MASK, VWREDSUM_VS, 0x3, 0x20 }, // 10536 + { PseudoVWREDSUM_VS_MF8_E8, VWREDSUM_VS, 0x5, 0x8 }, // 10537 + { PseudoVWREDSUM_VS_MF8_E8_MASK, VWREDSUM_VS, 0x5, 0x8 }, // 10538 + { PseudoVWREDSUM_VS_MF4_E8, VWREDSUM_VS, 0x6, 0x8 }, // 10539 + { PseudoVWREDSUM_VS_MF4_E8_MASK, VWREDSUM_VS, 0x6, 0x8 }, // 10540 + { PseudoVWREDSUM_VS_MF4_E16, VWREDSUM_VS, 0x6, 0x10 }, // 10541 + { PseudoVWREDSUM_VS_MF4_E16_MASK, VWREDSUM_VS, 0x6, 0x10 }, // 10542 + { PseudoVWREDSUM_VS_MF2_E8, VWREDSUM_VS, 0x7, 0x8 }, // 10543 + { PseudoVWREDSUM_VS_MF2_E8_MASK, VWREDSUM_VS, 0x7, 0x8 }, // 10544 + { PseudoVWREDSUM_VS_MF2_E16, VWREDSUM_VS, 0x7, 0x10 }, // 10545 + { PseudoVWREDSUM_VS_MF2_E16_MASK, VWREDSUM_VS, 0x7, 0x10 }, // 10546 + { PseudoVWREDSUM_VS_MF2_E32, VWREDSUM_VS, 0x7, 0x20 }, // 10547 + { PseudoVWREDSUM_VS_MF2_E32_MASK, VWREDSUM_VS, 0x7, 0x20 }, // 10548 + { PseudoVWSLL_VI_M1, VWSLL_VI, 0x0, 0x0 }, // 10549 + { PseudoVWSLL_VI_M1_MASK, VWSLL_VI, 0x0, 0x0 }, // 10550 + { PseudoVWSLL_VI_M2, VWSLL_VI, 0x1, 0x0 }, // 10551 + { PseudoVWSLL_VI_M2_MASK, VWSLL_VI, 0x1, 0x0 }, // 10552 + { PseudoVWSLL_VI_M4, VWSLL_VI, 0x2, 0x0 }, // 10553 + { PseudoVWSLL_VI_M4_MASK, VWSLL_VI, 0x2, 0x0 }, // 10554 + { PseudoVWSLL_VI_MF8, VWSLL_VI, 0x5, 0x0 }, // 10555 + { PseudoVWSLL_VI_MF8_MASK, VWSLL_VI, 0x5, 0x0 }, // 10556 + { PseudoVWSLL_VI_MF4, VWSLL_VI, 0x6, 0x0 }, // 10557 + { PseudoVWSLL_VI_MF4_MASK, VWSLL_VI, 0x6, 0x0 }, // 10558 + { PseudoVWSLL_VI_MF2, VWSLL_VI, 0x7, 0x0 }, // 10559 + { PseudoVWSLL_VI_MF2_MASK, VWSLL_VI, 0x7, 0x0 }, // 10560 + { PseudoVWSLL_VV_M1, VWSLL_VV, 0x0, 0x0 }, // 10561 + { PseudoVWSLL_VV_M1_MASK, VWSLL_VV, 0x0, 0x0 }, // 10562 + { PseudoVWSLL_VV_M2, VWSLL_VV, 0x1, 0x0 }, // 10563 + { PseudoVWSLL_VV_M2_MASK, VWSLL_VV, 0x1, 0x0 }, // 10564 + { PseudoVWSLL_VV_M4, VWSLL_VV, 0x2, 0x0 }, // 10565 + { PseudoVWSLL_VV_M4_MASK, VWSLL_VV, 0x2, 0x0 }, // 10566 + { PseudoVWSLL_VV_MF8, VWSLL_VV, 0x5, 0x0 }, // 10567 + { PseudoVWSLL_VV_MF8_MASK, VWSLL_VV, 0x5, 0x0 }, // 10568 + { PseudoVWSLL_VV_MF4, VWSLL_VV, 0x6, 0x0 }, // 10569 + { PseudoVWSLL_VV_MF4_MASK, VWSLL_VV, 0x6, 0x0 }, // 10570 + { PseudoVWSLL_VV_MF2, VWSLL_VV, 0x7, 0x0 }, // 10571 + { PseudoVWSLL_VV_MF2_MASK, VWSLL_VV, 0x7, 0x0 }, // 10572 + { PseudoVWSLL_VX_M1, VWSLL_VX, 0x0, 0x0 }, // 10573 + { PseudoVWSLL_VX_M1_MASK, VWSLL_VX, 0x0, 0x0 }, // 10574 + { PseudoVWSLL_VX_M2, VWSLL_VX, 0x1, 0x0 }, // 10575 + { PseudoVWSLL_VX_M2_MASK, VWSLL_VX, 0x1, 0x0 }, // 10576 + { PseudoVWSLL_VX_M4, VWSLL_VX, 0x2, 0x0 }, // 10577 + { PseudoVWSLL_VX_M4_MASK, VWSLL_VX, 0x2, 0x0 }, // 10578 + { PseudoVWSLL_VX_MF8, VWSLL_VX, 0x5, 0x0 }, // 10579 + { PseudoVWSLL_VX_MF8_MASK, VWSLL_VX, 0x5, 0x0 }, // 10580 + { PseudoVWSLL_VX_MF4, VWSLL_VX, 0x6, 0x0 }, // 10581 + { PseudoVWSLL_VX_MF4_MASK, VWSLL_VX, 0x6, 0x0 }, // 10582 + { PseudoVWSLL_VX_MF2, VWSLL_VX, 0x7, 0x0 }, // 10583 + { PseudoVWSLL_VX_MF2_MASK, VWSLL_VX, 0x7, 0x0 }, // 10584 + { PseudoVWSUBU_VV_M1, VWSUBU_VV, 0x0, 0x0 }, // 10585 + { PseudoVWSUBU_VV_M1_MASK, VWSUBU_VV, 0x0, 0x0 }, // 10586 + { PseudoVWSUBU_VV_M2, VWSUBU_VV, 0x1, 0x0 }, // 10587 + { PseudoVWSUBU_VV_M2_MASK, VWSUBU_VV, 0x1, 0x0 }, // 10588 + { PseudoVWSUBU_VV_M4, VWSUBU_VV, 0x2, 0x0 }, // 10589 + { PseudoVWSUBU_VV_M4_MASK, VWSUBU_VV, 0x2, 0x0 }, // 10590 + { PseudoVWSUBU_VV_MF8, VWSUBU_VV, 0x5, 0x0 }, // 10591 + { PseudoVWSUBU_VV_MF8_MASK, VWSUBU_VV, 0x5, 0x0 }, // 10592 + { PseudoVWSUBU_VV_MF4, VWSUBU_VV, 0x6, 0x0 }, // 10593 + { PseudoVWSUBU_VV_MF4_MASK, VWSUBU_VV, 0x6, 0x0 }, // 10594 + { PseudoVWSUBU_VV_MF2, VWSUBU_VV, 0x7, 0x0 }, // 10595 + { PseudoVWSUBU_VV_MF2_MASK, VWSUBU_VV, 0x7, 0x0 }, // 10596 + { PseudoVWSUBU_VX_M1, VWSUBU_VX, 0x0, 0x0 }, // 10597 + { PseudoVWSUBU_VX_M1_MASK, VWSUBU_VX, 0x0, 0x0 }, // 10598 + { PseudoVWSUBU_VX_M2, VWSUBU_VX, 0x1, 0x0 }, // 10599 + { PseudoVWSUBU_VX_M2_MASK, VWSUBU_VX, 0x1, 0x0 }, // 10600 + { PseudoVWSUBU_VX_M4, VWSUBU_VX, 0x2, 0x0 }, // 10601 + { PseudoVWSUBU_VX_M4_MASK, VWSUBU_VX, 0x2, 0x0 }, // 10602 + { PseudoVWSUBU_VX_MF8, VWSUBU_VX, 0x5, 0x0 }, // 10603 + { PseudoVWSUBU_VX_MF8_MASK, VWSUBU_VX, 0x5, 0x0 }, // 10604 + { PseudoVWSUBU_VX_MF4, VWSUBU_VX, 0x6, 0x0 }, // 10605 + { PseudoVWSUBU_VX_MF4_MASK, VWSUBU_VX, 0x6, 0x0 }, // 10606 + { PseudoVWSUBU_VX_MF2, VWSUBU_VX, 0x7, 0x0 }, // 10607 + { PseudoVWSUBU_VX_MF2_MASK, VWSUBU_VX, 0x7, 0x0 }, // 10608 + { PseudoVWSUBU_WV_M1, VWSUBU_WV, 0x0, 0x0 }, // 10609 + { PseudoVWSUBU_WV_M1_MASK, VWSUBU_WV, 0x0, 0x0 }, // 10610 + { PseudoVWSUBU_WV_M1_MASK_TIED, VWSUBU_WV, 0x0, 0x0 }, // 10611 + { PseudoVWSUBU_WV_M1_TIED, VWSUBU_WV, 0x0, 0x0 }, // 10612 + { PseudoVWSUBU_WV_M2, VWSUBU_WV, 0x1, 0x0 }, // 10613 + { PseudoVWSUBU_WV_M2_MASK, VWSUBU_WV, 0x1, 0x0 }, // 10614 + { PseudoVWSUBU_WV_M2_MASK_TIED, VWSUBU_WV, 0x1, 0x0 }, // 10615 + { PseudoVWSUBU_WV_M2_TIED, VWSUBU_WV, 0x1, 0x0 }, // 10616 + { PseudoVWSUBU_WV_M4, VWSUBU_WV, 0x2, 0x0 }, // 10617 + { PseudoVWSUBU_WV_M4_MASK, VWSUBU_WV, 0x2, 0x0 }, // 10618 + { PseudoVWSUBU_WV_M4_MASK_TIED, VWSUBU_WV, 0x2, 0x0 }, // 10619 + { PseudoVWSUBU_WV_M4_TIED, VWSUBU_WV, 0x2, 0x0 }, // 10620 + { PseudoVWSUBU_WV_MF8, VWSUBU_WV, 0x5, 0x0 }, // 10621 + { PseudoVWSUBU_WV_MF8_MASK, VWSUBU_WV, 0x5, 0x0 }, // 10622 + { PseudoVWSUBU_WV_MF8_MASK_TIED, VWSUBU_WV, 0x5, 0x0 }, // 10623 + { PseudoVWSUBU_WV_MF8_TIED, VWSUBU_WV, 0x5, 0x0 }, // 10624 + { PseudoVWSUBU_WV_MF4, VWSUBU_WV, 0x6, 0x0 }, // 10625 + { PseudoVWSUBU_WV_MF4_MASK, VWSUBU_WV, 0x6, 0x0 }, // 10626 + { PseudoVWSUBU_WV_MF4_MASK_TIED, VWSUBU_WV, 0x6, 0x0 }, // 10627 + { PseudoVWSUBU_WV_MF4_TIED, VWSUBU_WV, 0x6, 0x0 }, // 10628 + { PseudoVWSUBU_WV_MF2, VWSUBU_WV, 0x7, 0x0 }, // 10629 + { PseudoVWSUBU_WV_MF2_MASK, VWSUBU_WV, 0x7, 0x0 }, // 10630 + { PseudoVWSUBU_WV_MF2_MASK_TIED, VWSUBU_WV, 0x7, 0x0 }, // 10631 + { PseudoVWSUBU_WV_MF2_TIED, VWSUBU_WV, 0x7, 0x0 }, // 10632 + { PseudoVWSUBU_WX_M1, VWSUBU_WX, 0x0, 0x0 }, // 10633 + { PseudoVWSUBU_WX_M1_MASK, VWSUBU_WX, 0x0, 0x0 }, // 10634 + { PseudoVWSUBU_WX_M2, VWSUBU_WX, 0x1, 0x0 }, // 10635 + { PseudoVWSUBU_WX_M2_MASK, VWSUBU_WX, 0x1, 0x0 }, // 10636 + { PseudoVWSUBU_WX_M4, VWSUBU_WX, 0x2, 0x0 }, // 10637 + { PseudoVWSUBU_WX_M4_MASK, VWSUBU_WX, 0x2, 0x0 }, // 10638 + { PseudoVWSUBU_WX_MF8, VWSUBU_WX, 0x5, 0x0 }, // 10639 + { PseudoVWSUBU_WX_MF8_MASK, VWSUBU_WX, 0x5, 0x0 }, // 10640 + { PseudoVWSUBU_WX_MF4, VWSUBU_WX, 0x6, 0x0 }, // 10641 + { PseudoVWSUBU_WX_MF4_MASK, VWSUBU_WX, 0x6, 0x0 }, // 10642 + { PseudoVWSUBU_WX_MF2, VWSUBU_WX, 0x7, 0x0 }, // 10643 + { PseudoVWSUBU_WX_MF2_MASK, VWSUBU_WX, 0x7, 0x0 }, // 10644 + { PseudoVWSUB_VV_M1, VWSUB_VV, 0x0, 0x0 }, // 10645 + { PseudoVWSUB_VV_M1_MASK, VWSUB_VV, 0x0, 0x0 }, // 10646 + { PseudoVWSUB_VV_M2, VWSUB_VV, 0x1, 0x0 }, // 10647 + { PseudoVWSUB_VV_M2_MASK, VWSUB_VV, 0x1, 0x0 }, // 10648 + { PseudoVWSUB_VV_M4, VWSUB_VV, 0x2, 0x0 }, // 10649 + { PseudoVWSUB_VV_M4_MASK, VWSUB_VV, 0x2, 0x0 }, // 10650 + { PseudoVWSUB_VV_MF8, VWSUB_VV, 0x5, 0x0 }, // 10651 + { PseudoVWSUB_VV_MF8_MASK, VWSUB_VV, 0x5, 0x0 }, // 10652 + { PseudoVWSUB_VV_MF4, VWSUB_VV, 0x6, 0x0 }, // 10653 + { PseudoVWSUB_VV_MF4_MASK, VWSUB_VV, 0x6, 0x0 }, // 10654 + { PseudoVWSUB_VV_MF2, VWSUB_VV, 0x7, 0x0 }, // 10655 + { PseudoVWSUB_VV_MF2_MASK, VWSUB_VV, 0x7, 0x0 }, // 10656 + { PseudoVWSUB_VX_M1, VWSUB_VX, 0x0, 0x0 }, // 10657 + { PseudoVWSUB_VX_M1_MASK, VWSUB_VX, 0x0, 0x0 }, // 10658 + { PseudoVWSUB_VX_M2, VWSUB_VX, 0x1, 0x0 }, // 10659 + { PseudoVWSUB_VX_M2_MASK, VWSUB_VX, 0x1, 0x0 }, // 10660 + { PseudoVWSUB_VX_M4, VWSUB_VX, 0x2, 0x0 }, // 10661 + { PseudoVWSUB_VX_M4_MASK, VWSUB_VX, 0x2, 0x0 }, // 10662 + { PseudoVWSUB_VX_MF8, VWSUB_VX, 0x5, 0x0 }, // 10663 + { PseudoVWSUB_VX_MF8_MASK, VWSUB_VX, 0x5, 0x0 }, // 10664 + { PseudoVWSUB_VX_MF4, VWSUB_VX, 0x6, 0x0 }, // 10665 + { PseudoVWSUB_VX_MF4_MASK, VWSUB_VX, 0x6, 0x0 }, // 10666 + { PseudoVWSUB_VX_MF2, VWSUB_VX, 0x7, 0x0 }, // 10667 + { PseudoVWSUB_VX_MF2_MASK, VWSUB_VX, 0x7, 0x0 }, // 10668 + { PseudoVWSUB_WV_M1, VWSUB_WV, 0x0, 0x0 }, // 10669 + { PseudoVWSUB_WV_M1_MASK, VWSUB_WV, 0x0, 0x0 }, // 10670 + { PseudoVWSUB_WV_M1_MASK_TIED, VWSUB_WV, 0x0, 0x0 }, // 10671 + { PseudoVWSUB_WV_M1_TIED, VWSUB_WV, 0x0, 0x0 }, // 10672 + { PseudoVWSUB_WV_M2, VWSUB_WV, 0x1, 0x0 }, // 10673 + { PseudoVWSUB_WV_M2_MASK, VWSUB_WV, 0x1, 0x0 }, // 10674 + { PseudoVWSUB_WV_M2_MASK_TIED, VWSUB_WV, 0x1, 0x0 }, // 10675 + { PseudoVWSUB_WV_M2_TIED, VWSUB_WV, 0x1, 0x0 }, // 10676 + { PseudoVWSUB_WV_M4, VWSUB_WV, 0x2, 0x0 }, // 10677 + { PseudoVWSUB_WV_M4_MASK, VWSUB_WV, 0x2, 0x0 }, // 10678 + { PseudoVWSUB_WV_M4_MASK_TIED, VWSUB_WV, 0x2, 0x0 }, // 10679 + { PseudoVWSUB_WV_M4_TIED, VWSUB_WV, 0x2, 0x0 }, // 10680 + { PseudoVWSUB_WV_MF8, VWSUB_WV, 0x5, 0x0 }, // 10681 + { PseudoVWSUB_WV_MF8_MASK, VWSUB_WV, 0x5, 0x0 }, // 10682 + { PseudoVWSUB_WV_MF8_MASK_TIED, VWSUB_WV, 0x5, 0x0 }, // 10683 + { PseudoVWSUB_WV_MF8_TIED, VWSUB_WV, 0x5, 0x0 }, // 10684 + { PseudoVWSUB_WV_MF4, VWSUB_WV, 0x6, 0x0 }, // 10685 + { PseudoVWSUB_WV_MF4_MASK, VWSUB_WV, 0x6, 0x0 }, // 10686 + { PseudoVWSUB_WV_MF4_MASK_TIED, VWSUB_WV, 0x6, 0x0 }, // 10687 + { PseudoVWSUB_WV_MF4_TIED, VWSUB_WV, 0x6, 0x0 }, // 10688 + { PseudoVWSUB_WV_MF2, VWSUB_WV, 0x7, 0x0 }, // 10689 + { PseudoVWSUB_WV_MF2_MASK, VWSUB_WV, 0x7, 0x0 }, // 10690 + { PseudoVWSUB_WV_MF2_MASK_TIED, VWSUB_WV, 0x7, 0x0 }, // 10691 + { PseudoVWSUB_WV_MF2_TIED, VWSUB_WV, 0x7, 0x0 }, // 10692 + { PseudoVWSUB_WX_M1, VWSUB_WX, 0x0, 0x0 }, // 10693 + { PseudoVWSUB_WX_M1_MASK, VWSUB_WX, 0x0, 0x0 }, // 10694 + { PseudoVWSUB_WX_M2, VWSUB_WX, 0x1, 0x0 }, // 10695 + { PseudoVWSUB_WX_M2_MASK, VWSUB_WX, 0x1, 0x0 }, // 10696 + { PseudoVWSUB_WX_M4, VWSUB_WX, 0x2, 0x0 }, // 10697 + { PseudoVWSUB_WX_M4_MASK, VWSUB_WX, 0x2, 0x0 }, // 10698 + { PseudoVWSUB_WX_MF8, VWSUB_WX, 0x5, 0x0 }, // 10699 + { PseudoVWSUB_WX_MF8_MASK, VWSUB_WX, 0x5, 0x0 }, // 10700 + { PseudoVWSUB_WX_MF4, VWSUB_WX, 0x6, 0x0 }, // 10701 + { PseudoVWSUB_WX_MF4_MASK, VWSUB_WX, 0x6, 0x0 }, // 10702 + { PseudoVWSUB_WX_MF2, VWSUB_WX, 0x7, 0x0 }, // 10703 + { PseudoVWSUB_WX_MF2_MASK, VWSUB_WX, 0x7, 0x0 }, // 10704 + { PseudoVXOR_VI_M1, VXOR_VI, 0x0, 0x0 }, // 10705 + { PseudoVXOR_VI_M1_MASK, VXOR_VI, 0x0, 0x0 }, // 10706 + { PseudoVXOR_VI_M2, VXOR_VI, 0x1, 0x0 }, // 10707 + { PseudoVXOR_VI_M2_MASK, VXOR_VI, 0x1, 0x0 }, // 10708 + { PseudoVXOR_VI_M4, VXOR_VI, 0x2, 0x0 }, // 10709 + { PseudoVXOR_VI_M4_MASK, VXOR_VI, 0x2, 0x0 }, // 10710 + { PseudoVXOR_VI_M8, VXOR_VI, 0x3, 0x0 }, // 10711 + { PseudoVXOR_VI_M8_MASK, VXOR_VI, 0x3, 0x0 }, // 10712 + { PseudoVXOR_VI_MF8, VXOR_VI, 0x5, 0x0 }, // 10713 + { PseudoVXOR_VI_MF8_MASK, VXOR_VI, 0x5, 0x0 }, // 10714 + { PseudoVXOR_VI_MF4, VXOR_VI, 0x6, 0x0 }, // 10715 + { PseudoVXOR_VI_MF4_MASK, VXOR_VI, 0x6, 0x0 }, // 10716 + { PseudoVXOR_VI_MF2, VXOR_VI, 0x7, 0x0 }, // 10717 + { PseudoVXOR_VI_MF2_MASK, VXOR_VI, 0x7, 0x0 }, // 10718 + { PseudoVXOR_VV_M1, VXOR_VV, 0x0, 0x0 }, // 10719 + { PseudoVXOR_VV_M1_MASK, VXOR_VV, 0x0, 0x0 }, // 10720 + { PseudoVXOR_VV_M2, VXOR_VV, 0x1, 0x0 }, // 10721 + { PseudoVXOR_VV_M2_MASK, VXOR_VV, 0x1, 0x0 }, // 10722 + { PseudoVXOR_VV_M4, VXOR_VV, 0x2, 0x0 }, // 10723 + { PseudoVXOR_VV_M4_MASK, VXOR_VV, 0x2, 0x0 }, // 10724 + { PseudoVXOR_VV_M8, VXOR_VV, 0x3, 0x0 }, // 10725 + { PseudoVXOR_VV_M8_MASK, VXOR_VV, 0x3, 0x0 }, // 10726 + { PseudoVXOR_VV_MF8, VXOR_VV, 0x5, 0x0 }, // 10727 + { PseudoVXOR_VV_MF8_MASK, VXOR_VV, 0x5, 0x0 }, // 10728 + { PseudoVXOR_VV_MF4, VXOR_VV, 0x6, 0x0 }, // 10729 + { PseudoVXOR_VV_MF4_MASK, VXOR_VV, 0x6, 0x0 }, // 10730 + { PseudoVXOR_VV_MF2, VXOR_VV, 0x7, 0x0 }, // 10731 + { PseudoVXOR_VV_MF2_MASK, VXOR_VV, 0x7, 0x0 }, // 10732 + { PseudoVXOR_VX_M1, VXOR_VX, 0x0, 0x0 }, // 10733 + { PseudoVXOR_VX_M1_MASK, VXOR_VX, 0x0, 0x0 }, // 10734 + { PseudoVXOR_VX_M2, VXOR_VX, 0x1, 0x0 }, // 10735 + { PseudoVXOR_VX_M2_MASK, VXOR_VX, 0x1, 0x0 }, // 10736 + { PseudoVXOR_VX_M4, VXOR_VX, 0x2, 0x0 }, // 10737 + { PseudoVXOR_VX_M4_MASK, VXOR_VX, 0x2, 0x0 }, // 10738 + { PseudoVXOR_VX_M8, VXOR_VX, 0x3, 0x0 }, // 10739 + { PseudoVXOR_VX_M8_MASK, VXOR_VX, 0x3, 0x0 }, // 10740 + { PseudoVXOR_VX_MF8, VXOR_VX, 0x5, 0x0 }, // 10741 + { PseudoVXOR_VX_MF8_MASK, VXOR_VX, 0x5, 0x0 }, // 10742 + { PseudoVXOR_VX_MF4, VXOR_VX, 0x6, 0x0 }, // 10743 + { PseudoVXOR_VX_MF4_MASK, VXOR_VX, 0x6, 0x0 }, // 10744 + { PseudoVXOR_VX_MF2, VXOR_VX, 0x7, 0x0 }, // 10745 + { PseudoVXOR_VX_MF2_MASK, VXOR_VX, 0x7, 0x0 }, // 10746 + { PseudoVZEXT_VF2_M1, VZEXT_VF2, 0x0, 0x0 }, // 10747 + { PseudoVZEXT_VF2_M1_MASK, VZEXT_VF2, 0x0, 0x0 }, // 10748 + { PseudoVZEXT_VF2_M2, VZEXT_VF2, 0x1, 0x0 }, // 10749 + { PseudoVZEXT_VF2_M2_MASK, VZEXT_VF2, 0x1, 0x0 }, // 10750 + { PseudoVZEXT_VF2_M4, VZEXT_VF2, 0x2, 0x0 }, // 10751 + { PseudoVZEXT_VF2_M4_MASK, VZEXT_VF2, 0x2, 0x0 }, // 10752 + { PseudoVZEXT_VF2_M8, VZEXT_VF2, 0x3, 0x0 }, // 10753 + { PseudoVZEXT_VF2_M8_MASK, VZEXT_VF2, 0x3, 0x0 }, // 10754 + { PseudoVZEXT_VF2_MF4, VZEXT_VF2, 0x6, 0x0 }, // 10755 + { PseudoVZEXT_VF2_MF4_MASK, VZEXT_VF2, 0x6, 0x0 }, // 10756 + { PseudoVZEXT_VF2_MF2, VZEXT_VF2, 0x7, 0x0 }, // 10757 + { PseudoVZEXT_VF2_MF2_MASK, VZEXT_VF2, 0x7, 0x0 }, // 10758 + { PseudoVZEXT_VF4_M1, VZEXT_VF4, 0x0, 0x0 }, // 10759 + { PseudoVZEXT_VF4_M1_MASK, VZEXT_VF4, 0x0, 0x0 }, // 10760 + { PseudoVZEXT_VF4_M2, VZEXT_VF4, 0x1, 0x0 }, // 10761 + { PseudoVZEXT_VF4_M2_MASK, VZEXT_VF4, 0x1, 0x0 }, // 10762 + { PseudoVZEXT_VF4_M4, VZEXT_VF4, 0x2, 0x0 }, // 10763 + { PseudoVZEXT_VF4_M4_MASK, VZEXT_VF4, 0x2, 0x0 }, // 10764 + { PseudoVZEXT_VF4_M8, VZEXT_VF4, 0x3, 0x0 }, // 10765 + { PseudoVZEXT_VF4_M8_MASK, VZEXT_VF4, 0x3, 0x0 }, // 10766 + { PseudoVZEXT_VF4_MF2, VZEXT_VF4, 0x7, 0x0 }, // 10767 + { PseudoVZEXT_VF4_MF2_MASK, VZEXT_VF4, 0x7, 0x0 }, // 10768 + { PseudoVZEXT_VF8_M1, VZEXT_VF8, 0x0, 0x0 }, // 10769 + { PseudoVZEXT_VF8_M1_MASK, VZEXT_VF8, 0x0, 0x0 }, // 10770 + { PseudoVZEXT_VF8_M2, VZEXT_VF8, 0x1, 0x0 }, // 10771 + { PseudoVZEXT_VF8_M2_MASK, VZEXT_VF8, 0x1, 0x0 }, // 10772 + { PseudoVZEXT_VF8_M4, VZEXT_VF8, 0x2, 0x0 }, // 10773 + { PseudoVZEXT_VF8_M4_MASK, VZEXT_VF8, 0x2, 0x0 }, // 10774 + { PseudoVZEXT_VF8_M8, VZEXT_VF8, 0x3, 0x0 }, // 10775 + { PseudoVZEXT_VF8_M8_MASK, VZEXT_VF8, 0x3, 0x0 }, // 10776 + }; + +const RISCV_PseudoInfo *RISCV_getBaseInfo(unsigned BaseInstr, uint8_t VLMul, uint8_t SEW) { + unsigned i = binsearch_IndexTypeEncoding(Index, ARR_SIZE(Index), BaseInstrVLMulSEW); + if (i == -1) + return NULL; + else + return &RISCVVInversePseudosTable[Index[i].index]; +} + +#endif + +#ifdef GET_RISCVVLETable_IMPL +static const RISCV_VLEPseudo RISCVVLETable[] = { + { 0x0, 0x0, 0x0, 0x0, 0x0, PseudoVLM_V_B8 }, // 0 + { 0x0, 0x0, 0x0, 0x0, 0x1, PseudoVLM_V_B16 }, // 1 + { 0x0, 0x0, 0x0, 0x0, 0x2, PseudoVLM_V_B32 }, // 2 + { 0x0, 0x0, 0x0, 0x0, 0x3, PseudoVLM_V_B64 }, // 3 + { 0x0, 0x0, 0x0, 0x0, 0x5, PseudoVLM_V_B1 }, // 4 + { 0x0, 0x0, 0x0, 0x0, 0x6, PseudoVLM_V_B2 }, // 5 + { 0x0, 0x0, 0x0, 0x0, 0x7, PseudoVLM_V_B4 }, // 6 + { 0x0, 0x0, 0x0, 0x3, 0x0, PseudoVLE8_V_M1 }, // 7 + { 0x0, 0x0, 0x0, 0x3, 0x1, PseudoVLE8_V_M2 }, // 8 + { 0x0, 0x0, 0x0, 0x3, 0x2, PseudoVLE8_V_M4 }, // 9 + { 0x0, 0x0, 0x0, 0x3, 0x3, PseudoVLE8_V_M8 }, // 10 + { 0x0, 0x0, 0x0, 0x3, 0x5, PseudoVLE8_V_MF8 }, // 11 + { 0x0, 0x0, 0x0, 0x3, 0x6, PseudoVLE8_V_MF4 }, // 12 + { 0x0, 0x0, 0x0, 0x3, 0x7, PseudoVLE8_V_MF2 }, // 13 + { 0x0, 0x0, 0x0, 0x4, 0x0, PseudoVLE16_V_M1 }, // 14 + { 0x0, 0x0, 0x0, 0x4, 0x1, PseudoVLE16_V_M2 }, // 15 + { 0x0, 0x0, 0x0, 0x4, 0x2, PseudoVLE16_V_M4 }, // 16 + { 0x0, 0x0, 0x0, 0x4, 0x3, PseudoVLE16_V_M8 }, // 17 + { 0x0, 0x0, 0x0, 0x4, 0x6, PseudoVLE16_V_MF4 }, // 18 + { 0x0, 0x0, 0x0, 0x4, 0x7, PseudoVLE16_V_MF2 }, // 19 + { 0x0, 0x0, 0x0, 0x5, 0x0, PseudoVLE32_V_M1 }, // 20 + { 0x0, 0x0, 0x0, 0x5, 0x1, PseudoVLE32_V_M2 }, // 21 + { 0x0, 0x0, 0x0, 0x5, 0x2, PseudoVLE32_V_M4 }, // 22 + { 0x0, 0x0, 0x0, 0x5, 0x3, PseudoVLE32_V_M8 }, // 23 + { 0x0, 0x0, 0x0, 0x5, 0x7, PseudoVLE32_V_MF2 }, // 24 + { 0x0, 0x0, 0x0, 0x6, 0x0, PseudoVLE64_V_M1 }, // 25 + { 0x0, 0x0, 0x0, 0x6, 0x1, PseudoVLE64_V_M2 }, // 26 + { 0x0, 0x0, 0x0, 0x6, 0x2, PseudoVLE64_V_M4 }, // 27 + { 0x0, 0x0, 0x0, 0x6, 0x3, PseudoVLE64_V_M8 }, // 28 + { 0x0, 0x0, 0x1, 0x3, 0x0, PseudoVLE8FF_V_M1 }, // 29 + { 0x0, 0x0, 0x1, 0x3, 0x1, PseudoVLE8FF_V_M2 }, // 30 + { 0x0, 0x0, 0x1, 0x3, 0x2, PseudoVLE8FF_V_M4 }, // 31 + { 0x0, 0x0, 0x1, 0x3, 0x3, PseudoVLE8FF_V_M8 }, // 32 + { 0x0, 0x0, 0x1, 0x3, 0x5, PseudoVLE8FF_V_MF8 }, // 33 + { 0x0, 0x0, 0x1, 0x3, 0x6, PseudoVLE8FF_V_MF4 }, // 34 + { 0x0, 0x0, 0x1, 0x3, 0x7, PseudoVLE8FF_V_MF2 }, // 35 + { 0x0, 0x0, 0x1, 0x4, 0x0, PseudoVLE16FF_V_M1 }, // 36 + { 0x0, 0x0, 0x1, 0x4, 0x1, PseudoVLE16FF_V_M2 }, // 37 + { 0x0, 0x0, 0x1, 0x4, 0x2, PseudoVLE16FF_V_M4 }, // 38 + { 0x0, 0x0, 0x1, 0x4, 0x3, PseudoVLE16FF_V_M8 }, // 39 + { 0x0, 0x0, 0x1, 0x4, 0x6, PseudoVLE16FF_V_MF4 }, // 40 + { 0x0, 0x0, 0x1, 0x4, 0x7, PseudoVLE16FF_V_MF2 }, // 41 + { 0x0, 0x0, 0x1, 0x5, 0x0, PseudoVLE32FF_V_M1 }, // 42 + { 0x0, 0x0, 0x1, 0x5, 0x1, PseudoVLE32FF_V_M2 }, // 43 + { 0x0, 0x0, 0x1, 0x5, 0x2, PseudoVLE32FF_V_M4 }, // 44 + { 0x0, 0x0, 0x1, 0x5, 0x3, PseudoVLE32FF_V_M8 }, // 45 + { 0x0, 0x0, 0x1, 0x5, 0x7, PseudoVLE32FF_V_MF2 }, // 46 + { 0x0, 0x0, 0x1, 0x6, 0x0, PseudoVLE64FF_V_M1 }, // 47 + { 0x0, 0x0, 0x1, 0x6, 0x1, PseudoVLE64FF_V_M2 }, // 48 + { 0x0, 0x0, 0x1, 0x6, 0x2, PseudoVLE64FF_V_M4 }, // 49 + { 0x0, 0x0, 0x1, 0x6, 0x3, PseudoVLE64FF_V_M8 }, // 50 + { 0x0, 0x1, 0x0, 0x3, 0x0, PseudoVLSE8_V_M1 }, // 51 + { 0x0, 0x1, 0x0, 0x3, 0x1, PseudoVLSE8_V_M2 }, // 52 + { 0x0, 0x1, 0x0, 0x3, 0x2, PseudoVLSE8_V_M4 }, // 53 + { 0x0, 0x1, 0x0, 0x3, 0x3, PseudoVLSE8_V_M8 }, // 54 + { 0x0, 0x1, 0x0, 0x3, 0x5, PseudoVLSE8_V_MF8 }, // 55 + { 0x0, 0x1, 0x0, 0x3, 0x6, PseudoVLSE8_V_MF4 }, // 56 + { 0x0, 0x1, 0x0, 0x3, 0x7, PseudoVLSE8_V_MF2 }, // 57 + { 0x0, 0x1, 0x0, 0x4, 0x0, PseudoVLSE16_V_M1 }, // 58 + { 0x0, 0x1, 0x0, 0x4, 0x1, PseudoVLSE16_V_M2 }, // 59 + { 0x0, 0x1, 0x0, 0x4, 0x2, PseudoVLSE16_V_M4 }, // 60 + { 0x0, 0x1, 0x0, 0x4, 0x3, PseudoVLSE16_V_M8 }, // 61 + { 0x0, 0x1, 0x0, 0x4, 0x6, PseudoVLSE16_V_MF4 }, // 62 + { 0x0, 0x1, 0x0, 0x4, 0x7, PseudoVLSE16_V_MF2 }, // 63 + { 0x0, 0x1, 0x0, 0x5, 0x0, PseudoVLSE32_V_M1 }, // 64 + { 0x0, 0x1, 0x0, 0x5, 0x1, PseudoVLSE32_V_M2 }, // 65 + { 0x0, 0x1, 0x0, 0x5, 0x2, PseudoVLSE32_V_M4 }, // 66 + { 0x0, 0x1, 0x0, 0x5, 0x3, PseudoVLSE32_V_M8 }, // 67 + { 0x0, 0x1, 0x0, 0x5, 0x7, PseudoVLSE32_V_MF2 }, // 68 + { 0x0, 0x1, 0x0, 0x6, 0x0, PseudoVLSE64_V_M1 }, // 69 + { 0x0, 0x1, 0x0, 0x6, 0x1, PseudoVLSE64_V_M2 }, // 70 + { 0x0, 0x1, 0x0, 0x6, 0x2, PseudoVLSE64_V_M4 }, // 71 + { 0x0, 0x1, 0x0, 0x6, 0x3, PseudoVLSE64_V_M8 }, // 72 + { 0x1, 0x0, 0x0, 0x3, 0x0, PseudoVLE8_V_M1_MASK }, // 73 + { 0x1, 0x0, 0x0, 0x3, 0x1, PseudoVLE8_V_M2_MASK }, // 74 + { 0x1, 0x0, 0x0, 0x3, 0x2, PseudoVLE8_V_M4_MASK }, // 75 + { 0x1, 0x0, 0x0, 0x3, 0x3, PseudoVLE8_V_M8_MASK }, // 76 + { 0x1, 0x0, 0x0, 0x3, 0x5, PseudoVLE8_V_MF8_MASK }, // 77 + { 0x1, 0x0, 0x0, 0x3, 0x6, PseudoVLE8_V_MF4_MASK }, // 78 + { 0x1, 0x0, 0x0, 0x3, 0x7, PseudoVLE8_V_MF2_MASK }, // 79 + { 0x1, 0x0, 0x0, 0x4, 0x0, PseudoVLE16_V_M1_MASK }, // 80 + { 0x1, 0x0, 0x0, 0x4, 0x1, PseudoVLE16_V_M2_MASK }, // 81 + { 0x1, 0x0, 0x0, 0x4, 0x2, PseudoVLE16_V_M4_MASK }, // 82 + { 0x1, 0x0, 0x0, 0x4, 0x3, PseudoVLE16_V_M8_MASK }, // 83 + { 0x1, 0x0, 0x0, 0x4, 0x6, PseudoVLE16_V_MF4_MASK }, // 84 + { 0x1, 0x0, 0x0, 0x4, 0x7, PseudoVLE16_V_MF2_MASK }, // 85 + { 0x1, 0x0, 0x0, 0x5, 0x0, PseudoVLE32_V_M1_MASK }, // 86 + { 0x1, 0x0, 0x0, 0x5, 0x1, PseudoVLE32_V_M2_MASK }, // 87 + { 0x1, 0x0, 0x0, 0x5, 0x2, PseudoVLE32_V_M4_MASK }, // 88 + { 0x1, 0x0, 0x0, 0x5, 0x3, PseudoVLE32_V_M8_MASK }, // 89 + { 0x1, 0x0, 0x0, 0x5, 0x7, PseudoVLE32_V_MF2_MASK }, // 90 + { 0x1, 0x0, 0x0, 0x6, 0x0, PseudoVLE64_V_M1_MASK }, // 91 + { 0x1, 0x0, 0x0, 0x6, 0x1, PseudoVLE64_V_M2_MASK }, // 92 + { 0x1, 0x0, 0x0, 0x6, 0x2, PseudoVLE64_V_M4_MASK }, // 93 + { 0x1, 0x0, 0x0, 0x6, 0x3, PseudoVLE64_V_M8_MASK }, // 94 + { 0x1, 0x0, 0x1, 0x3, 0x0, PseudoVLE8FF_V_M1_MASK }, // 95 + { 0x1, 0x0, 0x1, 0x3, 0x1, PseudoVLE8FF_V_M2_MASK }, // 96 + { 0x1, 0x0, 0x1, 0x3, 0x2, PseudoVLE8FF_V_M4_MASK }, // 97 + { 0x1, 0x0, 0x1, 0x3, 0x3, PseudoVLE8FF_V_M8_MASK }, // 98 + { 0x1, 0x0, 0x1, 0x3, 0x5, PseudoVLE8FF_V_MF8_MASK }, // 99 + { 0x1, 0x0, 0x1, 0x3, 0x6, PseudoVLE8FF_V_MF4_MASK }, // 100 + { 0x1, 0x0, 0x1, 0x3, 0x7, PseudoVLE8FF_V_MF2_MASK }, // 101 + { 0x1, 0x0, 0x1, 0x4, 0x0, PseudoVLE16FF_V_M1_MASK }, // 102 + { 0x1, 0x0, 0x1, 0x4, 0x1, PseudoVLE16FF_V_M2_MASK }, // 103 + { 0x1, 0x0, 0x1, 0x4, 0x2, PseudoVLE16FF_V_M4_MASK }, // 104 + { 0x1, 0x0, 0x1, 0x4, 0x3, PseudoVLE16FF_V_M8_MASK }, // 105 + { 0x1, 0x0, 0x1, 0x4, 0x6, PseudoVLE16FF_V_MF4_MASK }, // 106 + { 0x1, 0x0, 0x1, 0x4, 0x7, PseudoVLE16FF_V_MF2_MASK }, // 107 + { 0x1, 0x0, 0x1, 0x5, 0x0, PseudoVLE32FF_V_M1_MASK }, // 108 + { 0x1, 0x0, 0x1, 0x5, 0x1, PseudoVLE32FF_V_M2_MASK }, // 109 + { 0x1, 0x0, 0x1, 0x5, 0x2, PseudoVLE32FF_V_M4_MASK }, // 110 + { 0x1, 0x0, 0x1, 0x5, 0x3, PseudoVLE32FF_V_M8_MASK }, // 111 + { 0x1, 0x0, 0x1, 0x5, 0x7, PseudoVLE32FF_V_MF2_MASK }, // 112 + { 0x1, 0x0, 0x1, 0x6, 0x0, PseudoVLE64FF_V_M1_MASK }, // 113 + { 0x1, 0x0, 0x1, 0x6, 0x1, PseudoVLE64FF_V_M2_MASK }, // 114 + { 0x1, 0x0, 0x1, 0x6, 0x2, PseudoVLE64FF_V_M4_MASK }, // 115 + { 0x1, 0x0, 0x1, 0x6, 0x3, PseudoVLE64FF_V_M8_MASK }, // 116 + { 0x1, 0x1, 0x0, 0x3, 0x0, PseudoVLSE8_V_M1_MASK }, // 117 + { 0x1, 0x1, 0x0, 0x3, 0x1, PseudoVLSE8_V_M2_MASK }, // 118 + { 0x1, 0x1, 0x0, 0x3, 0x2, PseudoVLSE8_V_M4_MASK }, // 119 + { 0x1, 0x1, 0x0, 0x3, 0x3, PseudoVLSE8_V_M8_MASK }, // 120 + { 0x1, 0x1, 0x0, 0x3, 0x5, PseudoVLSE8_V_MF8_MASK }, // 121 + { 0x1, 0x1, 0x0, 0x3, 0x6, PseudoVLSE8_V_MF4_MASK }, // 122 + { 0x1, 0x1, 0x0, 0x3, 0x7, PseudoVLSE8_V_MF2_MASK }, // 123 + { 0x1, 0x1, 0x0, 0x4, 0x0, PseudoVLSE16_V_M1_MASK }, // 124 + { 0x1, 0x1, 0x0, 0x4, 0x1, PseudoVLSE16_V_M2_MASK }, // 125 + { 0x1, 0x1, 0x0, 0x4, 0x2, PseudoVLSE16_V_M4_MASK }, // 126 + { 0x1, 0x1, 0x0, 0x4, 0x3, PseudoVLSE16_V_M8_MASK }, // 127 + { 0x1, 0x1, 0x0, 0x4, 0x6, PseudoVLSE16_V_MF4_MASK }, // 128 + { 0x1, 0x1, 0x0, 0x4, 0x7, PseudoVLSE16_V_MF2_MASK }, // 129 + { 0x1, 0x1, 0x0, 0x5, 0x0, PseudoVLSE32_V_M1_MASK }, // 130 + { 0x1, 0x1, 0x0, 0x5, 0x1, PseudoVLSE32_V_M2_MASK }, // 131 + { 0x1, 0x1, 0x0, 0x5, 0x2, PseudoVLSE32_V_M4_MASK }, // 132 + { 0x1, 0x1, 0x0, 0x5, 0x3, PseudoVLSE32_V_M8_MASK }, // 133 + { 0x1, 0x1, 0x0, 0x5, 0x7, PseudoVLSE32_V_MF2_MASK }, // 134 + { 0x1, 0x1, 0x0, 0x6, 0x0, PseudoVLSE64_V_M1_MASK }, // 135 + { 0x1, 0x1, 0x0, 0x6, 0x1, PseudoVLSE64_V_M2_MASK }, // 136 + { 0x1, 0x1, 0x0, 0x6, 0x2, PseudoVLSE64_V_M4_MASK }, // 137 + { 0x1, 0x1, 0x0, 0x6, 0x3, PseudoVLSE64_V_M8_MASK }, // 138 + }; + +const RISCV_VLEPseudo *RISCV_getVLEPseudo(uint8_t Masked, uint8_t Strided, uint8_t FF, uint8_t Log2SEW, uint8_t LMUL) { + unsigned i = binsearch_IndexTypeEncoding(Index, ARR_SIZE(Index), MaskedStridedFFLog2SEWLMUL); + if (i == -1) + return NULL; + else + return &RISCVVLETable[Index[i].index]; +} + +#endif + +#ifdef GET_RISCVVLSEGTable_IMPL +static const RISCV_VLSEGPseudo RISCVVLSEGTable[] = { + { 0x2, 0x0, 0x0, 0x0, 0x3, 0x0, PseudoVLSEG2E8_V_M1 }, // 0 + { 0x2, 0x0, 0x0, 0x0, 0x3, 0x1, PseudoVLSEG2E8_V_M2 }, // 1 + { 0x2, 0x0, 0x0, 0x0, 0x3, 0x2, PseudoVLSEG2E8_V_M4 }, // 2 + { 0x2, 0x0, 0x0, 0x0, 0x3, 0x5, PseudoVLSEG2E8_V_MF8 }, // 3 + { 0x2, 0x0, 0x0, 0x0, 0x3, 0x6, PseudoVLSEG2E8_V_MF4 }, // 4 + { 0x2, 0x0, 0x0, 0x0, 0x3, 0x7, PseudoVLSEG2E8_V_MF2 }, // 5 + { 0x2, 0x0, 0x0, 0x0, 0x4, 0x0, PseudoVLSEG2E16_V_M1 }, // 6 + { 0x2, 0x0, 0x0, 0x0, 0x4, 0x1, PseudoVLSEG2E16_V_M2 }, // 7 + { 0x2, 0x0, 0x0, 0x0, 0x4, 0x2, PseudoVLSEG2E16_V_M4 }, // 8 + { 0x2, 0x0, 0x0, 0x0, 0x4, 0x6, PseudoVLSEG2E16_V_MF4 }, // 9 + { 0x2, 0x0, 0x0, 0x0, 0x4, 0x7, PseudoVLSEG2E16_V_MF2 }, // 10 + { 0x2, 0x0, 0x0, 0x0, 0x5, 0x0, PseudoVLSEG2E32_V_M1 }, // 11 + { 0x2, 0x0, 0x0, 0x0, 0x5, 0x1, PseudoVLSEG2E32_V_M2 }, // 12 + { 0x2, 0x0, 0x0, 0x0, 0x5, 0x2, PseudoVLSEG2E32_V_M4 }, // 13 + { 0x2, 0x0, 0x0, 0x0, 0x5, 0x7, PseudoVLSEG2E32_V_MF2 }, // 14 + { 0x2, 0x0, 0x0, 0x0, 0x6, 0x0, PseudoVLSEG2E64_V_M1 }, // 15 + { 0x2, 0x0, 0x0, 0x0, 0x6, 0x1, PseudoVLSEG2E64_V_M2 }, // 16 + { 0x2, 0x0, 0x0, 0x0, 0x6, 0x2, PseudoVLSEG2E64_V_M4 }, // 17 + { 0x2, 0x0, 0x0, 0x1, 0x3, 0x0, PseudoVLSEG2E8FF_V_M1 }, // 18 + { 0x2, 0x0, 0x0, 0x1, 0x3, 0x1, PseudoVLSEG2E8FF_V_M2 }, // 19 + { 0x2, 0x0, 0x0, 0x1, 0x3, 0x2, PseudoVLSEG2E8FF_V_M4 }, // 20 + { 0x2, 0x0, 0x0, 0x1, 0x3, 0x5, PseudoVLSEG2E8FF_V_MF8 }, // 21 + { 0x2, 0x0, 0x0, 0x1, 0x3, 0x6, PseudoVLSEG2E8FF_V_MF4 }, // 22 + { 0x2, 0x0, 0x0, 0x1, 0x3, 0x7, PseudoVLSEG2E8FF_V_MF2 }, // 23 + { 0x2, 0x0, 0x0, 0x1, 0x4, 0x0, PseudoVLSEG2E16FF_V_M1 }, // 24 + { 0x2, 0x0, 0x0, 0x1, 0x4, 0x1, PseudoVLSEG2E16FF_V_M2 }, // 25 + { 0x2, 0x0, 0x0, 0x1, 0x4, 0x2, PseudoVLSEG2E16FF_V_M4 }, // 26 + { 0x2, 0x0, 0x0, 0x1, 0x4, 0x6, PseudoVLSEG2E16FF_V_MF4 }, // 27 + { 0x2, 0x0, 0x0, 0x1, 0x4, 0x7, PseudoVLSEG2E16FF_V_MF2 }, // 28 + { 0x2, 0x0, 0x0, 0x1, 0x5, 0x0, PseudoVLSEG2E32FF_V_M1 }, // 29 + { 0x2, 0x0, 0x0, 0x1, 0x5, 0x1, PseudoVLSEG2E32FF_V_M2 }, // 30 + { 0x2, 0x0, 0x0, 0x1, 0x5, 0x2, PseudoVLSEG2E32FF_V_M4 }, // 31 + { 0x2, 0x0, 0x0, 0x1, 0x5, 0x7, PseudoVLSEG2E32FF_V_MF2 }, // 32 + { 0x2, 0x0, 0x0, 0x1, 0x6, 0x0, PseudoVLSEG2E64FF_V_M1 }, // 33 + { 0x2, 0x0, 0x0, 0x1, 0x6, 0x1, PseudoVLSEG2E64FF_V_M2 }, // 34 + { 0x2, 0x0, 0x0, 0x1, 0x6, 0x2, PseudoVLSEG2E64FF_V_M4 }, // 35 + { 0x2, 0x0, 0x1, 0x0, 0x3, 0x0, PseudoVLSSEG2E8_V_M1 }, // 36 + { 0x2, 0x0, 0x1, 0x0, 0x3, 0x1, PseudoVLSSEG2E8_V_M2 }, // 37 + { 0x2, 0x0, 0x1, 0x0, 0x3, 0x2, PseudoVLSSEG2E8_V_M4 }, // 38 + { 0x2, 0x0, 0x1, 0x0, 0x3, 0x5, PseudoVLSSEG2E8_V_MF8 }, // 39 + { 0x2, 0x0, 0x1, 0x0, 0x3, 0x6, PseudoVLSSEG2E8_V_MF4 }, // 40 + { 0x2, 0x0, 0x1, 0x0, 0x3, 0x7, PseudoVLSSEG2E8_V_MF2 }, // 41 + { 0x2, 0x0, 0x1, 0x0, 0x4, 0x0, PseudoVLSSEG2E16_V_M1 }, // 42 + { 0x2, 0x0, 0x1, 0x0, 0x4, 0x1, PseudoVLSSEG2E16_V_M2 }, // 43 + { 0x2, 0x0, 0x1, 0x0, 0x4, 0x2, PseudoVLSSEG2E16_V_M4 }, // 44 + { 0x2, 0x0, 0x1, 0x0, 0x4, 0x6, PseudoVLSSEG2E16_V_MF4 }, // 45 + { 0x2, 0x0, 0x1, 0x0, 0x4, 0x7, PseudoVLSSEG2E16_V_MF2 }, // 46 + { 0x2, 0x0, 0x1, 0x0, 0x5, 0x0, PseudoVLSSEG2E32_V_M1 }, // 47 + { 0x2, 0x0, 0x1, 0x0, 0x5, 0x1, PseudoVLSSEG2E32_V_M2 }, // 48 + { 0x2, 0x0, 0x1, 0x0, 0x5, 0x2, PseudoVLSSEG2E32_V_M4 }, // 49 + { 0x2, 0x0, 0x1, 0x0, 0x5, 0x7, PseudoVLSSEG2E32_V_MF2 }, // 50 + { 0x2, 0x0, 0x1, 0x0, 0x6, 0x0, PseudoVLSSEG2E64_V_M1 }, // 51 + { 0x2, 0x0, 0x1, 0x0, 0x6, 0x1, PseudoVLSSEG2E64_V_M2 }, // 52 + { 0x2, 0x0, 0x1, 0x0, 0x6, 0x2, PseudoVLSSEG2E64_V_M4 }, // 53 + { 0x2, 0x1, 0x0, 0x0, 0x3, 0x0, PseudoVLSEG2E8_V_M1_MASK }, // 54 + { 0x2, 0x1, 0x0, 0x0, 0x3, 0x1, PseudoVLSEG2E8_V_M2_MASK }, // 55 + { 0x2, 0x1, 0x0, 0x0, 0x3, 0x2, PseudoVLSEG2E8_V_M4_MASK }, // 56 + { 0x2, 0x1, 0x0, 0x0, 0x3, 0x5, PseudoVLSEG2E8_V_MF8_MASK }, // 57 + { 0x2, 0x1, 0x0, 0x0, 0x3, 0x6, PseudoVLSEG2E8_V_MF4_MASK }, // 58 + { 0x2, 0x1, 0x0, 0x0, 0x3, 0x7, PseudoVLSEG2E8_V_MF2_MASK }, // 59 + { 0x2, 0x1, 0x0, 0x0, 0x4, 0x0, PseudoVLSEG2E16_V_M1_MASK }, // 60 + { 0x2, 0x1, 0x0, 0x0, 0x4, 0x1, PseudoVLSEG2E16_V_M2_MASK }, // 61 + { 0x2, 0x1, 0x0, 0x0, 0x4, 0x2, PseudoVLSEG2E16_V_M4_MASK }, // 62 + { 0x2, 0x1, 0x0, 0x0, 0x4, 0x6, PseudoVLSEG2E16_V_MF4_MASK }, // 63 + { 0x2, 0x1, 0x0, 0x0, 0x4, 0x7, PseudoVLSEG2E16_V_MF2_MASK }, // 64 + { 0x2, 0x1, 0x0, 0x0, 0x5, 0x0, PseudoVLSEG2E32_V_M1_MASK }, // 65 + { 0x2, 0x1, 0x0, 0x0, 0x5, 0x1, PseudoVLSEG2E32_V_M2_MASK }, // 66 + { 0x2, 0x1, 0x0, 0x0, 0x5, 0x2, PseudoVLSEG2E32_V_M4_MASK }, // 67 + { 0x2, 0x1, 0x0, 0x0, 0x5, 0x7, PseudoVLSEG2E32_V_MF2_MASK }, // 68 + { 0x2, 0x1, 0x0, 0x0, 0x6, 0x0, PseudoVLSEG2E64_V_M1_MASK }, // 69 + { 0x2, 0x1, 0x0, 0x0, 0x6, 0x1, PseudoVLSEG2E64_V_M2_MASK }, // 70 + { 0x2, 0x1, 0x0, 0x0, 0x6, 0x2, PseudoVLSEG2E64_V_M4_MASK }, // 71 + { 0x2, 0x1, 0x0, 0x1, 0x3, 0x0, PseudoVLSEG2E8FF_V_M1_MASK }, // 72 + { 0x2, 0x1, 0x0, 0x1, 0x3, 0x1, PseudoVLSEG2E8FF_V_M2_MASK }, // 73 + { 0x2, 0x1, 0x0, 0x1, 0x3, 0x2, PseudoVLSEG2E8FF_V_M4_MASK }, // 74 + { 0x2, 0x1, 0x0, 0x1, 0x3, 0x5, PseudoVLSEG2E8FF_V_MF8_MASK }, // 75 + { 0x2, 0x1, 0x0, 0x1, 0x3, 0x6, PseudoVLSEG2E8FF_V_MF4_MASK }, // 76 + { 0x2, 0x1, 0x0, 0x1, 0x3, 0x7, PseudoVLSEG2E8FF_V_MF2_MASK }, // 77 + { 0x2, 0x1, 0x0, 0x1, 0x4, 0x0, PseudoVLSEG2E16FF_V_M1_MASK }, // 78 + { 0x2, 0x1, 0x0, 0x1, 0x4, 0x1, PseudoVLSEG2E16FF_V_M2_MASK }, // 79 + { 0x2, 0x1, 0x0, 0x1, 0x4, 0x2, PseudoVLSEG2E16FF_V_M4_MASK }, // 80 + { 0x2, 0x1, 0x0, 0x1, 0x4, 0x6, PseudoVLSEG2E16FF_V_MF4_MASK }, // 81 + { 0x2, 0x1, 0x0, 0x1, 0x4, 0x7, PseudoVLSEG2E16FF_V_MF2_MASK }, // 82 + { 0x2, 0x1, 0x0, 0x1, 0x5, 0x0, PseudoVLSEG2E32FF_V_M1_MASK }, // 83 + { 0x2, 0x1, 0x0, 0x1, 0x5, 0x1, PseudoVLSEG2E32FF_V_M2_MASK }, // 84 + { 0x2, 0x1, 0x0, 0x1, 0x5, 0x2, PseudoVLSEG2E32FF_V_M4_MASK }, // 85 + { 0x2, 0x1, 0x0, 0x1, 0x5, 0x7, PseudoVLSEG2E32FF_V_MF2_MASK }, // 86 + { 0x2, 0x1, 0x0, 0x1, 0x6, 0x0, PseudoVLSEG2E64FF_V_M1_MASK }, // 87 + { 0x2, 0x1, 0x0, 0x1, 0x6, 0x1, PseudoVLSEG2E64FF_V_M2_MASK }, // 88 + { 0x2, 0x1, 0x0, 0x1, 0x6, 0x2, PseudoVLSEG2E64FF_V_M4_MASK }, // 89 + { 0x2, 0x1, 0x1, 0x0, 0x3, 0x0, PseudoVLSSEG2E8_V_M1_MASK }, // 90 + { 0x2, 0x1, 0x1, 0x0, 0x3, 0x1, PseudoVLSSEG2E8_V_M2_MASK }, // 91 + { 0x2, 0x1, 0x1, 0x0, 0x3, 0x2, PseudoVLSSEG2E8_V_M4_MASK }, // 92 + { 0x2, 0x1, 0x1, 0x0, 0x3, 0x5, PseudoVLSSEG2E8_V_MF8_MASK }, // 93 + { 0x2, 0x1, 0x1, 0x0, 0x3, 0x6, PseudoVLSSEG2E8_V_MF4_MASK }, // 94 + { 0x2, 0x1, 0x1, 0x0, 0x3, 0x7, PseudoVLSSEG2E8_V_MF2_MASK }, // 95 + { 0x2, 0x1, 0x1, 0x0, 0x4, 0x0, PseudoVLSSEG2E16_V_M1_MASK }, // 96 + { 0x2, 0x1, 0x1, 0x0, 0x4, 0x1, PseudoVLSSEG2E16_V_M2_MASK }, // 97 + { 0x2, 0x1, 0x1, 0x0, 0x4, 0x2, PseudoVLSSEG2E16_V_M4_MASK }, // 98 + { 0x2, 0x1, 0x1, 0x0, 0x4, 0x6, PseudoVLSSEG2E16_V_MF4_MASK }, // 99 + { 0x2, 0x1, 0x1, 0x0, 0x4, 0x7, PseudoVLSSEG2E16_V_MF2_MASK }, // 100 + { 0x2, 0x1, 0x1, 0x0, 0x5, 0x0, PseudoVLSSEG2E32_V_M1_MASK }, // 101 + { 0x2, 0x1, 0x1, 0x0, 0x5, 0x1, PseudoVLSSEG2E32_V_M2_MASK }, // 102 + { 0x2, 0x1, 0x1, 0x0, 0x5, 0x2, PseudoVLSSEG2E32_V_M4_MASK }, // 103 + { 0x2, 0x1, 0x1, 0x0, 0x5, 0x7, PseudoVLSSEG2E32_V_MF2_MASK }, // 104 + { 0x2, 0x1, 0x1, 0x0, 0x6, 0x0, PseudoVLSSEG2E64_V_M1_MASK }, // 105 + { 0x2, 0x1, 0x1, 0x0, 0x6, 0x1, PseudoVLSSEG2E64_V_M2_MASK }, // 106 + { 0x2, 0x1, 0x1, 0x0, 0x6, 0x2, PseudoVLSSEG2E64_V_M4_MASK }, // 107 + { 0x3, 0x0, 0x0, 0x0, 0x3, 0x0, PseudoVLSEG3E8_V_M1 }, // 108 + { 0x3, 0x0, 0x0, 0x0, 0x3, 0x1, PseudoVLSEG3E8_V_M2 }, // 109 + { 0x3, 0x0, 0x0, 0x0, 0x3, 0x5, PseudoVLSEG3E8_V_MF8 }, // 110 + { 0x3, 0x0, 0x0, 0x0, 0x3, 0x6, PseudoVLSEG3E8_V_MF4 }, // 111 + { 0x3, 0x0, 0x0, 0x0, 0x3, 0x7, PseudoVLSEG3E8_V_MF2 }, // 112 + { 0x3, 0x0, 0x0, 0x0, 0x4, 0x0, PseudoVLSEG3E16_V_M1 }, // 113 + { 0x3, 0x0, 0x0, 0x0, 0x4, 0x1, PseudoVLSEG3E16_V_M2 }, // 114 + { 0x3, 0x0, 0x0, 0x0, 0x4, 0x6, PseudoVLSEG3E16_V_MF4 }, // 115 + { 0x3, 0x0, 0x0, 0x0, 0x4, 0x7, PseudoVLSEG3E16_V_MF2 }, // 116 + { 0x3, 0x0, 0x0, 0x0, 0x5, 0x0, PseudoVLSEG3E32_V_M1 }, // 117 + { 0x3, 0x0, 0x0, 0x0, 0x5, 0x1, PseudoVLSEG3E32_V_M2 }, // 118 + { 0x3, 0x0, 0x0, 0x0, 0x5, 0x7, PseudoVLSEG3E32_V_MF2 }, // 119 + { 0x3, 0x0, 0x0, 0x0, 0x6, 0x0, PseudoVLSEG3E64_V_M1 }, // 120 + { 0x3, 0x0, 0x0, 0x0, 0x6, 0x1, PseudoVLSEG3E64_V_M2 }, // 121 + { 0x3, 0x0, 0x0, 0x1, 0x3, 0x0, PseudoVLSEG3E8FF_V_M1 }, // 122 + { 0x3, 0x0, 0x0, 0x1, 0x3, 0x1, PseudoVLSEG3E8FF_V_M2 }, // 123 + { 0x3, 0x0, 0x0, 0x1, 0x3, 0x5, PseudoVLSEG3E8FF_V_MF8 }, // 124 + { 0x3, 0x0, 0x0, 0x1, 0x3, 0x6, PseudoVLSEG3E8FF_V_MF4 }, // 125 + { 0x3, 0x0, 0x0, 0x1, 0x3, 0x7, PseudoVLSEG3E8FF_V_MF2 }, // 126 + { 0x3, 0x0, 0x0, 0x1, 0x4, 0x0, PseudoVLSEG3E16FF_V_M1 }, // 127 + { 0x3, 0x0, 0x0, 0x1, 0x4, 0x1, PseudoVLSEG3E16FF_V_M2 }, // 128 + { 0x3, 0x0, 0x0, 0x1, 0x4, 0x6, PseudoVLSEG3E16FF_V_MF4 }, // 129 + { 0x3, 0x0, 0x0, 0x1, 0x4, 0x7, PseudoVLSEG3E16FF_V_MF2 }, // 130 + { 0x3, 0x0, 0x0, 0x1, 0x5, 0x0, PseudoVLSEG3E32FF_V_M1 }, // 131 + { 0x3, 0x0, 0x0, 0x1, 0x5, 0x1, PseudoVLSEG3E32FF_V_M2 }, // 132 + { 0x3, 0x0, 0x0, 0x1, 0x5, 0x7, PseudoVLSEG3E32FF_V_MF2 }, // 133 + { 0x3, 0x0, 0x0, 0x1, 0x6, 0x0, PseudoVLSEG3E64FF_V_M1 }, // 134 + { 0x3, 0x0, 0x0, 0x1, 0x6, 0x1, PseudoVLSEG3E64FF_V_M2 }, // 135 + { 0x3, 0x0, 0x1, 0x0, 0x3, 0x0, PseudoVLSSEG3E8_V_M1 }, // 136 + { 0x3, 0x0, 0x1, 0x0, 0x3, 0x1, PseudoVLSSEG3E8_V_M2 }, // 137 + { 0x3, 0x0, 0x1, 0x0, 0x3, 0x5, PseudoVLSSEG3E8_V_MF8 }, // 138 + { 0x3, 0x0, 0x1, 0x0, 0x3, 0x6, PseudoVLSSEG3E8_V_MF4 }, // 139 + { 0x3, 0x0, 0x1, 0x0, 0x3, 0x7, PseudoVLSSEG3E8_V_MF2 }, // 140 + { 0x3, 0x0, 0x1, 0x0, 0x4, 0x0, PseudoVLSSEG3E16_V_M1 }, // 141 + { 0x3, 0x0, 0x1, 0x0, 0x4, 0x1, PseudoVLSSEG3E16_V_M2 }, // 142 + { 0x3, 0x0, 0x1, 0x0, 0x4, 0x6, PseudoVLSSEG3E16_V_MF4 }, // 143 + { 0x3, 0x0, 0x1, 0x0, 0x4, 0x7, PseudoVLSSEG3E16_V_MF2 }, // 144 + { 0x3, 0x0, 0x1, 0x0, 0x5, 0x0, PseudoVLSSEG3E32_V_M1 }, // 145 + { 0x3, 0x0, 0x1, 0x0, 0x5, 0x1, PseudoVLSSEG3E32_V_M2 }, // 146 + { 0x3, 0x0, 0x1, 0x0, 0x5, 0x7, PseudoVLSSEG3E32_V_MF2 }, // 147 + { 0x3, 0x0, 0x1, 0x0, 0x6, 0x0, PseudoVLSSEG3E64_V_M1 }, // 148 + { 0x3, 0x0, 0x1, 0x0, 0x6, 0x1, PseudoVLSSEG3E64_V_M2 }, // 149 + { 0x3, 0x1, 0x0, 0x0, 0x3, 0x0, PseudoVLSEG3E8_V_M1_MASK }, // 150 + { 0x3, 0x1, 0x0, 0x0, 0x3, 0x1, PseudoVLSEG3E8_V_M2_MASK }, // 151 + { 0x3, 0x1, 0x0, 0x0, 0x3, 0x5, PseudoVLSEG3E8_V_MF8_MASK }, // 152 + { 0x3, 0x1, 0x0, 0x0, 0x3, 0x6, PseudoVLSEG3E8_V_MF4_MASK }, // 153 + { 0x3, 0x1, 0x0, 0x0, 0x3, 0x7, PseudoVLSEG3E8_V_MF2_MASK }, // 154 + { 0x3, 0x1, 0x0, 0x0, 0x4, 0x0, PseudoVLSEG3E16_V_M1_MASK }, // 155 + { 0x3, 0x1, 0x0, 0x0, 0x4, 0x1, PseudoVLSEG3E16_V_M2_MASK }, // 156 + { 0x3, 0x1, 0x0, 0x0, 0x4, 0x6, PseudoVLSEG3E16_V_MF4_MASK }, // 157 + { 0x3, 0x1, 0x0, 0x0, 0x4, 0x7, PseudoVLSEG3E16_V_MF2_MASK }, // 158 + { 0x3, 0x1, 0x0, 0x0, 0x5, 0x0, PseudoVLSEG3E32_V_M1_MASK }, // 159 + { 0x3, 0x1, 0x0, 0x0, 0x5, 0x1, PseudoVLSEG3E32_V_M2_MASK }, // 160 + { 0x3, 0x1, 0x0, 0x0, 0x5, 0x7, PseudoVLSEG3E32_V_MF2_MASK }, // 161 + { 0x3, 0x1, 0x0, 0x0, 0x6, 0x0, PseudoVLSEG3E64_V_M1_MASK }, // 162 + { 0x3, 0x1, 0x0, 0x0, 0x6, 0x1, PseudoVLSEG3E64_V_M2_MASK }, // 163 + { 0x3, 0x1, 0x0, 0x1, 0x3, 0x0, PseudoVLSEG3E8FF_V_M1_MASK }, // 164 + { 0x3, 0x1, 0x0, 0x1, 0x3, 0x1, PseudoVLSEG3E8FF_V_M2_MASK }, // 165 + { 0x3, 0x1, 0x0, 0x1, 0x3, 0x5, PseudoVLSEG3E8FF_V_MF8_MASK }, // 166 + { 0x3, 0x1, 0x0, 0x1, 0x3, 0x6, PseudoVLSEG3E8FF_V_MF4_MASK }, // 167 + { 0x3, 0x1, 0x0, 0x1, 0x3, 0x7, PseudoVLSEG3E8FF_V_MF2_MASK }, // 168 + { 0x3, 0x1, 0x0, 0x1, 0x4, 0x0, PseudoVLSEG3E16FF_V_M1_MASK }, // 169 + { 0x3, 0x1, 0x0, 0x1, 0x4, 0x1, PseudoVLSEG3E16FF_V_M2_MASK }, // 170 + { 0x3, 0x1, 0x0, 0x1, 0x4, 0x6, PseudoVLSEG3E16FF_V_MF4_MASK }, // 171 + { 0x3, 0x1, 0x0, 0x1, 0x4, 0x7, PseudoVLSEG3E16FF_V_MF2_MASK }, // 172 + { 0x3, 0x1, 0x0, 0x1, 0x5, 0x0, PseudoVLSEG3E32FF_V_M1_MASK }, // 173 + { 0x3, 0x1, 0x0, 0x1, 0x5, 0x1, PseudoVLSEG3E32FF_V_M2_MASK }, // 174 + { 0x3, 0x1, 0x0, 0x1, 0x5, 0x7, PseudoVLSEG3E32FF_V_MF2_MASK }, // 175 + { 0x3, 0x1, 0x0, 0x1, 0x6, 0x0, PseudoVLSEG3E64FF_V_M1_MASK }, // 176 + { 0x3, 0x1, 0x0, 0x1, 0x6, 0x1, PseudoVLSEG3E64FF_V_M2_MASK }, // 177 + { 0x3, 0x1, 0x1, 0x0, 0x3, 0x0, PseudoVLSSEG3E8_V_M1_MASK }, // 178 + { 0x3, 0x1, 0x1, 0x0, 0x3, 0x1, PseudoVLSSEG3E8_V_M2_MASK }, // 179 + { 0x3, 0x1, 0x1, 0x0, 0x3, 0x5, PseudoVLSSEG3E8_V_MF8_MASK }, // 180 + { 0x3, 0x1, 0x1, 0x0, 0x3, 0x6, PseudoVLSSEG3E8_V_MF4_MASK }, // 181 + { 0x3, 0x1, 0x1, 0x0, 0x3, 0x7, PseudoVLSSEG3E8_V_MF2_MASK }, // 182 + { 0x3, 0x1, 0x1, 0x0, 0x4, 0x0, PseudoVLSSEG3E16_V_M1_MASK }, // 183 + { 0x3, 0x1, 0x1, 0x0, 0x4, 0x1, PseudoVLSSEG3E16_V_M2_MASK }, // 184 + { 0x3, 0x1, 0x1, 0x0, 0x4, 0x6, PseudoVLSSEG3E16_V_MF4_MASK }, // 185 + { 0x3, 0x1, 0x1, 0x0, 0x4, 0x7, PseudoVLSSEG3E16_V_MF2_MASK }, // 186 + { 0x3, 0x1, 0x1, 0x0, 0x5, 0x0, PseudoVLSSEG3E32_V_M1_MASK }, // 187 + { 0x3, 0x1, 0x1, 0x0, 0x5, 0x1, PseudoVLSSEG3E32_V_M2_MASK }, // 188 + { 0x3, 0x1, 0x1, 0x0, 0x5, 0x7, PseudoVLSSEG3E32_V_MF2_MASK }, // 189 + { 0x3, 0x1, 0x1, 0x0, 0x6, 0x0, PseudoVLSSEG3E64_V_M1_MASK }, // 190 + { 0x3, 0x1, 0x1, 0x0, 0x6, 0x1, PseudoVLSSEG3E64_V_M2_MASK }, // 191 + { 0x4, 0x0, 0x0, 0x0, 0x3, 0x0, PseudoVLSEG4E8_V_M1 }, // 192 + { 0x4, 0x0, 0x0, 0x0, 0x3, 0x1, PseudoVLSEG4E8_V_M2 }, // 193 + { 0x4, 0x0, 0x0, 0x0, 0x3, 0x5, PseudoVLSEG4E8_V_MF8 }, // 194 + { 0x4, 0x0, 0x0, 0x0, 0x3, 0x6, PseudoVLSEG4E8_V_MF4 }, // 195 + { 0x4, 0x0, 0x0, 0x0, 0x3, 0x7, PseudoVLSEG4E8_V_MF2 }, // 196 + { 0x4, 0x0, 0x0, 0x0, 0x4, 0x0, PseudoVLSEG4E16_V_M1 }, // 197 + { 0x4, 0x0, 0x0, 0x0, 0x4, 0x1, PseudoVLSEG4E16_V_M2 }, // 198 + { 0x4, 0x0, 0x0, 0x0, 0x4, 0x6, PseudoVLSEG4E16_V_MF4 }, // 199 + { 0x4, 0x0, 0x0, 0x0, 0x4, 0x7, PseudoVLSEG4E16_V_MF2 }, // 200 + { 0x4, 0x0, 0x0, 0x0, 0x5, 0x0, PseudoVLSEG4E32_V_M1 }, // 201 + { 0x4, 0x0, 0x0, 0x0, 0x5, 0x1, PseudoVLSEG4E32_V_M2 }, // 202 + { 0x4, 0x0, 0x0, 0x0, 0x5, 0x7, PseudoVLSEG4E32_V_MF2 }, // 203 + { 0x4, 0x0, 0x0, 0x0, 0x6, 0x0, PseudoVLSEG4E64_V_M1 }, // 204 + { 0x4, 0x0, 0x0, 0x0, 0x6, 0x1, PseudoVLSEG4E64_V_M2 }, // 205 + { 0x4, 0x0, 0x0, 0x1, 0x3, 0x0, PseudoVLSEG4E8FF_V_M1 }, // 206 + { 0x4, 0x0, 0x0, 0x1, 0x3, 0x1, PseudoVLSEG4E8FF_V_M2 }, // 207 + { 0x4, 0x0, 0x0, 0x1, 0x3, 0x5, PseudoVLSEG4E8FF_V_MF8 }, // 208 + { 0x4, 0x0, 0x0, 0x1, 0x3, 0x6, PseudoVLSEG4E8FF_V_MF4 }, // 209 + { 0x4, 0x0, 0x0, 0x1, 0x3, 0x7, PseudoVLSEG4E8FF_V_MF2 }, // 210 + { 0x4, 0x0, 0x0, 0x1, 0x4, 0x0, PseudoVLSEG4E16FF_V_M1 }, // 211 + { 0x4, 0x0, 0x0, 0x1, 0x4, 0x1, PseudoVLSEG4E16FF_V_M2 }, // 212 + { 0x4, 0x0, 0x0, 0x1, 0x4, 0x6, PseudoVLSEG4E16FF_V_MF4 }, // 213 + { 0x4, 0x0, 0x0, 0x1, 0x4, 0x7, PseudoVLSEG4E16FF_V_MF2 }, // 214 + { 0x4, 0x0, 0x0, 0x1, 0x5, 0x0, PseudoVLSEG4E32FF_V_M1 }, // 215 + { 0x4, 0x0, 0x0, 0x1, 0x5, 0x1, PseudoVLSEG4E32FF_V_M2 }, // 216 + { 0x4, 0x0, 0x0, 0x1, 0x5, 0x7, PseudoVLSEG4E32FF_V_MF2 }, // 217 + { 0x4, 0x0, 0x0, 0x1, 0x6, 0x0, PseudoVLSEG4E64FF_V_M1 }, // 218 + { 0x4, 0x0, 0x0, 0x1, 0x6, 0x1, PseudoVLSEG4E64FF_V_M2 }, // 219 + { 0x4, 0x0, 0x1, 0x0, 0x3, 0x0, PseudoVLSSEG4E8_V_M1 }, // 220 + { 0x4, 0x0, 0x1, 0x0, 0x3, 0x1, PseudoVLSSEG4E8_V_M2 }, // 221 + { 0x4, 0x0, 0x1, 0x0, 0x3, 0x5, PseudoVLSSEG4E8_V_MF8 }, // 222 + { 0x4, 0x0, 0x1, 0x0, 0x3, 0x6, PseudoVLSSEG4E8_V_MF4 }, // 223 + { 0x4, 0x0, 0x1, 0x0, 0x3, 0x7, PseudoVLSSEG4E8_V_MF2 }, // 224 + { 0x4, 0x0, 0x1, 0x0, 0x4, 0x0, PseudoVLSSEG4E16_V_M1 }, // 225 + { 0x4, 0x0, 0x1, 0x0, 0x4, 0x1, PseudoVLSSEG4E16_V_M2 }, // 226 + { 0x4, 0x0, 0x1, 0x0, 0x4, 0x6, PseudoVLSSEG4E16_V_MF4 }, // 227 + { 0x4, 0x0, 0x1, 0x0, 0x4, 0x7, PseudoVLSSEG4E16_V_MF2 }, // 228 + { 0x4, 0x0, 0x1, 0x0, 0x5, 0x0, PseudoVLSSEG4E32_V_M1 }, // 229 + { 0x4, 0x0, 0x1, 0x0, 0x5, 0x1, PseudoVLSSEG4E32_V_M2 }, // 230 + { 0x4, 0x0, 0x1, 0x0, 0x5, 0x7, PseudoVLSSEG4E32_V_MF2 }, // 231 + { 0x4, 0x0, 0x1, 0x0, 0x6, 0x0, PseudoVLSSEG4E64_V_M1 }, // 232 + { 0x4, 0x0, 0x1, 0x0, 0x6, 0x1, PseudoVLSSEG4E64_V_M2 }, // 233 + { 0x4, 0x1, 0x0, 0x0, 0x3, 0x0, PseudoVLSEG4E8_V_M1_MASK }, // 234 + { 0x4, 0x1, 0x0, 0x0, 0x3, 0x1, PseudoVLSEG4E8_V_M2_MASK }, // 235 + { 0x4, 0x1, 0x0, 0x0, 0x3, 0x5, PseudoVLSEG4E8_V_MF8_MASK }, // 236 + { 0x4, 0x1, 0x0, 0x0, 0x3, 0x6, PseudoVLSEG4E8_V_MF4_MASK }, // 237 + { 0x4, 0x1, 0x0, 0x0, 0x3, 0x7, PseudoVLSEG4E8_V_MF2_MASK }, // 238 + { 0x4, 0x1, 0x0, 0x0, 0x4, 0x0, PseudoVLSEG4E16_V_M1_MASK }, // 239 + { 0x4, 0x1, 0x0, 0x0, 0x4, 0x1, PseudoVLSEG4E16_V_M2_MASK }, // 240 + { 0x4, 0x1, 0x0, 0x0, 0x4, 0x6, PseudoVLSEG4E16_V_MF4_MASK }, // 241 + { 0x4, 0x1, 0x0, 0x0, 0x4, 0x7, PseudoVLSEG4E16_V_MF2_MASK }, // 242 + { 0x4, 0x1, 0x0, 0x0, 0x5, 0x0, PseudoVLSEG4E32_V_M1_MASK }, // 243 + { 0x4, 0x1, 0x0, 0x0, 0x5, 0x1, PseudoVLSEG4E32_V_M2_MASK }, // 244 + { 0x4, 0x1, 0x0, 0x0, 0x5, 0x7, PseudoVLSEG4E32_V_MF2_MASK }, // 245 + { 0x4, 0x1, 0x0, 0x0, 0x6, 0x0, PseudoVLSEG4E64_V_M1_MASK }, // 246 + { 0x4, 0x1, 0x0, 0x0, 0x6, 0x1, PseudoVLSEG4E64_V_M2_MASK }, // 247 + { 0x4, 0x1, 0x0, 0x1, 0x3, 0x0, PseudoVLSEG4E8FF_V_M1_MASK }, // 248 + { 0x4, 0x1, 0x0, 0x1, 0x3, 0x1, PseudoVLSEG4E8FF_V_M2_MASK }, // 249 + { 0x4, 0x1, 0x0, 0x1, 0x3, 0x5, PseudoVLSEG4E8FF_V_MF8_MASK }, // 250 + { 0x4, 0x1, 0x0, 0x1, 0x3, 0x6, PseudoVLSEG4E8FF_V_MF4_MASK }, // 251 + { 0x4, 0x1, 0x0, 0x1, 0x3, 0x7, PseudoVLSEG4E8FF_V_MF2_MASK }, // 252 + { 0x4, 0x1, 0x0, 0x1, 0x4, 0x0, PseudoVLSEG4E16FF_V_M1_MASK }, // 253 + { 0x4, 0x1, 0x0, 0x1, 0x4, 0x1, PseudoVLSEG4E16FF_V_M2_MASK }, // 254 + { 0x4, 0x1, 0x0, 0x1, 0x4, 0x6, PseudoVLSEG4E16FF_V_MF4_MASK }, // 255 + { 0x4, 0x1, 0x0, 0x1, 0x4, 0x7, PseudoVLSEG4E16FF_V_MF2_MASK }, // 256 + { 0x4, 0x1, 0x0, 0x1, 0x5, 0x0, PseudoVLSEG4E32FF_V_M1_MASK }, // 257 + { 0x4, 0x1, 0x0, 0x1, 0x5, 0x1, PseudoVLSEG4E32FF_V_M2_MASK }, // 258 + { 0x4, 0x1, 0x0, 0x1, 0x5, 0x7, PseudoVLSEG4E32FF_V_MF2_MASK }, // 259 + { 0x4, 0x1, 0x0, 0x1, 0x6, 0x0, PseudoVLSEG4E64FF_V_M1_MASK }, // 260 + { 0x4, 0x1, 0x0, 0x1, 0x6, 0x1, PseudoVLSEG4E64FF_V_M2_MASK }, // 261 + { 0x4, 0x1, 0x1, 0x0, 0x3, 0x0, PseudoVLSSEG4E8_V_M1_MASK }, // 262 + { 0x4, 0x1, 0x1, 0x0, 0x3, 0x1, PseudoVLSSEG4E8_V_M2_MASK }, // 263 + { 0x4, 0x1, 0x1, 0x0, 0x3, 0x5, PseudoVLSSEG4E8_V_MF8_MASK }, // 264 + { 0x4, 0x1, 0x1, 0x0, 0x3, 0x6, PseudoVLSSEG4E8_V_MF4_MASK }, // 265 + { 0x4, 0x1, 0x1, 0x0, 0x3, 0x7, PseudoVLSSEG4E8_V_MF2_MASK }, // 266 + { 0x4, 0x1, 0x1, 0x0, 0x4, 0x0, PseudoVLSSEG4E16_V_M1_MASK }, // 267 + { 0x4, 0x1, 0x1, 0x0, 0x4, 0x1, PseudoVLSSEG4E16_V_M2_MASK }, // 268 + { 0x4, 0x1, 0x1, 0x0, 0x4, 0x6, PseudoVLSSEG4E16_V_MF4_MASK }, // 269 + { 0x4, 0x1, 0x1, 0x0, 0x4, 0x7, PseudoVLSSEG4E16_V_MF2_MASK }, // 270 + { 0x4, 0x1, 0x1, 0x0, 0x5, 0x0, PseudoVLSSEG4E32_V_M1_MASK }, // 271 + { 0x4, 0x1, 0x1, 0x0, 0x5, 0x1, PseudoVLSSEG4E32_V_M2_MASK }, // 272 + { 0x4, 0x1, 0x1, 0x0, 0x5, 0x7, PseudoVLSSEG4E32_V_MF2_MASK }, // 273 + { 0x4, 0x1, 0x1, 0x0, 0x6, 0x0, PseudoVLSSEG4E64_V_M1_MASK }, // 274 + { 0x4, 0x1, 0x1, 0x0, 0x6, 0x1, PseudoVLSSEG4E64_V_M2_MASK }, // 275 + { 0x5, 0x0, 0x0, 0x0, 0x3, 0x0, PseudoVLSEG5E8_V_M1 }, // 276 + { 0x5, 0x0, 0x0, 0x0, 0x3, 0x5, PseudoVLSEG5E8_V_MF8 }, // 277 + { 0x5, 0x0, 0x0, 0x0, 0x3, 0x6, PseudoVLSEG5E8_V_MF4 }, // 278 + { 0x5, 0x0, 0x0, 0x0, 0x3, 0x7, PseudoVLSEG5E8_V_MF2 }, // 279 + { 0x5, 0x0, 0x0, 0x0, 0x4, 0x0, PseudoVLSEG5E16_V_M1 }, // 280 + { 0x5, 0x0, 0x0, 0x0, 0x4, 0x6, PseudoVLSEG5E16_V_MF4 }, // 281 + { 0x5, 0x0, 0x0, 0x0, 0x4, 0x7, PseudoVLSEG5E16_V_MF2 }, // 282 + { 0x5, 0x0, 0x0, 0x0, 0x5, 0x0, PseudoVLSEG5E32_V_M1 }, // 283 + { 0x5, 0x0, 0x0, 0x0, 0x5, 0x7, PseudoVLSEG5E32_V_MF2 }, // 284 + { 0x5, 0x0, 0x0, 0x0, 0x6, 0x0, PseudoVLSEG5E64_V_M1 }, // 285 + { 0x5, 0x0, 0x0, 0x1, 0x3, 0x0, PseudoVLSEG5E8FF_V_M1 }, // 286 + { 0x5, 0x0, 0x0, 0x1, 0x3, 0x5, PseudoVLSEG5E8FF_V_MF8 }, // 287 + { 0x5, 0x0, 0x0, 0x1, 0x3, 0x6, PseudoVLSEG5E8FF_V_MF4 }, // 288 + { 0x5, 0x0, 0x0, 0x1, 0x3, 0x7, PseudoVLSEG5E8FF_V_MF2 }, // 289 + { 0x5, 0x0, 0x0, 0x1, 0x4, 0x0, PseudoVLSEG5E16FF_V_M1 }, // 290 + { 0x5, 0x0, 0x0, 0x1, 0x4, 0x6, PseudoVLSEG5E16FF_V_MF4 }, // 291 + { 0x5, 0x0, 0x0, 0x1, 0x4, 0x7, PseudoVLSEG5E16FF_V_MF2 }, // 292 + { 0x5, 0x0, 0x0, 0x1, 0x5, 0x0, PseudoVLSEG5E32FF_V_M1 }, // 293 + { 0x5, 0x0, 0x0, 0x1, 0x5, 0x7, PseudoVLSEG5E32FF_V_MF2 }, // 294 + { 0x5, 0x0, 0x0, 0x1, 0x6, 0x0, PseudoVLSEG5E64FF_V_M1 }, // 295 + { 0x5, 0x0, 0x1, 0x0, 0x3, 0x0, PseudoVLSSEG5E8_V_M1 }, // 296 + { 0x5, 0x0, 0x1, 0x0, 0x3, 0x5, PseudoVLSSEG5E8_V_MF8 }, // 297 + { 0x5, 0x0, 0x1, 0x0, 0x3, 0x6, PseudoVLSSEG5E8_V_MF4 }, // 298 + { 0x5, 0x0, 0x1, 0x0, 0x3, 0x7, PseudoVLSSEG5E8_V_MF2 }, // 299 + { 0x5, 0x0, 0x1, 0x0, 0x4, 0x0, PseudoVLSSEG5E16_V_M1 }, // 300 + { 0x5, 0x0, 0x1, 0x0, 0x4, 0x6, PseudoVLSSEG5E16_V_MF4 }, // 301 + { 0x5, 0x0, 0x1, 0x0, 0x4, 0x7, PseudoVLSSEG5E16_V_MF2 }, // 302 + { 0x5, 0x0, 0x1, 0x0, 0x5, 0x0, PseudoVLSSEG5E32_V_M1 }, // 303 + { 0x5, 0x0, 0x1, 0x0, 0x5, 0x7, PseudoVLSSEG5E32_V_MF2 }, // 304 + { 0x5, 0x0, 0x1, 0x0, 0x6, 0x0, PseudoVLSSEG5E64_V_M1 }, // 305 + { 0x5, 0x1, 0x0, 0x0, 0x3, 0x0, PseudoVLSEG5E8_V_M1_MASK }, // 306 + { 0x5, 0x1, 0x0, 0x0, 0x3, 0x5, PseudoVLSEG5E8_V_MF8_MASK }, // 307 + { 0x5, 0x1, 0x0, 0x0, 0x3, 0x6, PseudoVLSEG5E8_V_MF4_MASK }, // 308 + { 0x5, 0x1, 0x0, 0x0, 0x3, 0x7, PseudoVLSEG5E8_V_MF2_MASK }, // 309 + { 0x5, 0x1, 0x0, 0x0, 0x4, 0x0, PseudoVLSEG5E16_V_M1_MASK }, // 310 + { 0x5, 0x1, 0x0, 0x0, 0x4, 0x6, PseudoVLSEG5E16_V_MF4_MASK }, // 311 + { 0x5, 0x1, 0x0, 0x0, 0x4, 0x7, PseudoVLSEG5E16_V_MF2_MASK }, // 312 + { 0x5, 0x1, 0x0, 0x0, 0x5, 0x0, PseudoVLSEG5E32_V_M1_MASK }, // 313 + { 0x5, 0x1, 0x0, 0x0, 0x5, 0x7, PseudoVLSEG5E32_V_MF2_MASK }, // 314 + { 0x5, 0x1, 0x0, 0x0, 0x6, 0x0, PseudoVLSEG5E64_V_M1_MASK }, // 315 + { 0x5, 0x1, 0x0, 0x1, 0x3, 0x0, PseudoVLSEG5E8FF_V_M1_MASK }, // 316 + { 0x5, 0x1, 0x0, 0x1, 0x3, 0x5, PseudoVLSEG5E8FF_V_MF8_MASK }, // 317 + { 0x5, 0x1, 0x0, 0x1, 0x3, 0x6, PseudoVLSEG5E8FF_V_MF4_MASK }, // 318 + { 0x5, 0x1, 0x0, 0x1, 0x3, 0x7, PseudoVLSEG5E8FF_V_MF2_MASK }, // 319 + { 0x5, 0x1, 0x0, 0x1, 0x4, 0x0, PseudoVLSEG5E16FF_V_M1_MASK }, // 320 + { 0x5, 0x1, 0x0, 0x1, 0x4, 0x6, PseudoVLSEG5E16FF_V_MF4_MASK }, // 321 + { 0x5, 0x1, 0x0, 0x1, 0x4, 0x7, PseudoVLSEG5E16FF_V_MF2_MASK }, // 322 + { 0x5, 0x1, 0x0, 0x1, 0x5, 0x0, PseudoVLSEG5E32FF_V_M1_MASK }, // 323 + { 0x5, 0x1, 0x0, 0x1, 0x5, 0x7, PseudoVLSEG5E32FF_V_MF2_MASK }, // 324 + { 0x5, 0x1, 0x0, 0x1, 0x6, 0x0, PseudoVLSEG5E64FF_V_M1_MASK }, // 325 + { 0x5, 0x1, 0x1, 0x0, 0x3, 0x0, PseudoVLSSEG5E8_V_M1_MASK }, // 326 + { 0x5, 0x1, 0x1, 0x0, 0x3, 0x5, PseudoVLSSEG5E8_V_MF8_MASK }, // 327 + { 0x5, 0x1, 0x1, 0x0, 0x3, 0x6, PseudoVLSSEG5E8_V_MF4_MASK }, // 328 + { 0x5, 0x1, 0x1, 0x0, 0x3, 0x7, PseudoVLSSEG5E8_V_MF2_MASK }, // 329 + { 0x5, 0x1, 0x1, 0x0, 0x4, 0x0, PseudoVLSSEG5E16_V_M1_MASK }, // 330 + { 0x5, 0x1, 0x1, 0x0, 0x4, 0x6, PseudoVLSSEG5E16_V_MF4_MASK }, // 331 + { 0x5, 0x1, 0x1, 0x0, 0x4, 0x7, PseudoVLSSEG5E16_V_MF2_MASK }, // 332 + { 0x5, 0x1, 0x1, 0x0, 0x5, 0x0, PseudoVLSSEG5E32_V_M1_MASK }, // 333 + { 0x5, 0x1, 0x1, 0x0, 0x5, 0x7, PseudoVLSSEG5E32_V_MF2_MASK }, // 334 + { 0x5, 0x1, 0x1, 0x0, 0x6, 0x0, PseudoVLSSEG5E64_V_M1_MASK }, // 335 + { 0x6, 0x0, 0x0, 0x0, 0x3, 0x0, PseudoVLSEG6E8_V_M1 }, // 336 + { 0x6, 0x0, 0x0, 0x0, 0x3, 0x5, PseudoVLSEG6E8_V_MF8 }, // 337 + { 0x6, 0x0, 0x0, 0x0, 0x3, 0x6, PseudoVLSEG6E8_V_MF4 }, // 338 + { 0x6, 0x0, 0x0, 0x0, 0x3, 0x7, PseudoVLSEG6E8_V_MF2 }, // 339 + { 0x6, 0x0, 0x0, 0x0, 0x4, 0x0, PseudoVLSEG6E16_V_M1 }, // 340 + { 0x6, 0x0, 0x0, 0x0, 0x4, 0x6, PseudoVLSEG6E16_V_MF4 }, // 341 + { 0x6, 0x0, 0x0, 0x0, 0x4, 0x7, PseudoVLSEG6E16_V_MF2 }, // 342 + { 0x6, 0x0, 0x0, 0x0, 0x5, 0x0, PseudoVLSEG6E32_V_M1 }, // 343 + { 0x6, 0x0, 0x0, 0x0, 0x5, 0x7, PseudoVLSEG6E32_V_MF2 }, // 344 + { 0x6, 0x0, 0x0, 0x0, 0x6, 0x0, PseudoVLSEG6E64_V_M1 }, // 345 + { 0x6, 0x0, 0x0, 0x1, 0x3, 0x0, PseudoVLSEG6E8FF_V_M1 }, // 346 + { 0x6, 0x0, 0x0, 0x1, 0x3, 0x5, PseudoVLSEG6E8FF_V_MF8 }, // 347 + { 0x6, 0x0, 0x0, 0x1, 0x3, 0x6, PseudoVLSEG6E8FF_V_MF4 }, // 348 + { 0x6, 0x0, 0x0, 0x1, 0x3, 0x7, PseudoVLSEG6E8FF_V_MF2 }, // 349 + { 0x6, 0x0, 0x0, 0x1, 0x4, 0x0, PseudoVLSEG6E16FF_V_M1 }, // 350 + { 0x6, 0x0, 0x0, 0x1, 0x4, 0x6, PseudoVLSEG6E16FF_V_MF4 }, // 351 + { 0x6, 0x0, 0x0, 0x1, 0x4, 0x7, PseudoVLSEG6E16FF_V_MF2 }, // 352 + { 0x6, 0x0, 0x0, 0x1, 0x5, 0x0, PseudoVLSEG6E32FF_V_M1 }, // 353 + { 0x6, 0x0, 0x0, 0x1, 0x5, 0x7, PseudoVLSEG6E32FF_V_MF2 }, // 354 + { 0x6, 0x0, 0x0, 0x1, 0x6, 0x0, PseudoVLSEG6E64FF_V_M1 }, // 355 + { 0x6, 0x0, 0x1, 0x0, 0x3, 0x0, PseudoVLSSEG6E8_V_M1 }, // 356 + { 0x6, 0x0, 0x1, 0x0, 0x3, 0x5, PseudoVLSSEG6E8_V_MF8 }, // 357 + { 0x6, 0x0, 0x1, 0x0, 0x3, 0x6, PseudoVLSSEG6E8_V_MF4 }, // 358 + { 0x6, 0x0, 0x1, 0x0, 0x3, 0x7, PseudoVLSSEG6E8_V_MF2 }, // 359 + { 0x6, 0x0, 0x1, 0x0, 0x4, 0x0, PseudoVLSSEG6E16_V_M1 }, // 360 + { 0x6, 0x0, 0x1, 0x0, 0x4, 0x6, PseudoVLSSEG6E16_V_MF4 }, // 361 + { 0x6, 0x0, 0x1, 0x0, 0x4, 0x7, PseudoVLSSEG6E16_V_MF2 }, // 362 + { 0x6, 0x0, 0x1, 0x0, 0x5, 0x0, PseudoVLSSEG6E32_V_M1 }, // 363 + { 0x6, 0x0, 0x1, 0x0, 0x5, 0x7, PseudoVLSSEG6E32_V_MF2 }, // 364 + { 0x6, 0x0, 0x1, 0x0, 0x6, 0x0, PseudoVLSSEG6E64_V_M1 }, // 365 + { 0x6, 0x1, 0x0, 0x0, 0x3, 0x0, PseudoVLSEG6E8_V_M1_MASK }, // 366 + { 0x6, 0x1, 0x0, 0x0, 0x3, 0x5, PseudoVLSEG6E8_V_MF8_MASK }, // 367 + { 0x6, 0x1, 0x0, 0x0, 0x3, 0x6, PseudoVLSEG6E8_V_MF4_MASK }, // 368 + { 0x6, 0x1, 0x0, 0x0, 0x3, 0x7, PseudoVLSEG6E8_V_MF2_MASK }, // 369 + { 0x6, 0x1, 0x0, 0x0, 0x4, 0x0, PseudoVLSEG6E16_V_M1_MASK }, // 370 + { 0x6, 0x1, 0x0, 0x0, 0x4, 0x6, PseudoVLSEG6E16_V_MF4_MASK }, // 371 + { 0x6, 0x1, 0x0, 0x0, 0x4, 0x7, PseudoVLSEG6E16_V_MF2_MASK }, // 372 + { 0x6, 0x1, 0x0, 0x0, 0x5, 0x0, PseudoVLSEG6E32_V_M1_MASK }, // 373 + { 0x6, 0x1, 0x0, 0x0, 0x5, 0x7, PseudoVLSEG6E32_V_MF2_MASK }, // 374 + { 0x6, 0x1, 0x0, 0x0, 0x6, 0x0, PseudoVLSEG6E64_V_M1_MASK }, // 375 + { 0x6, 0x1, 0x0, 0x1, 0x3, 0x0, PseudoVLSEG6E8FF_V_M1_MASK }, // 376 + { 0x6, 0x1, 0x0, 0x1, 0x3, 0x5, PseudoVLSEG6E8FF_V_MF8_MASK }, // 377 + { 0x6, 0x1, 0x0, 0x1, 0x3, 0x6, PseudoVLSEG6E8FF_V_MF4_MASK }, // 378 + { 0x6, 0x1, 0x0, 0x1, 0x3, 0x7, PseudoVLSEG6E8FF_V_MF2_MASK }, // 379 + { 0x6, 0x1, 0x0, 0x1, 0x4, 0x0, PseudoVLSEG6E16FF_V_M1_MASK }, // 380 + { 0x6, 0x1, 0x0, 0x1, 0x4, 0x6, PseudoVLSEG6E16FF_V_MF4_MASK }, // 381 + { 0x6, 0x1, 0x0, 0x1, 0x4, 0x7, PseudoVLSEG6E16FF_V_MF2_MASK }, // 382 + { 0x6, 0x1, 0x0, 0x1, 0x5, 0x0, PseudoVLSEG6E32FF_V_M1_MASK }, // 383 + { 0x6, 0x1, 0x0, 0x1, 0x5, 0x7, PseudoVLSEG6E32FF_V_MF2_MASK }, // 384 + { 0x6, 0x1, 0x0, 0x1, 0x6, 0x0, PseudoVLSEG6E64FF_V_M1_MASK }, // 385 + { 0x6, 0x1, 0x1, 0x0, 0x3, 0x0, PseudoVLSSEG6E8_V_M1_MASK }, // 386 + { 0x6, 0x1, 0x1, 0x0, 0x3, 0x5, PseudoVLSSEG6E8_V_MF8_MASK }, // 387 + { 0x6, 0x1, 0x1, 0x0, 0x3, 0x6, PseudoVLSSEG6E8_V_MF4_MASK }, // 388 + { 0x6, 0x1, 0x1, 0x0, 0x3, 0x7, PseudoVLSSEG6E8_V_MF2_MASK }, // 389 + { 0x6, 0x1, 0x1, 0x0, 0x4, 0x0, PseudoVLSSEG6E16_V_M1_MASK }, // 390 + { 0x6, 0x1, 0x1, 0x0, 0x4, 0x6, PseudoVLSSEG6E16_V_MF4_MASK }, // 391 + { 0x6, 0x1, 0x1, 0x0, 0x4, 0x7, PseudoVLSSEG6E16_V_MF2_MASK }, // 392 + { 0x6, 0x1, 0x1, 0x0, 0x5, 0x0, PseudoVLSSEG6E32_V_M1_MASK }, // 393 + { 0x6, 0x1, 0x1, 0x0, 0x5, 0x7, PseudoVLSSEG6E32_V_MF2_MASK }, // 394 + { 0x6, 0x1, 0x1, 0x0, 0x6, 0x0, PseudoVLSSEG6E64_V_M1_MASK }, // 395 + { 0x7, 0x0, 0x0, 0x0, 0x3, 0x0, PseudoVLSEG7E8_V_M1 }, // 396 + { 0x7, 0x0, 0x0, 0x0, 0x3, 0x5, PseudoVLSEG7E8_V_MF8 }, // 397 + { 0x7, 0x0, 0x0, 0x0, 0x3, 0x6, PseudoVLSEG7E8_V_MF4 }, // 398 + { 0x7, 0x0, 0x0, 0x0, 0x3, 0x7, PseudoVLSEG7E8_V_MF2 }, // 399 + { 0x7, 0x0, 0x0, 0x0, 0x4, 0x0, PseudoVLSEG7E16_V_M1 }, // 400 + { 0x7, 0x0, 0x0, 0x0, 0x4, 0x6, PseudoVLSEG7E16_V_MF4 }, // 401 + { 0x7, 0x0, 0x0, 0x0, 0x4, 0x7, PseudoVLSEG7E16_V_MF2 }, // 402 + { 0x7, 0x0, 0x0, 0x0, 0x5, 0x0, PseudoVLSEG7E32_V_M1 }, // 403 + { 0x7, 0x0, 0x0, 0x0, 0x5, 0x7, PseudoVLSEG7E32_V_MF2 }, // 404 + { 0x7, 0x0, 0x0, 0x0, 0x6, 0x0, PseudoVLSEG7E64_V_M1 }, // 405 + { 0x7, 0x0, 0x0, 0x1, 0x3, 0x0, PseudoVLSEG7E8FF_V_M1 }, // 406 + { 0x7, 0x0, 0x0, 0x1, 0x3, 0x5, PseudoVLSEG7E8FF_V_MF8 }, // 407 + { 0x7, 0x0, 0x0, 0x1, 0x3, 0x6, PseudoVLSEG7E8FF_V_MF4 }, // 408 + { 0x7, 0x0, 0x0, 0x1, 0x3, 0x7, PseudoVLSEG7E8FF_V_MF2 }, // 409 + { 0x7, 0x0, 0x0, 0x1, 0x4, 0x0, PseudoVLSEG7E16FF_V_M1 }, // 410 + { 0x7, 0x0, 0x0, 0x1, 0x4, 0x6, PseudoVLSEG7E16FF_V_MF4 }, // 411 + { 0x7, 0x0, 0x0, 0x1, 0x4, 0x7, PseudoVLSEG7E16FF_V_MF2 }, // 412 + { 0x7, 0x0, 0x0, 0x1, 0x5, 0x0, PseudoVLSEG7E32FF_V_M1 }, // 413 + { 0x7, 0x0, 0x0, 0x1, 0x5, 0x7, PseudoVLSEG7E32FF_V_MF2 }, // 414 + { 0x7, 0x0, 0x0, 0x1, 0x6, 0x0, PseudoVLSEG7E64FF_V_M1 }, // 415 + { 0x7, 0x0, 0x1, 0x0, 0x3, 0x0, PseudoVLSSEG7E8_V_M1 }, // 416 + { 0x7, 0x0, 0x1, 0x0, 0x3, 0x5, PseudoVLSSEG7E8_V_MF8 }, // 417 + { 0x7, 0x0, 0x1, 0x0, 0x3, 0x6, PseudoVLSSEG7E8_V_MF4 }, // 418 + { 0x7, 0x0, 0x1, 0x0, 0x3, 0x7, PseudoVLSSEG7E8_V_MF2 }, // 419 + { 0x7, 0x0, 0x1, 0x0, 0x4, 0x0, PseudoVLSSEG7E16_V_M1 }, // 420 + { 0x7, 0x0, 0x1, 0x0, 0x4, 0x6, PseudoVLSSEG7E16_V_MF4 }, // 421 + { 0x7, 0x0, 0x1, 0x0, 0x4, 0x7, PseudoVLSSEG7E16_V_MF2 }, // 422 + { 0x7, 0x0, 0x1, 0x0, 0x5, 0x0, PseudoVLSSEG7E32_V_M1 }, // 423 + { 0x7, 0x0, 0x1, 0x0, 0x5, 0x7, PseudoVLSSEG7E32_V_MF2 }, // 424 + { 0x7, 0x0, 0x1, 0x0, 0x6, 0x0, PseudoVLSSEG7E64_V_M1 }, // 425 + { 0x7, 0x1, 0x0, 0x0, 0x3, 0x0, PseudoVLSEG7E8_V_M1_MASK }, // 426 + { 0x7, 0x1, 0x0, 0x0, 0x3, 0x5, PseudoVLSEG7E8_V_MF8_MASK }, // 427 + { 0x7, 0x1, 0x0, 0x0, 0x3, 0x6, PseudoVLSEG7E8_V_MF4_MASK }, // 428 + { 0x7, 0x1, 0x0, 0x0, 0x3, 0x7, PseudoVLSEG7E8_V_MF2_MASK }, // 429 + { 0x7, 0x1, 0x0, 0x0, 0x4, 0x0, PseudoVLSEG7E16_V_M1_MASK }, // 430 + { 0x7, 0x1, 0x0, 0x0, 0x4, 0x6, PseudoVLSEG7E16_V_MF4_MASK }, // 431 + { 0x7, 0x1, 0x0, 0x0, 0x4, 0x7, PseudoVLSEG7E16_V_MF2_MASK }, // 432 + { 0x7, 0x1, 0x0, 0x0, 0x5, 0x0, PseudoVLSEG7E32_V_M1_MASK }, // 433 + { 0x7, 0x1, 0x0, 0x0, 0x5, 0x7, PseudoVLSEG7E32_V_MF2_MASK }, // 434 + { 0x7, 0x1, 0x0, 0x0, 0x6, 0x0, PseudoVLSEG7E64_V_M1_MASK }, // 435 + { 0x7, 0x1, 0x0, 0x1, 0x3, 0x0, PseudoVLSEG7E8FF_V_M1_MASK }, // 436 + { 0x7, 0x1, 0x0, 0x1, 0x3, 0x5, PseudoVLSEG7E8FF_V_MF8_MASK }, // 437 + { 0x7, 0x1, 0x0, 0x1, 0x3, 0x6, PseudoVLSEG7E8FF_V_MF4_MASK }, // 438 + { 0x7, 0x1, 0x0, 0x1, 0x3, 0x7, PseudoVLSEG7E8FF_V_MF2_MASK }, // 439 + { 0x7, 0x1, 0x0, 0x1, 0x4, 0x0, PseudoVLSEG7E16FF_V_M1_MASK }, // 440 + { 0x7, 0x1, 0x0, 0x1, 0x4, 0x6, PseudoVLSEG7E16FF_V_MF4_MASK }, // 441 + { 0x7, 0x1, 0x0, 0x1, 0x4, 0x7, PseudoVLSEG7E16FF_V_MF2_MASK }, // 442 + { 0x7, 0x1, 0x0, 0x1, 0x5, 0x0, PseudoVLSEG7E32FF_V_M1_MASK }, // 443 + { 0x7, 0x1, 0x0, 0x1, 0x5, 0x7, PseudoVLSEG7E32FF_V_MF2_MASK }, // 444 + { 0x7, 0x1, 0x0, 0x1, 0x6, 0x0, PseudoVLSEG7E64FF_V_M1_MASK }, // 445 + { 0x7, 0x1, 0x1, 0x0, 0x3, 0x0, PseudoVLSSEG7E8_V_M1_MASK }, // 446 + { 0x7, 0x1, 0x1, 0x0, 0x3, 0x5, PseudoVLSSEG7E8_V_MF8_MASK }, // 447 + { 0x7, 0x1, 0x1, 0x0, 0x3, 0x6, PseudoVLSSEG7E8_V_MF4_MASK }, // 448 + { 0x7, 0x1, 0x1, 0x0, 0x3, 0x7, PseudoVLSSEG7E8_V_MF2_MASK }, // 449 + { 0x7, 0x1, 0x1, 0x0, 0x4, 0x0, PseudoVLSSEG7E16_V_M1_MASK }, // 450 + { 0x7, 0x1, 0x1, 0x0, 0x4, 0x6, PseudoVLSSEG7E16_V_MF4_MASK }, // 451 + { 0x7, 0x1, 0x1, 0x0, 0x4, 0x7, PseudoVLSSEG7E16_V_MF2_MASK }, // 452 + { 0x7, 0x1, 0x1, 0x0, 0x5, 0x0, PseudoVLSSEG7E32_V_M1_MASK }, // 453 + { 0x7, 0x1, 0x1, 0x0, 0x5, 0x7, PseudoVLSSEG7E32_V_MF2_MASK }, // 454 + { 0x7, 0x1, 0x1, 0x0, 0x6, 0x0, PseudoVLSSEG7E64_V_M1_MASK }, // 455 + { 0x8, 0x0, 0x0, 0x0, 0x3, 0x0, PseudoVLSEG8E8_V_M1 }, // 456 + { 0x8, 0x0, 0x0, 0x0, 0x3, 0x5, PseudoVLSEG8E8_V_MF8 }, // 457 + { 0x8, 0x0, 0x0, 0x0, 0x3, 0x6, PseudoVLSEG8E8_V_MF4 }, // 458 + { 0x8, 0x0, 0x0, 0x0, 0x3, 0x7, PseudoVLSEG8E8_V_MF2 }, // 459 + { 0x8, 0x0, 0x0, 0x0, 0x4, 0x0, PseudoVLSEG8E16_V_M1 }, // 460 + { 0x8, 0x0, 0x0, 0x0, 0x4, 0x6, PseudoVLSEG8E16_V_MF4 }, // 461 + { 0x8, 0x0, 0x0, 0x0, 0x4, 0x7, PseudoVLSEG8E16_V_MF2 }, // 462 + { 0x8, 0x0, 0x0, 0x0, 0x5, 0x0, PseudoVLSEG8E32_V_M1 }, // 463 + { 0x8, 0x0, 0x0, 0x0, 0x5, 0x7, PseudoVLSEG8E32_V_MF2 }, // 464 + { 0x8, 0x0, 0x0, 0x0, 0x6, 0x0, PseudoVLSEG8E64_V_M1 }, // 465 + { 0x8, 0x0, 0x0, 0x1, 0x3, 0x0, PseudoVLSEG8E8FF_V_M1 }, // 466 + { 0x8, 0x0, 0x0, 0x1, 0x3, 0x5, PseudoVLSEG8E8FF_V_MF8 }, // 467 + { 0x8, 0x0, 0x0, 0x1, 0x3, 0x6, PseudoVLSEG8E8FF_V_MF4 }, // 468 + { 0x8, 0x0, 0x0, 0x1, 0x3, 0x7, PseudoVLSEG8E8FF_V_MF2 }, // 469 + { 0x8, 0x0, 0x0, 0x1, 0x4, 0x0, PseudoVLSEG8E16FF_V_M1 }, // 470 + { 0x8, 0x0, 0x0, 0x1, 0x4, 0x6, PseudoVLSEG8E16FF_V_MF4 }, // 471 + { 0x8, 0x0, 0x0, 0x1, 0x4, 0x7, PseudoVLSEG8E16FF_V_MF2 }, // 472 + { 0x8, 0x0, 0x0, 0x1, 0x5, 0x0, PseudoVLSEG8E32FF_V_M1 }, // 473 + { 0x8, 0x0, 0x0, 0x1, 0x5, 0x7, PseudoVLSEG8E32FF_V_MF2 }, // 474 + { 0x8, 0x0, 0x0, 0x1, 0x6, 0x0, PseudoVLSEG8E64FF_V_M1 }, // 475 + { 0x8, 0x0, 0x1, 0x0, 0x3, 0x0, PseudoVLSSEG8E8_V_M1 }, // 476 + { 0x8, 0x0, 0x1, 0x0, 0x3, 0x5, PseudoVLSSEG8E8_V_MF8 }, // 477 + { 0x8, 0x0, 0x1, 0x0, 0x3, 0x6, PseudoVLSSEG8E8_V_MF4 }, // 478 + { 0x8, 0x0, 0x1, 0x0, 0x3, 0x7, PseudoVLSSEG8E8_V_MF2 }, // 479 + { 0x8, 0x0, 0x1, 0x0, 0x4, 0x0, PseudoVLSSEG8E16_V_M1 }, // 480 + { 0x8, 0x0, 0x1, 0x0, 0x4, 0x6, PseudoVLSSEG8E16_V_MF4 }, // 481 + { 0x8, 0x0, 0x1, 0x0, 0x4, 0x7, PseudoVLSSEG8E16_V_MF2 }, // 482 + { 0x8, 0x0, 0x1, 0x0, 0x5, 0x0, PseudoVLSSEG8E32_V_M1 }, // 483 + { 0x8, 0x0, 0x1, 0x0, 0x5, 0x7, PseudoVLSSEG8E32_V_MF2 }, // 484 + { 0x8, 0x0, 0x1, 0x0, 0x6, 0x0, PseudoVLSSEG8E64_V_M1 }, // 485 + { 0x8, 0x1, 0x0, 0x0, 0x3, 0x0, PseudoVLSEG8E8_V_M1_MASK }, // 486 + { 0x8, 0x1, 0x0, 0x0, 0x3, 0x5, PseudoVLSEG8E8_V_MF8_MASK }, // 487 + { 0x8, 0x1, 0x0, 0x0, 0x3, 0x6, PseudoVLSEG8E8_V_MF4_MASK }, // 488 + { 0x8, 0x1, 0x0, 0x0, 0x3, 0x7, PseudoVLSEG8E8_V_MF2_MASK }, // 489 + { 0x8, 0x1, 0x0, 0x0, 0x4, 0x0, PseudoVLSEG8E16_V_M1_MASK }, // 490 + { 0x8, 0x1, 0x0, 0x0, 0x4, 0x6, PseudoVLSEG8E16_V_MF4_MASK }, // 491 + { 0x8, 0x1, 0x0, 0x0, 0x4, 0x7, PseudoVLSEG8E16_V_MF2_MASK }, // 492 + { 0x8, 0x1, 0x0, 0x0, 0x5, 0x0, PseudoVLSEG8E32_V_M1_MASK }, // 493 + { 0x8, 0x1, 0x0, 0x0, 0x5, 0x7, PseudoVLSEG8E32_V_MF2_MASK }, // 494 + { 0x8, 0x1, 0x0, 0x0, 0x6, 0x0, PseudoVLSEG8E64_V_M1_MASK }, // 495 + { 0x8, 0x1, 0x0, 0x1, 0x3, 0x0, PseudoVLSEG8E8FF_V_M1_MASK }, // 496 + { 0x8, 0x1, 0x0, 0x1, 0x3, 0x5, PseudoVLSEG8E8FF_V_MF8_MASK }, // 497 + { 0x8, 0x1, 0x0, 0x1, 0x3, 0x6, PseudoVLSEG8E8FF_V_MF4_MASK }, // 498 + { 0x8, 0x1, 0x0, 0x1, 0x3, 0x7, PseudoVLSEG8E8FF_V_MF2_MASK }, // 499 + { 0x8, 0x1, 0x0, 0x1, 0x4, 0x0, PseudoVLSEG8E16FF_V_M1_MASK }, // 500 + { 0x8, 0x1, 0x0, 0x1, 0x4, 0x6, PseudoVLSEG8E16FF_V_MF4_MASK }, // 501 + { 0x8, 0x1, 0x0, 0x1, 0x4, 0x7, PseudoVLSEG8E16FF_V_MF2_MASK }, // 502 + { 0x8, 0x1, 0x0, 0x1, 0x5, 0x0, PseudoVLSEG8E32FF_V_M1_MASK }, // 503 + { 0x8, 0x1, 0x0, 0x1, 0x5, 0x7, PseudoVLSEG8E32FF_V_MF2_MASK }, // 504 + { 0x8, 0x1, 0x0, 0x1, 0x6, 0x0, PseudoVLSEG8E64FF_V_M1_MASK }, // 505 + { 0x8, 0x1, 0x1, 0x0, 0x3, 0x0, PseudoVLSSEG8E8_V_M1_MASK }, // 506 + { 0x8, 0x1, 0x1, 0x0, 0x3, 0x5, PseudoVLSSEG8E8_V_MF8_MASK }, // 507 + { 0x8, 0x1, 0x1, 0x0, 0x3, 0x6, PseudoVLSSEG8E8_V_MF4_MASK }, // 508 + { 0x8, 0x1, 0x1, 0x0, 0x3, 0x7, PseudoVLSSEG8E8_V_MF2_MASK }, // 509 + { 0x8, 0x1, 0x1, 0x0, 0x4, 0x0, PseudoVLSSEG8E16_V_M1_MASK }, // 510 + { 0x8, 0x1, 0x1, 0x0, 0x4, 0x6, PseudoVLSSEG8E16_V_MF4_MASK }, // 511 + { 0x8, 0x1, 0x1, 0x0, 0x4, 0x7, PseudoVLSSEG8E16_V_MF2_MASK }, // 512 + { 0x8, 0x1, 0x1, 0x0, 0x5, 0x0, PseudoVLSSEG8E32_V_M1_MASK }, // 513 + { 0x8, 0x1, 0x1, 0x0, 0x5, 0x7, PseudoVLSSEG8E32_V_MF2_MASK }, // 514 + { 0x8, 0x1, 0x1, 0x0, 0x6, 0x0, PseudoVLSSEG8E64_V_M1_MASK }, // 515 + }; + +const RISCV_VLSEGPseudo *RISCV_getVLSEGPseudo(uint8_t NF, uint8_t Masked, uint8_t Strided, uint8_t FF, uint8_t Log2SEW, uint8_t LMUL) { + unsigned i = binsearch_IndexTypeEncoding(Index, ARR_SIZE(Index), NFMaskedStridedFFLog2SEWLMUL); + if (i == -1) + return NULL; + else + return &RISCVVLSEGTable[Index[i].index]; +} + +#endif + +#ifdef GET_RISCVVLXSEGTable_IMPL +static const RISCV_VLXSEGPseudo RISCVVLXSEGTable[] = { + { 0x2, 0x0, 0x0, 0x3, 0x0, 0x0, PseudoVLUXSEG2EI8_V_M1_M1 }, // 0 + { 0x2, 0x0, 0x0, 0x3, 0x0, 0x5, PseudoVLUXSEG2EI8_V_MF8_M1 }, // 1 + { 0x2, 0x0, 0x0, 0x3, 0x0, 0x6, PseudoVLUXSEG2EI8_V_MF4_M1 }, // 2 + { 0x2, 0x0, 0x0, 0x3, 0x0, 0x7, PseudoVLUXSEG2EI8_V_MF2_M1 }, // 3 + { 0x2, 0x0, 0x0, 0x3, 0x1, 0x0, PseudoVLUXSEG2EI8_V_M1_M2 }, // 4 + { 0x2, 0x0, 0x0, 0x3, 0x1, 0x1, PseudoVLUXSEG2EI8_V_M2_M2 }, // 5 + { 0x2, 0x0, 0x0, 0x3, 0x1, 0x6, PseudoVLUXSEG2EI8_V_MF4_M2 }, // 6 + { 0x2, 0x0, 0x0, 0x3, 0x1, 0x7, PseudoVLUXSEG2EI8_V_MF2_M2 }, // 7 + { 0x2, 0x0, 0x0, 0x3, 0x2, 0x0, PseudoVLUXSEG2EI8_V_M1_M4 }, // 8 + { 0x2, 0x0, 0x0, 0x3, 0x2, 0x1, PseudoVLUXSEG2EI8_V_M2_M4 }, // 9 + { 0x2, 0x0, 0x0, 0x3, 0x2, 0x2, PseudoVLUXSEG2EI8_V_M4_M4 }, // 10 + { 0x2, 0x0, 0x0, 0x3, 0x2, 0x7, PseudoVLUXSEG2EI8_V_MF2_M4 }, // 11 + { 0x2, 0x0, 0x0, 0x3, 0x5, 0x5, PseudoVLUXSEG2EI8_V_MF8_MF8 }, // 12 + { 0x2, 0x0, 0x0, 0x3, 0x6, 0x5, PseudoVLUXSEG2EI8_V_MF8_MF4 }, // 13 + { 0x2, 0x0, 0x0, 0x3, 0x6, 0x6, PseudoVLUXSEG2EI8_V_MF4_MF4 }, // 14 + { 0x2, 0x0, 0x0, 0x3, 0x7, 0x5, PseudoVLUXSEG2EI8_V_MF8_MF2 }, // 15 + { 0x2, 0x0, 0x0, 0x3, 0x7, 0x6, PseudoVLUXSEG2EI8_V_MF4_MF2 }, // 16 + { 0x2, 0x0, 0x0, 0x3, 0x7, 0x7, PseudoVLUXSEG2EI8_V_MF2_MF2 }, // 17 + { 0x2, 0x0, 0x0, 0x4, 0x0, 0x0, PseudoVLUXSEG2EI16_V_M1_M1 }, // 18 + { 0x2, 0x0, 0x0, 0x4, 0x0, 0x1, PseudoVLUXSEG2EI16_V_M2_M1 }, // 19 + { 0x2, 0x0, 0x0, 0x4, 0x0, 0x6, PseudoVLUXSEG2EI16_V_MF4_M1 }, // 20 + { 0x2, 0x0, 0x0, 0x4, 0x0, 0x7, PseudoVLUXSEG2EI16_V_MF2_M1 }, // 21 + { 0x2, 0x0, 0x0, 0x4, 0x1, 0x0, PseudoVLUXSEG2EI16_V_M1_M2 }, // 22 + { 0x2, 0x0, 0x0, 0x4, 0x1, 0x1, PseudoVLUXSEG2EI16_V_M2_M2 }, // 23 + { 0x2, 0x0, 0x0, 0x4, 0x1, 0x2, PseudoVLUXSEG2EI16_V_M4_M2 }, // 24 + { 0x2, 0x0, 0x0, 0x4, 0x1, 0x7, PseudoVLUXSEG2EI16_V_MF2_M2 }, // 25 + { 0x2, 0x0, 0x0, 0x4, 0x2, 0x0, PseudoVLUXSEG2EI16_V_M1_M4 }, // 26 + { 0x2, 0x0, 0x0, 0x4, 0x2, 0x1, PseudoVLUXSEG2EI16_V_M2_M4 }, // 27 + { 0x2, 0x0, 0x0, 0x4, 0x2, 0x2, PseudoVLUXSEG2EI16_V_M4_M4 }, // 28 + { 0x2, 0x0, 0x0, 0x4, 0x2, 0x3, PseudoVLUXSEG2EI16_V_M8_M4 }, // 29 + { 0x2, 0x0, 0x0, 0x4, 0x5, 0x6, PseudoVLUXSEG2EI16_V_MF4_MF8 }, // 30 + { 0x2, 0x0, 0x0, 0x4, 0x6, 0x6, PseudoVLUXSEG2EI16_V_MF4_MF4 }, // 31 + { 0x2, 0x0, 0x0, 0x4, 0x6, 0x7, PseudoVLUXSEG2EI16_V_MF2_MF4 }, // 32 + { 0x2, 0x0, 0x0, 0x4, 0x7, 0x0, PseudoVLUXSEG2EI16_V_M1_MF2 }, // 33 + { 0x2, 0x0, 0x0, 0x4, 0x7, 0x6, PseudoVLUXSEG2EI16_V_MF4_MF2 }, // 34 + { 0x2, 0x0, 0x0, 0x4, 0x7, 0x7, PseudoVLUXSEG2EI16_V_MF2_MF2 }, // 35 + { 0x2, 0x0, 0x0, 0x5, 0x0, 0x0, PseudoVLUXSEG2EI32_V_M1_M1 }, // 36 + { 0x2, 0x0, 0x0, 0x5, 0x0, 0x1, PseudoVLUXSEG2EI32_V_M2_M1 }, // 37 + { 0x2, 0x0, 0x0, 0x5, 0x0, 0x2, PseudoVLUXSEG2EI32_V_M4_M1 }, // 38 + { 0x2, 0x0, 0x0, 0x5, 0x0, 0x7, PseudoVLUXSEG2EI32_V_MF2_M1 }, // 39 + { 0x2, 0x0, 0x0, 0x5, 0x1, 0x0, PseudoVLUXSEG2EI32_V_M1_M2 }, // 40 + { 0x2, 0x0, 0x0, 0x5, 0x1, 0x1, PseudoVLUXSEG2EI32_V_M2_M2 }, // 41 + { 0x2, 0x0, 0x0, 0x5, 0x1, 0x2, PseudoVLUXSEG2EI32_V_M4_M2 }, // 42 + { 0x2, 0x0, 0x0, 0x5, 0x1, 0x3, PseudoVLUXSEG2EI32_V_M8_M2 }, // 43 + { 0x2, 0x0, 0x0, 0x5, 0x2, 0x1, PseudoVLUXSEG2EI32_V_M2_M4 }, // 44 + { 0x2, 0x0, 0x0, 0x5, 0x2, 0x2, PseudoVLUXSEG2EI32_V_M4_M4 }, // 45 + { 0x2, 0x0, 0x0, 0x5, 0x2, 0x3, PseudoVLUXSEG2EI32_V_M8_M4 }, // 46 + { 0x2, 0x0, 0x0, 0x5, 0x5, 0x7, PseudoVLUXSEG2EI32_V_MF2_MF8 }, // 47 + { 0x2, 0x0, 0x0, 0x5, 0x6, 0x0, PseudoVLUXSEG2EI32_V_M1_MF4 }, // 48 + { 0x2, 0x0, 0x0, 0x5, 0x6, 0x7, PseudoVLUXSEG2EI32_V_MF2_MF4 }, // 49 + { 0x2, 0x0, 0x0, 0x5, 0x7, 0x0, PseudoVLUXSEG2EI32_V_M1_MF2 }, // 50 + { 0x2, 0x0, 0x0, 0x5, 0x7, 0x1, PseudoVLUXSEG2EI32_V_M2_MF2 }, // 51 + { 0x2, 0x0, 0x0, 0x5, 0x7, 0x7, PseudoVLUXSEG2EI32_V_MF2_MF2 }, // 52 + { 0x2, 0x0, 0x0, 0x6, 0x0, 0x0, PseudoVLUXSEG2EI64_V_M1_M1 }, // 53 + { 0x2, 0x0, 0x0, 0x6, 0x0, 0x1, PseudoVLUXSEG2EI64_V_M2_M1 }, // 54 + { 0x2, 0x0, 0x0, 0x6, 0x0, 0x2, PseudoVLUXSEG2EI64_V_M4_M1 }, // 55 + { 0x2, 0x0, 0x0, 0x6, 0x0, 0x3, PseudoVLUXSEG2EI64_V_M8_M1 }, // 56 + { 0x2, 0x0, 0x0, 0x6, 0x1, 0x1, PseudoVLUXSEG2EI64_V_M2_M2 }, // 57 + { 0x2, 0x0, 0x0, 0x6, 0x1, 0x2, PseudoVLUXSEG2EI64_V_M4_M2 }, // 58 + { 0x2, 0x0, 0x0, 0x6, 0x1, 0x3, PseudoVLUXSEG2EI64_V_M8_M2 }, // 59 + { 0x2, 0x0, 0x0, 0x6, 0x2, 0x2, PseudoVLUXSEG2EI64_V_M4_M4 }, // 60 + { 0x2, 0x0, 0x0, 0x6, 0x2, 0x3, PseudoVLUXSEG2EI64_V_M8_M4 }, // 61 + { 0x2, 0x0, 0x0, 0x6, 0x5, 0x0, PseudoVLUXSEG2EI64_V_M1_MF8 }, // 62 + { 0x2, 0x0, 0x0, 0x6, 0x6, 0x0, PseudoVLUXSEG2EI64_V_M1_MF4 }, // 63 + { 0x2, 0x0, 0x0, 0x6, 0x6, 0x1, PseudoVLUXSEG2EI64_V_M2_MF4 }, // 64 + { 0x2, 0x0, 0x0, 0x6, 0x7, 0x0, PseudoVLUXSEG2EI64_V_M1_MF2 }, // 65 + { 0x2, 0x0, 0x0, 0x6, 0x7, 0x1, PseudoVLUXSEG2EI64_V_M2_MF2 }, // 66 + { 0x2, 0x0, 0x0, 0x6, 0x7, 0x2, PseudoVLUXSEG2EI64_V_M4_MF2 }, // 67 + { 0x2, 0x0, 0x1, 0x3, 0x0, 0x0, PseudoVLOXSEG2EI8_V_M1_M1 }, // 68 + { 0x2, 0x0, 0x1, 0x3, 0x0, 0x5, PseudoVLOXSEG2EI8_V_MF8_M1 }, // 69 + { 0x2, 0x0, 0x1, 0x3, 0x0, 0x6, PseudoVLOXSEG2EI8_V_MF4_M1 }, // 70 + { 0x2, 0x0, 0x1, 0x3, 0x0, 0x7, PseudoVLOXSEG2EI8_V_MF2_M1 }, // 71 + { 0x2, 0x0, 0x1, 0x3, 0x1, 0x0, PseudoVLOXSEG2EI8_V_M1_M2 }, // 72 + { 0x2, 0x0, 0x1, 0x3, 0x1, 0x1, PseudoVLOXSEG2EI8_V_M2_M2 }, // 73 + { 0x2, 0x0, 0x1, 0x3, 0x1, 0x6, PseudoVLOXSEG2EI8_V_MF4_M2 }, // 74 + { 0x2, 0x0, 0x1, 0x3, 0x1, 0x7, PseudoVLOXSEG2EI8_V_MF2_M2 }, // 75 + { 0x2, 0x0, 0x1, 0x3, 0x2, 0x0, PseudoVLOXSEG2EI8_V_M1_M4 }, // 76 + { 0x2, 0x0, 0x1, 0x3, 0x2, 0x1, PseudoVLOXSEG2EI8_V_M2_M4 }, // 77 + { 0x2, 0x0, 0x1, 0x3, 0x2, 0x2, PseudoVLOXSEG2EI8_V_M4_M4 }, // 78 + { 0x2, 0x0, 0x1, 0x3, 0x2, 0x7, PseudoVLOXSEG2EI8_V_MF2_M4 }, // 79 + { 0x2, 0x0, 0x1, 0x3, 0x5, 0x5, PseudoVLOXSEG2EI8_V_MF8_MF8 }, // 80 + { 0x2, 0x0, 0x1, 0x3, 0x6, 0x5, PseudoVLOXSEG2EI8_V_MF8_MF4 }, // 81 + { 0x2, 0x0, 0x1, 0x3, 0x6, 0x6, PseudoVLOXSEG2EI8_V_MF4_MF4 }, // 82 + { 0x2, 0x0, 0x1, 0x3, 0x7, 0x5, PseudoVLOXSEG2EI8_V_MF8_MF2 }, // 83 + { 0x2, 0x0, 0x1, 0x3, 0x7, 0x6, PseudoVLOXSEG2EI8_V_MF4_MF2 }, // 84 + { 0x2, 0x0, 0x1, 0x3, 0x7, 0x7, PseudoVLOXSEG2EI8_V_MF2_MF2 }, // 85 + { 0x2, 0x0, 0x1, 0x4, 0x0, 0x0, PseudoVLOXSEG2EI16_V_M1_M1 }, // 86 + { 0x2, 0x0, 0x1, 0x4, 0x0, 0x1, PseudoVLOXSEG2EI16_V_M2_M1 }, // 87 + { 0x2, 0x0, 0x1, 0x4, 0x0, 0x6, PseudoVLOXSEG2EI16_V_MF4_M1 }, // 88 + { 0x2, 0x0, 0x1, 0x4, 0x0, 0x7, PseudoVLOXSEG2EI16_V_MF2_M1 }, // 89 + { 0x2, 0x0, 0x1, 0x4, 0x1, 0x0, PseudoVLOXSEG2EI16_V_M1_M2 }, // 90 + { 0x2, 0x0, 0x1, 0x4, 0x1, 0x1, PseudoVLOXSEG2EI16_V_M2_M2 }, // 91 + { 0x2, 0x0, 0x1, 0x4, 0x1, 0x2, PseudoVLOXSEG2EI16_V_M4_M2 }, // 92 + { 0x2, 0x0, 0x1, 0x4, 0x1, 0x7, PseudoVLOXSEG2EI16_V_MF2_M2 }, // 93 + { 0x2, 0x0, 0x1, 0x4, 0x2, 0x0, PseudoVLOXSEG2EI16_V_M1_M4 }, // 94 + { 0x2, 0x0, 0x1, 0x4, 0x2, 0x1, PseudoVLOXSEG2EI16_V_M2_M4 }, // 95 + { 0x2, 0x0, 0x1, 0x4, 0x2, 0x2, PseudoVLOXSEG2EI16_V_M4_M4 }, // 96 + { 0x2, 0x0, 0x1, 0x4, 0x2, 0x3, PseudoVLOXSEG2EI16_V_M8_M4 }, // 97 + { 0x2, 0x0, 0x1, 0x4, 0x5, 0x6, PseudoVLOXSEG2EI16_V_MF4_MF8 }, // 98 + { 0x2, 0x0, 0x1, 0x4, 0x6, 0x6, PseudoVLOXSEG2EI16_V_MF4_MF4 }, // 99 + { 0x2, 0x0, 0x1, 0x4, 0x6, 0x7, PseudoVLOXSEG2EI16_V_MF2_MF4 }, // 100 + { 0x2, 0x0, 0x1, 0x4, 0x7, 0x0, PseudoVLOXSEG2EI16_V_M1_MF2 }, // 101 + { 0x2, 0x0, 0x1, 0x4, 0x7, 0x6, PseudoVLOXSEG2EI16_V_MF4_MF2 }, // 102 + { 0x2, 0x0, 0x1, 0x4, 0x7, 0x7, PseudoVLOXSEG2EI16_V_MF2_MF2 }, // 103 + { 0x2, 0x0, 0x1, 0x5, 0x0, 0x0, PseudoVLOXSEG2EI32_V_M1_M1 }, // 104 + { 0x2, 0x0, 0x1, 0x5, 0x0, 0x1, PseudoVLOXSEG2EI32_V_M2_M1 }, // 105 + { 0x2, 0x0, 0x1, 0x5, 0x0, 0x2, PseudoVLOXSEG2EI32_V_M4_M1 }, // 106 + { 0x2, 0x0, 0x1, 0x5, 0x0, 0x7, PseudoVLOXSEG2EI32_V_MF2_M1 }, // 107 + { 0x2, 0x0, 0x1, 0x5, 0x1, 0x0, PseudoVLOXSEG2EI32_V_M1_M2 }, // 108 + { 0x2, 0x0, 0x1, 0x5, 0x1, 0x1, PseudoVLOXSEG2EI32_V_M2_M2 }, // 109 + { 0x2, 0x0, 0x1, 0x5, 0x1, 0x2, PseudoVLOXSEG2EI32_V_M4_M2 }, // 110 + { 0x2, 0x0, 0x1, 0x5, 0x1, 0x3, PseudoVLOXSEG2EI32_V_M8_M2 }, // 111 + { 0x2, 0x0, 0x1, 0x5, 0x2, 0x1, PseudoVLOXSEG2EI32_V_M2_M4 }, // 112 + { 0x2, 0x0, 0x1, 0x5, 0x2, 0x2, PseudoVLOXSEG2EI32_V_M4_M4 }, // 113 + { 0x2, 0x0, 0x1, 0x5, 0x2, 0x3, PseudoVLOXSEG2EI32_V_M8_M4 }, // 114 + { 0x2, 0x0, 0x1, 0x5, 0x5, 0x7, PseudoVLOXSEG2EI32_V_MF2_MF8 }, // 115 + { 0x2, 0x0, 0x1, 0x5, 0x6, 0x0, PseudoVLOXSEG2EI32_V_M1_MF4 }, // 116 + { 0x2, 0x0, 0x1, 0x5, 0x6, 0x7, PseudoVLOXSEG2EI32_V_MF2_MF4 }, // 117 + { 0x2, 0x0, 0x1, 0x5, 0x7, 0x0, PseudoVLOXSEG2EI32_V_M1_MF2 }, // 118 + { 0x2, 0x0, 0x1, 0x5, 0x7, 0x1, PseudoVLOXSEG2EI32_V_M2_MF2 }, // 119 + { 0x2, 0x0, 0x1, 0x5, 0x7, 0x7, PseudoVLOXSEG2EI32_V_MF2_MF2 }, // 120 + { 0x2, 0x0, 0x1, 0x6, 0x0, 0x0, PseudoVLOXSEG2EI64_V_M1_M1 }, // 121 + { 0x2, 0x0, 0x1, 0x6, 0x0, 0x1, PseudoVLOXSEG2EI64_V_M2_M1 }, // 122 + { 0x2, 0x0, 0x1, 0x6, 0x0, 0x2, PseudoVLOXSEG2EI64_V_M4_M1 }, // 123 + { 0x2, 0x0, 0x1, 0x6, 0x0, 0x3, PseudoVLOXSEG2EI64_V_M8_M1 }, // 124 + { 0x2, 0x0, 0x1, 0x6, 0x1, 0x1, PseudoVLOXSEG2EI64_V_M2_M2 }, // 125 + { 0x2, 0x0, 0x1, 0x6, 0x1, 0x2, PseudoVLOXSEG2EI64_V_M4_M2 }, // 126 + { 0x2, 0x0, 0x1, 0x6, 0x1, 0x3, PseudoVLOXSEG2EI64_V_M8_M2 }, // 127 + { 0x2, 0x0, 0x1, 0x6, 0x2, 0x2, PseudoVLOXSEG2EI64_V_M4_M4 }, // 128 + { 0x2, 0x0, 0x1, 0x6, 0x2, 0x3, PseudoVLOXSEG2EI64_V_M8_M4 }, // 129 + { 0x2, 0x0, 0x1, 0x6, 0x5, 0x0, PseudoVLOXSEG2EI64_V_M1_MF8 }, // 130 + { 0x2, 0x0, 0x1, 0x6, 0x6, 0x0, PseudoVLOXSEG2EI64_V_M1_MF4 }, // 131 + { 0x2, 0x0, 0x1, 0x6, 0x6, 0x1, PseudoVLOXSEG2EI64_V_M2_MF4 }, // 132 + { 0x2, 0x0, 0x1, 0x6, 0x7, 0x0, PseudoVLOXSEG2EI64_V_M1_MF2 }, // 133 + { 0x2, 0x0, 0x1, 0x6, 0x7, 0x1, PseudoVLOXSEG2EI64_V_M2_MF2 }, // 134 + { 0x2, 0x0, 0x1, 0x6, 0x7, 0x2, PseudoVLOXSEG2EI64_V_M4_MF2 }, // 135 + { 0x2, 0x1, 0x0, 0x3, 0x0, 0x0, PseudoVLUXSEG2EI8_V_M1_M1_MASK }, // 136 + { 0x2, 0x1, 0x0, 0x3, 0x0, 0x5, PseudoVLUXSEG2EI8_V_MF8_M1_MASK }, // 137 + { 0x2, 0x1, 0x0, 0x3, 0x0, 0x6, PseudoVLUXSEG2EI8_V_MF4_M1_MASK }, // 138 + { 0x2, 0x1, 0x0, 0x3, 0x0, 0x7, PseudoVLUXSEG2EI8_V_MF2_M1_MASK }, // 139 + { 0x2, 0x1, 0x0, 0x3, 0x1, 0x0, PseudoVLUXSEG2EI8_V_M1_M2_MASK }, // 140 + { 0x2, 0x1, 0x0, 0x3, 0x1, 0x1, PseudoVLUXSEG2EI8_V_M2_M2_MASK }, // 141 + { 0x2, 0x1, 0x0, 0x3, 0x1, 0x6, PseudoVLUXSEG2EI8_V_MF4_M2_MASK }, // 142 + { 0x2, 0x1, 0x0, 0x3, 0x1, 0x7, PseudoVLUXSEG2EI8_V_MF2_M2_MASK }, // 143 + { 0x2, 0x1, 0x0, 0x3, 0x2, 0x0, PseudoVLUXSEG2EI8_V_M1_M4_MASK }, // 144 + { 0x2, 0x1, 0x0, 0x3, 0x2, 0x1, PseudoVLUXSEG2EI8_V_M2_M4_MASK }, // 145 + { 0x2, 0x1, 0x0, 0x3, 0x2, 0x2, PseudoVLUXSEG2EI8_V_M4_M4_MASK }, // 146 + { 0x2, 0x1, 0x0, 0x3, 0x2, 0x7, PseudoVLUXSEG2EI8_V_MF2_M4_MASK }, // 147 + { 0x2, 0x1, 0x0, 0x3, 0x5, 0x5, PseudoVLUXSEG2EI8_V_MF8_MF8_MASK }, // 148 + { 0x2, 0x1, 0x0, 0x3, 0x6, 0x5, PseudoVLUXSEG2EI8_V_MF8_MF4_MASK }, // 149 + { 0x2, 0x1, 0x0, 0x3, 0x6, 0x6, PseudoVLUXSEG2EI8_V_MF4_MF4_MASK }, // 150 + { 0x2, 0x1, 0x0, 0x3, 0x7, 0x5, PseudoVLUXSEG2EI8_V_MF8_MF2_MASK }, // 151 + { 0x2, 0x1, 0x0, 0x3, 0x7, 0x6, PseudoVLUXSEG2EI8_V_MF4_MF2_MASK }, // 152 + { 0x2, 0x1, 0x0, 0x3, 0x7, 0x7, PseudoVLUXSEG2EI8_V_MF2_MF2_MASK }, // 153 + { 0x2, 0x1, 0x0, 0x4, 0x0, 0x0, PseudoVLUXSEG2EI16_V_M1_M1_MASK }, // 154 + { 0x2, 0x1, 0x0, 0x4, 0x0, 0x1, PseudoVLUXSEG2EI16_V_M2_M1_MASK }, // 155 + { 0x2, 0x1, 0x0, 0x4, 0x0, 0x6, PseudoVLUXSEG2EI16_V_MF4_M1_MASK }, // 156 + { 0x2, 0x1, 0x0, 0x4, 0x0, 0x7, PseudoVLUXSEG2EI16_V_MF2_M1_MASK }, // 157 + { 0x2, 0x1, 0x0, 0x4, 0x1, 0x0, PseudoVLUXSEG2EI16_V_M1_M2_MASK }, // 158 + { 0x2, 0x1, 0x0, 0x4, 0x1, 0x1, PseudoVLUXSEG2EI16_V_M2_M2_MASK }, // 159 + { 0x2, 0x1, 0x0, 0x4, 0x1, 0x2, PseudoVLUXSEG2EI16_V_M4_M2_MASK }, // 160 + { 0x2, 0x1, 0x0, 0x4, 0x1, 0x7, PseudoVLUXSEG2EI16_V_MF2_M2_MASK }, // 161 + { 0x2, 0x1, 0x0, 0x4, 0x2, 0x0, PseudoVLUXSEG2EI16_V_M1_M4_MASK }, // 162 + { 0x2, 0x1, 0x0, 0x4, 0x2, 0x1, PseudoVLUXSEG2EI16_V_M2_M4_MASK }, // 163 + { 0x2, 0x1, 0x0, 0x4, 0x2, 0x2, PseudoVLUXSEG2EI16_V_M4_M4_MASK }, // 164 + { 0x2, 0x1, 0x0, 0x4, 0x2, 0x3, PseudoVLUXSEG2EI16_V_M8_M4_MASK }, // 165 + { 0x2, 0x1, 0x0, 0x4, 0x5, 0x6, PseudoVLUXSEG2EI16_V_MF4_MF8_MASK }, // 166 + { 0x2, 0x1, 0x0, 0x4, 0x6, 0x6, PseudoVLUXSEG2EI16_V_MF4_MF4_MASK }, // 167 + { 0x2, 0x1, 0x0, 0x4, 0x6, 0x7, PseudoVLUXSEG2EI16_V_MF2_MF4_MASK }, // 168 + { 0x2, 0x1, 0x0, 0x4, 0x7, 0x0, PseudoVLUXSEG2EI16_V_M1_MF2_MASK }, // 169 + { 0x2, 0x1, 0x0, 0x4, 0x7, 0x6, PseudoVLUXSEG2EI16_V_MF4_MF2_MASK }, // 170 + { 0x2, 0x1, 0x0, 0x4, 0x7, 0x7, PseudoVLUXSEG2EI16_V_MF2_MF2_MASK }, // 171 + { 0x2, 0x1, 0x0, 0x5, 0x0, 0x0, PseudoVLUXSEG2EI32_V_M1_M1_MASK }, // 172 + { 0x2, 0x1, 0x0, 0x5, 0x0, 0x1, PseudoVLUXSEG2EI32_V_M2_M1_MASK }, // 173 + { 0x2, 0x1, 0x0, 0x5, 0x0, 0x2, PseudoVLUXSEG2EI32_V_M4_M1_MASK }, // 174 + { 0x2, 0x1, 0x0, 0x5, 0x0, 0x7, PseudoVLUXSEG2EI32_V_MF2_M1_MASK }, // 175 + { 0x2, 0x1, 0x0, 0x5, 0x1, 0x0, PseudoVLUXSEG2EI32_V_M1_M2_MASK }, // 176 + { 0x2, 0x1, 0x0, 0x5, 0x1, 0x1, PseudoVLUXSEG2EI32_V_M2_M2_MASK }, // 177 + { 0x2, 0x1, 0x0, 0x5, 0x1, 0x2, PseudoVLUXSEG2EI32_V_M4_M2_MASK }, // 178 + { 0x2, 0x1, 0x0, 0x5, 0x1, 0x3, PseudoVLUXSEG2EI32_V_M8_M2_MASK }, // 179 + { 0x2, 0x1, 0x0, 0x5, 0x2, 0x1, PseudoVLUXSEG2EI32_V_M2_M4_MASK }, // 180 + { 0x2, 0x1, 0x0, 0x5, 0x2, 0x2, PseudoVLUXSEG2EI32_V_M4_M4_MASK }, // 181 + { 0x2, 0x1, 0x0, 0x5, 0x2, 0x3, PseudoVLUXSEG2EI32_V_M8_M4_MASK }, // 182 + { 0x2, 0x1, 0x0, 0x5, 0x5, 0x7, PseudoVLUXSEG2EI32_V_MF2_MF8_MASK }, // 183 + { 0x2, 0x1, 0x0, 0x5, 0x6, 0x0, PseudoVLUXSEG2EI32_V_M1_MF4_MASK }, // 184 + { 0x2, 0x1, 0x0, 0x5, 0x6, 0x7, PseudoVLUXSEG2EI32_V_MF2_MF4_MASK }, // 185 + { 0x2, 0x1, 0x0, 0x5, 0x7, 0x0, PseudoVLUXSEG2EI32_V_M1_MF2_MASK }, // 186 + { 0x2, 0x1, 0x0, 0x5, 0x7, 0x1, PseudoVLUXSEG2EI32_V_M2_MF2_MASK }, // 187 + { 0x2, 0x1, 0x0, 0x5, 0x7, 0x7, PseudoVLUXSEG2EI32_V_MF2_MF2_MASK }, // 188 + { 0x2, 0x1, 0x0, 0x6, 0x0, 0x0, PseudoVLUXSEG2EI64_V_M1_M1_MASK }, // 189 + { 0x2, 0x1, 0x0, 0x6, 0x0, 0x1, PseudoVLUXSEG2EI64_V_M2_M1_MASK }, // 190 + { 0x2, 0x1, 0x0, 0x6, 0x0, 0x2, PseudoVLUXSEG2EI64_V_M4_M1_MASK }, // 191 + { 0x2, 0x1, 0x0, 0x6, 0x0, 0x3, PseudoVLUXSEG2EI64_V_M8_M1_MASK }, // 192 + { 0x2, 0x1, 0x0, 0x6, 0x1, 0x1, PseudoVLUXSEG2EI64_V_M2_M2_MASK }, // 193 + { 0x2, 0x1, 0x0, 0x6, 0x1, 0x2, PseudoVLUXSEG2EI64_V_M4_M2_MASK }, // 194 + { 0x2, 0x1, 0x0, 0x6, 0x1, 0x3, PseudoVLUXSEG2EI64_V_M8_M2_MASK }, // 195 + { 0x2, 0x1, 0x0, 0x6, 0x2, 0x2, PseudoVLUXSEG2EI64_V_M4_M4_MASK }, // 196 + { 0x2, 0x1, 0x0, 0x6, 0x2, 0x3, PseudoVLUXSEG2EI64_V_M8_M4_MASK }, // 197 + { 0x2, 0x1, 0x0, 0x6, 0x5, 0x0, PseudoVLUXSEG2EI64_V_M1_MF8_MASK }, // 198 + { 0x2, 0x1, 0x0, 0x6, 0x6, 0x0, PseudoVLUXSEG2EI64_V_M1_MF4_MASK }, // 199 + { 0x2, 0x1, 0x0, 0x6, 0x6, 0x1, PseudoVLUXSEG2EI64_V_M2_MF4_MASK }, // 200 + { 0x2, 0x1, 0x0, 0x6, 0x7, 0x0, PseudoVLUXSEG2EI64_V_M1_MF2_MASK }, // 201 + { 0x2, 0x1, 0x0, 0x6, 0x7, 0x1, PseudoVLUXSEG2EI64_V_M2_MF2_MASK }, // 202 + { 0x2, 0x1, 0x0, 0x6, 0x7, 0x2, PseudoVLUXSEG2EI64_V_M4_MF2_MASK }, // 203 + { 0x2, 0x1, 0x1, 0x3, 0x0, 0x0, PseudoVLOXSEG2EI8_V_M1_M1_MASK }, // 204 + { 0x2, 0x1, 0x1, 0x3, 0x0, 0x5, PseudoVLOXSEG2EI8_V_MF8_M1_MASK }, // 205 + { 0x2, 0x1, 0x1, 0x3, 0x0, 0x6, PseudoVLOXSEG2EI8_V_MF4_M1_MASK }, // 206 + { 0x2, 0x1, 0x1, 0x3, 0x0, 0x7, PseudoVLOXSEG2EI8_V_MF2_M1_MASK }, // 207 + { 0x2, 0x1, 0x1, 0x3, 0x1, 0x0, PseudoVLOXSEG2EI8_V_M1_M2_MASK }, // 208 + { 0x2, 0x1, 0x1, 0x3, 0x1, 0x1, PseudoVLOXSEG2EI8_V_M2_M2_MASK }, // 209 + { 0x2, 0x1, 0x1, 0x3, 0x1, 0x6, PseudoVLOXSEG2EI8_V_MF4_M2_MASK }, // 210 + { 0x2, 0x1, 0x1, 0x3, 0x1, 0x7, PseudoVLOXSEG2EI8_V_MF2_M2_MASK }, // 211 + { 0x2, 0x1, 0x1, 0x3, 0x2, 0x0, PseudoVLOXSEG2EI8_V_M1_M4_MASK }, // 212 + { 0x2, 0x1, 0x1, 0x3, 0x2, 0x1, PseudoVLOXSEG2EI8_V_M2_M4_MASK }, // 213 + { 0x2, 0x1, 0x1, 0x3, 0x2, 0x2, PseudoVLOXSEG2EI8_V_M4_M4_MASK }, // 214 + { 0x2, 0x1, 0x1, 0x3, 0x2, 0x7, PseudoVLOXSEG2EI8_V_MF2_M4_MASK }, // 215 + { 0x2, 0x1, 0x1, 0x3, 0x5, 0x5, PseudoVLOXSEG2EI8_V_MF8_MF8_MASK }, // 216 + { 0x2, 0x1, 0x1, 0x3, 0x6, 0x5, PseudoVLOXSEG2EI8_V_MF8_MF4_MASK }, // 217 + { 0x2, 0x1, 0x1, 0x3, 0x6, 0x6, PseudoVLOXSEG2EI8_V_MF4_MF4_MASK }, // 218 + { 0x2, 0x1, 0x1, 0x3, 0x7, 0x5, PseudoVLOXSEG2EI8_V_MF8_MF2_MASK }, // 219 + { 0x2, 0x1, 0x1, 0x3, 0x7, 0x6, PseudoVLOXSEG2EI8_V_MF4_MF2_MASK }, // 220 + { 0x2, 0x1, 0x1, 0x3, 0x7, 0x7, PseudoVLOXSEG2EI8_V_MF2_MF2_MASK }, // 221 + { 0x2, 0x1, 0x1, 0x4, 0x0, 0x0, PseudoVLOXSEG2EI16_V_M1_M1_MASK }, // 222 + { 0x2, 0x1, 0x1, 0x4, 0x0, 0x1, PseudoVLOXSEG2EI16_V_M2_M1_MASK }, // 223 + { 0x2, 0x1, 0x1, 0x4, 0x0, 0x6, PseudoVLOXSEG2EI16_V_MF4_M1_MASK }, // 224 + { 0x2, 0x1, 0x1, 0x4, 0x0, 0x7, PseudoVLOXSEG2EI16_V_MF2_M1_MASK }, // 225 + { 0x2, 0x1, 0x1, 0x4, 0x1, 0x0, PseudoVLOXSEG2EI16_V_M1_M2_MASK }, // 226 + { 0x2, 0x1, 0x1, 0x4, 0x1, 0x1, PseudoVLOXSEG2EI16_V_M2_M2_MASK }, // 227 + { 0x2, 0x1, 0x1, 0x4, 0x1, 0x2, PseudoVLOXSEG2EI16_V_M4_M2_MASK }, // 228 + { 0x2, 0x1, 0x1, 0x4, 0x1, 0x7, PseudoVLOXSEG2EI16_V_MF2_M2_MASK }, // 229 + { 0x2, 0x1, 0x1, 0x4, 0x2, 0x0, PseudoVLOXSEG2EI16_V_M1_M4_MASK }, // 230 + { 0x2, 0x1, 0x1, 0x4, 0x2, 0x1, PseudoVLOXSEG2EI16_V_M2_M4_MASK }, // 231 + { 0x2, 0x1, 0x1, 0x4, 0x2, 0x2, PseudoVLOXSEG2EI16_V_M4_M4_MASK }, // 232 + { 0x2, 0x1, 0x1, 0x4, 0x2, 0x3, PseudoVLOXSEG2EI16_V_M8_M4_MASK }, // 233 + { 0x2, 0x1, 0x1, 0x4, 0x5, 0x6, PseudoVLOXSEG2EI16_V_MF4_MF8_MASK }, // 234 + { 0x2, 0x1, 0x1, 0x4, 0x6, 0x6, PseudoVLOXSEG2EI16_V_MF4_MF4_MASK }, // 235 + { 0x2, 0x1, 0x1, 0x4, 0x6, 0x7, PseudoVLOXSEG2EI16_V_MF2_MF4_MASK }, // 236 + { 0x2, 0x1, 0x1, 0x4, 0x7, 0x0, PseudoVLOXSEG2EI16_V_M1_MF2_MASK }, // 237 + { 0x2, 0x1, 0x1, 0x4, 0x7, 0x6, PseudoVLOXSEG2EI16_V_MF4_MF2_MASK }, // 238 + { 0x2, 0x1, 0x1, 0x4, 0x7, 0x7, PseudoVLOXSEG2EI16_V_MF2_MF2_MASK }, // 239 + { 0x2, 0x1, 0x1, 0x5, 0x0, 0x0, PseudoVLOXSEG2EI32_V_M1_M1_MASK }, // 240 + { 0x2, 0x1, 0x1, 0x5, 0x0, 0x1, PseudoVLOXSEG2EI32_V_M2_M1_MASK }, // 241 + { 0x2, 0x1, 0x1, 0x5, 0x0, 0x2, PseudoVLOXSEG2EI32_V_M4_M1_MASK }, // 242 + { 0x2, 0x1, 0x1, 0x5, 0x0, 0x7, PseudoVLOXSEG2EI32_V_MF2_M1_MASK }, // 243 + { 0x2, 0x1, 0x1, 0x5, 0x1, 0x0, PseudoVLOXSEG2EI32_V_M1_M2_MASK }, // 244 + { 0x2, 0x1, 0x1, 0x5, 0x1, 0x1, PseudoVLOXSEG2EI32_V_M2_M2_MASK }, // 245 + { 0x2, 0x1, 0x1, 0x5, 0x1, 0x2, PseudoVLOXSEG2EI32_V_M4_M2_MASK }, // 246 + { 0x2, 0x1, 0x1, 0x5, 0x1, 0x3, PseudoVLOXSEG2EI32_V_M8_M2_MASK }, // 247 + { 0x2, 0x1, 0x1, 0x5, 0x2, 0x1, PseudoVLOXSEG2EI32_V_M2_M4_MASK }, // 248 + { 0x2, 0x1, 0x1, 0x5, 0x2, 0x2, PseudoVLOXSEG2EI32_V_M4_M4_MASK }, // 249 + { 0x2, 0x1, 0x1, 0x5, 0x2, 0x3, PseudoVLOXSEG2EI32_V_M8_M4_MASK }, // 250 + { 0x2, 0x1, 0x1, 0x5, 0x5, 0x7, PseudoVLOXSEG2EI32_V_MF2_MF8_MASK }, // 251 + { 0x2, 0x1, 0x1, 0x5, 0x6, 0x0, PseudoVLOXSEG2EI32_V_M1_MF4_MASK }, // 252 + { 0x2, 0x1, 0x1, 0x5, 0x6, 0x7, PseudoVLOXSEG2EI32_V_MF2_MF4_MASK }, // 253 + { 0x2, 0x1, 0x1, 0x5, 0x7, 0x0, PseudoVLOXSEG2EI32_V_M1_MF2_MASK }, // 254 + { 0x2, 0x1, 0x1, 0x5, 0x7, 0x1, PseudoVLOXSEG2EI32_V_M2_MF2_MASK }, // 255 + { 0x2, 0x1, 0x1, 0x5, 0x7, 0x7, PseudoVLOXSEG2EI32_V_MF2_MF2_MASK }, // 256 + { 0x2, 0x1, 0x1, 0x6, 0x0, 0x0, PseudoVLOXSEG2EI64_V_M1_M1_MASK }, // 257 + { 0x2, 0x1, 0x1, 0x6, 0x0, 0x1, PseudoVLOXSEG2EI64_V_M2_M1_MASK }, // 258 + { 0x2, 0x1, 0x1, 0x6, 0x0, 0x2, PseudoVLOXSEG2EI64_V_M4_M1_MASK }, // 259 + { 0x2, 0x1, 0x1, 0x6, 0x0, 0x3, PseudoVLOXSEG2EI64_V_M8_M1_MASK }, // 260 + { 0x2, 0x1, 0x1, 0x6, 0x1, 0x1, PseudoVLOXSEG2EI64_V_M2_M2_MASK }, // 261 + { 0x2, 0x1, 0x1, 0x6, 0x1, 0x2, PseudoVLOXSEG2EI64_V_M4_M2_MASK }, // 262 + { 0x2, 0x1, 0x1, 0x6, 0x1, 0x3, PseudoVLOXSEG2EI64_V_M8_M2_MASK }, // 263 + { 0x2, 0x1, 0x1, 0x6, 0x2, 0x2, PseudoVLOXSEG2EI64_V_M4_M4_MASK }, // 264 + { 0x2, 0x1, 0x1, 0x6, 0x2, 0x3, PseudoVLOXSEG2EI64_V_M8_M4_MASK }, // 265 + { 0x2, 0x1, 0x1, 0x6, 0x5, 0x0, PseudoVLOXSEG2EI64_V_M1_MF8_MASK }, // 266 + { 0x2, 0x1, 0x1, 0x6, 0x6, 0x0, PseudoVLOXSEG2EI64_V_M1_MF4_MASK }, // 267 + { 0x2, 0x1, 0x1, 0x6, 0x6, 0x1, PseudoVLOXSEG2EI64_V_M2_MF4_MASK }, // 268 + { 0x2, 0x1, 0x1, 0x6, 0x7, 0x0, PseudoVLOXSEG2EI64_V_M1_MF2_MASK }, // 269 + { 0x2, 0x1, 0x1, 0x6, 0x7, 0x1, PseudoVLOXSEG2EI64_V_M2_MF2_MASK }, // 270 + { 0x2, 0x1, 0x1, 0x6, 0x7, 0x2, PseudoVLOXSEG2EI64_V_M4_MF2_MASK }, // 271 + { 0x3, 0x0, 0x0, 0x3, 0x0, 0x0, PseudoVLUXSEG3EI8_V_M1_M1 }, // 272 + { 0x3, 0x0, 0x0, 0x3, 0x0, 0x5, PseudoVLUXSEG3EI8_V_MF8_M1 }, // 273 + { 0x3, 0x0, 0x0, 0x3, 0x0, 0x6, PseudoVLUXSEG3EI8_V_MF4_M1 }, // 274 + { 0x3, 0x0, 0x0, 0x3, 0x0, 0x7, PseudoVLUXSEG3EI8_V_MF2_M1 }, // 275 + { 0x3, 0x0, 0x0, 0x3, 0x1, 0x0, PseudoVLUXSEG3EI8_V_M1_M2 }, // 276 + { 0x3, 0x0, 0x0, 0x3, 0x1, 0x1, PseudoVLUXSEG3EI8_V_M2_M2 }, // 277 + { 0x3, 0x0, 0x0, 0x3, 0x1, 0x6, PseudoVLUXSEG3EI8_V_MF4_M2 }, // 278 + { 0x3, 0x0, 0x0, 0x3, 0x1, 0x7, PseudoVLUXSEG3EI8_V_MF2_M2 }, // 279 + { 0x3, 0x0, 0x0, 0x3, 0x5, 0x5, PseudoVLUXSEG3EI8_V_MF8_MF8 }, // 280 + { 0x3, 0x0, 0x0, 0x3, 0x6, 0x5, PseudoVLUXSEG3EI8_V_MF8_MF4 }, // 281 + { 0x3, 0x0, 0x0, 0x3, 0x6, 0x6, PseudoVLUXSEG3EI8_V_MF4_MF4 }, // 282 + { 0x3, 0x0, 0x0, 0x3, 0x7, 0x5, PseudoVLUXSEG3EI8_V_MF8_MF2 }, // 283 + { 0x3, 0x0, 0x0, 0x3, 0x7, 0x6, PseudoVLUXSEG3EI8_V_MF4_MF2 }, // 284 + { 0x3, 0x0, 0x0, 0x3, 0x7, 0x7, PseudoVLUXSEG3EI8_V_MF2_MF2 }, // 285 + { 0x3, 0x0, 0x0, 0x4, 0x0, 0x0, PseudoVLUXSEG3EI16_V_M1_M1 }, // 286 + { 0x3, 0x0, 0x0, 0x4, 0x0, 0x1, PseudoVLUXSEG3EI16_V_M2_M1 }, // 287 + { 0x3, 0x0, 0x0, 0x4, 0x0, 0x6, PseudoVLUXSEG3EI16_V_MF4_M1 }, // 288 + { 0x3, 0x0, 0x0, 0x4, 0x0, 0x7, PseudoVLUXSEG3EI16_V_MF2_M1 }, // 289 + { 0x3, 0x0, 0x0, 0x4, 0x1, 0x0, PseudoVLUXSEG3EI16_V_M1_M2 }, // 290 + { 0x3, 0x0, 0x0, 0x4, 0x1, 0x1, PseudoVLUXSEG3EI16_V_M2_M2 }, // 291 + { 0x3, 0x0, 0x0, 0x4, 0x1, 0x2, PseudoVLUXSEG3EI16_V_M4_M2 }, // 292 + { 0x3, 0x0, 0x0, 0x4, 0x1, 0x7, PseudoVLUXSEG3EI16_V_MF2_M2 }, // 293 + { 0x3, 0x0, 0x0, 0x4, 0x5, 0x6, PseudoVLUXSEG3EI16_V_MF4_MF8 }, // 294 + { 0x3, 0x0, 0x0, 0x4, 0x6, 0x6, PseudoVLUXSEG3EI16_V_MF4_MF4 }, // 295 + { 0x3, 0x0, 0x0, 0x4, 0x6, 0x7, PseudoVLUXSEG3EI16_V_MF2_MF4 }, // 296 + { 0x3, 0x0, 0x0, 0x4, 0x7, 0x0, PseudoVLUXSEG3EI16_V_M1_MF2 }, // 297 + { 0x3, 0x0, 0x0, 0x4, 0x7, 0x6, PseudoVLUXSEG3EI16_V_MF4_MF2 }, // 298 + { 0x3, 0x0, 0x0, 0x4, 0x7, 0x7, PseudoVLUXSEG3EI16_V_MF2_MF2 }, // 299 + { 0x3, 0x0, 0x0, 0x5, 0x0, 0x0, PseudoVLUXSEG3EI32_V_M1_M1 }, // 300 + { 0x3, 0x0, 0x0, 0x5, 0x0, 0x1, PseudoVLUXSEG3EI32_V_M2_M1 }, // 301 + { 0x3, 0x0, 0x0, 0x5, 0x0, 0x2, PseudoVLUXSEG3EI32_V_M4_M1 }, // 302 + { 0x3, 0x0, 0x0, 0x5, 0x0, 0x7, PseudoVLUXSEG3EI32_V_MF2_M1 }, // 303 + { 0x3, 0x0, 0x0, 0x5, 0x1, 0x0, PseudoVLUXSEG3EI32_V_M1_M2 }, // 304 + { 0x3, 0x0, 0x0, 0x5, 0x1, 0x1, PseudoVLUXSEG3EI32_V_M2_M2 }, // 305 + { 0x3, 0x0, 0x0, 0x5, 0x1, 0x2, PseudoVLUXSEG3EI32_V_M4_M2 }, // 306 + { 0x3, 0x0, 0x0, 0x5, 0x1, 0x3, PseudoVLUXSEG3EI32_V_M8_M2 }, // 307 + { 0x3, 0x0, 0x0, 0x5, 0x5, 0x7, PseudoVLUXSEG3EI32_V_MF2_MF8 }, // 308 + { 0x3, 0x0, 0x0, 0x5, 0x6, 0x0, PseudoVLUXSEG3EI32_V_M1_MF4 }, // 309 + { 0x3, 0x0, 0x0, 0x5, 0x6, 0x7, PseudoVLUXSEG3EI32_V_MF2_MF4 }, // 310 + { 0x3, 0x0, 0x0, 0x5, 0x7, 0x0, PseudoVLUXSEG3EI32_V_M1_MF2 }, // 311 + { 0x3, 0x0, 0x0, 0x5, 0x7, 0x1, PseudoVLUXSEG3EI32_V_M2_MF2 }, // 312 + { 0x3, 0x0, 0x0, 0x5, 0x7, 0x7, PseudoVLUXSEG3EI32_V_MF2_MF2 }, // 313 + { 0x3, 0x0, 0x0, 0x6, 0x0, 0x0, PseudoVLUXSEG3EI64_V_M1_M1 }, // 314 + { 0x3, 0x0, 0x0, 0x6, 0x0, 0x1, PseudoVLUXSEG3EI64_V_M2_M1 }, // 315 + { 0x3, 0x0, 0x0, 0x6, 0x0, 0x2, PseudoVLUXSEG3EI64_V_M4_M1 }, // 316 + { 0x3, 0x0, 0x0, 0x6, 0x0, 0x3, PseudoVLUXSEG3EI64_V_M8_M1 }, // 317 + { 0x3, 0x0, 0x0, 0x6, 0x1, 0x1, PseudoVLUXSEG3EI64_V_M2_M2 }, // 318 + { 0x3, 0x0, 0x0, 0x6, 0x1, 0x2, PseudoVLUXSEG3EI64_V_M4_M2 }, // 319 + { 0x3, 0x0, 0x0, 0x6, 0x1, 0x3, PseudoVLUXSEG3EI64_V_M8_M2 }, // 320 + { 0x3, 0x0, 0x0, 0x6, 0x5, 0x0, PseudoVLUXSEG3EI64_V_M1_MF8 }, // 321 + { 0x3, 0x0, 0x0, 0x6, 0x6, 0x0, PseudoVLUXSEG3EI64_V_M1_MF4 }, // 322 + { 0x3, 0x0, 0x0, 0x6, 0x6, 0x1, PseudoVLUXSEG3EI64_V_M2_MF4 }, // 323 + { 0x3, 0x0, 0x0, 0x6, 0x7, 0x0, PseudoVLUXSEG3EI64_V_M1_MF2 }, // 324 + { 0x3, 0x0, 0x0, 0x6, 0x7, 0x1, PseudoVLUXSEG3EI64_V_M2_MF2 }, // 325 + { 0x3, 0x0, 0x0, 0x6, 0x7, 0x2, PseudoVLUXSEG3EI64_V_M4_MF2 }, // 326 + { 0x3, 0x0, 0x1, 0x3, 0x0, 0x0, PseudoVLOXSEG3EI8_V_M1_M1 }, // 327 + { 0x3, 0x0, 0x1, 0x3, 0x0, 0x5, PseudoVLOXSEG3EI8_V_MF8_M1 }, // 328 + { 0x3, 0x0, 0x1, 0x3, 0x0, 0x6, PseudoVLOXSEG3EI8_V_MF4_M1 }, // 329 + { 0x3, 0x0, 0x1, 0x3, 0x0, 0x7, PseudoVLOXSEG3EI8_V_MF2_M1 }, // 330 + { 0x3, 0x0, 0x1, 0x3, 0x1, 0x0, PseudoVLOXSEG3EI8_V_M1_M2 }, // 331 + { 0x3, 0x0, 0x1, 0x3, 0x1, 0x1, PseudoVLOXSEG3EI8_V_M2_M2 }, // 332 + { 0x3, 0x0, 0x1, 0x3, 0x1, 0x6, PseudoVLOXSEG3EI8_V_MF4_M2 }, // 333 + { 0x3, 0x0, 0x1, 0x3, 0x1, 0x7, PseudoVLOXSEG3EI8_V_MF2_M2 }, // 334 + { 0x3, 0x0, 0x1, 0x3, 0x5, 0x5, PseudoVLOXSEG3EI8_V_MF8_MF8 }, // 335 + { 0x3, 0x0, 0x1, 0x3, 0x6, 0x5, PseudoVLOXSEG3EI8_V_MF8_MF4 }, // 336 + { 0x3, 0x0, 0x1, 0x3, 0x6, 0x6, PseudoVLOXSEG3EI8_V_MF4_MF4 }, // 337 + { 0x3, 0x0, 0x1, 0x3, 0x7, 0x5, PseudoVLOXSEG3EI8_V_MF8_MF2 }, // 338 + { 0x3, 0x0, 0x1, 0x3, 0x7, 0x6, PseudoVLOXSEG3EI8_V_MF4_MF2 }, // 339 + { 0x3, 0x0, 0x1, 0x3, 0x7, 0x7, PseudoVLOXSEG3EI8_V_MF2_MF2 }, // 340 + { 0x3, 0x0, 0x1, 0x4, 0x0, 0x0, PseudoVLOXSEG3EI16_V_M1_M1 }, // 341 + { 0x3, 0x0, 0x1, 0x4, 0x0, 0x1, PseudoVLOXSEG3EI16_V_M2_M1 }, // 342 + { 0x3, 0x0, 0x1, 0x4, 0x0, 0x6, PseudoVLOXSEG3EI16_V_MF4_M1 }, // 343 + { 0x3, 0x0, 0x1, 0x4, 0x0, 0x7, PseudoVLOXSEG3EI16_V_MF2_M1 }, // 344 + { 0x3, 0x0, 0x1, 0x4, 0x1, 0x0, PseudoVLOXSEG3EI16_V_M1_M2 }, // 345 + { 0x3, 0x0, 0x1, 0x4, 0x1, 0x1, PseudoVLOXSEG3EI16_V_M2_M2 }, // 346 + { 0x3, 0x0, 0x1, 0x4, 0x1, 0x2, PseudoVLOXSEG3EI16_V_M4_M2 }, // 347 + { 0x3, 0x0, 0x1, 0x4, 0x1, 0x7, PseudoVLOXSEG3EI16_V_MF2_M2 }, // 348 + { 0x3, 0x0, 0x1, 0x4, 0x5, 0x6, PseudoVLOXSEG3EI16_V_MF4_MF8 }, // 349 + { 0x3, 0x0, 0x1, 0x4, 0x6, 0x6, PseudoVLOXSEG3EI16_V_MF4_MF4 }, // 350 + { 0x3, 0x0, 0x1, 0x4, 0x6, 0x7, PseudoVLOXSEG3EI16_V_MF2_MF4 }, // 351 + { 0x3, 0x0, 0x1, 0x4, 0x7, 0x0, PseudoVLOXSEG3EI16_V_M1_MF2 }, // 352 + { 0x3, 0x0, 0x1, 0x4, 0x7, 0x6, PseudoVLOXSEG3EI16_V_MF4_MF2 }, // 353 + { 0x3, 0x0, 0x1, 0x4, 0x7, 0x7, PseudoVLOXSEG3EI16_V_MF2_MF2 }, // 354 + { 0x3, 0x0, 0x1, 0x5, 0x0, 0x0, PseudoVLOXSEG3EI32_V_M1_M1 }, // 355 + { 0x3, 0x0, 0x1, 0x5, 0x0, 0x1, PseudoVLOXSEG3EI32_V_M2_M1 }, // 356 + { 0x3, 0x0, 0x1, 0x5, 0x0, 0x2, PseudoVLOXSEG3EI32_V_M4_M1 }, // 357 + { 0x3, 0x0, 0x1, 0x5, 0x0, 0x7, PseudoVLOXSEG3EI32_V_MF2_M1 }, // 358 + { 0x3, 0x0, 0x1, 0x5, 0x1, 0x0, PseudoVLOXSEG3EI32_V_M1_M2 }, // 359 + { 0x3, 0x0, 0x1, 0x5, 0x1, 0x1, PseudoVLOXSEG3EI32_V_M2_M2 }, // 360 + { 0x3, 0x0, 0x1, 0x5, 0x1, 0x2, PseudoVLOXSEG3EI32_V_M4_M2 }, // 361 + { 0x3, 0x0, 0x1, 0x5, 0x1, 0x3, PseudoVLOXSEG3EI32_V_M8_M2 }, // 362 + { 0x3, 0x0, 0x1, 0x5, 0x5, 0x7, PseudoVLOXSEG3EI32_V_MF2_MF8 }, // 363 + { 0x3, 0x0, 0x1, 0x5, 0x6, 0x0, PseudoVLOXSEG3EI32_V_M1_MF4 }, // 364 + { 0x3, 0x0, 0x1, 0x5, 0x6, 0x7, PseudoVLOXSEG3EI32_V_MF2_MF4 }, // 365 + { 0x3, 0x0, 0x1, 0x5, 0x7, 0x0, PseudoVLOXSEG3EI32_V_M1_MF2 }, // 366 + { 0x3, 0x0, 0x1, 0x5, 0x7, 0x1, PseudoVLOXSEG3EI32_V_M2_MF2 }, // 367 + { 0x3, 0x0, 0x1, 0x5, 0x7, 0x7, PseudoVLOXSEG3EI32_V_MF2_MF2 }, // 368 + { 0x3, 0x0, 0x1, 0x6, 0x0, 0x0, PseudoVLOXSEG3EI64_V_M1_M1 }, // 369 + { 0x3, 0x0, 0x1, 0x6, 0x0, 0x1, PseudoVLOXSEG3EI64_V_M2_M1 }, // 370 + { 0x3, 0x0, 0x1, 0x6, 0x0, 0x2, PseudoVLOXSEG3EI64_V_M4_M1 }, // 371 + { 0x3, 0x0, 0x1, 0x6, 0x0, 0x3, PseudoVLOXSEG3EI64_V_M8_M1 }, // 372 + { 0x3, 0x0, 0x1, 0x6, 0x1, 0x1, PseudoVLOXSEG3EI64_V_M2_M2 }, // 373 + { 0x3, 0x0, 0x1, 0x6, 0x1, 0x2, PseudoVLOXSEG3EI64_V_M4_M2 }, // 374 + { 0x3, 0x0, 0x1, 0x6, 0x1, 0x3, PseudoVLOXSEG3EI64_V_M8_M2 }, // 375 + { 0x3, 0x0, 0x1, 0x6, 0x5, 0x0, PseudoVLOXSEG3EI64_V_M1_MF8 }, // 376 + { 0x3, 0x0, 0x1, 0x6, 0x6, 0x0, PseudoVLOXSEG3EI64_V_M1_MF4 }, // 377 + { 0x3, 0x0, 0x1, 0x6, 0x6, 0x1, PseudoVLOXSEG3EI64_V_M2_MF4 }, // 378 + { 0x3, 0x0, 0x1, 0x6, 0x7, 0x0, PseudoVLOXSEG3EI64_V_M1_MF2 }, // 379 + { 0x3, 0x0, 0x1, 0x6, 0x7, 0x1, PseudoVLOXSEG3EI64_V_M2_MF2 }, // 380 + { 0x3, 0x0, 0x1, 0x6, 0x7, 0x2, PseudoVLOXSEG3EI64_V_M4_MF2 }, // 381 + { 0x3, 0x1, 0x0, 0x3, 0x0, 0x0, PseudoVLUXSEG3EI8_V_M1_M1_MASK }, // 382 + { 0x3, 0x1, 0x0, 0x3, 0x0, 0x5, PseudoVLUXSEG3EI8_V_MF8_M1_MASK }, // 383 + { 0x3, 0x1, 0x0, 0x3, 0x0, 0x6, PseudoVLUXSEG3EI8_V_MF4_M1_MASK }, // 384 + { 0x3, 0x1, 0x0, 0x3, 0x0, 0x7, PseudoVLUXSEG3EI8_V_MF2_M1_MASK }, // 385 + { 0x3, 0x1, 0x0, 0x3, 0x1, 0x0, PseudoVLUXSEG3EI8_V_M1_M2_MASK }, // 386 + { 0x3, 0x1, 0x0, 0x3, 0x1, 0x1, PseudoVLUXSEG3EI8_V_M2_M2_MASK }, // 387 + { 0x3, 0x1, 0x0, 0x3, 0x1, 0x6, PseudoVLUXSEG3EI8_V_MF4_M2_MASK }, // 388 + { 0x3, 0x1, 0x0, 0x3, 0x1, 0x7, PseudoVLUXSEG3EI8_V_MF2_M2_MASK }, // 389 + { 0x3, 0x1, 0x0, 0x3, 0x5, 0x5, PseudoVLUXSEG3EI8_V_MF8_MF8_MASK }, // 390 + { 0x3, 0x1, 0x0, 0x3, 0x6, 0x5, PseudoVLUXSEG3EI8_V_MF8_MF4_MASK }, // 391 + { 0x3, 0x1, 0x0, 0x3, 0x6, 0x6, PseudoVLUXSEG3EI8_V_MF4_MF4_MASK }, // 392 + { 0x3, 0x1, 0x0, 0x3, 0x7, 0x5, PseudoVLUXSEG3EI8_V_MF8_MF2_MASK }, // 393 + { 0x3, 0x1, 0x0, 0x3, 0x7, 0x6, PseudoVLUXSEG3EI8_V_MF4_MF2_MASK }, // 394 + { 0x3, 0x1, 0x0, 0x3, 0x7, 0x7, PseudoVLUXSEG3EI8_V_MF2_MF2_MASK }, // 395 + { 0x3, 0x1, 0x0, 0x4, 0x0, 0x0, PseudoVLUXSEG3EI16_V_M1_M1_MASK }, // 396 + { 0x3, 0x1, 0x0, 0x4, 0x0, 0x1, PseudoVLUXSEG3EI16_V_M2_M1_MASK }, // 397 + { 0x3, 0x1, 0x0, 0x4, 0x0, 0x6, PseudoVLUXSEG3EI16_V_MF4_M1_MASK }, // 398 + { 0x3, 0x1, 0x0, 0x4, 0x0, 0x7, PseudoVLUXSEG3EI16_V_MF2_M1_MASK }, // 399 + { 0x3, 0x1, 0x0, 0x4, 0x1, 0x0, PseudoVLUXSEG3EI16_V_M1_M2_MASK }, // 400 + { 0x3, 0x1, 0x0, 0x4, 0x1, 0x1, PseudoVLUXSEG3EI16_V_M2_M2_MASK }, // 401 + { 0x3, 0x1, 0x0, 0x4, 0x1, 0x2, PseudoVLUXSEG3EI16_V_M4_M2_MASK }, // 402 + { 0x3, 0x1, 0x0, 0x4, 0x1, 0x7, PseudoVLUXSEG3EI16_V_MF2_M2_MASK }, // 403 + { 0x3, 0x1, 0x0, 0x4, 0x5, 0x6, PseudoVLUXSEG3EI16_V_MF4_MF8_MASK }, // 404 + { 0x3, 0x1, 0x0, 0x4, 0x6, 0x6, PseudoVLUXSEG3EI16_V_MF4_MF4_MASK }, // 405 + { 0x3, 0x1, 0x0, 0x4, 0x6, 0x7, PseudoVLUXSEG3EI16_V_MF2_MF4_MASK }, // 406 + { 0x3, 0x1, 0x0, 0x4, 0x7, 0x0, PseudoVLUXSEG3EI16_V_M1_MF2_MASK }, // 407 + { 0x3, 0x1, 0x0, 0x4, 0x7, 0x6, PseudoVLUXSEG3EI16_V_MF4_MF2_MASK }, // 408 + { 0x3, 0x1, 0x0, 0x4, 0x7, 0x7, PseudoVLUXSEG3EI16_V_MF2_MF2_MASK }, // 409 + { 0x3, 0x1, 0x0, 0x5, 0x0, 0x0, PseudoVLUXSEG3EI32_V_M1_M1_MASK }, // 410 + { 0x3, 0x1, 0x0, 0x5, 0x0, 0x1, PseudoVLUXSEG3EI32_V_M2_M1_MASK }, // 411 + { 0x3, 0x1, 0x0, 0x5, 0x0, 0x2, PseudoVLUXSEG3EI32_V_M4_M1_MASK }, // 412 + { 0x3, 0x1, 0x0, 0x5, 0x0, 0x7, PseudoVLUXSEG3EI32_V_MF2_M1_MASK }, // 413 + { 0x3, 0x1, 0x0, 0x5, 0x1, 0x0, PseudoVLUXSEG3EI32_V_M1_M2_MASK }, // 414 + { 0x3, 0x1, 0x0, 0x5, 0x1, 0x1, PseudoVLUXSEG3EI32_V_M2_M2_MASK }, // 415 + { 0x3, 0x1, 0x0, 0x5, 0x1, 0x2, PseudoVLUXSEG3EI32_V_M4_M2_MASK }, // 416 + { 0x3, 0x1, 0x0, 0x5, 0x1, 0x3, PseudoVLUXSEG3EI32_V_M8_M2_MASK }, // 417 + { 0x3, 0x1, 0x0, 0x5, 0x5, 0x7, PseudoVLUXSEG3EI32_V_MF2_MF8_MASK }, // 418 + { 0x3, 0x1, 0x0, 0x5, 0x6, 0x0, PseudoVLUXSEG3EI32_V_M1_MF4_MASK }, // 419 + { 0x3, 0x1, 0x0, 0x5, 0x6, 0x7, PseudoVLUXSEG3EI32_V_MF2_MF4_MASK }, // 420 + { 0x3, 0x1, 0x0, 0x5, 0x7, 0x0, PseudoVLUXSEG3EI32_V_M1_MF2_MASK }, // 421 + { 0x3, 0x1, 0x0, 0x5, 0x7, 0x1, PseudoVLUXSEG3EI32_V_M2_MF2_MASK }, // 422 + { 0x3, 0x1, 0x0, 0x5, 0x7, 0x7, PseudoVLUXSEG3EI32_V_MF2_MF2_MASK }, // 423 + { 0x3, 0x1, 0x0, 0x6, 0x0, 0x0, PseudoVLUXSEG3EI64_V_M1_M1_MASK }, // 424 + { 0x3, 0x1, 0x0, 0x6, 0x0, 0x1, PseudoVLUXSEG3EI64_V_M2_M1_MASK }, // 425 + { 0x3, 0x1, 0x0, 0x6, 0x0, 0x2, PseudoVLUXSEG3EI64_V_M4_M1_MASK }, // 426 + { 0x3, 0x1, 0x0, 0x6, 0x0, 0x3, PseudoVLUXSEG3EI64_V_M8_M1_MASK }, // 427 + { 0x3, 0x1, 0x0, 0x6, 0x1, 0x1, PseudoVLUXSEG3EI64_V_M2_M2_MASK }, // 428 + { 0x3, 0x1, 0x0, 0x6, 0x1, 0x2, PseudoVLUXSEG3EI64_V_M4_M2_MASK }, // 429 + { 0x3, 0x1, 0x0, 0x6, 0x1, 0x3, PseudoVLUXSEG3EI64_V_M8_M2_MASK }, // 430 + { 0x3, 0x1, 0x0, 0x6, 0x5, 0x0, PseudoVLUXSEG3EI64_V_M1_MF8_MASK }, // 431 + { 0x3, 0x1, 0x0, 0x6, 0x6, 0x0, PseudoVLUXSEG3EI64_V_M1_MF4_MASK }, // 432 + { 0x3, 0x1, 0x0, 0x6, 0x6, 0x1, PseudoVLUXSEG3EI64_V_M2_MF4_MASK }, // 433 + { 0x3, 0x1, 0x0, 0x6, 0x7, 0x0, PseudoVLUXSEG3EI64_V_M1_MF2_MASK }, // 434 + { 0x3, 0x1, 0x0, 0x6, 0x7, 0x1, PseudoVLUXSEG3EI64_V_M2_MF2_MASK }, // 435 + { 0x3, 0x1, 0x0, 0x6, 0x7, 0x2, PseudoVLUXSEG3EI64_V_M4_MF2_MASK }, // 436 + { 0x3, 0x1, 0x1, 0x3, 0x0, 0x0, PseudoVLOXSEG3EI8_V_M1_M1_MASK }, // 437 + { 0x3, 0x1, 0x1, 0x3, 0x0, 0x5, PseudoVLOXSEG3EI8_V_MF8_M1_MASK }, // 438 + { 0x3, 0x1, 0x1, 0x3, 0x0, 0x6, PseudoVLOXSEG3EI8_V_MF4_M1_MASK }, // 439 + { 0x3, 0x1, 0x1, 0x3, 0x0, 0x7, PseudoVLOXSEG3EI8_V_MF2_M1_MASK }, // 440 + { 0x3, 0x1, 0x1, 0x3, 0x1, 0x0, PseudoVLOXSEG3EI8_V_M1_M2_MASK }, // 441 + { 0x3, 0x1, 0x1, 0x3, 0x1, 0x1, PseudoVLOXSEG3EI8_V_M2_M2_MASK }, // 442 + { 0x3, 0x1, 0x1, 0x3, 0x1, 0x6, PseudoVLOXSEG3EI8_V_MF4_M2_MASK }, // 443 + { 0x3, 0x1, 0x1, 0x3, 0x1, 0x7, PseudoVLOXSEG3EI8_V_MF2_M2_MASK }, // 444 + { 0x3, 0x1, 0x1, 0x3, 0x5, 0x5, PseudoVLOXSEG3EI8_V_MF8_MF8_MASK }, // 445 + { 0x3, 0x1, 0x1, 0x3, 0x6, 0x5, PseudoVLOXSEG3EI8_V_MF8_MF4_MASK }, // 446 + { 0x3, 0x1, 0x1, 0x3, 0x6, 0x6, PseudoVLOXSEG3EI8_V_MF4_MF4_MASK }, // 447 + { 0x3, 0x1, 0x1, 0x3, 0x7, 0x5, PseudoVLOXSEG3EI8_V_MF8_MF2_MASK }, // 448 + { 0x3, 0x1, 0x1, 0x3, 0x7, 0x6, PseudoVLOXSEG3EI8_V_MF4_MF2_MASK }, // 449 + { 0x3, 0x1, 0x1, 0x3, 0x7, 0x7, PseudoVLOXSEG3EI8_V_MF2_MF2_MASK }, // 450 + { 0x3, 0x1, 0x1, 0x4, 0x0, 0x0, PseudoVLOXSEG3EI16_V_M1_M1_MASK }, // 451 + { 0x3, 0x1, 0x1, 0x4, 0x0, 0x1, PseudoVLOXSEG3EI16_V_M2_M1_MASK }, // 452 + { 0x3, 0x1, 0x1, 0x4, 0x0, 0x6, PseudoVLOXSEG3EI16_V_MF4_M1_MASK }, // 453 + { 0x3, 0x1, 0x1, 0x4, 0x0, 0x7, PseudoVLOXSEG3EI16_V_MF2_M1_MASK }, // 454 + { 0x3, 0x1, 0x1, 0x4, 0x1, 0x0, PseudoVLOXSEG3EI16_V_M1_M2_MASK }, // 455 + { 0x3, 0x1, 0x1, 0x4, 0x1, 0x1, PseudoVLOXSEG3EI16_V_M2_M2_MASK }, // 456 + { 0x3, 0x1, 0x1, 0x4, 0x1, 0x2, PseudoVLOXSEG3EI16_V_M4_M2_MASK }, // 457 + { 0x3, 0x1, 0x1, 0x4, 0x1, 0x7, PseudoVLOXSEG3EI16_V_MF2_M2_MASK }, // 458 + { 0x3, 0x1, 0x1, 0x4, 0x5, 0x6, PseudoVLOXSEG3EI16_V_MF4_MF8_MASK }, // 459 + { 0x3, 0x1, 0x1, 0x4, 0x6, 0x6, PseudoVLOXSEG3EI16_V_MF4_MF4_MASK }, // 460 + { 0x3, 0x1, 0x1, 0x4, 0x6, 0x7, PseudoVLOXSEG3EI16_V_MF2_MF4_MASK }, // 461 + { 0x3, 0x1, 0x1, 0x4, 0x7, 0x0, PseudoVLOXSEG3EI16_V_M1_MF2_MASK }, // 462 + { 0x3, 0x1, 0x1, 0x4, 0x7, 0x6, PseudoVLOXSEG3EI16_V_MF4_MF2_MASK }, // 463 + { 0x3, 0x1, 0x1, 0x4, 0x7, 0x7, PseudoVLOXSEG3EI16_V_MF2_MF2_MASK }, // 464 + { 0x3, 0x1, 0x1, 0x5, 0x0, 0x0, PseudoVLOXSEG3EI32_V_M1_M1_MASK }, // 465 + { 0x3, 0x1, 0x1, 0x5, 0x0, 0x1, PseudoVLOXSEG3EI32_V_M2_M1_MASK }, // 466 + { 0x3, 0x1, 0x1, 0x5, 0x0, 0x2, PseudoVLOXSEG3EI32_V_M4_M1_MASK }, // 467 + { 0x3, 0x1, 0x1, 0x5, 0x0, 0x7, PseudoVLOXSEG3EI32_V_MF2_M1_MASK }, // 468 + { 0x3, 0x1, 0x1, 0x5, 0x1, 0x0, PseudoVLOXSEG3EI32_V_M1_M2_MASK }, // 469 + { 0x3, 0x1, 0x1, 0x5, 0x1, 0x1, PseudoVLOXSEG3EI32_V_M2_M2_MASK }, // 470 + { 0x3, 0x1, 0x1, 0x5, 0x1, 0x2, PseudoVLOXSEG3EI32_V_M4_M2_MASK }, // 471 + { 0x3, 0x1, 0x1, 0x5, 0x1, 0x3, PseudoVLOXSEG3EI32_V_M8_M2_MASK }, // 472 + { 0x3, 0x1, 0x1, 0x5, 0x5, 0x7, PseudoVLOXSEG3EI32_V_MF2_MF8_MASK }, // 473 + { 0x3, 0x1, 0x1, 0x5, 0x6, 0x0, PseudoVLOXSEG3EI32_V_M1_MF4_MASK }, // 474 + { 0x3, 0x1, 0x1, 0x5, 0x6, 0x7, PseudoVLOXSEG3EI32_V_MF2_MF4_MASK }, // 475 + { 0x3, 0x1, 0x1, 0x5, 0x7, 0x0, PseudoVLOXSEG3EI32_V_M1_MF2_MASK }, // 476 + { 0x3, 0x1, 0x1, 0x5, 0x7, 0x1, PseudoVLOXSEG3EI32_V_M2_MF2_MASK }, // 477 + { 0x3, 0x1, 0x1, 0x5, 0x7, 0x7, PseudoVLOXSEG3EI32_V_MF2_MF2_MASK }, // 478 + { 0x3, 0x1, 0x1, 0x6, 0x0, 0x0, PseudoVLOXSEG3EI64_V_M1_M1_MASK }, // 479 + { 0x3, 0x1, 0x1, 0x6, 0x0, 0x1, PseudoVLOXSEG3EI64_V_M2_M1_MASK }, // 480 + { 0x3, 0x1, 0x1, 0x6, 0x0, 0x2, PseudoVLOXSEG3EI64_V_M4_M1_MASK }, // 481 + { 0x3, 0x1, 0x1, 0x6, 0x0, 0x3, PseudoVLOXSEG3EI64_V_M8_M1_MASK }, // 482 + { 0x3, 0x1, 0x1, 0x6, 0x1, 0x1, PseudoVLOXSEG3EI64_V_M2_M2_MASK }, // 483 + { 0x3, 0x1, 0x1, 0x6, 0x1, 0x2, PseudoVLOXSEG3EI64_V_M4_M2_MASK }, // 484 + { 0x3, 0x1, 0x1, 0x6, 0x1, 0x3, PseudoVLOXSEG3EI64_V_M8_M2_MASK }, // 485 + { 0x3, 0x1, 0x1, 0x6, 0x5, 0x0, PseudoVLOXSEG3EI64_V_M1_MF8_MASK }, // 486 + { 0x3, 0x1, 0x1, 0x6, 0x6, 0x0, PseudoVLOXSEG3EI64_V_M1_MF4_MASK }, // 487 + { 0x3, 0x1, 0x1, 0x6, 0x6, 0x1, PseudoVLOXSEG3EI64_V_M2_MF4_MASK }, // 488 + { 0x3, 0x1, 0x1, 0x6, 0x7, 0x0, PseudoVLOXSEG3EI64_V_M1_MF2_MASK }, // 489 + { 0x3, 0x1, 0x1, 0x6, 0x7, 0x1, PseudoVLOXSEG3EI64_V_M2_MF2_MASK }, // 490 + { 0x3, 0x1, 0x1, 0x6, 0x7, 0x2, PseudoVLOXSEG3EI64_V_M4_MF2_MASK }, // 491 + { 0x4, 0x0, 0x0, 0x3, 0x0, 0x0, PseudoVLUXSEG4EI8_V_M1_M1 }, // 492 + { 0x4, 0x0, 0x0, 0x3, 0x0, 0x5, PseudoVLUXSEG4EI8_V_MF8_M1 }, // 493 + { 0x4, 0x0, 0x0, 0x3, 0x0, 0x6, PseudoVLUXSEG4EI8_V_MF4_M1 }, // 494 + { 0x4, 0x0, 0x0, 0x3, 0x0, 0x7, PseudoVLUXSEG4EI8_V_MF2_M1 }, // 495 + { 0x4, 0x0, 0x0, 0x3, 0x1, 0x0, PseudoVLUXSEG4EI8_V_M1_M2 }, // 496 + { 0x4, 0x0, 0x0, 0x3, 0x1, 0x1, PseudoVLUXSEG4EI8_V_M2_M2 }, // 497 + { 0x4, 0x0, 0x0, 0x3, 0x1, 0x6, PseudoVLUXSEG4EI8_V_MF4_M2 }, // 498 + { 0x4, 0x0, 0x0, 0x3, 0x1, 0x7, PseudoVLUXSEG4EI8_V_MF2_M2 }, // 499 + { 0x4, 0x0, 0x0, 0x3, 0x5, 0x5, PseudoVLUXSEG4EI8_V_MF8_MF8 }, // 500 + { 0x4, 0x0, 0x0, 0x3, 0x6, 0x5, PseudoVLUXSEG4EI8_V_MF8_MF4 }, // 501 + { 0x4, 0x0, 0x0, 0x3, 0x6, 0x6, PseudoVLUXSEG4EI8_V_MF4_MF4 }, // 502 + { 0x4, 0x0, 0x0, 0x3, 0x7, 0x5, PseudoVLUXSEG4EI8_V_MF8_MF2 }, // 503 + { 0x4, 0x0, 0x0, 0x3, 0x7, 0x6, PseudoVLUXSEG4EI8_V_MF4_MF2 }, // 504 + { 0x4, 0x0, 0x0, 0x3, 0x7, 0x7, PseudoVLUXSEG4EI8_V_MF2_MF2 }, // 505 + { 0x4, 0x0, 0x0, 0x4, 0x0, 0x0, PseudoVLUXSEG4EI16_V_M1_M1 }, // 506 + { 0x4, 0x0, 0x0, 0x4, 0x0, 0x1, PseudoVLUXSEG4EI16_V_M2_M1 }, // 507 + { 0x4, 0x0, 0x0, 0x4, 0x0, 0x6, PseudoVLUXSEG4EI16_V_MF4_M1 }, // 508 + { 0x4, 0x0, 0x0, 0x4, 0x0, 0x7, PseudoVLUXSEG4EI16_V_MF2_M1 }, // 509 + { 0x4, 0x0, 0x0, 0x4, 0x1, 0x0, PseudoVLUXSEG4EI16_V_M1_M2 }, // 510 + { 0x4, 0x0, 0x0, 0x4, 0x1, 0x1, PseudoVLUXSEG4EI16_V_M2_M2 }, // 511 + { 0x4, 0x0, 0x0, 0x4, 0x1, 0x2, PseudoVLUXSEG4EI16_V_M4_M2 }, // 512 + { 0x4, 0x0, 0x0, 0x4, 0x1, 0x7, PseudoVLUXSEG4EI16_V_MF2_M2 }, // 513 + { 0x4, 0x0, 0x0, 0x4, 0x5, 0x6, PseudoVLUXSEG4EI16_V_MF4_MF8 }, // 514 + { 0x4, 0x0, 0x0, 0x4, 0x6, 0x6, PseudoVLUXSEG4EI16_V_MF4_MF4 }, // 515 + { 0x4, 0x0, 0x0, 0x4, 0x6, 0x7, PseudoVLUXSEG4EI16_V_MF2_MF4 }, // 516 + { 0x4, 0x0, 0x0, 0x4, 0x7, 0x0, PseudoVLUXSEG4EI16_V_M1_MF2 }, // 517 + { 0x4, 0x0, 0x0, 0x4, 0x7, 0x6, PseudoVLUXSEG4EI16_V_MF4_MF2 }, // 518 + { 0x4, 0x0, 0x0, 0x4, 0x7, 0x7, PseudoVLUXSEG4EI16_V_MF2_MF2 }, // 519 + { 0x4, 0x0, 0x0, 0x5, 0x0, 0x0, PseudoVLUXSEG4EI32_V_M1_M1 }, // 520 + { 0x4, 0x0, 0x0, 0x5, 0x0, 0x1, PseudoVLUXSEG4EI32_V_M2_M1 }, // 521 + { 0x4, 0x0, 0x0, 0x5, 0x0, 0x2, PseudoVLUXSEG4EI32_V_M4_M1 }, // 522 + { 0x4, 0x0, 0x0, 0x5, 0x0, 0x7, PseudoVLUXSEG4EI32_V_MF2_M1 }, // 523 + { 0x4, 0x0, 0x0, 0x5, 0x1, 0x0, PseudoVLUXSEG4EI32_V_M1_M2 }, // 524 + { 0x4, 0x0, 0x0, 0x5, 0x1, 0x1, PseudoVLUXSEG4EI32_V_M2_M2 }, // 525 + { 0x4, 0x0, 0x0, 0x5, 0x1, 0x2, PseudoVLUXSEG4EI32_V_M4_M2 }, // 526 + { 0x4, 0x0, 0x0, 0x5, 0x1, 0x3, PseudoVLUXSEG4EI32_V_M8_M2 }, // 527 + { 0x4, 0x0, 0x0, 0x5, 0x5, 0x7, PseudoVLUXSEG4EI32_V_MF2_MF8 }, // 528 + { 0x4, 0x0, 0x0, 0x5, 0x6, 0x0, PseudoVLUXSEG4EI32_V_M1_MF4 }, // 529 + { 0x4, 0x0, 0x0, 0x5, 0x6, 0x7, PseudoVLUXSEG4EI32_V_MF2_MF4 }, // 530 + { 0x4, 0x0, 0x0, 0x5, 0x7, 0x0, PseudoVLUXSEG4EI32_V_M1_MF2 }, // 531 + { 0x4, 0x0, 0x0, 0x5, 0x7, 0x1, PseudoVLUXSEG4EI32_V_M2_MF2 }, // 532 + { 0x4, 0x0, 0x0, 0x5, 0x7, 0x7, PseudoVLUXSEG4EI32_V_MF2_MF2 }, // 533 + { 0x4, 0x0, 0x0, 0x6, 0x0, 0x0, PseudoVLUXSEG4EI64_V_M1_M1 }, // 534 + { 0x4, 0x0, 0x0, 0x6, 0x0, 0x1, PseudoVLUXSEG4EI64_V_M2_M1 }, // 535 + { 0x4, 0x0, 0x0, 0x6, 0x0, 0x2, PseudoVLUXSEG4EI64_V_M4_M1 }, // 536 + { 0x4, 0x0, 0x0, 0x6, 0x0, 0x3, PseudoVLUXSEG4EI64_V_M8_M1 }, // 537 + { 0x4, 0x0, 0x0, 0x6, 0x1, 0x1, PseudoVLUXSEG4EI64_V_M2_M2 }, // 538 + { 0x4, 0x0, 0x0, 0x6, 0x1, 0x2, PseudoVLUXSEG4EI64_V_M4_M2 }, // 539 + { 0x4, 0x0, 0x0, 0x6, 0x1, 0x3, PseudoVLUXSEG4EI64_V_M8_M2 }, // 540 + { 0x4, 0x0, 0x0, 0x6, 0x5, 0x0, PseudoVLUXSEG4EI64_V_M1_MF8 }, // 541 + { 0x4, 0x0, 0x0, 0x6, 0x6, 0x0, PseudoVLUXSEG4EI64_V_M1_MF4 }, // 542 + { 0x4, 0x0, 0x0, 0x6, 0x6, 0x1, PseudoVLUXSEG4EI64_V_M2_MF4 }, // 543 + { 0x4, 0x0, 0x0, 0x6, 0x7, 0x0, PseudoVLUXSEG4EI64_V_M1_MF2 }, // 544 + { 0x4, 0x0, 0x0, 0x6, 0x7, 0x1, PseudoVLUXSEG4EI64_V_M2_MF2 }, // 545 + { 0x4, 0x0, 0x0, 0x6, 0x7, 0x2, PseudoVLUXSEG4EI64_V_M4_MF2 }, // 546 + { 0x4, 0x0, 0x1, 0x3, 0x0, 0x0, PseudoVLOXSEG4EI8_V_M1_M1 }, // 547 + { 0x4, 0x0, 0x1, 0x3, 0x0, 0x5, PseudoVLOXSEG4EI8_V_MF8_M1 }, // 548 + { 0x4, 0x0, 0x1, 0x3, 0x0, 0x6, PseudoVLOXSEG4EI8_V_MF4_M1 }, // 549 + { 0x4, 0x0, 0x1, 0x3, 0x0, 0x7, PseudoVLOXSEG4EI8_V_MF2_M1 }, // 550 + { 0x4, 0x0, 0x1, 0x3, 0x1, 0x0, PseudoVLOXSEG4EI8_V_M1_M2 }, // 551 + { 0x4, 0x0, 0x1, 0x3, 0x1, 0x1, PseudoVLOXSEG4EI8_V_M2_M2 }, // 552 + { 0x4, 0x0, 0x1, 0x3, 0x1, 0x6, PseudoVLOXSEG4EI8_V_MF4_M2 }, // 553 + { 0x4, 0x0, 0x1, 0x3, 0x1, 0x7, PseudoVLOXSEG4EI8_V_MF2_M2 }, // 554 + { 0x4, 0x0, 0x1, 0x3, 0x5, 0x5, PseudoVLOXSEG4EI8_V_MF8_MF8 }, // 555 + { 0x4, 0x0, 0x1, 0x3, 0x6, 0x5, PseudoVLOXSEG4EI8_V_MF8_MF4 }, // 556 + { 0x4, 0x0, 0x1, 0x3, 0x6, 0x6, PseudoVLOXSEG4EI8_V_MF4_MF4 }, // 557 + { 0x4, 0x0, 0x1, 0x3, 0x7, 0x5, PseudoVLOXSEG4EI8_V_MF8_MF2 }, // 558 + { 0x4, 0x0, 0x1, 0x3, 0x7, 0x6, PseudoVLOXSEG4EI8_V_MF4_MF2 }, // 559 + { 0x4, 0x0, 0x1, 0x3, 0x7, 0x7, PseudoVLOXSEG4EI8_V_MF2_MF2 }, // 560 + { 0x4, 0x0, 0x1, 0x4, 0x0, 0x0, PseudoVLOXSEG4EI16_V_M1_M1 }, // 561 + { 0x4, 0x0, 0x1, 0x4, 0x0, 0x1, PseudoVLOXSEG4EI16_V_M2_M1 }, // 562 + { 0x4, 0x0, 0x1, 0x4, 0x0, 0x6, PseudoVLOXSEG4EI16_V_MF4_M1 }, // 563 + { 0x4, 0x0, 0x1, 0x4, 0x0, 0x7, PseudoVLOXSEG4EI16_V_MF2_M1 }, // 564 + { 0x4, 0x0, 0x1, 0x4, 0x1, 0x0, PseudoVLOXSEG4EI16_V_M1_M2 }, // 565 + { 0x4, 0x0, 0x1, 0x4, 0x1, 0x1, PseudoVLOXSEG4EI16_V_M2_M2 }, // 566 + { 0x4, 0x0, 0x1, 0x4, 0x1, 0x2, PseudoVLOXSEG4EI16_V_M4_M2 }, // 567 + { 0x4, 0x0, 0x1, 0x4, 0x1, 0x7, PseudoVLOXSEG4EI16_V_MF2_M2 }, // 568 + { 0x4, 0x0, 0x1, 0x4, 0x5, 0x6, PseudoVLOXSEG4EI16_V_MF4_MF8 }, // 569 + { 0x4, 0x0, 0x1, 0x4, 0x6, 0x6, PseudoVLOXSEG4EI16_V_MF4_MF4 }, // 570 + { 0x4, 0x0, 0x1, 0x4, 0x6, 0x7, PseudoVLOXSEG4EI16_V_MF2_MF4 }, // 571 + { 0x4, 0x0, 0x1, 0x4, 0x7, 0x0, PseudoVLOXSEG4EI16_V_M1_MF2 }, // 572 + { 0x4, 0x0, 0x1, 0x4, 0x7, 0x6, PseudoVLOXSEG4EI16_V_MF4_MF2 }, // 573 + { 0x4, 0x0, 0x1, 0x4, 0x7, 0x7, PseudoVLOXSEG4EI16_V_MF2_MF2 }, // 574 + { 0x4, 0x0, 0x1, 0x5, 0x0, 0x0, PseudoVLOXSEG4EI32_V_M1_M1 }, // 575 + { 0x4, 0x0, 0x1, 0x5, 0x0, 0x1, PseudoVLOXSEG4EI32_V_M2_M1 }, // 576 + { 0x4, 0x0, 0x1, 0x5, 0x0, 0x2, PseudoVLOXSEG4EI32_V_M4_M1 }, // 577 + { 0x4, 0x0, 0x1, 0x5, 0x0, 0x7, PseudoVLOXSEG4EI32_V_MF2_M1 }, // 578 + { 0x4, 0x0, 0x1, 0x5, 0x1, 0x0, PseudoVLOXSEG4EI32_V_M1_M2 }, // 579 + { 0x4, 0x0, 0x1, 0x5, 0x1, 0x1, PseudoVLOXSEG4EI32_V_M2_M2 }, // 580 + { 0x4, 0x0, 0x1, 0x5, 0x1, 0x2, PseudoVLOXSEG4EI32_V_M4_M2 }, // 581 + { 0x4, 0x0, 0x1, 0x5, 0x1, 0x3, PseudoVLOXSEG4EI32_V_M8_M2 }, // 582 + { 0x4, 0x0, 0x1, 0x5, 0x5, 0x7, PseudoVLOXSEG4EI32_V_MF2_MF8 }, // 583 + { 0x4, 0x0, 0x1, 0x5, 0x6, 0x0, PseudoVLOXSEG4EI32_V_M1_MF4 }, // 584 + { 0x4, 0x0, 0x1, 0x5, 0x6, 0x7, PseudoVLOXSEG4EI32_V_MF2_MF4 }, // 585 + { 0x4, 0x0, 0x1, 0x5, 0x7, 0x0, PseudoVLOXSEG4EI32_V_M1_MF2 }, // 586 + { 0x4, 0x0, 0x1, 0x5, 0x7, 0x1, PseudoVLOXSEG4EI32_V_M2_MF2 }, // 587 + { 0x4, 0x0, 0x1, 0x5, 0x7, 0x7, PseudoVLOXSEG4EI32_V_MF2_MF2 }, // 588 + { 0x4, 0x0, 0x1, 0x6, 0x0, 0x0, PseudoVLOXSEG4EI64_V_M1_M1 }, // 589 + { 0x4, 0x0, 0x1, 0x6, 0x0, 0x1, PseudoVLOXSEG4EI64_V_M2_M1 }, // 590 + { 0x4, 0x0, 0x1, 0x6, 0x0, 0x2, PseudoVLOXSEG4EI64_V_M4_M1 }, // 591 + { 0x4, 0x0, 0x1, 0x6, 0x0, 0x3, PseudoVLOXSEG4EI64_V_M8_M1 }, // 592 + { 0x4, 0x0, 0x1, 0x6, 0x1, 0x1, PseudoVLOXSEG4EI64_V_M2_M2 }, // 593 + { 0x4, 0x0, 0x1, 0x6, 0x1, 0x2, PseudoVLOXSEG4EI64_V_M4_M2 }, // 594 + { 0x4, 0x0, 0x1, 0x6, 0x1, 0x3, PseudoVLOXSEG4EI64_V_M8_M2 }, // 595 + { 0x4, 0x0, 0x1, 0x6, 0x5, 0x0, PseudoVLOXSEG4EI64_V_M1_MF8 }, // 596 + { 0x4, 0x0, 0x1, 0x6, 0x6, 0x0, PseudoVLOXSEG4EI64_V_M1_MF4 }, // 597 + { 0x4, 0x0, 0x1, 0x6, 0x6, 0x1, PseudoVLOXSEG4EI64_V_M2_MF4 }, // 598 + { 0x4, 0x0, 0x1, 0x6, 0x7, 0x0, PseudoVLOXSEG4EI64_V_M1_MF2 }, // 599 + { 0x4, 0x0, 0x1, 0x6, 0x7, 0x1, PseudoVLOXSEG4EI64_V_M2_MF2 }, // 600 + { 0x4, 0x0, 0x1, 0x6, 0x7, 0x2, PseudoVLOXSEG4EI64_V_M4_MF2 }, // 601 + { 0x4, 0x1, 0x0, 0x3, 0x0, 0x0, PseudoVLUXSEG4EI8_V_M1_M1_MASK }, // 602 + { 0x4, 0x1, 0x0, 0x3, 0x0, 0x5, PseudoVLUXSEG4EI8_V_MF8_M1_MASK }, // 603 + { 0x4, 0x1, 0x0, 0x3, 0x0, 0x6, PseudoVLUXSEG4EI8_V_MF4_M1_MASK }, // 604 + { 0x4, 0x1, 0x0, 0x3, 0x0, 0x7, PseudoVLUXSEG4EI8_V_MF2_M1_MASK }, // 605 + { 0x4, 0x1, 0x0, 0x3, 0x1, 0x0, PseudoVLUXSEG4EI8_V_M1_M2_MASK }, // 606 + { 0x4, 0x1, 0x0, 0x3, 0x1, 0x1, PseudoVLUXSEG4EI8_V_M2_M2_MASK }, // 607 + { 0x4, 0x1, 0x0, 0x3, 0x1, 0x6, PseudoVLUXSEG4EI8_V_MF4_M2_MASK }, // 608 + { 0x4, 0x1, 0x0, 0x3, 0x1, 0x7, PseudoVLUXSEG4EI8_V_MF2_M2_MASK }, // 609 + { 0x4, 0x1, 0x0, 0x3, 0x5, 0x5, PseudoVLUXSEG4EI8_V_MF8_MF8_MASK }, // 610 + { 0x4, 0x1, 0x0, 0x3, 0x6, 0x5, PseudoVLUXSEG4EI8_V_MF8_MF4_MASK }, // 611 + { 0x4, 0x1, 0x0, 0x3, 0x6, 0x6, PseudoVLUXSEG4EI8_V_MF4_MF4_MASK }, // 612 + { 0x4, 0x1, 0x0, 0x3, 0x7, 0x5, PseudoVLUXSEG4EI8_V_MF8_MF2_MASK }, // 613 + { 0x4, 0x1, 0x0, 0x3, 0x7, 0x6, PseudoVLUXSEG4EI8_V_MF4_MF2_MASK }, // 614 + { 0x4, 0x1, 0x0, 0x3, 0x7, 0x7, PseudoVLUXSEG4EI8_V_MF2_MF2_MASK }, // 615 + { 0x4, 0x1, 0x0, 0x4, 0x0, 0x0, PseudoVLUXSEG4EI16_V_M1_M1_MASK }, // 616 + { 0x4, 0x1, 0x0, 0x4, 0x0, 0x1, PseudoVLUXSEG4EI16_V_M2_M1_MASK }, // 617 + { 0x4, 0x1, 0x0, 0x4, 0x0, 0x6, PseudoVLUXSEG4EI16_V_MF4_M1_MASK }, // 618 + { 0x4, 0x1, 0x0, 0x4, 0x0, 0x7, PseudoVLUXSEG4EI16_V_MF2_M1_MASK }, // 619 + { 0x4, 0x1, 0x0, 0x4, 0x1, 0x0, PseudoVLUXSEG4EI16_V_M1_M2_MASK }, // 620 + { 0x4, 0x1, 0x0, 0x4, 0x1, 0x1, PseudoVLUXSEG4EI16_V_M2_M2_MASK }, // 621 + { 0x4, 0x1, 0x0, 0x4, 0x1, 0x2, PseudoVLUXSEG4EI16_V_M4_M2_MASK }, // 622 + { 0x4, 0x1, 0x0, 0x4, 0x1, 0x7, PseudoVLUXSEG4EI16_V_MF2_M2_MASK }, // 623 + { 0x4, 0x1, 0x0, 0x4, 0x5, 0x6, PseudoVLUXSEG4EI16_V_MF4_MF8_MASK }, // 624 + { 0x4, 0x1, 0x0, 0x4, 0x6, 0x6, PseudoVLUXSEG4EI16_V_MF4_MF4_MASK }, // 625 + { 0x4, 0x1, 0x0, 0x4, 0x6, 0x7, PseudoVLUXSEG4EI16_V_MF2_MF4_MASK }, // 626 + { 0x4, 0x1, 0x0, 0x4, 0x7, 0x0, PseudoVLUXSEG4EI16_V_M1_MF2_MASK }, // 627 + { 0x4, 0x1, 0x0, 0x4, 0x7, 0x6, PseudoVLUXSEG4EI16_V_MF4_MF2_MASK }, // 628 + { 0x4, 0x1, 0x0, 0x4, 0x7, 0x7, PseudoVLUXSEG4EI16_V_MF2_MF2_MASK }, // 629 + { 0x4, 0x1, 0x0, 0x5, 0x0, 0x0, PseudoVLUXSEG4EI32_V_M1_M1_MASK }, // 630 + { 0x4, 0x1, 0x0, 0x5, 0x0, 0x1, PseudoVLUXSEG4EI32_V_M2_M1_MASK }, // 631 + { 0x4, 0x1, 0x0, 0x5, 0x0, 0x2, PseudoVLUXSEG4EI32_V_M4_M1_MASK }, // 632 + { 0x4, 0x1, 0x0, 0x5, 0x0, 0x7, PseudoVLUXSEG4EI32_V_MF2_M1_MASK }, // 633 + { 0x4, 0x1, 0x0, 0x5, 0x1, 0x0, PseudoVLUXSEG4EI32_V_M1_M2_MASK }, // 634 + { 0x4, 0x1, 0x0, 0x5, 0x1, 0x1, PseudoVLUXSEG4EI32_V_M2_M2_MASK }, // 635 + { 0x4, 0x1, 0x0, 0x5, 0x1, 0x2, PseudoVLUXSEG4EI32_V_M4_M2_MASK }, // 636 + { 0x4, 0x1, 0x0, 0x5, 0x1, 0x3, PseudoVLUXSEG4EI32_V_M8_M2_MASK }, // 637 + { 0x4, 0x1, 0x0, 0x5, 0x5, 0x7, PseudoVLUXSEG4EI32_V_MF2_MF8_MASK }, // 638 + { 0x4, 0x1, 0x0, 0x5, 0x6, 0x0, PseudoVLUXSEG4EI32_V_M1_MF4_MASK }, // 639 + { 0x4, 0x1, 0x0, 0x5, 0x6, 0x7, PseudoVLUXSEG4EI32_V_MF2_MF4_MASK }, // 640 + { 0x4, 0x1, 0x0, 0x5, 0x7, 0x0, PseudoVLUXSEG4EI32_V_M1_MF2_MASK }, // 641 + { 0x4, 0x1, 0x0, 0x5, 0x7, 0x1, PseudoVLUXSEG4EI32_V_M2_MF2_MASK }, // 642 + { 0x4, 0x1, 0x0, 0x5, 0x7, 0x7, PseudoVLUXSEG4EI32_V_MF2_MF2_MASK }, // 643 + { 0x4, 0x1, 0x0, 0x6, 0x0, 0x0, PseudoVLUXSEG4EI64_V_M1_M1_MASK }, // 644 + { 0x4, 0x1, 0x0, 0x6, 0x0, 0x1, PseudoVLUXSEG4EI64_V_M2_M1_MASK }, // 645 + { 0x4, 0x1, 0x0, 0x6, 0x0, 0x2, PseudoVLUXSEG4EI64_V_M4_M1_MASK }, // 646 + { 0x4, 0x1, 0x0, 0x6, 0x0, 0x3, PseudoVLUXSEG4EI64_V_M8_M1_MASK }, // 647 + { 0x4, 0x1, 0x0, 0x6, 0x1, 0x1, PseudoVLUXSEG4EI64_V_M2_M2_MASK }, // 648 + { 0x4, 0x1, 0x0, 0x6, 0x1, 0x2, PseudoVLUXSEG4EI64_V_M4_M2_MASK }, // 649 + { 0x4, 0x1, 0x0, 0x6, 0x1, 0x3, PseudoVLUXSEG4EI64_V_M8_M2_MASK }, // 650 + { 0x4, 0x1, 0x0, 0x6, 0x5, 0x0, PseudoVLUXSEG4EI64_V_M1_MF8_MASK }, // 651 + { 0x4, 0x1, 0x0, 0x6, 0x6, 0x0, PseudoVLUXSEG4EI64_V_M1_MF4_MASK }, // 652 + { 0x4, 0x1, 0x0, 0x6, 0x6, 0x1, PseudoVLUXSEG4EI64_V_M2_MF4_MASK }, // 653 + { 0x4, 0x1, 0x0, 0x6, 0x7, 0x0, PseudoVLUXSEG4EI64_V_M1_MF2_MASK }, // 654 + { 0x4, 0x1, 0x0, 0x6, 0x7, 0x1, PseudoVLUXSEG4EI64_V_M2_MF2_MASK }, // 655 + { 0x4, 0x1, 0x0, 0x6, 0x7, 0x2, PseudoVLUXSEG4EI64_V_M4_MF2_MASK }, // 656 + { 0x4, 0x1, 0x1, 0x3, 0x0, 0x0, PseudoVLOXSEG4EI8_V_M1_M1_MASK }, // 657 + { 0x4, 0x1, 0x1, 0x3, 0x0, 0x5, PseudoVLOXSEG4EI8_V_MF8_M1_MASK }, // 658 + { 0x4, 0x1, 0x1, 0x3, 0x0, 0x6, PseudoVLOXSEG4EI8_V_MF4_M1_MASK }, // 659 + { 0x4, 0x1, 0x1, 0x3, 0x0, 0x7, PseudoVLOXSEG4EI8_V_MF2_M1_MASK }, // 660 + { 0x4, 0x1, 0x1, 0x3, 0x1, 0x0, PseudoVLOXSEG4EI8_V_M1_M2_MASK }, // 661 + { 0x4, 0x1, 0x1, 0x3, 0x1, 0x1, PseudoVLOXSEG4EI8_V_M2_M2_MASK }, // 662 + { 0x4, 0x1, 0x1, 0x3, 0x1, 0x6, PseudoVLOXSEG4EI8_V_MF4_M2_MASK }, // 663 + { 0x4, 0x1, 0x1, 0x3, 0x1, 0x7, PseudoVLOXSEG4EI8_V_MF2_M2_MASK }, // 664 + { 0x4, 0x1, 0x1, 0x3, 0x5, 0x5, PseudoVLOXSEG4EI8_V_MF8_MF8_MASK }, // 665 + { 0x4, 0x1, 0x1, 0x3, 0x6, 0x5, PseudoVLOXSEG4EI8_V_MF8_MF4_MASK }, // 666 + { 0x4, 0x1, 0x1, 0x3, 0x6, 0x6, PseudoVLOXSEG4EI8_V_MF4_MF4_MASK }, // 667 + { 0x4, 0x1, 0x1, 0x3, 0x7, 0x5, PseudoVLOXSEG4EI8_V_MF8_MF2_MASK }, // 668 + { 0x4, 0x1, 0x1, 0x3, 0x7, 0x6, PseudoVLOXSEG4EI8_V_MF4_MF2_MASK }, // 669 + { 0x4, 0x1, 0x1, 0x3, 0x7, 0x7, PseudoVLOXSEG4EI8_V_MF2_MF2_MASK }, // 670 + { 0x4, 0x1, 0x1, 0x4, 0x0, 0x0, PseudoVLOXSEG4EI16_V_M1_M1_MASK }, // 671 + { 0x4, 0x1, 0x1, 0x4, 0x0, 0x1, PseudoVLOXSEG4EI16_V_M2_M1_MASK }, // 672 + { 0x4, 0x1, 0x1, 0x4, 0x0, 0x6, PseudoVLOXSEG4EI16_V_MF4_M1_MASK }, // 673 + { 0x4, 0x1, 0x1, 0x4, 0x0, 0x7, PseudoVLOXSEG4EI16_V_MF2_M1_MASK }, // 674 + { 0x4, 0x1, 0x1, 0x4, 0x1, 0x0, PseudoVLOXSEG4EI16_V_M1_M2_MASK }, // 675 + { 0x4, 0x1, 0x1, 0x4, 0x1, 0x1, PseudoVLOXSEG4EI16_V_M2_M2_MASK }, // 676 + { 0x4, 0x1, 0x1, 0x4, 0x1, 0x2, PseudoVLOXSEG4EI16_V_M4_M2_MASK }, // 677 + { 0x4, 0x1, 0x1, 0x4, 0x1, 0x7, PseudoVLOXSEG4EI16_V_MF2_M2_MASK }, // 678 + { 0x4, 0x1, 0x1, 0x4, 0x5, 0x6, PseudoVLOXSEG4EI16_V_MF4_MF8_MASK }, // 679 + { 0x4, 0x1, 0x1, 0x4, 0x6, 0x6, PseudoVLOXSEG4EI16_V_MF4_MF4_MASK }, // 680 + { 0x4, 0x1, 0x1, 0x4, 0x6, 0x7, PseudoVLOXSEG4EI16_V_MF2_MF4_MASK }, // 681 + { 0x4, 0x1, 0x1, 0x4, 0x7, 0x0, PseudoVLOXSEG4EI16_V_M1_MF2_MASK }, // 682 + { 0x4, 0x1, 0x1, 0x4, 0x7, 0x6, PseudoVLOXSEG4EI16_V_MF4_MF2_MASK }, // 683 + { 0x4, 0x1, 0x1, 0x4, 0x7, 0x7, PseudoVLOXSEG4EI16_V_MF2_MF2_MASK }, // 684 + { 0x4, 0x1, 0x1, 0x5, 0x0, 0x0, PseudoVLOXSEG4EI32_V_M1_M1_MASK }, // 685 + { 0x4, 0x1, 0x1, 0x5, 0x0, 0x1, PseudoVLOXSEG4EI32_V_M2_M1_MASK }, // 686 + { 0x4, 0x1, 0x1, 0x5, 0x0, 0x2, PseudoVLOXSEG4EI32_V_M4_M1_MASK }, // 687 + { 0x4, 0x1, 0x1, 0x5, 0x0, 0x7, PseudoVLOXSEG4EI32_V_MF2_M1_MASK }, // 688 + { 0x4, 0x1, 0x1, 0x5, 0x1, 0x0, PseudoVLOXSEG4EI32_V_M1_M2_MASK }, // 689 + { 0x4, 0x1, 0x1, 0x5, 0x1, 0x1, PseudoVLOXSEG4EI32_V_M2_M2_MASK }, // 690 + { 0x4, 0x1, 0x1, 0x5, 0x1, 0x2, PseudoVLOXSEG4EI32_V_M4_M2_MASK }, // 691 + { 0x4, 0x1, 0x1, 0x5, 0x1, 0x3, PseudoVLOXSEG4EI32_V_M8_M2_MASK }, // 692 + { 0x4, 0x1, 0x1, 0x5, 0x5, 0x7, PseudoVLOXSEG4EI32_V_MF2_MF8_MASK }, // 693 + { 0x4, 0x1, 0x1, 0x5, 0x6, 0x0, PseudoVLOXSEG4EI32_V_M1_MF4_MASK }, // 694 + { 0x4, 0x1, 0x1, 0x5, 0x6, 0x7, PseudoVLOXSEG4EI32_V_MF2_MF4_MASK }, // 695 + { 0x4, 0x1, 0x1, 0x5, 0x7, 0x0, PseudoVLOXSEG4EI32_V_M1_MF2_MASK }, // 696 + { 0x4, 0x1, 0x1, 0x5, 0x7, 0x1, PseudoVLOXSEG4EI32_V_M2_MF2_MASK }, // 697 + { 0x4, 0x1, 0x1, 0x5, 0x7, 0x7, PseudoVLOXSEG4EI32_V_MF2_MF2_MASK }, // 698 + { 0x4, 0x1, 0x1, 0x6, 0x0, 0x0, PseudoVLOXSEG4EI64_V_M1_M1_MASK }, // 699 + { 0x4, 0x1, 0x1, 0x6, 0x0, 0x1, PseudoVLOXSEG4EI64_V_M2_M1_MASK }, // 700 + { 0x4, 0x1, 0x1, 0x6, 0x0, 0x2, PseudoVLOXSEG4EI64_V_M4_M1_MASK }, // 701 + { 0x4, 0x1, 0x1, 0x6, 0x0, 0x3, PseudoVLOXSEG4EI64_V_M8_M1_MASK }, // 702 + { 0x4, 0x1, 0x1, 0x6, 0x1, 0x1, PseudoVLOXSEG4EI64_V_M2_M2_MASK }, // 703 + { 0x4, 0x1, 0x1, 0x6, 0x1, 0x2, PseudoVLOXSEG4EI64_V_M4_M2_MASK }, // 704 + { 0x4, 0x1, 0x1, 0x6, 0x1, 0x3, PseudoVLOXSEG4EI64_V_M8_M2_MASK }, // 705 + { 0x4, 0x1, 0x1, 0x6, 0x5, 0x0, PseudoVLOXSEG4EI64_V_M1_MF8_MASK }, // 706 + { 0x4, 0x1, 0x1, 0x6, 0x6, 0x0, PseudoVLOXSEG4EI64_V_M1_MF4_MASK }, // 707 + { 0x4, 0x1, 0x1, 0x6, 0x6, 0x1, PseudoVLOXSEG4EI64_V_M2_MF4_MASK }, // 708 + { 0x4, 0x1, 0x1, 0x6, 0x7, 0x0, PseudoVLOXSEG4EI64_V_M1_MF2_MASK }, // 709 + { 0x4, 0x1, 0x1, 0x6, 0x7, 0x1, PseudoVLOXSEG4EI64_V_M2_MF2_MASK }, // 710 + { 0x4, 0x1, 0x1, 0x6, 0x7, 0x2, PseudoVLOXSEG4EI64_V_M4_MF2_MASK }, // 711 + { 0x5, 0x0, 0x0, 0x3, 0x0, 0x0, PseudoVLUXSEG5EI8_V_M1_M1 }, // 712 + { 0x5, 0x0, 0x0, 0x3, 0x0, 0x5, PseudoVLUXSEG5EI8_V_MF8_M1 }, // 713 + { 0x5, 0x0, 0x0, 0x3, 0x0, 0x6, PseudoVLUXSEG5EI8_V_MF4_M1 }, // 714 + { 0x5, 0x0, 0x0, 0x3, 0x0, 0x7, PseudoVLUXSEG5EI8_V_MF2_M1 }, // 715 + { 0x5, 0x0, 0x0, 0x3, 0x5, 0x5, PseudoVLUXSEG5EI8_V_MF8_MF8 }, // 716 + { 0x5, 0x0, 0x0, 0x3, 0x6, 0x5, PseudoVLUXSEG5EI8_V_MF8_MF4 }, // 717 + { 0x5, 0x0, 0x0, 0x3, 0x6, 0x6, PseudoVLUXSEG5EI8_V_MF4_MF4 }, // 718 + { 0x5, 0x0, 0x0, 0x3, 0x7, 0x5, PseudoVLUXSEG5EI8_V_MF8_MF2 }, // 719 + { 0x5, 0x0, 0x0, 0x3, 0x7, 0x6, PseudoVLUXSEG5EI8_V_MF4_MF2 }, // 720 + { 0x5, 0x0, 0x0, 0x3, 0x7, 0x7, PseudoVLUXSEG5EI8_V_MF2_MF2 }, // 721 + { 0x5, 0x0, 0x0, 0x4, 0x0, 0x0, PseudoVLUXSEG5EI16_V_M1_M1 }, // 722 + { 0x5, 0x0, 0x0, 0x4, 0x0, 0x1, PseudoVLUXSEG5EI16_V_M2_M1 }, // 723 + { 0x5, 0x0, 0x0, 0x4, 0x0, 0x6, PseudoVLUXSEG5EI16_V_MF4_M1 }, // 724 + { 0x5, 0x0, 0x0, 0x4, 0x0, 0x7, PseudoVLUXSEG5EI16_V_MF2_M1 }, // 725 + { 0x5, 0x0, 0x0, 0x4, 0x5, 0x6, PseudoVLUXSEG5EI16_V_MF4_MF8 }, // 726 + { 0x5, 0x0, 0x0, 0x4, 0x6, 0x6, PseudoVLUXSEG5EI16_V_MF4_MF4 }, // 727 + { 0x5, 0x0, 0x0, 0x4, 0x6, 0x7, PseudoVLUXSEG5EI16_V_MF2_MF4 }, // 728 + { 0x5, 0x0, 0x0, 0x4, 0x7, 0x0, PseudoVLUXSEG5EI16_V_M1_MF2 }, // 729 + { 0x5, 0x0, 0x0, 0x4, 0x7, 0x6, PseudoVLUXSEG5EI16_V_MF4_MF2 }, // 730 + { 0x5, 0x0, 0x0, 0x4, 0x7, 0x7, PseudoVLUXSEG5EI16_V_MF2_MF2 }, // 731 + { 0x5, 0x0, 0x0, 0x5, 0x0, 0x0, PseudoVLUXSEG5EI32_V_M1_M1 }, // 732 + { 0x5, 0x0, 0x0, 0x5, 0x0, 0x1, PseudoVLUXSEG5EI32_V_M2_M1 }, // 733 + { 0x5, 0x0, 0x0, 0x5, 0x0, 0x2, PseudoVLUXSEG5EI32_V_M4_M1 }, // 734 + { 0x5, 0x0, 0x0, 0x5, 0x0, 0x7, PseudoVLUXSEG5EI32_V_MF2_M1 }, // 735 + { 0x5, 0x0, 0x0, 0x5, 0x5, 0x7, PseudoVLUXSEG5EI32_V_MF2_MF8 }, // 736 + { 0x5, 0x0, 0x0, 0x5, 0x6, 0x0, PseudoVLUXSEG5EI32_V_M1_MF4 }, // 737 + { 0x5, 0x0, 0x0, 0x5, 0x6, 0x7, PseudoVLUXSEG5EI32_V_MF2_MF4 }, // 738 + { 0x5, 0x0, 0x0, 0x5, 0x7, 0x0, PseudoVLUXSEG5EI32_V_M1_MF2 }, // 739 + { 0x5, 0x0, 0x0, 0x5, 0x7, 0x1, PseudoVLUXSEG5EI32_V_M2_MF2 }, // 740 + { 0x5, 0x0, 0x0, 0x5, 0x7, 0x7, PseudoVLUXSEG5EI32_V_MF2_MF2 }, // 741 + { 0x5, 0x0, 0x0, 0x6, 0x0, 0x0, PseudoVLUXSEG5EI64_V_M1_M1 }, // 742 + { 0x5, 0x0, 0x0, 0x6, 0x0, 0x1, PseudoVLUXSEG5EI64_V_M2_M1 }, // 743 + { 0x5, 0x0, 0x0, 0x6, 0x0, 0x2, PseudoVLUXSEG5EI64_V_M4_M1 }, // 744 + { 0x5, 0x0, 0x0, 0x6, 0x0, 0x3, PseudoVLUXSEG5EI64_V_M8_M1 }, // 745 + { 0x5, 0x0, 0x0, 0x6, 0x5, 0x0, PseudoVLUXSEG5EI64_V_M1_MF8 }, // 746 + { 0x5, 0x0, 0x0, 0x6, 0x6, 0x0, PseudoVLUXSEG5EI64_V_M1_MF4 }, // 747 + { 0x5, 0x0, 0x0, 0x6, 0x6, 0x1, PseudoVLUXSEG5EI64_V_M2_MF4 }, // 748 + { 0x5, 0x0, 0x0, 0x6, 0x7, 0x0, PseudoVLUXSEG5EI64_V_M1_MF2 }, // 749 + { 0x5, 0x0, 0x0, 0x6, 0x7, 0x1, PseudoVLUXSEG5EI64_V_M2_MF2 }, // 750 + { 0x5, 0x0, 0x0, 0x6, 0x7, 0x2, PseudoVLUXSEG5EI64_V_M4_MF2 }, // 751 + { 0x5, 0x0, 0x1, 0x3, 0x0, 0x0, PseudoVLOXSEG5EI8_V_M1_M1 }, // 752 + { 0x5, 0x0, 0x1, 0x3, 0x0, 0x5, PseudoVLOXSEG5EI8_V_MF8_M1 }, // 753 + { 0x5, 0x0, 0x1, 0x3, 0x0, 0x6, PseudoVLOXSEG5EI8_V_MF4_M1 }, // 754 + { 0x5, 0x0, 0x1, 0x3, 0x0, 0x7, PseudoVLOXSEG5EI8_V_MF2_M1 }, // 755 + { 0x5, 0x0, 0x1, 0x3, 0x5, 0x5, PseudoVLOXSEG5EI8_V_MF8_MF8 }, // 756 + { 0x5, 0x0, 0x1, 0x3, 0x6, 0x5, PseudoVLOXSEG5EI8_V_MF8_MF4 }, // 757 + { 0x5, 0x0, 0x1, 0x3, 0x6, 0x6, PseudoVLOXSEG5EI8_V_MF4_MF4 }, // 758 + { 0x5, 0x0, 0x1, 0x3, 0x7, 0x5, PseudoVLOXSEG5EI8_V_MF8_MF2 }, // 759 + { 0x5, 0x0, 0x1, 0x3, 0x7, 0x6, PseudoVLOXSEG5EI8_V_MF4_MF2 }, // 760 + { 0x5, 0x0, 0x1, 0x3, 0x7, 0x7, PseudoVLOXSEG5EI8_V_MF2_MF2 }, // 761 + { 0x5, 0x0, 0x1, 0x4, 0x0, 0x0, PseudoVLOXSEG5EI16_V_M1_M1 }, // 762 + { 0x5, 0x0, 0x1, 0x4, 0x0, 0x1, PseudoVLOXSEG5EI16_V_M2_M1 }, // 763 + { 0x5, 0x0, 0x1, 0x4, 0x0, 0x6, PseudoVLOXSEG5EI16_V_MF4_M1 }, // 764 + { 0x5, 0x0, 0x1, 0x4, 0x0, 0x7, PseudoVLOXSEG5EI16_V_MF2_M1 }, // 765 + { 0x5, 0x0, 0x1, 0x4, 0x5, 0x6, PseudoVLOXSEG5EI16_V_MF4_MF8 }, // 766 + { 0x5, 0x0, 0x1, 0x4, 0x6, 0x6, PseudoVLOXSEG5EI16_V_MF4_MF4 }, // 767 + { 0x5, 0x0, 0x1, 0x4, 0x6, 0x7, PseudoVLOXSEG5EI16_V_MF2_MF4 }, // 768 + { 0x5, 0x0, 0x1, 0x4, 0x7, 0x0, PseudoVLOXSEG5EI16_V_M1_MF2 }, // 769 + { 0x5, 0x0, 0x1, 0x4, 0x7, 0x6, PseudoVLOXSEG5EI16_V_MF4_MF2 }, // 770 + { 0x5, 0x0, 0x1, 0x4, 0x7, 0x7, PseudoVLOXSEG5EI16_V_MF2_MF2 }, // 771 + { 0x5, 0x0, 0x1, 0x5, 0x0, 0x0, PseudoVLOXSEG5EI32_V_M1_M1 }, // 772 + { 0x5, 0x0, 0x1, 0x5, 0x0, 0x1, PseudoVLOXSEG5EI32_V_M2_M1 }, // 773 + { 0x5, 0x0, 0x1, 0x5, 0x0, 0x2, PseudoVLOXSEG5EI32_V_M4_M1 }, // 774 + { 0x5, 0x0, 0x1, 0x5, 0x0, 0x7, PseudoVLOXSEG5EI32_V_MF2_M1 }, // 775 + { 0x5, 0x0, 0x1, 0x5, 0x5, 0x7, PseudoVLOXSEG5EI32_V_MF2_MF8 }, // 776 + { 0x5, 0x0, 0x1, 0x5, 0x6, 0x0, PseudoVLOXSEG5EI32_V_M1_MF4 }, // 777 + { 0x5, 0x0, 0x1, 0x5, 0x6, 0x7, PseudoVLOXSEG5EI32_V_MF2_MF4 }, // 778 + { 0x5, 0x0, 0x1, 0x5, 0x7, 0x0, PseudoVLOXSEG5EI32_V_M1_MF2 }, // 779 + { 0x5, 0x0, 0x1, 0x5, 0x7, 0x1, PseudoVLOXSEG5EI32_V_M2_MF2 }, // 780 + { 0x5, 0x0, 0x1, 0x5, 0x7, 0x7, PseudoVLOXSEG5EI32_V_MF2_MF2 }, // 781 + { 0x5, 0x0, 0x1, 0x6, 0x0, 0x0, PseudoVLOXSEG5EI64_V_M1_M1 }, // 782 + { 0x5, 0x0, 0x1, 0x6, 0x0, 0x1, PseudoVLOXSEG5EI64_V_M2_M1 }, // 783 + { 0x5, 0x0, 0x1, 0x6, 0x0, 0x2, PseudoVLOXSEG5EI64_V_M4_M1 }, // 784 + { 0x5, 0x0, 0x1, 0x6, 0x0, 0x3, PseudoVLOXSEG5EI64_V_M8_M1 }, // 785 + { 0x5, 0x0, 0x1, 0x6, 0x5, 0x0, PseudoVLOXSEG5EI64_V_M1_MF8 }, // 786 + { 0x5, 0x0, 0x1, 0x6, 0x6, 0x0, PseudoVLOXSEG5EI64_V_M1_MF4 }, // 787 + { 0x5, 0x0, 0x1, 0x6, 0x6, 0x1, PseudoVLOXSEG5EI64_V_M2_MF4 }, // 788 + { 0x5, 0x0, 0x1, 0x6, 0x7, 0x0, PseudoVLOXSEG5EI64_V_M1_MF2 }, // 789 + { 0x5, 0x0, 0x1, 0x6, 0x7, 0x1, PseudoVLOXSEG5EI64_V_M2_MF2 }, // 790 + { 0x5, 0x0, 0x1, 0x6, 0x7, 0x2, PseudoVLOXSEG5EI64_V_M4_MF2 }, // 791 + { 0x5, 0x1, 0x0, 0x3, 0x0, 0x0, PseudoVLUXSEG5EI8_V_M1_M1_MASK }, // 792 + { 0x5, 0x1, 0x0, 0x3, 0x0, 0x5, PseudoVLUXSEG5EI8_V_MF8_M1_MASK }, // 793 + { 0x5, 0x1, 0x0, 0x3, 0x0, 0x6, PseudoVLUXSEG5EI8_V_MF4_M1_MASK }, // 794 + { 0x5, 0x1, 0x0, 0x3, 0x0, 0x7, PseudoVLUXSEG5EI8_V_MF2_M1_MASK }, // 795 + { 0x5, 0x1, 0x0, 0x3, 0x5, 0x5, PseudoVLUXSEG5EI8_V_MF8_MF8_MASK }, // 796 + { 0x5, 0x1, 0x0, 0x3, 0x6, 0x5, PseudoVLUXSEG5EI8_V_MF8_MF4_MASK }, // 797 + { 0x5, 0x1, 0x0, 0x3, 0x6, 0x6, PseudoVLUXSEG5EI8_V_MF4_MF4_MASK }, // 798 + { 0x5, 0x1, 0x0, 0x3, 0x7, 0x5, PseudoVLUXSEG5EI8_V_MF8_MF2_MASK }, // 799 + { 0x5, 0x1, 0x0, 0x3, 0x7, 0x6, PseudoVLUXSEG5EI8_V_MF4_MF2_MASK }, // 800 + { 0x5, 0x1, 0x0, 0x3, 0x7, 0x7, PseudoVLUXSEG5EI8_V_MF2_MF2_MASK }, // 801 + { 0x5, 0x1, 0x0, 0x4, 0x0, 0x0, PseudoVLUXSEG5EI16_V_M1_M1_MASK }, // 802 + { 0x5, 0x1, 0x0, 0x4, 0x0, 0x1, PseudoVLUXSEG5EI16_V_M2_M1_MASK }, // 803 + { 0x5, 0x1, 0x0, 0x4, 0x0, 0x6, PseudoVLUXSEG5EI16_V_MF4_M1_MASK }, // 804 + { 0x5, 0x1, 0x0, 0x4, 0x0, 0x7, PseudoVLUXSEG5EI16_V_MF2_M1_MASK }, // 805 + { 0x5, 0x1, 0x0, 0x4, 0x5, 0x6, PseudoVLUXSEG5EI16_V_MF4_MF8_MASK }, // 806 + { 0x5, 0x1, 0x0, 0x4, 0x6, 0x6, PseudoVLUXSEG5EI16_V_MF4_MF4_MASK }, // 807 + { 0x5, 0x1, 0x0, 0x4, 0x6, 0x7, PseudoVLUXSEG5EI16_V_MF2_MF4_MASK }, // 808 + { 0x5, 0x1, 0x0, 0x4, 0x7, 0x0, PseudoVLUXSEG5EI16_V_M1_MF2_MASK }, // 809 + { 0x5, 0x1, 0x0, 0x4, 0x7, 0x6, PseudoVLUXSEG5EI16_V_MF4_MF2_MASK }, // 810 + { 0x5, 0x1, 0x0, 0x4, 0x7, 0x7, PseudoVLUXSEG5EI16_V_MF2_MF2_MASK }, // 811 + { 0x5, 0x1, 0x0, 0x5, 0x0, 0x0, PseudoVLUXSEG5EI32_V_M1_M1_MASK }, // 812 + { 0x5, 0x1, 0x0, 0x5, 0x0, 0x1, PseudoVLUXSEG5EI32_V_M2_M1_MASK }, // 813 + { 0x5, 0x1, 0x0, 0x5, 0x0, 0x2, PseudoVLUXSEG5EI32_V_M4_M1_MASK }, // 814 + { 0x5, 0x1, 0x0, 0x5, 0x0, 0x7, PseudoVLUXSEG5EI32_V_MF2_M1_MASK }, // 815 + { 0x5, 0x1, 0x0, 0x5, 0x5, 0x7, PseudoVLUXSEG5EI32_V_MF2_MF8_MASK }, // 816 + { 0x5, 0x1, 0x0, 0x5, 0x6, 0x0, PseudoVLUXSEG5EI32_V_M1_MF4_MASK }, // 817 + { 0x5, 0x1, 0x0, 0x5, 0x6, 0x7, PseudoVLUXSEG5EI32_V_MF2_MF4_MASK }, // 818 + { 0x5, 0x1, 0x0, 0x5, 0x7, 0x0, PseudoVLUXSEG5EI32_V_M1_MF2_MASK }, // 819 + { 0x5, 0x1, 0x0, 0x5, 0x7, 0x1, PseudoVLUXSEG5EI32_V_M2_MF2_MASK }, // 820 + { 0x5, 0x1, 0x0, 0x5, 0x7, 0x7, PseudoVLUXSEG5EI32_V_MF2_MF2_MASK }, // 821 + { 0x5, 0x1, 0x0, 0x6, 0x0, 0x0, PseudoVLUXSEG5EI64_V_M1_M1_MASK }, // 822 + { 0x5, 0x1, 0x0, 0x6, 0x0, 0x1, PseudoVLUXSEG5EI64_V_M2_M1_MASK }, // 823 + { 0x5, 0x1, 0x0, 0x6, 0x0, 0x2, PseudoVLUXSEG5EI64_V_M4_M1_MASK }, // 824 + { 0x5, 0x1, 0x0, 0x6, 0x0, 0x3, PseudoVLUXSEG5EI64_V_M8_M1_MASK }, // 825 + { 0x5, 0x1, 0x0, 0x6, 0x5, 0x0, PseudoVLUXSEG5EI64_V_M1_MF8_MASK }, // 826 + { 0x5, 0x1, 0x0, 0x6, 0x6, 0x0, PseudoVLUXSEG5EI64_V_M1_MF4_MASK }, // 827 + { 0x5, 0x1, 0x0, 0x6, 0x6, 0x1, PseudoVLUXSEG5EI64_V_M2_MF4_MASK }, // 828 + { 0x5, 0x1, 0x0, 0x6, 0x7, 0x0, PseudoVLUXSEG5EI64_V_M1_MF2_MASK }, // 829 + { 0x5, 0x1, 0x0, 0x6, 0x7, 0x1, PseudoVLUXSEG5EI64_V_M2_MF2_MASK }, // 830 + { 0x5, 0x1, 0x0, 0x6, 0x7, 0x2, PseudoVLUXSEG5EI64_V_M4_MF2_MASK }, // 831 + { 0x5, 0x1, 0x1, 0x3, 0x0, 0x0, PseudoVLOXSEG5EI8_V_M1_M1_MASK }, // 832 + { 0x5, 0x1, 0x1, 0x3, 0x0, 0x5, PseudoVLOXSEG5EI8_V_MF8_M1_MASK }, // 833 + { 0x5, 0x1, 0x1, 0x3, 0x0, 0x6, PseudoVLOXSEG5EI8_V_MF4_M1_MASK }, // 834 + { 0x5, 0x1, 0x1, 0x3, 0x0, 0x7, PseudoVLOXSEG5EI8_V_MF2_M1_MASK }, // 835 + { 0x5, 0x1, 0x1, 0x3, 0x5, 0x5, PseudoVLOXSEG5EI8_V_MF8_MF8_MASK }, // 836 + { 0x5, 0x1, 0x1, 0x3, 0x6, 0x5, PseudoVLOXSEG5EI8_V_MF8_MF4_MASK }, // 837 + { 0x5, 0x1, 0x1, 0x3, 0x6, 0x6, PseudoVLOXSEG5EI8_V_MF4_MF4_MASK }, // 838 + { 0x5, 0x1, 0x1, 0x3, 0x7, 0x5, PseudoVLOXSEG5EI8_V_MF8_MF2_MASK }, // 839 + { 0x5, 0x1, 0x1, 0x3, 0x7, 0x6, PseudoVLOXSEG5EI8_V_MF4_MF2_MASK }, // 840 + { 0x5, 0x1, 0x1, 0x3, 0x7, 0x7, PseudoVLOXSEG5EI8_V_MF2_MF2_MASK }, // 841 + { 0x5, 0x1, 0x1, 0x4, 0x0, 0x0, PseudoVLOXSEG5EI16_V_M1_M1_MASK }, // 842 + { 0x5, 0x1, 0x1, 0x4, 0x0, 0x1, PseudoVLOXSEG5EI16_V_M2_M1_MASK }, // 843 + { 0x5, 0x1, 0x1, 0x4, 0x0, 0x6, PseudoVLOXSEG5EI16_V_MF4_M1_MASK }, // 844 + { 0x5, 0x1, 0x1, 0x4, 0x0, 0x7, PseudoVLOXSEG5EI16_V_MF2_M1_MASK }, // 845 + { 0x5, 0x1, 0x1, 0x4, 0x5, 0x6, PseudoVLOXSEG5EI16_V_MF4_MF8_MASK }, // 846 + { 0x5, 0x1, 0x1, 0x4, 0x6, 0x6, PseudoVLOXSEG5EI16_V_MF4_MF4_MASK }, // 847 + { 0x5, 0x1, 0x1, 0x4, 0x6, 0x7, PseudoVLOXSEG5EI16_V_MF2_MF4_MASK }, // 848 + { 0x5, 0x1, 0x1, 0x4, 0x7, 0x0, PseudoVLOXSEG5EI16_V_M1_MF2_MASK }, // 849 + { 0x5, 0x1, 0x1, 0x4, 0x7, 0x6, PseudoVLOXSEG5EI16_V_MF4_MF2_MASK }, // 850 + { 0x5, 0x1, 0x1, 0x4, 0x7, 0x7, PseudoVLOXSEG5EI16_V_MF2_MF2_MASK }, // 851 + { 0x5, 0x1, 0x1, 0x5, 0x0, 0x0, PseudoVLOXSEG5EI32_V_M1_M1_MASK }, // 852 + { 0x5, 0x1, 0x1, 0x5, 0x0, 0x1, PseudoVLOXSEG5EI32_V_M2_M1_MASK }, // 853 + { 0x5, 0x1, 0x1, 0x5, 0x0, 0x2, PseudoVLOXSEG5EI32_V_M4_M1_MASK }, // 854 + { 0x5, 0x1, 0x1, 0x5, 0x0, 0x7, PseudoVLOXSEG5EI32_V_MF2_M1_MASK }, // 855 + { 0x5, 0x1, 0x1, 0x5, 0x5, 0x7, PseudoVLOXSEG5EI32_V_MF2_MF8_MASK }, // 856 + { 0x5, 0x1, 0x1, 0x5, 0x6, 0x0, PseudoVLOXSEG5EI32_V_M1_MF4_MASK }, // 857 + { 0x5, 0x1, 0x1, 0x5, 0x6, 0x7, PseudoVLOXSEG5EI32_V_MF2_MF4_MASK }, // 858 + { 0x5, 0x1, 0x1, 0x5, 0x7, 0x0, PseudoVLOXSEG5EI32_V_M1_MF2_MASK }, // 859 + { 0x5, 0x1, 0x1, 0x5, 0x7, 0x1, PseudoVLOXSEG5EI32_V_M2_MF2_MASK }, // 860 + { 0x5, 0x1, 0x1, 0x5, 0x7, 0x7, PseudoVLOXSEG5EI32_V_MF2_MF2_MASK }, // 861 + { 0x5, 0x1, 0x1, 0x6, 0x0, 0x0, PseudoVLOXSEG5EI64_V_M1_M1_MASK }, // 862 + { 0x5, 0x1, 0x1, 0x6, 0x0, 0x1, PseudoVLOXSEG5EI64_V_M2_M1_MASK }, // 863 + { 0x5, 0x1, 0x1, 0x6, 0x0, 0x2, PseudoVLOXSEG5EI64_V_M4_M1_MASK }, // 864 + { 0x5, 0x1, 0x1, 0x6, 0x0, 0x3, PseudoVLOXSEG5EI64_V_M8_M1_MASK }, // 865 + { 0x5, 0x1, 0x1, 0x6, 0x5, 0x0, PseudoVLOXSEG5EI64_V_M1_MF8_MASK }, // 866 + { 0x5, 0x1, 0x1, 0x6, 0x6, 0x0, PseudoVLOXSEG5EI64_V_M1_MF4_MASK }, // 867 + { 0x5, 0x1, 0x1, 0x6, 0x6, 0x1, PseudoVLOXSEG5EI64_V_M2_MF4_MASK }, // 868 + { 0x5, 0x1, 0x1, 0x6, 0x7, 0x0, PseudoVLOXSEG5EI64_V_M1_MF2_MASK }, // 869 + { 0x5, 0x1, 0x1, 0x6, 0x7, 0x1, PseudoVLOXSEG5EI64_V_M2_MF2_MASK }, // 870 + { 0x5, 0x1, 0x1, 0x6, 0x7, 0x2, PseudoVLOXSEG5EI64_V_M4_MF2_MASK }, // 871 + { 0x6, 0x0, 0x0, 0x3, 0x0, 0x0, PseudoVLUXSEG6EI8_V_M1_M1 }, // 872 + { 0x6, 0x0, 0x0, 0x3, 0x0, 0x5, PseudoVLUXSEG6EI8_V_MF8_M1 }, // 873 + { 0x6, 0x0, 0x0, 0x3, 0x0, 0x6, PseudoVLUXSEG6EI8_V_MF4_M1 }, // 874 + { 0x6, 0x0, 0x0, 0x3, 0x0, 0x7, PseudoVLUXSEG6EI8_V_MF2_M1 }, // 875 + { 0x6, 0x0, 0x0, 0x3, 0x5, 0x5, PseudoVLUXSEG6EI8_V_MF8_MF8 }, // 876 + { 0x6, 0x0, 0x0, 0x3, 0x6, 0x5, PseudoVLUXSEG6EI8_V_MF8_MF4 }, // 877 + { 0x6, 0x0, 0x0, 0x3, 0x6, 0x6, PseudoVLUXSEG6EI8_V_MF4_MF4 }, // 878 + { 0x6, 0x0, 0x0, 0x3, 0x7, 0x5, PseudoVLUXSEG6EI8_V_MF8_MF2 }, // 879 + { 0x6, 0x0, 0x0, 0x3, 0x7, 0x6, PseudoVLUXSEG6EI8_V_MF4_MF2 }, // 880 + { 0x6, 0x0, 0x0, 0x3, 0x7, 0x7, PseudoVLUXSEG6EI8_V_MF2_MF2 }, // 881 + { 0x6, 0x0, 0x0, 0x4, 0x0, 0x0, PseudoVLUXSEG6EI16_V_M1_M1 }, // 882 + { 0x6, 0x0, 0x0, 0x4, 0x0, 0x1, PseudoVLUXSEG6EI16_V_M2_M1 }, // 883 + { 0x6, 0x0, 0x0, 0x4, 0x0, 0x6, PseudoVLUXSEG6EI16_V_MF4_M1 }, // 884 + { 0x6, 0x0, 0x0, 0x4, 0x0, 0x7, PseudoVLUXSEG6EI16_V_MF2_M1 }, // 885 + { 0x6, 0x0, 0x0, 0x4, 0x5, 0x6, PseudoVLUXSEG6EI16_V_MF4_MF8 }, // 886 + { 0x6, 0x0, 0x0, 0x4, 0x6, 0x6, PseudoVLUXSEG6EI16_V_MF4_MF4 }, // 887 + { 0x6, 0x0, 0x0, 0x4, 0x6, 0x7, PseudoVLUXSEG6EI16_V_MF2_MF4 }, // 888 + { 0x6, 0x0, 0x0, 0x4, 0x7, 0x0, PseudoVLUXSEG6EI16_V_M1_MF2 }, // 889 + { 0x6, 0x0, 0x0, 0x4, 0x7, 0x6, PseudoVLUXSEG6EI16_V_MF4_MF2 }, // 890 + { 0x6, 0x0, 0x0, 0x4, 0x7, 0x7, PseudoVLUXSEG6EI16_V_MF2_MF2 }, // 891 + { 0x6, 0x0, 0x0, 0x5, 0x0, 0x0, PseudoVLUXSEG6EI32_V_M1_M1 }, // 892 + { 0x6, 0x0, 0x0, 0x5, 0x0, 0x1, PseudoVLUXSEG6EI32_V_M2_M1 }, // 893 + { 0x6, 0x0, 0x0, 0x5, 0x0, 0x2, PseudoVLUXSEG6EI32_V_M4_M1 }, // 894 + { 0x6, 0x0, 0x0, 0x5, 0x0, 0x7, PseudoVLUXSEG6EI32_V_MF2_M1 }, // 895 + { 0x6, 0x0, 0x0, 0x5, 0x5, 0x7, PseudoVLUXSEG6EI32_V_MF2_MF8 }, // 896 + { 0x6, 0x0, 0x0, 0x5, 0x6, 0x0, PseudoVLUXSEG6EI32_V_M1_MF4 }, // 897 + { 0x6, 0x0, 0x0, 0x5, 0x6, 0x7, PseudoVLUXSEG6EI32_V_MF2_MF4 }, // 898 + { 0x6, 0x0, 0x0, 0x5, 0x7, 0x0, PseudoVLUXSEG6EI32_V_M1_MF2 }, // 899 + { 0x6, 0x0, 0x0, 0x5, 0x7, 0x1, PseudoVLUXSEG6EI32_V_M2_MF2 }, // 900 + { 0x6, 0x0, 0x0, 0x5, 0x7, 0x7, PseudoVLUXSEG6EI32_V_MF2_MF2 }, // 901 + { 0x6, 0x0, 0x0, 0x6, 0x0, 0x0, PseudoVLUXSEG6EI64_V_M1_M1 }, // 902 + { 0x6, 0x0, 0x0, 0x6, 0x0, 0x1, PseudoVLUXSEG6EI64_V_M2_M1 }, // 903 + { 0x6, 0x0, 0x0, 0x6, 0x0, 0x2, PseudoVLUXSEG6EI64_V_M4_M1 }, // 904 + { 0x6, 0x0, 0x0, 0x6, 0x0, 0x3, PseudoVLUXSEG6EI64_V_M8_M1 }, // 905 + { 0x6, 0x0, 0x0, 0x6, 0x5, 0x0, PseudoVLUXSEG6EI64_V_M1_MF8 }, // 906 + { 0x6, 0x0, 0x0, 0x6, 0x6, 0x0, PseudoVLUXSEG6EI64_V_M1_MF4 }, // 907 + { 0x6, 0x0, 0x0, 0x6, 0x6, 0x1, PseudoVLUXSEG6EI64_V_M2_MF4 }, // 908 + { 0x6, 0x0, 0x0, 0x6, 0x7, 0x0, PseudoVLUXSEG6EI64_V_M1_MF2 }, // 909 + { 0x6, 0x0, 0x0, 0x6, 0x7, 0x1, PseudoVLUXSEG6EI64_V_M2_MF2 }, // 910 + { 0x6, 0x0, 0x0, 0x6, 0x7, 0x2, PseudoVLUXSEG6EI64_V_M4_MF2 }, // 911 + { 0x6, 0x0, 0x1, 0x3, 0x0, 0x0, PseudoVLOXSEG6EI8_V_M1_M1 }, // 912 + { 0x6, 0x0, 0x1, 0x3, 0x0, 0x5, PseudoVLOXSEG6EI8_V_MF8_M1 }, // 913 + { 0x6, 0x0, 0x1, 0x3, 0x0, 0x6, PseudoVLOXSEG6EI8_V_MF4_M1 }, // 914 + { 0x6, 0x0, 0x1, 0x3, 0x0, 0x7, PseudoVLOXSEG6EI8_V_MF2_M1 }, // 915 + { 0x6, 0x0, 0x1, 0x3, 0x5, 0x5, PseudoVLOXSEG6EI8_V_MF8_MF8 }, // 916 + { 0x6, 0x0, 0x1, 0x3, 0x6, 0x5, PseudoVLOXSEG6EI8_V_MF8_MF4 }, // 917 + { 0x6, 0x0, 0x1, 0x3, 0x6, 0x6, PseudoVLOXSEG6EI8_V_MF4_MF4 }, // 918 + { 0x6, 0x0, 0x1, 0x3, 0x7, 0x5, PseudoVLOXSEG6EI8_V_MF8_MF2 }, // 919 + { 0x6, 0x0, 0x1, 0x3, 0x7, 0x6, PseudoVLOXSEG6EI8_V_MF4_MF2 }, // 920 + { 0x6, 0x0, 0x1, 0x3, 0x7, 0x7, PseudoVLOXSEG6EI8_V_MF2_MF2 }, // 921 + { 0x6, 0x0, 0x1, 0x4, 0x0, 0x0, PseudoVLOXSEG6EI16_V_M1_M1 }, // 922 + { 0x6, 0x0, 0x1, 0x4, 0x0, 0x1, PseudoVLOXSEG6EI16_V_M2_M1 }, // 923 + { 0x6, 0x0, 0x1, 0x4, 0x0, 0x6, PseudoVLOXSEG6EI16_V_MF4_M1 }, // 924 + { 0x6, 0x0, 0x1, 0x4, 0x0, 0x7, PseudoVLOXSEG6EI16_V_MF2_M1 }, // 925 + { 0x6, 0x0, 0x1, 0x4, 0x5, 0x6, PseudoVLOXSEG6EI16_V_MF4_MF8 }, // 926 + { 0x6, 0x0, 0x1, 0x4, 0x6, 0x6, PseudoVLOXSEG6EI16_V_MF4_MF4 }, // 927 + { 0x6, 0x0, 0x1, 0x4, 0x6, 0x7, PseudoVLOXSEG6EI16_V_MF2_MF4 }, // 928 + { 0x6, 0x0, 0x1, 0x4, 0x7, 0x0, PseudoVLOXSEG6EI16_V_M1_MF2 }, // 929 + { 0x6, 0x0, 0x1, 0x4, 0x7, 0x6, PseudoVLOXSEG6EI16_V_MF4_MF2 }, // 930 + { 0x6, 0x0, 0x1, 0x4, 0x7, 0x7, PseudoVLOXSEG6EI16_V_MF2_MF2 }, // 931 + { 0x6, 0x0, 0x1, 0x5, 0x0, 0x0, PseudoVLOXSEG6EI32_V_M1_M1 }, // 932 + { 0x6, 0x0, 0x1, 0x5, 0x0, 0x1, PseudoVLOXSEG6EI32_V_M2_M1 }, // 933 + { 0x6, 0x0, 0x1, 0x5, 0x0, 0x2, PseudoVLOXSEG6EI32_V_M4_M1 }, // 934 + { 0x6, 0x0, 0x1, 0x5, 0x0, 0x7, PseudoVLOXSEG6EI32_V_MF2_M1 }, // 935 + { 0x6, 0x0, 0x1, 0x5, 0x5, 0x7, PseudoVLOXSEG6EI32_V_MF2_MF8 }, // 936 + { 0x6, 0x0, 0x1, 0x5, 0x6, 0x0, PseudoVLOXSEG6EI32_V_M1_MF4 }, // 937 + { 0x6, 0x0, 0x1, 0x5, 0x6, 0x7, PseudoVLOXSEG6EI32_V_MF2_MF4 }, // 938 + { 0x6, 0x0, 0x1, 0x5, 0x7, 0x0, PseudoVLOXSEG6EI32_V_M1_MF2 }, // 939 + { 0x6, 0x0, 0x1, 0x5, 0x7, 0x1, PseudoVLOXSEG6EI32_V_M2_MF2 }, // 940 + { 0x6, 0x0, 0x1, 0x5, 0x7, 0x7, PseudoVLOXSEG6EI32_V_MF2_MF2 }, // 941 + { 0x6, 0x0, 0x1, 0x6, 0x0, 0x0, PseudoVLOXSEG6EI64_V_M1_M1 }, // 942 + { 0x6, 0x0, 0x1, 0x6, 0x0, 0x1, PseudoVLOXSEG6EI64_V_M2_M1 }, // 943 + { 0x6, 0x0, 0x1, 0x6, 0x0, 0x2, PseudoVLOXSEG6EI64_V_M4_M1 }, // 944 + { 0x6, 0x0, 0x1, 0x6, 0x0, 0x3, PseudoVLOXSEG6EI64_V_M8_M1 }, // 945 + { 0x6, 0x0, 0x1, 0x6, 0x5, 0x0, PseudoVLOXSEG6EI64_V_M1_MF8 }, // 946 + { 0x6, 0x0, 0x1, 0x6, 0x6, 0x0, PseudoVLOXSEG6EI64_V_M1_MF4 }, // 947 + { 0x6, 0x0, 0x1, 0x6, 0x6, 0x1, PseudoVLOXSEG6EI64_V_M2_MF4 }, // 948 + { 0x6, 0x0, 0x1, 0x6, 0x7, 0x0, PseudoVLOXSEG6EI64_V_M1_MF2 }, // 949 + { 0x6, 0x0, 0x1, 0x6, 0x7, 0x1, PseudoVLOXSEG6EI64_V_M2_MF2 }, // 950 + { 0x6, 0x0, 0x1, 0x6, 0x7, 0x2, PseudoVLOXSEG6EI64_V_M4_MF2 }, // 951 + { 0x6, 0x1, 0x0, 0x3, 0x0, 0x0, PseudoVLUXSEG6EI8_V_M1_M1_MASK }, // 952 + { 0x6, 0x1, 0x0, 0x3, 0x0, 0x5, PseudoVLUXSEG6EI8_V_MF8_M1_MASK }, // 953 + { 0x6, 0x1, 0x0, 0x3, 0x0, 0x6, PseudoVLUXSEG6EI8_V_MF4_M1_MASK }, // 954 + { 0x6, 0x1, 0x0, 0x3, 0x0, 0x7, PseudoVLUXSEG6EI8_V_MF2_M1_MASK }, // 955 + { 0x6, 0x1, 0x0, 0x3, 0x5, 0x5, PseudoVLUXSEG6EI8_V_MF8_MF8_MASK }, // 956 + { 0x6, 0x1, 0x0, 0x3, 0x6, 0x5, PseudoVLUXSEG6EI8_V_MF8_MF4_MASK }, // 957 + { 0x6, 0x1, 0x0, 0x3, 0x6, 0x6, PseudoVLUXSEG6EI8_V_MF4_MF4_MASK }, // 958 + { 0x6, 0x1, 0x0, 0x3, 0x7, 0x5, PseudoVLUXSEG6EI8_V_MF8_MF2_MASK }, // 959 + { 0x6, 0x1, 0x0, 0x3, 0x7, 0x6, PseudoVLUXSEG6EI8_V_MF4_MF2_MASK }, // 960 + { 0x6, 0x1, 0x0, 0x3, 0x7, 0x7, PseudoVLUXSEG6EI8_V_MF2_MF2_MASK }, // 961 + { 0x6, 0x1, 0x0, 0x4, 0x0, 0x0, PseudoVLUXSEG6EI16_V_M1_M1_MASK }, // 962 + { 0x6, 0x1, 0x0, 0x4, 0x0, 0x1, PseudoVLUXSEG6EI16_V_M2_M1_MASK }, // 963 + { 0x6, 0x1, 0x0, 0x4, 0x0, 0x6, PseudoVLUXSEG6EI16_V_MF4_M1_MASK }, // 964 + { 0x6, 0x1, 0x0, 0x4, 0x0, 0x7, PseudoVLUXSEG6EI16_V_MF2_M1_MASK }, // 965 + { 0x6, 0x1, 0x0, 0x4, 0x5, 0x6, PseudoVLUXSEG6EI16_V_MF4_MF8_MASK }, // 966 + { 0x6, 0x1, 0x0, 0x4, 0x6, 0x6, PseudoVLUXSEG6EI16_V_MF4_MF4_MASK }, // 967 + { 0x6, 0x1, 0x0, 0x4, 0x6, 0x7, PseudoVLUXSEG6EI16_V_MF2_MF4_MASK }, // 968 + { 0x6, 0x1, 0x0, 0x4, 0x7, 0x0, PseudoVLUXSEG6EI16_V_M1_MF2_MASK }, // 969 + { 0x6, 0x1, 0x0, 0x4, 0x7, 0x6, PseudoVLUXSEG6EI16_V_MF4_MF2_MASK }, // 970 + { 0x6, 0x1, 0x0, 0x4, 0x7, 0x7, PseudoVLUXSEG6EI16_V_MF2_MF2_MASK }, // 971 + { 0x6, 0x1, 0x0, 0x5, 0x0, 0x0, PseudoVLUXSEG6EI32_V_M1_M1_MASK }, // 972 + { 0x6, 0x1, 0x0, 0x5, 0x0, 0x1, PseudoVLUXSEG6EI32_V_M2_M1_MASK }, // 973 + { 0x6, 0x1, 0x0, 0x5, 0x0, 0x2, PseudoVLUXSEG6EI32_V_M4_M1_MASK }, // 974 + { 0x6, 0x1, 0x0, 0x5, 0x0, 0x7, PseudoVLUXSEG6EI32_V_MF2_M1_MASK }, // 975 + { 0x6, 0x1, 0x0, 0x5, 0x5, 0x7, PseudoVLUXSEG6EI32_V_MF2_MF8_MASK }, // 976 + { 0x6, 0x1, 0x0, 0x5, 0x6, 0x0, PseudoVLUXSEG6EI32_V_M1_MF4_MASK }, // 977 + { 0x6, 0x1, 0x0, 0x5, 0x6, 0x7, PseudoVLUXSEG6EI32_V_MF2_MF4_MASK }, // 978 + { 0x6, 0x1, 0x0, 0x5, 0x7, 0x0, PseudoVLUXSEG6EI32_V_M1_MF2_MASK }, // 979 + { 0x6, 0x1, 0x0, 0x5, 0x7, 0x1, PseudoVLUXSEG6EI32_V_M2_MF2_MASK }, // 980 + { 0x6, 0x1, 0x0, 0x5, 0x7, 0x7, PseudoVLUXSEG6EI32_V_MF2_MF2_MASK }, // 981 + { 0x6, 0x1, 0x0, 0x6, 0x0, 0x0, PseudoVLUXSEG6EI64_V_M1_M1_MASK }, // 982 + { 0x6, 0x1, 0x0, 0x6, 0x0, 0x1, PseudoVLUXSEG6EI64_V_M2_M1_MASK }, // 983 + { 0x6, 0x1, 0x0, 0x6, 0x0, 0x2, PseudoVLUXSEG6EI64_V_M4_M1_MASK }, // 984 + { 0x6, 0x1, 0x0, 0x6, 0x0, 0x3, PseudoVLUXSEG6EI64_V_M8_M1_MASK }, // 985 + { 0x6, 0x1, 0x0, 0x6, 0x5, 0x0, PseudoVLUXSEG6EI64_V_M1_MF8_MASK }, // 986 + { 0x6, 0x1, 0x0, 0x6, 0x6, 0x0, PseudoVLUXSEG6EI64_V_M1_MF4_MASK }, // 987 + { 0x6, 0x1, 0x0, 0x6, 0x6, 0x1, PseudoVLUXSEG6EI64_V_M2_MF4_MASK }, // 988 + { 0x6, 0x1, 0x0, 0x6, 0x7, 0x0, PseudoVLUXSEG6EI64_V_M1_MF2_MASK }, // 989 + { 0x6, 0x1, 0x0, 0x6, 0x7, 0x1, PseudoVLUXSEG6EI64_V_M2_MF2_MASK }, // 990 + { 0x6, 0x1, 0x0, 0x6, 0x7, 0x2, PseudoVLUXSEG6EI64_V_M4_MF2_MASK }, // 991 + { 0x6, 0x1, 0x1, 0x3, 0x0, 0x0, PseudoVLOXSEG6EI8_V_M1_M1_MASK }, // 992 + { 0x6, 0x1, 0x1, 0x3, 0x0, 0x5, PseudoVLOXSEG6EI8_V_MF8_M1_MASK }, // 993 + { 0x6, 0x1, 0x1, 0x3, 0x0, 0x6, PseudoVLOXSEG6EI8_V_MF4_M1_MASK }, // 994 + { 0x6, 0x1, 0x1, 0x3, 0x0, 0x7, PseudoVLOXSEG6EI8_V_MF2_M1_MASK }, // 995 + { 0x6, 0x1, 0x1, 0x3, 0x5, 0x5, PseudoVLOXSEG6EI8_V_MF8_MF8_MASK }, // 996 + { 0x6, 0x1, 0x1, 0x3, 0x6, 0x5, PseudoVLOXSEG6EI8_V_MF8_MF4_MASK }, // 997 + { 0x6, 0x1, 0x1, 0x3, 0x6, 0x6, PseudoVLOXSEG6EI8_V_MF4_MF4_MASK }, // 998 + { 0x6, 0x1, 0x1, 0x3, 0x7, 0x5, PseudoVLOXSEG6EI8_V_MF8_MF2_MASK }, // 999 + { 0x6, 0x1, 0x1, 0x3, 0x7, 0x6, PseudoVLOXSEG6EI8_V_MF4_MF2_MASK }, // 1000 + { 0x6, 0x1, 0x1, 0x3, 0x7, 0x7, PseudoVLOXSEG6EI8_V_MF2_MF2_MASK }, // 1001 + { 0x6, 0x1, 0x1, 0x4, 0x0, 0x0, PseudoVLOXSEG6EI16_V_M1_M1_MASK }, // 1002 + { 0x6, 0x1, 0x1, 0x4, 0x0, 0x1, PseudoVLOXSEG6EI16_V_M2_M1_MASK }, // 1003 + { 0x6, 0x1, 0x1, 0x4, 0x0, 0x6, PseudoVLOXSEG6EI16_V_MF4_M1_MASK }, // 1004 + { 0x6, 0x1, 0x1, 0x4, 0x0, 0x7, PseudoVLOXSEG6EI16_V_MF2_M1_MASK }, // 1005 + { 0x6, 0x1, 0x1, 0x4, 0x5, 0x6, PseudoVLOXSEG6EI16_V_MF4_MF8_MASK }, // 1006 + { 0x6, 0x1, 0x1, 0x4, 0x6, 0x6, PseudoVLOXSEG6EI16_V_MF4_MF4_MASK }, // 1007 + { 0x6, 0x1, 0x1, 0x4, 0x6, 0x7, PseudoVLOXSEG6EI16_V_MF2_MF4_MASK }, // 1008 + { 0x6, 0x1, 0x1, 0x4, 0x7, 0x0, PseudoVLOXSEG6EI16_V_M1_MF2_MASK }, // 1009 + { 0x6, 0x1, 0x1, 0x4, 0x7, 0x6, PseudoVLOXSEG6EI16_V_MF4_MF2_MASK }, // 1010 + { 0x6, 0x1, 0x1, 0x4, 0x7, 0x7, PseudoVLOXSEG6EI16_V_MF2_MF2_MASK }, // 1011 + { 0x6, 0x1, 0x1, 0x5, 0x0, 0x0, PseudoVLOXSEG6EI32_V_M1_M1_MASK }, // 1012 + { 0x6, 0x1, 0x1, 0x5, 0x0, 0x1, PseudoVLOXSEG6EI32_V_M2_M1_MASK }, // 1013 + { 0x6, 0x1, 0x1, 0x5, 0x0, 0x2, PseudoVLOXSEG6EI32_V_M4_M1_MASK }, // 1014 + { 0x6, 0x1, 0x1, 0x5, 0x0, 0x7, PseudoVLOXSEG6EI32_V_MF2_M1_MASK }, // 1015 + { 0x6, 0x1, 0x1, 0x5, 0x5, 0x7, PseudoVLOXSEG6EI32_V_MF2_MF8_MASK }, // 1016 + { 0x6, 0x1, 0x1, 0x5, 0x6, 0x0, PseudoVLOXSEG6EI32_V_M1_MF4_MASK }, // 1017 + { 0x6, 0x1, 0x1, 0x5, 0x6, 0x7, PseudoVLOXSEG6EI32_V_MF2_MF4_MASK }, // 1018 + { 0x6, 0x1, 0x1, 0x5, 0x7, 0x0, PseudoVLOXSEG6EI32_V_M1_MF2_MASK }, // 1019 + { 0x6, 0x1, 0x1, 0x5, 0x7, 0x1, PseudoVLOXSEG6EI32_V_M2_MF2_MASK }, // 1020 + { 0x6, 0x1, 0x1, 0x5, 0x7, 0x7, PseudoVLOXSEG6EI32_V_MF2_MF2_MASK }, // 1021 + { 0x6, 0x1, 0x1, 0x6, 0x0, 0x0, PseudoVLOXSEG6EI64_V_M1_M1_MASK }, // 1022 + { 0x6, 0x1, 0x1, 0x6, 0x0, 0x1, PseudoVLOXSEG6EI64_V_M2_M1_MASK }, // 1023 + { 0x6, 0x1, 0x1, 0x6, 0x0, 0x2, PseudoVLOXSEG6EI64_V_M4_M1_MASK }, // 1024 + { 0x6, 0x1, 0x1, 0x6, 0x0, 0x3, PseudoVLOXSEG6EI64_V_M8_M1_MASK }, // 1025 + { 0x6, 0x1, 0x1, 0x6, 0x5, 0x0, PseudoVLOXSEG6EI64_V_M1_MF8_MASK }, // 1026 + { 0x6, 0x1, 0x1, 0x6, 0x6, 0x0, PseudoVLOXSEG6EI64_V_M1_MF4_MASK }, // 1027 + { 0x6, 0x1, 0x1, 0x6, 0x6, 0x1, PseudoVLOXSEG6EI64_V_M2_MF4_MASK }, // 1028 + { 0x6, 0x1, 0x1, 0x6, 0x7, 0x0, PseudoVLOXSEG6EI64_V_M1_MF2_MASK }, // 1029 + { 0x6, 0x1, 0x1, 0x6, 0x7, 0x1, PseudoVLOXSEG6EI64_V_M2_MF2_MASK }, // 1030 + { 0x6, 0x1, 0x1, 0x6, 0x7, 0x2, PseudoVLOXSEG6EI64_V_M4_MF2_MASK }, // 1031 + { 0x7, 0x0, 0x0, 0x3, 0x0, 0x0, PseudoVLUXSEG7EI8_V_M1_M1 }, // 1032 + { 0x7, 0x0, 0x0, 0x3, 0x0, 0x5, PseudoVLUXSEG7EI8_V_MF8_M1 }, // 1033 + { 0x7, 0x0, 0x0, 0x3, 0x0, 0x6, PseudoVLUXSEG7EI8_V_MF4_M1 }, // 1034 + { 0x7, 0x0, 0x0, 0x3, 0x0, 0x7, PseudoVLUXSEG7EI8_V_MF2_M1 }, // 1035 + { 0x7, 0x0, 0x0, 0x3, 0x5, 0x5, PseudoVLUXSEG7EI8_V_MF8_MF8 }, // 1036 + { 0x7, 0x0, 0x0, 0x3, 0x6, 0x5, PseudoVLUXSEG7EI8_V_MF8_MF4 }, // 1037 + { 0x7, 0x0, 0x0, 0x3, 0x6, 0x6, PseudoVLUXSEG7EI8_V_MF4_MF4 }, // 1038 + { 0x7, 0x0, 0x0, 0x3, 0x7, 0x5, PseudoVLUXSEG7EI8_V_MF8_MF2 }, // 1039 + { 0x7, 0x0, 0x0, 0x3, 0x7, 0x6, PseudoVLUXSEG7EI8_V_MF4_MF2 }, // 1040 + { 0x7, 0x0, 0x0, 0x3, 0x7, 0x7, PseudoVLUXSEG7EI8_V_MF2_MF2 }, // 1041 + { 0x7, 0x0, 0x0, 0x4, 0x0, 0x0, PseudoVLUXSEG7EI16_V_M1_M1 }, // 1042 + { 0x7, 0x0, 0x0, 0x4, 0x0, 0x1, PseudoVLUXSEG7EI16_V_M2_M1 }, // 1043 + { 0x7, 0x0, 0x0, 0x4, 0x0, 0x6, PseudoVLUXSEG7EI16_V_MF4_M1 }, // 1044 + { 0x7, 0x0, 0x0, 0x4, 0x0, 0x7, PseudoVLUXSEG7EI16_V_MF2_M1 }, // 1045 + { 0x7, 0x0, 0x0, 0x4, 0x5, 0x6, PseudoVLUXSEG7EI16_V_MF4_MF8 }, // 1046 + { 0x7, 0x0, 0x0, 0x4, 0x6, 0x6, PseudoVLUXSEG7EI16_V_MF4_MF4 }, // 1047 + { 0x7, 0x0, 0x0, 0x4, 0x6, 0x7, PseudoVLUXSEG7EI16_V_MF2_MF4 }, // 1048 + { 0x7, 0x0, 0x0, 0x4, 0x7, 0x0, PseudoVLUXSEG7EI16_V_M1_MF2 }, // 1049 + { 0x7, 0x0, 0x0, 0x4, 0x7, 0x6, PseudoVLUXSEG7EI16_V_MF4_MF2 }, // 1050 + { 0x7, 0x0, 0x0, 0x4, 0x7, 0x7, PseudoVLUXSEG7EI16_V_MF2_MF2 }, // 1051 + { 0x7, 0x0, 0x0, 0x5, 0x0, 0x0, PseudoVLUXSEG7EI32_V_M1_M1 }, // 1052 + { 0x7, 0x0, 0x0, 0x5, 0x0, 0x1, PseudoVLUXSEG7EI32_V_M2_M1 }, // 1053 + { 0x7, 0x0, 0x0, 0x5, 0x0, 0x2, PseudoVLUXSEG7EI32_V_M4_M1 }, // 1054 + { 0x7, 0x0, 0x0, 0x5, 0x0, 0x7, PseudoVLUXSEG7EI32_V_MF2_M1 }, // 1055 + { 0x7, 0x0, 0x0, 0x5, 0x5, 0x7, PseudoVLUXSEG7EI32_V_MF2_MF8 }, // 1056 + { 0x7, 0x0, 0x0, 0x5, 0x6, 0x0, PseudoVLUXSEG7EI32_V_M1_MF4 }, // 1057 + { 0x7, 0x0, 0x0, 0x5, 0x6, 0x7, PseudoVLUXSEG7EI32_V_MF2_MF4 }, // 1058 + { 0x7, 0x0, 0x0, 0x5, 0x7, 0x0, PseudoVLUXSEG7EI32_V_M1_MF2 }, // 1059 + { 0x7, 0x0, 0x0, 0x5, 0x7, 0x1, PseudoVLUXSEG7EI32_V_M2_MF2 }, // 1060 + { 0x7, 0x0, 0x0, 0x5, 0x7, 0x7, PseudoVLUXSEG7EI32_V_MF2_MF2 }, // 1061 + { 0x7, 0x0, 0x0, 0x6, 0x0, 0x0, PseudoVLUXSEG7EI64_V_M1_M1 }, // 1062 + { 0x7, 0x0, 0x0, 0x6, 0x0, 0x1, PseudoVLUXSEG7EI64_V_M2_M1 }, // 1063 + { 0x7, 0x0, 0x0, 0x6, 0x0, 0x2, PseudoVLUXSEG7EI64_V_M4_M1 }, // 1064 + { 0x7, 0x0, 0x0, 0x6, 0x0, 0x3, PseudoVLUXSEG7EI64_V_M8_M1 }, // 1065 + { 0x7, 0x0, 0x0, 0x6, 0x5, 0x0, PseudoVLUXSEG7EI64_V_M1_MF8 }, // 1066 + { 0x7, 0x0, 0x0, 0x6, 0x6, 0x0, PseudoVLUXSEG7EI64_V_M1_MF4 }, // 1067 + { 0x7, 0x0, 0x0, 0x6, 0x6, 0x1, PseudoVLUXSEG7EI64_V_M2_MF4 }, // 1068 + { 0x7, 0x0, 0x0, 0x6, 0x7, 0x0, PseudoVLUXSEG7EI64_V_M1_MF2 }, // 1069 + { 0x7, 0x0, 0x0, 0x6, 0x7, 0x1, PseudoVLUXSEG7EI64_V_M2_MF2 }, // 1070 + { 0x7, 0x0, 0x0, 0x6, 0x7, 0x2, PseudoVLUXSEG7EI64_V_M4_MF2 }, // 1071 + { 0x7, 0x0, 0x1, 0x3, 0x0, 0x0, PseudoVLOXSEG7EI8_V_M1_M1 }, // 1072 + { 0x7, 0x0, 0x1, 0x3, 0x0, 0x5, PseudoVLOXSEG7EI8_V_MF8_M1 }, // 1073 + { 0x7, 0x0, 0x1, 0x3, 0x0, 0x6, PseudoVLOXSEG7EI8_V_MF4_M1 }, // 1074 + { 0x7, 0x0, 0x1, 0x3, 0x0, 0x7, PseudoVLOXSEG7EI8_V_MF2_M1 }, // 1075 + { 0x7, 0x0, 0x1, 0x3, 0x5, 0x5, PseudoVLOXSEG7EI8_V_MF8_MF8 }, // 1076 + { 0x7, 0x0, 0x1, 0x3, 0x6, 0x5, PseudoVLOXSEG7EI8_V_MF8_MF4 }, // 1077 + { 0x7, 0x0, 0x1, 0x3, 0x6, 0x6, PseudoVLOXSEG7EI8_V_MF4_MF4 }, // 1078 + { 0x7, 0x0, 0x1, 0x3, 0x7, 0x5, PseudoVLOXSEG7EI8_V_MF8_MF2 }, // 1079 + { 0x7, 0x0, 0x1, 0x3, 0x7, 0x6, PseudoVLOXSEG7EI8_V_MF4_MF2 }, // 1080 + { 0x7, 0x0, 0x1, 0x3, 0x7, 0x7, PseudoVLOXSEG7EI8_V_MF2_MF2 }, // 1081 + { 0x7, 0x0, 0x1, 0x4, 0x0, 0x0, PseudoVLOXSEG7EI16_V_M1_M1 }, // 1082 + { 0x7, 0x0, 0x1, 0x4, 0x0, 0x1, PseudoVLOXSEG7EI16_V_M2_M1 }, // 1083 + { 0x7, 0x0, 0x1, 0x4, 0x0, 0x6, PseudoVLOXSEG7EI16_V_MF4_M1 }, // 1084 + { 0x7, 0x0, 0x1, 0x4, 0x0, 0x7, PseudoVLOXSEG7EI16_V_MF2_M1 }, // 1085 + { 0x7, 0x0, 0x1, 0x4, 0x5, 0x6, PseudoVLOXSEG7EI16_V_MF4_MF8 }, // 1086 + { 0x7, 0x0, 0x1, 0x4, 0x6, 0x6, PseudoVLOXSEG7EI16_V_MF4_MF4 }, // 1087 + { 0x7, 0x0, 0x1, 0x4, 0x6, 0x7, PseudoVLOXSEG7EI16_V_MF2_MF4 }, // 1088 + { 0x7, 0x0, 0x1, 0x4, 0x7, 0x0, PseudoVLOXSEG7EI16_V_M1_MF2 }, // 1089 + { 0x7, 0x0, 0x1, 0x4, 0x7, 0x6, PseudoVLOXSEG7EI16_V_MF4_MF2 }, // 1090 + { 0x7, 0x0, 0x1, 0x4, 0x7, 0x7, PseudoVLOXSEG7EI16_V_MF2_MF2 }, // 1091 + { 0x7, 0x0, 0x1, 0x5, 0x0, 0x0, PseudoVLOXSEG7EI32_V_M1_M1 }, // 1092 + { 0x7, 0x0, 0x1, 0x5, 0x0, 0x1, PseudoVLOXSEG7EI32_V_M2_M1 }, // 1093 + { 0x7, 0x0, 0x1, 0x5, 0x0, 0x2, PseudoVLOXSEG7EI32_V_M4_M1 }, // 1094 + { 0x7, 0x0, 0x1, 0x5, 0x0, 0x7, PseudoVLOXSEG7EI32_V_MF2_M1 }, // 1095 + { 0x7, 0x0, 0x1, 0x5, 0x5, 0x7, PseudoVLOXSEG7EI32_V_MF2_MF8 }, // 1096 + { 0x7, 0x0, 0x1, 0x5, 0x6, 0x0, PseudoVLOXSEG7EI32_V_M1_MF4 }, // 1097 + { 0x7, 0x0, 0x1, 0x5, 0x6, 0x7, PseudoVLOXSEG7EI32_V_MF2_MF4 }, // 1098 + { 0x7, 0x0, 0x1, 0x5, 0x7, 0x0, PseudoVLOXSEG7EI32_V_M1_MF2 }, // 1099 + { 0x7, 0x0, 0x1, 0x5, 0x7, 0x1, PseudoVLOXSEG7EI32_V_M2_MF2 }, // 1100 + { 0x7, 0x0, 0x1, 0x5, 0x7, 0x7, PseudoVLOXSEG7EI32_V_MF2_MF2 }, // 1101 + { 0x7, 0x0, 0x1, 0x6, 0x0, 0x0, PseudoVLOXSEG7EI64_V_M1_M1 }, // 1102 + { 0x7, 0x0, 0x1, 0x6, 0x0, 0x1, PseudoVLOXSEG7EI64_V_M2_M1 }, // 1103 + { 0x7, 0x0, 0x1, 0x6, 0x0, 0x2, PseudoVLOXSEG7EI64_V_M4_M1 }, // 1104 + { 0x7, 0x0, 0x1, 0x6, 0x0, 0x3, PseudoVLOXSEG7EI64_V_M8_M1 }, // 1105 + { 0x7, 0x0, 0x1, 0x6, 0x5, 0x0, PseudoVLOXSEG7EI64_V_M1_MF8 }, // 1106 + { 0x7, 0x0, 0x1, 0x6, 0x6, 0x0, PseudoVLOXSEG7EI64_V_M1_MF4 }, // 1107 + { 0x7, 0x0, 0x1, 0x6, 0x6, 0x1, PseudoVLOXSEG7EI64_V_M2_MF4 }, // 1108 + { 0x7, 0x0, 0x1, 0x6, 0x7, 0x0, PseudoVLOXSEG7EI64_V_M1_MF2 }, // 1109 + { 0x7, 0x0, 0x1, 0x6, 0x7, 0x1, PseudoVLOXSEG7EI64_V_M2_MF2 }, // 1110 + { 0x7, 0x0, 0x1, 0x6, 0x7, 0x2, PseudoVLOXSEG7EI64_V_M4_MF2 }, // 1111 + { 0x7, 0x1, 0x0, 0x3, 0x0, 0x0, PseudoVLUXSEG7EI8_V_M1_M1_MASK }, // 1112 + { 0x7, 0x1, 0x0, 0x3, 0x0, 0x5, PseudoVLUXSEG7EI8_V_MF8_M1_MASK }, // 1113 + { 0x7, 0x1, 0x0, 0x3, 0x0, 0x6, PseudoVLUXSEG7EI8_V_MF4_M1_MASK }, // 1114 + { 0x7, 0x1, 0x0, 0x3, 0x0, 0x7, PseudoVLUXSEG7EI8_V_MF2_M1_MASK }, // 1115 + { 0x7, 0x1, 0x0, 0x3, 0x5, 0x5, PseudoVLUXSEG7EI8_V_MF8_MF8_MASK }, // 1116 + { 0x7, 0x1, 0x0, 0x3, 0x6, 0x5, PseudoVLUXSEG7EI8_V_MF8_MF4_MASK }, // 1117 + { 0x7, 0x1, 0x0, 0x3, 0x6, 0x6, PseudoVLUXSEG7EI8_V_MF4_MF4_MASK }, // 1118 + { 0x7, 0x1, 0x0, 0x3, 0x7, 0x5, PseudoVLUXSEG7EI8_V_MF8_MF2_MASK }, // 1119 + { 0x7, 0x1, 0x0, 0x3, 0x7, 0x6, PseudoVLUXSEG7EI8_V_MF4_MF2_MASK }, // 1120 + { 0x7, 0x1, 0x0, 0x3, 0x7, 0x7, PseudoVLUXSEG7EI8_V_MF2_MF2_MASK }, // 1121 + { 0x7, 0x1, 0x0, 0x4, 0x0, 0x0, PseudoVLUXSEG7EI16_V_M1_M1_MASK }, // 1122 + { 0x7, 0x1, 0x0, 0x4, 0x0, 0x1, PseudoVLUXSEG7EI16_V_M2_M1_MASK }, // 1123 + { 0x7, 0x1, 0x0, 0x4, 0x0, 0x6, PseudoVLUXSEG7EI16_V_MF4_M1_MASK }, // 1124 + { 0x7, 0x1, 0x0, 0x4, 0x0, 0x7, PseudoVLUXSEG7EI16_V_MF2_M1_MASK }, // 1125 + { 0x7, 0x1, 0x0, 0x4, 0x5, 0x6, PseudoVLUXSEG7EI16_V_MF4_MF8_MASK }, // 1126 + { 0x7, 0x1, 0x0, 0x4, 0x6, 0x6, PseudoVLUXSEG7EI16_V_MF4_MF4_MASK }, // 1127 + { 0x7, 0x1, 0x0, 0x4, 0x6, 0x7, PseudoVLUXSEG7EI16_V_MF2_MF4_MASK }, // 1128 + { 0x7, 0x1, 0x0, 0x4, 0x7, 0x0, PseudoVLUXSEG7EI16_V_M1_MF2_MASK }, // 1129 + { 0x7, 0x1, 0x0, 0x4, 0x7, 0x6, PseudoVLUXSEG7EI16_V_MF4_MF2_MASK }, // 1130 + { 0x7, 0x1, 0x0, 0x4, 0x7, 0x7, PseudoVLUXSEG7EI16_V_MF2_MF2_MASK }, // 1131 + { 0x7, 0x1, 0x0, 0x5, 0x0, 0x0, PseudoVLUXSEG7EI32_V_M1_M1_MASK }, // 1132 + { 0x7, 0x1, 0x0, 0x5, 0x0, 0x1, PseudoVLUXSEG7EI32_V_M2_M1_MASK }, // 1133 + { 0x7, 0x1, 0x0, 0x5, 0x0, 0x2, PseudoVLUXSEG7EI32_V_M4_M1_MASK }, // 1134 + { 0x7, 0x1, 0x0, 0x5, 0x0, 0x7, PseudoVLUXSEG7EI32_V_MF2_M1_MASK }, // 1135 + { 0x7, 0x1, 0x0, 0x5, 0x5, 0x7, PseudoVLUXSEG7EI32_V_MF2_MF8_MASK }, // 1136 + { 0x7, 0x1, 0x0, 0x5, 0x6, 0x0, PseudoVLUXSEG7EI32_V_M1_MF4_MASK }, // 1137 + { 0x7, 0x1, 0x0, 0x5, 0x6, 0x7, PseudoVLUXSEG7EI32_V_MF2_MF4_MASK }, // 1138 + { 0x7, 0x1, 0x0, 0x5, 0x7, 0x0, PseudoVLUXSEG7EI32_V_M1_MF2_MASK }, // 1139 + { 0x7, 0x1, 0x0, 0x5, 0x7, 0x1, PseudoVLUXSEG7EI32_V_M2_MF2_MASK }, // 1140 + { 0x7, 0x1, 0x0, 0x5, 0x7, 0x7, PseudoVLUXSEG7EI32_V_MF2_MF2_MASK }, // 1141 + { 0x7, 0x1, 0x0, 0x6, 0x0, 0x0, PseudoVLUXSEG7EI64_V_M1_M1_MASK }, // 1142 + { 0x7, 0x1, 0x0, 0x6, 0x0, 0x1, PseudoVLUXSEG7EI64_V_M2_M1_MASK }, // 1143 + { 0x7, 0x1, 0x0, 0x6, 0x0, 0x2, PseudoVLUXSEG7EI64_V_M4_M1_MASK }, // 1144 + { 0x7, 0x1, 0x0, 0x6, 0x0, 0x3, PseudoVLUXSEG7EI64_V_M8_M1_MASK }, // 1145 + { 0x7, 0x1, 0x0, 0x6, 0x5, 0x0, PseudoVLUXSEG7EI64_V_M1_MF8_MASK }, // 1146 + { 0x7, 0x1, 0x0, 0x6, 0x6, 0x0, PseudoVLUXSEG7EI64_V_M1_MF4_MASK }, // 1147 + { 0x7, 0x1, 0x0, 0x6, 0x6, 0x1, PseudoVLUXSEG7EI64_V_M2_MF4_MASK }, // 1148 + { 0x7, 0x1, 0x0, 0x6, 0x7, 0x0, PseudoVLUXSEG7EI64_V_M1_MF2_MASK }, // 1149 + { 0x7, 0x1, 0x0, 0x6, 0x7, 0x1, PseudoVLUXSEG7EI64_V_M2_MF2_MASK }, // 1150 + { 0x7, 0x1, 0x0, 0x6, 0x7, 0x2, PseudoVLUXSEG7EI64_V_M4_MF2_MASK }, // 1151 + { 0x7, 0x1, 0x1, 0x3, 0x0, 0x0, PseudoVLOXSEG7EI8_V_M1_M1_MASK }, // 1152 + { 0x7, 0x1, 0x1, 0x3, 0x0, 0x5, PseudoVLOXSEG7EI8_V_MF8_M1_MASK }, // 1153 + { 0x7, 0x1, 0x1, 0x3, 0x0, 0x6, PseudoVLOXSEG7EI8_V_MF4_M1_MASK }, // 1154 + { 0x7, 0x1, 0x1, 0x3, 0x0, 0x7, PseudoVLOXSEG7EI8_V_MF2_M1_MASK }, // 1155 + { 0x7, 0x1, 0x1, 0x3, 0x5, 0x5, PseudoVLOXSEG7EI8_V_MF8_MF8_MASK }, // 1156 + { 0x7, 0x1, 0x1, 0x3, 0x6, 0x5, PseudoVLOXSEG7EI8_V_MF8_MF4_MASK }, // 1157 + { 0x7, 0x1, 0x1, 0x3, 0x6, 0x6, PseudoVLOXSEG7EI8_V_MF4_MF4_MASK }, // 1158 + { 0x7, 0x1, 0x1, 0x3, 0x7, 0x5, PseudoVLOXSEG7EI8_V_MF8_MF2_MASK }, // 1159 + { 0x7, 0x1, 0x1, 0x3, 0x7, 0x6, PseudoVLOXSEG7EI8_V_MF4_MF2_MASK }, // 1160 + { 0x7, 0x1, 0x1, 0x3, 0x7, 0x7, PseudoVLOXSEG7EI8_V_MF2_MF2_MASK }, // 1161 + { 0x7, 0x1, 0x1, 0x4, 0x0, 0x0, PseudoVLOXSEG7EI16_V_M1_M1_MASK }, // 1162 + { 0x7, 0x1, 0x1, 0x4, 0x0, 0x1, PseudoVLOXSEG7EI16_V_M2_M1_MASK }, // 1163 + { 0x7, 0x1, 0x1, 0x4, 0x0, 0x6, PseudoVLOXSEG7EI16_V_MF4_M1_MASK }, // 1164 + { 0x7, 0x1, 0x1, 0x4, 0x0, 0x7, PseudoVLOXSEG7EI16_V_MF2_M1_MASK }, // 1165 + { 0x7, 0x1, 0x1, 0x4, 0x5, 0x6, PseudoVLOXSEG7EI16_V_MF4_MF8_MASK }, // 1166 + { 0x7, 0x1, 0x1, 0x4, 0x6, 0x6, PseudoVLOXSEG7EI16_V_MF4_MF4_MASK }, // 1167 + { 0x7, 0x1, 0x1, 0x4, 0x6, 0x7, PseudoVLOXSEG7EI16_V_MF2_MF4_MASK }, // 1168 + { 0x7, 0x1, 0x1, 0x4, 0x7, 0x0, PseudoVLOXSEG7EI16_V_M1_MF2_MASK }, // 1169 + { 0x7, 0x1, 0x1, 0x4, 0x7, 0x6, PseudoVLOXSEG7EI16_V_MF4_MF2_MASK }, // 1170 + { 0x7, 0x1, 0x1, 0x4, 0x7, 0x7, PseudoVLOXSEG7EI16_V_MF2_MF2_MASK }, // 1171 + { 0x7, 0x1, 0x1, 0x5, 0x0, 0x0, PseudoVLOXSEG7EI32_V_M1_M1_MASK }, // 1172 + { 0x7, 0x1, 0x1, 0x5, 0x0, 0x1, PseudoVLOXSEG7EI32_V_M2_M1_MASK }, // 1173 + { 0x7, 0x1, 0x1, 0x5, 0x0, 0x2, PseudoVLOXSEG7EI32_V_M4_M1_MASK }, // 1174 + { 0x7, 0x1, 0x1, 0x5, 0x0, 0x7, PseudoVLOXSEG7EI32_V_MF2_M1_MASK }, // 1175 + { 0x7, 0x1, 0x1, 0x5, 0x5, 0x7, PseudoVLOXSEG7EI32_V_MF2_MF8_MASK }, // 1176 + { 0x7, 0x1, 0x1, 0x5, 0x6, 0x0, PseudoVLOXSEG7EI32_V_M1_MF4_MASK }, // 1177 + { 0x7, 0x1, 0x1, 0x5, 0x6, 0x7, PseudoVLOXSEG7EI32_V_MF2_MF4_MASK }, // 1178 + { 0x7, 0x1, 0x1, 0x5, 0x7, 0x0, PseudoVLOXSEG7EI32_V_M1_MF2_MASK }, // 1179 + { 0x7, 0x1, 0x1, 0x5, 0x7, 0x1, PseudoVLOXSEG7EI32_V_M2_MF2_MASK }, // 1180 + { 0x7, 0x1, 0x1, 0x5, 0x7, 0x7, PseudoVLOXSEG7EI32_V_MF2_MF2_MASK }, // 1181 + { 0x7, 0x1, 0x1, 0x6, 0x0, 0x0, PseudoVLOXSEG7EI64_V_M1_M1_MASK }, // 1182 + { 0x7, 0x1, 0x1, 0x6, 0x0, 0x1, PseudoVLOXSEG7EI64_V_M2_M1_MASK }, // 1183 + { 0x7, 0x1, 0x1, 0x6, 0x0, 0x2, PseudoVLOXSEG7EI64_V_M4_M1_MASK }, // 1184 + { 0x7, 0x1, 0x1, 0x6, 0x0, 0x3, PseudoVLOXSEG7EI64_V_M8_M1_MASK }, // 1185 + { 0x7, 0x1, 0x1, 0x6, 0x5, 0x0, PseudoVLOXSEG7EI64_V_M1_MF8_MASK }, // 1186 + { 0x7, 0x1, 0x1, 0x6, 0x6, 0x0, PseudoVLOXSEG7EI64_V_M1_MF4_MASK }, // 1187 + { 0x7, 0x1, 0x1, 0x6, 0x6, 0x1, PseudoVLOXSEG7EI64_V_M2_MF4_MASK }, // 1188 + { 0x7, 0x1, 0x1, 0x6, 0x7, 0x0, PseudoVLOXSEG7EI64_V_M1_MF2_MASK }, // 1189 + { 0x7, 0x1, 0x1, 0x6, 0x7, 0x1, PseudoVLOXSEG7EI64_V_M2_MF2_MASK }, // 1190 + { 0x7, 0x1, 0x1, 0x6, 0x7, 0x2, PseudoVLOXSEG7EI64_V_M4_MF2_MASK }, // 1191 + { 0x8, 0x0, 0x0, 0x3, 0x0, 0x0, PseudoVLUXSEG8EI8_V_M1_M1 }, // 1192 + { 0x8, 0x0, 0x0, 0x3, 0x0, 0x5, PseudoVLUXSEG8EI8_V_MF8_M1 }, // 1193 + { 0x8, 0x0, 0x0, 0x3, 0x0, 0x6, PseudoVLUXSEG8EI8_V_MF4_M1 }, // 1194 + { 0x8, 0x0, 0x0, 0x3, 0x0, 0x7, PseudoVLUXSEG8EI8_V_MF2_M1 }, // 1195 + { 0x8, 0x0, 0x0, 0x3, 0x5, 0x5, PseudoVLUXSEG8EI8_V_MF8_MF8 }, // 1196 + { 0x8, 0x0, 0x0, 0x3, 0x6, 0x5, PseudoVLUXSEG8EI8_V_MF8_MF4 }, // 1197 + { 0x8, 0x0, 0x0, 0x3, 0x6, 0x6, PseudoVLUXSEG8EI8_V_MF4_MF4 }, // 1198 + { 0x8, 0x0, 0x0, 0x3, 0x7, 0x5, PseudoVLUXSEG8EI8_V_MF8_MF2 }, // 1199 + { 0x8, 0x0, 0x0, 0x3, 0x7, 0x6, PseudoVLUXSEG8EI8_V_MF4_MF2 }, // 1200 + { 0x8, 0x0, 0x0, 0x3, 0x7, 0x7, PseudoVLUXSEG8EI8_V_MF2_MF2 }, // 1201 + { 0x8, 0x0, 0x0, 0x4, 0x0, 0x0, PseudoVLUXSEG8EI16_V_M1_M1 }, // 1202 + { 0x8, 0x0, 0x0, 0x4, 0x0, 0x1, PseudoVLUXSEG8EI16_V_M2_M1 }, // 1203 + { 0x8, 0x0, 0x0, 0x4, 0x0, 0x6, PseudoVLUXSEG8EI16_V_MF4_M1 }, // 1204 + { 0x8, 0x0, 0x0, 0x4, 0x0, 0x7, PseudoVLUXSEG8EI16_V_MF2_M1 }, // 1205 + { 0x8, 0x0, 0x0, 0x4, 0x5, 0x6, PseudoVLUXSEG8EI16_V_MF4_MF8 }, // 1206 + { 0x8, 0x0, 0x0, 0x4, 0x6, 0x6, PseudoVLUXSEG8EI16_V_MF4_MF4 }, // 1207 + { 0x8, 0x0, 0x0, 0x4, 0x6, 0x7, PseudoVLUXSEG8EI16_V_MF2_MF4 }, // 1208 + { 0x8, 0x0, 0x0, 0x4, 0x7, 0x0, PseudoVLUXSEG8EI16_V_M1_MF2 }, // 1209 + { 0x8, 0x0, 0x0, 0x4, 0x7, 0x6, PseudoVLUXSEG8EI16_V_MF4_MF2 }, // 1210 + { 0x8, 0x0, 0x0, 0x4, 0x7, 0x7, PseudoVLUXSEG8EI16_V_MF2_MF2 }, // 1211 + { 0x8, 0x0, 0x0, 0x5, 0x0, 0x0, PseudoVLUXSEG8EI32_V_M1_M1 }, // 1212 + { 0x8, 0x0, 0x0, 0x5, 0x0, 0x1, PseudoVLUXSEG8EI32_V_M2_M1 }, // 1213 + { 0x8, 0x0, 0x0, 0x5, 0x0, 0x2, PseudoVLUXSEG8EI32_V_M4_M1 }, // 1214 + { 0x8, 0x0, 0x0, 0x5, 0x0, 0x7, PseudoVLUXSEG8EI32_V_MF2_M1 }, // 1215 + { 0x8, 0x0, 0x0, 0x5, 0x5, 0x7, PseudoVLUXSEG8EI32_V_MF2_MF8 }, // 1216 + { 0x8, 0x0, 0x0, 0x5, 0x6, 0x0, PseudoVLUXSEG8EI32_V_M1_MF4 }, // 1217 + { 0x8, 0x0, 0x0, 0x5, 0x6, 0x7, PseudoVLUXSEG8EI32_V_MF2_MF4 }, // 1218 + { 0x8, 0x0, 0x0, 0x5, 0x7, 0x0, PseudoVLUXSEG8EI32_V_M1_MF2 }, // 1219 + { 0x8, 0x0, 0x0, 0x5, 0x7, 0x1, PseudoVLUXSEG8EI32_V_M2_MF2 }, // 1220 + { 0x8, 0x0, 0x0, 0x5, 0x7, 0x7, PseudoVLUXSEG8EI32_V_MF2_MF2 }, // 1221 + { 0x8, 0x0, 0x0, 0x6, 0x0, 0x0, PseudoVLUXSEG8EI64_V_M1_M1 }, // 1222 + { 0x8, 0x0, 0x0, 0x6, 0x0, 0x1, PseudoVLUXSEG8EI64_V_M2_M1 }, // 1223 + { 0x8, 0x0, 0x0, 0x6, 0x0, 0x2, PseudoVLUXSEG8EI64_V_M4_M1 }, // 1224 + { 0x8, 0x0, 0x0, 0x6, 0x0, 0x3, PseudoVLUXSEG8EI64_V_M8_M1 }, // 1225 + { 0x8, 0x0, 0x0, 0x6, 0x5, 0x0, PseudoVLUXSEG8EI64_V_M1_MF8 }, // 1226 + { 0x8, 0x0, 0x0, 0x6, 0x6, 0x0, PseudoVLUXSEG8EI64_V_M1_MF4 }, // 1227 + { 0x8, 0x0, 0x0, 0x6, 0x6, 0x1, PseudoVLUXSEG8EI64_V_M2_MF4 }, // 1228 + { 0x8, 0x0, 0x0, 0x6, 0x7, 0x0, PseudoVLUXSEG8EI64_V_M1_MF2 }, // 1229 + { 0x8, 0x0, 0x0, 0x6, 0x7, 0x1, PseudoVLUXSEG8EI64_V_M2_MF2 }, // 1230 + { 0x8, 0x0, 0x0, 0x6, 0x7, 0x2, PseudoVLUXSEG8EI64_V_M4_MF2 }, // 1231 + { 0x8, 0x0, 0x1, 0x3, 0x0, 0x0, PseudoVLOXSEG8EI8_V_M1_M1 }, // 1232 + { 0x8, 0x0, 0x1, 0x3, 0x0, 0x5, PseudoVLOXSEG8EI8_V_MF8_M1 }, // 1233 + { 0x8, 0x0, 0x1, 0x3, 0x0, 0x6, PseudoVLOXSEG8EI8_V_MF4_M1 }, // 1234 + { 0x8, 0x0, 0x1, 0x3, 0x0, 0x7, PseudoVLOXSEG8EI8_V_MF2_M1 }, // 1235 + { 0x8, 0x0, 0x1, 0x3, 0x5, 0x5, PseudoVLOXSEG8EI8_V_MF8_MF8 }, // 1236 + { 0x8, 0x0, 0x1, 0x3, 0x6, 0x5, PseudoVLOXSEG8EI8_V_MF8_MF4 }, // 1237 + { 0x8, 0x0, 0x1, 0x3, 0x6, 0x6, PseudoVLOXSEG8EI8_V_MF4_MF4 }, // 1238 + { 0x8, 0x0, 0x1, 0x3, 0x7, 0x5, PseudoVLOXSEG8EI8_V_MF8_MF2 }, // 1239 + { 0x8, 0x0, 0x1, 0x3, 0x7, 0x6, PseudoVLOXSEG8EI8_V_MF4_MF2 }, // 1240 + { 0x8, 0x0, 0x1, 0x3, 0x7, 0x7, PseudoVLOXSEG8EI8_V_MF2_MF2 }, // 1241 + { 0x8, 0x0, 0x1, 0x4, 0x0, 0x0, PseudoVLOXSEG8EI16_V_M1_M1 }, // 1242 + { 0x8, 0x0, 0x1, 0x4, 0x0, 0x1, PseudoVLOXSEG8EI16_V_M2_M1 }, // 1243 + { 0x8, 0x0, 0x1, 0x4, 0x0, 0x6, PseudoVLOXSEG8EI16_V_MF4_M1 }, // 1244 + { 0x8, 0x0, 0x1, 0x4, 0x0, 0x7, PseudoVLOXSEG8EI16_V_MF2_M1 }, // 1245 + { 0x8, 0x0, 0x1, 0x4, 0x5, 0x6, PseudoVLOXSEG8EI16_V_MF4_MF8 }, // 1246 + { 0x8, 0x0, 0x1, 0x4, 0x6, 0x6, PseudoVLOXSEG8EI16_V_MF4_MF4 }, // 1247 + { 0x8, 0x0, 0x1, 0x4, 0x6, 0x7, PseudoVLOXSEG8EI16_V_MF2_MF4 }, // 1248 + { 0x8, 0x0, 0x1, 0x4, 0x7, 0x0, PseudoVLOXSEG8EI16_V_M1_MF2 }, // 1249 + { 0x8, 0x0, 0x1, 0x4, 0x7, 0x6, PseudoVLOXSEG8EI16_V_MF4_MF2 }, // 1250 + { 0x8, 0x0, 0x1, 0x4, 0x7, 0x7, PseudoVLOXSEG8EI16_V_MF2_MF2 }, // 1251 + { 0x8, 0x0, 0x1, 0x5, 0x0, 0x0, PseudoVLOXSEG8EI32_V_M1_M1 }, // 1252 + { 0x8, 0x0, 0x1, 0x5, 0x0, 0x1, PseudoVLOXSEG8EI32_V_M2_M1 }, // 1253 + { 0x8, 0x0, 0x1, 0x5, 0x0, 0x2, PseudoVLOXSEG8EI32_V_M4_M1 }, // 1254 + { 0x8, 0x0, 0x1, 0x5, 0x0, 0x7, PseudoVLOXSEG8EI32_V_MF2_M1 }, // 1255 + { 0x8, 0x0, 0x1, 0x5, 0x5, 0x7, PseudoVLOXSEG8EI32_V_MF2_MF8 }, // 1256 + { 0x8, 0x0, 0x1, 0x5, 0x6, 0x0, PseudoVLOXSEG8EI32_V_M1_MF4 }, // 1257 + { 0x8, 0x0, 0x1, 0x5, 0x6, 0x7, PseudoVLOXSEG8EI32_V_MF2_MF4 }, // 1258 + { 0x8, 0x0, 0x1, 0x5, 0x7, 0x0, PseudoVLOXSEG8EI32_V_M1_MF2 }, // 1259 + { 0x8, 0x0, 0x1, 0x5, 0x7, 0x1, PseudoVLOXSEG8EI32_V_M2_MF2 }, // 1260 + { 0x8, 0x0, 0x1, 0x5, 0x7, 0x7, PseudoVLOXSEG8EI32_V_MF2_MF2 }, // 1261 + { 0x8, 0x0, 0x1, 0x6, 0x0, 0x0, PseudoVLOXSEG8EI64_V_M1_M1 }, // 1262 + { 0x8, 0x0, 0x1, 0x6, 0x0, 0x1, PseudoVLOXSEG8EI64_V_M2_M1 }, // 1263 + { 0x8, 0x0, 0x1, 0x6, 0x0, 0x2, PseudoVLOXSEG8EI64_V_M4_M1 }, // 1264 + { 0x8, 0x0, 0x1, 0x6, 0x0, 0x3, PseudoVLOXSEG8EI64_V_M8_M1 }, // 1265 + { 0x8, 0x0, 0x1, 0x6, 0x5, 0x0, PseudoVLOXSEG8EI64_V_M1_MF8 }, // 1266 + { 0x8, 0x0, 0x1, 0x6, 0x6, 0x0, PseudoVLOXSEG8EI64_V_M1_MF4 }, // 1267 + { 0x8, 0x0, 0x1, 0x6, 0x6, 0x1, PseudoVLOXSEG8EI64_V_M2_MF4 }, // 1268 + { 0x8, 0x0, 0x1, 0x6, 0x7, 0x0, PseudoVLOXSEG8EI64_V_M1_MF2 }, // 1269 + { 0x8, 0x0, 0x1, 0x6, 0x7, 0x1, PseudoVLOXSEG8EI64_V_M2_MF2 }, // 1270 + { 0x8, 0x0, 0x1, 0x6, 0x7, 0x2, PseudoVLOXSEG8EI64_V_M4_MF2 }, // 1271 + { 0x8, 0x1, 0x0, 0x3, 0x0, 0x0, PseudoVLUXSEG8EI8_V_M1_M1_MASK }, // 1272 + { 0x8, 0x1, 0x0, 0x3, 0x0, 0x5, PseudoVLUXSEG8EI8_V_MF8_M1_MASK }, // 1273 + { 0x8, 0x1, 0x0, 0x3, 0x0, 0x6, PseudoVLUXSEG8EI8_V_MF4_M1_MASK }, // 1274 + { 0x8, 0x1, 0x0, 0x3, 0x0, 0x7, PseudoVLUXSEG8EI8_V_MF2_M1_MASK }, // 1275 + { 0x8, 0x1, 0x0, 0x3, 0x5, 0x5, PseudoVLUXSEG8EI8_V_MF8_MF8_MASK }, // 1276 + { 0x8, 0x1, 0x0, 0x3, 0x6, 0x5, PseudoVLUXSEG8EI8_V_MF8_MF4_MASK }, // 1277 + { 0x8, 0x1, 0x0, 0x3, 0x6, 0x6, PseudoVLUXSEG8EI8_V_MF4_MF4_MASK }, // 1278 + { 0x8, 0x1, 0x0, 0x3, 0x7, 0x5, PseudoVLUXSEG8EI8_V_MF8_MF2_MASK }, // 1279 + { 0x8, 0x1, 0x0, 0x3, 0x7, 0x6, PseudoVLUXSEG8EI8_V_MF4_MF2_MASK }, // 1280 + { 0x8, 0x1, 0x0, 0x3, 0x7, 0x7, PseudoVLUXSEG8EI8_V_MF2_MF2_MASK }, // 1281 + { 0x8, 0x1, 0x0, 0x4, 0x0, 0x0, PseudoVLUXSEG8EI16_V_M1_M1_MASK }, // 1282 + { 0x8, 0x1, 0x0, 0x4, 0x0, 0x1, PseudoVLUXSEG8EI16_V_M2_M1_MASK }, // 1283 + { 0x8, 0x1, 0x0, 0x4, 0x0, 0x6, PseudoVLUXSEG8EI16_V_MF4_M1_MASK }, // 1284 + { 0x8, 0x1, 0x0, 0x4, 0x0, 0x7, PseudoVLUXSEG8EI16_V_MF2_M1_MASK }, // 1285 + { 0x8, 0x1, 0x0, 0x4, 0x5, 0x6, PseudoVLUXSEG8EI16_V_MF4_MF8_MASK }, // 1286 + { 0x8, 0x1, 0x0, 0x4, 0x6, 0x6, PseudoVLUXSEG8EI16_V_MF4_MF4_MASK }, // 1287 + { 0x8, 0x1, 0x0, 0x4, 0x6, 0x7, PseudoVLUXSEG8EI16_V_MF2_MF4_MASK }, // 1288 + { 0x8, 0x1, 0x0, 0x4, 0x7, 0x0, PseudoVLUXSEG8EI16_V_M1_MF2_MASK }, // 1289 + { 0x8, 0x1, 0x0, 0x4, 0x7, 0x6, PseudoVLUXSEG8EI16_V_MF4_MF2_MASK }, // 1290 + { 0x8, 0x1, 0x0, 0x4, 0x7, 0x7, PseudoVLUXSEG8EI16_V_MF2_MF2_MASK }, // 1291 + { 0x8, 0x1, 0x0, 0x5, 0x0, 0x0, PseudoVLUXSEG8EI32_V_M1_M1_MASK }, // 1292 + { 0x8, 0x1, 0x0, 0x5, 0x0, 0x1, PseudoVLUXSEG8EI32_V_M2_M1_MASK }, // 1293 + { 0x8, 0x1, 0x0, 0x5, 0x0, 0x2, PseudoVLUXSEG8EI32_V_M4_M1_MASK }, // 1294 + { 0x8, 0x1, 0x0, 0x5, 0x0, 0x7, PseudoVLUXSEG8EI32_V_MF2_M1_MASK }, // 1295 + { 0x8, 0x1, 0x0, 0x5, 0x5, 0x7, PseudoVLUXSEG8EI32_V_MF2_MF8_MASK }, // 1296 + { 0x8, 0x1, 0x0, 0x5, 0x6, 0x0, PseudoVLUXSEG8EI32_V_M1_MF4_MASK }, // 1297 + { 0x8, 0x1, 0x0, 0x5, 0x6, 0x7, PseudoVLUXSEG8EI32_V_MF2_MF4_MASK }, // 1298 + { 0x8, 0x1, 0x0, 0x5, 0x7, 0x0, PseudoVLUXSEG8EI32_V_M1_MF2_MASK }, // 1299 + { 0x8, 0x1, 0x0, 0x5, 0x7, 0x1, PseudoVLUXSEG8EI32_V_M2_MF2_MASK }, // 1300 + { 0x8, 0x1, 0x0, 0x5, 0x7, 0x7, PseudoVLUXSEG8EI32_V_MF2_MF2_MASK }, // 1301 + { 0x8, 0x1, 0x0, 0x6, 0x0, 0x0, PseudoVLUXSEG8EI64_V_M1_M1_MASK }, // 1302 + { 0x8, 0x1, 0x0, 0x6, 0x0, 0x1, PseudoVLUXSEG8EI64_V_M2_M1_MASK }, // 1303 + { 0x8, 0x1, 0x0, 0x6, 0x0, 0x2, PseudoVLUXSEG8EI64_V_M4_M1_MASK }, // 1304 + { 0x8, 0x1, 0x0, 0x6, 0x0, 0x3, PseudoVLUXSEG8EI64_V_M8_M1_MASK }, // 1305 + { 0x8, 0x1, 0x0, 0x6, 0x5, 0x0, PseudoVLUXSEG8EI64_V_M1_MF8_MASK }, // 1306 + { 0x8, 0x1, 0x0, 0x6, 0x6, 0x0, PseudoVLUXSEG8EI64_V_M1_MF4_MASK }, // 1307 + { 0x8, 0x1, 0x0, 0x6, 0x6, 0x1, PseudoVLUXSEG8EI64_V_M2_MF4_MASK }, // 1308 + { 0x8, 0x1, 0x0, 0x6, 0x7, 0x0, PseudoVLUXSEG8EI64_V_M1_MF2_MASK }, // 1309 + { 0x8, 0x1, 0x0, 0x6, 0x7, 0x1, PseudoVLUXSEG8EI64_V_M2_MF2_MASK }, // 1310 + { 0x8, 0x1, 0x0, 0x6, 0x7, 0x2, PseudoVLUXSEG8EI64_V_M4_MF2_MASK }, // 1311 + { 0x8, 0x1, 0x1, 0x3, 0x0, 0x0, PseudoVLOXSEG8EI8_V_M1_M1_MASK }, // 1312 + { 0x8, 0x1, 0x1, 0x3, 0x0, 0x5, PseudoVLOXSEG8EI8_V_MF8_M1_MASK }, // 1313 + { 0x8, 0x1, 0x1, 0x3, 0x0, 0x6, PseudoVLOXSEG8EI8_V_MF4_M1_MASK }, // 1314 + { 0x8, 0x1, 0x1, 0x3, 0x0, 0x7, PseudoVLOXSEG8EI8_V_MF2_M1_MASK }, // 1315 + { 0x8, 0x1, 0x1, 0x3, 0x5, 0x5, PseudoVLOXSEG8EI8_V_MF8_MF8_MASK }, // 1316 + { 0x8, 0x1, 0x1, 0x3, 0x6, 0x5, PseudoVLOXSEG8EI8_V_MF8_MF4_MASK }, // 1317 + { 0x8, 0x1, 0x1, 0x3, 0x6, 0x6, PseudoVLOXSEG8EI8_V_MF4_MF4_MASK }, // 1318 + { 0x8, 0x1, 0x1, 0x3, 0x7, 0x5, PseudoVLOXSEG8EI8_V_MF8_MF2_MASK }, // 1319 + { 0x8, 0x1, 0x1, 0x3, 0x7, 0x6, PseudoVLOXSEG8EI8_V_MF4_MF2_MASK }, // 1320 + { 0x8, 0x1, 0x1, 0x3, 0x7, 0x7, PseudoVLOXSEG8EI8_V_MF2_MF2_MASK }, // 1321 + { 0x8, 0x1, 0x1, 0x4, 0x0, 0x0, PseudoVLOXSEG8EI16_V_M1_M1_MASK }, // 1322 + { 0x8, 0x1, 0x1, 0x4, 0x0, 0x1, PseudoVLOXSEG8EI16_V_M2_M1_MASK }, // 1323 + { 0x8, 0x1, 0x1, 0x4, 0x0, 0x6, PseudoVLOXSEG8EI16_V_MF4_M1_MASK }, // 1324 + { 0x8, 0x1, 0x1, 0x4, 0x0, 0x7, PseudoVLOXSEG8EI16_V_MF2_M1_MASK }, // 1325 + { 0x8, 0x1, 0x1, 0x4, 0x5, 0x6, PseudoVLOXSEG8EI16_V_MF4_MF8_MASK }, // 1326 + { 0x8, 0x1, 0x1, 0x4, 0x6, 0x6, PseudoVLOXSEG8EI16_V_MF4_MF4_MASK }, // 1327 + { 0x8, 0x1, 0x1, 0x4, 0x6, 0x7, PseudoVLOXSEG8EI16_V_MF2_MF4_MASK }, // 1328 + { 0x8, 0x1, 0x1, 0x4, 0x7, 0x0, PseudoVLOXSEG8EI16_V_M1_MF2_MASK }, // 1329 + { 0x8, 0x1, 0x1, 0x4, 0x7, 0x6, PseudoVLOXSEG8EI16_V_MF4_MF2_MASK }, // 1330 + { 0x8, 0x1, 0x1, 0x4, 0x7, 0x7, PseudoVLOXSEG8EI16_V_MF2_MF2_MASK }, // 1331 + { 0x8, 0x1, 0x1, 0x5, 0x0, 0x0, PseudoVLOXSEG8EI32_V_M1_M1_MASK }, // 1332 + { 0x8, 0x1, 0x1, 0x5, 0x0, 0x1, PseudoVLOXSEG8EI32_V_M2_M1_MASK }, // 1333 + { 0x8, 0x1, 0x1, 0x5, 0x0, 0x2, PseudoVLOXSEG8EI32_V_M4_M1_MASK }, // 1334 + { 0x8, 0x1, 0x1, 0x5, 0x0, 0x7, PseudoVLOXSEG8EI32_V_MF2_M1_MASK }, // 1335 + { 0x8, 0x1, 0x1, 0x5, 0x5, 0x7, PseudoVLOXSEG8EI32_V_MF2_MF8_MASK }, // 1336 + { 0x8, 0x1, 0x1, 0x5, 0x6, 0x0, PseudoVLOXSEG8EI32_V_M1_MF4_MASK }, // 1337 + { 0x8, 0x1, 0x1, 0x5, 0x6, 0x7, PseudoVLOXSEG8EI32_V_MF2_MF4_MASK }, // 1338 + { 0x8, 0x1, 0x1, 0x5, 0x7, 0x0, PseudoVLOXSEG8EI32_V_M1_MF2_MASK }, // 1339 + { 0x8, 0x1, 0x1, 0x5, 0x7, 0x1, PseudoVLOXSEG8EI32_V_M2_MF2_MASK }, // 1340 + { 0x8, 0x1, 0x1, 0x5, 0x7, 0x7, PseudoVLOXSEG8EI32_V_MF2_MF2_MASK }, // 1341 + { 0x8, 0x1, 0x1, 0x6, 0x0, 0x0, PseudoVLOXSEG8EI64_V_M1_M1_MASK }, // 1342 + { 0x8, 0x1, 0x1, 0x6, 0x0, 0x1, PseudoVLOXSEG8EI64_V_M2_M1_MASK }, // 1343 + { 0x8, 0x1, 0x1, 0x6, 0x0, 0x2, PseudoVLOXSEG8EI64_V_M4_M1_MASK }, // 1344 + { 0x8, 0x1, 0x1, 0x6, 0x0, 0x3, PseudoVLOXSEG8EI64_V_M8_M1_MASK }, // 1345 + { 0x8, 0x1, 0x1, 0x6, 0x5, 0x0, PseudoVLOXSEG8EI64_V_M1_MF8_MASK }, // 1346 + { 0x8, 0x1, 0x1, 0x6, 0x6, 0x0, PseudoVLOXSEG8EI64_V_M1_MF4_MASK }, // 1347 + { 0x8, 0x1, 0x1, 0x6, 0x6, 0x1, PseudoVLOXSEG8EI64_V_M2_MF4_MASK }, // 1348 + { 0x8, 0x1, 0x1, 0x6, 0x7, 0x0, PseudoVLOXSEG8EI64_V_M1_MF2_MASK }, // 1349 + { 0x8, 0x1, 0x1, 0x6, 0x7, 0x1, PseudoVLOXSEG8EI64_V_M2_MF2_MASK }, // 1350 + { 0x8, 0x1, 0x1, 0x6, 0x7, 0x2, PseudoVLOXSEG8EI64_V_M4_MF2_MASK }, // 1351 + }; + +const RISCV_VLXSEGPseudo *RISCV_getVLXSEGPseudo(uint8_t NF, uint8_t Masked, uint8_t Ordered, uint8_t Log2SEW, uint8_t LMUL, uint8_t IndexLMUL) { + unsigned i = binsearch_IndexTypeEncoding(Index, ARR_SIZE(Index), NFMaskedOrderedLog2SEWLMULIndexLMUL); + if (i == -1) + return NULL; + else + return &RISCVVLXSEGTable[Index[i].index]; +} + +#endif + +#ifdef GET_RISCVVLXTable_IMPL +static const RISCV_VLX_VSXPseudo RISCVVLXTable[] = { + { 0x0, 0x0, 0x3, 0x0, 0x0, PseudoVLUXEI8_V_M1_M1 }, // 0 + { 0x0, 0x0, 0x3, 0x0, 0x5, PseudoVLUXEI8_V_MF8_M1 }, // 1 + { 0x0, 0x0, 0x3, 0x0, 0x6, PseudoVLUXEI8_V_MF4_M1 }, // 2 + { 0x0, 0x0, 0x3, 0x0, 0x7, PseudoVLUXEI8_V_MF2_M1 }, // 3 + { 0x0, 0x0, 0x3, 0x1, 0x0, PseudoVLUXEI8_V_M1_M2 }, // 4 + { 0x0, 0x0, 0x3, 0x1, 0x1, PseudoVLUXEI8_V_M2_M2 }, // 5 + { 0x0, 0x0, 0x3, 0x1, 0x6, PseudoVLUXEI8_V_MF4_M2 }, // 6 + { 0x0, 0x0, 0x3, 0x1, 0x7, PseudoVLUXEI8_V_MF2_M2 }, // 7 + { 0x0, 0x0, 0x3, 0x2, 0x0, PseudoVLUXEI8_V_M1_M4 }, // 8 + { 0x0, 0x0, 0x3, 0x2, 0x1, PseudoVLUXEI8_V_M2_M4 }, // 9 + { 0x0, 0x0, 0x3, 0x2, 0x2, PseudoVLUXEI8_V_M4_M4 }, // 10 + { 0x0, 0x0, 0x3, 0x2, 0x7, PseudoVLUXEI8_V_MF2_M4 }, // 11 + { 0x0, 0x0, 0x3, 0x3, 0x0, PseudoVLUXEI8_V_M1_M8 }, // 12 + { 0x0, 0x0, 0x3, 0x3, 0x1, PseudoVLUXEI8_V_M2_M8 }, // 13 + { 0x0, 0x0, 0x3, 0x3, 0x2, PseudoVLUXEI8_V_M4_M8 }, // 14 + { 0x0, 0x0, 0x3, 0x3, 0x3, PseudoVLUXEI8_V_M8_M8 }, // 15 + { 0x0, 0x0, 0x3, 0x5, 0x5, PseudoVLUXEI8_V_MF8_MF8 }, // 16 + { 0x0, 0x0, 0x3, 0x6, 0x5, PseudoVLUXEI8_V_MF8_MF4 }, // 17 + { 0x0, 0x0, 0x3, 0x6, 0x6, PseudoVLUXEI8_V_MF4_MF4 }, // 18 + { 0x0, 0x0, 0x3, 0x7, 0x5, PseudoVLUXEI8_V_MF8_MF2 }, // 19 + { 0x0, 0x0, 0x3, 0x7, 0x6, PseudoVLUXEI8_V_MF4_MF2 }, // 20 + { 0x0, 0x0, 0x3, 0x7, 0x7, PseudoVLUXEI8_V_MF2_MF2 }, // 21 + { 0x0, 0x0, 0x4, 0x0, 0x0, PseudoVLUXEI16_V_M1_M1 }, // 22 + { 0x0, 0x0, 0x4, 0x0, 0x1, PseudoVLUXEI16_V_M2_M1 }, // 23 + { 0x0, 0x0, 0x4, 0x0, 0x6, PseudoVLUXEI16_V_MF4_M1 }, // 24 + { 0x0, 0x0, 0x4, 0x0, 0x7, PseudoVLUXEI16_V_MF2_M1 }, // 25 + { 0x0, 0x0, 0x4, 0x1, 0x0, PseudoVLUXEI16_V_M1_M2 }, // 26 + { 0x0, 0x0, 0x4, 0x1, 0x1, PseudoVLUXEI16_V_M2_M2 }, // 27 + { 0x0, 0x0, 0x4, 0x1, 0x2, PseudoVLUXEI16_V_M4_M2 }, // 28 + { 0x0, 0x0, 0x4, 0x1, 0x7, PseudoVLUXEI16_V_MF2_M2 }, // 29 + { 0x0, 0x0, 0x4, 0x2, 0x0, PseudoVLUXEI16_V_M1_M4 }, // 30 + { 0x0, 0x0, 0x4, 0x2, 0x1, PseudoVLUXEI16_V_M2_M4 }, // 31 + { 0x0, 0x0, 0x4, 0x2, 0x2, PseudoVLUXEI16_V_M4_M4 }, // 32 + { 0x0, 0x0, 0x4, 0x2, 0x3, PseudoVLUXEI16_V_M8_M4 }, // 33 + { 0x0, 0x0, 0x4, 0x3, 0x1, PseudoVLUXEI16_V_M2_M8 }, // 34 + { 0x0, 0x0, 0x4, 0x3, 0x2, PseudoVLUXEI16_V_M4_M8 }, // 35 + { 0x0, 0x0, 0x4, 0x3, 0x3, PseudoVLUXEI16_V_M8_M8 }, // 36 + { 0x0, 0x0, 0x4, 0x5, 0x6, PseudoVLUXEI16_V_MF4_MF8 }, // 37 + { 0x0, 0x0, 0x4, 0x6, 0x6, PseudoVLUXEI16_V_MF4_MF4 }, // 38 + { 0x0, 0x0, 0x4, 0x6, 0x7, PseudoVLUXEI16_V_MF2_MF4 }, // 39 + { 0x0, 0x0, 0x4, 0x7, 0x0, PseudoVLUXEI16_V_M1_MF2 }, // 40 + { 0x0, 0x0, 0x4, 0x7, 0x6, PseudoVLUXEI16_V_MF4_MF2 }, // 41 + { 0x0, 0x0, 0x4, 0x7, 0x7, PseudoVLUXEI16_V_MF2_MF2 }, // 42 + { 0x0, 0x0, 0x5, 0x0, 0x0, PseudoVLUXEI32_V_M1_M1 }, // 43 + { 0x0, 0x0, 0x5, 0x0, 0x1, PseudoVLUXEI32_V_M2_M1 }, // 44 + { 0x0, 0x0, 0x5, 0x0, 0x2, PseudoVLUXEI32_V_M4_M1 }, // 45 + { 0x0, 0x0, 0x5, 0x0, 0x7, PseudoVLUXEI32_V_MF2_M1 }, // 46 + { 0x0, 0x0, 0x5, 0x1, 0x0, PseudoVLUXEI32_V_M1_M2 }, // 47 + { 0x0, 0x0, 0x5, 0x1, 0x1, PseudoVLUXEI32_V_M2_M2 }, // 48 + { 0x0, 0x0, 0x5, 0x1, 0x2, PseudoVLUXEI32_V_M4_M2 }, // 49 + { 0x0, 0x0, 0x5, 0x1, 0x3, PseudoVLUXEI32_V_M8_M2 }, // 50 + { 0x0, 0x0, 0x5, 0x2, 0x1, PseudoVLUXEI32_V_M2_M4 }, // 51 + { 0x0, 0x0, 0x5, 0x2, 0x2, PseudoVLUXEI32_V_M4_M4 }, // 52 + { 0x0, 0x0, 0x5, 0x2, 0x3, PseudoVLUXEI32_V_M8_M4 }, // 53 + { 0x0, 0x0, 0x5, 0x3, 0x2, PseudoVLUXEI32_V_M4_M8 }, // 54 + { 0x0, 0x0, 0x5, 0x3, 0x3, PseudoVLUXEI32_V_M8_M8 }, // 55 + { 0x0, 0x0, 0x5, 0x5, 0x7, PseudoVLUXEI32_V_MF2_MF8 }, // 56 + { 0x0, 0x0, 0x5, 0x6, 0x0, PseudoVLUXEI32_V_M1_MF4 }, // 57 + { 0x0, 0x0, 0x5, 0x6, 0x7, PseudoVLUXEI32_V_MF2_MF4 }, // 58 + { 0x0, 0x0, 0x5, 0x7, 0x0, PseudoVLUXEI32_V_M1_MF2 }, // 59 + { 0x0, 0x0, 0x5, 0x7, 0x1, PseudoVLUXEI32_V_M2_MF2 }, // 60 + { 0x0, 0x0, 0x5, 0x7, 0x7, PseudoVLUXEI32_V_MF2_MF2 }, // 61 + { 0x0, 0x0, 0x6, 0x0, 0x0, PseudoVLUXEI64_V_M1_M1 }, // 62 + { 0x0, 0x0, 0x6, 0x0, 0x1, PseudoVLUXEI64_V_M2_M1 }, // 63 + { 0x0, 0x0, 0x6, 0x0, 0x2, PseudoVLUXEI64_V_M4_M1 }, // 64 + { 0x0, 0x0, 0x6, 0x0, 0x3, PseudoVLUXEI64_V_M8_M1 }, // 65 + { 0x0, 0x0, 0x6, 0x1, 0x1, PseudoVLUXEI64_V_M2_M2 }, // 66 + { 0x0, 0x0, 0x6, 0x1, 0x2, PseudoVLUXEI64_V_M4_M2 }, // 67 + { 0x0, 0x0, 0x6, 0x1, 0x3, PseudoVLUXEI64_V_M8_M2 }, // 68 + { 0x0, 0x0, 0x6, 0x2, 0x2, PseudoVLUXEI64_V_M4_M4 }, // 69 + { 0x0, 0x0, 0x6, 0x2, 0x3, PseudoVLUXEI64_V_M8_M4 }, // 70 + { 0x0, 0x0, 0x6, 0x3, 0x3, PseudoVLUXEI64_V_M8_M8 }, // 71 + { 0x0, 0x0, 0x6, 0x5, 0x0, PseudoVLUXEI64_V_M1_MF8 }, // 72 + { 0x0, 0x0, 0x6, 0x6, 0x0, PseudoVLUXEI64_V_M1_MF4 }, // 73 + { 0x0, 0x0, 0x6, 0x6, 0x1, PseudoVLUXEI64_V_M2_MF4 }, // 74 + { 0x0, 0x0, 0x6, 0x7, 0x0, PseudoVLUXEI64_V_M1_MF2 }, // 75 + { 0x0, 0x0, 0x6, 0x7, 0x1, PseudoVLUXEI64_V_M2_MF2 }, // 76 + { 0x0, 0x0, 0x6, 0x7, 0x2, PseudoVLUXEI64_V_M4_MF2 }, // 77 + { 0x0, 0x1, 0x3, 0x0, 0x0, PseudoVLOXEI8_V_M1_M1 }, // 78 + { 0x0, 0x1, 0x3, 0x0, 0x5, PseudoVLOXEI8_V_MF8_M1 }, // 79 + { 0x0, 0x1, 0x3, 0x0, 0x6, PseudoVLOXEI8_V_MF4_M1 }, // 80 + { 0x0, 0x1, 0x3, 0x0, 0x7, PseudoVLOXEI8_V_MF2_M1 }, // 81 + { 0x0, 0x1, 0x3, 0x1, 0x0, PseudoVLOXEI8_V_M1_M2 }, // 82 + { 0x0, 0x1, 0x3, 0x1, 0x1, PseudoVLOXEI8_V_M2_M2 }, // 83 + { 0x0, 0x1, 0x3, 0x1, 0x6, PseudoVLOXEI8_V_MF4_M2 }, // 84 + { 0x0, 0x1, 0x3, 0x1, 0x7, PseudoVLOXEI8_V_MF2_M2 }, // 85 + { 0x0, 0x1, 0x3, 0x2, 0x0, PseudoVLOXEI8_V_M1_M4 }, // 86 + { 0x0, 0x1, 0x3, 0x2, 0x1, PseudoVLOXEI8_V_M2_M4 }, // 87 + { 0x0, 0x1, 0x3, 0x2, 0x2, PseudoVLOXEI8_V_M4_M4 }, // 88 + { 0x0, 0x1, 0x3, 0x2, 0x7, PseudoVLOXEI8_V_MF2_M4 }, // 89 + { 0x0, 0x1, 0x3, 0x3, 0x0, PseudoVLOXEI8_V_M1_M8 }, // 90 + { 0x0, 0x1, 0x3, 0x3, 0x1, PseudoVLOXEI8_V_M2_M8 }, // 91 + { 0x0, 0x1, 0x3, 0x3, 0x2, PseudoVLOXEI8_V_M4_M8 }, // 92 + { 0x0, 0x1, 0x3, 0x3, 0x3, PseudoVLOXEI8_V_M8_M8 }, // 93 + { 0x0, 0x1, 0x3, 0x5, 0x5, PseudoVLOXEI8_V_MF8_MF8 }, // 94 + { 0x0, 0x1, 0x3, 0x6, 0x5, PseudoVLOXEI8_V_MF8_MF4 }, // 95 + { 0x0, 0x1, 0x3, 0x6, 0x6, PseudoVLOXEI8_V_MF4_MF4 }, // 96 + { 0x0, 0x1, 0x3, 0x7, 0x5, PseudoVLOXEI8_V_MF8_MF2 }, // 97 + { 0x0, 0x1, 0x3, 0x7, 0x6, PseudoVLOXEI8_V_MF4_MF2 }, // 98 + { 0x0, 0x1, 0x3, 0x7, 0x7, PseudoVLOXEI8_V_MF2_MF2 }, // 99 + { 0x0, 0x1, 0x4, 0x0, 0x0, PseudoVLOXEI16_V_M1_M1 }, // 100 + { 0x0, 0x1, 0x4, 0x0, 0x1, PseudoVLOXEI16_V_M2_M1 }, // 101 + { 0x0, 0x1, 0x4, 0x0, 0x6, PseudoVLOXEI16_V_MF4_M1 }, // 102 + { 0x0, 0x1, 0x4, 0x0, 0x7, PseudoVLOXEI16_V_MF2_M1 }, // 103 + { 0x0, 0x1, 0x4, 0x1, 0x0, PseudoVLOXEI16_V_M1_M2 }, // 104 + { 0x0, 0x1, 0x4, 0x1, 0x1, PseudoVLOXEI16_V_M2_M2 }, // 105 + { 0x0, 0x1, 0x4, 0x1, 0x2, PseudoVLOXEI16_V_M4_M2 }, // 106 + { 0x0, 0x1, 0x4, 0x1, 0x7, PseudoVLOXEI16_V_MF2_M2 }, // 107 + { 0x0, 0x1, 0x4, 0x2, 0x0, PseudoVLOXEI16_V_M1_M4 }, // 108 + { 0x0, 0x1, 0x4, 0x2, 0x1, PseudoVLOXEI16_V_M2_M4 }, // 109 + { 0x0, 0x1, 0x4, 0x2, 0x2, PseudoVLOXEI16_V_M4_M4 }, // 110 + { 0x0, 0x1, 0x4, 0x2, 0x3, PseudoVLOXEI16_V_M8_M4 }, // 111 + { 0x0, 0x1, 0x4, 0x3, 0x1, PseudoVLOXEI16_V_M2_M8 }, // 112 + { 0x0, 0x1, 0x4, 0x3, 0x2, PseudoVLOXEI16_V_M4_M8 }, // 113 + { 0x0, 0x1, 0x4, 0x3, 0x3, PseudoVLOXEI16_V_M8_M8 }, // 114 + { 0x0, 0x1, 0x4, 0x5, 0x6, PseudoVLOXEI16_V_MF4_MF8 }, // 115 + { 0x0, 0x1, 0x4, 0x6, 0x6, PseudoVLOXEI16_V_MF4_MF4 }, // 116 + { 0x0, 0x1, 0x4, 0x6, 0x7, PseudoVLOXEI16_V_MF2_MF4 }, // 117 + { 0x0, 0x1, 0x4, 0x7, 0x0, PseudoVLOXEI16_V_M1_MF2 }, // 118 + { 0x0, 0x1, 0x4, 0x7, 0x6, PseudoVLOXEI16_V_MF4_MF2 }, // 119 + { 0x0, 0x1, 0x4, 0x7, 0x7, PseudoVLOXEI16_V_MF2_MF2 }, // 120 + { 0x0, 0x1, 0x5, 0x0, 0x0, PseudoVLOXEI32_V_M1_M1 }, // 121 + { 0x0, 0x1, 0x5, 0x0, 0x1, PseudoVLOXEI32_V_M2_M1 }, // 122 + { 0x0, 0x1, 0x5, 0x0, 0x2, PseudoVLOXEI32_V_M4_M1 }, // 123 + { 0x0, 0x1, 0x5, 0x0, 0x7, PseudoVLOXEI32_V_MF2_M1 }, // 124 + { 0x0, 0x1, 0x5, 0x1, 0x0, PseudoVLOXEI32_V_M1_M2 }, // 125 + { 0x0, 0x1, 0x5, 0x1, 0x1, PseudoVLOXEI32_V_M2_M2 }, // 126 + { 0x0, 0x1, 0x5, 0x1, 0x2, PseudoVLOXEI32_V_M4_M2 }, // 127 + { 0x0, 0x1, 0x5, 0x1, 0x3, PseudoVLOXEI32_V_M8_M2 }, // 128 + { 0x0, 0x1, 0x5, 0x2, 0x1, PseudoVLOXEI32_V_M2_M4 }, // 129 + { 0x0, 0x1, 0x5, 0x2, 0x2, PseudoVLOXEI32_V_M4_M4 }, // 130 + { 0x0, 0x1, 0x5, 0x2, 0x3, PseudoVLOXEI32_V_M8_M4 }, // 131 + { 0x0, 0x1, 0x5, 0x3, 0x2, PseudoVLOXEI32_V_M4_M8 }, // 132 + { 0x0, 0x1, 0x5, 0x3, 0x3, PseudoVLOXEI32_V_M8_M8 }, // 133 + { 0x0, 0x1, 0x5, 0x5, 0x7, PseudoVLOXEI32_V_MF2_MF8 }, // 134 + { 0x0, 0x1, 0x5, 0x6, 0x0, PseudoVLOXEI32_V_M1_MF4 }, // 135 + { 0x0, 0x1, 0x5, 0x6, 0x7, PseudoVLOXEI32_V_MF2_MF4 }, // 136 + { 0x0, 0x1, 0x5, 0x7, 0x0, PseudoVLOXEI32_V_M1_MF2 }, // 137 + { 0x0, 0x1, 0x5, 0x7, 0x1, PseudoVLOXEI32_V_M2_MF2 }, // 138 + { 0x0, 0x1, 0x5, 0x7, 0x7, PseudoVLOXEI32_V_MF2_MF2 }, // 139 + { 0x0, 0x1, 0x6, 0x0, 0x0, PseudoVLOXEI64_V_M1_M1 }, // 140 + { 0x0, 0x1, 0x6, 0x0, 0x1, PseudoVLOXEI64_V_M2_M1 }, // 141 + { 0x0, 0x1, 0x6, 0x0, 0x2, PseudoVLOXEI64_V_M4_M1 }, // 142 + { 0x0, 0x1, 0x6, 0x0, 0x3, PseudoVLOXEI64_V_M8_M1 }, // 143 + { 0x0, 0x1, 0x6, 0x1, 0x1, PseudoVLOXEI64_V_M2_M2 }, // 144 + { 0x0, 0x1, 0x6, 0x1, 0x2, PseudoVLOXEI64_V_M4_M2 }, // 145 + { 0x0, 0x1, 0x6, 0x1, 0x3, PseudoVLOXEI64_V_M8_M2 }, // 146 + { 0x0, 0x1, 0x6, 0x2, 0x2, PseudoVLOXEI64_V_M4_M4 }, // 147 + { 0x0, 0x1, 0x6, 0x2, 0x3, PseudoVLOXEI64_V_M8_M4 }, // 148 + { 0x0, 0x1, 0x6, 0x3, 0x3, PseudoVLOXEI64_V_M8_M8 }, // 149 + { 0x0, 0x1, 0x6, 0x5, 0x0, PseudoVLOXEI64_V_M1_MF8 }, // 150 + { 0x0, 0x1, 0x6, 0x6, 0x0, PseudoVLOXEI64_V_M1_MF4 }, // 151 + { 0x0, 0x1, 0x6, 0x6, 0x1, PseudoVLOXEI64_V_M2_MF4 }, // 152 + { 0x0, 0x1, 0x6, 0x7, 0x0, PseudoVLOXEI64_V_M1_MF2 }, // 153 + { 0x0, 0x1, 0x6, 0x7, 0x1, PseudoVLOXEI64_V_M2_MF2 }, // 154 + { 0x0, 0x1, 0x6, 0x7, 0x2, PseudoVLOXEI64_V_M4_MF2 }, // 155 + { 0x1, 0x0, 0x3, 0x0, 0x0, PseudoVLUXEI8_V_M1_M1_MASK }, // 156 + { 0x1, 0x0, 0x3, 0x0, 0x5, PseudoVLUXEI8_V_MF8_M1_MASK }, // 157 + { 0x1, 0x0, 0x3, 0x0, 0x6, PseudoVLUXEI8_V_MF4_M1_MASK }, // 158 + { 0x1, 0x0, 0x3, 0x0, 0x7, PseudoVLUXEI8_V_MF2_M1_MASK }, // 159 + { 0x1, 0x0, 0x3, 0x1, 0x0, PseudoVLUXEI8_V_M1_M2_MASK }, // 160 + { 0x1, 0x0, 0x3, 0x1, 0x1, PseudoVLUXEI8_V_M2_M2_MASK }, // 161 + { 0x1, 0x0, 0x3, 0x1, 0x6, PseudoVLUXEI8_V_MF4_M2_MASK }, // 162 + { 0x1, 0x0, 0x3, 0x1, 0x7, PseudoVLUXEI8_V_MF2_M2_MASK }, // 163 + { 0x1, 0x0, 0x3, 0x2, 0x0, PseudoVLUXEI8_V_M1_M4_MASK }, // 164 + { 0x1, 0x0, 0x3, 0x2, 0x1, PseudoVLUXEI8_V_M2_M4_MASK }, // 165 + { 0x1, 0x0, 0x3, 0x2, 0x2, PseudoVLUXEI8_V_M4_M4_MASK }, // 166 + { 0x1, 0x0, 0x3, 0x2, 0x7, PseudoVLUXEI8_V_MF2_M4_MASK }, // 167 + { 0x1, 0x0, 0x3, 0x3, 0x0, PseudoVLUXEI8_V_M1_M8_MASK }, // 168 + { 0x1, 0x0, 0x3, 0x3, 0x1, PseudoVLUXEI8_V_M2_M8_MASK }, // 169 + { 0x1, 0x0, 0x3, 0x3, 0x2, PseudoVLUXEI8_V_M4_M8_MASK }, // 170 + { 0x1, 0x0, 0x3, 0x3, 0x3, PseudoVLUXEI8_V_M8_M8_MASK }, // 171 + { 0x1, 0x0, 0x3, 0x5, 0x5, PseudoVLUXEI8_V_MF8_MF8_MASK }, // 172 + { 0x1, 0x0, 0x3, 0x6, 0x5, PseudoVLUXEI8_V_MF8_MF4_MASK }, // 173 + { 0x1, 0x0, 0x3, 0x6, 0x6, PseudoVLUXEI8_V_MF4_MF4_MASK }, // 174 + { 0x1, 0x0, 0x3, 0x7, 0x5, PseudoVLUXEI8_V_MF8_MF2_MASK }, // 175 + { 0x1, 0x0, 0x3, 0x7, 0x6, PseudoVLUXEI8_V_MF4_MF2_MASK }, // 176 + { 0x1, 0x0, 0x3, 0x7, 0x7, PseudoVLUXEI8_V_MF2_MF2_MASK }, // 177 + { 0x1, 0x0, 0x4, 0x0, 0x0, PseudoVLUXEI16_V_M1_M1_MASK }, // 178 + { 0x1, 0x0, 0x4, 0x0, 0x1, PseudoVLUXEI16_V_M2_M1_MASK }, // 179 + { 0x1, 0x0, 0x4, 0x0, 0x6, PseudoVLUXEI16_V_MF4_M1_MASK }, // 180 + { 0x1, 0x0, 0x4, 0x0, 0x7, PseudoVLUXEI16_V_MF2_M1_MASK }, // 181 + { 0x1, 0x0, 0x4, 0x1, 0x0, PseudoVLUXEI16_V_M1_M2_MASK }, // 182 + { 0x1, 0x0, 0x4, 0x1, 0x1, PseudoVLUXEI16_V_M2_M2_MASK }, // 183 + { 0x1, 0x0, 0x4, 0x1, 0x2, PseudoVLUXEI16_V_M4_M2_MASK }, // 184 + { 0x1, 0x0, 0x4, 0x1, 0x7, PseudoVLUXEI16_V_MF2_M2_MASK }, // 185 + { 0x1, 0x0, 0x4, 0x2, 0x0, PseudoVLUXEI16_V_M1_M4_MASK }, // 186 + { 0x1, 0x0, 0x4, 0x2, 0x1, PseudoVLUXEI16_V_M2_M4_MASK }, // 187 + { 0x1, 0x0, 0x4, 0x2, 0x2, PseudoVLUXEI16_V_M4_M4_MASK }, // 188 + { 0x1, 0x0, 0x4, 0x2, 0x3, PseudoVLUXEI16_V_M8_M4_MASK }, // 189 + { 0x1, 0x0, 0x4, 0x3, 0x1, PseudoVLUXEI16_V_M2_M8_MASK }, // 190 + { 0x1, 0x0, 0x4, 0x3, 0x2, PseudoVLUXEI16_V_M4_M8_MASK }, // 191 + { 0x1, 0x0, 0x4, 0x3, 0x3, PseudoVLUXEI16_V_M8_M8_MASK }, // 192 + { 0x1, 0x0, 0x4, 0x5, 0x6, PseudoVLUXEI16_V_MF4_MF8_MASK }, // 193 + { 0x1, 0x0, 0x4, 0x6, 0x6, PseudoVLUXEI16_V_MF4_MF4_MASK }, // 194 + { 0x1, 0x0, 0x4, 0x6, 0x7, PseudoVLUXEI16_V_MF2_MF4_MASK }, // 195 + { 0x1, 0x0, 0x4, 0x7, 0x0, PseudoVLUXEI16_V_M1_MF2_MASK }, // 196 + { 0x1, 0x0, 0x4, 0x7, 0x6, PseudoVLUXEI16_V_MF4_MF2_MASK }, // 197 + { 0x1, 0x0, 0x4, 0x7, 0x7, PseudoVLUXEI16_V_MF2_MF2_MASK }, // 198 + { 0x1, 0x0, 0x5, 0x0, 0x0, PseudoVLUXEI32_V_M1_M1_MASK }, // 199 + { 0x1, 0x0, 0x5, 0x0, 0x1, PseudoVLUXEI32_V_M2_M1_MASK }, // 200 + { 0x1, 0x0, 0x5, 0x0, 0x2, PseudoVLUXEI32_V_M4_M1_MASK }, // 201 + { 0x1, 0x0, 0x5, 0x0, 0x7, PseudoVLUXEI32_V_MF2_M1_MASK }, // 202 + { 0x1, 0x0, 0x5, 0x1, 0x0, PseudoVLUXEI32_V_M1_M2_MASK }, // 203 + { 0x1, 0x0, 0x5, 0x1, 0x1, PseudoVLUXEI32_V_M2_M2_MASK }, // 204 + { 0x1, 0x0, 0x5, 0x1, 0x2, PseudoVLUXEI32_V_M4_M2_MASK }, // 205 + { 0x1, 0x0, 0x5, 0x1, 0x3, PseudoVLUXEI32_V_M8_M2_MASK }, // 206 + { 0x1, 0x0, 0x5, 0x2, 0x1, PseudoVLUXEI32_V_M2_M4_MASK }, // 207 + { 0x1, 0x0, 0x5, 0x2, 0x2, PseudoVLUXEI32_V_M4_M4_MASK }, // 208 + { 0x1, 0x0, 0x5, 0x2, 0x3, PseudoVLUXEI32_V_M8_M4_MASK }, // 209 + { 0x1, 0x0, 0x5, 0x3, 0x2, PseudoVLUXEI32_V_M4_M8_MASK }, // 210 + { 0x1, 0x0, 0x5, 0x3, 0x3, PseudoVLUXEI32_V_M8_M8_MASK }, // 211 + { 0x1, 0x0, 0x5, 0x5, 0x7, PseudoVLUXEI32_V_MF2_MF8_MASK }, // 212 + { 0x1, 0x0, 0x5, 0x6, 0x0, PseudoVLUXEI32_V_M1_MF4_MASK }, // 213 + { 0x1, 0x0, 0x5, 0x6, 0x7, PseudoVLUXEI32_V_MF2_MF4_MASK }, // 214 + { 0x1, 0x0, 0x5, 0x7, 0x0, PseudoVLUXEI32_V_M1_MF2_MASK }, // 215 + { 0x1, 0x0, 0x5, 0x7, 0x1, PseudoVLUXEI32_V_M2_MF2_MASK }, // 216 + { 0x1, 0x0, 0x5, 0x7, 0x7, PseudoVLUXEI32_V_MF2_MF2_MASK }, // 217 + { 0x1, 0x0, 0x6, 0x0, 0x0, PseudoVLUXEI64_V_M1_M1_MASK }, // 218 + { 0x1, 0x0, 0x6, 0x0, 0x1, PseudoVLUXEI64_V_M2_M1_MASK }, // 219 + { 0x1, 0x0, 0x6, 0x0, 0x2, PseudoVLUXEI64_V_M4_M1_MASK }, // 220 + { 0x1, 0x0, 0x6, 0x0, 0x3, PseudoVLUXEI64_V_M8_M1_MASK }, // 221 + { 0x1, 0x0, 0x6, 0x1, 0x1, PseudoVLUXEI64_V_M2_M2_MASK }, // 222 + { 0x1, 0x0, 0x6, 0x1, 0x2, PseudoVLUXEI64_V_M4_M2_MASK }, // 223 + { 0x1, 0x0, 0x6, 0x1, 0x3, PseudoVLUXEI64_V_M8_M2_MASK }, // 224 + { 0x1, 0x0, 0x6, 0x2, 0x2, PseudoVLUXEI64_V_M4_M4_MASK }, // 225 + { 0x1, 0x0, 0x6, 0x2, 0x3, PseudoVLUXEI64_V_M8_M4_MASK }, // 226 + { 0x1, 0x0, 0x6, 0x3, 0x3, PseudoVLUXEI64_V_M8_M8_MASK }, // 227 + { 0x1, 0x0, 0x6, 0x5, 0x0, PseudoVLUXEI64_V_M1_MF8_MASK }, // 228 + { 0x1, 0x0, 0x6, 0x6, 0x0, PseudoVLUXEI64_V_M1_MF4_MASK }, // 229 + { 0x1, 0x0, 0x6, 0x6, 0x1, PseudoVLUXEI64_V_M2_MF4_MASK }, // 230 + { 0x1, 0x0, 0x6, 0x7, 0x0, PseudoVLUXEI64_V_M1_MF2_MASK }, // 231 + { 0x1, 0x0, 0x6, 0x7, 0x1, PseudoVLUXEI64_V_M2_MF2_MASK }, // 232 + { 0x1, 0x0, 0x6, 0x7, 0x2, PseudoVLUXEI64_V_M4_MF2_MASK }, // 233 + { 0x1, 0x1, 0x3, 0x0, 0x0, PseudoVLOXEI8_V_M1_M1_MASK }, // 234 + { 0x1, 0x1, 0x3, 0x0, 0x5, PseudoVLOXEI8_V_MF8_M1_MASK }, // 235 + { 0x1, 0x1, 0x3, 0x0, 0x6, PseudoVLOXEI8_V_MF4_M1_MASK }, // 236 + { 0x1, 0x1, 0x3, 0x0, 0x7, PseudoVLOXEI8_V_MF2_M1_MASK }, // 237 + { 0x1, 0x1, 0x3, 0x1, 0x0, PseudoVLOXEI8_V_M1_M2_MASK }, // 238 + { 0x1, 0x1, 0x3, 0x1, 0x1, PseudoVLOXEI8_V_M2_M2_MASK }, // 239 + { 0x1, 0x1, 0x3, 0x1, 0x6, PseudoVLOXEI8_V_MF4_M2_MASK }, // 240 + { 0x1, 0x1, 0x3, 0x1, 0x7, PseudoVLOXEI8_V_MF2_M2_MASK }, // 241 + { 0x1, 0x1, 0x3, 0x2, 0x0, PseudoVLOXEI8_V_M1_M4_MASK }, // 242 + { 0x1, 0x1, 0x3, 0x2, 0x1, PseudoVLOXEI8_V_M2_M4_MASK }, // 243 + { 0x1, 0x1, 0x3, 0x2, 0x2, PseudoVLOXEI8_V_M4_M4_MASK }, // 244 + { 0x1, 0x1, 0x3, 0x2, 0x7, PseudoVLOXEI8_V_MF2_M4_MASK }, // 245 + { 0x1, 0x1, 0x3, 0x3, 0x0, PseudoVLOXEI8_V_M1_M8_MASK }, // 246 + { 0x1, 0x1, 0x3, 0x3, 0x1, PseudoVLOXEI8_V_M2_M8_MASK }, // 247 + { 0x1, 0x1, 0x3, 0x3, 0x2, PseudoVLOXEI8_V_M4_M8_MASK }, // 248 + { 0x1, 0x1, 0x3, 0x3, 0x3, PseudoVLOXEI8_V_M8_M8_MASK }, // 249 + { 0x1, 0x1, 0x3, 0x5, 0x5, PseudoVLOXEI8_V_MF8_MF8_MASK }, // 250 + { 0x1, 0x1, 0x3, 0x6, 0x5, PseudoVLOXEI8_V_MF8_MF4_MASK }, // 251 + { 0x1, 0x1, 0x3, 0x6, 0x6, PseudoVLOXEI8_V_MF4_MF4_MASK }, // 252 + { 0x1, 0x1, 0x3, 0x7, 0x5, PseudoVLOXEI8_V_MF8_MF2_MASK }, // 253 + { 0x1, 0x1, 0x3, 0x7, 0x6, PseudoVLOXEI8_V_MF4_MF2_MASK }, // 254 + { 0x1, 0x1, 0x3, 0x7, 0x7, PseudoVLOXEI8_V_MF2_MF2_MASK }, // 255 + { 0x1, 0x1, 0x4, 0x0, 0x0, PseudoVLOXEI16_V_M1_M1_MASK }, // 256 + { 0x1, 0x1, 0x4, 0x0, 0x1, PseudoVLOXEI16_V_M2_M1_MASK }, // 257 + { 0x1, 0x1, 0x4, 0x0, 0x6, PseudoVLOXEI16_V_MF4_M1_MASK }, // 258 + { 0x1, 0x1, 0x4, 0x0, 0x7, PseudoVLOXEI16_V_MF2_M1_MASK }, // 259 + { 0x1, 0x1, 0x4, 0x1, 0x0, PseudoVLOXEI16_V_M1_M2_MASK }, // 260 + { 0x1, 0x1, 0x4, 0x1, 0x1, PseudoVLOXEI16_V_M2_M2_MASK }, // 261 + { 0x1, 0x1, 0x4, 0x1, 0x2, PseudoVLOXEI16_V_M4_M2_MASK }, // 262 + { 0x1, 0x1, 0x4, 0x1, 0x7, PseudoVLOXEI16_V_MF2_M2_MASK }, // 263 + { 0x1, 0x1, 0x4, 0x2, 0x0, PseudoVLOXEI16_V_M1_M4_MASK }, // 264 + { 0x1, 0x1, 0x4, 0x2, 0x1, PseudoVLOXEI16_V_M2_M4_MASK }, // 265 + { 0x1, 0x1, 0x4, 0x2, 0x2, PseudoVLOXEI16_V_M4_M4_MASK }, // 266 + { 0x1, 0x1, 0x4, 0x2, 0x3, PseudoVLOXEI16_V_M8_M4_MASK }, // 267 + { 0x1, 0x1, 0x4, 0x3, 0x1, PseudoVLOXEI16_V_M2_M8_MASK }, // 268 + { 0x1, 0x1, 0x4, 0x3, 0x2, PseudoVLOXEI16_V_M4_M8_MASK }, // 269 + { 0x1, 0x1, 0x4, 0x3, 0x3, PseudoVLOXEI16_V_M8_M8_MASK }, // 270 + { 0x1, 0x1, 0x4, 0x5, 0x6, PseudoVLOXEI16_V_MF4_MF8_MASK }, // 271 + { 0x1, 0x1, 0x4, 0x6, 0x6, PseudoVLOXEI16_V_MF4_MF4_MASK }, // 272 + { 0x1, 0x1, 0x4, 0x6, 0x7, PseudoVLOXEI16_V_MF2_MF4_MASK }, // 273 + { 0x1, 0x1, 0x4, 0x7, 0x0, PseudoVLOXEI16_V_M1_MF2_MASK }, // 274 + { 0x1, 0x1, 0x4, 0x7, 0x6, PseudoVLOXEI16_V_MF4_MF2_MASK }, // 275 + { 0x1, 0x1, 0x4, 0x7, 0x7, PseudoVLOXEI16_V_MF2_MF2_MASK }, // 276 + { 0x1, 0x1, 0x5, 0x0, 0x0, PseudoVLOXEI32_V_M1_M1_MASK }, // 277 + { 0x1, 0x1, 0x5, 0x0, 0x1, PseudoVLOXEI32_V_M2_M1_MASK }, // 278 + { 0x1, 0x1, 0x5, 0x0, 0x2, PseudoVLOXEI32_V_M4_M1_MASK }, // 279 + { 0x1, 0x1, 0x5, 0x0, 0x7, PseudoVLOXEI32_V_MF2_M1_MASK }, // 280 + { 0x1, 0x1, 0x5, 0x1, 0x0, PseudoVLOXEI32_V_M1_M2_MASK }, // 281 + { 0x1, 0x1, 0x5, 0x1, 0x1, PseudoVLOXEI32_V_M2_M2_MASK }, // 282 + { 0x1, 0x1, 0x5, 0x1, 0x2, PseudoVLOXEI32_V_M4_M2_MASK }, // 283 + { 0x1, 0x1, 0x5, 0x1, 0x3, PseudoVLOXEI32_V_M8_M2_MASK }, // 284 + { 0x1, 0x1, 0x5, 0x2, 0x1, PseudoVLOXEI32_V_M2_M4_MASK }, // 285 + { 0x1, 0x1, 0x5, 0x2, 0x2, PseudoVLOXEI32_V_M4_M4_MASK }, // 286 + { 0x1, 0x1, 0x5, 0x2, 0x3, PseudoVLOXEI32_V_M8_M4_MASK }, // 287 + { 0x1, 0x1, 0x5, 0x3, 0x2, PseudoVLOXEI32_V_M4_M8_MASK }, // 288 + { 0x1, 0x1, 0x5, 0x3, 0x3, PseudoVLOXEI32_V_M8_M8_MASK }, // 289 + { 0x1, 0x1, 0x5, 0x5, 0x7, PseudoVLOXEI32_V_MF2_MF8_MASK }, // 290 + { 0x1, 0x1, 0x5, 0x6, 0x0, PseudoVLOXEI32_V_M1_MF4_MASK }, // 291 + { 0x1, 0x1, 0x5, 0x6, 0x7, PseudoVLOXEI32_V_MF2_MF4_MASK }, // 292 + { 0x1, 0x1, 0x5, 0x7, 0x0, PseudoVLOXEI32_V_M1_MF2_MASK }, // 293 + { 0x1, 0x1, 0x5, 0x7, 0x1, PseudoVLOXEI32_V_M2_MF2_MASK }, // 294 + { 0x1, 0x1, 0x5, 0x7, 0x7, PseudoVLOXEI32_V_MF2_MF2_MASK }, // 295 + { 0x1, 0x1, 0x6, 0x0, 0x0, PseudoVLOXEI64_V_M1_M1_MASK }, // 296 + { 0x1, 0x1, 0x6, 0x0, 0x1, PseudoVLOXEI64_V_M2_M1_MASK }, // 297 + { 0x1, 0x1, 0x6, 0x0, 0x2, PseudoVLOXEI64_V_M4_M1_MASK }, // 298 + { 0x1, 0x1, 0x6, 0x0, 0x3, PseudoVLOXEI64_V_M8_M1_MASK }, // 299 + { 0x1, 0x1, 0x6, 0x1, 0x1, PseudoVLOXEI64_V_M2_M2_MASK }, // 300 + { 0x1, 0x1, 0x6, 0x1, 0x2, PseudoVLOXEI64_V_M4_M2_MASK }, // 301 + { 0x1, 0x1, 0x6, 0x1, 0x3, PseudoVLOXEI64_V_M8_M2_MASK }, // 302 + { 0x1, 0x1, 0x6, 0x2, 0x2, PseudoVLOXEI64_V_M4_M4_MASK }, // 303 + { 0x1, 0x1, 0x6, 0x2, 0x3, PseudoVLOXEI64_V_M8_M4_MASK }, // 304 + { 0x1, 0x1, 0x6, 0x3, 0x3, PseudoVLOXEI64_V_M8_M8_MASK }, // 305 + { 0x1, 0x1, 0x6, 0x5, 0x0, PseudoVLOXEI64_V_M1_MF8_MASK }, // 306 + { 0x1, 0x1, 0x6, 0x6, 0x0, PseudoVLOXEI64_V_M1_MF4_MASK }, // 307 + { 0x1, 0x1, 0x6, 0x6, 0x1, PseudoVLOXEI64_V_M2_MF4_MASK }, // 308 + { 0x1, 0x1, 0x6, 0x7, 0x0, PseudoVLOXEI64_V_M1_MF2_MASK }, // 309 + { 0x1, 0x1, 0x6, 0x7, 0x1, PseudoVLOXEI64_V_M2_MF2_MASK }, // 310 + { 0x1, 0x1, 0x6, 0x7, 0x2, PseudoVLOXEI64_V_M4_MF2_MASK }, // 311 + }; + +const RISCV_VLX_VSXPseudo *RISCV_getVLXPseudo(uint8_t Masked, uint8_t Ordered, uint8_t Log2SEW, uint8_t LMUL, uint8_t IndexLMUL) { + unsigned i = binsearch_IndexTypeEncoding(Index, ARR_SIZE(Index), MaskedOrderedLog2SEWLMULIndexLMUL); + if (i == -1) + return NULL; + else + return &RISCVVLXTable[Index[i].index]; +} + +#endif + +#ifdef GET_RISCVVPseudosTable_IMPL +static const RISCV_PseudoInfo RISCVVPseudosTable[] = { + { PseudoTHVdotVMAQASU_VV_M1, THVdotVMAQASU_VV }, // 0 + { PseudoTHVdotVMAQASU_VV_M1_MASK, THVdotVMAQASU_VV }, // 1 + { PseudoTHVdotVMAQASU_VV_M2, THVdotVMAQASU_VV }, // 2 + { PseudoTHVdotVMAQASU_VV_M2_MASK, THVdotVMAQASU_VV }, // 3 + { PseudoTHVdotVMAQASU_VV_M4, THVdotVMAQASU_VV }, // 4 + { PseudoTHVdotVMAQASU_VV_M4_MASK, THVdotVMAQASU_VV }, // 5 + { PseudoTHVdotVMAQASU_VV_M8, THVdotVMAQASU_VV }, // 6 + { PseudoTHVdotVMAQASU_VV_M8_MASK, THVdotVMAQASU_VV }, // 7 + { PseudoTHVdotVMAQASU_VV_MF2, THVdotVMAQASU_VV }, // 8 + { PseudoTHVdotVMAQASU_VV_MF2_MASK, THVdotVMAQASU_VV }, // 9 + { PseudoTHVdotVMAQASU_VX_M1, THVdotVMAQASU_VX }, // 10 + { PseudoTHVdotVMAQASU_VX_M1_MASK, THVdotVMAQASU_VX }, // 11 + { PseudoTHVdotVMAQASU_VX_M2, THVdotVMAQASU_VX }, // 12 + { PseudoTHVdotVMAQASU_VX_M2_MASK, THVdotVMAQASU_VX }, // 13 + { PseudoTHVdotVMAQASU_VX_M4, THVdotVMAQASU_VX }, // 14 + { PseudoTHVdotVMAQASU_VX_M4_MASK, THVdotVMAQASU_VX }, // 15 + { PseudoTHVdotVMAQASU_VX_M8, THVdotVMAQASU_VX }, // 16 + { PseudoTHVdotVMAQASU_VX_M8_MASK, THVdotVMAQASU_VX }, // 17 + { PseudoTHVdotVMAQASU_VX_MF2, THVdotVMAQASU_VX }, // 18 + { PseudoTHVdotVMAQASU_VX_MF2_MASK, THVdotVMAQASU_VX }, // 19 + { PseudoTHVdotVMAQAUS_VX_M1, THVdotVMAQAUS_VX }, // 20 + { PseudoTHVdotVMAQAUS_VX_M1_MASK, THVdotVMAQAUS_VX }, // 21 + { PseudoTHVdotVMAQAUS_VX_M2, THVdotVMAQAUS_VX }, // 22 + { PseudoTHVdotVMAQAUS_VX_M2_MASK, THVdotVMAQAUS_VX }, // 23 + { PseudoTHVdotVMAQAUS_VX_M4, THVdotVMAQAUS_VX }, // 24 + { PseudoTHVdotVMAQAUS_VX_M4_MASK, THVdotVMAQAUS_VX }, // 25 + { PseudoTHVdotVMAQAUS_VX_M8, THVdotVMAQAUS_VX }, // 26 + { PseudoTHVdotVMAQAUS_VX_M8_MASK, THVdotVMAQAUS_VX }, // 27 + { PseudoTHVdotVMAQAUS_VX_MF2, THVdotVMAQAUS_VX }, // 28 + { PseudoTHVdotVMAQAUS_VX_MF2_MASK, THVdotVMAQAUS_VX }, // 29 + { PseudoTHVdotVMAQAU_VV_M1, THVdotVMAQAU_VV }, // 30 + { PseudoTHVdotVMAQAU_VV_M1_MASK, THVdotVMAQAU_VV }, // 31 + { PseudoTHVdotVMAQAU_VV_M2, THVdotVMAQAU_VV }, // 32 + { PseudoTHVdotVMAQAU_VV_M2_MASK, THVdotVMAQAU_VV }, // 33 + { PseudoTHVdotVMAQAU_VV_M4, THVdotVMAQAU_VV }, // 34 + { PseudoTHVdotVMAQAU_VV_M4_MASK, THVdotVMAQAU_VV }, // 35 + { PseudoTHVdotVMAQAU_VV_M8, THVdotVMAQAU_VV }, // 36 + { PseudoTHVdotVMAQAU_VV_M8_MASK, THVdotVMAQAU_VV }, // 37 + { PseudoTHVdotVMAQAU_VV_MF2, THVdotVMAQAU_VV }, // 38 + { PseudoTHVdotVMAQAU_VV_MF2_MASK, THVdotVMAQAU_VV }, // 39 + { PseudoTHVdotVMAQAU_VX_M1, THVdotVMAQAU_VX }, // 40 + { PseudoTHVdotVMAQAU_VX_M1_MASK, THVdotVMAQAU_VX }, // 41 + { PseudoTHVdotVMAQAU_VX_M2, THVdotVMAQAU_VX }, // 42 + { PseudoTHVdotVMAQAU_VX_M2_MASK, THVdotVMAQAU_VX }, // 43 + { PseudoTHVdotVMAQAU_VX_M4, THVdotVMAQAU_VX }, // 44 + { PseudoTHVdotVMAQAU_VX_M4_MASK, THVdotVMAQAU_VX }, // 45 + { PseudoTHVdotVMAQAU_VX_M8, THVdotVMAQAU_VX }, // 46 + { PseudoTHVdotVMAQAU_VX_M8_MASK, THVdotVMAQAU_VX }, // 47 + { PseudoTHVdotVMAQAU_VX_MF2, THVdotVMAQAU_VX }, // 48 + { PseudoTHVdotVMAQAU_VX_MF2_MASK, THVdotVMAQAU_VX }, // 49 + { PseudoTHVdotVMAQA_VV_M1, THVdotVMAQA_VV }, // 50 + { PseudoTHVdotVMAQA_VV_M1_MASK, THVdotVMAQA_VV }, // 51 + { PseudoTHVdotVMAQA_VV_M2, THVdotVMAQA_VV }, // 52 + { PseudoTHVdotVMAQA_VV_M2_MASK, THVdotVMAQA_VV }, // 53 + { PseudoTHVdotVMAQA_VV_M4, THVdotVMAQA_VV }, // 54 + { PseudoTHVdotVMAQA_VV_M4_MASK, THVdotVMAQA_VV }, // 55 + { PseudoTHVdotVMAQA_VV_M8, THVdotVMAQA_VV }, // 56 + { PseudoTHVdotVMAQA_VV_M8_MASK, THVdotVMAQA_VV }, // 57 + { PseudoTHVdotVMAQA_VV_MF2, THVdotVMAQA_VV }, // 58 + { PseudoTHVdotVMAQA_VV_MF2_MASK, THVdotVMAQA_VV }, // 59 + { PseudoTHVdotVMAQA_VX_M1, THVdotVMAQA_VX }, // 60 + { PseudoTHVdotVMAQA_VX_M1_MASK, THVdotVMAQA_VX }, // 61 + { PseudoTHVdotVMAQA_VX_M2, THVdotVMAQA_VX }, // 62 + { PseudoTHVdotVMAQA_VX_M2_MASK, THVdotVMAQA_VX }, // 63 + { PseudoTHVdotVMAQA_VX_M4, THVdotVMAQA_VX }, // 64 + { PseudoTHVdotVMAQA_VX_M4_MASK, THVdotVMAQA_VX }, // 65 + { PseudoTHVdotVMAQA_VX_M8, THVdotVMAQA_VX }, // 66 + { PseudoTHVdotVMAQA_VX_M8_MASK, THVdotVMAQA_VX }, // 67 + { PseudoTHVdotVMAQA_VX_MF2, THVdotVMAQA_VX }, // 68 + { PseudoTHVdotVMAQA_VX_MF2_MASK, THVdotVMAQA_VX }, // 69 + { PseudoVAADDU_VV_M1, VAADDU_VV }, // 70 + { PseudoVAADDU_VV_M1_MASK, VAADDU_VV }, // 71 + { PseudoVAADDU_VV_M2, VAADDU_VV }, // 72 + { PseudoVAADDU_VV_M2_MASK, VAADDU_VV }, // 73 + { PseudoVAADDU_VV_M4, VAADDU_VV }, // 74 + { PseudoVAADDU_VV_M4_MASK, VAADDU_VV }, // 75 + { PseudoVAADDU_VV_M8, VAADDU_VV }, // 76 + { PseudoVAADDU_VV_M8_MASK, VAADDU_VV }, // 77 + { PseudoVAADDU_VV_MF2, VAADDU_VV }, // 78 + { PseudoVAADDU_VV_MF2_MASK, VAADDU_VV }, // 79 + { PseudoVAADDU_VV_MF4, VAADDU_VV }, // 80 + { PseudoVAADDU_VV_MF4_MASK, VAADDU_VV }, // 81 + { PseudoVAADDU_VV_MF8, VAADDU_VV }, // 82 + { PseudoVAADDU_VV_MF8_MASK, VAADDU_VV }, // 83 + { PseudoVAADDU_VX_M1, VAADDU_VX }, // 84 + { PseudoVAADDU_VX_M1_MASK, VAADDU_VX }, // 85 + { PseudoVAADDU_VX_M2, VAADDU_VX }, // 86 + { PseudoVAADDU_VX_M2_MASK, VAADDU_VX }, // 87 + { PseudoVAADDU_VX_M4, VAADDU_VX }, // 88 + { PseudoVAADDU_VX_M4_MASK, VAADDU_VX }, // 89 + { PseudoVAADDU_VX_M8, VAADDU_VX }, // 90 + { PseudoVAADDU_VX_M8_MASK, VAADDU_VX }, // 91 + { PseudoVAADDU_VX_MF2, VAADDU_VX }, // 92 + { PseudoVAADDU_VX_MF2_MASK, VAADDU_VX }, // 93 + { PseudoVAADDU_VX_MF4, VAADDU_VX }, // 94 + { PseudoVAADDU_VX_MF4_MASK, VAADDU_VX }, // 95 + { PseudoVAADDU_VX_MF8, VAADDU_VX }, // 96 + { PseudoVAADDU_VX_MF8_MASK, VAADDU_VX }, // 97 + { PseudoVAADD_VV_M1, VAADD_VV }, // 98 + { PseudoVAADD_VV_M1_MASK, VAADD_VV }, // 99 + { PseudoVAADD_VV_M2, VAADD_VV }, // 100 + { PseudoVAADD_VV_M2_MASK, VAADD_VV }, // 101 + { PseudoVAADD_VV_M4, VAADD_VV }, // 102 + { PseudoVAADD_VV_M4_MASK, VAADD_VV }, // 103 + { PseudoVAADD_VV_M8, VAADD_VV }, // 104 + { PseudoVAADD_VV_M8_MASK, VAADD_VV }, // 105 + { PseudoVAADD_VV_MF2, VAADD_VV }, // 106 + { PseudoVAADD_VV_MF2_MASK, VAADD_VV }, // 107 + { PseudoVAADD_VV_MF4, VAADD_VV }, // 108 + { PseudoVAADD_VV_MF4_MASK, VAADD_VV }, // 109 + { PseudoVAADD_VV_MF8, VAADD_VV }, // 110 + { PseudoVAADD_VV_MF8_MASK, VAADD_VV }, // 111 + { PseudoVAADD_VX_M1, VAADD_VX }, // 112 + { PseudoVAADD_VX_M1_MASK, VAADD_VX }, // 113 + { PseudoVAADD_VX_M2, VAADD_VX }, // 114 + { PseudoVAADD_VX_M2_MASK, VAADD_VX }, // 115 + { PseudoVAADD_VX_M4, VAADD_VX }, // 116 + { PseudoVAADD_VX_M4_MASK, VAADD_VX }, // 117 + { PseudoVAADD_VX_M8, VAADD_VX }, // 118 + { PseudoVAADD_VX_M8_MASK, VAADD_VX }, // 119 + { PseudoVAADD_VX_MF2, VAADD_VX }, // 120 + { PseudoVAADD_VX_MF2_MASK, VAADD_VX }, // 121 + { PseudoVAADD_VX_MF4, VAADD_VX }, // 122 + { PseudoVAADD_VX_MF4_MASK, VAADD_VX }, // 123 + { PseudoVAADD_VX_MF8, VAADD_VX }, // 124 + { PseudoVAADD_VX_MF8_MASK, VAADD_VX }, // 125 + { PseudoVADC_VIM_M1, VADC_VIM }, // 126 + { PseudoVADC_VIM_M2, VADC_VIM }, // 127 + { PseudoVADC_VIM_M4, VADC_VIM }, // 128 + { PseudoVADC_VIM_M8, VADC_VIM }, // 129 + { PseudoVADC_VIM_MF2, VADC_VIM }, // 130 + { PseudoVADC_VIM_MF4, VADC_VIM }, // 131 + { PseudoVADC_VIM_MF8, VADC_VIM }, // 132 + { PseudoVADC_VVM_M1, VADC_VVM }, // 133 + { PseudoVADC_VVM_M2, VADC_VVM }, // 134 + { PseudoVADC_VVM_M4, VADC_VVM }, // 135 + { PseudoVADC_VVM_M8, VADC_VVM }, // 136 + { PseudoVADC_VVM_MF2, VADC_VVM }, // 137 + { PseudoVADC_VVM_MF4, VADC_VVM }, // 138 + { PseudoVADC_VVM_MF8, VADC_VVM }, // 139 + { PseudoVADC_VXM_M1, VADC_VXM }, // 140 + { PseudoVADC_VXM_M2, VADC_VXM }, // 141 + { PseudoVADC_VXM_M4, VADC_VXM }, // 142 + { PseudoVADC_VXM_M8, VADC_VXM }, // 143 + { PseudoVADC_VXM_MF2, VADC_VXM }, // 144 + { PseudoVADC_VXM_MF4, VADC_VXM }, // 145 + { PseudoVADC_VXM_MF8, VADC_VXM }, // 146 + { PseudoVADD_VI_M1, VADD_VI }, // 147 + { PseudoVADD_VI_M1_MASK, VADD_VI }, // 148 + { PseudoVADD_VI_M2, VADD_VI }, // 149 + { PseudoVADD_VI_M2_MASK, VADD_VI }, // 150 + { PseudoVADD_VI_M4, VADD_VI }, // 151 + { PseudoVADD_VI_M4_MASK, VADD_VI }, // 152 + { PseudoVADD_VI_M8, VADD_VI }, // 153 + { PseudoVADD_VI_M8_MASK, VADD_VI }, // 154 + { PseudoVADD_VI_MF2, VADD_VI }, // 155 + { PseudoVADD_VI_MF2_MASK, VADD_VI }, // 156 + { PseudoVADD_VI_MF4, VADD_VI }, // 157 + { PseudoVADD_VI_MF4_MASK, VADD_VI }, // 158 + { PseudoVADD_VI_MF8, VADD_VI }, // 159 + { PseudoVADD_VI_MF8_MASK, VADD_VI }, // 160 + { PseudoVADD_VV_M1, VADD_VV }, // 161 + { PseudoVADD_VV_M1_MASK, VADD_VV }, // 162 + { PseudoVADD_VV_M2, VADD_VV }, // 163 + { PseudoVADD_VV_M2_MASK, VADD_VV }, // 164 + { PseudoVADD_VV_M4, VADD_VV }, // 165 + { PseudoVADD_VV_M4_MASK, VADD_VV }, // 166 + { PseudoVADD_VV_M8, VADD_VV }, // 167 + { PseudoVADD_VV_M8_MASK, VADD_VV }, // 168 + { PseudoVADD_VV_MF2, VADD_VV }, // 169 + { PseudoVADD_VV_MF2_MASK, VADD_VV }, // 170 + { PseudoVADD_VV_MF4, VADD_VV }, // 171 + { PseudoVADD_VV_MF4_MASK, VADD_VV }, // 172 + { PseudoVADD_VV_MF8, VADD_VV }, // 173 + { PseudoVADD_VV_MF8_MASK, VADD_VV }, // 174 + { PseudoVADD_VX_M1, VADD_VX }, // 175 + { PseudoVADD_VX_M1_MASK, VADD_VX }, // 176 + { PseudoVADD_VX_M2, VADD_VX }, // 177 + { PseudoVADD_VX_M2_MASK, VADD_VX }, // 178 + { PseudoVADD_VX_M4, VADD_VX }, // 179 + { PseudoVADD_VX_M4_MASK, VADD_VX }, // 180 + { PseudoVADD_VX_M8, VADD_VX }, // 181 + { PseudoVADD_VX_M8_MASK, VADD_VX }, // 182 + { PseudoVADD_VX_MF2, VADD_VX }, // 183 + { PseudoVADD_VX_MF2_MASK, VADD_VX }, // 184 + { PseudoVADD_VX_MF4, VADD_VX }, // 185 + { PseudoVADD_VX_MF4_MASK, VADD_VX }, // 186 + { PseudoVADD_VX_MF8, VADD_VX }, // 187 + { PseudoVADD_VX_MF8_MASK, VADD_VX }, // 188 + { PseudoVAESDF_VS_M1_M1, VAESDF_VS }, // 189 + { PseudoVAESDF_VS_M1_MF2, VAESDF_VS }, // 190 + { PseudoVAESDF_VS_M1_MF4, VAESDF_VS }, // 191 + { PseudoVAESDF_VS_M1_MF8, VAESDF_VS }, // 192 + { PseudoVAESDF_VS_M2_M1, VAESDF_VS }, // 193 + { PseudoVAESDF_VS_M2_M2, VAESDF_VS }, // 194 + { PseudoVAESDF_VS_M2_MF2, VAESDF_VS }, // 195 + { PseudoVAESDF_VS_M2_MF4, VAESDF_VS }, // 196 + { PseudoVAESDF_VS_M2_MF8, VAESDF_VS }, // 197 + { PseudoVAESDF_VS_M4_M1, VAESDF_VS }, // 198 + { PseudoVAESDF_VS_M4_M2, VAESDF_VS }, // 199 + { PseudoVAESDF_VS_M4_M4, VAESDF_VS }, // 200 + { PseudoVAESDF_VS_M4_MF2, VAESDF_VS }, // 201 + { PseudoVAESDF_VS_M4_MF4, VAESDF_VS }, // 202 + { PseudoVAESDF_VS_M4_MF8, VAESDF_VS }, // 203 + { PseudoVAESDF_VS_M8_M1, VAESDF_VS }, // 204 + { PseudoVAESDF_VS_M8_M2, VAESDF_VS }, // 205 + { PseudoVAESDF_VS_M8_M4, VAESDF_VS }, // 206 + { PseudoVAESDF_VS_M8_MF2, VAESDF_VS }, // 207 + { PseudoVAESDF_VS_M8_MF4, VAESDF_VS }, // 208 + { PseudoVAESDF_VS_M8_MF8, VAESDF_VS }, // 209 + { PseudoVAESDF_VS_MF2_MF2, VAESDF_VS }, // 210 + { PseudoVAESDF_VS_MF2_MF4, VAESDF_VS }, // 211 + { PseudoVAESDF_VS_MF2_MF8, VAESDF_VS }, // 212 + { PseudoVAESDF_VV_M1, VAESDF_VV }, // 213 + { PseudoVAESDF_VV_M2, VAESDF_VV }, // 214 + { PseudoVAESDF_VV_M4, VAESDF_VV }, // 215 + { PseudoVAESDF_VV_M8, VAESDF_VV }, // 216 + { PseudoVAESDF_VV_MF2, VAESDF_VV }, // 217 + { PseudoVAESDM_VS_M1_M1, VAESDM_VS }, // 218 + { PseudoVAESDM_VS_M1_MF2, VAESDM_VS }, // 219 + { PseudoVAESDM_VS_M1_MF4, VAESDM_VS }, // 220 + { PseudoVAESDM_VS_M1_MF8, VAESDM_VS }, // 221 + { PseudoVAESDM_VS_M2_M1, VAESDM_VS }, // 222 + { PseudoVAESDM_VS_M2_M2, VAESDM_VS }, // 223 + { PseudoVAESDM_VS_M2_MF2, VAESDM_VS }, // 224 + { PseudoVAESDM_VS_M2_MF4, VAESDM_VS }, // 225 + { PseudoVAESDM_VS_M2_MF8, VAESDM_VS }, // 226 + { PseudoVAESDM_VS_M4_M1, VAESDM_VS }, // 227 + { PseudoVAESDM_VS_M4_M2, VAESDM_VS }, // 228 + { PseudoVAESDM_VS_M4_M4, VAESDM_VS }, // 229 + { PseudoVAESDM_VS_M4_MF2, VAESDM_VS }, // 230 + { PseudoVAESDM_VS_M4_MF4, VAESDM_VS }, // 231 + { PseudoVAESDM_VS_M4_MF8, VAESDM_VS }, // 232 + { PseudoVAESDM_VS_M8_M1, VAESDM_VS }, // 233 + { PseudoVAESDM_VS_M8_M2, VAESDM_VS }, // 234 + { PseudoVAESDM_VS_M8_M4, VAESDM_VS }, // 235 + { PseudoVAESDM_VS_M8_MF2, VAESDM_VS }, // 236 + { PseudoVAESDM_VS_M8_MF4, VAESDM_VS }, // 237 + { PseudoVAESDM_VS_M8_MF8, VAESDM_VS }, // 238 + { PseudoVAESDM_VS_MF2_MF2, VAESDM_VS }, // 239 + { PseudoVAESDM_VS_MF2_MF4, VAESDM_VS }, // 240 + { PseudoVAESDM_VS_MF2_MF8, VAESDM_VS }, // 241 + { PseudoVAESDM_VV_M1, VAESDM_VV }, // 242 + { PseudoVAESDM_VV_M2, VAESDM_VV }, // 243 + { PseudoVAESDM_VV_M4, VAESDM_VV }, // 244 + { PseudoVAESDM_VV_M8, VAESDM_VV }, // 245 + { PseudoVAESDM_VV_MF2, VAESDM_VV }, // 246 + { PseudoVAESEF_VS_M1_M1, VAESEF_VS }, // 247 + { PseudoVAESEF_VS_M1_MF2, VAESEF_VS }, // 248 + { PseudoVAESEF_VS_M1_MF4, VAESEF_VS }, // 249 + { PseudoVAESEF_VS_M1_MF8, VAESEF_VS }, // 250 + { PseudoVAESEF_VS_M2_M1, VAESEF_VS }, // 251 + { PseudoVAESEF_VS_M2_M2, VAESEF_VS }, // 252 + { PseudoVAESEF_VS_M2_MF2, VAESEF_VS }, // 253 + { PseudoVAESEF_VS_M2_MF4, VAESEF_VS }, // 254 + { PseudoVAESEF_VS_M2_MF8, VAESEF_VS }, // 255 + { PseudoVAESEF_VS_M4_M1, VAESEF_VS }, // 256 + { PseudoVAESEF_VS_M4_M2, VAESEF_VS }, // 257 + { PseudoVAESEF_VS_M4_M4, VAESEF_VS }, // 258 + { PseudoVAESEF_VS_M4_MF2, VAESEF_VS }, // 259 + { PseudoVAESEF_VS_M4_MF4, VAESEF_VS }, // 260 + { PseudoVAESEF_VS_M4_MF8, VAESEF_VS }, // 261 + { PseudoVAESEF_VS_M8_M1, VAESEF_VS }, // 262 + { PseudoVAESEF_VS_M8_M2, VAESEF_VS }, // 263 + { PseudoVAESEF_VS_M8_M4, VAESEF_VS }, // 264 + { PseudoVAESEF_VS_M8_MF2, VAESEF_VS }, // 265 + { PseudoVAESEF_VS_M8_MF4, VAESEF_VS }, // 266 + { PseudoVAESEF_VS_M8_MF8, VAESEF_VS }, // 267 + { PseudoVAESEF_VS_MF2_MF2, VAESEF_VS }, // 268 + { PseudoVAESEF_VS_MF2_MF4, VAESEF_VS }, // 269 + { PseudoVAESEF_VS_MF2_MF8, VAESEF_VS }, // 270 + { PseudoVAESEF_VV_M1, VAESEF_VV }, // 271 + { PseudoVAESEF_VV_M2, VAESEF_VV }, // 272 + { PseudoVAESEF_VV_M4, VAESEF_VV }, // 273 + { PseudoVAESEF_VV_M8, VAESEF_VV }, // 274 + { PseudoVAESEF_VV_MF2, VAESEF_VV }, // 275 + { PseudoVAESEM_VS_M1_M1, VAESEM_VS }, // 276 + { PseudoVAESEM_VS_M1_MF2, VAESEM_VS }, // 277 + { PseudoVAESEM_VS_M1_MF4, VAESEM_VS }, // 278 + { PseudoVAESEM_VS_M1_MF8, VAESEM_VS }, // 279 + { PseudoVAESEM_VS_M2_M1, VAESEM_VS }, // 280 + { PseudoVAESEM_VS_M2_M2, VAESEM_VS }, // 281 + { PseudoVAESEM_VS_M2_MF2, VAESEM_VS }, // 282 + { PseudoVAESEM_VS_M2_MF4, VAESEM_VS }, // 283 + { PseudoVAESEM_VS_M2_MF8, VAESEM_VS }, // 284 + { PseudoVAESEM_VS_M4_M1, VAESEM_VS }, // 285 + { PseudoVAESEM_VS_M4_M2, VAESEM_VS }, // 286 + { PseudoVAESEM_VS_M4_M4, VAESEM_VS }, // 287 + { PseudoVAESEM_VS_M4_MF2, VAESEM_VS }, // 288 + { PseudoVAESEM_VS_M4_MF4, VAESEM_VS }, // 289 + { PseudoVAESEM_VS_M4_MF8, VAESEM_VS }, // 290 + { PseudoVAESEM_VS_M8_M1, VAESEM_VS }, // 291 + { PseudoVAESEM_VS_M8_M2, VAESEM_VS }, // 292 + { PseudoVAESEM_VS_M8_M4, VAESEM_VS }, // 293 + { PseudoVAESEM_VS_M8_MF2, VAESEM_VS }, // 294 + { PseudoVAESEM_VS_M8_MF4, VAESEM_VS }, // 295 + { PseudoVAESEM_VS_M8_MF8, VAESEM_VS }, // 296 + { PseudoVAESEM_VS_MF2_MF2, VAESEM_VS }, // 297 + { PseudoVAESEM_VS_MF2_MF4, VAESEM_VS }, // 298 + { PseudoVAESEM_VS_MF2_MF8, VAESEM_VS }, // 299 + { PseudoVAESEM_VV_M1, VAESEM_VV }, // 300 + { PseudoVAESEM_VV_M2, VAESEM_VV }, // 301 + { PseudoVAESEM_VV_M4, VAESEM_VV }, // 302 + { PseudoVAESEM_VV_M8, VAESEM_VV }, // 303 + { PseudoVAESEM_VV_MF2, VAESEM_VV }, // 304 + { PseudoVAESKF1_VI_M1, VAESKF1_VI }, // 305 + { PseudoVAESKF1_VI_M2, VAESKF1_VI }, // 306 + { PseudoVAESKF1_VI_M4, VAESKF1_VI }, // 307 + { PseudoVAESKF1_VI_M8, VAESKF1_VI }, // 308 + { PseudoVAESKF1_VI_MF2, VAESKF1_VI }, // 309 + { PseudoVAESKF2_VI_M1, VAESKF2_VI }, // 310 + { PseudoVAESKF2_VI_M2, VAESKF2_VI }, // 311 + { PseudoVAESKF2_VI_M4, VAESKF2_VI }, // 312 + { PseudoVAESKF2_VI_M8, VAESKF2_VI }, // 313 + { PseudoVAESKF2_VI_MF2, VAESKF2_VI }, // 314 + { PseudoVAESZ_VS_M1_M1, VAESZ_VS }, // 315 + { PseudoVAESZ_VS_M1_MF2, VAESZ_VS }, // 316 + { PseudoVAESZ_VS_M1_MF4, VAESZ_VS }, // 317 + { PseudoVAESZ_VS_M1_MF8, VAESZ_VS }, // 318 + { PseudoVAESZ_VS_M2_M1, VAESZ_VS }, // 319 + { PseudoVAESZ_VS_M2_M2, VAESZ_VS }, // 320 + { PseudoVAESZ_VS_M2_MF2, VAESZ_VS }, // 321 + { PseudoVAESZ_VS_M2_MF4, VAESZ_VS }, // 322 + { PseudoVAESZ_VS_M2_MF8, VAESZ_VS }, // 323 + { PseudoVAESZ_VS_M4_M1, VAESZ_VS }, // 324 + { PseudoVAESZ_VS_M4_M2, VAESZ_VS }, // 325 + { PseudoVAESZ_VS_M4_M4, VAESZ_VS }, // 326 + { PseudoVAESZ_VS_M4_MF2, VAESZ_VS }, // 327 + { PseudoVAESZ_VS_M4_MF4, VAESZ_VS }, // 328 + { PseudoVAESZ_VS_M4_MF8, VAESZ_VS }, // 329 + { PseudoVAESZ_VS_M8_M1, VAESZ_VS }, // 330 + { PseudoVAESZ_VS_M8_M2, VAESZ_VS }, // 331 + { PseudoVAESZ_VS_M8_M4, VAESZ_VS }, // 332 + { PseudoVAESZ_VS_M8_MF2, VAESZ_VS }, // 333 + { PseudoVAESZ_VS_M8_MF4, VAESZ_VS }, // 334 + { PseudoVAESZ_VS_M8_MF8, VAESZ_VS }, // 335 + { PseudoVAESZ_VS_MF2_MF2, VAESZ_VS }, // 336 + { PseudoVAESZ_VS_MF2_MF4, VAESZ_VS }, // 337 + { PseudoVAESZ_VS_MF2_MF8, VAESZ_VS }, // 338 + { PseudoVANDN_VV_M1, VANDN_VV }, // 339 + { PseudoVANDN_VV_M1_MASK, VANDN_VV }, // 340 + { PseudoVANDN_VV_M2, VANDN_VV }, // 341 + { PseudoVANDN_VV_M2_MASK, VANDN_VV }, // 342 + { PseudoVANDN_VV_M4, VANDN_VV }, // 343 + { PseudoVANDN_VV_M4_MASK, VANDN_VV }, // 344 + { PseudoVANDN_VV_M8, VANDN_VV }, // 345 + { PseudoVANDN_VV_M8_MASK, VANDN_VV }, // 346 + { PseudoVANDN_VV_MF2, VANDN_VV }, // 347 + { PseudoVANDN_VV_MF2_MASK, VANDN_VV }, // 348 + { PseudoVANDN_VV_MF4, VANDN_VV }, // 349 + { PseudoVANDN_VV_MF4_MASK, VANDN_VV }, // 350 + { PseudoVANDN_VV_MF8, VANDN_VV }, // 351 + { PseudoVANDN_VV_MF8_MASK, VANDN_VV }, // 352 + { PseudoVANDN_VX_M1, VANDN_VX }, // 353 + { PseudoVANDN_VX_M1_MASK, VANDN_VX }, // 354 + { PseudoVANDN_VX_M2, VANDN_VX }, // 355 + { PseudoVANDN_VX_M2_MASK, VANDN_VX }, // 356 + { PseudoVANDN_VX_M4, VANDN_VX }, // 357 + { PseudoVANDN_VX_M4_MASK, VANDN_VX }, // 358 + { PseudoVANDN_VX_M8, VANDN_VX }, // 359 + { PseudoVANDN_VX_M8_MASK, VANDN_VX }, // 360 + { PseudoVANDN_VX_MF2, VANDN_VX }, // 361 + { PseudoVANDN_VX_MF2_MASK, VANDN_VX }, // 362 + { PseudoVANDN_VX_MF4, VANDN_VX }, // 363 + { PseudoVANDN_VX_MF4_MASK, VANDN_VX }, // 364 + { PseudoVANDN_VX_MF8, VANDN_VX }, // 365 + { PseudoVANDN_VX_MF8_MASK, VANDN_VX }, // 366 + { PseudoVAND_VI_M1, VAND_VI }, // 367 + { PseudoVAND_VI_M1_MASK, VAND_VI }, // 368 + { PseudoVAND_VI_M2, VAND_VI }, // 369 + { PseudoVAND_VI_M2_MASK, VAND_VI }, // 370 + { PseudoVAND_VI_M4, VAND_VI }, // 371 + { PseudoVAND_VI_M4_MASK, VAND_VI }, // 372 + { PseudoVAND_VI_M8, VAND_VI }, // 373 + { PseudoVAND_VI_M8_MASK, VAND_VI }, // 374 + { PseudoVAND_VI_MF2, VAND_VI }, // 375 + { PseudoVAND_VI_MF2_MASK, VAND_VI }, // 376 + { PseudoVAND_VI_MF4, VAND_VI }, // 377 + { PseudoVAND_VI_MF4_MASK, VAND_VI }, // 378 + { PseudoVAND_VI_MF8, VAND_VI }, // 379 + { PseudoVAND_VI_MF8_MASK, VAND_VI }, // 380 + { PseudoVAND_VV_M1, VAND_VV }, // 381 + { PseudoVAND_VV_M1_MASK, VAND_VV }, // 382 + { PseudoVAND_VV_M2, VAND_VV }, // 383 + { PseudoVAND_VV_M2_MASK, VAND_VV }, // 384 + { PseudoVAND_VV_M4, VAND_VV }, // 385 + { PseudoVAND_VV_M4_MASK, VAND_VV }, // 386 + { PseudoVAND_VV_M8, VAND_VV }, // 387 + { PseudoVAND_VV_M8_MASK, VAND_VV }, // 388 + { PseudoVAND_VV_MF2, VAND_VV }, // 389 + { PseudoVAND_VV_MF2_MASK, VAND_VV }, // 390 + { PseudoVAND_VV_MF4, VAND_VV }, // 391 + { PseudoVAND_VV_MF4_MASK, VAND_VV }, // 392 + { PseudoVAND_VV_MF8, VAND_VV }, // 393 + { PseudoVAND_VV_MF8_MASK, VAND_VV }, // 394 + { PseudoVAND_VX_M1, VAND_VX }, // 395 + { PseudoVAND_VX_M1_MASK, VAND_VX }, // 396 + { PseudoVAND_VX_M2, VAND_VX }, // 397 + { PseudoVAND_VX_M2_MASK, VAND_VX }, // 398 + { PseudoVAND_VX_M4, VAND_VX }, // 399 + { PseudoVAND_VX_M4_MASK, VAND_VX }, // 400 + { PseudoVAND_VX_M8, VAND_VX }, // 401 + { PseudoVAND_VX_M8_MASK, VAND_VX }, // 402 + { PseudoVAND_VX_MF2, VAND_VX }, // 403 + { PseudoVAND_VX_MF2_MASK, VAND_VX }, // 404 + { PseudoVAND_VX_MF4, VAND_VX }, // 405 + { PseudoVAND_VX_MF4_MASK, VAND_VX }, // 406 + { PseudoVAND_VX_MF8, VAND_VX }, // 407 + { PseudoVAND_VX_MF8_MASK, VAND_VX }, // 408 + { PseudoVASUBU_VV_M1, VASUBU_VV }, // 409 + { PseudoVASUBU_VV_M1_MASK, VASUBU_VV }, // 410 + { PseudoVASUBU_VV_M2, VASUBU_VV }, // 411 + { PseudoVASUBU_VV_M2_MASK, VASUBU_VV }, // 412 + { PseudoVASUBU_VV_M4, VASUBU_VV }, // 413 + { PseudoVASUBU_VV_M4_MASK, VASUBU_VV }, // 414 + { PseudoVASUBU_VV_M8, VASUBU_VV }, // 415 + { PseudoVASUBU_VV_M8_MASK, VASUBU_VV }, // 416 + { PseudoVASUBU_VV_MF2, VASUBU_VV }, // 417 + { PseudoVASUBU_VV_MF2_MASK, VASUBU_VV }, // 418 + { PseudoVASUBU_VV_MF4, VASUBU_VV }, // 419 + { PseudoVASUBU_VV_MF4_MASK, VASUBU_VV }, // 420 + { PseudoVASUBU_VV_MF8, VASUBU_VV }, // 421 + { PseudoVASUBU_VV_MF8_MASK, VASUBU_VV }, // 422 + { PseudoVASUBU_VX_M1, VASUBU_VX }, // 423 + { PseudoVASUBU_VX_M1_MASK, VASUBU_VX }, // 424 + { PseudoVASUBU_VX_M2, VASUBU_VX }, // 425 + { PseudoVASUBU_VX_M2_MASK, VASUBU_VX }, // 426 + { PseudoVASUBU_VX_M4, VASUBU_VX }, // 427 + { PseudoVASUBU_VX_M4_MASK, VASUBU_VX }, // 428 + { PseudoVASUBU_VX_M8, VASUBU_VX }, // 429 + { PseudoVASUBU_VX_M8_MASK, VASUBU_VX }, // 430 + { PseudoVASUBU_VX_MF2, VASUBU_VX }, // 431 + { PseudoVASUBU_VX_MF2_MASK, VASUBU_VX }, // 432 + { PseudoVASUBU_VX_MF4, VASUBU_VX }, // 433 + { PseudoVASUBU_VX_MF4_MASK, VASUBU_VX }, // 434 + { PseudoVASUBU_VX_MF8, VASUBU_VX }, // 435 + { PseudoVASUBU_VX_MF8_MASK, VASUBU_VX }, // 436 + { PseudoVASUB_VV_M1, VASUB_VV }, // 437 + { PseudoVASUB_VV_M1_MASK, VASUB_VV }, // 438 + { PseudoVASUB_VV_M2, VASUB_VV }, // 439 + { PseudoVASUB_VV_M2_MASK, VASUB_VV }, // 440 + { PseudoVASUB_VV_M4, VASUB_VV }, // 441 + { PseudoVASUB_VV_M4_MASK, VASUB_VV }, // 442 + { PseudoVASUB_VV_M8, VASUB_VV }, // 443 + { PseudoVASUB_VV_M8_MASK, VASUB_VV }, // 444 + { PseudoVASUB_VV_MF2, VASUB_VV }, // 445 + { PseudoVASUB_VV_MF2_MASK, VASUB_VV }, // 446 + { PseudoVASUB_VV_MF4, VASUB_VV }, // 447 + { PseudoVASUB_VV_MF4_MASK, VASUB_VV }, // 448 + { PseudoVASUB_VV_MF8, VASUB_VV }, // 449 + { PseudoVASUB_VV_MF8_MASK, VASUB_VV }, // 450 + { PseudoVASUB_VX_M1, VASUB_VX }, // 451 + { PseudoVASUB_VX_M1_MASK, VASUB_VX }, // 452 + { PseudoVASUB_VX_M2, VASUB_VX }, // 453 + { PseudoVASUB_VX_M2_MASK, VASUB_VX }, // 454 + { PseudoVASUB_VX_M4, VASUB_VX }, // 455 + { PseudoVASUB_VX_M4_MASK, VASUB_VX }, // 456 + { PseudoVASUB_VX_M8, VASUB_VX }, // 457 + { PseudoVASUB_VX_M8_MASK, VASUB_VX }, // 458 + { PseudoVASUB_VX_MF2, VASUB_VX }, // 459 + { PseudoVASUB_VX_MF2_MASK, VASUB_VX }, // 460 + { PseudoVASUB_VX_MF4, VASUB_VX }, // 461 + { PseudoVASUB_VX_MF4_MASK, VASUB_VX }, // 462 + { PseudoVASUB_VX_MF8, VASUB_VX }, // 463 + { PseudoVASUB_VX_MF8_MASK, VASUB_VX }, // 464 + { PseudoVBREV8_V_M1, VBREV8_V }, // 465 + { PseudoVBREV8_V_M1_MASK, VBREV8_V }, // 466 + { PseudoVBREV8_V_M2, VBREV8_V }, // 467 + { PseudoVBREV8_V_M2_MASK, VBREV8_V }, // 468 + { PseudoVBREV8_V_M4, VBREV8_V }, // 469 + { PseudoVBREV8_V_M4_MASK, VBREV8_V }, // 470 + { PseudoVBREV8_V_M8, VBREV8_V }, // 471 + { PseudoVBREV8_V_M8_MASK, VBREV8_V }, // 472 + { PseudoVBREV8_V_MF2, VBREV8_V }, // 473 + { PseudoVBREV8_V_MF2_MASK, VBREV8_V }, // 474 + { PseudoVBREV8_V_MF4, VBREV8_V }, // 475 + { PseudoVBREV8_V_MF4_MASK, VBREV8_V }, // 476 + { PseudoVBREV8_V_MF8, VBREV8_V }, // 477 + { PseudoVBREV8_V_MF8_MASK, VBREV8_V }, // 478 + { PseudoVBREV_V_M1, VBREV_V }, // 479 + { PseudoVBREV_V_M1_MASK, VBREV_V }, // 480 + { PseudoVBREV_V_M2, VBREV_V }, // 481 + { PseudoVBREV_V_M2_MASK, VBREV_V }, // 482 + { PseudoVBREV_V_M4, VBREV_V }, // 483 + { PseudoVBREV_V_M4_MASK, VBREV_V }, // 484 + { PseudoVBREV_V_M8, VBREV_V }, // 485 + { PseudoVBREV_V_M8_MASK, VBREV_V }, // 486 + { PseudoVBREV_V_MF2, VBREV_V }, // 487 + { PseudoVBREV_V_MF2_MASK, VBREV_V }, // 488 + { PseudoVBREV_V_MF4, VBREV_V }, // 489 + { PseudoVBREV_V_MF4_MASK, VBREV_V }, // 490 + { PseudoVBREV_V_MF8, VBREV_V }, // 491 + { PseudoVBREV_V_MF8_MASK, VBREV_V }, // 492 + { PseudoVCLMULH_VV_M1, VCLMULH_VV }, // 493 + { PseudoVCLMULH_VV_M1_MASK, VCLMULH_VV }, // 494 + { PseudoVCLMULH_VV_M2, VCLMULH_VV }, // 495 + { PseudoVCLMULH_VV_M2_MASK, VCLMULH_VV }, // 496 + { PseudoVCLMULH_VV_M4, VCLMULH_VV }, // 497 + { PseudoVCLMULH_VV_M4_MASK, VCLMULH_VV }, // 498 + { PseudoVCLMULH_VV_M8, VCLMULH_VV }, // 499 + { PseudoVCLMULH_VV_M8_MASK, VCLMULH_VV }, // 500 + { PseudoVCLMULH_VV_MF2, VCLMULH_VV }, // 501 + { PseudoVCLMULH_VV_MF2_MASK, VCLMULH_VV }, // 502 + { PseudoVCLMULH_VV_MF4, VCLMULH_VV }, // 503 + { PseudoVCLMULH_VV_MF4_MASK, VCLMULH_VV }, // 504 + { PseudoVCLMULH_VV_MF8, VCLMULH_VV }, // 505 + { PseudoVCLMULH_VV_MF8_MASK, VCLMULH_VV }, // 506 + { PseudoVCLMULH_VX_M1, VCLMULH_VX }, // 507 + { PseudoVCLMULH_VX_M1_MASK, VCLMULH_VX }, // 508 + { PseudoVCLMULH_VX_M2, VCLMULH_VX }, // 509 + { PseudoVCLMULH_VX_M2_MASK, VCLMULH_VX }, // 510 + { PseudoVCLMULH_VX_M4, VCLMULH_VX }, // 511 + { PseudoVCLMULH_VX_M4_MASK, VCLMULH_VX }, // 512 + { PseudoVCLMULH_VX_M8, VCLMULH_VX }, // 513 + { PseudoVCLMULH_VX_M8_MASK, VCLMULH_VX }, // 514 + { PseudoVCLMULH_VX_MF2, VCLMULH_VX }, // 515 + { PseudoVCLMULH_VX_MF2_MASK, VCLMULH_VX }, // 516 + { PseudoVCLMULH_VX_MF4, VCLMULH_VX }, // 517 + { PseudoVCLMULH_VX_MF4_MASK, VCLMULH_VX }, // 518 + { PseudoVCLMULH_VX_MF8, VCLMULH_VX }, // 519 + { PseudoVCLMULH_VX_MF8_MASK, VCLMULH_VX }, // 520 + { PseudoVCLMUL_VV_M1, VCLMUL_VV }, // 521 + { PseudoVCLMUL_VV_M1_MASK, VCLMUL_VV }, // 522 + { PseudoVCLMUL_VV_M2, VCLMUL_VV }, // 523 + { PseudoVCLMUL_VV_M2_MASK, VCLMUL_VV }, // 524 + { PseudoVCLMUL_VV_M4, VCLMUL_VV }, // 525 + { PseudoVCLMUL_VV_M4_MASK, VCLMUL_VV }, // 526 + { PseudoVCLMUL_VV_M8, VCLMUL_VV }, // 527 + { PseudoVCLMUL_VV_M8_MASK, VCLMUL_VV }, // 528 + { PseudoVCLMUL_VV_MF2, VCLMUL_VV }, // 529 + { PseudoVCLMUL_VV_MF2_MASK, VCLMUL_VV }, // 530 + { PseudoVCLMUL_VV_MF4, VCLMUL_VV }, // 531 + { PseudoVCLMUL_VV_MF4_MASK, VCLMUL_VV }, // 532 + { PseudoVCLMUL_VV_MF8, VCLMUL_VV }, // 533 + { PseudoVCLMUL_VV_MF8_MASK, VCLMUL_VV }, // 534 + { PseudoVCLMUL_VX_M1, VCLMUL_VX }, // 535 + { PseudoVCLMUL_VX_M1_MASK, VCLMUL_VX }, // 536 + { PseudoVCLMUL_VX_M2, VCLMUL_VX }, // 537 + { PseudoVCLMUL_VX_M2_MASK, VCLMUL_VX }, // 538 + { PseudoVCLMUL_VX_M4, VCLMUL_VX }, // 539 + { PseudoVCLMUL_VX_M4_MASK, VCLMUL_VX }, // 540 + { PseudoVCLMUL_VX_M8, VCLMUL_VX }, // 541 + { PseudoVCLMUL_VX_M8_MASK, VCLMUL_VX }, // 542 + { PseudoVCLMUL_VX_MF2, VCLMUL_VX }, // 543 + { PseudoVCLMUL_VX_MF2_MASK, VCLMUL_VX }, // 544 + { PseudoVCLMUL_VX_MF4, VCLMUL_VX }, // 545 + { PseudoVCLMUL_VX_MF4_MASK, VCLMUL_VX }, // 546 + { PseudoVCLMUL_VX_MF8, VCLMUL_VX }, // 547 + { PseudoVCLMUL_VX_MF8_MASK, VCLMUL_VX }, // 548 + { PseudoVCLZ_V_M1, VCLZ_V }, // 549 + { PseudoVCLZ_V_M1_MASK, VCLZ_V }, // 550 + { PseudoVCLZ_V_M2, VCLZ_V }, // 551 + { PseudoVCLZ_V_M2_MASK, VCLZ_V }, // 552 + { PseudoVCLZ_V_M4, VCLZ_V }, // 553 + { PseudoVCLZ_V_M4_MASK, VCLZ_V }, // 554 + { PseudoVCLZ_V_M8, VCLZ_V }, // 555 + { PseudoVCLZ_V_M8_MASK, VCLZ_V }, // 556 + { PseudoVCLZ_V_MF2, VCLZ_V }, // 557 + { PseudoVCLZ_V_MF2_MASK, VCLZ_V }, // 558 + { PseudoVCLZ_V_MF4, VCLZ_V }, // 559 + { PseudoVCLZ_V_MF4_MASK, VCLZ_V }, // 560 + { PseudoVCLZ_V_MF8, VCLZ_V }, // 561 + { PseudoVCLZ_V_MF8_MASK, VCLZ_V }, // 562 + { PseudoVCOMPRESS_VM_M1_E16, VCOMPRESS_VM }, // 563 + { PseudoVCOMPRESS_VM_M1_E32, VCOMPRESS_VM }, // 564 + { PseudoVCOMPRESS_VM_M1_E64, VCOMPRESS_VM }, // 565 + { PseudoVCOMPRESS_VM_M1_E8, VCOMPRESS_VM }, // 566 + { PseudoVCOMPRESS_VM_M2_E16, VCOMPRESS_VM }, // 567 + { PseudoVCOMPRESS_VM_M2_E32, VCOMPRESS_VM }, // 568 + { PseudoVCOMPRESS_VM_M2_E64, VCOMPRESS_VM }, // 569 + { PseudoVCOMPRESS_VM_M2_E8, VCOMPRESS_VM }, // 570 + { PseudoVCOMPRESS_VM_M4_E16, VCOMPRESS_VM }, // 571 + { PseudoVCOMPRESS_VM_M4_E32, VCOMPRESS_VM }, // 572 + { PseudoVCOMPRESS_VM_M4_E64, VCOMPRESS_VM }, // 573 + { PseudoVCOMPRESS_VM_M4_E8, VCOMPRESS_VM }, // 574 + { PseudoVCOMPRESS_VM_M8_E16, VCOMPRESS_VM }, // 575 + { PseudoVCOMPRESS_VM_M8_E32, VCOMPRESS_VM }, // 576 + { PseudoVCOMPRESS_VM_M8_E64, VCOMPRESS_VM }, // 577 + { PseudoVCOMPRESS_VM_M8_E8, VCOMPRESS_VM }, // 578 + { PseudoVCOMPRESS_VM_MF2_E16, VCOMPRESS_VM }, // 579 + { PseudoVCOMPRESS_VM_MF2_E32, VCOMPRESS_VM }, // 580 + { PseudoVCOMPRESS_VM_MF2_E8, VCOMPRESS_VM }, // 581 + { PseudoVCOMPRESS_VM_MF4_E16, VCOMPRESS_VM }, // 582 + { PseudoVCOMPRESS_VM_MF4_E8, VCOMPRESS_VM }, // 583 + { PseudoVCOMPRESS_VM_MF8_E8, VCOMPRESS_VM }, // 584 + { PseudoVCPOP_M_B1, VCPOP_M }, // 585 + { PseudoVCPOP_M_B16, VCPOP_M }, // 586 + { PseudoVCPOP_M_B16_MASK, VCPOP_M }, // 587 + { PseudoVCPOP_M_B1_MASK, VCPOP_M }, // 588 + { PseudoVCPOP_M_B2, VCPOP_M }, // 589 + { PseudoVCPOP_M_B2_MASK, VCPOP_M }, // 590 + { PseudoVCPOP_M_B32, VCPOP_M }, // 591 + { PseudoVCPOP_M_B32_MASK, VCPOP_M }, // 592 + { PseudoVCPOP_M_B4, VCPOP_M }, // 593 + { PseudoVCPOP_M_B4_MASK, VCPOP_M }, // 594 + { PseudoVCPOP_M_B64, VCPOP_M }, // 595 + { PseudoVCPOP_M_B64_MASK, VCPOP_M }, // 596 + { PseudoVCPOP_M_B8, VCPOP_M }, // 597 + { PseudoVCPOP_M_B8_MASK, VCPOP_M }, // 598 + { PseudoVCPOP_V_M1, VCPOP_V }, // 599 + { PseudoVCPOP_V_M1_MASK, VCPOP_V }, // 600 + { PseudoVCPOP_V_M2, VCPOP_V }, // 601 + { PseudoVCPOP_V_M2_MASK, VCPOP_V }, // 602 + { PseudoVCPOP_V_M4, VCPOP_V }, // 603 + { PseudoVCPOP_V_M4_MASK, VCPOP_V }, // 604 + { PseudoVCPOP_V_M8, VCPOP_V }, // 605 + { PseudoVCPOP_V_M8_MASK, VCPOP_V }, // 606 + { PseudoVCPOP_V_MF2, VCPOP_V }, // 607 + { PseudoVCPOP_V_MF2_MASK, VCPOP_V }, // 608 + { PseudoVCPOP_V_MF4, VCPOP_V }, // 609 + { PseudoVCPOP_V_MF4_MASK, VCPOP_V }, // 610 + { PseudoVCPOP_V_MF8, VCPOP_V }, // 611 + { PseudoVCPOP_V_MF8_MASK, VCPOP_V }, // 612 + { PseudoVCTZ_V_M1, VCTZ_V }, // 613 + { PseudoVCTZ_V_M1_MASK, VCTZ_V }, // 614 + { PseudoVCTZ_V_M2, VCTZ_V }, // 615 + { PseudoVCTZ_V_M2_MASK, VCTZ_V }, // 616 + { PseudoVCTZ_V_M4, VCTZ_V }, // 617 + { PseudoVCTZ_V_M4_MASK, VCTZ_V }, // 618 + { PseudoVCTZ_V_M8, VCTZ_V }, // 619 + { PseudoVCTZ_V_M8_MASK, VCTZ_V }, // 620 + { PseudoVCTZ_V_MF2, VCTZ_V }, // 621 + { PseudoVCTZ_V_MF2_MASK, VCTZ_V }, // 622 + { PseudoVCTZ_V_MF4, VCTZ_V }, // 623 + { PseudoVCTZ_V_MF4_MASK, VCTZ_V }, // 624 + { PseudoVCTZ_V_MF8, VCTZ_V }, // 625 + { PseudoVCTZ_V_MF8_MASK, VCTZ_V }, // 626 + { PseudoVC_FPR16VV_SE_M1, VC_FVV }, // 627 + { PseudoVC_FPR16VV_SE_M2, VC_FVV }, // 628 + { PseudoVC_FPR16VV_SE_M4, VC_FVV }, // 629 + { PseudoVC_FPR16VV_SE_M8, VC_FVV }, // 630 + { PseudoVC_FPR16VV_SE_MF2, VC_FVV }, // 631 + { PseudoVC_FPR16VV_SE_MF4, VC_FVV }, // 632 + { PseudoVC_FPR16VW_SE_M1, VC_FVW }, // 633 + { PseudoVC_FPR16VW_SE_M2, VC_FVW }, // 634 + { PseudoVC_FPR16VW_SE_M4, VC_FVW }, // 635 + { PseudoVC_FPR16VW_SE_M8, VC_FVW }, // 636 + { PseudoVC_FPR16VW_SE_MF2, VC_FVW }, // 637 + { PseudoVC_FPR16VW_SE_MF4, VC_FVW }, // 638 + { PseudoVC_FPR16V_SE_M1, VC_FV }, // 639 + { PseudoVC_FPR16V_SE_M2, VC_FV }, // 640 + { PseudoVC_FPR16V_SE_M4, VC_FV }, // 641 + { PseudoVC_FPR16V_SE_M8, VC_FV }, // 642 + { PseudoVC_FPR16V_SE_MF2, VC_FV }, // 643 + { PseudoVC_FPR16V_SE_MF4, VC_FV }, // 644 + { PseudoVC_FPR32VV_SE_M1, VC_FVV }, // 645 + { PseudoVC_FPR32VV_SE_M2, VC_FVV }, // 646 + { PseudoVC_FPR32VV_SE_M4, VC_FVV }, // 647 + { PseudoVC_FPR32VV_SE_M8, VC_FVV }, // 648 + { PseudoVC_FPR32VV_SE_MF2, VC_FVV }, // 649 + { PseudoVC_FPR32VW_SE_M1, VC_FVW }, // 650 + { PseudoVC_FPR32VW_SE_M2, VC_FVW }, // 651 + { PseudoVC_FPR32VW_SE_M4, VC_FVW }, // 652 + { PseudoVC_FPR32VW_SE_M8, VC_FVW }, // 653 + { PseudoVC_FPR32VW_SE_MF2, VC_FVW }, // 654 + { PseudoVC_FPR32V_SE_M1, VC_FV }, // 655 + { PseudoVC_FPR32V_SE_M2, VC_FV }, // 656 + { PseudoVC_FPR32V_SE_M4, VC_FV }, // 657 + { PseudoVC_FPR32V_SE_M8, VC_FV }, // 658 + { PseudoVC_FPR32V_SE_MF2, VC_FV }, // 659 + { PseudoVC_FPR64VV_SE_M1, VC_FVV }, // 660 + { PseudoVC_FPR64VV_SE_M2, VC_FVV }, // 661 + { PseudoVC_FPR64VV_SE_M4, VC_FVV }, // 662 + { PseudoVC_FPR64VV_SE_M8, VC_FVV }, // 663 + { PseudoVC_FPR64V_SE_M1, VC_FV }, // 664 + { PseudoVC_FPR64V_SE_M2, VC_FV }, // 665 + { PseudoVC_FPR64V_SE_M4, VC_FV }, // 666 + { PseudoVC_FPR64V_SE_M8, VC_FV }, // 667 + { PseudoVC_IVV_SE_M1, VC_IVV }, // 668 + { PseudoVC_IVV_SE_M2, VC_IVV }, // 669 + { PseudoVC_IVV_SE_M4, VC_IVV }, // 670 + { PseudoVC_IVV_SE_M8, VC_IVV }, // 671 + { PseudoVC_IVV_SE_MF2, VC_IVV }, // 672 + { PseudoVC_IVV_SE_MF4, VC_IVV }, // 673 + { PseudoVC_IVV_SE_MF8, VC_IVV }, // 674 + { PseudoVC_IVW_SE_M1, VC_IVW }, // 675 + { PseudoVC_IVW_SE_M2, VC_IVW }, // 676 + { PseudoVC_IVW_SE_M4, VC_IVW }, // 677 + { PseudoVC_IVW_SE_MF2, VC_IVW }, // 678 + { PseudoVC_IVW_SE_MF4, VC_IVW }, // 679 + { PseudoVC_IVW_SE_MF8, VC_IVW }, // 680 + { PseudoVC_IV_SE_M1, VC_IV }, // 681 + { PseudoVC_IV_SE_M2, VC_IV }, // 682 + { PseudoVC_IV_SE_M4, VC_IV }, // 683 + { PseudoVC_IV_SE_M8, VC_IV }, // 684 + { PseudoVC_IV_SE_MF2, VC_IV }, // 685 + { PseudoVC_IV_SE_MF4, VC_IV }, // 686 + { PseudoVC_IV_SE_MF8, VC_IV }, // 687 + { PseudoVC_I_SE_M1, VC_I }, // 688 + { PseudoVC_I_SE_M2, VC_I }, // 689 + { PseudoVC_I_SE_M4, VC_I }, // 690 + { PseudoVC_I_SE_M8, VC_I }, // 691 + { PseudoVC_I_SE_MF2, VC_I }, // 692 + { PseudoVC_I_SE_MF4, VC_I }, // 693 + { PseudoVC_I_SE_MF8, VC_I }, // 694 + { PseudoVC_VVV_SE_M1, VC_VVV }, // 695 + { PseudoVC_VVV_SE_M2, VC_VVV }, // 696 + { PseudoVC_VVV_SE_M4, VC_VVV }, // 697 + { PseudoVC_VVV_SE_M8, VC_VVV }, // 698 + { PseudoVC_VVV_SE_MF2, VC_VVV }, // 699 + { PseudoVC_VVV_SE_MF4, VC_VVV }, // 700 + { PseudoVC_VVV_SE_MF8, VC_VVV }, // 701 + { PseudoVC_VVW_SE_M1, VC_VVW }, // 702 + { PseudoVC_VVW_SE_M2, VC_VVW }, // 703 + { PseudoVC_VVW_SE_M4, VC_VVW }, // 704 + { PseudoVC_VVW_SE_MF2, VC_VVW }, // 705 + { PseudoVC_VVW_SE_MF4, VC_VVW }, // 706 + { PseudoVC_VVW_SE_MF8, VC_VVW }, // 707 + { PseudoVC_VV_SE_M1, VC_VV }, // 708 + { PseudoVC_VV_SE_M2, VC_VV }, // 709 + { PseudoVC_VV_SE_M4, VC_VV }, // 710 + { PseudoVC_VV_SE_M8, VC_VV }, // 711 + { PseudoVC_VV_SE_MF2, VC_VV }, // 712 + { PseudoVC_VV_SE_MF4, VC_VV }, // 713 + { PseudoVC_VV_SE_MF8, VC_VV }, // 714 + { PseudoVC_V_FPR16VV_M1, VC_V_FVV }, // 715 + { PseudoVC_V_FPR16VV_M2, VC_V_FVV }, // 716 + { PseudoVC_V_FPR16VV_M4, VC_V_FVV }, // 717 + { PseudoVC_V_FPR16VV_M8, VC_V_FVV }, // 718 + { PseudoVC_V_FPR16VV_MF2, VC_V_FVV }, // 719 + { PseudoVC_V_FPR16VV_MF4, VC_V_FVV }, // 720 + { PseudoVC_V_FPR16VV_SE_M1, VC_V_FVV }, // 721 + { PseudoVC_V_FPR16VV_SE_M2, VC_V_FVV }, // 722 + { PseudoVC_V_FPR16VV_SE_M4, VC_V_FVV }, // 723 + { PseudoVC_V_FPR16VV_SE_M8, VC_V_FVV }, // 724 + { PseudoVC_V_FPR16VV_SE_MF2, VC_V_FVV }, // 725 + { PseudoVC_V_FPR16VV_SE_MF4, VC_V_FVV }, // 726 + { PseudoVC_V_FPR16VW_M1, VC_V_FVW }, // 727 + { PseudoVC_V_FPR16VW_M2, VC_V_FVW }, // 728 + { PseudoVC_V_FPR16VW_M4, VC_V_FVW }, // 729 + { PseudoVC_V_FPR16VW_M8, VC_V_FVW }, // 730 + { PseudoVC_V_FPR16VW_MF2, VC_V_FVW }, // 731 + { PseudoVC_V_FPR16VW_MF4, VC_V_FVW }, // 732 + { PseudoVC_V_FPR16VW_SE_M1, VC_V_FVW }, // 733 + { PseudoVC_V_FPR16VW_SE_M2, VC_V_FVW }, // 734 + { PseudoVC_V_FPR16VW_SE_M4, VC_V_FVW }, // 735 + { PseudoVC_V_FPR16VW_SE_M8, VC_V_FVW }, // 736 + { PseudoVC_V_FPR16VW_SE_MF2, VC_V_FVW }, // 737 + { PseudoVC_V_FPR16VW_SE_MF4, VC_V_FVW }, // 738 + { PseudoVC_V_FPR16V_M1, VC_V_FV }, // 739 + { PseudoVC_V_FPR16V_M2, VC_V_FV }, // 740 + { PseudoVC_V_FPR16V_M4, VC_V_FV }, // 741 + { PseudoVC_V_FPR16V_M8, VC_V_FV }, // 742 + { PseudoVC_V_FPR16V_MF2, VC_V_FV }, // 743 + { PseudoVC_V_FPR16V_MF4, VC_V_FV }, // 744 + { PseudoVC_V_FPR16V_SE_M1, VC_V_FV }, // 745 + { PseudoVC_V_FPR16V_SE_M2, VC_V_FV }, // 746 + { PseudoVC_V_FPR16V_SE_M4, VC_V_FV }, // 747 + { PseudoVC_V_FPR16V_SE_M8, VC_V_FV }, // 748 + { PseudoVC_V_FPR16V_SE_MF2, VC_V_FV }, // 749 + { PseudoVC_V_FPR16V_SE_MF4, VC_V_FV }, // 750 + { PseudoVC_V_FPR32VV_M1, VC_V_FVV }, // 751 + { PseudoVC_V_FPR32VV_M2, VC_V_FVV }, // 752 + { PseudoVC_V_FPR32VV_M4, VC_V_FVV }, // 753 + { PseudoVC_V_FPR32VV_M8, VC_V_FVV }, // 754 + { PseudoVC_V_FPR32VV_MF2, VC_V_FVV }, // 755 + { PseudoVC_V_FPR32VV_SE_M1, VC_V_FVV }, // 756 + { PseudoVC_V_FPR32VV_SE_M2, VC_V_FVV }, // 757 + { PseudoVC_V_FPR32VV_SE_M4, VC_V_FVV }, // 758 + { PseudoVC_V_FPR32VV_SE_M8, VC_V_FVV }, // 759 + { PseudoVC_V_FPR32VV_SE_MF2, VC_V_FVV }, // 760 + { PseudoVC_V_FPR32VW_M1, VC_V_FVW }, // 761 + { PseudoVC_V_FPR32VW_M2, VC_V_FVW }, // 762 + { PseudoVC_V_FPR32VW_M4, VC_V_FVW }, // 763 + { PseudoVC_V_FPR32VW_M8, VC_V_FVW }, // 764 + { PseudoVC_V_FPR32VW_MF2, VC_V_FVW }, // 765 + { PseudoVC_V_FPR32VW_SE_M1, VC_V_FVW }, // 766 + { PseudoVC_V_FPR32VW_SE_M2, VC_V_FVW }, // 767 + { PseudoVC_V_FPR32VW_SE_M4, VC_V_FVW }, // 768 + { PseudoVC_V_FPR32VW_SE_M8, VC_V_FVW }, // 769 + { PseudoVC_V_FPR32VW_SE_MF2, VC_V_FVW }, // 770 + { PseudoVC_V_FPR32V_M1, VC_V_FV }, // 771 + { PseudoVC_V_FPR32V_M2, VC_V_FV }, // 772 + { PseudoVC_V_FPR32V_M4, VC_V_FV }, // 773 + { PseudoVC_V_FPR32V_M8, VC_V_FV }, // 774 + { PseudoVC_V_FPR32V_MF2, VC_V_FV }, // 775 + { PseudoVC_V_FPR32V_SE_M1, VC_V_FV }, // 776 + { PseudoVC_V_FPR32V_SE_M2, VC_V_FV }, // 777 + { PseudoVC_V_FPR32V_SE_M4, VC_V_FV }, // 778 + { PseudoVC_V_FPR32V_SE_M8, VC_V_FV }, // 779 + { PseudoVC_V_FPR32V_SE_MF2, VC_V_FV }, // 780 + { PseudoVC_V_FPR64VV_M1, VC_V_FVV }, // 781 + { PseudoVC_V_FPR64VV_M2, VC_V_FVV }, // 782 + { PseudoVC_V_FPR64VV_M4, VC_V_FVV }, // 783 + { PseudoVC_V_FPR64VV_M8, VC_V_FVV }, // 784 + { PseudoVC_V_FPR64VV_SE_M1, VC_V_FVV }, // 785 + { PseudoVC_V_FPR64VV_SE_M2, VC_V_FVV }, // 786 + { PseudoVC_V_FPR64VV_SE_M4, VC_V_FVV }, // 787 + { PseudoVC_V_FPR64VV_SE_M8, VC_V_FVV }, // 788 + { PseudoVC_V_FPR64V_M1, VC_V_FV }, // 789 + { PseudoVC_V_FPR64V_M2, VC_V_FV }, // 790 + { PseudoVC_V_FPR64V_M4, VC_V_FV }, // 791 + { PseudoVC_V_FPR64V_M8, VC_V_FV }, // 792 + { PseudoVC_V_FPR64V_SE_M1, VC_V_FV }, // 793 + { PseudoVC_V_FPR64V_SE_M2, VC_V_FV }, // 794 + { PseudoVC_V_FPR64V_SE_M4, VC_V_FV }, // 795 + { PseudoVC_V_FPR64V_SE_M8, VC_V_FV }, // 796 + { PseudoVC_V_IVV_M1, VC_V_IVV }, // 797 + { PseudoVC_V_IVV_M2, VC_V_IVV }, // 798 + { PseudoVC_V_IVV_M4, VC_V_IVV }, // 799 + { PseudoVC_V_IVV_M8, VC_V_IVV }, // 800 + { PseudoVC_V_IVV_MF2, VC_V_IVV }, // 801 + { PseudoVC_V_IVV_MF4, VC_V_IVV }, // 802 + { PseudoVC_V_IVV_MF8, VC_V_IVV }, // 803 + { PseudoVC_V_IVV_SE_M1, VC_V_IVV }, // 804 + { PseudoVC_V_IVV_SE_M2, VC_V_IVV }, // 805 + { PseudoVC_V_IVV_SE_M4, VC_V_IVV }, // 806 + { PseudoVC_V_IVV_SE_M8, VC_V_IVV }, // 807 + { PseudoVC_V_IVV_SE_MF2, VC_V_IVV }, // 808 + { PseudoVC_V_IVV_SE_MF4, VC_V_IVV }, // 809 + { PseudoVC_V_IVV_SE_MF8, VC_V_IVV }, // 810 + { PseudoVC_V_IVW_M1, VC_V_IVW }, // 811 + { PseudoVC_V_IVW_M2, VC_V_IVW }, // 812 + { PseudoVC_V_IVW_M4, VC_V_IVW }, // 813 + { PseudoVC_V_IVW_MF2, VC_V_IVW }, // 814 + { PseudoVC_V_IVW_MF4, VC_V_IVW }, // 815 + { PseudoVC_V_IVW_MF8, VC_V_IVW }, // 816 + { PseudoVC_V_IVW_SE_M1, VC_V_IVW }, // 817 + { PseudoVC_V_IVW_SE_M2, VC_V_IVW }, // 818 + { PseudoVC_V_IVW_SE_M4, VC_V_IVW }, // 819 + { PseudoVC_V_IVW_SE_MF2, VC_V_IVW }, // 820 + { PseudoVC_V_IVW_SE_MF4, VC_V_IVW }, // 821 + { PseudoVC_V_IVW_SE_MF8, VC_V_IVW }, // 822 + { PseudoVC_V_IV_M1, VC_V_IV }, // 823 + { PseudoVC_V_IV_M2, VC_V_IV }, // 824 + { PseudoVC_V_IV_M4, VC_V_IV }, // 825 + { PseudoVC_V_IV_M8, VC_V_IV }, // 826 + { PseudoVC_V_IV_MF2, VC_V_IV }, // 827 + { PseudoVC_V_IV_MF4, VC_V_IV }, // 828 + { PseudoVC_V_IV_MF8, VC_V_IV }, // 829 + { PseudoVC_V_IV_SE_M1, VC_V_IV }, // 830 + { PseudoVC_V_IV_SE_M2, VC_V_IV }, // 831 + { PseudoVC_V_IV_SE_M4, VC_V_IV }, // 832 + { PseudoVC_V_IV_SE_M8, VC_V_IV }, // 833 + { PseudoVC_V_IV_SE_MF2, VC_V_IV }, // 834 + { PseudoVC_V_IV_SE_MF4, VC_V_IV }, // 835 + { PseudoVC_V_IV_SE_MF8, VC_V_IV }, // 836 + { PseudoVC_V_I_M1, VC_V_I }, // 837 + { PseudoVC_V_I_M2, VC_V_I }, // 838 + { PseudoVC_V_I_M4, VC_V_I }, // 839 + { PseudoVC_V_I_M8, VC_V_I }, // 840 + { PseudoVC_V_I_MF2, VC_V_I }, // 841 + { PseudoVC_V_I_MF4, VC_V_I }, // 842 + { PseudoVC_V_I_MF8, VC_V_I }, // 843 + { PseudoVC_V_I_SE_M1, VC_V_I }, // 844 + { PseudoVC_V_I_SE_M2, VC_V_I }, // 845 + { PseudoVC_V_I_SE_M4, VC_V_I }, // 846 + { PseudoVC_V_I_SE_M8, VC_V_I }, // 847 + { PseudoVC_V_I_SE_MF2, VC_V_I }, // 848 + { PseudoVC_V_I_SE_MF4, VC_V_I }, // 849 + { PseudoVC_V_I_SE_MF8, VC_V_I }, // 850 + { PseudoVC_V_VVV_M1, VC_V_VVV }, // 851 + { PseudoVC_V_VVV_M2, VC_V_VVV }, // 852 + { PseudoVC_V_VVV_M4, VC_V_VVV }, // 853 + { PseudoVC_V_VVV_M8, VC_V_VVV }, // 854 + { PseudoVC_V_VVV_MF2, VC_V_VVV }, // 855 + { PseudoVC_V_VVV_MF4, VC_V_VVV }, // 856 + { PseudoVC_V_VVV_MF8, VC_V_VVV }, // 857 + { PseudoVC_V_VVV_SE_M1, VC_V_VVV }, // 858 + { PseudoVC_V_VVV_SE_M2, VC_V_VVV }, // 859 + { PseudoVC_V_VVV_SE_M4, VC_V_VVV }, // 860 + { PseudoVC_V_VVV_SE_M8, VC_V_VVV }, // 861 + { PseudoVC_V_VVV_SE_MF2, VC_V_VVV }, // 862 + { PseudoVC_V_VVV_SE_MF4, VC_V_VVV }, // 863 + { PseudoVC_V_VVV_SE_MF8, VC_V_VVV }, // 864 + { PseudoVC_V_VVW_M1, VC_V_VVW }, // 865 + { PseudoVC_V_VVW_M2, VC_V_VVW }, // 866 + { PseudoVC_V_VVW_M4, VC_V_VVW }, // 867 + { PseudoVC_V_VVW_MF2, VC_V_VVW }, // 868 + { PseudoVC_V_VVW_MF4, VC_V_VVW }, // 869 + { PseudoVC_V_VVW_MF8, VC_V_VVW }, // 870 + { PseudoVC_V_VVW_SE_M1, VC_V_VVW }, // 871 + { PseudoVC_V_VVW_SE_M2, VC_V_VVW }, // 872 + { PseudoVC_V_VVW_SE_M4, VC_V_VVW }, // 873 + { PseudoVC_V_VVW_SE_MF2, VC_V_VVW }, // 874 + { PseudoVC_V_VVW_SE_MF4, VC_V_VVW }, // 875 + { PseudoVC_V_VVW_SE_MF8, VC_V_VVW }, // 876 + { PseudoVC_V_VV_M1, VC_V_VV }, // 877 + { PseudoVC_V_VV_M2, VC_V_VV }, // 878 + { PseudoVC_V_VV_M4, VC_V_VV }, // 879 + { PseudoVC_V_VV_M8, VC_V_VV }, // 880 + { PseudoVC_V_VV_MF2, VC_V_VV }, // 881 + { PseudoVC_V_VV_MF4, VC_V_VV }, // 882 + { PseudoVC_V_VV_MF8, VC_V_VV }, // 883 + { PseudoVC_V_VV_SE_M1, VC_V_VV }, // 884 + { PseudoVC_V_VV_SE_M2, VC_V_VV }, // 885 + { PseudoVC_V_VV_SE_M4, VC_V_VV }, // 886 + { PseudoVC_V_VV_SE_M8, VC_V_VV }, // 887 + { PseudoVC_V_VV_SE_MF2, VC_V_VV }, // 888 + { PseudoVC_V_VV_SE_MF4, VC_V_VV }, // 889 + { PseudoVC_V_VV_SE_MF8, VC_V_VV }, // 890 + { PseudoVC_V_XVV_M1, VC_V_XVV }, // 891 + { PseudoVC_V_XVV_M2, VC_V_XVV }, // 892 + { PseudoVC_V_XVV_M4, VC_V_XVV }, // 893 + { PseudoVC_V_XVV_M8, VC_V_XVV }, // 894 + { PseudoVC_V_XVV_MF2, VC_V_XVV }, // 895 + { PseudoVC_V_XVV_MF4, VC_V_XVV }, // 896 + { PseudoVC_V_XVV_MF8, VC_V_XVV }, // 897 + { PseudoVC_V_XVV_SE_M1, VC_V_XVV }, // 898 + { PseudoVC_V_XVV_SE_M2, VC_V_XVV }, // 899 + { PseudoVC_V_XVV_SE_M4, VC_V_XVV }, // 900 + { PseudoVC_V_XVV_SE_M8, VC_V_XVV }, // 901 + { PseudoVC_V_XVV_SE_MF2, VC_V_XVV }, // 902 + { PseudoVC_V_XVV_SE_MF4, VC_V_XVV }, // 903 + { PseudoVC_V_XVV_SE_MF8, VC_V_XVV }, // 904 + { PseudoVC_V_XVW_M1, VC_V_XVW }, // 905 + { PseudoVC_V_XVW_M2, VC_V_XVW }, // 906 + { PseudoVC_V_XVW_M4, VC_V_XVW }, // 907 + { PseudoVC_V_XVW_MF2, VC_V_XVW }, // 908 + { PseudoVC_V_XVW_MF4, VC_V_XVW }, // 909 + { PseudoVC_V_XVW_MF8, VC_V_XVW }, // 910 + { PseudoVC_V_XVW_SE_M1, VC_V_XVW }, // 911 + { PseudoVC_V_XVW_SE_M2, VC_V_XVW }, // 912 + { PseudoVC_V_XVW_SE_M4, VC_V_XVW }, // 913 + { PseudoVC_V_XVW_SE_MF2, VC_V_XVW }, // 914 + { PseudoVC_V_XVW_SE_MF4, VC_V_XVW }, // 915 + { PseudoVC_V_XVW_SE_MF8, VC_V_XVW }, // 916 + { PseudoVC_V_XV_M1, VC_V_XV }, // 917 + { PseudoVC_V_XV_M2, VC_V_XV }, // 918 + { PseudoVC_V_XV_M4, VC_V_XV }, // 919 + { PseudoVC_V_XV_M8, VC_V_XV }, // 920 + { PseudoVC_V_XV_MF2, VC_V_XV }, // 921 + { PseudoVC_V_XV_MF4, VC_V_XV }, // 922 + { PseudoVC_V_XV_MF8, VC_V_XV }, // 923 + { PseudoVC_V_XV_SE_M1, VC_V_XV }, // 924 + { PseudoVC_V_XV_SE_M2, VC_V_XV }, // 925 + { PseudoVC_V_XV_SE_M4, VC_V_XV }, // 926 + { PseudoVC_V_XV_SE_M8, VC_V_XV }, // 927 + { PseudoVC_V_XV_SE_MF2, VC_V_XV }, // 928 + { PseudoVC_V_XV_SE_MF4, VC_V_XV }, // 929 + { PseudoVC_V_XV_SE_MF8, VC_V_XV }, // 930 + { PseudoVC_V_X_M1, VC_V_X }, // 931 + { PseudoVC_V_X_M2, VC_V_X }, // 932 + { PseudoVC_V_X_M4, VC_V_X }, // 933 + { PseudoVC_V_X_M8, VC_V_X }, // 934 + { PseudoVC_V_X_MF2, VC_V_X }, // 935 + { PseudoVC_V_X_MF4, VC_V_X }, // 936 + { PseudoVC_V_X_MF8, VC_V_X }, // 937 + { PseudoVC_V_X_SE_M1, VC_V_X }, // 938 + { PseudoVC_V_X_SE_M2, VC_V_X }, // 939 + { PseudoVC_V_X_SE_M4, VC_V_X }, // 940 + { PseudoVC_V_X_SE_M8, VC_V_X }, // 941 + { PseudoVC_V_X_SE_MF2, VC_V_X }, // 942 + { PseudoVC_V_X_SE_MF4, VC_V_X }, // 943 + { PseudoVC_V_X_SE_MF8, VC_V_X }, // 944 + { PseudoVC_XVV_SE_M1, VC_XVV }, // 945 + { PseudoVC_XVV_SE_M2, VC_XVV }, // 946 + { PseudoVC_XVV_SE_M4, VC_XVV }, // 947 + { PseudoVC_XVV_SE_M8, VC_XVV }, // 948 + { PseudoVC_XVV_SE_MF2, VC_XVV }, // 949 + { PseudoVC_XVV_SE_MF4, VC_XVV }, // 950 + { PseudoVC_XVV_SE_MF8, VC_XVV }, // 951 + { PseudoVC_XVW_SE_M1, VC_XVW }, // 952 + { PseudoVC_XVW_SE_M2, VC_XVW }, // 953 + { PseudoVC_XVW_SE_M4, VC_XVW }, // 954 + { PseudoVC_XVW_SE_MF2, VC_XVW }, // 955 + { PseudoVC_XVW_SE_MF4, VC_XVW }, // 956 + { PseudoVC_XVW_SE_MF8, VC_XVW }, // 957 + { PseudoVC_XV_SE_M1, VC_XV }, // 958 + { PseudoVC_XV_SE_M2, VC_XV }, // 959 + { PseudoVC_XV_SE_M4, VC_XV }, // 960 + { PseudoVC_XV_SE_M8, VC_XV }, // 961 + { PseudoVC_XV_SE_MF2, VC_XV }, // 962 + { PseudoVC_XV_SE_MF4, VC_XV }, // 963 + { PseudoVC_XV_SE_MF8, VC_XV }, // 964 + { PseudoVC_X_SE_M1, VC_X }, // 965 + { PseudoVC_X_SE_M2, VC_X }, // 966 + { PseudoVC_X_SE_M4, VC_X }, // 967 + { PseudoVC_X_SE_M8, VC_X }, // 968 + { PseudoVC_X_SE_MF2, VC_X }, // 969 + { PseudoVC_X_SE_MF4, VC_X }, // 970 + { PseudoVC_X_SE_MF8, VC_X }, // 971 + { PseudoVDIVU_VV_M1_E16, VDIVU_VV }, // 972 + { PseudoVDIVU_VV_M1_E16_MASK, VDIVU_VV }, // 973 + { PseudoVDIVU_VV_M1_E32, VDIVU_VV }, // 974 + { PseudoVDIVU_VV_M1_E32_MASK, VDIVU_VV }, // 975 + { PseudoVDIVU_VV_M1_E64, VDIVU_VV }, // 976 + { PseudoVDIVU_VV_M1_E64_MASK, VDIVU_VV }, // 977 + { PseudoVDIVU_VV_M1_E8, VDIVU_VV }, // 978 + { PseudoVDIVU_VV_M1_E8_MASK, VDIVU_VV }, // 979 + { PseudoVDIVU_VV_M2_E16, VDIVU_VV }, // 980 + { PseudoVDIVU_VV_M2_E16_MASK, VDIVU_VV }, // 981 + { PseudoVDIVU_VV_M2_E32, VDIVU_VV }, // 982 + { PseudoVDIVU_VV_M2_E32_MASK, VDIVU_VV }, // 983 + { PseudoVDIVU_VV_M2_E64, VDIVU_VV }, // 984 + { PseudoVDIVU_VV_M2_E64_MASK, VDIVU_VV }, // 985 + { PseudoVDIVU_VV_M2_E8, VDIVU_VV }, // 986 + { PseudoVDIVU_VV_M2_E8_MASK, VDIVU_VV }, // 987 + { PseudoVDIVU_VV_M4_E16, VDIVU_VV }, // 988 + { PseudoVDIVU_VV_M4_E16_MASK, VDIVU_VV }, // 989 + { PseudoVDIVU_VV_M4_E32, VDIVU_VV }, // 990 + { PseudoVDIVU_VV_M4_E32_MASK, VDIVU_VV }, // 991 + { PseudoVDIVU_VV_M4_E64, VDIVU_VV }, // 992 + { PseudoVDIVU_VV_M4_E64_MASK, VDIVU_VV }, // 993 + { PseudoVDIVU_VV_M4_E8, VDIVU_VV }, // 994 + { PseudoVDIVU_VV_M4_E8_MASK, VDIVU_VV }, // 995 + { PseudoVDIVU_VV_M8_E16, VDIVU_VV }, // 996 + { PseudoVDIVU_VV_M8_E16_MASK, VDIVU_VV }, // 997 + { PseudoVDIVU_VV_M8_E32, VDIVU_VV }, // 998 + { PseudoVDIVU_VV_M8_E32_MASK, VDIVU_VV }, // 999 + { PseudoVDIVU_VV_M8_E64, VDIVU_VV }, // 1000 + { PseudoVDIVU_VV_M8_E64_MASK, VDIVU_VV }, // 1001 + { PseudoVDIVU_VV_M8_E8, VDIVU_VV }, // 1002 + { PseudoVDIVU_VV_M8_E8_MASK, VDIVU_VV }, // 1003 + { PseudoVDIVU_VV_MF2_E16, VDIVU_VV }, // 1004 + { PseudoVDIVU_VV_MF2_E16_MASK, VDIVU_VV }, // 1005 + { PseudoVDIVU_VV_MF2_E32, VDIVU_VV }, // 1006 + { PseudoVDIVU_VV_MF2_E32_MASK, VDIVU_VV }, // 1007 + { PseudoVDIVU_VV_MF2_E8, VDIVU_VV }, // 1008 + { PseudoVDIVU_VV_MF2_E8_MASK, VDIVU_VV }, // 1009 + { PseudoVDIVU_VV_MF4_E16, VDIVU_VV }, // 1010 + { PseudoVDIVU_VV_MF4_E16_MASK, VDIVU_VV }, // 1011 + { PseudoVDIVU_VV_MF4_E8, VDIVU_VV }, // 1012 + { PseudoVDIVU_VV_MF4_E8_MASK, VDIVU_VV }, // 1013 + { PseudoVDIVU_VV_MF8_E8, VDIVU_VV }, // 1014 + { PseudoVDIVU_VV_MF8_E8_MASK, VDIVU_VV }, // 1015 + { PseudoVDIVU_VX_M1_E16, VDIVU_VX }, // 1016 + { PseudoVDIVU_VX_M1_E16_MASK, VDIVU_VX }, // 1017 + { PseudoVDIVU_VX_M1_E32, VDIVU_VX }, // 1018 + { PseudoVDIVU_VX_M1_E32_MASK, VDIVU_VX }, // 1019 + { PseudoVDIVU_VX_M1_E64, VDIVU_VX }, // 1020 + { PseudoVDIVU_VX_M1_E64_MASK, VDIVU_VX }, // 1021 + { PseudoVDIVU_VX_M1_E8, VDIVU_VX }, // 1022 + { PseudoVDIVU_VX_M1_E8_MASK, VDIVU_VX }, // 1023 + { PseudoVDIVU_VX_M2_E16, VDIVU_VX }, // 1024 + { PseudoVDIVU_VX_M2_E16_MASK, VDIVU_VX }, // 1025 + { PseudoVDIVU_VX_M2_E32, VDIVU_VX }, // 1026 + { PseudoVDIVU_VX_M2_E32_MASK, VDIVU_VX }, // 1027 + { PseudoVDIVU_VX_M2_E64, VDIVU_VX }, // 1028 + { PseudoVDIVU_VX_M2_E64_MASK, VDIVU_VX }, // 1029 + { PseudoVDIVU_VX_M2_E8, VDIVU_VX }, // 1030 + { PseudoVDIVU_VX_M2_E8_MASK, VDIVU_VX }, // 1031 + { PseudoVDIVU_VX_M4_E16, VDIVU_VX }, // 1032 + { PseudoVDIVU_VX_M4_E16_MASK, VDIVU_VX }, // 1033 + { PseudoVDIVU_VX_M4_E32, VDIVU_VX }, // 1034 + { PseudoVDIVU_VX_M4_E32_MASK, VDIVU_VX }, // 1035 + { PseudoVDIVU_VX_M4_E64, VDIVU_VX }, // 1036 + { PseudoVDIVU_VX_M4_E64_MASK, VDIVU_VX }, // 1037 + { PseudoVDIVU_VX_M4_E8, VDIVU_VX }, // 1038 + { PseudoVDIVU_VX_M4_E8_MASK, VDIVU_VX }, // 1039 + { PseudoVDIVU_VX_M8_E16, VDIVU_VX }, // 1040 + { PseudoVDIVU_VX_M8_E16_MASK, VDIVU_VX }, // 1041 + { PseudoVDIVU_VX_M8_E32, VDIVU_VX }, // 1042 + { PseudoVDIVU_VX_M8_E32_MASK, VDIVU_VX }, // 1043 + { PseudoVDIVU_VX_M8_E64, VDIVU_VX }, // 1044 + { PseudoVDIVU_VX_M8_E64_MASK, VDIVU_VX }, // 1045 + { PseudoVDIVU_VX_M8_E8, VDIVU_VX }, // 1046 + { PseudoVDIVU_VX_M8_E8_MASK, VDIVU_VX }, // 1047 + { PseudoVDIVU_VX_MF2_E16, VDIVU_VX }, // 1048 + { PseudoVDIVU_VX_MF2_E16_MASK, VDIVU_VX }, // 1049 + { PseudoVDIVU_VX_MF2_E32, VDIVU_VX }, // 1050 + { PseudoVDIVU_VX_MF2_E32_MASK, VDIVU_VX }, // 1051 + { PseudoVDIVU_VX_MF2_E8, VDIVU_VX }, // 1052 + { PseudoVDIVU_VX_MF2_E8_MASK, VDIVU_VX }, // 1053 + { PseudoVDIVU_VX_MF4_E16, VDIVU_VX }, // 1054 + { PseudoVDIVU_VX_MF4_E16_MASK, VDIVU_VX }, // 1055 + { PseudoVDIVU_VX_MF4_E8, VDIVU_VX }, // 1056 + { PseudoVDIVU_VX_MF4_E8_MASK, VDIVU_VX }, // 1057 + { PseudoVDIVU_VX_MF8_E8, VDIVU_VX }, // 1058 + { PseudoVDIVU_VX_MF8_E8_MASK, VDIVU_VX }, // 1059 + { PseudoVDIV_VV_M1_E16, VDIV_VV }, // 1060 + { PseudoVDIV_VV_M1_E16_MASK, VDIV_VV }, // 1061 + { PseudoVDIV_VV_M1_E32, VDIV_VV }, // 1062 + { PseudoVDIV_VV_M1_E32_MASK, VDIV_VV }, // 1063 + { PseudoVDIV_VV_M1_E64, VDIV_VV }, // 1064 + { PseudoVDIV_VV_M1_E64_MASK, VDIV_VV }, // 1065 + { PseudoVDIV_VV_M1_E8, VDIV_VV }, // 1066 + { PseudoVDIV_VV_M1_E8_MASK, VDIV_VV }, // 1067 + { PseudoVDIV_VV_M2_E16, VDIV_VV }, // 1068 + { PseudoVDIV_VV_M2_E16_MASK, VDIV_VV }, // 1069 + { PseudoVDIV_VV_M2_E32, VDIV_VV }, // 1070 + { PseudoVDIV_VV_M2_E32_MASK, VDIV_VV }, // 1071 + { PseudoVDIV_VV_M2_E64, VDIV_VV }, // 1072 + { PseudoVDIV_VV_M2_E64_MASK, VDIV_VV }, // 1073 + { PseudoVDIV_VV_M2_E8, VDIV_VV }, // 1074 + { PseudoVDIV_VV_M2_E8_MASK, VDIV_VV }, // 1075 + { PseudoVDIV_VV_M4_E16, VDIV_VV }, // 1076 + { PseudoVDIV_VV_M4_E16_MASK, VDIV_VV }, // 1077 + { PseudoVDIV_VV_M4_E32, VDIV_VV }, // 1078 + { PseudoVDIV_VV_M4_E32_MASK, VDIV_VV }, // 1079 + { PseudoVDIV_VV_M4_E64, VDIV_VV }, // 1080 + { PseudoVDIV_VV_M4_E64_MASK, VDIV_VV }, // 1081 + { PseudoVDIV_VV_M4_E8, VDIV_VV }, // 1082 + { PseudoVDIV_VV_M4_E8_MASK, VDIV_VV }, // 1083 + { PseudoVDIV_VV_M8_E16, VDIV_VV }, // 1084 + { PseudoVDIV_VV_M8_E16_MASK, VDIV_VV }, // 1085 + { PseudoVDIV_VV_M8_E32, VDIV_VV }, // 1086 + { PseudoVDIV_VV_M8_E32_MASK, VDIV_VV }, // 1087 + { PseudoVDIV_VV_M8_E64, VDIV_VV }, // 1088 + { PseudoVDIV_VV_M8_E64_MASK, VDIV_VV }, // 1089 + { PseudoVDIV_VV_M8_E8, VDIV_VV }, // 1090 + { PseudoVDIV_VV_M8_E8_MASK, VDIV_VV }, // 1091 + { PseudoVDIV_VV_MF2_E16, VDIV_VV }, // 1092 + { PseudoVDIV_VV_MF2_E16_MASK, VDIV_VV }, // 1093 + { PseudoVDIV_VV_MF2_E32, VDIV_VV }, // 1094 + { PseudoVDIV_VV_MF2_E32_MASK, VDIV_VV }, // 1095 + { PseudoVDIV_VV_MF2_E8, VDIV_VV }, // 1096 + { PseudoVDIV_VV_MF2_E8_MASK, VDIV_VV }, // 1097 + { PseudoVDIV_VV_MF4_E16, VDIV_VV }, // 1098 + { PseudoVDIV_VV_MF4_E16_MASK, VDIV_VV }, // 1099 + { PseudoVDIV_VV_MF4_E8, VDIV_VV }, // 1100 + { PseudoVDIV_VV_MF4_E8_MASK, VDIV_VV }, // 1101 + { PseudoVDIV_VV_MF8_E8, VDIV_VV }, // 1102 + { PseudoVDIV_VV_MF8_E8_MASK, VDIV_VV }, // 1103 + { PseudoVDIV_VX_M1_E16, VDIV_VX }, // 1104 + { PseudoVDIV_VX_M1_E16_MASK, VDIV_VX }, // 1105 + { PseudoVDIV_VX_M1_E32, VDIV_VX }, // 1106 + { PseudoVDIV_VX_M1_E32_MASK, VDIV_VX }, // 1107 + { PseudoVDIV_VX_M1_E64, VDIV_VX }, // 1108 + { PseudoVDIV_VX_M1_E64_MASK, VDIV_VX }, // 1109 + { PseudoVDIV_VX_M1_E8, VDIV_VX }, // 1110 + { PseudoVDIV_VX_M1_E8_MASK, VDIV_VX }, // 1111 + { PseudoVDIV_VX_M2_E16, VDIV_VX }, // 1112 + { PseudoVDIV_VX_M2_E16_MASK, VDIV_VX }, // 1113 + { PseudoVDIV_VX_M2_E32, VDIV_VX }, // 1114 + { PseudoVDIV_VX_M2_E32_MASK, VDIV_VX }, // 1115 + { PseudoVDIV_VX_M2_E64, VDIV_VX }, // 1116 + { PseudoVDIV_VX_M2_E64_MASK, VDIV_VX }, // 1117 + { PseudoVDIV_VX_M2_E8, VDIV_VX }, // 1118 + { PseudoVDIV_VX_M2_E8_MASK, VDIV_VX }, // 1119 + { PseudoVDIV_VX_M4_E16, VDIV_VX }, // 1120 + { PseudoVDIV_VX_M4_E16_MASK, VDIV_VX }, // 1121 + { PseudoVDIV_VX_M4_E32, VDIV_VX }, // 1122 + { PseudoVDIV_VX_M4_E32_MASK, VDIV_VX }, // 1123 + { PseudoVDIV_VX_M4_E64, VDIV_VX }, // 1124 + { PseudoVDIV_VX_M4_E64_MASK, VDIV_VX }, // 1125 + { PseudoVDIV_VX_M4_E8, VDIV_VX }, // 1126 + { PseudoVDIV_VX_M4_E8_MASK, VDIV_VX }, // 1127 + { PseudoVDIV_VX_M8_E16, VDIV_VX }, // 1128 + { PseudoVDIV_VX_M8_E16_MASK, VDIV_VX }, // 1129 + { PseudoVDIV_VX_M8_E32, VDIV_VX }, // 1130 + { PseudoVDIV_VX_M8_E32_MASK, VDIV_VX }, // 1131 + { PseudoVDIV_VX_M8_E64, VDIV_VX }, // 1132 + { PseudoVDIV_VX_M8_E64_MASK, VDIV_VX }, // 1133 + { PseudoVDIV_VX_M8_E8, VDIV_VX }, // 1134 + { PseudoVDIV_VX_M8_E8_MASK, VDIV_VX }, // 1135 + { PseudoVDIV_VX_MF2_E16, VDIV_VX }, // 1136 + { PseudoVDIV_VX_MF2_E16_MASK, VDIV_VX }, // 1137 + { PseudoVDIV_VX_MF2_E32, VDIV_VX }, // 1138 + { PseudoVDIV_VX_MF2_E32_MASK, VDIV_VX }, // 1139 + { PseudoVDIV_VX_MF2_E8, VDIV_VX }, // 1140 + { PseudoVDIV_VX_MF2_E8_MASK, VDIV_VX }, // 1141 + { PseudoVDIV_VX_MF4_E16, VDIV_VX }, // 1142 + { PseudoVDIV_VX_MF4_E16_MASK, VDIV_VX }, // 1143 + { PseudoVDIV_VX_MF4_E8, VDIV_VX }, // 1144 + { PseudoVDIV_VX_MF4_E8_MASK, VDIV_VX }, // 1145 + { PseudoVDIV_VX_MF8_E8, VDIV_VX }, // 1146 + { PseudoVDIV_VX_MF8_E8_MASK, VDIV_VX }, // 1147 + { PseudoVFADD_VFPR16_M1, VFADD_VF }, // 1148 + { PseudoVFADD_VFPR16_M1_MASK, VFADD_VF }, // 1149 + { PseudoVFADD_VFPR16_M2, VFADD_VF }, // 1150 + { PseudoVFADD_VFPR16_M2_MASK, VFADD_VF }, // 1151 + { PseudoVFADD_VFPR16_M4, VFADD_VF }, // 1152 + { PseudoVFADD_VFPR16_M4_MASK, VFADD_VF }, // 1153 + { PseudoVFADD_VFPR16_M8, VFADD_VF }, // 1154 + { PseudoVFADD_VFPR16_M8_MASK, VFADD_VF }, // 1155 + { PseudoVFADD_VFPR16_MF2, VFADD_VF }, // 1156 + { PseudoVFADD_VFPR16_MF2_MASK, VFADD_VF }, // 1157 + { PseudoVFADD_VFPR16_MF4, VFADD_VF }, // 1158 + { PseudoVFADD_VFPR16_MF4_MASK, VFADD_VF }, // 1159 + { PseudoVFADD_VFPR32_M1, VFADD_VF }, // 1160 + { PseudoVFADD_VFPR32_M1_MASK, VFADD_VF }, // 1161 + { PseudoVFADD_VFPR32_M2, VFADD_VF }, // 1162 + { PseudoVFADD_VFPR32_M2_MASK, VFADD_VF }, // 1163 + { PseudoVFADD_VFPR32_M4, VFADD_VF }, // 1164 + { PseudoVFADD_VFPR32_M4_MASK, VFADD_VF }, // 1165 + { PseudoVFADD_VFPR32_M8, VFADD_VF }, // 1166 + { PseudoVFADD_VFPR32_M8_MASK, VFADD_VF }, // 1167 + { PseudoVFADD_VFPR32_MF2, VFADD_VF }, // 1168 + { PseudoVFADD_VFPR32_MF2_MASK, VFADD_VF }, // 1169 + { PseudoVFADD_VFPR64_M1, VFADD_VF }, // 1170 + { PseudoVFADD_VFPR64_M1_MASK, VFADD_VF }, // 1171 + { PseudoVFADD_VFPR64_M2, VFADD_VF }, // 1172 + { PseudoVFADD_VFPR64_M2_MASK, VFADD_VF }, // 1173 + { PseudoVFADD_VFPR64_M4, VFADD_VF }, // 1174 + { PseudoVFADD_VFPR64_M4_MASK, VFADD_VF }, // 1175 + { PseudoVFADD_VFPR64_M8, VFADD_VF }, // 1176 + { PseudoVFADD_VFPR64_M8_MASK, VFADD_VF }, // 1177 + { PseudoVFADD_VV_M1, VFADD_VV }, // 1178 + { PseudoVFADD_VV_M1_MASK, VFADD_VV }, // 1179 + { PseudoVFADD_VV_M2, VFADD_VV }, // 1180 + { PseudoVFADD_VV_M2_MASK, VFADD_VV }, // 1181 + { PseudoVFADD_VV_M4, VFADD_VV }, // 1182 + { PseudoVFADD_VV_M4_MASK, VFADD_VV }, // 1183 + { PseudoVFADD_VV_M8, VFADD_VV }, // 1184 + { PseudoVFADD_VV_M8_MASK, VFADD_VV }, // 1185 + { PseudoVFADD_VV_MF2, VFADD_VV }, // 1186 + { PseudoVFADD_VV_MF2_MASK, VFADD_VV }, // 1187 + { PseudoVFADD_VV_MF4, VFADD_VV }, // 1188 + { PseudoVFADD_VV_MF4_MASK, VFADD_VV }, // 1189 + { PseudoVFCLASS_V_M1, VFCLASS_V }, // 1190 + { PseudoVFCLASS_V_M1_MASK, VFCLASS_V }, // 1191 + { PseudoVFCLASS_V_M2, VFCLASS_V }, // 1192 + { PseudoVFCLASS_V_M2_MASK, VFCLASS_V }, // 1193 + { PseudoVFCLASS_V_M4, VFCLASS_V }, // 1194 + { PseudoVFCLASS_V_M4_MASK, VFCLASS_V }, // 1195 + { PseudoVFCLASS_V_M8, VFCLASS_V }, // 1196 + { PseudoVFCLASS_V_M8_MASK, VFCLASS_V }, // 1197 + { PseudoVFCLASS_V_MF2, VFCLASS_V }, // 1198 + { PseudoVFCLASS_V_MF2_MASK, VFCLASS_V }, // 1199 + { PseudoVFCLASS_V_MF4, VFCLASS_V }, // 1200 + { PseudoVFCLASS_V_MF4_MASK, VFCLASS_V }, // 1201 + { PseudoVFCVT_F_XU_V_M1, VFCVT_F_XU_V }, // 1202 + { PseudoVFCVT_F_XU_V_M1_MASK, VFCVT_F_XU_V }, // 1203 + { PseudoVFCVT_F_XU_V_M2, VFCVT_F_XU_V }, // 1204 + { PseudoVFCVT_F_XU_V_M2_MASK, VFCVT_F_XU_V }, // 1205 + { PseudoVFCVT_F_XU_V_M4, VFCVT_F_XU_V }, // 1206 + { PseudoVFCVT_F_XU_V_M4_MASK, VFCVT_F_XU_V }, // 1207 + { PseudoVFCVT_F_XU_V_M8, VFCVT_F_XU_V }, // 1208 + { PseudoVFCVT_F_XU_V_M8_MASK, VFCVT_F_XU_V }, // 1209 + { PseudoVFCVT_F_XU_V_MF2, VFCVT_F_XU_V }, // 1210 + { PseudoVFCVT_F_XU_V_MF2_MASK, VFCVT_F_XU_V }, // 1211 + { PseudoVFCVT_F_XU_V_MF4, VFCVT_F_XU_V }, // 1212 + { PseudoVFCVT_F_XU_V_MF4_MASK, VFCVT_F_XU_V }, // 1213 + { PseudoVFCVT_F_X_V_M1, VFCVT_F_X_V }, // 1214 + { PseudoVFCVT_F_X_V_M1_MASK, VFCVT_F_X_V }, // 1215 + { PseudoVFCVT_F_X_V_M2, VFCVT_F_X_V }, // 1216 + { PseudoVFCVT_F_X_V_M2_MASK, VFCVT_F_X_V }, // 1217 + { PseudoVFCVT_F_X_V_M4, VFCVT_F_X_V }, // 1218 + { PseudoVFCVT_F_X_V_M4_MASK, VFCVT_F_X_V }, // 1219 + { PseudoVFCVT_F_X_V_M8, VFCVT_F_X_V }, // 1220 + { PseudoVFCVT_F_X_V_M8_MASK, VFCVT_F_X_V }, // 1221 + { PseudoVFCVT_F_X_V_MF2, VFCVT_F_X_V }, // 1222 + { PseudoVFCVT_F_X_V_MF2_MASK, VFCVT_F_X_V }, // 1223 + { PseudoVFCVT_F_X_V_MF4, VFCVT_F_X_V }, // 1224 + { PseudoVFCVT_F_X_V_MF4_MASK, VFCVT_F_X_V }, // 1225 + { PseudoVFCVT_RM_F_XU_V_M1, VFCVT_F_XU_V }, // 1226 + { PseudoVFCVT_RM_F_XU_V_M1_MASK, VFCVT_F_XU_V }, // 1227 + { PseudoVFCVT_RM_F_XU_V_M2, VFCVT_F_XU_V }, // 1228 + { PseudoVFCVT_RM_F_XU_V_M2_MASK, VFCVT_F_XU_V }, // 1229 + { PseudoVFCVT_RM_F_XU_V_M4, VFCVT_F_XU_V }, // 1230 + { PseudoVFCVT_RM_F_XU_V_M4_MASK, VFCVT_F_XU_V }, // 1231 + { PseudoVFCVT_RM_F_XU_V_M8, VFCVT_F_XU_V }, // 1232 + { PseudoVFCVT_RM_F_XU_V_M8_MASK, VFCVT_F_XU_V }, // 1233 + { PseudoVFCVT_RM_F_XU_V_MF2, VFCVT_F_XU_V }, // 1234 + { PseudoVFCVT_RM_F_XU_V_MF2_MASK, VFCVT_F_XU_V }, // 1235 + { PseudoVFCVT_RM_F_XU_V_MF4, VFCVT_F_XU_V }, // 1236 + { PseudoVFCVT_RM_F_XU_V_MF4_MASK, VFCVT_F_XU_V }, // 1237 + { PseudoVFCVT_RM_F_X_V_M1, VFCVT_F_X_V }, // 1238 + { PseudoVFCVT_RM_F_X_V_M1_MASK, VFCVT_F_X_V }, // 1239 + { PseudoVFCVT_RM_F_X_V_M2, VFCVT_F_X_V }, // 1240 + { PseudoVFCVT_RM_F_X_V_M2_MASK, VFCVT_F_X_V }, // 1241 + { PseudoVFCVT_RM_F_X_V_M4, VFCVT_F_X_V }, // 1242 + { PseudoVFCVT_RM_F_X_V_M4_MASK, VFCVT_F_X_V }, // 1243 + { PseudoVFCVT_RM_F_X_V_M8, VFCVT_F_X_V }, // 1244 + { PseudoVFCVT_RM_F_X_V_M8_MASK, VFCVT_F_X_V }, // 1245 + { PseudoVFCVT_RM_F_X_V_MF2, VFCVT_F_X_V }, // 1246 + { PseudoVFCVT_RM_F_X_V_MF2_MASK, VFCVT_F_X_V }, // 1247 + { PseudoVFCVT_RM_F_X_V_MF4, VFCVT_F_X_V }, // 1248 + { PseudoVFCVT_RM_F_X_V_MF4_MASK, VFCVT_F_X_V }, // 1249 + { PseudoVFCVT_RM_XU_F_V_M1, VFCVT_XU_F_V }, // 1250 + { PseudoVFCVT_RM_XU_F_V_M1_MASK, VFCVT_XU_F_V }, // 1251 + { PseudoVFCVT_RM_XU_F_V_M2, VFCVT_XU_F_V }, // 1252 + { PseudoVFCVT_RM_XU_F_V_M2_MASK, VFCVT_XU_F_V }, // 1253 + { PseudoVFCVT_RM_XU_F_V_M4, VFCVT_XU_F_V }, // 1254 + { PseudoVFCVT_RM_XU_F_V_M4_MASK, VFCVT_XU_F_V }, // 1255 + { PseudoVFCVT_RM_XU_F_V_M8, VFCVT_XU_F_V }, // 1256 + { PseudoVFCVT_RM_XU_F_V_M8_MASK, VFCVT_XU_F_V }, // 1257 + { PseudoVFCVT_RM_XU_F_V_MF2, VFCVT_XU_F_V }, // 1258 + { PseudoVFCVT_RM_XU_F_V_MF2_MASK, VFCVT_XU_F_V }, // 1259 + { PseudoVFCVT_RM_XU_F_V_MF4, VFCVT_XU_F_V }, // 1260 + { PseudoVFCVT_RM_XU_F_V_MF4_MASK, VFCVT_XU_F_V }, // 1261 + { PseudoVFCVT_RM_X_F_V_M1, VFCVT_X_F_V }, // 1262 + { PseudoVFCVT_RM_X_F_V_M1_MASK, VFCVT_X_F_V }, // 1263 + { PseudoVFCVT_RM_X_F_V_M2, VFCVT_X_F_V }, // 1264 + { PseudoVFCVT_RM_X_F_V_M2_MASK, VFCVT_X_F_V }, // 1265 + { PseudoVFCVT_RM_X_F_V_M4, VFCVT_X_F_V }, // 1266 + { PseudoVFCVT_RM_X_F_V_M4_MASK, VFCVT_X_F_V }, // 1267 + { PseudoVFCVT_RM_X_F_V_M8, VFCVT_X_F_V }, // 1268 + { PseudoVFCVT_RM_X_F_V_M8_MASK, VFCVT_X_F_V }, // 1269 + { PseudoVFCVT_RM_X_F_V_MF2, VFCVT_X_F_V }, // 1270 + { PseudoVFCVT_RM_X_F_V_MF2_MASK, VFCVT_X_F_V }, // 1271 + { PseudoVFCVT_RM_X_F_V_MF4, VFCVT_X_F_V }, // 1272 + { PseudoVFCVT_RM_X_F_V_MF4_MASK, VFCVT_X_F_V }, // 1273 + { PseudoVFCVT_RTZ_XU_F_V_M1, VFCVT_RTZ_XU_F_V }, // 1274 + { PseudoVFCVT_RTZ_XU_F_V_M1_MASK, VFCVT_RTZ_XU_F_V }, // 1275 + { PseudoVFCVT_RTZ_XU_F_V_M2, VFCVT_RTZ_XU_F_V }, // 1276 + { PseudoVFCVT_RTZ_XU_F_V_M2_MASK, VFCVT_RTZ_XU_F_V }, // 1277 + { PseudoVFCVT_RTZ_XU_F_V_M4, VFCVT_RTZ_XU_F_V }, // 1278 + { PseudoVFCVT_RTZ_XU_F_V_M4_MASK, VFCVT_RTZ_XU_F_V }, // 1279 + { PseudoVFCVT_RTZ_XU_F_V_M8, VFCVT_RTZ_XU_F_V }, // 1280 + { PseudoVFCVT_RTZ_XU_F_V_M8_MASK, VFCVT_RTZ_XU_F_V }, // 1281 + { PseudoVFCVT_RTZ_XU_F_V_MF2, VFCVT_RTZ_XU_F_V }, // 1282 + { PseudoVFCVT_RTZ_XU_F_V_MF2_MASK, VFCVT_RTZ_XU_F_V }, // 1283 + { PseudoVFCVT_RTZ_XU_F_V_MF4, VFCVT_RTZ_XU_F_V }, // 1284 + { PseudoVFCVT_RTZ_XU_F_V_MF4_MASK, VFCVT_RTZ_XU_F_V }, // 1285 + { PseudoVFCVT_RTZ_X_F_V_M1, VFCVT_RTZ_X_F_V }, // 1286 + { PseudoVFCVT_RTZ_X_F_V_M1_MASK, VFCVT_RTZ_X_F_V }, // 1287 + { PseudoVFCVT_RTZ_X_F_V_M2, VFCVT_RTZ_X_F_V }, // 1288 + { PseudoVFCVT_RTZ_X_F_V_M2_MASK, VFCVT_RTZ_X_F_V }, // 1289 + { PseudoVFCVT_RTZ_X_F_V_M4, VFCVT_RTZ_X_F_V }, // 1290 + { PseudoVFCVT_RTZ_X_F_V_M4_MASK, VFCVT_RTZ_X_F_V }, // 1291 + { PseudoVFCVT_RTZ_X_F_V_M8, VFCVT_RTZ_X_F_V }, // 1292 + { PseudoVFCVT_RTZ_X_F_V_M8_MASK, VFCVT_RTZ_X_F_V }, // 1293 + { PseudoVFCVT_RTZ_X_F_V_MF2, VFCVT_RTZ_X_F_V }, // 1294 + { PseudoVFCVT_RTZ_X_F_V_MF2_MASK, VFCVT_RTZ_X_F_V }, // 1295 + { PseudoVFCVT_RTZ_X_F_V_MF4, VFCVT_RTZ_X_F_V }, // 1296 + { PseudoVFCVT_RTZ_X_F_V_MF4_MASK, VFCVT_RTZ_X_F_V }, // 1297 + { PseudoVFCVT_XU_F_V_M1, VFCVT_XU_F_V }, // 1298 + { PseudoVFCVT_XU_F_V_M1_MASK, VFCVT_XU_F_V }, // 1299 + { PseudoVFCVT_XU_F_V_M2, VFCVT_XU_F_V }, // 1300 + { PseudoVFCVT_XU_F_V_M2_MASK, VFCVT_XU_F_V }, // 1301 + { PseudoVFCVT_XU_F_V_M4, VFCVT_XU_F_V }, // 1302 + { PseudoVFCVT_XU_F_V_M4_MASK, VFCVT_XU_F_V }, // 1303 + { PseudoVFCVT_XU_F_V_M8, VFCVT_XU_F_V }, // 1304 + { PseudoVFCVT_XU_F_V_M8_MASK, VFCVT_XU_F_V }, // 1305 + { PseudoVFCVT_XU_F_V_MF2, VFCVT_XU_F_V }, // 1306 + { PseudoVFCVT_XU_F_V_MF2_MASK, VFCVT_XU_F_V }, // 1307 + { PseudoVFCVT_XU_F_V_MF4, VFCVT_XU_F_V }, // 1308 + { PseudoVFCVT_XU_F_V_MF4_MASK, VFCVT_XU_F_V }, // 1309 + { PseudoVFCVT_X_F_V_M1, VFCVT_X_F_V }, // 1310 + { PseudoVFCVT_X_F_V_M1_MASK, VFCVT_X_F_V }, // 1311 + { PseudoVFCVT_X_F_V_M2, VFCVT_X_F_V }, // 1312 + { PseudoVFCVT_X_F_V_M2_MASK, VFCVT_X_F_V }, // 1313 + { PseudoVFCVT_X_F_V_M4, VFCVT_X_F_V }, // 1314 + { PseudoVFCVT_X_F_V_M4_MASK, VFCVT_X_F_V }, // 1315 + { PseudoVFCVT_X_F_V_M8, VFCVT_X_F_V }, // 1316 + { PseudoVFCVT_X_F_V_M8_MASK, VFCVT_X_F_V }, // 1317 + { PseudoVFCVT_X_F_V_MF2, VFCVT_X_F_V }, // 1318 + { PseudoVFCVT_X_F_V_MF2_MASK, VFCVT_X_F_V }, // 1319 + { PseudoVFCVT_X_F_V_MF4, VFCVT_X_F_V }, // 1320 + { PseudoVFCVT_X_F_V_MF4_MASK, VFCVT_X_F_V }, // 1321 + { PseudoVFDIV_VFPR16_M1_E16, VFDIV_VF }, // 1322 + { PseudoVFDIV_VFPR16_M1_E16_MASK, VFDIV_VF }, // 1323 + { PseudoVFDIV_VFPR16_M2_E16, VFDIV_VF }, // 1324 + { PseudoVFDIV_VFPR16_M2_E16_MASK, VFDIV_VF }, // 1325 + { PseudoVFDIV_VFPR16_M4_E16, VFDIV_VF }, // 1326 + { PseudoVFDIV_VFPR16_M4_E16_MASK, VFDIV_VF }, // 1327 + { PseudoVFDIV_VFPR16_M8_E16, VFDIV_VF }, // 1328 + { PseudoVFDIV_VFPR16_M8_E16_MASK, VFDIV_VF }, // 1329 + { PseudoVFDIV_VFPR16_MF2_E16, VFDIV_VF }, // 1330 + { PseudoVFDIV_VFPR16_MF2_E16_MASK, VFDIV_VF }, // 1331 + { PseudoVFDIV_VFPR16_MF4_E16, VFDIV_VF }, // 1332 + { PseudoVFDIV_VFPR16_MF4_E16_MASK, VFDIV_VF }, // 1333 + { PseudoVFDIV_VFPR32_M1_E32, VFDIV_VF }, // 1334 + { PseudoVFDIV_VFPR32_M1_E32_MASK, VFDIV_VF }, // 1335 + { PseudoVFDIV_VFPR32_M2_E32, VFDIV_VF }, // 1336 + { PseudoVFDIV_VFPR32_M2_E32_MASK, VFDIV_VF }, // 1337 + { PseudoVFDIV_VFPR32_M4_E32, VFDIV_VF }, // 1338 + { PseudoVFDIV_VFPR32_M4_E32_MASK, VFDIV_VF }, // 1339 + { PseudoVFDIV_VFPR32_M8_E32, VFDIV_VF }, // 1340 + { PseudoVFDIV_VFPR32_M8_E32_MASK, VFDIV_VF }, // 1341 + { PseudoVFDIV_VFPR32_MF2_E32, VFDIV_VF }, // 1342 + { PseudoVFDIV_VFPR32_MF2_E32_MASK, VFDIV_VF }, // 1343 + { PseudoVFDIV_VFPR64_M1_E64, VFDIV_VF }, // 1344 + { PseudoVFDIV_VFPR64_M1_E64_MASK, VFDIV_VF }, // 1345 + { PseudoVFDIV_VFPR64_M2_E64, VFDIV_VF }, // 1346 + { PseudoVFDIV_VFPR64_M2_E64_MASK, VFDIV_VF }, // 1347 + { PseudoVFDIV_VFPR64_M4_E64, VFDIV_VF }, // 1348 + { PseudoVFDIV_VFPR64_M4_E64_MASK, VFDIV_VF }, // 1349 + { PseudoVFDIV_VFPR64_M8_E64, VFDIV_VF }, // 1350 + { PseudoVFDIV_VFPR64_M8_E64_MASK, VFDIV_VF }, // 1351 + { PseudoVFDIV_VV_M1_E16, VFDIV_VV }, // 1352 + { PseudoVFDIV_VV_M1_E16_MASK, VFDIV_VV }, // 1353 + { PseudoVFDIV_VV_M1_E32, VFDIV_VV }, // 1354 + { PseudoVFDIV_VV_M1_E32_MASK, VFDIV_VV }, // 1355 + { PseudoVFDIV_VV_M1_E64, VFDIV_VV }, // 1356 + { PseudoVFDIV_VV_M1_E64_MASK, VFDIV_VV }, // 1357 + { PseudoVFDIV_VV_M2_E16, VFDIV_VV }, // 1358 + { PseudoVFDIV_VV_M2_E16_MASK, VFDIV_VV }, // 1359 + { PseudoVFDIV_VV_M2_E32, VFDIV_VV }, // 1360 + { PseudoVFDIV_VV_M2_E32_MASK, VFDIV_VV }, // 1361 + { PseudoVFDIV_VV_M2_E64, VFDIV_VV }, // 1362 + { PseudoVFDIV_VV_M2_E64_MASK, VFDIV_VV }, // 1363 + { PseudoVFDIV_VV_M4_E16, VFDIV_VV }, // 1364 + { PseudoVFDIV_VV_M4_E16_MASK, VFDIV_VV }, // 1365 + { PseudoVFDIV_VV_M4_E32, VFDIV_VV }, // 1366 + { PseudoVFDIV_VV_M4_E32_MASK, VFDIV_VV }, // 1367 + { PseudoVFDIV_VV_M4_E64, VFDIV_VV }, // 1368 + { PseudoVFDIV_VV_M4_E64_MASK, VFDIV_VV }, // 1369 + { PseudoVFDIV_VV_M8_E16, VFDIV_VV }, // 1370 + { PseudoVFDIV_VV_M8_E16_MASK, VFDIV_VV }, // 1371 + { PseudoVFDIV_VV_M8_E32, VFDIV_VV }, // 1372 + { PseudoVFDIV_VV_M8_E32_MASK, VFDIV_VV }, // 1373 + { PseudoVFDIV_VV_M8_E64, VFDIV_VV }, // 1374 + { PseudoVFDIV_VV_M8_E64_MASK, VFDIV_VV }, // 1375 + { PseudoVFDIV_VV_MF2_E16, VFDIV_VV }, // 1376 + { PseudoVFDIV_VV_MF2_E16_MASK, VFDIV_VV }, // 1377 + { PseudoVFDIV_VV_MF2_E32, VFDIV_VV }, // 1378 + { PseudoVFDIV_VV_MF2_E32_MASK, VFDIV_VV }, // 1379 + { PseudoVFDIV_VV_MF4_E16, VFDIV_VV }, // 1380 + { PseudoVFDIV_VV_MF4_E16_MASK, VFDIV_VV }, // 1381 + { PseudoVFIRST_M_B1, VFIRST_M }, // 1382 + { PseudoVFIRST_M_B16, VFIRST_M }, // 1383 + { PseudoVFIRST_M_B16_MASK, VFIRST_M }, // 1384 + { PseudoVFIRST_M_B1_MASK, VFIRST_M }, // 1385 + { PseudoVFIRST_M_B2, VFIRST_M }, // 1386 + { PseudoVFIRST_M_B2_MASK, VFIRST_M }, // 1387 + { PseudoVFIRST_M_B32, VFIRST_M }, // 1388 + { PseudoVFIRST_M_B32_MASK, VFIRST_M }, // 1389 + { PseudoVFIRST_M_B4, VFIRST_M }, // 1390 + { PseudoVFIRST_M_B4_MASK, VFIRST_M }, // 1391 + { PseudoVFIRST_M_B64, VFIRST_M }, // 1392 + { PseudoVFIRST_M_B64_MASK, VFIRST_M }, // 1393 + { PseudoVFIRST_M_B8, VFIRST_M }, // 1394 + { PseudoVFIRST_M_B8_MASK, VFIRST_M }, // 1395 + { PseudoVFMACC_VFPR16_M1, VFMACC_VF }, // 1396 + { PseudoVFMACC_VFPR16_M1_MASK, VFMACC_VF }, // 1397 + { PseudoVFMACC_VFPR16_M2, VFMACC_VF }, // 1398 + { PseudoVFMACC_VFPR16_M2_MASK, VFMACC_VF }, // 1399 + { PseudoVFMACC_VFPR16_M4, VFMACC_VF }, // 1400 + { PseudoVFMACC_VFPR16_M4_MASK, VFMACC_VF }, // 1401 + { PseudoVFMACC_VFPR16_M8, VFMACC_VF }, // 1402 + { PseudoVFMACC_VFPR16_M8_MASK, VFMACC_VF }, // 1403 + { PseudoVFMACC_VFPR16_MF2, VFMACC_VF }, // 1404 + { PseudoVFMACC_VFPR16_MF2_MASK, VFMACC_VF }, // 1405 + { PseudoVFMACC_VFPR16_MF4, VFMACC_VF }, // 1406 + { PseudoVFMACC_VFPR16_MF4_MASK, VFMACC_VF }, // 1407 + { PseudoVFMACC_VFPR32_M1, VFMACC_VF }, // 1408 + { PseudoVFMACC_VFPR32_M1_MASK, VFMACC_VF }, // 1409 + { PseudoVFMACC_VFPR32_M2, VFMACC_VF }, // 1410 + { PseudoVFMACC_VFPR32_M2_MASK, VFMACC_VF }, // 1411 + { PseudoVFMACC_VFPR32_M4, VFMACC_VF }, // 1412 + { PseudoVFMACC_VFPR32_M4_MASK, VFMACC_VF }, // 1413 + { PseudoVFMACC_VFPR32_M8, VFMACC_VF }, // 1414 + { PseudoVFMACC_VFPR32_M8_MASK, VFMACC_VF }, // 1415 + { PseudoVFMACC_VFPR32_MF2, VFMACC_VF }, // 1416 + { PseudoVFMACC_VFPR32_MF2_MASK, VFMACC_VF }, // 1417 + { PseudoVFMACC_VFPR64_M1, VFMACC_VF }, // 1418 + { PseudoVFMACC_VFPR64_M1_MASK, VFMACC_VF }, // 1419 + { PseudoVFMACC_VFPR64_M2, VFMACC_VF }, // 1420 + { PseudoVFMACC_VFPR64_M2_MASK, VFMACC_VF }, // 1421 + { PseudoVFMACC_VFPR64_M4, VFMACC_VF }, // 1422 + { PseudoVFMACC_VFPR64_M4_MASK, VFMACC_VF }, // 1423 + { PseudoVFMACC_VFPR64_M8, VFMACC_VF }, // 1424 + { PseudoVFMACC_VFPR64_M8_MASK, VFMACC_VF }, // 1425 + { PseudoVFMACC_VV_M1, VFMACC_VV }, // 1426 + { PseudoVFMACC_VV_M1_MASK, VFMACC_VV }, // 1427 + { PseudoVFMACC_VV_M2, VFMACC_VV }, // 1428 + { PseudoVFMACC_VV_M2_MASK, VFMACC_VV }, // 1429 + { PseudoVFMACC_VV_M4, VFMACC_VV }, // 1430 + { PseudoVFMACC_VV_M4_MASK, VFMACC_VV }, // 1431 + { PseudoVFMACC_VV_M8, VFMACC_VV }, // 1432 + { PseudoVFMACC_VV_M8_MASK, VFMACC_VV }, // 1433 + { PseudoVFMACC_VV_MF2, VFMACC_VV }, // 1434 + { PseudoVFMACC_VV_MF2_MASK, VFMACC_VV }, // 1435 + { PseudoVFMACC_VV_MF4, VFMACC_VV }, // 1436 + { PseudoVFMACC_VV_MF4_MASK, VFMACC_VV }, // 1437 + { PseudoVFMADD_VFPR16_M1, VFMADD_VF }, // 1438 + { PseudoVFMADD_VFPR16_M1_MASK, VFMADD_VF }, // 1439 + { PseudoVFMADD_VFPR16_M2, VFMADD_VF }, // 1440 + { PseudoVFMADD_VFPR16_M2_MASK, VFMADD_VF }, // 1441 + { PseudoVFMADD_VFPR16_M4, VFMADD_VF }, // 1442 + { PseudoVFMADD_VFPR16_M4_MASK, VFMADD_VF }, // 1443 + { PseudoVFMADD_VFPR16_M8, VFMADD_VF }, // 1444 + { PseudoVFMADD_VFPR16_M8_MASK, VFMADD_VF }, // 1445 + { PseudoVFMADD_VFPR16_MF2, VFMADD_VF }, // 1446 + { PseudoVFMADD_VFPR16_MF2_MASK, VFMADD_VF }, // 1447 + { PseudoVFMADD_VFPR16_MF4, VFMADD_VF }, // 1448 + { PseudoVFMADD_VFPR16_MF4_MASK, VFMADD_VF }, // 1449 + { PseudoVFMADD_VFPR32_M1, VFMADD_VF }, // 1450 + { PseudoVFMADD_VFPR32_M1_MASK, VFMADD_VF }, // 1451 + { PseudoVFMADD_VFPR32_M2, VFMADD_VF }, // 1452 + { PseudoVFMADD_VFPR32_M2_MASK, VFMADD_VF }, // 1453 + { PseudoVFMADD_VFPR32_M4, VFMADD_VF }, // 1454 + { PseudoVFMADD_VFPR32_M4_MASK, VFMADD_VF }, // 1455 + { PseudoVFMADD_VFPR32_M8, VFMADD_VF }, // 1456 + { PseudoVFMADD_VFPR32_M8_MASK, VFMADD_VF }, // 1457 + { PseudoVFMADD_VFPR32_MF2, VFMADD_VF }, // 1458 + { PseudoVFMADD_VFPR32_MF2_MASK, VFMADD_VF }, // 1459 + { PseudoVFMADD_VFPR64_M1, VFMADD_VF }, // 1460 + { PseudoVFMADD_VFPR64_M1_MASK, VFMADD_VF }, // 1461 + { PseudoVFMADD_VFPR64_M2, VFMADD_VF }, // 1462 + { PseudoVFMADD_VFPR64_M2_MASK, VFMADD_VF }, // 1463 + { PseudoVFMADD_VFPR64_M4, VFMADD_VF }, // 1464 + { PseudoVFMADD_VFPR64_M4_MASK, VFMADD_VF }, // 1465 + { PseudoVFMADD_VFPR64_M8, VFMADD_VF }, // 1466 + { PseudoVFMADD_VFPR64_M8_MASK, VFMADD_VF }, // 1467 + { PseudoVFMADD_VV_M1, VFMADD_VV }, // 1468 + { PseudoVFMADD_VV_M1_MASK, VFMADD_VV }, // 1469 + { PseudoVFMADD_VV_M2, VFMADD_VV }, // 1470 + { PseudoVFMADD_VV_M2_MASK, VFMADD_VV }, // 1471 + { PseudoVFMADD_VV_M4, VFMADD_VV }, // 1472 + { PseudoVFMADD_VV_M4_MASK, VFMADD_VV }, // 1473 + { PseudoVFMADD_VV_M8, VFMADD_VV }, // 1474 + { PseudoVFMADD_VV_M8_MASK, VFMADD_VV }, // 1475 + { PseudoVFMADD_VV_MF2, VFMADD_VV }, // 1476 + { PseudoVFMADD_VV_MF2_MASK, VFMADD_VV }, // 1477 + { PseudoVFMADD_VV_MF4, VFMADD_VV }, // 1478 + { PseudoVFMADD_VV_MF4_MASK, VFMADD_VV }, // 1479 + { PseudoVFMAX_VFPR16_M1, VFMAX_VF }, // 1480 + { PseudoVFMAX_VFPR16_M1_MASK, VFMAX_VF }, // 1481 + { PseudoVFMAX_VFPR16_M2, VFMAX_VF }, // 1482 + { PseudoVFMAX_VFPR16_M2_MASK, VFMAX_VF }, // 1483 + { PseudoVFMAX_VFPR16_M4, VFMAX_VF }, // 1484 + { PseudoVFMAX_VFPR16_M4_MASK, VFMAX_VF }, // 1485 + { PseudoVFMAX_VFPR16_M8, VFMAX_VF }, // 1486 + { PseudoVFMAX_VFPR16_M8_MASK, VFMAX_VF }, // 1487 + { PseudoVFMAX_VFPR16_MF2, VFMAX_VF }, // 1488 + { PseudoVFMAX_VFPR16_MF2_MASK, VFMAX_VF }, // 1489 + { PseudoVFMAX_VFPR16_MF4, VFMAX_VF }, // 1490 + { PseudoVFMAX_VFPR16_MF4_MASK, VFMAX_VF }, // 1491 + { PseudoVFMAX_VFPR32_M1, VFMAX_VF }, // 1492 + { PseudoVFMAX_VFPR32_M1_MASK, VFMAX_VF }, // 1493 + { PseudoVFMAX_VFPR32_M2, VFMAX_VF }, // 1494 + { PseudoVFMAX_VFPR32_M2_MASK, VFMAX_VF }, // 1495 + { PseudoVFMAX_VFPR32_M4, VFMAX_VF }, // 1496 + { PseudoVFMAX_VFPR32_M4_MASK, VFMAX_VF }, // 1497 + { PseudoVFMAX_VFPR32_M8, VFMAX_VF }, // 1498 + { PseudoVFMAX_VFPR32_M8_MASK, VFMAX_VF }, // 1499 + { PseudoVFMAX_VFPR32_MF2, VFMAX_VF }, // 1500 + { PseudoVFMAX_VFPR32_MF2_MASK, VFMAX_VF }, // 1501 + { PseudoVFMAX_VFPR64_M1, VFMAX_VF }, // 1502 + { PseudoVFMAX_VFPR64_M1_MASK, VFMAX_VF }, // 1503 + { PseudoVFMAX_VFPR64_M2, VFMAX_VF }, // 1504 + { PseudoVFMAX_VFPR64_M2_MASK, VFMAX_VF }, // 1505 + { PseudoVFMAX_VFPR64_M4, VFMAX_VF }, // 1506 + { PseudoVFMAX_VFPR64_M4_MASK, VFMAX_VF }, // 1507 + { PseudoVFMAX_VFPR64_M8, VFMAX_VF }, // 1508 + { PseudoVFMAX_VFPR64_M8_MASK, VFMAX_VF }, // 1509 + { PseudoVFMAX_VV_M1, VFMAX_VV }, // 1510 + { PseudoVFMAX_VV_M1_MASK, VFMAX_VV }, // 1511 + { PseudoVFMAX_VV_M2, VFMAX_VV }, // 1512 + { PseudoVFMAX_VV_M2_MASK, VFMAX_VV }, // 1513 + { PseudoVFMAX_VV_M4, VFMAX_VV }, // 1514 + { PseudoVFMAX_VV_M4_MASK, VFMAX_VV }, // 1515 + { PseudoVFMAX_VV_M8, VFMAX_VV }, // 1516 + { PseudoVFMAX_VV_M8_MASK, VFMAX_VV }, // 1517 + { PseudoVFMAX_VV_MF2, VFMAX_VV }, // 1518 + { PseudoVFMAX_VV_MF2_MASK, VFMAX_VV }, // 1519 + { PseudoVFMAX_VV_MF4, VFMAX_VV }, // 1520 + { PseudoVFMAX_VV_MF4_MASK, VFMAX_VV }, // 1521 + { PseudoVFMERGE_VFPR16M_M1, VFMERGE_VFM }, // 1522 + { PseudoVFMERGE_VFPR16M_M2, VFMERGE_VFM }, // 1523 + { PseudoVFMERGE_VFPR16M_M4, VFMERGE_VFM }, // 1524 + { PseudoVFMERGE_VFPR16M_M8, VFMERGE_VFM }, // 1525 + { PseudoVFMERGE_VFPR16M_MF2, VFMERGE_VFM }, // 1526 + { PseudoVFMERGE_VFPR16M_MF4, VFMERGE_VFM }, // 1527 + { PseudoVFMERGE_VFPR32M_M1, VFMERGE_VFM }, // 1528 + { PseudoVFMERGE_VFPR32M_M2, VFMERGE_VFM }, // 1529 + { PseudoVFMERGE_VFPR32M_M4, VFMERGE_VFM }, // 1530 + { PseudoVFMERGE_VFPR32M_M8, VFMERGE_VFM }, // 1531 + { PseudoVFMERGE_VFPR32M_MF2, VFMERGE_VFM }, // 1532 + { PseudoVFMERGE_VFPR64M_M1, VFMERGE_VFM }, // 1533 + { PseudoVFMERGE_VFPR64M_M2, VFMERGE_VFM }, // 1534 + { PseudoVFMERGE_VFPR64M_M4, VFMERGE_VFM }, // 1535 + { PseudoVFMERGE_VFPR64M_M8, VFMERGE_VFM }, // 1536 + { PseudoVFMIN_VFPR16_M1, VFMIN_VF }, // 1537 + { PseudoVFMIN_VFPR16_M1_MASK, VFMIN_VF }, // 1538 + { PseudoVFMIN_VFPR16_M2, VFMIN_VF }, // 1539 + { PseudoVFMIN_VFPR16_M2_MASK, VFMIN_VF }, // 1540 + { PseudoVFMIN_VFPR16_M4, VFMIN_VF }, // 1541 + { PseudoVFMIN_VFPR16_M4_MASK, VFMIN_VF }, // 1542 + { PseudoVFMIN_VFPR16_M8, VFMIN_VF }, // 1543 + { PseudoVFMIN_VFPR16_M8_MASK, VFMIN_VF }, // 1544 + { PseudoVFMIN_VFPR16_MF2, VFMIN_VF }, // 1545 + { PseudoVFMIN_VFPR16_MF2_MASK, VFMIN_VF }, // 1546 + { PseudoVFMIN_VFPR16_MF4, VFMIN_VF }, // 1547 + { PseudoVFMIN_VFPR16_MF4_MASK, VFMIN_VF }, // 1548 + { PseudoVFMIN_VFPR32_M1, VFMIN_VF }, // 1549 + { PseudoVFMIN_VFPR32_M1_MASK, VFMIN_VF }, // 1550 + { PseudoVFMIN_VFPR32_M2, VFMIN_VF }, // 1551 + { PseudoVFMIN_VFPR32_M2_MASK, VFMIN_VF }, // 1552 + { PseudoVFMIN_VFPR32_M4, VFMIN_VF }, // 1553 + { PseudoVFMIN_VFPR32_M4_MASK, VFMIN_VF }, // 1554 + { PseudoVFMIN_VFPR32_M8, VFMIN_VF }, // 1555 + { PseudoVFMIN_VFPR32_M8_MASK, VFMIN_VF }, // 1556 + { PseudoVFMIN_VFPR32_MF2, VFMIN_VF }, // 1557 + { PseudoVFMIN_VFPR32_MF2_MASK, VFMIN_VF }, // 1558 + { PseudoVFMIN_VFPR64_M1, VFMIN_VF }, // 1559 + { PseudoVFMIN_VFPR64_M1_MASK, VFMIN_VF }, // 1560 + { PseudoVFMIN_VFPR64_M2, VFMIN_VF }, // 1561 + { PseudoVFMIN_VFPR64_M2_MASK, VFMIN_VF }, // 1562 + { PseudoVFMIN_VFPR64_M4, VFMIN_VF }, // 1563 + { PseudoVFMIN_VFPR64_M4_MASK, VFMIN_VF }, // 1564 + { PseudoVFMIN_VFPR64_M8, VFMIN_VF }, // 1565 + { PseudoVFMIN_VFPR64_M8_MASK, VFMIN_VF }, // 1566 + { PseudoVFMIN_VV_M1, VFMIN_VV }, // 1567 + { PseudoVFMIN_VV_M1_MASK, VFMIN_VV }, // 1568 + { PseudoVFMIN_VV_M2, VFMIN_VV }, // 1569 + { PseudoVFMIN_VV_M2_MASK, VFMIN_VV }, // 1570 + { PseudoVFMIN_VV_M4, VFMIN_VV }, // 1571 + { PseudoVFMIN_VV_M4_MASK, VFMIN_VV }, // 1572 + { PseudoVFMIN_VV_M8, VFMIN_VV }, // 1573 + { PseudoVFMIN_VV_M8_MASK, VFMIN_VV }, // 1574 + { PseudoVFMIN_VV_MF2, VFMIN_VV }, // 1575 + { PseudoVFMIN_VV_MF2_MASK, VFMIN_VV }, // 1576 + { PseudoVFMIN_VV_MF4, VFMIN_VV }, // 1577 + { PseudoVFMIN_VV_MF4_MASK, VFMIN_VV }, // 1578 + { PseudoVFMSAC_VFPR16_M1, VFMSAC_VF }, // 1579 + { PseudoVFMSAC_VFPR16_M1_MASK, VFMSAC_VF }, // 1580 + { PseudoVFMSAC_VFPR16_M2, VFMSAC_VF }, // 1581 + { PseudoVFMSAC_VFPR16_M2_MASK, VFMSAC_VF }, // 1582 + { PseudoVFMSAC_VFPR16_M4, VFMSAC_VF }, // 1583 + { PseudoVFMSAC_VFPR16_M4_MASK, VFMSAC_VF }, // 1584 + { PseudoVFMSAC_VFPR16_M8, VFMSAC_VF }, // 1585 + { PseudoVFMSAC_VFPR16_M8_MASK, VFMSAC_VF }, // 1586 + { PseudoVFMSAC_VFPR16_MF2, VFMSAC_VF }, // 1587 + { PseudoVFMSAC_VFPR16_MF2_MASK, VFMSAC_VF }, // 1588 + { PseudoVFMSAC_VFPR16_MF4, VFMSAC_VF }, // 1589 + { PseudoVFMSAC_VFPR16_MF4_MASK, VFMSAC_VF }, // 1590 + { PseudoVFMSAC_VFPR32_M1, VFMSAC_VF }, // 1591 + { PseudoVFMSAC_VFPR32_M1_MASK, VFMSAC_VF }, // 1592 + { PseudoVFMSAC_VFPR32_M2, VFMSAC_VF }, // 1593 + { PseudoVFMSAC_VFPR32_M2_MASK, VFMSAC_VF }, // 1594 + { PseudoVFMSAC_VFPR32_M4, VFMSAC_VF }, // 1595 + { PseudoVFMSAC_VFPR32_M4_MASK, VFMSAC_VF }, // 1596 + { PseudoVFMSAC_VFPR32_M8, VFMSAC_VF }, // 1597 + { PseudoVFMSAC_VFPR32_M8_MASK, VFMSAC_VF }, // 1598 + { PseudoVFMSAC_VFPR32_MF2, VFMSAC_VF }, // 1599 + { PseudoVFMSAC_VFPR32_MF2_MASK, VFMSAC_VF }, // 1600 + { PseudoVFMSAC_VFPR64_M1, VFMSAC_VF }, // 1601 + { PseudoVFMSAC_VFPR64_M1_MASK, VFMSAC_VF }, // 1602 + { PseudoVFMSAC_VFPR64_M2, VFMSAC_VF }, // 1603 + { PseudoVFMSAC_VFPR64_M2_MASK, VFMSAC_VF }, // 1604 + { PseudoVFMSAC_VFPR64_M4, VFMSAC_VF }, // 1605 + { PseudoVFMSAC_VFPR64_M4_MASK, VFMSAC_VF }, // 1606 + { PseudoVFMSAC_VFPR64_M8, VFMSAC_VF }, // 1607 + { PseudoVFMSAC_VFPR64_M8_MASK, VFMSAC_VF }, // 1608 + { PseudoVFMSAC_VV_M1, VFMSAC_VV }, // 1609 + { PseudoVFMSAC_VV_M1_MASK, VFMSAC_VV }, // 1610 + { PseudoVFMSAC_VV_M2, VFMSAC_VV }, // 1611 + { PseudoVFMSAC_VV_M2_MASK, VFMSAC_VV }, // 1612 + { PseudoVFMSAC_VV_M4, VFMSAC_VV }, // 1613 + { PseudoVFMSAC_VV_M4_MASK, VFMSAC_VV }, // 1614 + { PseudoVFMSAC_VV_M8, VFMSAC_VV }, // 1615 + { PseudoVFMSAC_VV_M8_MASK, VFMSAC_VV }, // 1616 + { PseudoVFMSAC_VV_MF2, VFMSAC_VV }, // 1617 + { PseudoVFMSAC_VV_MF2_MASK, VFMSAC_VV }, // 1618 + { PseudoVFMSAC_VV_MF4, VFMSAC_VV }, // 1619 + { PseudoVFMSAC_VV_MF4_MASK, VFMSAC_VV }, // 1620 + { PseudoVFMSUB_VFPR16_M1, VFMSUB_VF }, // 1621 + { PseudoVFMSUB_VFPR16_M1_MASK, VFMSUB_VF }, // 1622 + { PseudoVFMSUB_VFPR16_M2, VFMSUB_VF }, // 1623 + { PseudoVFMSUB_VFPR16_M2_MASK, VFMSUB_VF }, // 1624 + { PseudoVFMSUB_VFPR16_M4, VFMSUB_VF }, // 1625 + { PseudoVFMSUB_VFPR16_M4_MASK, VFMSUB_VF }, // 1626 + { PseudoVFMSUB_VFPR16_M8, VFMSUB_VF }, // 1627 + { PseudoVFMSUB_VFPR16_M8_MASK, VFMSUB_VF }, // 1628 + { PseudoVFMSUB_VFPR16_MF2, VFMSUB_VF }, // 1629 + { PseudoVFMSUB_VFPR16_MF2_MASK, VFMSUB_VF }, // 1630 + { PseudoVFMSUB_VFPR16_MF4, VFMSUB_VF }, // 1631 + { PseudoVFMSUB_VFPR16_MF4_MASK, VFMSUB_VF }, // 1632 + { PseudoVFMSUB_VFPR32_M1, VFMSUB_VF }, // 1633 + { PseudoVFMSUB_VFPR32_M1_MASK, VFMSUB_VF }, // 1634 + { PseudoVFMSUB_VFPR32_M2, VFMSUB_VF }, // 1635 + { PseudoVFMSUB_VFPR32_M2_MASK, VFMSUB_VF }, // 1636 + { PseudoVFMSUB_VFPR32_M4, VFMSUB_VF }, // 1637 + { PseudoVFMSUB_VFPR32_M4_MASK, VFMSUB_VF }, // 1638 + { PseudoVFMSUB_VFPR32_M8, VFMSUB_VF }, // 1639 + { PseudoVFMSUB_VFPR32_M8_MASK, VFMSUB_VF }, // 1640 + { PseudoVFMSUB_VFPR32_MF2, VFMSUB_VF }, // 1641 + { PseudoVFMSUB_VFPR32_MF2_MASK, VFMSUB_VF }, // 1642 + { PseudoVFMSUB_VFPR64_M1, VFMSUB_VF }, // 1643 + { PseudoVFMSUB_VFPR64_M1_MASK, VFMSUB_VF }, // 1644 + { PseudoVFMSUB_VFPR64_M2, VFMSUB_VF }, // 1645 + { PseudoVFMSUB_VFPR64_M2_MASK, VFMSUB_VF }, // 1646 + { PseudoVFMSUB_VFPR64_M4, VFMSUB_VF }, // 1647 + { PseudoVFMSUB_VFPR64_M4_MASK, VFMSUB_VF }, // 1648 + { PseudoVFMSUB_VFPR64_M8, VFMSUB_VF }, // 1649 + { PseudoVFMSUB_VFPR64_M8_MASK, VFMSUB_VF }, // 1650 + { PseudoVFMSUB_VV_M1, VFMSUB_VV }, // 1651 + { PseudoVFMSUB_VV_M1_MASK, VFMSUB_VV }, // 1652 + { PseudoVFMSUB_VV_M2, VFMSUB_VV }, // 1653 + { PseudoVFMSUB_VV_M2_MASK, VFMSUB_VV }, // 1654 + { PseudoVFMSUB_VV_M4, VFMSUB_VV }, // 1655 + { PseudoVFMSUB_VV_M4_MASK, VFMSUB_VV }, // 1656 + { PseudoVFMSUB_VV_M8, VFMSUB_VV }, // 1657 + { PseudoVFMSUB_VV_M8_MASK, VFMSUB_VV }, // 1658 + { PseudoVFMSUB_VV_MF2, VFMSUB_VV }, // 1659 + { PseudoVFMSUB_VV_MF2_MASK, VFMSUB_VV }, // 1660 + { PseudoVFMSUB_VV_MF4, VFMSUB_VV }, // 1661 + { PseudoVFMSUB_VV_MF4_MASK, VFMSUB_VV }, // 1662 + { PseudoVFMUL_VFPR16_M1, VFMUL_VF }, // 1663 + { PseudoVFMUL_VFPR16_M1_MASK, VFMUL_VF }, // 1664 + { PseudoVFMUL_VFPR16_M2, VFMUL_VF }, // 1665 + { PseudoVFMUL_VFPR16_M2_MASK, VFMUL_VF }, // 1666 + { PseudoVFMUL_VFPR16_M4, VFMUL_VF }, // 1667 + { PseudoVFMUL_VFPR16_M4_MASK, VFMUL_VF }, // 1668 + { PseudoVFMUL_VFPR16_M8, VFMUL_VF }, // 1669 + { PseudoVFMUL_VFPR16_M8_MASK, VFMUL_VF }, // 1670 + { PseudoVFMUL_VFPR16_MF2, VFMUL_VF }, // 1671 + { PseudoVFMUL_VFPR16_MF2_MASK, VFMUL_VF }, // 1672 + { PseudoVFMUL_VFPR16_MF4, VFMUL_VF }, // 1673 + { PseudoVFMUL_VFPR16_MF4_MASK, VFMUL_VF }, // 1674 + { PseudoVFMUL_VFPR32_M1, VFMUL_VF }, // 1675 + { PseudoVFMUL_VFPR32_M1_MASK, VFMUL_VF }, // 1676 + { PseudoVFMUL_VFPR32_M2, VFMUL_VF }, // 1677 + { PseudoVFMUL_VFPR32_M2_MASK, VFMUL_VF }, // 1678 + { PseudoVFMUL_VFPR32_M4, VFMUL_VF }, // 1679 + { PseudoVFMUL_VFPR32_M4_MASK, VFMUL_VF }, // 1680 + { PseudoVFMUL_VFPR32_M8, VFMUL_VF }, // 1681 + { PseudoVFMUL_VFPR32_M8_MASK, VFMUL_VF }, // 1682 + { PseudoVFMUL_VFPR32_MF2, VFMUL_VF }, // 1683 + { PseudoVFMUL_VFPR32_MF2_MASK, VFMUL_VF }, // 1684 + { PseudoVFMUL_VFPR64_M1, VFMUL_VF }, // 1685 + { PseudoVFMUL_VFPR64_M1_MASK, VFMUL_VF }, // 1686 + { PseudoVFMUL_VFPR64_M2, VFMUL_VF }, // 1687 + { PseudoVFMUL_VFPR64_M2_MASK, VFMUL_VF }, // 1688 + { PseudoVFMUL_VFPR64_M4, VFMUL_VF }, // 1689 + { PseudoVFMUL_VFPR64_M4_MASK, VFMUL_VF }, // 1690 + { PseudoVFMUL_VFPR64_M8, VFMUL_VF }, // 1691 + { PseudoVFMUL_VFPR64_M8_MASK, VFMUL_VF }, // 1692 + { PseudoVFMUL_VV_M1, VFMUL_VV }, // 1693 + { PseudoVFMUL_VV_M1_MASK, VFMUL_VV }, // 1694 + { PseudoVFMUL_VV_M2, VFMUL_VV }, // 1695 + { PseudoVFMUL_VV_M2_MASK, VFMUL_VV }, // 1696 + { PseudoVFMUL_VV_M4, VFMUL_VV }, // 1697 + { PseudoVFMUL_VV_M4_MASK, VFMUL_VV }, // 1698 + { PseudoVFMUL_VV_M8, VFMUL_VV }, // 1699 + { PseudoVFMUL_VV_M8_MASK, VFMUL_VV }, // 1700 + { PseudoVFMUL_VV_MF2, VFMUL_VV }, // 1701 + { PseudoVFMUL_VV_MF2_MASK, VFMUL_VV }, // 1702 + { PseudoVFMUL_VV_MF4, VFMUL_VV }, // 1703 + { PseudoVFMUL_VV_MF4_MASK, VFMUL_VV }, // 1704 + { PseudoVFMV_FPR16_S_M1, VFMV_F_S }, // 1705 + { PseudoVFMV_FPR16_S_M2, VFMV_F_S }, // 1706 + { PseudoVFMV_FPR16_S_M4, VFMV_F_S }, // 1707 + { PseudoVFMV_FPR16_S_M8, VFMV_F_S }, // 1708 + { PseudoVFMV_FPR16_S_MF2, VFMV_F_S }, // 1709 + { PseudoVFMV_FPR16_S_MF4, VFMV_F_S }, // 1710 + { PseudoVFMV_FPR32_S_M1, VFMV_F_S }, // 1711 + { PseudoVFMV_FPR32_S_M2, VFMV_F_S }, // 1712 + { PseudoVFMV_FPR32_S_M4, VFMV_F_S }, // 1713 + { PseudoVFMV_FPR32_S_M8, VFMV_F_S }, // 1714 + { PseudoVFMV_FPR32_S_MF2, VFMV_F_S }, // 1715 + { PseudoVFMV_FPR64_S_M1, VFMV_F_S }, // 1716 + { PseudoVFMV_FPR64_S_M2, VFMV_F_S }, // 1717 + { PseudoVFMV_FPR64_S_M4, VFMV_F_S }, // 1718 + { PseudoVFMV_FPR64_S_M8, VFMV_F_S }, // 1719 + { PseudoVFMV_S_FPR16_M1, VFMV_S_F }, // 1720 + { PseudoVFMV_S_FPR16_M2, VFMV_S_F }, // 1721 + { PseudoVFMV_S_FPR16_M4, VFMV_S_F }, // 1722 + { PseudoVFMV_S_FPR16_M8, VFMV_S_F }, // 1723 + { PseudoVFMV_S_FPR16_MF2, VFMV_S_F }, // 1724 + { PseudoVFMV_S_FPR16_MF4, VFMV_S_F }, // 1725 + { PseudoVFMV_S_FPR32_M1, VFMV_S_F }, // 1726 + { PseudoVFMV_S_FPR32_M2, VFMV_S_F }, // 1727 + { PseudoVFMV_S_FPR32_M4, VFMV_S_F }, // 1728 + { PseudoVFMV_S_FPR32_M8, VFMV_S_F }, // 1729 + { PseudoVFMV_S_FPR32_MF2, VFMV_S_F }, // 1730 + { PseudoVFMV_S_FPR64_M1, VFMV_S_F }, // 1731 + { PseudoVFMV_S_FPR64_M2, VFMV_S_F }, // 1732 + { PseudoVFMV_S_FPR64_M4, VFMV_S_F }, // 1733 + { PseudoVFMV_S_FPR64_M8, VFMV_S_F }, // 1734 + { PseudoVFMV_V_FPR16_M1, VFMV_V_F }, // 1735 + { PseudoVFMV_V_FPR16_M2, VFMV_V_F }, // 1736 + { PseudoVFMV_V_FPR16_M4, VFMV_V_F }, // 1737 + { PseudoVFMV_V_FPR16_M8, VFMV_V_F }, // 1738 + { PseudoVFMV_V_FPR16_MF2, VFMV_V_F }, // 1739 + { PseudoVFMV_V_FPR16_MF4, VFMV_V_F }, // 1740 + { PseudoVFMV_V_FPR32_M1, VFMV_V_F }, // 1741 + { PseudoVFMV_V_FPR32_M2, VFMV_V_F }, // 1742 + { PseudoVFMV_V_FPR32_M4, VFMV_V_F }, // 1743 + { PseudoVFMV_V_FPR32_M8, VFMV_V_F }, // 1744 + { PseudoVFMV_V_FPR32_MF2, VFMV_V_F }, // 1745 + { PseudoVFMV_V_FPR64_M1, VFMV_V_F }, // 1746 + { PseudoVFMV_V_FPR64_M2, VFMV_V_F }, // 1747 + { PseudoVFMV_V_FPR64_M4, VFMV_V_F }, // 1748 + { PseudoVFMV_V_FPR64_M8, VFMV_V_F }, // 1749 + { PseudoVFNCVTBF16_F_F_W_M1, VFNCVTBF16_F_F_W }, // 1750 + { PseudoVFNCVTBF16_F_F_W_M1_MASK, VFNCVTBF16_F_F_W }, // 1751 + { PseudoVFNCVTBF16_F_F_W_M2, VFNCVTBF16_F_F_W }, // 1752 + { PseudoVFNCVTBF16_F_F_W_M2_MASK, VFNCVTBF16_F_F_W }, // 1753 + { PseudoVFNCVTBF16_F_F_W_M4, VFNCVTBF16_F_F_W }, // 1754 + { PseudoVFNCVTBF16_F_F_W_M4_MASK, VFNCVTBF16_F_F_W }, // 1755 + { PseudoVFNCVTBF16_F_F_W_MF2, VFNCVTBF16_F_F_W }, // 1756 + { PseudoVFNCVTBF16_F_F_W_MF2_MASK, VFNCVTBF16_F_F_W }, // 1757 + { PseudoVFNCVTBF16_F_F_W_MF4, VFNCVTBF16_F_F_W }, // 1758 + { PseudoVFNCVTBF16_F_F_W_MF4_MASK, VFNCVTBF16_F_F_W }, // 1759 + { PseudoVFNCVT_F_F_W_M1, VFNCVT_F_F_W }, // 1760 + { PseudoVFNCVT_F_F_W_M1_MASK, VFNCVT_F_F_W }, // 1761 + { PseudoVFNCVT_F_F_W_M2, VFNCVT_F_F_W }, // 1762 + { PseudoVFNCVT_F_F_W_M2_MASK, VFNCVT_F_F_W }, // 1763 + { PseudoVFNCVT_F_F_W_M4, VFNCVT_F_F_W }, // 1764 + { PseudoVFNCVT_F_F_W_M4_MASK, VFNCVT_F_F_W }, // 1765 + { PseudoVFNCVT_F_F_W_MF2, VFNCVT_F_F_W }, // 1766 + { PseudoVFNCVT_F_F_W_MF2_MASK, VFNCVT_F_F_W }, // 1767 + { PseudoVFNCVT_F_F_W_MF4, VFNCVT_F_F_W }, // 1768 + { PseudoVFNCVT_F_F_W_MF4_MASK, VFNCVT_F_F_W }, // 1769 + { PseudoVFNCVT_F_XU_W_M1, VFNCVT_F_XU_W }, // 1770 + { PseudoVFNCVT_F_XU_W_M1_MASK, VFNCVT_F_XU_W }, // 1771 + { PseudoVFNCVT_F_XU_W_M2, VFNCVT_F_XU_W }, // 1772 + { PseudoVFNCVT_F_XU_W_M2_MASK, VFNCVT_F_XU_W }, // 1773 + { PseudoVFNCVT_F_XU_W_M4, VFNCVT_F_XU_W }, // 1774 + { PseudoVFNCVT_F_XU_W_M4_MASK, VFNCVT_F_XU_W }, // 1775 + { PseudoVFNCVT_F_XU_W_MF2, VFNCVT_F_XU_W }, // 1776 + { PseudoVFNCVT_F_XU_W_MF2_MASK, VFNCVT_F_XU_W }, // 1777 + { PseudoVFNCVT_F_XU_W_MF4, VFNCVT_F_XU_W }, // 1778 + { PseudoVFNCVT_F_XU_W_MF4_MASK, VFNCVT_F_XU_W }, // 1779 + { PseudoVFNCVT_F_X_W_M1, VFNCVT_F_X_W }, // 1780 + { PseudoVFNCVT_F_X_W_M1_MASK, VFNCVT_F_X_W }, // 1781 + { PseudoVFNCVT_F_X_W_M2, VFNCVT_F_X_W }, // 1782 + { PseudoVFNCVT_F_X_W_M2_MASK, VFNCVT_F_X_W }, // 1783 + { PseudoVFNCVT_F_X_W_M4, VFNCVT_F_X_W }, // 1784 + { PseudoVFNCVT_F_X_W_M4_MASK, VFNCVT_F_X_W }, // 1785 + { PseudoVFNCVT_F_X_W_MF2, VFNCVT_F_X_W }, // 1786 + { PseudoVFNCVT_F_X_W_MF2_MASK, VFNCVT_F_X_W }, // 1787 + { PseudoVFNCVT_F_X_W_MF4, VFNCVT_F_X_W }, // 1788 + { PseudoVFNCVT_F_X_W_MF4_MASK, VFNCVT_F_X_W }, // 1789 + { PseudoVFNCVT_RM_F_XU_W_M1, VFNCVT_F_XU_W }, // 1790 + { PseudoVFNCVT_RM_F_XU_W_M1_MASK, VFNCVT_F_XU_W }, // 1791 + { PseudoVFNCVT_RM_F_XU_W_M2, VFNCVT_F_XU_W }, // 1792 + { PseudoVFNCVT_RM_F_XU_W_M2_MASK, VFNCVT_F_XU_W }, // 1793 + { PseudoVFNCVT_RM_F_XU_W_M4, VFNCVT_F_XU_W }, // 1794 + { PseudoVFNCVT_RM_F_XU_W_M4_MASK, VFNCVT_F_XU_W }, // 1795 + { PseudoVFNCVT_RM_F_XU_W_MF2, VFNCVT_F_XU_W }, // 1796 + { PseudoVFNCVT_RM_F_XU_W_MF2_MASK, VFNCVT_F_XU_W }, // 1797 + { PseudoVFNCVT_RM_F_XU_W_MF4, VFNCVT_F_XU_W }, // 1798 + { PseudoVFNCVT_RM_F_XU_W_MF4_MASK, VFNCVT_F_XU_W }, // 1799 + { PseudoVFNCVT_RM_F_X_W_M1, VFNCVT_F_X_W }, // 1800 + { PseudoVFNCVT_RM_F_X_W_M1_MASK, VFNCVT_F_X_W }, // 1801 + { PseudoVFNCVT_RM_F_X_W_M2, VFNCVT_F_X_W }, // 1802 + { PseudoVFNCVT_RM_F_X_W_M2_MASK, VFNCVT_F_X_W }, // 1803 + { PseudoVFNCVT_RM_F_X_W_M4, VFNCVT_F_X_W }, // 1804 + { PseudoVFNCVT_RM_F_X_W_M4_MASK, VFNCVT_F_X_W }, // 1805 + { PseudoVFNCVT_RM_F_X_W_MF2, VFNCVT_F_X_W }, // 1806 + { PseudoVFNCVT_RM_F_X_W_MF2_MASK, VFNCVT_F_X_W }, // 1807 + { PseudoVFNCVT_RM_F_X_W_MF4, VFNCVT_F_X_W }, // 1808 + { PseudoVFNCVT_RM_F_X_W_MF4_MASK, VFNCVT_F_X_W }, // 1809 + { PseudoVFNCVT_RM_XU_F_W_M1, VFNCVT_XU_F_W }, // 1810 + { PseudoVFNCVT_RM_XU_F_W_M1_MASK, VFNCVT_XU_F_W }, // 1811 + { PseudoVFNCVT_RM_XU_F_W_M2, VFNCVT_XU_F_W }, // 1812 + { PseudoVFNCVT_RM_XU_F_W_M2_MASK, VFNCVT_XU_F_W }, // 1813 + { PseudoVFNCVT_RM_XU_F_W_M4, VFNCVT_XU_F_W }, // 1814 + { PseudoVFNCVT_RM_XU_F_W_M4_MASK, VFNCVT_XU_F_W }, // 1815 + { PseudoVFNCVT_RM_XU_F_W_MF2, VFNCVT_XU_F_W }, // 1816 + { PseudoVFNCVT_RM_XU_F_W_MF2_MASK, VFNCVT_XU_F_W }, // 1817 + { PseudoVFNCVT_RM_XU_F_W_MF4, VFNCVT_XU_F_W }, // 1818 + { PseudoVFNCVT_RM_XU_F_W_MF4_MASK, VFNCVT_XU_F_W }, // 1819 + { PseudoVFNCVT_RM_XU_F_W_MF8, VFNCVT_XU_F_W }, // 1820 + { PseudoVFNCVT_RM_XU_F_W_MF8_MASK, VFNCVT_XU_F_W }, // 1821 + { PseudoVFNCVT_RM_X_F_W_M1, VFNCVT_X_F_W }, // 1822 + { PseudoVFNCVT_RM_X_F_W_M1_MASK, VFNCVT_X_F_W }, // 1823 + { PseudoVFNCVT_RM_X_F_W_M2, VFNCVT_X_F_W }, // 1824 + { PseudoVFNCVT_RM_X_F_W_M2_MASK, VFNCVT_X_F_W }, // 1825 + { PseudoVFNCVT_RM_X_F_W_M4, VFNCVT_X_F_W }, // 1826 + { PseudoVFNCVT_RM_X_F_W_M4_MASK, VFNCVT_X_F_W }, // 1827 + { PseudoVFNCVT_RM_X_F_W_MF2, VFNCVT_X_F_W }, // 1828 + { PseudoVFNCVT_RM_X_F_W_MF2_MASK, VFNCVT_X_F_W }, // 1829 + { PseudoVFNCVT_RM_X_F_W_MF4, VFNCVT_X_F_W }, // 1830 + { PseudoVFNCVT_RM_X_F_W_MF4_MASK, VFNCVT_X_F_W }, // 1831 + { PseudoVFNCVT_RM_X_F_W_MF8, VFNCVT_X_F_W }, // 1832 + { PseudoVFNCVT_RM_X_F_W_MF8_MASK, VFNCVT_X_F_W }, // 1833 + { PseudoVFNCVT_ROD_F_F_W_M1, VFNCVT_ROD_F_F_W }, // 1834 + { PseudoVFNCVT_ROD_F_F_W_M1_MASK, VFNCVT_ROD_F_F_W }, // 1835 + { PseudoVFNCVT_ROD_F_F_W_M2, VFNCVT_ROD_F_F_W }, // 1836 + { PseudoVFNCVT_ROD_F_F_W_M2_MASK, VFNCVT_ROD_F_F_W }, // 1837 + { PseudoVFNCVT_ROD_F_F_W_M4, VFNCVT_ROD_F_F_W }, // 1838 + { PseudoVFNCVT_ROD_F_F_W_M4_MASK, VFNCVT_ROD_F_F_W }, // 1839 + { PseudoVFNCVT_ROD_F_F_W_MF2, VFNCVT_ROD_F_F_W }, // 1840 + { PseudoVFNCVT_ROD_F_F_W_MF2_MASK, VFNCVT_ROD_F_F_W }, // 1841 + { PseudoVFNCVT_ROD_F_F_W_MF4, VFNCVT_ROD_F_F_W }, // 1842 + { PseudoVFNCVT_ROD_F_F_W_MF4_MASK, VFNCVT_ROD_F_F_W }, // 1843 + { PseudoVFNCVT_RTZ_XU_F_W_M1, VFNCVT_RTZ_XU_F_W }, // 1844 + { PseudoVFNCVT_RTZ_XU_F_W_M1_MASK, VFNCVT_RTZ_XU_F_W }, // 1845 + { PseudoVFNCVT_RTZ_XU_F_W_M2, VFNCVT_RTZ_XU_F_W }, // 1846 + { PseudoVFNCVT_RTZ_XU_F_W_M2_MASK, VFNCVT_RTZ_XU_F_W }, // 1847 + { PseudoVFNCVT_RTZ_XU_F_W_M4, VFNCVT_RTZ_XU_F_W }, // 1848 + { PseudoVFNCVT_RTZ_XU_F_W_M4_MASK, VFNCVT_RTZ_XU_F_W }, // 1849 + { PseudoVFNCVT_RTZ_XU_F_W_MF2, VFNCVT_RTZ_XU_F_W }, // 1850 + { PseudoVFNCVT_RTZ_XU_F_W_MF2_MASK, VFNCVT_RTZ_XU_F_W }, // 1851 + { PseudoVFNCVT_RTZ_XU_F_W_MF4, VFNCVT_RTZ_XU_F_W }, // 1852 + { PseudoVFNCVT_RTZ_XU_F_W_MF4_MASK, VFNCVT_RTZ_XU_F_W }, // 1853 + { PseudoVFNCVT_RTZ_XU_F_W_MF8, VFNCVT_RTZ_XU_F_W }, // 1854 + { PseudoVFNCVT_RTZ_XU_F_W_MF8_MASK, VFNCVT_RTZ_XU_F_W }, // 1855 + { PseudoVFNCVT_RTZ_X_F_W_M1, VFNCVT_RTZ_X_F_W }, // 1856 + { PseudoVFNCVT_RTZ_X_F_W_M1_MASK, VFNCVT_RTZ_X_F_W }, // 1857 + { PseudoVFNCVT_RTZ_X_F_W_M2, VFNCVT_RTZ_X_F_W }, // 1858 + { PseudoVFNCVT_RTZ_X_F_W_M2_MASK, VFNCVT_RTZ_X_F_W }, // 1859 + { PseudoVFNCVT_RTZ_X_F_W_M4, VFNCVT_RTZ_X_F_W }, // 1860 + { PseudoVFNCVT_RTZ_X_F_W_M4_MASK, VFNCVT_RTZ_X_F_W }, // 1861 + { PseudoVFNCVT_RTZ_X_F_W_MF2, VFNCVT_RTZ_X_F_W }, // 1862 + { PseudoVFNCVT_RTZ_X_F_W_MF2_MASK, VFNCVT_RTZ_X_F_W }, // 1863 + { PseudoVFNCVT_RTZ_X_F_W_MF4, VFNCVT_RTZ_X_F_W }, // 1864 + { PseudoVFNCVT_RTZ_X_F_W_MF4_MASK, VFNCVT_RTZ_X_F_W }, // 1865 + { PseudoVFNCVT_RTZ_X_F_W_MF8, VFNCVT_RTZ_X_F_W }, // 1866 + { PseudoVFNCVT_RTZ_X_F_W_MF8_MASK, VFNCVT_RTZ_X_F_W }, // 1867 + { PseudoVFNCVT_XU_F_W_M1, VFNCVT_XU_F_W }, // 1868 + { PseudoVFNCVT_XU_F_W_M1_MASK, VFNCVT_XU_F_W }, // 1869 + { PseudoVFNCVT_XU_F_W_M2, VFNCVT_XU_F_W }, // 1870 + { PseudoVFNCVT_XU_F_W_M2_MASK, VFNCVT_XU_F_W }, // 1871 + { PseudoVFNCVT_XU_F_W_M4, VFNCVT_XU_F_W }, // 1872 + { PseudoVFNCVT_XU_F_W_M4_MASK, VFNCVT_XU_F_W }, // 1873 + { PseudoVFNCVT_XU_F_W_MF2, VFNCVT_XU_F_W }, // 1874 + { PseudoVFNCVT_XU_F_W_MF2_MASK, VFNCVT_XU_F_W }, // 1875 + { PseudoVFNCVT_XU_F_W_MF4, VFNCVT_XU_F_W }, // 1876 + { PseudoVFNCVT_XU_F_W_MF4_MASK, VFNCVT_XU_F_W }, // 1877 + { PseudoVFNCVT_XU_F_W_MF8, VFNCVT_XU_F_W }, // 1878 + { PseudoVFNCVT_XU_F_W_MF8_MASK, VFNCVT_XU_F_W }, // 1879 + { PseudoVFNCVT_X_F_W_M1, VFNCVT_X_F_W }, // 1880 + { PseudoVFNCVT_X_F_W_M1_MASK, VFNCVT_X_F_W }, // 1881 + { PseudoVFNCVT_X_F_W_M2, VFNCVT_X_F_W }, // 1882 + { PseudoVFNCVT_X_F_W_M2_MASK, VFNCVT_X_F_W }, // 1883 + { PseudoVFNCVT_X_F_W_M4, VFNCVT_X_F_W }, // 1884 + { PseudoVFNCVT_X_F_W_M4_MASK, VFNCVT_X_F_W }, // 1885 + { PseudoVFNCVT_X_F_W_MF2, VFNCVT_X_F_W }, // 1886 + { PseudoVFNCVT_X_F_W_MF2_MASK, VFNCVT_X_F_W }, // 1887 + { PseudoVFNCVT_X_F_W_MF4, VFNCVT_X_F_W }, // 1888 + { PseudoVFNCVT_X_F_W_MF4_MASK, VFNCVT_X_F_W }, // 1889 + { PseudoVFNCVT_X_F_W_MF8, VFNCVT_X_F_W }, // 1890 + { PseudoVFNCVT_X_F_W_MF8_MASK, VFNCVT_X_F_W }, // 1891 + { PseudoVFNMACC_VFPR16_M1, VFNMACC_VF }, // 1892 + { PseudoVFNMACC_VFPR16_M1_MASK, VFNMACC_VF }, // 1893 + { PseudoVFNMACC_VFPR16_M2, VFNMACC_VF }, // 1894 + { PseudoVFNMACC_VFPR16_M2_MASK, VFNMACC_VF }, // 1895 + { PseudoVFNMACC_VFPR16_M4, VFNMACC_VF }, // 1896 + { PseudoVFNMACC_VFPR16_M4_MASK, VFNMACC_VF }, // 1897 + { PseudoVFNMACC_VFPR16_M8, VFNMACC_VF }, // 1898 + { PseudoVFNMACC_VFPR16_M8_MASK, VFNMACC_VF }, // 1899 + { PseudoVFNMACC_VFPR16_MF2, VFNMACC_VF }, // 1900 + { PseudoVFNMACC_VFPR16_MF2_MASK, VFNMACC_VF }, // 1901 + { PseudoVFNMACC_VFPR16_MF4, VFNMACC_VF }, // 1902 + { PseudoVFNMACC_VFPR16_MF4_MASK, VFNMACC_VF }, // 1903 + { PseudoVFNMACC_VFPR32_M1, VFNMACC_VF }, // 1904 + { PseudoVFNMACC_VFPR32_M1_MASK, VFNMACC_VF }, // 1905 + { PseudoVFNMACC_VFPR32_M2, VFNMACC_VF }, // 1906 + { PseudoVFNMACC_VFPR32_M2_MASK, VFNMACC_VF }, // 1907 + { PseudoVFNMACC_VFPR32_M4, VFNMACC_VF }, // 1908 + { PseudoVFNMACC_VFPR32_M4_MASK, VFNMACC_VF }, // 1909 + { PseudoVFNMACC_VFPR32_M8, VFNMACC_VF }, // 1910 + { PseudoVFNMACC_VFPR32_M8_MASK, VFNMACC_VF }, // 1911 + { PseudoVFNMACC_VFPR32_MF2, VFNMACC_VF }, // 1912 + { PseudoVFNMACC_VFPR32_MF2_MASK, VFNMACC_VF }, // 1913 + { PseudoVFNMACC_VFPR64_M1, VFNMACC_VF }, // 1914 + { PseudoVFNMACC_VFPR64_M1_MASK, VFNMACC_VF }, // 1915 + { PseudoVFNMACC_VFPR64_M2, VFNMACC_VF }, // 1916 + { PseudoVFNMACC_VFPR64_M2_MASK, VFNMACC_VF }, // 1917 + { PseudoVFNMACC_VFPR64_M4, VFNMACC_VF }, // 1918 + { PseudoVFNMACC_VFPR64_M4_MASK, VFNMACC_VF }, // 1919 + { PseudoVFNMACC_VFPR64_M8, VFNMACC_VF }, // 1920 + { PseudoVFNMACC_VFPR64_M8_MASK, VFNMACC_VF }, // 1921 + { PseudoVFNMACC_VV_M1, VFNMACC_VV }, // 1922 + { PseudoVFNMACC_VV_M1_MASK, VFNMACC_VV }, // 1923 + { PseudoVFNMACC_VV_M2, VFNMACC_VV }, // 1924 + { PseudoVFNMACC_VV_M2_MASK, VFNMACC_VV }, // 1925 + { PseudoVFNMACC_VV_M4, VFNMACC_VV }, // 1926 + { PseudoVFNMACC_VV_M4_MASK, VFNMACC_VV }, // 1927 + { PseudoVFNMACC_VV_M8, VFNMACC_VV }, // 1928 + { PseudoVFNMACC_VV_M8_MASK, VFNMACC_VV }, // 1929 + { PseudoVFNMACC_VV_MF2, VFNMACC_VV }, // 1930 + { PseudoVFNMACC_VV_MF2_MASK, VFNMACC_VV }, // 1931 + { PseudoVFNMACC_VV_MF4, VFNMACC_VV }, // 1932 + { PseudoVFNMACC_VV_MF4_MASK, VFNMACC_VV }, // 1933 + { PseudoVFNMADD_VFPR16_M1, VFNMADD_VF }, // 1934 + { PseudoVFNMADD_VFPR16_M1_MASK, VFNMADD_VF }, // 1935 + { PseudoVFNMADD_VFPR16_M2, VFNMADD_VF }, // 1936 + { PseudoVFNMADD_VFPR16_M2_MASK, VFNMADD_VF }, // 1937 + { PseudoVFNMADD_VFPR16_M4, VFNMADD_VF }, // 1938 + { PseudoVFNMADD_VFPR16_M4_MASK, VFNMADD_VF }, // 1939 + { PseudoVFNMADD_VFPR16_M8, VFNMADD_VF }, // 1940 + { PseudoVFNMADD_VFPR16_M8_MASK, VFNMADD_VF }, // 1941 + { PseudoVFNMADD_VFPR16_MF2, VFNMADD_VF }, // 1942 + { PseudoVFNMADD_VFPR16_MF2_MASK, VFNMADD_VF }, // 1943 + { PseudoVFNMADD_VFPR16_MF4, VFNMADD_VF }, // 1944 + { PseudoVFNMADD_VFPR16_MF4_MASK, VFNMADD_VF }, // 1945 + { PseudoVFNMADD_VFPR32_M1, VFNMADD_VF }, // 1946 + { PseudoVFNMADD_VFPR32_M1_MASK, VFNMADD_VF }, // 1947 + { PseudoVFNMADD_VFPR32_M2, VFNMADD_VF }, // 1948 + { PseudoVFNMADD_VFPR32_M2_MASK, VFNMADD_VF }, // 1949 + { PseudoVFNMADD_VFPR32_M4, VFNMADD_VF }, // 1950 + { PseudoVFNMADD_VFPR32_M4_MASK, VFNMADD_VF }, // 1951 + { PseudoVFNMADD_VFPR32_M8, VFNMADD_VF }, // 1952 + { PseudoVFNMADD_VFPR32_M8_MASK, VFNMADD_VF }, // 1953 + { PseudoVFNMADD_VFPR32_MF2, VFNMADD_VF }, // 1954 + { PseudoVFNMADD_VFPR32_MF2_MASK, VFNMADD_VF }, // 1955 + { PseudoVFNMADD_VFPR64_M1, VFNMADD_VF }, // 1956 + { PseudoVFNMADD_VFPR64_M1_MASK, VFNMADD_VF }, // 1957 + { PseudoVFNMADD_VFPR64_M2, VFNMADD_VF }, // 1958 + { PseudoVFNMADD_VFPR64_M2_MASK, VFNMADD_VF }, // 1959 + { PseudoVFNMADD_VFPR64_M4, VFNMADD_VF }, // 1960 + { PseudoVFNMADD_VFPR64_M4_MASK, VFNMADD_VF }, // 1961 + { PseudoVFNMADD_VFPR64_M8, VFNMADD_VF }, // 1962 + { PseudoVFNMADD_VFPR64_M8_MASK, VFNMADD_VF }, // 1963 + { PseudoVFNMADD_VV_M1, VFNMADD_VV }, // 1964 + { PseudoVFNMADD_VV_M1_MASK, VFNMADD_VV }, // 1965 + { PseudoVFNMADD_VV_M2, VFNMADD_VV }, // 1966 + { PseudoVFNMADD_VV_M2_MASK, VFNMADD_VV }, // 1967 + { PseudoVFNMADD_VV_M4, VFNMADD_VV }, // 1968 + { PseudoVFNMADD_VV_M4_MASK, VFNMADD_VV }, // 1969 + { PseudoVFNMADD_VV_M8, VFNMADD_VV }, // 1970 + { PseudoVFNMADD_VV_M8_MASK, VFNMADD_VV }, // 1971 + { PseudoVFNMADD_VV_MF2, VFNMADD_VV }, // 1972 + { PseudoVFNMADD_VV_MF2_MASK, VFNMADD_VV }, // 1973 + { PseudoVFNMADD_VV_MF4, VFNMADD_VV }, // 1974 + { PseudoVFNMADD_VV_MF4_MASK, VFNMADD_VV }, // 1975 + { PseudoVFNMSAC_VFPR16_M1, VFNMSAC_VF }, // 1976 + { PseudoVFNMSAC_VFPR16_M1_MASK, VFNMSAC_VF }, // 1977 + { PseudoVFNMSAC_VFPR16_M2, VFNMSAC_VF }, // 1978 + { PseudoVFNMSAC_VFPR16_M2_MASK, VFNMSAC_VF }, // 1979 + { PseudoVFNMSAC_VFPR16_M4, VFNMSAC_VF }, // 1980 + { PseudoVFNMSAC_VFPR16_M4_MASK, VFNMSAC_VF }, // 1981 + { PseudoVFNMSAC_VFPR16_M8, VFNMSAC_VF }, // 1982 + { PseudoVFNMSAC_VFPR16_M8_MASK, VFNMSAC_VF }, // 1983 + { PseudoVFNMSAC_VFPR16_MF2, VFNMSAC_VF }, // 1984 + { PseudoVFNMSAC_VFPR16_MF2_MASK, VFNMSAC_VF }, // 1985 + { PseudoVFNMSAC_VFPR16_MF4, VFNMSAC_VF }, // 1986 + { PseudoVFNMSAC_VFPR16_MF4_MASK, VFNMSAC_VF }, // 1987 + { PseudoVFNMSAC_VFPR32_M1, VFNMSAC_VF }, // 1988 + { PseudoVFNMSAC_VFPR32_M1_MASK, VFNMSAC_VF }, // 1989 + { PseudoVFNMSAC_VFPR32_M2, VFNMSAC_VF }, // 1990 + { PseudoVFNMSAC_VFPR32_M2_MASK, VFNMSAC_VF }, // 1991 + { PseudoVFNMSAC_VFPR32_M4, VFNMSAC_VF }, // 1992 + { PseudoVFNMSAC_VFPR32_M4_MASK, VFNMSAC_VF }, // 1993 + { PseudoVFNMSAC_VFPR32_M8, VFNMSAC_VF }, // 1994 + { PseudoVFNMSAC_VFPR32_M8_MASK, VFNMSAC_VF }, // 1995 + { PseudoVFNMSAC_VFPR32_MF2, VFNMSAC_VF }, // 1996 + { PseudoVFNMSAC_VFPR32_MF2_MASK, VFNMSAC_VF }, // 1997 + { PseudoVFNMSAC_VFPR64_M1, VFNMSAC_VF }, // 1998 + { PseudoVFNMSAC_VFPR64_M1_MASK, VFNMSAC_VF }, // 1999 + { PseudoVFNMSAC_VFPR64_M2, VFNMSAC_VF }, // 2000 + { PseudoVFNMSAC_VFPR64_M2_MASK, VFNMSAC_VF }, // 2001 + { PseudoVFNMSAC_VFPR64_M4, VFNMSAC_VF }, // 2002 + { PseudoVFNMSAC_VFPR64_M4_MASK, VFNMSAC_VF }, // 2003 + { PseudoVFNMSAC_VFPR64_M8, VFNMSAC_VF }, // 2004 + { PseudoVFNMSAC_VFPR64_M8_MASK, VFNMSAC_VF }, // 2005 + { PseudoVFNMSAC_VV_M1, VFNMSAC_VV }, // 2006 + { PseudoVFNMSAC_VV_M1_MASK, VFNMSAC_VV }, // 2007 + { PseudoVFNMSAC_VV_M2, VFNMSAC_VV }, // 2008 + { PseudoVFNMSAC_VV_M2_MASK, VFNMSAC_VV }, // 2009 + { PseudoVFNMSAC_VV_M4, VFNMSAC_VV }, // 2010 + { PseudoVFNMSAC_VV_M4_MASK, VFNMSAC_VV }, // 2011 + { PseudoVFNMSAC_VV_M8, VFNMSAC_VV }, // 2012 + { PseudoVFNMSAC_VV_M8_MASK, VFNMSAC_VV }, // 2013 + { PseudoVFNMSAC_VV_MF2, VFNMSAC_VV }, // 2014 + { PseudoVFNMSAC_VV_MF2_MASK, VFNMSAC_VV }, // 2015 + { PseudoVFNMSAC_VV_MF4, VFNMSAC_VV }, // 2016 + { PseudoVFNMSAC_VV_MF4_MASK, VFNMSAC_VV }, // 2017 + { PseudoVFNMSUB_VFPR16_M1, VFNMSUB_VF }, // 2018 + { PseudoVFNMSUB_VFPR16_M1_MASK, VFNMSUB_VF }, // 2019 + { PseudoVFNMSUB_VFPR16_M2, VFNMSUB_VF }, // 2020 + { PseudoVFNMSUB_VFPR16_M2_MASK, VFNMSUB_VF }, // 2021 + { PseudoVFNMSUB_VFPR16_M4, VFNMSUB_VF }, // 2022 + { PseudoVFNMSUB_VFPR16_M4_MASK, VFNMSUB_VF }, // 2023 + { PseudoVFNMSUB_VFPR16_M8, VFNMSUB_VF }, // 2024 + { PseudoVFNMSUB_VFPR16_M8_MASK, VFNMSUB_VF }, // 2025 + { PseudoVFNMSUB_VFPR16_MF2, VFNMSUB_VF }, // 2026 + { PseudoVFNMSUB_VFPR16_MF2_MASK, VFNMSUB_VF }, // 2027 + { PseudoVFNMSUB_VFPR16_MF4, VFNMSUB_VF }, // 2028 + { PseudoVFNMSUB_VFPR16_MF4_MASK, VFNMSUB_VF }, // 2029 + { PseudoVFNMSUB_VFPR32_M1, VFNMSUB_VF }, // 2030 + { PseudoVFNMSUB_VFPR32_M1_MASK, VFNMSUB_VF }, // 2031 + { PseudoVFNMSUB_VFPR32_M2, VFNMSUB_VF }, // 2032 + { PseudoVFNMSUB_VFPR32_M2_MASK, VFNMSUB_VF }, // 2033 + { PseudoVFNMSUB_VFPR32_M4, VFNMSUB_VF }, // 2034 + { PseudoVFNMSUB_VFPR32_M4_MASK, VFNMSUB_VF }, // 2035 + { PseudoVFNMSUB_VFPR32_M8, VFNMSUB_VF }, // 2036 + { PseudoVFNMSUB_VFPR32_M8_MASK, VFNMSUB_VF }, // 2037 + { PseudoVFNMSUB_VFPR32_MF2, VFNMSUB_VF }, // 2038 + { PseudoVFNMSUB_VFPR32_MF2_MASK, VFNMSUB_VF }, // 2039 + { PseudoVFNMSUB_VFPR64_M1, VFNMSUB_VF }, // 2040 + { PseudoVFNMSUB_VFPR64_M1_MASK, VFNMSUB_VF }, // 2041 + { PseudoVFNMSUB_VFPR64_M2, VFNMSUB_VF }, // 2042 + { PseudoVFNMSUB_VFPR64_M2_MASK, VFNMSUB_VF }, // 2043 + { PseudoVFNMSUB_VFPR64_M4, VFNMSUB_VF }, // 2044 + { PseudoVFNMSUB_VFPR64_M4_MASK, VFNMSUB_VF }, // 2045 + { PseudoVFNMSUB_VFPR64_M8, VFNMSUB_VF }, // 2046 + { PseudoVFNMSUB_VFPR64_M8_MASK, VFNMSUB_VF }, // 2047 + { PseudoVFNMSUB_VV_M1, VFNMSUB_VV }, // 2048 + { PseudoVFNMSUB_VV_M1_MASK, VFNMSUB_VV }, // 2049 + { PseudoVFNMSUB_VV_M2, VFNMSUB_VV }, // 2050 + { PseudoVFNMSUB_VV_M2_MASK, VFNMSUB_VV }, // 2051 + { PseudoVFNMSUB_VV_M4, VFNMSUB_VV }, // 2052 + { PseudoVFNMSUB_VV_M4_MASK, VFNMSUB_VV }, // 2053 + { PseudoVFNMSUB_VV_M8, VFNMSUB_VV }, // 2054 + { PseudoVFNMSUB_VV_M8_MASK, VFNMSUB_VV }, // 2055 + { PseudoVFNMSUB_VV_MF2, VFNMSUB_VV }, // 2056 + { PseudoVFNMSUB_VV_MF2_MASK, VFNMSUB_VV }, // 2057 + { PseudoVFNMSUB_VV_MF4, VFNMSUB_VV }, // 2058 + { PseudoVFNMSUB_VV_MF4_MASK, VFNMSUB_VV }, // 2059 + { PseudoVFNRCLIP_XU_F_QF_M1, VFNRCLIP_XU_F_QF }, // 2060 + { PseudoVFNRCLIP_XU_F_QF_M1_MASK, VFNRCLIP_XU_F_QF }, // 2061 + { PseudoVFNRCLIP_XU_F_QF_M2, VFNRCLIP_XU_F_QF }, // 2062 + { PseudoVFNRCLIP_XU_F_QF_M2_MASK, VFNRCLIP_XU_F_QF }, // 2063 + { PseudoVFNRCLIP_XU_F_QF_MF2, VFNRCLIP_XU_F_QF }, // 2064 + { PseudoVFNRCLIP_XU_F_QF_MF2_MASK, VFNRCLIP_XU_F_QF }, // 2065 + { PseudoVFNRCLIP_XU_F_QF_MF4, VFNRCLIP_XU_F_QF }, // 2066 + { PseudoVFNRCLIP_XU_F_QF_MF4_MASK, VFNRCLIP_XU_F_QF }, // 2067 + { PseudoVFNRCLIP_XU_F_QF_MF8, VFNRCLIP_XU_F_QF }, // 2068 + { PseudoVFNRCLIP_XU_F_QF_MF8_MASK, VFNRCLIP_XU_F_QF }, // 2069 + { PseudoVFNRCLIP_X_F_QF_M1, VFNRCLIP_X_F_QF }, // 2070 + { PseudoVFNRCLIP_X_F_QF_M1_MASK, VFNRCLIP_X_F_QF }, // 2071 + { PseudoVFNRCLIP_X_F_QF_M2, VFNRCLIP_X_F_QF }, // 2072 + { PseudoVFNRCLIP_X_F_QF_M2_MASK, VFNRCLIP_X_F_QF }, // 2073 + { PseudoVFNRCLIP_X_F_QF_MF2, VFNRCLIP_X_F_QF }, // 2074 + { PseudoVFNRCLIP_X_F_QF_MF2_MASK, VFNRCLIP_X_F_QF }, // 2075 + { PseudoVFNRCLIP_X_F_QF_MF4, VFNRCLIP_X_F_QF }, // 2076 + { PseudoVFNRCLIP_X_F_QF_MF4_MASK, VFNRCLIP_X_F_QF }, // 2077 + { PseudoVFNRCLIP_X_F_QF_MF8, VFNRCLIP_X_F_QF }, // 2078 + { PseudoVFNRCLIP_X_F_QF_MF8_MASK, VFNRCLIP_X_F_QF }, // 2079 + { PseudoVFRDIV_VFPR16_M1_E16, VFRDIV_VF }, // 2080 + { PseudoVFRDIV_VFPR16_M1_E16_MASK, VFRDIV_VF }, // 2081 + { PseudoVFRDIV_VFPR16_M2_E16, VFRDIV_VF }, // 2082 + { PseudoVFRDIV_VFPR16_M2_E16_MASK, VFRDIV_VF }, // 2083 + { PseudoVFRDIV_VFPR16_M4_E16, VFRDIV_VF }, // 2084 + { PseudoVFRDIV_VFPR16_M4_E16_MASK, VFRDIV_VF }, // 2085 + { PseudoVFRDIV_VFPR16_M8_E16, VFRDIV_VF }, // 2086 + { PseudoVFRDIV_VFPR16_M8_E16_MASK, VFRDIV_VF }, // 2087 + { PseudoVFRDIV_VFPR16_MF2_E16, VFRDIV_VF }, // 2088 + { PseudoVFRDIV_VFPR16_MF2_E16_MASK, VFRDIV_VF }, // 2089 + { PseudoVFRDIV_VFPR16_MF4_E16, VFRDIV_VF }, // 2090 + { PseudoVFRDIV_VFPR16_MF4_E16_MASK, VFRDIV_VF }, // 2091 + { PseudoVFRDIV_VFPR32_M1_E32, VFRDIV_VF }, // 2092 + { PseudoVFRDIV_VFPR32_M1_E32_MASK, VFRDIV_VF }, // 2093 + { PseudoVFRDIV_VFPR32_M2_E32, VFRDIV_VF }, // 2094 + { PseudoVFRDIV_VFPR32_M2_E32_MASK, VFRDIV_VF }, // 2095 + { PseudoVFRDIV_VFPR32_M4_E32, VFRDIV_VF }, // 2096 + { PseudoVFRDIV_VFPR32_M4_E32_MASK, VFRDIV_VF }, // 2097 + { PseudoVFRDIV_VFPR32_M8_E32, VFRDIV_VF }, // 2098 + { PseudoVFRDIV_VFPR32_M8_E32_MASK, VFRDIV_VF }, // 2099 + { PseudoVFRDIV_VFPR32_MF2_E32, VFRDIV_VF }, // 2100 + { PseudoVFRDIV_VFPR32_MF2_E32_MASK, VFRDIV_VF }, // 2101 + { PseudoVFRDIV_VFPR64_M1_E64, VFRDIV_VF }, // 2102 + { PseudoVFRDIV_VFPR64_M1_E64_MASK, VFRDIV_VF }, // 2103 + { PseudoVFRDIV_VFPR64_M2_E64, VFRDIV_VF }, // 2104 + { PseudoVFRDIV_VFPR64_M2_E64_MASK, VFRDIV_VF }, // 2105 + { PseudoVFRDIV_VFPR64_M4_E64, VFRDIV_VF }, // 2106 + { PseudoVFRDIV_VFPR64_M4_E64_MASK, VFRDIV_VF }, // 2107 + { PseudoVFRDIV_VFPR64_M8_E64, VFRDIV_VF }, // 2108 + { PseudoVFRDIV_VFPR64_M8_E64_MASK, VFRDIV_VF }, // 2109 + { PseudoVFREC7_V_M1, VFREC7_V }, // 2110 + { PseudoVFREC7_V_M1_MASK, VFREC7_V }, // 2111 + { PseudoVFREC7_V_M2, VFREC7_V }, // 2112 + { PseudoVFREC7_V_M2_MASK, VFREC7_V }, // 2113 + { PseudoVFREC7_V_M4, VFREC7_V }, // 2114 + { PseudoVFREC7_V_M4_MASK, VFREC7_V }, // 2115 + { PseudoVFREC7_V_M8, VFREC7_V }, // 2116 + { PseudoVFREC7_V_M8_MASK, VFREC7_V }, // 2117 + { PseudoVFREC7_V_MF2, VFREC7_V }, // 2118 + { PseudoVFREC7_V_MF2_MASK, VFREC7_V }, // 2119 + { PseudoVFREC7_V_MF4, VFREC7_V }, // 2120 + { PseudoVFREC7_V_MF4_MASK, VFREC7_V }, // 2121 + { PseudoVFREDMAX_VS_M1_E16, VFREDMAX_VS }, // 2122 + { PseudoVFREDMAX_VS_M1_E16_MASK, VFREDMAX_VS }, // 2123 + { PseudoVFREDMAX_VS_M1_E32, VFREDMAX_VS }, // 2124 + { PseudoVFREDMAX_VS_M1_E32_MASK, VFREDMAX_VS }, // 2125 + { PseudoVFREDMAX_VS_M1_E64, VFREDMAX_VS }, // 2126 + { PseudoVFREDMAX_VS_M1_E64_MASK, VFREDMAX_VS }, // 2127 + { PseudoVFREDMAX_VS_M2_E16, VFREDMAX_VS }, // 2128 + { PseudoVFREDMAX_VS_M2_E16_MASK, VFREDMAX_VS }, // 2129 + { PseudoVFREDMAX_VS_M2_E32, VFREDMAX_VS }, // 2130 + { PseudoVFREDMAX_VS_M2_E32_MASK, VFREDMAX_VS }, // 2131 + { PseudoVFREDMAX_VS_M2_E64, VFREDMAX_VS }, // 2132 + { PseudoVFREDMAX_VS_M2_E64_MASK, VFREDMAX_VS }, // 2133 + { PseudoVFREDMAX_VS_M4_E16, VFREDMAX_VS }, // 2134 + { PseudoVFREDMAX_VS_M4_E16_MASK, VFREDMAX_VS }, // 2135 + { PseudoVFREDMAX_VS_M4_E32, VFREDMAX_VS }, // 2136 + { PseudoVFREDMAX_VS_M4_E32_MASK, VFREDMAX_VS }, // 2137 + { PseudoVFREDMAX_VS_M4_E64, VFREDMAX_VS }, // 2138 + { PseudoVFREDMAX_VS_M4_E64_MASK, VFREDMAX_VS }, // 2139 + { PseudoVFREDMAX_VS_M8_E16, VFREDMAX_VS }, // 2140 + { PseudoVFREDMAX_VS_M8_E16_MASK, VFREDMAX_VS }, // 2141 + { PseudoVFREDMAX_VS_M8_E32, VFREDMAX_VS }, // 2142 + { PseudoVFREDMAX_VS_M8_E32_MASK, VFREDMAX_VS }, // 2143 + { PseudoVFREDMAX_VS_M8_E64, VFREDMAX_VS }, // 2144 + { PseudoVFREDMAX_VS_M8_E64_MASK, VFREDMAX_VS }, // 2145 + { PseudoVFREDMAX_VS_MF2_E16, VFREDMAX_VS }, // 2146 + { PseudoVFREDMAX_VS_MF2_E16_MASK, VFREDMAX_VS }, // 2147 + { PseudoVFREDMAX_VS_MF2_E32, VFREDMAX_VS }, // 2148 + { PseudoVFREDMAX_VS_MF2_E32_MASK, VFREDMAX_VS }, // 2149 + { PseudoVFREDMAX_VS_MF4_E16, VFREDMAX_VS }, // 2150 + { PseudoVFREDMAX_VS_MF4_E16_MASK, VFREDMAX_VS }, // 2151 + { PseudoVFREDMIN_VS_M1_E16, VFREDMIN_VS }, // 2152 + { PseudoVFREDMIN_VS_M1_E16_MASK, VFREDMIN_VS }, // 2153 + { PseudoVFREDMIN_VS_M1_E32, VFREDMIN_VS }, // 2154 + { PseudoVFREDMIN_VS_M1_E32_MASK, VFREDMIN_VS }, // 2155 + { PseudoVFREDMIN_VS_M1_E64, VFREDMIN_VS }, // 2156 + { PseudoVFREDMIN_VS_M1_E64_MASK, VFREDMIN_VS }, // 2157 + { PseudoVFREDMIN_VS_M2_E16, VFREDMIN_VS }, // 2158 + { PseudoVFREDMIN_VS_M2_E16_MASK, VFREDMIN_VS }, // 2159 + { PseudoVFREDMIN_VS_M2_E32, VFREDMIN_VS }, // 2160 + { PseudoVFREDMIN_VS_M2_E32_MASK, VFREDMIN_VS }, // 2161 + { PseudoVFREDMIN_VS_M2_E64, VFREDMIN_VS }, // 2162 + { PseudoVFREDMIN_VS_M2_E64_MASK, VFREDMIN_VS }, // 2163 + { PseudoVFREDMIN_VS_M4_E16, VFREDMIN_VS }, // 2164 + { PseudoVFREDMIN_VS_M4_E16_MASK, VFREDMIN_VS }, // 2165 + { PseudoVFREDMIN_VS_M4_E32, VFREDMIN_VS }, // 2166 + { PseudoVFREDMIN_VS_M4_E32_MASK, VFREDMIN_VS }, // 2167 + { PseudoVFREDMIN_VS_M4_E64, VFREDMIN_VS }, // 2168 + { PseudoVFREDMIN_VS_M4_E64_MASK, VFREDMIN_VS }, // 2169 + { PseudoVFREDMIN_VS_M8_E16, VFREDMIN_VS }, // 2170 + { PseudoVFREDMIN_VS_M8_E16_MASK, VFREDMIN_VS }, // 2171 + { PseudoVFREDMIN_VS_M8_E32, VFREDMIN_VS }, // 2172 + { PseudoVFREDMIN_VS_M8_E32_MASK, VFREDMIN_VS }, // 2173 + { PseudoVFREDMIN_VS_M8_E64, VFREDMIN_VS }, // 2174 + { PseudoVFREDMIN_VS_M8_E64_MASK, VFREDMIN_VS }, // 2175 + { PseudoVFREDMIN_VS_MF2_E16, VFREDMIN_VS }, // 2176 + { PseudoVFREDMIN_VS_MF2_E16_MASK, VFREDMIN_VS }, // 2177 + { PseudoVFREDMIN_VS_MF2_E32, VFREDMIN_VS }, // 2178 + { PseudoVFREDMIN_VS_MF2_E32_MASK, VFREDMIN_VS }, // 2179 + { PseudoVFREDMIN_VS_MF4_E16, VFREDMIN_VS }, // 2180 + { PseudoVFREDMIN_VS_MF4_E16_MASK, VFREDMIN_VS }, // 2181 + { PseudoVFREDOSUM_VS_M1_E16, VFREDOSUM_VS }, // 2182 + { PseudoVFREDOSUM_VS_M1_E16_MASK, VFREDOSUM_VS }, // 2183 + { PseudoVFREDOSUM_VS_M1_E32, VFREDOSUM_VS }, // 2184 + { PseudoVFREDOSUM_VS_M1_E32_MASK, VFREDOSUM_VS }, // 2185 + { PseudoVFREDOSUM_VS_M1_E64, VFREDOSUM_VS }, // 2186 + { PseudoVFREDOSUM_VS_M1_E64_MASK, VFREDOSUM_VS }, // 2187 + { PseudoVFREDOSUM_VS_M2_E16, VFREDOSUM_VS }, // 2188 + { PseudoVFREDOSUM_VS_M2_E16_MASK, VFREDOSUM_VS }, // 2189 + { PseudoVFREDOSUM_VS_M2_E32, VFREDOSUM_VS }, // 2190 + { PseudoVFREDOSUM_VS_M2_E32_MASK, VFREDOSUM_VS }, // 2191 + { PseudoVFREDOSUM_VS_M2_E64, VFREDOSUM_VS }, // 2192 + { PseudoVFREDOSUM_VS_M2_E64_MASK, VFREDOSUM_VS }, // 2193 + { PseudoVFREDOSUM_VS_M4_E16, VFREDOSUM_VS }, // 2194 + { PseudoVFREDOSUM_VS_M4_E16_MASK, VFREDOSUM_VS }, // 2195 + { PseudoVFREDOSUM_VS_M4_E32, VFREDOSUM_VS }, // 2196 + { PseudoVFREDOSUM_VS_M4_E32_MASK, VFREDOSUM_VS }, // 2197 + { PseudoVFREDOSUM_VS_M4_E64, VFREDOSUM_VS }, // 2198 + { PseudoVFREDOSUM_VS_M4_E64_MASK, VFREDOSUM_VS }, // 2199 + { PseudoVFREDOSUM_VS_M8_E16, VFREDOSUM_VS }, // 2200 + { PseudoVFREDOSUM_VS_M8_E16_MASK, VFREDOSUM_VS }, // 2201 + { PseudoVFREDOSUM_VS_M8_E32, VFREDOSUM_VS }, // 2202 + { PseudoVFREDOSUM_VS_M8_E32_MASK, VFREDOSUM_VS }, // 2203 + { PseudoVFREDOSUM_VS_M8_E64, VFREDOSUM_VS }, // 2204 + { PseudoVFREDOSUM_VS_M8_E64_MASK, VFREDOSUM_VS }, // 2205 + { PseudoVFREDOSUM_VS_MF2_E16, VFREDOSUM_VS }, // 2206 + { PseudoVFREDOSUM_VS_MF2_E16_MASK, VFREDOSUM_VS }, // 2207 + { PseudoVFREDOSUM_VS_MF2_E32, VFREDOSUM_VS }, // 2208 + { PseudoVFREDOSUM_VS_MF2_E32_MASK, VFREDOSUM_VS }, // 2209 + { PseudoVFREDOSUM_VS_MF4_E16, VFREDOSUM_VS }, // 2210 + { PseudoVFREDOSUM_VS_MF4_E16_MASK, VFREDOSUM_VS }, // 2211 + { PseudoVFREDUSUM_VS_M1_E16, VFREDUSUM_VS }, // 2212 + { PseudoVFREDUSUM_VS_M1_E16_MASK, VFREDUSUM_VS }, // 2213 + { PseudoVFREDUSUM_VS_M1_E32, VFREDUSUM_VS }, // 2214 + { PseudoVFREDUSUM_VS_M1_E32_MASK, VFREDUSUM_VS }, // 2215 + { PseudoVFREDUSUM_VS_M1_E64, VFREDUSUM_VS }, // 2216 + { PseudoVFREDUSUM_VS_M1_E64_MASK, VFREDUSUM_VS }, // 2217 + { PseudoVFREDUSUM_VS_M2_E16, VFREDUSUM_VS }, // 2218 + { PseudoVFREDUSUM_VS_M2_E16_MASK, VFREDUSUM_VS }, // 2219 + { PseudoVFREDUSUM_VS_M2_E32, VFREDUSUM_VS }, // 2220 + { PseudoVFREDUSUM_VS_M2_E32_MASK, VFREDUSUM_VS }, // 2221 + { PseudoVFREDUSUM_VS_M2_E64, VFREDUSUM_VS }, // 2222 + { PseudoVFREDUSUM_VS_M2_E64_MASK, VFREDUSUM_VS }, // 2223 + { PseudoVFREDUSUM_VS_M4_E16, VFREDUSUM_VS }, // 2224 + { PseudoVFREDUSUM_VS_M4_E16_MASK, VFREDUSUM_VS }, // 2225 + { PseudoVFREDUSUM_VS_M4_E32, VFREDUSUM_VS }, // 2226 + { PseudoVFREDUSUM_VS_M4_E32_MASK, VFREDUSUM_VS }, // 2227 + { PseudoVFREDUSUM_VS_M4_E64, VFREDUSUM_VS }, // 2228 + { PseudoVFREDUSUM_VS_M4_E64_MASK, VFREDUSUM_VS }, // 2229 + { PseudoVFREDUSUM_VS_M8_E16, VFREDUSUM_VS }, // 2230 + { PseudoVFREDUSUM_VS_M8_E16_MASK, VFREDUSUM_VS }, // 2231 + { PseudoVFREDUSUM_VS_M8_E32, VFREDUSUM_VS }, // 2232 + { PseudoVFREDUSUM_VS_M8_E32_MASK, VFREDUSUM_VS }, // 2233 + { PseudoVFREDUSUM_VS_M8_E64, VFREDUSUM_VS }, // 2234 + { PseudoVFREDUSUM_VS_M8_E64_MASK, VFREDUSUM_VS }, // 2235 + { PseudoVFREDUSUM_VS_MF2_E16, VFREDUSUM_VS }, // 2236 + { PseudoVFREDUSUM_VS_MF2_E16_MASK, VFREDUSUM_VS }, // 2237 + { PseudoVFREDUSUM_VS_MF2_E32, VFREDUSUM_VS }, // 2238 + { PseudoVFREDUSUM_VS_MF2_E32_MASK, VFREDUSUM_VS }, // 2239 + { PseudoVFREDUSUM_VS_MF4_E16, VFREDUSUM_VS }, // 2240 + { PseudoVFREDUSUM_VS_MF4_E16_MASK, VFREDUSUM_VS }, // 2241 + { PseudoVFRSQRT7_V_M1, VFRSQRT7_V }, // 2242 + { PseudoVFRSQRT7_V_M1_MASK, VFRSQRT7_V }, // 2243 + { PseudoVFRSQRT7_V_M2, VFRSQRT7_V }, // 2244 + { PseudoVFRSQRT7_V_M2_MASK, VFRSQRT7_V }, // 2245 + { PseudoVFRSQRT7_V_M4, VFRSQRT7_V }, // 2246 + { PseudoVFRSQRT7_V_M4_MASK, VFRSQRT7_V }, // 2247 + { PseudoVFRSQRT7_V_M8, VFRSQRT7_V }, // 2248 + { PseudoVFRSQRT7_V_M8_MASK, VFRSQRT7_V }, // 2249 + { PseudoVFRSQRT7_V_MF2, VFRSQRT7_V }, // 2250 + { PseudoVFRSQRT7_V_MF2_MASK, VFRSQRT7_V }, // 2251 + { PseudoVFRSQRT7_V_MF4, VFRSQRT7_V }, // 2252 + { PseudoVFRSQRT7_V_MF4_MASK, VFRSQRT7_V }, // 2253 + { PseudoVFRSUB_VFPR16_M1, VFRSUB_VF }, // 2254 + { PseudoVFRSUB_VFPR16_M1_MASK, VFRSUB_VF }, // 2255 + { PseudoVFRSUB_VFPR16_M2, VFRSUB_VF }, // 2256 + { PseudoVFRSUB_VFPR16_M2_MASK, VFRSUB_VF }, // 2257 + { PseudoVFRSUB_VFPR16_M4, VFRSUB_VF }, // 2258 + { PseudoVFRSUB_VFPR16_M4_MASK, VFRSUB_VF }, // 2259 + { PseudoVFRSUB_VFPR16_M8, VFRSUB_VF }, // 2260 + { PseudoVFRSUB_VFPR16_M8_MASK, VFRSUB_VF }, // 2261 + { PseudoVFRSUB_VFPR16_MF2, VFRSUB_VF }, // 2262 + { PseudoVFRSUB_VFPR16_MF2_MASK, VFRSUB_VF }, // 2263 + { PseudoVFRSUB_VFPR16_MF4, VFRSUB_VF }, // 2264 + { PseudoVFRSUB_VFPR16_MF4_MASK, VFRSUB_VF }, // 2265 + { PseudoVFRSUB_VFPR32_M1, VFRSUB_VF }, // 2266 + { PseudoVFRSUB_VFPR32_M1_MASK, VFRSUB_VF }, // 2267 + { PseudoVFRSUB_VFPR32_M2, VFRSUB_VF }, // 2268 + { PseudoVFRSUB_VFPR32_M2_MASK, VFRSUB_VF }, // 2269 + { PseudoVFRSUB_VFPR32_M4, VFRSUB_VF }, // 2270 + { PseudoVFRSUB_VFPR32_M4_MASK, VFRSUB_VF }, // 2271 + { PseudoVFRSUB_VFPR32_M8, VFRSUB_VF }, // 2272 + { PseudoVFRSUB_VFPR32_M8_MASK, VFRSUB_VF }, // 2273 + { PseudoVFRSUB_VFPR32_MF2, VFRSUB_VF }, // 2274 + { PseudoVFRSUB_VFPR32_MF2_MASK, VFRSUB_VF }, // 2275 + { PseudoVFRSUB_VFPR64_M1, VFRSUB_VF }, // 2276 + { PseudoVFRSUB_VFPR64_M1_MASK, VFRSUB_VF }, // 2277 + { PseudoVFRSUB_VFPR64_M2, VFRSUB_VF }, // 2278 + { PseudoVFRSUB_VFPR64_M2_MASK, VFRSUB_VF }, // 2279 + { PseudoVFRSUB_VFPR64_M4, VFRSUB_VF }, // 2280 + { PseudoVFRSUB_VFPR64_M4_MASK, VFRSUB_VF }, // 2281 + { PseudoVFRSUB_VFPR64_M8, VFRSUB_VF }, // 2282 + { PseudoVFRSUB_VFPR64_M8_MASK, VFRSUB_VF }, // 2283 + { PseudoVFSGNJN_VFPR16_M1, VFSGNJN_VF }, // 2284 + { PseudoVFSGNJN_VFPR16_M1_MASK, VFSGNJN_VF }, // 2285 + { PseudoVFSGNJN_VFPR16_M2, VFSGNJN_VF }, // 2286 + { PseudoVFSGNJN_VFPR16_M2_MASK, VFSGNJN_VF }, // 2287 + { PseudoVFSGNJN_VFPR16_M4, VFSGNJN_VF }, // 2288 + { PseudoVFSGNJN_VFPR16_M4_MASK, VFSGNJN_VF }, // 2289 + { PseudoVFSGNJN_VFPR16_M8, VFSGNJN_VF }, // 2290 + { PseudoVFSGNJN_VFPR16_M8_MASK, VFSGNJN_VF }, // 2291 + { PseudoVFSGNJN_VFPR16_MF2, VFSGNJN_VF }, // 2292 + { PseudoVFSGNJN_VFPR16_MF2_MASK, VFSGNJN_VF }, // 2293 + { PseudoVFSGNJN_VFPR16_MF4, VFSGNJN_VF }, // 2294 + { PseudoVFSGNJN_VFPR16_MF4_MASK, VFSGNJN_VF }, // 2295 + { PseudoVFSGNJN_VFPR32_M1, VFSGNJN_VF }, // 2296 + { PseudoVFSGNJN_VFPR32_M1_MASK, VFSGNJN_VF }, // 2297 + { PseudoVFSGNJN_VFPR32_M2, VFSGNJN_VF }, // 2298 + { PseudoVFSGNJN_VFPR32_M2_MASK, VFSGNJN_VF }, // 2299 + { PseudoVFSGNJN_VFPR32_M4, VFSGNJN_VF }, // 2300 + { PseudoVFSGNJN_VFPR32_M4_MASK, VFSGNJN_VF }, // 2301 + { PseudoVFSGNJN_VFPR32_M8, VFSGNJN_VF }, // 2302 + { PseudoVFSGNJN_VFPR32_M8_MASK, VFSGNJN_VF }, // 2303 + { PseudoVFSGNJN_VFPR32_MF2, VFSGNJN_VF }, // 2304 + { PseudoVFSGNJN_VFPR32_MF2_MASK, VFSGNJN_VF }, // 2305 + { PseudoVFSGNJN_VFPR64_M1, VFSGNJN_VF }, // 2306 + { PseudoVFSGNJN_VFPR64_M1_MASK, VFSGNJN_VF }, // 2307 + { PseudoVFSGNJN_VFPR64_M2, VFSGNJN_VF }, // 2308 + { PseudoVFSGNJN_VFPR64_M2_MASK, VFSGNJN_VF }, // 2309 + { PseudoVFSGNJN_VFPR64_M4, VFSGNJN_VF }, // 2310 + { PseudoVFSGNJN_VFPR64_M4_MASK, VFSGNJN_VF }, // 2311 + { PseudoVFSGNJN_VFPR64_M8, VFSGNJN_VF }, // 2312 + { PseudoVFSGNJN_VFPR64_M8_MASK, VFSGNJN_VF }, // 2313 + { PseudoVFSGNJN_VV_M1, VFSGNJN_VV }, // 2314 + { PseudoVFSGNJN_VV_M1_MASK, VFSGNJN_VV }, // 2315 + { PseudoVFSGNJN_VV_M2, VFSGNJN_VV }, // 2316 + { PseudoVFSGNJN_VV_M2_MASK, VFSGNJN_VV }, // 2317 + { PseudoVFSGNJN_VV_M4, VFSGNJN_VV }, // 2318 + { PseudoVFSGNJN_VV_M4_MASK, VFSGNJN_VV }, // 2319 + { PseudoVFSGNJN_VV_M8, VFSGNJN_VV }, // 2320 + { PseudoVFSGNJN_VV_M8_MASK, VFSGNJN_VV }, // 2321 + { PseudoVFSGNJN_VV_MF2, VFSGNJN_VV }, // 2322 + { PseudoVFSGNJN_VV_MF2_MASK, VFSGNJN_VV }, // 2323 + { PseudoVFSGNJN_VV_MF4, VFSGNJN_VV }, // 2324 + { PseudoVFSGNJN_VV_MF4_MASK, VFSGNJN_VV }, // 2325 + { PseudoVFSGNJX_VFPR16_M1, VFSGNJX_VF }, // 2326 + { PseudoVFSGNJX_VFPR16_M1_MASK, VFSGNJX_VF }, // 2327 + { PseudoVFSGNJX_VFPR16_M2, VFSGNJX_VF }, // 2328 + { PseudoVFSGNJX_VFPR16_M2_MASK, VFSGNJX_VF }, // 2329 + { PseudoVFSGNJX_VFPR16_M4, VFSGNJX_VF }, // 2330 + { PseudoVFSGNJX_VFPR16_M4_MASK, VFSGNJX_VF }, // 2331 + { PseudoVFSGNJX_VFPR16_M8, VFSGNJX_VF }, // 2332 + { PseudoVFSGNJX_VFPR16_M8_MASK, VFSGNJX_VF }, // 2333 + { PseudoVFSGNJX_VFPR16_MF2, VFSGNJX_VF }, // 2334 + { PseudoVFSGNJX_VFPR16_MF2_MASK, VFSGNJX_VF }, // 2335 + { PseudoVFSGNJX_VFPR16_MF4, VFSGNJX_VF }, // 2336 + { PseudoVFSGNJX_VFPR16_MF4_MASK, VFSGNJX_VF }, // 2337 + { PseudoVFSGNJX_VFPR32_M1, VFSGNJX_VF }, // 2338 + { PseudoVFSGNJX_VFPR32_M1_MASK, VFSGNJX_VF }, // 2339 + { PseudoVFSGNJX_VFPR32_M2, VFSGNJX_VF }, // 2340 + { PseudoVFSGNJX_VFPR32_M2_MASK, VFSGNJX_VF }, // 2341 + { PseudoVFSGNJX_VFPR32_M4, VFSGNJX_VF }, // 2342 + { PseudoVFSGNJX_VFPR32_M4_MASK, VFSGNJX_VF }, // 2343 + { PseudoVFSGNJX_VFPR32_M8, VFSGNJX_VF }, // 2344 + { PseudoVFSGNJX_VFPR32_M8_MASK, VFSGNJX_VF }, // 2345 + { PseudoVFSGNJX_VFPR32_MF2, VFSGNJX_VF }, // 2346 + { PseudoVFSGNJX_VFPR32_MF2_MASK, VFSGNJX_VF }, // 2347 + { PseudoVFSGNJX_VFPR64_M1, VFSGNJX_VF }, // 2348 + { PseudoVFSGNJX_VFPR64_M1_MASK, VFSGNJX_VF }, // 2349 + { PseudoVFSGNJX_VFPR64_M2, VFSGNJX_VF }, // 2350 + { PseudoVFSGNJX_VFPR64_M2_MASK, VFSGNJX_VF }, // 2351 + { PseudoVFSGNJX_VFPR64_M4, VFSGNJX_VF }, // 2352 + { PseudoVFSGNJX_VFPR64_M4_MASK, VFSGNJX_VF }, // 2353 + { PseudoVFSGNJX_VFPR64_M8, VFSGNJX_VF }, // 2354 + { PseudoVFSGNJX_VFPR64_M8_MASK, VFSGNJX_VF }, // 2355 + { PseudoVFSGNJX_VV_M1, VFSGNJX_VV }, // 2356 + { PseudoVFSGNJX_VV_M1_MASK, VFSGNJX_VV }, // 2357 + { PseudoVFSGNJX_VV_M2, VFSGNJX_VV }, // 2358 + { PseudoVFSGNJX_VV_M2_MASK, VFSGNJX_VV }, // 2359 + { PseudoVFSGNJX_VV_M4, VFSGNJX_VV }, // 2360 + { PseudoVFSGNJX_VV_M4_MASK, VFSGNJX_VV }, // 2361 + { PseudoVFSGNJX_VV_M8, VFSGNJX_VV }, // 2362 + { PseudoVFSGNJX_VV_M8_MASK, VFSGNJX_VV }, // 2363 + { PseudoVFSGNJX_VV_MF2, VFSGNJX_VV }, // 2364 + { PseudoVFSGNJX_VV_MF2_MASK, VFSGNJX_VV }, // 2365 + { PseudoVFSGNJX_VV_MF4, VFSGNJX_VV }, // 2366 + { PseudoVFSGNJX_VV_MF4_MASK, VFSGNJX_VV }, // 2367 + { PseudoVFSGNJ_VFPR16_M1, VFSGNJ_VF }, // 2368 + { PseudoVFSGNJ_VFPR16_M1_MASK, VFSGNJ_VF }, // 2369 + { PseudoVFSGNJ_VFPR16_M2, VFSGNJ_VF }, // 2370 + { PseudoVFSGNJ_VFPR16_M2_MASK, VFSGNJ_VF }, // 2371 + { PseudoVFSGNJ_VFPR16_M4, VFSGNJ_VF }, // 2372 + { PseudoVFSGNJ_VFPR16_M4_MASK, VFSGNJ_VF }, // 2373 + { PseudoVFSGNJ_VFPR16_M8, VFSGNJ_VF }, // 2374 + { PseudoVFSGNJ_VFPR16_M8_MASK, VFSGNJ_VF }, // 2375 + { PseudoVFSGNJ_VFPR16_MF2, VFSGNJ_VF }, // 2376 + { PseudoVFSGNJ_VFPR16_MF2_MASK, VFSGNJ_VF }, // 2377 + { PseudoVFSGNJ_VFPR16_MF4, VFSGNJ_VF }, // 2378 + { PseudoVFSGNJ_VFPR16_MF4_MASK, VFSGNJ_VF }, // 2379 + { PseudoVFSGNJ_VFPR32_M1, VFSGNJ_VF }, // 2380 + { PseudoVFSGNJ_VFPR32_M1_MASK, VFSGNJ_VF }, // 2381 + { PseudoVFSGNJ_VFPR32_M2, VFSGNJ_VF }, // 2382 + { PseudoVFSGNJ_VFPR32_M2_MASK, VFSGNJ_VF }, // 2383 + { PseudoVFSGNJ_VFPR32_M4, VFSGNJ_VF }, // 2384 + { PseudoVFSGNJ_VFPR32_M4_MASK, VFSGNJ_VF }, // 2385 + { PseudoVFSGNJ_VFPR32_M8, VFSGNJ_VF }, // 2386 + { PseudoVFSGNJ_VFPR32_M8_MASK, VFSGNJ_VF }, // 2387 + { PseudoVFSGNJ_VFPR32_MF2, VFSGNJ_VF }, // 2388 + { PseudoVFSGNJ_VFPR32_MF2_MASK, VFSGNJ_VF }, // 2389 + { PseudoVFSGNJ_VFPR64_M1, VFSGNJ_VF }, // 2390 + { PseudoVFSGNJ_VFPR64_M1_MASK, VFSGNJ_VF }, // 2391 + { PseudoVFSGNJ_VFPR64_M2, VFSGNJ_VF }, // 2392 + { PseudoVFSGNJ_VFPR64_M2_MASK, VFSGNJ_VF }, // 2393 + { PseudoVFSGNJ_VFPR64_M4, VFSGNJ_VF }, // 2394 + { PseudoVFSGNJ_VFPR64_M4_MASK, VFSGNJ_VF }, // 2395 + { PseudoVFSGNJ_VFPR64_M8, VFSGNJ_VF }, // 2396 + { PseudoVFSGNJ_VFPR64_M8_MASK, VFSGNJ_VF }, // 2397 + { PseudoVFSGNJ_VV_M1, VFSGNJ_VV }, // 2398 + { PseudoVFSGNJ_VV_M1_MASK, VFSGNJ_VV }, // 2399 + { PseudoVFSGNJ_VV_M2, VFSGNJ_VV }, // 2400 + { PseudoVFSGNJ_VV_M2_MASK, VFSGNJ_VV }, // 2401 + { PseudoVFSGNJ_VV_M4, VFSGNJ_VV }, // 2402 + { PseudoVFSGNJ_VV_M4_MASK, VFSGNJ_VV }, // 2403 + { PseudoVFSGNJ_VV_M8, VFSGNJ_VV }, // 2404 + { PseudoVFSGNJ_VV_M8_MASK, VFSGNJ_VV }, // 2405 + { PseudoVFSGNJ_VV_MF2, VFSGNJ_VV }, // 2406 + { PseudoVFSGNJ_VV_MF2_MASK, VFSGNJ_VV }, // 2407 + { PseudoVFSGNJ_VV_MF4, VFSGNJ_VV }, // 2408 + { PseudoVFSGNJ_VV_MF4_MASK, VFSGNJ_VV }, // 2409 + { PseudoVFSLIDE1DOWN_VFPR16_M1, VFSLIDE1DOWN_VF }, // 2410 + { PseudoVFSLIDE1DOWN_VFPR16_M1_MASK, VFSLIDE1DOWN_VF }, // 2411 + { PseudoVFSLIDE1DOWN_VFPR16_M2, VFSLIDE1DOWN_VF }, // 2412 + { PseudoVFSLIDE1DOWN_VFPR16_M2_MASK, VFSLIDE1DOWN_VF }, // 2413 + { PseudoVFSLIDE1DOWN_VFPR16_M4, VFSLIDE1DOWN_VF }, // 2414 + { PseudoVFSLIDE1DOWN_VFPR16_M4_MASK, VFSLIDE1DOWN_VF }, // 2415 + { PseudoVFSLIDE1DOWN_VFPR16_M8, VFSLIDE1DOWN_VF }, // 2416 + { PseudoVFSLIDE1DOWN_VFPR16_M8_MASK, VFSLIDE1DOWN_VF }, // 2417 + { PseudoVFSLIDE1DOWN_VFPR16_MF2, VFSLIDE1DOWN_VF }, // 2418 + { PseudoVFSLIDE1DOWN_VFPR16_MF2_MASK, VFSLIDE1DOWN_VF }, // 2419 + { PseudoVFSLIDE1DOWN_VFPR16_MF4, VFSLIDE1DOWN_VF }, // 2420 + { PseudoVFSLIDE1DOWN_VFPR16_MF4_MASK, VFSLIDE1DOWN_VF }, // 2421 + { PseudoVFSLIDE1DOWN_VFPR32_M1, VFSLIDE1DOWN_VF }, // 2422 + { PseudoVFSLIDE1DOWN_VFPR32_M1_MASK, VFSLIDE1DOWN_VF }, // 2423 + { PseudoVFSLIDE1DOWN_VFPR32_M2, VFSLIDE1DOWN_VF }, // 2424 + { PseudoVFSLIDE1DOWN_VFPR32_M2_MASK, VFSLIDE1DOWN_VF }, // 2425 + { PseudoVFSLIDE1DOWN_VFPR32_M4, VFSLIDE1DOWN_VF }, // 2426 + { PseudoVFSLIDE1DOWN_VFPR32_M4_MASK, VFSLIDE1DOWN_VF }, // 2427 + { PseudoVFSLIDE1DOWN_VFPR32_M8, VFSLIDE1DOWN_VF }, // 2428 + { PseudoVFSLIDE1DOWN_VFPR32_M8_MASK, VFSLIDE1DOWN_VF }, // 2429 + { PseudoVFSLIDE1DOWN_VFPR32_MF2, VFSLIDE1DOWN_VF }, // 2430 + { PseudoVFSLIDE1DOWN_VFPR32_MF2_MASK, VFSLIDE1DOWN_VF }, // 2431 + { PseudoVFSLIDE1DOWN_VFPR64_M1, VFSLIDE1DOWN_VF }, // 2432 + { PseudoVFSLIDE1DOWN_VFPR64_M1_MASK, VFSLIDE1DOWN_VF }, // 2433 + { PseudoVFSLIDE1DOWN_VFPR64_M2, VFSLIDE1DOWN_VF }, // 2434 + { PseudoVFSLIDE1DOWN_VFPR64_M2_MASK, VFSLIDE1DOWN_VF }, // 2435 + { PseudoVFSLIDE1DOWN_VFPR64_M4, VFSLIDE1DOWN_VF }, // 2436 + { PseudoVFSLIDE1DOWN_VFPR64_M4_MASK, VFSLIDE1DOWN_VF }, // 2437 + { PseudoVFSLIDE1DOWN_VFPR64_M8, VFSLIDE1DOWN_VF }, // 2438 + { PseudoVFSLIDE1DOWN_VFPR64_M8_MASK, VFSLIDE1DOWN_VF }, // 2439 + { PseudoVFSLIDE1UP_VFPR16_M1, VFSLIDE1UP_VF }, // 2440 + { PseudoVFSLIDE1UP_VFPR16_M1_MASK, VFSLIDE1UP_VF }, // 2441 + { PseudoVFSLIDE1UP_VFPR16_M2, VFSLIDE1UP_VF }, // 2442 + { PseudoVFSLIDE1UP_VFPR16_M2_MASK, VFSLIDE1UP_VF }, // 2443 + { PseudoVFSLIDE1UP_VFPR16_M4, VFSLIDE1UP_VF }, // 2444 + { PseudoVFSLIDE1UP_VFPR16_M4_MASK, VFSLIDE1UP_VF }, // 2445 + { PseudoVFSLIDE1UP_VFPR16_M8, VFSLIDE1UP_VF }, // 2446 + { PseudoVFSLIDE1UP_VFPR16_M8_MASK, VFSLIDE1UP_VF }, // 2447 + { PseudoVFSLIDE1UP_VFPR16_MF2, VFSLIDE1UP_VF }, // 2448 + { PseudoVFSLIDE1UP_VFPR16_MF2_MASK, VFSLIDE1UP_VF }, // 2449 + { PseudoVFSLIDE1UP_VFPR16_MF4, VFSLIDE1UP_VF }, // 2450 + { PseudoVFSLIDE1UP_VFPR16_MF4_MASK, VFSLIDE1UP_VF }, // 2451 + { PseudoVFSLIDE1UP_VFPR32_M1, VFSLIDE1UP_VF }, // 2452 + { PseudoVFSLIDE1UP_VFPR32_M1_MASK, VFSLIDE1UP_VF }, // 2453 + { PseudoVFSLIDE1UP_VFPR32_M2, VFSLIDE1UP_VF }, // 2454 + { PseudoVFSLIDE1UP_VFPR32_M2_MASK, VFSLIDE1UP_VF }, // 2455 + { PseudoVFSLIDE1UP_VFPR32_M4, VFSLIDE1UP_VF }, // 2456 + { PseudoVFSLIDE1UP_VFPR32_M4_MASK, VFSLIDE1UP_VF }, // 2457 + { PseudoVFSLIDE1UP_VFPR32_M8, VFSLIDE1UP_VF }, // 2458 + { PseudoVFSLIDE1UP_VFPR32_M8_MASK, VFSLIDE1UP_VF }, // 2459 + { PseudoVFSLIDE1UP_VFPR32_MF2, VFSLIDE1UP_VF }, // 2460 + { PseudoVFSLIDE1UP_VFPR32_MF2_MASK, VFSLIDE1UP_VF }, // 2461 + { PseudoVFSLIDE1UP_VFPR64_M1, VFSLIDE1UP_VF }, // 2462 + { PseudoVFSLIDE1UP_VFPR64_M1_MASK, VFSLIDE1UP_VF }, // 2463 + { PseudoVFSLIDE1UP_VFPR64_M2, VFSLIDE1UP_VF }, // 2464 + { PseudoVFSLIDE1UP_VFPR64_M2_MASK, VFSLIDE1UP_VF }, // 2465 + { PseudoVFSLIDE1UP_VFPR64_M4, VFSLIDE1UP_VF }, // 2466 + { PseudoVFSLIDE1UP_VFPR64_M4_MASK, VFSLIDE1UP_VF }, // 2467 + { PseudoVFSLIDE1UP_VFPR64_M8, VFSLIDE1UP_VF }, // 2468 + { PseudoVFSLIDE1UP_VFPR64_M8_MASK, VFSLIDE1UP_VF }, // 2469 + { PseudoVFSQRT_V_M1_E16, VFSQRT_V }, // 2470 + { PseudoVFSQRT_V_M1_E16_MASK, VFSQRT_V }, // 2471 + { PseudoVFSQRT_V_M1_E32, VFSQRT_V }, // 2472 + { PseudoVFSQRT_V_M1_E32_MASK, VFSQRT_V }, // 2473 + { PseudoVFSQRT_V_M1_E64, VFSQRT_V }, // 2474 + { PseudoVFSQRT_V_M1_E64_MASK, VFSQRT_V }, // 2475 + { PseudoVFSQRT_V_M2_E16, VFSQRT_V }, // 2476 + { PseudoVFSQRT_V_M2_E16_MASK, VFSQRT_V }, // 2477 + { PseudoVFSQRT_V_M2_E32, VFSQRT_V }, // 2478 + { PseudoVFSQRT_V_M2_E32_MASK, VFSQRT_V }, // 2479 + { PseudoVFSQRT_V_M2_E64, VFSQRT_V }, // 2480 + { PseudoVFSQRT_V_M2_E64_MASK, VFSQRT_V }, // 2481 + { PseudoVFSQRT_V_M4_E16, VFSQRT_V }, // 2482 + { PseudoVFSQRT_V_M4_E16_MASK, VFSQRT_V }, // 2483 + { PseudoVFSQRT_V_M4_E32, VFSQRT_V }, // 2484 + { PseudoVFSQRT_V_M4_E32_MASK, VFSQRT_V }, // 2485 + { PseudoVFSQRT_V_M4_E64, VFSQRT_V }, // 2486 + { PseudoVFSQRT_V_M4_E64_MASK, VFSQRT_V }, // 2487 + { PseudoVFSQRT_V_M8_E16, VFSQRT_V }, // 2488 + { PseudoVFSQRT_V_M8_E16_MASK, VFSQRT_V }, // 2489 + { PseudoVFSQRT_V_M8_E32, VFSQRT_V }, // 2490 + { PseudoVFSQRT_V_M8_E32_MASK, VFSQRT_V }, // 2491 + { PseudoVFSQRT_V_M8_E64, VFSQRT_V }, // 2492 + { PseudoVFSQRT_V_M8_E64_MASK, VFSQRT_V }, // 2493 + { PseudoVFSQRT_V_MF2_E16, VFSQRT_V }, // 2494 + { PseudoVFSQRT_V_MF2_E16_MASK, VFSQRT_V }, // 2495 + { PseudoVFSQRT_V_MF2_E32, VFSQRT_V }, // 2496 + { PseudoVFSQRT_V_MF2_E32_MASK, VFSQRT_V }, // 2497 + { PseudoVFSQRT_V_MF4_E16, VFSQRT_V }, // 2498 + { PseudoVFSQRT_V_MF4_E16_MASK, VFSQRT_V }, // 2499 + { PseudoVFSUB_VFPR16_M1, VFSUB_VF }, // 2500 + { PseudoVFSUB_VFPR16_M1_MASK, VFSUB_VF }, // 2501 + { PseudoVFSUB_VFPR16_M2, VFSUB_VF }, // 2502 + { PseudoVFSUB_VFPR16_M2_MASK, VFSUB_VF }, // 2503 + { PseudoVFSUB_VFPR16_M4, VFSUB_VF }, // 2504 + { PseudoVFSUB_VFPR16_M4_MASK, VFSUB_VF }, // 2505 + { PseudoVFSUB_VFPR16_M8, VFSUB_VF }, // 2506 + { PseudoVFSUB_VFPR16_M8_MASK, VFSUB_VF }, // 2507 + { PseudoVFSUB_VFPR16_MF2, VFSUB_VF }, // 2508 + { PseudoVFSUB_VFPR16_MF2_MASK, VFSUB_VF }, // 2509 + { PseudoVFSUB_VFPR16_MF4, VFSUB_VF }, // 2510 + { PseudoVFSUB_VFPR16_MF4_MASK, VFSUB_VF }, // 2511 + { PseudoVFSUB_VFPR32_M1, VFSUB_VF }, // 2512 + { PseudoVFSUB_VFPR32_M1_MASK, VFSUB_VF }, // 2513 + { PseudoVFSUB_VFPR32_M2, VFSUB_VF }, // 2514 + { PseudoVFSUB_VFPR32_M2_MASK, VFSUB_VF }, // 2515 + { PseudoVFSUB_VFPR32_M4, VFSUB_VF }, // 2516 + { PseudoVFSUB_VFPR32_M4_MASK, VFSUB_VF }, // 2517 + { PseudoVFSUB_VFPR32_M8, VFSUB_VF }, // 2518 + { PseudoVFSUB_VFPR32_M8_MASK, VFSUB_VF }, // 2519 + { PseudoVFSUB_VFPR32_MF2, VFSUB_VF }, // 2520 + { PseudoVFSUB_VFPR32_MF2_MASK, VFSUB_VF }, // 2521 + { PseudoVFSUB_VFPR64_M1, VFSUB_VF }, // 2522 + { PseudoVFSUB_VFPR64_M1_MASK, VFSUB_VF }, // 2523 + { PseudoVFSUB_VFPR64_M2, VFSUB_VF }, // 2524 + { PseudoVFSUB_VFPR64_M2_MASK, VFSUB_VF }, // 2525 + { PseudoVFSUB_VFPR64_M4, VFSUB_VF }, // 2526 + { PseudoVFSUB_VFPR64_M4_MASK, VFSUB_VF }, // 2527 + { PseudoVFSUB_VFPR64_M8, VFSUB_VF }, // 2528 + { PseudoVFSUB_VFPR64_M8_MASK, VFSUB_VF }, // 2529 + { PseudoVFSUB_VV_M1, VFSUB_VV }, // 2530 + { PseudoVFSUB_VV_M1_MASK, VFSUB_VV }, // 2531 + { PseudoVFSUB_VV_M2, VFSUB_VV }, // 2532 + { PseudoVFSUB_VV_M2_MASK, VFSUB_VV }, // 2533 + { PseudoVFSUB_VV_M4, VFSUB_VV }, // 2534 + { PseudoVFSUB_VV_M4_MASK, VFSUB_VV }, // 2535 + { PseudoVFSUB_VV_M8, VFSUB_VV }, // 2536 + { PseudoVFSUB_VV_M8_MASK, VFSUB_VV }, // 2537 + { PseudoVFSUB_VV_MF2, VFSUB_VV }, // 2538 + { PseudoVFSUB_VV_MF2_MASK, VFSUB_VV }, // 2539 + { PseudoVFSUB_VV_MF4, VFSUB_VV }, // 2540 + { PseudoVFSUB_VV_MF4_MASK, VFSUB_VV }, // 2541 + { PseudoVFWADD_VFPR16_M1, VFWADD_VF }, // 2542 + { PseudoVFWADD_VFPR16_M1_MASK, VFWADD_VF }, // 2543 + { PseudoVFWADD_VFPR16_M2, VFWADD_VF }, // 2544 + { PseudoVFWADD_VFPR16_M2_MASK, VFWADD_VF }, // 2545 + { PseudoVFWADD_VFPR16_M4, VFWADD_VF }, // 2546 + { PseudoVFWADD_VFPR16_M4_MASK, VFWADD_VF }, // 2547 + { PseudoVFWADD_VFPR16_MF2, VFWADD_VF }, // 2548 + { PseudoVFWADD_VFPR16_MF2_MASK, VFWADD_VF }, // 2549 + { PseudoVFWADD_VFPR16_MF4, VFWADD_VF }, // 2550 + { PseudoVFWADD_VFPR16_MF4_MASK, VFWADD_VF }, // 2551 + { PseudoVFWADD_VFPR32_M1, VFWADD_VF }, // 2552 + { PseudoVFWADD_VFPR32_M1_MASK, VFWADD_VF }, // 2553 + { PseudoVFWADD_VFPR32_M2, VFWADD_VF }, // 2554 + { PseudoVFWADD_VFPR32_M2_MASK, VFWADD_VF }, // 2555 + { PseudoVFWADD_VFPR32_M4, VFWADD_VF }, // 2556 + { PseudoVFWADD_VFPR32_M4_MASK, VFWADD_VF }, // 2557 + { PseudoVFWADD_VFPR32_MF2, VFWADD_VF }, // 2558 + { PseudoVFWADD_VFPR32_MF2_MASK, VFWADD_VF }, // 2559 + { PseudoVFWADD_VV_M1, VFWADD_VV }, // 2560 + { PseudoVFWADD_VV_M1_MASK, VFWADD_VV }, // 2561 + { PseudoVFWADD_VV_M2, VFWADD_VV }, // 2562 + { PseudoVFWADD_VV_M2_MASK, VFWADD_VV }, // 2563 + { PseudoVFWADD_VV_M4, VFWADD_VV }, // 2564 + { PseudoVFWADD_VV_M4_MASK, VFWADD_VV }, // 2565 + { PseudoVFWADD_VV_MF2, VFWADD_VV }, // 2566 + { PseudoVFWADD_VV_MF2_MASK, VFWADD_VV }, // 2567 + { PseudoVFWADD_VV_MF4, VFWADD_VV }, // 2568 + { PseudoVFWADD_VV_MF4_MASK, VFWADD_VV }, // 2569 + { PseudoVFWADD_WFPR16_M1, VFWADD_WF }, // 2570 + { PseudoVFWADD_WFPR16_M1_MASK, VFWADD_WF }, // 2571 + { PseudoVFWADD_WFPR16_M2, VFWADD_WF }, // 2572 + { PseudoVFWADD_WFPR16_M2_MASK, VFWADD_WF }, // 2573 + { PseudoVFWADD_WFPR16_M4, VFWADD_WF }, // 2574 + { PseudoVFWADD_WFPR16_M4_MASK, VFWADD_WF }, // 2575 + { PseudoVFWADD_WFPR16_MF2, VFWADD_WF }, // 2576 + { PseudoVFWADD_WFPR16_MF2_MASK, VFWADD_WF }, // 2577 + { PseudoVFWADD_WFPR16_MF4, VFWADD_WF }, // 2578 + { PseudoVFWADD_WFPR16_MF4_MASK, VFWADD_WF }, // 2579 + { PseudoVFWADD_WFPR32_M1, VFWADD_WF }, // 2580 + { PseudoVFWADD_WFPR32_M1_MASK, VFWADD_WF }, // 2581 + { PseudoVFWADD_WFPR32_M2, VFWADD_WF }, // 2582 + { PseudoVFWADD_WFPR32_M2_MASK, VFWADD_WF }, // 2583 + { PseudoVFWADD_WFPR32_M4, VFWADD_WF }, // 2584 + { PseudoVFWADD_WFPR32_M4_MASK, VFWADD_WF }, // 2585 + { PseudoVFWADD_WFPR32_MF2, VFWADD_WF }, // 2586 + { PseudoVFWADD_WFPR32_MF2_MASK, VFWADD_WF }, // 2587 + { PseudoVFWADD_WV_M1, VFWADD_WV }, // 2588 + { PseudoVFWADD_WV_M1_MASK, VFWADD_WV }, // 2589 + { PseudoVFWADD_WV_M1_MASK_TIED, VFWADD_WV }, // 2590 + { PseudoVFWADD_WV_M1_TIED, VFWADD_WV }, // 2591 + { PseudoVFWADD_WV_M2, VFWADD_WV }, // 2592 + { PseudoVFWADD_WV_M2_MASK, VFWADD_WV }, // 2593 + { PseudoVFWADD_WV_M2_MASK_TIED, VFWADD_WV }, // 2594 + { PseudoVFWADD_WV_M2_TIED, VFWADD_WV }, // 2595 + { PseudoVFWADD_WV_M4, VFWADD_WV }, // 2596 + { PseudoVFWADD_WV_M4_MASK, VFWADD_WV }, // 2597 + { PseudoVFWADD_WV_M4_MASK_TIED, VFWADD_WV }, // 2598 + { PseudoVFWADD_WV_M4_TIED, VFWADD_WV }, // 2599 + { PseudoVFWADD_WV_MF2, VFWADD_WV }, // 2600 + { PseudoVFWADD_WV_MF2_MASK, VFWADD_WV }, // 2601 + { PseudoVFWADD_WV_MF2_MASK_TIED, VFWADD_WV }, // 2602 + { PseudoVFWADD_WV_MF2_TIED, VFWADD_WV }, // 2603 + { PseudoVFWADD_WV_MF4, VFWADD_WV }, // 2604 + { PseudoVFWADD_WV_MF4_MASK, VFWADD_WV }, // 2605 + { PseudoVFWADD_WV_MF4_MASK_TIED, VFWADD_WV }, // 2606 + { PseudoVFWADD_WV_MF4_TIED, VFWADD_WV }, // 2607 + { PseudoVFWCVTBF16_F_F_V_M1, VFWCVTBF16_F_F_V }, // 2608 + { PseudoVFWCVTBF16_F_F_V_M1_MASK, VFWCVTBF16_F_F_V }, // 2609 + { PseudoVFWCVTBF16_F_F_V_M2, VFWCVTBF16_F_F_V }, // 2610 + { PseudoVFWCVTBF16_F_F_V_M2_MASK, VFWCVTBF16_F_F_V }, // 2611 + { PseudoVFWCVTBF16_F_F_V_M4, VFWCVTBF16_F_F_V }, // 2612 + { PseudoVFWCVTBF16_F_F_V_M4_MASK, VFWCVTBF16_F_F_V }, // 2613 + { PseudoVFWCVTBF16_F_F_V_MF2, VFWCVTBF16_F_F_V }, // 2614 + { PseudoVFWCVTBF16_F_F_V_MF2_MASK, VFWCVTBF16_F_F_V }, // 2615 + { PseudoVFWCVTBF16_F_F_V_MF4, VFWCVTBF16_F_F_V }, // 2616 + { PseudoVFWCVTBF16_F_F_V_MF4_MASK, VFWCVTBF16_F_F_V }, // 2617 + { PseudoVFWCVT_F_F_V_M1, VFWCVT_F_F_V }, // 2618 + { PseudoVFWCVT_F_F_V_M1_MASK, VFWCVT_F_F_V }, // 2619 + { PseudoVFWCVT_F_F_V_M2, VFWCVT_F_F_V }, // 2620 + { PseudoVFWCVT_F_F_V_M2_MASK, VFWCVT_F_F_V }, // 2621 + { PseudoVFWCVT_F_F_V_M4, VFWCVT_F_F_V }, // 2622 + { PseudoVFWCVT_F_F_V_M4_MASK, VFWCVT_F_F_V }, // 2623 + { PseudoVFWCVT_F_F_V_MF2, VFWCVT_F_F_V }, // 2624 + { PseudoVFWCVT_F_F_V_MF2_MASK, VFWCVT_F_F_V }, // 2625 + { PseudoVFWCVT_F_F_V_MF4, VFWCVT_F_F_V }, // 2626 + { PseudoVFWCVT_F_F_V_MF4_MASK, VFWCVT_F_F_V }, // 2627 + { PseudoVFWCVT_F_XU_V_M1, VFWCVT_F_XU_V }, // 2628 + { PseudoVFWCVT_F_XU_V_M1_MASK, VFWCVT_F_XU_V }, // 2629 + { PseudoVFWCVT_F_XU_V_M2, VFWCVT_F_XU_V }, // 2630 + { PseudoVFWCVT_F_XU_V_M2_MASK, VFWCVT_F_XU_V }, // 2631 + { PseudoVFWCVT_F_XU_V_M4, VFWCVT_F_XU_V }, // 2632 + { PseudoVFWCVT_F_XU_V_M4_MASK, VFWCVT_F_XU_V }, // 2633 + { PseudoVFWCVT_F_XU_V_MF2, VFWCVT_F_XU_V }, // 2634 + { PseudoVFWCVT_F_XU_V_MF2_MASK, VFWCVT_F_XU_V }, // 2635 + { PseudoVFWCVT_F_XU_V_MF4, VFWCVT_F_XU_V }, // 2636 + { PseudoVFWCVT_F_XU_V_MF4_MASK, VFWCVT_F_XU_V }, // 2637 + { PseudoVFWCVT_F_XU_V_MF8, VFWCVT_F_XU_V }, // 2638 + { PseudoVFWCVT_F_XU_V_MF8_MASK, VFWCVT_F_XU_V }, // 2639 + { PseudoVFWCVT_F_X_V_M1, VFWCVT_F_X_V }, // 2640 + { PseudoVFWCVT_F_X_V_M1_MASK, VFWCVT_F_X_V }, // 2641 + { PseudoVFWCVT_F_X_V_M2, VFWCVT_F_X_V }, // 2642 + { PseudoVFWCVT_F_X_V_M2_MASK, VFWCVT_F_X_V }, // 2643 + { PseudoVFWCVT_F_X_V_M4, VFWCVT_F_X_V }, // 2644 + { PseudoVFWCVT_F_X_V_M4_MASK, VFWCVT_F_X_V }, // 2645 + { PseudoVFWCVT_F_X_V_MF2, VFWCVT_F_X_V }, // 2646 + { PseudoVFWCVT_F_X_V_MF2_MASK, VFWCVT_F_X_V }, // 2647 + { PseudoVFWCVT_F_X_V_MF4, VFWCVT_F_X_V }, // 2648 + { PseudoVFWCVT_F_X_V_MF4_MASK, VFWCVT_F_X_V }, // 2649 + { PseudoVFWCVT_F_X_V_MF8, VFWCVT_F_X_V }, // 2650 + { PseudoVFWCVT_F_X_V_MF8_MASK, VFWCVT_F_X_V }, // 2651 + { PseudoVFWCVT_RM_XU_F_V_M1, VFWCVT_XU_F_V }, // 2652 + { PseudoVFWCVT_RM_XU_F_V_M1_MASK, VFWCVT_XU_F_V }, // 2653 + { PseudoVFWCVT_RM_XU_F_V_M2, VFWCVT_XU_F_V }, // 2654 + { PseudoVFWCVT_RM_XU_F_V_M2_MASK, VFWCVT_XU_F_V }, // 2655 + { PseudoVFWCVT_RM_XU_F_V_M4, VFWCVT_XU_F_V }, // 2656 + { PseudoVFWCVT_RM_XU_F_V_M4_MASK, VFWCVT_XU_F_V }, // 2657 + { PseudoVFWCVT_RM_XU_F_V_MF2, VFWCVT_XU_F_V }, // 2658 + { PseudoVFWCVT_RM_XU_F_V_MF2_MASK, VFWCVT_XU_F_V }, // 2659 + { PseudoVFWCVT_RM_XU_F_V_MF4, VFWCVT_XU_F_V }, // 2660 + { PseudoVFWCVT_RM_XU_F_V_MF4_MASK, VFWCVT_XU_F_V }, // 2661 + { PseudoVFWCVT_RM_X_F_V_M1, VFWCVT_X_F_V }, // 2662 + { PseudoVFWCVT_RM_X_F_V_M1_MASK, VFWCVT_X_F_V }, // 2663 + { PseudoVFWCVT_RM_X_F_V_M2, VFWCVT_X_F_V }, // 2664 + { PseudoVFWCVT_RM_X_F_V_M2_MASK, VFWCVT_X_F_V }, // 2665 + { PseudoVFWCVT_RM_X_F_V_M4, VFWCVT_X_F_V }, // 2666 + { PseudoVFWCVT_RM_X_F_V_M4_MASK, VFWCVT_X_F_V }, // 2667 + { PseudoVFWCVT_RM_X_F_V_MF2, VFWCVT_X_F_V }, // 2668 + { PseudoVFWCVT_RM_X_F_V_MF2_MASK, VFWCVT_X_F_V }, // 2669 + { PseudoVFWCVT_RM_X_F_V_MF4, VFWCVT_X_F_V }, // 2670 + { PseudoVFWCVT_RM_X_F_V_MF4_MASK, VFWCVT_X_F_V }, // 2671 + { PseudoVFWCVT_RTZ_XU_F_V_M1, VFWCVT_RTZ_XU_F_V }, // 2672 + { PseudoVFWCVT_RTZ_XU_F_V_M1_MASK, VFWCVT_RTZ_XU_F_V }, // 2673 + { PseudoVFWCVT_RTZ_XU_F_V_M2, VFWCVT_RTZ_XU_F_V }, // 2674 + { PseudoVFWCVT_RTZ_XU_F_V_M2_MASK, VFWCVT_RTZ_XU_F_V }, // 2675 + { PseudoVFWCVT_RTZ_XU_F_V_M4, VFWCVT_RTZ_XU_F_V }, // 2676 + { PseudoVFWCVT_RTZ_XU_F_V_M4_MASK, VFWCVT_RTZ_XU_F_V }, // 2677 + { PseudoVFWCVT_RTZ_XU_F_V_MF2, VFWCVT_RTZ_XU_F_V }, // 2678 + { PseudoVFWCVT_RTZ_XU_F_V_MF2_MASK, VFWCVT_RTZ_XU_F_V }, // 2679 + { PseudoVFWCVT_RTZ_XU_F_V_MF4, VFWCVT_RTZ_XU_F_V }, // 2680 + { PseudoVFWCVT_RTZ_XU_F_V_MF4_MASK, VFWCVT_RTZ_XU_F_V }, // 2681 + { PseudoVFWCVT_RTZ_X_F_V_M1, VFWCVT_RTZ_X_F_V }, // 2682 + { PseudoVFWCVT_RTZ_X_F_V_M1_MASK, VFWCVT_RTZ_X_F_V }, // 2683 + { PseudoVFWCVT_RTZ_X_F_V_M2, VFWCVT_RTZ_X_F_V }, // 2684 + { PseudoVFWCVT_RTZ_X_F_V_M2_MASK, VFWCVT_RTZ_X_F_V }, // 2685 + { PseudoVFWCVT_RTZ_X_F_V_M4, VFWCVT_RTZ_X_F_V }, // 2686 + { PseudoVFWCVT_RTZ_X_F_V_M4_MASK, VFWCVT_RTZ_X_F_V }, // 2687 + { PseudoVFWCVT_RTZ_X_F_V_MF2, VFWCVT_RTZ_X_F_V }, // 2688 + { PseudoVFWCVT_RTZ_X_F_V_MF2_MASK, VFWCVT_RTZ_X_F_V }, // 2689 + { PseudoVFWCVT_RTZ_X_F_V_MF4, VFWCVT_RTZ_X_F_V }, // 2690 + { PseudoVFWCVT_RTZ_X_F_V_MF4_MASK, VFWCVT_RTZ_X_F_V }, // 2691 + { PseudoVFWCVT_XU_F_V_M1, VFWCVT_XU_F_V }, // 2692 + { PseudoVFWCVT_XU_F_V_M1_MASK, VFWCVT_XU_F_V }, // 2693 + { PseudoVFWCVT_XU_F_V_M2, VFWCVT_XU_F_V }, // 2694 + { PseudoVFWCVT_XU_F_V_M2_MASK, VFWCVT_XU_F_V }, // 2695 + { PseudoVFWCVT_XU_F_V_M4, VFWCVT_XU_F_V }, // 2696 + { PseudoVFWCVT_XU_F_V_M4_MASK, VFWCVT_XU_F_V }, // 2697 + { PseudoVFWCVT_XU_F_V_MF2, VFWCVT_XU_F_V }, // 2698 + { PseudoVFWCVT_XU_F_V_MF2_MASK, VFWCVT_XU_F_V }, // 2699 + { PseudoVFWCVT_XU_F_V_MF4, VFWCVT_XU_F_V }, // 2700 + { PseudoVFWCVT_XU_F_V_MF4_MASK, VFWCVT_XU_F_V }, // 2701 + { PseudoVFWCVT_X_F_V_M1, VFWCVT_X_F_V }, // 2702 + { PseudoVFWCVT_X_F_V_M1_MASK, VFWCVT_X_F_V }, // 2703 + { PseudoVFWCVT_X_F_V_M2, VFWCVT_X_F_V }, // 2704 + { PseudoVFWCVT_X_F_V_M2_MASK, VFWCVT_X_F_V }, // 2705 + { PseudoVFWCVT_X_F_V_M4, VFWCVT_X_F_V }, // 2706 + { PseudoVFWCVT_X_F_V_M4_MASK, VFWCVT_X_F_V }, // 2707 + { PseudoVFWCVT_X_F_V_MF2, VFWCVT_X_F_V }, // 2708 + { PseudoVFWCVT_X_F_V_MF2_MASK, VFWCVT_X_F_V }, // 2709 + { PseudoVFWCVT_X_F_V_MF4, VFWCVT_X_F_V }, // 2710 + { PseudoVFWCVT_X_F_V_MF4_MASK, VFWCVT_X_F_V }, // 2711 + { PseudoVFWMACCBF16_VFPR16_M1, VFWMACCBF16_VF }, // 2712 + { PseudoVFWMACCBF16_VFPR16_M1_MASK, VFWMACCBF16_VF }, // 2713 + { PseudoVFWMACCBF16_VFPR16_M2, VFWMACCBF16_VF }, // 2714 + { PseudoVFWMACCBF16_VFPR16_M2_MASK, VFWMACCBF16_VF }, // 2715 + { PseudoVFWMACCBF16_VFPR16_M4, VFWMACCBF16_VF }, // 2716 + { PseudoVFWMACCBF16_VFPR16_M4_MASK, VFWMACCBF16_VF }, // 2717 + { PseudoVFWMACCBF16_VFPR16_MF2, VFWMACCBF16_VF }, // 2718 + { PseudoVFWMACCBF16_VFPR16_MF2_MASK, VFWMACCBF16_VF }, // 2719 + { PseudoVFWMACCBF16_VFPR16_MF4, VFWMACCBF16_VF }, // 2720 + { PseudoVFWMACCBF16_VFPR16_MF4_MASK, VFWMACCBF16_VF }, // 2721 + { PseudoVFWMACCBF16_VV_M1, VFWMACCBF16_VV }, // 2722 + { PseudoVFWMACCBF16_VV_M1_MASK, VFWMACCBF16_VV }, // 2723 + { PseudoVFWMACCBF16_VV_M2, VFWMACCBF16_VV }, // 2724 + { PseudoVFWMACCBF16_VV_M2_MASK, VFWMACCBF16_VV }, // 2725 + { PseudoVFWMACCBF16_VV_M4, VFWMACCBF16_VV }, // 2726 + { PseudoVFWMACCBF16_VV_M4_MASK, VFWMACCBF16_VV }, // 2727 + { PseudoVFWMACCBF16_VV_MF2, VFWMACCBF16_VV }, // 2728 + { PseudoVFWMACCBF16_VV_MF2_MASK, VFWMACCBF16_VV }, // 2729 + { PseudoVFWMACCBF16_VV_MF4, VFWMACCBF16_VV }, // 2730 + { PseudoVFWMACCBF16_VV_MF4_MASK, VFWMACCBF16_VV }, // 2731 + { PseudoVFWMACC_4x4x4_M1, VFWMACC_4x4x4 }, // 2732 + { PseudoVFWMACC_4x4x4_M2, VFWMACC_4x4x4 }, // 2733 + { PseudoVFWMACC_4x4x4_M4, VFWMACC_4x4x4 }, // 2734 + { PseudoVFWMACC_4x4x4_M8, VFWMACC_4x4x4 }, // 2735 + { PseudoVFWMACC_4x4x4_MF2, VFWMACC_4x4x4 }, // 2736 + { PseudoVFWMACC_4x4x4_MF4, VFWMACC_4x4x4 }, // 2737 + { PseudoVFWMACC_VFPR16_M1, VFWMACC_VF }, // 2738 + { PseudoVFWMACC_VFPR16_M1_MASK, VFWMACC_VF }, // 2739 + { PseudoVFWMACC_VFPR16_M2, VFWMACC_VF }, // 2740 + { PseudoVFWMACC_VFPR16_M2_MASK, VFWMACC_VF }, // 2741 + { PseudoVFWMACC_VFPR16_M4, VFWMACC_VF }, // 2742 + { PseudoVFWMACC_VFPR16_M4_MASK, VFWMACC_VF }, // 2743 + { PseudoVFWMACC_VFPR16_MF2, VFWMACC_VF }, // 2744 + { PseudoVFWMACC_VFPR16_MF2_MASK, VFWMACC_VF }, // 2745 + { PseudoVFWMACC_VFPR16_MF4, VFWMACC_VF }, // 2746 + { PseudoVFWMACC_VFPR16_MF4_MASK, VFWMACC_VF }, // 2747 + { PseudoVFWMACC_VFPR32_M1, VFWMACC_VF }, // 2748 + { PseudoVFWMACC_VFPR32_M1_MASK, VFWMACC_VF }, // 2749 + { PseudoVFWMACC_VFPR32_M2, VFWMACC_VF }, // 2750 + { PseudoVFWMACC_VFPR32_M2_MASK, VFWMACC_VF }, // 2751 + { PseudoVFWMACC_VFPR32_M4, VFWMACC_VF }, // 2752 + { PseudoVFWMACC_VFPR32_M4_MASK, VFWMACC_VF }, // 2753 + { PseudoVFWMACC_VFPR32_MF2, VFWMACC_VF }, // 2754 + { PseudoVFWMACC_VFPR32_MF2_MASK, VFWMACC_VF }, // 2755 + { PseudoVFWMACC_VV_M1, VFWMACC_VV }, // 2756 + { PseudoVFWMACC_VV_M1_MASK, VFWMACC_VV }, // 2757 + { PseudoVFWMACC_VV_M2, VFWMACC_VV }, // 2758 + { PseudoVFWMACC_VV_M2_MASK, VFWMACC_VV }, // 2759 + { PseudoVFWMACC_VV_M4, VFWMACC_VV }, // 2760 + { PseudoVFWMACC_VV_M4_MASK, VFWMACC_VV }, // 2761 + { PseudoVFWMACC_VV_MF2, VFWMACC_VV }, // 2762 + { PseudoVFWMACC_VV_MF2_MASK, VFWMACC_VV }, // 2763 + { PseudoVFWMACC_VV_MF4, VFWMACC_VV }, // 2764 + { PseudoVFWMACC_VV_MF4_MASK, VFWMACC_VV }, // 2765 + { PseudoVFWMSAC_VFPR16_M1, VFWMSAC_VF }, // 2766 + { PseudoVFWMSAC_VFPR16_M1_MASK, VFWMSAC_VF }, // 2767 + { PseudoVFWMSAC_VFPR16_M2, VFWMSAC_VF }, // 2768 + { PseudoVFWMSAC_VFPR16_M2_MASK, VFWMSAC_VF }, // 2769 + { PseudoVFWMSAC_VFPR16_M4, VFWMSAC_VF }, // 2770 + { PseudoVFWMSAC_VFPR16_M4_MASK, VFWMSAC_VF }, // 2771 + { PseudoVFWMSAC_VFPR16_MF2, VFWMSAC_VF }, // 2772 + { PseudoVFWMSAC_VFPR16_MF2_MASK, VFWMSAC_VF }, // 2773 + { PseudoVFWMSAC_VFPR16_MF4, VFWMSAC_VF }, // 2774 + { PseudoVFWMSAC_VFPR16_MF4_MASK, VFWMSAC_VF }, // 2775 + { PseudoVFWMSAC_VFPR32_M1, VFWMSAC_VF }, // 2776 + { PseudoVFWMSAC_VFPR32_M1_MASK, VFWMSAC_VF }, // 2777 + { PseudoVFWMSAC_VFPR32_M2, VFWMSAC_VF }, // 2778 + { PseudoVFWMSAC_VFPR32_M2_MASK, VFWMSAC_VF }, // 2779 + { PseudoVFWMSAC_VFPR32_M4, VFWMSAC_VF }, // 2780 + { PseudoVFWMSAC_VFPR32_M4_MASK, VFWMSAC_VF }, // 2781 + { PseudoVFWMSAC_VFPR32_MF2, VFWMSAC_VF }, // 2782 + { PseudoVFWMSAC_VFPR32_MF2_MASK, VFWMSAC_VF }, // 2783 + { PseudoVFWMSAC_VV_M1, VFWMSAC_VV }, // 2784 + { PseudoVFWMSAC_VV_M1_MASK, VFWMSAC_VV }, // 2785 + { PseudoVFWMSAC_VV_M2, VFWMSAC_VV }, // 2786 + { PseudoVFWMSAC_VV_M2_MASK, VFWMSAC_VV }, // 2787 + { PseudoVFWMSAC_VV_M4, VFWMSAC_VV }, // 2788 + { PseudoVFWMSAC_VV_M4_MASK, VFWMSAC_VV }, // 2789 + { PseudoVFWMSAC_VV_MF2, VFWMSAC_VV }, // 2790 + { PseudoVFWMSAC_VV_MF2_MASK, VFWMSAC_VV }, // 2791 + { PseudoVFWMSAC_VV_MF4, VFWMSAC_VV }, // 2792 + { PseudoVFWMSAC_VV_MF4_MASK, VFWMSAC_VV }, // 2793 + { PseudoVFWMUL_VFPR16_M1, VFWMUL_VF }, // 2794 + { PseudoVFWMUL_VFPR16_M1_MASK, VFWMUL_VF }, // 2795 + { PseudoVFWMUL_VFPR16_M2, VFWMUL_VF }, // 2796 + { PseudoVFWMUL_VFPR16_M2_MASK, VFWMUL_VF }, // 2797 + { PseudoVFWMUL_VFPR16_M4, VFWMUL_VF }, // 2798 + { PseudoVFWMUL_VFPR16_M4_MASK, VFWMUL_VF }, // 2799 + { PseudoVFWMUL_VFPR16_MF2, VFWMUL_VF }, // 2800 + { PseudoVFWMUL_VFPR16_MF2_MASK, VFWMUL_VF }, // 2801 + { PseudoVFWMUL_VFPR16_MF4, VFWMUL_VF }, // 2802 + { PseudoVFWMUL_VFPR16_MF4_MASK, VFWMUL_VF }, // 2803 + { PseudoVFWMUL_VFPR32_M1, VFWMUL_VF }, // 2804 + { PseudoVFWMUL_VFPR32_M1_MASK, VFWMUL_VF }, // 2805 + { PseudoVFWMUL_VFPR32_M2, VFWMUL_VF }, // 2806 + { PseudoVFWMUL_VFPR32_M2_MASK, VFWMUL_VF }, // 2807 + { PseudoVFWMUL_VFPR32_M4, VFWMUL_VF }, // 2808 + { PseudoVFWMUL_VFPR32_M4_MASK, VFWMUL_VF }, // 2809 + { PseudoVFWMUL_VFPR32_MF2, VFWMUL_VF }, // 2810 + { PseudoVFWMUL_VFPR32_MF2_MASK, VFWMUL_VF }, // 2811 + { PseudoVFWMUL_VV_M1, VFWMUL_VV }, // 2812 + { PseudoVFWMUL_VV_M1_MASK, VFWMUL_VV }, // 2813 + { PseudoVFWMUL_VV_M2, VFWMUL_VV }, // 2814 + { PseudoVFWMUL_VV_M2_MASK, VFWMUL_VV }, // 2815 + { PseudoVFWMUL_VV_M4, VFWMUL_VV }, // 2816 + { PseudoVFWMUL_VV_M4_MASK, VFWMUL_VV }, // 2817 + { PseudoVFWMUL_VV_MF2, VFWMUL_VV }, // 2818 + { PseudoVFWMUL_VV_MF2_MASK, VFWMUL_VV }, // 2819 + { PseudoVFWMUL_VV_MF4, VFWMUL_VV }, // 2820 + { PseudoVFWMUL_VV_MF4_MASK, VFWMUL_VV }, // 2821 + { PseudoVFWNMACC_VFPR16_M1, VFWNMACC_VF }, // 2822 + { PseudoVFWNMACC_VFPR16_M1_MASK, VFWNMACC_VF }, // 2823 + { PseudoVFWNMACC_VFPR16_M2, VFWNMACC_VF }, // 2824 + { PseudoVFWNMACC_VFPR16_M2_MASK, VFWNMACC_VF }, // 2825 + { PseudoVFWNMACC_VFPR16_M4, VFWNMACC_VF }, // 2826 + { PseudoVFWNMACC_VFPR16_M4_MASK, VFWNMACC_VF }, // 2827 + { PseudoVFWNMACC_VFPR16_MF2, VFWNMACC_VF }, // 2828 + { PseudoVFWNMACC_VFPR16_MF2_MASK, VFWNMACC_VF }, // 2829 + { PseudoVFWNMACC_VFPR16_MF4, VFWNMACC_VF }, // 2830 + { PseudoVFWNMACC_VFPR16_MF4_MASK, VFWNMACC_VF }, // 2831 + { PseudoVFWNMACC_VFPR32_M1, VFWNMACC_VF }, // 2832 + { PseudoVFWNMACC_VFPR32_M1_MASK, VFWNMACC_VF }, // 2833 + { PseudoVFWNMACC_VFPR32_M2, VFWNMACC_VF }, // 2834 + { PseudoVFWNMACC_VFPR32_M2_MASK, VFWNMACC_VF }, // 2835 + { PseudoVFWNMACC_VFPR32_M4, VFWNMACC_VF }, // 2836 + { PseudoVFWNMACC_VFPR32_M4_MASK, VFWNMACC_VF }, // 2837 + { PseudoVFWNMACC_VFPR32_MF2, VFWNMACC_VF }, // 2838 + { PseudoVFWNMACC_VFPR32_MF2_MASK, VFWNMACC_VF }, // 2839 + { PseudoVFWNMACC_VV_M1, VFWNMACC_VV }, // 2840 + { PseudoVFWNMACC_VV_M1_MASK, VFWNMACC_VV }, // 2841 + { PseudoVFWNMACC_VV_M2, VFWNMACC_VV }, // 2842 + { PseudoVFWNMACC_VV_M2_MASK, VFWNMACC_VV }, // 2843 + { PseudoVFWNMACC_VV_M4, VFWNMACC_VV }, // 2844 + { PseudoVFWNMACC_VV_M4_MASK, VFWNMACC_VV }, // 2845 + { PseudoVFWNMACC_VV_MF2, VFWNMACC_VV }, // 2846 + { PseudoVFWNMACC_VV_MF2_MASK, VFWNMACC_VV }, // 2847 + { PseudoVFWNMACC_VV_MF4, VFWNMACC_VV }, // 2848 + { PseudoVFWNMACC_VV_MF4_MASK, VFWNMACC_VV }, // 2849 + { PseudoVFWNMSAC_VFPR16_M1, VFWNMSAC_VF }, // 2850 + { PseudoVFWNMSAC_VFPR16_M1_MASK, VFWNMSAC_VF }, // 2851 + { PseudoVFWNMSAC_VFPR16_M2, VFWNMSAC_VF }, // 2852 + { PseudoVFWNMSAC_VFPR16_M2_MASK, VFWNMSAC_VF }, // 2853 + { PseudoVFWNMSAC_VFPR16_M4, VFWNMSAC_VF }, // 2854 + { PseudoVFWNMSAC_VFPR16_M4_MASK, VFWNMSAC_VF }, // 2855 + { PseudoVFWNMSAC_VFPR16_MF2, VFWNMSAC_VF }, // 2856 + { PseudoVFWNMSAC_VFPR16_MF2_MASK, VFWNMSAC_VF }, // 2857 + { PseudoVFWNMSAC_VFPR16_MF4, VFWNMSAC_VF }, // 2858 + { PseudoVFWNMSAC_VFPR16_MF4_MASK, VFWNMSAC_VF }, // 2859 + { PseudoVFWNMSAC_VFPR32_M1, VFWNMSAC_VF }, // 2860 + { PseudoVFWNMSAC_VFPR32_M1_MASK, VFWNMSAC_VF }, // 2861 + { PseudoVFWNMSAC_VFPR32_M2, VFWNMSAC_VF }, // 2862 + { PseudoVFWNMSAC_VFPR32_M2_MASK, VFWNMSAC_VF }, // 2863 + { PseudoVFWNMSAC_VFPR32_M4, VFWNMSAC_VF }, // 2864 + { PseudoVFWNMSAC_VFPR32_M4_MASK, VFWNMSAC_VF }, // 2865 + { PseudoVFWNMSAC_VFPR32_MF2, VFWNMSAC_VF }, // 2866 + { PseudoVFWNMSAC_VFPR32_MF2_MASK, VFWNMSAC_VF }, // 2867 + { PseudoVFWNMSAC_VV_M1, VFWNMSAC_VV }, // 2868 + { PseudoVFWNMSAC_VV_M1_MASK, VFWNMSAC_VV }, // 2869 + { PseudoVFWNMSAC_VV_M2, VFWNMSAC_VV }, // 2870 + { PseudoVFWNMSAC_VV_M2_MASK, VFWNMSAC_VV }, // 2871 + { PseudoVFWNMSAC_VV_M4, VFWNMSAC_VV }, // 2872 + { PseudoVFWNMSAC_VV_M4_MASK, VFWNMSAC_VV }, // 2873 + { PseudoVFWNMSAC_VV_MF2, VFWNMSAC_VV }, // 2874 + { PseudoVFWNMSAC_VV_MF2_MASK, VFWNMSAC_VV }, // 2875 + { PseudoVFWNMSAC_VV_MF4, VFWNMSAC_VV }, // 2876 + { PseudoVFWNMSAC_VV_MF4_MASK, VFWNMSAC_VV }, // 2877 + { PseudoVFWREDOSUM_VS_M1_E16, VFWREDOSUM_VS }, // 2878 + { PseudoVFWREDOSUM_VS_M1_E16_MASK, VFWREDOSUM_VS }, // 2879 + { PseudoVFWREDOSUM_VS_M1_E32, VFWREDOSUM_VS }, // 2880 + { PseudoVFWREDOSUM_VS_M1_E32_MASK, VFWREDOSUM_VS }, // 2881 + { PseudoVFWREDOSUM_VS_M2_E16, VFWREDOSUM_VS }, // 2882 + { PseudoVFWREDOSUM_VS_M2_E16_MASK, VFWREDOSUM_VS }, // 2883 + { PseudoVFWREDOSUM_VS_M2_E32, VFWREDOSUM_VS }, // 2884 + { PseudoVFWREDOSUM_VS_M2_E32_MASK, VFWREDOSUM_VS }, // 2885 + { PseudoVFWREDOSUM_VS_M4_E16, VFWREDOSUM_VS }, // 2886 + { PseudoVFWREDOSUM_VS_M4_E16_MASK, VFWREDOSUM_VS }, // 2887 + { PseudoVFWREDOSUM_VS_M4_E32, VFWREDOSUM_VS }, // 2888 + { PseudoVFWREDOSUM_VS_M4_E32_MASK, VFWREDOSUM_VS }, // 2889 + { PseudoVFWREDOSUM_VS_M8_E16, VFWREDOSUM_VS }, // 2890 + { PseudoVFWREDOSUM_VS_M8_E16_MASK, VFWREDOSUM_VS }, // 2891 + { PseudoVFWREDOSUM_VS_M8_E32, VFWREDOSUM_VS }, // 2892 + { PseudoVFWREDOSUM_VS_M8_E32_MASK, VFWREDOSUM_VS }, // 2893 + { PseudoVFWREDOSUM_VS_MF2_E16, VFWREDOSUM_VS }, // 2894 + { PseudoVFWREDOSUM_VS_MF2_E16_MASK, VFWREDOSUM_VS }, // 2895 + { PseudoVFWREDOSUM_VS_MF2_E32, VFWREDOSUM_VS }, // 2896 + { PseudoVFWREDOSUM_VS_MF2_E32_MASK, VFWREDOSUM_VS }, // 2897 + { PseudoVFWREDOSUM_VS_MF4_E16, VFWREDOSUM_VS }, // 2898 + { PseudoVFWREDOSUM_VS_MF4_E16_MASK, VFWREDOSUM_VS }, // 2899 + { PseudoVFWREDUSUM_VS_M1_E16, VFWREDUSUM_VS }, // 2900 + { PseudoVFWREDUSUM_VS_M1_E16_MASK, VFWREDUSUM_VS }, // 2901 + { PseudoVFWREDUSUM_VS_M1_E32, VFWREDUSUM_VS }, // 2902 + { PseudoVFWREDUSUM_VS_M1_E32_MASK, VFWREDUSUM_VS }, // 2903 + { PseudoVFWREDUSUM_VS_M2_E16, VFWREDUSUM_VS }, // 2904 + { PseudoVFWREDUSUM_VS_M2_E16_MASK, VFWREDUSUM_VS }, // 2905 + { PseudoVFWREDUSUM_VS_M2_E32, VFWREDUSUM_VS }, // 2906 + { PseudoVFWREDUSUM_VS_M2_E32_MASK, VFWREDUSUM_VS }, // 2907 + { PseudoVFWREDUSUM_VS_M4_E16, VFWREDUSUM_VS }, // 2908 + { PseudoVFWREDUSUM_VS_M4_E16_MASK, VFWREDUSUM_VS }, // 2909 + { PseudoVFWREDUSUM_VS_M4_E32, VFWREDUSUM_VS }, // 2910 + { PseudoVFWREDUSUM_VS_M4_E32_MASK, VFWREDUSUM_VS }, // 2911 + { PseudoVFWREDUSUM_VS_M8_E16, VFWREDUSUM_VS }, // 2912 + { PseudoVFWREDUSUM_VS_M8_E16_MASK, VFWREDUSUM_VS }, // 2913 + { PseudoVFWREDUSUM_VS_M8_E32, VFWREDUSUM_VS }, // 2914 + { PseudoVFWREDUSUM_VS_M8_E32_MASK, VFWREDUSUM_VS }, // 2915 + { PseudoVFWREDUSUM_VS_MF2_E16, VFWREDUSUM_VS }, // 2916 + { PseudoVFWREDUSUM_VS_MF2_E16_MASK, VFWREDUSUM_VS }, // 2917 + { PseudoVFWREDUSUM_VS_MF2_E32, VFWREDUSUM_VS }, // 2918 + { PseudoVFWREDUSUM_VS_MF2_E32_MASK, VFWREDUSUM_VS }, // 2919 + { PseudoVFWREDUSUM_VS_MF4_E16, VFWREDUSUM_VS }, // 2920 + { PseudoVFWREDUSUM_VS_MF4_E16_MASK, VFWREDUSUM_VS }, // 2921 + { PseudoVFWSUB_VFPR16_M1, VFWSUB_VF }, // 2922 + { PseudoVFWSUB_VFPR16_M1_MASK, VFWSUB_VF }, // 2923 + { PseudoVFWSUB_VFPR16_M2, VFWSUB_VF }, // 2924 + { PseudoVFWSUB_VFPR16_M2_MASK, VFWSUB_VF }, // 2925 + { PseudoVFWSUB_VFPR16_M4, VFWSUB_VF }, // 2926 + { PseudoVFWSUB_VFPR16_M4_MASK, VFWSUB_VF }, // 2927 + { PseudoVFWSUB_VFPR16_MF2, VFWSUB_VF }, // 2928 + { PseudoVFWSUB_VFPR16_MF2_MASK, VFWSUB_VF }, // 2929 + { PseudoVFWSUB_VFPR16_MF4, VFWSUB_VF }, // 2930 + { PseudoVFWSUB_VFPR16_MF4_MASK, VFWSUB_VF }, // 2931 + { PseudoVFWSUB_VFPR32_M1, VFWSUB_VF }, // 2932 + { PseudoVFWSUB_VFPR32_M1_MASK, VFWSUB_VF }, // 2933 + { PseudoVFWSUB_VFPR32_M2, VFWSUB_VF }, // 2934 + { PseudoVFWSUB_VFPR32_M2_MASK, VFWSUB_VF }, // 2935 + { PseudoVFWSUB_VFPR32_M4, VFWSUB_VF }, // 2936 + { PseudoVFWSUB_VFPR32_M4_MASK, VFWSUB_VF }, // 2937 + { PseudoVFWSUB_VFPR32_MF2, VFWSUB_VF }, // 2938 + { PseudoVFWSUB_VFPR32_MF2_MASK, VFWSUB_VF }, // 2939 + { PseudoVFWSUB_VV_M1, VFWSUB_VV }, // 2940 + { PseudoVFWSUB_VV_M1_MASK, VFWSUB_VV }, // 2941 + { PseudoVFWSUB_VV_M2, VFWSUB_VV }, // 2942 + { PseudoVFWSUB_VV_M2_MASK, VFWSUB_VV }, // 2943 + { PseudoVFWSUB_VV_M4, VFWSUB_VV }, // 2944 + { PseudoVFWSUB_VV_M4_MASK, VFWSUB_VV }, // 2945 + { PseudoVFWSUB_VV_MF2, VFWSUB_VV }, // 2946 + { PseudoVFWSUB_VV_MF2_MASK, VFWSUB_VV }, // 2947 + { PseudoVFWSUB_VV_MF4, VFWSUB_VV }, // 2948 + { PseudoVFWSUB_VV_MF4_MASK, VFWSUB_VV }, // 2949 + { PseudoVFWSUB_WFPR16_M1, VFWSUB_WF }, // 2950 + { PseudoVFWSUB_WFPR16_M1_MASK, VFWSUB_WF }, // 2951 + { PseudoVFWSUB_WFPR16_M2, VFWSUB_WF }, // 2952 + { PseudoVFWSUB_WFPR16_M2_MASK, VFWSUB_WF }, // 2953 + { PseudoVFWSUB_WFPR16_M4, VFWSUB_WF }, // 2954 + { PseudoVFWSUB_WFPR16_M4_MASK, VFWSUB_WF }, // 2955 + { PseudoVFWSUB_WFPR16_MF2, VFWSUB_WF }, // 2956 + { PseudoVFWSUB_WFPR16_MF2_MASK, VFWSUB_WF }, // 2957 + { PseudoVFWSUB_WFPR16_MF4, VFWSUB_WF }, // 2958 + { PseudoVFWSUB_WFPR16_MF4_MASK, VFWSUB_WF }, // 2959 + { PseudoVFWSUB_WFPR32_M1, VFWSUB_WF }, // 2960 + { PseudoVFWSUB_WFPR32_M1_MASK, VFWSUB_WF }, // 2961 + { PseudoVFWSUB_WFPR32_M2, VFWSUB_WF }, // 2962 + { PseudoVFWSUB_WFPR32_M2_MASK, VFWSUB_WF }, // 2963 + { PseudoVFWSUB_WFPR32_M4, VFWSUB_WF }, // 2964 + { PseudoVFWSUB_WFPR32_M4_MASK, VFWSUB_WF }, // 2965 + { PseudoVFWSUB_WFPR32_MF2, VFWSUB_WF }, // 2966 + { PseudoVFWSUB_WFPR32_MF2_MASK, VFWSUB_WF }, // 2967 + { PseudoVFWSUB_WV_M1, VFWSUB_WV }, // 2968 + { PseudoVFWSUB_WV_M1_MASK, VFWSUB_WV }, // 2969 + { PseudoVFWSUB_WV_M1_MASK_TIED, VFWSUB_WV }, // 2970 + { PseudoVFWSUB_WV_M1_TIED, VFWSUB_WV }, // 2971 + { PseudoVFWSUB_WV_M2, VFWSUB_WV }, // 2972 + { PseudoVFWSUB_WV_M2_MASK, VFWSUB_WV }, // 2973 + { PseudoVFWSUB_WV_M2_MASK_TIED, VFWSUB_WV }, // 2974 + { PseudoVFWSUB_WV_M2_TIED, VFWSUB_WV }, // 2975 + { PseudoVFWSUB_WV_M4, VFWSUB_WV }, // 2976 + { PseudoVFWSUB_WV_M4_MASK, VFWSUB_WV }, // 2977 + { PseudoVFWSUB_WV_M4_MASK_TIED, VFWSUB_WV }, // 2978 + { PseudoVFWSUB_WV_M4_TIED, VFWSUB_WV }, // 2979 + { PseudoVFWSUB_WV_MF2, VFWSUB_WV }, // 2980 + { PseudoVFWSUB_WV_MF2_MASK, VFWSUB_WV }, // 2981 + { PseudoVFWSUB_WV_MF2_MASK_TIED, VFWSUB_WV }, // 2982 + { PseudoVFWSUB_WV_MF2_TIED, VFWSUB_WV }, // 2983 + { PseudoVFWSUB_WV_MF4, VFWSUB_WV }, // 2984 + { PseudoVFWSUB_WV_MF4_MASK, VFWSUB_WV }, // 2985 + { PseudoVFWSUB_WV_MF4_MASK_TIED, VFWSUB_WV }, // 2986 + { PseudoVFWSUB_WV_MF4_TIED, VFWSUB_WV }, // 2987 + { PseudoVGHSH_VV_M1, VGHSH_VV }, // 2988 + { PseudoVGHSH_VV_M2, VGHSH_VV }, // 2989 + { PseudoVGHSH_VV_M4, VGHSH_VV }, // 2990 + { PseudoVGHSH_VV_M8, VGHSH_VV }, // 2991 + { PseudoVGHSH_VV_MF2, VGHSH_VV }, // 2992 + { PseudoVGMUL_VV_M1, VGMUL_VV }, // 2993 + { PseudoVGMUL_VV_M2, VGMUL_VV }, // 2994 + { PseudoVGMUL_VV_M4, VGMUL_VV }, // 2995 + { PseudoVGMUL_VV_M8, VGMUL_VV }, // 2996 + { PseudoVGMUL_VV_MF2, VGMUL_VV }, // 2997 + { PseudoVID_V_M1, VID_V }, // 2998 + { PseudoVID_V_M1_MASK, VID_V }, // 2999 + { PseudoVID_V_M2, VID_V }, // 3000 + { PseudoVID_V_M2_MASK, VID_V }, // 3001 + { PseudoVID_V_M4, VID_V }, // 3002 + { PseudoVID_V_M4_MASK, VID_V }, // 3003 + { PseudoVID_V_M8, VID_V }, // 3004 + { PseudoVID_V_M8_MASK, VID_V }, // 3005 + { PseudoVID_V_MF2, VID_V }, // 3006 + { PseudoVID_V_MF2_MASK, VID_V }, // 3007 + { PseudoVID_V_MF4, VID_V }, // 3008 + { PseudoVID_V_MF4_MASK, VID_V }, // 3009 + { PseudoVID_V_MF8, VID_V }, // 3010 + { PseudoVID_V_MF8_MASK, VID_V }, // 3011 + { PseudoVIOTA_M_M1, VIOTA_M }, // 3012 + { PseudoVIOTA_M_M1_MASK, VIOTA_M }, // 3013 + { PseudoVIOTA_M_M2, VIOTA_M }, // 3014 + { PseudoVIOTA_M_M2_MASK, VIOTA_M }, // 3015 + { PseudoVIOTA_M_M4, VIOTA_M }, // 3016 + { PseudoVIOTA_M_M4_MASK, VIOTA_M }, // 3017 + { PseudoVIOTA_M_M8, VIOTA_M }, // 3018 + { PseudoVIOTA_M_M8_MASK, VIOTA_M }, // 3019 + { PseudoVIOTA_M_MF2, VIOTA_M }, // 3020 + { PseudoVIOTA_M_MF2_MASK, VIOTA_M }, // 3021 + { PseudoVIOTA_M_MF4, VIOTA_M }, // 3022 + { PseudoVIOTA_M_MF4_MASK, VIOTA_M }, // 3023 + { PseudoVIOTA_M_MF8, VIOTA_M }, // 3024 + { PseudoVIOTA_M_MF8_MASK, VIOTA_M }, // 3025 + { PseudoVLE16FF_V_M1, VLE16FF_V }, // 3026 + { PseudoVLE16FF_V_M1_MASK, VLE16FF_V }, // 3027 + { PseudoVLE16FF_V_M2, VLE16FF_V }, // 3028 + { PseudoVLE16FF_V_M2_MASK, VLE16FF_V }, // 3029 + { PseudoVLE16FF_V_M4, VLE16FF_V }, // 3030 + { PseudoVLE16FF_V_M4_MASK, VLE16FF_V }, // 3031 + { PseudoVLE16FF_V_M8, VLE16FF_V }, // 3032 + { PseudoVLE16FF_V_M8_MASK, VLE16FF_V }, // 3033 + { PseudoVLE16FF_V_MF2, VLE16FF_V }, // 3034 + { PseudoVLE16FF_V_MF2_MASK, VLE16FF_V }, // 3035 + { PseudoVLE16FF_V_MF4, VLE16FF_V }, // 3036 + { PseudoVLE16FF_V_MF4_MASK, VLE16FF_V }, // 3037 + { PseudoVLE16_V_M1, VLE16_V }, // 3038 + { PseudoVLE16_V_M1_MASK, VLE16_V }, // 3039 + { PseudoVLE16_V_M2, VLE16_V }, // 3040 + { PseudoVLE16_V_M2_MASK, VLE16_V }, // 3041 + { PseudoVLE16_V_M4, VLE16_V }, // 3042 + { PseudoVLE16_V_M4_MASK, VLE16_V }, // 3043 + { PseudoVLE16_V_M8, VLE16_V }, // 3044 + { PseudoVLE16_V_M8_MASK, VLE16_V }, // 3045 + { PseudoVLE16_V_MF2, VLE16_V }, // 3046 + { PseudoVLE16_V_MF2_MASK, VLE16_V }, // 3047 + { PseudoVLE16_V_MF4, VLE16_V }, // 3048 + { PseudoVLE16_V_MF4_MASK, VLE16_V }, // 3049 + { PseudoVLE32FF_V_M1, VLE32FF_V }, // 3050 + { PseudoVLE32FF_V_M1_MASK, VLE32FF_V }, // 3051 + { PseudoVLE32FF_V_M2, VLE32FF_V }, // 3052 + { PseudoVLE32FF_V_M2_MASK, VLE32FF_V }, // 3053 + { PseudoVLE32FF_V_M4, VLE32FF_V }, // 3054 + { PseudoVLE32FF_V_M4_MASK, VLE32FF_V }, // 3055 + { PseudoVLE32FF_V_M8, VLE32FF_V }, // 3056 + { PseudoVLE32FF_V_M8_MASK, VLE32FF_V }, // 3057 + { PseudoVLE32FF_V_MF2, VLE32FF_V }, // 3058 + { PseudoVLE32FF_V_MF2_MASK, VLE32FF_V }, // 3059 + { PseudoVLE32_V_M1, VLE32_V }, // 3060 + { PseudoVLE32_V_M1_MASK, VLE32_V }, // 3061 + { PseudoVLE32_V_M2, VLE32_V }, // 3062 + { PseudoVLE32_V_M2_MASK, VLE32_V }, // 3063 + { PseudoVLE32_V_M4, VLE32_V }, // 3064 + { PseudoVLE32_V_M4_MASK, VLE32_V }, // 3065 + { PseudoVLE32_V_M8, VLE32_V }, // 3066 + { PseudoVLE32_V_M8_MASK, VLE32_V }, // 3067 + { PseudoVLE32_V_MF2, VLE32_V }, // 3068 + { PseudoVLE32_V_MF2_MASK, VLE32_V }, // 3069 + { PseudoVLE64FF_V_M1, VLE64FF_V }, // 3070 + { PseudoVLE64FF_V_M1_MASK, VLE64FF_V }, // 3071 + { PseudoVLE64FF_V_M2, VLE64FF_V }, // 3072 + { PseudoVLE64FF_V_M2_MASK, VLE64FF_V }, // 3073 + { PseudoVLE64FF_V_M4, VLE64FF_V }, // 3074 + { PseudoVLE64FF_V_M4_MASK, VLE64FF_V }, // 3075 + { PseudoVLE64FF_V_M8, VLE64FF_V }, // 3076 + { PseudoVLE64FF_V_M8_MASK, VLE64FF_V }, // 3077 + { PseudoVLE64_V_M1, VLE64_V }, // 3078 + { PseudoVLE64_V_M1_MASK, VLE64_V }, // 3079 + { PseudoVLE64_V_M2, VLE64_V }, // 3080 + { PseudoVLE64_V_M2_MASK, VLE64_V }, // 3081 + { PseudoVLE64_V_M4, VLE64_V }, // 3082 + { PseudoVLE64_V_M4_MASK, VLE64_V }, // 3083 + { PseudoVLE64_V_M8, VLE64_V }, // 3084 + { PseudoVLE64_V_M8_MASK, VLE64_V }, // 3085 + { PseudoVLE8FF_V_M1, VLE8FF_V }, // 3086 + { PseudoVLE8FF_V_M1_MASK, VLE8FF_V }, // 3087 + { PseudoVLE8FF_V_M2, VLE8FF_V }, // 3088 + { PseudoVLE8FF_V_M2_MASK, VLE8FF_V }, // 3089 + { PseudoVLE8FF_V_M4, VLE8FF_V }, // 3090 + { PseudoVLE8FF_V_M4_MASK, VLE8FF_V }, // 3091 + { PseudoVLE8FF_V_M8, VLE8FF_V }, // 3092 + { PseudoVLE8FF_V_M8_MASK, VLE8FF_V }, // 3093 + { PseudoVLE8FF_V_MF2, VLE8FF_V }, // 3094 + { PseudoVLE8FF_V_MF2_MASK, VLE8FF_V }, // 3095 + { PseudoVLE8FF_V_MF4, VLE8FF_V }, // 3096 + { PseudoVLE8FF_V_MF4_MASK, VLE8FF_V }, // 3097 + { PseudoVLE8FF_V_MF8, VLE8FF_V }, // 3098 + { PseudoVLE8FF_V_MF8_MASK, VLE8FF_V }, // 3099 + { PseudoVLE8_V_M1, VLE8_V }, // 3100 + { PseudoVLE8_V_M1_MASK, VLE8_V }, // 3101 + { PseudoVLE8_V_M2, VLE8_V }, // 3102 + { PseudoVLE8_V_M2_MASK, VLE8_V }, // 3103 + { PseudoVLE8_V_M4, VLE8_V }, // 3104 + { PseudoVLE8_V_M4_MASK, VLE8_V }, // 3105 + { PseudoVLE8_V_M8, VLE8_V }, // 3106 + { PseudoVLE8_V_M8_MASK, VLE8_V }, // 3107 + { PseudoVLE8_V_MF2, VLE8_V }, // 3108 + { PseudoVLE8_V_MF2_MASK, VLE8_V }, // 3109 + { PseudoVLE8_V_MF4, VLE8_V }, // 3110 + { PseudoVLE8_V_MF4_MASK, VLE8_V }, // 3111 + { PseudoVLE8_V_MF8, VLE8_V }, // 3112 + { PseudoVLE8_V_MF8_MASK, VLE8_V }, // 3113 + { PseudoVLM_V_B1, VLM_V }, // 3114 + { PseudoVLM_V_B16, VLM_V }, // 3115 + { PseudoVLM_V_B2, VLM_V }, // 3116 + { PseudoVLM_V_B32, VLM_V }, // 3117 + { PseudoVLM_V_B4, VLM_V }, // 3118 + { PseudoVLM_V_B64, VLM_V }, // 3119 + { PseudoVLM_V_B8, VLM_V }, // 3120 + { PseudoVLOXEI16_V_M1_M1, VLOXEI16_V }, // 3121 + { PseudoVLOXEI16_V_M1_M1_MASK, VLOXEI16_V }, // 3122 + { PseudoVLOXEI16_V_M1_M2, VLOXEI16_V }, // 3123 + { PseudoVLOXEI16_V_M1_M2_MASK, VLOXEI16_V }, // 3124 + { PseudoVLOXEI16_V_M1_M4, VLOXEI16_V }, // 3125 + { PseudoVLOXEI16_V_M1_M4_MASK, VLOXEI16_V }, // 3126 + { PseudoVLOXEI16_V_M1_MF2, VLOXEI16_V }, // 3127 + { PseudoVLOXEI16_V_M1_MF2_MASK, VLOXEI16_V }, // 3128 + { PseudoVLOXEI16_V_M2_M1, VLOXEI16_V }, // 3129 + { PseudoVLOXEI16_V_M2_M1_MASK, VLOXEI16_V }, // 3130 + { PseudoVLOXEI16_V_M2_M2, VLOXEI16_V }, // 3131 + { PseudoVLOXEI16_V_M2_M2_MASK, VLOXEI16_V }, // 3132 + { PseudoVLOXEI16_V_M2_M4, VLOXEI16_V }, // 3133 + { PseudoVLOXEI16_V_M2_M4_MASK, VLOXEI16_V }, // 3134 + { PseudoVLOXEI16_V_M2_M8, VLOXEI16_V }, // 3135 + { PseudoVLOXEI16_V_M2_M8_MASK, VLOXEI16_V }, // 3136 + { PseudoVLOXEI16_V_M4_M2, VLOXEI16_V }, // 3137 + { PseudoVLOXEI16_V_M4_M2_MASK, VLOXEI16_V }, // 3138 + { PseudoVLOXEI16_V_M4_M4, VLOXEI16_V }, // 3139 + { PseudoVLOXEI16_V_M4_M4_MASK, VLOXEI16_V }, // 3140 + { PseudoVLOXEI16_V_M4_M8, VLOXEI16_V }, // 3141 + { PseudoVLOXEI16_V_M4_M8_MASK, VLOXEI16_V }, // 3142 + { PseudoVLOXEI16_V_M8_M4, VLOXEI16_V }, // 3143 + { PseudoVLOXEI16_V_M8_M4_MASK, VLOXEI16_V }, // 3144 + { PseudoVLOXEI16_V_M8_M8, VLOXEI16_V }, // 3145 + { PseudoVLOXEI16_V_M8_M8_MASK, VLOXEI16_V }, // 3146 + { PseudoVLOXEI16_V_MF2_M1, VLOXEI16_V }, // 3147 + { PseudoVLOXEI16_V_MF2_M1_MASK, VLOXEI16_V }, // 3148 + { PseudoVLOXEI16_V_MF2_M2, VLOXEI16_V }, // 3149 + { PseudoVLOXEI16_V_MF2_M2_MASK, VLOXEI16_V }, // 3150 + { PseudoVLOXEI16_V_MF2_MF2, VLOXEI16_V }, // 3151 + { PseudoVLOXEI16_V_MF2_MF2_MASK, VLOXEI16_V }, // 3152 + { PseudoVLOXEI16_V_MF2_MF4, VLOXEI16_V }, // 3153 + { PseudoVLOXEI16_V_MF2_MF4_MASK, VLOXEI16_V }, // 3154 + { PseudoVLOXEI16_V_MF4_M1, VLOXEI16_V }, // 3155 + { PseudoVLOXEI16_V_MF4_M1_MASK, VLOXEI16_V }, // 3156 + { PseudoVLOXEI16_V_MF4_MF2, VLOXEI16_V }, // 3157 + { PseudoVLOXEI16_V_MF4_MF2_MASK, VLOXEI16_V }, // 3158 + { PseudoVLOXEI16_V_MF4_MF4, VLOXEI16_V }, // 3159 + { PseudoVLOXEI16_V_MF4_MF4_MASK, VLOXEI16_V }, // 3160 + { PseudoVLOXEI16_V_MF4_MF8, VLOXEI16_V }, // 3161 + { PseudoVLOXEI16_V_MF4_MF8_MASK, VLOXEI16_V }, // 3162 + { PseudoVLOXEI32_V_M1_M1, VLOXEI32_V }, // 3163 + { PseudoVLOXEI32_V_M1_M1_MASK, VLOXEI32_V }, // 3164 + { PseudoVLOXEI32_V_M1_M2, VLOXEI32_V }, // 3165 + { PseudoVLOXEI32_V_M1_M2_MASK, VLOXEI32_V }, // 3166 + { PseudoVLOXEI32_V_M1_MF2, VLOXEI32_V }, // 3167 + { PseudoVLOXEI32_V_M1_MF2_MASK, VLOXEI32_V }, // 3168 + { PseudoVLOXEI32_V_M1_MF4, VLOXEI32_V }, // 3169 + { PseudoVLOXEI32_V_M1_MF4_MASK, VLOXEI32_V }, // 3170 + { PseudoVLOXEI32_V_M2_M1, VLOXEI32_V }, // 3171 + { PseudoVLOXEI32_V_M2_M1_MASK, VLOXEI32_V }, // 3172 + { PseudoVLOXEI32_V_M2_M2, VLOXEI32_V }, // 3173 + { PseudoVLOXEI32_V_M2_M2_MASK, VLOXEI32_V }, // 3174 + { PseudoVLOXEI32_V_M2_M4, VLOXEI32_V }, // 3175 + { PseudoVLOXEI32_V_M2_M4_MASK, VLOXEI32_V }, // 3176 + { PseudoVLOXEI32_V_M2_MF2, VLOXEI32_V }, // 3177 + { PseudoVLOXEI32_V_M2_MF2_MASK, VLOXEI32_V }, // 3178 + { PseudoVLOXEI32_V_M4_M1, VLOXEI32_V }, // 3179 + { PseudoVLOXEI32_V_M4_M1_MASK, VLOXEI32_V }, // 3180 + { PseudoVLOXEI32_V_M4_M2, VLOXEI32_V }, // 3181 + { PseudoVLOXEI32_V_M4_M2_MASK, VLOXEI32_V }, // 3182 + { PseudoVLOXEI32_V_M4_M4, VLOXEI32_V }, // 3183 + { PseudoVLOXEI32_V_M4_M4_MASK, VLOXEI32_V }, // 3184 + { PseudoVLOXEI32_V_M4_M8, VLOXEI32_V }, // 3185 + { PseudoVLOXEI32_V_M4_M8_MASK, VLOXEI32_V }, // 3186 + { PseudoVLOXEI32_V_M8_M2, VLOXEI32_V }, // 3187 + { PseudoVLOXEI32_V_M8_M2_MASK, VLOXEI32_V }, // 3188 + { PseudoVLOXEI32_V_M8_M4, VLOXEI32_V }, // 3189 + { PseudoVLOXEI32_V_M8_M4_MASK, VLOXEI32_V }, // 3190 + { PseudoVLOXEI32_V_M8_M8, VLOXEI32_V }, // 3191 + { PseudoVLOXEI32_V_M8_M8_MASK, VLOXEI32_V }, // 3192 + { PseudoVLOXEI32_V_MF2_M1, VLOXEI32_V }, // 3193 + { PseudoVLOXEI32_V_MF2_M1_MASK, VLOXEI32_V }, // 3194 + { PseudoVLOXEI32_V_MF2_MF2, VLOXEI32_V }, // 3195 + { PseudoVLOXEI32_V_MF2_MF2_MASK, VLOXEI32_V }, // 3196 + { PseudoVLOXEI32_V_MF2_MF4, VLOXEI32_V }, // 3197 + { PseudoVLOXEI32_V_MF2_MF4_MASK, VLOXEI32_V }, // 3198 + { PseudoVLOXEI32_V_MF2_MF8, VLOXEI32_V }, // 3199 + { PseudoVLOXEI32_V_MF2_MF8_MASK, VLOXEI32_V }, // 3200 + { PseudoVLOXEI64_V_M1_M1, VLOXEI64_V }, // 3201 + { PseudoVLOXEI64_V_M1_M1_MASK, VLOXEI64_V }, // 3202 + { PseudoVLOXEI64_V_M1_MF2, VLOXEI64_V }, // 3203 + { PseudoVLOXEI64_V_M1_MF2_MASK, VLOXEI64_V }, // 3204 + { PseudoVLOXEI64_V_M1_MF4, VLOXEI64_V }, // 3205 + { PseudoVLOXEI64_V_M1_MF4_MASK, VLOXEI64_V }, // 3206 + { PseudoVLOXEI64_V_M1_MF8, VLOXEI64_V }, // 3207 + { PseudoVLOXEI64_V_M1_MF8_MASK, VLOXEI64_V }, // 3208 + { PseudoVLOXEI64_V_M2_M1, VLOXEI64_V }, // 3209 + { PseudoVLOXEI64_V_M2_M1_MASK, VLOXEI64_V }, // 3210 + { PseudoVLOXEI64_V_M2_M2, VLOXEI64_V }, // 3211 + { PseudoVLOXEI64_V_M2_M2_MASK, VLOXEI64_V }, // 3212 + { PseudoVLOXEI64_V_M2_MF2, VLOXEI64_V }, // 3213 + { PseudoVLOXEI64_V_M2_MF2_MASK, VLOXEI64_V }, // 3214 + { PseudoVLOXEI64_V_M2_MF4, VLOXEI64_V }, // 3215 + { PseudoVLOXEI64_V_M2_MF4_MASK, VLOXEI64_V }, // 3216 + { PseudoVLOXEI64_V_M4_M1, VLOXEI64_V }, // 3217 + { PseudoVLOXEI64_V_M4_M1_MASK, VLOXEI64_V }, // 3218 + { PseudoVLOXEI64_V_M4_M2, VLOXEI64_V }, // 3219 + { PseudoVLOXEI64_V_M4_M2_MASK, VLOXEI64_V }, // 3220 + { PseudoVLOXEI64_V_M4_M4, VLOXEI64_V }, // 3221 + { PseudoVLOXEI64_V_M4_M4_MASK, VLOXEI64_V }, // 3222 + { PseudoVLOXEI64_V_M4_MF2, VLOXEI64_V }, // 3223 + { PseudoVLOXEI64_V_M4_MF2_MASK, VLOXEI64_V }, // 3224 + { PseudoVLOXEI64_V_M8_M1, VLOXEI64_V }, // 3225 + { PseudoVLOXEI64_V_M8_M1_MASK, VLOXEI64_V }, // 3226 + { PseudoVLOXEI64_V_M8_M2, VLOXEI64_V }, // 3227 + { PseudoVLOXEI64_V_M8_M2_MASK, VLOXEI64_V }, // 3228 + { PseudoVLOXEI64_V_M8_M4, VLOXEI64_V }, // 3229 + { PseudoVLOXEI64_V_M8_M4_MASK, VLOXEI64_V }, // 3230 + { PseudoVLOXEI64_V_M8_M8, VLOXEI64_V }, // 3231 + { PseudoVLOXEI64_V_M8_M8_MASK, VLOXEI64_V }, // 3232 + { PseudoVLOXEI8_V_M1_M1, VLOXEI8_V }, // 3233 + { PseudoVLOXEI8_V_M1_M1_MASK, VLOXEI8_V }, // 3234 + { PseudoVLOXEI8_V_M1_M2, VLOXEI8_V }, // 3235 + { PseudoVLOXEI8_V_M1_M2_MASK, VLOXEI8_V }, // 3236 + { PseudoVLOXEI8_V_M1_M4, VLOXEI8_V }, // 3237 + { PseudoVLOXEI8_V_M1_M4_MASK, VLOXEI8_V }, // 3238 + { PseudoVLOXEI8_V_M1_M8, VLOXEI8_V }, // 3239 + { PseudoVLOXEI8_V_M1_M8_MASK, VLOXEI8_V }, // 3240 + { PseudoVLOXEI8_V_M2_M2, VLOXEI8_V }, // 3241 + { PseudoVLOXEI8_V_M2_M2_MASK, VLOXEI8_V }, // 3242 + { PseudoVLOXEI8_V_M2_M4, VLOXEI8_V }, // 3243 + { PseudoVLOXEI8_V_M2_M4_MASK, VLOXEI8_V }, // 3244 + { PseudoVLOXEI8_V_M2_M8, VLOXEI8_V }, // 3245 + { PseudoVLOXEI8_V_M2_M8_MASK, VLOXEI8_V }, // 3246 + { PseudoVLOXEI8_V_M4_M4, VLOXEI8_V }, // 3247 + { PseudoVLOXEI8_V_M4_M4_MASK, VLOXEI8_V }, // 3248 + { PseudoVLOXEI8_V_M4_M8, VLOXEI8_V }, // 3249 + { PseudoVLOXEI8_V_M4_M8_MASK, VLOXEI8_V }, // 3250 + { PseudoVLOXEI8_V_M8_M8, VLOXEI8_V }, // 3251 + { PseudoVLOXEI8_V_M8_M8_MASK, VLOXEI8_V }, // 3252 + { PseudoVLOXEI8_V_MF2_M1, VLOXEI8_V }, // 3253 + { PseudoVLOXEI8_V_MF2_M1_MASK, VLOXEI8_V }, // 3254 + { PseudoVLOXEI8_V_MF2_M2, VLOXEI8_V }, // 3255 + { PseudoVLOXEI8_V_MF2_M2_MASK, VLOXEI8_V }, // 3256 + { PseudoVLOXEI8_V_MF2_M4, VLOXEI8_V }, // 3257 + { PseudoVLOXEI8_V_MF2_M4_MASK, VLOXEI8_V }, // 3258 + { PseudoVLOXEI8_V_MF2_MF2, VLOXEI8_V }, // 3259 + { PseudoVLOXEI8_V_MF2_MF2_MASK, VLOXEI8_V }, // 3260 + { PseudoVLOXEI8_V_MF4_M1, VLOXEI8_V }, // 3261 + { PseudoVLOXEI8_V_MF4_M1_MASK, VLOXEI8_V }, // 3262 + { PseudoVLOXEI8_V_MF4_M2, VLOXEI8_V }, // 3263 + { PseudoVLOXEI8_V_MF4_M2_MASK, VLOXEI8_V }, // 3264 + { PseudoVLOXEI8_V_MF4_MF2, VLOXEI8_V }, // 3265 + { PseudoVLOXEI8_V_MF4_MF2_MASK, VLOXEI8_V }, // 3266 + { PseudoVLOXEI8_V_MF4_MF4, VLOXEI8_V }, // 3267 + { PseudoVLOXEI8_V_MF4_MF4_MASK, VLOXEI8_V }, // 3268 + { PseudoVLOXEI8_V_MF8_M1, VLOXEI8_V }, // 3269 + { PseudoVLOXEI8_V_MF8_M1_MASK, VLOXEI8_V }, // 3270 + { PseudoVLOXEI8_V_MF8_MF2, VLOXEI8_V }, // 3271 + { PseudoVLOXEI8_V_MF8_MF2_MASK, VLOXEI8_V }, // 3272 + { PseudoVLOXEI8_V_MF8_MF4, VLOXEI8_V }, // 3273 + { PseudoVLOXEI8_V_MF8_MF4_MASK, VLOXEI8_V }, // 3274 + { PseudoVLOXEI8_V_MF8_MF8, VLOXEI8_V }, // 3275 + { PseudoVLOXEI8_V_MF8_MF8_MASK, VLOXEI8_V }, // 3276 + { PseudoVLOXSEG2EI16_V_M1_M1, VLOXSEG2EI16_V }, // 3277 + { PseudoVLOXSEG2EI16_V_M1_M1_MASK, VLOXSEG2EI16_V }, // 3278 + { PseudoVLOXSEG2EI16_V_M1_M2, VLOXSEG2EI16_V }, // 3279 + { PseudoVLOXSEG2EI16_V_M1_M2_MASK, VLOXSEG2EI16_V }, // 3280 + { PseudoVLOXSEG2EI16_V_M1_M4, VLOXSEG2EI16_V }, // 3281 + { PseudoVLOXSEG2EI16_V_M1_M4_MASK, VLOXSEG2EI16_V }, // 3282 + { PseudoVLOXSEG2EI16_V_M1_MF2, VLOXSEG2EI16_V }, // 3283 + { PseudoVLOXSEG2EI16_V_M1_MF2_MASK, VLOXSEG2EI16_V }, // 3284 + { PseudoVLOXSEG2EI16_V_M2_M1, VLOXSEG2EI16_V }, // 3285 + { PseudoVLOXSEG2EI16_V_M2_M1_MASK, VLOXSEG2EI16_V }, // 3286 + { PseudoVLOXSEG2EI16_V_M2_M2, VLOXSEG2EI16_V }, // 3287 + { PseudoVLOXSEG2EI16_V_M2_M2_MASK, VLOXSEG2EI16_V }, // 3288 + { PseudoVLOXSEG2EI16_V_M2_M4, VLOXSEG2EI16_V }, // 3289 + { PseudoVLOXSEG2EI16_V_M2_M4_MASK, VLOXSEG2EI16_V }, // 3290 + { PseudoVLOXSEG2EI16_V_M4_M2, VLOXSEG2EI16_V }, // 3291 + { PseudoVLOXSEG2EI16_V_M4_M2_MASK, VLOXSEG2EI16_V }, // 3292 + { PseudoVLOXSEG2EI16_V_M4_M4, VLOXSEG2EI16_V }, // 3293 + { PseudoVLOXSEG2EI16_V_M4_M4_MASK, VLOXSEG2EI16_V }, // 3294 + { PseudoVLOXSEG2EI16_V_M8_M4, VLOXSEG2EI16_V }, // 3295 + { PseudoVLOXSEG2EI16_V_M8_M4_MASK, VLOXSEG2EI16_V }, // 3296 + { PseudoVLOXSEG2EI16_V_MF2_M1, VLOXSEG2EI16_V }, // 3297 + { PseudoVLOXSEG2EI16_V_MF2_M1_MASK, VLOXSEG2EI16_V }, // 3298 + { PseudoVLOXSEG2EI16_V_MF2_M2, VLOXSEG2EI16_V }, // 3299 + { PseudoVLOXSEG2EI16_V_MF2_M2_MASK, VLOXSEG2EI16_V }, // 3300 + { PseudoVLOXSEG2EI16_V_MF2_MF2, VLOXSEG2EI16_V }, // 3301 + { PseudoVLOXSEG2EI16_V_MF2_MF2_MASK, VLOXSEG2EI16_V }, // 3302 + { PseudoVLOXSEG2EI16_V_MF2_MF4, VLOXSEG2EI16_V }, // 3303 + { PseudoVLOXSEG2EI16_V_MF2_MF4_MASK, VLOXSEG2EI16_V }, // 3304 + { PseudoVLOXSEG2EI16_V_MF4_M1, VLOXSEG2EI16_V }, // 3305 + { PseudoVLOXSEG2EI16_V_MF4_M1_MASK, VLOXSEG2EI16_V }, // 3306 + { PseudoVLOXSEG2EI16_V_MF4_MF2, VLOXSEG2EI16_V }, // 3307 + { PseudoVLOXSEG2EI16_V_MF4_MF2_MASK, VLOXSEG2EI16_V }, // 3308 + { PseudoVLOXSEG2EI16_V_MF4_MF4, VLOXSEG2EI16_V }, // 3309 + { PseudoVLOXSEG2EI16_V_MF4_MF4_MASK, VLOXSEG2EI16_V }, // 3310 + { PseudoVLOXSEG2EI16_V_MF4_MF8, VLOXSEG2EI16_V }, // 3311 + { PseudoVLOXSEG2EI16_V_MF4_MF8_MASK, VLOXSEG2EI16_V }, // 3312 + { PseudoVLOXSEG2EI32_V_M1_M1, VLOXSEG2EI32_V }, // 3313 + { PseudoVLOXSEG2EI32_V_M1_M1_MASK, VLOXSEG2EI32_V }, // 3314 + { PseudoVLOXSEG2EI32_V_M1_M2, VLOXSEG2EI32_V }, // 3315 + { PseudoVLOXSEG2EI32_V_M1_M2_MASK, VLOXSEG2EI32_V }, // 3316 + { PseudoVLOXSEG2EI32_V_M1_MF2, VLOXSEG2EI32_V }, // 3317 + { PseudoVLOXSEG2EI32_V_M1_MF2_MASK, VLOXSEG2EI32_V }, // 3318 + { PseudoVLOXSEG2EI32_V_M1_MF4, VLOXSEG2EI32_V }, // 3319 + { PseudoVLOXSEG2EI32_V_M1_MF4_MASK, VLOXSEG2EI32_V }, // 3320 + { PseudoVLOXSEG2EI32_V_M2_M1, VLOXSEG2EI32_V }, // 3321 + { PseudoVLOXSEG2EI32_V_M2_M1_MASK, VLOXSEG2EI32_V }, // 3322 + { PseudoVLOXSEG2EI32_V_M2_M2, VLOXSEG2EI32_V }, // 3323 + { PseudoVLOXSEG2EI32_V_M2_M2_MASK, VLOXSEG2EI32_V }, // 3324 + { PseudoVLOXSEG2EI32_V_M2_M4, VLOXSEG2EI32_V }, // 3325 + { PseudoVLOXSEG2EI32_V_M2_M4_MASK, VLOXSEG2EI32_V }, // 3326 + { PseudoVLOXSEG2EI32_V_M2_MF2, VLOXSEG2EI32_V }, // 3327 + { PseudoVLOXSEG2EI32_V_M2_MF2_MASK, VLOXSEG2EI32_V }, // 3328 + { PseudoVLOXSEG2EI32_V_M4_M1, VLOXSEG2EI32_V }, // 3329 + { PseudoVLOXSEG2EI32_V_M4_M1_MASK, VLOXSEG2EI32_V }, // 3330 + { PseudoVLOXSEG2EI32_V_M4_M2, VLOXSEG2EI32_V }, // 3331 + { PseudoVLOXSEG2EI32_V_M4_M2_MASK, VLOXSEG2EI32_V }, // 3332 + { PseudoVLOXSEG2EI32_V_M4_M4, VLOXSEG2EI32_V }, // 3333 + { PseudoVLOXSEG2EI32_V_M4_M4_MASK, VLOXSEG2EI32_V }, // 3334 + { PseudoVLOXSEG2EI32_V_M8_M2, VLOXSEG2EI32_V }, // 3335 + { PseudoVLOXSEG2EI32_V_M8_M2_MASK, VLOXSEG2EI32_V }, // 3336 + { PseudoVLOXSEG2EI32_V_M8_M4, VLOXSEG2EI32_V }, // 3337 + { PseudoVLOXSEG2EI32_V_M8_M4_MASK, VLOXSEG2EI32_V }, // 3338 + { PseudoVLOXSEG2EI32_V_MF2_M1, VLOXSEG2EI32_V }, // 3339 + { PseudoVLOXSEG2EI32_V_MF2_M1_MASK, VLOXSEG2EI32_V }, // 3340 + { PseudoVLOXSEG2EI32_V_MF2_MF2, VLOXSEG2EI32_V }, // 3341 + { PseudoVLOXSEG2EI32_V_MF2_MF2_MASK, VLOXSEG2EI32_V }, // 3342 + { PseudoVLOXSEG2EI32_V_MF2_MF4, VLOXSEG2EI32_V }, // 3343 + { PseudoVLOXSEG2EI32_V_MF2_MF4_MASK, VLOXSEG2EI32_V }, // 3344 + { PseudoVLOXSEG2EI32_V_MF2_MF8, VLOXSEG2EI32_V }, // 3345 + { PseudoVLOXSEG2EI32_V_MF2_MF8_MASK, VLOXSEG2EI32_V }, // 3346 + { PseudoVLOXSEG2EI64_V_M1_M1, VLOXSEG2EI64_V }, // 3347 + { PseudoVLOXSEG2EI64_V_M1_M1_MASK, VLOXSEG2EI64_V }, // 3348 + { PseudoVLOXSEG2EI64_V_M1_MF2, VLOXSEG2EI64_V }, // 3349 + { PseudoVLOXSEG2EI64_V_M1_MF2_MASK, VLOXSEG2EI64_V }, // 3350 + { PseudoVLOXSEG2EI64_V_M1_MF4, VLOXSEG2EI64_V }, // 3351 + { PseudoVLOXSEG2EI64_V_M1_MF4_MASK, VLOXSEG2EI64_V }, // 3352 + { PseudoVLOXSEG2EI64_V_M1_MF8, VLOXSEG2EI64_V }, // 3353 + { PseudoVLOXSEG2EI64_V_M1_MF8_MASK, VLOXSEG2EI64_V }, // 3354 + { PseudoVLOXSEG2EI64_V_M2_M1, VLOXSEG2EI64_V }, // 3355 + { PseudoVLOXSEG2EI64_V_M2_M1_MASK, VLOXSEG2EI64_V }, // 3356 + { PseudoVLOXSEG2EI64_V_M2_M2, VLOXSEG2EI64_V }, // 3357 + { PseudoVLOXSEG2EI64_V_M2_M2_MASK, VLOXSEG2EI64_V }, // 3358 + { PseudoVLOXSEG2EI64_V_M2_MF2, VLOXSEG2EI64_V }, // 3359 + { PseudoVLOXSEG2EI64_V_M2_MF2_MASK, VLOXSEG2EI64_V }, // 3360 + { PseudoVLOXSEG2EI64_V_M2_MF4, VLOXSEG2EI64_V }, // 3361 + { PseudoVLOXSEG2EI64_V_M2_MF4_MASK, VLOXSEG2EI64_V }, // 3362 + { PseudoVLOXSEG2EI64_V_M4_M1, VLOXSEG2EI64_V }, // 3363 + { PseudoVLOXSEG2EI64_V_M4_M1_MASK, VLOXSEG2EI64_V }, // 3364 + { PseudoVLOXSEG2EI64_V_M4_M2, VLOXSEG2EI64_V }, // 3365 + { PseudoVLOXSEG2EI64_V_M4_M2_MASK, VLOXSEG2EI64_V }, // 3366 + { PseudoVLOXSEG2EI64_V_M4_M4, VLOXSEG2EI64_V }, // 3367 + { PseudoVLOXSEG2EI64_V_M4_M4_MASK, VLOXSEG2EI64_V }, // 3368 + { PseudoVLOXSEG2EI64_V_M4_MF2, VLOXSEG2EI64_V }, // 3369 + { PseudoVLOXSEG2EI64_V_M4_MF2_MASK, VLOXSEG2EI64_V }, // 3370 + { PseudoVLOXSEG2EI64_V_M8_M1, VLOXSEG2EI64_V }, // 3371 + { PseudoVLOXSEG2EI64_V_M8_M1_MASK, VLOXSEG2EI64_V }, // 3372 + { PseudoVLOXSEG2EI64_V_M8_M2, VLOXSEG2EI64_V }, // 3373 + { PseudoVLOXSEG2EI64_V_M8_M2_MASK, VLOXSEG2EI64_V }, // 3374 + { PseudoVLOXSEG2EI64_V_M8_M4, VLOXSEG2EI64_V }, // 3375 + { PseudoVLOXSEG2EI64_V_M8_M4_MASK, VLOXSEG2EI64_V }, // 3376 + { PseudoVLOXSEG2EI8_V_M1_M1, VLOXSEG2EI8_V }, // 3377 + { PseudoVLOXSEG2EI8_V_M1_M1_MASK, VLOXSEG2EI8_V }, // 3378 + { PseudoVLOXSEG2EI8_V_M1_M2, VLOXSEG2EI8_V }, // 3379 + { PseudoVLOXSEG2EI8_V_M1_M2_MASK, VLOXSEG2EI8_V }, // 3380 + { PseudoVLOXSEG2EI8_V_M1_M4, VLOXSEG2EI8_V }, // 3381 + { PseudoVLOXSEG2EI8_V_M1_M4_MASK, VLOXSEG2EI8_V }, // 3382 + { PseudoVLOXSEG2EI8_V_M2_M2, VLOXSEG2EI8_V }, // 3383 + { PseudoVLOXSEG2EI8_V_M2_M2_MASK, VLOXSEG2EI8_V }, // 3384 + { PseudoVLOXSEG2EI8_V_M2_M4, VLOXSEG2EI8_V }, // 3385 + { PseudoVLOXSEG2EI8_V_M2_M4_MASK, VLOXSEG2EI8_V }, // 3386 + { PseudoVLOXSEG2EI8_V_M4_M4, VLOXSEG2EI8_V }, // 3387 + { PseudoVLOXSEG2EI8_V_M4_M4_MASK, VLOXSEG2EI8_V }, // 3388 + { PseudoVLOXSEG2EI8_V_MF2_M1, VLOXSEG2EI8_V }, // 3389 + { PseudoVLOXSEG2EI8_V_MF2_M1_MASK, VLOXSEG2EI8_V }, // 3390 + { PseudoVLOXSEG2EI8_V_MF2_M2, VLOXSEG2EI8_V }, // 3391 + { PseudoVLOXSEG2EI8_V_MF2_M2_MASK, VLOXSEG2EI8_V }, // 3392 + { PseudoVLOXSEG2EI8_V_MF2_M4, VLOXSEG2EI8_V }, // 3393 + { PseudoVLOXSEG2EI8_V_MF2_M4_MASK, VLOXSEG2EI8_V }, // 3394 + { PseudoVLOXSEG2EI8_V_MF2_MF2, VLOXSEG2EI8_V }, // 3395 + { PseudoVLOXSEG2EI8_V_MF2_MF2_MASK, VLOXSEG2EI8_V }, // 3396 + { PseudoVLOXSEG2EI8_V_MF4_M1, VLOXSEG2EI8_V }, // 3397 + { PseudoVLOXSEG2EI8_V_MF4_M1_MASK, VLOXSEG2EI8_V }, // 3398 + { PseudoVLOXSEG2EI8_V_MF4_M2, VLOXSEG2EI8_V }, // 3399 + { PseudoVLOXSEG2EI8_V_MF4_M2_MASK, VLOXSEG2EI8_V }, // 3400 + { PseudoVLOXSEG2EI8_V_MF4_MF2, VLOXSEG2EI8_V }, // 3401 + { PseudoVLOXSEG2EI8_V_MF4_MF2_MASK, VLOXSEG2EI8_V }, // 3402 + { PseudoVLOXSEG2EI8_V_MF4_MF4, VLOXSEG2EI8_V }, // 3403 + { PseudoVLOXSEG2EI8_V_MF4_MF4_MASK, VLOXSEG2EI8_V }, // 3404 + { PseudoVLOXSEG2EI8_V_MF8_M1, VLOXSEG2EI8_V }, // 3405 + { PseudoVLOXSEG2EI8_V_MF8_M1_MASK, VLOXSEG2EI8_V }, // 3406 + { PseudoVLOXSEG2EI8_V_MF8_MF2, VLOXSEG2EI8_V }, // 3407 + { PseudoVLOXSEG2EI8_V_MF8_MF2_MASK, VLOXSEG2EI8_V }, // 3408 + { PseudoVLOXSEG2EI8_V_MF8_MF4, VLOXSEG2EI8_V }, // 3409 + { PseudoVLOXSEG2EI8_V_MF8_MF4_MASK, VLOXSEG2EI8_V }, // 3410 + { PseudoVLOXSEG2EI8_V_MF8_MF8, VLOXSEG2EI8_V }, // 3411 + { PseudoVLOXSEG2EI8_V_MF8_MF8_MASK, VLOXSEG2EI8_V }, // 3412 + { PseudoVLOXSEG3EI16_V_M1_M1, VLOXSEG3EI16_V }, // 3413 + { PseudoVLOXSEG3EI16_V_M1_M1_MASK, VLOXSEG3EI16_V }, // 3414 + { PseudoVLOXSEG3EI16_V_M1_M2, VLOXSEG3EI16_V }, // 3415 + { PseudoVLOXSEG3EI16_V_M1_M2_MASK, VLOXSEG3EI16_V }, // 3416 + { PseudoVLOXSEG3EI16_V_M1_MF2, VLOXSEG3EI16_V }, // 3417 + { PseudoVLOXSEG3EI16_V_M1_MF2_MASK, VLOXSEG3EI16_V }, // 3418 + { PseudoVLOXSEG3EI16_V_M2_M1, VLOXSEG3EI16_V }, // 3419 + { PseudoVLOXSEG3EI16_V_M2_M1_MASK, VLOXSEG3EI16_V }, // 3420 + { PseudoVLOXSEG3EI16_V_M2_M2, VLOXSEG3EI16_V }, // 3421 + { PseudoVLOXSEG3EI16_V_M2_M2_MASK, VLOXSEG3EI16_V }, // 3422 + { PseudoVLOXSEG3EI16_V_M4_M2, VLOXSEG3EI16_V }, // 3423 + { PseudoVLOXSEG3EI16_V_M4_M2_MASK, VLOXSEG3EI16_V }, // 3424 + { PseudoVLOXSEG3EI16_V_MF2_M1, VLOXSEG3EI16_V }, // 3425 + { PseudoVLOXSEG3EI16_V_MF2_M1_MASK, VLOXSEG3EI16_V }, // 3426 + { PseudoVLOXSEG3EI16_V_MF2_M2, VLOXSEG3EI16_V }, // 3427 + { PseudoVLOXSEG3EI16_V_MF2_M2_MASK, VLOXSEG3EI16_V }, // 3428 + { PseudoVLOXSEG3EI16_V_MF2_MF2, VLOXSEG3EI16_V }, // 3429 + { PseudoVLOXSEG3EI16_V_MF2_MF2_MASK, VLOXSEG3EI16_V }, // 3430 + { PseudoVLOXSEG3EI16_V_MF2_MF4, VLOXSEG3EI16_V }, // 3431 + { PseudoVLOXSEG3EI16_V_MF2_MF4_MASK, VLOXSEG3EI16_V }, // 3432 + { PseudoVLOXSEG3EI16_V_MF4_M1, VLOXSEG3EI16_V }, // 3433 + { PseudoVLOXSEG3EI16_V_MF4_M1_MASK, VLOXSEG3EI16_V }, // 3434 + { PseudoVLOXSEG3EI16_V_MF4_MF2, VLOXSEG3EI16_V }, // 3435 + { PseudoVLOXSEG3EI16_V_MF4_MF2_MASK, VLOXSEG3EI16_V }, // 3436 + { PseudoVLOXSEG3EI16_V_MF4_MF4, VLOXSEG3EI16_V }, // 3437 + { PseudoVLOXSEG3EI16_V_MF4_MF4_MASK, VLOXSEG3EI16_V }, // 3438 + { PseudoVLOXSEG3EI16_V_MF4_MF8, VLOXSEG3EI16_V }, // 3439 + { PseudoVLOXSEG3EI16_V_MF4_MF8_MASK, VLOXSEG3EI16_V }, // 3440 + { PseudoVLOXSEG3EI32_V_M1_M1, VLOXSEG3EI32_V }, // 3441 + { PseudoVLOXSEG3EI32_V_M1_M1_MASK, VLOXSEG3EI32_V }, // 3442 + { PseudoVLOXSEG3EI32_V_M1_M2, VLOXSEG3EI32_V }, // 3443 + { PseudoVLOXSEG3EI32_V_M1_M2_MASK, VLOXSEG3EI32_V }, // 3444 + { PseudoVLOXSEG3EI32_V_M1_MF2, VLOXSEG3EI32_V }, // 3445 + { PseudoVLOXSEG3EI32_V_M1_MF2_MASK, VLOXSEG3EI32_V }, // 3446 + { PseudoVLOXSEG3EI32_V_M1_MF4, VLOXSEG3EI32_V }, // 3447 + { PseudoVLOXSEG3EI32_V_M1_MF4_MASK, VLOXSEG3EI32_V }, // 3448 + { PseudoVLOXSEG3EI32_V_M2_M1, VLOXSEG3EI32_V }, // 3449 + { PseudoVLOXSEG3EI32_V_M2_M1_MASK, VLOXSEG3EI32_V }, // 3450 + { PseudoVLOXSEG3EI32_V_M2_M2, VLOXSEG3EI32_V }, // 3451 + { PseudoVLOXSEG3EI32_V_M2_M2_MASK, VLOXSEG3EI32_V }, // 3452 + { PseudoVLOXSEG3EI32_V_M2_MF2, VLOXSEG3EI32_V }, // 3453 + { PseudoVLOXSEG3EI32_V_M2_MF2_MASK, VLOXSEG3EI32_V }, // 3454 + { PseudoVLOXSEG3EI32_V_M4_M1, VLOXSEG3EI32_V }, // 3455 + { PseudoVLOXSEG3EI32_V_M4_M1_MASK, VLOXSEG3EI32_V }, // 3456 + { PseudoVLOXSEG3EI32_V_M4_M2, VLOXSEG3EI32_V }, // 3457 + { PseudoVLOXSEG3EI32_V_M4_M2_MASK, VLOXSEG3EI32_V }, // 3458 + { PseudoVLOXSEG3EI32_V_M8_M2, VLOXSEG3EI32_V }, // 3459 + { PseudoVLOXSEG3EI32_V_M8_M2_MASK, VLOXSEG3EI32_V }, // 3460 + { PseudoVLOXSEG3EI32_V_MF2_M1, VLOXSEG3EI32_V }, // 3461 + { PseudoVLOXSEG3EI32_V_MF2_M1_MASK, VLOXSEG3EI32_V }, // 3462 + { PseudoVLOXSEG3EI32_V_MF2_MF2, VLOXSEG3EI32_V }, // 3463 + { PseudoVLOXSEG3EI32_V_MF2_MF2_MASK, VLOXSEG3EI32_V }, // 3464 + { PseudoVLOXSEG3EI32_V_MF2_MF4, VLOXSEG3EI32_V }, // 3465 + { PseudoVLOXSEG3EI32_V_MF2_MF4_MASK, VLOXSEG3EI32_V }, // 3466 + { PseudoVLOXSEG3EI32_V_MF2_MF8, VLOXSEG3EI32_V }, // 3467 + { PseudoVLOXSEG3EI32_V_MF2_MF8_MASK, VLOXSEG3EI32_V }, // 3468 + { PseudoVLOXSEG3EI64_V_M1_M1, VLOXSEG3EI64_V }, // 3469 + { PseudoVLOXSEG3EI64_V_M1_M1_MASK, VLOXSEG3EI64_V }, // 3470 + { PseudoVLOXSEG3EI64_V_M1_MF2, VLOXSEG3EI64_V }, // 3471 + { PseudoVLOXSEG3EI64_V_M1_MF2_MASK, VLOXSEG3EI64_V }, // 3472 + { PseudoVLOXSEG3EI64_V_M1_MF4, VLOXSEG3EI64_V }, // 3473 + { PseudoVLOXSEG3EI64_V_M1_MF4_MASK, VLOXSEG3EI64_V }, // 3474 + { PseudoVLOXSEG3EI64_V_M1_MF8, VLOXSEG3EI64_V }, // 3475 + { PseudoVLOXSEG3EI64_V_M1_MF8_MASK, VLOXSEG3EI64_V }, // 3476 + { PseudoVLOXSEG3EI64_V_M2_M1, VLOXSEG3EI64_V }, // 3477 + { PseudoVLOXSEG3EI64_V_M2_M1_MASK, VLOXSEG3EI64_V }, // 3478 + { PseudoVLOXSEG3EI64_V_M2_M2, VLOXSEG3EI64_V }, // 3479 + { PseudoVLOXSEG3EI64_V_M2_M2_MASK, VLOXSEG3EI64_V }, // 3480 + { PseudoVLOXSEG3EI64_V_M2_MF2, VLOXSEG3EI64_V }, // 3481 + { PseudoVLOXSEG3EI64_V_M2_MF2_MASK, VLOXSEG3EI64_V }, // 3482 + { PseudoVLOXSEG3EI64_V_M2_MF4, VLOXSEG3EI64_V }, // 3483 + { PseudoVLOXSEG3EI64_V_M2_MF4_MASK, VLOXSEG3EI64_V }, // 3484 + { PseudoVLOXSEG3EI64_V_M4_M1, VLOXSEG3EI64_V }, // 3485 + { PseudoVLOXSEG3EI64_V_M4_M1_MASK, VLOXSEG3EI64_V }, // 3486 + { PseudoVLOXSEG3EI64_V_M4_M2, VLOXSEG3EI64_V }, // 3487 + { PseudoVLOXSEG3EI64_V_M4_M2_MASK, VLOXSEG3EI64_V }, // 3488 + { PseudoVLOXSEG3EI64_V_M4_MF2, VLOXSEG3EI64_V }, // 3489 + { PseudoVLOXSEG3EI64_V_M4_MF2_MASK, VLOXSEG3EI64_V }, // 3490 + { PseudoVLOXSEG3EI64_V_M8_M1, VLOXSEG3EI64_V }, // 3491 + { PseudoVLOXSEG3EI64_V_M8_M1_MASK, VLOXSEG3EI64_V }, // 3492 + { PseudoVLOXSEG3EI64_V_M8_M2, VLOXSEG3EI64_V }, // 3493 + { PseudoVLOXSEG3EI64_V_M8_M2_MASK, VLOXSEG3EI64_V }, // 3494 + { PseudoVLOXSEG3EI8_V_M1_M1, VLOXSEG3EI8_V }, // 3495 + { PseudoVLOXSEG3EI8_V_M1_M1_MASK, VLOXSEG3EI8_V }, // 3496 + { PseudoVLOXSEG3EI8_V_M1_M2, VLOXSEG3EI8_V }, // 3497 + { PseudoVLOXSEG3EI8_V_M1_M2_MASK, VLOXSEG3EI8_V }, // 3498 + { PseudoVLOXSEG3EI8_V_M2_M2, VLOXSEG3EI8_V }, // 3499 + { PseudoVLOXSEG3EI8_V_M2_M2_MASK, VLOXSEG3EI8_V }, // 3500 + { PseudoVLOXSEG3EI8_V_MF2_M1, VLOXSEG3EI8_V }, // 3501 + { PseudoVLOXSEG3EI8_V_MF2_M1_MASK, VLOXSEG3EI8_V }, // 3502 + { PseudoVLOXSEG3EI8_V_MF2_M2, VLOXSEG3EI8_V }, // 3503 + { PseudoVLOXSEG3EI8_V_MF2_M2_MASK, VLOXSEG3EI8_V }, // 3504 + { PseudoVLOXSEG3EI8_V_MF2_MF2, VLOXSEG3EI8_V }, // 3505 + { PseudoVLOXSEG3EI8_V_MF2_MF2_MASK, VLOXSEG3EI8_V }, // 3506 + { PseudoVLOXSEG3EI8_V_MF4_M1, VLOXSEG3EI8_V }, // 3507 + { PseudoVLOXSEG3EI8_V_MF4_M1_MASK, VLOXSEG3EI8_V }, // 3508 + { PseudoVLOXSEG3EI8_V_MF4_M2, VLOXSEG3EI8_V }, // 3509 + { PseudoVLOXSEG3EI8_V_MF4_M2_MASK, VLOXSEG3EI8_V }, // 3510 + { PseudoVLOXSEG3EI8_V_MF4_MF2, VLOXSEG3EI8_V }, // 3511 + { PseudoVLOXSEG3EI8_V_MF4_MF2_MASK, VLOXSEG3EI8_V }, // 3512 + { PseudoVLOXSEG3EI8_V_MF4_MF4, VLOXSEG3EI8_V }, // 3513 + { PseudoVLOXSEG3EI8_V_MF4_MF4_MASK, VLOXSEG3EI8_V }, // 3514 + { PseudoVLOXSEG3EI8_V_MF8_M1, VLOXSEG3EI8_V }, // 3515 + { PseudoVLOXSEG3EI8_V_MF8_M1_MASK, VLOXSEG3EI8_V }, // 3516 + { PseudoVLOXSEG3EI8_V_MF8_MF2, VLOXSEG3EI8_V }, // 3517 + { PseudoVLOXSEG3EI8_V_MF8_MF2_MASK, VLOXSEG3EI8_V }, // 3518 + { PseudoVLOXSEG3EI8_V_MF8_MF4, VLOXSEG3EI8_V }, // 3519 + { PseudoVLOXSEG3EI8_V_MF8_MF4_MASK, VLOXSEG3EI8_V }, // 3520 + { PseudoVLOXSEG3EI8_V_MF8_MF8, VLOXSEG3EI8_V }, // 3521 + { PseudoVLOXSEG3EI8_V_MF8_MF8_MASK, VLOXSEG3EI8_V }, // 3522 + { PseudoVLOXSEG4EI16_V_M1_M1, VLOXSEG4EI16_V }, // 3523 + { PseudoVLOXSEG4EI16_V_M1_M1_MASK, VLOXSEG4EI16_V }, // 3524 + { PseudoVLOXSEG4EI16_V_M1_M2, VLOXSEG4EI16_V }, // 3525 + { PseudoVLOXSEG4EI16_V_M1_M2_MASK, VLOXSEG4EI16_V }, // 3526 + { PseudoVLOXSEG4EI16_V_M1_MF2, VLOXSEG4EI16_V }, // 3527 + { PseudoVLOXSEG4EI16_V_M1_MF2_MASK, VLOXSEG4EI16_V }, // 3528 + { PseudoVLOXSEG4EI16_V_M2_M1, VLOXSEG4EI16_V }, // 3529 + { PseudoVLOXSEG4EI16_V_M2_M1_MASK, VLOXSEG4EI16_V }, // 3530 + { PseudoVLOXSEG4EI16_V_M2_M2, VLOXSEG4EI16_V }, // 3531 + { PseudoVLOXSEG4EI16_V_M2_M2_MASK, VLOXSEG4EI16_V }, // 3532 + { PseudoVLOXSEG4EI16_V_M4_M2, VLOXSEG4EI16_V }, // 3533 + { PseudoVLOXSEG4EI16_V_M4_M2_MASK, VLOXSEG4EI16_V }, // 3534 + { PseudoVLOXSEG4EI16_V_MF2_M1, VLOXSEG4EI16_V }, // 3535 + { PseudoVLOXSEG4EI16_V_MF2_M1_MASK, VLOXSEG4EI16_V }, // 3536 + { PseudoVLOXSEG4EI16_V_MF2_M2, VLOXSEG4EI16_V }, // 3537 + { PseudoVLOXSEG4EI16_V_MF2_M2_MASK, VLOXSEG4EI16_V }, // 3538 + { PseudoVLOXSEG4EI16_V_MF2_MF2, VLOXSEG4EI16_V }, // 3539 + { PseudoVLOXSEG4EI16_V_MF2_MF2_MASK, VLOXSEG4EI16_V }, // 3540 + { PseudoVLOXSEG4EI16_V_MF2_MF4, VLOXSEG4EI16_V }, // 3541 + { PseudoVLOXSEG4EI16_V_MF2_MF4_MASK, VLOXSEG4EI16_V }, // 3542 + { PseudoVLOXSEG4EI16_V_MF4_M1, VLOXSEG4EI16_V }, // 3543 + { PseudoVLOXSEG4EI16_V_MF4_M1_MASK, VLOXSEG4EI16_V }, // 3544 + { PseudoVLOXSEG4EI16_V_MF4_MF2, VLOXSEG4EI16_V }, // 3545 + { PseudoVLOXSEG4EI16_V_MF4_MF2_MASK, VLOXSEG4EI16_V }, // 3546 + { PseudoVLOXSEG4EI16_V_MF4_MF4, VLOXSEG4EI16_V }, // 3547 + { PseudoVLOXSEG4EI16_V_MF4_MF4_MASK, VLOXSEG4EI16_V }, // 3548 + { PseudoVLOXSEG4EI16_V_MF4_MF8, VLOXSEG4EI16_V }, // 3549 + { PseudoVLOXSEG4EI16_V_MF4_MF8_MASK, VLOXSEG4EI16_V }, // 3550 + { PseudoVLOXSEG4EI32_V_M1_M1, VLOXSEG4EI32_V }, // 3551 + { PseudoVLOXSEG4EI32_V_M1_M1_MASK, VLOXSEG4EI32_V }, // 3552 + { PseudoVLOXSEG4EI32_V_M1_M2, VLOXSEG4EI32_V }, // 3553 + { PseudoVLOXSEG4EI32_V_M1_M2_MASK, VLOXSEG4EI32_V }, // 3554 + { PseudoVLOXSEG4EI32_V_M1_MF2, VLOXSEG4EI32_V }, // 3555 + { PseudoVLOXSEG4EI32_V_M1_MF2_MASK, VLOXSEG4EI32_V }, // 3556 + { PseudoVLOXSEG4EI32_V_M1_MF4, VLOXSEG4EI32_V }, // 3557 + { PseudoVLOXSEG4EI32_V_M1_MF4_MASK, VLOXSEG4EI32_V }, // 3558 + { PseudoVLOXSEG4EI32_V_M2_M1, VLOXSEG4EI32_V }, // 3559 + { PseudoVLOXSEG4EI32_V_M2_M1_MASK, VLOXSEG4EI32_V }, // 3560 + { PseudoVLOXSEG4EI32_V_M2_M2, VLOXSEG4EI32_V }, // 3561 + { PseudoVLOXSEG4EI32_V_M2_M2_MASK, VLOXSEG4EI32_V }, // 3562 + { PseudoVLOXSEG4EI32_V_M2_MF2, VLOXSEG4EI32_V }, // 3563 + { PseudoVLOXSEG4EI32_V_M2_MF2_MASK, VLOXSEG4EI32_V }, // 3564 + { PseudoVLOXSEG4EI32_V_M4_M1, VLOXSEG4EI32_V }, // 3565 + { PseudoVLOXSEG4EI32_V_M4_M1_MASK, VLOXSEG4EI32_V }, // 3566 + { PseudoVLOXSEG4EI32_V_M4_M2, VLOXSEG4EI32_V }, // 3567 + { PseudoVLOXSEG4EI32_V_M4_M2_MASK, VLOXSEG4EI32_V }, // 3568 + { PseudoVLOXSEG4EI32_V_M8_M2, VLOXSEG4EI32_V }, // 3569 + { PseudoVLOXSEG4EI32_V_M8_M2_MASK, VLOXSEG4EI32_V }, // 3570 + { PseudoVLOXSEG4EI32_V_MF2_M1, VLOXSEG4EI32_V }, // 3571 + { PseudoVLOXSEG4EI32_V_MF2_M1_MASK, VLOXSEG4EI32_V }, // 3572 + { PseudoVLOXSEG4EI32_V_MF2_MF2, VLOXSEG4EI32_V }, // 3573 + { PseudoVLOXSEG4EI32_V_MF2_MF2_MASK, VLOXSEG4EI32_V }, // 3574 + { PseudoVLOXSEG4EI32_V_MF2_MF4, VLOXSEG4EI32_V }, // 3575 + { PseudoVLOXSEG4EI32_V_MF2_MF4_MASK, VLOXSEG4EI32_V }, // 3576 + { PseudoVLOXSEG4EI32_V_MF2_MF8, VLOXSEG4EI32_V }, // 3577 + { PseudoVLOXSEG4EI32_V_MF2_MF8_MASK, VLOXSEG4EI32_V }, // 3578 + { PseudoVLOXSEG4EI64_V_M1_M1, VLOXSEG4EI64_V }, // 3579 + { PseudoVLOXSEG4EI64_V_M1_M1_MASK, VLOXSEG4EI64_V }, // 3580 + { PseudoVLOXSEG4EI64_V_M1_MF2, VLOXSEG4EI64_V }, // 3581 + { PseudoVLOXSEG4EI64_V_M1_MF2_MASK, VLOXSEG4EI64_V }, // 3582 + { PseudoVLOXSEG4EI64_V_M1_MF4, VLOXSEG4EI64_V }, // 3583 + { PseudoVLOXSEG4EI64_V_M1_MF4_MASK, VLOXSEG4EI64_V }, // 3584 + { PseudoVLOXSEG4EI64_V_M1_MF8, VLOXSEG4EI64_V }, // 3585 + { PseudoVLOXSEG4EI64_V_M1_MF8_MASK, VLOXSEG4EI64_V }, // 3586 + { PseudoVLOXSEG4EI64_V_M2_M1, VLOXSEG4EI64_V }, // 3587 + { PseudoVLOXSEG4EI64_V_M2_M1_MASK, VLOXSEG4EI64_V }, // 3588 + { PseudoVLOXSEG4EI64_V_M2_M2, VLOXSEG4EI64_V }, // 3589 + { PseudoVLOXSEG4EI64_V_M2_M2_MASK, VLOXSEG4EI64_V }, // 3590 + { PseudoVLOXSEG4EI64_V_M2_MF2, VLOXSEG4EI64_V }, // 3591 + { PseudoVLOXSEG4EI64_V_M2_MF2_MASK, VLOXSEG4EI64_V }, // 3592 + { PseudoVLOXSEG4EI64_V_M2_MF4, VLOXSEG4EI64_V }, // 3593 + { PseudoVLOXSEG4EI64_V_M2_MF4_MASK, VLOXSEG4EI64_V }, // 3594 + { PseudoVLOXSEG4EI64_V_M4_M1, VLOXSEG4EI64_V }, // 3595 + { PseudoVLOXSEG4EI64_V_M4_M1_MASK, VLOXSEG4EI64_V }, // 3596 + { PseudoVLOXSEG4EI64_V_M4_M2, VLOXSEG4EI64_V }, // 3597 + { PseudoVLOXSEG4EI64_V_M4_M2_MASK, VLOXSEG4EI64_V }, // 3598 + { PseudoVLOXSEG4EI64_V_M4_MF2, VLOXSEG4EI64_V }, // 3599 + { PseudoVLOXSEG4EI64_V_M4_MF2_MASK, VLOXSEG4EI64_V }, // 3600 + { PseudoVLOXSEG4EI64_V_M8_M1, VLOXSEG4EI64_V }, // 3601 + { PseudoVLOXSEG4EI64_V_M8_M1_MASK, VLOXSEG4EI64_V }, // 3602 + { PseudoVLOXSEG4EI64_V_M8_M2, VLOXSEG4EI64_V }, // 3603 + { PseudoVLOXSEG4EI64_V_M8_M2_MASK, VLOXSEG4EI64_V }, // 3604 + { PseudoVLOXSEG4EI8_V_M1_M1, VLOXSEG4EI8_V }, // 3605 + { PseudoVLOXSEG4EI8_V_M1_M1_MASK, VLOXSEG4EI8_V }, // 3606 + { PseudoVLOXSEG4EI8_V_M1_M2, VLOXSEG4EI8_V }, // 3607 + { PseudoVLOXSEG4EI8_V_M1_M2_MASK, VLOXSEG4EI8_V }, // 3608 + { PseudoVLOXSEG4EI8_V_M2_M2, VLOXSEG4EI8_V }, // 3609 + { PseudoVLOXSEG4EI8_V_M2_M2_MASK, VLOXSEG4EI8_V }, // 3610 + { PseudoVLOXSEG4EI8_V_MF2_M1, VLOXSEG4EI8_V }, // 3611 + { PseudoVLOXSEG4EI8_V_MF2_M1_MASK, VLOXSEG4EI8_V }, // 3612 + { PseudoVLOXSEG4EI8_V_MF2_M2, VLOXSEG4EI8_V }, // 3613 + { PseudoVLOXSEG4EI8_V_MF2_M2_MASK, VLOXSEG4EI8_V }, // 3614 + { PseudoVLOXSEG4EI8_V_MF2_MF2, VLOXSEG4EI8_V }, // 3615 + { PseudoVLOXSEG4EI8_V_MF2_MF2_MASK, VLOXSEG4EI8_V }, // 3616 + { PseudoVLOXSEG4EI8_V_MF4_M1, VLOXSEG4EI8_V }, // 3617 + { PseudoVLOXSEG4EI8_V_MF4_M1_MASK, VLOXSEG4EI8_V }, // 3618 + { PseudoVLOXSEG4EI8_V_MF4_M2, VLOXSEG4EI8_V }, // 3619 + { PseudoVLOXSEG4EI8_V_MF4_M2_MASK, VLOXSEG4EI8_V }, // 3620 + { PseudoVLOXSEG4EI8_V_MF4_MF2, VLOXSEG4EI8_V }, // 3621 + { PseudoVLOXSEG4EI8_V_MF4_MF2_MASK, VLOXSEG4EI8_V }, // 3622 + { PseudoVLOXSEG4EI8_V_MF4_MF4, VLOXSEG4EI8_V }, // 3623 + { PseudoVLOXSEG4EI8_V_MF4_MF4_MASK, VLOXSEG4EI8_V }, // 3624 + { PseudoVLOXSEG4EI8_V_MF8_M1, VLOXSEG4EI8_V }, // 3625 + { PseudoVLOXSEG4EI8_V_MF8_M1_MASK, VLOXSEG4EI8_V }, // 3626 + { PseudoVLOXSEG4EI8_V_MF8_MF2, VLOXSEG4EI8_V }, // 3627 + { PseudoVLOXSEG4EI8_V_MF8_MF2_MASK, VLOXSEG4EI8_V }, // 3628 + { PseudoVLOXSEG4EI8_V_MF8_MF4, VLOXSEG4EI8_V }, // 3629 + { PseudoVLOXSEG4EI8_V_MF8_MF4_MASK, VLOXSEG4EI8_V }, // 3630 + { PseudoVLOXSEG4EI8_V_MF8_MF8, VLOXSEG4EI8_V }, // 3631 + { PseudoVLOXSEG4EI8_V_MF8_MF8_MASK, VLOXSEG4EI8_V }, // 3632 + { PseudoVLOXSEG5EI16_V_M1_M1, VLOXSEG5EI16_V }, // 3633 + { PseudoVLOXSEG5EI16_V_M1_M1_MASK, VLOXSEG5EI16_V }, // 3634 + { PseudoVLOXSEG5EI16_V_M1_MF2, VLOXSEG5EI16_V }, // 3635 + { PseudoVLOXSEG5EI16_V_M1_MF2_MASK, VLOXSEG5EI16_V }, // 3636 + { PseudoVLOXSEG5EI16_V_M2_M1, VLOXSEG5EI16_V }, // 3637 + { PseudoVLOXSEG5EI16_V_M2_M1_MASK, VLOXSEG5EI16_V }, // 3638 + { PseudoVLOXSEG5EI16_V_MF2_M1, VLOXSEG5EI16_V }, // 3639 + { PseudoVLOXSEG5EI16_V_MF2_M1_MASK, VLOXSEG5EI16_V }, // 3640 + { PseudoVLOXSEG5EI16_V_MF2_MF2, VLOXSEG5EI16_V }, // 3641 + { PseudoVLOXSEG5EI16_V_MF2_MF2_MASK, VLOXSEG5EI16_V }, // 3642 + { PseudoVLOXSEG5EI16_V_MF2_MF4, VLOXSEG5EI16_V }, // 3643 + { PseudoVLOXSEG5EI16_V_MF2_MF4_MASK, VLOXSEG5EI16_V }, // 3644 + { PseudoVLOXSEG5EI16_V_MF4_M1, VLOXSEG5EI16_V }, // 3645 + { PseudoVLOXSEG5EI16_V_MF4_M1_MASK, VLOXSEG5EI16_V }, // 3646 + { PseudoVLOXSEG5EI16_V_MF4_MF2, VLOXSEG5EI16_V }, // 3647 + { PseudoVLOXSEG5EI16_V_MF4_MF2_MASK, VLOXSEG5EI16_V }, // 3648 + { PseudoVLOXSEG5EI16_V_MF4_MF4, VLOXSEG5EI16_V }, // 3649 + { PseudoVLOXSEG5EI16_V_MF4_MF4_MASK, VLOXSEG5EI16_V }, // 3650 + { PseudoVLOXSEG5EI16_V_MF4_MF8, VLOXSEG5EI16_V }, // 3651 + { PseudoVLOXSEG5EI16_V_MF4_MF8_MASK, VLOXSEG5EI16_V }, // 3652 + { PseudoVLOXSEG5EI32_V_M1_M1, VLOXSEG5EI32_V }, // 3653 + { PseudoVLOXSEG5EI32_V_M1_M1_MASK, VLOXSEG5EI32_V }, // 3654 + { PseudoVLOXSEG5EI32_V_M1_MF2, VLOXSEG5EI32_V }, // 3655 + { PseudoVLOXSEG5EI32_V_M1_MF2_MASK, VLOXSEG5EI32_V }, // 3656 + { PseudoVLOXSEG5EI32_V_M1_MF4, VLOXSEG5EI32_V }, // 3657 + { PseudoVLOXSEG5EI32_V_M1_MF4_MASK, VLOXSEG5EI32_V }, // 3658 + { PseudoVLOXSEG5EI32_V_M2_M1, VLOXSEG5EI32_V }, // 3659 + { PseudoVLOXSEG5EI32_V_M2_M1_MASK, VLOXSEG5EI32_V }, // 3660 + { PseudoVLOXSEG5EI32_V_M2_MF2, VLOXSEG5EI32_V }, // 3661 + { PseudoVLOXSEG5EI32_V_M2_MF2_MASK, VLOXSEG5EI32_V }, // 3662 + { PseudoVLOXSEG5EI32_V_M4_M1, VLOXSEG5EI32_V }, // 3663 + { PseudoVLOXSEG5EI32_V_M4_M1_MASK, VLOXSEG5EI32_V }, // 3664 + { PseudoVLOXSEG5EI32_V_MF2_M1, VLOXSEG5EI32_V }, // 3665 + { PseudoVLOXSEG5EI32_V_MF2_M1_MASK, VLOXSEG5EI32_V }, // 3666 + { PseudoVLOXSEG5EI32_V_MF2_MF2, VLOXSEG5EI32_V }, // 3667 + { PseudoVLOXSEG5EI32_V_MF2_MF2_MASK, VLOXSEG5EI32_V }, // 3668 + { PseudoVLOXSEG5EI32_V_MF2_MF4, VLOXSEG5EI32_V }, // 3669 + { PseudoVLOXSEG5EI32_V_MF2_MF4_MASK, VLOXSEG5EI32_V }, // 3670 + { PseudoVLOXSEG5EI32_V_MF2_MF8, VLOXSEG5EI32_V }, // 3671 + { PseudoVLOXSEG5EI32_V_MF2_MF8_MASK, VLOXSEG5EI32_V }, // 3672 + { PseudoVLOXSEG5EI64_V_M1_M1, VLOXSEG5EI64_V }, // 3673 + { PseudoVLOXSEG5EI64_V_M1_M1_MASK, VLOXSEG5EI64_V }, // 3674 + { PseudoVLOXSEG5EI64_V_M1_MF2, VLOXSEG5EI64_V }, // 3675 + { PseudoVLOXSEG5EI64_V_M1_MF2_MASK, VLOXSEG5EI64_V }, // 3676 + { PseudoVLOXSEG5EI64_V_M1_MF4, VLOXSEG5EI64_V }, // 3677 + { PseudoVLOXSEG5EI64_V_M1_MF4_MASK, VLOXSEG5EI64_V }, // 3678 + { PseudoVLOXSEG5EI64_V_M1_MF8, VLOXSEG5EI64_V }, // 3679 + { PseudoVLOXSEG5EI64_V_M1_MF8_MASK, VLOXSEG5EI64_V }, // 3680 + { PseudoVLOXSEG5EI64_V_M2_M1, VLOXSEG5EI64_V }, // 3681 + { PseudoVLOXSEG5EI64_V_M2_M1_MASK, VLOXSEG5EI64_V }, // 3682 + { PseudoVLOXSEG5EI64_V_M2_MF2, VLOXSEG5EI64_V }, // 3683 + { PseudoVLOXSEG5EI64_V_M2_MF2_MASK, VLOXSEG5EI64_V }, // 3684 + { PseudoVLOXSEG5EI64_V_M2_MF4, VLOXSEG5EI64_V }, // 3685 + { PseudoVLOXSEG5EI64_V_M2_MF4_MASK, VLOXSEG5EI64_V }, // 3686 + { PseudoVLOXSEG5EI64_V_M4_M1, VLOXSEG5EI64_V }, // 3687 + { PseudoVLOXSEG5EI64_V_M4_M1_MASK, VLOXSEG5EI64_V }, // 3688 + { PseudoVLOXSEG5EI64_V_M4_MF2, VLOXSEG5EI64_V }, // 3689 + { PseudoVLOXSEG5EI64_V_M4_MF2_MASK, VLOXSEG5EI64_V }, // 3690 + { PseudoVLOXSEG5EI64_V_M8_M1, VLOXSEG5EI64_V }, // 3691 + { PseudoVLOXSEG5EI64_V_M8_M1_MASK, VLOXSEG5EI64_V }, // 3692 + { PseudoVLOXSEG5EI8_V_M1_M1, VLOXSEG5EI8_V }, // 3693 + { PseudoVLOXSEG5EI8_V_M1_M1_MASK, VLOXSEG5EI8_V }, // 3694 + { PseudoVLOXSEG5EI8_V_MF2_M1, VLOXSEG5EI8_V }, // 3695 + { PseudoVLOXSEG5EI8_V_MF2_M1_MASK, VLOXSEG5EI8_V }, // 3696 + { PseudoVLOXSEG5EI8_V_MF2_MF2, VLOXSEG5EI8_V }, // 3697 + { PseudoVLOXSEG5EI8_V_MF2_MF2_MASK, VLOXSEG5EI8_V }, // 3698 + { PseudoVLOXSEG5EI8_V_MF4_M1, VLOXSEG5EI8_V }, // 3699 + { PseudoVLOXSEG5EI8_V_MF4_M1_MASK, VLOXSEG5EI8_V }, // 3700 + { PseudoVLOXSEG5EI8_V_MF4_MF2, VLOXSEG5EI8_V }, // 3701 + { PseudoVLOXSEG5EI8_V_MF4_MF2_MASK, VLOXSEG5EI8_V }, // 3702 + { PseudoVLOXSEG5EI8_V_MF4_MF4, VLOXSEG5EI8_V }, // 3703 + { PseudoVLOXSEG5EI8_V_MF4_MF4_MASK, VLOXSEG5EI8_V }, // 3704 + { PseudoVLOXSEG5EI8_V_MF8_M1, VLOXSEG5EI8_V }, // 3705 + { PseudoVLOXSEG5EI8_V_MF8_M1_MASK, VLOXSEG5EI8_V }, // 3706 + { PseudoVLOXSEG5EI8_V_MF8_MF2, VLOXSEG5EI8_V }, // 3707 + { PseudoVLOXSEG5EI8_V_MF8_MF2_MASK, VLOXSEG5EI8_V }, // 3708 + { PseudoVLOXSEG5EI8_V_MF8_MF4, VLOXSEG5EI8_V }, // 3709 + { PseudoVLOXSEG5EI8_V_MF8_MF4_MASK, VLOXSEG5EI8_V }, // 3710 + { PseudoVLOXSEG5EI8_V_MF8_MF8, VLOXSEG5EI8_V }, // 3711 + { PseudoVLOXSEG5EI8_V_MF8_MF8_MASK, VLOXSEG5EI8_V }, // 3712 + { PseudoVLOXSEG6EI16_V_M1_M1, VLOXSEG6EI16_V }, // 3713 + { PseudoVLOXSEG6EI16_V_M1_M1_MASK, VLOXSEG6EI16_V }, // 3714 + { PseudoVLOXSEG6EI16_V_M1_MF2, VLOXSEG6EI16_V }, // 3715 + { PseudoVLOXSEG6EI16_V_M1_MF2_MASK, VLOXSEG6EI16_V }, // 3716 + { PseudoVLOXSEG6EI16_V_M2_M1, VLOXSEG6EI16_V }, // 3717 + { PseudoVLOXSEG6EI16_V_M2_M1_MASK, VLOXSEG6EI16_V }, // 3718 + { PseudoVLOXSEG6EI16_V_MF2_M1, VLOXSEG6EI16_V }, // 3719 + { PseudoVLOXSEG6EI16_V_MF2_M1_MASK, VLOXSEG6EI16_V }, // 3720 + { PseudoVLOXSEG6EI16_V_MF2_MF2, VLOXSEG6EI16_V }, // 3721 + { PseudoVLOXSEG6EI16_V_MF2_MF2_MASK, VLOXSEG6EI16_V }, // 3722 + { PseudoVLOXSEG6EI16_V_MF2_MF4, VLOXSEG6EI16_V }, // 3723 + { PseudoVLOXSEG6EI16_V_MF2_MF4_MASK, VLOXSEG6EI16_V }, // 3724 + { PseudoVLOXSEG6EI16_V_MF4_M1, VLOXSEG6EI16_V }, // 3725 + { PseudoVLOXSEG6EI16_V_MF4_M1_MASK, VLOXSEG6EI16_V }, // 3726 + { PseudoVLOXSEG6EI16_V_MF4_MF2, VLOXSEG6EI16_V }, // 3727 + { PseudoVLOXSEG6EI16_V_MF4_MF2_MASK, VLOXSEG6EI16_V }, // 3728 + { PseudoVLOXSEG6EI16_V_MF4_MF4, VLOXSEG6EI16_V }, // 3729 + { PseudoVLOXSEG6EI16_V_MF4_MF4_MASK, VLOXSEG6EI16_V }, // 3730 + { PseudoVLOXSEG6EI16_V_MF4_MF8, VLOXSEG6EI16_V }, // 3731 + { PseudoVLOXSEG6EI16_V_MF4_MF8_MASK, VLOXSEG6EI16_V }, // 3732 + { PseudoVLOXSEG6EI32_V_M1_M1, VLOXSEG6EI32_V }, // 3733 + { PseudoVLOXSEG6EI32_V_M1_M1_MASK, VLOXSEG6EI32_V }, // 3734 + { PseudoVLOXSEG6EI32_V_M1_MF2, VLOXSEG6EI32_V }, // 3735 + { PseudoVLOXSEG6EI32_V_M1_MF2_MASK, VLOXSEG6EI32_V }, // 3736 + { PseudoVLOXSEG6EI32_V_M1_MF4, VLOXSEG6EI32_V }, // 3737 + { PseudoVLOXSEG6EI32_V_M1_MF4_MASK, VLOXSEG6EI32_V }, // 3738 + { PseudoVLOXSEG6EI32_V_M2_M1, VLOXSEG6EI32_V }, // 3739 + { PseudoVLOXSEG6EI32_V_M2_M1_MASK, VLOXSEG6EI32_V }, // 3740 + { PseudoVLOXSEG6EI32_V_M2_MF2, VLOXSEG6EI32_V }, // 3741 + { PseudoVLOXSEG6EI32_V_M2_MF2_MASK, VLOXSEG6EI32_V }, // 3742 + { PseudoVLOXSEG6EI32_V_M4_M1, VLOXSEG6EI32_V }, // 3743 + { PseudoVLOXSEG6EI32_V_M4_M1_MASK, VLOXSEG6EI32_V }, // 3744 + { PseudoVLOXSEG6EI32_V_MF2_M1, VLOXSEG6EI32_V }, // 3745 + { PseudoVLOXSEG6EI32_V_MF2_M1_MASK, VLOXSEG6EI32_V }, // 3746 + { PseudoVLOXSEG6EI32_V_MF2_MF2, VLOXSEG6EI32_V }, // 3747 + { PseudoVLOXSEG6EI32_V_MF2_MF2_MASK, VLOXSEG6EI32_V }, // 3748 + { PseudoVLOXSEG6EI32_V_MF2_MF4, VLOXSEG6EI32_V }, // 3749 + { PseudoVLOXSEG6EI32_V_MF2_MF4_MASK, VLOXSEG6EI32_V }, // 3750 + { PseudoVLOXSEG6EI32_V_MF2_MF8, VLOXSEG6EI32_V }, // 3751 + { PseudoVLOXSEG6EI32_V_MF2_MF8_MASK, VLOXSEG6EI32_V }, // 3752 + { PseudoVLOXSEG6EI64_V_M1_M1, VLOXSEG6EI64_V }, // 3753 + { PseudoVLOXSEG6EI64_V_M1_M1_MASK, VLOXSEG6EI64_V }, // 3754 + { PseudoVLOXSEG6EI64_V_M1_MF2, VLOXSEG6EI64_V }, // 3755 + { PseudoVLOXSEG6EI64_V_M1_MF2_MASK, VLOXSEG6EI64_V }, // 3756 + { PseudoVLOXSEG6EI64_V_M1_MF4, VLOXSEG6EI64_V }, // 3757 + { PseudoVLOXSEG6EI64_V_M1_MF4_MASK, VLOXSEG6EI64_V }, // 3758 + { PseudoVLOXSEG6EI64_V_M1_MF8, VLOXSEG6EI64_V }, // 3759 + { PseudoVLOXSEG6EI64_V_M1_MF8_MASK, VLOXSEG6EI64_V }, // 3760 + { PseudoVLOXSEG6EI64_V_M2_M1, VLOXSEG6EI64_V }, // 3761 + { PseudoVLOXSEG6EI64_V_M2_M1_MASK, VLOXSEG6EI64_V }, // 3762 + { PseudoVLOXSEG6EI64_V_M2_MF2, VLOXSEG6EI64_V }, // 3763 + { PseudoVLOXSEG6EI64_V_M2_MF2_MASK, VLOXSEG6EI64_V }, // 3764 + { PseudoVLOXSEG6EI64_V_M2_MF4, VLOXSEG6EI64_V }, // 3765 + { PseudoVLOXSEG6EI64_V_M2_MF4_MASK, VLOXSEG6EI64_V }, // 3766 + { PseudoVLOXSEG6EI64_V_M4_M1, VLOXSEG6EI64_V }, // 3767 + { PseudoVLOXSEG6EI64_V_M4_M1_MASK, VLOXSEG6EI64_V }, // 3768 + { PseudoVLOXSEG6EI64_V_M4_MF2, VLOXSEG6EI64_V }, // 3769 + { PseudoVLOXSEG6EI64_V_M4_MF2_MASK, VLOXSEG6EI64_V }, // 3770 + { PseudoVLOXSEG6EI64_V_M8_M1, VLOXSEG6EI64_V }, // 3771 + { PseudoVLOXSEG6EI64_V_M8_M1_MASK, VLOXSEG6EI64_V }, // 3772 + { PseudoVLOXSEG6EI8_V_M1_M1, VLOXSEG6EI8_V }, // 3773 + { PseudoVLOXSEG6EI8_V_M1_M1_MASK, VLOXSEG6EI8_V }, // 3774 + { PseudoVLOXSEG6EI8_V_MF2_M1, VLOXSEG6EI8_V }, // 3775 + { PseudoVLOXSEG6EI8_V_MF2_M1_MASK, VLOXSEG6EI8_V }, // 3776 + { PseudoVLOXSEG6EI8_V_MF2_MF2, VLOXSEG6EI8_V }, // 3777 + { PseudoVLOXSEG6EI8_V_MF2_MF2_MASK, VLOXSEG6EI8_V }, // 3778 + { PseudoVLOXSEG6EI8_V_MF4_M1, VLOXSEG6EI8_V }, // 3779 + { PseudoVLOXSEG6EI8_V_MF4_M1_MASK, VLOXSEG6EI8_V }, // 3780 + { PseudoVLOXSEG6EI8_V_MF4_MF2, VLOXSEG6EI8_V }, // 3781 + { PseudoVLOXSEG6EI8_V_MF4_MF2_MASK, VLOXSEG6EI8_V }, // 3782 + { PseudoVLOXSEG6EI8_V_MF4_MF4, VLOXSEG6EI8_V }, // 3783 + { PseudoVLOXSEG6EI8_V_MF4_MF4_MASK, VLOXSEG6EI8_V }, // 3784 + { PseudoVLOXSEG6EI8_V_MF8_M1, VLOXSEG6EI8_V }, // 3785 + { PseudoVLOXSEG6EI8_V_MF8_M1_MASK, VLOXSEG6EI8_V }, // 3786 + { PseudoVLOXSEG6EI8_V_MF8_MF2, VLOXSEG6EI8_V }, // 3787 + { PseudoVLOXSEG6EI8_V_MF8_MF2_MASK, VLOXSEG6EI8_V }, // 3788 + { PseudoVLOXSEG6EI8_V_MF8_MF4, VLOXSEG6EI8_V }, // 3789 + { PseudoVLOXSEG6EI8_V_MF8_MF4_MASK, VLOXSEG6EI8_V }, // 3790 + { PseudoVLOXSEG6EI8_V_MF8_MF8, VLOXSEG6EI8_V }, // 3791 + { PseudoVLOXSEG6EI8_V_MF8_MF8_MASK, VLOXSEG6EI8_V }, // 3792 + { PseudoVLOXSEG7EI16_V_M1_M1, VLOXSEG7EI16_V }, // 3793 + { PseudoVLOXSEG7EI16_V_M1_M1_MASK, VLOXSEG7EI16_V }, // 3794 + { PseudoVLOXSEG7EI16_V_M1_MF2, VLOXSEG7EI16_V }, // 3795 + { PseudoVLOXSEG7EI16_V_M1_MF2_MASK, VLOXSEG7EI16_V }, // 3796 + { PseudoVLOXSEG7EI16_V_M2_M1, VLOXSEG7EI16_V }, // 3797 + { PseudoVLOXSEG7EI16_V_M2_M1_MASK, VLOXSEG7EI16_V }, // 3798 + { PseudoVLOXSEG7EI16_V_MF2_M1, VLOXSEG7EI16_V }, // 3799 + { PseudoVLOXSEG7EI16_V_MF2_M1_MASK, VLOXSEG7EI16_V }, // 3800 + { PseudoVLOXSEG7EI16_V_MF2_MF2, VLOXSEG7EI16_V }, // 3801 + { PseudoVLOXSEG7EI16_V_MF2_MF2_MASK, VLOXSEG7EI16_V }, // 3802 + { PseudoVLOXSEG7EI16_V_MF2_MF4, VLOXSEG7EI16_V }, // 3803 + { PseudoVLOXSEG7EI16_V_MF2_MF4_MASK, VLOXSEG7EI16_V }, // 3804 + { PseudoVLOXSEG7EI16_V_MF4_M1, VLOXSEG7EI16_V }, // 3805 + { PseudoVLOXSEG7EI16_V_MF4_M1_MASK, VLOXSEG7EI16_V }, // 3806 + { PseudoVLOXSEG7EI16_V_MF4_MF2, VLOXSEG7EI16_V }, // 3807 + { PseudoVLOXSEG7EI16_V_MF4_MF2_MASK, VLOXSEG7EI16_V }, // 3808 + { PseudoVLOXSEG7EI16_V_MF4_MF4, VLOXSEG7EI16_V }, // 3809 + { PseudoVLOXSEG7EI16_V_MF4_MF4_MASK, VLOXSEG7EI16_V }, // 3810 + { PseudoVLOXSEG7EI16_V_MF4_MF8, VLOXSEG7EI16_V }, // 3811 + { PseudoVLOXSEG7EI16_V_MF4_MF8_MASK, VLOXSEG7EI16_V }, // 3812 + { PseudoVLOXSEG7EI32_V_M1_M1, VLOXSEG7EI32_V }, // 3813 + { PseudoVLOXSEG7EI32_V_M1_M1_MASK, VLOXSEG7EI32_V }, // 3814 + { PseudoVLOXSEG7EI32_V_M1_MF2, VLOXSEG7EI32_V }, // 3815 + { PseudoVLOXSEG7EI32_V_M1_MF2_MASK, VLOXSEG7EI32_V }, // 3816 + { PseudoVLOXSEG7EI32_V_M1_MF4, VLOXSEG7EI32_V }, // 3817 + { PseudoVLOXSEG7EI32_V_M1_MF4_MASK, VLOXSEG7EI32_V }, // 3818 + { PseudoVLOXSEG7EI32_V_M2_M1, VLOXSEG7EI32_V }, // 3819 + { PseudoVLOXSEG7EI32_V_M2_M1_MASK, VLOXSEG7EI32_V }, // 3820 + { PseudoVLOXSEG7EI32_V_M2_MF2, VLOXSEG7EI32_V }, // 3821 + { PseudoVLOXSEG7EI32_V_M2_MF2_MASK, VLOXSEG7EI32_V }, // 3822 + { PseudoVLOXSEG7EI32_V_M4_M1, VLOXSEG7EI32_V }, // 3823 + { PseudoVLOXSEG7EI32_V_M4_M1_MASK, VLOXSEG7EI32_V }, // 3824 + { PseudoVLOXSEG7EI32_V_MF2_M1, VLOXSEG7EI32_V }, // 3825 + { PseudoVLOXSEG7EI32_V_MF2_M1_MASK, VLOXSEG7EI32_V }, // 3826 + { PseudoVLOXSEG7EI32_V_MF2_MF2, VLOXSEG7EI32_V }, // 3827 + { PseudoVLOXSEG7EI32_V_MF2_MF2_MASK, VLOXSEG7EI32_V }, // 3828 + { PseudoVLOXSEG7EI32_V_MF2_MF4, VLOXSEG7EI32_V }, // 3829 + { PseudoVLOXSEG7EI32_V_MF2_MF4_MASK, VLOXSEG7EI32_V }, // 3830 + { PseudoVLOXSEG7EI32_V_MF2_MF8, VLOXSEG7EI32_V }, // 3831 + { PseudoVLOXSEG7EI32_V_MF2_MF8_MASK, VLOXSEG7EI32_V }, // 3832 + { PseudoVLOXSEG7EI64_V_M1_M1, VLOXSEG7EI64_V }, // 3833 + { PseudoVLOXSEG7EI64_V_M1_M1_MASK, VLOXSEG7EI64_V }, // 3834 + { PseudoVLOXSEG7EI64_V_M1_MF2, VLOXSEG7EI64_V }, // 3835 + { PseudoVLOXSEG7EI64_V_M1_MF2_MASK, VLOXSEG7EI64_V }, // 3836 + { PseudoVLOXSEG7EI64_V_M1_MF4, VLOXSEG7EI64_V }, // 3837 + { PseudoVLOXSEG7EI64_V_M1_MF4_MASK, VLOXSEG7EI64_V }, // 3838 + { PseudoVLOXSEG7EI64_V_M1_MF8, VLOXSEG7EI64_V }, // 3839 + { PseudoVLOXSEG7EI64_V_M1_MF8_MASK, VLOXSEG7EI64_V }, // 3840 + { PseudoVLOXSEG7EI64_V_M2_M1, VLOXSEG7EI64_V }, // 3841 + { PseudoVLOXSEG7EI64_V_M2_M1_MASK, VLOXSEG7EI64_V }, // 3842 + { PseudoVLOXSEG7EI64_V_M2_MF2, VLOXSEG7EI64_V }, // 3843 + { PseudoVLOXSEG7EI64_V_M2_MF2_MASK, VLOXSEG7EI64_V }, // 3844 + { PseudoVLOXSEG7EI64_V_M2_MF4, VLOXSEG7EI64_V }, // 3845 + { PseudoVLOXSEG7EI64_V_M2_MF4_MASK, VLOXSEG7EI64_V }, // 3846 + { PseudoVLOXSEG7EI64_V_M4_M1, VLOXSEG7EI64_V }, // 3847 + { PseudoVLOXSEG7EI64_V_M4_M1_MASK, VLOXSEG7EI64_V }, // 3848 + { PseudoVLOXSEG7EI64_V_M4_MF2, VLOXSEG7EI64_V }, // 3849 + { PseudoVLOXSEG7EI64_V_M4_MF2_MASK, VLOXSEG7EI64_V }, // 3850 + { PseudoVLOXSEG7EI64_V_M8_M1, VLOXSEG7EI64_V }, // 3851 + { PseudoVLOXSEG7EI64_V_M8_M1_MASK, VLOXSEG7EI64_V }, // 3852 + { PseudoVLOXSEG7EI8_V_M1_M1, VLOXSEG7EI8_V }, // 3853 + { PseudoVLOXSEG7EI8_V_M1_M1_MASK, VLOXSEG7EI8_V }, // 3854 + { PseudoVLOXSEG7EI8_V_MF2_M1, VLOXSEG7EI8_V }, // 3855 + { PseudoVLOXSEG7EI8_V_MF2_M1_MASK, VLOXSEG7EI8_V }, // 3856 + { PseudoVLOXSEG7EI8_V_MF2_MF2, VLOXSEG7EI8_V }, // 3857 + { PseudoVLOXSEG7EI8_V_MF2_MF2_MASK, VLOXSEG7EI8_V }, // 3858 + { PseudoVLOXSEG7EI8_V_MF4_M1, VLOXSEG7EI8_V }, // 3859 + { PseudoVLOXSEG7EI8_V_MF4_M1_MASK, VLOXSEG7EI8_V }, // 3860 + { PseudoVLOXSEG7EI8_V_MF4_MF2, VLOXSEG7EI8_V }, // 3861 + { PseudoVLOXSEG7EI8_V_MF4_MF2_MASK, VLOXSEG7EI8_V }, // 3862 + { PseudoVLOXSEG7EI8_V_MF4_MF4, VLOXSEG7EI8_V }, // 3863 + { PseudoVLOXSEG7EI8_V_MF4_MF4_MASK, VLOXSEG7EI8_V }, // 3864 + { PseudoVLOXSEG7EI8_V_MF8_M1, VLOXSEG7EI8_V }, // 3865 + { PseudoVLOXSEG7EI8_V_MF8_M1_MASK, VLOXSEG7EI8_V }, // 3866 + { PseudoVLOXSEG7EI8_V_MF8_MF2, VLOXSEG7EI8_V }, // 3867 + { PseudoVLOXSEG7EI8_V_MF8_MF2_MASK, VLOXSEG7EI8_V }, // 3868 + { PseudoVLOXSEG7EI8_V_MF8_MF4, VLOXSEG7EI8_V }, // 3869 + { PseudoVLOXSEG7EI8_V_MF8_MF4_MASK, VLOXSEG7EI8_V }, // 3870 + { PseudoVLOXSEG7EI8_V_MF8_MF8, VLOXSEG7EI8_V }, // 3871 + { PseudoVLOXSEG7EI8_V_MF8_MF8_MASK, VLOXSEG7EI8_V }, // 3872 + { PseudoVLOXSEG8EI16_V_M1_M1, VLOXSEG8EI16_V }, // 3873 + { PseudoVLOXSEG8EI16_V_M1_M1_MASK, VLOXSEG8EI16_V }, // 3874 + { PseudoVLOXSEG8EI16_V_M1_MF2, VLOXSEG8EI16_V }, // 3875 + { PseudoVLOXSEG8EI16_V_M1_MF2_MASK, VLOXSEG8EI16_V }, // 3876 + { PseudoVLOXSEG8EI16_V_M2_M1, VLOXSEG8EI16_V }, // 3877 + { PseudoVLOXSEG8EI16_V_M2_M1_MASK, VLOXSEG8EI16_V }, // 3878 + { PseudoVLOXSEG8EI16_V_MF2_M1, VLOXSEG8EI16_V }, // 3879 + { PseudoVLOXSEG8EI16_V_MF2_M1_MASK, VLOXSEG8EI16_V }, // 3880 + { PseudoVLOXSEG8EI16_V_MF2_MF2, VLOXSEG8EI16_V }, // 3881 + { PseudoVLOXSEG8EI16_V_MF2_MF2_MASK, VLOXSEG8EI16_V }, // 3882 + { PseudoVLOXSEG8EI16_V_MF2_MF4, VLOXSEG8EI16_V }, // 3883 + { PseudoVLOXSEG8EI16_V_MF2_MF4_MASK, VLOXSEG8EI16_V }, // 3884 + { PseudoVLOXSEG8EI16_V_MF4_M1, VLOXSEG8EI16_V }, // 3885 + { PseudoVLOXSEG8EI16_V_MF4_M1_MASK, VLOXSEG8EI16_V }, // 3886 + { PseudoVLOXSEG8EI16_V_MF4_MF2, VLOXSEG8EI16_V }, // 3887 + { PseudoVLOXSEG8EI16_V_MF4_MF2_MASK, VLOXSEG8EI16_V }, // 3888 + { PseudoVLOXSEG8EI16_V_MF4_MF4, VLOXSEG8EI16_V }, // 3889 + { PseudoVLOXSEG8EI16_V_MF4_MF4_MASK, VLOXSEG8EI16_V }, // 3890 + { PseudoVLOXSEG8EI16_V_MF4_MF8, VLOXSEG8EI16_V }, // 3891 + { PseudoVLOXSEG8EI16_V_MF4_MF8_MASK, VLOXSEG8EI16_V }, // 3892 + { PseudoVLOXSEG8EI32_V_M1_M1, VLOXSEG8EI32_V }, // 3893 + { PseudoVLOXSEG8EI32_V_M1_M1_MASK, VLOXSEG8EI32_V }, // 3894 + { PseudoVLOXSEG8EI32_V_M1_MF2, VLOXSEG8EI32_V }, // 3895 + { PseudoVLOXSEG8EI32_V_M1_MF2_MASK, VLOXSEG8EI32_V }, // 3896 + { PseudoVLOXSEG8EI32_V_M1_MF4, VLOXSEG8EI32_V }, // 3897 + { PseudoVLOXSEG8EI32_V_M1_MF4_MASK, VLOXSEG8EI32_V }, // 3898 + { PseudoVLOXSEG8EI32_V_M2_M1, VLOXSEG8EI32_V }, // 3899 + { PseudoVLOXSEG8EI32_V_M2_M1_MASK, VLOXSEG8EI32_V }, // 3900 + { PseudoVLOXSEG8EI32_V_M2_MF2, VLOXSEG8EI32_V }, // 3901 + { PseudoVLOXSEG8EI32_V_M2_MF2_MASK, VLOXSEG8EI32_V }, // 3902 + { PseudoVLOXSEG8EI32_V_M4_M1, VLOXSEG8EI32_V }, // 3903 + { PseudoVLOXSEG8EI32_V_M4_M1_MASK, VLOXSEG8EI32_V }, // 3904 + { PseudoVLOXSEG8EI32_V_MF2_M1, VLOXSEG8EI32_V }, // 3905 + { PseudoVLOXSEG8EI32_V_MF2_M1_MASK, VLOXSEG8EI32_V }, // 3906 + { PseudoVLOXSEG8EI32_V_MF2_MF2, VLOXSEG8EI32_V }, // 3907 + { PseudoVLOXSEG8EI32_V_MF2_MF2_MASK, VLOXSEG8EI32_V }, // 3908 + { PseudoVLOXSEG8EI32_V_MF2_MF4, VLOXSEG8EI32_V }, // 3909 + { PseudoVLOXSEG8EI32_V_MF2_MF4_MASK, VLOXSEG8EI32_V }, // 3910 + { PseudoVLOXSEG8EI32_V_MF2_MF8, VLOXSEG8EI32_V }, // 3911 + { PseudoVLOXSEG8EI32_V_MF2_MF8_MASK, VLOXSEG8EI32_V }, // 3912 + { PseudoVLOXSEG8EI64_V_M1_M1, VLOXSEG8EI64_V }, // 3913 + { PseudoVLOXSEG8EI64_V_M1_M1_MASK, VLOXSEG8EI64_V }, // 3914 + { PseudoVLOXSEG8EI64_V_M1_MF2, VLOXSEG8EI64_V }, // 3915 + { PseudoVLOXSEG8EI64_V_M1_MF2_MASK, VLOXSEG8EI64_V }, // 3916 + { PseudoVLOXSEG8EI64_V_M1_MF4, VLOXSEG8EI64_V }, // 3917 + { PseudoVLOXSEG8EI64_V_M1_MF4_MASK, VLOXSEG8EI64_V }, // 3918 + { PseudoVLOXSEG8EI64_V_M1_MF8, VLOXSEG8EI64_V }, // 3919 + { PseudoVLOXSEG8EI64_V_M1_MF8_MASK, VLOXSEG8EI64_V }, // 3920 + { PseudoVLOXSEG8EI64_V_M2_M1, VLOXSEG8EI64_V }, // 3921 + { PseudoVLOXSEG8EI64_V_M2_M1_MASK, VLOXSEG8EI64_V }, // 3922 + { PseudoVLOXSEG8EI64_V_M2_MF2, VLOXSEG8EI64_V }, // 3923 + { PseudoVLOXSEG8EI64_V_M2_MF2_MASK, VLOXSEG8EI64_V }, // 3924 + { PseudoVLOXSEG8EI64_V_M2_MF4, VLOXSEG8EI64_V }, // 3925 + { PseudoVLOXSEG8EI64_V_M2_MF4_MASK, VLOXSEG8EI64_V }, // 3926 + { PseudoVLOXSEG8EI64_V_M4_M1, VLOXSEG8EI64_V }, // 3927 + { PseudoVLOXSEG8EI64_V_M4_M1_MASK, VLOXSEG8EI64_V }, // 3928 + { PseudoVLOXSEG8EI64_V_M4_MF2, VLOXSEG8EI64_V }, // 3929 + { PseudoVLOXSEG8EI64_V_M4_MF2_MASK, VLOXSEG8EI64_V }, // 3930 + { PseudoVLOXSEG8EI64_V_M8_M1, VLOXSEG8EI64_V }, // 3931 + { PseudoVLOXSEG8EI64_V_M8_M1_MASK, VLOXSEG8EI64_V }, // 3932 + { PseudoVLOXSEG8EI8_V_M1_M1, VLOXSEG8EI8_V }, // 3933 + { PseudoVLOXSEG8EI8_V_M1_M1_MASK, VLOXSEG8EI8_V }, // 3934 + { PseudoVLOXSEG8EI8_V_MF2_M1, VLOXSEG8EI8_V }, // 3935 + { PseudoVLOXSEG8EI8_V_MF2_M1_MASK, VLOXSEG8EI8_V }, // 3936 + { PseudoVLOXSEG8EI8_V_MF2_MF2, VLOXSEG8EI8_V }, // 3937 + { PseudoVLOXSEG8EI8_V_MF2_MF2_MASK, VLOXSEG8EI8_V }, // 3938 + { PseudoVLOXSEG8EI8_V_MF4_M1, VLOXSEG8EI8_V }, // 3939 + { PseudoVLOXSEG8EI8_V_MF4_M1_MASK, VLOXSEG8EI8_V }, // 3940 + { PseudoVLOXSEG8EI8_V_MF4_MF2, VLOXSEG8EI8_V }, // 3941 + { PseudoVLOXSEG8EI8_V_MF4_MF2_MASK, VLOXSEG8EI8_V }, // 3942 + { PseudoVLOXSEG8EI8_V_MF4_MF4, VLOXSEG8EI8_V }, // 3943 + { PseudoVLOXSEG8EI8_V_MF4_MF4_MASK, VLOXSEG8EI8_V }, // 3944 + { PseudoVLOXSEG8EI8_V_MF8_M1, VLOXSEG8EI8_V }, // 3945 + { PseudoVLOXSEG8EI8_V_MF8_M1_MASK, VLOXSEG8EI8_V }, // 3946 + { PseudoVLOXSEG8EI8_V_MF8_MF2, VLOXSEG8EI8_V }, // 3947 + { PseudoVLOXSEG8EI8_V_MF8_MF2_MASK, VLOXSEG8EI8_V }, // 3948 + { PseudoVLOXSEG8EI8_V_MF8_MF4, VLOXSEG8EI8_V }, // 3949 + { PseudoVLOXSEG8EI8_V_MF8_MF4_MASK, VLOXSEG8EI8_V }, // 3950 + { PseudoVLOXSEG8EI8_V_MF8_MF8, VLOXSEG8EI8_V }, // 3951 + { PseudoVLOXSEG8EI8_V_MF8_MF8_MASK, VLOXSEG8EI8_V }, // 3952 + { PseudoVLSE16_V_M1, VLSE16_V }, // 3953 + { PseudoVLSE16_V_M1_MASK, VLSE16_V }, // 3954 + { PseudoVLSE16_V_M2, VLSE16_V }, // 3955 + { PseudoVLSE16_V_M2_MASK, VLSE16_V }, // 3956 + { PseudoVLSE16_V_M4, VLSE16_V }, // 3957 + { PseudoVLSE16_V_M4_MASK, VLSE16_V }, // 3958 + { PseudoVLSE16_V_M8, VLSE16_V }, // 3959 + { PseudoVLSE16_V_M8_MASK, VLSE16_V }, // 3960 + { PseudoVLSE16_V_MF2, VLSE16_V }, // 3961 + { PseudoVLSE16_V_MF2_MASK, VLSE16_V }, // 3962 + { PseudoVLSE16_V_MF4, VLSE16_V }, // 3963 + { PseudoVLSE16_V_MF4_MASK, VLSE16_V }, // 3964 + { PseudoVLSE32_V_M1, VLSE32_V }, // 3965 + { PseudoVLSE32_V_M1_MASK, VLSE32_V }, // 3966 + { PseudoVLSE32_V_M2, VLSE32_V }, // 3967 + { PseudoVLSE32_V_M2_MASK, VLSE32_V }, // 3968 + { PseudoVLSE32_V_M4, VLSE32_V }, // 3969 + { PseudoVLSE32_V_M4_MASK, VLSE32_V }, // 3970 + { PseudoVLSE32_V_M8, VLSE32_V }, // 3971 + { PseudoVLSE32_V_M8_MASK, VLSE32_V }, // 3972 + { PseudoVLSE32_V_MF2, VLSE32_V }, // 3973 + { PseudoVLSE32_V_MF2_MASK, VLSE32_V }, // 3974 + { PseudoVLSE64_V_M1, VLSE64_V }, // 3975 + { PseudoVLSE64_V_M1_MASK, VLSE64_V }, // 3976 + { PseudoVLSE64_V_M2, VLSE64_V }, // 3977 + { PseudoVLSE64_V_M2_MASK, VLSE64_V }, // 3978 + { PseudoVLSE64_V_M4, VLSE64_V }, // 3979 + { PseudoVLSE64_V_M4_MASK, VLSE64_V }, // 3980 + { PseudoVLSE64_V_M8, VLSE64_V }, // 3981 + { PseudoVLSE64_V_M8_MASK, VLSE64_V }, // 3982 + { PseudoVLSE8_V_M1, VLSE8_V }, // 3983 + { PseudoVLSE8_V_M1_MASK, VLSE8_V }, // 3984 + { PseudoVLSE8_V_M2, VLSE8_V }, // 3985 + { PseudoVLSE8_V_M2_MASK, VLSE8_V }, // 3986 + { PseudoVLSE8_V_M4, VLSE8_V }, // 3987 + { PseudoVLSE8_V_M4_MASK, VLSE8_V }, // 3988 + { PseudoVLSE8_V_M8, VLSE8_V }, // 3989 + { PseudoVLSE8_V_M8_MASK, VLSE8_V }, // 3990 + { PseudoVLSE8_V_MF2, VLSE8_V }, // 3991 + { PseudoVLSE8_V_MF2_MASK, VLSE8_V }, // 3992 + { PseudoVLSE8_V_MF4, VLSE8_V }, // 3993 + { PseudoVLSE8_V_MF4_MASK, VLSE8_V }, // 3994 + { PseudoVLSE8_V_MF8, VLSE8_V }, // 3995 + { PseudoVLSE8_V_MF8_MASK, VLSE8_V }, // 3996 + { PseudoVLSEG2E16FF_V_M1, VLSEG2E16FF_V }, // 3997 + { PseudoVLSEG2E16FF_V_M1_MASK, VLSEG2E16FF_V }, // 3998 + { PseudoVLSEG2E16FF_V_M2, VLSEG2E16FF_V }, // 3999 + { PseudoVLSEG2E16FF_V_M2_MASK, VLSEG2E16FF_V }, // 4000 + { PseudoVLSEG2E16FF_V_M4, VLSEG2E16FF_V }, // 4001 + { PseudoVLSEG2E16FF_V_M4_MASK, VLSEG2E16FF_V }, // 4002 + { PseudoVLSEG2E16FF_V_MF2, VLSEG2E16FF_V }, // 4003 + { PseudoVLSEG2E16FF_V_MF2_MASK, VLSEG2E16FF_V }, // 4004 + { PseudoVLSEG2E16FF_V_MF4, VLSEG2E16FF_V }, // 4005 + { PseudoVLSEG2E16FF_V_MF4_MASK, VLSEG2E16FF_V }, // 4006 + { PseudoVLSEG2E16_V_M1, VLSEG2E16_V }, // 4007 + { PseudoVLSEG2E16_V_M1_MASK, VLSEG2E16_V }, // 4008 + { PseudoVLSEG2E16_V_M2, VLSEG2E16_V }, // 4009 + { PseudoVLSEG2E16_V_M2_MASK, VLSEG2E16_V }, // 4010 + { PseudoVLSEG2E16_V_M4, VLSEG2E16_V }, // 4011 + { PseudoVLSEG2E16_V_M4_MASK, VLSEG2E16_V }, // 4012 + { PseudoVLSEG2E16_V_MF2, VLSEG2E16_V }, // 4013 + { PseudoVLSEG2E16_V_MF2_MASK, VLSEG2E16_V }, // 4014 + { PseudoVLSEG2E16_V_MF4, VLSEG2E16_V }, // 4015 + { PseudoVLSEG2E16_V_MF4_MASK, VLSEG2E16_V }, // 4016 + { PseudoVLSEG2E32FF_V_M1, VLSEG2E32FF_V }, // 4017 + { PseudoVLSEG2E32FF_V_M1_MASK, VLSEG2E32FF_V }, // 4018 + { PseudoVLSEG2E32FF_V_M2, VLSEG2E32FF_V }, // 4019 + { PseudoVLSEG2E32FF_V_M2_MASK, VLSEG2E32FF_V }, // 4020 + { PseudoVLSEG2E32FF_V_M4, VLSEG2E32FF_V }, // 4021 + { PseudoVLSEG2E32FF_V_M4_MASK, VLSEG2E32FF_V }, // 4022 + { PseudoVLSEG2E32FF_V_MF2, VLSEG2E32FF_V }, // 4023 + { PseudoVLSEG2E32FF_V_MF2_MASK, VLSEG2E32FF_V }, // 4024 + { PseudoVLSEG2E32_V_M1, VLSEG2E32_V }, // 4025 + { PseudoVLSEG2E32_V_M1_MASK, VLSEG2E32_V }, // 4026 + { PseudoVLSEG2E32_V_M2, VLSEG2E32_V }, // 4027 + { PseudoVLSEG2E32_V_M2_MASK, VLSEG2E32_V }, // 4028 + { PseudoVLSEG2E32_V_M4, VLSEG2E32_V }, // 4029 + { PseudoVLSEG2E32_V_M4_MASK, VLSEG2E32_V }, // 4030 + { PseudoVLSEG2E32_V_MF2, VLSEG2E32_V }, // 4031 + { PseudoVLSEG2E32_V_MF2_MASK, VLSEG2E32_V }, // 4032 + { PseudoVLSEG2E64FF_V_M1, VLSEG2E64FF_V }, // 4033 + { PseudoVLSEG2E64FF_V_M1_MASK, VLSEG2E64FF_V }, // 4034 + { PseudoVLSEG2E64FF_V_M2, VLSEG2E64FF_V }, // 4035 + { PseudoVLSEG2E64FF_V_M2_MASK, VLSEG2E64FF_V }, // 4036 + { PseudoVLSEG2E64FF_V_M4, VLSEG2E64FF_V }, // 4037 + { PseudoVLSEG2E64FF_V_M4_MASK, VLSEG2E64FF_V }, // 4038 + { PseudoVLSEG2E64_V_M1, VLSEG2E64_V }, // 4039 + { PseudoVLSEG2E64_V_M1_MASK, VLSEG2E64_V }, // 4040 + { PseudoVLSEG2E64_V_M2, VLSEG2E64_V }, // 4041 + { PseudoVLSEG2E64_V_M2_MASK, VLSEG2E64_V }, // 4042 + { PseudoVLSEG2E64_V_M4, VLSEG2E64_V }, // 4043 + { PseudoVLSEG2E64_V_M4_MASK, VLSEG2E64_V }, // 4044 + { PseudoVLSEG2E8FF_V_M1, VLSEG2E8FF_V }, // 4045 + { PseudoVLSEG2E8FF_V_M1_MASK, VLSEG2E8FF_V }, // 4046 + { PseudoVLSEG2E8FF_V_M2, VLSEG2E8FF_V }, // 4047 + { PseudoVLSEG2E8FF_V_M2_MASK, VLSEG2E8FF_V }, // 4048 + { PseudoVLSEG2E8FF_V_M4, VLSEG2E8FF_V }, // 4049 + { PseudoVLSEG2E8FF_V_M4_MASK, VLSEG2E8FF_V }, // 4050 + { PseudoVLSEG2E8FF_V_MF2, VLSEG2E8FF_V }, // 4051 + { PseudoVLSEG2E8FF_V_MF2_MASK, VLSEG2E8FF_V }, // 4052 + { PseudoVLSEG2E8FF_V_MF4, VLSEG2E8FF_V }, // 4053 + { PseudoVLSEG2E8FF_V_MF4_MASK, VLSEG2E8FF_V }, // 4054 + { PseudoVLSEG2E8FF_V_MF8, VLSEG2E8FF_V }, // 4055 + { PseudoVLSEG2E8FF_V_MF8_MASK, VLSEG2E8FF_V }, // 4056 + { PseudoVLSEG2E8_V_M1, VLSEG2E8_V }, // 4057 + { PseudoVLSEG2E8_V_M1_MASK, VLSEG2E8_V }, // 4058 + { PseudoVLSEG2E8_V_M2, VLSEG2E8_V }, // 4059 + { PseudoVLSEG2E8_V_M2_MASK, VLSEG2E8_V }, // 4060 + { PseudoVLSEG2E8_V_M4, VLSEG2E8_V }, // 4061 + { PseudoVLSEG2E8_V_M4_MASK, VLSEG2E8_V }, // 4062 + { PseudoVLSEG2E8_V_MF2, VLSEG2E8_V }, // 4063 + { PseudoVLSEG2E8_V_MF2_MASK, VLSEG2E8_V }, // 4064 + { PseudoVLSEG2E8_V_MF4, VLSEG2E8_V }, // 4065 + { PseudoVLSEG2E8_V_MF4_MASK, VLSEG2E8_V }, // 4066 + { PseudoVLSEG2E8_V_MF8, VLSEG2E8_V }, // 4067 + { PseudoVLSEG2E8_V_MF8_MASK, VLSEG2E8_V }, // 4068 + { PseudoVLSEG3E16FF_V_M1, VLSEG3E16FF_V }, // 4069 + { PseudoVLSEG3E16FF_V_M1_MASK, VLSEG3E16FF_V }, // 4070 + { PseudoVLSEG3E16FF_V_M2, VLSEG3E16FF_V }, // 4071 + { PseudoVLSEG3E16FF_V_M2_MASK, VLSEG3E16FF_V }, // 4072 + { PseudoVLSEG3E16FF_V_MF2, VLSEG3E16FF_V }, // 4073 + { PseudoVLSEG3E16FF_V_MF2_MASK, VLSEG3E16FF_V }, // 4074 + { PseudoVLSEG3E16FF_V_MF4, VLSEG3E16FF_V }, // 4075 + { PseudoVLSEG3E16FF_V_MF4_MASK, VLSEG3E16FF_V }, // 4076 + { PseudoVLSEG3E16_V_M1, VLSEG3E16_V }, // 4077 + { PseudoVLSEG3E16_V_M1_MASK, VLSEG3E16_V }, // 4078 + { PseudoVLSEG3E16_V_M2, VLSEG3E16_V }, // 4079 + { PseudoVLSEG3E16_V_M2_MASK, VLSEG3E16_V }, // 4080 + { PseudoVLSEG3E16_V_MF2, VLSEG3E16_V }, // 4081 + { PseudoVLSEG3E16_V_MF2_MASK, VLSEG3E16_V }, // 4082 + { PseudoVLSEG3E16_V_MF4, VLSEG3E16_V }, // 4083 + { PseudoVLSEG3E16_V_MF4_MASK, VLSEG3E16_V }, // 4084 + { PseudoVLSEG3E32FF_V_M1, VLSEG3E32FF_V }, // 4085 + { PseudoVLSEG3E32FF_V_M1_MASK, VLSEG3E32FF_V }, // 4086 + { PseudoVLSEG3E32FF_V_M2, VLSEG3E32FF_V }, // 4087 + { PseudoVLSEG3E32FF_V_M2_MASK, VLSEG3E32FF_V }, // 4088 + { PseudoVLSEG3E32FF_V_MF2, VLSEG3E32FF_V }, // 4089 + { PseudoVLSEG3E32FF_V_MF2_MASK, VLSEG3E32FF_V }, // 4090 + { PseudoVLSEG3E32_V_M1, VLSEG3E32_V }, // 4091 + { PseudoVLSEG3E32_V_M1_MASK, VLSEG3E32_V }, // 4092 + { PseudoVLSEG3E32_V_M2, VLSEG3E32_V }, // 4093 + { PseudoVLSEG3E32_V_M2_MASK, VLSEG3E32_V }, // 4094 + { PseudoVLSEG3E32_V_MF2, VLSEG3E32_V }, // 4095 + { PseudoVLSEG3E32_V_MF2_MASK, VLSEG3E32_V }, // 4096 + { PseudoVLSEG3E64FF_V_M1, VLSEG3E64FF_V }, // 4097 + { PseudoVLSEG3E64FF_V_M1_MASK, VLSEG3E64FF_V }, // 4098 + { PseudoVLSEG3E64FF_V_M2, VLSEG3E64FF_V }, // 4099 + { PseudoVLSEG3E64FF_V_M2_MASK, VLSEG3E64FF_V }, // 4100 + { PseudoVLSEG3E64_V_M1, VLSEG3E64_V }, // 4101 + { PseudoVLSEG3E64_V_M1_MASK, VLSEG3E64_V }, // 4102 + { PseudoVLSEG3E64_V_M2, VLSEG3E64_V }, // 4103 + { PseudoVLSEG3E64_V_M2_MASK, VLSEG3E64_V }, // 4104 + { PseudoVLSEG3E8FF_V_M1, VLSEG3E8FF_V }, // 4105 + { PseudoVLSEG3E8FF_V_M1_MASK, VLSEG3E8FF_V }, // 4106 + { PseudoVLSEG3E8FF_V_M2, VLSEG3E8FF_V }, // 4107 + { PseudoVLSEG3E8FF_V_M2_MASK, VLSEG3E8FF_V }, // 4108 + { PseudoVLSEG3E8FF_V_MF2, VLSEG3E8FF_V }, // 4109 + { PseudoVLSEG3E8FF_V_MF2_MASK, VLSEG3E8FF_V }, // 4110 + { PseudoVLSEG3E8FF_V_MF4, VLSEG3E8FF_V }, // 4111 + { PseudoVLSEG3E8FF_V_MF4_MASK, VLSEG3E8FF_V }, // 4112 + { PseudoVLSEG3E8FF_V_MF8, VLSEG3E8FF_V }, // 4113 + { PseudoVLSEG3E8FF_V_MF8_MASK, VLSEG3E8FF_V }, // 4114 + { PseudoVLSEG3E8_V_M1, VLSEG3E8_V }, // 4115 + { PseudoVLSEG3E8_V_M1_MASK, VLSEG3E8_V }, // 4116 + { PseudoVLSEG3E8_V_M2, VLSEG3E8_V }, // 4117 + { PseudoVLSEG3E8_V_M2_MASK, VLSEG3E8_V }, // 4118 + { PseudoVLSEG3E8_V_MF2, VLSEG3E8_V }, // 4119 + { PseudoVLSEG3E8_V_MF2_MASK, VLSEG3E8_V }, // 4120 + { PseudoVLSEG3E8_V_MF4, VLSEG3E8_V }, // 4121 + { PseudoVLSEG3E8_V_MF4_MASK, VLSEG3E8_V }, // 4122 + { PseudoVLSEG3E8_V_MF8, VLSEG3E8_V }, // 4123 + { PseudoVLSEG3E8_V_MF8_MASK, VLSEG3E8_V }, // 4124 + { PseudoVLSEG4E16FF_V_M1, VLSEG4E16FF_V }, // 4125 + { PseudoVLSEG4E16FF_V_M1_MASK, VLSEG4E16FF_V }, // 4126 + { PseudoVLSEG4E16FF_V_M2, VLSEG4E16FF_V }, // 4127 + { PseudoVLSEG4E16FF_V_M2_MASK, VLSEG4E16FF_V }, // 4128 + { PseudoVLSEG4E16FF_V_MF2, VLSEG4E16FF_V }, // 4129 + { PseudoVLSEG4E16FF_V_MF2_MASK, VLSEG4E16FF_V }, // 4130 + { PseudoVLSEG4E16FF_V_MF4, VLSEG4E16FF_V }, // 4131 + { PseudoVLSEG4E16FF_V_MF4_MASK, VLSEG4E16FF_V }, // 4132 + { PseudoVLSEG4E16_V_M1, VLSEG4E16_V }, // 4133 + { PseudoVLSEG4E16_V_M1_MASK, VLSEG4E16_V }, // 4134 + { PseudoVLSEG4E16_V_M2, VLSEG4E16_V }, // 4135 + { PseudoVLSEG4E16_V_M2_MASK, VLSEG4E16_V }, // 4136 + { PseudoVLSEG4E16_V_MF2, VLSEG4E16_V }, // 4137 + { PseudoVLSEG4E16_V_MF2_MASK, VLSEG4E16_V }, // 4138 + { PseudoVLSEG4E16_V_MF4, VLSEG4E16_V }, // 4139 + { PseudoVLSEG4E16_V_MF4_MASK, VLSEG4E16_V }, // 4140 + { PseudoVLSEG4E32FF_V_M1, VLSEG4E32FF_V }, // 4141 + { PseudoVLSEG4E32FF_V_M1_MASK, VLSEG4E32FF_V }, // 4142 + { PseudoVLSEG4E32FF_V_M2, VLSEG4E32FF_V }, // 4143 + { PseudoVLSEG4E32FF_V_M2_MASK, VLSEG4E32FF_V }, // 4144 + { PseudoVLSEG4E32FF_V_MF2, VLSEG4E32FF_V }, // 4145 + { PseudoVLSEG4E32FF_V_MF2_MASK, VLSEG4E32FF_V }, // 4146 + { PseudoVLSEG4E32_V_M1, VLSEG4E32_V }, // 4147 + { PseudoVLSEG4E32_V_M1_MASK, VLSEG4E32_V }, // 4148 + { PseudoVLSEG4E32_V_M2, VLSEG4E32_V }, // 4149 + { PseudoVLSEG4E32_V_M2_MASK, VLSEG4E32_V }, // 4150 + { PseudoVLSEG4E32_V_MF2, VLSEG4E32_V }, // 4151 + { PseudoVLSEG4E32_V_MF2_MASK, VLSEG4E32_V }, // 4152 + { PseudoVLSEG4E64FF_V_M1, VLSEG4E64FF_V }, // 4153 + { PseudoVLSEG4E64FF_V_M1_MASK, VLSEG4E64FF_V }, // 4154 + { PseudoVLSEG4E64FF_V_M2, VLSEG4E64FF_V }, // 4155 + { PseudoVLSEG4E64FF_V_M2_MASK, VLSEG4E64FF_V }, // 4156 + { PseudoVLSEG4E64_V_M1, VLSEG4E64_V }, // 4157 + { PseudoVLSEG4E64_V_M1_MASK, VLSEG4E64_V }, // 4158 + { PseudoVLSEG4E64_V_M2, VLSEG4E64_V }, // 4159 + { PseudoVLSEG4E64_V_M2_MASK, VLSEG4E64_V }, // 4160 + { PseudoVLSEG4E8FF_V_M1, VLSEG4E8FF_V }, // 4161 + { PseudoVLSEG4E8FF_V_M1_MASK, VLSEG4E8FF_V }, // 4162 + { PseudoVLSEG4E8FF_V_M2, VLSEG4E8FF_V }, // 4163 + { PseudoVLSEG4E8FF_V_M2_MASK, VLSEG4E8FF_V }, // 4164 + { PseudoVLSEG4E8FF_V_MF2, VLSEG4E8FF_V }, // 4165 + { PseudoVLSEG4E8FF_V_MF2_MASK, VLSEG4E8FF_V }, // 4166 + { PseudoVLSEG4E8FF_V_MF4, VLSEG4E8FF_V }, // 4167 + { PseudoVLSEG4E8FF_V_MF4_MASK, VLSEG4E8FF_V }, // 4168 + { PseudoVLSEG4E8FF_V_MF8, VLSEG4E8FF_V }, // 4169 + { PseudoVLSEG4E8FF_V_MF8_MASK, VLSEG4E8FF_V }, // 4170 + { PseudoVLSEG4E8_V_M1, VLSEG4E8_V }, // 4171 + { PseudoVLSEG4E8_V_M1_MASK, VLSEG4E8_V }, // 4172 + { PseudoVLSEG4E8_V_M2, VLSEG4E8_V }, // 4173 + { PseudoVLSEG4E8_V_M2_MASK, VLSEG4E8_V }, // 4174 + { PseudoVLSEG4E8_V_MF2, VLSEG4E8_V }, // 4175 + { PseudoVLSEG4E8_V_MF2_MASK, VLSEG4E8_V }, // 4176 + { PseudoVLSEG4E8_V_MF4, VLSEG4E8_V }, // 4177 + { PseudoVLSEG4E8_V_MF4_MASK, VLSEG4E8_V }, // 4178 + { PseudoVLSEG4E8_V_MF8, VLSEG4E8_V }, // 4179 + { PseudoVLSEG4E8_V_MF8_MASK, VLSEG4E8_V }, // 4180 + { PseudoVLSEG5E16FF_V_M1, VLSEG5E16FF_V }, // 4181 + { PseudoVLSEG5E16FF_V_M1_MASK, VLSEG5E16FF_V }, // 4182 + { PseudoVLSEG5E16FF_V_MF2, VLSEG5E16FF_V }, // 4183 + { PseudoVLSEG5E16FF_V_MF2_MASK, VLSEG5E16FF_V }, // 4184 + { PseudoVLSEG5E16FF_V_MF4, VLSEG5E16FF_V }, // 4185 + { PseudoVLSEG5E16FF_V_MF4_MASK, VLSEG5E16FF_V }, // 4186 + { PseudoVLSEG5E16_V_M1, VLSEG5E16_V }, // 4187 + { PseudoVLSEG5E16_V_M1_MASK, VLSEG5E16_V }, // 4188 + { PseudoVLSEG5E16_V_MF2, VLSEG5E16_V }, // 4189 + { PseudoVLSEG5E16_V_MF2_MASK, VLSEG5E16_V }, // 4190 + { PseudoVLSEG5E16_V_MF4, VLSEG5E16_V }, // 4191 + { PseudoVLSEG5E16_V_MF4_MASK, VLSEG5E16_V }, // 4192 + { PseudoVLSEG5E32FF_V_M1, VLSEG5E32FF_V }, // 4193 + { PseudoVLSEG5E32FF_V_M1_MASK, VLSEG5E32FF_V }, // 4194 + { PseudoVLSEG5E32FF_V_MF2, VLSEG5E32FF_V }, // 4195 + { PseudoVLSEG5E32FF_V_MF2_MASK, VLSEG5E32FF_V }, // 4196 + { PseudoVLSEG5E32_V_M1, VLSEG5E32_V }, // 4197 + { PseudoVLSEG5E32_V_M1_MASK, VLSEG5E32_V }, // 4198 + { PseudoVLSEG5E32_V_MF2, VLSEG5E32_V }, // 4199 + { PseudoVLSEG5E32_V_MF2_MASK, VLSEG5E32_V }, // 4200 + { PseudoVLSEG5E64FF_V_M1, VLSEG5E64FF_V }, // 4201 + { PseudoVLSEG5E64FF_V_M1_MASK, VLSEG5E64FF_V }, // 4202 + { PseudoVLSEG5E64_V_M1, VLSEG5E64_V }, // 4203 + { PseudoVLSEG5E64_V_M1_MASK, VLSEG5E64_V }, // 4204 + { PseudoVLSEG5E8FF_V_M1, VLSEG5E8FF_V }, // 4205 + { PseudoVLSEG5E8FF_V_M1_MASK, VLSEG5E8FF_V }, // 4206 + { PseudoVLSEG5E8FF_V_MF2, VLSEG5E8FF_V }, // 4207 + { PseudoVLSEG5E8FF_V_MF2_MASK, VLSEG5E8FF_V }, // 4208 + { PseudoVLSEG5E8FF_V_MF4, VLSEG5E8FF_V }, // 4209 + { PseudoVLSEG5E8FF_V_MF4_MASK, VLSEG5E8FF_V }, // 4210 + { PseudoVLSEG5E8FF_V_MF8, VLSEG5E8FF_V }, // 4211 + { PseudoVLSEG5E8FF_V_MF8_MASK, VLSEG5E8FF_V }, // 4212 + { PseudoVLSEG5E8_V_M1, VLSEG5E8_V }, // 4213 + { PseudoVLSEG5E8_V_M1_MASK, VLSEG5E8_V }, // 4214 + { PseudoVLSEG5E8_V_MF2, VLSEG5E8_V }, // 4215 + { PseudoVLSEG5E8_V_MF2_MASK, VLSEG5E8_V }, // 4216 + { PseudoVLSEG5E8_V_MF4, VLSEG5E8_V }, // 4217 + { PseudoVLSEG5E8_V_MF4_MASK, VLSEG5E8_V }, // 4218 + { PseudoVLSEG5E8_V_MF8, VLSEG5E8_V }, // 4219 + { PseudoVLSEG5E8_V_MF8_MASK, VLSEG5E8_V }, // 4220 + { PseudoVLSEG6E16FF_V_M1, VLSEG6E16FF_V }, // 4221 + { PseudoVLSEG6E16FF_V_M1_MASK, VLSEG6E16FF_V }, // 4222 + { PseudoVLSEG6E16FF_V_MF2, VLSEG6E16FF_V }, // 4223 + { PseudoVLSEG6E16FF_V_MF2_MASK, VLSEG6E16FF_V }, // 4224 + { PseudoVLSEG6E16FF_V_MF4, VLSEG6E16FF_V }, // 4225 + { PseudoVLSEG6E16FF_V_MF4_MASK, VLSEG6E16FF_V }, // 4226 + { PseudoVLSEG6E16_V_M1, VLSEG6E16_V }, // 4227 + { PseudoVLSEG6E16_V_M1_MASK, VLSEG6E16_V }, // 4228 + { PseudoVLSEG6E16_V_MF2, VLSEG6E16_V }, // 4229 + { PseudoVLSEG6E16_V_MF2_MASK, VLSEG6E16_V }, // 4230 + { PseudoVLSEG6E16_V_MF4, VLSEG6E16_V }, // 4231 + { PseudoVLSEG6E16_V_MF4_MASK, VLSEG6E16_V }, // 4232 + { PseudoVLSEG6E32FF_V_M1, VLSEG6E32FF_V }, // 4233 + { PseudoVLSEG6E32FF_V_M1_MASK, VLSEG6E32FF_V }, // 4234 + { PseudoVLSEG6E32FF_V_MF2, VLSEG6E32FF_V }, // 4235 + { PseudoVLSEG6E32FF_V_MF2_MASK, VLSEG6E32FF_V }, // 4236 + { PseudoVLSEG6E32_V_M1, VLSEG6E32_V }, // 4237 + { PseudoVLSEG6E32_V_M1_MASK, VLSEG6E32_V }, // 4238 + { PseudoVLSEG6E32_V_MF2, VLSEG6E32_V }, // 4239 + { PseudoVLSEG6E32_V_MF2_MASK, VLSEG6E32_V }, // 4240 + { PseudoVLSEG6E64FF_V_M1, VLSEG6E64FF_V }, // 4241 + { PseudoVLSEG6E64FF_V_M1_MASK, VLSEG6E64FF_V }, // 4242 + { PseudoVLSEG6E64_V_M1, VLSEG6E64_V }, // 4243 + { PseudoVLSEG6E64_V_M1_MASK, VLSEG6E64_V }, // 4244 + { PseudoVLSEG6E8FF_V_M1, VLSEG6E8FF_V }, // 4245 + { PseudoVLSEG6E8FF_V_M1_MASK, VLSEG6E8FF_V }, // 4246 + { PseudoVLSEG6E8FF_V_MF2, VLSEG6E8FF_V }, // 4247 + { PseudoVLSEG6E8FF_V_MF2_MASK, VLSEG6E8FF_V }, // 4248 + { PseudoVLSEG6E8FF_V_MF4, VLSEG6E8FF_V }, // 4249 + { PseudoVLSEG6E8FF_V_MF4_MASK, VLSEG6E8FF_V }, // 4250 + { PseudoVLSEG6E8FF_V_MF8, VLSEG6E8FF_V }, // 4251 + { PseudoVLSEG6E8FF_V_MF8_MASK, VLSEG6E8FF_V }, // 4252 + { PseudoVLSEG6E8_V_M1, VLSEG6E8_V }, // 4253 + { PseudoVLSEG6E8_V_M1_MASK, VLSEG6E8_V }, // 4254 + { PseudoVLSEG6E8_V_MF2, VLSEG6E8_V }, // 4255 + { PseudoVLSEG6E8_V_MF2_MASK, VLSEG6E8_V }, // 4256 + { PseudoVLSEG6E8_V_MF4, VLSEG6E8_V }, // 4257 + { PseudoVLSEG6E8_V_MF4_MASK, VLSEG6E8_V }, // 4258 + { PseudoVLSEG6E8_V_MF8, VLSEG6E8_V }, // 4259 + { PseudoVLSEG6E8_V_MF8_MASK, VLSEG6E8_V }, // 4260 + { PseudoVLSEG7E16FF_V_M1, VLSEG7E16FF_V }, // 4261 + { PseudoVLSEG7E16FF_V_M1_MASK, VLSEG7E16FF_V }, // 4262 + { PseudoVLSEG7E16FF_V_MF2, VLSEG7E16FF_V }, // 4263 + { PseudoVLSEG7E16FF_V_MF2_MASK, VLSEG7E16FF_V }, // 4264 + { PseudoVLSEG7E16FF_V_MF4, VLSEG7E16FF_V }, // 4265 + { PseudoVLSEG7E16FF_V_MF4_MASK, VLSEG7E16FF_V }, // 4266 + { PseudoVLSEG7E16_V_M1, VLSEG7E16_V }, // 4267 + { PseudoVLSEG7E16_V_M1_MASK, VLSEG7E16_V }, // 4268 + { PseudoVLSEG7E16_V_MF2, VLSEG7E16_V }, // 4269 + { PseudoVLSEG7E16_V_MF2_MASK, VLSEG7E16_V }, // 4270 + { PseudoVLSEG7E16_V_MF4, VLSEG7E16_V }, // 4271 + { PseudoVLSEG7E16_V_MF4_MASK, VLSEG7E16_V }, // 4272 + { PseudoVLSEG7E32FF_V_M1, VLSEG7E32FF_V }, // 4273 + { PseudoVLSEG7E32FF_V_M1_MASK, VLSEG7E32FF_V }, // 4274 + { PseudoVLSEG7E32FF_V_MF2, VLSEG7E32FF_V }, // 4275 + { PseudoVLSEG7E32FF_V_MF2_MASK, VLSEG7E32FF_V }, // 4276 + { PseudoVLSEG7E32_V_M1, VLSEG7E32_V }, // 4277 + { PseudoVLSEG7E32_V_M1_MASK, VLSEG7E32_V }, // 4278 + { PseudoVLSEG7E32_V_MF2, VLSEG7E32_V }, // 4279 + { PseudoVLSEG7E32_V_MF2_MASK, VLSEG7E32_V }, // 4280 + { PseudoVLSEG7E64FF_V_M1, VLSEG7E64FF_V }, // 4281 + { PseudoVLSEG7E64FF_V_M1_MASK, VLSEG7E64FF_V }, // 4282 + { PseudoVLSEG7E64_V_M1, VLSEG7E64_V }, // 4283 + { PseudoVLSEG7E64_V_M1_MASK, VLSEG7E64_V }, // 4284 + { PseudoVLSEG7E8FF_V_M1, VLSEG7E8FF_V }, // 4285 + { PseudoVLSEG7E8FF_V_M1_MASK, VLSEG7E8FF_V }, // 4286 + { PseudoVLSEG7E8FF_V_MF2, VLSEG7E8FF_V }, // 4287 + { PseudoVLSEG7E8FF_V_MF2_MASK, VLSEG7E8FF_V }, // 4288 + { PseudoVLSEG7E8FF_V_MF4, VLSEG7E8FF_V }, // 4289 + { PseudoVLSEG7E8FF_V_MF4_MASK, VLSEG7E8FF_V }, // 4290 + { PseudoVLSEG7E8FF_V_MF8, VLSEG7E8FF_V }, // 4291 + { PseudoVLSEG7E8FF_V_MF8_MASK, VLSEG7E8FF_V }, // 4292 + { PseudoVLSEG7E8_V_M1, VLSEG7E8_V }, // 4293 + { PseudoVLSEG7E8_V_M1_MASK, VLSEG7E8_V }, // 4294 + { PseudoVLSEG7E8_V_MF2, VLSEG7E8_V }, // 4295 + { PseudoVLSEG7E8_V_MF2_MASK, VLSEG7E8_V }, // 4296 + { PseudoVLSEG7E8_V_MF4, VLSEG7E8_V }, // 4297 + { PseudoVLSEG7E8_V_MF4_MASK, VLSEG7E8_V }, // 4298 + { PseudoVLSEG7E8_V_MF8, VLSEG7E8_V }, // 4299 + { PseudoVLSEG7E8_V_MF8_MASK, VLSEG7E8_V }, // 4300 + { PseudoVLSEG8E16FF_V_M1, VLSEG8E16FF_V }, // 4301 + { PseudoVLSEG8E16FF_V_M1_MASK, VLSEG8E16FF_V }, // 4302 + { PseudoVLSEG8E16FF_V_MF2, VLSEG8E16FF_V }, // 4303 + { PseudoVLSEG8E16FF_V_MF2_MASK, VLSEG8E16FF_V }, // 4304 + { PseudoVLSEG8E16FF_V_MF4, VLSEG8E16FF_V }, // 4305 + { PseudoVLSEG8E16FF_V_MF4_MASK, VLSEG8E16FF_V }, // 4306 + { PseudoVLSEG8E16_V_M1, VLSEG8E16_V }, // 4307 + { PseudoVLSEG8E16_V_M1_MASK, VLSEG8E16_V }, // 4308 + { PseudoVLSEG8E16_V_MF2, VLSEG8E16_V }, // 4309 + { PseudoVLSEG8E16_V_MF2_MASK, VLSEG8E16_V }, // 4310 + { PseudoVLSEG8E16_V_MF4, VLSEG8E16_V }, // 4311 + { PseudoVLSEG8E16_V_MF4_MASK, VLSEG8E16_V }, // 4312 + { PseudoVLSEG8E32FF_V_M1, VLSEG8E32FF_V }, // 4313 + { PseudoVLSEG8E32FF_V_M1_MASK, VLSEG8E32FF_V }, // 4314 + { PseudoVLSEG8E32FF_V_MF2, VLSEG8E32FF_V }, // 4315 + { PseudoVLSEG8E32FF_V_MF2_MASK, VLSEG8E32FF_V }, // 4316 + { PseudoVLSEG8E32_V_M1, VLSEG8E32_V }, // 4317 + { PseudoVLSEG8E32_V_M1_MASK, VLSEG8E32_V }, // 4318 + { PseudoVLSEG8E32_V_MF2, VLSEG8E32_V }, // 4319 + { PseudoVLSEG8E32_V_MF2_MASK, VLSEG8E32_V }, // 4320 + { PseudoVLSEG8E64FF_V_M1, VLSEG8E64FF_V }, // 4321 + { PseudoVLSEG8E64FF_V_M1_MASK, VLSEG8E64FF_V }, // 4322 + { PseudoVLSEG8E64_V_M1, VLSEG8E64_V }, // 4323 + { PseudoVLSEG8E64_V_M1_MASK, VLSEG8E64_V }, // 4324 + { PseudoVLSEG8E8FF_V_M1, VLSEG8E8FF_V }, // 4325 + { PseudoVLSEG8E8FF_V_M1_MASK, VLSEG8E8FF_V }, // 4326 + { PseudoVLSEG8E8FF_V_MF2, VLSEG8E8FF_V }, // 4327 + { PseudoVLSEG8E8FF_V_MF2_MASK, VLSEG8E8FF_V }, // 4328 + { PseudoVLSEG8E8FF_V_MF4, VLSEG8E8FF_V }, // 4329 + { PseudoVLSEG8E8FF_V_MF4_MASK, VLSEG8E8FF_V }, // 4330 + { PseudoVLSEG8E8FF_V_MF8, VLSEG8E8FF_V }, // 4331 + { PseudoVLSEG8E8FF_V_MF8_MASK, VLSEG8E8FF_V }, // 4332 + { PseudoVLSEG8E8_V_M1, VLSEG8E8_V }, // 4333 + { PseudoVLSEG8E8_V_M1_MASK, VLSEG8E8_V }, // 4334 + { PseudoVLSEG8E8_V_MF2, VLSEG8E8_V }, // 4335 + { PseudoVLSEG8E8_V_MF2_MASK, VLSEG8E8_V }, // 4336 + { PseudoVLSEG8E8_V_MF4, VLSEG8E8_V }, // 4337 + { PseudoVLSEG8E8_V_MF4_MASK, VLSEG8E8_V }, // 4338 + { PseudoVLSEG8E8_V_MF8, VLSEG8E8_V }, // 4339 + { PseudoVLSEG8E8_V_MF8_MASK, VLSEG8E8_V }, // 4340 + { PseudoVLSSEG2E16_V_M1, VLSSEG2E16_V }, // 4341 + { PseudoVLSSEG2E16_V_M1_MASK, VLSSEG2E16_V }, // 4342 + { PseudoVLSSEG2E16_V_M2, VLSSEG2E16_V }, // 4343 + { PseudoVLSSEG2E16_V_M2_MASK, VLSSEG2E16_V }, // 4344 + { PseudoVLSSEG2E16_V_M4, VLSSEG2E16_V }, // 4345 + { PseudoVLSSEG2E16_V_M4_MASK, VLSSEG2E16_V }, // 4346 + { PseudoVLSSEG2E16_V_MF2, VLSSEG2E16_V }, // 4347 + { PseudoVLSSEG2E16_V_MF2_MASK, VLSSEG2E16_V }, // 4348 + { PseudoVLSSEG2E16_V_MF4, VLSSEG2E16_V }, // 4349 + { PseudoVLSSEG2E16_V_MF4_MASK, VLSSEG2E16_V }, // 4350 + { PseudoVLSSEG2E32_V_M1, VLSSEG2E32_V }, // 4351 + { PseudoVLSSEG2E32_V_M1_MASK, VLSSEG2E32_V }, // 4352 + { PseudoVLSSEG2E32_V_M2, VLSSEG2E32_V }, // 4353 + { PseudoVLSSEG2E32_V_M2_MASK, VLSSEG2E32_V }, // 4354 + { PseudoVLSSEG2E32_V_M4, VLSSEG2E32_V }, // 4355 + { PseudoVLSSEG2E32_V_M4_MASK, VLSSEG2E32_V }, // 4356 + { PseudoVLSSEG2E32_V_MF2, VLSSEG2E32_V }, // 4357 + { PseudoVLSSEG2E32_V_MF2_MASK, VLSSEG2E32_V }, // 4358 + { PseudoVLSSEG2E64_V_M1, VLSSEG2E64_V }, // 4359 + { PseudoVLSSEG2E64_V_M1_MASK, VLSSEG2E64_V }, // 4360 + { PseudoVLSSEG2E64_V_M2, VLSSEG2E64_V }, // 4361 + { PseudoVLSSEG2E64_V_M2_MASK, VLSSEG2E64_V }, // 4362 + { PseudoVLSSEG2E64_V_M4, VLSSEG2E64_V }, // 4363 + { PseudoVLSSEG2E64_V_M4_MASK, VLSSEG2E64_V }, // 4364 + { PseudoVLSSEG2E8_V_M1, VLSSEG2E8_V }, // 4365 + { PseudoVLSSEG2E8_V_M1_MASK, VLSSEG2E8_V }, // 4366 + { PseudoVLSSEG2E8_V_M2, VLSSEG2E8_V }, // 4367 + { PseudoVLSSEG2E8_V_M2_MASK, VLSSEG2E8_V }, // 4368 + { PseudoVLSSEG2E8_V_M4, VLSSEG2E8_V }, // 4369 + { PseudoVLSSEG2E8_V_M4_MASK, VLSSEG2E8_V }, // 4370 + { PseudoVLSSEG2E8_V_MF2, VLSSEG2E8_V }, // 4371 + { PseudoVLSSEG2E8_V_MF2_MASK, VLSSEG2E8_V }, // 4372 + { PseudoVLSSEG2E8_V_MF4, VLSSEG2E8_V }, // 4373 + { PseudoVLSSEG2E8_V_MF4_MASK, VLSSEG2E8_V }, // 4374 + { PseudoVLSSEG2E8_V_MF8, VLSSEG2E8_V }, // 4375 + { PseudoVLSSEG2E8_V_MF8_MASK, VLSSEG2E8_V }, // 4376 + { PseudoVLSSEG3E16_V_M1, VLSSEG3E16_V }, // 4377 + { PseudoVLSSEG3E16_V_M1_MASK, VLSSEG3E16_V }, // 4378 + { PseudoVLSSEG3E16_V_M2, VLSSEG3E16_V }, // 4379 + { PseudoVLSSEG3E16_V_M2_MASK, VLSSEG3E16_V }, // 4380 + { PseudoVLSSEG3E16_V_MF2, VLSSEG3E16_V }, // 4381 + { PseudoVLSSEG3E16_V_MF2_MASK, VLSSEG3E16_V }, // 4382 + { PseudoVLSSEG3E16_V_MF4, VLSSEG3E16_V }, // 4383 + { PseudoVLSSEG3E16_V_MF4_MASK, VLSSEG3E16_V }, // 4384 + { PseudoVLSSEG3E32_V_M1, VLSSEG3E32_V }, // 4385 + { PseudoVLSSEG3E32_V_M1_MASK, VLSSEG3E32_V }, // 4386 + { PseudoVLSSEG3E32_V_M2, VLSSEG3E32_V }, // 4387 + { PseudoVLSSEG3E32_V_M2_MASK, VLSSEG3E32_V }, // 4388 + { PseudoVLSSEG3E32_V_MF2, VLSSEG3E32_V }, // 4389 + { PseudoVLSSEG3E32_V_MF2_MASK, VLSSEG3E32_V }, // 4390 + { PseudoVLSSEG3E64_V_M1, VLSSEG3E64_V }, // 4391 + { PseudoVLSSEG3E64_V_M1_MASK, VLSSEG3E64_V }, // 4392 + { PseudoVLSSEG3E64_V_M2, VLSSEG3E64_V }, // 4393 + { PseudoVLSSEG3E64_V_M2_MASK, VLSSEG3E64_V }, // 4394 + { PseudoVLSSEG3E8_V_M1, VLSSEG3E8_V }, // 4395 + { PseudoVLSSEG3E8_V_M1_MASK, VLSSEG3E8_V }, // 4396 + { PseudoVLSSEG3E8_V_M2, VLSSEG3E8_V }, // 4397 + { PseudoVLSSEG3E8_V_M2_MASK, VLSSEG3E8_V }, // 4398 + { PseudoVLSSEG3E8_V_MF2, VLSSEG3E8_V }, // 4399 + { PseudoVLSSEG3E8_V_MF2_MASK, VLSSEG3E8_V }, // 4400 + { PseudoVLSSEG3E8_V_MF4, VLSSEG3E8_V }, // 4401 + { PseudoVLSSEG3E8_V_MF4_MASK, VLSSEG3E8_V }, // 4402 + { PseudoVLSSEG3E8_V_MF8, VLSSEG3E8_V }, // 4403 + { PseudoVLSSEG3E8_V_MF8_MASK, VLSSEG3E8_V }, // 4404 + { PseudoVLSSEG4E16_V_M1, VLSSEG4E16_V }, // 4405 + { PseudoVLSSEG4E16_V_M1_MASK, VLSSEG4E16_V }, // 4406 + { PseudoVLSSEG4E16_V_M2, VLSSEG4E16_V }, // 4407 + { PseudoVLSSEG4E16_V_M2_MASK, VLSSEG4E16_V }, // 4408 + { PseudoVLSSEG4E16_V_MF2, VLSSEG4E16_V }, // 4409 + { PseudoVLSSEG4E16_V_MF2_MASK, VLSSEG4E16_V }, // 4410 + { PseudoVLSSEG4E16_V_MF4, VLSSEG4E16_V }, // 4411 + { PseudoVLSSEG4E16_V_MF4_MASK, VLSSEG4E16_V }, // 4412 + { PseudoVLSSEG4E32_V_M1, VLSSEG4E32_V }, // 4413 + { PseudoVLSSEG4E32_V_M1_MASK, VLSSEG4E32_V }, // 4414 + { PseudoVLSSEG4E32_V_M2, VLSSEG4E32_V }, // 4415 + { PseudoVLSSEG4E32_V_M2_MASK, VLSSEG4E32_V }, // 4416 + { PseudoVLSSEG4E32_V_MF2, VLSSEG4E32_V }, // 4417 + { PseudoVLSSEG4E32_V_MF2_MASK, VLSSEG4E32_V }, // 4418 + { PseudoVLSSEG4E64_V_M1, VLSSEG4E64_V }, // 4419 + { PseudoVLSSEG4E64_V_M1_MASK, VLSSEG4E64_V }, // 4420 + { PseudoVLSSEG4E64_V_M2, VLSSEG4E64_V }, // 4421 + { PseudoVLSSEG4E64_V_M2_MASK, VLSSEG4E64_V }, // 4422 + { PseudoVLSSEG4E8_V_M1, VLSSEG4E8_V }, // 4423 + { PseudoVLSSEG4E8_V_M1_MASK, VLSSEG4E8_V }, // 4424 + { PseudoVLSSEG4E8_V_M2, VLSSEG4E8_V }, // 4425 + { PseudoVLSSEG4E8_V_M2_MASK, VLSSEG4E8_V }, // 4426 + { PseudoVLSSEG4E8_V_MF2, VLSSEG4E8_V }, // 4427 + { PseudoVLSSEG4E8_V_MF2_MASK, VLSSEG4E8_V }, // 4428 + { PseudoVLSSEG4E8_V_MF4, VLSSEG4E8_V }, // 4429 + { PseudoVLSSEG4E8_V_MF4_MASK, VLSSEG4E8_V }, // 4430 + { PseudoVLSSEG4E8_V_MF8, VLSSEG4E8_V }, // 4431 + { PseudoVLSSEG4E8_V_MF8_MASK, VLSSEG4E8_V }, // 4432 + { PseudoVLSSEG5E16_V_M1, VLSSEG5E16_V }, // 4433 + { PseudoVLSSEG5E16_V_M1_MASK, VLSSEG5E16_V }, // 4434 + { PseudoVLSSEG5E16_V_MF2, VLSSEG5E16_V }, // 4435 + { PseudoVLSSEG5E16_V_MF2_MASK, VLSSEG5E16_V }, // 4436 + { PseudoVLSSEG5E16_V_MF4, VLSSEG5E16_V }, // 4437 + { PseudoVLSSEG5E16_V_MF4_MASK, VLSSEG5E16_V }, // 4438 + { PseudoVLSSEG5E32_V_M1, VLSSEG5E32_V }, // 4439 + { PseudoVLSSEG5E32_V_M1_MASK, VLSSEG5E32_V }, // 4440 + { PseudoVLSSEG5E32_V_MF2, VLSSEG5E32_V }, // 4441 + { PseudoVLSSEG5E32_V_MF2_MASK, VLSSEG5E32_V }, // 4442 + { PseudoVLSSEG5E64_V_M1, VLSSEG5E64_V }, // 4443 + { PseudoVLSSEG5E64_V_M1_MASK, VLSSEG5E64_V }, // 4444 + { PseudoVLSSEG5E8_V_M1, VLSSEG5E8_V }, // 4445 + { PseudoVLSSEG5E8_V_M1_MASK, VLSSEG5E8_V }, // 4446 + { PseudoVLSSEG5E8_V_MF2, VLSSEG5E8_V }, // 4447 + { PseudoVLSSEG5E8_V_MF2_MASK, VLSSEG5E8_V }, // 4448 + { PseudoVLSSEG5E8_V_MF4, VLSSEG5E8_V }, // 4449 + { PseudoVLSSEG5E8_V_MF4_MASK, VLSSEG5E8_V }, // 4450 + { PseudoVLSSEG5E8_V_MF8, VLSSEG5E8_V }, // 4451 + { PseudoVLSSEG5E8_V_MF8_MASK, VLSSEG5E8_V }, // 4452 + { PseudoVLSSEG6E16_V_M1, VLSSEG6E16_V }, // 4453 + { PseudoVLSSEG6E16_V_M1_MASK, VLSSEG6E16_V }, // 4454 + { PseudoVLSSEG6E16_V_MF2, VLSSEG6E16_V }, // 4455 + { PseudoVLSSEG6E16_V_MF2_MASK, VLSSEG6E16_V }, // 4456 + { PseudoVLSSEG6E16_V_MF4, VLSSEG6E16_V }, // 4457 + { PseudoVLSSEG6E16_V_MF4_MASK, VLSSEG6E16_V }, // 4458 + { PseudoVLSSEG6E32_V_M1, VLSSEG6E32_V }, // 4459 + { PseudoVLSSEG6E32_V_M1_MASK, VLSSEG6E32_V }, // 4460 + { PseudoVLSSEG6E32_V_MF2, VLSSEG6E32_V }, // 4461 + { PseudoVLSSEG6E32_V_MF2_MASK, VLSSEG6E32_V }, // 4462 + { PseudoVLSSEG6E64_V_M1, VLSSEG6E64_V }, // 4463 + { PseudoVLSSEG6E64_V_M1_MASK, VLSSEG6E64_V }, // 4464 + { PseudoVLSSEG6E8_V_M1, VLSSEG6E8_V }, // 4465 + { PseudoVLSSEG6E8_V_M1_MASK, VLSSEG6E8_V }, // 4466 + { PseudoVLSSEG6E8_V_MF2, VLSSEG6E8_V }, // 4467 + { PseudoVLSSEG6E8_V_MF2_MASK, VLSSEG6E8_V }, // 4468 + { PseudoVLSSEG6E8_V_MF4, VLSSEG6E8_V }, // 4469 + { PseudoVLSSEG6E8_V_MF4_MASK, VLSSEG6E8_V }, // 4470 + { PseudoVLSSEG6E8_V_MF8, VLSSEG6E8_V }, // 4471 + { PseudoVLSSEG6E8_V_MF8_MASK, VLSSEG6E8_V }, // 4472 + { PseudoVLSSEG7E16_V_M1, VLSSEG7E16_V }, // 4473 + { PseudoVLSSEG7E16_V_M1_MASK, VLSSEG7E16_V }, // 4474 + { PseudoVLSSEG7E16_V_MF2, VLSSEG7E16_V }, // 4475 + { PseudoVLSSEG7E16_V_MF2_MASK, VLSSEG7E16_V }, // 4476 + { PseudoVLSSEG7E16_V_MF4, VLSSEG7E16_V }, // 4477 + { PseudoVLSSEG7E16_V_MF4_MASK, VLSSEG7E16_V }, // 4478 + { PseudoVLSSEG7E32_V_M1, VLSSEG7E32_V }, // 4479 + { PseudoVLSSEG7E32_V_M1_MASK, VLSSEG7E32_V }, // 4480 + { PseudoVLSSEG7E32_V_MF2, VLSSEG7E32_V }, // 4481 + { PseudoVLSSEG7E32_V_MF2_MASK, VLSSEG7E32_V }, // 4482 + { PseudoVLSSEG7E64_V_M1, VLSSEG7E64_V }, // 4483 + { PseudoVLSSEG7E64_V_M1_MASK, VLSSEG7E64_V }, // 4484 + { PseudoVLSSEG7E8_V_M1, VLSSEG7E8_V }, // 4485 + { PseudoVLSSEG7E8_V_M1_MASK, VLSSEG7E8_V }, // 4486 + { PseudoVLSSEG7E8_V_MF2, VLSSEG7E8_V }, // 4487 + { PseudoVLSSEG7E8_V_MF2_MASK, VLSSEG7E8_V }, // 4488 + { PseudoVLSSEG7E8_V_MF4, VLSSEG7E8_V }, // 4489 + { PseudoVLSSEG7E8_V_MF4_MASK, VLSSEG7E8_V }, // 4490 + { PseudoVLSSEG7E8_V_MF8, VLSSEG7E8_V }, // 4491 + { PseudoVLSSEG7E8_V_MF8_MASK, VLSSEG7E8_V }, // 4492 + { PseudoVLSSEG8E16_V_M1, VLSSEG8E16_V }, // 4493 + { PseudoVLSSEG8E16_V_M1_MASK, VLSSEG8E16_V }, // 4494 + { PseudoVLSSEG8E16_V_MF2, VLSSEG8E16_V }, // 4495 + { PseudoVLSSEG8E16_V_MF2_MASK, VLSSEG8E16_V }, // 4496 + { PseudoVLSSEG8E16_V_MF4, VLSSEG8E16_V }, // 4497 + { PseudoVLSSEG8E16_V_MF4_MASK, VLSSEG8E16_V }, // 4498 + { PseudoVLSSEG8E32_V_M1, VLSSEG8E32_V }, // 4499 + { PseudoVLSSEG8E32_V_M1_MASK, VLSSEG8E32_V }, // 4500 + { PseudoVLSSEG8E32_V_MF2, VLSSEG8E32_V }, // 4501 + { PseudoVLSSEG8E32_V_MF2_MASK, VLSSEG8E32_V }, // 4502 + { PseudoVLSSEG8E64_V_M1, VLSSEG8E64_V }, // 4503 + { PseudoVLSSEG8E64_V_M1_MASK, VLSSEG8E64_V }, // 4504 + { PseudoVLSSEG8E8_V_M1, VLSSEG8E8_V }, // 4505 + { PseudoVLSSEG8E8_V_M1_MASK, VLSSEG8E8_V }, // 4506 + { PseudoVLSSEG8E8_V_MF2, VLSSEG8E8_V }, // 4507 + { PseudoVLSSEG8E8_V_MF2_MASK, VLSSEG8E8_V }, // 4508 + { PseudoVLSSEG8E8_V_MF4, VLSSEG8E8_V }, // 4509 + { PseudoVLSSEG8E8_V_MF4_MASK, VLSSEG8E8_V }, // 4510 + { PseudoVLSSEG8E8_V_MF8, VLSSEG8E8_V }, // 4511 + { PseudoVLSSEG8E8_V_MF8_MASK, VLSSEG8E8_V }, // 4512 + { PseudoVLUXEI16_V_M1_M1, VLUXEI16_V }, // 4513 + { PseudoVLUXEI16_V_M1_M1_MASK, VLUXEI16_V }, // 4514 + { PseudoVLUXEI16_V_M1_M2, VLUXEI16_V }, // 4515 + { PseudoVLUXEI16_V_M1_M2_MASK, VLUXEI16_V }, // 4516 + { PseudoVLUXEI16_V_M1_M4, VLUXEI16_V }, // 4517 + { PseudoVLUXEI16_V_M1_M4_MASK, VLUXEI16_V }, // 4518 + { PseudoVLUXEI16_V_M1_MF2, VLUXEI16_V }, // 4519 + { PseudoVLUXEI16_V_M1_MF2_MASK, VLUXEI16_V }, // 4520 + { PseudoVLUXEI16_V_M2_M1, VLUXEI16_V }, // 4521 + { PseudoVLUXEI16_V_M2_M1_MASK, VLUXEI16_V }, // 4522 + { PseudoVLUXEI16_V_M2_M2, VLUXEI16_V }, // 4523 + { PseudoVLUXEI16_V_M2_M2_MASK, VLUXEI16_V }, // 4524 + { PseudoVLUXEI16_V_M2_M4, VLUXEI16_V }, // 4525 + { PseudoVLUXEI16_V_M2_M4_MASK, VLUXEI16_V }, // 4526 + { PseudoVLUXEI16_V_M2_M8, VLUXEI16_V }, // 4527 + { PseudoVLUXEI16_V_M2_M8_MASK, VLUXEI16_V }, // 4528 + { PseudoVLUXEI16_V_M4_M2, VLUXEI16_V }, // 4529 + { PseudoVLUXEI16_V_M4_M2_MASK, VLUXEI16_V }, // 4530 + { PseudoVLUXEI16_V_M4_M4, VLUXEI16_V }, // 4531 + { PseudoVLUXEI16_V_M4_M4_MASK, VLUXEI16_V }, // 4532 + { PseudoVLUXEI16_V_M4_M8, VLUXEI16_V }, // 4533 + { PseudoVLUXEI16_V_M4_M8_MASK, VLUXEI16_V }, // 4534 + { PseudoVLUXEI16_V_M8_M4, VLUXEI16_V }, // 4535 + { PseudoVLUXEI16_V_M8_M4_MASK, VLUXEI16_V }, // 4536 + { PseudoVLUXEI16_V_M8_M8, VLUXEI16_V }, // 4537 + { PseudoVLUXEI16_V_M8_M8_MASK, VLUXEI16_V }, // 4538 + { PseudoVLUXEI16_V_MF2_M1, VLUXEI16_V }, // 4539 + { PseudoVLUXEI16_V_MF2_M1_MASK, VLUXEI16_V }, // 4540 + { PseudoVLUXEI16_V_MF2_M2, VLUXEI16_V }, // 4541 + { PseudoVLUXEI16_V_MF2_M2_MASK, VLUXEI16_V }, // 4542 + { PseudoVLUXEI16_V_MF2_MF2, VLUXEI16_V }, // 4543 + { PseudoVLUXEI16_V_MF2_MF2_MASK, VLUXEI16_V }, // 4544 + { PseudoVLUXEI16_V_MF2_MF4, VLUXEI16_V }, // 4545 + { PseudoVLUXEI16_V_MF2_MF4_MASK, VLUXEI16_V }, // 4546 + { PseudoVLUXEI16_V_MF4_M1, VLUXEI16_V }, // 4547 + { PseudoVLUXEI16_V_MF4_M1_MASK, VLUXEI16_V }, // 4548 + { PseudoVLUXEI16_V_MF4_MF2, VLUXEI16_V }, // 4549 + { PseudoVLUXEI16_V_MF4_MF2_MASK, VLUXEI16_V }, // 4550 + { PseudoVLUXEI16_V_MF4_MF4, VLUXEI16_V }, // 4551 + { PseudoVLUXEI16_V_MF4_MF4_MASK, VLUXEI16_V }, // 4552 + { PseudoVLUXEI16_V_MF4_MF8, VLUXEI16_V }, // 4553 + { PseudoVLUXEI16_V_MF4_MF8_MASK, VLUXEI16_V }, // 4554 + { PseudoVLUXEI32_V_M1_M1, VLUXEI32_V }, // 4555 + { PseudoVLUXEI32_V_M1_M1_MASK, VLUXEI32_V }, // 4556 + { PseudoVLUXEI32_V_M1_M2, VLUXEI32_V }, // 4557 + { PseudoVLUXEI32_V_M1_M2_MASK, VLUXEI32_V }, // 4558 + { PseudoVLUXEI32_V_M1_MF2, VLUXEI32_V }, // 4559 + { PseudoVLUXEI32_V_M1_MF2_MASK, VLUXEI32_V }, // 4560 + { PseudoVLUXEI32_V_M1_MF4, VLUXEI32_V }, // 4561 + { PseudoVLUXEI32_V_M1_MF4_MASK, VLUXEI32_V }, // 4562 + { PseudoVLUXEI32_V_M2_M1, VLUXEI32_V }, // 4563 + { PseudoVLUXEI32_V_M2_M1_MASK, VLUXEI32_V }, // 4564 + { PseudoVLUXEI32_V_M2_M2, VLUXEI32_V }, // 4565 + { PseudoVLUXEI32_V_M2_M2_MASK, VLUXEI32_V }, // 4566 + { PseudoVLUXEI32_V_M2_M4, VLUXEI32_V }, // 4567 + { PseudoVLUXEI32_V_M2_M4_MASK, VLUXEI32_V }, // 4568 + { PseudoVLUXEI32_V_M2_MF2, VLUXEI32_V }, // 4569 + { PseudoVLUXEI32_V_M2_MF2_MASK, VLUXEI32_V }, // 4570 + { PseudoVLUXEI32_V_M4_M1, VLUXEI32_V }, // 4571 + { PseudoVLUXEI32_V_M4_M1_MASK, VLUXEI32_V }, // 4572 + { PseudoVLUXEI32_V_M4_M2, VLUXEI32_V }, // 4573 + { PseudoVLUXEI32_V_M4_M2_MASK, VLUXEI32_V }, // 4574 + { PseudoVLUXEI32_V_M4_M4, VLUXEI32_V }, // 4575 + { PseudoVLUXEI32_V_M4_M4_MASK, VLUXEI32_V }, // 4576 + { PseudoVLUXEI32_V_M4_M8, VLUXEI32_V }, // 4577 + { PseudoVLUXEI32_V_M4_M8_MASK, VLUXEI32_V }, // 4578 + { PseudoVLUXEI32_V_M8_M2, VLUXEI32_V }, // 4579 + { PseudoVLUXEI32_V_M8_M2_MASK, VLUXEI32_V }, // 4580 + { PseudoVLUXEI32_V_M8_M4, VLUXEI32_V }, // 4581 + { PseudoVLUXEI32_V_M8_M4_MASK, VLUXEI32_V }, // 4582 + { PseudoVLUXEI32_V_M8_M8, VLUXEI32_V }, // 4583 + { PseudoVLUXEI32_V_M8_M8_MASK, VLUXEI32_V }, // 4584 + { PseudoVLUXEI32_V_MF2_M1, VLUXEI32_V }, // 4585 + { PseudoVLUXEI32_V_MF2_M1_MASK, VLUXEI32_V }, // 4586 + { PseudoVLUXEI32_V_MF2_MF2, VLUXEI32_V }, // 4587 + { PseudoVLUXEI32_V_MF2_MF2_MASK, VLUXEI32_V }, // 4588 + { PseudoVLUXEI32_V_MF2_MF4, VLUXEI32_V }, // 4589 + { PseudoVLUXEI32_V_MF2_MF4_MASK, VLUXEI32_V }, // 4590 + { PseudoVLUXEI32_V_MF2_MF8, VLUXEI32_V }, // 4591 + { PseudoVLUXEI32_V_MF2_MF8_MASK, VLUXEI32_V }, // 4592 + { PseudoVLUXEI64_V_M1_M1, VLUXEI64_V }, // 4593 + { PseudoVLUXEI64_V_M1_M1_MASK, VLUXEI64_V }, // 4594 + { PseudoVLUXEI64_V_M1_MF2, VLUXEI64_V }, // 4595 + { PseudoVLUXEI64_V_M1_MF2_MASK, VLUXEI64_V }, // 4596 + { PseudoVLUXEI64_V_M1_MF4, VLUXEI64_V }, // 4597 + { PseudoVLUXEI64_V_M1_MF4_MASK, VLUXEI64_V }, // 4598 + { PseudoVLUXEI64_V_M1_MF8, VLUXEI64_V }, // 4599 + { PseudoVLUXEI64_V_M1_MF8_MASK, VLUXEI64_V }, // 4600 + { PseudoVLUXEI64_V_M2_M1, VLUXEI64_V }, // 4601 + { PseudoVLUXEI64_V_M2_M1_MASK, VLUXEI64_V }, // 4602 + { PseudoVLUXEI64_V_M2_M2, VLUXEI64_V }, // 4603 + { PseudoVLUXEI64_V_M2_M2_MASK, VLUXEI64_V }, // 4604 + { PseudoVLUXEI64_V_M2_MF2, VLUXEI64_V }, // 4605 + { PseudoVLUXEI64_V_M2_MF2_MASK, VLUXEI64_V }, // 4606 + { PseudoVLUXEI64_V_M2_MF4, VLUXEI64_V }, // 4607 + { PseudoVLUXEI64_V_M2_MF4_MASK, VLUXEI64_V }, // 4608 + { PseudoVLUXEI64_V_M4_M1, VLUXEI64_V }, // 4609 + { PseudoVLUXEI64_V_M4_M1_MASK, VLUXEI64_V }, // 4610 + { PseudoVLUXEI64_V_M4_M2, VLUXEI64_V }, // 4611 + { PseudoVLUXEI64_V_M4_M2_MASK, VLUXEI64_V }, // 4612 + { PseudoVLUXEI64_V_M4_M4, VLUXEI64_V }, // 4613 + { PseudoVLUXEI64_V_M4_M4_MASK, VLUXEI64_V }, // 4614 + { PseudoVLUXEI64_V_M4_MF2, VLUXEI64_V }, // 4615 + { PseudoVLUXEI64_V_M4_MF2_MASK, VLUXEI64_V }, // 4616 + { PseudoVLUXEI64_V_M8_M1, VLUXEI64_V }, // 4617 + { PseudoVLUXEI64_V_M8_M1_MASK, VLUXEI64_V }, // 4618 + { PseudoVLUXEI64_V_M8_M2, VLUXEI64_V }, // 4619 + { PseudoVLUXEI64_V_M8_M2_MASK, VLUXEI64_V }, // 4620 + { PseudoVLUXEI64_V_M8_M4, VLUXEI64_V }, // 4621 + { PseudoVLUXEI64_V_M8_M4_MASK, VLUXEI64_V }, // 4622 + { PseudoVLUXEI64_V_M8_M8, VLUXEI64_V }, // 4623 + { PseudoVLUXEI64_V_M8_M8_MASK, VLUXEI64_V }, // 4624 + { PseudoVLUXEI8_V_M1_M1, VLUXEI8_V }, // 4625 + { PseudoVLUXEI8_V_M1_M1_MASK, VLUXEI8_V }, // 4626 + { PseudoVLUXEI8_V_M1_M2, VLUXEI8_V }, // 4627 + { PseudoVLUXEI8_V_M1_M2_MASK, VLUXEI8_V }, // 4628 + { PseudoVLUXEI8_V_M1_M4, VLUXEI8_V }, // 4629 + { PseudoVLUXEI8_V_M1_M4_MASK, VLUXEI8_V }, // 4630 + { PseudoVLUXEI8_V_M1_M8, VLUXEI8_V }, // 4631 + { PseudoVLUXEI8_V_M1_M8_MASK, VLUXEI8_V }, // 4632 + { PseudoVLUXEI8_V_M2_M2, VLUXEI8_V }, // 4633 + { PseudoVLUXEI8_V_M2_M2_MASK, VLUXEI8_V }, // 4634 + { PseudoVLUXEI8_V_M2_M4, VLUXEI8_V }, // 4635 + { PseudoVLUXEI8_V_M2_M4_MASK, VLUXEI8_V }, // 4636 + { PseudoVLUXEI8_V_M2_M8, VLUXEI8_V }, // 4637 + { PseudoVLUXEI8_V_M2_M8_MASK, VLUXEI8_V }, // 4638 + { PseudoVLUXEI8_V_M4_M4, VLUXEI8_V }, // 4639 + { PseudoVLUXEI8_V_M4_M4_MASK, VLUXEI8_V }, // 4640 + { PseudoVLUXEI8_V_M4_M8, VLUXEI8_V }, // 4641 + { PseudoVLUXEI8_V_M4_M8_MASK, VLUXEI8_V }, // 4642 + { PseudoVLUXEI8_V_M8_M8, VLUXEI8_V }, // 4643 + { PseudoVLUXEI8_V_M8_M8_MASK, VLUXEI8_V }, // 4644 + { PseudoVLUXEI8_V_MF2_M1, VLUXEI8_V }, // 4645 + { PseudoVLUXEI8_V_MF2_M1_MASK, VLUXEI8_V }, // 4646 + { PseudoVLUXEI8_V_MF2_M2, VLUXEI8_V }, // 4647 + { PseudoVLUXEI8_V_MF2_M2_MASK, VLUXEI8_V }, // 4648 + { PseudoVLUXEI8_V_MF2_M4, VLUXEI8_V }, // 4649 + { PseudoVLUXEI8_V_MF2_M4_MASK, VLUXEI8_V }, // 4650 + { PseudoVLUXEI8_V_MF2_MF2, VLUXEI8_V }, // 4651 + { PseudoVLUXEI8_V_MF2_MF2_MASK, VLUXEI8_V }, // 4652 + { PseudoVLUXEI8_V_MF4_M1, VLUXEI8_V }, // 4653 + { PseudoVLUXEI8_V_MF4_M1_MASK, VLUXEI8_V }, // 4654 + { PseudoVLUXEI8_V_MF4_M2, VLUXEI8_V }, // 4655 + { PseudoVLUXEI8_V_MF4_M2_MASK, VLUXEI8_V }, // 4656 + { PseudoVLUXEI8_V_MF4_MF2, VLUXEI8_V }, // 4657 + { PseudoVLUXEI8_V_MF4_MF2_MASK, VLUXEI8_V }, // 4658 + { PseudoVLUXEI8_V_MF4_MF4, VLUXEI8_V }, // 4659 + { PseudoVLUXEI8_V_MF4_MF4_MASK, VLUXEI8_V }, // 4660 + { PseudoVLUXEI8_V_MF8_M1, VLUXEI8_V }, // 4661 + { PseudoVLUXEI8_V_MF8_M1_MASK, VLUXEI8_V }, // 4662 + { PseudoVLUXEI8_V_MF8_MF2, VLUXEI8_V }, // 4663 + { PseudoVLUXEI8_V_MF8_MF2_MASK, VLUXEI8_V }, // 4664 + { PseudoVLUXEI8_V_MF8_MF4, VLUXEI8_V }, // 4665 + { PseudoVLUXEI8_V_MF8_MF4_MASK, VLUXEI8_V }, // 4666 + { PseudoVLUXEI8_V_MF8_MF8, VLUXEI8_V }, // 4667 + { PseudoVLUXEI8_V_MF8_MF8_MASK, VLUXEI8_V }, // 4668 + { PseudoVLUXSEG2EI16_V_M1_M1, VLUXSEG2EI16_V }, // 4669 + { PseudoVLUXSEG2EI16_V_M1_M1_MASK, VLUXSEG2EI16_V }, // 4670 + { PseudoVLUXSEG2EI16_V_M1_M2, VLUXSEG2EI16_V }, // 4671 + { PseudoVLUXSEG2EI16_V_M1_M2_MASK, VLUXSEG2EI16_V }, // 4672 + { PseudoVLUXSEG2EI16_V_M1_M4, VLUXSEG2EI16_V }, // 4673 + { PseudoVLUXSEG2EI16_V_M1_M4_MASK, VLUXSEG2EI16_V }, // 4674 + { PseudoVLUXSEG2EI16_V_M1_MF2, VLUXSEG2EI16_V }, // 4675 + { PseudoVLUXSEG2EI16_V_M1_MF2_MASK, VLUXSEG2EI16_V }, // 4676 + { PseudoVLUXSEG2EI16_V_M2_M1, VLUXSEG2EI16_V }, // 4677 + { PseudoVLUXSEG2EI16_V_M2_M1_MASK, VLUXSEG2EI16_V }, // 4678 + { PseudoVLUXSEG2EI16_V_M2_M2, VLUXSEG2EI16_V }, // 4679 + { PseudoVLUXSEG2EI16_V_M2_M2_MASK, VLUXSEG2EI16_V }, // 4680 + { PseudoVLUXSEG2EI16_V_M2_M4, VLUXSEG2EI16_V }, // 4681 + { PseudoVLUXSEG2EI16_V_M2_M4_MASK, VLUXSEG2EI16_V }, // 4682 + { PseudoVLUXSEG2EI16_V_M4_M2, VLUXSEG2EI16_V }, // 4683 + { PseudoVLUXSEG2EI16_V_M4_M2_MASK, VLUXSEG2EI16_V }, // 4684 + { PseudoVLUXSEG2EI16_V_M4_M4, VLUXSEG2EI16_V }, // 4685 + { PseudoVLUXSEG2EI16_V_M4_M4_MASK, VLUXSEG2EI16_V }, // 4686 + { PseudoVLUXSEG2EI16_V_M8_M4, VLUXSEG2EI16_V }, // 4687 + { PseudoVLUXSEG2EI16_V_M8_M4_MASK, VLUXSEG2EI16_V }, // 4688 + { PseudoVLUXSEG2EI16_V_MF2_M1, VLUXSEG2EI16_V }, // 4689 + { PseudoVLUXSEG2EI16_V_MF2_M1_MASK, VLUXSEG2EI16_V }, // 4690 + { PseudoVLUXSEG2EI16_V_MF2_M2, VLUXSEG2EI16_V }, // 4691 + { PseudoVLUXSEG2EI16_V_MF2_M2_MASK, VLUXSEG2EI16_V }, // 4692 + { PseudoVLUXSEG2EI16_V_MF2_MF2, VLUXSEG2EI16_V }, // 4693 + { PseudoVLUXSEG2EI16_V_MF2_MF2_MASK, VLUXSEG2EI16_V }, // 4694 + { PseudoVLUXSEG2EI16_V_MF2_MF4, VLUXSEG2EI16_V }, // 4695 + { PseudoVLUXSEG2EI16_V_MF2_MF4_MASK, VLUXSEG2EI16_V }, // 4696 + { PseudoVLUXSEG2EI16_V_MF4_M1, VLUXSEG2EI16_V }, // 4697 + { PseudoVLUXSEG2EI16_V_MF4_M1_MASK, VLUXSEG2EI16_V }, // 4698 + { PseudoVLUXSEG2EI16_V_MF4_MF2, VLUXSEG2EI16_V }, // 4699 + { PseudoVLUXSEG2EI16_V_MF4_MF2_MASK, VLUXSEG2EI16_V }, // 4700 + { PseudoVLUXSEG2EI16_V_MF4_MF4, VLUXSEG2EI16_V }, // 4701 + { PseudoVLUXSEG2EI16_V_MF4_MF4_MASK, VLUXSEG2EI16_V }, // 4702 + { PseudoVLUXSEG2EI16_V_MF4_MF8, VLUXSEG2EI16_V }, // 4703 + { PseudoVLUXSEG2EI16_V_MF4_MF8_MASK, VLUXSEG2EI16_V }, // 4704 + { PseudoVLUXSEG2EI32_V_M1_M1, VLUXSEG2EI32_V }, // 4705 + { PseudoVLUXSEG2EI32_V_M1_M1_MASK, VLUXSEG2EI32_V }, // 4706 + { PseudoVLUXSEG2EI32_V_M1_M2, VLUXSEG2EI32_V }, // 4707 + { PseudoVLUXSEG2EI32_V_M1_M2_MASK, VLUXSEG2EI32_V }, // 4708 + { PseudoVLUXSEG2EI32_V_M1_MF2, VLUXSEG2EI32_V }, // 4709 + { PseudoVLUXSEG2EI32_V_M1_MF2_MASK, VLUXSEG2EI32_V }, // 4710 + { PseudoVLUXSEG2EI32_V_M1_MF4, VLUXSEG2EI32_V }, // 4711 + { PseudoVLUXSEG2EI32_V_M1_MF4_MASK, VLUXSEG2EI32_V }, // 4712 + { PseudoVLUXSEG2EI32_V_M2_M1, VLUXSEG2EI32_V }, // 4713 + { PseudoVLUXSEG2EI32_V_M2_M1_MASK, VLUXSEG2EI32_V }, // 4714 + { PseudoVLUXSEG2EI32_V_M2_M2, VLUXSEG2EI32_V }, // 4715 + { PseudoVLUXSEG2EI32_V_M2_M2_MASK, VLUXSEG2EI32_V }, // 4716 + { PseudoVLUXSEG2EI32_V_M2_M4, VLUXSEG2EI32_V }, // 4717 + { PseudoVLUXSEG2EI32_V_M2_M4_MASK, VLUXSEG2EI32_V }, // 4718 + { PseudoVLUXSEG2EI32_V_M2_MF2, VLUXSEG2EI32_V }, // 4719 + { PseudoVLUXSEG2EI32_V_M2_MF2_MASK, VLUXSEG2EI32_V }, // 4720 + { PseudoVLUXSEG2EI32_V_M4_M1, VLUXSEG2EI32_V }, // 4721 + { PseudoVLUXSEG2EI32_V_M4_M1_MASK, VLUXSEG2EI32_V }, // 4722 + { PseudoVLUXSEG2EI32_V_M4_M2, VLUXSEG2EI32_V }, // 4723 + { PseudoVLUXSEG2EI32_V_M4_M2_MASK, VLUXSEG2EI32_V }, // 4724 + { PseudoVLUXSEG2EI32_V_M4_M4, VLUXSEG2EI32_V }, // 4725 + { PseudoVLUXSEG2EI32_V_M4_M4_MASK, VLUXSEG2EI32_V }, // 4726 + { PseudoVLUXSEG2EI32_V_M8_M2, VLUXSEG2EI32_V }, // 4727 + { PseudoVLUXSEG2EI32_V_M8_M2_MASK, VLUXSEG2EI32_V }, // 4728 + { PseudoVLUXSEG2EI32_V_M8_M4, VLUXSEG2EI32_V }, // 4729 + { PseudoVLUXSEG2EI32_V_M8_M4_MASK, VLUXSEG2EI32_V }, // 4730 + { PseudoVLUXSEG2EI32_V_MF2_M1, VLUXSEG2EI32_V }, // 4731 + { PseudoVLUXSEG2EI32_V_MF2_M1_MASK, VLUXSEG2EI32_V }, // 4732 + { PseudoVLUXSEG2EI32_V_MF2_MF2, VLUXSEG2EI32_V }, // 4733 + { PseudoVLUXSEG2EI32_V_MF2_MF2_MASK, VLUXSEG2EI32_V }, // 4734 + { PseudoVLUXSEG2EI32_V_MF2_MF4, VLUXSEG2EI32_V }, // 4735 + { PseudoVLUXSEG2EI32_V_MF2_MF4_MASK, VLUXSEG2EI32_V }, // 4736 + { PseudoVLUXSEG2EI32_V_MF2_MF8, VLUXSEG2EI32_V }, // 4737 + { PseudoVLUXSEG2EI32_V_MF2_MF8_MASK, VLUXSEG2EI32_V }, // 4738 + { PseudoVLUXSEG2EI64_V_M1_M1, VLUXSEG2EI64_V }, // 4739 + { PseudoVLUXSEG2EI64_V_M1_M1_MASK, VLUXSEG2EI64_V }, // 4740 + { PseudoVLUXSEG2EI64_V_M1_MF2, VLUXSEG2EI64_V }, // 4741 + { PseudoVLUXSEG2EI64_V_M1_MF2_MASK, VLUXSEG2EI64_V }, // 4742 + { PseudoVLUXSEG2EI64_V_M1_MF4, VLUXSEG2EI64_V }, // 4743 + { PseudoVLUXSEG2EI64_V_M1_MF4_MASK, VLUXSEG2EI64_V }, // 4744 + { PseudoVLUXSEG2EI64_V_M1_MF8, VLUXSEG2EI64_V }, // 4745 + { PseudoVLUXSEG2EI64_V_M1_MF8_MASK, VLUXSEG2EI64_V }, // 4746 + { PseudoVLUXSEG2EI64_V_M2_M1, VLUXSEG2EI64_V }, // 4747 + { PseudoVLUXSEG2EI64_V_M2_M1_MASK, VLUXSEG2EI64_V }, // 4748 + { PseudoVLUXSEG2EI64_V_M2_M2, VLUXSEG2EI64_V }, // 4749 + { PseudoVLUXSEG2EI64_V_M2_M2_MASK, VLUXSEG2EI64_V }, // 4750 + { PseudoVLUXSEG2EI64_V_M2_MF2, VLUXSEG2EI64_V }, // 4751 + { PseudoVLUXSEG2EI64_V_M2_MF2_MASK, VLUXSEG2EI64_V }, // 4752 + { PseudoVLUXSEG2EI64_V_M2_MF4, VLUXSEG2EI64_V }, // 4753 + { PseudoVLUXSEG2EI64_V_M2_MF4_MASK, VLUXSEG2EI64_V }, // 4754 + { PseudoVLUXSEG2EI64_V_M4_M1, VLUXSEG2EI64_V }, // 4755 + { PseudoVLUXSEG2EI64_V_M4_M1_MASK, VLUXSEG2EI64_V }, // 4756 + { PseudoVLUXSEG2EI64_V_M4_M2, VLUXSEG2EI64_V }, // 4757 + { PseudoVLUXSEG2EI64_V_M4_M2_MASK, VLUXSEG2EI64_V }, // 4758 + { PseudoVLUXSEG2EI64_V_M4_M4, VLUXSEG2EI64_V }, // 4759 + { PseudoVLUXSEG2EI64_V_M4_M4_MASK, VLUXSEG2EI64_V }, // 4760 + { PseudoVLUXSEG2EI64_V_M4_MF2, VLUXSEG2EI64_V }, // 4761 + { PseudoVLUXSEG2EI64_V_M4_MF2_MASK, VLUXSEG2EI64_V }, // 4762 + { PseudoVLUXSEG2EI64_V_M8_M1, VLUXSEG2EI64_V }, // 4763 + { PseudoVLUXSEG2EI64_V_M8_M1_MASK, VLUXSEG2EI64_V }, // 4764 + { PseudoVLUXSEG2EI64_V_M8_M2, VLUXSEG2EI64_V }, // 4765 + { PseudoVLUXSEG2EI64_V_M8_M2_MASK, VLUXSEG2EI64_V }, // 4766 + { PseudoVLUXSEG2EI64_V_M8_M4, VLUXSEG2EI64_V }, // 4767 + { PseudoVLUXSEG2EI64_V_M8_M4_MASK, VLUXSEG2EI64_V }, // 4768 + { PseudoVLUXSEG2EI8_V_M1_M1, VLUXSEG2EI8_V }, // 4769 + { PseudoVLUXSEG2EI8_V_M1_M1_MASK, VLUXSEG2EI8_V }, // 4770 + { PseudoVLUXSEG2EI8_V_M1_M2, VLUXSEG2EI8_V }, // 4771 + { PseudoVLUXSEG2EI8_V_M1_M2_MASK, VLUXSEG2EI8_V }, // 4772 + { PseudoVLUXSEG2EI8_V_M1_M4, VLUXSEG2EI8_V }, // 4773 + { PseudoVLUXSEG2EI8_V_M1_M4_MASK, VLUXSEG2EI8_V }, // 4774 + { PseudoVLUXSEG2EI8_V_M2_M2, VLUXSEG2EI8_V }, // 4775 + { PseudoVLUXSEG2EI8_V_M2_M2_MASK, VLUXSEG2EI8_V }, // 4776 + { PseudoVLUXSEG2EI8_V_M2_M4, VLUXSEG2EI8_V }, // 4777 + { PseudoVLUXSEG2EI8_V_M2_M4_MASK, VLUXSEG2EI8_V }, // 4778 + { PseudoVLUXSEG2EI8_V_M4_M4, VLUXSEG2EI8_V }, // 4779 + { PseudoVLUXSEG2EI8_V_M4_M4_MASK, VLUXSEG2EI8_V }, // 4780 + { PseudoVLUXSEG2EI8_V_MF2_M1, VLUXSEG2EI8_V }, // 4781 + { PseudoVLUXSEG2EI8_V_MF2_M1_MASK, VLUXSEG2EI8_V }, // 4782 + { PseudoVLUXSEG2EI8_V_MF2_M2, VLUXSEG2EI8_V }, // 4783 + { PseudoVLUXSEG2EI8_V_MF2_M2_MASK, VLUXSEG2EI8_V }, // 4784 + { PseudoVLUXSEG2EI8_V_MF2_M4, VLUXSEG2EI8_V }, // 4785 + { PseudoVLUXSEG2EI8_V_MF2_M4_MASK, VLUXSEG2EI8_V }, // 4786 + { PseudoVLUXSEG2EI8_V_MF2_MF2, VLUXSEG2EI8_V }, // 4787 + { PseudoVLUXSEG2EI8_V_MF2_MF2_MASK, VLUXSEG2EI8_V }, // 4788 + { PseudoVLUXSEG2EI8_V_MF4_M1, VLUXSEG2EI8_V }, // 4789 + { PseudoVLUXSEG2EI8_V_MF4_M1_MASK, VLUXSEG2EI8_V }, // 4790 + { PseudoVLUXSEG2EI8_V_MF4_M2, VLUXSEG2EI8_V }, // 4791 + { PseudoVLUXSEG2EI8_V_MF4_M2_MASK, VLUXSEG2EI8_V }, // 4792 + { PseudoVLUXSEG2EI8_V_MF4_MF2, VLUXSEG2EI8_V }, // 4793 + { PseudoVLUXSEG2EI8_V_MF4_MF2_MASK, VLUXSEG2EI8_V }, // 4794 + { PseudoVLUXSEG2EI8_V_MF4_MF4, VLUXSEG2EI8_V }, // 4795 + { PseudoVLUXSEG2EI8_V_MF4_MF4_MASK, VLUXSEG2EI8_V }, // 4796 + { PseudoVLUXSEG2EI8_V_MF8_M1, VLUXSEG2EI8_V }, // 4797 + { PseudoVLUXSEG2EI8_V_MF8_M1_MASK, VLUXSEG2EI8_V }, // 4798 + { PseudoVLUXSEG2EI8_V_MF8_MF2, VLUXSEG2EI8_V }, // 4799 + { PseudoVLUXSEG2EI8_V_MF8_MF2_MASK, VLUXSEG2EI8_V }, // 4800 + { PseudoVLUXSEG2EI8_V_MF8_MF4, VLUXSEG2EI8_V }, // 4801 + { PseudoVLUXSEG2EI8_V_MF8_MF4_MASK, VLUXSEG2EI8_V }, // 4802 + { PseudoVLUXSEG2EI8_V_MF8_MF8, VLUXSEG2EI8_V }, // 4803 + { PseudoVLUXSEG2EI8_V_MF8_MF8_MASK, VLUXSEG2EI8_V }, // 4804 + { PseudoVLUXSEG3EI16_V_M1_M1, VLUXSEG3EI16_V }, // 4805 + { PseudoVLUXSEG3EI16_V_M1_M1_MASK, VLUXSEG3EI16_V }, // 4806 + { PseudoVLUXSEG3EI16_V_M1_M2, VLUXSEG3EI16_V }, // 4807 + { PseudoVLUXSEG3EI16_V_M1_M2_MASK, VLUXSEG3EI16_V }, // 4808 + { PseudoVLUXSEG3EI16_V_M1_MF2, VLUXSEG3EI16_V }, // 4809 + { PseudoVLUXSEG3EI16_V_M1_MF2_MASK, VLUXSEG3EI16_V }, // 4810 + { PseudoVLUXSEG3EI16_V_M2_M1, VLUXSEG3EI16_V }, // 4811 + { PseudoVLUXSEG3EI16_V_M2_M1_MASK, VLUXSEG3EI16_V }, // 4812 + { PseudoVLUXSEG3EI16_V_M2_M2, VLUXSEG3EI16_V }, // 4813 + { PseudoVLUXSEG3EI16_V_M2_M2_MASK, VLUXSEG3EI16_V }, // 4814 + { PseudoVLUXSEG3EI16_V_M4_M2, VLUXSEG3EI16_V }, // 4815 + { PseudoVLUXSEG3EI16_V_M4_M2_MASK, VLUXSEG3EI16_V }, // 4816 + { PseudoVLUXSEG3EI16_V_MF2_M1, VLUXSEG3EI16_V }, // 4817 + { PseudoVLUXSEG3EI16_V_MF2_M1_MASK, VLUXSEG3EI16_V }, // 4818 + { PseudoVLUXSEG3EI16_V_MF2_M2, VLUXSEG3EI16_V }, // 4819 + { PseudoVLUXSEG3EI16_V_MF2_M2_MASK, VLUXSEG3EI16_V }, // 4820 + { PseudoVLUXSEG3EI16_V_MF2_MF2, VLUXSEG3EI16_V }, // 4821 + { PseudoVLUXSEG3EI16_V_MF2_MF2_MASK, VLUXSEG3EI16_V }, // 4822 + { PseudoVLUXSEG3EI16_V_MF2_MF4, VLUXSEG3EI16_V }, // 4823 + { PseudoVLUXSEG3EI16_V_MF2_MF4_MASK, VLUXSEG3EI16_V }, // 4824 + { PseudoVLUXSEG3EI16_V_MF4_M1, VLUXSEG3EI16_V }, // 4825 + { PseudoVLUXSEG3EI16_V_MF4_M1_MASK, VLUXSEG3EI16_V }, // 4826 + { PseudoVLUXSEG3EI16_V_MF4_MF2, VLUXSEG3EI16_V }, // 4827 + { PseudoVLUXSEG3EI16_V_MF4_MF2_MASK, VLUXSEG3EI16_V }, // 4828 + { PseudoVLUXSEG3EI16_V_MF4_MF4, VLUXSEG3EI16_V }, // 4829 + { PseudoVLUXSEG3EI16_V_MF4_MF4_MASK, VLUXSEG3EI16_V }, // 4830 + { PseudoVLUXSEG3EI16_V_MF4_MF8, VLUXSEG3EI16_V }, // 4831 + { PseudoVLUXSEG3EI16_V_MF4_MF8_MASK, VLUXSEG3EI16_V }, // 4832 + { PseudoVLUXSEG3EI32_V_M1_M1, VLUXSEG3EI32_V }, // 4833 + { PseudoVLUXSEG3EI32_V_M1_M1_MASK, VLUXSEG3EI32_V }, // 4834 + { PseudoVLUXSEG3EI32_V_M1_M2, VLUXSEG3EI32_V }, // 4835 + { PseudoVLUXSEG3EI32_V_M1_M2_MASK, VLUXSEG3EI32_V }, // 4836 + { PseudoVLUXSEG3EI32_V_M1_MF2, VLUXSEG3EI32_V }, // 4837 + { PseudoVLUXSEG3EI32_V_M1_MF2_MASK, VLUXSEG3EI32_V }, // 4838 + { PseudoVLUXSEG3EI32_V_M1_MF4, VLUXSEG3EI32_V }, // 4839 + { PseudoVLUXSEG3EI32_V_M1_MF4_MASK, VLUXSEG3EI32_V }, // 4840 + { PseudoVLUXSEG3EI32_V_M2_M1, VLUXSEG3EI32_V }, // 4841 + { PseudoVLUXSEG3EI32_V_M2_M1_MASK, VLUXSEG3EI32_V }, // 4842 + { PseudoVLUXSEG3EI32_V_M2_M2, VLUXSEG3EI32_V }, // 4843 + { PseudoVLUXSEG3EI32_V_M2_M2_MASK, VLUXSEG3EI32_V }, // 4844 + { PseudoVLUXSEG3EI32_V_M2_MF2, VLUXSEG3EI32_V }, // 4845 + { PseudoVLUXSEG3EI32_V_M2_MF2_MASK, VLUXSEG3EI32_V }, // 4846 + { PseudoVLUXSEG3EI32_V_M4_M1, VLUXSEG3EI32_V }, // 4847 + { PseudoVLUXSEG3EI32_V_M4_M1_MASK, VLUXSEG3EI32_V }, // 4848 + { PseudoVLUXSEG3EI32_V_M4_M2, VLUXSEG3EI32_V }, // 4849 + { PseudoVLUXSEG3EI32_V_M4_M2_MASK, VLUXSEG3EI32_V }, // 4850 + { PseudoVLUXSEG3EI32_V_M8_M2, VLUXSEG3EI32_V }, // 4851 + { PseudoVLUXSEG3EI32_V_M8_M2_MASK, VLUXSEG3EI32_V }, // 4852 + { PseudoVLUXSEG3EI32_V_MF2_M1, VLUXSEG3EI32_V }, // 4853 + { PseudoVLUXSEG3EI32_V_MF2_M1_MASK, VLUXSEG3EI32_V }, // 4854 + { PseudoVLUXSEG3EI32_V_MF2_MF2, VLUXSEG3EI32_V }, // 4855 + { PseudoVLUXSEG3EI32_V_MF2_MF2_MASK, VLUXSEG3EI32_V }, // 4856 + { PseudoVLUXSEG3EI32_V_MF2_MF4, VLUXSEG3EI32_V }, // 4857 + { PseudoVLUXSEG3EI32_V_MF2_MF4_MASK, VLUXSEG3EI32_V }, // 4858 + { PseudoVLUXSEG3EI32_V_MF2_MF8, VLUXSEG3EI32_V }, // 4859 + { PseudoVLUXSEG3EI32_V_MF2_MF8_MASK, VLUXSEG3EI32_V }, // 4860 + { PseudoVLUXSEG3EI64_V_M1_M1, VLUXSEG3EI64_V }, // 4861 + { PseudoVLUXSEG3EI64_V_M1_M1_MASK, VLUXSEG3EI64_V }, // 4862 + { PseudoVLUXSEG3EI64_V_M1_MF2, VLUXSEG3EI64_V }, // 4863 + { PseudoVLUXSEG3EI64_V_M1_MF2_MASK, VLUXSEG3EI64_V }, // 4864 + { PseudoVLUXSEG3EI64_V_M1_MF4, VLUXSEG3EI64_V }, // 4865 + { PseudoVLUXSEG3EI64_V_M1_MF4_MASK, VLUXSEG3EI64_V }, // 4866 + { PseudoVLUXSEG3EI64_V_M1_MF8, VLUXSEG3EI64_V }, // 4867 + { PseudoVLUXSEG3EI64_V_M1_MF8_MASK, VLUXSEG3EI64_V }, // 4868 + { PseudoVLUXSEG3EI64_V_M2_M1, VLUXSEG3EI64_V }, // 4869 + { PseudoVLUXSEG3EI64_V_M2_M1_MASK, VLUXSEG3EI64_V }, // 4870 + { PseudoVLUXSEG3EI64_V_M2_M2, VLUXSEG3EI64_V }, // 4871 + { PseudoVLUXSEG3EI64_V_M2_M2_MASK, VLUXSEG3EI64_V }, // 4872 + { PseudoVLUXSEG3EI64_V_M2_MF2, VLUXSEG3EI64_V }, // 4873 + { PseudoVLUXSEG3EI64_V_M2_MF2_MASK, VLUXSEG3EI64_V }, // 4874 + { PseudoVLUXSEG3EI64_V_M2_MF4, VLUXSEG3EI64_V }, // 4875 + { PseudoVLUXSEG3EI64_V_M2_MF4_MASK, VLUXSEG3EI64_V }, // 4876 + { PseudoVLUXSEG3EI64_V_M4_M1, VLUXSEG3EI64_V }, // 4877 + { PseudoVLUXSEG3EI64_V_M4_M1_MASK, VLUXSEG3EI64_V }, // 4878 + { PseudoVLUXSEG3EI64_V_M4_M2, VLUXSEG3EI64_V }, // 4879 + { PseudoVLUXSEG3EI64_V_M4_M2_MASK, VLUXSEG3EI64_V }, // 4880 + { PseudoVLUXSEG3EI64_V_M4_MF2, VLUXSEG3EI64_V }, // 4881 + { PseudoVLUXSEG3EI64_V_M4_MF2_MASK, VLUXSEG3EI64_V }, // 4882 + { PseudoVLUXSEG3EI64_V_M8_M1, VLUXSEG3EI64_V }, // 4883 + { PseudoVLUXSEG3EI64_V_M8_M1_MASK, VLUXSEG3EI64_V }, // 4884 + { PseudoVLUXSEG3EI64_V_M8_M2, VLUXSEG3EI64_V }, // 4885 + { PseudoVLUXSEG3EI64_V_M8_M2_MASK, VLUXSEG3EI64_V }, // 4886 + { PseudoVLUXSEG3EI8_V_M1_M1, VLUXSEG3EI8_V }, // 4887 + { PseudoVLUXSEG3EI8_V_M1_M1_MASK, VLUXSEG3EI8_V }, // 4888 + { PseudoVLUXSEG3EI8_V_M1_M2, VLUXSEG3EI8_V }, // 4889 + { PseudoVLUXSEG3EI8_V_M1_M2_MASK, VLUXSEG3EI8_V }, // 4890 + { PseudoVLUXSEG3EI8_V_M2_M2, VLUXSEG3EI8_V }, // 4891 + { PseudoVLUXSEG3EI8_V_M2_M2_MASK, VLUXSEG3EI8_V }, // 4892 + { PseudoVLUXSEG3EI8_V_MF2_M1, VLUXSEG3EI8_V }, // 4893 + { PseudoVLUXSEG3EI8_V_MF2_M1_MASK, VLUXSEG3EI8_V }, // 4894 + { PseudoVLUXSEG3EI8_V_MF2_M2, VLUXSEG3EI8_V }, // 4895 + { PseudoVLUXSEG3EI8_V_MF2_M2_MASK, VLUXSEG3EI8_V }, // 4896 + { PseudoVLUXSEG3EI8_V_MF2_MF2, VLUXSEG3EI8_V }, // 4897 + { PseudoVLUXSEG3EI8_V_MF2_MF2_MASK, VLUXSEG3EI8_V }, // 4898 + { PseudoVLUXSEG3EI8_V_MF4_M1, VLUXSEG3EI8_V }, // 4899 + { PseudoVLUXSEG3EI8_V_MF4_M1_MASK, VLUXSEG3EI8_V }, // 4900 + { PseudoVLUXSEG3EI8_V_MF4_M2, VLUXSEG3EI8_V }, // 4901 + { PseudoVLUXSEG3EI8_V_MF4_M2_MASK, VLUXSEG3EI8_V }, // 4902 + { PseudoVLUXSEG3EI8_V_MF4_MF2, VLUXSEG3EI8_V }, // 4903 + { PseudoVLUXSEG3EI8_V_MF4_MF2_MASK, VLUXSEG3EI8_V }, // 4904 + { PseudoVLUXSEG3EI8_V_MF4_MF4, VLUXSEG3EI8_V }, // 4905 + { PseudoVLUXSEG3EI8_V_MF4_MF4_MASK, VLUXSEG3EI8_V }, // 4906 + { PseudoVLUXSEG3EI8_V_MF8_M1, VLUXSEG3EI8_V }, // 4907 + { PseudoVLUXSEG3EI8_V_MF8_M1_MASK, VLUXSEG3EI8_V }, // 4908 + { PseudoVLUXSEG3EI8_V_MF8_MF2, VLUXSEG3EI8_V }, // 4909 + { PseudoVLUXSEG3EI8_V_MF8_MF2_MASK, VLUXSEG3EI8_V }, // 4910 + { PseudoVLUXSEG3EI8_V_MF8_MF4, VLUXSEG3EI8_V }, // 4911 + { PseudoVLUXSEG3EI8_V_MF8_MF4_MASK, VLUXSEG3EI8_V }, // 4912 + { PseudoVLUXSEG3EI8_V_MF8_MF8, VLUXSEG3EI8_V }, // 4913 + { PseudoVLUXSEG3EI8_V_MF8_MF8_MASK, VLUXSEG3EI8_V }, // 4914 + { PseudoVLUXSEG4EI16_V_M1_M1, VLUXSEG4EI16_V }, // 4915 + { PseudoVLUXSEG4EI16_V_M1_M1_MASK, VLUXSEG4EI16_V }, // 4916 + { PseudoVLUXSEG4EI16_V_M1_M2, VLUXSEG4EI16_V }, // 4917 + { PseudoVLUXSEG4EI16_V_M1_M2_MASK, VLUXSEG4EI16_V }, // 4918 + { PseudoVLUXSEG4EI16_V_M1_MF2, VLUXSEG4EI16_V }, // 4919 + { PseudoVLUXSEG4EI16_V_M1_MF2_MASK, VLUXSEG4EI16_V }, // 4920 + { PseudoVLUXSEG4EI16_V_M2_M1, VLUXSEG4EI16_V }, // 4921 + { PseudoVLUXSEG4EI16_V_M2_M1_MASK, VLUXSEG4EI16_V }, // 4922 + { PseudoVLUXSEG4EI16_V_M2_M2, VLUXSEG4EI16_V }, // 4923 + { PseudoVLUXSEG4EI16_V_M2_M2_MASK, VLUXSEG4EI16_V }, // 4924 + { PseudoVLUXSEG4EI16_V_M4_M2, VLUXSEG4EI16_V }, // 4925 + { PseudoVLUXSEG4EI16_V_M4_M2_MASK, VLUXSEG4EI16_V }, // 4926 + { PseudoVLUXSEG4EI16_V_MF2_M1, VLUXSEG4EI16_V }, // 4927 + { PseudoVLUXSEG4EI16_V_MF2_M1_MASK, VLUXSEG4EI16_V }, // 4928 + { PseudoVLUXSEG4EI16_V_MF2_M2, VLUXSEG4EI16_V }, // 4929 + { PseudoVLUXSEG4EI16_V_MF2_M2_MASK, VLUXSEG4EI16_V }, // 4930 + { PseudoVLUXSEG4EI16_V_MF2_MF2, VLUXSEG4EI16_V }, // 4931 + { PseudoVLUXSEG4EI16_V_MF2_MF2_MASK, VLUXSEG4EI16_V }, // 4932 + { PseudoVLUXSEG4EI16_V_MF2_MF4, VLUXSEG4EI16_V }, // 4933 + { PseudoVLUXSEG4EI16_V_MF2_MF4_MASK, VLUXSEG4EI16_V }, // 4934 + { PseudoVLUXSEG4EI16_V_MF4_M1, VLUXSEG4EI16_V }, // 4935 + { PseudoVLUXSEG4EI16_V_MF4_M1_MASK, VLUXSEG4EI16_V }, // 4936 + { PseudoVLUXSEG4EI16_V_MF4_MF2, VLUXSEG4EI16_V }, // 4937 + { PseudoVLUXSEG4EI16_V_MF4_MF2_MASK, VLUXSEG4EI16_V }, // 4938 + { PseudoVLUXSEG4EI16_V_MF4_MF4, VLUXSEG4EI16_V }, // 4939 + { PseudoVLUXSEG4EI16_V_MF4_MF4_MASK, VLUXSEG4EI16_V }, // 4940 + { PseudoVLUXSEG4EI16_V_MF4_MF8, VLUXSEG4EI16_V }, // 4941 + { PseudoVLUXSEG4EI16_V_MF4_MF8_MASK, VLUXSEG4EI16_V }, // 4942 + { PseudoVLUXSEG4EI32_V_M1_M1, VLUXSEG4EI32_V }, // 4943 + { PseudoVLUXSEG4EI32_V_M1_M1_MASK, VLUXSEG4EI32_V }, // 4944 + { PseudoVLUXSEG4EI32_V_M1_M2, VLUXSEG4EI32_V }, // 4945 + { PseudoVLUXSEG4EI32_V_M1_M2_MASK, VLUXSEG4EI32_V }, // 4946 + { PseudoVLUXSEG4EI32_V_M1_MF2, VLUXSEG4EI32_V }, // 4947 + { PseudoVLUXSEG4EI32_V_M1_MF2_MASK, VLUXSEG4EI32_V }, // 4948 + { PseudoVLUXSEG4EI32_V_M1_MF4, VLUXSEG4EI32_V }, // 4949 + { PseudoVLUXSEG4EI32_V_M1_MF4_MASK, VLUXSEG4EI32_V }, // 4950 + { PseudoVLUXSEG4EI32_V_M2_M1, VLUXSEG4EI32_V }, // 4951 + { PseudoVLUXSEG4EI32_V_M2_M1_MASK, VLUXSEG4EI32_V }, // 4952 + { PseudoVLUXSEG4EI32_V_M2_M2, VLUXSEG4EI32_V }, // 4953 + { PseudoVLUXSEG4EI32_V_M2_M2_MASK, VLUXSEG4EI32_V }, // 4954 + { PseudoVLUXSEG4EI32_V_M2_MF2, VLUXSEG4EI32_V }, // 4955 + { PseudoVLUXSEG4EI32_V_M2_MF2_MASK, VLUXSEG4EI32_V }, // 4956 + { PseudoVLUXSEG4EI32_V_M4_M1, VLUXSEG4EI32_V }, // 4957 + { PseudoVLUXSEG4EI32_V_M4_M1_MASK, VLUXSEG4EI32_V }, // 4958 + { PseudoVLUXSEG4EI32_V_M4_M2, VLUXSEG4EI32_V }, // 4959 + { PseudoVLUXSEG4EI32_V_M4_M2_MASK, VLUXSEG4EI32_V }, // 4960 + { PseudoVLUXSEG4EI32_V_M8_M2, VLUXSEG4EI32_V }, // 4961 + { PseudoVLUXSEG4EI32_V_M8_M2_MASK, VLUXSEG4EI32_V }, // 4962 + { PseudoVLUXSEG4EI32_V_MF2_M1, VLUXSEG4EI32_V }, // 4963 + { PseudoVLUXSEG4EI32_V_MF2_M1_MASK, VLUXSEG4EI32_V }, // 4964 + { PseudoVLUXSEG4EI32_V_MF2_MF2, VLUXSEG4EI32_V }, // 4965 + { PseudoVLUXSEG4EI32_V_MF2_MF2_MASK, VLUXSEG4EI32_V }, // 4966 + { PseudoVLUXSEG4EI32_V_MF2_MF4, VLUXSEG4EI32_V }, // 4967 + { PseudoVLUXSEG4EI32_V_MF2_MF4_MASK, VLUXSEG4EI32_V }, // 4968 + { PseudoVLUXSEG4EI32_V_MF2_MF8, VLUXSEG4EI32_V }, // 4969 + { PseudoVLUXSEG4EI32_V_MF2_MF8_MASK, VLUXSEG4EI32_V }, // 4970 + { PseudoVLUXSEG4EI64_V_M1_M1, VLUXSEG4EI64_V }, // 4971 + { PseudoVLUXSEG4EI64_V_M1_M1_MASK, VLUXSEG4EI64_V }, // 4972 + { PseudoVLUXSEG4EI64_V_M1_MF2, VLUXSEG4EI64_V }, // 4973 + { PseudoVLUXSEG4EI64_V_M1_MF2_MASK, VLUXSEG4EI64_V }, // 4974 + { PseudoVLUXSEG4EI64_V_M1_MF4, VLUXSEG4EI64_V }, // 4975 + { PseudoVLUXSEG4EI64_V_M1_MF4_MASK, VLUXSEG4EI64_V }, // 4976 + { PseudoVLUXSEG4EI64_V_M1_MF8, VLUXSEG4EI64_V }, // 4977 + { PseudoVLUXSEG4EI64_V_M1_MF8_MASK, VLUXSEG4EI64_V }, // 4978 + { PseudoVLUXSEG4EI64_V_M2_M1, VLUXSEG4EI64_V }, // 4979 + { PseudoVLUXSEG4EI64_V_M2_M1_MASK, VLUXSEG4EI64_V }, // 4980 + { PseudoVLUXSEG4EI64_V_M2_M2, VLUXSEG4EI64_V }, // 4981 + { PseudoVLUXSEG4EI64_V_M2_M2_MASK, VLUXSEG4EI64_V }, // 4982 + { PseudoVLUXSEG4EI64_V_M2_MF2, VLUXSEG4EI64_V }, // 4983 + { PseudoVLUXSEG4EI64_V_M2_MF2_MASK, VLUXSEG4EI64_V }, // 4984 + { PseudoVLUXSEG4EI64_V_M2_MF4, VLUXSEG4EI64_V }, // 4985 + { PseudoVLUXSEG4EI64_V_M2_MF4_MASK, VLUXSEG4EI64_V }, // 4986 + { PseudoVLUXSEG4EI64_V_M4_M1, VLUXSEG4EI64_V }, // 4987 + { PseudoVLUXSEG4EI64_V_M4_M1_MASK, VLUXSEG4EI64_V }, // 4988 + { PseudoVLUXSEG4EI64_V_M4_M2, VLUXSEG4EI64_V }, // 4989 + { PseudoVLUXSEG4EI64_V_M4_M2_MASK, VLUXSEG4EI64_V }, // 4990 + { PseudoVLUXSEG4EI64_V_M4_MF2, VLUXSEG4EI64_V }, // 4991 + { PseudoVLUXSEG4EI64_V_M4_MF2_MASK, VLUXSEG4EI64_V }, // 4992 + { PseudoVLUXSEG4EI64_V_M8_M1, VLUXSEG4EI64_V }, // 4993 + { PseudoVLUXSEG4EI64_V_M8_M1_MASK, VLUXSEG4EI64_V }, // 4994 + { PseudoVLUXSEG4EI64_V_M8_M2, VLUXSEG4EI64_V }, // 4995 + { PseudoVLUXSEG4EI64_V_M8_M2_MASK, VLUXSEG4EI64_V }, // 4996 + { PseudoVLUXSEG4EI8_V_M1_M1, VLUXSEG4EI8_V }, // 4997 + { PseudoVLUXSEG4EI8_V_M1_M1_MASK, VLUXSEG4EI8_V }, // 4998 + { PseudoVLUXSEG4EI8_V_M1_M2, VLUXSEG4EI8_V }, // 4999 + { PseudoVLUXSEG4EI8_V_M1_M2_MASK, VLUXSEG4EI8_V }, // 5000 + { PseudoVLUXSEG4EI8_V_M2_M2, VLUXSEG4EI8_V }, // 5001 + { PseudoVLUXSEG4EI8_V_M2_M2_MASK, VLUXSEG4EI8_V }, // 5002 + { PseudoVLUXSEG4EI8_V_MF2_M1, VLUXSEG4EI8_V }, // 5003 + { PseudoVLUXSEG4EI8_V_MF2_M1_MASK, VLUXSEG4EI8_V }, // 5004 + { PseudoVLUXSEG4EI8_V_MF2_M2, VLUXSEG4EI8_V }, // 5005 + { PseudoVLUXSEG4EI8_V_MF2_M2_MASK, VLUXSEG4EI8_V }, // 5006 + { PseudoVLUXSEG4EI8_V_MF2_MF2, VLUXSEG4EI8_V }, // 5007 + { PseudoVLUXSEG4EI8_V_MF2_MF2_MASK, VLUXSEG4EI8_V }, // 5008 + { PseudoVLUXSEG4EI8_V_MF4_M1, VLUXSEG4EI8_V }, // 5009 + { PseudoVLUXSEG4EI8_V_MF4_M1_MASK, VLUXSEG4EI8_V }, // 5010 + { PseudoVLUXSEG4EI8_V_MF4_M2, VLUXSEG4EI8_V }, // 5011 + { PseudoVLUXSEG4EI8_V_MF4_M2_MASK, VLUXSEG4EI8_V }, // 5012 + { PseudoVLUXSEG4EI8_V_MF4_MF2, VLUXSEG4EI8_V }, // 5013 + { PseudoVLUXSEG4EI8_V_MF4_MF2_MASK, VLUXSEG4EI8_V }, // 5014 + { PseudoVLUXSEG4EI8_V_MF4_MF4, VLUXSEG4EI8_V }, // 5015 + { PseudoVLUXSEG4EI8_V_MF4_MF4_MASK, VLUXSEG4EI8_V }, // 5016 + { PseudoVLUXSEG4EI8_V_MF8_M1, VLUXSEG4EI8_V }, // 5017 + { PseudoVLUXSEG4EI8_V_MF8_M1_MASK, VLUXSEG4EI8_V }, // 5018 + { PseudoVLUXSEG4EI8_V_MF8_MF2, VLUXSEG4EI8_V }, // 5019 + { PseudoVLUXSEG4EI8_V_MF8_MF2_MASK, VLUXSEG4EI8_V }, // 5020 + { PseudoVLUXSEG4EI8_V_MF8_MF4, VLUXSEG4EI8_V }, // 5021 + { PseudoVLUXSEG4EI8_V_MF8_MF4_MASK, VLUXSEG4EI8_V }, // 5022 + { PseudoVLUXSEG4EI8_V_MF8_MF8, VLUXSEG4EI8_V }, // 5023 + { PseudoVLUXSEG4EI8_V_MF8_MF8_MASK, VLUXSEG4EI8_V }, // 5024 + { PseudoVLUXSEG5EI16_V_M1_M1, VLUXSEG5EI16_V }, // 5025 + { PseudoVLUXSEG5EI16_V_M1_M1_MASK, VLUXSEG5EI16_V }, // 5026 + { PseudoVLUXSEG5EI16_V_M1_MF2, VLUXSEG5EI16_V }, // 5027 + { PseudoVLUXSEG5EI16_V_M1_MF2_MASK, VLUXSEG5EI16_V }, // 5028 + { PseudoVLUXSEG5EI16_V_M2_M1, VLUXSEG5EI16_V }, // 5029 + { PseudoVLUXSEG5EI16_V_M2_M1_MASK, VLUXSEG5EI16_V }, // 5030 + { PseudoVLUXSEG5EI16_V_MF2_M1, VLUXSEG5EI16_V }, // 5031 + { PseudoVLUXSEG5EI16_V_MF2_M1_MASK, VLUXSEG5EI16_V }, // 5032 + { PseudoVLUXSEG5EI16_V_MF2_MF2, VLUXSEG5EI16_V }, // 5033 + { PseudoVLUXSEG5EI16_V_MF2_MF2_MASK, VLUXSEG5EI16_V }, // 5034 + { PseudoVLUXSEG5EI16_V_MF2_MF4, VLUXSEG5EI16_V }, // 5035 + { PseudoVLUXSEG5EI16_V_MF2_MF4_MASK, VLUXSEG5EI16_V }, // 5036 + { PseudoVLUXSEG5EI16_V_MF4_M1, VLUXSEG5EI16_V }, // 5037 + { PseudoVLUXSEG5EI16_V_MF4_M1_MASK, VLUXSEG5EI16_V }, // 5038 + { PseudoVLUXSEG5EI16_V_MF4_MF2, VLUXSEG5EI16_V }, // 5039 + { PseudoVLUXSEG5EI16_V_MF4_MF2_MASK, VLUXSEG5EI16_V }, // 5040 + { PseudoVLUXSEG5EI16_V_MF4_MF4, VLUXSEG5EI16_V }, // 5041 + { PseudoVLUXSEG5EI16_V_MF4_MF4_MASK, VLUXSEG5EI16_V }, // 5042 + { PseudoVLUXSEG5EI16_V_MF4_MF8, VLUXSEG5EI16_V }, // 5043 + { PseudoVLUXSEG5EI16_V_MF4_MF8_MASK, VLUXSEG5EI16_V }, // 5044 + { PseudoVLUXSEG5EI32_V_M1_M1, VLUXSEG5EI32_V }, // 5045 + { PseudoVLUXSEG5EI32_V_M1_M1_MASK, VLUXSEG5EI32_V }, // 5046 + { PseudoVLUXSEG5EI32_V_M1_MF2, VLUXSEG5EI32_V }, // 5047 + { PseudoVLUXSEG5EI32_V_M1_MF2_MASK, VLUXSEG5EI32_V }, // 5048 + { PseudoVLUXSEG5EI32_V_M1_MF4, VLUXSEG5EI32_V }, // 5049 + { PseudoVLUXSEG5EI32_V_M1_MF4_MASK, VLUXSEG5EI32_V }, // 5050 + { PseudoVLUXSEG5EI32_V_M2_M1, VLUXSEG5EI32_V }, // 5051 + { PseudoVLUXSEG5EI32_V_M2_M1_MASK, VLUXSEG5EI32_V }, // 5052 + { PseudoVLUXSEG5EI32_V_M2_MF2, VLUXSEG5EI32_V }, // 5053 + { PseudoVLUXSEG5EI32_V_M2_MF2_MASK, VLUXSEG5EI32_V }, // 5054 + { PseudoVLUXSEG5EI32_V_M4_M1, VLUXSEG5EI32_V }, // 5055 + { PseudoVLUXSEG5EI32_V_M4_M1_MASK, VLUXSEG5EI32_V }, // 5056 + { PseudoVLUXSEG5EI32_V_MF2_M1, VLUXSEG5EI32_V }, // 5057 + { PseudoVLUXSEG5EI32_V_MF2_M1_MASK, VLUXSEG5EI32_V }, // 5058 + { PseudoVLUXSEG5EI32_V_MF2_MF2, VLUXSEG5EI32_V }, // 5059 + { PseudoVLUXSEG5EI32_V_MF2_MF2_MASK, VLUXSEG5EI32_V }, // 5060 + { PseudoVLUXSEG5EI32_V_MF2_MF4, VLUXSEG5EI32_V }, // 5061 + { PseudoVLUXSEG5EI32_V_MF2_MF4_MASK, VLUXSEG5EI32_V }, // 5062 + { PseudoVLUXSEG5EI32_V_MF2_MF8, VLUXSEG5EI32_V }, // 5063 + { PseudoVLUXSEG5EI32_V_MF2_MF8_MASK, VLUXSEG5EI32_V }, // 5064 + { PseudoVLUXSEG5EI64_V_M1_M1, VLUXSEG5EI64_V }, // 5065 + { PseudoVLUXSEG5EI64_V_M1_M1_MASK, VLUXSEG5EI64_V }, // 5066 + { PseudoVLUXSEG5EI64_V_M1_MF2, VLUXSEG5EI64_V }, // 5067 + { PseudoVLUXSEG5EI64_V_M1_MF2_MASK, VLUXSEG5EI64_V }, // 5068 + { PseudoVLUXSEG5EI64_V_M1_MF4, VLUXSEG5EI64_V }, // 5069 + { PseudoVLUXSEG5EI64_V_M1_MF4_MASK, VLUXSEG5EI64_V }, // 5070 + { PseudoVLUXSEG5EI64_V_M1_MF8, VLUXSEG5EI64_V }, // 5071 + { PseudoVLUXSEG5EI64_V_M1_MF8_MASK, VLUXSEG5EI64_V }, // 5072 + { PseudoVLUXSEG5EI64_V_M2_M1, VLUXSEG5EI64_V }, // 5073 + { PseudoVLUXSEG5EI64_V_M2_M1_MASK, VLUXSEG5EI64_V }, // 5074 + { PseudoVLUXSEG5EI64_V_M2_MF2, VLUXSEG5EI64_V }, // 5075 + { PseudoVLUXSEG5EI64_V_M2_MF2_MASK, VLUXSEG5EI64_V }, // 5076 + { PseudoVLUXSEG5EI64_V_M2_MF4, VLUXSEG5EI64_V }, // 5077 + { PseudoVLUXSEG5EI64_V_M2_MF4_MASK, VLUXSEG5EI64_V }, // 5078 + { PseudoVLUXSEG5EI64_V_M4_M1, VLUXSEG5EI64_V }, // 5079 + { PseudoVLUXSEG5EI64_V_M4_M1_MASK, VLUXSEG5EI64_V }, // 5080 + { PseudoVLUXSEG5EI64_V_M4_MF2, VLUXSEG5EI64_V }, // 5081 + { PseudoVLUXSEG5EI64_V_M4_MF2_MASK, VLUXSEG5EI64_V }, // 5082 + { PseudoVLUXSEG5EI64_V_M8_M1, VLUXSEG5EI64_V }, // 5083 + { PseudoVLUXSEG5EI64_V_M8_M1_MASK, VLUXSEG5EI64_V }, // 5084 + { PseudoVLUXSEG5EI8_V_M1_M1, VLUXSEG5EI8_V }, // 5085 + { PseudoVLUXSEG5EI8_V_M1_M1_MASK, VLUXSEG5EI8_V }, // 5086 + { PseudoVLUXSEG5EI8_V_MF2_M1, VLUXSEG5EI8_V }, // 5087 + { PseudoVLUXSEG5EI8_V_MF2_M1_MASK, VLUXSEG5EI8_V }, // 5088 + { PseudoVLUXSEG5EI8_V_MF2_MF2, VLUXSEG5EI8_V }, // 5089 + { PseudoVLUXSEG5EI8_V_MF2_MF2_MASK, VLUXSEG5EI8_V }, // 5090 + { PseudoVLUXSEG5EI8_V_MF4_M1, VLUXSEG5EI8_V }, // 5091 + { PseudoVLUXSEG5EI8_V_MF4_M1_MASK, VLUXSEG5EI8_V }, // 5092 + { PseudoVLUXSEG5EI8_V_MF4_MF2, VLUXSEG5EI8_V }, // 5093 + { PseudoVLUXSEG5EI8_V_MF4_MF2_MASK, VLUXSEG5EI8_V }, // 5094 + { PseudoVLUXSEG5EI8_V_MF4_MF4, VLUXSEG5EI8_V }, // 5095 + { PseudoVLUXSEG5EI8_V_MF4_MF4_MASK, VLUXSEG5EI8_V }, // 5096 + { PseudoVLUXSEG5EI8_V_MF8_M1, VLUXSEG5EI8_V }, // 5097 + { PseudoVLUXSEG5EI8_V_MF8_M1_MASK, VLUXSEG5EI8_V }, // 5098 + { PseudoVLUXSEG5EI8_V_MF8_MF2, VLUXSEG5EI8_V }, // 5099 + { PseudoVLUXSEG5EI8_V_MF8_MF2_MASK, VLUXSEG5EI8_V }, // 5100 + { PseudoVLUXSEG5EI8_V_MF8_MF4, VLUXSEG5EI8_V }, // 5101 + { PseudoVLUXSEG5EI8_V_MF8_MF4_MASK, VLUXSEG5EI8_V }, // 5102 + { PseudoVLUXSEG5EI8_V_MF8_MF8, VLUXSEG5EI8_V }, // 5103 + { PseudoVLUXSEG5EI8_V_MF8_MF8_MASK, VLUXSEG5EI8_V }, // 5104 + { PseudoVLUXSEG6EI16_V_M1_M1, VLUXSEG6EI16_V }, // 5105 + { PseudoVLUXSEG6EI16_V_M1_M1_MASK, VLUXSEG6EI16_V }, // 5106 + { PseudoVLUXSEG6EI16_V_M1_MF2, VLUXSEG6EI16_V }, // 5107 + { PseudoVLUXSEG6EI16_V_M1_MF2_MASK, VLUXSEG6EI16_V }, // 5108 + { PseudoVLUXSEG6EI16_V_M2_M1, VLUXSEG6EI16_V }, // 5109 + { PseudoVLUXSEG6EI16_V_M2_M1_MASK, VLUXSEG6EI16_V }, // 5110 + { PseudoVLUXSEG6EI16_V_MF2_M1, VLUXSEG6EI16_V }, // 5111 + { PseudoVLUXSEG6EI16_V_MF2_M1_MASK, VLUXSEG6EI16_V }, // 5112 + { PseudoVLUXSEG6EI16_V_MF2_MF2, VLUXSEG6EI16_V }, // 5113 + { PseudoVLUXSEG6EI16_V_MF2_MF2_MASK, VLUXSEG6EI16_V }, // 5114 + { PseudoVLUXSEG6EI16_V_MF2_MF4, VLUXSEG6EI16_V }, // 5115 + { PseudoVLUXSEG6EI16_V_MF2_MF4_MASK, VLUXSEG6EI16_V }, // 5116 + { PseudoVLUXSEG6EI16_V_MF4_M1, VLUXSEG6EI16_V }, // 5117 + { PseudoVLUXSEG6EI16_V_MF4_M1_MASK, VLUXSEG6EI16_V }, // 5118 + { PseudoVLUXSEG6EI16_V_MF4_MF2, VLUXSEG6EI16_V }, // 5119 + { PseudoVLUXSEG6EI16_V_MF4_MF2_MASK, VLUXSEG6EI16_V }, // 5120 + { PseudoVLUXSEG6EI16_V_MF4_MF4, VLUXSEG6EI16_V }, // 5121 + { PseudoVLUXSEG6EI16_V_MF4_MF4_MASK, VLUXSEG6EI16_V }, // 5122 + { PseudoVLUXSEG6EI16_V_MF4_MF8, VLUXSEG6EI16_V }, // 5123 + { PseudoVLUXSEG6EI16_V_MF4_MF8_MASK, VLUXSEG6EI16_V }, // 5124 + { PseudoVLUXSEG6EI32_V_M1_M1, VLUXSEG6EI32_V }, // 5125 + { PseudoVLUXSEG6EI32_V_M1_M1_MASK, VLUXSEG6EI32_V }, // 5126 + { PseudoVLUXSEG6EI32_V_M1_MF2, VLUXSEG6EI32_V }, // 5127 + { PseudoVLUXSEG6EI32_V_M1_MF2_MASK, VLUXSEG6EI32_V }, // 5128 + { PseudoVLUXSEG6EI32_V_M1_MF4, VLUXSEG6EI32_V }, // 5129 + { PseudoVLUXSEG6EI32_V_M1_MF4_MASK, VLUXSEG6EI32_V }, // 5130 + { PseudoVLUXSEG6EI32_V_M2_M1, VLUXSEG6EI32_V }, // 5131 + { PseudoVLUXSEG6EI32_V_M2_M1_MASK, VLUXSEG6EI32_V }, // 5132 + { PseudoVLUXSEG6EI32_V_M2_MF2, VLUXSEG6EI32_V }, // 5133 + { PseudoVLUXSEG6EI32_V_M2_MF2_MASK, VLUXSEG6EI32_V }, // 5134 + { PseudoVLUXSEG6EI32_V_M4_M1, VLUXSEG6EI32_V }, // 5135 + { PseudoVLUXSEG6EI32_V_M4_M1_MASK, VLUXSEG6EI32_V }, // 5136 + { PseudoVLUXSEG6EI32_V_MF2_M1, VLUXSEG6EI32_V }, // 5137 + { PseudoVLUXSEG6EI32_V_MF2_M1_MASK, VLUXSEG6EI32_V }, // 5138 + { PseudoVLUXSEG6EI32_V_MF2_MF2, VLUXSEG6EI32_V }, // 5139 + { PseudoVLUXSEG6EI32_V_MF2_MF2_MASK, VLUXSEG6EI32_V }, // 5140 + { PseudoVLUXSEG6EI32_V_MF2_MF4, VLUXSEG6EI32_V }, // 5141 + { PseudoVLUXSEG6EI32_V_MF2_MF4_MASK, VLUXSEG6EI32_V }, // 5142 + { PseudoVLUXSEG6EI32_V_MF2_MF8, VLUXSEG6EI32_V }, // 5143 + { PseudoVLUXSEG6EI32_V_MF2_MF8_MASK, VLUXSEG6EI32_V }, // 5144 + { PseudoVLUXSEG6EI64_V_M1_M1, VLUXSEG6EI64_V }, // 5145 + { PseudoVLUXSEG6EI64_V_M1_M1_MASK, VLUXSEG6EI64_V }, // 5146 + { PseudoVLUXSEG6EI64_V_M1_MF2, VLUXSEG6EI64_V }, // 5147 + { PseudoVLUXSEG6EI64_V_M1_MF2_MASK, VLUXSEG6EI64_V }, // 5148 + { PseudoVLUXSEG6EI64_V_M1_MF4, VLUXSEG6EI64_V }, // 5149 + { PseudoVLUXSEG6EI64_V_M1_MF4_MASK, VLUXSEG6EI64_V }, // 5150 + { PseudoVLUXSEG6EI64_V_M1_MF8, VLUXSEG6EI64_V }, // 5151 + { PseudoVLUXSEG6EI64_V_M1_MF8_MASK, VLUXSEG6EI64_V }, // 5152 + { PseudoVLUXSEG6EI64_V_M2_M1, VLUXSEG6EI64_V }, // 5153 + { PseudoVLUXSEG6EI64_V_M2_M1_MASK, VLUXSEG6EI64_V }, // 5154 + { PseudoVLUXSEG6EI64_V_M2_MF2, VLUXSEG6EI64_V }, // 5155 + { PseudoVLUXSEG6EI64_V_M2_MF2_MASK, VLUXSEG6EI64_V }, // 5156 + { PseudoVLUXSEG6EI64_V_M2_MF4, VLUXSEG6EI64_V }, // 5157 + { PseudoVLUXSEG6EI64_V_M2_MF4_MASK, VLUXSEG6EI64_V }, // 5158 + { PseudoVLUXSEG6EI64_V_M4_M1, VLUXSEG6EI64_V }, // 5159 + { PseudoVLUXSEG6EI64_V_M4_M1_MASK, VLUXSEG6EI64_V }, // 5160 + { PseudoVLUXSEG6EI64_V_M4_MF2, VLUXSEG6EI64_V }, // 5161 + { PseudoVLUXSEG6EI64_V_M4_MF2_MASK, VLUXSEG6EI64_V }, // 5162 + { PseudoVLUXSEG6EI64_V_M8_M1, VLUXSEG6EI64_V }, // 5163 + { PseudoVLUXSEG6EI64_V_M8_M1_MASK, VLUXSEG6EI64_V }, // 5164 + { PseudoVLUXSEG6EI8_V_M1_M1, VLUXSEG6EI8_V }, // 5165 + { PseudoVLUXSEG6EI8_V_M1_M1_MASK, VLUXSEG6EI8_V }, // 5166 + { PseudoVLUXSEG6EI8_V_MF2_M1, VLUXSEG6EI8_V }, // 5167 + { PseudoVLUXSEG6EI8_V_MF2_M1_MASK, VLUXSEG6EI8_V }, // 5168 + { PseudoVLUXSEG6EI8_V_MF2_MF2, VLUXSEG6EI8_V }, // 5169 + { PseudoVLUXSEG6EI8_V_MF2_MF2_MASK, VLUXSEG6EI8_V }, // 5170 + { PseudoVLUXSEG6EI8_V_MF4_M1, VLUXSEG6EI8_V }, // 5171 + { PseudoVLUXSEG6EI8_V_MF4_M1_MASK, VLUXSEG6EI8_V }, // 5172 + { PseudoVLUXSEG6EI8_V_MF4_MF2, VLUXSEG6EI8_V }, // 5173 + { PseudoVLUXSEG6EI8_V_MF4_MF2_MASK, VLUXSEG6EI8_V }, // 5174 + { PseudoVLUXSEG6EI8_V_MF4_MF4, VLUXSEG6EI8_V }, // 5175 + { PseudoVLUXSEG6EI8_V_MF4_MF4_MASK, VLUXSEG6EI8_V }, // 5176 + { PseudoVLUXSEG6EI8_V_MF8_M1, VLUXSEG6EI8_V }, // 5177 + { PseudoVLUXSEG6EI8_V_MF8_M1_MASK, VLUXSEG6EI8_V }, // 5178 + { PseudoVLUXSEG6EI8_V_MF8_MF2, VLUXSEG6EI8_V }, // 5179 + { PseudoVLUXSEG6EI8_V_MF8_MF2_MASK, VLUXSEG6EI8_V }, // 5180 + { PseudoVLUXSEG6EI8_V_MF8_MF4, VLUXSEG6EI8_V }, // 5181 + { PseudoVLUXSEG6EI8_V_MF8_MF4_MASK, VLUXSEG6EI8_V }, // 5182 + { PseudoVLUXSEG6EI8_V_MF8_MF8, VLUXSEG6EI8_V }, // 5183 + { PseudoVLUXSEG6EI8_V_MF8_MF8_MASK, VLUXSEG6EI8_V }, // 5184 + { PseudoVLUXSEG7EI16_V_M1_M1, VLUXSEG7EI16_V }, // 5185 + { PseudoVLUXSEG7EI16_V_M1_M1_MASK, VLUXSEG7EI16_V }, // 5186 + { PseudoVLUXSEG7EI16_V_M1_MF2, VLUXSEG7EI16_V }, // 5187 + { PseudoVLUXSEG7EI16_V_M1_MF2_MASK, VLUXSEG7EI16_V }, // 5188 + { PseudoVLUXSEG7EI16_V_M2_M1, VLUXSEG7EI16_V }, // 5189 + { PseudoVLUXSEG7EI16_V_M2_M1_MASK, VLUXSEG7EI16_V }, // 5190 + { PseudoVLUXSEG7EI16_V_MF2_M1, VLUXSEG7EI16_V }, // 5191 + { PseudoVLUXSEG7EI16_V_MF2_M1_MASK, VLUXSEG7EI16_V }, // 5192 + { PseudoVLUXSEG7EI16_V_MF2_MF2, VLUXSEG7EI16_V }, // 5193 + { PseudoVLUXSEG7EI16_V_MF2_MF2_MASK, VLUXSEG7EI16_V }, // 5194 + { PseudoVLUXSEG7EI16_V_MF2_MF4, VLUXSEG7EI16_V }, // 5195 + { PseudoVLUXSEG7EI16_V_MF2_MF4_MASK, VLUXSEG7EI16_V }, // 5196 + { PseudoVLUXSEG7EI16_V_MF4_M1, VLUXSEG7EI16_V }, // 5197 + { PseudoVLUXSEG7EI16_V_MF4_M1_MASK, VLUXSEG7EI16_V }, // 5198 + { PseudoVLUXSEG7EI16_V_MF4_MF2, VLUXSEG7EI16_V }, // 5199 + { PseudoVLUXSEG7EI16_V_MF4_MF2_MASK, VLUXSEG7EI16_V }, // 5200 + { PseudoVLUXSEG7EI16_V_MF4_MF4, VLUXSEG7EI16_V }, // 5201 + { PseudoVLUXSEG7EI16_V_MF4_MF4_MASK, VLUXSEG7EI16_V }, // 5202 + { PseudoVLUXSEG7EI16_V_MF4_MF8, VLUXSEG7EI16_V }, // 5203 + { PseudoVLUXSEG7EI16_V_MF4_MF8_MASK, VLUXSEG7EI16_V }, // 5204 + { PseudoVLUXSEG7EI32_V_M1_M1, VLUXSEG7EI32_V }, // 5205 + { PseudoVLUXSEG7EI32_V_M1_M1_MASK, VLUXSEG7EI32_V }, // 5206 + { PseudoVLUXSEG7EI32_V_M1_MF2, VLUXSEG7EI32_V }, // 5207 + { PseudoVLUXSEG7EI32_V_M1_MF2_MASK, VLUXSEG7EI32_V }, // 5208 + { PseudoVLUXSEG7EI32_V_M1_MF4, VLUXSEG7EI32_V }, // 5209 + { PseudoVLUXSEG7EI32_V_M1_MF4_MASK, VLUXSEG7EI32_V }, // 5210 + { PseudoVLUXSEG7EI32_V_M2_M1, VLUXSEG7EI32_V }, // 5211 + { PseudoVLUXSEG7EI32_V_M2_M1_MASK, VLUXSEG7EI32_V }, // 5212 + { PseudoVLUXSEG7EI32_V_M2_MF2, VLUXSEG7EI32_V }, // 5213 + { PseudoVLUXSEG7EI32_V_M2_MF2_MASK, VLUXSEG7EI32_V }, // 5214 + { PseudoVLUXSEG7EI32_V_M4_M1, VLUXSEG7EI32_V }, // 5215 + { PseudoVLUXSEG7EI32_V_M4_M1_MASK, VLUXSEG7EI32_V }, // 5216 + { PseudoVLUXSEG7EI32_V_MF2_M1, VLUXSEG7EI32_V }, // 5217 + { PseudoVLUXSEG7EI32_V_MF2_M1_MASK, VLUXSEG7EI32_V }, // 5218 + { PseudoVLUXSEG7EI32_V_MF2_MF2, VLUXSEG7EI32_V }, // 5219 + { PseudoVLUXSEG7EI32_V_MF2_MF2_MASK, VLUXSEG7EI32_V }, // 5220 + { PseudoVLUXSEG7EI32_V_MF2_MF4, VLUXSEG7EI32_V }, // 5221 + { PseudoVLUXSEG7EI32_V_MF2_MF4_MASK, VLUXSEG7EI32_V }, // 5222 + { PseudoVLUXSEG7EI32_V_MF2_MF8, VLUXSEG7EI32_V }, // 5223 + { PseudoVLUXSEG7EI32_V_MF2_MF8_MASK, VLUXSEG7EI32_V }, // 5224 + { PseudoVLUXSEG7EI64_V_M1_M1, VLUXSEG7EI64_V }, // 5225 + { PseudoVLUXSEG7EI64_V_M1_M1_MASK, VLUXSEG7EI64_V }, // 5226 + { PseudoVLUXSEG7EI64_V_M1_MF2, VLUXSEG7EI64_V }, // 5227 + { PseudoVLUXSEG7EI64_V_M1_MF2_MASK, VLUXSEG7EI64_V }, // 5228 + { PseudoVLUXSEG7EI64_V_M1_MF4, VLUXSEG7EI64_V }, // 5229 + { PseudoVLUXSEG7EI64_V_M1_MF4_MASK, VLUXSEG7EI64_V }, // 5230 + { PseudoVLUXSEG7EI64_V_M1_MF8, VLUXSEG7EI64_V }, // 5231 + { PseudoVLUXSEG7EI64_V_M1_MF8_MASK, VLUXSEG7EI64_V }, // 5232 + { PseudoVLUXSEG7EI64_V_M2_M1, VLUXSEG7EI64_V }, // 5233 + { PseudoVLUXSEG7EI64_V_M2_M1_MASK, VLUXSEG7EI64_V }, // 5234 + { PseudoVLUXSEG7EI64_V_M2_MF2, VLUXSEG7EI64_V }, // 5235 + { PseudoVLUXSEG7EI64_V_M2_MF2_MASK, VLUXSEG7EI64_V }, // 5236 + { PseudoVLUXSEG7EI64_V_M2_MF4, VLUXSEG7EI64_V }, // 5237 + { PseudoVLUXSEG7EI64_V_M2_MF4_MASK, VLUXSEG7EI64_V }, // 5238 + { PseudoVLUXSEG7EI64_V_M4_M1, VLUXSEG7EI64_V }, // 5239 + { PseudoVLUXSEG7EI64_V_M4_M1_MASK, VLUXSEG7EI64_V }, // 5240 + { PseudoVLUXSEG7EI64_V_M4_MF2, VLUXSEG7EI64_V }, // 5241 + { PseudoVLUXSEG7EI64_V_M4_MF2_MASK, VLUXSEG7EI64_V }, // 5242 + { PseudoVLUXSEG7EI64_V_M8_M1, VLUXSEG7EI64_V }, // 5243 + { PseudoVLUXSEG7EI64_V_M8_M1_MASK, VLUXSEG7EI64_V }, // 5244 + { PseudoVLUXSEG7EI8_V_M1_M1, VLUXSEG7EI8_V }, // 5245 + { PseudoVLUXSEG7EI8_V_M1_M1_MASK, VLUXSEG7EI8_V }, // 5246 + { PseudoVLUXSEG7EI8_V_MF2_M1, VLUXSEG7EI8_V }, // 5247 + { PseudoVLUXSEG7EI8_V_MF2_M1_MASK, VLUXSEG7EI8_V }, // 5248 + { PseudoVLUXSEG7EI8_V_MF2_MF2, VLUXSEG7EI8_V }, // 5249 + { PseudoVLUXSEG7EI8_V_MF2_MF2_MASK, VLUXSEG7EI8_V }, // 5250 + { PseudoVLUXSEG7EI8_V_MF4_M1, VLUXSEG7EI8_V }, // 5251 + { PseudoVLUXSEG7EI8_V_MF4_M1_MASK, VLUXSEG7EI8_V }, // 5252 + { PseudoVLUXSEG7EI8_V_MF4_MF2, VLUXSEG7EI8_V }, // 5253 + { PseudoVLUXSEG7EI8_V_MF4_MF2_MASK, VLUXSEG7EI8_V }, // 5254 + { PseudoVLUXSEG7EI8_V_MF4_MF4, VLUXSEG7EI8_V }, // 5255 + { PseudoVLUXSEG7EI8_V_MF4_MF4_MASK, VLUXSEG7EI8_V }, // 5256 + { PseudoVLUXSEG7EI8_V_MF8_M1, VLUXSEG7EI8_V }, // 5257 + { PseudoVLUXSEG7EI8_V_MF8_M1_MASK, VLUXSEG7EI8_V }, // 5258 + { PseudoVLUXSEG7EI8_V_MF8_MF2, VLUXSEG7EI8_V }, // 5259 + { PseudoVLUXSEG7EI8_V_MF8_MF2_MASK, VLUXSEG7EI8_V }, // 5260 + { PseudoVLUXSEG7EI8_V_MF8_MF4, VLUXSEG7EI8_V }, // 5261 + { PseudoVLUXSEG7EI8_V_MF8_MF4_MASK, VLUXSEG7EI8_V }, // 5262 + { PseudoVLUXSEG7EI8_V_MF8_MF8, VLUXSEG7EI8_V }, // 5263 + { PseudoVLUXSEG7EI8_V_MF8_MF8_MASK, VLUXSEG7EI8_V }, // 5264 + { PseudoVLUXSEG8EI16_V_M1_M1, VLUXSEG8EI16_V }, // 5265 + { PseudoVLUXSEG8EI16_V_M1_M1_MASK, VLUXSEG8EI16_V }, // 5266 + { PseudoVLUXSEG8EI16_V_M1_MF2, VLUXSEG8EI16_V }, // 5267 + { PseudoVLUXSEG8EI16_V_M1_MF2_MASK, VLUXSEG8EI16_V }, // 5268 + { PseudoVLUXSEG8EI16_V_M2_M1, VLUXSEG8EI16_V }, // 5269 + { PseudoVLUXSEG8EI16_V_M2_M1_MASK, VLUXSEG8EI16_V }, // 5270 + { PseudoVLUXSEG8EI16_V_MF2_M1, VLUXSEG8EI16_V }, // 5271 + { PseudoVLUXSEG8EI16_V_MF2_M1_MASK, VLUXSEG8EI16_V }, // 5272 + { PseudoVLUXSEG8EI16_V_MF2_MF2, VLUXSEG8EI16_V }, // 5273 + { PseudoVLUXSEG8EI16_V_MF2_MF2_MASK, VLUXSEG8EI16_V }, // 5274 + { PseudoVLUXSEG8EI16_V_MF2_MF4, VLUXSEG8EI16_V }, // 5275 + { PseudoVLUXSEG8EI16_V_MF2_MF4_MASK, VLUXSEG8EI16_V }, // 5276 + { PseudoVLUXSEG8EI16_V_MF4_M1, VLUXSEG8EI16_V }, // 5277 + { PseudoVLUXSEG8EI16_V_MF4_M1_MASK, VLUXSEG8EI16_V }, // 5278 + { PseudoVLUXSEG8EI16_V_MF4_MF2, VLUXSEG8EI16_V }, // 5279 + { PseudoVLUXSEG8EI16_V_MF4_MF2_MASK, VLUXSEG8EI16_V }, // 5280 + { PseudoVLUXSEG8EI16_V_MF4_MF4, VLUXSEG8EI16_V }, // 5281 + { PseudoVLUXSEG8EI16_V_MF4_MF4_MASK, VLUXSEG8EI16_V }, // 5282 + { PseudoVLUXSEG8EI16_V_MF4_MF8, VLUXSEG8EI16_V }, // 5283 + { PseudoVLUXSEG8EI16_V_MF4_MF8_MASK, VLUXSEG8EI16_V }, // 5284 + { PseudoVLUXSEG8EI32_V_M1_M1, VLUXSEG8EI32_V }, // 5285 + { PseudoVLUXSEG8EI32_V_M1_M1_MASK, VLUXSEG8EI32_V }, // 5286 + { PseudoVLUXSEG8EI32_V_M1_MF2, VLUXSEG8EI32_V }, // 5287 + { PseudoVLUXSEG8EI32_V_M1_MF2_MASK, VLUXSEG8EI32_V }, // 5288 + { PseudoVLUXSEG8EI32_V_M1_MF4, VLUXSEG8EI32_V }, // 5289 + { PseudoVLUXSEG8EI32_V_M1_MF4_MASK, VLUXSEG8EI32_V }, // 5290 + { PseudoVLUXSEG8EI32_V_M2_M1, VLUXSEG8EI32_V }, // 5291 + { PseudoVLUXSEG8EI32_V_M2_M1_MASK, VLUXSEG8EI32_V }, // 5292 + { PseudoVLUXSEG8EI32_V_M2_MF2, VLUXSEG8EI32_V }, // 5293 + { PseudoVLUXSEG8EI32_V_M2_MF2_MASK, VLUXSEG8EI32_V }, // 5294 + { PseudoVLUXSEG8EI32_V_M4_M1, VLUXSEG8EI32_V }, // 5295 + { PseudoVLUXSEG8EI32_V_M4_M1_MASK, VLUXSEG8EI32_V }, // 5296 + { PseudoVLUXSEG8EI32_V_MF2_M1, VLUXSEG8EI32_V }, // 5297 + { PseudoVLUXSEG8EI32_V_MF2_M1_MASK, VLUXSEG8EI32_V }, // 5298 + { PseudoVLUXSEG8EI32_V_MF2_MF2, VLUXSEG8EI32_V }, // 5299 + { PseudoVLUXSEG8EI32_V_MF2_MF2_MASK, VLUXSEG8EI32_V }, // 5300 + { PseudoVLUXSEG8EI32_V_MF2_MF4, VLUXSEG8EI32_V }, // 5301 + { PseudoVLUXSEG8EI32_V_MF2_MF4_MASK, VLUXSEG8EI32_V }, // 5302 + { PseudoVLUXSEG8EI32_V_MF2_MF8, VLUXSEG8EI32_V }, // 5303 + { PseudoVLUXSEG8EI32_V_MF2_MF8_MASK, VLUXSEG8EI32_V }, // 5304 + { PseudoVLUXSEG8EI64_V_M1_M1, VLUXSEG8EI64_V }, // 5305 + { PseudoVLUXSEG8EI64_V_M1_M1_MASK, VLUXSEG8EI64_V }, // 5306 + { PseudoVLUXSEG8EI64_V_M1_MF2, VLUXSEG8EI64_V }, // 5307 + { PseudoVLUXSEG8EI64_V_M1_MF2_MASK, VLUXSEG8EI64_V }, // 5308 + { PseudoVLUXSEG8EI64_V_M1_MF4, VLUXSEG8EI64_V }, // 5309 + { PseudoVLUXSEG8EI64_V_M1_MF4_MASK, VLUXSEG8EI64_V }, // 5310 + { PseudoVLUXSEG8EI64_V_M1_MF8, VLUXSEG8EI64_V }, // 5311 + { PseudoVLUXSEG8EI64_V_M1_MF8_MASK, VLUXSEG8EI64_V }, // 5312 + { PseudoVLUXSEG8EI64_V_M2_M1, VLUXSEG8EI64_V }, // 5313 + { PseudoVLUXSEG8EI64_V_M2_M1_MASK, VLUXSEG8EI64_V }, // 5314 + { PseudoVLUXSEG8EI64_V_M2_MF2, VLUXSEG8EI64_V }, // 5315 + { PseudoVLUXSEG8EI64_V_M2_MF2_MASK, VLUXSEG8EI64_V }, // 5316 + { PseudoVLUXSEG8EI64_V_M2_MF4, VLUXSEG8EI64_V }, // 5317 + { PseudoVLUXSEG8EI64_V_M2_MF4_MASK, VLUXSEG8EI64_V }, // 5318 + { PseudoVLUXSEG8EI64_V_M4_M1, VLUXSEG8EI64_V }, // 5319 + { PseudoVLUXSEG8EI64_V_M4_M1_MASK, VLUXSEG8EI64_V }, // 5320 + { PseudoVLUXSEG8EI64_V_M4_MF2, VLUXSEG8EI64_V }, // 5321 + { PseudoVLUXSEG8EI64_V_M4_MF2_MASK, VLUXSEG8EI64_V }, // 5322 + { PseudoVLUXSEG8EI64_V_M8_M1, VLUXSEG8EI64_V }, // 5323 + { PseudoVLUXSEG8EI64_V_M8_M1_MASK, VLUXSEG8EI64_V }, // 5324 + { PseudoVLUXSEG8EI8_V_M1_M1, VLUXSEG8EI8_V }, // 5325 + { PseudoVLUXSEG8EI8_V_M1_M1_MASK, VLUXSEG8EI8_V }, // 5326 + { PseudoVLUXSEG8EI8_V_MF2_M1, VLUXSEG8EI8_V }, // 5327 + { PseudoVLUXSEG8EI8_V_MF2_M1_MASK, VLUXSEG8EI8_V }, // 5328 + { PseudoVLUXSEG8EI8_V_MF2_MF2, VLUXSEG8EI8_V }, // 5329 + { PseudoVLUXSEG8EI8_V_MF2_MF2_MASK, VLUXSEG8EI8_V }, // 5330 + { PseudoVLUXSEG8EI8_V_MF4_M1, VLUXSEG8EI8_V }, // 5331 + { PseudoVLUXSEG8EI8_V_MF4_M1_MASK, VLUXSEG8EI8_V }, // 5332 + { PseudoVLUXSEG8EI8_V_MF4_MF2, VLUXSEG8EI8_V }, // 5333 + { PseudoVLUXSEG8EI8_V_MF4_MF2_MASK, VLUXSEG8EI8_V }, // 5334 + { PseudoVLUXSEG8EI8_V_MF4_MF4, VLUXSEG8EI8_V }, // 5335 + { PseudoVLUXSEG8EI8_V_MF4_MF4_MASK, VLUXSEG8EI8_V }, // 5336 + { PseudoVLUXSEG8EI8_V_MF8_M1, VLUXSEG8EI8_V }, // 5337 + { PseudoVLUXSEG8EI8_V_MF8_M1_MASK, VLUXSEG8EI8_V }, // 5338 + { PseudoVLUXSEG8EI8_V_MF8_MF2, VLUXSEG8EI8_V }, // 5339 + { PseudoVLUXSEG8EI8_V_MF8_MF2_MASK, VLUXSEG8EI8_V }, // 5340 + { PseudoVLUXSEG8EI8_V_MF8_MF4, VLUXSEG8EI8_V }, // 5341 + { PseudoVLUXSEG8EI8_V_MF8_MF4_MASK, VLUXSEG8EI8_V }, // 5342 + { PseudoVLUXSEG8EI8_V_MF8_MF8, VLUXSEG8EI8_V }, // 5343 + { PseudoVLUXSEG8EI8_V_MF8_MF8_MASK, VLUXSEG8EI8_V }, // 5344 + { PseudoVMACC_VV_M1, VMACC_VV }, // 5345 + { PseudoVMACC_VV_M1_MASK, VMACC_VV }, // 5346 + { PseudoVMACC_VV_M2, VMACC_VV }, // 5347 + { PseudoVMACC_VV_M2_MASK, VMACC_VV }, // 5348 + { PseudoVMACC_VV_M4, VMACC_VV }, // 5349 + { PseudoVMACC_VV_M4_MASK, VMACC_VV }, // 5350 + { PseudoVMACC_VV_M8, VMACC_VV }, // 5351 + { PseudoVMACC_VV_M8_MASK, VMACC_VV }, // 5352 + { PseudoVMACC_VV_MF2, VMACC_VV }, // 5353 + { PseudoVMACC_VV_MF2_MASK, VMACC_VV }, // 5354 + { PseudoVMACC_VV_MF4, VMACC_VV }, // 5355 + { PseudoVMACC_VV_MF4_MASK, VMACC_VV }, // 5356 + { PseudoVMACC_VV_MF8, VMACC_VV }, // 5357 + { PseudoVMACC_VV_MF8_MASK, VMACC_VV }, // 5358 + { PseudoVMACC_VX_M1, VMACC_VX }, // 5359 + { PseudoVMACC_VX_M1_MASK, VMACC_VX }, // 5360 + { PseudoVMACC_VX_M2, VMACC_VX }, // 5361 + { PseudoVMACC_VX_M2_MASK, VMACC_VX }, // 5362 + { PseudoVMACC_VX_M4, VMACC_VX }, // 5363 + { PseudoVMACC_VX_M4_MASK, VMACC_VX }, // 5364 + { PseudoVMACC_VX_M8, VMACC_VX }, // 5365 + { PseudoVMACC_VX_M8_MASK, VMACC_VX }, // 5366 + { PseudoVMACC_VX_MF2, VMACC_VX }, // 5367 + { PseudoVMACC_VX_MF2_MASK, VMACC_VX }, // 5368 + { PseudoVMACC_VX_MF4, VMACC_VX }, // 5369 + { PseudoVMACC_VX_MF4_MASK, VMACC_VX }, // 5370 + { PseudoVMACC_VX_MF8, VMACC_VX }, // 5371 + { PseudoVMACC_VX_MF8_MASK, VMACC_VX }, // 5372 + { PseudoVMADC_VIM_M1, VMADC_VIM }, // 5373 + { PseudoVMADC_VIM_M2, VMADC_VIM }, // 5374 + { PseudoVMADC_VIM_M4, VMADC_VIM }, // 5375 + { PseudoVMADC_VIM_M8, VMADC_VIM }, // 5376 + { PseudoVMADC_VIM_MF2, VMADC_VIM }, // 5377 + { PseudoVMADC_VIM_MF4, VMADC_VIM }, // 5378 + { PseudoVMADC_VIM_MF8, VMADC_VIM }, // 5379 + { PseudoVMADC_VI_M1, VMADC_VI }, // 5380 + { PseudoVMADC_VI_M2, VMADC_VI }, // 5381 + { PseudoVMADC_VI_M4, VMADC_VI }, // 5382 + { PseudoVMADC_VI_M8, VMADC_VI }, // 5383 + { PseudoVMADC_VI_MF2, VMADC_VI }, // 5384 + { PseudoVMADC_VI_MF4, VMADC_VI }, // 5385 + { PseudoVMADC_VI_MF8, VMADC_VI }, // 5386 + { PseudoVMADC_VVM_M1, VMADC_VVM }, // 5387 + { PseudoVMADC_VVM_M2, VMADC_VVM }, // 5388 + { PseudoVMADC_VVM_M4, VMADC_VVM }, // 5389 + { PseudoVMADC_VVM_M8, VMADC_VVM }, // 5390 + { PseudoVMADC_VVM_MF2, VMADC_VVM }, // 5391 + { PseudoVMADC_VVM_MF4, VMADC_VVM }, // 5392 + { PseudoVMADC_VVM_MF8, VMADC_VVM }, // 5393 + { PseudoVMADC_VV_M1, VMADC_VV }, // 5394 + { PseudoVMADC_VV_M2, VMADC_VV }, // 5395 + { PseudoVMADC_VV_M4, VMADC_VV }, // 5396 + { PseudoVMADC_VV_M8, VMADC_VV }, // 5397 + { PseudoVMADC_VV_MF2, VMADC_VV }, // 5398 + { PseudoVMADC_VV_MF4, VMADC_VV }, // 5399 + { PseudoVMADC_VV_MF8, VMADC_VV }, // 5400 + { PseudoVMADC_VXM_M1, VMADC_VXM }, // 5401 + { PseudoVMADC_VXM_M2, VMADC_VXM }, // 5402 + { PseudoVMADC_VXM_M4, VMADC_VXM }, // 5403 + { PseudoVMADC_VXM_M8, VMADC_VXM }, // 5404 + { PseudoVMADC_VXM_MF2, VMADC_VXM }, // 5405 + { PseudoVMADC_VXM_MF4, VMADC_VXM }, // 5406 + { PseudoVMADC_VXM_MF8, VMADC_VXM }, // 5407 + { PseudoVMADC_VX_M1, VMADC_VX }, // 5408 + { PseudoVMADC_VX_M2, VMADC_VX }, // 5409 + { PseudoVMADC_VX_M4, VMADC_VX }, // 5410 + { PseudoVMADC_VX_M8, VMADC_VX }, // 5411 + { PseudoVMADC_VX_MF2, VMADC_VX }, // 5412 + { PseudoVMADC_VX_MF4, VMADC_VX }, // 5413 + { PseudoVMADC_VX_MF8, VMADC_VX }, // 5414 + { PseudoVMADD_VV_M1, VMADD_VV }, // 5415 + { PseudoVMADD_VV_M1_MASK, VMADD_VV }, // 5416 + { PseudoVMADD_VV_M2, VMADD_VV }, // 5417 + { PseudoVMADD_VV_M2_MASK, VMADD_VV }, // 5418 + { PseudoVMADD_VV_M4, VMADD_VV }, // 5419 + { PseudoVMADD_VV_M4_MASK, VMADD_VV }, // 5420 + { PseudoVMADD_VV_M8, VMADD_VV }, // 5421 + { PseudoVMADD_VV_M8_MASK, VMADD_VV }, // 5422 + { PseudoVMADD_VV_MF2, VMADD_VV }, // 5423 + { PseudoVMADD_VV_MF2_MASK, VMADD_VV }, // 5424 + { PseudoVMADD_VV_MF4, VMADD_VV }, // 5425 + { PseudoVMADD_VV_MF4_MASK, VMADD_VV }, // 5426 + { PseudoVMADD_VV_MF8, VMADD_VV }, // 5427 + { PseudoVMADD_VV_MF8_MASK, VMADD_VV }, // 5428 + { PseudoVMADD_VX_M1, VMADD_VX }, // 5429 + { PseudoVMADD_VX_M1_MASK, VMADD_VX }, // 5430 + { PseudoVMADD_VX_M2, VMADD_VX }, // 5431 + { PseudoVMADD_VX_M2_MASK, VMADD_VX }, // 5432 + { PseudoVMADD_VX_M4, VMADD_VX }, // 5433 + { PseudoVMADD_VX_M4_MASK, VMADD_VX }, // 5434 + { PseudoVMADD_VX_M8, VMADD_VX }, // 5435 + { PseudoVMADD_VX_M8_MASK, VMADD_VX }, // 5436 + { PseudoVMADD_VX_MF2, VMADD_VX }, // 5437 + { PseudoVMADD_VX_MF2_MASK, VMADD_VX }, // 5438 + { PseudoVMADD_VX_MF4, VMADD_VX }, // 5439 + { PseudoVMADD_VX_MF4_MASK, VMADD_VX }, // 5440 + { PseudoVMADD_VX_MF8, VMADD_VX }, // 5441 + { PseudoVMADD_VX_MF8_MASK, VMADD_VX }, // 5442 + { PseudoVMANDN_MM_M1, VMANDN_MM }, // 5443 + { PseudoVMANDN_MM_M2, VMANDN_MM }, // 5444 + { PseudoVMANDN_MM_M4, VMANDN_MM }, // 5445 + { PseudoVMANDN_MM_M8, VMANDN_MM }, // 5446 + { PseudoVMANDN_MM_MF2, VMANDN_MM }, // 5447 + { PseudoVMANDN_MM_MF4, VMANDN_MM }, // 5448 + { PseudoVMANDN_MM_MF8, VMANDN_MM }, // 5449 + { PseudoVMAND_MM_M1, VMAND_MM }, // 5450 + { PseudoVMAND_MM_M2, VMAND_MM }, // 5451 + { PseudoVMAND_MM_M4, VMAND_MM }, // 5452 + { PseudoVMAND_MM_M8, VMAND_MM }, // 5453 + { PseudoVMAND_MM_MF2, VMAND_MM }, // 5454 + { PseudoVMAND_MM_MF4, VMAND_MM }, // 5455 + { PseudoVMAND_MM_MF8, VMAND_MM }, // 5456 + { PseudoVMAXU_VV_M1, VMAXU_VV }, // 5457 + { PseudoVMAXU_VV_M1_MASK, VMAXU_VV }, // 5458 + { PseudoVMAXU_VV_M2, VMAXU_VV }, // 5459 + { PseudoVMAXU_VV_M2_MASK, VMAXU_VV }, // 5460 + { PseudoVMAXU_VV_M4, VMAXU_VV }, // 5461 + { PseudoVMAXU_VV_M4_MASK, VMAXU_VV }, // 5462 + { PseudoVMAXU_VV_M8, VMAXU_VV }, // 5463 + { PseudoVMAXU_VV_M8_MASK, VMAXU_VV }, // 5464 + { PseudoVMAXU_VV_MF2, VMAXU_VV }, // 5465 + { PseudoVMAXU_VV_MF2_MASK, VMAXU_VV }, // 5466 + { PseudoVMAXU_VV_MF4, VMAXU_VV }, // 5467 + { PseudoVMAXU_VV_MF4_MASK, VMAXU_VV }, // 5468 + { PseudoVMAXU_VV_MF8, VMAXU_VV }, // 5469 + { PseudoVMAXU_VV_MF8_MASK, VMAXU_VV }, // 5470 + { PseudoVMAXU_VX_M1, VMAXU_VX }, // 5471 + { PseudoVMAXU_VX_M1_MASK, VMAXU_VX }, // 5472 + { PseudoVMAXU_VX_M2, VMAXU_VX }, // 5473 + { PseudoVMAXU_VX_M2_MASK, VMAXU_VX }, // 5474 + { PseudoVMAXU_VX_M4, VMAXU_VX }, // 5475 + { PseudoVMAXU_VX_M4_MASK, VMAXU_VX }, // 5476 + { PseudoVMAXU_VX_M8, VMAXU_VX }, // 5477 + { PseudoVMAXU_VX_M8_MASK, VMAXU_VX }, // 5478 + { PseudoVMAXU_VX_MF2, VMAXU_VX }, // 5479 + { PseudoVMAXU_VX_MF2_MASK, VMAXU_VX }, // 5480 + { PseudoVMAXU_VX_MF4, VMAXU_VX }, // 5481 + { PseudoVMAXU_VX_MF4_MASK, VMAXU_VX }, // 5482 + { PseudoVMAXU_VX_MF8, VMAXU_VX }, // 5483 + { PseudoVMAXU_VX_MF8_MASK, VMAXU_VX }, // 5484 + { PseudoVMAX_VV_M1, VMAX_VV }, // 5485 + { PseudoVMAX_VV_M1_MASK, VMAX_VV }, // 5486 + { PseudoVMAX_VV_M2, VMAX_VV }, // 5487 + { PseudoVMAX_VV_M2_MASK, VMAX_VV }, // 5488 + { PseudoVMAX_VV_M4, VMAX_VV }, // 5489 + { PseudoVMAX_VV_M4_MASK, VMAX_VV }, // 5490 + { PseudoVMAX_VV_M8, VMAX_VV }, // 5491 + { PseudoVMAX_VV_M8_MASK, VMAX_VV }, // 5492 + { PseudoVMAX_VV_MF2, VMAX_VV }, // 5493 + { PseudoVMAX_VV_MF2_MASK, VMAX_VV }, // 5494 + { PseudoVMAX_VV_MF4, VMAX_VV }, // 5495 + { PseudoVMAX_VV_MF4_MASK, VMAX_VV }, // 5496 + { PseudoVMAX_VV_MF8, VMAX_VV }, // 5497 + { PseudoVMAX_VV_MF8_MASK, VMAX_VV }, // 5498 + { PseudoVMAX_VX_M1, VMAX_VX }, // 5499 + { PseudoVMAX_VX_M1_MASK, VMAX_VX }, // 5500 + { PseudoVMAX_VX_M2, VMAX_VX }, // 5501 + { PseudoVMAX_VX_M2_MASK, VMAX_VX }, // 5502 + { PseudoVMAX_VX_M4, VMAX_VX }, // 5503 + { PseudoVMAX_VX_M4_MASK, VMAX_VX }, // 5504 + { PseudoVMAX_VX_M8, VMAX_VX }, // 5505 + { PseudoVMAX_VX_M8_MASK, VMAX_VX }, // 5506 + { PseudoVMAX_VX_MF2, VMAX_VX }, // 5507 + { PseudoVMAX_VX_MF2_MASK, VMAX_VX }, // 5508 + { PseudoVMAX_VX_MF4, VMAX_VX }, // 5509 + { PseudoVMAX_VX_MF4_MASK, VMAX_VX }, // 5510 + { PseudoVMAX_VX_MF8, VMAX_VX }, // 5511 + { PseudoVMAX_VX_MF8_MASK, VMAX_VX }, // 5512 + { PseudoVMERGE_VIM_M1, VMERGE_VIM }, // 5513 + { PseudoVMERGE_VIM_M2, VMERGE_VIM }, // 5514 + { PseudoVMERGE_VIM_M4, VMERGE_VIM }, // 5515 + { PseudoVMERGE_VIM_M8, VMERGE_VIM }, // 5516 + { PseudoVMERGE_VIM_MF2, VMERGE_VIM }, // 5517 + { PseudoVMERGE_VIM_MF4, VMERGE_VIM }, // 5518 + { PseudoVMERGE_VIM_MF8, VMERGE_VIM }, // 5519 + { PseudoVMERGE_VVM_M1, VMERGE_VVM }, // 5520 + { PseudoVMERGE_VVM_M2, VMERGE_VVM }, // 5521 + { PseudoVMERGE_VVM_M4, VMERGE_VVM }, // 5522 + { PseudoVMERGE_VVM_M8, VMERGE_VVM }, // 5523 + { PseudoVMERGE_VVM_MF2, VMERGE_VVM }, // 5524 + { PseudoVMERGE_VVM_MF4, VMERGE_VVM }, // 5525 + { PseudoVMERGE_VVM_MF8, VMERGE_VVM }, // 5526 + { PseudoVMERGE_VXM_M1, VMERGE_VXM }, // 5527 + { PseudoVMERGE_VXM_M2, VMERGE_VXM }, // 5528 + { PseudoVMERGE_VXM_M4, VMERGE_VXM }, // 5529 + { PseudoVMERGE_VXM_M8, VMERGE_VXM }, // 5530 + { PseudoVMERGE_VXM_MF2, VMERGE_VXM }, // 5531 + { PseudoVMERGE_VXM_MF4, VMERGE_VXM }, // 5532 + { PseudoVMERGE_VXM_MF8, VMERGE_VXM }, // 5533 + { PseudoVMFEQ_VFPR16_M1, VMFEQ_VF }, // 5534 + { PseudoVMFEQ_VFPR16_M1_MASK, VMFEQ_VF }, // 5535 + { PseudoVMFEQ_VFPR16_M2, VMFEQ_VF }, // 5536 + { PseudoVMFEQ_VFPR16_M2_MASK, VMFEQ_VF }, // 5537 + { PseudoVMFEQ_VFPR16_M4, VMFEQ_VF }, // 5538 + { PseudoVMFEQ_VFPR16_M4_MASK, VMFEQ_VF }, // 5539 + { PseudoVMFEQ_VFPR16_M8, VMFEQ_VF }, // 5540 + { PseudoVMFEQ_VFPR16_M8_MASK, VMFEQ_VF }, // 5541 + { PseudoVMFEQ_VFPR16_MF2, VMFEQ_VF }, // 5542 + { PseudoVMFEQ_VFPR16_MF2_MASK, VMFEQ_VF }, // 5543 + { PseudoVMFEQ_VFPR16_MF4, VMFEQ_VF }, // 5544 + { PseudoVMFEQ_VFPR16_MF4_MASK, VMFEQ_VF }, // 5545 + { PseudoVMFEQ_VFPR32_M1, VMFEQ_VF }, // 5546 + { PseudoVMFEQ_VFPR32_M1_MASK, VMFEQ_VF }, // 5547 + { PseudoVMFEQ_VFPR32_M2, VMFEQ_VF }, // 5548 + { PseudoVMFEQ_VFPR32_M2_MASK, VMFEQ_VF }, // 5549 + { PseudoVMFEQ_VFPR32_M4, VMFEQ_VF }, // 5550 + { PseudoVMFEQ_VFPR32_M4_MASK, VMFEQ_VF }, // 5551 + { PseudoVMFEQ_VFPR32_M8, VMFEQ_VF }, // 5552 + { PseudoVMFEQ_VFPR32_M8_MASK, VMFEQ_VF }, // 5553 + { PseudoVMFEQ_VFPR32_MF2, VMFEQ_VF }, // 5554 + { PseudoVMFEQ_VFPR32_MF2_MASK, VMFEQ_VF }, // 5555 + { PseudoVMFEQ_VFPR64_M1, VMFEQ_VF }, // 5556 + { PseudoVMFEQ_VFPR64_M1_MASK, VMFEQ_VF }, // 5557 + { PseudoVMFEQ_VFPR64_M2, VMFEQ_VF }, // 5558 + { PseudoVMFEQ_VFPR64_M2_MASK, VMFEQ_VF }, // 5559 + { PseudoVMFEQ_VFPR64_M4, VMFEQ_VF }, // 5560 + { PseudoVMFEQ_VFPR64_M4_MASK, VMFEQ_VF }, // 5561 + { PseudoVMFEQ_VFPR64_M8, VMFEQ_VF }, // 5562 + { PseudoVMFEQ_VFPR64_M8_MASK, VMFEQ_VF }, // 5563 + { PseudoVMFEQ_VV_M1, VMFEQ_VV }, // 5564 + { PseudoVMFEQ_VV_M1_MASK, VMFEQ_VV }, // 5565 + { PseudoVMFEQ_VV_M2, VMFEQ_VV }, // 5566 + { PseudoVMFEQ_VV_M2_MASK, VMFEQ_VV }, // 5567 + { PseudoVMFEQ_VV_M4, VMFEQ_VV }, // 5568 + { PseudoVMFEQ_VV_M4_MASK, VMFEQ_VV }, // 5569 + { PseudoVMFEQ_VV_M8, VMFEQ_VV }, // 5570 + { PseudoVMFEQ_VV_M8_MASK, VMFEQ_VV }, // 5571 + { PseudoVMFEQ_VV_MF2, VMFEQ_VV }, // 5572 + { PseudoVMFEQ_VV_MF2_MASK, VMFEQ_VV }, // 5573 + { PseudoVMFEQ_VV_MF4, VMFEQ_VV }, // 5574 + { PseudoVMFEQ_VV_MF4_MASK, VMFEQ_VV }, // 5575 + { PseudoVMFGE_VFPR16_M1, VMFGE_VF }, // 5576 + { PseudoVMFGE_VFPR16_M1_MASK, VMFGE_VF }, // 5577 + { PseudoVMFGE_VFPR16_M2, VMFGE_VF }, // 5578 + { PseudoVMFGE_VFPR16_M2_MASK, VMFGE_VF }, // 5579 + { PseudoVMFGE_VFPR16_M4, VMFGE_VF }, // 5580 + { PseudoVMFGE_VFPR16_M4_MASK, VMFGE_VF }, // 5581 + { PseudoVMFGE_VFPR16_M8, VMFGE_VF }, // 5582 + { PseudoVMFGE_VFPR16_M8_MASK, VMFGE_VF }, // 5583 + { PseudoVMFGE_VFPR16_MF2, VMFGE_VF }, // 5584 + { PseudoVMFGE_VFPR16_MF2_MASK, VMFGE_VF }, // 5585 + { PseudoVMFGE_VFPR16_MF4, VMFGE_VF }, // 5586 + { PseudoVMFGE_VFPR16_MF4_MASK, VMFGE_VF }, // 5587 + { PseudoVMFGE_VFPR32_M1, VMFGE_VF }, // 5588 + { PseudoVMFGE_VFPR32_M1_MASK, VMFGE_VF }, // 5589 + { PseudoVMFGE_VFPR32_M2, VMFGE_VF }, // 5590 + { PseudoVMFGE_VFPR32_M2_MASK, VMFGE_VF }, // 5591 + { PseudoVMFGE_VFPR32_M4, VMFGE_VF }, // 5592 + { PseudoVMFGE_VFPR32_M4_MASK, VMFGE_VF }, // 5593 + { PseudoVMFGE_VFPR32_M8, VMFGE_VF }, // 5594 + { PseudoVMFGE_VFPR32_M8_MASK, VMFGE_VF }, // 5595 + { PseudoVMFGE_VFPR32_MF2, VMFGE_VF }, // 5596 + { PseudoVMFGE_VFPR32_MF2_MASK, VMFGE_VF }, // 5597 + { PseudoVMFGE_VFPR64_M1, VMFGE_VF }, // 5598 + { PseudoVMFGE_VFPR64_M1_MASK, VMFGE_VF }, // 5599 + { PseudoVMFGE_VFPR64_M2, VMFGE_VF }, // 5600 + { PseudoVMFGE_VFPR64_M2_MASK, VMFGE_VF }, // 5601 + { PseudoVMFGE_VFPR64_M4, VMFGE_VF }, // 5602 + { PseudoVMFGE_VFPR64_M4_MASK, VMFGE_VF }, // 5603 + { PseudoVMFGE_VFPR64_M8, VMFGE_VF }, // 5604 + { PseudoVMFGE_VFPR64_M8_MASK, VMFGE_VF }, // 5605 + { PseudoVMFGT_VFPR16_M1, VMFGT_VF }, // 5606 + { PseudoVMFGT_VFPR16_M1_MASK, VMFGT_VF }, // 5607 + { PseudoVMFGT_VFPR16_M2, VMFGT_VF }, // 5608 + { PseudoVMFGT_VFPR16_M2_MASK, VMFGT_VF }, // 5609 + { PseudoVMFGT_VFPR16_M4, VMFGT_VF }, // 5610 + { PseudoVMFGT_VFPR16_M4_MASK, VMFGT_VF }, // 5611 + { PseudoVMFGT_VFPR16_M8, VMFGT_VF }, // 5612 + { PseudoVMFGT_VFPR16_M8_MASK, VMFGT_VF }, // 5613 + { PseudoVMFGT_VFPR16_MF2, VMFGT_VF }, // 5614 + { PseudoVMFGT_VFPR16_MF2_MASK, VMFGT_VF }, // 5615 + { PseudoVMFGT_VFPR16_MF4, VMFGT_VF }, // 5616 + { PseudoVMFGT_VFPR16_MF4_MASK, VMFGT_VF }, // 5617 + { PseudoVMFGT_VFPR32_M1, VMFGT_VF }, // 5618 + { PseudoVMFGT_VFPR32_M1_MASK, VMFGT_VF }, // 5619 + { PseudoVMFGT_VFPR32_M2, VMFGT_VF }, // 5620 + { PseudoVMFGT_VFPR32_M2_MASK, VMFGT_VF }, // 5621 + { PseudoVMFGT_VFPR32_M4, VMFGT_VF }, // 5622 + { PseudoVMFGT_VFPR32_M4_MASK, VMFGT_VF }, // 5623 + { PseudoVMFGT_VFPR32_M8, VMFGT_VF }, // 5624 + { PseudoVMFGT_VFPR32_M8_MASK, VMFGT_VF }, // 5625 + { PseudoVMFGT_VFPR32_MF2, VMFGT_VF }, // 5626 + { PseudoVMFGT_VFPR32_MF2_MASK, VMFGT_VF }, // 5627 + { PseudoVMFGT_VFPR64_M1, VMFGT_VF }, // 5628 + { PseudoVMFGT_VFPR64_M1_MASK, VMFGT_VF }, // 5629 + { PseudoVMFGT_VFPR64_M2, VMFGT_VF }, // 5630 + { PseudoVMFGT_VFPR64_M2_MASK, VMFGT_VF }, // 5631 + { PseudoVMFGT_VFPR64_M4, VMFGT_VF }, // 5632 + { PseudoVMFGT_VFPR64_M4_MASK, VMFGT_VF }, // 5633 + { PseudoVMFGT_VFPR64_M8, VMFGT_VF }, // 5634 + { PseudoVMFGT_VFPR64_M8_MASK, VMFGT_VF }, // 5635 + { PseudoVMFLE_VFPR16_M1, VMFLE_VF }, // 5636 + { PseudoVMFLE_VFPR16_M1_MASK, VMFLE_VF }, // 5637 + { PseudoVMFLE_VFPR16_M2, VMFLE_VF }, // 5638 + { PseudoVMFLE_VFPR16_M2_MASK, VMFLE_VF }, // 5639 + { PseudoVMFLE_VFPR16_M4, VMFLE_VF }, // 5640 + { PseudoVMFLE_VFPR16_M4_MASK, VMFLE_VF }, // 5641 + { PseudoVMFLE_VFPR16_M8, VMFLE_VF }, // 5642 + { PseudoVMFLE_VFPR16_M8_MASK, VMFLE_VF }, // 5643 + { PseudoVMFLE_VFPR16_MF2, VMFLE_VF }, // 5644 + { PseudoVMFLE_VFPR16_MF2_MASK, VMFLE_VF }, // 5645 + { PseudoVMFLE_VFPR16_MF4, VMFLE_VF }, // 5646 + { PseudoVMFLE_VFPR16_MF4_MASK, VMFLE_VF }, // 5647 + { PseudoVMFLE_VFPR32_M1, VMFLE_VF }, // 5648 + { PseudoVMFLE_VFPR32_M1_MASK, VMFLE_VF }, // 5649 + { PseudoVMFLE_VFPR32_M2, VMFLE_VF }, // 5650 + { PseudoVMFLE_VFPR32_M2_MASK, VMFLE_VF }, // 5651 + { PseudoVMFLE_VFPR32_M4, VMFLE_VF }, // 5652 + { PseudoVMFLE_VFPR32_M4_MASK, VMFLE_VF }, // 5653 + { PseudoVMFLE_VFPR32_M8, VMFLE_VF }, // 5654 + { PseudoVMFLE_VFPR32_M8_MASK, VMFLE_VF }, // 5655 + { PseudoVMFLE_VFPR32_MF2, VMFLE_VF }, // 5656 + { PseudoVMFLE_VFPR32_MF2_MASK, VMFLE_VF }, // 5657 + { PseudoVMFLE_VFPR64_M1, VMFLE_VF }, // 5658 + { PseudoVMFLE_VFPR64_M1_MASK, VMFLE_VF }, // 5659 + { PseudoVMFLE_VFPR64_M2, VMFLE_VF }, // 5660 + { PseudoVMFLE_VFPR64_M2_MASK, VMFLE_VF }, // 5661 + { PseudoVMFLE_VFPR64_M4, VMFLE_VF }, // 5662 + { PseudoVMFLE_VFPR64_M4_MASK, VMFLE_VF }, // 5663 + { PseudoVMFLE_VFPR64_M8, VMFLE_VF }, // 5664 + { PseudoVMFLE_VFPR64_M8_MASK, VMFLE_VF }, // 5665 + { PseudoVMFLE_VV_M1, VMFLE_VV }, // 5666 + { PseudoVMFLE_VV_M1_MASK, VMFLE_VV }, // 5667 + { PseudoVMFLE_VV_M2, VMFLE_VV }, // 5668 + { PseudoVMFLE_VV_M2_MASK, VMFLE_VV }, // 5669 + { PseudoVMFLE_VV_M4, VMFLE_VV }, // 5670 + { PseudoVMFLE_VV_M4_MASK, VMFLE_VV }, // 5671 + { PseudoVMFLE_VV_M8, VMFLE_VV }, // 5672 + { PseudoVMFLE_VV_M8_MASK, VMFLE_VV }, // 5673 + { PseudoVMFLE_VV_MF2, VMFLE_VV }, // 5674 + { PseudoVMFLE_VV_MF2_MASK, VMFLE_VV }, // 5675 + { PseudoVMFLE_VV_MF4, VMFLE_VV }, // 5676 + { PseudoVMFLE_VV_MF4_MASK, VMFLE_VV }, // 5677 + { PseudoVMFLT_VFPR16_M1, VMFLT_VF }, // 5678 + { PseudoVMFLT_VFPR16_M1_MASK, VMFLT_VF }, // 5679 + { PseudoVMFLT_VFPR16_M2, VMFLT_VF }, // 5680 + { PseudoVMFLT_VFPR16_M2_MASK, VMFLT_VF }, // 5681 + { PseudoVMFLT_VFPR16_M4, VMFLT_VF }, // 5682 + { PseudoVMFLT_VFPR16_M4_MASK, VMFLT_VF }, // 5683 + { PseudoVMFLT_VFPR16_M8, VMFLT_VF }, // 5684 + { PseudoVMFLT_VFPR16_M8_MASK, VMFLT_VF }, // 5685 + { PseudoVMFLT_VFPR16_MF2, VMFLT_VF }, // 5686 + { PseudoVMFLT_VFPR16_MF2_MASK, VMFLT_VF }, // 5687 + { PseudoVMFLT_VFPR16_MF4, VMFLT_VF }, // 5688 + { PseudoVMFLT_VFPR16_MF4_MASK, VMFLT_VF }, // 5689 + { PseudoVMFLT_VFPR32_M1, VMFLT_VF }, // 5690 + { PseudoVMFLT_VFPR32_M1_MASK, VMFLT_VF }, // 5691 + { PseudoVMFLT_VFPR32_M2, VMFLT_VF }, // 5692 + { PseudoVMFLT_VFPR32_M2_MASK, VMFLT_VF }, // 5693 + { PseudoVMFLT_VFPR32_M4, VMFLT_VF }, // 5694 + { PseudoVMFLT_VFPR32_M4_MASK, VMFLT_VF }, // 5695 + { PseudoVMFLT_VFPR32_M8, VMFLT_VF }, // 5696 + { PseudoVMFLT_VFPR32_M8_MASK, VMFLT_VF }, // 5697 + { PseudoVMFLT_VFPR32_MF2, VMFLT_VF }, // 5698 + { PseudoVMFLT_VFPR32_MF2_MASK, VMFLT_VF }, // 5699 + { PseudoVMFLT_VFPR64_M1, VMFLT_VF }, // 5700 + { PseudoVMFLT_VFPR64_M1_MASK, VMFLT_VF }, // 5701 + { PseudoVMFLT_VFPR64_M2, VMFLT_VF }, // 5702 + { PseudoVMFLT_VFPR64_M2_MASK, VMFLT_VF }, // 5703 + { PseudoVMFLT_VFPR64_M4, VMFLT_VF }, // 5704 + { PseudoVMFLT_VFPR64_M4_MASK, VMFLT_VF }, // 5705 + { PseudoVMFLT_VFPR64_M8, VMFLT_VF }, // 5706 + { PseudoVMFLT_VFPR64_M8_MASK, VMFLT_VF }, // 5707 + { PseudoVMFLT_VV_M1, VMFLT_VV }, // 5708 + { PseudoVMFLT_VV_M1_MASK, VMFLT_VV }, // 5709 + { PseudoVMFLT_VV_M2, VMFLT_VV }, // 5710 + { PseudoVMFLT_VV_M2_MASK, VMFLT_VV }, // 5711 + { PseudoVMFLT_VV_M4, VMFLT_VV }, // 5712 + { PseudoVMFLT_VV_M4_MASK, VMFLT_VV }, // 5713 + { PseudoVMFLT_VV_M8, VMFLT_VV }, // 5714 + { PseudoVMFLT_VV_M8_MASK, VMFLT_VV }, // 5715 + { PseudoVMFLT_VV_MF2, VMFLT_VV }, // 5716 + { PseudoVMFLT_VV_MF2_MASK, VMFLT_VV }, // 5717 + { PseudoVMFLT_VV_MF4, VMFLT_VV }, // 5718 + { PseudoVMFLT_VV_MF4_MASK, VMFLT_VV }, // 5719 + { PseudoVMFNE_VFPR16_M1, VMFNE_VF }, // 5720 + { PseudoVMFNE_VFPR16_M1_MASK, VMFNE_VF }, // 5721 + { PseudoVMFNE_VFPR16_M2, VMFNE_VF }, // 5722 + { PseudoVMFNE_VFPR16_M2_MASK, VMFNE_VF }, // 5723 + { PseudoVMFNE_VFPR16_M4, VMFNE_VF }, // 5724 + { PseudoVMFNE_VFPR16_M4_MASK, VMFNE_VF }, // 5725 + { PseudoVMFNE_VFPR16_M8, VMFNE_VF }, // 5726 + { PseudoVMFNE_VFPR16_M8_MASK, VMFNE_VF }, // 5727 + { PseudoVMFNE_VFPR16_MF2, VMFNE_VF }, // 5728 + { PseudoVMFNE_VFPR16_MF2_MASK, VMFNE_VF }, // 5729 + { PseudoVMFNE_VFPR16_MF4, VMFNE_VF }, // 5730 + { PseudoVMFNE_VFPR16_MF4_MASK, VMFNE_VF }, // 5731 + { PseudoVMFNE_VFPR32_M1, VMFNE_VF }, // 5732 + { PseudoVMFNE_VFPR32_M1_MASK, VMFNE_VF }, // 5733 + { PseudoVMFNE_VFPR32_M2, VMFNE_VF }, // 5734 + { PseudoVMFNE_VFPR32_M2_MASK, VMFNE_VF }, // 5735 + { PseudoVMFNE_VFPR32_M4, VMFNE_VF }, // 5736 + { PseudoVMFNE_VFPR32_M4_MASK, VMFNE_VF }, // 5737 + { PseudoVMFNE_VFPR32_M8, VMFNE_VF }, // 5738 + { PseudoVMFNE_VFPR32_M8_MASK, VMFNE_VF }, // 5739 + { PseudoVMFNE_VFPR32_MF2, VMFNE_VF }, // 5740 + { PseudoVMFNE_VFPR32_MF2_MASK, VMFNE_VF }, // 5741 + { PseudoVMFNE_VFPR64_M1, VMFNE_VF }, // 5742 + { PseudoVMFNE_VFPR64_M1_MASK, VMFNE_VF }, // 5743 + { PseudoVMFNE_VFPR64_M2, VMFNE_VF }, // 5744 + { PseudoVMFNE_VFPR64_M2_MASK, VMFNE_VF }, // 5745 + { PseudoVMFNE_VFPR64_M4, VMFNE_VF }, // 5746 + { PseudoVMFNE_VFPR64_M4_MASK, VMFNE_VF }, // 5747 + { PseudoVMFNE_VFPR64_M8, VMFNE_VF }, // 5748 + { PseudoVMFNE_VFPR64_M8_MASK, VMFNE_VF }, // 5749 + { PseudoVMFNE_VV_M1, VMFNE_VV }, // 5750 + { PseudoVMFNE_VV_M1_MASK, VMFNE_VV }, // 5751 + { PseudoVMFNE_VV_M2, VMFNE_VV }, // 5752 + { PseudoVMFNE_VV_M2_MASK, VMFNE_VV }, // 5753 + { PseudoVMFNE_VV_M4, VMFNE_VV }, // 5754 + { PseudoVMFNE_VV_M4_MASK, VMFNE_VV }, // 5755 + { PseudoVMFNE_VV_M8, VMFNE_VV }, // 5756 + { PseudoVMFNE_VV_M8_MASK, VMFNE_VV }, // 5757 + { PseudoVMFNE_VV_MF2, VMFNE_VV }, // 5758 + { PseudoVMFNE_VV_MF2_MASK, VMFNE_VV }, // 5759 + { PseudoVMFNE_VV_MF4, VMFNE_VV }, // 5760 + { PseudoVMFNE_VV_MF4_MASK, VMFNE_VV }, // 5761 + { PseudoVMINU_VV_M1, VMINU_VV }, // 5762 + { PseudoVMINU_VV_M1_MASK, VMINU_VV }, // 5763 + { PseudoVMINU_VV_M2, VMINU_VV }, // 5764 + { PseudoVMINU_VV_M2_MASK, VMINU_VV }, // 5765 + { PseudoVMINU_VV_M4, VMINU_VV }, // 5766 + { PseudoVMINU_VV_M4_MASK, VMINU_VV }, // 5767 + { PseudoVMINU_VV_M8, VMINU_VV }, // 5768 + { PseudoVMINU_VV_M8_MASK, VMINU_VV }, // 5769 + { PseudoVMINU_VV_MF2, VMINU_VV }, // 5770 + { PseudoVMINU_VV_MF2_MASK, VMINU_VV }, // 5771 + { PseudoVMINU_VV_MF4, VMINU_VV }, // 5772 + { PseudoVMINU_VV_MF4_MASK, VMINU_VV }, // 5773 + { PseudoVMINU_VV_MF8, VMINU_VV }, // 5774 + { PseudoVMINU_VV_MF8_MASK, VMINU_VV }, // 5775 + { PseudoVMINU_VX_M1, VMINU_VX }, // 5776 + { PseudoVMINU_VX_M1_MASK, VMINU_VX }, // 5777 + { PseudoVMINU_VX_M2, VMINU_VX }, // 5778 + { PseudoVMINU_VX_M2_MASK, VMINU_VX }, // 5779 + { PseudoVMINU_VX_M4, VMINU_VX }, // 5780 + { PseudoVMINU_VX_M4_MASK, VMINU_VX }, // 5781 + { PseudoVMINU_VX_M8, VMINU_VX }, // 5782 + { PseudoVMINU_VX_M8_MASK, VMINU_VX }, // 5783 + { PseudoVMINU_VX_MF2, VMINU_VX }, // 5784 + { PseudoVMINU_VX_MF2_MASK, VMINU_VX }, // 5785 + { PseudoVMINU_VX_MF4, VMINU_VX }, // 5786 + { PseudoVMINU_VX_MF4_MASK, VMINU_VX }, // 5787 + { PseudoVMINU_VX_MF8, VMINU_VX }, // 5788 + { PseudoVMINU_VX_MF8_MASK, VMINU_VX }, // 5789 + { PseudoVMIN_VV_M1, VMIN_VV }, // 5790 + { PseudoVMIN_VV_M1_MASK, VMIN_VV }, // 5791 + { PseudoVMIN_VV_M2, VMIN_VV }, // 5792 + { PseudoVMIN_VV_M2_MASK, VMIN_VV }, // 5793 + { PseudoVMIN_VV_M4, VMIN_VV }, // 5794 + { PseudoVMIN_VV_M4_MASK, VMIN_VV }, // 5795 + { PseudoVMIN_VV_M8, VMIN_VV }, // 5796 + { PseudoVMIN_VV_M8_MASK, VMIN_VV }, // 5797 + { PseudoVMIN_VV_MF2, VMIN_VV }, // 5798 + { PseudoVMIN_VV_MF2_MASK, VMIN_VV }, // 5799 + { PseudoVMIN_VV_MF4, VMIN_VV }, // 5800 + { PseudoVMIN_VV_MF4_MASK, VMIN_VV }, // 5801 + { PseudoVMIN_VV_MF8, VMIN_VV }, // 5802 + { PseudoVMIN_VV_MF8_MASK, VMIN_VV }, // 5803 + { PseudoVMIN_VX_M1, VMIN_VX }, // 5804 + { PseudoVMIN_VX_M1_MASK, VMIN_VX }, // 5805 + { PseudoVMIN_VX_M2, VMIN_VX }, // 5806 + { PseudoVMIN_VX_M2_MASK, VMIN_VX }, // 5807 + { PseudoVMIN_VX_M4, VMIN_VX }, // 5808 + { PseudoVMIN_VX_M4_MASK, VMIN_VX }, // 5809 + { PseudoVMIN_VX_M8, VMIN_VX }, // 5810 + { PseudoVMIN_VX_M8_MASK, VMIN_VX }, // 5811 + { PseudoVMIN_VX_MF2, VMIN_VX }, // 5812 + { PseudoVMIN_VX_MF2_MASK, VMIN_VX }, // 5813 + { PseudoVMIN_VX_MF4, VMIN_VX }, // 5814 + { PseudoVMIN_VX_MF4_MASK, VMIN_VX }, // 5815 + { PseudoVMIN_VX_MF8, VMIN_VX }, // 5816 + { PseudoVMIN_VX_MF8_MASK, VMIN_VX }, // 5817 + { PseudoVMNAND_MM_M1, VMNAND_MM }, // 5818 + { PseudoVMNAND_MM_M2, VMNAND_MM }, // 5819 + { PseudoVMNAND_MM_M4, VMNAND_MM }, // 5820 + { PseudoVMNAND_MM_M8, VMNAND_MM }, // 5821 + { PseudoVMNAND_MM_MF2, VMNAND_MM }, // 5822 + { PseudoVMNAND_MM_MF4, VMNAND_MM }, // 5823 + { PseudoVMNAND_MM_MF8, VMNAND_MM }, // 5824 + { PseudoVMNOR_MM_M1, VMNOR_MM }, // 5825 + { PseudoVMNOR_MM_M2, VMNOR_MM }, // 5826 + { PseudoVMNOR_MM_M4, VMNOR_MM }, // 5827 + { PseudoVMNOR_MM_M8, VMNOR_MM }, // 5828 + { PseudoVMNOR_MM_MF2, VMNOR_MM }, // 5829 + { PseudoVMNOR_MM_MF4, VMNOR_MM }, // 5830 + { PseudoVMNOR_MM_MF8, VMNOR_MM }, // 5831 + { PseudoVMORN_MM_M1, VMORN_MM }, // 5832 + { PseudoVMORN_MM_M2, VMORN_MM }, // 5833 + { PseudoVMORN_MM_M4, VMORN_MM }, // 5834 + { PseudoVMORN_MM_M8, VMORN_MM }, // 5835 + { PseudoVMORN_MM_MF2, VMORN_MM }, // 5836 + { PseudoVMORN_MM_MF4, VMORN_MM }, // 5837 + { PseudoVMORN_MM_MF8, VMORN_MM }, // 5838 + { PseudoVMOR_MM_M1, VMOR_MM }, // 5839 + { PseudoVMOR_MM_M2, VMOR_MM }, // 5840 + { PseudoVMOR_MM_M4, VMOR_MM }, // 5841 + { PseudoVMOR_MM_M8, VMOR_MM }, // 5842 + { PseudoVMOR_MM_MF2, VMOR_MM }, // 5843 + { PseudoVMOR_MM_MF4, VMOR_MM }, // 5844 + { PseudoVMOR_MM_MF8, VMOR_MM }, // 5845 + { PseudoVMSBC_VVM_M1, VMSBC_VVM }, // 5846 + { PseudoVMSBC_VVM_M2, VMSBC_VVM }, // 5847 + { PseudoVMSBC_VVM_M4, VMSBC_VVM }, // 5848 + { PseudoVMSBC_VVM_M8, VMSBC_VVM }, // 5849 + { PseudoVMSBC_VVM_MF2, VMSBC_VVM }, // 5850 + { PseudoVMSBC_VVM_MF4, VMSBC_VVM }, // 5851 + { PseudoVMSBC_VVM_MF8, VMSBC_VVM }, // 5852 + { PseudoVMSBC_VV_M1, VMSBC_VV }, // 5853 + { PseudoVMSBC_VV_M2, VMSBC_VV }, // 5854 + { PseudoVMSBC_VV_M4, VMSBC_VV }, // 5855 + { PseudoVMSBC_VV_M8, VMSBC_VV }, // 5856 + { PseudoVMSBC_VV_MF2, VMSBC_VV }, // 5857 + { PseudoVMSBC_VV_MF4, VMSBC_VV }, // 5858 + { PseudoVMSBC_VV_MF8, VMSBC_VV }, // 5859 + { PseudoVMSBC_VXM_M1, VMSBC_VXM }, // 5860 + { PseudoVMSBC_VXM_M2, VMSBC_VXM }, // 5861 + { PseudoVMSBC_VXM_M4, VMSBC_VXM }, // 5862 + { PseudoVMSBC_VXM_M8, VMSBC_VXM }, // 5863 + { PseudoVMSBC_VXM_MF2, VMSBC_VXM }, // 5864 + { PseudoVMSBC_VXM_MF4, VMSBC_VXM }, // 5865 + { PseudoVMSBC_VXM_MF8, VMSBC_VXM }, // 5866 + { PseudoVMSBC_VX_M1, VMSBC_VX }, // 5867 + { PseudoVMSBC_VX_M2, VMSBC_VX }, // 5868 + { PseudoVMSBC_VX_M4, VMSBC_VX }, // 5869 + { PseudoVMSBC_VX_M8, VMSBC_VX }, // 5870 + { PseudoVMSBC_VX_MF2, VMSBC_VX }, // 5871 + { PseudoVMSBC_VX_MF4, VMSBC_VX }, // 5872 + { PseudoVMSBC_VX_MF8, VMSBC_VX }, // 5873 + { PseudoVMSBF_M_B1, VMSBF_M }, // 5874 + { PseudoVMSBF_M_B16, VMSBF_M }, // 5875 + { PseudoVMSBF_M_B16_MASK, VMSBF_M }, // 5876 + { PseudoVMSBF_M_B1_MASK, VMSBF_M }, // 5877 + { PseudoVMSBF_M_B2, VMSBF_M }, // 5878 + { PseudoVMSBF_M_B2_MASK, VMSBF_M }, // 5879 + { PseudoVMSBF_M_B32, VMSBF_M }, // 5880 + { PseudoVMSBF_M_B32_MASK, VMSBF_M }, // 5881 + { PseudoVMSBF_M_B4, VMSBF_M }, // 5882 + { PseudoVMSBF_M_B4_MASK, VMSBF_M }, // 5883 + { PseudoVMSBF_M_B64, VMSBF_M }, // 5884 + { PseudoVMSBF_M_B64_MASK, VMSBF_M }, // 5885 + { PseudoVMSBF_M_B8, VMSBF_M }, // 5886 + { PseudoVMSBF_M_B8_MASK, VMSBF_M }, // 5887 + { PseudoVMSEQ_VI_M1, VMSEQ_VI }, // 5888 + { PseudoVMSEQ_VI_M1_MASK, VMSEQ_VI }, // 5889 + { PseudoVMSEQ_VI_M2, VMSEQ_VI }, // 5890 + { PseudoVMSEQ_VI_M2_MASK, VMSEQ_VI }, // 5891 + { PseudoVMSEQ_VI_M4, VMSEQ_VI }, // 5892 + { PseudoVMSEQ_VI_M4_MASK, VMSEQ_VI }, // 5893 + { PseudoVMSEQ_VI_M8, VMSEQ_VI }, // 5894 + { PseudoVMSEQ_VI_M8_MASK, VMSEQ_VI }, // 5895 + { PseudoVMSEQ_VI_MF2, VMSEQ_VI }, // 5896 + { PseudoVMSEQ_VI_MF2_MASK, VMSEQ_VI }, // 5897 + { PseudoVMSEQ_VI_MF4, VMSEQ_VI }, // 5898 + { PseudoVMSEQ_VI_MF4_MASK, VMSEQ_VI }, // 5899 + { PseudoVMSEQ_VI_MF8, VMSEQ_VI }, // 5900 + { PseudoVMSEQ_VI_MF8_MASK, VMSEQ_VI }, // 5901 + { PseudoVMSEQ_VV_M1, VMSEQ_VV }, // 5902 + { PseudoVMSEQ_VV_M1_MASK, VMSEQ_VV }, // 5903 + { PseudoVMSEQ_VV_M2, VMSEQ_VV }, // 5904 + { PseudoVMSEQ_VV_M2_MASK, VMSEQ_VV }, // 5905 + { PseudoVMSEQ_VV_M4, VMSEQ_VV }, // 5906 + { PseudoVMSEQ_VV_M4_MASK, VMSEQ_VV }, // 5907 + { PseudoVMSEQ_VV_M8, VMSEQ_VV }, // 5908 + { PseudoVMSEQ_VV_M8_MASK, VMSEQ_VV }, // 5909 + { PseudoVMSEQ_VV_MF2, VMSEQ_VV }, // 5910 + { PseudoVMSEQ_VV_MF2_MASK, VMSEQ_VV }, // 5911 + { PseudoVMSEQ_VV_MF4, VMSEQ_VV }, // 5912 + { PseudoVMSEQ_VV_MF4_MASK, VMSEQ_VV }, // 5913 + { PseudoVMSEQ_VV_MF8, VMSEQ_VV }, // 5914 + { PseudoVMSEQ_VV_MF8_MASK, VMSEQ_VV }, // 5915 + { PseudoVMSEQ_VX_M1, VMSEQ_VX }, // 5916 + { PseudoVMSEQ_VX_M1_MASK, VMSEQ_VX }, // 5917 + { PseudoVMSEQ_VX_M2, VMSEQ_VX }, // 5918 + { PseudoVMSEQ_VX_M2_MASK, VMSEQ_VX }, // 5919 + { PseudoVMSEQ_VX_M4, VMSEQ_VX }, // 5920 + { PseudoVMSEQ_VX_M4_MASK, VMSEQ_VX }, // 5921 + { PseudoVMSEQ_VX_M8, VMSEQ_VX }, // 5922 + { PseudoVMSEQ_VX_M8_MASK, VMSEQ_VX }, // 5923 + { PseudoVMSEQ_VX_MF2, VMSEQ_VX }, // 5924 + { PseudoVMSEQ_VX_MF2_MASK, VMSEQ_VX }, // 5925 + { PseudoVMSEQ_VX_MF4, VMSEQ_VX }, // 5926 + { PseudoVMSEQ_VX_MF4_MASK, VMSEQ_VX }, // 5927 + { PseudoVMSEQ_VX_MF8, VMSEQ_VX }, // 5928 + { PseudoVMSEQ_VX_MF8_MASK, VMSEQ_VX }, // 5929 + { PseudoVMSGTU_VI_M1, VMSGTU_VI }, // 5930 + { PseudoVMSGTU_VI_M1_MASK, VMSGTU_VI }, // 5931 + { PseudoVMSGTU_VI_M2, VMSGTU_VI }, // 5932 + { PseudoVMSGTU_VI_M2_MASK, VMSGTU_VI }, // 5933 + { PseudoVMSGTU_VI_M4, VMSGTU_VI }, // 5934 + { PseudoVMSGTU_VI_M4_MASK, VMSGTU_VI }, // 5935 + { PseudoVMSGTU_VI_M8, VMSGTU_VI }, // 5936 + { PseudoVMSGTU_VI_M8_MASK, VMSGTU_VI }, // 5937 + { PseudoVMSGTU_VI_MF2, VMSGTU_VI }, // 5938 + { PseudoVMSGTU_VI_MF2_MASK, VMSGTU_VI }, // 5939 + { PseudoVMSGTU_VI_MF4, VMSGTU_VI }, // 5940 + { PseudoVMSGTU_VI_MF4_MASK, VMSGTU_VI }, // 5941 + { PseudoVMSGTU_VI_MF8, VMSGTU_VI }, // 5942 + { PseudoVMSGTU_VI_MF8_MASK, VMSGTU_VI }, // 5943 + { PseudoVMSGTU_VX_M1, VMSGTU_VX }, // 5944 + { PseudoVMSGTU_VX_M1_MASK, VMSGTU_VX }, // 5945 + { PseudoVMSGTU_VX_M2, VMSGTU_VX }, // 5946 + { PseudoVMSGTU_VX_M2_MASK, VMSGTU_VX }, // 5947 + { PseudoVMSGTU_VX_M4, VMSGTU_VX }, // 5948 + { PseudoVMSGTU_VX_M4_MASK, VMSGTU_VX }, // 5949 + { PseudoVMSGTU_VX_M8, VMSGTU_VX }, // 5950 + { PseudoVMSGTU_VX_M8_MASK, VMSGTU_VX }, // 5951 + { PseudoVMSGTU_VX_MF2, VMSGTU_VX }, // 5952 + { PseudoVMSGTU_VX_MF2_MASK, VMSGTU_VX }, // 5953 + { PseudoVMSGTU_VX_MF4, VMSGTU_VX }, // 5954 + { PseudoVMSGTU_VX_MF4_MASK, VMSGTU_VX }, // 5955 + { PseudoVMSGTU_VX_MF8, VMSGTU_VX }, // 5956 + { PseudoVMSGTU_VX_MF8_MASK, VMSGTU_VX }, // 5957 + { PseudoVMSGT_VI_M1, VMSGT_VI }, // 5958 + { PseudoVMSGT_VI_M1_MASK, VMSGT_VI }, // 5959 + { PseudoVMSGT_VI_M2, VMSGT_VI }, // 5960 + { PseudoVMSGT_VI_M2_MASK, VMSGT_VI }, // 5961 + { PseudoVMSGT_VI_M4, VMSGT_VI }, // 5962 + { PseudoVMSGT_VI_M4_MASK, VMSGT_VI }, // 5963 + { PseudoVMSGT_VI_M8, VMSGT_VI }, // 5964 + { PseudoVMSGT_VI_M8_MASK, VMSGT_VI }, // 5965 + { PseudoVMSGT_VI_MF2, VMSGT_VI }, // 5966 + { PseudoVMSGT_VI_MF2_MASK, VMSGT_VI }, // 5967 + { PseudoVMSGT_VI_MF4, VMSGT_VI }, // 5968 + { PseudoVMSGT_VI_MF4_MASK, VMSGT_VI }, // 5969 + { PseudoVMSGT_VI_MF8, VMSGT_VI }, // 5970 + { PseudoVMSGT_VI_MF8_MASK, VMSGT_VI }, // 5971 + { PseudoVMSGT_VX_M1, VMSGT_VX }, // 5972 + { PseudoVMSGT_VX_M1_MASK, VMSGT_VX }, // 5973 + { PseudoVMSGT_VX_M2, VMSGT_VX }, // 5974 + { PseudoVMSGT_VX_M2_MASK, VMSGT_VX }, // 5975 + { PseudoVMSGT_VX_M4, VMSGT_VX }, // 5976 + { PseudoVMSGT_VX_M4_MASK, VMSGT_VX }, // 5977 + { PseudoVMSGT_VX_M8, VMSGT_VX }, // 5978 + { PseudoVMSGT_VX_M8_MASK, VMSGT_VX }, // 5979 + { PseudoVMSGT_VX_MF2, VMSGT_VX }, // 5980 + { PseudoVMSGT_VX_MF2_MASK, VMSGT_VX }, // 5981 + { PseudoVMSGT_VX_MF4, VMSGT_VX }, // 5982 + { PseudoVMSGT_VX_MF4_MASK, VMSGT_VX }, // 5983 + { PseudoVMSGT_VX_MF8, VMSGT_VX }, // 5984 + { PseudoVMSGT_VX_MF8_MASK, VMSGT_VX }, // 5985 + { PseudoVMSIF_M_B1, VMSIF_M }, // 5986 + { PseudoVMSIF_M_B16, VMSIF_M }, // 5987 + { PseudoVMSIF_M_B16_MASK, VMSIF_M }, // 5988 + { PseudoVMSIF_M_B1_MASK, VMSIF_M }, // 5989 + { PseudoVMSIF_M_B2, VMSIF_M }, // 5990 + { PseudoVMSIF_M_B2_MASK, VMSIF_M }, // 5991 + { PseudoVMSIF_M_B32, VMSIF_M }, // 5992 + { PseudoVMSIF_M_B32_MASK, VMSIF_M }, // 5993 + { PseudoVMSIF_M_B4, VMSIF_M }, // 5994 + { PseudoVMSIF_M_B4_MASK, VMSIF_M }, // 5995 + { PseudoVMSIF_M_B64, VMSIF_M }, // 5996 + { PseudoVMSIF_M_B64_MASK, VMSIF_M }, // 5997 + { PseudoVMSIF_M_B8, VMSIF_M }, // 5998 + { PseudoVMSIF_M_B8_MASK, VMSIF_M }, // 5999 + { PseudoVMSLEU_VI_M1, VMSLEU_VI }, // 6000 + { PseudoVMSLEU_VI_M1_MASK, VMSLEU_VI }, // 6001 + { PseudoVMSLEU_VI_M2, VMSLEU_VI }, // 6002 + { PseudoVMSLEU_VI_M2_MASK, VMSLEU_VI }, // 6003 + { PseudoVMSLEU_VI_M4, VMSLEU_VI }, // 6004 + { PseudoVMSLEU_VI_M4_MASK, VMSLEU_VI }, // 6005 + { PseudoVMSLEU_VI_M8, VMSLEU_VI }, // 6006 + { PseudoVMSLEU_VI_M8_MASK, VMSLEU_VI }, // 6007 + { PseudoVMSLEU_VI_MF2, VMSLEU_VI }, // 6008 + { PseudoVMSLEU_VI_MF2_MASK, VMSLEU_VI }, // 6009 + { PseudoVMSLEU_VI_MF4, VMSLEU_VI }, // 6010 + { PseudoVMSLEU_VI_MF4_MASK, VMSLEU_VI }, // 6011 + { PseudoVMSLEU_VI_MF8, VMSLEU_VI }, // 6012 + { PseudoVMSLEU_VI_MF8_MASK, VMSLEU_VI }, // 6013 + { PseudoVMSLEU_VV_M1, VMSLEU_VV }, // 6014 + { PseudoVMSLEU_VV_M1_MASK, VMSLEU_VV }, // 6015 + { PseudoVMSLEU_VV_M2, VMSLEU_VV }, // 6016 + { PseudoVMSLEU_VV_M2_MASK, VMSLEU_VV }, // 6017 + { PseudoVMSLEU_VV_M4, VMSLEU_VV }, // 6018 + { PseudoVMSLEU_VV_M4_MASK, VMSLEU_VV }, // 6019 + { PseudoVMSLEU_VV_M8, VMSLEU_VV }, // 6020 + { PseudoVMSLEU_VV_M8_MASK, VMSLEU_VV }, // 6021 + { PseudoVMSLEU_VV_MF2, VMSLEU_VV }, // 6022 + { PseudoVMSLEU_VV_MF2_MASK, VMSLEU_VV }, // 6023 + { PseudoVMSLEU_VV_MF4, VMSLEU_VV }, // 6024 + { PseudoVMSLEU_VV_MF4_MASK, VMSLEU_VV }, // 6025 + { PseudoVMSLEU_VV_MF8, VMSLEU_VV }, // 6026 + { PseudoVMSLEU_VV_MF8_MASK, VMSLEU_VV }, // 6027 + { PseudoVMSLEU_VX_M1, VMSLEU_VX }, // 6028 + { PseudoVMSLEU_VX_M1_MASK, VMSLEU_VX }, // 6029 + { PseudoVMSLEU_VX_M2, VMSLEU_VX }, // 6030 + { PseudoVMSLEU_VX_M2_MASK, VMSLEU_VX }, // 6031 + { PseudoVMSLEU_VX_M4, VMSLEU_VX }, // 6032 + { PseudoVMSLEU_VX_M4_MASK, VMSLEU_VX }, // 6033 + { PseudoVMSLEU_VX_M8, VMSLEU_VX }, // 6034 + { PseudoVMSLEU_VX_M8_MASK, VMSLEU_VX }, // 6035 + { PseudoVMSLEU_VX_MF2, VMSLEU_VX }, // 6036 + { PseudoVMSLEU_VX_MF2_MASK, VMSLEU_VX }, // 6037 + { PseudoVMSLEU_VX_MF4, VMSLEU_VX }, // 6038 + { PseudoVMSLEU_VX_MF4_MASK, VMSLEU_VX }, // 6039 + { PseudoVMSLEU_VX_MF8, VMSLEU_VX }, // 6040 + { PseudoVMSLEU_VX_MF8_MASK, VMSLEU_VX }, // 6041 + { PseudoVMSLE_VI_M1, VMSLE_VI }, // 6042 + { PseudoVMSLE_VI_M1_MASK, VMSLE_VI }, // 6043 + { PseudoVMSLE_VI_M2, VMSLE_VI }, // 6044 + { PseudoVMSLE_VI_M2_MASK, VMSLE_VI }, // 6045 + { PseudoVMSLE_VI_M4, VMSLE_VI }, // 6046 + { PseudoVMSLE_VI_M4_MASK, VMSLE_VI }, // 6047 + { PseudoVMSLE_VI_M8, VMSLE_VI }, // 6048 + { PseudoVMSLE_VI_M8_MASK, VMSLE_VI }, // 6049 + { PseudoVMSLE_VI_MF2, VMSLE_VI }, // 6050 + { PseudoVMSLE_VI_MF2_MASK, VMSLE_VI }, // 6051 + { PseudoVMSLE_VI_MF4, VMSLE_VI }, // 6052 + { PseudoVMSLE_VI_MF4_MASK, VMSLE_VI }, // 6053 + { PseudoVMSLE_VI_MF8, VMSLE_VI }, // 6054 + { PseudoVMSLE_VI_MF8_MASK, VMSLE_VI }, // 6055 + { PseudoVMSLE_VV_M1, VMSLE_VV }, // 6056 + { PseudoVMSLE_VV_M1_MASK, VMSLE_VV }, // 6057 + { PseudoVMSLE_VV_M2, VMSLE_VV }, // 6058 + { PseudoVMSLE_VV_M2_MASK, VMSLE_VV }, // 6059 + { PseudoVMSLE_VV_M4, VMSLE_VV }, // 6060 + { PseudoVMSLE_VV_M4_MASK, VMSLE_VV }, // 6061 + { PseudoVMSLE_VV_M8, VMSLE_VV }, // 6062 + { PseudoVMSLE_VV_M8_MASK, VMSLE_VV }, // 6063 + { PseudoVMSLE_VV_MF2, VMSLE_VV }, // 6064 + { PseudoVMSLE_VV_MF2_MASK, VMSLE_VV }, // 6065 + { PseudoVMSLE_VV_MF4, VMSLE_VV }, // 6066 + { PseudoVMSLE_VV_MF4_MASK, VMSLE_VV }, // 6067 + { PseudoVMSLE_VV_MF8, VMSLE_VV }, // 6068 + { PseudoVMSLE_VV_MF8_MASK, VMSLE_VV }, // 6069 + { PseudoVMSLE_VX_M1, VMSLE_VX }, // 6070 + { PseudoVMSLE_VX_M1_MASK, VMSLE_VX }, // 6071 + { PseudoVMSLE_VX_M2, VMSLE_VX }, // 6072 + { PseudoVMSLE_VX_M2_MASK, VMSLE_VX }, // 6073 + { PseudoVMSLE_VX_M4, VMSLE_VX }, // 6074 + { PseudoVMSLE_VX_M4_MASK, VMSLE_VX }, // 6075 + { PseudoVMSLE_VX_M8, VMSLE_VX }, // 6076 + { PseudoVMSLE_VX_M8_MASK, VMSLE_VX }, // 6077 + { PseudoVMSLE_VX_MF2, VMSLE_VX }, // 6078 + { PseudoVMSLE_VX_MF2_MASK, VMSLE_VX }, // 6079 + { PseudoVMSLE_VX_MF4, VMSLE_VX }, // 6080 + { PseudoVMSLE_VX_MF4_MASK, VMSLE_VX }, // 6081 + { PseudoVMSLE_VX_MF8, VMSLE_VX }, // 6082 + { PseudoVMSLE_VX_MF8_MASK, VMSLE_VX }, // 6083 + { PseudoVMSLTU_VV_M1, VMSLTU_VV }, // 6084 + { PseudoVMSLTU_VV_M1_MASK, VMSLTU_VV }, // 6085 + { PseudoVMSLTU_VV_M2, VMSLTU_VV }, // 6086 + { PseudoVMSLTU_VV_M2_MASK, VMSLTU_VV }, // 6087 + { PseudoVMSLTU_VV_M4, VMSLTU_VV }, // 6088 + { PseudoVMSLTU_VV_M4_MASK, VMSLTU_VV }, // 6089 + { PseudoVMSLTU_VV_M8, VMSLTU_VV }, // 6090 + { PseudoVMSLTU_VV_M8_MASK, VMSLTU_VV }, // 6091 + { PseudoVMSLTU_VV_MF2, VMSLTU_VV }, // 6092 + { PseudoVMSLTU_VV_MF2_MASK, VMSLTU_VV }, // 6093 + { PseudoVMSLTU_VV_MF4, VMSLTU_VV }, // 6094 + { PseudoVMSLTU_VV_MF4_MASK, VMSLTU_VV }, // 6095 + { PseudoVMSLTU_VV_MF8, VMSLTU_VV }, // 6096 + { PseudoVMSLTU_VV_MF8_MASK, VMSLTU_VV }, // 6097 + { PseudoVMSLTU_VX_M1, VMSLTU_VX }, // 6098 + { PseudoVMSLTU_VX_M1_MASK, VMSLTU_VX }, // 6099 + { PseudoVMSLTU_VX_M2, VMSLTU_VX }, // 6100 + { PseudoVMSLTU_VX_M2_MASK, VMSLTU_VX }, // 6101 + { PseudoVMSLTU_VX_M4, VMSLTU_VX }, // 6102 + { PseudoVMSLTU_VX_M4_MASK, VMSLTU_VX }, // 6103 + { PseudoVMSLTU_VX_M8, VMSLTU_VX }, // 6104 + { PseudoVMSLTU_VX_M8_MASK, VMSLTU_VX }, // 6105 + { PseudoVMSLTU_VX_MF2, VMSLTU_VX }, // 6106 + { PseudoVMSLTU_VX_MF2_MASK, VMSLTU_VX }, // 6107 + { PseudoVMSLTU_VX_MF4, VMSLTU_VX }, // 6108 + { PseudoVMSLTU_VX_MF4_MASK, VMSLTU_VX }, // 6109 + { PseudoVMSLTU_VX_MF8, VMSLTU_VX }, // 6110 + { PseudoVMSLTU_VX_MF8_MASK, VMSLTU_VX }, // 6111 + { PseudoVMSLT_VV_M1, VMSLT_VV }, // 6112 + { PseudoVMSLT_VV_M1_MASK, VMSLT_VV }, // 6113 + { PseudoVMSLT_VV_M2, VMSLT_VV }, // 6114 + { PseudoVMSLT_VV_M2_MASK, VMSLT_VV }, // 6115 + { PseudoVMSLT_VV_M4, VMSLT_VV }, // 6116 + { PseudoVMSLT_VV_M4_MASK, VMSLT_VV }, // 6117 + { PseudoVMSLT_VV_M8, VMSLT_VV }, // 6118 + { PseudoVMSLT_VV_M8_MASK, VMSLT_VV }, // 6119 + { PseudoVMSLT_VV_MF2, VMSLT_VV }, // 6120 + { PseudoVMSLT_VV_MF2_MASK, VMSLT_VV }, // 6121 + { PseudoVMSLT_VV_MF4, VMSLT_VV }, // 6122 + { PseudoVMSLT_VV_MF4_MASK, VMSLT_VV }, // 6123 + { PseudoVMSLT_VV_MF8, VMSLT_VV }, // 6124 + { PseudoVMSLT_VV_MF8_MASK, VMSLT_VV }, // 6125 + { PseudoVMSLT_VX_M1, VMSLT_VX }, // 6126 + { PseudoVMSLT_VX_M1_MASK, VMSLT_VX }, // 6127 + { PseudoVMSLT_VX_M2, VMSLT_VX }, // 6128 + { PseudoVMSLT_VX_M2_MASK, VMSLT_VX }, // 6129 + { PseudoVMSLT_VX_M4, VMSLT_VX }, // 6130 + { PseudoVMSLT_VX_M4_MASK, VMSLT_VX }, // 6131 + { PseudoVMSLT_VX_M8, VMSLT_VX }, // 6132 + { PseudoVMSLT_VX_M8_MASK, VMSLT_VX }, // 6133 + { PseudoVMSLT_VX_MF2, VMSLT_VX }, // 6134 + { PseudoVMSLT_VX_MF2_MASK, VMSLT_VX }, // 6135 + { PseudoVMSLT_VX_MF4, VMSLT_VX }, // 6136 + { PseudoVMSLT_VX_MF4_MASK, VMSLT_VX }, // 6137 + { PseudoVMSLT_VX_MF8, VMSLT_VX }, // 6138 + { PseudoVMSLT_VX_MF8_MASK, VMSLT_VX }, // 6139 + { PseudoVMSNE_VI_M1, VMSNE_VI }, // 6140 + { PseudoVMSNE_VI_M1_MASK, VMSNE_VI }, // 6141 + { PseudoVMSNE_VI_M2, VMSNE_VI }, // 6142 + { PseudoVMSNE_VI_M2_MASK, VMSNE_VI }, // 6143 + { PseudoVMSNE_VI_M4, VMSNE_VI }, // 6144 + { PseudoVMSNE_VI_M4_MASK, VMSNE_VI }, // 6145 + { PseudoVMSNE_VI_M8, VMSNE_VI }, // 6146 + { PseudoVMSNE_VI_M8_MASK, VMSNE_VI }, // 6147 + { PseudoVMSNE_VI_MF2, VMSNE_VI }, // 6148 + { PseudoVMSNE_VI_MF2_MASK, VMSNE_VI }, // 6149 + { PseudoVMSNE_VI_MF4, VMSNE_VI }, // 6150 + { PseudoVMSNE_VI_MF4_MASK, VMSNE_VI }, // 6151 + { PseudoVMSNE_VI_MF8, VMSNE_VI }, // 6152 + { PseudoVMSNE_VI_MF8_MASK, VMSNE_VI }, // 6153 + { PseudoVMSNE_VV_M1, VMSNE_VV }, // 6154 + { PseudoVMSNE_VV_M1_MASK, VMSNE_VV }, // 6155 + { PseudoVMSNE_VV_M2, VMSNE_VV }, // 6156 + { PseudoVMSNE_VV_M2_MASK, VMSNE_VV }, // 6157 + { PseudoVMSNE_VV_M4, VMSNE_VV }, // 6158 + { PseudoVMSNE_VV_M4_MASK, VMSNE_VV }, // 6159 + { PseudoVMSNE_VV_M8, VMSNE_VV }, // 6160 + { PseudoVMSNE_VV_M8_MASK, VMSNE_VV }, // 6161 + { PseudoVMSNE_VV_MF2, VMSNE_VV }, // 6162 + { PseudoVMSNE_VV_MF2_MASK, VMSNE_VV }, // 6163 + { PseudoVMSNE_VV_MF4, VMSNE_VV }, // 6164 + { PseudoVMSNE_VV_MF4_MASK, VMSNE_VV }, // 6165 + { PseudoVMSNE_VV_MF8, VMSNE_VV }, // 6166 + { PseudoVMSNE_VV_MF8_MASK, VMSNE_VV }, // 6167 + { PseudoVMSNE_VX_M1, VMSNE_VX }, // 6168 + { PseudoVMSNE_VX_M1_MASK, VMSNE_VX }, // 6169 + { PseudoVMSNE_VX_M2, VMSNE_VX }, // 6170 + { PseudoVMSNE_VX_M2_MASK, VMSNE_VX }, // 6171 + { PseudoVMSNE_VX_M4, VMSNE_VX }, // 6172 + { PseudoVMSNE_VX_M4_MASK, VMSNE_VX }, // 6173 + { PseudoVMSNE_VX_M8, VMSNE_VX }, // 6174 + { PseudoVMSNE_VX_M8_MASK, VMSNE_VX }, // 6175 + { PseudoVMSNE_VX_MF2, VMSNE_VX }, // 6176 + { PseudoVMSNE_VX_MF2_MASK, VMSNE_VX }, // 6177 + { PseudoVMSNE_VX_MF4, VMSNE_VX }, // 6178 + { PseudoVMSNE_VX_MF4_MASK, VMSNE_VX }, // 6179 + { PseudoVMSNE_VX_MF8, VMSNE_VX }, // 6180 + { PseudoVMSNE_VX_MF8_MASK, VMSNE_VX }, // 6181 + { PseudoVMSOF_M_B1, VMSOF_M }, // 6182 + { PseudoVMSOF_M_B16, VMSOF_M }, // 6183 + { PseudoVMSOF_M_B16_MASK, VMSOF_M }, // 6184 + { PseudoVMSOF_M_B1_MASK, VMSOF_M }, // 6185 + { PseudoVMSOF_M_B2, VMSOF_M }, // 6186 + { PseudoVMSOF_M_B2_MASK, VMSOF_M }, // 6187 + { PseudoVMSOF_M_B32, VMSOF_M }, // 6188 + { PseudoVMSOF_M_B32_MASK, VMSOF_M }, // 6189 + { PseudoVMSOF_M_B4, VMSOF_M }, // 6190 + { PseudoVMSOF_M_B4_MASK, VMSOF_M }, // 6191 + { PseudoVMSOF_M_B64, VMSOF_M }, // 6192 + { PseudoVMSOF_M_B64_MASK, VMSOF_M }, // 6193 + { PseudoVMSOF_M_B8, VMSOF_M }, // 6194 + { PseudoVMSOF_M_B8_MASK, VMSOF_M }, // 6195 + { PseudoVMULHSU_VV_M1, VMULHSU_VV }, // 6196 + { PseudoVMULHSU_VV_M1_MASK, VMULHSU_VV }, // 6197 + { PseudoVMULHSU_VV_M2, VMULHSU_VV }, // 6198 + { PseudoVMULHSU_VV_M2_MASK, VMULHSU_VV }, // 6199 + { PseudoVMULHSU_VV_M4, VMULHSU_VV }, // 6200 + { PseudoVMULHSU_VV_M4_MASK, VMULHSU_VV }, // 6201 + { PseudoVMULHSU_VV_M8, VMULHSU_VV }, // 6202 + { PseudoVMULHSU_VV_M8_MASK, VMULHSU_VV }, // 6203 + { PseudoVMULHSU_VV_MF2, VMULHSU_VV }, // 6204 + { PseudoVMULHSU_VV_MF2_MASK, VMULHSU_VV }, // 6205 + { PseudoVMULHSU_VV_MF4, VMULHSU_VV }, // 6206 + { PseudoVMULHSU_VV_MF4_MASK, VMULHSU_VV }, // 6207 + { PseudoVMULHSU_VV_MF8, VMULHSU_VV }, // 6208 + { PseudoVMULHSU_VV_MF8_MASK, VMULHSU_VV }, // 6209 + { PseudoVMULHSU_VX_M1, VMULHSU_VX }, // 6210 + { PseudoVMULHSU_VX_M1_MASK, VMULHSU_VX }, // 6211 + { PseudoVMULHSU_VX_M2, VMULHSU_VX }, // 6212 + { PseudoVMULHSU_VX_M2_MASK, VMULHSU_VX }, // 6213 + { PseudoVMULHSU_VX_M4, VMULHSU_VX }, // 6214 + { PseudoVMULHSU_VX_M4_MASK, VMULHSU_VX }, // 6215 + { PseudoVMULHSU_VX_M8, VMULHSU_VX }, // 6216 + { PseudoVMULHSU_VX_M8_MASK, VMULHSU_VX }, // 6217 + { PseudoVMULHSU_VX_MF2, VMULHSU_VX }, // 6218 + { PseudoVMULHSU_VX_MF2_MASK, VMULHSU_VX }, // 6219 + { PseudoVMULHSU_VX_MF4, VMULHSU_VX }, // 6220 + { PseudoVMULHSU_VX_MF4_MASK, VMULHSU_VX }, // 6221 + { PseudoVMULHSU_VX_MF8, VMULHSU_VX }, // 6222 + { PseudoVMULHSU_VX_MF8_MASK, VMULHSU_VX }, // 6223 + { PseudoVMULHU_VV_M1, VMULHU_VV }, // 6224 + { PseudoVMULHU_VV_M1_MASK, VMULHU_VV }, // 6225 + { PseudoVMULHU_VV_M2, VMULHU_VV }, // 6226 + { PseudoVMULHU_VV_M2_MASK, VMULHU_VV }, // 6227 + { PseudoVMULHU_VV_M4, VMULHU_VV }, // 6228 + { PseudoVMULHU_VV_M4_MASK, VMULHU_VV }, // 6229 + { PseudoVMULHU_VV_M8, VMULHU_VV }, // 6230 + { PseudoVMULHU_VV_M8_MASK, VMULHU_VV }, // 6231 + { PseudoVMULHU_VV_MF2, VMULHU_VV }, // 6232 + { PseudoVMULHU_VV_MF2_MASK, VMULHU_VV }, // 6233 + { PseudoVMULHU_VV_MF4, VMULHU_VV }, // 6234 + { PseudoVMULHU_VV_MF4_MASK, VMULHU_VV }, // 6235 + { PseudoVMULHU_VV_MF8, VMULHU_VV }, // 6236 + { PseudoVMULHU_VV_MF8_MASK, VMULHU_VV }, // 6237 + { PseudoVMULHU_VX_M1, VMULHU_VX }, // 6238 + { PseudoVMULHU_VX_M1_MASK, VMULHU_VX }, // 6239 + { PseudoVMULHU_VX_M2, VMULHU_VX }, // 6240 + { PseudoVMULHU_VX_M2_MASK, VMULHU_VX }, // 6241 + { PseudoVMULHU_VX_M4, VMULHU_VX }, // 6242 + { PseudoVMULHU_VX_M4_MASK, VMULHU_VX }, // 6243 + { PseudoVMULHU_VX_M8, VMULHU_VX }, // 6244 + { PseudoVMULHU_VX_M8_MASK, VMULHU_VX }, // 6245 + { PseudoVMULHU_VX_MF2, VMULHU_VX }, // 6246 + { PseudoVMULHU_VX_MF2_MASK, VMULHU_VX }, // 6247 + { PseudoVMULHU_VX_MF4, VMULHU_VX }, // 6248 + { PseudoVMULHU_VX_MF4_MASK, VMULHU_VX }, // 6249 + { PseudoVMULHU_VX_MF8, VMULHU_VX }, // 6250 + { PseudoVMULHU_VX_MF8_MASK, VMULHU_VX }, // 6251 + { PseudoVMULH_VV_M1, VMULH_VV }, // 6252 + { PseudoVMULH_VV_M1_MASK, VMULH_VV }, // 6253 + { PseudoVMULH_VV_M2, VMULH_VV }, // 6254 + { PseudoVMULH_VV_M2_MASK, VMULH_VV }, // 6255 + { PseudoVMULH_VV_M4, VMULH_VV }, // 6256 + { PseudoVMULH_VV_M4_MASK, VMULH_VV }, // 6257 + { PseudoVMULH_VV_M8, VMULH_VV }, // 6258 + { PseudoVMULH_VV_M8_MASK, VMULH_VV }, // 6259 + { PseudoVMULH_VV_MF2, VMULH_VV }, // 6260 + { PseudoVMULH_VV_MF2_MASK, VMULH_VV }, // 6261 + { PseudoVMULH_VV_MF4, VMULH_VV }, // 6262 + { PseudoVMULH_VV_MF4_MASK, VMULH_VV }, // 6263 + { PseudoVMULH_VV_MF8, VMULH_VV }, // 6264 + { PseudoVMULH_VV_MF8_MASK, VMULH_VV }, // 6265 + { PseudoVMULH_VX_M1, VMULH_VX }, // 6266 + { PseudoVMULH_VX_M1_MASK, VMULH_VX }, // 6267 + { PseudoVMULH_VX_M2, VMULH_VX }, // 6268 + { PseudoVMULH_VX_M2_MASK, VMULH_VX }, // 6269 + { PseudoVMULH_VX_M4, VMULH_VX }, // 6270 + { PseudoVMULH_VX_M4_MASK, VMULH_VX }, // 6271 + { PseudoVMULH_VX_M8, VMULH_VX }, // 6272 + { PseudoVMULH_VX_M8_MASK, VMULH_VX }, // 6273 + { PseudoVMULH_VX_MF2, VMULH_VX }, // 6274 + { PseudoVMULH_VX_MF2_MASK, VMULH_VX }, // 6275 + { PseudoVMULH_VX_MF4, VMULH_VX }, // 6276 + { PseudoVMULH_VX_MF4_MASK, VMULH_VX }, // 6277 + { PseudoVMULH_VX_MF8, VMULH_VX }, // 6278 + { PseudoVMULH_VX_MF8_MASK, VMULH_VX }, // 6279 + { PseudoVMUL_VV_M1, VMUL_VV }, // 6280 + { PseudoVMUL_VV_M1_MASK, VMUL_VV }, // 6281 + { PseudoVMUL_VV_M2, VMUL_VV }, // 6282 + { PseudoVMUL_VV_M2_MASK, VMUL_VV }, // 6283 + { PseudoVMUL_VV_M4, VMUL_VV }, // 6284 + { PseudoVMUL_VV_M4_MASK, VMUL_VV }, // 6285 + { PseudoVMUL_VV_M8, VMUL_VV }, // 6286 + { PseudoVMUL_VV_M8_MASK, VMUL_VV }, // 6287 + { PseudoVMUL_VV_MF2, VMUL_VV }, // 6288 + { PseudoVMUL_VV_MF2_MASK, VMUL_VV }, // 6289 + { PseudoVMUL_VV_MF4, VMUL_VV }, // 6290 + { PseudoVMUL_VV_MF4_MASK, VMUL_VV }, // 6291 + { PseudoVMUL_VV_MF8, VMUL_VV }, // 6292 + { PseudoVMUL_VV_MF8_MASK, VMUL_VV }, // 6293 + { PseudoVMUL_VX_M1, VMUL_VX }, // 6294 + { PseudoVMUL_VX_M1_MASK, VMUL_VX }, // 6295 + { PseudoVMUL_VX_M2, VMUL_VX }, // 6296 + { PseudoVMUL_VX_M2_MASK, VMUL_VX }, // 6297 + { PseudoVMUL_VX_M4, VMUL_VX }, // 6298 + { PseudoVMUL_VX_M4_MASK, VMUL_VX }, // 6299 + { PseudoVMUL_VX_M8, VMUL_VX }, // 6300 + { PseudoVMUL_VX_M8_MASK, VMUL_VX }, // 6301 + { PseudoVMUL_VX_MF2, VMUL_VX }, // 6302 + { PseudoVMUL_VX_MF2_MASK, VMUL_VX }, // 6303 + { PseudoVMUL_VX_MF4, VMUL_VX }, // 6304 + { PseudoVMUL_VX_MF4_MASK, VMUL_VX }, // 6305 + { PseudoVMUL_VX_MF8, VMUL_VX }, // 6306 + { PseudoVMUL_VX_MF8_MASK, VMUL_VX }, // 6307 + { PseudoVMV_S_X, VMV_S_X }, // 6308 + { PseudoVMV_V_I_M1, VMV_V_I }, // 6309 + { PseudoVMV_V_I_M2, VMV_V_I }, // 6310 + { PseudoVMV_V_I_M4, VMV_V_I }, // 6311 + { PseudoVMV_V_I_M8, VMV_V_I }, // 6312 + { PseudoVMV_V_I_MF2, VMV_V_I }, // 6313 + { PseudoVMV_V_I_MF4, VMV_V_I }, // 6314 + { PseudoVMV_V_I_MF8, VMV_V_I }, // 6315 + { PseudoVMV_V_V_M1, VMV_V_V }, // 6316 + { PseudoVMV_V_V_M2, VMV_V_V }, // 6317 + { PseudoVMV_V_V_M4, VMV_V_V }, // 6318 + { PseudoVMV_V_V_M8, VMV_V_V }, // 6319 + { PseudoVMV_V_V_MF2, VMV_V_V }, // 6320 + { PseudoVMV_V_V_MF4, VMV_V_V }, // 6321 + { PseudoVMV_V_V_MF8, VMV_V_V }, // 6322 + { PseudoVMV_V_X_M1, VMV_V_X }, // 6323 + { PseudoVMV_V_X_M2, VMV_V_X }, // 6324 + { PseudoVMV_V_X_M4, VMV_V_X }, // 6325 + { PseudoVMV_V_X_M8, VMV_V_X }, // 6326 + { PseudoVMV_V_X_MF2, VMV_V_X }, // 6327 + { PseudoVMV_V_X_MF4, VMV_V_X }, // 6328 + { PseudoVMV_V_X_MF8, VMV_V_X }, // 6329 + { PseudoVMV_X_S, VMV_X_S }, // 6330 + { PseudoVMXNOR_MM_M1, VMXNOR_MM }, // 6331 + { PseudoVMXNOR_MM_M2, VMXNOR_MM }, // 6332 + { PseudoVMXNOR_MM_M4, VMXNOR_MM }, // 6333 + { PseudoVMXNOR_MM_M8, VMXNOR_MM }, // 6334 + { PseudoVMXNOR_MM_MF2, VMXNOR_MM }, // 6335 + { PseudoVMXNOR_MM_MF4, VMXNOR_MM }, // 6336 + { PseudoVMXNOR_MM_MF8, VMXNOR_MM }, // 6337 + { PseudoVMXOR_MM_M1, VMXOR_MM }, // 6338 + { PseudoVMXOR_MM_M2, VMXOR_MM }, // 6339 + { PseudoVMXOR_MM_M4, VMXOR_MM }, // 6340 + { PseudoVMXOR_MM_M8, VMXOR_MM }, // 6341 + { PseudoVMXOR_MM_MF2, VMXOR_MM }, // 6342 + { PseudoVMXOR_MM_MF4, VMXOR_MM }, // 6343 + { PseudoVMXOR_MM_MF8, VMXOR_MM }, // 6344 + { PseudoVNCLIPU_WI_M1, VNCLIPU_WI }, // 6345 + { PseudoVNCLIPU_WI_M1_MASK, VNCLIPU_WI }, // 6346 + { PseudoVNCLIPU_WI_M2, VNCLIPU_WI }, // 6347 + { PseudoVNCLIPU_WI_M2_MASK, VNCLIPU_WI }, // 6348 + { PseudoVNCLIPU_WI_M4, VNCLIPU_WI }, // 6349 + { PseudoVNCLIPU_WI_M4_MASK, VNCLIPU_WI }, // 6350 + { PseudoVNCLIPU_WI_MF2, VNCLIPU_WI }, // 6351 + { PseudoVNCLIPU_WI_MF2_MASK, VNCLIPU_WI }, // 6352 + { PseudoVNCLIPU_WI_MF4, VNCLIPU_WI }, // 6353 + { PseudoVNCLIPU_WI_MF4_MASK, VNCLIPU_WI }, // 6354 + { PseudoVNCLIPU_WI_MF8, VNCLIPU_WI }, // 6355 + { PseudoVNCLIPU_WI_MF8_MASK, VNCLIPU_WI }, // 6356 + { PseudoVNCLIPU_WV_M1, VNCLIPU_WV }, // 6357 + { PseudoVNCLIPU_WV_M1_MASK, VNCLIPU_WV }, // 6358 + { PseudoVNCLIPU_WV_M2, VNCLIPU_WV }, // 6359 + { PseudoVNCLIPU_WV_M2_MASK, VNCLIPU_WV }, // 6360 + { PseudoVNCLIPU_WV_M4, VNCLIPU_WV }, // 6361 + { PseudoVNCLIPU_WV_M4_MASK, VNCLIPU_WV }, // 6362 + { PseudoVNCLIPU_WV_MF2, VNCLIPU_WV }, // 6363 + { PseudoVNCLIPU_WV_MF2_MASK, VNCLIPU_WV }, // 6364 + { PseudoVNCLIPU_WV_MF4, VNCLIPU_WV }, // 6365 + { PseudoVNCLIPU_WV_MF4_MASK, VNCLIPU_WV }, // 6366 + { PseudoVNCLIPU_WV_MF8, VNCLIPU_WV }, // 6367 + { PseudoVNCLIPU_WV_MF8_MASK, VNCLIPU_WV }, // 6368 + { PseudoVNCLIPU_WX_M1, VNCLIPU_WX }, // 6369 + { PseudoVNCLIPU_WX_M1_MASK, VNCLIPU_WX }, // 6370 + { PseudoVNCLIPU_WX_M2, VNCLIPU_WX }, // 6371 + { PseudoVNCLIPU_WX_M2_MASK, VNCLIPU_WX }, // 6372 + { PseudoVNCLIPU_WX_M4, VNCLIPU_WX }, // 6373 + { PseudoVNCLIPU_WX_M4_MASK, VNCLIPU_WX }, // 6374 + { PseudoVNCLIPU_WX_MF2, VNCLIPU_WX }, // 6375 + { PseudoVNCLIPU_WX_MF2_MASK, VNCLIPU_WX }, // 6376 + { PseudoVNCLIPU_WX_MF4, VNCLIPU_WX }, // 6377 + { PseudoVNCLIPU_WX_MF4_MASK, VNCLIPU_WX }, // 6378 + { PseudoVNCLIPU_WX_MF8, VNCLIPU_WX }, // 6379 + { PseudoVNCLIPU_WX_MF8_MASK, VNCLIPU_WX }, // 6380 + { PseudoVNCLIP_WI_M1, VNCLIP_WI }, // 6381 + { PseudoVNCLIP_WI_M1_MASK, VNCLIP_WI }, // 6382 + { PseudoVNCLIP_WI_M2, VNCLIP_WI }, // 6383 + { PseudoVNCLIP_WI_M2_MASK, VNCLIP_WI }, // 6384 + { PseudoVNCLIP_WI_M4, VNCLIP_WI }, // 6385 + { PseudoVNCLIP_WI_M4_MASK, VNCLIP_WI }, // 6386 + { PseudoVNCLIP_WI_MF2, VNCLIP_WI }, // 6387 + { PseudoVNCLIP_WI_MF2_MASK, VNCLIP_WI }, // 6388 + { PseudoVNCLIP_WI_MF4, VNCLIP_WI }, // 6389 + { PseudoVNCLIP_WI_MF4_MASK, VNCLIP_WI }, // 6390 + { PseudoVNCLIP_WI_MF8, VNCLIP_WI }, // 6391 + { PseudoVNCLIP_WI_MF8_MASK, VNCLIP_WI }, // 6392 + { PseudoVNCLIP_WV_M1, VNCLIP_WV }, // 6393 + { PseudoVNCLIP_WV_M1_MASK, VNCLIP_WV }, // 6394 + { PseudoVNCLIP_WV_M2, VNCLIP_WV }, // 6395 + { PseudoVNCLIP_WV_M2_MASK, VNCLIP_WV }, // 6396 + { PseudoVNCLIP_WV_M4, VNCLIP_WV }, // 6397 + { PseudoVNCLIP_WV_M4_MASK, VNCLIP_WV }, // 6398 + { PseudoVNCLIP_WV_MF2, VNCLIP_WV }, // 6399 + { PseudoVNCLIP_WV_MF2_MASK, VNCLIP_WV }, // 6400 + { PseudoVNCLIP_WV_MF4, VNCLIP_WV }, // 6401 + { PseudoVNCLIP_WV_MF4_MASK, VNCLIP_WV }, // 6402 + { PseudoVNCLIP_WV_MF8, VNCLIP_WV }, // 6403 + { PseudoVNCLIP_WV_MF8_MASK, VNCLIP_WV }, // 6404 + { PseudoVNCLIP_WX_M1, VNCLIP_WX }, // 6405 + { PseudoVNCLIP_WX_M1_MASK, VNCLIP_WX }, // 6406 + { PseudoVNCLIP_WX_M2, VNCLIP_WX }, // 6407 + { PseudoVNCLIP_WX_M2_MASK, VNCLIP_WX }, // 6408 + { PseudoVNCLIP_WX_M4, VNCLIP_WX }, // 6409 + { PseudoVNCLIP_WX_M4_MASK, VNCLIP_WX }, // 6410 + { PseudoVNCLIP_WX_MF2, VNCLIP_WX }, // 6411 + { PseudoVNCLIP_WX_MF2_MASK, VNCLIP_WX }, // 6412 + { PseudoVNCLIP_WX_MF4, VNCLIP_WX }, // 6413 + { PseudoVNCLIP_WX_MF4_MASK, VNCLIP_WX }, // 6414 + { PseudoVNCLIP_WX_MF8, VNCLIP_WX }, // 6415 + { PseudoVNCLIP_WX_MF8_MASK, VNCLIP_WX }, // 6416 + { PseudoVNMSAC_VV_M1, VNMSAC_VV }, // 6417 + { PseudoVNMSAC_VV_M1_MASK, VNMSAC_VV }, // 6418 + { PseudoVNMSAC_VV_M2, VNMSAC_VV }, // 6419 + { PseudoVNMSAC_VV_M2_MASK, VNMSAC_VV }, // 6420 + { PseudoVNMSAC_VV_M4, VNMSAC_VV }, // 6421 + { PseudoVNMSAC_VV_M4_MASK, VNMSAC_VV }, // 6422 + { PseudoVNMSAC_VV_M8, VNMSAC_VV }, // 6423 + { PseudoVNMSAC_VV_M8_MASK, VNMSAC_VV }, // 6424 + { PseudoVNMSAC_VV_MF2, VNMSAC_VV }, // 6425 + { PseudoVNMSAC_VV_MF2_MASK, VNMSAC_VV }, // 6426 + { PseudoVNMSAC_VV_MF4, VNMSAC_VV }, // 6427 + { PseudoVNMSAC_VV_MF4_MASK, VNMSAC_VV }, // 6428 + { PseudoVNMSAC_VV_MF8, VNMSAC_VV }, // 6429 + { PseudoVNMSAC_VV_MF8_MASK, VNMSAC_VV }, // 6430 + { PseudoVNMSAC_VX_M1, VNMSAC_VX }, // 6431 + { PseudoVNMSAC_VX_M1_MASK, VNMSAC_VX }, // 6432 + { PseudoVNMSAC_VX_M2, VNMSAC_VX }, // 6433 + { PseudoVNMSAC_VX_M2_MASK, VNMSAC_VX }, // 6434 + { PseudoVNMSAC_VX_M4, VNMSAC_VX }, // 6435 + { PseudoVNMSAC_VX_M4_MASK, VNMSAC_VX }, // 6436 + { PseudoVNMSAC_VX_M8, VNMSAC_VX }, // 6437 + { PseudoVNMSAC_VX_M8_MASK, VNMSAC_VX }, // 6438 + { PseudoVNMSAC_VX_MF2, VNMSAC_VX }, // 6439 + { PseudoVNMSAC_VX_MF2_MASK, VNMSAC_VX }, // 6440 + { PseudoVNMSAC_VX_MF4, VNMSAC_VX }, // 6441 + { PseudoVNMSAC_VX_MF4_MASK, VNMSAC_VX }, // 6442 + { PseudoVNMSAC_VX_MF8, VNMSAC_VX }, // 6443 + { PseudoVNMSAC_VX_MF8_MASK, VNMSAC_VX }, // 6444 + { PseudoVNMSUB_VV_M1, VNMSUB_VV }, // 6445 + { PseudoVNMSUB_VV_M1_MASK, VNMSUB_VV }, // 6446 + { PseudoVNMSUB_VV_M2, VNMSUB_VV }, // 6447 + { PseudoVNMSUB_VV_M2_MASK, VNMSUB_VV }, // 6448 + { PseudoVNMSUB_VV_M4, VNMSUB_VV }, // 6449 + { PseudoVNMSUB_VV_M4_MASK, VNMSUB_VV }, // 6450 + { PseudoVNMSUB_VV_M8, VNMSUB_VV }, // 6451 + { PseudoVNMSUB_VV_M8_MASK, VNMSUB_VV }, // 6452 + { PseudoVNMSUB_VV_MF2, VNMSUB_VV }, // 6453 + { PseudoVNMSUB_VV_MF2_MASK, VNMSUB_VV }, // 6454 + { PseudoVNMSUB_VV_MF4, VNMSUB_VV }, // 6455 + { PseudoVNMSUB_VV_MF4_MASK, VNMSUB_VV }, // 6456 + { PseudoVNMSUB_VV_MF8, VNMSUB_VV }, // 6457 + { PseudoVNMSUB_VV_MF8_MASK, VNMSUB_VV }, // 6458 + { PseudoVNMSUB_VX_M1, VNMSUB_VX }, // 6459 + { PseudoVNMSUB_VX_M1_MASK, VNMSUB_VX }, // 6460 + { PseudoVNMSUB_VX_M2, VNMSUB_VX }, // 6461 + { PseudoVNMSUB_VX_M2_MASK, VNMSUB_VX }, // 6462 + { PseudoVNMSUB_VX_M4, VNMSUB_VX }, // 6463 + { PseudoVNMSUB_VX_M4_MASK, VNMSUB_VX }, // 6464 + { PseudoVNMSUB_VX_M8, VNMSUB_VX }, // 6465 + { PseudoVNMSUB_VX_M8_MASK, VNMSUB_VX }, // 6466 + { PseudoVNMSUB_VX_MF2, VNMSUB_VX }, // 6467 + { PseudoVNMSUB_VX_MF2_MASK, VNMSUB_VX }, // 6468 + { PseudoVNMSUB_VX_MF4, VNMSUB_VX }, // 6469 + { PseudoVNMSUB_VX_MF4_MASK, VNMSUB_VX }, // 6470 + { PseudoVNMSUB_VX_MF8, VNMSUB_VX }, // 6471 + { PseudoVNMSUB_VX_MF8_MASK, VNMSUB_VX }, // 6472 + { PseudoVNSRA_WI_M1, VNSRA_WI }, // 6473 + { PseudoVNSRA_WI_M1_MASK, VNSRA_WI }, // 6474 + { PseudoVNSRA_WI_M2, VNSRA_WI }, // 6475 + { PseudoVNSRA_WI_M2_MASK, VNSRA_WI }, // 6476 + { PseudoVNSRA_WI_M4, VNSRA_WI }, // 6477 + { PseudoVNSRA_WI_M4_MASK, VNSRA_WI }, // 6478 + { PseudoVNSRA_WI_MF2, VNSRA_WI }, // 6479 + { PseudoVNSRA_WI_MF2_MASK, VNSRA_WI }, // 6480 + { PseudoVNSRA_WI_MF4, VNSRA_WI }, // 6481 + { PseudoVNSRA_WI_MF4_MASK, VNSRA_WI }, // 6482 + { PseudoVNSRA_WI_MF8, VNSRA_WI }, // 6483 + { PseudoVNSRA_WI_MF8_MASK, VNSRA_WI }, // 6484 + { PseudoVNSRA_WV_M1, VNSRA_WV }, // 6485 + { PseudoVNSRA_WV_M1_MASK, VNSRA_WV }, // 6486 + { PseudoVNSRA_WV_M2, VNSRA_WV }, // 6487 + { PseudoVNSRA_WV_M2_MASK, VNSRA_WV }, // 6488 + { PseudoVNSRA_WV_M4, VNSRA_WV }, // 6489 + { PseudoVNSRA_WV_M4_MASK, VNSRA_WV }, // 6490 + { PseudoVNSRA_WV_MF2, VNSRA_WV }, // 6491 + { PseudoVNSRA_WV_MF2_MASK, VNSRA_WV }, // 6492 + { PseudoVNSRA_WV_MF4, VNSRA_WV }, // 6493 + { PseudoVNSRA_WV_MF4_MASK, VNSRA_WV }, // 6494 + { PseudoVNSRA_WV_MF8, VNSRA_WV }, // 6495 + { PseudoVNSRA_WV_MF8_MASK, VNSRA_WV }, // 6496 + { PseudoVNSRA_WX_M1, VNSRA_WX }, // 6497 + { PseudoVNSRA_WX_M1_MASK, VNSRA_WX }, // 6498 + { PseudoVNSRA_WX_M2, VNSRA_WX }, // 6499 + { PseudoVNSRA_WX_M2_MASK, VNSRA_WX }, // 6500 + { PseudoVNSRA_WX_M4, VNSRA_WX }, // 6501 + { PseudoVNSRA_WX_M4_MASK, VNSRA_WX }, // 6502 + { PseudoVNSRA_WX_MF2, VNSRA_WX }, // 6503 + { PseudoVNSRA_WX_MF2_MASK, VNSRA_WX }, // 6504 + { PseudoVNSRA_WX_MF4, VNSRA_WX }, // 6505 + { PseudoVNSRA_WX_MF4_MASK, VNSRA_WX }, // 6506 + { PseudoVNSRA_WX_MF8, VNSRA_WX }, // 6507 + { PseudoVNSRA_WX_MF8_MASK, VNSRA_WX }, // 6508 + { PseudoVNSRL_WI_M1, VNSRL_WI }, // 6509 + { PseudoVNSRL_WI_M1_MASK, VNSRL_WI }, // 6510 + { PseudoVNSRL_WI_M2, VNSRL_WI }, // 6511 + { PseudoVNSRL_WI_M2_MASK, VNSRL_WI }, // 6512 + { PseudoVNSRL_WI_M4, VNSRL_WI }, // 6513 + { PseudoVNSRL_WI_M4_MASK, VNSRL_WI }, // 6514 + { PseudoVNSRL_WI_MF2, VNSRL_WI }, // 6515 + { PseudoVNSRL_WI_MF2_MASK, VNSRL_WI }, // 6516 + { PseudoVNSRL_WI_MF4, VNSRL_WI }, // 6517 + { PseudoVNSRL_WI_MF4_MASK, VNSRL_WI }, // 6518 + { PseudoVNSRL_WI_MF8, VNSRL_WI }, // 6519 + { PseudoVNSRL_WI_MF8_MASK, VNSRL_WI }, // 6520 + { PseudoVNSRL_WV_M1, VNSRL_WV }, // 6521 + { PseudoVNSRL_WV_M1_MASK, VNSRL_WV }, // 6522 + { PseudoVNSRL_WV_M2, VNSRL_WV }, // 6523 + { PseudoVNSRL_WV_M2_MASK, VNSRL_WV }, // 6524 + { PseudoVNSRL_WV_M4, VNSRL_WV }, // 6525 + { PseudoVNSRL_WV_M4_MASK, VNSRL_WV }, // 6526 + { PseudoVNSRL_WV_MF2, VNSRL_WV }, // 6527 + { PseudoVNSRL_WV_MF2_MASK, VNSRL_WV }, // 6528 + { PseudoVNSRL_WV_MF4, VNSRL_WV }, // 6529 + { PseudoVNSRL_WV_MF4_MASK, VNSRL_WV }, // 6530 + { PseudoVNSRL_WV_MF8, VNSRL_WV }, // 6531 + { PseudoVNSRL_WV_MF8_MASK, VNSRL_WV }, // 6532 + { PseudoVNSRL_WX_M1, VNSRL_WX }, // 6533 + { PseudoVNSRL_WX_M1_MASK, VNSRL_WX }, // 6534 + { PseudoVNSRL_WX_M2, VNSRL_WX }, // 6535 + { PseudoVNSRL_WX_M2_MASK, VNSRL_WX }, // 6536 + { PseudoVNSRL_WX_M4, VNSRL_WX }, // 6537 + { PseudoVNSRL_WX_M4_MASK, VNSRL_WX }, // 6538 + { PseudoVNSRL_WX_MF2, VNSRL_WX }, // 6539 + { PseudoVNSRL_WX_MF2_MASK, VNSRL_WX }, // 6540 + { PseudoVNSRL_WX_MF4, VNSRL_WX }, // 6541 + { PseudoVNSRL_WX_MF4_MASK, VNSRL_WX }, // 6542 + { PseudoVNSRL_WX_MF8, VNSRL_WX }, // 6543 + { PseudoVNSRL_WX_MF8_MASK, VNSRL_WX }, // 6544 + { PseudoVOR_VI_M1, VOR_VI }, // 6545 + { PseudoVOR_VI_M1_MASK, VOR_VI }, // 6546 + { PseudoVOR_VI_M2, VOR_VI }, // 6547 + { PseudoVOR_VI_M2_MASK, VOR_VI }, // 6548 + { PseudoVOR_VI_M4, VOR_VI }, // 6549 + { PseudoVOR_VI_M4_MASK, VOR_VI }, // 6550 + { PseudoVOR_VI_M8, VOR_VI }, // 6551 + { PseudoVOR_VI_M8_MASK, VOR_VI }, // 6552 + { PseudoVOR_VI_MF2, VOR_VI }, // 6553 + { PseudoVOR_VI_MF2_MASK, VOR_VI }, // 6554 + { PseudoVOR_VI_MF4, VOR_VI }, // 6555 + { PseudoVOR_VI_MF4_MASK, VOR_VI }, // 6556 + { PseudoVOR_VI_MF8, VOR_VI }, // 6557 + { PseudoVOR_VI_MF8_MASK, VOR_VI }, // 6558 + { PseudoVOR_VV_M1, VOR_VV }, // 6559 + { PseudoVOR_VV_M1_MASK, VOR_VV }, // 6560 + { PseudoVOR_VV_M2, VOR_VV }, // 6561 + { PseudoVOR_VV_M2_MASK, VOR_VV }, // 6562 + { PseudoVOR_VV_M4, VOR_VV }, // 6563 + { PseudoVOR_VV_M4_MASK, VOR_VV }, // 6564 + { PseudoVOR_VV_M8, VOR_VV }, // 6565 + { PseudoVOR_VV_M8_MASK, VOR_VV }, // 6566 + { PseudoVOR_VV_MF2, VOR_VV }, // 6567 + { PseudoVOR_VV_MF2_MASK, VOR_VV }, // 6568 + { PseudoVOR_VV_MF4, VOR_VV }, // 6569 + { PseudoVOR_VV_MF4_MASK, VOR_VV }, // 6570 + { PseudoVOR_VV_MF8, VOR_VV }, // 6571 + { PseudoVOR_VV_MF8_MASK, VOR_VV }, // 6572 + { PseudoVOR_VX_M1, VOR_VX }, // 6573 + { PseudoVOR_VX_M1_MASK, VOR_VX }, // 6574 + { PseudoVOR_VX_M2, VOR_VX }, // 6575 + { PseudoVOR_VX_M2_MASK, VOR_VX }, // 6576 + { PseudoVOR_VX_M4, VOR_VX }, // 6577 + { PseudoVOR_VX_M4_MASK, VOR_VX }, // 6578 + { PseudoVOR_VX_M8, VOR_VX }, // 6579 + { PseudoVOR_VX_M8_MASK, VOR_VX }, // 6580 + { PseudoVOR_VX_MF2, VOR_VX }, // 6581 + { PseudoVOR_VX_MF2_MASK, VOR_VX }, // 6582 + { PseudoVOR_VX_MF4, VOR_VX }, // 6583 + { PseudoVOR_VX_MF4_MASK, VOR_VX }, // 6584 + { PseudoVOR_VX_MF8, VOR_VX }, // 6585 + { PseudoVOR_VX_MF8_MASK, VOR_VX }, // 6586 + { PseudoVQMACCSU_2x8x2_M1, VQMACCSU_2x8x2 }, // 6587 + { PseudoVQMACCSU_2x8x2_M2, VQMACCSU_2x8x2 }, // 6588 + { PseudoVQMACCSU_2x8x2_M4, VQMACCSU_2x8x2 }, // 6589 + { PseudoVQMACCSU_2x8x2_M8, VQMACCSU_2x8x2 }, // 6590 + { PseudoVQMACCSU_4x8x4_M1, VQMACCSU_4x8x4 }, // 6591 + { PseudoVQMACCSU_4x8x4_M2, VQMACCSU_4x8x4 }, // 6592 + { PseudoVQMACCSU_4x8x4_M4, VQMACCSU_4x8x4 }, // 6593 + { PseudoVQMACCSU_4x8x4_MF2, VQMACCSU_4x8x4 }, // 6594 + { PseudoVQMACCUS_2x8x2_M1, VQMACCUS_2x8x2 }, // 6595 + { PseudoVQMACCUS_2x8x2_M2, VQMACCUS_2x8x2 }, // 6596 + { PseudoVQMACCUS_2x8x2_M4, VQMACCUS_2x8x2 }, // 6597 + { PseudoVQMACCUS_2x8x2_M8, VQMACCUS_2x8x2 }, // 6598 + { PseudoVQMACCUS_4x8x4_M1, VQMACCUS_4x8x4 }, // 6599 + { PseudoVQMACCUS_4x8x4_M2, VQMACCUS_4x8x4 }, // 6600 + { PseudoVQMACCUS_4x8x4_M4, VQMACCUS_4x8x4 }, // 6601 + { PseudoVQMACCUS_4x8x4_MF2, VQMACCUS_4x8x4 }, // 6602 + { PseudoVQMACCU_2x8x2_M1, VQMACCU_2x8x2 }, // 6603 + { PseudoVQMACCU_2x8x2_M2, VQMACCU_2x8x2 }, // 6604 + { PseudoVQMACCU_2x8x2_M4, VQMACCU_2x8x2 }, // 6605 + { PseudoVQMACCU_2x8x2_M8, VQMACCU_2x8x2 }, // 6606 + { PseudoVQMACCU_4x8x4_M1, VQMACCU_4x8x4 }, // 6607 + { PseudoVQMACCU_4x8x4_M2, VQMACCU_4x8x4 }, // 6608 + { PseudoVQMACCU_4x8x4_M4, VQMACCU_4x8x4 }, // 6609 + { PseudoVQMACCU_4x8x4_MF2, VQMACCU_4x8x4 }, // 6610 + { PseudoVQMACC_2x8x2_M1, VQMACC_2x8x2 }, // 6611 + { PseudoVQMACC_2x8x2_M2, VQMACC_2x8x2 }, // 6612 + { PseudoVQMACC_2x8x2_M4, VQMACC_2x8x2 }, // 6613 + { PseudoVQMACC_2x8x2_M8, VQMACC_2x8x2 }, // 6614 + { PseudoVQMACC_4x8x4_M1, VQMACC_4x8x4 }, // 6615 + { PseudoVQMACC_4x8x4_M2, VQMACC_4x8x4 }, // 6616 + { PseudoVQMACC_4x8x4_M4, VQMACC_4x8x4 }, // 6617 + { PseudoVQMACC_4x8x4_MF2, VQMACC_4x8x4 }, // 6618 + { PseudoVREDAND_VS_M1_E16, VREDAND_VS }, // 6619 + { PseudoVREDAND_VS_M1_E16_MASK, VREDAND_VS }, // 6620 + { PseudoVREDAND_VS_M1_E32, VREDAND_VS }, // 6621 + { PseudoVREDAND_VS_M1_E32_MASK, VREDAND_VS }, // 6622 + { PseudoVREDAND_VS_M1_E64, VREDAND_VS }, // 6623 + { PseudoVREDAND_VS_M1_E64_MASK, VREDAND_VS }, // 6624 + { PseudoVREDAND_VS_M1_E8, VREDAND_VS }, // 6625 + { PseudoVREDAND_VS_M1_E8_MASK, VREDAND_VS }, // 6626 + { PseudoVREDAND_VS_M2_E16, VREDAND_VS }, // 6627 + { PseudoVREDAND_VS_M2_E16_MASK, VREDAND_VS }, // 6628 + { PseudoVREDAND_VS_M2_E32, VREDAND_VS }, // 6629 + { PseudoVREDAND_VS_M2_E32_MASK, VREDAND_VS }, // 6630 + { PseudoVREDAND_VS_M2_E64, VREDAND_VS }, // 6631 + { PseudoVREDAND_VS_M2_E64_MASK, VREDAND_VS }, // 6632 + { PseudoVREDAND_VS_M2_E8, VREDAND_VS }, // 6633 + { PseudoVREDAND_VS_M2_E8_MASK, VREDAND_VS }, // 6634 + { PseudoVREDAND_VS_M4_E16, VREDAND_VS }, // 6635 + { PseudoVREDAND_VS_M4_E16_MASK, VREDAND_VS }, // 6636 + { PseudoVREDAND_VS_M4_E32, VREDAND_VS }, // 6637 + { PseudoVREDAND_VS_M4_E32_MASK, VREDAND_VS }, // 6638 + { PseudoVREDAND_VS_M4_E64, VREDAND_VS }, // 6639 + { PseudoVREDAND_VS_M4_E64_MASK, VREDAND_VS }, // 6640 + { PseudoVREDAND_VS_M4_E8, VREDAND_VS }, // 6641 + { PseudoVREDAND_VS_M4_E8_MASK, VREDAND_VS }, // 6642 + { PseudoVREDAND_VS_M8_E16, VREDAND_VS }, // 6643 + { PseudoVREDAND_VS_M8_E16_MASK, VREDAND_VS }, // 6644 + { PseudoVREDAND_VS_M8_E32, VREDAND_VS }, // 6645 + { PseudoVREDAND_VS_M8_E32_MASK, VREDAND_VS }, // 6646 + { PseudoVREDAND_VS_M8_E64, VREDAND_VS }, // 6647 + { PseudoVREDAND_VS_M8_E64_MASK, VREDAND_VS }, // 6648 + { PseudoVREDAND_VS_M8_E8, VREDAND_VS }, // 6649 + { PseudoVREDAND_VS_M8_E8_MASK, VREDAND_VS }, // 6650 + { PseudoVREDAND_VS_MF2_E16, VREDAND_VS }, // 6651 + { PseudoVREDAND_VS_MF2_E16_MASK, VREDAND_VS }, // 6652 + { PseudoVREDAND_VS_MF2_E32, VREDAND_VS }, // 6653 + { PseudoVREDAND_VS_MF2_E32_MASK, VREDAND_VS }, // 6654 + { PseudoVREDAND_VS_MF2_E8, VREDAND_VS }, // 6655 + { PseudoVREDAND_VS_MF2_E8_MASK, VREDAND_VS }, // 6656 + { PseudoVREDAND_VS_MF4_E16, VREDAND_VS }, // 6657 + { PseudoVREDAND_VS_MF4_E16_MASK, VREDAND_VS }, // 6658 + { PseudoVREDAND_VS_MF4_E8, VREDAND_VS }, // 6659 + { PseudoVREDAND_VS_MF4_E8_MASK, VREDAND_VS }, // 6660 + { PseudoVREDAND_VS_MF8_E8, VREDAND_VS }, // 6661 + { PseudoVREDAND_VS_MF8_E8_MASK, VREDAND_VS }, // 6662 + { PseudoVREDMAXU_VS_M1_E16, VREDMAXU_VS }, // 6663 + { PseudoVREDMAXU_VS_M1_E16_MASK, VREDMAXU_VS }, // 6664 + { PseudoVREDMAXU_VS_M1_E32, VREDMAXU_VS }, // 6665 + { PseudoVREDMAXU_VS_M1_E32_MASK, VREDMAXU_VS }, // 6666 + { PseudoVREDMAXU_VS_M1_E64, VREDMAXU_VS }, // 6667 + { PseudoVREDMAXU_VS_M1_E64_MASK, VREDMAXU_VS }, // 6668 + { PseudoVREDMAXU_VS_M1_E8, VREDMAXU_VS }, // 6669 + { PseudoVREDMAXU_VS_M1_E8_MASK, VREDMAXU_VS }, // 6670 + { PseudoVREDMAXU_VS_M2_E16, VREDMAXU_VS }, // 6671 + { PseudoVREDMAXU_VS_M2_E16_MASK, VREDMAXU_VS }, // 6672 + { PseudoVREDMAXU_VS_M2_E32, VREDMAXU_VS }, // 6673 + { PseudoVREDMAXU_VS_M2_E32_MASK, VREDMAXU_VS }, // 6674 + { PseudoVREDMAXU_VS_M2_E64, VREDMAXU_VS }, // 6675 + { PseudoVREDMAXU_VS_M2_E64_MASK, VREDMAXU_VS }, // 6676 + { PseudoVREDMAXU_VS_M2_E8, VREDMAXU_VS }, // 6677 + { PseudoVREDMAXU_VS_M2_E8_MASK, VREDMAXU_VS }, // 6678 + { PseudoVREDMAXU_VS_M4_E16, VREDMAXU_VS }, // 6679 + { PseudoVREDMAXU_VS_M4_E16_MASK, VREDMAXU_VS }, // 6680 + { PseudoVREDMAXU_VS_M4_E32, VREDMAXU_VS }, // 6681 + { PseudoVREDMAXU_VS_M4_E32_MASK, VREDMAXU_VS }, // 6682 + { PseudoVREDMAXU_VS_M4_E64, VREDMAXU_VS }, // 6683 + { PseudoVREDMAXU_VS_M4_E64_MASK, VREDMAXU_VS }, // 6684 + { PseudoVREDMAXU_VS_M4_E8, VREDMAXU_VS }, // 6685 + { PseudoVREDMAXU_VS_M4_E8_MASK, VREDMAXU_VS }, // 6686 + { PseudoVREDMAXU_VS_M8_E16, VREDMAXU_VS }, // 6687 + { PseudoVREDMAXU_VS_M8_E16_MASK, VREDMAXU_VS }, // 6688 + { PseudoVREDMAXU_VS_M8_E32, VREDMAXU_VS }, // 6689 + { PseudoVREDMAXU_VS_M8_E32_MASK, VREDMAXU_VS }, // 6690 + { PseudoVREDMAXU_VS_M8_E64, VREDMAXU_VS }, // 6691 + { PseudoVREDMAXU_VS_M8_E64_MASK, VREDMAXU_VS }, // 6692 + { PseudoVREDMAXU_VS_M8_E8, VREDMAXU_VS }, // 6693 + { PseudoVREDMAXU_VS_M8_E8_MASK, VREDMAXU_VS }, // 6694 + { PseudoVREDMAXU_VS_MF2_E16, VREDMAXU_VS }, // 6695 + { PseudoVREDMAXU_VS_MF2_E16_MASK, VREDMAXU_VS }, // 6696 + { PseudoVREDMAXU_VS_MF2_E32, VREDMAXU_VS }, // 6697 + { PseudoVREDMAXU_VS_MF2_E32_MASK, VREDMAXU_VS }, // 6698 + { PseudoVREDMAXU_VS_MF2_E8, VREDMAXU_VS }, // 6699 + { PseudoVREDMAXU_VS_MF2_E8_MASK, VREDMAXU_VS }, // 6700 + { PseudoVREDMAXU_VS_MF4_E16, VREDMAXU_VS }, // 6701 + { PseudoVREDMAXU_VS_MF4_E16_MASK, VREDMAXU_VS }, // 6702 + { PseudoVREDMAXU_VS_MF4_E8, VREDMAXU_VS }, // 6703 + { PseudoVREDMAXU_VS_MF4_E8_MASK, VREDMAXU_VS }, // 6704 + { PseudoVREDMAXU_VS_MF8_E8, VREDMAXU_VS }, // 6705 + { PseudoVREDMAXU_VS_MF8_E8_MASK, VREDMAXU_VS }, // 6706 + { PseudoVREDMAX_VS_M1_E16, VREDMAX_VS }, // 6707 + { PseudoVREDMAX_VS_M1_E16_MASK, VREDMAX_VS }, // 6708 + { PseudoVREDMAX_VS_M1_E32, VREDMAX_VS }, // 6709 + { PseudoVREDMAX_VS_M1_E32_MASK, VREDMAX_VS }, // 6710 + { PseudoVREDMAX_VS_M1_E64, VREDMAX_VS }, // 6711 + { PseudoVREDMAX_VS_M1_E64_MASK, VREDMAX_VS }, // 6712 + { PseudoVREDMAX_VS_M1_E8, VREDMAX_VS }, // 6713 + { PseudoVREDMAX_VS_M1_E8_MASK, VREDMAX_VS }, // 6714 + { PseudoVREDMAX_VS_M2_E16, VREDMAX_VS }, // 6715 + { PseudoVREDMAX_VS_M2_E16_MASK, VREDMAX_VS }, // 6716 + { PseudoVREDMAX_VS_M2_E32, VREDMAX_VS }, // 6717 + { PseudoVREDMAX_VS_M2_E32_MASK, VREDMAX_VS }, // 6718 + { PseudoVREDMAX_VS_M2_E64, VREDMAX_VS }, // 6719 + { PseudoVREDMAX_VS_M2_E64_MASK, VREDMAX_VS }, // 6720 + { PseudoVREDMAX_VS_M2_E8, VREDMAX_VS }, // 6721 + { PseudoVREDMAX_VS_M2_E8_MASK, VREDMAX_VS }, // 6722 + { PseudoVREDMAX_VS_M4_E16, VREDMAX_VS }, // 6723 + { PseudoVREDMAX_VS_M4_E16_MASK, VREDMAX_VS }, // 6724 + { PseudoVREDMAX_VS_M4_E32, VREDMAX_VS }, // 6725 + { PseudoVREDMAX_VS_M4_E32_MASK, VREDMAX_VS }, // 6726 + { PseudoVREDMAX_VS_M4_E64, VREDMAX_VS }, // 6727 + { PseudoVREDMAX_VS_M4_E64_MASK, VREDMAX_VS }, // 6728 + { PseudoVREDMAX_VS_M4_E8, VREDMAX_VS }, // 6729 + { PseudoVREDMAX_VS_M4_E8_MASK, VREDMAX_VS }, // 6730 + { PseudoVREDMAX_VS_M8_E16, VREDMAX_VS }, // 6731 + { PseudoVREDMAX_VS_M8_E16_MASK, VREDMAX_VS }, // 6732 + { PseudoVREDMAX_VS_M8_E32, VREDMAX_VS }, // 6733 + { PseudoVREDMAX_VS_M8_E32_MASK, VREDMAX_VS }, // 6734 + { PseudoVREDMAX_VS_M8_E64, VREDMAX_VS }, // 6735 + { PseudoVREDMAX_VS_M8_E64_MASK, VREDMAX_VS }, // 6736 + { PseudoVREDMAX_VS_M8_E8, VREDMAX_VS }, // 6737 + { PseudoVREDMAX_VS_M8_E8_MASK, VREDMAX_VS }, // 6738 + { PseudoVREDMAX_VS_MF2_E16, VREDMAX_VS }, // 6739 + { PseudoVREDMAX_VS_MF2_E16_MASK, VREDMAX_VS }, // 6740 + { PseudoVREDMAX_VS_MF2_E32, VREDMAX_VS }, // 6741 + { PseudoVREDMAX_VS_MF2_E32_MASK, VREDMAX_VS }, // 6742 + { PseudoVREDMAX_VS_MF2_E8, VREDMAX_VS }, // 6743 + { PseudoVREDMAX_VS_MF2_E8_MASK, VREDMAX_VS }, // 6744 + { PseudoVREDMAX_VS_MF4_E16, VREDMAX_VS }, // 6745 + { PseudoVREDMAX_VS_MF4_E16_MASK, VREDMAX_VS }, // 6746 + { PseudoVREDMAX_VS_MF4_E8, VREDMAX_VS }, // 6747 + { PseudoVREDMAX_VS_MF4_E8_MASK, VREDMAX_VS }, // 6748 + { PseudoVREDMAX_VS_MF8_E8, VREDMAX_VS }, // 6749 + { PseudoVREDMAX_VS_MF8_E8_MASK, VREDMAX_VS }, // 6750 + { PseudoVREDMINU_VS_M1_E16, VREDMINU_VS }, // 6751 + { PseudoVREDMINU_VS_M1_E16_MASK, VREDMINU_VS }, // 6752 + { PseudoVREDMINU_VS_M1_E32, VREDMINU_VS }, // 6753 + { PseudoVREDMINU_VS_M1_E32_MASK, VREDMINU_VS }, // 6754 + { PseudoVREDMINU_VS_M1_E64, VREDMINU_VS }, // 6755 + { PseudoVREDMINU_VS_M1_E64_MASK, VREDMINU_VS }, // 6756 + { PseudoVREDMINU_VS_M1_E8, VREDMINU_VS }, // 6757 + { PseudoVREDMINU_VS_M1_E8_MASK, VREDMINU_VS }, // 6758 + { PseudoVREDMINU_VS_M2_E16, VREDMINU_VS }, // 6759 + { PseudoVREDMINU_VS_M2_E16_MASK, VREDMINU_VS }, // 6760 + { PseudoVREDMINU_VS_M2_E32, VREDMINU_VS }, // 6761 + { PseudoVREDMINU_VS_M2_E32_MASK, VREDMINU_VS }, // 6762 + { PseudoVREDMINU_VS_M2_E64, VREDMINU_VS }, // 6763 + { PseudoVREDMINU_VS_M2_E64_MASK, VREDMINU_VS }, // 6764 + { PseudoVREDMINU_VS_M2_E8, VREDMINU_VS }, // 6765 + { PseudoVREDMINU_VS_M2_E8_MASK, VREDMINU_VS }, // 6766 + { PseudoVREDMINU_VS_M4_E16, VREDMINU_VS }, // 6767 + { PseudoVREDMINU_VS_M4_E16_MASK, VREDMINU_VS }, // 6768 + { PseudoVREDMINU_VS_M4_E32, VREDMINU_VS }, // 6769 + { PseudoVREDMINU_VS_M4_E32_MASK, VREDMINU_VS }, // 6770 + { PseudoVREDMINU_VS_M4_E64, VREDMINU_VS }, // 6771 + { PseudoVREDMINU_VS_M4_E64_MASK, VREDMINU_VS }, // 6772 + { PseudoVREDMINU_VS_M4_E8, VREDMINU_VS }, // 6773 + { PseudoVREDMINU_VS_M4_E8_MASK, VREDMINU_VS }, // 6774 + { PseudoVREDMINU_VS_M8_E16, VREDMINU_VS }, // 6775 + { PseudoVREDMINU_VS_M8_E16_MASK, VREDMINU_VS }, // 6776 + { PseudoVREDMINU_VS_M8_E32, VREDMINU_VS }, // 6777 + { PseudoVREDMINU_VS_M8_E32_MASK, VREDMINU_VS }, // 6778 + { PseudoVREDMINU_VS_M8_E64, VREDMINU_VS }, // 6779 + { PseudoVREDMINU_VS_M8_E64_MASK, VREDMINU_VS }, // 6780 + { PseudoVREDMINU_VS_M8_E8, VREDMINU_VS }, // 6781 + { PseudoVREDMINU_VS_M8_E8_MASK, VREDMINU_VS }, // 6782 + { PseudoVREDMINU_VS_MF2_E16, VREDMINU_VS }, // 6783 + { PseudoVREDMINU_VS_MF2_E16_MASK, VREDMINU_VS }, // 6784 + { PseudoVREDMINU_VS_MF2_E32, VREDMINU_VS }, // 6785 + { PseudoVREDMINU_VS_MF2_E32_MASK, VREDMINU_VS }, // 6786 + { PseudoVREDMINU_VS_MF2_E8, VREDMINU_VS }, // 6787 + { PseudoVREDMINU_VS_MF2_E8_MASK, VREDMINU_VS }, // 6788 + { PseudoVREDMINU_VS_MF4_E16, VREDMINU_VS }, // 6789 + { PseudoVREDMINU_VS_MF4_E16_MASK, VREDMINU_VS }, // 6790 + { PseudoVREDMINU_VS_MF4_E8, VREDMINU_VS }, // 6791 + { PseudoVREDMINU_VS_MF4_E8_MASK, VREDMINU_VS }, // 6792 + { PseudoVREDMINU_VS_MF8_E8, VREDMINU_VS }, // 6793 + { PseudoVREDMINU_VS_MF8_E8_MASK, VREDMINU_VS }, // 6794 + { PseudoVREDMIN_VS_M1_E16, VREDMIN_VS }, // 6795 + { PseudoVREDMIN_VS_M1_E16_MASK, VREDMIN_VS }, // 6796 + { PseudoVREDMIN_VS_M1_E32, VREDMIN_VS }, // 6797 + { PseudoVREDMIN_VS_M1_E32_MASK, VREDMIN_VS }, // 6798 + { PseudoVREDMIN_VS_M1_E64, VREDMIN_VS }, // 6799 + { PseudoVREDMIN_VS_M1_E64_MASK, VREDMIN_VS }, // 6800 + { PseudoVREDMIN_VS_M1_E8, VREDMIN_VS }, // 6801 + { PseudoVREDMIN_VS_M1_E8_MASK, VREDMIN_VS }, // 6802 + { PseudoVREDMIN_VS_M2_E16, VREDMIN_VS }, // 6803 + { PseudoVREDMIN_VS_M2_E16_MASK, VREDMIN_VS }, // 6804 + { PseudoVREDMIN_VS_M2_E32, VREDMIN_VS }, // 6805 + { PseudoVREDMIN_VS_M2_E32_MASK, VREDMIN_VS }, // 6806 + { PseudoVREDMIN_VS_M2_E64, VREDMIN_VS }, // 6807 + { PseudoVREDMIN_VS_M2_E64_MASK, VREDMIN_VS }, // 6808 + { PseudoVREDMIN_VS_M2_E8, VREDMIN_VS }, // 6809 + { PseudoVREDMIN_VS_M2_E8_MASK, VREDMIN_VS }, // 6810 + { PseudoVREDMIN_VS_M4_E16, VREDMIN_VS }, // 6811 + { PseudoVREDMIN_VS_M4_E16_MASK, VREDMIN_VS }, // 6812 + { PseudoVREDMIN_VS_M4_E32, VREDMIN_VS }, // 6813 + { PseudoVREDMIN_VS_M4_E32_MASK, VREDMIN_VS }, // 6814 + { PseudoVREDMIN_VS_M4_E64, VREDMIN_VS }, // 6815 + { PseudoVREDMIN_VS_M4_E64_MASK, VREDMIN_VS }, // 6816 + { PseudoVREDMIN_VS_M4_E8, VREDMIN_VS }, // 6817 + { PseudoVREDMIN_VS_M4_E8_MASK, VREDMIN_VS }, // 6818 + { PseudoVREDMIN_VS_M8_E16, VREDMIN_VS }, // 6819 + { PseudoVREDMIN_VS_M8_E16_MASK, VREDMIN_VS }, // 6820 + { PseudoVREDMIN_VS_M8_E32, VREDMIN_VS }, // 6821 + { PseudoVREDMIN_VS_M8_E32_MASK, VREDMIN_VS }, // 6822 + { PseudoVREDMIN_VS_M8_E64, VREDMIN_VS }, // 6823 + { PseudoVREDMIN_VS_M8_E64_MASK, VREDMIN_VS }, // 6824 + { PseudoVREDMIN_VS_M8_E8, VREDMIN_VS }, // 6825 + { PseudoVREDMIN_VS_M8_E8_MASK, VREDMIN_VS }, // 6826 + { PseudoVREDMIN_VS_MF2_E16, VREDMIN_VS }, // 6827 + { PseudoVREDMIN_VS_MF2_E16_MASK, VREDMIN_VS }, // 6828 + { PseudoVREDMIN_VS_MF2_E32, VREDMIN_VS }, // 6829 + { PseudoVREDMIN_VS_MF2_E32_MASK, VREDMIN_VS }, // 6830 + { PseudoVREDMIN_VS_MF2_E8, VREDMIN_VS }, // 6831 + { PseudoVREDMIN_VS_MF2_E8_MASK, VREDMIN_VS }, // 6832 + { PseudoVREDMIN_VS_MF4_E16, VREDMIN_VS }, // 6833 + { PseudoVREDMIN_VS_MF4_E16_MASK, VREDMIN_VS }, // 6834 + { PseudoVREDMIN_VS_MF4_E8, VREDMIN_VS }, // 6835 + { PseudoVREDMIN_VS_MF4_E8_MASK, VREDMIN_VS }, // 6836 + { PseudoVREDMIN_VS_MF8_E8, VREDMIN_VS }, // 6837 + { PseudoVREDMIN_VS_MF8_E8_MASK, VREDMIN_VS }, // 6838 + { PseudoVREDOR_VS_M1_E16, VREDOR_VS }, // 6839 + { PseudoVREDOR_VS_M1_E16_MASK, VREDOR_VS }, // 6840 + { PseudoVREDOR_VS_M1_E32, VREDOR_VS }, // 6841 + { PseudoVREDOR_VS_M1_E32_MASK, VREDOR_VS }, // 6842 + { PseudoVREDOR_VS_M1_E64, VREDOR_VS }, // 6843 + { PseudoVREDOR_VS_M1_E64_MASK, VREDOR_VS }, // 6844 + { PseudoVREDOR_VS_M1_E8, VREDOR_VS }, // 6845 + { PseudoVREDOR_VS_M1_E8_MASK, VREDOR_VS }, // 6846 + { PseudoVREDOR_VS_M2_E16, VREDOR_VS }, // 6847 + { PseudoVREDOR_VS_M2_E16_MASK, VREDOR_VS }, // 6848 + { PseudoVREDOR_VS_M2_E32, VREDOR_VS }, // 6849 + { PseudoVREDOR_VS_M2_E32_MASK, VREDOR_VS }, // 6850 + { PseudoVREDOR_VS_M2_E64, VREDOR_VS }, // 6851 + { PseudoVREDOR_VS_M2_E64_MASK, VREDOR_VS }, // 6852 + { PseudoVREDOR_VS_M2_E8, VREDOR_VS }, // 6853 + { PseudoVREDOR_VS_M2_E8_MASK, VREDOR_VS }, // 6854 + { PseudoVREDOR_VS_M4_E16, VREDOR_VS }, // 6855 + { PseudoVREDOR_VS_M4_E16_MASK, VREDOR_VS }, // 6856 + { PseudoVREDOR_VS_M4_E32, VREDOR_VS }, // 6857 + { PseudoVREDOR_VS_M4_E32_MASK, VREDOR_VS }, // 6858 + { PseudoVREDOR_VS_M4_E64, VREDOR_VS }, // 6859 + { PseudoVREDOR_VS_M4_E64_MASK, VREDOR_VS }, // 6860 + { PseudoVREDOR_VS_M4_E8, VREDOR_VS }, // 6861 + { PseudoVREDOR_VS_M4_E8_MASK, VREDOR_VS }, // 6862 + { PseudoVREDOR_VS_M8_E16, VREDOR_VS }, // 6863 + { PseudoVREDOR_VS_M8_E16_MASK, VREDOR_VS }, // 6864 + { PseudoVREDOR_VS_M8_E32, VREDOR_VS }, // 6865 + { PseudoVREDOR_VS_M8_E32_MASK, VREDOR_VS }, // 6866 + { PseudoVREDOR_VS_M8_E64, VREDOR_VS }, // 6867 + { PseudoVREDOR_VS_M8_E64_MASK, VREDOR_VS }, // 6868 + { PseudoVREDOR_VS_M8_E8, VREDOR_VS }, // 6869 + { PseudoVREDOR_VS_M8_E8_MASK, VREDOR_VS }, // 6870 + { PseudoVREDOR_VS_MF2_E16, VREDOR_VS }, // 6871 + { PseudoVREDOR_VS_MF2_E16_MASK, VREDOR_VS }, // 6872 + { PseudoVREDOR_VS_MF2_E32, VREDOR_VS }, // 6873 + { PseudoVREDOR_VS_MF2_E32_MASK, VREDOR_VS }, // 6874 + { PseudoVREDOR_VS_MF2_E8, VREDOR_VS }, // 6875 + { PseudoVREDOR_VS_MF2_E8_MASK, VREDOR_VS }, // 6876 + { PseudoVREDOR_VS_MF4_E16, VREDOR_VS }, // 6877 + { PseudoVREDOR_VS_MF4_E16_MASK, VREDOR_VS }, // 6878 + { PseudoVREDOR_VS_MF4_E8, VREDOR_VS }, // 6879 + { PseudoVREDOR_VS_MF4_E8_MASK, VREDOR_VS }, // 6880 + { PseudoVREDOR_VS_MF8_E8, VREDOR_VS }, // 6881 + { PseudoVREDOR_VS_MF8_E8_MASK, VREDOR_VS }, // 6882 + { PseudoVREDSUM_VS_M1_E16, VREDSUM_VS }, // 6883 + { PseudoVREDSUM_VS_M1_E16_MASK, VREDSUM_VS }, // 6884 + { PseudoVREDSUM_VS_M1_E32, VREDSUM_VS }, // 6885 + { PseudoVREDSUM_VS_M1_E32_MASK, VREDSUM_VS }, // 6886 + { PseudoVREDSUM_VS_M1_E64, VREDSUM_VS }, // 6887 + { PseudoVREDSUM_VS_M1_E64_MASK, VREDSUM_VS }, // 6888 + { PseudoVREDSUM_VS_M1_E8, VREDSUM_VS }, // 6889 + { PseudoVREDSUM_VS_M1_E8_MASK, VREDSUM_VS }, // 6890 + { PseudoVREDSUM_VS_M2_E16, VREDSUM_VS }, // 6891 + { PseudoVREDSUM_VS_M2_E16_MASK, VREDSUM_VS }, // 6892 + { PseudoVREDSUM_VS_M2_E32, VREDSUM_VS }, // 6893 + { PseudoVREDSUM_VS_M2_E32_MASK, VREDSUM_VS }, // 6894 + { PseudoVREDSUM_VS_M2_E64, VREDSUM_VS }, // 6895 + { PseudoVREDSUM_VS_M2_E64_MASK, VREDSUM_VS }, // 6896 + { PseudoVREDSUM_VS_M2_E8, VREDSUM_VS }, // 6897 + { PseudoVREDSUM_VS_M2_E8_MASK, VREDSUM_VS }, // 6898 + { PseudoVREDSUM_VS_M4_E16, VREDSUM_VS }, // 6899 + { PseudoVREDSUM_VS_M4_E16_MASK, VREDSUM_VS }, // 6900 + { PseudoVREDSUM_VS_M4_E32, VREDSUM_VS }, // 6901 + { PseudoVREDSUM_VS_M4_E32_MASK, VREDSUM_VS }, // 6902 + { PseudoVREDSUM_VS_M4_E64, VREDSUM_VS }, // 6903 + { PseudoVREDSUM_VS_M4_E64_MASK, VREDSUM_VS }, // 6904 + { PseudoVREDSUM_VS_M4_E8, VREDSUM_VS }, // 6905 + { PseudoVREDSUM_VS_M4_E8_MASK, VREDSUM_VS }, // 6906 + { PseudoVREDSUM_VS_M8_E16, VREDSUM_VS }, // 6907 + { PseudoVREDSUM_VS_M8_E16_MASK, VREDSUM_VS }, // 6908 + { PseudoVREDSUM_VS_M8_E32, VREDSUM_VS }, // 6909 + { PseudoVREDSUM_VS_M8_E32_MASK, VREDSUM_VS }, // 6910 + { PseudoVREDSUM_VS_M8_E64, VREDSUM_VS }, // 6911 + { PseudoVREDSUM_VS_M8_E64_MASK, VREDSUM_VS }, // 6912 + { PseudoVREDSUM_VS_M8_E8, VREDSUM_VS }, // 6913 + { PseudoVREDSUM_VS_M8_E8_MASK, VREDSUM_VS }, // 6914 + { PseudoVREDSUM_VS_MF2_E16, VREDSUM_VS }, // 6915 + { PseudoVREDSUM_VS_MF2_E16_MASK, VREDSUM_VS }, // 6916 + { PseudoVREDSUM_VS_MF2_E32, VREDSUM_VS }, // 6917 + { PseudoVREDSUM_VS_MF2_E32_MASK, VREDSUM_VS }, // 6918 + { PseudoVREDSUM_VS_MF2_E8, VREDSUM_VS }, // 6919 + { PseudoVREDSUM_VS_MF2_E8_MASK, VREDSUM_VS }, // 6920 + { PseudoVREDSUM_VS_MF4_E16, VREDSUM_VS }, // 6921 + { PseudoVREDSUM_VS_MF4_E16_MASK, VREDSUM_VS }, // 6922 + { PseudoVREDSUM_VS_MF4_E8, VREDSUM_VS }, // 6923 + { PseudoVREDSUM_VS_MF4_E8_MASK, VREDSUM_VS }, // 6924 + { PseudoVREDSUM_VS_MF8_E8, VREDSUM_VS }, // 6925 + { PseudoVREDSUM_VS_MF8_E8_MASK, VREDSUM_VS }, // 6926 + { PseudoVREDXOR_VS_M1_E16, VREDXOR_VS }, // 6927 + { PseudoVREDXOR_VS_M1_E16_MASK, VREDXOR_VS }, // 6928 + { PseudoVREDXOR_VS_M1_E32, VREDXOR_VS }, // 6929 + { PseudoVREDXOR_VS_M1_E32_MASK, VREDXOR_VS }, // 6930 + { PseudoVREDXOR_VS_M1_E64, VREDXOR_VS }, // 6931 + { PseudoVREDXOR_VS_M1_E64_MASK, VREDXOR_VS }, // 6932 + { PseudoVREDXOR_VS_M1_E8, VREDXOR_VS }, // 6933 + { PseudoVREDXOR_VS_M1_E8_MASK, VREDXOR_VS }, // 6934 + { PseudoVREDXOR_VS_M2_E16, VREDXOR_VS }, // 6935 + { PseudoVREDXOR_VS_M2_E16_MASK, VREDXOR_VS }, // 6936 + { PseudoVREDXOR_VS_M2_E32, VREDXOR_VS }, // 6937 + { PseudoVREDXOR_VS_M2_E32_MASK, VREDXOR_VS }, // 6938 + { PseudoVREDXOR_VS_M2_E64, VREDXOR_VS }, // 6939 + { PseudoVREDXOR_VS_M2_E64_MASK, VREDXOR_VS }, // 6940 + { PseudoVREDXOR_VS_M2_E8, VREDXOR_VS }, // 6941 + { PseudoVREDXOR_VS_M2_E8_MASK, VREDXOR_VS }, // 6942 + { PseudoVREDXOR_VS_M4_E16, VREDXOR_VS }, // 6943 + { PseudoVREDXOR_VS_M4_E16_MASK, VREDXOR_VS }, // 6944 + { PseudoVREDXOR_VS_M4_E32, VREDXOR_VS }, // 6945 + { PseudoVREDXOR_VS_M4_E32_MASK, VREDXOR_VS }, // 6946 + { PseudoVREDXOR_VS_M4_E64, VREDXOR_VS }, // 6947 + { PseudoVREDXOR_VS_M4_E64_MASK, VREDXOR_VS }, // 6948 + { PseudoVREDXOR_VS_M4_E8, VREDXOR_VS }, // 6949 + { PseudoVREDXOR_VS_M4_E8_MASK, VREDXOR_VS }, // 6950 + { PseudoVREDXOR_VS_M8_E16, VREDXOR_VS }, // 6951 + { PseudoVREDXOR_VS_M8_E16_MASK, VREDXOR_VS }, // 6952 + { PseudoVREDXOR_VS_M8_E32, VREDXOR_VS }, // 6953 + { PseudoVREDXOR_VS_M8_E32_MASK, VREDXOR_VS }, // 6954 + { PseudoVREDXOR_VS_M8_E64, VREDXOR_VS }, // 6955 + { PseudoVREDXOR_VS_M8_E64_MASK, VREDXOR_VS }, // 6956 + { PseudoVREDXOR_VS_M8_E8, VREDXOR_VS }, // 6957 + { PseudoVREDXOR_VS_M8_E8_MASK, VREDXOR_VS }, // 6958 + { PseudoVREDXOR_VS_MF2_E16, VREDXOR_VS }, // 6959 + { PseudoVREDXOR_VS_MF2_E16_MASK, VREDXOR_VS }, // 6960 + { PseudoVREDXOR_VS_MF2_E32, VREDXOR_VS }, // 6961 + { PseudoVREDXOR_VS_MF2_E32_MASK, VREDXOR_VS }, // 6962 + { PseudoVREDXOR_VS_MF2_E8, VREDXOR_VS }, // 6963 + { PseudoVREDXOR_VS_MF2_E8_MASK, VREDXOR_VS }, // 6964 + { PseudoVREDXOR_VS_MF4_E16, VREDXOR_VS }, // 6965 + { PseudoVREDXOR_VS_MF4_E16_MASK, VREDXOR_VS }, // 6966 + { PseudoVREDXOR_VS_MF4_E8, VREDXOR_VS }, // 6967 + { PseudoVREDXOR_VS_MF4_E8_MASK, VREDXOR_VS }, // 6968 + { PseudoVREDXOR_VS_MF8_E8, VREDXOR_VS }, // 6969 + { PseudoVREDXOR_VS_MF8_E8_MASK, VREDXOR_VS }, // 6970 + { PseudoVREMU_VV_M1_E16, VREMU_VV }, // 6971 + { PseudoVREMU_VV_M1_E16_MASK, VREMU_VV }, // 6972 + { PseudoVREMU_VV_M1_E32, VREMU_VV }, // 6973 + { PseudoVREMU_VV_M1_E32_MASK, VREMU_VV }, // 6974 + { PseudoVREMU_VV_M1_E64, VREMU_VV }, // 6975 + { PseudoVREMU_VV_M1_E64_MASK, VREMU_VV }, // 6976 + { PseudoVREMU_VV_M1_E8, VREMU_VV }, // 6977 + { PseudoVREMU_VV_M1_E8_MASK, VREMU_VV }, // 6978 + { PseudoVREMU_VV_M2_E16, VREMU_VV }, // 6979 + { PseudoVREMU_VV_M2_E16_MASK, VREMU_VV }, // 6980 + { PseudoVREMU_VV_M2_E32, VREMU_VV }, // 6981 + { PseudoVREMU_VV_M2_E32_MASK, VREMU_VV }, // 6982 + { PseudoVREMU_VV_M2_E64, VREMU_VV }, // 6983 + { PseudoVREMU_VV_M2_E64_MASK, VREMU_VV }, // 6984 + { PseudoVREMU_VV_M2_E8, VREMU_VV }, // 6985 + { PseudoVREMU_VV_M2_E8_MASK, VREMU_VV }, // 6986 + { PseudoVREMU_VV_M4_E16, VREMU_VV }, // 6987 + { PseudoVREMU_VV_M4_E16_MASK, VREMU_VV }, // 6988 + { PseudoVREMU_VV_M4_E32, VREMU_VV }, // 6989 + { PseudoVREMU_VV_M4_E32_MASK, VREMU_VV }, // 6990 + { PseudoVREMU_VV_M4_E64, VREMU_VV }, // 6991 + { PseudoVREMU_VV_M4_E64_MASK, VREMU_VV }, // 6992 + { PseudoVREMU_VV_M4_E8, VREMU_VV }, // 6993 + { PseudoVREMU_VV_M4_E8_MASK, VREMU_VV }, // 6994 + { PseudoVREMU_VV_M8_E16, VREMU_VV }, // 6995 + { PseudoVREMU_VV_M8_E16_MASK, VREMU_VV }, // 6996 + { PseudoVREMU_VV_M8_E32, VREMU_VV }, // 6997 + { PseudoVREMU_VV_M8_E32_MASK, VREMU_VV }, // 6998 + { PseudoVREMU_VV_M8_E64, VREMU_VV }, // 6999 + { PseudoVREMU_VV_M8_E64_MASK, VREMU_VV }, // 7000 + { PseudoVREMU_VV_M8_E8, VREMU_VV }, // 7001 + { PseudoVREMU_VV_M8_E8_MASK, VREMU_VV }, // 7002 + { PseudoVREMU_VV_MF2_E16, VREMU_VV }, // 7003 + { PseudoVREMU_VV_MF2_E16_MASK, VREMU_VV }, // 7004 + { PseudoVREMU_VV_MF2_E32, VREMU_VV }, // 7005 + { PseudoVREMU_VV_MF2_E32_MASK, VREMU_VV }, // 7006 + { PseudoVREMU_VV_MF2_E8, VREMU_VV }, // 7007 + { PseudoVREMU_VV_MF2_E8_MASK, VREMU_VV }, // 7008 + { PseudoVREMU_VV_MF4_E16, VREMU_VV }, // 7009 + { PseudoVREMU_VV_MF4_E16_MASK, VREMU_VV }, // 7010 + { PseudoVREMU_VV_MF4_E8, VREMU_VV }, // 7011 + { PseudoVREMU_VV_MF4_E8_MASK, VREMU_VV }, // 7012 + { PseudoVREMU_VV_MF8_E8, VREMU_VV }, // 7013 + { PseudoVREMU_VV_MF8_E8_MASK, VREMU_VV }, // 7014 + { PseudoVREMU_VX_M1_E16, VREMU_VX }, // 7015 + { PseudoVREMU_VX_M1_E16_MASK, VREMU_VX }, // 7016 + { PseudoVREMU_VX_M1_E32, VREMU_VX }, // 7017 + { PseudoVREMU_VX_M1_E32_MASK, VREMU_VX }, // 7018 + { PseudoVREMU_VX_M1_E64, VREMU_VX }, // 7019 + { PseudoVREMU_VX_M1_E64_MASK, VREMU_VX }, // 7020 + { PseudoVREMU_VX_M1_E8, VREMU_VX }, // 7021 + { PseudoVREMU_VX_M1_E8_MASK, VREMU_VX }, // 7022 + { PseudoVREMU_VX_M2_E16, VREMU_VX }, // 7023 + { PseudoVREMU_VX_M2_E16_MASK, VREMU_VX }, // 7024 + { PseudoVREMU_VX_M2_E32, VREMU_VX }, // 7025 + { PseudoVREMU_VX_M2_E32_MASK, VREMU_VX }, // 7026 + { PseudoVREMU_VX_M2_E64, VREMU_VX }, // 7027 + { PseudoVREMU_VX_M2_E64_MASK, VREMU_VX }, // 7028 + { PseudoVREMU_VX_M2_E8, VREMU_VX }, // 7029 + { PseudoVREMU_VX_M2_E8_MASK, VREMU_VX }, // 7030 + { PseudoVREMU_VX_M4_E16, VREMU_VX }, // 7031 + { PseudoVREMU_VX_M4_E16_MASK, VREMU_VX }, // 7032 + { PseudoVREMU_VX_M4_E32, VREMU_VX }, // 7033 + { PseudoVREMU_VX_M4_E32_MASK, VREMU_VX }, // 7034 + { PseudoVREMU_VX_M4_E64, VREMU_VX }, // 7035 + { PseudoVREMU_VX_M4_E64_MASK, VREMU_VX }, // 7036 + { PseudoVREMU_VX_M4_E8, VREMU_VX }, // 7037 + { PseudoVREMU_VX_M4_E8_MASK, VREMU_VX }, // 7038 + { PseudoVREMU_VX_M8_E16, VREMU_VX }, // 7039 + { PseudoVREMU_VX_M8_E16_MASK, VREMU_VX }, // 7040 + { PseudoVREMU_VX_M8_E32, VREMU_VX }, // 7041 + { PseudoVREMU_VX_M8_E32_MASK, VREMU_VX }, // 7042 + { PseudoVREMU_VX_M8_E64, VREMU_VX }, // 7043 + { PseudoVREMU_VX_M8_E64_MASK, VREMU_VX }, // 7044 + { PseudoVREMU_VX_M8_E8, VREMU_VX }, // 7045 + { PseudoVREMU_VX_M8_E8_MASK, VREMU_VX }, // 7046 + { PseudoVREMU_VX_MF2_E16, VREMU_VX }, // 7047 + { PseudoVREMU_VX_MF2_E16_MASK, VREMU_VX }, // 7048 + { PseudoVREMU_VX_MF2_E32, VREMU_VX }, // 7049 + { PseudoVREMU_VX_MF2_E32_MASK, VREMU_VX }, // 7050 + { PseudoVREMU_VX_MF2_E8, VREMU_VX }, // 7051 + { PseudoVREMU_VX_MF2_E8_MASK, VREMU_VX }, // 7052 + { PseudoVREMU_VX_MF4_E16, VREMU_VX }, // 7053 + { PseudoVREMU_VX_MF4_E16_MASK, VREMU_VX }, // 7054 + { PseudoVREMU_VX_MF4_E8, VREMU_VX }, // 7055 + { PseudoVREMU_VX_MF4_E8_MASK, VREMU_VX }, // 7056 + { PseudoVREMU_VX_MF8_E8, VREMU_VX }, // 7057 + { PseudoVREMU_VX_MF8_E8_MASK, VREMU_VX }, // 7058 + { PseudoVREM_VV_M1_E16, VREM_VV }, // 7059 + { PseudoVREM_VV_M1_E16_MASK, VREM_VV }, // 7060 + { PseudoVREM_VV_M1_E32, VREM_VV }, // 7061 + { PseudoVREM_VV_M1_E32_MASK, VREM_VV }, // 7062 + { PseudoVREM_VV_M1_E64, VREM_VV }, // 7063 + { PseudoVREM_VV_M1_E64_MASK, VREM_VV }, // 7064 + { PseudoVREM_VV_M1_E8, VREM_VV }, // 7065 + { PseudoVREM_VV_M1_E8_MASK, VREM_VV }, // 7066 + { PseudoVREM_VV_M2_E16, VREM_VV }, // 7067 + { PseudoVREM_VV_M2_E16_MASK, VREM_VV }, // 7068 + { PseudoVREM_VV_M2_E32, VREM_VV }, // 7069 + { PseudoVREM_VV_M2_E32_MASK, VREM_VV }, // 7070 + { PseudoVREM_VV_M2_E64, VREM_VV }, // 7071 + { PseudoVREM_VV_M2_E64_MASK, VREM_VV }, // 7072 + { PseudoVREM_VV_M2_E8, VREM_VV }, // 7073 + { PseudoVREM_VV_M2_E8_MASK, VREM_VV }, // 7074 + { PseudoVREM_VV_M4_E16, VREM_VV }, // 7075 + { PseudoVREM_VV_M4_E16_MASK, VREM_VV }, // 7076 + { PseudoVREM_VV_M4_E32, VREM_VV }, // 7077 + { PseudoVREM_VV_M4_E32_MASK, VREM_VV }, // 7078 + { PseudoVREM_VV_M4_E64, VREM_VV }, // 7079 + { PseudoVREM_VV_M4_E64_MASK, VREM_VV }, // 7080 + { PseudoVREM_VV_M4_E8, VREM_VV }, // 7081 + { PseudoVREM_VV_M4_E8_MASK, VREM_VV }, // 7082 + { PseudoVREM_VV_M8_E16, VREM_VV }, // 7083 + { PseudoVREM_VV_M8_E16_MASK, VREM_VV }, // 7084 + { PseudoVREM_VV_M8_E32, VREM_VV }, // 7085 + { PseudoVREM_VV_M8_E32_MASK, VREM_VV }, // 7086 + { PseudoVREM_VV_M8_E64, VREM_VV }, // 7087 + { PseudoVREM_VV_M8_E64_MASK, VREM_VV }, // 7088 + { PseudoVREM_VV_M8_E8, VREM_VV }, // 7089 + { PseudoVREM_VV_M8_E8_MASK, VREM_VV }, // 7090 + { PseudoVREM_VV_MF2_E16, VREM_VV }, // 7091 + { PseudoVREM_VV_MF2_E16_MASK, VREM_VV }, // 7092 + { PseudoVREM_VV_MF2_E32, VREM_VV }, // 7093 + { PseudoVREM_VV_MF2_E32_MASK, VREM_VV }, // 7094 + { PseudoVREM_VV_MF2_E8, VREM_VV }, // 7095 + { PseudoVREM_VV_MF2_E8_MASK, VREM_VV }, // 7096 + { PseudoVREM_VV_MF4_E16, VREM_VV }, // 7097 + { PseudoVREM_VV_MF4_E16_MASK, VREM_VV }, // 7098 + { PseudoVREM_VV_MF4_E8, VREM_VV }, // 7099 + { PseudoVREM_VV_MF4_E8_MASK, VREM_VV }, // 7100 + { PseudoVREM_VV_MF8_E8, VREM_VV }, // 7101 + { PseudoVREM_VV_MF8_E8_MASK, VREM_VV }, // 7102 + { PseudoVREM_VX_M1_E16, VREM_VX }, // 7103 + { PseudoVREM_VX_M1_E16_MASK, VREM_VX }, // 7104 + { PseudoVREM_VX_M1_E32, VREM_VX }, // 7105 + { PseudoVREM_VX_M1_E32_MASK, VREM_VX }, // 7106 + { PseudoVREM_VX_M1_E64, VREM_VX }, // 7107 + { PseudoVREM_VX_M1_E64_MASK, VREM_VX }, // 7108 + { PseudoVREM_VX_M1_E8, VREM_VX }, // 7109 + { PseudoVREM_VX_M1_E8_MASK, VREM_VX }, // 7110 + { PseudoVREM_VX_M2_E16, VREM_VX }, // 7111 + { PseudoVREM_VX_M2_E16_MASK, VREM_VX }, // 7112 + { PseudoVREM_VX_M2_E32, VREM_VX }, // 7113 + { PseudoVREM_VX_M2_E32_MASK, VREM_VX }, // 7114 + { PseudoVREM_VX_M2_E64, VREM_VX }, // 7115 + { PseudoVREM_VX_M2_E64_MASK, VREM_VX }, // 7116 + { PseudoVREM_VX_M2_E8, VREM_VX }, // 7117 + { PseudoVREM_VX_M2_E8_MASK, VREM_VX }, // 7118 + { PseudoVREM_VX_M4_E16, VREM_VX }, // 7119 + { PseudoVREM_VX_M4_E16_MASK, VREM_VX }, // 7120 + { PseudoVREM_VX_M4_E32, VREM_VX }, // 7121 + { PseudoVREM_VX_M4_E32_MASK, VREM_VX }, // 7122 + { PseudoVREM_VX_M4_E64, VREM_VX }, // 7123 + { PseudoVREM_VX_M4_E64_MASK, VREM_VX }, // 7124 + { PseudoVREM_VX_M4_E8, VREM_VX }, // 7125 + { PseudoVREM_VX_M4_E8_MASK, VREM_VX }, // 7126 + { PseudoVREM_VX_M8_E16, VREM_VX }, // 7127 + { PseudoVREM_VX_M8_E16_MASK, VREM_VX }, // 7128 + { PseudoVREM_VX_M8_E32, VREM_VX }, // 7129 + { PseudoVREM_VX_M8_E32_MASK, VREM_VX }, // 7130 + { PseudoVREM_VX_M8_E64, VREM_VX }, // 7131 + { PseudoVREM_VX_M8_E64_MASK, VREM_VX }, // 7132 + { PseudoVREM_VX_M8_E8, VREM_VX }, // 7133 + { PseudoVREM_VX_M8_E8_MASK, VREM_VX }, // 7134 + { PseudoVREM_VX_MF2_E16, VREM_VX }, // 7135 + { PseudoVREM_VX_MF2_E16_MASK, VREM_VX }, // 7136 + { PseudoVREM_VX_MF2_E32, VREM_VX }, // 7137 + { PseudoVREM_VX_MF2_E32_MASK, VREM_VX }, // 7138 + { PseudoVREM_VX_MF2_E8, VREM_VX }, // 7139 + { PseudoVREM_VX_MF2_E8_MASK, VREM_VX }, // 7140 + { PseudoVREM_VX_MF4_E16, VREM_VX }, // 7141 + { PseudoVREM_VX_MF4_E16_MASK, VREM_VX }, // 7142 + { PseudoVREM_VX_MF4_E8, VREM_VX }, // 7143 + { PseudoVREM_VX_MF4_E8_MASK, VREM_VX }, // 7144 + { PseudoVREM_VX_MF8_E8, VREM_VX }, // 7145 + { PseudoVREM_VX_MF8_E8_MASK, VREM_VX }, // 7146 + { PseudoVREV8_V_M1, VREV8_V }, // 7147 + { PseudoVREV8_V_M1_MASK, VREV8_V }, // 7148 + { PseudoVREV8_V_M2, VREV8_V }, // 7149 + { PseudoVREV8_V_M2_MASK, VREV8_V }, // 7150 + { PseudoVREV8_V_M4, VREV8_V }, // 7151 + { PseudoVREV8_V_M4_MASK, VREV8_V }, // 7152 + { PseudoVREV8_V_M8, VREV8_V }, // 7153 + { PseudoVREV8_V_M8_MASK, VREV8_V }, // 7154 + { PseudoVREV8_V_MF2, VREV8_V }, // 7155 + { PseudoVREV8_V_MF2_MASK, VREV8_V }, // 7156 + { PseudoVREV8_V_MF4, VREV8_V }, // 7157 + { PseudoVREV8_V_MF4_MASK, VREV8_V }, // 7158 + { PseudoVREV8_V_MF8, VREV8_V }, // 7159 + { PseudoVREV8_V_MF8_MASK, VREV8_V }, // 7160 + { PseudoVRGATHEREI16_VV_M1_E16_M1, VRGATHEREI16_VV }, // 7161 + { PseudoVRGATHEREI16_VV_M1_E16_M1_MASK, VRGATHEREI16_VV }, // 7162 + { PseudoVRGATHEREI16_VV_M1_E16_M2, VRGATHEREI16_VV }, // 7163 + { PseudoVRGATHEREI16_VV_M1_E16_M2_MASK, VRGATHEREI16_VV }, // 7164 + { PseudoVRGATHEREI16_VV_M1_E16_MF2, VRGATHEREI16_VV }, // 7165 + { PseudoVRGATHEREI16_VV_M1_E16_MF2_MASK, VRGATHEREI16_VV }, // 7166 + { PseudoVRGATHEREI16_VV_M1_E16_MF4, VRGATHEREI16_VV }, // 7167 + { PseudoVRGATHEREI16_VV_M1_E16_MF4_MASK, VRGATHEREI16_VV }, // 7168 + { PseudoVRGATHEREI16_VV_M1_E32_M1, VRGATHEREI16_VV }, // 7169 + { PseudoVRGATHEREI16_VV_M1_E32_M1_MASK, VRGATHEREI16_VV }, // 7170 + { PseudoVRGATHEREI16_VV_M1_E32_M2, VRGATHEREI16_VV }, // 7171 + { PseudoVRGATHEREI16_VV_M1_E32_M2_MASK, VRGATHEREI16_VV }, // 7172 + { PseudoVRGATHEREI16_VV_M1_E32_MF2, VRGATHEREI16_VV }, // 7173 + { PseudoVRGATHEREI16_VV_M1_E32_MF2_MASK, VRGATHEREI16_VV }, // 7174 + { PseudoVRGATHEREI16_VV_M1_E32_MF4, VRGATHEREI16_VV }, // 7175 + { PseudoVRGATHEREI16_VV_M1_E32_MF4_MASK, VRGATHEREI16_VV }, // 7176 + { PseudoVRGATHEREI16_VV_M1_E64_M1, VRGATHEREI16_VV }, // 7177 + { PseudoVRGATHEREI16_VV_M1_E64_M1_MASK, VRGATHEREI16_VV }, // 7178 + { PseudoVRGATHEREI16_VV_M1_E64_M2, VRGATHEREI16_VV }, // 7179 + { PseudoVRGATHEREI16_VV_M1_E64_M2_MASK, VRGATHEREI16_VV }, // 7180 + { PseudoVRGATHEREI16_VV_M1_E64_MF2, VRGATHEREI16_VV }, // 7181 + { PseudoVRGATHEREI16_VV_M1_E64_MF2_MASK, VRGATHEREI16_VV }, // 7182 + { PseudoVRGATHEREI16_VV_M1_E64_MF4, VRGATHEREI16_VV }, // 7183 + { PseudoVRGATHEREI16_VV_M1_E64_MF4_MASK, VRGATHEREI16_VV }, // 7184 + { PseudoVRGATHEREI16_VV_M1_E8_M1, VRGATHEREI16_VV }, // 7185 + { PseudoVRGATHEREI16_VV_M1_E8_M1_MASK, VRGATHEREI16_VV }, // 7186 + { PseudoVRGATHEREI16_VV_M1_E8_M2, VRGATHEREI16_VV }, // 7187 + { PseudoVRGATHEREI16_VV_M1_E8_M2_MASK, VRGATHEREI16_VV }, // 7188 + { PseudoVRGATHEREI16_VV_M1_E8_MF2, VRGATHEREI16_VV }, // 7189 + { PseudoVRGATHEREI16_VV_M1_E8_MF2_MASK, VRGATHEREI16_VV }, // 7190 + { PseudoVRGATHEREI16_VV_M1_E8_MF4, VRGATHEREI16_VV }, // 7191 + { PseudoVRGATHEREI16_VV_M1_E8_MF4_MASK, VRGATHEREI16_VV }, // 7192 + { PseudoVRGATHEREI16_VV_M2_E16_M1, VRGATHEREI16_VV }, // 7193 + { PseudoVRGATHEREI16_VV_M2_E16_M1_MASK, VRGATHEREI16_VV }, // 7194 + { PseudoVRGATHEREI16_VV_M2_E16_M2, VRGATHEREI16_VV }, // 7195 + { PseudoVRGATHEREI16_VV_M2_E16_M2_MASK, VRGATHEREI16_VV }, // 7196 + { PseudoVRGATHEREI16_VV_M2_E16_M4, VRGATHEREI16_VV }, // 7197 + { PseudoVRGATHEREI16_VV_M2_E16_M4_MASK, VRGATHEREI16_VV }, // 7198 + { PseudoVRGATHEREI16_VV_M2_E16_MF2, VRGATHEREI16_VV }, // 7199 + { PseudoVRGATHEREI16_VV_M2_E16_MF2_MASK, VRGATHEREI16_VV }, // 7200 + { PseudoVRGATHEREI16_VV_M2_E32_M1, VRGATHEREI16_VV }, // 7201 + { PseudoVRGATHEREI16_VV_M2_E32_M1_MASK, VRGATHEREI16_VV }, // 7202 + { PseudoVRGATHEREI16_VV_M2_E32_M2, VRGATHEREI16_VV }, // 7203 + { PseudoVRGATHEREI16_VV_M2_E32_M2_MASK, VRGATHEREI16_VV }, // 7204 + { PseudoVRGATHEREI16_VV_M2_E32_M4, VRGATHEREI16_VV }, // 7205 + { PseudoVRGATHEREI16_VV_M2_E32_M4_MASK, VRGATHEREI16_VV }, // 7206 + { PseudoVRGATHEREI16_VV_M2_E32_MF2, VRGATHEREI16_VV }, // 7207 + { PseudoVRGATHEREI16_VV_M2_E32_MF2_MASK, VRGATHEREI16_VV }, // 7208 + { PseudoVRGATHEREI16_VV_M2_E64_M1, VRGATHEREI16_VV }, // 7209 + { PseudoVRGATHEREI16_VV_M2_E64_M1_MASK, VRGATHEREI16_VV }, // 7210 + { PseudoVRGATHEREI16_VV_M2_E64_M2, VRGATHEREI16_VV }, // 7211 + { PseudoVRGATHEREI16_VV_M2_E64_M2_MASK, VRGATHEREI16_VV }, // 7212 + { PseudoVRGATHEREI16_VV_M2_E64_M4, VRGATHEREI16_VV }, // 7213 + { PseudoVRGATHEREI16_VV_M2_E64_M4_MASK, VRGATHEREI16_VV }, // 7214 + { PseudoVRGATHEREI16_VV_M2_E64_MF2, VRGATHEREI16_VV }, // 7215 + { PseudoVRGATHEREI16_VV_M2_E64_MF2_MASK, VRGATHEREI16_VV }, // 7216 + { PseudoVRGATHEREI16_VV_M2_E8_M1, VRGATHEREI16_VV }, // 7217 + { PseudoVRGATHEREI16_VV_M2_E8_M1_MASK, VRGATHEREI16_VV }, // 7218 + { PseudoVRGATHEREI16_VV_M2_E8_M2, VRGATHEREI16_VV }, // 7219 + { PseudoVRGATHEREI16_VV_M2_E8_M2_MASK, VRGATHEREI16_VV }, // 7220 + { PseudoVRGATHEREI16_VV_M2_E8_M4, VRGATHEREI16_VV }, // 7221 + { PseudoVRGATHEREI16_VV_M2_E8_M4_MASK, VRGATHEREI16_VV }, // 7222 + { PseudoVRGATHEREI16_VV_M2_E8_MF2, VRGATHEREI16_VV }, // 7223 + { PseudoVRGATHEREI16_VV_M2_E8_MF2_MASK, VRGATHEREI16_VV }, // 7224 + { PseudoVRGATHEREI16_VV_M4_E16_M1, VRGATHEREI16_VV }, // 7225 + { PseudoVRGATHEREI16_VV_M4_E16_M1_MASK, VRGATHEREI16_VV }, // 7226 + { PseudoVRGATHEREI16_VV_M4_E16_M2, VRGATHEREI16_VV }, // 7227 + { PseudoVRGATHEREI16_VV_M4_E16_M2_MASK, VRGATHEREI16_VV }, // 7228 + { PseudoVRGATHEREI16_VV_M4_E16_M4, VRGATHEREI16_VV }, // 7229 + { PseudoVRGATHEREI16_VV_M4_E16_M4_MASK, VRGATHEREI16_VV }, // 7230 + { PseudoVRGATHEREI16_VV_M4_E16_M8, VRGATHEREI16_VV }, // 7231 + { PseudoVRGATHEREI16_VV_M4_E16_M8_MASK, VRGATHEREI16_VV }, // 7232 + { PseudoVRGATHEREI16_VV_M4_E32_M1, VRGATHEREI16_VV }, // 7233 + { PseudoVRGATHEREI16_VV_M4_E32_M1_MASK, VRGATHEREI16_VV }, // 7234 + { PseudoVRGATHEREI16_VV_M4_E32_M2, VRGATHEREI16_VV }, // 7235 + { PseudoVRGATHEREI16_VV_M4_E32_M2_MASK, VRGATHEREI16_VV }, // 7236 + { PseudoVRGATHEREI16_VV_M4_E32_M4, VRGATHEREI16_VV }, // 7237 + { PseudoVRGATHEREI16_VV_M4_E32_M4_MASK, VRGATHEREI16_VV }, // 7238 + { PseudoVRGATHEREI16_VV_M4_E32_M8, VRGATHEREI16_VV }, // 7239 + { PseudoVRGATHEREI16_VV_M4_E32_M8_MASK, VRGATHEREI16_VV }, // 7240 + { PseudoVRGATHEREI16_VV_M4_E64_M1, VRGATHEREI16_VV }, // 7241 + { PseudoVRGATHEREI16_VV_M4_E64_M1_MASK, VRGATHEREI16_VV }, // 7242 + { PseudoVRGATHEREI16_VV_M4_E64_M2, VRGATHEREI16_VV }, // 7243 + { PseudoVRGATHEREI16_VV_M4_E64_M2_MASK, VRGATHEREI16_VV }, // 7244 + { PseudoVRGATHEREI16_VV_M4_E64_M4, VRGATHEREI16_VV }, // 7245 + { PseudoVRGATHEREI16_VV_M4_E64_M4_MASK, VRGATHEREI16_VV }, // 7246 + { PseudoVRGATHEREI16_VV_M4_E64_M8, VRGATHEREI16_VV }, // 7247 + { PseudoVRGATHEREI16_VV_M4_E64_M8_MASK, VRGATHEREI16_VV }, // 7248 + { PseudoVRGATHEREI16_VV_M4_E8_M1, VRGATHEREI16_VV }, // 7249 + { PseudoVRGATHEREI16_VV_M4_E8_M1_MASK, VRGATHEREI16_VV }, // 7250 + { PseudoVRGATHEREI16_VV_M4_E8_M2, VRGATHEREI16_VV }, // 7251 + { PseudoVRGATHEREI16_VV_M4_E8_M2_MASK, VRGATHEREI16_VV }, // 7252 + { PseudoVRGATHEREI16_VV_M4_E8_M4, VRGATHEREI16_VV }, // 7253 + { PseudoVRGATHEREI16_VV_M4_E8_M4_MASK, VRGATHEREI16_VV }, // 7254 + { PseudoVRGATHEREI16_VV_M4_E8_M8, VRGATHEREI16_VV }, // 7255 + { PseudoVRGATHEREI16_VV_M4_E8_M8_MASK, VRGATHEREI16_VV }, // 7256 + { PseudoVRGATHEREI16_VV_M8_E16_M2, VRGATHEREI16_VV }, // 7257 + { PseudoVRGATHEREI16_VV_M8_E16_M2_MASK, VRGATHEREI16_VV }, // 7258 + { PseudoVRGATHEREI16_VV_M8_E16_M4, VRGATHEREI16_VV }, // 7259 + { PseudoVRGATHEREI16_VV_M8_E16_M4_MASK, VRGATHEREI16_VV }, // 7260 + { PseudoVRGATHEREI16_VV_M8_E16_M8, VRGATHEREI16_VV }, // 7261 + { PseudoVRGATHEREI16_VV_M8_E16_M8_MASK, VRGATHEREI16_VV }, // 7262 + { PseudoVRGATHEREI16_VV_M8_E32_M2, VRGATHEREI16_VV }, // 7263 + { PseudoVRGATHEREI16_VV_M8_E32_M2_MASK, VRGATHEREI16_VV }, // 7264 + { PseudoVRGATHEREI16_VV_M8_E32_M4, VRGATHEREI16_VV }, // 7265 + { PseudoVRGATHEREI16_VV_M8_E32_M4_MASK, VRGATHEREI16_VV }, // 7266 + { PseudoVRGATHEREI16_VV_M8_E32_M8, VRGATHEREI16_VV }, // 7267 + { PseudoVRGATHEREI16_VV_M8_E32_M8_MASK, VRGATHEREI16_VV }, // 7268 + { PseudoVRGATHEREI16_VV_M8_E64_M2, VRGATHEREI16_VV }, // 7269 + { PseudoVRGATHEREI16_VV_M8_E64_M2_MASK, VRGATHEREI16_VV }, // 7270 + { PseudoVRGATHEREI16_VV_M8_E64_M4, VRGATHEREI16_VV }, // 7271 + { PseudoVRGATHEREI16_VV_M8_E64_M4_MASK, VRGATHEREI16_VV }, // 7272 + { PseudoVRGATHEREI16_VV_M8_E64_M8, VRGATHEREI16_VV }, // 7273 + { PseudoVRGATHEREI16_VV_M8_E64_M8_MASK, VRGATHEREI16_VV }, // 7274 + { PseudoVRGATHEREI16_VV_M8_E8_M2, VRGATHEREI16_VV }, // 7275 + { PseudoVRGATHEREI16_VV_M8_E8_M2_MASK, VRGATHEREI16_VV }, // 7276 + { PseudoVRGATHEREI16_VV_M8_E8_M4, VRGATHEREI16_VV }, // 7277 + { PseudoVRGATHEREI16_VV_M8_E8_M4_MASK, VRGATHEREI16_VV }, // 7278 + { PseudoVRGATHEREI16_VV_M8_E8_M8, VRGATHEREI16_VV }, // 7279 + { PseudoVRGATHEREI16_VV_M8_E8_M8_MASK, VRGATHEREI16_VV }, // 7280 + { PseudoVRGATHEREI16_VV_MF2_E16_M1, VRGATHEREI16_VV }, // 7281 + { PseudoVRGATHEREI16_VV_MF2_E16_M1_MASK, VRGATHEREI16_VV }, // 7282 + { PseudoVRGATHEREI16_VV_MF2_E16_MF2, VRGATHEREI16_VV }, // 7283 + { PseudoVRGATHEREI16_VV_MF2_E16_MF2_MASK, VRGATHEREI16_VV }, // 7284 + { PseudoVRGATHEREI16_VV_MF2_E16_MF4, VRGATHEREI16_VV }, // 7285 + { PseudoVRGATHEREI16_VV_MF2_E16_MF4_MASK, VRGATHEREI16_VV }, // 7286 + { PseudoVRGATHEREI16_VV_MF2_E16_MF8, VRGATHEREI16_VV }, // 7287 + { PseudoVRGATHEREI16_VV_MF2_E16_MF8_MASK, VRGATHEREI16_VV }, // 7288 + { PseudoVRGATHEREI16_VV_MF2_E32_M1, VRGATHEREI16_VV }, // 7289 + { PseudoVRGATHEREI16_VV_MF2_E32_M1_MASK, VRGATHEREI16_VV }, // 7290 + { PseudoVRGATHEREI16_VV_MF2_E32_MF2, VRGATHEREI16_VV }, // 7291 + { PseudoVRGATHEREI16_VV_MF2_E32_MF2_MASK, VRGATHEREI16_VV }, // 7292 + { PseudoVRGATHEREI16_VV_MF2_E32_MF4, VRGATHEREI16_VV }, // 7293 + { PseudoVRGATHEREI16_VV_MF2_E32_MF4_MASK, VRGATHEREI16_VV }, // 7294 + { PseudoVRGATHEREI16_VV_MF2_E32_MF8, VRGATHEREI16_VV }, // 7295 + { PseudoVRGATHEREI16_VV_MF2_E32_MF8_MASK, VRGATHEREI16_VV }, // 7296 + { PseudoVRGATHEREI16_VV_MF2_E8_M1, VRGATHEREI16_VV }, // 7297 + { PseudoVRGATHEREI16_VV_MF2_E8_M1_MASK, VRGATHEREI16_VV }, // 7298 + { PseudoVRGATHEREI16_VV_MF2_E8_MF2, VRGATHEREI16_VV }, // 7299 + { PseudoVRGATHEREI16_VV_MF2_E8_MF2_MASK, VRGATHEREI16_VV }, // 7300 + { PseudoVRGATHEREI16_VV_MF2_E8_MF4, VRGATHEREI16_VV }, // 7301 + { PseudoVRGATHEREI16_VV_MF2_E8_MF4_MASK, VRGATHEREI16_VV }, // 7302 + { PseudoVRGATHEREI16_VV_MF2_E8_MF8, VRGATHEREI16_VV }, // 7303 + { PseudoVRGATHEREI16_VV_MF2_E8_MF8_MASK, VRGATHEREI16_VV }, // 7304 + { PseudoVRGATHEREI16_VV_MF4_E16_MF2, VRGATHEREI16_VV }, // 7305 + { PseudoVRGATHEREI16_VV_MF4_E16_MF2_MASK, VRGATHEREI16_VV }, // 7306 + { PseudoVRGATHEREI16_VV_MF4_E16_MF4, VRGATHEREI16_VV }, // 7307 + { PseudoVRGATHEREI16_VV_MF4_E16_MF4_MASK, VRGATHEREI16_VV }, // 7308 + { PseudoVRGATHEREI16_VV_MF4_E16_MF8, VRGATHEREI16_VV }, // 7309 + { PseudoVRGATHEREI16_VV_MF4_E16_MF8_MASK, VRGATHEREI16_VV }, // 7310 + { PseudoVRGATHEREI16_VV_MF4_E8_MF2, VRGATHEREI16_VV }, // 7311 + { PseudoVRGATHEREI16_VV_MF4_E8_MF2_MASK, VRGATHEREI16_VV }, // 7312 + { PseudoVRGATHEREI16_VV_MF4_E8_MF4, VRGATHEREI16_VV }, // 7313 + { PseudoVRGATHEREI16_VV_MF4_E8_MF4_MASK, VRGATHEREI16_VV }, // 7314 + { PseudoVRGATHEREI16_VV_MF4_E8_MF8, VRGATHEREI16_VV }, // 7315 + { PseudoVRGATHEREI16_VV_MF4_E8_MF8_MASK, VRGATHEREI16_VV }, // 7316 + { PseudoVRGATHEREI16_VV_MF8_E8_MF4, VRGATHEREI16_VV }, // 7317 + { PseudoVRGATHEREI16_VV_MF8_E8_MF4_MASK, VRGATHEREI16_VV }, // 7318 + { PseudoVRGATHEREI16_VV_MF8_E8_MF8, VRGATHEREI16_VV }, // 7319 + { PseudoVRGATHEREI16_VV_MF8_E8_MF8_MASK, VRGATHEREI16_VV }, // 7320 + { PseudoVRGATHER_VI_M1, VRGATHER_VI }, // 7321 + { PseudoVRGATHER_VI_M1_MASK, VRGATHER_VI }, // 7322 + { PseudoVRGATHER_VI_M2, VRGATHER_VI }, // 7323 + { PseudoVRGATHER_VI_M2_MASK, VRGATHER_VI }, // 7324 + { PseudoVRGATHER_VI_M4, VRGATHER_VI }, // 7325 + { PseudoVRGATHER_VI_M4_MASK, VRGATHER_VI }, // 7326 + { PseudoVRGATHER_VI_M8, VRGATHER_VI }, // 7327 + { PseudoVRGATHER_VI_M8_MASK, VRGATHER_VI }, // 7328 + { PseudoVRGATHER_VI_MF2, VRGATHER_VI }, // 7329 + { PseudoVRGATHER_VI_MF2_MASK, VRGATHER_VI }, // 7330 + { PseudoVRGATHER_VI_MF4, VRGATHER_VI }, // 7331 + { PseudoVRGATHER_VI_MF4_MASK, VRGATHER_VI }, // 7332 + { PseudoVRGATHER_VI_MF8, VRGATHER_VI }, // 7333 + { PseudoVRGATHER_VI_MF8_MASK, VRGATHER_VI }, // 7334 + { PseudoVRGATHER_VV_M1_E16, VRGATHER_VV }, // 7335 + { PseudoVRGATHER_VV_M1_E16_MASK, VRGATHER_VV }, // 7336 + { PseudoVRGATHER_VV_M1_E32, VRGATHER_VV }, // 7337 + { PseudoVRGATHER_VV_M1_E32_MASK, VRGATHER_VV }, // 7338 + { PseudoVRGATHER_VV_M1_E64, VRGATHER_VV }, // 7339 + { PseudoVRGATHER_VV_M1_E64_MASK, VRGATHER_VV }, // 7340 + { PseudoVRGATHER_VV_M1_E8, VRGATHER_VV }, // 7341 + { PseudoVRGATHER_VV_M1_E8_MASK, VRGATHER_VV }, // 7342 + { PseudoVRGATHER_VV_M2_E16, VRGATHER_VV }, // 7343 + { PseudoVRGATHER_VV_M2_E16_MASK, VRGATHER_VV }, // 7344 + { PseudoVRGATHER_VV_M2_E32, VRGATHER_VV }, // 7345 + { PseudoVRGATHER_VV_M2_E32_MASK, VRGATHER_VV }, // 7346 + { PseudoVRGATHER_VV_M2_E64, VRGATHER_VV }, // 7347 + { PseudoVRGATHER_VV_M2_E64_MASK, VRGATHER_VV }, // 7348 + { PseudoVRGATHER_VV_M2_E8, VRGATHER_VV }, // 7349 + { PseudoVRGATHER_VV_M2_E8_MASK, VRGATHER_VV }, // 7350 + { PseudoVRGATHER_VV_M4_E16, VRGATHER_VV }, // 7351 + { PseudoVRGATHER_VV_M4_E16_MASK, VRGATHER_VV }, // 7352 + { PseudoVRGATHER_VV_M4_E32, VRGATHER_VV }, // 7353 + { PseudoVRGATHER_VV_M4_E32_MASK, VRGATHER_VV }, // 7354 + { PseudoVRGATHER_VV_M4_E64, VRGATHER_VV }, // 7355 + { PseudoVRGATHER_VV_M4_E64_MASK, VRGATHER_VV }, // 7356 + { PseudoVRGATHER_VV_M4_E8, VRGATHER_VV }, // 7357 + { PseudoVRGATHER_VV_M4_E8_MASK, VRGATHER_VV }, // 7358 + { PseudoVRGATHER_VV_M8_E16, VRGATHER_VV }, // 7359 + { PseudoVRGATHER_VV_M8_E16_MASK, VRGATHER_VV }, // 7360 + { PseudoVRGATHER_VV_M8_E32, VRGATHER_VV }, // 7361 + { PseudoVRGATHER_VV_M8_E32_MASK, VRGATHER_VV }, // 7362 + { PseudoVRGATHER_VV_M8_E64, VRGATHER_VV }, // 7363 + { PseudoVRGATHER_VV_M8_E64_MASK, VRGATHER_VV }, // 7364 + { PseudoVRGATHER_VV_M8_E8, VRGATHER_VV }, // 7365 + { PseudoVRGATHER_VV_M8_E8_MASK, VRGATHER_VV }, // 7366 + { PseudoVRGATHER_VV_MF2_E16, VRGATHER_VV }, // 7367 + { PseudoVRGATHER_VV_MF2_E16_MASK, VRGATHER_VV }, // 7368 + { PseudoVRGATHER_VV_MF2_E32, VRGATHER_VV }, // 7369 + { PseudoVRGATHER_VV_MF2_E32_MASK, VRGATHER_VV }, // 7370 + { PseudoVRGATHER_VV_MF2_E8, VRGATHER_VV }, // 7371 + { PseudoVRGATHER_VV_MF2_E8_MASK, VRGATHER_VV }, // 7372 + { PseudoVRGATHER_VV_MF4_E16, VRGATHER_VV }, // 7373 + { PseudoVRGATHER_VV_MF4_E16_MASK, VRGATHER_VV }, // 7374 + { PseudoVRGATHER_VV_MF4_E8, VRGATHER_VV }, // 7375 + { PseudoVRGATHER_VV_MF4_E8_MASK, VRGATHER_VV }, // 7376 + { PseudoVRGATHER_VV_MF8_E8, VRGATHER_VV }, // 7377 + { PseudoVRGATHER_VV_MF8_E8_MASK, VRGATHER_VV }, // 7378 + { PseudoVRGATHER_VX_M1, VRGATHER_VX }, // 7379 + { PseudoVRGATHER_VX_M1_MASK, VRGATHER_VX }, // 7380 + { PseudoVRGATHER_VX_M2, VRGATHER_VX }, // 7381 + { PseudoVRGATHER_VX_M2_MASK, VRGATHER_VX }, // 7382 + { PseudoVRGATHER_VX_M4, VRGATHER_VX }, // 7383 + { PseudoVRGATHER_VX_M4_MASK, VRGATHER_VX }, // 7384 + { PseudoVRGATHER_VX_M8, VRGATHER_VX }, // 7385 + { PseudoVRGATHER_VX_M8_MASK, VRGATHER_VX }, // 7386 + { PseudoVRGATHER_VX_MF2, VRGATHER_VX }, // 7387 + { PseudoVRGATHER_VX_MF2_MASK, VRGATHER_VX }, // 7388 + { PseudoVRGATHER_VX_MF4, VRGATHER_VX }, // 7389 + { PseudoVRGATHER_VX_MF4_MASK, VRGATHER_VX }, // 7390 + { PseudoVRGATHER_VX_MF8, VRGATHER_VX }, // 7391 + { PseudoVRGATHER_VX_MF8_MASK, VRGATHER_VX }, // 7392 + { PseudoVROL_VV_M1, VROL_VV }, // 7393 + { PseudoVROL_VV_M1_MASK, VROL_VV }, // 7394 + { PseudoVROL_VV_M2, VROL_VV }, // 7395 + { PseudoVROL_VV_M2_MASK, VROL_VV }, // 7396 + { PseudoVROL_VV_M4, VROL_VV }, // 7397 + { PseudoVROL_VV_M4_MASK, VROL_VV }, // 7398 + { PseudoVROL_VV_M8, VROL_VV }, // 7399 + { PseudoVROL_VV_M8_MASK, VROL_VV }, // 7400 + { PseudoVROL_VV_MF2, VROL_VV }, // 7401 + { PseudoVROL_VV_MF2_MASK, VROL_VV }, // 7402 + { PseudoVROL_VV_MF4, VROL_VV }, // 7403 + { PseudoVROL_VV_MF4_MASK, VROL_VV }, // 7404 + { PseudoVROL_VV_MF8, VROL_VV }, // 7405 + { PseudoVROL_VV_MF8_MASK, VROL_VV }, // 7406 + { PseudoVROL_VX_M1, VROL_VX }, // 7407 + { PseudoVROL_VX_M1_MASK, VROL_VX }, // 7408 + { PseudoVROL_VX_M2, VROL_VX }, // 7409 + { PseudoVROL_VX_M2_MASK, VROL_VX }, // 7410 + { PseudoVROL_VX_M4, VROL_VX }, // 7411 + { PseudoVROL_VX_M4_MASK, VROL_VX }, // 7412 + { PseudoVROL_VX_M8, VROL_VX }, // 7413 + { PseudoVROL_VX_M8_MASK, VROL_VX }, // 7414 + { PseudoVROL_VX_MF2, VROL_VX }, // 7415 + { PseudoVROL_VX_MF2_MASK, VROL_VX }, // 7416 + { PseudoVROL_VX_MF4, VROL_VX }, // 7417 + { PseudoVROL_VX_MF4_MASK, VROL_VX }, // 7418 + { PseudoVROL_VX_MF8, VROL_VX }, // 7419 + { PseudoVROL_VX_MF8_MASK, VROL_VX }, // 7420 + { PseudoVROR_VI_M1, VROR_VI }, // 7421 + { PseudoVROR_VI_M1_MASK, VROR_VI }, // 7422 + { PseudoVROR_VI_M2, VROR_VI }, // 7423 + { PseudoVROR_VI_M2_MASK, VROR_VI }, // 7424 + { PseudoVROR_VI_M4, VROR_VI }, // 7425 + { PseudoVROR_VI_M4_MASK, VROR_VI }, // 7426 + { PseudoVROR_VI_M8, VROR_VI }, // 7427 + { PseudoVROR_VI_M8_MASK, VROR_VI }, // 7428 + { PseudoVROR_VI_MF2, VROR_VI }, // 7429 + { PseudoVROR_VI_MF2_MASK, VROR_VI }, // 7430 + { PseudoVROR_VI_MF4, VROR_VI }, // 7431 + { PseudoVROR_VI_MF4_MASK, VROR_VI }, // 7432 + { PseudoVROR_VI_MF8, VROR_VI }, // 7433 + { PseudoVROR_VI_MF8_MASK, VROR_VI }, // 7434 + { PseudoVROR_VV_M1, VROR_VV }, // 7435 + { PseudoVROR_VV_M1_MASK, VROR_VV }, // 7436 + { PseudoVROR_VV_M2, VROR_VV }, // 7437 + { PseudoVROR_VV_M2_MASK, VROR_VV }, // 7438 + { PseudoVROR_VV_M4, VROR_VV }, // 7439 + { PseudoVROR_VV_M4_MASK, VROR_VV }, // 7440 + { PseudoVROR_VV_M8, VROR_VV }, // 7441 + { PseudoVROR_VV_M8_MASK, VROR_VV }, // 7442 + { PseudoVROR_VV_MF2, VROR_VV }, // 7443 + { PseudoVROR_VV_MF2_MASK, VROR_VV }, // 7444 + { PseudoVROR_VV_MF4, VROR_VV }, // 7445 + { PseudoVROR_VV_MF4_MASK, VROR_VV }, // 7446 + { PseudoVROR_VV_MF8, VROR_VV }, // 7447 + { PseudoVROR_VV_MF8_MASK, VROR_VV }, // 7448 + { PseudoVROR_VX_M1, VROR_VX }, // 7449 + { PseudoVROR_VX_M1_MASK, VROR_VX }, // 7450 + { PseudoVROR_VX_M2, VROR_VX }, // 7451 + { PseudoVROR_VX_M2_MASK, VROR_VX }, // 7452 + { PseudoVROR_VX_M4, VROR_VX }, // 7453 + { PseudoVROR_VX_M4_MASK, VROR_VX }, // 7454 + { PseudoVROR_VX_M8, VROR_VX }, // 7455 + { PseudoVROR_VX_M8_MASK, VROR_VX }, // 7456 + { PseudoVROR_VX_MF2, VROR_VX }, // 7457 + { PseudoVROR_VX_MF2_MASK, VROR_VX }, // 7458 + { PseudoVROR_VX_MF4, VROR_VX }, // 7459 + { PseudoVROR_VX_MF4_MASK, VROR_VX }, // 7460 + { PseudoVROR_VX_MF8, VROR_VX }, // 7461 + { PseudoVROR_VX_MF8_MASK, VROR_VX }, // 7462 + { PseudoVRSUB_VI_M1, VRSUB_VI }, // 7463 + { PseudoVRSUB_VI_M1_MASK, VRSUB_VI }, // 7464 + { PseudoVRSUB_VI_M2, VRSUB_VI }, // 7465 + { PseudoVRSUB_VI_M2_MASK, VRSUB_VI }, // 7466 + { PseudoVRSUB_VI_M4, VRSUB_VI }, // 7467 + { PseudoVRSUB_VI_M4_MASK, VRSUB_VI }, // 7468 + { PseudoVRSUB_VI_M8, VRSUB_VI }, // 7469 + { PseudoVRSUB_VI_M8_MASK, VRSUB_VI }, // 7470 + { PseudoVRSUB_VI_MF2, VRSUB_VI }, // 7471 + { PseudoVRSUB_VI_MF2_MASK, VRSUB_VI }, // 7472 + { PseudoVRSUB_VI_MF4, VRSUB_VI }, // 7473 + { PseudoVRSUB_VI_MF4_MASK, VRSUB_VI }, // 7474 + { PseudoVRSUB_VI_MF8, VRSUB_VI }, // 7475 + { PseudoVRSUB_VI_MF8_MASK, VRSUB_VI }, // 7476 + { PseudoVRSUB_VX_M1, VRSUB_VX }, // 7477 + { PseudoVRSUB_VX_M1_MASK, VRSUB_VX }, // 7478 + { PseudoVRSUB_VX_M2, VRSUB_VX }, // 7479 + { PseudoVRSUB_VX_M2_MASK, VRSUB_VX }, // 7480 + { PseudoVRSUB_VX_M4, VRSUB_VX }, // 7481 + { PseudoVRSUB_VX_M4_MASK, VRSUB_VX }, // 7482 + { PseudoVRSUB_VX_M8, VRSUB_VX }, // 7483 + { PseudoVRSUB_VX_M8_MASK, VRSUB_VX }, // 7484 + { PseudoVRSUB_VX_MF2, VRSUB_VX }, // 7485 + { PseudoVRSUB_VX_MF2_MASK, VRSUB_VX }, // 7486 + { PseudoVRSUB_VX_MF4, VRSUB_VX }, // 7487 + { PseudoVRSUB_VX_MF4_MASK, VRSUB_VX }, // 7488 + { PseudoVRSUB_VX_MF8, VRSUB_VX }, // 7489 + { PseudoVRSUB_VX_MF8_MASK, VRSUB_VX }, // 7490 + { PseudoVSADDU_VI_M1, VSADDU_VI }, // 7491 + { PseudoVSADDU_VI_M1_MASK, VSADDU_VI }, // 7492 + { PseudoVSADDU_VI_M2, VSADDU_VI }, // 7493 + { PseudoVSADDU_VI_M2_MASK, VSADDU_VI }, // 7494 + { PseudoVSADDU_VI_M4, VSADDU_VI }, // 7495 + { PseudoVSADDU_VI_M4_MASK, VSADDU_VI }, // 7496 + { PseudoVSADDU_VI_M8, VSADDU_VI }, // 7497 + { PseudoVSADDU_VI_M8_MASK, VSADDU_VI }, // 7498 + { PseudoVSADDU_VI_MF2, VSADDU_VI }, // 7499 + { PseudoVSADDU_VI_MF2_MASK, VSADDU_VI }, // 7500 + { PseudoVSADDU_VI_MF4, VSADDU_VI }, // 7501 + { PseudoVSADDU_VI_MF4_MASK, VSADDU_VI }, // 7502 + { PseudoVSADDU_VI_MF8, VSADDU_VI }, // 7503 + { PseudoVSADDU_VI_MF8_MASK, VSADDU_VI }, // 7504 + { PseudoVSADDU_VV_M1, VSADDU_VV }, // 7505 + { PseudoVSADDU_VV_M1_MASK, VSADDU_VV }, // 7506 + { PseudoVSADDU_VV_M2, VSADDU_VV }, // 7507 + { PseudoVSADDU_VV_M2_MASK, VSADDU_VV }, // 7508 + { PseudoVSADDU_VV_M4, VSADDU_VV }, // 7509 + { PseudoVSADDU_VV_M4_MASK, VSADDU_VV }, // 7510 + { PseudoVSADDU_VV_M8, VSADDU_VV }, // 7511 + { PseudoVSADDU_VV_M8_MASK, VSADDU_VV }, // 7512 + { PseudoVSADDU_VV_MF2, VSADDU_VV }, // 7513 + { PseudoVSADDU_VV_MF2_MASK, VSADDU_VV }, // 7514 + { PseudoVSADDU_VV_MF4, VSADDU_VV }, // 7515 + { PseudoVSADDU_VV_MF4_MASK, VSADDU_VV }, // 7516 + { PseudoVSADDU_VV_MF8, VSADDU_VV }, // 7517 + { PseudoVSADDU_VV_MF8_MASK, VSADDU_VV }, // 7518 + { PseudoVSADDU_VX_M1, VSADDU_VX }, // 7519 + { PseudoVSADDU_VX_M1_MASK, VSADDU_VX }, // 7520 + { PseudoVSADDU_VX_M2, VSADDU_VX }, // 7521 + { PseudoVSADDU_VX_M2_MASK, VSADDU_VX }, // 7522 + { PseudoVSADDU_VX_M4, VSADDU_VX }, // 7523 + { PseudoVSADDU_VX_M4_MASK, VSADDU_VX }, // 7524 + { PseudoVSADDU_VX_M8, VSADDU_VX }, // 7525 + { PseudoVSADDU_VX_M8_MASK, VSADDU_VX }, // 7526 + { PseudoVSADDU_VX_MF2, VSADDU_VX }, // 7527 + { PseudoVSADDU_VX_MF2_MASK, VSADDU_VX }, // 7528 + { PseudoVSADDU_VX_MF4, VSADDU_VX }, // 7529 + { PseudoVSADDU_VX_MF4_MASK, VSADDU_VX }, // 7530 + { PseudoVSADDU_VX_MF8, VSADDU_VX }, // 7531 + { PseudoVSADDU_VX_MF8_MASK, VSADDU_VX }, // 7532 + { PseudoVSADD_VI_M1, VSADD_VI }, // 7533 + { PseudoVSADD_VI_M1_MASK, VSADD_VI }, // 7534 + { PseudoVSADD_VI_M2, VSADD_VI }, // 7535 + { PseudoVSADD_VI_M2_MASK, VSADD_VI }, // 7536 + { PseudoVSADD_VI_M4, VSADD_VI }, // 7537 + { PseudoVSADD_VI_M4_MASK, VSADD_VI }, // 7538 + { PseudoVSADD_VI_M8, VSADD_VI }, // 7539 + { PseudoVSADD_VI_M8_MASK, VSADD_VI }, // 7540 + { PseudoVSADD_VI_MF2, VSADD_VI }, // 7541 + { PseudoVSADD_VI_MF2_MASK, VSADD_VI }, // 7542 + { PseudoVSADD_VI_MF4, VSADD_VI }, // 7543 + { PseudoVSADD_VI_MF4_MASK, VSADD_VI }, // 7544 + { PseudoVSADD_VI_MF8, VSADD_VI }, // 7545 + { PseudoVSADD_VI_MF8_MASK, VSADD_VI }, // 7546 + { PseudoVSADD_VV_M1, VSADD_VV }, // 7547 + { PseudoVSADD_VV_M1_MASK, VSADD_VV }, // 7548 + { PseudoVSADD_VV_M2, VSADD_VV }, // 7549 + { PseudoVSADD_VV_M2_MASK, VSADD_VV }, // 7550 + { PseudoVSADD_VV_M4, VSADD_VV }, // 7551 + { PseudoVSADD_VV_M4_MASK, VSADD_VV }, // 7552 + { PseudoVSADD_VV_M8, VSADD_VV }, // 7553 + { PseudoVSADD_VV_M8_MASK, VSADD_VV }, // 7554 + { PseudoVSADD_VV_MF2, VSADD_VV }, // 7555 + { PseudoVSADD_VV_MF2_MASK, VSADD_VV }, // 7556 + { PseudoVSADD_VV_MF4, VSADD_VV }, // 7557 + { PseudoVSADD_VV_MF4_MASK, VSADD_VV }, // 7558 + { PseudoVSADD_VV_MF8, VSADD_VV }, // 7559 + { PseudoVSADD_VV_MF8_MASK, VSADD_VV }, // 7560 + { PseudoVSADD_VX_M1, VSADD_VX }, // 7561 + { PseudoVSADD_VX_M1_MASK, VSADD_VX }, // 7562 + { PseudoVSADD_VX_M2, VSADD_VX }, // 7563 + { PseudoVSADD_VX_M2_MASK, VSADD_VX }, // 7564 + { PseudoVSADD_VX_M4, VSADD_VX }, // 7565 + { PseudoVSADD_VX_M4_MASK, VSADD_VX }, // 7566 + { PseudoVSADD_VX_M8, VSADD_VX }, // 7567 + { PseudoVSADD_VX_M8_MASK, VSADD_VX }, // 7568 + { PseudoVSADD_VX_MF2, VSADD_VX }, // 7569 + { PseudoVSADD_VX_MF2_MASK, VSADD_VX }, // 7570 + { PseudoVSADD_VX_MF4, VSADD_VX }, // 7571 + { PseudoVSADD_VX_MF4_MASK, VSADD_VX }, // 7572 + { PseudoVSADD_VX_MF8, VSADD_VX }, // 7573 + { PseudoVSADD_VX_MF8_MASK, VSADD_VX }, // 7574 + { PseudoVSBC_VVM_M1, VSBC_VVM }, // 7575 + { PseudoVSBC_VVM_M2, VSBC_VVM }, // 7576 + { PseudoVSBC_VVM_M4, VSBC_VVM }, // 7577 + { PseudoVSBC_VVM_M8, VSBC_VVM }, // 7578 + { PseudoVSBC_VVM_MF2, VSBC_VVM }, // 7579 + { PseudoVSBC_VVM_MF4, VSBC_VVM }, // 7580 + { PseudoVSBC_VVM_MF8, VSBC_VVM }, // 7581 + { PseudoVSBC_VXM_M1, VSBC_VXM }, // 7582 + { PseudoVSBC_VXM_M2, VSBC_VXM }, // 7583 + { PseudoVSBC_VXM_M4, VSBC_VXM }, // 7584 + { PseudoVSBC_VXM_M8, VSBC_VXM }, // 7585 + { PseudoVSBC_VXM_MF2, VSBC_VXM }, // 7586 + { PseudoVSBC_VXM_MF4, VSBC_VXM }, // 7587 + { PseudoVSBC_VXM_MF8, VSBC_VXM }, // 7588 + { PseudoVSE16_V_M1, VSE16_V }, // 7589 + { PseudoVSE16_V_M1_MASK, VSE16_V }, // 7590 + { PseudoVSE16_V_M2, VSE16_V }, // 7591 + { PseudoVSE16_V_M2_MASK, VSE16_V }, // 7592 + { PseudoVSE16_V_M4, VSE16_V }, // 7593 + { PseudoVSE16_V_M4_MASK, VSE16_V }, // 7594 + { PseudoVSE16_V_M8, VSE16_V }, // 7595 + { PseudoVSE16_V_M8_MASK, VSE16_V }, // 7596 + { PseudoVSE16_V_MF2, VSE16_V }, // 7597 + { PseudoVSE16_V_MF2_MASK, VSE16_V }, // 7598 + { PseudoVSE16_V_MF4, VSE16_V }, // 7599 + { PseudoVSE16_V_MF4_MASK, VSE16_V }, // 7600 + { PseudoVSE32_V_M1, VSE32_V }, // 7601 + { PseudoVSE32_V_M1_MASK, VSE32_V }, // 7602 + { PseudoVSE32_V_M2, VSE32_V }, // 7603 + { PseudoVSE32_V_M2_MASK, VSE32_V }, // 7604 + { PseudoVSE32_V_M4, VSE32_V }, // 7605 + { PseudoVSE32_V_M4_MASK, VSE32_V }, // 7606 + { PseudoVSE32_V_M8, VSE32_V }, // 7607 + { PseudoVSE32_V_M8_MASK, VSE32_V }, // 7608 + { PseudoVSE32_V_MF2, VSE32_V }, // 7609 + { PseudoVSE32_V_MF2_MASK, VSE32_V }, // 7610 + { PseudoVSE64_V_M1, VSE64_V }, // 7611 + { PseudoVSE64_V_M1_MASK, VSE64_V }, // 7612 + { PseudoVSE64_V_M2, VSE64_V }, // 7613 + { PseudoVSE64_V_M2_MASK, VSE64_V }, // 7614 + { PseudoVSE64_V_M4, VSE64_V }, // 7615 + { PseudoVSE64_V_M4_MASK, VSE64_V }, // 7616 + { PseudoVSE64_V_M8, VSE64_V }, // 7617 + { PseudoVSE64_V_M8_MASK, VSE64_V }, // 7618 + { PseudoVSE8_V_M1, VSE8_V }, // 7619 + { PseudoVSE8_V_M1_MASK, VSE8_V }, // 7620 + { PseudoVSE8_V_M2, VSE8_V }, // 7621 + { PseudoVSE8_V_M2_MASK, VSE8_V }, // 7622 + { PseudoVSE8_V_M4, VSE8_V }, // 7623 + { PseudoVSE8_V_M4_MASK, VSE8_V }, // 7624 + { PseudoVSE8_V_M8, VSE8_V }, // 7625 + { PseudoVSE8_V_M8_MASK, VSE8_V }, // 7626 + { PseudoVSE8_V_MF2, VSE8_V }, // 7627 + { PseudoVSE8_V_MF2_MASK, VSE8_V }, // 7628 + { PseudoVSE8_V_MF4, VSE8_V }, // 7629 + { PseudoVSE8_V_MF4_MASK, VSE8_V }, // 7630 + { PseudoVSE8_V_MF8, VSE8_V }, // 7631 + { PseudoVSE8_V_MF8_MASK, VSE8_V }, // 7632 + { PseudoVSEXT_VF2_M1, VSEXT_VF2 }, // 7633 + { PseudoVSEXT_VF2_M1_MASK, VSEXT_VF2 }, // 7634 + { PseudoVSEXT_VF2_M2, VSEXT_VF2 }, // 7635 + { PseudoVSEXT_VF2_M2_MASK, VSEXT_VF2 }, // 7636 + { PseudoVSEXT_VF2_M4, VSEXT_VF2 }, // 7637 + { PseudoVSEXT_VF2_M4_MASK, VSEXT_VF2 }, // 7638 + { PseudoVSEXT_VF2_M8, VSEXT_VF2 }, // 7639 + { PseudoVSEXT_VF2_M8_MASK, VSEXT_VF2 }, // 7640 + { PseudoVSEXT_VF2_MF2, VSEXT_VF2 }, // 7641 + { PseudoVSEXT_VF2_MF2_MASK, VSEXT_VF2 }, // 7642 + { PseudoVSEXT_VF2_MF4, VSEXT_VF2 }, // 7643 + { PseudoVSEXT_VF2_MF4_MASK, VSEXT_VF2 }, // 7644 + { PseudoVSEXT_VF4_M1, VSEXT_VF4 }, // 7645 + { PseudoVSEXT_VF4_M1_MASK, VSEXT_VF4 }, // 7646 + { PseudoVSEXT_VF4_M2, VSEXT_VF4 }, // 7647 + { PseudoVSEXT_VF4_M2_MASK, VSEXT_VF4 }, // 7648 + { PseudoVSEXT_VF4_M4, VSEXT_VF4 }, // 7649 + { PseudoVSEXT_VF4_M4_MASK, VSEXT_VF4 }, // 7650 + { PseudoVSEXT_VF4_M8, VSEXT_VF4 }, // 7651 + { PseudoVSEXT_VF4_M8_MASK, VSEXT_VF4 }, // 7652 + { PseudoVSEXT_VF4_MF2, VSEXT_VF4 }, // 7653 + { PseudoVSEXT_VF4_MF2_MASK, VSEXT_VF4 }, // 7654 + { PseudoVSEXT_VF8_M1, VSEXT_VF8 }, // 7655 + { PseudoVSEXT_VF8_M1_MASK, VSEXT_VF8 }, // 7656 + { PseudoVSEXT_VF8_M2, VSEXT_VF8 }, // 7657 + { PseudoVSEXT_VF8_M2_MASK, VSEXT_VF8 }, // 7658 + { PseudoVSEXT_VF8_M4, VSEXT_VF8 }, // 7659 + { PseudoVSEXT_VF8_M4_MASK, VSEXT_VF8 }, // 7660 + { PseudoVSEXT_VF8_M8, VSEXT_VF8 }, // 7661 + { PseudoVSEXT_VF8_M8_MASK, VSEXT_VF8 }, // 7662 + { PseudoVSHA2CH_VV_M1, VSHA2CH_VV }, // 7663 + { PseudoVSHA2CH_VV_M2, VSHA2CH_VV }, // 7664 + { PseudoVSHA2CH_VV_M4, VSHA2CH_VV }, // 7665 + { PseudoVSHA2CH_VV_M8, VSHA2CH_VV }, // 7666 + { PseudoVSHA2CH_VV_MF2, VSHA2CH_VV }, // 7667 + { PseudoVSHA2CL_VV_M1, VSHA2CL_VV }, // 7668 + { PseudoVSHA2CL_VV_M2, VSHA2CL_VV }, // 7669 + { PseudoVSHA2CL_VV_M4, VSHA2CL_VV }, // 7670 + { PseudoVSHA2CL_VV_M8, VSHA2CL_VV }, // 7671 + { PseudoVSHA2CL_VV_MF2, VSHA2CL_VV }, // 7672 + { PseudoVSHA2MS_VV_M1, VSHA2MS_VV }, // 7673 + { PseudoVSHA2MS_VV_M2, VSHA2MS_VV }, // 7674 + { PseudoVSHA2MS_VV_M4, VSHA2MS_VV }, // 7675 + { PseudoVSHA2MS_VV_M8, VSHA2MS_VV }, // 7676 + { PseudoVSHA2MS_VV_MF2, VSHA2MS_VV }, // 7677 + { PseudoVSLIDE1DOWN_VX_M1, VSLIDE1DOWN_VX }, // 7678 + { PseudoVSLIDE1DOWN_VX_M1_MASK, VSLIDE1DOWN_VX }, // 7679 + { PseudoVSLIDE1DOWN_VX_M2, VSLIDE1DOWN_VX }, // 7680 + { PseudoVSLIDE1DOWN_VX_M2_MASK, VSLIDE1DOWN_VX }, // 7681 + { PseudoVSLIDE1DOWN_VX_M4, VSLIDE1DOWN_VX }, // 7682 + { PseudoVSLIDE1DOWN_VX_M4_MASK, VSLIDE1DOWN_VX }, // 7683 + { PseudoVSLIDE1DOWN_VX_M8, VSLIDE1DOWN_VX }, // 7684 + { PseudoVSLIDE1DOWN_VX_M8_MASK, VSLIDE1DOWN_VX }, // 7685 + { PseudoVSLIDE1DOWN_VX_MF2, VSLIDE1DOWN_VX }, // 7686 + { PseudoVSLIDE1DOWN_VX_MF2_MASK, VSLIDE1DOWN_VX }, // 7687 + { PseudoVSLIDE1DOWN_VX_MF4, VSLIDE1DOWN_VX }, // 7688 + { PseudoVSLIDE1DOWN_VX_MF4_MASK, VSLIDE1DOWN_VX }, // 7689 + { PseudoVSLIDE1DOWN_VX_MF8, VSLIDE1DOWN_VX }, // 7690 + { PseudoVSLIDE1DOWN_VX_MF8_MASK, VSLIDE1DOWN_VX }, // 7691 + { PseudoVSLIDE1UP_VX_M1, VSLIDE1UP_VX }, // 7692 + { PseudoVSLIDE1UP_VX_M1_MASK, VSLIDE1UP_VX }, // 7693 + { PseudoVSLIDE1UP_VX_M2, VSLIDE1UP_VX }, // 7694 + { PseudoVSLIDE1UP_VX_M2_MASK, VSLIDE1UP_VX }, // 7695 + { PseudoVSLIDE1UP_VX_M4, VSLIDE1UP_VX }, // 7696 + { PseudoVSLIDE1UP_VX_M4_MASK, VSLIDE1UP_VX }, // 7697 + { PseudoVSLIDE1UP_VX_M8, VSLIDE1UP_VX }, // 7698 + { PseudoVSLIDE1UP_VX_M8_MASK, VSLIDE1UP_VX }, // 7699 + { PseudoVSLIDE1UP_VX_MF2, VSLIDE1UP_VX }, // 7700 + { PseudoVSLIDE1UP_VX_MF2_MASK, VSLIDE1UP_VX }, // 7701 + { PseudoVSLIDE1UP_VX_MF4, VSLIDE1UP_VX }, // 7702 + { PseudoVSLIDE1UP_VX_MF4_MASK, VSLIDE1UP_VX }, // 7703 + { PseudoVSLIDE1UP_VX_MF8, VSLIDE1UP_VX }, // 7704 + { PseudoVSLIDE1UP_VX_MF8_MASK, VSLIDE1UP_VX }, // 7705 + { PseudoVSLIDEDOWN_VI_M1, VSLIDEDOWN_VI }, // 7706 + { PseudoVSLIDEDOWN_VI_M1_MASK, VSLIDEDOWN_VI }, // 7707 + { PseudoVSLIDEDOWN_VI_M2, VSLIDEDOWN_VI }, // 7708 + { PseudoVSLIDEDOWN_VI_M2_MASK, VSLIDEDOWN_VI }, // 7709 + { PseudoVSLIDEDOWN_VI_M4, VSLIDEDOWN_VI }, // 7710 + { PseudoVSLIDEDOWN_VI_M4_MASK, VSLIDEDOWN_VI }, // 7711 + { PseudoVSLIDEDOWN_VI_M8, VSLIDEDOWN_VI }, // 7712 + { PseudoVSLIDEDOWN_VI_M8_MASK, VSLIDEDOWN_VI }, // 7713 + { PseudoVSLIDEDOWN_VI_MF2, VSLIDEDOWN_VI }, // 7714 + { PseudoVSLIDEDOWN_VI_MF2_MASK, VSLIDEDOWN_VI }, // 7715 + { PseudoVSLIDEDOWN_VI_MF4, VSLIDEDOWN_VI }, // 7716 + { PseudoVSLIDEDOWN_VI_MF4_MASK, VSLIDEDOWN_VI }, // 7717 + { PseudoVSLIDEDOWN_VI_MF8, VSLIDEDOWN_VI }, // 7718 + { PseudoVSLIDEDOWN_VI_MF8_MASK, VSLIDEDOWN_VI }, // 7719 + { PseudoVSLIDEDOWN_VX_M1, VSLIDEDOWN_VX }, // 7720 + { PseudoVSLIDEDOWN_VX_M1_MASK, VSLIDEDOWN_VX }, // 7721 + { PseudoVSLIDEDOWN_VX_M2, VSLIDEDOWN_VX }, // 7722 + { PseudoVSLIDEDOWN_VX_M2_MASK, VSLIDEDOWN_VX }, // 7723 + { PseudoVSLIDEDOWN_VX_M4, VSLIDEDOWN_VX }, // 7724 + { PseudoVSLIDEDOWN_VX_M4_MASK, VSLIDEDOWN_VX }, // 7725 + { PseudoVSLIDEDOWN_VX_M8, VSLIDEDOWN_VX }, // 7726 + { PseudoVSLIDEDOWN_VX_M8_MASK, VSLIDEDOWN_VX }, // 7727 + { PseudoVSLIDEDOWN_VX_MF2, VSLIDEDOWN_VX }, // 7728 + { PseudoVSLIDEDOWN_VX_MF2_MASK, VSLIDEDOWN_VX }, // 7729 + { PseudoVSLIDEDOWN_VX_MF4, VSLIDEDOWN_VX }, // 7730 + { PseudoVSLIDEDOWN_VX_MF4_MASK, VSLIDEDOWN_VX }, // 7731 + { PseudoVSLIDEDOWN_VX_MF8, VSLIDEDOWN_VX }, // 7732 + { PseudoVSLIDEDOWN_VX_MF8_MASK, VSLIDEDOWN_VX }, // 7733 + { PseudoVSLIDEUP_VI_M1, VSLIDEUP_VI }, // 7734 + { PseudoVSLIDEUP_VI_M1_MASK, VSLIDEUP_VI }, // 7735 + { PseudoVSLIDEUP_VI_M2, VSLIDEUP_VI }, // 7736 + { PseudoVSLIDEUP_VI_M2_MASK, VSLIDEUP_VI }, // 7737 + { PseudoVSLIDEUP_VI_M4, VSLIDEUP_VI }, // 7738 + { PseudoVSLIDEUP_VI_M4_MASK, VSLIDEUP_VI }, // 7739 + { PseudoVSLIDEUP_VI_M8, VSLIDEUP_VI }, // 7740 + { PseudoVSLIDEUP_VI_M8_MASK, VSLIDEUP_VI }, // 7741 + { PseudoVSLIDEUP_VI_MF2, VSLIDEUP_VI }, // 7742 + { PseudoVSLIDEUP_VI_MF2_MASK, VSLIDEUP_VI }, // 7743 + { PseudoVSLIDEUP_VI_MF4, VSLIDEUP_VI }, // 7744 + { PseudoVSLIDEUP_VI_MF4_MASK, VSLIDEUP_VI }, // 7745 + { PseudoVSLIDEUP_VI_MF8, VSLIDEUP_VI }, // 7746 + { PseudoVSLIDEUP_VI_MF8_MASK, VSLIDEUP_VI }, // 7747 + { PseudoVSLIDEUP_VX_M1, VSLIDEUP_VX }, // 7748 + { PseudoVSLIDEUP_VX_M1_MASK, VSLIDEUP_VX }, // 7749 + { PseudoVSLIDEUP_VX_M2, VSLIDEUP_VX }, // 7750 + { PseudoVSLIDEUP_VX_M2_MASK, VSLIDEUP_VX }, // 7751 + { PseudoVSLIDEUP_VX_M4, VSLIDEUP_VX }, // 7752 + { PseudoVSLIDEUP_VX_M4_MASK, VSLIDEUP_VX }, // 7753 + { PseudoVSLIDEUP_VX_M8, VSLIDEUP_VX }, // 7754 + { PseudoVSLIDEUP_VX_M8_MASK, VSLIDEUP_VX }, // 7755 + { PseudoVSLIDEUP_VX_MF2, VSLIDEUP_VX }, // 7756 + { PseudoVSLIDEUP_VX_MF2_MASK, VSLIDEUP_VX }, // 7757 + { PseudoVSLIDEUP_VX_MF4, VSLIDEUP_VX }, // 7758 + { PseudoVSLIDEUP_VX_MF4_MASK, VSLIDEUP_VX }, // 7759 + { PseudoVSLIDEUP_VX_MF8, VSLIDEUP_VX }, // 7760 + { PseudoVSLIDEUP_VX_MF8_MASK, VSLIDEUP_VX }, // 7761 + { PseudoVSLL_VI_M1, VSLL_VI }, // 7762 + { PseudoVSLL_VI_M1_MASK, VSLL_VI }, // 7763 + { PseudoVSLL_VI_M2, VSLL_VI }, // 7764 + { PseudoVSLL_VI_M2_MASK, VSLL_VI }, // 7765 + { PseudoVSLL_VI_M4, VSLL_VI }, // 7766 + { PseudoVSLL_VI_M4_MASK, VSLL_VI }, // 7767 + { PseudoVSLL_VI_M8, VSLL_VI }, // 7768 + { PseudoVSLL_VI_M8_MASK, VSLL_VI }, // 7769 + { PseudoVSLL_VI_MF2, VSLL_VI }, // 7770 + { PseudoVSLL_VI_MF2_MASK, VSLL_VI }, // 7771 + { PseudoVSLL_VI_MF4, VSLL_VI }, // 7772 + { PseudoVSLL_VI_MF4_MASK, VSLL_VI }, // 7773 + { PseudoVSLL_VI_MF8, VSLL_VI }, // 7774 + { PseudoVSLL_VI_MF8_MASK, VSLL_VI }, // 7775 + { PseudoVSLL_VV_M1, VSLL_VV }, // 7776 + { PseudoVSLL_VV_M1_MASK, VSLL_VV }, // 7777 + { PseudoVSLL_VV_M2, VSLL_VV }, // 7778 + { PseudoVSLL_VV_M2_MASK, VSLL_VV }, // 7779 + { PseudoVSLL_VV_M4, VSLL_VV }, // 7780 + { PseudoVSLL_VV_M4_MASK, VSLL_VV }, // 7781 + { PseudoVSLL_VV_M8, VSLL_VV }, // 7782 + { PseudoVSLL_VV_M8_MASK, VSLL_VV }, // 7783 + { PseudoVSLL_VV_MF2, VSLL_VV }, // 7784 + { PseudoVSLL_VV_MF2_MASK, VSLL_VV }, // 7785 + { PseudoVSLL_VV_MF4, VSLL_VV }, // 7786 + { PseudoVSLL_VV_MF4_MASK, VSLL_VV }, // 7787 + { PseudoVSLL_VV_MF8, VSLL_VV }, // 7788 + { PseudoVSLL_VV_MF8_MASK, VSLL_VV }, // 7789 + { PseudoVSLL_VX_M1, VSLL_VX }, // 7790 + { PseudoVSLL_VX_M1_MASK, VSLL_VX }, // 7791 + { PseudoVSLL_VX_M2, VSLL_VX }, // 7792 + { PseudoVSLL_VX_M2_MASK, VSLL_VX }, // 7793 + { PseudoVSLL_VX_M4, VSLL_VX }, // 7794 + { PseudoVSLL_VX_M4_MASK, VSLL_VX }, // 7795 + { PseudoVSLL_VX_M8, VSLL_VX }, // 7796 + { PseudoVSLL_VX_M8_MASK, VSLL_VX }, // 7797 + { PseudoVSLL_VX_MF2, VSLL_VX }, // 7798 + { PseudoVSLL_VX_MF2_MASK, VSLL_VX }, // 7799 + { PseudoVSLL_VX_MF4, VSLL_VX }, // 7800 + { PseudoVSLL_VX_MF4_MASK, VSLL_VX }, // 7801 + { PseudoVSLL_VX_MF8, VSLL_VX }, // 7802 + { PseudoVSLL_VX_MF8_MASK, VSLL_VX }, // 7803 + { PseudoVSM3C_VI_M1, VSM3C_VI }, // 7804 + { PseudoVSM3C_VI_M2, VSM3C_VI }, // 7805 + { PseudoVSM3C_VI_M4, VSM3C_VI }, // 7806 + { PseudoVSM3C_VI_M8, VSM3C_VI }, // 7807 + { PseudoVSM3C_VI_MF2, VSM3C_VI }, // 7808 + { PseudoVSM3ME_VV_M1, VSM3ME_VV }, // 7809 + { PseudoVSM3ME_VV_M2, VSM3ME_VV }, // 7810 + { PseudoVSM3ME_VV_M4, VSM3ME_VV }, // 7811 + { PseudoVSM3ME_VV_M8, VSM3ME_VV }, // 7812 + { PseudoVSM3ME_VV_MF2, VSM3ME_VV }, // 7813 + { PseudoVSM4K_VI_M1, VSM4K_VI }, // 7814 + { PseudoVSM4K_VI_M2, VSM4K_VI }, // 7815 + { PseudoVSM4K_VI_M4, VSM4K_VI }, // 7816 + { PseudoVSM4K_VI_M8, VSM4K_VI }, // 7817 + { PseudoVSM4K_VI_MF2, VSM4K_VI }, // 7818 + { PseudoVSM4R_VS_M1_M1, VSM4R_VS }, // 7819 + { PseudoVSM4R_VS_M1_MF2, VSM4R_VS }, // 7820 + { PseudoVSM4R_VS_M1_MF4, VSM4R_VS }, // 7821 + { PseudoVSM4R_VS_M1_MF8, VSM4R_VS }, // 7822 + { PseudoVSM4R_VS_M2_M1, VSM4R_VS }, // 7823 + { PseudoVSM4R_VS_M2_M2, VSM4R_VS }, // 7824 + { PseudoVSM4R_VS_M2_MF2, VSM4R_VS }, // 7825 + { PseudoVSM4R_VS_M2_MF4, VSM4R_VS }, // 7826 + { PseudoVSM4R_VS_M2_MF8, VSM4R_VS }, // 7827 + { PseudoVSM4R_VS_M4_M1, VSM4R_VS }, // 7828 + { PseudoVSM4R_VS_M4_M2, VSM4R_VS }, // 7829 + { PseudoVSM4R_VS_M4_M4, VSM4R_VS }, // 7830 + { PseudoVSM4R_VS_M4_MF2, VSM4R_VS }, // 7831 + { PseudoVSM4R_VS_M4_MF4, VSM4R_VS }, // 7832 + { PseudoVSM4R_VS_M4_MF8, VSM4R_VS }, // 7833 + { PseudoVSM4R_VS_M8_M1, VSM4R_VS }, // 7834 + { PseudoVSM4R_VS_M8_M2, VSM4R_VS }, // 7835 + { PseudoVSM4R_VS_M8_M4, VSM4R_VS }, // 7836 + { PseudoVSM4R_VS_M8_MF2, VSM4R_VS }, // 7837 + { PseudoVSM4R_VS_M8_MF4, VSM4R_VS }, // 7838 + { PseudoVSM4R_VS_M8_MF8, VSM4R_VS }, // 7839 + { PseudoVSM4R_VS_MF2_MF2, VSM4R_VS }, // 7840 + { PseudoVSM4R_VS_MF2_MF4, VSM4R_VS }, // 7841 + { PseudoVSM4R_VS_MF2_MF8, VSM4R_VS }, // 7842 + { PseudoVSM4R_VV_M1, VSM4R_VV }, // 7843 + { PseudoVSM4R_VV_M2, VSM4R_VV }, // 7844 + { PseudoVSM4R_VV_M4, VSM4R_VV }, // 7845 + { PseudoVSM4R_VV_M8, VSM4R_VV }, // 7846 + { PseudoVSM4R_VV_MF2, VSM4R_VV }, // 7847 + { PseudoVSMUL_VV_M1, VSMUL_VV }, // 7848 + { PseudoVSMUL_VV_M1_MASK, VSMUL_VV }, // 7849 + { PseudoVSMUL_VV_M2, VSMUL_VV }, // 7850 + { PseudoVSMUL_VV_M2_MASK, VSMUL_VV }, // 7851 + { PseudoVSMUL_VV_M4, VSMUL_VV }, // 7852 + { PseudoVSMUL_VV_M4_MASK, VSMUL_VV }, // 7853 + { PseudoVSMUL_VV_M8, VSMUL_VV }, // 7854 + { PseudoVSMUL_VV_M8_MASK, VSMUL_VV }, // 7855 + { PseudoVSMUL_VV_MF2, VSMUL_VV }, // 7856 + { PseudoVSMUL_VV_MF2_MASK, VSMUL_VV }, // 7857 + { PseudoVSMUL_VV_MF4, VSMUL_VV }, // 7858 + { PseudoVSMUL_VV_MF4_MASK, VSMUL_VV }, // 7859 + { PseudoVSMUL_VV_MF8, VSMUL_VV }, // 7860 + { PseudoVSMUL_VV_MF8_MASK, VSMUL_VV }, // 7861 + { PseudoVSMUL_VX_M1, VSMUL_VX }, // 7862 + { PseudoVSMUL_VX_M1_MASK, VSMUL_VX }, // 7863 + { PseudoVSMUL_VX_M2, VSMUL_VX }, // 7864 + { PseudoVSMUL_VX_M2_MASK, VSMUL_VX }, // 7865 + { PseudoVSMUL_VX_M4, VSMUL_VX }, // 7866 + { PseudoVSMUL_VX_M4_MASK, VSMUL_VX }, // 7867 + { PseudoVSMUL_VX_M8, VSMUL_VX }, // 7868 + { PseudoVSMUL_VX_M8_MASK, VSMUL_VX }, // 7869 + { PseudoVSMUL_VX_MF2, VSMUL_VX }, // 7870 + { PseudoVSMUL_VX_MF2_MASK, VSMUL_VX }, // 7871 + { PseudoVSMUL_VX_MF4, VSMUL_VX }, // 7872 + { PseudoVSMUL_VX_MF4_MASK, VSMUL_VX }, // 7873 + { PseudoVSMUL_VX_MF8, VSMUL_VX }, // 7874 + { PseudoVSMUL_VX_MF8_MASK, VSMUL_VX }, // 7875 + { PseudoVSM_V_B1, VSM_V }, // 7876 + { PseudoVSM_V_B16, VSM_V }, // 7877 + { PseudoVSM_V_B2, VSM_V }, // 7878 + { PseudoVSM_V_B32, VSM_V }, // 7879 + { PseudoVSM_V_B4, VSM_V }, // 7880 + { PseudoVSM_V_B64, VSM_V }, // 7881 + { PseudoVSM_V_B8, VSM_V }, // 7882 + { PseudoVSOXEI16_V_M1_M1, VSOXEI16_V }, // 7883 + { PseudoVSOXEI16_V_M1_M1_MASK, VSOXEI16_V }, // 7884 + { PseudoVSOXEI16_V_M1_M2, VSOXEI16_V }, // 7885 + { PseudoVSOXEI16_V_M1_M2_MASK, VSOXEI16_V }, // 7886 + { PseudoVSOXEI16_V_M1_M4, VSOXEI16_V }, // 7887 + { PseudoVSOXEI16_V_M1_M4_MASK, VSOXEI16_V }, // 7888 + { PseudoVSOXEI16_V_M1_MF2, VSOXEI16_V }, // 7889 + { PseudoVSOXEI16_V_M1_MF2_MASK, VSOXEI16_V }, // 7890 + { PseudoVSOXEI16_V_M2_M1, VSOXEI16_V }, // 7891 + { PseudoVSOXEI16_V_M2_M1_MASK, VSOXEI16_V }, // 7892 + { PseudoVSOXEI16_V_M2_M2, VSOXEI16_V }, // 7893 + { PseudoVSOXEI16_V_M2_M2_MASK, VSOXEI16_V }, // 7894 + { PseudoVSOXEI16_V_M2_M4, VSOXEI16_V }, // 7895 + { PseudoVSOXEI16_V_M2_M4_MASK, VSOXEI16_V }, // 7896 + { PseudoVSOXEI16_V_M2_M8, VSOXEI16_V }, // 7897 + { PseudoVSOXEI16_V_M2_M8_MASK, VSOXEI16_V }, // 7898 + { PseudoVSOXEI16_V_M4_M2, VSOXEI16_V }, // 7899 + { PseudoVSOXEI16_V_M4_M2_MASK, VSOXEI16_V }, // 7900 + { PseudoVSOXEI16_V_M4_M4, VSOXEI16_V }, // 7901 + { PseudoVSOXEI16_V_M4_M4_MASK, VSOXEI16_V }, // 7902 + { PseudoVSOXEI16_V_M4_M8, VSOXEI16_V }, // 7903 + { PseudoVSOXEI16_V_M4_M8_MASK, VSOXEI16_V }, // 7904 + { PseudoVSOXEI16_V_M8_M4, VSOXEI16_V }, // 7905 + { PseudoVSOXEI16_V_M8_M4_MASK, VSOXEI16_V }, // 7906 + { PseudoVSOXEI16_V_M8_M8, VSOXEI16_V }, // 7907 + { PseudoVSOXEI16_V_M8_M8_MASK, VSOXEI16_V }, // 7908 + { PseudoVSOXEI16_V_MF2_M1, VSOXEI16_V }, // 7909 + { PseudoVSOXEI16_V_MF2_M1_MASK, VSOXEI16_V }, // 7910 + { PseudoVSOXEI16_V_MF2_M2, VSOXEI16_V }, // 7911 + { PseudoVSOXEI16_V_MF2_M2_MASK, VSOXEI16_V }, // 7912 + { PseudoVSOXEI16_V_MF2_MF2, VSOXEI16_V }, // 7913 + { PseudoVSOXEI16_V_MF2_MF2_MASK, VSOXEI16_V }, // 7914 + { PseudoVSOXEI16_V_MF2_MF4, VSOXEI16_V }, // 7915 + { PseudoVSOXEI16_V_MF2_MF4_MASK, VSOXEI16_V }, // 7916 + { PseudoVSOXEI16_V_MF4_M1, VSOXEI16_V }, // 7917 + { PseudoVSOXEI16_V_MF4_M1_MASK, VSOXEI16_V }, // 7918 + { PseudoVSOXEI16_V_MF4_MF2, VSOXEI16_V }, // 7919 + { PseudoVSOXEI16_V_MF4_MF2_MASK, VSOXEI16_V }, // 7920 + { PseudoVSOXEI16_V_MF4_MF4, VSOXEI16_V }, // 7921 + { PseudoVSOXEI16_V_MF4_MF4_MASK, VSOXEI16_V }, // 7922 + { PseudoVSOXEI16_V_MF4_MF8, VSOXEI16_V }, // 7923 + { PseudoVSOXEI16_V_MF4_MF8_MASK, VSOXEI16_V }, // 7924 + { PseudoVSOXEI32_V_M1_M1, VSOXEI32_V }, // 7925 + { PseudoVSOXEI32_V_M1_M1_MASK, VSOXEI32_V }, // 7926 + { PseudoVSOXEI32_V_M1_M2, VSOXEI32_V }, // 7927 + { PseudoVSOXEI32_V_M1_M2_MASK, VSOXEI32_V }, // 7928 + { PseudoVSOXEI32_V_M1_MF2, VSOXEI32_V }, // 7929 + { PseudoVSOXEI32_V_M1_MF2_MASK, VSOXEI32_V }, // 7930 + { PseudoVSOXEI32_V_M1_MF4, VSOXEI32_V }, // 7931 + { PseudoVSOXEI32_V_M1_MF4_MASK, VSOXEI32_V }, // 7932 + { PseudoVSOXEI32_V_M2_M1, VSOXEI32_V }, // 7933 + { PseudoVSOXEI32_V_M2_M1_MASK, VSOXEI32_V }, // 7934 + { PseudoVSOXEI32_V_M2_M2, VSOXEI32_V }, // 7935 + { PseudoVSOXEI32_V_M2_M2_MASK, VSOXEI32_V }, // 7936 + { PseudoVSOXEI32_V_M2_M4, VSOXEI32_V }, // 7937 + { PseudoVSOXEI32_V_M2_M4_MASK, VSOXEI32_V }, // 7938 + { PseudoVSOXEI32_V_M2_MF2, VSOXEI32_V }, // 7939 + { PseudoVSOXEI32_V_M2_MF2_MASK, VSOXEI32_V }, // 7940 + { PseudoVSOXEI32_V_M4_M1, VSOXEI32_V }, // 7941 + { PseudoVSOXEI32_V_M4_M1_MASK, VSOXEI32_V }, // 7942 + { PseudoVSOXEI32_V_M4_M2, VSOXEI32_V }, // 7943 + { PseudoVSOXEI32_V_M4_M2_MASK, VSOXEI32_V }, // 7944 + { PseudoVSOXEI32_V_M4_M4, VSOXEI32_V }, // 7945 + { PseudoVSOXEI32_V_M4_M4_MASK, VSOXEI32_V }, // 7946 + { PseudoVSOXEI32_V_M4_M8, VSOXEI32_V }, // 7947 + { PseudoVSOXEI32_V_M4_M8_MASK, VSOXEI32_V }, // 7948 + { PseudoVSOXEI32_V_M8_M2, VSOXEI32_V }, // 7949 + { PseudoVSOXEI32_V_M8_M2_MASK, VSOXEI32_V }, // 7950 + { PseudoVSOXEI32_V_M8_M4, VSOXEI32_V }, // 7951 + { PseudoVSOXEI32_V_M8_M4_MASK, VSOXEI32_V }, // 7952 + { PseudoVSOXEI32_V_M8_M8, VSOXEI32_V }, // 7953 + { PseudoVSOXEI32_V_M8_M8_MASK, VSOXEI32_V }, // 7954 + { PseudoVSOXEI32_V_MF2_M1, VSOXEI32_V }, // 7955 + { PseudoVSOXEI32_V_MF2_M1_MASK, VSOXEI32_V }, // 7956 + { PseudoVSOXEI32_V_MF2_MF2, VSOXEI32_V }, // 7957 + { PseudoVSOXEI32_V_MF2_MF2_MASK, VSOXEI32_V }, // 7958 + { PseudoVSOXEI32_V_MF2_MF4, VSOXEI32_V }, // 7959 + { PseudoVSOXEI32_V_MF2_MF4_MASK, VSOXEI32_V }, // 7960 + { PseudoVSOXEI32_V_MF2_MF8, VSOXEI32_V }, // 7961 + { PseudoVSOXEI32_V_MF2_MF8_MASK, VSOXEI32_V }, // 7962 + { PseudoVSOXEI64_V_M1_M1, VSOXEI64_V }, // 7963 + { PseudoVSOXEI64_V_M1_M1_MASK, VSOXEI64_V }, // 7964 + { PseudoVSOXEI64_V_M1_MF2, VSOXEI64_V }, // 7965 + { PseudoVSOXEI64_V_M1_MF2_MASK, VSOXEI64_V }, // 7966 + { PseudoVSOXEI64_V_M1_MF4, VSOXEI64_V }, // 7967 + { PseudoVSOXEI64_V_M1_MF4_MASK, VSOXEI64_V }, // 7968 + { PseudoVSOXEI64_V_M1_MF8, VSOXEI64_V }, // 7969 + { PseudoVSOXEI64_V_M1_MF8_MASK, VSOXEI64_V }, // 7970 + { PseudoVSOXEI64_V_M2_M1, VSOXEI64_V }, // 7971 + { PseudoVSOXEI64_V_M2_M1_MASK, VSOXEI64_V }, // 7972 + { PseudoVSOXEI64_V_M2_M2, VSOXEI64_V }, // 7973 + { PseudoVSOXEI64_V_M2_M2_MASK, VSOXEI64_V }, // 7974 + { PseudoVSOXEI64_V_M2_MF2, VSOXEI64_V }, // 7975 + { PseudoVSOXEI64_V_M2_MF2_MASK, VSOXEI64_V }, // 7976 + { PseudoVSOXEI64_V_M2_MF4, VSOXEI64_V }, // 7977 + { PseudoVSOXEI64_V_M2_MF4_MASK, VSOXEI64_V }, // 7978 + { PseudoVSOXEI64_V_M4_M1, VSOXEI64_V }, // 7979 + { PseudoVSOXEI64_V_M4_M1_MASK, VSOXEI64_V }, // 7980 + { PseudoVSOXEI64_V_M4_M2, VSOXEI64_V }, // 7981 + { PseudoVSOXEI64_V_M4_M2_MASK, VSOXEI64_V }, // 7982 + { PseudoVSOXEI64_V_M4_M4, VSOXEI64_V }, // 7983 + { PseudoVSOXEI64_V_M4_M4_MASK, VSOXEI64_V }, // 7984 + { PseudoVSOXEI64_V_M4_MF2, VSOXEI64_V }, // 7985 + { PseudoVSOXEI64_V_M4_MF2_MASK, VSOXEI64_V }, // 7986 + { PseudoVSOXEI64_V_M8_M1, VSOXEI64_V }, // 7987 + { PseudoVSOXEI64_V_M8_M1_MASK, VSOXEI64_V }, // 7988 + { PseudoVSOXEI64_V_M8_M2, VSOXEI64_V }, // 7989 + { PseudoVSOXEI64_V_M8_M2_MASK, VSOXEI64_V }, // 7990 + { PseudoVSOXEI64_V_M8_M4, VSOXEI64_V }, // 7991 + { PseudoVSOXEI64_V_M8_M4_MASK, VSOXEI64_V }, // 7992 + { PseudoVSOXEI64_V_M8_M8, VSOXEI64_V }, // 7993 + { PseudoVSOXEI64_V_M8_M8_MASK, VSOXEI64_V }, // 7994 + { PseudoVSOXEI8_V_M1_M1, VSOXEI8_V }, // 7995 + { PseudoVSOXEI8_V_M1_M1_MASK, VSOXEI8_V }, // 7996 + { PseudoVSOXEI8_V_M1_M2, VSOXEI8_V }, // 7997 + { PseudoVSOXEI8_V_M1_M2_MASK, VSOXEI8_V }, // 7998 + { PseudoVSOXEI8_V_M1_M4, VSOXEI8_V }, // 7999 + { PseudoVSOXEI8_V_M1_M4_MASK, VSOXEI8_V }, // 8000 + { PseudoVSOXEI8_V_M1_M8, VSOXEI8_V }, // 8001 + { PseudoVSOXEI8_V_M1_M8_MASK, VSOXEI8_V }, // 8002 + { PseudoVSOXEI8_V_M2_M2, VSOXEI8_V }, // 8003 + { PseudoVSOXEI8_V_M2_M2_MASK, VSOXEI8_V }, // 8004 + { PseudoVSOXEI8_V_M2_M4, VSOXEI8_V }, // 8005 + { PseudoVSOXEI8_V_M2_M4_MASK, VSOXEI8_V }, // 8006 + { PseudoVSOXEI8_V_M2_M8, VSOXEI8_V }, // 8007 + { PseudoVSOXEI8_V_M2_M8_MASK, VSOXEI8_V }, // 8008 + { PseudoVSOXEI8_V_M4_M4, VSOXEI8_V }, // 8009 + { PseudoVSOXEI8_V_M4_M4_MASK, VSOXEI8_V }, // 8010 + { PseudoVSOXEI8_V_M4_M8, VSOXEI8_V }, // 8011 + { PseudoVSOXEI8_V_M4_M8_MASK, VSOXEI8_V }, // 8012 + { PseudoVSOXEI8_V_M8_M8, VSOXEI8_V }, // 8013 + { PseudoVSOXEI8_V_M8_M8_MASK, VSOXEI8_V }, // 8014 + { PseudoVSOXEI8_V_MF2_M1, VSOXEI8_V }, // 8015 + { PseudoVSOXEI8_V_MF2_M1_MASK, VSOXEI8_V }, // 8016 + { PseudoVSOXEI8_V_MF2_M2, VSOXEI8_V }, // 8017 + { PseudoVSOXEI8_V_MF2_M2_MASK, VSOXEI8_V }, // 8018 + { PseudoVSOXEI8_V_MF2_M4, VSOXEI8_V }, // 8019 + { PseudoVSOXEI8_V_MF2_M4_MASK, VSOXEI8_V }, // 8020 + { PseudoVSOXEI8_V_MF2_MF2, VSOXEI8_V }, // 8021 + { PseudoVSOXEI8_V_MF2_MF2_MASK, VSOXEI8_V }, // 8022 + { PseudoVSOXEI8_V_MF4_M1, VSOXEI8_V }, // 8023 + { PseudoVSOXEI8_V_MF4_M1_MASK, VSOXEI8_V }, // 8024 + { PseudoVSOXEI8_V_MF4_M2, VSOXEI8_V }, // 8025 + { PseudoVSOXEI8_V_MF4_M2_MASK, VSOXEI8_V }, // 8026 + { PseudoVSOXEI8_V_MF4_MF2, VSOXEI8_V }, // 8027 + { PseudoVSOXEI8_V_MF4_MF2_MASK, VSOXEI8_V }, // 8028 + { PseudoVSOXEI8_V_MF4_MF4, VSOXEI8_V }, // 8029 + { PseudoVSOXEI8_V_MF4_MF4_MASK, VSOXEI8_V }, // 8030 + { PseudoVSOXEI8_V_MF8_M1, VSOXEI8_V }, // 8031 + { PseudoVSOXEI8_V_MF8_M1_MASK, VSOXEI8_V }, // 8032 + { PseudoVSOXEI8_V_MF8_MF2, VSOXEI8_V }, // 8033 + { PseudoVSOXEI8_V_MF8_MF2_MASK, VSOXEI8_V }, // 8034 + { PseudoVSOXEI8_V_MF8_MF4, VSOXEI8_V }, // 8035 + { PseudoVSOXEI8_V_MF8_MF4_MASK, VSOXEI8_V }, // 8036 + { PseudoVSOXEI8_V_MF8_MF8, VSOXEI8_V }, // 8037 + { PseudoVSOXEI8_V_MF8_MF8_MASK, VSOXEI8_V }, // 8038 + { PseudoVSOXSEG2EI16_V_M1_M1, VSOXSEG2EI16_V }, // 8039 + { PseudoVSOXSEG2EI16_V_M1_M1_MASK, VSOXSEG2EI16_V }, // 8040 + { PseudoVSOXSEG2EI16_V_M1_M2, VSOXSEG2EI16_V }, // 8041 + { PseudoVSOXSEG2EI16_V_M1_M2_MASK, VSOXSEG2EI16_V }, // 8042 + { PseudoVSOXSEG2EI16_V_M1_M4, VSOXSEG2EI16_V }, // 8043 + { PseudoVSOXSEG2EI16_V_M1_M4_MASK, VSOXSEG2EI16_V }, // 8044 + { PseudoVSOXSEG2EI16_V_M1_MF2, VSOXSEG2EI16_V }, // 8045 + { PseudoVSOXSEG2EI16_V_M1_MF2_MASK, VSOXSEG2EI16_V }, // 8046 + { PseudoVSOXSEG2EI16_V_M2_M1, VSOXSEG2EI16_V }, // 8047 + { PseudoVSOXSEG2EI16_V_M2_M1_MASK, VSOXSEG2EI16_V }, // 8048 + { PseudoVSOXSEG2EI16_V_M2_M2, VSOXSEG2EI16_V }, // 8049 + { PseudoVSOXSEG2EI16_V_M2_M2_MASK, VSOXSEG2EI16_V }, // 8050 + { PseudoVSOXSEG2EI16_V_M2_M4, VSOXSEG2EI16_V }, // 8051 + { PseudoVSOXSEG2EI16_V_M2_M4_MASK, VSOXSEG2EI16_V }, // 8052 + { PseudoVSOXSEG2EI16_V_M4_M2, VSOXSEG2EI16_V }, // 8053 + { PseudoVSOXSEG2EI16_V_M4_M2_MASK, VSOXSEG2EI16_V }, // 8054 + { PseudoVSOXSEG2EI16_V_M4_M4, VSOXSEG2EI16_V }, // 8055 + { PseudoVSOXSEG2EI16_V_M4_M4_MASK, VSOXSEG2EI16_V }, // 8056 + { PseudoVSOXSEG2EI16_V_M8_M4, VSOXSEG2EI16_V }, // 8057 + { PseudoVSOXSEG2EI16_V_M8_M4_MASK, VSOXSEG2EI16_V }, // 8058 + { PseudoVSOXSEG2EI16_V_MF2_M1, VSOXSEG2EI16_V }, // 8059 + { PseudoVSOXSEG2EI16_V_MF2_M1_MASK, VSOXSEG2EI16_V }, // 8060 + { PseudoVSOXSEG2EI16_V_MF2_M2, VSOXSEG2EI16_V }, // 8061 + { PseudoVSOXSEG2EI16_V_MF2_M2_MASK, VSOXSEG2EI16_V }, // 8062 + { PseudoVSOXSEG2EI16_V_MF2_MF2, VSOXSEG2EI16_V }, // 8063 + { PseudoVSOXSEG2EI16_V_MF2_MF2_MASK, VSOXSEG2EI16_V }, // 8064 + { PseudoVSOXSEG2EI16_V_MF2_MF4, VSOXSEG2EI16_V }, // 8065 + { PseudoVSOXSEG2EI16_V_MF2_MF4_MASK, VSOXSEG2EI16_V }, // 8066 + { PseudoVSOXSEG2EI16_V_MF4_M1, VSOXSEG2EI16_V }, // 8067 + { PseudoVSOXSEG2EI16_V_MF4_M1_MASK, VSOXSEG2EI16_V }, // 8068 + { PseudoVSOXSEG2EI16_V_MF4_MF2, VSOXSEG2EI16_V }, // 8069 + { PseudoVSOXSEG2EI16_V_MF4_MF2_MASK, VSOXSEG2EI16_V }, // 8070 + { PseudoVSOXSEG2EI16_V_MF4_MF4, VSOXSEG2EI16_V }, // 8071 + { PseudoVSOXSEG2EI16_V_MF4_MF4_MASK, VSOXSEG2EI16_V }, // 8072 + { PseudoVSOXSEG2EI16_V_MF4_MF8, VSOXSEG2EI16_V }, // 8073 + { PseudoVSOXSEG2EI16_V_MF4_MF8_MASK, VSOXSEG2EI16_V }, // 8074 + { PseudoVSOXSEG2EI32_V_M1_M1, VSOXSEG2EI32_V }, // 8075 + { PseudoVSOXSEG2EI32_V_M1_M1_MASK, VSOXSEG2EI32_V }, // 8076 + { PseudoVSOXSEG2EI32_V_M1_M2, VSOXSEG2EI32_V }, // 8077 + { PseudoVSOXSEG2EI32_V_M1_M2_MASK, VSOXSEG2EI32_V }, // 8078 + { PseudoVSOXSEG2EI32_V_M1_MF2, VSOXSEG2EI32_V }, // 8079 + { PseudoVSOXSEG2EI32_V_M1_MF2_MASK, VSOXSEG2EI32_V }, // 8080 + { PseudoVSOXSEG2EI32_V_M1_MF4, VSOXSEG2EI32_V }, // 8081 + { PseudoVSOXSEG2EI32_V_M1_MF4_MASK, VSOXSEG2EI32_V }, // 8082 + { PseudoVSOXSEG2EI32_V_M2_M1, VSOXSEG2EI32_V }, // 8083 + { PseudoVSOXSEG2EI32_V_M2_M1_MASK, VSOXSEG2EI32_V }, // 8084 + { PseudoVSOXSEG2EI32_V_M2_M2, VSOXSEG2EI32_V }, // 8085 + { PseudoVSOXSEG2EI32_V_M2_M2_MASK, VSOXSEG2EI32_V }, // 8086 + { PseudoVSOXSEG2EI32_V_M2_M4, VSOXSEG2EI32_V }, // 8087 + { PseudoVSOXSEG2EI32_V_M2_M4_MASK, VSOXSEG2EI32_V }, // 8088 + { PseudoVSOXSEG2EI32_V_M2_MF2, VSOXSEG2EI32_V }, // 8089 + { PseudoVSOXSEG2EI32_V_M2_MF2_MASK, VSOXSEG2EI32_V }, // 8090 + { PseudoVSOXSEG2EI32_V_M4_M1, VSOXSEG2EI32_V }, // 8091 + { PseudoVSOXSEG2EI32_V_M4_M1_MASK, VSOXSEG2EI32_V }, // 8092 + { PseudoVSOXSEG2EI32_V_M4_M2, VSOXSEG2EI32_V }, // 8093 + { PseudoVSOXSEG2EI32_V_M4_M2_MASK, VSOXSEG2EI32_V }, // 8094 + { PseudoVSOXSEG2EI32_V_M4_M4, VSOXSEG2EI32_V }, // 8095 + { PseudoVSOXSEG2EI32_V_M4_M4_MASK, VSOXSEG2EI32_V }, // 8096 + { PseudoVSOXSEG2EI32_V_M8_M2, VSOXSEG2EI32_V }, // 8097 + { PseudoVSOXSEG2EI32_V_M8_M2_MASK, VSOXSEG2EI32_V }, // 8098 + { PseudoVSOXSEG2EI32_V_M8_M4, VSOXSEG2EI32_V }, // 8099 + { PseudoVSOXSEG2EI32_V_M8_M4_MASK, VSOXSEG2EI32_V }, // 8100 + { PseudoVSOXSEG2EI32_V_MF2_M1, VSOXSEG2EI32_V }, // 8101 + { PseudoVSOXSEG2EI32_V_MF2_M1_MASK, VSOXSEG2EI32_V }, // 8102 + { PseudoVSOXSEG2EI32_V_MF2_MF2, VSOXSEG2EI32_V }, // 8103 + { PseudoVSOXSEG2EI32_V_MF2_MF2_MASK, VSOXSEG2EI32_V }, // 8104 + { PseudoVSOXSEG2EI32_V_MF2_MF4, VSOXSEG2EI32_V }, // 8105 + { PseudoVSOXSEG2EI32_V_MF2_MF4_MASK, VSOXSEG2EI32_V }, // 8106 + { PseudoVSOXSEG2EI32_V_MF2_MF8, VSOXSEG2EI32_V }, // 8107 + { PseudoVSOXSEG2EI32_V_MF2_MF8_MASK, VSOXSEG2EI32_V }, // 8108 + { PseudoVSOXSEG2EI64_V_M1_M1, VSOXSEG2EI64_V }, // 8109 + { PseudoVSOXSEG2EI64_V_M1_M1_MASK, VSOXSEG2EI64_V }, // 8110 + { PseudoVSOXSEG2EI64_V_M1_MF2, VSOXSEG2EI64_V }, // 8111 + { PseudoVSOXSEG2EI64_V_M1_MF2_MASK, VSOXSEG2EI64_V }, // 8112 + { PseudoVSOXSEG2EI64_V_M1_MF4, VSOXSEG2EI64_V }, // 8113 + { PseudoVSOXSEG2EI64_V_M1_MF4_MASK, VSOXSEG2EI64_V }, // 8114 + { PseudoVSOXSEG2EI64_V_M1_MF8, VSOXSEG2EI64_V }, // 8115 + { PseudoVSOXSEG2EI64_V_M1_MF8_MASK, VSOXSEG2EI64_V }, // 8116 + { PseudoVSOXSEG2EI64_V_M2_M1, VSOXSEG2EI64_V }, // 8117 + { PseudoVSOXSEG2EI64_V_M2_M1_MASK, VSOXSEG2EI64_V }, // 8118 + { PseudoVSOXSEG2EI64_V_M2_M2, VSOXSEG2EI64_V }, // 8119 + { PseudoVSOXSEG2EI64_V_M2_M2_MASK, VSOXSEG2EI64_V }, // 8120 + { PseudoVSOXSEG2EI64_V_M2_MF2, VSOXSEG2EI64_V }, // 8121 + { PseudoVSOXSEG2EI64_V_M2_MF2_MASK, VSOXSEG2EI64_V }, // 8122 + { PseudoVSOXSEG2EI64_V_M2_MF4, VSOXSEG2EI64_V }, // 8123 + { PseudoVSOXSEG2EI64_V_M2_MF4_MASK, VSOXSEG2EI64_V }, // 8124 + { PseudoVSOXSEG2EI64_V_M4_M1, VSOXSEG2EI64_V }, // 8125 + { PseudoVSOXSEG2EI64_V_M4_M1_MASK, VSOXSEG2EI64_V }, // 8126 + { PseudoVSOXSEG2EI64_V_M4_M2, VSOXSEG2EI64_V }, // 8127 + { PseudoVSOXSEG2EI64_V_M4_M2_MASK, VSOXSEG2EI64_V }, // 8128 + { PseudoVSOXSEG2EI64_V_M4_M4, VSOXSEG2EI64_V }, // 8129 + { PseudoVSOXSEG2EI64_V_M4_M4_MASK, VSOXSEG2EI64_V }, // 8130 + { PseudoVSOXSEG2EI64_V_M4_MF2, VSOXSEG2EI64_V }, // 8131 + { PseudoVSOXSEG2EI64_V_M4_MF2_MASK, VSOXSEG2EI64_V }, // 8132 + { PseudoVSOXSEG2EI64_V_M8_M1, VSOXSEG2EI64_V }, // 8133 + { PseudoVSOXSEG2EI64_V_M8_M1_MASK, VSOXSEG2EI64_V }, // 8134 + { PseudoVSOXSEG2EI64_V_M8_M2, VSOXSEG2EI64_V }, // 8135 + { PseudoVSOXSEG2EI64_V_M8_M2_MASK, VSOXSEG2EI64_V }, // 8136 + { PseudoVSOXSEG2EI64_V_M8_M4, VSOXSEG2EI64_V }, // 8137 + { PseudoVSOXSEG2EI64_V_M8_M4_MASK, VSOXSEG2EI64_V }, // 8138 + { PseudoVSOXSEG2EI8_V_M1_M1, VSOXSEG2EI8_V }, // 8139 + { PseudoVSOXSEG2EI8_V_M1_M1_MASK, VSOXSEG2EI8_V }, // 8140 + { PseudoVSOXSEG2EI8_V_M1_M2, VSOXSEG2EI8_V }, // 8141 + { PseudoVSOXSEG2EI8_V_M1_M2_MASK, VSOXSEG2EI8_V }, // 8142 + { PseudoVSOXSEG2EI8_V_M1_M4, VSOXSEG2EI8_V }, // 8143 + { PseudoVSOXSEG2EI8_V_M1_M4_MASK, VSOXSEG2EI8_V }, // 8144 + { PseudoVSOXSEG2EI8_V_M2_M2, VSOXSEG2EI8_V }, // 8145 + { PseudoVSOXSEG2EI8_V_M2_M2_MASK, VSOXSEG2EI8_V }, // 8146 + { PseudoVSOXSEG2EI8_V_M2_M4, VSOXSEG2EI8_V }, // 8147 + { PseudoVSOXSEG2EI8_V_M2_M4_MASK, VSOXSEG2EI8_V }, // 8148 + { PseudoVSOXSEG2EI8_V_M4_M4, VSOXSEG2EI8_V }, // 8149 + { PseudoVSOXSEG2EI8_V_M4_M4_MASK, VSOXSEG2EI8_V }, // 8150 + { PseudoVSOXSEG2EI8_V_MF2_M1, VSOXSEG2EI8_V }, // 8151 + { PseudoVSOXSEG2EI8_V_MF2_M1_MASK, VSOXSEG2EI8_V }, // 8152 + { PseudoVSOXSEG2EI8_V_MF2_M2, VSOXSEG2EI8_V }, // 8153 + { PseudoVSOXSEG2EI8_V_MF2_M2_MASK, VSOXSEG2EI8_V }, // 8154 + { PseudoVSOXSEG2EI8_V_MF2_M4, VSOXSEG2EI8_V }, // 8155 + { PseudoVSOXSEG2EI8_V_MF2_M4_MASK, VSOXSEG2EI8_V }, // 8156 + { PseudoVSOXSEG2EI8_V_MF2_MF2, VSOXSEG2EI8_V }, // 8157 + { PseudoVSOXSEG2EI8_V_MF2_MF2_MASK, VSOXSEG2EI8_V }, // 8158 + { PseudoVSOXSEG2EI8_V_MF4_M1, VSOXSEG2EI8_V }, // 8159 + { PseudoVSOXSEG2EI8_V_MF4_M1_MASK, VSOXSEG2EI8_V }, // 8160 + { PseudoVSOXSEG2EI8_V_MF4_M2, VSOXSEG2EI8_V }, // 8161 + { PseudoVSOXSEG2EI8_V_MF4_M2_MASK, VSOXSEG2EI8_V }, // 8162 + { PseudoVSOXSEG2EI8_V_MF4_MF2, VSOXSEG2EI8_V }, // 8163 + { PseudoVSOXSEG2EI8_V_MF4_MF2_MASK, VSOXSEG2EI8_V }, // 8164 + { PseudoVSOXSEG2EI8_V_MF4_MF4, VSOXSEG2EI8_V }, // 8165 + { PseudoVSOXSEG2EI8_V_MF4_MF4_MASK, VSOXSEG2EI8_V }, // 8166 + { PseudoVSOXSEG2EI8_V_MF8_M1, VSOXSEG2EI8_V }, // 8167 + { PseudoVSOXSEG2EI8_V_MF8_M1_MASK, VSOXSEG2EI8_V }, // 8168 + { PseudoVSOXSEG2EI8_V_MF8_MF2, VSOXSEG2EI8_V }, // 8169 + { PseudoVSOXSEG2EI8_V_MF8_MF2_MASK, VSOXSEG2EI8_V }, // 8170 + { PseudoVSOXSEG2EI8_V_MF8_MF4, VSOXSEG2EI8_V }, // 8171 + { PseudoVSOXSEG2EI8_V_MF8_MF4_MASK, VSOXSEG2EI8_V }, // 8172 + { PseudoVSOXSEG2EI8_V_MF8_MF8, VSOXSEG2EI8_V }, // 8173 + { PseudoVSOXSEG2EI8_V_MF8_MF8_MASK, VSOXSEG2EI8_V }, // 8174 + { PseudoVSOXSEG3EI16_V_M1_M1, VSOXSEG3EI16_V }, // 8175 + { PseudoVSOXSEG3EI16_V_M1_M1_MASK, VSOXSEG3EI16_V }, // 8176 + { PseudoVSOXSEG3EI16_V_M1_M2, VSOXSEG3EI16_V }, // 8177 + { PseudoVSOXSEG3EI16_V_M1_M2_MASK, VSOXSEG3EI16_V }, // 8178 + { PseudoVSOXSEG3EI16_V_M1_MF2, VSOXSEG3EI16_V }, // 8179 + { PseudoVSOXSEG3EI16_V_M1_MF2_MASK, VSOXSEG3EI16_V }, // 8180 + { PseudoVSOXSEG3EI16_V_M2_M1, VSOXSEG3EI16_V }, // 8181 + { PseudoVSOXSEG3EI16_V_M2_M1_MASK, VSOXSEG3EI16_V }, // 8182 + { PseudoVSOXSEG3EI16_V_M2_M2, VSOXSEG3EI16_V }, // 8183 + { PseudoVSOXSEG3EI16_V_M2_M2_MASK, VSOXSEG3EI16_V }, // 8184 + { PseudoVSOXSEG3EI16_V_M4_M2, VSOXSEG3EI16_V }, // 8185 + { PseudoVSOXSEG3EI16_V_M4_M2_MASK, VSOXSEG3EI16_V }, // 8186 + { PseudoVSOXSEG3EI16_V_MF2_M1, VSOXSEG3EI16_V }, // 8187 + { PseudoVSOXSEG3EI16_V_MF2_M1_MASK, VSOXSEG3EI16_V }, // 8188 + { PseudoVSOXSEG3EI16_V_MF2_M2, VSOXSEG3EI16_V }, // 8189 + { PseudoVSOXSEG3EI16_V_MF2_M2_MASK, VSOXSEG3EI16_V }, // 8190 + { PseudoVSOXSEG3EI16_V_MF2_MF2, VSOXSEG3EI16_V }, // 8191 + { PseudoVSOXSEG3EI16_V_MF2_MF2_MASK, VSOXSEG3EI16_V }, // 8192 + { PseudoVSOXSEG3EI16_V_MF2_MF4, VSOXSEG3EI16_V }, // 8193 + { PseudoVSOXSEG3EI16_V_MF2_MF4_MASK, VSOXSEG3EI16_V }, // 8194 + { PseudoVSOXSEG3EI16_V_MF4_M1, VSOXSEG3EI16_V }, // 8195 + { PseudoVSOXSEG3EI16_V_MF4_M1_MASK, VSOXSEG3EI16_V }, // 8196 + { PseudoVSOXSEG3EI16_V_MF4_MF2, VSOXSEG3EI16_V }, // 8197 + { PseudoVSOXSEG3EI16_V_MF4_MF2_MASK, VSOXSEG3EI16_V }, // 8198 + { PseudoVSOXSEG3EI16_V_MF4_MF4, VSOXSEG3EI16_V }, // 8199 + { PseudoVSOXSEG3EI16_V_MF4_MF4_MASK, VSOXSEG3EI16_V }, // 8200 + { PseudoVSOXSEG3EI16_V_MF4_MF8, VSOXSEG3EI16_V }, // 8201 + { PseudoVSOXSEG3EI16_V_MF4_MF8_MASK, VSOXSEG3EI16_V }, // 8202 + { PseudoVSOXSEG3EI32_V_M1_M1, VSOXSEG3EI32_V }, // 8203 + { PseudoVSOXSEG3EI32_V_M1_M1_MASK, VSOXSEG3EI32_V }, // 8204 + { PseudoVSOXSEG3EI32_V_M1_M2, VSOXSEG3EI32_V }, // 8205 + { PseudoVSOXSEG3EI32_V_M1_M2_MASK, VSOXSEG3EI32_V }, // 8206 + { PseudoVSOXSEG3EI32_V_M1_MF2, VSOXSEG3EI32_V }, // 8207 + { PseudoVSOXSEG3EI32_V_M1_MF2_MASK, VSOXSEG3EI32_V }, // 8208 + { PseudoVSOXSEG3EI32_V_M1_MF4, VSOXSEG3EI32_V }, // 8209 + { PseudoVSOXSEG3EI32_V_M1_MF4_MASK, VSOXSEG3EI32_V }, // 8210 + { PseudoVSOXSEG3EI32_V_M2_M1, VSOXSEG3EI32_V }, // 8211 + { PseudoVSOXSEG3EI32_V_M2_M1_MASK, VSOXSEG3EI32_V }, // 8212 + { PseudoVSOXSEG3EI32_V_M2_M2, VSOXSEG3EI32_V }, // 8213 + { PseudoVSOXSEG3EI32_V_M2_M2_MASK, VSOXSEG3EI32_V }, // 8214 + { PseudoVSOXSEG3EI32_V_M2_MF2, VSOXSEG3EI32_V }, // 8215 + { PseudoVSOXSEG3EI32_V_M2_MF2_MASK, VSOXSEG3EI32_V }, // 8216 + { PseudoVSOXSEG3EI32_V_M4_M1, VSOXSEG3EI32_V }, // 8217 + { PseudoVSOXSEG3EI32_V_M4_M1_MASK, VSOXSEG3EI32_V }, // 8218 + { PseudoVSOXSEG3EI32_V_M4_M2, VSOXSEG3EI32_V }, // 8219 + { PseudoVSOXSEG3EI32_V_M4_M2_MASK, VSOXSEG3EI32_V }, // 8220 + { PseudoVSOXSEG3EI32_V_M8_M2, VSOXSEG3EI32_V }, // 8221 + { PseudoVSOXSEG3EI32_V_M8_M2_MASK, VSOXSEG3EI32_V }, // 8222 + { PseudoVSOXSEG3EI32_V_MF2_M1, VSOXSEG3EI32_V }, // 8223 + { PseudoVSOXSEG3EI32_V_MF2_M1_MASK, VSOXSEG3EI32_V }, // 8224 + { PseudoVSOXSEG3EI32_V_MF2_MF2, VSOXSEG3EI32_V }, // 8225 + { PseudoVSOXSEG3EI32_V_MF2_MF2_MASK, VSOXSEG3EI32_V }, // 8226 + { PseudoVSOXSEG3EI32_V_MF2_MF4, VSOXSEG3EI32_V }, // 8227 + { PseudoVSOXSEG3EI32_V_MF2_MF4_MASK, VSOXSEG3EI32_V }, // 8228 + { PseudoVSOXSEG3EI32_V_MF2_MF8, VSOXSEG3EI32_V }, // 8229 + { PseudoVSOXSEG3EI32_V_MF2_MF8_MASK, VSOXSEG3EI32_V }, // 8230 + { PseudoVSOXSEG3EI64_V_M1_M1, VSOXSEG3EI64_V }, // 8231 + { PseudoVSOXSEG3EI64_V_M1_M1_MASK, VSOXSEG3EI64_V }, // 8232 + { PseudoVSOXSEG3EI64_V_M1_MF2, VSOXSEG3EI64_V }, // 8233 + { PseudoVSOXSEG3EI64_V_M1_MF2_MASK, VSOXSEG3EI64_V }, // 8234 + { PseudoVSOXSEG3EI64_V_M1_MF4, VSOXSEG3EI64_V }, // 8235 + { PseudoVSOXSEG3EI64_V_M1_MF4_MASK, VSOXSEG3EI64_V }, // 8236 + { PseudoVSOXSEG3EI64_V_M1_MF8, VSOXSEG3EI64_V }, // 8237 + { PseudoVSOXSEG3EI64_V_M1_MF8_MASK, VSOXSEG3EI64_V }, // 8238 + { PseudoVSOXSEG3EI64_V_M2_M1, VSOXSEG3EI64_V }, // 8239 + { PseudoVSOXSEG3EI64_V_M2_M1_MASK, VSOXSEG3EI64_V }, // 8240 + { PseudoVSOXSEG3EI64_V_M2_M2, VSOXSEG3EI64_V }, // 8241 + { PseudoVSOXSEG3EI64_V_M2_M2_MASK, VSOXSEG3EI64_V }, // 8242 + { PseudoVSOXSEG3EI64_V_M2_MF2, VSOXSEG3EI64_V }, // 8243 + { PseudoVSOXSEG3EI64_V_M2_MF2_MASK, VSOXSEG3EI64_V }, // 8244 + { PseudoVSOXSEG3EI64_V_M2_MF4, VSOXSEG3EI64_V }, // 8245 + { PseudoVSOXSEG3EI64_V_M2_MF4_MASK, VSOXSEG3EI64_V }, // 8246 + { PseudoVSOXSEG3EI64_V_M4_M1, VSOXSEG3EI64_V }, // 8247 + { PseudoVSOXSEG3EI64_V_M4_M1_MASK, VSOXSEG3EI64_V }, // 8248 + { PseudoVSOXSEG3EI64_V_M4_M2, VSOXSEG3EI64_V }, // 8249 + { PseudoVSOXSEG3EI64_V_M4_M2_MASK, VSOXSEG3EI64_V }, // 8250 + { PseudoVSOXSEG3EI64_V_M4_MF2, VSOXSEG3EI64_V }, // 8251 + { PseudoVSOXSEG3EI64_V_M4_MF2_MASK, VSOXSEG3EI64_V }, // 8252 + { PseudoVSOXSEG3EI64_V_M8_M1, VSOXSEG3EI64_V }, // 8253 + { PseudoVSOXSEG3EI64_V_M8_M1_MASK, VSOXSEG3EI64_V }, // 8254 + { PseudoVSOXSEG3EI64_V_M8_M2, VSOXSEG3EI64_V }, // 8255 + { PseudoVSOXSEG3EI64_V_M8_M2_MASK, VSOXSEG3EI64_V }, // 8256 + { PseudoVSOXSEG3EI8_V_M1_M1, VSOXSEG3EI8_V }, // 8257 + { PseudoVSOXSEG3EI8_V_M1_M1_MASK, VSOXSEG3EI8_V }, // 8258 + { PseudoVSOXSEG3EI8_V_M1_M2, VSOXSEG3EI8_V }, // 8259 + { PseudoVSOXSEG3EI8_V_M1_M2_MASK, VSOXSEG3EI8_V }, // 8260 + { PseudoVSOXSEG3EI8_V_M2_M2, VSOXSEG3EI8_V }, // 8261 + { PseudoVSOXSEG3EI8_V_M2_M2_MASK, VSOXSEG3EI8_V }, // 8262 + { PseudoVSOXSEG3EI8_V_MF2_M1, VSOXSEG3EI8_V }, // 8263 + { PseudoVSOXSEG3EI8_V_MF2_M1_MASK, VSOXSEG3EI8_V }, // 8264 + { PseudoVSOXSEG3EI8_V_MF2_M2, VSOXSEG3EI8_V }, // 8265 + { PseudoVSOXSEG3EI8_V_MF2_M2_MASK, VSOXSEG3EI8_V }, // 8266 + { PseudoVSOXSEG3EI8_V_MF2_MF2, VSOXSEG3EI8_V }, // 8267 + { PseudoVSOXSEG3EI8_V_MF2_MF2_MASK, VSOXSEG3EI8_V }, // 8268 + { PseudoVSOXSEG3EI8_V_MF4_M1, VSOXSEG3EI8_V }, // 8269 + { PseudoVSOXSEG3EI8_V_MF4_M1_MASK, VSOXSEG3EI8_V }, // 8270 + { PseudoVSOXSEG3EI8_V_MF4_M2, VSOXSEG3EI8_V }, // 8271 + { PseudoVSOXSEG3EI8_V_MF4_M2_MASK, VSOXSEG3EI8_V }, // 8272 + { PseudoVSOXSEG3EI8_V_MF4_MF2, VSOXSEG3EI8_V }, // 8273 + { PseudoVSOXSEG3EI8_V_MF4_MF2_MASK, VSOXSEG3EI8_V }, // 8274 + { PseudoVSOXSEG3EI8_V_MF4_MF4, VSOXSEG3EI8_V }, // 8275 + { PseudoVSOXSEG3EI8_V_MF4_MF4_MASK, VSOXSEG3EI8_V }, // 8276 + { PseudoVSOXSEG3EI8_V_MF8_M1, VSOXSEG3EI8_V }, // 8277 + { PseudoVSOXSEG3EI8_V_MF8_M1_MASK, VSOXSEG3EI8_V }, // 8278 + { PseudoVSOXSEG3EI8_V_MF8_MF2, VSOXSEG3EI8_V }, // 8279 + { PseudoVSOXSEG3EI8_V_MF8_MF2_MASK, VSOXSEG3EI8_V }, // 8280 + { PseudoVSOXSEG3EI8_V_MF8_MF4, VSOXSEG3EI8_V }, // 8281 + { PseudoVSOXSEG3EI8_V_MF8_MF4_MASK, VSOXSEG3EI8_V }, // 8282 + { PseudoVSOXSEG3EI8_V_MF8_MF8, VSOXSEG3EI8_V }, // 8283 + { PseudoVSOXSEG3EI8_V_MF8_MF8_MASK, VSOXSEG3EI8_V }, // 8284 + { PseudoVSOXSEG4EI16_V_M1_M1, VSOXSEG4EI16_V }, // 8285 + { PseudoVSOXSEG4EI16_V_M1_M1_MASK, VSOXSEG4EI16_V }, // 8286 + { PseudoVSOXSEG4EI16_V_M1_M2, VSOXSEG4EI16_V }, // 8287 + { PseudoVSOXSEG4EI16_V_M1_M2_MASK, VSOXSEG4EI16_V }, // 8288 + { PseudoVSOXSEG4EI16_V_M1_MF2, VSOXSEG4EI16_V }, // 8289 + { PseudoVSOXSEG4EI16_V_M1_MF2_MASK, VSOXSEG4EI16_V }, // 8290 + { PseudoVSOXSEG4EI16_V_M2_M1, VSOXSEG4EI16_V }, // 8291 + { PseudoVSOXSEG4EI16_V_M2_M1_MASK, VSOXSEG4EI16_V }, // 8292 + { PseudoVSOXSEG4EI16_V_M2_M2, VSOXSEG4EI16_V }, // 8293 + { PseudoVSOXSEG4EI16_V_M2_M2_MASK, VSOXSEG4EI16_V }, // 8294 + { PseudoVSOXSEG4EI16_V_M4_M2, VSOXSEG4EI16_V }, // 8295 + { PseudoVSOXSEG4EI16_V_M4_M2_MASK, VSOXSEG4EI16_V }, // 8296 + { PseudoVSOXSEG4EI16_V_MF2_M1, VSOXSEG4EI16_V }, // 8297 + { PseudoVSOXSEG4EI16_V_MF2_M1_MASK, VSOXSEG4EI16_V }, // 8298 + { PseudoVSOXSEG4EI16_V_MF2_M2, VSOXSEG4EI16_V }, // 8299 + { PseudoVSOXSEG4EI16_V_MF2_M2_MASK, VSOXSEG4EI16_V }, // 8300 + { PseudoVSOXSEG4EI16_V_MF2_MF2, VSOXSEG4EI16_V }, // 8301 + { PseudoVSOXSEG4EI16_V_MF2_MF2_MASK, VSOXSEG4EI16_V }, // 8302 + { PseudoVSOXSEG4EI16_V_MF2_MF4, VSOXSEG4EI16_V }, // 8303 + { PseudoVSOXSEG4EI16_V_MF2_MF4_MASK, VSOXSEG4EI16_V }, // 8304 + { PseudoVSOXSEG4EI16_V_MF4_M1, VSOXSEG4EI16_V }, // 8305 + { PseudoVSOXSEG4EI16_V_MF4_M1_MASK, VSOXSEG4EI16_V }, // 8306 + { PseudoVSOXSEG4EI16_V_MF4_MF2, VSOXSEG4EI16_V }, // 8307 + { PseudoVSOXSEG4EI16_V_MF4_MF2_MASK, VSOXSEG4EI16_V }, // 8308 + { PseudoVSOXSEG4EI16_V_MF4_MF4, VSOXSEG4EI16_V }, // 8309 + { PseudoVSOXSEG4EI16_V_MF4_MF4_MASK, VSOXSEG4EI16_V }, // 8310 + { PseudoVSOXSEG4EI16_V_MF4_MF8, VSOXSEG4EI16_V }, // 8311 + { PseudoVSOXSEG4EI16_V_MF4_MF8_MASK, VSOXSEG4EI16_V }, // 8312 + { PseudoVSOXSEG4EI32_V_M1_M1, VSOXSEG4EI32_V }, // 8313 + { PseudoVSOXSEG4EI32_V_M1_M1_MASK, VSOXSEG4EI32_V }, // 8314 + { PseudoVSOXSEG4EI32_V_M1_M2, VSOXSEG4EI32_V }, // 8315 + { PseudoVSOXSEG4EI32_V_M1_M2_MASK, VSOXSEG4EI32_V }, // 8316 + { PseudoVSOXSEG4EI32_V_M1_MF2, VSOXSEG4EI32_V }, // 8317 + { PseudoVSOXSEG4EI32_V_M1_MF2_MASK, VSOXSEG4EI32_V }, // 8318 + { PseudoVSOXSEG4EI32_V_M1_MF4, VSOXSEG4EI32_V }, // 8319 + { PseudoVSOXSEG4EI32_V_M1_MF4_MASK, VSOXSEG4EI32_V }, // 8320 + { PseudoVSOXSEG4EI32_V_M2_M1, VSOXSEG4EI32_V }, // 8321 + { PseudoVSOXSEG4EI32_V_M2_M1_MASK, VSOXSEG4EI32_V }, // 8322 + { PseudoVSOXSEG4EI32_V_M2_M2, VSOXSEG4EI32_V }, // 8323 + { PseudoVSOXSEG4EI32_V_M2_M2_MASK, VSOXSEG4EI32_V }, // 8324 + { PseudoVSOXSEG4EI32_V_M2_MF2, VSOXSEG4EI32_V }, // 8325 + { PseudoVSOXSEG4EI32_V_M2_MF2_MASK, VSOXSEG4EI32_V }, // 8326 + { PseudoVSOXSEG4EI32_V_M4_M1, VSOXSEG4EI32_V }, // 8327 + { PseudoVSOXSEG4EI32_V_M4_M1_MASK, VSOXSEG4EI32_V }, // 8328 + { PseudoVSOXSEG4EI32_V_M4_M2, VSOXSEG4EI32_V }, // 8329 + { PseudoVSOXSEG4EI32_V_M4_M2_MASK, VSOXSEG4EI32_V }, // 8330 + { PseudoVSOXSEG4EI32_V_M8_M2, VSOXSEG4EI32_V }, // 8331 + { PseudoVSOXSEG4EI32_V_M8_M2_MASK, VSOXSEG4EI32_V }, // 8332 + { PseudoVSOXSEG4EI32_V_MF2_M1, VSOXSEG4EI32_V }, // 8333 + { PseudoVSOXSEG4EI32_V_MF2_M1_MASK, VSOXSEG4EI32_V }, // 8334 + { PseudoVSOXSEG4EI32_V_MF2_MF2, VSOXSEG4EI32_V }, // 8335 + { PseudoVSOXSEG4EI32_V_MF2_MF2_MASK, VSOXSEG4EI32_V }, // 8336 + { PseudoVSOXSEG4EI32_V_MF2_MF4, VSOXSEG4EI32_V }, // 8337 + { PseudoVSOXSEG4EI32_V_MF2_MF4_MASK, VSOXSEG4EI32_V }, // 8338 + { PseudoVSOXSEG4EI32_V_MF2_MF8, VSOXSEG4EI32_V }, // 8339 + { PseudoVSOXSEG4EI32_V_MF2_MF8_MASK, VSOXSEG4EI32_V }, // 8340 + { PseudoVSOXSEG4EI64_V_M1_M1, VSOXSEG4EI64_V }, // 8341 + { PseudoVSOXSEG4EI64_V_M1_M1_MASK, VSOXSEG4EI64_V }, // 8342 + { PseudoVSOXSEG4EI64_V_M1_MF2, VSOXSEG4EI64_V }, // 8343 + { PseudoVSOXSEG4EI64_V_M1_MF2_MASK, VSOXSEG4EI64_V }, // 8344 + { PseudoVSOXSEG4EI64_V_M1_MF4, VSOXSEG4EI64_V }, // 8345 + { PseudoVSOXSEG4EI64_V_M1_MF4_MASK, VSOXSEG4EI64_V }, // 8346 + { PseudoVSOXSEG4EI64_V_M1_MF8, VSOXSEG4EI64_V }, // 8347 + { PseudoVSOXSEG4EI64_V_M1_MF8_MASK, VSOXSEG4EI64_V }, // 8348 + { PseudoVSOXSEG4EI64_V_M2_M1, VSOXSEG4EI64_V }, // 8349 + { PseudoVSOXSEG4EI64_V_M2_M1_MASK, VSOXSEG4EI64_V }, // 8350 + { PseudoVSOXSEG4EI64_V_M2_M2, VSOXSEG4EI64_V }, // 8351 + { PseudoVSOXSEG4EI64_V_M2_M2_MASK, VSOXSEG4EI64_V }, // 8352 + { PseudoVSOXSEG4EI64_V_M2_MF2, VSOXSEG4EI64_V }, // 8353 + { PseudoVSOXSEG4EI64_V_M2_MF2_MASK, VSOXSEG4EI64_V }, // 8354 + { PseudoVSOXSEG4EI64_V_M2_MF4, VSOXSEG4EI64_V }, // 8355 + { PseudoVSOXSEG4EI64_V_M2_MF4_MASK, VSOXSEG4EI64_V }, // 8356 + { PseudoVSOXSEG4EI64_V_M4_M1, VSOXSEG4EI64_V }, // 8357 + { PseudoVSOXSEG4EI64_V_M4_M1_MASK, VSOXSEG4EI64_V }, // 8358 + { PseudoVSOXSEG4EI64_V_M4_M2, VSOXSEG4EI64_V }, // 8359 + { PseudoVSOXSEG4EI64_V_M4_M2_MASK, VSOXSEG4EI64_V }, // 8360 + { PseudoVSOXSEG4EI64_V_M4_MF2, VSOXSEG4EI64_V }, // 8361 + { PseudoVSOXSEG4EI64_V_M4_MF2_MASK, VSOXSEG4EI64_V }, // 8362 + { PseudoVSOXSEG4EI64_V_M8_M1, VSOXSEG4EI64_V }, // 8363 + { PseudoVSOXSEG4EI64_V_M8_M1_MASK, VSOXSEG4EI64_V }, // 8364 + { PseudoVSOXSEG4EI64_V_M8_M2, VSOXSEG4EI64_V }, // 8365 + { PseudoVSOXSEG4EI64_V_M8_M2_MASK, VSOXSEG4EI64_V }, // 8366 + { PseudoVSOXSEG4EI8_V_M1_M1, VSOXSEG4EI8_V }, // 8367 + { PseudoVSOXSEG4EI8_V_M1_M1_MASK, VSOXSEG4EI8_V }, // 8368 + { PseudoVSOXSEG4EI8_V_M1_M2, VSOXSEG4EI8_V }, // 8369 + { PseudoVSOXSEG4EI8_V_M1_M2_MASK, VSOXSEG4EI8_V }, // 8370 + { PseudoVSOXSEG4EI8_V_M2_M2, VSOXSEG4EI8_V }, // 8371 + { PseudoVSOXSEG4EI8_V_M2_M2_MASK, VSOXSEG4EI8_V }, // 8372 + { PseudoVSOXSEG4EI8_V_MF2_M1, VSOXSEG4EI8_V }, // 8373 + { PseudoVSOXSEG4EI8_V_MF2_M1_MASK, VSOXSEG4EI8_V }, // 8374 + { PseudoVSOXSEG4EI8_V_MF2_M2, VSOXSEG4EI8_V }, // 8375 + { PseudoVSOXSEG4EI8_V_MF2_M2_MASK, VSOXSEG4EI8_V }, // 8376 + { PseudoVSOXSEG4EI8_V_MF2_MF2, VSOXSEG4EI8_V }, // 8377 + { PseudoVSOXSEG4EI8_V_MF2_MF2_MASK, VSOXSEG4EI8_V }, // 8378 + { PseudoVSOXSEG4EI8_V_MF4_M1, VSOXSEG4EI8_V }, // 8379 + { PseudoVSOXSEG4EI8_V_MF4_M1_MASK, VSOXSEG4EI8_V }, // 8380 + { PseudoVSOXSEG4EI8_V_MF4_M2, VSOXSEG4EI8_V }, // 8381 + { PseudoVSOXSEG4EI8_V_MF4_M2_MASK, VSOXSEG4EI8_V }, // 8382 + { PseudoVSOXSEG4EI8_V_MF4_MF2, VSOXSEG4EI8_V }, // 8383 + { PseudoVSOXSEG4EI8_V_MF4_MF2_MASK, VSOXSEG4EI8_V }, // 8384 + { PseudoVSOXSEG4EI8_V_MF4_MF4, VSOXSEG4EI8_V }, // 8385 + { PseudoVSOXSEG4EI8_V_MF4_MF4_MASK, VSOXSEG4EI8_V }, // 8386 + { PseudoVSOXSEG4EI8_V_MF8_M1, VSOXSEG4EI8_V }, // 8387 + { PseudoVSOXSEG4EI8_V_MF8_M1_MASK, VSOXSEG4EI8_V }, // 8388 + { PseudoVSOXSEG4EI8_V_MF8_MF2, VSOXSEG4EI8_V }, // 8389 + { PseudoVSOXSEG4EI8_V_MF8_MF2_MASK, VSOXSEG4EI8_V }, // 8390 + { PseudoVSOXSEG4EI8_V_MF8_MF4, VSOXSEG4EI8_V }, // 8391 + { PseudoVSOXSEG4EI8_V_MF8_MF4_MASK, VSOXSEG4EI8_V }, // 8392 + { PseudoVSOXSEG4EI8_V_MF8_MF8, VSOXSEG4EI8_V }, // 8393 + { PseudoVSOXSEG4EI8_V_MF8_MF8_MASK, VSOXSEG4EI8_V }, // 8394 + { PseudoVSOXSEG5EI16_V_M1_M1, VSOXSEG5EI16_V }, // 8395 + { PseudoVSOXSEG5EI16_V_M1_M1_MASK, VSOXSEG5EI16_V }, // 8396 + { PseudoVSOXSEG5EI16_V_M1_MF2, VSOXSEG5EI16_V }, // 8397 + { PseudoVSOXSEG5EI16_V_M1_MF2_MASK, VSOXSEG5EI16_V }, // 8398 + { PseudoVSOXSEG5EI16_V_M2_M1, VSOXSEG5EI16_V }, // 8399 + { PseudoVSOXSEG5EI16_V_M2_M1_MASK, VSOXSEG5EI16_V }, // 8400 + { PseudoVSOXSEG5EI16_V_MF2_M1, VSOXSEG5EI16_V }, // 8401 + { PseudoVSOXSEG5EI16_V_MF2_M1_MASK, VSOXSEG5EI16_V }, // 8402 + { PseudoVSOXSEG5EI16_V_MF2_MF2, VSOXSEG5EI16_V }, // 8403 + { PseudoVSOXSEG5EI16_V_MF2_MF2_MASK, VSOXSEG5EI16_V }, // 8404 + { PseudoVSOXSEG5EI16_V_MF2_MF4, VSOXSEG5EI16_V }, // 8405 + { PseudoVSOXSEG5EI16_V_MF2_MF4_MASK, VSOXSEG5EI16_V }, // 8406 + { PseudoVSOXSEG5EI16_V_MF4_M1, VSOXSEG5EI16_V }, // 8407 + { PseudoVSOXSEG5EI16_V_MF4_M1_MASK, VSOXSEG5EI16_V }, // 8408 + { PseudoVSOXSEG5EI16_V_MF4_MF2, VSOXSEG5EI16_V }, // 8409 + { PseudoVSOXSEG5EI16_V_MF4_MF2_MASK, VSOXSEG5EI16_V }, // 8410 + { PseudoVSOXSEG5EI16_V_MF4_MF4, VSOXSEG5EI16_V }, // 8411 + { PseudoVSOXSEG5EI16_V_MF4_MF4_MASK, VSOXSEG5EI16_V }, // 8412 + { PseudoVSOXSEG5EI16_V_MF4_MF8, VSOXSEG5EI16_V }, // 8413 + { PseudoVSOXSEG5EI16_V_MF4_MF8_MASK, VSOXSEG5EI16_V }, // 8414 + { PseudoVSOXSEG5EI32_V_M1_M1, VSOXSEG5EI32_V }, // 8415 + { PseudoVSOXSEG5EI32_V_M1_M1_MASK, VSOXSEG5EI32_V }, // 8416 + { PseudoVSOXSEG5EI32_V_M1_MF2, VSOXSEG5EI32_V }, // 8417 + { PseudoVSOXSEG5EI32_V_M1_MF2_MASK, VSOXSEG5EI32_V }, // 8418 + { PseudoVSOXSEG5EI32_V_M1_MF4, VSOXSEG5EI32_V }, // 8419 + { PseudoVSOXSEG5EI32_V_M1_MF4_MASK, VSOXSEG5EI32_V }, // 8420 + { PseudoVSOXSEG5EI32_V_M2_M1, VSOXSEG5EI32_V }, // 8421 + { PseudoVSOXSEG5EI32_V_M2_M1_MASK, VSOXSEG5EI32_V }, // 8422 + { PseudoVSOXSEG5EI32_V_M2_MF2, VSOXSEG5EI32_V }, // 8423 + { PseudoVSOXSEG5EI32_V_M2_MF2_MASK, VSOXSEG5EI32_V }, // 8424 + { PseudoVSOXSEG5EI32_V_M4_M1, VSOXSEG5EI32_V }, // 8425 + { PseudoVSOXSEG5EI32_V_M4_M1_MASK, VSOXSEG5EI32_V }, // 8426 + { PseudoVSOXSEG5EI32_V_MF2_M1, VSOXSEG5EI32_V }, // 8427 + { PseudoVSOXSEG5EI32_V_MF2_M1_MASK, VSOXSEG5EI32_V }, // 8428 + { PseudoVSOXSEG5EI32_V_MF2_MF2, VSOXSEG5EI32_V }, // 8429 + { PseudoVSOXSEG5EI32_V_MF2_MF2_MASK, VSOXSEG5EI32_V }, // 8430 + { PseudoVSOXSEG5EI32_V_MF2_MF4, VSOXSEG5EI32_V }, // 8431 + { PseudoVSOXSEG5EI32_V_MF2_MF4_MASK, VSOXSEG5EI32_V }, // 8432 + { PseudoVSOXSEG5EI32_V_MF2_MF8, VSOXSEG5EI32_V }, // 8433 + { PseudoVSOXSEG5EI32_V_MF2_MF8_MASK, VSOXSEG5EI32_V }, // 8434 + { PseudoVSOXSEG5EI64_V_M1_M1, VSOXSEG5EI64_V }, // 8435 + { PseudoVSOXSEG5EI64_V_M1_M1_MASK, VSOXSEG5EI64_V }, // 8436 + { PseudoVSOXSEG5EI64_V_M1_MF2, VSOXSEG5EI64_V }, // 8437 + { PseudoVSOXSEG5EI64_V_M1_MF2_MASK, VSOXSEG5EI64_V }, // 8438 + { PseudoVSOXSEG5EI64_V_M1_MF4, VSOXSEG5EI64_V }, // 8439 + { PseudoVSOXSEG5EI64_V_M1_MF4_MASK, VSOXSEG5EI64_V }, // 8440 + { PseudoVSOXSEG5EI64_V_M1_MF8, VSOXSEG5EI64_V }, // 8441 + { PseudoVSOXSEG5EI64_V_M1_MF8_MASK, VSOXSEG5EI64_V }, // 8442 + { PseudoVSOXSEG5EI64_V_M2_M1, VSOXSEG5EI64_V }, // 8443 + { PseudoVSOXSEG5EI64_V_M2_M1_MASK, VSOXSEG5EI64_V }, // 8444 + { PseudoVSOXSEG5EI64_V_M2_MF2, VSOXSEG5EI64_V }, // 8445 + { PseudoVSOXSEG5EI64_V_M2_MF2_MASK, VSOXSEG5EI64_V }, // 8446 + { PseudoVSOXSEG5EI64_V_M2_MF4, VSOXSEG5EI64_V }, // 8447 + { PseudoVSOXSEG5EI64_V_M2_MF4_MASK, VSOXSEG5EI64_V }, // 8448 + { PseudoVSOXSEG5EI64_V_M4_M1, VSOXSEG5EI64_V }, // 8449 + { PseudoVSOXSEG5EI64_V_M4_M1_MASK, VSOXSEG5EI64_V }, // 8450 + { PseudoVSOXSEG5EI64_V_M4_MF2, VSOXSEG5EI64_V }, // 8451 + { PseudoVSOXSEG5EI64_V_M4_MF2_MASK, VSOXSEG5EI64_V }, // 8452 + { PseudoVSOXSEG5EI64_V_M8_M1, VSOXSEG5EI64_V }, // 8453 + { PseudoVSOXSEG5EI64_V_M8_M1_MASK, VSOXSEG5EI64_V }, // 8454 + { PseudoVSOXSEG5EI8_V_M1_M1, VSOXSEG5EI8_V }, // 8455 + { PseudoVSOXSEG5EI8_V_M1_M1_MASK, VSOXSEG5EI8_V }, // 8456 + { PseudoVSOXSEG5EI8_V_MF2_M1, VSOXSEG5EI8_V }, // 8457 + { PseudoVSOXSEG5EI8_V_MF2_M1_MASK, VSOXSEG5EI8_V }, // 8458 + { PseudoVSOXSEG5EI8_V_MF2_MF2, VSOXSEG5EI8_V }, // 8459 + { PseudoVSOXSEG5EI8_V_MF2_MF2_MASK, VSOXSEG5EI8_V }, // 8460 + { PseudoVSOXSEG5EI8_V_MF4_M1, VSOXSEG5EI8_V }, // 8461 + { PseudoVSOXSEG5EI8_V_MF4_M1_MASK, VSOXSEG5EI8_V }, // 8462 + { PseudoVSOXSEG5EI8_V_MF4_MF2, VSOXSEG5EI8_V }, // 8463 + { PseudoVSOXSEG5EI8_V_MF4_MF2_MASK, VSOXSEG5EI8_V }, // 8464 + { PseudoVSOXSEG5EI8_V_MF4_MF4, VSOXSEG5EI8_V }, // 8465 + { PseudoVSOXSEG5EI8_V_MF4_MF4_MASK, VSOXSEG5EI8_V }, // 8466 + { PseudoVSOXSEG5EI8_V_MF8_M1, VSOXSEG5EI8_V }, // 8467 + { PseudoVSOXSEG5EI8_V_MF8_M1_MASK, VSOXSEG5EI8_V }, // 8468 + { PseudoVSOXSEG5EI8_V_MF8_MF2, VSOXSEG5EI8_V }, // 8469 + { PseudoVSOXSEG5EI8_V_MF8_MF2_MASK, VSOXSEG5EI8_V }, // 8470 + { PseudoVSOXSEG5EI8_V_MF8_MF4, VSOXSEG5EI8_V }, // 8471 + { PseudoVSOXSEG5EI8_V_MF8_MF4_MASK, VSOXSEG5EI8_V }, // 8472 + { PseudoVSOXSEG5EI8_V_MF8_MF8, VSOXSEG5EI8_V }, // 8473 + { PseudoVSOXSEG5EI8_V_MF8_MF8_MASK, VSOXSEG5EI8_V }, // 8474 + { PseudoVSOXSEG6EI16_V_M1_M1, VSOXSEG6EI16_V }, // 8475 + { PseudoVSOXSEG6EI16_V_M1_M1_MASK, VSOXSEG6EI16_V }, // 8476 + { PseudoVSOXSEG6EI16_V_M1_MF2, VSOXSEG6EI16_V }, // 8477 + { PseudoVSOXSEG6EI16_V_M1_MF2_MASK, VSOXSEG6EI16_V }, // 8478 + { PseudoVSOXSEG6EI16_V_M2_M1, VSOXSEG6EI16_V }, // 8479 + { PseudoVSOXSEG6EI16_V_M2_M1_MASK, VSOXSEG6EI16_V }, // 8480 + { PseudoVSOXSEG6EI16_V_MF2_M1, VSOXSEG6EI16_V }, // 8481 + { PseudoVSOXSEG6EI16_V_MF2_M1_MASK, VSOXSEG6EI16_V }, // 8482 + { PseudoVSOXSEG6EI16_V_MF2_MF2, VSOXSEG6EI16_V }, // 8483 + { PseudoVSOXSEG6EI16_V_MF2_MF2_MASK, VSOXSEG6EI16_V }, // 8484 + { PseudoVSOXSEG6EI16_V_MF2_MF4, VSOXSEG6EI16_V }, // 8485 + { PseudoVSOXSEG6EI16_V_MF2_MF4_MASK, VSOXSEG6EI16_V }, // 8486 + { PseudoVSOXSEG6EI16_V_MF4_M1, VSOXSEG6EI16_V }, // 8487 + { PseudoVSOXSEG6EI16_V_MF4_M1_MASK, VSOXSEG6EI16_V }, // 8488 + { PseudoVSOXSEG6EI16_V_MF4_MF2, VSOXSEG6EI16_V }, // 8489 + { PseudoVSOXSEG6EI16_V_MF4_MF2_MASK, VSOXSEG6EI16_V }, // 8490 + { PseudoVSOXSEG6EI16_V_MF4_MF4, VSOXSEG6EI16_V }, // 8491 + { PseudoVSOXSEG6EI16_V_MF4_MF4_MASK, VSOXSEG6EI16_V }, // 8492 + { PseudoVSOXSEG6EI16_V_MF4_MF8, VSOXSEG6EI16_V }, // 8493 + { PseudoVSOXSEG6EI16_V_MF4_MF8_MASK, VSOXSEG6EI16_V }, // 8494 + { PseudoVSOXSEG6EI32_V_M1_M1, VSOXSEG6EI32_V }, // 8495 + { PseudoVSOXSEG6EI32_V_M1_M1_MASK, VSOXSEG6EI32_V }, // 8496 + { PseudoVSOXSEG6EI32_V_M1_MF2, VSOXSEG6EI32_V }, // 8497 + { PseudoVSOXSEG6EI32_V_M1_MF2_MASK, VSOXSEG6EI32_V }, // 8498 + { PseudoVSOXSEG6EI32_V_M1_MF4, VSOXSEG6EI32_V }, // 8499 + { PseudoVSOXSEG6EI32_V_M1_MF4_MASK, VSOXSEG6EI32_V }, // 8500 + { PseudoVSOXSEG6EI32_V_M2_M1, VSOXSEG6EI32_V }, // 8501 + { PseudoVSOXSEG6EI32_V_M2_M1_MASK, VSOXSEG6EI32_V }, // 8502 + { PseudoVSOXSEG6EI32_V_M2_MF2, VSOXSEG6EI32_V }, // 8503 + { PseudoVSOXSEG6EI32_V_M2_MF2_MASK, VSOXSEG6EI32_V }, // 8504 + { PseudoVSOXSEG6EI32_V_M4_M1, VSOXSEG6EI32_V }, // 8505 + { PseudoVSOXSEG6EI32_V_M4_M1_MASK, VSOXSEG6EI32_V }, // 8506 + { PseudoVSOXSEG6EI32_V_MF2_M1, VSOXSEG6EI32_V }, // 8507 + { PseudoVSOXSEG6EI32_V_MF2_M1_MASK, VSOXSEG6EI32_V }, // 8508 + { PseudoVSOXSEG6EI32_V_MF2_MF2, VSOXSEG6EI32_V }, // 8509 + { PseudoVSOXSEG6EI32_V_MF2_MF2_MASK, VSOXSEG6EI32_V }, // 8510 + { PseudoVSOXSEG6EI32_V_MF2_MF4, VSOXSEG6EI32_V }, // 8511 + { PseudoVSOXSEG6EI32_V_MF2_MF4_MASK, VSOXSEG6EI32_V }, // 8512 + { PseudoVSOXSEG6EI32_V_MF2_MF8, VSOXSEG6EI32_V }, // 8513 + { PseudoVSOXSEG6EI32_V_MF2_MF8_MASK, VSOXSEG6EI32_V }, // 8514 + { PseudoVSOXSEG6EI64_V_M1_M1, VSOXSEG6EI64_V }, // 8515 + { PseudoVSOXSEG6EI64_V_M1_M1_MASK, VSOXSEG6EI64_V }, // 8516 + { PseudoVSOXSEG6EI64_V_M1_MF2, VSOXSEG6EI64_V }, // 8517 + { PseudoVSOXSEG6EI64_V_M1_MF2_MASK, VSOXSEG6EI64_V }, // 8518 + { PseudoVSOXSEG6EI64_V_M1_MF4, VSOXSEG6EI64_V }, // 8519 + { PseudoVSOXSEG6EI64_V_M1_MF4_MASK, VSOXSEG6EI64_V }, // 8520 + { PseudoVSOXSEG6EI64_V_M1_MF8, VSOXSEG6EI64_V }, // 8521 + { PseudoVSOXSEG6EI64_V_M1_MF8_MASK, VSOXSEG6EI64_V }, // 8522 + { PseudoVSOXSEG6EI64_V_M2_M1, VSOXSEG6EI64_V }, // 8523 + { PseudoVSOXSEG6EI64_V_M2_M1_MASK, VSOXSEG6EI64_V }, // 8524 + { PseudoVSOXSEG6EI64_V_M2_MF2, VSOXSEG6EI64_V }, // 8525 + { PseudoVSOXSEG6EI64_V_M2_MF2_MASK, VSOXSEG6EI64_V }, // 8526 + { PseudoVSOXSEG6EI64_V_M2_MF4, VSOXSEG6EI64_V }, // 8527 + { PseudoVSOXSEG6EI64_V_M2_MF4_MASK, VSOXSEG6EI64_V }, // 8528 + { PseudoVSOXSEG6EI64_V_M4_M1, VSOXSEG6EI64_V }, // 8529 + { PseudoVSOXSEG6EI64_V_M4_M1_MASK, VSOXSEG6EI64_V }, // 8530 + { PseudoVSOXSEG6EI64_V_M4_MF2, VSOXSEG6EI64_V }, // 8531 + { PseudoVSOXSEG6EI64_V_M4_MF2_MASK, VSOXSEG6EI64_V }, // 8532 + { PseudoVSOXSEG6EI64_V_M8_M1, VSOXSEG6EI64_V }, // 8533 + { PseudoVSOXSEG6EI64_V_M8_M1_MASK, VSOXSEG6EI64_V }, // 8534 + { PseudoVSOXSEG6EI8_V_M1_M1, VSOXSEG6EI8_V }, // 8535 + { PseudoVSOXSEG6EI8_V_M1_M1_MASK, VSOXSEG6EI8_V }, // 8536 + { PseudoVSOXSEG6EI8_V_MF2_M1, VSOXSEG6EI8_V }, // 8537 + { PseudoVSOXSEG6EI8_V_MF2_M1_MASK, VSOXSEG6EI8_V }, // 8538 + { PseudoVSOXSEG6EI8_V_MF2_MF2, VSOXSEG6EI8_V }, // 8539 + { PseudoVSOXSEG6EI8_V_MF2_MF2_MASK, VSOXSEG6EI8_V }, // 8540 + { PseudoVSOXSEG6EI8_V_MF4_M1, VSOXSEG6EI8_V }, // 8541 + { PseudoVSOXSEG6EI8_V_MF4_M1_MASK, VSOXSEG6EI8_V }, // 8542 + { PseudoVSOXSEG6EI8_V_MF4_MF2, VSOXSEG6EI8_V }, // 8543 + { PseudoVSOXSEG6EI8_V_MF4_MF2_MASK, VSOXSEG6EI8_V }, // 8544 + { PseudoVSOXSEG6EI8_V_MF4_MF4, VSOXSEG6EI8_V }, // 8545 + { PseudoVSOXSEG6EI8_V_MF4_MF4_MASK, VSOXSEG6EI8_V }, // 8546 + { PseudoVSOXSEG6EI8_V_MF8_M1, VSOXSEG6EI8_V }, // 8547 + { PseudoVSOXSEG6EI8_V_MF8_M1_MASK, VSOXSEG6EI8_V }, // 8548 + { PseudoVSOXSEG6EI8_V_MF8_MF2, VSOXSEG6EI8_V }, // 8549 + { PseudoVSOXSEG6EI8_V_MF8_MF2_MASK, VSOXSEG6EI8_V }, // 8550 + { PseudoVSOXSEG6EI8_V_MF8_MF4, VSOXSEG6EI8_V }, // 8551 + { PseudoVSOXSEG6EI8_V_MF8_MF4_MASK, VSOXSEG6EI8_V }, // 8552 + { PseudoVSOXSEG6EI8_V_MF8_MF8, VSOXSEG6EI8_V }, // 8553 + { PseudoVSOXSEG6EI8_V_MF8_MF8_MASK, VSOXSEG6EI8_V }, // 8554 + { PseudoVSOXSEG7EI16_V_M1_M1, VSOXSEG7EI16_V }, // 8555 + { PseudoVSOXSEG7EI16_V_M1_M1_MASK, VSOXSEG7EI16_V }, // 8556 + { PseudoVSOXSEG7EI16_V_M1_MF2, VSOXSEG7EI16_V }, // 8557 + { PseudoVSOXSEG7EI16_V_M1_MF2_MASK, VSOXSEG7EI16_V }, // 8558 + { PseudoVSOXSEG7EI16_V_M2_M1, VSOXSEG7EI16_V }, // 8559 + { PseudoVSOXSEG7EI16_V_M2_M1_MASK, VSOXSEG7EI16_V }, // 8560 + { PseudoVSOXSEG7EI16_V_MF2_M1, VSOXSEG7EI16_V }, // 8561 + { PseudoVSOXSEG7EI16_V_MF2_M1_MASK, VSOXSEG7EI16_V }, // 8562 + { PseudoVSOXSEG7EI16_V_MF2_MF2, VSOXSEG7EI16_V }, // 8563 + { PseudoVSOXSEG7EI16_V_MF2_MF2_MASK, VSOXSEG7EI16_V }, // 8564 + { PseudoVSOXSEG7EI16_V_MF2_MF4, VSOXSEG7EI16_V }, // 8565 + { PseudoVSOXSEG7EI16_V_MF2_MF4_MASK, VSOXSEG7EI16_V }, // 8566 + { PseudoVSOXSEG7EI16_V_MF4_M1, VSOXSEG7EI16_V }, // 8567 + { PseudoVSOXSEG7EI16_V_MF4_M1_MASK, VSOXSEG7EI16_V }, // 8568 + { PseudoVSOXSEG7EI16_V_MF4_MF2, VSOXSEG7EI16_V }, // 8569 + { PseudoVSOXSEG7EI16_V_MF4_MF2_MASK, VSOXSEG7EI16_V }, // 8570 + { PseudoVSOXSEG7EI16_V_MF4_MF4, VSOXSEG7EI16_V }, // 8571 + { PseudoVSOXSEG7EI16_V_MF4_MF4_MASK, VSOXSEG7EI16_V }, // 8572 + { PseudoVSOXSEG7EI16_V_MF4_MF8, VSOXSEG7EI16_V }, // 8573 + { PseudoVSOXSEG7EI16_V_MF4_MF8_MASK, VSOXSEG7EI16_V }, // 8574 + { PseudoVSOXSEG7EI32_V_M1_M1, VSOXSEG7EI32_V }, // 8575 + { PseudoVSOXSEG7EI32_V_M1_M1_MASK, VSOXSEG7EI32_V }, // 8576 + { PseudoVSOXSEG7EI32_V_M1_MF2, VSOXSEG7EI32_V }, // 8577 + { PseudoVSOXSEG7EI32_V_M1_MF2_MASK, VSOXSEG7EI32_V }, // 8578 + { PseudoVSOXSEG7EI32_V_M1_MF4, VSOXSEG7EI32_V }, // 8579 + { PseudoVSOXSEG7EI32_V_M1_MF4_MASK, VSOXSEG7EI32_V }, // 8580 + { PseudoVSOXSEG7EI32_V_M2_M1, VSOXSEG7EI32_V }, // 8581 + { PseudoVSOXSEG7EI32_V_M2_M1_MASK, VSOXSEG7EI32_V }, // 8582 + { PseudoVSOXSEG7EI32_V_M2_MF2, VSOXSEG7EI32_V }, // 8583 + { PseudoVSOXSEG7EI32_V_M2_MF2_MASK, VSOXSEG7EI32_V }, // 8584 + { PseudoVSOXSEG7EI32_V_M4_M1, VSOXSEG7EI32_V }, // 8585 + { PseudoVSOXSEG7EI32_V_M4_M1_MASK, VSOXSEG7EI32_V }, // 8586 + { PseudoVSOXSEG7EI32_V_MF2_M1, VSOXSEG7EI32_V }, // 8587 + { PseudoVSOXSEG7EI32_V_MF2_M1_MASK, VSOXSEG7EI32_V }, // 8588 + { PseudoVSOXSEG7EI32_V_MF2_MF2, VSOXSEG7EI32_V }, // 8589 + { PseudoVSOXSEG7EI32_V_MF2_MF2_MASK, VSOXSEG7EI32_V }, // 8590 + { PseudoVSOXSEG7EI32_V_MF2_MF4, VSOXSEG7EI32_V }, // 8591 + { PseudoVSOXSEG7EI32_V_MF2_MF4_MASK, VSOXSEG7EI32_V }, // 8592 + { PseudoVSOXSEG7EI32_V_MF2_MF8, VSOXSEG7EI32_V }, // 8593 + { PseudoVSOXSEG7EI32_V_MF2_MF8_MASK, VSOXSEG7EI32_V }, // 8594 + { PseudoVSOXSEG7EI64_V_M1_M1, VSOXSEG7EI64_V }, // 8595 + { PseudoVSOXSEG7EI64_V_M1_M1_MASK, VSOXSEG7EI64_V }, // 8596 + { PseudoVSOXSEG7EI64_V_M1_MF2, VSOXSEG7EI64_V }, // 8597 + { PseudoVSOXSEG7EI64_V_M1_MF2_MASK, VSOXSEG7EI64_V }, // 8598 + { PseudoVSOXSEG7EI64_V_M1_MF4, VSOXSEG7EI64_V }, // 8599 + { PseudoVSOXSEG7EI64_V_M1_MF4_MASK, VSOXSEG7EI64_V }, // 8600 + { PseudoVSOXSEG7EI64_V_M1_MF8, VSOXSEG7EI64_V }, // 8601 + { PseudoVSOXSEG7EI64_V_M1_MF8_MASK, VSOXSEG7EI64_V }, // 8602 + { PseudoVSOXSEG7EI64_V_M2_M1, VSOXSEG7EI64_V }, // 8603 + { PseudoVSOXSEG7EI64_V_M2_M1_MASK, VSOXSEG7EI64_V }, // 8604 + { PseudoVSOXSEG7EI64_V_M2_MF2, VSOXSEG7EI64_V }, // 8605 + { PseudoVSOXSEG7EI64_V_M2_MF2_MASK, VSOXSEG7EI64_V }, // 8606 + { PseudoVSOXSEG7EI64_V_M2_MF4, VSOXSEG7EI64_V }, // 8607 + { PseudoVSOXSEG7EI64_V_M2_MF4_MASK, VSOXSEG7EI64_V }, // 8608 + { PseudoVSOXSEG7EI64_V_M4_M1, VSOXSEG7EI64_V }, // 8609 + { PseudoVSOXSEG7EI64_V_M4_M1_MASK, VSOXSEG7EI64_V }, // 8610 + { PseudoVSOXSEG7EI64_V_M4_MF2, VSOXSEG7EI64_V }, // 8611 + { PseudoVSOXSEG7EI64_V_M4_MF2_MASK, VSOXSEG7EI64_V }, // 8612 + { PseudoVSOXSEG7EI64_V_M8_M1, VSOXSEG7EI64_V }, // 8613 + { PseudoVSOXSEG7EI64_V_M8_M1_MASK, VSOXSEG7EI64_V }, // 8614 + { PseudoVSOXSEG7EI8_V_M1_M1, VSOXSEG7EI8_V }, // 8615 + { PseudoVSOXSEG7EI8_V_M1_M1_MASK, VSOXSEG7EI8_V }, // 8616 + { PseudoVSOXSEG7EI8_V_MF2_M1, VSOXSEG7EI8_V }, // 8617 + { PseudoVSOXSEG7EI8_V_MF2_M1_MASK, VSOXSEG7EI8_V }, // 8618 + { PseudoVSOXSEG7EI8_V_MF2_MF2, VSOXSEG7EI8_V }, // 8619 + { PseudoVSOXSEG7EI8_V_MF2_MF2_MASK, VSOXSEG7EI8_V }, // 8620 + { PseudoVSOXSEG7EI8_V_MF4_M1, VSOXSEG7EI8_V }, // 8621 + { PseudoVSOXSEG7EI8_V_MF4_M1_MASK, VSOXSEG7EI8_V }, // 8622 + { PseudoVSOXSEG7EI8_V_MF4_MF2, VSOXSEG7EI8_V }, // 8623 + { PseudoVSOXSEG7EI8_V_MF4_MF2_MASK, VSOXSEG7EI8_V }, // 8624 + { PseudoVSOXSEG7EI8_V_MF4_MF4, VSOXSEG7EI8_V }, // 8625 + { PseudoVSOXSEG7EI8_V_MF4_MF4_MASK, VSOXSEG7EI8_V }, // 8626 + { PseudoVSOXSEG7EI8_V_MF8_M1, VSOXSEG7EI8_V }, // 8627 + { PseudoVSOXSEG7EI8_V_MF8_M1_MASK, VSOXSEG7EI8_V }, // 8628 + { PseudoVSOXSEG7EI8_V_MF8_MF2, VSOXSEG7EI8_V }, // 8629 + { PseudoVSOXSEG7EI8_V_MF8_MF2_MASK, VSOXSEG7EI8_V }, // 8630 + { PseudoVSOXSEG7EI8_V_MF8_MF4, VSOXSEG7EI8_V }, // 8631 + { PseudoVSOXSEG7EI8_V_MF8_MF4_MASK, VSOXSEG7EI8_V }, // 8632 + { PseudoVSOXSEG7EI8_V_MF8_MF8, VSOXSEG7EI8_V }, // 8633 + { PseudoVSOXSEG7EI8_V_MF8_MF8_MASK, VSOXSEG7EI8_V }, // 8634 + { PseudoVSOXSEG8EI16_V_M1_M1, VSOXSEG8EI16_V }, // 8635 + { PseudoVSOXSEG8EI16_V_M1_M1_MASK, VSOXSEG8EI16_V }, // 8636 + { PseudoVSOXSEG8EI16_V_M1_MF2, VSOXSEG8EI16_V }, // 8637 + { PseudoVSOXSEG8EI16_V_M1_MF2_MASK, VSOXSEG8EI16_V }, // 8638 + { PseudoVSOXSEG8EI16_V_M2_M1, VSOXSEG8EI16_V }, // 8639 + { PseudoVSOXSEG8EI16_V_M2_M1_MASK, VSOXSEG8EI16_V }, // 8640 + { PseudoVSOXSEG8EI16_V_MF2_M1, VSOXSEG8EI16_V }, // 8641 + { PseudoVSOXSEG8EI16_V_MF2_M1_MASK, VSOXSEG8EI16_V }, // 8642 + { PseudoVSOXSEG8EI16_V_MF2_MF2, VSOXSEG8EI16_V }, // 8643 + { PseudoVSOXSEG8EI16_V_MF2_MF2_MASK, VSOXSEG8EI16_V }, // 8644 + { PseudoVSOXSEG8EI16_V_MF2_MF4, VSOXSEG8EI16_V }, // 8645 + { PseudoVSOXSEG8EI16_V_MF2_MF4_MASK, VSOXSEG8EI16_V }, // 8646 + { PseudoVSOXSEG8EI16_V_MF4_M1, VSOXSEG8EI16_V }, // 8647 + { PseudoVSOXSEG8EI16_V_MF4_M1_MASK, VSOXSEG8EI16_V }, // 8648 + { PseudoVSOXSEG8EI16_V_MF4_MF2, VSOXSEG8EI16_V }, // 8649 + { PseudoVSOXSEG8EI16_V_MF4_MF2_MASK, VSOXSEG8EI16_V }, // 8650 + { PseudoVSOXSEG8EI16_V_MF4_MF4, VSOXSEG8EI16_V }, // 8651 + { PseudoVSOXSEG8EI16_V_MF4_MF4_MASK, VSOXSEG8EI16_V }, // 8652 + { PseudoVSOXSEG8EI16_V_MF4_MF8, VSOXSEG8EI16_V }, // 8653 + { PseudoVSOXSEG8EI16_V_MF4_MF8_MASK, VSOXSEG8EI16_V }, // 8654 + { PseudoVSOXSEG8EI32_V_M1_M1, VSOXSEG8EI32_V }, // 8655 + { PseudoVSOXSEG8EI32_V_M1_M1_MASK, VSOXSEG8EI32_V }, // 8656 + { PseudoVSOXSEG8EI32_V_M1_MF2, VSOXSEG8EI32_V }, // 8657 + { PseudoVSOXSEG8EI32_V_M1_MF2_MASK, VSOXSEG8EI32_V }, // 8658 + { PseudoVSOXSEG8EI32_V_M1_MF4, VSOXSEG8EI32_V }, // 8659 + { PseudoVSOXSEG8EI32_V_M1_MF4_MASK, VSOXSEG8EI32_V }, // 8660 + { PseudoVSOXSEG8EI32_V_M2_M1, VSOXSEG8EI32_V }, // 8661 + { PseudoVSOXSEG8EI32_V_M2_M1_MASK, VSOXSEG8EI32_V }, // 8662 + { PseudoVSOXSEG8EI32_V_M2_MF2, VSOXSEG8EI32_V }, // 8663 + { PseudoVSOXSEG8EI32_V_M2_MF2_MASK, VSOXSEG8EI32_V }, // 8664 + { PseudoVSOXSEG8EI32_V_M4_M1, VSOXSEG8EI32_V }, // 8665 + { PseudoVSOXSEG8EI32_V_M4_M1_MASK, VSOXSEG8EI32_V }, // 8666 + { PseudoVSOXSEG8EI32_V_MF2_M1, VSOXSEG8EI32_V }, // 8667 + { PseudoVSOXSEG8EI32_V_MF2_M1_MASK, VSOXSEG8EI32_V }, // 8668 + { PseudoVSOXSEG8EI32_V_MF2_MF2, VSOXSEG8EI32_V }, // 8669 + { PseudoVSOXSEG8EI32_V_MF2_MF2_MASK, VSOXSEG8EI32_V }, // 8670 + { PseudoVSOXSEG8EI32_V_MF2_MF4, VSOXSEG8EI32_V }, // 8671 + { PseudoVSOXSEG8EI32_V_MF2_MF4_MASK, VSOXSEG8EI32_V }, // 8672 + { PseudoVSOXSEG8EI32_V_MF2_MF8, VSOXSEG8EI32_V }, // 8673 + { PseudoVSOXSEG8EI32_V_MF2_MF8_MASK, VSOXSEG8EI32_V }, // 8674 + { PseudoVSOXSEG8EI64_V_M1_M1, VSOXSEG8EI64_V }, // 8675 + { PseudoVSOXSEG8EI64_V_M1_M1_MASK, VSOXSEG8EI64_V }, // 8676 + { PseudoVSOXSEG8EI64_V_M1_MF2, VSOXSEG8EI64_V }, // 8677 + { PseudoVSOXSEG8EI64_V_M1_MF2_MASK, VSOXSEG8EI64_V }, // 8678 + { PseudoVSOXSEG8EI64_V_M1_MF4, VSOXSEG8EI64_V }, // 8679 + { PseudoVSOXSEG8EI64_V_M1_MF4_MASK, VSOXSEG8EI64_V }, // 8680 + { PseudoVSOXSEG8EI64_V_M1_MF8, VSOXSEG8EI64_V }, // 8681 + { PseudoVSOXSEG8EI64_V_M1_MF8_MASK, VSOXSEG8EI64_V }, // 8682 + { PseudoVSOXSEG8EI64_V_M2_M1, VSOXSEG8EI64_V }, // 8683 + { PseudoVSOXSEG8EI64_V_M2_M1_MASK, VSOXSEG8EI64_V }, // 8684 + { PseudoVSOXSEG8EI64_V_M2_MF2, VSOXSEG8EI64_V }, // 8685 + { PseudoVSOXSEG8EI64_V_M2_MF2_MASK, VSOXSEG8EI64_V }, // 8686 + { PseudoVSOXSEG8EI64_V_M2_MF4, VSOXSEG8EI64_V }, // 8687 + { PseudoVSOXSEG8EI64_V_M2_MF4_MASK, VSOXSEG8EI64_V }, // 8688 + { PseudoVSOXSEG8EI64_V_M4_M1, VSOXSEG8EI64_V }, // 8689 + { PseudoVSOXSEG8EI64_V_M4_M1_MASK, VSOXSEG8EI64_V }, // 8690 + { PseudoVSOXSEG8EI64_V_M4_MF2, VSOXSEG8EI64_V }, // 8691 + { PseudoVSOXSEG8EI64_V_M4_MF2_MASK, VSOXSEG8EI64_V }, // 8692 + { PseudoVSOXSEG8EI64_V_M8_M1, VSOXSEG8EI64_V }, // 8693 + { PseudoVSOXSEG8EI64_V_M8_M1_MASK, VSOXSEG8EI64_V }, // 8694 + { PseudoVSOXSEG8EI8_V_M1_M1, VSOXSEG8EI8_V }, // 8695 + { PseudoVSOXSEG8EI8_V_M1_M1_MASK, VSOXSEG8EI8_V }, // 8696 + { PseudoVSOXSEG8EI8_V_MF2_M1, VSOXSEG8EI8_V }, // 8697 + { PseudoVSOXSEG8EI8_V_MF2_M1_MASK, VSOXSEG8EI8_V }, // 8698 + { PseudoVSOXSEG8EI8_V_MF2_MF2, VSOXSEG8EI8_V }, // 8699 + { PseudoVSOXSEG8EI8_V_MF2_MF2_MASK, VSOXSEG8EI8_V }, // 8700 + { PseudoVSOXSEG8EI8_V_MF4_M1, VSOXSEG8EI8_V }, // 8701 + { PseudoVSOXSEG8EI8_V_MF4_M1_MASK, VSOXSEG8EI8_V }, // 8702 + { PseudoVSOXSEG8EI8_V_MF4_MF2, VSOXSEG8EI8_V }, // 8703 + { PseudoVSOXSEG8EI8_V_MF4_MF2_MASK, VSOXSEG8EI8_V }, // 8704 + { PseudoVSOXSEG8EI8_V_MF4_MF4, VSOXSEG8EI8_V }, // 8705 + { PseudoVSOXSEG8EI8_V_MF4_MF4_MASK, VSOXSEG8EI8_V }, // 8706 + { PseudoVSOXSEG8EI8_V_MF8_M1, VSOXSEG8EI8_V }, // 8707 + { PseudoVSOXSEG8EI8_V_MF8_M1_MASK, VSOXSEG8EI8_V }, // 8708 + { PseudoVSOXSEG8EI8_V_MF8_MF2, VSOXSEG8EI8_V }, // 8709 + { PseudoVSOXSEG8EI8_V_MF8_MF2_MASK, VSOXSEG8EI8_V }, // 8710 + { PseudoVSOXSEG8EI8_V_MF8_MF4, VSOXSEG8EI8_V }, // 8711 + { PseudoVSOXSEG8EI8_V_MF8_MF4_MASK, VSOXSEG8EI8_V }, // 8712 + { PseudoVSOXSEG8EI8_V_MF8_MF8, VSOXSEG8EI8_V }, // 8713 + { PseudoVSOXSEG8EI8_V_MF8_MF8_MASK, VSOXSEG8EI8_V }, // 8714 + { PseudoVSRA_VI_M1, VSRA_VI }, // 8715 + { PseudoVSRA_VI_M1_MASK, VSRA_VI }, // 8716 + { PseudoVSRA_VI_M2, VSRA_VI }, // 8717 + { PseudoVSRA_VI_M2_MASK, VSRA_VI }, // 8718 + { PseudoVSRA_VI_M4, VSRA_VI }, // 8719 + { PseudoVSRA_VI_M4_MASK, VSRA_VI }, // 8720 + { PseudoVSRA_VI_M8, VSRA_VI }, // 8721 + { PseudoVSRA_VI_M8_MASK, VSRA_VI }, // 8722 + { PseudoVSRA_VI_MF2, VSRA_VI }, // 8723 + { PseudoVSRA_VI_MF2_MASK, VSRA_VI }, // 8724 + { PseudoVSRA_VI_MF4, VSRA_VI }, // 8725 + { PseudoVSRA_VI_MF4_MASK, VSRA_VI }, // 8726 + { PseudoVSRA_VI_MF8, VSRA_VI }, // 8727 + { PseudoVSRA_VI_MF8_MASK, VSRA_VI }, // 8728 + { PseudoVSRA_VV_M1, VSRA_VV }, // 8729 + { PseudoVSRA_VV_M1_MASK, VSRA_VV }, // 8730 + { PseudoVSRA_VV_M2, VSRA_VV }, // 8731 + { PseudoVSRA_VV_M2_MASK, VSRA_VV }, // 8732 + { PseudoVSRA_VV_M4, VSRA_VV }, // 8733 + { PseudoVSRA_VV_M4_MASK, VSRA_VV }, // 8734 + { PseudoVSRA_VV_M8, VSRA_VV }, // 8735 + { PseudoVSRA_VV_M8_MASK, VSRA_VV }, // 8736 + { PseudoVSRA_VV_MF2, VSRA_VV }, // 8737 + { PseudoVSRA_VV_MF2_MASK, VSRA_VV }, // 8738 + { PseudoVSRA_VV_MF4, VSRA_VV }, // 8739 + { PseudoVSRA_VV_MF4_MASK, VSRA_VV }, // 8740 + { PseudoVSRA_VV_MF8, VSRA_VV }, // 8741 + { PseudoVSRA_VV_MF8_MASK, VSRA_VV }, // 8742 + { PseudoVSRA_VX_M1, VSRA_VX }, // 8743 + { PseudoVSRA_VX_M1_MASK, VSRA_VX }, // 8744 + { PseudoVSRA_VX_M2, VSRA_VX }, // 8745 + { PseudoVSRA_VX_M2_MASK, VSRA_VX }, // 8746 + { PseudoVSRA_VX_M4, VSRA_VX }, // 8747 + { PseudoVSRA_VX_M4_MASK, VSRA_VX }, // 8748 + { PseudoVSRA_VX_M8, VSRA_VX }, // 8749 + { PseudoVSRA_VX_M8_MASK, VSRA_VX }, // 8750 + { PseudoVSRA_VX_MF2, VSRA_VX }, // 8751 + { PseudoVSRA_VX_MF2_MASK, VSRA_VX }, // 8752 + { PseudoVSRA_VX_MF4, VSRA_VX }, // 8753 + { PseudoVSRA_VX_MF4_MASK, VSRA_VX }, // 8754 + { PseudoVSRA_VX_MF8, VSRA_VX }, // 8755 + { PseudoVSRA_VX_MF8_MASK, VSRA_VX }, // 8756 + { PseudoVSRL_VI_M1, VSRL_VI }, // 8757 + { PseudoVSRL_VI_M1_MASK, VSRL_VI }, // 8758 + { PseudoVSRL_VI_M2, VSRL_VI }, // 8759 + { PseudoVSRL_VI_M2_MASK, VSRL_VI }, // 8760 + { PseudoVSRL_VI_M4, VSRL_VI }, // 8761 + { PseudoVSRL_VI_M4_MASK, VSRL_VI }, // 8762 + { PseudoVSRL_VI_M8, VSRL_VI }, // 8763 + { PseudoVSRL_VI_M8_MASK, VSRL_VI }, // 8764 + { PseudoVSRL_VI_MF2, VSRL_VI }, // 8765 + { PseudoVSRL_VI_MF2_MASK, VSRL_VI }, // 8766 + { PseudoVSRL_VI_MF4, VSRL_VI }, // 8767 + { PseudoVSRL_VI_MF4_MASK, VSRL_VI }, // 8768 + { PseudoVSRL_VI_MF8, VSRL_VI }, // 8769 + { PseudoVSRL_VI_MF8_MASK, VSRL_VI }, // 8770 + { PseudoVSRL_VV_M1, VSRL_VV }, // 8771 + { PseudoVSRL_VV_M1_MASK, VSRL_VV }, // 8772 + { PseudoVSRL_VV_M2, VSRL_VV }, // 8773 + { PseudoVSRL_VV_M2_MASK, VSRL_VV }, // 8774 + { PseudoVSRL_VV_M4, VSRL_VV }, // 8775 + { PseudoVSRL_VV_M4_MASK, VSRL_VV }, // 8776 + { PseudoVSRL_VV_M8, VSRL_VV }, // 8777 + { PseudoVSRL_VV_M8_MASK, VSRL_VV }, // 8778 + { PseudoVSRL_VV_MF2, VSRL_VV }, // 8779 + { PseudoVSRL_VV_MF2_MASK, VSRL_VV }, // 8780 + { PseudoVSRL_VV_MF4, VSRL_VV }, // 8781 + { PseudoVSRL_VV_MF4_MASK, VSRL_VV }, // 8782 + { PseudoVSRL_VV_MF8, VSRL_VV }, // 8783 + { PseudoVSRL_VV_MF8_MASK, VSRL_VV }, // 8784 + { PseudoVSRL_VX_M1, VSRL_VX }, // 8785 + { PseudoVSRL_VX_M1_MASK, VSRL_VX }, // 8786 + { PseudoVSRL_VX_M2, VSRL_VX }, // 8787 + { PseudoVSRL_VX_M2_MASK, VSRL_VX }, // 8788 + { PseudoVSRL_VX_M4, VSRL_VX }, // 8789 + { PseudoVSRL_VX_M4_MASK, VSRL_VX }, // 8790 + { PseudoVSRL_VX_M8, VSRL_VX }, // 8791 + { PseudoVSRL_VX_M8_MASK, VSRL_VX }, // 8792 + { PseudoVSRL_VX_MF2, VSRL_VX }, // 8793 + { PseudoVSRL_VX_MF2_MASK, VSRL_VX }, // 8794 + { PseudoVSRL_VX_MF4, VSRL_VX }, // 8795 + { PseudoVSRL_VX_MF4_MASK, VSRL_VX }, // 8796 + { PseudoVSRL_VX_MF8, VSRL_VX }, // 8797 + { PseudoVSRL_VX_MF8_MASK, VSRL_VX }, // 8798 + { PseudoVSSE16_V_M1, VSSE16_V }, // 8799 + { PseudoVSSE16_V_M1_MASK, VSSE16_V }, // 8800 + { PseudoVSSE16_V_M2, VSSE16_V }, // 8801 + { PseudoVSSE16_V_M2_MASK, VSSE16_V }, // 8802 + { PseudoVSSE16_V_M4, VSSE16_V }, // 8803 + { PseudoVSSE16_V_M4_MASK, VSSE16_V }, // 8804 + { PseudoVSSE16_V_M8, VSSE16_V }, // 8805 + { PseudoVSSE16_V_M8_MASK, VSSE16_V }, // 8806 + { PseudoVSSE16_V_MF2, VSSE16_V }, // 8807 + { PseudoVSSE16_V_MF2_MASK, VSSE16_V }, // 8808 + { PseudoVSSE16_V_MF4, VSSE16_V }, // 8809 + { PseudoVSSE16_V_MF4_MASK, VSSE16_V }, // 8810 + { PseudoVSSE32_V_M1, VSSE32_V }, // 8811 + { PseudoVSSE32_V_M1_MASK, VSSE32_V }, // 8812 + { PseudoVSSE32_V_M2, VSSE32_V }, // 8813 + { PseudoVSSE32_V_M2_MASK, VSSE32_V }, // 8814 + { PseudoVSSE32_V_M4, VSSE32_V }, // 8815 + { PseudoVSSE32_V_M4_MASK, VSSE32_V }, // 8816 + { PseudoVSSE32_V_M8, VSSE32_V }, // 8817 + { PseudoVSSE32_V_M8_MASK, VSSE32_V }, // 8818 + { PseudoVSSE32_V_MF2, VSSE32_V }, // 8819 + { PseudoVSSE32_V_MF2_MASK, VSSE32_V }, // 8820 + { PseudoVSSE64_V_M1, VSSE64_V }, // 8821 + { PseudoVSSE64_V_M1_MASK, VSSE64_V }, // 8822 + { PseudoVSSE64_V_M2, VSSE64_V }, // 8823 + { PseudoVSSE64_V_M2_MASK, VSSE64_V }, // 8824 + { PseudoVSSE64_V_M4, VSSE64_V }, // 8825 + { PseudoVSSE64_V_M4_MASK, VSSE64_V }, // 8826 + { PseudoVSSE64_V_M8, VSSE64_V }, // 8827 + { PseudoVSSE64_V_M8_MASK, VSSE64_V }, // 8828 + { PseudoVSSE8_V_M1, VSSE8_V }, // 8829 + { PseudoVSSE8_V_M1_MASK, VSSE8_V }, // 8830 + { PseudoVSSE8_V_M2, VSSE8_V }, // 8831 + { PseudoVSSE8_V_M2_MASK, VSSE8_V }, // 8832 + { PseudoVSSE8_V_M4, VSSE8_V }, // 8833 + { PseudoVSSE8_V_M4_MASK, VSSE8_V }, // 8834 + { PseudoVSSE8_V_M8, VSSE8_V }, // 8835 + { PseudoVSSE8_V_M8_MASK, VSSE8_V }, // 8836 + { PseudoVSSE8_V_MF2, VSSE8_V }, // 8837 + { PseudoVSSE8_V_MF2_MASK, VSSE8_V }, // 8838 + { PseudoVSSE8_V_MF4, VSSE8_V }, // 8839 + { PseudoVSSE8_V_MF4_MASK, VSSE8_V }, // 8840 + { PseudoVSSE8_V_MF8, VSSE8_V }, // 8841 + { PseudoVSSE8_V_MF8_MASK, VSSE8_V }, // 8842 + { PseudoVSSEG2E16_V_M1, VSSEG2E16_V }, // 8843 + { PseudoVSSEG2E16_V_M1_MASK, VSSEG2E16_V }, // 8844 + { PseudoVSSEG2E16_V_M2, VSSEG2E16_V }, // 8845 + { PseudoVSSEG2E16_V_M2_MASK, VSSEG2E16_V }, // 8846 + { PseudoVSSEG2E16_V_M4, VSSEG2E16_V }, // 8847 + { PseudoVSSEG2E16_V_M4_MASK, VSSEG2E16_V }, // 8848 + { PseudoVSSEG2E16_V_MF2, VSSEG2E16_V }, // 8849 + { PseudoVSSEG2E16_V_MF2_MASK, VSSEG2E16_V }, // 8850 + { PseudoVSSEG2E16_V_MF4, VSSEG2E16_V }, // 8851 + { PseudoVSSEG2E16_V_MF4_MASK, VSSEG2E16_V }, // 8852 + { PseudoVSSEG2E32_V_M1, VSSEG2E32_V }, // 8853 + { PseudoVSSEG2E32_V_M1_MASK, VSSEG2E32_V }, // 8854 + { PseudoVSSEG2E32_V_M2, VSSEG2E32_V }, // 8855 + { PseudoVSSEG2E32_V_M2_MASK, VSSEG2E32_V }, // 8856 + { PseudoVSSEG2E32_V_M4, VSSEG2E32_V }, // 8857 + { PseudoVSSEG2E32_V_M4_MASK, VSSEG2E32_V }, // 8858 + { PseudoVSSEG2E32_V_MF2, VSSEG2E32_V }, // 8859 + { PseudoVSSEG2E32_V_MF2_MASK, VSSEG2E32_V }, // 8860 + { PseudoVSSEG2E64_V_M1, VSSEG2E64_V }, // 8861 + { PseudoVSSEG2E64_V_M1_MASK, VSSEG2E64_V }, // 8862 + { PseudoVSSEG2E64_V_M2, VSSEG2E64_V }, // 8863 + { PseudoVSSEG2E64_V_M2_MASK, VSSEG2E64_V }, // 8864 + { PseudoVSSEG2E64_V_M4, VSSEG2E64_V }, // 8865 + { PseudoVSSEG2E64_V_M4_MASK, VSSEG2E64_V }, // 8866 + { PseudoVSSEG2E8_V_M1, VSSEG2E8_V }, // 8867 + { PseudoVSSEG2E8_V_M1_MASK, VSSEG2E8_V }, // 8868 + { PseudoVSSEG2E8_V_M2, VSSEG2E8_V }, // 8869 + { PseudoVSSEG2E8_V_M2_MASK, VSSEG2E8_V }, // 8870 + { PseudoVSSEG2E8_V_M4, VSSEG2E8_V }, // 8871 + { PseudoVSSEG2E8_V_M4_MASK, VSSEG2E8_V }, // 8872 + { PseudoVSSEG2E8_V_MF2, VSSEG2E8_V }, // 8873 + { PseudoVSSEG2E8_V_MF2_MASK, VSSEG2E8_V }, // 8874 + { PseudoVSSEG2E8_V_MF4, VSSEG2E8_V }, // 8875 + { PseudoVSSEG2E8_V_MF4_MASK, VSSEG2E8_V }, // 8876 + { PseudoVSSEG2E8_V_MF8, VSSEG2E8_V }, // 8877 + { PseudoVSSEG2E8_V_MF8_MASK, VSSEG2E8_V }, // 8878 + { PseudoVSSEG3E16_V_M1, VSSEG3E16_V }, // 8879 + { PseudoVSSEG3E16_V_M1_MASK, VSSEG3E16_V }, // 8880 + { PseudoVSSEG3E16_V_M2, VSSEG3E16_V }, // 8881 + { PseudoVSSEG3E16_V_M2_MASK, VSSEG3E16_V }, // 8882 + { PseudoVSSEG3E16_V_MF2, VSSEG3E16_V }, // 8883 + { PseudoVSSEG3E16_V_MF2_MASK, VSSEG3E16_V }, // 8884 + { PseudoVSSEG3E16_V_MF4, VSSEG3E16_V }, // 8885 + { PseudoVSSEG3E16_V_MF4_MASK, VSSEG3E16_V }, // 8886 + { PseudoVSSEG3E32_V_M1, VSSEG3E32_V }, // 8887 + { PseudoVSSEG3E32_V_M1_MASK, VSSEG3E32_V }, // 8888 + { PseudoVSSEG3E32_V_M2, VSSEG3E32_V }, // 8889 + { PseudoVSSEG3E32_V_M2_MASK, VSSEG3E32_V }, // 8890 + { PseudoVSSEG3E32_V_MF2, VSSEG3E32_V }, // 8891 + { PseudoVSSEG3E32_V_MF2_MASK, VSSEG3E32_V }, // 8892 + { PseudoVSSEG3E64_V_M1, VSSEG3E64_V }, // 8893 + { PseudoVSSEG3E64_V_M1_MASK, VSSEG3E64_V }, // 8894 + { PseudoVSSEG3E64_V_M2, VSSEG3E64_V }, // 8895 + { PseudoVSSEG3E64_V_M2_MASK, VSSEG3E64_V }, // 8896 + { PseudoVSSEG3E8_V_M1, VSSEG3E8_V }, // 8897 + { PseudoVSSEG3E8_V_M1_MASK, VSSEG3E8_V }, // 8898 + { PseudoVSSEG3E8_V_M2, VSSEG3E8_V }, // 8899 + { PseudoVSSEG3E8_V_M2_MASK, VSSEG3E8_V }, // 8900 + { PseudoVSSEG3E8_V_MF2, VSSEG3E8_V }, // 8901 + { PseudoVSSEG3E8_V_MF2_MASK, VSSEG3E8_V }, // 8902 + { PseudoVSSEG3E8_V_MF4, VSSEG3E8_V }, // 8903 + { PseudoVSSEG3E8_V_MF4_MASK, VSSEG3E8_V }, // 8904 + { PseudoVSSEG3E8_V_MF8, VSSEG3E8_V }, // 8905 + { PseudoVSSEG3E8_V_MF8_MASK, VSSEG3E8_V }, // 8906 + { PseudoVSSEG4E16_V_M1, VSSEG4E16_V }, // 8907 + { PseudoVSSEG4E16_V_M1_MASK, VSSEG4E16_V }, // 8908 + { PseudoVSSEG4E16_V_M2, VSSEG4E16_V }, // 8909 + { PseudoVSSEG4E16_V_M2_MASK, VSSEG4E16_V }, // 8910 + { PseudoVSSEG4E16_V_MF2, VSSEG4E16_V }, // 8911 + { PseudoVSSEG4E16_V_MF2_MASK, VSSEG4E16_V }, // 8912 + { PseudoVSSEG4E16_V_MF4, VSSEG4E16_V }, // 8913 + { PseudoVSSEG4E16_V_MF4_MASK, VSSEG4E16_V }, // 8914 + { PseudoVSSEG4E32_V_M1, VSSEG4E32_V }, // 8915 + { PseudoVSSEG4E32_V_M1_MASK, VSSEG4E32_V }, // 8916 + { PseudoVSSEG4E32_V_M2, VSSEG4E32_V }, // 8917 + { PseudoVSSEG4E32_V_M2_MASK, VSSEG4E32_V }, // 8918 + { PseudoVSSEG4E32_V_MF2, VSSEG4E32_V }, // 8919 + { PseudoVSSEG4E32_V_MF2_MASK, VSSEG4E32_V }, // 8920 + { PseudoVSSEG4E64_V_M1, VSSEG4E64_V }, // 8921 + { PseudoVSSEG4E64_V_M1_MASK, VSSEG4E64_V }, // 8922 + { PseudoVSSEG4E64_V_M2, VSSEG4E64_V }, // 8923 + { PseudoVSSEG4E64_V_M2_MASK, VSSEG4E64_V }, // 8924 + { PseudoVSSEG4E8_V_M1, VSSEG4E8_V }, // 8925 + { PseudoVSSEG4E8_V_M1_MASK, VSSEG4E8_V }, // 8926 + { PseudoVSSEG4E8_V_M2, VSSEG4E8_V }, // 8927 + { PseudoVSSEG4E8_V_M2_MASK, VSSEG4E8_V }, // 8928 + { PseudoVSSEG4E8_V_MF2, VSSEG4E8_V }, // 8929 + { PseudoVSSEG4E8_V_MF2_MASK, VSSEG4E8_V }, // 8930 + { PseudoVSSEG4E8_V_MF4, VSSEG4E8_V }, // 8931 + { PseudoVSSEG4E8_V_MF4_MASK, VSSEG4E8_V }, // 8932 + { PseudoVSSEG4E8_V_MF8, VSSEG4E8_V }, // 8933 + { PseudoVSSEG4E8_V_MF8_MASK, VSSEG4E8_V }, // 8934 + { PseudoVSSEG5E16_V_M1, VSSEG5E16_V }, // 8935 + { PseudoVSSEG5E16_V_M1_MASK, VSSEG5E16_V }, // 8936 + { PseudoVSSEG5E16_V_MF2, VSSEG5E16_V }, // 8937 + { PseudoVSSEG5E16_V_MF2_MASK, VSSEG5E16_V }, // 8938 + { PseudoVSSEG5E16_V_MF4, VSSEG5E16_V }, // 8939 + { PseudoVSSEG5E16_V_MF4_MASK, VSSEG5E16_V }, // 8940 + { PseudoVSSEG5E32_V_M1, VSSEG5E32_V }, // 8941 + { PseudoVSSEG5E32_V_M1_MASK, VSSEG5E32_V }, // 8942 + { PseudoVSSEG5E32_V_MF2, VSSEG5E32_V }, // 8943 + { PseudoVSSEG5E32_V_MF2_MASK, VSSEG5E32_V }, // 8944 + { PseudoVSSEG5E64_V_M1, VSSEG5E64_V }, // 8945 + { PseudoVSSEG5E64_V_M1_MASK, VSSEG5E64_V }, // 8946 + { PseudoVSSEG5E8_V_M1, VSSEG5E8_V }, // 8947 + { PseudoVSSEG5E8_V_M1_MASK, VSSEG5E8_V }, // 8948 + { PseudoVSSEG5E8_V_MF2, VSSEG5E8_V }, // 8949 + { PseudoVSSEG5E8_V_MF2_MASK, VSSEG5E8_V }, // 8950 + { PseudoVSSEG5E8_V_MF4, VSSEG5E8_V }, // 8951 + { PseudoVSSEG5E8_V_MF4_MASK, VSSEG5E8_V }, // 8952 + { PseudoVSSEG5E8_V_MF8, VSSEG5E8_V }, // 8953 + { PseudoVSSEG5E8_V_MF8_MASK, VSSEG5E8_V }, // 8954 + { PseudoVSSEG6E16_V_M1, VSSEG6E16_V }, // 8955 + { PseudoVSSEG6E16_V_M1_MASK, VSSEG6E16_V }, // 8956 + { PseudoVSSEG6E16_V_MF2, VSSEG6E16_V }, // 8957 + { PseudoVSSEG6E16_V_MF2_MASK, VSSEG6E16_V }, // 8958 + { PseudoVSSEG6E16_V_MF4, VSSEG6E16_V }, // 8959 + { PseudoVSSEG6E16_V_MF4_MASK, VSSEG6E16_V }, // 8960 + { PseudoVSSEG6E32_V_M1, VSSEG6E32_V }, // 8961 + { PseudoVSSEG6E32_V_M1_MASK, VSSEG6E32_V }, // 8962 + { PseudoVSSEG6E32_V_MF2, VSSEG6E32_V }, // 8963 + { PseudoVSSEG6E32_V_MF2_MASK, VSSEG6E32_V }, // 8964 + { PseudoVSSEG6E64_V_M1, VSSEG6E64_V }, // 8965 + { PseudoVSSEG6E64_V_M1_MASK, VSSEG6E64_V }, // 8966 + { PseudoVSSEG6E8_V_M1, VSSEG6E8_V }, // 8967 + { PseudoVSSEG6E8_V_M1_MASK, VSSEG6E8_V }, // 8968 + { PseudoVSSEG6E8_V_MF2, VSSEG6E8_V }, // 8969 + { PseudoVSSEG6E8_V_MF2_MASK, VSSEG6E8_V }, // 8970 + { PseudoVSSEG6E8_V_MF4, VSSEG6E8_V }, // 8971 + { PseudoVSSEG6E8_V_MF4_MASK, VSSEG6E8_V }, // 8972 + { PseudoVSSEG6E8_V_MF8, VSSEG6E8_V }, // 8973 + { PseudoVSSEG6E8_V_MF8_MASK, VSSEG6E8_V }, // 8974 + { PseudoVSSEG7E16_V_M1, VSSEG7E16_V }, // 8975 + { PseudoVSSEG7E16_V_M1_MASK, VSSEG7E16_V }, // 8976 + { PseudoVSSEG7E16_V_MF2, VSSEG7E16_V }, // 8977 + { PseudoVSSEG7E16_V_MF2_MASK, VSSEG7E16_V }, // 8978 + { PseudoVSSEG7E16_V_MF4, VSSEG7E16_V }, // 8979 + { PseudoVSSEG7E16_V_MF4_MASK, VSSEG7E16_V }, // 8980 + { PseudoVSSEG7E32_V_M1, VSSEG7E32_V }, // 8981 + { PseudoVSSEG7E32_V_M1_MASK, VSSEG7E32_V }, // 8982 + { PseudoVSSEG7E32_V_MF2, VSSEG7E32_V }, // 8983 + { PseudoVSSEG7E32_V_MF2_MASK, VSSEG7E32_V }, // 8984 + { PseudoVSSEG7E64_V_M1, VSSEG7E64_V }, // 8985 + { PseudoVSSEG7E64_V_M1_MASK, VSSEG7E64_V }, // 8986 + { PseudoVSSEG7E8_V_M1, VSSEG7E8_V }, // 8987 + { PseudoVSSEG7E8_V_M1_MASK, VSSEG7E8_V }, // 8988 + { PseudoVSSEG7E8_V_MF2, VSSEG7E8_V }, // 8989 + { PseudoVSSEG7E8_V_MF2_MASK, VSSEG7E8_V }, // 8990 + { PseudoVSSEG7E8_V_MF4, VSSEG7E8_V }, // 8991 + { PseudoVSSEG7E8_V_MF4_MASK, VSSEG7E8_V }, // 8992 + { PseudoVSSEG7E8_V_MF8, VSSEG7E8_V }, // 8993 + { PseudoVSSEG7E8_V_MF8_MASK, VSSEG7E8_V }, // 8994 + { PseudoVSSEG8E16_V_M1, VSSEG8E16_V }, // 8995 + { PseudoVSSEG8E16_V_M1_MASK, VSSEG8E16_V }, // 8996 + { PseudoVSSEG8E16_V_MF2, VSSEG8E16_V }, // 8997 + { PseudoVSSEG8E16_V_MF2_MASK, VSSEG8E16_V }, // 8998 + { PseudoVSSEG8E16_V_MF4, VSSEG8E16_V }, // 8999 + { PseudoVSSEG8E16_V_MF4_MASK, VSSEG8E16_V }, // 9000 + { PseudoVSSEG8E32_V_M1, VSSEG8E32_V }, // 9001 + { PseudoVSSEG8E32_V_M1_MASK, VSSEG8E32_V }, // 9002 + { PseudoVSSEG8E32_V_MF2, VSSEG8E32_V }, // 9003 + { PseudoVSSEG8E32_V_MF2_MASK, VSSEG8E32_V }, // 9004 + { PseudoVSSEG8E64_V_M1, VSSEG8E64_V }, // 9005 + { PseudoVSSEG8E64_V_M1_MASK, VSSEG8E64_V }, // 9006 + { PseudoVSSEG8E8_V_M1, VSSEG8E8_V }, // 9007 + { PseudoVSSEG8E8_V_M1_MASK, VSSEG8E8_V }, // 9008 + { PseudoVSSEG8E8_V_MF2, VSSEG8E8_V }, // 9009 + { PseudoVSSEG8E8_V_MF2_MASK, VSSEG8E8_V }, // 9010 + { PseudoVSSEG8E8_V_MF4, VSSEG8E8_V }, // 9011 + { PseudoVSSEG8E8_V_MF4_MASK, VSSEG8E8_V }, // 9012 + { PseudoVSSEG8E8_V_MF8, VSSEG8E8_V }, // 9013 + { PseudoVSSEG8E8_V_MF8_MASK, VSSEG8E8_V }, // 9014 + { PseudoVSSRA_VI_M1, VSSRA_VI }, // 9015 + { PseudoVSSRA_VI_M1_MASK, VSSRA_VI }, // 9016 + { PseudoVSSRA_VI_M2, VSSRA_VI }, // 9017 + { PseudoVSSRA_VI_M2_MASK, VSSRA_VI }, // 9018 + { PseudoVSSRA_VI_M4, VSSRA_VI }, // 9019 + { PseudoVSSRA_VI_M4_MASK, VSSRA_VI }, // 9020 + { PseudoVSSRA_VI_M8, VSSRA_VI }, // 9021 + { PseudoVSSRA_VI_M8_MASK, VSSRA_VI }, // 9022 + { PseudoVSSRA_VI_MF2, VSSRA_VI }, // 9023 + { PseudoVSSRA_VI_MF2_MASK, VSSRA_VI }, // 9024 + { PseudoVSSRA_VI_MF4, VSSRA_VI }, // 9025 + { PseudoVSSRA_VI_MF4_MASK, VSSRA_VI }, // 9026 + { PseudoVSSRA_VI_MF8, VSSRA_VI }, // 9027 + { PseudoVSSRA_VI_MF8_MASK, VSSRA_VI }, // 9028 + { PseudoVSSRA_VV_M1, VSSRA_VV }, // 9029 + { PseudoVSSRA_VV_M1_MASK, VSSRA_VV }, // 9030 + { PseudoVSSRA_VV_M2, VSSRA_VV }, // 9031 + { PseudoVSSRA_VV_M2_MASK, VSSRA_VV }, // 9032 + { PseudoVSSRA_VV_M4, VSSRA_VV }, // 9033 + { PseudoVSSRA_VV_M4_MASK, VSSRA_VV }, // 9034 + { PseudoVSSRA_VV_M8, VSSRA_VV }, // 9035 + { PseudoVSSRA_VV_M8_MASK, VSSRA_VV }, // 9036 + { PseudoVSSRA_VV_MF2, VSSRA_VV }, // 9037 + { PseudoVSSRA_VV_MF2_MASK, VSSRA_VV }, // 9038 + { PseudoVSSRA_VV_MF4, VSSRA_VV }, // 9039 + { PseudoVSSRA_VV_MF4_MASK, VSSRA_VV }, // 9040 + { PseudoVSSRA_VV_MF8, VSSRA_VV }, // 9041 + { PseudoVSSRA_VV_MF8_MASK, VSSRA_VV }, // 9042 + { PseudoVSSRA_VX_M1, VSSRA_VX }, // 9043 + { PseudoVSSRA_VX_M1_MASK, VSSRA_VX }, // 9044 + { PseudoVSSRA_VX_M2, VSSRA_VX }, // 9045 + { PseudoVSSRA_VX_M2_MASK, VSSRA_VX }, // 9046 + { PseudoVSSRA_VX_M4, VSSRA_VX }, // 9047 + { PseudoVSSRA_VX_M4_MASK, VSSRA_VX }, // 9048 + { PseudoVSSRA_VX_M8, VSSRA_VX }, // 9049 + { PseudoVSSRA_VX_M8_MASK, VSSRA_VX }, // 9050 + { PseudoVSSRA_VX_MF2, VSSRA_VX }, // 9051 + { PseudoVSSRA_VX_MF2_MASK, VSSRA_VX }, // 9052 + { PseudoVSSRA_VX_MF4, VSSRA_VX }, // 9053 + { PseudoVSSRA_VX_MF4_MASK, VSSRA_VX }, // 9054 + { PseudoVSSRA_VX_MF8, VSSRA_VX }, // 9055 + { PseudoVSSRA_VX_MF8_MASK, VSSRA_VX }, // 9056 + { PseudoVSSRL_VI_M1, VSSRL_VI }, // 9057 + { PseudoVSSRL_VI_M1_MASK, VSSRL_VI }, // 9058 + { PseudoVSSRL_VI_M2, VSSRL_VI }, // 9059 + { PseudoVSSRL_VI_M2_MASK, VSSRL_VI }, // 9060 + { PseudoVSSRL_VI_M4, VSSRL_VI }, // 9061 + { PseudoVSSRL_VI_M4_MASK, VSSRL_VI }, // 9062 + { PseudoVSSRL_VI_M8, VSSRL_VI }, // 9063 + { PseudoVSSRL_VI_M8_MASK, VSSRL_VI }, // 9064 + { PseudoVSSRL_VI_MF2, VSSRL_VI }, // 9065 + { PseudoVSSRL_VI_MF2_MASK, VSSRL_VI }, // 9066 + { PseudoVSSRL_VI_MF4, VSSRL_VI }, // 9067 + { PseudoVSSRL_VI_MF4_MASK, VSSRL_VI }, // 9068 + { PseudoVSSRL_VI_MF8, VSSRL_VI }, // 9069 + { PseudoVSSRL_VI_MF8_MASK, VSSRL_VI }, // 9070 + { PseudoVSSRL_VV_M1, VSSRL_VV }, // 9071 + { PseudoVSSRL_VV_M1_MASK, VSSRL_VV }, // 9072 + { PseudoVSSRL_VV_M2, VSSRL_VV }, // 9073 + { PseudoVSSRL_VV_M2_MASK, VSSRL_VV }, // 9074 + { PseudoVSSRL_VV_M4, VSSRL_VV }, // 9075 + { PseudoVSSRL_VV_M4_MASK, VSSRL_VV }, // 9076 + { PseudoVSSRL_VV_M8, VSSRL_VV }, // 9077 + { PseudoVSSRL_VV_M8_MASK, VSSRL_VV }, // 9078 + { PseudoVSSRL_VV_MF2, VSSRL_VV }, // 9079 + { PseudoVSSRL_VV_MF2_MASK, VSSRL_VV }, // 9080 + { PseudoVSSRL_VV_MF4, VSSRL_VV }, // 9081 + { PseudoVSSRL_VV_MF4_MASK, VSSRL_VV }, // 9082 + { PseudoVSSRL_VV_MF8, VSSRL_VV }, // 9083 + { PseudoVSSRL_VV_MF8_MASK, VSSRL_VV }, // 9084 + { PseudoVSSRL_VX_M1, VSSRL_VX }, // 9085 + { PseudoVSSRL_VX_M1_MASK, VSSRL_VX }, // 9086 + { PseudoVSSRL_VX_M2, VSSRL_VX }, // 9087 + { PseudoVSSRL_VX_M2_MASK, VSSRL_VX }, // 9088 + { PseudoVSSRL_VX_M4, VSSRL_VX }, // 9089 + { PseudoVSSRL_VX_M4_MASK, VSSRL_VX }, // 9090 + { PseudoVSSRL_VX_M8, VSSRL_VX }, // 9091 + { PseudoVSSRL_VX_M8_MASK, VSSRL_VX }, // 9092 + { PseudoVSSRL_VX_MF2, VSSRL_VX }, // 9093 + { PseudoVSSRL_VX_MF2_MASK, VSSRL_VX }, // 9094 + { PseudoVSSRL_VX_MF4, VSSRL_VX }, // 9095 + { PseudoVSSRL_VX_MF4_MASK, VSSRL_VX }, // 9096 + { PseudoVSSRL_VX_MF8, VSSRL_VX }, // 9097 + { PseudoVSSRL_VX_MF8_MASK, VSSRL_VX }, // 9098 + { PseudoVSSSEG2E16_V_M1, VSSSEG2E16_V }, // 9099 + { PseudoVSSSEG2E16_V_M1_MASK, VSSSEG2E16_V }, // 9100 + { PseudoVSSSEG2E16_V_M2, VSSSEG2E16_V }, // 9101 + { PseudoVSSSEG2E16_V_M2_MASK, VSSSEG2E16_V }, // 9102 + { PseudoVSSSEG2E16_V_M4, VSSSEG2E16_V }, // 9103 + { PseudoVSSSEG2E16_V_M4_MASK, VSSSEG2E16_V }, // 9104 + { PseudoVSSSEG2E16_V_MF2, VSSSEG2E16_V }, // 9105 + { PseudoVSSSEG2E16_V_MF2_MASK, VSSSEG2E16_V }, // 9106 + { PseudoVSSSEG2E16_V_MF4, VSSSEG2E16_V }, // 9107 + { PseudoVSSSEG2E16_V_MF4_MASK, VSSSEG2E16_V }, // 9108 + { PseudoVSSSEG2E32_V_M1, VSSSEG2E32_V }, // 9109 + { PseudoVSSSEG2E32_V_M1_MASK, VSSSEG2E32_V }, // 9110 + { PseudoVSSSEG2E32_V_M2, VSSSEG2E32_V }, // 9111 + { PseudoVSSSEG2E32_V_M2_MASK, VSSSEG2E32_V }, // 9112 + { PseudoVSSSEG2E32_V_M4, VSSSEG2E32_V }, // 9113 + { PseudoVSSSEG2E32_V_M4_MASK, VSSSEG2E32_V }, // 9114 + { PseudoVSSSEG2E32_V_MF2, VSSSEG2E32_V }, // 9115 + { PseudoVSSSEG2E32_V_MF2_MASK, VSSSEG2E32_V }, // 9116 + { PseudoVSSSEG2E64_V_M1, VSSSEG2E64_V }, // 9117 + { PseudoVSSSEG2E64_V_M1_MASK, VSSSEG2E64_V }, // 9118 + { PseudoVSSSEG2E64_V_M2, VSSSEG2E64_V }, // 9119 + { PseudoVSSSEG2E64_V_M2_MASK, VSSSEG2E64_V }, // 9120 + { PseudoVSSSEG2E64_V_M4, VSSSEG2E64_V }, // 9121 + { PseudoVSSSEG2E64_V_M4_MASK, VSSSEG2E64_V }, // 9122 + { PseudoVSSSEG2E8_V_M1, VSSSEG2E8_V }, // 9123 + { PseudoVSSSEG2E8_V_M1_MASK, VSSSEG2E8_V }, // 9124 + { PseudoVSSSEG2E8_V_M2, VSSSEG2E8_V }, // 9125 + { PseudoVSSSEG2E8_V_M2_MASK, VSSSEG2E8_V }, // 9126 + { PseudoVSSSEG2E8_V_M4, VSSSEG2E8_V }, // 9127 + { PseudoVSSSEG2E8_V_M4_MASK, VSSSEG2E8_V }, // 9128 + { PseudoVSSSEG2E8_V_MF2, VSSSEG2E8_V }, // 9129 + { PseudoVSSSEG2E8_V_MF2_MASK, VSSSEG2E8_V }, // 9130 + { PseudoVSSSEG2E8_V_MF4, VSSSEG2E8_V }, // 9131 + { PseudoVSSSEG2E8_V_MF4_MASK, VSSSEG2E8_V }, // 9132 + { PseudoVSSSEG2E8_V_MF8, VSSSEG2E8_V }, // 9133 + { PseudoVSSSEG2E8_V_MF8_MASK, VSSSEG2E8_V }, // 9134 + { PseudoVSSSEG3E16_V_M1, VSSSEG3E16_V }, // 9135 + { PseudoVSSSEG3E16_V_M1_MASK, VSSSEG3E16_V }, // 9136 + { PseudoVSSSEG3E16_V_M2, VSSSEG3E16_V }, // 9137 + { PseudoVSSSEG3E16_V_M2_MASK, VSSSEG3E16_V }, // 9138 + { PseudoVSSSEG3E16_V_MF2, VSSSEG3E16_V }, // 9139 + { PseudoVSSSEG3E16_V_MF2_MASK, VSSSEG3E16_V }, // 9140 + { PseudoVSSSEG3E16_V_MF4, VSSSEG3E16_V }, // 9141 + { PseudoVSSSEG3E16_V_MF4_MASK, VSSSEG3E16_V }, // 9142 + { PseudoVSSSEG3E32_V_M1, VSSSEG3E32_V }, // 9143 + { PseudoVSSSEG3E32_V_M1_MASK, VSSSEG3E32_V }, // 9144 + { PseudoVSSSEG3E32_V_M2, VSSSEG3E32_V }, // 9145 + { PseudoVSSSEG3E32_V_M2_MASK, VSSSEG3E32_V }, // 9146 + { PseudoVSSSEG3E32_V_MF2, VSSSEG3E32_V }, // 9147 + { PseudoVSSSEG3E32_V_MF2_MASK, VSSSEG3E32_V }, // 9148 + { PseudoVSSSEG3E64_V_M1, VSSSEG3E64_V }, // 9149 + { PseudoVSSSEG3E64_V_M1_MASK, VSSSEG3E64_V }, // 9150 + { PseudoVSSSEG3E64_V_M2, VSSSEG3E64_V }, // 9151 + { PseudoVSSSEG3E64_V_M2_MASK, VSSSEG3E64_V }, // 9152 + { PseudoVSSSEG3E8_V_M1, VSSSEG3E8_V }, // 9153 + { PseudoVSSSEG3E8_V_M1_MASK, VSSSEG3E8_V }, // 9154 + { PseudoVSSSEG3E8_V_M2, VSSSEG3E8_V }, // 9155 + { PseudoVSSSEG3E8_V_M2_MASK, VSSSEG3E8_V }, // 9156 + { PseudoVSSSEG3E8_V_MF2, VSSSEG3E8_V }, // 9157 + { PseudoVSSSEG3E8_V_MF2_MASK, VSSSEG3E8_V }, // 9158 + { PseudoVSSSEG3E8_V_MF4, VSSSEG3E8_V }, // 9159 + { PseudoVSSSEG3E8_V_MF4_MASK, VSSSEG3E8_V }, // 9160 + { PseudoVSSSEG3E8_V_MF8, VSSSEG3E8_V }, // 9161 + { PseudoVSSSEG3E8_V_MF8_MASK, VSSSEG3E8_V }, // 9162 + { PseudoVSSSEG4E16_V_M1, VSSSEG4E16_V }, // 9163 + { PseudoVSSSEG4E16_V_M1_MASK, VSSSEG4E16_V }, // 9164 + { PseudoVSSSEG4E16_V_M2, VSSSEG4E16_V }, // 9165 + { PseudoVSSSEG4E16_V_M2_MASK, VSSSEG4E16_V }, // 9166 + { PseudoVSSSEG4E16_V_MF2, VSSSEG4E16_V }, // 9167 + { PseudoVSSSEG4E16_V_MF2_MASK, VSSSEG4E16_V }, // 9168 + { PseudoVSSSEG4E16_V_MF4, VSSSEG4E16_V }, // 9169 + { PseudoVSSSEG4E16_V_MF4_MASK, VSSSEG4E16_V }, // 9170 + { PseudoVSSSEG4E32_V_M1, VSSSEG4E32_V }, // 9171 + { PseudoVSSSEG4E32_V_M1_MASK, VSSSEG4E32_V }, // 9172 + { PseudoVSSSEG4E32_V_M2, VSSSEG4E32_V }, // 9173 + { PseudoVSSSEG4E32_V_M2_MASK, VSSSEG4E32_V }, // 9174 + { PseudoVSSSEG4E32_V_MF2, VSSSEG4E32_V }, // 9175 + { PseudoVSSSEG4E32_V_MF2_MASK, VSSSEG4E32_V }, // 9176 + { PseudoVSSSEG4E64_V_M1, VSSSEG4E64_V }, // 9177 + { PseudoVSSSEG4E64_V_M1_MASK, VSSSEG4E64_V }, // 9178 + { PseudoVSSSEG4E64_V_M2, VSSSEG4E64_V }, // 9179 + { PseudoVSSSEG4E64_V_M2_MASK, VSSSEG4E64_V }, // 9180 + { PseudoVSSSEG4E8_V_M1, VSSSEG4E8_V }, // 9181 + { PseudoVSSSEG4E8_V_M1_MASK, VSSSEG4E8_V }, // 9182 + { PseudoVSSSEG4E8_V_M2, VSSSEG4E8_V }, // 9183 + { PseudoVSSSEG4E8_V_M2_MASK, VSSSEG4E8_V }, // 9184 + { PseudoVSSSEG4E8_V_MF2, VSSSEG4E8_V }, // 9185 + { PseudoVSSSEG4E8_V_MF2_MASK, VSSSEG4E8_V }, // 9186 + { PseudoVSSSEG4E8_V_MF4, VSSSEG4E8_V }, // 9187 + { PseudoVSSSEG4E8_V_MF4_MASK, VSSSEG4E8_V }, // 9188 + { PseudoVSSSEG4E8_V_MF8, VSSSEG4E8_V }, // 9189 + { PseudoVSSSEG4E8_V_MF8_MASK, VSSSEG4E8_V }, // 9190 + { PseudoVSSSEG5E16_V_M1, VSSSEG5E16_V }, // 9191 + { PseudoVSSSEG5E16_V_M1_MASK, VSSSEG5E16_V }, // 9192 + { PseudoVSSSEG5E16_V_MF2, VSSSEG5E16_V }, // 9193 + { PseudoVSSSEG5E16_V_MF2_MASK, VSSSEG5E16_V }, // 9194 + { PseudoVSSSEG5E16_V_MF4, VSSSEG5E16_V }, // 9195 + { PseudoVSSSEG5E16_V_MF4_MASK, VSSSEG5E16_V }, // 9196 + { PseudoVSSSEG5E32_V_M1, VSSSEG5E32_V }, // 9197 + { PseudoVSSSEG5E32_V_M1_MASK, VSSSEG5E32_V }, // 9198 + { PseudoVSSSEG5E32_V_MF2, VSSSEG5E32_V }, // 9199 + { PseudoVSSSEG5E32_V_MF2_MASK, VSSSEG5E32_V }, // 9200 + { PseudoVSSSEG5E64_V_M1, VSSSEG5E64_V }, // 9201 + { PseudoVSSSEG5E64_V_M1_MASK, VSSSEG5E64_V }, // 9202 + { PseudoVSSSEG5E8_V_M1, VSSSEG5E8_V }, // 9203 + { PseudoVSSSEG5E8_V_M1_MASK, VSSSEG5E8_V }, // 9204 + { PseudoVSSSEG5E8_V_MF2, VSSSEG5E8_V }, // 9205 + { PseudoVSSSEG5E8_V_MF2_MASK, VSSSEG5E8_V }, // 9206 + { PseudoVSSSEG5E8_V_MF4, VSSSEG5E8_V }, // 9207 + { PseudoVSSSEG5E8_V_MF4_MASK, VSSSEG5E8_V }, // 9208 + { PseudoVSSSEG5E8_V_MF8, VSSSEG5E8_V }, // 9209 + { PseudoVSSSEG5E8_V_MF8_MASK, VSSSEG5E8_V }, // 9210 + { PseudoVSSSEG6E16_V_M1, VSSSEG6E16_V }, // 9211 + { PseudoVSSSEG6E16_V_M1_MASK, VSSSEG6E16_V }, // 9212 + { PseudoVSSSEG6E16_V_MF2, VSSSEG6E16_V }, // 9213 + { PseudoVSSSEG6E16_V_MF2_MASK, VSSSEG6E16_V }, // 9214 + { PseudoVSSSEG6E16_V_MF4, VSSSEG6E16_V }, // 9215 + { PseudoVSSSEG6E16_V_MF4_MASK, VSSSEG6E16_V }, // 9216 + { PseudoVSSSEG6E32_V_M1, VSSSEG6E32_V }, // 9217 + { PseudoVSSSEG6E32_V_M1_MASK, VSSSEG6E32_V }, // 9218 + { PseudoVSSSEG6E32_V_MF2, VSSSEG6E32_V }, // 9219 + { PseudoVSSSEG6E32_V_MF2_MASK, VSSSEG6E32_V }, // 9220 + { PseudoVSSSEG6E64_V_M1, VSSSEG6E64_V }, // 9221 + { PseudoVSSSEG6E64_V_M1_MASK, VSSSEG6E64_V }, // 9222 + { PseudoVSSSEG6E8_V_M1, VSSSEG6E8_V }, // 9223 + { PseudoVSSSEG6E8_V_M1_MASK, VSSSEG6E8_V }, // 9224 + { PseudoVSSSEG6E8_V_MF2, VSSSEG6E8_V }, // 9225 + { PseudoVSSSEG6E8_V_MF2_MASK, VSSSEG6E8_V }, // 9226 + { PseudoVSSSEG6E8_V_MF4, VSSSEG6E8_V }, // 9227 + { PseudoVSSSEG6E8_V_MF4_MASK, VSSSEG6E8_V }, // 9228 + { PseudoVSSSEG6E8_V_MF8, VSSSEG6E8_V }, // 9229 + { PseudoVSSSEG6E8_V_MF8_MASK, VSSSEG6E8_V }, // 9230 + { PseudoVSSSEG7E16_V_M1, VSSSEG7E16_V }, // 9231 + { PseudoVSSSEG7E16_V_M1_MASK, VSSSEG7E16_V }, // 9232 + { PseudoVSSSEG7E16_V_MF2, VSSSEG7E16_V }, // 9233 + { PseudoVSSSEG7E16_V_MF2_MASK, VSSSEG7E16_V }, // 9234 + { PseudoVSSSEG7E16_V_MF4, VSSSEG7E16_V }, // 9235 + { PseudoVSSSEG7E16_V_MF4_MASK, VSSSEG7E16_V }, // 9236 + { PseudoVSSSEG7E32_V_M1, VSSSEG7E32_V }, // 9237 + { PseudoVSSSEG7E32_V_M1_MASK, VSSSEG7E32_V }, // 9238 + { PseudoVSSSEG7E32_V_MF2, VSSSEG7E32_V }, // 9239 + { PseudoVSSSEG7E32_V_MF2_MASK, VSSSEG7E32_V }, // 9240 + { PseudoVSSSEG7E64_V_M1, VSSSEG7E64_V }, // 9241 + { PseudoVSSSEG7E64_V_M1_MASK, VSSSEG7E64_V }, // 9242 + { PseudoVSSSEG7E8_V_M1, VSSSEG7E8_V }, // 9243 + { PseudoVSSSEG7E8_V_M1_MASK, VSSSEG7E8_V }, // 9244 + { PseudoVSSSEG7E8_V_MF2, VSSSEG7E8_V }, // 9245 + { PseudoVSSSEG7E8_V_MF2_MASK, VSSSEG7E8_V }, // 9246 + { PseudoVSSSEG7E8_V_MF4, VSSSEG7E8_V }, // 9247 + { PseudoVSSSEG7E8_V_MF4_MASK, VSSSEG7E8_V }, // 9248 + { PseudoVSSSEG7E8_V_MF8, VSSSEG7E8_V }, // 9249 + { PseudoVSSSEG7E8_V_MF8_MASK, VSSSEG7E8_V }, // 9250 + { PseudoVSSSEG8E16_V_M1, VSSSEG8E16_V }, // 9251 + { PseudoVSSSEG8E16_V_M1_MASK, VSSSEG8E16_V }, // 9252 + { PseudoVSSSEG8E16_V_MF2, VSSSEG8E16_V }, // 9253 + { PseudoVSSSEG8E16_V_MF2_MASK, VSSSEG8E16_V }, // 9254 + { PseudoVSSSEG8E16_V_MF4, VSSSEG8E16_V }, // 9255 + { PseudoVSSSEG8E16_V_MF4_MASK, VSSSEG8E16_V }, // 9256 + { PseudoVSSSEG8E32_V_M1, VSSSEG8E32_V }, // 9257 + { PseudoVSSSEG8E32_V_M1_MASK, VSSSEG8E32_V }, // 9258 + { PseudoVSSSEG8E32_V_MF2, VSSSEG8E32_V }, // 9259 + { PseudoVSSSEG8E32_V_MF2_MASK, VSSSEG8E32_V }, // 9260 + { PseudoVSSSEG8E64_V_M1, VSSSEG8E64_V }, // 9261 + { PseudoVSSSEG8E64_V_M1_MASK, VSSSEG8E64_V }, // 9262 + { PseudoVSSSEG8E8_V_M1, VSSSEG8E8_V }, // 9263 + { PseudoVSSSEG8E8_V_M1_MASK, VSSSEG8E8_V }, // 9264 + { PseudoVSSSEG8E8_V_MF2, VSSSEG8E8_V }, // 9265 + { PseudoVSSSEG8E8_V_MF2_MASK, VSSSEG8E8_V }, // 9266 + { PseudoVSSSEG8E8_V_MF4, VSSSEG8E8_V }, // 9267 + { PseudoVSSSEG8E8_V_MF4_MASK, VSSSEG8E8_V }, // 9268 + { PseudoVSSSEG8E8_V_MF8, VSSSEG8E8_V }, // 9269 + { PseudoVSSSEG8E8_V_MF8_MASK, VSSSEG8E8_V }, // 9270 + { PseudoVSSUBU_VV_M1, VSSUBU_VV }, // 9271 + { PseudoVSSUBU_VV_M1_MASK, VSSUBU_VV }, // 9272 + { PseudoVSSUBU_VV_M2, VSSUBU_VV }, // 9273 + { PseudoVSSUBU_VV_M2_MASK, VSSUBU_VV }, // 9274 + { PseudoVSSUBU_VV_M4, VSSUBU_VV }, // 9275 + { PseudoVSSUBU_VV_M4_MASK, VSSUBU_VV }, // 9276 + { PseudoVSSUBU_VV_M8, VSSUBU_VV }, // 9277 + { PseudoVSSUBU_VV_M8_MASK, VSSUBU_VV }, // 9278 + { PseudoVSSUBU_VV_MF2, VSSUBU_VV }, // 9279 + { PseudoVSSUBU_VV_MF2_MASK, VSSUBU_VV }, // 9280 + { PseudoVSSUBU_VV_MF4, VSSUBU_VV }, // 9281 + { PseudoVSSUBU_VV_MF4_MASK, VSSUBU_VV }, // 9282 + { PseudoVSSUBU_VV_MF8, VSSUBU_VV }, // 9283 + { PseudoVSSUBU_VV_MF8_MASK, VSSUBU_VV }, // 9284 + { PseudoVSSUBU_VX_M1, VSSUBU_VX }, // 9285 + { PseudoVSSUBU_VX_M1_MASK, VSSUBU_VX }, // 9286 + { PseudoVSSUBU_VX_M2, VSSUBU_VX }, // 9287 + { PseudoVSSUBU_VX_M2_MASK, VSSUBU_VX }, // 9288 + { PseudoVSSUBU_VX_M4, VSSUBU_VX }, // 9289 + { PseudoVSSUBU_VX_M4_MASK, VSSUBU_VX }, // 9290 + { PseudoVSSUBU_VX_M8, VSSUBU_VX }, // 9291 + { PseudoVSSUBU_VX_M8_MASK, VSSUBU_VX }, // 9292 + { PseudoVSSUBU_VX_MF2, VSSUBU_VX }, // 9293 + { PseudoVSSUBU_VX_MF2_MASK, VSSUBU_VX }, // 9294 + { PseudoVSSUBU_VX_MF4, VSSUBU_VX }, // 9295 + { PseudoVSSUBU_VX_MF4_MASK, VSSUBU_VX }, // 9296 + { PseudoVSSUBU_VX_MF8, VSSUBU_VX }, // 9297 + { PseudoVSSUBU_VX_MF8_MASK, VSSUBU_VX }, // 9298 + { PseudoVSSUB_VV_M1, VSSUB_VV }, // 9299 + { PseudoVSSUB_VV_M1_MASK, VSSUB_VV }, // 9300 + { PseudoVSSUB_VV_M2, VSSUB_VV }, // 9301 + { PseudoVSSUB_VV_M2_MASK, VSSUB_VV }, // 9302 + { PseudoVSSUB_VV_M4, VSSUB_VV }, // 9303 + { PseudoVSSUB_VV_M4_MASK, VSSUB_VV }, // 9304 + { PseudoVSSUB_VV_M8, VSSUB_VV }, // 9305 + { PseudoVSSUB_VV_M8_MASK, VSSUB_VV }, // 9306 + { PseudoVSSUB_VV_MF2, VSSUB_VV }, // 9307 + { PseudoVSSUB_VV_MF2_MASK, VSSUB_VV }, // 9308 + { PseudoVSSUB_VV_MF4, VSSUB_VV }, // 9309 + { PseudoVSSUB_VV_MF4_MASK, VSSUB_VV }, // 9310 + { PseudoVSSUB_VV_MF8, VSSUB_VV }, // 9311 + { PseudoVSSUB_VV_MF8_MASK, VSSUB_VV }, // 9312 + { PseudoVSSUB_VX_M1, VSSUB_VX }, // 9313 + { PseudoVSSUB_VX_M1_MASK, VSSUB_VX }, // 9314 + { PseudoVSSUB_VX_M2, VSSUB_VX }, // 9315 + { PseudoVSSUB_VX_M2_MASK, VSSUB_VX }, // 9316 + { PseudoVSSUB_VX_M4, VSSUB_VX }, // 9317 + { PseudoVSSUB_VX_M4_MASK, VSSUB_VX }, // 9318 + { PseudoVSSUB_VX_M8, VSSUB_VX }, // 9319 + { PseudoVSSUB_VX_M8_MASK, VSSUB_VX }, // 9320 + { PseudoVSSUB_VX_MF2, VSSUB_VX }, // 9321 + { PseudoVSSUB_VX_MF2_MASK, VSSUB_VX }, // 9322 + { PseudoVSSUB_VX_MF4, VSSUB_VX }, // 9323 + { PseudoVSSUB_VX_MF4_MASK, VSSUB_VX }, // 9324 + { PseudoVSSUB_VX_MF8, VSSUB_VX }, // 9325 + { PseudoVSSUB_VX_MF8_MASK, VSSUB_VX }, // 9326 + { PseudoVSUB_VV_M1, VSUB_VV }, // 9327 + { PseudoVSUB_VV_M1_MASK, VSUB_VV }, // 9328 + { PseudoVSUB_VV_M2, VSUB_VV }, // 9329 + { PseudoVSUB_VV_M2_MASK, VSUB_VV }, // 9330 + { PseudoVSUB_VV_M4, VSUB_VV }, // 9331 + { PseudoVSUB_VV_M4_MASK, VSUB_VV }, // 9332 + { PseudoVSUB_VV_M8, VSUB_VV }, // 9333 + { PseudoVSUB_VV_M8_MASK, VSUB_VV }, // 9334 + { PseudoVSUB_VV_MF2, VSUB_VV }, // 9335 + { PseudoVSUB_VV_MF2_MASK, VSUB_VV }, // 9336 + { PseudoVSUB_VV_MF4, VSUB_VV }, // 9337 + { PseudoVSUB_VV_MF4_MASK, VSUB_VV }, // 9338 + { PseudoVSUB_VV_MF8, VSUB_VV }, // 9339 + { PseudoVSUB_VV_MF8_MASK, VSUB_VV }, // 9340 + { PseudoVSUB_VX_M1, VSUB_VX }, // 9341 + { PseudoVSUB_VX_M1_MASK, VSUB_VX }, // 9342 + { PseudoVSUB_VX_M2, VSUB_VX }, // 9343 + { PseudoVSUB_VX_M2_MASK, VSUB_VX }, // 9344 + { PseudoVSUB_VX_M4, VSUB_VX }, // 9345 + { PseudoVSUB_VX_M4_MASK, VSUB_VX }, // 9346 + { PseudoVSUB_VX_M8, VSUB_VX }, // 9347 + { PseudoVSUB_VX_M8_MASK, VSUB_VX }, // 9348 + { PseudoVSUB_VX_MF2, VSUB_VX }, // 9349 + { PseudoVSUB_VX_MF2_MASK, VSUB_VX }, // 9350 + { PseudoVSUB_VX_MF4, VSUB_VX }, // 9351 + { PseudoVSUB_VX_MF4_MASK, VSUB_VX }, // 9352 + { PseudoVSUB_VX_MF8, VSUB_VX }, // 9353 + { PseudoVSUB_VX_MF8_MASK, VSUB_VX }, // 9354 + { PseudoVSUXEI16_V_M1_M1, VSUXEI16_V }, // 9355 + { PseudoVSUXEI16_V_M1_M1_MASK, VSUXEI16_V }, // 9356 + { PseudoVSUXEI16_V_M1_M2, VSUXEI16_V }, // 9357 + { PseudoVSUXEI16_V_M1_M2_MASK, VSUXEI16_V }, // 9358 + { PseudoVSUXEI16_V_M1_M4, VSUXEI16_V }, // 9359 + { PseudoVSUXEI16_V_M1_M4_MASK, VSUXEI16_V }, // 9360 + { PseudoVSUXEI16_V_M1_MF2, VSUXEI16_V }, // 9361 + { PseudoVSUXEI16_V_M1_MF2_MASK, VSUXEI16_V }, // 9362 + { PseudoVSUXEI16_V_M2_M1, VSUXEI16_V }, // 9363 + { PseudoVSUXEI16_V_M2_M1_MASK, VSUXEI16_V }, // 9364 + { PseudoVSUXEI16_V_M2_M2, VSUXEI16_V }, // 9365 + { PseudoVSUXEI16_V_M2_M2_MASK, VSUXEI16_V }, // 9366 + { PseudoVSUXEI16_V_M2_M4, VSUXEI16_V }, // 9367 + { PseudoVSUXEI16_V_M2_M4_MASK, VSUXEI16_V }, // 9368 + { PseudoVSUXEI16_V_M2_M8, VSUXEI16_V }, // 9369 + { PseudoVSUXEI16_V_M2_M8_MASK, VSUXEI16_V }, // 9370 + { PseudoVSUXEI16_V_M4_M2, VSUXEI16_V }, // 9371 + { PseudoVSUXEI16_V_M4_M2_MASK, VSUXEI16_V }, // 9372 + { PseudoVSUXEI16_V_M4_M4, VSUXEI16_V }, // 9373 + { PseudoVSUXEI16_V_M4_M4_MASK, VSUXEI16_V }, // 9374 + { PseudoVSUXEI16_V_M4_M8, VSUXEI16_V }, // 9375 + { PseudoVSUXEI16_V_M4_M8_MASK, VSUXEI16_V }, // 9376 + { PseudoVSUXEI16_V_M8_M4, VSUXEI16_V }, // 9377 + { PseudoVSUXEI16_V_M8_M4_MASK, VSUXEI16_V }, // 9378 + { PseudoVSUXEI16_V_M8_M8, VSUXEI16_V }, // 9379 + { PseudoVSUXEI16_V_M8_M8_MASK, VSUXEI16_V }, // 9380 + { PseudoVSUXEI16_V_MF2_M1, VSUXEI16_V }, // 9381 + { PseudoVSUXEI16_V_MF2_M1_MASK, VSUXEI16_V }, // 9382 + { PseudoVSUXEI16_V_MF2_M2, VSUXEI16_V }, // 9383 + { PseudoVSUXEI16_V_MF2_M2_MASK, VSUXEI16_V }, // 9384 + { PseudoVSUXEI16_V_MF2_MF2, VSUXEI16_V }, // 9385 + { PseudoVSUXEI16_V_MF2_MF2_MASK, VSUXEI16_V }, // 9386 + { PseudoVSUXEI16_V_MF2_MF4, VSUXEI16_V }, // 9387 + { PseudoVSUXEI16_V_MF2_MF4_MASK, VSUXEI16_V }, // 9388 + { PseudoVSUXEI16_V_MF4_M1, VSUXEI16_V }, // 9389 + { PseudoVSUXEI16_V_MF4_M1_MASK, VSUXEI16_V }, // 9390 + { PseudoVSUXEI16_V_MF4_MF2, VSUXEI16_V }, // 9391 + { PseudoVSUXEI16_V_MF4_MF2_MASK, VSUXEI16_V }, // 9392 + { PseudoVSUXEI16_V_MF4_MF4, VSUXEI16_V }, // 9393 + { PseudoVSUXEI16_V_MF4_MF4_MASK, VSUXEI16_V }, // 9394 + { PseudoVSUXEI16_V_MF4_MF8, VSUXEI16_V }, // 9395 + { PseudoVSUXEI16_V_MF4_MF8_MASK, VSUXEI16_V }, // 9396 + { PseudoVSUXEI32_V_M1_M1, VSUXEI32_V }, // 9397 + { PseudoVSUXEI32_V_M1_M1_MASK, VSUXEI32_V }, // 9398 + { PseudoVSUXEI32_V_M1_M2, VSUXEI32_V }, // 9399 + { PseudoVSUXEI32_V_M1_M2_MASK, VSUXEI32_V }, // 9400 + { PseudoVSUXEI32_V_M1_MF2, VSUXEI32_V }, // 9401 + { PseudoVSUXEI32_V_M1_MF2_MASK, VSUXEI32_V }, // 9402 + { PseudoVSUXEI32_V_M1_MF4, VSUXEI32_V }, // 9403 + { PseudoVSUXEI32_V_M1_MF4_MASK, VSUXEI32_V }, // 9404 + { PseudoVSUXEI32_V_M2_M1, VSUXEI32_V }, // 9405 + { PseudoVSUXEI32_V_M2_M1_MASK, VSUXEI32_V }, // 9406 + { PseudoVSUXEI32_V_M2_M2, VSUXEI32_V }, // 9407 + { PseudoVSUXEI32_V_M2_M2_MASK, VSUXEI32_V }, // 9408 + { PseudoVSUXEI32_V_M2_M4, VSUXEI32_V }, // 9409 + { PseudoVSUXEI32_V_M2_M4_MASK, VSUXEI32_V }, // 9410 + { PseudoVSUXEI32_V_M2_MF2, VSUXEI32_V }, // 9411 + { PseudoVSUXEI32_V_M2_MF2_MASK, VSUXEI32_V }, // 9412 + { PseudoVSUXEI32_V_M4_M1, VSUXEI32_V }, // 9413 + { PseudoVSUXEI32_V_M4_M1_MASK, VSUXEI32_V }, // 9414 + { PseudoVSUXEI32_V_M4_M2, VSUXEI32_V }, // 9415 + { PseudoVSUXEI32_V_M4_M2_MASK, VSUXEI32_V }, // 9416 + { PseudoVSUXEI32_V_M4_M4, VSUXEI32_V }, // 9417 + { PseudoVSUXEI32_V_M4_M4_MASK, VSUXEI32_V }, // 9418 + { PseudoVSUXEI32_V_M4_M8, VSUXEI32_V }, // 9419 + { PseudoVSUXEI32_V_M4_M8_MASK, VSUXEI32_V }, // 9420 + { PseudoVSUXEI32_V_M8_M2, VSUXEI32_V }, // 9421 + { PseudoVSUXEI32_V_M8_M2_MASK, VSUXEI32_V }, // 9422 + { PseudoVSUXEI32_V_M8_M4, VSUXEI32_V }, // 9423 + { PseudoVSUXEI32_V_M8_M4_MASK, VSUXEI32_V }, // 9424 + { PseudoVSUXEI32_V_M8_M8, VSUXEI32_V }, // 9425 + { PseudoVSUXEI32_V_M8_M8_MASK, VSUXEI32_V }, // 9426 + { PseudoVSUXEI32_V_MF2_M1, VSUXEI32_V }, // 9427 + { PseudoVSUXEI32_V_MF2_M1_MASK, VSUXEI32_V }, // 9428 + { PseudoVSUXEI32_V_MF2_MF2, VSUXEI32_V }, // 9429 + { PseudoVSUXEI32_V_MF2_MF2_MASK, VSUXEI32_V }, // 9430 + { PseudoVSUXEI32_V_MF2_MF4, VSUXEI32_V }, // 9431 + { PseudoVSUXEI32_V_MF2_MF4_MASK, VSUXEI32_V }, // 9432 + { PseudoVSUXEI32_V_MF2_MF8, VSUXEI32_V }, // 9433 + { PseudoVSUXEI32_V_MF2_MF8_MASK, VSUXEI32_V }, // 9434 + { PseudoVSUXEI64_V_M1_M1, VSUXEI64_V }, // 9435 + { PseudoVSUXEI64_V_M1_M1_MASK, VSUXEI64_V }, // 9436 + { PseudoVSUXEI64_V_M1_MF2, VSUXEI64_V }, // 9437 + { PseudoVSUXEI64_V_M1_MF2_MASK, VSUXEI64_V }, // 9438 + { PseudoVSUXEI64_V_M1_MF4, VSUXEI64_V }, // 9439 + { PseudoVSUXEI64_V_M1_MF4_MASK, VSUXEI64_V }, // 9440 + { PseudoVSUXEI64_V_M1_MF8, VSUXEI64_V }, // 9441 + { PseudoVSUXEI64_V_M1_MF8_MASK, VSUXEI64_V }, // 9442 + { PseudoVSUXEI64_V_M2_M1, VSUXEI64_V }, // 9443 + { PseudoVSUXEI64_V_M2_M1_MASK, VSUXEI64_V }, // 9444 + { PseudoVSUXEI64_V_M2_M2, VSUXEI64_V }, // 9445 + { PseudoVSUXEI64_V_M2_M2_MASK, VSUXEI64_V }, // 9446 + { PseudoVSUXEI64_V_M2_MF2, VSUXEI64_V }, // 9447 + { PseudoVSUXEI64_V_M2_MF2_MASK, VSUXEI64_V }, // 9448 + { PseudoVSUXEI64_V_M2_MF4, VSUXEI64_V }, // 9449 + { PseudoVSUXEI64_V_M2_MF4_MASK, VSUXEI64_V }, // 9450 + { PseudoVSUXEI64_V_M4_M1, VSUXEI64_V }, // 9451 + { PseudoVSUXEI64_V_M4_M1_MASK, VSUXEI64_V }, // 9452 + { PseudoVSUXEI64_V_M4_M2, VSUXEI64_V }, // 9453 + { PseudoVSUXEI64_V_M4_M2_MASK, VSUXEI64_V }, // 9454 + { PseudoVSUXEI64_V_M4_M4, VSUXEI64_V }, // 9455 + { PseudoVSUXEI64_V_M4_M4_MASK, VSUXEI64_V }, // 9456 + { PseudoVSUXEI64_V_M4_MF2, VSUXEI64_V }, // 9457 + { PseudoVSUXEI64_V_M4_MF2_MASK, VSUXEI64_V }, // 9458 + { PseudoVSUXEI64_V_M8_M1, VSUXEI64_V }, // 9459 + { PseudoVSUXEI64_V_M8_M1_MASK, VSUXEI64_V }, // 9460 + { PseudoVSUXEI64_V_M8_M2, VSUXEI64_V }, // 9461 + { PseudoVSUXEI64_V_M8_M2_MASK, VSUXEI64_V }, // 9462 + { PseudoVSUXEI64_V_M8_M4, VSUXEI64_V }, // 9463 + { PseudoVSUXEI64_V_M8_M4_MASK, VSUXEI64_V }, // 9464 + { PseudoVSUXEI64_V_M8_M8, VSUXEI64_V }, // 9465 + { PseudoVSUXEI64_V_M8_M8_MASK, VSUXEI64_V }, // 9466 + { PseudoVSUXEI8_V_M1_M1, VSUXEI8_V }, // 9467 + { PseudoVSUXEI8_V_M1_M1_MASK, VSUXEI8_V }, // 9468 + { PseudoVSUXEI8_V_M1_M2, VSUXEI8_V }, // 9469 + { PseudoVSUXEI8_V_M1_M2_MASK, VSUXEI8_V }, // 9470 + { PseudoVSUXEI8_V_M1_M4, VSUXEI8_V }, // 9471 + { PseudoVSUXEI8_V_M1_M4_MASK, VSUXEI8_V }, // 9472 + { PseudoVSUXEI8_V_M1_M8, VSUXEI8_V }, // 9473 + { PseudoVSUXEI8_V_M1_M8_MASK, VSUXEI8_V }, // 9474 + { PseudoVSUXEI8_V_M2_M2, VSUXEI8_V }, // 9475 + { PseudoVSUXEI8_V_M2_M2_MASK, VSUXEI8_V }, // 9476 + { PseudoVSUXEI8_V_M2_M4, VSUXEI8_V }, // 9477 + { PseudoVSUXEI8_V_M2_M4_MASK, VSUXEI8_V }, // 9478 + { PseudoVSUXEI8_V_M2_M8, VSUXEI8_V }, // 9479 + { PseudoVSUXEI8_V_M2_M8_MASK, VSUXEI8_V }, // 9480 + { PseudoVSUXEI8_V_M4_M4, VSUXEI8_V }, // 9481 + { PseudoVSUXEI8_V_M4_M4_MASK, VSUXEI8_V }, // 9482 + { PseudoVSUXEI8_V_M4_M8, VSUXEI8_V }, // 9483 + { PseudoVSUXEI8_V_M4_M8_MASK, VSUXEI8_V }, // 9484 + { PseudoVSUXEI8_V_M8_M8, VSUXEI8_V }, // 9485 + { PseudoVSUXEI8_V_M8_M8_MASK, VSUXEI8_V }, // 9486 + { PseudoVSUXEI8_V_MF2_M1, VSUXEI8_V }, // 9487 + { PseudoVSUXEI8_V_MF2_M1_MASK, VSUXEI8_V }, // 9488 + { PseudoVSUXEI8_V_MF2_M2, VSUXEI8_V }, // 9489 + { PseudoVSUXEI8_V_MF2_M2_MASK, VSUXEI8_V }, // 9490 + { PseudoVSUXEI8_V_MF2_M4, VSUXEI8_V }, // 9491 + { PseudoVSUXEI8_V_MF2_M4_MASK, VSUXEI8_V }, // 9492 + { PseudoVSUXEI8_V_MF2_MF2, VSUXEI8_V }, // 9493 + { PseudoVSUXEI8_V_MF2_MF2_MASK, VSUXEI8_V }, // 9494 + { PseudoVSUXEI8_V_MF4_M1, VSUXEI8_V }, // 9495 + { PseudoVSUXEI8_V_MF4_M1_MASK, VSUXEI8_V }, // 9496 + { PseudoVSUXEI8_V_MF4_M2, VSUXEI8_V }, // 9497 + { PseudoVSUXEI8_V_MF4_M2_MASK, VSUXEI8_V }, // 9498 + { PseudoVSUXEI8_V_MF4_MF2, VSUXEI8_V }, // 9499 + { PseudoVSUXEI8_V_MF4_MF2_MASK, VSUXEI8_V }, // 9500 + { PseudoVSUXEI8_V_MF4_MF4, VSUXEI8_V }, // 9501 + { PseudoVSUXEI8_V_MF4_MF4_MASK, VSUXEI8_V }, // 9502 + { PseudoVSUXEI8_V_MF8_M1, VSUXEI8_V }, // 9503 + { PseudoVSUXEI8_V_MF8_M1_MASK, VSUXEI8_V }, // 9504 + { PseudoVSUXEI8_V_MF8_MF2, VSUXEI8_V }, // 9505 + { PseudoVSUXEI8_V_MF8_MF2_MASK, VSUXEI8_V }, // 9506 + { PseudoVSUXEI8_V_MF8_MF4, VSUXEI8_V }, // 9507 + { PseudoVSUXEI8_V_MF8_MF4_MASK, VSUXEI8_V }, // 9508 + { PseudoVSUXEI8_V_MF8_MF8, VSUXEI8_V }, // 9509 + { PseudoVSUXEI8_V_MF8_MF8_MASK, VSUXEI8_V }, // 9510 + { PseudoVSUXSEG2EI16_V_M1_M1, VSUXSEG2EI16_V }, // 9511 + { PseudoVSUXSEG2EI16_V_M1_M1_MASK, VSUXSEG2EI16_V }, // 9512 + { PseudoVSUXSEG2EI16_V_M1_M2, VSUXSEG2EI16_V }, // 9513 + { PseudoVSUXSEG2EI16_V_M1_M2_MASK, VSUXSEG2EI16_V }, // 9514 + { PseudoVSUXSEG2EI16_V_M1_M4, VSUXSEG2EI16_V }, // 9515 + { PseudoVSUXSEG2EI16_V_M1_M4_MASK, VSUXSEG2EI16_V }, // 9516 + { PseudoVSUXSEG2EI16_V_M1_MF2, VSUXSEG2EI16_V }, // 9517 + { PseudoVSUXSEG2EI16_V_M1_MF2_MASK, VSUXSEG2EI16_V }, // 9518 + { PseudoVSUXSEG2EI16_V_M2_M1, VSUXSEG2EI16_V }, // 9519 + { PseudoVSUXSEG2EI16_V_M2_M1_MASK, VSUXSEG2EI16_V }, // 9520 + { PseudoVSUXSEG2EI16_V_M2_M2, VSUXSEG2EI16_V }, // 9521 + { PseudoVSUXSEG2EI16_V_M2_M2_MASK, VSUXSEG2EI16_V }, // 9522 + { PseudoVSUXSEG2EI16_V_M2_M4, VSUXSEG2EI16_V }, // 9523 + { PseudoVSUXSEG2EI16_V_M2_M4_MASK, VSUXSEG2EI16_V }, // 9524 + { PseudoVSUXSEG2EI16_V_M4_M2, VSUXSEG2EI16_V }, // 9525 + { PseudoVSUXSEG2EI16_V_M4_M2_MASK, VSUXSEG2EI16_V }, // 9526 + { PseudoVSUXSEG2EI16_V_M4_M4, VSUXSEG2EI16_V }, // 9527 + { PseudoVSUXSEG2EI16_V_M4_M4_MASK, VSUXSEG2EI16_V }, // 9528 + { PseudoVSUXSEG2EI16_V_M8_M4, VSUXSEG2EI16_V }, // 9529 + { PseudoVSUXSEG2EI16_V_M8_M4_MASK, VSUXSEG2EI16_V }, // 9530 + { PseudoVSUXSEG2EI16_V_MF2_M1, VSUXSEG2EI16_V }, // 9531 + { PseudoVSUXSEG2EI16_V_MF2_M1_MASK, VSUXSEG2EI16_V }, // 9532 + { PseudoVSUXSEG2EI16_V_MF2_M2, VSUXSEG2EI16_V }, // 9533 + { PseudoVSUXSEG2EI16_V_MF2_M2_MASK, VSUXSEG2EI16_V }, // 9534 + { PseudoVSUXSEG2EI16_V_MF2_MF2, VSUXSEG2EI16_V }, // 9535 + { PseudoVSUXSEG2EI16_V_MF2_MF2_MASK, VSUXSEG2EI16_V }, // 9536 + { PseudoVSUXSEG2EI16_V_MF2_MF4, VSUXSEG2EI16_V }, // 9537 + { PseudoVSUXSEG2EI16_V_MF2_MF4_MASK, VSUXSEG2EI16_V }, // 9538 + { PseudoVSUXSEG2EI16_V_MF4_M1, VSUXSEG2EI16_V }, // 9539 + { PseudoVSUXSEG2EI16_V_MF4_M1_MASK, VSUXSEG2EI16_V }, // 9540 + { PseudoVSUXSEG2EI16_V_MF4_MF2, VSUXSEG2EI16_V }, // 9541 + { PseudoVSUXSEG2EI16_V_MF4_MF2_MASK, VSUXSEG2EI16_V }, // 9542 + { PseudoVSUXSEG2EI16_V_MF4_MF4, VSUXSEG2EI16_V }, // 9543 + { PseudoVSUXSEG2EI16_V_MF4_MF4_MASK, VSUXSEG2EI16_V }, // 9544 + { PseudoVSUXSEG2EI16_V_MF4_MF8, VSUXSEG2EI16_V }, // 9545 + { PseudoVSUXSEG2EI16_V_MF4_MF8_MASK, VSUXSEG2EI16_V }, // 9546 + { PseudoVSUXSEG2EI32_V_M1_M1, VSUXSEG2EI32_V }, // 9547 + { PseudoVSUXSEG2EI32_V_M1_M1_MASK, VSUXSEG2EI32_V }, // 9548 + { PseudoVSUXSEG2EI32_V_M1_M2, VSUXSEG2EI32_V }, // 9549 + { PseudoVSUXSEG2EI32_V_M1_M2_MASK, VSUXSEG2EI32_V }, // 9550 + { PseudoVSUXSEG2EI32_V_M1_MF2, VSUXSEG2EI32_V }, // 9551 + { PseudoVSUXSEG2EI32_V_M1_MF2_MASK, VSUXSEG2EI32_V }, // 9552 + { PseudoVSUXSEG2EI32_V_M1_MF4, VSUXSEG2EI32_V }, // 9553 + { PseudoVSUXSEG2EI32_V_M1_MF4_MASK, VSUXSEG2EI32_V }, // 9554 + { PseudoVSUXSEG2EI32_V_M2_M1, VSUXSEG2EI32_V }, // 9555 + { PseudoVSUXSEG2EI32_V_M2_M1_MASK, VSUXSEG2EI32_V }, // 9556 + { PseudoVSUXSEG2EI32_V_M2_M2, VSUXSEG2EI32_V }, // 9557 + { PseudoVSUXSEG2EI32_V_M2_M2_MASK, VSUXSEG2EI32_V }, // 9558 + { PseudoVSUXSEG2EI32_V_M2_M4, VSUXSEG2EI32_V }, // 9559 + { PseudoVSUXSEG2EI32_V_M2_M4_MASK, VSUXSEG2EI32_V }, // 9560 + { PseudoVSUXSEG2EI32_V_M2_MF2, VSUXSEG2EI32_V }, // 9561 + { PseudoVSUXSEG2EI32_V_M2_MF2_MASK, VSUXSEG2EI32_V }, // 9562 + { PseudoVSUXSEG2EI32_V_M4_M1, VSUXSEG2EI32_V }, // 9563 + { PseudoVSUXSEG2EI32_V_M4_M1_MASK, VSUXSEG2EI32_V }, // 9564 + { PseudoVSUXSEG2EI32_V_M4_M2, VSUXSEG2EI32_V }, // 9565 + { PseudoVSUXSEG2EI32_V_M4_M2_MASK, VSUXSEG2EI32_V }, // 9566 + { PseudoVSUXSEG2EI32_V_M4_M4, VSUXSEG2EI32_V }, // 9567 + { PseudoVSUXSEG2EI32_V_M4_M4_MASK, VSUXSEG2EI32_V }, // 9568 + { PseudoVSUXSEG2EI32_V_M8_M2, VSUXSEG2EI32_V }, // 9569 + { PseudoVSUXSEG2EI32_V_M8_M2_MASK, VSUXSEG2EI32_V }, // 9570 + { PseudoVSUXSEG2EI32_V_M8_M4, VSUXSEG2EI32_V }, // 9571 + { PseudoVSUXSEG2EI32_V_M8_M4_MASK, VSUXSEG2EI32_V }, // 9572 + { PseudoVSUXSEG2EI32_V_MF2_M1, VSUXSEG2EI32_V }, // 9573 + { PseudoVSUXSEG2EI32_V_MF2_M1_MASK, VSUXSEG2EI32_V }, // 9574 + { PseudoVSUXSEG2EI32_V_MF2_MF2, VSUXSEG2EI32_V }, // 9575 + { PseudoVSUXSEG2EI32_V_MF2_MF2_MASK, VSUXSEG2EI32_V }, // 9576 + { PseudoVSUXSEG2EI32_V_MF2_MF4, VSUXSEG2EI32_V }, // 9577 + { PseudoVSUXSEG2EI32_V_MF2_MF4_MASK, VSUXSEG2EI32_V }, // 9578 + { PseudoVSUXSEG2EI32_V_MF2_MF8, VSUXSEG2EI32_V }, // 9579 + { PseudoVSUXSEG2EI32_V_MF2_MF8_MASK, VSUXSEG2EI32_V }, // 9580 + { PseudoVSUXSEG2EI64_V_M1_M1, VSUXSEG2EI64_V }, // 9581 + { PseudoVSUXSEG2EI64_V_M1_M1_MASK, VSUXSEG2EI64_V }, // 9582 + { PseudoVSUXSEG2EI64_V_M1_MF2, VSUXSEG2EI64_V }, // 9583 + { PseudoVSUXSEG2EI64_V_M1_MF2_MASK, VSUXSEG2EI64_V }, // 9584 + { PseudoVSUXSEG2EI64_V_M1_MF4, VSUXSEG2EI64_V }, // 9585 + { PseudoVSUXSEG2EI64_V_M1_MF4_MASK, VSUXSEG2EI64_V }, // 9586 + { PseudoVSUXSEG2EI64_V_M1_MF8, VSUXSEG2EI64_V }, // 9587 + { PseudoVSUXSEG2EI64_V_M1_MF8_MASK, VSUXSEG2EI64_V }, // 9588 + { PseudoVSUXSEG2EI64_V_M2_M1, VSUXSEG2EI64_V }, // 9589 + { PseudoVSUXSEG2EI64_V_M2_M1_MASK, VSUXSEG2EI64_V }, // 9590 + { PseudoVSUXSEG2EI64_V_M2_M2, VSUXSEG2EI64_V }, // 9591 + { PseudoVSUXSEG2EI64_V_M2_M2_MASK, VSUXSEG2EI64_V }, // 9592 + { PseudoVSUXSEG2EI64_V_M2_MF2, VSUXSEG2EI64_V }, // 9593 + { PseudoVSUXSEG2EI64_V_M2_MF2_MASK, VSUXSEG2EI64_V }, // 9594 + { PseudoVSUXSEG2EI64_V_M2_MF4, VSUXSEG2EI64_V }, // 9595 + { PseudoVSUXSEG2EI64_V_M2_MF4_MASK, VSUXSEG2EI64_V }, // 9596 + { PseudoVSUXSEG2EI64_V_M4_M1, VSUXSEG2EI64_V }, // 9597 + { PseudoVSUXSEG2EI64_V_M4_M1_MASK, VSUXSEG2EI64_V }, // 9598 + { PseudoVSUXSEG2EI64_V_M4_M2, VSUXSEG2EI64_V }, // 9599 + { PseudoVSUXSEG2EI64_V_M4_M2_MASK, VSUXSEG2EI64_V }, // 9600 + { PseudoVSUXSEG2EI64_V_M4_M4, VSUXSEG2EI64_V }, // 9601 + { PseudoVSUXSEG2EI64_V_M4_M4_MASK, VSUXSEG2EI64_V }, // 9602 + { PseudoVSUXSEG2EI64_V_M4_MF2, VSUXSEG2EI64_V }, // 9603 + { PseudoVSUXSEG2EI64_V_M4_MF2_MASK, VSUXSEG2EI64_V }, // 9604 + { PseudoVSUXSEG2EI64_V_M8_M1, VSUXSEG2EI64_V }, // 9605 + { PseudoVSUXSEG2EI64_V_M8_M1_MASK, VSUXSEG2EI64_V }, // 9606 + { PseudoVSUXSEG2EI64_V_M8_M2, VSUXSEG2EI64_V }, // 9607 + { PseudoVSUXSEG2EI64_V_M8_M2_MASK, VSUXSEG2EI64_V }, // 9608 + { PseudoVSUXSEG2EI64_V_M8_M4, VSUXSEG2EI64_V }, // 9609 + { PseudoVSUXSEG2EI64_V_M8_M4_MASK, VSUXSEG2EI64_V }, // 9610 + { PseudoVSUXSEG2EI8_V_M1_M1, VSUXSEG2EI8_V }, // 9611 + { PseudoVSUXSEG2EI8_V_M1_M1_MASK, VSUXSEG2EI8_V }, // 9612 + { PseudoVSUXSEG2EI8_V_M1_M2, VSUXSEG2EI8_V }, // 9613 + { PseudoVSUXSEG2EI8_V_M1_M2_MASK, VSUXSEG2EI8_V }, // 9614 + { PseudoVSUXSEG2EI8_V_M1_M4, VSUXSEG2EI8_V }, // 9615 + { PseudoVSUXSEG2EI8_V_M1_M4_MASK, VSUXSEG2EI8_V }, // 9616 + { PseudoVSUXSEG2EI8_V_M2_M2, VSUXSEG2EI8_V }, // 9617 + { PseudoVSUXSEG2EI8_V_M2_M2_MASK, VSUXSEG2EI8_V }, // 9618 + { PseudoVSUXSEG2EI8_V_M2_M4, VSUXSEG2EI8_V }, // 9619 + { PseudoVSUXSEG2EI8_V_M2_M4_MASK, VSUXSEG2EI8_V }, // 9620 + { PseudoVSUXSEG2EI8_V_M4_M4, VSUXSEG2EI8_V }, // 9621 + { PseudoVSUXSEG2EI8_V_M4_M4_MASK, VSUXSEG2EI8_V }, // 9622 + { PseudoVSUXSEG2EI8_V_MF2_M1, VSUXSEG2EI8_V }, // 9623 + { PseudoVSUXSEG2EI8_V_MF2_M1_MASK, VSUXSEG2EI8_V }, // 9624 + { PseudoVSUXSEG2EI8_V_MF2_M2, VSUXSEG2EI8_V }, // 9625 + { PseudoVSUXSEG2EI8_V_MF2_M2_MASK, VSUXSEG2EI8_V }, // 9626 + { PseudoVSUXSEG2EI8_V_MF2_M4, VSUXSEG2EI8_V }, // 9627 + { PseudoVSUXSEG2EI8_V_MF2_M4_MASK, VSUXSEG2EI8_V }, // 9628 + { PseudoVSUXSEG2EI8_V_MF2_MF2, VSUXSEG2EI8_V }, // 9629 + { PseudoVSUXSEG2EI8_V_MF2_MF2_MASK, VSUXSEG2EI8_V }, // 9630 + { PseudoVSUXSEG2EI8_V_MF4_M1, VSUXSEG2EI8_V }, // 9631 + { PseudoVSUXSEG2EI8_V_MF4_M1_MASK, VSUXSEG2EI8_V }, // 9632 + { PseudoVSUXSEG2EI8_V_MF4_M2, VSUXSEG2EI8_V }, // 9633 + { PseudoVSUXSEG2EI8_V_MF4_M2_MASK, VSUXSEG2EI8_V }, // 9634 + { PseudoVSUXSEG2EI8_V_MF4_MF2, VSUXSEG2EI8_V }, // 9635 + { PseudoVSUXSEG2EI8_V_MF4_MF2_MASK, VSUXSEG2EI8_V }, // 9636 + { PseudoVSUXSEG2EI8_V_MF4_MF4, VSUXSEG2EI8_V }, // 9637 + { PseudoVSUXSEG2EI8_V_MF4_MF4_MASK, VSUXSEG2EI8_V }, // 9638 + { PseudoVSUXSEG2EI8_V_MF8_M1, VSUXSEG2EI8_V }, // 9639 + { PseudoVSUXSEG2EI8_V_MF8_M1_MASK, VSUXSEG2EI8_V }, // 9640 + { PseudoVSUXSEG2EI8_V_MF8_MF2, VSUXSEG2EI8_V }, // 9641 + { PseudoVSUXSEG2EI8_V_MF8_MF2_MASK, VSUXSEG2EI8_V }, // 9642 + { PseudoVSUXSEG2EI8_V_MF8_MF4, VSUXSEG2EI8_V }, // 9643 + { PseudoVSUXSEG2EI8_V_MF8_MF4_MASK, VSUXSEG2EI8_V }, // 9644 + { PseudoVSUXSEG2EI8_V_MF8_MF8, VSUXSEG2EI8_V }, // 9645 + { PseudoVSUXSEG2EI8_V_MF8_MF8_MASK, VSUXSEG2EI8_V }, // 9646 + { PseudoVSUXSEG3EI16_V_M1_M1, VSUXSEG3EI16_V }, // 9647 + { PseudoVSUXSEG3EI16_V_M1_M1_MASK, VSUXSEG3EI16_V }, // 9648 + { PseudoVSUXSEG3EI16_V_M1_M2, VSUXSEG3EI16_V }, // 9649 + { PseudoVSUXSEG3EI16_V_M1_M2_MASK, VSUXSEG3EI16_V }, // 9650 + { PseudoVSUXSEG3EI16_V_M1_MF2, VSUXSEG3EI16_V }, // 9651 + { PseudoVSUXSEG3EI16_V_M1_MF2_MASK, VSUXSEG3EI16_V }, // 9652 + { PseudoVSUXSEG3EI16_V_M2_M1, VSUXSEG3EI16_V }, // 9653 + { PseudoVSUXSEG3EI16_V_M2_M1_MASK, VSUXSEG3EI16_V }, // 9654 + { PseudoVSUXSEG3EI16_V_M2_M2, VSUXSEG3EI16_V }, // 9655 + { PseudoVSUXSEG3EI16_V_M2_M2_MASK, VSUXSEG3EI16_V }, // 9656 + { PseudoVSUXSEG3EI16_V_M4_M2, VSUXSEG3EI16_V }, // 9657 + { PseudoVSUXSEG3EI16_V_M4_M2_MASK, VSUXSEG3EI16_V }, // 9658 + { PseudoVSUXSEG3EI16_V_MF2_M1, VSUXSEG3EI16_V }, // 9659 + { PseudoVSUXSEG3EI16_V_MF2_M1_MASK, VSUXSEG3EI16_V }, // 9660 + { PseudoVSUXSEG3EI16_V_MF2_M2, VSUXSEG3EI16_V }, // 9661 + { PseudoVSUXSEG3EI16_V_MF2_M2_MASK, VSUXSEG3EI16_V }, // 9662 + { PseudoVSUXSEG3EI16_V_MF2_MF2, VSUXSEG3EI16_V }, // 9663 + { PseudoVSUXSEG3EI16_V_MF2_MF2_MASK, VSUXSEG3EI16_V }, // 9664 + { PseudoVSUXSEG3EI16_V_MF2_MF4, VSUXSEG3EI16_V }, // 9665 + { PseudoVSUXSEG3EI16_V_MF2_MF4_MASK, VSUXSEG3EI16_V }, // 9666 + { PseudoVSUXSEG3EI16_V_MF4_M1, VSUXSEG3EI16_V }, // 9667 + { PseudoVSUXSEG3EI16_V_MF4_M1_MASK, VSUXSEG3EI16_V }, // 9668 + { PseudoVSUXSEG3EI16_V_MF4_MF2, VSUXSEG3EI16_V }, // 9669 + { PseudoVSUXSEG3EI16_V_MF4_MF2_MASK, VSUXSEG3EI16_V }, // 9670 + { PseudoVSUXSEG3EI16_V_MF4_MF4, VSUXSEG3EI16_V }, // 9671 + { PseudoVSUXSEG3EI16_V_MF4_MF4_MASK, VSUXSEG3EI16_V }, // 9672 + { PseudoVSUXSEG3EI16_V_MF4_MF8, VSUXSEG3EI16_V }, // 9673 + { PseudoVSUXSEG3EI16_V_MF4_MF8_MASK, VSUXSEG3EI16_V }, // 9674 + { PseudoVSUXSEG3EI32_V_M1_M1, VSUXSEG3EI32_V }, // 9675 + { PseudoVSUXSEG3EI32_V_M1_M1_MASK, VSUXSEG3EI32_V }, // 9676 + { PseudoVSUXSEG3EI32_V_M1_M2, VSUXSEG3EI32_V }, // 9677 + { PseudoVSUXSEG3EI32_V_M1_M2_MASK, VSUXSEG3EI32_V }, // 9678 + { PseudoVSUXSEG3EI32_V_M1_MF2, VSUXSEG3EI32_V }, // 9679 + { PseudoVSUXSEG3EI32_V_M1_MF2_MASK, VSUXSEG3EI32_V }, // 9680 + { PseudoVSUXSEG3EI32_V_M1_MF4, VSUXSEG3EI32_V }, // 9681 + { PseudoVSUXSEG3EI32_V_M1_MF4_MASK, VSUXSEG3EI32_V }, // 9682 + { PseudoVSUXSEG3EI32_V_M2_M1, VSUXSEG3EI32_V }, // 9683 + { PseudoVSUXSEG3EI32_V_M2_M1_MASK, VSUXSEG3EI32_V }, // 9684 + { PseudoVSUXSEG3EI32_V_M2_M2, VSUXSEG3EI32_V }, // 9685 + { PseudoVSUXSEG3EI32_V_M2_M2_MASK, VSUXSEG3EI32_V }, // 9686 + { PseudoVSUXSEG3EI32_V_M2_MF2, VSUXSEG3EI32_V }, // 9687 + { PseudoVSUXSEG3EI32_V_M2_MF2_MASK, VSUXSEG3EI32_V }, // 9688 + { PseudoVSUXSEG3EI32_V_M4_M1, VSUXSEG3EI32_V }, // 9689 + { PseudoVSUXSEG3EI32_V_M4_M1_MASK, VSUXSEG3EI32_V }, // 9690 + { PseudoVSUXSEG3EI32_V_M4_M2, VSUXSEG3EI32_V }, // 9691 + { PseudoVSUXSEG3EI32_V_M4_M2_MASK, VSUXSEG3EI32_V }, // 9692 + { PseudoVSUXSEG3EI32_V_M8_M2, VSUXSEG3EI32_V }, // 9693 + { PseudoVSUXSEG3EI32_V_M8_M2_MASK, VSUXSEG3EI32_V }, // 9694 + { PseudoVSUXSEG3EI32_V_MF2_M1, VSUXSEG3EI32_V }, // 9695 + { PseudoVSUXSEG3EI32_V_MF2_M1_MASK, VSUXSEG3EI32_V }, // 9696 + { PseudoVSUXSEG3EI32_V_MF2_MF2, VSUXSEG3EI32_V }, // 9697 + { PseudoVSUXSEG3EI32_V_MF2_MF2_MASK, VSUXSEG3EI32_V }, // 9698 + { PseudoVSUXSEG3EI32_V_MF2_MF4, VSUXSEG3EI32_V }, // 9699 + { PseudoVSUXSEG3EI32_V_MF2_MF4_MASK, VSUXSEG3EI32_V }, // 9700 + { PseudoVSUXSEG3EI32_V_MF2_MF8, VSUXSEG3EI32_V }, // 9701 + { PseudoVSUXSEG3EI32_V_MF2_MF8_MASK, VSUXSEG3EI32_V }, // 9702 + { PseudoVSUXSEG3EI64_V_M1_M1, VSUXSEG3EI64_V }, // 9703 + { PseudoVSUXSEG3EI64_V_M1_M1_MASK, VSUXSEG3EI64_V }, // 9704 + { PseudoVSUXSEG3EI64_V_M1_MF2, VSUXSEG3EI64_V }, // 9705 + { PseudoVSUXSEG3EI64_V_M1_MF2_MASK, VSUXSEG3EI64_V }, // 9706 + { PseudoVSUXSEG3EI64_V_M1_MF4, VSUXSEG3EI64_V }, // 9707 + { PseudoVSUXSEG3EI64_V_M1_MF4_MASK, VSUXSEG3EI64_V }, // 9708 + { PseudoVSUXSEG3EI64_V_M1_MF8, VSUXSEG3EI64_V }, // 9709 + { PseudoVSUXSEG3EI64_V_M1_MF8_MASK, VSUXSEG3EI64_V }, // 9710 + { PseudoVSUXSEG3EI64_V_M2_M1, VSUXSEG3EI64_V }, // 9711 + { PseudoVSUXSEG3EI64_V_M2_M1_MASK, VSUXSEG3EI64_V }, // 9712 + { PseudoVSUXSEG3EI64_V_M2_M2, VSUXSEG3EI64_V }, // 9713 + { PseudoVSUXSEG3EI64_V_M2_M2_MASK, VSUXSEG3EI64_V }, // 9714 + { PseudoVSUXSEG3EI64_V_M2_MF2, VSUXSEG3EI64_V }, // 9715 + { PseudoVSUXSEG3EI64_V_M2_MF2_MASK, VSUXSEG3EI64_V }, // 9716 + { PseudoVSUXSEG3EI64_V_M2_MF4, VSUXSEG3EI64_V }, // 9717 + { PseudoVSUXSEG3EI64_V_M2_MF4_MASK, VSUXSEG3EI64_V }, // 9718 + { PseudoVSUXSEG3EI64_V_M4_M1, VSUXSEG3EI64_V }, // 9719 + { PseudoVSUXSEG3EI64_V_M4_M1_MASK, VSUXSEG3EI64_V }, // 9720 + { PseudoVSUXSEG3EI64_V_M4_M2, VSUXSEG3EI64_V }, // 9721 + { PseudoVSUXSEG3EI64_V_M4_M2_MASK, VSUXSEG3EI64_V }, // 9722 + { PseudoVSUXSEG3EI64_V_M4_MF2, VSUXSEG3EI64_V }, // 9723 + { PseudoVSUXSEG3EI64_V_M4_MF2_MASK, VSUXSEG3EI64_V }, // 9724 + { PseudoVSUXSEG3EI64_V_M8_M1, VSUXSEG3EI64_V }, // 9725 + { PseudoVSUXSEG3EI64_V_M8_M1_MASK, VSUXSEG3EI64_V }, // 9726 + { PseudoVSUXSEG3EI64_V_M8_M2, VSUXSEG3EI64_V }, // 9727 + { PseudoVSUXSEG3EI64_V_M8_M2_MASK, VSUXSEG3EI64_V }, // 9728 + { PseudoVSUXSEG3EI8_V_M1_M1, VSUXSEG3EI8_V }, // 9729 + { PseudoVSUXSEG3EI8_V_M1_M1_MASK, VSUXSEG3EI8_V }, // 9730 + { PseudoVSUXSEG3EI8_V_M1_M2, VSUXSEG3EI8_V }, // 9731 + { PseudoVSUXSEG3EI8_V_M1_M2_MASK, VSUXSEG3EI8_V }, // 9732 + { PseudoVSUXSEG3EI8_V_M2_M2, VSUXSEG3EI8_V }, // 9733 + { PseudoVSUXSEG3EI8_V_M2_M2_MASK, VSUXSEG3EI8_V }, // 9734 + { PseudoVSUXSEG3EI8_V_MF2_M1, VSUXSEG3EI8_V }, // 9735 + { PseudoVSUXSEG3EI8_V_MF2_M1_MASK, VSUXSEG3EI8_V }, // 9736 + { PseudoVSUXSEG3EI8_V_MF2_M2, VSUXSEG3EI8_V }, // 9737 + { PseudoVSUXSEG3EI8_V_MF2_M2_MASK, VSUXSEG3EI8_V }, // 9738 + { PseudoVSUXSEG3EI8_V_MF2_MF2, VSUXSEG3EI8_V }, // 9739 + { PseudoVSUXSEG3EI8_V_MF2_MF2_MASK, VSUXSEG3EI8_V }, // 9740 + { PseudoVSUXSEG3EI8_V_MF4_M1, VSUXSEG3EI8_V }, // 9741 + { PseudoVSUXSEG3EI8_V_MF4_M1_MASK, VSUXSEG3EI8_V }, // 9742 + { PseudoVSUXSEG3EI8_V_MF4_M2, VSUXSEG3EI8_V }, // 9743 + { PseudoVSUXSEG3EI8_V_MF4_M2_MASK, VSUXSEG3EI8_V }, // 9744 + { PseudoVSUXSEG3EI8_V_MF4_MF2, VSUXSEG3EI8_V }, // 9745 + { PseudoVSUXSEG3EI8_V_MF4_MF2_MASK, VSUXSEG3EI8_V }, // 9746 + { PseudoVSUXSEG3EI8_V_MF4_MF4, VSUXSEG3EI8_V }, // 9747 + { PseudoVSUXSEG3EI8_V_MF4_MF4_MASK, VSUXSEG3EI8_V }, // 9748 + { PseudoVSUXSEG3EI8_V_MF8_M1, VSUXSEG3EI8_V }, // 9749 + { PseudoVSUXSEG3EI8_V_MF8_M1_MASK, VSUXSEG3EI8_V }, // 9750 + { PseudoVSUXSEG3EI8_V_MF8_MF2, VSUXSEG3EI8_V }, // 9751 + { PseudoVSUXSEG3EI8_V_MF8_MF2_MASK, VSUXSEG3EI8_V }, // 9752 + { PseudoVSUXSEG3EI8_V_MF8_MF4, VSUXSEG3EI8_V }, // 9753 + { PseudoVSUXSEG3EI8_V_MF8_MF4_MASK, VSUXSEG3EI8_V }, // 9754 + { PseudoVSUXSEG3EI8_V_MF8_MF8, VSUXSEG3EI8_V }, // 9755 + { PseudoVSUXSEG3EI8_V_MF8_MF8_MASK, VSUXSEG3EI8_V }, // 9756 + { PseudoVSUXSEG4EI16_V_M1_M1, VSUXSEG4EI16_V }, // 9757 + { PseudoVSUXSEG4EI16_V_M1_M1_MASK, VSUXSEG4EI16_V }, // 9758 + { PseudoVSUXSEG4EI16_V_M1_M2, VSUXSEG4EI16_V }, // 9759 + { PseudoVSUXSEG4EI16_V_M1_M2_MASK, VSUXSEG4EI16_V }, // 9760 + { PseudoVSUXSEG4EI16_V_M1_MF2, VSUXSEG4EI16_V }, // 9761 + { PseudoVSUXSEG4EI16_V_M1_MF2_MASK, VSUXSEG4EI16_V }, // 9762 + { PseudoVSUXSEG4EI16_V_M2_M1, VSUXSEG4EI16_V }, // 9763 + { PseudoVSUXSEG4EI16_V_M2_M1_MASK, VSUXSEG4EI16_V }, // 9764 + { PseudoVSUXSEG4EI16_V_M2_M2, VSUXSEG4EI16_V }, // 9765 + { PseudoVSUXSEG4EI16_V_M2_M2_MASK, VSUXSEG4EI16_V }, // 9766 + { PseudoVSUXSEG4EI16_V_M4_M2, VSUXSEG4EI16_V }, // 9767 + { PseudoVSUXSEG4EI16_V_M4_M2_MASK, VSUXSEG4EI16_V }, // 9768 + { PseudoVSUXSEG4EI16_V_MF2_M1, VSUXSEG4EI16_V }, // 9769 + { PseudoVSUXSEG4EI16_V_MF2_M1_MASK, VSUXSEG4EI16_V }, // 9770 + { PseudoVSUXSEG4EI16_V_MF2_M2, VSUXSEG4EI16_V }, // 9771 + { PseudoVSUXSEG4EI16_V_MF2_M2_MASK, VSUXSEG4EI16_V }, // 9772 + { PseudoVSUXSEG4EI16_V_MF2_MF2, VSUXSEG4EI16_V }, // 9773 + { PseudoVSUXSEG4EI16_V_MF2_MF2_MASK, VSUXSEG4EI16_V }, // 9774 + { PseudoVSUXSEG4EI16_V_MF2_MF4, VSUXSEG4EI16_V }, // 9775 + { PseudoVSUXSEG4EI16_V_MF2_MF4_MASK, VSUXSEG4EI16_V }, // 9776 + { PseudoVSUXSEG4EI16_V_MF4_M1, VSUXSEG4EI16_V }, // 9777 + { PseudoVSUXSEG4EI16_V_MF4_M1_MASK, VSUXSEG4EI16_V }, // 9778 + { PseudoVSUXSEG4EI16_V_MF4_MF2, VSUXSEG4EI16_V }, // 9779 + { PseudoVSUXSEG4EI16_V_MF4_MF2_MASK, VSUXSEG4EI16_V }, // 9780 + { PseudoVSUXSEG4EI16_V_MF4_MF4, VSUXSEG4EI16_V }, // 9781 + { PseudoVSUXSEG4EI16_V_MF4_MF4_MASK, VSUXSEG4EI16_V }, // 9782 + { PseudoVSUXSEG4EI16_V_MF4_MF8, VSUXSEG4EI16_V }, // 9783 + { PseudoVSUXSEG4EI16_V_MF4_MF8_MASK, VSUXSEG4EI16_V }, // 9784 + { PseudoVSUXSEG4EI32_V_M1_M1, VSUXSEG4EI32_V }, // 9785 + { PseudoVSUXSEG4EI32_V_M1_M1_MASK, VSUXSEG4EI32_V }, // 9786 + { PseudoVSUXSEG4EI32_V_M1_M2, VSUXSEG4EI32_V }, // 9787 + { PseudoVSUXSEG4EI32_V_M1_M2_MASK, VSUXSEG4EI32_V }, // 9788 + { PseudoVSUXSEG4EI32_V_M1_MF2, VSUXSEG4EI32_V }, // 9789 + { PseudoVSUXSEG4EI32_V_M1_MF2_MASK, VSUXSEG4EI32_V }, // 9790 + { PseudoVSUXSEG4EI32_V_M1_MF4, VSUXSEG4EI32_V }, // 9791 + { PseudoVSUXSEG4EI32_V_M1_MF4_MASK, VSUXSEG4EI32_V }, // 9792 + { PseudoVSUXSEG4EI32_V_M2_M1, VSUXSEG4EI32_V }, // 9793 + { PseudoVSUXSEG4EI32_V_M2_M1_MASK, VSUXSEG4EI32_V }, // 9794 + { PseudoVSUXSEG4EI32_V_M2_M2, VSUXSEG4EI32_V }, // 9795 + { PseudoVSUXSEG4EI32_V_M2_M2_MASK, VSUXSEG4EI32_V }, // 9796 + { PseudoVSUXSEG4EI32_V_M2_MF2, VSUXSEG4EI32_V }, // 9797 + { PseudoVSUXSEG4EI32_V_M2_MF2_MASK, VSUXSEG4EI32_V }, // 9798 + { PseudoVSUXSEG4EI32_V_M4_M1, VSUXSEG4EI32_V }, // 9799 + { PseudoVSUXSEG4EI32_V_M4_M1_MASK, VSUXSEG4EI32_V }, // 9800 + { PseudoVSUXSEG4EI32_V_M4_M2, VSUXSEG4EI32_V }, // 9801 + { PseudoVSUXSEG4EI32_V_M4_M2_MASK, VSUXSEG4EI32_V }, // 9802 + { PseudoVSUXSEG4EI32_V_M8_M2, VSUXSEG4EI32_V }, // 9803 + { PseudoVSUXSEG4EI32_V_M8_M2_MASK, VSUXSEG4EI32_V }, // 9804 + { PseudoVSUXSEG4EI32_V_MF2_M1, VSUXSEG4EI32_V }, // 9805 + { PseudoVSUXSEG4EI32_V_MF2_M1_MASK, VSUXSEG4EI32_V }, // 9806 + { PseudoVSUXSEG4EI32_V_MF2_MF2, VSUXSEG4EI32_V }, // 9807 + { PseudoVSUXSEG4EI32_V_MF2_MF2_MASK, VSUXSEG4EI32_V }, // 9808 + { PseudoVSUXSEG4EI32_V_MF2_MF4, VSUXSEG4EI32_V }, // 9809 + { PseudoVSUXSEG4EI32_V_MF2_MF4_MASK, VSUXSEG4EI32_V }, // 9810 + { PseudoVSUXSEG4EI32_V_MF2_MF8, VSUXSEG4EI32_V }, // 9811 + { PseudoVSUXSEG4EI32_V_MF2_MF8_MASK, VSUXSEG4EI32_V }, // 9812 + { PseudoVSUXSEG4EI64_V_M1_M1, VSUXSEG4EI64_V }, // 9813 + { PseudoVSUXSEG4EI64_V_M1_M1_MASK, VSUXSEG4EI64_V }, // 9814 + { PseudoVSUXSEG4EI64_V_M1_MF2, VSUXSEG4EI64_V }, // 9815 + { PseudoVSUXSEG4EI64_V_M1_MF2_MASK, VSUXSEG4EI64_V }, // 9816 + { PseudoVSUXSEG4EI64_V_M1_MF4, VSUXSEG4EI64_V }, // 9817 + { PseudoVSUXSEG4EI64_V_M1_MF4_MASK, VSUXSEG4EI64_V }, // 9818 + { PseudoVSUXSEG4EI64_V_M1_MF8, VSUXSEG4EI64_V }, // 9819 + { PseudoVSUXSEG4EI64_V_M1_MF8_MASK, VSUXSEG4EI64_V }, // 9820 + { PseudoVSUXSEG4EI64_V_M2_M1, VSUXSEG4EI64_V }, // 9821 + { PseudoVSUXSEG4EI64_V_M2_M1_MASK, VSUXSEG4EI64_V }, // 9822 + { PseudoVSUXSEG4EI64_V_M2_M2, VSUXSEG4EI64_V }, // 9823 + { PseudoVSUXSEG4EI64_V_M2_M2_MASK, VSUXSEG4EI64_V }, // 9824 + { PseudoVSUXSEG4EI64_V_M2_MF2, VSUXSEG4EI64_V }, // 9825 + { PseudoVSUXSEG4EI64_V_M2_MF2_MASK, VSUXSEG4EI64_V }, // 9826 + { PseudoVSUXSEG4EI64_V_M2_MF4, VSUXSEG4EI64_V }, // 9827 + { PseudoVSUXSEG4EI64_V_M2_MF4_MASK, VSUXSEG4EI64_V }, // 9828 + { PseudoVSUXSEG4EI64_V_M4_M1, VSUXSEG4EI64_V }, // 9829 + { PseudoVSUXSEG4EI64_V_M4_M1_MASK, VSUXSEG4EI64_V }, // 9830 + { PseudoVSUXSEG4EI64_V_M4_M2, VSUXSEG4EI64_V }, // 9831 + { PseudoVSUXSEG4EI64_V_M4_M2_MASK, VSUXSEG4EI64_V }, // 9832 + { PseudoVSUXSEG4EI64_V_M4_MF2, VSUXSEG4EI64_V }, // 9833 + { PseudoVSUXSEG4EI64_V_M4_MF2_MASK, VSUXSEG4EI64_V }, // 9834 + { PseudoVSUXSEG4EI64_V_M8_M1, VSUXSEG4EI64_V }, // 9835 + { PseudoVSUXSEG4EI64_V_M8_M1_MASK, VSUXSEG4EI64_V }, // 9836 + { PseudoVSUXSEG4EI64_V_M8_M2, VSUXSEG4EI64_V }, // 9837 + { PseudoVSUXSEG4EI64_V_M8_M2_MASK, VSUXSEG4EI64_V }, // 9838 + { PseudoVSUXSEG4EI8_V_M1_M1, VSUXSEG4EI8_V }, // 9839 + { PseudoVSUXSEG4EI8_V_M1_M1_MASK, VSUXSEG4EI8_V }, // 9840 + { PseudoVSUXSEG4EI8_V_M1_M2, VSUXSEG4EI8_V }, // 9841 + { PseudoVSUXSEG4EI8_V_M1_M2_MASK, VSUXSEG4EI8_V }, // 9842 + { PseudoVSUXSEG4EI8_V_M2_M2, VSUXSEG4EI8_V }, // 9843 + { PseudoVSUXSEG4EI8_V_M2_M2_MASK, VSUXSEG4EI8_V }, // 9844 + { PseudoVSUXSEG4EI8_V_MF2_M1, VSUXSEG4EI8_V }, // 9845 + { PseudoVSUXSEG4EI8_V_MF2_M1_MASK, VSUXSEG4EI8_V }, // 9846 + { PseudoVSUXSEG4EI8_V_MF2_M2, VSUXSEG4EI8_V }, // 9847 + { PseudoVSUXSEG4EI8_V_MF2_M2_MASK, VSUXSEG4EI8_V }, // 9848 + { PseudoVSUXSEG4EI8_V_MF2_MF2, VSUXSEG4EI8_V }, // 9849 + { PseudoVSUXSEG4EI8_V_MF2_MF2_MASK, VSUXSEG4EI8_V }, // 9850 + { PseudoVSUXSEG4EI8_V_MF4_M1, VSUXSEG4EI8_V }, // 9851 + { PseudoVSUXSEG4EI8_V_MF4_M1_MASK, VSUXSEG4EI8_V }, // 9852 + { PseudoVSUXSEG4EI8_V_MF4_M2, VSUXSEG4EI8_V }, // 9853 + { PseudoVSUXSEG4EI8_V_MF4_M2_MASK, VSUXSEG4EI8_V }, // 9854 + { PseudoVSUXSEG4EI8_V_MF4_MF2, VSUXSEG4EI8_V }, // 9855 + { PseudoVSUXSEG4EI8_V_MF4_MF2_MASK, VSUXSEG4EI8_V }, // 9856 + { PseudoVSUXSEG4EI8_V_MF4_MF4, VSUXSEG4EI8_V }, // 9857 + { PseudoVSUXSEG4EI8_V_MF4_MF4_MASK, VSUXSEG4EI8_V }, // 9858 + { PseudoVSUXSEG4EI8_V_MF8_M1, VSUXSEG4EI8_V }, // 9859 + { PseudoVSUXSEG4EI8_V_MF8_M1_MASK, VSUXSEG4EI8_V }, // 9860 + { PseudoVSUXSEG4EI8_V_MF8_MF2, VSUXSEG4EI8_V }, // 9861 + { PseudoVSUXSEG4EI8_V_MF8_MF2_MASK, VSUXSEG4EI8_V }, // 9862 + { PseudoVSUXSEG4EI8_V_MF8_MF4, VSUXSEG4EI8_V }, // 9863 + { PseudoVSUXSEG4EI8_V_MF8_MF4_MASK, VSUXSEG4EI8_V }, // 9864 + { PseudoVSUXSEG4EI8_V_MF8_MF8, VSUXSEG4EI8_V }, // 9865 + { PseudoVSUXSEG4EI8_V_MF8_MF8_MASK, VSUXSEG4EI8_V }, // 9866 + { PseudoVSUXSEG5EI16_V_M1_M1, VSUXSEG5EI16_V }, // 9867 + { PseudoVSUXSEG5EI16_V_M1_M1_MASK, VSUXSEG5EI16_V }, // 9868 + { PseudoVSUXSEG5EI16_V_M1_MF2, VSUXSEG5EI16_V }, // 9869 + { PseudoVSUXSEG5EI16_V_M1_MF2_MASK, VSUXSEG5EI16_V }, // 9870 + { PseudoVSUXSEG5EI16_V_M2_M1, VSUXSEG5EI16_V }, // 9871 + { PseudoVSUXSEG5EI16_V_M2_M1_MASK, VSUXSEG5EI16_V }, // 9872 + { PseudoVSUXSEG5EI16_V_MF2_M1, VSUXSEG5EI16_V }, // 9873 + { PseudoVSUXSEG5EI16_V_MF2_M1_MASK, VSUXSEG5EI16_V }, // 9874 + { PseudoVSUXSEG5EI16_V_MF2_MF2, VSUXSEG5EI16_V }, // 9875 + { PseudoVSUXSEG5EI16_V_MF2_MF2_MASK, VSUXSEG5EI16_V }, // 9876 + { PseudoVSUXSEG5EI16_V_MF2_MF4, VSUXSEG5EI16_V }, // 9877 + { PseudoVSUXSEG5EI16_V_MF2_MF4_MASK, VSUXSEG5EI16_V }, // 9878 + { PseudoVSUXSEG5EI16_V_MF4_M1, VSUXSEG5EI16_V }, // 9879 + { PseudoVSUXSEG5EI16_V_MF4_M1_MASK, VSUXSEG5EI16_V }, // 9880 + { PseudoVSUXSEG5EI16_V_MF4_MF2, VSUXSEG5EI16_V }, // 9881 + { PseudoVSUXSEG5EI16_V_MF4_MF2_MASK, VSUXSEG5EI16_V }, // 9882 + { PseudoVSUXSEG5EI16_V_MF4_MF4, VSUXSEG5EI16_V }, // 9883 + { PseudoVSUXSEG5EI16_V_MF4_MF4_MASK, VSUXSEG5EI16_V }, // 9884 + { PseudoVSUXSEG5EI16_V_MF4_MF8, VSUXSEG5EI16_V }, // 9885 + { PseudoVSUXSEG5EI16_V_MF4_MF8_MASK, VSUXSEG5EI16_V }, // 9886 + { PseudoVSUXSEG5EI32_V_M1_M1, VSUXSEG5EI32_V }, // 9887 + { PseudoVSUXSEG5EI32_V_M1_M1_MASK, VSUXSEG5EI32_V }, // 9888 + { PseudoVSUXSEG5EI32_V_M1_MF2, VSUXSEG5EI32_V }, // 9889 + { PseudoVSUXSEG5EI32_V_M1_MF2_MASK, VSUXSEG5EI32_V }, // 9890 + { PseudoVSUXSEG5EI32_V_M1_MF4, VSUXSEG5EI32_V }, // 9891 + { PseudoVSUXSEG5EI32_V_M1_MF4_MASK, VSUXSEG5EI32_V }, // 9892 + { PseudoVSUXSEG5EI32_V_M2_M1, VSUXSEG5EI32_V }, // 9893 + { PseudoVSUXSEG5EI32_V_M2_M1_MASK, VSUXSEG5EI32_V }, // 9894 + { PseudoVSUXSEG5EI32_V_M2_MF2, VSUXSEG5EI32_V }, // 9895 + { PseudoVSUXSEG5EI32_V_M2_MF2_MASK, VSUXSEG5EI32_V }, // 9896 + { PseudoVSUXSEG5EI32_V_M4_M1, VSUXSEG5EI32_V }, // 9897 + { PseudoVSUXSEG5EI32_V_M4_M1_MASK, VSUXSEG5EI32_V }, // 9898 + { PseudoVSUXSEG5EI32_V_MF2_M1, VSUXSEG5EI32_V }, // 9899 + { PseudoVSUXSEG5EI32_V_MF2_M1_MASK, VSUXSEG5EI32_V }, // 9900 + { PseudoVSUXSEG5EI32_V_MF2_MF2, VSUXSEG5EI32_V }, // 9901 + { PseudoVSUXSEG5EI32_V_MF2_MF2_MASK, VSUXSEG5EI32_V }, // 9902 + { PseudoVSUXSEG5EI32_V_MF2_MF4, VSUXSEG5EI32_V }, // 9903 + { PseudoVSUXSEG5EI32_V_MF2_MF4_MASK, VSUXSEG5EI32_V }, // 9904 + { PseudoVSUXSEG5EI32_V_MF2_MF8, VSUXSEG5EI32_V }, // 9905 + { PseudoVSUXSEG5EI32_V_MF2_MF8_MASK, VSUXSEG5EI32_V }, // 9906 + { PseudoVSUXSEG5EI64_V_M1_M1, VSUXSEG5EI64_V }, // 9907 + { PseudoVSUXSEG5EI64_V_M1_M1_MASK, VSUXSEG5EI64_V }, // 9908 + { PseudoVSUXSEG5EI64_V_M1_MF2, VSUXSEG5EI64_V }, // 9909 + { PseudoVSUXSEG5EI64_V_M1_MF2_MASK, VSUXSEG5EI64_V }, // 9910 + { PseudoVSUXSEG5EI64_V_M1_MF4, VSUXSEG5EI64_V }, // 9911 + { PseudoVSUXSEG5EI64_V_M1_MF4_MASK, VSUXSEG5EI64_V }, // 9912 + { PseudoVSUXSEG5EI64_V_M1_MF8, VSUXSEG5EI64_V }, // 9913 + { PseudoVSUXSEG5EI64_V_M1_MF8_MASK, VSUXSEG5EI64_V }, // 9914 + { PseudoVSUXSEG5EI64_V_M2_M1, VSUXSEG5EI64_V }, // 9915 + { PseudoVSUXSEG5EI64_V_M2_M1_MASK, VSUXSEG5EI64_V }, // 9916 + { PseudoVSUXSEG5EI64_V_M2_MF2, VSUXSEG5EI64_V }, // 9917 + { PseudoVSUXSEG5EI64_V_M2_MF2_MASK, VSUXSEG5EI64_V }, // 9918 + { PseudoVSUXSEG5EI64_V_M2_MF4, VSUXSEG5EI64_V }, // 9919 + { PseudoVSUXSEG5EI64_V_M2_MF4_MASK, VSUXSEG5EI64_V }, // 9920 + { PseudoVSUXSEG5EI64_V_M4_M1, VSUXSEG5EI64_V }, // 9921 + { PseudoVSUXSEG5EI64_V_M4_M1_MASK, VSUXSEG5EI64_V }, // 9922 + { PseudoVSUXSEG5EI64_V_M4_MF2, VSUXSEG5EI64_V }, // 9923 + { PseudoVSUXSEG5EI64_V_M4_MF2_MASK, VSUXSEG5EI64_V }, // 9924 + { PseudoVSUXSEG5EI64_V_M8_M1, VSUXSEG5EI64_V }, // 9925 + { PseudoVSUXSEG5EI64_V_M8_M1_MASK, VSUXSEG5EI64_V }, // 9926 + { PseudoVSUXSEG5EI8_V_M1_M1, VSUXSEG5EI8_V }, // 9927 + { PseudoVSUXSEG5EI8_V_M1_M1_MASK, VSUXSEG5EI8_V }, // 9928 + { PseudoVSUXSEG5EI8_V_MF2_M1, VSUXSEG5EI8_V }, // 9929 + { PseudoVSUXSEG5EI8_V_MF2_M1_MASK, VSUXSEG5EI8_V }, // 9930 + { PseudoVSUXSEG5EI8_V_MF2_MF2, VSUXSEG5EI8_V }, // 9931 + { PseudoVSUXSEG5EI8_V_MF2_MF2_MASK, VSUXSEG5EI8_V }, // 9932 + { PseudoVSUXSEG5EI8_V_MF4_M1, VSUXSEG5EI8_V }, // 9933 + { PseudoVSUXSEG5EI8_V_MF4_M1_MASK, VSUXSEG5EI8_V }, // 9934 + { PseudoVSUXSEG5EI8_V_MF4_MF2, VSUXSEG5EI8_V }, // 9935 + { PseudoVSUXSEG5EI8_V_MF4_MF2_MASK, VSUXSEG5EI8_V }, // 9936 + { PseudoVSUXSEG5EI8_V_MF4_MF4, VSUXSEG5EI8_V }, // 9937 + { PseudoVSUXSEG5EI8_V_MF4_MF4_MASK, VSUXSEG5EI8_V }, // 9938 + { PseudoVSUXSEG5EI8_V_MF8_M1, VSUXSEG5EI8_V }, // 9939 + { PseudoVSUXSEG5EI8_V_MF8_M1_MASK, VSUXSEG5EI8_V }, // 9940 + { PseudoVSUXSEG5EI8_V_MF8_MF2, VSUXSEG5EI8_V }, // 9941 + { PseudoVSUXSEG5EI8_V_MF8_MF2_MASK, VSUXSEG5EI8_V }, // 9942 + { PseudoVSUXSEG5EI8_V_MF8_MF4, VSUXSEG5EI8_V }, // 9943 + { PseudoVSUXSEG5EI8_V_MF8_MF4_MASK, VSUXSEG5EI8_V }, // 9944 + { PseudoVSUXSEG5EI8_V_MF8_MF8, VSUXSEG5EI8_V }, // 9945 + { PseudoVSUXSEG5EI8_V_MF8_MF8_MASK, VSUXSEG5EI8_V }, // 9946 + { PseudoVSUXSEG6EI16_V_M1_M1, VSUXSEG6EI16_V }, // 9947 + { PseudoVSUXSEG6EI16_V_M1_M1_MASK, VSUXSEG6EI16_V }, // 9948 + { PseudoVSUXSEG6EI16_V_M1_MF2, VSUXSEG6EI16_V }, // 9949 + { PseudoVSUXSEG6EI16_V_M1_MF2_MASK, VSUXSEG6EI16_V }, // 9950 + { PseudoVSUXSEG6EI16_V_M2_M1, VSUXSEG6EI16_V }, // 9951 + { PseudoVSUXSEG6EI16_V_M2_M1_MASK, VSUXSEG6EI16_V }, // 9952 + { PseudoVSUXSEG6EI16_V_MF2_M1, VSUXSEG6EI16_V }, // 9953 + { PseudoVSUXSEG6EI16_V_MF2_M1_MASK, VSUXSEG6EI16_V }, // 9954 + { PseudoVSUXSEG6EI16_V_MF2_MF2, VSUXSEG6EI16_V }, // 9955 + { PseudoVSUXSEG6EI16_V_MF2_MF2_MASK, VSUXSEG6EI16_V }, // 9956 + { PseudoVSUXSEG6EI16_V_MF2_MF4, VSUXSEG6EI16_V }, // 9957 + { PseudoVSUXSEG6EI16_V_MF2_MF4_MASK, VSUXSEG6EI16_V }, // 9958 + { PseudoVSUXSEG6EI16_V_MF4_M1, VSUXSEG6EI16_V }, // 9959 + { PseudoVSUXSEG6EI16_V_MF4_M1_MASK, VSUXSEG6EI16_V }, // 9960 + { PseudoVSUXSEG6EI16_V_MF4_MF2, VSUXSEG6EI16_V }, // 9961 + { PseudoVSUXSEG6EI16_V_MF4_MF2_MASK, VSUXSEG6EI16_V }, // 9962 + { PseudoVSUXSEG6EI16_V_MF4_MF4, VSUXSEG6EI16_V }, // 9963 + { PseudoVSUXSEG6EI16_V_MF4_MF4_MASK, VSUXSEG6EI16_V }, // 9964 + { PseudoVSUXSEG6EI16_V_MF4_MF8, VSUXSEG6EI16_V }, // 9965 + { PseudoVSUXSEG6EI16_V_MF4_MF8_MASK, VSUXSEG6EI16_V }, // 9966 + { PseudoVSUXSEG6EI32_V_M1_M1, VSUXSEG6EI32_V }, // 9967 + { PseudoVSUXSEG6EI32_V_M1_M1_MASK, VSUXSEG6EI32_V }, // 9968 + { PseudoVSUXSEG6EI32_V_M1_MF2, VSUXSEG6EI32_V }, // 9969 + { PseudoVSUXSEG6EI32_V_M1_MF2_MASK, VSUXSEG6EI32_V }, // 9970 + { PseudoVSUXSEG6EI32_V_M1_MF4, VSUXSEG6EI32_V }, // 9971 + { PseudoVSUXSEG6EI32_V_M1_MF4_MASK, VSUXSEG6EI32_V }, // 9972 + { PseudoVSUXSEG6EI32_V_M2_M1, VSUXSEG6EI32_V }, // 9973 + { PseudoVSUXSEG6EI32_V_M2_M1_MASK, VSUXSEG6EI32_V }, // 9974 + { PseudoVSUXSEG6EI32_V_M2_MF2, VSUXSEG6EI32_V }, // 9975 + { PseudoVSUXSEG6EI32_V_M2_MF2_MASK, VSUXSEG6EI32_V }, // 9976 + { PseudoVSUXSEG6EI32_V_M4_M1, VSUXSEG6EI32_V }, // 9977 + { PseudoVSUXSEG6EI32_V_M4_M1_MASK, VSUXSEG6EI32_V }, // 9978 + { PseudoVSUXSEG6EI32_V_MF2_M1, VSUXSEG6EI32_V }, // 9979 + { PseudoVSUXSEG6EI32_V_MF2_M1_MASK, VSUXSEG6EI32_V }, // 9980 + { PseudoVSUXSEG6EI32_V_MF2_MF2, VSUXSEG6EI32_V }, // 9981 + { PseudoVSUXSEG6EI32_V_MF2_MF2_MASK, VSUXSEG6EI32_V }, // 9982 + { PseudoVSUXSEG6EI32_V_MF2_MF4, VSUXSEG6EI32_V }, // 9983 + { PseudoVSUXSEG6EI32_V_MF2_MF4_MASK, VSUXSEG6EI32_V }, // 9984 + { PseudoVSUXSEG6EI32_V_MF2_MF8, VSUXSEG6EI32_V }, // 9985 + { PseudoVSUXSEG6EI32_V_MF2_MF8_MASK, VSUXSEG6EI32_V }, // 9986 + { PseudoVSUXSEG6EI64_V_M1_M1, VSUXSEG6EI64_V }, // 9987 + { PseudoVSUXSEG6EI64_V_M1_M1_MASK, VSUXSEG6EI64_V }, // 9988 + { PseudoVSUXSEG6EI64_V_M1_MF2, VSUXSEG6EI64_V }, // 9989 + { PseudoVSUXSEG6EI64_V_M1_MF2_MASK, VSUXSEG6EI64_V }, // 9990 + { PseudoVSUXSEG6EI64_V_M1_MF4, VSUXSEG6EI64_V }, // 9991 + { PseudoVSUXSEG6EI64_V_M1_MF4_MASK, VSUXSEG6EI64_V }, // 9992 + { PseudoVSUXSEG6EI64_V_M1_MF8, VSUXSEG6EI64_V }, // 9993 + { PseudoVSUXSEG6EI64_V_M1_MF8_MASK, VSUXSEG6EI64_V }, // 9994 + { PseudoVSUXSEG6EI64_V_M2_M1, VSUXSEG6EI64_V }, // 9995 + { PseudoVSUXSEG6EI64_V_M2_M1_MASK, VSUXSEG6EI64_V }, // 9996 + { PseudoVSUXSEG6EI64_V_M2_MF2, VSUXSEG6EI64_V }, // 9997 + { PseudoVSUXSEG6EI64_V_M2_MF2_MASK, VSUXSEG6EI64_V }, // 9998 + { PseudoVSUXSEG6EI64_V_M2_MF4, VSUXSEG6EI64_V }, // 9999 + { PseudoVSUXSEG6EI64_V_M2_MF4_MASK, VSUXSEG6EI64_V }, // 10000 + { PseudoVSUXSEG6EI64_V_M4_M1, VSUXSEG6EI64_V }, // 10001 + { PseudoVSUXSEG6EI64_V_M4_M1_MASK, VSUXSEG6EI64_V }, // 10002 + { PseudoVSUXSEG6EI64_V_M4_MF2, VSUXSEG6EI64_V }, // 10003 + { PseudoVSUXSEG6EI64_V_M4_MF2_MASK, VSUXSEG6EI64_V }, // 10004 + { PseudoVSUXSEG6EI64_V_M8_M1, VSUXSEG6EI64_V }, // 10005 + { PseudoVSUXSEG6EI64_V_M8_M1_MASK, VSUXSEG6EI64_V }, // 10006 + { PseudoVSUXSEG6EI8_V_M1_M1, VSUXSEG6EI8_V }, // 10007 + { PseudoVSUXSEG6EI8_V_M1_M1_MASK, VSUXSEG6EI8_V }, // 10008 + { PseudoVSUXSEG6EI8_V_MF2_M1, VSUXSEG6EI8_V }, // 10009 + { PseudoVSUXSEG6EI8_V_MF2_M1_MASK, VSUXSEG6EI8_V }, // 10010 + { PseudoVSUXSEG6EI8_V_MF2_MF2, VSUXSEG6EI8_V }, // 10011 + { PseudoVSUXSEG6EI8_V_MF2_MF2_MASK, VSUXSEG6EI8_V }, // 10012 + { PseudoVSUXSEG6EI8_V_MF4_M1, VSUXSEG6EI8_V }, // 10013 + { PseudoVSUXSEG6EI8_V_MF4_M1_MASK, VSUXSEG6EI8_V }, // 10014 + { PseudoVSUXSEG6EI8_V_MF4_MF2, VSUXSEG6EI8_V }, // 10015 + { PseudoVSUXSEG6EI8_V_MF4_MF2_MASK, VSUXSEG6EI8_V }, // 10016 + { PseudoVSUXSEG6EI8_V_MF4_MF4, VSUXSEG6EI8_V }, // 10017 + { PseudoVSUXSEG6EI8_V_MF4_MF4_MASK, VSUXSEG6EI8_V }, // 10018 + { PseudoVSUXSEG6EI8_V_MF8_M1, VSUXSEG6EI8_V }, // 10019 + { PseudoVSUXSEG6EI8_V_MF8_M1_MASK, VSUXSEG6EI8_V }, // 10020 + { PseudoVSUXSEG6EI8_V_MF8_MF2, VSUXSEG6EI8_V }, // 10021 + { PseudoVSUXSEG6EI8_V_MF8_MF2_MASK, VSUXSEG6EI8_V }, // 10022 + { PseudoVSUXSEG6EI8_V_MF8_MF4, VSUXSEG6EI8_V }, // 10023 + { PseudoVSUXSEG6EI8_V_MF8_MF4_MASK, VSUXSEG6EI8_V }, // 10024 + { PseudoVSUXSEG6EI8_V_MF8_MF8, VSUXSEG6EI8_V }, // 10025 + { PseudoVSUXSEG6EI8_V_MF8_MF8_MASK, VSUXSEG6EI8_V }, // 10026 + { PseudoVSUXSEG7EI16_V_M1_M1, VSUXSEG7EI16_V }, // 10027 + { PseudoVSUXSEG7EI16_V_M1_M1_MASK, VSUXSEG7EI16_V }, // 10028 + { PseudoVSUXSEG7EI16_V_M1_MF2, VSUXSEG7EI16_V }, // 10029 + { PseudoVSUXSEG7EI16_V_M1_MF2_MASK, VSUXSEG7EI16_V }, // 10030 + { PseudoVSUXSEG7EI16_V_M2_M1, VSUXSEG7EI16_V }, // 10031 + { PseudoVSUXSEG7EI16_V_M2_M1_MASK, VSUXSEG7EI16_V }, // 10032 + { PseudoVSUXSEG7EI16_V_MF2_M1, VSUXSEG7EI16_V }, // 10033 + { PseudoVSUXSEG7EI16_V_MF2_M1_MASK, VSUXSEG7EI16_V }, // 10034 + { PseudoVSUXSEG7EI16_V_MF2_MF2, VSUXSEG7EI16_V }, // 10035 + { PseudoVSUXSEG7EI16_V_MF2_MF2_MASK, VSUXSEG7EI16_V }, // 10036 + { PseudoVSUXSEG7EI16_V_MF2_MF4, VSUXSEG7EI16_V }, // 10037 + { PseudoVSUXSEG7EI16_V_MF2_MF4_MASK, VSUXSEG7EI16_V }, // 10038 + { PseudoVSUXSEG7EI16_V_MF4_M1, VSUXSEG7EI16_V }, // 10039 + { PseudoVSUXSEG7EI16_V_MF4_M1_MASK, VSUXSEG7EI16_V }, // 10040 + { PseudoVSUXSEG7EI16_V_MF4_MF2, VSUXSEG7EI16_V }, // 10041 + { PseudoVSUXSEG7EI16_V_MF4_MF2_MASK, VSUXSEG7EI16_V }, // 10042 + { PseudoVSUXSEG7EI16_V_MF4_MF4, VSUXSEG7EI16_V }, // 10043 + { PseudoVSUXSEG7EI16_V_MF4_MF4_MASK, VSUXSEG7EI16_V }, // 10044 + { PseudoVSUXSEG7EI16_V_MF4_MF8, VSUXSEG7EI16_V }, // 10045 + { PseudoVSUXSEG7EI16_V_MF4_MF8_MASK, VSUXSEG7EI16_V }, // 10046 + { PseudoVSUXSEG7EI32_V_M1_M1, VSUXSEG7EI32_V }, // 10047 + { PseudoVSUXSEG7EI32_V_M1_M1_MASK, VSUXSEG7EI32_V }, // 10048 + { PseudoVSUXSEG7EI32_V_M1_MF2, VSUXSEG7EI32_V }, // 10049 + { PseudoVSUXSEG7EI32_V_M1_MF2_MASK, VSUXSEG7EI32_V }, // 10050 + { PseudoVSUXSEG7EI32_V_M1_MF4, VSUXSEG7EI32_V }, // 10051 + { PseudoVSUXSEG7EI32_V_M1_MF4_MASK, VSUXSEG7EI32_V }, // 10052 + { PseudoVSUXSEG7EI32_V_M2_M1, VSUXSEG7EI32_V }, // 10053 + { PseudoVSUXSEG7EI32_V_M2_M1_MASK, VSUXSEG7EI32_V }, // 10054 + { PseudoVSUXSEG7EI32_V_M2_MF2, VSUXSEG7EI32_V }, // 10055 + { PseudoVSUXSEG7EI32_V_M2_MF2_MASK, VSUXSEG7EI32_V }, // 10056 + { PseudoVSUXSEG7EI32_V_M4_M1, VSUXSEG7EI32_V }, // 10057 + { PseudoVSUXSEG7EI32_V_M4_M1_MASK, VSUXSEG7EI32_V }, // 10058 + { PseudoVSUXSEG7EI32_V_MF2_M1, VSUXSEG7EI32_V }, // 10059 + { PseudoVSUXSEG7EI32_V_MF2_M1_MASK, VSUXSEG7EI32_V }, // 10060 + { PseudoVSUXSEG7EI32_V_MF2_MF2, VSUXSEG7EI32_V }, // 10061 + { PseudoVSUXSEG7EI32_V_MF2_MF2_MASK, VSUXSEG7EI32_V }, // 10062 + { PseudoVSUXSEG7EI32_V_MF2_MF4, VSUXSEG7EI32_V }, // 10063 + { PseudoVSUXSEG7EI32_V_MF2_MF4_MASK, VSUXSEG7EI32_V }, // 10064 + { PseudoVSUXSEG7EI32_V_MF2_MF8, VSUXSEG7EI32_V }, // 10065 + { PseudoVSUXSEG7EI32_V_MF2_MF8_MASK, VSUXSEG7EI32_V }, // 10066 + { PseudoVSUXSEG7EI64_V_M1_M1, VSUXSEG7EI64_V }, // 10067 + { PseudoVSUXSEG7EI64_V_M1_M1_MASK, VSUXSEG7EI64_V }, // 10068 + { PseudoVSUXSEG7EI64_V_M1_MF2, VSUXSEG7EI64_V }, // 10069 + { PseudoVSUXSEG7EI64_V_M1_MF2_MASK, VSUXSEG7EI64_V }, // 10070 + { PseudoVSUXSEG7EI64_V_M1_MF4, VSUXSEG7EI64_V }, // 10071 + { PseudoVSUXSEG7EI64_V_M1_MF4_MASK, VSUXSEG7EI64_V }, // 10072 + { PseudoVSUXSEG7EI64_V_M1_MF8, VSUXSEG7EI64_V }, // 10073 + { PseudoVSUXSEG7EI64_V_M1_MF8_MASK, VSUXSEG7EI64_V }, // 10074 + { PseudoVSUXSEG7EI64_V_M2_M1, VSUXSEG7EI64_V }, // 10075 + { PseudoVSUXSEG7EI64_V_M2_M1_MASK, VSUXSEG7EI64_V }, // 10076 + { PseudoVSUXSEG7EI64_V_M2_MF2, VSUXSEG7EI64_V }, // 10077 + { PseudoVSUXSEG7EI64_V_M2_MF2_MASK, VSUXSEG7EI64_V }, // 10078 + { PseudoVSUXSEG7EI64_V_M2_MF4, VSUXSEG7EI64_V }, // 10079 + { PseudoVSUXSEG7EI64_V_M2_MF4_MASK, VSUXSEG7EI64_V }, // 10080 + { PseudoVSUXSEG7EI64_V_M4_M1, VSUXSEG7EI64_V }, // 10081 + { PseudoVSUXSEG7EI64_V_M4_M1_MASK, VSUXSEG7EI64_V }, // 10082 + { PseudoVSUXSEG7EI64_V_M4_MF2, VSUXSEG7EI64_V }, // 10083 + { PseudoVSUXSEG7EI64_V_M4_MF2_MASK, VSUXSEG7EI64_V }, // 10084 + { PseudoVSUXSEG7EI64_V_M8_M1, VSUXSEG7EI64_V }, // 10085 + { PseudoVSUXSEG7EI64_V_M8_M1_MASK, VSUXSEG7EI64_V }, // 10086 + { PseudoVSUXSEG7EI8_V_M1_M1, VSUXSEG7EI8_V }, // 10087 + { PseudoVSUXSEG7EI8_V_M1_M1_MASK, VSUXSEG7EI8_V }, // 10088 + { PseudoVSUXSEG7EI8_V_MF2_M1, VSUXSEG7EI8_V }, // 10089 + { PseudoVSUXSEG7EI8_V_MF2_M1_MASK, VSUXSEG7EI8_V }, // 10090 + { PseudoVSUXSEG7EI8_V_MF2_MF2, VSUXSEG7EI8_V }, // 10091 + { PseudoVSUXSEG7EI8_V_MF2_MF2_MASK, VSUXSEG7EI8_V }, // 10092 + { PseudoVSUXSEG7EI8_V_MF4_M1, VSUXSEG7EI8_V }, // 10093 + { PseudoVSUXSEG7EI8_V_MF4_M1_MASK, VSUXSEG7EI8_V }, // 10094 + { PseudoVSUXSEG7EI8_V_MF4_MF2, VSUXSEG7EI8_V }, // 10095 + { PseudoVSUXSEG7EI8_V_MF4_MF2_MASK, VSUXSEG7EI8_V }, // 10096 + { PseudoVSUXSEG7EI8_V_MF4_MF4, VSUXSEG7EI8_V }, // 10097 + { PseudoVSUXSEG7EI8_V_MF4_MF4_MASK, VSUXSEG7EI8_V }, // 10098 + { PseudoVSUXSEG7EI8_V_MF8_M1, VSUXSEG7EI8_V }, // 10099 + { PseudoVSUXSEG7EI8_V_MF8_M1_MASK, VSUXSEG7EI8_V }, // 10100 + { PseudoVSUXSEG7EI8_V_MF8_MF2, VSUXSEG7EI8_V }, // 10101 + { PseudoVSUXSEG7EI8_V_MF8_MF2_MASK, VSUXSEG7EI8_V }, // 10102 + { PseudoVSUXSEG7EI8_V_MF8_MF4, VSUXSEG7EI8_V }, // 10103 + { PseudoVSUXSEG7EI8_V_MF8_MF4_MASK, VSUXSEG7EI8_V }, // 10104 + { PseudoVSUXSEG7EI8_V_MF8_MF8, VSUXSEG7EI8_V }, // 10105 + { PseudoVSUXSEG7EI8_V_MF8_MF8_MASK, VSUXSEG7EI8_V }, // 10106 + { PseudoVSUXSEG8EI16_V_M1_M1, VSUXSEG8EI16_V }, // 10107 + { PseudoVSUXSEG8EI16_V_M1_M1_MASK, VSUXSEG8EI16_V }, // 10108 + { PseudoVSUXSEG8EI16_V_M1_MF2, VSUXSEG8EI16_V }, // 10109 + { PseudoVSUXSEG8EI16_V_M1_MF2_MASK, VSUXSEG8EI16_V }, // 10110 + { PseudoVSUXSEG8EI16_V_M2_M1, VSUXSEG8EI16_V }, // 10111 + { PseudoVSUXSEG8EI16_V_M2_M1_MASK, VSUXSEG8EI16_V }, // 10112 + { PseudoVSUXSEG8EI16_V_MF2_M1, VSUXSEG8EI16_V }, // 10113 + { PseudoVSUXSEG8EI16_V_MF2_M1_MASK, VSUXSEG8EI16_V }, // 10114 + { PseudoVSUXSEG8EI16_V_MF2_MF2, VSUXSEG8EI16_V }, // 10115 + { PseudoVSUXSEG8EI16_V_MF2_MF2_MASK, VSUXSEG8EI16_V }, // 10116 + { PseudoVSUXSEG8EI16_V_MF2_MF4, VSUXSEG8EI16_V }, // 10117 + { PseudoVSUXSEG8EI16_V_MF2_MF4_MASK, VSUXSEG8EI16_V }, // 10118 + { PseudoVSUXSEG8EI16_V_MF4_M1, VSUXSEG8EI16_V }, // 10119 + { PseudoVSUXSEG8EI16_V_MF4_M1_MASK, VSUXSEG8EI16_V }, // 10120 + { PseudoVSUXSEG8EI16_V_MF4_MF2, VSUXSEG8EI16_V }, // 10121 + { PseudoVSUXSEG8EI16_V_MF4_MF2_MASK, VSUXSEG8EI16_V }, // 10122 + { PseudoVSUXSEG8EI16_V_MF4_MF4, VSUXSEG8EI16_V }, // 10123 + { PseudoVSUXSEG8EI16_V_MF4_MF4_MASK, VSUXSEG8EI16_V }, // 10124 + { PseudoVSUXSEG8EI16_V_MF4_MF8, VSUXSEG8EI16_V }, // 10125 + { PseudoVSUXSEG8EI16_V_MF4_MF8_MASK, VSUXSEG8EI16_V }, // 10126 + { PseudoVSUXSEG8EI32_V_M1_M1, VSUXSEG8EI32_V }, // 10127 + { PseudoVSUXSEG8EI32_V_M1_M1_MASK, VSUXSEG8EI32_V }, // 10128 + { PseudoVSUXSEG8EI32_V_M1_MF2, VSUXSEG8EI32_V }, // 10129 + { PseudoVSUXSEG8EI32_V_M1_MF2_MASK, VSUXSEG8EI32_V }, // 10130 + { PseudoVSUXSEG8EI32_V_M1_MF4, VSUXSEG8EI32_V }, // 10131 + { PseudoVSUXSEG8EI32_V_M1_MF4_MASK, VSUXSEG8EI32_V }, // 10132 + { PseudoVSUXSEG8EI32_V_M2_M1, VSUXSEG8EI32_V }, // 10133 + { PseudoVSUXSEG8EI32_V_M2_M1_MASK, VSUXSEG8EI32_V }, // 10134 + { PseudoVSUXSEG8EI32_V_M2_MF2, VSUXSEG8EI32_V }, // 10135 + { PseudoVSUXSEG8EI32_V_M2_MF2_MASK, VSUXSEG8EI32_V }, // 10136 + { PseudoVSUXSEG8EI32_V_M4_M1, VSUXSEG8EI32_V }, // 10137 + { PseudoVSUXSEG8EI32_V_M4_M1_MASK, VSUXSEG8EI32_V }, // 10138 + { PseudoVSUXSEG8EI32_V_MF2_M1, VSUXSEG8EI32_V }, // 10139 + { PseudoVSUXSEG8EI32_V_MF2_M1_MASK, VSUXSEG8EI32_V }, // 10140 + { PseudoVSUXSEG8EI32_V_MF2_MF2, VSUXSEG8EI32_V }, // 10141 + { PseudoVSUXSEG8EI32_V_MF2_MF2_MASK, VSUXSEG8EI32_V }, // 10142 + { PseudoVSUXSEG8EI32_V_MF2_MF4, VSUXSEG8EI32_V }, // 10143 + { PseudoVSUXSEG8EI32_V_MF2_MF4_MASK, VSUXSEG8EI32_V }, // 10144 + { PseudoVSUXSEG8EI32_V_MF2_MF8, VSUXSEG8EI32_V }, // 10145 + { PseudoVSUXSEG8EI32_V_MF2_MF8_MASK, VSUXSEG8EI32_V }, // 10146 + { PseudoVSUXSEG8EI64_V_M1_M1, VSUXSEG8EI64_V }, // 10147 + { PseudoVSUXSEG8EI64_V_M1_M1_MASK, VSUXSEG8EI64_V }, // 10148 + { PseudoVSUXSEG8EI64_V_M1_MF2, VSUXSEG8EI64_V }, // 10149 + { PseudoVSUXSEG8EI64_V_M1_MF2_MASK, VSUXSEG8EI64_V }, // 10150 + { PseudoVSUXSEG8EI64_V_M1_MF4, VSUXSEG8EI64_V }, // 10151 + { PseudoVSUXSEG8EI64_V_M1_MF4_MASK, VSUXSEG8EI64_V }, // 10152 + { PseudoVSUXSEG8EI64_V_M1_MF8, VSUXSEG8EI64_V }, // 10153 + { PseudoVSUXSEG8EI64_V_M1_MF8_MASK, VSUXSEG8EI64_V }, // 10154 + { PseudoVSUXSEG8EI64_V_M2_M1, VSUXSEG8EI64_V }, // 10155 + { PseudoVSUXSEG8EI64_V_M2_M1_MASK, VSUXSEG8EI64_V }, // 10156 + { PseudoVSUXSEG8EI64_V_M2_MF2, VSUXSEG8EI64_V }, // 10157 + { PseudoVSUXSEG8EI64_V_M2_MF2_MASK, VSUXSEG8EI64_V }, // 10158 + { PseudoVSUXSEG8EI64_V_M2_MF4, VSUXSEG8EI64_V }, // 10159 + { PseudoVSUXSEG8EI64_V_M2_MF4_MASK, VSUXSEG8EI64_V }, // 10160 + { PseudoVSUXSEG8EI64_V_M4_M1, VSUXSEG8EI64_V }, // 10161 + { PseudoVSUXSEG8EI64_V_M4_M1_MASK, VSUXSEG8EI64_V }, // 10162 + { PseudoVSUXSEG8EI64_V_M4_MF2, VSUXSEG8EI64_V }, // 10163 + { PseudoVSUXSEG8EI64_V_M4_MF2_MASK, VSUXSEG8EI64_V }, // 10164 + { PseudoVSUXSEG8EI64_V_M8_M1, VSUXSEG8EI64_V }, // 10165 + { PseudoVSUXSEG8EI64_V_M8_M1_MASK, VSUXSEG8EI64_V }, // 10166 + { PseudoVSUXSEG8EI8_V_M1_M1, VSUXSEG8EI8_V }, // 10167 + { PseudoVSUXSEG8EI8_V_M1_M1_MASK, VSUXSEG8EI8_V }, // 10168 + { PseudoVSUXSEG8EI8_V_MF2_M1, VSUXSEG8EI8_V }, // 10169 + { PseudoVSUXSEG8EI8_V_MF2_M1_MASK, VSUXSEG8EI8_V }, // 10170 + { PseudoVSUXSEG8EI8_V_MF2_MF2, VSUXSEG8EI8_V }, // 10171 + { PseudoVSUXSEG8EI8_V_MF2_MF2_MASK, VSUXSEG8EI8_V }, // 10172 + { PseudoVSUXSEG8EI8_V_MF4_M1, VSUXSEG8EI8_V }, // 10173 + { PseudoVSUXSEG8EI8_V_MF4_M1_MASK, VSUXSEG8EI8_V }, // 10174 + { PseudoVSUXSEG8EI8_V_MF4_MF2, VSUXSEG8EI8_V }, // 10175 + { PseudoVSUXSEG8EI8_V_MF4_MF2_MASK, VSUXSEG8EI8_V }, // 10176 + { PseudoVSUXSEG8EI8_V_MF4_MF4, VSUXSEG8EI8_V }, // 10177 + { PseudoVSUXSEG8EI8_V_MF4_MF4_MASK, VSUXSEG8EI8_V }, // 10178 + { PseudoVSUXSEG8EI8_V_MF8_M1, VSUXSEG8EI8_V }, // 10179 + { PseudoVSUXSEG8EI8_V_MF8_M1_MASK, VSUXSEG8EI8_V }, // 10180 + { PseudoVSUXSEG8EI8_V_MF8_MF2, VSUXSEG8EI8_V }, // 10181 + { PseudoVSUXSEG8EI8_V_MF8_MF2_MASK, VSUXSEG8EI8_V }, // 10182 + { PseudoVSUXSEG8EI8_V_MF8_MF4, VSUXSEG8EI8_V }, // 10183 + { PseudoVSUXSEG8EI8_V_MF8_MF4_MASK, VSUXSEG8EI8_V }, // 10184 + { PseudoVSUXSEG8EI8_V_MF8_MF8, VSUXSEG8EI8_V }, // 10185 + { PseudoVSUXSEG8EI8_V_MF8_MF8_MASK, VSUXSEG8EI8_V }, // 10186 + { PseudoVWADDU_VV_M1, VWADDU_VV }, // 10187 + { PseudoVWADDU_VV_M1_MASK, VWADDU_VV }, // 10188 + { PseudoVWADDU_VV_M2, VWADDU_VV }, // 10189 + { PseudoVWADDU_VV_M2_MASK, VWADDU_VV }, // 10190 + { PseudoVWADDU_VV_M4, VWADDU_VV }, // 10191 + { PseudoVWADDU_VV_M4_MASK, VWADDU_VV }, // 10192 + { PseudoVWADDU_VV_MF2, VWADDU_VV }, // 10193 + { PseudoVWADDU_VV_MF2_MASK, VWADDU_VV }, // 10194 + { PseudoVWADDU_VV_MF4, VWADDU_VV }, // 10195 + { PseudoVWADDU_VV_MF4_MASK, VWADDU_VV }, // 10196 + { PseudoVWADDU_VV_MF8, VWADDU_VV }, // 10197 + { PseudoVWADDU_VV_MF8_MASK, VWADDU_VV }, // 10198 + { PseudoVWADDU_VX_M1, VWADDU_VX }, // 10199 + { PseudoVWADDU_VX_M1_MASK, VWADDU_VX }, // 10200 + { PseudoVWADDU_VX_M2, VWADDU_VX }, // 10201 + { PseudoVWADDU_VX_M2_MASK, VWADDU_VX }, // 10202 + { PseudoVWADDU_VX_M4, VWADDU_VX }, // 10203 + { PseudoVWADDU_VX_M4_MASK, VWADDU_VX }, // 10204 + { PseudoVWADDU_VX_MF2, VWADDU_VX }, // 10205 + { PseudoVWADDU_VX_MF2_MASK, VWADDU_VX }, // 10206 + { PseudoVWADDU_VX_MF4, VWADDU_VX }, // 10207 + { PseudoVWADDU_VX_MF4_MASK, VWADDU_VX }, // 10208 + { PseudoVWADDU_VX_MF8, VWADDU_VX }, // 10209 + { PseudoVWADDU_VX_MF8_MASK, VWADDU_VX }, // 10210 + { PseudoVWADDU_WV_M1, VWADDU_WV }, // 10211 + { PseudoVWADDU_WV_M1_MASK, VWADDU_WV }, // 10212 + { PseudoVWADDU_WV_M1_MASK_TIED, VWADDU_WV }, // 10213 + { PseudoVWADDU_WV_M1_TIED, VWADDU_WV }, // 10214 + { PseudoVWADDU_WV_M2, VWADDU_WV }, // 10215 + { PseudoVWADDU_WV_M2_MASK, VWADDU_WV }, // 10216 + { PseudoVWADDU_WV_M2_MASK_TIED, VWADDU_WV }, // 10217 + { PseudoVWADDU_WV_M2_TIED, VWADDU_WV }, // 10218 + { PseudoVWADDU_WV_M4, VWADDU_WV }, // 10219 + { PseudoVWADDU_WV_M4_MASK, VWADDU_WV }, // 10220 + { PseudoVWADDU_WV_M4_MASK_TIED, VWADDU_WV }, // 10221 + { PseudoVWADDU_WV_M4_TIED, VWADDU_WV }, // 10222 + { PseudoVWADDU_WV_MF2, VWADDU_WV }, // 10223 + { PseudoVWADDU_WV_MF2_MASK, VWADDU_WV }, // 10224 + { PseudoVWADDU_WV_MF2_MASK_TIED, VWADDU_WV }, // 10225 + { PseudoVWADDU_WV_MF2_TIED, VWADDU_WV }, // 10226 + { PseudoVWADDU_WV_MF4, VWADDU_WV }, // 10227 + { PseudoVWADDU_WV_MF4_MASK, VWADDU_WV }, // 10228 + { PseudoVWADDU_WV_MF4_MASK_TIED, VWADDU_WV }, // 10229 + { PseudoVWADDU_WV_MF4_TIED, VWADDU_WV }, // 10230 + { PseudoVWADDU_WV_MF8, VWADDU_WV }, // 10231 + { PseudoVWADDU_WV_MF8_MASK, VWADDU_WV }, // 10232 + { PseudoVWADDU_WV_MF8_MASK_TIED, VWADDU_WV }, // 10233 + { PseudoVWADDU_WV_MF8_TIED, VWADDU_WV }, // 10234 + { PseudoVWADDU_WX_M1, VWADDU_WX }, // 10235 + { PseudoVWADDU_WX_M1_MASK, VWADDU_WX }, // 10236 + { PseudoVWADDU_WX_M2, VWADDU_WX }, // 10237 + { PseudoVWADDU_WX_M2_MASK, VWADDU_WX }, // 10238 + { PseudoVWADDU_WX_M4, VWADDU_WX }, // 10239 + { PseudoVWADDU_WX_M4_MASK, VWADDU_WX }, // 10240 + { PseudoVWADDU_WX_MF2, VWADDU_WX }, // 10241 + { PseudoVWADDU_WX_MF2_MASK, VWADDU_WX }, // 10242 + { PseudoVWADDU_WX_MF4, VWADDU_WX }, // 10243 + { PseudoVWADDU_WX_MF4_MASK, VWADDU_WX }, // 10244 + { PseudoVWADDU_WX_MF8, VWADDU_WX }, // 10245 + { PseudoVWADDU_WX_MF8_MASK, VWADDU_WX }, // 10246 + { PseudoVWADD_VV_M1, VWADD_VV }, // 10247 + { PseudoVWADD_VV_M1_MASK, VWADD_VV }, // 10248 + { PseudoVWADD_VV_M2, VWADD_VV }, // 10249 + { PseudoVWADD_VV_M2_MASK, VWADD_VV }, // 10250 + { PseudoVWADD_VV_M4, VWADD_VV }, // 10251 + { PseudoVWADD_VV_M4_MASK, VWADD_VV }, // 10252 + { PseudoVWADD_VV_MF2, VWADD_VV }, // 10253 + { PseudoVWADD_VV_MF2_MASK, VWADD_VV }, // 10254 + { PseudoVWADD_VV_MF4, VWADD_VV }, // 10255 + { PseudoVWADD_VV_MF4_MASK, VWADD_VV }, // 10256 + { PseudoVWADD_VV_MF8, VWADD_VV }, // 10257 + { PseudoVWADD_VV_MF8_MASK, VWADD_VV }, // 10258 + { PseudoVWADD_VX_M1, VWADD_VX }, // 10259 + { PseudoVWADD_VX_M1_MASK, VWADD_VX }, // 10260 + { PseudoVWADD_VX_M2, VWADD_VX }, // 10261 + { PseudoVWADD_VX_M2_MASK, VWADD_VX }, // 10262 + { PseudoVWADD_VX_M4, VWADD_VX }, // 10263 + { PseudoVWADD_VX_M4_MASK, VWADD_VX }, // 10264 + { PseudoVWADD_VX_MF2, VWADD_VX }, // 10265 + { PseudoVWADD_VX_MF2_MASK, VWADD_VX }, // 10266 + { PseudoVWADD_VX_MF4, VWADD_VX }, // 10267 + { PseudoVWADD_VX_MF4_MASK, VWADD_VX }, // 10268 + { PseudoVWADD_VX_MF8, VWADD_VX }, // 10269 + { PseudoVWADD_VX_MF8_MASK, VWADD_VX }, // 10270 + { PseudoVWADD_WV_M1, VWADD_WV }, // 10271 + { PseudoVWADD_WV_M1_MASK, VWADD_WV }, // 10272 + { PseudoVWADD_WV_M1_MASK_TIED, VWADD_WV }, // 10273 + { PseudoVWADD_WV_M1_TIED, VWADD_WV }, // 10274 + { PseudoVWADD_WV_M2, VWADD_WV }, // 10275 + { PseudoVWADD_WV_M2_MASK, VWADD_WV }, // 10276 + { PseudoVWADD_WV_M2_MASK_TIED, VWADD_WV }, // 10277 + { PseudoVWADD_WV_M2_TIED, VWADD_WV }, // 10278 + { PseudoVWADD_WV_M4, VWADD_WV }, // 10279 + { PseudoVWADD_WV_M4_MASK, VWADD_WV }, // 10280 + { PseudoVWADD_WV_M4_MASK_TIED, VWADD_WV }, // 10281 + { PseudoVWADD_WV_M4_TIED, VWADD_WV }, // 10282 + { PseudoVWADD_WV_MF2, VWADD_WV }, // 10283 + { PseudoVWADD_WV_MF2_MASK, VWADD_WV }, // 10284 + { PseudoVWADD_WV_MF2_MASK_TIED, VWADD_WV }, // 10285 + { PseudoVWADD_WV_MF2_TIED, VWADD_WV }, // 10286 + { PseudoVWADD_WV_MF4, VWADD_WV }, // 10287 + { PseudoVWADD_WV_MF4_MASK, VWADD_WV }, // 10288 + { PseudoVWADD_WV_MF4_MASK_TIED, VWADD_WV }, // 10289 + { PseudoVWADD_WV_MF4_TIED, VWADD_WV }, // 10290 + { PseudoVWADD_WV_MF8, VWADD_WV }, // 10291 + { PseudoVWADD_WV_MF8_MASK, VWADD_WV }, // 10292 + { PseudoVWADD_WV_MF8_MASK_TIED, VWADD_WV }, // 10293 + { PseudoVWADD_WV_MF8_TIED, VWADD_WV }, // 10294 + { PseudoVWADD_WX_M1, VWADD_WX }, // 10295 + { PseudoVWADD_WX_M1_MASK, VWADD_WX }, // 10296 + { PseudoVWADD_WX_M2, VWADD_WX }, // 10297 + { PseudoVWADD_WX_M2_MASK, VWADD_WX }, // 10298 + { PseudoVWADD_WX_M4, VWADD_WX }, // 10299 + { PseudoVWADD_WX_M4_MASK, VWADD_WX }, // 10300 + { PseudoVWADD_WX_MF2, VWADD_WX }, // 10301 + { PseudoVWADD_WX_MF2_MASK, VWADD_WX }, // 10302 + { PseudoVWADD_WX_MF4, VWADD_WX }, // 10303 + { PseudoVWADD_WX_MF4_MASK, VWADD_WX }, // 10304 + { PseudoVWADD_WX_MF8, VWADD_WX }, // 10305 + { PseudoVWADD_WX_MF8_MASK, VWADD_WX }, // 10306 + { PseudoVWMACCSU_VV_M1, VWMACCSU_VV }, // 10307 + { PseudoVWMACCSU_VV_M1_MASK, VWMACCSU_VV }, // 10308 + { PseudoVWMACCSU_VV_M2, VWMACCSU_VV }, // 10309 + { PseudoVWMACCSU_VV_M2_MASK, VWMACCSU_VV }, // 10310 + { PseudoVWMACCSU_VV_M4, VWMACCSU_VV }, // 10311 + { PseudoVWMACCSU_VV_M4_MASK, VWMACCSU_VV }, // 10312 + { PseudoVWMACCSU_VV_MF2, VWMACCSU_VV }, // 10313 + { PseudoVWMACCSU_VV_MF2_MASK, VWMACCSU_VV }, // 10314 + { PseudoVWMACCSU_VV_MF4, VWMACCSU_VV }, // 10315 + { PseudoVWMACCSU_VV_MF4_MASK, VWMACCSU_VV }, // 10316 + { PseudoVWMACCSU_VV_MF8, VWMACCSU_VV }, // 10317 + { PseudoVWMACCSU_VV_MF8_MASK, VWMACCSU_VV }, // 10318 + { PseudoVWMACCSU_VX_M1, VWMACCSU_VX }, // 10319 + { PseudoVWMACCSU_VX_M1_MASK, VWMACCSU_VX }, // 10320 + { PseudoVWMACCSU_VX_M2, VWMACCSU_VX }, // 10321 + { PseudoVWMACCSU_VX_M2_MASK, VWMACCSU_VX }, // 10322 + { PseudoVWMACCSU_VX_M4, VWMACCSU_VX }, // 10323 + { PseudoVWMACCSU_VX_M4_MASK, VWMACCSU_VX }, // 10324 + { PseudoVWMACCSU_VX_MF2, VWMACCSU_VX }, // 10325 + { PseudoVWMACCSU_VX_MF2_MASK, VWMACCSU_VX }, // 10326 + { PseudoVWMACCSU_VX_MF4, VWMACCSU_VX }, // 10327 + { PseudoVWMACCSU_VX_MF4_MASK, VWMACCSU_VX }, // 10328 + { PseudoVWMACCSU_VX_MF8, VWMACCSU_VX }, // 10329 + { PseudoVWMACCSU_VX_MF8_MASK, VWMACCSU_VX }, // 10330 + { PseudoVWMACCUS_VX_M1, VWMACCUS_VX }, // 10331 + { PseudoVWMACCUS_VX_M1_MASK, VWMACCUS_VX }, // 10332 + { PseudoVWMACCUS_VX_M2, VWMACCUS_VX }, // 10333 + { PseudoVWMACCUS_VX_M2_MASK, VWMACCUS_VX }, // 10334 + { PseudoVWMACCUS_VX_M4, VWMACCUS_VX }, // 10335 + { PseudoVWMACCUS_VX_M4_MASK, VWMACCUS_VX }, // 10336 + { PseudoVWMACCUS_VX_MF2, VWMACCUS_VX }, // 10337 + { PseudoVWMACCUS_VX_MF2_MASK, VWMACCUS_VX }, // 10338 + { PseudoVWMACCUS_VX_MF4, VWMACCUS_VX }, // 10339 + { PseudoVWMACCUS_VX_MF4_MASK, VWMACCUS_VX }, // 10340 + { PseudoVWMACCUS_VX_MF8, VWMACCUS_VX }, // 10341 + { PseudoVWMACCUS_VX_MF8_MASK, VWMACCUS_VX }, // 10342 + { PseudoVWMACCU_VV_M1, VWMACCU_VV }, // 10343 + { PseudoVWMACCU_VV_M1_MASK, VWMACCU_VV }, // 10344 + { PseudoVWMACCU_VV_M2, VWMACCU_VV }, // 10345 + { PseudoVWMACCU_VV_M2_MASK, VWMACCU_VV }, // 10346 + { PseudoVWMACCU_VV_M4, VWMACCU_VV }, // 10347 + { PseudoVWMACCU_VV_M4_MASK, VWMACCU_VV }, // 10348 + { PseudoVWMACCU_VV_MF2, VWMACCU_VV }, // 10349 + { PseudoVWMACCU_VV_MF2_MASK, VWMACCU_VV }, // 10350 + { PseudoVWMACCU_VV_MF4, VWMACCU_VV }, // 10351 + { PseudoVWMACCU_VV_MF4_MASK, VWMACCU_VV }, // 10352 + { PseudoVWMACCU_VV_MF8, VWMACCU_VV }, // 10353 + { PseudoVWMACCU_VV_MF8_MASK, VWMACCU_VV }, // 10354 + { PseudoVWMACCU_VX_M1, VWMACCU_VX }, // 10355 + { PseudoVWMACCU_VX_M1_MASK, VWMACCU_VX }, // 10356 + { PseudoVWMACCU_VX_M2, VWMACCU_VX }, // 10357 + { PseudoVWMACCU_VX_M2_MASK, VWMACCU_VX }, // 10358 + { PseudoVWMACCU_VX_M4, VWMACCU_VX }, // 10359 + { PseudoVWMACCU_VX_M4_MASK, VWMACCU_VX }, // 10360 + { PseudoVWMACCU_VX_MF2, VWMACCU_VX }, // 10361 + { PseudoVWMACCU_VX_MF2_MASK, VWMACCU_VX }, // 10362 + { PseudoVWMACCU_VX_MF4, VWMACCU_VX }, // 10363 + { PseudoVWMACCU_VX_MF4_MASK, VWMACCU_VX }, // 10364 + { PseudoVWMACCU_VX_MF8, VWMACCU_VX }, // 10365 + { PseudoVWMACCU_VX_MF8_MASK, VWMACCU_VX }, // 10366 + { PseudoVWMACC_VV_M1, VWMACC_VV }, // 10367 + { PseudoVWMACC_VV_M1_MASK, VWMACC_VV }, // 10368 + { PseudoVWMACC_VV_M2, VWMACC_VV }, // 10369 + { PseudoVWMACC_VV_M2_MASK, VWMACC_VV }, // 10370 + { PseudoVWMACC_VV_M4, VWMACC_VV }, // 10371 + { PseudoVWMACC_VV_M4_MASK, VWMACC_VV }, // 10372 + { PseudoVWMACC_VV_MF2, VWMACC_VV }, // 10373 + { PseudoVWMACC_VV_MF2_MASK, VWMACC_VV }, // 10374 + { PseudoVWMACC_VV_MF4, VWMACC_VV }, // 10375 + { PseudoVWMACC_VV_MF4_MASK, VWMACC_VV }, // 10376 + { PseudoVWMACC_VV_MF8, VWMACC_VV }, // 10377 + { PseudoVWMACC_VV_MF8_MASK, VWMACC_VV }, // 10378 + { PseudoVWMACC_VX_M1, VWMACC_VX }, // 10379 + { PseudoVWMACC_VX_M1_MASK, VWMACC_VX }, // 10380 + { PseudoVWMACC_VX_M2, VWMACC_VX }, // 10381 + { PseudoVWMACC_VX_M2_MASK, VWMACC_VX }, // 10382 + { PseudoVWMACC_VX_M4, VWMACC_VX }, // 10383 + { PseudoVWMACC_VX_M4_MASK, VWMACC_VX }, // 10384 + { PseudoVWMACC_VX_MF2, VWMACC_VX }, // 10385 + { PseudoVWMACC_VX_MF2_MASK, VWMACC_VX }, // 10386 + { PseudoVWMACC_VX_MF4, VWMACC_VX }, // 10387 + { PseudoVWMACC_VX_MF4_MASK, VWMACC_VX }, // 10388 + { PseudoVWMACC_VX_MF8, VWMACC_VX }, // 10389 + { PseudoVWMACC_VX_MF8_MASK, VWMACC_VX }, // 10390 + { PseudoVWMULSU_VV_M1, VWMULSU_VV }, // 10391 + { PseudoVWMULSU_VV_M1_MASK, VWMULSU_VV }, // 10392 + { PseudoVWMULSU_VV_M2, VWMULSU_VV }, // 10393 + { PseudoVWMULSU_VV_M2_MASK, VWMULSU_VV }, // 10394 + { PseudoVWMULSU_VV_M4, VWMULSU_VV }, // 10395 + { PseudoVWMULSU_VV_M4_MASK, VWMULSU_VV }, // 10396 + { PseudoVWMULSU_VV_MF2, VWMULSU_VV }, // 10397 + { PseudoVWMULSU_VV_MF2_MASK, VWMULSU_VV }, // 10398 + { PseudoVWMULSU_VV_MF4, VWMULSU_VV }, // 10399 + { PseudoVWMULSU_VV_MF4_MASK, VWMULSU_VV }, // 10400 + { PseudoVWMULSU_VV_MF8, VWMULSU_VV }, // 10401 + { PseudoVWMULSU_VV_MF8_MASK, VWMULSU_VV }, // 10402 + { PseudoVWMULSU_VX_M1, VWMULSU_VX }, // 10403 + { PseudoVWMULSU_VX_M1_MASK, VWMULSU_VX }, // 10404 + { PseudoVWMULSU_VX_M2, VWMULSU_VX }, // 10405 + { PseudoVWMULSU_VX_M2_MASK, VWMULSU_VX }, // 10406 + { PseudoVWMULSU_VX_M4, VWMULSU_VX }, // 10407 + { PseudoVWMULSU_VX_M4_MASK, VWMULSU_VX }, // 10408 + { PseudoVWMULSU_VX_MF2, VWMULSU_VX }, // 10409 + { PseudoVWMULSU_VX_MF2_MASK, VWMULSU_VX }, // 10410 + { PseudoVWMULSU_VX_MF4, VWMULSU_VX }, // 10411 + { PseudoVWMULSU_VX_MF4_MASK, VWMULSU_VX }, // 10412 + { PseudoVWMULSU_VX_MF8, VWMULSU_VX }, // 10413 + { PseudoVWMULSU_VX_MF8_MASK, VWMULSU_VX }, // 10414 + { PseudoVWMULU_VV_M1, VWMULU_VV }, // 10415 + { PseudoVWMULU_VV_M1_MASK, VWMULU_VV }, // 10416 + { PseudoVWMULU_VV_M2, VWMULU_VV }, // 10417 + { PseudoVWMULU_VV_M2_MASK, VWMULU_VV }, // 10418 + { PseudoVWMULU_VV_M4, VWMULU_VV }, // 10419 + { PseudoVWMULU_VV_M4_MASK, VWMULU_VV }, // 10420 + { PseudoVWMULU_VV_MF2, VWMULU_VV }, // 10421 + { PseudoVWMULU_VV_MF2_MASK, VWMULU_VV }, // 10422 + { PseudoVWMULU_VV_MF4, VWMULU_VV }, // 10423 + { PseudoVWMULU_VV_MF4_MASK, VWMULU_VV }, // 10424 + { PseudoVWMULU_VV_MF8, VWMULU_VV }, // 10425 + { PseudoVWMULU_VV_MF8_MASK, VWMULU_VV }, // 10426 + { PseudoVWMULU_VX_M1, VWMULU_VX }, // 10427 + { PseudoVWMULU_VX_M1_MASK, VWMULU_VX }, // 10428 + { PseudoVWMULU_VX_M2, VWMULU_VX }, // 10429 + { PseudoVWMULU_VX_M2_MASK, VWMULU_VX }, // 10430 + { PseudoVWMULU_VX_M4, VWMULU_VX }, // 10431 + { PseudoVWMULU_VX_M4_MASK, VWMULU_VX }, // 10432 + { PseudoVWMULU_VX_MF2, VWMULU_VX }, // 10433 + { PseudoVWMULU_VX_MF2_MASK, VWMULU_VX }, // 10434 + { PseudoVWMULU_VX_MF4, VWMULU_VX }, // 10435 + { PseudoVWMULU_VX_MF4_MASK, VWMULU_VX }, // 10436 + { PseudoVWMULU_VX_MF8, VWMULU_VX }, // 10437 + { PseudoVWMULU_VX_MF8_MASK, VWMULU_VX }, // 10438 + { PseudoVWMUL_VV_M1, VWMUL_VV }, // 10439 + { PseudoVWMUL_VV_M1_MASK, VWMUL_VV }, // 10440 + { PseudoVWMUL_VV_M2, VWMUL_VV }, // 10441 + { PseudoVWMUL_VV_M2_MASK, VWMUL_VV }, // 10442 + { PseudoVWMUL_VV_M4, VWMUL_VV }, // 10443 + { PseudoVWMUL_VV_M4_MASK, VWMUL_VV }, // 10444 + { PseudoVWMUL_VV_MF2, VWMUL_VV }, // 10445 + { PseudoVWMUL_VV_MF2_MASK, VWMUL_VV }, // 10446 + { PseudoVWMUL_VV_MF4, VWMUL_VV }, // 10447 + { PseudoVWMUL_VV_MF4_MASK, VWMUL_VV }, // 10448 + { PseudoVWMUL_VV_MF8, VWMUL_VV }, // 10449 + { PseudoVWMUL_VV_MF8_MASK, VWMUL_VV }, // 10450 + { PseudoVWMUL_VX_M1, VWMUL_VX }, // 10451 + { PseudoVWMUL_VX_M1_MASK, VWMUL_VX }, // 10452 + { PseudoVWMUL_VX_M2, VWMUL_VX }, // 10453 + { PseudoVWMUL_VX_M2_MASK, VWMUL_VX }, // 10454 + { PseudoVWMUL_VX_M4, VWMUL_VX }, // 10455 + { PseudoVWMUL_VX_M4_MASK, VWMUL_VX }, // 10456 + { PseudoVWMUL_VX_MF2, VWMUL_VX }, // 10457 + { PseudoVWMUL_VX_MF2_MASK, VWMUL_VX }, // 10458 + { PseudoVWMUL_VX_MF4, VWMUL_VX }, // 10459 + { PseudoVWMUL_VX_MF4_MASK, VWMUL_VX }, // 10460 + { PseudoVWMUL_VX_MF8, VWMUL_VX }, // 10461 + { PseudoVWMUL_VX_MF8_MASK, VWMUL_VX }, // 10462 + { PseudoVWREDSUMU_VS_M1_E16, VWREDSUMU_VS }, // 10463 + { PseudoVWREDSUMU_VS_M1_E16_MASK, VWREDSUMU_VS }, // 10464 + { PseudoVWREDSUMU_VS_M1_E32, VWREDSUMU_VS }, // 10465 + { PseudoVWREDSUMU_VS_M1_E32_MASK, VWREDSUMU_VS }, // 10466 + { PseudoVWREDSUMU_VS_M1_E8, VWREDSUMU_VS }, // 10467 + { PseudoVWREDSUMU_VS_M1_E8_MASK, VWREDSUMU_VS }, // 10468 + { PseudoVWREDSUMU_VS_M2_E16, VWREDSUMU_VS }, // 10469 + { PseudoVWREDSUMU_VS_M2_E16_MASK, VWREDSUMU_VS }, // 10470 + { PseudoVWREDSUMU_VS_M2_E32, VWREDSUMU_VS }, // 10471 + { PseudoVWREDSUMU_VS_M2_E32_MASK, VWREDSUMU_VS }, // 10472 + { PseudoVWREDSUMU_VS_M2_E8, VWREDSUMU_VS }, // 10473 + { PseudoVWREDSUMU_VS_M2_E8_MASK, VWREDSUMU_VS }, // 10474 + { PseudoVWREDSUMU_VS_M4_E16, VWREDSUMU_VS }, // 10475 + { PseudoVWREDSUMU_VS_M4_E16_MASK, VWREDSUMU_VS }, // 10476 + { PseudoVWREDSUMU_VS_M4_E32, VWREDSUMU_VS }, // 10477 + { PseudoVWREDSUMU_VS_M4_E32_MASK, VWREDSUMU_VS }, // 10478 + { PseudoVWREDSUMU_VS_M4_E8, VWREDSUMU_VS }, // 10479 + { PseudoVWREDSUMU_VS_M4_E8_MASK, VWREDSUMU_VS }, // 10480 + { PseudoVWREDSUMU_VS_M8_E16, VWREDSUMU_VS }, // 10481 + { PseudoVWREDSUMU_VS_M8_E16_MASK, VWREDSUMU_VS }, // 10482 + { PseudoVWREDSUMU_VS_M8_E32, VWREDSUMU_VS }, // 10483 + { PseudoVWREDSUMU_VS_M8_E32_MASK, VWREDSUMU_VS }, // 10484 + { PseudoVWREDSUMU_VS_M8_E8, VWREDSUMU_VS }, // 10485 + { PseudoVWREDSUMU_VS_M8_E8_MASK, VWREDSUMU_VS }, // 10486 + { PseudoVWREDSUMU_VS_MF2_E16, VWREDSUMU_VS }, // 10487 + { PseudoVWREDSUMU_VS_MF2_E16_MASK, VWREDSUMU_VS }, // 10488 + { PseudoVWREDSUMU_VS_MF2_E32, VWREDSUMU_VS }, // 10489 + { PseudoVWREDSUMU_VS_MF2_E32_MASK, VWREDSUMU_VS }, // 10490 + { PseudoVWREDSUMU_VS_MF2_E8, VWREDSUMU_VS }, // 10491 + { PseudoVWREDSUMU_VS_MF2_E8_MASK, VWREDSUMU_VS }, // 10492 + { PseudoVWREDSUMU_VS_MF4_E16, VWREDSUMU_VS }, // 10493 + { PseudoVWREDSUMU_VS_MF4_E16_MASK, VWREDSUMU_VS }, // 10494 + { PseudoVWREDSUMU_VS_MF4_E8, VWREDSUMU_VS }, // 10495 + { PseudoVWREDSUMU_VS_MF4_E8_MASK, VWREDSUMU_VS }, // 10496 + { PseudoVWREDSUMU_VS_MF8_E8, VWREDSUMU_VS }, // 10497 + { PseudoVWREDSUMU_VS_MF8_E8_MASK, VWREDSUMU_VS }, // 10498 + { PseudoVWREDSUM_VS_M1_E16, VWREDSUM_VS }, // 10499 + { PseudoVWREDSUM_VS_M1_E16_MASK, VWREDSUM_VS }, // 10500 + { PseudoVWREDSUM_VS_M1_E32, VWREDSUM_VS }, // 10501 + { PseudoVWREDSUM_VS_M1_E32_MASK, VWREDSUM_VS }, // 10502 + { PseudoVWREDSUM_VS_M1_E8, VWREDSUM_VS }, // 10503 + { PseudoVWREDSUM_VS_M1_E8_MASK, VWREDSUM_VS }, // 10504 + { PseudoVWREDSUM_VS_M2_E16, VWREDSUM_VS }, // 10505 + { PseudoVWREDSUM_VS_M2_E16_MASK, VWREDSUM_VS }, // 10506 + { PseudoVWREDSUM_VS_M2_E32, VWREDSUM_VS }, // 10507 + { PseudoVWREDSUM_VS_M2_E32_MASK, VWREDSUM_VS }, // 10508 + { PseudoVWREDSUM_VS_M2_E8, VWREDSUM_VS }, // 10509 + { PseudoVWREDSUM_VS_M2_E8_MASK, VWREDSUM_VS }, // 10510 + { PseudoVWREDSUM_VS_M4_E16, VWREDSUM_VS }, // 10511 + { PseudoVWREDSUM_VS_M4_E16_MASK, VWREDSUM_VS }, // 10512 + { PseudoVWREDSUM_VS_M4_E32, VWREDSUM_VS }, // 10513 + { PseudoVWREDSUM_VS_M4_E32_MASK, VWREDSUM_VS }, // 10514 + { PseudoVWREDSUM_VS_M4_E8, VWREDSUM_VS }, // 10515 + { PseudoVWREDSUM_VS_M4_E8_MASK, VWREDSUM_VS }, // 10516 + { PseudoVWREDSUM_VS_M8_E16, VWREDSUM_VS }, // 10517 + { PseudoVWREDSUM_VS_M8_E16_MASK, VWREDSUM_VS }, // 10518 + { PseudoVWREDSUM_VS_M8_E32, VWREDSUM_VS }, // 10519 + { PseudoVWREDSUM_VS_M8_E32_MASK, VWREDSUM_VS }, // 10520 + { PseudoVWREDSUM_VS_M8_E8, VWREDSUM_VS }, // 10521 + { PseudoVWREDSUM_VS_M8_E8_MASK, VWREDSUM_VS }, // 10522 + { PseudoVWREDSUM_VS_MF2_E16, VWREDSUM_VS }, // 10523 + { PseudoVWREDSUM_VS_MF2_E16_MASK, VWREDSUM_VS }, // 10524 + { PseudoVWREDSUM_VS_MF2_E32, VWREDSUM_VS }, // 10525 + { PseudoVWREDSUM_VS_MF2_E32_MASK, VWREDSUM_VS }, // 10526 + { PseudoVWREDSUM_VS_MF2_E8, VWREDSUM_VS }, // 10527 + { PseudoVWREDSUM_VS_MF2_E8_MASK, VWREDSUM_VS }, // 10528 + { PseudoVWREDSUM_VS_MF4_E16, VWREDSUM_VS }, // 10529 + { PseudoVWREDSUM_VS_MF4_E16_MASK, VWREDSUM_VS }, // 10530 + { PseudoVWREDSUM_VS_MF4_E8, VWREDSUM_VS }, // 10531 + { PseudoVWREDSUM_VS_MF4_E8_MASK, VWREDSUM_VS }, // 10532 + { PseudoVWREDSUM_VS_MF8_E8, VWREDSUM_VS }, // 10533 + { PseudoVWREDSUM_VS_MF8_E8_MASK, VWREDSUM_VS }, // 10534 + { PseudoVWSLL_VI_M1, VWSLL_VI }, // 10535 + { PseudoVWSLL_VI_M1_MASK, VWSLL_VI }, // 10536 + { PseudoVWSLL_VI_M2, VWSLL_VI }, // 10537 + { PseudoVWSLL_VI_M2_MASK, VWSLL_VI }, // 10538 + { PseudoVWSLL_VI_M4, VWSLL_VI }, // 10539 + { PseudoVWSLL_VI_M4_MASK, VWSLL_VI }, // 10540 + { PseudoVWSLL_VI_MF2, VWSLL_VI }, // 10541 + { PseudoVWSLL_VI_MF2_MASK, VWSLL_VI }, // 10542 + { PseudoVWSLL_VI_MF4, VWSLL_VI }, // 10543 + { PseudoVWSLL_VI_MF4_MASK, VWSLL_VI }, // 10544 + { PseudoVWSLL_VI_MF8, VWSLL_VI }, // 10545 + { PseudoVWSLL_VI_MF8_MASK, VWSLL_VI }, // 10546 + { PseudoVWSLL_VV_M1, VWSLL_VV }, // 10547 + { PseudoVWSLL_VV_M1_MASK, VWSLL_VV }, // 10548 + { PseudoVWSLL_VV_M2, VWSLL_VV }, // 10549 + { PseudoVWSLL_VV_M2_MASK, VWSLL_VV }, // 10550 + { PseudoVWSLL_VV_M4, VWSLL_VV }, // 10551 + { PseudoVWSLL_VV_M4_MASK, VWSLL_VV }, // 10552 + { PseudoVWSLL_VV_MF2, VWSLL_VV }, // 10553 + { PseudoVWSLL_VV_MF2_MASK, VWSLL_VV }, // 10554 + { PseudoVWSLL_VV_MF4, VWSLL_VV }, // 10555 + { PseudoVWSLL_VV_MF4_MASK, VWSLL_VV }, // 10556 + { PseudoVWSLL_VV_MF8, VWSLL_VV }, // 10557 + { PseudoVWSLL_VV_MF8_MASK, VWSLL_VV }, // 10558 + { PseudoVWSLL_VX_M1, VWSLL_VX }, // 10559 + { PseudoVWSLL_VX_M1_MASK, VWSLL_VX }, // 10560 + { PseudoVWSLL_VX_M2, VWSLL_VX }, // 10561 + { PseudoVWSLL_VX_M2_MASK, VWSLL_VX }, // 10562 + { PseudoVWSLL_VX_M4, VWSLL_VX }, // 10563 + { PseudoVWSLL_VX_M4_MASK, VWSLL_VX }, // 10564 + { PseudoVWSLL_VX_MF2, VWSLL_VX }, // 10565 + { PseudoVWSLL_VX_MF2_MASK, VWSLL_VX }, // 10566 + { PseudoVWSLL_VX_MF4, VWSLL_VX }, // 10567 + { PseudoVWSLL_VX_MF4_MASK, VWSLL_VX }, // 10568 + { PseudoVWSLL_VX_MF8, VWSLL_VX }, // 10569 + { PseudoVWSLL_VX_MF8_MASK, VWSLL_VX }, // 10570 + { PseudoVWSUBU_VV_M1, VWSUBU_VV }, // 10571 + { PseudoVWSUBU_VV_M1_MASK, VWSUBU_VV }, // 10572 + { PseudoVWSUBU_VV_M2, VWSUBU_VV }, // 10573 + { PseudoVWSUBU_VV_M2_MASK, VWSUBU_VV }, // 10574 + { PseudoVWSUBU_VV_M4, VWSUBU_VV }, // 10575 + { PseudoVWSUBU_VV_M4_MASK, VWSUBU_VV }, // 10576 + { PseudoVWSUBU_VV_MF2, VWSUBU_VV }, // 10577 + { PseudoVWSUBU_VV_MF2_MASK, VWSUBU_VV }, // 10578 + { PseudoVWSUBU_VV_MF4, VWSUBU_VV }, // 10579 + { PseudoVWSUBU_VV_MF4_MASK, VWSUBU_VV }, // 10580 + { PseudoVWSUBU_VV_MF8, VWSUBU_VV }, // 10581 + { PseudoVWSUBU_VV_MF8_MASK, VWSUBU_VV }, // 10582 + { PseudoVWSUBU_VX_M1, VWSUBU_VX }, // 10583 + { PseudoVWSUBU_VX_M1_MASK, VWSUBU_VX }, // 10584 + { PseudoVWSUBU_VX_M2, VWSUBU_VX }, // 10585 + { PseudoVWSUBU_VX_M2_MASK, VWSUBU_VX }, // 10586 + { PseudoVWSUBU_VX_M4, VWSUBU_VX }, // 10587 + { PseudoVWSUBU_VX_M4_MASK, VWSUBU_VX }, // 10588 + { PseudoVWSUBU_VX_MF2, VWSUBU_VX }, // 10589 + { PseudoVWSUBU_VX_MF2_MASK, VWSUBU_VX }, // 10590 + { PseudoVWSUBU_VX_MF4, VWSUBU_VX }, // 10591 + { PseudoVWSUBU_VX_MF4_MASK, VWSUBU_VX }, // 10592 + { PseudoVWSUBU_VX_MF8, VWSUBU_VX }, // 10593 + { PseudoVWSUBU_VX_MF8_MASK, VWSUBU_VX }, // 10594 + { PseudoVWSUBU_WV_M1, VWSUBU_WV }, // 10595 + { PseudoVWSUBU_WV_M1_MASK, VWSUBU_WV }, // 10596 + { PseudoVWSUBU_WV_M1_MASK_TIED, VWSUBU_WV }, // 10597 + { PseudoVWSUBU_WV_M1_TIED, VWSUBU_WV }, // 10598 + { PseudoVWSUBU_WV_M2, VWSUBU_WV }, // 10599 + { PseudoVWSUBU_WV_M2_MASK, VWSUBU_WV }, // 10600 + { PseudoVWSUBU_WV_M2_MASK_TIED, VWSUBU_WV }, // 10601 + { PseudoVWSUBU_WV_M2_TIED, VWSUBU_WV }, // 10602 + { PseudoVWSUBU_WV_M4, VWSUBU_WV }, // 10603 + { PseudoVWSUBU_WV_M4_MASK, VWSUBU_WV }, // 10604 + { PseudoVWSUBU_WV_M4_MASK_TIED, VWSUBU_WV }, // 10605 + { PseudoVWSUBU_WV_M4_TIED, VWSUBU_WV }, // 10606 + { PseudoVWSUBU_WV_MF2, VWSUBU_WV }, // 10607 + { PseudoVWSUBU_WV_MF2_MASK, VWSUBU_WV }, // 10608 + { PseudoVWSUBU_WV_MF2_MASK_TIED, VWSUBU_WV }, // 10609 + { PseudoVWSUBU_WV_MF2_TIED, VWSUBU_WV }, // 10610 + { PseudoVWSUBU_WV_MF4, VWSUBU_WV }, // 10611 + { PseudoVWSUBU_WV_MF4_MASK, VWSUBU_WV }, // 10612 + { PseudoVWSUBU_WV_MF4_MASK_TIED, VWSUBU_WV }, // 10613 + { PseudoVWSUBU_WV_MF4_TIED, VWSUBU_WV }, // 10614 + { PseudoVWSUBU_WV_MF8, VWSUBU_WV }, // 10615 + { PseudoVWSUBU_WV_MF8_MASK, VWSUBU_WV }, // 10616 + { PseudoVWSUBU_WV_MF8_MASK_TIED, VWSUBU_WV }, // 10617 + { PseudoVWSUBU_WV_MF8_TIED, VWSUBU_WV }, // 10618 + { PseudoVWSUBU_WX_M1, VWSUBU_WX }, // 10619 + { PseudoVWSUBU_WX_M1_MASK, VWSUBU_WX }, // 10620 + { PseudoVWSUBU_WX_M2, VWSUBU_WX }, // 10621 + { PseudoVWSUBU_WX_M2_MASK, VWSUBU_WX }, // 10622 + { PseudoVWSUBU_WX_M4, VWSUBU_WX }, // 10623 + { PseudoVWSUBU_WX_M4_MASK, VWSUBU_WX }, // 10624 + { PseudoVWSUBU_WX_MF2, VWSUBU_WX }, // 10625 + { PseudoVWSUBU_WX_MF2_MASK, VWSUBU_WX }, // 10626 + { PseudoVWSUBU_WX_MF4, VWSUBU_WX }, // 10627 + { PseudoVWSUBU_WX_MF4_MASK, VWSUBU_WX }, // 10628 + { PseudoVWSUBU_WX_MF8, VWSUBU_WX }, // 10629 + { PseudoVWSUBU_WX_MF8_MASK, VWSUBU_WX }, // 10630 + { PseudoVWSUB_VV_M1, VWSUB_VV }, // 10631 + { PseudoVWSUB_VV_M1_MASK, VWSUB_VV }, // 10632 + { PseudoVWSUB_VV_M2, VWSUB_VV }, // 10633 + { PseudoVWSUB_VV_M2_MASK, VWSUB_VV }, // 10634 + { PseudoVWSUB_VV_M4, VWSUB_VV }, // 10635 + { PseudoVWSUB_VV_M4_MASK, VWSUB_VV }, // 10636 + { PseudoVWSUB_VV_MF2, VWSUB_VV }, // 10637 + { PseudoVWSUB_VV_MF2_MASK, VWSUB_VV }, // 10638 + { PseudoVWSUB_VV_MF4, VWSUB_VV }, // 10639 + { PseudoVWSUB_VV_MF4_MASK, VWSUB_VV }, // 10640 + { PseudoVWSUB_VV_MF8, VWSUB_VV }, // 10641 + { PseudoVWSUB_VV_MF8_MASK, VWSUB_VV }, // 10642 + { PseudoVWSUB_VX_M1, VWSUB_VX }, // 10643 + { PseudoVWSUB_VX_M1_MASK, VWSUB_VX }, // 10644 + { PseudoVWSUB_VX_M2, VWSUB_VX }, // 10645 + { PseudoVWSUB_VX_M2_MASK, VWSUB_VX }, // 10646 + { PseudoVWSUB_VX_M4, VWSUB_VX }, // 10647 + { PseudoVWSUB_VX_M4_MASK, VWSUB_VX }, // 10648 + { PseudoVWSUB_VX_MF2, VWSUB_VX }, // 10649 + { PseudoVWSUB_VX_MF2_MASK, VWSUB_VX }, // 10650 + { PseudoVWSUB_VX_MF4, VWSUB_VX }, // 10651 + { PseudoVWSUB_VX_MF4_MASK, VWSUB_VX }, // 10652 + { PseudoVWSUB_VX_MF8, VWSUB_VX }, // 10653 + { PseudoVWSUB_VX_MF8_MASK, VWSUB_VX }, // 10654 + { PseudoVWSUB_WV_M1, VWSUB_WV }, // 10655 + { PseudoVWSUB_WV_M1_MASK, VWSUB_WV }, // 10656 + { PseudoVWSUB_WV_M1_MASK_TIED, VWSUB_WV }, // 10657 + { PseudoVWSUB_WV_M1_TIED, VWSUB_WV }, // 10658 + { PseudoVWSUB_WV_M2, VWSUB_WV }, // 10659 + { PseudoVWSUB_WV_M2_MASK, VWSUB_WV }, // 10660 + { PseudoVWSUB_WV_M2_MASK_TIED, VWSUB_WV }, // 10661 + { PseudoVWSUB_WV_M2_TIED, VWSUB_WV }, // 10662 + { PseudoVWSUB_WV_M4, VWSUB_WV }, // 10663 + { PseudoVWSUB_WV_M4_MASK, VWSUB_WV }, // 10664 + { PseudoVWSUB_WV_M4_MASK_TIED, VWSUB_WV }, // 10665 + { PseudoVWSUB_WV_M4_TIED, VWSUB_WV }, // 10666 + { PseudoVWSUB_WV_MF2, VWSUB_WV }, // 10667 + { PseudoVWSUB_WV_MF2_MASK, VWSUB_WV }, // 10668 + { PseudoVWSUB_WV_MF2_MASK_TIED, VWSUB_WV }, // 10669 + { PseudoVWSUB_WV_MF2_TIED, VWSUB_WV }, // 10670 + { PseudoVWSUB_WV_MF4, VWSUB_WV }, // 10671 + { PseudoVWSUB_WV_MF4_MASK, VWSUB_WV }, // 10672 + { PseudoVWSUB_WV_MF4_MASK_TIED, VWSUB_WV }, // 10673 + { PseudoVWSUB_WV_MF4_TIED, VWSUB_WV }, // 10674 + { PseudoVWSUB_WV_MF8, VWSUB_WV }, // 10675 + { PseudoVWSUB_WV_MF8_MASK, VWSUB_WV }, // 10676 + { PseudoVWSUB_WV_MF8_MASK_TIED, VWSUB_WV }, // 10677 + { PseudoVWSUB_WV_MF8_TIED, VWSUB_WV }, // 10678 + { PseudoVWSUB_WX_M1, VWSUB_WX }, // 10679 + { PseudoVWSUB_WX_M1_MASK, VWSUB_WX }, // 10680 + { PseudoVWSUB_WX_M2, VWSUB_WX }, // 10681 + { PseudoVWSUB_WX_M2_MASK, VWSUB_WX }, // 10682 + { PseudoVWSUB_WX_M4, VWSUB_WX }, // 10683 + { PseudoVWSUB_WX_M4_MASK, VWSUB_WX }, // 10684 + { PseudoVWSUB_WX_MF2, VWSUB_WX }, // 10685 + { PseudoVWSUB_WX_MF2_MASK, VWSUB_WX }, // 10686 + { PseudoVWSUB_WX_MF4, VWSUB_WX }, // 10687 + { PseudoVWSUB_WX_MF4_MASK, VWSUB_WX }, // 10688 + { PseudoVWSUB_WX_MF8, VWSUB_WX }, // 10689 + { PseudoVWSUB_WX_MF8_MASK, VWSUB_WX }, // 10690 + { PseudoVXOR_VI_M1, VXOR_VI }, // 10691 + { PseudoVXOR_VI_M1_MASK, VXOR_VI }, // 10692 + { PseudoVXOR_VI_M2, VXOR_VI }, // 10693 + { PseudoVXOR_VI_M2_MASK, VXOR_VI }, // 10694 + { PseudoVXOR_VI_M4, VXOR_VI }, // 10695 + { PseudoVXOR_VI_M4_MASK, VXOR_VI }, // 10696 + { PseudoVXOR_VI_M8, VXOR_VI }, // 10697 + { PseudoVXOR_VI_M8_MASK, VXOR_VI }, // 10698 + { PseudoVXOR_VI_MF2, VXOR_VI }, // 10699 + { PseudoVXOR_VI_MF2_MASK, VXOR_VI }, // 10700 + { PseudoVXOR_VI_MF4, VXOR_VI }, // 10701 + { PseudoVXOR_VI_MF4_MASK, VXOR_VI }, // 10702 + { PseudoVXOR_VI_MF8, VXOR_VI }, // 10703 + { PseudoVXOR_VI_MF8_MASK, VXOR_VI }, // 10704 + { PseudoVXOR_VV_M1, VXOR_VV }, // 10705 + { PseudoVXOR_VV_M1_MASK, VXOR_VV }, // 10706 + { PseudoVXOR_VV_M2, VXOR_VV }, // 10707 + { PseudoVXOR_VV_M2_MASK, VXOR_VV }, // 10708 + { PseudoVXOR_VV_M4, VXOR_VV }, // 10709 + { PseudoVXOR_VV_M4_MASK, VXOR_VV }, // 10710 + { PseudoVXOR_VV_M8, VXOR_VV }, // 10711 + { PseudoVXOR_VV_M8_MASK, VXOR_VV }, // 10712 + { PseudoVXOR_VV_MF2, VXOR_VV }, // 10713 + { PseudoVXOR_VV_MF2_MASK, VXOR_VV }, // 10714 + { PseudoVXOR_VV_MF4, VXOR_VV }, // 10715 + { PseudoVXOR_VV_MF4_MASK, VXOR_VV }, // 10716 + { PseudoVXOR_VV_MF8, VXOR_VV }, // 10717 + { PseudoVXOR_VV_MF8_MASK, VXOR_VV }, // 10718 + { PseudoVXOR_VX_M1, VXOR_VX }, // 10719 + { PseudoVXOR_VX_M1_MASK, VXOR_VX }, // 10720 + { PseudoVXOR_VX_M2, VXOR_VX }, // 10721 + { PseudoVXOR_VX_M2_MASK, VXOR_VX }, // 10722 + { PseudoVXOR_VX_M4, VXOR_VX }, // 10723 + { PseudoVXOR_VX_M4_MASK, VXOR_VX }, // 10724 + { PseudoVXOR_VX_M8, VXOR_VX }, // 10725 + { PseudoVXOR_VX_M8_MASK, VXOR_VX }, // 10726 + { PseudoVXOR_VX_MF2, VXOR_VX }, // 10727 + { PseudoVXOR_VX_MF2_MASK, VXOR_VX }, // 10728 + { PseudoVXOR_VX_MF4, VXOR_VX }, // 10729 + { PseudoVXOR_VX_MF4_MASK, VXOR_VX }, // 10730 + { PseudoVXOR_VX_MF8, VXOR_VX }, // 10731 + { PseudoVXOR_VX_MF8_MASK, VXOR_VX }, // 10732 + { PseudoVZEXT_VF2_M1, VZEXT_VF2 }, // 10733 + { PseudoVZEXT_VF2_M1_MASK, VZEXT_VF2 }, // 10734 + { PseudoVZEXT_VF2_M2, VZEXT_VF2 }, // 10735 + { PseudoVZEXT_VF2_M2_MASK, VZEXT_VF2 }, // 10736 + { PseudoVZEXT_VF2_M4, VZEXT_VF2 }, // 10737 + { PseudoVZEXT_VF2_M4_MASK, VZEXT_VF2 }, // 10738 + { PseudoVZEXT_VF2_M8, VZEXT_VF2 }, // 10739 + { PseudoVZEXT_VF2_M8_MASK, VZEXT_VF2 }, // 10740 + { PseudoVZEXT_VF2_MF2, VZEXT_VF2 }, // 10741 + { PseudoVZEXT_VF2_MF2_MASK, VZEXT_VF2 }, // 10742 + { PseudoVZEXT_VF2_MF4, VZEXT_VF2 }, // 10743 + { PseudoVZEXT_VF2_MF4_MASK, VZEXT_VF2 }, // 10744 + { PseudoVZEXT_VF4_M1, VZEXT_VF4 }, // 10745 + { PseudoVZEXT_VF4_M1_MASK, VZEXT_VF4 }, // 10746 + { PseudoVZEXT_VF4_M2, VZEXT_VF4 }, // 10747 + { PseudoVZEXT_VF4_M2_MASK, VZEXT_VF4 }, // 10748 + { PseudoVZEXT_VF4_M4, VZEXT_VF4 }, // 10749 + { PseudoVZEXT_VF4_M4_MASK, VZEXT_VF4 }, // 10750 + { PseudoVZEXT_VF4_M8, VZEXT_VF4 }, // 10751 + { PseudoVZEXT_VF4_M8_MASK, VZEXT_VF4 }, // 10752 + { PseudoVZEXT_VF4_MF2, VZEXT_VF4 }, // 10753 + { PseudoVZEXT_VF4_MF2_MASK, VZEXT_VF4 }, // 10754 + { PseudoVZEXT_VF8_M1, VZEXT_VF8 }, // 10755 + { PseudoVZEXT_VF8_M1_MASK, VZEXT_VF8 }, // 10756 + { PseudoVZEXT_VF8_M2, VZEXT_VF8 }, // 10757 + { PseudoVZEXT_VF8_M2_MASK, VZEXT_VF8 }, // 10758 + { PseudoVZEXT_VF8_M4, VZEXT_VF8 }, // 10759 + { PseudoVZEXT_VF8_M4_MASK, VZEXT_VF8 }, // 10760 + { PseudoVZEXT_VF8_M8, VZEXT_VF8 }, // 10761 + { PseudoVZEXT_VF8_M8_MASK, VZEXT_VF8 }, // 10762 + }; + +const RISCV_PseudoInfo *RISCV_getPseudoInfo(unsigned Pseudo) { + unsigned i = binsearch_IndexTypeEncoding(Index, ARR_SIZE(Index), Pseudo); + if (i == -1) + return NULL; + else + return &RISCVVPseudosTable[Index[i].index]; +} + +#endif + +#ifdef GET_RISCVVSETable_IMPL +static const RISCV_VSEPseudo RISCVVSETable[] = { + { 0x0, 0x0, 0x0, 0x0, PseudoVSM_V_B8 }, // 0 + { 0x0, 0x0, 0x0, 0x1, PseudoVSM_V_B16 }, // 1 + { 0x0, 0x0, 0x0, 0x2, PseudoVSM_V_B32 }, // 2 + { 0x0, 0x0, 0x0, 0x3, PseudoVSM_V_B64 }, // 3 + { 0x0, 0x0, 0x0, 0x5, PseudoVSM_V_B1 }, // 4 + { 0x0, 0x0, 0x0, 0x6, PseudoVSM_V_B2 }, // 5 + { 0x0, 0x0, 0x0, 0x7, PseudoVSM_V_B4 }, // 6 + { 0x0, 0x0, 0x3, 0x0, PseudoVSE8_V_M1 }, // 7 + { 0x0, 0x0, 0x3, 0x1, PseudoVSE8_V_M2 }, // 8 + { 0x0, 0x0, 0x3, 0x2, PseudoVSE8_V_M4 }, // 9 + { 0x0, 0x0, 0x3, 0x3, PseudoVSE8_V_M8 }, // 10 + { 0x0, 0x0, 0x3, 0x5, PseudoVSE8_V_MF8 }, // 11 + { 0x0, 0x0, 0x3, 0x6, PseudoVSE8_V_MF4 }, // 12 + { 0x0, 0x0, 0x3, 0x7, PseudoVSE8_V_MF2 }, // 13 + { 0x0, 0x0, 0x4, 0x0, PseudoVSE16_V_M1 }, // 14 + { 0x0, 0x0, 0x4, 0x1, PseudoVSE16_V_M2 }, // 15 + { 0x0, 0x0, 0x4, 0x2, PseudoVSE16_V_M4 }, // 16 + { 0x0, 0x0, 0x4, 0x3, PseudoVSE16_V_M8 }, // 17 + { 0x0, 0x0, 0x4, 0x6, PseudoVSE16_V_MF4 }, // 18 + { 0x0, 0x0, 0x4, 0x7, PseudoVSE16_V_MF2 }, // 19 + { 0x0, 0x0, 0x5, 0x0, PseudoVSE32_V_M1 }, // 20 + { 0x0, 0x0, 0x5, 0x1, PseudoVSE32_V_M2 }, // 21 + { 0x0, 0x0, 0x5, 0x2, PseudoVSE32_V_M4 }, // 22 + { 0x0, 0x0, 0x5, 0x3, PseudoVSE32_V_M8 }, // 23 + { 0x0, 0x0, 0x5, 0x7, PseudoVSE32_V_MF2 }, // 24 + { 0x0, 0x0, 0x6, 0x0, PseudoVSE64_V_M1 }, // 25 + { 0x0, 0x0, 0x6, 0x1, PseudoVSE64_V_M2 }, // 26 + { 0x0, 0x0, 0x6, 0x2, PseudoVSE64_V_M4 }, // 27 + { 0x0, 0x0, 0x6, 0x3, PseudoVSE64_V_M8 }, // 28 + { 0x0, 0x1, 0x3, 0x0, PseudoVSSE8_V_M1 }, // 29 + { 0x0, 0x1, 0x3, 0x1, PseudoVSSE8_V_M2 }, // 30 + { 0x0, 0x1, 0x3, 0x2, PseudoVSSE8_V_M4 }, // 31 + { 0x0, 0x1, 0x3, 0x3, PseudoVSSE8_V_M8 }, // 32 + { 0x0, 0x1, 0x3, 0x5, PseudoVSSE8_V_MF8 }, // 33 + { 0x0, 0x1, 0x3, 0x6, PseudoVSSE8_V_MF4 }, // 34 + { 0x0, 0x1, 0x3, 0x7, PseudoVSSE8_V_MF2 }, // 35 + { 0x0, 0x1, 0x4, 0x0, PseudoVSSE16_V_M1 }, // 36 + { 0x0, 0x1, 0x4, 0x1, PseudoVSSE16_V_M2 }, // 37 + { 0x0, 0x1, 0x4, 0x2, PseudoVSSE16_V_M4 }, // 38 + { 0x0, 0x1, 0x4, 0x3, PseudoVSSE16_V_M8 }, // 39 + { 0x0, 0x1, 0x4, 0x6, PseudoVSSE16_V_MF4 }, // 40 + { 0x0, 0x1, 0x4, 0x7, PseudoVSSE16_V_MF2 }, // 41 + { 0x0, 0x1, 0x5, 0x0, PseudoVSSE32_V_M1 }, // 42 + { 0x0, 0x1, 0x5, 0x1, PseudoVSSE32_V_M2 }, // 43 + { 0x0, 0x1, 0x5, 0x2, PseudoVSSE32_V_M4 }, // 44 + { 0x0, 0x1, 0x5, 0x3, PseudoVSSE32_V_M8 }, // 45 + { 0x0, 0x1, 0x5, 0x7, PseudoVSSE32_V_MF2 }, // 46 + { 0x0, 0x1, 0x6, 0x0, PseudoVSSE64_V_M1 }, // 47 + { 0x0, 0x1, 0x6, 0x1, PseudoVSSE64_V_M2 }, // 48 + { 0x0, 0x1, 0x6, 0x2, PseudoVSSE64_V_M4 }, // 49 + { 0x0, 0x1, 0x6, 0x3, PseudoVSSE64_V_M8 }, // 50 + { 0x1, 0x0, 0x3, 0x0, PseudoVSE8_V_M1_MASK }, // 51 + { 0x1, 0x0, 0x3, 0x1, PseudoVSE8_V_M2_MASK }, // 52 + { 0x1, 0x0, 0x3, 0x2, PseudoVSE8_V_M4_MASK }, // 53 + { 0x1, 0x0, 0x3, 0x3, PseudoVSE8_V_M8_MASK }, // 54 + { 0x1, 0x0, 0x3, 0x5, PseudoVSE8_V_MF8_MASK }, // 55 + { 0x1, 0x0, 0x3, 0x6, PseudoVSE8_V_MF4_MASK }, // 56 + { 0x1, 0x0, 0x3, 0x7, PseudoVSE8_V_MF2_MASK }, // 57 + { 0x1, 0x0, 0x4, 0x0, PseudoVSE16_V_M1_MASK }, // 58 + { 0x1, 0x0, 0x4, 0x1, PseudoVSE16_V_M2_MASK }, // 59 + { 0x1, 0x0, 0x4, 0x2, PseudoVSE16_V_M4_MASK }, // 60 + { 0x1, 0x0, 0x4, 0x3, PseudoVSE16_V_M8_MASK }, // 61 + { 0x1, 0x0, 0x4, 0x6, PseudoVSE16_V_MF4_MASK }, // 62 + { 0x1, 0x0, 0x4, 0x7, PseudoVSE16_V_MF2_MASK }, // 63 + { 0x1, 0x0, 0x5, 0x0, PseudoVSE32_V_M1_MASK }, // 64 + { 0x1, 0x0, 0x5, 0x1, PseudoVSE32_V_M2_MASK }, // 65 + { 0x1, 0x0, 0x5, 0x2, PseudoVSE32_V_M4_MASK }, // 66 + { 0x1, 0x0, 0x5, 0x3, PseudoVSE32_V_M8_MASK }, // 67 + { 0x1, 0x0, 0x5, 0x7, PseudoVSE32_V_MF2_MASK }, // 68 + { 0x1, 0x0, 0x6, 0x0, PseudoVSE64_V_M1_MASK }, // 69 + { 0x1, 0x0, 0x6, 0x1, PseudoVSE64_V_M2_MASK }, // 70 + { 0x1, 0x0, 0x6, 0x2, PseudoVSE64_V_M4_MASK }, // 71 + { 0x1, 0x0, 0x6, 0x3, PseudoVSE64_V_M8_MASK }, // 72 + { 0x1, 0x1, 0x3, 0x0, PseudoVSSE8_V_M1_MASK }, // 73 + { 0x1, 0x1, 0x3, 0x1, PseudoVSSE8_V_M2_MASK }, // 74 + { 0x1, 0x1, 0x3, 0x2, PseudoVSSE8_V_M4_MASK }, // 75 + { 0x1, 0x1, 0x3, 0x3, PseudoVSSE8_V_M8_MASK }, // 76 + { 0x1, 0x1, 0x3, 0x5, PseudoVSSE8_V_MF8_MASK }, // 77 + { 0x1, 0x1, 0x3, 0x6, PseudoVSSE8_V_MF4_MASK }, // 78 + { 0x1, 0x1, 0x3, 0x7, PseudoVSSE8_V_MF2_MASK }, // 79 + { 0x1, 0x1, 0x4, 0x0, PseudoVSSE16_V_M1_MASK }, // 80 + { 0x1, 0x1, 0x4, 0x1, PseudoVSSE16_V_M2_MASK }, // 81 + { 0x1, 0x1, 0x4, 0x2, PseudoVSSE16_V_M4_MASK }, // 82 + { 0x1, 0x1, 0x4, 0x3, PseudoVSSE16_V_M8_MASK }, // 83 + { 0x1, 0x1, 0x4, 0x6, PseudoVSSE16_V_MF4_MASK }, // 84 + { 0x1, 0x1, 0x4, 0x7, PseudoVSSE16_V_MF2_MASK }, // 85 + { 0x1, 0x1, 0x5, 0x0, PseudoVSSE32_V_M1_MASK }, // 86 + { 0x1, 0x1, 0x5, 0x1, PseudoVSSE32_V_M2_MASK }, // 87 + { 0x1, 0x1, 0x5, 0x2, PseudoVSSE32_V_M4_MASK }, // 88 + { 0x1, 0x1, 0x5, 0x3, PseudoVSSE32_V_M8_MASK }, // 89 + { 0x1, 0x1, 0x5, 0x7, PseudoVSSE32_V_MF2_MASK }, // 90 + { 0x1, 0x1, 0x6, 0x0, PseudoVSSE64_V_M1_MASK }, // 91 + { 0x1, 0x1, 0x6, 0x1, PseudoVSSE64_V_M2_MASK }, // 92 + { 0x1, 0x1, 0x6, 0x2, PseudoVSSE64_V_M4_MASK }, // 93 + { 0x1, 0x1, 0x6, 0x3, PseudoVSSE64_V_M8_MASK }, // 94 + }; + +const RISCV_VSEPseudo *RISCV_getVSEPseudo(uint8_t Masked, uint8_t Strided, uint8_t Log2SEW, uint8_t LMUL) { + unsigned i = binsearch_IndexTypeEncoding(Index, ARR_SIZE(Index), MaskedStridedLog2SEWLMUL); + if (i == -1) + return NULL; + else + return &RISCVVSETable[Index[i].index]; +} + +#endif + +#ifdef GET_RISCVVSSEGTable_IMPL +static const RISCV_VSSEGPseudo RISCVVSSEGTable[] = { + { 0x2, 0x0, 0x0, 0x3, 0x0, PseudoVSSEG2E8_V_M1 }, // 0 + { 0x2, 0x0, 0x0, 0x3, 0x1, PseudoVSSEG2E8_V_M2 }, // 1 + { 0x2, 0x0, 0x0, 0x3, 0x2, PseudoVSSEG2E8_V_M4 }, // 2 + { 0x2, 0x0, 0x0, 0x3, 0x5, PseudoVSSEG2E8_V_MF8 }, // 3 + { 0x2, 0x0, 0x0, 0x3, 0x6, PseudoVSSEG2E8_V_MF4 }, // 4 + { 0x2, 0x0, 0x0, 0x3, 0x7, PseudoVSSEG2E8_V_MF2 }, // 5 + { 0x2, 0x0, 0x0, 0x4, 0x0, PseudoVSSEG2E16_V_M1 }, // 6 + { 0x2, 0x0, 0x0, 0x4, 0x1, PseudoVSSEG2E16_V_M2 }, // 7 + { 0x2, 0x0, 0x0, 0x4, 0x2, PseudoVSSEG2E16_V_M4 }, // 8 + { 0x2, 0x0, 0x0, 0x4, 0x6, PseudoVSSEG2E16_V_MF4 }, // 9 + { 0x2, 0x0, 0x0, 0x4, 0x7, PseudoVSSEG2E16_V_MF2 }, // 10 + { 0x2, 0x0, 0x0, 0x5, 0x0, PseudoVSSEG2E32_V_M1 }, // 11 + { 0x2, 0x0, 0x0, 0x5, 0x1, PseudoVSSEG2E32_V_M2 }, // 12 + { 0x2, 0x0, 0x0, 0x5, 0x2, PseudoVSSEG2E32_V_M4 }, // 13 + { 0x2, 0x0, 0x0, 0x5, 0x7, PseudoVSSEG2E32_V_MF2 }, // 14 + { 0x2, 0x0, 0x0, 0x6, 0x0, PseudoVSSEG2E64_V_M1 }, // 15 + { 0x2, 0x0, 0x0, 0x6, 0x1, PseudoVSSEG2E64_V_M2 }, // 16 + { 0x2, 0x0, 0x0, 0x6, 0x2, PseudoVSSEG2E64_V_M4 }, // 17 + { 0x2, 0x0, 0x1, 0x3, 0x0, PseudoVSSSEG2E8_V_M1 }, // 18 + { 0x2, 0x0, 0x1, 0x3, 0x1, PseudoVSSSEG2E8_V_M2 }, // 19 + { 0x2, 0x0, 0x1, 0x3, 0x2, PseudoVSSSEG2E8_V_M4 }, // 20 + { 0x2, 0x0, 0x1, 0x3, 0x5, PseudoVSSSEG2E8_V_MF8 }, // 21 + { 0x2, 0x0, 0x1, 0x3, 0x6, PseudoVSSSEG2E8_V_MF4 }, // 22 + { 0x2, 0x0, 0x1, 0x3, 0x7, PseudoVSSSEG2E8_V_MF2 }, // 23 + { 0x2, 0x0, 0x1, 0x4, 0x0, PseudoVSSSEG2E16_V_M1 }, // 24 + { 0x2, 0x0, 0x1, 0x4, 0x1, PseudoVSSSEG2E16_V_M2 }, // 25 + { 0x2, 0x0, 0x1, 0x4, 0x2, PseudoVSSSEG2E16_V_M4 }, // 26 + { 0x2, 0x0, 0x1, 0x4, 0x6, PseudoVSSSEG2E16_V_MF4 }, // 27 + { 0x2, 0x0, 0x1, 0x4, 0x7, PseudoVSSSEG2E16_V_MF2 }, // 28 + { 0x2, 0x0, 0x1, 0x5, 0x0, PseudoVSSSEG2E32_V_M1 }, // 29 + { 0x2, 0x0, 0x1, 0x5, 0x1, PseudoVSSSEG2E32_V_M2 }, // 30 + { 0x2, 0x0, 0x1, 0x5, 0x2, PseudoVSSSEG2E32_V_M4 }, // 31 + { 0x2, 0x0, 0x1, 0x5, 0x7, PseudoVSSSEG2E32_V_MF2 }, // 32 + { 0x2, 0x0, 0x1, 0x6, 0x0, PseudoVSSSEG2E64_V_M1 }, // 33 + { 0x2, 0x0, 0x1, 0x6, 0x1, PseudoVSSSEG2E64_V_M2 }, // 34 + { 0x2, 0x0, 0x1, 0x6, 0x2, PseudoVSSSEG2E64_V_M4 }, // 35 + { 0x2, 0x1, 0x0, 0x3, 0x0, PseudoVSSEG2E8_V_M1_MASK }, // 36 + { 0x2, 0x1, 0x0, 0x3, 0x1, PseudoVSSEG2E8_V_M2_MASK }, // 37 + { 0x2, 0x1, 0x0, 0x3, 0x2, PseudoVSSEG2E8_V_M4_MASK }, // 38 + { 0x2, 0x1, 0x0, 0x3, 0x5, PseudoVSSEG2E8_V_MF8_MASK }, // 39 + { 0x2, 0x1, 0x0, 0x3, 0x6, PseudoVSSEG2E8_V_MF4_MASK }, // 40 + { 0x2, 0x1, 0x0, 0x3, 0x7, PseudoVSSEG2E8_V_MF2_MASK }, // 41 + { 0x2, 0x1, 0x0, 0x4, 0x0, PseudoVSSEG2E16_V_M1_MASK }, // 42 + { 0x2, 0x1, 0x0, 0x4, 0x1, PseudoVSSEG2E16_V_M2_MASK }, // 43 + { 0x2, 0x1, 0x0, 0x4, 0x2, PseudoVSSEG2E16_V_M4_MASK }, // 44 + { 0x2, 0x1, 0x0, 0x4, 0x6, PseudoVSSEG2E16_V_MF4_MASK }, // 45 + { 0x2, 0x1, 0x0, 0x4, 0x7, PseudoVSSEG2E16_V_MF2_MASK }, // 46 + { 0x2, 0x1, 0x0, 0x5, 0x0, PseudoVSSEG2E32_V_M1_MASK }, // 47 + { 0x2, 0x1, 0x0, 0x5, 0x1, PseudoVSSEG2E32_V_M2_MASK }, // 48 + { 0x2, 0x1, 0x0, 0x5, 0x2, PseudoVSSEG2E32_V_M4_MASK }, // 49 + { 0x2, 0x1, 0x0, 0x5, 0x7, PseudoVSSEG2E32_V_MF2_MASK }, // 50 + { 0x2, 0x1, 0x0, 0x6, 0x0, PseudoVSSEG2E64_V_M1_MASK }, // 51 + { 0x2, 0x1, 0x0, 0x6, 0x1, PseudoVSSEG2E64_V_M2_MASK }, // 52 + { 0x2, 0x1, 0x0, 0x6, 0x2, PseudoVSSEG2E64_V_M4_MASK }, // 53 + { 0x2, 0x1, 0x1, 0x3, 0x0, PseudoVSSSEG2E8_V_M1_MASK }, // 54 + { 0x2, 0x1, 0x1, 0x3, 0x1, PseudoVSSSEG2E8_V_M2_MASK }, // 55 + { 0x2, 0x1, 0x1, 0x3, 0x2, PseudoVSSSEG2E8_V_M4_MASK }, // 56 + { 0x2, 0x1, 0x1, 0x3, 0x5, PseudoVSSSEG2E8_V_MF8_MASK }, // 57 + { 0x2, 0x1, 0x1, 0x3, 0x6, PseudoVSSSEG2E8_V_MF4_MASK }, // 58 + { 0x2, 0x1, 0x1, 0x3, 0x7, PseudoVSSSEG2E8_V_MF2_MASK }, // 59 + { 0x2, 0x1, 0x1, 0x4, 0x0, PseudoVSSSEG2E16_V_M1_MASK }, // 60 + { 0x2, 0x1, 0x1, 0x4, 0x1, PseudoVSSSEG2E16_V_M2_MASK }, // 61 + { 0x2, 0x1, 0x1, 0x4, 0x2, PseudoVSSSEG2E16_V_M4_MASK }, // 62 + { 0x2, 0x1, 0x1, 0x4, 0x6, PseudoVSSSEG2E16_V_MF4_MASK }, // 63 + { 0x2, 0x1, 0x1, 0x4, 0x7, PseudoVSSSEG2E16_V_MF2_MASK }, // 64 + { 0x2, 0x1, 0x1, 0x5, 0x0, PseudoVSSSEG2E32_V_M1_MASK }, // 65 + { 0x2, 0x1, 0x1, 0x5, 0x1, PseudoVSSSEG2E32_V_M2_MASK }, // 66 + { 0x2, 0x1, 0x1, 0x5, 0x2, PseudoVSSSEG2E32_V_M4_MASK }, // 67 + { 0x2, 0x1, 0x1, 0x5, 0x7, PseudoVSSSEG2E32_V_MF2_MASK }, // 68 + { 0x2, 0x1, 0x1, 0x6, 0x0, PseudoVSSSEG2E64_V_M1_MASK }, // 69 + { 0x2, 0x1, 0x1, 0x6, 0x1, PseudoVSSSEG2E64_V_M2_MASK }, // 70 + { 0x2, 0x1, 0x1, 0x6, 0x2, PseudoVSSSEG2E64_V_M4_MASK }, // 71 + { 0x3, 0x0, 0x0, 0x3, 0x0, PseudoVSSEG3E8_V_M1 }, // 72 + { 0x3, 0x0, 0x0, 0x3, 0x1, PseudoVSSEG3E8_V_M2 }, // 73 + { 0x3, 0x0, 0x0, 0x3, 0x5, PseudoVSSEG3E8_V_MF8 }, // 74 + { 0x3, 0x0, 0x0, 0x3, 0x6, PseudoVSSEG3E8_V_MF4 }, // 75 + { 0x3, 0x0, 0x0, 0x3, 0x7, PseudoVSSEG3E8_V_MF2 }, // 76 + { 0x3, 0x0, 0x0, 0x4, 0x0, PseudoVSSEG3E16_V_M1 }, // 77 + { 0x3, 0x0, 0x0, 0x4, 0x1, PseudoVSSEG3E16_V_M2 }, // 78 + { 0x3, 0x0, 0x0, 0x4, 0x6, PseudoVSSEG3E16_V_MF4 }, // 79 + { 0x3, 0x0, 0x0, 0x4, 0x7, PseudoVSSEG3E16_V_MF2 }, // 80 + { 0x3, 0x0, 0x0, 0x5, 0x0, PseudoVSSEG3E32_V_M1 }, // 81 + { 0x3, 0x0, 0x0, 0x5, 0x1, PseudoVSSEG3E32_V_M2 }, // 82 + { 0x3, 0x0, 0x0, 0x5, 0x7, PseudoVSSEG3E32_V_MF2 }, // 83 + { 0x3, 0x0, 0x0, 0x6, 0x0, PseudoVSSEG3E64_V_M1 }, // 84 + { 0x3, 0x0, 0x0, 0x6, 0x1, PseudoVSSEG3E64_V_M2 }, // 85 + { 0x3, 0x0, 0x1, 0x3, 0x0, PseudoVSSSEG3E8_V_M1 }, // 86 + { 0x3, 0x0, 0x1, 0x3, 0x1, PseudoVSSSEG3E8_V_M2 }, // 87 + { 0x3, 0x0, 0x1, 0x3, 0x5, PseudoVSSSEG3E8_V_MF8 }, // 88 + { 0x3, 0x0, 0x1, 0x3, 0x6, PseudoVSSSEG3E8_V_MF4 }, // 89 + { 0x3, 0x0, 0x1, 0x3, 0x7, PseudoVSSSEG3E8_V_MF2 }, // 90 + { 0x3, 0x0, 0x1, 0x4, 0x0, PseudoVSSSEG3E16_V_M1 }, // 91 + { 0x3, 0x0, 0x1, 0x4, 0x1, PseudoVSSSEG3E16_V_M2 }, // 92 + { 0x3, 0x0, 0x1, 0x4, 0x6, PseudoVSSSEG3E16_V_MF4 }, // 93 + { 0x3, 0x0, 0x1, 0x4, 0x7, PseudoVSSSEG3E16_V_MF2 }, // 94 + { 0x3, 0x0, 0x1, 0x5, 0x0, PseudoVSSSEG3E32_V_M1 }, // 95 + { 0x3, 0x0, 0x1, 0x5, 0x1, PseudoVSSSEG3E32_V_M2 }, // 96 + { 0x3, 0x0, 0x1, 0x5, 0x7, PseudoVSSSEG3E32_V_MF2 }, // 97 + { 0x3, 0x0, 0x1, 0x6, 0x0, PseudoVSSSEG3E64_V_M1 }, // 98 + { 0x3, 0x0, 0x1, 0x6, 0x1, PseudoVSSSEG3E64_V_M2 }, // 99 + { 0x3, 0x1, 0x0, 0x3, 0x0, PseudoVSSEG3E8_V_M1_MASK }, // 100 + { 0x3, 0x1, 0x0, 0x3, 0x1, PseudoVSSEG3E8_V_M2_MASK }, // 101 + { 0x3, 0x1, 0x0, 0x3, 0x5, PseudoVSSEG3E8_V_MF8_MASK }, // 102 + { 0x3, 0x1, 0x0, 0x3, 0x6, PseudoVSSEG3E8_V_MF4_MASK }, // 103 + { 0x3, 0x1, 0x0, 0x3, 0x7, PseudoVSSEG3E8_V_MF2_MASK }, // 104 + { 0x3, 0x1, 0x0, 0x4, 0x0, PseudoVSSEG3E16_V_M1_MASK }, // 105 + { 0x3, 0x1, 0x0, 0x4, 0x1, PseudoVSSEG3E16_V_M2_MASK }, // 106 + { 0x3, 0x1, 0x0, 0x4, 0x6, PseudoVSSEG3E16_V_MF4_MASK }, // 107 + { 0x3, 0x1, 0x0, 0x4, 0x7, PseudoVSSEG3E16_V_MF2_MASK }, // 108 + { 0x3, 0x1, 0x0, 0x5, 0x0, PseudoVSSEG3E32_V_M1_MASK }, // 109 + { 0x3, 0x1, 0x0, 0x5, 0x1, PseudoVSSEG3E32_V_M2_MASK }, // 110 + { 0x3, 0x1, 0x0, 0x5, 0x7, PseudoVSSEG3E32_V_MF2_MASK }, // 111 + { 0x3, 0x1, 0x0, 0x6, 0x0, PseudoVSSEG3E64_V_M1_MASK }, // 112 + { 0x3, 0x1, 0x0, 0x6, 0x1, PseudoVSSEG3E64_V_M2_MASK }, // 113 + { 0x3, 0x1, 0x1, 0x3, 0x0, PseudoVSSSEG3E8_V_M1_MASK }, // 114 + { 0x3, 0x1, 0x1, 0x3, 0x1, PseudoVSSSEG3E8_V_M2_MASK }, // 115 + { 0x3, 0x1, 0x1, 0x3, 0x5, PseudoVSSSEG3E8_V_MF8_MASK }, // 116 + { 0x3, 0x1, 0x1, 0x3, 0x6, PseudoVSSSEG3E8_V_MF4_MASK }, // 117 + { 0x3, 0x1, 0x1, 0x3, 0x7, PseudoVSSSEG3E8_V_MF2_MASK }, // 118 + { 0x3, 0x1, 0x1, 0x4, 0x0, PseudoVSSSEG3E16_V_M1_MASK }, // 119 + { 0x3, 0x1, 0x1, 0x4, 0x1, PseudoVSSSEG3E16_V_M2_MASK }, // 120 + { 0x3, 0x1, 0x1, 0x4, 0x6, PseudoVSSSEG3E16_V_MF4_MASK }, // 121 + { 0x3, 0x1, 0x1, 0x4, 0x7, PseudoVSSSEG3E16_V_MF2_MASK }, // 122 + { 0x3, 0x1, 0x1, 0x5, 0x0, PseudoVSSSEG3E32_V_M1_MASK }, // 123 + { 0x3, 0x1, 0x1, 0x5, 0x1, PseudoVSSSEG3E32_V_M2_MASK }, // 124 + { 0x3, 0x1, 0x1, 0x5, 0x7, PseudoVSSSEG3E32_V_MF2_MASK }, // 125 + { 0x3, 0x1, 0x1, 0x6, 0x0, PseudoVSSSEG3E64_V_M1_MASK }, // 126 + { 0x3, 0x1, 0x1, 0x6, 0x1, PseudoVSSSEG3E64_V_M2_MASK }, // 127 + { 0x4, 0x0, 0x0, 0x3, 0x0, PseudoVSSEG4E8_V_M1 }, // 128 + { 0x4, 0x0, 0x0, 0x3, 0x1, PseudoVSSEG4E8_V_M2 }, // 129 + { 0x4, 0x0, 0x0, 0x3, 0x5, PseudoVSSEG4E8_V_MF8 }, // 130 + { 0x4, 0x0, 0x0, 0x3, 0x6, PseudoVSSEG4E8_V_MF4 }, // 131 + { 0x4, 0x0, 0x0, 0x3, 0x7, PseudoVSSEG4E8_V_MF2 }, // 132 + { 0x4, 0x0, 0x0, 0x4, 0x0, PseudoVSSEG4E16_V_M1 }, // 133 + { 0x4, 0x0, 0x0, 0x4, 0x1, PseudoVSSEG4E16_V_M2 }, // 134 + { 0x4, 0x0, 0x0, 0x4, 0x6, PseudoVSSEG4E16_V_MF4 }, // 135 + { 0x4, 0x0, 0x0, 0x4, 0x7, PseudoVSSEG4E16_V_MF2 }, // 136 + { 0x4, 0x0, 0x0, 0x5, 0x0, PseudoVSSEG4E32_V_M1 }, // 137 + { 0x4, 0x0, 0x0, 0x5, 0x1, PseudoVSSEG4E32_V_M2 }, // 138 + { 0x4, 0x0, 0x0, 0x5, 0x7, PseudoVSSEG4E32_V_MF2 }, // 139 + { 0x4, 0x0, 0x0, 0x6, 0x0, PseudoVSSEG4E64_V_M1 }, // 140 + { 0x4, 0x0, 0x0, 0x6, 0x1, PseudoVSSEG4E64_V_M2 }, // 141 + { 0x4, 0x0, 0x1, 0x3, 0x0, PseudoVSSSEG4E8_V_M1 }, // 142 + { 0x4, 0x0, 0x1, 0x3, 0x1, PseudoVSSSEG4E8_V_M2 }, // 143 + { 0x4, 0x0, 0x1, 0x3, 0x5, PseudoVSSSEG4E8_V_MF8 }, // 144 + { 0x4, 0x0, 0x1, 0x3, 0x6, PseudoVSSSEG4E8_V_MF4 }, // 145 + { 0x4, 0x0, 0x1, 0x3, 0x7, PseudoVSSSEG4E8_V_MF2 }, // 146 + { 0x4, 0x0, 0x1, 0x4, 0x0, PseudoVSSSEG4E16_V_M1 }, // 147 + { 0x4, 0x0, 0x1, 0x4, 0x1, PseudoVSSSEG4E16_V_M2 }, // 148 + { 0x4, 0x0, 0x1, 0x4, 0x6, PseudoVSSSEG4E16_V_MF4 }, // 149 + { 0x4, 0x0, 0x1, 0x4, 0x7, PseudoVSSSEG4E16_V_MF2 }, // 150 + { 0x4, 0x0, 0x1, 0x5, 0x0, PseudoVSSSEG4E32_V_M1 }, // 151 + { 0x4, 0x0, 0x1, 0x5, 0x1, PseudoVSSSEG4E32_V_M2 }, // 152 + { 0x4, 0x0, 0x1, 0x5, 0x7, PseudoVSSSEG4E32_V_MF2 }, // 153 + { 0x4, 0x0, 0x1, 0x6, 0x0, PseudoVSSSEG4E64_V_M1 }, // 154 + { 0x4, 0x0, 0x1, 0x6, 0x1, PseudoVSSSEG4E64_V_M2 }, // 155 + { 0x4, 0x1, 0x0, 0x3, 0x0, PseudoVSSEG4E8_V_M1_MASK }, // 156 + { 0x4, 0x1, 0x0, 0x3, 0x1, PseudoVSSEG4E8_V_M2_MASK }, // 157 + { 0x4, 0x1, 0x0, 0x3, 0x5, PseudoVSSEG4E8_V_MF8_MASK }, // 158 + { 0x4, 0x1, 0x0, 0x3, 0x6, PseudoVSSEG4E8_V_MF4_MASK }, // 159 + { 0x4, 0x1, 0x0, 0x3, 0x7, PseudoVSSEG4E8_V_MF2_MASK }, // 160 + { 0x4, 0x1, 0x0, 0x4, 0x0, PseudoVSSEG4E16_V_M1_MASK }, // 161 + { 0x4, 0x1, 0x0, 0x4, 0x1, PseudoVSSEG4E16_V_M2_MASK }, // 162 + { 0x4, 0x1, 0x0, 0x4, 0x6, PseudoVSSEG4E16_V_MF4_MASK }, // 163 + { 0x4, 0x1, 0x0, 0x4, 0x7, PseudoVSSEG4E16_V_MF2_MASK }, // 164 + { 0x4, 0x1, 0x0, 0x5, 0x0, PseudoVSSEG4E32_V_M1_MASK }, // 165 + { 0x4, 0x1, 0x0, 0x5, 0x1, PseudoVSSEG4E32_V_M2_MASK }, // 166 + { 0x4, 0x1, 0x0, 0x5, 0x7, PseudoVSSEG4E32_V_MF2_MASK }, // 167 + { 0x4, 0x1, 0x0, 0x6, 0x0, PseudoVSSEG4E64_V_M1_MASK }, // 168 + { 0x4, 0x1, 0x0, 0x6, 0x1, PseudoVSSEG4E64_V_M2_MASK }, // 169 + { 0x4, 0x1, 0x1, 0x3, 0x0, PseudoVSSSEG4E8_V_M1_MASK }, // 170 + { 0x4, 0x1, 0x1, 0x3, 0x1, PseudoVSSSEG4E8_V_M2_MASK }, // 171 + { 0x4, 0x1, 0x1, 0x3, 0x5, PseudoVSSSEG4E8_V_MF8_MASK }, // 172 + { 0x4, 0x1, 0x1, 0x3, 0x6, PseudoVSSSEG4E8_V_MF4_MASK }, // 173 + { 0x4, 0x1, 0x1, 0x3, 0x7, PseudoVSSSEG4E8_V_MF2_MASK }, // 174 + { 0x4, 0x1, 0x1, 0x4, 0x0, PseudoVSSSEG4E16_V_M1_MASK }, // 175 + { 0x4, 0x1, 0x1, 0x4, 0x1, PseudoVSSSEG4E16_V_M2_MASK }, // 176 + { 0x4, 0x1, 0x1, 0x4, 0x6, PseudoVSSSEG4E16_V_MF4_MASK }, // 177 + { 0x4, 0x1, 0x1, 0x4, 0x7, PseudoVSSSEG4E16_V_MF2_MASK }, // 178 + { 0x4, 0x1, 0x1, 0x5, 0x0, PseudoVSSSEG4E32_V_M1_MASK }, // 179 + { 0x4, 0x1, 0x1, 0x5, 0x1, PseudoVSSSEG4E32_V_M2_MASK }, // 180 + { 0x4, 0x1, 0x1, 0x5, 0x7, PseudoVSSSEG4E32_V_MF2_MASK }, // 181 + { 0x4, 0x1, 0x1, 0x6, 0x0, PseudoVSSSEG4E64_V_M1_MASK }, // 182 + { 0x4, 0x1, 0x1, 0x6, 0x1, PseudoVSSSEG4E64_V_M2_MASK }, // 183 + { 0x5, 0x0, 0x0, 0x3, 0x0, PseudoVSSEG5E8_V_M1 }, // 184 + { 0x5, 0x0, 0x0, 0x3, 0x5, PseudoVSSEG5E8_V_MF8 }, // 185 + { 0x5, 0x0, 0x0, 0x3, 0x6, PseudoVSSEG5E8_V_MF4 }, // 186 + { 0x5, 0x0, 0x0, 0x3, 0x7, PseudoVSSEG5E8_V_MF2 }, // 187 + { 0x5, 0x0, 0x0, 0x4, 0x0, PseudoVSSEG5E16_V_M1 }, // 188 + { 0x5, 0x0, 0x0, 0x4, 0x6, PseudoVSSEG5E16_V_MF4 }, // 189 + { 0x5, 0x0, 0x0, 0x4, 0x7, PseudoVSSEG5E16_V_MF2 }, // 190 + { 0x5, 0x0, 0x0, 0x5, 0x0, PseudoVSSEG5E32_V_M1 }, // 191 + { 0x5, 0x0, 0x0, 0x5, 0x7, PseudoVSSEG5E32_V_MF2 }, // 192 + { 0x5, 0x0, 0x0, 0x6, 0x0, PseudoVSSEG5E64_V_M1 }, // 193 + { 0x5, 0x0, 0x1, 0x3, 0x0, PseudoVSSSEG5E8_V_M1 }, // 194 + { 0x5, 0x0, 0x1, 0x3, 0x5, PseudoVSSSEG5E8_V_MF8 }, // 195 + { 0x5, 0x0, 0x1, 0x3, 0x6, PseudoVSSSEG5E8_V_MF4 }, // 196 + { 0x5, 0x0, 0x1, 0x3, 0x7, PseudoVSSSEG5E8_V_MF2 }, // 197 + { 0x5, 0x0, 0x1, 0x4, 0x0, PseudoVSSSEG5E16_V_M1 }, // 198 + { 0x5, 0x0, 0x1, 0x4, 0x6, PseudoVSSSEG5E16_V_MF4 }, // 199 + { 0x5, 0x0, 0x1, 0x4, 0x7, PseudoVSSSEG5E16_V_MF2 }, // 200 + { 0x5, 0x0, 0x1, 0x5, 0x0, PseudoVSSSEG5E32_V_M1 }, // 201 + { 0x5, 0x0, 0x1, 0x5, 0x7, PseudoVSSSEG5E32_V_MF2 }, // 202 + { 0x5, 0x0, 0x1, 0x6, 0x0, PseudoVSSSEG5E64_V_M1 }, // 203 + { 0x5, 0x1, 0x0, 0x3, 0x0, PseudoVSSEG5E8_V_M1_MASK }, // 204 + { 0x5, 0x1, 0x0, 0x3, 0x5, PseudoVSSEG5E8_V_MF8_MASK }, // 205 + { 0x5, 0x1, 0x0, 0x3, 0x6, PseudoVSSEG5E8_V_MF4_MASK }, // 206 + { 0x5, 0x1, 0x0, 0x3, 0x7, PseudoVSSEG5E8_V_MF2_MASK }, // 207 + { 0x5, 0x1, 0x0, 0x4, 0x0, PseudoVSSEG5E16_V_M1_MASK }, // 208 + { 0x5, 0x1, 0x0, 0x4, 0x6, PseudoVSSEG5E16_V_MF4_MASK }, // 209 + { 0x5, 0x1, 0x0, 0x4, 0x7, PseudoVSSEG5E16_V_MF2_MASK }, // 210 + { 0x5, 0x1, 0x0, 0x5, 0x0, PseudoVSSEG5E32_V_M1_MASK }, // 211 + { 0x5, 0x1, 0x0, 0x5, 0x7, PseudoVSSEG5E32_V_MF2_MASK }, // 212 + { 0x5, 0x1, 0x0, 0x6, 0x0, PseudoVSSEG5E64_V_M1_MASK }, // 213 + { 0x5, 0x1, 0x1, 0x3, 0x0, PseudoVSSSEG5E8_V_M1_MASK }, // 214 + { 0x5, 0x1, 0x1, 0x3, 0x5, PseudoVSSSEG5E8_V_MF8_MASK }, // 215 + { 0x5, 0x1, 0x1, 0x3, 0x6, PseudoVSSSEG5E8_V_MF4_MASK }, // 216 + { 0x5, 0x1, 0x1, 0x3, 0x7, PseudoVSSSEG5E8_V_MF2_MASK }, // 217 + { 0x5, 0x1, 0x1, 0x4, 0x0, PseudoVSSSEG5E16_V_M1_MASK }, // 218 + { 0x5, 0x1, 0x1, 0x4, 0x6, PseudoVSSSEG5E16_V_MF4_MASK }, // 219 + { 0x5, 0x1, 0x1, 0x4, 0x7, PseudoVSSSEG5E16_V_MF2_MASK }, // 220 + { 0x5, 0x1, 0x1, 0x5, 0x0, PseudoVSSSEG5E32_V_M1_MASK }, // 221 + { 0x5, 0x1, 0x1, 0x5, 0x7, PseudoVSSSEG5E32_V_MF2_MASK }, // 222 + { 0x5, 0x1, 0x1, 0x6, 0x0, PseudoVSSSEG5E64_V_M1_MASK }, // 223 + { 0x6, 0x0, 0x0, 0x3, 0x0, PseudoVSSEG6E8_V_M1 }, // 224 + { 0x6, 0x0, 0x0, 0x3, 0x5, PseudoVSSEG6E8_V_MF8 }, // 225 + { 0x6, 0x0, 0x0, 0x3, 0x6, PseudoVSSEG6E8_V_MF4 }, // 226 + { 0x6, 0x0, 0x0, 0x3, 0x7, PseudoVSSEG6E8_V_MF2 }, // 227 + { 0x6, 0x0, 0x0, 0x4, 0x0, PseudoVSSEG6E16_V_M1 }, // 228 + { 0x6, 0x0, 0x0, 0x4, 0x6, PseudoVSSEG6E16_V_MF4 }, // 229 + { 0x6, 0x0, 0x0, 0x4, 0x7, PseudoVSSEG6E16_V_MF2 }, // 230 + { 0x6, 0x0, 0x0, 0x5, 0x0, PseudoVSSEG6E32_V_M1 }, // 231 + { 0x6, 0x0, 0x0, 0x5, 0x7, PseudoVSSEG6E32_V_MF2 }, // 232 + { 0x6, 0x0, 0x0, 0x6, 0x0, PseudoVSSEG6E64_V_M1 }, // 233 + { 0x6, 0x0, 0x1, 0x3, 0x0, PseudoVSSSEG6E8_V_M1 }, // 234 + { 0x6, 0x0, 0x1, 0x3, 0x5, PseudoVSSSEG6E8_V_MF8 }, // 235 + { 0x6, 0x0, 0x1, 0x3, 0x6, PseudoVSSSEG6E8_V_MF4 }, // 236 + { 0x6, 0x0, 0x1, 0x3, 0x7, PseudoVSSSEG6E8_V_MF2 }, // 237 + { 0x6, 0x0, 0x1, 0x4, 0x0, PseudoVSSSEG6E16_V_M1 }, // 238 + { 0x6, 0x0, 0x1, 0x4, 0x6, PseudoVSSSEG6E16_V_MF4 }, // 239 + { 0x6, 0x0, 0x1, 0x4, 0x7, PseudoVSSSEG6E16_V_MF2 }, // 240 + { 0x6, 0x0, 0x1, 0x5, 0x0, PseudoVSSSEG6E32_V_M1 }, // 241 + { 0x6, 0x0, 0x1, 0x5, 0x7, PseudoVSSSEG6E32_V_MF2 }, // 242 + { 0x6, 0x0, 0x1, 0x6, 0x0, PseudoVSSSEG6E64_V_M1 }, // 243 + { 0x6, 0x1, 0x0, 0x3, 0x0, PseudoVSSEG6E8_V_M1_MASK }, // 244 + { 0x6, 0x1, 0x0, 0x3, 0x5, PseudoVSSEG6E8_V_MF8_MASK }, // 245 + { 0x6, 0x1, 0x0, 0x3, 0x6, PseudoVSSEG6E8_V_MF4_MASK }, // 246 + { 0x6, 0x1, 0x0, 0x3, 0x7, PseudoVSSEG6E8_V_MF2_MASK }, // 247 + { 0x6, 0x1, 0x0, 0x4, 0x0, PseudoVSSEG6E16_V_M1_MASK }, // 248 + { 0x6, 0x1, 0x0, 0x4, 0x6, PseudoVSSEG6E16_V_MF4_MASK }, // 249 + { 0x6, 0x1, 0x0, 0x4, 0x7, PseudoVSSEG6E16_V_MF2_MASK }, // 250 + { 0x6, 0x1, 0x0, 0x5, 0x0, PseudoVSSEG6E32_V_M1_MASK }, // 251 + { 0x6, 0x1, 0x0, 0x5, 0x7, PseudoVSSEG6E32_V_MF2_MASK }, // 252 + { 0x6, 0x1, 0x0, 0x6, 0x0, PseudoVSSEG6E64_V_M1_MASK }, // 253 + { 0x6, 0x1, 0x1, 0x3, 0x0, PseudoVSSSEG6E8_V_M1_MASK }, // 254 + { 0x6, 0x1, 0x1, 0x3, 0x5, PseudoVSSSEG6E8_V_MF8_MASK }, // 255 + { 0x6, 0x1, 0x1, 0x3, 0x6, PseudoVSSSEG6E8_V_MF4_MASK }, // 256 + { 0x6, 0x1, 0x1, 0x3, 0x7, PseudoVSSSEG6E8_V_MF2_MASK }, // 257 + { 0x6, 0x1, 0x1, 0x4, 0x0, PseudoVSSSEG6E16_V_M1_MASK }, // 258 + { 0x6, 0x1, 0x1, 0x4, 0x6, PseudoVSSSEG6E16_V_MF4_MASK }, // 259 + { 0x6, 0x1, 0x1, 0x4, 0x7, PseudoVSSSEG6E16_V_MF2_MASK }, // 260 + { 0x6, 0x1, 0x1, 0x5, 0x0, PseudoVSSSEG6E32_V_M1_MASK }, // 261 + { 0x6, 0x1, 0x1, 0x5, 0x7, PseudoVSSSEG6E32_V_MF2_MASK }, // 262 + { 0x6, 0x1, 0x1, 0x6, 0x0, PseudoVSSSEG6E64_V_M1_MASK }, // 263 + { 0x7, 0x0, 0x0, 0x3, 0x0, PseudoVSSEG7E8_V_M1 }, // 264 + { 0x7, 0x0, 0x0, 0x3, 0x5, PseudoVSSEG7E8_V_MF8 }, // 265 + { 0x7, 0x0, 0x0, 0x3, 0x6, PseudoVSSEG7E8_V_MF4 }, // 266 + { 0x7, 0x0, 0x0, 0x3, 0x7, PseudoVSSEG7E8_V_MF2 }, // 267 + { 0x7, 0x0, 0x0, 0x4, 0x0, PseudoVSSEG7E16_V_M1 }, // 268 + { 0x7, 0x0, 0x0, 0x4, 0x6, PseudoVSSEG7E16_V_MF4 }, // 269 + { 0x7, 0x0, 0x0, 0x4, 0x7, PseudoVSSEG7E16_V_MF2 }, // 270 + { 0x7, 0x0, 0x0, 0x5, 0x0, PseudoVSSEG7E32_V_M1 }, // 271 + { 0x7, 0x0, 0x0, 0x5, 0x7, PseudoVSSEG7E32_V_MF2 }, // 272 + { 0x7, 0x0, 0x0, 0x6, 0x0, PseudoVSSEG7E64_V_M1 }, // 273 + { 0x7, 0x0, 0x1, 0x3, 0x0, PseudoVSSSEG7E8_V_M1 }, // 274 + { 0x7, 0x0, 0x1, 0x3, 0x5, PseudoVSSSEG7E8_V_MF8 }, // 275 + { 0x7, 0x0, 0x1, 0x3, 0x6, PseudoVSSSEG7E8_V_MF4 }, // 276 + { 0x7, 0x0, 0x1, 0x3, 0x7, PseudoVSSSEG7E8_V_MF2 }, // 277 + { 0x7, 0x0, 0x1, 0x4, 0x0, PseudoVSSSEG7E16_V_M1 }, // 278 + { 0x7, 0x0, 0x1, 0x4, 0x6, PseudoVSSSEG7E16_V_MF4 }, // 279 + { 0x7, 0x0, 0x1, 0x4, 0x7, PseudoVSSSEG7E16_V_MF2 }, // 280 + { 0x7, 0x0, 0x1, 0x5, 0x0, PseudoVSSSEG7E32_V_M1 }, // 281 + { 0x7, 0x0, 0x1, 0x5, 0x7, PseudoVSSSEG7E32_V_MF2 }, // 282 + { 0x7, 0x0, 0x1, 0x6, 0x0, PseudoVSSSEG7E64_V_M1 }, // 283 + { 0x7, 0x1, 0x0, 0x3, 0x0, PseudoVSSEG7E8_V_M1_MASK }, // 284 + { 0x7, 0x1, 0x0, 0x3, 0x5, PseudoVSSEG7E8_V_MF8_MASK }, // 285 + { 0x7, 0x1, 0x0, 0x3, 0x6, PseudoVSSEG7E8_V_MF4_MASK }, // 286 + { 0x7, 0x1, 0x0, 0x3, 0x7, PseudoVSSEG7E8_V_MF2_MASK }, // 287 + { 0x7, 0x1, 0x0, 0x4, 0x0, PseudoVSSEG7E16_V_M1_MASK }, // 288 + { 0x7, 0x1, 0x0, 0x4, 0x6, PseudoVSSEG7E16_V_MF4_MASK }, // 289 + { 0x7, 0x1, 0x0, 0x4, 0x7, PseudoVSSEG7E16_V_MF2_MASK }, // 290 + { 0x7, 0x1, 0x0, 0x5, 0x0, PseudoVSSEG7E32_V_M1_MASK }, // 291 + { 0x7, 0x1, 0x0, 0x5, 0x7, PseudoVSSEG7E32_V_MF2_MASK }, // 292 + { 0x7, 0x1, 0x0, 0x6, 0x0, PseudoVSSEG7E64_V_M1_MASK }, // 293 + { 0x7, 0x1, 0x1, 0x3, 0x0, PseudoVSSSEG7E8_V_M1_MASK }, // 294 + { 0x7, 0x1, 0x1, 0x3, 0x5, PseudoVSSSEG7E8_V_MF8_MASK }, // 295 + { 0x7, 0x1, 0x1, 0x3, 0x6, PseudoVSSSEG7E8_V_MF4_MASK }, // 296 + { 0x7, 0x1, 0x1, 0x3, 0x7, PseudoVSSSEG7E8_V_MF2_MASK }, // 297 + { 0x7, 0x1, 0x1, 0x4, 0x0, PseudoVSSSEG7E16_V_M1_MASK }, // 298 + { 0x7, 0x1, 0x1, 0x4, 0x6, PseudoVSSSEG7E16_V_MF4_MASK }, // 299 + { 0x7, 0x1, 0x1, 0x4, 0x7, PseudoVSSSEG7E16_V_MF2_MASK }, // 300 + { 0x7, 0x1, 0x1, 0x5, 0x0, PseudoVSSSEG7E32_V_M1_MASK }, // 301 + { 0x7, 0x1, 0x1, 0x5, 0x7, PseudoVSSSEG7E32_V_MF2_MASK }, // 302 + { 0x7, 0x1, 0x1, 0x6, 0x0, PseudoVSSSEG7E64_V_M1_MASK }, // 303 + { 0x8, 0x0, 0x0, 0x3, 0x0, PseudoVSSEG8E8_V_M1 }, // 304 + { 0x8, 0x0, 0x0, 0x3, 0x5, PseudoVSSEG8E8_V_MF8 }, // 305 + { 0x8, 0x0, 0x0, 0x3, 0x6, PseudoVSSEG8E8_V_MF4 }, // 306 + { 0x8, 0x0, 0x0, 0x3, 0x7, PseudoVSSEG8E8_V_MF2 }, // 307 + { 0x8, 0x0, 0x0, 0x4, 0x0, PseudoVSSEG8E16_V_M1 }, // 308 + { 0x8, 0x0, 0x0, 0x4, 0x6, PseudoVSSEG8E16_V_MF4 }, // 309 + { 0x8, 0x0, 0x0, 0x4, 0x7, PseudoVSSEG8E16_V_MF2 }, // 310 + { 0x8, 0x0, 0x0, 0x5, 0x0, PseudoVSSEG8E32_V_M1 }, // 311 + { 0x8, 0x0, 0x0, 0x5, 0x7, PseudoVSSEG8E32_V_MF2 }, // 312 + { 0x8, 0x0, 0x0, 0x6, 0x0, PseudoVSSEG8E64_V_M1 }, // 313 + { 0x8, 0x0, 0x1, 0x3, 0x0, PseudoVSSSEG8E8_V_M1 }, // 314 + { 0x8, 0x0, 0x1, 0x3, 0x5, PseudoVSSSEG8E8_V_MF8 }, // 315 + { 0x8, 0x0, 0x1, 0x3, 0x6, PseudoVSSSEG8E8_V_MF4 }, // 316 + { 0x8, 0x0, 0x1, 0x3, 0x7, PseudoVSSSEG8E8_V_MF2 }, // 317 + { 0x8, 0x0, 0x1, 0x4, 0x0, PseudoVSSSEG8E16_V_M1 }, // 318 + { 0x8, 0x0, 0x1, 0x4, 0x6, PseudoVSSSEG8E16_V_MF4 }, // 319 + { 0x8, 0x0, 0x1, 0x4, 0x7, PseudoVSSSEG8E16_V_MF2 }, // 320 + { 0x8, 0x0, 0x1, 0x5, 0x0, PseudoVSSSEG8E32_V_M1 }, // 321 + { 0x8, 0x0, 0x1, 0x5, 0x7, PseudoVSSSEG8E32_V_MF2 }, // 322 + { 0x8, 0x0, 0x1, 0x6, 0x0, PseudoVSSSEG8E64_V_M1 }, // 323 + { 0x8, 0x1, 0x0, 0x3, 0x0, PseudoVSSEG8E8_V_M1_MASK }, // 324 + { 0x8, 0x1, 0x0, 0x3, 0x5, PseudoVSSEG8E8_V_MF8_MASK }, // 325 + { 0x8, 0x1, 0x0, 0x3, 0x6, PseudoVSSEG8E8_V_MF4_MASK }, // 326 + { 0x8, 0x1, 0x0, 0x3, 0x7, PseudoVSSEG8E8_V_MF2_MASK }, // 327 + { 0x8, 0x1, 0x0, 0x4, 0x0, PseudoVSSEG8E16_V_M1_MASK }, // 328 + { 0x8, 0x1, 0x0, 0x4, 0x6, PseudoVSSEG8E16_V_MF4_MASK }, // 329 + { 0x8, 0x1, 0x0, 0x4, 0x7, PseudoVSSEG8E16_V_MF2_MASK }, // 330 + { 0x8, 0x1, 0x0, 0x5, 0x0, PseudoVSSEG8E32_V_M1_MASK }, // 331 + { 0x8, 0x1, 0x0, 0x5, 0x7, PseudoVSSEG8E32_V_MF2_MASK }, // 332 + { 0x8, 0x1, 0x0, 0x6, 0x0, PseudoVSSEG8E64_V_M1_MASK }, // 333 + { 0x8, 0x1, 0x1, 0x3, 0x0, PseudoVSSSEG8E8_V_M1_MASK }, // 334 + { 0x8, 0x1, 0x1, 0x3, 0x5, PseudoVSSSEG8E8_V_MF8_MASK }, // 335 + { 0x8, 0x1, 0x1, 0x3, 0x6, PseudoVSSSEG8E8_V_MF4_MASK }, // 336 + { 0x8, 0x1, 0x1, 0x3, 0x7, PseudoVSSSEG8E8_V_MF2_MASK }, // 337 + { 0x8, 0x1, 0x1, 0x4, 0x0, PseudoVSSSEG8E16_V_M1_MASK }, // 338 + { 0x8, 0x1, 0x1, 0x4, 0x6, PseudoVSSSEG8E16_V_MF4_MASK }, // 339 + { 0x8, 0x1, 0x1, 0x4, 0x7, PseudoVSSSEG8E16_V_MF2_MASK }, // 340 + { 0x8, 0x1, 0x1, 0x5, 0x0, PseudoVSSSEG8E32_V_M1_MASK }, // 341 + { 0x8, 0x1, 0x1, 0x5, 0x7, PseudoVSSSEG8E32_V_MF2_MASK }, // 342 + { 0x8, 0x1, 0x1, 0x6, 0x0, PseudoVSSSEG8E64_V_M1_MASK }, // 343 + }; + +const RISCV_VSSEGPseudo *RISCV_getVSSEGPseudo(uint8_t NF, uint8_t Masked, uint8_t Strided, uint8_t Log2SEW, uint8_t LMUL) { + unsigned i = binsearch_IndexTypeEncoding(Index, ARR_SIZE(Index), NFMaskedStridedLog2SEWLMUL); + if (i == -1) + return NULL; + else + return &RISCVVSSEGTable[Index[i].index]; +} + +#endif + +#ifdef GET_RISCVVSXSEGTable_IMPL +static const RISCV_VSXSEGPseudo RISCVVSXSEGTable[] = { + { 0x2, 0x0, 0x0, 0x3, 0x0, 0x0, PseudoVSUXSEG2EI8_V_M1_M1 }, // 0 + { 0x2, 0x0, 0x0, 0x3, 0x0, 0x5, PseudoVSUXSEG2EI8_V_MF8_M1 }, // 1 + { 0x2, 0x0, 0x0, 0x3, 0x0, 0x6, PseudoVSUXSEG2EI8_V_MF4_M1 }, // 2 + { 0x2, 0x0, 0x0, 0x3, 0x0, 0x7, PseudoVSUXSEG2EI8_V_MF2_M1 }, // 3 + { 0x2, 0x0, 0x0, 0x3, 0x1, 0x0, PseudoVSUXSEG2EI8_V_M1_M2 }, // 4 + { 0x2, 0x0, 0x0, 0x3, 0x1, 0x1, PseudoVSUXSEG2EI8_V_M2_M2 }, // 5 + { 0x2, 0x0, 0x0, 0x3, 0x1, 0x6, PseudoVSUXSEG2EI8_V_MF4_M2 }, // 6 + { 0x2, 0x0, 0x0, 0x3, 0x1, 0x7, PseudoVSUXSEG2EI8_V_MF2_M2 }, // 7 + { 0x2, 0x0, 0x0, 0x3, 0x2, 0x0, PseudoVSUXSEG2EI8_V_M1_M4 }, // 8 + { 0x2, 0x0, 0x0, 0x3, 0x2, 0x1, PseudoVSUXSEG2EI8_V_M2_M4 }, // 9 + { 0x2, 0x0, 0x0, 0x3, 0x2, 0x2, PseudoVSUXSEG2EI8_V_M4_M4 }, // 10 + { 0x2, 0x0, 0x0, 0x3, 0x2, 0x7, PseudoVSUXSEG2EI8_V_MF2_M4 }, // 11 + { 0x2, 0x0, 0x0, 0x3, 0x5, 0x5, PseudoVSUXSEG2EI8_V_MF8_MF8 }, // 12 + { 0x2, 0x0, 0x0, 0x3, 0x6, 0x5, PseudoVSUXSEG2EI8_V_MF8_MF4 }, // 13 + { 0x2, 0x0, 0x0, 0x3, 0x6, 0x6, PseudoVSUXSEG2EI8_V_MF4_MF4 }, // 14 + { 0x2, 0x0, 0x0, 0x3, 0x7, 0x5, PseudoVSUXSEG2EI8_V_MF8_MF2 }, // 15 + { 0x2, 0x0, 0x0, 0x3, 0x7, 0x6, PseudoVSUXSEG2EI8_V_MF4_MF2 }, // 16 + { 0x2, 0x0, 0x0, 0x3, 0x7, 0x7, PseudoVSUXSEG2EI8_V_MF2_MF2 }, // 17 + { 0x2, 0x0, 0x0, 0x4, 0x0, 0x0, PseudoVSUXSEG2EI16_V_M1_M1 }, // 18 + { 0x2, 0x0, 0x0, 0x4, 0x0, 0x1, PseudoVSUXSEG2EI16_V_M2_M1 }, // 19 + { 0x2, 0x0, 0x0, 0x4, 0x0, 0x6, PseudoVSUXSEG2EI16_V_MF4_M1 }, // 20 + { 0x2, 0x0, 0x0, 0x4, 0x0, 0x7, PseudoVSUXSEG2EI16_V_MF2_M1 }, // 21 + { 0x2, 0x0, 0x0, 0x4, 0x1, 0x0, PseudoVSUXSEG2EI16_V_M1_M2 }, // 22 + { 0x2, 0x0, 0x0, 0x4, 0x1, 0x1, PseudoVSUXSEG2EI16_V_M2_M2 }, // 23 + { 0x2, 0x0, 0x0, 0x4, 0x1, 0x2, PseudoVSUXSEG2EI16_V_M4_M2 }, // 24 + { 0x2, 0x0, 0x0, 0x4, 0x1, 0x7, PseudoVSUXSEG2EI16_V_MF2_M2 }, // 25 + { 0x2, 0x0, 0x0, 0x4, 0x2, 0x0, PseudoVSUXSEG2EI16_V_M1_M4 }, // 26 + { 0x2, 0x0, 0x0, 0x4, 0x2, 0x1, PseudoVSUXSEG2EI16_V_M2_M4 }, // 27 + { 0x2, 0x0, 0x0, 0x4, 0x2, 0x2, PseudoVSUXSEG2EI16_V_M4_M4 }, // 28 + { 0x2, 0x0, 0x0, 0x4, 0x2, 0x3, PseudoVSUXSEG2EI16_V_M8_M4 }, // 29 + { 0x2, 0x0, 0x0, 0x4, 0x5, 0x6, PseudoVSUXSEG2EI16_V_MF4_MF8 }, // 30 + { 0x2, 0x0, 0x0, 0x4, 0x6, 0x6, PseudoVSUXSEG2EI16_V_MF4_MF4 }, // 31 + { 0x2, 0x0, 0x0, 0x4, 0x6, 0x7, PseudoVSUXSEG2EI16_V_MF2_MF4 }, // 32 + { 0x2, 0x0, 0x0, 0x4, 0x7, 0x0, PseudoVSUXSEG2EI16_V_M1_MF2 }, // 33 + { 0x2, 0x0, 0x0, 0x4, 0x7, 0x6, PseudoVSUXSEG2EI16_V_MF4_MF2 }, // 34 + { 0x2, 0x0, 0x0, 0x4, 0x7, 0x7, PseudoVSUXSEG2EI16_V_MF2_MF2 }, // 35 + { 0x2, 0x0, 0x0, 0x5, 0x0, 0x0, PseudoVSUXSEG2EI32_V_M1_M1 }, // 36 + { 0x2, 0x0, 0x0, 0x5, 0x0, 0x1, PseudoVSUXSEG2EI32_V_M2_M1 }, // 37 + { 0x2, 0x0, 0x0, 0x5, 0x0, 0x2, PseudoVSUXSEG2EI32_V_M4_M1 }, // 38 + { 0x2, 0x0, 0x0, 0x5, 0x0, 0x7, PseudoVSUXSEG2EI32_V_MF2_M1 }, // 39 + { 0x2, 0x0, 0x0, 0x5, 0x1, 0x0, PseudoVSUXSEG2EI32_V_M1_M2 }, // 40 + { 0x2, 0x0, 0x0, 0x5, 0x1, 0x1, PseudoVSUXSEG2EI32_V_M2_M2 }, // 41 + { 0x2, 0x0, 0x0, 0x5, 0x1, 0x2, PseudoVSUXSEG2EI32_V_M4_M2 }, // 42 + { 0x2, 0x0, 0x0, 0x5, 0x1, 0x3, PseudoVSUXSEG2EI32_V_M8_M2 }, // 43 + { 0x2, 0x0, 0x0, 0x5, 0x2, 0x1, PseudoVSUXSEG2EI32_V_M2_M4 }, // 44 + { 0x2, 0x0, 0x0, 0x5, 0x2, 0x2, PseudoVSUXSEG2EI32_V_M4_M4 }, // 45 + { 0x2, 0x0, 0x0, 0x5, 0x2, 0x3, PseudoVSUXSEG2EI32_V_M8_M4 }, // 46 + { 0x2, 0x0, 0x0, 0x5, 0x5, 0x7, PseudoVSUXSEG2EI32_V_MF2_MF8 }, // 47 + { 0x2, 0x0, 0x0, 0x5, 0x6, 0x0, PseudoVSUXSEG2EI32_V_M1_MF4 }, // 48 + { 0x2, 0x0, 0x0, 0x5, 0x6, 0x7, PseudoVSUXSEG2EI32_V_MF2_MF4 }, // 49 + { 0x2, 0x0, 0x0, 0x5, 0x7, 0x0, PseudoVSUXSEG2EI32_V_M1_MF2 }, // 50 + { 0x2, 0x0, 0x0, 0x5, 0x7, 0x1, PseudoVSUXSEG2EI32_V_M2_MF2 }, // 51 + { 0x2, 0x0, 0x0, 0x5, 0x7, 0x7, PseudoVSUXSEG2EI32_V_MF2_MF2 }, // 52 + { 0x2, 0x0, 0x0, 0x6, 0x0, 0x0, PseudoVSUXSEG2EI64_V_M1_M1 }, // 53 + { 0x2, 0x0, 0x0, 0x6, 0x0, 0x1, PseudoVSUXSEG2EI64_V_M2_M1 }, // 54 + { 0x2, 0x0, 0x0, 0x6, 0x0, 0x2, PseudoVSUXSEG2EI64_V_M4_M1 }, // 55 + { 0x2, 0x0, 0x0, 0x6, 0x0, 0x3, PseudoVSUXSEG2EI64_V_M8_M1 }, // 56 + { 0x2, 0x0, 0x0, 0x6, 0x1, 0x1, PseudoVSUXSEG2EI64_V_M2_M2 }, // 57 + { 0x2, 0x0, 0x0, 0x6, 0x1, 0x2, PseudoVSUXSEG2EI64_V_M4_M2 }, // 58 + { 0x2, 0x0, 0x0, 0x6, 0x1, 0x3, PseudoVSUXSEG2EI64_V_M8_M2 }, // 59 + { 0x2, 0x0, 0x0, 0x6, 0x2, 0x2, PseudoVSUXSEG2EI64_V_M4_M4 }, // 60 + { 0x2, 0x0, 0x0, 0x6, 0x2, 0x3, PseudoVSUXSEG2EI64_V_M8_M4 }, // 61 + { 0x2, 0x0, 0x0, 0x6, 0x5, 0x0, PseudoVSUXSEG2EI64_V_M1_MF8 }, // 62 + { 0x2, 0x0, 0x0, 0x6, 0x6, 0x0, PseudoVSUXSEG2EI64_V_M1_MF4 }, // 63 + { 0x2, 0x0, 0x0, 0x6, 0x6, 0x1, PseudoVSUXSEG2EI64_V_M2_MF4 }, // 64 + { 0x2, 0x0, 0x0, 0x6, 0x7, 0x0, PseudoVSUXSEG2EI64_V_M1_MF2 }, // 65 + { 0x2, 0x0, 0x0, 0x6, 0x7, 0x1, PseudoVSUXSEG2EI64_V_M2_MF2 }, // 66 + { 0x2, 0x0, 0x0, 0x6, 0x7, 0x2, PseudoVSUXSEG2EI64_V_M4_MF2 }, // 67 + { 0x2, 0x0, 0x1, 0x3, 0x0, 0x0, PseudoVSOXSEG2EI8_V_M1_M1 }, // 68 + { 0x2, 0x0, 0x1, 0x3, 0x0, 0x5, PseudoVSOXSEG2EI8_V_MF8_M1 }, // 69 + { 0x2, 0x0, 0x1, 0x3, 0x0, 0x6, PseudoVSOXSEG2EI8_V_MF4_M1 }, // 70 + { 0x2, 0x0, 0x1, 0x3, 0x0, 0x7, PseudoVSOXSEG2EI8_V_MF2_M1 }, // 71 + { 0x2, 0x0, 0x1, 0x3, 0x1, 0x0, PseudoVSOXSEG2EI8_V_M1_M2 }, // 72 + { 0x2, 0x0, 0x1, 0x3, 0x1, 0x1, PseudoVSOXSEG2EI8_V_M2_M2 }, // 73 + { 0x2, 0x0, 0x1, 0x3, 0x1, 0x6, PseudoVSOXSEG2EI8_V_MF4_M2 }, // 74 + { 0x2, 0x0, 0x1, 0x3, 0x1, 0x7, PseudoVSOXSEG2EI8_V_MF2_M2 }, // 75 + { 0x2, 0x0, 0x1, 0x3, 0x2, 0x0, PseudoVSOXSEG2EI8_V_M1_M4 }, // 76 + { 0x2, 0x0, 0x1, 0x3, 0x2, 0x1, PseudoVSOXSEG2EI8_V_M2_M4 }, // 77 + { 0x2, 0x0, 0x1, 0x3, 0x2, 0x2, PseudoVSOXSEG2EI8_V_M4_M4 }, // 78 + { 0x2, 0x0, 0x1, 0x3, 0x2, 0x7, PseudoVSOXSEG2EI8_V_MF2_M4 }, // 79 + { 0x2, 0x0, 0x1, 0x3, 0x5, 0x5, PseudoVSOXSEG2EI8_V_MF8_MF8 }, // 80 + { 0x2, 0x0, 0x1, 0x3, 0x6, 0x5, PseudoVSOXSEG2EI8_V_MF8_MF4 }, // 81 + { 0x2, 0x0, 0x1, 0x3, 0x6, 0x6, PseudoVSOXSEG2EI8_V_MF4_MF4 }, // 82 + { 0x2, 0x0, 0x1, 0x3, 0x7, 0x5, PseudoVSOXSEG2EI8_V_MF8_MF2 }, // 83 + { 0x2, 0x0, 0x1, 0x3, 0x7, 0x6, PseudoVSOXSEG2EI8_V_MF4_MF2 }, // 84 + { 0x2, 0x0, 0x1, 0x3, 0x7, 0x7, PseudoVSOXSEG2EI8_V_MF2_MF2 }, // 85 + { 0x2, 0x0, 0x1, 0x4, 0x0, 0x0, PseudoVSOXSEG2EI16_V_M1_M1 }, // 86 + { 0x2, 0x0, 0x1, 0x4, 0x0, 0x1, PseudoVSOXSEG2EI16_V_M2_M1 }, // 87 + { 0x2, 0x0, 0x1, 0x4, 0x0, 0x6, PseudoVSOXSEG2EI16_V_MF4_M1 }, // 88 + { 0x2, 0x0, 0x1, 0x4, 0x0, 0x7, PseudoVSOXSEG2EI16_V_MF2_M1 }, // 89 + { 0x2, 0x0, 0x1, 0x4, 0x1, 0x0, PseudoVSOXSEG2EI16_V_M1_M2 }, // 90 + { 0x2, 0x0, 0x1, 0x4, 0x1, 0x1, PseudoVSOXSEG2EI16_V_M2_M2 }, // 91 + { 0x2, 0x0, 0x1, 0x4, 0x1, 0x2, PseudoVSOXSEG2EI16_V_M4_M2 }, // 92 + { 0x2, 0x0, 0x1, 0x4, 0x1, 0x7, PseudoVSOXSEG2EI16_V_MF2_M2 }, // 93 + { 0x2, 0x0, 0x1, 0x4, 0x2, 0x0, PseudoVSOXSEG2EI16_V_M1_M4 }, // 94 + { 0x2, 0x0, 0x1, 0x4, 0x2, 0x1, PseudoVSOXSEG2EI16_V_M2_M4 }, // 95 + { 0x2, 0x0, 0x1, 0x4, 0x2, 0x2, PseudoVSOXSEG2EI16_V_M4_M4 }, // 96 + { 0x2, 0x0, 0x1, 0x4, 0x2, 0x3, PseudoVSOXSEG2EI16_V_M8_M4 }, // 97 + { 0x2, 0x0, 0x1, 0x4, 0x5, 0x6, PseudoVSOXSEG2EI16_V_MF4_MF8 }, // 98 + { 0x2, 0x0, 0x1, 0x4, 0x6, 0x6, PseudoVSOXSEG2EI16_V_MF4_MF4 }, // 99 + { 0x2, 0x0, 0x1, 0x4, 0x6, 0x7, PseudoVSOXSEG2EI16_V_MF2_MF4 }, // 100 + { 0x2, 0x0, 0x1, 0x4, 0x7, 0x0, PseudoVSOXSEG2EI16_V_M1_MF2 }, // 101 + { 0x2, 0x0, 0x1, 0x4, 0x7, 0x6, PseudoVSOXSEG2EI16_V_MF4_MF2 }, // 102 + { 0x2, 0x0, 0x1, 0x4, 0x7, 0x7, PseudoVSOXSEG2EI16_V_MF2_MF2 }, // 103 + { 0x2, 0x0, 0x1, 0x5, 0x0, 0x0, PseudoVSOXSEG2EI32_V_M1_M1 }, // 104 + { 0x2, 0x0, 0x1, 0x5, 0x0, 0x1, PseudoVSOXSEG2EI32_V_M2_M1 }, // 105 + { 0x2, 0x0, 0x1, 0x5, 0x0, 0x2, PseudoVSOXSEG2EI32_V_M4_M1 }, // 106 + { 0x2, 0x0, 0x1, 0x5, 0x0, 0x7, PseudoVSOXSEG2EI32_V_MF2_M1 }, // 107 + { 0x2, 0x0, 0x1, 0x5, 0x1, 0x0, PseudoVSOXSEG2EI32_V_M1_M2 }, // 108 + { 0x2, 0x0, 0x1, 0x5, 0x1, 0x1, PseudoVSOXSEG2EI32_V_M2_M2 }, // 109 + { 0x2, 0x0, 0x1, 0x5, 0x1, 0x2, PseudoVSOXSEG2EI32_V_M4_M2 }, // 110 + { 0x2, 0x0, 0x1, 0x5, 0x1, 0x3, PseudoVSOXSEG2EI32_V_M8_M2 }, // 111 + { 0x2, 0x0, 0x1, 0x5, 0x2, 0x1, PseudoVSOXSEG2EI32_V_M2_M4 }, // 112 + { 0x2, 0x0, 0x1, 0x5, 0x2, 0x2, PseudoVSOXSEG2EI32_V_M4_M4 }, // 113 + { 0x2, 0x0, 0x1, 0x5, 0x2, 0x3, PseudoVSOXSEG2EI32_V_M8_M4 }, // 114 + { 0x2, 0x0, 0x1, 0x5, 0x5, 0x7, PseudoVSOXSEG2EI32_V_MF2_MF8 }, // 115 + { 0x2, 0x0, 0x1, 0x5, 0x6, 0x0, PseudoVSOXSEG2EI32_V_M1_MF4 }, // 116 + { 0x2, 0x0, 0x1, 0x5, 0x6, 0x7, PseudoVSOXSEG2EI32_V_MF2_MF4 }, // 117 + { 0x2, 0x0, 0x1, 0x5, 0x7, 0x0, PseudoVSOXSEG2EI32_V_M1_MF2 }, // 118 + { 0x2, 0x0, 0x1, 0x5, 0x7, 0x1, PseudoVSOXSEG2EI32_V_M2_MF2 }, // 119 + { 0x2, 0x0, 0x1, 0x5, 0x7, 0x7, PseudoVSOXSEG2EI32_V_MF2_MF2 }, // 120 + { 0x2, 0x0, 0x1, 0x6, 0x0, 0x0, PseudoVSOXSEG2EI64_V_M1_M1 }, // 121 + { 0x2, 0x0, 0x1, 0x6, 0x0, 0x1, PseudoVSOXSEG2EI64_V_M2_M1 }, // 122 + { 0x2, 0x0, 0x1, 0x6, 0x0, 0x2, PseudoVSOXSEG2EI64_V_M4_M1 }, // 123 + { 0x2, 0x0, 0x1, 0x6, 0x0, 0x3, PseudoVSOXSEG2EI64_V_M8_M1 }, // 124 + { 0x2, 0x0, 0x1, 0x6, 0x1, 0x1, PseudoVSOXSEG2EI64_V_M2_M2 }, // 125 + { 0x2, 0x0, 0x1, 0x6, 0x1, 0x2, PseudoVSOXSEG2EI64_V_M4_M2 }, // 126 + { 0x2, 0x0, 0x1, 0x6, 0x1, 0x3, PseudoVSOXSEG2EI64_V_M8_M2 }, // 127 + { 0x2, 0x0, 0x1, 0x6, 0x2, 0x2, PseudoVSOXSEG2EI64_V_M4_M4 }, // 128 + { 0x2, 0x0, 0x1, 0x6, 0x2, 0x3, PseudoVSOXSEG2EI64_V_M8_M4 }, // 129 + { 0x2, 0x0, 0x1, 0x6, 0x5, 0x0, PseudoVSOXSEG2EI64_V_M1_MF8 }, // 130 + { 0x2, 0x0, 0x1, 0x6, 0x6, 0x0, PseudoVSOXSEG2EI64_V_M1_MF4 }, // 131 + { 0x2, 0x0, 0x1, 0x6, 0x6, 0x1, PseudoVSOXSEG2EI64_V_M2_MF4 }, // 132 + { 0x2, 0x0, 0x1, 0x6, 0x7, 0x0, PseudoVSOXSEG2EI64_V_M1_MF2 }, // 133 + { 0x2, 0x0, 0x1, 0x6, 0x7, 0x1, PseudoVSOXSEG2EI64_V_M2_MF2 }, // 134 + { 0x2, 0x0, 0x1, 0x6, 0x7, 0x2, PseudoVSOXSEG2EI64_V_M4_MF2 }, // 135 + { 0x2, 0x1, 0x0, 0x3, 0x0, 0x0, PseudoVSUXSEG2EI8_V_M1_M1_MASK }, // 136 + { 0x2, 0x1, 0x0, 0x3, 0x0, 0x5, PseudoVSUXSEG2EI8_V_MF8_M1_MASK }, // 137 + { 0x2, 0x1, 0x0, 0x3, 0x0, 0x6, PseudoVSUXSEG2EI8_V_MF4_M1_MASK }, // 138 + { 0x2, 0x1, 0x0, 0x3, 0x0, 0x7, PseudoVSUXSEG2EI8_V_MF2_M1_MASK }, // 139 + { 0x2, 0x1, 0x0, 0x3, 0x1, 0x0, PseudoVSUXSEG2EI8_V_M1_M2_MASK }, // 140 + { 0x2, 0x1, 0x0, 0x3, 0x1, 0x1, PseudoVSUXSEG2EI8_V_M2_M2_MASK }, // 141 + { 0x2, 0x1, 0x0, 0x3, 0x1, 0x6, PseudoVSUXSEG2EI8_V_MF4_M2_MASK }, // 142 + { 0x2, 0x1, 0x0, 0x3, 0x1, 0x7, PseudoVSUXSEG2EI8_V_MF2_M2_MASK }, // 143 + { 0x2, 0x1, 0x0, 0x3, 0x2, 0x0, PseudoVSUXSEG2EI8_V_M1_M4_MASK }, // 144 + { 0x2, 0x1, 0x0, 0x3, 0x2, 0x1, PseudoVSUXSEG2EI8_V_M2_M4_MASK }, // 145 + { 0x2, 0x1, 0x0, 0x3, 0x2, 0x2, PseudoVSUXSEG2EI8_V_M4_M4_MASK }, // 146 + { 0x2, 0x1, 0x0, 0x3, 0x2, 0x7, PseudoVSUXSEG2EI8_V_MF2_M4_MASK }, // 147 + { 0x2, 0x1, 0x0, 0x3, 0x5, 0x5, PseudoVSUXSEG2EI8_V_MF8_MF8_MASK }, // 148 + { 0x2, 0x1, 0x0, 0x3, 0x6, 0x5, PseudoVSUXSEG2EI8_V_MF8_MF4_MASK }, // 149 + { 0x2, 0x1, 0x0, 0x3, 0x6, 0x6, PseudoVSUXSEG2EI8_V_MF4_MF4_MASK }, // 150 + { 0x2, 0x1, 0x0, 0x3, 0x7, 0x5, PseudoVSUXSEG2EI8_V_MF8_MF2_MASK }, // 151 + { 0x2, 0x1, 0x0, 0x3, 0x7, 0x6, PseudoVSUXSEG2EI8_V_MF4_MF2_MASK }, // 152 + { 0x2, 0x1, 0x0, 0x3, 0x7, 0x7, PseudoVSUXSEG2EI8_V_MF2_MF2_MASK }, // 153 + { 0x2, 0x1, 0x0, 0x4, 0x0, 0x0, PseudoVSUXSEG2EI16_V_M1_M1_MASK }, // 154 + { 0x2, 0x1, 0x0, 0x4, 0x0, 0x1, PseudoVSUXSEG2EI16_V_M2_M1_MASK }, // 155 + { 0x2, 0x1, 0x0, 0x4, 0x0, 0x6, PseudoVSUXSEG2EI16_V_MF4_M1_MASK }, // 156 + { 0x2, 0x1, 0x0, 0x4, 0x0, 0x7, PseudoVSUXSEG2EI16_V_MF2_M1_MASK }, // 157 + { 0x2, 0x1, 0x0, 0x4, 0x1, 0x0, PseudoVSUXSEG2EI16_V_M1_M2_MASK }, // 158 + { 0x2, 0x1, 0x0, 0x4, 0x1, 0x1, PseudoVSUXSEG2EI16_V_M2_M2_MASK }, // 159 + { 0x2, 0x1, 0x0, 0x4, 0x1, 0x2, PseudoVSUXSEG2EI16_V_M4_M2_MASK }, // 160 + { 0x2, 0x1, 0x0, 0x4, 0x1, 0x7, PseudoVSUXSEG2EI16_V_MF2_M2_MASK }, // 161 + { 0x2, 0x1, 0x0, 0x4, 0x2, 0x0, PseudoVSUXSEG2EI16_V_M1_M4_MASK }, // 162 + { 0x2, 0x1, 0x0, 0x4, 0x2, 0x1, PseudoVSUXSEG2EI16_V_M2_M4_MASK }, // 163 + { 0x2, 0x1, 0x0, 0x4, 0x2, 0x2, PseudoVSUXSEG2EI16_V_M4_M4_MASK }, // 164 + { 0x2, 0x1, 0x0, 0x4, 0x2, 0x3, PseudoVSUXSEG2EI16_V_M8_M4_MASK }, // 165 + { 0x2, 0x1, 0x0, 0x4, 0x5, 0x6, PseudoVSUXSEG2EI16_V_MF4_MF8_MASK }, // 166 + { 0x2, 0x1, 0x0, 0x4, 0x6, 0x6, PseudoVSUXSEG2EI16_V_MF4_MF4_MASK }, // 167 + { 0x2, 0x1, 0x0, 0x4, 0x6, 0x7, PseudoVSUXSEG2EI16_V_MF2_MF4_MASK }, // 168 + { 0x2, 0x1, 0x0, 0x4, 0x7, 0x0, PseudoVSUXSEG2EI16_V_M1_MF2_MASK }, // 169 + { 0x2, 0x1, 0x0, 0x4, 0x7, 0x6, PseudoVSUXSEG2EI16_V_MF4_MF2_MASK }, // 170 + { 0x2, 0x1, 0x0, 0x4, 0x7, 0x7, PseudoVSUXSEG2EI16_V_MF2_MF2_MASK }, // 171 + { 0x2, 0x1, 0x0, 0x5, 0x0, 0x0, PseudoVSUXSEG2EI32_V_M1_M1_MASK }, // 172 + { 0x2, 0x1, 0x0, 0x5, 0x0, 0x1, PseudoVSUXSEG2EI32_V_M2_M1_MASK }, // 173 + { 0x2, 0x1, 0x0, 0x5, 0x0, 0x2, PseudoVSUXSEG2EI32_V_M4_M1_MASK }, // 174 + { 0x2, 0x1, 0x0, 0x5, 0x0, 0x7, PseudoVSUXSEG2EI32_V_MF2_M1_MASK }, // 175 + { 0x2, 0x1, 0x0, 0x5, 0x1, 0x0, PseudoVSUXSEG2EI32_V_M1_M2_MASK }, // 176 + { 0x2, 0x1, 0x0, 0x5, 0x1, 0x1, PseudoVSUXSEG2EI32_V_M2_M2_MASK }, // 177 + { 0x2, 0x1, 0x0, 0x5, 0x1, 0x2, PseudoVSUXSEG2EI32_V_M4_M2_MASK }, // 178 + { 0x2, 0x1, 0x0, 0x5, 0x1, 0x3, PseudoVSUXSEG2EI32_V_M8_M2_MASK }, // 179 + { 0x2, 0x1, 0x0, 0x5, 0x2, 0x1, PseudoVSUXSEG2EI32_V_M2_M4_MASK }, // 180 + { 0x2, 0x1, 0x0, 0x5, 0x2, 0x2, PseudoVSUXSEG2EI32_V_M4_M4_MASK }, // 181 + { 0x2, 0x1, 0x0, 0x5, 0x2, 0x3, PseudoVSUXSEG2EI32_V_M8_M4_MASK }, // 182 + { 0x2, 0x1, 0x0, 0x5, 0x5, 0x7, PseudoVSUXSEG2EI32_V_MF2_MF8_MASK }, // 183 + { 0x2, 0x1, 0x0, 0x5, 0x6, 0x0, PseudoVSUXSEG2EI32_V_M1_MF4_MASK }, // 184 + { 0x2, 0x1, 0x0, 0x5, 0x6, 0x7, PseudoVSUXSEG2EI32_V_MF2_MF4_MASK }, // 185 + { 0x2, 0x1, 0x0, 0x5, 0x7, 0x0, PseudoVSUXSEG2EI32_V_M1_MF2_MASK }, // 186 + { 0x2, 0x1, 0x0, 0x5, 0x7, 0x1, PseudoVSUXSEG2EI32_V_M2_MF2_MASK }, // 187 + { 0x2, 0x1, 0x0, 0x5, 0x7, 0x7, PseudoVSUXSEG2EI32_V_MF2_MF2_MASK }, // 188 + { 0x2, 0x1, 0x0, 0x6, 0x0, 0x0, PseudoVSUXSEG2EI64_V_M1_M1_MASK }, // 189 + { 0x2, 0x1, 0x0, 0x6, 0x0, 0x1, PseudoVSUXSEG2EI64_V_M2_M1_MASK }, // 190 + { 0x2, 0x1, 0x0, 0x6, 0x0, 0x2, PseudoVSUXSEG2EI64_V_M4_M1_MASK }, // 191 + { 0x2, 0x1, 0x0, 0x6, 0x0, 0x3, PseudoVSUXSEG2EI64_V_M8_M1_MASK }, // 192 + { 0x2, 0x1, 0x0, 0x6, 0x1, 0x1, PseudoVSUXSEG2EI64_V_M2_M2_MASK }, // 193 + { 0x2, 0x1, 0x0, 0x6, 0x1, 0x2, PseudoVSUXSEG2EI64_V_M4_M2_MASK }, // 194 + { 0x2, 0x1, 0x0, 0x6, 0x1, 0x3, PseudoVSUXSEG2EI64_V_M8_M2_MASK }, // 195 + { 0x2, 0x1, 0x0, 0x6, 0x2, 0x2, PseudoVSUXSEG2EI64_V_M4_M4_MASK }, // 196 + { 0x2, 0x1, 0x0, 0x6, 0x2, 0x3, PseudoVSUXSEG2EI64_V_M8_M4_MASK }, // 197 + { 0x2, 0x1, 0x0, 0x6, 0x5, 0x0, PseudoVSUXSEG2EI64_V_M1_MF8_MASK }, // 198 + { 0x2, 0x1, 0x0, 0x6, 0x6, 0x0, PseudoVSUXSEG2EI64_V_M1_MF4_MASK }, // 199 + { 0x2, 0x1, 0x0, 0x6, 0x6, 0x1, PseudoVSUXSEG2EI64_V_M2_MF4_MASK }, // 200 + { 0x2, 0x1, 0x0, 0x6, 0x7, 0x0, PseudoVSUXSEG2EI64_V_M1_MF2_MASK }, // 201 + { 0x2, 0x1, 0x0, 0x6, 0x7, 0x1, PseudoVSUXSEG2EI64_V_M2_MF2_MASK }, // 202 + { 0x2, 0x1, 0x0, 0x6, 0x7, 0x2, PseudoVSUXSEG2EI64_V_M4_MF2_MASK }, // 203 + { 0x2, 0x1, 0x1, 0x3, 0x0, 0x0, PseudoVSOXSEG2EI8_V_M1_M1_MASK }, // 204 + { 0x2, 0x1, 0x1, 0x3, 0x0, 0x5, PseudoVSOXSEG2EI8_V_MF8_M1_MASK }, // 205 + { 0x2, 0x1, 0x1, 0x3, 0x0, 0x6, PseudoVSOXSEG2EI8_V_MF4_M1_MASK }, // 206 + { 0x2, 0x1, 0x1, 0x3, 0x0, 0x7, PseudoVSOXSEG2EI8_V_MF2_M1_MASK }, // 207 + { 0x2, 0x1, 0x1, 0x3, 0x1, 0x0, PseudoVSOXSEG2EI8_V_M1_M2_MASK }, // 208 + { 0x2, 0x1, 0x1, 0x3, 0x1, 0x1, PseudoVSOXSEG2EI8_V_M2_M2_MASK }, // 209 + { 0x2, 0x1, 0x1, 0x3, 0x1, 0x6, PseudoVSOXSEG2EI8_V_MF4_M2_MASK }, // 210 + { 0x2, 0x1, 0x1, 0x3, 0x1, 0x7, PseudoVSOXSEG2EI8_V_MF2_M2_MASK }, // 211 + { 0x2, 0x1, 0x1, 0x3, 0x2, 0x0, PseudoVSOXSEG2EI8_V_M1_M4_MASK }, // 212 + { 0x2, 0x1, 0x1, 0x3, 0x2, 0x1, PseudoVSOXSEG2EI8_V_M2_M4_MASK }, // 213 + { 0x2, 0x1, 0x1, 0x3, 0x2, 0x2, PseudoVSOXSEG2EI8_V_M4_M4_MASK }, // 214 + { 0x2, 0x1, 0x1, 0x3, 0x2, 0x7, PseudoVSOXSEG2EI8_V_MF2_M4_MASK }, // 215 + { 0x2, 0x1, 0x1, 0x3, 0x5, 0x5, PseudoVSOXSEG2EI8_V_MF8_MF8_MASK }, // 216 + { 0x2, 0x1, 0x1, 0x3, 0x6, 0x5, PseudoVSOXSEG2EI8_V_MF8_MF4_MASK }, // 217 + { 0x2, 0x1, 0x1, 0x3, 0x6, 0x6, PseudoVSOXSEG2EI8_V_MF4_MF4_MASK }, // 218 + { 0x2, 0x1, 0x1, 0x3, 0x7, 0x5, PseudoVSOXSEG2EI8_V_MF8_MF2_MASK }, // 219 + { 0x2, 0x1, 0x1, 0x3, 0x7, 0x6, PseudoVSOXSEG2EI8_V_MF4_MF2_MASK }, // 220 + { 0x2, 0x1, 0x1, 0x3, 0x7, 0x7, PseudoVSOXSEG2EI8_V_MF2_MF2_MASK }, // 221 + { 0x2, 0x1, 0x1, 0x4, 0x0, 0x0, PseudoVSOXSEG2EI16_V_M1_M1_MASK }, // 222 + { 0x2, 0x1, 0x1, 0x4, 0x0, 0x1, PseudoVSOXSEG2EI16_V_M2_M1_MASK }, // 223 + { 0x2, 0x1, 0x1, 0x4, 0x0, 0x6, PseudoVSOXSEG2EI16_V_MF4_M1_MASK }, // 224 + { 0x2, 0x1, 0x1, 0x4, 0x0, 0x7, PseudoVSOXSEG2EI16_V_MF2_M1_MASK }, // 225 + { 0x2, 0x1, 0x1, 0x4, 0x1, 0x0, PseudoVSOXSEG2EI16_V_M1_M2_MASK }, // 226 + { 0x2, 0x1, 0x1, 0x4, 0x1, 0x1, PseudoVSOXSEG2EI16_V_M2_M2_MASK }, // 227 + { 0x2, 0x1, 0x1, 0x4, 0x1, 0x2, PseudoVSOXSEG2EI16_V_M4_M2_MASK }, // 228 + { 0x2, 0x1, 0x1, 0x4, 0x1, 0x7, PseudoVSOXSEG2EI16_V_MF2_M2_MASK }, // 229 + { 0x2, 0x1, 0x1, 0x4, 0x2, 0x0, PseudoVSOXSEG2EI16_V_M1_M4_MASK }, // 230 + { 0x2, 0x1, 0x1, 0x4, 0x2, 0x1, PseudoVSOXSEG2EI16_V_M2_M4_MASK }, // 231 + { 0x2, 0x1, 0x1, 0x4, 0x2, 0x2, PseudoVSOXSEG2EI16_V_M4_M4_MASK }, // 232 + { 0x2, 0x1, 0x1, 0x4, 0x2, 0x3, PseudoVSOXSEG2EI16_V_M8_M4_MASK }, // 233 + { 0x2, 0x1, 0x1, 0x4, 0x5, 0x6, PseudoVSOXSEG2EI16_V_MF4_MF8_MASK }, // 234 + { 0x2, 0x1, 0x1, 0x4, 0x6, 0x6, PseudoVSOXSEG2EI16_V_MF4_MF4_MASK }, // 235 + { 0x2, 0x1, 0x1, 0x4, 0x6, 0x7, PseudoVSOXSEG2EI16_V_MF2_MF4_MASK }, // 236 + { 0x2, 0x1, 0x1, 0x4, 0x7, 0x0, PseudoVSOXSEG2EI16_V_M1_MF2_MASK }, // 237 + { 0x2, 0x1, 0x1, 0x4, 0x7, 0x6, PseudoVSOXSEG2EI16_V_MF4_MF2_MASK }, // 238 + { 0x2, 0x1, 0x1, 0x4, 0x7, 0x7, PseudoVSOXSEG2EI16_V_MF2_MF2_MASK }, // 239 + { 0x2, 0x1, 0x1, 0x5, 0x0, 0x0, PseudoVSOXSEG2EI32_V_M1_M1_MASK }, // 240 + { 0x2, 0x1, 0x1, 0x5, 0x0, 0x1, PseudoVSOXSEG2EI32_V_M2_M1_MASK }, // 241 + { 0x2, 0x1, 0x1, 0x5, 0x0, 0x2, PseudoVSOXSEG2EI32_V_M4_M1_MASK }, // 242 + { 0x2, 0x1, 0x1, 0x5, 0x0, 0x7, PseudoVSOXSEG2EI32_V_MF2_M1_MASK }, // 243 + { 0x2, 0x1, 0x1, 0x5, 0x1, 0x0, PseudoVSOXSEG2EI32_V_M1_M2_MASK }, // 244 + { 0x2, 0x1, 0x1, 0x5, 0x1, 0x1, PseudoVSOXSEG2EI32_V_M2_M2_MASK }, // 245 + { 0x2, 0x1, 0x1, 0x5, 0x1, 0x2, PseudoVSOXSEG2EI32_V_M4_M2_MASK }, // 246 + { 0x2, 0x1, 0x1, 0x5, 0x1, 0x3, PseudoVSOXSEG2EI32_V_M8_M2_MASK }, // 247 + { 0x2, 0x1, 0x1, 0x5, 0x2, 0x1, PseudoVSOXSEG2EI32_V_M2_M4_MASK }, // 248 + { 0x2, 0x1, 0x1, 0x5, 0x2, 0x2, PseudoVSOXSEG2EI32_V_M4_M4_MASK }, // 249 + { 0x2, 0x1, 0x1, 0x5, 0x2, 0x3, PseudoVSOXSEG2EI32_V_M8_M4_MASK }, // 250 + { 0x2, 0x1, 0x1, 0x5, 0x5, 0x7, PseudoVSOXSEG2EI32_V_MF2_MF8_MASK }, // 251 + { 0x2, 0x1, 0x1, 0x5, 0x6, 0x0, PseudoVSOXSEG2EI32_V_M1_MF4_MASK }, // 252 + { 0x2, 0x1, 0x1, 0x5, 0x6, 0x7, PseudoVSOXSEG2EI32_V_MF2_MF4_MASK }, // 253 + { 0x2, 0x1, 0x1, 0x5, 0x7, 0x0, PseudoVSOXSEG2EI32_V_M1_MF2_MASK }, // 254 + { 0x2, 0x1, 0x1, 0x5, 0x7, 0x1, PseudoVSOXSEG2EI32_V_M2_MF2_MASK }, // 255 + { 0x2, 0x1, 0x1, 0x5, 0x7, 0x7, PseudoVSOXSEG2EI32_V_MF2_MF2_MASK }, // 256 + { 0x2, 0x1, 0x1, 0x6, 0x0, 0x0, PseudoVSOXSEG2EI64_V_M1_M1_MASK }, // 257 + { 0x2, 0x1, 0x1, 0x6, 0x0, 0x1, PseudoVSOXSEG2EI64_V_M2_M1_MASK }, // 258 + { 0x2, 0x1, 0x1, 0x6, 0x0, 0x2, PseudoVSOXSEG2EI64_V_M4_M1_MASK }, // 259 + { 0x2, 0x1, 0x1, 0x6, 0x0, 0x3, PseudoVSOXSEG2EI64_V_M8_M1_MASK }, // 260 + { 0x2, 0x1, 0x1, 0x6, 0x1, 0x1, PseudoVSOXSEG2EI64_V_M2_M2_MASK }, // 261 + { 0x2, 0x1, 0x1, 0x6, 0x1, 0x2, PseudoVSOXSEG2EI64_V_M4_M2_MASK }, // 262 + { 0x2, 0x1, 0x1, 0x6, 0x1, 0x3, PseudoVSOXSEG2EI64_V_M8_M2_MASK }, // 263 + { 0x2, 0x1, 0x1, 0x6, 0x2, 0x2, PseudoVSOXSEG2EI64_V_M4_M4_MASK }, // 264 + { 0x2, 0x1, 0x1, 0x6, 0x2, 0x3, PseudoVSOXSEG2EI64_V_M8_M4_MASK }, // 265 + { 0x2, 0x1, 0x1, 0x6, 0x5, 0x0, PseudoVSOXSEG2EI64_V_M1_MF8_MASK }, // 266 + { 0x2, 0x1, 0x1, 0x6, 0x6, 0x0, PseudoVSOXSEG2EI64_V_M1_MF4_MASK }, // 267 + { 0x2, 0x1, 0x1, 0x6, 0x6, 0x1, PseudoVSOXSEG2EI64_V_M2_MF4_MASK }, // 268 + { 0x2, 0x1, 0x1, 0x6, 0x7, 0x0, PseudoVSOXSEG2EI64_V_M1_MF2_MASK }, // 269 + { 0x2, 0x1, 0x1, 0x6, 0x7, 0x1, PseudoVSOXSEG2EI64_V_M2_MF2_MASK }, // 270 + { 0x2, 0x1, 0x1, 0x6, 0x7, 0x2, PseudoVSOXSEG2EI64_V_M4_MF2_MASK }, // 271 + { 0x3, 0x0, 0x0, 0x3, 0x0, 0x0, PseudoVSUXSEG3EI8_V_M1_M1 }, // 272 + { 0x3, 0x0, 0x0, 0x3, 0x0, 0x5, PseudoVSUXSEG3EI8_V_MF8_M1 }, // 273 + { 0x3, 0x0, 0x0, 0x3, 0x0, 0x6, PseudoVSUXSEG3EI8_V_MF4_M1 }, // 274 + { 0x3, 0x0, 0x0, 0x3, 0x0, 0x7, PseudoVSUXSEG3EI8_V_MF2_M1 }, // 275 + { 0x3, 0x0, 0x0, 0x3, 0x1, 0x0, PseudoVSUXSEG3EI8_V_M1_M2 }, // 276 + { 0x3, 0x0, 0x0, 0x3, 0x1, 0x1, PseudoVSUXSEG3EI8_V_M2_M2 }, // 277 + { 0x3, 0x0, 0x0, 0x3, 0x1, 0x6, PseudoVSUXSEG3EI8_V_MF4_M2 }, // 278 + { 0x3, 0x0, 0x0, 0x3, 0x1, 0x7, PseudoVSUXSEG3EI8_V_MF2_M2 }, // 279 + { 0x3, 0x0, 0x0, 0x3, 0x5, 0x5, PseudoVSUXSEG3EI8_V_MF8_MF8 }, // 280 + { 0x3, 0x0, 0x0, 0x3, 0x6, 0x5, PseudoVSUXSEG3EI8_V_MF8_MF4 }, // 281 + { 0x3, 0x0, 0x0, 0x3, 0x6, 0x6, PseudoVSUXSEG3EI8_V_MF4_MF4 }, // 282 + { 0x3, 0x0, 0x0, 0x3, 0x7, 0x5, PseudoVSUXSEG3EI8_V_MF8_MF2 }, // 283 + { 0x3, 0x0, 0x0, 0x3, 0x7, 0x6, PseudoVSUXSEG3EI8_V_MF4_MF2 }, // 284 + { 0x3, 0x0, 0x0, 0x3, 0x7, 0x7, PseudoVSUXSEG3EI8_V_MF2_MF2 }, // 285 + { 0x3, 0x0, 0x0, 0x4, 0x0, 0x0, PseudoVSUXSEG3EI16_V_M1_M1 }, // 286 + { 0x3, 0x0, 0x0, 0x4, 0x0, 0x1, PseudoVSUXSEG3EI16_V_M2_M1 }, // 287 + { 0x3, 0x0, 0x0, 0x4, 0x0, 0x6, PseudoVSUXSEG3EI16_V_MF4_M1 }, // 288 + { 0x3, 0x0, 0x0, 0x4, 0x0, 0x7, PseudoVSUXSEG3EI16_V_MF2_M1 }, // 289 + { 0x3, 0x0, 0x0, 0x4, 0x1, 0x0, PseudoVSUXSEG3EI16_V_M1_M2 }, // 290 + { 0x3, 0x0, 0x0, 0x4, 0x1, 0x1, PseudoVSUXSEG3EI16_V_M2_M2 }, // 291 + { 0x3, 0x0, 0x0, 0x4, 0x1, 0x2, PseudoVSUXSEG3EI16_V_M4_M2 }, // 292 + { 0x3, 0x0, 0x0, 0x4, 0x1, 0x7, PseudoVSUXSEG3EI16_V_MF2_M2 }, // 293 + { 0x3, 0x0, 0x0, 0x4, 0x5, 0x6, PseudoVSUXSEG3EI16_V_MF4_MF8 }, // 294 + { 0x3, 0x0, 0x0, 0x4, 0x6, 0x6, PseudoVSUXSEG3EI16_V_MF4_MF4 }, // 295 + { 0x3, 0x0, 0x0, 0x4, 0x6, 0x7, PseudoVSUXSEG3EI16_V_MF2_MF4 }, // 296 + { 0x3, 0x0, 0x0, 0x4, 0x7, 0x0, PseudoVSUXSEG3EI16_V_M1_MF2 }, // 297 + { 0x3, 0x0, 0x0, 0x4, 0x7, 0x6, PseudoVSUXSEG3EI16_V_MF4_MF2 }, // 298 + { 0x3, 0x0, 0x0, 0x4, 0x7, 0x7, PseudoVSUXSEG3EI16_V_MF2_MF2 }, // 299 + { 0x3, 0x0, 0x0, 0x5, 0x0, 0x0, PseudoVSUXSEG3EI32_V_M1_M1 }, // 300 + { 0x3, 0x0, 0x0, 0x5, 0x0, 0x1, PseudoVSUXSEG3EI32_V_M2_M1 }, // 301 + { 0x3, 0x0, 0x0, 0x5, 0x0, 0x2, PseudoVSUXSEG3EI32_V_M4_M1 }, // 302 + { 0x3, 0x0, 0x0, 0x5, 0x0, 0x7, PseudoVSUXSEG3EI32_V_MF2_M1 }, // 303 + { 0x3, 0x0, 0x0, 0x5, 0x1, 0x0, PseudoVSUXSEG3EI32_V_M1_M2 }, // 304 + { 0x3, 0x0, 0x0, 0x5, 0x1, 0x1, PseudoVSUXSEG3EI32_V_M2_M2 }, // 305 + { 0x3, 0x0, 0x0, 0x5, 0x1, 0x2, PseudoVSUXSEG3EI32_V_M4_M2 }, // 306 + { 0x3, 0x0, 0x0, 0x5, 0x1, 0x3, PseudoVSUXSEG3EI32_V_M8_M2 }, // 307 + { 0x3, 0x0, 0x0, 0x5, 0x5, 0x7, PseudoVSUXSEG3EI32_V_MF2_MF8 }, // 308 + { 0x3, 0x0, 0x0, 0x5, 0x6, 0x0, PseudoVSUXSEG3EI32_V_M1_MF4 }, // 309 + { 0x3, 0x0, 0x0, 0x5, 0x6, 0x7, PseudoVSUXSEG3EI32_V_MF2_MF4 }, // 310 + { 0x3, 0x0, 0x0, 0x5, 0x7, 0x0, PseudoVSUXSEG3EI32_V_M1_MF2 }, // 311 + { 0x3, 0x0, 0x0, 0x5, 0x7, 0x1, PseudoVSUXSEG3EI32_V_M2_MF2 }, // 312 + { 0x3, 0x0, 0x0, 0x5, 0x7, 0x7, PseudoVSUXSEG3EI32_V_MF2_MF2 }, // 313 + { 0x3, 0x0, 0x0, 0x6, 0x0, 0x0, PseudoVSUXSEG3EI64_V_M1_M1 }, // 314 + { 0x3, 0x0, 0x0, 0x6, 0x0, 0x1, PseudoVSUXSEG3EI64_V_M2_M1 }, // 315 + { 0x3, 0x0, 0x0, 0x6, 0x0, 0x2, PseudoVSUXSEG3EI64_V_M4_M1 }, // 316 + { 0x3, 0x0, 0x0, 0x6, 0x0, 0x3, PseudoVSUXSEG3EI64_V_M8_M1 }, // 317 + { 0x3, 0x0, 0x0, 0x6, 0x1, 0x1, PseudoVSUXSEG3EI64_V_M2_M2 }, // 318 + { 0x3, 0x0, 0x0, 0x6, 0x1, 0x2, PseudoVSUXSEG3EI64_V_M4_M2 }, // 319 + { 0x3, 0x0, 0x0, 0x6, 0x1, 0x3, PseudoVSUXSEG3EI64_V_M8_M2 }, // 320 + { 0x3, 0x0, 0x0, 0x6, 0x5, 0x0, PseudoVSUXSEG3EI64_V_M1_MF8 }, // 321 + { 0x3, 0x0, 0x0, 0x6, 0x6, 0x0, PseudoVSUXSEG3EI64_V_M1_MF4 }, // 322 + { 0x3, 0x0, 0x0, 0x6, 0x6, 0x1, PseudoVSUXSEG3EI64_V_M2_MF4 }, // 323 + { 0x3, 0x0, 0x0, 0x6, 0x7, 0x0, PseudoVSUXSEG3EI64_V_M1_MF2 }, // 324 + { 0x3, 0x0, 0x0, 0x6, 0x7, 0x1, PseudoVSUXSEG3EI64_V_M2_MF2 }, // 325 + { 0x3, 0x0, 0x0, 0x6, 0x7, 0x2, PseudoVSUXSEG3EI64_V_M4_MF2 }, // 326 + { 0x3, 0x0, 0x1, 0x3, 0x0, 0x0, PseudoVSOXSEG3EI8_V_M1_M1 }, // 327 + { 0x3, 0x0, 0x1, 0x3, 0x0, 0x5, PseudoVSOXSEG3EI8_V_MF8_M1 }, // 328 + { 0x3, 0x0, 0x1, 0x3, 0x0, 0x6, PseudoVSOXSEG3EI8_V_MF4_M1 }, // 329 + { 0x3, 0x0, 0x1, 0x3, 0x0, 0x7, PseudoVSOXSEG3EI8_V_MF2_M1 }, // 330 + { 0x3, 0x0, 0x1, 0x3, 0x1, 0x0, PseudoVSOXSEG3EI8_V_M1_M2 }, // 331 + { 0x3, 0x0, 0x1, 0x3, 0x1, 0x1, PseudoVSOXSEG3EI8_V_M2_M2 }, // 332 + { 0x3, 0x0, 0x1, 0x3, 0x1, 0x6, PseudoVSOXSEG3EI8_V_MF4_M2 }, // 333 + { 0x3, 0x0, 0x1, 0x3, 0x1, 0x7, PseudoVSOXSEG3EI8_V_MF2_M2 }, // 334 + { 0x3, 0x0, 0x1, 0x3, 0x5, 0x5, PseudoVSOXSEG3EI8_V_MF8_MF8 }, // 335 + { 0x3, 0x0, 0x1, 0x3, 0x6, 0x5, PseudoVSOXSEG3EI8_V_MF8_MF4 }, // 336 + { 0x3, 0x0, 0x1, 0x3, 0x6, 0x6, PseudoVSOXSEG3EI8_V_MF4_MF4 }, // 337 + { 0x3, 0x0, 0x1, 0x3, 0x7, 0x5, PseudoVSOXSEG3EI8_V_MF8_MF2 }, // 338 + { 0x3, 0x0, 0x1, 0x3, 0x7, 0x6, PseudoVSOXSEG3EI8_V_MF4_MF2 }, // 339 + { 0x3, 0x0, 0x1, 0x3, 0x7, 0x7, PseudoVSOXSEG3EI8_V_MF2_MF2 }, // 340 + { 0x3, 0x0, 0x1, 0x4, 0x0, 0x0, PseudoVSOXSEG3EI16_V_M1_M1 }, // 341 + { 0x3, 0x0, 0x1, 0x4, 0x0, 0x1, PseudoVSOXSEG3EI16_V_M2_M1 }, // 342 + { 0x3, 0x0, 0x1, 0x4, 0x0, 0x6, PseudoVSOXSEG3EI16_V_MF4_M1 }, // 343 + { 0x3, 0x0, 0x1, 0x4, 0x0, 0x7, PseudoVSOXSEG3EI16_V_MF2_M1 }, // 344 + { 0x3, 0x0, 0x1, 0x4, 0x1, 0x0, PseudoVSOXSEG3EI16_V_M1_M2 }, // 345 + { 0x3, 0x0, 0x1, 0x4, 0x1, 0x1, PseudoVSOXSEG3EI16_V_M2_M2 }, // 346 + { 0x3, 0x0, 0x1, 0x4, 0x1, 0x2, PseudoVSOXSEG3EI16_V_M4_M2 }, // 347 + { 0x3, 0x0, 0x1, 0x4, 0x1, 0x7, PseudoVSOXSEG3EI16_V_MF2_M2 }, // 348 + { 0x3, 0x0, 0x1, 0x4, 0x5, 0x6, PseudoVSOXSEG3EI16_V_MF4_MF8 }, // 349 + { 0x3, 0x0, 0x1, 0x4, 0x6, 0x6, PseudoVSOXSEG3EI16_V_MF4_MF4 }, // 350 + { 0x3, 0x0, 0x1, 0x4, 0x6, 0x7, PseudoVSOXSEG3EI16_V_MF2_MF4 }, // 351 + { 0x3, 0x0, 0x1, 0x4, 0x7, 0x0, PseudoVSOXSEG3EI16_V_M1_MF2 }, // 352 + { 0x3, 0x0, 0x1, 0x4, 0x7, 0x6, PseudoVSOXSEG3EI16_V_MF4_MF2 }, // 353 + { 0x3, 0x0, 0x1, 0x4, 0x7, 0x7, PseudoVSOXSEG3EI16_V_MF2_MF2 }, // 354 + { 0x3, 0x0, 0x1, 0x5, 0x0, 0x0, PseudoVSOXSEG3EI32_V_M1_M1 }, // 355 + { 0x3, 0x0, 0x1, 0x5, 0x0, 0x1, PseudoVSOXSEG3EI32_V_M2_M1 }, // 356 + { 0x3, 0x0, 0x1, 0x5, 0x0, 0x2, PseudoVSOXSEG3EI32_V_M4_M1 }, // 357 + { 0x3, 0x0, 0x1, 0x5, 0x0, 0x7, PseudoVSOXSEG3EI32_V_MF2_M1 }, // 358 + { 0x3, 0x0, 0x1, 0x5, 0x1, 0x0, PseudoVSOXSEG3EI32_V_M1_M2 }, // 359 + { 0x3, 0x0, 0x1, 0x5, 0x1, 0x1, PseudoVSOXSEG3EI32_V_M2_M2 }, // 360 + { 0x3, 0x0, 0x1, 0x5, 0x1, 0x2, PseudoVSOXSEG3EI32_V_M4_M2 }, // 361 + { 0x3, 0x0, 0x1, 0x5, 0x1, 0x3, PseudoVSOXSEG3EI32_V_M8_M2 }, // 362 + { 0x3, 0x0, 0x1, 0x5, 0x5, 0x7, PseudoVSOXSEG3EI32_V_MF2_MF8 }, // 363 + { 0x3, 0x0, 0x1, 0x5, 0x6, 0x0, PseudoVSOXSEG3EI32_V_M1_MF4 }, // 364 + { 0x3, 0x0, 0x1, 0x5, 0x6, 0x7, PseudoVSOXSEG3EI32_V_MF2_MF4 }, // 365 + { 0x3, 0x0, 0x1, 0x5, 0x7, 0x0, PseudoVSOXSEG3EI32_V_M1_MF2 }, // 366 + { 0x3, 0x0, 0x1, 0x5, 0x7, 0x1, PseudoVSOXSEG3EI32_V_M2_MF2 }, // 367 + { 0x3, 0x0, 0x1, 0x5, 0x7, 0x7, PseudoVSOXSEG3EI32_V_MF2_MF2 }, // 368 + { 0x3, 0x0, 0x1, 0x6, 0x0, 0x0, PseudoVSOXSEG3EI64_V_M1_M1 }, // 369 + { 0x3, 0x0, 0x1, 0x6, 0x0, 0x1, PseudoVSOXSEG3EI64_V_M2_M1 }, // 370 + { 0x3, 0x0, 0x1, 0x6, 0x0, 0x2, PseudoVSOXSEG3EI64_V_M4_M1 }, // 371 + { 0x3, 0x0, 0x1, 0x6, 0x0, 0x3, PseudoVSOXSEG3EI64_V_M8_M1 }, // 372 + { 0x3, 0x0, 0x1, 0x6, 0x1, 0x1, PseudoVSOXSEG3EI64_V_M2_M2 }, // 373 + { 0x3, 0x0, 0x1, 0x6, 0x1, 0x2, PseudoVSOXSEG3EI64_V_M4_M2 }, // 374 + { 0x3, 0x0, 0x1, 0x6, 0x1, 0x3, PseudoVSOXSEG3EI64_V_M8_M2 }, // 375 + { 0x3, 0x0, 0x1, 0x6, 0x5, 0x0, PseudoVSOXSEG3EI64_V_M1_MF8 }, // 376 + { 0x3, 0x0, 0x1, 0x6, 0x6, 0x0, PseudoVSOXSEG3EI64_V_M1_MF4 }, // 377 + { 0x3, 0x0, 0x1, 0x6, 0x6, 0x1, PseudoVSOXSEG3EI64_V_M2_MF4 }, // 378 + { 0x3, 0x0, 0x1, 0x6, 0x7, 0x0, PseudoVSOXSEG3EI64_V_M1_MF2 }, // 379 + { 0x3, 0x0, 0x1, 0x6, 0x7, 0x1, PseudoVSOXSEG3EI64_V_M2_MF2 }, // 380 + { 0x3, 0x0, 0x1, 0x6, 0x7, 0x2, PseudoVSOXSEG3EI64_V_M4_MF2 }, // 381 + { 0x3, 0x1, 0x0, 0x3, 0x0, 0x0, PseudoVSUXSEG3EI8_V_M1_M1_MASK }, // 382 + { 0x3, 0x1, 0x0, 0x3, 0x0, 0x5, PseudoVSUXSEG3EI8_V_MF8_M1_MASK }, // 383 + { 0x3, 0x1, 0x0, 0x3, 0x0, 0x6, PseudoVSUXSEG3EI8_V_MF4_M1_MASK }, // 384 + { 0x3, 0x1, 0x0, 0x3, 0x0, 0x7, PseudoVSUXSEG3EI8_V_MF2_M1_MASK }, // 385 + { 0x3, 0x1, 0x0, 0x3, 0x1, 0x0, PseudoVSUXSEG3EI8_V_M1_M2_MASK }, // 386 + { 0x3, 0x1, 0x0, 0x3, 0x1, 0x1, PseudoVSUXSEG3EI8_V_M2_M2_MASK }, // 387 + { 0x3, 0x1, 0x0, 0x3, 0x1, 0x6, PseudoVSUXSEG3EI8_V_MF4_M2_MASK }, // 388 + { 0x3, 0x1, 0x0, 0x3, 0x1, 0x7, PseudoVSUXSEG3EI8_V_MF2_M2_MASK }, // 389 + { 0x3, 0x1, 0x0, 0x3, 0x5, 0x5, PseudoVSUXSEG3EI8_V_MF8_MF8_MASK }, // 390 + { 0x3, 0x1, 0x0, 0x3, 0x6, 0x5, PseudoVSUXSEG3EI8_V_MF8_MF4_MASK }, // 391 + { 0x3, 0x1, 0x0, 0x3, 0x6, 0x6, PseudoVSUXSEG3EI8_V_MF4_MF4_MASK }, // 392 + { 0x3, 0x1, 0x0, 0x3, 0x7, 0x5, PseudoVSUXSEG3EI8_V_MF8_MF2_MASK }, // 393 + { 0x3, 0x1, 0x0, 0x3, 0x7, 0x6, PseudoVSUXSEG3EI8_V_MF4_MF2_MASK }, // 394 + { 0x3, 0x1, 0x0, 0x3, 0x7, 0x7, PseudoVSUXSEG3EI8_V_MF2_MF2_MASK }, // 395 + { 0x3, 0x1, 0x0, 0x4, 0x0, 0x0, PseudoVSUXSEG3EI16_V_M1_M1_MASK }, // 396 + { 0x3, 0x1, 0x0, 0x4, 0x0, 0x1, PseudoVSUXSEG3EI16_V_M2_M1_MASK }, // 397 + { 0x3, 0x1, 0x0, 0x4, 0x0, 0x6, PseudoVSUXSEG3EI16_V_MF4_M1_MASK }, // 398 + { 0x3, 0x1, 0x0, 0x4, 0x0, 0x7, PseudoVSUXSEG3EI16_V_MF2_M1_MASK }, // 399 + { 0x3, 0x1, 0x0, 0x4, 0x1, 0x0, PseudoVSUXSEG3EI16_V_M1_M2_MASK }, // 400 + { 0x3, 0x1, 0x0, 0x4, 0x1, 0x1, PseudoVSUXSEG3EI16_V_M2_M2_MASK }, // 401 + { 0x3, 0x1, 0x0, 0x4, 0x1, 0x2, PseudoVSUXSEG3EI16_V_M4_M2_MASK }, // 402 + { 0x3, 0x1, 0x0, 0x4, 0x1, 0x7, PseudoVSUXSEG3EI16_V_MF2_M2_MASK }, // 403 + { 0x3, 0x1, 0x0, 0x4, 0x5, 0x6, PseudoVSUXSEG3EI16_V_MF4_MF8_MASK }, // 404 + { 0x3, 0x1, 0x0, 0x4, 0x6, 0x6, PseudoVSUXSEG3EI16_V_MF4_MF4_MASK }, // 405 + { 0x3, 0x1, 0x0, 0x4, 0x6, 0x7, PseudoVSUXSEG3EI16_V_MF2_MF4_MASK }, // 406 + { 0x3, 0x1, 0x0, 0x4, 0x7, 0x0, PseudoVSUXSEG3EI16_V_M1_MF2_MASK }, // 407 + { 0x3, 0x1, 0x0, 0x4, 0x7, 0x6, PseudoVSUXSEG3EI16_V_MF4_MF2_MASK }, // 408 + { 0x3, 0x1, 0x0, 0x4, 0x7, 0x7, PseudoVSUXSEG3EI16_V_MF2_MF2_MASK }, // 409 + { 0x3, 0x1, 0x0, 0x5, 0x0, 0x0, PseudoVSUXSEG3EI32_V_M1_M1_MASK }, // 410 + { 0x3, 0x1, 0x0, 0x5, 0x0, 0x1, PseudoVSUXSEG3EI32_V_M2_M1_MASK }, // 411 + { 0x3, 0x1, 0x0, 0x5, 0x0, 0x2, PseudoVSUXSEG3EI32_V_M4_M1_MASK }, // 412 + { 0x3, 0x1, 0x0, 0x5, 0x0, 0x7, PseudoVSUXSEG3EI32_V_MF2_M1_MASK }, // 413 + { 0x3, 0x1, 0x0, 0x5, 0x1, 0x0, PseudoVSUXSEG3EI32_V_M1_M2_MASK }, // 414 + { 0x3, 0x1, 0x0, 0x5, 0x1, 0x1, PseudoVSUXSEG3EI32_V_M2_M2_MASK }, // 415 + { 0x3, 0x1, 0x0, 0x5, 0x1, 0x2, PseudoVSUXSEG3EI32_V_M4_M2_MASK }, // 416 + { 0x3, 0x1, 0x0, 0x5, 0x1, 0x3, PseudoVSUXSEG3EI32_V_M8_M2_MASK }, // 417 + { 0x3, 0x1, 0x0, 0x5, 0x5, 0x7, PseudoVSUXSEG3EI32_V_MF2_MF8_MASK }, // 418 + { 0x3, 0x1, 0x0, 0x5, 0x6, 0x0, PseudoVSUXSEG3EI32_V_M1_MF4_MASK }, // 419 + { 0x3, 0x1, 0x0, 0x5, 0x6, 0x7, PseudoVSUXSEG3EI32_V_MF2_MF4_MASK }, // 420 + { 0x3, 0x1, 0x0, 0x5, 0x7, 0x0, PseudoVSUXSEG3EI32_V_M1_MF2_MASK }, // 421 + { 0x3, 0x1, 0x0, 0x5, 0x7, 0x1, PseudoVSUXSEG3EI32_V_M2_MF2_MASK }, // 422 + { 0x3, 0x1, 0x0, 0x5, 0x7, 0x7, PseudoVSUXSEG3EI32_V_MF2_MF2_MASK }, // 423 + { 0x3, 0x1, 0x0, 0x6, 0x0, 0x0, PseudoVSUXSEG3EI64_V_M1_M1_MASK }, // 424 + { 0x3, 0x1, 0x0, 0x6, 0x0, 0x1, PseudoVSUXSEG3EI64_V_M2_M1_MASK }, // 425 + { 0x3, 0x1, 0x0, 0x6, 0x0, 0x2, PseudoVSUXSEG3EI64_V_M4_M1_MASK }, // 426 + { 0x3, 0x1, 0x0, 0x6, 0x0, 0x3, PseudoVSUXSEG3EI64_V_M8_M1_MASK }, // 427 + { 0x3, 0x1, 0x0, 0x6, 0x1, 0x1, PseudoVSUXSEG3EI64_V_M2_M2_MASK }, // 428 + { 0x3, 0x1, 0x0, 0x6, 0x1, 0x2, PseudoVSUXSEG3EI64_V_M4_M2_MASK }, // 429 + { 0x3, 0x1, 0x0, 0x6, 0x1, 0x3, PseudoVSUXSEG3EI64_V_M8_M2_MASK }, // 430 + { 0x3, 0x1, 0x0, 0x6, 0x5, 0x0, PseudoVSUXSEG3EI64_V_M1_MF8_MASK }, // 431 + { 0x3, 0x1, 0x0, 0x6, 0x6, 0x0, PseudoVSUXSEG3EI64_V_M1_MF4_MASK }, // 432 + { 0x3, 0x1, 0x0, 0x6, 0x6, 0x1, PseudoVSUXSEG3EI64_V_M2_MF4_MASK }, // 433 + { 0x3, 0x1, 0x0, 0x6, 0x7, 0x0, PseudoVSUXSEG3EI64_V_M1_MF2_MASK }, // 434 + { 0x3, 0x1, 0x0, 0x6, 0x7, 0x1, PseudoVSUXSEG3EI64_V_M2_MF2_MASK }, // 435 + { 0x3, 0x1, 0x0, 0x6, 0x7, 0x2, PseudoVSUXSEG3EI64_V_M4_MF2_MASK }, // 436 + { 0x3, 0x1, 0x1, 0x3, 0x0, 0x0, PseudoVSOXSEG3EI8_V_M1_M1_MASK }, // 437 + { 0x3, 0x1, 0x1, 0x3, 0x0, 0x5, PseudoVSOXSEG3EI8_V_MF8_M1_MASK }, // 438 + { 0x3, 0x1, 0x1, 0x3, 0x0, 0x6, PseudoVSOXSEG3EI8_V_MF4_M1_MASK }, // 439 + { 0x3, 0x1, 0x1, 0x3, 0x0, 0x7, PseudoVSOXSEG3EI8_V_MF2_M1_MASK }, // 440 + { 0x3, 0x1, 0x1, 0x3, 0x1, 0x0, PseudoVSOXSEG3EI8_V_M1_M2_MASK }, // 441 + { 0x3, 0x1, 0x1, 0x3, 0x1, 0x1, PseudoVSOXSEG3EI8_V_M2_M2_MASK }, // 442 + { 0x3, 0x1, 0x1, 0x3, 0x1, 0x6, PseudoVSOXSEG3EI8_V_MF4_M2_MASK }, // 443 + { 0x3, 0x1, 0x1, 0x3, 0x1, 0x7, PseudoVSOXSEG3EI8_V_MF2_M2_MASK }, // 444 + { 0x3, 0x1, 0x1, 0x3, 0x5, 0x5, PseudoVSOXSEG3EI8_V_MF8_MF8_MASK }, // 445 + { 0x3, 0x1, 0x1, 0x3, 0x6, 0x5, PseudoVSOXSEG3EI8_V_MF8_MF4_MASK }, // 446 + { 0x3, 0x1, 0x1, 0x3, 0x6, 0x6, PseudoVSOXSEG3EI8_V_MF4_MF4_MASK }, // 447 + { 0x3, 0x1, 0x1, 0x3, 0x7, 0x5, PseudoVSOXSEG3EI8_V_MF8_MF2_MASK }, // 448 + { 0x3, 0x1, 0x1, 0x3, 0x7, 0x6, PseudoVSOXSEG3EI8_V_MF4_MF2_MASK }, // 449 + { 0x3, 0x1, 0x1, 0x3, 0x7, 0x7, PseudoVSOXSEG3EI8_V_MF2_MF2_MASK }, // 450 + { 0x3, 0x1, 0x1, 0x4, 0x0, 0x0, PseudoVSOXSEG3EI16_V_M1_M1_MASK }, // 451 + { 0x3, 0x1, 0x1, 0x4, 0x0, 0x1, PseudoVSOXSEG3EI16_V_M2_M1_MASK }, // 452 + { 0x3, 0x1, 0x1, 0x4, 0x0, 0x6, PseudoVSOXSEG3EI16_V_MF4_M1_MASK }, // 453 + { 0x3, 0x1, 0x1, 0x4, 0x0, 0x7, PseudoVSOXSEG3EI16_V_MF2_M1_MASK }, // 454 + { 0x3, 0x1, 0x1, 0x4, 0x1, 0x0, PseudoVSOXSEG3EI16_V_M1_M2_MASK }, // 455 + { 0x3, 0x1, 0x1, 0x4, 0x1, 0x1, PseudoVSOXSEG3EI16_V_M2_M2_MASK }, // 456 + { 0x3, 0x1, 0x1, 0x4, 0x1, 0x2, PseudoVSOXSEG3EI16_V_M4_M2_MASK }, // 457 + { 0x3, 0x1, 0x1, 0x4, 0x1, 0x7, PseudoVSOXSEG3EI16_V_MF2_M2_MASK }, // 458 + { 0x3, 0x1, 0x1, 0x4, 0x5, 0x6, PseudoVSOXSEG3EI16_V_MF4_MF8_MASK }, // 459 + { 0x3, 0x1, 0x1, 0x4, 0x6, 0x6, PseudoVSOXSEG3EI16_V_MF4_MF4_MASK }, // 460 + { 0x3, 0x1, 0x1, 0x4, 0x6, 0x7, PseudoVSOXSEG3EI16_V_MF2_MF4_MASK }, // 461 + { 0x3, 0x1, 0x1, 0x4, 0x7, 0x0, PseudoVSOXSEG3EI16_V_M1_MF2_MASK }, // 462 + { 0x3, 0x1, 0x1, 0x4, 0x7, 0x6, PseudoVSOXSEG3EI16_V_MF4_MF2_MASK }, // 463 + { 0x3, 0x1, 0x1, 0x4, 0x7, 0x7, PseudoVSOXSEG3EI16_V_MF2_MF2_MASK }, // 464 + { 0x3, 0x1, 0x1, 0x5, 0x0, 0x0, PseudoVSOXSEG3EI32_V_M1_M1_MASK }, // 465 + { 0x3, 0x1, 0x1, 0x5, 0x0, 0x1, PseudoVSOXSEG3EI32_V_M2_M1_MASK }, // 466 + { 0x3, 0x1, 0x1, 0x5, 0x0, 0x2, PseudoVSOXSEG3EI32_V_M4_M1_MASK }, // 467 + { 0x3, 0x1, 0x1, 0x5, 0x0, 0x7, PseudoVSOXSEG3EI32_V_MF2_M1_MASK }, // 468 + { 0x3, 0x1, 0x1, 0x5, 0x1, 0x0, PseudoVSOXSEG3EI32_V_M1_M2_MASK }, // 469 + { 0x3, 0x1, 0x1, 0x5, 0x1, 0x1, PseudoVSOXSEG3EI32_V_M2_M2_MASK }, // 470 + { 0x3, 0x1, 0x1, 0x5, 0x1, 0x2, PseudoVSOXSEG3EI32_V_M4_M2_MASK }, // 471 + { 0x3, 0x1, 0x1, 0x5, 0x1, 0x3, PseudoVSOXSEG3EI32_V_M8_M2_MASK }, // 472 + { 0x3, 0x1, 0x1, 0x5, 0x5, 0x7, PseudoVSOXSEG3EI32_V_MF2_MF8_MASK }, // 473 + { 0x3, 0x1, 0x1, 0x5, 0x6, 0x0, PseudoVSOXSEG3EI32_V_M1_MF4_MASK }, // 474 + { 0x3, 0x1, 0x1, 0x5, 0x6, 0x7, PseudoVSOXSEG3EI32_V_MF2_MF4_MASK }, // 475 + { 0x3, 0x1, 0x1, 0x5, 0x7, 0x0, PseudoVSOXSEG3EI32_V_M1_MF2_MASK }, // 476 + { 0x3, 0x1, 0x1, 0x5, 0x7, 0x1, PseudoVSOXSEG3EI32_V_M2_MF2_MASK }, // 477 + { 0x3, 0x1, 0x1, 0x5, 0x7, 0x7, PseudoVSOXSEG3EI32_V_MF2_MF2_MASK }, // 478 + { 0x3, 0x1, 0x1, 0x6, 0x0, 0x0, PseudoVSOXSEG3EI64_V_M1_M1_MASK }, // 479 + { 0x3, 0x1, 0x1, 0x6, 0x0, 0x1, PseudoVSOXSEG3EI64_V_M2_M1_MASK }, // 480 + { 0x3, 0x1, 0x1, 0x6, 0x0, 0x2, PseudoVSOXSEG3EI64_V_M4_M1_MASK }, // 481 + { 0x3, 0x1, 0x1, 0x6, 0x0, 0x3, PseudoVSOXSEG3EI64_V_M8_M1_MASK }, // 482 + { 0x3, 0x1, 0x1, 0x6, 0x1, 0x1, PseudoVSOXSEG3EI64_V_M2_M2_MASK }, // 483 + { 0x3, 0x1, 0x1, 0x6, 0x1, 0x2, PseudoVSOXSEG3EI64_V_M4_M2_MASK }, // 484 + { 0x3, 0x1, 0x1, 0x6, 0x1, 0x3, PseudoVSOXSEG3EI64_V_M8_M2_MASK }, // 485 + { 0x3, 0x1, 0x1, 0x6, 0x5, 0x0, PseudoVSOXSEG3EI64_V_M1_MF8_MASK }, // 486 + { 0x3, 0x1, 0x1, 0x6, 0x6, 0x0, PseudoVSOXSEG3EI64_V_M1_MF4_MASK }, // 487 + { 0x3, 0x1, 0x1, 0x6, 0x6, 0x1, PseudoVSOXSEG3EI64_V_M2_MF4_MASK }, // 488 + { 0x3, 0x1, 0x1, 0x6, 0x7, 0x0, PseudoVSOXSEG3EI64_V_M1_MF2_MASK }, // 489 + { 0x3, 0x1, 0x1, 0x6, 0x7, 0x1, PseudoVSOXSEG3EI64_V_M2_MF2_MASK }, // 490 + { 0x3, 0x1, 0x1, 0x6, 0x7, 0x2, PseudoVSOXSEG3EI64_V_M4_MF2_MASK }, // 491 + { 0x4, 0x0, 0x0, 0x3, 0x0, 0x0, PseudoVSUXSEG4EI8_V_M1_M1 }, // 492 + { 0x4, 0x0, 0x0, 0x3, 0x0, 0x5, PseudoVSUXSEG4EI8_V_MF8_M1 }, // 493 + { 0x4, 0x0, 0x0, 0x3, 0x0, 0x6, PseudoVSUXSEG4EI8_V_MF4_M1 }, // 494 + { 0x4, 0x0, 0x0, 0x3, 0x0, 0x7, PseudoVSUXSEG4EI8_V_MF2_M1 }, // 495 + { 0x4, 0x0, 0x0, 0x3, 0x1, 0x0, PseudoVSUXSEG4EI8_V_M1_M2 }, // 496 + { 0x4, 0x0, 0x0, 0x3, 0x1, 0x1, PseudoVSUXSEG4EI8_V_M2_M2 }, // 497 + { 0x4, 0x0, 0x0, 0x3, 0x1, 0x6, PseudoVSUXSEG4EI8_V_MF4_M2 }, // 498 + { 0x4, 0x0, 0x0, 0x3, 0x1, 0x7, PseudoVSUXSEG4EI8_V_MF2_M2 }, // 499 + { 0x4, 0x0, 0x0, 0x3, 0x5, 0x5, PseudoVSUXSEG4EI8_V_MF8_MF8 }, // 500 + { 0x4, 0x0, 0x0, 0x3, 0x6, 0x5, PseudoVSUXSEG4EI8_V_MF8_MF4 }, // 501 + { 0x4, 0x0, 0x0, 0x3, 0x6, 0x6, PseudoVSUXSEG4EI8_V_MF4_MF4 }, // 502 + { 0x4, 0x0, 0x0, 0x3, 0x7, 0x5, PseudoVSUXSEG4EI8_V_MF8_MF2 }, // 503 + { 0x4, 0x0, 0x0, 0x3, 0x7, 0x6, PseudoVSUXSEG4EI8_V_MF4_MF2 }, // 504 + { 0x4, 0x0, 0x0, 0x3, 0x7, 0x7, PseudoVSUXSEG4EI8_V_MF2_MF2 }, // 505 + { 0x4, 0x0, 0x0, 0x4, 0x0, 0x0, PseudoVSUXSEG4EI16_V_M1_M1 }, // 506 + { 0x4, 0x0, 0x0, 0x4, 0x0, 0x1, PseudoVSUXSEG4EI16_V_M2_M1 }, // 507 + { 0x4, 0x0, 0x0, 0x4, 0x0, 0x6, PseudoVSUXSEG4EI16_V_MF4_M1 }, // 508 + { 0x4, 0x0, 0x0, 0x4, 0x0, 0x7, PseudoVSUXSEG4EI16_V_MF2_M1 }, // 509 + { 0x4, 0x0, 0x0, 0x4, 0x1, 0x0, PseudoVSUXSEG4EI16_V_M1_M2 }, // 510 + { 0x4, 0x0, 0x0, 0x4, 0x1, 0x1, PseudoVSUXSEG4EI16_V_M2_M2 }, // 511 + { 0x4, 0x0, 0x0, 0x4, 0x1, 0x2, PseudoVSUXSEG4EI16_V_M4_M2 }, // 512 + { 0x4, 0x0, 0x0, 0x4, 0x1, 0x7, PseudoVSUXSEG4EI16_V_MF2_M2 }, // 513 + { 0x4, 0x0, 0x0, 0x4, 0x5, 0x6, PseudoVSUXSEG4EI16_V_MF4_MF8 }, // 514 + { 0x4, 0x0, 0x0, 0x4, 0x6, 0x6, PseudoVSUXSEG4EI16_V_MF4_MF4 }, // 515 + { 0x4, 0x0, 0x0, 0x4, 0x6, 0x7, PseudoVSUXSEG4EI16_V_MF2_MF4 }, // 516 + { 0x4, 0x0, 0x0, 0x4, 0x7, 0x0, PseudoVSUXSEG4EI16_V_M1_MF2 }, // 517 + { 0x4, 0x0, 0x0, 0x4, 0x7, 0x6, PseudoVSUXSEG4EI16_V_MF4_MF2 }, // 518 + { 0x4, 0x0, 0x0, 0x4, 0x7, 0x7, PseudoVSUXSEG4EI16_V_MF2_MF2 }, // 519 + { 0x4, 0x0, 0x0, 0x5, 0x0, 0x0, PseudoVSUXSEG4EI32_V_M1_M1 }, // 520 + { 0x4, 0x0, 0x0, 0x5, 0x0, 0x1, PseudoVSUXSEG4EI32_V_M2_M1 }, // 521 + { 0x4, 0x0, 0x0, 0x5, 0x0, 0x2, PseudoVSUXSEG4EI32_V_M4_M1 }, // 522 + { 0x4, 0x0, 0x0, 0x5, 0x0, 0x7, PseudoVSUXSEG4EI32_V_MF2_M1 }, // 523 + { 0x4, 0x0, 0x0, 0x5, 0x1, 0x0, PseudoVSUXSEG4EI32_V_M1_M2 }, // 524 + { 0x4, 0x0, 0x0, 0x5, 0x1, 0x1, PseudoVSUXSEG4EI32_V_M2_M2 }, // 525 + { 0x4, 0x0, 0x0, 0x5, 0x1, 0x2, PseudoVSUXSEG4EI32_V_M4_M2 }, // 526 + { 0x4, 0x0, 0x0, 0x5, 0x1, 0x3, PseudoVSUXSEG4EI32_V_M8_M2 }, // 527 + { 0x4, 0x0, 0x0, 0x5, 0x5, 0x7, PseudoVSUXSEG4EI32_V_MF2_MF8 }, // 528 + { 0x4, 0x0, 0x0, 0x5, 0x6, 0x0, PseudoVSUXSEG4EI32_V_M1_MF4 }, // 529 + { 0x4, 0x0, 0x0, 0x5, 0x6, 0x7, PseudoVSUXSEG4EI32_V_MF2_MF4 }, // 530 + { 0x4, 0x0, 0x0, 0x5, 0x7, 0x0, PseudoVSUXSEG4EI32_V_M1_MF2 }, // 531 + { 0x4, 0x0, 0x0, 0x5, 0x7, 0x1, PseudoVSUXSEG4EI32_V_M2_MF2 }, // 532 + { 0x4, 0x0, 0x0, 0x5, 0x7, 0x7, PseudoVSUXSEG4EI32_V_MF2_MF2 }, // 533 + { 0x4, 0x0, 0x0, 0x6, 0x0, 0x0, PseudoVSUXSEG4EI64_V_M1_M1 }, // 534 + { 0x4, 0x0, 0x0, 0x6, 0x0, 0x1, PseudoVSUXSEG4EI64_V_M2_M1 }, // 535 + { 0x4, 0x0, 0x0, 0x6, 0x0, 0x2, PseudoVSUXSEG4EI64_V_M4_M1 }, // 536 + { 0x4, 0x0, 0x0, 0x6, 0x0, 0x3, PseudoVSUXSEG4EI64_V_M8_M1 }, // 537 + { 0x4, 0x0, 0x0, 0x6, 0x1, 0x1, PseudoVSUXSEG4EI64_V_M2_M2 }, // 538 + { 0x4, 0x0, 0x0, 0x6, 0x1, 0x2, PseudoVSUXSEG4EI64_V_M4_M2 }, // 539 + { 0x4, 0x0, 0x0, 0x6, 0x1, 0x3, PseudoVSUXSEG4EI64_V_M8_M2 }, // 540 + { 0x4, 0x0, 0x0, 0x6, 0x5, 0x0, PseudoVSUXSEG4EI64_V_M1_MF8 }, // 541 + { 0x4, 0x0, 0x0, 0x6, 0x6, 0x0, PseudoVSUXSEG4EI64_V_M1_MF4 }, // 542 + { 0x4, 0x0, 0x0, 0x6, 0x6, 0x1, PseudoVSUXSEG4EI64_V_M2_MF4 }, // 543 + { 0x4, 0x0, 0x0, 0x6, 0x7, 0x0, PseudoVSUXSEG4EI64_V_M1_MF2 }, // 544 + { 0x4, 0x0, 0x0, 0x6, 0x7, 0x1, PseudoVSUXSEG4EI64_V_M2_MF2 }, // 545 + { 0x4, 0x0, 0x0, 0x6, 0x7, 0x2, PseudoVSUXSEG4EI64_V_M4_MF2 }, // 546 + { 0x4, 0x0, 0x1, 0x3, 0x0, 0x0, PseudoVSOXSEG4EI8_V_M1_M1 }, // 547 + { 0x4, 0x0, 0x1, 0x3, 0x0, 0x5, PseudoVSOXSEG4EI8_V_MF8_M1 }, // 548 + { 0x4, 0x0, 0x1, 0x3, 0x0, 0x6, PseudoVSOXSEG4EI8_V_MF4_M1 }, // 549 + { 0x4, 0x0, 0x1, 0x3, 0x0, 0x7, PseudoVSOXSEG4EI8_V_MF2_M1 }, // 550 + { 0x4, 0x0, 0x1, 0x3, 0x1, 0x0, PseudoVSOXSEG4EI8_V_M1_M2 }, // 551 + { 0x4, 0x0, 0x1, 0x3, 0x1, 0x1, PseudoVSOXSEG4EI8_V_M2_M2 }, // 552 + { 0x4, 0x0, 0x1, 0x3, 0x1, 0x6, PseudoVSOXSEG4EI8_V_MF4_M2 }, // 553 + { 0x4, 0x0, 0x1, 0x3, 0x1, 0x7, PseudoVSOXSEG4EI8_V_MF2_M2 }, // 554 + { 0x4, 0x0, 0x1, 0x3, 0x5, 0x5, PseudoVSOXSEG4EI8_V_MF8_MF8 }, // 555 + { 0x4, 0x0, 0x1, 0x3, 0x6, 0x5, PseudoVSOXSEG4EI8_V_MF8_MF4 }, // 556 + { 0x4, 0x0, 0x1, 0x3, 0x6, 0x6, PseudoVSOXSEG4EI8_V_MF4_MF4 }, // 557 + { 0x4, 0x0, 0x1, 0x3, 0x7, 0x5, PseudoVSOXSEG4EI8_V_MF8_MF2 }, // 558 + { 0x4, 0x0, 0x1, 0x3, 0x7, 0x6, PseudoVSOXSEG4EI8_V_MF4_MF2 }, // 559 + { 0x4, 0x0, 0x1, 0x3, 0x7, 0x7, PseudoVSOXSEG4EI8_V_MF2_MF2 }, // 560 + { 0x4, 0x0, 0x1, 0x4, 0x0, 0x0, PseudoVSOXSEG4EI16_V_M1_M1 }, // 561 + { 0x4, 0x0, 0x1, 0x4, 0x0, 0x1, PseudoVSOXSEG4EI16_V_M2_M1 }, // 562 + { 0x4, 0x0, 0x1, 0x4, 0x0, 0x6, PseudoVSOXSEG4EI16_V_MF4_M1 }, // 563 + { 0x4, 0x0, 0x1, 0x4, 0x0, 0x7, PseudoVSOXSEG4EI16_V_MF2_M1 }, // 564 + { 0x4, 0x0, 0x1, 0x4, 0x1, 0x0, PseudoVSOXSEG4EI16_V_M1_M2 }, // 565 + { 0x4, 0x0, 0x1, 0x4, 0x1, 0x1, PseudoVSOXSEG4EI16_V_M2_M2 }, // 566 + { 0x4, 0x0, 0x1, 0x4, 0x1, 0x2, PseudoVSOXSEG4EI16_V_M4_M2 }, // 567 + { 0x4, 0x0, 0x1, 0x4, 0x1, 0x7, PseudoVSOXSEG4EI16_V_MF2_M2 }, // 568 + { 0x4, 0x0, 0x1, 0x4, 0x5, 0x6, PseudoVSOXSEG4EI16_V_MF4_MF8 }, // 569 + { 0x4, 0x0, 0x1, 0x4, 0x6, 0x6, PseudoVSOXSEG4EI16_V_MF4_MF4 }, // 570 + { 0x4, 0x0, 0x1, 0x4, 0x6, 0x7, PseudoVSOXSEG4EI16_V_MF2_MF4 }, // 571 + { 0x4, 0x0, 0x1, 0x4, 0x7, 0x0, PseudoVSOXSEG4EI16_V_M1_MF2 }, // 572 + { 0x4, 0x0, 0x1, 0x4, 0x7, 0x6, PseudoVSOXSEG4EI16_V_MF4_MF2 }, // 573 + { 0x4, 0x0, 0x1, 0x4, 0x7, 0x7, PseudoVSOXSEG4EI16_V_MF2_MF2 }, // 574 + { 0x4, 0x0, 0x1, 0x5, 0x0, 0x0, PseudoVSOXSEG4EI32_V_M1_M1 }, // 575 + { 0x4, 0x0, 0x1, 0x5, 0x0, 0x1, PseudoVSOXSEG4EI32_V_M2_M1 }, // 576 + { 0x4, 0x0, 0x1, 0x5, 0x0, 0x2, PseudoVSOXSEG4EI32_V_M4_M1 }, // 577 + { 0x4, 0x0, 0x1, 0x5, 0x0, 0x7, PseudoVSOXSEG4EI32_V_MF2_M1 }, // 578 + { 0x4, 0x0, 0x1, 0x5, 0x1, 0x0, PseudoVSOXSEG4EI32_V_M1_M2 }, // 579 + { 0x4, 0x0, 0x1, 0x5, 0x1, 0x1, PseudoVSOXSEG4EI32_V_M2_M2 }, // 580 + { 0x4, 0x0, 0x1, 0x5, 0x1, 0x2, PseudoVSOXSEG4EI32_V_M4_M2 }, // 581 + { 0x4, 0x0, 0x1, 0x5, 0x1, 0x3, PseudoVSOXSEG4EI32_V_M8_M2 }, // 582 + { 0x4, 0x0, 0x1, 0x5, 0x5, 0x7, PseudoVSOXSEG4EI32_V_MF2_MF8 }, // 583 + { 0x4, 0x0, 0x1, 0x5, 0x6, 0x0, PseudoVSOXSEG4EI32_V_M1_MF4 }, // 584 + { 0x4, 0x0, 0x1, 0x5, 0x6, 0x7, PseudoVSOXSEG4EI32_V_MF2_MF4 }, // 585 + { 0x4, 0x0, 0x1, 0x5, 0x7, 0x0, PseudoVSOXSEG4EI32_V_M1_MF2 }, // 586 + { 0x4, 0x0, 0x1, 0x5, 0x7, 0x1, PseudoVSOXSEG4EI32_V_M2_MF2 }, // 587 + { 0x4, 0x0, 0x1, 0x5, 0x7, 0x7, PseudoVSOXSEG4EI32_V_MF2_MF2 }, // 588 + { 0x4, 0x0, 0x1, 0x6, 0x0, 0x0, PseudoVSOXSEG4EI64_V_M1_M1 }, // 589 + { 0x4, 0x0, 0x1, 0x6, 0x0, 0x1, PseudoVSOXSEG4EI64_V_M2_M1 }, // 590 + { 0x4, 0x0, 0x1, 0x6, 0x0, 0x2, PseudoVSOXSEG4EI64_V_M4_M1 }, // 591 + { 0x4, 0x0, 0x1, 0x6, 0x0, 0x3, PseudoVSOXSEG4EI64_V_M8_M1 }, // 592 + { 0x4, 0x0, 0x1, 0x6, 0x1, 0x1, PseudoVSOXSEG4EI64_V_M2_M2 }, // 593 + { 0x4, 0x0, 0x1, 0x6, 0x1, 0x2, PseudoVSOXSEG4EI64_V_M4_M2 }, // 594 + { 0x4, 0x0, 0x1, 0x6, 0x1, 0x3, PseudoVSOXSEG4EI64_V_M8_M2 }, // 595 + { 0x4, 0x0, 0x1, 0x6, 0x5, 0x0, PseudoVSOXSEG4EI64_V_M1_MF8 }, // 596 + { 0x4, 0x0, 0x1, 0x6, 0x6, 0x0, PseudoVSOXSEG4EI64_V_M1_MF4 }, // 597 + { 0x4, 0x0, 0x1, 0x6, 0x6, 0x1, PseudoVSOXSEG4EI64_V_M2_MF4 }, // 598 + { 0x4, 0x0, 0x1, 0x6, 0x7, 0x0, PseudoVSOXSEG4EI64_V_M1_MF2 }, // 599 + { 0x4, 0x0, 0x1, 0x6, 0x7, 0x1, PseudoVSOXSEG4EI64_V_M2_MF2 }, // 600 + { 0x4, 0x0, 0x1, 0x6, 0x7, 0x2, PseudoVSOXSEG4EI64_V_M4_MF2 }, // 601 + { 0x4, 0x1, 0x0, 0x3, 0x0, 0x0, PseudoVSUXSEG4EI8_V_M1_M1_MASK }, // 602 + { 0x4, 0x1, 0x0, 0x3, 0x0, 0x5, PseudoVSUXSEG4EI8_V_MF8_M1_MASK }, // 603 + { 0x4, 0x1, 0x0, 0x3, 0x0, 0x6, PseudoVSUXSEG4EI8_V_MF4_M1_MASK }, // 604 + { 0x4, 0x1, 0x0, 0x3, 0x0, 0x7, PseudoVSUXSEG4EI8_V_MF2_M1_MASK }, // 605 + { 0x4, 0x1, 0x0, 0x3, 0x1, 0x0, PseudoVSUXSEG4EI8_V_M1_M2_MASK }, // 606 + { 0x4, 0x1, 0x0, 0x3, 0x1, 0x1, PseudoVSUXSEG4EI8_V_M2_M2_MASK }, // 607 + { 0x4, 0x1, 0x0, 0x3, 0x1, 0x6, PseudoVSUXSEG4EI8_V_MF4_M2_MASK }, // 608 + { 0x4, 0x1, 0x0, 0x3, 0x1, 0x7, PseudoVSUXSEG4EI8_V_MF2_M2_MASK }, // 609 + { 0x4, 0x1, 0x0, 0x3, 0x5, 0x5, PseudoVSUXSEG4EI8_V_MF8_MF8_MASK }, // 610 + { 0x4, 0x1, 0x0, 0x3, 0x6, 0x5, PseudoVSUXSEG4EI8_V_MF8_MF4_MASK }, // 611 + { 0x4, 0x1, 0x0, 0x3, 0x6, 0x6, PseudoVSUXSEG4EI8_V_MF4_MF4_MASK }, // 612 + { 0x4, 0x1, 0x0, 0x3, 0x7, 0x5, PseudoVSUXSEG4EI8_V_MF8_MF2_MASK }, // 613 + { 0x4, 0x1, 0x0, 0x3, 0x7, 0x6, PseudoVSUXSEG4EI8_V_MF4_MF2_MASK }, // 614 + { 0x4, 0x1, 0x0, 0x3, 0x7, 0x7, PseudoVSUXSEG4EI8_V_MF2_MF2_MASK }, // 615 + { 0x4, 0x1, 0x0, 0x4, 0x0, 0x0, PseudoVSUXSEG4EI16_V_M1_M1_MASK }, // 616 + { 0x4, 0x1, 0x0, 0x4, 0x0, 0x1, PseudoVSUXSEG4EI16_V_M2_M1_MASK }, // 617 + { 0x4, 0x1, 0x0, 0x4, 0x0, 0x6, PseudoVSUXSEG4EI16_V_MF4_M1_MASK }, // 618 + { 0x4, 0x1, 0x0, 0x4, 0x0, 0x7, PseudoVSUXSEG4EI16_V_MF2_M1_MASK }, // 619 + { 0x4, 0x1, 0x0, 0x4, 0x1, 0x0, PseudoVSUXSEG4EI16_V_M1_M2_MASK }, // 620 + { 0x4, 0x1, 0x0, 0x4, 0x1, 0x1, PseudoVSUXSEG4EI16_V_M2_M2_MASK }, // 621 + { 0x4, 0x1, 0x0, 0x4, 0x1, 0x2, PseudoVSUXSEG4EI16_V_M4_M2_MASK }, // 622 + { 0x4, 0x1, 0x0, 0x4, 0x1, 0x7, PseudoVSUXSEG4EI16_V_MF2_M2_MASK }, // 623 + { 0x4, 0x1, 0x0, 0x4, 0x5, 0x6, PseudoVSUXSEG4EI16_V_MF4_MF8_MASK }, // 624 + { 0x4, 0x1, 0x0, 0x4, 0x6, 0x6, PseudoVSUXSEG4EI16_V_MF4_MF4_MASK }, // 625 + { 0x4, 0x1, 0x0, 0x4, 0x6, 0x7, PseudoVSUXSEG4EI16_V_MF2_MF4_MASK }, // 626 + { 0x4, 0x1, 0x0, 0x4, 0x7, 0x0, PseudoVSUXSEG4EI16_V_M1_MF2_MASK }, // 627 + { 0x4, 0x1, 0x0, 0x4, 0x7, 0x6, PseudoVSUXSEG4EI16_V_MF4_MF2_MASK }, // 628 + { 0x4, 0x1, 0x0, 0x4, 0x7, 0x7, PseudoVSUXSEG4EI16_V_MF2_MF2_MASK }, // 629 + { 0x4, 0x1, 0x0, 0x5, 0x0, 0x0, PseudoVSUXSEG4EI32_V_M1_M1_MASK }, // 630 + { 0x4, 0x1, 0x0, 0x5, 0x0, 0x1, PseudoVSUXSEG4EI32_V_M2_M1_MASK }, // 631 + { 0x4, 0x1, 0x0, 0x5, 0x0, 0x2, PseudoVSUXSEG4EI32_V_M4_M1_MASK }, // 632 + { 0x4, 0x1, 0x0, 0x5, 0x0, 0x7, PseudoVSUXSEG4EI32_V_MF2_M1_MASK }, // 633 + { 0x4, 0x1, 0x0, 0x5, 0x1, 0x0, PseudoVSUXSEG4EI32_V_M1_M2_MASK }, // 634 + { 0x4, 0x1, 0x0, 0x5, 0x1, 0x1, PseudoVSUXSEG4EI32_V_M2_M2_MASK }, // 635 + { 0x4, 0x1, 0x0, 0x5, 0x1, 0x2, PseudoVSUXSEG4EI32_V_M4_M2_MASK }, // 636 + { 0x4, 0x1, 0x0, 0x5, 0x1, 0x3, PseudoVSUXSEG4EI32_V_M8_M2_MASK }, // 637 + { 0x4, 0x1, 0x0, 0x5, 0x5, 0x7, PseudoVSUXSEG4EI32_V_MF2_MF8_MASK }, // 638 + { 0x4, 0x1, 0x0, 0x5, 0x6, 0x0, PseudoVSUXSEG4EI32_V_M1_MF4_MASK }, // 639 + { 0x4, 0x1, 0x0, 0x5, 0x6, 0x7, PseudoVSUXSEG4EI32_V_MF2_MF4_MASK }, // 640 + { 0x4, 0x1, 0x0, 0x5, 0x7, 0x0, PseudoVSUXSEG4EI32_V_M1_MF2_MASK }, // 641 + { 0x4, 0x1, 0x0, 0x5, 0x7, 0x1, PseudoVSUXSEG4EI32_V_M2_MF2_MASK }, // 642 + { 0x4, 0x1, 0x0, 0x5, 0x7, 0x7, PseudoVSUXSEG4EI32_V_MF2_MF2_MASK }, // 643 + { 0x4, 0x1, 0x0, 0x6, 0x0, 0x0, PseudoVSUXSEG4EI64_V_M1_M1_MASK }, // 644 + { 0x4, 0x1, 0x0, 0x6, 0x0, 0x1, PseudoVSUXSEG4EI64_V_M2_M1_MASK }, // 645 + { 0x4, 0x1, 0x0, 0x6, 0x0, 0x2, PseudoVSUXSEG4EI64_V_M4_M1_MASK }, // 646 + { 0x4, 0x1, 0x0, 0x6, 0x0, 0x3, PseudoVSUXSEG4EI64_V_M8_M1_MASK }, // 647 + { 0x4, 0x1, 0x0, 0x6, 0x1, 0x1, PseudoVSUXSEG4EI64_V_M2_M2_MASK }, // 648 + { 0x4, 0x1, 0x0, 0x6, 0x1, 0x2, PseudoVSUXSEG4EI64_V_M4_M2_MASK }, // 649 + { 0x4, 0x1, 0x0, 0x6, 0x1, 0x3, PseudoVSUXSEG4EI64_V_M8_M2_MASK }, // 650 + { 0x4, 0x1, 0x0, 0x6, 0x5, 0x0, PseudoVSUXSEG4EI64_V_M1_MF8_MASK }, // 651 + { 0x4, 0x1, 0x0, 0x6, 0x6, 0x0, PseudoVSUXSEG4EI64_V_M1_MF4_MASK }, // 652 + { 0x4, 0x1, 0x0, 0x6, 0x6, 0x1, PseudoVSUXSEG4EI64_V_M2_MF4_MASK }, // 653 + { 0x4, 0x1, 0x0, 0x6, 0x7, 0x0, PseudoVSUXSEG4EI64_V_M1_MF2_MASK }, // 654 + { 0x4, 0x1, 0x0, 0x6, 0x7, 0x1, PseudoVSUXSEG4EI64_V_M2_MF2_MASK }, // 655 + { 0x4, 0x1, 0x0, 0x6, 0x7, 0x2, PseudoVSUXSEG4EI64_V_M4_MF2_MASK }, // 656 + { 0x4, 0x1, 0x1, 0x3, 0x0, 0x0, PseudoVSOXSEG4EI8_V_M1_M1_MASK }, // 657 + { 0x4, 0x1, 0x1, 0x3, 0x0, 0x5, PseudoVSOXSEG4EI8_V_MF8_M1_MASK }, // 658 + { 0x4, 0x1, 0x1, 0x3, 0x0, 0x6, PseudoVSOXSEG4EI8_V_MF4_M1_MASK }, // 659 + { 0x4, 0x1, 0x1, 0x3, 0x0, 0x7, PseudoVSOXSEG4EI8_V_MF2_M1_MASK }, // 660 + { 0x4, 0x1, 0x1, 0x3, 0x1, 0x0, PseudoVSOXSEG4EI8_V_M1_M2_MASK }, // 661 + { 0x4, 0x1, 0x1, 0x3, 0x1, 0x1, PseudoVSOXSEG4EI8_V_M2_M2_MASK }, // 662 + { 0x4, 0x1, 0x1, 0x3, 0x1, 0x6, PseudoVSOXSEG4EI8_V_MF4_M2_MASK }, // 663 + { 0x4, 0x1, 0x1, 0x3, 0x1, 0x7, PseudoVSOXSEG4EI8_V_MF2_M2_MASK }, // 664 + { 0x4, 0x1, 0x1, 0x3, 0x5, 0x5, PseudoVSOXSEG4EI8_V_MF8_MF8_MASK }, // 665 + { 0x4, 0x1, 0x1, 0x3, 0x6, 0x5, PseudoVSOXSEG4EI8_V_MF8_MF4_MASK }, // 666 + { 0x4, 0x1, 0x1, 0x3, 0x6, 0x6, PseudoVSOXSEG4EI8_V_MF4_MF4_MASK }, // 667 + { 0x4, 0x1, 0x1, 0x3, 0x7, 0x5, PseudoVSOXSEG4EI8_V_MF8_MF2_MASK }, // 668 + { 0x4, 0x1, 0x1, 0x3, 0x7, 0x6, PseudoVSOXSEG4EI8_V_MF4_MF2_MASK }, // 669 + { 0x4, 0x1, 0x1, 0x3, 0x7, 0x7, PseudoVSOXSEG4EI8_V_MF2_MF2_MASK }, // 670 + { 0x4, 0x1, 0x1, 0x4, 0x0, 0x0, PseudoVSOXSEG4EI16_V_M1_M1_MASK }, // 671 + { 0x4, 0x1, 0x1, 0x4, 0x0, 0x1, PseudoVSOXSEG4EI16_V_M2_M1_MASK }, // 672 + { 0x4, 0x1, 0x1, 0x4, 0x0, 0x6, PseudoVSOXSEG4EI16_V_MF4_M1_MASK }, // 673 + { 0x4, 0x1, 0x1, 0x4, 0x0, 0x7, PseudoVSOXSEG4EI16_V_MF2_M1_MASK }, // 674 + { 0x4, 0x1, 0x1, 0x4, 0x1, 0x0, PseudoVSOXSEG4EI16_V_M1_M2_MASK }, // 675 + { 0x4, 0x1, 0x1, 0x4, 0x1, 0x1, PseudoVSOXSEG4EI16_V_M2_M2_MASK }, // 676 + { 0x4, 0x1, 0x1, 0x4, 0x1, 0x2, PseudoVSOXSEG4EI16_V_M4_M2_MASK }, // 677 + { 0x4, 0x1, 0x1, 0x4, 0x1, 0x7, PseudoVSOXSEG4EI16_V_MF2_M2_MASK }, // 678 + { 0x4, 0x1, 0x1, 0x4, 0x5, 0x6, PseudoVSOXSEG4EI16_V_MF4_MF8_MASK }, // 679 + { 0x4, 0x1, 0x1, 0x4, 0x6, 0x6, PseudoVSOXSEG4EI16_V_MF4_MF4_MASK }, // 680 + { 0x4, 0x1, 0x1, 0x4, 0x6, 0x7, PseudoVSOXSEG4EI16_V_MF2_MF4_MASK }, // 681 + { 0x4, 0x1, 0x1, 0x4, 0x7, 0x0, PseudoVSOXSEG4EI16_V_M1_MF2_MASK }, // 682 + { 0x4, 0x1, 0x1, 0x4, 0x7, 0x6, PseudoVSOXSEG4EI16_V_MF4_MF2_MASK }, // 683 + { 0x4, 0x1, 0x1, 0x4, 0x7, 0x7, PseudoVSOXSEG4EI16_V_MF2_MF2_MASK }, // 684 + { 0x4, 0x1, 0x1, 0x5, 0x0, 0x0, PseudoVSOXSEG4EI32_V_M1_M1_MASK }, // 685 + { 0x4, 0x1, 0x1, 0x5, 0x0, 0x1, PseudoVSOXSEG4EI32_V_M2_M1_MASK }, // 686 + { 0x4, 0x1, 0x1, 0x5, 0x0, 0x2, PseudoVSOXSEG4EI32_V_M4_M1_MASK }, // 687 + { 0x4, 0x1, 0x1, 0x5, 0x0, 0x7, PseudoVSOXSEG4EI32_V_MF2_M1_MASK }, // 688 + { 0x4, 0x1, 0x1, 0x5, 0x1, 0x0, PseudoVSOXSEG4EI32_V_M1_M2_MASK }, // 689 + { 0x4, 0x1, 0x1, 0x5, 0x1, 0x1, PseudoVSOXSEG4EI32_V_M2_M2_MASK }, // 690 + { 0x4, 0x1, 0x1, 0x5, 0x1, 0x2, PseudoVSOXSEG4EI32_V_M4_M2_MASK }, // 691 + { 0x4, 0x1, 0x1, 0x5, 0x1, 0x3, PseudoVSOXSEG4EI32_V_M8_M2_MASK }, // 692 + { 0x4, 0x1, 0x1, 0x5, 0x5, 0x7, PseudoVSOXSEG4EI32_V_MF2_MF8_MASK }, // 693 + { 0x4, 0x1, 0x1, 0x5, 0x6, 0x0, PseudoVSOXSEG4EI32_V_M1_MF4_MASK }, // 694 + { 0x4, 0x1, 0x1, 0x5, 0x6, 0x7, PseudoVSOXSEG4EI32_V_MF2_MF4_MASK }, // 695 + { 0x4, 0x1, 0x1, 0x5, 0x7, 0x0, PseudoVSOXSEG4EI32_V_M1_MF2_MASK }, // 696 + { 0x4, 0x1, 0x1, 0x5, 0x7, 0x1, PseudoVSOXSEG4EI32_V_M2_MF2_MASK }, // 697 + { 0x4, 0x1, 0x1, 0x5, 0x7, 0x7, PseudoVSOXSEG4EI32_V_MF2_MF2_MASK }, // 698 + { 0x4, 0x1, 0x1, 0x6, 0x0, 0x0, PseudoVSOXSEG4EI64_V_M1_M1_MASK }, // 699 + { 0x4, 0x1, 0x1, 0x6, 0x0, 0x1, PseudoVSOXSEG4EI64_V_M2_M1_MASK }, // 700 + { 0x4, 0x1, 0x1, 0x6, 0x0, 0x2, PseudoVSOXSEG4EI64_V_M4_M1_MASK }, // 701 + { 0x4, 0x1, 0x1, 0x6, 0x0, 0x3, PseudoVSOXSEG4EI64_V_M8_M1_MASK }, // 702 + { 0x4, 0x1, 0x1, 0x6, 0x1, 0x1, PseudoVSOXSEG4EI64_V_M2_M2_MASK }, // 703 + { 0x4, 0x1, 0x1, 0x6, 0x1, 0x2, PseudoVSOXSEG4EI64_V_M4_M2_MASK }, // 704 + { 0x4, 0x1, 0x1, 0x6, 0x1, 0x3, PseudoVSOXSEG4EI64_V_M8_M2_MASK }, // 705 + { 0x4, 0x1, 0x1, 0x6, 0x5, 0x0, PseudoVSOXSEG4EI64_V_M1_MF8_MASK }, // 706 + { 0x4, 0x1, 0x1, 0x6, 0x6, 0x0, PseudoVSOXSEG4EI64_V_M1_MF4_MASK }, // 707 + { 0x4, 0x1, 0x1, 0x6, 0x6, 0x1, PseudoVSOXSEG4EI64_V_M2_MF4_MASK }, // 708 + { 0x4, 0x1, 0x1, 0x6, 0x7, 0x0, PseudoVSOXSEG4EI64_V_M1_MF2_MASK }, // 709 + { 0x4, 0x1, 0x1, 0x6, 0x7, 0x1, PseudoVSOXSEG4EI64_V_M2_MF2_MASK }, // 710 + { 0x4, 0x1, 0x1, 0x6, 0x7, 0x2, PseudoVSOXSEG4EI64_V_M4_MF2_MASK }, // 711 + { 0x5, 0x0, 0x0, 0x3, 0x0, 0x0, PseudoVSUXSEG5EI8_V_M1_M1 }, // 712 + { 0x5, 0x0, 0x0, 0x3, 0x0, 0x5, PseudoVSUXSEG5EI8_V_MF8_M1 }, // 713 + { 0x5, 0x0, 0x0, 0x3, 0x0, 0x6, PseudoVSUXSEG5EI8_V_MF4_M1 }, // 714 + { 0x5, 0x0, 0x0, 0x3, 0x0, 0x7, PseudoVSUXSEG5EI8_V_MF2_M1 }, // 715 + { 0x5, 0x0, 0x0, 0x3, 0x5, 0x5, PseudoVSUXSEG5EI8_V_MF8_MF8 }, // 716 + { 0x5, 0x0, 0x0, 0x3, 0x6, 0x5, PseudoVSUXSEG5EI8_V_MF8_MF4 }, // 717 + { 0x5, 0x0, 0x0, 0x3, 0x6, 0x6, PseudoVSUXSEG5EI8_V_MF4_MF4 }, // 718 + { 0x5, 0x0, 0x0, 0x3, 0x7, 0x5, PseudoVSUXSEG5EI8_V_MF8_MF2 }, // 719 + { 0x5, 0x0, 0x0, 0x3, 0x7, 0x6, PseudoVSUXSEG5EI8_V_MF4_MF2 }, // 720 + { 0x5, 0x0, 0x0, 0x3, 0x7, 0x7, PseudoVSUXSEG5EI8_V_MF2_MF2 }, // 721 + { 0x5, 0x0, 0x0, 0x4, 0x0, 0x0, PseudoVSUXSEG5EI16_V_M1_M1 }, // 722 + { 0x5, 0x0, 0x0, 0x4, 0x0, 0x1, PseudoVSUXSEG5EI16_V_M2_M1 }, // 723 + { 0x5, 0x0, 0x0, 0x4, 0x0, 0x6, PseudoVSUXSEG5EI16_V_MF4_M1 }, // 724 + { 0x5, 0x0, 0x0, 0x4, 0x0, 0x7, PseudoVSUXSEG5EI16_V_MF2_M1 }, // 725 + { 0x5, 0x0, 0x0, 0x4, 0x5, 0x6, PseudoVSUXSEG5EI16_V_MF4_MF8 }, // 726 + { 0x5, 0x0, 0x0, 0x4, 0x6, 0x6, PseudoVSUXSEG5EI16_V_MF4_MF4 }, // 727 + { 0x5, 0x0, 0x0, 0x4, 0x6, 0x7, PseudoVSUXSEG5EI16_V_MF2_MF4 }, // 728 + { 0x5, 0x0, 0x0, 0x4, 0x7, 0x0, PseudoVSUXSEG5EI16_V_M1_MF2 }, // 729 + { 0x5, 0x0, 0x0, 0x4, 0x7, 0x6, PseudoVSUXSEG5EI16_V_MF4_MF2 }, // 730 + { 0x5, 0x0, 0x0, 0x4, 0x7, 0x7, PseudoVSUXSEG5EI16_V_MF2_MF2 }, // 731 + { 0x5, 0x0, 0x0, 0x5, 0x0, 0x0, PseudoVSUXSEG5EI32_V_M1_M1 }, // 732 + { 0x5, 0x0, 0x0, 0x5, 0x0, 0x1, PseudoVSUXSEG5EI32_V_M2_M1 }, // 733 + { 0x5, 0x0, 0x0, 0x5, 0x0, 0x2, PseudoVSUXSEG5EI32_V_M4_M1 }, // 734 + { 0x5, 0x0, 0x0, 0x5, 0x0, 0x7, PseudoVSUXSEG5EI32_V_MF2_M1 }, // 735 + { 0x5, 0x0, 0x0, 0x5, 0x5, 0x7, PseudoVSUXSEG5EI32_V_MF2_MF8 }, // 736 + { 0x5, 0x0, 0x0, 0x5, 0x6, 0x0, PseudoVSUXSEG5EI32_V_M1_MF4 }, // 737 + { 0x5, 0x0, 0x0, 0x5, 0x6, 0x7, PseudoVSUXSEG5EI32_V_MF2_MF4 }, // 738 + { 0x5, 0x0, 0x0, 0x5, 0x7, 0x0, PseudoVSUXSEG5EI32_V_M1_MF2 }, // 739 + { 0x5, 0x0, 0x0, 0x5, 0x7, 0x1, PseudoVSUXSEG5EI32_V_M2_MF2 }, // 740 + { 0x5, 0x0, 0x0, 0x5, 0x7, 0x7, PseudoVSUXSEG5EI32_V_MF2_MF2 }, // 741 + { 0x5, 0x0, 0x0, 0x6, 0x0, 0x0, PseudoVSUXSEG5EI64_V_M1_M1 }, // 742 + { 0x5, 0x0, 0x0, 0x6, 0x0, 0x1, PseudoVSUXSEG5EI64_V_M2_M1 }, // 743 + { 0x5, 0x0, 0x0, 0x6, 0x0, 0x2, PseudoVSUXSEG5EI64_V_M4_M1 }, // 744 + { 0x5, 0x0, 0x0, 0x6, 0x0, 0x3, PseudoVSUXSEG5EI64_V_M8_M1 }, // 745 + { 0x5, 0x0, 0x0, 0x6, 0x5, 0x0, PseudoVSUXSEG5EI64_V_M1_MF8 }, // 746 + { 0x5, 0x0, 0x0, 0x6, 0x6, 0x0, PseudoVSUXSEG5EI64_V_M1_MF4 }, // 747 + { 0x5, 0x0, 0x0, 0x6, 0x6, 0x1, PseudoVSUXSEG5EI64_V_M2_MF4 }, // 748 + { 0x5, 0x0, 0x0, 0x6, 0x7, 0x0, PseudoVSUXSEG5EI64_V_M1_MF2 }, // 749 + { 0x5, 0x0, 0x0, 0x6, 0x7, 0x1, PseudoVSUXSEG5EI64_V_M2_MF2 }, // 750 + { 0x5, 0x0, 0x0, 0x6, 0x7, 0x2, PseudoVSUXSEG5EI64_V_M4_MF2 }, // 751 + { 0x5, 0x0, 0x1, 0x3, 0x0, 0x0, PseudoVSOXSEG5EI8_V_M1_M1 }, // 752 + { 0x5, 0x0, 0x1, 0x3, 0x0, 0x5, PseudoVSOXSEG5EI8_V_MF8_M1 }, // 753 + { 0x5, 0x0, 0x1, 0x3, 0x0, 0x6, PseudoVSOXSEG5EI8_V_MF4_M1 }, // 754 + { 0x5, 0x0, 0x1, 0x3, 0x0, 0x7, PseudoVSOXSEG5EI8_V_MF2_M1 }, // 755 + { 0x5, 0x0, 0x1, 0x3, 0x5, 0x5, PseudoVSOXSEG5EI8_V_MF8_MF8 }, // 756 + { 0x5, 0x0, 0x1, 0x3, 0x6, 0x5, PseudoVSOXSEG5EI8_V_MF8_MF4 }, // 757 + { 0x5, 0x0, 0x1, 0x3, 0x6, 0x6, PseudoVSOXSEG5EI8_V_MF4_MF4 }, // 758 + { 0x5, 0x0, 0x1, 0x3, 0x7, 0x5, PseudoVSOXSEG5EI8_V_MF8_MF2 }, // 759 + { 0x5, 0x0, 0x1, 0x3, 0x7, 0x6, PseudoVSOXSEG5EI8_V_MF4_MF2 }, // 760 + { 0x5, 0x0, 0x1, 0x3, 0x7, 0x7, PseudoVSOXSEG5EI8_V_MF2_MF2 }, // 761 + { 0x5, 0x0, 0x1, 0x4, 0x0, 0x0, PseudoVSOXSEG5EI16_V_M1_M1 }, // 762 + { 0x5, 0x0, 0x1, 0x4, 0x0, 0x1, PseudoVSOXSEG5EI16_V_M2_M1 }, // 763 + { 0x5, 0x0, 0x1, 0x4, 0x0, 0x6, PseudoVSOXSEG5EI16_V_MF4_M1 }, // 764 + { 0x5, 0x0, 0x1, 0x4, 0x0, 0x7, PseudoVSOXSEG5EI16_V_MF2_M1 }, // 765 + { 0x5, 0x0, 0x1, 0x4, 0x5, 0x6, PseudoVSOXSEG5EI16_V_MF4_MF8 }, // 766 + { 0x5, 0x0, 0x1, 0x4, 0x6, 0x6, PseudoVSOXSEG5EI16_V_MF4_MF4 }, // 767 + { 0x5, 0x0, 0x1, 0x4, 0x6, 0x7, PseudoVSOXSEG5EI16_V_MF2_MF4 }, // 768 + { 0x5, 0x0, 0x1, 0x4, 0x7, 0x0, PseudoVSOXSEG5EI16_V_M1_MF2 }, // 769 + { 0x5, 0x0, 0x1, 0x4, 0x7, 0x6, PseudoVSOXSEG5EI16_V_MF4_MF2 }, // 770 + { 0x5, 0x0, 0x1, 0x4, 0x7, 0x7, PseudoVSOXSEG5EI16_V_MF2_MF2 }, // 771 + { 0x5, 0x0, 0x1, 0x5, 0x0, 0x0, PseudoVSOXSEG5EI32_V_M1_M1 }, // 772 + { 0x5, 0x0, 0x1, 0x5, 0x0, 0x1, PseudoVSOXSEG5EI32_V_M2_M1 }, // 773 + { 0x5, 0x0, 0x1, 0x5, 0x0, 0x2, PseudoVSOXSEG5EI32_V_M4_M1 }, // 774 + { 0x5, 0x0, 0x1, 0x5, 0x0, 0x7, PseudoVSOXSEG5EI32_V_MF2_M1 }, // 775 + { 0x5, 0x0, 0x1, 0x5, 0x5, 0x7, PseudoVSOXSEG5EI32_V_MF2_MF8 }, // 776 + { 0x5, 0x0, 0x1, 0x5, 0x6, 0x0, PseudoVSOXSEG5EI32_V_M1_MF4 }, // 777 + { 0x5, 0x0, 0x1, 0x5, 0x6, 0x7, PseudoVSOXSEG5EI32_V_MF2_MF4 }, // 778 + { 0x5, 0x0, 0x1, 0x5, 0x7, 0x0, PseudoVSOXSEG5EI32_V_M1_MF2 }, // 779 + { 0x5, 0x0, 0x1, 0x5, 0x7, 0x1, PseudoVSOXSEG5EI32_V_M2_MF2 }, // 780 + { 0x5, 0x0, 0x1, 0x5, 0x7, 0x7, PseudoVSOXSEG5EI32_V_MF2_MF2 }, // 781 + { 0x5, 0x0, 0x1, 0x6, 0x0, 0x0, PseudoVSOXSEG5EI64_V_M1_M1 }, // 782 + { 0x5, 0x0, 0x1, 0x6, 0x0, 0x1, PseudoVSOXSEG5EI64_V_M2_M1 }, // 783 + { 0x5, 0x0, 0x1, 0x6, 0x0, 0x2, PseudoVSOXSEG5EI64_V_M4_M1 }, // 784 + { 0x5, 0x0, 0x1, 0x6, 0x0, 0x3, PseudoVSOXSEG5EI64_V_M8_M1 }, // 785 + { 0x5, 0x0, 0x1, 0x6, 0x5, 0x0, PseudoVSOXSEG5EI64_V_M1_MF8 }, // 786 + { 0x5, 0x0, 0x1, 0x6, 0x6, 0x0, PseudoVSOXSEG5EI64_V_M1_MF4 }, // 787 + { 0x5, 0x0, 0x1, 0x6, 0x6, 0x1, PseudoVSOXSEG5EI64_V_M2_MF4 }, // 788 + { 0x5, 0x0, 0x1, 0x6, 0x7, 0x0, PseudoVSOXSEG5EI64_V_M1_MF2 }, // 789 + { 0x5, 0x0, 0x1, 0x6, 0x7, 0x1, PseudoVSOXSEG5EI64_V_M2_MF2 }, // 790 + { 0x5, 0x0, 0x1, 0x6, 0x7, 0x2, PseudoVSOXSEG5EI64_V_M4_MF2 }, // 791 + { 0x5, 0x1, 0x0, 0x3, 0x0, 0x0, PseudoVSUXSEG5EI8_V_M1_M1_MASK }, // 792 + { 0x5, 0x1, 0x0, 0x3, 0x0, 0x5, PseudoVSUXSEG5EI8_V_MF8_M1_MASK }, // 793 + { 0x5, 0x1, 0x0, 0x3, 0x0, 0x6, PseudoVSUXSEG5EI8_V_MF4_M1_MASK }, // 794 + { 0x5, 0x1, 0x0, 0x3, 0x0, 0x7, PseudoVSUXSEG5EI8_V_MF2_M1_MASK }, // 795 + { 0x5, 0x1, 0x0, 0x3, 0x5, 0x5, PseudoVSUXSEG5EI8_V_MF8_MF8_MASK }, // 796 + { 0x5, 0x1, 0x0, 0x3, 0x6, 0x5, PseudoVSUXSEG5EI8_V_MF8_MF4_MASK }, // 797 + { 0x5, 0x1, 0x0, 0x3, 0x6, 0x6, PseudoVSUXSEG5EI8_V_MF4_MF4_MASK }, // 798 + { 0x5, 0x1, 0x0, 0x3, 0x7, 0x5, PseudoVSUXSEG5EI8_V_MF8_MF2_MASK }, // 799 + { 0x5, 0x1, 0x0, 0x3, 0x7, 0x6, PseudoVSUXSEG5EI8_V_MF4_MF2_MASK }, // 800 + { 0x5, 0x1, 0x0, 0x3, 0x7, 0x7, PseudoVSUXSEG5EI8_V_MF2_MF2_MASK }, // 801 + { 0x5, 0x1, 0x0, 0x4, 0x0, 0x0, PseudoVSUXSEG5EI16_V_M1_M1_MASK }, // 802 + { 0x5, 0x1, 0x0, 0x4, 0x0, 0x1, PseudoVSUXSEG5EI16_V_M2_M1_MASK }, // 803 + { 0x5, 0x1, 0x0, 0x4, 0x0, 0x6, PseudoVSUXSEG5EI16_V_MF4_M1_MASK }, // 804 + { 0x5, 0x1, 0x0, 0x4, 0x0, 0x7, PseudoVSUXSEG5EI16_V_MF2_M1_MASK }, // 805 + { 0x5, 0x1, 0x0, 0x4, 0x5, 0x6, PseudoVSUXSEG5EI16_V_MF4_MF8_MASK }, // 806 + { 0x5, 0x1, 0x0, 0x4, 0x6, 0x6, PseudoVSUXSEG5EI16_V_MF4_MF4_MASK }, // 807 + { 0x5, 0x1, 0x0, 0x4, 0x6, 0x7, PseudoVSUXSEG5EI16_V_MF2_MF4_MASK }, // 808 + { 0x5, 0x1, 0x0, 0x4, 0x7, 0x0, PseudoVSUXSEG5EI16_V_M1_MF2_MASK }, // 809 + { 0x5, 0x1, 0x0, 0x4, 0x7, 0x6, PseudoVSUXSEG5EI16_V_MF4_MF2_MASK }, // 810 + { 0x5, 0x1, 0x0, 0x4, 0x7, 0x7, PseudoVSUXSEG5EI16_V_MF2_MF2_MASK }, // 811 + { 0x5, 0x1, 0x0, 0x5, 0x0, 0x0, PseudoVSUXSEG5EI32_V_M1_M1_MASK }, // 812 + { 0x5, 0x1, 0x0, 0x5, 0x0, 0x1, PseudoVSUXSEG5EI32_V_M2_M1_MASK }, // 813 + { 0x5, 0x1, 0x0, 0x5, 0x0, 0x2, PseudoVSUXSEG5EI32_V_M4_M1_MASK }, // 814 + { 0x5, 0x1, 0x0, 0x5, 0x0, 0x7, PseudoVSUXSEG5EI32_V_MF2_M1_MASK }, // 815 + { 0x5, 0x1, 0x0, 0x5, 0x5, 0x7, PseudoVSUXSEG5EI32_V_MF2_MF8_MASK }, // 816 + { 0x5, 0x1, 0x0, 0x5, 0x6, 0x0, PseudoVSUXSEG5EI32_V_M1_MF4_MASK }, // 817 + { 0x5, 0x1, 0x0, 0x5, 0x6, 0x7, PseudoVSUXSEG5EI32_V_MF2_MF4_MASK }, // 818 + { 0x5, 0x1, 0x0, 0x5, 0x7, 0x0, PseudoVSUXSEG5EI32_V_M1_MF2_MASK }, // 819 + { 0x5, 0x1, 0x0, 0x5, 0x7, 0x1, PseudoVSUXSEG5EI32_V_M2_MF2_MASK }, // 820 + { 0x5, 0x1, 0x0, 0x5, 0x7, 0x7, PseudoVSUXSEG5EI32_V_MF2_MF2_MASK }, // 821 + { 0x5, 0x1, 0x0, 0x6, 0x0, 0x0, PseudoVSUXSEG5EI64_V_M1_M1_MASK }, // 822 + { 0x5, 0x1, 0x0, 0x6, 0x0, 0x1, PseudoVSUXSEG5EI64_V_M2_M1_MASK }, // 823 + { 0x5, 0x1, 0x0, 0x6, 0x0, 0x2, PseudoVSUXSEG5EI64_V_M4_M1_MASK }, // 824 + { 0x5, 0x1, 0x0, 0x6, 0x0, 0x3, PseudoVSUXSEG5EI64_V_M8_M1_MASK }, // 825 + { 0x5, 0x1, 0x0, 0x6, 0x5, 0x0, PseudoVSUXSEG5EI64_V_M1_MF8_MASK }, // 826 + { 0x5, 0x1, 0x0, 0x6, 0x6, 0x0, PseudoVSUXSEG5EI64_V_M1_MF4_MASK }, // 827 + { 0x5, 0x1, 0x0, 0x6, 0x6, 0x1, PseudoVSUXSEG5EI64_V_M2_MF4_MASK }, // 828 + { 0x5, 0x1, 0x0, 0x6, 0x7, 0x0, PseudoVSUXSEG5EI64_V_M1_MF2_MASK }, // 829 + { 0x5, 0x1, 0x0, 0x6, 0x7, 0x1, PseudoVSUXSEG5EI64_V_M2_MF2_MASK }, // 830 + { 0x5, 0x1, 0x0, 0x6, 0x7, 0x2, PseudoVSUXSEG5EI64_V_M4_MF2_MASK }, // 831 + { 0x5, 0x1, 0x1, 0x3, 0x0, 0x0, PseudoVSOXSEG5EI8_V_M1_M1_MASK }, // 832 + { 0x5, 0x1, 0x1, 0x3, 0x0, 0x5, PseudoVSOXSEG5EI8_V_MF8_M1_MASK }, // 833 + { 0x5, 0x1, 0x1, 0x3, 0x0, 0x6, PseudoVSOXSEG5EI8_V_MF4_M1_MASK }, // 834 + { 0x5, 0x1, 0x1, 0x3, 0x0, 0x7, PseudoVSOXSEG5EI8_V_MF2_M1_MASK }, // 835 + { 0x5, 0x1, 0x1, 0x3, 0x5, 0x5, PseudoVSOXSEG5EI8_V_MF8_MF8_MASK }, // 836 + { 0x5, 0x1, 0x1, 0x3, 0x6, 0x5, PseudoVSOXSEG5EI8_V_MF8_MF4_MASK }, // 837 + { 0x5, 0x1, 0x1, 0x3, 0x6, 0x6, PseudoVSOXSEG5EI8_V_MF4_MF4_MASK }, // 838 + { 0x5, 0x1, 0x1, 0x3, 0x7, 0x5, PseudoVSOXSEG5EI8_V_MF8_MF2_MASK }, // 839 + { 0x5, 0x1, 0x1, 0x3, 0x7, 0x6, PseudoVSOXSEG5EI8_V_MF4_MF2_MASK }, // 840 + { 0x5, 0x1, 0x1, 0x3, 0x7, 0x7, PseudoVSOXSEG5EI8_V_MF2_MF2_MASK }, // 841 + { 0x5, 0x1, 0x1, 0x4, 0x0, 0x0, PseudoVSOXSEG5EI16_V_M1_M1_MASK }, // 842 + { 0x5, 0x1, 0x1, 0x4, 0x0, 0x1, PseudoVSOXSEG5EI16_V_M2_M1_MASK }, // 843 + { 0x5, 0x1, 0x1, 0x4, 0x0, 0x6, PseudoVSOXSEG5EI16_V_MF4_M1_MASK }, // 844 + { 0x5, 0x1, 0x1, 0x4, 0x0, 0x7, PseudoVSOXSEG5EI16_V_MF2_M1_MASK }, // 845 + { 0x5, 0x1, 0x1, 0x4, 0x5, 0x6, PseudoVSOXSEG5EI16_V_MF4_MF8_MASK }, // 846 + { 0x5, 0x1, 0x1, 0x4, 0x6, 0x6, PseudoVSOXSEG5EI16_V_MF4_MF4_MASK }, // 847 + { 0x5, 0x1, 0x1, 0x4, 0x6, 0x7, PseudoVSOXSEG5EI16_V_MF2_MF4_MASK }, // 848 + { 0x5, 0x1, 0x1, 0x4, 0x7, 0x0, PseudoVSOXSEG5EI16_V_M1_MF2_MASK }, // 849 + { 0x5, 0x1, 0x1, 0x4, 0x7, 0x6, PseudoVSOXSEG5EI16_V_MF4_MF2_MASK }, // 850 + { 0x5, 0x1, 0x1, 0x4, 0x7, 0x7, PseudoVSOXSEG5EI16_V_MF2_MF2_MASK }, // 851 + { 0x5, 0x1, 0x1, 0x5, 0x0, 0x0, PseudoVSOXSEG5EI32_V_M1_M1_MASK }, // 852 + { 0x5, 0x1, 0x1, 0x5, 0x0, 0x1, PseudoVSOXSEG5EI32_V_M2_M1_MASK }, // 853 + { 0x5, 0x1, 0x1, 0x5, 0x0, 0x2, PseudoVSOXSEG5EI32_V_M4_M1_MASK }, // 854 + { 0x5, 0x1, 0x1, 0x5, 0x0, 0x7, PseudoVSOXSEG5EI32_V_MF2_M1_MASK }, // 855 + { 0x5, 0x1, 0x1, 0x5, 0x5, 0x7, PseudoVSOXSEG5EI32_V_MF2_MF8_MASK }, // 856 + { 0x5, 0x1, 0x1, 0x5, 0x6, 0x0, PseudoVSOXSEG5EI32_V_M1_MF4_MASK }, // 857 + { 0x5, 0x1, 0x1, 0x5, 0x6, 0x7, PseudoVSOXSEG5EI32_V_MF2_MF4_MASK }, // 858 + { 0x5, 0x1, 0x1, 0x5, 0x7, 0x0, PseudoVSOXSEG5EI32_V_M1_MF2_MASK }, // 859 + { 0x5, 0x1, 0x1, 0x5, 0x7, 0x1, PseudoVSOXSEG5EI32_V_M2_MF2_MASK }, // 860 + { 0x5, 0x1, 0x1, 0x5, 0x7, 0x7, PseudoVSOXSEG5EI32_V_MF2_MF2_MASK }, // 861 + { 0x5, 0x1, 0x1, 0x6, 0x0, 0x0, PseudoVSOXSEG5EI64_V_M1_M1_MASK }, // 862 + { 0x5, 0x1, 0x1, 0x6, 0x0, 0x1, PseudoVSOXSEG5EI64_V_M2_M1_MASK }, // 863 + { 0x5, 0x1, 0x1, 0x6, 0x0, 0x2, PseudoVSOXSEG5EI64_V_M4_M1_MASK }, // 864 + { 0x5, 0x1, 0x1, 0x6, 0x0, 0x3, PseudoVSOXSEG5EI64_V_M8_M1_MASK }, // 865 + { 0x5, 0x1, 0x1, 0x6, 0x5, 0x0, PseudoVSOXSEG5EI64_V_M1_MF8_MASK }, // 866 + { 0x5, 0x1, 0x1, 0x6, 0x6, 0x0, PseudoVSOXSEG5EI64_V_M1_MF4_MASK }, // 867 + { 0x5, 0x1, 0x1, 0x6, 0x6, 0x1, PseudoVSOXSEG5EI64_V_M2_MF4_MASK }, // 868 + { 0x5, 0x1, 0x1, 0x6, 0x7, 0x0, PseudoVSOXSEG5EI64_V_M1_MF2_MASK }, // 869 + { 0x5, 0x1, 0x1, 0x6, 0x7, 0x1, PseudoVSOXSEG5EI64_V_M2_MF2_MASK }, // 870 + { 0x5, 0x1, 0x1, 0x6, 0x7, 0x2, PseudoVSOXSEG5EI64_V_M4_MF2_MASK }, // 871 + { 0x6, 0x0, 0x0, 0x3, 0x0, 0x0, PseudoVSUXSEG6EI8_V_M1_M1 }, // 872 + { 0x6, 0x0, 0x0, 0x3, 0x0, 0x5, PseudoVSUXSEG6EI8_V_MF8_M1 }, // 873 + { 0x6, 0x0, 0x0, 0x3, 0x0, 0x6, PseudoVSUXSEG6EI8_V_MF4_M1 }, // 874 + { 0x6, 0x0, 0x0, 0x3, 0x0, 0x7, PseudoVSUXSEG6EI8_V_MF2_M1 }, // 875 + { 0x6, 0x0, 0x0, 0x3, 0x5, 0x5, PseudoVSUXSEG6EI8_V_MF8_MF8 }, // 876 + { 0x6, 0x0, 0x0, 0x3, 0x6, 0x5, PseudoVSUXSEG6EI8_V_MF8_MF4 }, // 877 + { 0x6, 0x0, 0x0, 0x3, 0x6, 0x6, PseudoVSUXSEG6EI8_V_MF4_MF4 }, // 878 + { 0x6, 0x0, 0x0, 0x3, 0x7, 0x5, PseudoVSUXSEG6EI8_V_MF8_MF2 }, // 879 + { 0x6, 0x0, 0x0, 0x3, 0x7, 0x6, PseudoVSUXSEG6EI8_V_MF4_MF2 }, // 880 + { 0x6, 0x0, 0x0, 0x3, 0x7, 0x7, PseudoVSUXSEG6EI8_V_MF2_MF2 }, // 881 + { 0x6, 0x0, 0x0, 0x4, 0x0, 0x0, PseudoVSUXSEG6EI16_V_M1_M1 }, // 882 + { 0x6, 0x0, 0x0, 0x4, 0x0, 0x1, PseudoVSUXSEG6EI16_V_M2_M1 }, // 883 + { 0x6, 0x0, 0x0, 0x4, 0x0, 0x6, PseudoVSUXSEG6EI16_V_MF4_M1 }, // 884 + { 0x6, 0x0, 0x0, 0x4, 0x0, 0x7, PseudoVSUXSEG6EI16_V_MF2_M1 }, // 885 + { 0x6, 0x0, 0x0, 0x4, 0x5, 0x6, PseudoVSUXSEG6EI16_V_MF4_MF8 }, // 886 + { 0x6, 0x0, 0x0, 0x4, 0x6, 0x6, PseudoVSUXSEG6EI16_V_MF4_MF4 }, // 887 + { 0x6, 0x0, 0x0, 0x4, 0x6, 0x7, PseudoVSUXSEG6EI16_V_MF2_MF4 }, // 888 + { 0x6, 0x0, 0x0, 0x4, 0x7, 0x0, PseudoVSUXSEG6EI16_V_M1_MF2 }, // 889 + { 0x6, 0x0, 0x0, 0x4, 0x7, 0x6, PseudoVSUXSEG6EI16_V_MF4_MF2 }, // 890 + { 0x6, 0x0, 0x0, 0x4, 0x7, 0x7, PseudoVSUXSEG6EI16_V_MF2_MF2 }, // 891 + { 0x6, 0x0, 0x0, 0x5, 0x0, 0x0, PseudoVSUXSEG6EI32_V_M1_M1 }, // 892 + { 0x6, 0x0, 0x0, 0x5, 0x0, 0x1, PseudoVSUXSEG6EI32_V_M2_M1 }, // 893 + { 0x6, 0x0, 0x0, 0x5, 0x0, 0x2, PseudoVSUXSEG6EI32_V_M4_M1 }, // 894 + { 0x6, 0x0, 0x0, 0x5, 0x0, 0x7, PseudoVSUXSEG6EI32_V_MF2_M1 }, // 895 + { 0x6, 0x0, 0x0, 0x5, 0x5, 0x7, PseudoVSUXSEG6EI32_V_MF2_MF8 }, // 896 + { 0x6, 0x0, 0x0, 0x5, 0x6, 0x0, PseudoVSUXSEG6EI32_V_M1_MF4 }, // 897 + { 0x6, 0x0, 0x0, 0x5, 0x6, 0x7, PseudoVSUXSEG6EI32_V_MF2_MF4 }, // 898 + { 0x6, 0x0, 0x0, 0x5, 0x7, 0x0, PseudoVSUXSEG6EI32_V_M1_MF2 }, // 899 + { 0x6, 0x0, 0x0, 0x5, 0x7, 0x1, PseudoVSUXSEG6EI32_V_M2_MF2 }, // 900 + { 0x6, 0x0, 0x0, 0x5, 0x7, 0x7, PseudoVSUXSEG6EI32_V_MF2_MF2 }, // 901 + { 0x6, 0x0, 0x0, 0x6, 0x0, 0x0, PseudoVSUXSEG6EI64_V_M1_M1 }, // 902 + { 0x6, 0x0, 0x0, 0x6, 0x0, 0x1, PseudoVSUXSEG6EI64_V_M2_M1 }, // 903 + { 0x6, 0x0, 0x0, 0x6, 0x0, 0x2, PseudoVSUXSEG6EI64_V_M4_M1 }, // 904 + { 0x6, 0x0, 0x0, 0x6, 0x0, 0x3, PseudoVSUXSEG6EI64_V_M8_M1 }, // 905 + { 0x6, 0x0, 0x0, 0x6, 0x5, 0x0, PseudoVSUXSEG6EI64_V_M1_MF8 }, // 906 + { 0x6, 0x0, 0x0, 0x6, 0x6, 0x0, PseudoVSUXSEG6EI64_V_M1_MF4 }, // 907 + { 0x6, 0x0, 0x0, 0x6, 0x6, 0x1, PseudoVSUXSEG6EI64_V_M2_MF4 }, // 908 + { 0x6, 0x0, 0x0, 0x6, 0x7, 0x0, PseudoVSUXSEG6EI64_V_M1_MF2 }, // 909 + { 0x6, 0x0, 0x0, 0x6, 0x7, 0x1, PseudoVSUXSEG6EI64_V_M2_MF2 }, // 910 + { 0x6, 0x0, 0x0, 0x6, 0x7, 0x2, PseudoVSUXSEG6EI64_V_M4_MF2 }, // 911 + { 0x6, 0x0, 0x1, 0x3, 0x0, 0x0, PseudoVSOXSEG6EI8_V_M1_M1 }, // 912 + { 0x6, 0x0, 0x1, 0x3, 0x0, 0x5, PseudoVSOXSEG6EI8_V_MF8_M1 }, // 913 + { 0x6, 0x0, 0x1, 0x3, 0x0, 0x6, PseudoVSOXSEG6EI8_V_MF4_M1 }, // 914 + { 0x6, 0x0, 0x1, 0x3, 0x0, 0x7, PseudoVSOXSEG6EI8_V_MF2_M1 }, // 915 + { 0x6, 0x0, 0x1, 0x3, 0x5, 0x5, PseudoVSOXSEG6EI8_V_MF8_MF8 }, // 916 + { 0x6, 0x0, 0x1, 0x3, 0x6, 0x5, PseudoVSOXSEG6EI8_V_MF8_MF4 }, // 917 + { 0x6, 0x0, 0x1, 0x3, 0x6, 0x6, PseudoVSOXSEG6EI8_V_MF4_MF4 }, // 918 + { 0x6, 0x0, 0x1, 0x3, 0x7, 0x5, PseudoVSOXSEG6EI8_V_MF8_MF2 }, // 919 + { 0x6, 0x0, 0x1, 0x3, 0x7, 0x6, PseudoVSOXSEG6EI8_V_MF4_MF2 }, // 920 + { 0x6, 0x0, 0x1, 0x3, 0x7, 0x7, PseudoVSOXSEG6EI8_V_MF2_MF2 }, // 921 + { 0x6, 0x0, 0x1, 0x4, 0x0, 0x0, PseudoVSOXSEG6EI16_V_M1_M1 }, // 922 + { 0x6, 0x0, 0x1, 0x4, 0x0, 0x1, PseudoVSOXSEG6EI16_V_M2_M1 }, // 923 + { 0x6, 0x0, 0x1, 0x4, 0x0, 0x6, PseudoVSOXSEG6EI16_V_MF4_M1 }, // 924 + { 0x6, 0x0, 0x1, 0x4, 0x0, 0x7, PseudoVSOXSEG6EI16_V_MF2_M1 }, // 925 + { 0x6, 0x0, 0x1, 0x4, 0x5, 0x6, PseudoVSOXSEG6EI16_V_MF4_MF8 }, // 926 + { 0x6, 0x0, 0x1, 0x4, 0x6, 0x6, PseudoVSOXSEG6EI16_V_MF4_MF4 }, // 927 + { 0x6, 0x0, 0x1, 0x4, 0x6, 0x7, PseudoVSOXSEG6EI16_V_MF2_MF4 }, // 928 + { 0x6, 0x0, 0x1, 0x4, 0x7, 0x0, PseudoVSOXSEG6EI16_V_M1_MF2 }, // 929 + { 0x6, 0x0, 0x1, 0x4, 0x7, 0x6, PseudoVSOXSEG6EI16_V_MF4_MF2 }, // 930 + { 0x6, 0x0, 0x1, 0x4, 0x7, 0x7, PseudoVSOXSEG6EI16_V_MF2_MF2 }, // 931 + { 0x6, 0x0, 0x1, 0x5, 0x0, 0x0, PseudoVSOXSEG6EI32_V_M1_M1 }, // 932 + { 0x6, 0x0, 0x1, 0x5, 0x0, 0x1, PseudoVSOXSEG6EI32_V_M2_M1 }, // 933 + { 0x6, 0x0, 0x1, 0x5, 0x0, 0x2, PseudoVSOXSEG6EI32_V_M4_M1 }, // 934 + { 0x6, 0x0, 0x1, 0x5, 0x0, 0x7, PseudoVSOXSEG6EI32_V_MF2_M1 }, // 935 + { 0x6, 0x0, 0x1, 0x5, 0x5, 0x7, PseudoVSOXSEG6EI32_V_MF2_MF8 }, // 936 + { 0x6, 0x0, 0x1, 0x5, 0x6, 0x0, PseudoVSOXSEG6EI32_V_M1_MF4 }, // 937 + { 0x6, 0x0, 0x1, 0x5, 0x6, 0x7, PseudoVSOXSEG6EI32_V_MF2_MF4 }, // 938 + { 0x6, 0x0, 0x1, 0x5, 0x7, 0x0, PseudoVSOXSEG6EI32_V_M1_MF2 }, // 939 + { 0x6, 0x0, 0x1, 0x5, 0x7, 0x1, PseudoVSOXSEG6EI32_V_M2_MF2 }, // 940 + { 0x6, 0x0, 0x1, 0x5, 0x7, 0x7, PseudoVSOXSEG6EI32_V_MF2_MF2 }, // 941 + { 0x6, 0x0, 0x1, 0x6, 0x0, 0x0, PseudoVSOXSEG6EI64_V_M1_M1 }, // 942 + { 0x6, 0x0, 0x1, 0x6, 0x0, 0x1, PseudoVSOXSEG6EI64_V_M2_M1 }, // 943 + { 0x6, 0x0, 0x1, 0x6, 0x0, 0x2, PseudoVSOXSEG6EI64_V_M4_M1 }, // 944 + { 0x6, 0x0, 0x1, 0x6, 0x0, 0x3, PseudoVSOXSEG6EI64_V_M8_M1 }, // 945 + { 0x6, 0x0, 0x1, 0x6, 0x5, 0x0, PseudoVSOXSEG6EI64_V_M1_MF8 }, // 946 + { 0x6, 0x0, 0x1, 0x6, 0x6, 0x0, PseudoVSOXSEG6EI64_V_M1_MF4 }, // 947 + { 0x6, 0x0, 0x1, 0x6, 0x6, 0x1, PseudoVSOXSEG6EI64_V_M2_MF4 }, // 948 + { 0x6, 0x0, 0x1, 0x6, 0x7, 0x0, PseudoVSOXSEG6EI64_V_M1_MF2 }, // 949 + { 0x6, 0x0, 0x1, 0x6, 0x7, 0x1, PseudoVSOXSEG6EI64_V_M2_MF2 }, // 950 + { 0x6, 0x0, 0x1, 0x6, 0x7, 0x2, PseudoVSOXSEG6EI64_V_M4_MF2 }, // 951 + { 0x6, 0x1, 0x0, 0x3, 0x0, 0x0, PseudoVSUXSEG6EI8_V_M1_M1_MASK }, // 952 + { 0x6, 0x1, 0x0, 0x3, 0x0, 0x5, PseudoVSUXSEG6EI8_V_MF8_M1_MASK }, // 953 + { 0x6, 0x1, 0x0, 0x3, 0x0, 0x6, PseudoVSUXSEG6EI8_V_MF4_M1_MASK }, // 954 + { 0x6, 0x1, 0x0, 0x3, 0x0, 0x7, PseudoVSUXSEG6EI8_V_MF2_M1_MASK }, // 955 + { 0x6, 0x1, 0x0, 0x3, 0x5, 0x5, PseudoVSUXSEG6EI8_V_MF8_MF8_MASK }, // 956 + { 0x6, 0x1, 0x0, 0x3, 0x6, 0x5, PseudoVSUXSEG6EI8_V_MF8_MF4_MASK }, // 957 + { 0x6, 0x1, 0x0, 0x3, 0x6, 0x6, PseudoVSUXSEG6EI8_V_MF4_MF4_MASK }, // 958 + { 0x6, 0x1, 0x0, 0x3, 0x7, 0x5, PseudoVSUXSEG6EI8_V_MF8_MF2_MASK }, // 959 + { 0x6, 0x1, 0x0, 0x3, 0x7, 0x6, PseudoVSUXSEG6EI8_V_MF4_MF2_MASK }, // 960 + { 0x6, 0x1, 0x0, 0x3, 0x7, 0x7, PseudoVSUXSEG6EI8_V_MF2_MF2_MASK }, // 961 + { 0x6, 0x1, 0x0, 0x4, 0x0, 0x0, PseudoVSUXSEG6EI16_V_M1_M1_MASK }, // 962 + { 0x6, 0x1, 0x0, 0x4, 0x0, 0x1, PseudoVSUXSEG6EI16_V_M2_M1_MASK }, // 963 + { 0x6, 0x1, 0x0, 0x4, 0x0, 0x6, PseudoVSUXSEG6EI16_V_MF4_M1_MASK }, // 964 + { 0x6, 0x1, 0x0, 0x4, 0x0, 0x7, PseudoVSUXSEG6EI16_V_MF2_M1_MASK }, // 965 + { 0x6, 0x1, 0x0, 0x4, 0x5, 0x6, PseudoVSUXSEG6EI16_V_MF4_MF8_MASK }, // 966 + { 0x6, 0x1, 0x0, 0x4, 0x6, 0x6, PseudoVSUXSEG6EI16_V_MF4_MF4_MASK }, // 967 + { 0x6, 0x1, 0x0, 0x4, 0x6, 0x7, PseudoVSUXSEG6EI16_V_MF2_MF4_MASK }, // 968 + { 0x6, 0x1, 0x0, 0x4, 0x7, 0x0, PseudoVSUXSEG6EI16_V_M1_MF2_MASK }, // 969 + { 0x6, 0x1, 0x0, 0x4, 0x7, 0x6, PseudoVSUXSEG6EI16_V_MF4_MF2_MASK }, // 970 + { 0x6, 0x1, 0x0, 0x4, 0x7, 0x7, PseudoVSUXSEG6EI16_V_MF2_MF2_MASK }, // 971 + { 0x6, 0x1, 0x0, 0x5, 0x0, 0x0, PseudoVSUXSEG6EI32_V_M1_M1_MASK }, // 972 + { 0x6, 0x1, 0x0, 0x5, 0x0, 0x1, PseudoVSUXSEG6EI32_V_M2_M1_MASK }, // 973 + { 0x6, 0x1, 0x0, 0x5, 0x0, 0x2, PseudoVSUXSEG6EI32_V_M4_M1_MASK }, // 974 + { 0x6, 0x1, 0x0, 0x5, 0x0, 0x7, PseudoVSUXSEG6EI32_V_MF2_M1_MASK }, // 975 + { 0x6, 0x1, 0x0, 0x5, 0x5, 0x7, PseudoVSUXSEG6EI32_V_MF2_MF8_MASK }, // 976 + { 0x6, 0x1, 0x0, 0x5, 0x6, 0x0, PseudoVSUXSEG6EI32_V_M1_MF4_MASK }, // 977 + { 0x6, 0x1, 0x0, 0x5, 0x6, 0x7, PseudoVSUXSEG6EI32_V_MF2_MF4_MASK }, // 978 + { 0x6, 0x1, 0x0, 0x5, 0x7, 0x0, PseudoVSUXSEG6EI32_V_M1_MF2_MASK }, // 979 + { 0x6, 0x1, 0x0, 0x5, 0x7, 0x1, PseudoVSUXSEG6EI32_V_M2_MF2_MASK }, // 980 + { 0x6, 0x1, 0x0, 0x5, 0x7, 0x7, PseudoVSUXSEG6EI32_V_MF2_MF2_MASK }, // 981 + { 0x6, 0x1, 0x0, 0x6, 0x0, 0x0, PseudoVSUXSEG6EI64_V_M1_M1_MASK }, // 982 + { 0x6, 0x1, 0x0, 0x6, 0x0, 0x1, PseudoVSUXSEG6EI64_V_M2_M1_MASK }, // 983 + { 0x6, 0x1, 0x0, 0x6, 0x0, 0x2, PseudoVSUXSEG6EI64_V_M4_M1_MASK }, // 984 + { 0x6, 0x1, 0x0, 0x6, 0x0, 0x3, PseudoVSUXSEG6EI64_V_M8_M1_MASK }, // 985 + { 0x6, 0x1, 0x0, 0x6, 0x5, 0x0, PseudoVSUXSEG6EI64_V_M1_MF8_MASK }, // 986 + { 0x6, 0x1, 0x0, 0x6, 0x6, 0x0, PseudoVSUXSEG6EI64_V_M1_MF4_MASK }, // 987 + { 0x6, 0x1, 0x0, 0x6, 0x6, 0x1, PseudoVSUXSEG6EI64_V_M2_MF4_MASK }, // 988 + { 0x6, 0x1, 0x0, 0x6, 0x7, 0x0, PseudoVSUXSEG6EI64_V_M1_MF2_MASK }, // 989 + { 0x6, 0x1, 0x0, 0x6, 0x7, 0x1, PseudoVSUXSEG6EI64_V_M2_MF2_MASK }, // 990 + { 0x6, 0x1, 0x0, 0x6, 0x7, 0x2, PseudoVSUXSEG6EI64_V_M4_MF2_MASK }, // 991 + { 0x6, 0x1, 0x1, 0x3, 0x0, 0x0, PseudoVSOXSEG6EI8_V_M1_M1_MASK }, // 992 + { 0x6, 0x1, 0x1, 0x3, 0x0, 0x5, PseudoVSOXSEG6EI8_V_MF8_M1_MASK }, // 993 + { 0x6, 0x1, 0x1, 0x3, 0x0, 0x6, PseudoVSOXSEG6EI8_V_MF4_M1_MASK }, // 994 + { 0x6, 0x1, 0x1, 0x3, 0x0, 0x7, PseudoVSOXSEG6EI8_V_MF2_M1_MASK }, // 995 + { 0x6, 0x1, 0x1, 0x3, 0x5, 0x5, PseudoVSOXSEG6EI8_V_MF8_MF8_MASK }, // 996 + { 0x6, 0x1, 0x1, 0x3, 0x6, 0x5, PseudoVSOXSEG6EI8_V_MF8_MF4_MASK }, // 997 + { 0x6, 0x1, 0x1, 0x3, 0x6, 0x6, PseudoVSOXSEG6EI8_V_MF4_MF4_MASK }, // 998 + { 0x6, 0x1, 0x1, 0x3, 0x7, 0x5, PseudoVSOXSEG6EI8_V_MF8_MF2_MASK }, // 999 + { 0x6, 0x1, 0x1, 0x3, 0x7, 0x6, PseudoVSOXSEG6EI8_V_MF4_MF2_MASK }, // 1000 + { 0x6, 0x1, 0x1, 0x3, 0x7, 0x7, PseudoVSOXSEG6EI8_V_MF2_MF2_MASK }, // 1001 + { 0x6, 0x1, 0x1, 0x4, 0x0, 0x0, PseudoVSOXSEG6EI16_V_M1_M1_MASK }, // 1002 + { 0x6, 0x1, 0x1, 0x4, 0x0, 0x1, PseudoVSOXSEG6EI16_V_M2_M1_MASK }, // 1003 + { 0x6, 0x1, 0x1, 0x4, 0x0, 0x6, PseudoVSOXSEG6EI16_V_MF4_M1_MASK }, // 1004 + { 0x6, 0x1, 0x1, 0x4, 0x0, 0x7, PseudoVSOXSEG6EI16_V_MF2_M1_MASK }, // 1005 + { 0x6, 0x1, 0x1, 0x4, 0x5, 0x6, PseudoVSOXSEG6EI16_V_MF4_MF8_MASK }, // 1006 + { 0x6, 0x1, 0x1, 0x4, 0x6, 0x6, PseudoVSOXSEG6EI16_V_MF4_MF4_MASK }, // 1007 + { 0x6, 0x1, 0x1, 0x4, 0x6, 0x7, PseudoVSOXSEG6EI16_V_MF2_MF4_MASK }, // 1008 + { 0x6, 0x1, 0x1, 0x4, 0x7, 0x0, PseudoVSOXSEG6EI16_V_M1_MF2_MASK }, // 1009 + { 0x6, 0x1, 0x1, 0x4, 0x7, 0x6, PseudoVSOXSEG6EI16_V_MF4_MF2_MASK }, // 1010 + { 0x6, 0x1, 0x1, 0x4, 0x7, 0x7, PseudoVSOXSEG6EI16_V_MF2_MF2_MASK }, // 1011 + { 0x6, 0x1, 0x1, 0x5, 0x0, 0x0, PseudoVSOXSEG6EI32_V_M1_M1_MASK }, // 1012 + { 0x6, 0x1, 0x1, 0x5, 0x0, 0x1, PseudoVSOXSEG6EI32_V_M2_M1_MASK }, // 1013 + { 0x6, 0x1, 0x1, 0x5, 0x0, 0x2, PseudoVSOXSEG6EI32_V_M4_M1_MASK }, // 1014 + { 0x6, 0x1, 0x1, 0x5, 0x0, 0x7, PseudoVSOXSEG6EI32_V_MF2_M1_MASK }, // 1015 + { 0x6, 0x1, 0x1, 0x5, 0x5, 0x7, PseudoVSOXSEG6EI32_V_MF2_MF8_MASK }, // 1016 + { 0x6, 0x1, 0x1, 0x5, 0x6, 0x0, PseudoVSOXSEG6EI32_V_M1_MF4_MASK }, // 1017 + { 0x6, 0x1, 0x1, 0x5, 0x6, 0x7, PseudoVSOXSEG6EI32_V_MF2_MF4_MASK }, // 1018 + { 0x6, 0x1, 0x1, 0x5, 0x7, 0x0, PseudoVSOXSEG6EI32_V_M1_MF2_MASK }, // 1019 + { 0x6, 0x1, 0x1, 0x5, 0x7, 0x1, PseudoVSOXSEG6EI32_V_M2_MF2_MASK }, // 1020 + { 0x6, 0x1, 0x1, 0x5, 0x7, 0x7, PseudoVSOXSEG6EI32_V_MF2_MF2_MASK }, // 1021 + { 0x6, 0x1, 0x1, 0x6, 0x0, 0x0, PseudoVSOXSEG6EI64_V_M1_M1_MASK }, // 1022 + { 0x6, 0x1, 0x1, 0x6, 0x0, 0x1, PseudoVSOXSEG6EI64_V_M2_M1_MASK }, // 1023 + { 0x6, 0x1, 0x1, 0x6, 0x0, 0x2, PseudoVSOXSEG6EI64_V_M4_M1_MASK }, // 1024 + { 0x6, 0x1, 0x1, 0x6, 0x0, 0x3, PseudoVSOXSEG6EI64_V_M8_M1_MASK }, // 1025 + { 0x6, 0x1, 0x1, 0x6, 0x5, 0x0, PseudoVSOXSEG6EI64_V_M1_MF8_MASK }, // 1026 + { 0x6, 0x1, 0x1, 0x6, 0x6, 0x0, PseudoVSOXSEG6EI64_V_M1_MF4_MASK }, // 1027 + { 0x6, 0x1, 0x1, 0x6, 0x6, 0x1, PseudoVSOXSEG6EI64_V_M2_MF4_MASK }, // 1028 + { 0x6, 0x1, 0x1, 0x6, 0x7, 0x0, PseudoVSOXSEG6EI64_V_M1_MF2_MASK }, // 1029 + { 0x6, 0x1, 0x1, 0x6, 0x7, 0x1, PseudoVSOXSEG6EI64_V_M2_MF2_MASK }, // 1030 + { 0x6, 0x1, 0x1, 0x6, 0x7, 0x2, PseudoVSOXSEG6EI64_V_M4_MF2_MASK }, // 1031 + { 0x7, 0x0, 0x0, 0x3, 0x0, 0x0, PseudoVSUXSEG7EI8_V_M1_M1 }, // 1032 + { 0x7, 0x0, 0x0, 0x3, 0x0, 0x5, PseudoVSUXSEG7EI8_V_MF8_M1 }, // 1033 + { 0x7, 0x0, 0x0, 0x3, 0x0, 0x6, PseudoVSUXSEG7EI8_V_MF4_M1 }, // 1034 + { 0x7, 0x0, 0x0, 0x3, 0x0, 0x7, PseudoVSUXSEG7EI8_V_MF2_M1 }, // 1035 + { 0x7, 0x0, 0x0, 0x3, 0x5, 0x5, PseudoVSUXSEG7EI8_V_MF8_MF8 }, // 1036 + { 0x7, 0x0, 0x0, 0x3, 0x6, 0x5, PseudoVSUXSEG7EI8_V_MF8_MF4 }, // 1037 + { 0x7, 0x0, 0x0, 0x3, 0x6, 0x6, PseudoVSUXSEG7EI8_V_MF4_MF4 }, // 1038 + { 0x7, 0x0, 0x0, 0x3, 0x7, 0x5, PseudoVSUXSEG7EI8_V_MF8_MF2 }, // 1039 + { 0x7, 0x0, 0x0, 0x3, 0x7, 0x6, PseudoVSUXSEG7EI8_V_MF4_MF2 }, // 1040 + { 0x7, 0x0, 0x0, 0x3, 0x7, 0x7, PseudoVSUXSEG7EI8_V_MF2_MF2 }, // 1041 + { 0x7, 0x0, 0x0, 0x4, 0x0, 0x0, PseudoVSUXSEG7EI16_V_M1_M1 }, // 1042 + { 0x7, 0x0, 0x0, 0x4, 0x0, 0x1, PseudoVSUXSEG7EI16_V_M2_M1 }, // 1043 + { 0x7, 0x0, 0x0, 0x4, 0x0, 0x6, PseudoVSUXSEG7EI16_V_MF4_M1 }, // 1044 + { 0x7, 0x0, 0x0, 0x4, 0x0, 0x7, PseudoVSUXSEG7EI16_V_MF2_M1 }, // 1045 + { 0x7, 0x0, 0x0, 0x4, 0x5, 0x6, PseudoVSUXSEG7EI16_V_MF4_MF8 }, // 1046 + { 0x7, 0x0, 0x0, 0x4, 0x6, 0x6, PseudoVSUXSEG7EI16_V_MF4_MF4 }, // 1047 + { 0x7, 0x0, 0x0, 0x4, 0x6, 0x7, PseudoVSUXSEG7EI16_V_MF2_MF4 }, // 1048 + { 0x7, 0x0, 0x0, 0x4, 0x7, 0x0, PseudoVSUXSEG7EI16_V_M1_MF2 }, // 1049 + { 0x7, 0x0, 0x0, 0x4, 0x7, 0x6, PseudoVSUXSEG7EI16_V_MF4_MF2 }, // 1050 + { 0x7, 0x0, 0x0, 0x4, 0x7, 0x7, PseudoVSUXSEG7EI16_V_MF2_MF2 }, // 1051 + { 0x7, 0x0, 0x0, 0x5, 0x0, 0x0, PseudoVSUXSEG7EI32_V_M1_M1 }, // 1052 + { 0x7, 0x0, 0x0, 0x5, 0x0, 0x1, PseudoVSUXSEG7EI32_V_M2_M1 }, // 1053 + { 0x7, 0x0, 0x0, 0x5, 0x0, 0x2, PseudoVSUXSEG7EI32_V_M4_M1 }, // 1054 + { 0x7, 0x0, 0x0, 0x5, 0x0, 0x7, PseudoVSUXSEG7EI32_V_MF2_M1 }, // 1055 + { 0x7, 0x0, 0x0, 0x5, 0x5, 0x7, PseudoVSUXSEG7EI32_V_MF2_MF8 }, // 1056 + { 0x7, 0x0, 0x0, 0x5, 0x6, 0x0, PseudoVSUXSEG7EI32_V_M1_MF4 }, // 1057 + { 0x7, 0x0, 0x0, 0x5, 0x6, 0x7, PseudoVSUXSEG7EI32_V_MF2_MF4 }, // 1058 + { 0x7, 0x0, 0x0, 0x5, 0x7, 0x0, PseudoVSUXSEG7EI32_V_M1_MF2 }, // 1059 + { 0x7, 0x0, 0x0, 0x5, 0x7, 0x1, PseudoVSUXSEG7EI32_V_M2_MF2 }, // 1060 + { 0x7, 0x0, 0x0, 0x5, 0x7, 0x7, PseudoVSUXSEG7EI32_V_MF2_MF2 }, // 1061 + { 0x7, 0x0, 0x0, 0x6, 0x0, 0x0, PseudoVSUXSEG7EI64_V_M1_M1 }, // 1062 + { 0x7, 0x0, 0x0, 0x6, 0x0, 0x1, PseudoVSUXSEG7EI64_V_M2_M1 }, // 1063 + { 0x7, 0x0, 0x0, 0x6, 0x0, 0x2, PseudoVSUXSEG7EI64_V_M4_M1 }, // 1064 + { 0x7, 0x0, 0x0, 0x6, 0x0, 0x3, PseudoVSUXSEG7EI64_V_M8_M1 }, // 1065 + { 0x7, 0x0, 0x0, 0x6, 0x5, 0x0, PseudoVSUXSEG7EI64_V_M1_MF8 }, // 1066 + { 0x7, 0x0, 0x0, 0x6, 0x6, 0x0, PseudoVSUXSEG7EI64_V_M1_MF4 }, // 1067 + { 0x7, 0x0, 0x0, 0x6, 0x6, 0x1, PseudoVSUXSEG7EI64_V_M2_MF4 }, // 1068 + { 0x7, 0x0, 0x0, 0x6, 0x7, 0x0, PseudoVSUXSEG7EI64_V_M1_MF2 }, // 1069 + { 0x7, 0x0, 0x0, 0x6, 0x7, 0x1, PseudoVSUXSEG7EI64_V_M2_MF2 }, // 1070 + { 0x7, 0x0, 0x0, 0x6, 0x7, 0x2, PseudoVSUXSEG7EI64_V_M4_MF2 }, // 1071 + { 0x7, 0x0, 0x1, 0x3, 0x0, 0x0, PseudoVSOXSEG7EI8_V_M1_M1 }, // 1072 + { 0x7, 0x0, 0x1, 0x3, 0x0, 0x5, PseudoVSOXSEG7EI8_V_MF8_M1 }, // 1073 + { 0x7, 0x0, 0x1, 0x3, 0x0, 0x6, PseudoVSOXSEG7EI8_V_MF4_M1 }, // 1074 + { 0x7, 0x0, 0x1, 0x3, 0x0, 0x7, PseudoVSOXSEG7EI8_V_MF2_M1 }, // 1075 + { 0x7, 0x0, 0x1, 0x3, 0x5, 0x5, PseudoVSOXSEG7EI8_V_MF8_MF8 }, // 1076 + { 0x7, 0x0, 0x1, 0x3, 0x6, 0x5, PseudoVSOXSEG7EI8_V_MF8_MF4 }, // 1077 + { 0x7, 0x0, 0x1, 0x3, 0x6, 0x6, PseudoVSOXSEG7EI8_V_MF4_MF4 }, // 1078 + { 0x7, 0x0, 0x1, 0x3, 0x7, 0x5, PseudoVSOXSEG7EI8_V_MF8_MF2 }, // 1079 + { 0x7, 0x0, 0x1, 0x3, 0x7, 0x6, PseudoVSOXSEG7EI8_V_MF4_MF2 }, // 1080 + { 0x7, 0x0, 0x1, 0x3, 0x7, 0x7, PseudoVSOXSEG7EI8_V_MF2_MF2 }, // 1081 + { 0x7, 0x0, 0x1, 0x4, 0x0, 0x0, PseudoVSOXSEG7EI16_V_M1_M1 }, // 1082 + { 0x7, 0x0, 0x1, 0x4, 0x0, 0x1, PseudoVSOXSEG7EI16_V_M2_M1 }, // 1083 + { 0x7, 0x0, 0x1, 0x4, 0x0, 0x6, PseudoVSOXSEG7EI16_V_MF4_M1 }, // 1084 + { 0x7, 0x0, 0x1, 0x4, 0x0, 0x7, PseudoVSOXSEG7EI16_V_MF2_M1 }, // 1085 + { 0x7, 0x0, 0x1, 0x4, 0x5, 0x6, PseudoVSOXSEG7EI16_V_MF4_MF8 }, // 1086 + { 0x7, 0x0, 0x1, 0x4, 0x6, 0x6, PseudoVSOXSEG7EI16_V_MF4_MF4 }, // 1087 + { 0x7, 0x0, 0x1, 0x4, 0x6, 0x7, PseudoVSOXSEG7EI16_V_MF2_MF4 }, // 1088 + { 0x7, 0x0, 0x1, 0x4, 0x7, 0x0, PseudoVSOXSEG7EI16_V_M1_MF2 }, // 1089 + { 0x7, 0x0, 0x1, 0x4, 0x7, 0x6, PseudoVSOXSEG7EI16_V_MF4_MF2 }, // 1090 + { 0x7, 0x0, 0x1, 0x4, 0x7, 0x7, PseudoVSOXSEG7EI16_V_MF2_MF2 }, // 1091 + { 0x7, 0x0, 0x1, 0x5, 0x0, 0x0, PseudoVSOXSEG7EI32_V_M1_M1 }, // 1092 + { 0x7, 0x0, 0x1, 0x5, 0x0, 0x1, PseudoVSOXSEG7EI32_V_M2_M1 }, // 1093 + { 0x7, 0x0, 0x1, 0x5, 0x0, 0x2, PseudoVSOXSEG7EI32_V_M4_M1 }, // 1094 + { 0x7, 0x0, 0x1, 0x5, 0x0, 0x7, PseudoVSOXSEG7EI32_V_MF2_M1 }, // 1095 + { 0x7, 0x0, 0x1, 0x5, 0x5, 0x7, PseudoVSOXSEG7EI32_V_MF2_MF8 }, // 1096 + { 0x7, 0x0, 0x1, 0x5, 0x6, 0x0, PseudoVSOXSEG7EI32_V_M1_MF4 }, // 1097 + { 0x7, 0x0, 0x1, 0x5, 0x6, 0x7, PseudoVSOXSEG7EI32_V_MF2_MF4 }, // 1098 + { 0x7, 0x0, 0x1, 0x5, 0x7, 0x0, PseudoVSOXSEG7EI32_V_M1_MF2 }, // 1099 + { 0x7, 0x0, 0x1, 0x5, 0x7, 0x1, PseudoVSOXSEG7EI32_V_M2_MF2 }, // 1100 + { 0x7, 0x0, 0x1, 0x5, 0x7, 0x7, PseudoVSOXSEG7EI32_V_MF2_MF2 }, // 1101 + { 0x7, 0x0, 0x1, 0x6, 0x0, 0x0, PseudoVSOXSEG7EI64_V_M1_M1 }, // 1102 + { 0x7, 0x0, 0x1, 0x6, 0x0, 0x1, PseudoVSOXSEG7EI64_V_M2_M1 }, // 1103 + { 0x7, 0x0, 0x1, 0x6, 0x0, 0x2, PseudoVSOXSEG7EI64_V_M4_M1 }, // 1104 + { 0x7, 0x0, 0x1, 0x6, 0x0, 0x3, PseudoVSOXSEG7EI64_V_M8_M1 }, // 1105 + { 0x7, 0x0, 0x1, 0x6, 0x5, 0x0, PseudoVSOXSEG7EI64_V_M1_MF8 }, // 1106 + { 0x7, 0x0, 0x1, 0x6, 0x6, 0x0, PseudoVSOXSEG7EI64_V_M1_MF4 }, // 1107 + { 0x7, 0x0, 0x1, 0x6, 0x6, 0x1, PseudoVSOXSEG7EI64_V_M2_MF4 }, // 1108 + { 0x7, 0x0, 0x1, 0x6, 0x7, 0x0, PseudoVSOXSEG7EI64_V_M1_MF2 }, // 1109 + { 0x7, 0x0, 0x1, 0x6, 0x7, 0x1, PseudoVSOXSEG7EI64_V_M2_MF2 }, // 1110 + { 0x7, 0x0, 0x1, 0x6, 0x7, 0x2, PseudoVSOXSEG7EI64_V_M4_MF2 }, // 1111 + { 0x7, 0x1, 0x0, 0x3, 0x0, 0x0, PseudoVSUXSEG7EI8_V_M1_M1_MASK }, // 1112 + { 0x7, 0x1, 0x0, 0x3, 0x0, 0x5, PseudoVSUXSEG7EI8_V_MF8_M1_MASK }, // 1113 + { 0x7, 0x1, 0x0, 0x3, 0x0, 0x6, PseudoVSUXSEG7EI8_V_MF4_M1_MASK }, // 1114 + { 0x7, 0x1, 0x0, 0x3, 0x0, 0x7, PseudoVSUXSEG7EI8_V_MF2_M1_MASK }, // 1115 + { 0x7, 0x1, 0x0, 0x3, 0x5, 0x5, PseudoVSUXSEG7EI8_V_MF8_MF8_MASK }, // 1116 + { 0x7, 0x1, 0x0, 0x3, 0x6, 0x5, PseudoVSUXSEG7EI8_V_MF8_MF4_MASK }, // 1117 + { 0x7, 0x1, 0x0, 0x3, 0x6, 0x6, PseudoVSUXSEG7EI8_V_MF4_MF4_MASK }, // 1118 + { 0x7, 0x1, 0x0, 0x3, 0x7, 0x5, PseudoVSUXSEG7EI8_V_MF8_MF2_MASK }, // 1119 + { 0x7, 0x1, 0x0, 0x3, 0x7, 0x6, PseudoVSUXSEG7EI8_V_MF4_MF2_MASK }, // 1120 + { 0x7, 0x1, 0x0, 0x3, 0x7, 0x7, PseudoVSUXSEG7EI8_V_MF2_MF2_MASK }, // 1121 + { 0x7, 0x1, 0x0, 0x4, 0x0, 0x0, PseudoVSUXSEG7EI16_V_M1_M1_MASK }, // 1122 + { 0x7, 0x1, 0x0, 0x4, 0x0, 0x1, PseudoVSUXSEG7EI16_V_M2_M1_MASK }, // 1123 + { 0x7, 0x1, 0x0, 0x4, 0x0, 0x6, PseudoVSUXSEG7EI16_V_MF4_M1_MASK }, // 1124 + { 0x7, 0x1, 0x0, 0x4, 0x0, 0x7, PseudoVSUXSEG7EI16_V_MF2_M1_MASK }, // 1125 + { 0x7, 0x1, 0x0, 0x4, 0x5, 0x6, PseudoVSUXSEG7EI16_V_MF4_MF8_MASK }, // 1126 + { 0x7, 0x1, 0x0, 0x4, 0x6, 0x6, PseudoVSUXSEG7EI16_V_MF4_MF4_MASK }, // 1127 + { 0x7, 0x1, 0x0, 0x4, 0x6, 0x7, PseudoVSUXSEG7EI16_V_MF2_MF4_MASK }, // 1128 + { 0x7, 0x1, 0x0, 0x4, 0x7, 0x0, PseudoVSUXSEG7EI16_V_M1_MF2_MASK }, // 1129 + { 0x7, 0x1, 0x0, 0x4, 0x7, 0x6, PseudoVSUXSEG7EI16_V_MF4_MF2_MASK }, // 1130 + { 0x7, 0x1, 0x0, 0x4, 0x7, 0x7, PseudoVSUXSEG7EI16_V_MF2_MF2_MASK }, // 1131 + { 0x7, 0x1, 0x0, 0x5, 0x0, 0x0, PseudoVSUXSEG7EI32_V_M1_M1_MASK }, // 1132 + { 0x7, 0x1, 0x0, 0x5, 0x0, 0x1, PseudoVSUXSEG7EI32_V_M2_M1_MASK }, // 1133 + { 0x7, 0x1, 0x0, 0x5, 0x0, 0x2, PseudoVSUXSEG7EI32_V_M4_M1_MASK }, // 1134 + { 0x7, 0x1, 0x0, 0x5, 0x0, 0x7, PseudoVSUXSEG7EI32_V_MF2_M1_MASK }, // 1135 + { 0x7, 0x1, 0x0, 0x5, 0x5, 0x7, PseudoVSUXSEG7EI32_V_MF2_MF8_MASK }, // 1136 + { 0x7, 0x1, 0x0, 0x5, 0x6, 0x0, PseudoVSUXSEG7EI32_V_M1_MF4_MASK }, // 1137 + { 0x7, 0x1, 0x0, 0x5, 0x6, 0x7, PseudoVSUXSEG7EI32_V_MF2_MF4_MASK }, // 1138 + { 0x7, 0x1, 0x0, 0x5, 0x7, 0x0, PseudoVSUXSEG7EI32_V_M1_MF2_MASK }, // 1139 + { 0x7, 0x1, 0x0, 0x5, 0x7, 0x1, PseudoVSUXSEG7EI32_V_M2_MF2_MASK }, // 1140 + { 0x7, 0x1, 0x0, 0x5, 0x7, 0x7, PseudoVSUXSEG7EI32_V_MF2_MF2_MASK }, // 1141 + { 0x7, 0x1, 0x0, 0x6, 0x0, 0x0, PseudoVSUXSEG7EI64_V_M1_M1_MASK }, // 1142 + { 0x7, 0x1, 0x0, 0x6, 0x0, 0x1, PseudoVSUXSEG7EI64_V_M2_M1_MASK }, // 1143 + { 0x7, 0x1, 0x0, 0x6, 0x0, 0x2, PseudoVSUXSEG7EI64_V_M4_M1_MASK }, // 1144 + { 0x7, 0x1, 0x0, 0x6, 0x0, 0x3, PseudoVSUXSEG7EI64_V_M8_M1_MASK }, // 1145 + { 0x7, 0x1, 0x0, 0x6, 0x5, 0x0, PseudoVSUXSEG7EI64_V_M1_MF8_MASK }, // 1146 + { 0x7, 0x1, 0x0, 0x6, 0x6, 0x0, PseudoVSUXSEG7EI64_V_M1_MF4_MASK }, // 1147 + { 0x7, 0x1, 0x0, 0x6, 0x6, 0x1, PseudoVSUXSEG7EI64_V_M2_MF4_MASK }, // 1148 + { 0x7, 0x1, 0x0, 0x6, 0x7, 0x0, PseudoVSUXSEG7EI64_V_M1_MF2_MASK }, // 1149 + { 0x7, 0x1, 0x0, 0x6, 0x7, 0x1, PseudoVSUXSEG7EI64_V_M2_MF2_MASK }, // 1150 + { 0x7, 0x1, 0x0, 0x6, 0x7, 0x2, PseudoVSUXSEG7EI64_V_M4_MF2_MASK }, // 1151 + { 0x7, 0x1, 0x1, 0x3, 0x0, 0x0, PseudoVSOXSEG7EI8_V_M1_M1_MASK }, // 1152 + { 0x7, 0x1, 0x1, 0x3, 0x0, 0x5, PseudoVSOXSEG7EI8_V_MF8_M1_MASK }, // 1153 + { 0x7, 0x1, 0x1, 0x3, 0x0, 0x6, PseudoVSOXSEG7EI8_V_MF4_M1_MASK }, // 1154 + { 0x7, 0x1, 0x1, 0x3, 0x0, 0x7, PseudoVSOXSEG7EI8_V_MF2_M1_MASK }, // 1155 + { 0x7, 0x1, 0x1, 0x3, 0x5, 0x5, PseudoVSOXSEG7EI8_V_MF8_MF8_MASK }, // 1156 + { 0x7, 0x1, 0x1, 0x3, 0x6, 0x5, PseudoVSOXSEG7EI8_V_MF8_MF4_MASK }, // 1157 + { 0x7, 0x1, 0x1, 0x3, 0x6, 0x6, PseudoVSOXSEG7EI8_V_MF4_MF4_MASK }, // 1158 + { 0x7, 0x1, 0x1, 0x3, 0x7, 0x5, PseudoVSOXSEG7EI8_V_MF8_MF2_MASK }, // 1159 + { 0x7, 0x1, 0x1, 0x3, 0x7, 0x6, PseudoVSOXSEG7EI8_V_MF4_MF2_MASK }, // 1160 + { 0x7, 0x1, 0x1, 0x3, 0x7, 0x7, PseudoVSOXSEG7EI8_V_MF2_MF2_MASK }, // 1161 + { 0x7, 0x1, 0x1, 0x4, 0x0, 0x0, PseudoVSOXSEG7EI16_V_M1_M1_MASK }, // 1162 + { 0x7, 0x1, 0x1, 0x4, 0x0, 0x1, PseudoVSOXSEG7EI16_V_M2_M1_MASK }, // 1163 + { 0x7, 0x1, 0x1, 0x4, 0x0, 0x6, PseudoVSOXSEG7EI16_V_MF4_M1_MASK }, // 1164 + { 0x7, 0x1, 0x1, 0x4, 0x0, 0x7, PseudoVSOXSEG7EI16_V_MF2_M1_MASK }, // 1165 + { 0x7, 0x1, 0x1, 0x4, 0x5, 0x6, PseudoVSOXSEG7EI16_V_MF4_MF8_MASK }, // 1166 + { 0x7, 0x1, 0x1, 0x4, 0x6, 0x6, PseudoVSOXSEG7EI16_V_MF4_MF4_MASK }, // 1167 + { 0x7, 0x1, 0x1, 0x4, 0x6, 0x7, PseudoVSOXSEG7EI16_V_MF2_MF4_MASK }, // 1168 + { 0x7, 0x1, 0x1, 0x4, 0x7, 0x0, PseudoVSOXSEG7EI16_V_M1_MF2_MASK }, // 1169 + { 0x7, 0x1, 0x1, 0x4, 0x7, 0x6, PseudoVSOXSEG7EI16_V_MF4_MF2_MASK }, // 1170 + { 0x7, 0x1, 0x1, 0x4, 0x7, 0x7, PseudoVSOXSEG7EI16_V_MF2_MF2_MASK }, // 1171 + { 0x7, 0x1, 0x1, 0x5, 0x0, 0x0, PseudoVSOXSEG7EI32_V_M1_M1_MASK }, // 1172 + { 0x7, 0x1, 0x1, 0x5, 0x0, 0x1, PseudoVSOXSEG7EI32_V_M2_M1_MASK }, // 1173 + { 0x7, 0x1, 0x1, 0x5, 0x0, 0x2, PseudoVSOXSEG7EI32_V_M4_M1_MASK }, // 1174 + { 0x7, 0x1, 0x1, 0x5, 0x0, 0x7, PseudoVSOXSEG7EI32_V_MF2_M1_MASK }, // 1175 + { 0x7, 0x1, 0x1, 0x5, 0x5, 0x7, PseudoVSOXSEG7EI32_V_MF2_MF8_MASK }, // 1176 + { 0x7, 0x1, 0x1, 0x5, 0x6, 0x0, PseudoVSOXSEG7EI32_V_M1_MF4_MASK }, // 1177 + { 0x7, 0x1, 0x1, 0x5, 0x6, 0x7, PseudoVSOXSEG7EI32_V_MF2_MF4_MASK }, // 1178 + { 0x7, 0x1, 0x1, 0x5, 0x7, 0x0, PseudoVSOXSEG7EI32_V_M1_MF2_MASK }, // 1179 + { 0x7, 0x1, 0x1, 0x5, 0x7, 0x1, PseudoVSOXSEG7EI32_V_M2_MF2_MASK }, // 1180 + { 0x7, 0x1, 0x1, 0x5, 0x7, 0x7, PseudoVSOXSEG7EI32_V_MF2_MF2_MASK }, // 1181 + { 0x7, 0x1, 0x1, 0x6, 0x0, 0x0, PseudoVSOXSEG7EI64_V_M1_M1_MASK }, // 1182 + { 0x7, 0x1, 0x1, 0x6, 0x0, 0x1, PseudoVSOXSEG7EI64_V_M2_M1_MASK }, // 1183 + { 0x7, 0x1, 0x1, 0x6, 0x0, 0x2, PseudoVSOXSEG7EI64_V_M4_M1_MASK }, // 1184 + { 0x7, 0x1, 0x1, 0x6, 0x0, 0x3, PseudoVSOXSEG7EI64_V_M8_M1_MASK }, // 1185 + { 0x7, 0x1, 0x1, 0x6, 0x5, 0x0, PseudoVSOXSEG7EI64_V_M1_MF8_MASK }, // 1186 + { 0x7, 0x1, 0x1, 0x6, 0x6, 0x0, PseudoVSOXSEG7EI64_V_M1_MF4_MASK }, // 1187 + { 0x7, 0x1, 0x1, 0x6, 0x6, 0x1, PseudoVSOXSEG7EI64_V_M2_MF4_MASK }, // 1188 + { 0x7, 0x1, 0x1, 0x6, 0x7, 0x0, PseudoVSOXSEG7EI64_V_M1_MF2_MASK }, // 1189 + { 0x7, 0x1, 0x1, 0x6, 0x7, 0x1, PseudoVSOXSEG7EI64_V_M2_MF2_MASK }, // 1190 + { 0x7, 0x1, 0x1, 0x6, 0x7, 0x2, PseudoVSOXSEG7EI64_V_M4_MF2_MASK }, // 1191 + { 0x8, 0x0, 0x0, 0x3, 0x0, 0x0, PseudoVSUXSEG8EI8_V_M1_M1 }, // 1192 + { 0x8, 0x0, 0x0, 0x3, 0x0, 0x5, PseudoVSUXSEG8EI8_V_MF8_M1 }, // 1193 + { 0x8, 0x0, 0x0, 0x3, 0x0, 0x6, PseudoVSUXSEG8EI8_V_MF4_M1 }, // 1194 + { 0x8, 0x0, 0x0, 0x3, 0x0, 0x7, PseudoVSUXSEG8EI8_V_MF2_M1 }, // 1195 + { 0x8, 0x0, 0x0, 0x3, 0x5, 0x5, PseudoVSUXSEG8EI8_V_MF8_MF8 }, // 1196 + { 0x8, 0x0, 0x0, 0x3, 0x6, 0x5, PseudoVSUXSEG8EI8_V_MF8_MF4 }, // 1197 + { 0x8, 0x0, 0x0, 0x3, 0x6, 0x6, PseudoVSUXSEG8EI8_V_MF4_MF4 }, // 1198 + { 0x8, 0x0, 0x0, 0x3, 0x7, 0x5, PseudoVSUXSEG8EI8_V_MF8_MF2 }, // 1199 + { 0x8, 0x0, 0x0, 0x3, 0x7, 0x6, PseudoVSUXSEG8EI8_V_MF4_MF2 }, // 1200 + { 0x8, 0x0, 0x0, 0x3, 0x7, 0x7, PseudoVSUXSEG8EI8_V_MF2_MF2 }, // 1201 + { 0x8, 0x0, 0x0, 0x4, 0x0, 0x0, PseudoVSUXSEG8EI16_V_M1_M1 }, // 1202 + { 0x8, 0x0, 0x0, 0x4, 0x0, 0x1, PseudoVSUXSEG8EI16_V_M2_M1 }, // 1203 + { 0x8, 0x0, 0x0, 0x4, 0x0, 0x6, PseudoVSUXSEG8EI16_V_MF4_M1 }, // 1204 + { 0x8, 0x0, 0x0, 0x4, 0x0, 0x7, PseudoVSUXSEG8EI16_V_MF2_M1 }, // 1205 + { 0x8, 0x0, 0x0, 0x4, 0x5, 0x6, PseudoVSUXSEG8EI16_V_MF4_MF8 }, // 1206 + { 0x8, 0x0, 0x0, 0x4, 0x6, 0x6, PseudoVSUXSEG8EI16_V_MF4_MF4 }, // 1207 + { 0x8, 0x0, 0x0, 0x4, 0x6, 0x7, PseudoVSUXSEG8EI16_V_MF2_MF4 }, // 1208 + { 0x8, 0x0, 0x0, 0x4, 0x7, 0x0, PseudoVSUXSEG8EI16_V_M1_MF2 }, // 1209 + { 0x8, 0x0, 0x0, 0x4, 0x7, 0x6, PseudoVSUXSEG8EI16_V_MF4_MF2 }, // 1210 + { 0x8, 0x0, 0x0, 0x4, 0x7, 0x7, PseudoVSUXSEG8EI16_V_MF2_MF2 }, // 1211 + { 0x8, 0x0, 0x0, 0x5, 0x0, 0x0, PseudoVSUXSEG8EI32_V_M1_M1 }, // 1212 + { 0x8, 0x0, 0x0, 0x5, 0x0, 0x1, PseudoVSUXSEG8EI32_V_M2_M1 }, // 1213 + { 0x8, 0x0, 0x0, 0x5, 0x0, 0x2, PseudoVSUXSEG8EI32_V_M4_M1 }, // 1214 + { 0x8, 0x0, 0x0, 0x5, 0x0, 0x7, PseudoVSUXSEG8EI32_V_MF2_M1 }, // 1215 + { 0x8, 0x0, 0x0, 0x5, 0x5, 0x7, PseudoVSUXSEG8EI32_V_MF2_MF8 }, // 1216 + { 0x8, 0x0, 0x0, 0x5, 0x6, 0x0, PseudoVSUXSEG8EI32_V_M1_MF4 }, // 1217 + { 0x8, 0x0, 0x0, 0x5, 0x6, 0x7, PseudoVSUXSEG8EI32_V_MF2_MF4 }, // 1218 + { 0x8, 0x0, 0x0, 0x5, 0x7, 0x0, PseudoVSUXSEG8EI32_V_M1_MF2 }, // 1219 + { 0x8, 0x0, 0x0, 0x5, 0x7, 0x1, PseudoVSUXSEG8EI32_V_M2_MF2 }, // 1220 + { 0x8, 0x0, 0x0, 0x5, 0x7, 0x7, PseudoVSUXSEG8EI32_V_MF2_MF2 }, // 1221 + { 0x8, 0x0, 0x0, 0x6, 0x0, 0x0, PseudoVSUXSEG8EI64_V_M1_M1 }, // 1222 + { 0x8, 0x0, 0x0, 0x6, 0x0, 0x1, PseudoVSUXSEG8EI64_V_M2_M1 }, // 1223 + { 0x8, 0x0, 0x0, 0x6, 0x0, 0x2, PseudoVSUXSEG8EI64_V_M4_M1 }, // 1224 + { 0x8, 0x0, 0x0, 0x6, 0x0, 0x3, PseudoVSUXSEG8EI64_V_M8_M1 }, // 1225 + { 0x8, 0x0, 0x0, 0x6, 0x5, 0x0, PseudoVSUXSEG8EI64_V_M1_MF8 }, // 1226 + { 0x8, 0x0, 0x0, 0x6, 0x6, 0x0, PseudoVSUXSEG8EI64_V_M1_MF4 }, // 1227 + { 0x8, 0x0, 0x0, 0x6, 0x6, 0x1, PseudoVSUXSEG8EI64_V_M2_MF4 }, // 1228 + { 0x8, 0x0, 0x0, 0x6, 0x7, 0x0, PseudoVSUXSEG8EI64_V_M1_MF2 }, // 1229 + { 0x8, 0x0, 0x0, 0x6, 0x7, 0x1, PseudoVSUXSEG8EI64_V_M2_MF2 }, // 1230 + { 0x8, 0x0, 0x0, 0x6, 0x7, 0x2, PseudoVSUXSEG8EI64_V_M4_MF2 }, // 1231 + { 0x8, 0x0, 0x1, 0x3, 0x0, 0x0, PseudoVSOXSEG8EI8_V_M1_M1 }, // 1232 + { 0x8, 0x0, 0x1, 0x3, 0x0, 0x5, PseudoVSOXSEG8EI8_V_MF8_M1 }, // 1233 + { 0x8, 0x0, 0x1, 0x3, 0x0, 0x6, PseudoVSOXSEG8EI8_V_MF4_M1 }, // 1234 + { 0x8, 0x0, 0x1, 0x3, 0x0, 0x7, PseudoVSOXSEG8EI8_V_MF2_M1 }, // 1235 + { 0x8, 0x0, 0x1, 0x3, 0x5, 0x5, PseudoVSOXSEG8EI8_V_MF8_MF8 }, // 1236 + { 0x8, 0x0, 0x1, 0x3, 0x6, 0x5, PseudoVSOXSEG8EI8_V_MF8_MF4 }, // 1237 + { 0x8, 0x0, 0x1, 0x3, 0x6, 0x6, PseudoVSOXSEG8EI8_V_MF4_MF4 }, // 1238 + { 0x8, 0x0, 0x1, 0x3, 0x7, 0x5, PseudoVSOXSEG8EI8_V_MF8_MF2 }, // 1239 + { 0x8, 0x0, 0x1, 0x3, 0x7, 0x6, PseudoVSOXSEG8EI8_V_MF4_MF2 }, // 1240 + { 0x8, 0x0, 0x1, 0x3, 0x7, 0x7, PseudoVSOXSEG8EI8_V_MF2_MF2 }, // 1241 + { 0x8, 0x0, 0x1, 0x4, 0x0, 0x0, PseudoVSOXSEG8EI16_V_M1_M1 }, // 1242 + { 0x8, 0x0, 0x1, 0x4, 0x0, 0x1, PseudoVSOXSEG8EI16_V_M2_M1 }, // 1243 + { 0x8, 0x0, 0x1, 0x4, 0x0, 0x6, PseudoVSOXSEG8EI16_V_MF4_M1 }, // 1244 + { 0x8, 0x0, 0x1, 0x4, 0x0, 0x7, PseudoVSOXSEG8EI16_V_MF2_M1 }, // 1245 + { 0x8, 0x0, 0x1, 0x4, 0x5, 0x6, PseudoVSOXSEG8EI16_V_MF4_MF8 }, // 1246 + { 0x8, 0x0, 0x1, 0x4, 0x6, 0x6, PseudoVSOXSEG8EI16_V_MF4_MF4 }, // 1247 + { 0x8, 0x0, 0x1, 0x4, 0x6, 0x7, PseudoVSOXSEG8EI16_V_MF2_MF4 }, // 1248 + { 0x8, 0x0, 0x1, 0x4, 0x7, 0x0, PseudoVSOXSEG8EI16_V_M1_MF2 }, // 1249 + { 0x8, 0x0, 0x1, 0x4, 0x7, 0x6, PseudoVSOXSEG8EI16_V_MF4_MF2 }, // 1250 + { 0x8, 0x0, 0x1, 0x4, 0x7, 0x7, PseudoVSOXSEG8EI16_V_MF2_MF2 }, // 1251 + { 0x8, 0x0, 0x1, 0x5, 0x0, 0x0, PseudoVSOXSEG8EI32_V_M1_M1 }, // 1252 + { 0x8, 0x0, 0x1, 0x5, 0x0, 0x1, PseudoVSOXSEG8EI32_V_M2_M1 }, // 1253 + { 0x8, 0x0, 0x1, 0x5, 0x0, 0x2, PseudoVSOXSEG8EI32_V_M4_M1 }, // 1254 + { 0x8, 0x0, 0x1, 0x5, 0x0, 0x7, PseudoVSOXSEG8EI32_V_MF2_M1 }, // 1255 + { 0x8, 0x0, 0x1, 0x5, 0x5, 0x7, PseudoVSOXSEG8EI32_V_MF2_MF8 }, // 1256 + { 0x8, 0x0, 0x1, 0x5, 0x6, 0x0, PseudoVSOXSEG8EI32_V_M1_MF4 }, // 1257 + { 0x8, 0x0, 0x1, 0x5, 0x6, 0x7, PseudoVSOXSEG8EI32_V_MF2_MF4 }, // 1258 + { 0x8, 0x0, 0x1, 0x5, 0x7, 0x0, PseudoVSOXSEG8EI32_V_M1_MF2 }, // 1259 + { 0x8, 0x0, 0x1, 0x5, 0x7, 0x1, PseudoVSOXSEG8EI32_V_M2_MF2 }, // 1260 + { 0x8, 0x0, 0x1, 0x5, 0x7, 0x7, PseudoVSOXSEG8EI32_V_MF2_MF2 }, // 1261 + { 0x8, 0x0, 0x1, 0x6, 0x0, 0x0, PseudoVSOXSEG8EI64_V_M1_M1 }, // 1262 + { 0x8, 0x0, 0x1, 0x6, 0x0, 0x1, PseudoVSOXSEG8EI64_V_M2_M1 }, // 1263 + { 0x8, 0x0, 0x1, 0x6, 0x0, 0x2, PseudoVSOXSEG8EI64_V_M4_M1 }, // 1264 + { 0x8, 0x0, 0x1, 0x6, 0x0, 0x3, PseudoVSOXSEG8EI64_V_M8_M1 }, // 1265 + { 0x8, 0x0, 0x1, 0x6, 0x5, 0x0, PseudoVSOXSEG8EI64_V_M1_MF8 }, // 1266 + { 0x8, 0x0, 0x1, 0x6, 0x6, 0x0, PseudoVSOXSEG8EI64_V_M1_MF4 }, // 1267 + { 0x8, 0x0, 0x1, 0x6, 0x6, 0x1, PseudoVSOXSEG8EI64_V_M2_MF4 }, // 1268 + { 0x8, 0x0, 0x1, 0x6, 0x7, 0x0, PseudoVSOXSEG8EI64_V_M1_MF2 }, // 1269 + { 0x8, 0x0, 0x1, 0x6, 0x7, 0x1, PseudoVSOXSEG8EI64_V_M2_MF2 }, // 1270 + { 0x8, 0x0, 0x1, 0x6, 0x7, 0x2, PseudoVSOXSEG8EI64_V_M4_MF2 }, // 1271 + { 0x8, 0x1, 0x0, 0x3, 0x0, 0x0, PseudoVSUXSEG8EI8_V_M1_M1_MASK }, // 1272 + { 0x8, 0x1, 0x0, 0x3, 0x0, 0x5, PseudoVSUXSEG8EI8_V_MF8_M1_MASK }, // 1273 + { 0x8, 0x1, 0x0, 0x3, 0x0, 0x6, PseudoVSUXSEG8EI8_V_MF4_M1_MASK }, // 1274 + { 0x8, 0x1, 0x0, 0x3, 0x0, 0x7, PseudoVSUXSEG8EI8_V_MF2_M1_MASK }, // 1275 + { 0x8, 0x1, 0x0, 0x3, 0x5, 0x5, PseudoVSUXSEG8EI8_V_MF8_MF8_MASK }, // 1276 + { 0x8, 0x1, 0x0, 0x3, 0x6, 0x5, PseudoVSUXSEG8EI8_V_MF8_MF4_MASK }, // 1277 + { 0x8, 0x1, 0x0, 0x3, 0x6, 0x6, PseudoVSUXSEG8EI8_V_MF4_MF4_MASK }, // 1278 + { 0x8, 0x1, 0x0, 0x3, 0x7, 0x5, PseudoVSUXSEG8EI8_V_MF8_MF2_MASK }, // 1279 + { 0x8, 0x1, 0x0, 0x3, 0x7, 0x6, PseudoVSUXSEG8EI8_V_MF4_MF2_MASK }, // 1280 + { 0x8, 0x1, 0x0, 0x3, 0x7, 0x7, PseudoVSUXSEG8EI8_V_MF2_MF2_MASK }, // 1281 + { 0x8, 0x1, 0x0, 0x4, 0x0, 0x0, PseudoVSUXSEG8EI16_V_M1_M1_MASK }, // 1282 + { 0x8, 0x1, 0x0, 0x4, 0x0, 0x1, PseudoVSUXSEG8EI16_V_M2_M1_MASK }, // 1283 + { 0x8, 0x1, 0x0, 0x4, 0x0, 0x6, PseudoVSUXSEG8EI16_V_MF4_M1_MASK }, // 1284 + { 0x8, 0x1, 0x0, 0x4, 0x0, 0x7, PseudoVSUXSEG8EI16_V_MF2_M1_MASK }, // 1285 + { 0x8, 0x1, 0x0, 0x4, 0x5, 0x6, PseudoVSUXSEG8EI16_V_MF4_MF8_MASK }, // 1286 + { 0x8, 0x1, 0x0, 0x4, 0x6, 0x6, PseudoVSUXSEG8EI16_V_MF4_MF4_MASK }, // 1287 + { 0x8, 0x1, 0x0, 0x4, 0x6, 0x7, PseudoVSUXSEG8EI16_V_MF2_MF4_MASK }, // 1288 + { 0x8, 0x1, 0x0, 0x4, 0x7, 0x0, PseudoVSUXSEG8EI16_V_M1_MF2_MASK }, // 1289 + { 0x8, 0x1, 0x0, 0x4, 0x7, 0x6, PseudoVSUXSEG8EI16_V_MF4_MF2_MASK }, // 1290 + { 0x8, 0x1, 0x0, 0x4, 0x7, 0x7, PseudoVSUXSEG8EI16_V_MF2_MF2_MASK }, // 1291 + { 0x8, 0x1, 0x0, 0x5, 0x0, 0x0, PseudoVSUXSEG8EI32_V_M1_M1_MASK }, // 1292 + { 0x8, 0x1, 0x0, 0x5, 0x0, 0x1, PseudoVSUXSEG8EI32_V_M2_M1_MASK }, // 1293 + { 0x8, 0x1, 0x0, 0x5, 0x0, 0x2, PseudoVSUXSEG8EI32_V_M4_M1_MASK }, // 1294 + { 0x8, 0x1, 0x0, 0x5, 0x0, 0x7, PseudoVSUXSEG8EI32_V_MF2_M1_MASK }, // 1295 + { 0x8, 0x1, 0x0, 0x5, 0x5, 0x7, PseudoVSUXSEG8EI32_V_MF2_MF8_MASK }, // 1296 + { 0x8, 0x1, 0x0, 0x5, 0x6, 0x0, PseudoVSUXSEG8EI32_V_M1_MF4_MASK }, // 1297 + { 0x8, 0x1, 0x0, 0x5, 0x6, 0x7, PseudoVSUXSEG8EI32_V_MF2_MF4_MASK }, // 1298 + { 0x8, 0x1, 0x0, 0x5, 0x7, 0x0, PseudoVSUXSEG8EI32_V_M1_MF2_MASK }, // 1299 + { 0x8, 0x1, 0x0, 0x5, 0x7, 0x1, PseudoVSUXSEG8EI32_V_M2_MF2_MASK }, // 1300 + { 0x8, 0x1, 0x0, 0x5, 0x7, 0x7, PseudoVSUXSEG8EI32_V_MF2_MF2_MASK }, // 1301 + { 0x8, 0x1, 0x0, 0x6, 0x0, 0x0, PseudoVSUXSEG8EI64_V_M1_M1_MASK }, // 1302 + { 0x8, 0x1, 0x0, 0x6, 0x0, 0x1, PseudoVSUXSEG8EI64_V_M2_M1_MASK }, // 1303 + { 0x8, 0x1, 0x0, 0x6, 0x0, 0x2, PseudoVSUXSEG8EI64_V_M4_M1_MASK }, // 1304 + { 0x8, 0x1, 0x0, 0x6, 0x0, 0x3, PseudoVSUXSEG8EI64_V_M8_M1_MASK }, // 1305 + { 0x8, 0x1, 0x0, 0x6, 0x5, 0x0, PseudoVSUXSEG8EI64_V_M1_MF8_MASK }, // 1306 + { 0x8, 0x1, 0x0, 0x6, 0x6, 0x0, PseudoVSUXSEG8EI64_V_M1_MF4_MASK }, // 1307 + { 0x8, 0x1, 0x0, 0x6, 0x6, 0x1, PseudoVSUXSEG8EI64_V_M2_MF4_MASK }, // 1308 + { 0x8, 0x1, 0x0, 0x6, 0x7, 0x0, PseudoVSUXSEG8EI64_V_M1_MF2_MASK }, // 1309 + { 0x8, 0x1, 0x0, 0x6, 0x7, 0x1, PseudoVSUXSEG8EI64_V_M2_MF2_MASK }, // 1310 + { 0x8, 0x1, 0x0, 0x6, 0x7, 0x2, PseudoVSUXSEG8EI64_V_M4_MF2_MASK }, // 1311 + { 0x8, 0x1, 0x1, 0x3, 0x0, 0x0, PseudoVSOXSEG8EI8_V_M1_M1_MASK }, // 1312 + { 0x8, 0x1, 0x1, 0x3, 0x0, 0x5, PseudoVSOXSEG8EI8_V_MF8_M1_MASK }, // 1313 + { 0x8, 0x1, 0x1, 0x3, 0x0, 0x6, PseudoVSOXSEG8EI8_V_MF4_M1_MASK }, // 1314 + { 0x8, 0x1, 0x1, 0x3, 0x0, 0x7, PseudoVSOXSEG8EI8_V_MF2_M1_MASK }, // 1315 + { 0x8, 0x1, 0x1, 0x3, 0x5, 0x5, PseudoVSOXSEG8EI8_V_MF8_MF8_MASK }, // 1316 + { 0x8, 0x1, 0x1, 0x3, 0x6, 0x5, PseudoVSOXSEG8EI8_V_MF8_MF4_MASK }, // 1317 + { 0x8, 0x1, 0x1, 0x3, 0x6, 0x6, PseudoVSOXSEG8EI8_V_MF4_MF4_MASK }, // 1318 + { 0x8, 0x1, 0x1, 0x3, 0x7, 0x5, PseudoVSOXSEG8EI8_V_MF8_MF2_MASK }, // 1319 + { 0x8, 0x1, 0x1, 0x3, 0x7, 0x6, PseudoVSOXSEG8EI8_V_MF4_MF2_MASK }, // 1320 + { 0x8, 0x1, 0x1, 0x3, 0x7, 0x7, PseudoVSOXSEG8EI8_V_MF2_MF2_MASK }, // 1321 + { 0x8, 0x1, 0x1, 0x4, 0x0, 0x0, PseudoVSOXSEG8EI16_V_M1_M1_MASK }, // 1322 + { 0x8, 0x1, 0x1, 0x4, 0x0, 0x1, PseudoVSOXSEG8EI16_V_M2_M1_MASK }, // 1323 + { 0x8, 0x1, 0x1, 0x4, 0x0, 0x6, PseudoVSOXSEG8EI16_V_MF4_M1_MASK }, // 1324 + { 0x8, 0x1, 0x1, 0x4, 0x0, 0x7, PseudoVSOXSEG8EI16_V_MF2_M1_MASK }, // 1325 + { 0x8, 0x1, 0x1, 0x4, 0x5, 0x6, PseudoVSOXSEG8EI16_V_MF4_MF8_MASK }, // 1326 + { 0x8, 0x1, 0x1, 0x4, 0x6, 0x6, PseudoVSOXSEG8EI16_V_MF4_MF4_MASK }, // 1327 + { 0x8, 0x1, 0x1, 0x4, 0x6, 0x7, PseudoVSOXSEG8EI16_V_MF2_MF4_MASK }, // 1328 + { 0x8, 0x1, 0x1, 0x4, 0x7, 0x0, PseudoVSOXSEG8EI16_V_M1_MF2_MASK }, // 1329 + { 0x8, 0x1, 0x1, 0x4, 0x7, 0x6, PseudoVSOXSEG8EI16_V_MF4_MF2_MASK }, // 1330 + { 0x8, 0x1, 0x1, 0x4, 0x7, 0x7, PseudoVSOXSEG8EI16_V_MF2_MF2_MASK }, // 1331 + { 0x8, 0x1, 0x1, 0x5, 0x0, 0x0, PseudoVSOXSEG8EI32_V_M1_M1_MASK }, // 1332 + { 0x8, 0x1, 0x1, 0x5, 0x0, 0x1, PseudoVSOXSEG8EI32_V_M2_M1_MASK }, // 1333 + { 0x8, 0x1, 0x1, 0x5, 0x0, 0x2, PseudoVSOXSEG8EI32_V_M4_M1_MASK }, // 1334 + { 0x8, 0x1, 0x1, 0x5, 0x0, 0x7, PseudoVSOXSEG8EI32_V_MF2_M1_MASK }, // 1335 + { 0x8, 0x1, 0x1, 0x5, 0x5, 0x7, PseudoVSOXSEG8EI32_V_MF2_MF8_MASK }, // 1336 + { 0x8, 0x1, 0x1, 0x5, 0x6, 0x0, PseudoVSOXSEG8EI32_V_M1_MF4_MASK }, // 1337 + { 0x8, 0x1, 0x1, 0x5, 0x6, 0x7, PseudoVSOXSEG8EI32_V_MF2_MF4_MASK }, // 1338 + { 0x8, 0x1, 0x1, 0x5, 0x7, 0x0, PseudoVSOXSEG8EI32_V_M1_MF2_MASK }, // 1339 + { 0x8, 0x1, 0x1, 0x5, 0x7, 0x1, PseudoVSOXSEG8EI32_V_M2_MF2_MASK }, // 1340 + { 0x8, 0x1, 0x1, 0x5, 0x7, 0x7, PseudoVSOXSEG8EI32_V_MF2_MF2_MASK }, // 1341 + { 0x8, 0x1, 0x1, 0x6, 0x0, 0x0, PseudoVSOXSEG8EI64_V_M1_M1_MASK }, // 1342 + { 0x8, 0x1, 0x1, 0x6, 0x0, 0x1, PseudoVSOXSEG8EI64_V_M2_M1_MASK }, // 1343 + { 0x8, 0x1, 0x1, 0x6, 0x0, 0x2, PseudoVSOXSEG8EI64_V_M4_M1_MASK }, // 1344 + { 0x8, 0x1, 0x1, 0x6, 0x0, 0x3, PseudoVSOXSEG8EI64_V_M8_M1_MASK }, // 1345 + { 0x8, 0x1, 0x1, 0x6, 0x5, 0x0, PseudoVSOXSEG8EI64_V_M1_MF8_MASK }, // 1346 + { 0x8, 0x1, 0x1, 0x6, 0x6, 0x0, PseudoVSOXSEG8EI64_V_M1_MF4_MASK }, // 1347 + { 0x8, 0x1, 0x1, 0x6, 0x6, 0x1, PseudoVSOXSEG8EI64_V_M2_MF4_MASK }, // 1348 + { 0x8, 0x1, 0x1, 0x6, 0x7, 0x0, PseudoVSOXSEG8EI64_V_M1_MF2_MASK }, // 1349 + { 0x8, 0x1, 0x1, 0x6, 0x7, 0x1, PseudoVSOXSEG8EI64_V_M2_MF2_MASK }, // 1350 + { 0x8, 0x1, 0x1, 0x6, 0x7, 0x2, PseudoVSOXSEG8EI64_V_M4_MF2_MASK }, // 1351 + }; + +const RISCV_VSXSEGPseudo *RISCV_getVSXSEGPseudo(uint8_t NF, uint8_t Masked, uint8_t Ordered, uint8_t Log2SEW, uint8_t LMUL, uint8_t IndexLMUL) { + unsigned i = binsearch_IndexTypeEncoding(Index, ARR_SIZE(Index), NFMaskedOrderedLog2SEWLMULIndexLMUL); + if (i == -1) + return NULL; + else + return &RISCVVSXSEGTable[Index[i].index]; +} + +#endif + +#ifdef GET_RISCVVSXTable_IMPL +static const RISCV_VLX_VSXPseudo RISCVVSXTable[] = { + { 0x0, 0x0, 0x3, 0x0, 0x0, PseudoVSUXEI8_V_M1_M1 }, // 0 + { 0x0, 0x0, 0x3, 0x0, 0x5, PseudoVSUXEI8_V_MF8_M1 }, // 1 + { 0x0, 0x0, 0x3, 0x0, 0x6, PseudoVSUXEI8_V_MF4_M1 }, // 2 + { 0x0, 0x0, 0x3, 0x0, 0x7, PseudoVSUXEI8_V_MF2_M1 }, // 3 + { 0x0, 0x0, 0x3, 0x1, 0x0, PseudoVSUXEI8_V_M1_M2 }, // 4 + { 0x0, 0x0, 0x3, 0x1, 0x1, PseudoVSUXEI8_V_M2_M2 }, // 5 + { 0x0, 0x0, 0x3, 0x1, 0x6, PseudoVSUXEI8_V_MF4_M2 }, // 6 + { 0x0, 0x0, 0x3, 0x1, 0x7, PseudoVSUXEI8_V_MF2_M2 }, // 7 + { 0x0, 0x0, 0x3, 0x2, 0x0, PseudoVSUXEI8_V_M1_M4 }, // 8 + { 0x0, 0x0, 0x3, 0x2, 0x1, PseudoVSUXEI8_V_M2_M4 }, // 9 + { 0x0, 0x0, 0x3, 0x2, 0x2, PseudoVSUXEI8_V_M4_M4 }, // 10 + { 0x0, 0x0, 0x3, 0x2, 0x7, PseudoVSUXEI8_V_MF2_M4 }, // 11 + { 0x0, 0x0, 0x3, 0x3, 0x0, PseudoVSUXEI8_V_M1_M8 }, // 12 + { 0x0, 0x0, 0x3, 0x3, 0x1, PseudoVSUXEI8_V_M2_M8 }, // 13 + { 0x0, 0x0, 0x3, 0x3, 0x2, PseudoVSUXEI8_V_M4_M8 }, // 14 + { 0x0, 0x0, 0x3, 0x3, 0x3, PseudoVSUXEI8_V_M8_M8 }, // 15 + { 0x0, 0x0, 0x3, 0x5, 0x5, PseudoVSUXEI8_V_MF8_MF8 }, // 16 + { 0x0, 0x0, 0x3, 0x6, 0x5, PseudoVSUXEI8_V_MF8_MF4 }, // 17 + { 0x0, 0x0, 0x3, 0x6, 0x6, PseudoVSUXEI8_V_MF4_MF4 }, // 18 + { 0x0, 0x0, 0x3, 0x7, 0x5, PseudoVSUXEI8_V_MF8_MF2 }, // 19 + { 0x0, 0x0, 0x3, 0x7, 0x6, PseudoVSUXEI8_V_MF4_MF2 }, // 20 + { 0x0, 0x0, 0x3, 0x7, 0x7, PseudoVSUXEI8_V_MF2_MF2 }, // 21 + { 0x0, 0x0, 0x4, 0x0, 0x0, PseudoVSUXEI16_V_M1_M1 }, // 22 + { 0x0, 0x0, 0x4, 0x0, 0x1, PseudoVSUXEI16_V_M2_M1 }, // 23 + { 0x0, 0x0, 0x4, 0x0, 0x6, PseudoVSUXEI16_V_MF4_M1 }, // 24 + { 0x0, 0x0, 0x4, 0x0, 0x7, PseudoVSUXEI16_V_MF2_M1 }, // 25 + { 0x0, 0x0, 0x4, 0x1, 0x0, PseudoVSUXEI16_V_M1_M2 }, // 26 + { 0x0, 0x0, 0x4, 0x1, 0x1, PseudoVSUXEI16_V_M2_M2 }, // 27 + { 0x0, 0x0, 0x4, 0x1, 0x2, PseudoVSUXEI16_V_M4_M2 }, // 28 + { 0x0, 0x0, 0x4, 0x1, 0x7, PseudoVSUXEI16_V_MF2_M2 }, // 29 + { 0x0, 0x0, 0x4, 0x2, 0x0, PseudoVSUXEI16_V_M1_M4 }, // 30 + { 0x0, 0x0, 0x4, 0x2, 0x1, PseudoVSUXEI16_V_M2_M4 }, // 31 + { 0x0, 0x0, 0x4, 0x2, 0x2, PseudoVSUXEI16_V_M4_M4 }, // 32 + { 0x0, 0x0, 0x4, 0x2, 0x3, PseudoVSUXEI16_V_M8_M4 }, // 33 + { 0x0, 0x0, 0x4, 0x3, 0x1, PseudoVSUXEI16_V_M2_M8 }, // 34 + { 0x0, 0x0, 0x4, 0x3, 0x2, PseudoVSUXEI16_V_M4_M8 }, // 35 + { 0x0, 0x0, 0x4, 0x3, 0x3, PseudoVSUXEI16_V_M8_M8 }, // 36 + { 0x0, 0x0, 0x4, 0x5, 0x6, PseudoVSUXEI16_V_MF4_MF8 }, // 37 + { 0x0, 0x0, 0x4, 0x6, 0x6, PseudoVSUXEI16_V_MF4_MF4 }, // 38 + { 0x0, 0x0, 0x4, 0x6, 0x7, PseudoVSUXEI16_V_MF2_MF4 }, // 39 + { 0x0, 0x0, 0x4, 0x7, 0x0, PseudoVSUXEI16_V_M1_MF2 }, // 40 + { 0x0, 0x0, 0x4, 0x7, 0x6, PseudoVSUXEI16_V_MF4_MF2 }, // 41 + { 0x0, 0x0, 0x4, 0x7, 0x7, PseudoVSUXEI16_V_MF2_MF2 }, // 42 + { 0x0, 0x0, 0x5, 0x0, 0x0, PseudoVSUXEI32_V_M1_M1 }, // 43 + { 0x0, 0x0, 0x5, 0x0, 0x1, PseudoVSUXEI32_V_M2_M1 }, // 44 + { 0x0, 0x0, 0x5, 0x0, 0x2, PseudoVSUXEI32_V_M4_M1 }, // 45 + { 0x0, 0x0, 0x5, 0x0, 0x7, PseudoVSUXEI32_V_MF2_M1 }, // 46 + { 0x0, 0x0, 0x5, 0x1, 0x0, PseudoVSUXEI32_V_M1_M2 }, // 47 + { 0x0, 0x0, 0x5, 0x1, 0x1, PseudoVSUXEI32_V_M2_M2 }, // 48 + { 0x0, 0x0, 0x5, 0x1, 0x2, PseudoVSUXEI32_V_M4_M2 }, // 49 + { 0x0, 0x0, 0x5, 0x1, 0x3, PseudoVSUXEI32_V_M8_M2 }, // 50 + { 0x0, 0x0, 0x5, 0x2, 0x1, PseudoVSUXEI32_V_M2_M4 }, // 51 + { 0x0, 0x0, 0x5, 0x2, 0x2, PseudoVSUXEI32_V_M4_M4 }, // 52 + { 0x0, 0x0, 0x5, 0x2, 0x3, PseudoVSUXEI32_V_M8_M4 }, // 53 + { 0x0, 0x0, 0x5, 0x3, 0x2, PseudoVSUXEI32_V_M4_M8 }, // 54 + { 0x0, 0x0, 0x5, 0x3, 0x3, PseudoVSUXEI32_V_M8_M8 }, // 55 + { 0x0, 0x0, 0x5, 0x5, 0x7, PseudoVSUXEI32_V_MF2_MF8 }, // 56 + { 0x0, 0x0, 0x5, 0x6, 0x0, PseudoVSUXEI32_V_M1_MF4 }, // 57 + { 0x0, 0x0, 0x5, 0x6, 0x7, PseudoVSUXEI32_V_MF2_MF4 }, // 58 + { 0x0, 0x0, 0x5, 0x7, 0x0, PseudoVSUXEI32_V_M1_MF2 }, // 59 + { 0x0, 0x0, 0x5, 0x7, 0x1, PseudoVSUXEI32_V_M2_MF2 }, // 60 + { 0x0, 0x0, 0x5, 0x7, 0x7, PseudoVSUXEI32_V_MF2_MF2 }, // 61 + { 0x0, 0x0, 0x6, 0x0, 0x0, PseudoVSUXEI64_V_M1_M1 }, // 62 + { 0x0, 0x0, 0x6, 0x0, 0x1, PseudoVSUXEI64_V_M2_M1 }, // 63 + { 0x0, 0x0, 0x6, 0x0, 0x2, PseudoVSUXEI64_V_M4_M1 }, // 64 + { 0x0, 0x0, 0x6, 0x0, 0x3, PseudoVSUXEI64_V_M8_M1 }, // 65 + { 0x0, 0x0, 0x6, 0x1, 0x1, PseudoVSUXEI64_V_M2_M2 }, // 66 + { 0x0, 0x0, 0x6, 0x1, 0x2, PseudoVSUXEI64_V_M4_M2 }, // 67 + { 0x0, 0x0, 0x6, 0x1, 0x3, PseudoVSUXEI64_V_M8_M2 }, // 68 + { 0x0, 0x0, 0x6, 0x2, 0x2, PseudoVSUXEI64_V_M4_M4 }, // 69 + { 0x0, 0x0, 0x6, 0x2, 0x3, PseudoVSUXEI64_V_M8_M4 }, // 70 + { 0x0, 0x0, 0x6, 0x3, 0x3, PseudoVSUXEI64_V_M8_M8 }, // 71 + { 0x0, 0x0, 0x6, 0x5, 0x0, PseudoVSUXEI64_V_M1_MF8 }, // 72 + { 0x0, 0x0, 0x6, 0x6, 0x0, PseudoVSUXEI64_V_M1_MF4 }, // 73 + { 0x0, 0x0, 0x6, 0x6, 0x1, PseudoVSUXEI64_V_M2_MF4 }, // 74 + { 0x0, 0x0, 0x6, 0x7, 0x0, PseudoVSUXEI64_V_M1_MF2 }, // 75 + { 0x0, 0x0, 0x6, 0x7, 0x1, PseudoVSUXEI64_V_M2_MF2 }, // 76 + { 0x0, 0x0, 0x6, 0x7, 0x2, PseudoVSUXEI64_V_M4_MF2 }, // 77 + { 0x0, 0x1, 0x3, 0x0, 0x0, PseudoVSOXEI8_V_M1_M1 }, // 78 + { 0x0, 0x1, 0x3, 0x0, 0x5, PseudoVSOXEI8_V_MF8_M1 }, // 79 + { 0x0, 0x1, 0x3, 0x0, 0x6, PseudoVSOXEI8_V_MF4_M1 }, // 80 + { 0x0, 0x1, 0x3, 0x0, 0x7, PseudoVSOXEI8_V_MF2_M1 }, // 81 + { 0x0, 0x1, 0x3, 0x1, 0x0, PseudoVSOXEI8_V_M1_M2 }, // 82 + { 0x0, 0x1, 0x3, 0x1, 0x1, PseudoVSOXEI8_V_M2_M2 }, // 83 + { 0x0, 0x1, 0x3, 0x1, 0x6, PseudoVSOXEI8_V_MF4_M2 }, // 84 + { 0x0, 0x1, 0x3, 0x1, 0x7, PseudoVSOXEI8_V_MF2_M2 }, // 85 + { 0x0, 0x1, 0x3, 0x2, 0x0, PseudoVSOXEI8_V_M1_M4 }, // 86 + { 0x0, 0x1, 0x3, 0x2, 0x1, PseudoVSOXEI8_V_M2_M4 }, // 87 + { 0x0, 0x1, 0x3, 0x2, 0x2, PseudoVSOXEI8_V_M4_M4 }, // 88 + { 0x0, 0x1, 0x3, 0x2, 0x7, PseudoVSOXEI8_V_MF2_M4 }, // 89 + { 0x0, 0x1, 0x3, 0x3, 0x0, PseudoVSOXEI8_V_M1_M8 }, // 90 + { 0x0, 0x1, 0x3, 0x3, 0x1, PseudoVSOXEI8_V_M2_M8 }, // 91 + { 0x0, 0x1, 0x3, 0x3, 0x2, PseudoVSOXEI8_V_M4_M8 }, // 92 + { 0x0, 0x1, 0x3, 0x3, 0x3, PseudoVSOXEI8_V_M8_M8 }, // 93 + { 0x0, 0x1, 0x3, 0x5, 0x5, PseudoVSOXEI8_V_MF8_MF8 }, // 94 + { 0x0, 0x1, 0x3, 0x6, 0x5, PseudoVSOXEI8_V_MF8_MF4 }, // 95 + { 0x0, 0x1, 0x3, 0x6, 0x6, PseudoVSOXEI8_V_MF4_MF4 }, // 96 + { 0x0, 0x1, 0x3, 0x7, 0x5, PseudoVSOXEI8_V_MF8_MF2 }, // 97 + { 0x0, 0x1, 0x3, 0x7, 0x6, PseudoVSOXEI8_V_MF4_MF2 }, // 98 + { 0x0, 0x1, 0x3, 0x7, 0x7, PseudoVSOXEI8_V_MF2_MF2 }, // 99 + { 0x0, 0x1, 0x4, 0x0, 0x0, PseudoVSOXEI16_V_M1_M1 }, // 100 + { 0x0, 0x1, 0x4, 0x0, 0x1, PseudoVSOXEI16_V_M2_M1 }, // 101 + { 0x0, 0x1, 0x4, 0x0, 0x6, PseudoVSOXEI16_V_MF4_M1 }, // 102 + { 0x0, 0x1, 0x4, 0x0, 0x7, PseudoVSOXEI16_V_MF2_M1 }, // 103 + { 0x0, 0x1, 0x4, 0x1, 0x0, PseudoVSOXEI16_V_M1_M2 }, // 104 + { 0x0, 0x1, 0x4, 0x1, 0x1, PseudoVSOXEI16_V_M2_M2 }, // 105 + { 0x0, 0x1, 0x4, 0x1, 0x2, PseudoVSOXEI16_V_M4_M2 }, // 106 + { 0x0, 0x1, 0x4, 0x1, 0x7, PseudoVSOXEI16_V_MF2_M2 }, // 107 + { 0x0, 0x1, 0x4, 0x2, 0x0, PseudoVSOXEI16_V_M1_M4 }, // 108 + { 0x0, 0x1, 0x4, 0x2, 0x1, PseudoVSOXEI16_V_M2_M4 }, // 109 + { 0x0, 0x1, 0x4, 0x2, 0x2, PseudoVSOXEI16_V_M4_M4 }, // 110 + { 0x0, 0x1, 0x4, 0x2, 0x3, PseudoVSOXEI16_V_M8_M4 }, // 111 + { 0x0, 0x1, 0x4, 0x3, 0x1, PseudoVSOXEI16_V_M2_M8 }, // 112 + { 0x0, 0x1, 0x4, 0x3, 0x2, PseudoVSOXEI16_V_M4_M8 }, // 113 + { 0x0, 0x1, 0x4, 0x3, 0x3, PseudoVSOXEI16_V_M8_M8 }, // 114 + { 0x0, 0x1, 0x4, 0x5, 0x6, PseudoVSOXEI16_V_MF4_MF8 }, // 115 + { 0x0, 0x1, 0x4, 0x6, 0x6, PseudoVSOXEI16_V_MF4_MF4 }, // 116 + { 0x0, 0x1, 0x4, 0x6, 0x7, PseudoVSOXEI16_V_MF2_MF4 }, // 117 + { 0x0, 0x1, 0x4, 0x7, 0x0, PseudoVSOXEI16_V_M1_MF2 }, // 118 + { 0x0, 0x1, 0x4, 0x7, 0x6, PseudoVSOXEI16_V_MF4_MF2 }, // 119 + { 0x0, 0x1, 0x4, 0x7, 0x7, PseudoVSOXEI16_V_MF2_MF2 }, // 120 + { 0x0, 0x1, 0x5, 0x0, 0x0, PseudoVSOXEI32_V_M1_M1 }, // 121 + { 0x0, 0x1, 0x5, 0x0, 0x1, PseudoVSOXEI32_V_M2_M1 }, // 122 + { 0x0, 0x1, 0x5, 0x0, 0x2, PseudoVSOXEI32_V_M4_M1 }, // 123 + { 0x0, 0x1, 0x5, 0x0, 0x7, PseudoVSOXEI32_V_MF2_M1 }, // 124 + { 0x0, 0x1, 0x5, 0x1, 0x0, PseudoVSOXEI32_V_M1_M2 }, // 125 + { 0x0, 0x1, 0x5, 0x1, 0x1, PseudoVSOXEI32_V_M2_M2 }, // 126 + { 0x0, 0x1, 0x5, 0x1, 0x2, PseudoVSOXEI32_V_M4_M2 }, // 127 + { 0x0, 0x1, 0x5, 0x1, 0x3, PseudoVSOXEI32_V_M8_M2 }, // 128 + { 0x0, 0x1, 0x5, 0x2, 0x1, PseudoVSOXEI32_V_M2_M4 }, // 129 + { 0x0, 0x1, 0x5, 0x2, 0x2, PseudoVSOXEI32_V_M4_M4 }, // 130 + { 0x0, 0x1, 0x5, 0x2, 0x3, PseudoVSOXEI32_V_M8_M4 }, // 131 + { 0x0, 0x1, 0x5, 0x3, 0x2, PseudoVSOXEI32_V_M4_M8 }, // 132 + { 0x0, 0x1, 0x5, 0x3, 0x3, PseudoVSOXEI32_V_M8_M8 }, // 133 + { 0x0, 0x1, 0x5, 0x5, 0x7, PseudoVSOXEI32_V_MF2_MF8 }, // 134 + { 0x0, 0x1, 0x5, 0x6, 0x0, PseudoVSOXEI32_V_M1_MF4 }, // 135 + { 0x0, 0x1, 0x5, 0x6, 0x7, PseudoVSOXEI32_V_MF2_MF4 }, // 136 + { 0x0, 0x1, 0x5, 0x7, 0x0, PseudoVSOXEI32_V_M1_MF2 }, // 137 + { 0x0, 0x1, 0x5, 0x7, 0x1, PseudoVSOXEI32_V_M2_MF2 }, // 138 + { 0x0, 0x1, 0x5, 0x7, 0x7, PseudoVSOXEI32_V_MF2_MF2 }, // 139 + { 0x0, 0x1, 0x6, 0x0, 0x0, PseudoVSOXEI64_V_M1_M1 }, // 140 + { 0x0, 0x1, 0x6, 0x0, 0x1, PseudoVSOXEI64_V_M2_M1 }, // 141 + { 0x0, 0x1, 0x6, 0x0, 0x2, PseudoVSOXEI64_V_M4_M1 }, // 142 + { 0x0, 0x1, 0x6, 0x0, 0x3, PseudoVSOXEI64_V_M8_M1 }, // 143 + { 0x0, 0x1, 0x6, 0x1, 0x1, PseudoVSOXEI64_V_M2_M2 }, // 144 + { 0x0, 0x1, 0x6, 0x1, 0x2, PseudoVSOXEI64_V_M4_M2 }, // 145 + { 0x0, 0x1, 0x6, 0x1, 0x3, PseudoVSOXEI64_V_M8_M2 }, // 146 + { 0x0, 0x1, 0x6, 0x2, 0x2, PseudoVSOXEI64_V_M4_M4 }, // 147 + { 0x0, 0x1, 0x6, 0x2, 0x3, PseudoVSOXEI64_V_M8_M4 }, // 148 + { 0x0, 0x1, 0x6, 0x3, 0x3, PseudoVSOXEI64_V_M8_M8 }, // 149 + { 0x0, 0x1, 0x6, 0x5, 0x0, PseudoVSOXEI64_V_M1_MF8 }, // 150 + { 0x0, 0x1, 0x6, 0x6, 0x0, PseudoVSOXEI64_V_M1_MF4 }, // 151 + { 0x0, 0x1, 0x6, 0x6, 0x1, PseudoVSOXEI64_V_M2_MF4 }, // 152 + { 0x0, 0x1, 0x6, 0x7, 0x0, PseudoVSOXEI64_V_M1_MF2 }, // 153 + { 0x0, 0x1, 0x6, 0x7, 0x1, PseudoVSOXEI64_V_M2_MF2 }, // 154 + { 0x0, 0x1, 0x6, 0x7, 0x2, PseudoVSOXEI64_V_M4_MF2 }, // 155 + { 0x1, 0x0, 0x3, 0x0, 0x0, PseudoVSUXEI8_V_M1_M1_MASK }, // 156 + { 0x1, 0x0, 0x3, 0x0, 0x5, PseudoVSUXEI8_V_MF8_M1_MASK }, // 157 + { 0x1, 0x0, 0x3, 0x0, 0x6, PseudoVSUXEI8_V_MF4_M1_MASK }, // 158 + { 0x1, 0x0, 0x3, 0x0, 0x7, PseudoVSUXEI8_V_MF2_M1_MASK }, // 159 + { 0x1, 0x0, 0x3, 0x1, 0x0, PseudoVSUXEI8_V_M1_M2_MASK }, // 160 + { 0x1, 0x0, 0x3, 0x1, 0x1, PseudoVSUXEI8_V_M2_M2_MASK }, // 161 + { 0x1, 0x0, 0x3, 0x1, 0x6, PseudoVSUXEI8_V_MF4_M2_MASK }, // 162 + { 0x1, 0x0, 0x3, 0x1, 0x7, PseudoVSUXEI8_V_MF2_M2_MASK }, // 163 + { 0x1, 0x0, 0x3, 0x2, 0x0, PseudoVSUXEI8_V_M1_M4_MASK }, // 164 + { 0x1, 0x0, 0x3, 0x2, 0x1, PseudoVSUXEI8_V_M2_M4_MASK }, // 165 + { 0x1, 0x0, 0x3, 0x2, 0x2, PseudoVSUXEI8_V_M4_M4_MASK }, // 166 + { 0x1, 0x0, 0x3, 0x2, 0x7, PseudoVSUXEI8_V_MF2_M4_MASK }, // 167 + { 0x1, 0x0, 0x3, 0x3, 0x0, PseudoVSUXEI8_V_M1_M8_MASK }, // 168 + { 0x1, 0x0, 0x3, 0x3, 0x1, PseudoVSUXEI8_V_M2_M8_MASK }, // 169 + { 0x1, 0x0, 0x3, 0x3, 0x2, PseudoVSUXEI8_V_M4_M8_MASK }, // 170 + { 0x1, 0x0, 0x3, 0x3, 0x3, PseudoVSUXEI8_V_M8_M8_MASK }, // 171 + { 0x1, 0x0, 0x3, 0x5, 0x5, PseudoVSUXEI8_V_MF8_MF8_MASK }, // 172 + { 0x1, 0x0, 0x3, 0x6, 0x5, PseudoVSUXEI8_V_MF8_MF4_MASK }, // 173 + { 0x1, 0x0, 0x3, 0x6, 0x6, PseudoVSUXEI8_V_MF4_MF4_MASK }, // 174 + { 0x1, 0x0, 0x3, 0x7, 0x5, PseudoVSUXEI8_V_MF8_MF2_MASK }, // 175 + { 0x1, 0x0, 0x3, 0x7, 0x6, PseudoVSUXEI8_V_MF4_MF2_MASK }, // 176 + { 0x1, 0x0, 0x3, 0x7, 0x7, PseudoVSUXEI8_V_MF2_MF2_MASK }, // 177 + { 0x1, 0x0, 0x4, 0x0, 0x0, PseudoVSUXEI16_V_M1_M1_MASK }, // 178 + { 0x1, 0x0, 0x4, 0x0, 0x1, PseudoVSUXEI16_V_M2_M1_MASK }, // 179 + { 0x1, 0x0, 0x4, 0x0, 0x6, PseudoVSUXEI16_V_MF4_M1_MASK }, // 180 + { 0x1, 0x0, 0x4, 0x0, 0x7, PseudoVSUXEI16_V_MF2_M1_MASK }, // 181 + { 0x1, 0x0, 0x4, 0x1, 0x0, PseudoVSUXEI16_V_M1_M2_MASK }, // 182 + { 0x1, 0x0, 0x4, 0x1, 0x1, PseudoVSUXEI16_V_M2_M2_MASK }, // 183 + { 0x1, 0x0, 0x4, 0x1, 0x2, PseudoVSUXEI16_V_M4_M2_MASK }, // 184 + { 0x1, 0x0, 0x4, 0x1, 0x7, PseudoVSUXEI16_V_MF2_M2_MASK }, // 185 + { 0x1, 0x0, 0x4, 0x2, 0x0, PseudoVSUXEI16_V_M1_M4_MASK }, // 186 + { 0x1, 0x0, 0x4, 0x2, 0x1, PseudoVSUXEI16_V_M2_M4_MASK }, // 187 + { 0x1, 0x0, 0x4, 0x2, 0x2, PseudoVSUXEI16_V_M4_M4_MASK }, // 188 + { 0x1, 0x0, 0x4, 0x2, 0x3, PseudoVSUXEI16_V_M8_M4_MASK }, // 189 + { 0x1, 0x0, 0x4, 0x3, 0x1, PseudoVSUXEI16_V_M2_M8_MASK }, // 190 + { 0x1, 0x0, 0x4, 0x3, 0x2, PseudoVSUXEI16_V_M4_M8_MASK }, // 191 + { 0x1, 0x0, 0x4, 0x3, 0x3, PseudoVSUXEI16_V_M8_M8_MASK }, // 192 + { 0x1, 0x0, 0x4, 0x5, 0x6, PseudoVSUXEI16_V_MF4_MF8_MASK }, // 193 + { 0x1, 0x0, 0x4, 0x6, 0x6, PseudoVSUXEI16_V_MF4_MF4_MASK }, // 194 + { 0x1, 0x0, 0x4, 0x6, 0x7, PseudoVSUXEI16_V_MF2_MF4_MASK }, // 195 + { 0x1, 0x0, 0x4, 0x7, 0x0, PseudoVSUXEI16_V_M1_MF2_MASK }, // 196 + { 0x1, 0x0, 0x4, 0x7, 0x6, PseudoVSUXEI16_V_MF4_MF2_MASK }, // 197 + { 0x1, 0x0, 0x4, 0x7, 0x7, PseudoVSUXEI16_V_MF2_MF2_MASK }, // 198 + { 0x1, 0x0, 0x5, 0x0, 0x0, PseudoVSUXEI32_V_M1_M1_MASK }, // 199 + { 0x1, 0x0, 0x5, 0x0, 0x1, PseudoVSUXEI32_V_M2_M1_MASK }, // 200 + { 0x1, 0x0, 0x5, 0x0, 0x2, PseudoVSUXEI32_V_M4_M1_MASK }, // 201 + { 0x1, 0x0, 0x5, 0x0, 0x7, PseudoVSUXEI32_V_MF2_M1_MASK }, // 202 + { 0x1, 0x0, 0x5, 0x1, 0x0, PseudoVSUXEI32_V_M1_M2_MASK }, // 203 + { 0x1, 0x0, 0x5, 0x1, 0x1, PseudoVSUXEI32_V_M2_M2_MASK }, // 204 + { 0x1, 0x0, 0x5, 0x1, 0x2, PseudoVSUXEI32_V_M4_M2_MASK }, // 205 + { 0x1, 0x0, 0x5, 0x1, 0x3, PseudoVSUXEI32_V_M8_M2_MASK }, // 206 + { 0x1, 0x0, 0x5, 0x2, 0x1, PseudoVSUXEI32_V_M2_M4_MASK }, // 207 + { 0x1, 0x0, 0x5, 0x2, 0x2, PseudoVSUXEI32_V_M4_M4_MASK }, // 208 + { 0x1, 0x0, 0x5, 0x2, 0x3, PseudoVSUXEI32_V_M8_M4_MASK }, // 209 + { 0x1, 0x0, 0x5, 0x3, 0x2, PseudoVSUXEI32_V_M4_M8_MASK }, // 210 + { 0x1, 0x0, 0x5, 0x3, 0x3, PseudoVSUXEI32_V_M8_M8_MASK }, // 211 + { 0x1, 0x0, 0x5, 0x5, 0x7, PseudoVSUXEI32_V_MF2_MF8_MASK }, // 212 + { 0x1, 0x0, 0x5, 0x6, 0x0, PseudoVSUXEI32_V_M1_MF4_MASK }, // 213 + { 0x1, 0x0, 0x5, 0x6, 0x7, PseudoVSUXEI32_V_MF2_MF4_MASK }, // 214 + { 0x1, 0x0, 0x5, 0x7, 0x0, PseudoVSUXEI32_V_M1_MF2_MASK }, // 215 + { 0x1, 0x0, 0x5, 0x7, 0x1, PseudoVSUXEI32_V_M2_MF2_MASK }, // 216 + { 0x1, 0x0, 0x5, 0x7, 0x7, PseudoVSUXEI32_V_MF2_MF2_MASK }, // 217 + { 0x1, 0x0, 0x6, 0x0, 0x0, PseudoVSUXEI64_V_M1_M1_MASK }, // 218 + { 0x1, 0x0, 0x6, 0x0, 0x1, PseudoVSUXEI64_V_M2_M1_MASK }, // 219 + { 0x1, 0x0, 0x6, 0x0, 0x2, PseudoVSUXEI64_V_M4_M1_MASK }, // 220 + { 0x1, 0x0, 0x6, 0x0, 0x3, PseudoVSUXEI64_V_M8_M1_MASK }, // 221 + { 0x1, 0x0, 0x6, 0x1, 0x1, PseudoVSUXEI64_V_M2_M2_MASK }, // 222 + { 0x1, 0x0, 0x6, 0x1, 0x2, PseudoVSUXEI64_V_M4_M2_MASK }, // 223 + { 0x1, 0x0, 0x6, 0x1, 0x3, PseudoVSUXEI64_V_M8_M2_MASK }, // 224 + { 0x1, 0x0, 0x6, 0x2, 0x2, PseudoVSUXEI64_V_M4_M4_MASK }, // 225 + { 0x1, 0x0, 0x6, 0x2, 0x3, PseudoVSUXEI64_V_M8_M4_MASK }, // 226 + { 0x1, 0x0, 0x6, 0x3, 0x3, PseudoVSUXEI64_V_M8_M8_MASK }, // 227 + { 0x1, 0x0, 0x6, 0x5, 0x0, PseudoVSUXEI64_V_M1_MF8_MASK }, // 228 + { 0x1, 0x0, 0x6, 0x6, 0x0, PseudoVSUXEI64_V_M1_MF4_MASK }, // 229 + { 0x1, 0x0, 0x6, 0x6, 0x1, PseudoVSUXEI64_V_M2_MF4_MASK }, // 230 + { 0x1, 0x0, 0x6, 0x7, 0x0, PseudoVSUXEI64_V_M1_MF2_MASK }, // 231 + { 0x1, 0x0, 0x6, 0x7, 0x1, PseudoVSUXEI64_V_M2_MF2_MASK }, // 232 + { 0x1, 0x0, 0x6, 0x7, 0x2, PseudoVSUXEI64_V_M4_MF2_MASK }, // 233 + { 0x1, 0x1, 0x3, 0x0, 0x0, PseudoVSOXEI8_V_M1_M1_MASK }, // 234 + { 0x1, 0x1, 0x3, 0x0, 0x5, PseudoVSOXEI8_V_MF8_M1_MASK }, // 235 + { 0x1, 0x1, 0x3, 0x0, 0x6, PseudoVSOXEI8_V_MF4_M1_MASK }, // 236 + { 0x1, 0x1, 0x3, 0x0, 0x7, PseudoVSOXEI8_V_MF2_M1_MASK }, // 237 + { 0x1, 0x1, 0x3, 0x1, 0x0, PseudoVSOXEI8_V_M1_M2_MASK }, // 238 + { 0x1, 0x1, 0x3, 0x1, 0x1, PseudoVSOXEI8_V_M2_M2_MASK }, // 239 + { 0x1, 0x1, 0x3, 0x1, 0x6, PseudoVSOXEI8_V_MF4_M2_MASK }, // 240 + { 0x1, 0x1, 0x3, 0x1, 0x7, PseudoVSOXEI8_V_MF2_M2_MASK }, // 241 + { 0x1, 0x1, 0x3, 0x2, 0x0, PseudoVSOXEI8_V_M1_M4_MASK }, // 242 + { 0x1, 0x1, 0x3, 0x2, 0x1, PseudoVSOXEI8_V_M2_M4_MASK }, // 243 + { 0x1, 0x1, 0x3, 0x2, 0x2, PseudoVSOXEI8_V_M4_M4_MASK }, // 244 + { 0x1, 0x1, 0x3, 0x2, 0x7, PseudoVSOXEI8_V_MF2_M4_MASK }, // 245 + { 0x1, 0x1, 0x3, 0x3, 0x0, PseudoVSOXEI8_V_M1_M8_MASK }, // 246 + { 0x1, 0x1, 0x3, 0x3, 0x1, PseudoVSOXEI8_V_M2_M8_MASK }, // 247 + { 0x1, 0x1, 0x3, 0x3, 0x2, PseudoVSOXEI8_V_M4_M8_MASK }, // 248 + { 0x1, 0x1, 0x3, 0x3, 0x3, PseudoVSOXEI8_V_M8_M8_MASK }, // 249 + { 0x1, 0x1, 0x3, 0x5, 0x5, PseudoVSOXEI8_V_MF8_MF8_MASK }, // 250 + { 0x1, 0x1, 0x3, 0x6, 0x5, PseudoVSOXEI8_V_MF8_MF4_MASK }, // 251 + { 0x1, 0x1, 0x3, 0x6, 0x6, PseudoVSOXEI8_V_MF4_MF4_MASK }, // 252 + { 0x1, 0x1, 0x3, 0x7, 0x5, PseudoVSOXEI8_V_MF8_MF2_MASK }, // 253 + { 0x1, 0x1, 0x3, 0x7, 0x6, PseudoVSOXEI8_V_MF4_MF2_MASK }, // 254 + { 0x1, 0x1, 0x3, 0x7, 0x7, PseudoVSOXEI8_V_MF2_MF2_MASK }, // 255 + { 0x1, 0x1, 0x4, 0x0, 0x0, PseudoVSOXEI16_V_M1_M1_MASK }, // 256 + { 0x1, 0x1, 0x4, 0x0, 0x1, PseudoVSOXEI16_V_M2_M1_MASK }, // 257 + { 0x1, 0x1, 0x4, 0x0, 0x6, PseudoVSOXEI16_V_MF4_M1_MASK }, // 258 + { 0x1, 0x1, 0x4, 0x0, 0x7, PseudoVSOXEI16_V_MF2_M1_MASK }, // 259 + { 0x1, 0x1, 0x4, 0x1, 0x0, PseudoVSOXEI16_V_M1_M2_MASK }, // 260 + { 0x1, 0x1, 0x4, 0x1, 0x1, PseudoVSOXEI16_V_M2_M2_MASK }, // 261 + { 0x1, 0x1, 0x4, 0x1, 0x2, PseudoVSOXEI16_V_M4_M2_MASK }, // 262 + { 0x1, 0x1, 0x4, 0x1, 0x7, PseudoVSOXEI16_V_MF2_M2_MASK }, // 263 + { 0x1, 0x1, 0x4, 0x2, 0x0, PseudoVSOXEI16_V_M1_M4_MASK }, // 264 + { 0x1, 0x1, 0x4, 0x2, 0x1, PseudoVSOXEI16_V_M2_M4_MASK }, // 265 + { 0x1, 0x1, 0x4, 0x2, 0x2, PseudoVSOXEI16_V_M4_M4_MASK }, // 266 + { 0x1, 0x1, 0x4, 0x2, 0x3, PseudoVSOXEI16_V_M8_M4_MASK }, // 267 + { 0x1, 0x1, 0x4, 0x3, 0x1, PseudoVSOXEI16_V_M2_M8_MASK }, // 268 + { 0x1, 0x1, 0x4, 0x3, 0x2, PseudoVSOXEI16_V_M4_M8_MASK }, // 269 + { 0x1, 0x1, 0x4, 0x3, 0x3, PseudoVSOXEI16_V_M8_M8_MASK }, // 270 + { 0x1, 0x1, 0x4, 0x5, 0x6, PseudoVSOXEI16_V_MF4_MF8_MASK }, // 271 + { 0x1, 0x1, 0x4, 0x6, 0x6, PseudoVSOXEI16_V_MF4_MF4_MASK }, // 272 + { 0x1, 0x1, 0x4, 0x6, 0x7, PseudoVSOXEI16_V_MF2_MF4_MASK }, // 273 + { 0x1, 0x1, 0x4, 0x7, 0x0, PseudoVSOXEI16_V_M1_MF2_MASK }, // 274 + { 0x1, 0x1, 0x4, 0x7, 0x6, PseudoVSOXEI16_V_MF4_MF2_MASK }, // 275 + { 0x1, 0x1, 0x4, 0x7, 0x7, PseudoVSOXEI16_V_MF2_MF2_MASK }, // 276 + { 0x1, 0x1, 0x5, 0x0, 0x0, PseudoVSOXEI32_V_M1_M1_MASK }, // 277 + { 0x1, 0x1, 0x5, 0x0, 0x1, PseudoVSOXEI32_V_M2_M1_MASK }, // 278 + { 0x1, 0x1, 0x5, 0x0, 0x2, PseudoVSOXEI32_V_M4_M1_MASK }, // 279 + { 0x1, 0x1, 0x5, 0x0, 0x7, PseudoVSOXEI32_V_MF2_M1_MASK }, // 280 + { 0x1, 0x1, 0x5, 0x1, 0x0, PseudoVSOXEI32_V_M1_M2_MASK }, // 281 + { 0x1, 0x1, 0x5, 0x1, 0x1, PseudoVSOXEI32_V_M2_M2_MASK }, // 282 + { 0x1, 0x1, 0x5, 0x1, 0x2, PseudoVSOXEI32_V_M4_M2_MASK }, // 283 + { 0x1, 0x1, 0x5, 0x1, 0x3, PseudoVSOXEI32_V_M8_M2_MASK }, // 284 + { 0x1, 0x1, 0x5, 0x2, 0x1, PseudoVSOXEI32_V_M2_M4_MASK }, // 285 + { 0x1, 0x1, 0x5, 0x2, 0x2, PseudoVSOXEI32_V_M4_M4_MASK }, // 286 + { 0x1, 0x1, 0x5, 0x2, 0x3, PseudoVSOXEI32_V_M8_M4_MASK }, // 287 + { 0x1, 0x1, 0x5, 0x3, 0x2, PseudoVSOXEI32_V_M4_M8_MASK }, // 288 + { 0x1, 0x1, 0x5, 0x3, 0x3, PseudoVSOXEI32_V_M8_M8_MASK }, // 289 + { 0x1, 0x1, 0x5, 0x5, 0x7, PseudoVSOXEI32_V_MF2_MF8_MASK }, // 290 + { 0x1, 0x1, 0x5, 0x6, 0x0, PseudoVSOXEI32_V_M1_MF4_MASK }, // 291 + { 0x1, 0x1, 0x5, 0x6, 0x7, PseudoVSOXEI32_V_MF2_MF4_MASK }, // 292 + { 0x1, 0x1, 0x5, 0x7, 0x0, PseudoVSOXEI32_V_M1_MF2_MASK }, // 293 + { 0x1, 0x1, 0x5, 0x7, 0x1, PseudoVSOXEI32_V_M2_MF2_MASK }, // 294 + { 0x1, 0x1, 0x5, 0x7, 0x7, PseudoVSOXEI32_V_MF2_MF2_MASK }, // 295 + { 0x1, 0x1, 0x6, 0x0, 0x0, PseudoVSOXEI64_V_M1_M1_MASK }, // 296 + { 0x1, 0x1, 0x6, 0x0, 0x1, PseudoVSOXEI64_V_M2_M1_MASK }, // 297 + { 0x1, 0x1, 0x6, 0x0, 0x2, PseudoVSOXEI64_V_M4_M1_MASK }, // 298 + { 0x1, 0x1, 0x6, 0x0, 0x3, PseudoVSOXEI64_V_M8_M1_MASK }, // 299 + { 0x1, 0x1, 0x6, 0x1, 0x1, PseudoVSOXEI64_V_M2_M2_MASK }, // 300 + { 0x1, 0x1, 0x6, 0x1, 0x2, PseudoVSOXEI64_V_M4_M2_MASK }, // 301 + { 0x1, 0x1, 0x6, 0x1, 0x3, PseudoVSOXEI64_V_M8_M2_MASK }, // 302 + { 0x1, 0x1, 0x6, 0x2, 0x2, PseudoVSOXEI64_V_M4_M4_MASK }, // 303 + { 0x1, 0x1, 0x6, 0x2, 0x3, PseudoVSOXEI64_V_M8_M4_MASK }, // 304 + { 0x1, 0x1, 0x6, 0x3, 0x3, PseudoVSOXEI64_V_M8_M8_MASK }, // 305 + { 0x1, 0x1, 0x6, 0x5, 0x0, PseudoVSOXEI64_V_M1_MF8_MASK }, // 306 + { 0x1, 0x1, 0x6, 0x6, 0x0, PseudoVSOXEI64_V_M1_MF4_MASK }, // 307 + { 0x1, 0x1, 0x6, 0x6, 0x1, PseudoVSOXEI64_V_M2_MF4_MASK }, // 308 + { 0x1, 0x1, 0x6, 0x7, 0x0, PseudoVSOXEI64_V_M1_MF2_MASK }, // 309 + { 0x1, 0x1, 0x6, 0x7, 0x1, PseudoVSOXEI64_V_M2_MF2_MASK }, // 310 + { 0x1, 0x1, 0x6, 0x7, 0x2, PseudoVSOXEI64_V_M4_MF2_MASK }, // 311 + }; + +const RISCV_VLX_VSXPseudo *RISCV_getVSXPseudo(uint8_t Masked, uint8_t Ordered, uint8_t Log2SEW, uint8_t LMUL, uint8_t IndexLMUL) { + unsigned i = binsearch_IndexTypeEncoding(Index, ARR_SIZE(Index), MaskedOrderedLog2SEWLMULIndexLMUL); + if (i == -1) + return NULL; + else + return &RISCVVSXTable[Index[i].index]; +} + +#endif + +#ifdef GET_SysRegsList_IMPL +static const RISCV_SysReg SysRegsList[] = { + { "fflags", { .raw_val = RISCV_SYSREG_FFLAGS }, "fflags", { .raw_val = RISCV_SYSREG_FFLAGS }, "", 0x1, {0} , false }, // 0 + { "frm", { .raw_val = RISCV_SYSREG_FRM }, "frm", { .raw_val = RISCV_SYSREG_FRM }, "", 0x2, {0} , false }, // 1 + { "fcsr", { .raw_val = RISCV_SYSREG_FCSR }, "fcsr", { .raw_val = RISCV_SYSREG_FCSR }, "", 0x3, {0} , false }, // 2 + { "vstart", { .raw_val = RISCV_SYSREG_VSTART }, "vstart", { .raw_val = RISCV_SYSREG_VSTART }, "", 0x8, {0} , false }, // 3 + { "vxsat", { .raw_val = RISCV_SYSREG_VXSAT }, "vxsat", { .raw_val = RISCV_SYSREG_VXSAT }, "", 0x9, {0} , false }, // 4 + { "vxrm", { .raw_val = RISCV_SYSREG_VXRM }, "vxrm", { .raw_val = RISCV_SYSREG_VXRM }, "", 0xA, {0} , false }, // 5 + { "vcsr", { .raw_val = RISCV_SYSREG_VCSR }, "vcsr", { .raw_val = RISCV_SYSREG_VCSR }, "", 0xF, {0} , false }, // 6 + { "seed", { .raw_val = RISCV_SYSREG_SEED }, "seed", { .raw_val = RISCV_SYSREG_SEED }, "", 0x15, {0} , false }, // 7 + { "jvt", { .raw_val = RISCV_SYSREG_JVT }, "jvt", { .raw_val = RISCV_SYSREG_JVT }, "", 0x17, {0} , false }, // 8 + { "sstatus", { .raw_val = RISCV_SYSREG_SSTATUS }, "sstatus", { .raw_val = RISCV_SYSREG_SSTATUS }, "", 0x100, {0} , false }, // 9 + { "sie", { .raw_val = RISCV_SYSREG_SIE }, "sie", { .raw_val = RISCV_SYSREG_SIE }, "", 0x104, {0} , false }, // 10 + { "stvec", { .raw_val = RISCV_SYSREG_STVEC }, "stvec", { .raw_val = RISCV_SYSREG_STVEC }, "", 0x105, {0} , false }, // 11 + { "scounteren", { .raw_val = RISCV_SYSREG_SCOUNTEREN }, "scounteren", { .raw_val = RISCV_SYSREG_SCOUNTEREN }, "", 0x106, {0} , false }, // 12 + { "senvcfg", { .raw_val = RISCV_SYSREG_SENVCFG }, "senvcfg", { .raw_val = RISCV_SYSREG_SENVCFG }, "", 0x10A, {0} , false }, // 13 + { "sstateen0", { .raw_val = RISCV_SYSREG_SSTATEEN0 }, "sstateen0", { .raw_val = RISCV_SYSREG_SSTATEEN0 }, "", 0x10C, {0} , false }, // 14 + { "sstateen1", { .raw_val = RISCV_SYSREG_SSTATEEN1 }, "sstateen1", { .raw_val = RISCV_SYSREG_SSTATEEN1 }, "", 0x10D, {0} , false }, // 15 + { "sstateen2", { .raw_val = RISCV_SYSREG_SSTATEEN2 }, "sstateen2", { .raw_val = RISCV_SYSREG_SSTATEEN2 }, "", 0x10E, {0} , false }, // 16 + { "sstateen3", { .raw_val = RISCV_SYSREG_SSTATEEN3 }, "sstateen3", { .raw_val = RISCV_SYSREG_SSTATEEN3 }, "", 0x10F, {0} , false }, // 17 + { "sieh", { .raw_val = RISCV_SYSREG_SIEH }, "sieh", { .raw_val = RISCV_SYSREG_SIEH }, "", 0x114, {0} , true }, // 18 + { "sscratch", { .raw_val = RISCV_SYSREG_SSCRATCH }, "sscratch", { .raw_val = RISCV_SYSREG_SSCRATCH }, "", 0x140, {0} , false }, // 19 + { "sepc", { .raw_val = RISCV_SYSREG_SEPC }, "sepc", { .raw_val = RISCV_SYSREG_SEPC }, "", 0x141, {0} , false }, // 20 + { "scause", { .raw_val = RISCV_SYSREG_SCAUSE }, "scause", { .raw_val = RISCV_SYSREG_SCAUSE }, "", 0x142, {0} , false }, // 21 + { "stval", { .raw_val = RISCV_SYSREG_STVAL }, "stval", { .raw_val = RISCV_SYSREG_STVAL }, "sbadaddr", 0x143, {0} , false }, // 22 + { "sip", { .raw_val = RISCV_SYSREG_SIP }, "sip", { .raw_val = RISCV_SYSREG_SIP }, "", 0x144, {0} , false }, // 23 + { "stimecmp", { .raw_val = RISCV_SYSREG_STIMECMP }, "stimecmp", { .raw_val = RISCV_SYSREG_STIMECMP }, "", 0x14D, {0} , false }, // 24 + { "siselect", { .raw_val = RISCV_SYSREG_SISELECT }, "siselect", { .raw_val = RISCV_SYSREG_SISELECT }, "", 0x150, {0} , false }, // 25 + { "sireg", { .raw_val = RISCV_SYSREG_SIREG }, "sireg", { .raw_val = RISCV_SYSREG_SIREG }, "", 0x151, {0} , false }, // 26 + { "siph", { .raw_val = RISCV_SYSREG_SIPH }, "siph", { .raw_val = RISCV_SYSREG_SIPH }, "", 0x154, {0} , true }, // 27 + { "stopei", { .raw_val = RISCV_SYSREG_STOPEI }, "stopei", { .raw_val = RISCV_SYSREG_STOPEI }, "", 0x15C, {0} , false }, // 28 + { "stimecmph", { .raw_val = RISCV_SYSREG_STIMECMPH }, "stimecmph", { .raw_val = RISCV_SYSREG_STIMECMPH }, "", 0x15D, {0} , true }, // 29 + { "satp", { .raw_val = RISCV_SYSREG_SATP }, "satp", { .raw_val = RISCV_SYSREG_SATP }, "sptbr", 0x180, {0} , false }, // 30 + { "vsstatus", { .raw_val = RISCV_SYSREG_VSSTATUS }, "vsstatus", { .raw_val = RISCV_SYSREG_VSSTATUS }, "", 0x200, {0} , false }, // 31 + { "vsie", { .raw_val = RISCV_SYSREG_VSIE }, "vsie", { .raw_val = RISCV_SYSREG_VSIE }, "", 0x204, {0} , false }, // 32 + { "vstvec", { .raw_val = RISCV_SYSREG_VSTVEC }, "vstvec", { .raw_val = RISCV_SYSREG_VSTVEC }, "", 0x205, {0} , false }, // 33 + { "vsieh", { .raw_val = RISCV_SYSREG_VSIEH }, "vsieh", { .raw_val = RISCV_SYSREG_VSIEH }, "", 0x214, {0} , true }, // 34 + { "vsscratch", { .raw_val = RISCV_SYSREG_VSSCRATCH }, "vsscratch", { .raw_val = RISCV_SYSREG_VSSCRATCH }, "", 0x240, {0} , false }, // 35 + { "vsepc", { .raw_val = RISCV_SYSREG_VSEPC }, "vsepc", { .raw_val = RISCV_SYSREG_VSEPC }, "", 0x241, {0} , false }, // 36 + { "vscause", { .raw_val = RISCV_SYSREG_VSCAUSE }, "vscause", { .raw_val = RISCV_SYSREG_VSCAUSE }, "", 0x242, {0} , false }, // 37 + { "vstval", { .raw_val = RISCV_SYSREG_VSTVAL }, "vstval", { .raw_val = RISCV_SYSREG_VSTVAL }, "", 0x243, {0} , false }, // 38 + { "vsip", { .raw_val = RISCV_SYSREG_VSIP }, "vsip", { .raw_val = RISCV_SYSREG_VSIP }, "", 0x244, {0} , false }, // 39 + { "vstimecmp", { .raw_val = RISCV_SYSREG_VSTIMECMP }, "vstimecmp", { .raw_val = RISCV_SYSREG_VSTIMECMP }, "", 0x24D, {0} , false }, // 40 + { "vsiselect", { .raw_val = RISCV_SYSREG_VSISELECT }, "vsiselect", { .raw_val = RISCV_SYSREG_VSISELECT }, "", 0x250, {0} , false }, // 41 + { "vsireg", { .raw_val = RISCV_SYSREG_VSIREG }, "vsireg", { .raw_val = RISCV_SYSREG_VSIREG }, "", 0x251, {0} , false }, // 42 + { "vsiph", { .raw_val = RISCV_SYSREG_VSIPH }, "vsiph", { .raw_val = RISCV_SYSREG_VSIPH }, "", 0x254, {0} , true }, // 43 + { "vstopei", { .raw_val = RISCV_SYSREG_VSTOPEI }, "vstopei", { .raw_val = RISCV_SYSREG_VSTOPEI }, "", 0x25C, {0} , false }, // 44 + { "vstimecmph", { .raw_val = RISCV_SYSREG_VSTIMECMPH }, "vstimecmph", { .raw_val = RISCV_SYSREG_VSTIMECMPH }, "", 0x25D, {0} , true }, // 45 + { "vsatp", { .raw_val = RISCV_SYSREG_VSATP }, "vsatp", { .raw_val = RISCV_SYSREG_VSATP }, "", 0x280, {0} , false }, // 46 + { "mstatus", { .raw_val = RISCV_SYSREG_MSTATUS }, "mstatus", { .raw_val = RISCV_SYSREG_MSTATUS }, "", 0x300, {0} , false }, // 47 + { "misa", { .raw_val = RISCV_SYSREG_MISA }, "misa", { .raw_val = RISCV_SYSREG_MISA }, "", 0x301, {0} , false }, // 48 + { "medeleg", { .raw_val = RISCV_SYSREG_MEDELEG }, "medeleg", { .raw_val = RISCV_SYSREG_MEDELEG }, "", 0x302, {0} , false }, // 49 + { "mideleg", { .raw_val = RISCV_SYSREG_MIDELEG }, "mideleg", { .raw_val = RISCV_SYSREG_MIDELEG }, "", 0x303, {0} , false }, // 50 + { "mie", { .raw_val = RISCV_SYSREG_MIE }, "mie", { .raw_val = RISCV_SYSREG_MIE }, "", 0x304, {0} , false }, // 51 + { "mtvec", { .raw_val = RISCV_SYSREG_MTVEC }, "mtvec", { .raw_val = RISCV_SYSREG_MTVEC }, "", 0x305, {0} , false }, // 52 + { "mcounteren", { .raw_val = RISCV_SYSREG_MCOUNTEREN }, "mcounteren", { .raw_val = RISCV_SYSREG_MCOUNTEREN }, "", 0x306, {0} , false }, // 53 + { "mvien", { .raw_val = RISCV_SYSREG_MVIEN }, "mvien", { .raw_val = RISCV_SYSREG_MVIEN }, "", 0x308, {0} , false }, // 54 + { "mvip", { .raw_val = RISCV_SYSREG_MVIP }, "mvip", { .raw_val = RISCV_SYSREG_MVIP }, "", 0x309, {0} , false }, // 55 + { "menvcfg", { .raw_val = RISCV_SYSREG_MENVCFG }, "menvcfg", { .raw_val = RISCV_SYSREG_MENVCFG }, "", 0x30A, {0} , false }, // 56 + { "mstateen0", { .raw_val = RISCV_SYSREG_MSTATEEN0 }, "mstateen0", { .raw_val = RISCV_SYSREG_MSTATEEN0 }, "", 0x30C, {0} , false }, // 57 + { "mstateen1", { .raw_val = RISCV_SYSREG_MSTATEEN1 }, "mstateen1", { .raw_val = RISCV_SYSREG_MSTATEEN1 }, "", 0x30D, {0} , false }, // 58 + { "mstateen2", { .raw_val = RISCV_SYSREG_MSTATEEN2 }, "mstateen2", { .raw_val = RISCV_SYSREG_MSTATEEN2 }, "", 0x30E, {0} , false }, // 59 + { "mstateen3", { .raw_val = RISCV_SYSREG_MSTATEEN3 }, "mstateen3", { .raw_val = RISCV_SYSREG_MSTATEEN3 }, "", 0x30F, {0} , false }, // 60 + { "mstatush", { .raw_val = RISCV_SYSREG_MSTATUSH }, "mstatush", { .raw_val = RISCV_SYSREG_MSTATUSH }, "", 0x310, {0} , true }, // 61 + { "midelegh", { .raw_val = RISCV_SYSREG_MIDELEGH }, "midelegh", { .raw_val = RISCV_SYSREG_MIDELEGH }, "", 0x313, {0} , true }, // 62 + { "mieh", { .raw_val = RISCV_SYSREG_MIEH }, "mieh", { .raw_val = RISCV_SYSREG_MIEH }, "", 0x314, {0} , true }, // 63 + { "mvienh", { .raw_val = RISCV_SYSREG_MVIENH }, "mvienh", { .raw_val = RISCV_SYSREG_MVIENH }, "", 0x318, {0} , true }, // 64 + { "mviph", { .raw_val = RISCV_SYSREG_MVIPH }, "mviph", { .raw_val = RISCV_SYSREG_MVIPH }, "", 0x319, {0} , true }, // 65 + { "menvcfgh", { .raw_val = RISCV_SYSREG_MENVCFGH }, "menvcfgh", { .raw_val = RISCV_SYSREG_MENVCFGH }, "", 0x31A, {0} , true }, // 66 + { "mstateen0h", { .raw_val = RISCV_SYSREG_MSTATEEN0H }, "mstateen0h", { .raw_val = RISCV_SYSREG_MSTATEEN0H }, "", 0x31C, {0} , true }, // 67 + { "mstateen1h", { .raw_val = RISCV_SYSREG_MSTATEEN1H }, "mstateen1h", { .raw_val = RISCV_SYSREG_MSTATEEN1H }, "", 0x31D, {0} , true }, // 68 + { "mstateen2h", { .raw_val = RISCV_SYSREG_MSTATEEN2H }, "mstateen2h", { .raw_val = RISCV_SYSREG_MSTATEEN2H }, "", 0x31E, {0} , true }, // 69 + { "mstateen3h", { .raw_val = RISCV_SYSREG_MSTATEEN3H }, "mstateen3h", { .raw_val = RISCV_SYSREG_MSTATEEN3H }, "", 0x31F, {0} , true }, // 70 + { "mcountinhibit", { .raw_val = RISCV_SYSREG_MCOUNTINHIBIT }, "mucounteren", { .raw_val = RISCV_SYSREG_MUCOUNTEREN }, "", 0x320, {0} , false }, // 71 + { "mhpmevent3", { .raw_val = RISCV_SYSREG_MHPMEVENT3 }, "mhpmevent3", { .raw_val = RISCV_SYSREG_MHPMEVENT3 }, "", 0x323, {0} , false }, // 72 + { "mhpmevent4", { .raw_val = RISCV_SYSREG_MHPMEVENT4 }, "mhpmevent4", { .raw_val = RISCV_SYSREG_MHPMEVENT4 }, "", 0x324, {0} , false }, // 73 + { "mhpmevent5", { .raw_val = RISCV_SYSREG_MHPMEVENT5 }, "mhpmevent5", { .raw_val = RISCV_SYSREG_MHPMEVENT5 }, "", 0x325, {0} , false }, // 74 + { "mhpmevent6", { .raw_val = RISCV_SYSREG_MHPMEVENT6 }, "mhpmevent6", { .raw_val = RISCV_SYSREG_MHPMEVENT6 }, "", 0x326, {0} , false }, // 75 + { "mhpmevent7", { .raw_val = RISCV_SYSREG_MHPMEVENT7 }, "mhpmevent7", { .raw_val = RISCV_SYSREG_MHPMEVENT7 }, "", 0x327, {0} , false }, // 76 + { "mhpmevent8", { .raw_val = RISCV_SYSREG_MHPMEVENT8 }, "mhpmevent8", { .raw_val = RISCV_SYSREG_MHPMEVENT8 }, "", 0x328, {0} , false }, // 77 + { "mhpmevent9", { .raw_val = RISCV_SYSREG_MHPMEVENT9 }, "mhpmevent9", { .raw_val = RISCV_SYSREG_MHPMEVENT9 }, "", 0x329, {0} , false }, // 78 + { "mhpmevent10", { .raw_val = RISCV_SYSREG_MHPMEVENT10 }, "mhpmevent10", { .raw_val = RISCV_SYSREG_MHPMEVENT10 }, "", 0x32A, {0} , false }, // 79 + { "mhpmevent11", { .raw_val = RISCV_SYSREG_MHPMEVENT11 }, "mhpmevent11", { .raw_val = RISCV_SYSREG_MHPMEVENT11 }, "", 0x32B, {0} , false }, // 80 + { "mhpmevent12", { .raw_val = RISCV_SYSREG_MHPMEVENT12 }, "mhpmevent12", { .raw_val = RISCV_SYSREG_MHPMEVENT12 }, "", 0x32C, {0} , false }, // 81 + { "mhpmevent13", { .raw_val = RISCV_SYSREG_MHPMEVENT13 }, "mhpmevent13", { .raw_val = RISCV_SYSREG_MHPMEVENT13 }, "", 0x32D, {0} , false }, // 82 + { "mhpmevent14", { .raw_val = RISCV_SYSREG_MHPMEVENT14 }, "mhpmevent14", { .raw_val = RISCV_SYSREG_MHPMEVENT14 }, "", 0x32E, {0} , false }, // 83 + { "mhpmevent15", { .raw_val = RISCV_SYSREG_MHPMEVENT15 }, "mhpmevent15", { .raw_val = RISCV_SYSREG_MHPMEVENT15 }, "", 0x32F, {0} , false }, // 84 + { "mhpmevent16", { .raw_val = RISCV_SYSREG_MHPMEVENT16 }, "mhpmevent16", { .raw_val = RISCV_SYSREG_MHPMEVENT16 }, "", 0x330, {0} , false }, // 85 + { "mhpmevent17", { .raw_val = RISCV_SYSREG_MHPMEVENT17 }, "mhpmevent17", { .raw_val = RISCV_SYSREG_MHPMEVENT17 }, "", 0x331, {0} , false }, // 86 + { "mhpmevent18", { .raw_val = RISCV_SYSREG_MHPMEVENT18 }, "mhpmevent18", { .raw_val = RISCV_SYSREG_MHPMEVENT18 }, "", 0x332, {0} , false }, // 87 + { "mhpmevent19", { .raw_val = RISCV_SYSREG_MHPMEVENT19 }, "mhpmevent19", { .raw_val = RISCV_SYSREG_MHPMEVENT19 }, "", 0x333, {0} , false }, // 88 + { "mhpmevent20", { .raw_val = RISCV_SYSREG_MHPMEVENT20 }, "mhpmevent20", { .raw_val = RISCV_SYSREG_MHPMEVENT20 }, "", 0x334, {0} , false }, // 89 + { "mhpmevent21", { .raw_val = RISCV_SYSREG_MHPMEVENT21 }, "mhpmevent21", { .raw_val = RISCV_SYSREG_MHPMEVENT21 }, "", 0x335, {0} , false }, // 90 + { "mhpmevent22", { .raw_val = RISCV_SYSREG_MHPMEVENT22 }, "mhpmevent22", { .raw_val = RISCV_SYSREG_MHPMEVENT22 }, "", 0x336, {0} , false }, // 91 + { "mhpmevent23", { .raw_val = RISCV_SYSREG_MHPMEVENT23 }, "mhpmevent23", { .raw_val = RISCV_SYSREG_MHPMEVENT23 }, "", 0x337, {0} , false }, // 92 + { "mhpmevent24", { .raw_val = RISCV_SYSREG_MHPMEVENT24 }, "mhpmevent24", { .raw_val = RISCV_SYSREG_MHPMEVENT24 }, "", 0x338, {0} , false }, // 93 + { "mhpmevent25", { .raw_val = RISCV_SYSREG_MHPMEVENT25 }, "mhpmevent25", { .raw_val = RISCV_SYSREG_MHPMEVENT25 }, "", 0x339, {0} , false }, // 94 + { "mhpmevent26", { .raw_val = RISCV_SYSREG_MHPMEVENT26 }, "mhpmevent26", { .raw_val = RISCV_SYSREG_MHPMEVENT26 }, "", 0x33A, {0} , false }, // 95 + { "mhpmevent27", { .raw_val = RISCV_SYSREG_MHPMEVENT27 }, "mhpmevent27", { .raw_val = RISCV_SYSREG_MHPMEVENT27 }, "", 0x33B, {0} , false }, // 96 + { "mhpmevent28", { .raw_val = RISCV_SYSREG_MHPMEVENT28 }, "mhpmevent28", { .raw_val = RISCV_SYSREG_MHPMEVENT28 }, "", 0x33C, {0} , false }, // 97 + { "mhpmevent29", { .raw_val = RISCV_SYSREG_MHPMEVENT29 }, "mhpmevent29", { .raw_val = RISCV_SYSREG_MHPMEVENT29 }, "", 0x33D, {0} , false }, // 98 + { "mhpmevent30", { .raw_val = RISCV_SYSREG_MHPMEVENT30 }, "mhpmevent30", { .raw_val = RISCV_SYSREG_MHPMEVENT30 }, "", 0x33E, {0} , false }, // 99 + { "mhpmevent31", { .raw_val = RISCV_SYSREG_MHPMEVENT31 }, "mhpmevent31", { .raw_val = RISCV_SYSREG_MHPMEVENT31 }, "", 0x33F, {0} , false }, // 100 + { "mscratch", { .raw_val = RISCV_SYSREG_MSCRATCH }, "mscratch", { .raw_val = RISCV_SYSREG_MSCRATCH }, "", 0x340, {0} , false }, // 101 + { "mepc", { .raw_val = RISCV_SYSREG_MEPC }, "mepc", { .raw_val = RISCV_SYSREG_MEPC }, "", 0x341, {0} , false }, // 102 + { "mcause", { .raw_val = RISCV_SYSREG_MCAUSE }, "mcause", { .raw_val = RISCV_SYSREG_MCAUSE }, "", 0x342, {0} , false }, // 103 + { "mtval", { .raw_val = RISCV_SYSREG_MTVAL }, "mtval", { .raw_val = RISCV_SYSREG_MTVAL }, "mbadaddr", 0x343, {0} , false }, // 104 + { "mip", { .raw_val = RISCV_SYSREG_MIP }, "mip", { .raw_val = RISCV_SYSREG_MIP }, "", 0x344, {0} , false }, // 105 + { "mtinst", { .raw_val = RISCV_SYSREG_MTINST }, "mtinst", { .raw_val = RISCV_SYSREG_MTINST }, "", 0x34A, {0} , false }, // 106 + { "mtval2", { .raw_val = RISCV_SYSREG_MTVAL2 }, "mtval2", { .raw_val = RISCV_SYSREG_MTVAL2 }, "", 0x34B, {0} , false }, // 107 + { "miselect", { .raw_val = RISCV_SYSREG_MISELECT }, "miselect", { .raw_val = RISCV_SYSREG_MISELECT }, "", 0x350, {0} , false }, // 108 + { "mireg", { .raw_val = RISCV_SYSREG_MIREG }, "mireg", { .raw_val = RISCV_SYSREG_MIREG }, "", 0x351, {0} , false }, // 109 + { "miph", { .raw_val = RISCV_SYSREG_MIPH }, "miph", { .raw_val = RISCV_SYSREG_MIPH }, "", 0x354, {0} , true }, // 110 + { "mtopei", { .raw_val = RISCV_SYSREG_MTOPEI }, "mtopei", { .raw_val = RISCV_SYSREG_MTOPEI }, "", 0x35C, {0} , false }, // 111 + { "pmpcfg0", { .raw_val = RISCV_SYSREG_PMPCFG0 }, "pmpcfg0", { .raw_val = RISCV_SYSREG_PMPCFG0 }, "", 0x3A0, {0} , false }, // 112 + { "pmpcfg1", { .raw_val = RISCV_SYSREG_PMPCFG1 }, "pmpcfg1", { .raw_val = RISCV_SYSREG_PMPCFG1 }, "", 0x3A1, {0} , true }, // 113 + { "pmpcfg2", { .raw_val = RISCV_SYSREG_PMPCFG2 }, "pmpcfg2", { .raw_val = RISCV_SYSREG_PMPCFG2 }, "", 0x3A2, {0} , false }, // 114 + { "pmpcfg3", { .raw_val = RISCV_SYSREG_PMPCFG3 }, "pmpcfg3", { .raw_val = RISCV_SYSREG_PMPCFG3 }, "", 0x3A3, {0} , true }, // 115 + { "pmpcfg4", { .raw_val = RISCV_SYSREG_PMPCFG4 }, "pmpcfg4", { .raw_val = RISCV_SYSREG_PMPCFG4 }, "", 0x3A4, {0} , false }, // 116 + { "pmpcfg5", { .raw_val = RISCV_SYSREG_PMPCFG5 }, "pmpcfg5", { .raw_val = RISCV_SYSREG_PMPCFG5 }, "", 0x3A5, {0} , true }, // 117 + { "pmpcfg6", { .raw_val = RISCV_SYSREG_PMPCFG6 }, "pmpcfg6", { .raw_val = RISCV_SYSREG_PMPCFG6 }, "", 0x3A6, {0} , false }, // 118 + { "pmpcfg7", { .raw_val = RISCV_SYSREG_PMPCFG7 }, "pmpcfg7", { .raw_val = RISCV_SYSREG_PMPCFG7 }, "", 0x3A7, {0} , true }, // 119 + { "pmpcfg8", { .raw_val = RISCV_SYSREG_PMPCFG8 }, "pmpcfg8", { .raw_val = RISCV_SYSREG_PMPCFG8 }, "", 0x3A8, {0} , false }, // 120 + { "pmpcfg9", { .raw_val = RISCV_SYSREG_PMPCFG9 }, "pmpcfg9", { .raw_val = RISCV_SYSREG_PMPCFG9 }, "", 0x3A9, {0} , true }, // 121 + { "pmpcfg10", { .raw_val = RISCV_SYSREG_PMPCFG10 }, "pmpcfg10", { .raw_val = RISCV_SYSREG_PMPCFG10 }, "", 0x3AA, {0} , false }, // 122 + { "pmpcfg11", { .raw_val = RISCV_SYSREG_PMPCFG11 }, "pmpcfg11", { .raw_val = RISCV_SYSREG_PMPCFG11 }, "", 0x3AB, {0} , true }, // 123 + { "pmpcfg12", { .raw_val = RISCV_SYSREG_PMPCFG12 }, "pmpcfg12", { .raw_val = RISCV_SYSREG_PMPCFG12 }, "", 0x3AC, {0} , false }, // 124 + { "pmpcfg13", { .raw_val = RISCV_SYSREG_PMPCFG13 }, "pmpcfg13", { .raw_val = RISCV_SYSREG_PMPCFG13 }, "", 0x3AD, {0} , true }, // 125 + { "pmpcfg14", { .raw_val = RISCV_SYSREG_PMPCFG14 }, "pmpcfg14", { .raw_val = RISCV_SYSREG_PMPCFG14 }, "", 0x3AE, {0} , false }, // 126 + { "pmpcfg15", { .raw_val = RISCV_SYSREG_PMPCFG15 }, "pmpcfg15", { .raw_val = RISCV_SYSREG_PMPCFG15 }, "", 0x3AF, {0} , true }, // 127 + { "pmpaddr0", { .raw_val = RISCV_SYSREG_PMPADDR0 }, "pmpaddr0", { .raw_val = RISCV_SYSREG_PMPADDR0 }, "", 0x3B0, {0} , false }, // 128 + { "pmpaddr1", { .raw_val = RISCV_SYSREG_PMPADDR1 }, "pmpaddr1", { .raw_val = RISCV_SYSREG_PMPADDR1 }, "", 0x3B1, {0} , false }, // 129 + { "pmpaddr2", { .raw_val = RISCV_SYSREG_PMPADDR2 }, "pmpaddr2", { .raw_val = RISCV_SYSREG_PMPADDR2 }, "", 0x3B2, {0} , false }, // 130 + { "pmpaddr3", { .raw_val = RISCV_SYSREG_PMPADDR3 }, "pmpaddr3", { .raw_val = RISCV_SYSREG_PMPADDR3 }, "", 0x3B3, {0} , false }, // 131 + { "pmpaddr4", { .raw_val = RISCV_SYSREG_PMPADDR4 }, "pmpaddr4", { .raw_val = RISCV_SYSREG_PMPADDR4 }, "", 0x3B4, {0} , false }, // 132 + { "pmpaddr5", { .raw_val = RISCV_SYSREG_PMPADDR5 }, "pmpaddr5", { .raw_val = RISCV_SYSREG_PMPADDR5 }, "", 0x3B5, {0} , false }, // 133 + { "pmpaddr6", { .raw_val = RISCV_SYSREG_PMPADDR6 }, "pmpaddr6", { .raw_val = RISCV_SYSREG_PMPADDR6 }, "", 0x3B6, {0} , false }, // 134 + { "pmpaddr7", { .raw_val = RISCV_SYSREG_PMPADDR7 }, "pmpaddr7", { .raw_val = RISCV_SYSREG_PMPADDR7 }, "", 0x3B7, {0} , false }, // 135 + { "pmpaddr8", { .raw_val = RISCV_SYSREG_PMPADDR8 }, "pmpaddr8", { .raw_val = RISCV_SYSREG_PMPADDR8 }, "", 0x3B8, {0} , false }, // 136 + { "pmpaddr9", { .raw_val = RISCV_SYSREG_PMPADDR9 }, "pmpaddr9", { .raw_val = RISCV_SYSREG_PMPADDR9 }, "", 0x3B9, {0} , false }, // 137 + { "pmpaddr10", { .raw_val = RISCV_SYSREG_PMPADDR10 }, "pmpaddr10", { .raw_val = RISCV_SYSREG_PMPADDR10 }, "", 0x3BA, {0} , false }, // 138 + { "pmpaddr11", { .raw_val = RISCV_SYSREG_PMPADDR11 }, "pmpaddr11", { .raw_val = RISCV_SYSREG_PMPADDR11 }, "", 0x3BB, {0} , false }, // 139 + { "pmpaddr12", { .raw_val = RISCV_SYSREG_PMPADDR12 }, "pmpaddr12", { .raw_val = RISCV_SYSREG_PMPADDR12 }, "", 0x3BC, {0} , false }, // 140 + { "pmpaddr13", { .raw_val = RISCV_SYSREG_PMPADDR13 }, "pmpaddr13", { .raw_val = RISCV_SYSREG_PMPADDR13 }, "", 0x3BD, {0} , false }, // 141 + { "pmpaddr14", { .raw_val = RISCV_SYSREG_PMPADDR14 }, "pmpaddr14", { .raw_val = RISCV_SYSREG_PMPADDR14 }, "", 0x3BE, {0} , false }, // 142 + { "pmpaddr15", { .raw_val = RISCV_SYSREG_PMPADDR15 }, "pmpaddr15", { .raw_val = RISCV_SYSREG_PMPADDR15 }, "", 0x3BF, {0} , false }, // 143 + { "pmpaddr16", { .raw_val = RISCV_SYSREG_PMPADDR16 }, "pmpaddr16", { .raw_val = RISCV_SYSREG_PMPADDR16 }, "", 0x3C0, {0} , false }, // 144 + { "pmpaddr17", { .raw_val = RISCV_SYSREG_PMPADDR17 }, "pmpaddr17", { .raw_val = RISCV_SYSREG_PMPADDR17 }, "", 0x3C1, {0} , false }, // 145 + { "pmpaddr18", { .raw_val = RISCV_SYSREG_PMPADDR18 }, "pmpaddr18", { .raw_val = RISCV_SYSREG_PMPADDR18 }, "", 0x3C2, {0} , false }, // 146 + { "pmpaddr19", { .raw_val = RISCV_SYSREG_PMPADDR19 }, "pmpaddr19", { .raw_val = RISCV_SYSREG_PMPADDR19 }, "", 0x3C3, {0} , false }, // 147 + { "pmpaddr20", { .raw_val = RISCV_SYSREG_PMPADDR20 }, "pmpaddr20", { .raw_val = RISCV_SYSREG_PMPADDR20 }, "", 0x3C4, {0} , false }, // 148 + { "pmpaddr21", { .raw_val = RISCV_SYSREG_PMPADDR21 }, "pmpaddr21", { .raw_val = RISCV_SYSREG_PMPADDR21 }, "", 0x3C5, {0} , false }, // 149 + { "pmpaddr22", { .raw_val = RISCV_SYSREG_PMPADDR22 }, "pmpaddr22", { .raw_val = RISCV_SYSREG_PMPADDR22 }, "", 0x3C6, {0} , false }, // 150 + { "pmpaddr23", { .raw_val = RISCV_SYSREG_PMPADDR23 }, "pmpaddr23", { .raw_val = RISCV_SYSREG_PMPADDR23 }, "", 0x3C7, {0} , false }, // 151 + { "pmpaddr24", { .raw_val = RISCV_SYSREG_PMPADDR24 }, "pmpaddr24", { .raw_val = RISCV_SYSREG_PMPADDR24 }, "", 0x3C8, {0} , false }, // 152 + { "pmpaddr25", { .raw_val = RISCV_SYSREG_PMPADDR25 }, "pmpaddr25", { .raw_val = RISCV_SYSREG_PMPADDR25 }, "", 0x3C9, {0} , false }, // 153 + { "pmpaddr26", { .raw_val = RISCV_SYSREG_PMPADDR26 }, "pmpaddr26", { .raw_val = RISCV_SYSREG_PMPADDR26 }, "", 0x3CA, {0} , false }, // 154 + { "pmpaddr27", { .raw_val = RISCV_SYSREG_PMPADDR27 }, "pmpaddr27", { .raw_val = RISCV_SYSREG_PMPADDR27 }, "", 0x3CB, {0} , false }, // 155 + { "pmpaddr28", { .raw_val = RISCV_SYSREG_PMPADDR28 }, "pmpaddr28", { .raw_val = RISCV_SYSREG_PMPADDR28 }, "", 0x3CC, {0} , false }, // 156 + { "pmpaddr29", { .raw_val = RISCV_SYSREG_PMPADDR29 }, "pmpaddr29", { .raw_val = RISCV_SYSREG_PMPADDR29 }, "", 0x3CD, {0} , false }, // 157 + { "pmpaddr30", { .raw_val = RISCV_SYSREG_PMPADDR30 }, "pmpaddr30", { .raw_val = RISCV_SYSREG_PMPADDR30 }, "", 0x3CE, {0} , false }, // 158 + { "pmpaddr31", { .raw_val = RISCV_SYSREG_PMPADDR31 }, "pmpaddr31", { .raw_val = RISCV_SYSREG_PMPADDR31 }, "", 0x3CF, {0} , false }, // 159 + { "pmpaddr32", { .raw_val = RISCV_SYSREG_PMPADDR32 }, "pmpaddr32", { .raw_val = RISCV_SYSREG_PMPADDR32 }, "", 0x3D0, {0} , false }, // 160 + { "pmpaddr33", { .raw_val = RISCV_SYSREG_PMPADDR33 }, "pmpaddr33", { .raw_val = RISCV_SYSREG_PMPADDR33 }, "", 0x3D1, {0} , false }, // 161 + { "pmpaddr34", { .raw_val = RISCV_SYSREG_PMPADDR34 }, "pmpaddr34", { .raw_val = RISCV_SYSREG_PMPADDR34 }, "", 0x3D2, {0} , false }, // 162 + { "pmpaddr35", { .raw_val = RISCV_SYSREG_PMPADDR35 }, "pmpaddr35", { .raw_val = RISCV_SYSREG_PMPADDR35 }, "", 0x3D3, {0} , false }, // 163 + { "pmpaddr36", { .raw_val = RISCV_SYSREG_PMPADDR36 }, "pmpaddr36", { .raw_val = RISCV_SYSREG_PMPADDR36 }, "", 0x3D4, {0} , false }, // 164 + { "pmpaddr37", { .raw_val = RISCV_SYSREG_PMPADDR37 }, "pmpaddr37", { .raw_val = RISCV_SYSREG_PMPADDR37 }, "", 0x3D5, {0} , false }, // 165 + { "pmpaddr38", { .raw_val = RISCV_SYSREG_PMPADDR38 }, "pmpaddr38", { .raw_val = RISCV_SYSREG_PMPADDR38 }, "", 0x3D6, {0} , false }, // 166 + { "pmpaddr39", { .raw_val = RISCV_SYSREG_PMPADDR39 }, "pmpaddr39", { .raw_val = RISCV_SYSREG_PMPADDR39 }, "", 0x3D7, {0} , false }, // 167 + { "pmpaddr40", { .raw_val = RISCV_SYSREG_PMPADDR40 }, "pmpaddr40", { .raw_val = RISCV_SYSREG_PMPADDR40 }, "", 0x3D8, {0} , false }, // 168 + { "pmpaddr41", { .raw_val = RISCV_SYSREG_PMPADDR41 }, "pmpaddr41", { .raw_val = RISCV_SYSREG_PMPADDR41 }, "", 0x3D9, {0} , false }, // 169 + { "pmpaddr42", { .raw_val = RISCV_SYSREG_PMPADDR42 }, "pmpaddr42", { .raw_val = RISCV_SYSREG_PMPADDR42 }, "", 0x3DA, {0} , false }, // 170 + { "pmpaddr43", { .raw_val = RISCV_SYSREG_PMPADDR43 }, "pmpaddr43", { .raw_val = RISCV_SYSREG_PMPADDR43 }, "", 0x3DB, {0} , false }, // 171 + { "pmpaddr44", { .raw_val = RISCV_SYSREG_PMPADDR44 }, "pmpaddr44", { .raw_val = RISCV_SYSREG_PMPADDR44 }, "", 0x3DC, {0} , false }, // 172 + { "pmpaddr45", { .raw_val = RISCV_SYSREG_PMPADDR45 }, "pmpaddr45", { .raw_val = RISCV_SYSREG_PMPADDR45 }, "", 0x3DD, {0} , false }, // 173 + { "pmpaddr46", { .raw_val = RISCV_SYSREG_PMPADDR46 }, "pmpaddr46", { .raw_val = RISCV_SYSREG_PMPADDR46 }, "", 0x3DE, {0} , false }, // 174 + { "pmpaddr47", { .raw_val = RISCV_SYSREG_PMPADDR47 }, "pmpaddr47", { .raw_val = RISCV_SYSREG_PMPADDR47 }, "", 0x3DF, {0} , false }, // 175 + { "pmpaddr48", { .raw_val = RISCV_SYSREG_PMPADDR48 }, "pmpaddr48", { .raw_val = RISCV_SYSREG_PMPADDR48 }, "", 0x3E0, {0} , false }, // 176 + { "pmpaddr49", { .raw_val = RISCV_SYSREG_PMPADDR49 }, "pmpaddr49", { .raw_val = RISCV_SYSREG_PMPADDR49 }, "", 0x3E1, {0} , false }, // 177 + { "pmpaddr50", { .raw_val = RISCV_SYSREG_PMPADDR50 }, "pmpaddr50", { .raw_val = RISCV_SYSREG_PMPADDR50 }, "", 0x3E2, {0} , false }, // 178 + { "pmpaddr51", { .raw_val = RISCV_SYSREG_PMPADDR51 }, "pmpaddr51", { .raw_val = RISCV_SYSREG_PMPADDR51 }, "", 0x3E3, {0} , false }, // 179 + { "pmpaddr52", { .raw_val = RISCV_SYSREG_PMPADDR52 }, "pmpaddr52", { .raw_val = RISCV_SYSREG_PMPADDR52 }, "", 0x3E4, {0} , false }, // 180 + { "pmpaddr53", { .raw_val = RISCV_SYSREG_PMPADDR53 }, "pmpaddr53", { .raw_val = RISCV_SYSREG_PMPADDR53 }, "", 0x3E5, {0} , false }, // 181 + { "pmpaddr54", { .raw_val = RISCV_SYSREG_PMPADDR54 }, "pmpaddr54", { .raw_val = RISCV_SYSREG_PMPADDR54 }, "", 0x3E6, {0} , false }, // 182 + { "pmpaddr55", { .raw_val = RISCV_SYSREG_PMPADDR55 }, "pmpaddr55", { .raw_val = RISCV_SYSREG_PMPADDR55 }, "", 0x3E7, {0} , false }, // 183 + { "pmpaddr56", { .raw_val = RISCV_SYSREG_PMPADDR56 }, "pmpaddr56", { .raw_val = RISCV_SYSREG_PMPADDR56 }, "", 0x3E8, {0} , false }, // 184 + { "pmpaddr57", { .raw_val = RISCV_SYSREG_PMPADDR57 }, "pmpaddr57", { .raw_val = RISCV_SYSREG_PMPADDR57 }, "", 0x3E9, {0} , false }, // 185 + { "pmpaddr58", { .raw_val = RISCV_SYSREG_PMPADDR58 }, "pmpaddr58", { .raw_val = RISCV_SYSREG_PMPADDR58 }, "", 0x3EA, {0} , false }, // 186 + { "pmpaddr59", { .raw_val = RISCV_SYSREG_PMPADDR59 }, "pmpaddr59", { .raw_val = RISCV_SYSREG_PMPADDR59 }, "", 0x3EB, {0} , false }, // 187 + { "pmpaddr60", { .raw_val = RISCV_SYSREG_PMPADDR60 }, "pmpaddr60", { .raw_val = RISCV_SYSREG_PMPADDR60 }, "", 0x3EC, {0} , false }, // 188 + { "pmpaddr61", { .raw_val = RISCV_SYSREG_PMPADDR61 }, "pmpaddr61", { .raw_val = RISCV_SYSREG_PMPADDR61 }, "", 0x3ED, {0} , false }, // 189 + { "pmpaddr62", { .raw_val = RISCV_SYSREG_PMPADDR62 }, "pmpaddr62", { .raw_val = RISCV_SYSREG_PMPADDR62 }, "", 0x3EE, {0} , false }, // 190 + { "pmpaddr63", { .raw_val = RISCV_SYSREG_PMPADDR63 }, "pmpaddr63", { .raw_val = RISCV_SYSREG_PMPADDR63 }, "", 0x3EF, {0} , false }, // 191 + { "scontext", { .raw_val = RISCV_SYSREG_SCONTEXT }, "scontext", { .raw_val = RISCV_SYSREG_SCONTEXT }, "", 0x5A8, {0} , false }, // 192 + { "hstatus", { .raw_val = RISCV_SYSREG_HSTATUS }, "hstatus", { .raw_val = RISCV_SYSREG_HSTATUS }, "", 0x600, {0} , false }, // 193 + { "hedeleg", { .raw_val = RISCV_SYSREG_HEDELEG }, "hedeleg", { .raw_val = RISCV_SYSREG_HEDELEG }, "", 0x602, {0} , false }, // 194 + { "hideleg", { .raw_val = RISCV_SYSREG_HIDELEG }, "hideleg", { .raw_val = RISCV_SYSREG_HIDELEG }, "", 0x603, {0} , false }, // 195 + { "hie", { .raw_val = RISCV_SYSREG_HIE }, "hie", { .raw_val = RISCV_SYSREG_HIE }, "", 0x604, {0} , false }, // 196 + { "htimedelta", { .raw_val = RISCV_SYSREG_HTIMEDELTA }, "htimedelta", { .raw_val = RISCV_SYSREG_HTIMEDELTA }, "", 0x605, {0} , false }, // 197 + { "hcounteren", { .raw_val = RISCV_SYSREG_HCOUNTEREN }, "hcounteren", { .raw_val = RISCV_SYSREG_HCOUNTEREN }, "", 0x606, {0} , false }, // 198 + { "hgeie", { .raw_val = RISCV_SYSREG_HGEIE }, "hgeie", { .raw_val = RISCV_SYSREG_HGEIE }, "", 0x607, {0} , false }, // 199 + { "hvien", { .raw_val = RISCV_SYSREG_HVIEN }, "hvien", { .raw_val = RISCV_SYSREG_HVIEN }, "", 0x608, {0} , false }, // 200 + { "hvictl", { .raw_val = RISCV_SYSREG_HVICTL }, "hvictl", { .raw_val = RISCV_SYSREG_HVICTL }, "", 0x609, {0} , false }, // 201 + { "henvcfg", { .raw_val = RISCV_SYSREG_HENVCFG }, "henvcfg", { .raw_val = RISCV_SYSREG_HENVCFG }, "", 0x60A, {0} , false }, // 202 + { "hstateen0", { .raw_val = RISCV_SYSREG_HSTATEEN0 }, "hstateen0", { .raw_val = RISCV_SYSREG_HSTATEEN0 }, "", 0x60C, {0} , false }, // 203 + { "hstateen1", { .raw_val = RISCV_SYSREG_HSTATEEN1 }, "hstateen1", { .raw_val = RISCV_SYSREG_HSTATEEN1 }, "", 0x60D, {0} , false }, // 204 + { "hstateen2", { .raw_val = RISCV_SYSREG_HSTATEEN2 }, "hstateen2", { .raw_val = RISCV_SYSREG_HSTATEEN2 }, "", 0x60E, {0} , false }, // 205 + { "hstateen3", { .raw_val = RISCV_SYSREG_HSTATEEN3 }, "hstateen3", { .raw_val = RISCV_SYSREG_HSTATEEN3 }, "", 0x60F, {0} , false }, // 206 + { "hidelegh", { .raw_val = RISCV_SYSREG_HIDELEGH }, "hidelegh", { .raw_val = RISCV_SYSREG_HIDELEGH }, "", 0x613, {0} , true }, // 207 + { "htimedeltah", { .raw_val = RISCV_SYSREG_HTIMEDELTAH }, "htimedeltah", { .raw_val = RISCV_SYSREG_HTIMEDELTAH }, "", 0x615, {0} , true }, // 208 + { "hvienh", { .raw_val = RISCV_SYSREG_HVIENH }, "hvienh", { .raw_val = RISCV_SYSREG_HVIENH }, "", 0x618, {0} , true }, // 209 + { "henvcfgh", { .raw_val = RISCV_SYSREG_HENVCFGH }, "henvcfgh", { .raw_val = RISCV_SYSREG_HENVCFGH }, "", 0x61A, {0} , true }, // 210 + { "hstateen0h", { .raw_val = RISCV_SYSREG_HSTATEEN0H }, "hstateen0h", { .raw_val = RISCV_SYSREG_HSTATEEN0H }, "", 0x61C, {0} , true }, // 211 + { "hstateen1h", { .raw_val = RISCV_SYSREG_HSTATEEN1H }, "hstateen1h", { .raw_val = RISCV_SYSREG_HSTATEEN1H }, "", 0x61D, {0} , true }, // 212 + { "hstateen2h", { .raw_val = RISCV_SYSREG_HSTATEEN2H }, "hstateen2h", { .raw_val = RISCV_SYSREG_HSTATEEN2H }, "", 0x61E, {0} , true }, // 213 + { "hstateen3h", { .raw_val = RISCV_SYSREG_HSTATEEN3H }, "hstateen3h", { .raw_val = RISCV_SYSREG_HSTATEEN3H }, "", 0x61F, {0} , true }, // 214 + { "htval", { .raw_val = RISCV_SYSREG_HTVAL }, "htval", { .raw_val = RISCV_SYSREG_HTVAL }, "", 0x643, {0} , false }, // 215 + { "hip", { .raw_val = RISCV_SYSREG_HIP }, "hip", { .raw_val = RISCV_SYSREG_HIP }, "", 0x644, {0} , false }, // 216 + { "hvip", { .raw_val = RISCV_SYSREG_HVIP }, "hvip", { .raw_val = RISCV_SYSREG_HVIP }, "", 0x645, {0} , false }, // 217 + { "hviprio1", { .raw_val = RISCV_SYSREG_HVIPRIO1 }, "hviprio1", { .raw_val = RISCV_SYSREG_HVIPRIO1 }, "", 0x646, {0} , false }, // 218 + { "hviprio2", { .raw_val = RISCV_SYSREG_HVIPRIO2 }, "hviprio2", { .raw_val = RISCV_SYSREG_HVIPRIO2 }, "", 0x647, {0} , false }, // 219 + { "htinst", { .raw_val = RISCV_SYSREG_HTINST }, "htinst", { .raw_val = RISCV_SYSREG_HTINST }, "", 0x64A, {0} , false }, // 220 + { "hviph", { .raw_val = RISCV_SYSREG_HVIPH }, "hviph", { .raw_val = RISCV_SYSREG_HVIPH }, "", 0x655, {0} , true }, // 221 + { "hviprio1h", { .raw_val = RISCV_SYSREG_HVIPRIO1H }, "hviprio1h", { .raw_val = RISCV_SYSREG_HVIPRIO1H }, "", 0x656, {0} , true }, // 222 + { "hviprio2h", { .raw_val = RISCV_SYSREG_HVIPRIO2H }, "hviprio2h", { .raw_val = RISCV_SYSREG_HVIPRIO2H }, "", 0x657, {0} , true }, // 223 + { "hgatp", { .raw_val = RISCV_SYSREG_HGATP }, "hgatp", { .raw_val = RISCV_SYSREG_HGATP }, "", 0x680, {0} , false }, // 224 + { "hcontext", { .raw_val = RISCV_SYSREG_HCONTEXT }, "hcontext", { .raw_val = RISCV_SYSREG_HCONTEXT }, "", 0x6A8, {0} , false }, // 225 + { "mhpmevent3h", { .raw_val = RISCV_SYSREG_MHPMEVENT3H }, "mhpmevent3h", { .raw_val = RISCV_SYSREG_MHPMEVENT3H }, "", 0x723, {0} , true }, // 226 + { "mhpmevent4h", { .raw_val = RISCV_SYSREG_MHPMEVENT4H }, "mhpmevent4h", { .raw_val = RISCV_SYSREG_MHPMEVENT4H }, "", 0x724, {0} , true }, // 227 + { "mhpmevent5h", { .raw_val = RISCV_SYSREG_MHPMEVENT5H }, "mhpmevent5h", { .raw_val = RISCV_SYSREG_MHPMEVENT5H }, "", 0x725, {0} , true }, // 228 + { "mhpmevent6h", { .raw_val = RISCV_SYSREG_MHPMEVENT6H }, "mhpmevent6h", { .raw_val = RISCV_SYSREG_MHPMEVENT6H }, "", 0x726, {0} , true }, // 229 + { "mhpmevent7h", { .raw_val = RISCV_SYSREG_MHPMEVENT7H }, "mhpmevent7h", { .raw_val = RISCV_SYSREG_MHPMEVENT7H }, "", 0x727, {0} , true }, // 230 + { "mhpmevent8h", { .raw_val = RISCV_SYSREG_MHPMEVENT8H }, "mhpmevent8h", { .raw_val = RISCV_SYSREG_MHPMEVENT8H }, "", 0x728, {0} , true }, // 231 + { "mhpmevent9h", { .raw_val = RISCV_SYSREG_MHPMEVENT9H }, "mhpmevent9h", { .raw_val = RISCV_SYSREG_MHPMEVENT9H }, "", 0x729, {0} , true }, // 232 + { "mhpmevent10h", { .raw_val = RISCV_SYSREG_MHPMEVENT10H }, "mhpmevent10h", { .raw_val = RISCV_SYSREG_MHPMEVENT10H }, "", 0x72A, {0} , true }, // 233 + { "mhpmevent11h", { .raw_val = RISCV_SYSREG_MHPMEVENT11H }, "mhpmevent11h", { .raw_val = RISCV_SYSREG_MHPMEVENT11H }, "", 0x72B, {0} , true }, // 234 + { "mhpmevent12h", { .raw_val = RISCV_SYSREG_MHPMEVENT12H }, "mhpmevent12h", { .raw_val = RISCV_SYSREG_MHPMEVENT12H }, "", 0x72C, {0} , true }, // 235 + { "mhpmevent13h", { .raw_val = RISCV_SYSREG_MHPMEVENT13H }, "mhpmevent13h", { .raw_val = RISCV_SYSREG_MHPMEVENT13H }, "", 0x72D, {0} , true }, // 236 + { "mhpmevent14h", { .raw_val = RISCV_SYSREG_MHPMEVENT14H }, "mhpmevent14h", { .raw_val = RISCV_SYSREG_MHPMEVENT14H }, "", 0x72E, {0} , true }, // 237 + { "mhpmevent15h", { .raw_val = RISCV_SYSREG_MHPMEVENT15H }, "mhpmevent15h", { .raw_val = RISCV_SYSREG_MHPMEVENT15H }, "", 0x72F, {0} , true }, // 238 + { "mhpmevent16h", { .raw_val = RISCV_SYSREG_MHPMEVENT16H }, "mhpmevent16h", { .raw_val = RISCV_SYSREG_MHPMEVENT16H }, "", 0x730, {0} , true }, // 239 + { "mhpmevent17h", { .raw_val = RISCV_SYSREG_MHPMEVENT17H }, "mhpmevent17h", { .raw_val = RISCV_SYSREG_MHPMEVENT17H }, "", 0x731, {0} , true }, // 240 + { "mhpmevent18h", { .raw_val = RISCV_SYSREG_MHPMEVENT18H }, "mhpmevent18h", { .raw_val = RISCV_SYSREG_MHPMEVENT18H }, "", 0x732, {0} , true }, // 241 + { "mhpmevent19h", { .raw_val = RISCV_SYSREG_MHPMEVENT19H }, "mhpmevent19h", { .raw_val = RISCV_SYSREG_MHPMEVENT19H }, "", 0x733, {0} , true }, // 242 + { "mhpmevent20h", { .raw_val = RISCV_SYSREG_MHPMEVENT20H }, "mhpmevent20h", { .raw_val = RISCV_SYSREG_MHPMEVENT20H }, "", 0x734, {0} , true }, // 243 + { "mhpmevent21h", { .raw_val = RISCV_SYSREG_MHPMEVENT21H }, "mhpmevent21h", { .raw_val = RISCV_SYSREG_MHPMEVENT21H }, "", 0x735, {0} , true }, // 244 + { "mhpmevent22h", { .raw_val = RISCV_SYSREG_MHPMEVENT22H }, "mhpmevent22h", { .raw_val = RISCV_SYSREG_MHPMEVENT22H }, "", 0x736, {0} , true }, // 245 + { "mhpmevent23h", { .raw_val = RISCV_SYSREG_MHPMEVENT23H }, "mhpmevent23h", { .raw_val = RISCV_SYSREG_MHPMEVENT23H }, "", 0x737, {0} , true }, // 246 + { "mhpmevent24h", { .raw_val = RISCV_SYSREG_MHPMEVENT24H }, "mhpmevent24h", { .raw_val = RISCV_SYSREG_MHPMEVENT24H }, "", 0x738, {0} , true }, // 247 + { "mhpmevent25h", { .raw_val = RISCV_SYSREG_MHPMEVENT25H }, "mhpmevent25h", { .raw_val = RISCV_SYSREG_MHPMEVENT25H }, "", 0x739, {0} , true }, // 248 + { "mhpmevent26h", { .raw_val = RISCV_SYSREG_MHPMEVENT26H }, "mhpmevent26h", { .raw_val = RISCV_SYSREG_MHPMEVENT26H }, "", 0x73A, {0} , true }, // 249 + { "mhpmevent27h", { .raw_val = RISCV_SYSREG_MHPMEVENT27H }, "mhpmevent27h", { .raw_val = RISCV_SYSREG_MHPMEVENT27H }, "", 0x73B, {0} , true }, // 250 + { "mhpmevent28h", { .raw_val = RISCV_SYSREG_MHPMEVENT28H }, "mhpmevent28h", { .raw_val = RISCV_SYSREG_MHPMEVENT28H }, "", 0x73C, {0} , true }, // 251 + { "mhpmevent29h", { .raw_val = RISCV_SYSREG_MHPMEVENT29H }, "mhpmevent29h", { .raw_val = RISCV_SYSREG_MHPMEVENT29H }, "", 0x73D, {0} , true }, // 252 + { "mhpmevent30h", { .raw_val = RISCV_SYSREG_MHPMEVENT30H }, "mhpmevent30h", { .raw_val = RISCV_SYSREG_MHPMEVENT30H }, "", 0x73E, {0} , true }, // 253 + { "mhpmevent31h", { .raw_val = RISCV_SYSREG_MHPMEVENT31H }, "mhpmevent31h", { .raw_val = RISCV_SYSREG_MHPMEVENT31H }, "", 0x73F, {0} , true }, // 254 + { "mseccfg", { .raw_val = RISCV_SYSREG_MSECCFG }, "mseccfg", { .raw_val = RISCV_SYSREG_MSECCFG }, "", 0x747, {0} , false }, // 255 + { "mseccfgh", { .raw_val = RISCV_SYSREG_MSECCFGH }, "mseccfgh", { .raw_val = RISCV_SYSREG_MSECCFGH }, "", 0x757, {0} , true }, // 256 + { "tselect", { .raw_val = RISCV_SYSREG_TSELECT }, "tselect", { .raw_val = RISCV_SYSREG_TSELECT }, "", 0x7A0, {0} , false }, // 257 + { "tdata1", { .raw_val = RISCV_SYSREG_TDATA1 }, "tdata1", { .raw_val = RISCV_SYSREG_TDATA1 }, "", 0x7A1, {0} , false }, // 258 + { "tdata2", { .raw_val = RISCV_SYSREG_TDATA2 }, "tdata2", { .raw_val = RISCV_SYSREG_TDATA2 }, "", 0x7A2, {0} , false }, // 259 + { "tdata3", { .raw_val = RISCV_SYSREG_TDATA3 }, "tdata3", { .raw_val = RISCV_SYSREG_TDATA3 }, "", 0x7A3, {0} , false }, // 260 + { "mcontext", { .raw_val = RISCV_SYSREG_MCONTEXT }, "mcontext", { .raw_val = RISCV_SYSREG_MCONTEXT }, "", 0x7A8, {0} , false }, // 261 + { "dcsr", { .raw_val = RISCV_SYSREG_DCSR }, "dcsr", { .raw_val = RISCV_SYSREG_DCSR }, "", 0x7B0, {0} , false }, // 262 + { "dpc", { .raw_val = RISCV_SYSREG_DPC }, "dpc", { .raw_val = RISCV_SYSREG_DPC }, "", 0x7B1, {0} , false }, // 263 + { "dscratch0", { .raw_val = RISCV_SYSREG_DSCRATCH0 }, "dscratch", { .raw_val = RISCV_SYSREG_DSCRATCH }, "", 0x7B2, {0} , false }, // 264 + { "dscratch1", { .raw_val = RISCV_SYSREG_DSCRATCH1 }, "dscratch1", { .raw_val = RISCV_SYSREG_DSCRATCH1 }, "", 0x7B3, {0} , false }, // 265 + { "mcycle", { .raw_val = RISCV_SYSREG_MCYCLE }, "mcycle", { .raw_val = RISCV_SYSREG_MCYCLE }, "", 0xB00, {0} , false }, // 266 + { "minstret", { .raw_val = RISCV_SYSREG_MINSTRET }, "minstret", { .raw_val = RISCV_SYSREG_MINSTRET }, "", 0xB02, {0} , false }, // 267 + { "mhpmcounter3", { .raw_val = RISCV_SYSREG_MHPMCOUNTER3 }, "mhpmcounter3", { .raw_val = RISCV_SYSREG_MHPMCOUNTER3 }, "", 0xB03, {0} , false }, // 268 + { "mhpmcounter4", { .raw_val = RISCV_SYSREG_MHPMCOUNTER4 }, "mhpmcounter4", { .raw_val = RISCV_SYSREG_MHPMCOUNTER4 }, "", 0xB04, {0} , false }, // 269 + { "mhpmcounter5", { .raw_val = RISCV_SYSREG_MHPMCOUNTER5 }, "mhpmcounter5", { .raw_val = RISCV_SYSREG_MHPMCOUNTER5 }, "", 0xB05, {0} , false }, // 270 + { "mhpmcounter6", { .raw_val = RISCV_SYSREG_MHPMCOUNTER6 }, "mhpmcounter6", { .raw_val = RISCV_SYSREG_MHPMCOUNTER6 }, "", 0xB06, {0} , false }, // 271 + { "mhpmcounter7", { .raw_val = RISCV_SYSREG_MHPMCOUNTER7 }, "mhpmcounter7", { .raw_val = RISCV_SYSREG_MHPMCOUNTER7 }, "", 0xB07, {0} , false }, // 272 + { "mhpmcounter8", { .raw_val = RISCV_SYSREG_MHPMCOUNTER8 }, "mhpmcounter8", { .raw_val = RISCV_SYSREG_MHPMCOUNTER8 }, "", 0xB08, {0} , false }, // 273 + { "mhpmcounter9", { .raw_val = RISCV_SYSREG_MHPMCOUNTER9 }, "mhpmcounter9", { .raw_val = RISCV_SYSREG_MHPMCOUNTER9 }, "", 0xB09, {0} , false }, // 274 + { "mhpmcounter10", { .raw_val = RISCV_SYSREG_MHPMCOUNTER10 }, "mhpmcounter10", { .raw_val = RISCV_SYSREG_MHPMCOUNTER10 }, "", 0xB0A, {0} , false }, // 275 + { "mhpmcounter11", { .raw_val = RISCV_SYSREG_MHPMCOUNTER11 }, "mhpmcounter11", { .raw_val = RISCV_SYSREG_MHPMCOUNTER11 }, "", 0xB0B, {0} , false }, // 276 + { "mhpmcounter12", { .raw_val = RISCV_SYSREG_MHPMCOUNTER12 }, "mhpmcounter12", { .raw_val = RISCV_SYSREG_MHPMCOUNTER12 }, "", 0xB0C, {0} , false }, // 277 + { "mhpmcounter13", { .raw_val = RISCV_SYSREG_MHPMCOUNTER13 }, "mhpmcounter13", { .raw_val = RISCV_SYSREG_MHPMCOUNTER13 }, "", 0xB0D, {0} , false }, // 278 + { "mhpmcounter14", { .raw_val = RISCV_SYSREG_MHPMCOUNTER14 }, "mhpmcounter14", { .raw_val = RISCV_SYSREG_MHPMCOUNTER14 }, "", 0xB0E, {0} , false }, // 279 + { "mhpmcounter15", { .raw_val = RISCV_SYSREG_MHPMCOUNTER15 }, "mhpmcounter15", { .raw_val = RISCV_SYSREG_MHPMCOUNTER15 }, "", 0xB0F, {0} , false }, // 280 + { "mhpmcounter16", { .raw_val = RISCV_SYSREG_MHPMCOUNTER16 }, "mhpmcounter16", { .raw_val = RISCV_SYSREG_MHPMCOUNTER16 }, "", 0xB10, {0} , false }, // 281 + { "mhpmcounter17", { .raw_val = RISCV_SYSREG_MHPMCOUNTER17 }, "mhpmcounter17", { .raw_val = RISCV_SYSREG_MHPMCOUNTER17 }, "", 0xB11, {0} , false }, // 282 + { "mhpmcounter18", { .raw_val = RISCV_SYSREG_MHPMCOUNTER18 }, "mhpmcounter18", { .raw_val = RISCV_SYSREG_MHPMCOUNTER18 }, "", 0xB12, {0} , false }, // 283 + { "mhpmcounter19", { .raw_val = RISCV_SYSREG_MHPMCOUNTER19 }, "mhpmcounter19", { .raw_val = RISCV_SYSREG_MHPMCOUNTER19 }, "", 0xB13, {0} , false }, // 284 + { "mhpmcounter20", { .raw_val = RISCV_SYSREG_MHPMCOUNTER20 }, "mhpmcounter20", { .raw_val = RISCV_SYSREG_MHPMCOUNTER20 }, "", 0xB14, {0} , false }, // 285 + { "mhpmcounter21", { .raw_val = RISCV_SYSREG_MHPMCOUNTER21 }, "mhpmcounter21", { .raw_val = RISCV_SYSREG_MHPMCOUNTER21 }, "", 0xB15, {0} , false }, // 286 + { "mhpmcounter22", { .raw_val = RISCV_SYSREG_MHPMCOUNTER22 }, "mhpmcounter22", { .raw_val = RISCV_SYSREG_MHPMCOUNTER22 }, "", 0xB16, {0} , false }, // 287 + { "mhpmcounter23", { .raw_val = RISCV_SYSREG_MHPMCOUNTER23 }, "mhpmcounter23", { .raw_val = RISCV_SYSREG_MHPMCOUNTER23 }, "", 0xB17, {0} , false }, // 288 + { "mhpmcounter24", { .raw_val = RISCV_SYSREG_MHPMCOUNTER24 }, "mhpmcounter24", { .raw_val = RISCV_SYSREG_MHPMCOUNTER24 }, "", 0xB18, {0} , false }, // 289 + { "mhpmcounter25", { .raw_val = RISCV_SYSREG_MHPMCOUNTER25 }, "mhpmcounter25", { .raw_val = RISCV_SYSREG_MHPMCOUNTER25 }, "", 0xB19, {0} , false }, // 290 + { "mhpmcounter26", { .raw_val = RISCV_SYSREG_MHPMCOUNTER26 }, "mhpmcounter26", { .raw_val = RISCV_SYSREG_MHPMCOUNTER26 }, "", 0xB1A, {0} , false }, // 291 + { "mhpmcounter27", { .raw_val = RISCV_SYSREG_MHPMCOUNTER27 }, "mhpmcounter27", { .raw_val = RISCV_SYSREG_MHPMCOUNTER27 }, "", 0xB1B, {0} , false }, // 292 + { "mhpmcounter28", { .raw_val = RISCV_SYSREG_MHPMCOUNTER28 }, "mhpmcounter28", { .raw_val = RISCV_SYSREG_MHPMCOUNTER28 }, "", 0xB1C, {0} , false }, // 293 + { "mhpmcounter29", { .raw_val = RISCV_SYSREG_MHPMCOUNTER29 }, "mhpmcounter29", { .raw_val = RISCV_SYSREG_MHPMCOUNTER29 }, "", 0xB1D, {0} , false }, // 294 + { "mhpmcounter30", { .raw_val = RISCV_SYSREG_MHPMCOUNTER30 }, "mhpmcounter30", { .raw_val = RISCV_SYSREG_MHPMCOUNTER30 }, "", 0xB1E, {0} , false }, // 295 + { "mhpmcounter31", { .raw_val = RISCV_SYSREG_MHPMCOUNTER31 }, "mhpmcounter31", { .raw_val = RISCV_SYSREG_MHPMCOUNTER31 }, "", 0xB1F, {0} , false }, // 296 + { "mcycleh", { .raw_val = RISCV_SYSREG_MCYCLEH }, "mcycleh", { .raw_val = RISCV_SYSREG_MCYCLEH }, "", 0xB80, {0} , true }, // 297 + { "minstreth", { .raw_val = RISCV_SYSREG_MINSTRETH }, "minstreth", { .raw_val = RISCV_SYSREG_MINSTRETH }, "", 0xB82, {0} , true }, // 298 + { "mhpmcounter3h", { .raw_val = RISCV_SYSREG_MHPMCOUNTER3H }, "mhpmcounter3h", { .raw_val = RISCV_SYSREG_MHPMCOUNTER3H }, "", 0xB83, {0} , true }, // 299 + { "mhpmcounter4h", { .raw_val = RISCV_SYSREG_MHPMCOUNTER4H }, "mhpmcounter4h", { .raw_val = RISCV_SYSREG_MHPMCOUNTER4H }, "", 0xB84, {0} , true }, // 300 + { "mhpmcounter5h", { .raw_val = RISCV_SYSREG_MHPMCOUNTER5H }, "mhpmcounter5h", { .raw_val = RISCV_SYSREG_MHPMCOUNTER5H }, "", 0xB85, {0} , true }, // 301 + { "mhpmcounter6h", { .raw_val = RISCV_SYSREG_MHPMCOUNTER6H }, "mhpmcounter6h", { .raw_val = RISCV_SYSREG_MHPMCOUNTER6H }, "", 0xB86, {0} , true }, // 302 + { "mhpmcounter7h", { .raw_val = RISCV_SYSREG_MHPMCOUNTER7H }, "mhpmcounter7h", { .raw_val = RISCV_SYSREG_MHPMCOUNTER7H }, "", 0xB87, {0} , true }, // 303 + { "mhpmcounter8h", { .raw_val = RISCV_SYSREG_MHPMCOUNTER8H }, "mhpmcounter8h", { .raw_val = RISCV_SYSREG_MHPMCOUNTER8H }, "", 0xB88, {0} , true }, // 304 + { "mhpmcounter9h", { .raw_val = RISCV_SYSREG_MHPMCOUNTER9H }, "mhpmcounter9h", { .raw_val = RISCV_SYSREG_MHPMCOUNTER9H }, "", 0xB89, {0} , true }, // 305 + { "mhpmcounter10h", { .raw_val = RISCV_SYSREG_MHPMCOUNTER10H }, "mhpmcounter10h", { .raw_val = RISCV_SYSREG_MHPMCOUNTER10H }, "", 0xB8A, {0} , true }, // 306 + { "mhpmcounter11h", { .raw_val = RISCV_SYSREG_MHPMCOUNTER11H }, "mhpmcounter11h", { .raw_val = RISCV_SYSREG_MHPMCOUNTER11H }, "", 0xB8B, {0} , true }, // 307 + { "mhpmcounter12h", { .raw_val = RISCV_SYSREG_MHPMCOUNTER12H }, "mhpmcounter12h", { .raw_val = RISCV_SYSREG_MHPMCOUNTER12H }, "", 0xB8C, {0} , true }, // 308 + { "mhpmcounter13h", { .raw_val = RISCV_SYSREG_MHPMCOUNTER13H }, "mhpmcounter13h", { .raw_val = RISCV_SYSREG_MHPMCOUNTER13H }, "", 0xB8D, {0} , true }, // 309 + { "mhpmcounter14h", { .raw_val = RISCV_SYSREG_MHPMCOUNTER14H }, "mhpmcounter14h", { .raw_val = RISCV_SYSREG_MHPMCOUNTER14H }, "", 0xB8E, {0} , true }, // 310 + { "mhpmcounter15h", { .raw_val = RISCV_SYSREG_MHPMCOUNTER15H }, "mhpmcounter15h", { .raw_val = RISCV_SYSREG_MHPMCOUNTER15H }, "", 0xB8F, {0} , true }, // 311 + { "mhpmcounter16h", { .raw_val = RISCV_SYSREG_MHPMCOUNTER16H }, "mhpmcounter16h", { .raw_val = RISCV_SYSREG_MHPMCOUNTER16H }, "", 0xB90, {0} , true }, // 312 + { "mhpmcounter17h", { .raw_val = RISCV_SYSREG_MHPMCOUNTER17H }, "mhpmcounter17h", { .raw_val = RISCV_SYSREG_MHPMCOUNTER17H }, "", 0xB91, {0} , true }, // 313 + { "mhpmcounter18h", { .raw_val = RISCV_SYSREG_MHPMCOUNTER18H }, "mhpmcounter18h", { .raw_val = RISCV_SYSREG_MHPMCOUNTER18H }, "", 0xB92, {0} , true }, // 314 + { "mhpmcounter19h", { .raw_val = RISCV_SYSREG_MHPMCOUNTER19H }, "mhpmcounter19h", { .raw_val = RISCV_SYSREG_MHPMCOUNTER19H }, "", 0xB93, {0} , true }, // 315 + { "mhpmcounter20h", { .raw_val = RISCV_SYSREG_MHPMCOUNTER20H }, "mhpmcounter20h", { .raw_val = RISCV_SYSREG_MHPMCOUNTER20H }, "", 0xB94, {0} , true }, // 316 + { "mhpmcounter21h", { .raw_val = RISCV_SYSREG_MHPMCOUNTER21H }, "mhpmcounter21h", { .raw_val = RISCV_SYSREG_MHPMCOUNTER21H }, "", 0xB95, {0} , true }, // 317 + { "mhpmcounter22h", { .raw_val = RISCV_SYSREG_MHPMCOUNTER22H }, "mhpmcounter22h", { .raw_val = RISCV_SYSREG_MHPMCOUNTER22H }, "", 0xB96, {0} , true }, // 318 + { "mhpmcounter23h", { .raw_val = RISCV_SYSREG_MHPMCOUNTER23H }, "mhpmcounter23h", { .raw_val = RISCV_SYSREG_MHPMCOUNTER23H }, "", 0xB97, {0} , true }, // 319 + { "mhpmcounter24h", { .raw_val = RISCV_SYSREG_MHPMCOUNTER24H }, "mhpmcounter24h", { .raw_val = RISCV_SYSREG_MHPMCOUNTER24H }, "", 0xB98, {0} , true }, // 320 + { "mhpmcounter25h", { .raw_val = RISCV_SYSREG_MHPMCOUNTER25H }, "mhpmcounter25h", { .raw_val = RISCV_SYSREG_MHPMCOUNTER25H }, "", 0xB99, {0} , true }, // 321 + { "mhpmcounter26h", { .raw_val = RISCV_SYSREG_MHPMCOUNTER26H }, "mhpmcounter26h", { .raw_val = RISCV_SYSREG_MHPMCOUNTER26H }, "", 0xB9A, {0} , true }, // 322 + { "mhpmcounter27h", { .raw_val = RISCV_SYSREG_MHPMCOUNTER27H }, "mhpmcounter27h", { .raw_val = RISCV_SYSREG_MHPMCOUNTER27H }, "", 0xB9B, {0} , true }, // 323 + { "mhpmcounter28h", { .raw_val = RISCV_SYSREG_MHPMCOUNTER28H }, "mhpmcounter28h", { .raw_val = RISCV_SYSREG_MHPMCOUNTER28H }, "", 0xB9C, {0} , true }, // 324 + { "mhpmcounter29h", { .raw_val = RISCV_SYSREG_MHPMCOUNTER29H }, "mhpmcounter29h", { .raw_val = RISCV_SYSREG_MHPMCOUNTER29H }, "", 0xB9D, {0} , true }, // 325 + { "mhpmcounter30h", { .raw_val = RISCV_SYSREG_MHPMCOUNTER30H }, "mhpmcounter30h", { .raw_val = RISCV_SYSREG_MHPMCOUNTER30H }, "", 0xB9E, {0} , true }, // 326 + { "mhpmcounter31h", { .raw_val = RISCV_SYSREG_MHPMCOUNTER31H }, "mhpmcounter31h", { .raw_val = RISCV_SYSREG_MHPMCOUNTER31H }, "", 0xB9F, {0} , true }, // 327 + { "cycle", { .raw_val = RISCV_SYSREG_CYCLE }, "cycle", { .raw_val = RISCV_SYSREG_CYCLE }, "", 0xC00, {0} , false }, // 328 + { "time", { .raw_val = RISCV_SYSREG_TIME }, "time", { .raw_val = RISCV_SYSREG_TIME }, "", 0xC01, {0} , false }, // 329 + { "instret", { .raw_val = RISCV_SYSREG_INSTRET }, "instret", { .raw_val = RISCV_SYSREG_INSTRET }, "", 0xC02, {0} , false }, // 330 + { "hpmcounter3", { .raw_val = RISCV_SYSREG_HPMCOUNTER3 }, "hpmcounter3", { .raw_val = RISCV_SYSREG_HPMCOUNTER3 }, "", 0xC03, {0} , false }, // 331 + { "hpmcounter4", { .raw_val = RISCV_SYSREG_HPMCOUNTER4 }, "hpmcounter4", { .raw_val = RISCV_SYSREG_HPMCOUNTER4 }, "", 0xC04, {0} , false }, // 332 + { "hpmcounter5", { .raw_val = RISCV_SYSREG_HPMCOUNTER5 }, "hpmcounter5", { .raw_val = RISCV_SYSREG_HPMCOUNTER5 }, "", 0xC05, {0} , false }, // 333 + { "hpmcounter6", { .raw_val = RISCV_SYSREG_HPMCOUNTER6 }, "hpmcounter6", { .raw_val = RISCV_SYSREG_HPMCOUNTER6 }, "", 0xC06, {0} , false }, // 334 + { "hpmcounter7", { .raw_val = RISCV_SYSREG_HPMCOUNTER7 }, "hpmcounter7", { .raw_val = RISCV_SYSREG_HPMCOUNTER7 }, "", 0xC07, {0} , false }, // 335 + { "hpmcounter8", { .raw_val = RISCV_SYSREG_HPMCOUNTER8 }, "hpmcounter8", { .raw_val = RISCV_SYSREG_HPMCOUNTER8 }, "", 0xC08, {0} , false }, // 336 + { "hpmcounter9", { .raw_val = RISCV_SYSREG_HPMCOUNTER9 }, "hpmcounter9", { .raw_val = RISCV_SYSREG_HPMCOUNTER9 }, "", 0xC09, {0} , false }, // 337 + { "hpmcounter10", { .raw_val = RISCV_SYSREG_HPMCOUNTER10 }, "hpmcounter10", { .raw_val = RISCV_SYSREG_HPMCOUNTER10 }, "", 0xC0A, {0} , false }, // 338 + { "hpmcounter11", { .raw_val = RISCV_SYSREG_HPMCOUNTER11 }, "hpmcounter11", { .raw_val = RISCV_SYSREG_HPMCOUNTER11 }, "", 0xC0B, {0} , false }, // 339 + { "hpmcounter12", { .raw_val = RISCV_SYSREG_HPMCOUNTER12 }, "hpmcounter12", { .raw_val = RISCV_SYSREG_HPMCOUNTER12 }, "", 0xC0C, {0} , false }, // 340 + { "hpmcounter13", { .raw_val = RISCV_SYSREG_HPMCOUNTER13 }, "hpmcounter13", { .raw_val = RISCV_SYSREG_HPMCOUNTER13 }, "", 0xC0D, {0} , false }, // 341 + { "hpmcounter14", { .raw_val = RISCV_SYSREG_HPMCOUNTER14 }, "hpmcounter14", { .raw_val = RISCV_SYSREG_HPMCOUNTER14 }, "", 0xC0E, {0} , false }, // 342 + { "hpmcounter15", { .raw_val = RISCV_SYSREG_HPMCOUNTER15 }, "hpmcounter15", { .raw_val = RISCV_SYSREG_HPMCOUNTER15 }, "", 0xC0F, {0} , false }, // 343 + { "hpmcounter16", { .raw_val = RISCV_SYSREG_HPMCOUNTER16 }, "hpmcounter16", { .raw_val = RISCV_SYSREG_HPMCOUNTER16 }, "", 0xC10, {0} , false }, // 344 + { "hpmcounter17", { .raw_val = RISCV_SYSREG_HPMCOUNTER17 }, "hpmcounter17", { .raw_val = RISCV_SYSREG_HPMCOUNTER17 }, "", 0xC11, {0} , false }, // 345 + { "hpmcounter18", { .raw_val = RISCV_SYSREG_HPMCOUNTER18 }, "hpmcounter18", { .raw_val = RISCV_SYSREG_HPMCOUNTER18 }, "", 0xC12, {0} , false }, // 346 + { "hpmcounter19", { .raw_val = RISCV_SYSREG_HPMCOUNTER19 }, "hpmcounter19", { .raw_val = RISCV_SYSREG_HPMCOUNTER19 }, "", 0xC13, {0} , false }, // 347 + { "hpmcounter20", { .raw_val = RISCV_SYSREG_HPMCOUNTER20 }, "hpmcounter20", { .raw_val = RISCV_SYSREG_HPMCOUNTER20 }, "", 0xC14, {0} , false }, // 348 + { "hpmcounter21", { .raw_val = RISCV_SYSREG_HPMCOUNTER21 }, "hpmcounter21", { .raw_val = RISCV_SYSREG_HPMCOUNTER21 }, "", 0xC15, {0} , false }, // 349 + { "hpmcounter22", { .raw_val = RISCV_SYSREG_HPMCOUNTER22 }, "hpmcounter22", { .raw_val = RISCV_SYSREG_HPMCOUNTER22 }, "", 0xC16, {0} , false }, // 350 + { "hpmcounter23", { .raw_val = RISCV_SYSREG_HPMCOUNTER23 }, "hpmcounter23", { .raw_val = RISCV_SYSREG_HPMCOUNTER23 }, "", 0xC17, {0} , false }, // 351 + { "hpmcounter24", { .raw_val = RISCV_SYSREG_HPMCOUNTER24 }, "hpmcounter24", { .raw_val = RISCV_SYSREG_HPMCOUNTER24 }, "", 0xC18, {0} , false }, // 352 + { "hpmcounter25", { .raw_val = RISCV_SYSREG_HPMCOUNTER25 }, "hpmcounter25", { .raw_val = RISCV_SYSREG_HPMCOUNTER25 }, "", 0xC19, {0} , false }, // 353 + { "hpmcounter26", { .raw_val = RISCV_SYSREG_HPMCOUNTER26 }, "hpmcounter26", { .raw_val = RISCV_SYSREG_HPMCOUNTER26 }, "", 0xC1A, {0} , false }, // 354 + { "hpmcounter27", { .raw_val = RISCV_SYSREG_HPMCOUNTER27 }, "hpmcounter27", { .raw_val = RISCV_SYSREG_HPMCOUNTER27 }, "", 0xC1B, {0} , false }, // 355 + { "hpmcounter28", { .raw_val = RISCV_SYSREG_HPMCOUNTER28 }, "hpmcounter28", { .raw_val = RISCV_SYSREG_HPMCOUNTER28 }, "", 0xC1C, {0} , false }, // 356 + { "hpmcounter29", { .raw_val = RISCV_SYSREG_HPMCOUNTER29 }, "hpmcounter29", { .raw_val = RISCV_SYSREG_HPMCOUNTER29 }, "", 0xC1D, {0} , false }, // 357 + { "hpmcounter30", { .raw_val = RISCV_SYSREG_HPMCOUNTER30 }, "hpmcounter30", { .raw_val = RISCV_SYSREG_HPMCOUNTER30 }, "", 0xC1E, {0} , false }, // 358 + { "hpmcounter31", { .raw_val = RISCV_SYSREG_HPMCOUNTER31 }, "hpmcounter31", { .raw_val = RISCV_SYSREG_HPMCOUNTER31 }, "", 0xC1F, {0} , false }, // 359 + { "vl", { .raw_val = RISCV_SYSREG_VL }, "vl", { .raw_val = RISCV_SYSREG_VL }, "", 0xC20, {0} , false }, // 360 + { "vtype", { .raw_val = RISCV_SYSREG_VTYPE }, "vtype", { .raw_val = RISCV_SYSREG_VTYPE }, "", 0xC21, {0} , false }, // 361 + { "vlenb", { .raw_val = RISCV_SYSREG_VLENB }, "vlenb", { .raw_val = RISCV_SYSREG_VLENB }, "", 0xC22, {0} , false }, // 362 + { "cycleh", { .raw_val = RISCV_SYSREG_CYCLEH }, "cycleh", { .raw_val = RISCV_SYSREG_CYCLEH }, "", 0xC80, {0} , true }, // 363 + { "timeh", { .raw_val = RISCV_SYSREG_TIMEH }, "timeh", { .raw_val = RISCV_SYSREG_TIMEH }, "", 0xC81, {0} , true }, // 364 + { "instreth", { .raw_val = RISCV_SYSREG_INSTRETH }, "instreth", { .raw_val = RISCV_SYSREG_INSTRETH }, "", 0xC82, {0} , true }, // 365 + { "hpmcounter3h", { .raw_val = RISCV_SYSREG_HPMCOUNTER3H }, "hpmcounter3h", { .raw_val = RISCV_SYSREG_HPMCOUNTER3H }, "", 0xC83, {0} , true }, // 366 + { "hpmcounter4h", { .raw_val = RISCV_SYSREG_HPMCOUNTER4H }, "hpmcounter4h", { .raw_val = RISCV_SYSREG_HPMCOUNTER4H }, "", 0xC84, {0} , true }, // 367 + { "hpmcounter5h", { .raw_val = RISCV_SYSREG_HPMCOUNTER5H }, "hpmcounter5h", { .raw_val = RISCV_SYSREG_HPMCOUNTER5H }, "", 0xC85, {0} , true }, // 368 + { "hpmcounter6h", { .raw_val = RISCV_SYSREG_HPMCOUNTER6H }, "hpmcounter6h", { .raw_val = RISCV_SYSREG_HPMCOUNTER6H }, "", 0xC86, {0} , true }, // 369 + { "hpmcounter7h", { .raw_val = RISCV_SYSREG_HPMCOUNTER7H }, "hpmcounter7h", { .raw_val = RISCV_SYSREG_HPMCOUNTER7H }, "", 0xC87, {0} , true }, // 370 + { "hpmcounter8h", { .raw_val = RISCV_SYSREG_HPMCOUNTER8H }, "hpmcounter8h", { .raw_val = RISCV_SYSREG_HPMCOUNTER8H }, "", 0xC88, {0} , true }, // 371 + { "hpmcounter9h", { .raw_val = RISCV_SYSREG_HPMCOUNTER9H }, "hpmcounter9h", { .raw_val = RISCV_SYSREG_HPMCOUNTER9H }, "", 0xC89, {0} , true }, // 372 + { "hpmcounter10h", { .raw_val = RISCV_SYSREG_HPMCOUNTER10H }, "hpmcounter10h", { .raw_val = RISCV_SYSREG_HPMCOUNTER10H }, "", 0xC8A, {0} , true }, // 373 + { "hpmcounter11h", { .raw_val = RISCV_SYSREG_HPMCOUNTER11H }, "hpmcounter11h", { .raw_val = RISCV_SYSREG_HPMCOUNTER11H }, "", 0xC8B, {0} , true }, // 374 + { "hpmcounter12h", { .raw_val = RISCV_SYSREG_HPMCOUNTER12H }, "hpmcounter12h", { .raw_val = RISCV_SYSREG_HPMCOUNTER12H }, "", 0xC8C, {0} , true }, // 375 + { "hpmcounter13h", { .raw_val = RISCV_SYSREG_HPMCOUNTER13H }, "hpmcounter13h", { .raw_val = RISCV_SYSREG_HPMCOUNTER13H }, "", 0xC8D, {0} , true }, // 376 + { "hpmcounter14h", { .raw_val = RISCV_SYSREG_HPMCOUNTER14H }, "hpmcounter14h", { .raw_val = RISCV_SYSREG_HPMCOUNTER14H }, "", 0xC8E, {0} , true }, // 377 + { "hpmcounter15h", { .raw_val = RISCV_SYSREG_HPMCOUNTER15H }, "hpmcounter15h", { .raw_val = RISCV_SYSREG_HPMCOUNTER15H }, "", 0xC8F, {0} , true }, // 378 + { "hpmcounter16h", { .raw_val = RISCV_SYSREG_HPMCOUNTER16H }, "hpmcounter16h", { .raw_val = RISCV_SYSREG_HPMCOUNTER16H }, "", 0xC90, {0} , true }, // 379 + { "hpmcounter17h", { .raw_val = RISCV_SYSREG_HPMCOUNTER17H }, "hpmcounter17h", { .raw_val = RISCV_SYSREG_HPMCOUNTER17H }, "", 0xC91, {0} , true }, // 380 + { "hpmcounter18h", { .raw_val = RISCV_SYSREG_HPMCOUNTER18H }, "hpmcounter18h", { .raw_val = RISCV_SYSREG_HPMCOUNTER18H }, "", 0xC92, {0} , true }, // 381 + { "hpmcounter19h", { .raw_val = RISCV_SYSREG_HPMCOUNTER19H }, "hpmcounter19h", { .raw_val = RISCV_SYSREG_HPMCOUNTER19H }, "", 0xC93, {0} , true }, // 382 + { "hpmcounter20h", { .raw_val = RISCV_SYSREG_HPMCOUNTER20H }, "hpmcounter20h", { .raw_val = RISCV_SYSREG_HPMCOUNTER20H }, "", 0xC94, {0} , true }, // 383 + { "hpmcounter21h", { .raw_val = RISCV_SYSREG_HPMCOUNTER21H }, "hpmcounter21h", { .raw_val = RISCV_SYSREG_HPMCOUNTER21H }, "", 0xC95, {0} , true }, // 384 + { "hpmcounter22h", { .raw_val = RISCV_SYSREG_HPMCOUNTER22H }, "hpmcounter22h", { .raw_val = RISCV_SYSREG_HPMCOUNTER22H }, "", 0xC96, {0} , true }, // 385 + { "hpmcounter23h", { .raw_val = RISCV_SYSREG_HPMCOUNTER23H }, "hpmcounter23h", { .raw_val = RISCV_SYSREG_HPMCOUNTER23H }, "", 0xC97, {0} , true }, // 386 + { "hpmcounter24h", { .raw_val = RISCV_SYSREG_HPMCOUNTER24H }, "hpmcounter24h", { .raw_val = RISCV_SYSREG_HPMCOUNTER24H }, "", 0xC98, {0} , true }, // 387 + { "hpmcounter25h", { .raw_val = RISCV_SYSREG_HPMCOUNTER25H }, "hpmcounter25h", { .raw_val = RISCV_SYSREG_HPMCOUNTER25H }, "", 0xC99, {0} , true }, // 388 + { "hpmcounter26h", { .raw_val = RISCV_SYSREG_HPMCOUNTER26H }, "hpmcounter26h", { .raw_val = RISCV_SYSREG_HPMCOUNTER26H }, "", 0xC9A, {0} , true }, // 389 + { "hpmcounter27h", { .raw_val = RISCV_SYSREG_HPMCOUNTER27H }, "hpmcounter27h", { .raw_val = RISCV_SYSREG_HPMCOUNTER27H }, "", 0xC9B, {0} , true }, // 390 + { "hpmcounter28h", { .raw_val = RISCV_SYSREG_HPMCOUNTER28H }, "hpmcounter28h", { .raw_val = RISCV_SYSREG_HPMCOUNTER28H }, "", 0xC9C, {0} , true }, // 391 + { "hpmcounter29h", { .raw_val = RISCV_SYSREG_HPMCOUNTER29H }, "hpmcounter29h", { .raw_val = RISCV_SYSREG_HPMCOUNTER29H }, "", 0xC9D, {0} , true }, // 392 + { "hpmcounter30h", { .raw_val = RISCV_SYSREG_HPMCOUNTER30H }, "hpmcounter30h", { .raw_val = RISCV_SYSREG_HPMCOUNTER30H }, "", 0xC9E, {0} , true }, // 393 + { "hpmcounter31h", { .raw_val = RISCV_SYSREG_HPMCOUNTER31H }, "hpmcounter31h", { .raw_val = RISCV_SYSREG_HPMCOUNTER31H }, "", 0xC9F, {0} , true }, // 394 + { "scountovf", { .raw_val = RISCV_SYSREG_SCOUNTOVF }, "scountovf", { .raw_val = RISCV_SYSREG_SCOUNTOVF }, "", 0xDA0, {0} , false }, // 395 + { "stopi", { .raw_val = RISCV_SYSREG_STOPI }, "stopi", { .raw_val = RISCV_SYSREG_STOPI }, "", 0xDB0, {0} , false }, // 396 + { "hgeip", { .raw_val = RISCV_SYSREG_HGEIP }, "hgeip", { .raw_val = RISCV_SYSREG_HGEIP }, "", 0xE12, {0} , false }, // 397 + { "vstopi", { .raw_val = RISCV_SYSREG_VSTOPI }, "vstopi", { .raw_val = RISCV_SYSREG_VSTOPI }, "", 0xEB0, {0} , false }, // 398 + { "mvendorid", { .raw_val = RISCV_SYSREG_MVENDORID }, "mvendorid", { .raw_val = RISCV_SYSREG_MVENDORID }, "", 0xF11, {0} , false }, // 399 + { "marchid", { .raw_val = RISCV_SYSREG_MARCHID }, "marchid", { .raw_val = RISCV_SYSREG_MARCHID }, "", 0xF12, {0} , false }, // 400 + { "mimpid", { .raw_val = RISCV_SYSREG_MIMPID }, "mimpid", { .raw_val = RISCV_SYSREG_MIMPID }, "", 0xF13, {0} , false }, // 401 + { "mhartid", { .raw_val = RISCV_SYSREG_MHARTID }, "mhartid", { .raw_val = RISCV_SYSREG_MHARTID }, "", 0xF14, {0} , false }, // 402 + { "mconfigptr", { .raw_val = RISCV_SYSREG_MCONFIGPTR }, "mconfigptr", { .raw_val = RISCV_SYSREG_MCONFIGPTR }, "", 0xF15, {0} , false }, // 403 + { "mtopi", { .raw_val = RISCV_SYSREG_MTOPI }, "mtopi", { .raw_val = RISCV_SYSREG_MTOPI }, "", 0xFB0, {0} , false }, // 404 + }; + +const RISCV_SysReg *RISCV_lookupSysRegByEncoding(uint16_t Encoding) { +static const struct IndexType Index[] = { +{1,0}, +{2,1}, +{3,2}, +{8,3}, +{9,4}, +{10,5}, +{15,6}, +{21,7}, +{23,8}, +{256,9}, +{260,10}, +{261,11}, +{262,12}, +{266,13}, +{268,14}, +{269,15}, +{270,16}, +{271,17}, +{276,18}, +{320,19}, +{321,20}, +{322,21}, +{323,22}, +{324,23}, +{333,24}, +{336,25}, +{337,26}, +{340,27}, +{348,28}, +{349,29}, +{384,30}, +{512,31}, +{516,32}, +{517,33}, +{532,34}, +{576,35}, +{577,36}, +{578,37}, +{579,38}, +{580,39}, +{589,40}, +{592,41}, +{593,42}, +{596,43}, +{604,44}, +{605,45}, +{640,46}, +{768,47}, +{769,48}, +{770,49}, +{771,50}, +{772,51}, +{773,52}, +{774,53}, +{776,54}, +{777,55}, +{778,56}, +{780,57}, +{781,58}, +{782,59}, +{783,60}, +{784,61}, +{787,62}, +{788,63}, +{792,64}, +{793,65}, +{794,66}, +{796,67}, +{797,68}, +{798,69}, +{799,70}, +{800,71}, +{803,72}, +{804,73}, +{805,74}, +{806,75}, +{807,76}, +{808,77}, +{809,78}, +{810,79}, +{811,80}, +{812,81}, +{813,82}, +{814,83}, +{815,84}, +{816,85}, +{817,86}, +{818,87}, +{819,88}, +{820,89}, +{821,90}, +{822,91}, +{823,92}, +{824,93}, +{825,94}, +{826,95}, +{827,96}, +{828,97}, +{829,98}, +{830,99}, +{831,100}, +{832,101}, +{833,102}, +{834,103}, +{835,104}, +{836,105}, +{842,106}, +{843,107}, +{848,108}, +{849,109}, +{852,110}, +{860,111}, +{928,112}, +{929,113}, +{930,114}, +{931,115}, +{932,116}, +{933,117}, +{934,118}, +{935,119}, +{936,120}, +{937,121}, +{938,122}, +{939,123}, +{940,124}, +{941,125}, +{942,126}, +{943,127}, +{944,128}, +{945,129}, +{946,130}, +{947,131}, +{948,132}, +{949,133}, +{950,134}, +{951,135}, +{952,136}, +{953,137}, +{954,138}, +{955,139}, +{956,140}, +{957,141}, +{958,142}, +{959,143}, +{960,144}, +{961,145}, +{962,146}, +{963,147}, +{964,148}, +{965,149}, +{966,150}, +{967,151}, +{968,152}, +{969,153}, +{970,154}, +{971,155}, +{972,156}, +{973,157}, +{974,158}, +{975,159}, +{976,160}, +{977,161}, +{978,162}, +{979,163}, +{980,164}, +{981,165}, +{982,166}, +{983,167}, +{984,168}, +{985,169}, +{986,170}, +{987,171}, +{988,172}, +{989,173}, +{990,174}, +{991,175}, +{992,176}, +{993,177}, +{994,178}, +{995,179}, +{996,180}, +{997,181}, +{998,182}, +{999,183}, +{1000,184}, +{1001,185}, +{1002,186}, +{1003,187}, +{1004,188}, +{1005,189}, +{1006,190}, +{1007,191}, +{1448,192}, +{1536,193}, +{1538,194}, +{1539,195}, +{1540,196}, +{1541,197}, +{1542,198}, +{1543,199}, +{1544,200}, +{1545,201}, +{1546,202}, +{1548,203}, +{1549,204}, +{1550,205}, +{1551,206}, +{1555,207}, +{1557,208}, +{1560,209}, +{1562,210}, +{1564,211}, +{1565,212}, +{1566,213}, +{1567,214}, +{1603,215}, +{1604,216}, +{1605,217}, +{1606,218}, +{1607,219}, +{1610,220}, +{1621,221}, +{1622,222}, +{1623,223}, +{1664,224}, +{1704,225}, +{1827,226}, +{1828,227}, +{1829,228}, +{1830,229}, +{1831,230}, +{1832,231}, +{1833,232}, +{1834,233}, +{1835,234}, +{1836,235}, +{1837,236}, +{1838,237}, +{1839,238}, +{1840,239}, +{1841,240}, +{1842,241}, +{1843,242}, +{1844,243}, +{1845,244}, +{1846,245}, +{1847,246}, +{1848,247}, +{1849,248}, +{1850,249}, +{1851,250}, +{1852,251}, +{1853,252}, +{1854,253}, +{1855,254}, +{1863,255}, +{1879,256}, +{1952,257}, +{1953,258}, +{1954,259}, +{1955,260}, +{1960,261}, +{1968,262}, +{1969,263}, +{1970,264}, +{1971,265}, +{2816,266}, +{2818,267}, +{2819,268}, +{2820,269}, +{2821,270}, +{2822,271}, +{2823,272}, +{2824,273}, +{2825,274}, +{2826,275}, +{2827,276}, +{2828,277}, +{2829,278}, +{2830,279}, +{2831,280}, +{2832,281}, +{2833,282}, +{2834,283}, +{2835,284}, +{2836,285}, +{2837,286}, +{2838,287}, +{2839,288}, +{2840,289}, +{2841,290}, +{2842,291}, +{2843,292}, +{2844,293}, +{2845,294}, +{2846,295}, +{2847,296}, +{2944,297}, +{2946,298}, +{2947,299}, +{2948,300}, +{2949,301}, +{2950,302}, +{2951,303}, +{2952,304}, +{2953,305}, +{2954,306}, +{2955,307}, +{2956,308}, +{2957,309}, +{2958,310}, +{2959,311}, +{2960,312}, +{2961,313}, +{2962,314}, +{2963,315}, +{2964,316}, +{2965,317}, +{2966,318}, +{2967,319}, +{2968,320}, +{2969,321}, +{2970,322}, +{2971,323}, +{2972,324}, +{2973,325}, +{2974,326}, +{2975,327}, +{3072,328}, +{3073,329}, +{3074,330}, +{3075,331}, +{3076,332}, +{3077,333}, +{3078,334}, +{3079,335}, +{3080,336}, +{3081,337}, +{3082,338}, +{3083,339}, +{3084,340}, +{3085,341}, +{3086,342}, +{3087,343}, +{3088,344}, +{3089,345}, +{3090,346}, +{3091,347}, +{3092,348}, +{3093,349}, +{3094,350}, +{3095,351}, +{3096,352}, +{3097,353}, +{3098,354}, +{3099,355}, +{3100,356}, +{3101,357}, +{3102,358}, +{3103,359}, +{3104,360}, +{3105,361}, +{3106,362}, +{3200,363}, +{3201,364}, +{3202,365}, +{3203,366}, +{3204,367}, +{3205,368}, +{3206,369}, +{3207,370}, +{3208,371}, +{3209,372}, +{3210,373}, +{3211,374}, +{3212,375}, +{3213,376}, +{3214,377}, +{3215,378}, +{3216,379}, +{3217,380}, +{3218,381}, +{3219,382}, +{3220,383}, +{3221,384}, +{3222,385}, +{3223,386}, +{3224,387}, +{3225,388}, +{3226,389}, +{3227,390}, +{3228,391}, +{3229,392}, +{3230,393}, +{3231,394}, +{3488,395}, +{3504,396}, +{3602,397}, +{3760,398}, +{3857,399}, +{3858,400}, +{3859,401}, +{3860,402}, +{3861,403}, +{4016,404}, +}; + unsigned i = binsearch_IndexTypeEncoding(Index, ARR_SIZE(Index), Encoding); + if (i == -1) + return NULL; + else + return &SysRegsList[Index[i].index]; +} + +const RISCV_SysReg *RISCV_lookupSysRegByAltName(const char * AltName) { + static const struct IndexTypeStr Index[] = { + { "CYCLE", 328 }, + { "CYCLEH", 363 }, + { "DCSR", 262 }, + { "DPC", 263 }, + { "DSCRATCH", 264 }, + { "DSCRATCH1", 265 }, + { "FCSR", 2 }, + { "FFLAGS", 0 }, + { "FRM", 1 }, + { "HCONTEXT", 225 }, + { "HCOUNTEREN", 198 }, + { "HEDELEG", 194 }, + { "HENVCFG", 202 }, + { "HENVCFGH", 210 }, + { "HGATP", 224 }, + { "HGEIE", 199 }, + { "HGEIP", 397 }, + { "HIDELEG", 195 }, + { "HIDELEGH", 207 }, + { "HIE", 196 }, + { "HIP", 216 }, + { "HPMCOUNTER10", 338 }, + { "HPMCOUNTER10H", 373 }, + { "HPMCOUNTER11", 339 }, + { "HPMCOUNTER11H", 374 }, + { "HPMCOUNTER12", 340 }, + { "HPMCOUNTER12H", 375 }, + { "HPMCOUNTER13", 341 }, + { "HPMCOUNTER13H", 376 }, + { "HPMCOUNTER14", 342 }, + { "HPMCOUNTER14H", 377 }, + { "HPMCOUNTER15", 343 }, + { "HPMCOUNTER15H", 378 }, + { "HPMCOUNTER16", 344 }, + { "HPMCOUNTER16H", 379 }, + { "HPMCOUNTER17", 345 }, + { "HPMCOUNTER17H", 380 }, + { "HPMCOUNTER18", 346 }, + { "HPMCOUNTER18H", 381 }, + { "HPMCOUNTER19", 347 }, + { "HPMCOUNTER19H", 382 }, + { "HPMCOUNTER20", 348 }, + { "HPMCOUNTER20H", 383 }, + { "HPMCOUNTER21", 349 }, + { "HPMCOUNTER21H", 384 }, + { "HPMCOUNTER22", 350 }, + { "HPMCOUNTER22H", 385 }, + { "HPMCOUNTER23", 351 }, + { "HPMCOUNTER23H", 386 }, + { "HPMCOUNTER24", 352 }, + { "HPMCOUNTER24H", 387 }, + { "HPMCOUNTER25", 353 }, + { "HPMCOUNTER25H", 388 }, + { "HPMCOUNTER26", 354 }, + { "HPMCOUNTER26H", 389 }, + { "HPMCOUNTER27", 355 }, + { "HPMCOUNTER27H", 390 }, + { "HPMCOUNTER28", 356 }, + { "HPMCOUNTER28H", 391 }, + { "HPMCOUNTER29", 357 }, + { "HPMCOUNTER29H", 392 }, + { "HPMCOUNTER3", 331 }, + { "HPMCOUNTER30", 358 }, + { "HPMCOUNTER30H", 393 }, + { "HPMCOUNTER31", 359 }, + { "HPMCOUNTER31H", 394 }, + { "HPMCOUNTER3H", 366 }, + { "HPMCOUNTER4", 332 }, + { "HPMCOUNTER4H", 367 }, + { "HPMCOUNTER5", 333 }, + { "HPMCOUNTER5H", 368 }, + { "HPMCOUNTER6", 334 }, + { "HPMCOUNTER6H", 369 }, + { "HPMCOUNTER7", 335 }, + { "HPMCOUNTER7H", 370 }, + { "HPMCOUNTER8", 336 }, + { "HPMCOUNTER8H", 371 }, + { "HPMCOUNTER9", 337 }, + { "HPMCOUNTER9H", 372 }, + { "HSTATEEN0", 203 }, + { "HSTATEEN0H", 211 }, + { "HSTATEEN1", 204 }, + { "HSTATEEN1H", 212 }, + { "HSTATEEN2", 205 }, + { "HSTATEEN2H", 213 }, + { "HSTATEEN3", 206 }, + { "HSTATEEN3H", 214 }, + { "HSTATUS", 193 }, + { "HTIMEDELTA", 197 }, + { "HTIMEDELTAH", 208 }, + { "HTINST", 220 }, + { "HTVAL", 215 }, + { "HVICTL", 201 }, + { "HVIEN", 200 }, + { "HVIENH", 209 }, + { "HVIP", 217 }, + { "HVIPH", 221 }, + { "HVIPRIO1", 218 }, + { "HVIPRIO1H", 222 }, + { "HVIPRIO2", 219 }, + { "HVIPRIO2H", 223 }, + { "INSTRET", 330 }, + { "INSTRETH", 365 }, + { "JVT", 8 }, + { "MARCHID", 400 }, + { "MCAUSE", 103 }, + { "MCONFIGPTR", 403 }, + { "MCONTEXT", 261 }, + { "MCOUNTEREN", 53 }, + { "MCYCLE", 266 }, + { "MCYCLEH", 297 }, + { "MEDELEG", 49 }, + { "MENVCFG", 56 }, + { "MENVCFGH", 66 }, + { "MEPC", 102 }, + { "MHARTID", 402 }, + { "MHPMCOUNTER10", 275 }, + { "MHPMCOUNTER10H", 306 }, + { "MHPMCOUNTER11", 276 }, + { "MHPMCOUNTER11H", 307 }, + { "MHPMCOUNTER12", 277 }, + { "MHPMCOUNTER12H", 308 }, + { "MHPMCOUNTER13", 278 }, + { "MHPMCOUNTER13H", 309 }, + { "MHPMCOUNTER14", 279 }, + { "MHPMCOUNTER14H", 310 }, + { "MHPMCOUNTER15", 280 }, + { "MHPMCOUNTER15H", 311 }, + { "MHPMCOUNTER16", 281 }, + { "MHPMCOUNTER16H", 312 }, + { "MHPMCOUNTER17", 282 }, + { "MHPMCOUNTER17H", 313 }, + { "MHPMCOUNTER18", 283 }, + { "MHPMCOUNTER18H", 314 }, + { "MHPMCOUNTER19", 284 }, + { "MHPMCOUNTER19H", 315 }, + { "MHPMCOUNTER20", 285 }, + { "MHPMCOUNTER20H", 316 }, + { "MHPMCOUNTER21", 286 }, + { "MHPMCOUNTER21H", 317 }, + { "MHPMCOUNTER22", 287 }, + { "MHPMCOUNTER22H", 318 }, + { "MHPMCOUNTER23", 288 }, + { "MHPMCOUNTER23H", 319 }, + { "MHPMCOUNTER24", 289 }, + { "MHPMCOUNTER24H", 320 }, + { "MHPMCOUNTER25", 290 }, + { "MHPMCOUNTER25H", 321 }, + { "MHPMCOUNTER26", 291 }, + { "MHPMCOUNTER26H", 322 }, + { "MHPMCOUNTER27", 292 }, + { "MHPMCOUNTER27H", 323 }, + { "MHPMCOUNTER28", 293 }, + { "MHPMCOUNTER28H", 324 }, + { "MHPMCOUNTER29", 294 }, + { "MHPMCOUNTER29H", 325 }, + { "MHPMCOUNTER3", 268 }, + { "MHPMCOUNTER30", 295 }, + { "MHPMCOUNTER30H", 326 }, + { "MHPMCOUNTER31", 296 }, + { "MHPMCOUNTER31H", 327 }, + { "MHPMCOUNTER3H", 299 }, + { "MHPMCOUNTER4", 269 }, + { "MHPMCOUNTER4H", 300 }, + { "MHPMCOUNTER5", 270 }, + { "MHPMCOUNTER5H", 301 }, + { "MHPMCOUNTER6", 271 }, + { "MHPMCOUNTER6H", 302 }, + { "MHPMCOUNTER7", 272 }, + { "MHPMCOUNTER7H", 303 }, + { "MHPMCOUNTER8", 273 }, + { "MHPMCOUNTER8H", 304 }, + { "MHPMCOUNTER9", 274 }, + { "MHPMCOUNTER9H", 305 }, + { "MHPMEVENT10", 79 }, + { "MHPMEVENT10H", 233 }, + { "MHPMEVENT11", 80 }, + { "MHPMEVENT11H", 234 }, + { "MHPMEVENT12", 81 }, + { "MHPMEVENT12H", 235 }, + { "MHPMEVENT13", 82 }, + { "MHPMEVENT13H", 236 }, + { "MHPMEVENT14", 83 }, + { "MHPMEVENT14H", 237 }, + { "MHPMEVENT15", 84 }, + { "MHPMEVENT15H", 238 }, + { "MHPMEVENT16", 85 }, + { "MHPMEVENT16H", 239 }, + { "MHPMEVENT17", 86 }, + { "MHPMEVENT17H", 240 }, + { "MHPMEVENT18", 87 }, + { "MHPMEVENT18H", 241 }, + { "MHPMEVENT19", 88 }, + { "MHPMEVENT19H", 242 }, + { "MHPMEVENT20", 89 }, + { "MHPMEVENT20H", 243 }, + { "MHPMEVENT21", 90 }, + { "MHPMEVENT21H", 244 }, + { "MHPMEVENT22", 91 }, + { "MHPMEVENT22H", 245 }, + { "MHPMEVENT23", 92 }, + { "MHPMEVENT23H", 246 }, + { "MHPMEVENT24", 93 }, + { "MHPMEVENT24H", 247 }, + { "MHPMEVENT25", 94 }, + { "MHPMEVENT25H", 248 }, + { "MHPMEVENT26", 95 }, + { "MHPMEVENT26H", 249 }, + { "MHPMEVENT27", 96 }, + { "MHPMEVENT27H", 250 }, + { "MHPMEVENT28", 97 }, + { "MHPMEVENT28H", 251 }, + { "MHPMEVENT29", 98 }, + { "MHPMEVENT29H", 252 }, + { "MHPMEVENT3", 72 }, + { "MHPMEVENT30", 99 }, + { "MHPMEVENT30H", 253 }, + { "MHPMEVENT31", 100 }, + { "MHPMEVENT31H", 254 }, + { "MHPMEVENT3H", 226 }, + { "MHPMEVENT4", 73 }, + { "MHPMEVENT4H", 227 }, + { "MHPMEVENT5", 74 }, + { "MHPMEVENT5H", 228 }, + { "MHPMEVENT6", 75 }, + { "MHPMEVENT6H", 229 }, + { "MHPMEVENT7", 76 }, + { "MHPMEVENT7H", 230 }, + { "MHPMEVENT8", 77 }, + { "MHPMEVENT8H", 231 }, + { "MHPMEVENT9", 78 }, + { "MHPMEVENT9H", 232 }, + { "MIDELEG", 50 }, + { "MIDELEGH", 62 }, + { "MIE", 51 }, + { "MIEH", 63 }, + { "MIMPID", 401 }, + { "MINSTRET", 267 }, + { "MINSTRETH", 298 }, + { "MIP", 105 }, + { "MIPH", 110 }, + { "MIREG", 109 }, + { "MISA", 48 }, + { "MISELECT", 108 }, + { "MSCRATCH", 101 }, + { "MSECCFG", 255 }, + { "MSECCFGH", 256 }, + { "MSTATEEN0", 57 }, + { "MSTATEEN0H", 67 }, + { "MSTATEEN1", 58 }, + { "MSTATEEN1H", 68 }, + { "MSTATEEN2", 59 }, + { "MSTATEEN2H", 69 }, + { "MSTATEEN3", 60 }, + { "MSTATEEN3H", 70 }, + { "MSTATUS", 47 }, + { "MSTATUSH", 61 }, + { "MTINST", 106 }, + { "MTOPEI", 111 }, + { "MTOPI", 404 }, + { "MTVAL", 104 }, + { "MTVAL2", 107 }, + { "MTVEC", 52 }, + { "MUCOUNTEREN", 71 }, + { "MVENDORID", 399 }, + { "MVIEN", 54 }, + { "MVIENH", 64 }, + { "MVIP", 55 }, + { "MVIPH", 65 }, + { "PMPADDR0", 128 }, + { "PMPADDR1", 129 }, + { "PMPADDR10", 138 }, + { "PMPADDR11", 139 }, + { "PMPADDR12", 140 }, + { "PMPADDR13", 141 }, + { "PMPADDR14", 142 }, + { "PMPADDR15", 143 }, + { "PMPADDR16", 144 }, + { "PMPADDR17", 145 }, + { "PMPADDR18", 146 }, + { "PMPADDR19", 147 }, + { "PMPADDR2", 130 }, + { "PMPADDR20", 148 }, + { "PMPADDR21", 149 }, + { "PMPADDR22", 150 }, + { "PMPADDR23", 151 }, + { "PMPADDR24", 152 }, + { "PMPADDR25", 153 }, + { "PMPADDR26", 154 }, + { "PMPADDR27", 155 }, + { "PMPADDR28", 156 }, + { "PMPADDR29", 157 }, + { "PMPADDR3", 131 }, + { "PMPADDR30", 158 }, + { "PMPADDR31", 159 }, + { "PMPADDR32", 160 }, + { "PMPADDR33", 161 }, + { "PMPADDR34", 162 }, + { "PMPADDR35", 163 }, + { "PMPADDR36", 164 }, + { "PMPADDR37", 165 }, + { "PMPADDR38", 166 }, + { "PMPADDR39", 167 }, + { "PMPADDR4", 132 }, + { "PMPADDR40", 168 }, + { "PMPADDR41", 169 }, + { "PMPADDR42", 170 }, + { "PMPADDR43", 171 }, + { "PMPADDR44", 172 }, + { "PMPADDR45", 173 }, + { "PMPADDR46", 174 }, + { "PMPADDR47", 175 }, + { "PMPADDR48", 176 }, + { "PMPADDR49", 177 }, + { "PMPADDR5", 133 }, + { "PMPADDR50", 178 }, + { "PMPADDR51", 179 }, + { "PMPADDR52", 180 }, + { "PMPADDR53", 181 }, + { "PMPADDR54", 182 }, + { "PMPADDR55", 183 }, + { "PMPADDR56", 184 }, + { "PMPADDR57", 185 }, + { "PMPADDR58", 186 }, + { "PMPADDR59", 187 }, + { "PMPADDR6", 134 }, + { "PMPADDR60", 188 }, + { "PMPADDR61", 189 }, + { "PMPADDR62", 190 }, + { "PMPADDR63", 191 }, + { "PMPADDR7", 135 }, + { "PMPADDR8", 136 }, + { "PMPADDR9", 137 }, + { "PMPCFG0", 112 }, + { "PMPCFG1", 113 }, + { "PMPCFG10", 122 }, + { "PMPCFG11", 123 }, + { "PMPCFG12", 124 }, + { "PMPCFG13", 125 }, + { "PMPCFG14", 126 }, + { "PMPCFG15", 127 }, + { "PMPCFG2", 114 }, + { "PMPCFG3", 115 }, + { "PMPCFG4", 116 }, + { "PMPCFG5", 117 }, + { "PMPCFG6", 118 }, + { "PMPCFG7", 119 }, + { "PMPCFG8", 120 }, + { "PMPCFG9", 121 }, + { "SATP", 30 }, + { "SCAUSE", 21 }, + { "SCONTEXT", 192 }, + { "SCOUNTEREN", 12 }, + { "SCOUNTOVF", 395 }, + { "SEED", 7 }, + { "SENVCFG", 13 }, + { "SEPC", 20 }, + { "SIE", 10 }, + { "SIEH", 18 }, + { "SIP", 23 }, + { "SIPH", 27 }, + { "SIREG", 26 }, + { "SISELECT", 25 }, + { "SSCRATCH", 19 }, + { "SSTATEEN0", 14 }, + { "SSTATEEN1", 15 }, + { "SSTATEEN2", 16 }, + { "SSTATEEN3", 17 }, + { "SSTATUS", 9 }, + { "STIMECMP", 24 }, + { "STIMECMPH", 29 }, + { "STOPEI", 28 }, + { "STOPI", 396 }, + { "STVAL", 22 }, + { "STVEC", 11 }, + { "TDATA1", 258 }, + { "TDATA2", 259 }, + { "TDATA3", 260 }, + { "TIME", 329 }, + { "TIMEH", 364 }, + { "TSELECT", 257 }, + { "VCSR", 6 }, + { "VL", 360 }, + { "VLENB", 362 }, + { "VSATP", 46 }, + { "VSCAUSE", 37 }, + { "VSEPC", 36 }, + { "VSIE", 32 }, + { "VSIEH", 34 }, + { "VSIP", 39 }, + { "VSIPH", 43 }, + { "VSIREG", 42 }, + { "VSISELECT", 41 }, + { "VSSCRATCH", 35 }, + { "VSSTATUS", 31 }, + { "VSTART", 3 }, + { "VSTIMECMP", 40 }, + { "VSTIMECMPH", 45 }, + { "VSTOPEI", 44 }, + { "VSTOPI", 398 }, + { "VSTVAL", 38 }, + { "VSTVEC", 33 }, + { "VTYPE", 361 }, + { "VXRM", 5 }, + { "VXSAT", 4 }, + }; + + unsigned i = binsearch_IndexTypeStrEncoding(Index, ARR_SIZE(Index), AltName); + if (i == -1) + return NULL; + else + return &SysRegsList[Index[i].index]; +} + +const RISCV_SysReg *RISCV_lookupSysRegByDeprecatedName(const char * DeprecatedName) { + static const struct IndexTypeStr Index[] = { + { "", 0 }, + { "", 1 }, + { "", 2 }, + { "", 3 }, + { "", 4 }, + { "", 5 }, + { "", 6 }, + { "", 7 }, + { "", 8 }, + { "", 9 }, + { "", 10 }, + { "", 11 }, + { "", 12 }, + { "", 13 }, + { "", 14 }, + { "", 15 }, + { "", 16 }, + { "", 17 }, + { "", 18 }, + { "", 19 }, + { "", 20 }, + { "", 21 }, + { "", 23 }, + { "", 24 }, + { "", 25 }, + { "", 26 }, + { "", 27 }, + { "", 28 }, + { "", 29 }, + { "", 31 }, + { "", 32 }, + { "", 33 }, + { "", 34 }, + { "", 35 }, + { "", 36 }, + { "", 37 }, + { "", 38 }, + { "", 39 }, + { "", 40 }, + { "", 41 }, + { "", 42 }, + { "", 43 }, + { "", 44 }, + { "", 45 }, + { "", 46 }, + { "", 47 }, + { "", 48 }, + { "", 49 }, + { "", 50 }, + { "", 51 }, + { "", 52 }, + { "", 53 }, + { "", 54 }, + { "", 55 }, + { "", 56 }, + { "", 57 }, + { "", 58 }, + { "", 59 }, + { "", 60 }, + { "", 61 }, + { "", 62 }, + { "", 63 }, + { "", 64 }, + { "", 65 }, + { "", 66 }, + { "", 67 }, + { "", 68 }, + { "", 69 }, + { "", 70 }, + { "", 71 }, + { "", 72 }, + { "", 73 }, + { "", 74 }, + { "", 75 }, + { "", 76 }, + { "", 77 }, + { "", 78 }, + { "", 79 }, + { "", 80 }, + { "", 81 }, + { "", 82 }, + { "", 83 }, + { "", 84 }, + { "", 85 }, + { "", 86 }, + { "", 87 }, + { "", 88 }, + { "", 89 }, + { "", 90 }, + { "", 91 }, + { "", 92 }, + { "", 93 }, + { "", 94 }, + { "", 95 }, + { "", 96 }, + { "", 97 }, + { "", 98 }, + { "", 99 }, + { "", 100 }, + { "", 101 }, + { "", 102 }, + { "", 103 }, + { "", 105 }, + { "", 106 }, + { "", 107 }, + { "", 108 }, + { "", 109 }, + { "", 110 }, + { "", 111 }, + { "", 112 }, + { "", 113 }, + { "", 114 }, + { "", 115 }, + { "", 116 }, + { "", 117 }, + { "", 118 }, + { "", 119 }, + { "", 120 }, + { "", 121 }, + { "", 122 }, + { "", 123 }, + { "", 124 }, + { "", 125 }, + { "", 126 }, + { "", 127 }, + { "", 128 }, + { "", 129 }, + { "", 130 }, + { "", 131 }, + { "", 132 }, + { "", 133 }, + { "", 134 }, + { "", 135 }, + { "", 136 }, + { "", 137 }, + { "", 138 }, + { "", 139 }, + { "", 140 }, + { "", 141 }, + { "", 142 }, + { "", 143 }, + { "", 144 }, + { "", 145 }, + { "", 146 }, + { "", 147 }, + { "", 148 }, + { "", 149 }, + { "", 150 }, + { "", 151 }, + { "", 152 }, + { "", 153 }, + { "", 154 }, + { "", 155 }, + { "", 156 }, + { "", 157 }, + { "", 158 }, + { "", 159 }, + { "", 160 }, + { "", 161 }, + { "", 162 }, + { "", 163 }, + { "", 164 }, + { "", 165 }, + { "", 166 }, + { "", 167 }, + { "", 168 }, + { "", 169 }, + { "", 170 }, + { "", 171 }, + { "", 172 }, + { "", 173 }, + { "", 174 }, + { "", 175 }, + { "", 176 }, + { "", 177 }, + { "", 178 }, + { "", 179 }, + { "", 180 }, + { "", 181 }, + { "", 182 }, + { "", 183 }, + { "", 184 }, + { "", 185 }, + { "", 186 }, + { "", 187 }, + { "", 188 }, + { "", 189 }, + { "", 190 }, + { "", 191 }, + { "", 192 }, + { "", 193 }, + { "", 194 }, + { "", 195 }, + { "", 196 }, + { "", 197 }, + { "", 198 }, + { "", 199 }, + { "", 200 }, + { "", 201 }, + { "", 202 }, + { "", 203 }, + { "", 204 }, + { "", 205 }, + { "", 206 }, + { "", 207 }, + { "", 208 }, + { "", 209 }, + { "", 210 }, + { "", 211 }, + { "", 212 }, + { "", 213 }, + { "", 214 }, + { "", 215 }, + { "", 216 }, + { "", 217 }, + { "", 218 }, + { "", 219 }, + { "", 220 }, + { "", 221 }, + { "", 222 }, + { "", 223 }, + { "", 224 }, + { "", 225 }, + { "", 226 }, + { "", 227 }, + { "", 228 }, + { "", 229 }, + { "", 230 }, + { "", 231 }, + { "", 232 }, + { "", 233 }, + { "", 234 }, + { "", 235 }, + { "", 236 }, + { "", 237 }, + { "", 238 }, + { "", 239 }, + { "", 240 }, + { "", 241 }, + { "", 242 }, + { "", 243 }, + { "", 244 }, + { "", 245 }, + { "", 246 }, + { "", 247 }, + { "", 248 }, + { "", 249 }, + { "", 250 }, + { "", 251 }, + { "", 252 }, + { "", 253 }, + { "", 254 }, + { "", 255 }, + { "", 256 }, + { "", 257 }, + { "", 258 }, + { "", 259 }, + { "", 260 }, + { "", 261 }, + { "", 262 }, + { "", 263 }, + { "", 264 }, + { "", 265 }, + { "", 266 }, + { "", 267 }, + { "", 268 }, + { "", 269 }, + { "", 270 }, + { "", 271 }, + { "", 272 }, + { "", 273 }, + { "", 274 }, + { "", 275 }, + { "", 276 }, + { "", 277 }, + { "", 278 }, + { "", 279 }, + { "", 280 }, + { "", 281 }, + { "", 282 }, + { "", 283 }, + { "", 284 }, + { "", 285 }, + { "", 286 }, + { "", 287 }, + { "", 288 }, + { "", 289 }, + { "", 290 }, + { "", 291 }, + { "", 292 }, + { "", 293 }, + { "", 294 }, + { "", 295 }, + { "", 296 }, + { "", 297 }, + { "", 298 }, + { "", 299 }, + { "", 300 }, + { "", 301 }, + { "", 302 }, + { "", 303 }, + { "", 304 }, + { "", 305 }, + { "", 306 }, + { "", 307 }, + { "", 308 }, + { "", 309 }, + { "", 310 }, + { "", 311 }, + { "", 312 }, + { "", 313 }, + { "", 314 }, + { "", 315 }, + { "", 316 }, + { "", 317 }, + { "", 318 }, + { "", 319 }, + { "", 320 }, + { "", 321 }, + { "", 322 }, + { "", 323 }, + { "", 324 }, + { "", 325 }, + { "", 326 }, + { "", 327 }, + { "", 328 }, + { "", 329 }, + { "", 330 }, + { "", 331 }, + { "", 332 }, + { "", 333 }, + { "", 334 }, + { "", 335 }, + { "", 336 }, + { "", 337 }, + { "", 338 }, + { "", 339 }, + { "", 340 }, + { "", 341 }, + { "", 342 }, + { "", 343 }, + { "", 344 }, + { "", 345 }, + { "", 346 }, + { "", 347 }, + { "", 348 }, + { "", 349 }, + { "", 350 }, + { "", 351 }, + { "", 352 }, + { "", 353 }, + { "", 354 }, + { "", 355 }, + { "", 356 }, + { "", 357 }, + { "", 358 }, + { "", 359 }, + { "", 360 }, + { "", 361 }, + { "", 362 }, + { "", 363 }, + { "", 364 }, + { "", 365 }, + { "", 366 }, + { "", 367 }, + { "", 368 }, + { "", 369 }, + { "", 370 }, + { "", 371 }, + { "", 372 }, + { "", 373 }, + { "", 374 }, + { "", 375 }, + { "", 376 }, + { "", 377 }, + { "", 378 }, + { "", 379 }, + { "", 380 }, + { "", 381 }, + { "", 382 }, + { "", 383 }, + { "", 384 }, + { "", 385 }, + { "", 386 }, + { "", 387 }, + { "", 388 }, + { "", 389 }, + { "", 390 }, + { "", 391 }, + { "", 392 }, + { "", 393 }, + { "", 394 }, + { "", 395 }, + { "", 396 }, + { "", 397 }, + { "", 398 }, + { "", 399 }, + { "", 400 }, + { "", 401 }, + { "", 402 }, + { "", 403 }, + { "", 404 }, + { "MBADADDR", 104 }, + { "SBADADDR", 22 }, + { "SPTBR", 30 }, + }; + + unsigned i = binsearch_IndexTypeStrEncoding(Index, ARR_SIZE(Index), DeprecatedName); + if (i == -1) + return NULL; + else + return &SysRegsList[Index[i].index]; +} + +const RISCV_SysReg *RISCV_lookupSysRegByName(const char * Name) { + static const struct IndexTypeStr Index[] = { + { "CYCLE", 328 }, + { "CYCLEH", 363 }, + { "DCSR", 262 }, + { "DPC", 263 }, + { "DSCRATCH0", 264 }, + { "DSCRATCH1", 265 }, + { "FCSR", 2 }, + { "FFLAGS", 0 }, + { "FRM", 1 }, + { "HCONTEXT", 225 }, + { "HCOUNTEREN", 198 }, + { "HEDELEG", 194 }, + { "HENVCFG", 202 }, + { "HENVCFGH", 210 }, + { "HGATP", 224 }, + { "HGEIE", 199 }, + { "HGEIP", 397 }, + { "HIDELEG", 195 }, + { "HIDELEGH", 207 }, + { "HIE", 196 }, + { "HIP", 216 }, + { "HPMCOUNTER10", 338 }, + { "HPMCOUNTER10H", 373 }, + { "HPMCOUNTER11", 339 }, + { "HPMCOUNTER11H", 374 }, + { "HPMCOUNTER12", 340 }, + { "HPMCOUNTER12H", 375 }, + { "HPMCOUNTER13", 341 }, + { "HPMCOUNTER13H", 376 }, + { "HPMCOUNTER14", 342 }, + { "HPMCOUNTER14H", 377 }, + { "HPMCOUNTER15", 343 }, + { "HPMCOUNTER15H", 378 }, + { "HPMCOUNTER16", 344 }, + { "HPMCOUNTER16H", 379 }, + { "HPMCOUNTER17", 345 }, + { "HPMCOUNTER17H", 380 }, + { "HPMCOUNTER18", 346 }, + { "HPMCOUNTER18H", 381 }, + { "HPMCOUNTER19", 347 }, + { "HPMCOUNTER19H", 382 }, + { "HPMCOUNTER20", 348 }, + { "HPMCOUNTER20H", 383 }, + { "HPMCOUNTER21", 349 }, + { "HPMCOUNTER21H", 384 }, + { "HPMCOUNTER22", 350 }, + { "HPMCOUNTER22H", 385 }, + { "HPMCOUNTER23", 351 }, + { "HPMCOUNTER23H", 386 }, + { "HPMCOUNTER24", 352 }, + { "HPMCOUNTER24H", 387 }, + { "HPMCOUNTER25", 353 }, + { "HPMCOUNTER25H", 388 }, + { "HPMCOUNTER26", 354 }, + { "HPMCOUNTER26H", 389 }, + { "HPMCOUNTER27", 355 }, + { "HPMCOUNTER27H", 390 }, + { "HPMCOUNTER28", 356 }, + { "HPMCOUNTER28H", 391 }, + { "HPMCOUNTER29", 357 }, + { "HPMCOUNTER29H", 392 }, + { "HPMCOUNTER3", 331 }, + { "HPMCOUNTER30", 358 }, + { "HPMCOUNTER30H", 393 }, + { "HPMCOUNTER31", 359 }, + { "HPMCOUNTER31H", 394 }, + { "HPMCOUNTER3H", 366 }, + { "HPMCOUNTER4", 332 }, + { "HPMCOUNTER4H", 367 }, + { "HPMCOUNTER5", 333 }, + { "HPMCOUNTER5H", 368 }, + { "HPMCOUNTER6", 334 }, + { "HPMCOUNTER6H", 369 }, + { "HPMCOUNTER7", 335 }, + { "HPMCOUNTER7H", 370 }, + { "HPMCOUNTER8", 336 }, + { "HPMCOUNTER8H", 371 }, + { "HPMCOUNTER9", 337 }, + { "HPMCOUNTER9H", 372 }, + { "HSTATEEN0", 203 }, + { "HSTATEEN0H", 211 }, + { "HSTATEEN1", 204 }, + { "HSTATEEN1H", 212 }, + { "HSTATEEN2", 205 }, + { "HSTATEEN2H", 213 }, + { "HSTATEEN3", 206 }, + { "HSTATEEN3H", 214 }, + { "HSTATUS", 193 }, + { "HTIMEDELTA", 197 }, + { "HTIMEDELTAH", 208 }, + { "HTINST", 220 }, + { "HTVAL", 215 }, + { "HVICTL", 201 }, + { "HVIEN", 200 }, + { "HVIENH", 209 }, + { "HVIP", 217 }, + { "HVIPH", 221 }, + { "HVIPRIO1", 218 }, + { "HVIPRIO1H", 222 }, + { "HVIPRIO2", 219 }, + { "HVIPRIO2H", 223 }, + { "INSTRET", 330 }, + { "INSTRETH", 365 }, + { "JVT", 8 }, + { "MARCHID", 400 }, + { "MCAUSE", 103 }, + { "MCONFIGPTR", 403 }, + { "MCONTEXT", 261 }, + { "MCOUNTEREN", 53 }, + { "MCOUNTINHIBIT", 71 }, + { "MCYCLE", 266 }, + { "MCYCLEH", 297 }, + { "MEDELEG", 49 }, + { "MENVCFG", 56 }, + { "MENVCFGH", 66 }, + { "MEPC", 102 }, + { "MHARTID", 402 }, + { "MHPMCOUNTER10", 275 }, + { "MHPMCOUNTER10H", 306 }, + { "MHPMCOUNTER11", 276 }, + { "MHPMCOUNTER11H", 307 }, + { "MHPMCOUNTER12", 277 }, + { "MHPMCOUNTER12H", 308 }, + { "MHPMCOUNTER13", 278 }, + { "MHPMCOUNTER13H", 309 }, + { "MHPMCOUNTER14", 279 }, + { "MHPMCOUNTER14H", 310 }, + { "MHPMCOUNTER15", 280 }, + { "MHPMCOUNTER15H", 311 }, + { "MHPMCOUNTER16", 281 }, + { "MHPMCOUNTER16H", 312 }, + { "MHPMCOUNTER17", 282 }, + { "MHPMCOUNTER17H", 313 }, + { "MHPMCOUNTER18", 283 }, + { "MHPMCOUNTER18H", 314 }, + { "MHPMCOUNTER19", 284 }, + { "MHPMCOUNTER19H", 315 }, + { "MHPMCOUNTER20", 285 }, + { "MHPMCOUNTER20H", 316 }, + { "MHPMCOUNTER21", 286 }, + { "MHPMCOUNTER21H", 317 }, + { "MHPMCOUNTER22", 287 }, + { "MHPMCOUNTER22H", 318 }, + { "MHPMCOUNTER23", 288 }, + { "MHPMCOUNTER23H", 319 }, + { "MHPMCOUNTER24", 289 }, + { "MHPMCOUNTER24H", 320 }, + { "MHPMCOUNTER25", 290 }, + { "MHPMCOUNTER25H", 321 }, + { "MHPMCOUNTER26", 291 }, + { "MHPMCOUNTER26H", 322 }, + { "MHPMCOUNTER27", 292 }, + { "MHPMCOUNTER27H", 323 }, + { "MHPMCOUNTER28", 293 }, + { "MHPMCOUNTER28H", 324 }, + { "MHPMCOUNTER29", 294 }, + { "MHPMCOUNTER29H", 325 }, + { "MHPMCOUNTER3", 268 }, + { "MHPMCOUNTER30", 295 }, + { "MHPMCOUNTER30H", 326 }, + { "MHPMCOUNTER31", 296 }, + { "MHPMCOUNTER31H", 327 }, + { "MHPMCOUNTER3H", 299 }, + { "MHPMCOUNTER4", 269 }, + { "MHPMCOUNTER4H", 300 }, + { "MHPMCOUNTER5", 270 }, + { "MHPMCOUNTER5H", 301 }, + { "MHPMCOUNTER6", 271 }, + { "MHPMCOUNTER6H", 302 }, + { "MHPMCOUNTER7", 272 }, + { "MHPMCOUNTER7H", 303 }, + { "MHPMCOUNTER8", 273 }, + { "MHPMCOUNTER8H", 304 }, + { "MHPMCOUNTER9", 274 }, + { "MHPMCOUNTER9H", 305 }, + { "MHPMEVENT10", 79 }, + { "MHPMEVENT10H", 233 }, + { "MHPMEVENT11", 80 }, + { "MHPMEVENT11H", 234 }, + { "MHPMEVENT12", 81 }, + { "MHPMEVENT12H", 235 }, + { "MHPMEVENT13", 82 }, + { "MHPMEVENT13H", 236 }, + { "MHPMEVENT14", 83 }, + { "MHPMEVENT14H", 237 }, + { "MHPMEVENT15", 84 }, + { "MHPMEVENT15H", 238 }, + { "MHPMEVENT16", 85 }, + { "MHPMEVENT16H", 239 }, + { "MHPMEVENT17", 86 }, + { "MHPMEVENT17H", 240 }, + { "MHPMEVENT18", 87 }, + { "MHPMEVENT18H", 241 }, + { "MHPMEVENT19", 88 }, + { "MHPMEVENT19H", 242 }, + { "MHPMEVENT20", 89 }, + { "MHPMEVENT20H", 243 }, + { "MHPMEVENT21", 90 }, + { "MHPMEVENT21H", 244 }, + { "MHPMEVENT22", 91 }, + { "MHPMEVENT22H", 245 }, + { "MHPMEVENT23", 92 }, + { "MHPMEVENT23H", 246 }, + { "MHPMEVENT24", 93 }, + { "MHPMEVENT24H", 247 }, + { "MHPMEVENT25", 94 }, + { "MHPMEVENT25H", 248 }, + { "MHPMEVENT26", 95 }, + { "MHPMEVENT26H", 249 }, + { "MHPMEVENT27", 96 }, + { "MHPMEVENT27H", 250 }, + { "MHPMEVENT28", 97 }, + { "MHPMEVENT28H", 251 }, + { "MHPMEVENT29", 98 }, + { "MHPMEVENT29H", 252 }, + { "MHPMEVENT3", 72 }, + { "MHPMEVENT30", 99 }, + { "MHPMEVENT30H", 253 }, + { "MHPMEVENT31", 100 }, + { "MHPMEVENT31H", 254 }, + { "MHPMEVENT3H", 226 }, + { "MHPMEVENT4", 73 }, + { "MHPMEVENT4H", 227 }, + { "MHPMEVENT5", 74 }, + { "MHPMEVENT5H", 228 }, + { "MHPMEVENT6", 75 }, + { "MHPMEVENT6H", 229 }, + { "MHPMEVENT7", 76 }, + { "MHPMEVENT7H", 230 }, + { "MHPMEVENT8", 77 }, + { "MHPMEVENT8H", 231 }, + { "MHPMEVENT9", 78 }, + { "MHPMEVENT9H", 232 }, + { "MIDELEG", 50 }, + { "MIDELEGH", 62 }, + { "MIE", 51 }, + { "MIEH", 63 }, + { "MIMPID", 401 }, + { "MINSTRET", 267 }, + { "MINSTRETH", 298 }, + { "MIP", 105 }, + { "MIPH", 110 }, + { "MIREG", 109 }, + { "MISA", 48 }, + { "MISELECT", 108 }, + { "MSCRATCH", 101 }, + { "MSECCFG", 255 }, + { "MSECCFGH", 256 }, + { "MSTATEEN0", 57 }, + { "MSTATEEN0H", 67 }, + { "MSTATEEN1", 58 }, + { "MSTATEEN1H", 68 }, + { "MSTATEEN2", 59 }, + { "MSTATEEN2H", 69 }, + { "MSTATEEN3", 60 }, + { "MSTATEEN3H", 70 }, + { "MSTATUS", 47 }, + { "MSTATUSH", 61 }, + { "MTINST", 106 }, + { "MTOPEI", 111 }, + { "MTOPI", 404 }, + { "MTVAL", 104 }, + { "MTVAL2", 107 }, + { "MTVEC", 52 }, + { "MVENDORID", 399 }, + { "MVIEN", 54 }, + { "MVIENH", 64 }, + { "MVIP", 55 }, + { "MVIPH", 65 }, + { "PMPADDR0", 128 }, + { "PMPADDR1", 129 }, + { "PMPADDR10", 138 }, + { "PMPADDR11", 139 }, + { "PMPADDR12", 140 }, + { "PMPADDR13", 141 }, + { "PMPADDR14", 142 }, + { "PMPADDR15", 143 }, + { "PMPADDR16", 144 }, + { "PMPADDR17", 145 }, + { "PMPADDR18", 146 }, + { "PMPADDR19", 147 }, + { "PMPADDR2", 130 }, + { "PMPADDR20", 148 }, + { "PMPADDR21", 149 }, + { "PMPADDR22", 150 }, + { "PMPADDR23", 151 }, + { "PMPADDR24", 152 }, + { "PMPADDR25", 153 }, + { "PMPADDR26", 154 }, + { "PMPADDR27", 155 }, + { "PMPADDR28", 156 }, + { "PMPADDR29", 157 }, + { "PMPADDR3", 131 }, + { "PMPADDR30", 158 }, + { "PMPADDR31", 159 }, + { "PMPADDR32", 160 }, + { "PMPADDR33", 161 }, + { "PMPADDR34", 162 }, + { "PMPADDR35", 163 }, + { "PMPADDR36", 164 }, + { "PMPADDR37", 165 }, + { "PMPADDR38", 166 }, + { "PMPADDR39", 167 }, + { "PMPADDR4", 132 }, + { "PMPADDR40", 168 }, + { "PMPADDR41", 169 }, + { "PMPADDR42", 170 }, + { "PMPADDR43", 171 }, + { "PMPADDR44", 172 }, + { "PMPADDR45", 173 }, + { "PMPADDR46", 174 }, + { "PMPADDR47", 175 }, + { "PMPADDR48", 176 }, + { "PMPADDR49", 177 }, + { "PMPADDR5", 133 }, + { "PMPADDR50", 178 }, + { "PMPADDR51", 179 }, + { "PMPADDR52", 180 }, + { "PMPADDR53", 181 }, + { "PMPADDR54", 182 }, + { "PMPADDR55", 183 }, + { "PMPADDR56", 184 }, + { "PMPADDR57", 185 }, + { "PMPADDR58", 186 }, + { "PMPADDR59", 187 }, + { "PMPADDR6", 134 }, + { "PMPADDR60", 188 }, + { "PMPADDR61", 189 }, + { "PMPADDR62", 190 }, + { "PMPADDR63", 191 }, + { "PMPADDR7", 135 }, + { "PMPADDR8", 136 }, + { "PMPADDR9", 137 }, + { "PMPCFG0", 112 }, + { "PMPCFG1", 113 }, + { "PMPCFG10", 122 }, + { "PMPCFG11", 123 }, + { "PMPCFG12", 124 }, + { "PMPCFG13", 125 }, + { "PMPCFG14", 126 }, + { "PMPCFG15", 127 }, + { "PMPCFG2", 114 }, + { "PMPCFG3", 115 }, + { "PMPCFG4", 116 }, + { "PMPCFG5", 117 }, + { "PMPCFG6", 118 }, + { "PMPCFG7", 119 }, + { "PMPCFG8", 120 }, + { "PMPCFG9", 121 }, + { "SATP", 30 }, + { "SCAUSE", 21 }, + { "SCONTEXT", 192 }, + { "SCOUNTEREN", 12 }, + { "SCOUNTOVF", 395 }, + { "SEED", 7 }, + { "SENVCFG", 13 }, + { "SEPC", 20 }, + { "SIE", 10 }, + { "SIEH", 18 }, + { "SIP", 23 }, + { "SIPH", 27 }, + { "SIREG", 26 }, + { "SISELECT", 25 }, + { "SSCRATCH", 19 }, + { "SSTATEEN0", 14 }, + { "SSTATEEN1", 15 }, + { "SSTATEEN2", 16 }, + { "SSTATEEN3", 17 }, + { "SSTATUS", 9 }, + { "STIMECMP", 24 }, + { "STIMECMPH", 29 }, + { "STOPEI", 28 }, + { "STOPI", 396 }, + { "STVAL", 22 }, + { "STVEC", 11 }, + { "TDATA1", 258 }, + { "TDATA2", 259 }, + { "TDATA3", 260 }, + { "TIME", 329 }, + { "TIMEH", 364 }, + { "TSELECT", 257 }, + { "VCSR", 6 }, + { "VL", 360 }, + { "VLENB", 362 }, + { "VSATP", 46 }, + { "VSCAUSE", 37 }, + { "VSEPC", 36 }, + { "VSIE", 32 }, + { "VSIEH", 34 }, + { "VSIP", 39 }, + { "VSIPH", 43 }, + { "VSIREG", 42 }, + { "VSISELECT", 41 }, + { "VSSCRATCH", 35 }, + { "VSSTATUS", 31 }, + { "VSTART", 3 }, + { "VSTIMECMP", 40 }, + { "VSTIMECMPH", 45 }, + { "VSTOPEI", 44 }, + { "VSTOPI", 398 }, + { "VSTVAL", 38 }, + { "VSTVEC", 33 }, + { "VTYPE", 361 }, + { "VXRM", 5 }, + { "VXSAT", 4 }, + }; + + unsigned i = binsearch_IndexTypeStrEncoding(Index, ARR_SIZE(Index), Name); + if (i == -1) + return NULL; + else + return &SysRegsList[Index[i].index]; +} + +#endif + +#undef GET_RISCVMaskedPseudosTable_DECL +#undef GET_RISCVMaskedPseudosTable_IMPL +#undef GET_RISCVOpcodesList_DECL +#undef GET_RISCVOpcodesList_IMPL +#undef GET_RISCVTuneInfoTable_DECL +#undef GET_RISCVTuneInfoTable_IMPL +#undef GET_RISCVVInversePseudosTable_DECL +#undef GET_RISCVVInversePseudosTable_IMPL +#undef GET_RISCVVLETable_DECL +#undef GET_RISCVVLETable_IMPL +#undef GET_RISCVVLSEGTable_DECL +#undef GET_RISCVVLSEGTable_IMPL +#undef GET_RISCVVLXSEGTable_DECL +#undef GET_RISCVVLXSEGTable_IMPL +#undef GET_RISCVVLXTable_DECL +#undef GET_RISCVVLXTable_IMPL +#undef GET_RISCVVPseudosTable_DECL +#undef GET_RISCVVPseudosTable_IMPL +#undef GET_RISCVVSETable_DECL +#undef GET_RISCVVSETable_IMPL +#undef GET_RISCVVSSEGTable_DECL +#undef GET_RISCVVSSEGTable_IMPL +#undef GET_RISCVVSXSEGTable_DECL +#undef GET_RISCVVSXSEGTable_IMPL +#undef GET_RISCVVSXTable_DECL +#undef GET_RISCVVSXTable_IMPL +#undef GET_SysRegsList_DECL +#undef GET_SysRegsList_IMPL diff --git a/arch/RISCV/RISCVInstPrinter.c b/arch/RISCV/RISCVInstPrinter.c index 5d2f492d22..114379179d 100644 --- a/arch/RISCV/RISCVInstPrinter.c +++ b/arch/RISCV/RISCVInstPrinter.c @@ -1,811 +1,411 @@ -//===-- RISCVInstPrinter.cpp - Convert RISCV MCInst to asm syntax ---------===// -// -// The LLVM Compiler Infrastructure +/* Capstone Disassembly Engine, http://www.capstone-engine.org */ +/* By Nguyen Anh Quynh , 2013-2022, */ +/* Rot127 2022-2023 */ +/* Automatically translated source file from LLVM. */ + +/* LLVM-commit: */ +/* LLVM-tag: */ + +/* Only small edits allowed. */ +/* For multiple similar edits, please create a Patch for the translator. */ + +/* Capstone's C++ file translator: */ +/* https://github.com/capstone-engine/capstone/tree/next/suite/auto-sync */ + +//===-- RISCVInstPrinter.cpp - Convert RISC-V MCInst to asm syntax --------===// // -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // -// This class prints an RISCV MCInst to a .s file. +// This class prints an RISC-V MCInst to a .s file. // //===----------------------------------------------------------------------===// -#ifdef CAPSTONE_HAS_RISCV - -#include // DEBUG -#include -#include #include +#include "../../MathExtras.h" -#include "RISCVInstPrinter.h" -#include "RISCVBaseInfo.h" -#include "../../MCInst.h" -#include "../../SStream.h" -#include "../../MCRegisterInfo.h" -#include "../../utils.h" -#include "../../Mapping.h" #include "RISCVMapping.h" +#include "RISCVInstPrinter.h" -//#include "RISCVDisassembler.h" +#define GET_SUBTARGETINFO_ENUM +#include "RISCVGenSubtargetInfo.inc" -#define GET_REGINFO_ENUM -#define GET_REGINFO_MC_DESC -#include "RISCVGenRegisterInfo.inc" #define GET_INSTRINFO_ENUM #include "RISCVGenInstrInfo.inc" -// Autogenerated by tblgen. -static void printInstruction(MCInst *MI, SStream *O, MCRegisterInfo *MRI); -static bool printAliasInstr(MCInst *MI, SStream *OS, void *info); -static void printOperand(MCInst *MI, unsigned OpNo, SStream *O); -static void printFenceArg(MCInst *MI, unsigned OpNo, SStream *O); -static void printCSRSystemRegister(MCInst *, unsigned, SStream *); -static void printFRMArg(MCInst *MI, unsigned OpNo, SStream *O); -static void printCustomAliasOperand(MCInst *, unsigned, unsigned, SStream *); -/// getRegisterName - This method is automatically generated by tblgen -/// from the register set description. This returns the assembler name -/// for the specified register. -static const char *getRegisterName(unsigned RegNo, unsigned AltIdx); +#define GET_REGINFO_ENUM +#include "RISCVGenRegisterInfo.inc" +#define GET_SysRegsList_IMPL +#include "RISCVGenSystemOperands.inc" + +#define GEN_UNCOMPRESS_INSTR +#include "RISCVGenCompressedInstructionsInfo.inc" + +#include "RISCVMapping.h" + +#define CONCAT(a, b) CONCAT_(a, b) +#define CONCAT_(a, b) a##_##b + +#define DEBUG_TYPE "asm-printer" + +static void printCustomAliasOperand( + MCInst *MI, uint64_t Address, unsigned OpIdx, + unsigned PrintMethodIdx, + SStream *OS); +static inline void printRegName(SStream *O, MCRegister Reg); +static inline void printOperand(MCInst *MI, unsigned OpNo, SStream *O); // Include the auto-generated portion of the assembly writer. #define PRINT_ALIAS_INSTR #include "RISCVGenAsmWriter.inc" -static void fixDetailOfEffectiveAddr(MCInst *MI) -{ - // Operands for load and store instructions in RISCV vary widely - unsigned id = MI->flat_insn->id; - unsigned reg = 0; - int64_t imm = 0; - uint8_t access = 0; - - switch (id) { - case RISCV_INS_C_FLD: - case RISCV_INS_C_LW: - case RISCV_INS_C_FLW: - case RISCV_INS_C_LD: - case RISCV_INS_C_FSD: - case RISCV_INS_C_SW: - case RISCV_INS_C_FSW: - case RISCV_INS_C_SD: - case RISCV_INS_C_FLDSP: - case RISCV_INS_C_LWSP: - case RISCV_INS_C_FLWSP: - case RISCV_INS_C_LDSP: - case RISCV_INS_C_FSDSP: - case RISCV_INS_C_SWSP: - case RISCV_INS_C_FSWSP: - case RISCV_INS_C_SDSP: - case RISCV_INS_FLW: - case RISCV_INS_FSW: - case RISCV_INS_FLD: - case RISCV_INS_FSD: - case RISCV_INS_LB: - case RISCV_INS_LBU: - case RISCV_INS_LD: - case RISCV_INS_LH: - case RISCV_INS_LHU: - case RISCV_INS_LW: - case RISCV_INS_LWU: - case RISCV_INS_SB: - case RISCV_INS_SD: - case RISCV_INS_SH: - case RISCV_INS_SW: { - CS_ASSERT(3 == MI->flat_insn->detail->riscv.op_count); - CS_ASSERT(RISCV_OP_REG == RISCV_get_detail_op(MI, -3)->type); - CS_ASSERT(RISCV_OP_IMM == RISCV_get_detail_op(MI, -2)->type); - CS_ASSERT(RISCV_OP_REG == RISCV_get_detail_op(MI, -1)->type); - - imm = RISCV_get_detail_op(MI, -2)->imm; - reg = RISCV_get_detail_op(MI, -1)->reg; - access = RISCV_get_detail_op(MI, -1)->access; - - RISCV_get_detail_op(MI, -2)->type = RISCV_OP_MEM; - RISCV_get_detail_op(MI, -2)->mem.base = reg; - RISCV_get_detail_op(MI, -2)->mem.disp = imm; - RISCV_get_detail_op(MI, -2)->access = access; - - RISCV_dec_op_count(MI); - - break; - } - case RISCV_INS_LR_W: - case RISCV_INS_LR_W_AQ: - case RISCV_INS_LR_W_AQ_RL: - case RISCV_INS_LR_W_RL: - case RISCV_INS_LR_D: - case RISCV_INS_LR_D_AQ: - case RISCV_INS_LR_D_AQ_RL: - case RISCV_INS_LR_D_RL: { - CS_ASSERT(2 == MI->flat_insn->detail->riscv.op_count); - CS_ASSERT(RISCV_OP_REG == RISCV_get_detail_op(MI, -1)->type); - CS_ASSERT(RISCV_OP_REG == RISCV_get_detail_op(MI, -2)->type); - - reg = RISCV_get_detail_op(MI, -1)->reg; - - RISCV_get_detail_op(MI, -1)->type = RISCV_OP_MEM; - RISCV_get_detail_op(MI, -1)->mem.base = reg; - RISCV_get_detail_op(MI, -1)->mem.disp = 0; - - break; - } - case RISCV_INS_SC_W: - case RISCV_INS_SC_W_AQ: - case RISCV_INS_SC_W_AQ_RL: - case RISCV_INS_SC_W_RL: - case RISCV_INS_SC_D: - case RISCV_INS_SC_D_AQ: - case RISCV_INS_SC_D_AQ_RL: - case RISCV_INS_SC_D_RL: - case RISCV_INS_AMOADD_D: - case RISCV_INS_AMOADD_D_AQ: - case RISCV_INS_AMOADD_D_AQ_RL: - case RISCV_INS_AMOADD_D_RL: - case RISCV_INS_AMOADD_W: - case RISCV_INS_AMOADD_W_AQ: - case RISCV_INS_AMOADD_W_AQ_RL: - case RISCV_INS_AMOADD_W_RL: - case RISCV_INS_AMOAND_D: - case RISCV_INS_AMOAND_D_AQ: - case RISCV_INS_AMOAND_D_AQ_RL: - case RISCV_INS_AMOAND_D_RL: - case RISCV_INS_AMOAND_W: - case RISCV_INS_AMOAND_W_AQ: - case RISCV_INS_AMOAND_W_AQ_RL: - case RISCV_INS_AMOAND_W_RL: - case RISCV_INS_AMOMAXU_D: - case RISCV_INS_AMOMAXU_D_AQ: - case RISCV_INS_AMOMAXU_D_AQ_RL: - case RISCV_INS_AMOMAXU_D_RL: - case RISCV_INS_AMOMAXU_W: - case RISCV_INS_AMOMAXU_W_AQ: - case RISCV_INS_AMOMAXU_W_AQ_RL: - case RISCV_INS_AMOMAXU_W_RL: - case RISCV_INS_AMOMAX_D: - case RISCV_INS_AMOMAX_D_AQ: - case RISCV_INS_AMOMAX_D_AQ_RL: - case RISCV_INS_AMOMAX_D_RL: - case RISCV_INS_AMOMAX_W: - case RISCV_INS_AMOMAX_W_AQ: - case RISCV_INS_AMOMAX_W_AQ_RL: - case RISCV_INS_AMOMAX_W_RL: - case RISCV_INS_AMOMINU_D: - case RISCV_INS_AMOMINU_D_AQ: - case RISCV_INS_AMOMINU_D_AQ_RL: - case RISCV_INS_AMOMINU_D_RL: - case RISCV_INS_AMOMINU_W: - case RISCV_INS_AMOMINU_W_AQ: - case RISCV_INS_AMOMINU_W_AQ_RL: - case RISCV_INS_AMOMINU_W_RL: - case RISCV_INS_AMOMIN_D: - case RISCV_INS_AMOMIN_D_AQ: - case RISCV_INS_AMOMIN_D_AQ_RL: - case RISCV_INS_AMOMIN_D_RL: - case RISCV_INS_AMOMIN_W: - case RISCV_INS_AMOMIN_W_AQ: - case RISCV_INS_AMOMIN_W_AQ_RL: - case RISCV_INS_AMOMIN_W_RL: - case RISCV_INS_AMOOR_D: - case RISCV_INS_AMOOR_D_AQ: - case RISCV_INS_AMOOR_D_AQ_RL: - case RISCV_INS_AMOOR_D_RL: - case RISCV_INS_AMOOR_W: - case RISCV_INS_AMOOR_W_AQ: - case RISCV_INS_AMOOR_W_AQ_RL: - case RISCV_INS_AMOOR_W_RL: - case RISCV_INS_AMOSWAP_D: - case RISCV_INS_AMOSWAP_D_AQ: - case RISCV_INS_AMOSWAP_D_AQ_RL: - case RISCV_INS_AMOSWAP_D_RL: - case RISCV_INS_AMOSWAP_W: - case RISCV_INS_AMOSWAP_W_AQ: - case RISCV_INS_AMOSWAP_W_AQ_RL: - case RISCV_INS_AMOSWAP_W_RL: - case RISCV_INS_AMOXOR_D: - case RISCV_INS_AMOXOR_D_AQ: - case RISCV_INS_AMOXOR_D_AQ_RL: - case RISCV_INS_AMOXOR_D_RL: - case RISCV_INS_AMOXOR_W: - case RISCV_INS_AMOXOR_W_AQ: - case RISCV_INS_AMOXOR_W_AQ_RL: - case RISCV_INS_AMOXOR_W_RL: { - CS_ASSERT(3 == MI->flat_insn->detail->riscv.op_count); - CS_ASSERT(RISCV_OP_REG == RISCV_get_detail_op(MI, -3)->type); - CS_ASSERT(RISCV_OP_REG == RISCV_get_detail_op(MI, -2)->type); - CS_ASSERT(RISCV_OP_REG == RISCV_get_detail_op(MI, -1)->type); - - reg = RISCV_get_detail_op(MI, -1)->reg; - - RISCV_get_detail_op(MI, -1)->type = RISCV_OP_MEM; - RISCV_get_detail_op(MI, -1)->mem.base = reg; - RISCV_get_detail_op(MI, -1)->mem.disp = 0; +// Print architectural register names rather than the ABI names (such as x2 +// instead of sp). +// TODO: Make RISCVInstPrinter_doGetRegisterName non-static so that this can a +// member. +static bool ArchRegNames; - break; - } - default: { - CS_ASSERT(0 && "id is not a RISC-V memory instruction"); - break; - } - } - return; +const char *doGetRegisterName(MCRegister Reg) +{ + return getRegisterName(Reg, ArchRegNames ? RISCV_NoRegAltName : + RISCV_ABIRegAltName); } -//void RISCVInstPrinter::printInst(const MCInst *MI, raw_ostream &O, -// StringRef Annot, const MCSubtargetInfo &STI) -void RISCV_printInst(MCInst *MI, SStream *O, void *info) +static inline void printRegName(SStream *O, MCRegister Reg) { - MCRegisterInfo *MRI = (MCRegisterInfo *)info; - //bool Res = false; - //MCInst *NewMI = MI; - // TODO: RISCV compressd instructions. - //MCInst UncompressedMI; - //if (!NoAliases) - //Res = uncompressInst(UncompressedMI, *MI, MRI, STI); - //if (Res) - //NewMI = const_cast(&UncompressedMI); - if (/*NoAliases ||*/ !printAliasInstr(MI, O, info)) - printInstruction(MI, O, MRI); - //printAnnotation(O, Annot); - // fix load/store type insttuction - if (MI->csh->detail_opt && - MI->flat_insn->detail->riscv.need_effective_addr) - fixDetailOfEffectiveAddr(MI); - - return; + SStream_concat0(markup_OS(O, Markup_Register), doGetRegisterName(Reg)); } -static void printRegName(SStream *OS, unsigned RegNo) -{ - SStream_concat0(OS, getRegisterName(RegNo, RISCV_ABIRegAltName)); +bool haveRequiredFeatures(const RISCV_SysReg *Reg, MCInst *MI) { + // Not in 32-bit mode. + if (Reg->isRV32Only && RISCV_getFeatureBits(MI->csh->mode, RISCV_Feature64Bit)) + return false; + + return true; } -/** -void RISCVInstPrinter::printOperand(const MCInst *MI, unsigned OpNo, - raw_ostream &O, const char *Modifier) -*/ -static void printOperand(MCInst *MI, unsigned OpNo, SStream *O) +static inline void printOperand(MCInst *MI, unsigned OpNo, SStream *O) { - unsigned reg; - int64_t Imm = 0; - - RISCV_add_cs_detail(MI, OpNo); + RISCV_add_cs_detail_0(MI, RISCV_OP_GROUP_Operand, OpNo); - MCOperand *MO = MCInst_getOperand(MI, OpNo); + MCOperand *MO = MCInst_getOperand(MI, (OpNo)); if (MCOperand_isReg(MO)) { - reg = MCOperand_getReg(MO); - printRegName(O, reg); - } else { - CS_ASSERT(MCOperand_isImm(MO) && - "Unknown operand kind in printOperand"); - Imm = MCOperand_getImm(MO); - if (Imm >= 0) { - if (Imm > HEX_THRESHOLD) - SStream_concat(O, "0x%" PRIx64, Imm); - else - SStream_concat(O, "%" PRIu64, Imm); - } else { - if (Imm < -HEX_THRESHOLD) - SStream_concat(O, "-0x%" PRIx64, -Imm); - else - SStream_concat(O, "-%" PRIu64, -Imm); - } + printRegName(O, MCOperand_getReg(MO)); + return; } - //CS_ASSERT(MO.isExpr() && "Unknown operand kind in printOperand"); + if (MCOperand_isImm(MO)) { + printInt64(markup_OS(O, Markup_Immediate), + MCOperand_getImm(MO)); + return; + } - return; + CS_ASSERT(MCOperand_isExpr(MO) && + "Unknown operand kind in printOperand"); + printExpr(O, MCOperand_getExpr(MO)); } -static const char *getCSRSystemRegisterName(unsigned CsrNo) + void printBranchOperand(MCInst *MI, uint64_t Address, + unsigned OpNo, SStream *O) { - switch (CsrNo) { - /* - * From RISC-V Privileged Architecture Version 1.10. - * In the same order as Table 2.5. - */ - case 0x0000: - return "ustatus"; - case 0x0004: - return "uie"; - case 0x0005: - return "utvec"; - - case 0x0040: - return "uscratch"; - case 0x0041: - return "uepc"; - case 0x0042: - return "ucause"; - case 0x0043: - return "utval"; - case 0x0044: - return "uip"; - - case 0x0001: - return "fflags"; - case 0x0002: - return "frm"; - case 0x0003: - return "fcsr"; - - case 0x0c00: - return "cycle"; - case 0x0c01: - return "time"; - case 0x0c02: - return "instret"; - case 0x0c03: - return "hpmcounter3"; - case 0x0c04: - return "hpmcounter4"; - case 0x0c05: - return "hpmcounter5"; - case 0x0c06: - return "hpmcounter6"; - case 0x0c07: - return "hpmcounter7"; - case 0x0c08: - return "hpmcounter8"; - case 0x0c09: - return "hpmcounter9"; - case 0x0c0a: - return "hpmcounter10"; - case 0x0c0b: - return "hpmcounter11"; - case 0x0c0c: - return "hpmcounter12"; - case 0x0c0d: - return "hpmcounter13"; - case 0x0c0e: - return "hpmcounter14"; - case 0x0c0f: - return "hpmcounter15"; - case 0x0c10: - return "hpmcounter16"; - case 0x0c11: - return "hpmcounter17"; - case 0x0c12: - return "hpmcounter18"; - case 0x0c13: - return "hpmcounter19"; - case 0x0c14: - return "hpmcounter20"; - case 0x0c15: - return "hpmcounter21"; - case 0x0c16: - return "hpmcounter22"; - case 0x0c17: - return "hpmcounter23"; - case 0x0c18: - return "hpmcounter24"; - case 0x0c19: - return "hpmcounter25"; - case 0x0c1a: - return "hpmcounter26"; - case 0x0c1b: - return "hpmcounter27"; - case 0x0c1c: - return "hpmcounter28"; - case 0x0c1d: - return "hpmcounter29"; - case 0x0c1e: - return "hpmcounter30"; - case 0x0c1f: - return "hpmcounter31"; - case 0x0c80: - return "cycleh"; - case 0x0c81: - return "timeh"; - case 0x0c82: - return "instreth"; - case 0x0c83: - return "hpmcounter3h"; - case 0x0c84: - return "hpmcounter4h"; - case 0x0c85: - return "hpmcounter5h"; - case 0x0c86: - return "hpmcounter6h"; - case 0x0c87: - return "hpmcounter7h"; - case 0x0c88: - return "hpmcounter8h"; - case 0x0c89: - return "hpmcounter9h"; - case 0x0c8a: - return "hpmcounter10h"; - case 0x0c8b: - return "hpmcounter11h"; - case 0x0c8c: - return "hpmcounter12h"; - case 0x0c8d: - return "hpmcounter13h"; - case 0x0c8e: - return "hpmcounter14h"; - case 0x0c8f: - return "hpmcounter15h"; - case 0x0c90: - return "hpmcounter16h"; - case 0x0c91: - return "hpmcounter17h"; - case 0x0c92: - return "hpmcounter18h"; - case 0x0c93: - return "hpmcounter19h"; - case 0x0c94: - return "hpmcounter20h"; - case 0x0c95: - return "hpmcounter21h"; - case 0x0c96: - return "hpmcounter22h"; - case 0x0c97: - return "hpmcounter23h"; - case 0x0c98: - return "hpmcounter24h"; - case 0x0c99: - return "hpmcounter25h"; - case 0x0c9a: - return "hpmcounter26h"; - case 0x0c9b: - return "hpmcounter27h"; - case 0x0c9c: - return "hpmcounter28h"; - case 0x0c9d: - return "hpmcounter29h"; - case 0x0c9e: - return "hpmcounter30h"; - case 0x0c9f: - return "hpmcounter31h"; - - case 0x0100: - return "sstatus"; - case 0x0102: - return "sedeleg"; - case 0x0103: - return "sideleg"; - case 0x0104: - return "sie"; - case 0x0105: - return "stvec"; - case 0x0106: - return "scounteren"; - - case 0x0140: - return "sscratch"; - case 0x0141: - return "sepc"; - case 0x0142: - return "scause"; - case 0x0143: - return "stval"; - case 0x0144: - return "sip"; - - case 0x0180: - return "satp"; - - case 0x0f11: - return "mvendorid"; - case 0x0f12: - return "marchid"; - case 0x0f13: - return "mimpid"; - case 0x0f14: - return "mhartid"; - - case 0x0300: - return "mstatus"; - case 0x0301: - return "misa"; - case 0x0302: - return "medeleg"; - case 0x0303: - return "mideleg"; - case 0x0304: - return "mie"; - case 0x0305: - return "mtvec"; - case 0x0306: - return "mcounteren"; - - case 0x0340: - return "mscratch"; - case 0x0341: - return "mepc"; - case 0x0342: - return "mcause"; - case 0x0343: - return "mtval"; - case 0x0344: - return "mip"; - - case 0x03a0: - return "pmpcfg0"; - case 0x03a1: - return "pmpcfg1"; - case 0x03a2: - return "pmpcfg2"; - case 0x03a3: - return "pmpcfg3"; - case 0x03b0: - return "pmpaddr0"; - case 0x03b1: - return "pmpaddr1"; - case 0x03b2: - return "pmpaddr2"; - case 0x03b3: - return "pmpaddr3"; - case 0x03b4: - return "pmpaddr4"; - case 0x03b5: - return "pmpaddr5"; - case 0x03b6: - return "pmpaddr6"; - case 0x03b7: - return "pmpaddr7"; - case 0x03b8: - return "pmpaddr8"; - case 0x03b9: - return "pmpaddr9"; - case 0x03ba: - return "pmpaddr10"; - case 0x03bb: - return "pmpaddr11"; - case 0x03bc: - return "pmpaddr12"; - case 0x03bd: - return "pmpaddr13"; - case 0x03be: - return "pmpaddr14"; - case 0x03bf: - return "pmpaddr15"; - - case 0x0b00: - return "mcycle"; - case 0x0b02: - return "minstret"; - case 0x0b03: - return "mhpmcounter3"; - case 0x0b04: - return "mhpmcounter4"; - case 0x0b05: - return "mhpmcounter5"; - case 0x0b06: - return "mhpmcounter6"; - case 0x0b07: - return "mhpmcounter7"; - case 0x0b08: - return "mhpmcounter8"; - case 0x0b09: - return "mhpmcounter9"; - case 0x0b0a: - return "mhpmcounter10"; - case 0x0b0b: - return "mhpmcounter11"; - case 0x0b0c: - return "mhpmcounter12"; - case 0x0b0d: - return "mhpmcounter13"; - case 0x0b0e: - return "mhpmcounter14"; - case 0x0b0f: - return "mhpmcounter15"; - case 0x0b10: - return "mhpmcounter16"; - case 0x0b11: - return "mhpmcounter17"; - case 0x0b12: - return "mhpmcounter18"; - case 0x0b13: - return "mhpmcounter19"; - case 0x0b14: - return "mhpmcounter20"; - case 0x0b15: - return "mhpmcounter21"; - case 0x0b16: - return "mhpmcounter22"; - case 0x0b17: - return "mhpmcounter23"; - case 0x0b18: - return "mhpmcounter24"; - case 0x0b19: - return "mhpmcounter25"; - case 0x0b1a: - return "mhpmcounter26"; - case 0x0b1b: - return "mhpmcounter27"; - case 0x0b1c: - return "mhpmcounter28"; - case 0x0b1d: - return "mhpmcounter29"; - case 0x0b1e: - return "mhpmcounter30"; - case 0x0b1f: - return "mhpmcounter31"; - case 0x0b80: - return "mcycleh"; - case 0x0b82: - return "minstreth"; - case 0x0b83: - return "mhpmcounter3h"; - case 0x0b84: - return "mhpmcounter4h"; - case 0x0b85: - return "mhpmcounter5h"; - case 0x0b86: - return "mhpmcounter6h"; - case 0x0b87: - return "mhpmcounter7h"; - case 0x0b88: - return "mhpmcounter8h"; - case 0x0b89: - return "mhpmcounter9h"; - case 0x0b8a: - return "mhpmcounter10h"; - case 0x0b8b: - return "mhpmcounter11h"; - case 0x0b8c: - return "mhpmcounter12h"; - case 0x0b8d: - return "mhpmcounter13h"; - case 0x0b8e: - return "mhpmcounter14h"; - case 0x0b8f: - return "mhpmcounter15h"; - case 0x0b90: - return "mhpmcounter16h"; - case 0x0b91: - return "mhpmcounter17h"; - case 0x0b92: - return "mhpmcounter18h"; - case 0x0b93: - return "mhpmcounter19h"; - case 0x0b94: - return "mhpmcounter20h"; - case 0x0b95: - return "mhpmcounter21h"; - case 0x0b96: - return "mhpmcounter22h"; - case 0x0b97: - return "mhpmcounter23h"; - case 0x0b98: - return "mhpmcounter24h"; - case 0x0b99: - return "mhpmcounter25h"; - case 0x0b9a: - return "mhpmcounter26h"; - case 0x0b9b: - return "mhpmcounter27h"; - case 0x0b9c: - return "mhpmcounter28h"; - case 0x0b9d: - return "mhpmcounter29h"; - case 0x0b9e: - return "mhpmcounter30h"; - case 0x0b9f: - return "mhpmcounter31h"; - - case 0x0323: - return "mhpmevent3"; - case 0x0324: - return "mhpmevent4"; - case 0x0325: - return "mhpmevent5"; - case 0x0326: - return "mhpmevent6"; - case 0x0327: - return "mhpmevent7"; - case 0x0328: - return "mhpmevent8"; - case 0x0329: - return "mhpmevent9"; - case 0x032a: - return "mhpmevent10"; - case 0x032b: - return "mhpmevent11"; - case 0x032c: - return "mhpmevent12"; - case 0x032d: - return "mhpmevent13"; - case 0x032e: - return "mhpmevent14"; - case 0x032f: - return "mhpmevent15"; - case 0x0330: - return "mhpmevent16"; - case 0x0331: - return "mhpmevent17"; - case 0x0332: - return "mhpmevent18"; - case 0x0333: - return "mhpmevent19"; - case 0x0334: - return "mhpmevent20"; - case 0x0335: - return "mhpmevent21"; - case 0x0336: - return "mhpmevent22"; - case 0x0337: - return "mhpmevent23"; - case 0x0338: - return "mhpmevent24"; - case 0x0339: - return "mhpmevent25"; - case 0x033a: - return "mhpmevent26"; - case 0x033b: - return "mhpmevent27"; - case 0x033c: - return "mhpmevent28"; - case 0x033d: - return "mhpmevent29"; - case 0x033e: - return "mhpmevent30"; - case 0x033f: - return "mhpmevent31"; - - case 0x07a0: - return "tselect"; - case 0x07a1: - return "tdata1"; - case 0x07a2: - return "tdata2"; - case 0x07a3: - return "tdata3"; - - case 0x07b0: - return "dcsr"; - case 0x07b1: - return "dpc"; - case 0x07b2: - return "dscratch"; + RISCV_add_cs_detail_0(MI, RISCV_OP_GROUP_BranchOperand, OpNo); + MCOperand *MO = MCInst_getOperand(MI, (OpNo)); + if (!MCOperand_isImm(MO)) + return printOperand(MI, OpNo, O); + + if (MI->csh->PrintBranchImmAsAddress) { + uint64_t Target = Address + MCOperand_getImm(MO); + if (!RISCV_getFeatureBits(MI->csh->mode, RISCV_Feature64Bit)) + Target &= 0xffffffff; + printUInt64(markup_OS(O, Markup_Target), Target); + } else { + printInt64(markup_OS(O, Markup_Target), + MCOperand_getImm(MO)); } - return NULL; } -static void printCSRSystemRegister(MCInst *MI, unsigned OpNo, - //const MCSubtargetInfo &STI, - SStream *O) + void printCSRSystemRegister(MCInst *MI, unsigned OpNo, SStream *O) { - unsigned Imm = MCOperand_getImm(MCInst_getOperand(MI, OpNo)); - const char *Name = getCSRSystemRegisterName(Imm); - - if (Name) { - SStream_concat0(O, Name); - } else { - SStream_concat(O, "%u", Imm); - } + RISCV_add_cs_detail_0(MI, RISCV_OP_GROUP_CSRSystemRegister, OpNo); + unsigned Imm = MCOperand_getImm(MCInst_getOperand(MI, (OpNo))); + const RISCV_SysReg *SysReg = RISCV_lookupSysRegByEncoding(Imm); + if (SysReg && haveRequiredFeatures(SysReg, MI)) + SStream_concat0(markup_OS(O, Markup_Register), SysReg->Name); + else + printUInt64(markup_OS(O, Markup_Register), Imm); } -static void printFenceArg(MCInst *MI, unsigned OpNo, SStream *O) + void printFenceArg(MCInst *MI, unsigned OpNo, SStream *O) { - unsigned FenceArg = MCOperand_getImm(MCInst_getOperand(MI, OpNo)); - //CS_ASSERT (((FenceArg >> 4) == 0) && "Invalid immediate in printFenceArg"); + RISCV_add_cs_detail_0(MI, RISCV_OP_GROUP_FenceArg, OpNo); + unsigned FenceArg = MCOperand_getImm(MCInst_getOperand(MI, (OpNo))); + CS_ASSERT(((FenceArg >> 4) == 0) && + "Invalid immediate in printFenceArg"); if ((FenceArg & RISCVFenceField_I) != 0) SStream_concat0(O, "i"); + if ((FenceArg & RISCVFenceField_O) != 0) SStream_concat0(O, "o"); + if ((FenceArg & RISCVFenceField_R) != 0) SStream_concat0(O, "r"); + if ((FenceArg & RISCVFenceField_W) != 0) SStream_concat0(O, "w"); + if (FenceArg == 0) - SStream_concat0(O, "unknown"); + SStream_concat0(O, "0"); +} + + void printFRMArg(MCInst *MI, unsigned OpNo, SStream *O) +{ + RISCV_add_cs_detail_0(MI, RISCV_OP_GROUP_FRMArg, OpNo); + unsigned FRMArg = MCOperand_getImm( + MCInst_getOperand(MI, (OpNo))); + if (!(MI->csh->syntax & CS_OPT_SYNTAX_NO_ALIAS_TEXT) && FRMArg == RISCVFPRndMode_DYN) + return; + SStream_concat(O, "%s", ", "); + SStream_concat0(O, RISCVFPRndMode_roundingModeToString(FRMArg)); +} + + void printFRMArgLegacy(MCInst *MI, unsigned OpNo, SStream *O) +{ + RISCV_add_cs_detail_0(MI, RISCV_OP_GROUP_FRMArgLegacy, OpNo); + unsigned FRMArg = MCOperand_getImm( + MCInst_getOperand(MI, (OpNo))); + // Never print rounding mode if it's the default 'rne'. This ensures the + // output can still be parsed by older tools that erroneously failed to + // accept a rounding mode. + if (FRMArg == RISCVFPRndMode_RNE) + return; + SStream_concat(O, "%s", ", "); + SStream_concat0(O, RISCVFPRndMode_roundingModeToString(FRMArg)); +} + + void printFPImmOperand(MCInst *MI, unsigned OpNo, SStream *O) +{ + RISCV_add_cs_detail_0(MI, RISCV_OP_GROUP_FPImmOperand, OpNo); + unsigned Imm = MCOperand_getImm(MCInst_getOperand(MI, (OpNo))); + if (Imm == 1) { + SStream_concat0(markup_OS(O, Markup_Immediate), "min"); + } else if (Imm == 30) { + SStream_concat0(markup_OS(O, Markup_Immediate), "inf"); + } else if (Imm == 31) { + SStream_concat0(markup_OS(O, Markup_Immediate), "nan"); + } else { + float FPVal = getFPImm(Imm); + // If the value is an integer, print a .0 fraction. Otherwise, use %g to + // which will not print trailing zeros and will use scientific notation + // if it is shorter than printing as a decimal. The smallest value requires + // 12 digits of precision including the decimal. + if (FPVal == (int)(FPVal)) + printfFloat(markup_OS(O, Markup_Immediate), "%.1f", FPVal); + else + printfFloat(markup_OS(O, Markup_Immediate), "%.12g", FPVal); + } +} + + void printZeroOffsetMemOp(MCInst *MI, unsigned OpNo, SStream *O) +{ + RISCV_add_cs_detail_0(MI, RISCV_OP_GROUP_ZeroOffsetMemOp, OpNo); + MCOperand *MO = MCInst_getOperand(MI, (OpNo)); + + CS_ASSERT(MCOperand_isReg(MO) && + "printZeroOffsetMemOp can only print register operands"); + SStream_concat0(O, "("); + printRegName(O, MCOperand_getReg(MO)); + SStream_concat0(O, ")"); +} + + void printVTypeI(MCInst *MI, unsigned OpNo, SStream *O) +{ + RISCV_add_cs_detail_0(MI, RISCV_OP_GROUP_VTypeI, OpNo); + unsigned Imm = MCOperand_getImm(MCInst_getOperand(MI, (OpNo))); + // Print the raw immediate for reserved values: vlmul[2:0]=4, vsew[2:0]=0b1xx, + // or non-zero in bits 8 and above. + if (RISCVVType_getVLMUL(Imm) == RISCVII_LMUL_RESERVED || + RISCVVType_getSEW(Imm) > 64 || (Imm >> 8) != 0) { + printUInt64(O, Imm); + return; + } + // Print the text form. + printVType(Imm, O); +} + + void printRlist(MCInst *MI, unsigned OpNo, SStream *O) +{ + RISCV_add_cs_detail_0(MI, RISCV_OP_GROUP_Rlist, OpNo); + unsigned Imm = MCOperand_getImm(MCInst_getOperand(MI, (OpNo))); + SStream_concat0(O, "{"); + switch (Imm) { + case RISCVZC_RLISTENCODE_RA: + SStream_concat0(markup_OS(O, Markup_Register), + (ArchRegNames ? "x1" : "ra")); + break; + case RISCVZC_RLISTENCODE_RA_S0: + SStream_concat0(markup_OS(O, Markup_Register), + (ArchRegNames ? "x1" : "ra")); + SStream_concat0(O, ", "); + SStream_concat0(markup_OS(O, Markup_Register), + (ArchRegNames ? "x8" : "s0")); + break; + case RISCVZC_RLISTENCODE_RA_S0_S1: + SStream_concat0(markup_OS(O, Markup_Register), + (ArchRegNames ? "x1" : "ra")); + SStream_concat0(O, ", "); + SStream_concat0(markup_OS(O, Markup_Register), + (ArchRegNames ? "x8" : "s0")); + SStream_concat0(O, "-"); + + SStream_concat0(markup_OS(O, Markup_Register), + (ArchRegNames ? "x9" : "s1")); + break; + case RISCVZC_RLISTENCODE_RA_S0_S2: + SStream_concat0(markup_OS(O, Markup_Register), + (ArchRegNames ? "x1" : "ra")); + SStream_concat0(O, ", "); + SStream_concat0(markup_OS(O, Markup_Register), + (ArchRegNames ? "x8" : "s0")); + SStream_concat0(O, "-"); + + SStream_concat0(markup_OS(O, Markup_Register), + (ArchRegNames ? "x9" : "s2")); + if (ArchRegNames) { + SStream_concat0(O, ", "); + SStream_concat0(markup_OS(O, Markup_Register), "x18"); + } + break; + case RISCVZC_RLISTENCODE_RA_S0_S3: + case RISCVZC_RLISTENCODE_RA_S0_S4: + case RISCVZC_RLISTENCODE_RA_S0_S5: + case RISCVZC_RLISTENCODE_RA_S0_S6: + case RISCVZC_RLISTENCODE_RA_S0_S7: + case RISCVZC_RLISTENCODE_RA_S0_S8: + case RISCVZC_RLISTENCODE_RA_S0_S9: + case RISCVZC_RLISTENCODE_RA_S0_S11: + SStream_concat0(markup_OS(O, Markup_Register), + (ArchRegNames ? "x1" : "ra")); + SStream_concat0(O, ", "); + SStream_concat0(markup_OS(O, Markup_Register), + (ArchRegNames ? "x8" : "s0")); + SStream_concat0(O, "-"); + + if (ArchRegNames) { + SStream_concat0(markup_OS(O, Markup_Register), "x9"); + SStream_concat0(O, ", "); + SStream_concat0(markup_OS(O, Markup_Register), "x18"); + SStream_concat0(O, "-"); + } + SStream_concat0( + markup_OS(O, Markup_Register), + doGetRegisterName( + RISCV_X19 + + (Imm == RISCVZC_RLISTENCODE_RA_S0_S11 ? + 8 : + Imm - RISCVZC_RLISTENCODE_RA_S0_S3))); + break; + default: + CS_ASSERT(0 && "invalid register list"); + } + SStream_concat0(O, "}"); +} + + void printRegReg(MCInst *MI, unsigned OpNo, SStream *O) +{ + RISCV_add_cs_detail_0(MI, RISCV_OP_GROUP_RegReg, OpNo); + MCOperand *MO = MCInst_getOperand(MI, (OpNo)); + + CS_ASSERT(MCOperand_isReg(MO) && + "printRegReg can only print register operands"); + if (MCOperand_getReg(MO) == RISCV_NoRegister) + return; + printRegName(O, MCOperand_getReg(MO)); + + SStream_concat0(O, "("); + MCOperand *MO1 = MCInst_getOperand(MI, (OpNo + 1)); + CS_ASSERT(MCOperand_isReg(MO1) && + "printRegReg can only print register operands"); + printRegName(O, MCOperand_getReg(MO1)); + SStream_concat0(O, ")"); +} + + void printSpimm(MCInst *MI, unsigned OpNo, SStream *O) +{ + RISCV_add_cs_detail_0(MI, RISCV_OP_GROUP_Spimm, OpNo); + int64_t Imm = MCOperand_getImm(MCInst_getOperand(MI, (OpNo))); + unsigned Opcode = MCInst_getOpcode(MI); + bool IsRV64 = RISCV_getFeatureBits(MI->csh->mode, RISCV_Feature64Bit); + bool IsEABI = RISCV_getFeatureBits(MI->csh->mode, RISCV_FeatureRVE); + int64_t Spimm = 0; + int64_t RlistVal = MCOperand_getImm(MCInst_getOperand(MI, (0))); + CS_ASSERT(RlistVal != 16 && "Incorrect rlist."); + unsigned Base = RISCVZC_getStackAdjBase(RlistVal, IsRV64, IsEABI); + Spimm = Imm + Base; + CS_ASSERT((Spimm >= Base && Spimm <= Base + 48) && "Incorrect spimm"); + if (Opcode == RISCV_CM_PUSH) + Spimm = -Spimm; + + RISCVZC_printSpimm(Spimm, markup_OS(O, Markup_Immediate)); } -static void printFRMArg(MCInst *MI, unsigned OpNo, SStream *O) + void printVMaskReg(MCInst *MI, unsigned OpNo, SStream *O) { - enum RoundingMode FRMArg = (enum RoundingMode)MCOperand_getImm( - MCInst_getOperand(MI, OpNo)); -#if 0 - auto FRMArg = - static_cast(MI->getOperand(OpNo).getImm()); - O << RISCVFPRndMode::roundingModeToString(FRMArg); -#endif - SStream_concat0(O, roundingModeToString(FRMArg)); + RISCV_add_cs_detail_0(MI, RISCV_OP_GROUP_VMaskReg, OpNo); + MCOperand *MO = MCInst_getOperand(MI, (OpNo)); + + CS_ASSERT(MCOperand_isReg(MO) && + "printVMaskReg can only print register operands"); + if (MCOperand_getReg(MO) == RISCV_NoRegister) + return; + SStream_concat0(O, ", "); + printRegName(O, MCOperand_getReg(MO)); + SStream_concat0(O, ".t"); } -#endif // CAPSTONE_HAS_RISCV +void RISCV_LLVM_printInstruction(MCInst *MI, SStream *O, void * /* MCRegisterInfo* */ info) { + MI->MRI = (MCRegisterInfo*) info; + + if (MI->csh->syntax & CS_OPT_SYNTAX_NO_ALIAS_TEXT) { + printInstruction(MI, MI->address, O); + } else { + MCInst Uncompressed; + MCInst_Init(&Uncompressed, MI->csh->arch); + + MCInst *McInstr = MI; + if (uncompressInst(&Uncompressed, MI)) { + McInstr = &Uncompressed; + Uncompressed.MRI = MI->MRI; + Uncompressed.csh = MI->csh; + Uncompressed.flat_insn = MI->flat_insn; + } + + if (printAliasInstr(McInstr, MI->address, O)) + MI->isAliasInstr = true; + else + printInstruction(McInstr, MI->address, O); + } + printf("\n\n ADDING MISSING ACCESS \n\n"); + RISCV_add_groups(MI); + RISCV_add_missing_write_access(MI); + RISCV_compact_operands(MI); +} + +const char *getSysRegName(unsigned reg) { + const RISCV_SysReg *SysReg = RISCV_lookupSysRegByEncoding(reg); + return SysReg->Name; +} + +const char *RISCV_LLVM_getRegisterName(unsigned RegNo, unsigned AltIdx) { + return getRegisterName(RegNo, AltIdx); +} + +bool isCompressed(MCInst *MI) { + MCInst unused; + MCInst_Init(&unused, MI->csh->arch); + return uncompressInst(&unused, MI); +} diff --git a/arch/RISCV/RISCVInstPrinter.h b/arch/RISCV/RISCVInstPrinter.h index ef4afd9a43..b5090c2c5f 100644 --- a/arch/RISCV/RISCVInstPrinter.h +++ b/arch/RISCV/RISCVInstPrinter.h @@ -1,24 +1,69 @@ -//===-- RISCVInstPrinter.h - Convert RISCV MCInst to asm syntax ---*- C++ -*--// -// -// The LLVM Compiler Infrastructure +/* Capstone Disassembly Engine, http://www.capstone-engine.org */ +/* By Nguyen Anh Quynh , 2013-2022, */ +/* Rot127 2022-2023 */ +/* Automatically translated source file from LLVM. */ + +/* LLVM-commit: */ +/* LLVM-tag: */ + +/* Only small edits allowed. */ +/* For multiple similar edits, please create a Patch for the translator. */ + +/* Capstone's C++ file translator: */ +/* https://github.com/capstone-engine/capstone/tree/next/suite/auto-sync */ + +//===-- RISCVInstPrinter.h - Convert RISC-V MCInst to asm syntax --*- C++ -*--// // -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // -// This class prints a RISCV MCInst to a .s file. +// This class prints a RISC-V MCInst to a .s file. // //===----------------------------------------------------------------------===// -#ifndef CS_RISCVINSTPRINTER_H -#define CS_RISCVINSTPRINTER_H +#ifndef LLVM_LIB_TARGET_RISCV_MCTARGETDESC_RISCVINSTPRINTER_H +#define LLVM_LIB_TARGET_RISCV_MCTARGETDESC_RISCVINSTPRINTER_H -#include "../../MCInst.h" +#include +#include +#include +#include + +#include "../../MCInstPrinter.h" +#include "../../cs_priv.h" #include "../../SStream.h" +#include "RISCVBaseInfo.h" +#include "RISCVDisassemblerExtension.h" + +#define CONCAT(a, b) CONCAT_(a, b) +#define CONCAT_(a, b) a##_##b + +void printBranchOperand(MCInst *MI, uint64_t Address, unsigned OpNo, + SStream *O); +void printCSRSystemRegister(MCInst *MI, unsigned OpNo, SStream *O); +void printFenceArg(MCInst *MI, unsigned OpNo, SStream *O); +void printFRMArg(MCInst *MI, unsigned OpNo, SStream *O); +void printFRMArgLegacy(MCInst *MI, unsigned OpNo, SStream *O); +void printFPImmOperand(MCInst *MI, unsigned OpNo, SStream *O); +void printZeroOffsetMemOp(MCInst *MI, unsigned OpNo, SStream *O); +void printVTypeI(MCInst *MI, unsigned OpNo, SStream *O); +void printVMaskReg(MCInst *MI, unsigned OpNo, SStream *O); +void printRlist(MCInst *MI, unsigned OpNo, SStream *O); +void printSpimm(MCInst *MI, unsigned OpNo, SStream *O); +void printRegReg(MCInst *MI, unsigned OpNo, SStream *O); + +const char *RISCV_LLVM_getRegisterName(unsigned RegNo, unsigned AltIdx); + +const char *getSysRegName(unsigned reg); -void RISCV_printInst(MCInst *MI, SStream *O, void *info); +bool isCompressed(MCInst *MI); -void RISCV_post_printer(csh ud, cs_insn *insn, char *insn_asm, MCInst *mci); +typedef enum { + #define GET_ENUM_VALUES_SysReg + #include "RISCVGenCSSystemOperandsEnum.inc" +} SysRegValue; #endif diff --git a/arch/RISCV/RISCVLinkage.h b/arch/RISCV/RISCVLinkage.h new file mode 100644 index 0000000000..79cf1c47dc --- /dev/null +++ b/arch/RISCV/RISCVLinkage.h @@ -0,0 +1,16 @@ +#ifndef CS_MIPS_LINKAGE_H +#define CS_MIPS_LINKAGE_H + +#include "../../MCDisassembler.h" +#include "../../MCInst.h" +#include "../../MCRegisterInfo.h" +#include "../../SStream.h" +#include "capstone/capstone.h" + +bool RISCV_LLVM_getInstruction(csh handle, const uint8_t *Bytes, + size_t ByteLen, MCInst *MI, uint16_t *Size, + uint64_t Address, void *Info); +const char *RISCV_LLVM_getRegisterName(unsigned RegNo, unsigned AltIdx); +void RISCV_LLVM_printInstruction(MCInst *MI, SStream *O, void * /* MCRegisterInfo* */ info); + +#endif // CS_MIPS_LINKAGE_H \ No newline at end of file diff --git a/arch/RISCV/RISCVMapping.c b/arch/RISCV/RISCVMapping.c index ed9f27cf01..3d72625f0e 100644 --- a/arch/RISCV/RISCVMapping.c +++ b/arch/RISCV/RISCVMapping.c @@ -1,227 +1,278 @@ +#include "capstone/riscv.h" +#include #ifdef CAPSTONE_HAS_RISCV -#include // debug +#include // debug #include #include "../../Mapping.h" #include "../../utils.h" -#include "../../cs_simple_types.h" #include "RISCVMapping.h" -#include "RISCVInstPrinter.h" + +#include "../../cs_simple_types.h" #define GET_INSTRINFO_ENUM #include "RISCVGenInstrInfo.inc" -#ifndef CAPSTONE_DIET -static const name_map reg_name_maps[] = { - { RISCV_REG_INVALID, NULL }, - - { RISCV_REG_X0, "zero" }, { RISCV_REG_X1, "ra" }, - { RISCV_REG_X2, "sp" }, { RISCV_REG_X3, "gp" }, - { RISCV_REG_X4, "tp" }, { RISCV_REG_X5, "t0" }, - { RISCV_REG_X6, "t1" }, { RISCV_REG_X7, "t2" }, - { RISCV_REG_X8, "s0" }, { RISCV_REG_X9, "s1" }, - { RISCV_REG_X10, "a0" }, { RISCV_REG_X11, "a1" }, - { RISCV_REG_X12, "a2" }, { RISCV_REG_X13, "a3" }, - { RISCV_REG_X14, "a4" }, { RISCV_REG_X15, "a5" }, - { RISCV_REG_X16, "a6" }, { RISCV_REG_X17, "a7" }, - { RISCV_REG_X18, "s2" }, { RISCV_REG_X19, "s3" }, - { RISCV_REG_X20, "s4" }, { RISCV_REG_X21, "s5" }, - { RISCV_REG_X22, "s6" }, { RISCV_REG_X23, "s7" }, - { RISCV_REG_X24, "s8" }, { RISCV_REG_X25, "s9" }, - { RISCV_REG_X26, "s10" }, { RISCV_REG_X27, "s11" }, - { RISCV_REG_X28, "t3" }, { RISCV_REG_X29, "t4" }, - { RISCV_REG_X30, "t5" }, { RISCV_REG_X31, "t6" }, - - { RISCV_REG_F0_32, "ft0" }, { RISCV_REG_F0_64, "ft0" }, - { RISCV_REG_F1_32, "ft1" }, { RISCV_REG_F1_64, "ft1" }, - { RISCV_REG_F2_32, "ft2" }, { RISCV_REG_F2_64, "ft2" }, - { RISCV_REG_F3_32, "ft3" }, { RISCV_REG_F3_64, "ft3" }, - { RISCV_REG_F4_32, "ft4" }, { RISCV_REG_F4_64, "ft4" }, - { RISCV_REG_F5_32, "ft5" }, { RISCV_REG_F5_64, "ft5" }, - { RISCV_REG_F6_32, "ft6" }, { RISCV_REG_F6_64, "ft6" }, - { RISCV_REG_F7_32, "ft7" }, { RISCV_REG_F7_64, "ft7" }, - { RISCV_REG_F8_32, "fs0" }, { RISCV_REG_F8_64, "fs0" }, - { RISCV_REG_F9_32, "fs1" }, { RISCV_REG_F9_64, "fs1" }, - { RISCV_REG_F10_32, "fa0" }, { RISCV_REG_F10_64, "fa0" }, - { RISCV_REG_F11_32, "fa1" }, { RISCV_REG_F11_64, "fa1" }, - { RISCV_REG_F12_32, "fa2" }, { RISCV_REG_F12_64, "fa2" }, - { RISCV_REG_F13_32, "fa3" }, { RISCV_REG_F13_64, "fa3" }, - { RISCV_REG_F14_32, "fa4" }, { RISCV_REG_F14_64, "fa4" }, - { RISCV_REG_F15_32, "fa5" }, { RISCV_REG_F15_64, "fa5" }, - { RISCV_REG_F16_32, "fa6" }, { RISCV_REG_F16_64, "fa6" }, - { RISCV_REG_F17_32, "fa7" }, { RISCV_REG_F17_64, "fa7" }, - { RISCV_REG_F18_32, "fs2" }, { RISCV_REG_F18_64, "fs2" }, - { RISCV_REG_F19_32, "fs3" }, { RISCV_REG_F19_64, "fs3" }, - { RISCV_REG_F20_32, "fs4" }, { RISCV_REG_F20_64, "fs4" }, - { RISCV_REG_F21_32, "fs5" }, { RISCV_REG_F21_64, "fs5" }, - { RISCV_REG_F22_32, "fs6" }, { RISCV_REG_F22_64, "fs6" }, - { RISCV_REG_F23_32, "fs7" }, { RISCV_REG_F23_64, "fs7" }, - { RISCV_REG_F24_32, "fs8" }, { RISCV_REG_F24_64, "fs8" }, - { RISCV_REG_F25_32, "fs9" }, { RISCV_REG_F25_64, "fs9" }, - { RISCV_REG_F26_32, "fs10" }, { RISCV_REG_F26_64, "fs10" }, - { RISCV_REG_F27_32, "fs11" }, { RISCV_REG_F27_64, "fs11" }, - { RISCV_REG_F28_32, "ft8" }, { RISCV_REG_F28_64, "ft8" }, - { RISCV_REG_F29_32, "ft9" }, { RISCV_REG_F29_64, "ft9" }, - { RISCV_REG_F30_32, "ft10" }, { RISCV_REG_F30_64, "ft10" }, - { RISCV_REG_F31_32, "ft11" }, { RISCV_REG_F31_64, "ft11" }, -}; -#endif +#define GET_REGINFO_ENUM +#define GET_REGINFO_MC_DESC +#include "RISCVGenRegisterInfo.inc" + +#include "RISCVInstPrinter.h" const char *RISCV_reg_name(csh handle, unsigned int reg) { -#ifndef CAPSTONE_DIET - if (reg >= RISCV_REG_ENDING) - return NULL; - return reg_name_maps[reg].name; -#else - return NULL; -#endif + int syntax_opt = ((cs_struct *)(uintptr_t)handle)->syntax; + + if (syntax_opt & CS_OPT_SYNTAX_NOREGNAME) { + return RISCV_LLVM_getRegisterName(reg, RISCV_NoRegAltName); + } + return RISCV_LLVM_getRegisterName(reg, RISCV_ABIRegAltName); } static const insn_map insns[] = { - // dummy item - { 0, - 0, -#ifndef CAPSTONE_DIET - { 0 }, - { 0 }, - { 0 }, - 0, - 0 -#endif - }, - -#include "RISCVMappingInsn.inc" +#include "RISCVGenCSMappingInsn.inc" }; #ifndef CAPSTONE_DIET static const map_insn_ops insn_operands[] = { -#include "RISCVMappingInsnOp.inc" +#include "RISCVGenCSMappingInsnOp.inc" }; #endif -void RISCV_add_cs_detail(MCInst *MI, unsigned OpNum) +void RISCV_add_cs_detail_0(MCInst *MI, riscv_op_group opgroup, unsigned OpNum) { if (!detail_is_set(MI)) return; + // are not "true" arguments and has no Capstone equivalent + if (opgroup == RISCV_OP_GROUP_FRMArg || opgroup == RISCV_OP_GROUP_FRMArgLegacy) + return; - cs_op_type op_type = map_get_op_type(MI, OpNum); - - if (op_type == CS_OP_IMM) { - RISCV_get_detail_op(MI, 0)->type = RISCV_OP_IMM; - RISCV_get_detail_op(MI, 0)->imm = MCInst_getOpVal(MI, OpNum); - RISCV_get_detail_op(MI, 0)->access = - map_get_op_access(MI, OpNum); - RISCV_inc_op_count(MI); - } else if (op_type == CS_OP_REG) { - RISCV_get_detail_op(MI, 0)->type = RISCV_OP_REG; - RISCV_get_detail_op(MI, 0)->reg = MCInst_getOpVal(MI, OpNum); - RISCV_get_detail_op(MI, 0)->access = - map_get_op_access(MI, OpNum); - RISCV_inc_op_count(MI); - } else { - CS_ASSERT(0 && "Op type not handled."); + cs_detail *details = MI->flat_insn->detail; + cs_riscv *riscv_details = &(details->riscv); + cs_riscv_op *op = &(riscv_details->operands[OpNum]); + op->type = (riscv_op_type) map_get_op_type(MI, OpNum); + op->access = (cs_ac_type) map_get_op_access(MI, OpNum); + switch (map_get_op_type(MI, OpNum)) { + case CS_OP_REG: + op->reg = MCInst_getOperand(MI, OpNum)->RegVal; + break; + case CS_OP_MEM: + op->mem.base = 0; + op->mem.disp = MCInst_getOperand(MI, OpNum)->ImmVal; + break; + case CS_OP_IMM: { + uint64_t val = MCInst_getOperand(MI, OpNum)->ImmVal; + if (opgroup != RISCV_OP_GROUP_CSRSystemRegister) { + op->imm = val; + } else /* system register read-write */ { + op->type = RISCV_OP_CSR; + op->csr = val; + // CSR instruction always read-writes the system operand + op->access = CS_AC_READ_WRITE; + } + break; + } + case CS_OP_MEM_REG: + op->type = (riscv_op_type) CS_OP_MEM; + op->mem.base = MCInst_getOperand(MI, OpNum)->RegVal; + break; + case CS_OP_MEM_IMM: + // fill in the disp in the last operand + op = &(riscv_details->operands[OpNum - 1]); + op->type = (riscv_op_type) CS_OP_MEM; + op->mem.disp = MCInst_getOperand(MI, OpNum)->ImmVal; + riscv_details->op_count--; // don't increase the count, cancel the coming increment + break; + case CS_OP_INVALID: + break; + default: { + CS_ASSERT(0 && "unhandled operand type"); + } } + riscv_details->op_count++; +} + +static inline void RISCV_add_adhoc_groups(MCInst *MI); + +void RISCV_add_groups(MCInst *MI) { + if (!detail_is_set(MI)) + return; + + MI->flat_insn->detail->groups_count = 0; + int i = 0; + while (insns[MI->Opcode].groups[i] != 0) { + + add_group(MI, insns[MI->Opcode].groups[i]); + i++; + } + RISCV_add_adhoc_groups(MI); +} + +enum { + #define GET_ENUM_VALUES_RISCVOpcode + #include "RISCVGenCSSystemOperandsEnum.inc" +}; + +static inline void RISCV_add_privileged_group(MCInst *MI) { + uint8_t opcode = MI->flat_insn->bytes[0] & 0x80; + // no privileged instruction has a major opcode other than SYSTEM + if (opcode != RISCV_RISCVOPCODE_SYSTEM) { + return; + } + uint8_t func3 = (MI->flat_insn->bytes[1] >> 4) & 0x7; + // no privileged instruction has a minor opcode other than PRIV or PRIVM + if (func3 != 0 && func3 != 0x4) { + return; + } + uint16_t func12 = readBytes16(MI, &(MI->flat_insn->bytes[2])) >> 4; + // ecall and ebreak has SYSTEM and PRIV but aren't privileged + if (func12 == 0 || func12 == 1) { + return; + } + uint8_t func6 = func12 >> 6; + // a subspace under extension-defined custom SYSTEM instructions that is not privileged + if (func6 == 0x23 || func6 == 0x33) { + return; + } + add_group(MI, RISCV_GRP_PRIVILEGE); +} + +static inline void RISCV_add_interrupt_group(MCInst *MI) { + if (MI->Opcode == RISCV_ECALL || MI->Opcode == RISCV_EBREAK) { + add_group(MI, RISCV_GRP_INT); + } +} + +static inline void RISCV_add_interrupt_ret_group(MCInst *MI) { + if (MI->Opcode == RISCV_MRET || MI->Opcode == RISCV_SRET) { + add_group(MI, RISCV_GRP_IRET); + } +} + +static inline void RISCV_add_adhoc_groups(MCInst *MI) { + RISCV_add_privileged_group(MI); + RISCV_add_interrupt_group(MI); + RISCV_add_interrupt_ret_group(MI); +} + +// for weird reasons some instructions end up with valid operands that are +// interspersed with invalid operands, i.e. the operands array is an "island" +// of valid operands with invalid gaps between them, this function will compactify +// all the valid operands and pad the rest of the array to invalid +void RISCV_compact_operands(MCInst *MI) { + if (!detail_is_set(MI)) + return; + cs_riscv_op* ops = MI->flat_insn->detail->riscv.operands; + unsigned int write_pos = 0; + + // Move valid elements to front + for (unsigned int read_pos = 0; read_pos < NUM_RISCV_OPS; read_pos++) { + if (ops[read_pos].type != (riscv_op_type)CS_OP_INVALID) { + if (write_pos != read_pos) { + ops[write_pos] = ops[read_pos]; + } + write_pos++; + } + } + // fill the rest, if any, with invalid + for (unsigned int i = write_pos; i < NUM_RISCV_OPS; i++) { + memset((void *)(&ops[i]), CS_OP_INVALID, sizeof(cs_riscv_op)); + } +} + +// some C instructions have only 2 apparent operands, one of them is read-write +// the operand information for those instruction has 3 operands, the first and second are the same, +// but once with read and once write access +// when those instructions are disassembled only the operand entry with the read access is used, +// and therefore the read-write operand is wrongly classified as only-read +// this logic tries to correct that +void RISCV_add_missing_write_access(MCInst* MI) { + if (!detail_is_set(MI)) + return; + if (!isCompressed(MI)) + return; + + cs_riscv *riscv_details = &(MI->flat_insn->detail->riscv); + cs_riscv_op* ops = riscv_details->operands; + // make the detection condition as specific as possible + // so it doesn't accidentally trigger for other cases + if (riscv_details->op_count == 2 + && ops[0].type == RISCV_OP_INVALID && ops[1].type == RISCV_OP_REG + && ops[1].access == CS_AC_READ) { + ops[1].access |= CS_AC_WRITE; + } } // given internal insn id, return public instruction info -void RISCV_get_insn_id(cs_struct *h, cs_insn *insn, unsigned int id) +void RISCV_get_insn_id(cs_struct * h, cs_insn * insn, unsigned int id) { - unsigned int i; + unsigned int i; - i = insn_find(insns, ARR_SIZE(insns), id, &h->insn_cache); - if (i != 0) { - insn->id = insns[i].mapid; + i = insn_find(insns, ARR_SIZE(insns), id, &h->insn_cache); + if (i != 0) { + insn->id = insns[i].mapid; - if (h->detail_opt) { + if (h->detail_opt) { #ifndef CAPSTONE_DIET - memcpy(insn->detail->regs_read, insns[i].regs_use, - sizeof(insns[i].regs_use)); - insn->detail->regs_read_count = - (uint8_t)count_positive(insns[i].regs_use); - - memcpy(insn->detail->regs_write, insns[i].regs_mod, - sizeof(insns[i].regs_mod)); - insn->detail->regs_write_count = - (uint8_t)count_positive(insns[i].regs_mod); - - memcpy(insn->detail->groups, insns[i].groups, - sizeof(insns[i].groups)); - insn->detail->groups_count = - (uint8_t)count_positive8(insns[i].groups); - - if (insns[i].branch || insns[i].indirect_branch) { - // this insn also belongs to JUMP group. add JUMP group - insn->detail - ->groups[insn->detail->groups_count] = - RISCV_GRP_JUMP; - insn->detail->groups_count++; - } + memcpy(insn->detail->regs_read, + insns[i].regs_use, sizeof(insns[i].regs_use)); + insn->detail->regs_read_count = (uint8_t)count_positive(insns[i].regs_use); + + memcpy(insn->detail->regs_write, insns[i].regs_mod, sizeof(insns[i].regs_mod)); + insn->detail->regs_write_count = (uint8_t)count_positive(insns[i].regs_mod); + + memcpy(insn->detail->groups, insns[i].groups, sizeof(insns[i].groups)); + insn->detail->groups_count = (uint8_t)count_positive8(insns[i].groups); + + if (insns[i].branch || insns[i].indirect_branch) { + // this insn also belongs to JUMP group. add JUMP group + insn->detail->groups[insn->detail->groups_count] = RISCV_GRP_JUMP; + insn->detail->groups_count++; + } #endif - } - } + } + } } -static const name_map insn_name_maps[] = { - { RISCV_INS_INVALID, NULL }, +static const char *const insn_name_maps[] = { + /*RISCV_INS_INVALID:*/ NULL, -#include "RISCVGenInsnNameMaps.inc" +#include "RISCVGenCSMappingInsnName.inc" }; const char *RISCV_insn_name(csh handle, unsigned int id) { #ifndef CAPSTONE_DIET - if (id >= RISCV_INS_ENDING) - return NULL; + if (id >= RISCV_INS_ENDING) + return NULL; - return insn_name_maps[id].name; + return insn_name_maps[id]; #else - return NULL; + return NULL; #endif } #ifndef CAPSTONE_DIET static const name_map group_name_maps[] = { - // generic groups - { RISCV_GRP_INVALID, NULL }, - { RISCV_GRP_JUMP, "jump" }, - { RISCV_GRP_CALL, "call" }, - { RISCV_GRP_RET, "ret" }, - { RISCV_GRP_INT, "int" }, - { RISCV_GRP_IRET, "iret" }, - { RISCV_GRP_PRIVILEGE, "privileged" }, - { RISCV_GRP_BRANCH_RELATIVE, "branch_relative" }, - - // architecture specific - { RISCV_GRP_ISRV32, "isrv32" }, - { RISCV_GRP_ISRV64, "isrv64" }, - { RISCV_GRP_HASSTDEXTA, "hasStdExtA" }, - { RISCV_GRP_HASSTDEXTC, "hasStdExtC" }, - { RISCV_GRP_HASSTDEXTD, "hasStdExtD" }, - { RISCV_GRP_HASSTDEXTF, "hasStdExtF" }, - { RISCV_GRP_HASSTDEXTM, "hasStdExtM" }, - - /* - { RISCV_GRP_ISRVA, "isrva" }, - { RISCV_GRP_ISRVC, "isrvc" }, - { RISCV_GRP_ISRVD, "isrvd" }, - { RISCV_GRP_ISRVCD, "isrvcd" }, - { RISCV_GRP_ISRVF, "isrvf" }, - { RISCV_GRP_ISRV32C, "isrv32c" }, - { RISCV_GRP_ISRV32CF, "isrv32cf" }, - { RISCV_GRP_ISRVM, "isrvm" }, - { RISCV_GRP_ISRV64A, "isrv64a" }, - { RISCV_GRP_ISRV64C, "isrv64c" }, - { RISCV_GRP_ISRV64D, "isrv64d" }, - { RISCV_GRP_ISRV64F, "isrv64f" }, - { RISCV_GRP_ISRV64M, "isrv64m" } - */ - { RISCV_GRP_ENDING, NULL } + // generic groups + { RISCV_GRP_INVALID, NULL }, + { RISCV_GRP_JUMP, "jump" }, + { RISCV_GRP_CALL, "call" }, + { RISCV_GRP_RET, "ret" }, + { RISCV_GRP_INT, "int" }, + { RISCV_GRP_IRET, "iret" }, + { RISCV_GRP_PRIVILEGE, "privileged" }, + { RISCV_GRP_BRANCH_RELATIVE, "branch_relative" }, + + // architecture specific + #include "RISCVGenCSFeatureName.inc" + + { RISCV_GRP_ENDING, NULL } }; #endif @@ -229,8 +280,10 @@ const char *RISCV_group_name(csh handle, unsigned int id) { #ifndef CAPSTONE_DIET // verify group id + // if past the end if (id >= RISCV_GRP_ENDING || - (id > RISCV_GRP_BRANCH_RELATIVE && id < RISCV_GRP_ISRV32)) + // or in the encoding gap between generic groups and arch-specific groups + (id > RISCV_GRP_BRANCH_RELATIVE && id < RISCV_FEATURE_HASSTDEXTI)) return NULL; return id2name(group_name_maps, ARR_SIZE(group_name_maps), id); #else @@ -239,126 +292,24 @@ const char *RISCV_group_name(csh handle, unsigned int id) } // map instruction name to public instruction ID -riscv_reg RISCV_map_insn(const char *name) +riscv_insn RISCV_map_insn(const char *name) { // handle special alias first unsigned int i; - - // NOTE: skip first NULL name in insn_name_maps - i = name2id(&insn_name_maps[1], ARR_SIZE(insn_name_maps) - 1, name); - - return (i != -1) ? i : RISCV_REG_INVALID; + for (i = 1; i < ARR_SIZE(insn_name_maps); i++) { + if (!strcmp(name, insn_name_maps[i])) + return i; + } + return RISCV_INS_INVALID; } -// map internal raw register to 'public' register -riscv_reg RISCV_map_register(unsigned int r) +void RISCV_init(MCRegisterInfo *MRI) { - static const unsigned int map[] = { - 0, - RISCV_REG_X0, - RISCV_REG_X1, - RISCV_REG_X2, - RISCV_REG_X3, - RISCV_REG_X4, - RISCV_REG_X5, - RISCV_REG_X6, - RISCV_REG_X7, - RISCV_REG_X8, - RISCV_REG_X9, - RISCV_REG_X10, - RISCV_REG_X11, - RISCV_REG_X12, - RISCV_REG_X13, - RISCV_REG_X14, - RISCV_REG_X15, - RISCV_REG_X16, - RISCV_REG_X17, - RISCV_REG_X18, - RISCV_REG_X19, - RISCV_REG_X20, - RISCV_REG_X21, - RISCV_REG_X22, - RISCV_REG_X23, - RISCV_REG_X24, - RISCV_REG_X25, - RISCV_REG_X26, - RISCV_REG_X27, - RISCV_REG_X28, - RISCV_REG_X29, - RISCV_REG_X30, - RISCV_REG_X31, - - RISCV_REG_F0_32, - RISCV_REG_F0_64, - RISCV_REG_F1_32, - RISCV_REG_F1_64, - RISCV_REG_F2_32, - RISCV_REG_F2_64, - RISCV_REG_F3_32, - RISCV_REG_F3_64, - RISCV_REG_F4_32, - RISCV_REG_F4_64, - RISCV_REG_F5_32, - RISCV_REG_F5_64, - RISCV_REG_F6_32, - RISCV_REG_F6_64, - RISCV_REG_F7_32, - RISCV_REG_F7_64, - RISCV_REG_F8_32, - RISCV_REG_F8_64, - RISCV_REG_F9_32, - RISCV_REG_F9_64, - RISCV_REG_F10_32, - RISCV_REG_F10_64, - RISCV_REG_F11_32, - RISCV_REG_F11_64, - RISCV_REG_F12_32, - RISCV_REG_F12_64, - RISCV_REG_F13_32, - RISCV_REG_F13_64, - RISCV_REG_F14_32, - RISCV_REG_F14_64, - RISCV_REG_F15_32, - RISCV_REG_F15_64, - RISCV_REG_F16_32, - RISCV_REG_F16_64, - RISCV_REG_F17_32, - RISCV_REG_F17_64, - RISCV_REG_F18_32, - RISCV_REG_F18_64, - RISCV_REG_F19_32, - RISCV_REG_F19_64, - RISCV_REG_F20_32, - RISCV_REG_F20_64, - RISCV_REG_F21_32, - RISCV_REG_F21_64, - RISCV_REG_F22_32, - RISCV_REG_F22_64, - RISCV_REG_F23_32, - RISCV_REG_F23_64, - RISCV_REG_F24_32, - RISCV_REG_F24_64, - RISCV_REG_F25_32, - RISCV_REG_F25_64, - RISCV_REG_F26_32, - RISCV_REG_F26_64, - RISCV_REG_F27_32, - RISCV_REG_F27_64, - RISCV_REG_F28_32, - RISCV_REG_F28_64, - RISCV_REG_F29_32, - RISCV_REG_F29_64, - RISCV_REG_F30_32, - RISCV_REG_F30_64, - RISCV_REG_F31_32, - RISCV_REG_F31_64, - }; - - if (r < ARR_SIZE(map)) - return map[r]; - - // cannot find this register - return 0; + MCRegisterInfo_InitMCRegisterInfo( + MRI, RISCVRegDesc, RISCV_REG_ENDING, 0, 0, + RISCVMCRegisterClasses, ARR_SIZE(RISCVMCRegisterClasses), 0, + 0, RISCVRegDiffLists, 0, RISCVSubRegIdxLists, + ARR_SIZE(RISCVSubRegIdxLists), 0); } #endif diff --git a/arch/RISCV/RISCVMapping.h b/arch/RISCV/RISCVMapping.h index a1809379b0..c439835ab5 100644 --- a/arch/RISCV/RISCVMapping.h +++ b/arch/RISCV/RISCVMapping.h @@ -3,6 +3,11 @@ #define CS_RISCV_MAP_H #include "../../include/capstone/capstone.h" +#include "../../cs_priv.h" + +typedef enum { + #include "RISCVGenCSOpGroup.inc" +} riscv_op_group; // given internal insn id, return public instruction info void RISCV_get_insn_id(cs_struct *h, cs_insn *insn, unsigned int id); @@ -13,12 +18,18 @@ const char *RISCV_group_name(csh handle, unsigned int id); const char *RISCV_reg_name(csh handle, unsigned int reg); -void RISCV_add_cs_detail(MCInst *MI, unsigned OpNum); +void RISCV_add_cs_detail_0(MCInst *MI, riscv_op_group opgroup, unsigned OpNum); + +void RISCV_add_groups(MCInst *MI); + +void RISCV_compact_operands(MCInst *MI); + +void RISCV_add_missing_write_access(MCInst* MI); + // map instruction name to instruction ID -riscv_reg RISCV_map_insn(const char *name); +riscv_insn RISCV_map_insn(const char *name); -// map internal raw register to 'public' register -riscv_reg RISCV_map_register(unsigned int r); +void RISCV_init(MCRegisterInfo *MRI); #endif diff --git a/arch/RISCV/RISCVMappingInsn.inc b/arch/RISCV/RISCVMappingInsn.inc deleted file mode 100644 index b2a9a10957..0000000000 --- a/arch/RISCV/RISCVMappingInsn.inc +++ /dev/null @@ -1,1635 +0,0 @@ -// This is auto-gen data for Capstone engine (www.capstone-engine.org) -// By Nguyen Anh Quynh - -{ - RISCV_ADD, RISCV_INS_ADD, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { 0 }, 0, 0 -#endif -}, -{ - RISCV_ADDI, RISCV_INS_ADDI, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { 0 }, 0, 0 -#endif -}, -{ - RISCV_ADDIW, RISCV_INS_ADDIW, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_ADDW, RISCV_INS_ADDW, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOADD_D, RISCV_INS_AMOADD_D, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOADD_D_AQ, RISCV_INS_AMOADD_D_AQ, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOADD_D_AQ_RL, RISCV_INS_AMOADD_D_AQ_RL, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOADD_D_RL, RISCV_INS_AMOADD_D_RL, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOADD_W, RISCV_INS_AMOADD_W, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOADD_W_AQ, RISCV_INS_AMOADD_W_AQ, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOADD_W_AQ_RL, RISCV_INS_AMOADD_W_AQ_RL, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOADD_W_RL, RISCV_INS_AMOADD_W_RL, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOAND_D, RISCV_INS_AMOAND_D, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOAND_D_AQ, RISCV_INS_AMOAND_D_AQ, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOAND_D_AQ_RL, RISCV_INS_AMOAND_D_AQ_RL, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOAND_D_RL, RISCV_INS_AMOAND_D_RL, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOAND_W, RISCV_INS_AMOAND_W, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOAND_W_AQ, RISCV_INS_AMOAND_W_AQ, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOAND_W_AQ_RL, RISCV_INS_AMOAND_W_AQ_RL, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOAND_W_RL, RISCV_INS_AMOAND_W_RL, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOMAXU_D, RISCV_INS_AMOMAXU_D, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOMAXU_D_AQ, RISCV_INS_AMOMAXU_D_AQ, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOMAXU_D_AQ_RL, RISCV_INS_AMOMAXU_D_AQ_RL, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOMAXU_D_RL, RISCV_INS_AMOMAXU_D_RL, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOMAXU_W, RISCV_INS_AMOMAXU_W, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOMAXU_W_AQ, RISCV_INS_AMOMAXU_W_AQ, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOMAXU_W_AQ_RL, RISCV_INS_AMOMAXU_W_AQ_RL, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOMAXU_W_RL, RISCV_INS_AMOMAXU_W_RL, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOMAX_D, RISCV_INS_AMOMAX_D, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOMAX_D_AQ, RISCV_INS_AMOMAX_D_AQ, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOMAX_D_AQ_RL, RISCV_INS_AMOMAX_D_AQ_RL, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOMAX_D_RL, RISCV_INS_AMOMAX_D_RL, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOMAX_W, RISCV_INS_AMOMAX_W, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOMAX_W_AQ, RISCV_INS_AMOMAX_W_AQ, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOMAX_W_AQ_RL, RISCV_INS_AMOMAX_W_AQ_RL, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOMAX_W_RL, RISCV_INS_AMOMAX_W_RL, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOMINU_D, RISCV_INS_AMOMINU_D, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOMINU_D_AQ, RISCV_INS_AMOMINU_D_AQ, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOMINU_D_AQ_RL, RISCV_INS_AMOMINU_D_AQ_RL, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOMINU_D_RL, RISCV_INS_AMOMINU_D_RL, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOMINU_W, RISCV_INS_AMOMINU_W, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOMINU_W_AQ, RISCV_INS_AMOMINU_W_AQ, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOMINU_W_AQ_RL, RISCV_INS_AMOMINU_W_AQ_RL, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOMINU_W_RL, RISCV_INS_AMOMINU_W_RL, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOMIN_D, RISCV_INS_AMOMIN_D, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOMIN_D_AQ, RISCV_INS_AMOMIN_D_AQ, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOMIN_D_AQ_RL, RISCV_INS_AMOMIN_D_AQ_RL, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOMIN_D_RL, RISCV_INS_AMOMIN_D_RL, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOMIN_W, RISCV_INS_AMOMIN_W, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOMIN_W_AQ, RISCV_INS_AMOMIN_W_AQ, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOMIN_W_AQ_RL, RISCV_INS_AMOMIN_W_AQ_RL, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOMIN_W_RL, RISCV_INS_AMOMIN_W_RL, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOOR_D, RISCV_INS_AMOOR_D, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOOR_D_AQ, RISCV_INS_AMOOR_D_AQ, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOOR_D_AQ_RL, RISCV_INS_AMOOR_D_AQ_RL, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOOR_D_RL, RISCV_INS_AMOOR_D_RL, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOOR_W, RISCV_INS_AMOOR_W, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOOR_W_AQ, RISCV_INS_AMOOR_W_AQ, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOOR_W_AQ_RL, RISCV_INS_AMOOR_W_AQ_RL, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOOR_W_RL, RISCV_INS_AMOOR_W_RL, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOSWAP_D, RISCV_INS_AMOSWAP_D, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOSWAP_D_AQ, RISCV_INS_AMOSWAP_D_AQ, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOSWAP_D_AQ_RL, RISCV_INS_AMOSWAP_D_AQ_RL, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOSWAP_D_RL, RISCV_INS_AMOSWAP_D_RL, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOSWAP_W, RISCV_INS_AMOSWAP_W, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOSWAP_W_AQ, RISCV_INS_AMOSWAP_W_AQ, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOSWAP_W_AQ_RL, RISCV_INS_AMOSWAP_W_AQ_RL, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOSWAP_W_RL, RISCV_INS_AMOSWAP_W_RL, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOXOR_D, RISCV_INS_AMOXOR_D, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOXOR_D_AQ, RISCV_INS_AMOXOR_D_AQ, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOXOR_D_AQ_RL, RISCV_INS_AMOXOR_D_AQ_RL, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOXOR_D_RL, RISCV_INS_AMOXOR_D_RL, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOXOR_W, RISCV_INS_AMOXOR_W, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOXOR_W_AQ, RISCV_INS_AMOXOR_W_AQ, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOXOR_W_AQ_RL, RISCV_INS_AMOXOR_W_AQ_RL, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, 0 }, 0, 0 -#endif -}, -{ - RISCV_AMOXOR_W_RL, RISCV_INS_AMOXOR_W_RL, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, 0 }, 0, 0 -#endif -}, -{ - RISCV_AND, RISCV_INS_AND, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { 0 }, 0, 0 -#endif -}, -{ - RISCV_ANDI, RISCV_INS_ANDI, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { 0 }, 0, 0 -#endif -}, -{ - RISCV_AUIPC, RISCV_INS_AUIPC, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { 0 }, 0, 0 -#endif -}, -{ - RISCV_BEQ, RISCV_INS_BEQ, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_BRANCH_RELATIVE, 0 }, 1, 0 -#endif -}, -{ - RISCV_BGE, RISCV_INS_BGE, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_BRANCH_RELATIVE, 0 }, 1, 0 -#endif -}, -{ - RISCV_BGEU, RISCV_INS_BGEU, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_BRANCH_RELATIVE, 0 }, 1, 0 -#endif -}, -{ - RISCV_BLT, RISCV_INS_BLT, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_BRANCH_RELATIVE, 0 }, 1, 0 -#endif -}, -{ - RISCV_BLTU, RISCV_INS_BLTU, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_BRANCH_RELATIVE, 0 }, 1, 0 -#endif -}, -{ - RISCV_BNE, RISCV_INS_BNE, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_BRANCH_RELATIVE, 0 }, 1, 0 -#endif -}, -{ - RISCV_CSRRC, RISCV_INS_CSRRC, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { 0 }, 0, 0 -#endif -}, -{ - RISCV_CSRRCI, RISCV_INS_CSRRCI, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { 0 }, 0, 0 -#endif -}, -{ - RISCV_CSRRS, RISCV_INS_CSRRS, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { 0 }, 0, 0 -#endif -}, -{ - RISCV_CSRRSI, RISCV_INS_CSRRSI, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { 0 }, 0, 0 -#endif -}, -{ - RISCV_CSRRW, RISCV_INS_CSRRW, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { 0 }, 0, 0 -#endif -}, -{ - RISCV_CSRRWI, RISCV_INS_CSRRWI, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { 0 }, 0, 0 -#endif -}, -{ - RISCV_C_ADD, RISCV_INS_C_ADD, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTC, 0 }, 0, 0 -#endif -}, -{ - RISCV_C_ADDI, RISCV_INS_C_ADDI, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTC, 0 }, 0, 0 -#endif -}, -{ - RISCV_C_ADDI16SP, RISCV_INS_C_ADDI16SP, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTC, 0 }, 0, 0 -#endif -}, -{ - RISCV_C_ADDI4SPN, RISCV_INS_C_ADDI4SPN, -#ifndef CAPSTONE_DIET - { RISCV_REG_X2, 0 }, { 0 }, { RISCV_GRP_HASSTDEXTC, 0 }, 0, 0 -#endif -}, -{ - RISCV_C_ADDIW, RISCV_INS_C_ADDIW, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTC, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_C_ADDW, RISCV_INS_C_ADDW, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTC, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_C_AND, RISCV_INS_C_AND, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTC, 0 }, 0, 0 -#endif -}, -{ - RISCV_C_ANDI, RISCV_INS_C_ANDI, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTC, 0 }, 0, 0 -#endif -}, -{ - RISCV_C_BEQZ, RISCV_INS_C_BEQZ, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTC, RISCV_GRP_BRANCH_RELATIVE, 0 }, 1, 0 -#endif -}, -{ - RISCV_C_BNEZ, RISCV_INS_C_BNEZ, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTC, RISCV_GRP_BRANCH_RELATIVE, 0 }, 1, 0 -#endif -}, -{ - RISCV_C_EBREAK, RISCV_INS_C_EBREAK, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTC, 0 }, 0, 0 -#endif -}, -{ - RISCV_C_FLD, RISCV_INS_C_FLD, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTC, RISCV_GRP_HASSTDEXTD, 0 }, 0, 0 -#endif -}, -{ - RISCV_C_FLDSP, RISCV_INS_C_FLDSP, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTC, RISCV_GRP_HASSTDEXTD, 0 }, 0, 0 -#endif -}, -{ - RISCV_C_FLW, RISCV_INS_C_FLW, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTC, RISCV_GRP_HASSTDEXTF, RISCV_GRP_ISRV32, 0 }, 0, 0 -#endif -}, -{ - RISCV_C_FLWSP, RISCV_INS_C_FLWSP, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTC, RISCV_GRP_HASSTDEXTF, RISCV_GRP_ISRV32, 0 }, 0, 0 -#endif -}, -{ - RISCV_C_FSD, RISCV_INS_C_FSD, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTC, RISCV_GRP_HASSTDEXTD, 0 }, 0, 0 -#endif -}, -{ - RISCV_C_FSDSP, RISCV_INS_C_FSDSP, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTC, RISCV_GRP_HASSTDEXTD, 0 }, 0, 0 -#endif -}, -{ - RISCV_C_FSW, RISCV_INS_C_FSW, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTC, RISCV_GRP_HASSTDEXTF, RISCV_GRP_ISRV32, 0 }, 0, 0 -#endif -}, -{ - RISCV_C_FSWSP, RISCV_INS_C_FSWSP, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTC, RISCV_GRP_HASSTDEXTF, RISCV_GRP_ISRV32, 0 }, 0, 0 -#endif -}, -{ - RISCV_C_J, RISCV_INS_C_J, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTC, 0 }, 1, 0 -#endif -}, -{ - RISCV_C_JAL, RISCV_INS_C_JAL, -#ifndef CAPSTONE_DIET - { 0 }, { RISCV_REG_X1, 0 }, { RISCV_GRP_HASSTDEXTC, RISCV_GRP_ISRV32, RISCV_GRP_CALL, 0 }, 0, 0 -#endif -}, -{ - RISCV_C_JALR, RISCV_INS_C_JALR, -#ifndef CAPSTONE_DIET - { 0 }, { RISCV_REG_X1, 0 }, { RISCV_GRP_HASSTDEXTC, RISCV_GRP_CALL, 0 }, 0, 0 -#endif -}, -{ - RISCV_C_JR, RISCV_INS_C_JR, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTC, 0 }, 1, 1 -#endif -}, -{ - RISCV_C_LD, RISCV_INS_C_LD, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTC, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_C_LDSP, RISCV_INS_C_LDSP, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTC, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_C_LI, RISCV_INS_C_LI, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTC, 0 }, 0, 0 -#endif -}, -{ - RISCV_C_LUI, RISCV_INS_C_LUI, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTC, 0 }, 0, 0 -#endif -}, -{ - RISCV_C_LW, RISCV_INS_C_LW, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTC, 0 }, 0, 0 -#endif -}, -{ - RISCV_C_LWSP, RISCV_INS_C_LWSP, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTC, 0 }, 0, 0 -#endif -}, -{ - RISCV_C_MV, RISCV_INS_C_MV, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTC, 0 }, 0, 0 -#endif -}, -{ - RISCV_C_NOP, RISCV_INS_C_NOP, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTC, 0 }, 0, 0 -#endif -}, -{ - RISCV_C_OR, RISCV_INS_C_OR, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTC, 0 }, 0, 0 -#endif -}, -{ - RISCV_C_SD, RISCV_INS_C_SD, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTC, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_C_SDSP, RISCV_INS_C_SDSP, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTC, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_C_SLLI, RISCV_INS_C_SLLI, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTC, 0 }, 0, 0 -#endif -}, -{ - RISCV_C_SRAI, RISCV_INS_C_SRAI, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTC, 0 }, 0, 0 -#endif -}, -{ - RISCV_C_SRLI, RISCV_INS_C_SRLI, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTC, 0 }, 0, 0 -#endif -}, -{ - RISCV_C_SUB, RISCV_INS_C_SUB, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTC, 0 }, 0, 0 -#endif -}, -{ - RISCV_C_SUBW, RISCV_INS_C_SUBW, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTC, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_C_SW, RISCV_INS_C_SW, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTC, 0 }, 0, 0 -#endif -}, -{ - RISCV_C_SWSP, RISCV_INS_C_SWSP, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTC, 0 }, 0, 0 -#endif -}, -{ - RISCV_C_UNIMP, RISCV_INS_C_UNIMP, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTC, 0 }, 0, 0 -#endif -}, -{ - RISCV_C_XOR, RISCV_INS_C_XOR, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTC, 0 }, 0, 0 -#endif -}, -{ - RISCV_DIV, RISCV_INS_DIV, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTM, 0 }, 0, 0 -#endif -}, -{ - RISCV_DIVU, RISCV_INS_DIVU, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTM, 0 }, 0, 0 -#endif -}, -{ - RISCV_DIVUW, RISCV_INS_DIVUW, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTM, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_DIVW, RISCV_INS_DIVW, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTM, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_EBREAK, RISCV_INS_EBREAK, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { 0 }, 0, 0 -#endif -}, -{ - RISCV_ECALL, RISCV_INS_ECALL, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_INT, 0 }, 0, 0 -#endif -}, -{ - RISCV_FADD_D, RISCV_INS_FADD_D, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTD, 0 }, 0, 0 -#endif -}, -{ - RISCV_FADD_S, RISCV_INS_FADD_S, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTF, 0 }, 0, 0 -#endif -}, -{ - RISCV_FCLASS_D, RISCV_INS_FCLASS_D, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTD, 0 }, 0, 0 -#endif -}, -{ - RISCV_FCLASS_S, RISCV_INS_FCLASS_S, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTF, 0 }, 0, 0 -#endif -}, -{ - RISCV_FCVT_D_L, RISCV_INS_FCVT_D_L, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTD, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_FCVT_D_LU, RISCV_INS_FCVT_D_LU, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTD, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_FCVT_D_S, RISCV_INS_FCVT_D_S, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTD, 0 }, 0, 0 -#endif -}, -{ - RISCV_FCVT_D_W, RISCV_INS_FCVT_D_W, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTD, 0 }, 0, 0 -#endif -}, -{ - RISCV_FCVT_D_WU, RISCV_INS_FCVT_D_WU, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTD, 0 }, 0, 0 -#endif -}, -{ - RISCV_FCVT_LU_D, RISCV_INS_FCVT_LU_D, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTD, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_FCVT_LU_S, RISCV_INS_FCVT_LU_S, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTF, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_FCVT_L_D, RISCV_INS_FCVT_L_D, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTD, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_FCVT_L_S, RISCV_INS_FCVT_L_S, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTF, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_FCVT_S_D, RISCV_INS_FCVT_S_D, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTD, 0 }, 0, 0 -#endif -}, -{ - RISCV_FCVT_S_L, RISCV_INS_FCVT_S_L, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTF, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_FCVT_S_LU, RISCV_INS_FCVT_S_LU, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTF, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_FCVT_S_W, RISCV_INS_FCVT_S_W, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTF, 0 }, 0, 0 -#endif -}, -{ - RISCV_FCVT_S_WU, RISCV_INS_FCVT_S_WU, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTF, 0 }, 0, 0 -#endif -}, -{ - RISCV_FCVT_WU_D, RISCV_INS_FCVT_WU_D, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTD, 0 }, 0, 0 -#endif -}, -{ - RISCV_FCVT_WU_S, RISCV_INS_FCVT_WU_S, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTF, 0 }, 0, 0 -#endif -}, -{ - RISCV_FCVT_W_D, RISCV_INS_FCVT_W_D, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTD, 0 }, 0, 0 -#endif -}, -{ - RISCV_FCVT_W_S, RISCV_INS_FCVT_W_S, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTF, 0 }, 0, 0 -#endif -}, -{ - RISCV_FDIV_D, RISCV_INS_FDIV_D, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTD, 0 }, 0, 0 -#endif -}, -{ - RISCV_FDIV_S, RISCV_INS_FDIV_S, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTF, 0 }, 0, 0 -#endif -}, -{ - RISCV_FENCE, RISCV_INS_FENCE, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { 0 }, 0, 0 -#endif -}, -{ - RISCV_FENCE_I, RISCV_INS_FENCE_I, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { 0 }, 0, 0 -#endif -}, -{ - RISCV_FENCE_TSO, RISCV_INS_FENCE_TSO, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { 0 }, 0, 0 -#endif -}, -{ - RISCV_FEQ_D, RISCV_INS_FEQ_D, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTD, 0 }, 0, 0 -#endif -}, -{ - RISCV_FEQ_S, RISCV_INS_FEQ_S, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTF, 0 }, 0, 0 -#endif -}, -{ - RISCV_FLD, RISCV_INS_FLD, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTD, 0 }, 0, 0 -#endif -}, -{ - RISCV_FLE_D, RISCV_INS_FLE_D, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTD, 0 }, 0, 0 -#endif -}, -{ - RISCV_FLE_S, RISCV_INS_FLE_S, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTF, 0 }, 0, 0 -#endif -}, -{ - RISCV_FLT_D, RISCV_INS_FLT_D, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTD, 0 }, 0, 0 -#endif -}, -{ - RISCV_FLT_S, RISCV_INS_FLT_S, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTF, 0 }, 0, 0 -#endif -}, -{ - RISCV_FLW, RISCV_INS_FLW, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTF, 0 }, 0, 0 -#endif -}, -{ - RISCV_FMADD_D, RISCV_INS_FMADD_D, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTD, 0 }, 0, 0 -#endif -}, -{ - RISCV_FMADD_S, RISCV_INS_FMADD_S, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTF, 0 }, 0, 0 -#endif -}, -{ - RISCV_FMAX_D, RISCV_INS_FMAX_D, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTD, 0 }, 0, 0 -#endif -}, -{ - RISCV_FMAX_S, RISCV_INS_FMAX_S, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTF, 0 }, 0, 0 -#endif -}, -{ - RISCV_FMIN_D, RISCV_INS_FMIN_D, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTD, 0 }, 0, 0 -#endif -}, -{ - RISCV_FMIN_S, RISCV_INS_FMIN_S, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTF, 0 }, 0, 0 -#endif -}, -{ - RISCV_FMSUB_D, RISCV_INS_FMSUB_D, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTD, 0 }, 0, 0 -#endif -}, -{ - RISCV_FMSUB_S, RISCV_INS_FMSUB_S, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTF, 0 }, 0, 0 -#endif -}, -{ - RISCV_FMUL_D, RISCV_INS_FMUL_D, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTD, 0 }, 0, 0 -#endif -}, -{ - RISCV_FMUL_S, RISCV_INS_FMUL_S, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTF, 0 }, 0, 0 -#endif -}, -{ - RISCV_FMV_D_X, RISCV_INS_FMV_D_X, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTD, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_FMV_W_X, RISCV_INS_FMV_W_X, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTF, 0 }, 0, 0 -#endif -}, -{ - RISCV_FMV_X_D, RISCV_INS_FMV_X_D, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTD, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_FMV_X_W, RISCV_INS_FMV_X_W, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTF, 0 }, 0, 0 -#endif -}, -{ - RISCV_FNMADD_D, RISCV_INS_FNMADD_D, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTD, 0 }, 0, 0 -#endif -}, -{ - RISCV_FNMADD_S, RISCV_INS_FNMADD_S, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTF, 0 }, 0, 0 -#endif -}, -{ - RISCV_FNMSUB_D, RISCV_INS_FNMSUB_D, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTD, 0 }, 0, 0 -#endif -}, -{ - RISCV_FNMSUB_S, RISCV_INS_FNMSUB_S, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTF, 0 }, 0, 0 -#endif -}, -{ - RISCV_FSD, RISCV_INS_FSD, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTD, 0 }, 0, 0 -#endif -}, -{ - RISCV_FSGNJN_D, RISCV_INS_FSGNJN_D, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTD, 0 }, 0, 0 -#endif -}, -{ - RISCV_FSGNJN_S, RISCV_INS_FSGNJN_S, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTF, 0 }, 0, 0 -#endif -}, -{ - RISCV_FSGNJX_D, RISCV_INS_FSGNJX_D, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTD, 0 }, 0, 0 -#endif -}, -{ - RISCV_FSGNJX_S, RISCV_INS_FSGNJX_S, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTF, 0 }, 0, 0 -#endif -}, -{ - RISCV_FSGNJ_D, RISCV_INS_FSGNJ_D, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTD, 0 }, 0, 0 -#endif -}, -{ - RISCV_FSGNJ_S, RISCV_INS_FSGNJ_S, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTF, 0 }, 0, 0 -#endif -}, -{ - RISCV_FSQRT_D, RISCV_INS_FSQRT_D, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTD, 0 }, 0, 0 -#endif -}, -{ - RISCV_FSQRT_S, RISCV_INS_FSQRT_S, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTF, 0 }, 0, 0 -#endif -}, -{ - RISCV_FSUB_D, RISCV_INS_FSUB_D, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTD, 0 }, 0, 0 -#endif -}, -{ - RISCV_FSUB_S, RISCV_INS_FSUB_S, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTF, 0 }, 0, 0 -#endif -}, -{ - RISCV_FSW, RISCV_INS_FSW, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTF, 0 }, 0, 0 -#endif -}, -{ - RISCV_JAL, RISCV_INS_JAL, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_CALL, 0 }, 0, 0 -#endif -}, -{ - RISCV_JALR, RISCV_INS_JALR, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_CALL, 0 }, 0, 0 -#endif -}, -{ - RISCV_LB, RISCV_INS_LB, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { 0 }, 0, 0 -#endif -}, -{ - RISCV_LBU, RISCV_INS_LBU, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { 0 }, 0, 0 -#endif -}, -{ - RISCV_LD, RISCV_INS_LD, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_LH, RISCV_INS_LH, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { 0 }, 0, 0 -#endif -}, -{ - RISCV_LHU, RISCV_INS_LHU, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { 0 }, 0, 0 -#endif -}, -{ - RISCV_LR_D, RISCV_INS_LR_D, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_LR_D_AQ, RISCV_INS_LR_D_AQ, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_LR_D_AQ_RL, RISCV_INS_LR_D_AQ_RL, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_LR_D_RL, RISCV_INS_LR_D_RL, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_LR_W, RISCV_INS_LR_W, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, 0 }, 0, 0 -#endif -}, -{ - RISCV_LR_W_AQ, RISCV_INS_LR_W_AQ, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, 0 }, 0, 0 -#endif -}, -{ - RISCV_LR_W_AQ_RL, RISCV_INS_LR_W_AQ_RL, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, 0 }, 0, 0 -#endif -}, -{ - RISCV_LR_W_RL, RISCV_INS_LR_W_RL, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, 0 }, 0, 0 -#endif -}, -{ - RISCV_LUI, RISCV_INS_LUI, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { 0 }, 0, 0 -#endif -}, -{ - RISCV_LW, RISCV_INS_LW, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { 0 }, 0, 0 -#endif -}, -{ - RISCV_LWU, RISCV_INS_LWU, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_MRET, RISCV_INS_MRET, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { 0 }, 0, 0 -#endif -}, -{ - RISCV_MUL, RISCV_INS_MUL, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTM, 0 }, 0, 0 -#endif -}, -{ - RISCV_MULH, RISCV_INS_MULH, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTM, 0 }, 0, 0 -#endif -}, -{ - RISCV_MULHSU, RISCV_INS_MULHSU, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTM, 0 }, 0, 0 -#endif -}, -{ - RISCV_MULHU, RISCV_INS_MULHU, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTM, 0 }, 0, 0 -#endif -}, -{ - RISCV_MULW, RISCV_INS_MULW, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTM, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_OR, RISCV_INS_OR, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { 0 }, 0, 0 -#endif -}, -{ - RISCV_ORI, RISCV_INS_ORI, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { 0 }, 0, 0 -#endif -}, -{ - RISCV_REM, RISCV_INS_REM, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTM, 0 }, 0, 0 -#endif -}, -{ - RISCV_REMU, RISCV_INS_REMU, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTM, 0 }, 0, 0 -#endif -}, -{ - RISCV_REMUW, RISCV_INS_REMUW, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTM, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_REMW, RISCV_INS_REMW, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTM, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_SB, RISCV_INS_SB, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { 0 }, 0, 0 -#endif -}, -{ - RISCV_SC_D, RISCV_INS_SC_D, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_SC_D_AQ, RISCV_INS_SC_D_AQ, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_SC_D_AQ_RL, RISCV_INS_SC_D_AQ_RL, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_SC_D_RL, RISCV_INS_SC_D_RL, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_SC_W, RISCV_INS_SC_W, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, 0 }, 0, 0 -#endif -}, -{ - RISCV_SC_W_AQ, RISCV_INS_SC_W_AQ, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, 0 }, 0, 0 -#endif -}, -{ - RISCV_SC_W_AQ_RL, RISCV_INS_SC_W_AQ_RL, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, 0 }, 0, 0 -#endif -}, -{ - RISCV_SC_W_RL, RISCV_INS_SC_W_RL, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_HASSTDEXTA, 0 }, 0, 0 -#endif -}, -{ - RISCV_SD, RISCV_INS_SD, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_SFENCE_VMA, RISCV_INS_SFENCE_VMA, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { 0 }, 0, 0 -#endif -}, -{ - RISCV_SH, RISCV_INS_SH, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { 0 }, 0, 0 -#endif -}, -{ - RISCV_SLL, RISCV_INS_SLL, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { 0 }, 0, 0 -#endif -}, -{ - RISCV_SLLI, RISCV_INS_SLLI, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { 0 }, 0, 0 -#endif -}, -{ - RISCV_SLLIW, RISCV_INS_SLLIW, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_SLLW, RISCV_INS_SLLW, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_SLT, RISCV_INS_SLT, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { 0 }, 0, 0 -#endif -}, -{ - RISCV_SLTI, RISCV_INS_SLTI, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { 0 }, 0, 0 -#endif -}, -{ - RISCV_SLTIU, RISCV_INS_SLTIU, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { 0 }, 0, 0 -#endif -}, -{ - RISCV_SLTU, RISCV_INS_SLTU, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { 0 }, 0, 0 -#endif -}, -{ - RISCV_SRA, RISCV_INS_SRA, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { 0 }, 0, 0 -#endif -}, -{ - RISCV_SRAI, RISCV_INS_SRAI, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { 0 }, 0, 0 -#endif -}, -{ - RISCV_SRAIW, RISCV_INS_SRAIW, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_SRAW, RISCV_INS_SRAW, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_SRET, RISCV_INS_SRET, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { 0 }, 0, 0 -#endif -}, -{ - RISCV_SRL, RISCV_INS_SRL, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { 0 }, 0, 0 -#endif -}, -{ - RISCV_SRLI, RISCV_INS_SRLI, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { 0 }, 0, 0 -#endif -}, -{ - RISCV_SRLIW, RISCV_INS_SRLIW, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_SRLW, RISCV_INS_SRLW, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_SUB, RISCV_INS_SUB, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { 0 }, 0, 0 -#endif -}, -{ - RISCV_SUBW, RISCV_INS_SUBW, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { RISCV_GRP_ISRV64, 0 }, 0, 0 -#endif -}, -{ - RISCV_SW, RISCV_INS_SW, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { 0 }, 0, 0 -#endif -}, -{ - RISCV_UNIMP, RISCV_INS_UNIMP, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { 0 }, 0, 0 -#endif -}, -{ - RISCV_URET, RISCV_INS_URET, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { 0 }, 0, 0 -#endif -}, -{ - RISCV_WFI, RISCV_INS_WFI, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { 0 }, 0, 0 -#endif -}, -{ - RISCV_XOR, RISCV_INS_XOR, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { 0 }, 0, 0 -#endif -}, -{ - RISCV_XORI, RISCV_INS_XORI, -#ifndef CAPSTONE_DIET - { 0 }, { 0 }, { 0 }, 0, 0 -#endif -}, diff --git a/arch/RISCV/RISCVMappingInsnOp.inc b/arch/RISCV/RISCVMappingInsnOp.inc deleted file mode 100644 index fc67f0834b..0000000000 --- a/arch/RISCV/RISCVMappingInsnOp.inc +++ /dev/null @@ -1,2438 +0,0 @@ -/* Capstone Disassembly Engine, https://www.capstone-engine.org */ -/* By Nguyen Anh Quynh , 2013-2022, */ -/* Rot127 2022-2023 */ - -{{{ /* RISCV_PHI (0) */ - 0 -}}}, -{{{ /* RISCV_INLINEASM (1) */ - 0 -}}}, -{{{ /* RISCV_INLINEASM_BR (2) */ - 0 -}}}, -{{{ /* RISCV_CFI_INSTRUCTION (3) */ - 0 -}}}, -{{{ /* RISCV_EH_LABEL (4) */ - 0 -}}}, -{{{ /* RISCV_GC_LABEL (5) */ - 0 -}}}, -{{{ /* RISCV_ANNOTATION_LABEL (6) */ - 0 -}}}, -{{{ /* RISCV_KILL (7) */ - 0 -}}}, -{{{ /* RISCV_EXTRACT_SUBREG (8) */ - 0 -}}}, -{{{ /* RISCV_INSERT_SUBREG (9) */ - 0 -}}}, -{{{ /* RISCV_IMPLICIT_DEF (10) */ - 0 -}}}, -{{{ /* RISCV_SUBREG_TO_REG (11) */ - 0 -}}}, -{{{ /* RISCV_COPY_TO_REGCLASS (12) */ - 0 -}}}, -{{{ /* RISCV_DBG_VALUE (13) */ - 0 -}}}, -{{{ /* RISCV_DBG_LABEL (14) */ - 0 -}}}, -{{{ /* RISCV_REG_SEQUENCE (15) */ - 0 -}}}, -{{{ /* RISCV_COPY (16) */ - 0 -}}}, -{{{ /* RISCV_BUNDLE (17) */ - 0 -}}}, -{{{ /* RISCV_LIFETIME_START (18) */ - 0 -}}}, -{{{ /* RISCV_LIFETIME_END (19) */ - 0 -}}}, -{{{ /* RISCV_STACKMAP (20) */ - 0 -}}}, -{{{ /* RISCV_FENTRY_CALL (21) */ - 0 -}}}, -{{{ /* RISCV_PATCHPOINT (22) */ - 0 -}}}, -{{{ /* RISCV_LOAD_STACK_GUARD (23) */ - 0 -}}}, -{{{ /* RISCV_STATEPOINT (24) */ - 0 -}}}, -{{{ /* RISCV_LOCAL_ESCAPE (25) */ - 0 -}}}, -{{{ /* RISCV_FAULTING_OP (26) */ - 0 -}}}, -{{{ /* RISCV_PATCHABLE_OP (27) */ - 0 -}}}, -{{{ /* RISCV_PATCHABLE_FUNCTION_ENTER (28) */ - 0 -}}}, -{{{ /* RISCV_PATCHABLE_RET (29) */ - 0 -}}}, -{{{ /* RISCV_PATCHABLE_FUNCTION_EXIT (30) */ - 0 -}}}, -{{{ /* RISCV_PATCHABLE_TAIL_CALL (31) */ - 0 -}}}, -{{{ /* RISCV_PATCHABLE_EVENT_CALL (32) */ - 0 -}}}, -{{{ /* RISCV_PATCHABLE_TYPED_EVENT_CALL (33) */ - 0 -}}}, -{{{ /* RISCV_ICALL_BRANCH_FUNNEL (34) */ - 0 -}}}, -{{{ /* RISCV_G_ADD (35) */ - 0 -}}}, -{{{ /* RISCV_G_SUB (36) */ - 0 -}}}, -{{{ /* RISCV_G_MUL (37) */ - 0 -}}}, -{{{ /* RISCV_G_SDIV (38) */ - 0 -}}}, -{{{ /* RISCV_G_UDIV (39) */ - 0 -}}}, -{{{ /* RISCV_G_SREM (40) */ - 0 -}}}, -{{{ /* RISCV_G_UREM (41) */ - 0 -}}}, -{{{ /* RISCV_G_AND (42) */ - 0 -}}}, -{{{ /* RISCV_G_OR (43) */ - 0 -}}}, -{{{ /* RISCV_G_XOR (44) */ - 0 -}}}, -{{{ /* RISCV_G_IMPLICIT_DEF (45) */ - 0 -}}}, -{{{ /* RISCV_G_PHI (46) */ - 0 -}}}, -{{{ /* RISCV_G_FRAME_INDEX (47) */ - 0 -}}}, -{{{ /* RISCV_G_GLOBAL_VALUE (48) */ - 0 -}}}, -{{{ /* RISCV_G_EXTRACT (49) */ - 0 -}}}, -{{{ /* RISCV_G_UNMERGE_VALUES (50) */ - 0 -}}}, -{{{ /* RISCV_G_INSERT (51) */ - 0 -}}}, -{{{ /* RISCV_G_MERGE_VALUES (52) */ - 0 -}}}, -{{{ /* RISCV_G_BUILD_VECTOR (53) */ - 0 -}}}, -{{{ /* RISCV_G_BUILD_VECTOR_TRUNC (54) */ - 0 -}}}, -{{{ /* RISCV_G_CONCAT_VECTORS (55) */ - 0 -}}}, -{{{ /* RISCV_G_PTRTOINT (56) */ - 0 -}}}, -{{{ /* RISCV_G_INTTOPTR (57) */ - 0 -}}}, -{{{ /* RISCV_G_BITCAST (58) */ - 0 -}}}, -{{{ /* RISCV_G_INTRINSIC_TRUNC (59) */ - 0 -}}}, -{{{ /* RISCV_G_INTRINSIC_ROUND (60) */ - 0 -}}}, -{{{ /* RISCV_G_LOAD (61) */ - 0 -}}}, -{{{ /* RISCV_G_SEXTLOAD (62) */ - 0 -}}}, -{{{ /* RISCV_G_ZEXTLOAD (63) */ - 0 -}}}, -{{{ /* RISCV_G_STORE (64) */ - 0 -}}}, -{{{ /* RISCV_G_ATOMIC_CMPXCHG_WITH_SUCCESS (65) */ - 0 -}}}, -{{{ /* RISCV_G_ATOMIC_CMPXCHG (66) */ - 0 -}}}, -{{{ /* RISCV_G_ATOMICRMW_XCHG (67) */ - 0 -}}}, -{{{ /* RISCV_G_ATOMICRMW_ADD (68) */ - 0 -}}}, -{{{ /* RISCV_G_ATOMICRMW_SUB (69) */ - 0 -}}}, -{{{ /* RISCV_G_ATOMICRMW_AND (70) */ - 0 -}}}, -{{{ /* RISCV_G_ATOMICRMW_NAND (71) */ - 0 -}}}, -{{{ /* RISCV_G_ATOMICRMW_OR (72) */ - 0 -}}}, -{{{ /* RISCV_G_ATOMICRMW_XOR (73) */ - 0 -}}}, -{{{ /* RISCV_G_ATOMICRMW_MAX (74) */ - 0 -}}}, -{{{ /* RISCV_G_ATOMICRMW_MIN (75) */ - 0 -}}}, -{{{ /* RISCV_G_ATOMICRMW_UMAX (76) */ - 0 -}}}, -{{{ /* RISCV_G_ATOMICRMW_UMIN (77) */ - 0 -}}}, -{{{ /* RISCV_G_BRCOND (78) */ - 0 -}}}, -{{{ /* RISCV_G_BRINDIRECT (79) */ - 0 -}}}, -{{{ /* RISCV_G_INTRINSIC (80) */ - 0 -}}}, -{{{ /* RISCV_G_INTRINSIC_W_SIDE_EFFECTS (81) */ - 0 -}}}, -{{{ /* RISCV_G_ANYEXT (82) */ - 0 -}}}, -{{{ /* RISCV_G_TRUNC (83) */ - 0 -}}}, -{{{ /* RISCV_G_CONSTANT (84) */ - 0 -}}}, -{{{ /* RISCV_G_FCONSTANT (85) */ - 0 -}}}, -{{{ /* RISCV_G_VASTART (86) */ - 0 -}}}, -{{{ /* RISCV_G_VAARG (87) */ - 0 -}}}, -{{{ /* RISCV_G_SEXT (88) */ - 0 -}}}, -{{{ /* RISCV_G_ZEXT (89) */ - 0 -}}}, -{{{ /* RISCV_G_SHL (90) */ - 0 -}}}, -{{{ /* RISCV_G_LSHR (91) */ - 0 -}}}, -{{{ /* RISCV_G_ASHR (92) */ - 0 -}}}, -{{{ /* RISCV_G_ICMP (93) */ - 0 -}}}, -{{{ /* RISCV_G_FCMP (94) */ - 0 -}}}, -{{{ /* RISCV_G_SELECT (95) */ - 0 -}}}, -{{{ /* RISCV_G_UADDO (96) */ - 0 -}}}, -{{{ /* RISCV_G_UADDE (97) */ - 0 -}}}, -{{{ /* RISCV_G_USUBO (98) */ - 0 -}}}, -{{{ /* RISCV_G_USUBE (99) */ - 0 -}}}, -{{{ /* RISCV_G_SADDO (100) */ - 0 -}}}, -{{{ /* RISCV_G_SADDE (101) */ - 0 -}}}, -{{{ /* RISCV_G_SSUBO (102) */ - 0 -}}}, -{{{ /* RISCV_G_SSUBE (103) */ - 0 -}}}, -{{{ /* RISCV_G_UMULO (104) */ - 0 -}}}, -{{{ /* RISCV_G_SMULO (105) */ - 0 -}}}, -{{{ /* RISCV_G_UMULH (106) */ - 0 -}}}, -{{{ /* RISCV_G_SMULH (107) */ - 0 -}}}, -{{{ /* RISCV_G_FADD (108) */ - 0 -}}}, -{{{ /* RISCV_G_FSUB (109) */ - 0 -}}}, -{{{ /* RISCV_G_FMUL (110) */ - 0 -}}}, -{{{ /* RISCV_G_FMA (111) */ - 0 -}}}, -{{{ /* RISCV_G_FDIV (112) */ - 0 -}}}, -{{{ /* RISCV_G_FREM (113) */ - 0 -}}}, -{{{ /* RISCV_G_FPOW (114) */ - 0 -}}}, -{{{ /* RISCV_G_FEXP (115) */ - 0 -}}}, -{{{ /* RISCV_G_FEXP2 (116) */ - 0 -}}}, -{{{ /* RISCV_G_FLOG (117) */ - 0 -}}}, -{{{ /* RISCV_G_FLOG2 (118) */ - 0 -}}}, -{{{ /* RISCV_G_FLOG10 (119) */ - 0 -}}}, -{{{ /* RISCV_G_FNEG (120) */ - 0 -}}}, -{{{ /* RISCV_G_FPEXT (121) */ - 0 -}}}, -{{{ /* RISCV_G_FPTRUNC (122) */ - 0 -}}}, -{{{ /* RISCV_G_FPTOSI (123) */ - 0 -}}}, -{{{ /* RISCV_G_FPTOUI (124) */ - 0 -}}}, -{{{ /* RISCV_G_SITOFP (125) */ - 0 -}}}, -{{{ /* RISCV_G_UITOFP (126) */ - 0 -}}}, -{{{ /* RISCV_G_FABS (127) */ - 0 -}}}, -{{{ /* RISCV_G_FCANONICALIZE (128) */ - 0 -}}}, -{{{ /* RISCV_G_GEP (129) */ - 0 -}}}, -{{{ /* RISCV_G_PTR_MASK (130) */ - 0 -}}}, -{{{ /* RISCV_G_BR (131) */ - 0 -}}}, -{{{ /* RISCV_G_INSERT_VECTOR_ELT (132) */ - 0 -}}}, -{{{ /* RISCV_G_EXTRACT_VECTOR_ELT (133) */ - 0 -}}}, -{{{ /* RISCV_G_SHUFFLE_VECTOR (134) */ - 0 -}}}, -{{{ /* RISCV_G_CTTZ (135) */ - 0 -}}}, -{{{ /* RISCV_G_CTTZ_ZERO_UNDEF (136) */ - 0 -}}}, -{{{ /* RISCV_G_CTLZ (137) */ - 0 -}}}, -{{{ /* RISCV_G_CTLZ_ZERO_UNDEF (138) */ - 0 -}}}, -{{{ /* RISCV_G_CTPOP (139) */ - 0 -}}}, -{{{ /* RISCV_G_BSWAP (140) */ - 0 -}}}, -{{{ /* RISCV_G_FCEIL (141) */ - 0 -}}}, -{{{ /* RISCV_G_FCOS (142) */ - 0 -}}}, -{{{ /* RISCV_G_FSIN (143) */ - 0 -}}}, -{{{ /* RISCV_G_FSQRT (144) */ - 0 -}}}, -{{{ /* RISCV_G_FFLOOR (145) */ - 0 -}}}, -{{{ /* RISCV_G_ADDRSPACE_CAST (146) */ - 0 -}}}, -{{{ /* RISCV_G_BLOCK_ADDR (147) */ - 0 -}}}, -{{{ /* RISCV_ADJCALLSTACKDOWN (148) */ - 0 -}}}, -{{{ /* RISCV_ADJCALLSTACKUP (149) */ - 0 -}}}, -{{{ /* RISCV_BuildPairF64Pseudo (150) */ - 0 -}}}, -{{{ /* RISCV_PseudoAtomicLoadNand32 (151) */ - 0 -}}}, -{{{ /* RISCV_PseudoAtomicLoadNand64 (152) */ - 0 -}}}, -{{{ /* RISCV_PseudoBR (153) */ - 0 -}}}, -{{{ /* RISCV_PseudoBRIND (154) */ - 0 -}}}, -{{{ /* RISCV_PseudoCALL (155) */ - 0 -}}}, -{{{ /* RISCV_PseudoCALLIndirect (156) */ - 0 -}}}, -{{{ /* RISCV_PseudoCmpXchg32 (157) */ - 0 -}}}, -{{{ /* RISCV_PseudoCmpXchg64 (158) */ - 0 -}}}, -{{{ /* RISCV_PseudoLA (159) */ - 0 -}}}, -{{{ /* RISCV_PseudoLI (160) */ - 0 -}}}, -{{{ /* RISCV_PseudoLLA (161) */ - 0 -}}}, -{{{ /* RISCV_PseudoMaskedAtomicLoadAdd32 (162) */ - 0 -}}}, -{{{ /* RISCV_PseudoMaskedAtomicLoadMax32 (163) */ - 0 -}}}, -{{{ /* RISCV_PseudoMaskedAtomicLoadMin32 (164) */ - 0 -}}}, -{{{ /* RISCV_PseudoMaskedAtomicLoadNand32 (165) */ - 0 -}}}, -{{{ /* RISCV_PseudoMaskedAtomicLoadSub32 (166) */ - 0 -}}}, -{{{ /* RISCV_PseudoMaskedAtomicLoadUMax32 (167) */ - 0 -}}}, -{{{ /* RISCV_PseudoMaskedAtomicLoadUMin32 (168) */ - 0 -}}}, -{{{ /* RISCV_PseudoMaskedAtomicSwap32 (169) */ - 0 -}}}, -{{{ /* RISCV_PseudoMaskedCmpXchg32 (170) */ - 0 -}}}, -{{{ /* RISCV_PseudoRET (171) */ - 0 -}}}, -{{{ /* RISCV_PseudoTAIL (172) */ - 0 -}}}, -{{{ /* RISCV_PseudoTAILIndirect (173) */ - 0 -}}}, -{{{ /* RISCV_Select_FPR32_Using_CC_GPR (174) */ - 0 -}}}, -{{{ /* RISCV_Select_FPR64_Using_CC_GPR (175) */ - 0 -}}}, -{{{ /* RISCV_Select_GPR_Using_CC_GPR (176) */ - 0 -}}}, -{{{ /* RISCV_SplitF64Pseudo (177) */ - 0 -}}}, -{ /* RISCV_ADD (178) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_ADDI (179) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_ADDIW (180) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_ADDW (181) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOADD_D (182) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOADD_D_AQ (183) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOADD_D_AQ_RL (184) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOADD_D_RL (185) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOADD_W (186) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOADD_W_AQ (187) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOADD_W_AQ_RL (188) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOADD_W_RL (189) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOAND_D (190) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOAND_D_AQ (191) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOAND_D_AQ_RL (192) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOAND_D_RL (193) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOAND_W (194) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOAND_W_AQ (195) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOAND_W_AQ_RL (196) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOAND_W_RL (197) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOMAXU_D (198) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOMAXU_D_AQ (199) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOMAXU_D_AQ_RL (200) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOMAXU_D_RL (201) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOMAXU_W (202) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOMAXU_W_AQ (203) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOMAXU_W_AQ_RL (204) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOMAXU_W_RL (205) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOMAX_D (206) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOMAX_D_AQ (207) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOMAX_D_AQ_RL (208) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOMAX_D_RL (209) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOMAX_W (210) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOMAX_W_AQ (211) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOMAX_W_AQ_RL (212) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOMAX_W_RL (213) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOMINU_D (214) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOMINU_D_AQ (215) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOMINU_D_AQ_RL (216) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOMINU_D_RL (217) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOMINU_W (218) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOMINU_W_AQ (219) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOMINU_W_AQ_RL (220) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOMINU_W_RL (221) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOMIN_D (222) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOMIN_D_AQ (223) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOMIN_D_AQ_RL (224) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOMIN_D_RL (225) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOMIN_W (226) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOMIN_W_AQ (227) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOMIN_W_AQ_RL (228) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOMIN_W_RL (229) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOOR_D (230) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOOR_D_AQ (231) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOOR_D_AQ_RL (232) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOOR_D_RL (233) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOOR_W (234) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOOR_W_AQ (235) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOOR_W_AQ_RL (236) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOOR_W_RL (237) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOSWAP_D (238) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOSWAP_D_AQ (239) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOSWAP_D_AQ_RL (240) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOSWAP_D_RL (241) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOSWAP_W (242) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOSWAP_W_AQ (243) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOSWAP_W_AQ_RL (244) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOSWAP_W_RL (245) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOXOR_D (246) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOXOR_D_AQ (247) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOXOR_D_AQ_RL (248) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOXOR_D_RL (249) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOXOR_W (250) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOXOR_W_AQ (251) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOXOR_W_AQ_RL (252) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AMOXOR_W_RL (253) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AND (254) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_ANDI (255) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_AUIPC (256) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_BEQ (257) */ -{ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_BGE (258) */ -{ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_BGEU (259) */ -{ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_BLT (260) */ -{ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_BLTU (261) */ -{ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_BNE (262) */ -{ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_CSRRC (263) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_CSRRCI (264) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_CSRRS (265) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_CSRRSI (266) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_CSRRW (267) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_CSRRWI (268) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_C_ADD (269) */ -{ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_C_ADDI (270) */ -{ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_C_ADDI16SP (271) */ -{ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_C_ADDI4SPN (272) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_C_ADDIW (273) */ -{ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_C_ADDW (274) */ -{ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_C_AND (275) */ -{ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_C_ANDI (276) */ -{ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_C_BEQZ (277) */ -{ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_C_BNEZ (278) */ -{ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_C_EBREAK (279) */ -{ - { 0 } -}}, -{ /* RISCV_C_FLD (280) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_C_FLDSP (281) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_C_FLW (282) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_C_FLWSP (283) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_C_FSD (284) */ -{ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_C_FSDSP (285) */ -{ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_C_FSW (286) */ -{ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_C_FSWSP (287) */ -{ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_C_J (288) */ -{ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_C_JAL (289) */ -{ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_C_JALR (290) */ -{ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_C_JR (291) */ -{ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_C_LD (292) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_C_LDSP (293) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_C_LI (294) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_C_LUI (295) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_C_LW (296) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_C_LWSP (297) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_C_MV (298) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_C_NOP (299) */ -{ - { 0 } -}}, -{ /* RISCV_C_OR (300) */ -{ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_C_SD (301) */ -{ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_C_SDSP (302) */ -{ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_C_SLLI (303) */ -{ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_C_SRAI (304) */ -{ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_C_SRLI (305) */ -{ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_C_SUB (306) */ -{ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_C_SUBW (307) */ -{ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_C_SW (308) */ -{ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_C_SWSP (309) */ -{ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_C_UNIMP (310) */ -{ - { 0 } -}}, -{ /* RISCV_C_XOR (311) */ -{ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ | CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_DIV (312) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_DIVU (313) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_DIVUW (314) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_DIVW (315) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_EBREAK (316) */ -{ - { 0 } -}}, -{ /* RISCV_ECALL (317) */ -{ - { 0 } -}}, -{ /* RISCV_FADD_D (318) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FADD_S (319) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FCLASS_D (320) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FCLASS_S (321) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FCVT_D_L (322) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FCVT_D_LU (323) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FCVT_D_S (324) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FCVT_D_W (325) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FCVT_D_WU (326) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FCVT_LU_D (327) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FCVT_LU_S (328) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FCVT_L_D (329) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FCVT_L_S (330) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FCVT_S_D (331) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FCVT_S_L (332) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FCVT_S_LU (333) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FCVT_S_W (334) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FCVT_S_WU (335) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FCVT_WU_D (336) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FCVT_WU_S (337) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FCVT_W_D (338) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FCVT_W_S (339) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FDIV_D (340) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FDIV_S (341) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FENCE (342) */ -{ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FENCE_I (343) */ -{ - { 0 } -}}, -{ /* RISCV_FENCE_TSO (344) */ -{ - { 0 } -}}, -{ /* RISCV_FEQ_D (345) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FEQ_S (346) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FLD (347) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FLE_D (348) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FLE_S (349) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FLT_D (350) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FLT_S (351) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FLW (352) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FMADD_D (353) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FMADD_S (354) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FMAX_D (355) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FMAX_S (356) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FMIN_D (357) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FMIN_S (358) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FMSUB_D (359) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FMSUB_S (360) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FMUL_D (361) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FMUL_S (362) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FMV_D_X (363) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FMV_W_X (364) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FMV_X_D (365) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FMV_X_W (366) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FNMADD_D (367) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FNMADD_S (368) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FNMSUB_D (369) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FNMSUB_S (370) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FSD (371) */ -{ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FSGNJN_D (372) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FSGNJN_S (373) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FSGNJX_D (374) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FSGNJX_S (375) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FSGNJ_D (376) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FSGNJ_S (377) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FSQRT_D (378) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FSQRT_S (379) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FSUB_D (380) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f64, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FSUB_S (381) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_FSW (382) */ -{ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_f32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_JAL (383) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_JALR (384) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_LB (385) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i8, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_LBU (386) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i8, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_LD (387) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_LH (388) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i16, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_LHU (389) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i16, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_LR_D (390) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_LR_D_AQ (391) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_LR_D_AQ_RL (392) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_LR_D_RL (393) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_LR_W (394) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_LR_W_AQ (395) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_LR_W_AQ_RL (396) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_LR_W_RL (397) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_LUI (398) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_LW (399) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_LWU (400) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_MRET (401) */ -{ - { 0 } -}}, -{ /* RISCV_MUL (402) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_MULH (403) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_MULHSU (404) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_MULHU (405) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_MULW (406) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_OR (407) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_ORI (408) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_REM (409) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_REMU (410) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_REMUW (411) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_REMW (412) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_SB (413) */ -{ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i8, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_SC_D (414) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_SC_D_AQ (415) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_SC_D_AQ_RL (416) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_SC_D_RL (417) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_SC_W (418) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_SC_W_AQ (419) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_SC_W_AQ_RL (420) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_SC_W_RL (421) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_SD (422) */ -{ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_SFENCE_VMA (423) */ -{ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_SH (424) */ -{ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i16, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_SLL (425) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_SLLI (426) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_SLLIW (427) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_SLLW (428) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_SLT (429) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_SLTI (430) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_SLTIU (431) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_SLTU (432) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_SRA (433) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_SRAI (434) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_SRAIW (435) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_SRAW (436) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_SRET (437) */ -{ - { 0 } -}}, -{ /* RISCV_SRL (438) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_SRLI (439) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_SRLIW (440) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_SRLW (441) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_SUB (442) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_SUBW (443) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_i64, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_SW (444) */ -{ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_i32, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_UNIMP (445) */ -{ - { 0 } -}}, -{ /* RISCV_URET (446) */ -{ - { 0 } -}}, -{ /* RISCV_WFI (447) */ -{ - { 0 } -}}, -{ /* RISCV_XOR (448) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_XORI (449) */ -{ - { CS_OP_REG, CS_AC_WRITE, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_REG, CS_AC_READ, { CS_DATA_TYPE_Untyped, CS_DATA_TYPE_LAST }, }, /* */ - { CS_OP_IMM, CS_AC_READ, { CS_DATA_TYPE_Other, CS_DATA_TYPE_LAST }, }, /* */ - { 0 } -}}, -{ /* RISCV_INSTRUCTION_LIST_END (450) */ -{ - { 0 } -}}, diff --git a/arch/RISCV/RISCVModule.c b/arch/RISCV/RISCVModule.c index f72f4498e0..c6bc50ea9f 100644 --- a/arch/RISCV/RISCVModule.c +++ b/arch/RISCV/RISCVModule.c @@ -6,10 +6,10 @@ #include "../../utils.h" #include "../../MCRegisterInfo.h" -#include "RISCVDisassembler.h" #include "RISCVInstPrinter.h" #include "RISCVMapping.h" #include "RISCVModule.h" +#include "RISCVLinkage.h" cs_err RISCV_global_init(cs_struct *ud) { @@ -17,10 +17,10 @@ cs_err RISCV_global_init(cs_struct *ud) mri = cs_mem_malloc(sizeof(*mri)); RISCV_init(mri); - ud->printer = RISCV_printInst; + ud->printer = RISCV_LLVM_printInstruction; ud->printer_info = mri; ud->getinsn_info = mri; - ud->disasm = RISCV_getInstruction; + ud->disasm = RISCV_LLVM_getInstruction; ud->post_printer = NULL; ud->reg_name = RISCV_reg_name; diff --git a/cs.c b/cs.c index 80ade811fb..ab157bc7f5 100644 --- a/cs.c +++ b/cs.c @@ -200,8 +200,13 @@ typedef struct cs_arch_config { } #define CS_ARCH_CONFIG_RISCV \ { \ - RISCV_global_init, RISCV_option, \ - ~(CS_MODE_RISCV32 | CS_MODE_RISCV64 | CS_MODE_RISCVC), \ + RISCV_global_init, \ + RISCV_option, \ + ~(CS_MODE_RISCV32 | CS_MODE_RISCV64 | CS_MODE_RISCV_C | CS_MODE_RISCV_FD | CS_MODE_RISCV_V | \ + CS_MODE_RISCV_ZFINX | CS_MODE_RISCV_ZCMP_ZCMT_ZCE | CS_MODE_RISCV_ZICFISS | CS_MODE_RISCV_E | \ + CS_MODE_RISCV_A | CS_MODE_RISCV_COREV | CS_MODE_RISCV_SIFIVE | CS_MODE_RISCV_THEAD | \ + CS_MODE_RISCV_ZBA | CS_MODE_RISCV_ZBB | CS_MODE_RISCV_ZBC | CS_MODE_RISCV_ZBKB | \ + CS_MODE_RISCV_ZBKC | CS_MODE_RISCV_ZBKX | CS_MODE_RISCV_ZBS), \ } #define CS_ARCH_CONFIG_SH \ { \ @@ -994,7 +999,7 @@ static uint8_t skipdata_size(cs_struct *handle) return 8; case CS_ARCH_RISCV: // special compress mode - if (handle->mode & CS_MODE_RISCVC) + if (handle->mode & CS_MODE_RISCV_C) return 2; return 4; case CS_ARCH_SH: diff --git a/cstool/cstool.c b/cstool/cstool.c index c341f7fb0f..fedbff68c9 100644 --- a/cstool/cstool.c +++ b/cstool/cstool.c @@ -64,6 +64,9 @@ static struct { { CS_ARCH_LOONGARCH, CS_ARCH_MIPS, CS_ARCH_MAX }, CS_OPT_SYNTAX_NO_DOLLAR, 0 }, + { "+noalias", "Does not print the text alias of an alias instruction", { + CS_ARCH_RISCV, CS_ARCH_MAX + }, CS_OPT_SYNTAX_NO_ALIAS_TEXT, 0}, // cs_mode only { "+nofloat", "Disables floating point support", @@ -135,6 +138,37 @@ static struct { { CS_ARCH_SPARC, CS_ARCH_MAX }, 0, CS_MODE_V9 }, + { "+c", + "Enables RISCV C extension.", + { CS_ARCH_RISCV, CS_ARCH_MAX }, + 0, + CS_MODE_RISCV_C }, + { "+fd", + "Enables RISCV F and D extensions.", + { CS_ARCH_RISCV, CS_ARCH_MAX }, + 0, + CS_MODE_RISCV_FD }, + { "+v", + "Enables RISCV V extension.", + { CS_ARCH_RISCV, CS_ARCH_MAX }, + 0, + CS_MODE_RISCV_V }, + { "+inx", + "Enables RISCV Zfinx, Zdinx, and Zhinx extensions," + " zhinxmin is also enabled as it's subset of zhinx ", + { CS_ARCH_RISCV, CS_ARCH_MAX }, + 0, + CS_MODE_RISCV_ZFINX }, + { "+zcmp-t-e", + "Enables the following RISCV code size reduction extensions: zcmp, zcmt and zce", + { CS_ARCH_RISCV, CS_ARCH_MAX }, + 0, + CS_MODE_RISCV_ZCMP_ZCMT_ZCE }, + { "a", + "Enables the RISCV A extension", + { CS_ARCH_RISCV, CS_ARCH_MAX}, + 0, + CS_MODE_RISCV_A }, { NULL } }; @@ -351,9 +385,9 @@ static struct { CS_MODE_BIG_ENDIAN | CS_MODE_BPF_EXTENDED }, { "riscv32", "Risc-V 32-bit, little endian", CS_ARCH_RISCV, - CS_MODE_RISCV32 | CS_MODE_RISCVC }, + CS_MODE_RISCV32 | CS_MODE_RISCV_C }, { "riscv64", "Risc-V 64-bit, little endian", CS_ARCH_RISCV, - CS_MODE_RISCV64 | CS_MODE_RISCVC }, + CS_MODE_RISCV64 | CS_MODE_RISCV_C }, { "6502", "MOS 6502", CS_ARCH_MOS65XX, CS_MODE_MOS65XX_6502 }, { "65c02", "WDC 65c02", CS_ARCH_MOS65XX, CS_MODE_MOS65XX_65C02 }, @@ -955,6 +989,8 @@ int main(int argc, char **argv) } count = cs_disasm(handle, assembly, size, address, 0, &insn); + printf("\nINSN TEXT: %s, %s", insn->mnemonic, insn->op_str); + printf("\n ------------------------------ COUNT OF CS INSN OPS : %d \n", insn->detail->riscv.op_count); if (count > 0) { for (i = 0; i < count; i++) { int j; diff --git a/cstool/cstool_riscv.c b/cstool/cstool_riscv.c index f7aa721fc5..0bb7ece6ed 100644 --- a/cstool/cstool_riscv.c +++ b/cstool/cstool_riscv.c @@ -1,10 +1,13 @@ /* Capstone Disassembler Engine */ /* By Nguyen Anh Quynh , 2013-2014 */ +#include "capstone/riscv.h" #include #include #include "cstool.h" +#include "../arch/RISCV/RISCVInstPrinter.h" + void print_insn_detail_riscv(csh handle, cs_insn *ins) { cs_riscv *riscv; @@ -41,6 +44,12 @@ void print_insn_detail_riscv(csh handle, cs_insn *ins) i, (long)op->mem.disp); break; + case RISCV_OP_FP: + printf("\t\toperands[%u].type: FP_IMM\n", i); + break; + case RISCV_OP_CSR: + printf("\t\toperands[%u].type: CSR = %s\n", i, getSysRegName(op->csr)); + break; } switch (op->access) { diff --git a/include/capstone/capstone.h b/include/capstone/capstone.h index aea92876c7..f321023069 100644 --- a/include/capstone/capstone.h +++ b/include/capstone/capstone.h @@ -204,11 +204,29 @@ typedef enum cs_mode { CS_MODE_M680X_CPU12 = 1 << 9, ///< M680X Motorola/Freescale/NXP CPU12 ///< used on M68HC12/HCS12 CS_MODE_M680X_HCS08 = 1 << 10, ///< M680X Freescale/NXP HCS08 mode - CS_MODE_BPF_CLASSIC = 0, ///< Classic BPF mode (default) - CS_MODE_BPF_EXTENDED = 1 << 0, ///< Extended BPF mode - CS_MODE_RISCV32 = 1 << 0, ///< RISCV RV32G - CS_MODE_RISCV64 = 1 << 1, ///< RISCV RV64G - CS_MODE_RISCVC = 1 << 2, ///< RISCV compressed instructure mode + CS_MODE_BPF_CLASSIC = 0, ///< Classic BPF mode (default) + CS_MODE_BPF_EXTENDED = 1 << 0, ///< Extended BPF mode + CS_MODE_RISCV32 = 1 << 0, ///< RISCV RV32G + CS_MODE_RISCV64 = 1 << 1, ///< RISCV RV64G + CS_MODE_RISCV_C = 1 << 2, ///< RISCV compressed instructure mode + CS_MODE_RISCV_FD = 1 << 3, + CS_MODE_RISCV_V = 1 << 4, + CS_MODE_RISCV_ZFINX = 1 << 5, + CS_MODE_RISCV_ZCMP_ZCMT_ZCE = 1 << 6, + CS_MODE_RISCV_ZICFISS = 1 << 7, + CS_MODE_RISCV_E = 1 << 8, + CS_MODE_RISCV_A = 1 << 9, + CS_MODE_RISCV_COREV = 1 << 10, + CS_MODE_RISCV_THEAD = 1 << 11, + CS_MODE_RISCV_SIFIVE = 1 << 12, + CS_MODE_RISCV_BITMANIP = 1 << 13, + CS_MODE_RISCV_ZBA = 1 << 14, + CS_MODE_RISCV_ZBB = 1 << 15, + CS_MODE_RISCV_ZBC = 1 << 16, + CS_MODE_RISCV_ZBKB = 1 << 17, + CS_MODE_RISCV_ZBKC = 1 << 18, + CS_MODE_RISCV_ZBKX = 1 << 19, + CS_MODE_RISCV_ZBS = 1 << 20, CS_MODE_MOS65XX_6502 = 1 << 1, ///< MOS65XXX MOS 6502 CS_MODE_MOS65XX_65C02 = 1 << 2, ///< MOS65XXX WDC 65c02 CS_MODE_MOS65XX_W65C02 = 1 << 3, ///< MOS65XXX WDC W65c02 @@ -340,6 +358,9 @@ typedef enum cs_opt_value { CS_OPT_SYNTAX_NO_DOLLAR = 1 << 9, ///< Does not print the $ in front of Mips, LoongArch registers. + CS_OPT_SYNTAX_NO_ALIAS_TEXT = + 1 + << 10, ///< Does not print an instruction's alias test if the instruction is an alias CS_OPT_DETAIL_REAL = 1 << 1, ///< If enabled, always sets the real instruction detail. Even if the instruction is an alias. @@ -765,7 +786,7 @@ const char *CAPSTONE_API cs_strerror(cs_err code); which complicates things. This is especially troublesome for the case @count=0, when cs_disasm() runs uncontrollably (until either end of input buffer, or when it encounters an invalid instruction). - + @handle: handle returned by cs_open() @code: buffer containing raw binary code to be disassembled. @code_size: size of the above code buffer. @@ -828,7 +849,7 @@ cs_insn *CAPSTONE_API cs_malloc(csh handle); which complicates things. This is especially troublesome for the case @count=0, when cs_disasm() runs uncontrollably (until either end of input buffer, or when it encounters an invalid instruction). - + @handle: handle returned by cs_open() @code: buffer containing raw binary code to be disassembled @size: size of above code diff --git a/include/capstone/riscv.h b/include/capstone/riscv.h index 2e67f8fb07..f8825f7654 100644 --- a/include/capstone/riscv.h +++ b/include/capstone/riscv.h @@ -21,7 +21,7 @@ extern "C" { //#undef riscv #ifdef _MSC_VER -#pragma warning(disable : 4201) +#pragma warning(disable:4201) #endif //> Operand type for instruction's operands @@ -30,25 +30,28 @@ typedef enum riscv_op_type { RISCV_OP_REG = CS_OP_REG, // = CS_OP_REG (Register operand). RISCV_OP_IMM = CS_OP_IMM, // = CS_OP_IMM (Immediate operand). RISCV_OP_MEM = CS_OP_MEM, // = CS_OP_MEM (Memory operand). + RISCV_OP_FP = CS_OP_FP, // = CS_OP_FP (FP immediate operand). + RISCV_OP_CSR = CS_OP_SPECIAL // = Control and Status Register. } riscv_op_type; // Instruction's operand referring to memory // This is associated with RISCV_OP_MEM operand type above typedef struct riscv_op_mem { - unsigned int base; // base register - int64_t disp; // displacement/offset value + unsigned int base; // base register + int64_t disp; // displacement/offset value } riscv_op_mem; // Instruction operand typedef struct cs_riscv_op { - riscv_op_type type; // operand type + riscv_op_type type; // operand type union { - unsigned int reg; // register value for REG operand - int64_t imm; // immediate value for IMM operand - riscv_op_mem mem; // base/disp value for MEM operand + unsigned int reg; // register value for REG operand + int64_t imm; // immediate value for IMM operand + double dimm; // immeidate double value for FP operands + riscv_op_mem mem; // base/disp value for MEM operand + uint16_t csr; // CSR system register (12-bit max in RISCV) }; - cs_ac_type - access; ///< How is this operand accessed? (READ, WRITE or READ|WRITE) + cs_ac_type access; ///< How is this operand accessed? (READ, WRITE or READ|WRITE) } cs_riscv_op; #define NUM_RISCV_OPS 8 @@ -65,238 +68,970 @@ typedef struct cs_riscv { //> RISCV registers typedef enum riscv_reg { - RISCV_REG_INVALID = 0, - //> General purpose registers - RISCV_REG_X0, // "zero" - RISCV_REG_ZERO = RISCV_REG_X0, // "zero" - RISCV_REG_X1, // "ra" - RISCV_REG_RA = RISCV_REG_X1, // "ra" - RISCV_REG_X2, // "sp" - RISCV_REG_SP = RISCV_REG_X2, // "sp" - RISCV_REG_X3, // "gp" - RISCV_REG_GP = RISCV_REG_X3, // "gp" - RISCV_REG_X4, // "tp" - RISCV_REG_TP = RISCV_REG_X4, // "tp" - RISCV_REG_X5, // "t0" - RISCV_REG_T0 = RISCV_REG_X5, // "t0" - RISCV_REG_X6, // "t1" - RISCV_REG_T1 = RISCV_REG_X6, // "t1" - RISCV_REG_X7, // "t2" - RISCV_REG_T2 = RISCV_REG_X7, // "t2" - RISCV_REG_X8, // "s0/fp" - RISCV_REG_S0 = RISCV_REG_X8, // "s0" - RISCV_REG_FP = RISCV_REG_X8, // "fp" - RISCV_REG_X9, // "s1" - RISCV_REG_S1 = RISCV_REG_X9, // "s1" - RISCV_REG_X10, // "a0" - RISCV_REG_A0 = RISCV_REG_X10, // "a0" - RISCV_REG_X11, // "a1" - RISCV_REG_A1 = RISCV_REG_X11, // "a1" - RISCV_REG_X12, // "a2" - RISCV_REG_A2 = RISCV_REG_X12, // "a2" - RISCV_REG_X13, // "a3" - RISCV_REG_A3 = RISCV_REG_X13, // "a3" - RISCV_REG_X14, // "a4" - RISCV_REG_A4 = RISCV_REG_X14, // "a4" - RISCV_REG_X15, // "a5" - RISCV_REG_A5 = RISCV_REG_X15, // "a5" - RISCV_REG_X16, // "a6" - RISCV_REG_A6 = RISCV_REG_X16, // "a6" - RISCV_REG_X17, // "a7" - RISCV_REG_A7 = RISCV_REG_X17, // "a7" - RISCV_REG_X18, // "s2" - RISCV_REG_S2 = RISCV_REG_X18, // "s2" - RISCV_REG_X19, // "s3" - RISCV_REG_S3 = RISCV_REG_X19, // "s3" - RISCV_REG_X20, // "s4" - RISCV_REG_S4 = RISCV_REG_X20, // "s4" - RISCV_REG_X21, // "s5" - RISCV_REG_S5 = RISCV_REG_X21, // "s5" - RISCV_REG_X22, // "s6" - RISCV_REG_S6 = RISCV_REG_X22, // "s6" - RISCV_REG_X23, // "s7" - RISCV_REG_S7 = RISCV_REG_X23, // "s7" - RISCV_REG_X24, // "s8" - RISCV_REG_S8 = RISCV_REG_X24, // "s8" - RISCV_REG_X25, // "s9" - RISCV_REG_S9 = RISCV_REG_X25, // "s9" - RISCV_REG_X26, // "s10" - RISCV_REG_S10 = RISCV_REG_X26, // "s10" - RISCV_REG_X27, // "s11" - RISCV_REG_S11 = RISCV_REG_X27, // "s11" - RISCV_REG_X28, // "t3" - RISCV_REG_T3 = RISCV_REG_X28, // "t3" - RISCV_REG_X29, // "t4" - RISCV_REG_T4 = RISCV_REG_X29, // "t4" - RISCV_REG_X30, // "t5" - RISCV_REG_T5 = RISCV_REG_X30, // "t5" - RISCV_REG_X31, // "t6" - RISCV_REG_T6 = RISCV_REG_X31, // "t6" + // generated content begin + // clang-format off - //> Floating-point registers - RISCV_REG_F0_32, // "ft0" - RISCV_REG_F0_64, // "ft0" - RISCV_REG_F1_32, // "ft1" - RISCV_REG_F1_64, // "ft1" - RISCV_REG_F2_32, // "ft2" - RISCV_REG_F2_64, // "ft2" - RISCV_REG_F3_32, // "ft3" - RISCV_REG_F3_64, // "ft3" - RISCV_REG_F4_32, // "ft4" - RISCV_REG_F4_64, // "ft4" - RISCV_REG_F5_32, // "ft5" - RISCV_REG_F5_64, // "ft5" - RISCV_REG_F6_32, // "ft6" - RISCV_REG_F6_64, // "ft6" - RISCV_REG_F7_32, // "ft7" - RISCV_REG_F7_64, // "ft7" - RISCV_REG_F8_32, // "fs0" - RISCV_REG_F8_64, // "fs0" - RISCV_REG_F9_32, // "fs1" - RISCV_REG_F9_64, // "fs1" - RISCV_REG_F10_32, // "fa0" - RISCV_REG_F10_64, // "fa0" - RISCV_REG_F11_32, // "fa1" - RISCV_REG_F11_64, // "fa1" - RISCV_REG_F12_32, // "fa2" - RISCV_REG_F12_64, // "fa2" - RISCV_REG_F13_32, // "fa3" - RISCV_REG_F13_64, // "fa3" - RISCV_REG_F14_32, // "fa4" - RISCV_REG_F14_64, // "fa4" - RISCV_REG_F15_32, // "fa5" - RISCV_REG_F15_64, // "fa5" - RISCV_REG_F16_32, // "fa6" - RISCV_REG_F16_64, // "fa6" - RISCV_REG_F17_32, // "fa7" - RISCV_REG_F17_64, // "fa7" - RISCV_REG_F18_32, // "fs2" - RISCV_REG_F18_64, // "fs2" - RISCV_REG_F19_32, // "fs3" - RISCV_REG_F19_64, // "fs3" - RISCV_REG_F20_32, // "fs4" - RISCV_REG_F20_64, // "fs4" - RISCV_REG_F21_32, // "fs5" - RISCV_REG_F21_64, // "fs5" - RISCV_REG_F22_32, // "fs6" - RISCV_REG_F22_64, // "fs6" - RISCV_REG_F23_32, // "fs7" - RISCV_REG_F23_64, // "fs7" - RISCV_REG_F24_32, // "fs8" - RISCV_REG_F24_64, // "fs8" - RISCV_REG_F25_32, // "fs9" - RISCV_REG_F25_64, // "fs9" - RISCV_REG_F26_32, // "fs10" - RISCV_REG_F26_64, // "fs10" - RISCV_REG_F27_32, // "fs11" - RISCV_REG_F27_64, // "fs11" - RISCV_REG_F28_32, // "ft8" - RISCV_REG_F28_64, // "ft8" - RISCV_REG_F29_32, // "ft9" - RISCV_REG_F29_64, // "ft9" - RISCV_REG_F30_32, // "ft10" - RISCV_REG_F30_64, // "ft10" - RISCV_REG_F31_32, // "ft11" - RISCV_REG_F31_64, // "ft11" + RISCV_REG_INVALID = 0, + RISCV_REG_FFLAGS = 1, + RISCV_REG_FRM = 2, + RISCV_REG_SSP = 3, + RISCV_REG_VL = 4, + RISCV_REG_VLENB = 5, + RISCV_REG_VTYPE = 6, + RISCV_REG_VXRM = 7, + RISCV_REG_VXSAT = 8, + RISCV_REG_DUMMY_REG_PAIR_WITH_X0 = 9, + RISCV_REG_V0 = 10, + RISCV_REG_V1 = 11, + RISCV_REG_V2 = 12, + RISCV_REG_V3 = 13, + RISCV_REG_V4 = 14, + RISCV_REG_V5 = 15, + RISCV_REG_V6 = 16, + RISCV_REG_V7 = 17, + RISCV_REG_V8 = 18, + RISCV_REG_V9 = 19, + RISCV_REG_V10 = 20, + RISCV_REG_V11 = 21, + RISCV_REG_V12 = 22, + RISCV_REG_V13 = 23, + RISCV_REG_V14 = 24, + RISCV_REG_V15 = 25, + RISCV_REG_V16 = 26, + RISCV_REG_V17 = 27, + RISCV_REG_V18 = 28, + RISCV_REG_V19 = 29, + RISCV_REG_V20 = 30, + RISCV_REG_V21 = 31, + RISCV_REG_V22 = 32, + RISCV_REG_V23 = 33, + RISCV_REG_V24 = 34, + RISCV_REG_V25 = 35, + RISCV_REG_V26 = 36, + RISCV_REG_V27 = 37, + RISCV_REG_V28 = 38, + RISCV_REG_V29 = 39, + RISCV_REG_V30 = 40, + RISCV_REG_V31 = 41, + RISCV_REG_X0 = 42, + RISCV_REG_X1 = 43, + RISCV_REG_X2 = 44, + RISCV_REG_X3 = 45, + RISCV_REG_X4 = 46, + RISCV_REG_X5 = 47, + RISCV_REG_X6 = 48, + RISCV_REG_X7 = 49, + RISCV_REG_X8 = 50, + RISCV_REG_X9 = 51, + RISCV_REG_X10 = 52, + RISCV_REG_X11 = 53, + RISCV_REG_X12 = 54, + RISCV_REG_X13 = 55, + RISCV_REG_X14 = 56, + RISCV_REG_X15 = 57, + RISCV_REG_X16 = 58, + RISCV_REG_X17 = 59, + RISCV_REG_X18 = 60, + RISCV_REG_X19 = 61, + RISCV_REG_X20 = 62, + RISCV_REG_X21 = 63, + RISCV_REG_X22 = 64, + RISCV_REG_X23 = 65, + RISCV_REG_X24 = 66, + RISCV_REG_X25 = 67, + RISCV_REG_X26 = 68, + RISCV_REG_X27 = 69, + RISCV_REG_X28 = 70, + RISCV_REG_X29 = 71, + RISCV_REG_X30 = 72, + RISCV_REG_X31 = 73, + RISCV_REG_F0_D = 74, + RISCV_REG_F1_D = 75, + RISCV_REG_F2_D = 76, + RISCV_REG_F3_D = 77, + RISCV_REG_F4_D = 78, + RISCV_REG_F5_D = 79, + RISCV_REG_F6_D = 80, + RISCV_REG_F7_D = 81, + RISCV_REG_F8_D = 82, + RISCV_REG_F9_D = 83, + RISCV_REG_F10_D = 84, + RISCV_REG_F11_D = 85, + RISCV_REG_F12_D = 86, + RISCV_REG_F13_D = 87, + RISCV_REG_F14_D = 88, + RISCV_REG_F15_D = 89, + RISCV_REG_F16_D = 90, + RISCV_REG_F17_D = 91, + RISCV_REG_F18_D = 92, + RISCV_REG_F19_D = 93, + RISCV_REG_F20_D = 94, + RISCV_REG_F21_D = 95, + RISCV_REG_F22_D = 96, + RISCV_REG_F23_D = 97, + RISCV_REG_F24_D = 98, + RISCV_REG_F25_D = 99, + RISCV_REG_F26_D = 100, + RISCV_REG_F27_D = 101, + RISCV_REG_F28_D = 102, + RISCV_REG_F29_D = 103, + RISCV_REG_F30_D = 104, + RISCV_REG_F31_D = 105, + RISCV_REG_F0_F = 106, + RISCV_REG_F1_F = 107, + RISCV_REG_F2_F = 108, + RISCV_REG_F3_F = 109, + RISCV_REG_F4_F = 110, + RISCV_REG_F5_F = 111, + RISCV_REG_F6_F = 112, + RISCV_REG_F7_F = 113, + RISCV_REG_F8_F = 114, + RISCV_REG_F9_F = 115, + RISCV_REG_F10_F = 116, + RISCV_REG_F11_F = 117, + RISCV_REG_F12_F = 118, + RISCV_REG_F13_F = 119, + RISCV_REG_F14_F = 120, + RISCV_REG_F15_F = 121, + RISCV_REG_F16_F = 122, + RISCV_REG_F17_F = 123, + RISCV_REG_F18_F = 124, + RISCV_REG_F19_F = 125, + RISCV_REG_F20_F = 126, + RISCV_REG_F21_F = 127, + RISCV_REG_F22_F = 128, + RISCV_REG_F23_F = 129, + RISCV_REG_F24_F = 130, + RISCV_REG_F25_F = 131, + RISCV_REG_F26_F = 132, + RISCV_REG_F27_F = 133, + RISCV_REG_F28_F = 134, + RISCV_REG_F29_F = 135, + RISCV_REG_F30_F = 136, + RISCV_REG_F31_F = 137, + RISCV_REG_F0_H = 138, + RISCV_REG_F1_H = 139, + RISCV_REG_F2_H = 140, + RISCV_REG_F3_H = 141, + RISCV_REG_F4_H = 142, + RISCV_REG_F5_H = 143, + RISCV_REG_F6_H = 144, + RISCV_REG_F7_H = 145, + RISCV_REG_F8_H = 146, + RISCV_REG_F9_H = 147, + RISCV_REG_F10_H = 148, + RISCV_REG_F11_H = 149, + RISCV_REG_F12_H = 150, + RISCV_REG_F13_H = 151, + RISCV_REG_F14_H = 152, + RISCV_REG_F15_H = 153, + RISCV_REG_F16_H = 154, + RISCV_REG_F17_H = 155, + RISCV_REG_F18_H = 156, + RISCV_REG_F19_H = 157, + RISCV_REG_F20_H = 158, + RISCV_REG_F21_H = 159, + RISCV_REG_F22_H = 160, + RISCV_REG_F23_H = 161, + RISCV_REG_F24_H = 162, + RISCV_REG_F25_H = 163, + RISCV_REG_F26_H = 164, + RISCV_REG_F27_H = 165, + RISCV_REG_F28_H = 166, + RISCV_REG_F29_H = 167, + RISCV_REG_F30_H = 168, + RISCV_REG_F31_H = 169, + RISCV_REG_X0_PAIR = 170, + RISCV_REG_V0M2 = 171, + RISCV_REG_V0M4 = 172, + RISCV_REG_V0M8 = 173, + RISCV_REG_V2M2 = 174, + RISCV_REG_V4M2 = 175, + RISCV_REG_V4M4 = 176, + RISCV_REG_V6M2 = 177, + RISCV_REG_V8M2 = 178, + RISCV_REG_V8M4 = 179, + RISCV_REG_V8M8 = 180, + RISCV_REG_V10M2 = 181, + RISCV_REG_V12M2 = 182, + RISCV_REG_V12M4 = 183, + RISCV_REG_V14M2 = 184, + RISCV_REG_V16M2 = 185, + RISCV_REG_V16M4 = 186, + RISCV_REG_V16M8 = 187, + RISCV_REG_V18M2 = 188, + RISCV_REG_V20M2 = 189, + RISCV_REG_V20M4 = 190, + RISCV_REG_V22M2 = 191, + RISCV_REG_V24M2 = 192, + RISCV_REG_V24M4 = 193, + RISCV_REG_V24M8 = 194, + RISCV_REG_V26M2 = 195, + RISCV_REG_V28M2 = 196, + RISCV_REG_V28M4 = 197, + RISCV_REG_V30M2 = 198, + RISCV_REG_X2_X3 = 199, + RISCV_REG_X4_X5 = 200, + RISCV_REG_X6_X7 = 201, + RISCV_REG_X8_X9 = 202, + RISCV_REG_X10_X11 = 203, + RISCV_REG_X12_X13 = 204, + RISCV_REG_X14_X15 = 205, + RISCV_REG_X16_X17 = 206, + RISCV_REG_X18_X19 = 207, + RISCV_REG_X20_X21 = 208, + RISCV_REG_X22_X23 = 209, + RISCV_REG_X24_X25 = 210, + RISCV_REG_X26_X27 = 211, + RISCV_REG_X28_X29 = 212, + RISCV_REG_X30_X31 = 213, + RISCV_REG_V1_V2 = 214, + RISCV_REG_V2_V3 = 215, + RISCV_REG_V3_V4 = 216, + RISCV_REG_V4_V5 = 217, + RISCV_REG_V5_V6 = 218, + RISCV_REG_V6_V7 = 219, + RISCV_REG_V7_V8 = 220, + RISCV_REG_V8_V9 = 221, + RISCV_REG_V9_V10 = 222, + RISCV_REG_V10_V11 = 223, + RISCV_REG_V11_V12 = 224, + RISCV_REG_V12_V13 = 225, + RISCV_REG_V13_V14 = 226, + RISCV_REG_V14_V15 = 227, + RISCV_REG_V15_V16 = 228, + RISCV_REG_V16_V17 = 229, + RISCV_REG_V17_V18 = 230, + RISCV_REG_V18_V19 = 231, + RISCV_REG_V19_V20 = 232, + RISCV_REG_V20_V21 = 233, + RISCV_REG_V21_V22 = 234, + RISCV_REG_V22_V23 = 235, + RISCV_REG_V23_V24 = 236, + RISCV_REG_V24_V25 = 237, + RISCV_REG_V25_V26 = 238, + RISCV_REG_V26_V27 = 239, + RISCV_REG_V27_V28 = 240, + RISCV_REG_V28_V29 = 241, + RISCV_REG_V29_V30 = 242, + RISCV_REG_V30_V31 = 243, + RISCV_REG_V0_V1 = 244, + RISCV_REG_V2M2_V4M2 = 245, + RISCV_REG_V4M2_V6M2 = 246, + RISCV_REG_V6M2_V8M2 = 247, + RISCV_REG_V8M2_V10M2 = 248, + RISCV_REG_V10M2_V12M2 = 249, + RISCV_REG_V12M2_V14M2 = 250, + RISCV_REG_V14M2_V16M2 = 251, + RISCV_REG_V16M2_V18M2 = 252, + RISCV_REG_V18M2_V20M2 = 253, + RISCV_REG_V20M2_V22M2 = 254, + RISCV_REG_V22M2_V24M2 = 255, + RISCV_REG_V24M2_V26M2 = 256, + RISCV_REG_V26M2_V28M2 = 257, + RISCV_REG_V28M2_V30M2 = 258, + RISCV_REG_V0M2_V2M2 = 259, + RISCV_REG_V4M4_V8M4 = 260, + RISCV_REG_V8M4_V12M4 = 261, + RISCV_REG_V12M4_V16M4 = 262, + RISCV_REG_V16M4_V20M4 = 263, + RISCV_REG_V20M4_V24M4 = 264, + RISCV_REG_V24M4_V28M4 = 265, + RISCV_REG_V0M4_V4M4 = 266, + RISCV_REG_V1_V2_V3 = 267, + RISCV_REG_V2_V3_V4 = 268, + RISCV_REG_V3_V4_V5 = 269, + RISCV_REG_V4_V5_V6 = 270, + RISCV_REG_V5_V6_V7 = 271, + RISCV_REG_V6_V7_V8 = 272, + RISCV_REG_V7_V8_V9 = 273, + RISCV_REG_V8_V9_V10 = 274, + RISCV_REG_V9_V10_V11 = 275, + RISCV_REG_V10_V11_V12 = 276, + RISCV_REG_V11_V12_V13 = 277, + RISCV_REG_V12_V13_V14 = 278, + RISCV_REG_V13_V14_V15 = 279, + RISCV_REG_V14_V15_V16 = 280, + RISCV_REG_V15_V16_V17 = 281, + RISCV_REG_V16_V17_V18 = 282, + RISCV_REG_V17_V18_V19 = 283, + RISCV_REG_V18_V19_V20 = 284, + RISCV_REG_V19_V20_V21 = 285, + RISCV_REG_V20_V21_V22 = 286, + RISCV_REG_V21_V22_V23 = 287, + RISCV_REG_V22_V23_V24 = 288, + RISCV_REG_V23_V24_V25 = 289, + RISCV_REG_V24_V25_V26 = 290, + RISCV_REG_V25_V26_V27 = 291, + RISCV_REG_V26_V27_V28 = 292, + RISCV_REG_V27_V28_V29 = 293, + RISCV_REG_V28_V29_V30 = 294, + RISCV_REG_V29_V30_V31 = 295, + RISCV_REG_V0_V1_V2 = 296, + RISCV_REG_V2M2_V4M2_V6M2 = 297, + RISCV_REG_V4M2_V6M2_V8M2 = 298, + RISCV_REG_V6M2_V8M2_V10M2 = 299, + RISCV_REG_V8M2_V10M2_V12M2 = 300, + RISCV_REG_V10M2_V12M2_V14M2 = 301, + RISCV_REG_V12M2_V14M2_V16M2 = 302, + RISCV_REG_V14M2_V16M2_V18M2 = 303, + RISCV_REG_V16M2_V18M2_V20M2 = 304, + RISCV_REG_V18M2_V20M2_V22M2 = 305, + RISCV_REG_V20M2_V22M2_V24M2 = 306, + RISCV_REG_V22M2_V24M2_V26M2 = 307, + RISCV_REG_V24M2_V26M2_V28M2 = 308, + RISCV_REG_V26M2_V28M2_V30M2 = 309, + RISCV_REG_V0M2_V2M2_V4M2 = 310, + RISCV_REG_V1_V2_V3_V4 = 311, + RISCV_REG_V2_V3_V4_V5 = 312, + RISCV_REG_V3_V4_V5_V6 = 313, + RISCV_REG_V4_V5_V6_V7 = 314, + RISCV_REG_V5_V6_V7_V8 = 315, + RISCV_REG_V6_V7_V8_V9 = 316, + RISCV_REG_V7_V8_V9_V10 = 317, + RISCV_REG_V8_V9_V10_V11 = 318, + RISCV_REG_V9_V10_V11_V12 = 319, + RISCV_REG_V10_V11_V12_V13 = 320, + RISCV_REG_V11_V12_V13_V14 = 321, + RISCV_REG_V12_V13_V14_V15 = 322, + RISCV_REG_V13_V14_V15_V16 = 323, + RISCV_REG_V14_V15_V16_V17 = 324, + RISCV_REG_V15_V16_V17_V18 = 325, + RISCV_REG_V16_V17_V18_V19 = 326, + RISCV_REG_V17_V18_V19_V20 = 327, + RISCV_REG_V18_V19_V20_V21 = 328, + RISCV_REG_V19_V20_V21_V22 = 329, + RISCV_REG_V20_V21_V22_V23 = 330, + RISCV_REG_V21_V22_V23_V24 = 331, + RISCV_REG_V22_V23_V24_V25 = 332, + RISCV_REG_V23_V24_V25_V26 = 333, + RISCV_REG_V24_V25_V26_V27 = 334, + RISCV_REG_V25_V26_V27_V28 = 335, + RISCV_REG_V26_V27_V28_V29 = 336, + RISCV_REG_V27_V28_V29_V30 = 337, + RISCV_REG_V28_V29_V30_V31 = 338, + RISCV_REG_V0_V1_V2_V3 = 339, + RISCV_REG_V2M2_V4M2_V6M2_V8M2 = 340, + RISCV_REG_V4M2_V6M2_V8M2_V10M2 = 341, + RISCV_REG_V6M2_V8M2_V10M2_V12M2 = 342, + RISCV_REG_V8M2_V10M2_V12M2_V14M2 = 343, + RISCV_REG_V10M2_V12M2_V14M2_V16M2 = 344, + RISCV_REG_V12M2_V14M2_V16M2_V18M2 = 345, + RISCV_REG_V14M2_V16M2_V18M2_V20M2 = 346, + RISCV_REG_V16M2_V18M2_V20M2_V22M2 = 347, + RISCV_REG_V18M2_V20M2_V22M2_V24M2 = 348, + RISCV_REG_V20M2_V22M2_V24M2_V26M2 = 349, + RISCV_REG_V22M2_V24M2_V26M2_V28M2 = 350, + RISCV_REG_V24M2_V26M2_V28M2_V30M2 = 351, + RISCV_REG_V0M2_V2M2_V4M2_V6M2 = 352, + RISCV_REG_V1_V2_V3_V4_V5 = 353, + RISCV_REG_V2_V3_V4_V5_V6 = 354, + RISCV_REG_V3_V4_V5_V6_V7 = 355, + RISCV_REG_V4_V5_V6_V7_V8 = 356, + RISCV_REG_V5_V6_V7_V8_V9 = 357, + RISCV_REG_V6_V7_V8_V9_V10 = 358, + RISCV_REG_V7_V8_V9_V10_V11 = 359, + RISCV_REG_V8_V9_V10_V11_V12 = 360, + RISCV_REG_V9_V10_V11_V12_V13 = 361, + RISCV_REG_V10_V11_V12_V13_V14 = 362, + RISCV_REG_V11_V12_V13_V14_V15 = 363, + RISCV_REG_V12_V13_V14_V15_V16 = 364, + RISCV_REG_V13_V14_V15_V16_V17 = 365, + RISCV_REG_V14_V15_V16_V17_V18 = 366, + RISCV_REG_V15_V16_V17_V18_V19 = 367, + RISCV_REG_V16_V17_V18_V19_V20 = 368, + RISCV_REG_V17_V18_V19_V20_V21 = 369, + RISCV_REG_V18_V19_V20_V21_V22 = 370, + RISCV_REG_V19_V20_V21_V22_V23 = 371, + RISCV_REG_V20_V21_V22_V23_V24 = 372, + RISCV_REG_V21_V22_V23_V24_V25 = 373, + RISCV_REG_V22_V23_V24_V25_V26 = 374, + RISCV_REG_V23_V24_V25_V26_V27 = 375, + RISCV_REG_V24_V25_V26_V27_V28 = 376, + RISCV_REG_V25_V26_V27_V28_V29 = 377, + RISCV_REG_V26_V27_V28_V29_V30 = 378, + RISCV_REG_V27_V28_V29_V30_V31 = 379, + RISCV_REG_V0_V1_V2_V3_V4 = 380, + RISCV_REG_V1_V2_V3_V4_V5_V6 = 381, + RISCV_REG_V2_V3_V4_V5_V6_V7 = 382, + RISCV_REG_V3_V4_V5_V6_V7_V8 = 383, + RISCV_REG_V4_V5_V6_V7_V8_V9 = 384, + RISCV_REG_V5_V6_V7_V8_V9_V10 = 385, + RISCV_REG_V6_V7_V8_V9_V10_V11 = 386, + RISCV_REG_V7_V8_V9_V10_V11_V12 = 387, + RISCV_REG_V8_V9_V10_V11_V12_V13 = 388, + RISCV_REG_V9_V10_V11_V12_V13_V14 = 389, + RISCV_REG_V10_V11_V12_V13_V14_V15 = 390, + RISCV_REG_V11_V12_V13_V14_V15_V16 = 391, + RISCV_REG_V12_V13_V14_V15_V16_V17 = 392, + RISCV_REG_V13_V14_V15_V16_V17_V18 = 393, + RISCV_REG_V14_V15_V16_V17_V18_V19 = 394, + RISCV_REG_V15_V16_V17_V18_V19_V20 = 395, + RISCV_REG_V16_V17_V18_V19_V20_V21 = 396, + RISCV_REG_V17_V18_V19_V20_V21_V22 = 397, + RISCV_REG_V18_V19_V20_V21_V22_V23 = 398, + RISCV_REG_V19_V20_V21_V22_V23_V24 = 399, + RISCV_REG_V20_V21_V22_V23_V24_V25 = 400, + RISCV_REG_V21_V22_V23_V24_V25_V26 = 401, + RISCV_REG_V22_V23_V24_V25_V26_V27 = 402, + RISCV_REG_V23_V24_V25_V26_V27_V28 = 403, + RISCV_REG_V24_V25_V26_V27_V28_V29 = 404, + RISCV_REG_V25_V26_V27_V28_V29_V30 = 405, + RISCV_REG_V26_V27_V28_V29_V30_V31 = 406, + RISCV_REG_V0_V1_V2_V3_V4_V5 = 407, + RISCV_REG_V1_V2_V3_V4_V5_V6_V7 = 408, + RISCV_REG_V2_V3_V4_V5_V6_V7_V8 = 409, + RISCV_REG_V3_V4_V5_V6_V7_V8_V9 = 410, + RISCV_REG_V4_V5_V6_V7_V8_V9_V10 = 411, + RISCV_REG_V5_V6_V7_V8_V9_V10_V11 = 412, + RISCV_REG_V6_V7_V8_V9_V10_V11_V12 = 413, + RISCV_REG_V7_V8_V9_V10_V11_V12_V13 = 414, + RISCV_REG_V8_V9_V10_V11_V12_V13_V14 = 415, + RISCV_REG_V9_V10_V11_V12_V13_V14_V15 = 416, + RISCV_REG_V10_V11_V12_V13_V14_V15_V16 = 417, + RISCV_REG_V11_V12_V13_V14_V15_V16_V17 = 418, + RISCV_REG_V12_V13_V14_V15_V16_V17_V18 = 419, + RISCV_REG_V13_V14_V15_V16_V17_V18_V19 = 420, + RISCV_REG_V14_V15_V16_V17_V18_V19_V20 = 421, + RISCV_REG_V15_V16_V17_V18_V19_V20_V21 = 422, + RISCV_REG_V16_V17_V18_V19_V20_V21_V22 = 423, + RISCV_REG_V17_V18_V19_V20_V21_V22_V23 = 424, + RISCV_REG_V18_V19_V20_V21_V22_V23_V24 = 425, + RISCV_REG_V19_V20_V21_V22_V23_V24_V25 = 426, + RISCV_REG_V20_V21_V22_V23_V24_V25_V26 = 427, + RISCV_REG_V21_V22_V23_V24_V25_V26_V27 = 428, + RISCV_REG_V22_V23_V24_V25_V26_V27_V28 = 429, + RISCV_REG_V23_V24_V25_V26_V27_V28_V29 = 430, + RISCV_REG_V24_V25_V26_V27_V28_V29_V30 = 431, + RISCV_REG_V25_V26_V27_V28_V29_V30_V31 = 432, + RISCV_REG_V0_V1_V2_V3_V4_V5_V6 = 433, + RISCV_REG_V1_V2_V3_V4_V5_V6_V7_V8 = 434, + RISCV_REG_V2_V3_V4_V5_V6_V7_V8_V9 = 435, + RISCV_REG_V3_V4_V5_V6_V7_V8_V9_V10 = 436, + RISCV_REG_V4_V5_V6_V7_V8_V9_V10_V11 = 437, + RISCV_REG_V5_V6_V7_V8_V9_V10_V11_V12 = 438, + RISCV_REG_V6_V7_V8_V9_V10_V11_V12_V13 = 439, + RISCV_REG_V7_V8_V9_V10_V11_V12_V13_V14 = 440, + RISCV_REG_V8_V9_V10_V11_V12_V13_V14_V15 = 441, + RISCV_REG_V9_V10_V11_V12_V13_V14_V15_V16 = 442, + RISCV_REG_V10_V11_V12_V13_V14_V15_V16_V17 = 443, + RISCV_REG_V11_V12_V13_V14_V15_V16_V17_V18 = 444, + RISCV_REG_V12_V13_V14_V15_V16_V17_V18_V19 = 445, + RISCV_REG_V13_V14_V15_V16_V17_V18_V19_V20 = 446, + RISCV_REG_V14_V15_V16_V17_V18_V19_V20_V21 = 447, + RISCV_REG_V15_V16_V17_V18_V19_V20_V21_V22 = 448, + RISCV_REG_V16_V17_V18_V19_V20_V21_V22_V23 = 449, + RISCV_REG_V17_V18_V19_V20_V21_V22_V23_V24 = 450, + RISCV_REG_V18_V19_V20_V21_V22_V23_V24_V25 = 451, + RISCV_REG_V19_V20_V21_V22_V23_V24_V25_V26 = 452, + RISCV_REG_V20_V21_V22_V23_V24_V25_V26_V27 = 453, + RISCV_REG_V21_V22_V23_V24_V25_V26_V27_V28 = 454, + RISCV_REG_V22_V23_V24_V25_V26_V27_V28_V29 = 455, + RISCV_REG_V23_V24_V25_V26_V27_V28_V29_V30 = 456, + RISCV_REG_V24_V25_V26_V27_V28_V29_V30_V31 = 457, + RISCV_REG_V0_V1_V2_V3_V4_V5_V6_V7 = 458, + RISCV_REG_ENDING, // 459 - RISCV_REG_ENDING, // <-- mark the end of the list or registers + // clang-format on + // generated content end } riscv_reg; //> RISCV instruction typedef enum riscv_insn { - RISCV_INS_INVALID = 0, + // generated content begin + // clang-format off + RISCV_INS_INVALID, RISCV_INS_ADD, + RISCV_INS_CALL, + RISCV_INS_FLD, + RISCV_INS_FLH, + RISCV_INS_FLW, + RISCV_INS_FSD, + RISCV_INS_FSH, + RISCV_INS_FSW, + RISCV_INS_JUMP, + RISCV_INS_LA, + RISCV_INS_LA_TLSDESC, + RISCV_INS_LA_TLS_GD, + RISCV_INS_LA_TLS_IE, + RISCV_INS_LB, + RISCV_INS_LBU, + RISCV_INS_LD, + RISCV_INS_LGA, + RISCV_INS_LH, + RISCV_INS_LHU, + RISCV_INS_LI, + RISCV_INS_LLA, + RISCV_INS_LW, + RISCV_INS_LWU, + RISCV_INS_SB, + RISCV_INS_SD, + RISCV_INS_SEXT_B, + RISCV_INS_SEXT_H, + RISCV_INS_SH, + RISCV_INS_SW, + RISCV_INS_TAIL, + RISCV_INS_JALR, + RISCV_INS_VMSGEU_VI, + RISCV_INS_VMSGEU_VX, + RISCV_INS_VMSGE_VI, + RISCV_INS_VMSGE_VX, + RISCV_INS_VMSLTU_VI, + RISCV_INS_VMSLT_VI, + RISCV_INS_ZEXT_H, + RISCV_INS_ZEXT_W, RISCV_INS_ADDI, RISCV_INS_ADDIW, RISCV_INS_ADDW, + RISCV_INS_ADD_UW, + RISCV_INS_AES32DSI, + RISCV_INS_AES32DSMI, + RISCV_INS_AES32ESI, + RISCV_INS_AES32ESMI, + RISCV_INS_AES64DS, + RISCV_INS_AES64DSM, + RISCV_INS_AES64ES, + RISCV_INS_AES64ESM, + RISCV_INS_AES64IM, + RISCV_INS_AES64KS1I, + RISCV_INS_AES64KS2, RISCV_INS_AMOADD_D, RISCV_INS_AMOADD_D_AQ, - RISCV_INS_AMOADD_D_AQ_RL, + RISCV_INS_AMOADD_D_AQRL, RISCV_INS_AMOADD_D_RL, RISCV_INS_AMOADD_W, RISCV_INS_AMOADD_W_AQ, - RISCV_INS_AMOADD_W_AQ_RL, + RISCV_INS_AMOADD_W_AQRL, RISCV_INS_AMOADD_W_RL, RISCV_INS_AMOAND_D, RISCV_INS_AMOAND_D_AQ, - RISCV_INS_AMOAND_D_AQ_RL, + RISCV_INS_AMOAND_D_AQRL, RISCV_INS_AMOAND_D_RL, RISCV_INS_AMOAND_W, RISCV_INS_AMOAND_W_AQ, - RISCV_INS_AMOAND_W_AQ_RL, + RISCV_INS_AMOAND_W_AQRL, RISCV_INS_AMOAND_W_RL, + RISCV_INS_AMOCAS_D, + RISCV_INS_AMOCAS_D_AQ, + RISCV_INS_AMOCAS_D_AQRL, + RISCV_INS_AMOCAS_D_RL, + RISCV_INS_AMOCAS_Q, + RISCV_INS_AMOCAS_Q_AQ, + RISCV_INS_AMOCAS_Q_AQRL, + RISCV_INS_AMOCAS_Q_RL, + RISCV_INS_AMOCAS_W, + RISCV_INS_AMOCAS_W_AQ, + RISCV_INS_AMOCAS_W_AQRL, + RISCV_INS_AMOCAS_W_RL, RISCV_INS_AMOMAXU_D, RISCV_INS_AMOMAXU_D_AQ, - RISCV_INS_AMOMAXU_D_AQ_RL, + RISCV_INS_AMOMAXU_D_AQRL, RISCV_INS_AMOMAXU_D_RL, RISCV_INS_AMOMAXU_W, RISCV_INS_AMOMAXU_W_AQ, - RISCV_INS_AMOMAXU_W_AQ_RL, + RISCV_INS_AMOMAXU_W_AQRL, RISCV_INS_AMOMAXU_W_RL, RISCV_INS_AMOMAX_D, RISCV_INS_AMOMAX_D_AQ, - RISCV_INS_AMOMAX_D_AQ_RL, + RISCV_INS_AMOMAX_D_AQRL, RISCV_INS_AMOMAX_D_RL, RISCV_INS_AMOMAX_W, RISCV_INS_AMOMAX_W_AQ, - RISCV_INS_AMOMAX_W_AQ_RL, + RISCV_INS_AMOMAX_W_AQRL, RISCV_INS_AMOMAX_W_RL, RISCV_INS_AMOMINU_D, RISCV_INS_AMOMINU_D_AQ, - RISCV_INS_AMOMINU_D_AQ_RL, + RISCV_INS_AMOMINU_D_AQRL, RISCV_INS_AMOMINU_D_RL, RISCV_INS_AMOMINU_W, RISCV_INS_AMOMINU_W_AQ, - RISCV_INS_AMOMINU_W_AQ_RL, + RISCV_INS_AMOMINU_W_AQRL, RISCV_INS_AMOMINU_W_RL, RISCV_INS_AMOMIN_D, RISCV_INS_AMOMIN_D_AQ, - RISCV_INS_AMOMIN_D_AQ_RL, + RISCV_INS_AMOMIN_D_AQRL, RISCV_INS_AMOMIN_D_RL, RISCV_INS_AMOMIN_W, RISCV_INS_AMOMIN_W_AQ, - RISCV_INS_AMOMIN_W_AQ_RL, + RISCV_INS_AMOMIN_W_AQRL, RISCV_INS_AMOMIN_W_RL, RISCV_INS_AMOOR_D, RISCV_INS_AMOOR_D_AQ, - RISCV_INS_AMOOR_D_AQ_RL, + RISCV_INS_AMOOR_D_AQRL, RISCV_INS_AMOOR_D_RL, RISCV_INS_AMOOR_W, RISCV_INS_AMOOR_W_AQ, - RISCV_INS_AMOOR_W_AQ_RL, + RISCV_INS_AMOOR_W_AQRL, RISCV_INS_AMOOR_W_RL, RISCV_INS_AMOSWAP_D, RISCV_INS_AMOSWAP_D_AQ, - RISCV_INS_AMOSWAP_D_AQ_RL, + RISCV_INS_AMOSWAP_D_AQRL, RISCV_INS_AMOSWAP_D_RL, RISCV_INS_AMOSWAP_W, RISCV_INS_AMOSWAP_W_AQ, - RISCV_INS_AMOSWAP_W_AQ_RL, + RISCV_INS_AMOSWAP_W_AQRL, RISCV_INS_AMOSWAP_W_RL, RISCV_INS_AMOXOR_D, RISCV_INS_AMOXOR_D_AQ, - RISCV_INS_AMOXOR_D_AQ_RL, + RISCV_INS_AMOXOR_D_AQRL, RISCV_INS_AMOXOR_D_RL, RISCV_INS_AMOXOR_W, RISCV_INS_AMOXOR_W_AQ, - RISCV_INS_AMOXOR_W_AQ_RL, + RISCV_INS_AMOXOR_W_AQRL, RISCV_INS_AMOXOR_W_RL, RISCV_INS_AND, RISCV_INS_ANDI, + RISCV_INS_ANDN, RISCV_INS_AUIPC, + RISCV_INS_BCLR, + RISCV_INS_BCLRI, RISCV_INS_BEQ, + RISCV_INS_BEXT, + RISCV_INS_BEXTI, RISCV_INS_BGE, RISCV_INS_BGEU, + RISCV_INS_BINV, + RISCV_INS_BINVI, RISCV_INS_BLT, RISCV_INS_BLTU, RISCV_INS_BNE, + RISCV_INS_BREV8, + RISCV_INS_BSET, + RISCV_INS_BSETI, + RISCV_INS_CBO_CLEAN, + RISCV_INS_CBO_FLUSH, + RISCV_INS_CBO_INVAL, + RISCV_INS_CBO_ZERO, + RISCV_INS_CLMUL, + RISCV_INS_CLMULH, + RISCV_INS_CLMULR, + RISCV_INS_CLZ, + RISCV_INS_CLZW, + RISCV_INS_CMOP_1, + RISCV_INS_CMOP_11, + RISCV_INS_CMOP_13, + RISCV_INS_CMOP_15, + RISCV_INS_CMOP_3, + RISCV_INS_CMOP_5, + RISCV_INS_CMOP_7, + RISCV_INS_CMOP_9, + RISCV_INS_CM_JALT, + RISCV_INS_CM_JT, + RISCV_INS_CM_MVA01S, + RISCV_INS_CM_MVSA01, + RISCV_INS_CM_POP, + RISCV_INS_CM_POPRET, + RISCV_INS_CM_POPRETZ, + RISCV_INS_CM_PUSH, + RISCV_INS_CPOP, + RISCV_INS_CPOPW, RISCV_INS_CSRRC, RISCV_INS_CSRRCI, RISCV_INS_CSRRS, RISCV_INS_CSRRSI, RISCV_INS_CSRRW, RISCV_INS_CSRRWI, + RISCV_INS_CTZ, + RISCV_INS_CTZW, + RISCV_INS_CV_ABS, + RISCV_INS_CV_ABS_B, + RISCV_INS_CV_ABS_H, + RISCV_INS_CV_ADDN, + RISCV_INS_CV_ADDNR, + RISCV_INS_CV_ADDRN, + RISCV_INS_CV_ADDRNR, + RISCV_INS_CV_ADDUN, + RISCV_INS_CV_ADDUNR, + RISCV_INS_CV_ADDURN, + RISCV_INS_CV_ADDURNR, + RISCV_INS_CV_ADD_B, + RISCV_INS_CV_ADD_DIV2, + RISCV_INS_CV_ADD_DIV4, + RISCV_INS_CV_ADD_DIV8, + RISCV_INS_CV_ADD_H, + RISCV_INS_CV_ADD_SCI_B, + RISCV_INS_CV_ADD_SCI_H, + RISCV_INS_CV_ADD_SC_B, + RISCV_INS_CV_ADD_SC_H, + RISCV_INS_CV_AND_B, + RISCV_INS_CV_AND_H, + RISCV_INS_CV_AND_SCI_B, + RISCV_INS_CV_AND_SCI_H, + RISCV_INS_CV_AND_SC_B, + RISCV_INS_CV_AND_SC_H, + RISCV_INS_CV_AVGU_B, + RISCV_INS_CV_AVGU_H, + RISCV_INS_CV_AVGU_SCI_B, + RISCV_INS_CV_AVGU_SCI_H, + RISCV_INS_CV_AVGU_SC_B, + RISCV_INS_CV_AVGU_SC_H, + RISCV_INS_CV_AVG_B, + RISCV_INS_CV_AVG_H, + RISCV_INS_CV_AVG_SCI_B, + RISCV_INS_CV_AVG_SCI_H, + RISCV_INS_CV_AVG_SC_B, + RISCV_INS_CV_AVG_SC_H, + RISCV_INS_CV_BCLR, + RISCV_INS_CV_BCLRR, + RISCV_INS_CV_BEQIMM, + RISCV_INS_CV_BITREV, + RISCV_INS_CV_BNEIMM, + RISCV_INS_CV_BSET, + RISCV_INS_CV_BSETR, + RISCV_INS_CV_CLB, + RISCV_INS_CV_CLIP, + RISCV_INS_CV_CLIPR, + RISCV_INS_CV_CLIPU, + RISCV_INS_CV_CLIPUR, + RISCV_INS_CV_CMPEQ_B, + RISCV_INS_CV_CMPEQ_H, + RISCV_INS_CV_CMPEQ_SCI_B, + RISCV_INS_CV_CMPEQ_SCI_H, + RISCV_INS_CV_CMPEQ_SC_B, + RISCV_INS_CV_CMPEQ_SC_H, + RISCV_INS_CV_CMPGEU_B, + RISCV_INS_CV_CMPGEU_H, + RISCV_INS_CV_CMPGEU_SCI_B, + RISCV_INS_CV_CMPGEU_SCI_H, + RISCV_INS_CV_CMPGEU_SC_B, + RISCV_INS_CV_CMPGEU_SC_H, + RISCV_INS_CV_CMPGE_B, + RISCV_INS_CV_CMPGE_H, + RISCV_INS_CV_CMPGE_SCI_B, + RISCV_INS_CV_CMPGE_SCI_H, + RISCV_INS_CV_CMPGE_SC_B, + RISCV_INS_CV_CMPGE_SC_H, + RISCV_INS_CV_CMPGTU_B, + RISCV_INS_CV_CMPGTU_H, + RISCV_INS_CV_CMPGTU_SCI_B, + RISCV_INS_CV_CMPGTU_SCI_H, + RISCV_INS_CV_CMPGTU_SC_B, + RISCV_INS_CV_CMPGTU_SC_H, + RISCV_INS_CV_CMPGT_B, + RISCV_INS_CV_CMPGT_H, + RISCV_INS_CV_CMPGT_SCI_B, + RISCV_INS_CV_CMPGT_SCI_H, + RISCV_INS_CV_CMPGT_SC_B, + RISCV_INS_CV_CMPGT_SC_H, + RISCV_INS_CV_CMPLEU_B, + RISCV_INS_CV_CMPLEU_H, + RISCV_INS_CV_CMPLEU_SCI_B, + RISCV_INS_CV_CMPLEU_SCI_H, + RISCV_INS_CV_CMPLEU_SC_B, + RISCV_INS_CV_CMPLEU_SC_H, + RISCV_INS_CV_CMPLE_B, + RISCV_INS_CV_CMPLE_H, + RISCV_INS_CV_CMPLE_SCI_B, + RISCV_INS_CV_CMPLE_SCI_H, + RISCV_INS_CV_CMPLE_SC_B, + RISCV_INS_CV_CMPLE_SC_H, + RISCV_INS_CV_CMPLTU_B, + RISCV_INS_CV_CMPLTU_H, + RISCV_INS_CV_CMPLTU_SCI_B, + RISCV_INS_CV_CMPLTU_SCI_H, + RISCV_INS_CV_CMPLTU_SC_B, + RISCV_INS_CV_CMPLTU_SC_H, + RISCV_INS_CV_CMPLT_B, + RISCV_INS_CV_CMPLT_H, + RISCV_INS_CV_CMPLT_SCI_B, + RISCV_INS_CV_CMPLT_SCI_H, + RISCV_INS_CV_CMPLT_SC_B, + RISCV_INS_CV_CMPLT_SC_H, + RISCV_INS_CV_CMPNE_B, + RISCV_INS_CV_CMPNE_H, + RISCV_INS_CV_CMPNE_SCI_B, + RISCV_INS_CV_CMPNE_SCI_H, + RISCV_INS_CV_CMPNE_SC_B, + RISCV_INS_CV_CMPNE_SC_H, + RISCV_INS_CV_CNT, + RISCV_INS_CV_CPLXCONJ, + RISCV_INS_CV_CPLXMUL_I, + RISCV_INS_CV_CPLXMUL_I_DIV2, + RISCV_INS_CV_CPLXMUL_I_DIV4, + RISCV_INS_CV_CPLXMUL_I_DIV8, + RISCV_INS_CV_CPLXMUL_R, + RISCV_INS_CV_CPLXMUL_R_DIV2, + RISCV_INS_CV_CPLXMUL_R_DIV4, + RISCV_INS_CV_CPLXMUL_R_DIV8, + RISCV_INS_CV_DOTSP_B, + RISCV_INS_CV_DOTSP_H, + RISCV_INS_CV_DOTSP_SCI_B, + RISCV_INS_CV_DOTSP_SCI_H, + RISCV_INS_CV_DOTSP_SC_B, + RISCV_INS_CV_DOTSP_SC_H, + RISCV_INS_CV_DOTUP_B, + RISCV_INS_CV_DOTUP_H, + RISCV_INS_CV_DOTUP_SCI_B, + RISCV_INS_CV_DOTUP_SCI_H, + RISCV_INS_CV_DOTUP_SC_B, + RISCV_INS_CV_DOTUP_SC_H, + RISCV_INS_CV_DOTUSP_B, + RISCV_INS_CV_DOTUSP_H, + RISCV_INS_CV_DOTUSP_SCI_B, + RISCV_INS_CV_DOTUSP_SCI_H, + RISCV_INS_CV_DOTUSP_SC_B, + RISCV_INS_CV_DOTUSP_SC_H, + RISCV_INS_CV_ELW, + RISCV_INS_CV_EXTBS, + RISCV_INS_CV_EXTBZ, + RISCV_INS_CV_EXTHS, + RISCV_INS_CV_EXTHZ, + RISCV_INS_CV_EXTRACT, + RISCV_INS_CV_EXTRACTR, + RISCV_INS_CV_EXTRACTU, + RISCV_INS_CV_EXTRACTUR, + RISCV_INS_CV_EXTRACTU_B, + RISCV_INS_CV_EXTRACTU_H, + RISCV_INS_CV_EXTRACT_B, + RISCV_INS_CV_EXTRACT_H, + RISCV_INS_CV_FF1, + RISCV_INS_CV_FL1, + RISCV_INS_CV_INSERT, + RISCV_INS_CV_INSERTR, + RISCV_INS_CV_INSERT_B, + RISCV_INS_CV_INSERT_H, + RISCV_INS_CV_LBU, + RISCV_INS_CV_LB, + RISCV_INS_CV_LHU, + RISCV_INS_CV_LH, + RISCV_INS_CV_LW, + RISCV_INS_CV_MAC, + RISCV_INS_CV_MACHHSN, + RISCV_INS_CV_MACHHSRN, + RISCV_INS_CV_MACHHUN, + RISCV_INS_CV_MACHHURN, + RISCV_INS_CV_MACSN, + RISCV_INS_CV_MACSRN, + RISCV_INS_CV_MACUN, + RISCV_INS_CV_MACURN, + RISCV_INS_CV_MAX, + RISCV_INS_CV_MAXU, + RISCV_INS_CV_MAXU_B, + RISCV_INS_CV_MAXU_H, + RISCV_INS_CV_MAXU_SCI_B, + RISCV_INS_CV_MAXU_SCI_H, + RISCV_INS_CV_MAXU_SC_B, + RISCV_INS_CV_MAXU_SC_H, + RISCV_INS_CV_MAX_B, + RISCV_INS_CV_MAX_H, + RISCV_INS_CV_MAX_SCI_B, + RISCV_INS_CV_MAX_SCI_H, + RISCV_INS_CV_MAX_SC_B, + RISCV_INS_CV_MAX_SC_H, + RISCV_INS_CV_MIN, + RISCV_INS_CV_MINU, + RISCV_INS_CV_MINU_B, + RISCV_INS_CV_MINU_H, + RISCV_INS_CV_MINU_SCI_B, + RISCV_INS_CV_MINU_SCI_H, + RISCV_INS_CV_MINU_SC_B, + RISCV_INS_CV_MINU_SC_H, + RISCV_INS_CV_MIN_B, + RISCV_INS_CV_MIN_H, + RISCV_INS_CV_MIN_SCI_B, + RISCV_INS_CV_MIN_SCI_H, + RISCV_INS_CV_MIN_SC_B, + RISCV_INS_CV_MIN_SC_H, + RISCV_INS_CV_MSU, + RISCV_INS_CV_MULHHSN, + RISCV_INS_CV_MULHHSRN, + RISCV_INS_CV_MULHHUN, + RISCV_INS_CV_MULHHURN, + RISCV_INS_CV_MULSN, + RISCV_INS_CV_MULSRN, + RISCV_INS_CV_MULUN, + RISCV_INS_CV_MULURN, + RISCV_INS_CV_OR_B, + RISCV_INS_CV_OR_H, + RISCV_INS_CV_OR_SCI_B, + RISCV_INS_CV_OR_SCI_H, + RISCV_INS_CV_OR_SC_B, + RISCV_INS_CV_OR_SC_H, + RISCV_INS_CV_PACK, + RISCV_INS_CV_PACKHI_B, + RISCV_INS_CV_PACKLO_B, + RISCV_INS_CV_PACK_H, + RISCV_INS_CV_ROR, + RISCV_INS_CV_SB, + RISCV_INS_CV_SDOTSP_B, + RISCV_INS_CV_SDOTSP_H, + RISCV_INS_CV_SDOTSP_SCI_B, + RISCV_INS_CV_SDOTSP_SCI_H, + RISCV_INS_CV_SDOTSP_SC_B, + RISCV_INS_CV_SDOTSP_SC_H, + RISCV_INS_CV_SDOTUP_B, + RISCV_INS_CV_SDOTUP_H, + RISCV_INS_CV_SDOTUP_SCI_B, + RISCV_INS_CV_SDOTUP_SCI_H, + RISCV_INS_CV_SDOTUP_SC_B, + RISCV_INS_CV_SDOTUP_SC_H, + RISCV_INS_CV_SDOTUSP_B, + RISCV_INS_CV_SDOTUSP_H, + RISCV_INS_CV_SDOTUSP_SCI_B, + RISCV_INS_CV_SDOTUSP_SCI_H, + RISCV_INS_CV_SDOTUSP_SC_B, + RISCV_INS_CV_SDOTUSP_SC_H, + RISCV_INS_CV_SHUFFLE2_B, + RISCV_INS_CV_SHUFFLE2_H, + RISCV_INS_CV_SHUFFLEI0_SCI_B, + RISCV_INS_CV_SHUFFLEI1_SCI_B, + RISCV_INS_CV_SHUFFLEI2_SCI_B, + RISCV_INS_CV_SHUFFLEI3_SCI_B, + RISCV_INS_CV_SHUFFLE_B, + RISCV_INS_CV_SHUFFLE_H, + RISCV_INS_CV_SHUFFLE_SCI_H, + RISCV_INS_CV_SH, + RISCV_INS_CV_SLET, + RISCV_INS_CV_SLETU, + RISCV_INS_CV_SLL_B, + RISCV_INS_CV_SLL_H, + RISCV_INS_CV_SLL_SCI_B, + RISCV_INS_CV_SLL_SCI_H, + RISCV_INS_CV_SLL_SC_B, + RISCV_INS_CV_SLL_SC_H, + RISCV_INS_CV_SRA_B, + RISCV_INS_CV_SRA_H, + RISCV_INS_CV_SRA_SCI_B, + RISCV_INS_CV_SRA_SCI_H, + RISCV_INS_CV_SRA_SC_B, + RISCV_INS_CV_SRA_SC_H, + RISCV_INS_CV_SRL_B, + RISCV_INS_CV_SRL_H, + RISCV_INS_CV_SRL_SCI_B, + RISCV_INS_CV_SRL_SCI_H, + RISCV_INS_CV_SRL_SC_B, + RISCV_INS_CV_SRL_SC_H, + RISCV_INS_CV_SUBN, + RISCV_INS_CV_SUBNR, + RISCV_INS_CV_SUBRN, + RISCV_INS_CV_SUBRNR, + RISCV_INS_CV_SUBROTMJ, + RISCV_INS_CV_SUBROTMJ_DIV2, + RISCV_INS_CV_SUBROTMJ_DIV4, + RISCV_INS_CV_SUBROTMJ_DIV8, + RISCV_INS_CV_SUBUN, + RISCV_INS_CV_SUBUNR, + RISCV_INS_CV_SUBURN, + RISCV_INS_CV_SUBURNR, + RISCV_INS_CV_SUB_B, + RISCV_INS_CV_SUB_DIV2, + RISCV_INS_CV_SUB_DIV4, + RISCV_INS_CV_SUB_DIV8, + RISCV_INS_CV_SUB_H, + RISCV_INS_CV_SUB_SCI_B, + RISCV_INS_CV_SUB_SCI_H, + RISCV_INS_CV_SUB_SC_B, + RISCV_INS_CV_SUB_SC_H, + RISCV_INS_CV_SW, + RISCV_INS_CV_XOR_B, + RISCV_INS_CV_XOR_H, + RISCV_INS_CV_XOR_SCI_B, + RISCV_INS_CV_XOR_SCI_H, + RISCV_INS_CV_XOR_SC_B, + RISCV_INS_CV_XOR_SC_H, + RISCV_INS_CZERO_EQZ, + RISCV_INS_CZERO_NEZ, RISCV_INS_C_ADD, RISCV_INS_C_ADDI, RISCV_INS_C_ADDI16SP, @@ -320,115 +1055,240 @@ typedef enum riscv_insn { RISCV_INS_C_JAL, RISCV_INS_C_JALR, RISCV_INS_C_JR, + RISCV_INS_C_LBU, RISCV_INS_C_LD, RISCV_INS_C_LDSP, + RISCV_INS_C_LH, + RISCV_INS_C_LHU, RISCV_INS_C_LI, RISCV_INS_C_LUI, RISCV_INS_C_LW, RISCV_INS_C_LWSP, + RISCV_INS_C_MUL, RISCV_INS_C_MV, RISCV_INS_C_NOP, + RISCV_INS_C_NOT, RISCV_INS_C_OR, + RISCV_INS_C_SB, RISCV_INS_C_SD, RISCV_INS_C_SDSP, + RISCV_INS_C_SEXT_B, + RISCV_INS_C_SEXT_H, + RISCV_INS_C_SH, RISCV_INS_C_SLLI, + RISCV_INS_C_SLLI64, RISCV_INS_C_SRAI, + RISCV_INS_C_SRAI64, RISCV_INS_C_SRLI, + RISCV_INS_C_SRLI64, + RISCV_INS_C_SSPOPCHK, + RISCV_INS_C_SSPUSH, RISCV_INS_C_SUB, RISCV_INS_C_SUBW, RISCV_INS_C_SW, RISCV_INS_C_SWSP, RISCV_INS_C_UNIMP, RISCV_INS_C_XOR, + RISCV_INS_C_ZEXT_B, + RISCV_INS_C_ZEXT_H, + RISCV_INS_C_ZEXT_W, RISCV_INS_DIV, RISCV_INS_DIVU, RISCV_INS_DIVUW, RISCV_INS_DIVW, + RISCV_INS_DRET, RISCV_INS_EBREAK, RISCV_INS_ECALL, RISCV_INS_FADD_D, + RISCV_INS_FADD_H, RISCV_INS_FADD_S, RISCV_INS_FCLASS_D, + RISCV_INS_FCLASS_H, RISCV_INS_FCLASS_S, + RISCV_INS_FCVTMOD_W_D, + RISCV_INS_FCVT_BF16_S, + RISCV_INS_FCVT_D_H, RISCV_INS_FCVT_D_L, RISCV_INS_FCVT_D_LU, RISCV_INS_FCVT_D_S, RISCV_INS_FCVT_D_W, RISCV_INS_FCVT_D_WU, + RISCV_INS_FCVT_H_D, + RISCV_INS_FCVT_H_L, + RISCV_INS_FCVT_H_LU, + RISCV_INS_FCVT_H_S, + RISCV_INS_FCVT_H_W, + RISCV_INS_FCVT_H_WU, RISCV_INS_FCVT_LU_D, + RISCV_INS_FCVT_LU_H, RISCV_INS_FCVT_LU_S, RISCV_INS_FCVT_L_D, + RISCV_INS_FCVT_L_H, RISCV_INS_FCVT_L_S, + RISCV_INS_FCVT_S_BF16, RISCV_INS_FCVT_S_D, + RISCV_INS_FCVT_S_H, RISCV_INS_FCVT_S_L, RISCV_INS_FCVT_S_LU, RISCV_INS_FCVT_S_W, RISCV_INS_FCVT_S_WU, RISCV_INS_FCVT_WU_D, + RISCV_INS_FCVT_WU_H, RISCV_INS_FCVT_WU_S, RISCV_INS_FCVT_W_D, + RISCV_INS_FCVT_W_H, RISCV_INS_FCVT_W_S, RISCV_INS_FDIV_D, + RISCV_INS_FDIV_H, RISCV_INS_FDIV_S, RISCV_INS_FENCE, RISCV_INS_FENCE_I, RISCV_INS_FENCE_TSO, RISCV_INS_FEQ_D, + RISCV_INS_FEQ_H, RISCV_INS_FEQ_S, - RISCV_INS_FLD, + RISCV_INS_FLEQ_D, + RISCV_INS_FLEQ_H, + RISCV_INS_FLEQ_S, RISCV_INS_FLE_D, + RISCV_INS_FLE_H, RISCV_INS_FLE_S, + RISCV_INS_FLI_D, + RISCV_INS_FLI_H, + RISCV_INS_FLI_S, + RISCV_INS_FLTQ_D, + RISCV_INS_FLTQ_H, + RISCV_INS_FLTQ_S, RISCV_INS_FLT_D, + RISCV_INS_FLT_H, RISCV_INS_FLT_S, - RISCV_INS_FLW, RISCV_INS_FMADD_D, + RISCV_INS_FMADD_H, RISCV_INS_FMADD_S, + RISCV_INS_FMAXM_D, + RISCV_INS_FMAXM_H, + RISCV_INS_FMAXM_S, RISCV_INS_FMAX_D, + RISCV_INS_FMAX_H, RISCV_INS_FMAX_S, + RISCV_INS_FMINM_D, + RISCV_INS_FMINM_H, + RISCV_INS_FMINM_S, RISCV_INS_FMIN_D, + RISCV_INS_FMIN_H, RISCV_INS_FMIN_S, RISCV_INS_FMSUB_D, + RISCV_INS_FMSUB_H, RISCV_INS_FMSUB_S, RISCV_INS_FMUL_D, + RISCV_INS_FMUL_H, RISCV_INS_FMUL_S, + RISCV_INS_FMVH_X_D, + RISCV_INS_FMVP_D_X, RISCV_INS_FMV_D_X, + RISCV_INS_FMV_H_X, RISCV_INS_FMV_W_X, RISCV_INS_FMV_X_D, + RISCV_INS_FMV_X_H, RISCV_INS_FMV_X_W, RISCV_INS_FNMADD_D, + RISCV_INS_FNMADD_H, RISCV_INS_FNMADD_S, RISCV_INS_FNMSUB_D, + RISCV_INS_FNMSUB_H, RISCV_INS_FNMSUB_S, - RISCV_INS_FSD, + RISCV_INS_FROUNDNX_D, + RISCV_INS_FROUNDNX_H, + RISCV_INS_FROUNDNX_S, + RISCV_INS_FROUND_D, + RISCV_INS_FROUND_H, + RISCV_INS_FROUND_S, RISCV_INS_FSGNJN_D, + RISCV_INS_FSGNJN_H, RISCV_INS_FSGNJN_S, RISCV_INS_FSGNJX_D, + RISCV_INS_FSGNJX_H, RISCV_INS_FSGNJX_S, RISCV_INS_FSGNJ_D, + RISCV_INS_FSGNJ_H, RISCV_INS_FSGNJ_S, RISCV_INS_FSQRT_D, + RISCV_INS_FSQRT_H, RISCV_INS_FSQRT_S, RISCV_INS_FSUB_D, + RISCV_INS_FSUB_H, RISCV_INS_FSUB_S, - RISCV_INS_FSW, + RISCV_INS_HFENCE_GVMA, + RISCV_INS_HFENCE_VVMA, + RISCV_INS_HINVAL_GVMA, + RISCV_INS_HINVAL_VVMA, + RISCV_INS_HLVX_HU, + RISCV_INS_HLVX_WU, + RISCV_INS_HLV_B, + RISCV_INS_HLV_BU, + RISCV_INS_HLV_D, + RISCV_INS_HLV_H, + RISCV_INS_HLV_HU, + RISCV_INS_HLV_W, + RISCV_INS_HLV_WU, + RISCV_INS_HSV_B, + RISCV_INS_HSV_D, + RISCV_INS_HSV_H, + RISCV_INS_HSV_W, RISCV_INS_JAL, - RISCV_INS_JALR, - RISCV_INS_LB, - RISCV_INS_LBU, - RISCV_INS_LD, - RISCV_INS_LH, - RISCV_INS_LHU, RISCV_INS_LR_D, RISCV_INS_LR_D_AQ, - RISCV_INS_LR_D_AQ_RL, + RISCV_INS_LR_D_AQRL, RISCV_INS_LR_D_RL, RISCV_INS_LR_W, RISCV_INS_LR_W_AQ, - RISCV_INS_LR_W_AQ_RL, + RISCV_INS_LR_W_AQRL, RISCV_INS_LR_W_RL, RISCV_INS_LUI, - RISCV_INS_LW, - RISCV_INS_LWU, + RISCV_INS_MAX, + RISCV_INS_MAXU, + RISCV_INS_MIN, + RISCV_INS_MINU, + RISCV_INS_MOP_R_0, + RISCV_INS_MOP_R_1, + RISCV_INS_MOP_R_10, + RISCV_INS_MOP_R_11, + RISCV_INS_MOP_R_12, + RISCV_INS_MOP_R_13, + RISCV_INS_MOP_R_14, + RISCV_INS_MOP_R_15, + RISCV_INS_MOP_R_16, + RISCV_INS_MOP_R_17, + RISCV_INS_MOP_R_18, + RISCV_INS_MOP_R_19, + RISCV_INS_MOP_R_2, + RISCV_INS_MOP_R_20, + RISCV_INS_MOP_R_21, + RISCV_INS_MOP_R_22, + RISCV_INS_MOP_R_23, + RISCV_INS_MOP_R_24, + RISCV_INS_MOP_R_25, + RISCV_INS_MOP_R_26, + RISCV_INS_MOP_R_27, + RISCV_INS_MOP_R_28, + RISCV_INS_MOP_R_29, + RISCV_INS_MOP_R_3, + RISCV_INS_MOP_R_30, + RISCV_INS_MOP_R_31, + RISCV_INS_MOP_R_4, + RISCV_INS_MOP_R_5, + RISCV_INS_MOP_R_6, + RISCV_INS_MOP_R_7, + RISCV_INS_MOP_R_8, + RISCV_INS_MOP_R_9, + RISCV_INS_MOP_RR_0, + RISCV_INS_MOP_RR_1, + RISCV_INS_MOP_RR_2, + RISCV_INS_MOP_RR_3, + RISCV_INS_MOP_RR_4, + RISCV_INS_MOP_RR_5, + RISCV_INS_MOP_RR_6, + RISCV_INS_MOP_RR_7, RISCV_INS_MRET, RISCV_INS_MUL, RISCV_INS_MULH, @@ -436,31 +1296,71 @@ typedef enum riscv_insn { RISCV_INS_MULHU, RISCV_INS_MULW, RISCV_INS_OR, + RISCV_INS_ORC_B, RISCV_INS_ORI, + RISCV_INS_ORN, + RISCV_INS_PACK, + RISCV_INS_PACKH, + RISCV_INS_PACKW, + RISCV_INS_PREFETCH_I, + RISCV_INS_PREFETCH_R, + RISCV_INS_PREFETCH_W, RISCV_INS_REM, RISCV_INS_REMU, RISCV_INS_REMUW, RISCV_INS_REMW, - RISCV_INS_SB, + RISCV_INS_REV8, + RISCV_INS_ROL, + RISCV_INS_ROLW, + RISCV_INS_ROR, + RISCV_INS_RORI, + RISCV_INS_RORIW, + RISCV_INS_RORW, RISCV_INS_SC_D, RISCV_INS_SC_D_AQ, - RISCV_INS_SC_D_AQ_RL, + RISCV_INS_SC_D_AQRL, RISCV_INS_SC_D_RL, RISCV_INS_SC_W, RISCV_INS_SC_W_AQ, - RISCV_INS_SC_W_AQ_RL, + RISCV_INS_SC_W_AQRL, RISCV_INS_SC_W_RL, - RISCV_INS_SD, + RISCV_INS_SFENCE_INVAL_IR, RISCV_INS_SFENCE_VMA, - RISCV_INS_SH, + RISCV_INS_SFENCE_W_INVAL, + RISCV_INS_SH1ADD, + RISCV_INS_SH1ADD_UW, + RISCV_INS_SH2ADD, + RISCV_INS_SH2ADD_UW, + RISCV_INS_SH3ADD, + RISCV_INS_SH3ADD_UW, + RISCV_INS_SHA256SIG0, + RISCV_INS_SHA256SIG1, + RISCV_INS_SHA256SUM0, + RISCV_INS_SHA256SUM1, + RISCV_INS_SHA512SIG0, + RISCV_INS_SHA512SIG0H, + RISCV_INS_SHA512SIG0L, + RISCV_INS_SHA512SIG1, + RISCV_INS_SHA512SIG1H, + RISCV_INS_SHA512SIG1L, + RISCV_INS_SHA512SUM0, + RISCV_INS_SHA512SUM0R, + RISCV_INS_SHA512SUM1, + RISCV_INS_SHA512SUM1R, + RISCV_INS_SINVAL_VMA, RISCV_INS_SLL, RISCV_INS_SLLI, RISCV_INS_SLLIW, + RISCV_INS_SLLI_UW, RISCV_INS_SLLW, RISCV_INS_SLT, RISCV_INS_SLTI, RISCV_INS_SLTIU, RISCV_INS_SLTU, + RISCV_INS_SM3P0, + RISCV_INS_SM3P1, + RISCV_INS_SM4ED, + RISCV_INS_SM4KS, RISCV_INS_SRA, RISCV_INS_SRAI, RISCV_INS_SRAIW, @@ -470,47 +1370,1082 @@ typedef enum riscv_insn { RISCV_INS_SRLI, RISCV_INS_SRLIW, RISCV_INS_SRLW, + RISCV_INS_SSAMOSWAP_D, + RISCV_INS_SSAMOSWAP_D_AQ, + RISCV_INS_SSAMOSWAP_D_AQRL, + RISCV_INS_SSAMOSWAP_D_RL, + RISCV_INS_SSAMOSWAP_W, + RISCV_INS_SSAMOSWAP_W_AQ, + RISCV_INS_SSAMOSWAP_W_AQRL, + RISCV_INS_SSAMOSWAP_W_RL, + RISCV_INS_SSPOPCHK, + RISCV_INS_SSPUSH, + RISCV_INS_SSRDP, RISCV_INS_SUB, RISCV_INS_SUBW, - RISCV_INS_SW, + RISCV_INS_TH_VMAQASU_VV, + RISCV_INS_TH_VMAQASU_VX, + RISCV_INS_TH_VMAQAUS_VX, + RISCV_INS_TH_VMAQAU_VV, + RISCV_INS_TH_VMAQAU_VX, + RISCV_INS_TH_VMAQA_VV, + RISCV_INS_TH_VMAQA_VX, + RISCV_INS_TH_ADDSL, + RISCV_INS_TH_DCACHE_CALL, + RISCV_INS_TH_DCACHE_CIALL, + RISCV_INS_TH_DCACHE_CIPA, + RISCV_INS_TH_DCACHE_CISW, + RISCV_INS_TH_DCACHE_CIVA, + RISCV_INS_TH_DCACHE_CPA, + RISCV_INS_TH_DCACHE_CPAL1, + RISCV_INS_TH_DCACHE_CSW, + RISCV_INS_TH_DCACHE_CVA, + RISCV_INS_TH_DCACHE_CVAL1, + RISCV_INS_TH_DCACHE_IALL, + RISCV_INS_TH_DCACHE_IPA, + RISCV_INS_TH_DCACHE_ISW, + RISCV_INS_TH_DCACHE_IVA, + RISCV_INS_TH_EXT, + RISCV_INS_TH_EXTU, + RISCV_INS_TH_FF0, + RISCV_INS_TH_FF1, + RISCV_INS_TH_FLRD, + RISCV_INS_TH_FLRW, + RISCV_INS_TH_FLURD, + RISCV_INS_TH_FLURW, + RISCV_INS_TH_FSRD, + RISCV_INS_TH_FSRW, + RISCV_INS_TH_FSURD, + RISCV_INS_TH_FSURW, + RISCV_INS_TH_ICACHE_IALL, + RISCV_INS_TH_ICACHE_IALLS, + RISCV_INS_TH_ICACHE_IPA, + RISCV_INS_TH_ICACHE_IVA, + RISCV_INS_TH_L2CACHE_CALL, + RISCV_INS_TH_L2CACHE_CIALL, + RISCV_INS_TH_L2CACHE_IALL, + RISCV_INS_TH_LBIA, + RISCV_INS_TH_LBIB, + RISCV_INS_TH_LBUIA, + RISCV_INS_TH_LBUIB, + RISCV_INS_TH_LDD, + RISCV_INS_TH_LDIA, + RISCV_INS_TH_LDIB, + RISCV_INS_TH_LHIA, + RISCV_INS_TH_LHIB, + RISCV_INS_TH_LHUIA, + RISCV_INS_TH_LHUIB, + RISCV_INS_TH_LRB, + RISCV_INS_TH_LRBU, + RISCV_INS_TH_LRD, + RISCV_INS_TH_LRH, + RISCV_INS_TH_LRHU, + RISCV_INS_TH_LRW, + RISCV_INS_TH_LRWU, + RISCV_INS_TH_LURB, + RISCV_INS_TH_LURBU, + RISCV_INS_TH_LURD, + RISCV_INS_TH_LURH, + RISCV_INS_TH_LURHU, + RISCV_INS_TH_LURW, + RISCV_INS_TH_LURWU, + RISCV_INS_TH_LWD, + RISCV_INS_TH_LWIA, + RISCV_INS_TH_LWIB, + RISCV_INS_TH_LWUD, + RISCV_INS_TH_LWUIA, + RISCV_INS_TH_LWUIB, + RISCV_INS_TH_MULA, + RISCV_INS_TH_MULAH, + RISCV_INS_TH_MULAW, + RISCV_INS_TH_MULS, + RISCV_INS_TH_MULSH, + RISCV_INS_TH_MULSW, + RISCV_INS_TH_MVEQZ, + RISCV_INS_TH_MVNEZ, + RISCV_INS_TH_REV, + RISCV_INS_TH_REVW, + RISCV_INS_TH_SBIA, + RISCV_INS_TH_SBIB, + RISCV_INS_TH_SDD, + RISCV_INS_TH_SDIA, + RISCV_INS_TH_SDIB, + RISCV_INS_TH_SFENCE_VMAS, + RISCV_INS_TH_SHIA, + RISCV_INS_TH_SHIB, + RISCV_INS_TH_SRB, + RISCV_INS_TH_SRD, + RISCV_INS_TH_SRH, + RISCV_INS_TH_SRRI, + RISCV_INS_TH_SRRIW, + RISCV_INS_TH_SRW, + RISCV_INS_TH_SURB, + RISCV_INS_TH_SURD, + RISCV_INS_TH_SURH, + RISCV_INS_TH_SURW, + RISCV_INS_TH_SWD, + RISCV_INS_TH_SWIA, + RISCV_INS_TH_SWIB, + RISCV_INS_TH_SYNC, + RISCV_INS_TH_SYNC_I, + RISCV_INS_TH_SYNC_IS, + RISCV_INS_TH_SYNC_S, + RISCV_INS_TH_TST, + RISCV_INS_TH_TSTNBZ, RISCV_INS_UNIMP, - RISCV_INS_URET, + RISCV_INS_UNZIP, + RISCV_INS_VAADDU_VV, + RISCV_INS_VAADDU_VX, + RISCV_INS_VAADD_VV, + RISCV_INS_VAADD_VX, + RISCV_INS_VADC_VIM, + RISCV_INS_VADC_VVM, + RISCV_INS_VADC_VXM, + RISCV_INS_VADD_VI, + RISCV_INS_VADD_VV, + RISCV_INS_VADD_VX, + RISCV_INS_VAESDF_VS, + RISCV_INS_VAESDF_VV, + RISCV_INS_VAESDM_VS, + RISCV_INS_VAESDM_VV, + RISCV_INS_VAESEF_VS, + RISCV_INS_VAESEF_VV, + RISCV_INS_VAESEM_VS, + RISCV_INS_VAESEM_VV, + RISCV_INS_VAESKF1_VI, + RISCV_INS_VAESKF2_VI, + RISCV_INS_VAESZ_VS, + RISCV_INS_VANDN_VV, + RISCV_INS_VANDN_VX, + RISCV_INS_VAND_VI, + RISCV_INS_VAND_VV, + RISCV_INS_VAND_VX, + RISCV_INS_VASUBU_VV, + RISCV_INS_VASUBU_VX, + RISCV_INS_VASUB_VV, + RISCV_INS_VASUB_VX, + RISCV_INS_VBREV8_V, + RISCV_INS_VBREV_V, + RISCV_INS_VCLMULH_VV, + RISCV_INS_VCLMULH_VX, + RISCV_INS_VCLMUL_VV, + RISCV_INS_VCLMUL_VX, + RISCV_INS_VCLZ_V, + RISCV_INS_VCOMPRESS_VM, + RISCV_INS_VCPOP_M, + RISCV_INS_VCPOP_V, + RISCV_INS_VCTZ_V, + RISCV_INS_SF_VC_FV, + RISCV_INS_SF_VC_FVV, + RISCV_INS_SF_VC_FVW, + RISCV_INS_SF_VC_I, + RISCV_INS_SF_VC_IV, + RISCV_INS_SF_VC_IVV, + RISCV_INS_SF_VC_IVW, + RISCV_INS_SF_VC_VV, + RISCV_INS_SF_VC_VVV, + RISCV_INS_SF_VC_VVW, + RISCV_INS_SF_VC_V_FV, + RISCV_INS_SF_VC_V_FVV, + RISCV_INS_SF_VC_V_FVW, + RISCV_INS_SF_VC_V_I, + RISCV_INS_SF_VC_V_IV, + RISCV_INS_SF_VC_V_IVV, + RISCV_INS_SF_VC_V_IVW, + RISCV_INS_SF_VC_V_VV, + RISCV_INS_SF_VC_V_VVV, + RISCV_INS_SF_VC_V_VVW, + RISCV_INS_SF_VC_V_X, + RISCV_INS_SF_VC_V_XV, + RISCV_INS_SF_VC_V_XVV, + RISCV_INS_SF_VC_V_XVW, + RISCV_INS_SF_VC_X, + RISCV_INS_SF_VC_XV, + RISCV_INS_SF_VC_XVV, + RISCV_INS_SF_VC_XVW, + RISCV_INS_VDIVU_VV, + RISCV_INS_VDIVU_VX, + RISCV_INS_VDIV_VV, + RISCV_INS_VDIV_VX, + RISCV_INS_VFADD_VF, + RISCV_INS_VFADD_VV, + RISCV_INS_VFCLASS_V, + RISCV_INS_VFCVT_F_XU_V, + RISCV_INS_VFCVT_F_X_V, + RISCV_INS_VFCVT_RTZ_XU_F_V, + RISCV_INS_VFCVT_RTZ_X_F_V, + RISCV_INS_VFCVT_XU_F_V, + RISCV_INS_VFCVT_X_F_V, + RISCV_INS_VFDIV_VF, + RISCV_INS_VFDIV_VV, + RISCV_INS_VFIRST_M, + RISCV_INS_VFMACC_VF, + RISCV_INS_VFMACC_VV, + RISCV_INS_VFMADD_VF, + RISCV_INS_VFMADD_VV, + RISCV_INS_VFMAX_VF, + RISCV_INS_VFMAX_VV, + RISCV_INS_VFMERGE_VFM, + RISCV_INS_VFMIN_VF, + RISCV_INS_VFMIN_VV, + RISCV_INS_VFMSAC_VF, + RISCV_INS_VFMSAC_VV, + RISCV_INS_VFMSUB_VF, + RISCV_INS_VFMSUB_VV, + RISCV_INS_VFMUL_VF, + RISCV_INS_VFMUL_VV, + RISCV_INS_VFMV_F_S, + RISCV_INS_VFMV_S_F, + RISCV_INS_VFMV_V_F, + RISCV_INS_VFNCVTBF16_F_F_W, + RISCV_INS_VFNCVT_F_F_W, + RISCV_INS_VFNCVT_F_XU_W, + RISCV_INS_VFNCVT_F_X_W, + RISCV_INS_VFNCVT_ROD_F_F_W, + RISCV_INS_VFNCVT_RTZ_XU_F_W, + RISCV_INS_VFNCVT_RTZ_X_F_W, + RISCV_INS_VFNCVT_XU_F_W, + RISCV_INS_VFNCVT_X_F_W, + RISCV_INS_VFNMACC_VF, + RISCV_INS_VFNMACC_VV, + RISCV_INS_VFNMADD_VF, + RISCV_INS_VFNMADD_VV, + RISCV_INS_VFNMSAC_VF, + RISCV_INS_VFNMSAC_VV, + RISCV_INS_VFNMSUB_VF, + RISCV_INS_VFNMSUB_VV, + RISCV_INS_SF_VFNRCLIP_XU_F_QF, + RISCV_INS_SF_VFNRCLIP_X_F_QF, + RISCV_INS_VFRDIV_VF, + RISCV_INS_VFREC7_V, + RISCV_INS_VFREDMAX_VS, + RISCV_INS_VFREDMIN_VS, + RISCV_INS_VFREDOSUM_VS, + RISCV_INS_VFREDUSUM_VS, + RISCV_INS_VFRSQRT7_V, + RISCV_INS_VFRSUB_VF, + RISCV_INS_VFSGNJN_VF, + RISCV_INS_VFSGNJN_VV, + RISCV_INS_VFSGNJX_VF, + RISCV_INS_VFSGNJX_VV, + RISCV_INS_VFSGNJ_VF, + RISCV_INS_VFSGNJ_VV, + RISCV_INS_VFSLIDE1DOWN_VF, + RISCV_INS_VFSLIDE1UP_VF, + RISCV_INS_VFSQRT_V, + RISCV_INS_VFSUB_VF, + RISCV_INS_VFSUB_VV, + RISCV_INS_VFWADD_VF, + RISCV_INS_VFWADD_VV, + RISCV_INS_VFWADD_WF, + RISCV_INS_VFWADD_WV, + RISCV_INS_VFWCVTBF16_F_F_V, + RISCV_INS_VFWCVT_F_F_V, + RISCV_INS_VFWCVT_F_XU_V, + RISCV_INS_VFWCVT_F_X_V, + RISCV_INS_VFWCVT_RTZ_XU_F_V, + RISCV_INS_VFWCVT_RTZ_X_F_V, + RISCV_INS_VFWCVT_XU_F_V, + RISCV_INS_VFWCVT_X_F_V, + RISCV_INS_VFWMACCBF16_VF, + RISCV_INS_VFWMACCBF16_VV, + RISCV_INS_SF_VFWMACC_4X4X4, + RISCV_INS_VFWMACC_VF, + RISCV_INS_VFWMACC_VV, + RISCV_INS_VFWMSAC_VF, + RISCV_INS_VFWMSAC_VV, + RISCV_INS_VFWMUL_VF, + RISCV_INS_VFWMUL_VV, + RISCV_INS_VFWNMACC_VF, + RISCV_INS_VFWNMACC_VV, + RISCV_INS_VFWNMSAC_VF, + RISCV_INS_VFWNMSAC_VV, + RISCV_INS_VFWREDOSUM_VS, + RISCV_INS_VFWREDUSUM_VS, + RISCV_INS_VFWSUB_VF, + RISCV_INS_VFWSUB_VV, + RISCV_INS_VFWSUB_WF, + RISCV_INS_VFWSUB_WV, + RISCV_INS_VGHSH_VV, + RISCV_INS_VGMUL_VV, + RISCV_INS_VID_V, + RISCV_INS_VIOTA_M, + RISCV_INS_VL1RE16_V, + RISCV_INS_VL1RE32_V, + RISCV_INS_VL1RE64_V, + RISCV_INS_VL1RE8_V, + RISCV_INS_VL2RE16_V, + RISCV_INS_VL2RE32_V, + RISCV_INS_VL2RE64_V, + RISCV_INS_VL2RE8_V, + RISCV_INS_VL4RE16_V, + RISCV_INS_VL4RE32_V, + RISCV_INS_VL4RE64_V, + RISCV_INS_VL4RE8_V, + RISCV_INS_VL8RE16_V, + RISCV_INS_VL8RE32_V, + RISCV_INS_VL8RE64_V, + RISCV_INS_VL8RE8_V, + RISCV_INS_VLE16FF_V, + RISCV_INS_VLE16_V, + RISCV_INS_VLE32FF_V, + RISCV_INS_VLE32_V, + RISCV_INS_VLE64FF_V, + RISCV_INS_VLE64_V, + RISCV_INS_VLE8FF_V, + RISCV_INS_VLE8_V, + RISCV_INS_VLM_V, + RISCV_INS_VLOXEI16_V, + RISCV_INS_VLOXEI32_V, + RISCV_INS_VLOXEI64_V, + RISCV_INS_VLOXEI8_V, + RISCV_INS_VLOXSEG2EI16_V, + RISCV_INS_VLOXSEG2EI32_V, + RISCV_INS_VLOXSEG2EI64_V, + RISCV_INS_VLOXSEG2EI8_V, + RISCV_INS_VLOXSEG3EI16_V, + RISCV_INS_VLOXSEG3EI32_V, + RISCV_INS_VLOXSEG3EI64_V, + RISCV_INS_VLOXSEG3EI8_V, + RISCV_INS_VLOXSEG4EI16_V, + RISCV_INS_VLOXSEG4EI32_V, + RISCV_INS_VLOXSEG4EI64_V, + RISCV_INS_VLOXSEG4EI8_V, + RISCV_INS_VLOXSEG5EI16_V, + RISCV_INS_VLOXSEG5EI32_V, + RISCV_INS_VLOXSEG5EI64_V, + RISCV_INS_VLOXSEG5EI8_V, + RISCV_INS_VLOXSEG6EI16_V, + RISCV_INS_VLOXSEG6EI32_V, + RISCV_INS_VLOXSEG6EI64_V, + RISCV_INS_VLOXSEG6EI8_V, + RISCV_INS_VLOXSEG7EI16_V, + RISCV_INS_VLOXSEG7EI32_V, + RISCV_INS_VLOXSEG7EI64_V, + RISCV_INS_VLOXSEG7EI8_V, + RISCV_INS_VLOXSEG8EI16_V, + RISCV_INS_VLOXSEG8EI32_V, + RISCV_INS_VLOXSEG8EI64_V, + RISCV_INS_VLOXSEG8EI8_V, + RISCV_INS_VLSE16_V, + RISCV_INS_VLSE32_V, + RISCV_INS_VLSE64_V, + RISCV_INS_VLSE8_V, + RISCV_INS_VLSEG2E16FF_V, + RISCV_INS_VLSEG2E16_V, + RISCV_INS_VLSEG2E32FF_V, + RISCV_INS_VLSEG2E32_V, + RISCV_INS_VLSEG2E64FF_V, + RISCV_INS_VLSEG2E64_V, + RISCV_INS_VLSEG2E8FF_V, + RISCV_INS_VLSEG2E8_V, + RISCV_INS_VLSEG3E16FF_V, + RISCV_INS_VLSEG3E16_V, + RISCV_INS_VLSEG3E32FF_V, + RISCV_INS_VLSEG3E32_V, + RISCV_INS_VLSEG3E64FF_V, + RISCV_INS_VLSEG3E64_V, + RISCV_INS_VLSEG3E8FF_V, + RISCV_INS_VLSEG3E8_V, + RISCV_INS_VLSEG4E16FF_V, + RISCV_INS_VLSEG4E16_V, + RISCV_INS_VLSEG4E32FF_V, + RISCV_INS_VLSEG4E32_V, + RISCV_INS_VLSEG4E64FF_V, + RISCV_INS_VLSEG4E64_V, + RISCV_INS_VLSEG4E8FF_V, + RISCV_INS_VLSEG4E8_V, + RISCV_INS_VLSEG5E16FF_V, + RISCV_INS_VLSEG5E16_V, + RISCV_INS_VLSEG5E32FF_V, + RISCV_INS_VLSEG5E32_V, + RISCV_INS_VLSEG5E64FF_V, + RISCV_INS_VLSEG5E64_V, + RISCV_INS_VLSEG5E8FF_V, + RISCV_INS_VLSEG5E8_V, + RISCV_INS_VLSEG6E16FF_V, + RISCV_INS_VLSEG6E16_V, + RISCV_INS_VLSEG6E32FF_V, + RISCV_INS_VLSEG6E32_V, + RISCV_INS_VLSEG6E64FF_V, + RISCV_INS_VLSEG6E64_V, + RISCV_INS_VLSEG6E8FF_V, + RISCV_INS_VLSEG6E8_V, + RISCV_INS_VLSEG7E16FF_V, + RISCV_INS_VLSEG7E16_V, + RISCV_INS_VLSEG7E32FF_V, + RISCV_INS_VLSEG7E32_V, + RISCV_INS_VLSEG7E64FF_V, + RISCV_INS_VLSEG7E64_V, + RISCV_INS_VLSEG7E8FF_V, + RISCV_INS_VLSEG7E8_V, + RISCV_INS_VLSEG8E16FF_V, + RISCV_INS_VLSEG8E16_V, + RISCV_INS_VLSEG8E32FF_V, + RISCV_INS_VLSEG8E32_V, + RISCV_INS_VLSEG8E64FF_V, + RISCV_INS_VLSEG8E64_V, + RISCV_INS_VLSEG8E8FF_V, + RISCV_INS_VLSEG8E8_V, + RISCV_INS_VLSSEG2E16_V, + RISCV_INS_VLSSEG2E32_V, + RISCV_INS_VLSSEG2E64_V, + RISCV_INS_VLSSEG2E8_V, + RISCV_INS_VLSSEG3E16_V, + RISCV_INS_VLSSEG3E32_V, + RISCV_INS_VLSSEG3E64_V, + RISCV_INS_VLSSEG3E8_V, + RISCV_INS_VLSSEG4E16_V, + RISCV_INS_VLSSEG4E32_V, + RISCV_INS_VLSSEG4E64_V, + RISCV_INS_VLSSEG4E8_V, + RISCV_INS_VLSSEG5E16_V, + RISCV_INS_VLSSEG5E32_V, + RISCV_INS_VLSSEG5E64_V, + RISCV_INS_VLSSEG5E8_V, + RISCV_INS_VLSSEG6E16_V, + RISCV_INS_VLSSEG6E32_V, + RISCV_INS_VLSSEG6E64_V, + RISCV_INS_VLSSEG6E8_V, + RISCV_INS_VLSSEG7E16_V, + RISCV_INS_VLSSEG7E32_V, + RISCV_INS_VLSSEG7E64_V, + RISCV_INS_VLSSEG7E8_V, + RISCV_INS_VLSSEG8E16_V, + RISCV_INS_VLSSEG8E32_V, + RISCV_INS_VLSSEG8E64_V, + RISCV_INS_VLSSEG8E8_V, + RISCV_INS_VLUXEI16_V, + RISCV_INS_VLUXEI32_V, + RISCV_INS_VLUXEI64_V, + RISCV_INS_VLUXEI8_V, + RISCV_INS_VLUXSEG2EI16_V, + RISCV_INS_VLUXSEG2EI32_V, + RISCV_INS_VLUXSEG2EI64_V, + RISCV_INS_VLUXSEG2EI8_V, + RISCV_INS_VLUXSEG3EI16_V, + RISCV_INS_VLUXSEG3EI32_V, + RISCV_INS_VLUXSEG3EI64_V, + RISCV_INS_VLUXSEG3EI8_V, + RISCV_INS_VLUXSEG4EI16_V, + RISCV_INS_VLUXSEG4EI32_V, + RISCV_INS_VLUXSEG4EI64_V, + RISCV_INS_VLUXSEG4EI8_V, + RISCV_INS_VLUXSEG5EI16_V, + RISCV_INS_VLUXSEG5EI32_V, + RISCV_INS_VLUXSEG5EI64_V, + RISCV_INS_VLUXSEG5EI8_V, + RISCV_INS_VLUXSEG6EI16_V, + RISCV_INS_VLUXSEG6EI32_V, + RISCV_INS_VLUXSEG6EI64_V, + RISCV_INS_VLUXSEG6EI8_V, + RISCV_INS_VLUXSEG7EI16_V, + RISCV_INS_VLUXSEG7EI32_V, + RISCV_INS_VLUXSEG7EI64_V, + RISCV_INS_VLUXSEG7EI8_V, + RISCV_INS_VLUXSEG8EI16_V, + RISCV_INS_VLUXSEG8EI32_V, + RISCV_INS_VLUXSEG8EI64_V, + RISCV_INS_VLUXSEG8EI8_V, + RISCV_INS_VMACC_VV, + RISCV_INS_VMACC_VX, + RISCV_INS_VMADC_VI, + RISCV_INS_VMADC_VIM, + RISCV_INS_VMADC_VV, + RISCV_INS_VMADC_VVM, + RISCV_INS_VMADC_VX, + RISCV_INS_VMADC_VXM, + RISCV_INS_VMADD_VV, + RISCV_INS_VMADD_VX, + RISCV_INS_VMANDN_MM, + RISCV_INS_VMAND_MM, + RISCV_INS_VMAXU_VV, + RISCV_INS_VMAXU_VX, + RISCV_INS_VMAX_VV, + RISCV_INS_VMAX_VX, + RISCV_INS_VMERGE_VIM, + RISCV_INS_VMERGE_VVM, + RISCV_INS_VMERGE_VXM, + RISCV_INS_VMFEQ_VF, + RISCV_INS_VMFEQ_VV, + RISCV_INS_VMFGE_VF, + RISCV_INS_VMFGT_VF, + RISCV_INS_VMFLE_VF, + RISCV_INS_VMFLE_VV, + RISCV_INS_VMFLT_VF, + RISCV_INS_VMFLT_VV, + RISCV_INS_VMFNE_VF, + RISCV_INS_VMFNE_VV, + RISCV_INS_VMINU_VV, + RISCV_INS_VMINU_VX, + RISCV_INS_VMIN_VV, + RISCV_INS_VMIN_VX, + RISCV_INS_VMNAND_MM, + RISCV_INS_VMNOR_MM, + RISCV_INS_VMORN_MM, + RISCV_INS_VMOR_MM, + RISCV_INS_VMSBC_VV, + RISCV_INS_VMSBC_VVM, + RISCV_INS_VMSBC_VX, + RISCV_INS_VMSBC_VXM, + RISCV_INS_VMSBF_M, + RISCV_INS_VMSEQ_VI, + RISCV_INS_VMSEQ_VV, + RISCV_INS_VMSEQ_VX, + RISCV_INS_VMSGTU_VI, + RISCV_INS_VMSGTU_VX, + RISCV_INS_VMSGT_VI, + RISCV_INS_VMSGT_VX, + RISCV_INS_VMSIF_M, + RISCV_INS_VMSLEU_VI, + RISCV_INS_VMSLEU_VV, + RISCV_INS_VMSLEU_VX, + RISCV_INS_VMSLE_VI, + RISCV_INS_VMSLE_VV, + RISCV_INS_VMSLE_VX, + RISCV_INS_VMSLTU_VV, + RISCV_INS_VMSLTU_VX, + RISCV_INS_VMSLT_VV, + RISCV_INS_VMSLT_VX, + RISCV_INS_VMSNE_VI, + RISCV_INS_VMSNE_VV, + RISCV_INS_VMSNE_VX, + RISCV_INS_VMSOF_M, + RISCV_INS_VMULHSU_VV, + RISCV_INS_VMULHSU_VX, + RISCV_INS_VMULHU_VV, + RISCV_INS_VMULHU_VX, + RISCV_INS_VMULH_VV, + RISCV_INS_VMULH_VX, + RISCV_INS_VMUL_VV, + RISCV_INS_VMUL_VX, + RISCV_INS_VMV1R_V, + RISCV_INS_VMV2R_V, + RISCV_INS_VMV4R_V, + RISCV_INS_VMV8R_V, + RISCV_INS_VMV_S_X, + RISCV_INS_VMV_V_I, + RISCV_INS_VMV_V_V, + RISCV_INS_VMV_V_X, + RISCV_INS_VMV_X_S, + RISCV_INS_VMXNOR_MM, + RISCV_INS_VMXOR_MM, + RISCV_INS_VNCLIPU_WI, + RISCV_INS_VNCLIPU_WV, + RISCV_INS_VNCLIPU_WX, + RISCV_INS_VNCLIP_WI, + RISCV_INS_VNCLIP_WV, + RISCV_INS_VNCLIP_WX, + RISCV_INS_VNMSAC_VV, + RISCV_INS_VNMSAC_VX, + RISCV_INS_VNMSUB_VV, + RISCV_INS_VNMSUB_VX, + RISCV_INS_VNSRA_WI, + RISCV_INS_VNSRA_WV, + RISCV_INS_VNSRA_WX, + RISCV_INS_VNSRL_WI, + RISCV_INS_VNSRL_WV, + RISCV_INS_VNSRL_WX, + RISCV_INS_VOR_VI, + RISCV_INS_VOR_VV, + RISCV_INS_VOR_VX, + RISCV_INS_SF_VQMACCSU_2X8X2, + RISCV_INS_SF_VQMACCSU_4X8X4, + RISCV_INS_SF_VQMACCUS_2X8X2, + RISCV_INS_SF_VQMACCUS_4X8X4, + RISCV_INS_SF_VQMACCU_2X8X2, + RISCV_INS_SF_VQMACCU_4X8X4, + RISCV_INS_SF_VQMACC_2X8X2, + RISCV_INS_SF_VQMACC_4X8X4, + RISCV_INS_VREDAND_VS, + RISCV_INS_VREDMAXU_VS, + RISCV_INS_VREDMAX_VS, + RISCV_INS_VREDMINU_VS, + RISCV_INS_VREDMIN_VS, + RISCV_INS_VREDOR_VS, + RISCV_INS_VREDSUM_VS, + RISCV_INS_VREDXOR_VS, + RISCV_INS_VREMU_VV, + RISCV_INS_VREMU_VX, + RISCV_INS_VREM_VV, + RISCV_INS_VREM_VX, + RISCV_INS_VREV8_V, + RISCV_INS_VRGATHEREI16_VV, + RISCV_INS_VRGATHER_VI, + RISCV_INS_VRGATHER_VV, + RISCV_INS_VRGATHER_VX, + RISCV_INS_VROL_VV, + RISCV_INS_VROL_VX, + RISCV_INS_VROR_VI, + RISCV_INS_VROR_VV, + RISCV_INS_VROR_VX, + RISCV_INS_VRSUB_VI, + RISCV_INS_VRSUB_VX, + RISCV_INS_VS1R_V, + RISCV_INS_VS2R_V, + RISCV_INS_VS4R_V, + RISCV_INS_VS8R_V, + RISCV_INS_VSADDU_VI, + RISCV_INS_VSADDU_VV, + RISCV_INS_VSADDU_VX, + RISCV_INS_VSADD_VI, + RISCV_INS_VSADD_VV, + RISCV_INS_VSADD_VX, + RISCV_INS_VSBC_VVM, + RISCV_INS_VSBC_VXM, + RISCV_INS_VSE16_V, + RISCV_INS_VSE32_V, + RISCV_INS_VSE64_V, + RISCV_INS_VSE8_V, + RISCV_INS_VSETIVLI, + RISCV_INS_VSETVL, + RISCV_INS_VSETVLI, + RISCV_INS_VSEXT_VF2, + RISCV_INS_VSEXT_VF4, + RISCV_INS_VSEXT_VF8, + RISCV_INS_VSHA2CH_VV, + RISCV_INS_VSHA2CL_VV, + RISCV_INS_VSHA2MS_VV, + RISCV_INS_VSLIDE1DOWN_VX, + RISCV_INS_VSLIDE1UP_VX, + RISCV_INS_VSLIDEDOWN_VI, + RISCV_INS_VSLIDEDOWN_VX, + RISCV_INS_VSLIDEUP_VI, + RISCV_INS_VSLIDEUP_VX, + RISCV_INS_VSLL_VI, + RISCV_INS_VSLL_VV, + RISCV_INS_VSLL_VX, + RISCV_INS_VSM3C_VI, + RISCV_INS_VSM3ME_VV, + RISCV_INS_VSM4K_VI, + RISCV_INS_VSM4R_VS, + RISCV_INS_VSM4R_VV, + RISCV_INS_VSMUL_VV, + RISCV_INS_VSMUL_VX, + RISCV_INS_VSM_V, + RISCV_INS_VSOXEI16_V, + RISCV_INS_VSOXEI32_V, + RISCV_INS_VSOXEI64_V, + RISCV_INS_VSOXEI8_V, + RISCV_INS_VSOXSEG2EI16_V, + RISCV_INS_VSOXSEG2EI32_V, + RISCV_INS_VSOXSEG2EI64_V, + RISCV_INS_VSOXSEG2EI8_V, + RISCV_INS_VSOXSEG3EI16_V, + RISCV_INS_VSOXSEG3EI32_V, + RISCV_INS_VSOXSEG3EI64_V, + RISCV_INS_VSOXSEG3EI8_V, + RISCV_INS_VSOXSEG4EI16_V, + RISCV_INS_VSOXSEG4EI32_V, + RISCV_INS_VSOXSEG4EI64_V, + RISCV_INS_VSOXSEG4EI8_V, + RISCV_INS_VSOXSEG5EI16_V, + RISCV_INS_VSOXSEG5EI32_V, + RISCV_INS_VSOXSEG5EI64_V, + RISCV_INS_VSOXSEG5EI8_V, + RISCV_INS_VSOXSEG6EI16_V, + RISCV_INS_VSOXSEG6EI32_V, + RISCV_INS_VSOXSEG6EI64_V, + RISCV_INS_VSOXSEG6EI8_V, + RISCV_INS_VSOXSEG7EI16_V, + RISCV_INS_VSOXSEG7EI32_V, + RISCV_INS_VSOXSEG7EI64_V, + RISCV_INS_VSOXSEG7EI8_V, + RISCV_INS_VSOXSEG8EI16_V, + RISCV_INS_VSOXSEG8EI32_V, + RISCV_INS_VSOXSEG8EI64_V, + RISCV_INS_VSOXSEG8EI8_V, + RISCV_INS_VSRA_VI, + RISCV_INS_VSRA_VV, + RISCV_INS_VSRA_VX, + RISCV_INS_VSRL_VI, + RISCV_INS_VSRL_VV, + RISCV_INS_VSRL_VX, + RISCV_INS_VSSE16_V, + RISCV_INS_VSSE32_V, + RISCV_INS_VSSE64_V, + RISCV_INS_VSSE8_V, + RISCV_INS_VSSEG2E16_V, + RISCV_INS_VSSEG2E32_V, + RISCV_INS_VSSEG2E64_V, + RISCV_INS_VSSEG2E8_V, + RISCV_INS_VSSEG3E16_V, + RISCV_INS_VSSEG3E32_V, + RISCV_INS_VSSEG3E64_V, + RISCV_INS_VSSEG3E8_V, + RISCV_INS_VSSEG4E16_V, + RISCV_INS_VSSEG4E32_V, + RISCV_INS_VSSEG4E64_V, + RISCV_INS_VSSEG4E8_V, + RISCV_INS_VSSEG5E16_V, + RISCV_INS_VSSEG5E32_V, + RISCV_INS_VSSEG5E64_V, + RISCV_INS_VSSEG5E8_V, + RISCV_INS_VSSEG6E16_V, + RISCV_INS_VSSEG6E32_V, + RISCV_INS_VSSEG6E64_V, + RISCV_INS_VSSEG6E8_V, + RISCV_INS_VSSEG7E16_V, + RISCV_INS_VSSEG7E32_V, + RISCV_INS_VSSEG7E64_V, + RISCV_INS_VSSEG7E8_V, + RISCV_INS_VSSEG8E16_V, + RISCV_INS_VSSEG8E32_V, + RISCV_INS_VSSEG8E64_V, + RISCV_INS_VSSEG8E8_V, + RISCV_INS_VSSRA_VI, + RISCV_INS_VSSRA_VV, + RISCV_INS_VSSRA_VX, + RISCV_INS_VSSRL_VI, + RISCV_INS_VSSRL_VV, + RISCV_INS_VSSRL_VX, + RISCV_INS_VSSSEG2E16_V, + RISCV_INS_VSSSEG2E32_V, + RISCV_INS_VSSSEG2E64_V, + RISCV_INS_VSSSEG2E8_V, + RISCV_INS_VSSSEG3E16_V, + RISCV_INS_VSSSEG3E32_V, + RISCV_INS_VSSSEG3E64_V, + RISCV_INS_VSSSEG3E8_V, + RISCV_INS_VSSSEG4E16_V, + RISCV_INS_VSSSEG4E32_V, + RISCV_INS_VSSSEG4E64_V, + RISCV_INS_VSSSEG4E8_V, + RISCV_INS_VSSSEG5E16_V, + RISCV_INS_VSSSEG5E32_V, + RISCV_INS_VSSSEG5E64_V, + RISCV_INS_VSSSEG5E8_V, + RISCV_INS_VSSSEG6E16_V, + RISCV_INS_VSSSEG6E32_V, + RISCV_INS_VSSSEG6E64_V, + RISCV_INS_VSSSEG6E8_V, + RISCV_INS_VSSSEG7E16_V, + RISCV_INS_VSSSEG7E32_V, + RISCV_INS_VSSSEG7E64_V, + RISCV_INS_VSSSEG7E8_V, + RISCV_INS_VSSSEG8E16_V, + RISCV_INS_VSSSEG8E32_V, + RISCV_INS_VSSSEG8E64_V, + RISCV_INS_VSSSEG8E8_V, + RISCV_INS_VSSUBU_VV, + RISCV_INS_VSSUBU_VX, + RISCV_INS_VSSUB_VV, + RISCV_INS_VSSUB_VX, + RISCV_INS_VSUB_VV, + RISCV_INS_VSUB_VX, + RISCV_INS_VSUXEI16_V, + RISCV_INS_VSUXEI32_V, + RISCV_INS_VSUXEI64_V, + RISCV_INS_VSUXEI8_V, + RISCV_INS_VSUXSEG2EI16_V, + RISCV_INS_VSUXSEG2EI32_V, + RISCV_INS_VSUXSEG2EI64_V, + RISCV_INS_VSUXSEG2EI8_V, + RISCV_INS_VSUXSEG3EI16_V, + RISCV_INS_VSUXSEG3EI32_V, + RISCV_INS_VSUXSEG3EI64_V, + RISCV_INS_VSUXSEG3EI8_V, + RISCV_INS_VSUXSEG4EI16_V, + RISCV_INS_VSUXSEG4EI32_V, + RISCV_INS_VSUXSEG4EI64_V, + RISCV_INS_VSUXSEG4EI8_V, + RISCV_INS_VSUXSEG5EI16_V, + RISCV_INS_VSUXSEG5EI32_V, + RISCV_INS_VSUXSEG5EI64_V, + RISCV_INS_VSUXSEG5EI8_V, + RISCV_INS_VSUXSEG6EI16_V, + RISCV_INS_VSUXSEG6EI32_V, + RISCV_INS_VSUXSEG6EI64_V, + RISCV_INS_VSUXSEG6EI8_V, + RISCV_INS_VSUXSEG7EI16_V, + RISCV_INS_VSUXSEG7EI32_V, + RISCV_INS_VSUXSEG7EI64_V, + RISCV_INS_VSUXSEG7EI8_V, + RISCV_INS_VSUXSEG8EI16_V, + RISCV_INS_VSUXSEG8EI32_V, + RISCV_INS_VSUXSEG8EI64_V, + RISCV_INS_VSUXSEG8EI8_V, + RISCV_INS_VT_MASKC, + RISCV_INS_VT_MASKCN, + RISCV_INS_VWADDU_VV, + RISCV_INS_VWADDU_VX, + RISCV_INS_VWADDU_WV, + RISCV_INS_VWADDU_WX, + RISCV_INS_VWADD_VV, + RISCV_INS_VWADD_VX, + RISCV_INS_VWADD_WV, + RISCV_INS_VWADD_WX, + RISCV_INS_VWMACCSU_VV, + RISCV_INS_VWMACCSU_VX, + RISCV_INS_VWMACCUS_VX, + RISCV_INS_VWMACCU_VV, + RISCV_INS_VWMACCU_VX, + RISCV_INS_VWMACC_VV, + RISCV_INS_VWMACC_VX, + RISCV_INS_VWMULSU_VV, + RISCV_INS_VWMULSU_VX, + RISCV_INS_VWMULU_VV, + RISCV_INS_VWMULU_VX, + RISCV_INS_VWMUL_VV, + RISCV_INS_VWMUL_VX, + RISCV_INS_VWREDSUMU_VS, + RISCV_INS_VWREDSUM_VS, + RISCV_INS_VWSLL_VI, + RISCV_INS_VWSLL_VV, + RISCV_INS_VWSLL_VX, + RISCV_INS_VWSUBU_VV, + RISCV_INS_VWSUBU_VX, + RISCV_INS_VWSUBU_WV, + RISCV_INS_VWSUBU_WX, + RISCV_INS_VWSUB_VV, + RISCV_INS_VWSUB_VX, + RISCV_INS_VWSUB_WV, + RISCV_INS_VWSUB_WX, + RISCV_INS_VXOR_VI, + RISCV_INS_VXOR_VV, + RISCV_INS_VXOR_VX, + RISCV_INS_VZEXT_VF2, + RISCV_INS_VZEXT_VF4, + RISCV_INS_VZEXT_VF8, RISCV_INS_WFI, + RISCV_INS_WRS_NTO, + RISCV_INS_WRS_STO, + RISCV_INS_XNOR, RISCV_INS_XOR, RISCV_INS_XORI, + RISCV_INS_XPERM4, + RISCV_INS_XPERM8, + RISCV_INS_ZIP, + + // clang-format on + // generated content end + RISCV_INS_ENDING, + + RISCV_INS_ALIAS_BEGIN, + // generated content begin + // clang-format off - RISCV_INS_ENDING, + RISCV_INS_ALIAS_NOP, // Real instr.: RISCV_ADDI + RISCV_INS_ALIAS_LI, // Real instr.: RISCV_ADDI + RISCV_INS_ALIAS_MV, // Real instr.: RISCV_ADDI + RISCV_INS_ALIAS_NOT, // Real instr.: RISCV_XORI + RISCV_INS_ALIAS_NEG, // Real instr.: RISCV_SUB + RISCV_INS_ALIAS_NEGW, // Real instr.: RISCV_SUBW + RISCV_INS_ALIAS_SEXT_W, // Real instr.: RISCV_ADDIW + RISCV_INS_ALIAS_SEQZ, // Real instr.: RISCV_SLTIU + RISCV_INS_ALIAS_SNEZ, // Real instr.: RISCV_SLTU + RISCV_INS_ALIAS_SLTZ, // Real instr.: RISCV_SLT + RISCV_INS_ALIAS_SGTZ, // Real instr.: RISCV_SLT + RISCV_INS_ALIAS_BEQZ, // Real instr.: RISCV_BEQ + RISCV_INS_ALIAS_BNEZ, // Real instr.: RISCV_BNE + RISCV_INS_ALIAS_BLEZ, // Real instr.: RISCV_BGE + RISCV_INS_ALIAS_BGEZ, // Real instr.: RISCV_BGE + RISCV_INS_ALIAS_BLTZ, // Real instr.: RISCV_BLT + RISCV_INS_ALIAS_BGTZ, // Real instr.: RISCV_BLT + RISCV_INS_ALIAS_J, // Real instr.: RISCV_JAL + RISCV_INS_ALIAS_JAL, // Real instr.: RISCV_JAL + RISCV_INS_ALIAS_JR, // Real instr.: RISCV_JALR + RISCV_INS_ALIAS_JALR, // Real instr.: RISCV_JALR + RISCV_INS_ALIAS_RET, // Real instr.: RISCV_JALR + RISCV_INS_ALIAS_FENCE, // Real instr.: RISCV_FENCE + RISCV_INS_ALIAS_PAUSE, // Real instr.: RISCV_FENCE + RISCV_INS_ALIAS_RDINSTRET, // Real instr.: RISCV_CSRRS + RISCV_INS_ALIAS_RDCYCLE, // Real instr.: RISCV_CSRRS + RISCV_INS_ALIAS_RDTIME, // Real instr.: RISCV_CSRRS + RISCV_INS_ALIAS_RDINSTRETH, // Real instr.: RISCV_CSRRS + RISCV_INS_ALIAS_RDCYCLEH, // Real instr.: RISCV_CSRRS + RISCV_INS_ALIAS_RDTIMEH, // Real instr.: RISCV_CSRRS + RISCV_INS_ALIAS_CSRR, // Real instr.: RISCV_CSRRS + RISCV_INS_ALIAS_CSRW, // Real instr.: RISCV_CSRRW + RISCV_INS_ALIAS_CSRS, // Real instr.: RISCV_CSRRS + RISCV_INS_ALIAS_CSRC, // Real instr.: RISCV_CSRRC + RISCV_INS_ALIAS_CSRWI, // Real instr.: RISCV_CSRRWI + RISCV_INS_ALIAS_CSRSI, // Real instr.: RISCV_CSRRSI + RISCV_INS_ALIAS_CSRCI, // Real instr.: RISCV_CSRRCI + RISCV_INS_ALIAS_SFENCE_VMA, // Real instr.: RISCV_SFENCE_VMA + RISCV_INS_ALIAS_HFENCE_GVMA, // Real instr.: RISCV_HFENCE_GVMA + RISCV_INS_ALIAS_HFENCE_VVMA, // Real instr.: RISCV_HFENCE_VVMA + RISCV_INS_ALIAS_NTL_P1, // Real instr.: RISCV_ADD + RISCV_INS_ALIAS_NTL_PALL, // Real instr.: RISCV_ADD + RISCV_INS_ALIAS_NTL_S1, // Real instr.: RISCV_ADD + RISCV_INS_ALIAS_NTL_ALL, // Real instr.: RISCV_ADD + RISCV_INS_ALIAS_LPAD, // Real instr.: RISCV_AUIPC + RISCV_INS_ALIAS_FMV_S, // Real instr.: RISCV_FSGNJ_S + RISCV_INS_ALIAS_FABS_S, // Real instr.: RISCV_FSGNJX_S + RISCV_INS_ALIAS_FNEG_S, // Real instr.: RISCV_FSGNJN_S + RISCV_INS_ALIAS_FRCSR, // Real instr.: RISCV_CSRRS + RISCV_INS_ALIAS_FSCSR, // Real instr.: RISCV_CSRRW + RISCV_INS_ALIAS_FRRM, // Real instr.: RISCV_CSRRS + RISCV_INS_ALIAS_FSRM, // Real instr.: RISCV_CSRRW + RISCV_INS_ALIAS_FSRMI, // Real instr.: RISCV_CSRRWI + RISCV_INS_ALIAS_FRFLAGS, // Real instr.: RISCV_CSRRS + RISCV_INS_ALIAS_FSFLAGS, // Real instr.: RISCV_CSRRW + RISCV_INS_ALIAS_FSFLAGSI, // Real instr.: RISCV_CSRRWI + RISCV_INS_ALIAS_FMV_D, // Real instr.: RISCV_FSGNJ_D + RISCV_INS_ALIAS_FABS_D, // Real instr.: RISCV_FSGNJX_D + RISCV_INS_ALIAS_FNEG_D, // Real instr.: RISCV_FSGNJN_D + RISCV_INS_ALIAS_FMV_H, // Real instr.: RISCV_FSGNJ_H + RISCV_INS_ALIAS_FABS_H, // Real instr.: RISCV_FSGNJX_H + RISCV_INS_ALIAS_FNEG_H, // Real instr.: RISCV_FSGNJN_H + RISCV_INS_ALIAS_ZEXT_W, // Real instr.: RISCV_ADD_UW + RISCV_INS_ALIAS_VL1R_V, // Real instr.: RISCV_VL1RE8_V + RISCV_INS_ALIAS_VL2R_V, // Real instr.: RISCV_VL2RE8_V + RISCV_INS_ALIAS_VL4R_V, // Real instr.: RISCV_VL4RE8_V + RISCV_INS_ALIAS_VL8R_V, // Real instr.: RISCV_VL8RE8_V + RISCV_INS_ALIAS_VNEG_V, // Real instr.: RISCV_VRSUB_VX + RISCV_INS_ALIAS_VWCVT_X_X_V, // Real instr.: RISCV_VWADD_VX + RISCV_INS_ALIAS_VWCVTU_X_X_V, // Real instr.: RISCV_VWADDU_VX + RISCV_INS_ALIAS_VNOT_V, // Real instr.: RISCV_VXOR_VI + RISCV_INS_ALIAS_VNCVT_X_X_W, // Real instr.: RISCV_VNSRL_WX + RISCV_INS_ALIAS_VFNEG_V, // Real instr.: RISCV_VFSGNJN_VV + RISCV_INS_ALIAS_VFABS_V, // Real instr.: RISCV_VFSGNJX_VV + RISCV_INS_ALIAS_VMMV_M, // Real instr.: RISCV_VMAND_MM + RISCV_INS_ALIAS_VMCLR_M, // Real instr.: RISCV_VMXOR_MM + RISCV_INS_ALIAS_VMSET_M, // Real instr.: RISCV_VMXNOR_MM + RISCV_INS_ALIAS_VMNOT_M, // Real instr.: RISCV_VMNAND_MM + RISCV_INS_ALIAS_C_NTL_P1, // Real instr.: RISCV_C_ADD_HINT + RISCV_INS_ALIAS_C_NTL_PALL, // Real instr.: RISCV_C_ADD_HINT + RISCV_INS_ALIAS_C_NTL_S1, // Real instr.: RISCV_C_ADD_HINT + RISCV_INS_ALIAS_C_NTL_ALL, // Real instr.: RISCV_C_ADD_HINT + RISCV_INS_ALIAS_CV_MULS, // Real instr.: RISCV_CV_MULSN + RISCV_INS_ALIAS_CV_MULHHS, // Real instr.: RISCV_CV_MULHHSN + RISCV_INS_ALIAS_CV_MULU, // Real instr.: RISCV_CV_MULUN + RISCV_INS_ALIAS_CV_MULHHU, // Real instr.: RISCV_CV_MULHHUN + + // clang-format on + // generated content end + RISCV_INS_ALIAS_END, } riscv_insn; //> Group of RISCV instructions typedef enum riscv_insn_group { - RISCV_GRP_INVALID = 0, ///< = CS_GRP_INVALID + RISCV_GRP_INVALID = 0, ///< = CS_GRP_INVALID + + // Generic groups + // all jump instructions (conditional+direct+indirect jumps) + RISCV_GRP_JUMP, ///< = CS_GRP_JUMP + // all call instructions + RISCV_GRP_CALL, ///< = CS_GRP_CALL + // all return instructions + RISCV_GRP_RET, ///< = CS_GRP_RET + // all interrupt instructions (int+syscall) + RISCV_GRP_INT, ///< = CS_GRP_INT + // all interrupt return instructions + RISCV_GRP_IRET, ///< = CS_GRP_IRET + // all privileged instructions + RISCV_GRP_PRIVILEGE, ///< = CS_GRP_PRIVILEGE + // all relative branching instructions + RISCV_GRP_BRANCH_RELATIVE, ///< = CS_GRP_BRANCH_RELATIVE + + // Architecture-specific groups + // generated content begin + // clang-format off - // Generic groups - // all jump instructions (conditional+direct+indirect jumps) - RISCV_GRP_JUMP, ///< = CS_GRP_JUMP - // all call instructions - RISCV_GRP_CALL, ///< = CS_GRP_CALL - // all return instructions - RISCV_GRP_RET, ///< = CS_GRP_RET - // all interrupt instructions (int+syscall) - RISCV_GRP_INT, ///< = CS_GRP_INT - // all interrupt return instructions - RISCV_GRP_IRET, ///< = CS_GRP_IRET - // all privileged instructions - RISCV_GRP_PRIVILEGE, ///< = CS_GRP_PRIVILEGE - // all relative branching instructions - RISCV_GRP_BRANCH_RELATIVE, ///< = CS_GRP_BRANCH_RELATIVE + RISCV_FEATURE_HASSTDEXTI = 128, + RISCV_FEATURE_HASSTDEXTZICBOM, + RISCV_FEATURE_HASSTDEXTZICBOP, + RISCV_FEATURE_HASSTDEXTZICBOZ, + RISCV_FEATURE_HASSTDEXTZICSR, + RISCV_FEATURE_HASSTDEXTZICOND, + RISCV_FEATURE_HASSTDEXTZIFENCEI, + RISCV_FEATURE_HASSTDEXTZIHINTPAUSE, + RISCV_FEATURE_HASSTDEXTZIHINTNTL, + RISCV_FEATURE_HASSTDEXTZIMOP, + RISCV_FEATURE_HASSTDEXTZICFILP, + RISCV_FEATURE_HASSTDEXTZICFISS, + RISCV_FEATURE_HASSTDEXTM, + RISCV_FEATURE_HASSTDEXTMORZMMUL, + RISCV_FEATURE_HASSTDEXTA, + RISCV_FEATURE_HASSTDEXTZTSO, + RISCV_FEATURE_HASSTDEXTZACAS, + RISCV_FEATURE_HASSTDEXTZAWRS, + RISCV_FEATURE_HASSTDEXTF, + RISCV_FEATURE_HASSTDEXTD, + RISCV_FEATURE_HASSTDEXTZFHMIN, + RISCV_FEATURE_HASSTDEXTZFH, + RISCV_FEATURE_HASSTDEXTZFBFMIN, + RISCV_FEATURE_HASHALFFPLOADSTOREMOVE, + RISCV_FEATURE_HASSTDEXTZFA, + RISCV_FEATURE_HASSTDEXTZFINX, + RISCV_FEATURE_HASSTDEXTZDINX, + RISCV_FEATURE_HASSTDEXTZHINXMIN, + RISCV_FEATURE_HASSTDEXTZHINX, + RISCV_FEATURE_HASSTDEXTC, + RISCV_FEATURE_HASRVCHINTS, + RISCV_FEATURE_HASSTDEXTCORZCA, + RISCV_FEATURE_HASSTDEXTZCB, + RISCV_FEATURE_HASSTDEXTCORZCD, + RISCV_FEATURE_HASSTDEXTZCMP, + RISCV_FEATURE_HASSTDEXTZCMT, + RISCV_FEATURE_HASSTDEXTCORZCFORZCE, + RISCV_FEATURE_HASSTDEXTZCMOP, + RISCV_FEATURE_HASSTDEXTZBA, + RISCV_FEATURE_HASSTDEXTZBB, + RISCV_FEATURE_HASSTDEXTZBC, + RISCV_FEATURE_HASSTDEXTZBS, + RISCV_FEATURE_HASSTDEXTZBKB, + RISCV_FEATURE_HASSTDEXTZBKX, + RISCV_FEATURE_HASSTDEXTZBBORZBKB, + RISCV_FEATURE_HASSTDEXTZBKC, + RISCV_FEATURE_HASSTDEXTZBCORZBKC, + RISCV_FEATURE_HASSTDEXTZKND, + RISCV_FEATURE_HASSTDEXTZKNE, + RISCV_FEATURE_HASSTDEXTZKNDORZKNE, + RISCV_FEATURE_HASSTDEXTZKNH, + RISCV_FEATURE_HASSTDEXTZKSED, + RISCV_FEATURE_HASSTDEXTZKSH, + RISCV_FEATURE_HASSTDEXTZKR, + RISCV_FEATURE_HASSTDEXTZVFBFMIN, + RISCV_FEATURE_HASSTDEXTZVFBFWMA, + RISCV_FEATURE_HASSTDEXTZFHORZVFH, + RISCV_FEATURE_HASSTDEXTZVKB, + RISCV_FEATURE_HASSTDEXTZVBB, + RISCV_FEATURE_HASSTDEXTZVBC, + RISCV_FEATURE_HASSTDEXTZVKG, + RISCV_FEATURE_HASSTDEXTZVKNED, + RISCV_FEATURE_HASSTDEXTZVKNHA, + RISCV_FEATURE_HASSTDEXTZVKNHB, + RISCV_FEATURE_HASSTDEXTZVKNHAORZVKNHB, + RISCV_FEATURE_HASSTDEXTZVKSED, + RISCV_FEATURE_HASSTDEXTZVKSH, + RISCV_FEATURE_HASVINSTRUCTIONS, + RISCV_FEATURE_HASVINSTRUCTIONSI64, + RISCV_FEATURE_HASVINSTRUCTIONSANYF, + RISCV_FEATURE_HASVINSTRUCTIONSF16MINIMAL, + RISCV_FEATURE_HASSTDEXTH, + RISCV_FEATURE_HASSTDEXTSVINVAL, + RISCV_FEATURE_HASVENDORXVENTANACONDOPS, + RISCV_FEATURE_HASVENDORXTHEADBA, + RISCV_FEATURE_HASVENDORXTHEADBB, + RISCV_FEATURE_HASVENDORXTHEADBS, + RISCV_FEATURE_HASVENDORXTHEADCONDMOV, + RISCV_FEATURE_HASVENDORXTHEADCMO, + RISCV_FEATURE_HASVENDORXTHEADFMEMIDX, + RISCV_FEATURE_HASVENDORXTHEADMAC, + RISCV_FEATURE_HASVENDORXTHEADMEMIDX, + RISCV_FEATURE_HASVENDORXTHEADMEMPAIR, + RISCV_FEATURE_HASVENDORXTHEADSYNC, + RISCV_FEATURE_HASVENDORXTHEADVDOT, + RISCV_FEATURE_HASVENDORXSFVCP, + RISCV_FEATURE_HASVENDORXSFVQMACCDOD, + RISCV_FEATURE_HASVENDORXSFVQMACCQOQ, + RISCV_FEATURE_HASVENDORXSFVFWMACCQQQ, + RISCV_FEATURE_HASVENDORXSFVFNRCLIPXFQF, + RISCV_FEATURE_HASVENDORXCVELW, + RISCV_FEATURE_HASVENDORXCVBITMANIP, + RISCV_FEATURE_HASVENDORXCVMAC, + RISCV_FEATURE_HASVENDORXCVMEM, + RISCV_FEATURE_HASVENDORXCVALU, + RISCV_FEATURE_HASVENDORXCVSIMD, + RISCV_FEATURE_HASVENDORXCVBI, + RISCV_FEATURE_ISRV64, + RISCV_FEATURE_ISRV32, + RISCV_FEATURE_ISRVE, - // Architecture-specific groups - RISCV_GRP_ISRV32 = 128, - RISCV_GRP_ISRV64, - RISCV_GRP_HASSTDEXTA, - RISCV_GRP_HASSTDEXTC, - RISCV_GRP_HASSTDEXTD, - RISCV_GRP_HASSTDEXTF, - RISCV_GRP_HASSTDEXTM, - RISCV_GRP_ENDING, + // clang-format on + // generated content end + + RISCV_GRP_ENDING, } riscv_insn_group; #ifdef __cplusplus @@ -518,3 +2453,4 @@ typedef enum riscv_insn_group { #endif #endif + diff --git a/suite/MC/RISCV/XCValu_valid_riscv32_riscv_xcvalu_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/XCValu_valid_riscv32_riscv_xcvalu_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..4aaf90e0f4 --- /dev/null +++ b/suite/MC/RISCV/XCValu_valid_riscv32_riscv_xcvalu_syntax_no_alias_text.txt.cs @@ -0,0 +1,73 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32"|"CS_MODE_RISCV_XCVALU", None +0xab,0x32,0x73,0x86 == cv.addurnr t0, t1, t2 +0x2b,0xb5,0xc5,0x86 == cv.addurnr a0, a1, a2 +0xab,0x32,0x73,0x5c == cv.maxu t0, t1, t2 +0x2b,0xb5,0xc5,0x5c == cv.maxu a0, a1, a2 +0xab,0x32,0x73,0x8c == cv.subrnr t0, t1, t2 +0x2b,0xb5,0xc5,0x8c == cv.subrnr a0, a1, a2 +0xab,0x32,0x73,0x52 == cv.slet t0, t1, t2 +0x2b,0xb5,0xc5,0x52 == cv.slet a0, a1, a2 +0xdb,0x32,0x73,0x80 == cv.subrn t0, t1, t2, 0 +0xdb,0x32,0x73,0xa0 == cv.subrn t0, t1, t2, 16 +0x5b,0xb5,0x05,0xbe == cv.subrn a0, a1, zero, 31 +0xab,0x32,0x73,0x88 == cv.subnr t0, t1, t2 +0x2b,0xb5,0xc5,0x88 == cv.subnr a0, a1, a2 +0xab,0x32,0x73,0x82 == cv.addunr t0, t1, t2 +0x2b,0xb5,0xc5,0x82 == cv.addunr a0, a1, a2 +0xdb,0x22,0x73,0xc0 == cv.addurn t0, t1, t2, 0 +0xdb,0x22,0x73,0xe0 == cv.addurn t0, t1, t2, 16 +0x5b,0xa5,0x05,0xfe == cv.addurn a0, a1, zero, 31 +0xdb,0x22,0x73,0x40 == cv.addun t0, t1, t2, 0 +0xdb,0x22,0x73,0x60 == cv.addun t0, t1, t2, 16 +0x5b,0xa5,0x05,0x7e == cv.addun a0, a1, zero, 31 +0xab,0x32,0x03,0x72 == cv.clipu t0, t1, 0 +0xab,0x32,0x03,0x73 == cv.clipu t0, t1, 16 +0x2b,0x35,0xf0,0x73 == cv.clipu a0, zero, 31 +0xab,0x32,0x03,0x70 == cv.clip t0, t1, 0 +0xab,0x32,0x03,0x71 == cv.clip t0, t1, 16 +0x2b,0x35,0xf0,0x71 == cv.clip a0, zero, 31 +0xab,0x32,0x03,0x62 == cv.exthz t0, t1 +0x2b,0xb5,0x05,0x62 == cv.exthz a0, a1 +0xab,0x32,0x73,0x5a == cv.max t0, t1, t2 +0x2b,0xb5,0xc5,0x5a == cv.max a0, a1, a2 +0xab,0x32,0x73,0x74 == cv.clipr t0, t1, t2 +0x2b,0xb5,0xc5,0x74 == cv.clipr a0, a1, a2 +0xdb,0x32,0x73,0x00 == cv.subn t0, t1, t2, 0 +0xdb,0x32,0x73,0x20 == cv.subn t0, t1, t2, 16 +0x5b,0xb5,0x05,0x3e == cv.subn a0, a1, zero, 31 +0xab,0x32,0x03,0x66 == cv.extbz t0, t1 +0x2b,0xb5,0x05,0x66 == cv.extbz a0, a1 +0xab,0x32,0x03,0x50 == cv.abs t0, t1 +0x2b,0xb5,0x05,0x50 == cv.abs a0, a1 +0xab,0x32,0x73,0x76 == cv.clipur t0, t1, t2 +0x2b,0xb5,0xc5,0x76 == cv.clipur a0, a1, a2 +0xab,0x32,0x73,0x58 == cv.minu t0, t1, t2 +0x2b,0xb5,0xc5,0x58 == cv.minu a0, a1, a2 +0xdb,0x22,0x73,0x00 == cv.addn t0, t1, t2, 0 +0xdb,0x22,0x73,0x20 == cv.addn t0, t1, t2, 16 +0x5b,0xa5,0x05,0x3e == cv.addn a0, a1, zero, 31 +0xab,0x32,0x73,0x8a == cv.subunr t0, t1, t2 +0x2b,0xb5,0xc5,0x8a == cv.subunr a0, a1, a2 +0xab,0x32,0x03,0x64 == cv.extbs t0, t1 +0x2b,0xb5,0x05,0x64 == cv.extbs a0, a1 +0xab,0x32,0x73,0x54 == cv.sletu t0, t1, t2 +0x2b,0xb5,0xc5,0x54 == cv.sletu a0, a1, a2 +0xab,0x32,0x73,0x56 == cv.min t0, t1, t2 +0x2b,0xb5,0xc5,0x56 == cv.min a0, a1, a2 +0xab,0x32,0x73,0x8e == cv.suburnr t0, t1, t2 +0x2b,0xb5,0xc5,0x8e == cv.suburnr a0, a1, a2 +0xab,0x32,0x73,0x84 == cv.addrnr t0, t1, t2 +0x2b,0xb5,0xc5,0x84 == cv.addrnr a0, a1, a2 +0xab,0x32,0x03,0x60 == cv.exths t0, t1 +0x2b,0xb5,0x05,0x60 == cv.exths a0, a1 +0xdb,0x22,0x73,0x80 == cv.addrn t0, t1, t2, 0 +0xdb,0x22,0x73,0xa0 == cv.addrn t0, t1, t2, 16 +0x5b,0xa5,0x05,0xbe == cv.addrn a0, a1, zero, 31 +0xdb,0x32,0x73,0xc0 == cv.suburn t0, t1, t2, 0 +0xdb,0x32,0x73,0xe0 == cv.suburn t0, t1, t2, 16 +0x5b,0xb5,0x05,0xfe == cv.suburn a0, a1, zero, 31 +0xab,0x32,0x73,0x80 == cv.addnr t0, t1, t2 +0x2b,0xb5,0xc5,0x80 == cv.addnr a0, a1, a2 +0xdb,0x32,0x73,0x40 == cv.subun t0, t1, t2, 0 +0xdb,0x32,0x73,0x60 == cv.subun t0, t1, t2, 16 +0x5b,0xb5,0x05,0x7e == cv.subun a0, a1, zero, 31 \ No newline at end of file diff --git a/suite/MC/RISCV/XCVbi_riscv32_riscv_xcvbi.txt.cs b/suite/MC/RISCV/XCVbi_riscv32_riscv_xcvbi.txt.cs new file mode 100644 index 0000000000..9272cb1040 --- /dev/null +++ b/suite/MC/RISCV/XCVbi_riscv32_riscv_xcvbi.txt.cs @@ -0,0 +1,5 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32"|"CS_MODE_RISCV_XCVBI", None +0x0b,0xe0,0x02,0x00 == cv.beqimm t0, 0, 0 +0x0b,0x65,0x55,0x02 == cv.beqimm a0, 5, 42 +0x0b,0xf0,0x02,0x00 == cv.bneimm t0, 0, 0 +0x0b,0x75,0x55,0x02 == cv.bneimm a0, 5, 42 \ No newline at end of file diff --git a/suite/MC/RISCV/XCVbitmanip_riscv32_riscv_xcvbitmanip.txt.cs b/suite/MC/RISCV/XCVbitmanip_riscv32_riscv_xcvbitmanip.txt.cs new file mode 100644 index 0000000000..fcd1ee9bf3 --- /dev/null +++ b/suite/MC/RISCV/XCVbitmanip_riscv32_riscv_xcvbitmanip.txt.cs @@ -0,0 +1,49 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32"|"CS_MODE_RISCV_XCVBITMANIP", None +0xdb,0x02,0x13,0x00 == cv.extract t0, t1, 0, 1 +0x5b,0x85,0x25,0x23 == cv.extract a0, a1, 17, 18 +0x5b,0x84,0xf4,0x3d == cv.extract s0, s1, 30, 31 +0xdb,0x02,0x13,0x40 == cv.extractu t0, t1, 0, 1 +0x5b,0x85,0x25,0x63 == cv.extractu a0, a1, 17, 18 +0x5b,0x84,0xf4,0x7d == cv.extractu s0, s1, 30, 31 +0xdb,0x02,0x13,0x80 == cv.insert t0, t1, 0, 1 +0x5b,0x85,0x25,0xa3 == cv.insert a0, a1, 17, 18 +0x5b,0x84,0xf4,0xbd == cv.insert s0, s1, 30, 31 +0xdb,0x12,0x13,0x00 == cv.bclr t0, t1, 0, 1 +0x5b,0x95,0x25,0x23 == cv.bclr a0, a1, 17, 18 +0x5b,0x94,0xf4,0x3d == cv.bclr s0, s1, 30, 31 +0xdb,0x12,0x13,0x40 == cv.bset t0, t1, 0, 1 +0x5b,0x95,0x25,0x63 == cv.bset a0, a1, 17, 18 +0x5b,0x94,0xf4,0x7d == cv.bset s0, s1, 30, 31 +0xdb,0x12,0x13,0xc0 == cv.bitrev t0, t1, 0, 1 +0x5b,0x95,0x25,0xc3 == cv.bitrev a0, a1, 1, 18 +0x5b,0x94,0xf4,0xc5 == cv.bitrev s0, s1, 2, 31 +0xab,0x32,0x73,0x30 == cv.extractr t0, t1, t2 +0x2b,0xb5,0xc5,0x30 == cv.extractr a0, a1, a2 +0x2b,0xb4,0x24,0x31 == cv.extractr s0, s1, s2 +0xab,0x32,0x73,0x32 == cv.extractur t0, t1, t2 +0x2b,0xb5,0xc5,0x32 == cv.extractur a0, a1, a2 +0x2b,0xb4,0x24,0x33 == cv.extractur s0, s1, s2 +0xab,0x32,0x73,0x34 == cv.insertr t0, t1, t2 +0x2b,0xb5,0xc5,0x34 == cv.insertr a0, a1, a2 +0x2b,0xb4,0x24,0x35 == cv.insertr s0, s1, s2 +0xab,0x32,0x73,0x38 == cv.bclrr t0, t1, t2 +0x2b,0xb5,0xc5,0x38 == cv.bclrr a0, a1, a2 +0x2b,0xb4,0x24,0x39 == cv.bclrr s0, s1, s2 +0xab,0x32,0x73,0x3a == cv.bsetr t0, t1, t2 +0x2b,0xb5,0xc5,0x3a == cv.bsetr a0, a1, a2 +0x2b,0xb4,0x24,0x3b == cv.bsetr s0, s1, s2 +0xab,0x32,0x73,0x40 == cv.ror t0, t1, t2 +0x2b,0xb5,0xc5,0x40 == cv.ror a0, a1, a2 +0x2b,0xb4,0x24,0x41 == cv.ror s0, s1, s2 +0xab,0x32,0x03,0x42 == cv.ff1 t0, t1 +0x2b,0xb5,0x05,0x42 == cv.ff1 a0, a1 +0x2b,0xb4,0x04,0x42 == cv.ff1 s0, s1 +0xab,0x32,0x03,0x44 == cv.fl1 t0, t1 +0x2b,0xb5,0x05,0x44 == cv.fl1 a0, a1 +0x2b,0xb4,0x04,0x44 == cv.fl1 s0, s1 +0xab,0x32,0x03,0x46 == cv.clb t0, t1 +0x2b,0xb5,0x05,0x46 == cv.clb a0, a1 +0x2b,0xb4,0x04,0x46 == cv.clb s0, s1 +0xab,0x32,0x03,0x48 == cv.cnt t0, t1 +0x2b,0xb5,0x05,0x48 == cv.cnt a0, a1 +0x2b,0xb4,0x04,0x48 == cv.cnt s0, s1 \ No newline at end of file diff --git a/suite/MC/RISCV/XCVelw_valid_riscv32_riscv_xcvelw.txt.cs b/suite/MC/RISCV/XCVelw_valid_riscv32_riscv_xcvelw.txt.cs new file mode 100644 index 0000000000..d5b2dfcf7e --- /dev/null +++ b/suite/MC/RISCV/XCVelw_valid_riscv32_riscv_xcvelw.txt.cs @@ -0,0 +1,4 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32"|"CS_MODE_RISCV_XCVELW", None +0x0b,0x35,0x05,0x40 == cv.elw a0, 1024(a0) +0x8b,0xb5,0x15,0x00 == cv.elw a1, 1(a1) +0x0b,0xb6,0x06,0xc0 == cv.elw a2, -1024(a3) \ No newline at end of file diff --git a/suite/MC/RISCV/XCVmac_valid_riscv32_riscv_xcvmac_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/XCVmac_valid_riscv32_riscv_xcvmac_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..6e0f478145 --- /dev/null +++ b/suite/MC/RISCV/XCVmac_valid_riscv32_riscv_xcvmac_syntax_no_alias_text.txt.cs @@ -0,0 +1,57 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32"|"CS_MODE_RISCV_XCVMAC", None +0xab,0x32,0x73,0x90 == cv.mac t0, t1, t2 +0xab,0x32,0x03,0x90 == cv.mac t0, t1, zero +0xdb,0x62,0x73,0x40 == cv.machhsn t0, t1, t2, 0 +0xdb,0x62,0x03,0x60 == cv.machhsn t0, t1, zero, 16 +0xdb,0x62,0x03,0x7e == cv.machhsn t0, t1, zero, 31 +0xdb,0x62,0x73,0xc0 == cv.machhsrn t0, t1, t2, 0 +0xdb,0x62,0x03,0xe0 == cv.machhsrn t0, t1, zero, 16 +0xdb,0x62,0x03,0xfe == cv.machhsrn t0, t1, zero, 31 +0xdb,0x72,0x73,0x40 == cv.machhun t0, t1, t2, 0 +0xdb,0x72,0x03,0x60 == cv.machhun t0, t1, zero, 16 +0xdb,0x72,0x03,0x7e == cv.machhun t0, t1, zero, 31 +0xdb,0x72,0x73,0xc0 == cv.machhurn t0, t1, t2, 0 +0xdb,0x72,0x03,0xe0 == cv.machhurn t0, t1, zero, 16 +0xdb,0x72,0x03,0xfe == cv.machhurn t0, t1, zero, 31 +0xdb,0x62,0x73,0x00 == cv.macsn t0, t1, t2, 0 +0xdb,0x62,0x03,0x20 == cv.macsn t0, t1, zero, 16 +0xdb,0x62,0x03,0x3e == cv.macsn t0, t1, zero, 31 +0xdb,0x62,0x73,0x80 == cv.macsrn t0, t1, t2, 0 +0xdb,0x62,0x03,0xa0 == cv.macsrn t0, t1, zero, 16 +0xdb,0x62,0x03,0xbe == cv.macsrn t0, t1, zero, 31 +0xdb,0x72,0x73,0x00 == cv.macun t0, t1, t2, 0 +0xdb,0x72,0x03,0x20 == cv.macun t0, t1, zero, 16 +0xdb,0x72,0x03,0x3e == cv.macun t0, t1, zero, 31 +0xdb,0x72,0x73,0x80 == cv.macurn t0, t1, t2, 0 +0xdb,0x72,0x03,0xa0 == cv.macurn t0, t1, zero, 16 +0xdb,0x72,0x03,0xbe == cv.macurn t0, t1, zero, 31 +0xab,0x32,0x73,0x92 == cv.msu t0, t1, t2 +0xab,0x32,0x03,0x92 == cv.msu t0, t1, zero +0xdb,0x42,0x73,0x40 == cv.mulhhsn t0, t1, t2, 0 +0xdb,0x42,0x03,0x40 == cv.mulhhsn t0, t1, zero, 0 +0xdb,0x42,0x03,0x60 == cv.mulhhsn t0, t1, zero, 16 +0xdb,0x42,0x03,0x7e == cv.mulhhsn t0, t1, zero, 31 +0xdb,0x42,0x73,0xc0 == cv.mulhhsrn t0, t1, t2, 0 +0xdb,0x42,0x03,0xe0 == cv.mulhhsrn t0, t1, zero, 16 +0xdb,0x42,0x03,0xfe == cv.mulhhsrn t0, t1, zero, 31 +0xdb,0x52,0x73,0x40 == cv.mulhhun t0, t1, t2, 0 +0xdb,0x52,0x03,0x40 == cv.mulhhun t0, t1, zero, 0 +0xdb,0x52,0x03,0x60 == cv.mulhhun t0, t1, zero, 16 +0xdb,0x52,0x03,0x7e == cv.mulhhun t0, t1, zero, 31 +0xdb,0x52,0x73,0xc0 == cv.mulhhurn t0, t1, t2, 0 +0xdb,0x52,0x03,0xe0 == cv.mulhhurn t0, t1, zero, 16 +0xdb,0x52,0x03,0xfe == cv.mulhhurn t0, t1, zero, 31 +0xdb,0x42,0x73,0x00 == cv.mulsn t0, t1, t2, 0 +0xdb,0x42,0x03,0x00 == cv.mulsn t0, t1, zero, 0 +0xdb,0x42,0x03,0x20 == cv.mulsn t0, t1, zero, 16 +0xdb,0x42,0x03,0x3e == cv.mulsn t0, t1, zero, 31 +0xdb,0x42,0x73,0x80 == cv.mulsrn t0, t1, t2, 0 +0xdb,0x42,0x03,0xa0 == cv.mulsrn t0, t1, zero, 16 +0xdb,0x42,0x03,0xbe == cv.mulsrn t0, t1, zero, 31 +0xdb,0x52,0x73,0x00 == cv.mulun t0, t1, t2, 0 +0xdb,0x52,0x03,0x00 == cv.mulun t0, t1, zero, 0 +0xdb,0x52,0x03,0x20 == cv.mulun t0, t1, zero, 16 +0xdb,0x52,0x03,0x3e == cv.mulun t0, t1, zero, 31 +0xdb,0x52,0x73,0x80 == cv.mulurn t0, t1, t2, 0 +0xdb,0x52,0x03,0xa0 == cv.mulurn t0, t1, zero, 16 +0xdb,0x52,0x03,0xbe == cv.mulurn t0, t1, zero, 31 \ No newline at end of file diff --git a/suite/MC/RISCV/XCVmem_valid_riscv32_riscv_xcvmem.txt.cs b/suite/MC/RISCV/XCVmem_valid_riscv32_riscv_xcvmem.txt.cs new file mode 100644 index 0000000000..20598ebcb1 --- /dev/null +++ b/suite/MC/RISCV/XCVmem_valid_riscv32_riscv_xcvmem.txt.cs @@ -0,0 +1,49 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32"|"CS_MODE_RISCV_XCVMEM", None +0x8b,0x02,0x03,0x00 == cv.lb t0, (t1), 0 +0x0b,0x85,0xf5,0x7f == cv.lb a0, (a1), 2047 +0xab,0x32,0x73,0x00 == cv.lb t0, (t1), t2 +0x2b,0xb5,0xc5,0x00 == cv.lb a0, (a1), a2 +0xab,0x32,0x73,0x08 == cv.lb t0, t2(t1) +0x2b,0xb5,0xc5,0x08 == cv.lb a0, a2(a1) +0x8b,0x42,0x03,0x00 == cv.lbu t0, (t1), 0 +0x0b,0xc5,0xf5,0x7f == cv.lbu a0, (a1), 2047 +0xab,0x32,0x73,0x10 == cv.lbu t0, (t1), t2 +0x2b,0xb5,0xc5,0x10 == cv.lbu a0, (a1), a2 +0xab,0x32,0x73,0x18 == cv.lbu t0, t2(t1) +0x2b,0xb5,0xc5,0x18 == cv.lbu a0, a2(a1) +0x8b,0x12,0x03,0x00 == cv.lh t0, (t1), 0 +0x0b,0x95,0xf5,0x7f == cv.lh a0, (a1), 2047 +0xab,0x32,0x73,0x02 == cv.lh t0, (t1), t2 +0x2b,0xb5,0xc5,0x02 == cv.lh a0, (a1), a2 +0xab,0x32,0x73,0x0a == cv.lh t0, t2(t1) +0x2b,0xb5,0xc5,0x0a == cv.lh a0, a2(a1) +0x8b,0x52,0x03,0x00 == cv.lhu t0, (t1), 0 +0x0b,0xd5,0xf5,0x7f == cv.lhu a0, (a1), 2047 +0xab,0x32,0x73,0x12 == cv.lhu t0, (t1), t2 +0x2b,0xb5,0xc5,0x12 == cv.lhu a0, (a1), a2 +0xab,0x32,0x73,0x1a == cv.lhu t0, t2(t1) +0x2b,0xb5,0xc5,0x1a == cv.lhu a0, a2(a1) +0x8b,0x22,0x03,0x00 == cv.lw t0, (t1), 0 +0x0b,0xa5,0xf5,0x7f == cv.lw a0, (a1), 2047 +0xab,0x32,0x73,0x04 == cv.lw t0, (t1), t2 +0x2b,0xb5,0xc5,0x04 == cv.lw a0, (a1), a2 +0xab,0x32,0x73,0x0c == cv.lw t0, t2(t1) +0x2b,0xb5,0xc5,0x0c == cv.lw a0, a2(a1) +0x2b,0x00,0x53,0x00 == cv.sb t0, (t1), 0 +0xab,0x8f,0xa5,0x7e == cv.sb a0, (a1), 2047 +0xab,0x33,0x53,0x20 == cv.sb t0, (t1), t2 +0x2b,0xb6,0xa5,0x20 == cv.sb a0, (a1), a2 +0xab,0x33,0x53,0x28 == cv.sb t0, t2(t1) +0x2b,0xb6,0xa5,0x28 == cv.sb a0, a2(a1) +0x2b,0x10,0x53,0x00 == cv.sh t0, (t1), 0 +0xab,0x9f,0xa5,0x7e == cv.sh a0, (a1), 2047 +0xab,0x33,0x53,0x22 == cv.sh t0, (t1), t2 +0x2b,0xb6,0xa5,0x22 == cv.sh a0, (a1), a2 +0xab,0x33,0x53,0x2a == cv.sh t0, t2(t1) +0x2b,0xb6,0xa5,0x2a == cv.sh a0, a2(a1) +0x2b,0x20,0x53,0x00 == cv.sw t0, (t1), 0 +0xab,0xaf,0xa5,0x7e == cv.sw a0, (a1), 2047 +0xab,0x33,0x53,0x24 == cv.sw t0, (t1), t2 +0x2b,0xb6,0xa5,0x24 == cv.sw a0, (a1), a2 +0xab,0x33,0x53,0x2c == cv.sw t0, t2(t1) +0x2b,0xb6,0xa5,0x2c == cv.sw a0, a2(a1) \ No newline at end of file diff --git a/suite/MC/RISCV/XCVsimd_riscv32_riscv_xcvsimd.txt.cs b/suite/MC/RISCV/XCVsimd_riscv32_riscv_xcvsimd.txt.cs new file mode 100644 index 0000000000..11e8b5da26 --- /dev/null +++ b/suite/MC/RISCV/XCVsimd_riscv32_riscv_xcvsimd.txt.cs @@ -0,0 +1,881 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32"|"CS_MODE_RISCV_XCVSIMD", None +0xfb,0x02,0x73,0x00 == cv.add.h t0, t1, t2 +0x7b,0x8e,0xee,0x01 == cv.add.h t3, t4, t5 +0x7b,0x85,0xc5,0x00 == cv.add.h a0, a1, a2 +0x7b,0x84,0x24,0x01 == cv.add.h s0, s1, s2 +0xfb,0x12,0x73,0x00 == cv.add.b t0, t1, t2 +0x7b,0x9e,0xee,0x01 == cv.add.b t3, t4, t5 +0x7b,0x95,0xc5,0x00 == cv.add.b a0, a1, a2 +0x7b,0x94,0x24,0x01 == cv.add.b s0, s1, s2 +0xfb,0x42,0x73,0x00 == cv.add.sc.h t0, t1, t2 +0x7b,0xce,0xee,0x01 == cv.add.sc.h t3, t4, t5 +0x7b,0xc5,0xc5,0x00 == cv.add.sc.h a0, a1, a2 +0x7b,0xc4,0x24,0x01 == cv.add.sc.h s0, s1, s2 +0xfb,0x52,0x73,0x00 == cv.add.sc.b t0, t1, t2 +0x7b,0xde,0xee,0x01 == cv.add.sc.b t3, t4, t5 +0x7b,0xd5,0xc5,0x00 == cv.add.sc.b a0, a1, a2 +0x7b,0xd4,0x24,0x01 == cv.add.sc.b s0, s1, s2 +0xfb,0x62,0x03,0x00 == cv.add.sci.h t0, t1, 0 +0x7b,0xee,0x0e,0x01 == cv.add.sci.h t3, t4, -32 +0x7b,0xe5,0x35,0x02 == cv.add.sci.h a0, a1, 7 +0x7b,0xe4,0xf4,0x03 == cv.add.sci.h s0, s1, -1 +0xfb,0x72,0x03,0x00 == cv.add.sci.b t0, t1, 0 +0x7b,0xfe,0x0e,0x01 == cv.add.sci.b t3, t4, -32 +0x7b,0xf5,0x35,0x02 == cv.add.sci.b a0, a1, 7 +0x7b,0xf4,0xf4,0x03 == cv.add.sci.b s0, s1, -1 +0xfb,0x02,0x73,0x08 == cv.sub.h t0, t1, t2 +0x7b,0x8e,0xee,0x09 == cv.sub.h t3, t4, t5 +0x7b,0x85,0xc5,0x08 == cv.sub.h a0, a1, a2 +0x7b,0x84,0x24,0x09 == cv.sub.h s0, s1, s2 +0xfb,0x12,0x73,0x08 == cv.sub.b t0, t1, t2 +0x7b,0x9e,0xee,0x09 == cv.sub.b t3, t4, t5 +0x7b,0x95,0xc5,0x08 == cv.sub.b a0, a1, a2 +0x7b,0x94,0x24,0x09 == cv.sub.b s0, s1, s2 +0xfb,0x42,0x73,0x08 == cv.sub.sc.h t0, t1, t2 +0x7b,0xce,0xee,0x09 == cv.sub.sc.h t3, t4, t5 +0x7b,0xc5,0xc5,0x08 == cv.sub.sc.h a0, a1, a2 +0x7b,0xc4,0x24,0x09 == cv.sub.sc.h s0, s1, s2 +0xfb,0x52,0x73,0x08 == cv.sub.sc.b t0, t1, t2 +0x7b,0xde,0xee,0x09 == cv.sub.sc.b t3, t4, t5 +0x7b,0xd5,0xc5,0x08 == cv.sub.sc.b a0, a1, a2 +0x7b,0xd4,0x24,0x09 == cv.sub.sc.b s0, s1, s2 +0xfb,0x62,0x03,0x08 == cv.sub.sci.h t0, t1, 0 +0x7b,0xee,0x0e,0x09 == cv.sub.sci.h t3, t4, -32 +0x7b,0xe5,0x35,0x0a == cv.sub.sci.h a0, a1, 7 +0x7b,0xe4,0xf4,0x0b == cv.sub.sci.h s0, s1, -1 +0xfb,0x72,0x03,0x08 == cv.sub.sci.b t0, t1, 0 +0x7b,0xfe,0x0e,0x09 == cv.sub.sci.b t3, t4, -32 +0x7b,0xf5,0x35,0x0a == cv.sub.sci.b a0, a1, 7 +0x7b,0xf4,0xf4,0x0b == cv.sub.sci.b s0, s1, -1 +0xfb,0x02,0x73,0x10 == cv.avg.h t0, t1, t2 +0x7b,0x8e,0xee,0x11 == cv.avg.h t3, t4, t5 +0x7b,0x85,0xc5,0x10 == cv.avg.h a0, a1, a2 +0x7b,0x84,0x24,0x11 == cv.avg.h s0, s1, s2 +0xfb,0x12,0x73,0x10 == cv.avg.b t0, t1, t2 +0x7b,0x9e,0xee,0x11 == cv.avg.b t3, t4, t5 +0x7b,0x95,0xc5,0x10 == cv.avg.b a0, a1, a2 +0x7b,0x94,0x24,0x11 == cv.avg.b s0, s1, s2 +0xfb,0x42,0x73,0x10 == cv.avg.sc.h t0, t1, t2 +0x7b,0xce,0xee,0x11 == cv.avg.sc.h t3, t4, t5 +0x7b,0xc5,0xc5,0x10 == cv.avg.sc.h a0, a1, a2 +0x7b,0xc4,0x24,0x11 == cv.avg.sc.h s0, s1, s2 +0xfb,0x52,0x73,0x10 == cv.avg.sc.b t0, t1, t2 +0x7b,0xde,0xee,0x11 == cv.avg.sc.b t3, t4, t5 +0x7b,0xd5,0xc5,0x10 == cv.avg.sc.b a0, a1, a2 +0x7b,0xd4,0x24,0x11 == cv.avg.sc.b s0, s1, s2 +0xfb,0x62,0x03,0x10 == cv.avg.sci.h t0, t1, 0 +0x7b,0xee,0x0e,0x11 == cv.avg.sci.h t3, t4, -32 +0x7b,0xe5,0x35,0x12 == cv.avg.sci.h a0, a1, 7 +0x7b,0xe4,0xf4,0x13 == cv.avg.sci.h s0, s1, -1 +0xfb,0x72,0x03,0x10 == cv.avg.sci.b t0, t1, 0 +0x7b,0xfe,0x0e,0x11 == cv.avg.sci.b t3, t4, -32 +0x7b,0xf5,0x35,0x12 == cv.avg.sci.b a0, a1, 7 +0x7b,0xf4,0xf4,0x13 == cv.avg.sci.b s0, s1, -1 +0xfb,0x02,0x73,0x18 == cv.avgu.h t0, t1, t2 +0x7b,0x8e,0xee,0x19 == cv.avgu.h t3, t4, t5 +0x7b,0x85,0xc5,0x18 == cv.avgu.h a0, a1, a2 +0x7b,0x84,0x24,0x19 == cv.avgu.h s0, s1, s2 +0xfb,0x12,0x73,0x18 == cv.avgu.b t0, t1, t2 +0x7b,0x9e,0xee,0x19 == cv.avgu.b t3, t4, t5 +0x7b,0x95,0xc5,0x18 == cv.avgu.b a0, a1, a2 +0x7b,0x94,0x24,0x19 == cv.avgu.b s0, s1, s2 +0xfb,0x42,0x73,0x18 == cv.avgu.sc.h t0, t1, t2 +0x7b,0xce,0xee,0x19 == cv.avgu.sc.h t3, t4, t5 +0x7b,0xc5,0xc5,0x18 == cv.avgu.sc.h a0, a1, a2 +0x7b,0xc4,0x24,0x19 == cv.avgu.sc.h s0, s1, s2 +0xfb,0x52,0x73,0x18 == cv.avgu.sc.b t0, t1, t2 +0x7b,0xde,0xee,0x19 == cv.avgu.sc.b t3, t4, t5 +0x7b,0xd5,0xc5,0x18 == cv.avgu.sc.b a0, a1, a2 +0x7b,0xd4,0x24,0x19 == cv.avgu.sc.b s0, s1, s2 +0xfb,0x62,0x03,0x18 == cv.avgu.sci.h t0, t1, 0 +0x7b,0xee,0x0e,0x19 == cv.avgu.sci.h t3, t4, 32 +0x7b,0xe5,0x35,0x1a == cv.avgu.sci.h a0, a1, 7 +0x7b,0xe4,0xf4,0x1b == cv.avgu.sci.h s0, s1, 63 +0xfb,0x72,0x03,0x18 == cv.avgu.sci.b t0, t1, 0 +0x7b,0xfe,0x0e,0x19 == cv.avgu.sci.b t3, t4, 32 +0x7b,0xf5,0x35,0x1a == cv.avgu.sci.b a0, a1, 7 +0x7b,0xf4,0xf4,0x1b == cv.avgu.sci.b s0, s1, 63 +0xfb,0x02,0x73,0x20 == cv.min.h t0, t1, t2 +0x7b,0x8e,0xee,0x21 == cv.min.h t3, t4, t5 +0x7b,0x85,0xc5,0x20 == cv.min.h a0, a1, a2 +0x7b,0x84,0x24,0x21 == cv.min.h s0, s1, s2 +0xfb,0x12,0x73,0x20 == cv.min.b t0, t1, t2 +0x7b,0x9e,0xee,0x21 == cv.min.b t3, t4, t5 +0x7b,0x95,0xc5,0x20 == cv.min.b a0, a1, a2 +0x7b,0x94,0x24,0x21 == cv.min.b s0, s1, s2 +0xfb,0x42,0x73,0x20 == cv.min.sc.h t0, t1, t2 +0x7b,0xce,0xee,0x21 == cv.min.sc.h t3, t4, t5 +0x7b,0xc5,0xc5,0x20 == cv.min.sc.h a0, a1, a2 +0x7b,0xc4,0x24,0x21 == cv.min.sc.h s0, s1, s2 +0xfb,0x52,0x73,0x20 == cv.min.sc.b t0, t1, t2 +0x7b,0xde,0xee,0x21 == cv.min.sc.b t3, t4, t5 +0x7b,0xd5,0xc5,0x20 == cv.min.sc.b a0, a1, a2 +0x7b,0xd4,0x24,0x21 == cv.min.sc.b s0, s1, s2 +0xfb,0x62,0x03,0x20 == cv.min.sci.h t0, t1, 0 +0x7b,0xee,0x0e,0x21 == cv.min.sci.h t3, t4, -32 +0x7b,0xe5,0x35,0x22 == cv.min.sci.h a0, a1, 7 +0x7b,0xe4,0xf4,0x23 == cv.min.sci.h s0, s1, -1 +0xfb,0x72,0x03,0x20 == cv.min.sci.b t0, t1, 0 +0x7b,0xfe,0x0e,0x21 == cv.min.sci.b t3, t4, -32 +0x7b,0xf5,0x35,0x22 == cv.min.sci.b a0, a1, 7 +0x7b,0xf4,0xf4,0x23 == cv.min.sci.b s0, s1, -1 +0xfb,0x02,0x73,0x28 == cv.minu.h t0, t1, t2 +0x7b,0x8e,0xee,0x29 == cv.minu.h t3, t4, t5 +0x7b,0x85,0xc5,0x28 == cv.minu.h a0, a1, a2 +0x7b,0x84,0x24,0x29 == cv.minu.h s0, s1, s2 +0xfb,0x12,0x73,0x28 == cv.minu.b t0, t1, t2 +0x7b,0x9e,0xee,0x29 == cv.minu.b t3, t4, t5 +0x7b,0x95,0xc5,0x28 == cv.minu.b a0, a1, a2 +0x7b,0x94,0x24,0x29 == cv.minu.b s0, s1, s2 +0xfb,0x42,0x73,0x28 == cv.minu.sc.h t0, t1, t2 +0x7b,0xce,0xee,0x29 == cv.minu.sc.h t3, t4, t5 +0x7b,0xc5,0xc5,0x28 == cv.minu.sc.h a0, a1, a2 +0x7b,0xc4,0x24,0x29 == cv.minu.sc.h s0, s1, s2 +0xfb,0x52,0x73,0x28 == cv.minu.sc.b t0, t1, t2 +0x7b,0xde,0xee,0x29 == cv.minu.sc.b t3, t4, t5 +0x7b,0xd5,0xc5,0x28 == cv.minu.sc.b a0, a1, a2 +0x7b,0xd4,0x24,0x29 == cv.minu.sc.b s0, s1, s2 +0xfb,0x62,0x03,0x28 == cv.minu.sci.h t0, t1, 0 +0x7b,0xee,0x0e,0x29 == cv.minu.sci.h t3, t4, 32 +0x7b,0xe5,0x35,0x2a == cv.minu.sci.h a0, a1, 7 +0x7b,0xe4,0xf4,0x2b == cv.minu.sci.h s0, s1, 63 +0xfb,0x72,0x03,0x28 == cv.minu.sci.b t0, t1, 0 +0x7b,0xfe,0x0e,0x29 == cv.minu.sci.b t3, t4, 32 +0x7b,0xf5,0x35,0x2a == cv.minu.sci.b a0, a1, 7 +0x7b,0xf4,0xf4,0x2b == cv.minu.sci.b s0, s1, 63 +0xfb,0x02,0x73,0x30 == cv.max.h t0, t1, t2 +0x7b,0x8e,0xee,0x31 == cv.max.h t3, t4, t5 +0x7b,0x85,0xc5,0x30 == cv.max.h a0, a1, a2 +0x7b,0x84,0x24,0x31 == cv.max.h s0, s1, s2 +0xfb,0x12,0x73,0x30 == cv.max.b t0, t1, t2 +0x7b,0x9e,0xee,0x31 == cv.max.b t3, t4, t5 +0x7b,0x95,0xc5,0x30 == cv.max.b a0, a1, a2 +0x7b,0x94,0x24,0x31 == cv.max.b s0, s1, s2 +0xfb,0x42,0x73,0x30 == cv.max.sc.h t0, t1, t2 +0x7b,0xce,0xee,0x31 == cv.max.sc.h t3, t4, t5 +0x7b,0xc5,0xc5,0x30 == cv.max.sc.h a0, a1, a2 +0x7b,0xc4,0x24,0x31 == cv.max.sc.h s0, s1, s2 +0xfb,0x52,0x73,0x30 == cv.max.sc.b t0, t1, t2 +0x7b,0xde,0xee,0x31 == cv.max.sc.b t3, t4, t5 +0x7b,0xd5,0xc5,0x30 == cv.max.sc.b a0, a1, a2 +0x7b,0xd4,0x24,0x31 == cv.max.sc.b s0, s1, s2 +0xfb,0x62,0x03,0x30 == cv.max.sci.h t0, t1, 0 +0x7b,0xee,0x0e,0x31 == cv.max.sci.h t3, t4, -32 +0x7b,0xe5,0x35,0x32 == cv.max.sci.h a0, a1, 7 +0x7b,0xe4,0xf4,0x33 == cv.max.sci.h s0, s1, -1 +0xfb,0x72,0x03,0x30 == cv.max.sci.b t0, t1, 0 +0x7b,0xfe,0x0e,0x31 == cv.max.sci.b t3, t4, -32 +0x7b,0xf5,0x35,0x32 == cv.max.sci.b a0, a1, 7 +0x7b,0xf4,0xf4,0x33 == cv.max.sci.b s0, s1, -1 +0xfb,0x02,0x73,0x38 == cv.maxu.h t0, t1, t2 +0x7b,0x8e,0xee,0x39 == cv.maxu.h t3, t4, t5 +0x7b,0x85,0xc5,0x38 == cv.maxu.h a0, a1, a2 +0x7b,0x84,0x24,0x39 == cv.maxu.h s0, s1, s2 +0xfb,0x12,0x73,0x38 == cv.maxu.b t0, t1, t2 +0x7b,0x9e,0xee,0x39 == cv.maxu.b t3, t4, t5 +0x7b,0x95,0xc5,0x38 == cv.maxu.b a0, a1, a2 +0x7b,0x94,0x24,0x39 == cv.maxu.b s0, s1, s2 +0xfb,0x42,0x73,0x38 == cv.maxu.sc.h t0, t1, t2 +0x7b,0xce,0xee,0x39 == cv.maxu.sc.h t3, t4, t5 +0x7b,0xc5,0xc5,0x38 == cv.maxu.sc.h a0, a1, a2 +0x7b,0xc4,0x24,0x39 == cv.maxu.sc.h s0, s1, s2 +0xfb,0x52,0x73,0x38 == cv.maxu.sc.b t0, t1, t2 +0x7b,0xde,0xee,0x39 == cv.maxu.sc.b t3, t4, t5 +0x7b,0xd5,0xc5,0x38 == cv.maxu.sc.b a0, a1, a2 +0x7b,0xd4,0x24,0x39 == cv.maxu.sc.b s0, s1, s2 +0xfb,0x62,0x03,0x38 == cv.maxu.sci.h t0, t1, 0 +0x7b,0xee,0x0e,0x39 == cv.maxu.sci.h t3, t4, 32 +0x7b,0xe5,0x35,0x3a == cv.maxu.sci.h a0, a1, 7 +0x7b,0xe4,0xf4,0x3b == cv.maxu.sci.h s0, s1, 63 +0xfb,0x72,0x03,0x38 == cv.maxu.sci.b t0, t1, 0 +0x7b,0xfe,0x0e,0x39 == cv.maxu.sci.b t3, t4, 32 +0x7b,0xf5,0x35,0x3a == cv.maxu.sci.b a0, a1, 7 +0x7b,0xf4,0xf4,0x3b == cv.maxu.sci.b s0, s1, 63 +0xfb,0x02,0x73,0x40 == cv.srl.h t0, t1, t2 +0x7b,0x8e,0xee,0x41 == cv.srl.h t3, t4, t5 +0x7b,0x85,0xc5,0x40 == cv.srl.h a0, a1, a2 +0x7b,0x84,0x24,0x41 == cv.srl.h s0, s1, s2 +0xfb,0x12,0x73,0x40 == cv.srl.b t0, t1, t2 +0x7b,0x9e,0xee,0x41 == cv.srl.b t3, t4, t5 +0x7b,0x95,0xc5,0x40 == cv.srl.b a0, a1, a2 +0x7b,0x94,0x24,0x41 == cv.srl.b s0, s1, s2 +0xfb,0x42,0x73,0x40 == cv.srl.sc.h t0, t1, t2 +0x7b,0xce,0xee,0x41 == cv.srl.sc.h t3, t4, t5 +0x7b,0xc5,0xc5,0x40 == cv.srl.sc.h a0, a1, a2 +0x7b,0xc4,0x24,0x41 == cv.srl.sc.h s0, s1, s2 +0xfb,0x52,0x73,0x40 == cv.srl.sc.b t0, t1, t2 +0x7b,0xde,0xee,0x41 == cv.srl.sc.b t3, t4, t5 +0x7b,0xd5,0xc5,0x40 == cv.srl.sc.b a0, a1, a2 +0x7b,0xd4,0x24,0x41 == cv.srl.sc.b s0, s1, s2 +0xfb,0x62,0x03,0x40 == cv.srl.sci.h t0, t1, 0 +0x7b,0xee,0x0e,0x40 == cv.srl.sci.h t3, t4, 0 +0x7b,0xe5,0x35,0x42 == cv.srl.sci.h a0, a1, 7 +0x7b,0xe4,0x74,0x42 == cv.srl.sci.h s0, s1, 15 +0xfb,0x72,0x03,0x40 == cv.srl.sci.b t0, t1, 0 +0x7b,0xfe,0x0e,0x40 == cv.srl.sci.b t3, t4, 0 +0x7b,0xf5,0x35,0x42 == cv.srl.sci.b a0, a1, 7 +0x7b,0xf4,0x34,0x42 == cv.srl.sci.b s0, s1, 7 +0xfb,0x02,0x73,0x48 == cv.sra.h t0, t1, t2 +0x7b,0x8e,0xee,0x49 == cv.sra.h t3, t4, t5 +0x7b,0x85,0xc5,0x48 == cv.sra.h a0, a1, a2 +0x7b,0x84,0x24,0x49 == cv.sra.h s0, s1, s2 +0xfb,0x12,0x73,0x48 == cv.sra.b t0, t1, t2 +0x7b,0x9e,0xee,0x49 == cv.sra.b t3, t4, t5 +0x7b,0x95,0xc5,0x48 == cv.sra.b a0, a1, a2 +0x7b,0x94,0x24,0x49 == cv.sra.b s0, s1, s2 +0xfb,0x42,0x73,0x48 == cv.sra.sc.h t0, t1, t2 +0x7b,0xce,0xee,0x49 == cv.sra.sc.h t3, t4, t5 +0x7b,0xc5,0xc5,0x48 == cv.sra.sc.h a0, a1, a2 +0x7b,0xc4,0x24,0x49 == cv.sra.sc.h s0, s1, s2 +0xfb,0x52,0x73,0x48 == cv.sra.sc.b t0, t1, t2 +0x7b,0xde,0xee,0x49 == cv.sra.sc.b t3, t4, t5 +0x7b,0xd5,0xc5,0x48 == cv.sra.sc.b a0, a1, a2 +0x7b,0xd4,0x24,0x49 == cv.sra.sc.b s0, s1, s2 +0xfb,0x62,0x03,0x48 == cv.sra.sci.h t0, t1, 0 +0x7b,0xee,0x0e,0x48 == cv.sra.sci.h t3, t4, 0 +0x7b,0xe5,0x35,0x4a == cv.sra.sci.h a0, a1, 7 +0x7b,0xe4,0x74,0x4a == cv.sra.sci.h s0, s1, 15 +0xfb,0x72,0x03,0x48 == cv.sra.sci.b t0, t1, 0 +0x7b,0xfe,0x0e,0x48 == cv.sra.sci.b t3, t4, 0 +0x7b,0xf5,0x35,0x4a == cv.sra.sci.b a0, a1, 7 +0x7b,0xf4,0x34,0x4a == cv.sra.sci.b s0, s1, 7 +0xfb,0x02,0x73,0x50 == cv.sll.h t0, t1, t2 +0x7b,0x8e,0xee,0x51 == cv.sll.h t3, t4, t5 +0x7b,0x85,0xc5,0x50 == cv.sll.h a0, a1, a2 +0x7b,0x84,0x24,0x51 == cv.sll.h s0, s1, s2 +0xfb,0x12,0x73,0x50 == cv.sll.b t0, t1, t2 +0x7b,0x9e,0xee,0x51 == cv.sll.b t3, t4, t5 +0x7b,0x95,0xc5,0x50 == cv.sll.b a0, a1, a2 +0x7b,0x94,0x24,0x51 == cv.sll.b s0, s1, s2 +0xfb,0x42,0x73,0x50 == cv.sll.sc.h t0, t1, t2 +0x7b,0xce,0xee,0x51 == cv.sll.sc.h t3, t4, t5 +0x7b,0xc5,0xc5,0x50 == cv.sll.sc.h a0, a1, a2 +0x7b,0xc4,0x24,0x51 == cv.sll.sc.h s0, s1, s2 +0xfb,0x52,0x73,0x50 == cv.sll.sc.b t0, t1, t2 +0x7b,0xde,0xee,0x51 == cv.sll.sc.b t3, t4, t5 +0x7b,0xd5,0xc5,0x50 == cv.sll.sc.b a0, a1, a2 +0x7b,0xd4,0x24,0x51 == cv.sll.sc.b s0, s1, s2 +0xfb,0x62,0x03,0x50 == cv.sll.sci.h t0, t1, 0 +0x7b,0xee,0x0e,0x50 == cv.sll.sci.h t3, t4, 0 +0x7b,0xe5,0x35,0x52 == cv.sll.sci.h a0, a1, 7 +0x7b,0xe4,0x74,0x52 == cv.sll.sci.h s0, s1, 15 +0xfb,0x72,0x03,0x50 == cv.sll.sci.b t0, t1, 0 +0x7b,0xfe,0x0e,0x50 == cv.sll.sci.b t3, t4, 0 +0x7b,0xf5,0x35,0x52 == cv.sll.sci.b a0, a1, 7 +0x7b,0xf4,0x34,0x52 == cv.sll.sci.b s0, s1, 7 +0xfb,0x02,0x73,0x58 == cv.or.h t0, t1, t2 +0x7b,0x8e,0xee,0x59 == cv.or.h t3, t4, t5 +0x7b,0x85,0xc5,0x58 == cv.or.h a0, a1, a2 +0x7b,0x84,0x24,0x59 == cv.or.h s0, s1, s2 +0xfb,0x12,0x73,0x58 == cv.or.b t0, t1, t2 +0x7b,0x9e,0xee,0x59 == cv.or.b t3, t4, t5 +0x7b,0x95,0xc5,0x58 == cv.or.b a0, a1, a2 +0x7b,0x94,0x24,0x59 == cv.or.b s0, s1, s2 +0xfb,0x42,0x73,0x58 == cv.or.sc.h t0, t1, t2 +0x7b,0xce,0xee,0x59 == cv.or.sc.h t3, t4, t5 +0x7b,0xc5,0xc5,0x58 == cv.or.sc.h a0, a1, a2 +0x7b,0xc4,0x24,0x59 == cv.or.sc.h s0, s1, s2 +0xfb,0x52,0x73,0x58 == cv.or.sc.b t0, t1, t2 +0x7b,0xde,0xee,0x59 == cv.or.sc.b t3, t4, t5 +0x7b,0xd5,0xc5,0x58 == cv.or.sc.b a0, a1, a2 +0x7b,0xd4,0x24,0x59 == cv.or.sc.b s0, s1, s2 +0xfb,0x62,0x03,0x58 == cv.or.sci.h t0, t1, 0 +0x7b,0xee,0x0e,0x59 == cv.or.sci.h t3, t4, -32 +0x7b,0xe5,0x35,0x5a == cv.or.sci.h a0, a1, 7 +0x7b,0xe4,0xf4,0x5b == cv.or.sci.h s0, s1, -1 +0xfb,0x72,0x03,0x58 == cv.or.sci.b t0, t1, 0 +0x7b,0xfe,0x0e,0x59 == cv.or.sci.b t3, t4, -32 +0x7b,0xf5,0x35,0x5a == cv.or.sci.b a0, a1, 7 +0x7b,0xf4,0xf4,0x5b == cv.or.sci.b s0, s1, -1 +0xfb,0x02,0x73,0x60 == cv.xor.h t0, t1, t2 +0x7b,0x8e,0xee,0x61 == cv.xor.h t3, t4, t5 +0x7b,0x85,0xc5,0x60 == cv.xor.h a0, a1, a2 +0x7b,0x84,0x24,0x61 == cv.xor.h s0, s1, s2 +0xfb,0x12,0x73,0x60 == cv.xor.b t0, t1, t2 +0x7b,0x9e,0xee,0x61 == cv.xor.b t3, t4, t5 +0x7b,0x95,0xc5,0x60 == cv.xor.b a0, a1, a2 +0x7b,0x94,0x24,0x61 == cv.xor.b s0, s1, s2 +0xfb,0x42,0x73,0x60 == cv.xor.sc.h t0, t1, t2 +0x7b,0xce,0xee,0x61 == cv.xor.sc.h t3, t4, t5 +0x7b,0xc5,0xc5,0x60 == cv.xor.sc.h a0, a1, a2 +0x7b,0xc4,0x24,0x61 == cv.xor.sc.h s0, s1, s2 +0xfb,0x52,0x73,0x60 == cv.xor.sc.b t0, t1, t2 +0x7b,0xde,0xee,0x61 == cv.xor.sc.b t3, t4, t5 +0x7b,0xd5,0xc5,0x60 == cv.xor.sc.b a0, a1, a2 +0x7b,0xd4,0x24,0x61 == cv.xor.sc.b s0, s1, s2 +0xfb,0x62,0x03,0x60 == cv.xor.sci.h t0, t1, 0 +0x7b,0xee,0x0e,0x61 == cv.xor.sci.h t3, t4, -32 +0x7b,0xe5,0x35,0x62 == cv.xor.sci.h a0, a1, 7 +0x7b,0xe4,0xf4,0x63 == cv.xor.sci.h s0, s1, -1 +0xfb,0x72,0x03,0x60 == cv.xor.sci.b t0, t1, 0 +0x7b,0xfe,0x0e,0x61 == cv.xor.sci.b t3, t4, -32 +0x7b,0xf5,0x35,0x62 == cv.xor.sci.b a0, a1, 7 +0x7b,0xf4,0xf4,0x63 == cv.xor.sci.b s0, s1, -1 +0xfb,0x02,0x73,0x68 == cv.and.h t0, t1, t2 +0x7b,0x8e,0xee,0x69 == cv.and.h t3, t4, t5 +0x7b,0x85,0xc5,0x68 == cv.and.h a0, a1, a2 +0x7b,0x84,0x24,0x69 == cv.and.h s0, s1, s2 +0xfb,0x12,0x73,0x68 == cv.and.b t0, t1, t2 +0x7b,0x9e,0xee,0x69 == cv.and.b t3, t4, t5 +0x7b,0x95,0xc5,0x68 == cv.and.b a0, a1, a2 +0x7b,0x94,0x24,0x69 == cv.and.b s0, s1, s2 +0xfb,0x42,0x73,0x68 == cv.and.sc.h t0, t1, t2 +0x7b,0xce,0xee,0x69 == cv.and.sc.h t3, t4, t5 +0x7b,0xc5,0xc5,0x68 == cv.and.sc.h a0, a1, a2 +0x7b,0xc4,0x24,0x69 == cv.and.sc.h s0, s1, s2 +0xfb,0x52,0x73,0x68 == cv.and.sc.b t0, t1, t2 +0x7b,0xde,0xee,0x69 == cv.and.sc.b t3, t4, t5 +0x7b,0xd5,0xc5,0x68 == cv.and.sc.b a0, a1, a2 +0x7b,0xd4,0x24,0x69 == cv.and.sc.b s0, s1, s2 +0xfb,0x62,0x03,0x68 == cv.and.sci.h t0, t1, 0 +0x7b,0xee,0x0e,0x69 == cv.and.sci.h t3, t4, -32 +0x7b,0xe5,0x35,0x6a == cv.and.sci.h a0, a1, 7 +0x7b,0xe4,0xf4,0x6b == cv.and.sci.h s0, s1, -1 +0xfb,0x72,0x03,0x68 == cv.and.sci.b t0, t1, 0 +0x7b,0xfe,0x0e,0x69 == cv.and.sci.b t3, t4, -32 +0x7b,0xf5,0x35,0x6a == cv.and.sci.b a0, a1, 7 +0x7b,0xf4,0xf4,0x6b == cv.and.sci.b s0, s1, -1 +0xfb,0x02,0x03,0x70 == cv.abs.h t0, t1 +0x7b,0x8e,0x0e,0x70 == cv.abs.h t3, t4 +0x7b,0x85,0x05,0x70 == cv.abs.h a0, a1 +0x7b,0x84,0x04,0x70 == cv.abs.h s0, s1 +0xfb,0x12,0x03,0x70 == cv.abs.b t0, t1 +0x7b,0x9e,0x0e,0x70 == cv.abs.b t3, t4 +0x7b,0x95,0x05,0x70 == cv.abs.b a0, a1 +0x7b,0x94,0x04,0x70 == cv.abs.b s0, s1 +0xfb,0x02,0x73,0x80 == cv.dotup.h t0, t1, t2 +0x7b,0x8e,0xee,0x81 == cv.dotup.h t3, t4, t5 +0x7b,0x85,0xc5,0x80 == cv.dotup.h a0, a1, a2 +0x7b,0x84,0x24,0x81 == cv.dotup.h s0, s1, s2 +0xfb,0x12,0x73,0x80 == cv.dotup.b t0, t1, t2 +0x7b,0x9e,0xee,0x81 == cv.dotup.b t3, t4, t5 +0x7b,0x95,0xc5,0x80 == cv.dotup.b a0, a1, a2 +0x7b,0x94,0x24,0x81 == cv.dotup.b s0, s1, s2 +0xfb,0x42,0x73,0x80 == cv.dotup.sc.h t0, t1, t2 +0x7b,0xce,0xee,0x81 == cv.dotup.sc.h t3, t4, t5 +0x7b,0xc5,0xc5,0x80 == cv.dotup.sc.h a0, a1, a2 +0x7b,0xc4,0x24,0x81 == cv.dotup.sc.h s0, s1, s2 +0xfb,0x52,0x73,0x80 == cv.dotup.sc.b t0, t1, t2 +0x7b,0xde,0xee,0x81 == cv.dotup.sc.b t3, t4, t5 +0x7b,0xd5,0xc5,0x80 == cv.dotup.sc.b a0, a1, a2 +0x7b,0xd4,0x24,0x81 == cv.dotup.sc.b s0, s1, s2 +0xfb,0x62,0x03,0x80 == cv.dotup.sci.h t0, t1, 0 +0x7b,0xee,0x0e,0x81 == cv.dotup.sci.h t3, t4, 32 +0x7b,0xe5,0x35,0x82 == cv.dotup.sci.h a0, a1, 7 +0x7b,0xe4,0xf4,0x83 == cv.dotup.sci.h s0, s1, 63 +0xfb,0x72,0x03,0x80 == cv.dotup.sci.b t0, t1, 0 +0x7b,0xfe,0x0e,0x81 == cv.dotup.sci.b t3, t4, 32 +0x7b,0xf5,0x35,0x82 == cv.dotup.sci.b a0, a1, 7 +0x7b,0xf4,0xf4,0x83 == cv.dotup.sci.b s0, s1, 63 +0xfb,0x02,0x73,0x88 == cv.dotusp.h t0, t1, t2 +0x7b,0x8e,0xee,0x89 == cv.dotusp.h t3, t4, t5 +0x7b,0x85,0xc5,0x88 == cv.dotusp.h a0, a1, a2 +0x7b,0x84,0x24,0x89 == cv.dotusp.h s0, s1, s2 +0xfb,0x12,0x73,0x88 == cv.dotusp.b t0, t1, t2 +0x7b,0x9e,0xee,0x89 == cv.dotusp.b t3, t4, t5 +0x7b,0x95,0xc5,0x88 == cv.dotusp.b a0, a1, a2 +0x7b,0x94,0x24,0x89 == cv.dotusp.b s0, s1, s2 +0xfb,0x42,0x73,0x88 == cv.dotusp.sc.h t0, t1, t2 +0x7b,0xce,0xee,0x89 == cv.dotusp.sc.h t3, t4, t5 +0x7b,0xc5,0xc5,0x88 == cv.dotusp.sc.h a0, a1, a2 +0x7b,0xc4,0x24,0x89 == cv.dotusp.sc.h s0, s1, s2 +0xfb,0x52,0x73,0x88 == cv.dotusp.sc.b t0, t1, t2 +0x7b,0xde,0xee,0x89 == cv.dotusp.sc.b t3, t4, t5 +0x7b,0xd5,0xc5,0x88 == cv.dotusp.sc.b a0, a1, a2 +0x7b,0xd4,0x24,0x89 == cv.dotusp.sc.b s0, s1, s2 +0xfb,0x62,0x03,0x88 == cv.dotusp.sci.h t0, t1, 0 +0x7b,0xee,0x0e,0x89 == cv.dotusp.sci.h t3, t4, -32 +0x7b,0xe5,0x35,0x8a == cv.dotusp.sci.h a0, a1, 7 +0x7b,0xe4,0xf4,0x8b == cv.dotusp.sci.h s0, s1, -1 +0xfb,0x72,0x03,0x88 == cv.dotusp.sci.b t0, t1, 0 +0x7b,0xfe,0x0e,0x89 == cv.dotusp.sci.b t3, t4, -32 +0x7b,0xf5,0x35,0x8a == cv.dotusp.sci.b a0, a1, 7 +0x7b,0xf4,0xf4,0x8b == cv.dotusp.sci.b s0, s1, -1 +0xfb,0x02,0x73,0x90 == cv.dotsp.h t0, t1, t2 +0x7b,0x8e,0xee,0x91 == cv.dotsp.h t3, t4, t5 +0x7b,0x85,0xc5,0x90 == cv.dotsp.h a0, a1, a2 +0x7b,0x84,0x24,0x91 == cv.dotsp.h s0, s1, s2 +0xfb,0x12,0x73,0x90 == cv.dotsp.b t0, t1, t2 +0x7b,0x9e,0xee,0x91 == cv.dotsp.b t3, t4, t5 +0x7b,0x95,0xc5,0x90 == cv.dotsp.b a0, a1, a2 +0x7b,0x94,0x24,0x91 == cv.dotsp.b s0, s1, s2 +0xfb,0x42,0x73,0x90 == cv.dotsp.sc.h t0, t1, t2 +0x7b,0xce,0xee,0x91 == cv.dotsp.sc.h t3, t4, t5 +0x7b,0xc5,0xc5,0x90 == cv.dotsp.sc.h a0, a1, a2 +0x7b,0xc4,0x24,0x91 == cv.dotsp.sc.h s0, s1, s2 +0xfb,0x52,0x73,0x90 == cv.dotsp.sc.b t0, t1, t2 +0x7b,0xde,0xee,0x91 == cv.dotsp.sc.b t3, t4, t5 +0x7b,0xd5,0xc5,0x90 == cv.dotsp.sc.b a0, a1, a2 +0x7b,0xd4,0x24,0x91 == cv.dotsp.sc.b s0, s1, s2 +0xfb,0x62,0x03,0x90 == cv.dotsp.sci.h t0, t1, 0 +0x7b,0xee,0x0e,0x91 == cv.dotsp.sci.h t3, t4, -32 +0x7b,0xe5,0x35,0x92 == cv.dotsp.sci.h a0, a1, 7 +0x7b,0xe4,0xf4,0x93 == cv.dotsp.sci.h s0, s1, -1 +0xfb,0x72,0x03,0x90 == cv.dotsp.sci.b t0, t1, 0 +0x7b,0xfe,0x0e,0x91 == cv.dotsp.sci.b t3, t4, -32 +0x7b,0xf5,0x35,0x92 == cv.dotsp.sci.b a0, a1, 7 +0x7b,0xf4,0xf4,0x93 == cv.dotsp.sci.b s0, s1, -1 +0xfb,0x02,0x73,0x98 == cv.sdotup.h t0, t1, t2 +0x7b,0x8e,0xee,0x99 == cv.sdotup.h t3, t4, t5 +0x7b,0x85,0xc5,0x98 == cv.sdotup.h a0, a1, a2 +0x7b,0x84,0x24,0x99 == cv.sdotup.h s0, s1, s2 +0xfb,0x12,0x73,0x98 == cv.sdotup.b t0, t1, t2 +0x7b,0x9e,0xee,0x99 == cv.sdotup.b t3, t4, t5 +0x7b,0x95,0xc5,0x98 == cv.sdotup.b a0, a1, a2 +0x7b,0x94,0x24,0x99 == cv.sdotup.b s0, s1, s2 +0xfb,0x42,0x73,0x98 == cv.sdotup.sc.h t0, t1, t2 +0x7b,0xce,0xee,0x99 == cv.sdotup.sc.h t3, t4, t5 +0x7b,0xc5,0xc5,0x98 == cv.sdotup.sc.h a0, a1, a2 +0x7b,0xc4,0x24,0x99 == cv.sdotup.sc.h s0, s1, s2 +0xfb,0x52,0x73,0x98 == cv.sdotup.sc.b t0, t1, t2 +0x7b,0xde,0xee,0x99 == cv.sdotup.sc.b t3, t4, t5 +0x7b,0xd5,0xc5,0x98 == cv.sdotup.sc.b a0, a1, a2 +0x7b,0xd4,0x24,0x99 == cv.sdotup.sc.b s0, s1, s2 +0xfb,0x62,0x03,0x98 == cv.sdotup.sci.h t0, t1, 0 +0x7b,0xee,0x0e,0x99 == cv.sdotup.sci.h t3, t4, 32 +0x7b,0xe5,0x35,0x9a == cv.sdotup.sci.h a0, a1, 7 +0x7b,0xe4,0xf4,0x9b == cv.sdotup.sci.h s0, s1, 63 +0xfb,0x72,0x03,0x98 == cv.sdotup.sci.b t0, t1, 0 +0x7b,0xfe,0x0e,0x99 == cv.sdotup.sci.b t3, t4, 32 +0x7b,0xf5,0x35,0x9a == cv.sdotup.sci.b a0, a1, 7 +0x7b,0xf4,0xf4,0x9b == cv.sdotup.sci.b s0, s1, 63 +0xfb,0x02,0x73,0xa0 == cv.sdotusp.h t0, t1, t2 +0x7b,0x8e,0xee,0xa1 == cv.sdotusp.h t3, t4, t5 +0x7b,0x85,0xc5,0xa0 == cv.sdotusp.h a0, a1, a2 +0x7b,0x84,0x24,0xa1 == cv.sdotusp.h s0, s1, s2 +0xfb,0x12,0x73,0xa0 == cv.sdotusp.b t0, t1, t2 +0x7b,0x9e,0xee,0xa1 == cv.sdotusp.b t3, t4, t5 +0x7b,0x95,0xc5,0xa0 == cv.sdotusp.b a0, a1, a2 +0x7b,0x94,0x24,0xa1 == cv.sdotusp.b s0, s1, s2 +0xfb,0x42,0x73,0xa0 == cv.sdotusp.sc.h t0, t1, t2 +0x7b,0xce,0xee,0xa1 == cv.sdotusp.sc.h t3, t4, t5 +0x7b,0xc5,0xc5,0xa0 == cv.sdotusp.sc.h a0, a1, a2 +0x7b,0xc4,0x24,0xa1 == cv.sdotusp.sc.h s0, s1, s2 +0xfb,0x52,0x73,0xa0 == cv.sdotusp.sc.b t0, t1, t2 +0x7b,0xde,0xee,0xa1 == cv.sdotusp.sc.b t3, t4, t5 +0x7b,0xd5,0xc5,0xa0 == cv.sdotusp.sc.b a0, a1, a2 +0x7b,0xd4,0x24,0xa1 == cv.sdotusp.sc.b s0, s1, s2 +0xfb,0x62,0x03,0xa0 == cv.sdotusp.sci.h t0, t1, 0 +0x7b,0xee,0x0e,0xa1 == cv.sdotusp.sci.h t3, t4, -32 +0x7b,0xe5,0x35,0xa2 == cv.sdotusp.sci.h a0, a1, 7 +0x7b,0xe4,0xf4,0xa3 == cv.sdotusp.sci.h s0, s1, -1 +0xfb,0x72,0x03,0xa0 == cv.sdotusp.sci.b t0, t1, 0 +0x7b,0xfe,0x0e,0xa1 == cv.sdotusp.sci.b t3, t4, -32 +0x7b,0xf5,0x35,0xa2 == cv.sdotusp.sci.b a0, a1, 7 +0x7b,0xf4,0xf4,0xa3 == cv.sdotusp.sci.b s0, s1, -1 +0xfb,0x02,0x73,0xa8 == cv.sdotsp.h t0, t1, t2 +0x7b,0x8e,0xee,0xa9 == cv.sdotsp.h t3, t4, t5 +0x7b,0x85,0xc5,0xa8 == cv.sdotsp.h a0, a1, a2 +0x7b,0x84,0x24,0xa9 == cv.sdotsp.h s0, s1, s2 +0xfb,0x12,0x73,0xa8 == cv.sdotsp.b t0, t1, t2 +0x7b,0x9e,0xee,0xa9 == cv.sdotsp.b t3, t4, t5 +0x7b,0x95,0xc5,0xa8 == cv.sdotsp.b a0, a1, a2 +0x7b,0x94,0x24,0xa9 == cv.sdotsp.b s0, s1, s2 +0xfb,0x42,0x73,0xa8 == cv.sdotsp.sc.h t0, t1, t2 +0x7b,0xce,0xee,0xa9 == cv.sdotsp.sc.h t3, t4, t5 +0x7b,0xc5,0xc5,0xa8 == cv.sdotsp.sc.h a0, a1, a2 +0x7b,0xc4,0x24,0xa9 == cv.sdotsp.sc.h s0, s1, s2 +0xfb,0x52,0x73,0xa8 == cv.sdotsp.sc.b t0, t1, t2 +0x7b,0xde,0xee,0xa9 == cv.sdotsp.sc.b t3, t4, t5 +0x7b,0xd5,0xc5,0xa8 == cv.sdotsp.sc.b a0, a1, a2 +0x7b,0xd4,0x24,0xa9 == cv.sdotsp.sc.b s0, s1, s2 +0xfb,0x62,0x03,0xa8 == cv.sdotsp.sci.h t0, t1, 0 +0x7b,0xee,0x0e,0xa9 == cv.sdotsp.sci.h t3, t4, -32 +0x7b,0xe5,0x35,0xaa == cv.sdotsp.sci.h a0, a1, 7 +0x7b,0xe4,0xf4,0xab == cv.sdotsp.sci.h s0, s1, -1 +0xfb,0x72,0x03,0xa8 == cv.sdotsp.sci.b t0, t1, 0 +0x7b,0xfe,0x0e,0xa9 == cv.sdotsp.sci.b t3, t4, -32 +0x7b,0xf5,0x35,0xaa == cv.sdotsp.sci.b a0, a1, 7 +0x7b,0xf4,0xf4,0xab == cv.sdotsp.sci.b s0, s1, -1 +0xfb,0x02,0x03,0xb8 == cv.extract.h t0, t1, 0 +0x7b,0x8e,0x0e,0xb9 == cv.extract.h t3, t4, 32 +0x7b,0x85,0x35,0xba == cv.extract.h a0, a1, 7 +0x7b,0x84,0xf4,0xbb == cv.extract.h s0, s1, 63 +0xfb,0x12,0x03,0xb8 == cv.extract.b t0, t1, 0 +0x7b,0x9e,0x0e,0xb9 == cv.extract.b t3, t4, 32 +0x7b,0x95,0x35,0xba == cv.extract.b a0, a1, 7 +0x7b,0x94,0xf4,0xbb == cv.extract.b s0, s1, 63 +0xfb,0x22,0x03,0xb8 == cv.extractu.h t0, t1, 0 +0x7b,0xae,0x0e,0xb9 == cv.extractu.h t3, t4, 32 +0x7b,0xa5,0x35,0xba == cv.extractu.h a0, a1, 7 +0x7b,0xa4,0xf4,0xbb == cv.extractu.h s0, s1, 63 +0xfb,0x32,0x03,0xb8 == cv.extractu.b t0, t1, 0 +0x7b,0xbe,0x0e,0xb9 == cv.extractu.b t3, t4, 32 +0x7b,0xb5,0x35,0xba == cv.extractu.b a0, a1, 7 +0x7b,0xb4,0xf4,0xbb == cv.extractu.b s0, s1, 63 +0xfb,0x42,0x03,0xb8 == cv.insert.h t0, t1, 0 +0x7b,0xce,0x0e,0xb9 == cv.insert.h t3, t4, 32 +0x7b,0xc5,0x35,0xba == cv.insert.h a0, a1, 7 +0x7b,0xc4,0xf4,0xbb == cv.insert.h s0, s1, 63 +0xfb,0x52,0x03,0xb8 == cv.insert.b t0, t1, 0 +0x7b,0xde,0x0e,0xb9 == cv.insert.b t3, t4, 32 +0x7b,0xd5,0x35,0xba == cv.insert.b a0, a1, 7 +0x7b,0xd4,0xf4,0xbb == cv.insert.b s0, s1, 63 +0xfb,0x02,0x73,0xc0 == cv.shuffle.h t0, t1, t2 +0x7b,0x8e,0xee,0xc1 == cv.shuffle.h t3, t4, t5 +0x7b,0x85,0xc5,0xc0 == cv.shuffle.h a0, a1, a2 +0x7b,0x84,0x24,0xc1 == cv.shuffle.h s0, s1, s2 +0xfb,0x12,0x73,0xc0 == cv.shuffle.b t0, t1, t2 +0x7b,0x9e,0xee,0xc1 == cv.shuffle.b t3, t4, t5 +0x7b,0x95,0xc5,0xc0 == cv.shuffle.b a0, a1, a2 +0x7b,0x94,0x24,0xc1 == cv.shuffle.b s0, s1, s2 +0xfb,0x62,0x03,0xc0 == cv.shuffle.sci.h t0, t1, 0 +0x7b,0xee,0x0e,0xc1 == cv.shuffle.sci.h t3, t4, 32 +0x7b,0xe5,0x35,0xc2 == cv.shuffle.sci.h a0, a1, 7 +0x7b,0xe4,0xf4,0xc3 == cv.shuffle.sci.h s0, s1, 63 +0xfb,0x72,0x03,0xc0 == cv.shufflei0.sci.b t0, t1, 0 +0x7b,0xfe,0x0e,0xc1 == cv.shufflei0.sci.b t3, t4, 32 +0x7b,0xf5,0x35,0xc2 == cv.shufflei0.sci.b a0, a1, 7 +0x7b,0xf4,0xf4,0xc3 == cv.shufflei0.sci.b s0, s1, 63 +0xfb,0x72,0x03,0xc8 == cv.shufflei1.sci.b t0, t1, 0 +0x7b,0xfe,0x0e,0xc9 == cv.shufflei1.sci.b t3, t4, 32 +0x7b,0xf5,0x35,0xca == cv.shufflei1.sci.b a0, a1, 7 +0x7b,0xf4,0xf4,0xcb == cv.shufflei1.sci.b s0, s1, 63 +0xfb,0x72,0x03,0xd0 == cv.shufflei2.sci.b t0, t1, 0 +0x7b,0xfe,0x0e,0xd1 == cv.shufflei2.sci.b t3, t4, 32 +0x7b,0xf5,0x35,0xd2 == cv.shufflei2.sci.b a0, a1, 7 +0x7b,0xf4,0xf4,0xd3 == cv.shufflei2.sci.b s0, s1, 63 +0xfb,0x72,0x03,0xd8 == cv.shufflei3.sci.b t0, t1, 0 +0x7b,0xfe,0x0e,0xd9 == cv.shufflei3.sci.b t3, t4, 32 +0x7b,0xf5,0x35,0xda == cv.shufflei3.sci.b a0, a1, 7 +0x7b,0xf4,0xf4,0xdb == cv.shufflei3.sci.b s0, s1, 63 +0xfb,0x02,0x73,0xe0 == cv.shuffle2.h t0, t1, t2 +0x7b,0x8e,0xee,0xe1 == cv.shuffle2.h t3, t4, t5 +0x7b,0x85,0xc5,0xe0 == cv.shuffle2.h a0, a1, a2 +0x7b,0x84,0x24,0xe1 == cv.shuffle2.h s0, s1, s2 +0xfb,0x12,0x73,0xe0 == cv.shuffle2.b t0, t1, t2 +0x7b,0x9e,0xee,0xe1 == cv.shuffle2.b t3, t4, t5 +0x7b,0x95,0xc5,0xe0 == cv.shuffle2.b a0, a1, a2 +0x7b,0x94,0x24,0xe1 == cv.shuffle2.b s0, s1, s2 +0xfb,0x02,0x73,0xf0 == cv.pack t0, t1, t2 +0x7b,0x8e,0xee,0xf1 == cv.pack t3, t4, t5 +0x7b,0x85,0xc5,0xf0 == cv.pack a0, a1, a2 +0x7b,0x84,0x24,0xf1 == cv.pack s0, s1, s2 +0xfb,0x02,0x73,0xf2 == cv.pack.h t0, t1, t2 +0x7b,0x8e,0xee,0xf3 == cv.pack.h t3, t4, t5 +0x7b,0x85,0xc5,0xf2 == cv.pack.h a0, a1, a2 +0x7b,0x84,0x24,0xf3 == cv.pack.h s0, s1, s2 +0xfb,0x12,0x73,0xfa == cv.packhi.b t0, t1, t2 +0x7b,0x9e,0xee,0xfb == cv.packhi.b t3, t4, t5 +0x7b,0x95,0xc5,0xfa == cv.packhi.b a0, a1, a2 +0x7b,0x94,0x24,0xfb == cv.packhi.b s0, s1, s2 +0xfb,0x12,0x73,0xf8 == cv.packlo.b t0, t1, t2 +0x7b,0x9e,0xee,0xf9 == cv.packlo.b t3, t4, t5 +0x7b,0x95,0xc5,0xf8 == cv.packlo.b a0, a1, a2 +0x7b,0x94,0x24,0xf9 == cv.packlo.b s0, s1, s2 +0xfb,0x02,0x73,0x04 == cv.cmpeq.h t0, t1, t2 +0x7b,0x8e,0xee,0x05 == cv.cmpeq.h t3, t4, t5 +0x7b,0x85,0xc5,0x04 == cv.cmpeq.h a0, a1, a2 +0x7b,0x84,0x24,0x05 == cv.cmpeq.h s0, s1, s2 +0xfb,0x12,0x73,0x04 == cv.cmpeq.b t0, t1, t2 +0x7b,0x9e,0xee,0x05 == cv.cmpeq.b t3, t4, t5 +0x7b,0x95,0xc5,0x04 == cv.cmpeq.b a0, a1, a2 +0x7b,0x94,0x24,0x05 == cv.cmpeq.b s0, s1, s2 +0xfb,0x42,0x73,0x04 == cv.cmpeq.sc.h t0, t1, t2 +0x7b,0xce,0xee,0x05 == cv.cmpeq.sc.h t3, t4, t5 +0x7b,0xc5,0xc5,0x04 == cv.cmpeq.sc.h a0, a1, a2 +0x7b,0xc4,0x24,0x05 == cv.cmpeq.sc.h s0, s1, s2 +0xfb,0x52,0x73,0x04 == cv.cmpeq.sc.b t0, t1, t2 +0x7b,0xde,0xee,0x05 == cv.cmpeq.sc.b t3, t4, t5 +0x7b,0xd5,0xc5,0x04 == cv.cmpeq.sc.b a0, a1, a2 +0x7b,0xd4,0x24,0x05 == cv.cmpeq.sc.b s0, s1, s2 +0xfb,0x62,0x03,0x04 == cv.cmpeq.sci.h t0, t1, 0 +0x7b,0xee,0x0e,0x05 == cv.cmpeq.sci.h t3, t4, -32 +0x7b,0xe5,0x35,0x06 == cv.cmpeq.sci.h a0, a1, 7 +0x7b,0xe4,0xf4,0x07 == cv.cmpeq.sci.h s0, s1, -1 +0xfb,0x72,0x03,0x04 == cv.cmpeq.sci.b t0, t1, 0 +0x7b,0xfe,0x0e,0x05 == cv.cmpeq.sci.b t3, t4, -32 +0x7b,0xf5,0x35,0x06 == cv.cmpeq.sci.b a0, a1, 7 +0x7b,0xf4,0xf4,0x07 == cv.cmpeq.sci.b s0, s1, -1 +0xfb,0x02,0x73,0x0c == cv.cmpne.h t0, t1, t2 +0x7b,0x8e,0xee,0x0d == cv.cmpne.h t3, t4, t5 +0x7b,0x85,0xc5,0x0c == cv.cmpne.h a0, a1, a2 +0x7b,0x84,0x24,0x0d == cv.cmpne.h s0, s1, s2 +0xfb,0x12,0x73,0x0c == cv.cmpne.b t0, t1, t2 +0x7b,0x9e,0xee,0x0d == cv.cmpne.b t3, t4, t5 +0x7b,0x95,0xc5,0x0c == cv.cmpne.b a0, a1, a2 +0x7b,0x94,0x24,0x0d == cv.cmpne.b s0, s1, s2 +0xfb,0x42,0x73,0x0c == cv.cmpne.sc.h t0, t1, t2 +0x7b,0xce,0xee,0x0d == cv.cmpne.sc.h t3, t4, t5 +0x7b,0xc5,0xc5,0x0c == cv.cmpne.sc.h a0, a1, a2 +0x7b,0xc4,0x24,0x0d == cv.cmpne.sc.h s0, s1, s2 +0xfb,0x52,0x73,0x0c == cv.cmpne.sc.b t0, t1, t2 +0x7b,0xde,0xee,0x0d == cv.cmpne.sc.b t3, t4, t5 +0x7b,0xd5,0xc5,0x0c == cv.cmpne.sc.b a0, a1, a2 +0x7b,0xd4,0x24,0x0d == cv.cmpne.sc.b s0, s1, s2 +0xfb,0x62,0x03,0x0c == cv.cmpne.sci.h t0, t1, 0 +0x7b,0xee,0x0e,0x0d == cv.cmpne.sci.h t3, t4, -32 +0x7b,0xe5,0x35,0x0e == cv.cmpne.sci.h a0, a1, 7 +0x7b,0xe4,0xf4,0x0f == cv.cmpne.sci.h s0, s1, -1 +0xfb,0x72,0x03,0x0c == cv.cmpne.sci.b t0, t1, 0 +0x7b,0xfe,0x0e,0x0d == cv.cmpne.sci.b t3, t4, -32 +0x7b,0xf5,0x35,0x0e == cv.cmpne.sci.b a0, a1, 7 +0x7b,0xf4,0xf4,0x0f == cv.cmpne.sci.b s0, s1, -1 +0xfb,0x02,0x73,0x14 == cv.cmpgt.h t0, t1, t2 +0x7b,0x8e,0xee,0x15 == cv.cmpgt.h t3, t4, t5 +0x7b,0x85,0xc5,0x14 == cv.cmpgt.h a0, a1, a2 +0x7b,0x84,0x24,0x15 == cv.cmpgt.h s0, s1, s2 +0xfb,0x12,0x73,0x14 == cv.cmpgt.b t0, t1, t2 +0x7b,0x9e,0xee,0x15 == cv.cmpgt.b t3, t4, t5 +0x7b,0x95,0xc5,0x14 == cv.cmpgt.b a0, a1, a2 +0x7b,0x94,0x24,0x15 == cv.cmpgt.b s0, s1, s2 +0xfb,0x42,0x73,0x14 == cv.cmpgt.sc.h t0, t1, t2 +0x7b,0xce,0xee,0x15 == cv.cmpgt.sc.h t3, t4, t5 +0x7b,0xc5,0xc5,0x14 == cv.cmpgt.sc.h a0, a1, a2 +0x7b,0xc4,0x24,0x15 == cv.cmpgt.sc.h s0, s1, s2 +0xfb,0x52,0x73,0x14 == cv.cmpgt.sc.b t0, t1, t2 +0x7b,0xde,0xee,0x15 == cv.cmpgt.sc.b t3, t4, t5 +0x7b,0xd5,0xc5,0x14 == cv.cmpgt.sc.b a0, a1, a2 +0x7b,0xd4,0x24,0x15 == cv.cmpgt.sc.b s0, s1, s2 +0xfb,0x62,0x03,0x14 == cv.cmpgt.sci.h t0, t1, 0 +0x7b,0xee,0x0e,0x15 == cv.cmpgt.sci.h t3, t4, -32 +0x7b,0xe5,0x35,0x16 == cv.cmpgt.sci.h a0, a1, 7 +0x7b,0xe4,0xf4,0x17 == cv.cmpgt.sci.h s0, s1, -1 +0xfb,0x72,0x03,0x14 == cv.cmpgt.sci.b t0, t1, 0 +0x7b,0xfe,0x0e,0x15 == cv.cmpgt.sci.b t3, t4, -32 +0x7b,0xf5,0x35,0x16 == cv.cmpgt.sci.b a0, a1, 7 +0x7b,0xf4,0xf4,0x17 == cv.cmpgt.sci.b s0, s1, -1 +0xfb,0x02,0x73,0x1c == cv.cmpge.h t0, t1, t2 +0x7b,0x8e,0xee,0x1d == cv.cmpge.h t3, t4, t5 +0x7b,0x85,0xc5,0x1c == cv.cmpge.h a0, a1, a2 +0x7b,0x84,0x24,0x1d == cv.cmpge.h s0, s1, s2 +0xfb,0x12,0x73,0x1c == cv.cmpge.b t0, t1, t2 +0x7b,0x9e,0xee,0x1d == cv.cmpge.b t3, t4, t5 +0x7b,0x95,0xc5,0x1c == cv.cmpge.b a0, a1, a2 +0x7b,0x94,0x24,0x1d == cv.cmpge.b s0, s1, s2 +0xfb,0x42,0x73,0x1c == cv.cmpge.sc.h t0, t1, t2 +0x7b,0xce,0xee,0x1d == cv.cmpge.sc.h t3, t4, t5 +0x7b,0xc5,0xc5,0x1c == cv.cmpge.sc.h a0, a1, a2 +0x7b,0xc4,0x24,0x1d == cv.cmpge.sc.h s0, s1, s2 +0xfb,0x52,0x73,0x1c == cv.cmpge.sc.b t0, t1, t2 +0x7b,0xde,0xee,0x1d == cv.cmpge.sc.b t3, t4, t5 +0x7b,0xd5,0xc5,0x1c == cv.cmpge.sc.b a0, a1, a2 +0x7b,0xd4,0x24,0x1d == cv.cmpge.sc.b s0, s1, s2 +0xfb,0x62,0x03,0x1c == cv.cmpge.sci.h t0, t1, 0 +0x7b,0xee,0x0e,0x1d == cv.cmpge.sci.h t3, t4, -32 +0x7b,0xe5,0x35,0x1e == cv.cmpge.sci.h a0, a1, 7 +0x7b,0xe4,0xf4,0x1f == cv.cmpge.sci.h s0, s1, -1 +0xfb,0x72,0x03,0x1c == cv.cmpge.sci.b t0, t1, 0 +0x7b,0xfe,0x0e,0x1d == cv.cmpge.sci.b t3, t4, -32 +0x7b,0xf5,0x35,0x1e == cv.cmpge.sci.b a0, a1, 7 +0x7b,0xf4,0xf4,0x1f == cv.cmpge.sci.b s0, s1, -1 +0xfb,0x02,0x73,0x24 == cv.cmplt.h t0, t1, t2 +0x7b,0x8e,0xee,0x25 == cv.cmplt.h t3, t4, t5 +0x7b,0x85,0xc5,0x24 == cv.cmplt.h a0, a1, a2 +0x7b,0x84,0x24,0x25 == cv.cmplt.h s0, s1, s2 +0xfb,0x12,0x73,0x24 == cv.cmplt.b t0, t1, t2 +0x7b,0x9e,0xee,0x25 == cv.cmplt.b t3, t4, t5 +0x7b,0x95,0xc5,0x24 == cv.cmplt.b a0, a1, a2 +0x7b,0x94,0x24,0x25 == cv.cmplt.b s0, s1, s2 +0xfb,0x42,0x73,0x24 == cv.cmplt.sc.h t0, t1, t2 +0x7b,0xce,0xee,0x25 == cv.cmplt.sc.h t3, t4, t5 +0x7b,0xc5,0xc5,0x24 == cv.cmplt.sc.h a0, a1, a2 +0x7b,0xc4,0x24,0x25 == cv.cmplt.sc.h s0, s1, s2 +0xfb,0x52,0x73,0x24 == cv.cmplt.sc.b t0, t1, t2 +0x7b,0xde,0xee,0x25 == cv.cmplt.sc.b t3, t4, t5 +0x7b,0xd5,0xc5,0x24 == cv.cmplt.sc.b a0, a1, a2 +0x7b,0xd4,0x24,0x25 == cv.cmplt.sc.b s0, s1, s2 +0xfb,0x62,0x03,0x24 == cv.cmplt.sci.h t0, t1, 0 +0x7b,0xee,0x0e,0x25 == cv.cmplt.sci.h t3, t4, -32 +0x7b,0xe5,0x35,0x26 == cv.cmplt.sci.h a0, a1, 7 +0x7b,0xe4,0xf4,0x27 == cv.cmplt.sci.h s0, s1, -1 +0xfb,0x72,0x03,0x24 == cv.cmplt.sci.b t0, t1, 0 +0x7b,0xfe,0x0e,0x25 == cv.cmplt.sci.b t3, t4, -32 +0x7b,0xf5,0x35,0x26 == cv.cmplt.sci.b a0, a1, 7 +0x7b,0xf4,0xf4,0x27 == cv.cmplt.sci.b s0, s1, -1 +0xfb,0x02,0x73,0x2c == cv.cmple.h t0, t1, t2 +0x7b,0x8e,0xee,0x2d == cv.cmple.h t3, t4, t5 +0x7b,0x85,0xc5,0x2c == cv.cmple.h a0, a1, a2 +0x7b,0x84,0x24,0x2d == cv.cmple.h s0, s1, s2 +0xfb,0x12,0x73,0x2c == cv.cmple.b t0, t1, t2 +0x7b,0x9e,0xee,0x2d == cv.cmple.b t3, t4, t5 +0x7b,0x95,0xc5,0x2c == cv.cmple.b a0, a1, a2 +0x7b,0x94,0x24,0x2d == cv.cmple.b s0, s1, s2 +0xfb,0x42,0x73,0x2c == cv.cmple.sc.h t0, t1, t2 +0x7b,0xce,0xee,0x2d == cv.cmple.sc.h t3, t4, t5 +0x7b,0xc5,0xc5,0x2c == cv.cmple.sc.h a0, a1, a2 +0x7b,0xc4,0x24,0x2d == cv.cmple.sc.h s0, s1, s2 +0xfb,0x52,0x73,0x2c == cv.cmple.sc.b t0, t1, t2 +0x7b,0xde,0xee,0x2d == cv.cmple.sc.b t3, t4, t5 +0x7b,0xd5,0xc5,0x2c == cv.cmple.sc.b a0, a1, a2 +0x7b,0xd4,0x24,0x2d == cv.cmple.sc.b s0, s1, s2 +0xfb,0x62,0x03,0x2c == cv.cmple.sci.h t0, t1, 0 +0x7b,0xee,0x0e,0x2d == cv.cmple.sci.h t3, t4, -32 +0x7b,0xe5,0x35,0x2e == cv.cmple.sci.h a0, a1, 7 +0x7b,0xe4,0xf4,0x2f == cv.cmple.sci.h s0, s1, -1 +0xfb,0x72,0x03,0x2c == cv.cmple.sci.b t0, t1, 0 +0x7b,0xfe,0x0e,0x2d == cv.cmple.sci.b t3, t4, -32 +0x7b,0xf5,0x35,0x2e == cv.cmple.sci.b a0, a1, 7 +0x7b,0xf4,0xf4,0x2f == cv.cmple.sci.b s0, s1, -1 +0xfb,0x02,0x73,0x34 == cv.cmpgtu.h t0, t1, t2 +0x7b,0x8e,0xee,0x35 == cv.cmpgtu.h t3, t4, t5 +0x7b,0x85,0xc5,0x34 == cv.cmpgtu.h a0, a1, a2 +0x7b,0x84,0x24,0x35 == cv.cmpgtu.h s0, s1, s2 +0xfb,0x12,0x73,0x34 == cv.cmpgtu.b t0, t1, t2 +0x7b,0x9e,0xee,0x35 == cv.cmpgtu.b t3, t4, t5 +0x7b,0x95,0xc5,0x34 == cv.cmpgtu.b a0, a1, a2 +0x7b,0x94,0x24,0x35 == cv.cmpgtu.b s0, s1, s2 +0xfb,0x42,0x73,0x34 == cv.cmpgtu.sc.h t0, t1, t2 +0x7b,0xce,0xee,0x35 == cv.cmpgtu.sc.h t3, t4, t5 +0x7b,0xc5,0xc5,0x34 == cv.cmpgtu.sc.h a0, a1, a2 +0x7b,0xc4,0x24,0x35 == cv.cmpgtu.sc.h s0, s1, s2 +0xfb,0x52,0x73,0x34 == cv.cmpgtu.sc.b t0, t1, t2 +0x7b,0xde,0xee,0x35 == cv.cmpgtu.sc.b t3, t4, t5 +0x7b,0xd5,0xc5,0x34 == cv.cmpgtu.sc.b a0, a1, a2 +0x7b,0xd4,0x24,0x35 == cv.cmpgtu.sc.b s0, s1, s2 +0xfb,0x62,0x03,0x34 == cv.cmpgtu.sci.h t0, t1, 0 +0x7b,0xee,0x0e,0x35 == cv.cmpgtu.sci.h t3, t4, 32 +0x7b,0xe5,0x35,0x36 == cv.cmpgtu.sci.h a0, a1, 7 +0x7b,0xe4,0xf4,0x37 == cv.cmpgtu.sci.h s0, s1, 63 +0xfb,0x72,0x03,0x34 == cv.cmpgtu.sci.b t0, t1, 0 +0x7b,0xfe,0x0e,0x35 == cv.cmpgtu.sci.b t3, t4, 32 +0x7b,0xf5,0x35,0x36 == cv.cmpgtu.sci.b a0, a1, 7 +0x7b,0xf4,0xf4,0x37 == cv.cmpgtu.sci.b s0, s1, 63 +0xfb,0x02,0x73,0x3c == cv.cmpgeu.h t0, t1, t2 +0x7b,0x8e,0xee,0x3d == cv.cmpgeu.h t3, t4, t5 +0x7b,0x85,0xc5,0x3c == cv.cmpgeu.h a0, a1, a2 +0x7b,0x84,0x24,0x3d == cv.cmpgeu.h s0, s1, s2 +0xfb,0x12,0x73,0x3c == cv.cmpgeu.b t0, t1, t2 +0x7b,0x9e,0xee,0x3d == cv.cmpgeu.b t3, t4, t5 +0x7b,0x95,0xc5,0x3c == cv.cmpgeu.b a0, a1, a2 +0x7b,0x94,0x24,0x3d == cv.cmpgeu.b s0, s1, s2 +0xfb,0x42,0x73,0x3c == cv.cmpgeu.sc.h t0, t1, t2 +0x7b,0xce,0xee,0x3d == cv.cmpgeu.sc.h t3, t4, t5 +0x7b,0xc5,0xc5,0x3c == cv.cmpgeu.sc.h a0, a1, a2 +0x7b,0xc4,0x24,0x3d == cv.cmpgeu.sc.h s0, s1, s2 +0xfb,0x52,0x73,0x3c == cv.cmpgeu.sc.b t0, t1, t2 +0x7b,0xde,0xee,0x3d == cv.cmpgeu.sc.b t3, t4, t5 +0x7b,0xd5,0xc5,0x3c == cv.cmpgeu.sc.b a0, a1, a2 +0x7b,0xd4,0x24,0x3d == cv.cmpgeu.sc.b s0, s1, s2 +0xfb,0x62,0x03,0x3c == cv.cmpgeu.sci.h t0, t1, 0 +0x7b,0xee,0x0e,0x3d == cv.cmpgeu.sci.h t3, t4, 32 +0x7b,0xe5,0x35,0x3e == cv.cmpgeu.sci.h a0, a1, 7 +0x7b,0xe4,0xf4,0x3f == cv.cmpgeu.sci.h s0, s1, 63 +0xfb,0x72,0x03,0x3c == cv.cmpgeu.sci.b t0, t1, 0 +0x7b,0xfe,0x0e,0x3d == cv.cmpgeu.sci.b t3, t4, 32 +0x7b,0xf5,0x35,0x3e == cv.cmpgeu.sci.b a0, a1, 7 +0x7b,0xf4,0xf4,0x3f == cv.cmpgeu.sci.b s0, s1, 63 +0xfb,0x02,0x73,0x44 == cv.cmpltu.h t0, t1, t2 +0x7b,0x8e,0xee,0x45 == cv.cmpltu.h t3, t4, t5 +0x7b,0x85,0xc5,0x44 == cv.cmpltu.h a0, a1, a2 +0x7b,0x84,0x24,0x45 == cv.cmpltu.h s0, s1, s2 +0xfb,0x12,0x73,0x44 == cv.cmpltu.b t0, t1, t2 +0x7b,0x9e,0xee,0x45 == cv.cmpltu.b t3, t4, t5 +0x7b,0x95,0xc5,0x44 == cv.cmpltu.b a0, a1, a2 +0x7b,0x94,0x24,0x45 == cv.cmpltu.b s0, s1, s2 +0xfb,0x42,0x73,0x44 == cv.cmpltu.sc.h t0, t1, t2 +0x7b,0xce,0xee,0x45 == cv.cmpltu.sc.h t3, t4, t5 +0x7b,0xc5,0xc5,0x44 == cv.cmpltu.sc.h a0, a1, a2 +0x7b,0xc4,0x24,0x45 == cv.cmpltu.sc.h s0, s1, s2 +0xfb,0x52,0x73,0x44 == cv.cmpltu.sc.b t0, t1, t2 +0x7b,0xde,0xee,0x45 == cv.cmpltu.sc.b t3, t4, t5 +0x7b,0xd5,0xc5,0x44 == cv.cmpltu.sc.b a0, a1, a2 +0x7b,0xd4,0x24,0x45 == cv.cmpltu.sc.b s0, s1, s2 +0xfb,0x62,0x03,0x44 == cv.cmpltu.sci.h t0, t1, 0 +0x7b,0xee,0x0e,0x45 == cv.cmpltu.sci.h t3, t4, 32 +0x7b,0xe5,0x35,0x46 == cv.cmpltu.sci.h a0, a1, 7 +0x7b,0xe4,0xf4,0x47 == cv.cmpltu.sci.h s0, s1, 63 +0xfb,0x72,0x03,0x44 == cv.cmpltu.sci.b t0, t1, 0 +0x7b,0xfe,0x0e,0x45 == cv.cmpltu.sci.b t3, t4, 32 +0x7b,0xf5,0x35,0x46 == cv.cmpltu.sci.b a0, a1, 7 +0x7b,0xf4,0xf4,0x47 == cv.cmpltu.sci.b s0, s1, 63 +0xfb,0x02,0x73,0x4c == cv.cmpleu.h t0, t1, t2 +0x7b,0x8e,0xee,0x4d == cv.cmpleu.h t3, t4, t5 +0x7b,0x85,0xc5,0x4c == cv.cmpleu.h a0, a1, a2 +0x7b,0x84,0x24,0x4d == cv.cmpleu.h s0, s1, s2 +0xfb,0x12,0x73,0x4c == cv.cmpleu.b t0, t1, t2 +0x7b,0x9e,0xee,0x4d == cv.cmpleu.b t3, t4, t5 +0x7b,0x95,0xc5,0x4c == cv.cmpleu.b a0, a1, a2 +0x7b,0x94,0x24,0x4d == cv.cmpleu.b s0, s1, s2 +0xfb,0x42,0x73,0x4c == cv.cmpleu.sc.h t0, t1, t2 +0x7b,0xce,0xee,0x4d == cv.cmpleu.sc.h t3, t4, t5 +0x7b,0xc5,0xc5,0x4c == cv.cmpleu.sc.h a0, a1, a2 +0x7b,0xc4,0x24,0x4d == cv.cmpleu.sc.h s0, s1, s2 +0xfb,0x52,0x73,0x4c == cv.cmpleu.sc.b t0, t1, t2 +0x7b,0xde,0xee,0x4d == cv.cmpleu.sc.b t3, t4, t5 +0x7b,0xd5,0xc5,0x4c == cv.cmpleu.sc.b a0, a1, a2 +0x7b,0xd4,0x24,0x4d == cv.cmpleu.sc.b s0, s1, s2 +0xfb,0x62,0x03,0x4c == cv.cmpleu.sci.h t0, t1, 0 +0x7b,0xee,0x0e,0x4d == cv.cmpleu.sci.h t3, t4, 32 +0x7b,0xe5,0x35,0x4e == cv.cmpleu.sci.h a0, a1, 7 +0x7b,0xe4,0xf4,0x4f == cv.cmpleu.sci.h s0, s1, 63 +0xfb,0x72,0x03,0x4c == cv.cmpleu.sci.b t0, t1, 0 +0x7b,0xfe,0x0e,0x4d == cv.cmpleu.sci.b t3, t4, 32 +0x7b,0xf5,0x35,0x4e == cv.cmpleu.sci.b a0, a1, 7 +0x7b,0xf4,0xf4,0x4f == cv.cmpleu.sci.b s0, s1, 63 +0xfb,0x02,0x73,0x54 == cv.cplxmul.r t0, t1, t2 +0x7b,0x8e,0xee,0x55 == cv.cplxmul.r t3, t4, t5 +0x7b,0x85,0xc5,0x54 == cv.cplxmul.r a0, a1, a2 +0x7b,0x84,0x24,0x55 == cv.cplxmul.r s0, s1, s2 +0xfb,0x02,0x73,0x56 == cv.cplxmul.i t0, t1, t2 +0x7b,0x8e,0xee,0x57 == cv.cplxmul.i t3, t4, t5 +0x7b,0x85,0xc5,0x56 == cv.cplxmul.i a0, a1, a2 +0x7b,0x84,0x24,0x57 == cv.cplxmul.i s0, s1, s2 +0xfb,0x22,0x73,0x54 == cv.cplxmul.r.div2 t0, t1, t2 +0x7b,0xae,0xee,0x55 == cv.cplxmul.r.div2 t3, t4, t5 +0x7b,0xa5,0xc5,0x54 == cv.cplxmul.r.div2 a0, a1, a2 +0x7b,0xa4,0x24,0x55 == cv.cplxmul.r.div2 s0, s1, s2 +0xfb,0x22,0x73,0x56 == cv.cplxmul.i.div2 t0, t1, t2 +0x7b,0xae,0xee,0x57 == cv.cplxmul.i.div2 t3, t4, t5 +0x7b,0xa5,0xc5,0x56 == cv.cplxmul.i.div2 a0, a1, a2 +0x7b,0xa4,0x24,0x57 == cv.cplxmul.i.div2 s0, s1, s2 +0xfb,0x42,0x73,0x54 == cv.cplxmul.r.div4 t0, t1, t2 +0x7b,0xce,0xee,0x55 == cv.cplxmul.r.div4 t3, t4, t5 +0x7b,0xc5,0xc5,0x54 == cv.cplxmul.r.div4 a0, a1, a2 +0x7b,0xc4,0x24,0x55 == cv.cplxmul.r.div4 s0, s1, s2 +0xfb,0x42,0x73,0x56 == cv.cplxmul.i.div4 t0, t1, t2 +0x7b,0xce,0xee,0x57 == cv.cplxmul.i.div4 t3, t4, t5 +0x7b,0xc5,0xc5,0x56 == cv.cplxmul.i.div4 a0, a1, a2 +0x7b,0xc4,0x24,0x57 == cv.cplxmul.i.div4 s0, s1, s2 +0xfb,0x62,0x73,0x54 == cv.cplxmul.r.div8 t0, t1, t2 +0x7b,0xee,0xee,0x55 == cv.cplxmul.r.div8 t3, t4, t5 +0x7b,0xe5,0xc5,0x54 == cv.cplxmul.r.div8 a0, a1, a2 +0x7b,0xe4,0x24,0x55 == cv.cplxmul.r.div8 s0, s1, s2 +0xfb,0x62,0x73,0x56 == cv.cplxmul.i.div8 t0, t1, t2 +0x7b,0xee,0xee,0x57 == cv.cplxmul.i.div8 t3, t4, t5 +0x7b,0xe5,0xc5,0x56 == cv.cplxmul.i.div8 a0, a1, a2 +0x7b,0xe4,0x24,0x57 == cv.cplxmul.i.div8 s0, s1, s2 +0xfb,0x02,0x03,0x5c == cv.cplxconj t0, t1 +0x7b,0x8e,0x0e,0x5c == cv.cplxconj t3, t4 +0x7b,0x85,0x05,0x5c == cv.cplxconj a0, a1 +0x7b,0x84,0x04,0x5c == cv.cplxconj s0, s1 +0xfb,0x02,0x73,0x64 == cv.subrotmj t0, t1, t2 +0x7b,0x8e,0xee,0x65 == cv.subrotmj t3, t4, t5 +0x7b,0x85,0xc5,0x64 == cv.subrotmj a0, a1, a2 +0x7b,0x84,0x24,0x65 == cv.subrotmj s0, s1, s2 +0xfb,0x22,0x73,0x64 == cv.subrotmj.div2 t0, t1, t2 +0x7b,0xae,0xee,0x65 == cv.subrotmj.div2 t3, t4, t5 +0x7b,0xa5,0xc5,0x64 == cv.subrotmj.div2 a0, a1, a2 +0x7b,0xa4,0x24,0x65 == cv.subrotmj.div2 s0, s1, s2 +0xfb,0x42,0x73,0x64 == cv.subrotmj.div4 t0, t1, t2 +0x7b,0xce,0xee,0x65 == cv.subrotmj.div4 t3, t4, t5 +0x7b,0xc5,0xc5,0x64 == cv.subrotmj.div4 a0, a1, a2 +0x7b,0xc4,0x24,0x65 == cv.subrotmj.div4 s0, s1, s2 +0xfb,0x62,0x73,0x64 == cv.subrotmj.div8 t0, t1, t2 +0x7b,0xee,0xee,0x65 == cv.subrotmj.div8 t3, t4, t5 +0x7b,0xe5,0xc5,0x64 == cv.subrotmj.div8 a0, a1, a2 +0x7b,0xe4,0x24,0x65 == cv.subrotmj.div8 s0, s1, s2 +0xfb,0x22,0x73,0x6c == cv.add.div2 t0, t1, t2 +0x7b,0xae,0xee,0x6d == cv.add.div2 t3, t4, t5 +0x7b,0xa5,0xc5,0x6c == cv.add.div2 a0, a1, a2 +0x7b,0xa4,0x24,0x6d == cv.add.div2 s0, s1, s2 +0xfb,0x42,0x73,0x6c == cv.add.div4 t0, t1, t2 +0x7b,0xce,0xee,0x6d == cv.add.div4 t3, t4, t5 +0x7b,0xc5,0xc5,0x6c == cv.add.div4 a0, a1, a2 +0x7b,0xc4,0x24,0x6d == cv.add.div4 s0, s1, s2 +0xfb,0x62,0x73,0x6c == cv.add.div8 t0, t1, t2 +0x7b,0xee,0xee,0x6d == cv.add.div8 t3, t4, t5 +0x7b,0xe5,0xc5,0x6c == cv.add.div8 a0, a1, a2 +0x7b,0xe4,0x24,0x6d == cv.add.div8 s0, s1, s2 +0xfb,0x22,0x73,0x74 == cv.sub.div2 t0, t1, t2 +0x7b,0xae,0xee,0x75 == cv.sub.div2 t3, t4, t5 +0x7b,0xa5,0xc5,0x74 == cv.sub.div2 a0, a1, a2 +0x7b,0xa4,0x24,0x75 == cv.sub.div2 s0, s1, s2 +0xfb,0x42,0x73,0x74 == cv.sub.div4 t0, t1, t2 +0x7b,0xce,0xee,0x75 == cv.sub.div4 t3, t4, t5 +0x7b,0xc5,0xc5,0x74 == cv.sub.div4 a0, a1, a2 +0x7b,0xc4,0x24,0x75 == cv.sub.div4 s0, s1, s2 +0xfb,0x62,0x73,0x74 == cv.sub.div8 t0, t1, t2 +0x7b,0xee,0xee,0x75 == cv.sub.div8 t3, t4, t5 +0x7b,0xe5,0xc5,0x74 == cv.sub.div8 a0, a1, a2 +0x7b,0xe4,0x24,0x75 == cv.sub.div8 s0, s1, s2 \ No newline at end of file diff --git a/suite/MC/RISCV/XTHeadBa_valid_riscv32_riscv_xtheadba.txt.cs b/suite/MC/RISCV/XTHeadBa_valid_riscv32_riscv_xtheadba.txt.cs new file mode 100644 index 0000000000..6d57ddb913 --- /dev/null +++ b/suite/MC/RISCV/XTHeadBa_valid_riscv32_riscv_xtheadba.txt.cs @@ -0,0 +1,5 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32"|"CS_MODE_RISCV_XTHEADBA", None +0x8b,0x12,0x73,0x00 == th.addsl t0, t1, t2, 0 +0x8b,0x12,0x73,0x02 == th.addsl t0, t1, t2, 1 +0x8b,0x12,0x73,0x04 == th.addsl t0, t1, t2, 2 +0x8b,0x12,0x73,0x06 == th.addsl t0, t1, t2, 3 \ No newline at end of file diff --git a/suite/MC/RISCV/XTHeadVdot_valid_riscv64_riscv_xtheadvdot.txt.cs b/suite/MC/RISCV/XTHeadVdot_valid_riscv64_riscv_xtheadvdot.txt.cs new file mode 100644 index 0000000000..c94f5b8e4e --- /dev/null +++ b/suite/MC/RISCV/XTHeadVdot_valid_riscv64_riscv_xtheadvdot.txt.cs @@ -0,0 +1,15 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64"|"CS_MODE_RISCV_XTHEADVDOT", None +0x0b,0x64,0x4a,0x88 == th.vmaqau.vv v8, v20, v4, v0.t +0x0b,0x64,0x4a,0x8a == th.vmaqau.vv v8, v20, v4 +0x0b,0x64,0x45,0x8c == th.vmaqau.vx v8, a0, v4, v0.t +0x0b,0x64,0x45,0x8e == th.vmaqau.vx v8, a0, v4 +0x0b,0x64,0x4a,0x80 == th.vmaqa.vv v8, v20, v4, v0.t +0x0b,0x64,0x4a,0x82 == th.vmaqa.vv v8, v20, v4 +0x0b,0x64,0x45,0x84 == th.vmaqa.vx v8, a0, v4, v0.t +0x0b,0x64,0x45,0x86 == th.vmaqa.vx v8, a0, v4 +0x0b,0x64,0x4a,0x90 == th.vmaqasu.vv v8, v20, v4, v0.t +0x0b,0x64,0x4a,0x92 == th.vmaqasu.vv v8, v20, v4 +0x0b,0x64,0x45,0x94 == th.vmaqasu.vx v8, a0, v4, v0.t +0x0b,0x64,0x45,0x96 == th.vmaqasu.vx v8, a0, v4 +0x0b,0x64,0x45,0x9c == th.vmaqaus.vx v8, a0, v4, v0.t +0x0b,0x64,0x45,0x9e == th.vmaqaus.vx v8, a0, v4 \ No newline at end of file diff --git a/suite/MC/RISCV/XVentanaCondOps_valid_riscv64_xventanacondops_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/XVentanaCondOps_valid_riscv64_xventanacondops_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..9a6949f278 --- /dev/null +++ b/suite/MC/RISCV/XVentanaCondOps_valid_riscv64_xventanacondops_syntax_no_alias_text.txt.cs @@ -0,0 +1,5 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64", None +0x7b,0x60,0x00,0x00 == vt.maskc zero, zero, zero +0x7b,0x70,0x00,0x00 == vt.maskcn zero, zero, zero +0xfb,0x60,0x31,0x00 == vt.maskc ra, sp, gp +0xfb,0x70,0x31,0x00 == vt.maskcn ra, sp, gp \ No newline at end of file diff --git a/suite/MC/RISCV/Zawrs_valid_riscv32_zawrs_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/Zawrs_valid_riscv32_zawrs_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..3475724d62 --- /dev/null +++ b/suite/MC/RISCV/Zawrs_valid_riscv32_zawrs_syntax_no_alias_text.txt.cs @@ -0,0 +1,3 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32", None +0x73,0x00,0xd0,0x00 == wrs.nto +0x73,0x00,0xd0,0x01 == wrs.sto \ No newline at end of file diff --git a/suite/MC/RISCV/add_riscv64_riscv_v.txt.cs b/suite/MC/RISCV/add_riscv64_riscv_v.txt.cs new file mode 100644 index 0000000000..e00c9ff3b7 --- /dev/null +++ b/suite/MC/RISCV/add_riscv64_riscv_v.txt.cs @@ -0,0 +1,60 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64"|"CS_MODE_RISCV_V", None +0x57,0x04,0x4a,0x00 == vadd.vv v8, v4, v20, v0.t +0x57,0x04,0x4a,0x02 == vadd.vv v8, v4, v20 +0x57,0x44,0x45,0x00 == vadd.vx v8, v4, a0, v0.t +0x57,0x44,0x45,0x02 == vadd.vx v8, v4, a0 +0x57,0xb4,0x47,0x00 == vadd.vi v8, v4, 15, v0.t +0x57,0xb4,0x47,0x02 == vadd.vi v8, v4, 15 +0x57,0x24,0x4a,0xc0 == vwaddu.vv v8, v4, v20, v0.t +0x57,0x24,0x4a,0xc2 == vwaddu.vv v8, v4, v20 +0x57,0x64,0x45,0xc0 == vwaddu.vx v8, v4, a0, v0.t +0x57,0x64,0x45,0xc2 == vwaddu.vx v8, v4, a0 +0x57,0x24,0x4a,0xc4 == vwadd.vv v8, v4, v20, v0.t +0x57,0x24,0x4a,0xc6 == vwadd.vv v8, v4, v20 +0x57,0x64,0x45,0xc4 == vwadd.vx v8, v4, a0, v0.t +0x57,0x64,0x45,0xc6 == vwadd.vx v8, v4, a0 +0x57,0x24,0x4a,0xd0 == vwaddu.wv v8, v4, v20, v0.t +0x57,0x24,0x4a,0xd2 == vwaddu.wv v8, v4, v20 +0x57,0x64,0x45,0xd0 == vwaddu.wx v8, v4, a0, v0.t +0x57,0x64,0x45,0xd2 == vwaddu.wx v8, v4, a0 +0x57,0x24,0x4a,0xd4 == vwadd.wv v8, v4, v20, v0.t +0x57,0x24,0x4a,0xd6 == vwadd.wv v8, v4, v20 +0x57,0x64,0x45,0xd4 == vwadd.wx v8, v4, a0, v0.t +0x57,0x64,0x45,0xd6 == vwadd.wx v8, v4, a0 +0x57,0x04,0x4a,0x40 == vadc.vvm v8, v4, v20, v0 +0x57,0x02,0x4a,0x40 == vadc.vvm v4, v4, v20, v0 +0x57,0x04,0x44,0x40 == vadc.vvm v8, v4, v8, v0 +0x57,0x44,0x45,0x40 == vadc.vxm v8, v4, a0, v0 +0x57,0xb4,0x47,0x40 == vadc.vim v8, v4, 15, v0 +0x57,0x04,0x4a,0x44 == vmadc.vvm v8, v4, v20, v0 +0x57,0x02,0x4a,0x44 == vmadc.vvm v4, v4, v20, v0 +0x57,0x04,0x44,0x44 == vmadc.vvm v8, v4, v8, v0 +0x57,0x44,0x45,0x44 == vmadc.vxm v8, v4, a0, v0 +0x57,0xb4,0x47,0x44 == vmadc.vim v8, v4, 15, v0 +0x57,0x04,0x4a,0x46 == vmadc.vv v8, v4, v20 +0x57,0x44,0x45,0x46 == vmadc.vx v8, v4, a0 +0x57,0xb4,0x47,0x46 == vmadc.vi v8, v4, 15 +0x57,0x04,0x4a,0x80 == vsaddu.vv v8, v4, v20, v0.t +0x57,0x04,0x4a,0x82 == vsaddu.vv v8, v4, v20 +0x57,0x44,0x45,0x80 == vsaddu.vx v8, v4, a0, v0.t +0x57,0x44,0x45,0x82 == vsaddu.vx v8, v4, a0 +0x57,0xb4,0x47,0x80 == vsaddu.vi v8, v4, 15, v0.t +0x57,0xb4,0x47,0x82 == vsaddu.vi v8, v4, 15 +0x57,0x04,0x4a,0x84 == vsadd.vv v8, v4, v20, v0.t +0x57,0x04,0x4a,0x86 == vsadd.vv v8, v4, v20 +0x57,0x44,0x45,0x84 == vsadd.vx v8, v4, a0, v0.t +0x57,0x44,0x45,0x86 == vsadd.vx v8, v4, a0 +0x57,0xb4,0x47,0x84 == vsadd.vi v8, v4, 15, v0.t +0x57,0xb4,0x47,0x86 == vsadd.vi v8, v4, 15 +0x57,0x24,0x4a,0x24 == vaadd.vv v8, v4, v20, v0.t +0x57,0x24,0x4a,0x26 == vaadd.vv v8, v4, v20 +0x57,0x64,0x45,0x24 == vaadd.vx v8, v4, a0, v0.t +0x57,0x64,0x45,0x26 == vaadd.vx v8, v4, a0 +0x57,0x24,0x4a,0x20 == vaaddu.vv v8, v4, v20, v0.t +0x57,0x24,0x4a,0x22 == vaaddu.vv v8, v4, v20 +0x57,0x64,0x45,0x20 == vaaddu.vx v8, v4, a0, v0.t +0x57,0x64,0x45,0x22 == vaaddu.vx v8, v4, a0 +0x57,0x64,0x40,0xc4 == vwcvt.x.x.v v8, v4, v0.t +0x57,0x64,0x40,0xc6 == vwcvt.x.x.v v8, v4 +0x57,0x64,0x40,0xc0 == vwcvtu.x.x.v v8, v4, v0.t +0x57,0x64,0x40,0xc2 == vwcvtu.x.x.v v8, v4 \ No newline at end of file diff --git a/suite/MC/RISCV/and_riscv64_riscv_v.txt.cs b/suite/MC/RISCV/and_riscv64_riscv_v.txt.cs new file mode 100644 index 0000000000..7201bcee92 --- /dev/null +++ b/suite/MC/RISCV/and_riscv64_riscv_v.txt.cs @@ -0,0 +1,7 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64"|"CS_MODE_RISCV_V", None +0x57,0x04,0x4a,0x24 == vand.vv v8, v4, v20, v0.t +0x57,0x04,0x4a,0x26 == vand.vv v8, v4, v20 +0x57,0x44,0x45,0x24 == vand.vx v8, v4, a0, v0.t +0x57,0x44,0x45,0x26 == vand.vx v8, v4, a0 +0x57,0xb4,0x47,0x24 == vand.vi v8, v4, 15, v0.t +0x57,0xb4,0x47,0x26 == vand.vi v8, v4, 15 \ No newline at end of file diff --git a/suite/MC/RISCV/clip_riscv64_riscv_v.txt.cs b/suite/MC/RISCV/clip_riscv64_riscv_v.txt.cs new file mode 100644 index 0000000000..643cb5c456 --- /dev/null +++ b/suite/MC/RISCV/clip_riscv64_riscv_v.txt.cs @@ -0,0 +1,13 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64"|"CS_MODE_RISCV_V", None +0x57,0x04,0x4a,0xb8 == vnclipu.wv v8, v4, v20, v0.t +0x57,0x04,0x4a,0xba == vnclipu.wv v8, v4, v20 +0x57,0x44,0x45,0xb8 == vnclipu.wx v8, v4, a0, v0.t +0x57,0x44,0x45,0xba == vnclipu.wx v8, v4, a0 +0x57,0xb4,0x4f,0xb8 == vnclipu.wi v8, v4, 31, v0.t +0x57,0xb4,0x4f,0xba == vnclipu.wi v8, v4, 31 +0x57,0x04,0x4a,0xbc == vnclip.wv v8, v4, v20, v0.t +0x57,0x04,0x4a,0xbe == vnclip.wv v8, v4, v20 +0x57,0x44,0x45,0xbc == vnclip.wx v8, v4, a0, v0.t +0x57,0x44,0x45,0xbe == vnclip.wx v8, v4, a0 +0x57,0xb4,0x4f,0xbc == vnclip.wi v8, v4, 31, v0.t +0x57,0xb4,0x4f,0xbe == vnclip.wi v8, v4, 31 \ No newline at end of file diff --git a/suite/MC/RISCV/compare_riscv64_riscv_v.txt.cs b/suite/MC/RISCV/compare_riscv64_riscv_v.txt.cs new file mode 100644 index 0000000000..6a666f9f0e --- /dev/null +++ b/suite/MC/RISCV/compare_riscv64_riscv_v.txt.cs @@ -0,0 +1,58 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64"|"CS_MODE_RISCV_V", None +0x57,0x00,0x4a,0x6c == vmslt.vv v0, v4, v20, v0.t +0x57,0x04,0x4a,0x60 == vmseq.vv v8, v4, v20, v0.t +0x57,0x04,0x4a,0x62 == vmseq.vv v8, v4, v20 +0x57,0x44,0x45,0x60 == vmseq.vx v8, v4, a0, v0.t +0x57,0x44,0x45,0x62 == vmseq.vx v8, v4, a0 +0x57,0xb4,0x47,0x60 == vmseq.vi v8, v4, 15, v0.t +0x57,0xb4,0x47,0x62 == vmseq.vi v8, v4, 15 +0x57,0x04,0x4a,0x64 == vmsne.vv v8, v4, v20, v0.t +0x57,0x04,0x4a,0x66 == vmsne.vv v8, v4, v20 +0x57,0x44,0x45,0x64 == vmsne.vx v8, v4, a0, v0.t +0x57,0x44,0x45,0x66 == vmsne.vx v8, v4, a0 +0x57,0xb4,0x47,0x64 == vmsne.vi v8, v4, 15, v0.t +0x57,0xb4,0x47,0x66 == vmsne.vi v8, v4, 15 +0x57,0x04,0x4a,0x68 == vmsltu.vv v8, v4, v20, v0.t +0x57,0x04,0x4a,0x6a == vmsltu.vv v8, v4, v20 +0x57,0x44,0x45,0x68 == vmsltu.vx v8, v4, a0, v0.t +0x57,0x44,0x45,0x6a == vmsltu.vx v8, v4, a0 +0x57,0x04,0x4a,0x6c == vmslt.vv v8, v4, v20, v0.t +0x57,0x04,0x4a,0x6e == vmslt.vv v8, v4, v20 +0x57,0x44,0x45,0x6c == vmslt.vx v8, v4, a0, v0.t +0x57,0x44,0x45,0x6e == vmslt.vx v8, v4, a0 +0x57,0x04,0x4a,0x70 == vmsleu.vv v8, v4, v20, v0.t +0x57,0x04,0x4a,0x72 == vmsleu.vv v8, v4, v20 +0x57,0x44,0x45,0x70 == vmsleu.vx v8, v4, a0, v0.t +0x57,0x44,0x45,0x72 == vmsleu.vx v8, v4, a0 +0x57,0xb4,0x47,0x70 == vmsleu.vi v8, v4, 15, v0.t +0x57,0xb4,0x47,0x72 == vmsleu.vi v8, v4, 15 +0x57,0x04,0x4a,0x74 == vmsle.vv v8, v4, v20, v0.t +0x57,0x04,0x4a,0x76 == vmsle.vv v8, v4, v20 +0x57,0x44,0x45,0x74 == vmsle.vx v8, v4, a0, v0.t +0x57,0x44,0x45,0x76 == vmsle.vx v8, v4, a0 +0x57,0xb4,0x47,0x74 == vmsle.vi v8, v4, 15, v0.t +0x57,0xb4,0x47,0x76 == vmsle.vi v8, v4, 15 +0x57,0x44,0x45,0x78 == vmsgtu.vx v8, v4, a0, v0.t +0x57,0x44,0x45,0x7a == vmsgtu.vx v8, v4, a0 +0x57,0xb4,0x47,0x78 == vmsgtu.vi v8, v4, 15, v0.t +0x57,0xb4,0x47,0x7a == vmsgtu.vi v8, v4, 15 +0x57,0x44,0x45,0x7c == vmsgt.vx v8, v4, a0, v0.t +0x57,0x44,0x45,0x7e == vmsgt.vx v8, v4, a0 +0x57,0xb4,0x47,0x7c == vmsgt.vi v8, v4, 15, v0.t +0x57,0xb4,0x47,0x7e == vmsgt.vi v8, v4, 15 +0x57,0x04,0x42,0x64 == vmsne.vv v8, v4, v4, v0.t +0x57,0x04,0x42,0x66 == vmsne.vv v8, v4, v4 +0x57,0x04,0x42,0x60 == vmseq.vv v8, v4, v4, v0.t +0x57,0x04,0x42,0x62 == vmseq.vv v8, v4, v4 +0x57,0x24,0x84,0x76 == vmnot.m v8, v8 +0x57,0x40,0x45,0x6e == vmslt.vx v0, v4, a0 +0x57,0x20,0x00,0x76 == vmnot.m v0, v0 +0x57,0x24,0x80,0x6e == vmxor.mm v8, v8, v0 +0x57,0x41,0x45,0x6a == vmsltu.vx v2, v4, a0 +0x57,0x20,0x01,0x62 == vmandn.mm v0, v0, v2 +0x57,0x41,0x45,0x6e == vmslt.vx v2, v4, a0 +0x57,0x21,0x01,0x62 == vmandn.mm v2, v0, v2 +0xd7,0x24,0x90,0x62 == vmandn.mm v9, v9, v0 +0xd7,0xa4,0x24,0x6a == vmor.mm v9, v2, v9 +0x57,0x24,0x80,0x62 == vmandn.mm v8, v8, v0 +0x57,0x24,0x24,0x6a == vmor.mm v8, v2, v8 \ No newline at end of file diff --git a/suite/MC/RISCV/compress_cjal_riscv32_riscv_c.txt.cs b/suite/MC/RISCV/compress_cjal_riscv32_riscv_c.txt.cs new file mode 100644 index 0000000000..e3ac7de836 --- /dev/null +++ b/suite/MC/RISCV/compress_cjal_riscv32_riscv_c.txt.cs @@ -0,0 +1,2 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32"|"CS_MODE_RISCV_C", None +0xfd,0x2f == jal 2046 \ No newline at end of file diff --git a/suite/MC/RISCV/compress_rv32d_riscv32_riscv_c_riscv_d.txt.cs b/suite/MC/RISCV/compress_rv32d_riscv32_riscv_c_riscv_d.txt.cs new file mode 100644 index 0000000000..9b8b2d6ed1 --- /dev/null +++ b/suite/MC/RISCV/compress_rv32d_riscv32_riscv_c_riscv_d.txt.cs @@ -0,0 +1,5 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32"|"CS_MODE_RISCV_C"|"CS_MODE_RISCV_D", None +0x06,0x20 == fld ft0, 64(sp) +0x82,0xa0 == fsd ft0, 64(sp) +0x60,0x3c == fld fs0, 248(s0) +0x60,0xbc == fsd fs0, 248(s0) \ No newline at end of file diff --git a/suite/MC/RISCV/compress_rv32f_riscv32_riscv_c_riscv_f.txt.cs b/suite/MC/RISCV/compress_rv32f_riscv32_riscv_c_riscv_f.txt.cs new file mode 100644 index 0000000000..58dfcafbb4 --- /dev/null +++ b/suite/MC/RISCV/compress_rv32f_riscv32_riscv_c_riscv_f.txt.cs @@ -0,0 +1,5 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32"|"CS_MODE_RISCV_C"|"CS_MODE_RISCV_F", None +0x76,0x70 == flw ft0, 124(sp) +0x82,0xfe == fsw ft0, 124(sp) +0x60,0x7c == flw fs0, 124(s0) +0x60,0xfc == fsw fs0, 124(s0) \ No newline at end of file diff --git a/suite/MC/RISCV/compress_rv32i_riscv32_riscv_c.txt.cs b/suite/MC/RISCV/compress_rv32i_riscv32_riscv_c.txt.cs new file mode 100644 index 0000000000..9cf70fe47a --- /dev/null +++ b/suite/MC/RISCV/compress_rv32i_riscv32_riscv_c.txt.cs @@ -0,0 +1,30 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32"|"CS_MODE_RISCV_C", None +0x2e,0x85 == mv a0, a1 +0xe0,0x1f == addi s0, sp, 1020 +0xe0,0x5f == lw s0, 124(a5) +0xe0,0xdf == sw s0, 124(a5) +0x01,0x00 == nop +0x81,0x10 == addi ra, ra, -32 +0x85,0x50 == li ra, -31 +0x39,0x71 == addi sp, sp, -64 +0xfd,0x61 == lui gp, 31 +0x7d,0x80 == srli s0, s0, 31 +0x7d,0x84 == srai s0, s0, 31 +0x7d,0x88 == andi s0, s0, 31 +0x1d,0x8c == sub s0, s0, a5 +0x3d,0x8c == xor s0, s0, a5 +0x5d,0x8c == or s0, s0, a5 +0x45,0x8c == or s0, s0, s1 +0x7d,0x8c == and s0, s0, a5 +0x01,0xb0 == j -2048 +0x01,0xd0 == beqz s0, -256 +0x7d,0xec == bnez s0, 254 +0x7e,0x04 == slli s0, s0, 31 +0xfe,0x50 == lw ra, 252(sp) +0x82,0x80 == ret +0x92,0x80 == mv ra, tp +0x02,0x90 == ebreak +0x02,0x94 == jalr s0 +0x3e,0x94 == add s0, s0, a5 +0x82,0xdf == sw zero, 252(sp) +0x00,0x00 == unimp \ No newline at end of file diff --git a/suite/MC/RISCV/compress_rv64i_riscv64_riscv_c.txt.cs b/suite/MC/RISCV/compress_rv64i_riscv64_riscv_c.txt.cs new file mode 100644 index 0000000000..9bbe153795 --- /dev/null +++ b/suite/MC/RISCV/compress_rv64i_riscv64_riscv_c.txt.cs @@ -0,0 +1,8 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64"|"CS_MODE_RISCV_C", None +0xe0,0x7f == ld s0, 248(a5) +0xa0,0xe3 == sd s0, 64(a5) +0x7d,0x22 == addiw tp, tp, 31 +0x1d,0x9c == subw s0, s0, a5 +0x3d,0x9c == addw s0, s0, a5 +0xee,0x70 == ld ra, 248(sp) +0xa2,0xe0 == sd s0, 64(sp) \ No newline at end of file diff --git a/suite/MC/RISCV/compressed_zicfiss_riscv32_riscv_experimental_zicfiss__experimental_zcmop_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/compressed_zicfiss_riscv32_riscv_experimental_zicfiss__experimental_zcmop_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..37cbe27b40 --- /dev/null +++ b/suite/MC/RISCV/compressed_zicfiss_riscv32_riscv_experimental_zicfiss__experimental_zcmop_syntax_no_alias_text.txt.cs @@ -0,0 +1,3 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32"|"CS_MODE_RISCV_EXPERIMENTAL_ZICFISS", None +0x81,0x62 == c.sspopchk t0 +0x81,0x60 == c.sspush ra \ No newline at end of file diff --git a/suite/MC/RISCV/convert_riscv64_riscv_v_riscv_f.txt.cs b/suite/MC/RISCV/convert_riscv64_riscv_v_riscv_f.txt.cs new file mode 100644 index 0000000000..0c0623fbc2 --- /dev/null +++ b/suite/MC/RISCV/convert_riscv64_riscv_v_riscv_f.txt.cs @@ -0,0 +1,44 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64"|"CS_MODE_RISCV_V"|"CS_MODE_RISCV_F", None +0x57,0x14,0x40,0x48 == vfcvt.xu.f.v v8, v4, v0.t +0x57,0x14,0x40,0x4a == vfcvt.xu.f.v v8, v4 +0x57,0x94,0x40,0x48 == vfcvt.x.f.v v8, v4, v0.t +0x57,0x94,0x40,0x4a == vfcvt.x.f.v v8, v4 +0x57,0x14,0x41,0x48 == vfcvt.f.xu.v v8, v4, v0.t +0x57,0x14,0x41,0x4a == vfcvt.f.xu.v v8, v4 +0x57,0x94,0x41,0x48 == vfcvt.f.x.v v8, v4, v0.t +0x57,0x94,0x41,0x4a == vfcvt.f.x.v v8, v4 +0x57,0x14,0x43,0x48 == vfcvt.rtz.xu.f.v v8, v4, v0.t +0x57,0x14,0x43,0x4a == vfcvt.rtz.xu.f.v v8, v4 +0x57,0x94,0x43,0x48 == vfcvt.rtz.x.f.v v8, v4, v0.t +0x57,0x94,0x43,0x4a == vfcvt.rtz.x.f.v v8, v4 +0x57,0x14,0x44,0x48 == vfwcvt.xu.f.v v8, v4, v0.t +0x57,0x14,0x44,0x4a == vfwcvt.xu.f.v v8, v4 +0x57,0x94,0x44,0x48 == vfwcvt.x.f.v v8, v4, v0.t +0x57,0x94,0x44,0x4a == vfwcvt.x.f.v v8, v4 +0x57,0x14,0x45,0x48 == vfwcvt.f.xu.v v8, v4, v0.t +0x57,0x14,0x45,0x4a == vfwcvt.f.xu.v v8, v4 +0x57,0x94,0x45,0x48 == vfwcvt.f.x.v v8, v4, v0.t +0x57,0x94,0x45,0x4a == vfwcvt.f.x.v v8, v4 +0x57,0x14,0x46,0x48 == vfwcvt.f.f.v v8, v4, v0.t +0x57,0x14,0x46,0x4a == vfwcvt.f.f.v v8, v4 +0x57,0x14,0x47,0x48 == vfwcvt.rtz.xu.f.v v8, v4, v0.t +0x57,0x14,0x47,0x4a == vfwcvt.rtz.xu.f.v v8, v4 +0x57,0x94,0x47,0x48 == vfwcvt.rtz.x.f.v v8, v4, v0.t +0x57,0x94,0x47,0x4a == vfwcvt.rtz.x.f.v v8, v4 +0x57,0x14,0x48,0x48 == vfncvt.xu.f.w v8, v4, v0.t +0x57,0x12,0x48,0x48 == vfncvt.xu.f.w v4, v4, v0.t +0x57,0x14,0x48,0x4a == vfncvt.xu.f.w v8, v4 +0x57,0x94,0x48,0x48 == vfncvt.x.f.w v8, v4, v0.t +0x57,0x94,0x48,0x4a == vfncvt.x.f.w v8, v4 +0x57,0x14,0x49,0x48 == vfncvt.f.xu.w v8, v4, v0.t +0x57,0x14,0x49,0x4a == vfncvt.f.xu.w v8, v4 +0x57,0x94,0x49,0x48 == vfncvt.f.x.w v8, v4, v0.t +0x57,0x94,0x49,0x4a == vfncvt.f.x.w v8, v4 +0x57,0x14,0x4a,0x48 == vfncvt.f.f.w v8, v4, v0.t +0x57,0x14,0x4a,0x4a == vfncvt.f.f.w v8, v4 +0x57,0x94,0x4a,0x48 == vfncvt.rod.f.f.w v8, v4, v0.t +0x57,0x94,0x4a,0x4a == vfncvt.rod.f.f.w v8, v4 +0x57,0x14,0x4b,0x48 == vfncvt.rtz.xu.f.w v8, v4, v0.t +0x57,0x14,0x4b,0x4a == vfncvt.rtz.xu.f.w v8, v4 +0x57,0x94,0x4b,0x48 == vfncvt.rtz.x.f.w v8, v4, v0.t +0x57,0x94,0x4b,0x4a == vfncvt.rtz.x.f.w v8, v4 \ No newline at end of file diff --git a/suite/MC/RISCV/debug_valid_riscv32_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/debug_valid_riscv32_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..4227194224 --- /dev/null +++ b/suite/MC/RISCV/debug_valid_riscv32_syntax_no_alias_text.txt.cs @@ -0,0 +1,2 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32", None +0x73,0x00,0x20,0x7b == dret \ No newline at end of file diff --git a/suite/MC/RISCV/deprecated_csr_names_riscv32_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/deprecated_csr_names_riscv32_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..28c863b044 --- /dev/null +++ b/suite/MC/RISCV/deprecated_csr_names_riscv32_syntax_no_alias_text.txt.cs @@ -0,0 +1,4 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32", None +0x73,0x10,0x30,0x14 == csrrw zero, stval, zero +0x73,0x10,0x30,0x34 == csrrw zero, mtval, zero +0x73,0x10,0x00,0x18 == csrrw zero, satp, zero \ No newline at end of file diff --git a/suite/MC/RISCV/div_riscv64_riscv_v.txt.cs b/suite/MC/RISCV/div_riscv64_riscv_v.txt.cs new file mode 100644 index 0000000000..40a49454eb --- /dev/null +++ b/suite/MC/RISCV/div_riscv64_riscv_v.txt.cs @@ -0,0 +1,17 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64"|"CS_MODE_RISCV_V", None +0x57,0x24,0x4a,0x80 == vdivu.vv v8, v4, v20, v0.t +0x57,0x24,0x4a,0x82 == vdivu.vv v8, v4, v20 +0x57,0x64,0x45,0x80 == vdivu.vx v8, v4, a0, v0.t +0x57,0x64,0x45,0x82 == vdivu.vx v8, v4, a0 +0x57,0x24,0x4a,0x84 == vdiv.vv v8, v4, v20, v0.t +0x57,0x24,0x4a,0x86 == vdiv.vv v8, v4, v20 +0x57,0x64,0x45,0x84 == vdiv.vx v8, v4, a0, v0.t +0x57,0x64,0x45,0x86 == vdiv.vx v8, v4, a0 +0x57,0x24,0x4a,0x88 == vremu.vv v8, v4, v20, v0.t +0x57,0x24,0x4a,0x8a == vremu.vv v8, v4, v20 +0x57,0x64,0x45,0x88 == vremu.vx v8, v4, a0, v0.t +0x57,0x64,0x45,0x8a == vremu.vx v8, v4, a0 +0x57,0x24,0x4a,0x8c == vrem.vv v8, v4, v20, v0.t +0x57,0x24,0x4a,0x8e == vrem.vv v8, v4, v20 +0x57,0x64,0x45,0x8c == vrem.vx v8, v4, a0, v0.t +0x57,0x64,0x45,0x8e == vrem.vx v8, v4, a0 \ No newline at end of file diff --git a/suite/MC/RISCV/ext_riscv64_riscv_v.txt.cs b/suite/MC/RISCV/ext_riscv64_riscv_v.txt.cs new file mode 100644 index 0000000000..74f5443ff5 --- /dev/null +++ b/suite/MC/RISCV/ext_riscv64_riscv_v.txt.cs @@ -0,0 +1,13 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64"|"CS_MODE_RISCV_V", None +0x57,0x24,0x43,0x48 == vzext.vf2 v8, v4, v0.t +0x57,0x24,0x43,0x4a == vzext.vf2 v8, v4 +0x57,0xa4,0x43,0x48 == vsext.vf2 v8, v4, v0.t +0x57,0xa4,0x43,0x4a == vsext.vf2 v8, v4 +0x57,0x24,0x42,0x48 == vzext.vf4 v8, v4, v0.t +0x57,0x24,0x42,0x4a == vzext.vf4 v8, v4 +0x57,0xa4,0x42,0x48 == vsext.vf4 v8, v4, v0.t +0x57,0xa4,0x42,0x4a == vsext.vf4 v8, v4 +0x57,0x24,0x41,0x48 == vzext.vf8 v8, v4, v0.t +0x57,0x24,0x41,0x4a == vzext.vf8 v8, v4 +0x57,0xa4,0x41,0x48 == vsext.vf8 v8, v4, v0.t +0x57,0xa4,0x41,0x4a == vsext.vf8 v8, v4 \ No newline at end of file diff --git a/suite/MC/RISCV/fadd_riscv64_riscv_v_riscv_f.txt.cs b/suite/MC/RISCV/fadd_riscv64_riscv_v_riscv_f.txt.cs new file mode 100644 index 0000000000..22a6d2c785 --- /dev/null +++ b/suite/MC/RISCV/fadd_riscv64_riscv_v_riscv_f.txt.cs @@ -0,0 +1,13 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64"|"CS_MODE_RISCV_V"|"CS_MODE_RISCV_F", None +0x57,0x14,0x4a,0x00 == vfadd.vv v8, v4, v20, v0.t +0x57,0x14,0x4a,0x02 == vfadd.vv v8, v4, v20 +0x57,0x54,0x45,0x00 == vfadd.vf v8, v4, fa0, v0.t +0x57,0x54,0x45,0x02 == vfadd.vf v8, v4, fa0 +0x57,0x14,0x4a,0xc0 == vfwadd.vv v8, v4, v20, v0.t +0x57,0x14,0x4a,0xc2 == vfwadd.vv v8, v4, v20 +0x57,0x54,0x45,0xc0 == vfwadd.vf v8, v4, fa0, v0.t +0x57,0x54,0x45,0xc2 == vfwadd.vf v8, v4, fa0 +0x57,0x14,0x4a,0xd0 == vfwadd.wv v8, v4, v20, v0.t +0x57,0x14,0x4a,0xd2 == vfwadd.wv v8, v4, v20 +0x57,0x54,0x45,0xd0 == vfwadd.wf v8, v4, fa0, v0.t +0x57,0x54,0x45,0xd2 == vfwadd.wf v8, v4, fa0 \ No newline at end of file diff --git a/suite/MC/RISCV/fcompare_riscv64_riscv_v_riscv_f.txt.cs b/suite/MC/RISCV/fcompare_riscv64_riscv_v_riscv_f.txt.cs new file mode 100644 index 0000000000..d86f33e845 --- /dev/null +++ b/suite/MC/RISCV/fcompare_riscv64_riscv_v_riscv_f.txt.cs @@ -0,0 +1,22 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64"|"CS_MODE_RISCV_V"|"CS_MODE_RISCV_F", None +0x57,0x14,0x4a,0x60 == vmfeq.vv v8, v4, v20, v0.t +0x57,0x14,0x4a,0x62 == vmfeq.vv v8, v4, v20 +0x57,0x54,0x45,0x60 == vmfeq.vf v8, v4, fa0, v0.t +0x57,0x54,0x45,0x62 == vmfeq.vf v8, v4, fa0 +0x57,0x14,0x4a,0x70 == vmfne.vv v8, v4, v20, v0.t +0x57,0x14,0x4a,0x72 == vmfne.vv v8, v4, v20 +0x57,0x54,0x45,0x70 == vmfne.vf v8, v4, fa0, v0.t +0x57,0x54,0x45,0x72 == vmfne.vf v8, v4, fa0 +0x57,0x14,0x4a,0x6c == vmflt.vv v8, v4, v20, v0.t +0x57,0x14,0x4a,0x6e == vmflt.vv v8, v4, v20 +0x57,0x54,0x45,0x6c == vmflt.vf v8, v4, fa0, v0.t +0x57,0x54,0x45,0x6e == vmflt.vf v8, v4, fa0 +0x57,0x14,0x4a,0x64 == vmfle.vv v8, v4, v20, v0.t +0x57,0x14,0x4a,0x66 == vmfle.vv v8, v4, v20 +0x57,0x54,0x45,0x64 == vmfle.vf v8, v4, fa0, v0.t +0x57,0x54,0x45,0x66 == vmfle.vf v8, v4, fa0 +0x57,0x54,0x45,0x74 == vmfgt.vf v8, v4, fa0, v0.t +0x57,0x54,0x45,0x76 == vmfgt.vf v8, v4, fa0 +0x57,0x54,0x45,0x7c == vmfge.vf v8, v4, fa0, v0.t +0x57,0x54,0x45,0x7e == vmfge.vf v8, v4, fa0 +0x57,0x10,0x4a,0x60 == vmfeq.vv v0, v4, v20, v0.t \ No newline at end of file diff --git a/suite/MC/RISCV/fdiv_riscv64_riscv_v_riscv_f.txt.cs b/suite/MC/RISCV/fdiv_riscv64_riscv_v_riscv_f.txt.cs new file mode 100644 index 0000000000..bf29233fa2 --- /dev/null +++ b/suite/MC/RISCV/fdiv_riscv64_riscv_v_riscv_f.txt.cs @@ -0,0 +1,7 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64"|"CS_MODE_RISCV_V"|"CS_MODE_RISCV_F", None +0x57,0x14,0x4a,0x80 == vfdiv.vv v8, v4, v20, v0.t +0x57,0x14,0x4a,0x82 == vfdiv.vv v8, v4, v20 +0x57,0x54,0x45,0x80 == vfdiv.vf v8, v4, fa0, v0.t +0x57,0x54,0x45,0x82 == vfdiv.vf v8, v4, fa0 +0x57,0x54,0x45,0x84 == vfrdiv.vf v8, v4, fa0, v0.t +0x57,0x54,0x45,0x86 == vfrdiv.vf v8, v4, fa0 \ No newline at end of file diff --git a/suite/MC/RISCV/fixups_compressed_riscv32_riscv_c.txt.cs b/suite/MC/RISCV/fixups_compressed_riscv32_riscv_c.txt.cs new file mode 100644 index 0000000000..327f3bf05e --- /dev/null +++ b/suite/MC/RISCV/fixups_compressed_riscv32_riscv_c.txt.cs @@ -0,0 +1,2 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32"|"CS_MODE_RISCV_C", None +0x01,0x00 == nop \ No newline at end of file diff --git a/suite/MC/RISCV/fixups_riscv32_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/fixups_riscv32_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..b26cce411b --- /dev/null +++ b/suite/MC/RISCV/fixups_riscv32_syntax_no_alias_text.txt.cs @@ -0,0 +1,2 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32", None +0x13,0x00,0x00,0x00 == addi zero, zero, 0 \ No newline at end of file diff --git a/suite/MC/RISCV/fmacc_riscv64_riscv_v_riscv_f.txt.cs b/suite/MC/RISCV/fmacc_riscv64_riscv_v_riscv_f.txt.cs new file mode 100644 index 0000000000..2d2ac1e977 --- /dev/null +++ b/suite/MC/RISCV/fmacc_riscv64_riscv_v_riscv_f.txt.cs @@ -0,0 +1,49 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64"|"CS_MODE_RISCV_V"|"CS_MODE_RISCV_F", None +0x57,0x14,0x4a,0xb0 == vfmacc.vv v8, v20, v4, v0.t +0x57,0x14,0x4a,0xb2 == vfmacc.vv v8, v20, v4 +0x57,0x54,0x45,0xb0 == vfmacc.vf v8, fa0, v4, v0.t +0x57,0x54,0x45,0xb2 == vfmacc.vf v8, fa0, v4 +0x57,0x14,0x4a,0xb4 == vfnmacc.vv v8, v20, v4, v0.t +0x57,0x14,0x4a,0xb6 == vfnmacc.vv v8, v20, v4 +0x57,0x54,0x45,0xb4 == vfnmacc.vf v8, fa0, v4, v0.t +0x57,0x54,0x45,0xb6 == vfnmacc.vf v8, fa0, v4 +0x57,0x14,0x4a,0xb8 == vfmsac.vv v8, v20, v4, v0.t +0x57,0x14,0x4a,0xba == vfmsac.vv v8, v20, v4 +0x57,0x54,0x45,0xb8 == vfmsac.vf v8, fa0, v4, v0.t +0x57,0x54,0x45,0xba == vfmsac.vf v8, fa0, v4 +0x57,0x14,0x4a,0xbc == vfnmsac.vv v8, v20, v4, v0.t +0x57,0x14,0x4a,0xbe == vfnmsac.vv v8, v20, v4 +0x57,0x54,0x45,0xbc == vfnmsac.vf v8, fa0, v4, v0.t +0x57,0x54,0x45,0xbe == vfnmsac.vf v8, fa0, v4 +0x57,0x14,0x4a,0xa0 == vfmadd.vv v8, v20, v4, v0.t +0x57,0x14,0x4a,0xa2 == vfmadd.vv v8, v20, v4 +0x57,0x54,0x45,0xa0 == vfmadd.vf v8, fa0, v4, v0.t +0x57,0x54,0x45,0xa2 == vfmadd.vf v8, fa0, v4 +0x57,0x14,0x4a,0xa4 == vfnmadd.vv v8, v20, v4, v0.t +0x57,0x14,0x4a,0xa6 == vfnmadd.vv v8, v20, v4 +0x57,0x54,0x45,0xa4 == vfnmadd.vf v8, fa0, v4, v0.t +0x57,0x54,0x45,0xa6 == vfnmadd.vf v8, fa0, v4 +0x57,0x14,0x4a,0xa8 == vfmsub.vv v8, v20, v4, v0.t +0x57,0x14,0x4a,0xaa == vfmsub.vv v8, v20, v4 +0x57,0x54,0x45,0xa8 == vfmsub.vf v8, fa0, v4, v0.t +0x57,0x54,0x45,0xaa == vfmsub.vf v8, fa0, v4 +0x57,0x14,0x4a,0xac == vfnmsub.vv v8, v20, v4, v0.t +0x57,0x14,0x4a,0xae == vfnmsub.vv v8, v20, v4 +0x57,0x54,0x45,0xac == vfnmsub.vf v8, fa0, v4, v0.t +0x57,0x54,0x45,0xae == vfnmsub.vf v8, fa0, v4 +0x57,0x14,0x4a,0xf0 == vfwmacc.vv v8, v20, v4, v0.t +0x57,0x14,0x4a,0xf2 == vfwmacc.vv v8, v20, v4 +0x57,0x54,0x45,0xf0 == vfwmacc.vf v8, fa0, v4, v0.t +0x57,0x54,0x45,0xf2 == vfwmacc.vf v8, fa0, v4 +0x57,0x14,0x4a,0xf4 == vfwnmacc.vv v8, v20, v4, v0.t +0x57,0x14,0x4a,0xf6 == vfwnmacc.vv v8, v20, v4 +0x57,0x54,0x45,0xf4 == vfwnmacc.vf v8, fa0, v4, v0.t +0x57,0x54,0x45,0xf6 == vfwnmacc.vf v8, fa0, v4 +0x57,0x14,0x4a,0xf8 == vfwmsac.vv v8, v20, v4, v0.t +0x57,0x14,0x4a,0xfa == vfwmsac.vv v8, v20, v4 +0x57,0x54,0x45,0xf8 == vfwmsac.vf v8, fa0, v4, v0.t +0x57,0x54,0x45,0xfa == vfwmsac.vf v8, fa0, v4 +0x57,0x14,0x4a,0xfc == vfwnmsac.vv v8, v20, v4, v0.t +0x57,0x14,0x4a,0xfe == vfwnmsac.vv v8, v20, v4 +0x57,0x54,0x45,0xfc == vfwnmsac.vf v8, fa0, v4, v0.t +0x57,0x54,0x45,0xfe == vfwnmsac.vf v8, fa0, v4 \ No newline at end of file diff --git a/suite/MC/RISCV/fminmax_riscv64_riscv_v_riscv_f.txt.cs b/suite/MC/RISCV/fminmax_riscv64_riscv_v_riscv_f.txt.cs new file mode 100644 index 0000000000..577c23b355 --- /dev/null +++ b/suite/MC/RISCV/fminmax_riscv64_riscv_v_riscv_f.txt.cs @@ -0,0 +1,9 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64"|"CS_MODE_RISCV_V"|"CS_MODE_RISCV_F", None +0x57,0x14,0x4a,0x10 == vfmin.vv v8, v4, v20, v0.t +0x57,0x14,0x4a,0x12 == vfmin.vv v8, v4, v20 +0x57,0x54,0x45,0x10 == vfmin.vf v8, v4, fa0, v0.t +0x57,0x54,0x45,0x12 == vfmin.vf v8, v4, fa0 +0x57,0x14,0x4a,0x18 == vfmax.vv v8, v4, v20, v0.t +0x57,0x14,0x4a,0x1a == vfmax.vv v8, v4, v20 +0x57,0x54,0x45,0x18 == vfmax.vf v8, v4, fa0, v0.t +0x57,0x54,0x45,0x1a == vfmax.vf v8, v4, fa0 \ No newline at end of file diff --git a/suite/MC/RISCV/fmul_riscv64_riscv_v_riscv_f.txt.cs b/suite/MC/RISCV/fmul_riscv64_riscv_v_riscv_f.txt.cs new file mode 100644 index 0000000000..4a2144dd91 --- /dev/null +++ b/suite/MC/RISCV/fmul_riscv64_riscv_v_riscv_f.txt.cs @@ -0,0 +1,9 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64"|"CS_MODE_RISCV_V"|"CS_MODE_RISCV_F", None +0x57,0x14,0x4a,0x90 == vfmul.vv v8, v4, v20, v0.t +0x57,0x14,0x4a,0x92 == vfmul.vv v8, v4, v20 +0x57,0x54,0x45,0x90 == vfmul.vf v8, v4, fa0, v0.t +0x57,0x54,0x45,0x92 == vfmul.vf v8, v4, fa0 +0x57,0x14,0x4a,0xe0 == vfwmul.vv v8, v4, v20, v0.t +0x57,0x14,0x4a,0xe2 == vfwmul.vv v8, v4, v20 +0x57,0x54,0x45,0xe0 == vfwmul.vf v8, v4, fa0, v0.t +0x57,0x54,0x45,0xe2 == vfwmul.vf v8, v4, fa0 \ No newline at end of file diff --git a/suite/MC/RISCV/fmv_riscv64_riscv_v_riscv_f.txt.cs b/suite/MC/RISCV/fmv_riscv64_riscv_v_riscv_f.txt.cs new file mode 100644 index 0000000000..bf7ae04fa2 --- /dev/null +++ b/suite/MC/RISCV/fmv_riscv64_riscv_v_riscv_f.txt.cs @@ -0,0 +1,4 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64"|"CS_MODE_RISCV_V"|"CS_MODE_RISCV_F", None +0x57,0x54,0x05,0x5e == vfmv.v.f v8, fa0 +0x57,0x15,0x40,0x42 == vfmv.f.s fa0, v4 +0x57,0x54,0x05,0x42 == vfmv.s.f v8, fa0 \ No newline at end of file diff --git a/suite/MC/RISCV/fothers_riscv64_riscv_v_riscv_f_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/fothers_riscv64_riscv_v_riscv_f_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..e0cf2cdb7d --- /dev/null +++ b/suite/MC/RISCV/fothers_riscv64_riscv_v_riscv_f_syntax_no_alias_text.txt.cs @@ -0,0 +1,14 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64"|"CS_MODE_RISCV_V"|"CS_MODE_RISCV_F", None +0x57,0x14,0x40,0x4c == vfsqrt.v v8, v4, v0.t +0x57,0x14,0x40,0x4e == vfsqrt.v v8, v4 +0x57,0x14,0x42,0x4c == vfrsqrt7.v v8, v4, v0.t +0x57,0x14,0x42,0x4e == vfrsqrt7.v v8, v4 +0x57,0x94,0x42,0x4c == vfrec7.v v8, v4, v0.t +0x57,0x94,0x42,0x4e == vfrec7.v v8, v4 +0x57,0x14,0x48,0x4c == vfclass.v v8, v4, v0.t +0x57,0x14,0x48,0x4e == vfclass.v v8, v4 +0x57,0x54,0x45,0x5c == vfmerge.vfm v8, v4, fa0, v0 +0x57,0x54,0x45,0x38 == vfslide1up.vf v8, v4, fa0, v0.t +0x57,0x54,0x45,0x3a == vfslide1up.vf v8, v4, fa0 +0x57,0x54,0x45,0x3c == vfslide1down.vf v8, v4, fa0, v0.t +0x57,0x54,0x45,0x3e == vfslide1down.vf v8, v4, fa0 \ No newline at end of file diff --git a/suite/MC/RISCV/freduction_riscv64_riscv_v_riscv_f_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/freduction_riscv64_riscv_v_riscv_f_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..90e94f4be8 --- /dev/null +++ b/suite/MC/RISCV/freduction_riscv64_riscv_v_riscv_f_syntax_no_alias_text.txt.cs @@ -0,0 +1,14 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64"|"CS_MODE_RISCV_V"|"CS_MODE_RISCV_F", None +0x57,0x14,0x4a,0x0c == vfredosum.vs v8, v4, v20, v0.t +0x57,0x14,0x4a,0x0e == vfredosum.vs v8, v4, v20 +0x57,0x14,0x4a,0x04 == vfredusum.vs v8, v4, v20, v0.t +0x57,0x14,0x4a,0x06 == vfredusum.vs v8, v4, v20 +0x57,0x14,0x4a,0x1c == vfredmax.vs v8, v4, v20, v0.t +0x57,0x14,0x4a,0x1e == vfredmax.vs v8, v4, v20 +0x57,0x14,0x4a,0x14 == vfredmin.vs v8, v4, v20, v0.t +0x57,0x14,0x4a,0x16 == vfredmin.vs v8, v4, v20 +0x57,0x14,0x4a,0xcc == vfwredosum.vs v8, v4, v20, v0.t +0x57,0x14,0x4a,0xce == vfwredosum.vs v8, v4, v20 +0x57,0x14,0x4a,0xc4 == vfwredusum.vs v8, v4, v20, v0.t +0x57,0x14,0x4a,0xc6 == vfwredusum.vs v8, v4, v20 +0x57,0x10,0x4a,0x0c == vfredosum.vs v0, v4, v20, v0.t \ No newline at end of file diff --git a/suite/MC/RISCV/fsub_riscv64_riscv_v_riscv_f.txt.cs b/suite/MC/RISCV/fsub_riscv64_riscv_v_riscv_f.txt.cs new file mode 100644 index 0000000000..0a66100f1f --- /dev/null +++ b/suite/MC/RISCV/fsub_riscv64_riscv_v_riscv_f.txt.cs @@ -0,0 +1,15 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64"|"CS_MODE_RISCV_V"|"CS_MODE_RISCV_F", None +0x57,0x14,0x4a,0x08 == vfsub.vv v8, v4, v20, v0.t +0x57,0x14,0x4a,0x0a == vfsub.vv v8, v4, v20 +0x57,0x54,0x45,0x08 == vfsub.vf v8, v4, fa0, v0.t +0x57,0x54,0x45,0x0a == vfsub.vf v8, v4, fa0 +0x57,0x54,0x45,0x9c == vfrsub.vf v8, v4, fa0, v0.t +0x57,0x54,0x45,0x9e == vfrsub.vf v8, v4, fa0 +0x57,0x14,0x4a,0xc8 == vfwsub.vv v8, v4, v20, v0.t +0x57,0x14,0x4a,0xca == vfwsub.vv v8, v4, v20 +0x57,0x54,0x45,0xc8 == vfwsub.vf v8, v4, fa0, v0.t +0x57,0x54,0x45,0xca == vfwsub.vf v8, v4, fa0 +0x57,0x14,0x4a,0xd8 == vfwsub.wv v8, v4, v20, v0.t +0x57,0x14,0x4a,0xda == vfwsub.wv v8, v4, v20 +0x57,0x54,0x45,0xd8 == vfwsub.wf v8, v4, fa0, v0.t +0x57,0x54,0x45,0xda == vfwsub.wf v8, v4, fa0 \ No newline at end of file diff --git a/suite/MC/RISCV/hypervisor_csr_names_riscv32_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/hypervisor_csr_names_riscv32_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..1da33e1465 --- /dev/null +++ b/suite/MC/RISCV/hypervisor_csr_names_riscv32_syntax_no_alias_text.txt.cs @@ -0,0 +1,75 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32", None +0x73,0x23,0x00,0x60 == csrrs t1, hstatus, zero +0xf3,0x23,0x00,0x60 == csrrs t2, hstatus, zero +0x73,0x23,0x20,0x60 == csrrs t1, hedeleg, zero +0xf3,0x23,0x20,0x60 == csrrs t2, hedeleg, zero +0x73,0x23,0x30,0x60 == csrrs t1, hideleg, zero +0xf3,0x23,0x30,0x60 == csrrs t2, hideleg, zero +0x73,0x23,0x40,0x60 == csrrs t1, hie, zero +0xf3,0x23,0x40,0x60 == csrrs t2, hie, zero +0x73,0x23,0x60,0x60 == csrrs t1, hcounteren, zero +0xf3,0x23,0x60,0x60 == csrrs t2, hcounteren, zero +0x73,0x23,0x70,0x60 == csrrs t1, hgeie, zero +0xf3,0x23,0x70,0x60 == csrrs t2, hgeie, zero +0x73,0x23,0x30,0x64 == csrrs t1, htval, zero +0xf3,0x23,0x30,0x64 == csrrs t2, htval, zero +0x73,0x23,0x40,0x64 == csrrs t1, hip, zero +0xf3,0x23,0x40,0x64 == csrrs t2, hip, zero +0x73,0x23,0x50,0x64 == csrrs t1, hvip, zero +0xf3,0x23,0x50,0x64 == csrrs t2, hvip, zero +0x73,0x23,0xa0,0x64 == csrrs t1, htinst, zero +0xf3,0x23,0xa0,0x64 == csrrs t2, htinst, zero +0x73,0x23,0x20,0xe1 == csrrs t1, hgeip, zero +0xf3,0x23,0x20,0xe1 == csrrs t2, hgeip, zero +0x73,0x23,0xa0,0x60 == csrrs t1, henvcfg, zero +0xf3,0x23,0xa0,0x60 == csrrs t2, henvcfg, zero +0x73,0x23,0x00,0x68 == csrrs t1, hgatp, zero +0xf3,0x23,0x00,0x68 == csrrs t2, hgatp, zero +0x73,0x23,0x80,0x6a == csrrs t1, hcontext, zero +0xf3,0x23,0x80,0x6a == csrrs t2, hcontext, zero +0x73,0x23,0x50,0x60 == csrrs t1, htimedelta, zero +0xf3,0x23,0x50,0x60 == csrrs t2, htimedelta, zero +0x73,0x23,0x00,0x20 == csrrs t1, vsstatus, zero +0xf3,0x23,0x00,0x20 == csrrs t2, vsstatus, zero +0x73,0x23,0x40,0x20 == csrrs t1, vsie, zero +0xf3,0x23,0x40,0x20 == csrrs t2, vsie, zero +0x73,0x23,0x50,0x20 == csrrs t1, vstvec, zero +0xf3,0x23,0x50,0x20 == csrrs t2, vstvec, zero +0x73,0x23,0x00,0x24 == csrrs t1, vsscratch, zero +0xf3,0x23,0x00,0x24 == csrrs t2, vsscratch, zero +0x73,0x23,0x10,0x24 == csrrs t1, vsepc, zero +0xf3,0x23,0x10,0x24 == csrrs t2, vsepc, zero +0x73,0x23,0x20,0x24 == csrrs t1, vscause, zero +0xf3,0x23,0x20,0x24 == csrrs t2, vscause, zero +0x73,0x23,0x30,0x24 == csrrs t1, vstval, zero +0xf3,0x23,0x30,0x24 == csrrs t2, vstval, zero +0x73,0x23,0x40,0x24 == csrrs t1, vsip, zero +0xf3,0x23,0x40,0x24 == csrrs t2, vsip, zero +0x73,0x23,0xd0,0x24 == csrrs t1, vstimecmp, zero +0xf3,0x23,0xd0,0x24 == csrrs t2, vstimecmp, zero +0x73,0x23,0x00,0x28 == csrrs t1, vsatp, zero +0xf3,0x23,0x00,0x28 == csrrs t2, vsatp, zero +0x73,0x23,0xc0,0x60 == csrrs t1, hstateen0, zero +0xf3,0x23,0xc0,0x60 == csrrs t2, hstateen0, zero +0x73,0x23,0xd0,0x60 == csrrs t1, hstateen1, zero +0xf3,0x23,0xd0,0x60 == csrrs t2, hstateen1, zero +0x73,0x23,0xe0,0x60 == csrrs t1, hstateen2, zero +0xf3,0x23,0xe0,0x60 == csrrs t2, hstateen2, zero +0x73,0x23,0xf0,0x60 == csrrs t1, hstateen3, zero +0xf3,0x23,0xf0,0x60 == csrrs t2, hstateen3, zero +0x73,0x23,0x80,0x60 == csrrs t1, hvien, zero +0xf3,0x23,0x80,0x60 == csrrs t2, hvien, zero +0x73,0x23,0x90,0x60 == csrrs t1, hvictl, zero +0xf3,0x23,0x90,0x60 == csrrs t2, hvictl, zero +0x73,0x23,0x60,0x64 == csrrs t1, hviprio1, zero +0xf3,0x23,0x60,0x64 == csrrs t2, hviprio1, zero +0x73,0x23,0x70,0x64 == csrrs t1, hviprio2, zero +0xf3,0x23,0x70,0x64 == csrrs t2, hviprio2, zero +0x73,0x23,0x00,0x25 == csrrs t1, vsiselect, zero +0xf3,0x23,0x00,0x25 == csrrs t2, vsiselect, zero +0x73,0x23,0x10,0x25 == csrrs t1, vsireg, zero +0xf3,0x23,0x10,0x25 == csrrs t2, vsireg, zero +0x73,0x23,0xc0,0x25 == csrrs t1, vstopei, zero +0xf3,0x23,0xc0,0x25 == csrrs t2, vstopei, zero +0x73,0x23,0x00,0xeb == csrrs t1, vstopi, zero +0xf3,0x23,0x00,0xeb == csrrs t2, vstopi, zero \ No newline at end of file diff --git a/suite/MC/RISCV/load_riscv64_riscv_v_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/load_riscv64_riscv_v_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..2d63ed6013 --- /dev/null +++ b/suite/MC/RISCV/load_riscv64_riscv_v_syntax_no_alias_text.txt.cs @@ -0,0 +1,59 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64"|"CS_MODE_RISCV_V", None +0x07,0x00,0xb5,0x02 == vlm.v v0, (a0) +0x07,0x04,0xb5,0x02 == vlm.v v8, (a0) +0x07,0x04,0x05,0x00 == vle8.v v8, (a0), v0.t +0x07,0x04,0x05,0x02 == vle8.v v8, (a0) +0x07,0x54,0x05,0x00 == vle16.v v8, (a0), v0.t +0x07,0x54,0x05,0x02 == vle16.v v8, (a0) +0x07,0x64,0x05,0x00 == vle32.v v8, (a0), v0.t +0x07,0x64,0x05,0x02 == vle32.v v8, (a0) +0x07,0x74,0x05,0x00 == vle64.v v8, (a0), v0.t +0x07,0x74,0x05,0x02 == vle64.v v8, (a0) +0x07,0x04,0x05,0x01 == vle8ff.v v8, (a0), v0.t +0x07,0x04,0x05,0x03 == vle8ff.v v8, (a0) +0x07,0x54,0x05,0x01 == vle16ff.v v8, (a0), v0.t +0x07,0x54,0x05,0x03 == vle16ff.v v8, (a0) +0x07,0x64,0x05,0x01 == vle32ff.v v8, (a0), v0.t +0x07,0x64,0x05,0x03 == vle32ff.v v8, (a0) +0x07,0x74,0x05,0x01 == vle64ff.v v8, (a0), v0.t +0x07,0x74,0x05,0x03 == vle64ff.v v8, (a0) +0x07,0x04,0xb5,0x08 == vlse8.v v8, (a0), a1, v0.t +0x07,0x04,0xb5,0x0a == vlse8.v v8, (a0), a1 +0x07,0x54,0xb5,0x08 == vlse16.v v8, (a0), a1, v0.t +0x07,0x54,0xb5,0x0a == vlse16.v v8, (a0), a1 +0x07,0x64,0xb5,0x08 == vlse32.v v8, (a0), a1, v0.t +0x07,0x64,0xb5,0x0a == vlse32.v v8, (a0), a1 +0x07,0x74,0xb5,0x08 == vlse64.v v8, (a0), a1, v0.t +0x07,0x74,0xb5,0x0a == vlse64.v v8, (a0), a1 +0x07,0x04,0x45,0x04 == vluxei8.v v8, (a0), v4, v0.t +0x07,0x04,0x45,0x06 == vluxei8.v v8, (a0), v4 +0x07,0x54,0x45,0x04 == vluxei16.v v8, (a0), v4, v0.t +0x07,0x54,0x45,0x06 == vluxei16.v v8, (a0), v4 +0x07,0x64,0x45,0x04 == vluxei32.v v8, (a0), v4, v0.t +0x07,0x64,0x45,0x06 == vluxei32.v v8, (a0), v4 +0x07,0x74,0x45,0x04 == vluxei64.v v8, (a0), v4, v0.t +0x07,0x74,0x45,0x06 == vluxei64.v v8, (a0), v4 +0x07,0x04,0x45,0x0c == vloxei8.v v8, (a0), v4, v0.t +0x07,0x04,0x45,0x0e == vloxei8.v v8, (a0), v4 +0x07,0x54,0x45,0x0c == vloxei16.v v8, (a0), v4, v0.t +0x07,0x54,0x45,0x0e == vloxei16.v v8, (a0), v4 +0x07,0x64,0x45,0x0c == vloxei32.v v8, (a0), v4, v0.t +0x07,0x64,0x45,0x0e == vloxei32.v v8, (a0), v4 +0x07,0x74,0x45,0x0c == vloxei64.v v8, (a0), v4, v0.t +0x07,0x74,0x45,0x0e == vloxei64.v v8, (a0), v4 +0x07,0x04,0x85,0x02 == vl1re8.v v8, (a0) +0x07,0x54,0x85,0x02 == vl1re16.v v8, (a0) +0x07,0x64,0x85,0x02 == vl1re32.v v8, (a0) +0x07,0x74,0x85,0x02 == vl1re64.v v8, (a0) +0x07,0x04,0x85,0x22 == vl2re8.v v8, (a0) +0x07,0x54,0x85,0x22 == vl2re16.v v8, (a0) +0x07,0x64,0x85,0x22 == vl2re32.v v8, (a0) +0x07,0x74,0x85,0x22 == vl2re64.v v8, (a0) +0x07,0x04,0x85,0x62 == vl4re8.v v8, (a0) +0x07,0x54,0x85,0x62 == vl4re16.v v8, (a0) +0x07,0x64,0x85,0x62 == vl4re32.v v8, (a0) +0x07,0x74,0x85,0x62 == vl4re64.v v8, (a0) +0x07,0x04,0x85,0xe2 == vl8re8.v v8, (a0) +0x07,0x54,0x85,0xe2 == vl8re16.v v8, (a0) +0x07,0x64,0x85,0xe2 == vl8re32.v v8, (a0) +0x07,0x74,0x85,0xe2 == vl8re64.v v8, (a0) \ No newline at end of file diff --git a/suite/MC/RISCV/macc_riscv64_riscv_v.txt.cs b/suite/MC/RISCV/macc_riscv64_riscv_v.txt.cs new file mode 100644 index 0000000000..0e57ad230d --- /dev/null +++ b/suite/MC/RISCV/macc_riscv64_riscv_v.txt.cs @@ -0,0 +1,31 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64"|"CS_MODE_RISCV_V", None +0x57,0x24,0x4a,0xb4 == vmacc.vv v8, v20, v4, v0.t +0x57,0x24,0x4a,0xb6 == vmacc.vv v8, v20, v4 +0x57,0x64,0x45,0xb4 == vmacc.vx v8, a0, v4, v0.t +0x57,0x64,0x45,0xb6 == vmacc.vx v8, a0, v4 +0x57,0x24,0x4a,0xbc == vnmsac.vv v8, v20, v4, v0.t +0x57,0x24,0x4a,0xbe == vnmsac.vv v8, v20, v4 +0x57,0x64,0x45,0xbc == vnmsac.vx v8, a0, v4, v0.t +0x57,0x64,0x45,0xbe == vnmsac.vx v8, a0, v4 +0x57,0x24,0x4a,0xa4 == vmadd.vv v8, v20, v4, v0.t +0x57,0x24,0x4a,0xa6 == vmadd.vv v8, v20, v4 +0x57,0x64,0x45,0xa4 == vmadd.vx v8, a0, v4, v0.t +0x57,0x64,0x45,0xa6 == vmadd.vx v8, a0, v4 +0x57,0x24,0x4a,0xac == vnmsub.vv v8, v20, v4, v0.t +0x57,0x24,0x4a,0xae == vnmsub.vv v8, v20, v4 +0x57,0x64,0x45,0xac == vnmsub.vx v8, a0, v4, v0.t +0x57,0x64,0x45,0xae == vnmsub.vx v8, a0, v4 +0x57,0x24,0x4a,0xf0 == vwmaccu.vv v8, v20, v4, v0.t +0x57,0x24,0x4a,0xf2 == vwmaccu.vv v8, v20, v4 +0x57,0x64,0x45,0xf0 == vwmaccu.vx v8, a0, v4, v0.t +0x57,0x64,0x45,0xf2 == vwmaccu.vx v8, a0, v4 +0x57,0x24,0x4a,0xf4 == vwmacc.vv v8, v20, v4, v0.t +0x57,0x24,0x4a,0xf6 == vwmacc.vv v8, v20, v4 +0x57,0x64,0x45,0xf4 == vwmacc.vx v8, a0, v4, v0.t +0x57,0x64,0x45,0xf6 == vwmacc.vx v8, a0, v4 +0x57,0x24,0x4a,0xfc == vwmaccsu.vv v8, v20, v4, v0.t +0x57,0x24,0x4a,0xfe == vwmaccsu.vv v8, v20, v4 +0x57,0x64,0x45,0xfc == vwmaccsu.vx v8, a0, v4, v0.t +0x57,0x64,0x45,0xfe == vwmaccsu.vx v8, a0, v4 +0x57,0x64,0x45,0xf8 == vwmaccus.vx v8, a0, v4, v0.t +0x57,0x64,0x45,0xfa == vwmaccus.vx v8, a0, v4 \ No newline at end of file diff --git a/suite/MC/RISCV/machine_csr_names_riscv32_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/machine_csr_names_riscv32_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..ce3b96e795 --- /dev/null +++ b/suite/MC/RISCV/machine_csr_names_riscv32_syntax_no_alias_text.txt.cs @@ -0,0 +1,347 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32", None +0x73,0x23,0x10,0xf1 == csrrs t1, mvendorid, zero +0xf3,0x23,0x10,0xf1 == csrrs t2, mvendorid, zero +0x73,0x23,0x20,0xf1 == csrrs t1, marchid, zero +0xf3,0x23,0x20,0xf1 == csrrs t2, marchid, zero +0x73,0x23,0x30,0xf1 == csrrs t1, mimpid, zero +0xf3,0x23,0x30,0xf1 == csrrs t2, mimpid, zero +0x73,0x23,0x40,0xf1 == csrrs t1, mhartid, zero +0xf3,0x23,0x40,0xf1 == csrrs t2, mhartid, zero +0x73,0x23,0x50,0xf1 == csrrs t1, mconfigptr, zero +0xf3,0x23,0x50,0xf1 == csrrs t2, mconfigptr, zero +0x73,0x23,0x00,0x30 == csrrs t1, mstatus, zero +0xf3,0x23,0x00,0x30 == csrrs t2, mstatus, zero +0x73,0x23,0x10,0x30 == csrrs t1, misa, zero +0xf3,0x23,0x10,0x30 == csrrs t2, misa, zero +0x73,0x23,0x20,0x30 == csrrs t1, medeleg, zero +0xf3,0x23,0x20,0x30 == csrrs t2, medeleg, zero +0x73,0x23,0x30,0x30 == csrrs t1, mideleg, zero +0xf3,0x23,0x30,0x30 == csrrs t2, mideleg, zero +0x73,0x23,0x40,0x30 == csrrs t1, mie, zero +0xf3,0x23,0x40,0x30 == csrrs t2, mie, zero +0x73,0x23,0x50,0x30 == csrrs t1, mtvec, zero +0xf3,0x23,0x50,0x30 == csrrs t2, mtvec, zero +0x73,0x23,0x60,0x30 == csrrs t1, mcounteren, zero +0xf3,0x23,0x60,0x30 == csrrs t2, mcounteren, zero +0x73,0x23,0x00,0x34 == csrrs t1, mscratch, zero +0xf3,0x23,0x00,0x34 == csrrs t2, mscratch, zero +0x73,0x23,0x10,0x34 == csrrs t1, mepc, zero +0xf3,0x23,0x10,0x34 == csrrs t2, mepc, zero +0x73,0x23,0x20,0x34 == csrrs t1, mcause, zero +0xf3,0x23,0x20,0x34 == csrrs t2, mcause, zero +0x73,0x23,0x30,0x34 == csrrs t1, mtval, zero +0xf3,0x23,0x30,0x34 == csrrs t2, mtval, zero +0x73,0x23,0x40,0x34 == csrrs t1, mip, zero +0xf3,0x23,0x40,0x34 == csrrs t2, mip, zero +0x73,0x23,0xa0,0x34 == csrrs t1, mtinst, zero +0xf3,0x23,0xa0,0x34 == csrrs t2, mtinst, zero +0x73,0x23,0xb0,0x34 == csrrs t1, mtval2, zero +0xf3,0x23,0xb0,0x34 == csrrs t2, mtval2, zero +0x73,0x23,0xa0,0x30 == csrrs t1, menvcfg, zero +0xf3,0x23,0xa0,0x30 == csrrs t2, menvcfg, zero +0x73,0x23,0x70,0x74 == csrrs t1, mseccfg, zero +0xf3,0x23,0x70,0x74 == csrrs t2, mseccfg, zero +0x73,0x23,0x00,0x3a == csrrs t1, pmpcfg0, zero +0xf3,0x23,0x00,0x3a == csrrs t2, pmpcfg0, zero +0x73,0x23,0x20,0x3a == csrrs t1, pmpcfg2, zero +0xf3,0x23,0x20,0x3a == csrrs t2, pmpcfg2, zero +0x73,0x23,0x40,0x3a == csrrs t1, pmpcfg4, zero +0xf3,0x23,0x40,0x3a == csrrs t2, pmpcfg4, zero +0x73,0x23,0x60,0x3a == csrrs t1, pmpcfg6, zero +0xf3,0x23,0x60,0x3a == csrrs t2, pmpcfg6, zero +0x73,0x23,0x80,0x3a == csrrs t1, pmpcfg8, zero +0xf3,0x23,0x80,0x3a == csrrs t2, pmpcfg8, zero +0x73,0x23,0xa0,0x3a == csrrs t1, pmpcfg10, zero +0xf3,0x23,0xa0,0x3a == csrrs t2, pmpcfg10, zero +0x73,0x23,0xc0,0x3a == csrrs t1, pmpcfg12, zero +0xf3,0x23,0xc0,0x3a == csrrs t2, pmpcfg12, zero +0x73,0x23,0xe0,0x3a == csrrs t1, pmpcfg14, zero +0xf3,0x23,0xe0,0x3a == csrrs t2, pmpcfg14, zero +0x73,0x23,0x00,0x3b == csrrs t1, pmpaddr0, zero +0xf3,0x23,0x00,0x3b == csrrs t2, pmpaddr0, zero +0x73,0x23,0x10,0x3b == csrrs t1, pmpaddr1, zero +0xf3,0x23,0x10,0x3b == csrrs t2, pmpaddr1, zero +0x73,0x23,0x20,0x3b == csrrs t1, pmpaddr2, zero +0xf3,0x23,0x20,0x3b == csrrs t2, pmpaddr2, zero +0x73,0x23,0x30,0x3b == csrrs t1, pmpaddr3, zero +0xf3,0x23,0x30,0x3b == csrrs t2, pmpaddr3, zero +0x73,0x23,0x40,0x3b == csrrs t1, pmpaddr4, zero +0xf3,0x23,0x40,0x3b == csrrs t2, pmpaddr4, zero +0x73,0x23,0x50,0x3b == csrrs t1, pmpaddr5, zero +0xf3,0x23,0x50,0x3b == csrrs t2, pmpaddr5, zero +0x73,0x23,0x60,0x3b == csrrs t1, pmpaddr6, zero +0xf3,0x23,0x60,0x3b == csrrs t2, pmpaddr6, zero +0x73,0x23,0x70,0x3b == csrrs t1, pmpaddr7, zero +0xf3,0x23,0x70,0x3b == csrrs t2, pmpaddr7, zero +0x73,0x23,0x80,0x3b == csrrs t1, pmpaddr8, zero +0xf3,0x23,0x80,0x3b == csrrs t2, pmpaddr8, zero +0x73,0x23,0x90,0x3b == csrrs t1, pmpaddr9, zero +0xf3,0x23,0x90,0x3b == csrrs t2, pmpaddr9, zero +0x73,0x23,0xa0,0x3b == csrrs t1, pmpaddr10, zero +0xf3,0x23,0xa0,0x3b == csrrs t2, pmpaddr10, zero +0x73,0x23,0xb0,0x3b == csrrs t1, pmpaddr11, zero +0xf3,0x23,0xb0,0x3b == csrrs t2, pmpaddr11, zero +0x73,0x23,0xc0,0x3b == csrrs t1, pmpaddr12, zero +0xf3,0x23,0xc0,0x3b == csrrs t2, pmpaddr12, zero +0x73,0x23,0xd0,0x3b == csrrs t1, pmpaddr13, zero +0xf3,0x23,0xd0,0x3b == csrrs t2, pmpaddr13, zero +0x73,0x23,0xe0,0x3b == csrrs t1, pmpaddr14, zero +0xf3,0x23,0xe0,0x3b == csrrs t2, pmpaddr14, zero +0x73,0x23,0xf0,0x3b == csrrs t1, pmpaddr15, zero +0xf3,0x23,0xf0,0x3b == csrrs t2, pmpaddr15, zero +0x73,0x23,0x00,0x3c == csrrs t1, pmpaddr16, zero +0xf3,0x23,0x00,0x3c == csrrs t2, pmpaddr16, zero +0x73,0x23,0x10,0x3c == csrrs t1, pmpaddr17, zero +0xf3,0x23,0x10,0x3c == csrrs t2, pmpaddr17, zero +0x73,0x23,0x20,0x3c == csrrs t1, pmpaddr18, zero +0xf3,0x23,0x20,0x3c == csrrs t2, pmpaddr18, zero +0x73,0x23,0x30,0x3c == csrrs t1, pmpaddr19, zero +0xf3,0x23,0x30,0x3c == csrrs t2, pmpaddr19, zero +0x73,0x23,0x40,0x3c == csrrs t1, pmpaddr20, zero +0xf3,0x23,0x40,0x3c == csrrs t2, pmpaddr20, zero +0x73,0x23,0x50,0x3c == csrrs t1, pmpaddr21, zero +0xf3,0x23,0x50,0x3c == csrrs t2, pmpaddr21, zero +0x73,0x23,0x60,0x3c == csrrs t1, pmpaddr22, zero +0xf3,0x23,0x60,0x3c == csrrs t2, pmpaddr22, zero +0x73,0x23,0x70,0x3c == csrrs t1, pmpaddr23, zero +0xf3,0x23,0x70,0x3c == csrrs t2, pmpaddr23, zero +0x73,0x23,0x80,0x3c == csrrs t1, pmpaddr24, zero +0xf3,0x23,0x80,0x3c == csrrs t2, pmpaddr24, zero +0x73,0x23,0x90,0x3c == csrrs t1, pmpaddr25, zero +0xf3,0x23,0x90,0x3c == csrrs t2, pmpaddr25, zero +0x73,0x23,0xa0,0x3c == csrrs t1, pmpaddr26, zero +0xf3,0x23,0xa0,0x3c == csrrs t2, pmpaddr26, zero +0x73,0x23,0xb0,0x3c == csrrs t1, pmpaddr27, zero +0xf3,0x23,0xb0,0x3c == csrrs t2, pmpaddr27, zero +0x73,0x23,0xc0,0x3c == csrrs t1, pmpaddr28, zero +0xf3,0x23,0xc0,0x3c == csrrs t2, pmpaddr28, zero +0x73,0x23,0xd0,0x3c == csrrs t1, pmpaddr29, zero +0xf3,0x23,0xd0,0x3c == csrrs t2, pmpaddr29, zero +0x73,0x23,0xe0,0x3c == csrrs t1, pmpaddr30, zero +0xf3,0x23,0xe0,0x3c == csrrs t2, pmpaddr30, zero +0x73,0x23,0xf0,0x3c == csrrs t1, pmpaddr31, zero +0xf3,0x23,0xf0,0x3c == csrrs t2, pmpaddr31, zero +0x73,0x23,0x00,0x3d == csrrs t1, pmpaddr32, zero +0xf3,0x23,0x00,0x3d == csrrs t2, pmpaddr32, zero +0x73,0x23,0x10,0x3d == csrrs t1, pmpaddr33, zero +0xf3,0x23,0x10,0x3d == csrrs t2, pmpaddr33, zero +0x73,0x23,0x20,0x3d == csrrs t1, pmpaddr34, zero +0xf3,0x23,0x20,0x3d == csrrs t2, pmpaddr34, zero +0x73,0x23,0x30,0x3d == csrrs t1, pmpaddr35, zero +0xf3,0x23,0x30,0x3d == csrrs t2, pmpaddr35, zero +0x73,0x23,0x40,0x3d == csrrs t1, pmpaddr36, zero +0xf3,0x23,0x40,0x3d == csrrs t2, pmpaddr36, zero +0x73,0x23,0x50,0x3d == csrrs t1, pmpaddr37, zero +0xf3,0x23,0x50,0x3d == csrrs t2, pmpaddr37, zero +0x73,0x23,0x60,0x3d == csrrs t1, pmpaddr38, zero +0xf3,0x23,0x60,0x3d == csrrs t2, pmpaddr38, zero +0x73,0x23,0x70,0x3d == csrrs t1, pmpaddr39, zero +0xf3,0x23,0x70,0x3d == csrrs t2, pmpaddr39, zero +0x73,0x23,0x80,0x3d == csrrs t1, pmpaddr40, zero +0xf3,0x23,0x80,0x3d == csrrs t2, pmpaddr40, zero +0x73,0x23,0x90,0x3d == csrrs t1, pmpaddr41, zero +0xf3,0x23,0x90,0x3d == csrrs t2, pmpaddr41, zero +0x73,0x23,0xa0,0x3d == csrrs t1, pmpaddr42, zero +0xf3,0x23,0xa0,0x3d == csrrs t2, pmpaddr42, zero +0x73,0x23,0xb0,0x3d == csrrs t1, pmpaddr43, zero +0xf3,0x23,0xb0,0x3d == csrrs t2, pmpaddr43, zero +0x73,0x23,0xc0,0x3d == csrrs t1, pmpaddr44, zero +0xf3,0x23,0xc0,0x3d == csrrs t2, pmpaddr44, zero +0x73,0x23,0xd0,0x3d == csrrs t1, pmpaddr45, zero +0xf3,0x23,0xd0,0x3d == csrrs t2, pmpaddr45, zero +0x73,0x23,0xe0,0x3d == csrrs t1, pmpaddr46, zero +0xf3,0x23,0xe0,0x3d == csrrs t2, pmpaddr46, zero +0x73,0x23,0xf0,0x3d == csrrs t1, pmpaddr47, zero +0xf3,0x23,0xf0,0x3d == csrrs t2, pmpaddr47, zero +0x73,0x23,0x00,0x3e == csrrs t1, pmpaddr48, zero +0xf3,0x23,0x00,0x3e == csrrs t2, pmpaddr48, zero +0x73,0x23,0x10,0x3e == csrrs t1, pmpaddr49, zero +0xf3,0x23,0x10,0x3e == csrrs t2, pmpaddr49, zero +0x73,0x23,0x20,0x3e == csrrs t1, pmpaddr50, zero +0xf3,0x23,0x20,0x3e == csrrs t2, pmpaddr50, zero +0x73,0x23,0x30,0x3e == csrrs t1, pmpaddr51, zero +0xf3,0x23,0x30,0x3e == csrrs t2, pmpaddr51, zero +0x73,0x23,0x40,0x3e == csrrs t1, pmpaddr52, zero +0xf3,0x23,0x40,0x3e == csrrs t2, pmpaddr52, zero +0x73,0x23,0x50,0x3e == csrrs t1, pmpaddr53, zero +0xf3,0x23,0x50,0x3e == csrrs t2, pmpaddr53, zero +0x73,0x23,0x60,0x3e == csrrs t1, pmpaddr54, zero +0xf3,0x23,0x60,0x3e == csrrs t2, pmpaddr54, zero +0x73,0x23,0x70,0x3e == csrrs t1, pmpaddr55, zero +0xf3,0x23,0x70,0x3e == csrrs t2, pmpaddr55, zero +0x73,0x23,0x80,0x3e == csrrs t1, pmpaddr56, zero +0xf3,0x23,0x80,0x3e == csrrs t2, pmpaddr56, zero +0x73,0x23,0x90,0x3e == csrrs t1, pmpaddr57, zero +0xf3,0x23,0x90,0x3e == csrrs t2, pmpaddr57, zero +0x73,0x23,0xa0,0x3e == csrrs t1, pmpaddr58, zero +0xf3,0x23,0xa0,0x3e == csrrs t2, pmpaddr58, zero +0x73,0x23,0xb0,0x3e == csrrs t1, pmpaddr59, zero +0xf3,0x23,0xb0,0x3e == csrrs t2, pmpaddr59, zero +0x73,0x23,0xc0,0x3e == csrrs t1, pmpaddr60, zero +0xf3,0x23,0xc0,0x3e == csrrs t2, pmpaddr60, zero +0x73,0x23,0xd0,0x3e == csrrs t1, pmpaddr61, zero +0xf3,0x23,0xd0,0x3e == csrrs t2, pmpaddr61, zero +0x73,0x23,0xe0,0x3e == csrrs t1, pmpaddr62, zero +0xf3,0x23,0xe0,0x3e == csrrs t2, pmpaddr62, zero +0x73,0x23,0xf0,0x3e == csrrs t1, pmpaddr63, zero +0xf3,0x23,0xf0,0x3e == csrrs t2, pmpaddr63, zero +0x73,0x23,0x00,0xb0 == csrrs t1, mcycle, zero +0xf3,0x23,0x00,0xb0 == csrrs t2, mcycle, zero +0x73,0x23,0x20,0xb0 == csrrs t1, minstret, zero +0xf3,0x23,0x20,0xb0 == csrrs t2, minstret, zero +0x73,0x23,0x00,0x7a == csrrs t1, tselect, zero +0xf3,0x23,0x00,0x7a == csrrs t2, tselect, zero +0x73,0x23,0x10,0x7a == csrrs t1, tdata1, zero +0xf3,0x23,0x10,0x7a == csrrs t2, tdata1, zero +0x73,0x23,0x20,0x7a == csrrs t1, tdata2, zero +0xf3,0x23,0x20,0x7a == csrrs t2, tdata2, zero +0x73,0x23,0x30,0x7a == csrrs t1, tdata3, zero +0xf3,0x23,0x30,0x7a == csrrs t2, tdata3, zero +0x73,0x23,0x80,0x7a == csrrs t1, mcontext, zero +0xf3,0x23,0x80,0x7a == csrrs t2, mcontext, zero +0x73,0x23,0x00,0x7b == csrrs t1, dcsr, zero +0xf3,0x23,0x00,0x7b == csrrs t2, dcsr, zero +0x73,0x23,0x10,0x7b == csrrs t1, dpc, zero +0xf3,0x23,0x10,0x7b == csrrs t2, dpc, zero +0x73,0x23,0x20,0x7b == csrrs t1, dscratch0, zero +0xf3,0x23,0x20,0x7b == csrrs t2, dscratch0, zero +0x73,0x23,0x30,0x7b == csrrs t1, dscratch1, zero +0xf3,0x23,0x30,0x7b == csrrs t2, dscratch1, zero +0x73,0x23,0x30,0xb0 == csrrs t1, mhpmcounter3, zero +0xf3,0x23,0x30,0xb0 == csrrs t2, mhpmcounter3, zero +0x73,0x23,0x40,0xb0 == csrrs t1, mhpmcounter4, zero +0xf3,0x23,0x40,0xb0 == csrrs t2, mhpmcounter4, zero +0x73,0x23,0x50,0xb0 == csrrs t1, mhpmcounter5, zero +0xf3,0x23,0x50,0xb0 == csrrs t2, mhpmcounter5, zero +0x73,0x23,0x60,0xb0 == csrrs t1, mhpmcounter6, zero +0xf3,0x23,0x60,0xb0 == csrrs t2, mhpmcounter6, zero +0x73,0x23,0x70,0xb0 == csrrs t1, mhpmcounter7, zero +0xf3,0x23,0x70,0xb0 == csrrs t2, mhpmcounter7, zero +0x73,0x23,0x80,0xb0 == csrrs t1, mhpmcounter8, zero +0xf3,0x23,0x80,0xb0 == csrrs t2, mhpmcounter8, zero +0x73,0x23,0x90,0xb0 == csrrs t1, mhpmcounter9, zero +0xf3,0x23,0x90,0xb0 == csrrs t2, mhpmcounter9, zero +0x73,0x23,0xa0,0xb0 == csrrs t1, mhpmcounter10, zero +0xf3,0x23,0xa0,0xb0 == csrrs t2, mhpmcounter10, zero +0x73,0x23,0xb0,0xb0 == csrrs t1, mhpmcounter11, zero +0xf3,0x23,0xb0,0xb0 == csrrs t2, mhpmcounter11, zero +0x73,0x23,0xc0,0xb0 == csrrs t1, mhpmcounter12, zero +0xf3,0x23,0xc0,0xb0 == csrrs t2, mhpmcounter12, zero +0x73,0x23,0xd0,0xb0 == csrrs t1, mhpmcounter13, zero +0xf3,0x23,0xd0,0xb0 == csrrs t2, mhpmcounter13, zero +0x73,0x23,0xe0,0xb0 == csrrs t1, mhpmcounter14, zero +0xf3,0x23,0xe0,0xb0 == csrrs t2, mhpmcounter14, zero +0x73,0x23,0xf0,0xb0 == csrrs t1, mhpmcounter15, zero +0xf3,0x23,0xf0,0xb0 == csrrs t2, mhpmcounter15, zero +0x73,0x23,0x00,0xb1 == csrrs t1, mhpmcounter16, zero +0xf3,0x23,0x00,0xb1 == csrrs t2, mhpmcounter16, zero +0x73,0x23,0x10,0xb1 == csrrs t1, mhpmcounter17, zero +0xf3,0x23,0x10,0xb1 == csrrs t2, mhpmcounter17, zero +0x73,0x23,0x20,0xb1 == csrrs t1, mhpmcounter18, zero +0xf3,0x23,0x20,0xb1 == csrrs t2, mhpmcounter18, zero +0x73,0x23,0x30,0xb1 == csrrs t1, mhpmcounter19, zero +0xf3,0x23,0x30,0xb1 == csrrs t2, mhpmcounter19, zero +0x73,0x23,0x40,0xb1 == csrrs t1, mhpmcounter20, zero +0xf3,0x23,0x40,0xb1 == csrrs t2, mhpmcounter20, zero +0x73,0x23,0x50,0xb1 == csrrs t1, mhpmcounter21, zero +0xf3,0x23,0x50,0xb1 == csrrs t2, mhpmcounter21, zero +0x73,0x23,0x60,0xb1 == csrrs t1, mhpmcounter22, zero +0xf3,0x23,0x60,0xb1 == csrrs t2, mhpmcounter22, zero +0x73,0x23,0x70,0xb1 == csrrs t1, mhpmcounter23, zero +0xf3,0x23,0x70,0xb1 == csrrs t2, mhpmcounter23, zero +0x73,0x23,0x80,0xb1 == csrrs t1, mhpmcounter24, zero +0xf3,0x23,0x80,0xb1 == csrrs t2, mhpmcounter24, zero +0x73,0x23,0x90,0xb1 == csrrs t1, mhpmcounter25, zero +0xf3,0x23,0x90,0xb1 == csrrs t2, mhpmcounter25, zero +0x73,0x23,0xa0,0xb1 == csrrs t1, mhpmcounter26, zero +0xf3,0x23,0xa0,0xb1 == csrrs t2, mhpmcounter26, zero +0x73,0x23,0xb0,0xb1 == csrrs t1, mhpmcounter27, zero +0xf3,0x23,0xb0,0xb1 == csrrs t2, mhpmcounter27, zero +0x73,0x23,0xc0,0xb1 == csrrs t1, mhpmcounter28, zero +0xf3,0x23,0xc0,0xb1 == csrrs t2, mhpmcounter28, zero +0x73,0x23,0xd0,0xb1 == csrrs t1, mhpmcounter29, zero +0xf3,0x23,0xd0,0xb1 == csrrs t2, mhpmcounter29, zero +0x73,0x23,0xe0,0xb1 == csrrs t1, mhpmcounter30, zero +0xf3,0x23,0xe0,0xb1 == csrrs t2, mhpmcounter30, zero +0x73,0x23,0xf0,0xb1 == csrrs t1, mhpmcounter31, zero +0xf3,0x23,0xf0,0xb1 == csrrs t2, mhpmcounter31, zero +0x73,0x23,0x00,0x32 == csrrs t1, mcountinhibit, zero +0xf3,0x23,0x00,0x32 == csrrs t2, mcountinhibit, zero +0x73,0x23,0x30,0x32 == csrrs t1, mhpmevent3, zero +0xf3,0x23,0x30,0x32 == csrrs t2, mhpmevent3, zero +0x73,0x23,0x40,0x32 == csrrs t1, mhpmevent4, zero +0xf3,0x23,0x40,0x32 == csrrs t2, mhpmevent4, zero +0x73,0x23,0x50,0x32 == csrrs t1, mhpmevent5, zero +0xf3,0x23,0x50,0x32 == csrrs t2, mhpmevent5, zero +0x73,0x23,0x60,0x32 == csrrs t1, mhpmevent6, zero +0xf3,0x23,0x60,0x32 == csrrs t2, mhpmevent6, zero +0x73,0x23,0x70,0x32 == csrrs t1, mhpmevent7, zero +0xf3,0x23,0x70,0x32 == csrrs t2, mhpmevent7, zero +0x73,0x23,0x80,0x32 == csrrs t1, mhpmevent8, zero +0xf3,0x23,0x80,0x32 == csrrs t2, mhpmevent8, zero +0x73,0x23,0x90,0x32 == csrrs t1, mhpmevent9, zero +0xf3,0x23,0x90,0x32 == csrrs t2, mhpmevent9, zero +0x73,0x23,0xa0,0x32 == csrrs t1, mhpmevent10, zero +0xf3,0x23,0xa0,0x32 == csrrs t2, mhpmevent10, zero +0x73,0x23,0xb0,0x32 == csrrs t1, mhpmevent11, zero +0xf3,0x23,0xb0,0x32 == csrrs t2, mhpmevent11, zero +0x73,0x23,0xc0,0x32 == csrrs t1, mhpmevent12, zero +0xf3,0x23,0xc0,0x32 == csrrs t2, mhpmevent12, zero +0x73,0x23,0xd0,0x32 == csrrs t1, mhpmevent13, zero +0xf3,0x23,0xd0,0x32 == csrrs t2, mhpmevent13, zero +0x73,0x23,0xe0,0x32 == csrrs t1, mhpmevent14, zero +0xf3,0x23,0xe0,0x32 == csrrs t2, mhpmevent14, zero +0x73,0x23,0xf0,0x32 == csrrs t1, mhpmevent15, zero +0xf3,0x23,0xf0,0x32 == csrrs t2, mhpmevent15, zero +0x73,0x23,0x00,0x33 == csrrs t1, mhpmevent16, zero +0xf3,0x23,0x00,0x33 == csrrs t2, mhpmevent16, zero +0x73,0x23,0x10,0x33 == csrrs t1, mhpmevent17, zero +0xf3,0x23,0x10,0x33 == csrrs t2, mhpmevent17, zero +0x73,0x23,0x20,0x33 == csrrs t1, mhpmevent18, zero +0xf3,0x23,0x20,0x33 == csrrs t2, mhpmevent18, zero +0x73,0x23,0x30,0x33 == csrrs t1, mhpmevent19, zero +0xf3,0x23,0x30,0x33 == csrrs t2, mhpmevent19, zero +0x73,0x23,0x40,0x33 == csrrs t1, mhpmevent20, zero +0xf3,0x23,0x40,0x33 == csrrs t2, mhpmevent20, zero +0x73,0x23,0x50,0x33 == csrrs t1, mhpmevent21, zero +0xf3,0x23,0x50,0x33 == csrrs t2, mhpmevent21, zero +0x73,0x23,0x60,0x33 == csrrs t1, mhpmevent22, zero +0xf3,0x23,0x60,0x33 == csrrs t2, mhpmevent22, zero +0x73,0x23,0x70,0x33 == csrrs t1, mhpmevent23, zero +0xf3,0x23,0x70,0x33 == csrrs t2, mhpmevent23, zero +0x73,0x23,0x80,0x33 == csrrs t1, mhpmevent24, zero +0xf3,0x23,0x80,0x33 == csrrs t2, mhpmevent24, zero +0x73,0x23,0x90,0x33 == csrrs t1, mhpmevent25, zero +0xf3,0x23,0x90,0x33 == csrrs t2, mhpmevent25, zero +0x73,0x23,0xa0,0x33 == csrrs t1, mhpmevent26, zero +0xf3,0x23,0xa0,0x33 == csrrs t2, mhpmevent26, zero +0x73,0x23,0xb0,0x33 == csrrs t1, mhpmevent27, zero +0xf3,0x23,0xb0,0x33 == csrrs t2, mhpmevent27, zero +0x73,0x23,0xc0,0x33 == csrrs t1, mhpmevent28, zero +0xf3,0x23,0xc0,0x33 == csrrs t2, mhpmevent28, zero +0x73,0x23,0xd0,0x33 == csrrs t1, mhpmevent29, zero +0xf3,0x23,0xd0,0x33 == csrrs t2, mhpmevent29, zero +0x73,0x23,0xe0,0x33 == csrrs t1, mhpmevent30, zero +0xf3,0x23,0xe0,0x33 == csrrs t2, mhpmevent30, zero +0x73,0x23,0xf0,0x33 == csrrs t1, mhpmevent31, zero +0xf3,0x23,0xf0,0x33 == csrrs t2, mhpmevent31, zero +0x73,0x23,0xc0,0x30 == csrrs t1, mstateen0, zero +0xf3,0x23,0xc0,0x30 == csrrs t2, mstateen0, zero +0x73,0x23,0xd0,0x30 == csrrs t1, mstateen1, zero +0xf3,0x23,0xd0,0x30 == csrrs t2, mstateen1, zero +0x73,0x23,0xe0,0x30 == csrrs t1, mstateen2, zero +0xf3,0x23,0xe0,0x30 == csrrs t2, mstateen2, zero +0x73,0x23,0xf0,0x30 == csrrs t1, mstateen3, zero +0xf3,0x23,0xf0,0x30 == csrrs t2, mstateen3, zero +0x73,0x23,0x00,0x35 == csrrs t1, miselect, zero +0xf3,0x23,0x00,0x35 == csrrs t2, miselect, zero +0x73,0x23,0x10,0x35 == csrrs t1, mireg, zero +0xf3,0x23,0x10,0x35 == csrrs t2, mireg, zero +0x73,0x23,0xc0,0x35 == csrrs t1, mtopei, zero +0xf3,0x23,0xc0,0x35 == csrrs t2, mtopei, zero +0x73,0x23,0x00,0xfb == csrrs t1, mtopi, zero +0xf3,0x23,0x00,0xfb == csrrs t2, mtopi, zero +0x73,0x23,0x80,0x30 == csrrs t1, mvien, zero +0xf3,0x23,0x80,0x30 == csrrs t2, mvien, zero +0x73,0x23,0x90,0x30 == csrrs t1, mvip, zero +0xf3,0x23,0x90,0x30 == csrrs t2, mvip, zero \ No newline at end of file diff --git a/suite/MC/RISCV/mask_riscv64_riscv_v.txt.cs b/suite/MC/RISCV/mask_riscv64_riscv_v.txt.cs new file mode 100644 index 0000000000..42d2700668 --- /dev/null +++ b/suite/MC/RISCV/mask_riscv64_riscv_v.txt.cs @@ -0,0 +1,27 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64"|"CS_MODE_RISCV_V", None +0x57,0x24,0x4a,0x66 == vmand.mm v8, v4, v20 +0x57,0x24,0x4a,0x76 == vmnand.mm v8, v4, v20 +0x57,0x24,0x4a,0x62 == vmandn.mm v8, v4, v20 +0x57,0x24,0x4a,0x6e == vmxor.mm v8, v4, v20 +0x57,0x24,0x4a,0x6a == vmor.mm v8, v4, v20 +0x57,0x24,0x4a,0x7a == vmnor.mm v8, v4, v20 +0x57,0x24,0x4a,0x72 == vmorn.mm v8, v4, v20 +0x57,0x24,0x4a,0x7e == vmxnor.mm v8, v4, v20 +0x57,0x26,0x48,0x40 == vcpop.m a2, v4, v0.t +0x57,0x26,0x48,0x42 == vcpop.m a2, v4 +0x57,0xa6,0x48,0x40 == vfirst.m a2, v4, v0.t +0x57,0xa6,0x48,0x42 == vfirst.m a2, v4 +0x57,0xa4,0x40,0x50 == vmsbf.m v8, v4, v0.t +0x57,0xa4,0x40,0x52 == vmsbf.m v8, v4 +0x57,0xa4,0x41,0x50 == vmsif.m v8, v4, v0.t +0x57,0xa4,0x41,0x52 == vmsif.m v8, v4 +0x57,0x24,0x41,0x50 == vmsof.m v8, v4, v0.t +0x57,0x24,0x41,0x52 == vmsof.m v8, v4 +0x57,0x24,0x48,0x50 == viota.m v8, v4, v0.t +0x57,0x24,0x48,0x52 == viota.m v8, v4 +0x57,0xa4,0x08,0x50 == vid.v v8, v0.t +0x57,0xa4,0x08,0x52 == vid.v v8 +0x57,0x24,0x42,0x66 == vmmv.m v8, v4 +0x57,0x24,0x84,0x6e == vmclr.m v8 +0x57,0x24,0x84,0x7e == vmset.m v8 +0x57,0x24,0x42,0x76 == vmnot.m v8, v4 \ No newline at end of file diff --git a/suite/MC/RISCV/minmax_riscv64_riscv_v.txt.cs b/suite/MC/RISCV/minmax_riscv64_riscv_v.txt.cs new file mode 100644 index 0000000000..48504c7685 --- /dev/null +++ b/suite/MC/RISCV/minmax_riscv64_riscv_v.txt.cs @@ -0,0 +1,17 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64"|"CS_MODE_RISCV_V", None +0x57,0x04,0x4a,0x10 == vminu.vv v8, v4, v20, v0.t +0x57,0x04,0x4a,0x12 == vminu.vv v8, v4, v20 +0x57,0x44,0x45,0x10 == vminu.vx v8, v4, a0, v0.t +0x57,0x44,0x45,0x12 == vminu.vx v8, v4, a0 +0x57,0x04,0x4a,0x14 == vmin.vv v8, v4, v20, v0.t +0x57,0x04,0x4a,0x16 == vmin.vv v8, v4, v20 +0x57,0x44,0x45,0x14 == vmin.vx v8, v4, a0, v0.t +0x57,0x44,0x45,0x16 == vmin.vx v8, v4, a0 +0x57,0x04,0x4a,0x18 == vmaxu.vv v8, v4, v20, v0.t +0x57,0x04,0x4a,0x1a == vmaxu.vv v8, v4, v20 +0x57,0x44,0x45,0x18 == vmaxu.vx v8, v4, a0, v0.t +0x57,0x44,0x45,0x1a == vmaxu.vx v8, v4, a0 +0x57,0x04,0x4a,0x1c == vmax.vv v8, v4, v20, v0.t +0x57,0x04,0x4a,0x1e == vmax.vv v8, v4, v20 +0x57,0x44,0x45,0x1c == vmax.vx v8, v4, a0, v0.t +0x57,0x44,0x45,0x1e == vmax.vx v8, v4, a0 \ No newline at end of file diff --git a/suite/MC/RISCV/mul_riscv64_riscv_v.txt.cs b/suite/MC/RISCV/mul_riscv64_riscv_v.txt.cs new file mode 100644 index 0000000000..30e44c4845 --- /dev/null +++ b/suite/MC/RISCV/mul_riscv64_riscv_v.txt.cs @@ -0,0 +1,33 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64"|"CS_MODE_RISCV_V", None +0x57,0x24,0x4a,0x94 == vmul.vv v8, v4, v20, v0.t +0x57,0x24,0x4a,0x96 == vmul.vv v8, v4, v20 +0x57,0x64,0x45,0x94 == vmul.vx v8, v4, a0, v0.t +0x57,0x64,0x45,0x96 == vmul.vx v8, v4, a0 +0x57,0x24,0x4a,0x9c == vmulh.vv v8, v4, v20, v0.t +0x57,0x24,0x4a,0x9e == vmulh.vv v8, v4, v20 +0x57,0x64,0x45,0x9c == vmulh.vx v8, v4, a0, v0.t +0x57,0x64,0x45,0x9e == vmulh.vx v8, v4, a0 +0x57,0x24,0x4a,0x90 == vmulhu.vv v8, v4, v20, v0.t +0x57,0x24,0x4a,0x92 == vmulhu.vv v8, v4, v20 +0x57,0x64,0x45,0x90 == vmulhu.vx v8, v4, a0, v0.t +0x57,0x64,0x45,0x92 == vmulhu.vx v8, v4, a0 +0x57,0x24,0x4a,0x98 == vmulhsu.vv v8, v4, v20, v0.t +0x57,0x24,0x4a,0x9a == vmulhsu.vv v8, v4, v20 +0x57,0x64,0x45,0x98 == vmulhsu.vx v8, v4, a0, v0.t +0x57,0x64,0x45,0x9a == vmulhsu.vx v8, v4, a0 +0x57,0x24,0x4a,0xec == vwmul.vv v8, v4, v20, v0.t +0x57,0x24,0x4a,0xee == vwmul.vv v8, v4, v20 +0x57,0x64,0x45,0xec == vwmul.vx v8, v4, a0, v0.t +0x57,0x64,0x45,0xee == vwmul.vx v8, v4, a0 +0x57,0x24,0x4a,0xe0 == vwmulu.vv v8, v4, v20, v0.t +0x57,0x24,0x4a,0xe2 == vwmulu.vv v8, v4, v20 +0x57,0x64,0x45,0xe0 == vwmulu.vx v8, v4, a0, v0.t +0x57,0x64,0x45,0xe2 == vwmulu.vx v8, v4, a0 +0x57,0x24,0x4a,0xe8 == vwmulsu.vv v8, v4, v20, v0.t +0x57,0x24,0x4a,0xea == vwmulsu.vv v8, v4, v20 +0x57,0x64,0x45,0xe8 == vwmulsu.vx v8, v4, a0, v0.t +0x57,0x64,0x45,0xea == vwmulsu.vx v8, v4, a0 +0x57,0x04,0x4a,0x9c == vsmul.vv v8, v4, v20, v0.t +0x57,0x04,0x4a,0x9e == vsmul.vv v8, v4, v20 +0x57,0x44,0x45,0x9c == vsmul.vx v8, v4, a0, v0.t +0x57,0x44,0x45,0x9e == vsmul.vx v8, v4, a0 \ No newline at end of file diff --git a/suite/MC/RISCV/mv_riscv64_riscv_v.txt.cs b/suite/MC/RISCV/mv_riscv64_riscv_v.txt.cs new file mode 100644 index 0000000000..28d756f0b4 --- /dev/null +++ b/suite/MC/RISCV/mv_riscv64_riscv_v.txt.cs @@ -0,0 +1,10 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64"|"CS_MODE_RISCV_V", None +0x57,0x04,0x0a,0x5e == vmv.v.v v8, v20 +0x57,0x44,0x05,0x5e == vmv.v.x v8, a0 +0x57,0xb4,0x07,0x5e == vmv.v.i v8, 15 +0x57,0x26,0x40,0x42 == vmv.x.s a2, v4 +0x57,0x64,0x05,0x42 == vmv.s.x v8, a0 +0x57,0x34,0x40,0x9e == vmv1r.v v8, v4 +0x57,0xb4,0x40,0x9e == vmv2r.v v8, v4 +0x57,0xb4,0x41,0x9e == vmv4r.v v8, v4 +0x57,0xb4,0x83,0x9f == vmv8r.v v8, v24 \ No newline at end of file diff --git a/suite/MC/RISCV/option_arch_riscv32.txt.cs b/suite/MC/RISCV/option_arch_riscv32.txt.cs new file mode 100644 index 0000000000..5fe8a6ba9e --- /dev/null +++ b/suite/MC/RISCV/option_arch_riscv32.txt.cs @@ -0,0 +1,10 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32", None +0x13,0x85,0x05,0x00 == mv a0, a1 +0x13,0x04,0xc1,0x3f == addi s0, sp, 1020 +0x2e,0x85 == mv a0, a1 +0xe0,0x1f == addi s0, sp, 1020 +0x07,0x20,0xc5,0x00 == flw ft0, 12(a0) +0x33,0x87,0x80,0x02 == mul a4, ra, s0 +0xaf,0x22,0x03,0x10 == lr.w t0, (t1) +0xb3,0x22,0x73,0x20 == sh1add t0, t1, t2 +0x08,0x61 == flw fa0, 0(a0) \ No newline at end of file diff --git a/suite/MC/RISCV/option_rvc_riscv32.txt.cs b/suite/MC/RISCV/option_rvc_riscv32.txt.cs new file mode 100644 index 0000000000..d3f00d6188 --- /dev/null +++ b/suite/MC/RISCV/option_rvc_riscv32.txt.cs @@ -0,0 +1,5 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32", None +0x13,0x85,0x05,0x00 == mv a0, a1 +0x13,0x04,0xc1,0x3f == addi s0, sp, 1020 +0x2e,0x85 == mv a0, a1 +0xe0,0x1f == addi s0, sp, 1020 \ No newline at end of file diff --git a/suite/MC/RISCV/or_riscv64_riscv_v.txt.cs b/suite/MC/RISCV/or_riscv64_riscv_v.txt.cs new file mode 100644 index 0000000000..21edf04777 --- /dev/null +++ b/suite/MC/RISCV/or_riscv64_riscv_v.txt.cs @@ -0,0 +1,7 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64"|"CS_MODE_RISCV_V", None +0x57,0x04,0x4a,0x28 == vor.vv v8, v4, v20, v0.t +0x57,0x04,0x4a,0x2a == vor.vv v8, v4, v20 +0x57,0x44,0x45,0x28 == vor.vx v8, v4, a0, v0.t +0x57,0x44,0x45,0x2a == vor.vx v8, v4, a0 +0x57,0xb4,0x47,0x28 == vor.vi v8, v4, 15, v0.t +0x57,0xb4,0x47,0x2a == vor.vi v8, v4, 15 \ No newline at end of file diff --git a/suite/MC/RISCV/others_riscv64_riscv_v_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/others_riscv64_riscv_v_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..5632e86f60 --- /dev/null +++ b/suite/MC/RISCV/others_riscv64_riscv_v_syntax_no_alias_text.txt.cs @@ -0,0 +1,25 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64"|"CS_MODE_RISCV_V", None +0x57,0x04,0x4a,0x5c == vmerge.vvm v8, v4, v20, v0 +0x57,0x44,0x45,0x5c == vmerge.vxm v8, v4, a0, v0 +0x57,0xb4,0x47,0x5c == vmerge.vim v8, v4, 15, v0 +0x57,0x44,0x45,0x38 == vslideup.vx v8, v4, a0, v0.t +0x57,0x44,0x45,0x3a == vslideup.vx v8, v4, a0 +0x57,0xb4,0x4f,0x38 == vslideup.vi v8, v4, 31, v0.t +0x57,0xb4,0x4f,0x3a == vslideup.vi v8, v4, 31 +0x57,0x44,0x45,0x3c == vslidedown.vx v8, v4, a0, v0.t +0x57,0x44,0x45,0x3e == vslidedown.vx v8, v4, a0 +0x57,0xb4,0x4f,0x3c == vslidedown.vi v8, v4, 31, v0.t +0x57,0xb4,0x4f,0x3e == vslidedown.vi v8, v4, 31 +0x57,0x64,0x45,0x38 == vslide1up.vx v8, v4, a0, v0.t +0x57,0x64,0x45,0x3a == vslide1up.vx v8, v4, a0 +0x57,0x64,0x45,0x3c == vslide1down.vx v8, v4, a0, v0.t +0x57,0x64,0x45,0x3e == vslide1down.vx v8, v4, a0 +0x57,0x04,0x4a,0x30 == vrgather.vv v8, v4, v20, v0.t +0x57,0x04,0x4a,0x32 == vrgather.vv v8, v4, v20 +0x57,0x44,0x45,0x30 == vrgather.vx v8, v4, a0, v0.t +0x57,0x44,0x45,0x32 == vrgather.vx v8, v4, a0 +0x57,0xb4,0x4f,0x30 == vrgather.vi v8, v4, 31, v0.t +0x57,0xb4,0x4f,0x32 == vrgather.vi v8, v4, 31 +0x57,0x04,0x4a,0x38 == vrgatherei16.vv v8, v4, v20, v0.t +0x57,0x04,0x4a,0x3a == vrgatherei16.vv v8, v4, v20 +0x57,0x24,0x4a,0x5e == vcompress.vm v8, v4, v20 \ No newline at end of file diff --git a/suite/MC/RISCV/print_imm_hex_riscv32_riscv_v_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/print_imm_hex_riscv32_riscv_v_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..191deb2cdd --- /dev/null +++ b/suite/MC/RISCV/print_imm_hex_riscv32_riscv_v_syntax_no_alias_text.txt.cs @@ -0,0 +1,5 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32"|"CS_MODE_RISCV_V", None +0x63,0x83,0x94,0x06 == beq s1, s1, 102 +0x03,0x25,0x16,0x06 == lw a0, 97(a2) +0xf3,0xd2,0xff,0xff == csrrwi t0, 4095, 31 +0x57,0x76,0xf5,0x0f == vsetvli a2, a0, 255 \ No newline at end of file diff --git a/suite/MC/RISCV/priv_valid_riscv32_svinval_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/priv_valid_riscv32_svinval_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..d2374630af --- /dev/null +++ b/suite/MC/RISCV/priv_valid_riscv32_svinval_syntax_no_alias_text.txt.cs @@ -0,0 +1,10 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32", None +0x73,0x00,0x20,0x10 == sret +0x73,0x00,0x20,0x30 == mret +0x73,0x00,0x50,0x10 == wfi +0x73,0x00,0x00,0x12 == sfence.vma zero, zero +0x73,0x00,0xb5,0x12 == sfence.vma a0, a1 +0x73,0x00,0x00,0x16 == sinval.vma zero, zero +0x73,0x00,0xb5,0x16 == sinval.vma a0, a1 +0x73,0x00,0x00,0x18 == sfence.w.inval +0x73,0x00,0x10,0x18 == sfence.inval.ir \ No newline at end of file diff --git a/suite/MC/RISCV/reduction_riscv64_riscv_v.txt.cs b/suite/MC/RISCV/reduction_riscv64_riscv_v.txt.cs new file mode 100644 index 0000000000..544e5110d8 --- /dev/null +++ b/suite/MC/RISCV/reduction_riscv64_riscv_v.txt.cs @@ -0,0 +1,22 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64"|"CS_MODE_RISCV_V", None +0x57,0x24,0x4a,0x00 == vredsum.vs v8, v4, v20, v0.t +0x57,0x24,0x4a,0x02 == vredsum.vs v8, v4, v20 +0x57,0x24,0x4a,0x18 == vredmaxu.vs v8, v4, v20, v0.t +0x57,0x24,0x4a,0x1a == vredmaxu.vs v8, v4, v20 +0x57,0x24,0x4a,0x1c == vredmax.vs v8, v4, v20, v0.t +0x57,0x24,0x4a,0x1e == vredmax.vs v8, v4, v20 +0x57,0x24,0x4a,0x10 == vredminu.vs v8, v4, v20, v0.t +0x57,0x24,0x4a,0x12 == vredminu.vs v8, v4, v20 +0x57,0x24,0x4a,0x14 == vredmin.vs v8, v4, v20, v0.t +0x57,0x24,0x4a,0x16 == vredmin.vs v8, v4, v20 +0x57,0x24,0x4a,0x04 == vredand.vs v8, v4, v20, v0.t +0x57,0x24,0x4a,0x06 == vredand.vs v8, v4, v20 +0x57,0x24,0x4a,0x08 == vredor.vs v8, v4, v20, v0.t +0x57,0x24,0x4a,0x0a == vredor.vs v8, v4, v20 +0x57,0x24,0x4a,0x0c == vredxor.vs v8, v4, v20, v0.t +0x57,0x24,0x4a,0x0e == vredxor.vs v8, v4, v20 +0x57,0x04,0x4a,0xc0 == vwredsumu.vs v8, v4, v20, v0.t +0x57,0x04,0x4a,0xc2 == vwredsumu.vs v8, v4, v20 +0x57,0x04,0x4a,0xc4 == vwredsum.vs v8, v4, v20, v0.t +0x57,0x04,0x4a,0xc6 == vwredsum.vs v8, v4, v20 +0x57,0x20,0x4a,0x00 == vredsum.vs v0, v4, v20, v0.t \ No newline at end of file diff --git a/suite/MC/RISCV/rv32_hypervisor_csr_names_riscv32_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rv32_hypervisor_csr_names_riscv32_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..0dfe7f18d4 --- /dev/null +++ b/suite/MC/RISCV/rv32_hypervisor_csr_names_riscv32_syntax_no_alias_text.txt.cs @@ -0,0 +1,29 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32", None +0x73,0x23,0xa0,0x61 == csrrs t1, henvcfgh, zero +0xf3,0x23,0xa0,0x61 == csrrs t2, henvcfgh, zero +0x73,0x23,0x50,0x61 == csrrs t1, htimedeltah, zero +0xf3,0x23,0x50,0x61 == csrrs t2, htimedeltah, zero +0x73,0x23,0xd0,0x25 == csrrs t1, vstimecmph, zero +0xf3,0x23,0xd0,0x25 == csrrs t2, vstimecmph, zero +0x73,0x23,0xc0,0x61 == csrrs t1, hstateen0h, zero +0xf3,0x23,0xc0,0x61 == csrrs t2, hstateen0h, zero +0x73,0x23,0xd0,0x61 == csrrs t1, hstateen1h, zero +0xf3,0x23,0xd0,0x61 == csrrs t2, hstateen1h, zero +0x73,0x23,0xe0,0x61 == csrrs t1, hstateen2h, zero +0xf3,0x23,0xe0,0x61 == csrrs t2, hstateen2h, zero +0x73,0x23,0xf0,0x61 == csrrs t1, hstateen3h, zero +0xf3,0x23,0xf0,0x61 == csrrs t2, hstateen3h, zero +0x73,0x23,0x30,0x61 == csrrs t1, hidelegh, zero +0xf3,0x23,0x30,0x61 == csrrs t2, hidelegh, zero +0x73,0x23,0x80,0x61 == csrrs t1, hvienh, zero +0xf3,0x23,0x80,0x61 == csrrs t2, hvienh, zero +0x73,0x23,0x50,0x65 == csrrs t1, hviph, zero +0xf3,0x23,0x50,0x65 == csrrs t2, hviph, zero +0x73,0x23,0x60,0x65 == csrrs t1, hviprio1h, zero +0xf3,0x23,0x60,0x65 == csrrs t2, hviprio1h, zero +0x73,0x23,0x70,0x65 == csrrs t1, hviprio2h, zero +0xf3,0x23,0x70,0x65 == csrrs t2, hviprio2h, zero +0x73,0x23,0x40,0x21 == csrrs t1, vsieh, zero +0xf3,0x23,0x40,0x21 == csrrs t2, vsieh, zero +0x73,0x23,0x40,0x25 == csrrs t1, vsiph, zero +0xf3,0x23,0x40,0x25 == csrrs t2, vsiph, zero \ No newline at end of file diff --git a/suite/MC/RISCV/rv32_immediate_riscv32_riscv_v.txt.cs b/suite/MC/RISCV/rv32_immediate_riscv32_riscv_v.txt.cs new file mode 100644 index 0000000000..3bd8c35b0e --- /dev/null +++ b/suite/MC/RISCV/rv32_immediate_riscv32_riscv_v.txt.cs @@ -0,0 +1,3 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32"|"CS_MODE_RISCV_V", None +0x57,0x34,0x48,0x02 == vadd.vi v8, v4, -16 +0x57,0x34,0x48,0x72 == vmsleu.vi v8, v4, -16 \ No newline at end of file diff --git a/suite/MC/RISCV/rv32_machine_csr_names_riscv32_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rv32_machine_csr_names_riscv32_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..ae290be102 --- /dev/null +++ b/suite/MC/RISCV/rv32_machine_csr_names_riscv32_syntax_no_alias_text.txt.cs @@ -0,0 +1,161 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32", None +0x73,0x23,0x00,0x31 == csrrs t1, mstatush, zero +0xf3,0x23,0x00,0x31 == csrrs t2, mstatush, zero +0x73,0x23,0xa0,0x31 == csrrs t1, menvcfgh, zero +0xf3,0x23,0xa0,0x31 == csrrs t2, menvcfgh, zero +0x73,0x23,0x70,0x75 == csrrs t1, mseccfgh, zero +0xf3,0x23,0x70,0x75 == csrrs t2, mseccfgh, zero +0x73,0x23,0x10,0x3a == csrrs t1, pmpcfg1, zero +0xf3,0x23,0x10,0x3a == csrrs t2, pmpcfg1, zero +0x73,0x23,0x30,0x3a == csrrs t1, pmpcfg3, zero +0xf3,0x23,0x30,0x3a == csrrs t2, pmpcfg3, zero +0x73,0x23,0x50,0x3a == csrrs t1, pmpcfg5, zero +0xf3,0x23,0x50,0x3a == csrrs t2, pmpcfg5, zero +0x73,0x23,0x70,0x3a == csrrs t1, pmpcfg7, zero +0xf3,0x23,0x70,0x3a == csrrs t2, pmpcfg7, zero +0x73,0x23,0x90,0x3a == csrrs t1, pmpcfg9, zero +0xf3,0x23,0x90,0x3a == csrrs t2, pmpcfg9, zero +0x73,0x23,0xb0,0x3a == csrrs t1, pmpcfg11, zero +0xf3,0x23,0xb0,0x3a == csrrs t2, pmpcfg11, zero +0x73,0x23,0xd0,0x3a == csrrs t1, pmpcfg13, zero +0xf3,0x23,0xd0,0x3a == csrrs t2, pmpcfg13, zero +0x73,0x23,0xf0,0x3a == csrrs t1, pmpcfg15, zero +0xf3,0x23,0xf0,0x3a == csrrs t2, pmpcfg15, zero +0x73,0x23,0x00,0xb8 == csrrs t1, mcycleh, zero +0xf3,0x23,0x00,0xb8 == csrrs t2, mcycleh, zero +0x73,0x23,0x20,0xb8 == csrrs t1, minstreth, zero +0xf3,0x23,0x20,0xb8 == csrrs t2, minstreth, zero +0x73,0x23,0x30,0xb8 == csrrs t1, mhpmcounter3h, zero +0xf3,0x23,0x30,0xb8 == csrrs t2, mhpmcounter3h, zero +0x73,0x23,0x40,0xb8 == csrrs t1, mhpmcounter4h, zero +0xf3,0x23,0x40,0xb8 == csrrs t2, mhpmcounter4h, zero +0x73,0x23,0x50,0xb8 == csrrs t1, mhpmcounter5h, zero +0xf3,0x23,0x50,0xb8 == csrrs t2, mhpmcounter5h, zero +0x73,0x23,0x60,0xb8 == csrrs t1, mhpmcounter6h, zero +0xf3,0x23,0x60,0xb8 == csrrs t2, mhpmcounter6h, zero +0x73,0x23,0x70,0xb8 == csrrs t1, mhpmcounter7h, zero +0xf3,0x23,0x70,0xb8 == csrrs t2, mhpmcounter7h, zero +0x73,0x23,0x80,0xb8 == csrrs t1, mhpmcounter8h, zero +0xf3,0x23,0x80,0xb8 == csrrs t2, mhpmcounter8h, zero +0x73,0x23,0x90,0xb8 == csrrs t1, mhpmcounter9h, zero +0xf3,0x23,0x90,0xb8 == csrrs t2, mhpmcounter9h, zero +0x73,0x23,0xa0,0xb8 == csrrs t1, mhpmcounter10h, zero +0xf3,0x23,0xa0,0xb8 == csrrs t2, mhpmcounter10h, zero +0x73,0x23,0xb0,0xb8 == csrrs t1, mhpmcounter11h, zero +0xf3,0x23,0xb0,0xb8 == csrrs t2, mhpmcounter11h, zero +0x73,0x23,0xc0,0xb8 == csrrs t1, mhpmcounter12h, zero +0xf3,0x23,0xc0,0xb8 == csrrs t2, mhpmcounter12h, zero +0x73,0x23,0xd0,0xb8 == csrrs t1, mhpmcounter13h, zero +0xf3,0x23,0xd0,0xb8 == csrrs t2, mhpmcounter13h, zero +0x73,0x23,0xe0,0xb8 == csrrs t1, mhpmcounter14h, zero +0xf3,0x23,0xe0,0xb8 == csrrs t2, mhpmcounter14h, zero +0x73,0x23,0xf0,0xb8 == csrrs t1, mhpmcounter15h, zero +0xf3,0x23,0xf0,0xb8 == csrrs t2, mhpmcounter15h, zero +0x73,0x23,0x00,0xb9 == csrrs t1, mhpmcounter16h, zero +0xf3,0x23,0x00,0xb9 == csrrs t2, mhpmcounter16h, zero +0x73,0x23,0x10,0xb9 == csrrs t1, mhpmcounter17h, zero +0xf3,0x23,0x10,0xb9 == csrrs t2, mhpmcounter17h, zero +0x73,0x23,0x20,0xb9 == csrrs t1, mhpmcounter18h, zero +0xf3,0x23,0x20,0xb9 == csrrs t2, mhpmcounter18h, zero +0x73,0x23,0x30,0xb9 == csrrs t1, mhpmcounter19h, zero +0xf3,0x23,0x30,0xb9 == csrrs t2, mhpmcounter19h, zero +0x73,0x23,0x40,0xb9 == csrrs t1, mhpmcounter20h, zero +0xf3,0x23,0x40,0xb9 == csrrs t2, mhpmcounter20h, zero +0x73,0x23,0x50,0xb9 == csrrs t1, mhpmcounter21h, zero +0xf3,0x23,0x50,0xb9 == csrrs t2, mhpmcounter21h, zero +0x73,0x23,0x60,0xb9 == csrrs t1, mhpmcounter22h, zero +0xf3,0x23,0x60,0xb9 == csrrs t2, mhpmcounter22h, zero +0x73,0x23,0x70,0xb9 == csrrs t1, mhpmcounter23h, zero +0xf3,0x23,0x70,0xb9 == csrrs t2, mhpmcounter23h, zero +0x73,0x23,0x80,0xb9 == csrrs t1, mhpmcounter24h, zero +0xf3,0x23,0x80,0xb9 == csrrs t2, mhpmcounter24h, zero +0x73,0x23,0x90,0xb9 == csrrs t1, mhpmcounter25h, zero +0xf3,0x23,0x90,0xb9 == csrrs t2, mhpmcounter25h, zero +0x73,0x23,0xa0,0xb9 == csrrs t1, mhpmcounter26h, zero +0xf3,0x23,0xa0,0xb9 == csrrs t2, mhpmcounter26h, zero +0x73,0x23,0xb0,0xb9 == csrrs t1, mhpmcounter27h, zero +0xf3,0x23,0xb0,0xb9 == csrrs t2, mhpmcounter27h, zero +0x73,0x23,0xc0,0xb9 == csrrs t1, mhpmcounter28h, zero +0xf3,0x23,0xc0,0xb9 == csrrs t2, mhpmcounter28h, zero +0x73,0x23,0xd0,0xb9 == csrrs t1, mhpmcounter29h, zero +0xf3,0x23,0xd0,0xb9 == csrrs t2, mhpmcounter29h, zero +0x73,0x23,0xe0,0xb9 == csrrs t1, mhpmcounter30h, zero +0xf3,0x23,0xe0,0xb9 == csrrs t2, mhpmcounter30h, zero +0x73,0x23,0xf0,0xb9 == csrrs t1, mhpmcounter31h, zero +0xf3,0x23,0xf0,0xb9 == csrrs t2, mhpmcounter31h, zero +0x73,0x23,0x30,0x72 == csrrs t1, mhpmevent3h, zero +0xf3,0x23,0x30,0x72 == csrrs t2, mhpmevent3h, zero +0x73,0x23,0x40,0x72 == csrrs t1, mhpmevent4h, zero +0xf3,0x23,0x40,0x72 == csrrs t2, mhpmevent4h, zero +0x73,0x23,0x50,0x72 == csrrs t1, mhpmevent5h, zero +0xf3,0x23,0x50,0x72 == csrrs t2, mhpmevent5h, zero +0x73,0x23,0x60,0x72 == csrrs t1, mhpmevent6h, zero +0xf3,0x23,0x60,0x72 == csrrs t2, mhpmevent6h, zero +0x73,0x23,0x70,0x72 == csrrs t1, mhpmevent7h, zero +0xf3,0x23,0x70,0x72 == csrrs t2, mhpmevent7h, zero +0x73,0x23,0x80,0x72 == csrrs t1, mhpmevent8h, zero +0xf3,0x23,0x80,0x72 == csrrs t2, mhpmevent8h, zero +0x73,0x23,0x90,0x72 == csrrs t1, mhpmevent9h, zero +0xf3,0x23,0x90,0x72 == csrrs t2, mhpmevent9h, zero +0x73,0x23,0xa0,0x72 == csrrs t1, mhpmevent10h, zero +0xf3,0x23,0xa0,0x72 == csrrs t2, mhpmevent10h, zero +0x73,0x23,0xb0,0x72 == csrrs t1, mhpmevent11h, zero +0xf3,0x23,0xb0,0x72 == csrrs t2, mhpmevent11h, zero +0x73,0x23,0xc0,0x72 == csrrs t1, mhpmevent12h, zero +0xf3,0x23,0xc0,0x72 == csrrs t2, mhpmevent12h, zero +0x73,0x23,0xd0,0x72 == csrrs t1, mhpmevent13h, zero +0xf3,0x23,0xd0,0x72 == csrrs t2, mhpmevent13h, zero +0x73,0x23,0xe0,0x72 == csrrs t1, mhpmevent14h, zero +0xf3,0x23,0xe0,0x72 == csrrs t2, mhpmevent14h, zero +0x73,0x23,0xf0,0x72 == csrrs t1, mhpmevent15h, zero +0xf3,0x23,0xf0,0x72 == csrrs t2, mhpmevent15h, zero +0x73,0x23,0x00,0x73 == csrrs t1, mhpmevent16h, zero +0xf3,0x23,0x00,0x73 == csrrs t2, mhpmevent16h, zero +0x73,0x23,0x10,0x73 == csrrs t1, mhpmevent17h, zero +0xf3,0x23,0x10,0x73 == csrrs t2, mhpmevent17h, zero +0x73,0x23,0x20,0x73 == csrrs t1, mhpmevent18h, zero +0xf3,0x23,0x20,0x73 == csrrs t2, mhpmevent18h, zero +0x73,0x23,0x30,0x73 == csrrs t1, mhpmevent19h, zero +0xf3,0x23,0x30,0x73 == csrrs t2, mhpmevent19h, zero +0x73,0x23,0x40,0x73 == csrrs t1, mhpmevent20h, zero +0xf3,0x23,0x40,0x73 == csrrs t2, mhpmevent20h, zero +0x73,0x23,0x50,0x73 == csrrs t1, mhpmevent21h, zero +0xf3,0x23,0x50,0x73 == csrrs t2, mhpmevent21h, zero +0x73,0x23,0x60,0x73 == csrrs t1, mhpmevent22h, zero +0xf3,0x23,0x60,0x73 == csrrs t2, mhpmevent22h, zero +0x73,0x23,0x70,0x73 == csrrs t1, mhpmevent23h, zero +0xf3,0x23,0x70,0x73 == csrrs t2, mhpmevent23h, zero +0x73,0x23,0x80,0x73 == csrrs t1, mhpmevent24h, zero +0xf3,0x23,0x80,0x73 == csrrs t2, mhpmevent24h, zero +0x73,0x23,0x90,0x73 == csrrs t1, mhpmevent25h, zero +0xf3,0x23,0x90,0x73 == csrrs t2, mhpmevent25h, zero +0x73,0x23,0xa0,0x73 == csrrs t1, mhpmevent26h, zero +0xf3,0x23,0xa0,0x73 == csrrs t2, mhpmevent26h, zero +0x73,0x23,0xb0,0x73 == csrrs t1, mhpmevent27h, zero +0xf3,0x23,0xb0,0x73 == csrrs t2, mhpmevent27h, zero +0x73,0x23,0xc0,0x73 == csrrs t1, mhpmevent28h, zero +0xf3,0x23,0xc0,0x73 == csrrs t2, mhpmevent28h, zero +0x73,0x23,0xd0,0x73 == csrrs t1, mhpmevent29h, zero +0xf3,0x23,0xd0,0x73 == csrrs t2, mhpmevent29h, zero +0x73,0x23,0xe0,0x73 == csrrs t1, mhpmevent30h, zero +0xf3,0x23,0xe0,0x73 == csrrs t2, mhpmevent30h, zero +0x73,0x23,0xf0,0x73 == csrrs t1, mhpmevent31h, zero +0xf3,0x23,0xf0,0x73 == csrrs t2, mhpmevent31h, zero +0x73,0x23,0xc0,0x31 == csrrs t1, mstateen0h, zero +0xf3,0x23,0xc0,0x31 == csrrs t2, mstateen0h, zero +0x73,0x23,0xd0,0x31 == csrrs t1, mstateen1h, zero +0xf3,0x23,0xd0,0x31 == csrrs t2, mstateen1h, zero +0x73,0x23,0xe0,0x31 == csrrs t1, mstateen2h, zero +0xf3,0x23,0xe0,0x31 == csrrs t2, mstateen2h, zero +0x73,0x23,0xf0,0x31 == csrrs t1, mstateen3h, zero +0xf3,0x23,0xf0,0x31 == csrrs t2, mstateen3h, zero +0x73,0x23,0x30,0x31 == csrrs t1, midelegh, zero +0xf3,0x23,0x30,0x31 == csrrs t2, midelegh, zero +0x73,0x23,0x40,0x31 == csrrs t1, mieh, zero +0xf3,0x23,0x40,0x31 == csrrs t2, mieh, zero +0x73,0x23,0x80,0x31 == csrrs t1, mvienh, zero +0xf3,0x23,0x80,0x31 == csrrs t2, mvienh, zero +0x73,0x23,0x90,0x31 == csrrs t1, mviph, zero +0xf3,0x23,0x90,0x31 == csrrs t2, mviph, zero +0x73,0x23,0x40,0x35 == csrrs t1, miph, zero +0xf3,0x23,0x40,0x35 == csrrs t2, miph, zero \ No newline at end of file diff --git a/suite/MC/RISCV/rv32_supervisor_csr_names_riscv32_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rv32_supervisor_csr_names_riscv32_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..4dbc259a2a --- /dev/null +++ b/suite/MC/RISCV/rv32_supervisor_csr_names_riscv32_syntax_no_alias_text.txt.cs @@ -0,0 +1,7 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32", None +0x73,0x23,0xd0,0x15 == csrrs t1, stimecmph, zero +0xf3,0x23,0xd0,0x15 == csrrs t2, stimecmph, zero +0x73,0x23,0x40,0x11 == csrrs t1, sieh, zero +0xf3,0x23,0x40,0x11 == csrrs t2, sieh, zero +0x73,0x23,0x40,0x15 == csrrs t1, siph, zero +0xf3,0x23,0x40,0x15 == csrrs t2, siph, zero \ No newline at end of file diff --git a/suite/MC/RISCV/rv32_user_csr_names_riscv32_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rv32_user_csr_names_riscv32_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..b09fbe8bf3 --- /dev/null +++ b/suite/MC/RISCV/rv32_user_csr_names_riscv32_syntax_no_alias_text.txt.cs @@ -0,0 +1,65 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32", None +0x73,0x23,0x00,0xc8 == csrrs t1, cycleh, zero +0xf3,0x23,0x00,0xc8 == csrrs t2, cycleh, zero +0x73,0x23,0x10,0xc8 == csrrs t1, timeh, zero +0xf3,0x23,0x10,0xc8 == csrrs t2, timeh, zero +0x73,0x23,0x20,0xc8 == csrrs t1, instreth, zero +0xf3,0x23,0x20,0xc8 == csrrs t2, instreth, zero +0x73,0x23,0x30,0xc8 == csrrs t1, hpmcounter3h, zero +0xf3,0x23,0x30,0xc8 == csrrs t2, hpmcounter3h, zero +0x73,0x23,0x40,0xc8 == csrrs t1, hpmcounter4h, zero +0xf3,0x23,0x40,0xc8 == csrrs t2, hpmcounter4h, zero +0x73,0x23,0x50,0xc8 == csrrs t1, hpmcounter5h, zero +0xf3,0x23,0x50,0xc8 == csrrs t2, hpmcounter5h, zero +0x73,0x23,0x60,0xc8 == csrrs t1, hpmcounter6h, zero +0xf3,0x23,0x60,0xc8 == csrrs t2, hpmcounter6h, zero +0x73,0x23,0x70,0xc8 == csrrs t1, hpmcounter7h, zero +0xf3,0x23,0x70,0xc8 == csrrs t2, hpmcounter7h, zero +0x73,0x23,0x80,0xc8 == csrrs t1, hpmcounter8h, zero +0xf3,0x23,0x80,0xc8 == csrrs t2, hpmcounter8h, zero +0x73,0x23,0x90,0xc8 == csrrs t1, hpmcounter9h, zero +0xf3,0x23,0x90,0xc8 == csrrs t2, hpmcounter9h, zero +0x73,0x23,0xa0,0xc8 == csrrs t1, hpmcounter10h, zero +0xf3,0x23,0xa0,0xc8 == csrrs t2, hpmcounter10h, zero +0x73,0x23,0xb0,0xc8 == csrrs t1, hpmcounter11h, zero +0xf3,0x23,0xb0,0xc8 == csrrs t2, hpmcounter11h, zero +0x73,0x23,0xc0,0xc8 == csrrs t1, hpmcounter12h, zero +0xf3,0x23,0xc0,0xc8 == csrrs t2, hpmcounter12h, zero +0x73,0x23,0xd0,0xc8 == csrrs t1, hpmcounter13h, zero +0xf3,0x23,0xd0,0xc8 == csrrs t2, hpmcounter13h, zero +0x73,0x23,0xe0,0xc8 == csrrs t1, hpmcounter14h, zero +0xf3,0x23,0xe0,0xc8 == csrrs t2, hpmcounter14h, zero +0x73,0x23,0xf0,0xc8 == csrrs t1, hpmcounter15h, zero +0xf3,0x23,0xf0,0xc8 == csrrs t2, hpmcounter15h, zero +0x73,0x23,0x00,0xc9 == csrrs t1, hpmcounter16h, zero +0xf3,0x23,0x00,0xc9 == csrrs t2, hpmcounter16h, zero +0x73,0x23,0x10,0xc9 == csrrs t1, hpmcounter17h, zero +0xf3,0x23,0x10,0xc9 == csrrs t2, hpmcounter17h, zero +0x73,0x23,0x20,0xc9 == csrrs t1, hpmcounter18h, zero +0xf3,0x23,0x20,0xc9 == csrrs t2, hpmcounter18h, zero +0x73,0x23,0x30,0xc9 == csrrs t1, hpmcounter19h, zero +0xf3,0x23,0x30,0xc9 == csrrs t2, hpmcounter19h, zero +0x73,0x23,0x40,0xc9 == csrrs t1, hpmcounter20h, zero +0xf3,0x23,0x40,0xc9 == csrrs t2, hpmcounter20h, zero +0x73,0x23,0x50,0xc9 == csrrs t1, hpmcounter21h, zero +0xf3,0x23,0x50,0xc9 == csrrs t2, hpmcounter21h, zero +0x73,0x23,0x60,0xc9 == csrrs t1, hpmcounter22h, zero +0xf3,0x23,0x60,0xc9 == csrrs t2, hpmcounter22h, zero +0x73,0x23,0x70,0xc9 == csrrs t1, hpmcounter23h, zero +0xf3,0x23,0x70,0xc9 == csrrs t2, hpmcounter23h, zero +0x73,0x23,0x80,0xc9 == csrrs t1, hpmcounter24h, zero +0xf3,0x23,0x80,0xc9 == csrrs t2, hpmcounter24h, zero +0x73,0x23,0x90,0xc9 == csrrs t1, hpmcounter25h, zero +0xf3,0x23,0x90,0xc9 == csrrs t2, hpmcounter25h, zero +0x73,0x23,0xa0,0xc9 == csrrs t1, hpmcounter26h, zero +0xf3,0x23,0xa0,0xc9 == csrrs t2, hpmcounter26h, zero +0x73,0x23,0xb0,0xc9 == csrrs t1, hpmcounter27h, zero +0xf3,0x23,0xb0,0xc9 == csrrs t2, hpmcounter27h, zero +0x73,0x23,0xc0,0xc9 == csrrs t1, hpmcounter28h, zero +0xf3,0x23,0xc0,0xc9 == csrrs t2, hpmcounter28h, zero +0x73,0x23,0xd0,0xc9 == csrrs t1, hpmcounter29h, zero +0xf3,0x23,0xd0,0xc9 == csrrs t2, hpmcounter29h, zero +0x73,0x23,0xe0,0xc9 == csrrs t1, hpmcounter30h, zero +0xf3,0x23,0xe0,0xc9 == csrrs t2, hpmcounter30h, zero +0x73,0x23,0xf0,0xc9 == csrrs t1, hpmcounter31h, zero +0xf3,0x23,0xf0,0xc9 == csrrs t2, hpmcounter31h, zero \ No newline at end of file diff --git a/suite/MC/RISCV/rv32c_only_valid_riscv32_riscv_c_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rv32c_only_valid_riscv32_riscv_c_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..d9f4a29f77 --- /dev/null +++ b/suite/MC/RISCV/rv32c_only_valid_riscv32_riscv_c_syntax_no_alias_text.txt.cs @@ -0,0 +1,3 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32"|"CS_MODE_RISCV_C", None +0xfd,0x2f == c.jal 2046 +0xfd,0x15 == c.addi a1, -1 \ No newline at end of file diff --git a/suite/MC/RISCV/rv32c_valid_riscv32_riscv_c_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rv32c_valid_riscv32_riscv_c_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..cc4770638a --- /dev/null +++ b/suite/MC/RISCV/rv32c_valid_riscv32_riscv_c_syntax_no_alias_text.txt.cs @@ -0,0 +1,36 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32"|"CS_MODE_RISCV_C", None +0x82,0x40 == c.lwsp ra, 0(sp) +0x86,0xdf == c.swsp ra, 252(sp) +0x10,0x41 == c.lw a2, 0(a0) +0xfc,0xde == c.sw a5, 124(a3) +0x02,0x44 == c.lwsp s0, 0(sp) +0x22,0xc0 == c.swsp s0, 0(sp) +0x80,0x40 == c.lw s0, 0(s1) +0x80,0xc0 == c.sw s0, 0(s1) +0x01,0xb0 == c.j -2048 +0x82,0x88 == c.jr a7 +0x82,0x95 == c.jalr a1 +0x81,0xd2 == c.beqz a3, -256 +0xfd,0xef == c.bnez a5, 254 +0xfd,0x48 == c.li a7, 31 +0x81,0x16 == c.addi a3, -32 +0x01,0x71 == c.addi16sp sp, -512 +0x7d,0x61 == c.addi16sp sp, 496 +0xf4,0x1f == c.addi4spn a3, sp, 1020 +0x54,0x00 == c.addi4spn a3, sp, 4 +0x86,0x05 == c.slli a1, 1 +0xfd,0x82 == c.srli a3, 31 +0x09,0x87 == c.srai a4, 2 +0xbd,0x8b == c.andi a5, 15 +0xa2,0x88 == c.mv a7, s0 +0xf1,0x8d == c.and a1, a2 +0x55,0x8e == c.or a2, a3 +0xb9,0x8e == c.xor a3, a4 +0x1d,0x8f == c.sub a4, a5 +0x01,0x00 == c.nop +0x02,0x90 == c.ebreak +0x05,0x64 == c.lui s0, 1 +0x7d,0x64 == c.lui s0, 31 +0x01,0x74 == c.lui s0, 1048544 +0x7d,0x74 == c.lui s0, 1048575 +0x00,0x00 == c.unimp \ No newline at end of file diff --git a/suite/MC/RISCV/rv32d_valid_riscv32_riscv_d_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rv32d_valid_riscv32_riscv_d_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..c1aa0f94c6 --- /dev/null +++ b/suite/MC/RISCV/rv32d_valid_riscv32_riscv_d_syntax_no_alias_text.txt.cs @@ -0,0 +1,49 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32"|"CS_MODE_RISCV_D", None +0x53,0xfd,0xcd,0x01 == fadd.s fs10, fs11, ft8, dyn +0x07,0x30,0xc5,0x00 == fld ft0, 12(a0) +0x87,0xb0,0x40,0x00 == fld ft1, 4(ra) +0x07,0xb1,0x06,0x80 == fld ft2, -2048(a3) +0x87,0xb1,0x04,0x80 == fld ft3, -2048(s1) +0x07,0x32,0xf9,0x7f == fld ft4, 2047(s2) +0x87,0xb2,0x09,0x00 == fld ft5, 0(s3) +0xa7,0x3f,0x6a,0x7e == fsd ft6, 2047(s4) +0x27,0xb0,0x7a,0x80 == fsd ft7, -2048(s5) +0x27,0x30,0x8b,0x80 == fsd fs0, -2048(s6) +0xa7,0xb3,0x9b,0x3e == fsd fs1, 999(s7) +0x43,0xf5,0xc5,0x6a == fmadd.d fa0, fa1, fa2, fa3, dyn +0x47,0xf7,0x07,0x8b == fmsub.d fa4, fa5, fa6, fa7, dyn +0x4b,0xf9,0x49,0xab == fnmsub.d fs2, fs3, fs4, fs5, dyn +0x4f,0xfb,0x8b,0xcb == fnmadd.d fs6, fs7, fs8, fs9, dyn +0x53,0xfd,0xcd,0x03 == fadd.d fs10, fs11, ft8, dyn +0xd3,0x7e,0xff,0x0b == fsub.d ft9, ft10, ft11, dyn +0x53,0xf0,0x20,0x12 == fmul.d ft0, ft1, ft2, dyn +0xd3,0x71,0x52,0x1a == fdiv.d ft3, ft4, ft5, dyn +0x53,0xf3,0x03,0x5a == fsqrt.d ft6, ft7, dyn +0xd3,0x04,0xb5,0x22 == fsgnj.d fs1, fa0, fa1 +0xd3,0x95,0xe6,0x22 == fsgnjn.d fa1, fa3, fa4 +0xd3,0x26,0xb6,0x22 == fsgnjx.d fa3, fa2, fa1 +0xd3,0x07,0x18,0x2b == fmin.d fa5, fa6, fa7 +0x53,0x99,0x49,0x2b == fmax.d fs2, fs3, fs4 +0xd3,0x7a,0x1b,0x40 == fcvt.s.d fs5, fs6, dyn +0xd3,0x0b,0x0c,0x42 == fcvt.d.s fs7, fs8 +0xd3,0x3b,0x0c,0x42 == fcvt.d.s fs7, fs8, rup +0xd3,0x25,0x9c,0xa3 == feq.d a1, fs8, fs9 +0x53,0x16,0xbd,0xa3 == flt.d a2, fs10, fs11 +0xd3,0x06,0xde,0xa3 == fle.d a3, ft8, ft9 +0xd3,0x16,0x0f,0xe2 == fclass.d a3, ft10 +0x53,0xf7,0x0f,0xc2 == fcvt.w.d a4, ft11, dyn +0x53,0x80,0x07,0xd2 == fcvt.d.w ft0, a5 +0x53,0xb0,0x07,0xd2 == fcvt.d.w ft0, a5, rup +0xd3,0x00,0x18,0xd2 == fcvt.d.wu ft1, a6 +0xd3,0x30,0x18,0xd2 == fcvt.d.wu ft1, a6, rup +0x43,0x85,0xc5,0x6a == fmadd.d fa0, fa1, fa2, fa3, rne +0x47,0x97,0x07,0x8b == fmsub.d fa4, fa5, fa6, fa7, rtz +0x4b,0xa9,0x49,0xab == fnmsub.d fs2, fs3, fs4, fs5, rdn +0x4f,0xbb,0x8b,0xcb == fnmadd.d fs6, fs7, fs8, fs9, rup +0x53,0xcd,0xcd,0x03 == fadd.d fs10, fs11, ft8, rmm +0x53,0x80,0x20,0x12 == fmul.d ft0, ft1, ft2, rne +0xd3,0x11,0x52,0x1a == fdiv.d ft3, ft4, ft5, rtz +0x53,0xa3,0x03,0x5a == fsqrt.d ft6, ft7, rdn +0xd3,0x3a,0x1b,0x40 == fcvt.s.d fs5, fs6, rup +0x53,0xc7,0x0f,0xc2 == fcvt.w.d a4, ft11, rmm +0xd3,0x77,0x1f,0xc2 == fcvt.wu.d a5, ft10, dyn \ No newline at end of file diff --git a/suite/MC/RISCV/rv32dc_valid_riscv32_riscv_c_riscv_d_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rv32dc_valid_riscv32_riscv_c_riscv_d_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..4bc2a08bdd --- /dev/null +++ b/suite/MC/RISCV/rv32dc_valid_riscv32_riscv_c_riscv_d_syntax_no_alias_text.txt.cs @@ -0,0 +1,5 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32"|"CS_MODE_RISCV_C"|"CS_MODE_RISCV_D", None +0x7e,0x34 == c.fldsp fs0, 504(sp) +0xc6,0xbf == c.fsdsp fa7, 504(sp) +0xf4,0x3f == c.fld fa3, 248(a5) +0xf0,0xbd == c.fsd fa2, 248(a1) \ No newline at end of file diff --git a/suite/MC/RISCV/rv32e_valid_riscv32_riscv_e_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rv32e_valid_riscv32_riscv_e_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..963d1850ce --- /dev/null +++ b/suite/MC/RISCV/rv32e_valid_riscv32_riscv_e_syntax_no_alias_text.txt.cs @@ -0,0 +1,50 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32"|"CS_MODE_RISCV_E", None +0x37,0x10,0x00,0x00 == lui zero, 1 +0x97,0x20,0x00,0x00 == auipc ra, 2 +0x6f,0x01,0x40,0x00 == jal sp, 4 +0xe7,0x81,0x41,0x00 == jalr gp, 4(gp) +0x63,0x04,0x52,0x00 == beq tp, t0, 8 +0x63,0x16,0x73,0x00 == bne t1, t2, 12 +0x63,0x48,0x94,0x00 == blt s0, s1, 16 +0x63,0x5a,0xb5,0x00 == bge a0, a1, 20 +0x63,0x7c,0xd6,0x00 == bgeu a2, a3, 24 +0x03,0x87,0x97,0x01 == lb a4, 25(a5) +0x03,0x90,0xa0,0x01 == lh zero, 26(ra) +0x03,0xa1,0xc1,0x01 == lw sp, 28(gp) +0x03,0xc2,0xd2,0x01 == lbu tp, 29(t0) +0x03,0xd3,0xe3,0x01 == lhu t1, 30(t2) +0xa3,0x8f,0x84,0x00 == sb s0, 31(s1) +0x23,0x90,0xa5,0x02 == sh a0, 32(a1) +0x23,0xa2,0xc6,0x02 == sw a2, 36(a3) +0x13,0x87,0x57,0x02 == addi a4, a5, 37 +0x13,0x25,0xc6,0xfe == slti a0, a2, -20 +0x13,0x42,0xd3,0xf9 == xori tp, t1, -99 +0x13,0xe5,0x05,0x80 == ori a0, a1, -2048 +0x93,0x70,0xf1,0x7f == andi ra, sp, 2047 +0x13,0x13,0xf3,0x01 == slli t1, t1, 31 +0x13,0x55,0x07,0x00 == srli a0, a4, 0 +0x93,0x55,0xf1,0x40 == srai a1, sp, 15 +0x93,0x12,0xd3,0x00 == slli t0, t1, 13 +0xb3,0x00,0x00,0x00 == add ra, zero, zero +0xb3,0x82,0x63,0x40 == sub t0, t2, t1 +0xb3,0x17,0xd7,0x00 == sll a5, a4, a3 +0x33,0x24,0x84,0x00 == slt s0, s0, s0 +0xb3,0x31,0xb5,0x00 == sltu gp, a0, a1 +0xb3,0x44,0x94,0x00 == xor s1, s0, s1 +0x33,0x55,0x54,0x00 == srl a0, s0, t0 +0xb3,0xd2,0x06,0x40 == sra t0, a3, zero +0xb3,0x67,0x13,0x00 == or a5, t1, ra +0x33,0xf5,0xd4,0x00 == and a0, s1, a3 +0x0f,0x00,0xf0,0x0f == fence iorw, iorw +0x0f,0x00,0x30,0x83 == fence.tso +0x0f,0x10,0x00,0x00 == fence.i +0x73,0x00,0x00,0x00 == ecall +0x73,0x00,0x10,0x00 == ebreak +0x73,0x10,0x00,0xc0 == unimp +0xf3,0x12,0xf3,0xff == csrrw t0, 4095, t1 +0x73,0x24,0x00,0xc0 == csrrs s0, cycle, zero +0x73,0xa4,0x17,0x00 == csrrs s0, fflags, a5 +0x73,0xb1,0x00,0x00 == csrrc sp, 0, ra +0xf3,0x57,0x00,0x00 == csrrwi a5, 0, 0 +0xf3,0xe3,0xff,0xff == csrrsi t2, 4095, 31 +0x73,0xf3,0x02,0x14 == csrrci t1, sscratch, 5 \ No newline at end of file diff --git a/suite/MC/RISCV/rv32f_valid_riscv32_riscv_f_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rv32f_valid_riscv32_riscv_f_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..51a44b919f --- /dev/null +++ b/suite/MC/RISCV/rv32f_valid_riscv32_riscv_f_syntax_no_alias_text.txt.cs @@ -0,0 +1,49 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32"|"CS_MODE_RISCV_F", None +0x07,0x20,0xc5,0x00 == flw ft0, 12(a0) +0x87,0xa0,0x40,0x00 == flw ft1, 4(ra) +0x07,0xa1,0x06,0x80 == flw ft2, -2048(a3) +0x87,0xa1,0x04,0x80 == flw ft3, -2048(s1) +0x07,0x22,0xf9,0x7f == flw ft4, 2047(s2) +0x87,0xa2,0x09,0x00 == flw ft5, 0(s3) +0xa7,0x2f,0x6a,0x7e == fsw ft6, 2047(s4) +0x27,0xa0,0x7a,0x80 == fsw ft7, -2048(s5) +0x27,0x20,0x8b,0x80 == fsw fs0, -2048(s6) +0xa7,0xa3,0x9b,0x3e == fsw fs1, 999(s7) +0x43,0xf5,0xc5,0x68 == fmadd.s fa0, fa1, fa2, fa3, dyn +0x47,0xf7,0x07,0x89 == fmsub.s fa4, fa5, fa6, fa7, dyn +0x4b,0xf9,0x49,0xa9 == fnmsub.s fs2, fs3, fs4, fs5, dyn +0x4f,0xfb,0x8b,0xc9 == fnmadd.s fs6, fs7, fs8, fs9, dyn +0x53,0xfd,0xcd,0x01 == fadd.s fs10, fs11, ft8, dyn +0xd3,0x7e,0xff,0x09 == fsub.s ft9, ft10, ft11, dyn +0x53,0xf0,0x20,0x10 == fmul.s ft0, ft1, ft2, dyn +0xd3,0x71,0x52,0x18 == fdiv.s ft3, ft4, ft5, dyn +0x53,0xf3,0x03,0x58 == fsqrt.s ft6, ft7, dyn +0xd3,0x04,0xb5,0x20 == fsgnj.s fs1, fa0, fa1 +0xd3,0x95,0xe6,0x20 == fsgnjn.s fa1, fa3, fa4 +0x53,0xa7,0xc6,0x20 == fsgnjx.s fa4, fa3, fa2 +0xd3,0x07,0x18,0x29 == fmin.s fa5, fa6, fa7 +0x53,0x99,0x49,0x29 == fmax.s fs2, fs3, fs4 +0x53,0xf5,0x0a,0xc0 == fcvt.w.s a0, fs5, dyn +0xd3,0x75,0x1b,0xc0 == fcvt.wu.s a1, fs6, dyn +0x53,0x86,0x0b,0xe0 == fmv.x.w a2, fs7 +0xd3,0x25,0x9c,0xa1 == feq.s a1, fs8, fs9 +0x53,0x16,0xbd,0xa1 == flt.s a2, fs10, fs11 +0xd3,0x06,0xde,0xa1 == fle.s a3, ft8, ft9 +0xd3,0x16,0x0f,0xe0 == fclass.s a3, ft10 +0xd3,0x7f,0x07,0xd0 == fcvt.s.w ft11, a4, dyn +0x53,0xf0,0x17,0xd0 == fcvt.s.wu ft0, a5, dyn +0xd3,0x00,0x08,0xf0 == fmv.w.x ft1, a6 +0x43,0x85,0xc5,0x68 == fmadd.s fa0, fa1, fa2, fa3, rne +0x47,0x97,0x07,0x89 == fmsub.s fa4, fa5, fa6, fa7, rtz +0x4b,0xa9,0x49,0xa9 == fnmsub.s fs2, fs3, fs4, fs5, rdn +0x4f,0xbb,0x8b,0xc9 == fnmadd.s fs6, fs7, fs8, fs9, rup +0x43,0xc5,0xc5,0x68 == fmadd.s fa0, fa1, fa2, fa3, rmm +0x53,0x8d,0xcd,0x01 == fadd.s fs10, fs11, ft8, rne +0xd3,0x1e,0xff,0x09 == fsub.s ft9, ft10, ft11, rtz +0x53,0xa0,0x20,0x10 == fmul.s ft0, ft1, ft2, rdn +0xd3,0x31,0x52,0x18 == fdiv.s ft3, ft4, ft5, rup +0x53,0xc3,0x03,0x58 == fsqrt.s ft6, ft7, rmm +0x53,0xb5,0x0a,0xc0 == fcvt.w.s a0, fs5, rup +0xd3,0x25,0x1b,0xc0 == fcvt.wu.s a1, fs6, rdn +0xd3,0x1f,0x07,0xd0 == fcvt.s.w ft11, a4, rtz +0x53,0x80,0x17,0xd0 == fcvt.s.wu ft0, a5, rne \ No newline at end of file diff --git a/suite/MC/RISCV/rv32fc_valid_riscv32_riscv_c_riscv_f_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rv32fc_valid_riscv32_riscv_c_riscv_f_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..673263dc4b --- /dev/null +++ b/suite/MC/RISCV/rv32fc_valid_riscv32_riscv_c_riscv_f_syntax_no_alias_text.txt.cs @@ -0,0 +1,5 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32"|"CS_MODE_RISCV_C"|"CS_MODE_RISCV_F", None +0x7e,0x74 == c.flwsp fs0, 252(sp) +0xc6,0xff == c.fswsp fa7, 252(sp) +0xf4,0x7f == c.flw fa3, 124(a5) +0xf0,0xfd == c.fsw fa2, 124(a1) \ No newline at end of file diff --git a/suite/MC/RISCV/rv32i_only_valid_riscv32_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rv32i_only_valid_riscv32_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..6134207c66 --- /dev/null +++ b/suite/MC/RISCV/rv32i_only_valid_riscv32_syntax_no_alias_text.txt.cs @@ -0,0 +1,5 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32", None +0x13,0x85,0xf5,0xff == addi a0, a1, -1 +0x13,0xe6,0x06,0x80 == ori a2, a3, -2048 +0x83,0x25,0xb6,0x9a == lw a1, -1621(a2) +0x23,0x2c,0xb6,0xfe == sw a1, -8(a2) \ No newline at end of file diff --git a/suite/MC/RISCV/rv32i_valid_riscv32_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rv32i_valid_riscv32_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..1dccba211a --- /dev/null +++ b/suite/MC/RISCV/rv32i_valid_riscv32_syntax_no_alias_text.txt.cs @@ -0,0 +1,86 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32", None +0x37,0x25,0x00,0x00 == lui a0, 2 +0xb7,0x0d,0x00,0x87 == lui s11, 552960 +0x37,0x05,0x00,0x00 == lui a0, 0 +0xb7,0xf2,0xff,0xff == lui t0, 1048575 +0xb7,0x01,0x00,0x00 == lui gp, 0 +0x37,0xe5,0x01,0x00 == lui a0, 30 +0x37,0xf5,0x01,0x00 == lui a0, 31 +0x17,0x25,0x00,0x00 == auipc a0, 2 +0x97,0x0d,0x00,0x87 == auipc s11, 552960 +0x97,0xf2,0xff,0xff == auipc t0, 1048575 +0x97,0x01,0x00,0x00 == auipc gp, 0 +0x17,0xe5,0x01,0x00 == auipc a0, 30 +0x6f,0xf6,0xff,0x7f == jal a2, 1048574 +0xef,0x06,0x00,0x10 == jal a3, 256 +0x6f,0x05,0xe0,0x01 == jal a0, 30 +0x6f,0x04,0x00,0x00 == jal s0, 0 +0x6f,0x04,0xc0,0x09 == jal s0, 156 +0x67,0x85,0x05,0x80 == jalr a0, -2048(a1) +0xe7,0x03,0xf3,0x7f == jalr t2, 2047(t1) +0x67,0x01,0x00,0x10 == jalr sp, 256(zero) +0xe7,0x05,0xe6,0x01 == jalr a1, 30(a2) +0x63,0x83,0x94,0x06 == beq s1, s1, 102 +0x63,0x10,0xf7,0x80 == bne a4, a5, -4096 +0xe3,0x4f,0x31,0x7e == blt sp, gp, 4094 +0xe3,0x50,0x19,0xf2 == bge s2, ra, -224 +0x63,0x60,0x00,0x00 == bltu zero, zero, 0 +0x63,0x70,0x2c,0x20 == bgeu s8, sp, 512 +0x63,0xff,0x62,0x00 == bgeu t0, t1, 30 +0x83,0x89,0x40,0x00 == lb s3, 4(ra) +0x03,0x13,0x00,0x80 == lh t1, -2048(zero) +0x03,0x13,0x00,0x00 == lh t1, 0(zero) +0x03,0x11,0xf5,0x7f == lh sp, 2047(a0) +0x03,0x25,0x16,0x06 == lw a0, 97(a2) +0x83,0x02,0xe3,0x01 == lb t0, 30(t1) +0x03,0x84,0x04,0x00 == lb s0, 0(s1) +0x03,0x84,0xc4,0x09 == lb s0, 156(s1) +0xa3,0x0f,0xa6,0x7e == sb a0, 2047(a2) +0x23,0x10,0xcf,0x81 == sh t3, -2048(t5) +0x23,0x10,0xcf,0x01 == sh t3, 0(t5) +0xa3,0x23,0x10,0x3e == sw ra, 999(zero) +0x23,0xaf,0xa2,0x00 == sw a0, 30(t0) +0x23,0xa0,0x84,0x00 == sw s0, 0(s1) +0x23,0xae,0x84,0x08 == sw s0, 156(s1) +0x93,0x00,0x21,0x00 == addi ra, sp, 2 +0x93,0x00,0xe1,0x01 == addi ra, sp, 30 +0x93,0x00,0x01,0x00 == addi ra, sp, 0 +0x93,0x00,0xc1,0x09 == addi ra, sp, 156 +0x13,0x25,0xc6,0xfe == slti a0, a2, -20 +0x13,0xb9,0x09,0x05 == sltiu s2, s3, 80 +0x13,0x42,0xd3,0xf9 == xori tp, t1, -99 +0x13,0xe5,0x05,0x80 == ori a0, a1, -2048 +0x13,0xe5,0x05,0x00 == ori a0, a1, 0 +0x93,0x70,0xf1,0x7f == andi ra, sp, 2047 +0x13,0x1e,0xfe,0x01 == slli t3, t3, 31 +0x13,0x55,0x07,0x00 == srli a0, a4, 0 +0x13,0x56,0xf1,0x40 == srai a2, sp, 15 +0x13,0x1e,0xee,0x01 == slli t3, t3, 30 +0xb3,0x00,0x00,0x00 == add ra, zero, zero +0xb3,0x82,0x63,0x40 == sub t0, t2, t1 +0xb3,0x17,0xd7,0x00 == sll a5, a4, a3 +0x33,0x24,0x84,0x00 == slt s0, s0, s0 +0xb3,0x31,0xb5,0x00 == sltu gp, a0, a1 +0x33,0x49,0x89,0x01 == xor s2, s2, s8 +0x33,0x55,0x54,0x00 == srl a0, s0, t0 +0xb3,0x52,0x09,0x40 == sra t0, s2, zero +0x33,0x6d,0x13,0x00 == or s10, t1, ra +0x33,0x75,0x39,0x01 == and a0, s2, s3 +0x0f,0x00,0xf0,0x0f == fence iorw, iorw +0x0f,0x00,0x30,0x0c == fence io, rw +0x0f,0x00,0x10,0x02 == fence r, w +0x0f,0x00,0xa0,0x01 == fence w, ir +0x0f,0x00,0x30,0x83 == fence.tso +0x0f,0x10,0x00,0x00 == fence.i +0x73,0x00,0x00,0x00 == ecall +0x73,0x00,0x10,0x00 == ebreak +0x73,0x10,0x00,0xc0 == unimp +0xf3,0x12,0xf3,0xff == csrrw t0, 4095, t1 +0x73,0x94,0xf4,0xff == csrrw s0, 4095, s1 +0x73,0x94,0x14,0x00 == csrrw s0, fflags, s1 +0x73,0x24,0x00,0xc0 == csrrs s0, cycle, zero +0xf3,0xa9,0x1a,0x00 == csrrs s3, fflags, s5 +0x73,0xb1,0x00,0x00 == csrrc sp, 0, ra +0xf3,0x57,0x00,0x00 == csrrwi a5, 0, 0 +0xf3,0xe3,0xff,0xff == csrrsi t2, 4095, 31 +0x73,0xf3,0x02,0x14 == csrrci t1, sscratch, 5 \ No newline at end of file diff --git a/suite/MC/RISCV/rv32ih_aliases_valid_riscv32_h_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rv32ih_aliases_valid_riscv32_h_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..65a8e55ca7 --- /dev/null +++ b/suite/MC/RISCV/rv32ih_aliases_valid_riscv32_h_syntax_no_alias_text.txt.cs @@ -0,0 +1,15 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32", None +0x73,0x00,0x00,0x62 == hfence.gvma zero, zero +0x73,0x00,0x05,0x62 == hfence.gvma a0, zero +0x73,0x00,0x00,0x22 == hfence.vvma zero, zero +0x73,0x00,0x05,0x22 == hfence.vvma a0, zero +0x73,0xc5,0x05,0x60 == hlv.b a0, (a1) +0x73,0xc5,0x15,0x60 == hlv.bu a0, (a1) +0xf3,0x45,0x06,0x64 == hlv.h a1, (a2) +0xf3,0xc5,0x15,0x64 == hlv.hu a1, (a1) +0xf3,0x45,0x36,0x64 == hlvx.hu a1, (a2) +0x73,0x46,0x06,0x68 == hlv.w a2, (a2) +0x73,0xc6,0x36,0x68 == hlvx.wu a2, (a3) +0x73,0xc0,0xa5,0x62 == hsv.b a0, (a1) +0x73,0xc0,0xa5,0x66 == hsv.h a0, (a1) +0x73,0xc0,0xa5,0x6a == hsv.w a0, (a1) \ No newline at end of file diff --git a/suite/MC/RISCV/rv32ih_valid_riscv32_h_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rv32ih_valid_riscv32_h_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..65719c331c --- /dev/null +++ b/suite/MC/RISCV/rv32ih_valid_riscv32_h_syntax_no_alias_text.txt.cs @@ -0,0 +1,15 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32", None +0x73,0x00,0x00,0x22 == hfence.vvma zero, zero +0x73,0x00,0xb5,0x22 == hfence.vvma a0, a1 +0x73,0x00,0x00,0x62 == hfence.gvma zero, zero +0x73,0x00,0xb5,0x62 == hfence.gvma a0, a1 +0x73,0xc5,0x05,0x60 == hlv.b a0, (a1) +0x73,0xc5,0x15,0x60 == hlv.bu a0, (a1) +0xf3,0x45,0x06,0x64 == hlv.h a1, (a2) +0xf3,0xc5,0x15,0x64 == hlv.hu a1, (a1) +0xf3,0x45,0x36,0x64 == hlvx.hu a1, (a2) +0x73,0x46,0x06,0x68 == hlv.w a2, (a2) +0x73,0xc6,0x36,0x68 == hlvx.wu a2, (a3) +0x73,0xc0,0xa5,0x62 == hsv.b a0, (a1) +0x73,0xc0,0xa5,0x66 == hsv.h a0, (a1) +0x73,0xc0,0xa5,0x6a == hsv.w a0, (a1) \ No newline at end of file diff --git a/suite/MC/RISCV/rv32m_valid_riscv32_m_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rv32m_valid_riscv32_m_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..5e3a3dd82e --- /dev/null +++ b/suite/MC/RISCV/rv32m_valid_riscv32_m_syntax_no_alias_text.txt.cs @@ -0,0 +1,9 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32", None +0x33,0x87,0x80,0x02 == mul a4, ra, s0 +0xb3,0x10,0x00,0x02 == mulh ra, zero, zero +0xb3,0xa2,0x63,0x02 == mulhsu t0, t2, t1 +0xb3,0x37,0xd7,0x02 == mulhu a5, a4, a3 +0x33,0x44,0x84,0x02 == div s0, s0, s0 +0xb3,0x51,0xb5,0x02 == divu gp, a0, a1 +0x33,0x69,0x89,0x03 == rem s2, s2, s8 +0x33,0x79,0x89,0x03 == remu s2, s2, s8 \ No newline at end of file diff --git a/suite/MC/RISCV/rv32xtheadbs_valid_riscv32_riscv_xtheadbs.txt.cs b/suite/MC/RISCV/rv32xtheadbs_valid_riscv32_riscv_xtheadbs.txt.cs new file mode 100644 index 0000000000..1d78c70120 --- /dev/null +++ b/suite/MC/RISCV/rv32xtheadbs_valid_riscv32_riscv_xtheadbs.txt.cs @@ -0,0 +1,3 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32"|"CS_MODE_RISCV_XTHEADBS", None +0x8b,0x12,0x13,0x88 == th.tst t0, t1, 1 +0x8b,0x12,0xf3,0x89 == th.tst t0, t1, 31 \ No newline at end of file diff --git a/suite/MC/RISCV/rv32xtheadfmemidx_valid_riscv32_riscv_d_riscv_xtheadfmemidx.txt.cs b/suite/MC/RISCV/rv32xtheadfmemidx_valid_riscv32_riscv_d_riscv_xtheadfmemidx.txt.cs new file mode 100644 index 0000000000..a15b29a3b6 --- /dev/null +++ b/suite/MC/RISCV/rv32xtheadfmemidx_valid_riscv32_riscv_d_riscv_xtheadfmemidx.txt.cs @@ -0,0 +1,9 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32"|"CS_MODE_RISCV_D"|"CS_MODE_RISCV_XTHEADFMEMIDX", None +0x0b,0xe5,0xc5,0x60 == th.flrd fa0, a1, a2, 0 +0x0b,0xe5,0xc5,0x66 == th.flrd fa0, a1, a2, 3 +0x0b,0xe5,0xc5,0x40 == th.flrw fa0, a1, a2, 0 +0x0b,0xe5,0xc5,0x46 == th.flrw fa0, a1, a2, 3 +0x0b,0xf5,0xc5,0x60 == th.fsrd fa0, a1, a2, 0 +0x0b,0xf5,0xc5,0x66 == th.fsrd fa0, a1, a2, 3 +0x0b,0xf5,0xc5,0x40 == th.fsrw fa0, a1, a2, 0 +0x0b,0xf5,0xc5,0x46 == th.fsrw fa0, a1, a2, 3 \ No newline at end of file diff --git a/suite/MC/RISCV/rv32xtheadmac_valid_riscv32_riscv_xtheadmac.txt.cs b/suite/MC/RISCV/rv32xtheadmac_valid_riscv32_riscv_xtheadmac.txt.cs new file mode 100644 index 0000000000..864567d840 --- /dev/null +++ b/suite/MC/RISCV/rv32xtheadmac_valid_riscv32_riscv_xtheadmac.txt.cs @@ -0,0 +1,5 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32"|"CS_MODE_RISCV_XTHEADMAC", None +0x0b,0x95,0xc5,0x20 == th.mula a0, a1, a2 +0x0b,0x95,0xc5,0x28 == th.mulah a0, a1, a2 +0x0b,0x95,0xc5,0x22 == th.muls a0, a1, a2 +0x0b,0x95,0xc5,0x2a == th.mulsh a0, a1, a2 \ No newline at end of file diff --git a/suite/MC/RISCV/rv32xtheadmemidx_valid_riscv32_riscv_xtheadmemidx.txt.cs b/suite/MC/RISCV/rv32xtheadmemidx_valid_riscv32_riscv_xtheadmemidx.txt.cs new file mode 100644 index 0000000000..6c556c4ba8 --- /dev/null +++ b/suite/MC/RISCV/rv32xtheadmemidx_valid_riscv32_riscv_xtheadmemidx.txt.cs @@ -0,0 +1,33 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32"|"CS_MODE_RISCV_XTHEADMEMIDX", None +0x0b,0xc5,0x05,0x5c == th.lwia a0, (a1), 0, 2 +0x0b,0xc5,0x05,0x4f == th.lwib a0, (a1), -16, 3 +0x0b,0xc5,0x05,0x3c == th.lhia a0, (a1), 0, 2 +0x0b,0xc5,0x05,0x2f == th.lhib a0, (a1), -16, 3 +0x0b,0xc5,0x05,0xb8 == th.lhuia a0, (a1), 0, 0 +0x0b,0xc5,0xf5,0xaa == th.lhuib a0, (a1), 15, 1 +0x0b,0xc5,0x05,0x1c == th.lbia a0, (a1), 0, 2 +0x0b,0xc5,0x05,0x0f == th.lbib a0, (a1), -16, 3 +0x0b,0xc5,0x05,0x98 == th.lbuia a0, (a1), 0, 0 +0x0b,0xc5,0xf5,0x8a == th.lbuib a0, (a1), 15, 1 +0x0b,0xd5,0x05,0x5c == th.swia a0, (a1), 0, 2 +0x0b,0xd5,0x15,0x4e == th.swib a0, (a1), 1, 3 +0x0b,0xd5,0x45,0x38 == th.shia a0, (a1), 4, 0 +0x0b,0xd5,0xd5,0x2a == th.shib a0, (a1), 13, 1 +0x0b,0xd5,0xe5,0x1c == th.sbia a0, (a1), 14, 2 +0x0b,0xd5,0xf5,0x0e == th.sbib a0, (a1), 15, 3 +0x0b,0xc5,0xc5,0x42 == th.lrw a0, a1, a2, 1 +0x0b,0xc5,0xc5,0x26 == th.lrh a0, a1, a2, 3 +0x0b,0xc5,0xc5,0xa0 == th.lrhu a0, a1, a2, 0 +0x0b,0xc5,0xc5,0x02 == th.lrb a0, a1, a2, 1 +0x0b,0xc5,0xc5,0x84 == th.lrbu a0, a1, a2, 2 +0x0b,0xd5,0xc5,0x40 == th.srw a0, a1, a2, 0 +0x0b,0xd5,0xc5,0x22 == th.srh a0, a1, a2, 1 +0x0b,0xd5,0xc5,0x04 == th.srb a0, a1, a2, 2 +0x0b,0xc5,0xc5,0x52 == th.lurw a0, a1, a2, 1 +0x0b,0xc5,0xc5,0x36 == th.lurh a0, a1, a2, 3 +0x0b,0xc5,0xc5,0xb0 == th.lurhu a0, a1, a2, 0 +0x0b,0xc5,0xc5,0x12 == th.lurb a0, a1, a2, 1 +0x0b,0xc5,0xc5,0x94 == th.lurbu a0, a1, a2, 2 +0x0b,0xd5,0xc5,0x50 == th.surw a0, a1, a2, 0 +0x0b,0xd5,0xc5,0x32 == th.surh a0, a1, a2, 1 +0x0b,0xd5,0xc5,0x14 == th.surb a0, a1, a2, 2 \ No newline at end of file diff --git a/suite/MC/RISCV/rv32xtheadmempair_valid_riscv32_riscv_xtheadmempair.txt.cs b/suite/MC/RISCV/rv32xtheadmempair_valid_riscv32_riscv_xtheadmempair.txt.cs new file mode 100644 index 0000000000..ade40e94f1 --- /dev/null +++ b/suite/MC/RISCV/rv32xtheadmempair_valid_riscv32_riscv_xtheadmempair.txt.cs @@ -0,0 +1,4 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32"|"CS_MODE_RISCV_XTHEADMEMPAIR", None +0x0b,0x45,0xb6,0xe2 == th.lwd a0, a1, (a2), 1, 3 +0x0b,0x45,0xb6,0xf4 == th.lwud a0, a1, (a2), 2, 3 +0x0b,0x55,0xb6,0xe0 == th.swd a0, a1, (a2), 0, 3 \ No newline at end of file diff --git a/suite/MC/RISCV/rv32zaamo_valid_riscv32_riscv_a_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rv32zaamo_valid_riscv32_riscv_a_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..68639910db --- /dev/null +++ b/suite/MC/RISCV/rv32zaamo_valid_riscv32_riscv_a_syntax_no_alias_text.txt.cs @@ -0,0 +1,37 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32"|"CS_MODE_RISCV_A", None +0x2f,0x27,0x14,0x08 == amoswap.w a4, ra, (s0) +0xaf,0xa5,0xc6,0x00 == amoadd.w a1, a2, (a3) +0x2f,0x26,0xd7,0x20 == amoxor.w a2, a3, (a4) +0xaf,0xa6,0xe7,0x60 == amoand.w a3, a4, (a5) +0x2f,0x27,0xf8,0x40 == amoor.w a4, a5, (a6) +0xaf,0xa7,0x08,0x81 == amomin.w a5, a6, (a7) +0xaf,0xab,0x6a,0xa1 == amomax.w s7, s6, (s5) +0x2f,0x2b,0x5a,0xc1 == amominu.w s6, s5, (s4) +0xaf,0xaa,0x49,0xe1 == amomaxu.w s5, s4, (s3) +0x2f,0x27,0x14,0x0c == amoswap.w.aq a4, ra, (s0) +0xaf,0xa5,0xc6,0x04 == amoadd.w.aq a1, a2, (a3) +0x2f,0x26,0xd7,0x24 == amoxor.w.aq a2, a3, (a4) +0xaf,0xa6,0xe7,0x64 == amoand.w.aq a3, a4, (a5) +0x2f,0x27,0xf8,0x44 == amoor.w.aq a4, a5, (a6) +0xaf,0xa7,0x08,0x85 == amomin.w.aq a5, a6, (a7) +0xaf,0xab,0x6a,0xa5 == amomax.w.aq s7, s6, (s5) +0x2f,0x2b,0x5a,0xc5 == amominu.w.aq s6, s5, (s4) +0xaf,0xaa,0x49,0xe5 == amomaxu.w.aq s5, s4, (s3) +0x2f,0x27,0x14,0x0a == amoswap.w.rl a4, ra, (s0) +0xaf,0xa5,0xc6,0x02 == amoadd.w.rl a1, a2, (a3) +0x2f,0x26,0xd7,0x22 == amoxor.w.rl a2, a3, (a4) +0xaf,0xa6,0xe7,0x62 == amoand.w.rl a3, a4, (a5) +0x2f,0x27,0xf8,0x42 == amoor.w.rl a4, a5, (a6) +0xaf,0xa7,0x08,0x83 == amomin.w.rl a5, a6, (a7) +0xaf,0xab,0x6a,0xa3 == amomax.w.rl s7, s6, (s5) +0x2f,0x2b,0x5a,0xc3 == amominu.w.rl s6, s5, (s4) +0xaf,0xaa,0x49,0xe3 == amomaxu.w.rl s5, s4, (s3) +0x2f,0x27,0x14,0x0e == amoswap.w.aqrl a4, ra, (s0) +0xaf,0xa5,0xc6,0x06 == amoadd.w.aqrl a1, a2, (a3) +0x2f,0x26,0xd7,0x26 == amoxor.w.aqrl a2, a3, (a4) +0xaf,0xa6,0xe7,0x66 == amoand.w.aqrl a3, a4, (a5) +0x2f,0x27,0xf8,0x46 == amoor.w.aqrl a4, a5, (a6) +0xaf,0xa7,0x08,0x87 == amomin.w.aqrl a5, a6, (a7) +0xaf,0xab,0x6a,0xa7 == amomax.w.aqrl s7, s6, (s5) +0x2f,0x2b,0x5a,0xc7 == amominu.w.aqrl s6, s5, (s4) +0xaf,0xaa,0x49,0xe7 == amomaxu.w.aqrl s5, s4, (s3) \ No newline at end of file diff --git a/suite/MC/RISCV/rv32zacas_valid_riscv32_experimental_zacas_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rv32zacas_valid_riscv32_experimental_zacas_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..6b98adc139 --- /dev/null +++ b/suite/MC/RISCV/rv32zacas_valid_riscv32_experimental_zacas_syntax_no_alias_text.txt.cs @@ -0,0 +1,11 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32", None +0xaf,0xa5,0xd7,0x28 == amocas.w a1, a3, (a5) +0x2f,0xa0,0x07,0x28 == amocas.w zero, zero, (a5) +0x2f,0xa0,0x07,0x2c == amocas.w.aq zero, zero, (a5) +0x2f,0xa0,0x07,0x2a == amocas.w.rl zero, zero, (a5) +0x2f,0xa0,0x07,0x2e == amocas.w.aqrl zero, zero, (a5) +0x2f,0xb5,0xc5,0x28 == amocas.d a0, a2, (a1) +0x2f,0xb0,0x05,0x28 == amocas.d zero, zero, (a1) +0x2f,0xb0,0x05,0x2c == amocas.d.aq zero, zero, (a1) +0x2f,0xb0,0x05,0x2a == amocas.d.rl zero, zero, (a1) +0x2f,0xb0,0x05,0x2e == amocas.d.aqrl zero, zero, (a1) \ No newline at end of file diff --git a/suite/MC/RISCV/rv32zalrsc_valid_riscv32_riscv_a_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rv32zalrsc_valid_riscv32_riscv_a_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..ca6aee3b3c --- /dev/null +++ b/suite/MC/RISCV/rv32zalrsc_valid_riscv32_riscv_a_syntax_no_alias_text.txt.cs @@ -0,0 +1,9 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32"|"CS_MODE_RISCV_A", None +0xaf,0x22,0x03,0x10 == lr.w t0, (t1) +0x2f,0xa3,0x03,0x14 == lr.w.aq t1, (t2) +0xaf,0x23,0x0e,0x12 == lr.w.rl t2, (t3) +0x2f,0xae,0x0e,0x16 == lr.w.aqrl t3, (t4) +0xaf,0xaf,0xee,0x19 == sc.w t6, t5, (t4) +0x2f,0x2f,0xde,0x1d == sc.w.aq t5, t4, (t3) +0xaf,0xae,0xc3,0x1b == sc.w.rl t4, t3, (t2) +0x2f,0x2e,0x73,0x1e == sc.w.aqrl t3, t2, (t1) \ No newline at end of file diff --git a/suite/MC/RISCV/rv32zba_valid_riscv32_riscv_zba.txt.cs b/suite/MC/RISCV/rv32zba_valid_riscv32_riscv_zba.txt.cs new file mode 100644 index 0000000000..ea2a620746 --- /dev/null +++ b/suite/MC/RISCV/rv32zba_valid_riscv32_riscv_zba.txt.cs @@ -0,0 +1,4 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32"|"CS_MODE_RISCV_ZBA", None +0xb3,0x22,0x73,0x20 == sh1add t0, t1, t2 +0xb3,0x42,0x73,0x20 == sh2add t0, t1, t2 +0xb3,0x62,0x73,0x20 == sh3add t0, t1, t2 \ No newline at end of file diff --git a/suite/MC/RISCV/rv32zbb_only_valid_riscv32_riscv_zbb_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rv32zbb_only_valid_riscv32_riscv_zbb_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..a683d3f35e --- /dev/null +++ b/suite/MC/RISCV/rv32zbb_only_valid_riscv32_riscv_zbb_syntax_no_alias_text.txt.cs @@ -0,0 +1,5 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32"|"CS_MODE_RISCV_ZBB", None +0xb3,0x42,0x03,0x08 == zext.h t0, t1 +0x93,0x52,0xf3,0x61 == rori t0, t1, 31 +0x93,0x52,0x03,0x60 == rori t0, t1, 0 +0x93,0x52,0x83,0x69 == rev8 t0, t1 \ No newline at end of file diff --git a/suite/MC/RISCV/rv32zbb_valid_riscv32_riscv_zbb_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rv32zbb_valid_riscv32_riscv_zbb_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..52cf63be69 --- /dev/null +++ b/suite/MC/RISCV/rv32zbb_valid_riscv32_riscv_zbb_syntax_no_alias_text.txt.cs @@ -0,0 +1,16 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32"|"CS_MODE_RISCV_ZBB", None +0x93,0x12,0x03,0x60 == clz t0, t1 +0x93,0x12,0x13,0x60 == ctz t0, t1 +0x93,0x12,0x23,0x60 == cpop t0, t1 +0x93,0x12,0x43,0x60 == sext.b t0, t1 +0x93,0x12,0x53,0x60 == sext.h t0, t1 +0xb3,0x42,0x73,0x0a == min t0, t1, t2 +0xb3,0x52,0x73,0x0a == minu t0, t1, t2 +0xb3,0x62,0x73,0x0a == max t0, t1, t2 +0xb3,0x72,0x73,0x0a == maxu t0, t1, t2 +0xb3,0x72,0x73,0x40 == andn t0, t1, t2 +0xb3,0x62,0x73,0x40 == orn t0, t1, t2 +0xb3,0x42,0x73,0x40 == xnor t0, t1, t2 +0xb3,0x12,0x73,0x60 == rol t0, t1, t2 +0xb3,0x52,0x73,0x60 == ror t0, t1, t2 +0x93,0x52,0x73,0x28 == orc.b t0, t1 \ No newline at end of file diff --git a/suite/MC/RISCV/rv32zbc_valid_riscv32_riscv_zbc.txt.cs b/suite/MC/RISCV/rv32zbc_valid_riscv32_riscv_zbc.txt.cs new file mode 100644 index 0000000000..09bbf5abf2 --- /dev/null +++ b/suite/MC/RISCV/rv32zbc_valid_riscv32_riscv_zbc.txt.cs @@ -0,0 +1,4 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32"|"CS_MODE_RISCV_ZBC", None +0xb3,0x12,0x73,0x0a == clmul t0, t1, t2 +0xb3,0x22,0x73,0x0a == clmulr t0, t1, t2 +0xb3,0x32,0x73,0x0a == clmulh t0, t1, t2 \ No newline at end of file diff --git a/suite/MC/RISCV/rv32zbkb_only_valid_riscv32_riscv_zbkb.txt.cs b/suite/MC/RISCV/rv32zbkb_only_valid_riscv32_riscv_zbkb.txt.cs new file mode 100644 index 0000000000..65eb85dff7 --- /dev/null +++ b/suite/MC/RISCV/rv32zbkb_only_valid_riscv32_riscv_zbkb.txt.cs @@ -0,0 +1,4 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32"|"CS_MODE_RISCV_ZBKB", None +0x93,0x52,0x83,0x69 == rev8 t0, t1 +0x93,0x12,0xf3,0x08 == zip t0, t1 +0x93,0x52,0xf3,0x08 == unzip t0, t1 \ No newline at end of file diff --git a/suite/MC/RISCV/rv32zbkb_valid_riscv32_riscv_zbkb.txt.cs b/suite/MC/RISCV/rv32zbkb_valid_riscv32_riscv_zbkb.txt.cs new file mode 100644 index 0000000000..e784bc8f95 --- /dev/null +++ b/suite/MC/RISCV/rv32zbkb_valid_riscv32_riscv_zbkb.txt.cs @@ -0,0 +1,12 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32"|"CS_MODE_RISCV_ZBKB", None +0xb3,0x52,0x73,0x60 == ror t0, t1, t2 +0xb3,0x12,0x73,0x60 == rol t0, t1, t2 +0x93,0x52,0xf3,0x61 == rori t0, t1, 31 +0x93,0x52,0x03,0x60 == rori t0, t1, 0 +0xb3,0x72,0x73,0x40 == andn t0, t1, t2 +0xb3,0x62,0x73,0x40 == orn t0, t1, t2 +0xb3,0x42,0x73,0x40 == xnor t0, t1, t2 +0xb3,0x42,0x73,0x08 == pack t0, t1, t2 +0xb3,0x42,0x03,0x08 == pack t0, t1, zero +0xb3,0x72,0x73,0x08 == packh t0, t1, t2 +0x93,0x52,0x73,0x68 == brev8 t0, t1 \ No newline at end of file diff --git a/suite/MC/RISCV/rv32zbkc_valid_riscv32_riscv_zbkc.txt.cs b/suite/MC/RISCV/rv32zbkc_valid_riscv32_riscv_zbkc.txt.cs new file mode 100644 index 0000000000..82978b6afc --- /dev/null +++ b/suite/MC/RISCV/rv32zbkc_valid_riscv32_riscv_zbkc.txt.cs @@ -0,0 +1,3 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32"|"CS_MODE_RISCV_ZBKC", None +0xb3,0x12,0x73,0x0a == clmul t0, t1, t2 +0xb3,0x32,0x73,0x0a == clmulh t0, t1, t2 \ No newline at end of file diff --git a/suite/MC/RISCV/rv32zbkx_valid_riscv32_riscv_zbkx.txt.cs b/suite/MC/RISCV/rv32zbkx_valid_riscv32_riscv_zbkx.txt.cs new file mode 100644 index 0000000000..e54710837f --- /dev/null +++ b/suite/MC/RISCV/rv32zbkx_valid_riscv32_riscv_zbkx.txt.cs @@ -0,0 +1,3 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32"|"CS_MODE_RISCV_ZBKX", None +0xb3,0x42,0x73,0x28 == xperm8 t0, t1, t2 +0xb3,0x22,0x73,0x28 == xperm4 t0, t1, t2 \ No newline at end of file diff --git a/suite/MC/RISCV/rv32zbs_valid_riscv32_riscv_zbs.txt.cs b/suite/MC/RISCV/rv32zbs_valid_riscv32_riscv_zbs.txt.cs new file mode 100644 index 0000000000..18f2a4da7e --- /dev/null +++ b/suite/MC/RISCV/rv32zbs_valid_riscv32_riscv_zbs.txt.cs @@ -0,0 +1,9 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32"|"CS_MODE_RISCV_ZBS", None +0xb3,0x12,0x73,0x48 == bclr t0, t1, t2 +0xb3,0x12,0x73,0x28 == bset t0, t1, t2 +0xb3,0x12,0x73,0x68 == binv t0, t1, t2 +0xb3,0x52,0x73,0x48 == bext t0, t1, t2 +0x93,0x12,0x13,0x48 == bclri t0, t1, 1 +0x93,0x12,0x13,0x28 == bseti t0, t1, 1 +0x93,0x12,0x13,0x68 == binvi t0, t1, 1 +0x93,0x52,0x13,0x48 == bexti t0, t1, 1 \ No newline at end of file diff --git a/suite/MC/RISCV/rv32zcb_valid_riscv32_m_riscv_zbb_riscv_zba__zcb_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rv32zcb_valid_riscv32_m_riscv_zbb_riscv_zba__zcb_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..f375ab0d1c --- /dev/null +++ b/suite/MC/RISCV/rv32zcb_valid_riscv32_m_riscv_zbb_riscv_zba__zcb_syntax_no_alias_text.txt.cs @@ -0,0 +1,17 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32"|"CS_MODE_RISCV_ZBB"|"CS_MODE_RISCV_ZBA", None +0x61,0x9c == c.zext.b s0 +0x65,0x9c == c.sext.b s0 +0x69,0x9c == c.zext.h s0 +0x6d,0x9c == c.sext.h s0 +0x75,0x9c == c.not s0 +0x45,0x9c == c.mul s0, s1 +0x3c,0x83 == c.lbu a5, 2(a4) +0x3c,0x87 == c.lhu a5, 2(a4) +0x7c,0x87 == c.lh a5, 2(a4) +0x3c,0x8b == c.sb a5, 2(a4) +0x3c,0x8f == c.sh a5, 2(a4) +0x80,0x80 == c.lbu s0, 0(s1) +0x80,0x84 == c.lhu s0, 0(s1) +0xc0,0x84 == c.lh s0, 0(s1) +0x80,0x88 == c.sb s0, 0(s1) +0x80,0x8c == c.sh s0, 0(s1) \ No newline at end of file diff --git a/suite/MC/RISCV/rv32zcmp_valid_riscv32_riscv_zcmp_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rv32zcmp_valid_riscv32_riscv_zcmp_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..777abb6dfe --- /dev/null +++ b/suite/MC/RISCV/rv32zcmp_valid_riscv32_riscv_zcmp_syntax_no_alias_text.txt.cs @@ -0,0 +1,38 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32"|"CS_MODE_RISCV_ZCMP", None +0xa2,0xac == cm.mvsa01 s1, s0 +0xe2,0xac == cm.mva01s s1, s0 +0x62,0xac == cm.mva01s s0, s0 +0x42,0xbe == cm.popret {ra}, 16 +0x46,0xbe == cm.popret {ra}, 32 +0x5e,0xbe == cm.popret {ra, s0}, 64 +0x62,0xbe == cm.popret {ra, s0-s1}, 16 +0x76,0xbe == cm.popret {ra, s0-s2}, 32 +0x82,0xbe == cm.popret {ra, s0-s3}, 32 +0xa2,0xbe == cm.popret {ra, s0-s5}, 32 +0xc2,0xbe == cm.popret {ra, s0-s7}, 48 +0xfe,0xbe == cm.popret {ra, s0-s11}, 112 +0x42,0xbc == cm.popretz {ra}, 16 +0x46,0xbc == cm.popretz {ra}, 32 +0x5e,0xbc == cm.popretz {ra, s0}, 64 +0x62,0xbc == cm.popretz {ra, s0-s1}, 16 +0x76,0xbc == cm.popretz {ra, s0-s2}, 32 +0x82,0xbc == cm.popretz {ra, s0-s3}, 32 +0xa2,0xbc == cm.popretz {ra, s0-s5}, 32 +0xc2,0xbc == cm.popretz {ra, s0-s7}, 48 +0xfe,0xbc == cm.popretz {ra, s0-s11}, 112 +0x42,0xba == cm.pop {ra}, 16 +0x46,0xba == cm.pop {ra}, 32 +0x52,0xba == cm.pop {ra, s0}, 16 +0x66,0xba == cm.pop {ra, s0-s1}, 32 +0x76,0xba == cm.pop {ra, s0-s2}, 32 +0xa2,0xba == cm.pop {ra, s0-s5}, 32 +0xc2,0xba == cm.pop {ra, s0-s7}, 48 +0xf2,0xba == cm.pop {ra, s0-s11}, 64 +0x42,0xb8 == cm.push {ra}, -16 +0x56,0xb8 == cm.push {ra, s0}, -32 +0x62,0xb8 == cm.push {ra, s0-s1}, -16 +0x82,0xb8 == cm.push {ra, s0-s3}, -32 +0xc2,0xb8 == cm.push {ra, s0-s7}, -48 +0xc6,0xb8 == cm.push {ra, s0-s7}, -64 +0xf6,0xb8 == cm.push {ra, s0-s11}, -80 +0xfe,0xb8 == cm.push {ra, s0-s11}, -112 \ No newline at end of file diff --git a/suite/MC/RISCV/rv32zcmt_valid_riscv32_riscv_zcmt_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rv32zcmt_valid_riscv32_riscv_zcmt_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..4b49a6afac --- /dev/null +++ b/suite/MC/RISCV/rv32zcmt_valid_riscv32_riscv_zcmt_syntax_no_alias_text.txt.cs @@ -0,0 +1,3 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32"|"CS_MODE_RISCV_ZCMT", None +0x06,0xa0 == cm.jt 1 +0x82,0xa0 == cm.jalt 32 \ No newline at end of file diff --git a/suite/MC/RISCV/rv32zdinx_valid_riscv32_riscv_zdinx_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rv32zdinx_valid_riscv32_riscv_zdinx_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..d85549158a --- /dev/null +++ b/suite/MC/RISCV/rv32zdinx_valid_riscv32_riscv_zdinx_syntax_no_alias_text.txt.cs @@ -0,0 +1,38 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32"|"CS_MODE_RISCV_ZDINX", None +0x43,0x75,0xe6,0x82 == fmadd.d a0, a2, a4, a6, dyn +0x47,0x75,0xe6,0x82 == fmsub.d a0, a2, a4, a6, dyn +0x4b,0x75,0xe6,0x82 == fnmsub.d a0, a2, a4, a6, dyn +0x4f,0x75,0xe6,0x82 == fnmadd.d a0, a2, a4, a6, dyn +0x53,0x7d,0xee,0x03 == fadd.d s10, t3, t5, dyn +0x53,0x7d,0xee,0x0b == fsub.d s10, t3, t5, dyn +0x53,0x7d,0xee,0x13 == fmul.d s10, t3, t5, dyn +0x53,0x7d,0xee,0x1b == fdiv.d s10, t3, t5, dyn +0x53,0x7a,0x0b,0x5a == fsqrt.d s4, s6, dyn +0x53,0x0d,0xee,0x23 == fsgnj.d s10, t3, t5 +0x53,0x1d,0xee,0x23 == fsgnjn.d s10, t3, t5 +0x53,0x2d,0xee,0x23 == fsgnjx.d s10, t3, t5 +0x53,0x0d,0xee,0x2b == fmin.d s10, t3, t5 +0x53,0x1d,0xee,0x2b == fmax.d s10, t3, t5 +0x53,0x7d,0x1e,0x40 == fcvt.s.d s10, t3, dyn +0x53,0x0d,0x0e,0x42 == fcvt.d.s s10, t3 +0x53,0x3d,0x0e,0x42 == fcvt.d.s s10, t3, rup +0x53,0x2d,0xee,0xa3 == feq.d s10, t3, t5 +0x53,0x1d,0xee,0xa3 == flt.d s10, t3, t5 +0x53,0x0d,0xee,0xa3 == fle.d s10, t3, t5 +0x53,0x1d,0x0e,0xe2 == fclass.d s10, t3 +0x53,0x7a,0x0b,0xc2 == fcvt.w.d s4, s6, dyn +0x53,0x0d,0x0e,0xd2 == fcvt.d.w s10, t3 +0x53,0x3d,0x0e,0xd2 == fcvt.d.w s10, t3, rup +0x53,0x0d,0x1e,0xd2 == fcvt.d.wu s10, t3 +0x53,0x3d,0x1e,0xd2 == fcvt.d.wu s10, t3, rup +0x43,0x05,0xe6,0x82 == fmadd.d a0, a2, a4, a6, rne +0x47,0x15,0xe6,0x82 == fmsub.d a0, a2, a4, a6, rtz +0x4b,0x25,0xe6,0x82 == fnmsub.d a0, a2, a4, a6, rdn +0x4f,0x35,0xe6,0x82 == fnmadd.d a0, a2, a4, a6, rup +0x53,0x4d,0xee,0x03 == fadd.d s10, t3, t5, rmm +0x53,0x0d,0xee,0x13 == fmul.d s10, t3, t5, rne +0x53,0x1d,0xee,0x1b == fdiv.d s10, t3, t5, rtz +0x53,0x2a,0x0b,0x5a == fsqrt.d s4, s6, rdn +0x53,0x3a,0x1b,0x40 == fcvt.s.d s4, s6, rup +0x53,0x4a,0x0b,0xc2 == fcvt.w.d s4, s6, rmm +0x53,0x7a,0x1b,0xc2 == fcvt.wu.d s4, s6, dyn \ No newline at end of file diff --git a/suite/MC/RISCV/rv32zfa_only_valid_riscv32_zfa_riscv_d__zfh_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rv32zfa_only_valid_riscv32_zfa_riscv_d__zfh_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..c82c543a2d --- /dev/null +++ b/suite/MC/RISCV/rv32zfa_only_valid_riscv32_zfa_riscv_d__zfh_syntax_no_alias_text.txt.cs @@ -0,0 +1,3 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32"|"CS_MODE_RISCV_D", None +0xd3,0x85,0x14,0xe2 == fmvh.x.d a1, fs1 +0xd3,0x84,0xc5,0xb2 == fmvp.d.x fs1, a1, a2 \ No newline at end of file diff --git a/suite/MC/RISCV/rv32zfbfmin_valid_riscv32_experimental_zfbfmin_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rv32zfbfmin_valid_riscv32_experimental_zfbfmin_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..b14297c79d --- /dev/null +++ b/suite/MC/RISCV/rv32zfbfmin_valid_riscv32_experimental_zfbfmin_syntax_no_alias_text.txt.cs @@ -0,0 +1,15 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32", None +0x07,0x10,0xc5,0x00 == flh ft0, 12(a0) +0x87,0x90,0x40,0x00 == flh ft1, 4(ra) +0x07,0x91,0x06,0x80 == flh ft2, -2048(a3) +0x87,0x91,0x04,0x80 == flh ft3, -2048(s1) +0x07,0x12,0xf9,0x7f == flh ft4, 2047(s2) +0x87,0x92,0x09,0x00 == flh ft5, 0(s3) +0xa7,0x1f,0x6a,0x7e == fsh ft6, 2047(s4) +0x27,0x90,0x7a,0x80 == fsh ft7, -2048(s5) +0x27,0x10,0x8b,0x80 == fsh fs0, -2048(s6) +0xa7,0x93,0x9b,0x3e == fsh fs1, 999(s7) +0x53,0x86,0x0b,0xe4 == fmv.x.h a2, fs7 +0xd3,0x00,0x08,0xf4 == fmv.h.x ft1, a6 +0x53,0x75,0x60,0x40 == fcvt.s.bf16 fa0, ft0, dyn +0x53,0x71,0x86,0x44 == fcvt.bf16.s ft2, fa2, dyn \ No newline at end of file diff --git a/suite/MC/RISCV/rv32zfh_valid_riscv32_zfh_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rv32zfh_valid_riscv32_zfh_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..ea2132c468 --- /dev/null +++ b/suite/MC/RISCV/rv32zfh_valid_riscv32_zfh_syntax_no_alias_text.txt.cs @@ -0,0 +1,49 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32", None +0x07,0x10,0xc5,0x00 == flh ft0, 12(a0) +0x87,0x90,0x40,0x00 == flh ft1, 4(ra) +0x07,0x91,0x06,0x80 == flh ft2, -2048(a3) +0x87,0x91,0x04,0x80 == flh ft3, -2048(s1) +0x07,0x12,0xf9,0x7f == flh ft4, 2047(s2) +0x87,0x92,0x09,0x00 == flh ft5, 0(s3) +0xa7,0x1f,0x6a,0x7e == fsh ft6, 2047(s4) +0x27,0x90,0x7a,0x80 == fsh ft7, -2048(s5) +0x27,0x10,0x8b,0x80 == fsh fs0, -2048(s6) +0xa7,0x93,0x9b,0x3e == fsh fs1, 999(s7) +0x43,0xf5,0xc5,0x6c == fmadd.h fa0, fa1, fa2, fa3, dyn +0x47,0xf7,0x07,0x8d == fmsub.h fa4, fa5, fa6, fa7, dyn +0x4b,0xf9,0x49,0xad == fnmsub.h fs2, fs3, fs4, fs5, dyn +0x4f,0xfb,0x8b,0xcd == fnmadd.h fs6, fs7, fs8, fs9, dyn +0x53,0xfd,0xcd,0x05 == fadd.h fs10, fs11, ft8, dyn +0xd3,0x7e,0xff,0x0d == fsub.h ft9, ft10, ft11, dyn +0x53,0xf0,0x20,0x14 == fmul.h ft0, ft1, ft2, dyn +0xd3,0x71,0x52,0x1c == fdiv.h ft3, ft4, ft5, dyn +0x53,0xf3,0x03,0x5c == fsqrt.h ft6, ft7, dyn +0xd3,0x04,0xb5,0x24 == fsgnj.h fs1, fa0, fa1 +0xd3,0x95,0xe6,0x24 == fsgnjn.h fa1, fa3, fa4 +0x53,0xa7,0xc6,0x24 == fsgnjx.h fa4, fa3, fa2 +0xd3,0x07,0x18,0x2d == fmin.h fa5, fa6, fa7 +0x53,0x99,0x49,0x2d == fmax.h fs2, fs3, fs4 +0x53,0xf5,0x0a,0xc4 == fcvt.w.h a0, fs5, dyn +0xd3,0x75,0x1b,0xc4 == fcvt.wu.h a1, fs6, dyn +0x53,0x86,0x0b,0xe4 == fmv.x.h a2, fs7 +0xd3,0x25,0x9c,0xa5 == feq.h a1, fs8, fs9 +0x53,0x16,0xbd,0xa5 == flt.h a2, fs10, fs11 +0xd3,0x06,0xde,0xa5 == fle.h a3, ft8, ft9 +0xd3,0x16,0x0f,0xe4 == fclass.h a3, ft10 +0xd3,0x7f,0x07,0xd4 == fcvt.h.w ft11, a4, dyn +0x53,0xf0,0x17,0xd4 == fcvt.h.wu ft0, a5, dyn +0xd3,0x00,0x08,0xf4 == fmv.h.x ft1, a6 +0x43,0x85,0xc5,0x6c == fmadd.h fa0, fa1, fa2, fa3, rne +0x47,0x97,0x07,0x8d == fmsub.h fa4, fa5, fa6, fa7, rtz +0x4b,0xa9,0x49,0xad == fnmsub.h fs2, fs3, fs4, fs5, rdn +0x4f,0xbb,0x8b,0xcd == fnmadd.h fs6, fs7, fs8, fs9, rup +0x43,0xc5,0xc5,0x6c == fmadd.h fa0, fa1, fa2, fa3, rmm +0x53,0x8d,0xcd,0x05 == fadd.h fs10, fs11, ft8, rne +0xd3,0x1e,0xff,0x0d == fsub.h ft9, ft10, ft11, rtz +0x53,0xa0,0x20,0x14 == fmul.h ft0, ft1, ft2, rdn +0xd3,0x31,0x52,0x1c == fdiv.h ft3, ft4, ft5, rup +0x53,0xc3,0x03,0x5c == fsqrt.h ft6, ft7, rmm +0x53,0xb5,0x0a,0xc4 == fcvt.w.h a0, fs5, rup +0xd3,0x25,0x1b,0xc4 == fcvt.wu.h a1, fs6, rdn +0xd3,0x1f,0x07,0xd4 == fcvt.h.w ft11, a4, rtz +0x53,0x80,0x17,0xd4 == fcvt.h.wu ft0, a5, rne \ No newline at end of file diff --git a/suite/MC/RISCV/rv32zfhmin_valid_riscv32_zfhmin_riscv_d_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rv32zfhmin_valid_riscv32_zfhmin_riscv_d_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..bed608df77 --- /dev/null +++ b/suite/MC/RISCV/rv32zfhmin_valid_riscv32_zfhmin_riscv_d_syntax_no_alias_text.txt.cs @@ -0,0 +1,19 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32"|"CS_MODE_RISCV_D", None +0x07,0x10,0xc5,0x00 == flh ft0, 12(a0) +0x87,0x90,0x40,0x00 == flh ft1, 4(ra) +0x07,0x91,0x06,0x80 == flh ft2, -2048(a3) +0x87,0x91,0x04,0x80 == flh ft3, -2048(s1) +0x07,0x12,0xf9,0x7f == flh ft4, 2047(s2) +0x87,0x92,0x09,0x00 == flh ft5, 0(s3) +0xa7,0x1f,0x6a,0x7e == fsh ft6, 2047(s4) +0x27,0x90,0x7a,0x80 == fsh ft7, -2048(s5) +0x27,0x10,0x8b,0x80 == fsh fs0, -2048(s6) +0xa7,0x93,0x9b,0x3e == fsh fs1, 999(s7) +0x53,0x86,0x0b,0xe4 == fmv.x.h a2, fs7 +0xd3,0x00,0x08,0xf4 == fmv.h.x ft1, a6 +0x53,0x05,0x20,0x40 == fcvt.s.h fa0, ft0 +0x53,0x35,0x20,0x40 == fcvt.s.h fa0, ft0, rup +0x53,0x71,0x06,0x44 == fcvt.h.s ft2, fa2, dyn +0x53,0x05,0x20,0x42 == fcvt.d.h fa0, ft0 +0x53,0x35,0x20,0x42 == fcvt.d.h fa0, ft0, rup +0x53,0x71,0x16,0x44 == fcvt.h.d ft2, fa2, dyn \ No newline at end of file diff --git a/suite/MC/RISCV/rv32zfinx_valid_riscv32_riscv_zfinx_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rv32zfinx_valid_riscv32_riscv_zfinx_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..b2f8a88f48 --- /dev/null +++ b/suite/MC/RISCV/rv32zfinx_valid_riscv32_riscv_zfinx_syntax_no_alias_text.txt.cs @@ -0,0 +1,37 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32"|"CS_MODE_RISCV_ZFINX", None +0x43,0xf5,0xc5,0x68 == fmadd.s a0, a1, a2, a3, dyn +0x47,0xf7,0x07,0x89 == fmsub.s a4, a5, a6, a7, dyn +0x4b,0xf9,0x49,0xa9 == fnmsub.s s2, s3, s4, s5, dyn +0x4f,0xfb,0x8b,0xc9 == fnmadd.s s6, s7, s8, s9, dyn +0x53,0xfd,0xcd,0x01 == fadd.s s10, s11, t3, dyn +0xd3,0x7e,0xff,0x09 == fsub.s t4, t5, t6, dyn +0x53,0xf4,0x24,0x11 == fmul.s s0, s1, s2, dyn +0xd3,0x79,0x5a,0x19 == fdiv.s s3, s4, s5, dyn +0x53,0xf3,0x03,0x58 == fsqrt.s t1, t2, dyn +0xd3,0x04,0xb5,0x20 == fsgnj.s s1, a0, a1 +0xd3,0x95,0xe6,0x20 == fsgnjn.s a1, a3, a4 +0x53,0xa7,0xc6,0x20 == fsgnjx.s a4, a3, a2 +0xd3,0x07,0x18,0x29 == fmin.s a5, a6, a7 +0x53,0x99,0x49,0x29 == fmax.s s2, s3, s4 +0x53,0xf5,0x0a,0xc0 == fcvt.w.s a0, s5, dyn +0xd3,0x75,0x1b,0xc0 == fcvt.wu.s a1, s6, dyn +0xd3,0x25,0x9c,0xa1 == feq.s a1, s8, s9 +0x53,0x16,0xbd,0xa1 == flt.s a2, s10, s11 +0xd3,0x06,0xde,0xa1 == fle.s a3, t3, t4 +0xd3,0x16,0x0f,0xe0 == fclass.s a3, t5 +0xd3,0x7f,0x07,0xd0 == fcvt.s.w t6, a4, dyn +0x53,0xf4,0x17,0xd0 == fcvt.s.wu s0, a5, dyn +0x43,0x85,0xc5,0x68 == fmadd.s a0, a1, a2, a3, rne +0x47,0x97,0x07,0x89 == fmsub.s a4, a5, a6, a7, rtz +0x4b,0xa9,0x49,0xa9 == fnmsub.s s2, s3, s4, s5, rdn +0x4f,0xbb,0x8b,0xc9 == fnmadd.s s6, s7, s8, s9, rup +0x43,0xc5,0xc5,0x68 == fmadd.s a0, a1, a2, a3, rmm +0x53,0x8d,0xcd,0x01 == fadd.s s10, s11, t3, rne +0xd3,0x1e,0xff,0x09 == fsub.s t4, t5, t6, rtz +0x53,0xa4,0x24,0x11 == fmul.s s0, s1, s2, rdn +0xd3,0x39,0x5a,0x19 == fdiv.s s3, s4, s5, rup +0x53,0xc3,0x03,0x58 == fsqrt.s t1, t2, rmm +0x53,0xb5,0x0a,0xc0 == fcvt.w.s a0, s5, rup +0xd3,0x25,0x1b,0xc0 == fcvt.wu.s a1, s6, rdn +0xd3,0x1f,0x07,0xd0 == fcvt.s.w t6, a4, rtz +0x53,0x84,0x17,0xd0 == fcvt.s.wu s0, a5, rne \ No newline at end of file diff --git a/suite/MC/RISCV/rv32zhinx_valid_riscv32_riscv_zfinx_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rv32zhinx_valid_riscv32_riscv_zfinx_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..639a84d59b --- /dev/null +++ b/suite/MC/RISCV/rv32zhinx_valid_riscv32_riscv_zfinx_syntax_no_alias_text.txt.cs @@ -0,0 +1,37 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32"|"CS_MODE_RISCV_ZFINX", None +0x43,0xf5,0xc5,0x6c == fmadd.h a0, a1, a2, a3, dyn +0x47,0xf7,0x07,0x8d == fmsub.h a4, a5, a6, a7, dyn +0x4b,0xf9,0x49,0xad == fnmsub.h s2, s3, s4, s5, dyn +0x4f,0xfb,0x8b,0xcd == fnmadd.h s6, s7, s8, s9, dyn +0x53,0xfd,0xcd,0x05 == fadd.h s10, s11, t3, dyn +0xd3,0x7e,0xff,0x0d == fsub.h t4, t5, t6, dyn +0x53,0xf4,0x24,0x15 == fmul.h s0, s1, s2, dyn +0xd3,0x79,0x5a,0x1d == fdiv.h s3, s4, s5, dyn +0x53,0xfb,0x0b,0x5c == fsqrt.h s6, s7, dyn +0xd3,0x04,0xb5,0x24 == fsgnj.h s1, a0, a1 +0xd3,0x95,0xe6,0x24 == fsgnjn.h a1, a3, a4 +0x53,0xa7,0xc6,0x24 == fsgnjx.h a4, a3, a2 +0xd3,0x07,0x18,0x2d == fmin.h a5, a6, a7 +0x53,0x99,0x49,0x2d == fmax.h s2, s3, s4 +0x53,0xf5,0x0a,0xc4 == fcvt.w.h a0, s5, dyn +0xd3,0x75,0x1b,0xc4 == fcvt.wu.h a1, s6, dyn +0xd3,0x25,0x9c,0xa5 == feq.h a1, s8, s9 +0x53,0x16,0xbd,0xa5 == flt.h a2, s10, s11 +0xd3,0x06,0xde,0xa5 == fle.h a3, t3, t4 +0xd3,0x16,0x0f,0xe4 == fclass.h a3, t5 +0xd3,0x7f,0x07,0xd4 == fcvt.h.w t6, a4, dyn +0x53,0xf4,0x17,0xd4 == fcvt.h.wu s0, a5, dyn +0x43,0x85,0xc5,0x6c == fmadd.h a0, a1, a2, a3, rne +0x47,0x97,0x07,0x8d == fmsub.h a4, a5, a6, a7, rtz +0x4b,0xa9,0x49,0xad == fnmsub.h s2, s3, s4, s5, rdn +0x4f,0xbb,0x8b,0xcd == fnmadd.h s6, s7, s8, s9, rup +0x43,0xc5,0xc5,0x6c == fmadd.h a0, a1, a2, a3, rmm +0x53,0x8d,0xcd,0x05 == fadd.h s10, s11, t3, rne +0xd3,0x1e,0xff,0x0d == fsub.h t4, t5, t6, rtz +0x53,0xa4,0x24,0x15 == fmul.h s0, s1, s2, rdn +0xd3,0x39,0x5a,0x1d == fdiv.h s3, s4, s5, rup +0x53,0xcb,0x0b,0x5c == fsqrt.h s6, s7, rmm +0x53,0xb5,0x0a,0xc4 == fcvt.w.h a0, s5, rup +0xd3,0x25,0x1b,0xc4 == fcvt.wu.h a1, s6, rdn +0xd3,0x1f,0x07,0xd4 == fcvt.h.w t6, a4, rtz +0x53,0x84,0x17,0xd4 == fcvt.h.wu s0, a5, rne \ No newline at end of file diff --git a/suite/MC/RISCV/rv32zhinxmin_valid_riscv32_riscv_zfinx_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rv32zhinxmin_valid_riscv32_riscv_zfinx_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..673129a371 --- /dev/null +++ b/suite/MC/RISCV/rv32zhinxmin_valid_riscv32_riscv_zfinx_syntax_no_alias_text.txt.cs @@ -0,0 +1,4 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32"|"CS_MODE_RISCV_ZFINX", None +0x53,0x85,0x25,0x40 == fcvt.s.h a0, a1 +0x53,0xb5,0x25,0x40 == fcvt.s.h a0, a1, rup +0x53,0xf5,0x05,0x44 == fcvt.h.s a0, a1, dyn \ No newline at end of file diff --git a/suite/MC/RISCV/rv32zicbom_valid_riscv32_zicbom.txt.cs b/suite/MC/RISCV/rv32zicbom_valid_riscv32_zicbom.txt.cs new file mode 100644 index 0000000000..2c592efc50 --- /dev/null +++ b/suite/MC/RISCV/rv32zicbom_valid_riscv32_zicbom.txt.cs @@ -0,0 +1,4 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32", None +0x0f,0xa0,0x12,0x00 == cbo.clean (t0) +0x0f,0x20,0x23,0x00 == cbo.flush (t1) +0x0f,0xa0,0x03,0x00 == cbo.inval (t2) \ No newline at end of file diff --git a/suite/MC/RISCV/rv32zicbop_valid_riscv32_zicbop.txt.cs b/suite/MC/RISCV/rv32zicbop_valid_riscv32_zicbop.txt.cs new file mode 100644 index 0000000000..a65aec1805 --- /dev/null +++ b/suite/MC/RISCV/rv32zicbop_valid_riscv32_zicbop.txt.cs @@ -0,0 +1,9 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32", None +0x13,0xe0,0x02,0x80 == prefetch.i -2048(t0) +0x13,0xe0,0x02,0x7e == prefetch.i 2016(t0) +0x13,0x60,0x13,0x80 == prefetch.r -2048(t1) +0x13,0x60,0x13,0x7e == prefetch.r 2016(t1) +0x13,0xe0,0x33,0x80 == prefetch.w -2048(t2) +0x13,0xe0,0x33,0x7e == prefetch.w 2016(t2) +0x13,0xe5,0x05,0x80 == ori a0, a1, -2048 +0x13,0xe5,0x05,0x00 == ori a0, a1, 0 \ No newline at end of file diff --git a/suite/MC/RISCV/rv32zicboz_valid_riscv32_zicboz.txt.cs b/suite/MC/RISCV/rv32zicboz_valid_riscv32_zicboz.txt.cs new file mode 100644 index 0000000000..7c5a03f749 --- /dev/null +++ b/suite/MC/RISCV/rv32zicboz_valid_riscv32_zicboz.txt.cs @@ -0,0 +1,2 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32", None +0x0f,0xa0,0x42,0x00 == cbo.zero (t0) \ No newline at end of file diff --git a/suite/MC/RISCV/rv32zicond_valid_riscv32_zicond.txt.cs b/suite/MC/RISCV/rv32zicond_valid_riscv32_zicond.txt.cs new file mode 100644 index 0000000000..226e206d58 --- /dev/null +++ b/suite/MC/RISCV/rv32zicond_valid_riscv32_zicond.txt.cs @@ -0,0 +1,3 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32", None +0xb3,0xd2,0x16,0x0e == czero.eqz t0, a3, ra +0xb3,0xf5,0xf1,0x0f == czero.nez a1, gp, t6 \ No newline at end of file diff --git a/suite/MC/RISCV/rv32zihintntl_valid_riscv32_zihintntl_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rv32zihintntl_valid_riscv32_zihintntl_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..d031cb9619 --- /dev/null +++ b/suite/MC/RISCV/rv32zihintntl_valid_riscv32_zihintntl_syntax_no_alias_text.txt.cs @@ -0,0 +1,5 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32", None +0x33,0x00,0x20,0x00 == add zero, zero, sp +0x33,0x00,0x30,0x00 == add zero, zero, gp +0x33,0x00,0x40,0x00 == add zero, zero, tp +0x33,0x00,0x50,0x00 == add zero, zero, t0 \ No newline at end of file diff --git a/suite/MC/RISCV/rv32zihintntlc_valid_riscv32_zihintntl_riscv_c.txt.cs b/suite/MC/RISCV/rv32zihintntlc_valid_riscv32_zihintntl_riscv_c.txt.cs new file mode 100644 index 0000000000..ad936f723d --- /dev/null +++ b/suite/MC/RISCV/rv32zihintntlc_valid_riscv32_zihintntl_riscv_c.txt.cs @@ -0,0 +1,9 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32"|"CS_MODE_RISCV_C", None +0x33,0x00,0x20,0x00 == ntl.p1 +0x33,0x00,0x30,0x00 == ntl.pall +0x33,0x00,0x40,0x00 == ntl.s1 +0x33,0x00,0x50,0x00 == ntl.all +0x0a,0x90 == c.ntl.p1 +0x0e,0x90 == c.ntl.pall +0x12,0x90 == c.ntl.s1 +0x16,0x90 == c.ntl.all \ No newline at end of file diff --git a/suite/MC/RISCV/rv32zihintpause_valid_riscv32_zihintpause_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rv32zihintpause_valid_riscv32_zihintpause_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..63cefaf980 --- /dev/null +++ b/suite/MC/RISCV/rv32zihintpause_valid_riscv32_zihintpause_syntax_no_alias_text.txt.cs @@ -0,0 +1,4 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32", None +0x0f,0x00,0x00,0x01 == fence w, 0 +0x0f,0x00,0x10,0x00 == fence 0, w +0x0f,0x00,0x00,0x00 == fence 0, 0 \ No newline at end of file diff --git a/suite/MC/RISCV/rv32zknd_only_valid_riscv32_zknd.txt.cs b/suite/MC/RISCV/rv32zknd_only_valid_riscv32_zknd.txt.cs new file mode 100644 index 0000000000..190133afa0 --- /dev/null +++ b/suite/MC/RISCV/rv32zknd_only_valid_riscv32_zknd.txt.cs @@ -0,0 +1,3 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32", None +0x33,0x85,0xc5,0xea == aes32dsi a0, a1, a2, 3 +0x33,0x85,0xc5,0xee == aes32dsmi a0, a1, a2, 3 \ No newline at end of file diff --git a/suite/MC/RISCV/rv32zkne_only_valid_riscv32_zkne.txt.cs b/suite/MC/RISCV/rv32zkne_only_valid_riscv32_zkne.txt.cs new file mode 100644 index 0000000000..aaddaeb697 --- /dev/null +++ b/suite/MC/RISCV/rv32zkne_only_valid_riscv32_zkne.txt.cs @@ -0,0 +1,3 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32", None +0x33,0x85,0xc5,0xe2 == aes32esi a0, a1, a2, 3 +0x33,0x85,0xc5,0xe6 == aes32esmi a0, a1, a2, 3 \ No newline at end of file diff --git a/suite/MC/RISCV/rv32zknh_only_valid_riscv32_zknh.txt.cs b/suite/MC/RISCV/rv32zknh_only_valid_riscv32_zknh.txt.cs new file mode 100644 index 0000000000..2ebd9afc55 --- /dev/null +++ b/suite/MC/RISCV/rv32zknh_only_valid_riscv32_zknh.txt.cs @@ -0,0 +1,7 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32", None +0x33,0x85,0xc5,0x5c == sha512sig0h a0, a1, a2 +0x33,0x85,0xc5,0x5e == sha512sig1h a0, a1, a2 +0x33,0x85,0xc5,0x54 == sha512sig0l a0, a1, a2 +0x33,0x85,0xc5,0x56 == sha512sig1l a0, a1, a2 +0x33,0x85,0xc5,0x50 == sha512sum0r a0, a1, a2 +0x33,0x85,0xc5,0x52 == sha512sum1r a0, a1, a2 \ No newline at end of file diff --git a/suite/MC/RISCV/rv32zknh_valid_riscv32_zknh.txt.cs b/suite/MC/RISCV/rv32zknh_valid_riscv32_zknh.txt.cs new file mode 100644 index 0000000000..7b8e4df0b6 --- /dev/null +++ b/suite/MC/RISCV/rv32zknh_valid_riscv32_zknh.txt.cs @@ -0,0 +1,5 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32", None +0x13,0x95,0x25,0x10 == sha256sig0 a0, a1 +0x13,0x95,0x35,0x10 == sha256sig1 a0, a1 +0x13,0x95,0x05,0x10 == sha256sum0 a0, a1 +0x13,0x95,0x15,0x10 == sha256sum1 a0, a1 \ No newline at end of file diff --git a/suite/MC/RISCV/rv32zksed_valid_riscv32_zksed.txt.cs b/suite/MC/RISCV/rv32zksed_valid_riscv32_zksed.txt.cs new file mode 100644 index 0000000000..24b4fec36d --- /dev/null +++ b/suite/MC/RISCV/rv32zksed_valid_riscv32_zksed.txt.cs @@ -0,0 +1,3 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32", None +0x33,0x85,0xc5,0xf0 == sm4ed a0, a1, a2, 3 +0x33,0x85,0xc5,0xf4 == sm4ks a0, a1, a2, 3 \ No newline at end of file diff --git a/suite/MC/RISCV/rv32zksh_valid_riscv32_zksh.txt.cs b/suite/MC/RISCV/rv32zksh_valid_riscv32_zksh.txt.cs new file mode 100644 index 0000000000..525c1fde73 --- /dev/null +++ b/suite/MC/RISCV/rv32zksh_valid_riscv32_zksh.txt.cs @@ -0,0 +1,3 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32", None +0x13,0x95,0x85,0x10 == sm3p0 a0, a1 +0x13,0x95,0x95,0x10 == sm3p1 a0, a1 \ No newline at end of file diff --git a/suite/MC/RISCV/rv64_machine_csr_names_riscv64_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rv64_machine_csr_names_riscv64_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..8e3a800dfd --- /dev/null +++ b/suite/MC/RISCV/rv64_machine_csr_names_riscv64_syntax_no_alias_text.txt.cs @@ -0,0 +1,34 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64", None +0xf3,0x23,0x10,0x3a == csrrs t2, 929, zero +0xf3,0x23,0x30,0x3a == csrrs t2, 931, zero +0xf3,0x23,0x00,0xb8 == csrrs t2, 2944, zero +0xf3,0x23,0x20,0xb8 == csrrs t2, 2946, zero +0xf3,0x23,0x30,0xb8 == csrrs t2, 2947, zero +0xf3,0x23,0x40,0xb8 == csrrs t2, 2948, zero +0xf3,0x23,0x50,0xb8 == csrrs t2, 2949, zero +0xf3,0x23,0x60,0xb8 == csrrs t2, 2950, zero +0xf3,0x23,0x70,0xb8 == csrrs t2, 2951, zero +0xf3,0x23,0x80,0xb8 == csrrs t2, 2952, zero +0xf3,0x23,0x90,0xb8 == csrrs t2, 2953, zero +0xf3,0x23,0xa0,0xb8 == csrrs t2, 2954, zero +0xf3,0x23,0xb0,0xb8 == csrrs t2, 2955, zero +0xf3,0x23,0xc0,0xb8 == csrrs t2, 2956, zero +0xf3,0x23,0xd0,0xb8 == csrrs t2, 2957, zero +0xf3,0x23,0xe0,0xb8 == csrrs t2, 2958, zero +0xf3,0x23,0xf0,0xb8 == csrrs t2, 2959, zero +0xf3,0x23,0x00,0xb9 == csrrs t2, 2960, zero +0xf3,0x23,0x10,0xb9 == csrrs t2, 2961, zero +0xf3,0x23,0x20,0xb9 == csrrs t2, 2962, zero +0xf3,0x23,0x30,0xb9 == csrrs t2, 2963, zero +0xf3,0x23,0x40,0xb9 == csrrs t2, 2964, zero +0xf3,0x23,0x50,0xb9 == csrrs t2, 2965, zero +0xf3,0x23,0x60,0xb9 == csrrs t2, 2966, zero +0xf3,0x23,0x70,0xb9 == csrrs t2, 2967, zero +0xf3,0x23,0x80,0xb9 == csrrs t2, 2968, zero +0xf3,0x23,0x90,0xb9 == csrrs t2, 2969, zero +0xf3,0x23,0xa0,0xb9 == csrrs t2, 2970, zero +0xf3,0x23,0xb0,0xb9 == csrrs t2, 2971, zero +0xf3,0x23,0xc0,0xb9 == csrrs t2, 2972, zero +0xf3,0x23,0xd0,0xb9 == csrrs t2, 2973, zero +0xf3,0x23,0xe0,0xb9 == csrrs t2, 2974, zero +0xf3,0x23,0xf0,0xb9 == csrrs t2, 2975, zero \ No newline at end of file diff --git a/suite/MC/RISCV/rv64_user_csr_names_riscv64_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rv64_user_csr_names_riscv64_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..45cd4d8db0 --- /dev/null +++ b/suite/MC/RISCV/rv64_user_csr_names_riscv64_syntax_no_alias_text.txt.cs @@ -0,0 +1,33 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64", None +0xf3,0x23,0x00,0xc8 == csrrs t2, 3200, zero +0xf3,0x23,0x10,0xc8 == csrrs t2, 3201, zero +0xf3,0x23,0x20,0xc8 == csrrs t2, 3202, zero +0xf3,0x23,0x30,0xc8 == csrrs t2, 3203, zero +0xf3,0x23,0x40,0xc8 == csrrs t2, 3204, zero +0xf3,0x23,0x50,0xc8 == csrrs t2, 3205, zero +0xf3,0x23,0x60,0xc8 == csrrs t2, 3206, zero +0xf3,0x23,0x70,0xc8 == csrrs t2, 3207, zero +0xf3,0x23,0x80,0xc8 == csrrs t2, 3208, zero +0xf3,0x23,0x90,0xc8 == csrrs t2, 3209, zero +0xf3,0x23,0xa0,0xc8 == csrrs t2, 3210, zero +0xf3,0x23,0xb0,0xc8 == csrrs t2, 3211, zero +0xf3,0x23,0xc0,0xc8 == csrrs t2, 3212, zero +0xf3,0x23,0xd0,0xc8 == csrrs t2, 3213, zero +0xf3,0x23,0xe0,0xc8 == csrrs t2, 3214, zero +0xf3,0x23,0xf0,0xc8 == csrrs t2, 3215, zero +0xf3,0x23,0x00,0xc9 == csrrs t2, 3216, zero +0xf3,0x23,0x10,0xc9 == csrrs t2, 3217, zero +0xf3,0x23,0x20,0xc9 == csrrs t2, 3218, zero +0xf3,0x23,0x30,0xc9 == csrrs t2, 3219, zero +0xf3,0x23,0x40,0xc9 == csrrs t2, 3220, zero +0xf3,0x23,0x50,0xc9 == csrrs t2, 3221, zero +0xf3,0x23,0x60,0xc9 == csrrs t2, 3222, zero +0xf3,0x23,0x70,0xc9 == csrrs t2, 3223, zero +0xf3,0x23,0x80,0xc9 == csrrs t2, 3224, zero +0xf3,0x23,0x90,0xc9 == csrrs t2, 3225, zero +0xf3,0x23,0xa0,0xc9 == csrrs t2, 3226, zero +0xf3,0x23,0xb0,0xc9 == csrrs t2, 3227, zero +0xf3,0x23,0xc0,0xc9 == csrrs t2, 3228, zero +0xf3,0x23,0xd0,0xc9 == csrrs t2, 3229, zero +0xf3,0x23,0xe0,0xc9 == csrrs t2, 3230, zero +0xf3,0x23,0xf0,0xc9 == csrrs t2, 3231, zero \ No newline at end of file diff --git a/suite/MC/RISCV/rv64c_hints_valid_riscv64_riscv_c_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rv64c_hints_valid_riscv64_riscv_c_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..ba2d72170a --- /dev/null +++ b/suite/MC/RISCV/rv64c_hints_valid_riscv64_riscv_c_syntax_no_alias_text.txt.cs @@ -0,0 +1,2 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64"|"CS_MODE_RISCV_C", None +0x7e,0x10 == c.slli zero, 63 \ No newline at end of file diff --git a/suite/MC/RISCV/rv64c_valid_riscv64_riscv_c_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rv64c_valid_riscv64_riscv_c_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..7a0020dbf2 --- /dev/null +++ b/suite/MC/RISCV/rv64c_valid_riscv64_riscv_c_syntax_no_alias_text.txt.cs @@ -0,0 +1,12 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64"|"CS_MODE_RISCV_C", None +0x82,0x60 == c.ldsp ra, 0(sp) +0x86,0xff == c.sdsp ra, 504(sp) +0x98,0x62 == c.ld a4, 0(a3) +0xfc,0xfe == c.sd a5, 248(a3) +0x99,0x9e == c.subw a3, a4 +0x31,0x9d == c.addw a0, a2 +0x81,0x36 == c.addiw a3, -32 +0xfd,0x26 == c.addiw a3, 31 +0x7e,0x14 == c.slli s0, 63 +0xfd,0x92 == c.srli a3, 63 +0x7d,0x96 == c.srai a2, 63 \ No newline at end of file diff --git a/suite/MC/RISCV/rv64d_valid_riscv64_riscv_d_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rv64d_valid_riscv64_riscv_d_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..b68b542591 --- /dev/null +++ b/suite/MC/RISCV/rv64d_valid_riscv64_riscv_d_syntax_no_alias_text.txt.cs @@ -0,0 +1,11 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64"|"CS_MODE_RISCV_D", None +0x53,0x75,0x20,0xc2 == fcvt.l.d a0, ft0, dyn +0xd3,0xf5,0x30,0xc2 == fcvt.lu.d a1, ft1, dyn +0x53,0x06,0x01,0xe2 == fmv.x.d a2, ft2 +0xd3,0xf1,0x26,0xd2 == fcvt.d.l ft3, a3, dyn +0x53,0x72,0x37,0xd2 == fcvt.d.lu ft4, a4, dyn +0xd3,0x82,0x07,0xf2 == fmv.d.x ft5, a5 +0xd3,0x81,0x26,0xd2 == fcvt.d.l ft3, a3, rne +0x53,0x12,0x37,0xd2 == fcvt.d.lu ft4, a4, rtz +0x53,0x25,0x20,0xc2 == fcvt.l.d a0, ft0, rdn +0xd3,0xb5,0x30,0xc2 == fcvt.lu.d a1, ft1, rup \ No newline at end of file diff --git a/suite/MC/RISCV/rv64dc_valid_riscv64_riscv_c_riscv_d_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rv64dc_valid_riscv64_riscv_c_riscv_d_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..380c420442 --- /dev/null +++ b/suite/MC/RISCV/rv64dc_valid_riscv64_riscv_c_riscv_d_syntax_no_alias_text.txt.cs @@ -0,0 +1,5 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64"|"CS_MODE_RISCV_C"|"CS_MODE_RISCV_D", None +0x7e,0x34 == c.fldsp fs0, 504(sp) +0xc6,0xbf == c.fsdsp fa7, 504(sp) +0xf4,0x3f == c.fld fa3, 248(a5) +0xf0,0xbd == c.fsd fa2, 248(a1) \ No newline at end of file diff --git a/suite/MC/RISCV/rv64e_valid_riscv64_riscv_e_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rv64e_valid_riscv64_riscv_e_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..bbdce41e57 --- /dev/null +++ b/suite/MC/RISCV/rv64e_valid_riscv64_riscv_e_syntax_no_alias_text.txt.cs @@ -0,0 +1,13 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64"|"CS_MODE_RISCV_E", None +0x03,0xb7,0x97,0x01 == ld a4, 25(a5) +0x23,0xb2,0xc6,0x02 == sd a2, 36(a3) +0x1b,0x87,0x57,0x02 == addiw a4, a5, 37 +0x1b,0x13,0xf3,0x01 == slliw t1, t1, 31 +0x1b,0x55,0x07,0x00 == srliw a0, a4, 0 +0x9b,0x55,0xf1,0x40 == sraiw a1, sp, 15 +0x9b,0x12,0xd3,0x00 == slliw t0, t1, 13 +0xbb,0x00,0x00,0x00 == addw ra, zero, zero +0xbb,0x82,0x63,0x40 == subw t0, t2, t1 +0xbb,0x17,0xd7,0x00 == sllw a5, a4, a3 +0x3b,0x55,0x54,0x00 == srlw a0, s0, t0 +0xbb,0xd2,0x06,0x40 == sraw t0, a3, zero \ No newline at end of file diff --git a/suite/MC/RISCV/rv64f_valid_riscv64_riscv_f_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rv64f_valid_riscv64_riscv_f_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..2510ba630d --- /dev/null +++ b/suite/MC/RISCV/rv64f_valid_riscv64_riscv_f_syntax_no_alias_text.txt.cs @@ -0,0 +1,9 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64"|"CS_MODE_RISCV_F", None +0x53,0x75,0x20,0xc0 == fcvt.l.s a0, ft0, dyn +0xd3,0xf5,0x30,0xc0 == fcvt.lu.s a1, ft1, dyn +0x53,0x71,0x26,0xd0 == fcvt.s.l ft2, a2, dyn +0xd3,0xf1,0x36,0xd0 == fcvt.s.lu ft3, a3, dyn +0x53,0x07,0x22,0xc0 == fcvt.l.s a4, ft4, rne +0xd3,0x97,0x32,0xc0 == fcvt.lu.s a5, ft5, rtz +0x53,0x23,0x28,0xd0 == fcvt.s.l ft6, a6, rdn +0xd3,0xb3,0x38,0xd0 == fcvt.s.lu ft7, a7, rup \ No newline at end of file diff --git a/suite/MC/RISCV/rv64i_valid_riscv64_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rv64i_valid_riscv64_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..b8c4d82186 --- /dev/null +++ b/suite/MC/RISCV/rv64i_valid_riscv64_syntax_no_alias_text.txt.cs @@ -0,0 +1,30 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64", None +0x03,0xe0,0x40,0x00 == lwu zero, 4(ra) +0x03,0xe1,0x41,0x00 == lwu sp, 4(gp) +0x03,0xe2,0x02,0x80 == lwu tp, -2048(t0) +0x03,0xe3,0x03,0x80 == lwu t1, -2048(t2) +0x03,0xe4,0xf4,0x7f == lwu s0, 2047(s1) +0x03,0xb5,0x05,0x80 == ld a0, -2048(a1) +0x03,0xb6,0x06,0x80 == ld a2, -2048(a3) +0x03,0xb7,0xf7,0x7f == ld a4, 2047(a5) +0x23,0xb0,0x08,0x81 == sd a6, -2048(a7) +0x23,0xb0,0x29,0x81 == sd s2, -2048(s3) +0xa3,0xbf,0x4a,0x7f == sd s4, 2047(s5) +0x13,0x9b,0xdb,0x02 == slli s6, s7, 45 +0x13,0xdc,0x0c,0x00 == srli s8, s9, 0 +0x13,0xdd,0xfd,0x41 == srai s10, s11, 31 +0x1b,0x8e,0x0e,0x80 == addiw t3, t4, -2048 +0x1b,0x8f,0xff,0x7f == addiw t5, t6, 2047 +0x1b,0x90,0x00,0x00 == slliw zero, ra, 0 +0x1b,0x91,0xf1,0x01 == slliw sp, gp, 31 +0x1b,0xd2,0x02,0x00 == srliw tp, t0, 0 +0x1b,0xd3,0xf3,0x01 == srliw t1, t2, 31 +0x1b,0xd4,0x04,0x40 == sraiw s0, s1, 0 +0x1b,0xd5,0xf5,0x41 == sraiw a0, a1, 31 +0x3b,0x86,0xe6,0x00 == addw a2, a3, a4 +0xbb,0x07,0x18,0x01 == addw a5, a6, a7 +0x3b,0x89,0x49,0x41 == subw s2, s3, s4 +0xbb,0x0a,0x7b,0x41 == subw s5, s6, s7 +0x3b,0x9c,0xac,0x01 == sllw s8, s9, s10 +0xbb,0x5d,0xde,0x01 == srlw s11, t3, t4 +0x3b,0xdf,0x0f,0x40 == sraw t5, t6, zero \ No newline at end of file diff --git a/suite/MC/RISCV/rv64ih_valid_riscv64_h_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rv64ih_valid_riscv64_h_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..c68f93bf5d --- /dev/null +++ b/suite/MC/RISCV/rv64ih_valid_riscv64_h_syntax_no_alias_text.txt.cs @@ -0,0 +1,4 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64", None +0x73,0xc5,0x15,0x68 == hlv.wu a0, (a1) +0x73,0xc5,0x05,0x6c == hlv.d a0, (a1) +0x73,0xc0,0xa5,0x6e == hsv.d a0, (a1) \ No newline at end of file diff --git a/suite/MC/RISCV/rv64m_valid_riscv64_m_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rv64m_valid_riscv64_m_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..598cf61526 --- /dev/null +++ b/suite/MC/RISCV/rv64m_valid_riscv64_m_syntax_no_alias_text.txt.cs @@ -0,0 +1,6 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64", None +0xbb,0x00,0x31,0x02 == mulw ra, sp, gp +0x3b,0xc2,0x62,0x02 == divw tp, t0, t1 +0xbb,0x53,0x24,0x03 == divuw t2, s0, s2 +0x3b,0xe5,0xc5,0x02 == remw a0, a1, a2 +0xbb,0x76,0xf7,0x02 == remuw a3, a4, a5 \ No newline at end of file diff --git a/suite/MC/RISCV/rv64xtheadfmemidx_valid_riscv64_riscv_d_riscv_xtheadfmemidx.txt.cs b/suite/MC/RISCV/rv64xtheadfmemidx_valid_riscv64_riscv_d_riscv_xtheadfmemidx.txt.cs new file mode 100644 index 0000000000..96ec06de2b --- /dev/null +++ b/suite/MC/RISCV/rv64xtheadfmemidx_valid_riscv64_riscv_d_riscv_xtheadfmemidx.txt.cs @@ -0,0 +1,17 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64"|"CS_MODE_RISCV_D"|"CS_MODE_RISCV_XTHEADFMEMIDX", None +0x0b,0xe5,0xc5,0x60 == th.flrd fa0, a1, a2, 0 +0x0b,0xe5,0xc5,0x66 == th.flrd fa0, a1, a2, 3 +0x0b,0xe5,0xc5,0x40 == th.flrw fa0, a1, a2, 0 +0x0b,0xe5,0xc5,0x46 == th.flrw fa0, a1, a2, 3 +0x0b,0xe5,0xc5,0x70 == th.flurd fa0, a1, a2, 0 +0x0b,0xe5,0xc5,0x76 == th.flurd fa0, a1, a2, 3 +0x0b,0xe5,0xc5,0x50 == th.flurw fa0, a1, a2, 0 +0x0b,0xe5,0xc5,0x56 == th.flurw fa0, a1, a2, 3 +0x0b,0xf5,0xc5,0x60 == th.fsrd fa0, a1, a2, 0 +0x0b,0xf5,0xc5,0x66 == th.fsrd fa0, a1, a2, 3 +0x0b,0xf5,0xc5,0x40 == th.fsrw fa0, a1, a2, 0 +0x0b,0xf5,0xc5,0x46 == th.fsrw fa0, a1, a2, 3 +0x0b,0xf5,0xc5,0x70 == th.fsurd fa0, a1, a2, 0 +0x0b,0xf5,0xc5,0x76 == th.fsurd fa0, a1, a2, 3 +0x0b,0xf5,0xc5,0x50 == th.fsurw fa0, a1, a2, 0 +0x0b,0xf5,0xc5,0x56 == th.fsurw fa0, a1, a2, 3 \ No newline at end of file diff --git a/suite/MC/RISCV/rv64xtheadmac_valid_riscv64_riscv_xtheadmac.txt.cs b/suite/MC/RISCV/rv64xtheadmac_valid_riscv64_riscv_xtheadmac.txt.cs new file mode 100644 index 0000000000..df866a914e --- /dev/null +++ b/suite/MC/RISCV/rv64xtheadmac_valid_riscv64_riscv_xtheadmac.txt.cs @@ -0,0 +1,7 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64"|"CS_MODE_RISCV_XTHEADMAC", None +0x0b,0x95,0xc5,0x20 == th.mula a0, a1, a2 +0x0b,0x95,0xc5,0x28 == th.mulah a0, a1, a2 +0x0b,0x95,0xc5,0x24 == th.mulaw a0, a1, a2 +0x0b,0x95,0xc5,0x22 == th.muls a0, a1, a2 +0x0b,0x95,0xc5,0x2a == th.mulsh a0, a1, a2 +0x0b,0x95,0xc5,0x26 == th.mulsw a0, a1, a2 \ No newline at end of file diff --git a/suite/MC/RISCV/rv64xtheadmemidx_valid_riscv64_riscv_xtheadmemidx.txt.cs b/suite/MC/RISCV/rv64xtheadmemidx_valid_riscv64_riscv_xtheadmemidx.txt.cs new file mode 100644 index 0000000000..000f0d3594 --- /dev/null +++ b/suite/MC/RISCV/rv64xtheadmemidx_valid_riscv64_riscv_xtheadmemidx.txt.cs @@ -0,0 +1,45 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64"|"CS_MODE_RISCV_XTHEADMEMIDX", None +0x0b,0xc5,0x05,0x78 == th.ldia a0, (a1), 0, 0 +0x0b,0xc5,0xf5,0x6a == th.ldib a0, (a1), 15, 1 +0x0b,0xc5,0x05,0x5c == th.lwia a0, (a1), 0, 2 +0x0b,0xc5,0x05,0x4f == th.lwib a0, (a1), -16, 3 +0x0b,0xc5,0x05,0xd8 == th.lwuia a0, (a1), 0, 0 +0x0b,0xc5,0xf5,0xca == th.lwuib a0, (a1), 15, 1 +0x0b,0xc5,0x05,0x3c == th.lhia a0, (a1), 0, 2 +0x0b,0xc5,0x05,0x2f == th.lhib a0, (a1), -16, 3 +0x0b,0xc5,0x05,0xb8 == th.lhuia a0, (a1), 0, 0 +0x0b,0xc5,0xf5,0xaa == th.lhuib a0, (a1), 15, 1 +0x0b,0xc5,0x05,0x1c == th.lbia a0, (a1), 0, 2 +0x0b,0xc5,0x05,0x0f == th.lbib a0, (a1), -16, 3 +0x0b,0xc5,0x05,0x98 == th.lbuia a0, (a1), 0, 0 +0x0b,0xc5,0xf5,0x8a == th.lbuib a0, (a1), 15, 1 +0x0b,0xd5,0x05,0x79 == th.sdia a0, (a1), -16, 0 +0x0b,0xd5,0xf5,0x6b == th.sdib a0, (a1), -1, 1 +0x0b,0xd5,0x05,0x5c == th.swia a0, (a1), 0, 2 +0x0b,0xd5,0x15,0x4e == th.swib a0, (a1), 1, 3 +0x0b,0xd5,0x45,0x38 == th.shia a0, (a1), 4, 0 +0x0b,0xd5,0xd5,0x2a == th.shib a0, (a1), 13, 1 +0x0b,0xd5,0xe5,0x1c == th.sbia a0, (a1), 14, 2 +0x0b,0xd5,0xf5,0x0e == th.sbib a0, (a1), 15, 3 +0x0b,0xc5,0xc5,0x60 == th.lrd a0, a1, a2, 0 +0x0b,0xc5,0xc5,0x42 == th.lrw a0, a1, a2, 1 +0x0b,0xc5,0xc5,0xc4 == th.lrwu a0, a1, a2, 2 +0x0b,0xc5,0xc5,0x26 == th.lrh a0, a1, a2, 3 +0x0b,0xc5,0xc5,0xa0 == th.lrhu a0, a1, a2, 0 +0x0b,0xc5,0xc5,0x02 == th.lrb a0, a1, a2, 1 +0x0b,0xc5,0xc5,0x84 == th.lrbu a0, a1, a2, 2 +0x0b,0xd5,0xc5,0x66 == th.srd a0, a1, a2, 3 +0x0b,0xd5,0xc5,0x40 == th.srw a0, a1, a2, 0 +0x0b,0xd5,0xc5,0x22 == th.srh a0, a1, a2, 1 +0x0b,0xd5,0xc5,0x04 == th.srb a0, a1, a2, 2 +0x0b,0xc5,0xc5,0x70 == th.lurd a0, a1, a2, 0 +0x0b,0xc5,0xc5,0x52 == th.lurw a0, a1, a2, 1 +0x0b,0xc5,0xc5,0xd4 == th.lurwu a0, a1, a2, 2 +0x0b,0xc5,0xc5,0x36 == th.lurh a0, a1, a2, 3 +0x0b,0xc5,0xc5,0xb0 == th.lurhu a0, a1, a2, 0 +0x0b,0xc5,0xc5,0x12 == th.lurb a0, a1, a2, 1 +0x0b,0xc5,0xc5,0x94 == th.lurbu a0, a1, a2, 2 +0x0b,0xd5,0xc5,0x76 == th.surd a0, a1, a2, 3 +0x0b,0xd5,0xc5,0x50 == th.surw a0, a1, a2, 0 +0x0b,0xd5,0xc5,0x32 == th.surh a0, a1, a2, 1 +0x0b,0xd5,0xc5,0x14 == th.surb a0, a1, a2, 2 \ No newline at end of file diff --git a/suite/MC/RISCV/rv64xtheadmempair_valid_riscv64_riscv_xtheadmempair.txt.cs b/suite/MC/RISCV/rv64xtheadmempair_valid_riscv64_riscv_xtheadmempair.txt.cs new file mode 100644 index 0000000000..93d10a91a8 --- /dev/null +++ b/suite/MC/RISCV/rv64xtheadmempair_valid_riscv64_riscv_xtheadmempair.txt.cs @@ -0,0 +1,6 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64"|"CS_MODE_RISCV_XTHEADMEMPAIR", None +0x0b,0x45,0xb6,0xe2 == th.lwd a0, a1, (a2), 1, 3 +0x0b,0x45,0xb6,0xf4 == th.lwud a0, a1, (a2), 2, 3 +0x0b,0x55,0xb6,0xe0 == th.swd a0, a1, (a2), 0, 3 +0x0b,0x45,0xb6,0xf8 == th.ldd a0, a1, (a2), 0, 4 +0x0b,0x55,0xb6,0xfe == th.sdd a0, a1, (a2), 3, 4 \ No newline at end of file diff --git a/suite/MC/RISCV/rv64zaamo_valid_riscv64_riscv_a_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rv64zaamo_valid_riscv64_riscv_a_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..6bfd2e215e --- /dev/null +++ b/suite/MC/RISCV/rv64zaamo_valid_riscv64_riscv_a_syntax_no_alias_text.txt.cs @@ -0,0 +1,37 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64"|"CS_MODE_RISCV_A", None +0x2f,0x37,0x14,0x08 == amoswap.d a4, ra, (s0) +0xaf,0xb5,0xc6,0x00 == amoadd.d a1, a2, (a3) +0x2f,0x36,0xd7,0x20 == amoxor.d a2, a3, (a4) +0xaf,0xb6,0xe7,0x60 == amoand.d a3, a4, (a5) +0x2f,0x37,0xf8,0x40 == amoor.d a4, a5, (a6) +0xaf,0xb7,0x08,0x81 == amomin.d a5, a6, (a7) +0xaf,0xbb,0x6a,0xa1 == amomax.d s7, s6, (s5) +0x2f,0x3b,0x5a,0xc1 == amominu.d s6, s5, (s4) +0xaf,0xba,0x49,0xe1 == amomaxu.d s5, s4, (s3) +0x2f,0x37,0x14,0x0c == amoswap.d.aq a4, ra, (s0) +0xaf,0xb5,0xc6,0x04 == amoadd.d.aq a1, a2, (a3) +0x2f,0x36,0xd7,0x24 == amoxor.d.aq a2, a3, (a4) +0xaf,0xb6,0xe7,0x64 == amoand.d.aq a3, a4, (a5) +0x2f,0x37,0xf8,0x44 == amoor.d.aq a4, a5, (a6) +0xaf,0xb7,0x08,0x85 == amomin.d.aq a5, a6, (a7) +0xaf,0xbb,0x6a,0xa5 == amomax.d.aq s7, s6, (s5) +0x2f,0x3b,0x5a,0xc5 == amominu.d.aq s6, s5, (s4) +0xaf,0xba,0x49,0xe5 == amomaxu.d.aq s5, s4, (s3) +0x2f,0x37,0x14,0x0a == amoswap.d.rl a4, ra, (s0) +0xaf,0xb5,0xc6,0x02 == amoadd.d.rl a1, a2, (a3) +0x2f,0x36,0xd7,0x22 == amoxor.d.rl a2, a3, (a4) +0xaf,0xb6,0xe7,0x62 == amoand.d.rl a3, a4, (a5) +0x2f,0x37,0xf8,0x42 == amoor.d.rl a4, a5, (a6) +0xaf,0xb7,0x08,0x83 == amomin.d.rl a5, a6, (a7) +0xaf,0xbb,0x6a,0xa3 == amomax.d.rl s7, s6, (s5) +0x2f,0x3b,0x5a,0xc3 == amominu.d.rl s6, s5, (s4) +0xaf,0xba,0x49,0xe3 == amomaxu.d.rl s5, s4, (s3) +0x2f,0x37,0x14,0x0e == amoswap.d.aqrl a4, ra, (s0) +0xaf,0xb5,0xc6,0x06 == amoadd.d.aqrl a1, a2, (a3) +0x2f,0x36,0xd7,0x26 == amoxor.d.aqrl a2, a3, (a4) +0xaf,0xb6,0xe7,0x66 == amoand.d.aqrl a3, a4, (a5) +0x2f,0x37,0xf8,0x46 == amoor.d.aqrl a4, a5, (a6) +0xaf,0xb7,0x08,0x87 == amomin.d.aqrl a5, a6, (a7) +0xaf,0xbb,0x6a,0xa7 == amomax.d.aqrl s7, s6, (s5) +0x2f,0x3b,0x5a,0xc7 == amominu.d.aqrl s6, s5, (s4) +0xaf,0xba,0x49,0xe7 == amomaxu.d.aqrl s5, s4, (s3) \ No newline at end of file diff --git a/suite/MC/RISCV/rv64zacas_valid_riscv64_experimental_zacas_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rv64zacas_valid_riscv64_experimental_zacas_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..1d5d4fbc4b --- /dev/null +++ b/suite/MC/RISCV/rv64zacas_valid_riscv64_experimental_zacas_syntax_no_alias_text.txt.cs @@ -0,0 +1,10 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64", None +0xaf,0xb5,0xd7,0x28 == amocas.d a1, a3, (a5) +0xaf,0xb5,0xd7,0x2c == amocas.d.aq a1, a3, (a5) +0xaf,0xb5,0xd7,0x2a == amocas.d.rl a1, a3, (a5) +0xaf,0xb5,0xd7,0x2e == amocas.d.aqrl a1, a3, (a5) +0x2f,0xc5,0xc5,0x28 == amocas.q a0, a2, (a1) +0x2f,0xc0,0x05,0x28 == amocas.q zero, zero, (a1) +0x2f,0xc0,0x05,0x2c == amocas.q.aq zero, zero, (a1) +0x2f,0xc0,0x05,0x2a == amocas.q.rl zero, zero, (a1) +0x2f,0xc0,0x05,0x2e == amocas.q.aqrl zero, zero, (a1) \ No newline at end of file diff --git a/suite/MC/RISCV/rv64zalrsc_valid_riscv64_riscv_a_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rv64zalrsc_valid_riscv64_riscv_a_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..bc0e874131 --- /dev/null +++ b/suite/MC/RISCV/rv64zalrsc_valid_riscv64_riscv_a_syntax_no_alias_text.txt.cs @@ -0,0 +1,9 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64"|"CS_MODE_RISCV_A", None +0xaf,0x32,0x03,0x10 == lr.d t0, (t1) +0x2f,0xb3,0x03,0x14 == lr.d.aq t1, (t2) +0xaf,0x33,0x0e,0x12 == lr.d.rl t2, (t3) +0x2f,0xbe,0x0e,0x16 == lr.d.aqrl t3, (t4) +0xaf,0xbf,0xee,0x19 == sc.d t6, t5, (t4) +0x2f,0x3f,0xde,0x1d == sc.d.aq t5, t4, (t3) +0xaf,0xbe,0xc3,0x1b == sc.d.rl t4, t3, (t2) +0x2f,0x3e,0x73,0x1e == sc.d.aqrl t3, t2, (t1) \ No newline at end of file diff --git a/suite/MC/RISCV/rv64zba_valid_riscv64_riscv_zba.txt.cs b/suite/MC/RISCV/rv64zba_valid_riscv64_riscv_zba.txt.cs new file mode 100644 index 0000000000..d0b4f572f9 --- /dev/null +++ b/suite/MC/RISCV/rv64zba_valid_riscv64_riscv_zba.txt.cs @@ -0,0 +1,6 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64"|"CS_MODE_RISCV_ZBA", None +0x9b,0x12,0x03,0x08 == slli.uw t0, t1, 0 +0xbb,0x02,0x73,0x08 == add.uw t0, t1, t2 +0xbb,0x22,0x73,0x20 == sh1add.uw t0, t1, t2 +0xbb,0x42,0x73,0x20 == sh2add.uw t0, t1, t2 +0xbb,0x62,0x73,0x20 == sh3add.uw t0, t1, t2 \ No newline at end of file diff --git a/suite/MC/RISCV/rv64zbb_valid_riscv64_riscv_zbb_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rv64zbb_valid_riscv64_riscv_zbb_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..3d0c980bd9 --- /dev/null +++ b/suite/MC/RISCV/rv64zbb_valid_riscv64_riscv_zbb_syntax_no_alias_text.txt.cs @@ -0,0 +1,17 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64"|"CS_MODE_RISCV_ZBB", None +0xbb,0x42,0x03,0x08 == zext.h t0, t1 +0x93,0x52,0xf3,0x63 == rori t0, t1, 63 +0x93,0x52,0x03,0x60 == rori t0, t1, 0 +0x93,0x52,0x83,0x6b == rev8 t0, t1 +0x9b,0x12,0x03,0x60 == clzw t0, t1 +0x9b,0x12,0x13,0x60 == ctzw t0, t1 +0x9b,0x12,0x23,0x60 == cpopw t0, t1 +0x93,0x02,0xe0,0xfe == addi t0, zero, -18 +0x93,0xd2,0x52,0x61 == rori t0, t0, 21 +0x93,0x02,0xa0,0xfa == addi t0, zero, -86 +0x93,0xd2,0x42,0x60 == rori t0, t0, 4 +0x93,0xd2,0x52,0x62 == rori t0, t0, 37 +0xbb,0x12,0x73,0x60 == rolw t0, t1, t2 +0xbb,0x52,0x73,0x60 == rorw t0, t1, t2 +0x9b,0x52,0xf3,0x61 == roriw t0, t1, 31 +0x9b,0x52,0x03,0x60 == roriw t0, t1, 0 \ No newline at end of file diff --git a/suite/MC/RISCV/rv64zbkb_valid_riscv64_riscv_zbkb.txt.cs b/suite/MC/RISCV/rv64zbkb_valid_riscv64_riscv_zbkb.txt.cs new file mode 100644 index 0000000000..c607ee5ef1 --- /dev/null +++ b/suite/MC/RISCV/rv64zbkb_valid_riscv64_riscv_zbkb.txt.cs @@ -0,0 +1,8 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64"|"CS_MODE_RISCV_ZBKB", None +0x93,0x52,0x83,0x6b == rev8 t0, t1 +0xbb,0x52,0x73,0x60 == rorw t0, t1, t2 +0xbb,0x12,0x73,0x60 == rolw t0, t1, t2 +0x9b,0x52,0xf3,0x61 == roriw t0, t1, 31 +0x9b,0x52,0x03,0x60 == roriw t0, t1, 0 +0xbb,0x42,0x73,0x08 == packw t0, t1, t2 +0xbb,0x42,0x03,0x08 == packw t0, t1, zero \ No newline at end of file diff --git a/suite/MC/RISCV/rv64zcb_valid_riscv64_m_riscv_zbb_riscv_zba__zcb_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rv64zcb_valid_riscv64_m_riscv_zbb_riscv_zba__zcb_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..fbbd0acd32 --- /dev/null +++ b/suite/MC/RISCV/rv64zcb_valid_riscv64_m_riscv_zbb_riscv_zba__zcb_syntax_no_alias_text.txt.cs @@ -0,0 +1,2 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64"|"CS_MODE_RISCV_ZBB"|"CS_MODE_RISCV_ZBA", None +0x71,0x9c == c.zext.w s0 \ No newline at end of file diff --git a/suite/MC/RISCV/rv64zcmp_valid_riscv64_riscv_zcmp_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rv64zcmp_valid_riscv64_riscv_zcmp_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..c744ae5c39 --- /dev/null +++ b/suite/MC/RISCV/rv64zcmp_valid_riscv64_riscv_zcmp_syntax_no_alias_text.txt.cs @@ -0,0 +1,36 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64"|"CS_MODE_RISCV_ZCMP", None +0xa2,0xac == cm.mvsa01 s1, s0 +0xe2,0xac == cm.mva01s s1, s0 +0x42,0xbe == cm.popret {ra}, 16 +0x46,0xbe == cm.popret {ra}, 32 +0x5e,0xbe == cm.popret {ra, s0}, 64 +0x62,0xbe == cm.popret {ra, s0-s1}, 32 +0x72,0xbe == cm.popret {ra, s0-s2}, 32 +0x86,0xbe == cm.popret {ra, s0-s3}, 64 +0xa2,0xbe == cm.popret {ra, s0-s5}, 64 +0xc2,0xbe == cm.popret {ra, s0-s7}, 80 +0xf2,0xbe == cm.popret {ra, s0-s11}, 112 +0x42,0xbc == cm.popretz {ra}, 16 +0x46,0xbc == cm.popretz {ra}, 32 +0x5e,0xbc == cm.popretz {ra, s0}, 64 +0x62,0xbc == cm.popretz {ra, s0-s1}, 32 +0x72,0xbc == cm.popretz {ra, s0-s2}, 32 +0x86,0xbc == cm.popretz {ra, s0-s3}, 64 +0xa2,0xbc == cm.popretz {ra, s0-s5}, 64 +0xc2,0xbc == cm.popretz {ra, s0-s7}, 80 +0xf2,0xbc == cm.popretz {ra, s0-s11}, 112 +0x42,0xba == cm.pop {ra}, 16 +0x46,0xba == cm.pop {ra}, 32 +0x52,0xba == cm.pop {ra, s0}, 16 +0x62,0xba == cm.pop {ra, s0-s1}, 32 +0x72,0xba == cm.pop {ra, s0-s2}, 32 +0xa2,0xba == cm.pop {ra, s0-s5}, 64 +0xc2,0xba == cm.pop {ra, s0-s7}, 80 +0xf2,0xba == cm.pop {ra, s0-s11}, 112 +0x42,0xb8 == cm.push {ra}, -16 +0x56,0xb8 == cm.push {ra, s0}, -32 +0x62,0xb8 == cm.push {ra, s0-s1}, -32 +0x86,0xb8 == cm.push {ra, s0-s3}, -64 +0xc2,0xb8 == cm.push {ra, s0-s7}, -80 +0xf2,0xb8 == cm.push {ra, s0-s11}, -112 +0xf6,0xb8 == cm.push {ra, s0-s11}, -128 \ No newline at end of file diff --git a/suite/MC/RISCV/rv64zdinx_valid_riscv64_riscv_zdinx_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rv64zdinx_valid_riscv64_riscv_zdinx_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..e0ee38d73b --- /dev/null +++ b/suite/MC/RISCV/rv64zdinx_valid_riscv64_riscv_zdinx_syntax_no_alias_text.txt.cs @@ -0,0 +1,9 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64"|"CS_MODE_RISCV_ZDINX", None +0x53,0xf5,0x22,0xc2 == fcvt.l.d a0, t0, dyn +0xd3,0x75,0x33,0xc2 == fcvt.lu.d a1, t1, dyn +0x53,0xfe,0x26,0xd2 == fcvt.d.l t3, a3, dyn +0xd3,0x7e,0x37,0xd2 == fcvt.d.lu t4, a4, dyn +0x53,0x8e,0x26,0xd2 == fcvt.d.l t3, a3, rne +0xd3,0x1e,0x37,0xd2 == fcvt.d.lu t4, a4, rtz +0x53,0xa5,0x22,0xc2 == fcvt.l.d a0, t0, rdn +0xd3,0x35,0x33,0xc2 == fcvt.lu.d a1, t1, rup \ No newline at end of file diff --git a/suite/MC/RISCV/rv64zfh_valid_riscv64_zfh_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rv64zfh_valid_riscv64_zfh_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..f61617fb7e --- /dev/null +++ b/suite/MC/RISCV/rv64zfh_valid_riscv64_zfh_syntax_no_alias_text.txt.cs @@ -0,0 +1,9 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64", None +0x53,0x75,0x20,0xc4 == fcvt.l.h a0, ft0, dyn +0xd3,0xf5,0x30,0xc4 == fcvt.lu.h a1, ft1, dyn +0x53,0x71,0x26,0xd4 == fcvt.h.l ft2, a2, dyn +0xd3,0xf1,0x36,0xd4 == fcvt.h.lu ft3, a3, dyn +0x53,0x07,0x22,0xc4 == fcvt.l.h a4, ft4, rne +0xd3,0x97,0x32,0xc4 == fcvt.lu.h a5, ft5, rtz +0x53,0x23,0x28,0xd4 == fcvt.h.l ft6, a6, rdn +0xd3,0xb3,0x38,0xd4 == fcvt.h.lu ft7, a7, rup \ No newline at end of file diff --git a/suite/MC/RISCV/rv64zfinx_valid_riscv64_riscv_zfinx_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rv64zfinx_valid_riscv64_riscv_zfinx_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..f1d472328e --- /dev/null +++ b/suite/MC/RISCV/rv64zfinx_valid_riscv64_riscv_zfinx_syntax_no_alias_text.txt.cs @@ -0,0 +1,9 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64"|"CS_MODE_RISCV_ZFINX", None +0x53,0xf5,0x22,0xc0 == fcvt.l.s a0, t0, dyn +0xd3,0x75,0x33,0xc0 == fcvt.lu.s a1, t1, dyn +0xd3,0x73,0x26,0xd0 == fcvt.s.l t2, a2, dyn +0x53,0xfe,0x36,0xd0 == fcvt.s.lu t3, a3, dyn +0x53,0x87,0x2e,0xc0 == fcvt.l.s a4, t4, rne +0xd3,0x17,0x3f,0xc0 == fcvt.lu.s a5, t5, rtz +0xd3,0x2f,0x28,0xd0 == fcvt.s.l t6, a6, rdn +0xd3,0xbb,0x38,0xd0 == fcvt.s.lu s7, a7, rup \ No newline at end of file diff --git a/suite/MC/RISCV/rv64zhinx_valid_riscv64_riscv_zfinx_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rv64zhinx_valid_riscv64_riscv_zfinx_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..f6cec24a92 --- /dev/null +++ b/suite/MC/RISCV/rv64zhinx_valid_riscv64_riscv_zfinx_syntax_no_alias_text.txt.cs @@ -0,0 +1,9 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64"|"CS_MODE_RISCV_ZFINX", None +0x53,0xf5,0x22,0xc4 == fcvt.l.h a0, t0, dyn +0xd3,0x75,0x33,0xc4 == fcvt.lu.h a1, t1, dyn +0xd3,0x73,0x26,0xd4 == fcvt.h.l t2, a2, dyn +0x53,0xfe,0x36,0xd4 == fcvt.h.lu t3, a3, dyn +0x53,0x87,0x2e,0xc4 == fcvt.l.h a4, t4, rne +0xd3,0x17,0x3f,0xc4 == fcvt.lu.h a5, t5, rtz +0xd3,0x2f,0x28,0xd4 == fcvt.h.l t6, a6, rdn +0xd3,0xbb,0x38,0xd4 == fcvt.h.lu s7, a7, rup \ No newline at end of file diff --git a/suite/MC/RISCV/rv64zhinxmin_valid_riscv64_riscv_zfinx__zdinx_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rv64zhinxmin_valid_riscv64_riscv_zfinx__zdinx_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..2f4a1b94bc --- /dev/null +++ b/suite/MC/RISCV/rv64zhinxmin_valid_riscv64_riscv_zfinx__zdinx_syntax_no_alias_text.txt.cs @@ -0,0 +1,4 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64"|"CS_MODE_RISCV_ZFINX", None +0x53,0x05,0x26,0x42 == fcvt.d.h a0, a2 +0x53,0x35,0x26,0x42 == fcvt.d.h a0, a2, rup +0x53,0x75,0x16,0x44 == fcvt.h.d a0, a2, dyn \ No newline at end of file diff --git a/suite/MC/RISCV/rv64zknd_only_valid_riscv64_zknd.txt.cs b/suite/MC/RISCV/rv64zknd_only_valid_riscv64_zknd.txt.cs new file mode 100644 index 0000000000..9cd84338de --- /dev/null +++ b/suite/MC/RISCV/rv64zknd_only_valid_riscv64_zknd.txt.cs @@ -0,0 +1,6 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64", None +0x33,0x85,0xc5,0x3a == aes64ds a0, a1, a2 +0x33,0x85,0xc5,0x3e == aes64dsm a0, a1, a2 +0x13,0x95,0x05,0x30 == aes64im a0, a1 +0x13,0x95,0x55,0x31 == aes64ks1i a0, a1, 5 +0x33,0x85,0xc5,0x7e == aes64ks2 a0, a1, a2 \ No newline at end of file diff --git a/suite/MC/RISCV/rv64zkne_only_valid_riscv64_zkne.txt.cs b/suite/MC/RISCV/rv64zkne_only_valid_riscv64_zkne.txt.cs new file mode 100644 index 0000000000..96408b107c --- /dev/null +++ b/suite/MC/RISCV/rv64zkne_only_valid_riscv64_zkne.txt.cs @@ -0,0 +1,5 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64", None +0x33,0x85,0xc5,0x32 == aes64es a0, a1, a2 +0x33,0x85,0xc5,0x36 == aes64esm a0, a1, a2 +0x13,0x95,0x55,0x31 == aes64ks1i a0, a1, 5 +0x33,0x85,0xc5,0x7e == aes64ks2 a0, a1, a2 \ No newline at end of file diff --git a/suite/MC/RISCV/rv64zknh_only_valid_riscv64_zknh.txt.cs b/suite/MC/RISCV/rv64zknh_only_valid_riscv64_zknh.txt.cs new file mode 100644 index 0000000000..4e73c4b62a --- /dev/null +++ b/suite/MC/RISCV/rv64zknh_only_valid_riscv64_zknh.txt.cs @@ -0,0 +1,5 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64", None +0x13,0x95,0x65,0x10 == sha512sig0 a0, a1 +0x13,0x95,0x75,0x10 == sha512sig1 a0, a1 +0x13,0x95,0x45,0x10 == sha512sum0 a0, a1 +0x13,0x95,0x55,0x10 == sha512sum1 a0, a1 \ No newline at end of file diff --git a/suite/MC/RISCV/rvc_hints_valid_riscv32_riscv_c_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rvc_hints_valid_riscv32_riscv_c_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..07e0c18cdc --- /dev/null +++ b/suite/MC/RISCV/rvc_hints_valid_riscv32_riscv_c_syntax_no_alias_text.txt.cs @@ -0,0 +1,14 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32"|"CS_MODE_RISCV_C", None +0x21,0x00 == c.nop 8 +0x1d,0x00 == c.nop 7 +0x01,0x05 == c.addi a0, 0 +0x01,0x40 == c.li zero, 0 +0x05,0x40 == c.li zero, 1 +0x05,0x60 == c.lui zero, 1 +0x2a,0x80 == c.mv zero, a0 +0x2a,0x90 == c.add zero, a0 +0x06,0x00 == c.slli zero, 1 +0x02,0x00 == c.slli64 zero +0x02,0x05 == c.slli64 a0 +0x81,0x81 == c.srli64 a1 +0x01,0x85 == c.srai64 a0 \ No newline at end of file diff --git a/suite/MC/RISCV/rvf_user_csr_names_riscv32_riscv_f_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rvf_user_csr_names_riscv32_riscv_f_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..df9a002e26 --- /dev/null +++ b/suite/MC/RISCV/rvf_user_csr_names_riscv32_riscv_f_syntax_no_alias_text.txt.cs @@ -0,0 +1,7 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32"|"CS_MODE_RISCV_F", None +0x73,0x23,0x10,0x00 == csrrs t1, fflags, zero +0xf3,0x23,0x10,0x00 == csrrs t2, fflags, zero +0x73,0x23,0x20,0x00 == csrrs t1, frm, zero +0xf3,0x23,0x20,0x00 == csrrs t2, frm, zero +0x73,0x23,0x30,0x00 == csrrs t1, fcsr, zero +0xf3,0x23,0x30,0x00 == csrrs t2, fcsr, zero \ No newline at end of file diff --git a/suite/MC/RISCV/rvk_user_csr_name_riscv32_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rvk_user_csr_name_riscv32_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..1eb14e895c --- /dev/null +++ b/suite/MC/RISCV/rvk_user_csr_name_riscv32_syntax_no_alias_text.txt.cs @@ -0,0 +1,3 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32", None +0x73,0x23,0x50,0x01 == csrrs t1, seed, zero +0xf3,0x23,0x50,0x01 == csrrs t2, seed, zero \ No newline at end of file diff --git a/suite/MC/RISCV/rvv_user_csr_names_riscv32_riscv_f_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rvv_user_csr_names_riscv32_riscv_f_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..c2dc4f6614 --- /dev/null +++ b/suite/MC/RISCV/rvv_user_csr_names_riscv32_riscv_f_syntax_no_alias_text.txt.cs @@ -0,0 +1,15 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32"|"CS_MODE_RISCV_F", None +0x73,0x23,0x80,0x00 == csrrs t1, vstart, zero +0xf3,0x23,0x80,0x00 == csrrs t2, vstart, zero +0x73,0x23,0x90,0x00 == csrrs t1, vxsat, zero +0xf3,0x23,0x90,0x00 == csrrs t2, vxsat, zero +0x73,0x23,0xa0,0x00 == csrrs t1, vxrm, zero +0xf3,0x23,0xa0,0x00 == csrrs t2, vxrm, zero +0x73,0x23,0xf0,0x00 == csrrs t1, vcsr, zero +0xf3,0x23,0xf0,0x00 == csrrs t2, vcsr, zero +0x73,0x23,0x00,0xc2 == csrrs t1, vl, zero +0xf3,0x23,0x00,0xc2 == csrrs t2, vl, zero +0x73,0x23,0x10,0xc2 == csrrs t1, vtype, zero +0xf3,0x23,0x10,0xc2 == csrrs t2, vtype, zero +0x73,0x23,0x20,0xc2 == csrrs t1, vlenb, zero +0xf3,0x23,0x20,0xc2 == csrrs t2, vlenb, zero \ No newline at end of file diff --git a/suite/MC/RISCV/rvzcmop_valid_riscv32_experimental_zcmop.txt.cs b/suite/MC/RISCV/rvzcmop_valid_riscv32_experimental_zcmop.txt.cs new file mode 100644 index 0000000000..aec16aed49 --- /dev/null +++ b/suite/MC/RISCV/rvzcmop_valid_riscv32_experimental_zcmop.txt.cs @@ -0,0 +1,9 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32", None +0x81,0x60 == cmop.1 +0x81,0x61 == cmop.3 +0x81,0x62 == cmop.5 +0x81,0x63 == cmop.7 +0x81,0x64 == cmop.9 +0x81,0x65 == cmop.11 +0x81,0x66 == cmop.13 +0x81,0x67 == cmop.15 \ No newline at end of file diff --git a/suite/MC/RISCV/rvzcmt_user_csr_name_riscv32_riscv_zcmt_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/rvzcmt_user_csr_name_riscv32_riscv_zcmt_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..3625da0ba2 --- /dev/null +++ b/suite/MC/RISCV/rvzcmt_user_csr_name_riscv32_riscv_zcmt_syntax_no_alias_text.txt.cs @@ -0,0 +1,3 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32"|"CS_MODE_RISCV_ZCMT", None +0x73,0x23,0x70,0x01 == csrrs t1, jvt, zero +0xf3,0x23,0x70,0x01 == csrrs t2, jvt, zero \ No newline at end of file diff --git a/suite/MC/RISCV/rvzimop_valid_riscv32_experimental_zimop.txt.cs b/suite/MC/RISCV/rvzimop_valid_riscv32_experimental_zimop.txt.cs new file mode 100644 index 0000000000..0de9d6c2be --- /dev/null +++ b/suite/MC/RISCV/rvzimop_valid_riscv32_experimental_zimop.txt.cs @@ -0,0 +1,5 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32", None +0x73,0xc6,0xc5,0x81 == mop.r.0 a2, a1 +0x73,0xc6,0xf5,0xcd == mop.r.31 a2, a1 +0xf3,0x46,0xb6,0x82 == mop.rr.0 a3, a2, a1 +0xf3,0x46,0xb6,0xce == mop.rr.7 a3, a2, a1 \ No newline at end of file diff --git a/suite/MC/RISCV/shift_riscv64_riscv_v.txt.cs b/suite/MC/RISCV/shift_riscv64_riscv_v.txt.cs new file mode 100644 index 0000000000..22a3ff6f88 --- /dev/null +++ b/suite/MC/RISCV/shift_riscv64_riscv_v.txt.cs @@ -0,0 +1,44 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64"|"CS_MODE_RISCV_V", None +0x57,0x04,0x4a,0x94 == vsll.vv v8, v4, v20, v0.t +0x57,0x04,0x4a,0x96 == vsll.vv v8, v4, v20 +0x57,0x44,0x45,0x94 == vsll.vx v8, v4, a0, v0.t +0x57,0x44,0x45,0x96 == vsll.vx v8, v4, a0 +0x57,0xb4,0x4f,0x94 == vsll.vi v8, v4, 31, v0.t +0x57,0xb4,0x4f,0x96 == vsll.vi v8, v4, 31 +0x57,0x04,0x4a,0xa0 == vsrl.vv v8, v4, v20, v0.t +0x57,0x04,0x4a,0xa2 == vsrl.vv v8, v4, v20 +0x57,0x44,0x45,0xa0 == vsrl.vx v8, v4, a0, v0.t +0x57,0x44,0x45,0xa2 == vsrl.vx v8, v4, a0 +0x57,0xb4,0x4f,0xa0 == vsrl.vi v8, v4, 31, v0.t +0x57,0xb4,0x4f,0xa2 == vsrl.vi v8, v4, 31 +0x57,0x04,0x4a,0xa4 == vsra.vv v8, v4, v20, v0.t +0x57,0x04,0x4a,0xa6 == vsra.vv v8, v4, v20 +0x57,0x44,0x45,0xa4 == vsra.vx v8, v4, a0, v0.t +0x57,0x44,0x45,0xa6 == vsra.vx v8, v4, a0 +0x57,0xb4,0x4f,0xa4 == vsra.vi v8, v4, 31, v0.t +0x57,0xb4,0x4f,0xa6 == vsra.vi v8, v4, 31 +0x57,0x04,0x4a,0xb0 == vnsrl.wv v8, v4, v20, v0.t +0x57,0x02,0x4a,0xb0 == vnsrl.wv v4, v4, v20, v0.t +0x57,0x04,0x4a,0xb2 == vnsrl.wv v8, v4, v20 +0x57,0x44,0x45,0xb0 == vnsrl.wx v8, v4, a0, v0.t +0x57,0x44,0x45,0xb2 == vnsrl.wx v8, v4, a0 +0x57,0xb4,0x4f,0xb0 == vnsrl.wi v8, v4, 31, v0.t +0x57,0xb4,0x4f,0xb2 == vnsrl.wi v8, v4, 31 +0x57,0x04,0x4a,0xb4 == vnsra.wv v8, v4, v20, v0.t +0x57,0x04,0x4a,0xb6 == vnsra.wv v8, v4, v20 +0x57,0x44,0x45,0xb4 == vnsra.wx v8, v4, a0, v0.t +0x57,0x44,0x45,0xb6 == vnsra.wx v8, v4, a0 +0x57,0xb4,0x4f,0xb4 == vnsra.wi v8, v4, 31, v0.t +0x57,0xb4,0x4f,0xb6 == vnsra.wi v8, v4, 31 +0x57,0x04,0x4a,0xa8 == vssrl.vv v8, v4, v20, v0.t +0x57,0x04,0x4a,0xaa == vssrl.vv v8, v4, v20 +0x57,0x44,0x45,0xa8 == vssrl.vx v8, v4, a0, v0.t +0x57,0x44,0x45,0xaa == vssrl.vx v8, v4, a0 +0x57,0xb4,0x4f,0xa8 == vssrl.vi v8, v4, 31, v0.t +0x57,0xb4,0x4f,0xaa == vssrl.vi v8, v4, 31 +0x57,0x04,0x4a,0xac == vssra.vv v8, v4, v20, v0.t +0x57,0x04,0x4a,0xae == vssra.vv v8, v4, v20 +0x57,0x44,0x45,0xac == vssra.vx v8, v4, a0, v0.t +0x57,0x44,0x45,0xae == vssra.vx v8, v4, a0 +0x57,0xb4,0x4f,0xac == vssra.vi v8, v4, 31, v0.t +0x57,0xb4,0x4f,0xae == vssra.vi v8, v4, 31 \ No newline at end of file diff --git a/suite/MC/RISCV/sign_injection_riscv64_riscv_v_riscv_f.txt.cs b/suite/MC/RISCV/sign_injection_riscv64_riscv_v_riscv_f.txt.cs new file mode 100644 index 0000000000..b48b5e555b --- /dev/null +++ b/suite/MC/RISCV/sign_injection_riscv64_riscv_v_riscv_f.txt.cs @@ -0,0 +1,13 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64"|"CS_MODE_RISCV_V"|"CS_MODE_RISCV_F", None +0x57,0x14,0x4a,0x20 == vfsgnj.vv v8, v4, v20, v0.t +0x57,0x14,0x4a,0x22 == vfsgnj.vv v8, v4, v20 +0x57,0x54,0x45,0x20 == vfsgnj.vf v8, v4, fa0, v0.t +0x57,0x54,0x45,0x22 == vfsgnj.vf v8, v4, fa0 +0x57,0x14,0x4a,0x24 == vfsgnjn.vv v8, v4, v20, v0.t +0x57,0x14,0x4a,0x26 == vfsgnjn.vv v8, v4, v20 +0x57,0x54,0x45,0x24 == vfsgnjn.vf v8, v4, fa0, v0.t +0x57,0x54,0x45,0x26 == vfsgnjn.vf v8, v4, fa0 +0x57,0x14,0x4a,0x28 == vfsgnjx.vv v8, v4, v20, v0.t +0x57,0x14,0x4a,0x2a == vfsgnjx.vv v8, v4, v20 +0x57,0x54,0x45,0x28 == vfsgnjx.vf v8, v4, fa0, v0.t +0x57,0x54,0x45,0x2a == vfsgnjx.vf v8, v4, fa0 \ No newline at end of file diff --git a/suite/MC/RISCV/store_riscv64_riscv_v_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/store_riscv64_riscv_v_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..211aef99f7 --- /dev/null +++ b/suite/MC/RISCV/store_riscv64_riscv_v_syntax_no_alias_text.txt.cs @@ -0,0 +1,38 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64"|"CS_MODE_RISCV_V", None +0x27,0x0c,0xb5,0x02 == vsm.v v24, (a0) +0x27,0x0c,0x05,0x00 == vse8.v v24, (a0), v0.t +0x27,0x0c,0x05,0x02 == vse8.v v24, (a0) +0x27,0x5c,0x05,0x00 == vse16.v v24, (a0), v0.t +0x27,0x5c,0x05,0x02 == vse16.v v24, (a0) +0x27,0x6c,0x05,0x00 == vse32.v v24, (a0), v0.t +0x27,0x6c,0x05,0x02 == vse32.v v24, (a0) +0x27,0x7c,0x05,0x00 == vse64.v v24, (a0), v0.t +0x27,0x7c,0x05,0x02 == vse64.v v24, (a0) +0x27,0x0c,0xb5,0x08 == vsse8.v v24, (a0), a1, v0.t +0x27,0x0c,0xb5,0x0a == vsse8.v v24, (a0), a1 +0x27,0x5c,0xb5,0x08 == vsse16.v v24, (a0), a1, v0.t +0x27,0x5c,0xb5,0x0a == vsse16.v v24, (a0), a1 +0x27,0x6c,0xb5,0x08 == vsse32.v v24, (a0), a1, v0.t +0x27,0x6c,0xb5,0x0a == vsse32.v v24, (a0), a1 +0x27,0x7c,0xb5,0x08 == vsse64.v v24, (a0), a1, v0.t +0x27,0x7c,0xb5,0x0a == vsse64.v v24, (a0), a1 +0x27,0x0c,0x45,0x04 == vsuxei8.v v24, (a0), v4, v0.t +0x27,0x0c,0x45,0x06 == vsuxei8.v v24, (a0), v4 +0x27,0x5c,0x45,0x04 == vsuxei16.v v24, (a0), v4, v0.t +0x27,0x5c,0x45,0x06 == vsuxei16.v v24, (a0), v4 +0x27,0x6c,0x45,0x04 == vsuxei32.v v24, (a0), v4, v0.t +0x27,0x6c,0x45,0x06 == vsuxei32.v v24, (a0), v4 +0x27,0x7c,0x45,0x04 == vsuxei64.v v24, (a0), v4, v0.t +0x27,0x7c,0x45,0x06 == vsuxei64.v v24, (a0), v4 +0x27,0x0c,0x45,0x0c == vsoxei8.v v24, (a0), v4, v0.t +0x27,0x0c,0x45,0x0e == vsoxei8.v v24, (a0), v4 +0x27,0x5c,0x45,0x0c == vsoxei16.v v24, (a0), v4, v0.t +0x27,0x5c,0x45,0x0e == vsoxei16.v v24, (a0), v4 +0x27,0x6c,0x45,0x0c == vsoxei32.v v24, (a0), v4, v0.t +0x27,0x6c,0x45,0x0e == vsoxei32.v v24, (a0), v4 +0x27,0x7c,0x45,0x0c == vsoxei64.v v24, (a0), v4, v0.t +0x27,0x7c,0x45,0x0e == vsoxei64.v v24, (a0), v4 +0x27,0x0c,0x85,0x02 == vs1r.v v24, (a0) +0x27,0x0c,0x85,0x22 == vs2r.v v24, (a0) +0x27,0x0c,0x85,0x62 == vs4r.v v24, (a0) +0x27,0x0c,0x85,0xe2 == vs8r.v v24, (a0) \ No newline at end of file diff --git a/suite/MC/RISCV/sub_riscv64_riscv_v.txt.cs b/suite/MC/RISCV/sub_riscv64_riscv_v.txt.cs new file mode 100644 index 0000000000..8ed507cfdc --- /dev/null +++ b/suite/MC/RISCV/sub_riscv64_riscv_v.txt.cs @@ -0,0 +1,51 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64"|"CS_MODE_RISCV_V", None +0x57,0x04,0x4a,0x08 == vsub.vv v8, v4, v20, v0.t +0x57,0x04,0x4a,0x0a == vsub.vv v8, v4, v20 +0x57,0x44,0x45,0x08 == vsub.vx v8, v4, a0, v0.t +0x57,0x44,0x45,0x0a == vsub.vx v8, v4, a0 +0x57,0x44,0x45,0x0c == vrsub.vx v8, v4, a0, v0.t +0x57,0x44,0x45,0x0e == vrsub.vx v8, v4, a0 +0x57,0xb4,0x47,0x0c == vrsub.vi v8, v4, 15, v0.t +0x57,0xb4,0x47,0x0e == vrsub.vi v8, v4, 15 +0x57,0x24,0x4a,0xc8 == vwsubu.vv v8, v4, v20, v0.t +0x57,0x24,0x4a,0xca == vwsubu.vv v8, v4, v20 +0x57,0x64,0x45,0xc8 == vwsubu.vx v8, v4, a0, v0.t +0x57,0x64,0x45,0xca == vwsubu.vx v8, v4, a0 +0x57,0x24,0x4a,0xcc == vwsub.vv v8, v4, v20, v0.t +0x57,0x24,0x4a,0xce == vwsub.vv v8, v4, v20 +0x57,0x64,0x45,0xcc == vwsub.vx v8, v4, a0, v0.t +0x57,0x64,0x45,0xce == vwsub.vx v8, v4, a0 +0x57,0x24,0x4a,0xd8 == vwsubu.wv v8, v4, v20, v0.t +0x57,0x24,0x4a,0xda == vwsubu.wv v8, v4, v20 +0x57,0x64,0x45,0xd8 == vwsubu.wx v8, v4, a0, v0.t +0x57,0x64,0x45,0xda == vwsubu.wx v8, v4, a0 +0x57,0x24,0x4a,0xdc == vwsub.wv v8, v4, v20, v0.t +0x57,0x24,0x4a,0xde == vwsub.wv v8, v4, v20 +0x57,0x64,0x45,0xdc == vwsub.wx v8, v4, a0, v0.t +0x57,0x64,0x45,0xde == vwsub.wx v8, v4, a0 +0x57,0x04,0x4a,0x48 == vsbc.vvm v8, v4, v20, v0 +0x57,0x02,0x4a,0x48 == vsbc.vvm v4, v4, v20, v0 +0x57,0x04,0x44,0x48 == vsbc.vvm v8, v4, v8, v0 +0x57,0x44,0x45,0x48 == vsbc.vxm v8, v4, a0, v0 +0x57,0x04,0x4a,0x4c == vmsbc.vvm v8, v4, v20, v0 +0x57,0x02,0x4a,0x4c == vmsbc.vvm v4, v4, v20, v0 +0x57,0x04,0x44,0x4c == vmsbc.vvm v8, v4, v8, v0 +0x57,0x44,0x45,0x4c == vmsbc.vxm v8, v4, a0, v0 +0x57,0x04,0x4a,0x4e == vmsbc.vv v8, v4, v20 +0x57,0x44,0x45,0x4e == vmsbc.vx v8, v4, a0 +0x57,0x04,0x4a,0x88 == vssubu.vv v8, v4, v20, v0.t +0x57,0x04,0x4a,0x8a == vssubu.vv v8, v4, v20 +0x57,0x44,0x45,0x88 == vssubu.vx v8, v4, a0, v0.t +0x57,0x44,0x45,0x8a == vssubu.vx v8, v4, a0 +0x57,0x04,0x4a,0x8c == vssub.vv v8, v4, v20, v0.t +0x57,0x04,0x4a,0x8e == vssub.vv v8, v4, v20 +0x57,0x44,0x45,0x8c == vssub.vx v8, v4, a0, v0.t +0x57,0x44,0x45,0x8e == vssub.vx v8, v4, a0 +0x57,0x24,0x4a,0x2c == vasub.vv v8, v4, v20, v0.t +0x57,0x24,0x4a,0x2e == vasub.vv v8, v4, v20 +0x57,0x64,0x45,0x2c == vasub.vx v8, v4, a0, v0.t +0x57,0x64,0x45,0x2e == vasub.vx v8, v4, a0 +0x57,0x24,0x4a,0x28 == vasubu.vv v8, v4, v20, v0.t +0x57,0x24,0x4a,0x2a == vasubu.vv v8, v4, v20 +0x57,0x64,0x45,0x28 == vasubu.vx v8, v4, a0, v0.t +0x57,0x64,0x45,0x2a == vasubu.vx v8, v4, a0 \ No newline at end of file diff --git a/suite/MC/RISCV/supervisor_csr_names_riscv32_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/supervisor_csr_names_riscv32_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..4530d4c5fd --- /dev/null +++ b/suite/MC/RISCV/supervisor_csr_names_riscv32_syntax_no_alias_text.txt.cs @@ -0,0 +1,45 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32", None +0x73,0x23,0x00,0x10 == csrrs t1, sstatus, zero +0xf3,0x23,0x00,0x10 == csrrs t2, sstatus, zero +0x73,0x23,0x40,0x10 == csrrs t1, sie, zero +0xf3,0x23,0x40,0x10 == csrrs t2, sie, zero +0x73,0x23,0x50,0x10 == csrrs t1, stvec, zero +0xf3,0x23,0x50,0x10 == csrrs t2, stvec, zero +0x73,0x23,0x60,0x10 == csrrs t1, scounteren, zero +0xf3,0x23,0x60,0x10 == csrrs t2, scounteren, zero +0x73,0x23,0xd0,0x14 == csrrs t1, stimecmp, zero +0xf3,0x23,0xd0,0x14 == csrrs t2, stimecmp, zero +0x73,0x23,0xa0,0x10 == csrrs t1, senvcfg, zero +0xf3,0x23,0xa0,0x10 == csrrs t2, senvcfg, zero +0x73,0x23,0x00,0x14 == csrrs t1, sscratch, zero +0xf3,0x23,0x00,0x14 == csrrs t2, sscratch, zero +0x73,0x23,0x10,0x14 == csrrs t1, sepc, zero +0xf3,0x23,0x10,0x14 == csrrs t2, sepc, zero +0x73,0x23,0x20,0x14 == csrrs t1, scause, zero +0xf3,0x23,0x20,0x14 == csrrs t2, scause, zero +0x73,0x23,0x30,0x14 == csrrs t1, stval, zero +0xf3,0x23,0x30,0x14 == csrrs t2, stval, zero +0x73,0x23,0x40,0x14 == csrrs t1, sip, zero +0xf3,0x23,0x40,0x14 == csrrs t2, sip, zero +0x73,0x23,0x00,0x18 == csrrs t1, satp, zero +0xf3,0x23,0x00,0x18 == csrrs t2, satp, zero +0x73,0x23,0x80,0x5a == csrrs t1, scontext, zero +0xf3,0x23,0x80,0x5a == csrrs t2, scontext, zero +0x73,0x23,0x00,0xda == csrrs t1, scountovf, zero +0xf3,0x23,0x00,0xda == csrrs t2, scountovf, zero +0x73,0x23,0xc0,0x10 == csrrs t1, sstateen0, zero +0xf3,0x23,0xc0,0x10 == csrrs t2, sstateen0, zero +0x73,0x23,0xd0,0x10 == csrrs t1, sstateen1, zero +0xf3,0x23,0xd0,0x10 == csrrs t2, sstateen1, zero +0x73,0x23,0xe0,0x10 == csrrs t1, sstateen2, zero +0xf3,0x23,0xe0,0x10 == csrrs t2, sstateen2, zero +0x73,0x23,0xf0,0x10 == csrrs t1, sstateen3, zero +0xf3,0x23,0xf0,0x10 == csrrs t2, sstateen3, zero +0x73,0x23,0x00,0x15 == csrrs t1, siselect, zero +0xf3,0x23,0x00,0x15 == csrrs t2, siselect, zero +0x73,0x23,0x10,0x15 == csrrs t1, sireg, zero +0xf3,0x23,0x10,0x15 == csrrs t2, sireg, zero +0x73,0x23,0xc0,0x15 == csrrs t1, stopei, zero +0xf3,0x23,0xc0,0x15 == csrrs t2, stopei, zero +0x73,0x23,0x00,0xdb == csrrs t1, stopi, zero +0xf3,0x23,0x00,0xdb == csrrs t2, stopi, zero \ No newline at end of file diff --git a/suite/MC/RISCV/user_csr_names_riscv32_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/user_csr_names_riscv32_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..adeb4cefc6 --- /dev/null +++ b/suite/MC/RISCV/user_csr_names_riscv32_syntax_no_alias_text.txt.cs @@ -0,0 +1,65 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32", None +0x73,0x23,0x00,0xc0 == csrrs t1, cycle, zero +0xf3,0x23,0x00,0xc0 == csrrs t2, cycle, zero +0x73,0x23,0x10,0xc0 == csrrs t1, time, zero +0xf3,0x23,0x10,0xc0 == csrrs t2, time, zero +0x73,0x23,0x20,0xc0 == csrrs t1, instret, zero +0xf3,0x23,0x20,0xc0 == csrrs t2, instret, zero +0x73,0x23,0x30,0xc0 == csrrs t1, hpmcounter3, zero +0xf3,0x23,0x30,0xc0 == csrrs t2, hpmcounter3, zero +0x73,0x23,0x40,0xc0 == csrrs t1, hpmcounter4, zero +0xf3,0x23,0x40,0xc0 == csrrs t2, hpmcounter4, zero +0x73,0x23,0x50,0xc0 == csrrs t1, hpmcounter5, zero +0xf3,0x23,0x50,0xc0 == csrrs t2, hpmcounter5, zero +0x73,0x23,0x60,0xc0 == csrrs t1, hpmcounter6, zero +0xf3,0x23,0x60,0xc0 == csrrs t2, hpmcounter6, zero +0x73,0x23,0x70,0xc0 == csrrs t1, hpmcounter7, zero +0xf3,0x23,0x70,0xc0 == csrrs t2, hpmcounter7, zero +0x73,0x23,0x80,0xc0 == csrrs t1, hpmcounter8, zero +0xf3,0x23,0x80,0xc0 == csrrs t2, hpmcounter8, zero +0x73,0x23,0x90,0xc0 == csrrs t1, hpmcounter9, zero +0xf3,0x23,0x90,0xc0 == csrrs t2, hpmcounter9, zero +0x73,0x23,0xa0,0xc0 == csrrs t1, hpmcounter10, zero +0xf3,0x23,0xa0,0xc0 == csrrs t2, hpmcounter10, zero +0x73,0x23,0xb0,0xc0 == csrrs t1, hpmcounter11, zero +0xf3,0x23,0xb0,0xc0 == csrrs t2, hpmcounter11, zero +0x73,0x23,0xc0,0xc0 == csrrs t1, hpmcounter12, zero +0xf3,0x23,0xc0,0xc0 == csrrs t2, hpmcounter12, zero +0x73,0x23,0xd0,0xc0 == csrrs t1, hpmcounter13, zero +0xf3,0x23,0xd0,0xc0 == csrrs t2, hpmcounter13, zero +0x73,0x23,0xe0,0xc0 == csrrs t1, hpmcounter14, zero +0xf3,0x23,0xe0,0xc0 == csrrs t2, hpmcounter14, zero +0x73,0x23,0xf0,0xc0 == csrrs t1, hpmcounter15, zero +0xf3,0x23,0xf0,0xc0 == csrrs t2, hpmcounter15, zero +0x73,0x23,0x00,0xc1 == csrrs t1, hpmcounter16, zero +0xf3,0x23,0x00,0xc1 == csrrs t2, hpmcounter16, zero +0x73,0x23,0x10,0xc1 == csrrs t1, hpmcounter17, zero +0xf3,0x23,0x10,0xc1 == csrrs t2, hpmcounter17, zero +0x73,0x23,0x20,0xc1 == csrrs t1, hpmcounter18, zero +0xf3,0x23,0x20,0xc1 == csrrs t2, hpmcounter18, zero +0x73,0x23,0x30,0xc1 == csrrs t1, hpmcounter19, zero +0xf3,0x23,0x30,0xc1 == csrrs t2, hpmcounter19, zero +0x73,0x23,0x40,0xc1 == csrrs t1, hpmcounter20, zero +0xf3,0x23,0x40,0xc1 == csrrs t2, hpmcounter20, zero +0x73,0x23,0x50,0xc1 == csrrs t1, hpmcounter21, zero +0xf3,0x23,0x50,0xc1 == csrrs t2, hpmcounter21, zero +0x73,0x23,0x60,0xc1 == csrrs t1, hpmcounter22, zero +0xf3,0x23,0x60,0xc1 == csrrs t2, hpmcounter22, zero +0x73,0x23,0x70,0xc1 == csrrs t1, hpmcounter23, zero +0xf3,0x23,0x70,0xc1 == csrrs t2, hpmcounter23, zero +0x73,0x23,0x80,0xc1 == csrrs t1, hpmcounter24, zero +0xf3,0x23,0x80,0xc1 == csrrs t2, hpmcounter24, zero +0x73,0x23,0x90,0xc1 == csrrs t1, hpmcounter25, zero +0xf3,0x23,0x90,0xc1 == csrrs t2, hpmcounter25, zero +0x73,0x23,0xa0,0xc1 == csrrs t1, hpmcounter26, zero +0xf3,0x23,0xa0,0xc1 == csrrs t2, hpmcounter26, zero +0x73,0x23,0xb0,0xc1 == csrrs t1, hpmcounter27, zero +0xf3,0x23,0xb0,0xc1 == csrrs t2, hpmcounter27, zero +0x73,0x23,0xc0,0xc1 == csrrs t1, hpmcounter28, zero +0xf3,0x23,0xc0,0xc1 == csrrs t2, hpmcounter28, zero +0x73,0x23,0xd0,0xc1 == csrrs t1, hpmcounter29, zero +0xf3,0x23,0xd0,0xc1 == csrrs t2, hpmcounter29, zero +0x73,0x23,0xe0,0xc1 == csrrs t1, hpmcounter30, zero +0xf3,0x23,0xe0,0xc1 == csrrs t2, hpmcounter30, zero +0x73,0x23,0xf0,0xc1 == csrrs t1, hpmcounter31, zero +0xf3,0x23,0xf0,0xc1 == csrrs t2, hpmcounter31, zero \ No newline at end of file diff --git a/suite/MC/RISCV/vsetvl_riscv64_riscv_v.txt.cs b/suite/MC/RISCV/vsetvl_riscv64_riscv_v.txt.cs new file mode 100644 index 0000000000..3e2aa2a4aa --- /dev/null +++ b/suite/MC/RISCV/vsetvl_riscv64_riscv_v.txt.cs @@ -0,0 +1,17 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64"|"CS_MODE_RISCV_V", None +0x57,0x76,0x45,0x22 == vsetvli a2, a0, 548 +0x57,0x76,0x05,0x0d == vsetvli a2, a0, e32, m1, ta, ma +0x57,0x76,0x15,0x0d == vsetvli a2, a0, e32, m2, ta, ma +0x57,0x76,0x05,0x05 == vsetvli a2, a0, e32, m1, ta, mu +0x57,0x76,0x05,0x09 == vsetvli a2, a0, e32, m1, tu, ma +0x57,0x76,0x25,0x0d == vsetvli a2, a0, e32, m4, ta, ma +0x57,0x76,0x35,0x0d == vsetvli a2, a0, e32, m8, ta, ma +0x57,0x76,0x75,0x0d == vsetvli a2, a0, e32, mf2, ta, ma +0x57,0x76,0x65,0x0d == vsetvli a2, a0, e32, mf4, ta, ma +0x57,0x76,0x55,0x0d == vsetvli a2, a0, e32, mf8, ta, ma +0x57,0x76,0x05,0x01 == vsetvli a2, a0, e32, m1, tu, mu +0x57,0x76,0xb5,0x80 == vsetvl a2, a0, a1 +0x57,0x76,0x40,0xe2 == vsetivli a2, 0, 548 +0x57,0x76,0x00,0xcd == vsetivli a2, 0, e32, m1, ta, ma +0x57,0xf6,0x07,0xcd == vsetivli a2, 15, e32, m1, ta, ma +0x57,0xf6,0x0f,0xcd == vsetivli a2, 31, e32, m1, ta, ma \ No newline at end of file diff --git a/suite/MC/RISCV/xor_riscv64_riscv_v.txt.cs b/suite/MC/RISCV/xor_riscv64_riscv_v.txt.cs new file mode 100644 index 0000000000..7e8dd80f8c --- /dev/null +++ b/suite/MC/RISCV/xor_riscv64_riscv_v.txt.cs @@ -0,0 +1,9 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64"|"CS_MODE_RISCV_V", None +0x57,0x04,0x4a,0x2c == vxor.vv v8, v4, v20, v0.t +0x57,0x04,0x4a,0x2e == vxor.vv v8, v4, v20 +0x57,0x44,0x45,0x2c == vxor.vx v8, v4, a0, v0.t +0x57,0x44,0x45,0x2e == vxor.vx v8, v4, a0 +0x57,0xb4,0x47,0x2c == vxor.vi v8, v4, 15, v0.t +0x57,0xb4,0x47,0x2e == vxor.vi v8, v4, 15 +0x57,0xb4,0x4f,0x2c == vnot.v v8, v4, v0.t +0x57,0xb4,0x4f,0x2e == vnot.v v8, v4 \ No newline at end of file diff --git a/suite/MC/RISCV/xsfvcp_riscv32_riscv_v_riscv_xsfvcp.txt.cs b/suite/MC/RISCV/xsfvcp_riscv32_riscv_v_riscv_xsfvcp.txt.cs new file mode 100644 index 0000000000..6bedc7ea5f --- /dev/null +++ b/suite/MC/RISCV/xsfvcp_riscv32_riscv_v_riscv_xsfvcp.txt.cs @@ -0,0 +1,29 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32"|"CS_MODE_RISCV_V"|"CS_MODE_RISCV_XSFVCP", None +0xdb,0xcf,0xf5,0x0e == sf.vc.x 3, 15, 31, a1 +0xdb,0xbf,0xf7,0x0e == sf.vc.i 3, 15, 31, 15 +0xdb,0x8f,0x20,0x2e == sf.vc.vv 3, 31, v2, v1 +0xdb,0xcf,0x25,0x2e == sf.vc.xv 3, 31, v2, a1 +0xdb,0xbf,0x27,0x2e == sf.vc.iv 3, 31, v2, 15 +0xdb,0xdf,0x25,0x2e == sf.vc.fv 1, 31, v2, fa1 +0x5b,0x80,0x20,0xae == sf.vc.vvv 3, v0, v2, v1 +0x5b,0xc0,0x25,0xae == sf.vc.xvv 3, v0, v2, a1 +0x5b,0xb0,0x27,0xae == sf.vc.ivv 3, v0, v2, 15 +0x5b,0xd0,0x25,0xae == sf.vc.fvv 1, v0, v2, fa1 +0x5b,0x80,0x20,0xfe == sf.vc.vvw 3, v0, v2, v1 +0x5b,0xc0,0x25,0xfe == sf.vc.xvw 3, v0, v2, a1 +0x5b,0xb0,0x27,0xfe == sf.vc.ivw 3, v0, v2, 15 +0x5b,0xd0,0x25,0xfe == sf.vc.fvw 1, v0, v2, fa1 +0x5b,0xc0,0xf5,0x0c == sf.vc.v.x 3, 15, v0, a1 +0x5b,0xb0,0xf7,0x0c == sf.vc.v.i 3, 15, v0, 15 +0x5b,0x80,0x20,0x2c == sf.vc.v.vv 3, v0, v2, v1 +0x5b,0xc0,0x25,0x2c == sf.vc.v.xv 3, v0, v2, a1 +0x5b,0xb0,0x27,0x2c == sf.vc.v.iv 3, v0, v2, 15 +0x5b,0xd0,0x25,0x2c == sf.vc.v.fv 1, v0, v2, fa1 +0x5b,0x80,0x20,0xac == sf.vc.v.vvv 3, v0, v2, v1 +0x5b,0xc0,0x25,0xac == sf.vc.v.xvv 3, v0, v2, a1 +0x5b,0xb0,0x27,0xac == sf.vc.v.ivv 3, v0, v2, 15 +0x5b,0xd0,0x25,0xac == sf.vc.v.fvv 1, v0, v2, fa1 +0x5b,0x80,0x20,0xfc == sf.vc.v.vvw 3, v0, v2, v1 +0x5b,0xc0,0x25,0xfc == sf.vc.v.xvw 3, v0, v2, a1 +0x5b,0xb0,0x27,0xfc == sf.vc.v.ivw 3, v0, v2, 15 +0x5b,0xd0,0x25,0xfc == sf.vc.v.fvw 1, v0, v2, fa1 \ No newline at end of file diff --git a/suite/MC/RISCV/xsfvfnrclip_riscv64_riscv_v_riscv_xsfvfnrclipxfqf.txt.cs b/suite/MC/RISCV/xsfvfnrclip_riscv64_riscv_v_riscv_xsfvfnrclipxfqf.txt.cs new file mode 100644 index 0000000000..c25b29b6f8 --- /dev/null +++ b/suite/MC/RISCV/xsfvfnrclip_riscv64_riscv_v_riscv_xsfvfnrclipxfqf.txt.cs @@ -0,0 +1,5 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64"|"CS_MODE_RISCV_V"|"CS_MODE_RISCV_XSFVFNRCLIPXFQF", None +0x5b,0x52,0x86,0x8a == sf.vfnrclip.xu.f.qf v4, v8, fa2 +0x5b,0x52,0x86,0x88 == sf.vfnrclip.xu.f.qf v4, v8, fa2, v0.t +0x5b,0x52,0x86,0x8e == sf.vfnrclip.x.f.qf v4, v8, fa2 +0x5b,0x52,0x86,0x8c == sf.vfnrclip.x.f.qf v4, v8, fa2, v0.t \ No newline at end of file diff --git a/suite/MC/RISCV/xsfvfwmacc_riscv64_riscv_v_riscv_xsfvfwmaccqqq.txt.cs b/suite/MC/RISCV/xsfvfwmacc_riscv64_riscv_v_riscv_xsfvfwmaccqqq.txt.cs new file mode 100644 index 0000000000..d0b6e490ee --- /dev/null +++ b/suite/MC/RISCV/xsfvfwmacc_riscv64_riscv_v_riscv_xsfvfwmaccqqq.txt.cs @@ -0,0 +1,2 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64"|"CS_MODE_RISCV_V"|"CS_MODE_RISCV_XSFVFWMACCQQQ", None +0x5b,0x14,0x42,0xf3 == sf.vfwmacc.4x4x4 v8, v4, v20 \ No newline at end of file diff --git a/suite/MC/RISCV/xsfvqmacc_riscv64_riscv_v_riscv_xsfvqmaccqoq_riscv_xsfvqmaccdod.txt.cs b/suite/MC/RISCV/xsfvqmacc_riscv64_riscv_v_riscv_xsfvqmaccqoq_riscv_xsfvqmaccdod.txt.cs new file mode 100644 index 0000000000..49a30015f0 --- /dev/null +++ b/suite/MC/RISCV/xsfvqmacc_riscv64_riscv_v_riscv_xsfvqmaccqoq_riscv_xsfvqmaccdod.txt.cs @@ -0,0 +1,9 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64"|"CS_MODE_RISCV_V"|"CS_MODE_RISCV_XSFVQMACCQOQ"|"CS_MODE_RISCV_XSFVQMACCDOD", None +0x5b,0x24,0x42,0xb3 == sf.vqmaccu.2x8x2 v8, v4, v20 +0x5b,0x24,0x42,0xb7 == sf.vqmacc.2x8x2 v8, v4, v20 +0x5b,0x24,0x42,0xbb == sf.vqmaccus.2x8x2 v8, v4, v20 +0x5b,0x24,0x42,0xbf == sf.vqmaccsu.2x8x2 v8, v4, v20 +0x5b,0x24,0x42,0xf3 == sf.vqmaccu.4x8x4 v8, v4, v20 +0x5b,0x24,0x42,0xf7 == sf.vqmacc.4x8x4 v8, v4, v20 +0x5b,0x24,0x42,0xfb == sf.vqmaccus.4x8x4 v8, v4, v20 +0x5b,0x24,0x42,0xff == sf.vqmaccsu.4x8x4 v8, v4, v20 \ No newline at end of file diff --git a/suite/MC/RISCV/xtheadcmo_valid_riscv32_riscv_xtheadcmo.txt.cs b/suite/MC/RISCV/xtheadcmo_valid_riscv32_riscv_xtheadcmo.txt.cs new file mode 100644 index 0000000000..67165b5091 --- /dev/null +++ b/suite/MC/RISCV/xtheadcmo_valid_riscv32_riscv_xtheadcmo.txt.cs @@ -0,0 +1,22 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32"|"CS_MODE_RISCV_XTHEADCMO", None +0x0b,0x00,0x18,0x02 == th.dcache.csw a6 +0x0b,0x80,0x22,0x02 == th.dcache.isw t0 +0x0b,0x80,0x38,0x02 == th.dcache.cisw a7 +0x0b,0x80,0x43,0x02 == th.dcache.cval1 t2 +0x0b,0x80,0x56,0x02 == th.dcache.cva a3 +0x0b,0x80,0x67,0x02 == th.dcache.iva a5 +0x0b,0x00,0x77,0x02 == th.dcache.civa a4 +0x0b,0x00,0x83,0x02 == th.dcache.cpal1 t1 +0x0b,0x00,0x95,0x02 == th.dcache.cpa a0 +0x0b,0x00,0xa6,0x02 == th.dcache.ipa a2 +0x0b,0x80,0xb5,0x02 == th.dcache.cipa a1 +0x0b,0x80,0x0e,0x03 == th.icache.iva t4 +0x0b,0x00,0x8e,0x03 == th.icache.ipa t3 +0x0b,0x00,0x10,0x00 == th.dcache.call +0x0b,0x00,0x20,0x00 == th.dcache.iall +0x0b,0x00,0x30,0x00 == th.dcache.ciall +0x0b,0x00,0x00,0x01 == th.icache.iall +0x0b,0x00,0x10,0x01 == th.icache.ialls +0x0b,0x00,0x50,0x01 == th.l2cache.call +0x0b,0x00,0x60,0x01 == th.l2cache.iall +0x0b,0x00,0x70,0x01 == th.l2cache.ciall \ No newline at end of file diff --git a/suite/MC/RISCV/xtheadcondmov_valid_riscv32_riscv_xtheadcondmov.txt.cs b/suite/MC/RISCV/xtheadcondmov_valid_riscv32_riscv_xtheadcondmov.txt.cs new file mode 100644 index 0000000000..dfc53285b5 --- /dev/null +++ b/suite/MC/RISCV/xtheadcondmov_valid_riscv32_riscv_xtheadcondmov.txt.cs @@ -0,0 +1,3 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32"|"CS_MODE_RISCV_XTHEADCONDMOV", None +0x0b,0x95,0xc5,0x40 == th.mveqz a0, a1, a2 +0x0b,0x95,0xc5,0x42 == th.mvnez a0, a1, a2 \ No newline at end of file diff --git a/suite/MC/RISCV/xtheadsync_valid_riscv32_riscv_xtheadsync.txt.cs b/suite/MC/RISCV/xtheadsync_valid_riscv32_riscv_xtheadsync.txt.cs new file mode 100644 index 0000000000..d07d7bc474 --- /dev/null +++ b/suite/MC/RISCV/xtheadsync_valid_riscv32_riscv_xtheadsync.txt.cs @@ -0,0 +1,6 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32"|"CS_MODE_RISCV_XTHEADSYNC", None +0x0b,0x00,0xb5,0x04 == th.sfence.vmas a0, a1 +0x0b,0x00,0x80,0x01 == th.sync +0x0b,0x00,0xa0,0x01 == th.sync.i +0x0b,0x00,0xb0,0x01 == th.sync.is +0x0b,0x00,0x90,0x01 == th.sync.s \ No newline at end of file diff --git a/suite/MC/RISCV/zfa_valid_riscv32_zfa_riscv_d__zfh_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/zfa_valid_riscv32_zfa_riscv_d__zfh_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..020f03238a --- /dev/null +++ b/suite/MC/RISCV/zfa_valid_riscv32_zfa_riscv_d__zfh_syntax_no_alias_text.txt.cs @@ -0,0 +1,134 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32"|"CS_MODE_RISCV_D", None +0xd3,0x00,0x10,0xf0 == fli.s ft1, -1.0 +0xd3,0x80,0x10,0xf0 == fli.s ft1, min +0xd3,0x00,0x11,0xf0 == fli.s ft1, 1.52587890625e-05 +0xd3,0x80,0x11,0xf0 == fli.s ft1, 3.0517578125e-05 +0xd3,0x00,0x12,0xf0 == fli.s ft1, 0.00390625 +0xd3,0x80,0x12,0xf0 == fli.s ft1, 0.0078125 +0xd3,0x00,0x13,0xf0 == fli.s ft1, 0.0625 +0xd3,0x80,0x13,0xf0 == fli.s ft1, 0.125 +0xd3,0x00,0x14,0xf0 == fli.s ft1, 0.25 +0xd3,0x80,0x14,0xf0 == fli.s ft1, 0.3125 +0xd3,0x00,0x15,0xf0 == fli.s ft1, 0.375 +0xd3,0x80,0x15,0xf0 == fli.s ft1, 0.4375 +0xd3,0x00,0x16,0xf0 == fli.s ft1, 0.5 +0xd3,0x80,0x16,0xf0 == fli.s ft1, 0.625 +0xd3,0x00,0x17,0xf0 == fli.s ft1, 0.75 +0xd3,0x80,0x17,0xf0 == fli.s ft1, 0.875 +0xd3,0x00,0x18,0xf0 == fli.s ft1, 1.0 +0xd3,0x80,0x18,0xf0 == fli.s ft1, 1.25 +0xd3,0x00,0x19,0xf0 == fli.s ft1, 1.5 +0xd3,0x80,0x19,0xf0 == fli.s ft1, 1.75 +0xd3,0x00,0x1a,0xf0 == fli.s ft1, 2.0 +0xd3,0x80,0x1a,0xf0 == fli.s ft1, 2.5 +0xd3,0x00,0x1b,0xf0 == fli.s ft1, 3.0 +0xd3,0x80,0x1b,0xf0 == fli.s ft1, 4.0 +0xd3,0x00,0x1c,0xf0 == fli.s ft1, 8.0 +0xd3,0x80,0x1c,0xf0 == fli.s ft1, 16.0 +0xd3,0x00,0x1d,0xf0 == fli.s ft1, 128.0 +0xd3,0x80,0x1d,0xf0 == fli.s ft1, 256.0 +0xd3,0x00,0x1e,0xf0 == fli.s ft1, 32768.0 +0xd3,0x80,0x1e,0xf0 == fli.s ft1, 65536.0 +0xd3,0x00,0x1f,0xf0 == fli.s ft1, inf +0xd3,0x80,0x1f,0xf0 == fli.s ft1, nan +0xd3,0x00,0x10,0xf2 == fli.d ft1, -1.0 +0xd3,0x80,0x10,0xf2 == fli.d ft1, min +0xd3,0x00,0x11,0xf2 == fli.d ft1, 1.52587890625e-05 +0xd3,0x80,0x11,0xf2 == fli.d ft1, 3.0517578125e-05 +0xd3,0x00,0x12,0xf2 == fli.d ft1, 0.00390625 +0xd3,0x80,0x12,0xf2 == fli.d ft1, 0.0078125 +0xd3,0x00,0x13,0xf2 == fli.d ft1, 0.0625 +0xd3,0x80,0x13,0xf2 == fli.d ft1, 0.125 +0xd3,0x00,0x14,0xf2 == fli.d ft1, 0.25 +0xd3,0x80,0x14,0xf2 == fli.d ft1, 0.3125 +0xd3,0x00,0x15,0xf2 == fli.d ft1, 0.375 +0xd3,0x80,0x15,0xf2 == fli.d ft1, 0.4375 +0xd3,0x00,0x16,0xf2 == fli.d ft1, 0.5 +0xd3,0x80,0x16,0xf2 == fli.d ft1, 0.625 +0xd3,0x00,0x17,0xf2 == fli.d ft1, 0.75 +0xd3,0x80,0x17,0xf2 == fli.d ft1, 0.875 +0xd3,0x00,0x18,0xf2 == fli.d ft1, 1.0 +0xd3,0x80,0x18,0xf2 == fli.d ft1, 1.25 +0xd3,0x00,0x19,0xf2 == fli.d ft1, 1.5 +0xd3,0x80,0x19,0xf2 == fli.d ft1, 1.75 +0xd3,0x00,0x1a,0xf2 == fli.d ft1, 2.0 +0xd3,0x80,0x1a,0xf2 == fli.d ft1, 2.5 +0xd3,0x00,0x1b,0xf2 == fli.d ft1, 3.0 +0xd3,0x80,0x1b,0xf2 == fli.d ft1, 4.0 +0xd3,0x00,0x1c,0xf2 == fli.d ft1, 8.0 +0xd3,0x80,0x1c,0xf2 == fli.d ft1, 16.0 +0xd3,0x00,0x1d,0xf2 == fli.d ft1, 128.0 +0xd3,0x80,0x1d,0xf2 == fli.d ft1, 256.0 +0xd3,0x00,0x1e,0xf2 == fli.d ft1, 32768.0 +0xd3,0x80,0x1e,0xf2 == fli.d ft1, 65536.0 +0xd3,0x00,0x1f,0xf2 == fli.d ft1, inf +0xd3,0x80,0x1f,0xf2 == fli.d ft1, nan +0xd3,0x00,0x10,0xf4 == fli.h ft1, -1.0 +0xd3,0x80,0x10,0xf4 == fli.h ft1, min +0xd3,0x00,0x11,0xf4 == fli.h ft1, 1.52587890625e-05 +0xd3,0x80,0x11,0xf4 == fli.h ft1, 3.0517578125e-05 +0xd3,0x00,0x12,0xf4 == fli.h ft1, 0.00390625 +0xd3,0x80,0x12,0xf4 == fli.h ft1, 0.0078125 +0xd3,0x00,0x13,0xf4 == fli.h ft1, 0.0625 +0xd3,0x80,0x13,0xf4 == fli.h ft1, 0.125 +0xd3,0x00,0x14,0xf4 == fli.h ft1, 0.25 +0xd3,0x80,0x14,0xf4 == fli.h ft1, 0.3125 +0xd3,0x00,0x15,0xf4 == fli.h ft1, 0.375 +0xd3,0x80,0x15,0xf4 == fli.h ft1, 0.4375 +0xd3,0x00,0x16,0xf4 == fli.h ft1, 0.5 +0xd3,0x80,0x16,0xf4 == fli.h ft1, 0.625 +0xd3,0x00,0x17,0xf4 == fli.h ft1, 0.75 +0xd3,0x80,0x17,0xf4 == fli.h ft1, 0.875 +0xd3,0x00,0x18,0xf4 == fli.h ft1, 1.0 +0xd3,0x80,0x18,0xf4 == fli.h ft1, 1.25 +0xd3,0x00,0x19,0xf4 == fli.h ft1, 1.5 +0xd3,0x80,0x19,0xf4 == fli.h ft1, 1.75 +0xd3,0x00,0x1a,0xf4 == fli.h ft1, 2.0 +0xd3,0x80,0x1a,0xf4 == fli.h ft1, 2.5 +0xd3,0x00,0x1b,0xf4 == fli.h ft1, 3.0 +0xd3,0x80,0x1b,0xf4 == fli.h ft1, 4.0 +0xd3,0x00,0x1c,0xf4 == fli.h ft1, 8.0 +0xd3,0x80,0x1c,0xf4 == fli.h ft1, 16.0 +0xd3,0x00,0x1d,0xf4 == fli.h ft1, 128.0 +0xd3,0x80,0x1d,0xf4 == fli.h ft1, 256.0 +0xd3,0x00,0x1e,0xf4 == fli.h ft1, 32768.0 +0xd3,0x80,0x1e,0xf4 == fli.h ft1, 65536.0 +0xd3,0x00,0x1f,0xf4 == fli.h ft1, inf +0xd3,0x80,0x1f,0xf4 == fli.h ft1, nan +0x53,0xa5,0xc5,0x28 == fminm.s fa0, fa1, fa2 +0xd3,0x39,0x5a,0x29 == fmaxm.s fs3, fs4, fs5 +0x53,0xa5,0xc5,0x2a == fminm.d fa0, fa1, fa2 +0xd3,0x39,0x5a,0x2b == fmaxm.d fs3, fs4, fs5 +0x53,0xa5,0xc5,0x2c == fminm.h fa0, fa1, fa2 +0xd3,0x39,0x5a,0x2d == fmaxm.h fs3, fs4, fs5 +0xd3,0x74,0x49,0x40 == fround.s fs1, fs2, dyn +0xd3,0x14,0x49,0x40 == fround.s fs1, fs2, rtz +0xd3,0x04,0x49,0x40 == fround.s fs1, fs2, rne +0xd3,0x74,0x59,0x40 == froundnx.s fs1, fs2, dyn +0xd3,0x14,0x59,0x40 == froundnx.s fs1, fs2, rtz +0xd3,0x04,0x59,0x40 == froundnx.s fs1, fs2, rne +0xd3,0x74,0x49,0x42 == fround.d fs1, fs2, dyn +0xd3,0x14,0x49,0x42 == fround.d fs1, fs2, rtz +0xd3,0x04,0x49,0x42 == fround.d fs1, fs2, rne +0xd3,0x74,0x59,0x42 == froundnx.d fs1, fs2, dyn +0xd3,0x14,0x59,0x42 == froundnx.d fs1, fs2, rtz +0xd3,0x04,0x59,0x42 == froundnx.d fs1, fs2, rne +0xd3,0xf0,0x45,0x44 == fround.h ft1, fa1, dyn +0xd3,0x90,0x45,0x44 == fround.h ft1, fa1, rtz +0xd3,0x04,0x49,0x44 == fround.h fs1, fs2, rne +0xd3,0xf0,0x55,0x44 == froundnx.h ft1, fa1, dyn +0xd3,0x90,0x55,0x44 == froundnx.h ft1, fa1, rtz +0xd3,0x04,0x59,0x44 == froundnx.h fs1, fs2, rne +0xd3,0x95,0x80,0xc2 == fcvtmod.w.d a1, ft1, rtz +0xd3,0xd5,0x24,0xa1 == fltq.s a1, fs1, fs2 +0xd3,0xc5,0x20,0xa0 == fleq.s a1, ft1, ft2 +0xd3,0x55,0x99,0xa0 == fltq.s a1, fs2, fs1 +0xd3,0x45,0x11,0xa0 == fleq.s a1, ft2, ft1 +0xd3,0xd5,0x24,0xa3 == fltq.d a1, fs1, fs2 +0xd3,0xc5,0x20,0xa2 == fleq.d a1, ft1, ft2 +0xd3,0x55,0x99,0xa2 == fltq.d a1, fs2, fs1 +0xd3,0x45,0x11,0xa2 == fleq.d a1, ft2, ft1 +0xd3,0xd5,0x24,0xa5 == fltq.h a1, fs1, fs2 +0xd3,0xc5,0x20,0xa4 == fleq.h a1, ft1, ft2 +0xd3,0x55,0x99,0xa4 == fltq.h a1, fs2, fs1 +0xd3,0x45,0x11,0xa4 == fleq.h a1, ft2, ft1 \ No newline at end of file diff --git a/suite/MC/RISCV/zfa_zfhmin_zvfh_valid_riscv32_zfa__zfhmin__zvfh_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/zfa_zfhmin_zvfh_valid_riscv32_zfa__zfhmin__zvfh_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..a9b821b13d --- /dev/null +++ b/suite/MC/RISCV/zfa_zfhmin_zvfh_valid_riscv32_zfa__zfhmin__zvfh_syntax_no_alias_text.txt.cs @@ -0,0 +1,2 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32", None +0xd3,0x00,0x10,0xf4 == fli.h ft1, -1.0 \ No newline at end of file diff --git a/suite/MC/RISCV/zicfilp_valid_riscv32_experimental_zicfilp_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/zicfilp_valid_riscv32_experimental_zicfilp_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..be83636322 --- /dev/null +++ b/suite/MC/RISCV/zicfilp_valid_riscv32_experimental_zicfilp_syntax_no_alias_text.txt.cs @@ -0,0 +1,2 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32", None +0x17,0x60,0x01,0x00 == auipc zero, 22 \ No newline at end of file diff --git a/suite/MC/RISCV/zicfiss_valid_riscv32_riscv_a_riscv_experimental_zicfiss_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/zicfiss_valid_riscv32_riscv_a_riscv_experimental_zicfiss_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..a182035562 --- /dev/null +++ b/suite/MC/RISCV/zicfiss_valid_riscv32_riscv_a_riscv_experimental_zicfiss_syntax_no_alias_text.txt.cs @@ -0,0 +1,10 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32"|"CS_MODE_RISCV_A"|"CS_MODE_RISCV_EXPERIMENTAL_ZICFISS", None +0x73,0xc0,0xc0,0xcd == sspopchk ra +0x73,0xc0,0xc2,0xcd == sspopchk t0 +0x73,0x40,0x10,0xce == sspush ra +0x73,0x40,0x50,0xce == sspush t0 +0xf3,0x40,0xc0,0xcd == ssrdp ra +0x2f,0x27,0x14,0x48 == ssamoswap.w a4, ra, (s0) +0x2f,0x27,0x14,0x4c == ssamoswap.w.aq a4, ra, (s0) +0x2f,0x27,0x14,0x4a == ssamoswap.w.rl a4, ra, (s0) +0x2f,0x27,0x14,0x4e == ssamoswap.w.aqrl a4, ra, (s0) \ No newline at end of file diff --git a/suite/MC/RISCV/zvbb_riscv32_zve32x_zvbb.txt.cs b/suite/MC/RISCV/zvbb_riscv32_zve32x_zvbb.txt.cs new file mode 100644 index 0000000000..a387f7fa0e --- /dev/null +++ b/suite/MC/RISCV/zvbb_riscv32_zve32x_zvbb.txt.cs @@ -0,0 +1,8 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32", None +0x57,0x25,0x95,0x48 == vbrev.v v10, v9, v0.t +0x57,0x25,0x96,0x48 == vclz.v v10, v9, v0.t +0x57,0x25,0x97,0x48 == vcpop.v v10, v9, v0.t +0x57,0xa5,0x96,0x48 == vctz.v v10, v9, v0.t +0x57,0x05,0x94,0xd4 == vwsll.vv v10, v9, v8, v0.t +0x57,0x45,0x95,0xd4 == vwsll.vx v10, v9, a0, v0.t +0x57,0xb5,0x9e,0xd4 == vwsll.vi v10, v9, 29, v0.t \ No newline at end of file diff --git a/suite/MC/RISCV/zvbc_riscv32_zve64x_zvbc.txt.cs b/suite/MC/RISCV/zvbc_riscv32_zve64x_zvbc.txt.cs new file mode 100644 index 0000000000..6ac9343e8e --- /dev/null +++ b/suite/MC/RISCV/zvbc_riscv32_zve64x_zvbc.txt.cs @@ -0,0 +1,5 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32", None +0x57,0x25,0x94,0x32 == vclmul.vv v10, v9, v8 +0x57,0x65,0x95,0x32 == vclmul.vx v10, v9, a0 +0x57,0x25,0x94,0x36 == vclmulh.vv v10, v9, v8 +0x57,0x65,0x95,0x36 == vclmulh.vx v10, v9, a0 \ No newline at end of file diff --git a/suite/MC/RISCV/zvfbfmin_riscv32_experimental_zvfbfmin.txt.cs b/suite/MC/RISCV/zvfbfmin_riscv32_experimental_zvfbfmin.txt.cs new file mode 100644 index 0000000000..d5ee76d438 --- /dev/null +++ b/suite/MC/RISCV/zvfbfmin_riscv32_experimental_zvfbfmin.txt.cs @@ -0,0 +1,5 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32", None +0x57,0x94,0x4e,0x48 == vfncvtbf16.f.f.w v8, v4, v0.t +0x57,0x94,0x4e,0x4a == vfncvtbf16.f.f.w v8, v4 +0x57,0x94,0x46,0x48 == vfwcvtbf16.f.f.v v8, v4, v0.t +0x57,0x94,0x46,0x4a == vfwcvtbf16.f.f.v v8, v4 \ No newline at end of file diff --git a/suite/MC/RISCV/zvfbfwma_riscv32_experimental_zvfbfwma.txt.cs b/suite/MC/RISCV/zvfbfwma_riscv32_experimental_zvfbfwma.txt.cs new file mode 100644 index 0000000000..9e8aeb59df --- /dev/null +++ b/suite/MC/RISCV/zvfbfwma_riscv32_experimental_zvfbfwma.txt.cs @@ -0,0 +1,9 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32", None +0x57,0x14,0x4a,0xec == vfwmaccbf16.vv v8, v20, v4, v0.t +0x57,0x14,0x4a,0xee == vfwmaccbf16.vv v8, v20, v4 +0x57,0x54,0x45,0xec == vfwmaccbf16.vf v8, fa0, v4, v0.t +0x57,0x54,0x45,0xee == vfwmaccbf16.vf v8, fa0, v4 +0x07,0x10,0xc5,0x00 == flh ft0, 12(a0) +0xa7,0x1f,0x6a,0x7e == fsh ft6, 2047(s4) +0x53,0x86,0x0b,0xe4 == fmv.x.h a2, fs7 +0xd3,0x00,0x08,0xf4 == fmv.h.x ft1, a6 \ No newline at end of file diff --git a/suite/MC/RISCV/zvkb_riscv32_zve32x_zvkb.txt.cs b/suite/MC/RISCV/zvkb_riscv32_zve32x_zvkb.txt.cs new file mode 100644 index 0000000000..c5d6e16987 --- /dev/null +++ b/suite/MC/RISCV/zvkb_riscv32_zve32x_zvkb.txt.cs @@ -0,0 +1,10 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32", None +0x57,0x05,0x94,0x04 == vandn.vv v10, v9, v8, v0.t +0x57,0x45,0x95,0x04 == vandn.vx v10, v9, a0, v0.t +0x57,0x25,0x94,0x48 == vbrev8.v v10, v9, v0.t +0x57,0xa5,0x94,0x48 == vrev8.v v10, v9, v0.t +0x57,0x05,0x94,0x54 == vrol.vv v10, v9, v8, v0.t +0x57,0x45,0x95,0x54 == vrol.vx v10, v9, a0, v0.t +0x57,0x05,0x94,0x50 == vror.vv v10, v9, v8, v0.t +0x57,0x45,0x95,0x50 == vror.vx v10, v9, a0, v0.t +0x57,0xb5,0x90,0x54 == vror.vi v10, v9, 33, v0.t \ No newline at end of file diff --git a/suite/MC/RISCV/zvkg_riscv32_zve32x_zvkg.txt.cs b/suite/MC/RISCV/zvkg_riscv32_zve32x_zvkg.txt.cs new file mode 100644 index 0000000000..3c98e900b0 --- /dev/null +++ b/suite/MC/RISCV/zvkg_riscv32_zve32x_zvkg.txt.cs @@ -0,0 +1,3 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32", None +0x77,0x25,0x94,0xb2 == vghsh.vv v10, v9, v8 +0x77,0xa5,0x98,0xa2 == vgmul.vv v10, v9 \ No newline at end of file diff --git a/suite/MC/RISCV/zvkned_riscv32_zve32x_zvkned.txt.cs b/suite/MC/RISCV/zvkned_riscv32_zve32x_zvkned.txt.cs new file mode 100644 index 0000000000..2933b603a9 --- /dev/null +++ b/suite/MC/RISCV/zvkned_riscv32_zve32x_zvkned.txt.cs @@ -0,0 +1,14 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32", None +0x77,0xa5,0x90,0xa2 == vaesdf.vv v10, v9 +0x77,0xa5,0x90,0xa6 == vaesdf.vs v10, v9 +0x77,0xa5,0x91,0xa2 == vaesef.vv v10, v9 +0x77,0xa5,0x91,0xa6 == vaesef.vs v10, v9 +0x77,0x25,0x90,0xa2 == vaesdm.vv v10, v9 +0x77,0x25,0x90,0xa6 == vaesdm.vs v10, v9 +0x77,0x25,0x91,0xa2 == vaesem.vv v10, v9 +0x77,0x25,0x91,0xa6 == vaesem.vs v10, v9 +0x77,0xa5,0x90,0x8a == vaeskf1.vi v10, v9, 1 +0x77,0xa5,0x9f,0x8a == vaeskf1.vi v10, v9, 31 +0x77,0x25,0x91,0xaa == vaeskf2.vi v10, v9, 2 +0x77,0xa5,0x9f,0xaa == vaeskf2.vi v10, v9, 31 +0x77,0xa5,0x93,0xa6 == vaesz.vs v10, v9 \ No newline at end of file diff --git a/suite/MC/RISCV/zvknh_riscv32_zve32x_zvknha.txt.cs b/suite/MC/RISCV/zvknh_riscv32_zve32x_zvknha.txt.cs new file mode 100644 index 0000000000..83e9c1e0b6 --- /dev/null +++ b/suite/MC/RISCV/zvknh_riscv32_zve32x_zvknha.txt.cs @@ -0,0 +1,4 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32", None +0x77,0x25,0x94,0xb6 == vsha2ms.vv v10, v9, v8 +0x77,0x25,0x94,0xba == vsha2ch.vv v10, v9, v8 +0x77,0x25,0x94,0xbe == vsha2cl.vv v10, v9, v8 \ No newline at end of file diff --git a/suite/MC/RISCV/zvksed_riscv32_zve32x_zvksed.txt.cs b/suite/MC/RISCV/zvksed_riscv32_zve32x_zvksed.txt.cs new file mode 100644 index 0000000000..655c583a60 --- /dev/null +++ b/suite/MC/RISCV/zvksed_riscv32_zve32x_zvksed.txt.cs @@ -0,0 +1,5 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32", None +0x77,0xa5,0x93,0x86 == vsm4k.vi v10, v9, 7 +0x77,0xa5,0x9f,0x86 == vsm4k.vi v10, v9, 31 +0x77,0x25,0x98,0xa2 == vsm4r.vv v10, v9 +0x77,0x25,0x98,0xa6 == vsm4r.vs v10, v9 \ No newline at end of file diff --git a/suite/MC/RISCV/zvksh_riscv32_zve32x_zvksh.txt.cs b/suite/MC/RISCV/zvksh_riscv32_zve32x_zvksh.txt.cs new file mode 100644 index 0000000000..7920b331fa --- /dev/null +++ b/suite/MC/RISCV/zvksh_riscv32_zve32x_zvksh.txt.cs @@ -0,0 +1,3 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV32", None +0x77,0xa5,0x93,0xae == vsm3c.vi v10, v9, 7 +0x77,0x25,0x94,0x82 == vsm3me.vv v10, v9, v8 \ No newline at end of file diff --git a/suite/MC/RISCV/zvlsseg_riscv64_riscv_v_syntax_no_alias_text.txt.cs b/suite/MC/RISCV/zvlsseg_riscv64_riscv_v_syntax_no_alias_text.txt.cs new file mode 100644 index 0000000000..7a21087b33 --- /dev/null +++ b/suite/MC/RISCV/zvlsseg_riscv64_riscv_v_syntax_no_alias_text.txt.cs @@ -0,0 +1,505 @@ +# CS_ARCH_RISCV, "CS_MODE_RISCV64"|"CS_MODE_RISCV_V", None +0x07,0x04,0x05,0x20 == vlseg2e8.v v8, (a0), v0.t +0x07,0x04,0x05,0x22 == vlseg2e8.v v8, (a0) +0x07,0x54,0x05,0x20 == vlseg2e16.v v8, (a0), v0.t +0x07,0x54,0x05,0x22 == vlseg2e16.v v8, (a0) +0x07,0x64,0x05,0x20 == vlseg2e32.v v8, (a0), v0.t +0x07,0x64,0x05,0x22 == vlseg2e32.v v8, (a0) +0x07,0x74,0x05,0x20 == vlseg2e64.v v8, (a0), v0.t +0x07,0x74,0x05,0x22 == vlseg2e64.v v8, (a0) +0x07,0x04,0x05,0x21 == vlseg2e8ff.v v8, (a0), v0.t +0x07,0x04,0x05,0x23 == vlseg2e8ff.v v8, (a0) +0x07,0x54,0x05,0x21 == vlseg2e16ff.v v8, (a0), v0.t +0x07,0x54,0x05,0x23 == vlseg2e16ff.v v8, (a0) +0x07,0x64,0x05,0x21 == vlseg2e32ff.v v8, (a0), v0.t +0x07,0x64,0x05,0x23 == vlseg2e32ff.v v8, (a0) +0x07,0x74,0x05,0x21 == vlseg2e64ff.v v8, (a0), v0.t +0x07,0x74,0x05,0x23 == vlseg2e64ff.v v8, (a0) +0x07,0x04,0xb5,0x28 == vlsseg2e8.v v8, (a0), a1, v0.t +0x07,0x04,0xb5,0x2a == vlsseg2e8.v v8, (a0), a1 +0x07,0x54,0xb5,0x28 == vlsseg2e16.v v8, (a0), a1, v0.t +0x07,0x54,0xb5,0x2a == vlsseg2e16.v v8, (a0), a1 +0x07,0x64,0xb5,0x28 == vlsseg2e32.v v8, (a0), a1, v0.t +0x07,0x64,0xb5,0x2a == vlsseg2e32.v v8, (a0), a1 +0x07,0x74,0xb5,0x28 == vlsseg2e64.v v8, (a0), a1, v0.t +0x07,0x74,0xb5,0x2a == vlsseg2e64.v v8, (a0), a1 +0x07,0x04,0x45,0x24 == vluxseg2ei8.v v8, (a0), v4, v0.t +0x07,0x04,0x45,0x26 == vluxseg2ei8.v v8, (a0), v4 +0x07,0x54,0x45,0x24 == vluxseg2ei16.v v8, (a0), v4, v0.t +0x07,0x54,0x45,0x26 == vluxseg2ei16.v v8, (a0), v4 +0x07,0x64,0x45,0x24 == vluxseg2ei32.v v8, (a0), v4, v0.t +0x07,0x64,0x45,0x26 == vluxseg2ei32.v v8, (a0), v4 +0x07,0x74,0x45,0x24 == vluxseg2ei64.v v8, (a0), v4, v0.t +0x07,0x74,0x45,0x26 == vluxseg2ei64.v v8, (a0), v4 +0x07,0x04,0x45,0x2c == vloxseg2ei8.v v8, (a0), v4, v0.t +0x07,0x04,0x45,0x2e == vloxseg2ei8.v v8, (a0), v4 +0x07,0x54,0x45,0x2c == vloxseg2ei16.v v8, (a0), v4, v0.t +0x07,0x54,0x45,0x2e == vloxseg2ei16.v v8, (a0), v4 +0x07,0x64,0x45,0x2c == vloxseg2ei32.v v8, (a0), v4, v0.t +0x07,0x64,0x45,0x2e == vloxseg2ei32.v v8, (a0), v4 +0x07,0x74,0x45,0x2c == vloxseg2ei64.v v8, (a0), v4, v0.t +0x07,0x74,0x45,0x2e == vloxseg2ei64.v v8, (a0), v4 +0x07,0x04,0x05,0x40 == vlseg3e8.v v8, (a0), v0.t +0x07,0x04,0x05,0x42 == vlseg3e8.v v8, (a0) +0x07,0x54,0x05,0x40 == vlseg3e16.v v8, (a0), v0.t +0x07,0x54,0x05,0x42 == vlseg3e16.v v8, (a0) +0x07,0x64,0x05,0x40 == vlseg3e32.v v8, (a0), v0.t +0x07,0x64,0x05,0x42 == vlseg3e32.v v8, (a0) +0x07,0x74,0x05,0x40 == vlseg3e64.v v8, (a0), v0.t +0x07,0x74,0x05,0x42 == vlseg3e64.v v8, (a0) +0x07,0x04,0x05,0x41 == vlseg3e8ff.v v8, (a0), v0.t +0x07,0x04,0x05,0x43 == vlseg3e8ff.v v8, (a0) +0x07,0x54,0x05,0x41 == vlseg3e16ff.v v8, (a0), v0.t +0x07,0x54,0x05,0x43 == vlseg3e16ff.v v8, (a0) +0x07,0x64,0x05,0x41 == vlseg3e32ff.v v8, (a0), v0.t +0x07,0x64,0x05,0x43 == vlseg3e32ff.v v8, (a0) +0x07,0x74,0x05,0x41 == vlseg3e64ff.v v8, (a0), v0.t +0x07,0x74,0x05,0x43 == vlseg3e64ff.v v8, (a0) +0x07,0x04,0xb5,0x48 == vlsseg3e8.v v8, (a0), a1, v0.t +0x07,0x04,0xb5,0x4a == vlsseg3e8.v v8, (a0), a1 +0x07,0x54,0xb5,0x48 == vlsseg3e16.v v8, (a0), a1, v0.t +0x07,0x54,0xb5,0x4a == vlsseg3e16.v v8, (a0), a1 +0x07,0x64,0xb5,0x48 == vlsseg3e32.v v8, (a0), a1, v0.t +0x07,0x64,0xb5,0x4a == vlsseg3e32.v v8, (a0), a1 +0x07,0x74,0xb5,0x48 == vlsseg3e64.v v8, (a0), a1, v0.t +0x07,0x74,0xb5,0x4a == vlsseg3e64.v v8, (a0), a1 +0x07,0x04,0x45,0x44 == vluxseg3ei8.v v8, (a0), v4, v0.t +0x07,0x04,0x45,0x46 == vluxseg3ei8.v v8, (a0), v4 +0x07,0x54,0x45,0x44 == vluxseg3ei16.v v8, (a0), v4, v0.t +0x07,0x54,0x45,0x46 == vluxseg3ei16.v v8, (a0), v4 +0x07,0x64,0x45,0x44 == vluxseg3ei32.v v8, (a0), v4, v0.t +0x07,0x64,0x45,0x46 == vluxseg3ei32.v v8, (a0), v4 +0x07,0x74,0x45,0x44 == vluxseg3ei64.v v8, (a0), v4, v0.t +0x07,0x74,0x45,0x46 == vluxseg3ei64.v v8, (a0), v4 +0x07,0x04,0x45,0x4c == vloxseg3ei8.v v8, (a0), v4, v0.t +0x07,0x04,0x45,0x4e == vloxseg3ei8.v v8, (a0), v4 +0x07,0x54,0x45,0x4c == vloxseg3ei16.v v8, (a0), v4, v0.t +0x07,0x54,0x45,0x4e == vloxseg3ei16.v v8, (a0), v4 +0x07,0x64,0x45,0x4c == vloxseg3ei32.v v8, (a0), v4, v0.t +0x07,0x64,0x45,0x4e == vloxseg3ei32.v v8, (a0), v4 +0x07,0x74,0x45,0x4c == vloxseg3ei64.v v8, (a0), v4, v0.t +0x07,0x74,0x45,0x4e == vloxseg3ei64.v v8, (a0), v4 +0x07,0x04,0x05,0x60 == vlseg4e8.v v8, (a0), v0.t +0x07,0x04,0x05,0x62 == vlseg4e8.v v8, (a0) +0x07,0x54,0x05,0x60 == vlseg4e16.v v8, (a0), v0.t +0x07,0x54,0x05,0x62 == vlseg4e16.v v8, (a0) +0x07,0x64,0x05,0x60 == vlseg4e32.v v8, (a0), v0.t +0x07,0x64,0x05,0x62 == vlseg4e32.v v8, (a0) +0x07,0x74,0x05,0x60 == vlseg4e64.v v8, (a0), v0.t +0x07,0x74,0x05,0x62 == vlseg4e64.v v8, (a0) +0x07,0x04,0x05,0x61 == vlseg4e8ff.v v8, (a0), v0.t +0x07,0x04,0x05,0x63 == vlseg4e8ff.v v8, (a0) +0x07,0x54,0x05,0x61 == vlseg4e16ff.v v8, (a0), v0.t +0x07,0x54,0x05,0x63 == vlseg4e16ff.v v8, (a0) +0x07,0x64,0x05,0x61 == vlseg4e32ff.v v8, (a0), v0.t +0x07,0x64,0x05,0x63 == vlseg4e32ff.v v8, (a0) +0x07,0x74,0x05,0x61 == vlseg4e64ff.v v8, (a0), v0.t +0x07,0x74,0x05,0x63 == vlseg4e64ff.v v8, (a0) +0x07,0x04,0xb5,0x68 == vlsseg4e8.v v8, (a0), a1, v0.t +0x07,0x04,0xb5,0x6a == vlsseg4e8.v v8, (a0), a1 +0x07,0x54,0xb5,0x68 == vlsseg4e16.v v8, (a0), a1, v0.t +0x07,0x54,0xb5,0x6a == vlsseg4e16.v v8, (a0), a1 +0x07,0x64,0xb5,0x68 == vlsseg4e32.v v8, (a0), a1, v0.t +0x07,0x64,0xb5,0x6a == vlsseg4e32.v v8, (a0), a1 +0x07,0x74,0xb5,0x68 == vlsseg4e64.v v8, (a0), a1, v0.t +0x07,0x74,0xb5,0x6a == vlsseg4e64.v v8, (a0), a1 +0x07,0x04,0x45,0x64 == vluxseg4ei8.v v8, (a0), v4, v0.t +0x07,0x04,0x45,0x66 == vluxseg4ei8.v v8, (a0), v4 +0x07,0x54,0x45,0x64 == vluxseg4ei16.v v8, (a0), v4, v0.t +0x07,0x54,0x45,0x66 == vluxseg4ei16.v v8, (a0), v4 +0x07,0x64,0x45,0x64 == vluxseg4ei32.v v8, (a0), v4, v0.t +0x07,0x64,0x45,0x66 == vluxseg4ei32.v v8, (a0), v4 +0x07,0x74,0x45,0x64 == vluxseg4ei64.v v8, (a0), v4, v0.t +0x07,0x74,0x45,0x66 == vluxseg4ei64.v v8, (a0), v4 +0x07,0x04,0x45,0x6c == vloxseg4ei8.v v8, (a0), v4, v0.t +0x07,0x04,0x45,0x6e == vloxseg4ei8.v v8, (a0), v4 +0x07,0x54,0x45,0x6c == vloxseg4ei16.v v8, (a0), v4, v0.t +0x07,0x54,0x45,0x6e == vloxseg4ei16.v v8, (a0), v4 +0x07,0x64,0x45,0x6c == vloxseg4ei32.v v8, (a0), v4, v0.t +0x07,0x64,0x45,0x6e == vloxseg4ei32.v v8, (a0), v4 +0x07,0x74,0x45,0x6c == vloxseg4ei64.v v8, (a0), v4, v0.t +0x07,0x74,0x45,0x6e == vloxseg4ei64.v v8, (a0), v4 +0x07,0x04,0x05,0x80 == vlseg5e8.v v8, (a0), v0.t +0x07,0x04,0x05,0x82 == vlseg5e8.v v8, (a0) +0x07,0x54,0x05,0x80 == vlseg5e16.v v8, (a0), v0.t +0x07,0x54,0x05,0x82 == vlseg5e16.v v8, (a0) +0x07,0x64,0x05,0x80 == vlseg5e32.v v8, (a0), v0.t +0x07,0x64,0x05,0x82 == vlseg5e32.v v8, (a0) +0x07,0x74,0x05,0x80 == vlseg5e64.v v8, (a0), v0.t +0x07,0x74,0x05,0x82 == vlseg5e64.v v8, (a0) +0x07,0x04,0x05,0x81 == vlseg5e8ff.v v8, (a0), v0.t +0x07,0x04,0x05,0x83 == vlseg5e8ff.v v8, (a0) +0x07,0x54,0x05,0x81 == vlseg5e16ff.v v8, (a0), v0.t +0x07,0x54,0x05,0x83 == vlseg5e16ff.v v8, (a0) +0x07,0x64,0x05,0x81 == vlseg5e32ff.v v8, (a0), v0.t +0x07,0x64,0x05,0x83 == vlseg5e32ff.v v8, (a0) +0x07,0x74,0x05,0x81 == vlseg5e64ff.v v8, (a0), v0.t +0x07,0x74,0x05,0x83 == vlseg5e64ff.v v8, (a0) +0x07,0x04,0xb5,0x88 == vlsseg5e8.v v8, (a0), a1, v0.t +0x07,0x04,0xb5,0x8a == vlsseg5e8.v v8, (a0), a1 +0x07,0x54,0xb5,0x88 == vlsseg5e16.v v8, (a0), a1, v0.t +0x07,0x54,0xb5,0x8a == vlsseg5e16.v v8, (a0), a1 +0x07,0x64,0xb5,0x88 == vlsseg5e32.v v8, (a0), a1, v0.t +0x07,0x64,0xb5,0x8a == vlsseg5e32.v v8, (a0), a1 +0x07,0x74,0xb5,0x88 == vlsseg5e64.v v8, (a0), a1, v0.t +0x07,0x74,0xb5,0x8a == vlsseg5e64.v v8, (a0), a1 +0x07,0x04,0x45,0x84 == vluxseg5ei8.v v8, (a0), v4, v0.t +0x07,0x04,0x45,0x86 == vluxseg5ei8.v v8, (a0), v4 +0x07,0x54,0x45,0x84 == vluxseg5ei16.v v8, (a0), v4, v0.t +0x07,0x54,0x45,0x86 == vluxseg5ei16.v v8, (a0), v4 +0x07,0x64,0x45,0x84 == vluxseg5ei32.v v8, (a0), v4, v0.t +0x07,0x64,0x45,0x86 == vluxseg5ei32.v v8, (a0), v4 +0x07,0x74,0x45,0x84 == vluxseg5ei64.v v8, (a0), v4, v0.t +0x07,0x74,0x45,0x86 == vluxseg5ei64.v v8, (a0), v4 +0x07,0x04,0x45,0x8c == vloxseg5ei8.v v8, (a0), v4, v0.t +0x07,0x04,0x45,0x8e == vloxseg5ei8.v v8, (a0), v4 +0x07,0x54,0x45,0x8c == vloxseg5ei16.v v8, (a0), v4, v0.t +0x07,0x54,0x45,0x8e == vloxseg5ei16.v v8, (a0), v4 +0x07,0x64,0x45,0x8c == vloxseg5ei32.v v8, (a0), v4, v0.t +0x07,0x64,0x45,0x8e == vloxseg5ei32.v v8, (a0), v4 +0x07,0x74,0x45,0x8c == vloxseg5ei64.v v8, (a0), v4, v0.t +0x07,0x74,0x45,0x8e == vloxseg5ei64.v v8, (a0), v4 +0x07,0x04,0x05,0xa0 == vlseg6e8.v v8, (a0), v0.t +0x07,0x04,0x05,0xa2 == vlseg6e8.v v8, (a0) +0x07,0x54,0x05,0xa0 == vlseg6e16.v v8, (a0), v0.t +0x07,0x54,0x05,0xa2 == vlseg6e16.v v8, (a0) +0x07,0x64,0x05,0xa0 == vlseg6e32.v v8, (a0), v0.t +0x07,0x64,0x05,0xa2 == vlseg6e32.v v8, (a0) +0x07,0x74,0x05,0xa0 == vlseg6e64.v v8, (a0), v0.t +0x07,0x74,0x05,0xa2 == vlseg6e64.v v8, (a0) +0x07,0x04,0x05,0xa1 == vlseg6e8ff.v v8, (a0), v0.t +0x07,0x04,0x05,0xa3 == vlseg6e8ff.v v8, (a0) +0x07,0x54,0x05,0xa1 == vlseg6e16ff.v v8, (a0), v0.t +0x07,0x54,0x05,0xa3 == vlseg6e16ff.v v8, (a0) +0x07,0x64,0x05,0xa1 == vlseg6e32ff.v v8, (a0), v0.t +0x07,0x64,0x05,0xa3 == vlseg6e32ff.v v8, (a0) +0x07,0x74,0x05,0xa1 == vlseg6e64ff.v v8, (a0), v0.t +0x07,0x74,0x05,0xa3 == vlseg6e64ff.v v8, (a0) +0x07,0x04,0xb5,0xa8 == vlsseg6e8.v v8, (a0), a1, v0.t +0x07,0x04,0xb5,0xaa == vlsseg6e8.v v8, (a0), a1 +0x07,0x54,0xb5,0xa8 == vlsseg6e16.v v8, (a0), a1, v0.t +0x07,0x54,0xb5,0xaa == vlsseg6e16.v v8, (a0), a1 +0x07,0x64,0xb5,0xa8 == vlsseg6e32.v v8, (a0), a1, v0.t +0x07,0x64,0xb5,0xaa == vlsseg6e32.v v8, (a0), a1 +0x07,0x74,0xb5,0xa8 == vlsseg6e64.v v8, (a0), a1, v0.t +0x07,0x74,0xb5,0xaa == vlsseg6e64.v v8, (a0), a1 +0x07,0x04,0x45,0xa4 == vluxseg6ei8.v v8, (a0), v4, v0.t +0x07,0x04,0x45,0xa6 == vluxseg6ei8.v v8, (a0), v4 +0x07,0x54,0x45,0xa4 == vluxseg6ei16.v v8, (a0), v4, v0.t +0x07,0x54,0x45,0xa6 == vluxseg6ei16.v v8, (a0), v4 +0x07,0x64,0x45,0xa4 == vluxseg6ei32.v v8, (a0), v4, v0.t +0x07,0x64,0x45,0xa6 == vluxseg6ei32.v v8, (a0), v4 +0x07,0x74,0x45,0xa4 == vluxseg6ei64.v v8, (a0), v4, v0.t +0x07,0x74,0x45,0xa6 == vluxseg6ei64.v v8, (a0), v4 +0x07,0x04,0x45,0xac == vloxseg6ei8.v v8, (a0), v4, v0.t +0x07,0x04,0x45,0xae == vloxseg6ei8.v v8, (a0), v4 +0x07,0x54,0x45,0xac == vloxseg6ei16.v v8, (a0), v4, v0.t +0x07,0x54,0x45,0xae == vloxseg6ei16.v v8, (a0), v4 +0x07,0x64,0x45,0xac == vloxseg6ei32.v v8, (a0), v4, v0.t +0x07,0x64,0x45,0xae == vloxseg6ei32.v v8, (a0), v4 +0x07,0x74,0x45,0xac == vloxseg6ei64.v v8, (a0), v4, v0.t +0x07,0x74,0x45,0xae == vloxseg6ei64.v v8, (a0), v4 +0x07,0x04,0x05,0xc0 == vlseg7e8.v v8, (a0), v0.t +0x07,0x04,0x05,0xc2 == vlseg7e8.v v8, (a0) +0x07,0x54,0x05,0xc0 == vlseg7e16.v v8, (a0), v0.t +0x07,0x54,0x05,0xc2 == vlseg7e16.v v8, (a0) +0x07,0x64,0x05,0xc0 == vlseg7e32.v v8, (a0), v0.t +0x07,0x64,0x05,0xc2 == vlseg7e32.v v8, (a0) +0x07,0x74,0x05,0xc0 == vlseg7e64.v v8, (a0), v0.t +0x07,0x74,0x05,0xc2 == vlseg7e64.v v8, (a0) +0x07,0x04,0x05,0xc1 == vlseg7e8ff.v v8, (a0), v0.t +0x07,0x04,0x05,0xc3 == vlseg7e8ff.v v8, (a0) +0x07,0x54,0x05,0xc1 == vlseg7e16ff.v v8, (a0), v0.t +0x07,0x54,0x05,0xc3 == vlseg7e16ff.v v8, (a0) +0x07,0x64,0x05,0xc1 == vlseg7e32ff.v v8, (a0), v0.t +0x07,0x64,0x05,0xc3 == vlseg7e32ff.v v8, (a0) +0x07,0x74,0x05,0xc1 == vlseg7e64ff.v v8, (a0), v0.t +0x07,0x74,0x05,0xc3 == vlseg7e64ff.v v8, (a0) +0x07,0x04,0xb5,0xc8 == vlsseg7e8.v v8, (a0), a1, v0.t +0x07,0x04,0xb5,0xca == vlsseg7e8.v v8, (a0), a1 +0x07,0x54,0xb5,0xc8 == vlsseg7e16.v v8, (a0), a1, v0.t +0x07,0x54,0xb5,0xca == vlsseg7e16.v v8, (a0), a1 +0x07,0x64,0xb5,0xc8 == vlsseg7e32.v v8, (a0), a1, v0.t +0x07,0x64,0xb5,0xca == vlsseg7e32.v v8, (a0), a1 +0x07,0x74,0xb5,0xc8 == vlsseg7e64.v v8, (a0), a1, v0.t +0x07,0x74,0xb5,0xca == vlsseg7e64.v v8, (a0), a1 +0x07,0x04,0x45,0xc4 == vluxseg7ei8.v v8, (a0), v4, v0.t +0x07,0x04,0x45,0xc6 == vluxseg7ei8.v v8, (a0), v4 +0x07,0x54,0x45,0xc4 == vluxseg7ei16.v v8, (a0), v4, v0.t +0x07,0x54,0x45,0xc6 == vluxseg7ei16.v v8, (a0), v4 +0x07,0x64,0x45,0xc4 == vluxseg7ei32.v v8, (a0), v4, v0.t +0x07,0x64,0x45,0xc6 == vluxseg7ei32.v v8, (a0), v4 +0x07,0x74,0x45,0xc4 == vluxseg7ei64.v v8, (a0), v4, v0.t +0x07,0x74,0x45,0xc6 == vluxseg7ei64.v v8, (a0), v4 +0x07,0x04,0x45,0xcc == vloxseg7ei8.v v8, (a0), v4, v0.t +0x07,0x04,0x45,0xce == vloxseg7ei8.v v8, (a0), v4 +0x07,0x54,0x45,0xcc == vloxseg7ei16.v v8, (a0), v4, v0.t +0x07,0x54,0x45,0xce == vloxseg7ei16.v v8, (a0), v4 +0x07,0x64,0x45,0xcc == vloxseg7ei32.v v8, (a0), v4, v0.t +0x07,0x64,0x45,0xce == vloxseg7ei32.v v8, (a0), v4 +0x07,0x74,0x45,0xcc == vloxseg7ei64.v v8, (a0), v4, v0.t +0x07,0x74,0x45,0xce == vloxseg7ei64.v v8, (a0), v4 +0x07,0x04,0x05,0xe0 == vlseg8e8.v v8, (a0), v0.t +0x07,0x04,0x05,0xe2 == vlseg8e8.v v8, (a0) +0x07,0x54,0x05,0xe0 == vlseg8e16.v v8, (a0), v0.t +0x07,0x54,0x05,0xe2 == vlseg8e16.v v8, (a0) +0x07,0x64,0x05,0xe0 == vlseg8e32.v v8, (a0), v0.t +0x07,0x64,0x05,0xe2 == vlseg8e32.v v8, (a0) +0x07,0x74,0x05,0xe0 == vlseg8e64.v v8, (a0), v0.t +0x07,0x74,0x05,0xe2 == vlseg8e64.v v8, (a0) +0x07,0x04,0x05,0xe1 == vlseg8e8ff.v v8, (a0), v0.t +0x07,0x04,0x05,0xe3 == vlseg8e8ff.v v8, (a0) +0x07,0x54,0x05,0xe1 == vlseg8e16ff.v v8, (a0), v0.t +0x07,0x54,0x05,0xe3 == vlseg8e16ff.v v8, (a0) +0x07,0x64,0x05,0xe1 == vlseg8e32ff.v v8, (a0), v0.t +0x07,0x64,0x05,0xe3 == vlseg8e32ff.v v8, (a0) +0x07,0x74,0x05,0xe1 == vlseg8e64ff.v v8, (a0), v0.t +0x07,0x74,0x05,0xe3 == vlseg8e64ff.v v8, (a0) +0x07,0x04,0xb5,0xe8 == vlsseg8e8.v v8, (a0), a1, v0.t +0x07,0x04,0xb5,0xea == vlsseg8e8.v v8, (a0), a1 +0x07,0x54,0xb5,0xe8 == vlsseg8e16.v v8, (a0), a1, v0.t +0x07,0x54,0xb5,0xea == vlsseg8e16.v v8, (a0), a1 +0x07,0x64,0xb5,0xe8 == vlsseg8e32.v v8, (a0), a1, v0.t +0x07,0x64,0xb5,0xea == vlsseg8e32.v v8, (a0), a1 +0x07,0x74,0xb5,0xe8 == vlsseg8e64.v v8, (a0), a1, v0.t +0x07,0x74,0xb5,0xea == vlsseg8e64.v v8, (a0), a1 +0x07,0x04,0x45,0xe4 == vluxseg8ei8.v v8, (a0), v4, v0.t +0x07,0x04,0x45,0xe6 == vluxseg8ei8.v v8, (a0), v4 +0x07,0x54,0x45,0xe4 == vluxseg8ei16.v v8, (a0), v4, v0.t +0x07,0x54,0x45,0xe6 == vluxseg8ei16.v v8, (a0), v4 +0x07,0x64,0x45,0xe4 == vluxseg8ei32.v v8, (a0), v4, v0.t +0x07,0x64,0x45,0xe6 == vluxseg8ei32.v v8, (a0), v4 +0x07,0x74,0x45,0xe4 == vluxseg8ei64.v v8, (a0), v4, v0.t +0x07,0x74,0x45,0xe6 == vluxseg8ei64.v v8, (a0), v4 +0x07,0x04,0x45,0xec == vloxseg8ei8.v v8, (a0), v4, v0.t +0x07,0x04,0x45,0xee == vloxseg8ei8.v v8, (a0), v4 +0x07,0x54,0x45,0xec == vloxseg8ei16.v v8, (a0), v4, v0.t +0x07,0x54,0x45,0xee == vloxseg8ei16.v v8, (a0), v4 +0x07,0x64,0x45,0xec == vloxseg8ei32.v v8, (a0), v4, v0.t +0x07,0x64,0x45,0xee == vloxseg8ei32.v v8, (a0), v4 +0x07,0x74,0x45,0xec == vloxseg8ei64.v v8, (a0), v4, v0.t +0x07,0x74,0x45,0xee == vloxseg8ei64.v v8, (a0), v4 +0x27,0x0c,0x05,0x20 == vsseg2e8.v v24, (a0), v0.t +0x27,0x0c,0x05,0x22 == vsseg2e8.v v24, (a0) +0x27,0x5c,0x05,0x20 == vsseg2e16.v v24, (a0), v0.t +0x27,0x5c,0x05,0x22 == vsseg2e16.v v24, (a0) +0x27,0x6c,0x05,0x20 == vsseg2e32.v v24, (a0), v0.t +0x27,0x6c,0x05,0x22 == vsseg2e32.v v24, (a0) +0x27,0x7c,0x05,0x20 == vsseg2e64.v v24, (a0), v0.t +0x27,0x7c,0x05,0x22 == vsseg2e64.v v24, (a0) +0x27,0x0c,0xb5,0x28 == vssseg2e8.v v24, (a0), a1, v0.t +0x27,0x0c,0xb5,0x2a == vssseg2e8.v v24, (a0), a1 +0x27,0x5c,0xb5,0x28 == vssseg2e16.v v24, (a0), a1, v0.t +0x27,0x5c,0xb5,0x2a == vssseg2e16.v v24, (a0), a1 +0x27,0x6c,0xb5,0x28 == vssseg2e32.v v24, (a0), a1, v0.t +0x27,0x6c,0xb5,0x2a == vssseg2e32.v v24, (a0), a1 +0x27,0x7c,0xb5,0x28 == vssseg2e64.v v24, (a0), a1, v0.t +0x27,0x7c,0xb5,0x2a == vssseg2e64.v v24, (a0), a1 +0x27,0x0c,0x45,0x24 == vsuxseg2ei8.v v24, (a0), v4, v0.t +0x27,0x0c,0x45,0x26 == vsuxseg2ei8.v v24, (a0), v4 +0x27,0x5c,0x45,0x24 == vsuxseg2ei16.v v24, (a0), v4, v0.t +0x27,0x5c,0x45,0x26 == vsuxseg2ei16.v v24, (a0), v4 +0x27,0x6c,0x45,0x24 == vsuxseg2ei32.v v24, (a0), v4, v0.t +0x27,0x6c,0x45,0x26 == vsuxseg2ei32.v v24, (a0), v4 +0x27,0x7c,0x45,0x24 == vsuxseg2ei64.v v24, (a0), v4, v0.t +0x27,0x7c,0x45,0x26 == vsuxseg2ei64.v v24, (a0), v4 +0x27,0x0c,0x45,0x2c == vsoxseg2ei8.v v24, (a0), v4, v0.t +0x27,0x0c,0x45,0x2e == vsoxseg2ei8.v v24, (a0), v4 +0x27,0x5c,0x45,0x2c == vsoxseg2ei16.v v24, (a0), v4, v0.t +0x27,0x5c,0x45,0x2e == vsoxseg2ei16.v v24, (a0), v4 +0x27,0x6c,0x45,0x2c == vsoxseg2ei32.v v24, (a0), v4, v0.t +0x27,0x6c,0x45,0x2e == vsoxseg2ei32.v v24, (a0), v4 +0x27,0x7c,0x45,0x2c == vsoxseg2ei64.v v24, (a0), v4, v0.t +0x27,0x7c,0x45,0x2e == vsoxseg2ei64.v v24, (a0), v4 +0x27,0x0c,0x05,0x40 == vsseg3e8.v v24, (a0), v0.t +0x27,0x0c,0x05,0x42 == vsseg3e8.v v24, (a0) +0x27,0x5c,0x05,0x40 == vsseg3e16.v v24, (a0), v0.t +0x27,0x5c,0x05,0x42 == vsseg3e16.v v24, (a0) +0x27,0x6c,0x05,0x40 == vsseg3e32.v v24, (a0), v0.t +0x27,0x6c,0x05,0x42 == vsseg3e32.v v24, (a0) +0x27,0x7c,0x05,0x40 == vsseg3e64.v v24, (a0), v0.t +0x27,0x7c,0x05,0x42 == vsseg3e64.v v24, (a0) +0x27,0x0c,0xb5,0x48 == vssseg3e8.v v24, (a0), a1, v0.t +0x27,0x0c,0xb5,0x4a == vssseg3e8.v v24, (a0), a1 +0x27,0x5c,0xb5,0x48 == vssseg3e16.v v24, (a0), a1, v0.t +0x27,0x5c,0xb5,0x4a == vssseg3e16.v v24, (a0), a1 +0x27,0x6c,0xb5,0x48 == vssseg3e32.v v24, (a0), a1, v0.t +0x27,0x6c,0xb5,0x4a == vssseg3e32.v v24, (a0), a1 +0x27,0x7c,0xb5,0x48 == vssseg3e64.v v24, (a0), a1, v0.t +0x27,0x7c,0xb5,0x4a == vssseg3e64.v v24, (a0), a1 +0x27,0x0c,0x45,0x44 == vsuxseg3ei8.v v24, (a0), v4, v0.t +0x27,0x0c,0x45,0x46 == vsuxseg3ei8.v v24, (a0), v4 +0x27,0x5c,0x45,0x44 == vsuxseg3ei16.v v24, (a0), v4, v0.t +0x27,0x5c,0x45,0x46 == vsuxseg3ei16.v v24, (a0), v4 +0x27,0x6c,0x45,0x44 == vsuxseg3ei32.v v24, (a0), v4, v0.t +0x27,0x6c,0x45,0x46 == vsuxseg3ei32.v v24, (a0), v4 +0x27,0x7c,0x45,0x44 == vsuxseg3ei64.v v24, (a0), v4, v0.t +0x27,0x7c,0x45,0x46 == vsuxseg3ei64.v v24, (a0), v4 +0x27,0x0c,0x45,0x4c == vsoxseg3ei8.v v24, (a0), v4, v0.t +0x27,0x0c,0x45,0x4e == vsoxseg3ei8.v v24, (a0), v4 +0x27,0x5c,0x45,0x4c == vsoxseg3ei16.v v24, (a0), v4, v0.t +0x27,0x5c,0x45,0x4e == vsoxseg3ei16.v v24, (a0), v4 +0x27,0x6c,0x45,0x4c == vsoxseg3ei32.v v24, (a0), v4, v0.t +0x27,0x6c,0x45,0x4e == vsoxseg3ei32.v v24, (a0), v4 +0x27,0x7c,0x45,0x4c == vsoxseg3ei64.v v24, (a0), v4, v0.t +0x27,0x7c,0x45,0x4e == vsoxseg3ei64.v v24, (a0), v4 +0x27,0x0c,0x05,0x60 == vsseg4e8.v v24, (a0), v0.t +0x27,0x0c,0x05,0x62 == vsseg4e8.v v24, (a0) +0x27,0x5c,0x05,0x60 == vsseg4e16.v v24, (a0), v0.t +0x27,0x5c,0x05,0x62 == vsseg4e16.v v24, (a0) +0x27,0x6c,0x05,0x60 == vsseg4e32.v v24, (a0), v0.t +0x27,0x6c,0x05,0x62 == vsseg4e32.v v24, (a0) +0x27,0x7c,0x05,0x60 == vsseg4e64.v v24, (a0), v0.t +0x27,0x7c,0x05,0x62 == vsseg4e64.v v24, (a0) +0x27,0x0c,0xb5,0x68 == vssseg4e8.v v24, (a0), a1, v0.t +0x27,0x0c,0xb5,0x6a == vssseg4e8.v v24, (a0), a1 +0x27,0x5c,0xb5,0x68 == vssseg4e16.v v24, (a0), a1, v0.t +0x27,0x5c,0xb5,0x6a == vssseg4e16.v v24, (a0), a1 +0x27,0x6c,0xb5,0x68 == vssseg4e32.v v24, (a0), a1, v0.t +0x27,0x6c,0xb5,0x6a == vssseg4e32.v v24, (a0), a1 +0x27,0x7c,0xb5,0x68 == vssseg4e64.v v24, (a0), a1, v0.t +0x27,0x7c,0xb5,0x6a == vssseg4e64.v v24, (a0), a1 +0x27,0x0c,0x45,0x64 == vsuxseg4ei8.v v24, (a0), v4, v0.t +0x27,0x0c,0x45,0x66 == vsuxseg4ei8.v v24, (a0), v4 +0x27,0x5c,0x45,0x64 == vsuxseg4ei16.v v24, (a0), v4, v0.t +0x27,0x5c,0x45,0x66 == vsuxseg4ei16.v v24, (a0), v4 +0x27,0x6c,0x45,0x64 == vsuxseg4ei32.v v24, (a0), v4, v0.t +0x27,0x6c,0x45,0x66 == vsuxseg4ei32.v v24, (a0), v4 +0x27,0x7c,0x45,0x64 == vsuxseg4ei64.v v24, (a0), v4, v0.t +0x27,0x7c,0x45,0x66 == vsuxseg4ei64.v v24, (a0), v4 +0x27,0x0c,0x45,0x6c == vsoxseg4ei8.v v24, (a0), v4, v0.t +0x27,0x0c,0x45,0x6e == vsoxseg4ei8.v v24, (a0), v4 +0x27,0x5c,0x45,0x6c == vsoxseg4ei16.v v24, (a0), v4, v0.t +0x27,0x5c,0x45,0x6e == vsoxseg4ei16.v v24, (a0), v4 +0x27,0x6c,0x45,0x6c == vsoxseg4ei32.v v24, (a0), v4, v0.t +0x27,0x6c,0x45,0x6e == vsoxseg4ei32.v v24, (a0), v4 +0x27,0x7c,0x45,0x6c == vsoxseg4ei64.v v24, (a0), v4, v0.t +0x27,0x7c,0x45,0x6e == vsoxseg4ei64.v v24, (a0), v4 +0x27,0x0c,0x05,0x80 == vsseg5e8.v v24, (a0), v0.t +0x27,0x0c,0x05,0x82 == vsseg5e8.v v24, (a0) +0x27,0x5c,0x05,0x80 == vsseg5e16.v v24, (a0), v0.t +0x27,0x5c,0x05,0x82 == vsseg5e16.v v24, (a0) +0x27,0x6c,0x05,0x80 == vsseg5e32.v v24, (a0), v0.t +0x27,0x6c,0x05,0x82 == vsseg5e32.v v24, (a0) +0x27,0x7c,0x05,0x80 == vsseg5e64.v v24, (a0), v0.t +0x27,0x7c,0x05,0x82 == vsseg5e64.v v24, (a0) +0x27,0x0c,0xb5,0x88 == vssseg5e8.v v24, (a0), a1, v0.t +0x27,0x0c,0xb5,0x8a == vssseg5e8.v v24, (a0), a1 +0x27,0x5c,0xb5,0x88 == vssseg5e16.v v24, (a0), a1, v0.t +0x27,0x5c,0xb5,0x8a == vssseg5e16.v v24, (a0), a1 +0x27,0x6c,0xb5,0x88 == vssseg5e32.v v24, (a0), a1, v0.t +0x27,0x6c,0xb5,0x8a == vssseg5e32.v v24, (a0), a1 +0x27,0x7c,0xb5,0x88 == vssseg5e64.v v24, (a0), a1, v0.t +0x27,0x7c,0xb5,0x8a == vssseg5e64.v v24, (a0), a1 +0x27,0x0c,0x45,0x84 == vsuxseg5ei8.v v24, (a0), v4, v0.t +0x27,0x0c,0x45,0x86 == vsuxseg5ei8.v v24, (a0), v4 +0x27,0x5c,0x45,0x84 == vsuxseg5ei16.v v24, (a0), v4, v0.t +0x27,0x5c,0x45,0x86 == vsuxseg5ei16.v v24, (a0), v4 +0x27,0x6c,0x45,0x84 == vsuxseg5ei32.v v24, (a0), v4, v0.t +0x27,0x6c,0x45,0x86 == vsuxseg5ei32.v v24, (a0), v4 +0x27,0x7c,0x45,0x84 == vsuxseg5ei64.v v24, (a0), v4, v0.t +0x27,0x7c,0x45,0x86 == vsuxseg5ei64.v v24, (a0), v4 +0x27,0x0c,0x45,0x8c == vsoxseg5ei8.v v24, (a0), v4, v0.t +0x27,0x0c,0x45,0x8e == vsoxseg5ei8.v v24, (a0), v4 +0x27,0x5c,0x45,0x8c == vsoxseg5ei16.v v24, (a0), v4, v0.t +0x27,0x5c,0x45,0x8e == vsoxseg5ei16.v v24, (a0), v4 +0x27,0x6c,0x45,0x8c == vsoxseg5ei32.v v24, (a0), v4, v0.t +0x27,0x6c,0x45,0x8e == vsoxseg5ei32.v v24, (a0), v4 +0x27,0x7c,0x45,0x8c == vsoxseg5ei64.v v24, (a0), v4, v0.t +0x27,0x7c,0x45,0x8e == vsoxseg5ei64.v v24, (a0), v4 +0x27,0x0c,0x05,0xa0 == vsseg6e8.v v24, (a0), v0.t +0x27,0x0c,0x05,0xa2 == vsseg6e8.v v24, (a0) +0x27,0x5c,0x05,0xa0 == vsseg6e16.v v24, (a0), v0.t +0x27,0x5c,0x05,0xa2 == vsseg6e16.v v24, (a0) +0x27,0x6c,0x05,0xa0 == vsseg6e32.v v24, (a0), v0.t +0x27,0x6c,0x05,0xa2 == vsseg6e32.v v24, (a0) +0x27,0x7c,0x05,0xa0 == vsseg6e64.v v24, (a0), v0.t +0x27,0x7c,0x05,0xa2 == vsseg6e64.v v24, (a0) +0x27,0x0c,0xb5,0xa8 == vssseg6e8.v v24, (a0), a1, v0.t +0x27,0x0c,0xb5,0xaa == vssseg6e8.v v24, (a0), a1 +0x27,0x5c,0xb5,0xa8 == vssseg6e16.v v24, (a0), a1, v0.t +0x27,0x5c,0xb5,0xaa == vssseg6e16.v v24, (a0), a1 +0x27,0x6c,0xb5,0xa8 == vssseg6e32.v v24, (a0), a1, v0.t +0x27,0x6c,0xb5,0xaa == vssseg6e32.v v24, (a0), a1 +0x27,0x7c,0xb5,0xa8 == vssseg6e64.v v24, (a0), a1, v0.t +0x27,0x7c,0xb5,0xaa == vssseg6e64.v v24, (a0), a1 +0x27,0x0c,0x45,0xa4 == vsuxseg6ei8.v v24, (a0), v4, v0.t +0x27,0x0c,0x45,0xa6 == vsuxseg6ei8.v v24, (a0), v4 +0x27,0x5c,0x45,0xa4 == vsuxseg6ei16.v v24, (a0), v4, v0.t +0x27,0x5c,0x45,0xa6 == vsuxseg6ei16.v v24, (a0), v4 +0x27,0x6c,0x45,0xa4 == vsuxseg6ei32.v v24, (a0), v4, v0.t +0x27,0x6c,0x45,0xa6 == vsuxseg6ei32.v v24, (a0), v4 +0x27,0x7c,0x45,0xa4 == vsuxseg6ei64.v v24, (a0), v4, v0.t +0x27,0x7c,0x45,0xa6 == vsuxseg6ei64.v v24, (a0), v4 +0x27,0x0c,0x45,0xac == vsoxseg6ei8.v v24, (a0), v4, v0.t +0x27,0x0c,0x45,0xae == vsoxseg6ei8.v v24, (a0), v4 +0x27,0x5c,0x45,0xac == vsoxseg6ei16.v v24, (a0), v4, v0.t +0x27,0x5c,0x45,0xae == vsoxseg6ei16.v v24, (a0), v4 +0x27,0x6c,0x45,0xac == vsoxseg6ei32.v v24, (a0), v4, v0.t +0x27,0x6c,0x45,0xae == vsoxseg6ei32.v v24, (a0), v4 +0x27,0x7c,0x45,0xac == vsoxseg6ei64.v v24, (a0), v4, v0.t +0x27,0x7c,0x45,0xae == vsoxseg6ei64.v v24, (a0), v4 +0x27,0x0c,0x05,0xc0 == vsseg7e8.v v24, (a0), v0.t +0x27,0x0c,0x05,0xc2 == vsseg7e8.v v24, (a0) +0x27,0x5c,0x05,0xc0 == vsseg7e16.v v24, (a0), v0.t +0x27,0x5c,0x05,0xc2 == vsseg7e16.v v24, (a0) +0x27,0x6c,0x05,0xc0 == vsseg7e32.v v24, (a0), v0.t +0x27,0x6c,0x05,0xc2 == vsseg7e32.v v24, (a0) +0x27,0x7c,0x05,0xc0 == vsseg7e64.v v24, (a0), v0.t +0x27,0x7c,0x05,0xc2 == vsseg7e64.v v24, (a0) +0x27,0x0c,0xb5,0xc8 == vssseg7e8.v v24, (a0), a1, v0.t +0x27,0x0c,0xb5,0xca == vssseg7e8.v v24, (a0), a1 +0x27,0x5c,0xb5,0xc8 == vssseg7e16.v v24, (a0), a1, v0.t +0x27,0x5c,0xb5,0xca == vssseg7e16.v v24, (a0), a1 +0x27,0x6c,0xb5,0xc8 == vssseg7e32.v v24, (a0), a1, v0.t +0x27,0x6c,0xb5,0xca == vssseg7e32.v v24, (a0), a1 +0x27,0x7c,0xb5,0xc8 == vssseg7e64.v v24, (a0), a1, v0.t +0x27,0x7c,0xb5,0xca == vssseg7e64.v v24, (a0), a1 +0x27,0x0c,0x45,0xc4 == vsuxseg7ei8.v v24, (a0), v4, v0.t +0x27,0x0c,0x45,0xc6 == vsuxseg7ei8.v v24, (a0), v4 +0x27,0x5c,0x45,0xc4 == vsuxseg7ei16.v v24, (a0), v4, v0.t +0x27,0x5c,0x45,0xc6 == vsuxseg7ei16.v v24, (a0), v4 +0x27,0x6c,0x45,0xc4 == vsuxseg7ei32.v v24, (a0), v4, v0.t +0x27,0x6c,0x45,0xc6 == vsuxseg7ei32.v v24, (a0), v4 +0x27,0x7c,0x45,0xc4 == vsuxseg7ei64.v v24, (a0), v4, v0.t +0x27,0x7c,0x45,0xc6 == vsuxseg7ei64.v v24, (a0), v4 +0x27,0x0c,0x45,0xcc == vsoxseg7ei8.v v24, (a0), v4, v0.t +0x27,0x0c,0x45,0xce == vsoxseg7ei8.v v24, (a0), v4 +0x27,0x5c,0x45,0xcc == vsoxseg7ei16.v v24, (a0), v4, v0.t +0x27,0x5c,0x45,0xce == vsoxseg7ei16.v v24, (a0), v4 +0x27,0x6c,0x45,0xcc == vsoxseg7ei32.v v24, (a0), v4, v0.t +0x27,0x6c,0x45,0xce == vsoxseg7ei32.v v24, (a0), v4 +0x27,0x7c,0x45,0xcc == vsoxseg7ei64.v v24, (a0), v4, v0.t +0x27,0x7c,0x45,0xce == vsoxseg7ei64.v v24, (a0), v4 +0x27,0x0c,0x05,0xe0 == vsseg8e8.v v24, (a0), v0.t +0x27,0x0c,0x05,0xe2 == vsseg8e8.v v24, (a0) +0x27,0x5c,0x05,0xe0 == vsseg8e16.v v24, (a0), v0.t +0x27,0x5c,0x05,0xe2 == vsseg8e16.v v24, (a0) +0x27,0x6c,0x05,0xe0 == vsseg8e32.v v24, (a0), v0.t +0x27,0x6c,0x05,0xe2 == vsseg8e32.v v24, (a0) +0x27,0x7c,0x05,0xe0 == vsseg8e64.v v24, (a0), v0.t +0x27,0x7c,0x05,0xe2 == vsseg8e64.v v24, (a0) +0x27,0x0c,0xb5,0xe8 == vssseg8e8.v v24, (a0), a1, v0.t +0x27,0x0c,0xb5,0xea == vssseg8e8.v v24, (a0), a1 +0x27,0x5c,0xb5,0xe8 == vssseg8e16.v v24, (a0), a1, v0.t +0x27,0x5c,0xb5,0xea == vssseg8e16.v v24, (a0), a1 +0x27,0x6c,0xb5,0xe8 == vssseg8e32.v v24, (a0), a1, v0.t +0x27,0x6c,0xb5,0xea == vssseg8e32.v v24, (a0), a1 +0x27,0x7c,0xb5,0xe8 == vssseg8e64.v v24, (a0), a1, v0.t +0x27,0x7c,0xb5,0xea == vssseg8e64.v v24, (a0), a1 +0x27,0x0c,0x45,0xe4 == vsuxseg8ei8.v v24, (a0), v4, v0.t +0x27,0x0c,0x45,0xe6 == vsuxseg8ei8.v v24, (a0), v4 +0x27,0x5c,0x45,0xe4 == vsuxseg8ei16.v v24, (a0), v4, v0.t +0x27,0x5c,0x45,0xe6 == vsuxseg8ei16.v v24, (a0), v4 +0x27,0x6c,0x45,0xe4 == vsuxseg8ei32.v v24, (a0), v4, v0.t +0x27,0x6c,0x45,0xe6 == vsuxseg8ei32.v v24, (a0), v4 +0x27,0x7c,0x45,0xe4 == vsuxseg8ei64.v v24, (a0), v4, v0.t +0x27,0x7c,0x45,0xe6 == vsuxseg8ei64.v v24, (a0), v4 +0x27,0x0c,0x45,0xec == vsoxseg8ei8.v v24, (a0), v4, v0.t +0x27,0x0c,0x45,0xee == vsoxseg8ei8.v v24, (a0), v4 +0x27,0x5c,0x45,0xec == vsoxseg8ei16.v v24, (a0), v4, v0.t +0x27,0x5c,0x45,0xee == vsoxseg8ei16.v v24, (a0), v4 +0x27,0x6c,0x45,0xec == vsoxseg8ei32.v v24, (a0), v4, v0.t +0x27,0x6c,0x45,0xee == vsoxseg8ei32.v v24, (a0), v4 +0x27,0x7c,0x45,0xec == vsoxseg8ei64.v v24, (a0), v4, v0.t +0x27,0x7c,0x45,0xee == vsoxseg8ei64.v v24, (a0), v4 \ No newline at end of file diff --git a/suite/auto-sync/src/autosync/MCUpdater.py b/suite/auto-sync/src/autosync/MCUpdater.py index c4b4024ae6..0061e5354f 100755 --- a/suite/auto-sync/src/autosync/MCUpdater.py +++ b/suite/auto-sync/src/autosync/MCUpdater.py @@ -49,6 +49,10 @@ def parse_llvm_mc_line(self, line: str) -> tuple[str, str, Path]: attribute = m.group(2).strip("+") processed_attr.append(attribute) opts += ",".join(processed_attr) + + if "-riscv-no-aliases" in cmd: + opts += " riscv-no-aliases" + print("\n ----------------------------------------------- CMD became " + cmd + " ------------------------------------ \n") return cmd, opts, Path(test_file) def exec(self) -> sp.CompletedProcess: @@ -198,11 +202,18 @@ def init_tests(self, unified_test_cases: bool): asm_text = re.sub(r"\t+", " ", asm_text) asm_text = asm_text.strip() if not self.valid_byte_seq(enc_bytes): + log.warning( + f"ignoring invalid byte stream {self.mc_cmd.file} for arch {self.arch}" + ) continue if (enc_bytes + asm_text) in dups: continue + if self.arch == "RISCV" and ".insn" in asm_text: + log.warning(f"ignoring .insn directive {asm_text}, unsupported for arch {self.arch}") + continue + dups.append(enc_bytes + asm_text) if text_section in self.tests: if unified_test_cases: @@ -244,6 +255,10 @@ def valid_byte_seq(self, enc_bytes): # It always needs 4 bytes. # Otherwise it is likely a reloc or symbol test return enc_bytes.count("0x") == 4 + case "RISCV": + # RISCV can allow arbitrary lengths up to 192-bit and beyond + # but the vast majority is 16 and 32 bit, we also allow 48 and 64 for good measure + return enc_bytes.count("0x") in {2,4,6,8} case _: return True diff --git a/suite/auto-sync/src/autosync/Targets.py b/suite/auto-sync/src/autosync/Targets.py index 1065902c1c..c0bcba1a9a 100644 --- a/suite/auto-sync/src/autosync/Targets.py +++ b/suite/auto-sync/src/autosync/Targets.py @@ -14,6 +14,7 @@ "TriCore", "ARC", "Sparc", + "RISCV" ] # Names of the target architecture as they are used in code and pretty much everywhere else. @@ -29,6 +30,7 @@ "TriCore", "ARC", "Sparc", + "RISCV" ] # Maps the target full name to the name used in code (and pretty much everywhere else). @@ -45,6 +47,7 @@ "ARC": "ARC", "Sparc": "Sparc", "ARCH": "ARCH", # For testing + "RISCV":"RISCV" } # Maps the name from ARCH_LLVM_NAMING to the directory name in LLVM @@ -61,4 +64,5 @@ "ARC": "ARC", "Sparc": "Sparc", "ARCH": "ARCH", # For testing + "RISCV":"RISCV" } diff --git a/suite/auto-sync/src/autosync/cpptranslator/arch_config.json b/suite/auto-sync/src/autosync/cpptranslator/arch_config.json index 4ee00ba61a..b1eeeb030b 100644 --- a/suite/auto-sync/src/autosync/cpptranslator/arch_config.json +++ b/suite/auto-sync/src/autosync/cpptranslator/arch_config.json @@ -16,7 +16,8 @@ "MipsInstPrinter.cpp", "SystemZInstPrinter.cpp", "XtensaInstPrinter.cpp", - "SparcInstPrinter.cpp" + "SparcInstPrinter.cpp", + "RISCVInstPrinter.cpp" ] }, "InlineToStaticInline": { @@ -314,5 +315,33 @@ ], "templates_with_arg_deduction": [], "manually_edited_files": [] + }, + "RISCV": { + "files_to_translate": [ + { + "in": "{LLVM_ROOT}/llvm/lib/Target/RISCV/Disassembler/RISCVDisassembler.cpp", + "out": "RISCVDisassembler.c" + },{ + "in": "{LLVM_ROOT}/llvm/lib/Target/RISCV/MCTargetDesc/RISCVInstPrinter.cpp", + "out": "RISCVInstPrinter.c" + },{ + "in": "{LLVM_ROOT}/llvm/lib/Target/RISCV/MCTargetDesc/RISCVInstPrinter.h", + "out": "RISCVInstPrinter.h" + }, + { + "in": "{LLVM_ROOT}/llvm/lib/Target/RISCV/MCTargetDesc/RISCVBaseInfo.h", + "out": "RISCVBaseInfo.h" + }, + { + "in": "{LLVM_ROOT}/llvm/lib/Target/RISCV/MCTargetDesc/RISCVBaseInfo.cpp", + "out": "RISCVBaseInfo.c" + } + ], + "files_for_template_search": [ + "{LLVM_ROOT}/llvm/lib/Target/RISCV/Disassembler/RISCVDisassembler.cpp", + "{CPP_INC_OUT_DIR}/RISCVGenDisassemblerTables.inc" + ], + "templates_with_arg_deduction": [], + "manually_edited_files": [] } } diff --git a/suite/auto-sync/src/autosync/cpptranslator/patches/Includes.py b/suite/auto-sync/src/autosync/cpptranslator/patches/Includes.py index 16e3336dac..86877c52be 100644 --- a/suite/auto-sync/src/autosync/cpptranslator/patches/Includes.py +++ b/suite/auto-sync/src/autosync/cpptranslator/patches/Includes.py @@ -74,6 +74,8 @@ def get_patch(self, captures: [(Node, str)], src: bytes, **kwargs) -> bytes: return res + get_ARC_includes(filename) + get_general_macros() case "Sparc": return res + get_sparc_includes(filename) + get_general_macros() + case "RISCV": + return res + get_RISCV_includes(filename) + get_general_macros() case "TEST_ARCH": return res + b"test_output" case _: @@ -480,6 +482,57 @@ def get_sparc_includes(filename: str) -> bytes: log.fatal(f"No includes given for Sparc source file: {filename}") exit(1) +def get_RISCV_includes(filename: str) -> bytes: + match filename: + case "RISCVDisassembler.cpp": + return ( + b'#include "../../MCInst.h"\n' + + b'#include "../../MathExtras.h"\n' + + b'#include "../../MCInstPrinter.h"\n' + + b'#include "../../MCDisassembler.h"\n' + + b'#include "../../MCFixedLenDisassembler.h"\n' + + b'#include "../../cs_priv.h"\n' + + b'#include "../../utils.h"\n' + + b'#include "RISCVDisassemblerExtension.h"\n' + + b'#include "RISCVBaseInfo.h"\n\n' + + b"#define GET_SUBTARGETINFO_ENUM\n" + + b'#include "RISCVGenSubtargetInfo.inc"\n\n' + + b"#define GET_REGINFO_ENUM\n" + + b'#include "RISCVGenRegisterInfo.inc"\n\n' + + b"#define GET_INSTRINFO_ENUM\n" + + b"#define GET_INSTRINFO_MC_DESC\n" + + b'#include "RISCVGenInstrInfo.inc"\n\n' + ) + case "RISCVInstPrinter.cpp": + return ( + b'#include "RISCVMapping.h"\n' + + b'#include "RISCVInstPrinter.h"\n\n' + + b"#define GET_SUBTARGETINFO_ENUM\n" + + b'#include "RISCVGenSubtargetInfo.inc"\n\n' + + b"#define GET_INSTRINFO_ENUM\n" + + b'#include "RISCVGenInstrInfo.inc"\n\n' + + b"#define GET_REGINFO_ENUM\n" + + b'#include "RISCVGenRegisterInfo.inc"\n\n' + ) + case "RISCVInstPrinter.h": + return ( + b'#include "../../MCInstPrinter.h"\n' + + b'#include "../../cs_priv.h"\n' + + b'#include "../../SStream.h"\n' + + b'#include "RISCVBaseInfo.h"\n' + ) + case "RISCVBaseInfo.h": + return ( + b'#include "../../utils.h"\n' + ) + case "RISCVBaseInfo.cpp": + return ( + b'#include "RISCVBaseInfo.h"\n\n' + ) + log.fatal(f"No includes given for RISCV source file: {filename}") + exit(1) + + def get_general_macros(): return ( diff --git a/suite/auto-sync/src/autosync/inc_gen.json b/suite/auto-sync/src/autosync/inc_gen.json index dfc6e26af4..f334785163 100644 --- a/suite/auto-sync/src/autosync/inc_gen.json +++ b/suite/auto-sync/src/autosync/inc_gen.json @@ -46,7 +46,14 @@ "name": "SystemOperand", "tblgen_arg": "--gen-searchable-tables", "inc_name": "", - "only_arch": ["AArch64", "ARM", "Sparc"], + "only_arch": ["AArch64", "ARM", "Sparc", "RISCV"], + "lang": ["CCS"] + }, + { + "name": "InstCompressorUncompressor", + "tblgen_arg": "--gen-compress-inst-emitter", + "inc_name": "CompressedInstructionsInfo", + "only_arch": ["RISCV"], "lang": ["CCS"] } ] diff --git a/suite/auto-sync/src/autosync/mcupdater.json b/suite/auto-sync/src/autosync/mcupdater.json index 666dd9fcbb..198d5be606 100644 --- a/suite/auto-sync/src/autosync/mcupdater.json +++ b/suite/auto-sync/src/autosync/mcupdater.json @@ -1,7 +1,8 @@ { "use_assembly_tests": [ "Xtensa", - "Sparc" + "Sparc", + "RISCV" ], "exclude_disassembly_tests": [ "Xtensa" @@ -146,6 +147,84 @@ "sparcv9": ["CS_MODE_V9"], "sparcv9-unknown-linux": ["CS_MODE_V9"], "sparcel-linux-gnu": ["CS_MODE_LITTLE_ENDIAN"] + }, + "RISCV": { + "riscv-no-aliases": ["CS_OPT_SYNTAX_NO_ALIAS_TEXT"], + + "+experimental-zicfiss":["CS_MODE_RISCV_EXPERIMENTAL_ZICFISS"], + "experimental-zicfiss": ["CS_MODE_RISCV_EXPERIMENTAL_ZICFISS"], + + "a": ["CS_MODE_RISCV_A"], + + "c": ["CS_MODE_RISCV_C"], + "+c": ["CS_MODE_RISCV_C"], + + "f": ["CS_MODE_RISCV_F"], + "+f": ["CS_MODE_RISCV_F"], + "d": ["CS_MODE_RISCV_D"], + "+d": ["CS_MODE_RISCV_D"], + + "e": ["CS_MODE_RISCV_E"], + + "riscv32": ["CS_MODE_RISCV32"], + "riscv64": ["CS_MODE_RISCV64"], + + "v": ["CS_MODE_RISCV_V"], + "zce": ["CS_MODE_RISCV_ZCE"], + "zcmp": ["CS_MODE_RISCV_ZCMP"], + "zcmt": ["CS_MODE_RISCV_ZCMT"], + + "zdinx": ["CS_MODE_RISCV_ZDINX"], + "zfinx": ["CS_MODE_RISCV_ZFINX"], + "zhinx": ["CS_MODE_RISCV_ZFINX"], + "zhinxmin": ["CS_MODE_RISCV_ZFINX"], + + + "zba": ["CS_MODE_RISCV_ZBA"], + "+zba": ["CS_MODE_RISCV_ZBA"], + "zbb": ["CS_MODE_RISCV_ZBB"], + "+zbb": ["CS_MODE_RISCV_ZBB"], + "zbc": ["CS_MODE_RISCV_ZBC"], + "+zbc": ["CS_MODE_RISCV_ZBC"], + "zbkb": ["CS_MODE_RISCV_ZBKB"], + "+zbkb": ["CS_MODE_RISCV_ZBKB"], + "zbkc": ["CS_MODE_RISCV_ZBKC"], + "+zbkc": ["CS_MODE_RISCV_ZBKC"], + "zbkx": ["CS_MODE_RISCV_ZBKX"], + "+zbkx": ["CS_MODE_RISCV_ZBKX"], + "zbs": ["CS_MODE_RISCV_ZBS"], + "+zbs": ["CS_MODE_RISCV_ZBS"], + + "xcvalu": ["CS_MODE_RISCV_XCVALU"], + "xcvbi": ["CS_MODE_RISCV_XCVBI"], + "xcvbitmanip": ["CS_MODE_RISCV_XCVBITMANIP"], + "xcvelw": ["CS_MODE_RISCV_XCVELW"], + "xcvmac": ["CS_MODE_RISCV_XCVMAC"], + "xcvmem": ["CS_MODE_RISCV_XCVMEM"], + "xcvsimd": ["CS_MODE_RISCV_XCVSIMD"], + + "xsfvcp": ["CS_MODE_RISCV_XSFVCP"], + "xsfvfnrclipxfqf": ["CS_MODE_RISCV_XSFVFNRCLIPXFQF"], + "xsfvfwmaccqqq": ["CS_MODE_RISCV_XSFVFWMACCQQQ"], + "xsfvqmaccdod": ["CS_MODE_RISCV_XSFVQMACCDOD"], + "xsfvqmaccqoq": ["CS_MODE_RISCV_XSFVQMACCQOQ"], + "+xsfvcp": ["CS_MODE_RISCV_XSFVCP"], + "+xsfvfnrclipxfqf": ["CS_MODE_RISCV_XSFVFNRCLIPXFQF"], + "+xsfvfwmaccqqq": ["CS_MODE_RISCV_XSFVFWMACCQQQ"], + "+xsfvqmaccdod": ["CS_MODE_RISCV_XSFVQMACCDOD"], + "+xsfvqmaccqoq": ["CS_MODE_RISCV_XSFVQMACCQOQ"], + + "xtheadbs": ["CS_MODE_RISCV_XTHEADBS"], + "xtheadmemidx": ["CS_MODE_RISCV_XTHEADMEMIDX"], + "xtheadfmemidx": ["CS_MODE_RISCV_XTHEADFMEMIDX"], + "xtheadmac": ["CS_MODE_RISCV_XTHEADMAC"], + "xtheadmempair": ["CS_MODE_RISCV_XTHEADMEMPAIR"], + "xtheadba": ["CS_MODE_RISCV_XTHEADBA"], + "xtheadcmo": ["CS_MODE_RISCV_XTHEADCMO"], + "xtheadcondmov": ["CS_MODE_RISCV_XTHEADCONDMOV"], + "xtheadsync": ["CS_MODE_RISCV_XTHEADSYNC"], + "xtheadvdot": ["CS_MODE_RISCV_XTHEADVDOT"] + } } } diff --git a/suite/cstest/include/test_compare.h b/suite/cstest/include/test_compare.h index f678f5032e..f9f440605d 100644 --- a/suite/cstest/include/test_compare.h +++ b/suite/cstest/include/test_compare.h @@ -231,4 +231,15 @@ typedef int32_t tbool; } \ } +#define compare_string_from_int_ret(actual, expected, converter, ret_val) \ + if (expected) { \ + const char *actual_str = converter(actual); \ + if (!strings_match(actual_str, expected)) { \ + fprintf(stderr, \ + #actual " != " #expected ": '%s' != '%s'\n", \ + actual_str, expected); \ + return ret_val; \ + } \ + } + #endif // TEST_COMPARE_H diff --git a/suite/cstest/include/test_detail_riscv.h b/suite/cstest/include/test_detail_riscv.h index 0ba4d98e0d..45abd27a5b 100644 --- a/suite/cstest/include/test_detail_riscv.h +++ b/suite/cstest/include/test_detail_riscv.h @@ -16,6 +16,7 @@ typedef struct { uint64_t imm; char *mem_base; int64_t mem_disp; + char *csr; } TestDetailRISCVOp; static const cyaml_schema_field_t test_detail_riscv_op_mapping_schema[] = { @@ -31,7 +32,9 @@ static const cyaml_schema_field_t test_detail_riscv_op_mapping_schema[] = { CYAML_FLAG_POINTER | CYAML_FLAG_OPTIONAL, TestDetailRISCVOp, mem_base, 0, CYAML_UNLIMITED), CYAML_FIELD_INT("mem_disp", CYAML_FLAG_OPTIONAL, TestDetailRISCVOp, - mem_disp), + mem_disp), + CYAML_FIELD_STRING_PTR("csr", CYAML_FLAG_POINTER | CYAML_FLAG_OPTIONAL, + TestDetailRISCVOp, csr, 0, CYAML_UNLIMITED), CYAML_FIELD_END }; diff --git a/suite/cstest/include/test_mapping.h b/suite/cstest/include/test_mapping.h index 4fd7b0d48b..0198b3b6fe 100644 --- a/suite/cstest/include/test_mapping.h +++ b/suite/cstest/include/test_mapping.h @@ -5,6 +5,7 @@ #define TEST_MAPPING_H #include "../../../Mapping.h" +#include "capstone/riscv.h" #include /// Maps a string to an option @@ -145,9 +146,54 @@ static const cs_enum_id_map test_mode_map[] = { { .str = "CS_MODE_PWR8", .val = CS_MODE_PWR8 }, { .str = "CS_MODE_PWR9", .val = CS_MODE_PWR9 }, { .str = "CS_MODE_QPX", .val = CS_MODE_QPX }, - { .str = "CS_MODE_RISCV32", .val = CS_MODE_RISCV32 }, - { .str = "CS_MODE_RISCV64", .val = CS_MODE_RISCV64 }, - { .str = "CS_MODE_RISCVC", .val = CS_MODE_RISCVC }, + { .str = "CS_MODE_RISCV32" , .val = CS_MODE_RISCV32 }, + { .str = "CS_MODE_RISCV64" , .val = CS_MODE_RISCV64 }, + { .str = "CS_MODE_RISCVC" , .val = CS_MODE_RISCV_C }, + { .str = "CS_MODE_RISCV_A" , .val = CS_MODE_RISCV_A }, + { .str = "CS_MODE_RISCV_C" , .val = CS_MODE_RISCV_C }, + { .str = "CS_MODE_RISCV_D" , .val = CS_MODE_RISCV_FD }, + { .str = "CS_MODE_RISCV_E" , .val = CS_MODE_RISCV_E }, + { .str = "CS_MODE_RISCV_EXPERIMENTAL_ZICFISS", .val = CS_MODE_RISCV_ZICFISS}, + { .str = "CS_MODE_RISCV_F" , .val = CS_MODE_RISCV_FD }, + { .str = "CS_MODE_RISCV_V" , .val = CS_MODE_RISCV_V }, + { .str = "CS_MODE_RISCV_XCVALU", .val = CS_MODE_RISCV_COREV }, + { .str = "CS_MODE_RISCV_XCVBI", .val = CS_MODE_RISCV_COREV }, + { .str = "CS_MODE_RISCV_XCVBITMANIP", .val = CS_MODE_RISCV_COREV }, + { .str = "CS_MODE_RISCV_XCVELW", .val = CS_MODE_RISCV_COREV }, + { .str = "CS_MODE_RISCV_XCVMAC", .val = CS_MODE_RISCV_COREV }, + { .str = "CS_MODE_RISCV_XCVMEM", .val = CS_MODE_RISCV_COREV }, + { .str = "CS_MODE_RISCV_XCVSIMD", .val = CS_MODE_RISCV_COREV }, + { .str = "CS_MODE_RISCV_XSFVCP", .val = CS_MODE_RISCV_SIFIVE }, + { .str = "CS_MODE_RISCV_XSFVFNRCLIPXFQF", .val = CS_MODE_RISCV_SIFIVE }, + { .str = "CS_MODE_RISCV_XSFVFWMACCQQQ", .val = CS_MODE_RISCV_SIFIVE }, + { .str = "CS_MODE_RISCV_XSFVQMACCDOD", .val = CS_MODE_RISCV_SIFIVE }, + { .str = "CS_MODE_RISCV_XSFVQMACCQOQ", .val = CS_MODE_RISCV_SIFIVE }, + { .str = "CS_MODE_RISCV_XTHEADBA" , .val = CS_MODE_RISCV_THEAD}, + { .str = "CS_MODE_RISCV_XTHEADBS" , .val = CS_MODE_RISCV_THEAD}, + { .str = "CS_MODE_RISCV_XTHEADCMO" , .val = CS_MODE_RISCV_THEAD}, + { .str = "CS_MODE_RISCV_XTHEADCONDMOV" , .val = CS_MODE_RISCV_THEAD}, + { .str = "CS_MODE_RISCV_XTHEADFMEMIDX" , .val = CS_MODE_RISCV_THEAD}, + { .str = "CS_MODE_RISCV_XTHEADMAC" , .val = CS_MODE_RISCV_THEAD}, + { .str = "CS_MODE_RISCV_XTHEADMEMIDX" , .val = CS_MODE_RISCV_THEAD}, + { .str = "CS_MODE_RISCV_XTHEADMEMPAIR" , .val = CS_MODE_RISCV_THEAD}, + { .str = "CS_MODE_RISCV_XTHEADSYNC" , .val = CS_MODE_RISCV_THEAD}, + { .str = "CS_MODE_RISCV_XTHEADVDOT" , .val = CS_MODE_RISCV_THEAD}, + { .str = "CS_MODE_RISCV_ZBA", .val = CS_MODE_RISCV_ZBA }, + { .str = "CS_MODE_RISCV_ZBB", .val = CS_MODE_RISCV_ZBB }, + { .str = "CS_MODE_RISCV_ZBC", .val = CS_MODE_RISCV_ZBC }, + { .str = "CS_MODE_RISCV_ZBKB", .val = CS_MODE_RISCV_ZBKB }, + { .str = "CS_MODE_RISCV_ZBKC", .val = CS_MODE_RISCV_ZBKC }, + { .str = "CS_MODE_RISCV_ZBKX", .val = CS_MODE_RISCV_ZBKX }, + { .str = "CS_MODE_RISCV_ZBS", .val = CS_MODE_RISCV_ZBS }, + { .str = "CS_MODE_RISCV_ZCE" , .val = CS_MODE_RISCV_ZCMP_ZCMT_ZCE}, + { .str = "CS_MODE_RISCV_ZCMP" , .val = CS_MODE_RISCV_ZCMP_ZCMT_ZCE}, + { .str = "CS_MODE_RISCV_ZCMT" , .val = CS_MODE_RISCV_ZCMP_ZCMT_ZCE}, + { .str = "CS_MODE_RISCV_ZDINX" , .val = CS_MODE_RISCV_ZFINX}, + { .str = "CS_MODE_RISCV_ZFINX" , .val = CS_MODE_RISCV_ZFINX}, + { .str = "CS_MODE_RISCV_ZHINX" , .val = CS_MODE_RISCV_ZFINX}, + { .str = "CS_MODE_RISCV_ZHINXMIN", .val = CS_MODE_RISCV_ZFINX}, + + { .str = "CS_MODE_SH2", .val = CS_MODE_SH2 }, { .str = "CS_MODE_SH2A", .val = CS_MODE_SH2A }, { .str = "CS_MODE_SH3", .val = CS_MODE_SH3 }, @@ -217,6 +263,8 @@ static const TestOptionMapEntry test_option_map[] = { .opt = { .type = CS_OPT_SYNTAX, .val = CS_OPT_SYNTAX_PERCENT } }, { .str = "CS_OPT_SYNTAX_NO_DOLLAR", .opt = { .type = CS_OPT_SYNTAX, .val = CS_OPT_SYNTAX_NO_DOLLAR } }, + { .str = "CS_OPT_SYNTAX_NO_ALIAS_TEXT", + .opt = { .type = CS_OPT_SYNTAX, .val = CS_OPT_SYNTAX_NO_ALIAS_TEXT} } }; static const cs_enum_id_map cs_enum_map[] = { @@ -1198,21 +1246,114 @@ static const cs_enum_id_map cs_enum_map[] = { { .str = "PPC_PRED_Z_MINUS", .val = PPC_PRED_Z_MINUS }, { .str = "PPC_PRED_Z_PLUS", .val = PPC_PRED_Z_PLUS }, { .str = "PPC_PRED_Z_RESERVED", .val = PPC_PRED_Z_RESERVED }, - { .str = "RISCV_GRP_BRANCH_RELATIVE", - .val = RISCV_GRP_BRANCH_RELATIVE }, + { .str = "RISCV_FEATURE_HasHalfFPLoadStoreMove", .val = RISCV_FEATURE_HASHALFFPLOADSTOREMOVE }, + { .str = "RISCV_FEATURE_HasRVCHints", .val = RISCV_FEATURE_HASRVCHINTS }, + { .str = "RISCV_FEATURE_HasStdExtA", .val = RISCV_FEATURE_HASSTDEXTA }, + { .str = "RISCV_FEATURE_HasStdExtC", .val = RISCV_FEATURE_HASSTDEXTC }, + { .str = "RISCV_FEATURE_HasStdExtCOrZca", .val = RISCV_FEATURE_HASSTDEXTCORZCA }, + { .str = "RISCV_FEATURE_HasStdExtCOrZcd", .val = RISCV_FEATURE_HASSTDEXTCORZCD }, + { .str = "RISCV_FEATURE_HasStdExtCOrZcfOrZce", .val = RISCV_FEATURE_HASSTDEXTCORZCFORZCE }, + { .str = "RISCV_FEATURE_HasStdExtD", .val = RISCV_FEATURE_HASSTDEXTD }, + { .str = "RISCV_FEATURE_HasStdExtF", .val = RISCV_FEATURE_HASSTDEXTF }, + { .str = "RISCV_FEATURE_HasStdExtH", .val = RISCV_FEATURE_HASSTDEXTH }, + { .str = "RISCV_FEATURE_HasStdExtI", .val = RISCV_FEATURE_HASSTDEXTI }, + { .str = "RISCV_FEATURE_HasStdExtM", .val = RISCV_FEATURE_HASSTDEXTM }, + { .str = "RISCV_FEATURE_HasStdExtMOrZmmul", .val = RISCV_FEATURE_HASSTDEXTMORZMMUL }, + { .str = "RISCV_FEATURE_HasStdExtSvinval", .val = RISCV_FEATURE_HASSTDEXTSVINVAL }, + { .str = "RISCV_FEATURE_HasStdExtZacas", .val = RISCV_FEATURE_HASSTDEXTZACAS }, + { .str = "RISCV_FEATURE_HasStdExtZawrs", .val = RISCV_FEATURE_HASSTDEXTZAWRS }, + { .str = "RISCV_FEATURE_HasStdExtZba", .val = RISCV_FEATURE_HASSTDEXTZBA }, + { .str = "RISCV_FEATURE_HasStdExtZbb", .val = RISCV_FEATURE_HASSTDEXTZBB }, + { .str = "RISCV_FEATURE_HasStdExtZbbOrZbkb", .val = RISCV_FEATURE_HASSTDEXTZBBORZBKB }, + { .str = "RISCV_FEATURE_HasStdExtZbc", .val = RISCV_FEATURE_HASSTDEXTZBC }, + { .str = "RISCV_FEATURE_HasStdExtZbcOrZbkc", .val = RISCV_FEATURE_HASSTDEXTZBCORZBKC }, + { .str = "RISCV_FEATURE_HasStdExtZbkb", .val = RISCV_FEATURE_HASSTDEXTZBKB }, + { .str = "RISCV_FEATURE_HasStdExtZbkc", .val = RISCV_FEATURE_HASSTDEXTZBKC }, + { .str = "RISCV_FEATURE_HasStdExtZbkx", .val = RISCV_FEATURE_HASSTDEXTZBKX }, + { .str = "RISCV_FEATURE_HasStdExtZbs", .val = RISCV_FEATURE_HASSTDEXTZBS }, + { .str = "RISCV_FEATURE_HasStdExtZcb", .val = RISCV_FEATURE_HASSTDEXTZCB }, + { .str = "RISCV_FEATURE_HasStdExtZcmop", .val = RISCV_FEATURE_HASSTDEXTZCMOP }, + { .str = "RISCV_FEATURE_HasStdExtZcmp", .val = RISCV_FEATURE_HASSTDEXTZCMP }, + { .str = "RISCV_FEATURE_HasStdExtZcmt", .val = RISCV_FEATURE_HASSTDEXTZCMT }, + { .str = "RISCV_FEATURE_HasStdExtZdinx", .val = RISCV_FEATURE_HASSTDEXTZDINX }, + { .str = "RISCV_FEATURE_HasStdExtZfa", .val = RISCV_FEATURE_HASSTDEXTZFA }, + { .str = "RISCV_FEATURE_HasStdExtZfbfmin", .val = RISCV_FEATURE_HASSTDEXTZFBFMIN }, + { .str = "RISCV_FEATURE_HasStdExtZfh", .val = RISCV_FEATURE_HASSTDEXTZFH }, + { .str = "RISCV_FEATURE_HasStdExtZfhOrZvfh", .val = RISCV_FEATURE_HASSTDEXTZFHORZVFH }, + { .str = "RISCV_FEATURE_HasStdExtZfhmin", .val = RISCV_FEATURE_HASSTDEXTZFHMIN }, + { .str = "RISCV_FEATURE_HasStdExtZfinx", .val = RISCV_FEATURE_HASSTDEXTZFINX }, + { .str = "RISCV_FEATURE_HasStdExtZhinx", .val = RISCV_FEATURE_HASSTDEXTZHINX }, + { .str = "RISCV_FEATURE_HasStdExtZhinxmin", .val = RISCV_FEATURE_HASSTDEXTZHINXMIN }, + { .str = "RISCV_FEATURE_HasStdExtZicbom", .val = RISCV_FEATURE_HASSTDEXTZICBOM }, + { .str = "RISCV_FEATURE_HasStdExtZicbop", .val = RISCV_FEATURE_HASSTDEXTZICBOP }, + { .str = "RISCV_FEATURE_HasStdExtZicboz", .val = RISCV_FEATURE_HASSTDEXTZICBOZ }, + { .str = "RISCV_FEATURE_HasStdExtZicfilp", .val = RISCV_FEATURE_HASSTDEXTZICFILP }, + { .str = "RISCV_FEATURE_HasStdExtZicfiss", .val = RISCV_FEATURE_HASSTDEXTZICFISS }, + { .str = "RISCV_FEATURE_HasStdExtZicond", .val = RISCV_FEATURE_HASSTDEXTZICOND }, + { .str = "RISCV_FEATURE_HasStdExtZicsr", .val = RISCV_FEATURE_HASSTDEXTZICSR }, + { .str = "RISCV_FEATURE_HasStdExtZifencei", .val = RISCV_FEATURE_HASSTDEXTZIFENCEI }, + { .str = "RISCV_FEATURE_HasStdExtZihintntl", .val = RISCV_FEATURE_HASSTDEXTZIHINTNTL }, + { .str = "RISCV_FEATURE_HasStdExtZihintpause", .val = RISCV_FEATURE_HASSTDEXTZIHINTPAUSE }, + { .str = "RISCV_FEATURE_HasStdExtZimop", .val = RISCV_FEATURE_HASSTDEXTZIMOP }, + { .str = "RISCV_FEATURE_HasStdExtZknd", .val = RISCV_FEATURE_HASSTDEXTZKND }, + { .str = "RISCV_FEATURE_HasStdExtZkndOrZkne", .val = RISCV_FEATURE_HASSTDEXTZKNDORZKNE }, + { .str = "RISCV_FEATURE_HasStdExtZkne", .val = RISCV_FEATURE_HASSTDEXTZKNE }, + { .str = "RISCV_FEATURE_HasStdExtZknh", .val = RISCV_FEATURE_HASSTDEXTZKNH }, + { .str = "RISCV_FEATURE_HasStdExtZkr", .val = RISCV_FEATURE_HASSTDEXTZKR }, + { .str = "RISCV_FEATURE_HasStdExtZksed", .val = RISCV_FEATURE_HASSTDEXTZKSED }, + { .str = "RISCV_FEATURE_HasStdExtZksh", .val = RISCV_FEATURE_HASSTDEXTZKSH }, + { .str = "RISCV_FEATURE_HasStdExtZtso", .val = RISCV_FEATURE_HASSTDEXTZTSO }, + { .str = "RISCV_FEATURE_HasStdExtZvbb", .val = RISCV_FEATURE_HASSTDEXTZVBB }, + { .str = "RISCV_FEATURE_HasStdExtZvbc", .val = RISCV_FEATURE_HASSTDEXTZVBC }, + { .str = "RISCV_FEATURE_HasStdExtZvfbfmin", .val = RISCV_FEATURE_HASSTDEXTZVFBFMIN }, + { .str = "RISCV_FEATURE_HasStdExtZvfbfwma", .val = RISCV_FEATURE_HASSTDEXTZVFBFWMA }, + { .str = "RISCV_FEATURE_HasStdExtZvkb", .val = RISCV_FEATURE_HASSTDEXTZVKB }, + { .str = "RISCV_FEATURE_HasStdExtZvkg", .val = RISCV_FEATURE_HASSTDEXTZVKG }, + { .str = "RISCV_FEATURE_HasStdExtZvkned", .val = RISCV_FEATURE_HASSTDEXTZVKNED }, + { .str = "RISCV_FEATURE_HasStdExtZvknha", .val = RISCV_FEATURE_HASSTDEXTZVKNHA }, + { .str = "RISCV_FEATURE_HasStdExtZvknhaOrZvknhb", .val = RISCV_FEATURE_HASSTDEXTZVKNHAORZVKNHB }, + { .str = "RISCV_FEATURE_HasStdExtZvknhb", .val = RISCV_FEATURE_HASSTDEXTZVKNHB }, + { .str = "RISCV_FEATURE_HasStdExtZvksed", .val = RISCV_FEATURE_HASSTDEXTZVKSED }, + { .str = "RISCV_FEATURE_HasStdExtZvksh", .val = RISCV_FEATURE_HASSTDEXTZVKSH }, + { .str = "RISCV_FEATURE_HasVInstructions", .val = RISCV_FEATURE_HASVINSTRUCTIONS }, + { .str = "RISCV_FEATURE_HasVInstructionsAnyF", .val = RISCV_FEATURE_HASVINSTRUCTIONSANYF }, + { .str = "RISCV_FEATURE_HasVInstructionsF16Minimal", .val = RISCV_FEATURE_HASVINSTRUCTIONSF16MINIMAL }, + { .str = "RISCV_FEATURE_HasVInstructionsI64", .val = RISCV_FEATURE_HASVINSTRUCTIONSI64 }, + { .str = "RISCV_FEATURE_HasVendorXCValu", .val = RISCV_FEATURE_HASVENDORXCVALU }, + { .str = "RISCV_FEATURE_HasVendorXCVbi", .val = RISCV_FEATURE_HASVENDORXCVBI }, + { .str = "RISCV_FEATURE_HasVendorXCVbitmanip", .val = RISCV_FEATURE_HASVENDORXCVBITMANIP }, + { .str = "RISCV_FEATURE_HasVendorXCVelw", .val = RISCV_FEATURE_HASVENDORXCVELW }, + { .str = "RISCV_FEATURE_HasVendorXCVmac", .val = RISCV_FEATURE_HASVENDORXCVMAC }, + { .str = "RISCV_FEATURE_HasVendorXCVmem", .val = RISCV_FEATURE_HASVENDORXCVMEM }, + { .str = "RISCV_FEATURE_HasVendorXCVsimd", .val = RISCV_FEATURE_HASVENDORXCVSIMD }, + { .str = "RISCV_FEATURE_HasVendorXSfvcp", .val = RISCV_FEATURE_HASVENDORXSFVCP }, + { .str = "RISCV_FEATURE_HasVendorXSfvfnrclipxfqf", .val = RISCV_FEATURE_HASVENDORXSFVFNRCLIPXFQF }, + { .str = "RISCV_FEATURE_HasVendorXSfvfwmaccqqq", .val = RISCV_FEATURE_HASVENDORXSFVFWMACCQQQ }, + { .str = "RISCV_FEATURE_HasVendorXSfvqmaccdod", .val = RISCV_FEATURE_HASVENDORXSFVQMACCDOD }, + { .str = "RISCV_FEATURE_HasVendorXSfvqmaccqoq", .val = RISCV_FEATURE_HASVENDORXSFVQMACCQOQ }, + { .str = "RISCV_FEATURE_HasVendorXTHeadBa", .val = RISCV_FEATURE_HASVENDORXTHEADBA }, + { .str = "RISCV_FEATURE_HasVendorXTHeadBb", .val = RISCV_FEATURE_HASVENDORXTHEADBB }, + { .str = "RISCV_FEATURE_HasVendorXTHeadBs", .val = RISCV_FEATURE_HASVENDORXTHEADBS }, + { .str = "RISCV_FEATURE_HasVendorXTHeadCmo", .val = RISCV_FEATURE_HASVENDORXTHEADCMO }, + { .str = "RISCV_FEATURE_HasVendorXTHeadCondMov", .val = RISCV_FEATURE_HASVENDORXTHEADCONDMOV }, + { .str = "RISCV_FEATURE_HasVendorXTHeadFMemIdx", .val = RISCV_FEATURE_HASVENDORXTHEADFMEMIDX }, + { .str = "RISCV_FEATURE_HasVendorXTHeadMac", .val = RISCV_FEATURE_HASVENDORXTHEADMAC }, + { .str = "RISCV_FEATURE_HasVendorXTHeadMemIdx", .val = RISCV_FEATURE_HASVENDORXTHEADMEMIDX }, + { .str = "RISCV_FEATURE_HasVendorXTHeadMemPair", .val = RISCV_FEATURE_HASVENDORXTHEADMEMPAIR }, + { .str = "RISCV_FEATURE_HasVendorXTHeadSync", .val = RISCV_FEATURE_HASVENDORXTHEADSYNC }, + { .str = "RISCV_FEATURE_HasVendorXTHeadVdot", .val = RISCV_FEATURE_HASVENDORXTHEADVDOT }, + { .str = "RISCV_FEATURE_HasVendorXVentanaCondOps", .val = RISCV_FEATURE_HASVENDORXVENTANACONDOPS }, + { .str = "RISCV_FEATURE_IsRV32", .val = RISCV_FEATURE_ISRV32 }, + { .str = "RISCV_FEATURE_IsRV64", .val = RISCV_FEATURE_ISRV64 }, + { .str = "RISCV_FEATURE_IsRVE", .val = RISCV_FEATURE_ISRVE }, + { .str = "RISCV_GRP_BRANCH_RELATIVE", .val = RISCV_GRP_BRANCH_RELATIVE }, { .str = "RISCV_GRP_CALL", .val = RISCV_GRP_CALL }, - { .str = "RISCV_GRP_HASSTDEXTA", .val = RISCV_GRP_HASSTDEXTA }, - { .str = "RISCV_GRP_HASSTDEXTC", .val = RISCV_GRP_HASSTDEXTC }, - { .str = "RISCV_GRP_HASSTDEXTD", .val = RISCV_GRP_HASSTDEXTD }, - { .str = "RISCV_GRP_HASSTDEXTF", .val = RISCV_GRP_HASSTDEXTF }, - { .str = "RISCV_GRP_HASSTDEXTM", .val = RISCV_GRP_HASSTDEXTM }, { .str = "RISCV_GRP_INT", .val = RISCV_GRP_INT }, { .str = "RISCV_GRP_IRET", .val = RISCV_GRP_IRET }, - { .str = "RISCV_GRP_ISRV32", .val = RISCV_GRP_ISRV32 }, - { .str = "RISCV_GRP_ISRV64", .val = RISCV_GRP_ISRV64 }, { .str = "RISCV_GRP_JUMP", .val = RISCV_GRP_JUMP }, { .str = "RISCV_GRP_PRIVILEGE", .val = RISCV_GRP_PRIVILEGE }, { .str = "RISCV_GRP_RET", .val = RISCV_GRP_RET }, + { .str = "RISCV_OP_CSR", .val = RISCV_OP_CSR }, { .str = "RISCV_OP_IMM", .val = RISCV_OP_IMM }, { .str = "RISCV_OP_MEM", .val = RISCV_OP_MEM }, { .str = "RISCV_OP_REG", .val = RISCV_OP_REG }, diff --git a/suite/cstest/src/test_detail_riscv.c b/suite/cstest/src/test_detail_riscv.c index ef3a59e69e..ec7162f74b 100644 --- a/suite/cstest/src/test_detail_riscv.c +++ b/suite/cstest/src/test_detail_riscv.c @@ -1,12 +1,15 @@ // Copyright © 2024 Rot127 // SPDX-License-Identifier: BSD-3 +#include "capstone/riscv.h" #include "test_compare.h" #include "test_detail_riscv.h" #include #include #include +#include "../arch/RISCV/RISCVInstPrinter.h" + TestDetailRISCV *test_detail_riscv_new() { return cs_mem_calloc(sizeof(TestDetailRISCV), 1); @@ -99,6 +102,9 @@ bool test_expected_riscv(csh *handle, const cs_riscv *actual, false); compare_int64_ret(op->mem.disp, eop->mem_disp, false); break; + case RISCV_OP_CSR: + compare_string_from_int_ret(op->csr, eop->csr, getSysRegName, false); + break; } } diff --git a/tests/MC/RISCV/XCValu_valid_riscv32_riscv_xcvalu_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/XCValu_valid_riscv32_riscv_xcvalu_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..42e41a0677 --- /dev/null +++ b/tests/MC/RISCV/XCValu_valid_riscv32_riscv_xcvalu_syntax_no_alias_text.txt.yaml @@ -0,0 +1,720 @@ +test_cases: + - + input: + bytes: [ 0xab, 0x32, 0x73, 0x86 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.addurnr t0, t1, t2" + + - + input: + bytes: [ 0x2b, 0xb5, 0xc5, 0x86 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.addurnr a0, a1, a2" + + - + input: + bytes: [ 0xab, 0x32, 0x73, 0x5c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.maxu t0, t1, t2" + + - + input: + bytes: [ 0x2b, 0xb5, 0xc5, 0x5c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.maxu a0, a1, a2" + + - + input: + bytes: [ 0xab, 0x32, 0x73, 0x8c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.subrnr t0, t1, t2" + + - + input: + bytes: [ 0x2b, 0xb5, 0xc5, 0x8c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.subrnr a0, a1, a2" + + - + input: + bytes: [ 0xab, 0x32, 0x73, 0x52 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.slet t0, t1, t2" + + - + input: + bytes: [ 0x2b, 0xb5, 0xc5, 0x52 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.slet a0, a1, a2" + + - + input: + bytes: [ 0xdb, 0x32, 0x73, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.subrn t0, t1, t2, 0" + + - + input: + bytes: [ 0xdb, 0x32, 0x73, 0xa0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.subrn t0, t1, t2, 16" + + - + input: + bytes: [ 0x5b, 0xb5, 0x05, 0xbe ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.subrn a0, a1, zero, 31" + + - + input: + bytes: [ 0xab, 0x32, 0x73, 0x88 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.subnr t0, t1, t2" + + - + input: + bytes: [ 0x2b, 0xb5, 0xc5, 0x88 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.subnr a0, a1, a2" + + - + input: + bytes: [ 0xab, 0x32, 0x73, 0x82 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.addunr t0, t1, t2" + + - + input: + bytes: [ 0x2b, 0xb5, 0xc5, 0x82 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.addunr a0, a1, a2" + + - + input: + bytes: [ 0xdb, 0x22, 0x73, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.addurn t0, t1, t2, 0" + + - + input: + bytes: [ 0xdb, 0x22, 0x73, 0xe0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.addurn t0, t1, t2, 16" + + - + input: + bytes: [ 0x5b, 0xa5, 0x05, 0xfe ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.addurn a0, a1, zero, 31" + + - + input: + bytes: [ 0xdb, 0x22, 0x73, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.addun t0, t1, t2, 0" + + - + input: + bytes: [ 0xdb, 0x22, 0x73, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.addun t0, t1, t2, 16" + + - + input: + bytes: [ 0x5b, 0xa5, 0x05, 0x7e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.addun a0, a1, zero, 31" + + - + input: + bytes: [ 0xab, 0x32, 0x03, 0x72 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.clipu t0, t1, 0" + + - + input: + bytes: [ 0xab, 0x32, 0x03, 0x73 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.clipu t0, t1, 16" + + - + input: + bytes: [ 0x2b, 0x35, 0xf0, 0x73 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.clipu a0, zero, 31" + + - + input: + bytes: [ 0xab, 0x32, 0x03, 0x70 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.clip t0, t1, 0" + + - + input: + bytes: [ 0xab, 0x32, 0x03, 0x71 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.clip t0, t1, 16" + + - + input: + bytes: [ 0x2b, 0x35, 0xf0, 0x71 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.clip a0, zero, 31" + + - + input: + bytes: [ 0xab, 0x32, 0x03, 0x62 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.exthz t0, t1" + + - + input: + bytes: [ 0x2b, 0xb5, 0x05, 0x62 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.exthz a0, a1" + + - + input: + bytes: [ 0xab, 0x32, 0x73, 0x5a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.max t0, t1, t2" + + - + input: + bytes: [ 0x2b, 0xb5, 0xc5, 0x5a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.max a0, a1, a2" + + - + input: + bytes: [ 0xab, 0x32, 0x73, 0x74 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.clipr t0, t1, t2" + + - + input: + bytes: [ 0x2b, 0xb5, 0xc5, 0x74 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.clipr a0, a1, a2" + + - + input: + bytes: [ 0xdb, 0x32, 0x73, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.subn t0, t1, t2, 0" + + - + input: + bytes: [ 0xdb, 0x32, 0x73, 0x20 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.subn t0, t1, t2, 16" + + - + input: + bytes: [ 0x5b, 0xb5, 0x05, 0x3e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.subn a0, a1, zero, 31" + + - + input: + bytes: [ 0xab, 0x32, 0x03, 0x66 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.extbz t0, t1" + + - + input: + bytes: [ 0x2b, 0xb5, 0x05, 0x66 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.extbz a0, a1" + + - + input: + bytes: [ 0xab, 0x32, 0x03, 0x50 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.abs t0, t1" + + - + input: + bytes: [ 0x2b, 0xb5, 0x05, 0x50 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.abs a0, a1" + + - + input: + bytes: [ 0xab, 0x32, 0x73, 0x76 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.clipur t0, t1, t2" + + - + input: + bytes: [ 0x2b, 0xb5, 0xc5, 0x76 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.clipur a0, a1, a2" + + - + input: + bytes: [ 0xab, 0x32, 0x73, 0x58 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.minu t0, t1, t2" + + - + input: + bytes: [ 0x2b, 0xb5, 0xc5, 0x58 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.minu a0, a1, a2" + + - + input: + bytes: [ 0xdb, 0x22, 0x73, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.addn t0, t1, t2, 0" + + - + input: + bytes: [ 0xdb, 0x22, 0x73, 0x20 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.addn t0, t1, t2, 16" + + - + input: + bytes: [ 0x5b, 0xa5, 0x05, 0x3e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.addn a0, a1, zero, 31" + + - + input: + bytes: [ 0xab, 0x32, 0x73, 0x8a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.subunr t0, t1, t2" + + - + input: + bytes: [ 0x2b, 0xb5, 0xc5, 0x8a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.subunr a0, a1, a2" + + - + input: + bytes: [ 0xab, 0x32, 0x03, 0x64 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.extbs t0, t1" + + - + input: + bytes: [ 0x2b, 0xb5, 0x05, 0x64 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.extbs a0, a1" + + - + input: + bytes: [ 0xab, 0x32, 0x73, 0x54 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.sletu t0, t1, t2" + + - + input: + bytes: [ 0x2b, 0xb5, 0xc5, 0x54 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.sletu a0, a1, a2" + + - + input: + bytes: [ 0xab, 0x32, 0x73, 0x56 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.min t0, t1, t2" + + - + input: + bytes: [ 0x2b, 0xb5, 0xc5, 0x56 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.min a0, a1, a2" + + - + input: + bytes: [ 0xab, 0x32, 0x73, 0x8e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.suburnr t0, t1, t2" + + - + input: + bytes: [ 0x2b, 0xb5, 0xc5, 0x8e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.suburnr a0, a1, a2" + + - + input: + bytes: [ 0xab, 0x32, 0x73, 0x84 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.addrnr t0, t1, t2" + + - + input: + bytes: [ 0x2b, 0xb5, 0xc5, 0x84 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.addrnr a0, a1, a2" + + - + input: + bytes: [ 0xab, 0x32, 0x03, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.exths t0, t1" + + - + input: + bytes: [ 0x2b, 0xb5, 0x05, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.exths a0, a1" + + - + input: + bytes: [ 0xdb, 0x22, 0x73, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.addrn t0, t1, t2, 0" + + - + input: + bytes: [ 0xdb, 0x22, 0x73, 0xa0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.addrn t0, t1, t2, 16" + + - + input: + bytes: [ 0x5b, 0xa5, 0x05, 0xbe ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.addrn a0, a1, zero, 31" + + - + input: + bytes: [ 0xdb, 0x32, 0x73, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.suburn t0, t1, t2, 0" + + - + input: + bytes: [ 0xdb, 0x32, 0x73, 0xe0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.suburn t0, t1, t2, 16" + + - + input: + bytes: [ 0x5b, 0xb5, 0x05, 0xfe ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.suburn a0, a1, zero, 31" + + - + input: + bytes: [ 0xab, 0x32, 0x73, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.addnr t0, t1, t2" + + - + input: + bytes: [ 0x2b, 0xb5, 0xc5, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.addnr a0, a1, a2" + + - + input: + bytes: [ 0xdb, 0x32, 0x73, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.subun t0, t1, t2, 0" + + - + input: + bytes: [ 0xdb, 0x32, 0x73, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.subun t0, t1, t2, 16" + + - + input: + bytes: [ 0x5b, 0xb5, 0x05, 0x7e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVALU", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.subun a0, a1, zero, 31" diff --git a/tests/MC/RISCV/XCVbi_riscv32_riscv_xcvbi.txt.yaml b/tests/MC/RISCV/XCVbi_riscv32_riscv_xcvbi.txt.yaml new file mode 100644 index 0000000000..1778d0bc7b --- /dev/null +++ b/tests/MC/RISCV/XCVbi_riscv32_riscv_xcvbi.txt.yaml @@ -0,0 +1,40 @@ +test_cases: + - + input: + bytes: [ 0x0b, 0xe0, 0x02, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVBI" ] + expected: + insns: + - + asm_text: "cv.beqimm t0, 0, 0" + + - + input: + bytes: [ 0x0b, 0x65, 0x55, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVBI" ] + expected: + insns: + - + asm_text: "cv.beqimm a0, 5, 42" + + - + input: + bytes: [ 0x0b, 0xf0, 0x02, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVBI" ] + expected: + insns: + - + asm_text: "cv.bneimm t0, 0, 0" + + - + input: + bytes: [ 0x0b, 0x75, 0x55, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVBI" ] + expected: + insns: + - + asm_text: "cv.bneimm a0, 5, 42" diff --git a/tests/MC/RISCV/XCVbitmanip_riscv32_riscv_xcvbitmanip.txt.yaml b/tests/MC/RISCV/XCVbitmanip_riscv32_riscv_xcvbitmanip.txt.yaml new file mode 100644 index 0000000000..53091f1dbe --- /dev/null +++ b/tests/MC/RISCV/XCVbitmanip_riscv32_riscv_xcvbitmanip.txt.yaml @@ -0,0 +1,480 @@ +test_cases: + - + input: + bytes: [ 0xdb, 0x02, 0x13, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVBITMANIP" ] + expected: + insns: + - + asm_text: "cv.extract t0, t1, 0, 1" + + - + input: + bytes: [ 0x5b, 0x85, 0x25, 0x23 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVBITMANIP" ] + expected: + insns: + - + asm_text: "cv.extract a0, a1, 17, 18" + + - + input: + bytes: [ 0x5b, 0x84, 0xf4, 0x3d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVBITMANIP" ] + expected: + insns: + - + asm_text: "cv.extract s0, s1, 30, 31" + + - + input: + bytes: [ 0xdb, 0x02, 0x13, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVBITMANIP" ] + expected: + insns: + - + asm_text: "cv.extractu t0, t1, 0, 1" + + - + input: + bytes: [ 0x5b, 0x85, 0x25, 0x63 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVBITMANIP" ] + expected: + insns: + - + asm_text: "cv.extractu a0, a1, 17, 18" + + - + input: + bytes: [ 0x5b, 0x84, 0xf4, 0x7d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVBITMANIP" ] + expected: + insns: + - + asm_text: "cv.extractu s0, s1, 30, 31" + + - + input: + bytes: [ 0xdb, 0x02, 0x13, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVBITMANIP" ] + expected: + insns: + - + asm_text: "cv.insert t0, t1, 0, 1" + + - + input: + bytes: [ 0x5b, 0x85, 0x25, 0xa3 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVBITMANIP" ] + expected: + insns: + - + asm_text: "cv.insert a0, a1, 17, 18" + + - + input: + bytes: [ 0x5b, 0x84, 0xf4, 0xbd ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVBITMANIP" ] + expected: + insns: + - + asm_text: "cv.insert s0, s1, 30, 31" + + - + input: + bytes: [ 0xdb, 0x12, 0x13, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVBITMANIP" ] + expected: + insns: + - + asm_text: "cv.bclr t0, t1, 0, 1" + + - + input: + bytes: [ 0x5b, 0x95, 0x25, 0x23 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVBITMANIP" ] + expected: + insns: + - + asm_text: "cv.bclr a0, a1, 17, 18" + + - + input: + bytes: [ 0x5b, 0x94, 0xf4, 0x3d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVBITMANIP" ] + expected: + insns: + - + asm_text: "cv.bclr s0, s1, 30, 31" + + - + input: + bytes: [ 0xdb, 0x12, 0x13, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVBITMANIP" ] + expected: + insns: + - + asm_text: "cv.bset t0, t1, 0, 1" + + - + input: + bytes: [ 0x5b, 0x95, 0x25, 0x63 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVBITMANIP" ] + expected: + insns: + - + asm_text: "cv.bset a0, a1, 17, 18" + + - + input: + bytes: [ 0x5b, 0x94, 0xf4, 0x7d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVBITMANIP" ] + expected: + insns: + - + asm_text: "cv.bset s0, s1, 30, 31" + + - + input: + bytes: [ 0xdb, 0x12, 0x13, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVBITMANIP" ] + expected: + insns: + - + asm_text: "cv.bitrev t0, t1, 0, 1" + + - + input: + bytes: [ 0x5b, 0x95, 0x25, 0xc3 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVBITMANIP" ] + expected: + insns: + - + asm_text: "cv.bitrev a0, a1, 1, 18" + + - + input: + bytes: [ 0x5b, 0x94, 0xf4, 0xc5 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVBITMANIP" ] + expected: + insns: + - + asm_text: "cv.bitrev s0, s1, 2, 31" + + - + input: + bytes: [ 0xab, 0x32, 0x73, 0x30 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVBITMANIP" ] + expected: + insns: + - + asm_text: "cv.extractr t0, t1, t2" + + - + input: + bytes: [ 0x2b, 0xb5, 0xc5, 0x30 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVBITMANIP" ] + expected: + insns: + - + asm_text: "cv.extractr a0, a1, a2" + + - + input: + bytes: [ 0x2b, 0xb4, 0x24, 0x31 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVBITMANIP" ] + expected: + insns: + - + asm_text: "cv.extractr s0, s1, s2" + + - + input: + bytes: [ 0xab, 0x32, 0x73, 0x32 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVBITMANIP" ] + expected: + insns: + - + asm_text: "cv.extractur t0, t1, t2" + + - + input: + bytes: [ 0x2b, 0xb5, 0xc5, 0x32 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVBITMANIP" ] + expected: + insns: + - + asm_text: "cv.extractur a0, a1, a2" + + - + input: + bytes: [ 0x2b, 0xb4, 0x24, 0x33 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVBITMANIP" ] + expected: + insns: + - + asm_text: "cv.extractur s0, s1, s2" + + - + input: + bytes: [ 0xab, 0x32, 0x73, 0x34 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVBITMANIP" ] + expected: + insns: + - + asm_text: "cv.insertr t0, t1, t2" + + - + input: + bytes: [ 0x2b, 0xb5, 0xc5, 0x34 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVBITMANIP" ] + expected: + insns: + - + asm_text: "cv.insertr a0, a1, a2" + + - + input: + bytes: [ 0x2b, 0xb4, 0x24, 0x35 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVBITMANIP" ] + expected: + insns: + - + asm_text: "cv.insertr s0, s1, s2" + + - + input: + bytes: [ 0xab, 0x32, 0x73, 0x38 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVBITMANIP" ] + expected: + insns: + - + asm_text: "cv.bclrr t0, t1, t2" + + - + input: + bytes: [ 0x2b, 0xb5, 0xc5, 0x38 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVBITMANIP" ] + expected: + insns: + - + asm_text: "cv.bclrr a0, a1, a2" + + - + input: + bytes: [ 0x2b, 0xb4, 0x24, 0x39 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVBITMANIP" ] + expected: + insns: + - + asm_text: "cv.bclrr s0, s1, s2" + + - + input: + bytes: [ 0xab, 0x32, 0x73, 0x3a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVBITMANIP" ] + expected: + insns: + - + asm_text: "cv.bsetr t0, t1, t2" + + - + input: + bytes: [ 0x2b, 0xb5, 0xc5, 0x3a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVBITMANIP" ] + expected: + insns: + - + asm_text: "cv.bsetr a0, a1, a2" + + - + input: + bytes: [ 0x2b, 0xb4, 0x24, 0x3b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVBITMANIP" ] + expected: + insns: + - + asm_text: "cv.bsetr s0, s1, s2" + + - + input: + bytes: [ 0xab, 0x32, 0x73, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVBITMANIP" ] + expected: + insns: + - + asm_text: "cv.ror t0, t1, t2" + + - + input: + bytes: [ 0x2b, 0xb5, 0xc5, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVBITMANIP" ] + expected: + insns: + - + asm_text: "cv.ror a0, a1, a2" + + - + input: + bytes: [ 0x2b, 0xb4, 0x24, 0x41 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVBITMANIP" ] + expected: + insns: + - + asm_text: "cv.ror s0, s1, s2" + + - + input: + bytes: [ 0xab, 0x32, 0x03, 0x42 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVBITMANIP" ] + expected: + insns: + - + asm_text: "cv.ff1 t0, t1" + + - + input: + bytes: [ 0x2b, 0xb5, 0x05, 0x42 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVBITMANIP" ] + expected: + insns: + - + asm_text: "cv.ff1 a0, a1" + + - + input: + bytes: [ 0x2b, 0xb4, 0x04, 0x42 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVBITMANIP" ] + expected: + insns: + - + asm_text: "cv.ff1 s0, s1" + + - + input: + bytes: [ 0xab, 0x32, 0x03, 0x44 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVBITMANIP" ] + expected: + insns: + - + asm_text: "cv.fl1 t0, t1" + + - + input: + bytes: [ 0x2b, 0xb5, 0x05, 0x44 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVBITMANIP" ] + expected: + insns: + - + asm_text: "cv.fl1 a0, a1" + + - + input: + bytes: [ 0x2b, 0xb4, 0x04, 0x44 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVBITMANIP" ] + expected: + insns: + - + asm_text: "cv.fl1 s0, s1" + + - + input: + bytes: [ 0xab, 0x32, 0x03, 0x46 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVBITMANIP" ] + expected: + insns: + - + asm_text: "cv.clb t0, t1" + + - + input: + bytes: [ 0x2b, 0xb5, 0x05, 0x46 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVBITMANIP" ] + expected: + insns: + - + asm_text: "cv.clb a0, a1" + + - + input: + bytes: [ 0x2b, 0xb4, 0x04, 0x46 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVBITMANIP" ] + expected: + insns: + - + asm_text: "cv.clb s0, s1" + + - + input: + bytes: [ 0xab, 0x32, 0x03, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVBITMANIP" ] + expected: + insns: + - + asm_text: "cv.cnt t0, t1" + + - + input: + bytes: [ 0x2b, 0xb5, 0x05, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVBITMANIP" ] + expected: + insns: + - + asm_text: "cv.cnt a0, a1" + + - + input: + bytes: [ 0x2b, 0xb4, 0x04, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVBITMANIP" ] + expected: + insns: + - + asm_text: "cv.cnt s0, s1" diff --git a/tests/MC/RISCV/XCVelw_valid_riscv32_riscv_xcvelw.txt.yaml b/tests/MC/RISCV/XCVelw_valid_riscv32_riscv_xcvelw.txt.yaml new file mode 100644 index 0000000000..8571201380 --- /dev/null +++ b/tests/MC/RISCV/XCVelw_valid_riscv32_riscv_xcvelw.txt.yaml @@ -0,0 +1,30 @@ +test_cases: + - + input: + bytes: [ 0x0b, 0x35, 0x05, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVELW" ] + expected: + insns: + - + asm_text: "cv.elw a0, 1024(a0)" + + - + input: + bytes: [ 0x8b, 0xb5, 0x15, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVELW" ] + expected: + insns: + - + asm_text: "cv.elw a1, 1(a1)" + + - + input: + bytes: [ 0x0b, 0xb6, 0x06, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVELW" ] + expected: + insns: + - + asm_text: "cv.elw a2, -1024(a3)" diff --git a/tests/MC/RISCV/XCVmac_valid_riscv32_riscv_xcvmac_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/XCVmac_valid_riscv32_riscv_xcvmac_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..79e9878d8a --- /dev/null +++ b/tests/MC/RISCV/XCVmac_valid_riscv32_riscv_xcvmac_syntax_no_alias_text.txt.yaml @@ -0,0 +1,560 @@ +test_cases: + - + input: + bytes: [ 0xab, 0x32, 0x73, 0x90 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMAC", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.mac t0, t1, t2" + + - + input: + bytes: [ 0xab, 0x32, 0x03, 0x90 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMAC", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.mac t0, t1, zero" + + - + input: + bytes: [ 0xdb, 0x62, 0x73, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMAC", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.machhsn t0, t1, t2, 0" + + - + input: + bytes: [ 0xdb, 0x62, 0x03, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMAC", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.machhsn t0, t1, zero, 16" + + - + input: + bytes: [ 0xdb, 0x62, 0x03, 0x7e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMAC", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.machhsn t0, t1, zero, 31" + + - + input: + bytes: [ 0xdb, 0x62, 0x73, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMAC", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.machhsrn t0, t1, t2, 0" + + - + input: + bytes: [ 0xdb, 0x62, 0x03, 0xe0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMAC", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.machhsrn t0, t1, zero, 16" + + - + input: + bytes: [ 0xdb, 0x62, 0x03, 0xfe ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMAC", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.machhsrn t0, t1, zero, 31" + + - + input: + bytes: [ 0xdb, 0x72, 0x73, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMAC", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.machhun t0, t1, t2, 0" + + - + input: + bytes: [ 0xdb, 0x72, 0x03, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMAC", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.machhun t0, t1, zero, 16" + + - + input: + bytes: [ 0xdb, 0x72, 0x03, 0x7e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMAC", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.machhun t0, t1, zero, 31" + + - + input: + bytes: [ 0xdb, 0x72, 0x73, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMAC", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.machhurn t0, t1, t2, 0" + + - + input: + bytes: [ 0xdb, 0x72, 0x03, 0xe0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMAC", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.machhurn t0, t1, zero, 16" + + - + input: + bytes: [ 0xdb, 0x72, 0x03, 0xfe ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMAC", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.machhurn t0, t1, zero, 31" + + - + input: + bytes: [ 0xdb, 0x62, 0x73, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMAC", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.macsn t0, t1, t2, 0" + + - + input: + bytes: [ 0xdb, 0x62, 0x03, 0x20 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMAC", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.macsn t0, t1, zero, 16" + + - + input: + bytes: [ 0xdb, 0x62, 0x03, 0x3e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMAC", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.macsn t0, t1, zero, 31" + + - + input: + bytes: [ 0xdb, 0x62, 0x73, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMAC", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.macsrn t0, t1, t2, 0" + + - + input: + bytes: [ 0xdb, 0x62, 0x03, 0xa0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMAC", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.macsrn t0, t1, zero, 16" + + - + input: + bytes: [ 0xdb, 0x62, 0x03, 0xbe ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMAC", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.macsrn t0, t1, zero, 31" + + - + input: + bytes: [ 0xdb, 0x72, 0x73, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMAC", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.macun t0, t1, t2, 0" + + - + input: + bytes: [ 0xdb, 0x72, 0x03, 0x20 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMAC", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.macun t0, t1, zero, 16" + + - + input: + bytes: [ 0xdb, 0x72, 0x03, 0x3e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMAC", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.macun t0, t1, zero, 31" + + - + input: + bytes: [ 0xdb, 0x72, 0x73, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMAC", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.macurn t0, t1, t2, 0" + + - + input: + bytes: [ 0xdb, 0x72, 0x03, 0xa0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMAC", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.macurn t0, t1, zero, 16" + + - + input: + bytes: [ 0xdb, 0x72, 0x03, 0xbe ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMAC", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.macurn t0, t1, zero, 31" + + - + input: + bytes: [ 0xab, 0x32, 0x73, 0x92 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMAC", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.msu t0, t1, t2" + + - + input: + bytes: [ 0xab, 0x32, 0x03, 0x92 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMAC", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.msu t0, t1, zero" + + - + input: + bytes: [ 0xdb, 0x42, 0x73, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMAC", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.mulhhsn t0, t1, t2, 0" + + - + input: + bytes: [ 0xdb, 0x42, 0x03, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMAC", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.mulhhsn t0, t1, zero, 0" + + - + input: + bytes: [ 0xdb, 0x42, 0x03, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMAC", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.mulhhsn t0, t1, zero, 16" + + - + input: + bytes: [ 0xdb, 0x42, 0x03, 0x7e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMAC", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.mulhhsn t0, t1, zero, 31" + + - + input: + bytes: [ 0xdb, 0x42, 0x73, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMAC", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.mulhhsrn t0, t1, t2, 0" + + - + input: + bytes: [ 0xdb, 0x42, 0x03, 0xe0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMAC", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.mulhhsrn t0, t1, zero, 16" + + - + input: + bytes: [ 0xdb, 0x42, 0x03, 0xfe ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMAC", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.mulhhsrn t0, t1, zero, 31" + + - + input: + bytes: [ 0xdb, 0x52, 0x73, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMAC", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.mulhhun t0, t1, t2, 0" + + - + input: + bytes: [ 0xdb, 0x52, 0x03, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMAC", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.mulhhun t0, t1, zero, 0" + + - + input: + bytes: [ 0xdb, 0x52, 0x03, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMAC", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.mulhhun t0, t1, zero, 16" + + - + input: + bytes: [ 0xdb, 0x52, 0x03, 0x7e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMAC", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.mulhhun t0, t1, zero, 31" + + - + input: + bytes: [ 0xdb, 0x52, 0x73, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMAC", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.mulhhurn t0, t1, t2, 0" + + - + input: + bytes: [ 0xdb, 0x52, 0x03, 0xe0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMAC", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.mulhhurn t0, t1, zero, 16" + + - + input: + bytes: [ 0xdb, 0x52, 0x03, 0xfe ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMAC", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.mulhhurn t0, t1, zero, 31" + + - + input: + bytes: [ 0xdb, 0x42, 0x73, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMAC", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.mulsn t0, t1, t2, 0" + + - + input: + bytes: [ 0xdb, 0x42, 0x03, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMAC", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.mulsn t0, t1, zero, 0" + + - + input: + bytes: [ 0xdb, 0x42, 0x03, 0x20 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMAC", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.mulsn t0, t1, zero, 16" + + - + input: + bytes: [ 0xdb, 0x42, 0x03, 0x3e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMAC", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.mulsn t0, t1, zero, 31" + + - + input: + bytes: [ 0xdb, 0x42, 0x73, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMAC", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.mulsrn t0, t1, t2, 0" + + - + input: + bytes: [ 0xdb, 0x42, 0x03, 0xa0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMAC", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.mulsrn t0, t1, zero, 16" + + - + input: + bytes: [ 0xdb, 0x42, 0x03, 0xbe ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMAC", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.mulsrn t0, t1, zero, 31" + + - + input: + bytes: [ 0xdb, 0x52, 0x73, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMAC", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.mulun t0, t1, t2, 0" + + - + input: + bytes: [ 0xdb, 0x52, 0x03, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMAC", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.mulun t0, t1, zero, 0" + + - + input: + bytes: [ 0xdb, 0x52, 0x03, 0x20 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMAC", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.mulun t0, t1, zero, 16" + + - + input: + bytes: [ 0xdb, 0x52, 0x03, 0x3e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMAC", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.mulun t0, t1, zero, 31" + + - + input: + bytes: [ 0xdb, 0x52, 0x73, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMAC", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.mulurn t0, t1, t2, 0" + + - + input: + bytes: [ 0xdb, 0x52, 0x03, 0xa0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMAC", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.mulurn t0, t1, zero, 16" + + - + input: + bytes: [ 0xdb, 0x52, 0x03, 0xbe ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMAC", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cv.mulurn t0, t1, zero, 31" diff --git a/tests/MC/RISCV/XCVmem_valid_riscv32_riscv_xcvmem.txt.yaml b/tests/MC/RISCV/XCVmem_valid_riscv32_riscv_xcvmem.txt.yaml new file mode 100644 index 0000000000..65d1b6834b --- /dev/null +++ b/tests/MC/RISCV/XCVmem_valid_riscv32_riscv_xcvmem.txt.yaml @@ -0,0 +1,480 @@ +test_cases: + - + input: + bytes: [ 0x8b, 0x02, 0x03, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMEM" ] + expected: + insns: + - + asm_text: "cv.lb t0, (t1), 0" + + - + input: + bytes: [ 0x0b, 0x85, 0xf5, 0x7f ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMEM" ] + expected: + insns: + - + asm_text: "cv.lb a0, (a1), 2047" + + - + input: + bytes: [ 0xab, 0x32, 0x73, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMEM" ] + expected: + insns: + - + asm_text: "cv.lb t0, (t1), t2" + + - + input: + bytes: [ 0x2b, 0xb5, 0xc5, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMEM" ] + expected: + insns: + - + asm_text: "cv.lb a0, (a1), a2" + + - + input: + bytes: [ 0xab, 0x32, 0x73, 0x08 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMEM" ] + expected: + insns: + - + asm_text: "cv.lb t0, t2(t1)" + + - + input: + bytes: [ 0x2b, 0xb5, 0xc5, 0x08 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMEM" ] + expected: + insns: + - + asm_text: "cv.lb a0, a2(a1)" + + - + input: + bytes: [ 0x8b, 0x42, 0x03, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMEM" ] + expected: + insns: + - + asm_text: "cv.lbu t0, (t1), 0" + + - + input: + bytes: [ 0x0b, 0xc5, 0xf5, 0x7f ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMEM" ] + expected: + insns: + - + asm_text: "cv.lbu a0, (a1), 2047" + + - + input: + bytes: [ 0xab, 0x32, 0x73, 0x10 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMEM" ] + expected: + insns: + - + asm_text: "cv.lbu t0, (t1), t2" + + - + input: + bytes: [ 0x2b, 0xb5, 0xc5, 0x10 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMEM" ] + expected: + insns: + - + asm_text: "cv.lbu a0, (a1), a2" + + - + input: + bytes: [ 0xab, 0x32, 0x73, 0x18 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMEM" ] + expected: + insns: + - + asm_text: "cv.lbu t0, t2(t1)" + + - + input: + bytes: [ 0x2b, 0xb5, 0xc5, 0x18 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMEM" ] + expected: + insns: + - + asm_text: "cv.lbu a0, a2(a1)" + + - + input: + bytes: [ 0x8b, 0x12, 0x03, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMEM" ] + expected: + insns: + - + asm_text: "cv.lh t0, (t1), 0" + + - + input: + bytes: [ 0x0b, 0x95, 0xf5, 0x7f ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMEM" ] + expected: + insns: + - + asm_text: "cv.lh a0, (a1), 2047" + + - + input: + bytes: [ 0xab, 0x32, 0x73, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMEM" ] + expected: + insns: + - + asm_text: "cv.lh t0, (t1), t2" + + - + input: + bytes: [ 0x2b, 0xb5, 0xc5, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMEM" ] + expected: + insns: + - + asm_text: "cv.lh a0, (a1), a2" + + - + input: + bytes: [ 0xab, 0x32, 0x73, 0x0a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMEM" ] + expected: + insns: + - + asm_text: "cv.lh t0, t2(t1)" + + - + input: + bytes: [ 0x2b, 0xb5, 0xc5, 0x0a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMEM" ] + expected: + insns: + - + asm_text: "cv.lh a0, a2(a1)" + + - + input: + bytes: [ 0x8b, 0x52, 0x03, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMEM" ] + expected: + insns: + - + asm_text: "cv.lhu t0, (t1), 0" + + - + input: + bytes: [ 0x0b, 0xd5, 0xf5, 0x7f ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMEM" ] + expected: + insns: + - + asm_text: "cv.lhu a0, (a1), 2047" + + - + input: + bytes: [ 0xab, 0x32, 0x73, 0x12 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMEM" ] + expected: + insns: + - + asm_text: "cv.lhu t0, (t1), t2" + + - + input: + bytes: [ 0x2b, 0xb5, 0xc5, 0x12 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMEM" ] + expected: + insns: + - + asm_text: "cv.lhu a0, (a1), a2" + + - + input: + bytes: [ 0xab, 0x32, 0x73, 0x1a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMEM" ] + expected: + insns: + - + asm_text: "cv.lhu t0, t2(t1)" + + - + input: + bytes: [ 0x2b, 0xb5, 0xc5, 0x1a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMEM" ] + expected: + insns: + - + asm_text: "cv.lhu a0, a2(a1)" + + - + input: + bytes: [ 0x8b, 0x22, 0x03, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMEM" ] + expected: + insns: + - + asm_text: "cv.lw t0, (t1), 0" + + - + input: + bytes: [ 0x0b, 0xa5, 0xf5, 0x7f ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMEM" ] + expected: + insns: + - + asm_text: "cv.lw a0, (a1), 2047" + + - + input: + bytes: [ 0xab, 0x32, 0x73, 0x04 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMEM" ] + expected: + insns: + - + asm_text: "cv.lw t0, (t1), t2" + + - + input: + bytes: [ 0x2b, 0xb5, 0xc5, 0x04 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMEM" ] + expected: + insns: + - + asm_text: "cv.lw a0, (a1), a2" + + - + input: + bytes: [ 0xab, 0x32, 0x73, 0x0c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMEM" ] + expected: + insns: + - + asm_text: "cv.lw t0, t2(t1)" + + - + input: + bytes: [ 0x2b, 0xb5, 0xc5, 0x0c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMEM" ] + expected: + insns: + - + asm_text: "cv.lw a0, a2(a1)" + + - + input: + bytes: [ 0x2b, 0x00, 0x53, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMEM" ] + expected: + insns: + - + asm_text: "cv.sb t0, (t1), 0" + + - + input: + bytes: [ 0xab, 0x8f, 0xa5, 0x7e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMEM" ] + expected: + insns: + - + asm_text: "cv.sb a0, (a1), 2047" + + - + input: + bytes: [ 0xab, 0x33, 0x53, 0x20 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMEM" ] + expected: + insns: + - + asm_text: "cv.sb t0, (t1), t2" + + - + input: + bytes: [ 0x2b, 0xb6, 0xa5, 0x20 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMEM" ] + expected: + insns: + - + asm_text: "cv.sb a0, (a1), a2" + + - + input: + bytes: [ 0xab, 0x33, 0x53, 0x28 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMEM" ] + expected: + insns: + - + asm_text: "cv.sb t0, t2(t1)" + + - + input: + bytes: [ 0x2b, 0xb6, 0xa5, 0x28 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMEM" ] + expected: + insns: + - + asm_text: "cv.sb a0, a2(a1)" + + - + input: + bytes: [ 0x2b, 0x10, 0x53, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMEM" ] + expected: + insns: + - + asm_text: "cv.sh t0, (t1), 0" + + - + input: + bytes: [ 0xab, 0x9f, 0xa5, 0x7e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMEM" ] + expected: + insns: + - + asm_text: "cv.sh a0, (a1), 2047" + + - + input: + bytes: [ 0xab, 0x33, 0x53, 0x22 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMEM" ] + expected: + insns: + - + asm_text: "cv.sh t0, (t1), t2" + + - + input: + bytes: [ 0x2b, 0xb6, 0xa5, 0x22 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMEM" ] + expected: + insns: + - + asm_text: "cv.sh a0, (a1), a2" + + - + input: + bytes: [ 0xab, 0x33, 0x53, 0x2a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMEM" ] + expected: + insns: + - + asm_text: "cv.sh t0, t2(t1)" + + - + input: + bytes: [ 0x2b, 0xb6, 0xa5, 0x2a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMEM" ] + expected: + insns: + - + asm_text: "cv.sh a0, a2(a1)" + + - + input: + bytes: [ 0x2b, 0x20, 0x53, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMEM" ] + expected: + insns: + - + asm_text: "cv.sw t0, (t1), 0" + + - + input: + bytes: [ 0xab, 0xaf, 0xa5, 0x7e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMEM" ] + expected: + insns: + - + asm_text: "cv.sw a0, (a1), 2047" + + - + input: + bytes: [ 0xab, 0x33, 0x53, 0x24 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMEM" ] + expected: + insns: + - + asm_text: "cv.sw t0, (t1), t2" + + - + input: + bytes: [ 0x2b, 0xb6, 0xa5, 0x24 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMEM" ] + expected: + insns: + - + asm_text: "cv.sw a0, (a1), a2" + + - + input: + bytes: [ 0xab, 0x33, 0x53, 0x2c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMEM" ] + expected: + insns: + - + asm_text: "cv.sw t0, t2(t1)" + + - + input: + bytes: [ 0x2b, 0xb6, 0xa5, 0x2c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVMEM" ] + expected: + insns: + - + asm_text: "cv.sw a0, a2(a1)" diff --git a/tests/MC/RISCV/XCVsimd_riscv32_riscv_xcvsimd.txt.yaml b/tests/MC/RISCV/XCVsimd_riscv32_riscv_xcvsimd.txt.yaml new file mode 100644 index 0000000000..c368ae9afd --- /dev/null +++ b/tests/MC/RISCV/XCVsimd_riscv32_riscv_xcvsimd.txt.yaml @@ -0,0 +1,8800 @@ +test_cases: + - + input: + bytes: [ 0xfb, 0x02, 0x73, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.add.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x8e, 0xee, 0x01 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.add.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x85, 0xc5, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.add.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x84, 0x24, 0x01 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.add.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x12, 0x73, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.add.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x9e, 0xee, 0x01 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.add.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x95, 0xc5, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.add.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x94, 0x24, 0x01 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.add.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x42, 0x73, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.add.sc.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xce, 0xee, 0x01 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.add.sc.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xc5, 0xc5, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.add.sc.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xc4, 0x24, 0x01 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.add.sc.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x52, 0x73, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.add.sc.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xde, 0xee, 0x01 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.add.sc.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xd5, 0xc5, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.add.sc.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xd4, 0x24, 0x01 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.add.sc.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x62, 0x03, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.add.sci.h t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xee, 0x0e, 0x01 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.add.sci.h t3, t4, -32" + + - + input: + bytes: [ 0x7b, 0xe5, 0x35, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.add.sci.h a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xe4, 0xf4, 0x03 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.add.sci.h s0, s1, -1" + + - + input: + bytes: [ 0xfb, 0x72, 0x03, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.add.sci.b t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xfe, 0x0e, 0x01 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.add.sci.b t3, t4, -32" + + - + input: + bytes: [ 0x7b, 0xf5, 0x35, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.add.sci.b a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xf4, 0xf4, 0x03 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.add.sci.b s0, s1, -1" + + - + input: + bytes: [ 0xfb, 0x02, 0x73, 0x08 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sub.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x8e, 0xee, 0x09 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sub.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x85, 0xc5, 0x08 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sub.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x84, 0x24, 0x09 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sub.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x12, 0x73, 0x08 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sub.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x9e, 0xee, 0x09 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sub.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x95, 0xc5, 0x08 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sub.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x94, 0x24, 0x09 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sub.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x42, 0x73, 0x08 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sub.sc.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xce, 0xee, 0x09 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sub.sc.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xc5, 0xc5, 0x08 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sub.sc.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xc4, 0x24, 0x09 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sub.sc.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x52, 0x73, 0x08 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sub.sc.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xde, 0xee, 0x09 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sub.sc.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xd5, 0xc5, 0x08 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sub.sc.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xd4, 0x24, 0x09 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sub.sc.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x62, 0x03, 0x08 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sub.sci.h t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xee, 0x0e, 0x09 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sub.sci.h t3, t4, -32" + + - + input: + bytes: [ 0x7b, 0xe5, 0x35, 0x0a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sub.sci.h a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xe4, 0xf4, 0x0b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sub.sci.h s0, s1, -1" + + - + input: + bytes: [ 0xfb, 0x72, 0x03, 0x08 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sub.sci.b t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xfe, 0x0e, 0x09 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sub.sci.b t3, t4, -32" + + - + input: + bytes: [ 0x7b, 0xf5, 0x35, 0x0a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sub.sci.b a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xf4, 0xf4, 0x0b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sub.sci.b s0, s1, -1" + + - + input: + bytes: [ 0xfb, 0x02, 0x73, 0x10 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.avg.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x8e, 0xee, 0x11 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.avg.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x85, 0xc5, 0x10 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.avg.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x84, 0x24, 0x11 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.avg.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x12, 0x73, 0x10 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.avg.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x9e, 0xee, 0x11 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.avg.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x95, 0xc5, 0x10 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.avg.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x94, 0x24, 0x11 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.avg.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x42, 0x73, 0x10 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.avg.sc.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xce, 0xee, 0x11 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.avg.sc.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xc5, 0xc5, 0x10 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.avg.sc.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xc4, 0x24, 0x11 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.avg.sc.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x52, 0x73, 0x10 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.avg.sc.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xde, 0xee, 0x11 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.avg.sc.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xd5, 0xc5, 0x10 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.avg.sc.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xd4, 0x24, 0x11 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.avg.sc.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x62, 0x03, 0x10 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.avg.sci.h t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xee, 0x0e, 0x11 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.avg.sci.h t3, t4, -32" + + - + input: + bytes: [ 0x7b, 0xe5, 0x35, 0x12 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.avg.sci.h a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xe4, 0xf4, 0x13 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.avg.sci.h s0, s1, -1" + + - + input: + bytes: [ 0xfb, 0x72, 0x03, 0x10 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.avg.sci.b t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xfe, 0x0e, 0x11 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.avg.sci.b t3, t4, -32" + + - + input: + bytes: [ 0x7b, 0xf5, 0x35, 0x12 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.avg.sci.b a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xf4, 0xf4, 0x13 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.avg.sci.b s0, s1, -1" + + - + input: + bytes: [ 0xfb, 0x02, 0x73, 0x18 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.avgu.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x8e, 0xee, 0x19 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.avgu.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x85, 0xc5, 0x18 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.avgu.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x84, 0x24, 0x19 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.avgu.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x12, 0x73, 0x18 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.avgu.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x9e, 0xee, 0x19 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.avgu.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x95, 0xc5, 0x18 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.avgu.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x94, 0x24, 0x19 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.avgu.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x42, 0x73, 0x18 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.avgu.sc.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xce, 0xee, 0x19 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.avgu.sc.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xc5, 0xc5, 0x18 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.avgu.sc.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xc4, 0x24, 0x19 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.avgu.sc.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x52, 0x73, 0x18 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.avgu.sc.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xde, 0xee, 0x19 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.avgu.sc.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xd5, 0xc5, 0x18 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.avgu.sc.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xd4, 0x24, 0x19 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.avgu.sc.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x62, 0x03, 0x18 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.avgu.sci.h t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xee, 0x0e, 0x19 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.avgu.sci.h t3, t4, 32" + + - + input: + bytes: [ 0x7b, 0xe5, 0x35, 0x1a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.avgu.sci.h a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xe4, 0xf4, 0x1b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.avgu.sci.h s0, s1, 63" + + - + input: + bytes: [ 0xfb, 0x72, 0x03, 0x18 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.avgu.sci.b t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xfe, 0x0e, 0x19 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.avgu.sci.b t3, t4, 32" + + - + input: + bytes: [ 0x7b, 0xf5, 0x35, 0x1a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.avgu.sci.b a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xf4, 0xf4, 0x1b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.avgu.sci.b s0, s1, 63" + + - + input: + bytes: [ 0xfb, 0x02, 0x73, 0x20 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.min.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x8e, 0xee, 0x21 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.min.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x85, 0xc5, 0x20 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.min.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x84, 0x24, 0x21 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.min.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x12, 0x73, 0x20 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.min.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x9e, 0xee, 0x21 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.min.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x95, 0xc5, 0x20 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.min.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x94, 0x24, 0x21 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.min.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x42, 0x73, 0x20 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.min.sc.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xce, 0xee, 0x21 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.min.sc.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xc5, 0xc5, 0x20 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.min.sc.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xc4, 0x24, 0x21 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.min.sc.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x52, 0x73, 0x20 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.min.sc.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xde, 0xee, 0x21 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.min.sc.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xd5, 0xc5, 0x20 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.min.sc.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xd4, 0x24, 0x21 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.min.sc.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x62, 0x03, 0x20 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.min.sci.h t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xee, 0x0e, 0x21 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.min.sci.h t3, t4, -32" + + - + input: + bytes: [ 0x7b, 0xe5, 0x35, 0x22 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.min.sci.h a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xe4, 0xf4, 0x23 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.min.sci.h s0, s1, -1" + + - + input: + bytes: [ 0xfb, 0x72, 0x03, 0x20 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.min.sci.b t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xfe, 0x0e, 0x21 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.min.sci.b t3, t4, -32" + + - + input: + bytes: [ 0x7b, 0xf5, 0x35, 0x22 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.min.sci.b a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xf4, 0xf4, 0x23 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.min.sci.b s0, s1, -1" + + - + input: + bytes: [ 0xfb, 0x02, 0x73, 0x28 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.minu.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x8e, 0xee, 0x29 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.minu.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x85, 0xc5, 0x28 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.minu.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x84, 0x24, 0x29 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.minu.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x12, 0x73, 0x28 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.minu.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x9e, 0xee, 0x29 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.minu.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x95, 0xc5, 0x28 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.minu.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x94, 0x24, 0x29 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.minu.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x42, 0x73, 0x28 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.minu.sc.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xce, 0xee, 0x29 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.minu.sc.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xc5, 0xc5, 0x28 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.minu.sc.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xc4, 0x24, 0x29 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.minu.sc.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x52, 0x73, 0x28 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.minu.sc.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xde, 0xee, 0x29 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.minu.sc.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xd5, 0xc5, 0x28 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.minu.sc.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xd4, 0x24, 0x29 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.minu.sc.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x62, 0x03, 0x28 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.minu.sci.h t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xee, 0x0e, 0x29 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.minu.sci.h t3, t4, 32" + + - + input: + bytes: [ 0x7b, 0xe5, 0x35, 0x2a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.minu.sci.h a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xe4, 0xf4, 0x2b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.minu.sci.h s0, s1, 63" + + - + input: + bytes: [ 0xfb, 0x72, 0x03, 0x28 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.minu.sci.b t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xfe, 0x0e, 0x29 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.minu.sci.b t3, t4, 32" + + - + input: + bytes: [ 0x7b, 0xf5, 0x35, 0x2a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.minu.sci.b a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xf4, 0xf4, 0x2b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.minu.sci.b s0, s1, 63" + + - + input: + bytes: [ 0xfb, 0x02, 0x73, 0x30 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.max.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x8e, 0xee, 0x31 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.max.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x85, 0xc5, 0x30 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.max.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x84, 0x24, 0x31 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.max.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x12, 0x73, 0x30 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.max.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x9e, 0xee, 0x31 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.max.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x95, 0xc5, 0x30 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.max.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x94, 0x24, 0x31 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.max.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x42, 0x73, 0x30 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.max.sc.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xce, 0xee, 0x31 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.max.sc.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xc5, 0xc5, 0x30 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.max.sc.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xc4, 0x24, 0x31 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.max.sc.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x52, 0x73, 0x30 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.max.sc.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xde, 0xee, 0x31 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.max.sc.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xd5, 0xc5, 0x30 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.max.sc.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xd4, 0x24, 0x31 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.max.sc.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x62, 0x03, 0x30 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.max.sci.h t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xee, 0x0e, 0x31 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.max.sci.h t3, t4, -32" + + - + input: + bytes: [ 0x7b, 0xe5, 0x35, 0x32 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.max.sci.h a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xe4, 0xf4, 0x33 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.max.sci.h s0, s1, -1" + + - + input: + bytes: [ 0xfb, 0x72, 0x03, 0x30 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.max.sci.b t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xfe, 0x0e, 0x31 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.max.sci.b t3, t4, -32" + + - + input: + bytes: [ 0x7b, 0xf5, 0x35, 0x32 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.max.sci.b a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xf4, 0xf4, 0x33 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.max.sci.b s0, s1, -1" + + - + input: + bytes: [ 0xfb, 0x02, 0x73, 0x38 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.maxu.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x8e, 0xee, 0x39 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.maxu.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x85, 0xc5, 0x38 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.maxu.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x84, 0x24, 0x39 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.maxu.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x12, 0x73, 0x38 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.maxu.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x9e, 0xee, 0x39 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.maxu.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x95, 0xc5, 0x38 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.maxu.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x94, 0x24, 0x39 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.maxu.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x42, 0x73, 0x38 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.maxu.sc.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xce, 0xee, 0x39 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.maxu.sc.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xc5, 0xc5, 0x38 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.maxu.sc.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xc4, 0x24, 0x39 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.maxu.sc.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x52, 0x73, 0x38 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.maxu.sc.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xde, 0xee, 0x39 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.maxu.sc.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xd5, 0xc5, 0x38 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.maxu.sc.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xd4, 0x24, 0x39 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.maxu.sc.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x62, 0x03, 0x38 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.maxu.sci.h t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xee, 0x0e, 0x39 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.maxu.sci.h t3, t4, 32" + + - + input: + bytes: [ 0x7b, 0xe5, 0x35, 0x3a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.maxu.sci.h a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xe4, 0xf4, 0x3b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.maxu.sci.h s0, s1, 63" + + - + input: + bytes: [ 0xfb, 0x72, 0x03, 0x38 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.maxu.sci.b t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xfe, 0x0e, 0x39 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.maxu.sci.b t3, t4, 32" + + - + input: + bytes: [ 0x7b, 0xf5, 0x35, 0x3a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.maxu.sci.b a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xf4, 0xf4, 0x3b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.maxu.sci.b s0, s1, 63" + + - + input: + bytes: [ 0xfb, 0x02, 0x73, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.srl.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x8e, 0xee, 0x41 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.srl.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x85, 0xc5, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.srl.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x84, 0x24, 0x41 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.srl.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x12, 0x73, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.srl.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x9e, 0xee, 0x41 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.srl.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x95, 0xc5, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.srl.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x94, 0x24, 0x41 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.srl.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x42, 0x73, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.srl.sc.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xce, 0xee, 0x41 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.srl.sc.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xc5, 0xc5, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.srl.sc.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xc4, 0x24, 0x41 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.srl.sc.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x52, 0x73, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.srl.sc.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xde, 0xee, 0x41 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.srl.sc.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xd5, 0xc5, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.srl.sc.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xd4, 0x24, 0x41 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.srl.sc.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x62, 0x03, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.srl.sci.h t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xee, 0x0e, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.srl.sci.h t3, t4, 0" + + - + input: + bytes: [ 0x7b, 0xe5, 0x35, 0x42 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.srl.sci.h a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xe4, 0x74, 0x42 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.srl.sci.h s0, s1, 15" + + - + input: + bytes: [ 0xfb, 0x72, 0x03, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.srl.sci.b t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xfe, 0x0e, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.srl.sci.b t3, t4, 0" + + - + input: + bytes: [ 0x7b, 0xf5, 0x35, 0x42 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.srl.sci.b a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xf4, 0x34, 0x42 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.srl.sci.b s0, s1, 7" + + - + input: + bytes: [ 0xfb, 0x02, 0x73, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sra.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x8e, 0xee, 0x49 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sra.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x85, 0xc5, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sra.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x84, 0x24, 0x49 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sra.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x12, 0x73, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sra.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x9e, 0xee, 0x49 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sra.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x95, 0xc5, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sra.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x94, 0x24, 0x49 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sra.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x42, 0x73, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sra.sc.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xce, 0xee, 0x49 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sra.sc.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xc5, 0xc5, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sra.sc.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xc4, 0x24, 0x49 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sra.sc.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x52, 0x73, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sra.sc.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xde, 0xee, 0x49 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sra.sc.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xd5, 0xc5, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sra.sc.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xd4, 0x24, 0x49 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sra.sc.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x62, 0x03, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sra.sci.h t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xee, 0x0e, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sra.sci.h t3, t4, 0" + + - + input: + bytes: [ 0x7b, 0xe5, 0x35, 0x4a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sra.sci.h a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xe4, 0x74, 0x4a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sra.sci.h s0, s1, 15" + + - + input: + bytes: [ 0xfb, 0x72, 0x03, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sra.sci.b t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xfe, 0x0e, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sra.sci.b t3, t4, 0" + + - + input: + bytes: [ 0x7b, 0xf5, 0x35, 0x4a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sra.sci.b a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xf4, 0x34, 0x4a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sra.sci.b s0, s1, 7" + + - + input: + bytes: [ 0xfb, 0x02, 0x73, 0x50 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sll.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x8e, 0xee, 0x51 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sll.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x85, 0xc5, 0x50 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sll.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x84, 0x24, 0x51 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sll.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x12, 0x73, 0x50 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sll.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x9e, 0xee, 0x51 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sll.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x95, 0xc5, 0x50 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sll.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x94, 0x24, 0x51 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sll.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x42, 0x73, 0x50 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sll.sc.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xce, 0xee, 0x51 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sll.sc.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xc5, 0xc5, 0x50 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sll.sc.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xc4, 0x24, 0x51 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sll.sc.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x52, 0x73, 0x50 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sll.sc.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xde, 0xee, 0x51 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sll.sc.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xd5, 0xc5, 0x50 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sll.sc.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xd4, 0x24, 0x51 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sll.sc.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x62, 0x03, 0x50 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sll.sci.h t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xee, 0x0e, 0x50 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sll.sci.h t3, t4, 0" + + - + input: + bytes: [ 0x7b, 0xe5, 0x35, 0x52 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sll.sci.h a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xe4, 0x74, 0x52 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sll.sci.h s0, s1, 15" + + - + input: + bytes: [ 0xfb, 0x72, 0x03, 0x50 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sll.sci.b t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xfe, 0x0e, 0x50 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sll.sci.b t3, t4, 0" + + - + input: + bytes: [ 0x7b, 0xf5, 0x35, 0x52 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sll.sci.b a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xf4, 0x34, 0x52 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sll.sci.b s0, s1, 7" + + - + input: + bytes: [ 0xfb, 0x02, 0x73, 0x58 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.or.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x8e, 0xee, 0x59 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.or.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x85, 0xc5, 0x58 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.or.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x84, 0x24, 0x59 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.or.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x12, 0x73, 0x58 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.or.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x9e, 0xee, 0x59 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.or.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x95, 0xc5, 0x58 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.or.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x94, 0x24, 0x59 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.or.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x42, 0x73, 0x58 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.or.sc.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xce, 0xee, 0x59 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.or.sc.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xc5, 0xc5, 0x58 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.or.sc.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xc4, 0x24, 0x59 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.or.sc.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x52, 0x73, 0x58 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.or.sc.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xde, 0xee, 0x59 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.or.sc.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xd5, 0xc5, 0x58 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.or.sc.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xd4, 0x24, 0x59 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.or.sc.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x62, 0x03, 0x58 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.or.sci.h t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xee, 0x0e, 0x59 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.or.sci.h t3, t4, -32" + + - + input: + bytes: [ 0x7b, 0xe5, 0x35, 0x5a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.or.sci.h a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xe4, 0xf4, 0x5b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.or.sci.h s0, s1, -1" + + - + input: + bytes: [ 0xfb, 0x72, 0x03, 0x58 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.or.sci.b t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xfe, 0x0e, 0x59 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.or.sci.b t3, t4, -32" + + - + input: + bytes: [ 0x7b, 0xf5, 0x35, 0x5a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.or.sci.b a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xf4, 0xf4, 0x5b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.or.sci.b s0, s1, -1" + + - + input: + bytes: [ 0xfb, 0x02, 0x73, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.xor.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x8e, 0xee, 0x61 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.xor.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x85, 0xc5, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.xor.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x84, 0x24, 0x61 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.xor.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x12, 0x73, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.xor.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x9e, 0xee, 0x61 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.xor.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x95, 0xc5, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.xor.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x94, 0x24, 0x61 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.xor.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x42, 0x73, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.xor.sc.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xce, 0xee, 0x61 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.xor.sc.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xc5, 0xc5, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.xor.sc.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xc4, 0x24, 0x61 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.xor.sc.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x52, 0x73, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.xor.sc.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xde, 0xee, 0x61 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.xor.sc.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xd5, 0xc5, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.xor.sc.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xd4, 0x24, 0x61 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.xor.sc.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x62, 0x03, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.xor.sci.h t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xee, 0x0e, 0x61 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.xor.sci.h t3, t4, -32" + + - + input: + bytes: [ 0x7b, 0xe5, 0x35, 0x62 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.xor.sci.h a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xe4, 0xf4, 0x63 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.xor.sci.h s0, s1, -1" + + - + input: + bytes: [ 0xfb, 0x72, 0x03, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.xor.sci.b t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xfe, 0x0e, 0x61 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.xor.sci.b t3, t4, -32" + + - + input: + bytes: [ 0x7b, 0xf5, 0x35, 0x62 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.xor.sci.b a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xf4, 0xf4, 0x63 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.xor.sci.b s0, s1, -1" + + - + input: + bytes: [ 0xfb, 0x02, 0x73, 0x68 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.and.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x8e, 0xee, 0x69 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.and.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x85, 0xc5, 0x68 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.and.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x84, 0x24, 0x69 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.and.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x12, 0x73, 0x68 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.and.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x9e, 0xee, 0x69 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.and.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x95, 0xc5, 0x68 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.and.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x94, 0x24, 0x69 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.and.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x42, 0x73, 0x68 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.and.sc.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xce, 0xee, 0x69 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.and.sc.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xc5, 0xc5, 0x68 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.and.sc.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xc4, 0x24, 0x69 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.and.sc.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x52, 0x73, 0x68 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.and.sc.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xde, 0xee, 0x69 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.and.sc.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xd5, 0xc5, 0x68 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.and.sc.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xd4, 0x24, 0x69 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.and.sc.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x62, 0x03, 0x68 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.and.sci.h t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xee, 0x0e, 0x69 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.and.sci.h t3, t4, -32" + + - + input: + bytes: [ 0x7b, 0xe5, 0x35, 0x6a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.and.sci.h a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xe4, 0xf4, 0x6b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.and.sci.h s0, s1, -1" + + - + input: + bytes: [ 0xfb, 0x72, 0x03, 0x68 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.and.sci.b t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xfe, 0x0e, 0x69 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.and.sci.b t3, t4, -32" + + - + input: + bytes: [ 0x7b, 0xf5, 0x35, 0x6a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.and.sci.b a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xf4, 0xf4, 0x6b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.and.sci.b s0, s1, -1" + + - + input: + bytes: [ 0xfb, 0x02, 0x03, 0x70 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.abs.h t0, t1" + + - + input: + bytes: [ 0x7b, 0x8e, 0x0e, 0x70 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.abs.h t3, t4" + + - + input: + bytes: [ 0x7b, 0x85, 0x05, 0x70 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.abs.h a0, a1" + + - + input: + bytes: [ 0x7b, 0x84, 0x04, 0x70 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.abs.h s0, s1" + + - + input: + bytes: [ 0xfb, 0x12, 0x03, 0x70 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.abs.b t0, t1" + + - + input: + bytes: [ 0x7b, 0x9e, 0x0e, 0x70 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.abs.b t3, t4" + + - + input: + bytes: [ 0x7b, 0x95, 0x05, 0x70 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.abs.b a0, a1" + + - + input: + bytes: [ 0x7b, 0x94, 0x04, 0x70 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.abs.b s0, s1" + + - + input: + bytes: [ 0xfb, 0x02, 0x73, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotup.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x8e, 0xee, 0x81 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotup.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x85, 0xc5, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotup.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x84, 0x24, 0x81 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotup.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x12, 0x73, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotup.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x9e, 0xee, 0x81 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotup.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x95, 0xc5, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotup.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x94, 0x24, 0x81 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotup.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x42, 0x73, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotup.sc.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xce, 0xee, 0x81 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotup.sc.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xc5, 0xc5, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotup.sc.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xc4, 0x24, 0x81 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotup.sc.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x52, 0x73, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotup.sc.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xde, 0xee, 0x81 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotup.sc.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xd5, 0xc5, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotup.sc.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xd4, 0x24, 0x81 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotup.sc.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x62, 0x03, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotup.sci.h t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xee, 0x0e, 0x81 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotup.sci.h t3, t4, 32" + + - + input: + bytes: [ 0x7b, 0xe5, 0x35, 0x82 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotup.sci.h a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xe4, 0xf4, 0x83 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotup.sci.h s0, s1, 63" + + - + input: + bytes: [ 0xfb, 0x72, 0x03, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotup.sci.b t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xfe, 0x0e, 0x81 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotup.sci.b t3, t4, 32" + + - + input: + bytes: [ 0x7b, 0xf5, 0x35, 0x82 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotup.sci.b a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xf4, 0xf4, 0x83 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotup.sci.b s0, s1, 63" + + - + input: + bytes: [ 0xfb, 0x02, 0x73, 0x88 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotusp.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x8e, 0xee, 0x89 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotusp.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x85, 0xc5, 0x88 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotusp.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x84, 0x24, 0x89 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotusp.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x12, 0x73, 0x88 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotusp.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x9e, 0xee, 0x89 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotusp.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x95, 0xc5, 0x88 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotusp.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x94, 0x24, 0x89 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotusp.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x42, 0x73, 0x88 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotusp.sc.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xce, 0xee, 0x89 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotusp.sc.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xc5, 0xc5, 0x88 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotusp.sc.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xc4, 0x24, 0x89 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotusp.sc.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x52, 0x73, 0x88 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotusp.sc.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xde, 0xee, 0x89 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotusp.sc.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xd5, 0xc5, 0x88 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotusp.sc.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xd4, 0x24, 0x89 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotusp.sc.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x62, 0x03, 0x88 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotusp.sci.h t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xee, 0x0e, 0x89 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotusp.sci.h t3, t4, -32" + + - + input: + bytes: [ 0x7b, 0xe5, 0x35, 0x8a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotusp.sci.h a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xe4, 0xf4, 0x8b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotusp.sci.h s0, s1, -1" + + - + input: + bytes: [ 0xfb, 0x72, 0x03, 0x88 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotusp.sci.b t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xfe, 0x0e, 0x89 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotusp.sci.b t3, t4, -32" + + - + input: + bytes: [ 0x7b, 0xf5, 0x35, 0x8a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotusp.sci.b a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xf4, 0xf4, 0x8b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotusp.sci.b s0, s1, -1" + + - + input: + bytes: [ 0xfb, 0x02, 0x73, 0x90 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotsp.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x8e, 0xee, 0x91 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotsp.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x85, 0xc5, 0x90 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotsp.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x84, 0x24, 0x91 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotsp.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x12, 0x73, 0x90 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotsp.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x9e, 0xee, 0x91 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotsp.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x95, 0xc5, 0x90 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotsp.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x94, 0x24, 0x91 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotsp.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x42, 0x73, 0x90 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotsp.sc.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xce, 0xee, 0x91 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotsp.sc.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xc5, 0xc5, 0x90 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotsp.sc.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xc4, 0x24, 0x91 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotsp.sc.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x52, 0x73, 0x90 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotsp.sc.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xde, 0xee, 0x91 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotsp.sc.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xd5, 0xc5, 0x90 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotsp.sc.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xd4, 0x24, 0x91 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotsp.sc.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x62, 0x03, 0x90 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotsp.sci.h t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xee, 0x0e, 0x91 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotsp.sci.h t3, t4, -32" + + - + input: + bytes: [ 0x7b, 0xe5, 0x35, 0x92 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotsp.sci.h a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xe4, 0xf4, 0x93 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotsp.sci.h s0, s1, -1" + + - + input: + bytes: [ 0xfb, 0x72, 0x03, 0x90 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotsp.sci.b t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xfe, 0x0e, 0x91 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotsp.sci.b t3, t4, -32" + + - + input: + bytes: [ 0x7b, 0xf5, 0x35, 0x92 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotsp.sci.b a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xf4, 0xf4, 0x93 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.dotsp.sci.b s0, s1, -1" + + - + input: + bytes: [ 0xfb, 0x02, 0x73, 0x98 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotup.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x8e, 0xee, 0x99 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotup.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x85, 0xc5, 0x98 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotup.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x84, 0x24, 0x99 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotup.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x12, 0x73, 0x98 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotup.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x9e, 0xee, 0x99 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotup.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x95, 0xc5, 0x98 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotup.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x94, 0x24, 0x99 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotup.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x42, 0x73, 0x98 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotup.sc.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xce, 0xee, 0x99 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotup.sc.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xc5, 0xc5, 0x98 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotup.sc.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xc4, 0x24, 0x99 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotup.sc.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x52, 0x73, 0x98 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotup.sc.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xde, 0xee, 0x99 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotup.sc.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xd5, 0xc5, 0x98 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotup.sc.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xd4, 0x24, 0x99 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotup.sc.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x62, 0x03, 0x98 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotup.sci.h t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xee, 0x0e, 0x99 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotup.sci.h t3, t4, 32" + + - + input: + bytes: [ 0x7b, 0xe5, 0x35, 0x9a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotup.sci.h a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xe4, 0xf4, 0x9b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotup.sci.h s0, s1, 63" + + - + input: + bytes: [ 0xfb, 0x72, 0x03, 0x98 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotup.sci.b t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xfe, 0x0e, 0x99 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotup.sci.b t3, t4, 32" + + - + input: + bytes: [ 0x7b, 0xf5, 0x35, 0x9a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotup.sci.b a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xf4, 0xf4, 0x9b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotup.sci.b s0, s1, 63" + + - + input: + bytes: [ 0xfb, 0x02, 0x73, 0xa0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotusp.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x8e, 0xee, 0xa1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotusp.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x85, 0xc5, 0xa0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotusp.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x84, 0x24, 0xa1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotusp.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x12, 0x73, 0xa0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotusp.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x9e, 0xee, 0xa1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotusp.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x95, 0xc5, 0xa0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotusp.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x94, 0x24, 0xa1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotusp.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x42, 0x73, 0xa0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotusp.sc.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xce, 0xee, 0xa1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotusp.sc.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xc5, 0xc5, 0xa0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotusp.sc.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xc4, 0x24, 0xa1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotusp.sc.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x52, 0x73, 0xa0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotusp.sc.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xde, 0xee, 0xa1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotusp.sc.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xd5, 0xc5, 0xa0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotusp.sc.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xd4, 0x24, 0xa1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotusp.sc.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x62, 0x03, 0xa0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotusp.sci.h t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xee, 0x0e, 0xa1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotusp.sci.h t3, t4, -32" + + - + input: + bytes: [ 0x7b, 0xe5, 0x35, 0xa2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotusp.sci.h a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xe4, 0xf4, 0xa3 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotusp.sci.h s0, s1, -1" + + - + input: + bytes: [ 0xfb, 0x72, 0x03, 0xa0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotusp.sci.b t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xfe, 0x0e, 0xa1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotusp.sci.b t3, t4, -32" + + - + input: + bytes: [ 0x7b, 0xf5, 0x35, 0xa2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotusp.sci.b a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xf4, 0xf4, 0xa3 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotusp.sci.b s0, s1, -1" + + - + input: + bytes: [ 0xfb, 0x02, 0x73, 0xa8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotsp.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x8e, 0xee, 0xa9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotsp.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x85, 0xc5, 0xa8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotsp.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x84, 0x24, 0xa9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotsp.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x12, 0x73, 0xa8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotsp.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x9e, 0xee, 0xa9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotsp.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x95, 0xc5, 0xa8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotsp.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x94, 0x24, 0xa9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotsp.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x42, 0x73, 0xa8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotsp.sc.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xce, 0xee, 0xa9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotsp.sc.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xc5, 0xc5, 0xa8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotsp.sc.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xc4, 0x24, 0xa9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotsp.sc.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x52, 0x73, 0xa8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotsp.sc.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xde, 0xee, 0xa9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotsp.sc.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xd5, 0xc5, 0xa8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotsp.sc.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xd4, 0x24, 0xa9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotsp.sc.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x62, 0x03, 0xa8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotsp.sci.h t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xee, 0x0e, 0xa9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotsp.sci.h t3, t4, -32" + + - + input: + bytes: [ 0x7b, 0xe5, 0x35, 0xaa ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotsp.sci.h a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xe4, 0xf4, 0xab ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotsp.sci.h s0, s1, -1" + + - + input: + bytes: [ 0xfb, 0x72, 0x03, 0xa8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotsp.sci.b t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xfe, 0x0e, 0xa9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotsp.sci.b t3, t4, -32" + + - + input: + bytes: [ 0x7b, 0xf5, 0x35, 0xaa ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotsp.sci.b a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xf4, 0xf4, 0xab ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sdotsp.sci.b s0, s1, -1" + + - + input: + bytes: [ 0xfb, 0x02, 0x03, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.extract.h t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0x8e, 0x0e, 0xb9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.extract.h t3, t4, 32" + + - + input: + bytes: [ 0x7b, 0x85, 0x35, 0xba ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.extract.h a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0x84, 0xf4, 0xbb ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.extract.h s0, s1, 63" + + - + input: + bytes: [ 0xfb, 0x12, 0x03, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.extract.b t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0x9e, 0x0e, 0xb9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.extract.b t3, t4, 32" + + - + input: + bytes: [ 0x7b, 0x95, 0x35, 0xba ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.extract.b a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0x94, 0xf4, 0xbb ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.extract.b s0, s1, 63" + + - + input: + bytes: [ 0xfb, 0x22, 0x03, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.extractu.h t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xae, 0x0e, 0xb9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.extractu.h t3, t4, 32" + + - + input: + bytes: [ 0x7b, 0xa5, 0x35, 0xba ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.extractu.h a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xa4, 0xf4, 0xbb ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.extractu.h s0, s1, 63" + + - + input: + bytes: [ 0xfb, 0x32, 0x03, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.extractu.b t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xbe, 0x0e, 0xb9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.extractu.b t3, t4, 32" + + - + input: + bytes: [ 0x7b, 0xb5, 0x35, 0xba ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.extractu.b a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xb4, 0xf4, 0xbb ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.extractu.b s0, s1, 63" + + - + input: + bytes: [ 0xfb, 0x42, 0x03, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.insert.h t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xce, 0x0e, 0xb9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.insert.h t3, t4, 32" + + - + input: + bytes: [ 0x7b, 0xc5, 0x35, 0xba ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.insert.h a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xc4, 0xf4, 0xbb ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.insert.h s0, s1, 63" + + - + input: + bytes: [ 0xfb, 0x52, 0x03, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.insert.b t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xde, 0x0e, 0xb9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.insert.b t3, t4, 32" + + - + input: + bytes: [ 0x7b, 0xd5, 0x35, 0xba ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.insert.b a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xd4, 0xf4, 0xbb ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.insert.b s0, s1, 63" + + - + input: + bytes: [ 0xfb, 0x02, 0x73, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.shuffle.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x8e, 0xee, 0xc1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.shuffle.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x85, 0xc5, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.shuffle.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x84, 0x24, 0xc1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.shuffle.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x12, 0x73, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.shuffle.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x9e, 0xee, 0xc1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.shuffle.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x95, 0xc5, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.shuffle.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x94, 0x24, 0xc1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.shuffle.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x62, 0x03, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.shuffle.sci.h t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xee, 0x0e, 0xc1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.shuffle.sci.h t3, t4, 32" + + - + input: + bytes: [ 0x7b, 0xe5, 0x35, 0xc2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.shuffle.sci.h a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xe4, 0xf4, 0xc3 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.shuffle.sci.h s0, s1, 63" + + - + input: + bytes: [ 0xfb, 0x72, 0x03, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.shufflei0.sci.b t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xfe, 0x0e, 0xc1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.shufflei0.sci.b t3, t4, 32" + + - + input: + bytes: [ 0x7b, 0xf5, 0x35, 0xc2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.shufflei0.sci.b a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xf4, 0xf4, 0xc3 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.shufflei0.sci.b s0, s1, 63" + + - + input: + bytes: [ 0xfb, 0x72, 0x03, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.shufflei1.sci.b t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xfe, 0x0e, 0xc9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.shufflei1.sci.b t3, t4, 32" + + - + input: + bytes: [ 0x7b, 0xf5, 0x35, 0xca ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.shufflei1.sci.b a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xf4, 0xf4, 0xcb ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.shufflei1.sci.b s0, s1, 63" + + - + input: + bytes: [ 0xfb, 0x72, 0x03, 0xd0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.shufflei2.sci.b t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xfe, 0x0e, 0xd1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.shufflei2.sci.b t3, t4, 32" + + - + input: + bytes: [ 0x7b, 0xf5, 0x35, 0xd2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.shufflei2.sci.b a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xf4, 0xf4, 0xd3 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.shufflei2.sci.b s0, s1, 63" + + - + input: + bytes: [ 0xfb, 0x72, 0x03, 0xd8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.shufflei3.sci.b t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xfe, 0x0e, 0xd9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.shufflei3.sci.b t3, t4, 32" + + - + input: + bytes: [ 0x7b, 0xf5, 0x35, 0xda ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.shufflei3.sci.b a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xf4, 0xf4, 0xdb ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.shufflei3.sci.b s0, s1, 63" + + - + input: + bytes: [ 0xfb, 0x02, 0x73, 0xe0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.shuffle2.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x8e, 0xee, 0xe1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.shuffle2.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x85, 0xc5, 0xe0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.shuffle2.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x84, 0x24, 0xe1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.shuffle2.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x12, 0x73, 0xe0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.shuffle2.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x9e, 0xee, 0xe1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.shuffle2.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x95, 0xc5, 0xe0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.shuffle2.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x94, 0x24, 0xe1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.shuffle2.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x02, 0x73, 0xf0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.pack t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x8e, 0xee, 0xf1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.pack t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x85, 0xc5, 0xf0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.pack a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x84, 0x24, 0xf1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.pack s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x02, 0x73, 0xf2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.pack.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x8e, 0xee, 0xf3 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.pack.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x85, 0xc5, 0xf2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.pack.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x84, 0x24, 0xf3 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.pack.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x12, 0x73, 0xfa ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.packhi.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x9e, 0xee, 0xfb ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.packhi.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x95, 0xc5, 0xfa ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.packhi.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x94, 0x24, 0xfb ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.packhi.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x12, 0x73, 0xf8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.packlo.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x9e, 0xee, 0xf9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.packlo.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x95, 0xc5, 0xf8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.packlo.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x94, 0x24, 0xf9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.packlo.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x02, 0x73, 0x04 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpeq.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x8e, 0xee, 0x05 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpeq.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x85, 0xc5, 0x04 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpeq.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x84, 0x24, 0x05 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpeq.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x12, 0x73, 0x04 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpeq.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x9e, 0xee, 0x05 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpeq.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x95, 0xc5, 0x04 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpeq.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x94, 0x24, 0x05 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpeq.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x42, 0x73, 0x04 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpeq.sc.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xce, 0xee, 0x05 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpeq.sc.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xc5, 0xc5, 0x04 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpeq.sc.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xc4, 0x24, 0x05 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpeq.sc.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x52, 0x73, 0x04 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpeq.sc.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xde, 0xee, 0x05 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpeq.sc.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xd5, 0xc5, 0x04 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpeq.sc.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xd4, 0x24, 0x05 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpeq.sc.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x62, 0x03, 0x04 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpeq.sci.h t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xee, 0x0e, 0x05 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpeq.sci.h t3, t4, -32" + + - + input: + bytes: [ 0x7b, 0xe5, 0x35, 0x06 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpeq.sci.h a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xe4, 0xf4, 0x07 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpeq.sci.h s0, s1, -1" + + - + input: + bytes: [ 0xfb, 0x72, 0x03, 0x04 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpeq.sci.b t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xfe, 0x0e, 0x05 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpeq.sci.b t3, t4, -32" + + - + input: + bytes: [ 0x7b, 0xf5, 0x35, 0x06 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpeq.sci.b a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xf4, 0xf4, 0x07 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpeq.sci.b s0, s1, -1" + + - + input: + bytes: [ 0xfb, 0x02, 0x73, 0x0c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpne.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x8e, 0xee, 0x0d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpne.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x85, 0xc5, 0x0c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpne.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x84, 0x24, 0x0d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpne.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x12, 0x73, 0x0c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpne.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x9e, 0xee, 0x0d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpne.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x95, 0xc5, 0x0c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpne.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x94, 0x24, 0x0d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpne.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x42, 0x73, 0x0c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpne.sc.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xce, 0xee, 0x0d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpne.sc.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xc5, 0xc5, 0x0c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpne.sc.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xc4, 0x24, 0x0d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpne.sc.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x52, 0x73, 0x0c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpne.sc.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xde, 0xee, 0x0d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpne.sc.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xd5, 0xc5, 0x0c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpne.sc.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xd4, 0x24, 0x0d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpne.sc.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x62, 0x03, 0x0c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpne.sci.h t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xee, 0x0e, 0x0d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpne.sci.h t3, t4, -32" + + - + input: + bytes: [ 0x7b, 0xe5, 0x35, 0x0e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpne.sci.h a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xe4, 0xf4, 0x0f ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpne.sci.h s0, s1, -1" + + - + input: + bytes: [ 0xfb, 0x72, 0x03, 0x0c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpne.sci.b t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xfe, 0x0e, 0x0d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpne.sci.b t3, t4, -32" + + - + input: + bytes: [ 0x7b, 0xf5, 0x35, 0x0e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpne.sci.b a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xf4, 0xf4, 0x0f ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpne.sci.b s0, s1, -1" + + - + input: + bytes: [ 0xfb, 0x02, 0x73, 0x14 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgt.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x8e, 0xee, 0x15 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgt.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x85, 0xc5, 0x14 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgt.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x84, 0x24, 0x15 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgt.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x12, 0x73, 0x14 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgt.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x9e, 0xee, 0x15 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgt.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x95, 0xc5, 0x14 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgt.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x94, 0x24, 0x15 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgt.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x42, 0x73, 0x14 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgt.sc.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xce, 0xee, 0x15 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgt.sc.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xc5, 0xc5, 0x14 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgt.sc.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xc4, 0x24, 0x15 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgt.sc.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x52, 0x73, 0x14 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgt.sc.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xde, 0xee, 0x15 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgt.sc.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xd5, 0xc5, 0x14 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgt.sc.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xd4, 0x24, 0x15 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgt.sc.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x62, 0x03, 0x14 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgt.sci.h t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xee, 0x0e, 0x15 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgt.sci.h t3, t4, -32" + + - + input: + bytes: [ 0x7b, 0xe5, 0x35, 0x16 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgt.sci.h a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xe4, 0xf4, 0x17 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgt.sci.h s0, s1, -1" + + - + input: + bytes: [ 0xfb, 0x72, 0x03, 0x14 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgt.sci.b t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xfe, 0x0e, 0x15 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgt.sci.b t3, t4, -32" + + - + input: + bytes: [ 0x7b, 0xf5, 0x35, 0x16 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgt.sci.b a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xf4, 0xf4, 0x17 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgt.sci.b s0, s1, -1" + + - + input: + bytes: [ 0xfb, 0x02, 0x73, 0x1c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpge.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x8e, 0xee, 0x1d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpge.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x85, 0xc5, 0x1c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpge.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x84, 0x24, 0x1d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpge.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x12, 0x73, 0x1c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpge.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x9e, 0xee, 0x1d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpge.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x95, 0xc5, 0x1c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpge.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x94, 0x24, 0x1d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpge.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x42, 0x73, 0x1c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpge.sc.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xce, 0xee, 0x1d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpge.sc.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xc5, 0xc5, 0x1c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpge.sc.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xc4, 0x24, 0x1d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpge.sc.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x52, 0x73, 0x1c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpge.sc.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xde, 0xee, 0x1d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpge.sc.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xd5, 0xc5, 0x1c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpge.sc.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xd4, 0x24, 0x1d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpge.sc.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x62, 0x03, 0x1c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpge.sci.h t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xee, 0x0e, 0x1d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpge.sci.h t3, t4, -32" + + - + input: + bytes: [ 0x7b, 0xe5, 0x35, 0x1e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpge.sci.h a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xe4, 0xf4, 0x1f ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpge.sci.h s0, s1, -1" + + - + input: + bytes: [ 0xfb, 0x72, 0x03, 0x1c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpge.sci.b t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xfe, 0x0e, 0x1d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpge.sci.b t3, t4, -32" + + - + input: + bytes: [ 0x7b, 0xf5, 0x35, 0x1e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpge.sci.b a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xf4, 0xf4, 0x1f ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpge.sci.b s0, s1, -1" + + - + input: + bytes: [ 0xfb, 0x02, 0x73, 0x24 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmplt.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x8e, 0xee, 0x25 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmplt.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x85, 0xc5, 0x24 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmplt.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x84, 0x24, 0x25 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmplt.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x12, 0x73, 0x24 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmplt.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x9e, 0xee, 0x25 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmplt.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x95, 0xc5, 0x24 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmplt.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x94, 0x24, 0x25 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmplt.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x42, 0x73, 0x24 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmplt.sc.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xce, 0xee, 0x25 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmplt.sc.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xc5, 0xc5, 0x24 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmplt.sc.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xc4, 0x24, 0x25 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmplt.sc.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x52, 0x73, 0x24 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmplt.sc.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xde, 0xee, 0x25 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmplt.sc.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xd5, 0xc5, 0x24 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmplt.sc.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xd4, 0x24, 0x25 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmplt.sc.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x62, 0x03, 0x24 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmplt.sci.h t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xee, 0x0e, 0x25 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmplt.sci.h t3, t4, -32" + + - + input: + bytes: [ 0x7b, 0xe5, 0x35, 0x26 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmplt.sci.h a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xe4, 0xf4, 0x27 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmplt.sci.h s0, s1, -1" + + - + input: + bytes: [ 0xfb, 0x72, 0x03, 0x24 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmplt.sci.b t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xfe, 0x0e, 0x25 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmplt.sci.b t3, t4, -32" + + - + input: + bytes: [ 0x7b, 0xf5, 0x35, 0x26 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmplt.sci.b a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xf4, 0xf4, 0x27 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmplt.sci.b s0, s1, -1" + + - + input: + bytes: [ 0xfb, 0x02, 0x73, 0x2c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmple.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x8e, 0xee, 0x2d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmple.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x85, 0xc5, 0x2c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmple.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x84, 0x24, 0x2d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmple.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x12, 0x73, 0x2c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmple.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x9e, 0xee, 0x2d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmple.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x95, 0xc5, 0x2c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmple.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x94, 0x24, 0x2d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmple.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x42, 0x73, 0x2c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmple.sc.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xce, 0xee, 0x2d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmple.sc.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xc5, 0xc5, 0x2c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmple.sc.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xc4, 0x24, 0x2d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmple.sc.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x52, 0x73, 0x2c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmple.sc.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xde, 0xee, 0x2d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmple.sc.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xd5, 0xc5, 0x2c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmple.sc.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xd4, 0x24, 0x2d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmple.sc.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x62, 0x03, 0x2c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmple.sci.h t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xee, 0x0e, 0x2d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmple.sci.h t3, t4, -32" + + - + input: + bytes: [ 0x7b, 0xe5, 0x35, 0x2e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmple.sci.h a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xe4, 0xf4, 0x2f ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmple.sci.h s0, s1, -1" + + - + input: + bytes: [ 0xfb, 0x72, 0x03, 0x2c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmple.sci.b t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xfe, 0x0e, 0x2d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmple.sci.b t3, t4, -32" + + - + input: + bytes: [ 0x7b, 0xf5, 0x35, 0x2e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmple.sci.b a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xf4, 0xf4, 0x2f ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmple.sci.b s0, s1, -1" + + - + input: + bytes: [ 0xfb, 0x02, 0x73, 0x34 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgtu.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x8e, 0xee, 0x35 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgtu.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x85, 0xc5, 0x34 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgtu.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x84, 0x24, 0x35 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgtu.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x12, 0x73, 0x34 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgtu.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x9e, 0xee, 0x35 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgtu.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x95, 0xc5, 0x34 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgtu.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x94, 0x24, 0x35 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgtu.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x42, 0x73, 0x34 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgtu.sc.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xce, 0xee, 0x35 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgtu.sc.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xc5, 0xc5, 0x34 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgtu.sc.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xc4, 0x24, 0x35 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgtu.sc.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x52, 0x73, 0x34 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgtu.sc.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xde, 0xee, 0x35 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgtu.sc.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xd5, 0xc5, 0x34 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgtu.sc.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xd4, 0x24, 0x35 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgtu.sc.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x62, 0x03, 0x34 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgtu.sci.h t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xee, 0x0e, 0x35 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgtu.sci.h t3, t4, 32" + + - + input: + bytes: [ 0x7b, 0xe5, 0x35, 0x36 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgtu.sci.h a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xe4, 0xf4, 0x37 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgtu.sci.h s0, s1, 63" + + - + input: + bytes: [ 0xfb, 0x72, 0x03, 0x34 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgtu.sci.b t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xfe, 0x0e, 0x35 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgtu.sci.b t3, t4, 32" + + - + input: + bytes: [ 0x7b, 0xf5, 0x35, 0x36 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgtu.sci.b a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xf4, 0xf4, 0x37 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgtu.sci.b s0, s1, 63" + + - + input: + bytes: [ 0xfb, 0x02, 0x73, 0x3c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgeu.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x8e, 0xee, 0x3d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgeu.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x85, 0xc5, 0x3c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgeu.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x84, 0x24, 0x3d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgeu.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x12, 0x73, 0x3c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgeu.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x9e, 0xee, 0x3d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgeu.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x95, 0xc5, 0x3c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgeu.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x94, 0x24, 0x3d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgeu.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x42, 0x73, 0x3c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgeu.sc.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xce, 0xee, 0x3d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgeu.sc.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xc5, 0xc5, 0x3c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgeu.sc.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xc4, 0x24, 0x3d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgeu.sc.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x52, 0x73, 0x3c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgeu.sc.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xde, 0xee, 0x3d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgeu.sc.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xd5, 0xc5, 0x3c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgeu.sc.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xd4, 0x24, 0x3d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgeu.sc.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x62, 0x03, 0x3c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgeu.sci.h t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xee, 0x0e, 0x3d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgeu.sci.h t3, t4, 32" + + - + input: + bytes: [ 0x7b, 0xe5, 0x35, 0x3e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgeu.sci.h a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xe4, 0xf4, 0x3f ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgeu.sci.h s0, s1, 63" + + - + input: + bytes: [ 0xfb, 0x72, 0x03, 0x3c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgeu.sci.b t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xfe, 0x0e, 0x3d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgeu.sci.b t3, t4, 32" + + - + input: + bytes: [ 0x7b, 0xf5, 0x35, 0x3e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgeu.sci.b a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xf4, 0xf4, 0x3f ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpgeu.sci.b s0, s1, 63" + + - + input: + bytes: [ 0xfb, 0x02, 0x73, 0x44 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpltu.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x8e, 0xee, 0x45 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpltu.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x85, 0xc5, 0x44 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpltu.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x84, 0x24, 0x45 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpltu.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x12, 0x73, 0x44 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpltu.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x9e, 0xee, 0x45 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpltu.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x95, 0xc5, 0x44 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpltu.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x94, 0x24, 0x45 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpltu.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x42, 0x73, 0x44 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpltu.sc.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xce, 0xee, 0x45 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpltu.sc.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xc5, 0xc5, 0x44 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpltu.sc.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xc4, 0x24, 0x45 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpltu.sc.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x52, 0x73, 0x44 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpltu.sc.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xde, 0xee, 0x45 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpltu.sc.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xd5, 0xc5, 0x44 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpltu.sc.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xd4, 0x24, 0x45 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpltu.sc.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x62, 0x03, 0x44 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpltu.sci.h t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xee, 0x0e, 0x45 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpltu.sci.h t3, t4, 32" + + - + input: + bytes: [ 0x7b, 0xe5, 0x35, 0x46 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpltu.sci.h a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xe4, 0xf4, 0x47 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpltu.sci.h s0, s1, 63" + + - + input: + bytes: [ 0xfb, 0x72, 0x03, 0x44 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpltu.sci.b t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xfe, 0x0e, 0x45 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpltu.sci.b t3, t4, 32" + + - + input: + bytes: [ 0x7b, 0xf5, 0x35, 0x46 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpltu.sci.b a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xf4, 0xf4, 0x47 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpltu.sci.b s0, s1, 63" + + - + input: + bytes: [ 0xfb, 0x02, 0x73, 0x4c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpleu.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x8e, 0xee, 0x4d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpleu.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x85, 0xc5, 0x4c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpleu.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x84, 0x24, 0x4d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpleu.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x12, 0x73, 0x4c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpleu.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x9e, 0xee, 0x4d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpleu.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x95, 0xc5, 0x4c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpleu.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x94, 0x24, 0x4d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpleu.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x42, 0x73, 0x4c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpleu.sc.h t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xce, 0xee, 0x4d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpleu.sc.h t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xc5, 0xc5, 0x4c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpleu.sc.h a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xc4, 0x24, 0x4d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpleu.sc.h s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x52, 0x73, 0x4c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpleu.sc.b t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xde, 0xee, 0x4d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpleu.sc.b t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xd5, 0xc5, 0x4c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpleu.sc.b a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xd4, 0x24, 0x4d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpleu.sc.b s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x62, 0x03, 0x4c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpleu.sci.h t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xee, 0x0e, 0x4d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpleu.sci.h t3, t4, 32" + + - + input: + bytes: [ 0x7b, 0xe5, 0x35, 0x4e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpleu.sci.h a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xe4, 0xf4, 0x4f ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpleu.sci.h s0, s1, 63" + + - + input: + bytes: [ 0xfb, 0x72, 0x03, 0x4c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpleu.sci.b t0, t1, 0" + + - + input: + bytes: [ 0x7b, 0xfe, 0x0e, 0x4d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpleu.sci.b t3, t4, 32" + + - + input: + bytes: [ 0x7b, 0xf5, 0x35, 0x4e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpleu.sci.b a0, a1, 7" + + - + input: + bytes: [ 0x7b, 0xf4, 0xf4, 0x4f ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cmpleu.sci.b s0, s1, 63" + + - + input: + bytes: [ 0xfb, 0x02, 0x73, 0x54 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cplxmul.r t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x8e, 0xee, 0x55 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cplxmul.r t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x85, 0xc5, 0x54 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cplxmul.r a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x84, 0x24, 0x55 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cplxmul.r s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x02, 0x73, 0x56 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cplxmul.i t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x8e, 0xee, 0x57 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cplxmul.i t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x85, 0xc5, 0x56 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cplxmul.i a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x84, 0x24, 0x57 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cplxmul.i s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x22, 0x73, 0x54 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cplxmul.r.div2 t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xae, 0xee, 0x55 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cplxmul.r.div2 t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xa5, 0xc5, 0x54 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cplxmul.r.div2 a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xa4, 0x24, 0x55 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cplxmul.r.div2 s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x22, 0x73, 0x56 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cplxmul.i.div2 t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xae, 0xee, 0x57 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cplxmul.i.div2 t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xa5, 0xc5, 0x56 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cplxmul.i.div2 a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xa4, 0x24, 0x57 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cplxmul.i.div2 s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x42, 0x73, 0x54 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cplxmul.r.div4 t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xce, 0xee, 0x55 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cplxmul.r.div4 t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xc5, 0xc5, 0x54 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cplxmul.r.div4 a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xc4, 0x24, 0x55 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cplxmul.r.div4 s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x42, 0x73, 0x56 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cplxmul.i.div4 t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xce, 0xee, 0x57 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cplxmul.i.div4 t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xc5, 0xc5, 0x56 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cplxmul.i.div4 a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xc4, 0x24, 0x57 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cplxmul.i.div4 s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x62, 0x73, 0x54 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cplxmul.r.div8 t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xee, 0xee, 0x55 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cplxmul.r.div8 t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xe5, 0xc5, 0x54 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cplxmul.r.div8 a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xe4, 0x24, 0x55 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cplxmul.r.div8 s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x62, 0x73, 0x56 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cplxmul.i.div8 t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xee, 0xee, 0x57 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cplxmul.i.div8 t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xe5, 0xc5, 0x56 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cplxmul.i.div8 a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xe4, 0x24, 0x57 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cplxmul.i.div8 s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x02, 0x03, 0x5c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cplxconj t0, t1" + + - + input: + bytes: [ 0x7b, 0x8e, 0x0e, 0x5c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cplxconj t3, t4" + + - + input: + bytes: [ 0x7b, 0x85, 0x05, 0x5c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cplxconj a0, a1" + + - + input: + bytes: [ 0x7b, 0x84, 0x04, 0x5c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.cplxconj s0, s1" + + - + input: + bytes: [ 0xfb, 0x02, 0x73, 0x64 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.subrotmj t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0x8e, 0xee, 0x65 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.subrotmj t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0x85, 0xc5, 0x64 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.subrotmj a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0x84, 0x24, 0x65 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.subrotmj s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x22, 0x73, 0x64 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.subrotmj.div2 t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xae, 0xee, 0x65 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.subrotmj.div2 t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xa5, 0xc5, 0x64 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.subrotmj.div2 a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xa4, 0x24, 0x65 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.subrotmj.div2 s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x42, 0x73, 0x64 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.subrotmj.div4 t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xce, 0xee, 0x65 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.subrotmj.div4 t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xc5, 0xc5, 0x64 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.subrotmj.div4 a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xc4, 0x24, 0x65 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.subrotmj.div4 s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x62, 0x73, 0x64 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.subrotmj.div8 t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xee, 0xee, 0x65 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.subrotmj.div8 t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xe5, 0xc5, 0x64 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.subrotmj.div8 a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xe4, 0x24, 0x65 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.subrotmj.div8 s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x22, 0x73, 0x6c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.add.div2 t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xae, 0xee, 0x6d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.add.div2 t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xa5, 0xc5, 0x6c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.add.div2 a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xa4, 0x24, 0x6d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.add.div2 s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x42, 0x73, 0x6c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.add.div4 t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xce, 0xee, 0x6d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.add.div4 t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xc5, 0xc5, 0x6c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.add.div4 a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xc4, 0x24, 0x6d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.add.div4 s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x62, 0x73, 0x6c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.add.div8 t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xee, 0xee, 0x6d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.add.div8 t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xe5, 0xc5, 0x6c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.add.div8 a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xe4, 0x24, 0x6d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.add.div8 s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x22, 0x73, 0x74 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sub.div2 t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xae, 0xee, 0x75 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sub.div2 t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xa5, 0xc5, 0x74 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sub.div2 a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xa4, 0x24, 0x75 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sub.div2 s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x42, 0x73, 0x74 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sub.div4 t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xce, 0xee, 0x75 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sub.div4 t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xc5, 0xc5, 0x74 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sub.div4 a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xc4, 0x24, 0x75 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sub.div4 s0, s1, s2" + + - + input: + bytes: [ 0xfb, 0x62, 0x73, 0x74 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sub.div8 t0, t1, t2" + + - + input: + bytes: [ 0x7b, 0xee, 0xee, 0x75 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sub.div8 t3, t4, t5" + + - + input: + bytes: [ 0x7b, 0xe5, 0xc5, 0x74 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sub.div8 a0, a1, a2" + + - + input: + bytes: [ 0x7b, 0xe4, 0x24, 0x75 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XCVSIMD" ] + expected: + insns: + - + asm_text: "cv.sub.div8 s0, s1, s2" diff --git a/tests/MC/RISCV/XTHeadBa_valid_riscv32_riscv_xtheadba.txt.yaml b/tests/MC/RISCV/XTHeadBa_valid_riscv32_riscv_xtheadba.txt.yaml new file mode 100644 index 0000000000..701c33b3e2 --- /dev/null +++ b/tests/MC/RISCV/XTHeadBa_valid_riscv32_riscv_xtheadba.txt.yaml @@ -0,0 +1,40 @@ +test_cases: + - + input: + bytes: [ 0x8b, 0x12, 0x73, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADBA" ] + expected: + insns: + - + asm_text: "th.addsl t0, t1, t2, 0" + + - + input: + bytes: [ 0x8b, 0x12, 0x73, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADBA" ] + expected: + insns: + - + asm_text: "th.addsl t0, t1, t2, 1" + + - + input: + bytes: [ 0x8b, 0x12, 0x73, 0x04 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADBA" ] + expected: + insns: + - + asm_text: "th.addsl t0, t1, t2, 2" + + - + input: + bytes: [ 0x8b, 0x12, 0x73, 0x06 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADBA" ] + expected: + insns: + - + asm_text: "th.addsl t0, t1, t2, 3" diff --git a/tests/MC/RISCV/XTHeadVdot_valid_riscv64_riscv_xtheadvdot.txt.yaml b/tests/MC/RISCV/XTHeadVdot_valid_riscv64_riscv_xtheadvdot.txt.yaml new file mode 100644 index 0000000000..504b8aef55 --- /dev/null +++ b/tests/MC/RISCV/XTHeadVdot_valid_riscv64_riscv_xtheadvdot.txt.yaml @@ -0,0 +1,140 @@ +test_cases: + - + input: + bytes: [ 0x0b, 0x64, 0x4a, 0x88 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADVDOT" ] + expected: + insns: + - + asm_text: "th.vmaqau.vv v8, v20, v4, v0.t" + + - + input: + bytes: [ 0x0b, 0x64, 0x4a, 0x8a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADVDOT" ] + expected: + insns: + - + asm_text: "th.vmaqau.vv v8, v20, v4" + + - + input: + bytes: [ 0x0b, 0x64, 0x45, 0x8c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADVDOT" ] + expected: + insns: + - + asm_text: "th.vmaqau.vx v8, a0, v4, v0.t" + + - + input: + bytes: [ 0x0b, 0x64, 0x45, 0x8e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADVDOT" ] + expected: + insns: + - + asm_text: "th.vmaqau.vx v8, a0, v4" + + - + input: + bytes: [ 0x0b, 0x64, 0x4a, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADVDOT" ] + expected: + insns: + - + asm_text: "th.vmaqa.vv v8, v20, v4, v0.t" + + - + input: + bytes: [ 0x0b, 0x64, 0x4a, 0x82 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADVDOT" ] + expected: + insns: + - + asm_text: "th.vmaqa.vv v8, v20, v4" + + - + input: + bytes: [ 0x0b, 0x64, 0x45, 0x84 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADVDOT" ] + expected: + insns: + - + asm_text: "th.vmaqa.vx v8, a0, v4, v0.t" + + - + input: + bytes: [ 0x0b, 0x64, 0x45, 0x86 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADVDOT" ] + expected: + insns: + - + asm_text: "th.vmaqa.vx v8, a0, v4" + + - + input: + bytes: [ 0x0b, 0x64, 0x4a, 0x90 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADVDOT" ] + expected: + insns: + - + asm_text: "th.vmaqasu.vv v8, v20, v4, v0.t" + + - + input: + bytes: [ 0x0b, 0x64, 0x4a, 0x92 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADVDOT" ] + expected: + insns: + - + asm_text: "th.vmaqasu.vv v8, v20, v4" + + - + input: + bytes: [ 0x0b, 0x64, 0x45, 0x94 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADVDOT" ] + expected: + insns: + - + asm_text: "th.vmaqasu.vx v8, a0, v4, v0.t" + + - + input: + bytes: [ 0x0b, 0x64, 0x45, 0x96 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADVDOT" ] + expected: + insns: + - + asm_text: "th.vmaqasu.vx v8, a0, v4" + + - + input: + bytes: [ 0x0b, 0x64, 0x45, 0x9c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADVDOT" ] + expected: + insns: + - + asm_text: "th.vmaqaus.vx v8, a0, v4, v0.t" + + - + input: + bytes: [ 0x0b, 0x64, 0x45, 0x9e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADVDOT" ] + expected: + insns: + - + asm_text: "th.vmaqaus.vx v8, a0, v4" diff --git a/tests/MC/RISCV/XVentanaCondOps_valid_riscv64_xventanacondops_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/XVentanaCondOps_valid_riscv64_xventanacondops_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..2afc649dbb --- /dev/null +++ b/tests/MC/RISCV/XVentanaCondOps_valid_riscv64_xventanacondops_syntax_no_alias_text.txt.yaml @@ -0,0 +1,40 @@ +test_cases: + - + input: + bytes: [ 0x7b, 0x60, 0x00, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "xventanacondops", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vt.maskc zero, zero, zero" + + - + input: + bytes: [ 0x7b, 0x70, 0x00, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "xventanacondops", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vt.maskcn zero, zero, zero" + + - + input: + bytes: [ 0xfb, 0x60, 0x31, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "xventanacondops", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vt.maskc ra, sp, gp" + + - + input: + bytes: [ 0xfb, 0x70, 0x31, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "xventanacondops", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vt.maskcn ra, sp, gp" diff --git a/tests/MC/RISCV/Zawrs_valid_riscv32_zawrs_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/Zawrs_valid_riscv32_zawrs_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..99f2df8364 --- /dev/null +++ b/tests/MC/RISCV/Zawrs_valid_riscv32_zawrs_syntax_no_alias_text.txt.yaml @@ -0,0 +1,20 @@ +test_cases: + - + input: + bytes: [ 0x73, 0x00, 0xd0, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zawrs", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "wrs.nto" + + - + input: + bytes: [ 0x73, 0x00, 0xd0, 0x01 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zawrs", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "wrs.sto" diff --git a/tests/MC/RISCV/add_riscv64_riscv_v.txt.yaml b/tests/MC/RISCV/add_riscv64_riscv_v.txt.yaml new file mode 100644 index 0000000000..3b210ffd57 --- /dev/null +++ b/tests/MC/RISCV/add_riscv64_riscv_v.txt.yaml @@ -0,0 +1,590 @@ +test_cases: + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vadd.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vadd.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vadd.vx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vadd.vx v8, v4, a0" + + - + input: + bytes: [ 0x57, 0xb4, 0x47, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vadd.vi v8, v4, 15, v0.t" + + - + input: + bytes: [ 0x57, 0xb4, 0x47, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vadd.vi v8, v4, 15" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwaddu.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0xc2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwaddu.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwaddu.vx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0xc2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwaddu.vx v8, v4, a0" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0xc4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwadd.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0xc6 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwadd.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0xc4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwadd.vx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0xc6 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwadd.vx v8, v4, a0" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0xd0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwaddu.wv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0xd2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwaddu.wv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0xd0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwaddu.wx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0xd2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwaddu.wx v8, v4, a0" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0xd4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwadd.wv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0xd6 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwadd.wv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0xd4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwadd.wx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0xd6 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwadd.wx v8, v4, a0" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vadc.vvm v8, v4, v20, v0" + + - + input: + bytes: [ 0x57, 0x02, 0x4a, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vadc.vvm v4, v4, v20, v0" + + - + input: + bytes: [ 0x57, 0x04, 0x44, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vadc.vvm v8, v4, v8, v0" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vadc.vxm v8, v4, a0, v0" + + - + input: + bytes: [ 0x57, 0xb4, 0x47, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vadc.vim v8, v4, 15, v0" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0x44 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmadc.vvm v8, v4, v20, v0" + + - + input: + bytes: [ 0x57, 0x02, 0x4a, 0x44 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmadc.vvm v4, v4, v20, v0" + + - + input: + bytes: [ 0x57, 0x04, 0x44, 0x44 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmadc.vvm v8, v4, v8, v0" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x44 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmadc.vxm v8, v4, a0, v0" + + - + input: + bytes: [ 0x57, 0xb4, 0x47, 0x44 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmadc.vim v8, v4, 15, v0" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0x46 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmadc.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x46 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmadc.vx v8, v4, a0" + + - + input: + bytes: [ 0x57, 0xb4, 0x47, 0x46 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmadc.vi v8, v4, 15" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsaddu.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0x82 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsaddu.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsaddu.vx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x82 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsaddu.vx v8, v4, a0" + + - + input: + bytes: [ 0x57, 0xb4, 0x47, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsaddu.vi v8, v4, 15, v0.t" + + - + input: + bytes: [ 0x57, 0xb4, 0x47, 0x82 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsaddu.vi v8, v4, 15" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0x84 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsadd.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0x86 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsadd.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x84 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsadd.vx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x86 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsadd.vx v8, v4, a0" + + - + input: + bytes: [ 0x57, 0xb4, 0x47, 0x84 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsadd.vi v8, v4, 15, v0.t" + + - + input: + bytes: [ 0x57, 0xb4, 0x47, 0x86 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsadd.vi v8, v4, 15" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0x24 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vaadd.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0x26 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vaadd.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0x24 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vaadd.vx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0x26 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vaadd.vx v8, v4, a0" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0x20 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vaaddu.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0x22 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vaaddu.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0x20 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vaaddu.vx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0x22 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vaaddu.vx v8, v4, a0" + + - + input: + bytes: [ 0x57, 0x64, 0x40, 0xc4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwcvt.x.x.v v8, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x64, 0x40, 0xc6 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwcvt.x.x.v v8, v4" + + - + input: + bytes: [ 0x57, 0x64, 0x40, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwcvtu.x.x.v v8, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x64, 0x40, 0xc2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwcvtu.x.x.v v8, v4" diff --git a/tests/MC/RISCV/and_riscv64_riscv_v.txt.yaml b/tests/MC/RISCV/and_riscv64_riscv_v.txt.yaml new file mode 100644 index 0000000000..53cd050f46 --- /dev/null +++ b/tests/MC/RISCV/and_riscv64_riscv_v.txt.yaml @@ -0,0 +1,60 @@ +test_cases: + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0x24 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vand.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0x26 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vand.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x24 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vand.vx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x26 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vand.vx v8, v4, a0" + + - + input: + bytes: [ 0x57, 0xb4, 0x47, 0x24 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vand.vi v8, v4, 15, v0.t" + + - + input: + bytes: [ 0x57, 0xb4, 0x47, 0x26 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vand.vi v8, v4, 15" diff --git a/tests/MC/RISCV/clip_riscv64_riscv_v.txt.yaml b/tests/MC/RISCV/clip_riscv64_riscv_v.txt.yaml new file mode 100644 index 0000000000..bb87b47279 --- /dev/null +++ b/tests/MC/RISCV/clip_riscv64_riscv_v.txt.yaml @@ -0,0 +1,120 @@ +test_cases: + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vnclipu.wv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0xba ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vnclipu.wv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vnclipu.wx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0xba ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vnclipu.wx v8, v4, a0" + + - + input: + bytes: [ 0x57, 0xb4, 0x4f, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vnclipu.wi v8, v4, 31, v0.t" + + - + input: + bytes: [ 0x57, 0xb4, 0x4f, 0xba ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vnclipu.wi v8, v4, 31" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0xbc ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vnclip.wv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0xbe ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vnclip.wv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0xbc ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vnclip.wx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0xbe ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vnclip.wx v8, v4, a0" + + - + input: + bytes: [ 0x57, 0xb4, 0x4f, 0xbc ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vnclip.wi v8, v4, 31, v0.t" + + - + input: + bytes: [ 0x57, 0xb4, 0x4f, 0xbe ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vnclip.wi v8, v4, 31" diff --git a/tests/MC/RISCV/compare_riscv64_riscv_v.txt.yaml b/tests/MC/RISCV/compare_riscv64_riscv_v.txt.yaml new file mode 100644 index 0000000000..42bb2f2fb2 --- /dev/null +++ b/tests/MC/RISCV/compare_riscv64_riscv_v.txt.yaml @@ -0,0 +1,570 @@ +test_cases: + - + input: + bytes: [ 0x57, 0x00, 0x4a, 0x6c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmslt.vv v0, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmseq.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0x62 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmseq.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmseq.vx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x62 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmseq.vx v8, v4, a0" + + - + input: + bytes: [ 0x57, 0xb4, 0x47, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmseq.vi v8, v4, 15, v0.t" + + - + input: + bytes: [ 0x57, 0xb4, 0x47, 0x62 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmseq.vi v8, v4, 15" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0x64 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmsne.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0x66 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmsne.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x64 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmsne.vx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x66 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmsne.vx v8, v4, a0" + + - + input: + bytes: [ 0x57, 0xb4, 0x47, 0x64 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmsne.vi v8, v4, 15, v0.t" + + - + input: + bytes: [ 0x57, 0xb4, 0x47, 0x66 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmsne.vi v8, v4, 15" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0x68 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmsltu.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0x6a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmsltu.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x68 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmsltu.vx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x6a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmsltu.vx v8, v4, a0" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0x6c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmslt.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0x6e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmslt.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x6c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmslt.vx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x6e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmslt.vx v8, v4, a0" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0x70 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmsleu.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0x72 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmsleu.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x70 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmsleu.vx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x72 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmsleu.vx v8, v4, a0" + + - + input: + bytes: [ 0x57, 0xb4, 0x47, 0x70 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmsleu.vi v8, v4, 15, v0.t" + + - + input: + bytes: [ 0x57, 0xb4, 0x47, 0x72 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmsleu.vi v8, v4, 15" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0x74 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmsle.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0x76 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmsle.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x74 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmsle.vx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x76 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmsle.vx v8, v4, a0" + + - + input: + bytes: [ 0x57, 0xb4, 0x47, 0x74 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmsle.vi v8, v4, 15, v0.t" + + - + input: + bytes: [ 0x57, 0xb4, 0x47, 0x76 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmsle.vi v8, v4, 15" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x78 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmsgtu.vx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x7a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmsgtu.vx v8, v4, a0" + + - + input: + bytes: [ 0x57, 0xb4, 0x47, 0x78 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmsgtu.vi v8, v4, 15, v0.t" + + - + input: + bytes: [ 0x57, 0xb4, 0x47, 0x7a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmsgtu.vi v8, v4, 15" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x7c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmsgt.vx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x7e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmsgt.vx v8, v4, a0" + + - + input: + bytes: [ 0x57, 0xb4, 0x47, 0x7c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmsgt.vi v8, v4, 15, v0.t" + + - + input: + bytes: [ 0x57, 0xb4, 0x47, 0x7e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmsgt.vi v8, v4, 15" + + - + input: + bytes: [ 0x57, 0x04, 0x42, 0x64 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmsne.vv v8, v4, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x04, 0x42, 0x66 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmsne.vv v8, v4, v4" + + - + input: + bytes: [ 0x57, 0x04, 0x42, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmseq.vv v8, v4, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x04, 0x42, 0x62 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmseq.vv v8, v4, v4" + + - + input: + bytes: [ 0x57, 0x24, 0x84, 0x76 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmnot.m v8, v8" + + - + input: + bytes: [ 0x57, 0x40, 0x45, 0x6e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmslt.vx v0, v4, a0" + + - + input: + bytes: [ 0x57, 0x20, 0x00, 0x76 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmnot.m v0, v0" + + - + input: + bytes: [ 0x57, 0x24, 0x80, 0x6e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmxor.mm v8, v8, v0" + + - + input: + bytes: [ 0x57, 0x41, 0x45, 0x6a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmsltu.vx v2, v4, a0" + + - + input: + bytes: [ 0x57, 0x20, 0x01, 0x62 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmandn.mm v0, v0, v2" + + - + input: + bytes: [ 0x57, 0x41, 0x45, 0x6e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmslt.vx v2, v4, a0" + + - + input: + bytes: [ 0x57, 0x21, 0x01, 0x62 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmandn.mm v2, v0, v2" + + - + input: + bytes: [ 0xd7, 0x24, 0x90, 0x62 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmandn.mm v9, v9, v0" + + - + input: + bytes: [ 0xd7, 0xa4, 0x24, 0x6a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmor.mm v9, v2, v9" + + - + input: + bytes: [ 0x57, 0x24, 0x80, 0x62 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmandn.mm v8, v8, v0" + + - + input: + bytes: [ 0x57, 0x24, 0x24, 0x6a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmor.mm v8, v2, v8" diff --git a/tests/MC/RISCV/compress_cjal_riscv32_riscv_c.txt.yaml b/tests/MC/RISCV/compress_cjal_riscv32_riscv_c.txt.yaml new file mode 100644 index 0000000000..5e7ee4d069 --- /dev/null +++ b/tests/MC/RISCV/compress_cjal_riscv32_riscv_c.txt.yaml @@ -0,0 +1,10 @@ +test_cases: + - + input: + bytes: [ 0xfd, 0x2f ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C" ] + expected: + insns: + - + asm_text: "jal 2046" diff --git a/tests/MC/RISCV/compress_rv32d_riscv32_riscv_c_riscv_d.txt.yaml b/tests/MC/RISCV/compress_rv32d_riscv32_riscv_c_riscv_d.txt.yaml new file mode 100644 index 0000000000..0f4e9c7c6f --- /dev/null +++ b/tests/MC/RISCV/compress_rv32d_riscv32_riscv_c_riscv_d.txt.yaml @@ -0,0 +1,40 @@ +test_cases: + - + input: + bytes: [ 0x06, 0x20 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_MODE_RISCV_D" ] + expected: + insns: + - + asm_text: "fld ft0, 64(sp)" + + - + input: + bytes: [ 0x82, 0xa0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_MODE_RISCV_D" ] + expected: + insns: + - + asm_text: "fsd ft0, 64(sp)" + + - + input: + bytes: [ 0x60, 0x3c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_MODE_RISCV_D" ] + expected: + insns: + - + asm_text: "fld fs0, 248(s0)" + + - + input: + bytes: [ 0x60, 0xbc ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_MODE_RISCV_D" ] + expected: + insns: + - + asm_text: "fsd fs0, 248(s0)" diff --git a/tests/MC/RISCV/compress_rv32f_riscv32_riscv_c_riscv_f.txt.yaml b/tests/MC/RISCV/compress_rv32f_riscv32_riscv_c_riscv_f.txt.yaml new file mode 100644 index 0000000000..b2a10c8b56 --- /dev/null +++ b/tests/MC/RISCV/compress_rv32f_riscv32_riscv_c_riscv_f.txt.yaml @@ -0,0 +1,40 @@ +test_cases: + - + input: + bytes: [ 0x76, 0x70 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "flw ft0, 124(sp)" + + - + input: + bytes: [ 0x82, 0xfe ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "fsw ft0, 124(sp)" + + - + input: + bytes: [ 0x60, 0x7c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "flw fs0, 124(s0)" + + - + input: + bytes: [ 0x60, 0xfc ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "fsw fs0, 124(s0)" diff --git a/tests/MC/RISCV/compress_rv32i_riscv32_riscv_c.txt.yaml b/tests/MC/RISCV/compress_rv32i_riscv32_riscv_c.txt.yaml new file mode 100644 index 0000000000..f6478d757e --- /dev/null +++ b/tests/MC/RISCV/compress_rv32i_riscv32_riscv_c.txt.yaml @@ -0,0 +1,290 @@ +test_cases: + - + input: + bytes: [ 0x2e, 0x85 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C" ] + expected: + insns: + - + asm_text: "mv a0, a1" + + - + input: + bytes: [ 0xe0, 0x1f ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C" ] + expected: + insns: + - + asm_text: "addi s0, sp, 1020" + + - + input: + bytes: [ 0xe0, 0x5f ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C" ] + expected: + insns: + - + asm_text: "lw s0, 124(a5)" + + - + input: + bytes: [ 0xe0, 0xdf ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C" ] + expected: + insns: + - + asm_text: "sw s0, 124(a5)" + + - + input: + bytes: [ 0x01, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C" ] + expected: + insns: + - + asm_text: "nop" + + - + input: + bytes: [ 0x81, 0x10 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C" ] + expected: + insns: + - + asm_text: "addi ra, ra, -32" + + - + input: + bytes: [ 0x85, 0x50 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C" ] + expected: + insns: + - + asm_text: "li ra, -31" + + - + input: + bytes: [ 0x39, 0x71 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C" ] + expected: + insns: + - + asm_text: "addi sp, sp, -64" + + - + input: + bytes: [ 0xfd, 0x61 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C" ] + expected: + insns: + - + asm_text: "lui gp, 31" + + - + input: + bytes: [ 0x7d, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C" ] + expected: + insns: + - + asm_text: "srli s0, s0, 31" + + - + input: + bytes: [ 0x7d, 0x84 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C" ] + expected: + insns: + - + asm_text: "srai s0, s0, 31" + + - + input: + bytes: [ 0x7d, 0x88 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C" ] + expected: + insns: + - + asm_text: "andi s0, s0, 31" + + - + input: + bytes: [ 0x1d, 0x8c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C" ] + expected: + insns: + - + asm_text: "sub s0, s0, a5" + + - + input: + bytes: [ 0x3d, 0x8c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C" ] + expected: + insns: + - + asm_text: "xor s0, s0, a5" + + - + input: + bytes: [ 0x5d, 0x8c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C" ] + expected: + insns: + - + asm_text: "or s0, s0, a5" + + - + input: + bytes: [ 0x45, 0x8c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C" ] + expected: + insns: + - + asm_text: "or s0, s0, s1" + + - + input: + bytes: [ 0x7d, 0x8c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C" ] + expected: + insns: + - + asm_text: "and s0, s0, a5" + + - + input: + bytes: [ 0x01, 0xb0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C" ] + expected: + insns: + - + asm_text: "j -2048" + + - + input: + bytes: [ 0x01, 0xd0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C" ] + expected: + insns: + - + asm_text: "beqz s0, -256" + + - + input: + bytes: [ 0x7d, 0xec ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C" ] + expected: + insns: + - + asm_text: "bnez s0, 254" + + - + input: + bytes: [ 0x7e, 0x04 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C" ] + expected: + insns: + - + asm_text: "slli s0, s0, 31" + + - + input: + bytes: [ 0xfe, 0x50 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C" ] + expected: + insns: + - + asm_text: "lw ra, 252(sp)" + + - + input: + bytes: [ 0x82, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C" ] + expected: + insns: + - + asm_text: "ret" + + - + input: + bytes: [ 0x92, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C" ] + expected: + insns: + - + asm_text: "mv ra, tp" + + - + input: + bytes: [ 0x02, 0x90 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C" ] + expected: + insns: + - + asm_text: "ebreak" + + - + input: + bytes: [ 0x02, 0x94 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C" ] + expected: + insns: + - + asm_text: "jalr s0" + + - + input: + bytes: [ 0x3e, 0x94 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C" ] + expected: + insns: + - + asm_text: "add s0, s0, a5" + + - + input: + bytes: [ 0x82, 0xdf ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C" ] + expected: + insns: + - + asm_text: "sw zero, 252(sp)" + + - + input: + bytes: [ 0x00, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C" ] + expected: + insns: + - + asm_text: "unimp" diff --git a/tests/MC/RISCV/compress_rv64i_riscv64_riscv_c.txt.yaml b/tests/MC/RISCV/compress_rv64i_riscv64_riscv_c.txt.yaml new file mode 100644 index 0000000000..cfe0af2396 --- /dev/null +++ b/tests/MC/RISCV/compress_rv64i_riscv64_riscv_c.txt.yaml @@ -0,0 +1,70 @@ +test_cases: + - + input: + bytes: [ 0xe0, 0x7f ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_C" ] + expected: + insns: + - + asm_text: "ld s0, 248(a5)" + + - + input: + bytes: [ 0xa0, 0xe3 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_C" ] + expected: + insns: + - + asm_text: "sd s0, 64(a5)" + + - + input: + bytes: [ 0x7d, 0x22 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_C" ] + expected: + insns: + - + asm_text: "addiw tp, tp, 31" + + - + input: + bytes: [ 0x1d, 0x9c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_C" ] + expected: + insns: + - + asm_text: "subw s0, s0, a5" + + - + input: + bytes: [ 0x3d, 0x9c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_C" ] + expected: + insns: + - + asm_text: "addw s0, s0, a5" + + - + input: + bytes: [ 0xee, 0x70 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_C" ] + expected: + insns: + - + asm_text: "ld ra, 248(sp)" + + - + input: + bytes: [ 0xa2, 0xe0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_C" ] + expected: + insns: + - + asm_text: "sd s0, 64(sp)" diff --git a/tests/MC/RISCV/compressed_zicfiss_riscv32_riscv_experimental_zicfiss__experimental_zcmop_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/compressed_zicfiss_riscv32_riscv_experimental_zicfiss__experimental_zcmop_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..5c66f6bb49 --- /dev/null +++ b/tests/MC/RISCV/compressed_zicfiss_riscv32_riscv_experimental_zicfiss__experimental_zcmop_syntax_no_alias_text.txt.yaml @@ -0,0 +1,20 @@ +test_cases: + - + input: + bytes: [ 0x81, 0x62 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_EXPERIMENTAL_ZICFISS", "+experimental-zcmop", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.sspopchk t0" + + - + input: + bytes: [ 0x81, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_EXPERIMENTAL_ZICFISS", "+experimental-zcmop", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.sspush ra" diff --git a/tests/MC/RISCV/convert_riscv64_riscv_v_riscv_f.txt.yaml b/tests/MC/RISCV/convert_riscv64_riscv_v_riscv_f.txt.yaml new file mode 100644 index 0000000000..b92e5832fb --- /dev/null +++ b/tests/MC/RISCV/convert_riscv64_riscv_v_riscv_f.txt.yaml @@ -0,0 +1,430 @@ +test_cases: + - + input: + bytes: [ 0x57, 0x14, 0x40, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfcvt.xu.f.v v8, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x14, 0x40, 0x4a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfcvt.xu.f.v v8, v4" + + - + input: + bytes: [ 0x57, 0x94, 0x40, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfcvt.x.f.v v8, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x94, 0x40, 0x4a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfcvt.x.f.v v8, v4" + + - + input: + bytes: [ 0x57, 0x14, 0x41, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfcvt.f.xu.v v8, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x14, 0x41, 0x4a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfcvt.f.xu.v v8, v4" + + - + input: + bytes: [ 0x57, 0x94, 0x41, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfcvt.f.x.v v8, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x94, 0x41, 0x4a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfcvt.f.x.v v8, v4" + + - + input: + bytes: [ 0x57, 0x14, 0x43, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfcvt.rtz.xu.f.v v8, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x14, 0x43, 0x4a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfcvt.rtz.xu.f.v v8, v4" + + - + input: + bytes: [ 0x57, 0x94, 0x43, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfcvt.rtz.x.f.v v8, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x94, 0x43, 0x4a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfcvt.rtz.x.f.v v8, v4" + + - + input: + bytes: [ 0x57, 0x14, 0x44, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfwcvt.xu.f.v v8, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x14, 0x44, 0x4a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfwcvt.xu.f.v v8, v4" + + - + input: + bytes: [ 0x57, 0x94, 0x44, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfwcvt.x.f.v v8, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x94, 0x44, 0x4a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfwcvt.x.f.v v8, v4" + + - + input: + bytes: [ 0x57, 0x14, 0x45, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfwcvt.f.xu.v v8, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x14, 0x45, 0x4a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfwcvt.f.xu.v v8, v4" + + - + input: + bytes: [ 0x57, 0x94, 0x45, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfwcvt.f.x.v v8, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x94, 0x45, 0x4a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfwcvt.f.x.v v8, v4" + + - + input: + bytes: [ 0x57, 0x14, 0x46, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfwcvt.f.f.v v8, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x14, 0x46, 0x4a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfwcvt.f.f.v v8, v4" + + - + input: + bytes: [ 0x57, 0x14, 0x47, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfwcvt.rtz.xu.f.v v8, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x14, 0x47, 0x4a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfwcvt.rtz.xu.f.v v8, v4" + + - + input: + bytes: [ 0x57, 0x94, 0x47, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfwcvt.rtz.x.f.v v8, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x94, 0x47, 0x4a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfwcvt.rtz.x.f.v v8, v4" + + - + input: + bytes: [ 0x57, 0x14, 0x48, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfncvt.xu.f.w v8, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x12, 0x48, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfncvt.xu.f.w v4, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x14, 0x48, 0x4a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfncvt.xu.f.w v8, v4" + + - + input: + bytes: [ 0x57, 0x94, 0x48, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfncvt.x.f.w v8, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x94, 0x48, 0x4a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfncvt.x.f.w v8, v4" + + - + input: + bytes: [ 0x57, 0x14, 0x49, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfncvt.f.xu.w v8, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x14, 0x49, 0x4a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfncvt.f.xu.w v8, v4" + + - + input: + bytes: [ 0x57, 0x94, 0x49, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfncvt.f.x.w v8, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x94, 0x49, 0x4a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfncvt.f.x.w v8, v4" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfncvt.f.f.w v8, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0x4a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfncvt.f.f.w v8, v4" + + - + input: + bytes: [ 0x57, 0x94, 0x4a, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfncvt.rod.f.f.w v8, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x94, 0x4a, 0x4a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfncvt.rod.f.f.w v8, v4" + + - + input: + bytes: [ 0x57, 0x14, 0x4b, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfncvt.rtz.xu.f.w v8, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x14, 0x4b, 0x4a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfncvt.rtz.xu.f.w v8, v4" + + - + input: + bytes: [ 0x57, 0x94, 0x4b, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfncvt.rtz.x.f.w v8, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x94, 0x4b, 0x4a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfncvt.rtz.x.f.w v8, v4" diff --git a/tests/MC/RISCV/debug_valid_riscv32_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/debug_valid_riscv32_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..d7ffb8c3c3 --- /dev/null +++ b/tests/MC/RISCV/debug_valid_riscv32_syntax_no_alias_text.txt.yaml @@ -0,0 +1,10 @@ +test_cases: + - + input: + bytes: [ 0x73, 0x00, 0x20, 0x7b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "dret" diff --git a/tests/MC/RISCV/deprecated_csr_names_riscv32_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/deprecated_csr_names_riscv32_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..3e53c28ba4 --- /dev/null +++ b/tests/MC/RISCV/deprecated_csr_names_riscv32_syntax_no_alias_text.txt.yaml @@ -0,0 +1,30 @@ +test_cases: + - + input: + bytes: [ 0x73, 0x10, 0x30, 0x14 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrw zero, stval, zero" + + - + input: + bytes: [ 0x73, 0x10, 0x30, 0x34 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrw zero, mtval, zero" + + - + input: + bytes: [ 0x73, 0x10, 0x00, 0x18 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrw zero, satp, zero" diff --git a/tests/MC/RISCV/div_riscv64_riscv_v.txt.yaml b/tests/MC/RISCV/div_riscv64_riscv_v.txt.yaml new file mode 100644 index 0000000000..5b1008f695 --- /dev/null +++ b/tests/MC/RISCV/div_riscv64_riscv_v.txt.yaml @@ -0,0 +1,160 @@ +test_cases: + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vdivu.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0x82 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vdivu.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vdivu.vx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0x82 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vdivu.vx v8, v4, a0" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0x84 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vdiv.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0x86 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vdiv.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0x84 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vdiv.vx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0x86 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vdiv.vx v8, v4, a0" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0x88 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vremu.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0x8a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vremu.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0x88 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vremu.vx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0x8a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vremu.vx v8, v4, a0" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0x8c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vrem.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0x8e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vrem.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0x8c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vrem.vx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0x8e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vrem.vx v8, v4, a0" diff --git a/tests/MC/RISCV/ext_riscv64_riscv_v.txt.yaml b/tests/MC/RISCV/ext_riscv64_riscv_v.txt.yaml new file mode 100644 index 0000000000..33320d1991 --- /dev/null +++ b/tests/MC/RISCV/ext_riscv64_riscv_v.txt.yaml @@ -0,0 +1,120 @@ +test_cases: + - + input: + bytes: [ 0x57, 0x24, 0x43, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vzext.vf2 v8, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x24, 0x43, 0x4a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vzext.vf2 v8, v4" + + - + input: + bytes: [ 0x57, 0xa4, 0x43, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsext.vf2 v8, v4, v0.t" + + - + input: + bytes: [ 0x57, 0xa4, 0x43, 0x4a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsext.vf2 v8, v4" + + - + input: + bytes: [ 0x57, 0x24, 0x42, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vzext.vf4 v8, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x24, 0x42, 0x4a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vzext.vf4 v8, v4" + + - + input: + bytes: [ 0x57, 0xa4, 0x42, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsext.vf4 v8, v4, v0.t" + + - + input: + bytes: [ 0x57, 0xa4, 0x42, 0x4a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsext.vf4 v8, v4" + + - + input: + bytes: [ 0x57, 0x24, 0x41, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vzext.vf8 v8, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x24, 0x41, 0x4a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vzext.vf8 v8, v4" + + - + input: + bytes: [ 0x57, 0xa4, 0x41, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsext.vf8 v8, v4, v0.t" + + - + input: + bytes: [ 0x57, 0xa4, 0x41, 0x4a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsext.vf8 v8, v4" diff --git a/tests/MC/RISCV/fadd_riscv64_riscv_v_riscv_f.txt.yaml b/tests/MC/RISCV/fadd_riscv64_riscv_v_riscv_f.txt.yaml new file mode 100644 index 0000000000..de27c76895 --- /dev/null +++ b/tests/MC/RISCV/fadd_riscv64_riscv_v_riscv_f.txt.yaml @@ -0,0 +1,120 @@ +test_cases: + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfadd.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfadd.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfadd.vf v8, v4, fa0, v0.t" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfadd.vf v8, v4, fa0" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfwadd.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0xc2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfwadd.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfwadd.vf v8, v4, fa0, v0.t" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0xc2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfwadd.vf v8, v4, fa0" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0xd0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfwadd.wv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0xd2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfwadd.wv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0xd0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfwadd.wf v8, v4, fa0, v0.t" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0xd2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfwadd.wf v8, v4, fa0" diff --git a/tests/MC/RISCV/fcompare_riscv64_riscv_v_riscv_f.txt.yaml b/tests/MC/RISCV/fcompare_riscv64_riscv_v_riscv_f.txt.yaml new file mode 100644 index 0000000000..2d6ca269e6 --- /dev/null +++ b/tests/MC/RISCV/fcompare_riscv64_riscv_v_riscv_f.txt.yaml @@ -0,0 +1,210 @@ +test_cases: + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vmfeq.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0x62 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vmfeq.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vmfeq.vf v8, v4, fa0, v0.t" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0x62 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vmfeq.vf v8, v4, fa0" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0x70 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vmfne.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0x72 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vmfne.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0x70 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vmfne.vf v8, v4, fa0, v0.t" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0x72 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vmfne.vf v8, v4, fa0" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0x6c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vmflt.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0x6e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vmflt.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0x6c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vmflt.vf v8, v4, fa0, v0.t" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0x6e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vmflt.vf v8, v4, fa0" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0x64 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vmfle.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0x66 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vmfle.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0x64 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vmfle.vf v8, v4, fa0, v0.t" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0x66 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vmfle.vf v8, v4, fa0" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0x74 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vmfgt.vf v8, v4, fa0, v0.t" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0x76 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vmfgt.vf v8, v4, fa0" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0x7c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vmfge.vf v8, v4, fa0, v0.t" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0x7e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vmfge.vf v8, v4, fa0" + + - + input: + bytes: [ 0x57, 0x10, 0x4a, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vmfeq.vv v0, v4, v20, v0.t" diff --git a/tests/MC/RISCV/fdiv_riscv64_riscv_v_riscv_f.txt.yaml b/tests/MC/RISCV/fdiv_riscv64_riscv_v_riscv_f.txt.yaml new file mode 100644 index 0000000000..c2975036e5 --- /dev/null +++ b/tests/MC/RISCV/fdiv_riscv64_riscv_v_riscv_f.txt.yaml @@ -0,0 +1,60 @@ +test_cases: + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfdiv.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0x82 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfdiv.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfdiv.vf v8, v4, fa0, v0.t" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0x82 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfdiv.vf v8, v4, fa0" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0x84 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfrdiv.vf v8, v4, fa0, v0.t" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0x86 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfrdiv.vf v8, v4, fa0" diff --git a/tests/MC/RISCV/fixups_compressed_riscv32_riscv_c.txt.yaml b/tests/MC/RISCV/fixups_compressed_riscv32_riscv_c.txt.yaml new file mode 100644 index 0000000000..4ba46685f1 --- /dev/null +++ b/tests/MC/RISCV/fixups_compressed_riscv32_riscv_c.txt.yaml @@ -0,0 +1,10 @@ +test_cases: + - + input: + bytes: [ 0x01, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C" ] + expected: + insns: + - + asm_text: "nop" diff --git a/tests/MC/RISCV/fixups_riscv32_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/fixups_riscv32_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..3fd1b77bf8 --- /dev/null +++ b/tests/MC/RISCV/fixups_riscv32_syntax_no_alias_text.txt.yaml @@ -0,0 +1,10 @@ +test_cases: + - + input: + bytes: [ 0x13, 0x00, 0x00, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "addi zero, zero, 0" diff --git a/tests/MC/RISCV/fmacc_riscv64_riscv_v_riscv_f.txt.yaml b/tests/MC/RISCV/fmacc_riscv64_riscv_v_riscv_f.txt.yaml new file mode 100644 index 0000000000..aa61b24a74 --- /dev/null +++ b/tests/MC/RISCV/fmacc_riscv64_riscv_v_riscv_f.txt.yaml @@ -0,0 +1,480 @@ +test_cases: + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0xb0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfmacc.vv v8, v20, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0xb2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfmacc.vv v8, v20, v4" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0xb0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfmacc.vf v8, fa0, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0xb2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfmacc.vf v8, fa0, v4" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0xb4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfnmacc.vv v8, v20, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0xb6 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfnmacc.vv v8, v20, v4" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0xb4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfnmacc.vf v8, fa0, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0xb6 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfnmacc.vf v8, fa0, v4" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfmsac.vv v8, v20, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0xba ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfmsac.vv v8, v20, v4" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfmsac.vf v8, fa0, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0xba ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfmsac.vf v8, fa0, v4" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0xbc ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfnmsac.vv v8, v20, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0xbe ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfnmsac.vv v8, v20, v4" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0xbc ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfnmsac.vf v8, fa0, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0xbe ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfnmsac.vf v8, fa0, v4" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0xa0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfmadd.vv v8, v20, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0xa2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfmadd.vv v8, v20, v4" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0xa0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfmadd.vf v8, fa0, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0xa2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfmadd.vf v8, fa0, v4" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0xa4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfnmadd.vv v8, v20, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0xa6 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfnmadd.vv v8, v20, v4" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0xa4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfnmadd.vf v8, fa0, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0xa6 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfnmadd.vf v8, fa0, v4" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0xa8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfmsub.vv v8, v20, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0xaa ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfmsub.vv v8, v20, v4" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0xa8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfmsub.vf v8, fa0, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0xaa ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfmsub.vf v8, fa0, v4" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0xac ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfnmsub.vv v8, v20, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0xae ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfnmsub.vv v8, v20, v4" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0xac ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfnmsub.vf v8, fa0, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0xae ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfnmsub.vf v8, fa0, v4" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0xf0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfwmacc.vv v8, v20, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0xf2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfwmacc.vv v8, v20, v4" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0xf0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfwmacc.vf v8, fa0, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0xf2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfwmacc.vf v8, fa0, v4" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0xf4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfwnmacc.vv v8, v20, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0xf6 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfwnmacc.vv v8, v20, v4" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0xf4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfwnmacc.vf v8, fa0, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0xf6 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfwnmacc.vf v8, fa0, v4" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0xf8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfwmsac.vv v8, v20, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0xfa ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfwmsac.vv v8, v20, v4" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0xf8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfwmsac.vf v8, fa0, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0xfa ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfwmsac.vf v8, fa0, v4" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0xfc ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfwnmsac.vv v8, v20, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0xfe ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfwnmsac.vv v8, v20, v4" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0xfc ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfwnmsac.vf v8, fa0, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0xfe ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfwnmsac.vf v8, fa0, v4" diff --git a/tests/MC/RISCV/fminmax_riscv64_riscv_v_riscv_f.txt.yaml b/tests/MC/RISCV/fminmax_riscv64_riscv_v_riscv_f.txt.yaml new file mode 100644 index 0000000000..1136d05177 --- /dev/null +++ b/tests/MC/RISCV/fminmax_riscv64_riscv_v_riscv_f.txt.yaml @@ -0,0 +1,80 @@ +test_cases: + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0x10 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfmin.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0x12 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfmin.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0x10 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfmin.vf v8, v4, fa0, v0.t" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0x12 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfmin.vf v8, v4, fa0" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0x18 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfmax.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0x1a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfmax.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0x18 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfmax.vf v8, v4, fa0, v0.t" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0x1a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfmax.vf v8, v4, fa0" diff --git a/tests/MC/RISCV/fmul_riscv64_riscv_v_riscv_f.txt.yaml b/tests/MC/RISCV/fmul_riscv64_riscv_v_riscv_f.txt.yaml new file mode 100644 index 0000000000..9dda29f7ee --- /dev/null +++ b/tests/MC/RISCV/fmul_riscv64_riscv_v_riscv_f.txt.yaml @@ -0,0 +1,80 @@ +test_cases: + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0x90 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfmul.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0x92 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfmul.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0x90 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfmul.vf v8, v4, fa0, v0.t" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0x92 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfmul.vf v8, v4, fa0" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0xe0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfwmul.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0xe2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfwmul.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0xe0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfwmul.vf v8, v4, fa0, v0.t" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0xe2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfwmul.vf v8, v4, fa0" diff --git a/tests/MC/RISCV/fmv_riscv64_riscv_v_riscv_f.txt.yaml b/tests/MC/RISCV/fmv_riscv64_riscv_v_riscv_f.txt.yaml new file mode 100644 index 0000000000..c9c1f20d2b --- /dev/null +++ b/tests/MC/RISCV/fmv_riscv64_riscv_v_riscv_f.txt.yaml @@ -0,0 +1,30 @@ +test_cases: + - + input: + bytes: [ 0x57, 0x54, 0x05, 0x5e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfmv.v.f v8, fa0" + + - + input: + bytes: [ 0x57, 0x15, 0x40, 0x42 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfmv.f.s fa0, v4" + + - + input: + bytes: [ 0x57, 0x54, 0x05, 0x42 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfmv.s.f v8, fa0" diff --git a/tests/MC/RISCV/fothers_riscv64_riscv_v_riscv_f_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/fothers_riscv64_riscv_v_riscv_f_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..e04ff4d279 --- /dev/null +++ b/tests/MC/RISCV/fothers_riscv64_riscv_v_riscv_f_syntax_no_alias_text.txt.yaml @@ -0,0 +1,130 @@ +test_cases: + - + input: + bytes: [ 0x57, 0x14, 0x40, 0x4c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vfsqrt.v v8, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x14, 0x40, 0x4e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vfsqrt.v v8, v4" + + - + input: + bytes: [ 0x57, 0x14, 0x42, 0x4c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vfrsqrt7.v v8, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x14, 0x42, 0x4e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vfrsqrt7.v v8, v4" + + - + input: + bytes: [ 0x57, 0x94, 0x42, 0x4c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vfrec7.v v8, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x94, 0x42, 0x4e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vfrec7.v v8, v4" + + - + input: + bytes: [ 0x57, 0x14, 0x48, 0x4c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vfclass.v v8, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x14, 0x48, 0x4e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vfclass.v v8, v4" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0x5c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vfmerge.vfm v8, v4, fa0, v0" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0x38 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vfslide1up.vf v8, v4, fa0, v0.t" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0x3a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vfslide1up.vf v8, v4, fa0" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0x3c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vfslide1down.vf v8, v4, fa0, v0.t" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0x3e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vfslide1down.vf v8, v4, fa0" diff --git a/tests/MC/RISCV/freduction_riscv64_riscv_v_riscv_f_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/freduction_riscv64_riscv_v_riscv_f_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..3295cc40da --- /dev/null +++ b/tests/MC/RISCV/freduction_riscv64_riscv_v_riscv_f_syntax_no_alias_text.txt.yaml @@ -0,0 +1,130 @@ +test_cases: + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0x0c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vfredosum.vs v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0x0e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vfredosum.vs v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0x04 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vfredusum.vs v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0x06 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vfredusum.vs v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0x1c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vfredmax.vs v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0x1e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vfredmax.vs v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0x14 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vfredmin.vs v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0x16 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vfredmin.vs v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0xcc ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vfwredosum.vs v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0xce ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vfwredosum.vs v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0xc4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vfwredusum.vs v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0xc6 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vfwredusum.vs v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x10, 0x4a, 0x0c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vfredosum.vs v0, v4, v20, v0.t" diff --git a/tests/MC/RISCV/fsub_riscv64_riscv_v_riscv_f.txt.yaml b/tests/MC/RISCV/fsub_riscv64_riscv_v_riscv_f.txt.yaml new file mode 100644 index 0000000000..d3922c4025 --- /dev/null +++ b/tests/MC/RISCV/fsub_riscv64_riscv_v_riscv_f.txt.yaml @@ -0,0 +1,140 @@ +test_cases: + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0x08 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfsub.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0x0a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfsub.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0x08 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfsub.vf v8, v4, fa0, v0.t" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0x0a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfsub.vf v8, v4, fa0" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0x9c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfrsub.vf v8, v4, fa0, v0.t" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0x9e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfrsub.vf v8, v4, fa0" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfwsub.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0xca ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfwsub.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfwsub.vf v8, v4, fa0, v0.t" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0xca ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfwsub.vf v8, v4, fa0" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0xd8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfwsub.wv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0xda ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfwsub.wv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0xd8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfwsub.wf v8, v4, fa0, v0.t" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0xda ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfwsub.wf v8, v4, fa0" diff --git a/tests/MC/RISCV/hypervisor_csr_names_riscv32_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/hypervisor_csr_names_riscv32_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..4722a26e0c --- /dev/null +++ b/tests/MC/RISCV/hypervisor_csr_names_riscv32_syntax_no_alias_text.txt.yaml @@ -0,0 +1,740 @@ +test_cases: + - + input: + bytes: [ 0x73, 0x23, 0x00, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hstatus, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x00, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hstatus, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x20, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hedeleg, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x20, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hedeleg, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x30, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hideleg, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x30, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hideleg, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x40, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hie, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x40, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hie, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x60, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hcounteren, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x60, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hcounteren, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x70, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hgeie, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x70, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hgeie, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x30, 0x64 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, htval, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x30, 0x64 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, htval, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x40, 0x64 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hip, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x40, 0x64 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hip, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x50, 0x64 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hvip, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x50, 0x64 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hvip, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xa0, 0x64 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, htinst, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xa0, 0x64 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, htinst, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x20, 0xe1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hgeip, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x20, 0xe1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hgeip, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xa0, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, henvcfg, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xa0, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, henvcfg, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x00, 0x68 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hgatp, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x00, 0x68 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hgatp, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x80, 0x6a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hcontext, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x80, 0x6a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hcontext, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x50, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, htimedelta, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x50, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, htimedelta, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x00, 0x20 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, vsstatus, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x00, 0x20 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, vsstatus, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x40, 0x20 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, vsie, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x40, 0x20 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, vsie, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x50, 0x20 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, vstvec, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x50, 0x20 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, vstvec, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x00, 0x24 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, vsscratch, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x00, 0x24 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, vsscratch, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x10, 0x24 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, vsepc, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x10, 0x24 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, vsepc, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x20, 0x24 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, vscause, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x20, 0x24 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, vscause, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x30, 0x24 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, vstval, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x30, 0x24 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, vstval, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x40, 0x24 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, vsip, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x40, 0x24 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, vsip, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xd0, 0x24 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, vstimecmp, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xd0, 0x24 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, vstimecmp, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x00, 0x28 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, vsatp, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x00, 0x28 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, vsatp, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xc0, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hstateen0, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xc0, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hstateen0, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xd0, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hstateen1, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xd0, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hstateen1, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xe0, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hstateen2, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xe0, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hstateen2, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xf0, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hstateen3, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xf0, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hstateen3, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x80, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hvien, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x80, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hvien, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x90, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hvictl, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x90, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hvictl, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x60, 0x64 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hviprio1, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x60, 0x64 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hviprio1, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x70, 0x64 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hviprio2, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x70, 0x64 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hviprio2, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x00, 0x25 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, vsiselect, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x00, 0x25 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, vsiselect, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x10, 0x25 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, vsireg, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x10, 0x25 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, vsireg, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xc0, 0x25 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, vstopei, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xc0, 0x25 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, vstopei, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x00, 0xeb ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, vstopi, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x00, 0xeb ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, vstopi, zero" diff --git a/tests/MC/RISCV/insn-riscv32.s.yaml b/tests/MC/RISCV/insn-riscv32.s.yaml index b425cea48c..587276ef99 100644 --- a/tests/MC/RISCV/insn-riscv32.s.yaml +++ b/tests/MC/RISCV/insn-riscv32.s.yaml @@ -21,7 +21,7 @@ test_cases: input: bytes: [ 0x2f, 0xae, 0xaa, 0x0a ] arch: "CS_ARCH_RISCV" - options: [ "CS_MODE_RISCV32" ] + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_A" ] expected: insns: - diff --git a/tests/MC/RISCV/insn-riscv64.s.yaml b/tests/MC/RISCV/insn-riscv64.s.yaml index 9fdbb19363..451cc7a1f7 100644 --- a/tests/MC/RISCV/insn-riscv64.s.yaml +++ b/tests/MC/RISCV/insn-riscv64.s.yaml @@ -21,7 +21,7 @@ test_cases: input: bytes: [ 0x2f, 0xbe, 0xaa, 0x0a ] arch: "CS_ARCH_RISCV" - options: [ "CS_MODE_RISCV64" ] + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_A" ] expected: insns: - diff --git a/tests/MC/RISCV/load_riscv64_riscv_v_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/load_riscv64_riscv_v_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..c14f8f319f --- /dev/null +++ b/tests/MC/RISCV/load_riscv64_riscv_v_syntax_no_alias_text.txt.yaml @@ -0,0 +1,580 @@ +test_cases: + - + input: + bytes: [ 0x07, 0x00, 0xb5, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlm.v v0, (a0)" + + - + input: + bytes: [ 0x07, 0x04, 0xb5, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlm.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x04, 0x05, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vle8.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x04, 0x05, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vle8.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x54, 0x05, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vle16.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x54, 0x05, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vle16.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x64, 0x05, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vle32.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x64, 0x05, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vle32.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x74, 0x05, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vle64.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x74, 0x05, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vle64.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x04, 0x05, 0x01 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vle8ff.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x04, 0x05, 0x03 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vle8ff.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x54, 0x05, 0x01 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vle16ff.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x54, 0x05, 0x03 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vle16ff.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x64, 0x05, 0x01 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vle32ff.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x64, 0x05, 0x03 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vle32ff.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x74, 0x05, 0x01 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vle64ff.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x74, 0x05, 0x03 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vle64ff.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x04, 0xb5, 0x08 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlse8.v v8, (a0), a1, v0.t" + + - + input: + bytes: [ 0x07, 0x04, 0xb5, 0x0a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlse8.v v8, (a0), a1" + + - + input: + bytes: [ 0x07, 0x54, 0xb5, 0x08 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlse16.v v8, (a0), a1, v0.t" + + - + input: + bytes: [ 0x07, 0x54, 0xb5, 0x0a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlse16.v v8, (a0), a1" + + - + input: + bytes: [ 0x07, 0x64, 0xb5, 0x08 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlse32.v v8, (a0), a1, v0.t" + + - + input: + bytes: [ 0x07, 0x64, 0xb5, 0x0a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlse32.v v8, (a0), a1" + + - + input: + bytes: [ 0x07, 0x74, 0xb5, 0x08 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlse64.v v8, (a0), a1, v0.t" + + - + input: + bytes: [ 0x07, 0x74, 0xb5, 0x0a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlse64.v v8, (a0), a1" + + - + input: + bytes: [ 0x07, 0x04, 0x45, 0x04 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxei8.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x04, 0x45, 0x06 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxei8.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x54, 0x45, 0x04 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxei16.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x54, 0x45, 0x06 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxei16.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x64, 0x45, 0x04 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxei32.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x64, 0x45, 0x06 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxei32.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x74, 0x45, 0x04 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxei64.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x74, 0x45, 0x06 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxei64.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x04, 0x45, 0x0c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxei8.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x04, 0x45, 0x0e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxei8.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x54, 0x45, 0x0c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxei16.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x54, 0x45, 0x0e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxei16.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x64, 0x45, 0x0c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxei32.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x64, 0x45, 0x0e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxei32.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x74, 0x45, 0x0c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxei64.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x74, 0x45, 0x0e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxei64.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x04, 0x85, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vl1re8.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x54, 0x85, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vl1re16.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x64, 0x85, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vl1re32.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x74, 0x85, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vl1re64.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x04, 0x85, 0x22 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vl2re8.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x54, 0x85, 0x22 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vl2re16.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x64, 0x85, 0x22 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vl2re32.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x74, 0x85, 0x22 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vl2re64.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x04, 0x85, 0x62 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vl4re8.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x54, 0x85, 0x62 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vl4re16.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x64, 0x85, 0x62 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vl4re32.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x74, 0x85, 0x62 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vl4re64.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x04, 0x85, 0xe2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vl8re8.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x54, 0x85, 0xe2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vl8re16.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x64, 0x85, 0xe2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vl8re32.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x74, 0x85, 0xe2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vl8re64.v v8, (a0)" diff --git a/tests/MC/RISCV/macc_riscv64_riscv_v.txt.yaml b/tests/MC/RISCV/macc_riscv64_riscv_v.txt.yaml new file mode 100644 index 0000000000..bbf9967790 --- /dev/null +++ b/tests/MC/RISCV/macc_riscv64_riscv_v.txt.yaml @@ -0,0 +1,300 @@ +test_cases: + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0xb4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmacc.vv v8, v20, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0xb6 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmacc.vv v8, v20, v4" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0xb4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmacc.vx v8, a0, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0xb6 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmacc.vx v8, a0, v4" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0xbc ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vnmsac.vv v8, v20, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0xbe ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vnmsac.vv v8, v20, v4" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0xbc ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vnmsac.vx v8, a0, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0xbe ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vnmsac.vx v8, a0, v4" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0xa4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmadd.vv v8, v20, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0xa6 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmadd.vv v8, v20, v4" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0xa4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmadd.vx v8, a0, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0xa6 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmadd.vx v8, a0, v4" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0xac ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vnmsub.vv v8, v20, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0xae ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vnmsub.vv v8, v20, v4" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0xac ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vnmsub.vx v8, a0, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0xae ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vnmsub.vx v8, a0, v4" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0xf0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwmaccu.vv v8, v20, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0xf2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwmaccu.vv v8, v20, v4" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0xf0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwmaccu.vx v8, a0, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0xf2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwmaccu.vx v8, a0, v4" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0xf4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwmacc.vv v8, v20, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0xf6 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwmacc.vv v8, v20, v4" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0xf4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwmacc.vx v8, a0, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0xf6 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwmacc.vx v8, a0, v4" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0xfc ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwmaccsu.vv v8, v20, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0xfe ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwmaccsu.vv v8, v20, v4" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0xfc ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwmaccsu.vx v8, a0, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0xfe ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwmaccsu.vx v8, a0, v4" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0xf8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwmaccus.vx v8, a0, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0xfa ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwmaccus.vx v8, a0, v4" diff --git a/tests/MC/RISCV/machine_csr_names_riscv32_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/machine_csr_names_riscv32_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..9cc6de2e9b --- /dev/null +++ b/tests/MC/RISCV/machine_csr_names_riscv32_syntax_no_alias_text.txt.yaml @@ -0,0 +1,3460 @@ +test_cases: + - + input: + bytes: [ 0x73, 0x23, 0x10, 0xf1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mvendorid, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x10, 0xf1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mvendorid, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x20, 0xf1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, marchid, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x20, 0xf1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, marchid, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x30, 0xf1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mimpid, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x30, 0xf1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mimpid, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x40, 0xf1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhartid, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x40, 0xf1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhartid, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x50, 0xf1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mconfigptr, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x50, 0xf1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mconfigptr, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x00, 0x30 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mstatus, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x00, 0x30 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mstatus, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x10, 0x30 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, misa, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x10, 0x30 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, misa, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x20, 0x30 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, medeleg, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x20, 0x30 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, medeleg, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x30, 0x30 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mideleg, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x30, 0x30 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mideleg, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x40, 0x30 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mie, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x40, 0x30 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mie, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x50, 0x30 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mtvec, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x50, 0x30 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mtvec, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x60, 0x30 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mcounteren, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x60, 0x30 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mcounteren, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x00, 0x34 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mscratch, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x00, 0x34 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mscratch, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x10, 0x34 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mepc, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x10, 0x34 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mepc, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x20, 0x34 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mcause, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x20, 0x34 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mcause, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x30, 0x34 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mtval, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x30, 0x34 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mtval, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x40, 0x34 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mip, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x40, 0x34 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mip, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xa0, 0x34 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mtinst, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xa0, 0x34 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mtinst, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xb0, 0x34 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mtval2, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xb0, 0x34 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mtval2, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xa0, 0x30 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, menvcfg, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xa0, 0x30 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, menvcfg, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x70, 0x74 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mseccfg, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x70, 0x74 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mseccfg, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x00, 0x3a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpcfg0, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x00, 0x3a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpcfg0, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x20, 0x3a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpcfg2, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x20, 0x3a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpcfg2, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x40, 0x3a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpcfg4, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x40, 0x3a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpcfg4, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x60, 0x3a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpcfg6, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x60, 0x3a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpcfg6, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x80, 0x3a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpcfg8, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x80, 0x3a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpcfg8, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xa0, 0x3a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpcfg10, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xa0, 0x3a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpcfg10, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xc0, 0x3a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpcfg12, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xc0, 0x3a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpcfg12, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xe0, 0x3a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpcfg14, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xe0, 0x3a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpcfg14, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x00, 0x3b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr0, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x00, 0x3b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr0, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x10, 0x3b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr1, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x10, 0x3b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr1, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x20, 0x3b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr2, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x20, 0x3b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr2, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x30, 0x3b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr3, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x30, 0x3b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr3, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x40, 0x3b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr4, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x40, 0x3b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr4, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x50, 0x3b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr5, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x50, 0x3b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr5, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x60, 0x3b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr6, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x60, 0x3b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr6, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x70, 0x3b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr7, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x70, 0x3b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr7, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x80, 0x3b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr8, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x80, 0x3b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr8, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x90, 0x3b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr9, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x90, 0x3b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr9, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xa0, 0x3b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr10, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xa0, 0x3b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr10, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xb0, 0x3b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr11, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xb0, 0x3b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr11, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xc0, 0x3b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr12, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xc0, 0x3b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr12, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xd0, 0x3b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr13, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xd0, 0x3b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr13, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xe0, 0x3b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr14, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xe0, 0x3b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr14, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xf0, 0x3b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr15, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xf0, 0x3b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr15, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x00, 0x3c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr16, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x00, 0x3c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr16, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x10, 0x3c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr17, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x10, 0x3c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr17, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x20, 0x3c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr18, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x20, 0x3c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr18, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x30, 0x3c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr19, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x30, 0x3c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr19, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x40, 0x3c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr20, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x40, 0x3c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr20, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x50, 0x3c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr21, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x50, 0x3c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr21, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x60, 0x3c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr22, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x60, 0x3c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr22, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x70, 0x3c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr23, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x70, 0x3c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr23, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x80, 0x3c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr24, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x80, 0x3c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr24, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x90, 0x3c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr25, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x90, 0x3c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr25, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xa0, 0x3c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr26, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xa0, 0x3c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr26, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xb0, 0x3c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr27, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xb0, 0x3c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr27, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xc0, 0x3c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr28, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xc0, 0x3c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr28, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xd0, 0x3c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr29, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xd0, 0x3c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr29, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xe0, 0x3c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr30, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xe0, 0x3c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr30, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xf0, 0x3c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr31, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xf0, 0x3c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr31, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x00, 0x3d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr32, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x00, 0x3d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr32, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x10, 0x3d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr33, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x10, 0x3d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr33, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x20, 0x3d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr34, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x20, 0x3d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr34, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x30, 0x3d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr35, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x30, 0x3d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr35, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x40, 0x3d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr36, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x40, 0x3d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr36, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x50, 0x3d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr37, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x50, 0x3d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr37, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x60, 0x3d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr38, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x60, 0x3d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr38, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x70, 0x3d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr39, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x70, 0x3d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr39, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x80, 0x3d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr40, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x80, 0x3d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr40, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x90, 0x3d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr41, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x90, 0x3d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr41, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xa0, 0x3d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr42, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xa0, 0x3d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr42, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xb0, 0x3d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr43, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xb0, 0x3d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr43, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xc0, 0x3d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr44, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xc0, 0x3d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr44, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xd0, 0x3d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr45, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xd0, 0x3d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr45, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xe0, 0x3d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr46, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xe0, 0x3d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr46, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xf0, 0x3d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr47, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xf0, 0x3d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr47, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x00, 0x3e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr48, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x00, 0x3e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr48, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x10, 0x3e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr49, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x10, 0x3e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr49, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x20, 0x3e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr50, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x20, 0x3e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr50, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x30, 0x3e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr51, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x30, 0x3e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr51, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x40, 0x3e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr52, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x40, 0x3e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr52, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x50, 0x3e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr53, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x50, 0x3e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr53, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x60, 0x3e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr54, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x60, 0x3e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr54, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x70, 0x3e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr55, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x70, 0x3e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr55, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x80, 0x3e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr56, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x80, 0x3e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr56, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x90, 0x3e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr57, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x90, 0x3e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr57, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xa0, 0x3e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr58, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xa0, 0x3e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr58, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xb0, 0x3e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr59, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xb0, 0x3e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr59, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xc0, 0x3e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr60, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xc0, 0x3e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr60, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xd0, 0x3e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr61, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xd0, 0x3e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr61, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xe0, 0x3e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr62, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xe0, 0x3e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr62, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xf0, 0x3e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpaddr63, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xf0, 0x3e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpaddr63, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x00, 0xb0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mcycle, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x00, 0xb0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mcycle, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x20, 0xb0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, minstret, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x20, 0xb0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, minstret, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x00, 0x7a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, tselect, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x00, 0x7a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, tselect, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x10, 0x7a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, tdata1, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x10, 0x7a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, tdata1, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x20, 0x7a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, tdata2, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x20, 0x7a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, tdata2, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x30, 0x7a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, tdata3, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x30, 0x7a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, tdata3, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x80, 0x7a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mcontext, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x80, 0x7a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mcontext, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x00, 0x7b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, dcsr, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x00, 0x7b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, dcsr, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x10, 0x7b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, dpc, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x10, 0x7b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, dpc, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x20, 0x7b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, dscratch0, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x20, 0x7b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, dscratch0, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x30, 0x7b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, dscratch1, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x30, 0x7b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, dscratch1, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x30, 0xb0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmcounter3, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x30, 0xb0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmcounter3, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x40, 0xb0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmcounter4, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x40, 0xb0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmcounter4, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x50, 0xb0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmcounter5, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x50, 0xb0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmcounter5, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x60, 0xb0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmcounter6, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x60, 0xb0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmcounter6, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x70, 0xb0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmcounter7, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x70, 0xb0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmcounter7, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x80, 0xb0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmcounter8, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x80, 0xb0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmcounter8, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x90, 0xb0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmcounter9, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x90, 0xb0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmcounter9, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xa0, 0xb0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmcounter10, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xa0, 0xb0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmcounter10, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xb0, 0xb0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmcounter11, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xb0, 0xb0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmcounter11, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xc0, 0xb0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmcounter12, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xc0, 0xb0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmcounter12, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xd0, 0xb0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmcounter13, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xd0, 0xb0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmcounter13, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xe0, 0xb0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmcounter14, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xe0, 0xb0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmcounter14, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xf0, 0xb0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmcounter15, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xf0, 0xb0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmcounter15, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x00, 0xb1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmcounter16, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x00, 0xb1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmcounter16, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x10, 0xb1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmcounter17, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x10, 0xb1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmcounter17, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x20, 0xb1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmcounter18, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x20, 0xb1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmcounter18, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x30, 0xb1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmcounter19, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x30, 0xb1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmcounter19, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x40, 0xb1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmcounter20, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x40, 0xb1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmcounter20, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x50, 0xb1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmcounter21, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x50, 0xb1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmcounter21, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x60, 0xb1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmcounter22, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x60, 0xb1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmcounter22, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x70, 0xb1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmcounter23, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x70, 0xb1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmcounter23, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x80, 0xb1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmcounter24, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x80, 0xb1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmcounter24, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x90, 0xb1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmcounter25, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x90, 0xb1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmcounter25, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xa0, 0xb1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmcounter26, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xa0, 0xb1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmcounter26, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xb0, 0xb1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmcounter27, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xb0, 0xb1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmcounter27, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xc0, 0xb1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmcounter28, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xc0, 0xb1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmcounter28, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xd0, 0xb1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmcounter29, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xd0, 0xb1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmcounter29, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xe0, 0xb1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmcounter30, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xe0, 0xb1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmcounter30, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xf0, 0xb1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmcounter31, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xf0, 0xb1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmcounter31, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x00, 0x32 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mcountinhibit, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x00, 0x32 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mcountinhibit, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x30, 0x32 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmevent3, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x30, 0x32 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmevent3, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x40, 0x32 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmevent4, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x40, 0x32 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmevent4, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x50, 0x32 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmevent5, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x50, 0x32 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmevent5, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x60, 0x32 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmevent6, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x60, 0x32 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmevent6, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x70, 0x32 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmevent7, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x70, 0x32 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmevent7, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x80, 0x32 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmevent8, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x80, 0x32 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmevent8, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x90, 0x32 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmevent9, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x90, 0x32 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmevent9, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xa0, 0x32 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmevent10, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xa0, 0x32 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmevent10, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xb0, 0x32 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmevent11, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xb0, 0x32 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmevent11, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xc0, 0x32 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmevent12, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xc0, 0x32 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmevent12, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xd0, 0x32 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmevent13, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xd0, 0x32 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmevent13, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xe0, 0x32 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmevent14, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xe0, 0x32 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmevent14, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xf0, 0x32 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmevent15, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xf0, 0x32 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmevent15, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x00, 0x33 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmevent16, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x00, 0x33 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmevent16, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x10, 0x33 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmevent17, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x10, 0x33 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmevent17, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x20, 0x33 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmevent18, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x20, 0x33 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmevent18, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x30, 0x33 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmevent19, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x30, 0x33 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmevent19, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x40, 0x33 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmevent20, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x40, 0x33 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmevent20, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x50, 0x33 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmevent21, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x50, 0x33 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmevent21, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x60, 0x33 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmevent22, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x60, 0x33 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmevent22, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x70, 0x33 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmevent23, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x70, 0x33 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmevent23, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x80, 0x33 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmevent24, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x80, 0x33 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmevent24, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x90, 0x33 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmevent25, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x90, 0x33 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmevent25, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xa0, 0x33 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmevent26, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xa0, 0x33 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmevent26, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xb0, 0x33 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmevent27, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xb0, 0x33 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmevent27, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xc0, 0x33 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmevent28, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xc0, 0x33 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmevent28, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xd0, 0x33 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmevent29, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xd0, 0x33 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmevent29, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xe0, 0x33 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmevent30, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xe0, 0x33 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmevent30, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xf0, 0x33 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmevent31, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xf0, 0x33 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmevent31, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xc0, 0x30 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mstateen0, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xc0, 0x30 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mstateen0, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xd0, 0x30 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mstateen1, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xd0, 0x30 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mstateen1, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xe0, 0x30 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mstateen2, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xe0, 0x30 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mstateen2, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xf0, 0x30 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mstateen3, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xf0, 0x30 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mstateen3, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x00, 0x35 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, miselect, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x00, 0x35 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, miselect, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x10, 0x35 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mireg, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x10, 0x35 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mireg, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xc0, 0x35 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mtopei, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xc0, 0x35 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mtopei, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x00, 0xfb ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mtopi, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x00, 0xfb ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mtopi, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x80, 0x30 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mvien, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x80, 0x30 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mvien, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x90, 0x30 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mvip, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x90, 0x30 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mvip, zero" diff --git a/tests/MC/RISCV/mask_riscv64_riscv_v.txt.yaml b/tests/MC/RISCV/mask_riscv64_riscv_v.txt.yaml new file mode 100644 index 0000000000..37324c4d77 --- /dev/null +++ b/tests/MC/RISCV/mask_riscv64_riscv_v.txt.yaml @@ -0,0 +1,260 @@ +test_cases: + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0x66 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmand.mm v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0x76 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmnand.mm v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0x62 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmandn.mm v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0x6e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmxor.mm v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0x6a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmor.mm v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0x7a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmnor.mm v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0x72 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmorn.mm v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0x7e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmxnor.mm v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x26, 0x48, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vcpop.m a2, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x26, 0x48, 0x42 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vcpop.m a2, v4" + + - + input: + bytes: [ 0x57, 0xa6, 0x48, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vfirst.m a2, v4, v0.t" + + - + input: + bytes: [ 0x57, 0xa6, 0x48, 0x42 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vfirst.m a2, v4" + + - + input: + bytes: [ 0x57, 0xa4, 0x40, 0x50 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmsbf.m v8, v4, v0.t" + + - + input: + bytes: [ 0x57, 0xa4, 0x40, 0x52 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmsbf.m v8, v4" + + - + input: + bytes: [ 0x57, 0xa4, 0x41, 0x50 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmsif.m v8, v4, v0.t" + + - + input: + bytes: [ 0x57, 0xa4, 0x41, 0x52 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmsif.m v8, v4" + + - + input: + bytes: [ 0x57, 0x24, 0x41, 0x50 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmsof.m v8, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x24, 0x41, 0x52 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmsof.m v8, v4" + + - + input: + bytes: [ 0x57, 0x24, 0x48, 0x50 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "viota.m v8, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x24, 0x48, 0x52 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "viota.m v8, v4" + + - + input: + bytes: [ 0x57, 0xa4, 0x08, 0x50 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vid.v v8, v0.t" + + - + input: + bytes: [ 0x57, 0xa4, 0x08, 0x52 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vid.v v8" + + - + input: + bytes: [ 0x57, 0x24, 0x42, 0x66 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmmv.m v8, v4" + + - + input: + bytes: [ 0x57, 0x24, 0x84, 0x6e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmclr.m v8" + + - + input: + bytes: [ 0x57, 0x24, 0x84, 0x7e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmset.m v8" + + - + input: + bytes: [ 0x57, 0x24, 0x42, 0x76 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmnot.m v8, v4" diff --git a/tests/MC/RISCV/minmax_riscv64_riscv_v.txt.yaml b/tests/MC/RISCV/minmax_riscv64_riscv_v.txt.yaml new file mode 100644 index 0000000000..883404c147 --- /dev/null +++ b/tests/MC/RISCV/minmax_riscv64_riscv_v.txt.yaml @@ -0,0 +1,160 @@ +test_cases: + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0x10 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vminu.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0x12 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vminu.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x10 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vminu.vx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x12 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vminu.vx v8, v4, a0" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0x14 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmin.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0x16 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmin.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x14 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmin.vx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x16 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmin.vx v8, v4, a0" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0x18 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmaxu.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0x1a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmaxu.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x18 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmaxu.vx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x1a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmaxu.vx v8, v4, a0" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0x1c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmax.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0x1e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmax.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x1c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmax.vx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x1e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmax.vx v8, v4, a0" diff --git a/tests/MC/RISCV/mul_riscv64_riscv_v.txt.yaml b/tests/MC/RISCV/mul_riscv64_riscv_v.txt.yaml new file mode 100644 index 0000000000..be4b30dd4e --- /dev/null +++ b/tests/MC/RISCV/mul_riscv64_riscv_v.txt.yaml @@ -0,0 +1,320 @@ +test_cases: + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0x94 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmul.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0x96 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmul.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0x94 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmul.vx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0x96 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmul.vx v8, v4, a0" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0x9c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmulh.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0x9e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmulh.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0x9c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmulh.vx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0x9e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmulh.vx v8, v4, a0" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0x90 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmulhu.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0x92 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmulhu.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0x90 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmulhu.vx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0x92 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmulhu.vx v8, v4, a0" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0x98 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmulhsu.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0x9a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmulhsu.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0x98 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmulhsu.vx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0x9a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmulhsu.vx v8, v4, a0" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0xec ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwmul.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0xee ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwmul.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0xec ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwmul.vx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0xee ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwmul.vx v8, v4, a0" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0xe0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwmulu.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0xe2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwmulu.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0xe0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwmulu.vx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0xe2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwmulu.vx v8, v4, a0" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0xe8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwmulsu.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0xea ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwmulsu.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0xe8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwmulsu.vx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0xea ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwmulsu.vx v8, v4, a0" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0x9c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsmul.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0x9e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsmul.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x9c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsmul.vx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x9e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsmul.vx v8, v4, a0" diff --git a/tests/MC/RISCV/mv_riscv64_riscv_v.txt.yaml b/tests/MC/RISCV/mv_riscv64_riscv_v.txt.yaml new file mode 100644 index 0000000000..2ffb6ee7e0 --- /dev/null +++ b/tests/MC/RISCV/mv_riscv64_riscv_v.txt.yaml @@ -0,0 +1,90 @@ +test_cases: + - + input: + bytes: [ 0x57, 0x04, 0x0a, 0x5e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmv.v.v v8, v20" + + - + input: + bytes: [ 0x57, 0x44, 0x05, 0x5e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmv.v.x v8, a0" + + - + input: + bytes: [ 0x57, 0xb4, 0x07, 0x5e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmv.v.i v8, 15" + + - + input: + bytes: [ 0x57, 0x26, 0x40, 0x42 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmv.x.s a2, v4" + + - + input: + bytes: [ 0x57, 0x64, 0x05, 0x42 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmv.s.x v8, a0" + + - + input: + bytes: [ 0x57, 0x34, 0x40, 0x9e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmv1r.v v8, v4" + + - + input: + bytes: [ 0x57, 0xb4, 0x40, 0x9e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmv2r.v v8, v4" + + - + input: + bytes: [ 0x57, 0xb4, 0x41, 0x9e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmv4r.v v8, v4" + + - + input: + bytes: [ 0x57, 0xb4, 0x83, 0x9f ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmv8r.v v8, v24" diff --git a/tests/MC/RISCV/option_arch_riscv32.txt.yaml b/tests/MC/RISCV/option_arch_riscv32.txt.yaml new file mode 100644 index 0000000000..6c2cebcea3 --- /dev/null +++ b/tests/MC/RISCV/option_arch_riscv32.txt.yaml @@ -0,0 +1,98 @@ +test_cases: + - + input: + bytes: [ 0x13, 0x85, 0x05, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32" ] + expected: + insns: + - + asm_text: "mv a0, a1" + + - + input: + bytes: [ 0x13, 0x04, 0xc1, 0x3f ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32" ] + expected: + insns: + - + asm_text: "addi s0, sp, 1020" + + - + input: + bytes: [ 0x2e, 0x85 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32" ] + expected: + insns: + - + asm_text: "mv a0, a1" + + - + input: + bytes: [ 0xe0, 0x1f ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32" ] + expected: + insns: + - + asm_text: "addi s0, sp, 1020" + + - + input: + bytes: [ 0x07, 0x20, 0xc5, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32" ] + expected: + insns: + - + asm_text: "flw ft0, 12(a0)" + + - + input: + bytes: [ 0x33, 0x87, 0x80, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32" ] + expected: + insns: + - + asm_text: "mul a4, ra, s0" + + - + skip: true + skip_reason: > + Bad test generated due to the ASUpdater not understanding the + inline architecture options syntax in LLVM tests, this test + should have been generated with an "a" flag because this + instruction belongs to the atomic extension + input: + bytes: [ 0xaf, 0x22, 0x03, 0x10 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32" ] + expected: + insns: + - + asm_text: "lr.w t0, (t1)" + + - + skip: true + skip_reason: "Same as above, should have been generated with a 'zba' extension" + input: + bytes: [ 0xb3, 0x22, 0x73, 0x20 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32" ] + expected: + insns: + - + asm_text: "sh1add t0, t1, t2" + + - + input: + bytes: [ 0x08, 0x61 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32" ] + expected: + insns: + - + asm_text: "flw fa0, 0(a0)" diff --git a/tests/MC/RISCV/option_rvc_riscv32.txt.yaml b/tests/MC/RISCV/option_rvc_riscv32.txt.yaml new file mode 100644 index 0000000000..a217441708 --- /dev/null +++ b/tests/MC/RISCV/option_rvc_riscv32.txt.yaml @@ -0,0 +1,40 @@ +test_cases: + - + input: + bytes: [ 0x13, 0x85, 0x05, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32" ] + expected: + insns: + - + asm_text: "mv a0, a1" + + - + input: + bytes: [ 0x13, 0x04, 0xc1, 0x3f ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32" ] + expected: + insns: + - + asm_text: "addi s0, sp, 1020" + + - + input: + bytes: [ 0x2e, 0x85 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32" ] + expected: + insns: + - + asm_text: "mv a0, a1" + + - + input: + bytes: [ 0xe0, 0x1f ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32" ] + expected: + insns: + - + asm_text: "addi s0, sp, 1020" diff --git a/tests/MC/RISCV/or_riscv64_riscv_v.txt.yaml b/tests/MC/RISCV/or_riscv64_riscv_v.txt.yaml new file mode 100644 index 0000000000..ac53af3427 --- /dev/null +++ b/tests/MC/RISCV/or_riscv64_riscv_v.txt.yaml @@ -0,0 +1,60 @@ +test_cases: + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0x28 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vor.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0x2a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vor.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x28 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vor.vx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x2a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vor.vx v8, v4, a0" + + - + input: + bytes: [ 0x57, 0xb4, 0x47, 0x28 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vor.vi v8, v4, 15, v0.t" + + - + input: + bytes: [ 0x57, 0xb4, 0x47, 0x2a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vor.vi v8, v4, 15" diff --git a/tests/MC/RISCV/others_riscv64_riscv_v_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/others_riscv64_riscv_v_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..ece8419e05 --- /dev/null +++ b/tests/MC/RISCV/others_riscv64_riscv_v_syntax_no_alias_text.txt.yaml @@ -0,0 +1,240 @@ +test_cases: + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0x5c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vmerge.vvm v8, v4, v20, v0" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x5c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vmerge.vxm v8, v4, a0, v0" + + - + input: + bytes: [ 0x57, 0xb4, 0x47, 0x5c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vmerge.vim v8, v4, 15, v0" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x38 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vslideup.vx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x3a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vslideup.vx v8, v4, a0" + + - + input: + bytes: [ 0x57, 0xb4, 0x4f, 0x38 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vslideup.vi v8, v4, 31, v0.t" + + - + input: + bytes: [ 0x57, 0xb4, 0x4f, 0x3a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vslideup.vi v8, v4, 31" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x3c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vslidedown.vx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x3e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vslidedown.vx v8, v4, a0" + + - + input: + bytes: [ 0x57, 0xb4, 0x4f, 0x3c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vslidedown.vi v8, v4, 31, v0.t" + + - + input: + bytes: [ 0x57, 0xb4, 0x4f, 0x3e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vslidedown.vi v8, v4, 31" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0x38 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vslide1up.vx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0x3a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vslide1up.vx v8, v4, a0" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0x3c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vslide1down.vx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0x3e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vslide1down.vx v8, v4, a0" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0x30 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vrgather.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0x32 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vrgather.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x30 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vrgather.vx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x32 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vrgather.vx v8, v4, a0" + + - + input: + bytes: [ 0x57, 0xb4, 0x4f, 0x30 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vrgather.vi v8, v4, 31, v0.t" + + - + input: + bytes: [ 0x57, 0xb4, 0x4f, 0x32 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vrgather.vi v8, v4, 31" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0x38 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vrgatherei16.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0x3a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vrgatherei16.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0x5e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vcompress.vm v8, v4, v20" diff --git a/tests/MC/RISCV/print_imm_hex_riscv32_riscv_v_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/print_imm_hex_riscv32_riscv_v_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..bbafe6b987 --- /dev/null +++ b/tests/MC/RISCV/print_imm_hex_riscv32_riscv_v_syntax_no_alias_text.txt.yaml @@ -0,0 +1,40 @@ +test_cases: + - + input: + bytes: [ 0x63, 0x83, 0x94, 0x06 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "beq s1, s1, 102" + + - + input: + bytes: [ 0x03, 0x25, 0x16, 0x06 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "lw a0, 97(a2)" + + - + input: + bytes: [ 0xf3, 0xd2, 0xff, 0xff ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrwi t0, 4095, 31" + + - + input: + bytes: [ 0x57, 0x76, 0xf5, 0x0f ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsetvli a2, a0, 255" diff --git a/tests/MC/RISCV/priv_valid_riscv32_svinval_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/priv_valid_riscv32_svinval_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..739fabdc03 --- /dev/null +++ b/tests/MC/RISCV/priv_valid_riscv32_svinval_syntax_no_alias_text.txt.yaml @@ -0,0 +1,90 @@ +test_cases: + - + input: + bytes: [ 0x73, 0x00, 0x20, 0x10 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "svinval", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "sret" + + - + input: + bytes: [ 0x73, 0x00, 0x20, 0x30 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "svinval", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "mret" + + - + input: + bytes: [ 0x73, 0x00, 0x50, 0x10 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "svinval", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "wfi" + + - + input: + bytes: [ 0x73, 0x00, 0x00, 0x12 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "svinval", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "sfence.vma zero, zero" + + - + input: + bytes: [ 0x73, 0x00, 0xb5, 0x12 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "svinval", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "sfence.vma a0, a1" + + - + input: + bytes: [ 0x73, 0x00, 0x00, 0x16 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "svinval", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "sinval.vma zero, zero" + + - + input: + bytes: [ 0x73, 0x00, 0xb5, 0x16 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "svinval", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "sinval.vma a0, a1" + + - + input: + bytes: [ 0x73, 0x00, 0x00, 0x18 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "svinval", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "sfence.w.inval" + + - + input: + bytes: [ 0x73, 0x00, 0x10, 0x18 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "svinval", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "sfence.inval.ir" diff --git a/tests/MC/RISCV/reduction_riscv64_riscv_v.txt.yaml b/tests/MC/RISCV/reduction_riscv64_riscv_v.txt.yaml new file mode 100644 index 0000000000..377d4550c9 --- /dev/null +++ b/tests/MC/RISCV/reduction_riscv64_riscv_v.txt.yaml @@ -0,0 +1,210 @@ +test_cases: + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vredsum.vs v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vredsum.vs v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0x18 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vredmaxu.vs v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0x1a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vredmaxu.vs v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0x1c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vredmax.vs v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0x1e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vredmax.vs v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0x10 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vredminu.vs v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0x12 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vredminu.vs v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0x14 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vredmin.vs v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0x16 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vredmin.vs v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0x04 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vredand.vs v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0x06 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vredand.vs v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0x08 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vredor.vs v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0x0a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vredor.vs v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0x0c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vredxor.vs v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0x0e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vredxor.vs v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwredsumu.vs v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0xc2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwredsumu.vs v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0xc4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwredsum.vs v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0xc6 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwredsum.vs v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x20, 0x4a, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vredsum.vs v0, v4, v20, v0.t" diff --git a/tests/MC/RISCV/rv32_hypervisor_csr_names_riscv32_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rv32_hypervisor_csr_names_riscv32_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..7c7f80a409 --- /dev/null +++ b/tests/MC/RISCV/rv32_hypervisor_csr_names_riscv32_syntax_no_alias_text.txt.yaml @@ -0,0 +1,280 @@ +test_cases: + - + input: + bytes: [ 0x73, 0x23, 0xa0, 0x61 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, henvcfgh, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xa0, 0x61 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, henvcfgh, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x50, 0x61 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, htimedeltah, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x50, 0x61 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, htimedeltah, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xd0, 0x25 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, vstimecmph, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xd0, 0x25 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, vstimecmph, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xc0, 0x61 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hstateen0h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xc0, 0x61 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hstateen0h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xd0, 0x61 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hstateen1h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xd0, 0x61 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hstateen1h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xe0, 0x61 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hstateen2h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xe0, 0x61 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hstateen2h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xf0, 0x61 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hstateen3h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xf0, 0x61 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hstateen3h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x30, 0x61 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hidelegh, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x30, 0x61 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hidelegh, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x80, 0x61 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hvienh, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x80, 0x61 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hvienh, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x50, 0x65 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hviph, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x50, 0x65 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hviph, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x60, 0x65 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hviprio1h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x60, 0x65 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hviprio1h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x70, 0x65 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hviprio2h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x70, 0x65 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hviprio2h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x40, 0x21 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, vsieh, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x40, 0x21 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, vsieh, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x40, 0x25 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, vsiph, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x40, 0x25 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, vsiph, zero" diff --git a/tests/MC/RISCV/rv32_immediate_riscv32_riscv_v.txt.yaml b/tests/MC/RISCV/rv32_immediate_riscv32_riscv_v.txt.yaml new file mode 100644 index 0000000000..5815b314e6 --- /dev/null +++ b/tests/MC/RISCV/rv32_immediate_riscv32_riscv_v.txt.yaml @@ -0,0 +1,20 @@ +test_cases: + - + input: + bytes: [ 0x57, 0x34, 0x48, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vadd.vi v8, v4, -16" + + - + input: + bytes: [ 0x57, 0x34, 0x48, 0x72 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmsleu.vi v8, v4, -16" diff --git a/tests/MC/RISCV/rv32_machine_csr_names_riscv32_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rv32_machine_csr_names_riscv32_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..9adc216653 --- /dev/null +++ b/tests/MC/RISCV/rv32_machine_csr_names_riscv32_syntax_no_alias_text.txt.yaml @@ -0,0 +1,1600 @@ +test_cases: + - + input: + bytes: [ 0x73, 0x23, 0x00, 0x31 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mstatush, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x00, 0x31 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mstatush, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xa0, 0x31 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, menvcfgh, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xa0, 0x31 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, menvcfgh, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x70, 0x75 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mseccfgh, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x70, 0x75 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mseccfgh, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x10, 0x3a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpcfg1, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x10, 0x3a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpcfg1, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x30, 0x3a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpcfg3, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x30, 0x3a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpcfg3, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x50, 0x3a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpcfg5, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x50, 0x3a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpcfg5, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x70, 0x3a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpcfg7, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x70, 0x3a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpcfg7, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x90, 0x3a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpcfg9, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x90, 0x3a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpcfg9, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xb0, 0x3a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpcfg11, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xb0, 0x3a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpcfg11, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xd0, 0x3a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpcfg13, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xd0, 0x3a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpcfg13, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xf0, 0x3a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, pmpcfg15, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xf0, 0x3a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, pmpcfg15, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x00, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mcycleh, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x00, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mcycleh, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x20, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, minstreth, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x20, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, minstreth, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x30, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmcounter3h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x30, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmcounter3h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x40, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmcounter4h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x40, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmcounter4h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x50, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmcounter5h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x50, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmcounter5h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x60, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmcounter6h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x60, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmcounter6h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x70, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmcounter7h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x70, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmcounter7h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x80, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmcounter8h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x80, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmcounter8h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x90, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmcounter9h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x90, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmcounter9h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xa0, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmcounter10h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xa0, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmcounter10h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xb0, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmcounter11h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xb0, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmcounter11h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xc0, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmcounter12h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xc0, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmcounter12h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xd0, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmcounter13h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xd0, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmcounter13h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xe0, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmcounter14h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xe0, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmcounter14h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xf0, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmcounter15h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xf0, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmcounter15h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x00, 0xb9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmcounter16h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x00, 0xb9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmcounter16h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x10, 0xb9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmcounter17h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x10, 0xb9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmcounter17h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x20, 0xb9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmcounter18h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x20, 0xb9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmcounter18h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x30, 0xb9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmcounter19h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x30, 0xb9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmcounter19h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x40, 0xb9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmcounter20h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x40, 0xb9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmcounter20h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x50, 0xb9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmcounter21h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x50, 0xb9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmcounter21h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x60, 0xb9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmcounter22h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x60, 0xb9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmcounter22h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x70, 0xb9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmcounter23h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x70, 0xb9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmcounter23h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x80, 0xb9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmcounter24h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x80, 0xb9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmcounter24h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x90, 0xb9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmcounter25h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x90, 0xb9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmcounter25h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xa0, 0xb9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmcounter26h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xa0, 0xb9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmcounter26h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xb0, 0xb9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmcounter27h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xb0, 0xb9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmcounter27h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xc0, 0xb9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmcounter28h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xc0, 0xb9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmcounter28h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xd0, 0xb9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmcounter29h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xd0, 0xb9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmcounter29h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xe0, 0xb9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmcounter30h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xe0, 0xb9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmcounter30h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xf0, 0xb9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmcounter31h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xf0, 0xb9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmcounter31h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x30, 0x72 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmevent3h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x30, 0x72 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmevent3h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x40, 0x72 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmevent4h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x40, 0x72 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmevent4h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x50, 0x72 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmevent5h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x50, 0x72 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmevent5h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x60, 0x72 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmevent6h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x60, 0x72 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmevent6h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x70, 0x72 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmevent7h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x70, 0x72 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmevent7h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x80, 0x72 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmevent8h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x80, 0x72 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmevent8h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x90, 0x72 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmevent9h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x90, 0x72 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmevent9h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xa0, 0x72 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmevent10h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xa0, 0x72 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmevent10h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xb0, 0x72 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmevent11h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xb0, 0x72 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmevent11h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xc0, 0x72 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmevent12h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xc0, 0x72 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmevent12h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xd0, 0x72 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmevent13h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xd0, 0x72 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmevent13h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xe0, 0x72 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmevent14h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xe0, 0x72 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmevent14h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xf0, 0x72 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmevent15h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xf0, 0x72 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmevent15h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x00, 0x73 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmevent16h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x00, 0x73 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmevent16h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x10, 0x73 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmevent17h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x10, 0x73 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmevent17h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x20, 0x73 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmevent18h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x20, 0x73 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmevent18h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x30, 0x73 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmevent19h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x30, 0x73 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmevent19h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x40, 0x73 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmevent20h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x40, 0x73 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmevent20h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x50, 0x73 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmevent21h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x50, 0x73 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmevent21h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x60, 0x73 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmevent22h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x60, 0x73 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmevent22h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x70, 0x73 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmevent23h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x70, 0x73 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmevent23h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x80, 0x73 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmevent24h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x80, 0x73 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmevent24h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x90, 0x73 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmevent25h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x90, 0x73 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmevent25h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xa0, 0x73 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmevent26h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xa0, 0x73 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmevent26h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xb0, 0x73 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmevent27h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xb0, 0x73 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmevent27h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xc0, 0x73 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmevent28h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xc0, 0x73 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmevent28h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xd0, 0x73 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmevent29h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xd0, 0x73 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmevent29h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xe0, 0x73 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmevent30h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xe0, 0x73 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmevent30h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xf0, 0x73 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mhpmevent31h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xf0, 0x73 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mhpmevent31h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xc0, 0x31 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mstateen0h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xc0, 0x31 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mstateen0h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xd0, 0x31 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mstateen1h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xd0, 0x31 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mstateen1h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xe0, 0x31 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mstateen2h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xe0, 0x31 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mstateen2h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xf0, 0x31 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mstateen3h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xf0, 0x31 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mstateen3h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x30, 0x31 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, midelegh, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x30, 0x31 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, midelegh, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x40, 0x31 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mieh, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x40, 0x31 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mieh, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x80, 0x31 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mvienh, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x80, 0x31 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mvienh, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x90, 0x31 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, mviph, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x90, 0x31 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, mviph, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x40, 0x35 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, miph, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x40, 0x35 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, miph, zero" diff --git a/tests/MC/RISCV/rv32_supervisor_csr_names_riscv32_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rv32_supervisor_csr_names_riscv32_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..2202547554 --- /dev/null +++ b/tests/MC/RISCV/rv32_supervisor_csr_names_riscv32_syntax_no_alias_text.txt.yaml @@ -0,0 +1,60 @@ +test_cases: + - + input: + bytes: [ 0x73, 0x23, 0xd0, 0x15 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, stimecmph, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xd0, 0x15 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, stimecmph, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x40, 0x11 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, sieh, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x40, 0x11 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, sieh, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x40, 0x15 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, siph, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x40, 0x15 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, siph, zero" diff --git a/tests/MC/RISCV/rv32_user_csr_names_riscv32_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rv32_user_csr_names_riscv32_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..a6b7144317 --- /dev/null +++ b/tests/MC/RISCV/rv32_user_csr_names_riscv32_syntax_no_alias_text.txt.yaml @@ -0,0 +1,640 @@ +test_cases: + - + input: + bytes: [ 0x73, 0x23, 0x00, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, cycleh, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x00, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, cycleh, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x10, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, timeh, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x10, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, timeh, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x20, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, instreth, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x20, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, instreth, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x30, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hpmcounter3h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x30, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hpmcounter3h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x40, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hpmcounter4h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x40, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hpmcounter4h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x50, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hpmcounter5h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x50, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hpmcounter5h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x60, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hpmcounter6h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x60, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hpmcounter6h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x70, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hpmcounter7h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x70, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hpmcounter7h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x80, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hpmcounter8h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x80, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hpmcounter8h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x90, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hpmcounter9h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x90, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hpmcounter9h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xa0, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hpmcounter10h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xa0, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hpmcounter10h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xb0, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hpmcounter11h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xb0, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hpmcounter11h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xc0, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hpmcounter12h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xc0, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hpmcounter12h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xd0, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hpmcounter13h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xd0, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hpmcounter13h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xe0, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hpmcounter14h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xe0, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hpmcounter14h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xf0, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hpmcounter15h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xf0, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hpmcounter15h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x00, 0xc9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hpmcounter16h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x00, 0xc9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hpmcounter16h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x10, 0xc9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hpmcounter17h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x10, 0xc9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hpmcounter17h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x20, 0xc9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hpmcounter18h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x20, 0xc9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hpmcounter18h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x30, 0xc9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hpmcounter19h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x30, 0xc9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hpmcounter19h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x40, 0xc9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hpmcounter20h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x40, 0xc9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hpmcounter20h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x50, 0xc9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hpmcounter21h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x50, 0xc9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hpmcounter21h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x60, 0xc9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hpmcounter22h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x60, 0xc9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hpmcounter22h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x70, 0xc9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hpmcounter23h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x70, 0xc9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hpmcounter23h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x80, 0xc9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hpmcounter24h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x80, 0xc9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hpmcounter24h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x90, 0xc9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hpmcounter25h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x90, 0xc9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hpmcounter25h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xa0, 0xc9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hpmcounter26h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xa0, 0xc9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hpmcounter26h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xb0, 0xc9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hpmcounter27h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xb0, 0xc9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hpmcounter27h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xc0, 0xc9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hpmcounter28h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xc0, 0xc9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hpmcounter28h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xd0, 0xc9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hpmcounter29h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xd0, 0xc9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hpmcounter29h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xe0, 0xc9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hpmcounter30h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xe0, 0xc9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hpmcounter30h, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xf0, 0xc9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hpmcounter31h, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xf0, 0xc9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hpmcounter31h, zero" diff --git a/tests/MC/RISCV/rv32c_only_valid_riscv32_riscv_c_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rv32c_only_valid_riscv32_riscv_c_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..faecc05d56 --- /dev/null +++ b/tests/MC/RISCV/rv32c_only_valid_riscv32_riscv_c_syntax_no_alias_text.txt.yaml @@ -0,0 +1,20 @@ +test_cases: + - + input: + bytes: [ 0xfd, 0x2f ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.jal 2046" + + - + input: + bytes: [ 0xfd, 0x15 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.addi a1, -1" diff --git a/tests/MC/RISCV/rv32c_valid_riscv32_riscv_c_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rv32c_valid_riscv32_riscv_c_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..d41fa1074b --- /dev/null +++ b/tests/MC/RISCV/rv32c_valid_riscv32_riscv_c_syntax_no_alias_text.txt.yaml @@ -0,0 +1,350 @@ +test_cases: + - + input: + bytes: [ 0x82, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.lwsp ra, 0(sp)" + + - + input: + bytes: [ 0x86, 0xdf ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.swsp ra, 252(sp)" + + - + input: + bytes: [ 0x10, 0x41 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.lw a2, 0(a0)" + + - + input: + bytes: [ 0xfc, 0xde ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.sw a5, 124(a3)" + + - + input: + bytes: [ 0x02, 0x44 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.lwsp s0, 0(sp)" + + - + input: + bytes: [ 0x22, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.swsp s0, 0(sp)" + + - + input: + bytes: [ 0x80, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.lw s0, 0(s1)" + + - + input: + bytes: [ 0x80, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.sw s0, 0(s1)" + + - + input: + bytes: [ 0x01, 0xb0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.j -2048" + + - + input: + bytes: [ 0x82, 0x88 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.jr a7" + + - + input: + bytes: [ 0x82, 0x95 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.jalr a1" + + - + input: + bytes: [ 0x81, 0xd2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.beqz a3, -256" + + - + input: + bytes: [ 0xfd, 0xef ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.bnez a5, 254" + + - + input: + bytes: [ 0xfd, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.li a7, 31" + + - + input: + bytes: [ 0x81, 0x16 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.addi a3, -32" + + - + input: + bytes: [ 0x01, 0x71 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.addi16sp sp, -512" + + - + input: + bytes: [ 0x7d, 0x61 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.addi16sp sp, 496" + + - + input: + bytes: [ 0xf4, 0x1f ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.addi4spn a3, sp, 1020" + + - + input: + bytes: [ 0x54, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.addi4spn a3, sp, 4" + + - + input: + bytes: [ 0x86, 0x05 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.slli a1, 1" + + - + input: + bytes: [ 0xfd, 0x82 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.srli a3, 31" + + - + input: + bytes: [ 0x09, 0x87 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.srai a4, 2" + + - + input: + bytes: [ 0xbd, 0x8b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.andi a5, 15" + + - + input: + bytes: [ 0xa2, 0x88 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.mv a7, s0" + + - + input: + bytes: [ 0xf1, 0x8d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.and a1, a2" + + - + input: + bytes: [ 0x55, 0x8e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.or a2, a3" + + - + input: + bytes: [ 0xb9, 0x8e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.xor a3, a4" + + - + input: + bytes: [ 0x1d, 0x8f ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.sub a4, a5" + + - + input: + bytes: [ 0x01, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.nop" + + - + input: + bytes: [ 0x02, 0x90 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.ebreak" + + - + input: + bytes: [ 0x05, 0x64 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.lui s0, 1" + + - + input: + bytes: [ 0x7d, 0x64 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.lui s0, 31" + + - + input: + bytes: [ 0x01, 0x74 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.lui s0, 1048544" + + - + input: + bytes: [ 0x7d, 0x74 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.lui s0, 1048575" + + - + input: + bytes: [ 0x00, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.unimp" diff --git a/tests/MC/RISCV/rv32d_valid_riscv32_riscv_d_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rv32d_valid_riscv32_riscv_d_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..3bec66fd30 --- /dev/null +++ b/tests/MC/RISCV/rv32d_valid_riscv32_riscv_d_syntax_no_alias_text.txt.yaml @@ -0,0 +1,480 @@ +test_cases: + - + input: + bytes: [ 0x53, 0xfd, 0xcd, 0x01 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fadd.s fs10, fs11, ft8, dyn" + + - + input: + bytes: [ 0x07, 0x30, 0xc5, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fld ft0, 12(a0)" + + - + input: + bytes: [ 0x87, 0xb0, 0x40, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fld ft1, 4(ra)" + + - + input: + bytes: [ 0x07, 0xb1, 0x06, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fld ft2, -2048(a3)" + + - + input: + bytes: [ 0x87, 0xb1, 0x04, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fld ft3, -2048(s1)" + + - + input: + bytes: [ 0x07, 0x32, 0xf9, 0x7f ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fld ft4, 2047(s2)" + + - + input: + bytes: [ 0x87, 0xb2, 0x09, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fld ft5, 0(s3)" + + - + input: + bytes: [ 0xa7, 0x3f, 0x6a, 0x7e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsd ft6, 2047(s4)" + + - + input: + bytes: [ 0x27, 0xb0, 0x7a, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsd ft7, -2048(s5)" + + - + input: + bytes: [ 0x27, 0x30, 0x8b, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsd fs0, -2048(s6)" + + - + input: + bytes: [ 0xa7, 0xb3, 0x9b, 0x3e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsd fs1, 999(s7)" + + - + input: + bytes: [ 0x43, 0xf5, 0xc5, 0x6a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmadd.d fa0, fa1, fa2, fa3, dyn" + + - + input: + bytes: [ 0x47, 0xf7, 0x07, 0x8b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmsub.d fa4, fa5, fa6, fa7, dyn" + + - + input: + bytes: [ 0x4b, 0xf9, 0x49, 0xab ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fnmsub.d fs2, fs3, fs4, fs5, dyn" + + - + input: + bytes: [ 0x4f, 0xfb, 0x8b, 0xcb ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fnmadd.d fs6, fs7, fs8, fs9, dyn" + + - + input: + bytes: [ 0x53, 0xfd, 0xcd, 0x03 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fadd.d fs10, fs11, ft8, dyn" + + - + input: + bytes: [ 0xd3, 0x7e, 0xff, 0x0b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsub.d ft9, ft10, ft11, dyn" + + - + input: + bytes: [ 0x53, 0xf0, 0x20, 0x12 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmul.d ft0, ft1, ft2, dyn" + + - + input: + bytes: [ 0xd3, 0x71, 0x52, 0x1a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fdiv.d ft3, ft4, ft5, dyn" + + - + input: + bytes: [ 0x53, 0xf3, 0x03, 0x5a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsqrt.d ft6, ft7, dyn" + + - + input: + bytes: [ 0xd3, 0x04, 0xb5, 0x22 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsgnj.d fs1, fa0, fa1" + + - + input: + bytes: [ 0xd3, 0x95, 0xe6, 0x22 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsgnjn.d fa1, fa3, fa4" + + - + input: + bytes: [ 0xd3, 0x26, 0xb6, 0x22 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsgnjx.d fa3, fa2, fa1" + + - + input: + bytes: [ 0xd3, 0x07, 0x18, 0x2b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmin.d fa5, fa6, fa7" + + - + input: + bytes: [ 0x53, 0x99, 0x49, 0x2b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmax.d fs2, fs3, fs4" + + - + input: + bytes: [ 0xd3, 0x7a, 0x1b, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.s.d fs5, fs6, dyn" + + - + input: + bytes: [ 0xd3, 0x0b, 0x0c, 0x42 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.d.s fs7, fs8" + + - + input: + bytes: [ 0xd3, 0x3b, 0x0c, 0x42 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.d.s fs7, fs8, rup" + + - + input: + bytes: [ 0xd3, 0x25, 0x9c, 0xa3 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "feq.d a1, fs8, fs9" + + - + input: + bytes: [ 0x53, 0x16, 0xbd, 0xa3 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "flt.d a2, fs10, fs11" + + - + input: + bytes: [ 0xd3, 0x06, 0xde, 0xa3 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fle.d a3, ft8, ft9" + + - + input: + bytes: [ 0xd3, 0x16, 0x0f, 0xe2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fclass.d a3, ft10" + + - + input: + bytes: [ 0x53, 0xf7, 0x0f, 0xc2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.w.d a4, ft11, dyn" + + - + input: + bytes: [ 0x53, 0x80, 0x07, 0xd2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.d.w ft0, a5" + + - + input: + bytes: [ 0x53, 0xb0, 0x07, 0xd2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.d.w ft0, a5, rup" + + - + input: + bytes: [ 0xd3, 0x00, 0x18, 0xd2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.d.wu ft1, a6" + + - + input: + bytes: [ 0xd3, 0x30, 0x18, 0xd2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.d.wu ft1, a6, rup" + + - + input: + bytes: [ 0x43, 0x85, 0xc5, 0x6a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmadd.d fa0, fa1, fa2, fa3, rne" + + - + input: + bytes: [ 0x47, 0x97, 0x07, 0x8b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmsub.d fa4, fa5, fa6, fa7, rtz" + + - + input: + bytes: [ 0x4b, 0xa9, 0x49, 0xab ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fnmsub.d fs2, fs3, fs4, fs5, rdn" + + - + input: + bytes: [ 0x4f, 0xbb, 0x8b, 0xcb ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fnmadd.d fs6, fs7, fs8, fs9, rup" + + - + input: + bytes: [ 0x53, 0xcd, 0xcd, 0x03 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fadd.d fs10, fs11, ft8, rmm" + + - + input: + bytes: [ 0x53, 0x80, 0x20, 0x12 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmul.d ft0, ft1, ft2, rne" + + - + input: + bytes: [ 0xd3, 0x11, 0x52, 0x1a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fdiv.d ft3, ft4, ft5, rtz" + + - + input: + bytes: [ 0x53, 0xa3, 0x03, 0x5a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsqrt.d ft6, ft7, rdn" + + - + input: + bytes: [ 0xd3, 0x3a, 0x1b, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.s.d fs5, fs6, rup" + + - + input: + bytes: [ 0x53, 0xc7, 0x0f, 0xc2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.w.d a4, ft11, rmm" + + - + input: + bytes: [ 0xd3, 0x77, 0x1f, 0xc2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.wu.d a5, ft10, dyn" diff --git a/tests/MC/RISCV/rv32dc_valid_riscv32_riscv_c_riscv_d_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rv32dc_valid_riscv32_riscv_c_riscv_d_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..be5595b7e6 --- /dev/null +++ b/tests/MC/RISCV/rv32dc_valid_riscv32_riscv_c_riscv_d_syntax_no_alias_text.txt.yaml @@ -0,0 +1,40 @@ +test_cases: + - + input: + bytes: [ 0x7e, 0x34 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.fldsp fs0, 504(sp)" + + - + input: + bytes: [ 0xc6, 0xbf ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.fsdsp fa7, 504(sp)" + + - + input: + bytes: [ 0xf4, 0x3f ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.fld fa3, 248(a5)" + + - + input: + bytes: [ 0xf0, 0xbd ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.fsd fa2, 248(a1)" diff --git a/tests/MC/RISCV/rv32e_valid_riscv32_riscv_e_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rv32e_valid_riscv32_riscv_e_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..680c6f6512 --- /dev/null +++ b/tests/MC/RISCV/rv32e_valid_riscv32_riscv_e_syntax_no_alias_text.txt.yaml @@ -0,0 +1,490 @@ +test_cases: + - + input: + bytes: [ 0x37, 0x10, 0x00, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "lui zero, 1" + + - + input: + bytes: [ 0x97, 0x20, 0x00, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "auipc ra, 2" + + - + input: + bytes: [ 0x6f, 0x01, 0x40, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "jal sp, 4" + + - + input: + bytes: [ 0xe7, 0x81, 0x41, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "jalr gp, 4(gp)" + + - + input: + bytes: [ 0x63, 0x04, 0x52, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "beq tp, t0, 8" + + - + input: + bytes: [ 0x63, 0x16, 0x73, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "bne t1, t2, 12" + + - + input: + bytes: [ 0x63, 0x48, 0x94, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "blt s0, s1, 16" + + - + input: + bytes: [ 0x63, 0x5a, 0xb5, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "bge a0, a1, 20" + + - + input: + bytes: [ 0x63, 0x7c, 0xd6, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "bgeu a2, a3, 24" + + - + input: + bytes: [ 0x03, 0x87, 0x97, 0x01 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "lb a4, 25(a5)" + + - + input: + bytes: [ 0x03, 0x90, 0xa0, 0x01 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "lh zero, 26(ra)" + + - + input: + bytes: [ 0x03, 0xa1, 0xc1, 0x01 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "lw sp, 28(gp)" + + - + input: + bytes: [ 0x03, 0xc2, 0xd2, 0x01 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "lbu tp, 29(t0)" + + - + input: + bytes: [ 0x03, 0xd3, 0xe3, 0x01 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "lhu t1, 30(t2)" + + - + input: + bytes: [ 0xa3, 0x8f, 0x84, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "sb s0, 31(s1)" + + - + input: + bytes: [ 0x23, 0x90, 0xa5, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "sh a0, 32(a1)" + + - + input: + bytes: [ 0x23, 0xa2, 0xc6, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "sw a2, 36(a3)" + + - + input: + bytes: [ 0x13, 0x87, 0x57, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "addi a4, a5, 37" + + - + input: + bytes: [ 0x13, 0x25, 0xc6, 0xfe ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "slti a0, a2, -20" + + - + input: + bytes: [ 0x13, 0x42, 0xd3, 0xf9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "xori tp, t1, -99" + + - + input: + bytes: [ 0x13, 0xe5, 0x05, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "ori a0, a1, -2048" + + - + input: + bytes: [ 0x93, 0x70, 0xf1, 0x7f ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "andi ra, sp, 2047" + + - + input: + bytes: [ 0x13, 0x13, 0xf3, 0x01 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "slli t1, t1, 31" + + - + input: + bytes: [ 0x13, 0x55, 0x07, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "srli a0, a4, 0" + + - + input: + bytes: [ 0x93, 0x55, 0xf1, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "srai a1, sp, 15" + + - + input: + bytes: [ 0x93, 0x12, 0xd3, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "slli t0, t1, 13" + + - + input: + bytes: [ 0xb3, 0x00, 0x00, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "add ra, zero, zero" + + - + input: + bytes: [ 0xb3, 0x82, 0x63, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "sub t0, t2, t1" + + - + input: + bytes: [ 0xb3, 0x17, 0xd7, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "sll a5, a4, a3" + + - + input: + bytes: [ 0x33, 0x24, 0x84, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "slt s0, s0, s0" + + - + input: + bytes: [ 0xb3, 0x31, 0xb5, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "sltu gp, a0, a1" + + - + input: + bytes: [ 0xb3, 0x44, 0x94, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "xor s1, s0, s1" + + - + input: + bytes: [ 0x33, 0x55, 0x54, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "srl a0, s0, t0" + + - + input: + bytes: [ 0xb3, 0xd2, 0x06, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "sra t0, a3, zero" + + - + input: + bytes: [ 0xb3, 0x67, 0x13, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "or a5, t1, ra" + + - + input: + bytes: [ 0x33, 0xf5, 0xd4, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "and a0, s1, a3" + + - + input: + bytes: [ 0x0f, 0x00, 0xf0, 0x0f ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fence iorw, iorw" + + - + input: + bytes: [ 0x0f, 0x00, 0x30, 0x83 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fence.tso" + + - + input: + bytes: [ 0x0f, 0x10, 0x00, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fence.i" + + - + input: + bytes: [ 0x73, 0x00, 0x00, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "ecall" + + - + input: + bytes: [ 0x73, 0x00, 0x10, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "ebreak" + + - + input: + bytes: [ 0x73, 0x10, 0x00, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "unimp" + + - + input: + bytes: [ 0xf3, 0x12, 0xf3, 0xff ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrw t0, 4095, t1" + + - + input: + bytes: [ 0x73, 0x24, 0x00, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs s0, cycle, zero" + + - + input: + bytes: [ 0x73, 0xa4, 0x17, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs s0, fflags, a5" + + - + input: + bytes: [ 0x73, 0xb1, 0x00, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrc sp, 0, ra" + + - + input: + bytes: [ 0xf3, 0x57, 0x00, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrwi a5, 0, 0" + + - + input: + bytes: [ 0xf3, 0xe3, 0xff, 0xff ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrsi t2, 4095, 31" + + - + input: + bytes: [ 0x73, 0xf3, 0x02, 0x14 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrci t1, sscratch, 5" diff --git a/tests/MC/RISCV/rv32f_valid_riscv32_riscv_f_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rv32f_valid_riscv32_riscv_f_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..0a89d8849f --- /dev/null +++ b/tests/MC/RISCV/rv32f_valid_riscv32_riscv_f_syntax_no_alias_text.txt.yaml @@ -0,0 +1,480 @@ +test_cases: + - + input: + bytes: [ 0x07, 0x20, 0xc5, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "flw ft0, 12(a0)" + + - + input: + bytes: [ 0x87, 0xa0, 0x40, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "flw ft1, 4(ra)" + + - + input: + bytes: [ 0x07, 0xa1, 0x06, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "flw ft2, -2048(a3)" + + - + input: + bytes: [ 0x87, 0xa1, 0x04, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "flw ft3, -2048(s1)" + + - + input: + bytes: [ 0x07, 0x22, 0xf9, 0x7f ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "flw ft4, 2047(s2)" + + - + input: + bytes: [ 0x87, 0xa2, 0x09, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "flw ft5, 0(s3)" + + - + input: + bytes: [ 0xa7, 0x2f, 0x6a, 0x7e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsw ft6, 2047(s4)" + + - + input: + bytes: [ 0x27, 0xa0, 0x7a, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsw ft7, -2048(s5)" + + - + input: + bytes: [ 0x27, 0x20, 0x8b, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsw fs0, -2048(s6)" + + - + input: + bytes: [ 0xa7, 0xa3, 0x9b, 0x3e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsw fs1, 999(s7)" + + - + input: + bytes: [ 0x43, 0xf5, 0xc5, 0x68 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmadd.s fa0, fa1, fa2, fa3, dyn" + + - + input: + bytes: [ 0x47, 0xf7, 0x07, 0x89 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmsub.s fa4, fa5, fa6, fa7, dyn" + + - + input: + bytes: [ 0x4b, 0xf9, 0x49, 0xa9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fnmsub.s fs2, fs3, fs4, fs5, dyn" + + - + input: + bytes: [ 0x4f, 0xfb, 0x8b, 0xc9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fnmadd.s fs6, fs7, fs8, fs9, dyn" + + - + input: + bytes: [ 0x53, 0xfd, 0xcd, 0x01 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fadd.s fs10, fs11, ft8, dyn" + + - + input: + bytes: [ 0xd3, 0x7e, 0xff, 0x09 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsub.s ft9, ft10, ft11, dyn" + + - + input: + bytes: [ 0x53, 0xf0, 0x20, 0x10 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmul.s ft0, ft1, ft2, dyn" + + - + input: + bytes: [ 0xd3, 0x71, 0x52, 0x18 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fdiv.s ft3, ft4, ft5, dyn" + + - + input: + bytes: [ 0x53, 0xf3, 0x03, 0x58 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsqrt.s ft6, ft7, dyn" + + - + input: + bytes: [ 0xd3, 0x04, 0xb5, 0x20 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsgnj.s fs1, fa0, fa1" + + - + input: + bytes: [ 0xd3, 0x95, 0xe6, 0x20 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsgnjn.s fa1, fa3, fa4" + + - + input: + bytes: [ 0x53, 0xa7, 0xc6, 0x20 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsgnjx.s fa4, fa3, fa2" + + - + input: + bytes: [ 0xd3, 0x07, 0x18, 0x29 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmin.s fa5, fa6, fa7" + + - + input: + bytes: [ 0x53, 0x99, 0x49, 0x29 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmax.s fs2, fs3, fs4" + + - + input: + bytes: [ 0x53, 0xf5, 0x0a, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.w.s a0, fs5, dyn" + + - + input: + bytes: [ 0xd3, 0x75, 0x1b, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.wu.s a1, fs6, dyn" + + - + input: + bytes: [ 0x53, 0x86, 0x0b, 0xe0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmv.x.w a2, fs7" + + - + input: + bytes: [ 0xd3, 0x25, 0x9c, 0xa1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "feq.s a1, fs8, fs9" + + - + input: + bytes: [ 0x53, 0x16, 0xbd, 0xa1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "flt.s a2, fs10, fs11" + + - + input: + bytes: [ 0xd3, 0x06, 0xde, 0xa1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fle.s a3, ft8, ft9" + + - + input: + bytes: [ 0xd3, 0x16, 0x0f, 0xe0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fclass.s a3, ft10" + + - + input: + bytes: [ 0xd3, 0x7f, 0x07, 0xd0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.s.w ft11, a4, dyn" + + - + input: + bytes: [ 0x53, 0xf0, 0x17, 0xd0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.s.wu ft0, a5, dyn" + + - + input: + bytes: [ 0xd3, 0x00, 0x08, 0xf0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmv.w.x ft1, a6" + + - + input: + bytes: [ 0x43, 0x85, 0xc5, 0x68 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmadd.s fa0, fa1, fa2, fa3, rne" + + - + input: + bytes: [ 0x47, 0x97, 0x07, 0x89 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmsub.s fa4, fa5, fa6, fa7, rtz" + + - + input: + bytes: [ 0x4b, 0xa9, 0x49, 0xa9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fnmsub.s fs2, fs3, fs4, fs5, rdn" + + - + input: + bytes: [ 0x4f, 0xbb, 0x8b, 0xc9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fnmadd.s fs6, fs7, fs8, fs9, rup" + + - + input: + bytes: [ 0x43, 0xc5, 0xc5, 0x68 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmadd.s fa0, fa1, fa2, fa3, rmm" + + - + input: + bytes: [ 0x53, 0x8d, 0xcd, 0x01 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fadd.s fs10, fs11, ft8, rne" + + - + input: + bytes: [ 0xd3, 0x1e, 0xff, 0x09 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsub.s ft9, ft10, ft11, rtz" + + - + input: + bytes: [ 0x53, 0xa0, 0x20, 0x10 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmul.s ft0, ft1, ft2, rdn" + + - + input: + bytes: [ 0xd3, 0x31, 0x52, 0x18 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fdiv.s ft3, ft4, ft5, rup" + + - + input: + bytes: [ 0x53, 0xc3, 0x03, 0x58 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsqrt.s ft6, ft7, rmm" + + - + input: + bytes: [ 0x53, 0xb5, 0x0a, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.w.s a0, fs5, rup" + + - + input: + bytes: [ 0xd3, 0x25, 0x1b, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.wu.s a1, fs6, rdn" + + - + input: + bytes: [ 0xd3, 0x1f, 0x07, 0xd0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.s.w ft11, a4, rtz" + + - + input: + bytes: [ 0x53, 0x80, 0x17, 0xd0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.s.wu ft0, a5, rne" diff --git a/tests/MC/RISCV/rv32fc_valid_riscv32_riscv_c_riscv_f_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rv32fc_valid_riscv32_riscv_c_riscv_f_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..85e5a7808d --- /dev/null +++ b/tests/MC/RISCV/rv32fc_valid_riscv32_riscv_c_riscv_f_syntax_no_alias_text.txt.yaml @@ -0,0 +1,40 @@ +test_cases: + - + input: + bytes: [ 0x7e, 0x74 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.flwsp fs0, 252(sp)" + + - + input: + bytes: [ 0xc6, 0xff ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.fswsp fa7, 252(sp)" + + - + input: + bytes: [ 0xf4, 0x7f ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.flw fa3, 124(a5)" + + - + input: + bytes: [ 0xf0, 0xfd ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.fsw fa2, 124(a1)" diff --git a/tests/MC/RISCV/rv32i_only_valid_riscv32_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rv32i_only_valid_riscv32_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..b545ca248d --- /dev/null +++ b/tests/MC/RISCV/rv32i_only_valid_riscv32_syntax_no_alias_text.txt.yaml @@ -0,0 +1,40 @@ +test_cases: + - + input: + bytes: [ 0x13, 0x85, 0xf5, 0xff ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "addi a0, a1, -1" + + - + input: + bytes: [ 0x13, 0xe6, 0x06, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "ori a2, a3, -2048" + + - + input: + bytes: [ 0x83, 0x25, 0xb6, 0x9a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "lw a1, -1621(a2)" + + - + input: + bytes: [ 0x23, 0x2c, 0xb6, 0xfe ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "sw a1, -8(a2)" diff --git a/tests/MC/RISCV/rv32i_valid_riscv32_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rv32i_valid_riscv32_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..6fdf880d9d --- /dev/null +++ b/tests/MC/RISCV/rv32i_valid_riscv32_syntax_no_alias_text.txt.yaml @@ -0,0 +1,850 @@ +test_cases: + - + input: + bytes: [ 0x37, 0x25, 0x00, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "lui a0, 2" + + - + input: + bytes: [ 0xb7, 0x0d, 0x00, 0x87 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "lui s11, 552960" + + - + input: + bytes: [ 0x37, 0x05, 0x00, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "lui a0, 0" + + - + input: + bytes: [ 0xb7, 0xf2, 0xff, 0xff ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "lui t0, 1048575" + + - + input: + bytes: [ 0xb7, 0x01, 0x00, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "lui gp, 0" + + - + input: + bytes: [ 0x37, 0xe5, 0x01, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "lui a0, 30" + + - + input: + bytes: [ 0x37, 0xf5, 0x01, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "lui a0, 31" + + - + input: + bytes: [ 0x17, 0x25, 0x00, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "auipc a0, 2" + + - + input: + bytes: [ 0x97, 0x0d, 0x00, 0x87 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "auipc s11, 552960" + + - + input: + bytes: [ 0x97, 0xf2, 0xff, 0xff ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "auipc t0, 1048575" + + - + input: + bytes: [ 0x97, 0x01, 0x00, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "auipc gp, 0" + + - + input: + bytes: [ 0x17, 0xe5, 0x01, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "auipc a0, 30" + + - + input: + bytes: [ 0x6f, 0xf6, 0xff, 0x7f ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "jal a2, 1048574" + + - + input: + bytes: [ 0xef, 0x06, 0x00, 0x10 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "jal a3, 256" + + - + input: + bytes: [ 0x6f, 0x05, 0xe0, 0x01 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "jal a0, 30" + + - + input: + bytes: [ 0x6f, 0x04, 0x00, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "jal s0, 0" + + - + input: + bytes: [ 0x6f, 0x04, 0xc0, 0x09 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "jal s0, 156" + + - + input: + bytes: [ 0x67, 0x85, 0x05, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "jalr a0, -2048(a1)" + + - + input: + bytes: [ 0xe7, 0x03, 0xf3, 0x7f ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "jalr t2, 2047(t1)" + + - + input: + bytes: [ 0x67, 0x01, 0x00, 0x10 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "jalr sp, 256(zero)" + + - + input: + bytes: [ 0xe7, 0x05, 0xe6, 0x01 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "jalr a1, 30(a2)" + + - + input: + bytes: [ 0x63, 0x83, 0x94, 0x06 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "beq s1, s1, 102" + + - + input: + bytes: [ 0x63, 0x10, 0xf7, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "bne a4, a5, -4096" + + - + input: + bytes: [ 0xe3, 0x4f, 0x31, 0x7e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "blt sp, gp, 4094" + + - + input: + bytes: [ 0xe3, 0x50, 0x19, 0xf2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "bge s2, ra, -224" + + - + input: + bytes: [ 0x63, 0x60, 0x00, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "bltu zero, zero, 0" + + - + input: + bytes: [ 0x63, 0x70, 0x2c, 0x20 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "bgeu s8, sp, 512" + + - + input: + bytes: [ 0x63, 0xff, 0x62, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "bgeu t0, t1, 30" + + - + input: + bytes: [ 0x83, 0x89, 0x40, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "lb s3, 4(ra)" + + - + input: + bytes: [ 0x03, 0x13, 0x00, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "lh t1, -2048(zero)" + + - + input: + bytes: [ 0x03, 0x13, 0x00, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "lh t1, 0(zero)" + + - + input: + bytes: [ 0x03, 0x11, 0xf5, 0x7f ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "lh sp, 2047(a0)" + + - + input: + bytes: [ 0x03, 0x25, 0x16, 0x06 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "lw a0, 97(a2)" + + - + input: + bytes: [ 0x83, 0x02, 0xe3, 0x01 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "lb t0, 30(t1)" + + - + input: + bytes: [ 0x03, 0x84, 0x04, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "lb s0, 0(s1)" + + - + input: + bytes: [ 0x03, 0x84, 0xc4, 0x09 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "lb s0, 156(s1)" + + - + input: + bytes: [ 0xa3, 0x0f, 0xa6, 0x7e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "sb a0, 2047(a2)" + + - + input: + bytes: [ 0x23, 0x10, 0xcf, 0x81 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "sh t3, -2048(t5)" + + - + input: + bytes: [ 0x23, 0x10, 0xcf, 0x01 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "sh t3, 0(t5)" + + - + input: + bytes: [ 0xa3, 0x23, 0x10, 0x3e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "sw ra, 999(zero)" + + - + input: + bytes: [ 0x23, 0xaf, 0xa2, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "sw a0, 30(t0)" + + - + input: + bytes: [ 0x23, 0xa0, 0x84, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "sw s0, 0(s1)" + + - + input: + bytes: [ 0x23, 0xae, 0x84, 0x08 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "sw s0, 156(s1)" + + - + input: + bytes: [ 0x93, 0x00, 0x21, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "addi ra, sp, 2" + + - + input: + bytes: [ 0x93, 0x00, 0xe1, 0x01 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "addi ra, sp, 30" + + - + input: + bytes: [ 0x93, 0x00, 0x01, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "addi ra, sp, 0" + + - + input: + bytes: [ 0x93, 0x00, 0xc1, 0x09 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "addi ra, sp, 156" + + - + input: + bytes: [ 0x13, 0x25, 0xc6, 0xfe ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "slti a0, a2, -20" + + - + input: + bytes: [ 0x13, 0xb9, 0x09, 0x05 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "sltiu s2, s3, 80" + + - + input: + bytes: [ 0x13, 0x42, 0xd3, 0xf9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "xori tp, t1, -99" + + - + input: + bytes: [ 0x13, 0xe5, 0x05, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "ori a0, a1, -2048" + + - + input: + bytes: [ 0x13, 0xe5, 0x05, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "ori a0, a1, 0" + + - + input: + bytes: [ 0x93, 0x70, 0xf1, 0x7f ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "andi ra, sp, 2047" + + - + input: + bytes: [ 0x13, 0x1e, 0xfe, 0x01 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "slli t3, t3, 31" + + - + input: + bytes: [ 0x13, 0x55, 0x07, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "srli a0, a4, 0" + + - + input: + bytes: [ 0x13, 0x56, 0xf1, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "srai a2, sp, 15" + + - + input: + bytes: [ 0x13, 0x1e, 0xee, 0x01 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "slli t3, t3, 30" + + - + input: + bytes: [ 0xb3, 0x00, 0x00, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "add ra, zero, zero" + + - + input: + bytes: [ 0xb3, 0x82, 0x63, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "sub t0, t2, t1" + + - + input: + bytes: [ 0xb3, 0x17, 0xd7, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "sll a5, a4, a3" + + - + input: + bytes: [ 0x33, 0x24, 0x84, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "slt s0, s0, s0" + + - + input: + bytes: [ 0xb3, 0x31, 0xb5, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "sltu gp, a0, a1" + + - + input: + bytes: [ 0x33, 0x49, 0x89, 0x01 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "xor s2, s2, s8" + + - + input: + bytes: [ 0x33, 0x55, 0x54, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "srl a0, s0, t0" + + - + input: + bytes: [ 0xb3, 0x52, 0x09, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "sra t0, s2, zero" + + - + input: + bytes: [ 0x33, 0x6d, 0x13, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "or s10, t1, ra" + + - + input: + bytes: [ 0x33, 0x75, 0x39, 0x01 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "and a0, s2, s3" + + - + input: + bytes: [ 0x0f, 0x00, 0xf0, 0x0f ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fence iorw, iorw" + + - + input: + bytes: [ 0x0f, 0x00, 0x30, 0x0c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fence io, rw" + + - + input: + bytes: [ 0x0f, 0x00, 0x10, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fence r, w" + + - + input: + bytes: [ 0x0f, 0x00, 0xa0, 0x01 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fence w, ir" + + - + input: + bytes: [ 0x0f, 0x00, 0x30, 0x83 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fence.tso" + + - + input: + bytes: [ 0x0f, 0x10, 0x00, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fence.i" + + - + input: + bytes: [ 0x73, 0x00, 0x00, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "ecall" + + - + input: + bytes: [ 0x73, 0x00, 0x10, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "ebreak" + + - + input: + bytes: [ 0x73, 0x10, 0x00, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "unimp" + + - + input: + bytes: [ 0xf3, 0x12, 0xf3, 0xff ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrw t0, 4095, t1" + + - + input: + bytes: [ 0x73, 0x94, 0xf4, 0xff ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrw s0, 4095, s1" + + - + input: + bytes: [ 0x73, 0x94, 0x14, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrw s0, fflags, s1" + + - + input: + bytes: [ 0x73, 0x24, 0x00, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs s0, cycle, zero" + + - + input: + bytes: [ 0xf3, 0xa9, 0x1a, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs s3, fflags, s5" + + - + input: + bytes: [ 0x73, 0xb1, 0x00, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrc sp, 0, ra" + + - + input: + bytes: [ 0xf3, 0x57, 0x00, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrwi a5, 0, 0" + + - + input: + bytes: [ 0xf3, 0xe3, 0xff, 0xff ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrsi t2, 4095, 31" + + - + input: + bytes: [ 0x73, 0xf3, 0x02, 0x14 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrci t1, sscratch, 5" diff --git a/tests/MC/RISCV/rv32ih_aliases_valid_riscv32_h_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rv32ih_aliases_valid_riscv32_h_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..a87f5edcfb --- /dev/null +++ b/tests/MC/RISCV/rv32ih_aliases_valid_riscv32_h_syntax_no_alias_text.txt.yaml @@ -0,0 +1,140 @@ +test_cases: + - + input: + bytes: [ 0x73, 0x00, 0x00, 0x62 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "h", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "hfence.gvma zero, zero" + + - + input: + bytes: [ 0x73, 0x00, 0x05, 0x62 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "h", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "hfence.gvma a0, zero" + + - + input: + bytes: [ 0x73, 0x00, 0x00, 0x22 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "h", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "hfence.vvma zero, zero" + + - + input: + bytes: [ 0x73, 0x00, 0x05, 0x22 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "h", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "hfence.vvma a0, zero" + + - + input: + bytes: [ 0x73, 0xc5, 0x05, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "h", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "hlv.b a0, (a1)" + + - + input: + bytes: [ 0x73, 0xc5, 0x15, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "h", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "hlv.bu a0, (a1)" + + - + input: + bytes: [ 0xf3, 0x45, 0x06, 0x64 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "h", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "hlv.h a1, (a2)" + + - + input: + bytes: [ 0xf3, 0xc5, 0x15, 0x64 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "h", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "hlv.hu a1, (a1)" + + - + input: + bytes: [ 0xf3, 0x45, 0x36, 0x64 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "h", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "hlvx.hu a1, (a2)" + + - + input: + bytes: [ 0x73, 0x46, 0x06, 0x68 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "h", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "hlv.w a2, (a2)" + + - + input: + bytes: [ 0x73, 0xc6, 0x36, 0x68 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "h", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "hlvx.wu a2, (a3)" + + - + input: + bytes: [ 0x73, 0xc0, 0xa5, 0x62 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "h", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "hsv.b a0, (a1)" + + - + input: + bytes: [ 0x73, 0xc0, 0xa5, 0x66 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "h", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "hsv.h a0, (a1)" + + - + input: + bytes: [ 0x73, 0xc0, 0xa5, 0x6a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "h", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "hsv.w a0, (a1)" diff --git a/tests/MC/RISCV/rv32ih_valid_riscv32_h_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rv32ih_valid_riscv32_h_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..b926ace241 --- /dev/null +++ b/tests/MC/RISCV/rv32ih_valid_riscv32_h_syntax_no_alias_text.txt.yaml @@ -0,0 +1,140 @@ +test_cases: + - + input: + bytes: [ 0x73, 0x00, 0x00, 0x22 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "h", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "hfence.vvma zero, zero" + + - + input: + bytes: [ 0x73, 0x00, 0xb5, 0x22 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "h", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "hfence.vvma a0, a1" + + - + input: + bytes: [ 0x73, 0x00, 0x00, 0x62 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "h", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "hfence.gvma zero, zero" + + - + input: + bytes: [ 0x73, 0x00, 0xb5, 0x62 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "h", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "hfence.gvma a0, a1" + + - + input: + bytes: [ 0x73, 0xc5, 0x05, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "h", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "hlv.b a0, (a1)" + + - + input: + bytes: [ 0x73, 0xc5, 0x15, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "h", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "hlv.bu a0, (a1)" + + - + input: + bytes: [ 0xf3, 0x45, 0x06, 0x64 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "h", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "hlv.h a1, (a2)" + + - + input: + bytes: [ 0xf3, 0xc5, 0x15, 0x64 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "h", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "hlv.hu a1, (a1)" + + - + input: + bytes: [ 0xf3, 0x45, 0x36, 0x64 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "h", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "hlvx.hu a1, (a2)" + + - + input: + bytes: [ 0x73, 0x46, 0x06, 0x68 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "h", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "hlv.w a2, (a2)" + + - + input: + bytes: [ 0x73, 0xc6, 0x36, 0x68 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "h", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "hlvx.wu a2, (a3)" + + - + input: + bytes: [ 0x73, 0xc0, 0xa5, 0x62 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "h", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "hsv.b a0, (a1)" + + - + input: + bytes: [ 0x73, 0xc0, 0xa5, 0x66 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "h", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "hsv.h a0, (a1)" + + - + input: + bytes: [ 0x73, 0xc0, 0xa5, 0x6a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "h", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "hsv.w a0, (a1)" diff --git a/tests/MC/RISCV/rv32m_valid_riscv32_m_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rv32m_valid_riscv32_m_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..4c8e89a944 --- /dev/null +++ b/tests/MC/RISCV/rv32m_valid_riscv32_m_syntax_no_alias_text.txt.yaml @@ -0,0 +1,80 @@ +test_cases: + - + input: + bytes: [ 0x33, 0x87, 0x80, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "m", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "mul a4, ra, s0" + + - + input: + bytes: [ 0xb3, 0x10, 0x00, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "m", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "mulh ra, zero, zero" + + - + input: + bytes: [ 0xb3, 0xa2, 0x63, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "m", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "mulhsu t0, t2, t1" + + - + input: + bytes: [ 0xb3, 0x37, 0xd7, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "m", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "mulhu a5, a4, a3" + + - + input: + bytes: [ 0x33, 0x44, 0x84, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "m", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "div s0, s0, s0" + + - + input: + bytes: [ 0xb3, 0x51, 0xb5, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "m", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "divu gp, a0, a1" + + - + input: + bytes: [ 0x33, 0x69, 0x89, 0x03 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "m", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "rem s2, s2, s8" + + - + input: + bytes: [ 0x33, 0x79, 0x89, 0x03 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "m", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "remu s2, s2, s8" diff --git a/tests/MC/RISCV/rv32xtheadbs_valid_riscv32_riscv_xtheadbs.txt.yaml b/tests/MC/RISCV/rv32xtheadbs_valid_riscv32_riscv_xtheadbs.txt.yaml new file mode 100644 index 0000000000..be408e75bd --- /dev/null +++ b/tests/MC/RISCV/rv32xtheadbs_valid_riscv32_riscv_xtheadbs.txt.yaml @@ -0,0 +1,20 @@ +test_cases: + - + input: + bytes: [ 0x8b, 0x12, 0x13, 0x88 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADBS" ] + expected: + insns: + - + asm_text: "th.tst t0, t1, 1" + + - + input: + bytes: [ 0x8b, 0x12, 0xf3, 0x89 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADBS" ] + expected: + insns: + - + asm_text: "th.tst t0, t1, 31" diff --git a/tests/MC/RISCV/rv32xtheadfmemidx_valid_riscv32_riscv_d_riscv_xtheadfmemidx.txt.yaml b/tests/MC/RISCV/rv32xtheadfmemidx_valid_riscv32_riscv_d_riscv_xtheadfmemidx.txt.yaml new file mode 100644 index 0000000000..fb592628c0 --- /dev/null +++ b/tests/MC/RISCV/rv32xtheadfmemidx_valid_riscv32_riscv_d_riscv_xtheadfmemidx.txt.yaml @@ -0,0 +1,80 @@ +test_cases: + - + input: + bytes: [ 0x0b, 0xe5, 0xc5, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_D", "CS_MODE_RISCV_XTHEADFMEMIDX" ] + expected: + insns: + - + asm_text: "th.flrd fa0, a1, a2, 0" + + - + input: + bytes: [ 0x0b, 0xe5, 0xc5, 0x66 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_D", "CS_MODE_RISCV_XTHEADFMEMIDX" ] + expected: + insns: + - + asm_text: "th.flrd fa0, a1, a2, 3" + + - + input: + bytes: [ 0x0b, 0xe5, 0xc5, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_D", "CS_MODE_RISCV_XTHEADFMEMIDX" ] + expected: + insns: + - + asm_text: "th.flrw fa0, a1, a2, 0" + + - + input: + bytes: [ 0x0b, 0xe5, 0xc5, 0x46 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_D", "CS_MODE_RISCV_XTHEADFMEMIDX" ] + expected: + insns: + - + asm_text: "th.flrw fa0, a1, a2, 3" + + - + input: + bytes: [ 0x0b, 0xf5, 0xc5, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_D", "CS_MODE_RISCV_XTHEADFMEMIDX" ] + expected: + insns: + - + asm_text: "th.fsrd fa0, a1, a2, 0" + + - + input: + bytes: [ 0x0b, 0xf5, 0xc5, 0x66 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_D", "CS_MODE_RISCV_XTHEADFMEMIDX" ] + expected: + insns: + - + asm_text: "th.fsrd fa0, a1, a2, 3" + + - + input: + bytes: [ 0x0b, 0xf5, 0xc5, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_D", "CS_MODE_RISCV_XTHEADFMEMIDX" ] + expected: + insns: + - + asm_text: "th.fsrw fa0, a1, a2, 0" + + - + input: + bytes: [ 0x0b, 0xf5, 0xc5, 0x46 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_D", "CS_MODE_RISCV_XTHEADFMEMIDX" ] + expected: + insns: + - + asm_text: "th.fsrw fa0, a1, a2, 3" diff --git a/tests/MC/RISCV/rv32xtheadmac_valid_riscv32_riscv_xtheadmac.txt.yaml b/tests/MC/RISCV/rv32xtheadmac_valid_riscv32_riscv_xtheadmac.txt.yaml new file mode 100644 index 0000000000..7f98b699ab --- /dev/null +++ b/tests/MC/RISCV/rv32xtheadmac_valid_riscv32_riscv_xtheadmac.txt.yaml @@ -0,0 +1,40 @@ +test_cases: + - + input: + bytes: [ 0x0b, 0x95, 0xc5, 0x20 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADMAC" ] + expected: + insns: + - + asm_text: "th.mula a0, a1, a2" + + - + input: + bytes: [ 0x0b, 0x95, 0xc5, 0x28 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADMAC" ] + expected: + insns: + - + asm_text: "th.mulah a0, a1, a2" + + - + input: + bytes: [ 0x0b, 0x95, 0xc5, 0x22 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADMAC" ] + expected: + insns: + - + asm_text: "th.muls a0, a1, a2" + + - + input: + bytes: [ 0x0b, 0x95, 0xc5, 0x2a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADMAC" ] + expected: + insns: + - + asm_text: "th.mulsh a0, a1, a2" diff --git a/tests/MC/RISCV/rv32xtheadmemidx_valid_riscv32_riscv_xtheadmemidx.txt.yaml b/tests/MC/RISCV/rv32xtheadmemidx_valid_riscv32_riscv_xtheadmemidx.txt.yaml new file mode 100644 index 0000000000..c26c95b8ee --- /dev/null +++ b/tests/MC/RISCV/rv32xtheadmemidx_valid_riscv32_riscv_xtheadmemidx.txt.yaml @@ -0,0 +1,320 @@ +test_cases: + - + input: + bytes: [ 0x0b, 0xc5, 0x05, 0x5c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.lwia a0, (a1), 0, 2" + + - + input: + bytes: [ 0x0b, 0xc5, 0x05, 0x4f ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.lwib a0, (a1), -16, 3" + + - + input: + bytes: [ 0x0b, 0xc5, 0x05, 0x3c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.lhia a0, (a1), 0, 2" + + - + input: + bytes: [ 0x0b, 0xc5, 0x05, 0x2f ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.lhib a0, (a1), -16, 3" + + - + input: + bytes: [ 0x0b, 0xc5, 0x05, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.lhuia a0, (a1), 0, 0" + + - + input: + bytes: [ 0x0b, 0xc5, 0xf5, 0xaa ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.lhuib a0, (a1), 15, 1" + + - + input: + bytes: [ 0x0b, 0xc5, 0x05, 0x1c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.lbia a0, (a1), 0, 2" + + - + input: + bytes: [ 0x0b, 0xc5, 0x05, 0x0f ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.lbib a0, (a1), -16, 3" + + - + input: + bytes: [ 0x0b, 0xc5, 0x05, 0x98 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.lbuia a0, (a1), 0, 0" + + - + input: + bytes: [ 0x0b, 0xc5, 0xf5, 0x8a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.lbuib a0, (a1), 15, 1" + + - + input: + bytes: [ 0x0b, 0xd5, 0x05, 0x5c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.swia a0, (a1), 0, 2" + + - + input: + bytes: [ 0x0b, 0xd5, 0x15, 0x4e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.swib a0, (a1), 1, 3" + + - + input: + bytes: [ 0x0b, 0xd5, 0x45, 0x38 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.shia a0, (a1), 4, 0" + + - + input: + bytes: [ 0x0b, 0xd5, 0xd5, 0x2a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.shib a0, (a1), 13, 1" + + - + input: + bytes: [ 0x0b, 0xd5, 0xe5, 0x1c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.sbia a0, (a1), 14, 2" + + - + input: + bytes: [ 0x0b, 0xd5, 0xf5, 0x0e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.sbib a0, (a1), 15, 3" + + - + input: + bytes: [ 0x0b, 0xc5, 0xc5, 0x42 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.lrw a0, a1, a2, 1" + + - + input: + bytes: [ 0x0b, 0xc5, 0xc5, 0x26 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.lrh a0, a1, a2, 3" + + - + input: + bytes: [ 0x0b, 0xc5, 0xc5, 0xa0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.lrhu a0, a1, a2, 0" + + - + input: + bytes: [ 0x0b, 0xc5, 0xc5, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.lrb a0, a1, a2, 1" + + - + input: + bytes: [ 0x0b, 0xc5, 0xc5, 0x84 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.lrbu a0, a1, a2, 2" + + - + input: + bytes: [ 0x0b, 0xd5, 0xc5, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.srw a0, a1, a2, 0" + + - + input: + bytes: [ 0x0b, 0xd5, 0xc5, 0x22 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.srh a0, a1, a2, 1" + + - + input: + bytes: [ 0x0b, 0xd5, 0xc5, 0x04 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.srb a0, a1, a2, 2" + + - + input: + bytes: [ 0x0b, 0xc5, 0xc5, 0x52 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.lurw a0, a1, a2, 1" + + - + input: + bytes: [ 0x0b, 0xc5, 0xc5, 0x36 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.lurh a0, a1, a2, 3" + + - + input: + bytes: [ 0x0b, 0xc5, 0xc5, 0xb0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.lurhu a0, a1, a2, 0" + + - + input: + bytes: [ 0x0b, 0xc5, 0xc5, 0x12 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.lurb a0, a1, a2, 1" + + - + input: + bytes: [ 0x0b, 0xc5, 0xc5, 0x94 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.lurbu a0, a1, a2, 2" + + - + input: + bytes: [ 0x0b, 0xd5, 0xc5, 0x50 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.surw a0, a1, a2, 0" + + - + input: + bytes: [ 0x0b, 0xd5, 0xc5, 0x32 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.surh a0, a1, a2, 1" + + - + input: + bytes: [ 0x0b, 0xd5, 0xc5, 0x14 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.surb a0, a1, a2, 2" diff --git a/tests/MC/RISCV/rv32xtheadmempair_valid_riscv32_riscv_xtheadmempair.txt.yaml b/tests/MC/RISCV/rv32xtheadmempair_valid_riscv32_riscv_xtheadmempair.txt.yaml new file mode 100644 index 0000000000..2862f40e2f --- /dev/null +++ b/tests/MC/RISCV/rv32xtheadmempair_valid_riscv32_riscv_xtheadmempair.txt.yaml @@ -0,0 +1,30 @@ +test_cases: + - + input: + bytes: [ 0x0b, 0x45, 0xb6, 0xe2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADMEMPAIR" ] + expected: + insns: + - + asm_text: "th.lwd a0, a1, (a2), 1, 3" + + - + input: + bytes: [ 0x0b, 0x45, 0xb6, 0xf4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADMEMPAIR" ] + expected: + insns: + - + asm_text: "th.lwud a0, a1, (a2), 2, 3" + + - + input: + bytes: [ 0x0b, 0x55, 0xb6, 0xe0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADMEMPAIR" ] + expected: + insns: + - + asm_text: "th.swd a0, a1, (a2), 0, 3" diff --git a/tests/MC/RISCV/rv32zaamo_valid_riscv32_riscv_a_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rv32zaamo_valid_riscv32_riscv_a_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..33443648eb --- /dev/null +++ b/tests/MC/RISCV/rv32zaamo_valid_riscv32_riscv_a_syntax_no_alias_text.txt.yaml @@ -0,0 +1,360 @@ +test_cases: + - + input: + bytes: [ 0x2f, 0x27, 0x14, 0x08 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amoswap.w a4, ra, (s0)" + + - + input: + bytes: [ 0xaf, 0xa5, 0xc6, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amoadd.w a1, a2, (a3)" + + - + input: + bytes: [ 0x2f, 0x26, 0xd7, 0x20 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amoxor.w a2, a3, (a4)" + + - + input: + bytes: [ 0xaf, 0xa6, 0xe7, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amoand.w a3, a4, (a5)" + + - + input: + bytes: [ 0x2f, 0x27, 0xf8, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amoor.w a4, a5, (a6)" + + - + input: + bytes: [ 0xaf, 0xa7, 0x08, 0x81 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amomin.w a5, a6, (a7)" + + - + input: + bytes: [ 0xaf, 0xab, 0x6a, 0xa1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amomax.w s7, s6, (s5)" + + - + input: + bytes: [ 0x2f, 0x2b, 0x5a, 0xc1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amominu.w s6, s5, (s4)" + + - + input: + bytes: [ 0xaf, 0xaa, 0x49, 0xe1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amomaxu.w s5, s4, (s3)" + + - + input: + bytes: [ 0x2f, 0x27, 0x14, 0x0c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amoswap.w.aq a4, ra, (s0)" + + - + input: + bytes: [ 0xaf, 0xa5, 0xc6, 0x04 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amoadd.w.aq a1, a2, (a3)" + + - + input: + bytes: [ 0x2f, 0x26, 0xd7, 0x24 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amoxor.w.aq a2, a3, (a4)" + + - + input: + bytes: [ 0xaf, 0xa6, 0xe7, 0x64 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amoand.w.aq a3, a4, (a5)" + + - + input: + bytes: [ 0x2f, 0x27, 0xf8, 0x44 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amoor.w.aq a4, a5, (a6)" + + - + input: + bytes: [ 0xaf, 0xa7, 0x08, 0x85 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amomin.w.aq a5, a6, (a7)" + + - + input: + bytes: [ 0xaf, 0xab, 0x6a, 0xa5 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amomax.w.aq s7, s6, (s5)" + + - + input: + bytes: [ 0x2f, 0x2b, 0x5a, 0xc5 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amominu.w.aq s6, s5, (s4)" + + - + input: + bytes: [ 0xaf, 0xaa, 0x49, 0xe5 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amomaxu.w.aq s5, s4, (s3)" + + - + input: + bytes: [ 0x2f, 0x27, 0x14, 0x0a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amoswap.w.rl a4, ra, (s0)" + + - + input: + bytes: [ 0xaf, 0xa5, 0xc6, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amoadd.w.rl a1, a2, (a3)" + + - + input: + bytes: [ 0x2f, 0x26, 0xd7, 0x22 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amoxor.w.rl a2, a3, (a4)" + + - + input: + bytes: [ 0xaf, 0xa6, 0xe7, 0x62 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amoand.w.rl a3, a4, (a5)" + + - + input: + bytes: [ 0x2f, 0x27, 0xf8, 0x42 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amoor.w.rl a4, a5, (a6)" + + - + input: + bytes: [ 0xaf, 0xa7, 0x08, 0x83 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amomin.w.rl a5, a6, (a7)" + + - + input: + bytes: [ 0xaf, 0xab, 0x6a, 0xa3 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amomax.w.rl s7, s6, (s5)" + + - + input: + bytes: [ 0x2f, 0x2b, 0x5a, 0xc3 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amominu.w.rl s6, s5, (s4)" + + - + input: + bytes: [ 0xaf, 0xaa, 0x49, 0xe3 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amomaxu.w.rl s5, s4, (s3)" + + - + input: + bytes: [ 0x2f, 0x27, 0x14, 0x0e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amoswap.w.aqrl a4, ra, (s0)" + + - + input: + bytes: [ 0xaf, 0xa5, 0xc6, 0x06 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amoadd.w.aqrl a1, a2, (a3)" + + - + input: + bytes: [ 0x2f, 0x26, 0xd7, 0x26 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amoxor.w.aqrl a2, a3, (a4)" + + - + input: + bytes: [ 0xaf, 0xa6, 0xe7, 0x66 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amoand.w.aqrl a3, a4, (a5)" + + - + input: + bytes: [ 0x2f, 0x27, 0xf8, 0x46 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amoor.w.aqrl a4, a5, (a6)" + + - + input: + bytes: [ 0xaf, 0xa7, 0x08, 0x87 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amomin.w.aqrl a5, a6, (a7)" + + - + input: + bytes: [ 0xaf, 0xab, 0x6a, 0xa7 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amomax.w.aqrl s7, s6, (s5)" + + - + input: + bytes: [ 0x2f, 0x2b, 0x5a, 0xc7 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amominu.w.aqrl s6, s5, (s4)" + + - + input: + bytes: [ 0xaf, 0xaa, 0x49, 0xe7 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amomaxu.w.aqrl s5, s4, (s3)" diff --git a/tests/MC/RISCV/rv32zacas_valid_riscv32_experimental_zacas_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rv32zacas_valid_riscv32_experimental_zacas_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..d967342e7b --- /dev/null +++ b/tests/MC/RISCV/rv32zacas_valid_riscv32_experimental_zacas_syntax_no_alias_text.txt.yaml @@ -0,0 +1,100 @@ +test_cases: + - + input: + bytes: [ 0xaf, 0xa5, 0xd7, 0x28 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "experimental-zacas", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amocas.w a1, a3, (a5)" + + - + input: + bytes: [ 0x2f, 0xa0, 0x07, 0x28 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "experimental-zacas", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amocas.w zero, zero, (a5)" + + - + input: + bytes: [ 0x2f, 0xa0, 0x07, 0x2c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "experimental-zacas", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amocas.w.aq zero, zero, (a5)" + + - + input: + bytes: [ 0x2f, 0xa0, 0x07, 0x2a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "experimental-zacas", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amocas.w.rl zero, zero, (a5)" + + - + input: + bytes: [ 0x2f, 0xa0, 0x07, 0x2e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "experimental-zacas", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amocas.w.aqrl zero, zero, (a5)" + + - + input: + bytes: [ 0x2f, 0xb5, 0xc5, 0x28 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "experimental-zacas", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amocas.d a0, a2, (a1)" + + - + input: + bytes: [ 0x2f, 0xb0, 0x05, 0x28 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "experimental-zacas", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amocas.d zero, zero, (a1)" + + - + input: + bytes: [ 0x2f, 0xb0, 0x05, 0x2c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "experimental-zacas", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amocas.d.aq zero, zero, (a1)" + + - + input: + bytes: [ 0x2f, 0xb0, 0x05, 0x2a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "experimental-zacas", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amocas.d.rl zero, zero, (a1)" + + - + input: + bytes: [ 0x2f, 0xb0, 0x05, 0x2e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "experimental-zacas", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amocas.d.aqrl zero, zero, (a1)" diff --git a/tests/MC/RISCV/rv32zalrsc_valid_riscv32_riscv_a_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rv32zalrsc_valid_riscv32_riscv_a_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..6e79bf0daa --- /dev/null +++ b/tests/MC/RISCV/rv32zalrsc_valid_riscv32_riscv_a_syntax_no_alias_text.txt.yaml @@ -0,0 +1,80 @@ +test_cases: + - + input: + bytes: [ 0xaf, 0x22, 0x03, 0x10 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "lr.w t0, (t1)" + + - + input: + bytes: [ 0x2f, 0xa3, 0x03, 0x14 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "lr.w.aq t1, (t2)" + + - + input: + bytes: [ 0xaf, 0x23, 0x0e, 0x12 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "lr.w.rl t2, (t3)" + + - + input: + bytes: [ 0x2f, 0xae, 0x0e, 0x16 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "lr.w.aqrl t3, (t4)" + + - + input: + bytes: [ 0xaf, 0xaf, 0xee, 0x19 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "sc.w t6, t5, (t4)" + + - + input: + bytes: [ 0x2f, 0x2f, 0xde, 0x1d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "sc.w.aq t5, t4, (t3)" + + - + input: + bytes: [ 0xaf, 0xae, 0xc3, 0x1b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "sc.w.rl t4, t3, (t2)" + + - + input: + bytes: [ 0x2f, 0x2e, 0x73, 0x1e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "sc.w.aqrl t3, t2, (t1)" diff --git a/tests/MC/RISCV/rv32zba_valid_riscv32_riscv_zba.txt.yaml b/tests/MC/RISCV/rv32zba_valid_riscv32_riscv_zba.txt.yaml new file mode 100644 index 0000000000..c464856081 --- /dev/null +++ b/tests/MC/RISCV/rv32zba_valid_riscv32_riscv_zba.txt.yaml @@ -0,0 +1,30 @@ +test_cases: + - + input: + bytes: [ 0xb3, 0x22, 0x73, 0x20 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZBA" ] + expected: + insns: + - + asm_text: "sh1add t0, t1, t2" + + - + input: + bytes: [ 0xb3, 0x42, 0x73, 0x20 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZBA" ] + expected: + insns: + - + asm_text: "sh2add t0, t1, t2" + + - + input: + bytes: [ 0xb3, 0x62, 0x73, 0x20 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZBA" ] + expected: + insns: + - + asm_text: "sh3add t0, t1, t2" diff --git a/tests/MC/RISCV/rv32zbb_only_valid_riscv32_riscv_zbb_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rv32zbb_only_valid_riscv32_riscv_zbb_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..58d124b196 --- /dev/null +++ b/tests/MC/RISCV/rv32zbb_only_valid_riscv32_riscv_zbb_syntax_no_alias_text.txt.yaml @@ -0,0 +1,40 @@ +test_cases: + - + input: + bytes: [ 0xb3, 0x42, 0x03, 0x08 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZBB", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "zext.h t0, t1" + + - + input: + bytes: [ 0x93, 0x52, 0xf3, 0x61 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZBB", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "rori t0, t1, 31" + + - + input: + bytes: [ 0x93, 0x52, 0x03, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZBB", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "rori t0, t1, 0" + + - + input: + bytes: [ 0x93, 0x52, 0x83, 0x69 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZBB", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "rev8 t0, t1" diff --git a/tests/MC/RISCV/rv32zbb_valid_riscv32_riscv_zbb_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rv32zbb_valid_riscv32_riscv_zbb_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..21aaecd56d --- /dev/null +++ b/tests/MC/RISCV/rv32zbb_valid_riscv32_riscv_zbb_syntax_no_alias_text.txt.yaml @@ -0,0 +1,150 @@ +test_cases: + - + input: + bytes: [ 0x93, 0x12, 0x03, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZBB", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "clz t0, t1" + + - + input: + bytes: [ 0x93, 0x12, 0x13, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZBB", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "ctz t0, t1" + + - + input: + bytes: [ 0x93, 0x12, 0x23, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZBB", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cpop t0, t1" + + - + input: + bytes: [ 0x93, 0x12, 0x43, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZBB", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "sext.b t0, t1" + + - + input: + bytes: [ 0x93, 0x12, 0x53, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZBB", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "sext.h t0, t1" + + - + input: + bytes: [ 0xb3, 0x42, 0x73, 0x0a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZBB", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "min t0, t1, t2" + + - + input: + bytes: [ 0xb3, 0x52, 0x73, 0x0a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZBB", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "minu t0, t1, t2" + + - + input: + bytes: [ 0xb3, 0x62, 0x73, 0x0a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZBB", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "max t0, t1, t2" + + - + input: + bytes: [ 0xb3, 0x72, 0x73, 0x0a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZBB", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "maxu t0, t1, t2" + + - + input: + bytes: [ 0xb3, 0x72, 0x73, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZBB", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "andn t0, t1, t2" + + - + input: + bytes: [ 0xb3, 0x62, 0x73, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZBB", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "orn t0, t1, t2" + + - + input: + bytes: [ 0xb3, 0x42, 0x73, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZBB", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "xnor t0, t1, t2" + + - + input: + bytes: [ 0xb3, 0x12, 0x73, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZBB", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "rol t0, t1, t2" + + - + input: + bytes: [ 0xb3, 0x52, 0x73, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZBB", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "ror t0, t1, t2" + + - + input: + bytes: [ 0x93, 0x52, 0x73, 0x28 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZBB", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "orc.b t0, t1" diff --git a/tests/MC/RISCV/rv32zbc_valid_riscv32_riscv_zbc.txt.yaml b/tests/MC/RISCV/rv32zbc_valid_riscv32_riscv_zbc.txt.yaml new file mode 100644 index 0000000000..aa9c5e5413 --- /dev/null +++ b/tests/MC/RISCV/rv32zbc_valid_riscv32_riscv_zbc.txt.yaml @@ -0,0 +1,30 @@ +test_cases: + - + input: + bytes: [ 0xb3, 0x12, 0x73, 0x0a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZBC" ] + expected: + insns: + - + asm_text: "clmul t0, t1, t2" + + - + input: + bytes: [ 0xb3, 0x22, 0x73, 0x0a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZBC" ] + expected: + insns: + - + asm_text: "clmulr t0, t1, t2" + + - + input: + bytes: [ 0xb3, 0x32, 0x73, 0x0a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZBC" ] + expected: + insns: + - + asm_text: "clmulh t0, t1, t2" diff --git a/tests/MC/RISCV/rv32zbkb_only_valid_riscv32_riscv_zbkb.txt.yaml b/tests/MC/RISCV/rv32zbkb_only_valid_riscv32_riscv_zbkb.txt.yaml new file mode 100644 index 0000000000..1835825510 --- /dev/null +++ b/tests/MC/RISCV/rv32zbkb_only_valid_riscv32_riscv_zbkb.txt.yaml @@ -0,0 +1,30 @@ +test_cases: + - + input: + bytes: [ 0x93, 0x52, 0x83, 0x69 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZBKB" ] + expected: + insns: + - + asm_text: "rev8 t0, t1" + + - + input: + bytes: [ 0x93, 0x12, 0xf3, 0x08 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZBKB" ] + expected: + insns: + - + asm_text: "zip t0, t1" + + - + input: + bytes: [ 0x93, 0x52, 0xf3, 0x08 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZBKB" ] + expected: + insns: + - + asm_text: "unzip t0, t1" diff --git a/tests/MC/RISCV/rv32zbkb_valid_riscv32_riscv_zbkb.txt.yaml b/tests/MC/RISCV/rv32zbkb_valid_riscv32_riscv_zbkb.txt.yaml new file mode 100644 index 0000000000..ee74930998 --- /dev/null +++ b/tests/MC/RISCV/rv32zbkb_valid_riscv32_riscv_zbkb.txt.yaml @@ -0,0 +1,110 @@ +test_cases: + - + input: + bytes: [ 0xb3, 0x52, 0x73, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZBKB" ] + expected: + insns: + - + asm_text: "ror t0, t1, t2" + + - + input: + bytes: [ 0xb3, 0x12, 0x73, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZBKB" ] + expected: + insns: + - + asm_text: "rol t0, t1, t2" + + - + input: + bytes: [ 0x93, 0x52, 0xf3, 0x61 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZBKB" ] + expected: + insns: + - + asm_text: "rori t0, t1, 31" + + - + input: + bytes: [ 0x93, 0x52, 0x03, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZBKB" ] + expected: + insns: + - + asm_text: "rori t0, t1, 0" + + - + input: + bytes: [ 0xb3, 0x72, 0x73, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZBKB" ] + expected: + insns: + - + asm_text: "andn t0, t1, t2" + + - + input: + bytes: [ 0xb3, 0x62, 0x73, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZBKB" ] + expected: + insns: + - + asm_text: "orn t0, t1, t2" + + - + input: + bytes: [ 0xb3, 0x42, 0x73, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZBKB" ] + expected: + insns: + - + asm_text: "xnor t0, t1, t2" + + - + input: + bytes: [ 0xb3, 0x42, 0x73, 0x08 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZBKB" ] + expected: + insns: + - + asm_text: "pack t0, t1, t2" + + - + input: + bytes: [ 0xb3, 0x42, 0x03, 0x08 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZBKB" ] + expected: + insns: + - + asm_text: "pack t0, t1, zero" + + - + input: + bytes: [ 0xb3, 0x72, 0x73, 0x08 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZBKB" ] + expected: + insns: + - + asm_text: "packh t0, t1, t2" + + - + input: + bytes: [ 0x93, 0x52, 0x73, 0x68 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZBKB" ] + expected: + insns: + - + asm_text: "brev8 t0, t1" diff --git a/tests/MC/RISCV/rv32zbkc_valid_riscv32_riscv_zbkc.txt.yaml b/tests/MC/RISCV/rv32zbkc_valid_riscv32_riscv_zbkc.txt.yaml new file mode 100644 index 0000000000..d8403e7b51 --- /dev/null +++ b/tests/MC/RISCV/rv32zbkc_valid_riscv32_riscv_zbkc.txt.yaml @@ -0,0 +1,20 @@ +test_cases: + - + input: + bytes: [ 0xb3, 0x12, 0x73, 0x0a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZBKC" ] + expected: + insns: + - + asm_text: "clmul t0, t1, t2" + + - + input: + bytes: [ 0xb3, 0x32, 0x73, 0x0a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZBKC" ] + expected: + insns: + - + asm_text: "clmulh t0, t1, t2" diff --git a/tests/MC/RISCV/rv32zbkx_valid_riscv32_riscv_zbkx.txt.yaml b/tests/MC/RISCV/rv32zbkx_valid_riscv32_riscv_zbkx.txt.yaml new file mode 100644 index 0000000000..2dfcf090a7 --- /dev/null +++ b/tests/MC/RISCV/rv32zbkx_valid_riscv32_riscv_zbkx.txt.yaml @@ -0,0 +1,20 @@ +test_cases: + - + input: + bytes: [ 0xb3, 0x42, 0x73, 0x28 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZBKX" ] + expected: + insns: + - + asm_text: "xperm8 t0, t1, t2" + + - + input: + bytes: [ 0xb3, 0x22, 0x73, 0x28 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZBKX" ] + expected: + insns: + - + asm_text: "xperm4 t0, t1, t2" diff --git a/tests/MC/RISCV/rv32zbs_valid_riscv32_riscv_zbs.txt.yaml b/tests/MC/RISCV/rv32zbs_valid_riscv32_riscv_zbs.txt.yaml new file mode 100644 index 0000000000..a12fdfeedc --- /dev/null +++ b/tests/MC/RISCV/rv32zbs_valid_riscv32_riscv_zbs.txt.yaml @@ -0,0 +1,80 @@ +test_cases: + - + input: + bytes: [ 0xb3, 0x12, 0x73, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZBS" ] + expected: + insns: + - + asm_text: "bclr t0, t1, t2" + + - + input: + bytes: [ 0xb3, 0x12, 0x73, 0x28 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZBS" ] + expected: + insns: + - + asm_text: "bset t0, t1, t2" + + - + input: + bytes: [ 0xb3, 0x12, 0x73, 0x68 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZBS" ] + expected: + insns: + - + asm_text: "binv t0, t1, t2" + + - + input: + bytes: [ 0xb3, 0x52, 0x73, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZBS" ] + expected: + insns: + - + asm_text: "bext t0, t1, t2" + + - + input: + bytes: [ 0x93, 0x12, 0x13, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZBS" ] + expected: + insns: + - + asm_text: "bclri t0, t1, 1" + + - + input: + bytes: [ 0x93, 0x12, 0x13, 0x28 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZBS" ] + expected: + insns: + - + asm_text: "bseti t0, t1, 1" + + - + input: + bytes: [ 0x93, 0x12, 0x13, 0x68 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZBS" ] + expected: + insns: + - + asm_text: "binvi t0, t1, 1" + + - + input: + bytes: [ 0x93, 0x52, 0x13, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZBS" ] + expected: + insns: + - + asm_text: "bexti t0, t1, 1" diff --git a/tests/MC/RISCV/rv32zcb_valid_riscv32_m_riscv_zbb_riscv_zba__zcb_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rv32zcb_valid_riscv32_m_riscv_zbb_riscv_zba__zcb_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..bcf93f834f --- /dev/null +++ b/tests/MC/RISCV/rv32zcb_valid_riscv32_m_riscv_zbb_riscv_zba__zcb_syntax_no_alias_text.txt.yaml @@ -0,0 +1,160 @@ +test_cases: + - + input: + bytes: [ 0x61, 0x9c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "m", "CS_MODE_RISCV_ZBB", "CS_MODE_RISCV_ZBA", "+zcb", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.zext.b s0" + + - + input: + bytes: [ 0x65, 0x9c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "m", "CS_MODE_RISCV_ZBB", "CS_MODE_RISCV_ZBA", "+zcb", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.sext.b s0" + + - + input: + bytes: [ 0x69, 0x9c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "m", "CS_MODE_RISCV_ZBB", "CS_MODE_RISCV_ZBA", "+zcb", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.zext.h s0" + + - + input: + bytes: [ 0x6d, 0x9c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "m", "CS_MODE_RISCV_ZBB", "CS_MODE_RISCV_ZBA", "+zcb", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.sext.h s0" + + - + input: + bytes: [ 0x75, 0x9c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "m", "CS_MODE_RISCV_ZBB", "CS_MODE_RISCV_ZBA", "+zcb", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.not s0" + + - + input: + bytes: [ 0x45, 0x9c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "m", "CS_MODE_RISCV_ZBB", "CS_MODE_RISCV_ZBA", "+zcb", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.mul s0, s1" + + - + input: + bytes: [ 0x3c, 0x83 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "m", "CS_MODE_RISCV_ZBB", "CS_MODE_RISCV_ZBA", "+zcb", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.lbu a5, 2(a4)" + + - + input: + bytes: [ 0x3c, 0x87 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "m", "CS_MODE_RISCV_ZBB", "CS_MODE_RISCV_ZBA", "+zcb", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.lhu a5, 2(a4)" + + - + input: + bytes: [ 0x7c, 0x87 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "m", "CS_MODE_RISCV_ZBB", "CS_MODE_RISCV_ZBA", "+zcb", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.lh a5, 2(a4)" + + - + input: + bytes: [ 0x3c, 0x8b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "m", "CS_MODE_RISCV_ZBB", "CS_MODE_RISCV_ZBA", "+zcb", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.sb a5, 2(a4)" + + - + input: + bytes: [ 0x3c, 0x8f ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "m", "CS_MODE_RISCV_ZBB", "CS_MODE_RISCV_ZBA", "+zcb", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.sh a5, 2(a4)" + + - + input: + bytes: [ 0x80, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "m", "CS_MODE_RISCV_ZBB", "CS_MODE_RISCV_ZBA", "+zcb", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.lbu s0, 0(s1)" + + - + input: + bytes: [ 0x80, 0x84 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "m", "CS_MODE_RISCV_ZBB", "CS_MODE_RISCV_ZBA", "+zcb", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.lhu s0, 0(s1)" + + - + input: + bytes: [ 0xc0, 0x84 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "m", "CS_MODE_RISCV_ZBB", "CS_MODE_RISCV_ZBA", "+zcb", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.lh s0, 0(s1)" + + - + input: + bytes: [ 0x80, 0x88 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "m", "CS_MODE_RISCV_ZBB", "CS_MODE_RISCV_ZBA", "+zcb", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.sb s0, 0(s1)" + + - + input: + bytes: [ 0x80, 0x8c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "m", "CS_MODE_RISCV_ZBB", "CS_MODE_RISCV_ZBA", "+zcb", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.sh s0, 0(s1)" diff --git a/tests/MC/RISCV/rv32zcmp_valid_riscv32_riscv_zcmp_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rv32zcmp_valid_riscv32_riscv_zcmp_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..795980cf13 --- /dev/null +++ b/tests/MC/RISCV/rv32zcmp_valid_riscv32_riscv_zcmp_syntax_no_alias_text.txt.yaml @@ -0,0 +1,370 @@ +test_cases: + - + input: + bytes: [ 0xa2, 0xac ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.mvsa01 s1, s0" + + - + input: + bytes: [ 0xe2, 0xac ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.mva01s s1, s0" + + - + input: + bytes: [ 0x62, 0xac ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.mva01s s0, s0" + + - + input: + bytes: [ 0x42, 0xbe ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.popret {ra}, 16" + + - + input: + bytes: [ 0x46, 0xbe ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.popret {ra}, 32" + + - + input: + bytes: [ 0x5e, 0xbe ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.popret {ra, s0}, 64" + + - + input: + bytes: [ 0x62, 0xbe ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.popret {ra, s0-s1}, 16" + + - + input: + bytes: [ 0x76, 0xbe ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.popret {ra, s0-s2}, 32" + + - + input: + bytes: [ 0x82, 0xbe ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.popret {ra, s0-s3}, 32" + + - + input: + bytes: [ 0xa2, 0xbe ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.popret {ra, s0-s5}, 32" + + - + input: + bytes: [ 0xc2, 0xbe ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.popret {ra, s0-s7}, 48" + + - + input: + bytes: [ 0xfe, 0xbe ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.popret {ra, s0-s11}, 112" + + - + input: + bytes: [ 0x42, 0xbc ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.popretz {ra}, 16" + + - + input: + bytes: [ 0x46, 0xbc ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.popretz {ra}, 32" + + - + input: + bytes: [ 0x5e, 0xbc ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.popretz {ra, s0}, 64" + + - + input: + bytes: [ 0x62, 0xbc ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.popretz {ra, s0-s1}, 16" + + - + input: + bytes: [ 0x76, 0xbc ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.popretz {ra, s0-s2}, 32" + + - + input: + bytes: [ 0x82, 0xbc ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.popretz {ra, s0-s3}, 32" + + - + input: + bytes: [ 0xa2, 0xbc ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.popretz {ra, s0-s5}, 32" + + - + input: + bytes: [ 0xc2, 0xbc ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.popretz {ra, s0-s7}, 48" + + - + input: + bytes: [ 0xfe, 0xbc ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.popretz {ra, s0-s11}, 112" + + - + input: + bytes: [ 0x42, 0xba ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.pop {ra}, 16" + + - + input: + bytes: [ 0x46, 0xba ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.pop {ra}, 32" + + - + input: + bytes: [ 0x52, 0xba ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.pop {ra, s0}, 16" + + - + input: + bytes: [ 0x66, 0xba ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.pop {ra, s0-s1}, 32" + + - + input: + bytes: [ 0x76, 0xba ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.pop {ra, s0-s2}, 32" + + - + input: + bytes: [ 0xa2, 0xba ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.pop {ra, s0-s5}, 32" + + - + input: + bytes: [ 0xc2, 0xba ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.pop {ra, s0-s7}, 48" + + - + input: + bytes: [ 0xf2, 0xba ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.pop {ra, s0-s11}, 64" + + - + input: + bytes: [ 0x42, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.push {ra}, -16" + + - + input: + bytes: [ 0x56, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.push {ra, s0}, -32" + + - + input: + bytes: [ 0x62, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.push {ra, s0-s1}, -16" + + - + input: + bytes: [ 0x82, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.push {ra, s0-s3}, -32" + + - + input: + bytes: [ 0xc2, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.push {ra, s0-s7}, -48" + + - + input: + bytes: [ 0xc6, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.push {ra, s0-s7}, -64" + + - + input: + bytes: [ 0xf6, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.push {ra, s0-s11}, -80" + + - + input: + bytes: [ 0xfe, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.push {ra, s0-s11}, -112" diff --git a/tests/MC/RISCV/rv32zcmt_valid_riscv32_riscv_zcmt_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rv32zcmt_valid_riscv32_riscv_zcmt_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..083991df86 --- /dev/null +++ b/tests/MC/RISCV/rv32zcmt_valid_riscv32_riscv_zcmt_syntax_no_alias_text.txt.yaml @@ -0,0 +1,20 @@ +test_cases: + - + input: + bytes: [ 0x06, 0xa0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZCMT", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.jt 1" + + - + input: + bytes: [ 0x82, 0xa0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZCMT", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.jalt 32" diff --git a/tests/MC/RISCV/rv32zdinx_valid_riscv32_riscv_zdinx_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rv32zdinx_valid_riscv32_riscv_zdinx_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..3487fd7670 --- /dev/null +++ b/tests/MC/RISCV/rv32zdinx_valid_riscv32_riscv_zdinx_syntax_no_alias_text.txt.yaml @@ -0,0 +1,370 @@ +test_cases: + - + input: + bytes: [ 0x43, 0x75, 0xe6, 0x82 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZDINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmadd.d a0, a2, a4, a6, dyn" + + - + input: + bytes: [ 0x47, 0x75, 0xe6, 0x82 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZDINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmsub.d a0, a2, a4, a6, dyn" + + - + input: + bytes: [ 0x4b, 0x75, 0xe6, 0x82 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZDINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fnmsub.d a0, a2, a4, a6, dyn" + + - + input: + bytes: [ 0x4f, 0x75, 0xe6, 0x82 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZDINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fnmadd.d a0, a2, a4, a6, dyn" + + - + input: + bytes: [ 0x53, 0x7d, 0xee, 0x03 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZDINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fadd.d s10, t3, t5, dyn" + + - + input: + bytes: [ 0x53, 0x7d, 0xee, 0x0b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZDINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsub.d s10, t3, t5, dyn" + + - + input: + bytes: [ 0x53, 0x7d, 0xee, 0x13 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZDINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmul.d s10, t3, t5, dyn" + + - + input: + bytes: [ 0x53, 0x7d, 0xee, 0x1b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZDINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fdiv.d s10, t3, t5, dyn" + + - + input: + bytes: [ 0x53, 0x7a, 0x0b, 0x5a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZDINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsqrt.d s4, s6, dyn" + + - + input: + bytes: [ 0x53, 0x0d, 0xee, 0x23 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZDINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsgnj.d s10, t3, t5" + + - + input: + bytes: [ 0x53, 0x1d, 0xee, 0x23 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZDINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsgnjn.d s10, t3, t5" + + - + input: + bytes: [ 0x53, 0x2d, 0xee, 0x23 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZDINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsgnjx.d s10, t3, t5" + + - + input: + bytes: [ 0x53, 0x0d, 0xee, 0x2b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZDINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmin.d s10, t3, t5" + + - + input: + bytes: [ 0x53, 0x1d, 0xee, 0x2b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZDINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmax.d s10, t3, t5" + + - + input: + bytes: [ 0x53, 0x7d, 0x1e, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZDINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.s.d s10, t3, dyn" + + - + input: + bytes: [ 0x53, 0x0d, 0x0e, 0x42 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZDINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.d.s s10, t3" + + - + input: + bytes: [ 0x53, 0x3d, 0x0e, 0x42 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZDINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.d.s s10, t3, rup" + + - + input: + bytes: [ 0x53, 0x2d, 0xee, 0xa3 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZDINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "feq.d s10, t3, t5" + + - + input: + bytes: [ 0x53, 0x1d, 0xee, 0xa3 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZDINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "flt.d s10, t3, t5" + + - + input: + bytes: [ 0x53, 0x0d, 0xee, 0xa3 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZDINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fle.d s10, t3, t5" + + - + input: + bytes: [ 0x53, 0x1d, 0x0e, 0xe2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZDINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fclass.d s10, t3" + + - + input: + bytes: [ 0x53, 0x7a, 0x0b, 0xc2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZDINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.w.d s4, s6, dyn" + + - + input: + bytes: [ 0x53, 0x0d, 0x0e, 0xd2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZDINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.d.w s10, t3" + + - + input: + bytes: [ 0x53, 0x3d, 0x0e, 0xd2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZDINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.d.w s10, t3, rup" + + - + input: + bytes: [ 0x53, 0x0d, 0x1e, 0xd2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZDINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.d.wu s10, t3" + + - + input: + bytes: [ 0x53, 0x3d, 0x1e, 0xd2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZDINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.d.wu s10, t3, rup" + + - + input: + bytes: [ 0x43, 0x05, 0xe6, 0x82 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZDINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmadd.d a0, a2, a4, a6, rne" + + - + input: + bytes: [ 0x47, 0x15, 0xe6, 0x82 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZDINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmsub.d a0, a2, a4, a6, rtz" + + - + input: + bytes: [ 0x4b, 0x25, 0xe6, 0x82 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZDINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fnmsub.d a0, a2, a4, a6, rdn" + + - + input: + bytes: [ 0x4f, 0x35, 0xe6, 0x82 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZDINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fnmadd.d a0, a2, a4, a6, rup" + + - + input: + bytes: [ 0x53, 0x4d, 0xee, 0x03 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZDINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fadd.d s10, t3, t5, rmm" + + - + input: + bytes: [ 0x53, 0x0d, 0xee, 0x13 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZDINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmul.d s10, t3, t5, rne" + + - + input: + bytes: [ 0x53, 0x1d, 0xee, 0x1b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZDINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fdiv.d s10, t3, t5, rtz" + + - + input: + bytes: [ 0x53, 0x2a, 0x0b, 0x5a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZDINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsqrt.d s4, s6, rdn" + + - + input: + bytes: [ 0x53, 0x3a, 0x1b, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZDINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.s.d s4, s6, rup" + + - + input: + bytes: [ 0x53, 0x4a, 0x0b, 0xc2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZDINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.w.d s4, s6, rmm" + + - + input: + bytes: [ 0x53, 0x7a, 0x1b, 0xc2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZDINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.wu.d s4, s6, dyn" diff --git a/tests/MC/RISCV/rv32zfa_only_valid_riscv32_zfa_riscv_d__zfh_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rv32zfa_only_valid_riscv32_zfa_riscv_d__zfh_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..723289c7b8 --- /dev/null +++ b/tests/MC/RISCV/rv32zfa_only_valid_riscv32_zfa_riscv_d__zfh_syntax_no_alias_text.txt.yaml @@ -0,0 +1,20 @@ +test_cases: + - + input: + bytes: [ 0xd3, 0x85, 0x14, 0xe2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmvh.x.d a1, fs1" + + - + input: + bytes: [ 0xd3, 0x84, 0xc5, 0xb2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmvp.d.x fs1, a1, a2" diff --git a/tests/MC/RISCV/rv32zfbfmin_valid_riscv32_experimental_zfbfmin_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rv32zfbfmin_valid_riscv32_experimental_zfbfmin_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..d2451cd70f --- /dev/null +++ b/tests/MC/RISCV/rv32zfbfmin_valid_riscv32_experimental_zfbfmin_syntax_no_alias_text.txt.yaml @@ -0,0 +1,140 @@ +test_cases: + - + input: + bytes: [ 0x07, 0x10, 0xc5, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "experimental-zfbfmin", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "flh ft0, 12(a0)" + + - + input: + bytes: [ 0x87, 0x90, 0x40, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "experimental-zfbfmin", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "flh ft1, 4(ra)" + + - + input: + bytes: [ 0x07, 0x91, 0x06, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "experimental-zfbfmin", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "flh ft2, -2048(a3)" + + - + input: + bytes: [ 0x87, 0x91, 0x04, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "experimental-zfbfmin", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "flh ft3, -2048(s1)" + + - + input: + bytes: [ 0x07, 0x12, 0xf9, 0x7f ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "experimental-zfbfmin", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "flh ft4, 2047(s2)" + + - + input: + bytes: [ 0x87, 0x92, 0x09, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "experimental-zfbfmin", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "flh ft5, 0(s3)" + + - + input: + bytes: [ 0xa7, 0x1f, 0x6a, 0x7e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "experimental-zfbfmin", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsh ft6, 2047(s4)" + + - + input: + bytes: [ 0x27, 0x90, 0x7a, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "experimental-zfbfmin", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsh ft7, -2048(s5)" + + - + input: + bytes: [ 0x27, 0x10, 0x8b, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "experimental-zfbfmin", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsh fs0, -2048(s6)" + + - + input: + bytes: [ 0xa7, 0x93, 0x9b, 0x3e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "experimental-zfbfmin", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsh fs1, 999(s7)" + + - + input: + bytes: [ 0x53, 0x86, 0x0b, 0xe4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "experimental-zfbfmin", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmv.x.h a2, fs7" + + - + input: + bytes: [ 0xd3, 0x00, 0x08, 0xf4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "experimental-zfbfmin", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmv.h.x ft1, a6" + + - + input: + bytes: [ 0x53, 0x75, 0x60, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "experimental-zfbfmin", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.s.bf16 fa0, ft0, dyn" + + - + input: + bytes: [ 0x53, 0x71, 0x86, 0x44 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "experimental-zfbfmin", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.bf16.s ft2, fa2, dyn" diff --git a/tests/MC/RISCV/rv32zfh_valid_riscv32_zfh_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rv32zfh_valid_riscv32_zfh_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..a2099f2efe --- /dev/null +++ b/tests/MC/RISCV/rv32zfh_valid_riscv32_zfh_syntax_no_alias_text.txt.yaml @@ -0,0 +1,480 @@ +test_cases: + - + input: + bytes: [ 0x07, 0x10, 0xc5, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "flh ft0, 12(a0)" + + - + input: + bytes: [ 0x87, 0x90, 0x40, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "flh ft1, 4(ra)" + + - + input: + bytes: [ 0x07, 0x91, 0x06, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "flh ft2, -2048(a3)" + + - + input: + bytes: [ 0x87, 0x91, 0x04, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "flh ft3, -2048(s1)" + + - + input: + bytes: [ 0x07, 0x12, 0xf9, 0x7f ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "flh ft4, 2047(s2)" + + - + input: + bytes: [ 0x87, 0x92, 0x09, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "flh ft5, 0(s3)" + + - + input: + bytes: [ 0xa7, 0x1f, 0x6a, 0x7e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsh ft6, 2047(s4)" + + - + input: + bytes: [ 0x27, 0x90, 0x7a, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsh ft7, -2048(s5)" + + - + input: + bytes: [ 0x27, 0x10, 0x8b, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsh fs0, -2048(s6)" + + - + input: + bytes: [ 0xa7, 0x93, 0x9b, 0x3e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsh fs1, 999(s7)" + + - + input: + bytes: [ 0x43, 0xf5, 0xc5, 0x6c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmadd.h fa0, fa1, fa2, fa3, dyn" + + - + input: + bytes: [ 0x47, 0xf7, 0x07, 0x8d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmsub.h fa4, fa5, fa6, fa7, dyn" + + - + input: + bytes: [ 0x4b, 0xf9, 0x49, 0xad ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fnmsub.h fs2, fs3, fs4, fs5, dyn" + + - + input: + bytes: [ 0x4f, 0xfb, 0x8b, 0xcd ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fnmadd.h fs6, fs7, fs8, fs9, dyn" + + - + input: + bytes: [ 0x53, 0xfd, 0xcd, 0x05 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fadd.h fs10, fs11, ft8, dyn" + + - + input: + bytes: [ 0xd3, 0x7e, 0xff, 0x0d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsub.h ft9, ft10, ft11, dyn" + + - + input: + bytes: [ 0x53, 0xf0, 0x20, 0x14 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmul.h ft0, ft1, ft2, dyn" + + - + input: + bytes: [ 0xd3, 0x71, 0x52, 0x1c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fdiv.h ft3, ft4, ft5, dyn" + + - + input: + bytes: [ 0x53, 0xf3, 0x03, 0x5c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsqrt.h ft6, ft7, dyn" + + - + input: + bytes: [ 0xd3, 0x04, 0xb5, 0x24 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsgnj.h fs1, fa0, fa1" + + - + input: + bytes: [ 0xd3, 0x95, 0xe6, 0x24 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsgnjn.h fa1, fa3, fa4" + + - + input: + bytes: [ 0x53, 0xa7, 0xc6, 0x24 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsgnjx.h fa4, fa3, fa2" + + - + input: + bytes: [ 0xd3, 0x07, 0x18, 0x2d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmin.h fa5, fa6, fa7" + + - + input: + bytes: [ 0x53, 0x99, 0x49, 0x2d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmax.h fs2, fs3, fs4" + + - + input: + bytes: [ 0x53, 0xf5, 0x0a, 0xc4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.w.h a0, fs5, dyn" + + - + input: + bytes: [ 0xd3, 0x75, 0x1b, 0xc4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.wu.h a1, fs6, dyn" + + - + input: + bytes: [ 0x53, 0x86, 0x0b, 0xe4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmv.x.h a2, fs7" + + - + input: + bytes: [ 0xd3, 0x25, 0x9c, 0xa5 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "feq.h a1, fs8, fs9" + + - + input: + bytes: [ 0x53, 0x16, 0xbd, 0xa5 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "flt.h a2, fs10, fs11" + + - + input: + bytes: [ 0xd3, 0x06, 0xde, 0xa5 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fle.h a3, ft8, ft9" + + - + input: + bytes: [ 0xd3, 0x16, 0x0f, 0xe4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fclass.h a3, ft10" + + - + input: + bytes: [ 0xd3, 0x7f, 0x07, 0xd4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.h.w ft11, a4, dyn" + + - + input: + bytes: [ 0x53, 0xf0, 0x17, 0xd4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.h.wu ft0, a5, dyn" + + - + input: + bytes: [ 0xd3, 0x00, 0x08, 0xf4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmv.h.x ft1, a6" + + - + input: + bytes: [ 0x43, 0x85, 0xc5, 0x6c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmadd.h fa0, fa1, fa2, fa3, rne" + + - + input: + bytes: [ 0x47, 0x97, 0x07, 0x8d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmsub.h fa4, fa5, fa6, fa7, rtz" + + - + input: + bytes: [ 0x4b, 0xa9, 0x49, 0xad ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fnmsub.h fs2, fs3, fs4, fs5, rdn" + + - + input: + bytes: [ 0x4f, 0xbb, 0x8b, 0xcd ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fnmadd.h fs6, fs7, fs8, fs9, rup" + + - + input: + bytes: [ 0x43, 0xc5, 0xc5, 0x6c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmadd.h fa0, fa1, fa2, fa3, rmm" + + - + input: + bytes: [ 0x53, 0x8d, 0xcd, 0x05 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fadd.h fs10, fs11, ft8, rne" + + - + input: + bytes: [ 0xd3, 0x1e, 0xff, 0x0d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsub.h ft9, ft10, ft11, rtz" + + - + input: + bytes: [ 0x53, 0xa0, 0x20, 0x14 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmul.h ft0, ft1, ft2, rdn" + + - + input: + bytes: [ 0xd3, 0x31, 0x52, 0x1c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fdiv.h ft3, ft4, ft5, rup" + + - + input: + bytes: [ 0x53, 0xc3, 0x03, 0x5c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsqrt.h ft6, ft7, rmm" + + - + input: + bytes: [ 0x53, 0xb5, 0x0a, 0xc4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.w.h a0, fs5, rup" + + - + input: + bytes: [ 0xd3, 0x25, 0x1b, 0xc4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.wu.h a1, fs6, rdn" + + - + input: + bytes: [ 0xd3, 0x1f, 0x07, 0xd4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.h.w ft11, a4, rtz" + + - + input: + bytes: [ 0x53, 0x80, 0x17, 0xd4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.h.wu ft0, a5, rne" diff --git a/tests/MC/RISCV/rv32zfhmin_valid_riscv32_zfhmin_riscv_d_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rv32zfhmin_valid_riscv32_zfhmin_riscv_d_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..0ae868010c --- /dev/null +++ b/tests/MC/RISCV/rv32zfhmin_valid_riscv32_zfhmin_riscv_d_syntax_no_alias_text.txt.yaml @@ -0,0 +1,180 @@ +test_cases: + - + input: + bytes: [ 0x07, 0x10, 0xc5, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfhmin", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "flh ft0, 12(a0)" + + - + input: + bytes: [ 0x87, 0x90, 0x40, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfhmin", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "flh ft1, 4(ra)" + + - + input: + bytes: [ 0x07, 0x91, 0x06, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfhmin", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "flh ft2, -2048(a3)" + + - + input: + bytes: [ 0x87, 0x91, 0x04, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfhmin", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "flh ft3, -2048(s1)" + + - + input: + bytes: [ 0x07, 0x12, 0xf9, 0x7f ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfhmin", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "flh ft4, 2047(s2)" + + - + input: + bytes: [ 0x87, 0x92, 0x09, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfhmin", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "flh ft5, 0(s3)" + + - + input: + bytes: [ 0xa7, 0x1f, 0x6a, 0x7e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfhmin", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsh ft6, 2047(s4)" + + - + input: + bytes: [ 0x27, 0x90, 0x7a, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfhmin", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsh ft7, -2048(s5)" + + - + input: + bytes: [ 0x27, 0x10, 0x8b, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfhmin", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsh fs0, -2048(s6)" + + - + input: + bytes: [ 0xa7, 0x93, 0x9b, 0x3e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfhmin", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsh fs1, 999(s7)" + + - + input: + bytes: [ 0x53, 0x86, 0x0b, 0xe4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfhmin", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmv.x.h a2, fs7" + + - + input: + bytes: [ 0xd3, 0x00, 0x08, 0xf4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfhmin", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmv.h.x ft1, a6" + + - + input: + bytes: [ 0x53, 0x05, 0x20, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfhmin", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.s.h fa0, ft0" + + - + input: + bytes: [ 0x53, 0x35, 0x20, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfhmin", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.s.h fa0, ft0, rup" + + - + input: + bytes: [ 0x53, 0x71, 0x06, 0x44 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfhmin", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.h.s ft2, fa2, dyn" + + - + input: + bytes: [ 0x53, 0x05, 0x20, 0x42 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfhmin", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.d.h fa0, ft0" + + - + input: + bytes: [ 0x53, 0x35, 0x20, 0x42 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfhmin", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.d.h fa0, ft0, rup" + + - + input: + bytes: [ 0x53, 0x71, 0x16, 0x44 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfhmin", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.h.d ft2, fa2, dyn" diff --git a/tests/MC/RISCV/rv32zfinx_valid_riscv32_riscv_zfinx_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rv32zfinx_valid_riscv32_riscv_zfinx_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..0de0ac594c --- /dev/null +++ b/tests/MC/RISCV/rv32zfinx_valid_riscv32_riscv_zfinx_syntax_no_alias_text.txt.yaml @@ -0,0 +1,360 @@ +test_cases: + - + input: + bytes: [ 0x43, 0xf5, 0xc5, 0x68 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmadd.s a0, a1, a2, a3, dyn" + + - + input: + bytes: [ 0x47, 0xf7, 0x07, 0x89 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmsub.s a4, a5, a6, a7, dyn" + + - + input: + bytes: [ 0x4b, 0xf9, 0x49, 0xa9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fnmsub.s s2, s3, s4, s5, dyn" + + - + input: + bytes: [ 0x4f, 0xfb, 0x8b, 0xc9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fnmadd.s s6, s7, s8, s9, dyn" + + - + input: + bytes: [ 0x53, 0xfd, 0xcd, 0x01 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fadd.s s10, s11, t3, dyn" + + - + input: + bytes: [ 0xd3, 0x7e, 0xff, 0x09 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsub.s t4, t5, t6, dyn" + + - + input: + bytes: [ 0x53, 0xf4, 0x24, 0x11 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmul.s s0, s1, s2, dyn" + + - + input: + bytes: [ 0xd3, 0x79, 0x5a, 0x19 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fdiv.s s3, s4, s5, dyn" + + - + input: + bytes: [ 0x53, 0xf3, 0x03, 0x58 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsqrt.s t1, t2, dyn" + + - + input: + bytes: [ 0xd3, 0x04, 0xb5, 0x20 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsgnj.s s1, a0, a1" + + - + input: + bytes: [ 0xd3, 0x95, 0xe6, 0x20 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsgnjn.s a1, a3, a4" + + - + input: + bytes: [ 0x53, 0xa7, 0xc6, 0x20 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsgnjx.s a4, a3, a2" + + - + input: + bytes: [ 0xd3, 0x07, 0x18, 0x29 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmin.s a5, a6, a7" + + - + input: + bytes: [ 0x53, 0x99, 0x49, 0x29 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmax.s s2, s3, s4" + + - + input: + bytes: [ 0x53, 0xf5, 0x0a, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.w.s a0, s5, dyn" + + - + input: + bytes: [ 0xd3, 0x75, 0x1b, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.wu.s a1, s6, dyn" + + - + input: + bytes: [ 0xd3, 0x25, 0x9c, 0xa1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "feq.s a1, s8, s9" + + - + input: + bytes: [ 0x53, 0x16, 0xbd, 0xa1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "flt.s a2, s10, s11" + + - + input: + bytes: [ 0xd3, 0x06, 0xde, 0xa1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fle.s a3, t3, t4" + + - + input: + bytes: [ 0xd3, 0x16, 0x0f, 0xe0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fclass.s a3, t5" + + - + input: + bytes: [ 0xd3, 0x7f, 0x07, 0xd0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.s.w t6, a4, dyn" + + - + input: + bytes: [ 0x53, 0xf4, 0x17, 0xd0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.s.wu s0, a5, dyn" + + - + input: + bytes: [ 0x43, 0x85, 0xc5, 0x68 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmadd.s a0, a1, a2, a3, rne" + + - + input: + bytes: [ 0x47, 0x97, 0x07, 0x89 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmsub.s a4, a5, a6, a7, rtz" + + - + input: + bytes: [ 0x4b, 0xa9, 0x49, 0xa9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fnmsub.s s2, s3, s4, s5, rdn" + + - + input: + bytes: [ 0x4f, 0xbb, 0x8b, 0xc9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fnmadd.s s6, s7, s8, s9, rup" + + - + input: + bytes: [ 0x43, 0xc5, 0xc5, 0x68 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmadd.s a0, a1, a2, a3, rmm" + + - + input: + bytes: [ 0x53, 0x8d, 0xcd, 0x01 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fadd.s s10, s11, t3, rne" + + - + input: + bytes: [ 0xd3, 0x1e, 0xff, 0x09 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsub.s t4, t5, t6, rtz" + + - + input: + bytes: [ 0x53, 0xa4, 0x24, 0x11 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmul.s s0, s1, s2, rdn" + + - + input: + bytes: [ 0xd3, 0x39, 0x5a, 0x19 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fdiv.s s3, s4, s5, rup" + + - + input: + bytes: [ 0x53, 0xc3, 0x03, 0x58 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsqrt.s t1, t2, rmm" + + - + input: + bytes: [ 0x53, 0xb5, 0x0a, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.w.s a0, s5, rup" + + - + input: + bytes: [ 0xd3, 0x25, 0x1b, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.wu.s a1, s6, rdn" + + - + input: + bytes: [ 0xd3, 0x1f, 0x07, 0xd0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.s.w t6, a4, rtz" + + - + input: + bytes: [ 0x53, 0x84, 0x17, 0xd0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.s.wu s0, a5, rne" diff --git a/tests/MC/RISCV/rv32zhinx_valid_riscv32_riscv_zfinx_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rv32zhinx_valid_riscv32_riscv_zfinx_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..4a584947e5 --- /dev/null +++ b/tests/MC/RISCV/rv32zhinx_valid_riscv32_riscv_zfinx_syntax_no_alias_text.txt.yaml @@ -0,0 +1,360 @@ +test_cases: + - + input: + bytes: [ 0x43, 0xf5, 0xc5, 0x6c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmadd.h a0, a1, a2, a3, dyn" + + - + input: + bytes: [ 0x47, 0xf7, 0x07, 0x8d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmsub.h a4, a5, a6, a7, dyn" + + - + input: + bytes: [ 0x4b, 0xf9, 0x49, 0xad ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fnmsub.h s2, s3, s4, s5, dyn" + + - + input: + bytes: [ 0x4f, 0xfb, 0x8b, 0xcd ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fnmadd.h s6, s7, s8, s9, dyn" + + - + input: + bytes: [ 0x53, 0xfd, 0xcd, 0x05 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fadd.h s10, s11, t3, dyn" + + - + input: + bytes: [ 0xd3, 0x7e, 0xff, 0x0d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsub.h t4, t5, t6, dyn" + + - + input: + bytes: [ 0x53, 0xf4, 0x24, 0x15 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmul.h s0, s1, s2, dyn" + + - + input: + bytes: [ 0xd3, 0x79, 0x5a, 0x1d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fdiv.h s3, s4, s5, dyn" + + - + input: + bytes: [ 0x53, 0xfb, 0x0b, 0x5c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsqrt.h s6, s7, dyn" + + - + input: + bytes: [ 0xd3, 0x04, 0xb5, 0x24 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsgnj.h s1, a0, a1" + + - + input: + bytes: [ 0xd3, 0x95, 0xe6, 0x24 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsgnjn.h a1, a3, a4" + + - + input: + bytes: [ 0x53, 0xa7, 0xc6, 0x24 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsgnjx.h a4, a3, a2" + + - + input: + bytes: [ 0xd3, 0x07, 0x18, 0x2d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmin.h a5, a6, a7" + + - + input: + bytes: [ 0x53, 0x99, 0x49, 0x2d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmax.h s2, s3, s4" + + - + input: + bytes: [ 0x53, 0xf5, 0x0a, 0xc4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.w.h a0, s5, dyn" + + - + input: + bytes: [ 0xd3, 0x75, 0x1b, 0xc4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.wu.h a1, s6, dyn" + + - + input: + bytes: [ 0xd3, 0x25, 0x9c, 0xa5 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "feq.h a1, s8, s9" + + - + input: + bytes: [ 0x53, 0x16, 0xbd, 0xa5 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "flt.h a2, s10, s11" + + - + input: + bytes: [ 0xd3, 0x06, 0xde, 0xa5 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fle.h a3, t3, t4" + + - + input: + bytes: [ 0xd3, 0x16, 0x0f, 0xe4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fclass.h a3, t5" + + - + input: + bytes: [ 0xd3, 0x7f, 0x07, 0xd4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.h.w t6, a4, dyn" + + - + input: + bytes: [ 0x53, 0xf4, 0x17, 0xd4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.h.wu s0, a5, dyn" + + - + input: + bytes: [ 0x43, 0x85, 0xc5, 0x6c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmadd.h a0, a1, a2, a3, rne" + + - + input: + bytes: [ 0x47, 0x97, 0x07, 0x8d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmsub.h a4, a5, a6, a7, rtz" + + - + input: + bytes: [ 0x4b, 0xa9, 0x49, 0xad ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fnmsub.h s2, s3, s4, s5, rdn" + + - + input: + bytes: [ 0x4f, 0xbb, 0x8b, 0xcd ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fnmadd.h s6, s7, s8, s9, rup" + + - + input: + bytes: [ 0x43, 0xc5, 0xc5, 0x6c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmadd.h a0, a1, a2, a3, rmm" + + - + input: + bytes: [ 0x53, 0x8d, 0xcd, 0x05 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fadd.h s10, s11, t3, rne" + + - + input: + bytes: [ 0xd3, 0x1e, 0xff, 0x0d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsub.h t4, t5, t6, rtz" + + - + input: + bytes: [ 0x53, 0xa4, 0x24, 0x15 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmul.h s0, s1, s2, rdn" + + - + input: + bytes: [ 0xd3, 0x39, 0x5a, 0x1d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fdiv.h s3, s4, s5, rup" + + - + input: + bytes: [ 0x53, 0xcb, 0x0b, 0x5c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fsqrt.h s6, s7, rmm" + + - + input: + bytes: [ 0x53, 0xb5, 0x0a, 0xc4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.w.h a0, s5, rup" + + - + input: + bytes: [ 0xd3, 0x25, 0x1b, 0xc4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.wu.h a1, s6, rdn" + + - + input: + bytes: [ 0xd3, 0x1f, 0x07, 0xd4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.h.w t6, a4, rtz" + + - + input: + bytes: [ 0x53, 0x84, 0x17, 0xd4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.h.wu s0, a5, rne" diff --git a/tests/MC/RISCV/rv32zhinxmin_valid_riscv32_riscv_zfinx_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rv32zhinxmin_valid_riscv32_riscv_zfinx_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..8b6d1f727b --- /dev/null +++ b/tests/MC/RISCV/rv32zhinxmin_valid_riscv32_riscv_zfinx_syntax_no_alias_text.txt.yaml @@ -0,0 +1,30 @@ +test_cases: + - + input: + bytes: [ 0x53, 0x85, 0x25, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.s.h a0, a1" + + - + input: + bytes: [ 0x53, 0xb5, 0x25, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.s.h a0, a1, rup" + + - + input: + bytes: [ 0x53, 0xf5, 0x05, 0x44 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.h.s a0, a1, dyn" diff --git a/tests/MC/RISCV/rv32zicbom_valid_riscv32_zicbom.txt.yaml b/tests/MC/RISCV/rv32zicbom_valid_riscv32_zicbom.txt.yaml new file mode 100644 index 0000000000..abb6cef41b --- /dev/null +++ b/tests/MC/RISCV/rv32zicbom_valid_riscv32_zicbom.txt.yaml @@ -0,0 +1,30 @@ +test_cases: + - + input: + bytes: [ 0x0f, 0xa0, 0x12, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zicbom" ] + expected: + insns: + - + asm_text: "cbo.clean (t0)" + + - + input: + bytes: [ 0x0f, 0x20, 0x23, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zicbom" ] + expected: + insns: + - + asm_text: "cbo.flush (t1)" + + - + input: + bytes: [ 0x0f, 0xa0, 0x03, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zicbom" ] + expected: + insns: + - + asm_text: "cbo.inval (t2)" diff --git a/tests/MC/RISCV/rv32zicbop_valid_riscv32_zicbop.txt.yaml b/tests/MC/RISCV/rv32zicbop_valid_riscv32_zicbop.txt.yaml new file mode 100644 index 0000000000..10df559b6a --- /dev/null +++ b/tests/MC/RISCV/rv32zicbop_valid_riscv32_zicbop.txt.yaml @@ -0,0 +1,80 @@ +test_cases: + - + input: + bytes: [ 0x13, 0xe0, 0x02, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zicbop" ] + expected: + insns: + - + asm_text: "prefetch.i -2048(t0)" + + - + input: + bytes: [ 0x13, 0xe0, 0x02, 0x7e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zicbop" ] + expected: + insns: + - + asm_text: "prefetch.i 2016(t0)" + + - + input: + bytes: [ 0x13, 0x60, 0x13, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zicbop" ] + expected: + insns: + - + asm_text: "prefetch.r -2048(t1)" + + - + input: + bytes: [ 0x13, 0x60, 0x13, 0x7e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zicbop" ] + expected: + insns: + - + asm_text: "prefetch.r 2016(t1)" + + - + input: + bytes: [ 0x13, 0xe0, 0x33, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zicbop" ] + expected: + insns: + - + asm_text: "prefetch.w -2048(t2)" + + - + input: + bytes: [ 0x13, 0xe0, 0x33, 0x7e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zicbop" ] + expected: + insns: + - + asm_text: "prefetch.w 2016(t2)" + + - + input: + bytes: [ 0x13, 0xe5, 0x05, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zicbop" ] + expected: + insns: + - + asm_text: "ori a0, a1, -2048" + + - + input: + bytes: [ 0x13, 0xe5, 0x05, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zicbop" ] + expected: + insns: + - + asm_text: "ori a0, a1, 0" diff --git a/tests/MC/RISCV/rv32zicboz_valid_riscv32_zicboz.txt.yaml b/tests/MC/RISCV/rv32zicboz_valid_riscv32_zicboz.txt.yaml new file mode 100644 index 0000000000..c81b72da1d --- /dev/null +++ b/tests/MC/RISCV/rv32zicboz_valid_riscv32_zicboz.txt.yaml @@ -0,0 +1,10 @@ +test_cases: + - + input: + bytes: [ 0x0f, 0xa0, 0x42, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zicboz" ] + expected: + insns: + - + asm_text: "cbo.zero (t0)" diff --git a/tests/MC/RISCV/rv32zicond_valid_riscv32_zicond.txt.yaml b/tests/MC/RISCV/rv32zicond_valid_riscv32_zicond.txt.yaml new file mode 100644 index 0000000000..ddca487d9f --- /dev/null +++ b/tests/MC/RISCV/rv32zicond_valid_riscv32_zicond.txt.yaml @@ -0,0 +1,20 @@ +test_cases: + - + input: + bytes: [ 0xb3, 0xd2, 0x16, 0x0e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zicond" ] + expected: + insns: + - + asm_text: "czero.eqz t0, a3, ra" + + - + input: + bytes: [ 0xb3, 0xf5, 0xf1, 0x0f ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zicond" ] + expected: + insns: + - + asm_text: "czero.nez a1, gp, t6" diff --git a/tests/MC/RISCV/rv32zihintntl_valid_riscv32_zihintntl_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rv32zihintntl_valid_riscv32_zihintntl_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..f27104531f --- /dev/null +++ b/tests/MC/RISCV/rv32zihintntl_valid_riscv32_zihintntl_syntax_no_alias_text.txt.yaml @@ -0,0 +1,40 @@ +test_cases: + - + input: + bytes: [ 0x33, 0x00, 0x20, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zihintntl", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "add zero, zero, sp" + + - + input: + bytes: [ 0x33, 0x00, 0x30, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zihintntl", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "add zero, zero, gp" + + - + input: + bytes: [ 0x33, 0x00, 0x40, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zihintntl", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "add zero, zero, tp" + + - + input: + bytes: [ 0x33, 0x00, 0x50, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zihintntl", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "add zero, zero, t0" diff --git a/tests/MC/RISCV/rv32zihintntlc_valid_riscv32_zihintntl_riscv_c.txt.yaml b/tests/MC/RISCV/rv32zihintntlc_valid_riscv32_zihintntl_riscv_c.txt.yaml new file mode 100644 index 0000000000..d8bac8f6f5 --- /dev/null +++ b/tests/MC/RISCV/rv32zihintntlc_valid_riscv32_zihintntl_riscv_c.txt.yaml @@ -0,0 +1,80 @@ +test_cases: + - + input: + bytes: [ 0x33, 0x00, 0x20, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zihintntl", "CS_MODE_RISCV_C" ] + expected: + insns: + - + asm_text: "ntl.p1" + + - + input: + bytes: [ 0x33, 0x00, 0x30, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zihintntl", "CS_MODE_RISCV_C" ] + expected: + insns: + - + asm_text: "ntl.pall" + + - + input: + bytes: [ 0x33, 0x00, 0x40, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zihintntl", "CS_MODE_RISCV_C" ] + expected: + insns: + - + asm_text: "ntl.s1" + + - + input: + bytes: [ 0x33, 0x00, 0x50, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zihintntl", "CS_MODE_RISCV_C" ] + expected: + insns: + - + asm_text: "ntl.all" + + - + input: + bytes: [ 0x0a, 0x90 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zihintntl", "CS_MODE_RISCV_C" ] + expected: + insns: + - + asm_text: "c.ntl.p1" + + - + input: + bytes: [ 0x0e, 0x90 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zihintntl", "CS_MODE_RISCV_C" ] + expected: + insns: + - + asm_text: "c.ntl.pall" + + - + input: + bytes: [ 0x12, 0x90 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zihintntl", "CS_MODE_RISCV_C" ] + expected: + insns: + - + asm_text: "c.ntl.s1" + + - + input: + bytes: [ 0x16, 0x90 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zihintntl", "CS_MODE_RISCV_C" ] + expected: + insns: + - + asm_text: "c.ntl.all" diff --git a/tests/MC/RISCV/rv32zihintpause_valid_riscv32_zihintpause_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rv32zihintpause_valid_riscv32_zihintpause_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..a9b8181107 --- /dev/null +++ b/tests/MC/RISCV/rv32zihintpause_valid_riscv32_zihintpause_syntax_no_alias_text.txt.yaml @@ -0,0 +1,30 @@ +test_cases: + - + input: + bytes: [ 0x0f, 0x00, 0x00, 0x01 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zihintpause", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fence w, 0" + + - + input: + bytes: [ 0x0f, 0x00, 0x10, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zihintpause", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fence 0, w" + + - + input: + bytes: [ 0x0f, 0x00, 0x00, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zihintpause", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fence 0, 0" diff --git a/tests/MC/RISCV/rv32zknd_only_valid_riscv32_zknd.txt.yaml b/tests/MC/RISCV/rv32zknd_only_valid_riscv32_zknd.txt.yaml new file mode 100644 index 0000000000..ad9d15914e --- /dev/null +++ b/tests/MC/RISCV/rv32zknd_only_valid_riscv32_zknd.txt.yaml @@ -0,0 +1,20 @@ +test_cases: + - + input: + bytes: [ 0x33, 0x85, 0xc5, 0xea ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zknd" ] + expected: + insns: + - + asm_text: "aes32dsi a0, a1, a2, 3" + + - + input: + bytes: [ 0x33, 0x85, 0xc5, 0xee ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zknd" ] + expected: + insns: + - + asm_text: "aes32dsmi a0, a1, a2, 3" diff --git a/tests/MC/RISCV/rv32zkne_only_valid_riscv32_zkne.txt.yaml b/tests/MC/RISCV/rv32zkne_only_valid_riscv32_zkne.txt.yaml new file mode 100644 index 0000000000..1a3a2bd43e --- /dev/null +++ b/tests/MC/RISCV/rv32zkne_only_valid_riscv32_zkne.txt.yaml @@ -0,0 +1,20 @@ +test_cases: + - + input: + bytes: [ 0x33, 0x85, 0xc5, 0xe2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zkne" ] + expected: + insns: + - + asm_text: "aes32esi a0, a1, a2, 3" + + - + input: + bytes: [ 0x33, 0x85, 0xc5, 0xe6 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zkne" ] + expected: + insns: + - + asm_text: "aes32esmi a0, a1, a2, 3" diff --git a/tests/MC/RISCV/rv32zknh_only_valid_riscv32_zknh.txt.yaml b/tests/MC/RISCV/rv32zknh_only_valid_riscv32_zknh.txt.yaml new file mode 100644 index 0000000000..b499aff6eb --- /dev/null +++ b/tests/MC/RISCV/rv32zknh_only_valid_riscv32_zknh.txt.yaml @@ -0,0 +1,60 @@ +test_cases: + - + input: + bytes: [ 0x33, 0x85, 0xc5, 0x5c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zknh" ] + expected: + insns: + - + asm_text: "sha512sig0h a0, a1, a2" + + - + input: + bytes: [ 0x33, 0x85, 0xc5, 0x5e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zknh" ] + expected: + insns: + - + asm_text: "sha512sig1h a0, a1, a2" + + - + input: + bytes: [ 0x33, 0x85, 0xc5, 0x54 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zknh" ] + expected: + insns: + - + asm_text: "sha512sig0l a0, a1, a2" + + - + input: + bytes: [ 0x33, 0x85, 0xc5, 0x56 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zknh" ] + expected: + insns: + - + asm_text: "sha512sig1l a0, a1, a2" + + - + input: + bytes: [ 0x33, 0x85, 0xc5, 0x50 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zknh" ] + expected: + insns: + - + asm_text: "sha512sum0r a0, a1, a2" + + - + input: + bytes: [ 0x33, 0x85, 0xc5, 0x52 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zknh" ] + expected: + insns: + - + asm_text: "sha512sum1r a0, a1, a2" diff --git a/tests/MC/RISCV/rv32zknh_valid_riscv32_zknh.txt.yaml b/tests/MC/RISCV/rv32zknh_valid_riscv32_zknh.txt.yaml new file mode 100644 index 0000000000..4b15826264 --- /dev/null +++ b/tests/MC/RISCV/rv32zknh_valid_riscv32_zknh.txt.yaml @@ -0,0 +1,40 @@ +test_cases: + - + input: + bytes: [ 0x13, 0x95, 0x25, 0x10 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zknh" ] + expected: + insns: + - + asm_text: "sha256sig0 a0, a1" + + - + input: + bytes: [ 0x13, 0x95, 0x35, 0x10 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zknh" ] + expected: + insns: + - + asm_text: "sha256sig1 a0, a1" + + - + input: + bytes: [ 0x13, 0x95, 0x05, 0x10 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zknh" ] + expected: + insns: + - + asm_text: "sha256sum0 a0, a1" + + - + input: + bytes: [ 0x13, 0x95, 0x15, 0x10 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zknh" ] + expected: + insns: + - + asm_text: "sha256sum1 a0, a1" diff --git a/tests/MC/RISCV/rv32zksed_valid_riscv32_zksed.txt.yaml b/tests/MC/RISCV/rv32zksed_valid_riscv32_zksed.txt.yaml new file mode 100644 index 0000000000..4ded0fb39b --- /dev/null +++ b/tests/MC/RISCV/rv32zksed_valid_riscv32_zksed.txt.yaml @@ -0,0 +1,20 @@ +test_cases: + - + input: + bytes: [ 0x33, 0x85, 0xc5, 0xf0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zksed" ] + expected: + insns: + - + asm_text: "sm4ed a0, a1, a2, 3" + + - + input: + bytes: [ 0x33, 0x85, 0xc5, 0xf4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zksed" ] + expected: + insns: + - + asm_text: "sm4ks a0, a1, a2, 3" diff --git a/tests/MC/RISCV/rv32zksh_valid_riscv32_zksh.txt.yaml b/tests/MC/RISCV/rv32zksh_valid_riscv32_zksh.txt.yaml new file mode 100644 index 0000000000..6a3c31d521 --- /dev/null +++ b/tests/MC/RISCV/rv32zksh_valid_riscv32_zksh.txt.yaml @@ -0,0 +1,20 @@ +test_cases: + - + input: + bytes: [ 0x13, 0x95, 0x85, 0x10 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zksh" ] + expected: + insns: + - + asm_text: "sm3p0 a0, a1" + + - + input: + bytes: [ 0x13, 0x95, 0x95, 0x10 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zksh" ] + expected: + insns: + - + asm_text: "sm3p1 a0, a1" diff --git a/tests/MC/RISCV/rv64_machine_csr_names_riscv64_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rv64_machine_csr_names_riscv64_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..dd164e759b --- /dev/null +++ b/tests/MC/RISCV/rv64_machine_csr_names_riscv64_syntax_no_alias_text.txt.yaml @@ -0,0 +1,330 @@ +test_cases: + - + input: + bytes: [ 0xf3, 0x23, 0x10, 0x3a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 929, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x30, 0x3a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 931, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x00, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 2944, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x20, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 2946, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x30, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 2947, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x40, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 2948, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x50, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 2949, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x60, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 2950, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x70, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 2951, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x80, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 2952, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x90, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 2953, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xa0, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 2954, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xb0, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 2955, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xc0, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 2956, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xd0, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 2957, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xe0, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 2958, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xf0, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 2959, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x00, 0xb9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 2960, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x10, 0xb9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 2961, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x20, 0xb9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 2962, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x30, 0xb9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 2963, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x40, 0xb9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 2964, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x50, 0xb9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 2965, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x60, 0xb9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 2966, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x70, 0xb9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 2967, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x80, 0xb9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 2968, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x90, 0xb9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 2969, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xa0, 0xb9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 2970, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xb0, 0xb9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 2971, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xc0, 0xb9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 2972, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xd0, 0xb9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 2973, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xe0, 0xb9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 2974, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xf0, 0xb9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 2975, zero" diff --git a/tests/MC/RISCV/rv64_user_csr_names_riscv64_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rv64_user_csr_names_riscv64_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..2c3739f639 --- /dev/null +++ b/tests/MC/RISCV/rv64_user_csr_names_riscv64_syntax_no_alias_text.txt.yaml @@ -0,0 +1,320 @@ +test_cases: + - + input: + bytes: [ 0xf3, 0x23, 0x00, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 3200, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x10, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 3201, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x20, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 3202, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x30, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 3203, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x40, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 3204, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x50, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 3205, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x60, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 3206, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x70, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 3207, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x80, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 3208, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x90, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 3209, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xa0, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 3210, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xb0, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 3211, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xc0, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 3212, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xd0, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 3213, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xe0, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 3214, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xf0, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 3215, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x00, 0xc9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 3216, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x10, 0xc9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 3217, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x20, 0xc9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 3218, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x30, 0xc9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 3219, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x40, 0xc9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 3220, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x50, 0xc9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 3221, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x60, 0xc9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 3222, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x70, 0xc9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 3223, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x80, 0xc9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 3224, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x90, 0xc9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 3225, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xa0, 0xc9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 3226, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xb0, 0xc9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 3227, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xc0, 0xc9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 3228, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xd0, 0xc9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 3229, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xe0, 0xc9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 3230, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xf0, 0xc9 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, 3231, zero" diff --git a/tests/MC/RISCV/rv64c_hints_valid_riscv64_riscv_c_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rv64c_hints_valid_riscv64_riscv_c_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..d74f211fc2 --- /dev/null +++ b/tests/MC/RISCV/rv64c_hints_valid_riscv64_riscv_c_syntax_no_alias_text.txt.yaml @@ -0,0 +1,10 @@ +test_cases: + - + input: + bytes: [ 0x7e, 0x10 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.slli zero, 63" diff --git a/tests/MC/RISCV/rv64c_valid_riscv64_riscv_c_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rv64c_valid_riscv64_riscv_c_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..c67817c5f5 --- /dev/null +++ b/tests/MC/RISCV/rv64c_valid_riscv64_riscv_c_syntax_no_alias_text.txt.yaml @@ -0,0 +1,110 @@ +test_cases: + - + input: + bytes: [ 0x82, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.ldsp ra, 0(sp)" + + - + input: + bytes: [ 0x86, 0xff ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.sdsp ra, 504(sp)" + + - + input: + bytes: [ 0x98, 0x62 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.ld a4, 0(a3)" + + - + input: + bytes: [ 0xfc, 0xfe ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.sd a5, 248(a3)" + + - + input: + bytes: [ 0x99, 0x9e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.subw a3, a4" + + - + input: + bytes: [ 0x31, 0x9d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.addw a0, a2" + + - + input: + bytes: [ 0x81, 0x36 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.addiw a3, -32" + + - + input: + bytes: [ 0xfd, 0x26 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.addiw a3, 31" + + - + input: + bytes: [ 0x7e, 0x14 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.slli s0, 63" + + - + input: + bytes: [ 0xfd, 0x92 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.srli a3, 63" + + - + input: + bytes: [ 0x7d, 0x96 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.srai a2, 63" diff --git a/tests/MC/RISCV/rv64d_valid_riscv64_riscv_d_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rv64d_valid_riscv64_riscv_d_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..e1992db616 --- /dev/null +++ b/tests/MC/RISCV/rv64d_valid_riscv64_riscv_d_syntax_no_alias_text.txt.yaml @@ -0,0 +1,100 @@ +test_cases: + - + input: + bytes: [ 0x53, 0x75, 0x20, 0xc2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.l.d a0, ft0, dyn" + + - + input: + bytes: [ 0xd3, 0xf5, 0x30, 0xc2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.lu.d a1, ft1, dyn" + + - + input: + bytes: [ 0x53, 0x06, 0x01, 0xe2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmv.x.d a2, ft2" + + - + input: + bytes: [ 0xd3, 0xf1, 0x26, 0xd2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.d.l ft3, a3, dyn" + + - + input: + bytes: [ 0x53, 0x72, 0x37, 0xd2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.d.lu ft4, a4, dyn" + + - + input: + bytes: [ 0xd3, 0x82, 0x07, 0xf2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmv.d.x ft5, a5" + + - + input: + bytes: [ 0xd3, 0x81, 0x26, 0xd2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.d.l ft3, a3, rne" + + - + input: + bytes: [ 0x53, 0x12, 0x37, 0xd2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.d.lu ft4, a4, rtz" + + - + input: + bytes: [ 0x53, 0x25, 0x20, 0xc2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.l.d a0, ft0, rdn" + + - + input: + bytes: [ 0xd3, 0xb5, 0x30, 0xc2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.lu.d a1, ft1, rup" diff --git a/tests/MC/RISCV/rv64dc_valid_riscv64_riscv_c_riscv_d_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rv64dc_valid_riscv64_riscv_c_riscv_d_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..87df667717 --- /dev/null +++ b/tests/MC/RISCV/rv64dc_valid_riscv64_riscv_c_riscv_d_syntax_no_alias_text.txt.yaml @@ -0,0 +1,40 @@ +test_cases: + - + input: + bytes: [ 0x7e, 0x34 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_C", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.fldsp fs0, 504(sp)" + + - + input: + bytes: [ 0xc6, 0xbf ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_C", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.fsdsp fa7, 504(sp)" + + - + input: + bytes: [ 0xf4, 0x3f ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_C", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.fld fa3, 248(a5)" + + - + input: + bytes: [ 0xf0, 0xbd ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_C", "CS_MODE_RISCV_D", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.fsd fa2, 248(a1)" diff --git a/tests/MC/RISCV/rv64e_valid_riscv64_riscv_e_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rv64e_valid_riscv64_riscv_e_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..bc00e74a77 --- /dev/null +++ b/tests/MC/RISCV/rv64e_valid_riscv64_riscv_e_syntax_no_alias_text.txt.yaml @@ -0,0 +1,120 @@ +test_cases: + - + input: + bytes: [ 0x03, 0xb7, 0x97, 0x01 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "ld a4, 25(a5)" + + - + input: + bytes: [ 0x23, 0xb2, 0xc6, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "sd a2, 36(a3)" + + - + input: + bytes: [ 0x1b, 0x87, 0x57, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "addiw a4, a5, 37" + + - + input: + bytes: [ 0x1b, 0x13, 0xf3, 0x01 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "slliw t1, t1, 31" + + - + input: + bytes: [ 0x1b, 0x55, 0x07, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "srliw a0, a4, 0" + + - + input: + bytes: [ 0x9b, 0x55, 0xf1, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "sraiw a1, sp, 15" + + - + input: + bytes: [ 0x9b, 0x12, 0xd3, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "slliw t0, t1, 13" + + - + input: + bytes: [ 0xbb, 0x00, 0x00, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "addw ra, zero, zero" + + - + input: + bytes: [ 0xbb, 0x82, 0x63, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "subw t0, t2, t1" + + - + input: + bytes: [ 0xbb, 0x17, 0xd7, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "sllw a5, a4, a3" + + - + input: + bytes: [ 0x3b, 0x55, 0x54, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "srlw a0, s0, t0" + + - + input: + bytes: [ 0xbb, 0xd2, 0x06, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_E", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "sraw t0, a3, zero" diff --git a/tests/MC/RISCV/rv64f_valid_riscv64_riscv_f_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rv64f_valid_riscv64_riscv_f_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..c8f7c25dae --- /dev/null +++ b/tests/MC/RISCV/rv64f_valid_riscv64_riscv_f_syntax_no_alias_text.txt.yaml @@ -0,0 +1,80 @@ +test_cases: + - + input: + bytes: [ 0x53, 0x75, 0x20, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.l.s a0, ft0, dyn" + + - + input: + bytes: [ 0xd3, 0xf5, 0x30, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.lu.s a1, ft1, dyn" + + - + input: + bytes: [ 0x53, 0x71, 0x26, 0xd0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.s.l ft2, a2, dyn" + + - + input: + bytes: [ 0xd3, 0xf1, 0x36, 0xd0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.s.lu ft3, a3, dyn" + + - + input: + bytes: [ 0x53, 0x07, 0x22, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.l.s a4, ft4, rne" + + - + input: + bytes: [ 0xd3, 0x97, 0x32, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.lu.s a5, ft5, rtz" + + - + input: + bytes: [ 0x53, 0x23, 0x28, 0xd0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.s.l ft6, a6, rdn" + + - + input: + bytes: [ 0xd3, 0xb3, 0x38, 0xd0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.s.lu ft7, a7, rup" diff --git a/tests/MC/RISCV/rv64i_valid_riscv64_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rv64i_valid_riscv64_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..8b5d5bc499 --- /dev/null +++ b/tests/MC/RISCV/rv64i_valid_riscv64_syntax_no_alias_text.txt.yaml @@ -0,0 +1,290 @@ +test_cases: + - + input: + bytes: [ 0x03, 0xe0, 0x40, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "lwu zero, 4(ra)" + + - + input: + bytes: [ 0x03, 0xe1, 0x41, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "lwu sp, 4(gp)" + + - + input: + bytes: [ 0x03, 0xe2, 0x02, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "lwu tp, -2048(t0)" + + - + input: + bytes: [ 0x03, 0xe3, 0x03, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "lwu t1, -2048(t2)" + + - + input: + bytes: [ 0x03, 0xe4, 0xf4, 0x7f ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "lwu s0, 2047(s1)" + + - + input: + bytes: [ 0x03, 0xb5, 0x05, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "ld a0, -2048(a1)" + + - + input: + bytes: [ 0x03, 0xb6, 0x06, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "ld a2, -2048(a3)" + + - + input: + bytes: [ 0x03, 0xb7, 0xf7, 0x7f ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "ld a4, 2047(a5)" + + - + input: + bytes: [ 0x23, 0xb0, 0x08, 0x81 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "sd a6, -2048(a7)" + + - + input: + bytes: [ 0x23, 0xb0, 0x29, 0x81 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "sd s2, -2048(s3)" + + - + input: + bytes: [ 0xa3, 0xbf, 0x4a, 0x7f ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "sd s4, 2047(s5)" + + - + input: + bytes: [ 0x13, 0x9b, 0xdb, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "slli s6, s7, 45" + + - + input: + bytes: [ 0x13, 0xdc, 0x0c, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "srli s8, s9, 0" + + - + input: + bytes: [ 0x13, 0xdd, 0xfd, 0x41 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "srai s10, s11, 31" + + - + input: + bytes: [ 0x1b, 0x8e, 0x0e, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "addiw t3, t4, -2048" + + - + input: + bytes: [ 0x1b, 0x8f, 0xff, 0x7f ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "addiw t5, t6, 2047" + + - + input: + bytes: [ 0x1b, 0x90, 0x00, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "slliw zero, ra, 0" + + - + input: + bytes: [ 0x1b, 0x91, 0xf1, 0x01 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "slliw sp, gp, 31" + + - + input: + bytes: [ 0x1b, 0xd2, 0x02, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "srliw tp, t0, 0" + + - + input: + bytes: [ 0x1b, 0xd3, 0xf3, 0x01 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "srliw t1, t2, 31" + + - + input: + bytes: [ 0x1b, 0xd4, 0x04, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "sraiw s0, s1, 0" + + - + input: + bytes: [ 0x1b, 0xd5, 0xf5, 0x41 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "sraiw a0, a1, 31" + + - + input: + bytes: [ 0x3b, 0x86, 0xe6, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "addw a2, a3, a4" + + - + input: + bytes: [ 0xbb, 0x07, 0x18, 0x01 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "addw a5, a6, a7" + + - + input: + bytes: [ 0x3b, 0x89, 0x49, 0x41 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "subw s2, s3, s4" + + - + input: + bytes: [ 0xbb, 0x0a, 0x7b, 0x41 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "subw s5, s6, s7" + + - + input: + bytes: [ 0x3b, 0x9c, 0xac, 0x01 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "sllw s8, s9, s10" + + - + input: + bytes: [ 0xbb, 0x5d, 0xde, 0x01 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "srlw s11, t3, t4" + + - + input: + bytes: [ 0x3b, 0xdf, 0x0f, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "sraw t5, t6, zero" diff --git a/tests/MC/RISCV/rv64ih_valid_riscv64_h_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rv64ih_valid_riscv64_h_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..7c4f64960a --- /dev/null +++ b/tests/MC/RISCV/rv64ih_valid_riscv64_h_syntax_no_alias_text.txt.yaml @@ -0,0 +1,30 @@ +test_cases: + - + input: + bytes: [ 0x73, 0xc5, 0x15, 0x68 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "h", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "hlv.wu a0, (a1)" + + - + input: + bytes: [ 0x73, 0xc5, 0x05, 0x6c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "h", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "hlv.d a0, (a1)" + + - + input: + bytes: [ 0x73, 0xc0, 0xa5, 0x6e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "h", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "hsv.d a0, (a1)" diff --git a/tests/MC/RISCV/rv64m_valid_riscv64_m_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rv64m_valid_riscv64_m_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..184886bb9f --- /dev/null +++ b/tests/MC/RISCV/rv64m_valid_riscv64_m_syntax_no_alias_text.txt.yaml @@ -0,0 +1,50 @@ +test_cases: + - + input: + bytes: [ 0xbb, 0x00, 0x31, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "m", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "mulw ra, sp, gp" + + - + input: + bytes: [ 0x3b, 0xc2, 0x62, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "m", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "divw tp, t0, t1" + + - + input: + bytes: [ 0xbb, 0x53, 0x24, 0x03 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "m", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "divuw t2, s0, s2" + + - + input: + bytes: [ 0x3b, 0xe5, 0xc5, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "m", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "remw a0, a1, a2" + + - + input: + bytes: [ 0xbb, 0x76, 0xf7, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "m", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "remuw a3, a4, a5" diff --git a/tests/MC/RISCV/rv64xtheadfmemidx_valid_riscv64_riscv_d_riscv_xtheadfmemidx.txt.yaml b/tests/MC/RISCV/rv64xtheadfmemidx_valid_riscv64_riscv_d_riscv_xtheadfmemidx.txt.yaml new file mode 100644 index 0000000000..723c3b9572 --- /dev/null +++ b/tests/MC/RISCV/rv64xtheadfmemidx_valid_riscv64_riscv_d_riscv_xtheadfmemidx.txt.yaml @@ -0,0 +1,160 @@ +test_cases: + - + input: + bytes: [ 0x0b, 0xe5, 0xc5, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_D", "CS_MODE_RISCV_XTHEADFMEMIDX" ] + expected: + insns: + - + asm_text: "th.flrd fa0, a1, a2, 0" + + - + input: + bytes: [ 0x0b, 0xe5, 0xc5, 0x66 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_D", "CS_MODE_RISCV_XTHEADFMEMIDX" ] + expected: + insns: + - + asm_text: "th.flrd fa0, a1, a2, 3" + + - + input: + bytes: [ 0x0b, 0xe5, 0xc5, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_D", "CS_MODE_RISCV_XTHEADFMEMIDX" ] + expected: + insns: + - + asm_text: "th.flrw fa0, a1, a2, 0" + + - + input: + bytes: [ 0x0b, 0xe5, 0xc5, 0x46 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_D", "CS_MODE_RISCV_XTHEADFMEMIDX" ] + expected: + insns: + - + asm_text: "th.flrw fa0, a1, a2, 3" + + - + input: + bytes: [ 0x0b, 0xe5, 0xc5, 0x70 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_D", "CS_MODE_RISCV_XTHEADFMEMIDX" ] + expected: + insns: + - + asm_text: "th.flurd fa0, a1, a2, 0" + + - + input: + bytes: [ 0x0b, 0xe5, 0xc5, 0x76 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_D", "CS_MODE_RISCV_XTHEADFMEMIDX" ] + expected: + insns: + - + asm_text: "th.flurd fa0, a1, a2, 3" + + - + input: + bytes: [ 0x0b, 0xe5, 0xc5, 0x50 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_D", "CS_MODE_RISCV_XTHEADFMEMIDX" ] + expected: + insns: + - + asm_text: "th.flurw fa0, a1, a2, 0" + + - + input: + bytes: [ 0x0b, 0xe5, 0xc5, 0x56 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_D", "CS_MODE_RISCV_XTHEADFMEMIDX" ] + expected: + insns: + - + asm_text: "th.flurw fa0, a1, a2, 3" + + - + input: + bytes: [ 0x0b, 0xf5, 0xc5, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_D", "CS_MODE_RISCV_XTHEADFMEMIDX" ] + expected: + insns: + - + asm_text: "th.fsrd fa0, a1, a2, 0" + + - + input: + bytes: [ 0x0b, 0xf5, 0xc5, 0x66 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_D", "CS_MODE_RISCV_XTHEADFMEMIDX" ] + expected: + insns: + - + asm_text: "th.fsrd fa0, a1, a2, 3" + + - + input: + bytes: [ 0x0b, 0xf5, 0xc5, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_D", "CS_MODE_RISCV_XTHEADFMEMIDX" ] + expected: + insns: + - + asm_text: "th.fsrw fa0, a1, a2, 0" + + - + input: + bytes: [ 0x0b, 0xf5, 0xc5, 0x46 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_D", "CS_MODE_RISCV_XTHEADFMEMIDX" ] + expected: + insns: + - + asm_text: "th.fsrw fa0, a1, a2, 3" + + - + input: + bytes: [ 0x0b, 0xf5, 0xc5, 0x70 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_D", "CS_MODE_RISCV_XTHEADFMEMIDX" ] + expected: + insns: + - + asm_text: "th.fsurd fa0, a1, a2, 0" + + - + input: + bytes: [ 0x0b, 0xf5, 0xc5, 0x76 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_D", "CS_MODE_RISCV_XTHEADFMEMIDX" ] + expected: + insns: + - + asm_text: "th.fsurd fa0, a1, a2, 3" + + - + input: + bytes: [ 0x0b, 0xf5, 0xc5, 0x50 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_D", "CS_MODE_RISCV_XTHEADFMEMIDX" ] + expected: + insns: + - + asm_text: "th.fsurw fa0, a1, a2, 0" + + - + input: + bytes: [ 0x0b, 0xf5, 0xc5, 0x56 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_D", "CS_MODE_RISCV_XTHEADFMEMIDX" ] + expected: + insns: + - + asm_text: "th.fsurw fa0, a1, a2, 3" diff --git a/tests/MC/RISCV/rv64xtheadmac_valid_riscv64_riscv_xtheadmac.txt.yaml b/tests/MC/RISCV/rv64xtheadmac_valid_riscv64_riscv_xtheadmac.txt.yaml new file mode 100644 index 0000000000..1ac7621ebd --- /dev/null +++ b/tests/MC/RISCV/rv64xtheadmac_valid_riscv64_riscv_xtheadmac.txt.yaml @@ -0,0 +1,60 @@ +test_cases: + - + input: + bytes: [ 0x0b, 0x95, 0xc5, 0x20 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADMAC" ] + expected: + insns: + - + asm_text: "th.mula a0, a1, a2" + + - + input: + bytes: [ 0x0b, 0x95, 0xc5, 0x28 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADMAC" ] + expected: + insns: + - + asm_text: "th.mulah a0, a1, a2" + + - + input: + bytes: [ 0x0b, 0x95, 0xc5, 0x24 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADMAC" ] + expected: + insns: + - + asm_text: "th.mulaw a0, a1, a2" + + - + input: + bytes: [ 0x0b, 0x95, 0xc5, 0x22 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADMAC" ] + expected: + insns: + - + asm_text: "th.muls a0, a1, a2" + + - + input: + bytes: [ 0x0b, 0x95, 0xc5, 0x2a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADMAC" ] + expected: + insns: + - + asm_text: "th.mulsh a0, a1, a2" + + - + input: + bytes: [ 0x0b, 0x95, 0xc5, 0x26 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADMAC" ] + expected: + insns: + - + asm_text: "th.mulsw a0, a1, a2" diff --git a/tests/MC/RISCV/rv64xtheadmemidx_valid_riscv64_riscv_xtheadmemidx.txt.yaml b/tests/MC/RISCV/rv64xtheadmemidx_valid_riscv64_riscv_xtheadmemidx.txt.yaml new file mode 100644 index 0000000000..d024a0b12e --- /dev/null +++ b/tests/MC/RISCV/rv64xtheadmemidx_valid_riscv64_riscv_xtheadmemidx.txt.yaml @@ -0,0 +1,440 @@ +test_cases: + - + input: + bytes: [ 0x0b, 0xc5, 0x05, 0x78 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.ldia a0, (a1), 0, 0" + + - + input: + bytes: [ 0x0b, 0xc5, 0xf5, 0x6a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.ldib a0, (a1), 15, 1" + + - + input: + bytes: [ 0x0b, 0xc5, 0x05, 0x5c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.lwia a0, (a1), 0, 2" + + - + input: + bytes: [ 0x0b, 0xc5, 0x05, 0x4f ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.lwib a0, (a1), -16, 3" + + - + input: + bytes: [ 0x0b, 0xc5, 0x05, 0xd8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.lwuia a0, (a1), 0, 0" + + - + input: + bytes: [ 0x0b, 0xc5, 0xf5, 0xca ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.lwuib a0, (a1), 15, 1" + + - + input: + bytes: [ 0x0b, 0xc5, 0x05, 0x3c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.lhia a0, (a1), 0, 2" + + - + input: + bytes: [ 0x0b, 0xc5, 0x05, 0x2f ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.lhib a0, (a1), -16, 3" + + - + input: + bytes: [ 0x0b, 0xc5, 0x05, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.lhuia a0, (a1), 0, 0" + + - + input: + bytes: [ 0x0b, 0xc5, 0xf5, 0xaa ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.lhuib a0, (a1), 15, 1" + + - + input: + bytes: [ 0x0b, 0xc5, 0x05, 0x1c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.lbia a0, (a1), 0, 2" + + - + input: + bytes: [ 0x0b, 0xc5, 0x05, 0x0f ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.lbib a0, (a1), -16, 3" + + - + input: + bytes: [ 0x0b, 0xc5, 0x05, 0x98 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.lbuia a0, (a1), 0, 0" + + - + input: + bytes: [ 0x0b, 0xc5, 0xf5, 0x8a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.lbuib a0, (a1), 15, 1" + + - + input: + bytes: [ 0x0b, 0xd5, 0x05, 0x79 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.sdia a0, (a1), -16, 0" + + - + input: + bytes: [ 0x0b, 0xd5, 0xf5, 0x6b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.sdib a0, (a1), -1, 1" + + - + input: + bytes: [ 0x0b, 0xd5, 0x05, 0x5c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.swia a0, (a1), 0, 2" + + - + input: + bytes: [ 0x0b, 0xd5, 0x15, 0x4e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.swib a0, (a1), 1, 3" + + - + input: + bytes: [ 0x0b, 0xd5, 0x45, 0x38 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.shia a0, (a1), 4, 0" + + - + input: + bytes: [ 0x0b, 0xd5, 0xd5, 0x2a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.shib a0, (a1), 13, 1" + + - + input: + bytes: [ 0x0b, 0xd5, 0xe5, 0x1c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.sbia a0, (a1), 14, 2" + + - + input: + bytes: [ 0x0b, 0xd5, 0xf5, 0x0e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.sbib a0, (a1), 15, 3" + + - + input: + bytes: [ 0x0b, 0xc5, 0xc5, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.lrd a0, a1, a2, 0" + + - + input: + bytes: [ 0x0b, 0xc5, 0xc5, 0x42 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.lrw a0, a1, a2, 1" + + - + input: + bytes: [ 0x0b, 0xc5, 0xc5, 0xc4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.lrwu a0, a1, a2, 2" + + - + input: + bytes: [ 0x0b, 0xc5, 0xc5, 0x26 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.lrh a0, a1, a2, 3" + + - + input: + bytes: [ 0x0b, 0xc5, 0xc5, 0xa0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.lrhu a0, a1, a2, 0" + + - + input: + bytes: [ 0x0b, 0xc5, 0xc5, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.lrb a0, a1, a2, 1" + + - + input: + bytes: [ 0x0b, 0xc5, 0xc5, 0x84 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.lrbu a0, a1, a2, 2" + + - + input: + bytes: [ 0x0b, 0xd5, 0xc5, 0x66 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.srd a0, a1, a2, 3" + + - + input: + bytes: [ 0x0b, 0xd5, 0xc5, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.srw a0, a1, a2, 0" + + - + input: + bytes: [ 0x0b, 0xd5, 0xc5, 0x22 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.srh a0, a1, a2, 1" + + - + input: + bytes: [ 0x0b, 0xd5, 0xc5, 0x04 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.srb a0, a1, a2, 2" + + - + input: + bytes: [ 0x0b, 0xc5, 0xc5, 0x70 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.lurd a0, a1, a2, 0" + + - + input: + bytes: [ 0x0b, 0xc5, 0xc5, 0x52 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.lurw a0, a1, a2, 1" + + - + input: + bytes: [ 0x0b, 0xc5, 0xc5, 0xd4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.lurwu a0, a1, a2, 2" + + - + input: + bytes: [ 0x0b, 0xc5, 0xc5, 0x36 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.lurh a0, a1, a2, 3" + + - + input: + bytes: [ 0x0b, 0xc5, 0xc5, 0xb0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.lurhu a0, a1, a2, 0" + + - + input: + bytes: [ 0x0b, 0xc5, 0xc5, 0x12 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.lurb a0, a1, a2, 1" + + - + input: + bytes: [ 0x0b, 0xc5, 0xc5, 0x94 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.lurbu a0, a1, a2, 2" + + - + input: + bytes: [ 0x0b, 0xd5, 0xc5, 0x76 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.surd a0, a1, a2, 3" + + - + input: + bytes: [ 0x0b, 0xd5, 0xc5, 0x50 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.surw a0, a1, a2, 0" + + - + input: + bytes: [ 0x0b, 0xd5, 0xc5, 0x32 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.surh a0, a1, a2, 1" + + - + input: + bytes: [ 0x0b, 0xd5, 0xc5, 0x14 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADMEMIDX" ] + expected: + insns: + - + asm_text: "th.surb a0, a1, a2, 2" diff --git a/tests/MC/RISCV/rv64xtheadmempair_valid_riscv64_riscv_xtheadmempair.txt.yaml b/tests/MC/RISCV/rv64xtheadmempair_valid_riscv64_riscv_xtheadmempair.txt.yaml new file mode 100644 index 0000000000..ff72dc8d02 --- /dev/null +++ b/tests/MC/RISCV/rv64xtheadmempair_valid_riscv64_riscv_xtheadmempair.txt.yaml @@ -0,0 +1,50 @@ +test_cases: + - + input: + bytes: [ 0x0b, 0x45, 0xb6, 0xe2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADMEMPAIR" ] + expected: + insns: + - + asm_text: "th.lwd a0, a1, (a2), 1, 3" + + - + input: + bytes: [ 0x0b, 0x45, 0xb6, 0xf4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADMEMPAIR" ] + expected: + insns: + - + asm_text: "th.lwud a0, a1, (a2), 2, 3" + + - + input: + bytes: [ 0x0b, 0x55, 0xb6, 0xe0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADMEMPAIR" ] + expected: + insns: + - + asm_text: "th.swd a0, a1, (a2), 0, 3" + + - + input: + bytes: [ 0x0b, 0x45, 0xb6, 0xf8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADMEMPAIR" ] + expected: + insns: + - + asm_text: "th.ldd a0, a1, (a2), 0, 4" + + - + input: + bytes: [ 0x0b, 0x55, 0xb6, 0xfe ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_XTHEADMEMPAIR" ] + expected: + insns: + - + asm_text: "th.sdd a0, a1, (a2), 3, 4" diff --git a/tests/MC/RISCV/rv64zaamo_valid_riscv64_riscv_a_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rv64zaamo_valid_riscv64_riscv_a_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..856c0f7e96 --- /dev/null +++ b/tests/MC/RISCV/rv64zaamo_valid_riscv64_riscv_a_syntax_no_alias_text.txt.yaml @@ -0,0 +1,360 @@ +test_cases: + - + input: + bytes: [ 0x2f, 0x37, 0x14, 0x08 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amoswap.d a4, ra, (s0)" + + - + input: + bytes: [ 0xaf, 0xb5, 0xc6, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amoadd.d a1, a2, (a3)" + + - + input: + bytes: [ 0x2f, 0x36, 0xd7, 0x20 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amoxor.d a2, a3, (a4)" + + - + input: + bytes: [ 0xaf, 0xb6, 0xe7, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amoand.d a3, a4, (a5)" + + - + input: + bytes: [ 0x2f, 0x37, 0xf8, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amoor.d a4, a5, (a6)" + + - + input: + bytes: [ 0xaf, 0xb7, 0x08, 0x81 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amomin.d a5, a6, (a7)" + + - + input: + bytes: [ 0xaf, 0xbb, 0x6a, 0xa1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amomax.d s7, s6, (s5)" + + - + input: + bytes: [ 0x2f, 0x3b, 0x5a, 0xc1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amominu.d s6, s5, (s4)" + + - + input: + bytes: [ 0xaf, 0xba, 0x49, 0xe1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amomaxu.d s5, s4, (s3)" + + - + input: + bytes: [ 0x2f, 0x37, 0x14, 0x0c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amoswap.d.aq a4, ra, (s0)" + + - + input: + bytes: [ 0xaf, 0xb5, 0xc6, 0x04 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amoadd.d.aq a1, a2, (a3)" + + - + input: + bytes: [ 0x2f, 0x36, 0xd7, 0x24 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amoxor.d.aq a2, a3, (a4)" + + - + input: + bytes: [ 0xaf, 0xb6, 0xe7, 0x64 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amoand.d.aq a3, a4, (a5)" + + - + input: + bytes: [ 0x2f, 0x37, 0xf8, 0x44 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amoor.d.aq a4, a5, (a6)" + + - + input: + bytes: [ 0xaf, 0xb7, 0x08, 0x85 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amomin.d.aq a5, a6, (a7)" + + - + input: + bytes: [ 0xaf, 0xbb, 0x6a, 0xa5 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amomax.d.aq s7, s6, (s5)" + + - + input: + bytes: [ 0x2f, 0x3b, 0x5a, 0xc5 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amominu.d.aq s6, s5, (s4)" + + - + input: + bytes: [ 0xaf, 0xba, 0x49, 0xe5 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amomaxu.d.aq s5, s4, (s3)" + + - + input: + bytes: [ 0x2f, 0x37, 0x14, 0x0a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amoswap.d.rl a4, ra, (s0)" + + - + input: + bytes: [ 0xaf, 0xb5, 0xc6, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amoadd.d.rl a1, a2, (a3)" + + - + input: + bytes: [ 0x2f, 0x36, 0xd7, 0x22 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amoxor.d.rl a2, a3, (a4)" + + - + input: + bytes: [ 0xaf, 0xb6, 0xe7, 0x62 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amoand.d.rl a3, a4, (a5)" + + - + input: + bytes: [ 0x2f, 0x37, 0xf8, 0x42 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amoor.d.rl a4, a5, (a6)" + + - + input: + bytes: [ 0xaf, 0xb7, 0x08, 0x83 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amomin.d.rl a5, a6, (a7)" + + - + input: + bytes: [ 0xaf, 0xbb, 0x6a, 0xa3 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amomax.d.rl s7, s6, (s5)" + + - + input: + bytes: [ 0x2f, 0x3b, 0x5a, 0xc3 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amominu.d.rl s6, s5, (s4)" + + - + input: + bytes: [ 0xaf, 0xba, 0x49, 0xe3 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amomaxu.d.rl s5, s4, (s3)" + + - + input: + bytes: [ 0x2f, 0x37, 0x14, 0x0e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amoswap.d.aqrl a4, ra, (s0)" + + - + input: + bytes: [ 0xaf, 0xb5, 0xc6, 0x06 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amoadd.d.aqrl a1, a2, (a3)" + + - + input: + bytes: [ 0x2f, 0x36, 0xd7, 0x26 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amoxor.d.aqrl a2, a3, (a4)" + + - + input: + bytes: [ 0xaf, 0xb6, 0xe7, 0x66 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amoand.d.aqrl a3, a4, (a5)" + + - + input: + bytes: [ 0x2f, 0x37, 0xf8, 0x46 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amoor.d.aqrl a4, a5, (a6)" + + - + input: + bytes: [ 0xaf, 0xb7, 0x08, 0x87 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amomin.d.aqrl a5, a6, (a7)" + + - + input: + bytes: [ 0xaf, 0xbb, 0x6a, 0xa7 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amomax.d.aqrl s7, s6, (s5)" + + - + input: + bytes: [ 0x2f, 0x3b, 0x5a, 0xc7 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amominu.d.aqrl s6, s5, (s4)" + + - + input: + bytes: [ 0xaf, 0xba, 0x49, 0xe7 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amomaxu.d.aqrl s5, s4, (s3)" diff --git a/tests/MC/RISCV/rv64zacas_valid_riscv64_experimental_zacas_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rv64zacas_valid_riscv64_experimental_zacas_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..6b4d8316c9 --- /dev/null +++ b/tests/MC/RISCV/rv64zacas_valid_riscv64_experimental_zacas_syntax_no_alias_text.txt.yaml @@ -0,0 +1,90 @@ +test_cases: + - + input: + bytes: [ 0xaf, 0xb5, 0xd7, 0x28 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "experimental-zacas", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amocas.d a1, a3, (a5)" + + - + input: + bytes: [ 0xaf, 0xb5, 0xd7, 0x2c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "experimental-zacas", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amocas.d.aq a1, a3, (a5)" + + - + input: + bytes: [ 0xaf, 0xb5, 0xd7, 0x2a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "experimental-zacas", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amocas.d.rl a1, a3, (a5)" + + - + input: + bytes: [ 0xaf, 0xb5, 0xd7, 0x2e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "experimental-zacas", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amocas.d.aqrl a1, a3, (a5)" + + - + input: + bytes: [ 0x2f, 0xc5, 0xc5, 0x28 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "experimental-zacas", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amocas.q a0, a2, (a1)" + + - + input: + bytes: [ 0x2f, 0xc0, 0x05, 0x28 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "experimental-zacas", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amocas.q zero, zero, (a1)" + + - + input: + bytes: [ 0x2f, 0xc0, 0x05, 0x2c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "experimental-zacas", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amocas.q.aq zero, zero, (a1)" + + - + input: + bytes: [ 0x2f, 0xc0, 0x05, 0x2a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "experimental-zacas", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amocas.q.rl zero, zero, (a1)" + + - + input: + bytes: [ 0x2f, 0xc0, 0x05, 0x2e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "experimental-zacas", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "amocas.q.aqrl zero, zero, (a1)" diff --git a/tests/MC/RISCV/rv64zalrsc_valid_riscv64_riscv_a_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rv64zalrsc_valid_riscv64_riscv_a_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..362bf48a74 --- /dev/null +++ b/tests/MC/RISCV/rv64zalrsc_valid_riscv64_riscv_a_syntax_no_alias_text.txt.yaml @@ -0,0 +1,80 @@ +test_cases: + - + input: + bytes: [ 0xaf, 0x32, 0x03, 0x10 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "lr.d t0, (t1)" + + - + input: + bytes: [ 0x2f, 0xb3, 0x03, 0x14 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "lr.d.aq t1, (t2)" + + - + input: + bytes: [ 0xaf, 0x33, 0x0e, 0x12 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "lr.d.rl t2, (t3)" + + - + input: + bytes: [ 0x2f, 0xbe, 0x0e, 0x16 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "lr.d.aqrl t3, (t4)" + + - + input: + bytes: [ 0xaf, 0xbf, 0xee, 0x19 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "sc.d t6, t5, (t4)" + + - + input: + bytes: [ 0x2f, 0x3f, 0xde, 0x1d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "sc.d.aq t5, t4, (t3)" + + - + input: + bytes: [ 0xaf, 0xbe, 0xc3, 0x1b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "sc.d.rl t4, t3, (t2)" + + - + input: + bytes: [ 0x2f, 0x3e, 0x73, 0x1e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_A", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "sc.d.aqrl t3, t2, (t1)" diff --git a/tests/MC/RISCV/rv64zba_valid_riscv64_riscv_zba.txt.yaml b/tests/MC/RISCV/rv64zba_valid_riscv64_riscv_zba.txt.yaml new file mode 100644 index 0000000000..ac38b23c4a --- /dev/null +++ b/tests/MC/RISCV/rv64zba_valid_riscv64_riscv_zba.txt.yaml @@ -0,0 +1,50 @@ +test_cases: + - + input: + bytes: [ 0x9b, 0x12, 0x03, 0x08 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZBA" ] + expected: + insns: + - + asm_text: "slli.uw t0, t1, 0" + + - + input: + bytes: [ 0xbb, 0x02, 0x73, 0x08 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZBA" ] + expected: + insns: + - + asm_text: "add.uw t0, t1, t2" + + - + input: + bytes: [ 0xbb, 0x22, 0x73, 0x20 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZBA" ] + expected: + insns: + - + asm_text: "sh1add.uw t0, t1, t2" + + - + input: + bytes: [ 0xbb, 0x42, 0x73, 0x20 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZBA" ] + expected: + insns: + - + asm_text: "sh2add.uw t0, t1, t2" + + - + input: + bytes: [ 0xbb, 0x62, 0x73, 0x20 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZBA" ] + expected: + insns: + - + asm_text: "sh3add.uw t0, t1, t2" diff --git a/tests/MC/RISCV/rv64zbb_valid_riscv64_riscv_zbb_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rv64zbb_valid_riscv64_riscv_zbb_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..194f44ca87 --- /dev/null +++ b/tests/MC/RISCV/rv64zbb_valid_riscv64_riscv_zbb_syntax_no_alias_text.txt.yaml @@ -0,0 +1,160 @@ +test_cases: + - + input: + bytes: [ 0xbb, 0x42, 0x03, 0x08 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZBB", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "zext.h t0, t1" + + - + input: + bytes: [ 0x93, 0x52, 0xf3, 0x63 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZBB", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "rori t0, t1, 63" + + - + input: + bytes: [ 0x93, 0x52, 0x03, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZBB", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "rori t0, t1, 0" + + - + input: + bytes: [ 0x93, 0x52, 0x83, 0x6b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZBB", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "rev8 t0, t1" + + - + input: + bytes: [ 0x9b, 0x12, 0x03, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZBB", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "clzw t0, t1" + + - + input: + bytes: [ 0x9b, 0x12, 0x13, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZBB", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "ctzw t0, t1" + + - + input: + bytes: [ 0x9b, 0x12, 0x23, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZBB", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cpopw t0, t1" + + - + input: + bytes: [ 0x93, 0x02, 0xe0, 0xfe ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZBB", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "addi t0, zero, -18" + + - + input: + bytes: [ 0x93, 0xd2, 0x52, 0x61 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZBB", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "rori t0, t0, 21" + + - + input: + bytes: [ 0x93, 0x02, 0xa0, 0xfa ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZBB", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "addi t0, zero, -86" + + - + input: + bytes: [ 0x93, 0xd2, 0x42, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZBB", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "rori t0, t0, 4" + + - + input: + bytes: [ 0x93, 0xd2, 0x52, 0x62 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZBB", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "rori t0, t0, 37" + + - + input: + bytes: [ 0xbb, 0x12, 0x73, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZBB", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "rolw t0, t1, t2" + + - + input: + bytes: [ 0xbb, 0x52, 0x73, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZBB", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "rorw t0, t1, t2" + + - + input: + bytes: [ 0x9b, 0x52, 0xf3, 0x61 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZBB", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "roriw t0, t1, 31" + + - + input: + bytes: [ 0x9b, 0x52, 0x03, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZBB", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "roriw t0, t1, 0" diff --git a/tests/MC/RISCV/rv64zbkb_valid_riscv64_riscv_zbkb.txt.yaml b/tests/MC/RISCV/rv64zbkb_valid_riscv64_riscv_zbkb.txt.yaml new file mode 100644 index 0000000000..40354480af --- /dev/null +++ b/tests/MC/RISCV/rv64zbkb_valid_riscv64_riscv_zbkb.txt.yaml @@ -0,0 +1,70 @@ +test_cases: + - + input: + bytes: [ 0x93, 0x52, 0x83, 0x6b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZBKB" ] + expected: + insns: + - + asm_text: "rev8 t0, t1" + + - + input: + bytes: [ 0xbb, 0x52, 0x73, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZBKB" ] + expected: + insns: + - + asm_text: "rorw t0, t1, t2" + + - + input: + bytes: [ 0xbb, 0x12, 0x73, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZBKB" ] + expected: + insns: + - + asm_text: "rolw t0, t1, t2" + + - + input: + bytes: [ 0x9b, 0x52, 0xf3, 0x61 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZBKB" ] + expected: + insns: + - + asm_text: "roriw t0, t1, 31" + + - + input: + bytes: [ 0x9b, 0x52, 0x03, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZBKB" ] + expected: + insns: + - + asm_text: "roriw t0, t1, 0" + + - + input: + bytes: [ 0xbb, 0x42, 0x73, 0x08 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZBKB" ] + expected: + insns: + - + asm_text: "packw t0, t1, t2" + + - + input: + bytes: [ 0xbb, 0x42, 0x03, 0x08 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZBKB" ] + expected: + insns: + - + asm_text: "packw t0, t1, zero" diff --git a/tests/MC/RISCV/rv64zcb_valid_riscv64_m_riscv_zbb_riscv_zba__zcb_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rv64zcb_valid_riscv64_m_riscv_zbb_riscv_zba__zcb_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..a69464c6dc --- /dev/null +++ b/tests/MC/RISCV/rv64zcb_valid_riscv64_m_riscv_zbb_riscv_zba__zcb_syntax_no_alias_text.txt.yaml @@ -0,0 +1,10 @@ +test_cases: + - + input: + bytes: [ 0x71, 0x9c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "m", "CS_MODE_RISCV_ZBB", "CS_MODE_RISCV_ZBA", "+zcb", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.zext.w s0" diff --git a/tests/MC/RISCV/rv64zcmp_valid_riscv64_riscv_zcmp_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rv64zcmp_valid_riscv64_riscv_zcmp_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..b7996e05ec --- /dev/null +++ b/tests/MC/RISCV/rv64zcmp_valid_riscv64_riscv_zcmp_syntax_no_alias_text.txt.yaml @@ -0,0 +1,350 @@ +test_cases: + - + input: + bytes: [ 0xa2, 0xac ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.mvsa01 s1, s0" + + - + input: + bytes: [ 0xe2, 0xac ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.mva01s s1, s0" + + - + input: + bytes: [ 0x42, 0xbe ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.popret {ra}, 16" + + - + input: + bytes: [ 0x46, 0xbe ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.popret {ra}, 32" + + - + input: + bytes: [ 0x5e, 0xbe ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.popret {ra, s0}, 64" + + - + input: + bytes: [ 0x62, 0xbe ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.popret {ra, s0-s1}, 32" + + - + input: + bytes: [ 0x72, 0xbe ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.popret {ra, s0-s2}, 32" + + - + input: + bytes: [ 0x86, 0xbe ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.popret {ra, s0-s3}, 64" + + - + input: + bytes: [ 0xa2, 0xbe ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.popret {ra, s0-s5}, 64" + + - + input: + bytes: [ 0xc2, 0xbe ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.popret {ra, s0-s7}, 80" + + - + input: + bytes: [ 0xf2, 0xbe ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.popret {ra, s0-s11}, 112" + + - + input: + bytes: [ 0x42, 0xbc ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.popretz {ra}, 16" + + - + input: + bytes: [ 0x46, 0xbc ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.popretz {ra}, 32" + + - + input: + bytes: [ 0x5e, 0xbc ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.popretz {ra, s0}, 64" + + - + input: + bytes: [ 0x62, 0xbc ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.popretz {ra, s0-s1}, 32" + + - + input: + bytes: [ 0x72, 0xbc ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.popretz {ra, s0-s2}, 32" + + - + input: + bytes: [ 0x86, 0xbc ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.popretz {ra, s0-s3}, 64" + + - + input: + bytes: [ 0xa2, 0xbc ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.popretz {ra, s0-s5}, 64" + + - + input: + bytes: [ 0xc2, 0xbc ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.popretz {ra, s0-s7}, 80" + + - + input: + bytes: [ 0xf2, 0xbc ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.popretz {ra, s0-s11}, 112" + + - + input: + bytes: [ 0x42, 0xba ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.pop {ra}, 16" + + - + input: + bytes: [ 0x46, 0xba ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.pop {ra}, 32" + + - + input: + bytes: [ 0x52, 0xba ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.pop {ra, s0}, 16" + + - + input: + bytes: [ 0x62, 0xba ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.pop {ra, s0-s1}, 32" + + - + input: + bytes: [ 0x72, 0xba ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.pop {ra, s0-s2}, 32" + + - + input: + bytes: [ 0xa2, 0xba ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.pop {ra, s0-s5}, 64" + + - + input: + bytes: [ 0xc2, 0xba ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.pop {ra, s0-s7}, 80" + + - + input: + bytes: [ 0xf2, 0xba ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.pop {ra, s0-s11}, 112" + + - + input: + bytes: [ 0x42, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.push {ra}, -16" + + - + input: + bytes: [ 0x56, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.push {ra, s0}, -32" + + - + input: + bytes: [ 0x62, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.push {ra, s0-s1}, -32" + + - + input: + bytes: [ 0x86, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.push {ra, s0-s3}, -64" + + - + input: + bytes: [ 0xc2, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.push {ra, s0-s7}, -80" + + - + input: + bytes: [ 0xf2, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.push {ra, s0-s11}, -112" + + - + input: + bytes: [ 0xf6, 0xb8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZCMP", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "cm.push {ra, s0-s11}, -128" diff --git a/tests/MC/RISCV/rv64zdinx_valid_riscv64_riscv_zdinx_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rv64zdinx_valid_riscv64_riscv_zdinx_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..7b09f53bbe --- /dev/null +++ b/tests/MC/RISCV/rv64zdinx_valid_riscv64_riscv_zdinx_syntax_no_alias_text.txt.yaml @@ -0,0 +1,80 @@ +test_cases: + - + input: + bytes: [ 0x53, 0xf5, 0x22, 0xc2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZDINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.l.d a0, t0, dyn" + + - + input: + bytes: [ 0xd3, 0x75, 0x33, 0xc2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZDINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.lu.d a1, t1, dyn" + + - + input: + bytes: [ 0x53, 0xfe, 0x26, 0xd2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZDINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.d.l t3, a3, dyn" + + - + input: + bytes: [ 0xd3, 0x7e, 0x37, 0xd2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZDINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.d.lu t4, a4, dyn" + + - + input: + bytes: [ 0x53, 0x8e, 0x26, 0xd2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZDINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.d.l t3, a3, rne" + + - + input: + bytes: [ 0xd3, 0x1e, 0x37, 0xd2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZDINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.d.lu t4, a4, rtz" + + - + input: + bytes: [ 0x53, 0xa5, 0x22, 0xc2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZDINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.l.d a0, t0, rdn" + + - + input: + bytes: [ 0xd3, 0x35, 0x33, 0xc2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZDINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.lu.d a1, t1, rup" diff --git a/tests/MC/RISCV/rv64zfh_valid_riscv64_zfh_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rv64zfh_valid_riscv64_zfh_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..d331c049af --- /dev/null +++ b/tests/MC/RISCV/rv64zfh_valid_riscv64_zfh_syntax_no_alias_text.txt.yaml @@ -0,0 +1,80 @@ +test_cases: + - + input: + bytes: [ 0x53, 0x75, 0x20, 0xc4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.l.h a0, ft0, dyn" + + - + input: + bytes: [ 0xd3, 0xf5, 0x30, 0xc4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.lu.h a1, ft1, dyn" + + - + input: + bytes: [ 0x53, 0x71, 0x26, 0xd4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.h.l ft2, a2, dyn" + + - + input: + bytes: [ 0xd3, 0xf1, 0x36, 0xd4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.h.lu ft3, a3, dyn" + + - + input: + bytes: [ 0x53, 0x07, 0x22, 0xc4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.l.h a4, ft4, rne" + + - + input: + bytes: [ 0xd3, 0x97, 0x32, 0xc4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.lu.h a5, ft5, rtz" + + - + input: + bytes: [ 0x53, 0x23, 0x28, 0xd4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.h.l ft6, a6, rdn" + + - + input: + bytes: [ 0xd3, 0xb3, 0x38, 0xd4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.h.lu ft7, a7, rup" diff --git a/tests/MC/RISCV/rv64zfinx_valid_riscv64_riscv_zfinx_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rv64zfinx_valid_riscv64_riscv_zfinx_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..eb3cc5b7ef --- /dev/null +++ b/tests/MC/RISCV/rv64zfinx_valid_riscv64_riscv_zfinx_syntax_no_alias_text.txt.yaml @@ -0,0 +1,80 @@ +test_cases: + - + input: + bytes: [ 0x53, 0xf5, 0x22, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.l.s a0, t0, dyn" + + - + input: + bytes: [ 0xd3, 0x75, 0x33, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.lu.s a1, t1, dyn" + + - + input: + bytes: [ 0xd3, 0x73, 0x26, 0xd0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.s.l t2, a2, dyn" + + - + input: + bytes: [ 0x53, 0xfe, 0x36, 0xd0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.s.lu t3, a3, dyn" + + - + input: + bytes: [ 0x53, 0x87, 0x2e, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.l.s a4, t4, rne" + + - + input: + bytes: [ 0xd3, 0x17, 0x3f, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.lu.s a5, t5, rtz" + + - + input: + bytes: [ 0xd3, 0x2f, 0x28, 0xd0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.s.l t6, a6, rdn" + + - + input: + bytes: [ 0xd3, 0xbb, 0x38, 0xd0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.s.lu s7, a7, rup" diff --git a/tests/MC/RISCV/rv64zhinx_valid_riscv64_riscv_zfinx_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rv64zhinx_valid_riscv64_riscv_zfinx_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..7145ac1dd7 --- /dev/null +++ b/tests/MC/RISCV/rv64zhinx_valid_riscv64_riscv_zfinx_syntax_no_alias_text.txt.yaml @@ -0,0 +1,80 @@ +test_cases: + - + input: + bytes: [ 0x53, 0xf5, 0x22, 0xc4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.l.h a0, t0, dyn" + + - + input: + bytes: [ 0xd3, 0x75, 0x33, 0xc4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.lu.h a1, t1, dyn" + + - + input: + bytes: [ 0xd3, 0x73, 0x26, 0xd4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.h.l t2, a2, dyn" + + - + input: + bytes: [ 0x53, 0xfe, 0x36, 0xd4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.h.lu t3, a3, dyn" + + - + input: + bytes: [ 0x53, 0x87, 0x2e, 0xc4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.l.h a4, t4, rne" + + - + input: + bytes: [ 0xd3, 0x17, 0x3f, 0xc4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.lu.h a5, t5, rtz" + + - + input: + bytes: [ 0xd3, 0x2f, 0x28, 0xd4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.h.l t6, a6, rdn" + + - + input: + bytes: [ 0xd3, 0xbb, 0x38, 0xd4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZFINX", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.h.lu s7, a7, rup" diff --git a/tests/MC/RISCV/rv64zhinxmin_valid_riscv64_riscv_zfinx__zdinx_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rv64zhinxmin_valid_riscv64_riscv_zfinx__zdinx_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..2a6d80eb18 --- /dev/null +++ b/tests/MC/RISCV/rv64zhinxmin_valid_riscv64_riscv_zfinx__zdinx_syntax_no_alias_text.txt.yaml @@ -0,0 +1,30 @@ +test_cases: + - + input: + bytes: [ 0x53, 0x05, 0x26, 0x42 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZFINX", "+zdinx", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.d.h a0, a2" + + - + input: + bytes: [ 0x53, 0x35, 0x26, 0x42 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZFINX", "+zdinx", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.d.h a0, a2, rup" + + - + input: + bytes: [ 0x53, 0x75, 0x16, 0x44 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_ZFINX", "+zdinx", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvt.h.d a0, a2, dyn" diff --git a/tests/MC/RISCV/rv64zknd_only_valid_riscv64_zknd.txt.yaml b/tests/MC/RISCV/rv64zknd_only_valid_riscv64_zknd.txt.yaml new file mode 100644 index 0000000000..71ee4f0d0f --- /dev/null +++ b/tests/MC/RISCV/rv64zknd_only_valid_riscv64_zknd.txt.yaml @@ -0,0 +1,50 @@ +test_cases: + - + input: + bytes: [ 0x33, 0x85, 0xc5, 0x3a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "zknd" ] + expected: + insns: + - + asm_text: "aes64ds a0, a1, a2" + + - + input: + bytes: [ 0x33, 0x85, 0xc5, 0x3e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "zknd" ] + expected: + insns: + - + asm_text: "aes64dsm a0, a1, a2" + + - + input: + bytes: [ 0x13, 0x95, 0x05, 0x30 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "zknd" ] + expected: + insns: + - + asm_text: "aes64im a0, a1" + + - + input: + bytes: [ 0x13, 0x95, 0x55, 0x31 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "zknd" ] + expected: + insns: + - + asm_text: "aes64ks1i a0, a1, 5" + + - + input: + bytes: [ 0x33, 0x85, 0xc5, 0x7e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "zknd" ] + expected: + insns: + - + asm_text: "aes64ks2 a0, a1, a2" diff --git a/tests/MC/RISCV/rv64zkne_only_valid_riscv64_zkne.txt.yaml b/tests/MC/RISCV/rv64zkne_only_valid_riscv64_zkne.txt.yaml new file mode 100644 index 0000000000..587440ca4e --- /dev/null +++ b/tests/MC/RISCV/rv64zkne_only_valid_riscv64_zkne.txt.yaml @@ -0,0 +1,40 @@ +test_cases: + - + input: + bytes: [ 0x33, 0x85, 0xc5, 0x32 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "zkne" ] + expected: + insns: + - + asm_text: "aes64es a0, a1, a2" + + - + input: + bytes: [ 0x33, 0x85, 0xc5, 0x36 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "zkne" ] + expected: + insns: + - + asm_text: "aes64esm a0, a1, a2" + + - + input: + bytes: [ 0x13, 0x95, 0x55, 0x31 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "zkne" ] + expected: + insns: + - + asm_text: "aes64ks1i a0, a1, 5" + + - + input: + bytes: [ 0x33, 0x85, 0xc5, 0x7e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "zkne" ] + expected: + insns: + - + asm_text: "aes64ks2 a0, a1, a2" diff --git a/tests/MC/RISCV/rv64zknh_only_valid_riscv64_zknh.txt.yaml b/tests/MC/RISCV/rv64zknh_only_valid_riscv64_zknh.txt.yaml new file mode 100644 index 0000000000..a39e5b8708 --- /dev/null +++ b/tests/MC/RISCV/rv64zknh_only_valid_riscv64_zknh.txt.yaml @@ -0,0 +1,40 @@ +test_cases: + - + input: + bytes: [ 0x13, 0x95, 0x65, 0x10 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "zknh" ] + expected: + insns: + - + asm_text: "sha512sig0 a0, a1" + + - + input: + bytes: [ 0x13, 0x95, 0x75, 0x10 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "zknh" ] + expected: + insns: + - + asm_text: "sha512sig1 a0, a1" + + - + input: + bytes: [ 0x13, 0x95, 0x45, 0x10 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "zknh" ] + expected: + insns: + - + asm_text: "sha512sum0 a0, a1" + + - + input: + bytes: [ 0x13, 0x95, 0x55, 0x10 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "zknh" ] + expected: + insns: + - + asm_text: "sha512sum1 a0, a1" diff --git a/tests/MC/RISCV/rvc_hints_valid_riscv32_riscv_c_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rvc_hints_valid_riscv32_riscv_c_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..d75378b4b8 --- /dev/null +++ b/tests/MC/RISCV/rvc_hints_valid_riscv32_riscv_c_syntax_no_alias_text.txt.yaml @@ -0,0 +1,130 @@ +test_cases: + - + input: + bytes: [ 0x21, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.nop 8" + + - + input: + bytes: [ 0x1d, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.nop 7" + + - + input: + bytes: [ 0x01, 0x05 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.addi a0, 0" + + - + input: + bytes: [ 0x01, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.li zero, 0" + + - + input: + bytes: [ 0x05, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.li zero, 1" + + - + input: + bytes: [ 0x05, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.lui zero, 1" + + - + input: + bytes: [ 0x2a, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.mv zero, a0" + + - + input: + bytes: [ 0x2a, 0x90 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.add zero, a0" + + - + input: + bytes: [ 0x06, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.slli zero, 1" + + - + input: + bytes: [ 0x02, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.slli64 zero" + + - + input: + bytes: [ 0x02, 0x05 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.slli64 a0" + + - + input: + bytes: [ 0x81, 0x81 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.srli64 a1" + + - + input: + bytes: [ 0x01, 0x85 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_C", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "c.srai64 a0" diff --git a/tests/MC/RISCV/rvf_user_csr_names_riscv32_riscv_f_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rvf_user_csr_names_riscv32_riscv_f_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..6703e2082b --- /dev/null +++ b/tests/MC/RISCV/rvf_user_csr_names_riscv32_riscv_f_syntax_no_alias_text.txt.yaml @@ -0,0 +1,60 @@ +test_cases: + - + input: + bytes: [ 0x73, 0x23, 0x10, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, fflags, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x10, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, fflags, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x20, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, frm, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x20, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, frm, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x30, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, fcsr, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x30, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, fcsr, zero" diff --git a/tests/MC/RISCV/rvk_user_csr_name_riscv32_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rvk_user_csr_name_riscv32_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..c5196ec2b5 --- /dev/null +++ b/tests/MC/RISCV/rvk_user_csr_name_riscv32_syntax_no_alias_text.txt.yaml @@ -0,0 +1,20 @@ +test_cases: + - + input: + bytes: [ 0x73, 0x23, 0x50, 0x01 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, seed, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x50, 0x01 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, seed, zero" diff --git a/tests/MC/RISCV/rvv_user_csr_names_riscv32_riscv_f_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rvv_user_csr_names_riscv32_riscv_f_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..d431c47612 --- /dev/null +++ b/tests/MC/RISCV/rvv_user_csr_names_riscv32_riscv_f_syntax_no_alias_text.txt.yaml @@ -0,0 +1,140 @@ +test_cases: + - + input: + bytes: [ 0x73, 0x23, 0x80, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, vstart, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x80, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, vstart, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x90, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, vxsat, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x90, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, vxsat, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xa0, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, vxrm, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xa0, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, vxrm, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xf0, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, vcsr, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xf0, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, vcsr, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x00, 0xc2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, vl, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x00, 0xc2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, vl, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x10, 0xc2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, vtype, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x10, 0xc2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, vtype, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x20, 0xc2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, vlenb, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x20, 0xc2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_F", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, vlenb, zero" diff --git a/tests/MC/RISCV/rvzcmop_valid_riscv32_experimental_zcmop.txt.yaml b/tests/MC/RISCV/rvzcmop_valid_riscv32_experimental_zcmop.txt.yaml new file mode 100644 index 0000000000..9fded899f6 --- /dev/null +++ b/tests/MC/RISCV/rvzcmop_valid_riscv32_experimental_zcmop.txt.yaml @@ -0,0 +1,80 @@ +test_cases: + - + input: + bytes: [ 0x81, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "experimental-zcmop" ] + expected: + insns: + - + asm_text: "cmop.1" + + - + input: + bytes: [ 0x81, 0x61 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "experimental-zcmop" ] + expected: + insns: + - + asm_text: "cmop.3" + + - + input: + bytes: [ 0x81, 0x62 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "experimental-zcmop" ] + expected: + insns: + - + asm_text: "cmop.5" + + - + input: + bytes: [ 0x81, 0x63 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "experimental-zcmop" ] + expected: + insns: + - + asm_text: "cmop.7" + + - + input: + bytes: [ 0x81, 0x64 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "experimental-zcmop" ] + expected: + insns: + - + asm_text: "cmop.9" + + - + input: + bytes: [ 0x81, 0x65 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "experimental-zcmop" ] + expected: + insns: + - + asm_text: "cmop.11" + + - + input: + bytes: [ 0x81, 0x66 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "experimental-zcmop" ] + expected: + insns: + - + asm_text: "cmop.13" + + - + input: + bytes: [ 0x81, 0x67 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "experimental-zcmop" ] + expected: + insns: + - + asm_text: "cmop.15" diff --git a/tests/MC/RISCV/rvzcmt_user_csr_name_riscv32_riscv_zcmt_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/rvzcmt_user_csr_name_riscv32_riscv_zcmt_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..b6a8831664 --- /dev/null +++ b/tests/MC/RISCV/rvzcmt_user_csr_name_riscv32_riscv_zcmt_syntax_no_alias_text.txt.yaml @@ -0,0 +1,20 @@ +test_cases: + - + input: + bytes: [ 0x73, 0x23, 0x70, 0x01 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZCMT", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, jvt, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x70, 0x01 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_ZCMT", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, jvt, zero" diff --git a/tests/MC/RISCV/rvzimop_valid_riscv32_experimental_zimop.txt.yaml b/tests/MC/RISCV/rvzimop_valid_riscv32_experimental_zimop.txt.yaml new file mode 100644 index 0000000000..5017de81a1 --- /dev/null +++ b/tests/MC/RISCV/rvzimop_valid_riscv32_experimental_zimop.txt.yaml @@ -0,0 +1,40 @@ +test_cases: + - + input: + bytes: [ 0x73, 0xc6, 0xc5, 0x81 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "experimental-zimop" ] + expected: + insns: + - + asm_text: "mop.r.0 a2, a1" + + - + input: + bytes: [ 0x73, 0xc6, 0xf5, 0xcd ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "experimental-zimop" ] + expected: + insns: + - + asm_text: "mop.r.31 a2, a1" + + - + input: + bytes: [ 0xf3, 0x46, 0xb6, 0x82 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "experimental-zimop" ] + expected: + insns: + - + asm_text: "mop.rr.0 a3, a2, a1" + + - + input: + bytes: [ 0xf3, 0x46, 0xb6, 0xce ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "experimental-zimop" ] + expected: + insns: + - + asm_text: "mop.rr.7 a3, a2, a1" diff --git a/tests/MC/RISCV/shift_riscv64_riscv_v.txt.yaml b/tests/MC/RISCV/shift_riscv64_riscv_v.txt.yaml new file mode 100644 index 0000000000..755bc3f3a7 --- /dev/null +++ b/tests/MC/RISCV/shift_riscv64_riscv_v.txt.yaml @@ -0,0 +1,430 @@ +test_cases: + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0x94 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsll.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0x96 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsll.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x94 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsll.vx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x96 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsll.vx v8, v4, a0" + + - + input: + bytes: [ 0x57, 0xb4, 0x4f, 0x94 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsll.vi v8, v4, 31, v0.t" + + - + input: + bytes: [ 0x57, 0xb4, 0x4f, 0x96 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsll.vi v8, v4, 31" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0xa0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsrl.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0xa2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsrl.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0xa0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsrl.vx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0xa2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsrl.vx v8, v4, a0" + + - + input: + bytes: [ 0x57, 0xb4, 0x4f, 0xa0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsrl.vi v8, v4, 31, v0.t" + + - + input: + bytes: [ 0x57, 0xb4, 0x4f, 0xa2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsrl.vi v8, v4, 31" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0xa4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsra.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0xa6 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsra.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0xa4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsra.vx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0xa6 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsra.vx v8, v4, a0" + + - + input: + bytes: [ 0x57, 0xb4, 0x4f, 0xa4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsra.vi v8, v4, 31, v0.t" + + - + input: + bytes: [ 0x57, 0xb4, 0x4f, 0xa6 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsra.vi v8, v4, 31" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0xb0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vnsrl.wv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x02, 0x4a, 0xb0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vnsrl.wv v4, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0xb2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vnsrl.wv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0xb0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vnsrl.wx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0xb2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vnsrl.wx v8, v4, a0" + + - + input: + bytes: [ 0x57, 0xb4, 0x4f, 0xb0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vnsrl.wi v8, v4, 31, v0.t" + + - + input: + bytes: [ 0x57, 0xb4, 0x4f, 0xb2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vnsrl.wi v8, v4, 31" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0xb4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vnsra.wv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0xb6 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vnsra.wv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0xb4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vnsra.wx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0xb6 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vnsra.wx v8, v4, a0" + + - + input: + bytes: [ 0x57, 0xb4, 0x4f, 0xb4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vnsra.wi v8, v4, 31, v0.t" + + - + input: + bytes: [ 0x57, 0xb4, 0x4f, 0xb6 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vnsra.wi v8, v4, 31" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0xa8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vssrl.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0xaa ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vssrl.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0xa8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vssrl.vx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0xaa ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vssrl.vx v8, v4, a0" + + - + input: + bytes: [ 0x57, 0xb4, 0x4f, 0xa8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vssrl.vi v8, v4, 31, v0.t" + + - + input: + bytes: [ 0x57, 0xb4, 0x4f, 0xaa ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vssrl.vi v8, v4, 31" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0xac ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vssra.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0xae ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vssra.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0xac ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vssra.vx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0xae ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vssra.vx v8, v4, a0" + + - + input: + bytes: [ 0x57, 0xb4, 0x4f, 0xac ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vssra.vi v8, v4, 31, v0.t" + + - + input: + bytes: [ 0x57, 0xb4, 0x4f, 0xae ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vssra.vi v8, v4, 31" diff --git a/tests/MC/RISCV/sign_injection_riscv64_riscv_v_riscv_f.txt.yaml b/tests/MC/RISCV/sign_injection_riscv64_riscv_v_riscv_f.txt.yaml new file mode 100644 index 0000000000..c0a9127a75 --- /dev/null +++ b/tests/MC/RISCV/sign_injection_riscv64_riscv_v_riscv_f.txt.yaml @@ -0,0 +1,120 @@ +test_cases: + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0x20 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfsgnj.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0x22 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfsgnj.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0x20 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfsgnj.vf v8, v4, fa0, v0.t" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0x22 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfsgnj.vf v8, v4, fa0" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0x24 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfsgnjn.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0x26 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfsgnjn.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0x24 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfsgnjn.vf v8, v4, fa0, v0.t" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0x26 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfsgnjn.vf v8, v4, fa0" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0x28 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfsgnjx.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0x2a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfsgnjx.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0x28 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfsgnjx.vf v8, v4, fa0, v0.t" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0x2a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_F" ] + expected: + insns: + - + asm_text: "vfsgnjx.vf v8, v4, fa0" diff --git a/tests/MC/RISCV/store_riscv64_riscv_v_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/store_riscv64_riscv_v_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..d7a485e61c --- /dev/null +++ b/tests/MC/RISCV/store_riscv64_riscv_v_syntax_no_alias_text.txt.yaml @@ -0,0 +1,370 @@ +test_cases: + - + input: + bytes: [ 0x27, 0x0c, 0xb5, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsm.v v24, (a0)" + + - + input: + bytes: [ 0x27, 0x0c, 0x05, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vse8.v v24, (a0), v0.t" + + - + input: + bytes: [ 0x27, 0x0c, 0x05, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vse8.v v24, (a0)" + + - + input: + bytes: [ 0x27, 0x5c, 0x05, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vse16.v v24, (a0), v0.t" + + - + input: + bytes: [ 0x27, 0x5c, 0x05, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vse16.v v24, (a0)" + + - + input: + bytes: [ 0x27, 0x6c, 0x05, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vse32.v v24, (a0), v0.t" + + - + input: + bytes: [ 0x27, 0x6c, 0x05, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vse32.v v24, (a0)" + + - + input: + bytes: [ 0x27, 0x7c, 0x05, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vse64.v v24, (a0), v0.t" + + - + input: + bytes: [ 0x27, 0x7c, 0x05, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vse64.v v24, (a0)" + + - + input: + bytes: [ 0x27, 0x0c, 0xb5, 0x08 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsse8.v v24, (a0), a1, v0.t" + + - + input: + bytes: [ 0x27, 0x0c, 0xb5, 0x0a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsse8.v v24, (a0), a1" + + - + input: + bytes: [ 0x27, 0x5c, 0xb5, 0x08 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsse16.v v24, (a0), a1, v0.t" + + - + input: + bytes: [ 0x27, 0x5c, 0xb5, 0x0a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsse16.v v24, (a0), a1" + + - + input: + bytes: [ 0x27, 0x6c, 0xb5, 0x08 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsse32.v v24, (a0), a1, v0.t" + + - + input: + bytes: [ 0x27, 0x6c, 0xb5, 0x0a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsse32.v v24, (a0), a1" + + - + input: + bytes: [ 0x27, 0x7c, 0xb5, 0x08 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsse64.v v24, (a0), a1, v0.t" + + - + input: + bytes: [ 0x27, 0x7c, 0xb5, 0x0a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsse64.v v24, (a0), a1" + + - + input: + bytes: [ 0x27, 0x0c, 0x45, 0x04 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxei8.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x0c, 0x45, 0x06 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxei8.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x5c, 0x45, 0x04 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxei16.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x5c, 0x45, 0x06 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxei16.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x6c, 0x45, 0x04 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxei32.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x6c, 0x45, 0x06 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxei32.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x7c, 0x45, 0x04 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxei64.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x7c, 0x45, 0x06 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxei64.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x0c, 0x45, 0x0c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxei8.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x0c, 0x45, 0x0e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxei8.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x5c, 0x45, 0x0c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxei16.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x5c, 0x45, 0x0e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxei16.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x6c, 0x45, 0x0c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxei32.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x6c, 0x45, 0x0e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxei32.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x7c, 0x45, 0x0c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxei64.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x7c, 0x45, 0x0e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxei64.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x0c, 0x85, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vs1r.v v24, (a0)" + + - + input: + bytes: [ 0x27, 0x0c, 0x85, 0x22 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vs2r.v v24, (a0)" + + - + input: + bytes: [ 0x27, 0x0c, 0x85, 0x62 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vs4r.v v24, (a0)" + + - + input: + bytes: [ 0x27, 0x0c, 0x85, 0xe2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vs8r.v v24, (a0)" diff --git a/tests/MC/RISCV/sub_riscv64_riscv_v.txt.yaml b/tests/MC/RISCV/sub_riscv64_riscv_v.txt.yaml new file mode 100644 index 0000000000..32d8dcb03b --- /dev/null +++ b/tests/MC/RISCV/sub_riscv64_riscv_v.txt.yaml @@ -0,0 +1,500 @@ +test_cases: + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0x08 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsub.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0x0a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsub.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x08 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsub.vx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x0a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsub.vx v8, v4, a0" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x0c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vrsub.vx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x0e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vrsub.vx v8, v4, a0" + + - + input: + bytes: [ 0x57, 0xb4, 0x47, 0x0c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vrsub.vi v8, v4, 15, v0.t" + + - + input: + bytes: [ 0x57, 0xb4, 0x47, 0x0e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vrsub.vi v8, v4, 15" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwsubu.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0xca ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwsubu.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwsubu.vx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0xca ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwsubu.vx v8, v4, a0" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0xcc ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwsub.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0xce ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwsub.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0xcc ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwsub.vx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0xce ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwsub.vx v8, v4, a0" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0xd8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwsubu.wv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0xda ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwsubu.wv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0xd8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwsubu.wx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0xda ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwsubu.wx v8, v4, a0" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0xdc ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwsub.wv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0xde ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwsub.wv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0xdc ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwsub.wx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0xde ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vwsub.wx v8, v4, a0" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsbc.vvm v8, v4, v20, v0" + + - + input: + bytes: [ 0x57, 0x02, 0x4a, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsbc.vvm v4, v4, v20, v0" + + - + input: + bytes: [ 0x57, 0x04, 0x44, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsbc.vvm v8, v4, v8, v0" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsbc.vxm v8, v4, a0, v0" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0x4c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmsbc.vvm v8, v4, v20, v0" + + - + input: + bytes: [ 0x57, 0x02, 0x4a, 0x4c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmsbc.vvm v4, v4, v20, v0" + + - + input: + bytes: [ 0x57, 0x04, 0x44, 0x4c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmsbc.vvm v8, v4, v8, v0" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x4c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmsbc.vxm v8, v4, a0, v0" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0x4e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmsbc.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x4e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vmsbc.vx v8, v4, a0" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0x88 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vssubu.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0x8a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vssubu.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x88 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vssubu.vx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x8a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vssubu.vx v8, v4, a0" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0x8c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vssub.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0x8e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vssub.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x8c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vssub.vx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x8e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vssub.vx v8, v4, a0" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0x2c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vasub.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0x2e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vasub.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0x2c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vasub.vx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0x2e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vasub.vx v8, v4, a0" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0x28 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vasubu.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x24, 0x4a, 0x2a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vasubu.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0x28 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vasubu.vx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x64, 0x45, 0x2a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vasubu.vx v8, v4, a0" diff --git a/tests/MC/RISCV/supervisor_csr_names_riscv32_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/supervisor_csr_names_riscv32_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..2661144ff4 --- /dev/null +++ b/tests/MC/RISCV/supervisor_csr_names_riscv32_syntax_no_alias_text.txt.yaml @@ -0,0 +1,440 @@ +test_cases: + - + input: + bytes: [ 0x73, 0x23, 0x00, 0x10 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, sstatus, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x00, 0x10 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, sstatus, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x40, 0x10 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, sie, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x40, 0x10 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, sie, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x50, 0x10 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, stvec, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x50, 0x10 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, stvec, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x60, 0x10 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, scounteren, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x60, 0x10 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, scounteren, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xd0, 0x14 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, stimecmp, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xd0, 0x14 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, stimecmp, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xa0, 0x10 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, senvcfg, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xa0, 0x10 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, senvcfg, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x00, 0x14 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, sscratch, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x00, 0x14 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, sscratch, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x10, 0x14 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, sepc, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x10, 0x14 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, sepc, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x20, 0x14 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, scause, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x20, 0x14 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, scause, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x30, 0x14 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, stval, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x30, 0x14 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, stval, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x40, 0x14 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, sip, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x40, 0x14 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, sip, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x00, 0x18 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, satp, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x00, 0x18 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, satp, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x80, 0x5a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, scontext, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x80, 0x5a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, scontext, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x00, 0xda ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, scountovf, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x00, 0xda ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, scountovf, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xc0, 0x10 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, sstateen0, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xc0, 0x10 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, sstateen0, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xd0, 0x10 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, sstateen1, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xd0, 0x10 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, sstateen1, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xe0, 0x10 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, sstateen2, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xe0, 0x10 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, sstateen2, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xf0, 0x10 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, sstateen3, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xf0, 0x10 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, sstateen3, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x00, 0x15 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, siselect, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x00, 0x15 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, siselect, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x10, 0x15 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, sireg, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x10, 0x15 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, sireg, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xc0, 0x15 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, stopei, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xc0, 0x15 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, stopei, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x00, 0xdb ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, stopi, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x00, 0xdb ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, stopi, zero" diff --git a/tests/MC/RISCV/user_csr_names_riscv32_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/user_csr_names_riscv32_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..721c807486 --- /dev/null +++ b/tests/MC/RISCV/user_csr_names_riscv32_syntax_no_alias_text.txt.yaml @@ -0,0 +1,640 @@ +test_cases: + - + input: + bytes: [ 0x73, 0x23, 0x00, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, cycle, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x00, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, cycle, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x10, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, time, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x10, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, time, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x20, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, instret, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x20, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, instret, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x30, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hpmcounter3, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x30, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hpmcounter3, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x40, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hpmcounter4, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x40, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hpmcounter4, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x50, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hpmcounter5, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x50, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hpmcounter5, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x60, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hpmcounter6, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x60, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hpmcounter6, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x70, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hpmcounter7, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x70, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hpmcounter7, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x80, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hpmcounter8, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x80, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hpmcounter8, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x90, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hpmcounter9, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x90, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hpmcounter9, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xa0, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hpmcounter10, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xa0, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hpmcounter10, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xb0, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hpmcounter11, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xb0, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hpmcounter11, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xc0, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hpmcounter12, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xc0, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hpmcounter12, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xd0, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hpmcounter13, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xd0, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hpmcounter13, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xe0, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hpmcounter14, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xe0, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hpmcounter14, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xf0, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hpmcounter15, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xf0, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hpmcounter15, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x00, 0xc1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hpmcounter16, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x00, 0xc1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hpmcounter16, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x10, 0xc1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hpmcounter17, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x10, 0xc1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hpmcounter17, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x20, 0xc1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hpmcounter18, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x20, 0xc1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hpmcounter18, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x30, 0xc1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hpmcounter19, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x30, 0xc1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hpmcounter19, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x40, 0xc1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hpmcounter20, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x40, 0xc1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hpmcounter20, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x50, 0xc1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hpmcounter21, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x50, 0xc1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hpmcounter21, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x60, 0xc1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hpmcounter22, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x60, 0xc1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hpmcounter22, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x70, 0xc1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hpmcounter23, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x70, 0xc1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hpmcounter23, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x80, 0xc1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hpmcounter24, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x80, 0xc1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hpmcounter24, zero" + + - + input: + bytes: [ 0x73, 0x23, 0x90, 0xc1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hpmcounter25, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0x90, 0xc1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hpmcounter25, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xa0, 0xc1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hpmcounter26, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xa0, 0xc1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hpmcounter26, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xb0, 0xc1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hpmcounter27, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xb0, 0xc1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hpmcounter27, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xc0, 0xc1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hpmcounter28, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xc0, 0xc1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hpmcounter28, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xd0, 0xc1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hpmcounter29, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xd0, 0xc1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hpmcounter29, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xe0, 0xc1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hpmcounter30, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xe0, 0xc1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hpmcounter30, zero" + + - + input: + bytes: [ 0x73, 0x23, 0xf0, 0xc1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t1, hpmcounter31, zero" + + - + input: + bytes: [ 0xf3, 0x23, 0xf0, 0xc1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "csrrs t2, hpmcounter31, zero" diff --git a/tests/MC/RISCV/vsetvl_riscv64_riscv_v.txt.yaml b/tests/MC/RISCV/vsetvl_riscv64_riscv_v.txt.yaml new file mode 100644 index 0000000000..3776bd9773 --- /dev/null +++ b/tests/MC/RISCV/vsetvl_riscv64_riscv_v.txt.yaml @@ -0,0 +1,160 @@ +test_cases: + - + input: + bytes: [ 0x57, 0x76, 0x45, 0x22 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsetvli a2, a0, 548" + + - + input: + bytes: [ 0x57, 0x76, 0x05, 0x0d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsetvli a2, a0, e32, m1, ta, ma" + + - + input: + bytes: [ 0x57, 0x76, 0x15, 0x0d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsetvli a2, a0, e32, m2, ta, ma" + + - + input: + bytes: [ 0x57, 0x76, 0x05, 0x05 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsetvli a2, a0, e32, m1, ta, mu" + + - + input: + bytes: [ 0x57, 0x76, 0x05, 0x09 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsetvli a2, a0, e32, m1, tu, ma" + + - + input: + bytes: [ 0x57, 0x76, 0x25, 0x0d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsetvli a2, a0, e32, m4, ta, ma" + + - + input: + bytes: [ 0x57, 0x76, 0x35, 0x0d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsetvli a2, a0, e32, m8, ta, ma" + + - + input: + bytes: [ 0x57, 0x76, 0x75, 0x0d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsetvli a2, a0, e32, mf2, ta, ma" + + - + input: + bytes: [ 0x57, 0x76, 0x65, 0x0d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsetvli a2, a0, e32, mf4, ta, ma" + + - + input: + bytes: [ 0x57, 0x76, 0x55, 0x0d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsetvli a2, a0, e32, mf8, ta, ma" + + - + input: + bytes: [ 0x57, 0x76, 0x05, 0x01 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsetvli a2, a0, e32, m1, tu, mu" + + - + input: + bytes: [ 0x57, 0x76, 0xb5, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsetvl a2, a0, a1" + + - + input: + bytes: [ 0x57, 0x76, 0x40, 0xe2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsetivli a2, 0, 548" + + - + input: + bytes: [ 0x57, 0x76, 0x00, 0xcd ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsetivli a2, 0, e32, m1, ta, ma" + + - + input: + bytes: [ 0x57, 0xf6, 0x07, 0xcd ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsetivli a2, 15, e32, m1, ta, ma" + + - + input: + bytes: [ 0x57, 0xf6, 0x0f, 0xcd ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vsetivli a2, 31, e32, m1, ta, ma" diff --git a/tests/MC/RISCV/xor_riscv64_riscv_v.txt.yaml b/tests/MC/RISCV/xor_riscv64_riscv_v.txt.yaml new file mode 100644 index 0000000000..a5b5a6167c --- /dev/null +++ b/tests/MC/RISCV/xor_riscv64_riscv_v.txt.yaml @@ -0,0 +1,80 @@ +test_cases: + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0x2c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vxor.vv v8, v4, v20, v0.t" + + - + input: + bytes: [ 0x57, 0x04, 0x4a, 0x2e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vxor.vv v8, v4, v20" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x2c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vxor.vx v8, v4, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x44, 0x45, 0x2e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vxor.vx v8, v4, a0" + + - + input: + bytes: [ 0x57, 0xb4, 0x47, 0x2c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vxor.vi v8, v4, 15, v0.t" + + - + input: + bytes: [ 0x57, 0xb4, 0x47, 0x2e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vxor.vi v8, v4, 15" + + - + input: + bytes: [ 0x57, 0xb4, 0x4f, 0x2c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vnot.v v8, v4, v0.t" + + - + input: + bytes: [ 0x57, 0xb4, 0x4f, 0x2e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V" ] + expected: + insns: + - + asm_text: "vnot.v v8, v4" diff --git a/tests/MC/RISCV/xsfvcp_riscv32_riscv_v_riscv_xsfvcp.txt.yaml b/tests/MC/RISCV/xsfvcp_riscv32_riscv_v_riscv_xsfvcp.txt.yaml new file mode 100644 index 0000000000..97535ad28b --- /dev/null +++ b/tests/MC/RISCV/xsfvcp_riscv32_riscv_v_riscv_xsfvcp.txt.yaml @@ -0,0 +1,280 @@ +test_cases: + - + input: + bytes: [ 0xdb, 0xcf, 0xf5, 0x0e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_V", "CS_MODE_RISCV_XSFVCP" ] + expected: + insns: + - + asm_text: "sf.vc.x 3, 15, 31, a1" + + - + input: + bytes: [ 0xdb, 0xbf, 0xf7, 0x0e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_V", "CS_MODE_RISCV_XSFVCP" ] + expected: + insns: + - + asm_text: "sf.vc.i 3, 15, 31, 15" + + - + input: + bytes: [ 0xdb, 0x8f, 0x20, 0x2e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_V", "CS_MODE_RISCV_XSFVCP" ] + expected: + insns: + - + asm_text: "sf.vc.vv 3, 31, v2, v1" + + - + input: + bytes: [ 0xdb, 0xcf, 0x25, 0x2e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_V", "CS_MODE_RISCV_XSFVCP" ] + expected: + insns: + - + asm_text: "sf.vc.xv 3, 31, v2, a1" + + - + input: + bytes: [ 0xdb, 0xbf, 0x27, 0x2e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_V", "CS_MODE_RISCV_XSFVCP" ] + expected: + insns: + - + asm_text: "sf.vc.iv 3, 31, v2, 15" + + - + input: + bytes: [ 0xdb, 0xdf, 0x25, 0x2e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_V", "CS_MODE_RISCV_XSFVCP" ] + expected: + insns: + - + asm_text: "sf.vc.fv 1, 31, v2, fa1" + + - + input: + bytes: [ 0x5b, 0x80, 0x20, 0xae ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_V", "CS_MODE_RISCV_XSFVCP" ] + expected: + insns: + - + asm_text: "sf.vc.vvv 3, v0, v2, v1" + + - + input: + bytes: [ 0x5b, 0xc0, 0x25, 0xae ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_V", "CS_MODE_RISCV_XSFVCP" ] + expected: + insns: + - + asm_text: "sf.vc.xvv 3, v0, v2, a1" + + - + input: + bytes: [ 0x5b, 0xb0, 0x27, 0xae ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_V", "CS_MODE_RISCV_XSFVCP" ] + expected: + insns: + - + asm_text: "sf.vc.ivv 3, v0, v2, 15" + + - + input: + bytes: [ 0x5b, 0xd0, 0x25, 0xae ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_V", "CS_MODE_RISCV_XSFVCP" ] + expected: + insns: + - + asm_text: "sf.vc.fvv 1, v0, v2, fa1" + + - + input: + bytes: [ 0x5b, 0x80, 0x20, 0xfe ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_V", "CS_MODE_RISCV_XSFVCP" ] + expected: + insns: + - + asm_text: "sf.vc.vvw 3, v0, v2, v1" + + - + input: + bytes: [ 0x5b, 0xc0, 0x25, 0xfe ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_V", "CS_MODE_RISCV_XSFVCP" ] + expected: + insns: + - + asm_text: "sf.vc.xvw 3, v0, v2, a1" + + - + input: + bytes: [ 0x5b, 0xb0, 0x27, 0xfe ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_V", "CS_MODE_RISCV_XSFVCP" ] + expected: + insns: + - + asm_text: "sf.vc.ivw 3, v0, v2, 15" + + - + input: + bytes: [ 0x5b, 0xd0, 0x25, 0xfe ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_V", "CS_MODE_RISCV_XSFVCP" ] + expected: + insns: + - + asm_text: "sf.vc.fvw 1, v0, v2, fa1" + + - + input: + bytes: [ 0x5b, 0xc0, 0xf5, 0x0c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_V", "CS_MODE_RISCV_XSFVCP" ] + expected: + insns: + - + asm_text: "sf.vc.v.x 3, 15, v0, a1" + + - + input: + bytes: [ 0x5b, 0xb0, 0xf7, 0x0c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_V", "CS_MODE_RISCV_XSFVCP" ] + expected: + insns: + - + asm_text: "sf.vc.v.i 3, 15, v0, 15" + + - + input: + bytes: [ 0x5b, 0x80, 0x20, 0x2c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_V", "CS_MODE_RISCV_XSFVCP" ] + expected: + insns: + - + asm_text: "sf.vc.v.vv 3, v0, v2, v1" + + - + input: + bytes: [ 0x5b, 0xc0, 0x25, 0x2c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_V", "CS_MODE_RISCV_XSFVCP" ] + expected: + insns: + - + asm_text: "sf.vc.v.xv 3, v0, v2, a1" + + - + input: + bytes: [ 0x5b, 0xb0, 0x27, 0x2c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_V", "CS_MODE_RISCV_XSFVCP" ] + expected: + insns: + - + asm_text: "sf.vc.v.iv 3, v0, v2, 15" + + - + input: + bytes: [ 0x5b, 0xd0, 0x25, 0x2c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_V", "CS_MODE_RISCV_XSFVCP" ] + expected: + insns: + - + asm_text: "sf.vc.v.fv 1, v0, v2, fa1" + + - + input: + bytes: [ 0x5b, 0x80, 0x20, 0xac ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_V", "CS_MODE_RISCV_XSFVCP" ] + expected: + insns: + - + asm_text: "sf.vc.v.vvv 3, v0, v2, v1" + + - + input: + bytes: [ 0x5b, 0xc0, 0x25, 0xac ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_V", "CS_MODE_RISCV_XSFVCP" ] + expected: + insns: + - + asm_text: "sf.vc.v.xvv 3, v0, v2, a1" + + - + input: + bytes: [ 0x5b, 0xb0, 0x27, 0xac ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_V", "CS_MODE_RISCV_XSFVCP" ] + expected: + insns: + - + asm_text: "sf.vc.v.ivv 3, v0, v2, 15" + + - + input: + bytes: [ 0x5b, 0xd0, 0x25, 0xac ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_V", "CS_MODE_RISCV_XSFVCP" ] + expected: + insns: + - + asm_text: "sf.vc.v.fvv 1, v0, v2, fa1" + + - + input: + bytes: [ 0x5b, 0x80, 0x20, 0xfc ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_V", "CS_MODE_RISCV_XSFVCP" ] + expected: + insns: + - + asm_text: "sf.vc.v.vvw 3, v0, v2, v1" + + - + input: + bytes: [ 0x5b, 0xc0, 0x25, 0xfc ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_V", "CS_MODE_RISCV_XSFVCP" ] + expected: + insns: + - + asm_text: "sf.vc.v.xvw 3, v0, v2, a1" + + - + input: + bytes: [ 0x5b, 0xb0, 0x27, 0xfc ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_V", "CS_MODE_RISCV_XSFVCP" ] + expected: + insns: + - + asm_text: "sf.vc.v.ivw 3, v0, v2, 15" + + - + input: + bytes: [ 0x5b, 0xd0, 0x25, 0xfc ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_V", "CS_MODE_RISCV_XSFVCP" ] + expected: + insns: + - + asm_text: "sf.vc.v.fvw 1, v0, v2, fa1" diff --git a/tests/MC/RISCV/xsfvfnrclip_riscv64_riscv_v_riscv_xsfvfnrclipxfqf.txt.yaml b/tests/MC/RISCV/xsfvfnrclip_riscv64_riscv_v_riscv_xsfvfnrclipxfqf.txt.yaml new file mode 100644 index 0000000000..e0ca892bff --- /dev/null +++ b/tests/MC/RISCV/xsfvfnrclip_riscv64_riscv_v_riscv_xsfvfnrclipxfqf.txt.yaml @@ -0,0 +1,40 @@ +test_cases: + - + input: + bytes: [ 0x5b, 0x52, 0x86, 0x8a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_XSFVFNRCLIPXFQF" ] + expected: + insns: + - + asm_text: "sf.vfnrclip.xu.f.qf v4, v8, fa2" + + - + input: + bytes: [ 0x5b, 0x52, 0x86, 0x88 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_XSFVFNRCLIPXFQF" ] + expected: + insns: + - + asm_text: "sf.vfnrclip.xu.f.qf v4, v8, fa2, v0.t" + + - + input: + bytes: [ 0x5b, 0x52, 0x86, 0x8e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_XSFVFNRCLIPXFQF" ] + expected: + insns: + - + asm_text: "sf.vfnrclip.x.f.qf v4, v8, fa2" + + - + input: + bytes: [ 0x5b, 0x52, 0x86, 0x8c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_XSFVFNRCLIPXFQF" ] + expected: + insns: + - + asm_text: "sf.vfnrclip.x.f.qf v4, v8, fa2, v0.t" diff --git a/tests/MC/RISCV/xsfvfwmacc_riscv64_riscv_v_riscv_xsfvfwmaccqqq.txt.yaml b/tests/MC/RISCV/xsfvfwmacc_riscv64_riscv_v_riscv_xsfvfwmaccqqq.txt.yaml new file mode 100644 index 0000000000..89181055a2 --- /dev/null +++ b/tests/MC/RISCV/xsfvfwmacc_riscv64_riscv_v_riscv_xsfvfwmaccqqq.txt.yaml @@ -0,0 +1,10 @@ +test_cases: + - + input: + bytes: [ 0x5b, 0x14, 0x42, 0xf3 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_XSFVFWMACCQQQ" ] + expected: + insns: + - + asm_text: "sf.vfwmacc.4x4x4 v8, v4, v20" diff --git a/tests/MC/RISCV/xsfvqmacc_riscv64_riscv_v_riscv_xsfvqmaccqoq_riscv_xsfvqmaccdod.txt.yaml b/tests/MC/RISCV/xsfvqmacc_riscv64_riscv_v_riscv_xsfvqmaccqoq_riscv_xsfvqmaccdod.txt.yaml new file mode 100644 index 0000000000..691ff485a9 --- /dev/null +++ b/tests/MC/RISCV/xsfvqmacc_riscv64_riscv_v_riscv_xsfvqmaccqoq_riscv_xsfvqmaccdod.txt.yaml @@ -0,0 +1,80 @@ +test_cases: + - + input: + bytes: [ 0x5b, 0x24, 0x42, 0xb3 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_XSFVQMACCQOQ", "CS_MODE_RISCV_XSFVQMACCDOD" ] + expected: + insns: + - + asm_text: "sf.vqmaccu.2x8x2 v8, v4, v20" + + - + input: + bytes: [ 0x5b, 0x24, 0x42, 0xb7 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_XSFVQMACCQOQ", "CS_MODE_RISCV_XSFVQMACCDOD" ] + expected: + insns: + - + asm_text: "sf.vqmacc.2x8x2 v8, v4, v20" + + - + input: + bytes: [ 0x5b, 0x24, 0x42, 0xbb ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_XSFVQMACCQOQ", "CS_MODE_RISCV_XSFVQMACCDOD" ] + expected: + insns: + - + asm_text: "sf.vqmaccus.2x8x2 v8, v4, v20" + + - + input: + bytes: [ 0x5b, 0x24, 0x42, 0xbf ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_XSFVQMACCQOQ", "CS_MODE_RISCV_XSFVQMACCDOD" ] + expected: + insns: + - + asm_text: "sf.vqmaccsu.2x8x2 v8, v4, v20" + + - + input: + bytes: [ 0x5b, 0x24, 0x42, 0xf3 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_XSFVQMACCQOQ", "CS_MODE_RISCV_XSFVQMACCDOD" ] + expected: + insns: + - + asm_text: "sf.vqmaccu.4x8x4 v8, v4, v20" + + - + input: + bytes: [ 0x5b, 0x24, 0x42, 0xf7 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_XSFVQMACCQOQ", "CS_MODE_RISCV_XSFVQMACCDOD" ] + expected: + insns: + - + asm_text: "sf.vqmacc.4x8x4 v8, v4, v20" + + - + input: + bytes: [ 0x5b, 0x24, 0x42, 0xfb ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_XSFVQMACCQOQ", "CS_MODE_RISCV_XSFVQMACCDOD" ] + expected: + insns: + - + asm_text: "sf.vqmaccus.4x8x4 v8, v4, v20" + + - + input: + bytes: [ 0x5b, 0x24, 0x42, 0xff ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_MODE_RISCV_XSFVQMACCQOQ", "CS_MODE_RISCV_XSFVQMACCDOD" ] + expected: + insns: + - + asm_text: "sf.vqmaccsu.4x8x4 v8, v4, v20" diff --git a/tests/MC/RISCV/xtheadcmo_valid_riscv32_riscv_xtheadcmo.txt.yaml b/tests/MC/RISCV/xtheadcmo_valid_riscv32_riscv_xtheadcmo.txt.yaml new file mode 100644 index 0000000000..4162b01c85 --- /dev/null +++ b/tests/MC/RISCV/xtheadcmo_valid_riscv32_riscv_xtheadcmo.txt.yaml @@ -0,0 +1,210 @@ +test_cases: + - + input: + bytes: [ 0x0b, 0x00, 0x18, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADCMO" ] + expected: + insns: + - + asm_text: "th.dcache.csw a6" + + - + input: + bytes: [ 0x0b, 0x80, 0x22, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADCMO" ] + expected: + insns: + - + asm_text: "th.dcache.isw t0" + + - + input: + bytes: [ 0x0b, 0x80, 0x38, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADCMO" ] + expected: + insns: + - + asm_text: "th.dcache.cisw a7" + + - + input: + bytes: [ 0x0b, 0x80, 0x43, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADCMO" ] + expected: + insns: + - + asm_text: "th.dcache.cval1 t2" + + - + input: + bytes: [ 0x0b, 0x80, 0x56, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADCMO" ] + expected: + insns: + - + asm_text: "th.dcache.cva a3" + + - + input: + bytes: [ 0x0b, 0x80, 0x67, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADCMO" ] + expected: + insns: + - + asm_text: "th.dcache.iva a5" + + - + input: + bytes: [ 0x0b, 0x00, 0x77, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADCMO" ] + expected: + insns: + - + asm_text: "th.dcache.civa a4" + + - + input: + bytes: [ 0x0b, 0x00, 0x83, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADCMO" ] + expected: + insns: + - + asm_text: "th.dcache.cpal1 t1" + + - + input: + bytes: [ 0x0b, 0x00, 0x95, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADCMO" ] + expected: + insns: + - + asm_text: "th.dcache.cpa a0" + + - + input: + bytes: [ 0x0b, 0x00, 0xa6, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADCMO" ] + expected: + insns: + - + asm_text: "th.dcache.ipa a2" + + - + input: + bytes: [ 0x0b, 0x80, 0xb5, 0x02 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADCMO" ] + expected: + insns: + - + asm_text: "th.dcache.cipa a1" + + - + input: + bytes: [ 0x0b, 0x80, 0x0e, 0x03 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADCMO" ] + expected: + insns: + - + asm_text: "th.icache.iva t4" + + - + input: + bytes: [ 0x0b, 0x00, 0x8e, 0x03 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADCMO" ] + expected: + insns: + - + asm_text: "th.icache.ipa t3" + + - + input: + bytes: [ 0x0b, 0x00, 0x10, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADCMO" ] + expected: + insns: + - + asm_text: "th.dcache.call" + + - + input: + bytes: [ 0x0b, 0x00, 0x20, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADCMO" ] + expected: + insns: + - + asm_text: "th.dcache.iall" + + - + input: + bytes: [ 0x0b, 0x00, 0x30, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADCMO" ] + expected: + insns: + - + asm_text: "th.dcache.ciall" + + - + input: + bytes: [ 0x0b, 0x00, 0x00, 0x01 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADCMO" ] + expected: + insns: + - + asm_text: "th.icache.iall" + + - + input: + bytes: [ 0x0b, 0x00, 0x10, 0x01 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADCMO" ] + expected: + insns: + - + asm_text: "th.icache.ialls" + + - + input: + bytes: [ 0x0b, 0x00, 0x50, 0x01 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADCMO" ] + expected: + insns: + - + asm_text: "th.l2cache.call" + + - + input: + bytes: [ 0x0b, 0x00, 0x60, 0x01 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADCMO" ] + expected: + insns: + - + asm_text: "th.l2cache.iall" + + - + input: + bytes: [ 0x0b, 0x00, 0x70, 0x01 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADCMO" ] + expected: + insns: + - + asm_text: "th.l2cache.ciall" diff --git a/tests/MC/RISCV/xtheadcondmov_valid_riscv32_riscv_xtheadcondmov.txt.yaml b/tests/MC/RISCV/xtheadcondmov_valid_riscv32_riscv_xtheadcondmov.txt.yaml new file mode 100644 index 0000000000..6e7a5ebad9 --- /dev/null +++ b/tests/MC/RISCV/xtheadcondmov_valid_riscv32_riscv_xtheadcondmov.txt.yaml @@ -0,0 +1,20 @@ +test_cases: + - + input: + bytes: [ 0x0b, 0x95, 0xc5, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADCONDMOV" ] + expected: + insns: + - + asm_text: "th.mveqz a0, a1, a2" + + - + input: + bytes: [ 0x0b, 0x95, 0xc5, 0x42 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADCONDMOV" ] + expected: + insns: + - + asm_text: "th.mvnez a0, a1, a2" diff --git a/tests/MC/RISCV/xtheadsync_valid_riscv32_riscv_xtheadsync.txt.yaml b/tests/MC/RISCV/xtheadsync_valid_riscv32_riscv_xtheadsync.txt.yaml new file mode 100644 index 0000000000..6d7f12634a --- /dev/null +++ b/tests/MC/RISCV/xtheadsync_valid_riscv32_riscv_xtheadsync.txt.yaml @@ -0,0 +1,50 @@ +test_cases: + - + input: + bytes: [ 0x0b, 0x00, 0xb5, 0x04 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADSYNC" ] + expected: + insns: + - + asm_text: "th.sfence.vmas a0, a1" + + - + input: + bytes: [ 0x0b, 0x00, 0x80, 0x01 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADSYNC" ] + expected: + insns: + - + asm_text: "th.sync" + + - + input: + bytes: [ 0x0b, 0x00, 0xa0, 0x01 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADSYNC" ] + expected: + insns: + - + asm_text: "th.sync.i" + + - + input: + bytes: [ 0x0b, 0x00, 0xb0, 0x01 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADSYNC" ] + expected: + insns: + - + asm_text: "th.sync.is" + + - + input: + bytes: [ 0x0b, 0x00, 0x90, 0x01 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_XTHEADSYNC" ] + expected: + insns: + - + asm_text: "th.sync.s" diff --git a/tests/MC/RISCV/zfa_valid_riscv32_zfa_riscv_d__zfh_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/zfa_valid_riscv32_zfa_riscv_d__zfh_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..11631ad4ae --- /dev/null +++ b/tests/MC/RISCV/zfa_valid_riscv32_zfa_riscv_d__zfh_syntax_no_alias_text.txt.yaml @@ -0,0 +1,1330 @@ +test_cases: + - + input: + bytes: [ 0xd3, 0x00, 0x10, 0xf0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.s ft1, -1.0" + + - + input: + bytes: [ 0xd3, 0x80, 0x10, 0xf0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.s ft1, min" + + - + input: + bytes: [ 0xd3, 0x00, 0x11, 0xf0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.s ft1, 1.52587890625e-05" + + - + input: + bytes: [ 0xd3, 0x80, 0x11, 0xf0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.s ft1, 3.0517578125e-05" + + - + input: + bytes: [ 0xd3, 0x00, 0x12, 0xf0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.s ft1, 0.00390625" + + - + input: + bytes: [ 0xd3, 0x80, 0x12, 0xf0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.s ft1, 0.0078125" + + - + input: + bytes: [ 0xd3, 0x00, 0x13, 0xf0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.s ft1, 0.0625" + + - + input: + bytes: [ 0xd3, 0x80, 0x13, 0xf0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.s ft1, 0.125" + + - + input: + bytes: [ 0xd3, 0x00, 0x14, 0xf0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.s ft1, 0.25" + + - + input: + bytes: [ 0xd3, 0x80, 0x14, 0xf0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.s ft1, 0.3125" + + - + input: + bytes: [ 0xd3, 0x00, 0x15, 0xf0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.s ft1, 0.375" + + - + input: + bytes: [ 0xd3, 0x80, 0x15, 0xf0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.s ft1, 0.4375" + + - + input: + bytes: [ 0xd3, 0x00, 0x16, 0xf0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.s ft1, 0.5" + + - + input: + bytes: [ 0xd3, 0x80, 0x16, 0xf0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.s ft1, 0.625" + + - + input: + bytes: [ 0xd3, 0x00, 0x17, 0xf0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.s ft1, 0.75" + + - + input: + bytes: [ 0xd3, 0x80, 0x17, 0xf0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.s ft1, 0.875" + + - + input: + bytes: [ 0xd3, 0x00, 0x18, 0xf0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.s ft1, 1.0" + + - + input: + bytes: [ 0xd3, 0x80, 0x18, 0xf0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.s ft1, 1.25" + + - + input: + bytes: [ 0xd3, 0x00, 0x19, 0xf0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.s ft1, 1.5" + + - + input: + bytes: [ 0xd3, 0x80, 0x19, 0xf0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.s ft1, 1.75" + + - + input: + bytes: [ 0xd3, 0x00, 0x1a, 0xf0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.s ft1, 2.0" + + - + input: + bytes: [ 0xd3, 0x80, 0x1a, 0xf0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.s ft1, 2.5" + + - + input: + bytes: [ 0xd3, 0x00, 0x1b, 0xf0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.s ft1, 3.0" + + - + input: + bytes: [ 0xd3, 0x80, 0x1b, 0xf0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.s ft1, 4.0" + + - + input: + bytes: [ 0xd3, 0x00, 0x1c, 0xf0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.s ft1, 8.0" + + - + input: + bytes: [ 0xd3, 0x80, 0x1c, 0xf0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.s ft1, 16.0" + + - + input: + bytes: [ 0xd3, 0x00, 0x1d, 0xf0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.s ft1, 128.0" + + - + input: + bytes: [ 0xd3, 0x80, 0x1d, 0xf0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.s ft1, 256.0" + + - + input: + bytes: [ 0xd3, 0x00, 0x1e, 0xf0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.s ft1, 32768.0" + + - + input: + bytes: [ 0xd3, 0x80, 0x1e, 0xf0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.s ft1, 65536.0" + + - + input: + bytes: [ 0xd3, 0x00, 0x1f, 0xf0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.s ft1, inf" + + - + input: + bytes: [ 0xd3, 0x80, 0x1f, 0xf0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.s ft1, nan" + + - + input: + bytes: [ 0xd3, 0x00, 0x10, 0xf2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.d ft1, -1.0" + + - + input: + bytes: [ 0xd3, 0x80, 0x10, 0xf2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.d ft1, min" + + - + input: + bytes: [ 0xd3, 0x00, 0x11, 0xf2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.d ft1, 1.52587890625e-05" + + - + input: + bytes: [ 0xd3, 0x80, 0x11, 0xf2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.d ft1, 3.0517578125e-05" + + - + input: + bytes: [ 0xd3, 0x00, 0x12, 0xf2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.d ft1, 0.00390625" + + - + input: + bytes: [ 0xd3, 0x80, 0x12, 0xf2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.d ft1, 0.0078125" + + - + input: + bytes: [ 0xd3, 0x00, 0x13, 0xf2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.d ft1, 0.0625" + + - + input: + bytes: [ 0xd3, 0x80, 0x13, 0xf2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.d ft1, 0.125" + + - + input: + bytes: [ 0xd3, 0x00, 0x14, 0xf2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.d ft1, 0.25" + + - + input: + bytes: [ 0xd3, 0x80, 0x14, 0xf2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.d ft1, 0.3125" + + - + input: + bytes: [ 0xd3, 0x00, 0x15, 0xf2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.d ft1, 0.375" + + - + input: + bytes: [ 0xd3, 0x80, 0x15, 0xf2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.d ft1, 0.4375" + + - + input: + bytes: [ 0xd3, 0x00, 0x16, 0xf2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.d ft1, 0.5" + + - + input: + bytes: [ 0xd3, 0x80, 0x16, 0xf2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.d ft1, 0.625" + + - + input: + bytes: [ 0xd3, 0x00, 0x17, 0xf2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.d ft1, 0.75" + + - + input: + bytes: [ 0xd3, 0x80, 0x17, 0xf2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.d ft1, 0.875" + + - + input: + bytes: [ 0xd3, 0x00, 0x18, 0xf2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.d ft1, 1.0" + + - + input: + bytes: [ 0xd3, 0x80, 0x18, 0xf2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.d ft1, 1.25" + + - + input: + bytes: [ 0xd3, 0x00, 0x19, 0xf2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.d ft1, 1.5" + + - + input: + bytes: [ 0xd3, 0x80, 0x19, 0xf2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.d ft1, 1.75" + + - + input: + bytes: [ 0xd3, 0x00, 0x1a, 0xf2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.d ft1, 2.0" + + - + input: + bytes: [ 0xd3, 0x80, 0x1a, 0xf2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.d ft1, 2.5" + + - + input: + bytes: [ 0xd3, 0x00, 0x1b, 0xf2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.d ft1, 3.0" + + - + input: + bytes: [ 0xd3, 0x80, 0x1b, 0xf2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.d ft1, 4.0" + + - + input: + bytes: [ 0xd3, 0x00, 0x1c, 0xf2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.d ft1, 8.0" + + - + input: + bytes: [ 0xd3, 0x80, 0x1c, 0xf2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.d ft1, 16.0" + + - + input: + bytes: [ 0xd3, 0x00, 0x1d, 0xf2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.d ft1, 128.0" + + - + input: + bytes: [ 0xd3, 0x80, 0x1d, 0xf2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.d ft1, 256.0" + + - + input: + bytes: [ 0xd3, 0x00, 0x1e, 0xf2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.d ft1, 32768.0" + + - + input: + bytes: [ 0xd3, 0x80, 0x1e, 0xf2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.d ft1, 65536.0" + + - + input: + bytes: [ 0xd3, 0x00, 0x1f, 0xf2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.d ft1, inf" + + - + input: + bytes: [ 0xd3, 0x80, 0x1f, 0xf2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.d ft1, nan" + + - + input: + bytes: [ 0xd3, 0x00, 0x10, 0xf4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.h ft1, -1.0" + + - + input: + bytes: [ 0xd3, 0x80, 0x10, 0xf4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.h ft1, min" + + - + input: + bytes: [ 0xd3, 0x00, 0x11, 0xf4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.h ft1, 1.52587890625e-05" + + - + input: + bytes: [ 0xd3, 0x80, 0x11, 0xf4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.h ft1, 3.0517578125e-05" + + - + input: + bytes: [ 0xd3, 0x00, 0x12, 0xf4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.h ft1, 0.00390625" + + - + input: + bytes: [ 0xd3, 0x80, 0x12, 0xf4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.h ft1, 0.0078125" + + - + input: + bytes: [ 0xd3, 0x00, 0x13, 0xf4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.h ft1, 0.0625" + + - + input: + bytes: [ 0xd3, 0x80, 0x13, 0xf4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.h ft1, 0.125" + + - + input: + bytes: [ 0xd3, 0x00, 0x14, 0xf4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.h ft1, 0.25" + + - + input: + bytes: [ 0xd3, 0x80, 0x14, 0xf4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.h ft1, 0.3125" + + - + input: + bytes: [ 0xd3, 0x00, 0x15, 0xf4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.h ft1, 0.375" + + - + input: + bytes: [ 0xd3, 0x80, 0x15, 0xf4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.h ft1, 0.4375" + + - + input: + bytes: [ 0xd3, 0x00, 0x16, 0xf4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.h ft1, 0.5" + + - + input: + bytes: [ 0xd3, 0x80, 0x16, 0xf4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.h ft1, 0.625" + + - + input: + bytes: [ 0xd3, 0x00, 0x17, 0xf4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.h ft1, 0.75" + + - + input: + bytes: [ 0xd3, 0x80, 0x17, 0xf4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.h ft1, 0.875" + + - + input: + bytes: [ 0xd3, 0x00, 0x18, 0xf4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.h ft1, 1.0" + + - + input: + bytes: [ 0xd3, 0x80, 0x18, 0xf4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.h ft1, 1.25" + + - + input: + bytes: [ 0xd3, 0x00, 0x19, 0xf4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.h ft1, 1.5" + + - + input: + bytes: [ 0xd3, 0x80, 0x19, 0xf4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.h ft1, 1.75" + + - + input: + bytes: [ 0xd3, 0x00, 0x1a, 0xf4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.h ft1, 2.0" + + - + input: + bytes: [ 0xd3, 0x80, 0x1a, 0xf4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.h ft1, 2.5" + + - + input: + bytes: [ 0xd3, 0x00, 0x1b, 0xf4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.h ft1, 3.0" + + - + input: + bytes: [ 0xd3, 0x80, 0x1b, 0xf4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.h ft1, 4.0" + + - + input: + bytes: [ 0xd3, 0x00, 0x1c, 0xf4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.h ft1, 8.0" + + - + input: + bytes: [ 0xd3, 0x80, 0x1c, 0xf4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.h ft1, 16.0" + + - + input: + bytes: [ 0xd3, 0x00, 0x1d, 0xf4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.h ft1, 128.0" + + - + input: + bytes: [ 0xd3, 0x80, 0x1d, 0xf4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.h ft1, 256.0" + + - + input: + bytes: [ 0xd3, 0x00, 0x1e, 0xf4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.h ft1, 32768.0" + + - + input: + bytes: [ 0xd3, 0x80, 0x1e, 0xf4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.h ft1, 65536.0" + + - + input: + bytes: [ 0xd3, 0x00, 0x1f, 0xf4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.h ft1, inf" + + - + input: + bytes: [ 0xd3, 0x80, 0x1f, 0xf4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.h ft1, nan" + + - + input: + bytes: [ 0x53, 0xa5, 0xc5, 0x28 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fminm.s fa0, fa1, fa2" + + - + input: + bytes: [ 0xd3, 0x39, 0x5a, 0x29 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmaxm.s fs3, fs4, fs5" + + - + input: + bytes: [ 0x53, 0xa5, 0xc5, 0x2a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fminm.d fa0, fa1, fa2" + + - + input: + bytes: [ 0xd3, 0x39, 0x5a, 0x2b ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmaxm.d fs3, fs4, fs5" + + - + input: + bytes: [ 0x53, 0xa5, 0xc5, 0x2c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fminm.h fa0, fa1, fa2" + + - + input: + bytes: [ 0xd3, 0x39, 0x5a, 0x2d ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fmaxm.h fs3, fs4, fs5" + + - + input: + bytes: [ 0xd3, 0x74, 0x49, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fround.s fs1, fs2, dyn" + + - + input: + bytes: [ 0xd3, 0x14, 0x49, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fround.s fs1, fs2, rtz" + + - + input: + bytes: [ 0xd3, 0x04, 0x49, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fround.s fs1, fs2, rne" + + - + input: + bytes: [ 0xd3, 0x74, 0x59, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "froundnx.s fs1, fs2, dyn" + + - + input: + bytes: [ 0xd3, 0x14, 0x59, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "froundnx.s fs1, fs2, rtz" + + - + input: + bytes: [ 0xd3, 0x04, 0x59, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "froundnx.s fs1, fs2, rne" + + - + input: + bytes: [ 0xd3, 0x74, 0x49, 0x42 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fround.d fs1, fs2, dyn" + + - + input: + bytes: [ 0xd3, 0x14, 0x49, 0x42 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fround.d fs1, fs2, rtz" + + - + input: + bytes: [ 0xd3, 0x04, 0x49, 0x42 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fround.d fs1, fs2, rne" + + - + input: + bytes: [ 0xd3, 0x74, 0x59, 0x42 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "froundnx.d fs1, fs2, dyn" + + - + input: + bytes: [ 0xd3, 0x14, 0x59, 0x42 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "froundnx.d fs1, fs2, rtz" + + - + input: + bytes: [ 0xd3, 0x04, 0x59, 0x42 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "froundnx.d fs1, fs2, rne" + + - + input: + bytes: [ 0xd3, 0xf0, 0x45, 0x44 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fround.h ft1, fa1, dyn" + + - + input: + bytes: [ 0xd3, 0x90, 0x45, 0x44 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fround.h ft1, fa1, rtz" + + - + input: + bytes: [ 0xd3, 0x04, 0x49, 0x44 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fround.h fs1, fs2, rne" + + - + input: + bytes: [ 0xd3, 0xf0, 0x55, 0x44 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "froundnx.h ft1, fa1, dyn" + + - + input: + bytes: [ 0xd3, 0x90, 0x55, 0x44 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "froundnx.h ft1, fa1, rtz" + + - + input: + bytes: [ 0xd3, 0x04, 0x59, 0x44 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "froundnx.h fs1, fs2, rne" + + - + input: + bytes: [ 0xd3, 0x95, 0x80, 0xc2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fcvtmod.w.d a1, ft1, rtz" + + - + input: + bytes: [ 0xd3, 0xd5, 0x24, 0xa1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fltq.s a1, fs1, fs2" + + - + input: + bytes: [ 0xd3, 0xc5, 0x20, 0xa0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fleq.s a1, ft1, ft2" + + - + input: + bytes: [ 0xd3, 0x55, 0x99, 0xa0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fltq.s a1, fs2, fs1" + + - + input: + bytes: [ 0xd3, 0x45, 0x11, 0xa0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fleq.s a1, ft2, ft1" + + - + input: + bytes: [ 0xd3, 0xd5, 0x24, 0xa3 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fltq.d a1, fs1, fs2" + + - + input: + bytes: [ 0xd3, 0xc5, 0x20, 0xa2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fleq.d a1, ft1, ft2" + + - + input: + bytes: [ 0xd3, 0x55, 0x99, 0xa2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fltq.d a1, fs2, fs1" + + - + input: + bytes: [ 0xd3, 0x45, 0x11, 0xa2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fleq.d a1, ft2, ft1" + + - + input: + bytes: [ 0xd3, 0xd5, 0x24, 0xa5 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fltq.h a1, fs1, fs2" + + - + input: + bytes: [ 0xd3, 0xc5, 0x20, 0xa4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fleq.h a1, ft1, ft2" + + - + input: + bytes: [ 0xd3, 0x55, 0x99, 0xa4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fltq.h a1, fs2, fs1" + + - + input: + bytes: [ 0xd3, 0x45, 0x11, 0xa4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "CS_MODE_RISCV_D", "+zfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fleq.h a1, ft2, ft1" diff --git a/tests/MC/RISCV/zfa_zfhmin_zvfh_valid_riscv32_zfa__zfhmin__zvfh_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/zfa_zfhmin_zvfh_valid_riscv32_zfa__zfhmin__zvfh_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..e77281a52b --- /dev/null +++ b/tests/MC/RISCV/zfa_zfhmin_zvfh_valid_riscv32_zfa__zfhmin__zvfh_syntax_no_alias_text.txt.yaml @@ -0,0 +1,10 @@ +test_cases: + - + input: + bytes: [ 0xd3, 0x00, 0x10, 0xf4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zfa", "+zfhmin", "+zvfh", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "fli.h ft1, -1.0" diff --git a/tests/MC/RISCV/zicfilp_valid_riscv32_experimental_zicfilp_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/zicfilp_valid_riscv32_experimental_zicfilp_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..1dada1b948 --- /dev/null +++ b/tests/MC/RISCV/zicfilp_valid_riscv32_experimental_zicfilp_syntax_no_alias_text.txt.yaml @@ -0,0 +1,10 @@ +test_cases: + - + input: + bytes: [ 0x17, 0x60, 0x01, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "experimental-zicfilp", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "auipc zero, 22" diff --git a/tests/MC/RISCV/zicfiss_valid_riscv32_riscv_a_riscv_experimental_zicfiss_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/zicfiss_valid_riscv32_riscv_a_riscv_experimental_zicfiss_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..cd9d142f94 --- /dev/null +++ b/tests/MC/RISCV/zicfiss_valid_riscv32_riscv_a_riscv_experimental_zicfiss_syntax_no_alias_text.txt.yaml @@ -0,0 +1,90 @@ +test_cases: + - + input: + bytes: [ 0x73, 0xc0, 0xc0, 0xcd ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_A", "CS_MODE_RISCV_EXPERIMENTAL_ZICFISS", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "sspopchk ra" + + - + input: + bytes: [ 0x73, 0xc0, 0xc2, 0xcd ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_A", "CS_MODE_RISCV_EXPERIMENTAL_ZICFISS", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "sspopchk t0" + + - + input: + bytes: [ 0x73, 0x40, 0x10, 0xce ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_A", "CS_MODE_RISCV_EXPERIMENTAL_ZICFISS", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "sspush ra" + + - + input: + bytes: [ 0x73, 0x40, 0x50, 0xce ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_A", "CS_MODE_RISCV_EXPERIMENTAL_ZICFISS", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "sspush t0" + + - + input: + bytes: [ 0xf3, 0x40, 0xc0, 0xcd ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_A", "CS_MODE_RISCV_EXPERIMENTAL_ZICFISS", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "ssrdp ra" + + - + input: + bytes: [ 0x2f, 0x27, 0x14, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_A", "CS_MODE_RISCV_EXPERIMENTAL_ZICFISS", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "ssamoswap.w a4, ra, (s0)" + + - + input: + bytes: [ 0x2f, 0x27, 0x14, 0x4c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_A", "CS_MODE_RISCV_EXPERIMENTAL_ZICFISS", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "ssamoswap.w.aq a4, ra, (s0)" + + - + input: + bytes: [ 0x2f, 0x27, 0x14, 0x4a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_A", "CS_MODE_RISCV_EXPERIMENTAL_ZICFISS", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "ssamoswap.w.rl a4, ra, (s0)" + + - + input: + bytes: [ 0x2f, 0x27, 0x14, 0x4e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "CS_MODE_RISCV_A", "CS_MODE_RISCV_EXPERIMENTAL_ZICFISS", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "ssamoswap.w.aqrl a4, ra, (s0)" diff --git a/tests/MC/RISCV/zvbb_riscv32_zve32x_zvbb.txt.yaml b/tests/MC/RISCV/zvbb_riscv32_zve32x_zvbb.txt.yaml new file mode 100644 index 0000000000..762067988a --- /dev/null +++ b/tests/MC/RISCV/zvbb_riscv32_zve32x_zvbb.txt.yaml @@ -0,0 +1,70 @@ +test_cases: + - + input: + bytes: [ 0x57, 0x25, 0x95, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zve32x", "zvbb" ] + expected: + insns: + - + asm_text: "vbrev.v v10, v9, v0.t" + + - + input: + bytes: [ 0x57, 0x25, 0x96, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zve32x", "zvbb" ] + expected: + insns: + - + asm_text: "vclz.v v10, v9, v0.t" + + - + input: + bytes: [ 0x57, 0x25, 0x97, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zve32x", "zvbb" ] + expected: + insns: + - + asm_text: "vcpop.v v10, v9, v0.t" + + - + input: + bytes: [ 0x57, 0xa5, 0x96, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zve32x", "zvbb" ] + expected: + insns: + - + asm_text: "vctz.v v10, v9, v0.t" + + - + input: + bytes: [ 0x57, 0x05, 0x94, 0xd4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zve32x", "zvbb" ] + expected: + insns: + - + asm_text: "vwsll.vv v10, v9, v8, v0.t" + + - + input: + bytes: [ 0x57, 0x45, 0x95, 0xd4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zve32x", "zvbb" ] + expected: + insns: + - + asm_text: "vwsll.vx v10, v9, a0, v0.t" + + - + input: + bytes: [ 0x57, 0xb5, 0x9e, 0xd4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zve32x", "zvbb" ] + expected: + insns: + - + asm_text: "vwsll.vi v10, v9, 29, v0.t" diff --git a/tests/MC/RISCV/zvbc_riscv32_zve64x_zvbc.txt.yaml b/tests/MC/RISCV/zvbc_riscv32_zve64x_zvbc.txt.yaml new file mode 100644 index 0000000000..9e7e7d7b2a --- /dev/null +++ b/tests/MC/RISCV/zvbc_riscv32_zve64x_zvbc.txt.yaml @@ -0,0 +1,40 @@ +test_cases: + - + input: + bytes: [ 0x57, 0x25, 0x94, 0x32 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zve64x", "zvbc" ] + expected: + insns: + - + asm_text: "vclmul.vv v10, v9, v8" + + - + input: + bytes: [ 0x57, 0x65, 0x95, 0x32 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zve64x", "zvbc" ] + expected: + insns: + - + asm_text: "vclmul.vx v10, v9, a0" + + - + input: + bytes: [ 0x57, 0x25, 0x94, 0x36 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zve64x", "zvbc" ] + expected: + insns: + - + asm_text: "vclmulh.vv v10, v9, v8" + + - + input: + bytes: [ 0x57, 0x65, 0x95, 0x36 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zve64x", "zvbc" ] + expected: + insns: + - + asm_text: "vclmulh.vx v10, v9, a0" diff --git a/tests/MC/RISCV/zvfbfmin_riscv32_experimental_zvfbfmin.txt.yaml b/tests/MC/RISCV/zvfbfmin_riscv32_experimental_zvfbfmin.txt.yaml new file mode 100644 index 0000000000..20c45885b0 --- /dev/null +++ b/tests/MC/RISCV/zvfbfmin_riscv32_experimental_zvfbfmin.txt.yaml @@ -0,0 +1,40 @@ +test_cases: + - + input: + bytes: [ 0x57, 0x94, 0x4e, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "experimental-zvfbfmin" ] + expected: + insns: + - + asm_text: "vfncvtbf16.f.f.w v8, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x94, 0x4e, 0x4a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "experimental-zvfbfmin" ] + expected: + insns: + - + asm_text: "vfncvtbf16.f.f.w v8, v4" + + - + input: + bytes: [ 0x57, 0x94, 0x46, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "experimental-zvfbfmin" ] + expected: + insns: + - + asm_text: "vfwcvtbf16.f.f.v v8, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x94, 0x46, 0x4a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "experimental-zvfbfmin" ] + expected: + insns: + - + asm_text: "vfwcvtbf16.f.f.v v8, v4" diff --git a/tests/MC/RISCV/zvfbfwma_riscv32_experimental_zvfbfwma.txt.yaml b/tests/MC/RISCV/zvfbfwma_riscv32_experimental_zvfbfwma.txt.yaml new file mode 100644 index 0000000000..1cdf67f6e3 --- /dev/null +++ b/tests/MC/RISCV/zvfbfwma_riscv32_experimental_zvfbfwma.txt.yaml @@ -0,0 +1,80 @@ +test_cases: + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0xec ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "experimental-zvfbfwma" ] + expected: + insns: + - + asm_text: "vfwmaccbf16.vv v8, v20, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x14, 0x4a, 0xee ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "experimental-zvfbfwma" ] + expected: + insns: + - + asm_text: "vfwmaccbf16.vv v8, v20, v4" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0xec ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "experimental-zvfbfwma" ] + expected: + insns: + - + asm_text: "vfwmaccbf16.vf v8, fa0, v4, v0.t" + + - + input: + bytes: [ 0x57, 0x54, 0x45, 0xee ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "experimental-zvfbfwma" ] + expected: + insns: + - + asm_text: "vfwmaccbf16.vf v8, fa0, v4" + + - + input: + bytes: [ 0x07, 0x10, 0xc5, 0x00 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "experimental-zvfbfwma" ] + expected: + insns: + - + asm_text: "flh ft0, 12(a0)" + + - + input: + bytes: [ 0xa7, 0x1f, 0x6a, 0x7e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "experimental-zvfbfwma" ] + expected: + insns: + - + asm_text: "fsh ft6, 2047(s4)" + + - + input: + bytes: [ 0x53, 0x86, 0x0b, 0xe4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "experimental-zvfbfwma" ] + expected: + insns: + - + asm_text: "fmv.x.h a2, fs7" + + - + input: + bytes: [ 0xd3, 0x00, 0x08, 0xf4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "experimental-zvfbfwma" ] + expected: + insns: + - + asm_text: "fmv.h.x ft1, a6" diff --git a/tests/MC/RISCV/zvkb_riscv32_zve32x_zvkb.txt.yaml b/tests/MC/RISCV/zvkb_riscv32_zve32x_zvkb.txt.yaml new file mode 100644 index 0000000000..3346c52f7b --- /dev/null +++ b/tests/MC/RISCV/zvkb_riscv32_zve32x_zvkb.txt.yaml @@ -0,0 +1,90 @@ +test_cases: + - + input: + bytes: [ 0x57, 0x05, 0x94, 0x04 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zve32x", "zvkb" ] + expected: + insns: + - + asm_text: "vandn.vv v10, v9, v8, v0.t" + + - + input: + bytes: [ 0x57, 0x45, 0x95, 0x04 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zve32x", "zvkb" ] + expected: + insns: + - + asm_text: "vandn.vx v10, v9, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x25, 0x94, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zve32x", "zvkb" ] + expected: + insns: + - + asm_text: "vbrev8.v v10, v9, v0.t" + + - + input: + bytes: [ 0x57, 0xa5, 0x94, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zve32x", "zvkb" ] + expected: + insns: + - + asm_text: "vrev8.v v10, v9, v0.t" + + - + input: + bytes: [ 0x57, 0x05, 0x94, 0x54 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zve32x", "zvkb" ] + expected: + insns: + - + asm_text: "vrol.vv v10, v9, v8, v0.t" + + - + input: + bytes: [ 0x57, 0x45, 0x95, 0x54 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zve32x", "zvkb" ] + expected: + insns: + - + asm_text: "vrol.vx v10, v9, a0, v0.t" + + - + input: + bytes: [ 0x57, 0x05, 0x94, 0x50 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zve32x", "zvkb" ] + expected: + insns: + - + asm_text: "vror.vv v10, v9, v8, v0.t" + + - + input: + bytes: [ 0x57, 0x45, 0x95, 0x50 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zve32x", "zvkb" ] + expected: + insns: + - + asm_text: "vror.vx v10, v9, a0, v0.t" + + - + input: + bytes: [ 0x57, 0xb5, 0x90, 0x54 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zve32x", "zvkb" ] + expected: + insns: + - + asm_text: "vror.vi v10, v9, 33, v0.t" diff --git a/tests/MC/RISCV/zvkg_riscv32_zve32x_zvkg.txt.yaml b/tests/MC/RISCV/zvkg_riscv32_zve32x_zvkg.txt.yaml new file mode 100644 index 0000000000..e657a9836d --- /dev/null +++ b/tests/MC/RISCV/zvkg_riscv32_zve32x_zvkg.txt.yaml @@ -0,0 +1,20 @@ +test_cases: + - + input: + bytes: [ 0x77, 0x25, 0x94, 0xb2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zve32x", "zvkg" ] + expected: + insns: + - + asm_text: "vghsh.vv v10, v9, v8" + + - + input: + bytes: [ 0x77, 0xa5, 0x98, 0xa2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zve32x", "zvkg" ] + expected: + insns: + - + asm_text: "vgmul.vv v10, v9" diff --git a/tests/MC/RISCV/zvkned_riscv32_zve32x_zvkned.txt.yaml b/tests/MC/RISCV/zvkned_riscv32_zve32x_zvkned.txt.yaml new file mode 100644 index 0000000000..a632cbe811 --- /dev/null +++ b/tests/MC/RISCV/zvkned_riscv32_zve32x_zvkned.txt.yaml @@ -0,0 +1,130 @@ +test_cases: + - + input: + bytes: [ 0x77, 0xa5, 0x90, 0xa2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zve32x", "zvkned" ] + expected: + insns: + - + asm_text: "vaesdf.vv v10, v9" + + - + input: + bytes: [ 0x77, 0xa5, 0x90, 0xa6 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zve32x", "zvkned" ] + expected: + insns: + - + asm_text: "vaesdf.vs v10, v9" + + - + input: + bytes: [ 0x77, 0xa5, 0x91, 0xa2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zve32x", "zvkned" ] + expected: + insns: + - + asm_text: "vaesef.vv v10, v9" + + - + input: + bytes: [ 0x77, 0xa5, 0x91, 0xa6 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zve32x", "zvkned" ] + expected: + insns: + - + asm_text: "vaesef.vs v10, v9" + + - + input: + bytes: [ 0x77, 0x25, 0x90, 0xa2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zve32x", "zvkned" ] + expected: + insns: + - + asm_text: "vaesdm.vv v10, v9" + + - + input: + bytes: [ 0x77, 0x25, 0x90, 0xa6 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zve32x", "zvkned" ] + expected: + insns: + - + asm_text: "vaesdm.vs v10, v9" + + - + input: + bytes: [ 0x77, 0x25, 0x91, 0xa2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zve32x", "zvkned" ] + expected: + insns: + - + asm_text: "vaesem.vv v10, v9" + + - + input: + bytes: [ 0x77, 0x25, 0x91, 0xa6 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zve32x", "zvkned" ] + expected: + insns: + - + asm_text: "vaesem.vs v10, v9" + + - + input: + bytes: [ 0x77, 0xa5, 0x90, 0x8a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zve32x", "zvkned" ] + expected: + insns: + - + asm_text: "vaeskf1.vi v10, v9, 1" + + - + input: + bytes: [ 0x77, 0xa5, 0x9f, 0x8a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zve32x", "zvkned" ] + expected: + insns: + - + asm_text: "vaeskf1.vi v10, v9, 31" + + - + input: + bytes: [ 0x77, 0x25, 0x91, 0xaa ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zve32x", "zvkned" ] + expected: + insns: + - + asm_text: "vaeskf2.vi v10, v9, 2" + + - + input: + bytes: [ 0x77, 0xa5, 0x9f, 0xaa ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zve32x", "zvkned" ] + expected: + insns: + - + asm_text: "vaeskf2.vi v10, v9, 31" + + - + input: + bytes: [ 0x77, 0xa5, 0x93, 0xa6 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zve32x", "zvkned" ] + expected: + insns: + - + asm_text: "vaesz.vs v10, v9" diff --git a/tests/MC/RISCV/zvknh_riscv32_zve32x_zvknha.txt.yaml b/tests/MC/RISCV/zvknh_riscv32_zve32x_zvknha.txt.yaml new file mode 100644 index 0000000000..7b9a3fe57f --- /dev/null +++ b/tests/MC/RISCV/zvknh_riscv32_zve32x_zvknha.txt.yaml @@ -0,0 +1,30 @@ +test_cases: + - + input: + bytes: [ 0x77, 0x25, 0x94, 0xb6 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zve32x", "zvknha" ] + expected: + insns: + - + asm_text: "vsha2ms.vv v10, v9, v8" + + - + input: + bytes: [ 0x77, 0x25, 0x94, 0xba ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zve32x", "zvknha" ] + expected: + insns: + - + asm_text: "vsha2ch.vv v10, v9, v8" + + - + input: + bytes: [ 0x77, 0x25, 0x94, 0xbe ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zve32x", "zvknha" ] + expected: + insns: + - + asm_text: "vsha2cl.vv v10, v9, v8" diff --git a/tests/MC/RISCV/zvksed_riscv32_zve32x_zvksed.txt.yaml b/tests/MC/RISCV/zvksed_riscv32_zve32x_zvksed.txt.yaml new file mode 100644 index 0000000000..4ad739d070 --- /dev/null +++ b/tests/MC/RISCV/zvksed_riscv32_zve32x_zvksed.txt.yaml @@ -0,0 +1,40 @@ +test_cases: + - + input: + bytes: [ 0x77, 0xa5, 0x93, 0x86 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zve32x", "zvksed" ] + expected: + insns: + - + asm_text: "vsm4k.vi v10, v9, 7" + + - + input: + bytes: [ 0x77, 0xa5, 0x9f, 0x86 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zve32x", "zvksed" ] + expected: + insns: + - + asm_text: "vsm4k.vi v10, v9, 31" + + - + input: + bytes: [ 0x77, 0x25, 0x98, 0xa2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zve32x", "zvksed" ] + expected: + insns: + - + asm_text: "vsm4r.vv v10, v9" + + - + input: + bytes: [ 0x77, 0x25, 0x98, 0xa6 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zve32x", "zvksed" ] + expected: + insns: + - + asm_text: "vsm4r.vs v10, v9" diff --git a/tests/MC/RISCV/zvksh_riscv32_zve32x_zvksh.txt.yaml b/tests/MC/RISCV/zvksh_riscv32_zve32x_zvksh.txt.yaml new file mode 100644 index 0000000000..5c363b3b9a --- /dev/null +++ b/tests/MC/RISCV/zvksh_riscv32_zve32x_zvksh.txt.yaml @@ -0,0 +1,20 @@ +test_cases: + - + input: + bytes: [ 0x77, 0xa5, 0x93, 0xae ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zve32x", "zvksh" ] + expected: + insns: + - + asm_text: "vsm3c.vi v10, v9, 7" + + - + input: + bytes: [ 0x77, 0x25, 0x94, 0x82 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV32", "zve32x", "zvksh" ] + expected: + insns: + - + asm_text: "vsm3me.vv v10, v9, v8" diff --git a/tests/MC/RISCV/zvlsseg_riscv64_riscv_v_syntax_no_alias_text.txt.yaml b/tests/MC/RISCV/zvlsseg_riscv64_riscv_v_syntax_no_alias_text.txt.yaml new file mode 100644 index 0000000000..36559f1bff --- /dev/null +++ b/tests/MC/RISCV/zvlsseg_riscv64_riscv_v_syntax_no_alias_text.txt.yaml @@ -0,0 +1,5040 @@ +test_cases: + - + input: + bytes: [ 0x07, 0x04, 0x05, 0x20 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg2e8.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x04, 0x05, 0x22 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg2e8.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x54, 0x05, 0x20 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg2e16.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x54, 0x05, 0x22 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg2e16.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x64, 0x05, 0x20 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg2e32.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x64, 0x05, 0x22 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg2e32.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x74, 0x05, 0x20 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg2e64.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x74, 0x05, 0x22 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg2e64.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x04, 0x05, 0x21 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg2e8ff.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x04, 0x05, 0x23 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg2e8ff.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x54, 0x05, 0x21 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg2e16ff.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x54, 0x05, 0x23 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg2e16ff.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x64, 0x05, 0x21 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg2e32ff.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x64, 0x05, 0x23 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg2e32ff.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x74, 0x05, 0x21 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg2e64ff.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x74, 0x05, 0x23 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg2e64ff.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x04, 0xb5, 0x28 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlsseg2e8.v v8, (a0), a1, v0.t" + + - + input: + bytes: [ 0x07, 0x04, 0xb5, 0x2a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlsseg2e8.v v8, (a0), a1" + + - + input: + bytes: [ 0x07, 0x54, 0xb5, 0x28 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlsseg2e16.v v8, (a0), a1, v0.t" + + - + input: + bytes: [ 0x07, 0x54, 0xb5, 0x2a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlsseg2e16.v v8, (a0), a1" + + - + input: + bytes: [ 0x07, 0x64, 0xb5, 0x28 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlsseg2e32.v v8, (a0), a1, v0.t" + + - + input: + bytes: [ 0x07, 0x64, 0xb5, 0x2a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlsseg2e32.v v8, (a0), a1" + + - + input: + bytes: [ 0x07, 0x74, 0xb5, 0x28 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlsseg2e64.v v8, (a0), a1, v0.t" + + - + input: + bytes: [ 0x07, 0x74, 0xb5, 0x2a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlsseg2e64.v v8, (a0), a1" + + - + input: + bytes: [ 0x07, 0x04, 0x45, 0x24 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxseg2ei8.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x04, 0x45, 0x26 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxseg2ei8.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x54, 0x45, 0x24 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxseg2ei16.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x54, 0x45, 0x26 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxseg2ei16.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x64, 0x45, 0x24 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxseg2ei32.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x64, 0x45, 0x26 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxseg2ei32.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x74, 0x45, 0x24 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxseg2ei64.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x74, 0x45, 0x26 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxseg2ei64.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x04, 0x45, 0x2c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxseg2ei8.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x04, 0x45, 0x2e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxseg2ei8.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x54, 0x45, 0x2c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxseg2ei16.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x54, 0x45, 0x2e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxseg2ei16.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x64, 0x45, 0x2c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxseg2ei32.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x64, 0x45, 0x2e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxseg2ei32.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x74, 0x45, 0x2c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxseg2ei64.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x74, 0x45, 0x2e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxseg2ei64.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x04, 0x05, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg3e8.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x04, 0x05, 0x42 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg3e8.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x54, 0x05, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg3e16.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x54, 0x05, 0x42 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg3e16.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x64, 0x05, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg3e32.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x64, 0x05, 0x42 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg3e32.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x74, 0x05, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg3e64.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x74, 0x05, 0x42 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg3e64.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x04, 0x05, 0x41 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg3e8ff.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x04, 0x05, 0x43 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg3e8ff.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x54, 0x05, 0x41 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg3e16ff.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x54, 0x05, 0x43 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg3e16ff.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x64, 0x05, 0x41 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg3e32ff.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x64, 0x05, 0x43 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg3e32ff.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x74, 0x05, 0x41 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg3e64ff.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x74, 0x05, 0x43 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg3e64ff.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x04, 0xb5, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlsseg3e8.v v8, (a0), a1, v0.t" + + - + input: + bytes: [ 0x07, 0x04, 0xb5, 0x4a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlsseg3e8.v v8, (a0), a1" + + - + input: + bytes: [ 0x07, 0x54, 0xb5, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlsseg3e16.v v8, (a0), a1, v0.t" + + - + input: + bytes: [ 0x07, 0x54, 0xb5, 0x4a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlsseg3e16.v v8, (a0), a1" + + - + input: + bytes: [ 0x07, 0x64, 0xb5, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlsseg3e32.v v8, (a0), a1, v0.t" + + - + input: + bytes: [ 0x07, 0x64, 0xb5, 0x4a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlsseg3e32.v v8, (a0), a1" + + - + input: + bytes: [ 0x07, 0x74, 0xb5, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlsseg3e64.v v8, (a0), a1, v0.t" + + - + input: + bytes: [ 0x07, 0x74, 0xb5, 0x4a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlsseg3e64.v v8, (a0), a1" + + - + input: + bytes: [ 0x07, 0x04, 0x45, 0x44 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxseg3ei8.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x04, 0x45, 0x46 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxseg3ei8.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x54, 0x45, 0x44 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxseg3ei16.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x54, 0x45, 0x46 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxseg3ei16.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x64, 0x45, 0x44 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxseg3ei32.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x64, 0x45, 0x46 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxseg3ei32.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x74, 0x45, 0x44 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxseg3ei64.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x74, 0x45, 0x46 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxseg3ei64.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x04, 0x45, 0x4c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxseg3ei8.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x04, 0x45, 0x4e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxseg3ei8.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x54, 0x45, 0x4c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxseg3ei16.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x54, 0x45, 0x4e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxseg3ei16.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x64, 0x45, 0x4c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxseg3ei32.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x64, 0x45, 0x4e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxseg3ei32.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x74, 0x45, 0x4c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxseg3ei64.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x74, 0x45, 0x4e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxseg3ei64.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x04, 0x05, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg4e8.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x04, 0x05, 0x62 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg4e8.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x54, 0x05, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg4e16.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x54, 0x05, 0x62 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg4e16.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x64, 0x05, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg4e32.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x64, 0x05, 0x62 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg4e32.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x74, 0x05, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg4e64.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x74, 0x05, 0x62 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg4e64.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x04, 0x05, 0x61 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg4e8ff.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x04, 0x05, 0x63 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg4e8ff.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x54, 0x05, 0x61 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg4e16ff.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x54, 0x05, 0x63 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg4e16ff.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x64, 0x05, 0x61 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg4e32ff.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x64, 0x05, 0x63 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg4e32ff.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x74, 0x05, 0x61 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg4e64ff.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x74, 0x05, 0x63 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg4e64ff.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x04, 0xb5, 0x68 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlsseg4e8.v v8, (a0), a1, v0.t" + + - + input: + bytes: [ 0x07, 0x04, 0xb5, 0x6a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlsseg4e8.v v8, (a0), a1" + + - + input: + bytes: [ 0x07, 0x54, 0xb5, 0x68 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlsseg4e16.v v8, (a0), a1, v0.t" + + - + input: + bytes: [ 0x07, 0x54, 0xb5, 0x6a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlsseg4e16.v v8, (a0), a1" + + - + input: + bytes: [ 0x07, 0x64, 0xb5, 0x68 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlsseg4e32.v v8, (a0), a1, v0.t" + + - + input: + bytes: [ 0x07, 0x64, 0xb5, 0x6a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlsseg4e32.v v8, (a0), a1" + + - + input: + bytes: [ 0x07, 0x74, 0xb5, 0x68 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlsseg4e64.v v8, (a0), a1, v0.t" + + - + input: + bytes: [ 0x07, 0x74, 0xb5, 0x6a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlsseg4e64.v v8, (a0), a1" + + - + input: + bytes: [ 0x07, 0x04, 0x45, 0x64 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxseg4ei8.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x04, 0x45, 0x66 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxseg4ei8.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x54, 0x45, 0x64 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxseg4ei16.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x54, 0x45, 0x66 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxseg4ei16.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x64, 0x45, 0x64 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxseg4ei32.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x64, 0x45, 0x66 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxseg4ei32.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x74, 0x45, 0x64 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxseg4ei64.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x74, 0x45, 0x66 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxseg4ei64.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x04, 0x45, 0x6c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxseg4ei8.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x04, 0x45, 0x6e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxseg4ei8.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x54, 0x45, 0x6c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxseg4ei16.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x54, 0x45, 0x6e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxseg4ei16.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x64, 0x45, 0x6c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxseg4ei32.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x64, 0x45, 0x6e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxseg4ei32.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x74, 0x45, 0x6c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxseg4ei64.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x74, 0x45, 0x6e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxseg4ei64.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x04, 0x05, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg5e8.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x04, 0x05, 0x82 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg5e8.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x54, 0x05, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg5e16.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x54, 0x05, 0x82 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg5e16.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x64, 0x05, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg5e32.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x64, 0x05, 0x82 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg5e32.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x74, 0x05, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg5e64.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x74, 0x05, 0x82 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg5e64.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x04, 0x05, 0x81 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg5e8ff.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x04, 0x05, 0x83 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg5e8ff.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x54, 0x05, 0x81 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg5e16ff.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x54, 0x05, 0x83 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg5e16ff.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x64, 0x05, 0x81 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg5e32ff.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x64, 0x05, 0x83 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg5e32ff.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x74, 0x05, 0x81 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg5e64ff.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x74, 0x05, 0x83 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg5e64ff.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x04, 0xb5, 0x88 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlsseg5e8.v v8, (a0), a1, v0.t" + + - + input: + bytes: [ 0x07, 0x04, 0xb5, 0x8a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlsseg5e8.v v8, (a0), a1" + + - + input: + bytes: [ 0x07, 0x54, 0xb5, 0x88 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlsseg5e16.v v8, (a0), a1, v0.t" + + - + input: + bytes: [ 0x07, 0x54, 0xb5, 0x8a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlsseg5e16.v v8, (a0), a1" + + - + input: + bytes: [ 0x07, 0x64, 0xb5, 0x88 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlsseg5e32.v v8, (a0), a1, v0.t" + + - + input: + bytes: [ 0x07, 0x64, 0xb5, 0x8a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlsseg5e32.v v8, (a0), a1" + + - + input: + bytes: [ 0x07, 0x74, 0xb5, 0x88 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlsseg5e64.v v8, (a0), a1, v0.t" + + - + input: + bytes: [ 0x07, 0x74, 0xb5, 0x8a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlsseg5e64.v v8, (a0), a1" + + - + input: + bytes: [ 0x07, 0x04, 0x45, 0x84 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxseg5ei8.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x04, 0x45, 0x86 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxseg5ei8.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x54, 0x45, 0x84 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxseg5ei16.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x54, 0x45, 0x86 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxseg5ei16.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x64, 0x45, 0x84 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxseg5ei32.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x64, 0x45, 0x86 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxseg5ei32.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x74, 0x45, 0x84 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxseg5ei64.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x74, 0x45, 0x86 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxseg5ei64.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x04, 0x45, 0x8c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxseg5ei8.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x04, 0x45, 0x8e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxseg5ei8.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x54, 0x45, 0x8c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxseg5ei16.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x54, 0x45, 0x8e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxseg5ei16.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x64, 0x45, 0x8c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxseg5ei32.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x64, 0x45, 0x8e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxseg5ei32.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x74, 0x45, 0x8c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxseg5ei64.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x74, 0x45, 0x8e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxseg5ei64.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x04, 0x05, 0xa0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg6e8.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x04, 0x05, 0xa2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg6e8.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x54, 0x05, 0xa0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg6e16.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x54, 0x05, 0xa2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg6e16.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x64, 0x05, 0xa0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg6e32.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x64, 0x05, 0xa2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg6e32.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x74, 0x05, 0xa0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg6e64.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x74, 0x05, 0xa2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg6e64.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x04, 0x05, 0xa1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg6e8ff.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x04, 0x05, 0xa3 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg6e8ff.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x54, 0x05, 0xa1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg6e16ff.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x54, 0x05, 0xa3 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg6e16ff.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x64, 0x05, 0xa1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg6e32ff.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x64, 0x05, 0xa3 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg6e32ff.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x74, 0x05, 0xa1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg6e64ff.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x74, 0x05, 0xa3 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg6e64ff.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x04, 0xb5, 0xa8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlsseg6e8.v v8, (a0), a1, v0.t" + + - + input: + bytes: [ 0x07, 0x04, 0xb5, 0xaa ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlsseg6e8.v v8, (a0), a1" + + - + input: + bytes: [ 0x07, 0x54, 0xb5, 0xa8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlsseg6e16.v v8, (a0), a1, v0.t" + + - + input: + bytes: [ 0x07, 0x54, 0xb5, 0xaa ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlsseg6e16.v v8, (a0), a1" + + - + input: + bytes: [ 0x07, 0x64, 0xb5, 0xa8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlsseg6e32.v v8, (a0), a1, v0.t" + + - + input: + bytes: [ 0x07, 0x64, 0xb5, 0xaa ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlsseg6e32.v v8, (a0), a1" + + - + input: + bytes: [ 0x07, 0x74, 0xb5, 0xa8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlsseg6e64.v v8, (a0), a1, v0.t" + + - + input: + bytes: [ 0x07, 0x74, 0xb5, 0xaa ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlsseg6e64.v v8, (a0), a1" + + - + input: + bytes: [ 0x07, 0x04, 0x45, 0xa4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxseg6ei8.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x04, 0x45, 0xa6 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxseg6ei8.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x54, 0x45, 0xa4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxseg6ei16.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x54, 0x45, 0xa6 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxseg6ei16.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x64, 0x45, 0xa4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxseg6ei32.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x64, 0x45, 0xa6 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxseg6ei32.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x74, 0x45, 0xa4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxseg6ei64.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x74, 0x45, 0xa6 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxseg6ei64.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x04, 0x45, 0xac ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxseg6ei8.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x04, 0x45, 0xae ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxseg6ei8.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x54, 0x45, 0xac ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxseg6ei16.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x54, 0x45, 0xae ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxseg6ei16.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x64, 0x45, 0xac ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxseg6ei32.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x64, 0x45, 0xae ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxseg6ei32.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x74, 0x45, 0xac ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxseg6ei64.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x74, 0x45, 0xae ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxseg6ei64.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x04, 0x05, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg7e8.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x04, 0x05, 0xc2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg7e8.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x54, 0x05, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg7e16.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x54, 0x05, 0xc2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg7e16.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x64, 0x05, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg7e32.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x64, 0x05, 0xc2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg7e32.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x74, 0x05, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg7e64.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x74, 0x05, 0xc2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg7e64.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x04, 0x05, 0xc1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg7e8ff.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x04, 0x05, 0xc3 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg7e8ff.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x54, 0x05, 0xc1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg7e16ff.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x54, 0x05, 0xc3 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg7e16ff.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x64, 0x05, 0xc1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg7e32ff.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x64, 0x05, 0xc3 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg7e32ff.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x74, 0x05, 0xc1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg7e64ff.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x74, 0x05, 0xc3 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg7e64ff.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x04, 0xb5, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlsseg7e8.v v8, (a0), a1, v0.t" + + - + input: + bytes: [ 0x07, 0x04, 0xb5, 0xca ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlsseg7e8.v v8, (a0), a1" + + - + input: + bytes: [ 0x07, 0x54, 0xb5, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlsseg7e16.v v8, (a0), a1, v0.t" + + - + input: + bytes: [ 0x07, 0x54, 0xb5, 0xca ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlsseg7e16.v v8, (a0), a1" + + - + input: + bytes: [ 0x07, 0x64, 0xb5, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlsseg7e32.v v8, (a0), a1, v0.t" + + - + input: + bytes: [ 0x07, 0x64, 0xb5, 0xca ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlsseg7e32.v v8, (a0), a1" + + - + input: + bytes: [ 0x07, 0x74, 0xb5, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlsseg7e64.v v8, (a0), a1, v0.t" + + - + input: + bytes: [ 0x07, 0x74, 0xb5, 0xca ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlsseg7e64.v v8, (a0), a1" + + - + input: + bytes: [ 0x07, 0x04, 0x45, 0xc4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxseg7ei8.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x04, 0x45, 0xc6 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxseg7ei8.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x54, 0x45, 0xc4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxseg7ei16.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x54, 0x45, 0xc6 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxseg7ei16.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x64, 0x45, 0xc4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxseg7ei32.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x64, 0x45, 0xc6 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxseg7ei32.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x74, 0x45, 0xc4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxseg7ei64.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x74, 0x45, 0xc6 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxseg7ei64.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x04, 0x45, 0xcc ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxseg7ei8.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x04, 0x45, 0xce ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxseg7ei8.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x54, 0x45, 0xcc ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxseg7ei16.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x54, 0x45, 0xce ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxseg7ei16.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x64, 0x45, 0xcc ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxseg7ei32.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x64, 0x45, 0xce ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxseg7ei32.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x74, 0x45, 0xcc ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxseg7ei64.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x74, 0x45, 0xce ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxseg7ei64.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x04, 0x05, 0xe0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg8e8.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x04, 0x05, 0xe2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg8e8.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x54, 0x05, 0xe0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg8e16.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x54, 0x05, 0xe2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg8e16.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x64, 0x05, 0xe0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg8e32.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x64, 0x05, 0xe2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg8e32.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x74, 0x05, 0xe0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg8e64.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x74, 0x05, 0xe2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg8e64.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x04, 0x05, 0xe1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg8e8ff.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x04, 0x05, 0xe3 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg8e8ff.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x54, 0x05, 0xe1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg8e16ff.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x54, 0x05, 0xe3 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg8e16ff.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x64, 0x05, 0xe1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg8e32ff.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x64, 0x05, 0xe3 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg8e32ff.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x74, 0x05, 0xe1 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg8e64ff.v v8, (a0), v0.t" + + - + input: + bytes: [ 0x07, 0x74, 0x05, 0xe3 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlseg8e64ff.v v8, (a0)" + + - + input: + bytes: [ 0x07, 0x04, 0xb5, 0xe8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlsseg8e8.v v8, (a0), a1, v0.t" + + - + input: + bytes: [ 0x07, 0x04, 0xb5, 0xea ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlsseg8e8.v v8, (a0), a1" + + - + input: + bytes: [ 0x07, 0x54, 0xb5, 0xe8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlsseg8e16.v v8, (a0), a1, v0.t" + + - + input: + bytes: [ 0x07, 0x54, 0xb5, 0xea ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlsseg8e16.v v8, (a0), a1" + + - + input: + bytes: [ 0x07, 0x64, 0xb5, 0xe8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlsseg8e32.v v8, (a0), a1, v0.t" + + - + input: + bytes: [ 0x07, 0x64, 0xb5, 0xea ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlsseg8e32.v v8, (a0), a1" + + - + input: + bytes: [ 0x07, 0x74, 0xb5, 0xe8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlsseg8e64.v v8, (a0), a1, v0.t" + + - + input: + bytes: [ 0x07, 0x74, 0xb5, 0xea ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vlsseg8e64.v v8, (a0), a1" + + - + input: + bytes: [ 0x07, 0x04, 0x45, 0xe4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxseg8ei8.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x04, 0x45, 0xe6 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxseg8ei8.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x54, 0x45, 0xe4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxseg8ei16.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x54, 0x45, 0xe6 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxseg8ei16.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x64, 0x45, 0xe4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxseg8ei32.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x64, 0x45, 0xe6 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxseg8ei32.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x74, 0x45, 0xe4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxseg8ei64.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x74, 0x45, 0xe6 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vluxseg8ei64.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x04, 0x45, 0xec ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxseg8ei8.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x04, 0x45, 0xee ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxseg8ei8.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x54, 0x45, 0xec ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxseg8ei16.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x54, 0x45, 0xee ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxseg8ei16.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x64, 0x45, 0xec ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxseg8ei32.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x64, 0x45, 0xee ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxseg8ei32.v v8, (a0), v4" + + - + input: + bytes: [ 0x07, 0x74, 0x45, 0xec ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxseg8ei64.v v8, (a0), v4, v0.t" + + - + input: + bytes: [ 0x07, 0x74, 0x45, 0xee ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vloxseg8ei64.v v8, (a0), v4" + + - + input: + bytes: [ 0x27, 0x0c, 0x05, 0x20 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsseg2e8.v v24, (a0), v0.t" + + - + input: + bytes: [ 0x27, 0x0c, 0x05, 0x22 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsseg2e8.v v24, (a0)" + + - + input: + bytes: [ 0x27, 0x5c, 0x05, 0x20 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsseg2e16.v v24, (a0), v0.t" + + - + input: + bytes: [ 0x27, 0x5c, 0x05, 0x22 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsseg2e16.v v24, (a0)" + + - + input: + bytes: [ 0x27, 0x6c, 0x05, 0x20 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsseg2e32.v v24, (a0), v0.t" + + - + input: + bytes: [ 0x27, 0x6c, 0x05, 0x22 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsseg2e32.v v24, (a0)" + + - + input: + bytes: [ 0x27, 0x7c, 0x05, 0x20 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsseg2e64.v v24, (a0), v0.t" + + - + input: + bytes: [ 0x27, 0x7c, 0x05, 0x22 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsseg2e64.v v24, (a0)" + + - + input: + bytes: [ 0x27, 0x0c, 0xb5, 0x28 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vssseg2e8.v v24, (a0), a1, v0.t" + + - + input: + bytes: [ 0x27, 0x0c, 0xb5, 0x2a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vssseg2e8.v v24, (a0), a1" + + - + input: + bytes: [ 0x27, 0x5c, 0xb5, 0x28 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vssseg2e16.v v24, (a0), a1, v0.t" + + - + input: + bytes: [ 0x27, 0x5c, 0xb5, 0x2a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vssseg2e16.v v24, (a0), a1" + + - + input: + bytes: [ 0x27, 0x6c, 0xb5, 0x28 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vssseg2e32.v v24, (a0), a1, v0.t" + + - + input: + bytes: [ 0x27, 0x6c, 0xb5, 0x2a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vssseg2e32.v v24, (a0), a1" + + - + input: + bytes: [ 0x27, 0x7c, 0xb5, 0x28 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vssseg2e64.v v24, (a0), a1, v0.t" + + - + input: + bytes: [ 0x27, 0x7c, 0xb5, 0x2a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vssseg2e64.v v24, (a0), a1" + + - + input: + bytes: [ 0x27, 0x0c, 0x45, 0x24 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxseg2ei8.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x0c, 0x45, 0x26 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxseg2ei8.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x5c, 0x45, 0x24 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxseg2ei16.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x5c, 0x45, 0x26 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxseg2ei16.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x6c, 0x45, 0x24 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxseg2ei32.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x6c, 0x45, 0x26 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxseg2ei32.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x7c, 0x45, 0x24 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxseg2ei64.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x7c, 0x45, 0x26 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxseg2ei64.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x0c, 0x45, 0x2c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxseg2ei8.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x0c, 0x45, 0x2e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxseg2ei8.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x5c, 0x45, 0x2c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxseg2ei16.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x5c, 0x45, 0x2e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxseg2ei16.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x6c, 0x45, 0x2c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxseg2ei32.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x6c, 0x45, 0x2e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxseg2ei32.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x7c, 0x45, 0x2c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxseg2ei64.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x7c, 0x45, 0x2e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxseg2ei64.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x0c, 0x05, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsseg3e8.v v24, (a0), v0.t" + + - + input: + bytes: [ 0x27, 0x0c, 0x05, 0x42 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsseg3e8.v v24, (a0)" + + - + input: + bytes: [ 0x27, 0x5c, 0x05, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsseg3e16.v v24, (a0), v0.t" + + - + input: + bytes: [ 0x27, 0x5c, 0x05, 0x42 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsseg3e16.v v24, (a0)" + + - + input: + bytes: [ 0x27, 0x6c, 0x05, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsseg3e32.v v24, (a0), v0.t" + + - + input: + bytes: [ 0x27, 0x6c, 0x05, 0x42 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsseg3e32.v v24, (a0)" + + - + input: + bytes: [ 0x27, 0x7c, 0x05, 0x40 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsseg3e64.v v24, (a0), v0.t" + + - + input: + bytes: [ 0x27, 0x7c, 0x05, 0x42 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsseg3e64.v v24, (a0)" + + - + input: + bytes: [ 0x27, 0x0c, 0xb5, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vssseg3e8.v v24, (a0), a1, v0.t" + + - + input: + bytes: [ 0x27, 0x0c, 0xb5, 0x4a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vssseg3e8.v v24, (a0), a1" + + - + input: + bytes: [ 0x27, 0x5c, 0xb5, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vssseg3e16.v v24, (a0), a1, v0.t" + + - + input: + bytes: [ 0x27, 0x5c, 0xb5, 0x4a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vssseg3e16.v v24, (a0), a1" + + - + input: + bytes: [ 0x27, 0x6c, 0xb5, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vssseg3e32.v v24, (a0), a1, v0.t" + + - + input: + bytes: [ 0x27, 0x6c, 0xb5, 0x4a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vssseg3e32.v v24, (a0), a1" + + - + input: + bytes: [ 0x27, 0x7c, 0xb5, 0x48 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vssseg3e64.v v24, (a0), a1, v0.t" + + - + input: + bytes: [ 0x27, 0x7c, 0xb5, 0x4a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vssseg3e64.v v24, (a0), a1" + + - + input: + bytes: [ 0x27, 0x0c, 0x45, 0x44 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxseg3ei8.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x0c, 0x45, 0x46 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxseg3ei8.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x5c, 0x45, 0x44 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxseg3ei16.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x5c, 0x45, 0x46 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxseg3ei16.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x6c, 0x45, 0x44 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxseg3ei32.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x6c, 0x45, 0x46 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxseg3ei32.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x7c, 0x45, 0x44 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxseg3ei64.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x7c, 0x45, 0x46 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxseg3ei64.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x0c, 0x45, 0x4c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxseg3ei8.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x0c, 0x45, 0x4e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxseg3ei8.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x5c, 0x45, 0x4c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxseg3ei16.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x5c, 0x45, 0x4e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxseg3ei16.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x6c, 0x45, 0x4c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxseg3ei32.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x6c, 0x45, 0x4e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxseg3ei32.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x7c, 0x45, 0x4c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxseg3ei64.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x7c, 0x45, 0x4e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxseg3ei64.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x0c, 0x05, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsseg4e8.v v24, (a0), v0.t" + + - + input: + bytes: [ 0x27, 0x0c, 0x05, 0x62 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsseg4e8.v v24, (a0)" + + - + input: + bytes: [ 0x27, 0x5c, 0x05, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsseg4e16.v v24, (a0), v0.t" + + - + input: + bytes: [ 0x27, 0x5c, 0x05, 0x62 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsseg4e16.v v24, (a0)" + + - + input: + bytes: [ 0x27, 0x6c, 0x05, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsseg4e32.v v24, (a0), v0.t" + + - + input: + bytes: [ 0x27, 0x6c, 0x05, 0x62 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsseg4e32.v v24, (a0)" + + - + input: + bytes: [ 0x27, 0x7c, 0x05, 0x60 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsseg4e64.v v24, (a0), v0.t" + + - + input: + bytes: [ 0x27, 0x7c, 0x05, 0x62 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsseg4e64.v v24, (a0)" + + - + input: + bytes: [ 0x27, 0x0c, 0xb5, 0x68 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vssseg4e8.v v24, (a0), a1, v0.t" + + - + input: + bytes: [ 0x27, 0x0c, 0xb5, 0x6a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vssseg4e8.v v24, (a0), a1" + + - + input: + bytes: [ 0x27, 0x5c, 0xb5, 0x68 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vssseg4e16.v v24, (a0), a1, v0.t" + + - + input: + bytes: [ 0x27, 0x5c, 0xb5, 0x6a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vssseg4e16.v v24, (a0), a1" + + - + input: + bytes: [ 0x27, 0x6c, 0xb5, 0x68 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vssseg4e32.v v24, (a0), a1, v0.t" + + - + input: + bytes: [ 0x27, 0x6c, 0xb5, 0x6a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vssseg4e32.v v24, (a0), a1" + + - + input: + bytes: [ 0x27, 0x7c, 0xb5, 0x68 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vssseg4e64.v v24, (a0), a1, v0.t" + + - + input: + bytes: [ 0x27, 0x7c, 0xb5, 0x6a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vssseg4e64.v v24, (a0), a1" + + - + input: + bytes: [ 0x27, 0x0c, 0x45, 0x64 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxseg4ei8.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x0c, 0x45, 0x66 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxseg4ei8.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x5c, 0x45, 0x64 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxseg4ei16.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x5c, 0x45, 0x66 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxseg4ei16.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x6c, 0x45, 0x64 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxseg4ei32.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x6c, 0x45, 0x66 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxseg4ei32.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x7c, 0x45, 0x64 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxseg4ei64.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x7c, 0x45, 0x66 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxseg4ei64.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x0c, 0x45, 0x6c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxseg4ei8.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x0c, 0x45, 0x6e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxseg4ei8.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x5c, 0x45, 0x6c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxseg4ei16.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x5c, 0x45, 0x6e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxseg4ei16.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x6c, 0x45, 0x6c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxseg4ei32.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x6c, 0x45, 0x6e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxseg4ei32.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x7c, 0x45, 0x6c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxseg4ei64.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x7c, 0x45, 0x6e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxseg4ei64.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x0c, 0x05, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsseg5e8.v v24, (a0), v0.t" + + - + input: + bytes: [ 0x27, 0x0c, 0x05, 0x82 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsseg5e8.v v24, (a0)" + + - + input: + bytes: [ 0x27, 0x5c, 0x05, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsseg5e16.v v24, (a0), v0.t" + + - + input: + bytes: [ 0x27, 0x5c, 0x05, 0x82 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsseg5e16.v v24, (a0)" + + - + input: + bytes: [ 0x27, 0x6c, 0x05, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsseg5e32.v v24, (a0), v0.t" + + - + input: + bytes: [ 0x27, 0x6c, 0x05, 0x82 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsseg5e32.v v24, (a0)" + + - + input: + bytes: [ 0x27, 0x7c, 0x05, 0x80 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsseg5e64.v v24, (a0), v0.t" + + - + input: + bytes: [ 0x27, 0x7c, 0x05, 0x82 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsseg5e64.v v24, (a0)" + + - + input: + bytes: [ 0x27, 0x0c, 0xb5, 0x88 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vssseg5e8.v v24, (a0), a1, v0.t" + + - + input: + bytes: [ 0x27, 0x0c, 0xb5, 0x8a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vssseg5e8.v v24, (a0), a1" + + - + input: + bytes: [ 0x27, 0x5c, 0xb5, 0x88 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vssseg5e16.v v24, (a0), a1, v0.t" + + - + input: + bytes: [ 0x27, 0x5c, 0xb5, 0x8a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vssseg5e16.v v24, (a0), a1" + + - + input: + bytes: [ 0x27, 0x6c, 0xb5, 0x88 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vssseg5e32.v v24, (a0), a1, v0.t" + + - + input: + bytes: [ 0x27, 0x6c, 0xb5, 0x8a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vssseg5e32.v v24, (a0), a1" + + - + input: + bytes: [ 0x27, 0x7c, 0xb5, 0x88 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vssseg5e64.v v24, (a0), a1, v0.t" + + - + input: + bytes: [ 0x27, 0x7c, 0xb5, 0x8a ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vssseg5e64.v v24, (a0), a1" + + - + input: + bytes: [ 0x27, 0x0c, 0x45, 0x84 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxseg5ei8.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x0c, 0x45, 0x86 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxseg5ei8.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x5c, 0x45, 0x84 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxseg5ei16.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x5c, 0x45, 0x86 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxseg5ei16.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x6c, 0x45, 0x84 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxseg5ei32.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x6c, 0x45, 0x86 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxseg5ei32.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x7c, 0x45, 0x84 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxseg5ei64.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x7c, 0x45, 0x86 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxseg5ei64.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x0c, 0x45, 0x8c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxseg5ei8.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x0c, 0x45, 0x8e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxseg5ei8.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x5c, 0x45, 0x8c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxseg5ei16.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x5c, 0x45, 0x8e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxseg5ei16.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x6c, 0x45, 0x8c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxseg5ei32.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x6c, 0x45, 0x8e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxseg5ei32.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x7c, 0x45, 0x8c ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxseg5ei64.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x7c, 0x45, 0x8e ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxseg5ei64.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x0c, 0x05, 0xa0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsseg6e8.v v24, (a0), v0.t" + + - + input: + bytes: [ 0x27, 0x0c, 0x05, 0xa2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsseg6e8.v v24, (a0)" + + - + input: + bytes: [ 0x27, 0x5c, 0x05, 0xa0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsseg6e16.v v24, (a0), v0.t" + + - + input: + bytes: [ 0x27, 0x5c, 0x05, 0xa2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsseg6e16.v v24, (a0)" + + - + input: + bytes: [ 0x27, 0x6c, 0x05, 0xa0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsseg6e32.v v24, (a0), v0.t" + + - + input: + bytes: [ 0x27, 0x6c, 0x05, 0xa2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsseg6e32.v v24, (a0)" + + - + input: + bytes: [ 0x27, 0x7c, 0x05, 0xa0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsseg6e64.v v24, (a0), v0.t" + + - + input: + bytes: [ 0x27, 0x7c, 0x05, 0xa2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsseg6e64.v v24, (a0)" + + - + input: + bytes: [ 0x27, 0x0c, 0xb5, 0xa8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vssseg6e8.v v24, (a0), a1, v0.t" + + - + input: + bytes: [ 0x27, 0x0c, 0xb5, 0xaa ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vssseg6e8.v v24, (a0), a1" + + - + input: + bytes: [ 0x27, 0x5c, 0xb5, 0xa8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vssseg6e16.v v24, (a0), a1, v0.t" + + - + input: + bytes: [ 0x27, 0x5c, 0xb5, 0xaa ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vssseg6e16.v v24, (a0), a1" + + - + input: + bytes: [ 0x27, 0x6c, 0xb5, 0xa8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vssseg6e32.v v24, (a0), a1, v0.t" + + - + input: + bytes: [ 0x27, 0x6c, 0xb5, 0xaa ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vssseg6e32.v v24, (a0), a1" + + - + input: + bytes: [ 0x27, 0x7c, 0xb5, 0xa8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vssseg6e64.v v24, (a0), a1, v0.t" + + - + input: + bytes: [ 0x27, 0x7c, 0xb5, 0xaa ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vssseg6e64.v v24, (a0), a1" + + - + input: + bytes: [ 0x27, 0x0c, 0x45, 0xa4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxseg6ei8.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x0c, 0x45, 0xa6 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxseg6ei8.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x5c, 0x45, 0xa4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxseg6ei16.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x5c, 0x45, 0xa6 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxseg6ei16.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x6c, 0x45, 0xa4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxseg6ei32.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x6c, 0x45, 0xa6 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxseg6ei32.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x7c, 0x45, 0xa4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxseg6ei64.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x7c, 0x45, 0xa6 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxseg6ei64.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x0c, 0x45, 0xac ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxseg6ei8.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x0c, 0x45, 0xae ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxseg6ei8.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x5c, 0x45, 0xac ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxseg6ei16.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x5c, 0x45, 0xae ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxseg6ei16.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x6c, 0x45, 0xac ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxseg6ei32.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x6c, 0x45, 0xae ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxseg6ei32.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x7c, 0x45, 0xac ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxseg6ei64.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x7c, 0x45, 0xae ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxseg6ei64.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x0c, 0x05, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsseg7e8.v v24, (a0), v0.t" + + - + input: + bytes: [ 0x27, 0x0c, 0x05, 0xc2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsseg7e8.v v24, (a0)" + + - + input: + bytes: [ 0x27, 0x5c, 0x05, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsseg7e16.v v24, (a0), v0.t" + + - + input: + bytes: [ 0x27, 0x5c, 0x05, 0xc2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsseg7e16.v v24, (a0)" + + - + input: + bytes: [ 0x27, 0x6c, 0x05, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsseg7e32.v v24, (a0), v0.t" + + - + input: + bytes: [ 0x27, 0x6c, 0x05, 0xc2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsseg7e32.v v24, (a0)" + + - + input: + bytes: [ 0x27, 0x7c, 0x05, 0xc0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsseg7e64.v v24, (a0), v0.t" + + - + input: + bytes: [ 0x27, 0x7c, 0x05, 0xc2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsseg7e64.v v24, (a0)" + + - + input: + bytes: [ 0x27, 0x0c, 0xb5, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vssseg7e8.v v24, (a0), a1, v0.t" + + - + input: + bytes: [ 0x27, 0x0c, 0xb5, 0xca ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vssseg7e8.v v24, (a0), a1" + + - + input: + bytes: [ 0x27, 0x5c, 0xb5, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vssseg7e16.v v24, (a0), a1, v0.t" + + - + input: + bytes: [ 0x27, 0x5c, 0xb5, 0xca ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vssseg7e16.v v24, (a0), a1" + + - + input: + bytes: [ 0x27, 0x6c, 0xb5, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vssseg7e32.v v24, (a0), a1, v0.t" + + - + input: + bytes: [ 0x27, 0x6c, 0xb5, 0xca ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vssseg7e32.v v24, (a0), a1" + + - + input: + bytes: [ 0x27, 0x7c, 0xb5, 0xc8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vssseg7e64.v v24, (a0), a1, v0.t" + + - + input: + bytes: [ 0x27, 0x7c, 0xb5, 0xca ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vssseg7e64.v v24, (a0), a1" + + - + input: + bytes: [ 0x27, 0x0c, 0x45, 0xc4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxseg7ei8.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x0c, 0x45, 0xc6 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxseg7ei8.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x5c, 0x45, 0xc4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxseg7ei16.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x5c, 0x45, 0xc6 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxseg7ei16.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x6c, 0x45, 0xc4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxseg7ei32.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x6c, 0x45, 0xc6 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxseg7ei32.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x7c, 0x45, 0xc4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxseg7ei64.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x7c, 0x45, 0xc6 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxseg7ei64.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x0c, 0x45, 0xcc ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxseg7ei8.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x0c, 0x45, 0xce ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxseg7ei8.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x5c, 0x45, 0xcc ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxseg7ei16.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x5c, 0x45, 0xce ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxseg7ei16.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x6c, 0x45, 0xcc ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxseg7ei32.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x6c, 0x45, 0xce ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxseg7ei32.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x7c, 0x45, 0xcc ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxseg7ei64.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x7c, 0x45, 0xce ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxseg7ei64.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x0c, 0x05, 0xe0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsseg8e8.v v24, (a0), v0.t" + + - + input: + bytes: [ 0x27, 0x0c, 0x05, 0xe2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsseg8e8.v v24, (a0)" + + - + input: + bytes: [ 0x27, 0x5c, 0x05, 0xe0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsseg8e16.v v24, (a0), v0.t" + + - + input: + bytes: [ 0x27, 0x5c, 0x05, 0xe2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsseg8e16.v v24, (a0)" + + - + input: + bytes: [ 0x27, 0x6c, 0x05, 0xe0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsseg8e32.v v24, (a0), v0.t" + + - + input: + bytes: [ 0x27, 0x6c, 0x05, 0xe2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsseg8e32.v v24, (a0)" + + - + input: + bytes: [ 0x27, 0x7c, 0x05, 0xe0 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsseg8e64.v v24, (a0), v0.t" + + - + input: + bytes: [ 0x27, 0x7c, 0x05, 0xe2 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsseg8e64.v v24, (a0)" + + - + input: + bytes: [ 0x27, 0x0c, 0xb5, 0xe8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vssseg8e8.v v24, (a0), a1, v0.t" + + - + input: + bytes: [ 0x27, 0x0c, 0xb5, 0xea ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vssseg8e8.v v24, (a0), a1" + + - + input: + bytes: [ 0x27, 0x5c, 0xb5, 0xe8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vssseg8e16.v v24, (a0), a1, v0.t" + + - + input: + bytes: [ 0x27, 0x5c, 0xb5, 0xea ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vssseg8e16.v v24, (a0), a1" + + - + input: + bytes: [ 0x27, 0x6c, 0xb5, 0xe8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vssseg8e32.v v24, (a0), a1, v0.t" + + - + input: + bytes: [ 0x27, 0x6c, 0xb5, 0xea ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vssseg8e32.v v24, (a0), a1" + + - + input: + bytes: [ 0x27, 0x7c, 0xb5, 0xe8 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vssseg8e64.v v24, (a0), a1, v0.t" + + - + input: + bytes: [ 0x27, 0x7c, 0xb5, 0xea ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vssseg8e64.v v24, (a0), a1" + + - + input: + bytes: [ 0x27, 0x0c, 0x45, 0xe4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxseg8ei8.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x0c, 0x45, 0xe6 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxseg8ei8.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x5c, 0x45, 0xe4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxseg8ei16.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x5c, 0x45, 0xe6 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxseg8ei16.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x6c, 0x45, 0xe4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxseg8ei32.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x6c, 0x45, 0xe6 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxseg8ei32.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x7c, 0x45, 0xe4 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxseg8ei64.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x7c, 0x45, 0xe6 ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsuxseg8ei64.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x0c, 0x45, 0xec ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxseg8ei8.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x0c, 0x45, 0xee ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxseg8ei8.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x5c, 0x45, 0xec ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxseg8ei16.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x5c, 0x45, 0xee ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxseg8ei16.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x6c, 0x45, 0xec ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxseg8ei32.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x6c, 0x45, 0xee ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxseg8ei32.v v24, (a0), v4" + + - + input: + bytes: [ 0x27, 0x7c, 0x45, 0xec ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxseg8ei64.v v24, (a0), v4, v0.t" + + - + input: + bytes: [ 0x27, 0x7c, 0x45, 0xee ] + arch: "CS_ARCH_RISCV" + options: [ "CS_MODE_RISCV64", "CS_MODE_RISCV_V", "CS_OPT_SYNTAX_NO_ALIAS_TEXT" ] + expected: + insns: + - + asm_text: "vsoxseg8ei64.v v24, (a0), v4" diff --git a/tests/details/riscv.yaml b/tests/details/riscv.yaml index 9bd6be20f7..9f9b3832e3 100644 --- a/tests/details/riscv.yaml +++ b/tests/details/riscv.yaml @@ -1,4049 +1,3692 @@ test_cases: - - - input: - bytes: [ 0x37, 0x34, 0x00, 0x00, 0x97, 0x82, 0x00, 0x00, 0xef, 0x00, 0x80, 0x00, 0xef, 0xf0, 0x1f, 0xff, 0xe7, 0x00, 0x45, 0x00, 0xe7, 0x00, 0xc0, 0xff, 0x63, 0x05, 0x41, 0x00, 0xe3, 0x9d, 0x61, 0xfe, 0x63, 0xca, 0x93, 0x00, 0x63, 0x53, 0xb5, 0x00, 0x63, 0x65, 0xd6, 0x00, 0x63, 0x76, 0xf7, 0x00, 0x03, 0x88, 0x18, 0x00, 0x03, 0x99, 0x49, 0x00, 0x03, 0xaa, 0x6a, 0x00, 0x03, 0xcb, 0x2b, 0x01, 0x03, 0xdc, 0x8c, 0x01, 0x23, 0x86, 0xad, 0x03, 0x23, 0x9a, 0xce, 0x03, 0x23, 0x8f, 0xef, 0x01, 0x93, 0x00, 0xe0, 0x00, 0x13, 0xa1, 0x01, 0x01, 0x13, 0xb2, 0x02, 0x7d, 0x13, 0xc3, 0x03, 0xdd, 0x13, 0xe4, 0xc4, 0x12, 0x13, 0xf5, 0x85, 0x0c, 0x13, 0x96, 0xe6, 0x01, 0x13, 0xd7, 0x97, 0x01, 0x13, 0xd8, 0xf8, 0x40, 0x33, 0x89, 0x49, 0x01, 0xb3, 0x0a, 0x7b, 0x41, 0x33, 0xac, 0xac, 0x01, 0xb3, 0x3d, 0xde, 0x01, 0x33, 0xd2, 0x62, 0x40, 0xb3, 0x43, 0x94, 0x00, 0x33, 0xe5, 0xc5, 0x00, 0xb3, 0x76, 0xf7, 0x00, 0xb3, 0x54, 0x39, 0x01, 0xb3, 0x50, 0x31, 0x00, 0x33, 0x9f, 0x0f, 0x00, 0x73, 0x15, 0x04, 0xb0, 0xf3, 0x56, 0x00, 0x10, 0x33, 0x05, 0x7b, 0x03, 0xb3, 0x45, 0x9c, 0x03, 0x33, 0x66, 0xbd, 0x03, 0x2f, 0xa4, 0x02, 0x10, 0xaf, 0x23, 0x65, 0x18, 0x2f, 0x27, 0x2f, 0x01, 0x43, 0xf0, 0x20, 0x18, 0xd3, 0x72, 0x73, 0x00, 0x53, 0xf4, 0x04, 0x58, 0x53, 0x85, 0xc5, 0x28, 0x53, 0x2e, 0xde, 0xa1, 0xd3, 0x84, 0x05, 0xf0, 0x53, 0x06, 0x05, 0xe0, 0x53, 0x75, 0x00, 0xc0, 0xd3, 0xf0, 0x05, 0xd0, 0xd3, 0x15, 0x08, 0xe0, 0x87, 0xaa, 0x75, 0x00, 0x27, 0x27, 0x66, 0x01, 0x43, 0xf0, 0x20, 0x1a, 0xd3, 0x72, 0x73, 0x02, 0x53, 0xf4, 0x04, 0x5a, 0x53, 0x85, 0xc5, 0x2a, 0x53, 0x2e, 0xde, 0xa3 ] - arch: "riscv" - options: [ CS_OPT_DETAIL, CS_MODE_RISCV32 ] + - input: + bytes: + [ + 0x37, + 0x34, + 0x00, + 0x00, + 0x97, + 0x82, + 0x00, + 0x00, + 0xef, + 0x00, + 0x80, + 0x00, + 0xef, + 0xf0, + 0x1f, + 0xff, + 0xe7, + 0x00, + 0x45, + 0x00, + 0xe7, + 0x00, + 0xc0, + 0xff, + 0x63, + 0x05, + 0x41, + 0x00, + 0xe3, + 0x9d, + 0x61, + 0xfe, + 0x63, + 0xca, + 0x93, + 0x00, + 0x63, + 0x53, + 0xb5, + 0x00, + 0x63, + 0x65, + 0xd6, + 0x00, + 0x63, + 0x76, + 0xf7, + 0x00, + 0x03, + 0x88, + 0x18, + 0x00, + 0x03, + 0x99, + 0x49, + 0x00, + 0x03, + 0xaa, + 0x6a, + 0x00, + 0x03, + 0xcb, + 0x2b, + 0x01, + 0x03, + 0xdc, + 0x8c, + 0x01, + 0x23, + 0x86, + 0xad, + 0x03, + 0x23, + 0x9a, + 0xce, + 0x03, + 0x23, + 0x8f, + 0xef, + 0x01, + 0x93, + 0x00, + 0xe0, + 0x00, + 0x13, + 0xa1, + 0x01, + 0x01, + 0x13, + 0xb2, + 0x02, + 0x7d, + 0x13, + 0xc3, + 0x03, + 0xdd, + 0x13, + 0xe4, + 0xc4, + 0x12, + 0x13, + 0xf5, + 0x85, + 0x0c, + 0x13, + 0x96, + 0xe6, + 0x01, + 0x13, + 0xd7, + 0x97, + 0x01, + 0x13, + 0xd8, + 0xf8, + 0x40, + 0x33, + 0x89, + 0x49, + 0x01, + 0xb3, + 0x0a, + 0x7b, + 0x41, + 0x33, + 0xac, + 0xac, + 0x01, + 0xb3, + 0x3d, + 0xde, + 0x01, + 0x33, + 0xd2, + 0x62, + 0x40, + 0xb3, + 0x43, + 0x94, + 0x00, + 0x33, + 0xe5, + 0xc5, + 0x00, + 0xb3, + 0x76, + 0xf7, + 0x00, + 0xb3, + 0x54, + 0x39, + 0x01, + 0xb3, + 0x50, + 0x31, + 0x00, + 0x33, + 0x9f, + 0x0f, + 0x00, + 0x73, + 0x15, + 0x04, + 0xb0, + 0xf3, + 0x56, + 0x00, + 0x10, + 0x33, + 0x05, + 0x7b, + 0x03, + 0xb3, + 0x45, + 0x9c, + 0x03, + 0x33, + 0x66, + 0xbd, + 0x03, + 0x2f, + 0xa4, + 0x02, + 0x10, + 0xaf, + 0x23, + 0x65, + 0x18, + 0x2f, + 0x27, + 0x2f, + 0x01, + 0x43, + 0xf0, + 0x20, + 0x18, + 0xd3, + 0x72, + 0x73, + 0x00, + 0x53, + 0xf4, + 0x04, + 0x58, + 0x53, + 0x85, + 0xc5, + 0x28, + 0x53, + 0x2e, + 0xde, + 0xa1, + 0xd3, + 0x84, + 0x05, + 0xf0, + 0x53, + 0x06, + 0x05, + 0xe0, + 0x53, + 0x75, + 0x00, + 0xc0, + 0xd3, + 0xf0, + 0x05, + 0xd0, + 0xd3, + 0x15, + 0x08, + 0xe0, + 0x87, + 0xaa, + 0x75, + 0x00, + 0x27, + 0x27, + 0x66, + 0x01, + 0x43, + 0xf0, + 0x20, + 0x1a, + 0xd3, + 0x72, + 0x73, + 0x02, + 0x53, + 0xf4, + 0x04, + 0x5a, + 0x53, + 0x85, + 0xc5, + 0x2a, + 0x53, + 0x2e, + 0xde, + 0xa3, + ] + arch: "CS_ARCH_RISCV" + options: + [ + CS_OPT_DETAIL, + CS_MODE_RISCV32, + CS_MODE_RISCV_A, + CS_MODE_RISCV_D, + CS_OPT_SYNTAX_NO_ALIAS_TEXT, + ] address: 0x1000 expected: insns: - - - asm_text: "lui s0, 3" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: s0 - access: CS_AC_WRITE - - - type: RISCV_OP_IMM - imm: 0x3 - access: CS_AC_READ - - - asm_text: "auipc t0, 8" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: t0 - access: CS_AC_WRITE - - - type: RISCV_OP_IMM - imm: 0x8 - access: CS_AC_READ - - - asm_text: "jal 8" - details: - riscv: - operands: - - - type: RISCV_OP_IMM - imm: 0x8 - access: CS_AC_READ - groups: [ RISCV_GRP_CALL ] - - - asm_text: "jal -0x10" - details: - riscv: - operands: - - - type: RISCV_OP_IMM - imm: -0x10 - access: CS_AC_READ - groups: [ RISCV_GRP_CALL ] - - - asm_text: "jalr ra, a0, 4" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: ra - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: a0 - access: CS_AC_READ - - - type: RISCV_OP_IMM - imm: 0x4 - access: CS_AC_READ - groups: [ RISCV_GRP_CALL ] - - - asm_text: "jalr ra, zero, -4" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: ra - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: zero - access: CS_AC_READ - - - type: RISCV_OP_IMM - imm: -4 - access: CS_AC_READ - groups: [ RISCV_GRP_CALL ] - - - asm_text: "beq sp, tp, 0xa" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: sp - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: tp - access: CS_AC_READ - - - type: RISCV_OP_IMM - imm: 0xa - access: CS_AC_READ - groups: [ RISCV_GRP_BRANCH_RELATIVE, RISCV_GRP_JUMP ] - - - asm_text: "bne gp, t1, -6" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: gp - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: t1 - access: CS_AC_READ - - - type: RISCV_OP_IMM - imm: -6 - access: CS_AC_READ - groups: [ RISCV_GRP_BRANCH_RELATIVE, RISCV_GRP_JUMP ] - - - asm_text: "blt t2, s1, 0x14" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: t2 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: s1 - access: CS_AC_READ - - - type: RISCV_OP_IMM - imm: 0x14 - access: CS_AC_READ - groups: [ RISCV_GRP_BRANCH_RELATIVE, RISCV_GRP_JUMP ] - - - asm_text: "bge a0, a1, 6" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a0 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: a1 - access: CS_AC_READ - - - type: RISCV_OP_IMM - imm: 0x6 - access: CS_AC_READ - groups: [ RISCV_GRP_BRANCH_RELATIVE, RISCV_GRP_JUMP ] - - - asm_text: "bltu a2, a3, 0xa" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a2 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: a3 - access: CS_AC_READ - - - type: RISCV_OP_IMM - imm: 0xa - access: CS_AC_READ - groups: [ RISCV_GRP_BRANCH_RELATIVE, RISCV_GRP_JUMP ] - - - asm_text: "bgeu a4, a5, 0xc" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a4 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: a5 - access: CS_AC_READ - - - type: RISCV_OP_IMM - imm: 0xc - access: CS_AC_READ - groups: [ RISCV_GRP_BRANCH_RELATIVE, RISCV_GRP_JUMP ] - - - asm_text: "lb a6, 1(a7)" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a6 - access: CS_AC_WRITE - - - type: RISCV_OP_MEM - mem_base: a7 - mem_disp: 0x1 - access: CS_AC_READ - - - asm_text: "lh s2, 4(s3)" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: s2 - access: CS_AC_WRITE - - - type: RISCV_OP_MEM - mem_base: s3 - mem_disp: 0x4 - access: CS_AC_READ - - - asm_text: "lw s4, 6(s5)" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: s4 - access: CS_AC_WRITE - - - type: RISCV_OP_MEM - mem_base: s5 - mem_disp: 0x6 - access: CS_AC_READ - - - asm_text: "lbu s6, 0x12(s7)" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: s6 - access: CS_AC_WRITE - - - type: RISCV_OP_MEM - mem_base: s7 - mem_disp: 0x12 - access: CS_AC_READ - - - asm_text: "lhu s8, 0x18(s9)" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: s8 - access: CS_AC_WRITE - - - type: RISCV_OP_MEM - mem_base: s9 - mem_disp: 0x18 - access: CS_AC_READ - - - asm_text: "sb s10, 0x2c(s11)" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: s10 - access: CS_AC_READ - - - type: RISCV_OP_MEM - mem_base: s11 - mem_disp: 0x2c - access: CS_AC_WRITE - - - asm_text: "sh t3, 0x34(t4)" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: t3 - access: CS_AC_READ - - - type: RISCV_OP_MEM - mem_base: t4 - mem_disp: 0x34 - access: CS_AC_WRITE - - - asm_text: "sb t5, 0x1e(t6)" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: t5 - access: CS_AC_READ - - - type: RISCV_OP_MEM - mem_base: t6 - mem_disp: 0x1e - access: CS_AC_WRITE - - - asm_text: "addi ra, zero, 0xe" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: ra - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: zero - access: CS_AC_READ - - - type: RISCV_OP_IMM - imm: 0xe - access: CS_AC_READ - - - asm_text: "slti sp, gp, 0x10" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: sp - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: gp - access: CS_AC_READ - - - type: RISCV_OP_IMM - imm: 0x10 - access: CS_AC_READ - - - asm_text: "sltiu tp, t0, 0x7d0" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: tp - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: t0 - access: CS_AC_READ - - - type: RISCV_OP_IMM - imm: 0x7d0 - access: CS_AC_READ - - - asm_text: "xori t1, t2, -0x230" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: t1 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: t2 - access: CS_AC_READ - - - type: RISCV_OP_IMM - imm: -0x230 - access: CS_AC_READ - - - asm_text: "ori s0, s1, 0x12c" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: s0 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: s1 - access: CS_AC_READ - - - type: RISCV_OP_IMM - imm: 0x12c - access: CS_AC_READ - - - asm_text: "andi a0, a1, 0xc8" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a0 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: a1 - access: CS_AC_READ - - - type: RISCV_OP_IMM - imm: 0xc8 - access: CS_AC_READ - - - asm_text: "slli a2, a3, 0x1e" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a2 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: a3 - access: CS_AC_READ - - - type: RISCV_OP_IMM - imm: 0x1e - access: CS_AC_READ - - - asm_text: "srli a4, a5, 0x19" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a4 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: a5 - access: CS_AC_READ - - - type: RISCV_OP_IMM - imm: 0x19 - access: CS_AC_READ - - - asm_text: "srai a6, a7, 0xf" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a6 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: a7 - access: CS_AC_READ - - - type: RISCV_OP_IMM - imm: 0xf - access: CS_AC_READ - - - asm_text: "add s2, s3, s4" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: s2 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: s3 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: s4 - access: CS_AC_READ - - - asm_text: "sub s5, s6, s7" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: s5 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: s6 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: s7 - access: CS_AC_READ - - - asm_text: "slt s8, s9, s10" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: s8 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: s9 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: s10 - access: CS_AC_READ - - - asm_text: "sltu s11, t3, t4" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: s11 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: t3 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: t4 - access: CS_AC_READ - - - asm_text: "sra tp, t0, t1" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: tp - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: t0 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: t1 - access: CS_AC_READ - - - asm_text: "xor t2, s0, s1" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: t2 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: s0 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: s1 - access: CS_AC_READ - - - asm_text: "or a0, a1, a2" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a0 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: a1 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: a2 - access: CS_AC_READ - - - asm_text: "and a3, a4, a5" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a3 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: a4 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: a5 - access: CS_AC_READ - - - asm_text: "srl s1, s2, s3" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: s1 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: s2 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: s3 - access: CS_AC_READ - - - asm_text: "srl ra, sp, gp" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: ra - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: sp - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: gp - access: CS_AC_READ - - - asm_text: "sll t5, t6, zero" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: t5 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: t6 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: zero - access: CS_AC_READ - - - asm_text: "csrrw a0, mcycle, s0" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a0 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: s0 - access: CS_AC_READ - - - asm_text: "csrrwi a3, sstatus, 0" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a3 - access: CS_AC_WRITE - - - type: RISCV_OP_IMM - imm: 0x0 - access: CS_AC_READ - - - asm_text: "mul a0, s6, s7" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a0 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: s6 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: s7 - access: CS_AC_READ - groups: [ RISCV_GRP_HASSTDEXTM ] - - - asm_text: "div a1, s8, s9" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a1 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: s8 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: s9 - access: CS_AC_READ - groups: [ RISCV_GRP_HASSTDEXTM ] - - - asm_text: "rem a2, s10, s11" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a2 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: s10 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: s11 - access: CS_AC_READ - groups: [ RISCV_GRP_HASSTDEXTM ] - - - asm_text: "lr.w s0, (t0)" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: s0 - access: CS_AC_WRITE - - - type: RISCV_OP_MEM - mem_base: t0 - access: CS_AC_READ - groups: [ RISCV_GRP_HASSTDEXTA ] - - - asm_text: "sc.w t2, t1, (a0)" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: t2 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: t1 - access: CS_AC_READ - - - type: RISCV_OP_MEM - mem_base: a0 - access: CS_AC_WRITE - groups: [ RISCV_GRP_HASSTDEXTA ] - - - asm_text: "amoadd.w a4, s2, (t5)" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a4 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: s2 - access: CS_AC_READ - - - type: RISCV_OP_MEM - mem_base: t5 - access: CS_AC_READ_WRITE - groups: [ RISCV_GRP_HASSTDEXTA ] - - - asm_text: "fmadd.s ft0, ft1, ft2, ft3" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: ft0 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: ft1 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: ft2 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: ft3 - access: CS_AC_READ - groups: [ RISCV_GRP_HASSTDEXTF ] - - - asm_text: "fadd.s ft5, ft6, ft7" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: ft5 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: ft6 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: ft7 - access: CS_AC_READ - groups: [ RISCV_GRP_HASSTDEXTF ] - - - asm_text: "fsqrt.s fs0, fs1" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: fs0 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: fs1 - access: CS_AC_READ - groups: [ RISCV_GRP_HASSTDEXTF ] - - - asm_text: "fmin.s fa0, fa1, fa2" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: fa0 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: fa1 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: fa2 - access: CS_AC_READ - groups: [ RISCV_GRP_HASSTDEXTF ] - - - asm_text: "feq.s t3, ft8, ft9" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: t3 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: ft8 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: ft9 - access: CS_AC_READ - groups: [ RISCV_GRP_HASSTDEXTF ] - - - asm_text: "fmv.w.x fs1, a1" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: fs1 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: a1 - access: CS_AC_READ - groups: [ RISCV_GRP_HASSTDEXTF ] - - - asm_text: "fmv.x.w a2, fa0" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a2 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: fa0 - access: CS_AC_READ - groups: [ RISCV_GRP_HASSTDEXTF ] - - - asm_text: "fcvt.w.s a0, ft0" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a0 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: ft0 - access: CS_AC_READ - groups: [ RISCV_GRP_HASSTDEXTF ] - - - asm_text: "fcvt.s.w ft1, a1" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: ft1 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: a1 - access: CS_AC_READ - groups: [ RISCV_GRP_HASSTDEXTF ] - - - asm_text: "fclass.s a1, fa6" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a1 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: fa6 - access: CS_AC_READ - groups: [ RISCV_GRP_HASSTDEXTF ] - - - asm_text: "flw fs5, 7(a1)" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: fs5 - access: CS_AC_WRITE - - - type: RISCV_OP_MEM - mem_base: a1 - mem_disp: 0x7 - access: CS_AC_READ - groups: [ RISCV_GRP_HASSTDEXTF ] - - - asm_text: "fsw fs6, 0xe(a2)" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: fs6 - access: CS_AC_READ - - - type: RISCV_OP_MEM - mem_base: a2 - mem_disp: 0xe - access: CS_AC_WRITE - groups: [ RISCV_GRP_HASSTDEXTF ] - - - asm_text: "fmadd.d ft0, ft1, ft2, ft3" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: ft0 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: ft1 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: ft2 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: ft3 - access: CS_AC_READ - groups: [ RISCV_GRP_HASSTDEXTD ] - - - asm_text: "fadd.d ft5, ft6, ft7" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: ft5 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: ft6 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: ft7 - access: CS_AC_READ - groups: [ RISCV_GRP_HASSTDEXTD ] - - - asm_text: "fsqrt.d fs0, fs1" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: fs0 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: fs1 - access: CS_AC_READ - groups: [ RISCV_GRP_HASSTDEXTD ] - - - asm_text: "fmin.d fa0, fa1, fa2" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: fa0 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: fa1 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: fa2 - access: CS_AC_READ - groups: [ RISCV_GRP_HASSTDEXTD ] - - - asm_text: "feq.d t3, ft8, ft9" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: t3 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: ft8 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: ft9 - access: CS_AC_READ - groups: [ RISCV_GRP_HASSTDEXTD ] - - - input: - bytes: [ 0x13, 0x04, 0xa8, 0x7a, 0xbb, 0x07, 0x9c, 0x02, 0xbb, 0x40, 0x5d, 0x02, 0x3b, 0x63, 0xb7, 0x03, 0x2f, 0xb4, 0x02, 0x10, 0xaf, 0x33, 0x65, 0x18, 0x2f, 0x37, 0x2f, 0x01, 0x53, 0x75, 0x20, 0xc0, 0xd3, 0xf0, 0x25, 0xd0, 0xd3, 0x84, 0x05, 0xf2, 0x53, 0x06, 0x05, 0xe2, 0x53, 0x75, 0x00, 0xc2, 0xd3, 0x80, 0x05, 0xd2, 0xd3, 0x15, 0x08, 0xe2, 0x87, 0xba, 0x75, 0x00, 0x27, 0x37, 0x66, 0x01 ] - arch: "riscv" - options: [ CS_OPT_DETAIL, CS_MODE_RISCV64 ] + - asm_text: "lui s0, 3" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: s0 + access: CS_AC_WRITE + - type: RISCV_OP_IMM + imm: 0x3 + access: CS_AC_READ + - asm_text: "auipc t0, 8" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: t0 + access: CS_AC_WRITE + - type: RISCV_OP_IMM + imm: 0x8 + access: CS_AC_READ + - asm_text: "jal ra, 4112" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: ra + access: CS_AC_WRITE + + - type: RISCV_OP_IMM + imm: 0x8 + access: CS_AC_READ + groups: [RISCV_GRP_CALL, RISCV_GRP_BRANCH_RELATIVE] + - asm_text: "jal ra, 4092" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: ra + access: CS_AC_WRITE + - type: RISCV_OP_IMM + imm: -0x10 + access: CS_AC_READ + groups: [RISCV_GRP_CALL, RISCV_GRP_BRANCH_RELATIVE] + - asm_text: "jalr ra, 4(a0)" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: ra + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: a0 + access: CS_AC_READ + - type: RISCV_OP_IMM + imm: 0x4 + access: CS_AC_READ + groups: [RISCV_GRP_CALL] + - asm_text: "jalr ra, -4(zero)" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: ra + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: zero + access: CS_AC_READ + - type: RISCV_OP_IMM + imm: -4 + access: CS_AC_READ + groups: [RISCV_GRP_CALL] + - asm_text: "beq sp, tp, 4130" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: sp + access: CS_AC_READ + - type: RISCV_OP_REG + reg: tp + access: CS_AC_READ + - type: RISCV_OP_IMM + imm: 0xa + access: CS_AC_READ + groups: [RISCV_GRP_JUMP, RISCV_GRP_BRANCH_RELATIVE] + - asm_text: "bne gp, t1, 4118" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: gp + access: CS_AC_READ + - type: RISCV_OP_REG + reg: t1 + access: CS_AC_READ + - type: RISCV_OP_IMM + imm: -6 + access: CS_AC_READ + groups: [RISCV_GRP_JUMP, RISCV_GRP_BRANCH_RELATIVE] + - asm_text: "blt t2, s1, 4148" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: t2 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: s1 + access: CS_AC_READ + - type: RISCV_OP_IMM + imm: 0x14 + access: CS_AC_READ + groups: [RISCV_GRP_JUMP, RISCV_GRP_BRANCH_RELATIVE] + - asm_text: "bge a0, a1, 4138" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a0 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: a1 + access: CS_AC_READ + - type: RISCV_OP_IMM + imm: 0x6 + access: CS_AC_READ + groups: [RISCV_GRP_JUMP, RISCV_GRP_BRANCH_RELATIVE] + - asm_text: "bltu a2, a3, 4146" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a2 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: a3 + access: CS_AC_READ + - type: RISCV_OP_IMM + imm: 0xa + access: CS_AC_READ + groups: [RISCV_GRP_JUMP, RISCV_GRP_BRANCH_RELATIVE] + - asm_text: "bgeu a4, a5, 4152" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a4 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: a5 + access: CS_AC_READ + - type: RISCV_OP_IMM + imm: 0xc + access: CS_AC_READ + groups: [RISCV_GRP_JUMP, RISCV_GRP_BRANCH_RELATIVE] + - asm_text: "lb a6, 1(a7)" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a6 + access: CS_AC_WRITE + - type: RISCV_OP_MEM + mem_base: a7 + mem_disp: 0x1 + access: CS_AC_READ + - asm_text: "lh s2, 4(s3)" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: s2 + access: CS_AC_WRITE + - type: RISCV_OP_MEM + mem_base: s3 + mem_disp: 0x4 + access: CS_AC_READ + - asm_text: "lw s4, 6(s5)" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: s4 + access: CS_AC_WRITE + - type: RISCV_OP_MEM + mem_base: s5 + mem_disp: 0x6 + access: CS_AC_READ + - asm_text: "lbu s6, 0x12(s7)" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: s6 + access: CS_AC_WRITE + - type: RISCV_OP_MEM + mem_base: s7 + mem_disp: 0x12 + access: CS_AC_READ + - asm_text: "lhu s8, 0x18(s9)" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: s8 + access: CS_AC_WRITE + - type: RISCV_OP_MEM + mem_base: s9 + mem_disp: 0x18 + access: CS_AC_READ + - asm_text: "sb s10, 0x2c(s11)" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: s10 + access: CS_AC_READ + - type: RISCV_OP_MEM + mem_base: s11 + mem_disp: 0x2c + access: CS_AC_WRITE + - asm_text: "sh t3, 0x34(t4)" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: t3 + access: CS_AC_READ + - type: RISCV_OP_MEM + mem_base: t4 + mem_disp: 0x34 + access: CS_AC_WRITE + - asm_text: "sb t5, 0x1e(t6)" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: t5 + access: CS_AC_READ + - type: RISCV_OP_MEM + mem_base: t6 + mem_disp: 0x1e + access: CS_AC_WRITE + - asm_text: "addi ra, zero, 0xe" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: ra + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: zero + access: CS_AC_READ + - type: RISCV_OP_IMM + imm: 0xe + access: CS_AC_READ + - asm_text: "slti sp, gp, 0x10" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: sp + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: gp + access: CS_AC_READ + - type: RISCV_OP_IMM + imm: 0x10 + access: CS_AC_READ + - asm_text: "sltiu tp, t0, 0x7d0" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: tp + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: t0 + access: CS_AC_READ + - type: RISCV_OP_IMM + imm: 0x7d0 + access: CS_AC_READ + - asm_text: "xori t1, t2, -0x230" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: t1 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: t2 + access: CS_AC_READ + - type: RISCV_OP_IMM + imm: -0x230 + access: CS_AC_READ + - asm_text: "ori s0, s1, 0x12c" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: s0 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: s1 + access: CS_AC_READ + - type: RISCV_OP_IMM + imm: 0x12c + access: CS_AC_READ + - asm_text: "andi a0, a1, 0xc8" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a0 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: a1 + access: CS_AC_READ + - type: RISCV_OP_IMM + imm: 0xc8 + access: CS_AC_READ + - asm_text: "slli a2, a3, 0x1e" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a2 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: a3 + access: CS_AC_READ + - type: RISCV_OP_IMM + imm: 0x1e + access: CS_AC_READ + - asm_text: "srli a4, a5, 0x19" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a4 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: a5 + access: CS_AC_READ + - type: RISCV_OP_IMM + imm: 0x19 + access: CS_AC_READ + - asm_text: "srai a6, a7, 0xf" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a6 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: a7 + access: CS_AC_READ + - type: RISCV_OP_IMM + imm: 0xf + access: CS_AC_READ + - asm_text: "add s2, s3, s4" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: s2 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: s3 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: s4 + access: CS_AC_READ + - asm_text: "sub s5, s6, s7" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: s5 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: s6 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: s7 + access: CS_AC_READ + - asm_text: "slt s8, s9, s10" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: s8 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: s9 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: s10 + access: CS_AC_READ + - asm_text: "sltu s11, t3, t4" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: s11 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: t3 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: t4 + access: CS_AC_READ + - asm_text: "sra tp, t0, t1" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: tp + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: t0 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: t1 + access: CS_AC_READ + - asm_text: "xor t2, s0, s1" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: t2 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: s0 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: s1 + access: CS_AC_READ + - asm_text: "or a0, a1, a2" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a0 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: a1 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: a2 + access: CS_AC_READ + - asm_text: "and a3, a4, a5" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a3 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: a4 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: a5 + access: CS_AC_READ + - asm_text: "srl s1, s2, s3" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: s1 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: s2 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: s3 + access: CS_AC_READ + - asm_text: "srl ra, sp, gp" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: ra + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: sp + access: CS_AC_READ + - type: RISCV_OP_REG + reg: gp + access: CS_AC_READ + - asm_text: "sll t5, t6, zero" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: t5 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: t6 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: zero + access: CS_AC_READ + - asm_text: "csrrw a0, mcycle, s0" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a0 + access: CS_AC_WRITE + - type: RISCV_OP_CSR + csr: mcycle + access: CS_AC_READ_WRITE + - type: RISCV_OP_REG + reg: s0 + access: CS_AC_READ + - asm_text: "csrrwi a3, sstatus, 0" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a3 + access: CS_AC_WRITE + - type: RISCV_OP_CSR + csr: sstatus + access: CS_AC_READ_WRITE + - type: RISCV_OP_IMM + imm: 0x0 + access: CS_AC_READ + - asm_text: "mul a0, s6, s7" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a0 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: s6 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: s7 + access: CS_AC_READ + groups: [HasStdExtMOrZmmul] + - asm_text: "div a1, s8, s9" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a1 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: s8 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: s9 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtM] + - asm_text: "rem a2, s10, s11" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a2 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: s10 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: s11 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtM] + - asm_text: "lr.w s0, (t0)" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: s0 + access: CS_AC_WRITE + - type: RISCV_OP_MEM + mem_base: t0 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtA] + - asm_text: "sc.w t2, t1, (a0)" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: t2 + access: CS_AC_WRITE + - type: RISCV_OP_MEM + mem_base: a0 + access: CS_AC_READ_WRITE + - type: RISCV_OP_REG + reg: t1 + access: CS_AC_READ + + groups: [RISCV_FEATURE_HasStdExtA] + - asm_text: "amoadd.w a4, s2, (t5)" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a4 + access: CS_AC_WRITE + - type: RISCV_OP_MEM + mem_base: t5 + access: CS_AC_READ_WRITE + - type: RISCV_OP_REG + reg: s2 + access: CS_AC_READ + + groups: [RISCV_FEATURE_HasStdExtA] + - asm_text: "fmadd.s ft0, ft1, ft2, ft3, dyn" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: ft0 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: ft1 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: ft2 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: ft3 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtF] + - asm_text: "fadd.s ft5, ft6, ft7, dyn" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: ft5 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: ft6 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: ft7 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtF] + - asm_text: "fsqrt.s fs0, fs1, dyn" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: fs0 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: fs1 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtF] + - asm_text: "fmin.s fa0, fa1, fa2" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: fa0 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: fa1 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: fa2 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtF] + - asm_text: "feq.s t3, ft8, ft9" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: t3 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: ft8 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: ft9 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtF] + - asm_text: "fmv.w.x fs1, a1" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: fs1 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: a1 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtF] + - asm_text: "fmv.x.w a2, fa0" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a2 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: fa0 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtF] + - asm_text: "fcvt.w.s a0, ft0, dyn" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a0 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: ft0 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtF] + - asm_text: "fcvt.s.w ft1, a1, dyn" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: ft1 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: a1 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtF] + - asm_text: "fclass.s a1, fa6" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a1 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: fa6 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtF] + - asm_text: "flw fs5, 7(a1)" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: fs5 + access: CS_AC_WRITE + - type: RISCV_OP_MEM + mem_base: a1 + mem_disp: 0x7 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtF] + - asm_text: "fsw fs6, 0xe(a2)" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: fs6 + access: CS_AC_READ + - type: RISCV_OP_MEM + mem_base: a2 + mem_disp: 0xe + access: CS_AC_WRITE + groups: [RISCV_FEATURE_HasStdExtF] + - asm_text: "fmadd.d ft0, ft1, ft2, ft3, dyn" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: ft0 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: ft1 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: ft2 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: ft3 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtD] + - asm_text: "fadd.d ft5, ft6, ft7, dyn" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: ft5 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: ft6 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: ft7 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtD] + - asm_text: "fsqrt.d fs0, fs1, dyn" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: fs0 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: fs1 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtD] + - asm_text: "fmin.d fa0, fa1, fa2" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: fa0 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: fa1 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: fa2 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtD] + - asm_text: "feq.d t3, ft8, ft9" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: t3 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: ft8 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: ft9 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtD] + - input: + bytes: + [ + 0x13, + 0x04, + 0xa8, + 0x7a, + 0xbb, + 0x07, + 0x9c, + 0x02, + 0xbb, + 0x40, + 0x5d, + 0x02, + 0x3b, + 0x63, + 0xb7, + 0x03, + 0x2f, + 0xb4, + 0x02, + 0x10, + 0xaf, + 0x33, + 0x65, + 0x18, + 0x2f, + 0x37, + 0x2f, + 0x01, + 0x53, + 0x75, + 0x20, + 0xc0, + 0xd3, + 0xf0, + 0x25, + 0xd0, + 0xd3, + 0x84, + 0x05, + 0xf2, + 0x53, + 0x06, + 0x05, + 0xe2, + 0x53, + 0x75, + 0x00, + 0xc2, + 0xd3, + 0x80, + 0x05, + 0xd2, + 0xd3, + 0x15, + 0x08, + 0xe2, + 0x87, + 0xba, + 0x75, + 0x00, + 0x27, + 0x37, + 0x66, + 0x01, + ] + arch: "CS_ARCH_RISCV" + options: + [CS_OPT_DETAIL, CS_MODE_RISCV64, CS_MODE_RISCV_A, CS_MODE_RISCV_D] address: 0x1000 expected: insns: - - - asm_text: "addi s0, a6, 0x7aa" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: s0 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: a6 - access: CS_AC_READ - - - type: RISCV_OP_IMM - imm: 0x7aa - access: CS_AC_READ - - - asm_text: "mulw a5, s8, s1" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a5 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: s8 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: s1 - access: CS_AC_READ - groups: [ RISCV_GRP_HASSTDEXTM, RISCV_GRP_ISRV64 ] - - - asm_text: "divw ra, s10, t0" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: ra - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: s10 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: t0 - access: CS_AC_READ - groups: [ RISCV_GRP_HASSTDEXTM, RISCV_GRP_ISRV64 ] - - - asm_text: "remw t1, a4, s11" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: t1 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: a4 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: s11 - access: CS_AC_READ - groups: [ RISCV_GRP_HASSTDEXTM, RISCV_GRP_ISRV64 ] - - - asm_text: "lr.d s0, (t0)" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: s0 - access: CS_AC_WRITE - - - type: RISCV_OP_MEM - mem_base: t0 - access: CS_AC_READ - groups: [ RISCV_GRP_HASSTDEXTA, RISCV_GRP_ISRV64 ] - - - asm_text: "sc.d t2, t1, (a0)" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: t2 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: t1 - access: CS_AC_READ - - - type: RISCV_OP_MEM - mem_base: a0 - access: CS_AC_WRITE - groups: [ RISCV_GRP_HASSTDEXTA, RISCV_GRP_ISRV64 ] - - - asm_text: "amoadd.d a4, s2, (t5)" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a4 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: s2 - access: CS_AC_READ - - - type: RISCV_OP_MEM - mem_base: t5 - access: CS_AC_READ_WRITE - groups: [ RISCV_GRP_HASSTDEXTA, RISCV_GRP_ISRV64 ] - - - asm_text: "fcvt.l.s a0, ft0" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a0 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: ft0 - access: CS_AC_READ - groups: [ RISCV_GRP_HASSTDEXTF, RISCV_GRP_ISRV64 ] - - - asm_text: "fcvt.s.l ft1, a1" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: ft1 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: a1 - access: CS_AC_READ - groups: [ RISCV_GRP_HASSTDEXTF, RISCV_GRP_ISRV64 ] - - - asm_text: "fmv.d.x fs1, a1" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: fs1 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: a1 - access: CS_AC_READ - groups: [ RISCV_GRP_HASSTDEXTD, RISCV_GRP_ISRV64 ] - - - asm_text: "fmv.x.d a2, fa0" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a2 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: fa0 - access: CS_AC_READ - groups: [ RISCV_GRP_HASSTDEXTD, RISCV_GRP_ISRV64 ] - - - asm_text: "fcvt.w.d a0, ft0" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a0 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: ft0 - access: CS_AC_READ - groups: [ RISCV_GRP_HASSTDEXTD ] - - - asm_text: "fcvt.d.w ft1, a1" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: ft1 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: a1 - access: CS_AC_READ - groups: [ RISCV_GRP_HASSTDEXTD ] - - - asm_text: "fclass.d a1, fa6" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a1 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: fa6 - access: CS_AC_READ - groups: [ RISCV_GRP_HASSTDEXTD ] - - - asm_text: "fld fs5, 7(a1)" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: fs5 - access: CS_AC_WRITE - - - type: RISCV_OP_MEM - mem_base: a1 - mem_disp: 0x7 - access: CS_AC_READ - groups: [ RISCV_GRP_HASSTDEXTD ] - - - asm_text: "fsd fs6, 0xe(a2)" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: fs6 - access: CS_AC_READ - - - type: RISCV_OP_MEM - mem_base: a2 - mem_disp: 0xe - access: CS_AC_WRITE - groups: [ RISCV_GRP_HASSTDEXTD ] - - - input: - bytes: [ 0xe8, 0x1f, 0x7d, 0x61, 0x80, 0x25, 0x00, 0x46, 0x88, 0xa2, 0x04, 0xcb, 0x55, 0x13, 0xf2, 0x93, 0x5d, 0x45, 0x19, 0x80, 0x15, 0x68, 0x2a, 0xa4, 0x62, 0x24, 0xa6, 0xff, 0x2a, 0x65, 0x76, 0x86, 0x65, 0xdd, 0x01, 0x00, 0xfd, 0xaf, 0x82, 0x82, 0x11, 0x20, 0x82, 0x94 ] - arch: "riscv" - options: [ CS_OPT_DETAIL, CS_MODE_RISCVC ] + - asm_text: "addi s0, a6, 0x7aa" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: s0 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: a6 + access: CS_AC_READ + - type: RISCV_OP_IMM + imm: 0x7aa + access: CS_AC_READ + - asm_text: "mulw a5, s8, s1" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a5 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: s8 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: s1 + access: CS_AC_READ + groups: [HasStdExtMOrZmmul, RISCV_FEATURE_IsRV64] + - asm_text: "divw ra, s10, t0" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: ra + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: s10 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: t0 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtM, RISCV_FEATURE_IsRV64] + - asm_text: "remw t1, a4, s11" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: t1 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: a4 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: s11 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtM, RISCV_FEATURE_IsRV64] + - asm_text: "lr.d s0, (t0)" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: s0 + access: CS_AC_WRITE + - type: RISCV_OP_MEM + mem_base: t0 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtA, RISCV_FEATURE_IsRV64] + - asm_text: "sc.d t2, t1, (a0)" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: t2 + access: CS_AC_WRITE + - type: RISCV_OP_MEM + mem_base: a0 + access: CS_AC_READ_WRITE + - type: RISCV_OP_REG + reg: t1 + access: CS_AC_READ + + groups: [RISCV_FEATURE_HasStdExtA, RISCV_FEATURE_IsRV64] + - asm_text: "amoadd.d a4, s2, (t5)" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a4 + access: CS_AC_WRITE + - type: RISCV_OP_MEM + mem_base: t5 + access: CS_AC_READ_WRITE + - type: RISCV_OP_REG + reg: s2 + access: CS_AC_READ + + groups: [RISCV_FEATURE_HasStdExtA, RISCV_FEATURE_IsRV64] + - asm_text: "fcvt.l.s a0, ft0" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a0 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: ft0 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtF, RISCV_FEATURE_IsRV64] + - asm_text: "fcvt.s.l ft1, a1" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: ft1 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: a1 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtF, RISCV_FEATURE_IsRV64] + - asm_text: "fmv.d.x fs1, a1" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: fs1 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: a1 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtD, RISCV_FEATURE_IsRV64] + - asm_text: "fmv.x.d a2, fa0" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a2 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: fa0 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtD, RISCV_FEATURE_IsRV64] + - asm_text: "fcvt.w.d a0, ft0" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a0 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: ft0 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtD] + - asm_text: "fcvt.d.w ft1, a1" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: ft1 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: a1 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtD] + - asm_text: "fclass.d a1, fa6" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a1 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: fa6 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtD] + - asm_text: "fld fs5, 7(a1)" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: fs5 + access: CS_AC_WRITE + - type: RISCV_OP_MEM + mem_base: a1 + mem_disp: 0x7 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtD] + - asm_text: "fsd fs6, 0xe(a2)" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: fs6 + access: CS_AC_READ + - type: RISCV_OP_MEM + mem_base: a2 + mem_disp: 0xe + access: CS_AC_WRITE + groups: [RISCV_FEATURE_HasStdExtD] + - input: + bytes: + [ + 0xe8, + 0x1f, + 0x7d, + 0x61, + 0x80, + 0x25, + 0x00, + 0x46, + 0x88, + 0xa2, + 0x04, + 0xcb, + 0x55, + 0x13, + 0xf2, + 0x93, + 0x5d, + 0x45, + 0x19, + 0x80, + 0x15, + 0x68, + 0x2a, + 0xa4, + 0x62, + 0x24, + 0xa6, + 0xff, + 0x2a, + 0x65, + 0x76, + 0x86, + 0x65, + 0xdd, + 0x01, + 0x00, + 0xfd, + 0xaf, + 0x82, + 0x82, + 0x11, + 0x20, + 0x82, + 0x94, + ] + arch: "CS_ARCH_RISCV" + options: [CS_OPT_DETAIL, CS_MODE_RISCVC, CS_OPT_SYNTAX_NO_ALIAS_TEXT] address: 0x1000 expected: insns: - - - asm_text: "c.addi4spn a0, sp, 0x3fc" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a0 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: sp - access: CS_AC_READ - - - type: RISCV_OP_IMM - imm: 0x3fc - access: CS_AC_READ - groups: [ RISCV_GRP_HASSTDEXTC ] - - - asm_text: "c.addi16sp sp, 0x1f0" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: sp - access: CS_AC_READ_WRITE - - - type: RISCV_OP_IMM - imm: 0x1f0 - access: CS_AC_READ - groups: [ RISCV_GRP_HASSTDEXTC ] - - - asm_text: "c.fld fs0, 8(a1)" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: fs0 - access: CS_AC_WRITE - - - type: RISCV_OP_MEM - mem_base: a1 - mem_disp: 0x8 - access: CS_AC_READ - groups: [ RISCV_GRP_HASSTDEXTC, RISCV_GRP_HASSTDEXTD ] - - - asm_text: "c.lw s0, 8(a2)" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: s0 - access: CS_AC_WRITE - - - type: RISCV_OP_MEM - mem_base: a2 - mem_disp: 0x8 - access: CS_AC_READ - groups: [ RISCV_GRP_HASSTDEXTC ] - - - asm_text: "c.fsd fa0, 0(a3)" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: fa0 - access: CS_AC_READ - - - type: RISCV_OP_MEM - mem_base: a3 - access: CS_AC_WRITE - groups: [ RISCV_GRP_HASSTDEXTC, RISCV_GRP_HASSTDEXTD ] - - - asm_text: "c.sw s1, 0x10(a4)" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: s1 - access: CS_AC_READ - - - type: RISCV_OP_MEM - mem_base: a4 - mem_disp: 0x10 - access: CS_AC_WRITE - groups: [ RISCV_GRP_HASSTDEXTC ] - - - asm_text: "c.addi t1, -0xb" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: t1 - access: CS_AC_READ_WRITE - - - type: RISCV_OP_IMM - imm: -0xb - access: CS_AC_READ - groups: [ RISCV_GRP_HASSTDEXTC ] - - - asm_text: "c.add t2, t3" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: t2 - access: CS_AC_READ_WRITE - - - type: RISCV_OP_REG - reg: t3 - access: CS_AC_READ - groups: [ RISCV_GRP_HASSTDEXTC ] - - - asm_text: "c.li a0, 0x17" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a0 - access: CS_AC_WRITE - - - type: RISCV_OP_IMM - imm: 0x17 - access: CS_AC_READ - groups: [ RISCV_GRP_HASSTDEXTC ] - - - asm_text: "c.srli s0, 6" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: s0 - access: CS_AC_READ_WRITE - - - type: RISCV_OP_IMM - imm: 0x6 - access: CS_AC_READ - groups: [ RISCV_GRP_HASSTDEXTC ] - - - asm_text: "c.lui a6, 5" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a6 - access: CS_AC_WRITE - - - type: RISCV_OP_IMM - imm: 0x5 - access: CS_AC_READ - groups: [ RISCV_GRP_HASSTDEXTC ] - - - asm_text: "c.fsdsp fa0, 8(sp)" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: fa0 - access: CS_AC_READ - - - type: RISCV_OP_MEM - mem_base: sp - mem_disp: 0x8 - access: CS_AC_WRITE - groups: [ RISCV_GRP_HASSTDEXTC, RISCV_GRP_HASSTDEXTD ] - - - asm_text: "c.fldsp fs0, 0x18(sp)" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: fs0 - access: CS_AC_WRITE - - - type: RISCV_OP_MEM - mem_base: sp - mem_disp: 0x18 - access: CS_AC_READ - groups: [ RISCV_GRP_HASSTDEXTC, RISCV_GRP_HASSTDEXTD ] - - - asm_text: "c.fswsp fs1, 0xfc(sp)" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: fs1 - access: CS_AC_READ - - - type: RISCV_OP_IMM - imm: 0xfc - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: sp - access: CS_AC_WRITE - groups: [ RISCV_GRP_HASSTDEXTC, RISCV_GRP_HASSTDEXTF, RISCV_GRP_ISRV32 ] - - - asm_text: "c.flwsp fa0, 0x88(sp)" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: fa0 - access: CS_AC_WRITE - - - type: RISCV_OP_IMM - imm: 0x88 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: sp - access: CS_AC_READ - groups: [ RISCV_GRP_HASSTDEXTC, RISCV_GRP_HASSTDEXTF, RISCV_GRP_ISRV32 ] - - - asm_text: "c.mv a2, t4" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a2 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: t4 - access: CS_AC_READ - groups: [ RISCV_GRP_HASSTDEXTC ] - - - asm_text: "c.beqz a0, -8" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a0 - access: CS_AC_READ - - - type: RISCV_OP_IMM - imm: -8 - access: CS_AC_READ - groups: [ RISCV_GRP_HASSTDEXTC, RISCV_GRP_BRANCH_RELATIVE, RISCV_GRP_JUMP ] - - - asm_text: "c.nop" - details: - groups: [ RISCV_GRP_HASSTDEXTC ] - - - asm_text: "c.j 0x7fe" - details: - riscv: - operands: - - - type: RISCV_OP_IMM - imm: 0x7fe - access: CS_AC_READ - groups: [ RISCV_GRP_HASSTDEXTC, RISCV_GRP_JUMP ] - - - asm_text: "c.jr t0" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: t0 - access: CS_AC_READ - groups: [ RISCV_GRP_HASSTDEXTC, RISCV_GRP_JUMP ] - - - asm_text: "c.jal 4" - details: - riscv: - operands: - - - type: RISCV_OP_IMM - imm: 0x4 - access: CS_AC_READ - groups: [ RISCV_GRP_HASSTDEXTC, RISCV_GRP_ISRV32, RISCV_GRP_CALL ] - - - asm_text: "c.jalr s1" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: s1 - access: CS_AC_READ - groups: [ RISCV_GRP_HASSTDEXTC, RISCV_GRP_CALL ] - - - input: - bytes: [ 0x37,0x34,0x00,0x00 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "lui s0, 3" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: s0 - access: CS_AC_WRITE - - - type: RISCV_OP_IMM - imm: 0x3 - access: CS_AC_READ - - - input: - bytes: [ 0x97,0x82,0x00,0x00 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "auipc t0, 8" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: t0 - access: CS_AC_WRITE - - - type: RISCV_OP_IMM - imm: 0x8 - access: CS_AC_READ - - - input: - bytes: [ 0xef,0x00,0x80,0x00 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "jal 8" - details: - riscv: - operands: - - - type: RISCV_OP_IMM - imm: 0x8 - access: CS_AC_READ - groups: [ call ] - - - input: - bytes: [ 0xef,0xf0,0x1f,0xff ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "jal -0x10" - details: - riscv: - operands: - - - type: RISCV_OP_IMM - imm: -0x10 - access: CS_AC_READ - groups: [ call ] - - - input: - bytes: [ 0xe7,0x00,0x45,0x00 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "jalr ra, a0, 4" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: ra - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: a0 - access: CS_AC_READ - - - type: RISCV_OP_IMM - imm: 0x4 - access: CS_AC_READ - groups: [ call ] - - - input: - bytes: [ 0xe7,0x00,0xc0,0xff ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "jalr ra, zero, -4" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: ra - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: zero - access: CS_AC_READ - - - type: RISCV_OP_IMM - imm: -4 - access: CS_AC_READ - groups: [ call ] - - - input: - bytes: [ 0x63,0x05,0x41,0x00 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "beq sp, tp, 0xa" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: sp - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: tp - access: CS_AC_READ - - - type: RISCV_OP_IMM - imm: 0xa - access: CS_AC_READ - groups: [ branch_relative, jump ] - - - input: - bytes: [ 0xe3,0x9d,0x61,0xfe ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "bne gp, t1, -6" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: gp - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: t1 - access: CS_AC_READ - - - type: RISCV_OP_IMM - imm: -6 - access: CS_AC_READ - groups: [ branch_relative, jump ] - - - input: - bytes: [ 0x63,0xca,0x93,0x00 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "blt t2, s1, 0x14" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: t2 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: s1 - access: CS_AC_READ - - - type: RISCV_OP_IMM - imm: 0x14 - access: CS_AC_READ - groups: [ branch_relative, jump ] - - - input: - bytes: [ 0x63,0x53,0xb5,0x00 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "bge a0, a1, 6" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a0 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: a1 - access: CS_AC_READ - - - type: RISCV_OP_IMM - imm: 0x6 - access: CS_AC_READ - groups: [ branch_relative, jump ] - - - input: - bytes: [ 0x63,0x65,0xd6,0x00 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "bltu a2, a3, 0xa" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a2 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: a3 - access: CS_AC_READ - - - type: RISCV_OP_IMM - imm: 0xa - access: CS_AC_READ - groups: [ branch_relative, jump ] - - - input: - bytes: [ 0x63,0x76,0xf7,0x00 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "bgeu a4, a5, 0xc" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a4 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: a5 - access: CS_AC_READ - - - type: RISCV_OP_IMM - imm: 0xc - access: CS_AC_READ - groups: [ branch_relative, jump ] - - - input: - bytes: [ 0x03,0x88,0x18,0x00 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "lb a6, 1(a7)" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a6 - access: CS_AC_WRITE - - - type: RISCV_OP_MEM - mem_base: a7 - mem_disp: 0x1 - access: CS_AC_READ - - - input: - bytes: [ 0x03,0x99,0x49,0x00 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "lh s2, 4(s3)" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: s2 - access: CS_AC_WRITE - - - type: RISCV_OP_MEM - mem_base: s3 - mem_disp: 0x4 - access: CS_AC_READ - - - input: - bytes: [ 0x03,0xaa,0x6a,0x00 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "lw s4, 6(s5)" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: s4 - access: CS_AC_WRITE - - - type: RISCV_OP_MEM - mem_base: s5 - mem_disp: 0x6 - access: CS_AC_READ - - - input: - bytes: [ 0x03,0xcb,0x2b,0x01 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "lbu s6, 0x12(s7)" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: s6 - access: CS_AC_WRITE - - - type: RISCV_OP_MEM - mem_base: s7 - mem_disp: 0x12 - access: CS_AC_READ - - - input: - bytes: [ 0x03,0xdc,0x8c,0x01 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "lhu s8, 0x18(s9)" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: s8 - access: CS_AC_WRITE - - - type: RISCV_OP_MEM - mem_base: s9 - mem_disp: 0x18 - access: CS_AC_READ - - - input: - bytes: [ 0x23,0x86,0xad,0x03 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "sb s10, 0x2c(s11)" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: s10 - access: CS_AC_READ - - - type: RISCV_OP_MEM - mem_base: s11 - mem_disp: 0x2c - access: CS_AC_WRITE - - - input: - bytes: [ 0x23,0x9a,0xce,0x03 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "sh t3, 0x34(t4)" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: t3 - access: CS_AC_READ - - - type: RISCV_OP_MEM - mem_base: t4 - mem_disp: 0x34 - access: CS_AC_WRITE - - - input: - bytes: [ 0x23,0x8f,0xef,0x01 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "sb t5, 0x1e(t6)" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: t5 - access: CS_AC_READ - - - type: RISCV_OP_MEM - mem_base: t6 - mem_disp: 0x1e - access: CS_AC_WRITE - - - input: - bytes: [ 0x93,0x00,0xe0,0x00 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "addi ra, zero, 0xe" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: ra - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: zero - access: CS_AC_READ - - - type: RISCV_OP_IMM - imm: 0xe - access: CS_AC_READ - - - input: - bytes: [ 0x13,0xa1,0x01,0x01 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "slti sp, gp, 0x10" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: sp - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: gp - access: CS_AC_READ - - - type: RISCV_OP_IMM - imm: 0x10 - access: CS_AC_READ - - - input: - bytes: [ 0x13,0xb2,0x02,0x7d ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "sltiu tp, t0, 0x7d0" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: tp - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: t0 - access: CS_AC_READ - - - type: RISCV_OP_IMM - imm: 0x7d0 - access: CS_AC_READ - - - input: - bytes: [ 0x13,0xc3,0x03,0xdd ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "xori t1, t2, -0x230" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: t1 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: t2 - access: CS_AC_READ - - - type: RISCV_OP_IMM - imm: -0x230 - access: CS_AC_READ - - - input: - bytes: [ 0x13,0xe4,0xc4,0x12 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "ori s0, s1, 0x12c" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: s0 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: s1 - access: CS_AC_READ - - - type: RISCV_OP_IMM - imm: 0x12c - access: CS_AC_READ - - - input: - bytes: [ 0x13,0xf5,0x85,0x0c ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "andi a0, a1, 0xc8" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a0 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: a1 - access: CS_AC_READ - - - type: RISCV_OP_IMM - imm: 0xc8 - access: CS_AC_READ - - - input: - bytes: [ 0x13,0x96,0xe6,0x01 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "slli a2, a3, 0x1e" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a2 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: a3 - access: CS_AC_READ - - - type: RISCV_OP_IMM - imm: 0x1e - access: CS_AC_READ - - - input: - bytes: [ 0x13,0xd7,0x97,0x01 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "srli a4, a5, 0x19" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a4 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: a5 - access: CS_AC_READ - - - type: RISCV_OP_IMM - imm: 0x19 - access: CS_AC_READ - - - input: - bytes: [ 0x13,0xd8,0xf8,0x40 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "srai a6, a7, 0xf" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a6 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: a7 - access: CS_AC_READ - - - type: RISCV_OP_IMM - imm: 0xf - access: CS_AC_READ - - - input: - bytes: [ 0x33,0x89,0x49,0x01 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "add s2, s3, s4" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: s2 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: s3 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: s4 - access: CS_AC_READ - - - input: - bytes: [ 0xb3,0x0a,0x7b,0x41 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "sub s5, s6, s7" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: s5 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: s6 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: s7 - access: CS_AC_READ - - - input: - bytes: [ 0x33,0xac,0xac,0x01 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "slt s8, s9, s10" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: s8 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: s9 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: s10 - access: CS_AC_READ - - - input: - bytes: [ 0xb3,0x3d,0xde,0x01 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "sltu s11, t3, t4" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: s11 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: t3 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: t4 - access: CS_AC_READ - - - input: - bytes: [ 0x33,0xd2,0x62,0x40 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "sra tp, t0, t1" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: tp - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: t0 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: t1 - access: CS_AC_READ - - - input: - bytes: [ 0xb3,0x43,0x94,0x00 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "xor t2, s0, s1" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: t2 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: s0 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: s1 - access: CS_AC_READ - - - input: - bytes: [ 0x33,0xe5,0xc5,0x00 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "or a0, a1, a2" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a0 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: a1 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: a2 - access: CS_AC_READ - - - input: - bytes: [ 0xb3,0x76,0xf7,0x00 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "and a3, a4, a5" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a3 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: a4 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: a5 - access: CS_AC_READ - - - input: - bytes: [ 0xb3,0x54,0x39,0x01 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "srl s1, s2, s3" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: s1 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: s2 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: s3 - access: CS_AC_READ - - - input: - bytes: [ 0xb3,0x50,0x31,0x00 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "srl ra, sp, gp" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: ra - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: sp - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: gp - access: CS_AC_READ - - - input: - bytes: [ 0x33,0x9f,0x0f,0x00 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "sll t5, t6, zero" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: t5 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: t6 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: zero - access: CS_AC_READ - - - input: - bytes: [ 0x73,0x15,0x04,0xb0 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "csrrw a0, mcycle, s0" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a0 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: s0 - access: CS_AC_READ - - - input: - bytes: [ 0xf3,0x56,0x00,0x10 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "csrrwi a3, sstatus, 0" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a3 - access: CS_AC_WRITE - - - type: RISCV_OP_IMM - imm: 0x0 - access: CS_AC_READ - - - input: - bytes: [ 0x33,0x05,0x7b,0x03 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "mul a0, s6, s7" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a0 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: s6 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: s7 - access: CS_AC_READ - groups: [ hasStdExtM ] - - - input: - bytes: [ 0xb3,0x45,0x9c,0x03 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "div a1, s8, s9" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a1 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: s8 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: s9 - access: CS_AC_READ - groups: [ hasStdExtM ] - - - input: - bytes: [ 0x33,0x66,0xbd,0x03 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "rem a2, s10, s11" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a2 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: s10 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: s11 - access: CS_AC_READ - groups: [ hasStdExtM ] - - - input: - bytes: [ 0x2f,0xa4,0x02,0x10 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "lr.w s0, (t0)" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: s0 - access: CS_AC_WRITE - - - type: RISCV_OP_MEM - mem_base: t0 - access: CS_AC_READ - groups: [ hasStdExtA ] - - - input: - bytes: [ 0xaf,0x23,0x65,0x18 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "sc.w t2, t1, (a0)" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: t2 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: t1 - access: CS_AC_READ - - - type: RISCV_OP_MEM - mem_base: a0 - access: CS_AC_WRITE - groups: [ hasStdExtA ] - - - input: - bytes: [ 0x2f,0x27,0x2f,0x01 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "amoadd.w a4, s2, (t5)" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a4 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: s2 - access: CS_AC_READ - - - type: RISCV_OP_MEM - mem_base: t5 - access: CS_AC_READ_WRITE - groups: [ hasStdExtA ] - - - input: - bytes: [ 0x43,0xf0,0x20,0x18 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "fmadd.s ft0, ft1, ft2, ft3" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: ft0 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: ft1 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: ft2 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: ft3 - access: CS_AC_READ - groups: [ hasStdExtF ] - - - input: - bytes: [ 0xd3,0x72,0x73,0x00 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "fadd.s ft5, ft6, ft7" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: ft5 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: ft6 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: ft7 - access: CS_AC_READ - groups: [ hasStdExtF ] - - - input: - bytes: [ 0x53,0xf4,0x04,0x58 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "fsqrt.s fs0, fs1" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: fs0 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: fs1 - access: CS_AC_READ - groups: [ hasStdExtF ] - - - input: - bytes: [ 0x53,0x85,0xc5,0x28 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "fmin.s fa0, fa1, fa2" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: fa0 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: fa1 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: fa2 - access: CS_AC_READ - groups: [ hasStdExtF ] - - - input: - bytes: [ 0x53,0x2e,0xde,0xa1 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "feq.s t3, ft8, ft9" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: t3 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: ft8 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: ft9 - access: CS_AC_READ - groups: [ hasStdExtF ] - - - input: - bytes: [ 0xd3,0x84,0x05,0xf0 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "fmv.w.x fs1, a1" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: fs1 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: a1 - access: CS_AC_READ - groups: [ hasStdExtF ] - - - input: - bytes: [ 0x53,0x06,0x05,0xe0 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "fmv.x.w a2, fa0" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a2 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: fa0 - access: CS_AC_READ - groups: [ hasStdExtF ] - - - input: - bytes: [ 0x53,0x75,0x00,0xc0 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "fcvt.w.s a0, ft0" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a0 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: ft0 - access: CS_AC_READ - groups: [ hasStdExtF ] - - - input: - bytes: [ 0xd3,0xf0,0x05,0xd0 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "fcvt.s.w ft1, a1" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: ft1 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: a1 - access: CS_AC_READ - groups: [ hasStdExtF ] - - - input: - bytes: [ 0xd3,0x15,0x08,0xe0 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "fclass.s a1, fa6" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a1 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: fa6 - access: CS_AC_READ - groups: [ hasStdExtF ] - - - input: - bytes: [ 0x87,0xaa,0x75,0x00 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "flw fs5, 7(a1)" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: fs5 - access: CS_AC_WRITE - - - type: RISCV_OP_MEM - mem_base: a1 - mem_disp: 0x7 - access: CS_AC_READ - groups: [ hasStdExtF ] - - - input: - bytes: [ 0x27,0x27,0x66,0x01 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "fsw fs6, 0xe(a2)" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: fs6 - access: CS_AC_READ - - - type: RISCV_OP_MEM - mem_base: a2 - mem_disp: 0xe - access: CS_AC_WRITE - groups: [ hasStdExtF ] - - - input: - bytes: [ 0x43,0xf0,0x20,0x1a ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "fmadd.d ft0, ft1, ft2, ft3" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: ft0 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: ft1 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: ft2 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: ft3 - access: CS_AC_READ - groups: [ hasStdExtD ] - - - input: - bytes: [ 0xd3,0x72,0x73,0x02 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "fadd.d ft5, ft6, ft7" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: ft5 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: ft6 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: ft7 - access: CS_AC_READ - groups: [ hasStdExtD ] - - - input: - bytes: [ 0x53,0xf4,0x04,0x5a ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "fsqrt.d fs0, fs1" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: fs0 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: fs1 - access: CS_AC_READ - groups: [ hasStdExtD ] - - - input: - bytes: [ 0x53,0x85,0xc5,0x2a ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "fmin.d fa0, fa1, fa2" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: fa0 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: fa1 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: fa2 - access: CS_AC_READ - groups: [ hasStdExtD ] - - - input: - bytes: [ 0x53,0x2e,0xde,0xa3 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "feq.d t3, ft8, ft9" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: t3 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: ft8 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: ft9 - access: CS_AC_READ - groups: [ hasStdExtD ] - - - input: - bytes: [ 0x13,0x04,0xa8,0x7a ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV64, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "addi s0, a6, 0x7aa" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: s0 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: a6 - access: CS_AC_READ - - - type: RISCV_OP_IMM - imm: 0x7aa - access: CS_AC_READ - - - input: - bytes: [ 0xbb,0x07,0x9c,0x02 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV64, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "mulw a5, s8, s1" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a5 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: s8 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: s1 - access: CS_AC_READ - groups: [ hasStdExtM, isrv64 ] - - - input: - bytes: [ 0xbb,0x40,0x5d,0x02 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV64, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "divw ra, s10, t0" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: ra - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: s10 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: t0 - access: CS_AC_READ - groups: [ hasStdExtM, isrv64 ] - - - input: - bytes: [ 0x3b,0x63,0xb7,0x03 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV64, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "remw t1, a4, s11" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: t1 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: a4 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: s11 - access: CS_AC_READ - groups: [ hasStdExtM, isrv64 ] - - - input: - bytes: [ 0x2f,0xb4,0x02,0x10 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV64, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "lr.d s0, (t0)" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: s0 - access: CS_AC_WRITE - - - type: RISCV_OP_MEM - mem_base: t0 - access: CS_AC_READ - groups: [ hasStdExtA, isrv64 ] - - - input: - bytes: [ 0xaf,0x33,0x65,0x18 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV64, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "sc.d t2, t1, (a0)" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: t2 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: t1 - access: CS_AC_READ - - - type: RISCV_OP_MEM - mem_base: a0 - access: CS_AC_WRITE - groups: [ hasStdExtA, isrv64 ] - - - input: - bytes: [ 0x2f,0x37,0x2f,0x01 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV64, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "amoadd.d a4, s2, (t5)" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a4 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: s2 - access: CS_AC_READ - - - type: RISCV_OP_MEM - mem_base: t5 - access: CS_AC_READ_WRITE - groups: [ hasStdExtA, isrv64 ] - - - input: - bytes: [ 0x53,0x75,0x20,0xc0 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV64, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "fcvt.l.s a0, ft0" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a0 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: ft0 - access: CS_AC_READ - groups: [ hasStdExtF, isrv64 ] - - - input: - bytes: [ 0xd3,0xf0,0x25,0xd0 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV64, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "fcvt.s.l ft1, a1" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: ft1 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: a1 - access: CS_AC_READ - groups: [ hasStdExtF, isrv64 ] - - - input: - bytes: [ 0xd3,0x84,0x05,0xf2 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV64, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "fmv.d.x fs1, a1" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: fs1 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: a1 - access: CS_AC_READ - groups: [ hasStdExtD, isrv64 ] - - - input: - bytes: [ 0x53,0x06,0x05,0xe2 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV64, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "fmv.x.d a2, fa0" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a2 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: fa0 - access: CS_AC_READ - groups: [ hasStdExtD, isrv64 ] - - - input: - bytes: [ 0x53,0x75,0x00,0xc2 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV64, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "fcvt.w.d a0, ft0" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a0 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: ft0 - access: CS_AC_READ - groups: [ hasStdExtD ] - - - input: - bytes: [ 0xd3,0x80,0x05,0xd2 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV64, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "fcvt.d.w ft1, a1" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: ft1 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: a1 - access: CS_AC_READ - groups: [ hasStdExtD ] - - - input: - bytes: [ 0xd3,0x15,0x08,0xe2 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV64, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "fclass.d a1, fa6" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a1 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: fa6 - access: CS_AC_READ - groups: [ hasStdExtD ] - - - input: - bytes: [ 0x87,0xba,0x75,0x00 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV64, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "fld fs5, 7(a1)" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: fs5 - access: CS_AC_WRITE - - - type: RISCV_OP_MEM - mem_base: a1 - mem_disp: 0x7 - access: CS_AC_READ - groups: [ hasStdExtD ] - - - input: - bytes: [ 0x27,0x37,0x66,0x01 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV64, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "fsd fs6, 0xe(a2)" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: fs6 - access: CS_AC_READ - - - type: RISCV_OP_MEM - mem_base: a2 - mem_disp: 0xe - access: CS_AC_WRITE - groups: [ hasStdExtD ] - - - input: - bytes: [ 0xe8,0x1f ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCVC, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "c.addi4spn a0, sp, 0x3fc" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a0 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: sp - access: CS_AC_READ - - - type: RISCV_OP_IMM - imm: 0x3fc - access: CS_AC_READ - groups: [ hasStdExtC ] - - - input: - bytes: [ 0x7d,0x61 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCVC, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "c.addi16sp sp, 0x1f0" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: sp - access: CS_AC_READ_WRITE - - - type: RISCV_OP_IMM - imm: 0x1f0 - access: CS_AC_READ - groups: [ hasStdExtC ] - - - input: - bytes: [ 0x80,0x25 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCVC, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "c.fld fs0, 8(a1)" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: fs0 - access: CS_AC_WRITE - - - type: RISCV_OP_MEM - mem_base: a1 - mem_disp: 0x8 - access: CS_AC_READ - groups: [ hasStdExtC, hasStdExtD ] - - - input: - bytes: [ 0x00,0x46 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCVC, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "c.lw s0, 8(a2)" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: s0 - access: CS_AC_WRITE - - - type: RISCV_OP_MEM - mem_base: a2 - mem_disp: 0x8 - access: CS_AC_READ - groups: [ hasStdExtC ] - - - input: - bytes: [ 0x88,0xa2 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCVC, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "c.fsd fa0, 0(a3)" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: fa0 - access: CS_AC_READ - - - type: RISCV_OP_MEM - mem_base: a3 - access: CS_AC_WRITE - groups: [ hasStdExtC, hasStdExtD ] - - - input: - bytes: [ 0x04,0xcb ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCVC, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "c.sw s1, 0x10(a4)" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: s1 - access: CS_AC_READ - - - type: RISCV_OP_MEM - mem_base: a4 - mem_disp: 0x10 - access: CS_AC_WRITE - groups: [ hasStdExtC ] - - - input: - bytes: [ 0x55,0x13 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCVC, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "c.addi t1, -0xb" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: t1 - access: CS_AC_READ_WRITE - - - type: RISCV_OP_IMM - imm: -0xb - access: CS_AC_READ - groups: [ hasStdExtC ] - - - input: - bytes: [ 0xf2,0x93 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCVC, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "c.add t2, t3" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: t2 - access: CS_AC_READ_WRITE - - - type: RISCV_OP_REG - reg: t3 - access: CS_AC_READ - groups: [ hasStdExtC ] - - - input: - bytes: [ 0x5d,0x45 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCVC, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "c.li a0, 0x17" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a0 - access: CS_AC_WRITE - - - type: RISCV_OP_IMM - imm: 0x17 - access: CS_AC_READ - groups: [ hasStdExtC ] - - - input: - bytes: [ 0x19,0x80 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCVC, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "c.srli s0, 6" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: s0 - access: CS_AC_READ_WRITE - - - type: RISCV_OP_IMM - imm: 0x6 - access: CS_AC_READ - groups: [ hasStdExtC ] - - - input: - bytes: [ 0x15,0x68 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCVC, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "c.lui a6, 5" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a6 - access: CS_AC_WRITE - - - type: RISCV_OP_IMM - imm: 0x5 - access: CS_AC_READ - groups: [ hasStdExtC ] - - - input: - bytes: [ 0x2a,0xa4 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCVC, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "c.fsdsp fa0, 8(sp)" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: fa0 - access: CS_AC_READ - - - type: RISCV_OP_MEM - mem_base: sp - mem_disp: 0x8 - access: CS_AC_WRITE - groups: [ hasStdExtC, hasStdExtD ] - - - input: - bytes: [ 0x62,0x24 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCVC, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "c.fldsp fs0, 0x18(sp)" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: fs0 - access: CS_AC_WRITE - - - type: RISCV_OP_MEM - mem_base: sp - mem_disp: 0x18 - access: CS_AC_READ - groups: [ hasStdExtC, hasStdExtD ] - - - input: - bytes: [ 0xa6,0xff ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCVC, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "c.fswsp fs1, 0xfc(sp)" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: fs1 - access: CS_AC_READ - - - type: RISCV_OP_IMM - imm: 0xfc - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: sp - access: CS_AC_WRITE - groups: [ hasStdExtC, hasStdExtF, isrv32 ] - - - input: - bytes: [ 0x2a,0x65 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCVC, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "c.flwsp fa0, 0x88(sp)" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: fa0 - access: CS_AC_WRITE - - - type: RISCV_OP_IMM - imm: 0x88 - access: CS_AC_READ - - - type: RISCV_OP_REG - reg: sp - access: CS_AC_READ - groups: [ hasStdExtC, hasStdExtF, isrv32 ] - - - input: - bytes: [ 0x76,0x86 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCVC, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "c.mv a2, t4" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a2 - access: CS_AC_WRITE - - - type: RISCV_OP_REG - reg: t4 - access: CS_AC_READ - groups: [ hasStdExtC ] - - - input: - bytes: [ 0x65,0xdd ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCVC, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "c.beqz a0, -8" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: a0 - access: CS_AC_READ - - - type: RISCV_OP_IMM - imm: -0x8 - access: CS_AC_READ - groups: [ hasStdExtC, branch_relative, jump ] - - - input: - bytes: [ 0x01,0x00 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCVC, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "c.nop" - details: - groups: [ hasStdExtC ] - - - input: - bytes: [ 0xfd,0xaf ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCVC, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "c.j 0x7fe" - details: - riscv: - operands: - - - type: RISCV_OP_IMM - imm: 0x7fe - access: CS_AC_READ - groups: [ hasStdExtC, jump ] - - - input: - bytes: [ 0x82,0x82 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCVC, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "c.jr t0" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: t0 - access: CS_AC_READ - groups: [ hasStdExtC, jump ] - - - input: - bytes: [ 0x11,0x20 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCVC, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "c.jal 4" - details: - riscv: - operands: - - - type: RISCV_OP_IMM - imm: 0x4 - access: CS_AC_READ - groups: [ hasStdExtC, isrv32, call ] - - - input: - bytes: [ 0x82,0x94 ] - arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCVC, CS_OPT_DETAIL ] - address: 0x0 - expected: - insns: - - - asm_text: "c.jalr s1" - details: - riscv: - operands: - - - type: RISCV_OP_REG - reg: s1 - access: CS_AC_READ - groups: [ hasStdExtC, call ] + - asm_text: "c.addi4spn a0, sp, 0x3fc" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a0 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: sp + access: CS_AC_READ + - type: RISCV_OP_IMM + imm: 0x3fc + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtCOrZca] + - asm_text: "c.addi16sp sp, 0x1f0" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: sp + access: CS_AC_READ_WRITE + - type: RISCV_OP_IMM + imm: 0x1f0 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtCOrZca] + - asm_text: "c.fld fs0, 8(a1)" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: fs0 + access: CS_AC_WRITE + - type: RISCV_OP_MEM + mem_base: a1 + mem_disp: 0x8 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtCOrZcd, RISCV_FEATURE_HasStdExtD] + - asm_text: "c.lw s0, 8(a2)" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: s0 + access: CS_AC_WRITE + - type: RISCV_OP_MEM + mem_base: a2 + mem_disp: 0x8 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtCOrZca] + - asm_text: "c.fsd fa0, 0(a3)" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: fa0 + access: CS_AC_READ + - type: RISCV_OP_MEM + mem_base: a3 + access: CS_AC_WRITE + groups: [RISCV_FEATURE_HasStdExtCOrZcd, RISCV_FEATURE_HasStdExtD] + - asm_text: "c.sw s1, 0x10(a4)" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: s1 + access: CS_AC_READ + - type: RISCV_OP_MEM + mem_base: a4 + mem_disp: 0x10 + access: CS_AC_WRITE + groups: [RISCV_FEATURE_HasStdExtCOrZca] + - asm_text: "c.addi t1, -0xb" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: t1 + access: CS_AC_READ_WRITE + - type: RISCV_OP_IMM + imm: -0xb + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtCOrZca] + - asm_text: "c.add t2, t3" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: t2 + access: CS_AC_READ_WRITE + - type: RISCV_OP_REG + reg: t3 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtCOrZca] + - asm_text: "c.li a0, 0x17" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a0 + access: CS_AC_WRITE + - type: RISCV_OP_IMM + imm: 0x17 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtCOrZca] + - asm_text: "c.srli s0, 6" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: s0 + access: CS_AC_READ_WRITE + - type: RISCV_OP_IMM + imm: 0x6 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtCOrZca] + - asm_text: "c.lui a6, 5" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a6 + access: CS_AC_WRITE + - type: RISCV_OP_IMM + imm: 0x5 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtCOrZca] + - asm_text: "c.fsdsp fa0, 8(sp)" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: fa0 + access: CS_AC_READ + - type: RISCV_OP_MEM + mem_base: sp + mem_disp: 0x8 + access: CS_AC_WRITE + groups: [RISCV_FEATURE_HasStdExtCOrZcd, RISCV_FEATURE_HasStdExtD] + - asm_text: "c.fldsp fs0, 0x18(sp)" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: fs0 + access: CS_AC_WRITE + - type: RISCV_OP_MEM + mem_base: sp + mem_disp: 0x18 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtCOrZcd, RISCV_FEATURE_HasStdExtD] + - asm_text: "c.fswsp fs1, 0xfc(sp)" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: fs1 + access: CS_AC_READ + - type: RISCV_OP_MEM + mem_base: sp + mem_disp: 0xfc + access: CS_AC_WRITE + groups: + [ + RISCV_FEATURE_HasStdExtCOrZcfOrZce, + RISCV_FEATURE_HasStdExtF, + RISCV_FEATURE_IsRV32, + ] + - asm_text: "c.flwsp fa0, 0x88(sp)" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: fa0 + access: CS_AC_WRITE + - type: RISCV_OP_MEM + mem_base: sp + mem_disp: 0x88 + access: CS_AC_READ + groups: + [ + RISCV_FEATURE_HasStdExtCOrZcfOrZce, + RISCV_FEATURE_HasStdExtF, + RISCV_FEATURE_IsRV32, + ] + - asm_text: "c.mv a2, t4" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a2 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: t4 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtCOrZca] + - asm_text: "c.beqz a0, 4120" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a0 + access: CS_AC_READ + - type: RISCV_OP_IMM + imm: -8 + access: CS_AC_READ + groups: + [ + RISCV_GRP_JUMP, + RISCV_GRP_BRANCH_RELATIVE, + RISCV_FEATURE_HasStdExtCOrZca, + ] + - asm_text: "c.nop" + details: + groups: [RISCV_FEATURE_HasStdExtCOrZca] + - asm_text: "c.j 6178" + details: + riscv: + operands: + - type: RISCV_OP_IMM + imm: 0x7fe + access: CS_AC_READ + groups: + [ + RISCV_GRP_JUMP, + RISCV_GRP_BRANCH_RELATIVE, + RISCV_FEATURE_HasStdExtCOrZca, + ] + - asm_text: "c.jr t0" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: t0 + access: CS_AC_READ + groups: [RISCV_GRP_JUMP, RISCV_FEATURE_HasStdExtCOrZca] + - asm_text: "c.jal 4140" + details: + riscv: + operands: + - type: RISCV_OP_IMM + imm: 0x4 + access: CS_AC_READ + groups: + [ + RISCV_GRP_CALL, + RISCV_GRP_BRANCH_RELATIVE, + RISCV_FEATURE_HasStdExtCOrZca, + RISCV_FEATURE_IsRV32, + ] + - asm_text: "c.jalr s1" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: s1 + access: CS_AC_READ + groups: [RISCV_GRP_CALL, RISCV_FEATURE_HasStdExtCOrZca] + - input: + bytes: [0x37, 0x34, 0x00, 0x00] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "lui s0, 3" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: s0 + access: CS_AC_WRITE + - type: RISCV_OP_IMM + imm: 0x3 + access: CS_AC_READ + - input: + bytes: [0x97, 0x82, 0x00, 0x00] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "auipc t0, 8" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: t0 + access: CS_AC_WRITE + - type: RISCV_OP_IMM + imm: 0x8 + access: CS_AC_READ + - input: + bytes: [0xef, 0x00, 0x80, 0x00] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "jal 8" + details: + riscv: + operands: + - type: RISCV_OP_IMM + imm: 0x8 + access: CS_AC_READ + groups: [RISCV_GRP_CALL, RISCV_GRP_BRANCH_RELATIVE] + - input: + bytes: [0xef, 0xf0, 0x1f, 0xff] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "jal -0x10" + details: + riscv: + operands: + - type: RISCV_OP_IMM + imm: -0x10 + access: CS_AC_READ + groups: [RISCV_GRP_CALL, RISCV_GRP_BRANCH_RELATIVE] + - input: + bytes: [0xe7, 0x00, 0x45, 0x00] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL, CS_OPT_SYNTAX_NO_ALIAS_TEXT] + address: 0x0 + expected: + insns: + - asm_text: "jalr ra, 4(a0)" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: ra + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: a0 + access: CS_AC_READ + - type: RISCV_OP_IMM + imm: 0x4 + access: CS_AC_READ + groups: [RISCV_GRP_CALL] + - input: + bytes: [0xe7, 0x00, 0xc0, 0xff] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL, CS_OPT_SYNTAX_NO_ALIAS_TEXT] + address: 0x0 + expected: + insns: + - asm_text: "jalr ra, -4(zero)" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: ra + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: zero + access: CS_AC_READ + - type: RISCV_OP_IMM + imm: -4 + access: CS_AC_READ + groups: [RISCV_GRP_CALL] + - input: + bytes: [0x63, 0x05, 0x41, 0x00] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "beq sp, tp, 0xa" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: sp + access: CS_AC_READ + - type: RISCV_OP_REG + reg: tp + access: CS_AC_READ + - type: RISCV_OP_IMM + imm: 0xa + access: CS_AC_READ + groups: [RISCV_GRP_JUMP, RISCV_GRP_BRANCH_RELATIVE] + - input: + bytes: [0xe3, 0x9d, 0x61, 0xfe] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "bne gp, t1, -6" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: gp + access: CS_AC_READ + - type: RISCV_OP_REG + reg: t1 + access: CS_AC_READ + - type: RISCV_OP_IMM + imm: -6 + access: CS_AC_READ + groups: [RISCV_GRP_JUMP, RISCV_GRP_BRANCH_RELATIVE] + - input: + bytes: [0x63, 0xca, 0x93, 0x00] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "blt t2, s1, 0x14" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: t2 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: s1 + access: CS_AC_READ + - type: RISCV_OP_IMM + imm: 0x14 + access: CS_AC_READ + groups: [RISCV_GRP_JUMP, RISCV_GRP_BRANCH_RELATIVE] + - input: + bytes: [0x63, 0x53, 0xb5, 0x00] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "bge a0, a1, 6" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a0 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: a1 + access: CS_AC_READ + - type: RISCV_OP_IMM + imm: 0x6 + access: CS_AC_READ + groups: [RISCV_GRP_JUMP, RISCV_GRP_BRANCH_RELATIVE] + - input: + bytes: [0x63, 0x65, 0xd6, 0x00] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "bltu a2, a3, 0xa" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a2 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: a3 + access: CS_AC_READ + - type: RISCV_OP_IMM + imm: 0xa + access: CS_AC_READ + groups: [RISCV_GRP_JUMP, RISCV_GRP_BRANCH_RELATIVE] + - input: + bytes: [0x63, 0x76, 0xf7, 0x00] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "bgeu a4, a5, 0xc" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a4 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: a5 + access: CS_AC_READ + - type: RISCV_OP_IMM + imm: 0xc + access: CS_AC_READ + groups: [RISCV_GRP_JUMP, RISCV_GRP_BRANCH_RELATIVE] + - input: + bytes: [0x03, 0x88, 0x18, 0x00] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "lb a6, 1(a7)" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a6 + access: CS_AC_WRITE + - type: RISCV_OP_MEM + mem_base: a7 + mem_disp: 0x1 + access: CS_AC_READ + - input: + bytes: [0x03, 0x99, 0x49, 0x00] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "lh s2, 4(s3)" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: s2 + access: CS_AC_WRITE + - type: RISCV_OP_MEM + mem_base: s3 + mem_disp: 0x4 + access: CS_AC_READ + - input: + bytes: [0x03, 0xaa, 0x6a, 0x00] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "lw s4, 6(s5)" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: s4 + access: CS_AC_WRITE + - type: RISCV_OP_MEM + mem_base: s5 + mem_disp: 0x6 + access: CS_AC_READ + - input: + bytes: [0x03, 0xcb, 0x2b, 0x01] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "lbu s6, 0x12(s7)" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: s6 + access: CS_AC_WRITE + - type: RISCV_OP_MEM + mem_base: s7 + mem_disp: 0x12 + access: CS_AC_READ + - input: + bytes: [0x03, 0xdc, 0x8c, 0x01] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "lhu s8, 0x18(s9)" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: s8 + access: CS_AC_WRITE + - type: RISCV_OP_MEM + mem_base: s9 + mem_disp: 0x18 + access: CS_AC_READ + - input: + bytes: [0x23, 0x86, 0xad, 0x03] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "sb s10, 0x2c(s11)" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: s10 + access: CS_AC_READ + - type: RISCV_OP_MEM + mem_base: s11 + mem_disp: 0x2c + access: CS_AC_WRITE + - input: + bytes: [0x23, 0x9a, 0xce, 0x03] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "sh t3, 0x34(t4)" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: t3 + access: CS_AC_READ + - type: RISCV_OP_MEM + mem_base: t4 + mem_disp: 0x34 + access: CS_AC_WRITE + - input: + bytes: [0x23, 0x8f, 0xef, 0x01] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "sb t5, 0x1e(t6)" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: t5 + access: CS_AC_READ + - type: RISCV_OP_MEM + mem_base: t6 + mem_disp: 0x1e + access: CS_AC_WRITE + - input: + bytes: [0x93, 0x00, 0xe0, 0x00] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL, CS_OPT_SYNTAX_NO_ALIAS_TEXT] + address: 0x0 + expected: + insns: + - asm_text: "addi ra, zero, 0xe" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: ra + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: zero + access: CS_AC_READ + - type: RISCV_OP_IMM + imm: 0xe + access: CS_AC_READ + - input: + bytes: [0x13, 0xa1, 0x01, 0x01] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "slti sp, gp, 0x10" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: sp + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: gp + access: CS_AC_READ + - type: RISCV_OP_IMM + imm: 0x10 + access: CS_AC_READ + - input: + bytes: [0x13, 0xb2, 0x02, 0x7d] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "sltiu tp, t0, 0x7d0" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: tp + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: t0 + access: CS_AC_READ + - type: RISCV_OP_IMM + imm: 0x7d0 + access: CS_AC_READ + - input: + bytes: [0x13, 0xc3, 0x03, 0xdd] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "xori t1, t2, -0x230" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: t1 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: t2 + access: CS_AC_READ + - type: RISCV_OP_IMM + imm: -0x230 + access: CS_AC_READ + - input: + bytes: [0x13, 0xe4, 0xc4, 0x12] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "ori s0, s1, 0x12c" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: s0 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: s1 + access: CS_AC_READ + - type: RISCV_OP_IMM + imm: 0x12c + access: CS_AC_READ + - input: + bytes: [0x13, 0xf5, 0x85, 0x0c] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "andi a0, a1, 0xc8" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a0 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: a1 + access: CS_AC_READ + - type: RISCV_OP_IMM + imm: 0xc8 + access: CS_AC_READ + - input: + bytes: [0x13, 0x96, 0xe6, 0x01] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "slli a2, a3, 0x1e" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a2 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: a3 + access: CS_AC_READ + - type: RISCV_OP_IMM + imm: 0x1e + access: CS_AC_READ + - input: + bytes: [0x13, 0xd7, 0x97, 0x01] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "srli a4, a5, 0x19" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a4 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: a5 + access: CS_AC_READ + - type: RISCV_OP_IMM + imm: 0x19 + access: CS_AC_READ + - input: + bytes: [0x13, 0xd8, 0xf8, 0x40] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "srai a6, a7, 0xf" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a6 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: a7 + access: CS_AC_READ + - type: RISCV_OP_IMM + imm: 0xf + access: CS_AC_READ + - input: + bytes: [0x33, 0x89, 0x49, 0x01] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "add s2, s3, s4" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: s2 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: s3 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: s4 + access: CS_AC_READ + - input: + bytes: [0xb3, 0x0a, 0x7b, 0x41] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "sub s5, s6, s7" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: s5 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: s6 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: s7 + access: CS_AC_READ + - input: + bytes: [0x33, 0xac, 0xac, 0x01] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "slt s8, s9, s10" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: s8 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: s9 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: s10 + access: CS_AC_READ + - input: + bytes: [0xb3, 0x3d, 0xde, 0x01] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "sltu s11, t3, t4" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: s11 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: t3 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: t4 + access: CS_AC_READ + - input: + bytes: [0x33, 0xd2, 0x62, 0x40] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "sra tp, t0, t1" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: tp + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: t0 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: t1 + access: CS_AC_READ + - input: + bytes: [0xb3, 0x43, 0x94, 0x00] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "xor t2, s0, s1" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: t2 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: s0 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: s1 + access: CS_AC_READ + - input: + bytes: [0x33, 0xe5, 0xc5, 0x00] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "or a0, a1, a2" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a0 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: a1 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: a2 + access: CS_AC_READ + - input: + bytes: [0xb3, 0x76, 0xf7, 0x00] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "and a3, a4, a5" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a3 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: a4 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: a5 + access: CS_AC_READ + - input: + bytes: [0xb3, 0x54, 0x39, 0x01] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "srl s1, s2, s3" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: s1 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: s2 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: s3 + access: CS_AC_READ + - input: + bytes: [0xb3, 0x50, 0x31, 0x00] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "srl ra, sp, gp" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: ra + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: sp + access: CS_AC_READ + - type: RISCV_OP_REG + reg: gp + access: CS_AC_READ + - input: + bytes: [0x33, 0x9f, 0x0f, 0x00] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "sll t5, t6, zero" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: t5 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: t6 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: zero + access: CS_AC_READ + - input: + bytes: [0x73, 0x15, 0x04, 0xb0] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "csrrw a0, mcycle, s0" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a0 + access: CS_AC_WRITE + - type: RISCV_OP_CSR + csr: mcycle + access: CS_AC_READ_WRITE + - type: RISCV_OP_REG + reg: s0 + access: CS_AC_READ + - input: + bytes: [0xf3, 0x56, 0x00, 0x10] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "csrrwi a3, sstatus, 0" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a3 + access: CS_AC_WRITE + - type: RISCV_OP_CSR + csr: sstatus + access: CS_AC_READ_WRITE + - type: RISCV_OP_IMM + imm: 0x0 + access: CS_AC_READ + - input: + bytes: [0x33, 0x05, 0x7b, 0x03] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "mul a0, s6, s7" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a0 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: s6 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: s7 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtMOrZmmul] + - input: + bytes: [0xb3, 0x45, 0x9c, 0x03] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "div a1, s8, s9" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a1 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: s8 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: s9 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtM] + - input: + bytes: [0x33, 0x66, 0xbd, 0x03] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "rem a2, s10, s11" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a2 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: s10 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: s11 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtM] + - input: + bytes: [0x2f, 0xa4, 0x02, 0x10] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL, "CS_MODE_RISCV_A"] + address: 0x0 + expected: + insns: + - asm_text: "lr.w s0, (t0)" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: s0 + access: CS_AC_WRITE + - type: RISCV_OP_MEM + mem_base: t0 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtA] + - input: + bytes: [0xaf, 0x23, 0x65, 0x18] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL, CS_MODE_RISCV_A] + address: 0x0 + expected: + insns: + - asm_text: "sc.w t2, t1, (a0)" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: t2 + access: CS_AC_WRITE + - type: RISCV_OP_MEM + mem_base: a0 + access: CS_AC_READ_WRITE + - type: RISCV_OP_REG + reg: t1 + access: CS_AC_READ + + groups: [RISCV_FEATURE_HasStdExtA] + - input: + bytes: [0x2f, 0x27, 0x2f, 0x01] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL, CS_MODE_RISCV_A] + address: 0x0 + expected: + insns: + - asm_text: "amoadd.w a4, s2, (t5)" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a4 + access: CS_AC_WRITE + - type: RISCV_OP_MEM + mem_base: t5 + access: CS_AC_READ_WRITE + - type: RISCV_OP_REG + reg: s2 + access: CS_AC_READ + + groups: [RISCV_FEATURE_HasStdExtA] + - input: + bytes: [0x43, 0xf0, 0x20, 0x18] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "fmadd.s ft0, ft1, ft2, ft3" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: ft0 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: ft1 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: ft2 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: ft3 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtF] + - input: + bytes: [0xd3, 0x72, 0x73, 0x00] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "fadd.s ft5, ft6, ft7" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: ft5 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: ft6 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: ft7 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtF] + - input: + bytes: [0x53, 0xf4, 0x04, 0x58] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "fsqrt.s fs0, fs1" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: fs0 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: fs1 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtF] + - input: + bytes: [0x53, 0x85, 0xc5, 0x28] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "fmin.s fa0, fa1, fa2" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: fa0 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: fa1 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: fa2 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtF] + - input: + bytes: [0x53, 0x2e, 0xde, 0xa1] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "feq.s t3, ft8, ft9" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: t3 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: ft8 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: ft9 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtF] + - input: + bytes: [0xd3, 0x84, 0x05, 0xf0] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "fmv.w.x fs1, a1" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: fs1 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: a1 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtF] + - input: + bytes: [0x53, 0x06, 0x05, 0xe0] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "fmv.x.w a2, fa0" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a2 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: fa0 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtF] + - input: + bytes: [0x53, 0x75, 0x00, 0xc0] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "fcvt.w.s a0, ft0" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a0 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: ft0 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtF] + - input: + bytes: [0xd3, 0xf0, 0x05, 0xd0] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "fcvt.s.w ft1, a1" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: ft1 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: a1 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtF] + - input: + bytes: [0xd3, 0x15, 0x08, 0xe0] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "fclass.s a1, fa6" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a1 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: fa6 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtF] + - input: + bytes: [0x87, 0xaa, 0x75, 0x00] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "flw fs5, 7(a1)" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: fs5 + access: CS_AC_WRITE + - type: RISCV_OP_MEM + mem_base: a1 + mem_disp: 0x7 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtF] + - input: + bytes: [0x27, 0x27, 0x66, 0x01] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "fsw fs6, 0xe(a2)" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: fs6 + access: CS_AC_READ + - type: RISCV_OP_MEM + mem_base: a2 + mem_disp: 0xe + access: CS_AC_WRITE + groups: [RISCV_FEATURE_HasStdExtF] + - input: + bytes: [0x43, 0xf0, 0x20, 0x1a] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "fmadd.d ft0, ft1, ft2, ft3" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: ft0 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: ft1 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: ft2 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: ft3 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtD] + - input: + bytes: [0xd3, 0x72, 0x73, 0x02] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "fadd.d ft5, ft6, ft7" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: ft5 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: ft6 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: ft7 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtD] + - input: + bytes: [0x53, 0xf4, 0x04, 0x5a] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "fsqrt.d fs0, fs1" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: fs0 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: fs1 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtD] + - input: + bytes: [0x53, 0x85, 0xc5, 0x2a] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "fmin.d fa0, fa1, fa2" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: fa0 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: fa1 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: fa2 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtD] + - input: + bytes: [0x53, 0x2e, 0xde, 0xa3] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV32, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "feq.d t3, ft8, ft9" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: t3 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: ft8 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: ft9 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtD] + - input: + bytes: [0x13, 0x04, 0xa8, 0x7a] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV64, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "addi s0, a6, 0x7aa" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: s0 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: a6 + access: CS_AC_READ + - type: RISCV_OP_IMM + imm: 0x7aa + access: CS_AC_READ + - input: + bytes: [0xbb, 0x07, 0x9c, 0x02] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV64, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "mulw a5, s8, s1" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a5 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: s8 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: s1 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtMOrZmmul, RISCV_FEATURE_IsRV64] + - input: + bytes: [0xbb, 0x40, 0x5d, 0x02] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV64, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "divw ra, s10, t0" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: ra + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: s10 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: t0 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtM, RISCV_FEATURE_IsRV64] + - input: + bytes: [0x3b, 0x63, 0xb7, 0x03] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV64, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "remw t1, a4, s11" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: t1 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: a4 + access: CS_AC_READ + - type: RISCV_OP_REG + reg: s11 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtM, RISCV_FEATURE_IsRV64] + - input: + bytes: [0x2f, 0xb4, 0x02, 0x10] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV64, CS_OPT_DETAIL, CS_MODE_RISCV_A] + address: 0x0 + expected: + insns: + - asm_text: "lr.d s0, (t0)" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: s0 + access: CS_AC_WRITE + - type: RISCV_OP_MEM + mem_base: t0 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtA, RISCV_FEATURE_IsRV64] + - input: + bytes: [0xaf, 0x33, 0x65, 0x18] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV64, CS_OPT_DETAIL, CS_MODE_RISCV_A] + address: 0x0 + expected: + insns: + - asm_text: "sc.d t2, t1, (a0)" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: t2 + access: CS_AC_WRITE + - type: RISCV_OP_MEM + mem_base: a0 + access: CS_AC_READ_WRITE + - type: RISCV_OP_REG + reg: t1 + access: CS_AC_READ + + groups: [RISCV_FEATURE_HasStdExtA, RISCV_FEATURE_IsRV64] + - input: + bytes: [0x2f, 0x37, 0x2f, 0x01] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV64, CS_OPT_DETAIL, CS_MODE_RISCV_A] + address: 0x0 + expected: + insns: + - asm_text: "amoadd.d a4, s2, (t5)" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a4 + access: CS_AC_WRITE + - type: RISCV_OP_MEM + mem_base: t5 + access: CS_AC_READ_WRITE + - type: RISCV_OP_REG + reg: s2 + access: CS_AC_READ + + groups: [RISCV_FEATURE_HasStdExtA, RISCV_FEATURE_IsRV64] + - input: + bytes: [0x53, 0x75, 0x20, 0xc0] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV64, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "fcvt.l.s a0, ft0" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a0 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: ft0 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtF, RISCV_FEATURE_IsRV64] + - input: + bytes: [0xd3, 0xf0, 0x25, 0xd0] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV64, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "fcvt.s.l ft1, a1" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: ft1 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: a1 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtF, RISCV_FEATURE_IsRV64] + - input: + bytes: [0xd3, 0x84, 0x05, 0xf2] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV64, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "fmv.d.x fs1, a1" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: fs1 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: a1 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtD, RISCV_FEATURE_IsRV64] + - input: + bytes: [0x53, 0x06, 0x05, 0xe2] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV64, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "fmv.x.d a2, fa0" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a2 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: fa0 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtD, RISCV_FEATURE_IsRV64] + - input: + bytes: [0x53, 0x75, 0x00, 0xc2] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV64, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "fcvt.w.d a0, ft0" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a0 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: ft0 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtD] + - input: + bytes: [0xd3, 0x80, 0x05, 0xd2] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV64, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "fcvt.d.w ft1, a1" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: ft1 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: a1 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtD] + - input: + bytes: [0xd3, 0x15, 0x08, 0xe2] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV64, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "fclass.d a1, fa6" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a1 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: fa6 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtD] + - input: + bytes: [0x87, 0xba, 0x75, 0x00] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV64, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "fld fs5, 7(a1)" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: fs5 + access: CS_AC_WRITE + - type: RISCV_OP_MEM + mem_base: a1 + mem_disp: 0x7 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtD] + - input: + bytes: [0x27, 0x37, 0x66, 0x01] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCV64, CS_OPT_DETAIL] + address: 0x0 + expected: + insns: + - asm_text: "fsd fs6, 0xe(a2)" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: fs6 + access: CS_AC_READ + - type: RISCV_OP_MEM + mem_base: a2 + mem_disp: 0xe + access: CS_AC_WRITE + groups: [RISCV_FEATURE_HasStdExtD] + - input: + bytes: [0xe8, 0x1f] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCVC, CS_OPT_DETAIL, CS_OPT_SYNTAX_NO_ALIAS_TEXT] + address: 0x0 + expected: + insns: + - asm_text: "c.addi4spn a0, sp, 0x3fc" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a0 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: sp + access: CS_AC_READ + - type: RISCV_OP_IMM + imm: 0x3fc + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtCOrZca] + - input: + bytes: [0x7d, 0x61] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCVC, CS_OPT_DETAIL, CS_OPT_SYNTAX_NO_ALIAS_TEXT] + address: 0x0 + expected: + insns: + - asm_text: "c.addi16sp sp, 0x1f0" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: sp + access: CS_AC_READ_WRITE + - type: RISCV_OP_IMM + imm: 0x1f0 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtCOrZca] + - input: + bytes: [0x80, 0x25] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCVC, CS_OPT_DETAIL, CS_OPT_SYNTAX_NO_ALIAS_TEXT] + address: 0x0 + expected: + insns: + - asm_text: "c.fld fs0, 8(a1)" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: fs0 + access: CS_AC_WRITE + - type: RISCV_OP_MEM + mem_base: a1 + mem_disp: 0x8 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtCOrZcd, RISCV_FEATURE_HasStdExtD] + - input: + bytes: [0x00, 0x46] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCVC, CS_OPT_DETAIL, CS_OPT_SYNTAX_NO_ALIAS_TEXT] + address: 0x0 + expected: + insns: + - asm_text: "c.lw s0, 8(a2)" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: s0 + access: CS_AC_WRITE + - type: RISCV_OP_MEM + mem_base: a2 + mem_disp: 0x8 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtCOrZca] + - input: + bytes: [0x88, 0xa2] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCVC, CS_OPT_DETAIL, CS_OPT_SYNTAX_NO_ALIAS_TEXT] + address: 0x0 + expected: + insns: + - asm_text: "c.fsd fa0, 0(a3)" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: fa0 + access: CS_AC_READ + - type: RISCV_OP_MEM + mem_base: a3 + access: CS_AC_WRITE + groups: [RISCV_FEATURE_HasStdExtCOrZcd, RISCV_FEATURE_HasStdExtD] + - input: + bytes: [0x04, 0xcb] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCVC, CS_OPT_DETAIL, CS_OPT_SYNTAX_NO_ALIAS_TEXT] + address: 0x0 + expected: + insns: + - asm_text: "c.sw s1, 0x10(a4)" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: s1 + access: CS_AC_READ + - type: RISCV_OP_MEM + mem_base: a4 + mem_disp: 0x10 + access: CS_AC_WRITE + groups: [RISCV_FEATURE_HasStdExtCOrZca] + - input: + bytes: [0x55, 0x13] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCVC, CS_OPT_DETAIL, CS_OPT_SYNTAX_NO_ALIAS_TEXT] + address: 0x0 + expected: + insns: + - asm_text: "c.addi t1, -0xb" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: t1 + access: CS_AC_READ_WRITE + - type: RISCV_OP_IMM + imm: -0xb + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtCOrZca] + - input: + bytes: [0xf2, 0x93] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCVC, CS_OPT_DETAIL, CS_OPT_SYNTAX_NO_ALIAS_TEXT] + address: 0x0 + expected: + insns: + - asm_text: "c.add t2, t3" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: t2 + access: CS_AC_READ_WRITE + - type: RISCV_OP_REG + reg: t3 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtCOrZca] + - input: + bytes: [0x5d, 0x45] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCVC, CS_OPT_DETAIL, CS_OPT_SYNTAX_NO_ALIAS_TEXT] + address: 0x0 + expected: + insns: + - asm_text: "c.li a0, 0x17" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a0 + access: CS_AC_WRITE + - type: RISCV_OP_IMM + imm: 0x17 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtCOrZca] + - input: + bytes: [0x19, 0x80] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCVC, CS_OPT_DETAIL, CS_OPT_SYNTAX_NO_ALIAS_TEXT] + address: 0x0 + expected: + insns: + - asm_text: "c.srli s0, 6" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: s0 + access: CS_AC_READ_WRITE + - type: RISCV_OP_IMM + imm: 0x6 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtCOrZca] + - input: + bytes: [0x15, 0x68] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCVC, CS_OPT_DETAIL, CS_OPT_SYNTAX_NO_ALIAS_TEXT] + address: 0x0 + expected: + insns: + - asm_text: "c.lui a6, 5" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a6 + access: CS_AC_WRITE + - type: RISCV_OP_IMM + imm: 0x5 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtCOrZca] + - input: + bytes: [0x2a, 0xa4] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCVC, CS_OPT_DETAIL, CS_OPT_SYNTAX_NO_ALIAS_TEXT] + address: 0x0 + expected: + insns: + - asm_text: "c.fsdsp fa0, 8(sp)" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: fa0 + access: CS_AC_READ + - type: RISCV_OP_MEM + mem_base: sp + mem_disp: 0x8 + access: CS_AC_WRITE + groups: [RISCV_FEATURE_HasStdExtCOrZcd, RISCV_FEATURE_HasStdExtD] + - input: + bytes: [0x62, 0x24] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCVC, CS_OPT_DETAIL, CS_OPT_SYNTAX_NO_ALIAS_TEXT] + address: 0x0 + expected: + insns: + - asm_text: "c.fldsp fs0, 0x18(sp)" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: fs0 + access: CS_AC_WRITE + - type: RISCV_OP_MEM + mem_base: sp + mem_disp: 0x18 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtCOrZcd, RISCV_FEATURE_HasStdExtD] + - input: + bytes: [0xa6, 0xff] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCVC, CS_OPT_DETAIL, CS_OPT_SYNTAX_NO_ALIAS_TEXT] + address: 0x0 + expected: + insns: + - asm_text: "c.fswsp fs1, 0xfc(sp)" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: fs1 + access: CS_AC_READ + - type: RISCV_OP_MEM + mem_base: sp + mem_disp: 0xfc + access: CS_AC_WRITE + + groups: + [ + RISCV_FEATURE_HasStdExtCOrZcfOrZce, + RISCV_FEATURE_HasStdExtF, + RISCV_FEATURE_IsRV32, + ] + - input: + bytes: [0x2a, 0x65] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCVC, CS_OPT_DETAIL, CS_OPT_SYNTAX_NO_ALIAS_TEXT] + address: 0x0 + expected: + insns: + - asm_text: "c.flwsp fa0, 0x88(sp)" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: fa0 + access: CS_AC_WRITE + - type: RISCV_OP_MEM + mem_base: sp + mem_disp: 0x88 + access: CS_AC_READ + + groups: + [ + RISCV_FEATURE_HasStdExtCOrZcfOrZce, + RISCV_FEATURE_HasStdExtF, + RISCV_FEATURE_IsRV32, + ] + - input: + bytes: [0x76, 0x86] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCVC, CS_OPT_DETAIL, CS_OPT_SYNTAX_NO_ALIAS_TEXT] + address: 0x0 + expected: + insns: + - asm_text: "c.mv a2, t4" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a2 + access: CS_AC_WRITE + - type: RISCV_OP_REG + reg: t4 + access: CS_AC_READ + groups: [RISCV_FEATURE_HasStdExtCOrZca] + - input: + bytes: [0x65, 0xdd] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCVC, CS_OPT_DETAIL, CS_OPT_SYNTAX_NO_ALIAS_TEXT] + address: 0x0 + expected: + insns: + - asm_text: "c.beqz a0, -8" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: a0 + access: CS_AC_READ + - type: RISCV_OP_IMM + imm: -0x8 + access: CS_AC_READ + groups: + [ + RISCV_GRP_JUMP, + RISCV_GRP_BRANCH_RELATIVE, + RISCV_FEATURE_HasStdExtCOrZca, + ] + - input: + bytes: [0x01, 0x00] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCVC, CS_OPT_DETAIL, CS_OPT_SYNTAX_NO_ALIAS_TEXT] + address: 0x0 + expected: + insns: + - asm_text: "c.nop" + details: + groups: [RISCV_FEATURE_HasStdExtCOrZca] + - input: + bytes: [0xfd, 0xaf] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCVC, CS_OPT_DETAIL, CS_OPT_SYNTAX_NO_ALIAS_TEXT] + address: 0x0 + expected: + insns: + - asm_text: "c.j 0x7fe" + details: + riscv: + operands: + - type: RISCV_OP_IMM + imm: 0x7fe + access: CS_AC_READ + groups: + [ + RISCV_GRP_JUMP, + RISCV_GRP_BRANCH_RELATIVE, + RISCV_FEATURE_HasStdExtCOrZca, + ] + - input: + bytes: [0x82, 0x82] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCVC, CS_OPT_DETAIL, CS_OPT_SYNTAX_NO_ALIAS_TEXT] + address: 0x0 + expected: + insns: + - asm_text: "c.jr t0" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: t0 + access: CS_AC_READ + groups: [RISCV_GRP_JUMP, RISCV_FEATURE_HasStdExtCOrZca] + - input: + bytes: [0x11, 0x20] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCVC, CS_OPT_DETAIL, CS_OPT_SYNTAX_NO_ALIAS_TEXT] + address: 0x0 + expected: + insns: + - asm_text: "c.jal 4" + details: + riscv: + operands: + - type: RISCV_OP_IMM + imm: 0x4 + access: CS_AC_READ + groups: + [ + RISCV_GRP_CALL, + RISCV_GRP_BRANCH_RELATIVE, + RISCV_FEATURE_HasStdExtCOrZca, + RISCV_FEATURE_IsRV32, + ] + - input: + bytes: [0x82, 0x94] + arch: "CS_ARCH_RISCV" + options: [CS_MODE_RISCVC, CS_OPT_DETAIL, CS_OPT_SYNTAX_NO_ALIAS_TEXT] + address: 0x0 + expected: + insns: + - asm_text: "c.jalr s1" + details: + riscv: + operands: + - type: RISCV_OP_REG + reg: s1 + access: CS_AC_READ + groups: [RISCV_GRP_CALL, RISCV_FEATURE_HasStdExtCOrZca] diff --git a/tests/issues/issues.yaml b/tests/issues/issues.yaml index 09ea5163fe..28e3dbcada 100644 --- a/tests/issues/issues.yaml +++ b/tests/issues/issues.yaml @@ -89,7 +89,7 @@ test_cases: - type: RISCV_OP_IMM imm: 0x8 - groups: [ branch_relative, jump ] + groups: [ jump, branch_relative ] - input: name: "issue 2007 RISCV64 instruction groups" @@ -120,7 +120,7 @@ test_cases: - type: RISCV_OP_IMM imm: 0x4 - groups: [ call ] + groups: [ call, branch_relative ] - input: name: "issue 2007 RISCV32 instruction groups" @@ -141,7 +141,7 @@ test_cases: - type: RISCV_OP_IMM imm: 0x8 - groups: [ branch_relative, jump ] + groups: [ jump, branch_relative ] - input: name: "issue 2007 RISCV32 instruction groups" @@ -172,13 +172,13 @@ test_cases: - type: RISCV_OP_IMM imm: 0x4 - groups: [ call ] + groups: [ call, branch_relative ] - input: name: "issue 2007 RISCV32 instruction groups" bytes: [ 0x11,0x20 ] arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_MODE_RISCVC, CS_OPT_DETAIL ] + options: [ CS_MODE_RISCV32, CS_MODE_RISCVC, CS_OPT_DETAIL, CS_OPT_SYNTAX_NO_ALIAS_TEXT ] address: 0x0 expected: insns: @@ -190,13 +190,13 @@ test_cases: - type: RISCV_OP_IMM imm: 0x4 - groups: [ hasStdExtC, isrv32, call ] + groups: [ call, branch_relative, HasStdExtCOrZca, IsRV32 ] - input: name: "issue 2007 RISCV32 instruction groups" bytes: [ 0x91,0xc1 ] arch: "CS_ARCH_RISCV" - options: [ CS_MODE_RISCV32, CS_MODE_RISCVC, CS_OPT_DETAIL ] + options: [ CS_MODE_RISCV32, CS_MODE_RISCVC, CS_OPT_DETAIL, CS_OPT_SYNTAX_NO_ALIAS_TEXT ] address: 0x0 expected: insns: @@ -211,7 +211,7 @@ test_cases: - type: RISCV_OP_IMM imm: 0x4 - groups: [ hasStdExtC, branch_relative, jump ] + groups: [ jump, branch_relative, HasStdExtCOrZca ] - input: name: "issue 1997 notrack jmp" @@ -5662,7 +5662,7 @@ test_cases: name: "RISCV - #2632 - Memory operand type was 3 instead of 0x80" bytes: [ 0x0c, 0xc2 ] arch: "CS_ARCH_RISCV" - options: [ CS_OPT_DETAIL, CS_MODE_RISCV32, CS_MODE_RISCVC ] + options: [ CS_OPT_DETAIL, CS_MODE_RISCV32, CS_MODE_RISCVC, CS_OPT_SYNTAX_NO_ALIAS_TEXT ] address: 0x0 expected: insns: @@ -6257,7 +6257,7 @@ test_cases: name: "issue #2731 - Should disassemble" bytes: [ 0x15, 0x83 ] arch: "CS_ARCH_RISCV" - options: [ CS_MODE_LITTLE_ENDIAN, CS_MODE_32 ] + options: [ CS_MODE_LITTLE_ENDIAN, CS_MODE_32, CS_OPT_SYNTAX_NO_ALIAS_TEXT ] address: 0x0 expected: insns: